from Translator import *
import DeclarationList
import Declaration
import SelectorList
import Property
import pdb
class SSSObject(Declaration.SSSDeclaration):
UNKNOWN_RULE = 0
STYLE_RULE = 1
CHARSET_RULE = 2
IMPORT_RULE = 3
MEDIA_RULE = 4
FONT_FACE_RULE = 5
PAGE_RULE = 6
#// Extensions...
COMMENT_RULE = 7
INCLUDE_RULE = 8
INHERIT_RULE = 9
CONSTANT_RULE = 10
COPY_RULE = 11
def __init__(self):
super(SSSObject, self).__init__()
self._declarations = DeclarationList.SSSDeclarationList(self)
self._selector_lookup = {}
def deleteRule(self, index):
return self._declarations._deleteRule(index)
def insertRule(self, rule, index):
return self._declarations.insertItem(rule, index)
def appendRule(self, rule):
return self._declarations.appendItem(rule)
#/* begin property functions */
def getPropertyText(self):
string = ''
for key, item in self.items:
if (get_class(item) == 'SSSProperty'):
string += "\t" + item.cssText
return string
def getRuleText(self):
string = ''
for key, item in self.items.items():
if (get_class(item) != 'SSSProperty'):
string += item.cssText
return string
def _parse(self, text):
ruleText = ''
sourceText = text
stack = []
incomment = False
for i in xrange(len(sourceText)):
char = sourceText[i]
if char == '/' and i != len(sourceText) - 1 and sourceText[i + 1] == '*':
incomment = True
continue
elif char == '/' and sourceText[i - 1] == '*':
incomment = False
continue
if not incomment:
ruleText += char
if (char == '{'):
stack.append(char)
elif (char == '}'):
array_pop(stack)
if (len(stack) == 0):
self.append(ruleText)
ruleText = ''
elif (char == ';') and (len(stack) == 0):
self.append(ruleText)
ruleText = ''
def getPropertyCSSValue(self, propertyName):
prop_name = trim(propertyName)
#pdb.set_trace()
counter = self._declarations.length - 1
while counter >= 0:
item = self._declarations.item(counter)
if get_class(item) == 'SSSProperty' and item.name == prop_name:
return item
elif get_class(item) == 'SSSIncludeRule' or get_class(item) == 'SSSImportRule':
included_imported_property = item.getPropertyCSSValue(propertyName)
if (included_imported_property):
return included_imported_property
counter -= 1
return None
def inherit(self, selectorList, rule):
for i in xrange(len(selectorList)): #(i = 0; i < selectorList.length; i++):
selector_to_inherit = selectorList.item(i)
matches = self.getRulesWithSelector(selector_to_inherit)
#foreach(matches as matching_selector=>$matches):
for matching_selector, match in matches.items():
for i in xrange(len(rule.selectorList)): #(i = 0; i < rule.selectorList.length; i++):
rule_selector = rule.selectorList.item(i)
new_selector = preg_replace(trim(selector_to_inherit), ' ' + rule_selector + ' ' , ' ' + matching_selector + ' ')
def addSelectorToStyleRules(self, selector, rules):
for key, rule in rules.items():
if (rule.parentStyleSheet.ownerRule.type != SSSObject.IMPORT_RULE):
rule.addSelector(selector)
else:
self._inherit_offset += 1
index = self.insertRule(rule, self._inherit_offset)
new_rule = self._declarations.item(index)
new_rule.addSelector(selector)
self.addSelectorReference(selector, rule)
def inheritFromStyleRuleWithSelector(self, selectorList):
for i in xrange(len(selectorList)): #(i = 0; i < selectorList.length; i++):
self.inheritFromStyleRuleWithSelector(selectorList.item(i))
return
def addInheritance(self, selector, child_selector):
matches = self.getRulesWithSelector(selector)
#foreach(matches as matching_selector=>rules):
for matching_selector, rules in matches.items():
new_selector = preg_replace(trim(selector), trim(child_selector), matching_selector)
self.addSelectorToStyleRules(new_selector, rules)
def getPropertyValue(self, propertyName):
item = self.getPropertyCSSValue(propertyName)
if (item):
return item.value
return None
def setProperty(self, propertyName, value, priority = ''):
item = self.getPropertyCSSValue(propertyName)
if (item): #// property currently exists...
item.setValue(value)
return self.appendItem(obj)
def getRulesWithSelector(self, selector):
matches = []
selector = trim(selector)
for selectorText, rules in self._selector_lookup.items():
if preg_match('[\s]+' + selector + '[\s]+', ' ' + selectorText + ' '):
for rule in rules:
matches.append(rule)
return matches
def getRulesBySelector(self, selector):
try:
return self._selector_lookup[trim(selector)]
except KeyError:
return []
def copyFromRulesWithSelectors(self, selectors):
selectorList = SelectorList.SSSSelectorList()
selectors = selectorList.getSelectorsAsArray(selectors)
for selector in selectors:
self.copyFromRulesWithSelector(selector)
def copyFromRulesWithSelector(self, selector):
rules = self.hostStyleSheet.getRulesBySelector(selector)
for rule in rules:
self.copyFromRule(rule)
def copyFromRule(self, rule):
props = rule.getPropertiesAsArray()
for prop in props:
prop_object = Property.SSSProperty()
self.addDeclaration(prop_object)
prop_object.cssText = prop.cssText
def addSelectorReferences(self, rule):
import SelectorList
selectorList = SelectorList.SSSSelectorList()
selectors_array = selectorList.getSelectorsAsArray(rule.selectorText)
for selector in selectors_array:
self.addSelectorReference(selector, rule)
def addSelectorReference(self, selector, rule):
try:
self._selector_lookup[trim(selector)].append(rule)
except KeyError:
self._selector_lookup[trim(selector)] = []
self._selector_lookup[trim(selector)].append(rule)
if self.parentObject:
self.parentObject.addSelectorReference(selector, rule)
def getPropertiesAsArray(self):
props = []
for i in xrange(self._declarations.length):
item = self._declarations.item(i)
if (get_class(item) == 'SSSProperty'):
props.append(item)
return props
def getStyleRulesAsArray(self):
props = []
for i in xrange(self._declarations.length):
item = self._declarations.item(i)
if (get_class(item) == 'SSSStyleRule'):
props.append(item)
return props
def getNonStyleRulesAsArray(self):
props = []
addLogMessage('self._declarations.length = ' + str(self._declarations.length))
for i in xrange(self._declarations.length): #(i = 0; i < self._declarations.length; i++):
item = self._declarations.item(i)
if (get_class(item) != 'SSSStyleRule'):
props.append(item)
return props
def getCssTextFromArray(self, objects):
cssText = ''
for obj in objects:
cssText += obj.cssText
return cssText
def addDeclaration(self, obj):
self._declarations.appendItem(obj)
obj._setParentObject(self)
return obj
def isDirective(self, cssText):
matches = preg_match(r'^(\@[\S]*)', trim(cssText))
if (matches):
return matches[0]
return False
def append(self, cssText):
directive = self.isDirective(cssText)
if (directive):
if directive == '@charset':
return self.addCharsetRule(cssText)
elif directive == '@font-face':
return self.addFontFaceRule(cssText)
elif directive == '@import':
return self.addImportRule(cssText)
elif directive == '@media':
return self.addMediaRule(cssText)
#// SSC Extensions...
elif directive == '@inherit':
return self.addInheritRule(cssText)
elif directive == '@comment':
return self.addCommentRule(cssText)
elif directive == '@include':
return self.addIncludeRule(cssText)
elif directive == '@ignore':
return self.addIgnoreRule(cssText)
elif directive == '@constant':
return self.addConstantRule(cssText)
elif directive == '@copy':
return self.addCopyRule(cssText)
if preg_match(r'\;$', trim(cssText)):
return self.addProperty(cssText)
return self.addStyleRule(cssText)
def addCharsetRule(self, cssText):
import CharsetRule
return self.addDeclaration(CharsetRule.SSSCharsetRule(cssText))
def addFontFaceRule(self, cssText):
return self.addDeclaration(SSSFontFaceRule(cssText))
def addImportRule(self, cssText):
import ImportRule
rule = self.addDeclaration(ImportRule.SSSImportRule())
rule.cssText = cssText
return rule
def addMediaRule(self, cssText):
import MediaRule
rule = self.addDeclaration(MediaRule.SSSMediaRule())
rule.cssText = cssText
return rule
def addInheritRule(self, cssText):
import InheritRule
rule = self.addDeclaration(InheritRule.SSSInheritRule())
rule.cssText = cssText
return rule
def addCommentRule(self, cssText):
import CommentRule
rule = self.addDeclaration(CommentRule.SSSCommentRule(cssText))
return rule
def addIncludeRule(self, cssText):
import IncludeRule
rule = self.addDeclaration(IncludeRule.SSSIncludeRule())
rule.cssText = cssText
return rule
def addIgnoreRule(self, cssText):
import IgnoreRule
rule = self.addDeclaration(IgnoreRule.SSSIgnoreRule())
rule.cssText = cssText
return rule
def addConstantRule(self, cssText):
import ConstantRule
rule = self.addDeclaration(ConstantRule.SSSConstantRule())
rule.cssText = cssText
return rule
def addCopyRule(self, cssText):
import CopyRule
rule = self.addDeclaration(CopyRule.SSSCopyRule(cssText))
self.copyFromRulesWithSelectors(rule.selectorText)
return rule
#// Style Rules:
def addStyleRule(self, cssText):
import StyleRule
obj = self.addDeclaration(StyleRule.SSSStyleRule())
obj.cssText = cssText
if get_class(obj) == 'SSSStyleRule':
#obj.prependToAllSelectors(self.selectorText)
self.addSelectorReferences(obj)
return obj
def addStyleSheet(self, cssText = ''):
obj = self.addDeclaration(StyleSheet.SSSStyleSheet())
return obj
def addProperty(self, cssText):
import Property
obj = self.addDeclaration(Property.SSSProperty())
obj.cssText = cssText
return obj
def getVar(self, name):
value = self.getPropertyValue(name)
if (value):
return value
elif (self.parentObject):
return self.parentObject.getVar(name)
return False
def __set(self, var, value):
prop = self.__get(var)
if prop:
prop.value = value
else:
prop = SSSProperty()
prop.name = var
prop.value = value
self._declarations.appendItem(prop)
def get_length(self):
if (self._declarations):
return self._declarations.length
return 0
length = property(get_length)
