home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_1105 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  7.0 KB  |  206 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
  8.  
  9. class Header:
  10.     
  11.     def __init__(self, in_file, bug_handler, copy = None, run_level = 1):
  12.         self._Header__file = in_file
  13.         self._Header__bug_handler = bug_handler
  14.         self._Header__copy = copy
  15.         self._Header__write_to = tempfile.mktemp()
  16.         self._Header__found_a_header = 0
  17.  
  18.     
  19.     def __in_header_func(self, line):
  20.         if self._Header__cb_count == self._Header__header_bracket_count:
  21.             self._Header__in_header = 0
  22.             self._Header__write_obj.write(line)
  23.             self._Header__write_to_head_obj.write('mi<mk<head___clo\n')
  24.             self._Header__write_to_head_obj.write('mi<tg<close_____<header-or-footer\n')
  25.             self._Header__write_to_head_obj.write('mi<mk<header-clo\n')
  26.         else:
  27.             self._Header__write_to_head_obj.write(line)
  28.  
  29.     
  30.     def __found_header(self, line):
  31.         self._Header__found_a_header = 1
  32.         self._Header__in_header = 1
  33.         self._Header__header_count += 1
  34.         self._Header__cb_count = 0
  35.         self._Header__header_bracket_count = self._Header__ob_count
  36.         self._Header__write_obj.write('mi<mk<header-ind<%04d\n' % self._Header__header_count)
  37.         self._Header__write_to_head_obj.write('mi<mk<header-ope<%04d\n' % self._Header__header_count)
  38.         info = line[6:16]
  39.         type = self._Header__head_dict.get(info)
  40.         if type:
  41.             self._Header__write_to_head_obj.write('mi<tg<open-att__<header-or-footer<type>%s\n' % type)
  42.         else:
  43.             sys.stderr.write('module is header\n')
  44.             sys.stderr.write('method is __found_header\n')
  45.             sys.stderr.write('no dict entry\n')
  46.             sys.stderr.write('line is %s' % line)
  47.             self._Header__write_to_head_obj.write('mi<tg<open-att__<header-or-footer<type>none\n')
  48.  
  49.     
  50.     def __default_sep(self, line):
  51.         if self._Header__token_info[3:5] == 'hf':
  52.             self._Header__found_header(line)
  53.         
  54.         self._Header__write_obj.write(line)
  55.  
  56.     
  57.     def __initiate_sep_values(self):
  58.         self._Header__bracket_count = 0
  59.         self._Header__ob_count = 0
  60.         self._Header__cb_count = 0
  61.         self._Header__header_bracket_count = 0
  62.         self._Header__in_header = 0
  63.         self._Header__header_count = 0
  64.         self._Header__head_dict = {
  65.             'head-left_': 'header-left',
  66.             'head-right': 'header-right',
  67.             'foot-left_': 'footer-left',
  68.             'foot-right': 'footer-right',
  69.             'head-first': 'header-first',
  70.             'foot-first': 'footer-first',
  71.             'header____': 'header',
  72.             'footer____': 'footer' }
  73.  
  74.     
  75.     def separate_headers(self):
  76.         self._Header__initiate_sep_values()
  77.         read_obj = open(self._Header__file)
  78.         self._Header__write_obj = open(self._Header__write_to, 'w')
  79.         self._Header__header_holder = tempfile.mktemp()
  80.         self._Header__write_to_head_obj = open(self._Header__header_holder, 'w')
  81.         line_to_read = 1
  82.         while line_to_read:
  83.             line_to_read = read_obj.readline()
  84.             line = line_to_read
  85.             self._Header__token_info = line[:16]
  86.             if self._Header__token_info == 'ob<nu<open-brack':
  87.                 self._Header__ob_count = line[-5:-1]
  88.             
  89.             if self._Header__token_info == 'cb<nu<clos-brack':
  90.                 self._Header__cb_count = line[-5:-1]
  91.             
  92.             if self._Header__in_header:
  93.                 self._Header__in_header_func(line)
  94.                 continue
  95.             self._Header__default_sep(line)
  96.         self._Header__write_obj.close()
  97.         read_obj.close()
  98.         self._Header__write_to_head_obj.close()
  99.         read_obj = open(self._Header__header_holder, 'r')
  100.         write_obj = open(self._Header__write_to, 'a')
  101.         write_obj.write('mi<mk<header-beg\n')
  102.         line = 1
  103.         while line:
  104.             line = read_obj.readline()
  105.             write_obj.write(line)
  106.         write_obj.write('mi<mk<header-end\n')
  107.         read_obj.close()
  108.         write_obj.close()
  109.         os.remove(self._Header__header_holder)
  110.         copy_obj = copy.Copy(bug_handler = self._Header__bug_handler)
  111.         if self._Header__copy:
  112.             copy_obj.copy_file(self._Header__write_to, 'header_separate.info')
  113.         
  114.         copy_obj.rename(self._Header__write_to, self._Header__file)
  115.         os.remove(self._Header__write_to)
  116.  
  117.     
  118.     def update_info(self, file, copy):
  119.         self._Header__file = file
  120.         self._Header__copy = copy
  121.  
  122.     
  123.     def __get_head_body_func(self, line):
  124.         if self._Header__token_info == 'mi<mk<header-beg':
  125.             self._Header__state = 'head'
  126.         else:
  127.             self._Header__write_obj.write(line)
  128.  
  129.     
  130.     def __get_head_head_func(self, line):
  131.         if self._Header__token_info == 'mi<mk<header-end':
  132.             self._Header__state = 'body'
  133.         else:
  134.             self._Header__write_to_head_obj.write(line)
  135.  
  136.     
  137.     def __get_headers(self):
  138.         read_obj = open(self._Header__file)
  139.         self._Header__write_obj = open(self._Header__write_to, 'w')
  140.         self._Header__write_to_head_obj = open(self._Header__header_holder, 'w')
  141.         line = 1
  142.         while line:
  143.             line = read_obj.readline()
  144.             self._Header__token_info = line[:16]
  145.             if self._Header__state == 'body':
  146.                 self._Header__get_head_body_func(line)
  147.                 continue
  148.             if self._Header__state == 'head':
  149.                 self._Header__get_head_head_func(line)
  150.                 continue
  151.         read_obj.close()
  152.         self._Header__write_obj.close()
  153.         self._Header__write_to_head_obj.close()
  154.  
  155.     
  156.     def __get_head_from_temp(self, num):
  157.         look_for = 'mi<mk<header-ope<' + num + '\n'
  158.         found_head = 0
  159.         string_to_return = ''
  160.         line = 1
  161.         while line:
  162.             line = self._Header__read_from_head_obj.readline()
  163.             if found_head:
  164.                 if line == 'mi<mk<header-clo\n':
  165.                     return string_to_return
  166.                 string_to_return = string_to_return + line
  167.                 continue
  168.             line == 'mi<mk<header-clo\n'
  169.             if line == look_for:
  170.                 found_head = 1
  171.                 continue
  172.  
  173.     
  174.     def __join_from_temp(self):
  175.         self._Header__read_from_head_obj = open(self._Header__header_holder, 'r')
  176.         read_obj = open(self._Header__write_to, 'r')
  177.         self._Header__write_obj = open(self._Header__write_to2, 'w')
  178.         line = 1
  179.         while line:
  180.             line = read_obj.readline()
  181.             if line[:16] == 'mi<mk<header-ind':
  182.                 line = self._Header__get_head_from_temp(line[17:-1])
  183.             
  184.             self._Header__write_obj.write(line)
  185.         read_obj.close()
  186.  
  187.     
  188.     def join_headers(self):
  189.         if not self._Header__found_a_header:
  190.             return None
  191.         self._Header__write_to2 = tempfile.mktemp()
  192.         self._Header__state = 'body'
  193.         self._Header__get_headers()
  194.         self._Header__join_from_temp()
  195.         self._Header__write_obj.close()
  196.         self._Header__read_from_head_obj.close()
  197.         copy_obj = copy.Copy(bug_handler = self._Header__bug_handler)
  198.         if self._Header__copy:
  199.             copy_obj.copy_file(self._Header__write_to, 'header_join.data')
  200.         
  201.         copy_obj.rename(self._Header__write_to, self._Header__file)
  202.         os.remove(self._Header__write_to)
  203.         os.remove(self._Header__header_holder)
  204.  
  205.  
  206.