Changeset 15818 for lang/actionscript

Timestamp:

07/15/08 01:20:04 (4 months ago)

Author:

gyuque

Message:

supported universal selectors

Location:

lang/actionscript/ascss/src

Files:

• KyotoDemo.as (modified) (7 diffs)
• KyotoDemo.swf (modified) (previous)
• css/ASCSS.asy (modified) (1 diff)
• css/CSSRuleSet.as (modified) (3 diffs)
• css/CSSSelector.as (modified) (2 diffs)
• css/CSSStyleSelector.as (modified) (3 diffs)
• cssdom/XMLElementWrapper.as (modified) (8 diffs)
• kyotodemo/ElementData.as (added)
• kyotodemo/XMLDocument.as (modified) (7 diffs)

lang/actionscript/ascss/src/KyotoDemo.as

@@ -5 +5 @@
         import flash.geom.*;
         import flash.text.*;
+        import flash.utils.*;
         import css.*;
         import cssdom.*;
@@ -35 +36 @@
 
                 private var mDocument:XMLDocument;
+                private var mPrevMatchedDocument:XMLDocument = null;
+                private var mStyleSheet:StyleList;
 
                 function KyotoDemo()
@@ -95 +98 @@
                         removeChild(tx);
                         addChild(tx);
+                        tx.width = 300;
+                        tx.height = 300;
                         tx.textColor = 0xffffff;
                         onXMLChanged(null);
@@ -134 +139 @@
                 private function onCSSChanged(e:Event):void
                 {
+                        mStyleSheet = null;
                         clearCSSError();
                         var parser:ASCSS = new ASCSS(mCSSField.text, new DebugOutProxy(this));
                         parser.parse();
                         createSelectorMarkers(parser.sheet);
+                        mStyleSheet = parser.sheet;
                         showSelectorMarkers();
+
+                        doMatching();
                 }
 
@@ -147 +156 @@
                         try{
                                 mDocument = new XMLDocument(mXMLField.text);
+                                XMLElementWrapper.createFor(mDocument.root, mDocument);
                         } catch(e:Error) {
                                 outXMLError(e.toString());
@@ -152 +162 @@
 
                         showElementMarkers();
+
+                        doMatching();
                 }
 
@@ -243 +255 @@
                         }
                 }
+
+                private function doMatching():void
+                {
+                        STDOUT.cls();
+                        if (!mDocument || !mStyleSheet) return;
+
+                        var list:Array = mDocument.elementMetadatas;
+
+                        var sel:CSSStyleSelector;
+
+                        mDocument.clearStyleSheets();
+                        mDocument.appendStyleSheet(mStyleSheet as css.StyleSheet);
+                        sel = mDocument.createStyleSelector()
+                        if (!sel)
+                                return;
+                        mPrevMatchedDocument = mDocument;
+                        for each(var md:ElementData in list)
+                        {
+                                var elem:IASCSSElement = md.wrapper;
+                                sel.initElementAndPseudoState(elem);
+                                sel.initForStyleResolve(elem, null);
+
+                                var authorStyle:CSSRuleSet = sel.authorStyle;
+                                var indexes:Array = [-1, -1];
+
+                                sel.matchRules(authorStyle, indexes);
+                                if (!sel.matchedRulesIsEmpty)
+                                {
+                                        for each(var rd:CSSRuleData in sel.matchedRulesList)
+                                        {
+                                                STDOUT.puts(rd.selector.dump());
+                                        }
+                                }
+                        }
+                }
         }
 }

lang/actionscript/ascss/src/css/ASCSS.asy

@@ -1585 +1585 @@
                 appendStyleObject(rule);
                 rule.selector = sel;
+                sel._owner = rule;
                 rule.declaration = new CSSMutableStyleDeclaration(rule, mParsedProperties);
         }

lang/actionscript/ascss/src/css/CSSRuleSet.as

@@ -4 +4 @@
         {
                 private var mRuleCount:uint = 0;
+                private var mUniversalRules:CSSRuleDataList;
 
                 private var m_idRules:Object    = {};
@@ -20 +21 @@
                 public function getTagRules(key:String):CSSRuleDataList {
                         return m_tagRules[key] as CSSRuleDataList;
+                }
+
+                public function getUniversalRules():CSSRuleDataList {
+                        return mUniversalRules as CSSRuleDataList;
                 }
 
@@ -64 +69 @@
                                 return;
                         }
+                        else
+                        {
+                                // Just put it in the universal rule set.
+                                if (!mUniversalRules)
+                                        mUniversalRules = new CSSRuleDataList(mRuleCount++, rule, sel);
+                                else
+                                        mUniversalRules.append(mRuleCount++, rule, sel);
+                        }
                 }
 

lang/actionscript/ascss/src/css/CSSSelector.as

@@ -159 +159 @@
                 }
 
+                private var mOwner:CSSStyleRule;
+
                 function CSSSelector()
                 {
@@ -168 +170 @@
                         m_relation = Descendant;
                         mPseudoType = PseudoNotParsed;
+                }
+
+                public function set _owner(r:CSSStyleRule):void
+                {
+                        mOwner = r;
+                }
+
+                public function get _owner():CSSStyleRule
+                {
+                        return mOwner;
                 }
 

lang/actionscript/ascss/src/css/CSSStyleSelector.as

@@ -292 +292 @@
 
                         matchRulesForList(rules.getTagRules(mElement.localName), aRuleIndexes);
+                        matchRulesForList(rules.getUniversalRules(), aRuleIndexes);
 
                         // If we didn't match any rules, we're done.
@@ -318 +319 @@
                 }
 
