void HSSDisplayObject::setDAnchorY(HSSParserNode::p value)
{
this->dAnchorY = value;
HSSObservableProperty observedProperty = HSSObservablePropertyHeight;
if(this->observedAnchorY != NULL)
{
this->observedAnchorY->removeObserver(this->observedAnchorYProperty, this);
}
HSSContainer::p parentContainer = this->getParent();
const std::vector<HSSDisplayObject::p> * scope;
if(parentContainer){
scope = &(parentContainer->getChildren());
} else {
scope = NULL;
}
this->anchorY = this->_setLDProperty(
&HSSDisplayObject::anchorYChanged,
value,
this->height,
observedProperty,
this,
this->observedAnchorY,
this->observedAnchorYProperty,
scope
);
this->notifyObservers(HSSObservablePropertyAnchorY, &this->anchorY);
#if AXR_DEBUG_LEVEL > 0
this->setDirty(true);
#endif
}
std::vector< std::vector<HSSDisplayObject::p> > AXRController::selectAllHierarchical(const std::vector<HSSDisplayObject::p> & scope, HSSDisplayObject::p thisObj, bool negating, bool processing)
{
std::vector< std::vector<HSSDisplayObject::p> > selections = this->selectOnLevel(scope, thisObj, negating, processing);
unsigned i, j, k, size, size2, size3;
for (i=0, size=selections.size(); i<size; i++) {
std::vector<HSSDisplayObject::p> newSearch;
for(j=0, size2=scope.size(); j<size2; j++){
if(scope[j]->isA(HSSObjectTypeContainer)){
HSSContainer::p theContainer = boost::static_pointer_cast<HSSContainer>(scope[j]);
const std::vector<HSSDisplayObject::p> children = theContainer->getChildren();
for(k=0, size3 = children.size(); k<size3; k++){
newSearch.push_back(children[k]);
}
}
}
std::vector< std::vector<HSSDisplayObject::p> > childSelection;
if(newSearch.size() > 0){
this->currentChainCount -= 1;
this->readNextSelectorNode();
childSelection = this->selectAllHierarchical(newSearch, thisObj, false, processing);
for (j=0, size2=selections.size(); j<size2; j++) {
//std::vector<HSSDisplayObject::p> & selection = selections[j];
for (k=0, size3=childSelection.size(); k<size3; k++) {
selections[j].insert(selections[j].end(), childSelection[k].begin(), childSelection[k].end());
}
}
}
}
return selections;
}
std::vector< std::vector<HSSDisplayObject::p> > AXRController::selectHierarchical(const std::vector<HSSDisplayObject::p> & scope, HSSDisplayObject::p thisObj, bool negating, bool processing)
{
std::vector< std::vector<HSSDisplayObject::p> > selections = this->selectOnLevel(scope, thisObj, negating, processing);
unsigned i, size;
for (i=0, size=selections.size(); i<size; i++) {
std::vector<HSSDisplayObject::p> selection = selections[i];
if(selection.size() > 0){
if(!this->isAtEndOfSelector()){
if(this->currentSelectorNode->isA(HSSParserNodeTypeCombinator)){
HSSCombinator::p combinator = boost::static_pointer_cast<HSSCombinator>(this->currentSelectorNode);
HSSCombinatorType combinatorType = combinator->getCombinatorType();
switch (combinatorType) {
case HSSCombinatorTypeChildren:
{
std::vector<HSSDisplayObject::p> newScope;
unsigned j, size2, k, size3;
for(j=0, size2 = selection.size(); j<size2; j++){
if(selection[j]->isA(HSSObjectTypeContainer)){
HSSContainer::p theContainer = boost::static_pointer_cast<HSSContainer>(selection[j]);
const std::vector<HSSDisplayObject::p> children = theContainer->getChildren();
for(k=0, size3 = children.size(); k<size3; k++){
newScope.push_back(children[k]);
}
}
}
this->readNextSelectorNode();
return this->selectHierarchical(newScope, thisObj, false, processing);
break;
}
case HSSCombinatorTypeDescendants:
{
std::vector<HSSDisplayObject::p> newScope;
unsigned j, size2, k, size3;
for(j=0, size2 = selection.size(); j<size2; j++){
if(selection[j]->isA(HSSObjectTypeContainer)){
HSSContainer::p theContainer = boost::static_pointer_cast<HSSContainer>(selection[j]);
const std::vector<HSSDisplayObject::p> children = theContainer->getChildren();
for(k=0, size3 = children.size(); k<size3; k++){
newScope.push_back(children[k]);
}
}
}
this->readNextSelectorNode();
return this->selectAllHierarchical(newScope, thisObj, false, processing);
break;
}
default:
break;
}
}
}
}
}
return selections;
}
void AXRController::add(HSSContainer::p & newContainer)
{
if(!this->root){
this->root = newContainer;
} else {
if(this->currentContext.size() != 0){
HSSContainer::p theCurrent = this->currentContext.top();
theCurrent->add(newContainer);
} else {
throw "tried to add a container to nonexistent current";
}
}
}
void AXRController::setRoot(HSSContainer::p newRoot){
this->root = newRoot;
if(this->core->getParserHSS()->currentObjectContextSize() == 0){
this->core->getParserHSS()->currentObjectContextAdd(newRoot);
}
newRoot->setRoot(true);
}
void AXRController::setRoot(HSSContainer::p newRoot){
this->root = newRoot;
HSSParser::p hssparser = AXRCore::getInstance()->getParserHSS();
if(hssparser->currentObjectContextSize() == 0){
hssparser->currentObjectContextAdd(newRoot);
}
newRoot->setRoot(true);
}
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");
}
}
}
const std::vector<HSSDisplayObject::p> HSSParentFilter::apply(const std::vector<HSSDisplayObject::p> &scope, bool negating)
{
if(scope.size() > 0){
std::vector<HSSDisplayObject::p> ret;
int size=scope.size();
HSSContainer::p container;
if (!negating)
for (int i=0; i<size; i++){
container = HSSContainer::asContainer(scope[i]);
if (container && container->getChildren(false).size()>0)
ret.push_back(scope[i]);
}
else
for (int i=0; i<size; i++){
container = HSSContainer::asContainer(scope[i]);
if (container && container->getChildren(false).size()==0)
ret.push_back(scope[i]);
}
return ret;
} else {
return scope;
}
}
int main(int argc, char **argv) {
SDL_Init( SDL_INIT_VIDEO );
screen = SDL_SetVideoMode( WINDOW_WIDTH, WINDOW_HEIGHT, 32, SDL_HWSURFACE | SDL_DOUBLEBUF | SDL_RESIZABLE );
cr = cairosdl_create (screen);
SDL_WM_SetCaption( WINDOW_TITLE, 0 );
#ifdef __WIN32__
HINSTANCE handle = ::GetModuleHandle(NULL);
mainicon = ::LoadIcon(handle, "main");
SDL_SysWMinfo wminfo;
SDL_VERSION(&wminfo.version);
if (SDL_GetWMInfo(&wminfo) == 1) ::SetClassLong(wminfo.window, GCL_HICON, (LONG) mainicon);
#endif
SDL_EnableKeyRepeat(300, 50);
SDL_EnableUNICODE(1);
wrapper = new WinAxrWrapper();
AXRCore::p core = wrapper->getCore();
wrapper->hwnd = wminfo.window;
wrapper->loadFile();
SDL_Event event;
while (SDL_WaitEvent(&event)) {
if (event.type == SDL_QUIT) {
break;
} else if (event.type == SDL_MOUSEBUTTONDOWN) {
AXRCore::p core = wrapper->getCore();
HSSContainer::p root = core->getController()->getRoot();
if (root) {
HSSPoint thePoint;
thePoint.x = event.button.x;
thePoint.y = event.button.y;
root->handleEvent(HSSEventTypeMouseDown, &thePoint);
}
} else if (event.type == SDL_MOUSEBUTTONUP) {
AXRCore::p core = wrapper->getCore();
HSSContainer::p root = core->getController()->getRoot();
if (root) {
HSSPoint thePoint;
thePoint.x = event.button.x;
thePoint.y = event.button.y;
root->handleEvent(HSSEventTypeMouseUp, &thePoint);
}
} else if (event.type == SDL_MOUSEMOTION) {
AXRCore::p core = wrapper->getCore();
HSSContainer::p root = core->getController()->getRoot();
if (root) {
HSSPoint thePoint;
thePoint.x = event.motion.x;
thePoint.y = event.motion.y;
root->handleEvent(HSSEventTypeMouseMove, &thePoint);
}
} else if (event.type == SDL_KEYDOWN) {
} else if (event.type == SDL_KEYUP) {
if(event.key.keysym.sym == SDLK_F5) {
reload();
} else if(event.key.keysym.sym == SDLK_o && (event.key.keysym.mod & KMOD_CTRL) ) {
wrapper->loadFile();
}
} else if(event.type == SDL_VIDEORESIZE) {
cairosdl_destroy (cr);
screen = SDL_SetVideoMode (event.resize.w, event.resize.h, 32, SDL_HWSURFACE | SDL_DOUBLEBUF | SDL_RESIZABLE);
SDL_SetAlpha(screen,SDL_SRCALPHA,CAIROSDL_AMASK);
cr = cairosdl_create (screen);
wrapper->setNeedsDisplay(true);
} else {
}
render();
SDL_Flip(screen);
//SDL_Delay(1000/30);
}
SDL_Quit();
#ifdef __WIN32__
::DestroyIcon(mainicon);
#endif
return 0;
}
void HSSDisplayObject::setDHeight(HSSParserNode::p value)
{
if(value->isA(HSSParserNodeTypeKeywordConstant)){
} else {
this->dHeight = value;
HSSObservableProperty observedProperty = HSSObservablePropertyHeight;
if(this->observedHeight != NULL)
{
this->observedHeight->removeObserver(this->observedHeightProperty, this);
//we're cheating a bit here (maybe FIXME?)
}
HSSContainer::p parentContainer = this->getParent();
if(parentContainer){
this->height = this->_setLDProperty(
&HSSDisplayObject::heightChanged,
value,
parentContainer->height,
observedProperty,
parentContainer.get(),
this->observedHeight,
this->observedHeightProperty,
&(parentContainer->getChildren())
);
} else {
this->height = this->_setLDProperty(
NULL,
value,
150,
observedProperty,
this,
this->observedHeight,
this->observedHeightProperty,
NULL
);
}
this->notifyObservers(HSSObservablePropertyHeight, &this->height);
this->setNeedsSurface(true);
this->setDirty(true);
}
// //std_log1("setting height of "+this->name+":");
// this->dHeight = value;
// HSSParserNodeType nodeType = value->getType();
//
// if(observedHeight != NULL)
// {
// observedHeight->removeObserver(HSSObservablePropertyHeight, this);
// }
//
// switch (nodeType) {
// case HSSParserNodeTypeNumberConstant:
// {
// HSSNumberConstant::p heightValue = boost::static_pointer_cast<HSSNumberConstant>(value);
// this->height = heightValue->getValue();
// break;
// }
//
// case HSSParserNodeTypePercentageConstant:
// {
// HSSPercentageConstant::p heightValue = boost::static_pointer_cast<HSSPercentageConstant>(value);
// HSSContainer::p parentContainer = this->getParent();
// if(parentContainer){
// this->height = heightValue->getValue(parentContainer->height);
// parentContainer->observe(HSSObservablePropertyHeight, this, new HSSValueChangedCallback<HSSDisplayObject>(this, &HSSDisplayObject::heightChanged));
// this->observedHeight = parentContainer.get();
// }
// break;
// }
//
// case HSSParserNodeTypeExpression:
// {
// HSSExpression::p heightExpression = boost::static_pointer_cast<HSSExpression>(value);
// HSSContainer::p parentContainer = this->getParent();
// if(parentContainer){
// heightExpression->setPercentageBase(parentContainer->height);
// heightExpression->setPercentageObserved(HSSObservablePropertyHeight, parentContainer.get());
// heightExpression->setScope(&(parentContainer->getChildren()));
// this->height = heightExpression->evaluate();
// heightExpression->observe(HSSObservablePropertyHeight, this, new HSSValueChangedCallback<HSSDisplayObject>(this, &HSSDisplayObject::heightChanged));
// } else {
// heightExpression->setPercentageBase(this->height);
// heightExpression->setPercentageObserved(HSSObservablePropertyHeight, this);
// if(this->isA(HSSObjectTypeContainer)){
// HSSContainer * thisContainer = static_cast<HSSContainer *>(this);
// heightExpression->setScope(&(thisContainer->getChildren()));
// }
// this->height = heightExpression->evaluate();
// heightExpression->observe(HSSObservablePropertyValue, this, new HSSValueChangedCallback<HSSDisplayObject>(this, &HSSDisplayObject::heightChanged));
// }
// break;
// }
//
// case HSSParserNodeTypeKeywordConstant:
//
// break;
//
// default:
// throw "unknown parser node type while setting dHeight";
// break;
// }
//
// //fprintf(stderr, "%f\n", this->height);
// this->notifyObservers(HSSObservablePropertyHeight, &this->height);
// this->setNeedsSurface(true);
// this->setDirty(true);
}
void HSSDisplayObject::setDWidth(HSSParserNode::p value)
{
if(value->isA(HSSParserNodeTypeKeywordConstant)){
} else {
this->dWidth = value;
HSSObservableProperty observedProperty = HSSObservablePropertyWidth;
if(this->observedWidth != NULL)
{
this->observedWidth->removeObserver(this->observedWidthProperty, this);
}
HSSContainer::p parentContainer = this->getParent();
if(parentContainer){
this->width = this->_setLDProperty(
&HSSDisplayObject::widthChanged,
value,
parentContainer->width,
observedProperty,
parentContainer.get(),
this->observedWidth,
this->observedWidthProperty,
&(parentContainer->getChildren())
);
} else {
this->width = this->_setLDProperty(
NULL,
value,
150,
observedProperty,
this,
this->observedWidth,
this->observedWidthProperty,
NULL
);
}
this->notifyObservers(HSSObservablePropertyWidth, &this->width);
this->setNeedsSurface(true);
this->setDirty(true);
}
// //std_log1("setting width of "+this->name+":");
// this->dWidth = value;
// HSSParserNodeType nodeType = value->getType();
//
// if(observedWidth != NULL)
// {
// //std_log1("#################should unsubscribe observer here#########################");
// observedWidth->removeObserver(HSSObservablePropertyWidth, this);
// }
//
// switch (nodeType) {
// case HSSParserNodeTypeNumberConstant:
// {
// HSSNumberConstant::p widthValue = boost::static_pointer_cast<HSSNumberConstant>(value);
// this->width = widthValue->getValue();
// break;
// }
//
// case HSSParserNodeTypePercentageConstant:
// {
// HSSPercentageConstant::p widthValue = boost::static_pointer_cast<HSSPercentageConstant>(value);
// HSSContainer::p parentContainer = this->getParent();
// if(parentContainer){
// this->width = widthValue->getValue(parentContainer->width);
// parentContainer->observe(HSSObservablePropertyWidth, this, new HSSValueChangedCallback<HSSDisplayObject>(this, &HSSDisplayObject::widthChanged));
// this->observedWidth = parentContainer.get();
//
// } else {
// this->width = widthValue->getValue(this->width);
// }
// break;
// }
//
// case HSSParserNodeTypeExpression:
// {
// HSSExpression::p widthExpression = boost::static_pointer_cast<HSSExpression>(value);
// HSSContainer::p parentContainer = this->getParent();
// if(parentContainer){
// widthExpression->setPercentageBase(parentContainer->width);
// widthExpression->setPercentageObserved(HSSObservablePropertyWidth, parentContainer.get());
// widthExpression->setScope(&(parentContainer->getChildren()));
// this->width = widthExpression->evaluate();
// widthExpression->observe(HSSObservablePropertyWidth, this, new HSSValueChangedCallback<HSSDisplayObject>(this, &HSSDisplayObject::widthChanged));
// } else {
// widthExpression->setPercentageBase(this->width);
// widthExpression->setPercentageObserved(HSSObservablePropertyWidth, this);
// if(this->isA(HSSObjectTypeContainer)){
// HSSContainer * thisContainer = static_cast<HSSContainer *>(this);
// widthExpression->setScope(&(thisContainer->getChildren()));
// }
// this->width = widthExpression->evaluate();
// widthExpression->observe(HSSObservablePropertyWidth, this, new HSSValueChangedCallback<HSSDisplayObject>(this, &HSSDisplayObject::widthChanged));
// }
// break;
// }
//
// case HSSParserNodeTypeKeywordConstant:
//
// break;
//
// default:
// throw "unknown parser node type while setting dWidth";
// break;
// }
//
// //fprintf(stderr, "%f\n", this->width);
// this->notifyObservers(HSSObservablePropertyWidth, &this->width);
// this->setNeedsSurface(true);
// this->setDirty(true);
}
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);
}
}
}
}
}
void HSSRequest::fire()
{
AXRDocument* document = this->getController()->document();
//if there is no target
if (this->target->empty())
{
document->loadXMLFile(this->src);
}
else
{
switch (this->mode)
{
default:
{
AXRController::p controller = AXRController::p(new AXRController(document));
XMLParser::p xmlParser(new XMLParser(controller.data()));
HSSParser::p hssParser(new HSSParser(controller.data()));
AXRBuffer::p baseFile = document->getFile();
AXRBuffer::p newFile;
try
{
newFile = document->getFile(this->src);
}
catch (const AXRError &e)
{
e.raise();
}
if (newFile)
{
bool loadingSuccess = xmlParser->loadFile(newFile);
if (!loadingSuccess)
{
AXRError("AXRDocument", "Could not load the XML file").raise();
}
else
{
HSSContainer::p root = qSharedPointerCast<HSSContainer > (controller->getRoot());
if (root)
{
std::vector<QUrl> loadSheets = controller->loadSheetsGet();
for (std::vector<QUrl>::iterator sheetsIt = loadSheets.begin(); sheetsIt != loadSheets.end(); ++sheetsIt)
{
AXRBuffer::p hssfile;
try
{
hssfile = document->getFile(*sheetsIt);
}
catch (const AXRError &e)
{
e.raise();
continue;
}
if (!hssParser->loadFile(hssfile))
{
AXRError("AXRDocument", "Could not load the HSS file").raise();
}
}
controller->matchRulesToContentTree();
HSSSimpleSelection::const_iterator targetIt, childIt;
for (targetIt = this->target->begin(); targetIt != this->target->end(); ++targetIt)
{
const HSSDisplayObject::p & theDO = *targetIt;
HSSContainer::p theContainer = HSSContainer::asContainer(theDO);
if (theContainer)
{
theContainer->clear();
for (childIt = root->getChildren()->begin(); childIt != root->getChildren()->end(); ++childIt)
{
const HSSDisplayObject::p & theChild = *childIt;
theContainer->add(theChild);
}
}
}
root->setNeedsRereadRules(true);
root->recursiveReadDefinitionObjects();
root->handleEvent(HSSEventTypeLoad, NULL);
document->setNeedsDisplay(true);
}
}
}
// AXRDocument::tp document = AXRDocument::getInstance();
// AXRWrapper * document = document->getWrapper();
// AXRBuffer::p baseFile = document->getFile();
//
// bool loadingSuccess = document->loadFile(baseFile->basePath+this->src, this->src);
// if(loadingSuccess){
// unsigned i, size;
// for (i=0, size=this->target.size(); i<size; ++i) {
// std_log1("Adding loaded file to target");
//
// if(this->target[i]->isA(HSSObjectTypeContainer)){
// const HSSContainer::p & theCont = qSharedPointerCast<HSSContainer>(this->target[i]);
// const HSSContainer::p & loadedRoot = fileController.getRoot();
// theCont->add(loadedRoot);
//
// unsigned j, k, size2, size3;
// HSSSimpleSelection::p scope = theCont->getChildren();
// for (j=0, size2=fileController.rulesSize(); j<size2; ++j) {
// HSSRule::p & theRule = fileController.rulesGet(j);
// theRule->childrenAdd(theRule);
// }
// for (j=0, size2=theCont->rulesSize(); j<size2; ++j) {
// HSSRule::p theRule = theCont->rulesGet(j);
// for (k=0, size3=theRule->childrenSize(); k<size3; ++k) {
// HSSRule::p childRule = theRule->childrenGet(k);
// this->getController()->recursiveMatchRulesToDisplayObjects(childRule, scope, theCont);
// }
// }
//
// theCont->recursiveReadDefinitionObjects();
// theCont->setNeedsLayout(true);
// }
// }
// }
break;
}
}
}
}
