void AXRController::recursiveMatchRulesToDisplayObjects(HSSRule::p & rule, const std::vector<HSSDisplayObject::p> & scope) { this->currentChain = rule->selectorChain; this->currentChainSize = this->currentChain->size(); this->currentChainCount = 0; this->currentSelectorNode = this->currentChain->get(0); const std::vector<HSSDisplayObject::p> selection = this->selectHierarchical(scope); unsigned i, size, j, size2; for (i=0, size=selection.size(); i<size; i++) { const HSSDisplayObject::p & displayObject = selection[i]; std_log1("match "+displayObject->getElementName()); displayObject->rulesAdd(rule); displayObject->setNeedsRereadRules(true); displayObject->setNeedsSurface(true); displayObject->setDirty(true); //if it is a container it may have children if(displayObject->isA(HSSObjectTypeContainer)){ HSSContainer::p container = boost::static_pointer_cast<HSSContainer>(displayObject); for (j=0, size2=rule->childrenSize(); j<size2; j++) { HSSRule::p childRule = rule->childrenGet(j); this->recursiveMatchRulesToDisplayObjects(childRule, container->children); } } } // //look at the selector chain // HSSSelectorChain * selectorChain(rule->selectorChain.get()); // std::vector<HSSDisplayObject::p>tempSelection; // unsigned i, j, size; // // unsigned selectorCount = 0; // unsigned selectorSize = selectorChain->size(); // while (selectorCount < selectorSize) { // const HSSParserNode::p & selector = selectorChain->get(selectorCount++); // if(selectorChain->size() == 1){ // if(selector->isA(HSSParserNodeTypeSelector)){ // HSSSelector::p simpleSelector = boost::static_pointer_cast<HSSSelector>(selector); // //select items // for (i=0, size=scope.size(); i<size; i++) { // const HSSDisplayObject::p & displayObject = scope[i]; // // //does it match // if(simpleSelector->getElementName() == displayObject->getElementName()){ // std_log1("match "+displayObject->getElementName()); // displayObject->rulesAdd(rule); // displayObject->setNeedsRereadRules(true); // displayObject->setNeedsSurface(true); // displayObject->setDirty(true); // // //if it is a container it may have children // if(displayObject->isA(HSSObjectTypeContainer)){ // HSSContainer::p container = boost::static_pointer_cast<HSSContainer>(displayObject); // for (i=0; i<container->children.size(); i++) { //FIXME: container will have an accessor for chlidrenSize in the future // for (j=0; j<rule->childrenSize(); j++) { // HSSRule::p childRule = rule->childrenGet(j); // this->recursiveMatchRulesToDisplayObjects(childRule, container->children); // } // } // } // } // } // } // } else { // const HSSParserNode::p & selector2 = selectorChain->get(selectorCount++); // HSSParserNodeType selectorType = selector2->getType(); // switch (selectorType) { // case HSSParserNodeTypeCombinator: // { // HSSCombinator::p combinator = boost::static_pointer_cast<HSSCombinator>(selector2); // const HSSCombinatorType & combinatorType = combinator->getCombinatorType(); // switch (combinatorType) { // case HSSCombinatorTypeNextSiblings: // <#statements#> // break; // // default: // break; // } // break; // } // // default: // break; // } // } // } // // // // //select items // for (i=0, size=scope.size(); i<size; i++) { // const HSSDisplayObject::p & displayObject = scope[i]; // // // // //in case we're dealing with a displayObject which cannot have children // //we shortcut here // if(selectorChain->size() > 1 && !displayObject->isA(HSSObjectTypeContainer)){ // //we're done // continue; // } // // for (j=0, size=selectorChain->size(); j<size; j++) { // const HSSParserNode::p & currentNode = selectorChain->get(j); // if(currentNode->isA(HSSParserNodeTypeSelector)){ // HSSSelector::p simpleSelector = boost::static_pointer_cast<HSSSelector>(currentNode); // // //match the selector // if (simpleSelector->getElementName() == displayObject->getElementName()) { // tempSelection.push_back(displayObject); // } // } // } // } }
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); } } } } }