home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_2349 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  15.9 KB  |  423 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import os
  5. import re
  6. import math
  7. import glob
  8. import sys
  9. import pyreadline.logger as logger
  10. from pyreadline.logger import log, log_sock
  11. from pyreadline.keysyms.common import make_KeyPress_from_keydescr
  12. import pyreadline.lineeditor.lineobj as lineobj
  13. import pyreadline.lineeditor.history as history
  14. import pyreadline.clipboard as clipboard
  15. from pyreadline.error import ReadlineError, GetSetError
  16. from pyreadline.unicode_helper import ensure_str, ensure_unicode
  17. in_ironpython = 'IronPython' in sys.version
  18.  
  19. class BaseMode(object):
  20.     mode = 'base'
  21.     
  22.     def __init__(self, rlobj):
  23.         self.rlobj = rlobj
  24.         self.exit_dispatch = { }
  25.         self.key_dispatch = { }
  26.         self.argument = 1
  27.         self.prevargument = None
  28.  
  29.     
  30.     def __repr__(self):
  31.         return '<BaseMode>'
  32.  
  33.     
  34.     def _gs(x):
  35.         
  36.         def g(self):
  37.             return getattr(self.rlobj, x)
  38.  
  39.         
  40.         def s(self, q):
  41.             setattr(self.rlobj, x, q)
  42.  
  43.         return (g, s)
  44.  
  45.     
  46.     def _g(x):
  47.         
  48.         def g(self):
  49.             return getattr(self.rlobj, x)
  50.  
  51.         return g
  52.  
  53.     
  54.     def _argreset(self):
  55.         val = self.argument
  56.         self.argument = 1
  57.         return val
  58.  
  59.     argument_reset = property(_argreset)
  60.     ctrl_c_tap_time_interval = property(*_gs('ctrl_c_tap_time_interval'))
  61.     allow_ctrl_c = property(*_gs('allow_ctrl_c'))
  62.     l_buffer = property(*_gs('l_buffer'))
  63.     next_meta = property(*_gs('next_meta'))
  64.     first_prompt = property(*_gs('first_prompt'))
  65.     prompt = property(*_gs('prompt'))
  66.     paste_line_buffer = property(*_gs('paste_line_buffer'))
  67.     completer_delims = property(*_gs('completer_delims'))
  68.     show_all_if_ambiguous = property(*_gs('show_all_if_ambiguous'))
  69.     mark_directories = property(*_gs('mark_directories'))
  70.     completer = property(*_gs('completer'))
  71.     begidx = property(*_gs('begidx'))
  72.     startup_hook = property(*_gs('startup_hook'))
  73.     pre_input_hook = property(*_gs('pre_input_hook'))
  74.     endidx = property(*_gs('endidx'))
  75.     console = property(_g('console'))
  76.     insert_text = property(_g('insert_text'))
  77.     _print_prompt = property(_g('_print_prompt'))
  78.     _update_line = property(_g('_update_line'))
  79.     add_history = property(_g('add_history'))
  80.     _bell = property(_g('_bell'))
  81.     _clear_after = property(_g('_clear_after'))
  82.     _set_cursor = property(_g('_set_cursor'))
  83.     _update_prompt_pos = property(_g('_update_prompt_pos'))
  84.     _update_line = property(_g('_update_line'))
  85.     enable_win32_clipboard = property(_g('enable_win32_clipboard'))
  86.     enable_ipython_paste_list_of_lists = property(_g('enable_ipython_paste_list_of_lists'))
  87.     enable_ipython_paste_for_paths = property(_g('enable_ipython_paste_for_paths'))
  88.     _bell = property(_g('_bell'))
  89.     _history = property(_g('_history'))
  90.     prompt_end_pos = property(_g('prompt_end_pos'))
  91.     prompt_begin_pos = property(_g('prompt_begin_pos'))
  92.     rl_settings_to_string = property(_g('rl_settings_to_string'))
  93.     
  94.     def _readline_from_keyboard(self):
  95.         raise NotImplementedError
  96.  
  97.     
  98.     def readline(self, prompt = ''):
  99.         raise NotImplementedError
  100.  
  101.     
  102.     def _bind_key(self, key, func):
  103.         if type(func) != type(self._bind_key):
  104.             print 'Trying to bind non method to keystroke:%s,%s' % (key, func)
  105.             raise PyreadlineError('Trying to bind non method to keystroke:%s,%s,%s,%s' % (key, func, type(func), type(self._bind_key)))
  106.         type(func) != type(self._bind_key)
  107.         keyinfo = make_KeyPress_from_keydescr(key.lower()).tuple()
  108.         log('>>>%s -> %s<<<' % (keyinfo, func.__name__))
  109.         self.key_dispatch[keyinfo] = func
  110.  
  111.     
  112.     def _bind_exit_key(self, key):
  113.         keyinfo = make_KeyPress_from_keydescr(key.lower()).tuple()
  114.         self.exit_dispatch[keyinfo] = None
  115.  
  116.     
  117.     def init_editing_mode(self, e):
  118.         raise NotImplementedError
  119.  
  120.     
  121.     def _get_completions(self):
  122.         completions = []
  123.         self.begidx = self.l_buffer.point
  124.         self.endidx = self.l_buffer.point
  125.         buf = self.l_buffer.line_buffer
  126.         if self.completer:
  127.             while self.begidx > 0:
  128.                 self.begidx -= 1
  129.                 if buf[self.begidx] in self.completer_delims:
  130.                     self.begidx += 1
  131.                     break
  132.                     continue
  133.                 self
  134.                 continue
  135.                 self
  136.             text = ensure_str(''.join(buf[self.begidx:self.endidx]))
  137.             log('complete text="%s"' % text)
  138.             i = 0
  139.             while None:
  140.                 
  141.                 try:
  142.                     r = ensure_unicode(self.completer(text, i))
  143.                 except:
  144.                     break
  145.  
  146.                 i += 1
  147.                 if r and r not in completions:
  148.                     completions.append(r)
  149.                     continue
  150.                 break
  151.                 continue
  152.                 log('text completions=%s' % completions)
  153.         self.completer
  154.         if not completions:
  155.             while self.begidx > 0:
  156.                 self.begidx -= 1
  157.                 if buf[self.begidx] in ' \t\n':
  158.                     self.begidx += 1
  159.                     break
  160.                     continue
  161.                 self
  162.                 continue
  163.                 self
  164.             text = ensure_str(''.join(buf[self.begidx:self.endidx]))
  165.             log('file complete text="%s"' % text)
  166.             completions = map(ensure_unicode, glob.glob(os.path.expanduser(text) + '*'))
  167.             if self.mark_directories == 'on':
  168.                 mc = []
  169.                 for f in completions:
  170.                     if os.path.isdir(f):
  171.                         mc.append(f + os.sep)
  172.                         continue
  173.                     mc.append(f)
  174.                 
  175.                 completions = mc
  176.             
  177.             log('fnames=%s' % completions)
  178.         
  179.         return completions
  180.  
  181.     
  182.     def _display_completions(self, completions):
  183.         if not completions:
  184.             return None
  185.         self.console.write('\n')
  186.         wmax = max(map(len, completions))
  187.         (w, h) = self.console.size()
  188.         cols = max(1, int((w - 1) / (wmax + 1)))
  189.         rows = int(math.ceil(float(len(completions)) / cols))
  190.         for row in range(rows):
  191.             s = ''
  192.             for col in range(cols):
  193.                 i = col * rows + row
  194.                 if i < len(completions):
  195.                     self.console.write(completions[i].ljust(wmax + 1))
  196.                     continue
  197.                 completions
  198.             
  199.             self.console.write('\n')
  200.         
  201.         if in_ironpython:
  202.             self.prompt = sys.ps1
  203.         
  204.         self._print_prompt()
  205.  
  206.     
  207.     def complete(self, e):
  208.         completions = self._get_completions()
  209.  
  210.     
  211.     def possible_completions(self, e):
  212.         completions = self._get_completions()
  213.         self._display_completions(completions)
  214.  
  215.     
  216.     def insert_completions(self, e):
  217.         completions = self._get_completions()
  218.         b = self.begidx
  219.         e = self.endidx
  220.         for comp in completions:
  221.             rep = [ c for c in comp ]
  222.             rep.append(' ')
  223.             self.l_buffer[b:e] = rep
  224.             b += len(rep)
  225.             e = b
  226.         
  227.         self.line_cursor = b
  228.  
  229.     
  230.     def menu_complete(self, e):
  231.         pass
  232.  
  233.     
  234.     def beginning_of_line(self, e):
  235.         self.l_buffer.beginning_of_line()
  236.  
  237.     
  238.     def end_of_line(self, e):
  239.         self.l_buffer.end_of_line()
  240.  
  241.     
  242.     def forward_char(self, e):
  243.         self.l_buffer.forward_char(self.argument_reset)
  244.  
  245.     
  246.     def backward_char(self, e):
  247.         self.l_buffer.backward_char(self.argument_reset)
  248.  
  249.     
  250.     def forward_word(self, e):
  251.         self.l_buffer.forward_word(self.argument_reset)
  252.  
  253.     
  254.     def backward_word(self, e):
  255.         self.l_buffer.backward_word(self.argument_reset)
  256.  
  257.     
  258.     def forward_word_end(self, e):
  259.         self.l_buffer.forward_word_end(self.argument_reset)
  260.  
  261.     
  262.     def backward_word_end(self, e):
  263.         self.l_buffer.backward_word_end(self.argument_reset)
  264.  
  265.     
  266.     def beginning_of_line_extend_selection(self, e):
  267.         self.l_buffer.beginning_of_line_extend_selection()
  268.  
  269.     
  270.     def end_of_line_extend_selection(self, e):
  271.         self.l_buffer.end_of_line_extend_selection()
  272.  
  273.     
  274.     def forward_char_extend_selection(self, e):
  275.         self.l_buffer.forward_char_extend_selection(self.argument_reset)
  276.  
  277.     
  278.     def backward_char_extend_selection(self, e):
  279.         self.l_buffer.backward_char_extend_selection(self.argument_reset)
  280.  
  281.     
  282.     def forward_word_extend_selection(self, e):
  283.         self.l_buffer.forward_word_extend_selection(self.argument_reset)
  284.  
  285.     
  286.     def backward_word_extend_selection(self, e):
  287.         self.l_buffer.backward_word_extend_selection(self.argument_reset)
  288.  
  289.     
  290.     def forward_word_end_extend_selection(self, e):
  291.         self.l_buffer.forward_word_end_extend_selection(self.argument_reset)
  292.  
  293.     
  294.     def backward_word_end_extend_selection(self, e):
  295.         self.l_buffer.forward_word_end_extend_selection(self.argument_reset)
  296.  
  297.     
  298.     def upcase_word(self, e):
  299.         self.l_buffer.upcase_word()
  300.  
  301.     
  302.     def downcase_word(self, e):
  303.         self.l_buffer.downcase_word()
  304.  
  305.     
  306.     def capitalize_word(self, e):
  307.         self.l_buffer.capitalize_word()
  308.  
  309.     
  310.     def clear_screen(self, e):
  311.         self.console.page()
  312.  
  313.     
  314.     def redraw_current_line(self, e):
  315.         pass
  316.  
  317.     
  318.     def accept_line(self, e):
  319.         return True
  320.  
  321.     
  322.     def delete_char(self, e):
  323.         self.l_buffer.delete_char(self.argument_reset)
  324.  
  325.     
  326.     def backward_delete_char(self, e):
  327.         self.l_buffer.backward_delete_char(self.argument_reset)
  328.  
  329.     
  330.     def backward_delete_word(self, e):
  331.         self.l_buffer.backward_delete_word(self.argument_reset)
  332.  
  333.     
  334.     def forward_delete_word(self, e):
  335.         self.l_buffer.forward_delete_word(self.argument_reset)
  336.  
  337.     
  338.     def delete_horizontal_space(self, e):
  339.         self.l_buffer.delete_horizontal_space()
  340.  
  341.     
  342.     def self_insert(self, e):
  343.         if e.char and ord(e.char) != 0:
  344.             self.insert_text(e.char)
  345.         
  346.  
  347.     
  348.     def paste(self, e):
  349.         if self.enable_win32_clipboard:
  350.             txt = clipboard.get_clipboard_text_and_convert(False)
  351.             txt = txt.split('\n')[0].strip('\r').strip('\n')
  352.             log('paste: >%s<' % map(ord, txt))
  353.             self.insert_text(txt)
  354.         
  355.  
  356.     
  357.     def paste_mulitline_code(self, e):
  358.         reg = re.compile('\r?\n')
  359.         if self.enable_win32_clipboard:
  360.             txt = clipboard.get_clipboard_text_and_convert(False)
  361.             t = reg.split(txt)
  362.             t = _[1]
  363.             if t != [
  364.                 '']:
  365.                 self.insert_text(t[0])
  366.                 self.add_history(self.l_buffer.copy())
  367.                 self.paste_line_buffer = t[1:]
  368.                 log('multi: %s' % self.paste_line_buffer)
  369.                 return True
  370.             return False
  371.         self.enable_win32_clipboard
  372.  
  373.     
  374.     def ipython_paste(self, e):
  375.         if self.enable_win32_clipboard:
  376.             txt = clipboard.get_clipboard_text_and_convert(self.enable_ipython_paste_list_of_lists)
  377.             if self.enable_ipython_paste_for_paths:
  378.                 if len(txt) < 300 and '\t' not in txt and '\n' not in txt:
  379.                     txt = txt.replace('\\', '/').replace(' ', '\\ ')
  380.                 
  381.             
  382.             self.insert_text(txt)
  383.         
  384.  
  385.     
  386.     def copy_region_to_clipboard(self, e):
  387.         self.l_buffer.copy_region_to_clipboard()
  388.  
  389.     
  390.     def copy_selection_to_clipboard(self, e):
  391.         self.l_buffer.copy_selection_to_clipboard()
  392.  
  393.     
  394.     def cut_selection_to_clipboard(self, e):
  395.         self.l_buffer.cut_selection_to_clipboard()
  396.  
  397.     
  398.     def dump_functions(self, e):
  399.         print 
  400.         txt = '\n'.join(self.rl_settings_to_string())
  401.         print txt
  402.         self._print_prompt()
  403.  
  404.  
  405.  
  406. def commonprefix(m):
  407.     if not m:
  408.         return ''
  409.     prefix = m[0]
  410.     for item in m:
  411.         for i in range(len(prefix)):
  412.             if prefix[:i + 1].lower() != item[:i + 1].lower():
  413.                 prefix = prefix[:i]
  414.                 if i == 0:
  415.                     return ''
  416.                 break
  417.                 continue
  418.             i == 0
  419.         
  420.     
  421.     return prefix
  422.  
  423.