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 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);
}
void HSSLog::fire()
{
switch (this->dValue->getType()) {
case HSSParserNodeTypeFunctionCall:
{
HSSFunction::p fnct = boost::static_pointer_cast<HSSFunction>(this->dValue);
if(fnct->isA(HSSFunctionTypeRef)){
HSSRefFunction::p refFnct = boost::static_pointer_cast<HSSRefFunction>(fnct);
refFnct->setScope(this->scope);
void * data = refFnct->evaluate();
switch (refFnct->getPropertyName()) {
case HSSObservablePropertyWidth:
case HSSObservablePropertyHeight:
case HSSObservablePropertyAnchorX:
case HSSObservablePropertyAnchorY:
case HSSObservablePropertyAlignX:
case HSSObservablePropertyAlignY:
case HSSObservablePropertyContentAlignX:
case HSSObservablePropertyContentAlignY:
case HSSObservablePropertyStartX:
case HSSObservablePropertyStartY:
case HSSObservablePropertyEndX:
case HSSObservablePropertyEndY:
case HSSObservablePropertyPosition:
case HSSObservablePropertyRed:
case HSSObservablePropertyGreen:
case HSSObservablePropertyBlue:
case HSSObservablePropertyAlpha:
case HSSObservablePropertySize:
case HSSObservablePropertyCorners:
{
std_log(*(long double*)data);
break;
}
case HSSObservablePropertyMargin:
case HSSObservablePropertyPadding:
case HSSObservablePropertyShape:
case HSSObservablePropertyStartColor:
case HSSObservablePropertyEndColor:
case HSSObservablePropertyColorStops:
case HSSObservablePropertyBalance:
case HSSObservablePropertyFace:
case HSSObservablePropertyColor:
case HSSObservablePropertyAction:
{
std_log((*(HSSObject::p *)data)->toString());
break;
}
case HSSObservablePropertyBackground:
case HSSObservablePropertyBorder:
case HSSObservablePropertyFont:
{
std::vector<HSSObject::p> v_data = *(std::vector<HSSObject::p>*)data;
std::vector<HSSObject::p>::iterator it;
if (v_data.size() == 0) {
std_log("empty");
} else {
for (it=v_data.begin(); it!=v_data.end(); it++) {
std_log((*it)->toString());
}
}
break;
}
case HSSObservablePropertyOn:
{
boost::unordered_map<HSSEventType, std::vector<HSSObject::p> > m_data = *(boost::unordered_map<HSSEventType, std::vector<HSSObject::p> >*)data;
boost::unordered_map<HSSEventType, std::vector<HSSObject::p> >::iterator it;
if (m_data.size() == 0) {
std_log("empty");
} else {
for (it=m_data.begin(); it!=m_data.end(); it++) {
std::vector<HSSObject::p> v_data = (*it).second;
std::vector<HSSObject::p>::iterator it2;
for (it2=v_data.begin(); it2!=v_data.end(); it2++) {
std_log((*it2)->toString());
}
}
}
break;
}
case HSSObservablePropertyDirectionPrimary:
case HSSObservablePropertyDirectionSecondary:
case HSSObservablePropertyTransform:
case HSSObservablePropertyTextAlign:
case HSSObservablePropertyWeight:
case HSSObservablePropertySrc:
case HSSObservablePropertyMode:
case HSSObservablePropertyContentTarget:
{
std_log(*(std::string*)data);
break;
}
case HSSObservablePropertyFlagChanged:
case HSSObservablePropertyText:
case HSSObservablePropertyTarget:
default:
{
std_log("logging this property is not supported");
break;
}
}
}
break;
}
case HSSParserNodeTypeStringConstant:
{
HSSStringConstant::p str = boost::static_pointer_cast<HSSStringConstant>(this->dValue);
std_log(str->getValue());
break;
}
default:
{
std_log(this->dValue->toString());
break;
}
}
}