void HSSFlagAction::fire()
{
HSSFlagFunction::p flagFunction = this->getFlagFunction();
HSSSelection::p selection = this->getController()->select(flagFunction->getSelectorChains(), this->scope, this->getThisObj(), false);
HSSSimpleSelection::p inner = selection->joinAll();
for (HSSSimpleSelection::iterator innerIt = inner->begin(); innerIt != inner->end(); ++innerIt)
{
HSSDisplayObject::p container = *innerIt;
switch (flagFunction->getFlagFunctionType())
{
case HSSFlagFunctionTypeFlag:
container->flagsActivate(flagFunction->getName());
break;
case HSSFlagFunctionTypeUnflag:
container->flagsDeactivate(flagFunction->getName());
break;
case HSSFlagFunctionTypeToggleFlag:
container->flagsToggle(flagFunction->getName());
break;
default:
throw AXRWarning("HSSFlagAction", "Invalid flag function type for flag action");
break;
}
}
}
QVariant HSSRefFunction::_evaluate()
{
HSSSimpleSelection::p selection = this->getController()->select(this->selectorChains, this->scope, this->getThisObj(), false)->joinAll();
if (selection->empty())
{
// ignore
}
else if (selection->size() == 1)
{
HSSDisplayObject::p container = selection->front();
this->_value = container->getProperty(this->propertyName);
container->observe(this->propertyName, HSSObservablePropertyValue, this, new HSSValueChangedCallback<HSSRefFunction > (this, &HSSRefFunction::valueChanged));
this->observed = container.data();
}
else
{
/*
if (this->modifier == "min"){
unsigned i, size;
HSSUnit tempval;
HSSDisplayObject::p container;
for (i=0, size = selection.size(); i<size; ++i) {
tempval = *(HSSUnit*)selection[i]->getProperty(this->propertyName);
if (tempval < *(HSSUnit*)this->_value){
this->_value = &tempval;
container = selection[i];
}
}
this->_value = container->getProperty(this->propertyName);
container->observe(this->propertyName, HSSObservablePropertyValue, this, new HSSValueChangedCallback<HSSRefFunction>(this, &HSSRefFunction::valueChanged));
} else if (this->modifier == "max"){
} else if (this->modifier == "avg"){
}
*/
throw AXRError("HSSRefFunciton", "Using modifiers in ref functions is not implemented yet");
}
return this->_value;
}
void AXRController::add(HSSDisplayObject::p newElement)
{
newElement->setController(this);
if(!this->root){
HSSContainer::p cont = HSSContainer::asContainer(newElement);
if (cont){
this->setRoot(cont);
} else {
std_log1("############## HSSController: cannot add non-controller as root");
}
} else {
if(this->currentContext.size() != 0){
HSSContainer::p theCurrent = this->currentContext.top();
theCurrent->add(newElement);
} else {
std_log1("############## HSSController: tried to add a container to nonexistent current");
}
}
}
bool AXRController::loadFile(std::string xmlfilepath, std::string xmlfilename)
{
//we assume success unless noted otherwise
bool loadingSuccess = true;
std::string hssfilepath = std::string();
std::string hssfolder = std::string();
std::string hssfilename = std::string();
unsigned i, j;
if(this->_hasLoadedFile){
//prepare itself for loading a new file
this->reset();
}
//the xml parser will call the enterElement, addAttribute and exitElement functions to construct the initial tree
if(!this->loadXMLFile(xmlfilepath, xmlfilename)){
//FIXME: handle the error
std_log1("could not load the xml file");
loadingSuccess = false;
} else {
//needs reset on next load
this->_hasLoadedFile = true;
//load the obtained stylesheets
if(this->loadSheets.size() == 0){
throw AXRNoStylesheetsException(xmlfilepath);
//FIXME: test this to better understand exceptions
std_log1("this comes after the exception, it get's executed");
} else {
for (i=0; i<this->loadSheets.size(); i++) {
hssfilename = this->loadSheets[i];
if(hssfilename.substr(0,1) == "/"){
//FIXME: add support for absolute paths
} else {
//FIXME: why is doing exactly the opposite of what I expect? that's why I put the ! in there
// size_t hasFolder = hssfilename.rfind("/", hssfilename.size());
// if(hasFolder != -1){
// //construct the new path
// hssfolder = hssfilename.substr(0, hssfilename.rfind("/", hssfilename.length()));
// std_log1("has folder: ");std_log1(hssfolder);
// } else {
hssfolder = xmlfilepath.substr(0, xmlfilepath.rfind("/", xmlfilepath.length())+1);
hssfilepath = hssfolder.append(hssfilename);
// std_log1("no folder: ");std_log1(hssfilepath);
// }
if(! this->loadHSSFile(hssfilepath, hssfilename.substr(hssfilename.rfind("/", hssfilename.length())+1))){
//FIXME: handle the error
loadingSuccess = false;
std_log1("error loading hss file");
} else {
//assign the rules to the objects
HSSDisplayObject::p rootObj = boost::static_pointer_cast<HSSDisplayObject>(this->root);
for (j=0; j<this->rules.size(); j++) {
HSSRule::p& rule = this->rules[j];
const HSSDisplayObject::p rootScopeArr[1] = {root};
const std::vector<HSSDisplayObject::p>rootScope(rootScopeArr, rootScopeArr+1);
this->recursiveMatchRulesToDisplayObjects(rule, rootScope);
}
//read the rules into values
rootObj->recursiveReadDefinitionObjects();
}
}
}
}
}
return loadingSuccess;
}
void AXRController::recursiveMatchRulesToDisplayObjects(const HSSRule::p & rule, const std::vector<HSSDisplayObject::p> & scope, HSSContainer::p container, bool applyingInstructions)
{
HSSInstruction::p instruction = rule->getInstruction();
if (instruction && applyingInstructions) {
switch (instruction->getInstructionType()) {
case HSSNewInstruction:
{
std::string elementName = rule->getSelectorChain()->subject()->getElementName();
unsigned i;
unsigned argssize = 1;
HSSParserNode::p argument = instruction->getArgument();
if(argument){
if (argument->isA(HSSParserNodeTypeNumberConstant)) {
HSSNumberConstant::p argnum = boost::static_pointer_cast<HSSNumberConstant>(argument);
argssize = (int)argnum->getValue();
}
}
for (i=0; i<argssize; i++) {
HSSContainer::p newContainer = HSSContainer::p(new HSSContainer());
newContainer->setName(elementName);
newContainer->setElementName(elementName);;
this->add(newContainer);
rule->setThisObj(newContainer);
newContainer->rulesAdd(rule, (rule->getActiveByDefault() ? HSSRuleStateOn : HSSRuleStateOff ));
std_log1("created "+newContainer->getElementName());
newContainer->setNeedsRereadRules(true);
newContainer->setNeedsSurface(true);
newContainer->setDirty(true);
unsigned i, size;
this->currentContext.push(newContainer);
for (i=0, size=rule->childrenSize(); i<size; i++) {
const HSSRule::p childRule = rule->childrenGet(i);
this->recursiveMatchRulesToDisplayObjects(childRule, newContainer->getChildren(), newContainer, applyingInstructions);
}
newContainer->setNeedsRereadRules(true);
//newContainer->fireEvent(HSSEventTypeLoad);
this->currentContext.pop();
}
break;
}
case HSSMoveInstruction:
{
HSSContainer::p parent = container->getParent();
if (parent) {
std::vector<HSSDisplayObject::p> moveScope = parent->getChildren();
this->setSelectorChain(rule->getSelectorChain());
std::vector< std::vector<HSSDisplayObject::p> > selection = this->selectHierarchical(moveScope, container);
unsigned i, j, k, size, size2, size3;
this->currentContext.push(container);
//move the children over
for (i=0, size=selection.size(); i<size; i++) {
std::vector<HSSDisplayObject::p> inner = selection[i];
for (j=0, size2=inner.size(); j<size2; j++) {
HSSDisplayObject::p theDO = inner[j];
if(theDO != container){
theDO->removeFromParent();
this->add(theDO);
rule->setThisObj(theDO);
std_log1("moved "+theDO->getElementName());
theDO->rulesAdd(rule, (rule->getActiveByDefault() ? HSSRuleStateOn : HSSRuleStateOff ));
theDO->setNeedsRereadRules(true);
theDO->setNeedsSurface(true);
theDO->setDirty(true);
if(theDO->isA(HSSObjectTypeContainer)){
HSSContainer::p theContainer = boost::static_pointer_cast<HSSContainer>(theDO);
this->currentContext.push(theContainer);
//assign more rules
for (k=0, size3=rule->childrenSize(); k<size3; k++) {
const HSSRule::p childRule = rule->childrenGet(k);
this->recursiveMatchRulesToDisplayObjects(childRule, theContainer->getChildren(), theContainer, applyingInstructions);
}
this->currentContext.pop();
}
theDO->setNeedsRereadRules(true);
//theDO->fireEvent(HSSEventTypeLoad);
}
}
}
this->currentContext.pop();
}
break;
}
case HSSDeleteInstruction:
{
//select the items to be deleted
this->setSelectorChain(rule->getSelectorChain());
std::vector< std::vector<HSSDisplayObject::p> > selection = this->selectHierarchical(scope, container);
unsigned i, j, size, size2;
for (i=0, size=selection.size(); i<size; i++) {
std::vector<HSSDisplayObject::p> inner = selection[i];
for (j=0, size2=inner.size(); j<size2; j++) {
inner[j]->removeFromParent();
}
}
break;
}
default:
break;
}
} else {
HSSSelectorChain::p selectorChain = rule->getSelectorChain();
if(selectorChain){
this->setSelectorChain(selectorChain);
//if it starts with a combinator, adjust the scope and selector chain
bool useAdjustedScope = false;
std::vector<HSSDisplayObject::p> adjustedScope;
if(this->currentSelectorNode->isA(HSSParserNodeTypeCombinator)){
useAdjustedScope = true;
adjustedScope.push_back(container);
this->currentChain->prepend(HSSSelector::p(new HSSSelector(container->getElementName())));
this->currentChainSize ++;
this->currentSelectorNode = this->currentChain->get(0);
}
//we observe the parent for dom changes
container->observe(HSSObservablePropertyTreeChange, HSSObservablePropertyValue, rule.get(), new HSSValueChangedCallback<HSSRule>(rule.get(), &HSSRule::treeChanged));
rule->setObservedTreeChanger(container.get());
rule->setThisObj(container);
rule->setOriginalScope(scope);
std::vector< std::vector<HSSDisplayObject::p> > selection = this->selectHierarchical((useAdjustedScope ? adjustedScope : scope), container);
unsigned i, j, k, size, size2, size3;
for (i=0, size=selection.size(); i<size; i++) {
std::vector<HSSDisplayObject::p> inner = selection[i];
for (j=0, size2=inner.size(); j<size2; j++) {
const HSSDisplayObject::p & displayObject = inner[j];
std_log1("match "+displayObject->getElementName());
displayObject->rulesAdd(rule, (rule->getActiveByDefault() ? HSSRuleStateOn : HSSRuleStateOff ));
displayObject->setNeedsRereadRules(true);
displayObject->setNeedsSurface(true);
displayObject->setDirty(true);
//if it is a container it may have children
if(displayObject->isA(HSSObjectTypeContainer)){
HSSContainer::p selectedContainer = boost::static_pointer_cast<HSSContainer>(displayObject);
this->currentContext.push(selectedContainer);
for (k=0, size3=rule->childrenSize(); k<size3; k++) {
const HSSRule::p childRule = rule->childrenGet(k);
this->recursiveMatchRulesToDisplayObjects(childRule, selectedContainer->getChildren(), selectedContainer, applyingInstructions);
}
this->currentContext.pop();
}
displayObject->setNeedsRereadRules(true);
}
}
}
}
}