home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_1569 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  10.2 KB  |  252 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. __all__ = [
  5.     'CSSImportRule']
  6. __docformat__ = 'restructuredtext'
  7. __version__ = '$Id: cssimportrule.py 1941 2010-03-23 20:15:46Z cthedot $'
  8. import cssrule
  9. import cssutils
  10. import os
  11. import urlparse
  12. import xml.dom as xml
  13.  
  14. class CSSImportRule(cssrule.CSSRule):
  15.     
  16.     def __init__(self, href = None, mediaText = u'all', name = None, parentRule = None, parentStyleSheet = None, readonly = False):
  17.         super(CSSImportRule, self).__init__(parentRule = parentRule, parentStyleSheet = parentStyleSheet)
  18.         self._atkeyword = u'@import'
  19.         self._styleSheet = None
  20.         self._media = cssutils.stylesheets.MediaList()
  21.         if mediaText:
  22.             self._media.mediaText = mediaText
  23.         
  24.         seq = self._tempSeq()
  25.         seq.append(None, 'href')
  26.         seq.append(self._media, 'media')
  27.         seq.append(None, 'name')
  28.         self._setSeq(seq)
  29.         self.name = name
  30.         self.hreftype = None
  31.         self.href = href
  32.         self._readonly = readonly
  33.  
  34.     
  35.     def __repr__(self):
  36.         if self._usemedia:
  37.             mediaText = self.media.mediaText
  38.         else:
  39.             mediaText = None
  40.         return 'cssutils.css.%s(href=%r, mediaText=%r, name=%r)' % (self.__class__.__name__, self.href, self.media.mediaText, self.name)
  41.  
  42.     
  43.     def __str__(self):
  44.         if self._usemedia:
  45.             mediaText = self.media.mediaText
  46.         else:
  47.             mediaText = None
  48.         return '<cssutils.css.%s object href=%r mediaText=%r name=%r at 0x%x>' % (self.__class__.__name__, self.href, mediaText, self.name, id(self))
  49.  
  50.     _usemedia = property((lambda self: self.media.mediaText not in (u'', u'all')), doc = 'if self._media is used (or simply empty)')
  51.     
  52.     def _getCssText(self):
  53.         return cssutils.ser.do_CSSImportRule(self)
  54.  
  55.     
  56.     def _setCssText(self, cssText):
  57.         super(CSSImportRule, self)._setCssText(cssText)
  58.         tokenizer = self._tokenize2(cssText)
  59.         attoken = self._nexttoken(tokenizer, None)
  60.         if self._type(attoken) != self._prods.IMPORT_SYM:
  61.             self._log.error(u'CSSImportRule: No CSSImportRule found: %s' % self._valuestr(cssText), error = xml.dom.InvalidModificationErr)
  62.         else:
  63.             oldmedia = cssutils.stylesheets.MediaList()
  64.             oldmedia._absorb(self.media)
  65.             new = {
  66.                 'keyword': self._tokenvalue(attoken),
  67.                 'href': None,
  68.                 'hreftype': None,
  69.                 'media': None,
  70.                 'name': None,
  71.                 'wellformed': True }
  72.             
  73.             def _CSSImportRule__doname(seq, token):
  74.                 new['name'] = self._stringtokenvalue(token)
  75.                 seq.append(new['name'], 'name')
  76.                 return ';'
  77.  
  78.             
  79.             def _string(expected, seq, token, tokenizer = (None, (None, None), None)):
  80.                 if 'href' == expected:
  81.                     new['href'] = self._stringtokenvalue(token)
  82.                     new['hreftype'] = 'string'
  83.                     seq.append(new['href'], 'href')
  84.                     return 'media name ;'
  85.                 if 'name' in expected:
  86.                     return _CSSImportRule__doname(seq, token)
  87.                 new['wellformed'] = False
  88.                 self._log.error(u'CSSImportRule: Unexpected string.', token)
  89.                 return expected
  90.  
  91.             
  92.             def _uri(expected, seq, token, tokenizer = (None, None)):
  93.                 if 'href' == expected:
  94.                     uri = self._uritokenvalue(token)
  95.                     new['hreftype'] = 'uri'
  96.                     new['href'] = uri
  97.                     seq.append(new['href'], 'href')
  98.                     return 'media name ;'
  99.                 new['wellformed'] = False
  100.                 self._log.error(u'CSSImportRule: Unexpected URI.', token)
  101.                 return expected
  102.  
  103.             
  104.             def _ident(expected, seq, token, tokenizer = (None, None, None, None, None)):
  105.                 if expected.startswith('media'):
  106.                     mediatokens = self._tokensupto2(tokenizer, importmediaqueryendonly = True)
  107.                     mediatokens.insert(0, token)
  108.                     last = mediatokens.pop()
  109.                     lastval = self._tokenvalue(last)
  110.                     lasttyp = self._type(last)
  111.                     if lastval != u';' and lasttyp not in ('EOF', self._prods.STRING):
  112.                         new['wellformed'] = False
  113.                         self._log.error(u'CSSImportRule: No ";" found: %s' % self._valuestr(cssText), token = token)
  114.                     
  115.                     self.media.mediaText = mediatokens
  116.                     if self.media.wellformed:
  117.                         new['media'] = self.media
  118.                         seq.append(self.media, 'media')
  119.                     else:
  120.                         self.media._absorb(oldmedia)
  121.                         new['wellformed'] = False
  122.                         self._log.error(u'CSSImportRule: Invalid MediaList: %s' % self._valuestr(cssText), token = token)
  123.                     if lasttyp == self._prods.STRING:
  124.                         return _CSSImportRule__doname(seq, last)
  125.                     return 'EOF'
  126.                 expected.startswith('media')
  127.                 new['wellformed'] = False
  128.                 self._log.error(u'CSSImportRule: Unexpected ident.', token)
  129.                 return expected
  130.  
  131.             
  132.             def _char(expected, seq, token, tokenizer = (None, None)):
  133.                 val = self._tokenvalue(token)
  134.                 if expected.endswith(';') and u';' == val:
  135.                     return 'EOF'
  136.                 new['wellformed'] = False
  137.                 self._log.error(u'CSSImportRule: Unexpected char.', token)
  138.                 return expected
  139.  
  140.             newseq = self._tempSeq()
  141.             (wellformed, expected) = self._parse(expected = 'href', seq = newseq, tokenizer = tokenizer, productions = {
  142.                 'STRING': _string,
  143.                 'URI': _uri,
  144.                 'IDENT': _ident,
  145.                 'CHAR': _char }, new = new)
  146.             if wellformed:
  147.                 pass
  148.             wellformed = new['wellformed']
  149.             if not new['href']:
  150.                 wellformed = False
  151.                 self._log.error(u'CSSImportRule: No href found: %s' % self._valuestr(cssText))
  152.             
  153.             if expected != 'EOF':
  154.                 wellformed = False
  155.                 self._log.error(u'CSSImportRule: No ";" found: %s' % self._valuestr(cssText))
  156.             
  157.             if wellformed:
  158.                 self.atkeyword = new['keyword']
  159.                 self.hreftype = new['hreftype']
  160.                 if not new['media']:
  161.                     self.media.mediaText = u'all'
  162.                     newseq.append(self.media, 'media')
  163.                 
  164.                 self.name = new['name']
  165.                 self.href = new['href']
  166.                 self._setSeq(newseq)
  167.             
  168.  
  169.     cssText = property(fget = _getCssText, fset = _setCssText, doc = '(DOM) The parsable textual representation of this rule.')
  170.     
  171.     def _setHref(self, href):
  172.         self._href = href
  173.         for i, item in enumerate(self.seq):
  174.             val = item.value
  175.             type_ = item.type
  176.             if 'href' == type_:
  177.                 self._seq[i] = (href, type_, item.line, item.col)
  178.                 break
  179.                 continue
  180.         
  181.         importedSheet = cssutils.css.CSSStyleSheet(media = self.media, ownerRule = self, title = self.name)
  182.         if href and self.parentStyleSheet:
  183.             parentHref = self.parentStyleSheet.href
  184.             if parentHref is None:
  185.                 parentHref = cssutils.helper.path2url(os.getcwd()) + '/'
  186.             
  187.             fullhref = urlparse.urljoin(parentHref, self.href)
  188.             
  189.             try:
  190.                 (usedEncoding, enctype, cssText) = self.parentStyleSheet._resolveImport(fullhref)
  191.                 if cssText is None:
  192.                     raise IOError('Cannot read Stylesheet.')
  193.                 cssText is None
  194.                 (encodingOverride, encoding) = (None, None)
  195.                 if enctype == 0:
  196.                     encodingOverride = usedEncoding
  197.                 elif enctype < enctype:
  198.                     pass
  199.                 elif enctype < 5:
  200.                     encoding = usedEncoding
  201.                 
  202.                 importedSheet._href = fullhref
  203.                 importedSheet._setFetcher(self.parentStyleSheet._fetcher)
  204.                 importedSheet._setCssTextWithEncodingOverride(cssText, encodingOverride = encodingOverride, encoding = encoding)
  205.             except (OSError, IOError, ValueError):
  206.                 e = None
  207.                 self._log.warn(u'CSSImportRule: While processing imported style sheet href=%r: %r' % (self.href, e), neverraise = True)
  208.  
  209.             self.hrefFound = True
  210.             self._styleSheet = importedSheet
  211.         else:
  212.             self._styleSheet = importedSheet
  213.             self.hrefFound = False
  214.  
  215.     _href = None
  216.     href = property((lambda self: self._href), _setHref, doc = u'Location of the style sheet to be imported.')
  217.     media = property((lambda self: self._media), doc = u'(DOM readonly) A list of media types for this rule of type :class:`~cssutils.stylesheets.MediaList`.')
  218.     
  219.     def _setName(self, name):
  220.         if name is None or isinstance(name, basestring):
  221.             if not name:
  222.                 name = None
  223.             
  224.             self._name = name
  225.             for i, item in enumerate(self.seq):
  226.                 val = item.value
  227.                 typ = item.type
  228.                 if 'name' == typ:
  229.                     self._seq[i] = (name, typ, item.line, item.col)
  230.                     break
  231.                     continue
  232.             
  233.             if self.styleSheet:
  234.                 self.styleSheet.title = name
  235.             
  236.         else:
  237.             self._log.error(u'CSSImportRule: Not a valid name: %s' % name)
  238.  
  239.     name = property((lambda self: self._name), _setName, doc = u'An optional name for the imported sheet.')
  240.     styleSheet = property((lambda self: self._styleSheet), doc = '(readonly) The style sheet referred to by this rule.')
  241.     type = property((lambda self: self.IMPORT_RULE), doc = 'The type of this rule, as defined by a CSSRule type constant.')
  242.     
  243.     def _getWellformed(self):
  244.         if self._usemedia:
  245.             if self.href:
  246.                 pass
  247.             return bool(self.media.wellformed)
  248.         return bool(self.href)
  249.  
  250.     wellformed = property(_getWellformed)
  251.  
  252.