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