home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_1570 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  10.3 KB  |  223 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. __all__ = [
  5.     'CSSMediaRule']
  6. __docformat__ = 'restructuredtext'
  7. __version__ = '$Id: cssmediarule.py 1943 2010-03-23 20:54:00Z cthedot $'
  8. import cssrule
  9. import cssutils
  10. import xml.dom as xml
  11.  
  12. class CSSMediaRule(cssrule.CSSRule):
  13.     
  14.     def __init__(self, mediaText = 'all', name = None, parentRule = None, parentStyleSheet = None, readonly = False):
  15.         super(CSSMediaRule, self).__init__(parentRule = parentRule, parentStyleSheet = parentStyleSheet)
  16.         self._atkeyword = u'@media'
  17.         self._media = cssutils.stylesheets.MediaList(mediaText, readonly = readonly)
  18.         self.name = name
  19.         self.cssRules = cssutils.css.cssrulelist.CSSRuleList()
  20.         self._readonly = readonly
  21.  
  22.     
  23.     def __iter__(self):
  24.         for rule in self._cssRules:
  25.             yield rule
  26.         
  27.  
  28.     
  29.     def __repr__(self):
  30.         return 'cssutils.css.%s(mediaText=%r)' % (self.__class__.__name__, self.media.mediaText)
  31.  
  32.     
  33.     def __str__(self):
  34.         return '<cssutils.css.%s object mediaText=%r at 0x%x>' % (self.__class__.__name__, self.media.mediaText, id(self))
  35.  
  36.     
  37.     def _setCssRules(self, cssRules):
  38.         cssRules.append = self.insertRule
  39.         cssRules.extend = self.insertRule
  40.         cssRules.__delitem__ == self.deleteRule
  41.         for rule in cssRules:
  42.             rule._parentStyleSheet = None
  43.             rule._parentRule = self
  44.         
  45.         self._cssRules = cssRules
  46.  
  47.     cssRules = property((lambda self: self._cssRules), _setCssRules, 'All Rules in this style sheet, a :class:`~cssutils.css.CSSRuleList`.')
  48.     
  49.     def _getCssText(self):
  50.         return cssutils.ser.do_CSSMediaRule(self)
  51.  
  52.     
  53.     def _setCssText(self, cssText):
  54.         super(CSSMediaRule, self)._setCssText(cssText)
  55.         (cssText, namespaces) = self._splitNamespacesOff(cssText)
  56.         
  57.         try:
  58.             namespaces = self.parentStyleSheet.namespaces
  59.         except AttributeError:
  60.             pass
  61.  
  62.         tokenizer = self._tokenize2(cssText)
  63.         attoken = self._nexttoken(tokenizer, None)
  64.         if self._type(attoken) != self._prods.MEDIA_SYM:
  65.             self._log.error(u'CSSMediaRule: No CSSMediaRule found: %s' % self._valuestr(cssText), error = xml.dom.InvalidModificationErr)
  66.         else:
  67.             oldmedia = cssutils.stylesheets.MediaList()
  68.             oldmedia._absorb(self.media)
  69.             wellformed = True
  70.             (mediatokens, end) = self._tokensupto2(tokenizer, mediaqueryendonly = True, separateEnd = True)
  71.             if u'{' == self._tokenvalue(end) or self._prods.STRING == self._type(end):
  72.                 self.media.mediaText = mediatokens
  73.             
  74.             name = None
  75.             nameseq = self._tempSeq()
  76.             if self._prods.STRING == self._type(end):
  77.                 name = self._stringtokenvalue(end)
  78.                 (nametokens, end) = self._tokensupto2(tokenizer, blockstartonly = True, separateEnd = True)
  79.                 (wellformed, expected) = self._parse(None, nameseq, nametokens, { })
  80.                 if not wellformed:
  81.                     self._log.error(u'CSSMediaRule: Syntax Error: %s' % self._valuestr(cssText))
  82.                 
  83.             
  84.             if u'{' != self._tokenvalue(end):
  85.                 self._log.error(u'CSSMediaRule: No "{" found: %s' % self._valuestr(cssText))
  86.                 return None
  87.             (cssrulestokens, braceOrEOF) = self._tokensupto2(tokenizer, mediaendonly = True, separateEnd = True)
  88.             nonetoken = self._nexttoken(tokenizer, None)
  89.             if 'EOF' == self._type(braceOrEOF):
  90.                 cssrulestokens.append(braceOrEOF)
  91.                 braceOrEOF = ('CHAR', '}', 0, 0)
  92.                 self._log.debug(u'CSSMediaRule: Incomplete, adding "}".', token = braceOrEOF, neverraise = True)
  93.             
  94.             if u'}' != self._tokenvalue(braceOrEOF):
  95.                 self._log.error(u'CSSMediaRule: No "}" found.', token = braceOrEOF)
  96.             elif nonetoken:
  97.                 self._log.error(u'CSSMediaRule: Trailing content found.', token = nonetoken)
  98.             else:
  99.                 newcssrules = []
  100.                 new = {
  101.                     'wellformed': True }
  102.                 
  103.                 def ruleset(expected, seq, token, tokenizer):
  104.                     rule = cssutils.css.CSSStyleRule(parentRule = self)
  105.                     rule.cssText = (self._tokensupto2(tokenizer, token), namespaces)
  106.                     if rule.wellformed:
  107.                         seq.append(rule)
  108.                     
  109.                     return expected
  110.  
  111.                 
  112.                 def atrule(expected, seq, token, tokenizer):
  113.                     tokens = self._tokensupto2(tokenizer, token)
  114.                     atval = self._tokenvalue(token)
  115.                     if atval in ('@charset ', '@font-face', '@import', '@namespace', '@page', '@media'):
  116.                         self._log.error(u'CSSMediaRule: This rule is not allowed in CSSMediaRule - ignored: %s.' % self._valuestr(tokens), token = token, error = xml.dom.HierarchyRequestErr)
  117.                     else:
  118.                         rule = cssutils.css.CSSUnknownRule(parentRule = self, parentStyleSheet = self.parentStyleSheet)
  119.                         rule.cssText = tokens
  120.                         if rule.wellformed:
  121.                             seq.append(rule)
  122.                         
  123.                     return expected
  124.  
  125.                 
  126.                 def COMMENT(expected, seq, token, tokenizer = None):
  127.                     seq.append(cssutils.css.CSSComment([
  128.                         token]))
  129.                     return expected
  130.  
  131.                 tokenizer = (lambda .0: for t in .0:
  132. t)(cssrulestokens)
  133.                 (wellformed, expected) = self._parse(braceOrEOF, newcssrules, tokenizer, {
  134.                     'COMMENT': COMMENT,
  135.                     'CHARSET_SYM': atrule,
  136.                     'FONT_FACE_SYM': atrule,
  137.                     'IMPORT_SYM': atrule,
  138.                     'NAMESPACE_SYM': atrule,
  139.                     'PAGE_SYM': atrule,
  140.                     'MEDIA_SYM': atrule,
  141.                     'ATKEYWORD': atrule }, default = ruleset, new = new)
  142.                 if self.media.wellformed and wellformed:
  143.                     self.name = name
  144.                     self._setSeq(nameseq)
  145.                     del self._cssRules[:]
  146.                     for r in newcssrules:
  147.                         r._parentRule = self
  148.                         self._cssRules.append(r)
  149.                     
  150.                 else:
  151.                     self.media._absorb(oldmedia)
  152.  
  153.     cssText = property(_getCssText, _setCssText, doc = '(DOM) The parsable textual representation of this rule.')
  154.     
  155.     def _setName(self, name):
  156.         if isinstance(name, basestring) or name is None:
  157.             if not name:
  158.                 name = None
  159.             
  160.             self._name = name
  161.         else:
  162.             self._log.error(u'CSSImportRule: Not a valid name: %s' % name)
  163.  
  164.     name = property((lambda self: self._name), _setName, doc = u'An optional name for this media rule.')
  165.     media = property((lambda self: self._media), doc = u'(DOM readonly) A list of media types for this rule of type :class:`~cssutils.stylesheets.MediaList`.')
  166.     
  167.     def deleteRule(self, index):
  168.         self._checkReadonly()
  169.         if isinstance(index, cssrule.CSSRule):
  170.             for i, r in enumerate(self.cssRules):
  171.                 if index == r:
  172.                     index = i
  173.                     break
  174.                     continue
  175.             else:
  176.                 raise xml.dom.IndexSizeErr(u"CSSMediaRule: Not a rule in this rule'a cssRules list: %s" % index)
  177.         
  178.         try:
  179.             self._cssRules[index]._parentRule = None
  180.             del self._cssRules[index]
  181.         except IndexError:
  182.             raise xml.dom.IndexSizeErr(u'CSSMediaRule: %s is not a valid index in the rulelist of length %i' % (index, self._cssRules.length))
  183.  
  184.  
  185.     
  186.     def add(self, rule):
  187.         self.insertRule(rule, index = None)
  188.  
  189.     
  190.     def insertRule(self, rule, index = None):
  191.         self._checkReadonly()
  192.         if index is None:
  193.             index = len(self._cssRules)
  194.         elif index < 0 or index > self._cssRules.length:
  195.             raise xml.dom.IndexSizeErr(u'CSSMediaRule: Invalid index %s for CSSRuleList with a length of %s.' % (index, self._cssRules.length))
  196.         
  197.         if isinstance(rule, basestring):
  198.             tempsheet = cssutils.css.CSSStyleSheet()
  199.             tempsheet.cssText = rule
  200.             if (len(tempsheet.cssRules) != 1 or tempsheet.cssRules) and not isinstance(tempsheet.cssRules[0], cssutils.css.CSSRule):
  201.                 self._log.error(u'CSSMediaRule: Invalid Rule: %s' % rule)
  202.                 return None
  203.             rule = tempsheet.cssRules[0]
  204.         elif isinstance(rule, cssutils.css.CSSRuleList):
  205.             for i, r in enumerate(rule):
  206.                 self.insertRule(r, index + i)
  207.             
  208.             return index
  209.         if not isinstance(rule, cssutils.css.CSSRule):
  210.             self._log.error(u'CSSMediaRule: Not a CSSRule: %s' % rule)
  211.             return None
  212.         if isinstance(rule, cssutils.css.CSSCharsetRule) and isinstance(rule, cssutils.css.CSSFontFaceRule) and isinstance(rule, cssutils.css.CSSImportRule) and isinstance(rule, cssutils.css.CSSNamespaceRule) and isinstance(rule, cssutils.css.CSSPageRule) or isinstance(rule, CSSMediaRule):
  213.             self._log.error(u'CSSMediaRule: This type of rule is not allowed here: %s' % rule.cssText, error = xml.dom.HierarchyRequestErr)
  214.             return None
  215.         self._cssRules.insert(index, rule)
  216.         rule._parentRule = self
  217.         rule._parentStyleSheet = self.parentStyleSheet
  218.         return index
  219.  
  220.     type = property((lambda self: self.MEDIA_RULE), doc = 'The type of this rule, as defined by a CSSRule type constant.')
  221.     wellformed = property((lambda self: self.media.wellformed))
  222.  
  223.