home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_1601 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  22.6 KB  |  715 lines

  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. __all__ = [
  5.     'CSSSerializer',
  6.     'Preferences']
  7. __docformat__ = 'restructuredtext'
  8. __version__ = '$Id: serialize.py 1927 2010-03-20 21:52:02Z cthedot $'
  9. from cssutils.helper import normalize
  10. import codecs
  11. import cssutils
  12. import helper
  13. import re
  14. import xml.dom as xml
  15.  
  16. def _escapecss(e):
  17.     s = e.object[e.start:e.end]
  18.     return ([]([ u'\\%s ' % str(hex(ord(x)))[2:].upper() for x in s ]), e.end)
  19.  
  20. codecs.register_error('escapecss', _escapecss)
  21.  
  22. class Preferences(object):
  23.     
  24.     def __init__(self, **initials):
  25.         self.useDefaults()
  26.         for key, value in initials.items():
  27.             if value:
  28.                 self.__setattr__(key, value)
  29.                 continue
  30.         
  31.  
  32.     
  33.     def __repr__(self):
  34.         return u', '.join % ([], []([ '\n    %s=%r' % (p, self.__getattribute__(p)) for p in self.__dict__ ]))
  35.  
  36.     
  37.     def __str__(self):
  38.         return u' '.join % ([], []([ '%s=%r' % (p, self.__getattribute__(p)) for p in self.__dict__ ]), id(self))
  39.  
  40.     
  41.     def useDefaults(self):
  42.         self.defaultAtKeyword = True
  43.         self.defaultPropertyName = True
  44.         self.defaultPropertyPriority = True
  45.         self.importHrefFormat = None
  46.         self.indent = u'    '
  47.         self.indentSpecificities = False
  48.         self.keepAllProperties = True
  49.         self.keepComments = True
  50.         self.keepEmptyRules = False
  51.         self.keepUnkownAtRules = True
  52.         self.keepUsedNamespaceRulesOnly = False
  53.         self.lineNumbers = False
  54.         self.lineSeparator = u'\n'
  55.         self.listItemSpacer = u' '
  56.         self.normalizedVarNames = True
  57.         self.omitLastSemicolon = True
  58.         self.paranthesisSpacer = u' '
  59.         self.propertyNameSpacer = u' '
  60.         self.resolveVariables = False
  61.         self.selectorCombinatorSpacer = u' '
  62.         self.spacer = u' '
  63.         self.validOnly = False
  64.  
  65.     
  66.     def useMinified(self):
  67.         self.importHrefFormat = 'string'
  68.         self.indent = u''
  69.         self.keepComments = False
  70.         self.keepEmptyRules = False
  71.         self.keepUnkownAtRules = False
  72.         self.keepUsedNamespaceRulesOnly = True
  73.         self.lineNumbers = False
  74.         self.lineSeparator = u''
  75.         self.listItemSpacer = u''
  76.         self.omitLastSemicolon = True
  77.         self.paranthesisSpacer = u''
  78.         self.propertyNameSpacer = u''
  79.         self.selectorCombinatorSpacer = u''
  80.         self.spacer = u''
  81.         self.validOnly = False
  82.  
  83.  
  84.  
  85. class Out(object):
  86.     
  87.     def __init__(self, ser):
  88.         self.ser = ser
  89.         self.out = []
  90.  
  91.     
  92.     def _remove_last_if_S(self):
  93.         if self.out and not self.out[-1].strip():
  94.             del self.out[-1]
  95.         
  96.  
  97.     
  98.     def append(self, val, typ = None, space = True, keepS = False, indent = False, lineSeparator = False):
  99.         prefspace = self.ser.prefs.spacer
  100.         if val or typ in ('STRING', 'URI'):
  101.             if 'COMMENT' == typ:
  102.                 if self.ser.prefs.keepComments:
  103.                     val = val.cssText
  104.                 else:
  105.                     return None
  106.             self.ser.prefs.keepComments
  107.             if hasattr(val, 'cssText'):
  108.                 val = val.cssText
  109.             elif 'S' == typ and not keepS:
  110.                 return None
  111.             if 'S' == typ and keepS:
  112.                 val = u' '
  113.             elif typ in ('NUMBER', 'DIMENSION', 'PERCENTAGE') and val == '0':
  114.                 if self.out and self.out[-1] in u'+-':
  115.                     del self.out[-1]
  116.                 
  117.             elif 'STRING' == typ:
  118.                 if val is None:
  119.                     return None
  120.                 val = helper.string(val)
  121.                 if not prefspace:
  122.                     self._remove_last_if_S()
  123.                 
  124.             elif 'URI' == typ:
  125.                 val = helper.uri(val)
  126.             elif 'HASH' == typ:
  127.                 val = self.ser._hash(val)
  128.             elif val in u'+>~,:{;)]/':
  129.                 self._remove_last_if_S()
  130.             
  131.             if indent:
  132.                 self.out.append(self.ser._indentblock(val, self.ser._level + 1))
  133.             elif val.endswith(u' '):
  134.                 self._remove_last_if_S()
  135.             
  136.             self.out.append(val)
  137.             if lineSeparator:
  138.                 pass
  139.             elif val in u'+>~':
  140.                 self.out.insert(-1, self.ser.prefs.selectorCombinatorSpacer)
  141.                 self.out.append(self.ser.prefs.selectorCombinatorSpacer)
  142.             elif u')' == val and not keepS:
  143.                 self.out.append(u' ')
  144.             elif u',' == val:
  145.                 self.out.append(self.ser.prefs.listItemSpacer)
  146.             elif u':' == val:
  147.                 self.out.append(self.ser.prefs.propertyNameSpacer)
  148.             elif u'{' == val:
  149.                 self.out.insert(-1, self.ser.prefs.paranthesisSpacer)
  150.                 self.out.append(self.ser.prefs.lineSeparator)
  151.             elif u';' == val:
  152.                 self.out.append(self.ser.prefs.lineSeparator)
  153.             elif val not in u'}[]()/' and typ != 'FUNCTION' and space:
  154.                 self.out.append(self.ser.prefs.spacer)
  155.                 if typ != 'STRING' and not (self.ser.prefs.spacer) and self.out and not self.out[-1].endswith(u' '):
  156.                     self.out.append(u' ')
  157.                 
  158.             
  159.         
  160.  
  161.     
  162.     def value(self, delim = u'', end = None, keepS = False):
  163.         if not keepS:
  164.             self._remove_last_if_S()
  165.         
  166.         if end:
  167.             self.out.append(end)
  168.         
  169.         return delim.join(self.out)
  170.  
  171.  
  172.  
  173. class CSSSerializer(object):
  174.     
  175.     def __init__(self, prefs = None):
  176.         if not prefs:
  177.             prefs = Preferences()
  178.         
  179.         self.prefs = prefs
  180.         self._level = 0
  181.         self._selectors = []
  182.         self._selectorlevel = 0
  183.  
  184.     
  185.     def _atkeyword(self, rule, default):
  186.         if self.prefs.defaultAtKeyword:
  187.             return default
  188.         return rule.atkeyword
  189.  
  190.     
  191.     def _indentblock(self, text, level):
  192.         if not self.prefs.lineSeparator:
  193.             return text
  194.         return []([ u'%s%s' % (level * self.prefs.indent, line) for line in text.split(self.prefs.lineSeparator) ])
  195.  
  196.     
  197.     def _propertyname(self, property, actual):
  198.         if self.prefs.defaultPropertyName and not (self.prefs.keepAllProperties):
  199.             return property.name
  200.         return actual
  201.  
  202.     
  203.     def _linenumnbers(self, text):
  204.         if self.prefs.lineNumbers:
  205.             pad = len(str(text.count(self.prefs.lineSeparator) + 1))
  206.             out = []
  207.             for i, line in enumerate(text.split(self.prefs.lineSeparator)):
  208.                 out.append(u'%*i: %s' % (pad, i + 1, line))
  209.             
  210.             text = self.prefs.lineSeparator.join(out)
  211.         
  212.         return text
  213.  
  214.     
  215.     def _hash(self, val, type_ = None):
  216.         if len(val) == 7 and val[1] == val[2] and val[3] == val[4] and val[5] == val[6]:
  217.             return u'#%s%s%s' % (val[1], val[3], val[5])
  218.         return val
  219.  
  220.     
  221.     def _valid(self, x):
  222.         if not (self.prefs.validOnly) and self.prefs.validOnly:
  223.             pass
  224.         return x.valid
  225.  
  226.     
  227.     def do_CSSStyleSheet(self, stylesheet):
  228.         useduris = stylesheet._getUsedURIs()
  229.         out = []
  230.         for rule in stylesheet.cssRules:
  231.             if self.prefs.keepUsedNamespaceRulesOnly and rule.NAMESPACE_RULE == rule.type and rule.namespaceURI not in useduris:
  232.                 if rule.prefix or None not in useduris:
  233.                     continue
  234.                 
  235.             cssText = rule.cssText
  236.             if cssText:
  237.                 out.append(cssText)
  238.                 continue
  239.         
  240.         text = self._linenumnbers(self.prefs.lineSeparator.join(out))
  241.         
  242.         try:
  243.             encoding = stylesheet.cssRules[0].encoding
  244.         except (IndexError, AttributeError):
  245.             encoding = 'UTF-8'
  246.  
  247.         return text.encode(encoding, 'escapecss')
  248.  
  249.     
  250.     def do_CSSComment(self, rule):
  251.         if rule._cssText and self.prefs.keepComments:
  252.             return rule._cssText
  253.         return u''
  254.  
  255.     
  256.     def do_CSSCharsetRule(self, rule):
  257.         if rule.wellformed:
  258.             return u'@charset %s;' % helper.string(rule.encoding)
  259.         return u''
  260.  
  261.     
  262.     def do_CSSVariablesRule(self, rule):
  263.         variablesText = rule.variables.cssText
  264.         if variablesText and rule.wellformed and not (self.prefs.resolveVariables):
  265.             out = Out(self)
  266.             out.append(self._atkeyword(rule, u'@variables'))
  267.             for item in rule.seq:
  268.                 out.append(item.value, item.type)
  269.             
  270.             out.append(u'{')
  271.             out.append(u'%s%s}' % (variablesText, self.prefs.lineSeparator), indent = 1)
  272.             return out.value()
  273.         return u''
  274.  
  275.     
  276.     def do_CSSFontFaceRule(self, rule):
  277.         styleText = self.do_css_CSSStyleDeclaration(rule.style)
  278.         if styleText and rule.wellformed:
  279.             out = Out(self)
  280.             out.append(self._atkeyword(rule, u'@font-face'))
  281.             for item in rule.seq:
  282.                 out.append(item.value, item.type)
  283.             
  284.             out.append(u'{')
  285.             out.append(u'%s%s}' % (styleText, self.prefs.lineSeparator), indent = 1)
  286.             return out.value()
  287.         return u''
  288.  
  289.     
  290.     def do_CSSImportRule(self, rule):
  291.         if rule.wellformed:
  292.             out = Out(self)
  293.             out.append(self._atkeyword(rule, u'@import'))
  294.             for item in rule.seq:
  295.                 typ = item.type
  296.                 val = item.value
  297.                 if 'href' == typ:
  298.                     if (self.prefs.importHrefFormat == 'string' or self.prefs.importHrefFormat != 'uri') and rule.hreftype == 'string':
  299.                         out.append(val, 'STRING')
  300.                     else:
  301.                         out.append(val, 'URI')
  302.                 rule.hreftype == 'string'
  303.                 if 'media' == typ:
  304.                     mediaText = self.do_stylesheets_medialist(val)
  305.                     if mediaText and mediaText != u'all':
  306.                         out.append(mediaText)
  307.                     
  308.                 mediaText != u'all'
  309.                 if 'name' == typ:
  310.                     out.append(val, 'STRING')
  311.                     continue
  312.                 out.append(val, typ)
  313.             
  314.             return out.value(end = u';')
  315.         return u''
  316.  
  317.     
  318.     def do_CSSNamespaceRule(self, rule):
  319.         if rule.wellformed:
  320.             out = Out(self)
  321.             out.append(self._atkeyword(rule, u'@namespace'))
  322.             for item in rule.seq:
  323.                 typ = item.type
  324.                 val = item.value
  325.                 if 'namespaceURI' == typ:
  326.                     out.append(val, 'STRING')
  327.                     continue
  328.                 out.append(val, typ)
  329.             
  330.             return out.value(end = u';')
  331.         return u''
  332.  
  333.     
  334.     def do_CSSMediaRule(self, rule):
  335.         if not rule.media.wellformed:
  336.             return u''
  337.         out = [
  338.             self._atkeyword(rule, u'@media')]
  339.         if not len(self.prefs.spacer):
  340.             out.append(u' ')
  341.         else:
  342.             out.append(self.prefs.spacer)
  343.         out.append(self.do_stylesheets_medialist(rule.media))
  344.         if rule.name:
  345.             out.append(self.prefs.spacer)
  346.             nameout = Out(self)
  347.             nameout.append(helper.string(rule.name))
  348.             for item in rule.seq:
  349.                 nameout.append(item.value, item.type)
  350.             
  351.             out.append(nameout.value())
  352.         
  353.         out.append(self.prefs.paranthesisSpacer)
  354.         out.append(u'{')
  355.         out.append(self.prefs.lineSeparator)
  356.         rulesout = []
  357.         for r in rule.cssRules:
  358.             rtext = r.cssText
  359.             if rtext:
  360.                 rulesout.append(self._indentblock(rtext, self._level + 1))
  361.                 rulesout.append(self.prefs.lineSeparator)
  362.                 continue
  363.         
  364.         if not (self.prefs.keepEmptyRules) and not u''.join(rulesout).strip():
  365.             return u''
  366.         out.extend(rulesout)
  367.         out.append(u'%s}' % (self._level + 1) * self.prefs.indent)
  368.         return u''.join(out)
  369.  
  370.     
  371.     def do_CSSPageRule(self, rule):
  372.         styleText = self.do_css_CSSStyleDeclaration(rule.style)
  373.         if styleText and rule.wellformed:
  374.             out = Out(self)
  375.             out.append(self._atkeyword(rule, u'@page'))
  376.             out.append(rule.selectorText)
  377.             out.append(u'{')
  378.             out.append(u'%s%s}' % (styleText, self.prefs.lineSeparator), indent = 1)
  379.             return out.value()
  380.         return u''
  381.  
  382.     
  383.     def do_CSSPageRuleSelector(self, seq):
  384.         out = Out(self)
  385.         for item in seq:
  386.             if item.type == 'IDENT':
  387.                 out.append(item.value, item.type, space = False)
  388.                 continue
  389.             out.append(item.value, item.type)
  390.         
  391.         return out.value()
  392.  
  393.     
  394.     def do_CSSUnknownRule(self, rule):
  395.         if rule.wellformed and self.prefs.keepUnkownAtRules:
  396.             out = Out(self)
  397.             out.append(rule.atkeyword)
  398.             stacks = []
  399.             for item in rule.seq:
  400.                 typ = item.type
  401.                 val = item.value
  402.                 if u'}' == val:
  403.                     stackblock = stacks.pop().value()
  404.                     if stackblock:
  405.                         val = self._indentblock(stackblock + self.prefs.lineSeparator + val, min(1, len(stacks) + 1))
  406.                     else:
  407.                         val = self._indentblock(val, min(1, len(stacks) + 1))
  408.                 
  409.                 if stacks:
  410.                     stacks[-1].append(val, typ)
  411.                 else:
  412.                     out.append(val, typ)
  413.                 if u'{' == val:
  414.                     stacks.append(Out(self))
  415.                     continue
  416.             
  417.             return out.value()
  418.         return u''
  419.  
  420.     
  421.     def do_CSSStyleRule(self, rule):
  422.         selectorText = self.do_css_SelectorList(rule.selectorList)
  423.         if not selectorText or not (rule.wellformed):
  424.             return u''
  425.         self._level += 1
  426.         styleText = u''
  427.         
  428.         try:
  429.             styleText = self.do_css_CSSStyleDeclaration(rule.style)
  430.         finally:
  431.             self._level -= 1
  432.  
  433.         if not styleText:
  434.             if self.prefs.keepEmptyRules:
  435.                 return u'%s%s{}' % (selectorText, self.prefs.paranthesisSpacer)
  436.         else:
  437.             return self._indentblock(u'%s%s{%s%s%s%s}' % (selectorText, self.prefs.paranthesisSpacer, self.prefs.lineSeparator, self._indentblock(styleText, self._level + 1), self.prefs.lineSeparator, (self._level + 1) * self.prefs.indent), self._selectorlevel)
  438.         return self.prefs.keepEmptyRules
  439.  
  440.     
  441.     def do_css_SelectorList(self, selectorlist):
  442.         if selectorlist.wellformed:
  443.             out = []
  444.             for part in selectorlist.seq:
  445.                 if isinstance(part, cssutils.css.Selector):
  446.                     out.append(part.selectorText)
  447.                     continue
  448.                 out.append(part)
  449.             
  450.             sep = u',%s' % self.prefs.listItemSpacer
  451.             return sep.join(out)
  452.         return u''
  453.  
  454.     
  455.     def do_css_Selector(self, selector):
  456.         if selector.wellformed:
  457.             out = Out(self)
  458.             DEFAULTURI = selector._namespaces.get('', None)
  459.             for item in selector.seq:
  460.                 typ = item.type
  461.                 val = item.value
  462.                 if type(val) == tuple:
  463.                     (namespaceURI, name) = val
  464.                     if (DEFAULTURI == namespaceURI or not DEFAULTURI) and namespaceURI is None:
  465.                         out.append(name, typ, space = False)
  466.                     elif namespaceURI == cssutils._ANYNS:
  467.                         prefix = u'*'
  468.                     else:
  469.                         
  470.                         try:
  471.                             prefix = selector._namespaces.prefixForNamespaceURI(namespaceURI)
  472.                         except IndexError:
  473.                             prefix = u''
  474.  
  475.                     out.append(u'%s|%s' % (prefix, name), typ, space = False)
  476.                     continue
  477.                 out.append(val, typ, space = False, keepS = True)
  478.             
  479.             return out.value()
  480.         return u''
  481.  
  482.     
  483.     def do_css_CSSVariablesDeclaration(self, variables):
  484.         if len(variables.seq) > 0:
  485.             out = Out(self)
  486.             lastitem = len(variables.seq) - 1
  487.             for i, item in enumerate(variables.seq):
  488.                 type_ = item.type
  489.                 val = item.value
  490.                 if u'var' == type_:
  491.                     (name, cssvalue) = val
  492.                     if self.prefs.normalizedVarNames:
  493.                         name = normalize(name)
  494.                     
  495.                     out.append(name)
  496.                     out.append(u':')
  497.                     out.append(cssvalue.cssText)
  498.                     if i < lastitem or not (self.prefs.omitLastSemicolon):
  499.                         out.append(u';')
  500.                     
  501.                 not (self.prefs.omitLastSemicolon)
  502.                 if isinstance(val, cssutils.css.CSSComment):
  503.                     out.append(val, 'COMMENT')
  504.                     out.append(self.prefs.lineSeparator)
  505.                     continue
  506.                 out.append(val.cssText, type_)
  507.                 out.append(self.prefs.lineSeparator)
  508.             
  509.             return out.value().strip()
  510.         return u''
  511.  
  512.     
  513.     def do_css_CSSStyleDeclaration(self, style, separator = None):
  514.         if len(style.seq) > 0:
  515.             if separator is None:
  516.                 separator = self.prefs.lineSeparator
  517.             
  518.             out = []
  519.             for i, item in enumerate(seq):
  520.                 typ = item.type
  521.                 val = item.value
  522.                 if isinstance(val, cssutils.css.CSSComment):
  523.                     if self.prefs.keepComments:
  524.                         out.append(val.cssText)
  525.                         out.append(separator)
  526.                     
  527.                 self.prefs.keepComments
  528.                 if isinstance(val, cssutils.css.Property):
  529.                     if val.cssText:
  530.                         out.append(val.cssText)
  531.                         if not self.prefs.omitLastSemicolon and i == len(seq) - 1:
  532.                             out.append(u';')
  533.                         
  534.                         out.append(separator)
  535.                     
  536.                 val.cssText
  537.                 if isinstance(val, cssutils.css.CSSUnknownRule):
  538.                     out.append(val.cssText)
  539.                     out.append(separator)
  540.                     continue
  541.                 [] if self.prefs.keepAllProperties else []
  542.                 out.append(val)
  543.                 out.append(separator)
  544.             
  545.             if out and out[-1] == separator:
  546.                 del out[-1]
  547.             
  548.             return u''.join(out)
  549.         return u''
  550.  
  551.     
  552.     def do_Property(self, property):
  553.         out = []
  554.         if property.seqs[0] and property.wellformed and self._valid(property):
  555.             (nameseq, cssvalue, priorityseq) = property.seqs
  556.             for part in nameseq:
  557.                 if hasattr(part, 'cssText'):
  558.                     out.append(part.cssText)
  559.                     continue
  560.                 if property.literalname == part:
  561.                     out.append(self._propertyname(property, part))
  562.                     continue
  563.                 out.append(part)
  564.             
  565.             if out:
  566.                 if (not (property._mediaQuery) or property._mediaQuery) and cssvalue.cssText:
  567.                     out.append(u':')
  568.                     out.append(self.prefs.propertyNameSpacer)
  569.                 
  570.             out.append(cssvalue.cssText)
  571.             if out and priorityseq:
  572.                 out.append(u' ')
  573.                 for part in priorityseq:
  574.                     if hasattr(part, 'cssText'):
  575.                         out.append(part.cssText)
  576.                         continue
  577.                     if part == property.literalpriority and self.prefs.defaultPropertyPriority:
  578.                         out.append(property.priority)
  579.                         continue
  580.                     out.append(part)
  581.                 
  582.             
  583.         
  584.         return u''.join(out)
  585.  
  586.     
  587.     def do_Property_priority(self, priorityseq):
  588.         out = []
  589.         for part in priorityseq:
  590.             if hasattr(part, 'cssText'):
  591.                 out.append(u' ')
  592.                 out.append(part.cssText)
  593.                 out.append(u' ')
  594.                 continue
  595.             out.append(part)
  596.         
  597.         return u''.join(out).strip()
  598.  
  599.     
  600.     def do_css_CSSValue(self, cssvalue):
  601.         if not cssvalue:
  602.             return u''
  603.         out = Out(self)
  604.         for item in cssvalue.seq:
  605.             type_ = item.type
  606.             val = item.value
  607.             if hasattr(val, 'cssText'):
  608.                 out.append(val.cssText, type_)
  609.                 continue
  610.             cssvalue
  611.             if val and val[0] == val[-1] and val[0] in '\'"':
  612.                 val = helper.string(val[1:-1])
  613.             
  614.             out.append(val, type_)
  615.         
  616.         return out.value()
  617.  
  618.     
  619.     def do_css_CSSPrimitiveValue(self, cssvalue):
  620.         if not cssvalue:
  621.             return u''
  622.         out = Out(self)
  623.         for item in cssvalue.seq:
  624.             type_ = item.type
  625.             val = item.value
  626.             if type_ in ('DIMENSION', 'NUMBER', 'PERCENTAGE'):
  627.                 (n, d) = cssvalue._getNumDim(val)
  628.                 if 0 == n:
  629.                     if cssvalue.primitiveType in cssvalue._lengthtypes:
  630.                         val = u'0'
  631.                     else:
  632.                         val = u'0' + d
  633.                 else:
  634.                     val = unicode(n) + d
  635.             
  636.             out.append(val, type_)
  637.         
  638.         return out.value()
  639.  
  640.     
  641.     def do_css_CSSVariable(self, variable):
  642.         if not variable:
  643.             return u''
  644.         out = Out(self)
  645.         if not (self.prefs.resolveVariables) or not (variable.value):
  646.             for item in variable.seq:
  647.                 type_ = item.type
  648.                 val = item.value
  649.                 out.append(val, type_)
  650.             
  651.         else:
  652.             out.append(variable.value)
  653.         return out.value()
  654.  
  655.     
  656.     def do_css_RGBColor(self, cssvalue):
  657.         if not cssvalue:
  658.             return u''
  659.         out = Out(self)
  660.         unary = None
  661.         for item in cssvalue.seq:
  662.             type_ = item.type
  663.             val = item.value
  664.             out.append(val, type_)
  665.         
  666.         return out.value()
  667.  
  668.     
  669.     def do_stylesheets_medialist(self, medialist):
  670.         if len(medialist) == 0:
  671.             return u'all'
  672.         sep = u',%s' % self.prefs.listItemSpacer
  673.         return sep.join((lambda .0: for mq in .0:
  674. mq.mediaText)(medialist))
  675.  
  676.     
  677.     def do_stylesheets_mediaquery(self, mediaquery):
  678.         if mediaquery.wellformed:
  679.             out = []
  680.             for part in mediaquery.seq:
  681.                 if isinstance(part, cssutils.css.Property):
  682.                     out.append(u'(%s)' % part.cssText)
  683.                     continue
  684.                 if hasattr(part, 'cssText'):
  685.                     out.append(part.cssText)
  686.                     continue
  687.                 out.append(part)
  688.             
  689.             return u' '.join(out)
  690.         return u''
  691.  
  692.     
  693.     def do_css_ExpressionValue(self, cssvalue):
  694.         if not cssvalue:
  695.             return u''
  696.         out = Out(self)
  697.         for item in cssvalue.seq:
  698.             type_ = item.type
  699.             val = item.value
  700.             if type_ in ('DIMENSION', 'NUMBER', 'PERCENTAGE'):
  701.                 (n, d) = cssvalue._getNumDim(val)
  702.                 if 0 == n:
  703.                     if cssvalue.primitiveType in cssvalue._lengthtypes:
  704.                         val = u'0'
  705.                     else:
  706.                         val = u'0' + d
  707.                 else:
  708.                     val = unicode(n) + d
  709.             
  710.             out.append(val, None, space = False)
  711.         
  712.         return out.value()
  713.  
  714.  
  715.