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

  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import sys
  5. import os
  6. import tempfile
  7. from calibre.ebooks.rtf2xml import copy, border_parse
  8.  
  9. class Table:
  10.     
  11.     def __init__(self, in_file, bug_handler, copy = None, run_level = 1):
  12.         self._Table__file = in_file
  13.         self._Table__bug_handler = bug_handler
  14.         self._Table__copy = copy
  15.         self._Table__run_level = run_level
  16.         self._Table__write_to = tempfile.mktemp()
  17.  
  18.     
  19.     def __initiate_values(self):
  20.         self._Table__state_dict = {
  21.             'in_table': self._Table__in_table_func,
  22.             'in_row_def': self._Table__in_row_def_func,
  23.             'not_in_table': self._Table__not_in_table_func,
  24.             'in_cell': self._Table__in_cell_func,
  25.             'in_row': self._Table__in_row_func }
  26.         self._Table__not_in_table_dict = {
  27.             'cw<tb<row-def___': self._Table__found_row_def_func,
  28.             'cw<tb<in-table__': self._Table__start_table_func,
  29.             'mi<mk<in-table__': self._Table__start_table_func }
  30.         self._Table__in_row_definition_dict = {
  31.             'mi<mk<not-in-tbl': self._Table__end_row_table_func,
  32.             'mi<mk<pard-start': self._Table__end_row_def_func }
  33.         self._Table__in_row_dict = {
  34.             'mi<mk<not-in-tbl': self._Table__close_table,
  35.             'mi<mk<pard-start': self._Table__start_cell_func,
  36.             'cw<tb<row_______': self._Table__end_row_func,
  37.             'cw<tb<cell______': self._Table__empty_cell }
  38.         self._Table__state = [
  39.             'not_in_table']
  40.         self._Table__table_data = []
  41.         self._Table__row_dict = { }
  42.         self._Table__cell_list = []
  43.         self._Table__cell_widths = []
  44.  
  45.     
  46.     def __in_table_func(self, line):
  47.         if self._Table__token_info == 'mi<mk<not-in-tbl' and self._Table__token_info == 'mi<mk<sect-start' and self._Table__token_info == 'mi<mk<sect-close' or self._Table__token_info == 'mi<mk<body-close':
  48.             self._Table__close_table(line)
  49.         elif self._Table__token_info == 'mi<mk<pard-start':
  50.             self._Table__start_row_func(line)
  51.             self._Table__start_cell_func(line)
  52.         elif self._Table__token_info == 'cw<tb<row-def___':
  53.             self._Table__found_row_def_func(line)
  54.         elif self._Table__token_info == 'cw<tb<cell______':
  55.             self._Table__start_row_func(line)
  56.             self._Table__empty_cell(line)
  57.         
  58.         self._Table__write_obj.write(line)
  59.  
  60.     
  61.     def __not_in_table_func(self, line):
  62.         action = self._Table__not_in_table_dict.get(self._Table__token_info)
  63.         if action:
  64.             action(line)
  65.         
  66.         self._Table__write_obj.write(line)
  67.  
  68.     
  69.     def __close_table(self, line):
  70.         self._Table__write_obj.write('mi<mk<table-end_\n')
  71.         self._Table__state = [
  72.             'not_in_table']
  73.         self._Table__table_data[-1]['number-of-columns'] = self._Table__max_number_cells_in_row
  74.         self._Table__table_data[-1]['number-of-rows'] = self._Table__rows_in_table
  75.         average_cells_in_row = self._Table__mode(self._Table__list_of_cells_in_row)
  76.         self._Table__table_data[-1]['average-cells-per-row'] = average_cells_in_row
  77.         average_cell_width = self._Table__mode(self._Table__cell_widths)
  78.         self._Table__table_data[-1]['average-cell-width'] = average_cell_width
  79.  
  80.     
  81.     def __found_row_def_func(self, line):
  82.         self._Table__state.append('in_row_def')
  83.         self._Table__last_cell_position = 0
  84.         self._Table__row_dict = { }
  85.         self._Table__cell_list = []
  86.         self._Table__cell_list.append({ })
  87.         self._Table__cell_widths = []
  88.  
  89.     
  90.     def __start_table_func(self, line):
  91.         self._Table__rows_in_table = 0
  92.         self._Table__cells_in_table = 0
  93.         self._Table__cells_in_row = 0
  94.         self._Table__max_number_cells_in_row = 0
  95.         self._Table__table_data.append({ })
  96.         self._Table__list_of_cells_in_row = []
  97.         self._Table__write_obj.write('mi<mk<tabl-start\n')
  98.         self._Table__state.append('in_table')
  99.  
  100.     
  101.     def __end_row_table_func(self, line):
  102.         self._Table__close_table(self, line)
  103.  
  104.     
  105.     def __end_row_def_func(self, line):
  106.         if len(self._Table__state) > 0:
  107.             if self._Table__state[-1] == 'in_row_def':
  108.                 self._Table__state.pop()
  109.             
  110.         
  111.         self._Table__cell_list.pop()
  112.         widths = self._Table__row_dict.get('widths')
  113.         if widths:
  114.             width_list = widths.split(',')
  115.             num_cells = len(width_list)
  116.             self._Table__row_dict['number-of-cells'] = num_cells
  117.         
  118.  
  119.     
  120.     def __in_row_def_func(self, line):
  121.         if self._Table__token_info == 'cw<tb<row_______':
  122.             self._Table__end_row_func(line)
  123.             self._Table__end_row_def_func(line)
  124.             self._Table__write_obj.write(line)
  125.         elif line[0:2] == 'cw':
  126.             self._Table__handle_row_token(line)
  127.             self._Table__write_obj.write(line)
  128.         elif self._Table__token_info == 'mi<mk<not-in-tbl' and 'in_table' in self._Table__state:
  129.             self._Table__end_row_def_func(line)
  130.             self._Table__close_table(line)
  131.             self._Table__write_obj.write(line)
  132.         elif self._Table__token_info == 'mi<mk<pard-start':
  133.             self._Table__end_row_def_func(line)
  134.             if self._Table__state > 0 and self._Table__state[-1] == 'in_table':
  135.                 self._Table__start_row_func(line)
  136.                 self._Table__start_cell_func(line)
  137.             
  138.             self._Table__write_obj.write(line)
  139.         elif self._Table__token_info == 'mi<mk<in-table__':
  140.             self._Table__end_row_def_func(line)
  141.             if len(self._Table__state) > 0 and self._Table__state[-1] != 'in_table':
  142.                 self._Table__start_table_func(line)
  143.             
  144.             self._Table__write_obj.write(line)
  145.         else:
  146.             self._Table__write_obj.write(line)
  147.  
  148.     
  149.     def __handle_row_token(self, line):
  150.         if line[3:5] == 'bd':
  151.             border_obj = border_parse.BorderParse()
  152.             the_dict = border_obj.parse_border(line)
  153.             keys = the_dict.keys()
  154.             in_cell = 0
  155.             for key in keys:
  156.                 if key[0:11] == 'border-cell':
  157.                     in_cell = 1
  158.                     continue
  159.             
  160.             for key in keys:
  161.                 if in_cell:
  162.                     self._Table__cell_list[-1][key] = the_dict[key]
  163.                     continue
  164.                 self._Table__row_dict[key] = the_dict[key]
  165.             
  166.         elif self._Table__token_info == 'cw<tb<cell-posit':
  167.             self._Table__found_cell_position(line)
  168.         elif self._Table__token_info == 'cw<tb<row-pos-le':
  169.             position = line[20:-1]
  170.             self._Table__row_dict['left-row-position'] = position
  171.         elif self._Table__token_info == 'cw<tb<row-header':
  172.             self._Table__row_dict['header'] = 'true'
  173.         
  174.  
  175.     
  176.     def __start_cell_func(self, line):
  177.         self._Table__state.append('in_cell')
  178.         if len(self._Table__cell_list) > 0:
  179.             self._Table__write_obj.write('mi<tg<open-att__<cell')
  180.             cell_dict = self._Table__cell_list[0]
  181.             keys = cell_dict.keys()
  182.             for key in keys:
  183.                 self._Table__write_obj.write('<%s>%s' % (key, cell_dict[key]))
  184.             
  185.             self._Table__write_obj.write('\n')
  186.             self._Table__cell_list.pop(0)
  187.         else:
  188.             self._Table__write_obj.write('mi<tg<open______<cell\n')
  189.         self._Table__cells_in_table += 1
  190.         self._Table__cells_in_row += 1
  191.  
  192.     
  193.     def __start_row_func(self, line):
  194.         self._Table__state.append('in_row')
  195.         self._Table__write_obj.write('mi<tg<open-att__<row')
  196.         keys = self._Table__row_dict.keys()
  197.         for key in keys:
  198.             self._Table__write_obj.write('<%s>%s' % (key, self._Table__row_dict[key]))
  199.         
  200.         self._Table__write_obj.write('\n')
  201.         self._Table__cells_in_row = 0
  202.         self._Table__rows_in_table += 1
  203.  
  204.     
  205.     def __found_cell_position(self, line):
  206.         new_cell_position = round(float(line[20:-1]), 2)
  207.         left_position = 0
  208.         if self._Table__last_cell_position == 0:
  209.             left_position = self._Table__row_dict.get('left-row-position', 0)
  210.             left_position = float(left_position)
  211.         
  212.         width = new_cell_position - self._Table__last_cell_position - left_position
  213.         width = str('%.2f' % width)
  214.         self._Table__last_cell_position = new_cell_position
  215.         widths_exists = self._Table__row_dict.get('widths')
  216.         if widths_exists:
  217.             self._Table__row_dict['widths'] += ', %s' % str(width)
  218.         else:
  219.             self._Table__row_dict['widths'] = str(width)
  220.         self._Table__cell_list[-1]['width'] = width
  221.         self._Table__cell_list.append({ })
  222.         self._Table__cell_widths.append(width)
  223.  
  224.     
  225.     def __in_cell_func(self, line):
  226.         if self._Table__token_info == 'mi<mk<not-in-tbl' and self._Table__token_info == 'mi<mk<sect-start' and self._Table__token_info == 'mi<mk<sect-close' or self._Table__token_info == 'mi<mk<body-close':
  227.             self._Table__end_cell_func(line)
  228.             self._Table__end_row_func(line)
  229.             self._Table__close_table(line)
  230.             self._Table__write_obj.write(line)
  231.         elif self._Table__token_info == 'cw<tb<cell______':
  232.             self._Table__end_cell_func(line)
  233.         else:
  234.             self._Table__write_obj.write(line)
  235.  
  236.     
  237.     def __end_cell_func(self, line):
  238.         if len(self._Table__state) > 1:
  239.             if self._Table__state[-1] == 'in_cell':
  240.                 self._Table__state.pop()
  241.             
  242.         
  243.         self._Table__write_obj.write('mi<mk<close_cell\n')
  244.         self._Table__write_obj.write('mi<tg<close_____<cell\n')
  245.         self._Table__write_obj.write('mi<mk<closecell_\n')
  246.  
  247.     
  248.     def __in_row_func(self, line):
  249.         if self._Table__token_info == 'mi<mk<not-in-tbl' and self._Table__token_info == 'mi<mk<sect-start' and self._Table__token_info == 'mi<mk<sect-close' or self._Table__token_info == 'mi<mk<body-close':
  250.             self._Table__end_row_func(line)
  251.             self._Table__close_table(line)
  252.             self._Table__write_obj.write(line)
  253.         else:
  254.             action = self._Table__in_row_dict.get(self._Table__token_info)
  255.             if action:
  256.                 action(line)
  257.             
  258.             self._Table__write_obj.write(line)
  259.  
  260.     
  261.     def __end_row_func(self, line):
  262.         if self._Table__cells_in_row > self._Table__max_number_cells_in_row:
  263.             self._Table__max_number_cells_in_row = self._Table__cells_in_row
  264.         
  265.         self._Table__list_of_cells_in_row.append(self._Table__cells_in_row)
  266.  
  267.     
  268.     def __empty_cell(self, line):
  269.         if len(self._Table__cell_list) > 0:
  270.             self._Table__write_obj.write('mi<tg<empty-att_<cell')
  271.             cell_dict = self._Table__cell_list[-1]
  272.             keys = cell_dict.keys()
  273.             for key in keys:
  274.                 self._Table__write_obj.write('<%s>%s' % (key, cell_dict[key]))
  275.             
  276.             self._Table__write_obj.write('\n')
  277.         else:
  278.             self._Table__write_obj.write('mi<tg<empty_____<cell\n')
  279.         self._Table__cells_in_table += 1
  280.         self._Table__cells_in_row += 1
  281.  
  282.     
  283.     def __mode(self, the_list):
  284.         max = 0
  285.         mode = 'not-defined'
  286.         for item in the_list:
  287.             num_of_values = the_list.count(item)
  288.             if num_of_values > max:
  289.                 mode = item
  290.                 max = num_of_values
  291.                 continue
  292.         
  293.         return mode
  294.  
  295.     
  296.     def make_table(self):
  297.         self._Table__initiate_values()
  298.         read_obj = open(self._Table__file, 'r')
  299.         self._Table__write_obj = open(self._Table__write_to, 'w')
  300.         line_to_read = 1
  301.         while line_to_read:
  302.             line_to_read = read_obj.readline()
  303.             line = line_to_read
  304.             self._Table__token_info = line[:16]
  305.             action = self._Table__state_dict.get(self._Table__state[-1])
  306.             if action == None:
  307.                 sys.stderr.write('No matching state in module table.py\n')
  308.                 sys.stderr.write(self._Table__state[-1] + '\n')
  309.             
  310.             action(line)
  311.         read_obj.close()
  312.         self._Table__write_obj.close()
  313.         copy_obj = copy.Copy(bug_handler = self._Table__bug_handler)
  314.         if self._Table__copy:
  315.             copy_obj.copy_file(self._Table__write_to, 'table.data')
  316.         
  317.         copy_obj.rename(self._Table__write_to, self._Table__file)
  318.         os.remove(self._Table__write_to)
  319.         return self._Table__table_data
  320.  
  321.  
  322.