void HSSRequest::setDTarget(HSSParserNode::p value)
{
switch (value->getType())
{
case HSSParserNodeTypeKeywordConstant:
case HSSParserNodeTypeFunctionCall:
{
this->dTarget = value;
if (this->observedTarget)
{
this->observedTarget->removeObserver(this->observedTargetProperty, HSSObservablePropertyTarget, this);
}
switch (value->getType())
{
case HSSParserNodeTypeKeywordConstant:
/**
* @todo what here?
*/
break;
case HSSParserNodeTypeFunctionCall:
{
HSSFunction::p fnct = qSharedPointerCast<HSSFunction > (value)->clone();
if (fnct)
{
fnct->setScope(this->scope);
fnct->setThisObj(this->getThisObj());
QVariant remoteValue = fnct->evaluate();
if (remoteValue.canConvert< HSSSelection::p >())
{
HSSSimpleSelection::p selection = remoteValue.value< HSSSelection::p >()->joinAll();
this->target->clear();
this->target->insert(this->target->end(), selection->begin(), selection->end());
}
/**
* @todo potentially leaking
*/
fnct->observe(HSSObservablePropertyValue, HSSObservablePropertyTarget, this, new HSSValueChangedCallback<HSSRequest > (this, &HSSRequest::targetChanged));
this->observedTarget = fnct.data();
this->observedTargetProperty = HSSObservablePropertyValue;
}
break;
}
default:
break;
}
this->notifyObservers(HSSObservablePropertySrc, &this->src);
break;
}
default:
throw AXRWarning("HSSRequest", "Invalid value for src of " + this->name);
}
}
void HSSRequest::setDSrc(HSSParserNode::p value)
{
switch (value->getType())
{
case HSSParserNodeTypeKeywordConstant:
case HSSParserNodeTypeFunctionCall:
case HSSParserNodeTypeStringConstant:
{
this->dSrc = value;
if (this->observedSrc)
{
this->observedSrc->removeObserver(this->observedSrcProperty, HSSObservablePropertySrc, this);
}
switch (value->getType())
{
case HSSParserNodeTypeKeywordConstant:
/**
* @todo what here?
*/
break;
case HSSParserNodeTypeStringConstant:
{
HSSStringConstant::p theString = qSharedPointerCast<HSSStringConstant > (value);
this->src = QUrl(theString->getValue());
break;
}
case HSSParserNodeTypeFunctionCall:
{
HSSFunction::p fnct = qSharedPointerCast<HSSFunction > (value)->clone();
fnct->setScope(this->scope);
fnct->setThisObj(this->getThisObj());
QVariant remoteValue = fnct->evaluate();
if (remoteValue.canConvert<AXRString>())
{
this->src = QUrl(remoteValue.value<AXRString>());
}
break;
}
default:
break;
}
this->notifyObservers(HSSObservablePropertySrc, &this->src);
break;
}
default:
throw AXRWarning("HSSRequest", "Invalid value for src of " + this->name);
}
}
HSSUnit HSSColorStop::_evaluatePropertyValue(
void(HSSColorStop::*callback)(HSSObservableProperty property, void* data),
HSSParserNode::p value,
HSSUnit percentageBase,
HSSObservableProperty observedSourceProperty,
HSSObservable * &observedStore,
HSSObservableProperty &observedStoreProperty
)
{
HSSUnit ret;
HSSParserNodeType nodeType = value->getType();
switch (nodeType)
{
case HSSParserNodeTypeNumberConstant:
{
HSSNumberConstant::p numberValue = qSharedPointerCast<HSSNumberConstant > (value);
ret = numberValue->getValue();
break;
}
case HSSParserNodeTypePercentageConstant:
{
HSSPercentageConstant::p percentageValue = qSharedPointerCast<HSSPercentageConstant > (value);
ret = percentageValue->getValue(percentageBase);
break;
}
case HSSParserNodeTypeExpression:
{
HSSExpression::p expressionValue = qSharedPointerCast<HSSExpression > (value);
expressionValue->setPercentageBase(percentageBase);
expressionValue->setScope(this->scope);
expressionValue->setThisObj(this->getThisObj());
ret = expressionValue->evaluate();
if (callback)
{
expressionValue->observe(HSSObservablePropertyValue, observedSourceProperty, this, new HSSValueChangedCallback<HSSColorStop > (this, callback));
}
break;
}
case HSSParserNodeTypeKeywordConstant:
break;
default:
AXRWarning("HSSColorStop", "Unknown parser node type while setting value for HSSLineGradient property").raise();
break;
}
return ret;
}
long double HSSRgb::_setLDProperty(
void(HSSRgb::*callback)(HSSObservableProperty property, void* data),
HSSParserNode::p value,
long double percentageBase,
HSSObservableProperty observedSourceProperty,
HSSObservable * &observedStore,
HSSObservableProperty &observedStoreProperty
)
{
long double ret;
HSSParserNodeType nodeType = value->getType();
switch (nodeType) {
case HSSParserNodeTypeNumberConstant:
{
HSSNumberConstant::p numberValue = boost::static_pointer_cast<HSSNumberConstant>(value);
ret = numberValue->getValue();
break;
}
case HSSParserNodeTypePercentageConstant:
{
HSSPercentageConstant::p percentageValue = boost::static_pointer_cast<HSSPercentageConstant>(value);
ret = percentageValue->getValue(percentageBase);
break;
}
case HSSParserNodeTypeExpression:
{
HSSExpression::p expressionValue = boost::static_pointer_cast<HSSExpression>(value);
expressionValue->setPercentageBase(percentageBase);
//expressionValue->setScope(scope);
ret = expressionValue->evaluate();
if(callback != NULL){
expressionValue->observe(HSSObservablePropertyValue, observedSourceProperty, this, new HSSValueChangedCallback<HSSRgb>(this, callback));
observedStore = expressionValue.get();
observedStoreProperty = HSSObservablePropertyValue;
}
break;
}
case HSSParserNodeTypeKeywordConstant:
break;
default:
throw AXRError::p(new AXRError("HSSRgb", "Unknown parser node type "+HSSParserNode::parserNodeStringRepresentation(nodeType)+" while setting value for HSSRgb property"));
break;
}
return ret;
}
void HSSColorStop::setDBalance(HSSParserNode::p value)
{
switch (value->getType())
{
case HSSParserNodeTypeNumberConstant:
case HSSParserNodeTypePercentageConstant:
case HSSParserNodeTypeExpression:
this->dBalance = value;
this->balance = this->_evaluatePropertyValue(
&HSSColorStop::balanceChanged,
value,
1.,
HSSObservablePropertyBalance,
this->observedBalance,
this->observedBalanceProperty
);
break;
case HSSParserNodeTypeFunctionCall:
{
this->dBalance = value;
HSSFunction::p fnct = qSharedPointerCast<HSSFunction > (value)->clone();
if (fnct && fnct->isA(HSSFunctionTypeRef))
{
fnct->setScope(this->scope);
fnct->setThisObj(this->getThisObj());
QVariant remoteValue = fnct->evaluate();
if (remoteValue.canConvert<HSSUnit>())
{
this->balance = remoteValue.value<HSSUnit>();
}
fnct->observe(HSSObservablePropertyValue, HSSObservablePropertyBalance, this, new HSSValueChangedCallback<HSSColorStop > (this, &HSSColorStop::balanceChanged));
}
else
{
throw AXRWarning("HSSDGradient", "Invalid function type for balance of " + this->name);
}
break;
}
default:
throw AXRWarning("HSSColorStop", "Invalid value for balance of " + this->name);
}
this->notifyObservers(HSSObservablePropertyBalance, &this->balance);
this->notifyObservers(HSSObservablePropertyValue, NULL);
}
void HSSFunction::setScope(HSSSimpleSelection::p newScope)
{
this->scope = newScope;
std::deque<HSSParserNode::p>::const_iterator it;
for (it = this->_arguments.begin(); it != this->_arguments.end(); ++it)
{
const HSSParserNode::p node = (*it);
switch (node->getType())
{
case HSSParserNodeTypeFunctionCall:
{
HSSFunction::p func = qSharedPointerCast<HSSFunction > (node);
func->setScope(newScope);
break;
}
case HSSParserNodeTypeExpression:
{
HSSExpression::p exp = qSharedPointerCast<HSSExpression > (node);
exp->setScope(newScope);
break;
}
default:
break;
}
switch (node->getStatementType())
{
case HSSStatementTypeObjectDefinition:
{
HSSObjectDefinition::p objdef = qSharedPointerCast<HSSObjectDefinition > (node);
objdef->setScope(newScope);
break;
}
default:
break;
}
}
}
long double HSSDisplayObject::_setLDProperty(
void(HSSDisplayObject::*callback)(HSSObservableProperty property, void* data),
HSSParserNode::p value,
long double percentageBase,
HSSObservableProperty observedProperty,
HSSObservable * observedObject,
HSSObservable * &observedStore,
HSSObservableProperty &observedStoreProperty,
const std::vector<HSSDisplayObject::p> * scope
)
{
long double ret;
HSSParserNodeType nodeType = value->getType();
switch (nodeType) {
case HSSParserNodeTypeNumberConstant:
{
HSSNumberConstant::p numberValue = boost::static_pointer_cast<HSSNumberConstant>(value);
ret = numberValue->getValue();
break;
}
case HSSParserNodeTypePercentageConstant:
{
HSSPercentageConstant::p percentageValue = boost::static_pointer_cast<HSSPercentageConstant>(value);
ret = percentageValue->getValue(percentageBase);
if(callback != NULL)
{
observedObject->observe(observedProperty, this, new HSSValueChangedCallback<HSSDisplayObject>(this, callback));
observedStore = observedObject;
observedStoreProperty = observedProperty;
}
break;
}
case HSSParserNodeTypeExpression:
{
HSSExpression::p expressionValue = boost::static_pointer_cast<HSSExpression>(value);
expressionValue->setPercentageBase(percentageBase);
expressionValue->setPercentageObserved(observedProperty, observedObject);
expressionValue->setScope(scope);
ret = expressionValue->evaluate();
if(callback != NULL){
expressionValue->observe(HSSObservablePropertyValue, this, new HSSValueChangedCallback<HSSDisplayObject>(this, callback));
observedStore = expressionValue.get();
observedStoreProperty = HSSObservablePropertyValue;
}
break;
}
case HSSParserNodeTypeKeywordConstant:
break;
default:
throw "unknown parser node type while setting dHeight";
break;
}
return ret;
}
void HSSColorStop::setDColor(HSSParserNode::p value)
{
bool valid = false;
switch (value->getType())
{
case HSSParserNodeTypeObjectNameConstant:
{
this->dColor = value;
try
{
HSSObjectNameConstant::p objname = qSharedPointerCast<HSSObjectNameConstant > (value);
HSSObjectDefinition::p objdef = this->getController()->objectTreeGet(objname->getValue());
this->setDColor(objdef);
valid = true;
}
catch (const AXRError &e)
{
e.raise();
}
break;
}
case HSSParserNodeTypeFunctionCall:
{
this->dColor = value;
HSSFunction::p fnct = qSharedPointerCast<HSSFunction > (value)->clone();
if (fnct && fnct->isA(HSSFunctionTypeRef))
{
fnct->setScope(this->scope);
fnct->setThisObj(this->getThisObj());
QVariant remoteValue = fnct->evaluate();
if (remoteValue.canConvert<HSSRgb::p>())
{
this->color = remoteValue.value<HSSRgb::p>();
valid = true;
}
fnct->observe(HSSObservablePropertyValue, HSSObservablePropertyColor, this, new HSSValueChangedCallback<HSSColorStop > (this, &HSSColorStop::colorChanged));
}
break;
}
case HSSParserNodeTypeKeywordConstant:
{
HSSKeywordConstant::p theKW = qSharedPointerCast<HSSKeywordConstant>(value);
AXRString kwValue = theKW->getValue();
if (kwValue == "black")
{
this->color = HSSRgb::blackColor(this->getController());
valid = true;
}
else if (kwValue == "white")
{
this->color = HSSRgb::whiteColor(this->getController());
valid = true;
}
else if (kwValue == "transparent")
{
//the color will remain empty for transparent
this->color.clear();
valid = true;
}
break;
}
default:
break;
}
switch (value->getStatementType())
{
case HSSStatementTypeObjectDefinition:
{
this->dColor = value;
HSSObjectDefinition::p objdef = qSharedPointerCast<HSSObjectDefinition > (value);
objdef->setScope(this->scope);
objdef->setThisObj(this->getThisObj());
objdef->apply();
HSSObject::p theobj = objdef->getObject();
if (theobj && theobj->isA(HSSObjectTypeRgb))
{
this->color = qSharedPointerCast<HSSRgb > (theobj);
valid = true;
}
break;
}
default:
break;
}
if (!valid)
throw AXRWarning("HSSColorStop", "Invalid value for color of " + this->name);
this->notifyObservers(HSSObservablePropertyColor, &this->color);
this->notifyObservers(HSSObservablePropertyValue, NULL);
}
