home *** CD-ROM | disk | FTP | other *** search
/ Chip 2011 November / CHIP_2011_11.iso / Programy / Narzedzia / Calibre / calibre-0.8.18.msi / file_262 / formatter.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2011-09-09  |  14.7 KB  |  531 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.7)
  3.  
  4. import sys
  5. AS_IS = None
  6.  
  7. class NullFormatter:
  8.     
  9.     def __init__(self, writer = None):
  10.         if writer is None:
  11.             writer = NullWriter()
  12.         self.writer = writer
  13.  
  14.     
  15.     def end_paragraph(self, blankline):
  16.         pass
  17.  
  18.     
  19.     def add_line_break(self):
  20.         pass
  21.  
  22.     
  23.     def add_hor_rule(self, *args, **kw):
  24.         pass
  25.  
  26.     
  27.     def add_label_data(self, format, counter, blankline = None):
  28.         pass
  29.  
  30.     
  31.     def add_flowing_data(self, data):
  32.         pass
  33.  
  34.     
  35.     def add_literal_data(self, data):
  36.         pass
  37.  
  38.     
  39.     def flush_softspace(self):
  40.         pass
  41.  
  42.     
  43.     def push_alignment(self, align):
  44.         pass
  45.  
  46.     
  47.     def pop_alignment(self):
  48.         pass
  49.  
  50.     
  51.     def push_font(self, x):
  52.         pass
  53.  
  54.     
  55.     def pop_font(self):
  56.         pass
  57.  
  58.     
  59.     def push_margin(self, margin):
  60.         pass
  61.  
  62.     
  63.     def pop_margin(self):
  64.         pass
  65.  
  66.     
  67.     def set_spacing(self, spacing):
  68.         pass
  69.  
  70.     
  71.     def push_style(self, *styles):
  72.         pass
  73.  
  74.     
  75.     def pop_style(self, n = 1):
  76.         pass
  77.  
  78.     
  79.     def assert_line_data(self, flag = 1):
  80.         pass
  81.  
  82.  
  83.  
  84. class AbstractFormatter:
  85.     
  86.     def __init__(self, writer):
  87.         self.writer = writer
  88.         self.align = None
  89.         self.align_stack = []
  90.         self.font_stack = []
  91.         self.margin_stack = []
  92.         self.spacing = None
  93.         self.style_stack = []
  94.         self.nospace = 1
  95.         self.softspace = 0
  96.         self.para_end = 1
  97.         self.parskip = 0
  98.         self.hard_break = 1
  99.         self.have_label = 0
  100.  
  101.     
  102.     def end_paragraph(self, blankline):
  103.         if not self.hard_break:
  104.             self.writer.send_line_break()
  105.             self.have_label = 0
  106.         if self.parskip < blankline and not (self.have_label):
  107.             self.writer.send_paragraph(blankline - self.parskip)
  108.             self.parskip = blankline
  109.             self.have_label = 0
  110.         self.hard_break = self.nospace = self.para_end = 1
  111.         self.softspace = 0
  112.  
  113.     
  114.     def add_line_break(self):
  115.         if not self.hard_break or self.para_end:
  116.             self.writer.send_line_break()
  117.             self.have_label = self.parskip = 0
  118.         self.hard_break = self.nospace = 1
  119.         self.softspace = 0
  120.  
  121.     
  122.     def add_hor_rule(self, *args, **kw):
  123.         if not self.hard_break:
  124.             self.writer.send_line_break()
  125.         self.writer.send_hor_rule(*args, **kw)
  126.         self.hard_break = self.nospace = 1
  127.         self.have_label = self.para_end = self.softspace = self.parskip = 0
  128.  
  129.     
  130.     def add_label_data(self, format, counter, blankline = None):
  131.         if self.have_label or not (self.hard_break):
  132.             self.writer.send_line_break()
  133.         if not self.para_end:
  134.             if not blankline or 1:
  135.                 pass
  136.             self.writer.send_paragraph(0)
  137.         if isinstance(format, str):
  138.             self.writer.send_label_data(self.format_counter(format, counter))
  139.         else:
  140.             self.writer.send_label_data(format)
  141.         self.nospace = self.have_label = self.hard_break = self.para_end = 1
  142.         self.softspace = self.parskip = 0
  143.  
  144.     
  145.     def format_counter(self, format, counter):
  146.         label = ''
  147.         for c in format:
  148.             if c == '1':
  149.                 label = label + '%d' % counter
  150.                 continue
  151.             if c in 'aA' or counter > 0:
  152.                 label = label + self.format_letter(c, counter)
  153.             
  154.             if c in 'iI' or counter > 0:
  155.                 label = label + self.format_roman(c, counter)
  156.             
  157.             label = label + c
  158.         
  159.         return label
  160.  
  161.     
  162.     def format_letter(self, case, counter):
  163.         label = ''
  164.         while counter > 0:
  165.             (counter, x) = divmod(counter - 1, 26)
  166.             s = chr(ord(case) + x)
  167.             label = s + label
  168.         return label
  169.  
  170.     
  171.     def format_roman(self, case, counter):
  172.         ones = [
  173.             'i',
  174.             'x',
  175.             'c',
  176.             'm']
  177.         fives = [
  178.             'v',
  179.             'l',
  180.             'd']
  181.         (label, index) = ('', 0)
  182.         while counter > 0:
  183.             (counter, x) = divmod(counter, 10)
  184.             if x == 9:
  185.                 label = ones[index] + ones[index + 1] + label
  186.             elif x == 4:
  187.                 label = ones[index] + fives[index] + label
  188.             elif x >= 5:
  189.                 s = fives[index]
  190.                 x = x - 5
  191.             else:
  192.                 s = ''
  193.             s = s + ones[index] * x
  194.             label = s + label
  195.             index = index + 1
  196.         if case == 'I':
  197.             return label.upper()
  198.  
  199.     
  200.     def add_flowing_data(self, data):
  201.         if not data:
  202.             return None
  203.         prespace = None[:1].isspace()
  204.         postspace = data[-1:].isspace()
  205.         data = ' '.join(data.split())
  206.         if self.nospace and not data:
  207.             return None
  208.         if None or self.softspace:
  209.             if not data:
  210.                 if not self.nospace:
  211.                     self.softspace = 1
  212.                     self.parskip = 0
  213.                 return None
  214.             if not None.nospace:
  215.                 data = ' ' + data
  216.             
  217.         self.hard_break = self.nospace = self.para_end = self.parskip = self.have_label = 0
  218.         self.softspace = postspace
  219.         self.writer.send_flowing_data(data)
  220.  
  221.     
  222.     def add_literal_data(self, data):
  223.         if not data:
  224.             return None
  225.         if None.softspace:
  226.             self.writer.send_flowing_data(' ')
  227.         self.hard_break = data[-1:] == '\n'
  228.         self.nospace = self.para_end = self.softspace = self.parskip = self.have_label = 0
  229.         self.writer.send_literal_data(data)
  230.  
  231.     
  232.     def flush_softspace(self):
  233.         if self.softspace:
  234.             self.hard_break = self.para_end = self.parskip = self.have_label = self.softspace = 0
  235.             self.nospace = 1
  236.             self.writer.send_flowing_data(' ')
  237.  
  238.     
  239.     def push_alignment(self, align):
  240.         if align and align != self.align:
  241.             self.writer.new_alignment(align)
  242.             self.align = align
  243.             self.align_stack.append(align)
  244.         else:
  245.             self.align_stack.append(self.align)
  246.  
  247.     
  248.     def pop_alignment(self):
  249.         if self.align_stack:
  250.             del self.align_stack[-1]
  251.         if self.align_stack:
  252.             self.align = align = self.align_stack[-1]
  253.             self.writer.new_alignment(align)
  254.         else:
  255.             self.align = None
  256.             self.writer.new_alignment(None)
  257.  
  258.     
  259.     def push_font(self, font):
  260.         (size, i, b, tt) = font
  261.         if self.softspace:
  262.             self.hard_break = self.para_end = self.softspace = 0
  263.             self.nospace = 1
  264.             self.writer.send_flowing_data(' ')
  265.         if self.font_stack:
  266.             (csize, ci, cb, ctt) = self.font_stack[-1]
  267.             if size is AS_IS:
  268.                 size = csize
  269.             if i is AS_IS:
  270.                 i = ci
  271.             if b is AS_IS:
  272.                 b = cb
  273.             if tt is AS_IS:
  274.                 tt = ctt
  275.             
  276.         font = (size, i, b, tt)
  277.         self.font_stack.append(font)
  278.         self.writer.new_font(font)
  279.  
  280.     
  281.     def pop_font(self):
  282.         if self.font_stack:
  283.             del self.font_stack[-1]
  284.         if self.font_stack:
  285.             font = self.font_stack[-1]
  286.         else:
  287.             font = None
  288.         self.writer.new_font(font)
  289.  
  290.     
  291.     def push_margin(self, margin):
  292.         self.margin_stack.append(margin)
  293.         fstack = filter(None, self.margin_stack)
  294.         if not margin and fstack:
  295.             margin = fstack[-1]
  296.         self.writer.new_margin(margin, len(fstack))
  297.  
  298.     
  299.     def pop_margin(self):
  300.         if self.margin_stack:
  301.             del self.margin_stack[-1]
  302.         fstack = filter(None, self.margin_stack)
  303.         if fstack:
  304.             margin = fstack[-1]
  305.         else:
  306.             margin = None
  307.         self.writer.new_margin(margin, len(fstack))
  308.  
  309.     
  310.     def set_spacing(self, spacing):
  311.         self.spacing = spacing
  312.         self.writer.new_spacing(spacing)
  313.  
  314.     
  315.     def push_style(self, *styles):
  316.         if self.softspace:
  317.             self.hard_break = self.para_end = self.softspace = 0
  318.             self.nospace = 1
  319.             self.writer.send_flowing_data(' ')
  320.         for style in styles:
  321.             self.style_stack.append(style)
  322.         
  323.         self.writer.new_styles(tuple(self.style_stack))
  324.  
  325.     
  326.     def pop_style(self, n = 1):
  327.         del self.style_stack[-n:]
  328.         self.writer.new_styles(tuple(self.style_stack))
  329.  
  330.     
  331.     def assert_line_data(self, flag = 1):
  332.         self.nospace = self.hard_break = not flag
  333.         self.para_end = self.parskip = self.have_label = 0
  334.  
  335.  
  336.  
  337. class NullWriter:
  338.     
  339.     def __init__(self):
  340.         pass
  341.  
  342.     
  343.     def flush(self):
  344.         pass
  345.  
  346.     
  347.     def new_alignment(self, align):
  348.         pass
  349.  
  350.     
  351.     def new_font(self, font):
  352.         pass
  353.  
  354.     
  355.     def new_margin(self, margin, level):
  356.         pass
  357.  
  358.     
  359.     def new_spacing(self, spacing):
  360.         pass
  361.  
  362.     
  363.     def new_styles(self, styles):
  364.         pass
  365.  
  366.     
  367.     def send_paragraph(self, blankline):
  368.         pass
  369.  
  370.     
  371.     def send_line_break(self):
  372.         pass
  373.  
  374.     
  375.     def send_hor_rule(self, *args, **kw):
  376.         pass
  377.  
  378.     
  379.     def send_label_data(self, data):
  380.         pass
  381.  
  382.     
  383.     def send_flowing_data(self, data):
  384.         pass
  385.  
  386.     
  387.     def send_literal_data(self, data):
  388.         pass
  389.  
  390.  
  391.  
  392. class AbstractWriter(NullWriter):
  393.     
  394.     def new_alignment(self, align):
  395.         print 'new_alignment(%r)' % (align,)
  396.  
  397.     
  398.     def new_font(self, font):
  399.         print 'new_font(%r)' % (font,)
  400.  
  401.     
  402.     def new_margin(self, margin, level):
  403.         print 'new_margin(%r, %d)' % (margin, level)
  404.  
  405.     
  406.     def new_spacing(self, spacing):
  407.         print 'new_spacing(%r)' % (spacing,)
  408.  
  409.     
  410.     def new_styles(self, styles):
  411.         print 'new_styles(%r)' % (styles,)
  412.  
  413.     
  414.     def send_paragraph(self, blankline):
  415.         print 'send_paragraph(%r)' % (blankline,)
  416.  
  417.     
  418.     def send_line_break(self):
  419.         print 'send_line_break()'
  420.  
  421.     
  422.     def send_hor_rule(self, *args, **kw):
  423.         print 'send_hor_rule()'
  424.  
  425.     
  426.     def send_label_data(self, data):
  427.         print 'send_label_data(%r)' % (data,)
  428.  
  429.     
  430.     def send_flowing_data(self, data):
  431.         print 'send_flowing_data(%r)' % (data,)
  432.  
  433.     
  434.     def send_literal_data(self, data):
  435.         print 'send_literal_data(%r)' % (data,)
  436.  
  437.  
  438.  
  439. class DumbWriter(NullWriter):
  440.     
  441.     def __init__(self, file = None, maxcol = 72):
  442.         if not file:
  443.             pass
  444.         self.file = sys.stdout
  445.         self.maxcol = maxcol
  446.         NullWriter.__init__(self)
  447.         self.reset()
  448.  
  449.     
  450.     def reset(self):
  451.         self.col = 0
  452.         self.atbreak = 0
  453.  
  454.     
  455.     def send_paragraph(self, blankline):
  456.         self.file.write('\n' * blankline)
  457.         self.col = 0
  458.         self.atbreak = 0
  459.  
  460.     
  461.     def send_line_break(self):
  462.         self.file.write('\n')
  463.         self.col = 0
  464.         self.atbreak = 0
  465.  
  466.     
  467.     def send_hor_rule(self, *args, **kw):
  468.         self.file.write('\n')
  469.         self.file.write('-' * self.maxcol)
  470.         self.file.write('\n')
  471.         self.col = 0
  472.         self.atbreak = 0
  473.  
  474.     
  475.     def send_literal_data(self, data):
  476.         self.file.write(data)
  477.         i = data.rfind('\n')
  478.         if i >= 0:
  479.             self.col = 0
  480.             data = data[i + 1:]
  481.         data = data.expandtabs()
  482.         self.col = self.col + len(data)
  483.         self.atbreak = 0
  484.  
  485.     
  486.     def send_flowing_data(self, data):
  487.         if not data:
  488.             return None
  489.         if not None.atbreak:
  490.             pass
  491.         atbreak = data[0].isspace()
  492.         col = self.col
  493.         maxcol = self.maxcol
  494.         write = self.file.write
  495.         for word in data.split():
  496.             if atbreak:
  497.                 if col + len(word) >= maxcol:
  498.                     write('\n')
  499.                     col = 0
  500.                 else:
  501.                     write(' ')
  502.                     col = col + 1
  503.             write(word)
  504.             col = col + len(word)
  505.             atbreak = 1
  506.         
  507.         self.col = col
  508.         self.atbreak = data[-1].isspace()
  509.  
  510.  
  511.  
  512. def test(file = None):
  513.     w = DumbWriter()
  514.     f = AbstractFormatter(w)
  515.     if file is not None:
  516.         fp = open(file)
  517.     elif sys.argv[1:]:
  518.         fp = open(sys.argv[1])
  519.     else:
  520.         fp = sys.stdin
  521.     for line in fp:
  522.         if line == '\n':
  523.             f.end_paragraph(1)
  524.             continue
  525.         f.add_flowing_data(line)
  526.     
  527.     f.end_paragraph(0)
  528.  
  529. if __name__ == '__main__':
  530.     test()
  531.