+                public function get matchedRulesList():Array
+                {
+                        return mMatchedRules;
+                }
+
                 public function matchRulesForList(rules:CSSRuleDataList, aRuleIndexes:Array /* first, last */):void
                 {
@@ -328 +334 @@
                                 const localName:String         = mElement.localName;
                                 const selectorLocalName:String = d.selector.m_tag.localName;
-
                                 if ((localName == selectorLocalName || selectorLocalName == '*') && checkSelector1(d.selector))
                                 {

lang/actionscript/ascss/src/cssdom/XMLElementWrapper.as

@@ -2 +2 @@
 {
         import css.*;
+        import flash.utils.*;
 
-        public class XMLElementWrapper implements IASCSSStyledElement, IASCSSDocument
+        public class XMLElementWrapper implements IASCSSStyledElement
         {
                 private var m_usesSiblingRules:Boolean;
@@ -19 +20 @@
                 private var mMappedElementSheet:CSSStyleSheet;
                 private var mStyleSelector:CSSStyleSelector;
+                private var mRenderStyle:RenderStyle;
 
                 function XMLElementWrapper(x:XML, d:IASCSSDocument)
@@ -28 +30 @@
                         mClassNames = new ClassNames();
                         readClassNames(x.attribute("class")[0]);
+                }
+
+                public function get renderStyle():RenderStyle
+                {
+                        return mRenderStyle;
+                }
+
+                public function get hovered():Boolean
+                {
+                        return false;
                 }
 
@@ -46 +58 @@
                 {
                         var wrapper:XMLElementWrapper = new XMLElementWrapper(x, d);
+/*
                         if (d == null)
                         {
@@ -52 +65 @@
                                 wrapper.mStyleSheets = new StyleSheetList(wrapper);
                         }
-
+*/
                         var len:uint = x.children().length();
                         for (var i:uint = 0;i < len;i++)
@@ -70 +83 @@
 
                         return wrapper;
+                }
+
+                public function appendChild(e:IASCSSElement):void
+                {
+                        if (!mChildren)
+                                mChildren = [];
+
+                        mChildren.push(e);
                 }
 
@@ -124 +145 @@
                         return mDoc;
                 }
-
+/*
                 public function setUsesSiblingRules(b:Boolean):void
                 {
@@ -165 +186 @@
                         mStyleSheets.add(s);
                 }
+*/
         }
 }

lang/actionscript/ascss/src/kyotodemo/XMLDocument.as

@@ -1 +1 @@
 package kyotodemo
 {
-        public class XMLDocument
+        import cssdom.*;
+        import css.*;
+
+        public class XMLDocument implements IASCSSDocument
         {
                 private var mMetadatas:Array;
@@ -7 +10 @@
                 private var mSource:String;
                 private var mLineNo:int;
+
+                private var mStyleSheets:StyleSheetList;
+                private var mMappedElementSheet:CSSStyleSheet;
+                private var mStyleSelector:CSSStyleSelector;
+                // for parser
+                private var m_usesSiblingRules:Boolean;
+                private var m_usesDescendantRules:Boolean;
+                private var m_usesFirstLineRules:Boolean;
+
                 function XMLDocument(src:String)
                 {
+                        mStyleSheets = new StyleSheetList(this);
                         mSource = src;
                         mMetadatas = [];
@@ -16 +29 @@
                         mXML = new XML(src);
 
-                        STDOUT.cls();
-
                         var pre:Object = /^[^<]+/.exec(src);
                         mLineNo = pre ? countBreaks(pre[0]) : 0;
                         checkLineno(mXML);
+                }
+
+                public function get root():XML
+                {
+                        return mXML;
                 }
 
@@ -28 +44 @@
                 }
 
-                private function checkLineno(x:XML, nest:int = 0):void
+                private function checkLineno(x:XML, nest:int = 0, parent:ElementData = null):void
                 {
                         var md:ElementData = null;
@@ -39 +55 @@
                                 md = new ElementData();
                                 md.x = x;
+                                md.wrapper = new XMLElementWrapper(x, this);
                                 md.nest = nest;
                                 md.lineno = mLineNo;
                                 mMetadatas.push(md);
+
+                                if (parent && parent.wrapper) {
+                                        parent.wrapper.appendChild(md.wrapper);
+                                        md.wrapper.parent = parent.wrapper;
+                                }
                         }
 
@@ -47 +69 @@
                         for each(var ch:XML in list)
                         {
-                                checkLineno(ch, nest + 1);
+                                checkLineno(ch, nest + 1, md);
                         }
 
@@ -69 +91 @@
                         return c;
                 }
+
+                // Document interface
+                public function isHTMLDocument():Boolean
+                {
+                        return false;
+                }
+
+                public function get inCompatMode():Boolean
+                {
+                        return true;
+                }
+
+                public function setUsesSiblingRules(b:Boolean):void
+                {
+                        m_usesSiblingRules = b;
+                }
+
+                public function setUsesDescendantRules(b:Boolean):void
+                {
+                        m_usesDescendantRules = b;
+                }
+
+                public function setUsesFirstLineRules(b:Boolean):void
+                {
+                        m_usesFirstLineRules = b;
+                }
+
+                public function createStyleSelector():CSSStyleSelector
+                {
+                        mStyleSelector = new CSSStyleSelector(this, userStyleSheet, mStyleSheets, mMappedElementSheet, !inCompatMode, true);
+                        return mStyleSelector;
+                }
+
+                public function get userStyleSheet():String
+                {
+                        return null;
+                }
+
+                public function getElementById(id:String):IASCSSElement
+                {
+                        return null; // not needed for this demo
+                }
+
+                public function appendStyleSheet(s:StyleSheet):void
+                {
+                        mStyleSelector = null;
+                        mStyleSheets.add(s);
+                }
+
+                public function clearStyleSheets():void
+                {
+                        mStyleSelector = null;
+                        mStyleSheets = new StyleSheetList(this);
+                }
         }
 }