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

  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import os
  5. import pyreadline.logger as logger
  6. from pyreadline.logger import log
  7. import pyreadline.lineeditor.lineobj as lineobj
  8. import pyreadline.lineeditor.history as history
  9. import basemode
  10.  
  11. class NotEmacsMode(basemode.BaseMode):
  12.     mode = 'notemacs'
  13.     
  14.     def __init__(self, rlobj):
  15.         super(NotEmacsMode, self).__init__(rlobj)
  16.  
  17.     
  18.     def __repr__(self):
  19.         return '<NotEmacsMode>'
  20.  
  21.     
  22.     def _readline_from_keyboard(self):
  23.         c = self.console
  24.         while None:
  25.             event = c.getkeypress()
  26.             if self.next_meta:
  27.                 self.next_meta = False
  28.                 (control, meta, shift, code) = event.keyinfo
  29.                 event.keyinfo = (control, True, shift, code)
  30.             
  31.             if event.keyinfo in self.exit_dispatch:
  32.                 if lineobj.EndOfLine(self.l_buffer) == 0:
  33.                     raise EOFError
  34.                 lineobj.EndOfLine(self.l_buffer) == 0
  35.             
  36.             dispatch_func = self.key_dispatch.get(event.keyinfo, self.self_insert)
  37.             log('readline from keyboard:%s' % (event.keyinfo,))
  38.             r = None
  39.             if dispatch_func:
  40.                 r = dispatch_func(event)
  41.                 self.l_buffer.push_undo()
  42.             
  43.             self.previous_func = dispatch_func
  44.             if r:
  45.                 self._update_line()
  46.                 break
  47.                 continue
  48.             continue
  49.             return None
  50.  
  51.     
  52.     def readline(self, prompt = ''):
  53.         if self.first_prompt:
  54.             self.first_prompt = False
  55.             if self.startup_hook:
  56.                 
  57.                 try:
  58.                     self.startup_hook()
  59.                 print 'startup hook failed'
  60.                 traceback.print_exc()
  61.  
  62.             
  63.         
  64.         c = self.console
  65.         self.l_buffer.reset_line()
  66.         self.prompt = prompt
  67.         self._print_prompt()
  68.         if self.pre_input_hook:
  69.             
  70.             try:
  71.                 self.pre_input_hook()
  72.             print 'pre_input_hook failed'
  73.             traceback.print_exc()
  74.             self.pre_input_hook = None
  75.  
  76.         
  77.         log('in readline: %s' % self.paste_line_buffer)
  78.         if len(self.paste_line_buffer) > 0:
  79.             self.l_buffer = lineobj.ReadlineTextBuffer(self.paste_line_buffer[0])
  80.             self._update_line()
  81.             self.paste_line_buffer = self.paste_line_buffer[1:]
  82.             c.write('\r\n')
  83.         else:
  84.             self._readline_from_keyboard()
  85.             c.write('\r\n')
  86.         self.add_history(self.l_buffer.copy())
  87.         log('returning(%s)' % self.l_buffer.get_line_text())
  88.         return self.l_buffer.get_line_text() + '\n'
  89.  
  90.     
  91.     def beginning_of_line(self, e):
  92.         self.l_buffer.beginning_of_line()
  93.  
  94.     
  95.     def end_of_line(self, e):
  96.         self.l_buffer.end_of_line()
  97.  
  98.     
  99.     def forward_char(self, e):
  100.         self.l_buffer.forward_char()
  101.  
  102.     
  103.     def backward_char(self, e):
  104.         self.l_buffer.backward_char()
  105.  
  106.     
  107.     def forward_word(self, e):
  108.         self.l_buffer.forward_word()
  109.  
  110.     
  111.     def backward_word(self, e):
  112.         self.l_buffer.backward_word()
  113.  
  114.     
  115.     def clear_screen(self, e):
  116.         self.console.page()
  117.  
  118.     
  119.     def redraw_current_line(self, e):
  120.         pass
  121.  
  122.     
  123.     def accept_line(self, e):
  124.         return True
  125.  
  126.     
  127.     def previous_history(self, e):
  128.         self._history.previous_history(self.l_buffer)
  129.  
  130.     
  131.     def next_history(self, e):
  132.         self._history.next_history(self.l_buffer)
  133.  
  134.     
  135.     def beginning_of_history(self, e):
  136.         self._history.beginning_of_history()
  137.  
  138.     
  139.     def end_of_history(self, e):
  140.         self._history.end_of_history(self.l_buffer)
  141.  
  142.     
  143.     def _i_search(self, searchfun, direction, init_event):
  144.         c = self.console
  145.         line = self.get_line_buffer()
  146.         query = ''
  147.         hc_start = self._history.history_cursor
  148.         while None:
  149.             (x, y) = self.prompt_end_pos
  150.             if direction < 0:
  151.                 prompt = 'reverse-i-search'
  152.             else:
  153.                 prompt = 'forward-i-search'
  154.             scroll = c.write_scrolling("%s`%s': %s" % (prompt, query, line))
  155.             self._update_prompt_pos(scroll)
  156.             self._clear_after()
  157.             event = c.getkeypress()
  158.             if event.keysym == 'BackSpace':
  159.                 if len(query) > 0:
  160.                     query = query[:-1]
  161.                     self._history.history_cursor = hc_start
  162.                 else:
  163.                     self._bell()
  164.             elif event.char in string.letters + string.digits + string.punctuation + ' ':
  165.                 self._history.history_cursor = hc_start
  166.                 query += event.char
  167.             elif event.keyinfo == init_event.keyinfo:
  168.                 self._history.history_cursor += direction
  169.                 line = searchfun(query)
  170.             elif event.keysym != 'Return':
  171.                 self._bell()
  172.             
  173.             break
  174.             line = searchfun(query)
  175.             continue
  176.             (px, py) = self.prompt_begin_pos
  177.             c.pos(0, py)
  178.             self.l_buffer.set_line(line)
  179.             self._print_prompt()
  180.             self._history.history_cursor = len(self._history.history)
  181.             return None
  182.  
  183.     
  184.     def reverse_search_history(self, e):
  185.         self._i_search(self._history.reverse_search_history, -1, e)
  186.  
  187.     
  188.     def forward_search_history(self, e):
  189.         self._i_search(self._history.forward_search_history, 1, e)
  190.  
  191.     
  192.     def non_incremental_reverse_search_history(self, e):
  193.         self._history.non_incremental_reverse_search_history(self.l_buffer)
  194.  
  195.     
  196.     def non_incremental_forward_search_history(self, e):
  197.         self._history.non_incremental_reverse_search_history(self.l_buffer)
  198.  
  199.     
  200.     def history_search_forward(self, e):
  201.         self.l_buffer = self._history.history_search_forward(self.l_buffer)
  202.  
  203.     
  204.     def history_search_backward(self, e):
  205.         self.l_buffer = self._history.history_search_backward(self.l_buffer)
  206.  
  207.     
  208.     def yank_nth_arg(self, e):
  209.         pass
  210.  
  211.     
  212.     def yank_last_arg(self, e):
  213.         pass
  214.  
  215.     
  216.     def delete_char(self, e):
  217.         self.l_buffer.delete_char()
  218.  
  219.     
  220.     def backward_delete_char(self, e):
  221.         self.l_buffer.backward_delete_char()
  222.  
  223.     
  224.     def forward_backward_delete_char(self, e):
  225.         pass
  226.  
  227.     
  228.     def quoted_insert(self, e):
  229.         e = self.console.getkeypress()
  230.         self.insert_text(e.char)
  231.  
  232.     
  233.     def tab_insert(self, e):
  234.         ws = ' ' * (self.tabstop - self.line_cursor % self.tabstop)
  235.         self.insert_text(ws)
  236.  
  237.     
  238.     def self_insert(self, e):
  239.         if ord(e.char) != 0:
  240.             self.insert_text(e.char)
  241.         
  242.  
  243.     
  244.     def transpose_chars(self, e):
  245.         self.l_buffer.transpose_chars()
  246.  
  247.     
  248.     def transpose_words(self, e):
  249.         self.l_buffer.transpose_words()
  250.  
  251.     
  252.     def upcase_word(self, e):
  253.         self.l_buffer.upcase_word()
  254.  
  255.     
  256.     def downcase_word(self, e):
  257.         self.l_buffer.downcase_word()
  258.  
  259.     
  260.     def capitalize_word(self, e):
  261.         self.l_buffer.capitalize_word()
  262.  
  263.     
  264.     def overwrite_mode(self, e):
  265.         pass
  266.  
  267.     
  268.     def kill_line(self, e):
  269.         self.l_buffer.kill_line()
  270.  
  271.     
  272.     def backward_kill_line(self, e):
  273.         self.l_buffer.backward_kill_line()
  274.  
  275.     
  276.     def unix_line_discard(self, e):
  277.         self.l_buffer.unix_line_discard()
  278.  
  279.     
  280.     def kill_whole_line(self, e):
  281.         self.l_buffer.kill_whole_line()
  282.  
  283.     
  284.     def kill_word(self, e):
  285.         self.l_buffer.kill_word()
  286.  
  287.     
  288.     def backward_kill_word(self, e):
  289.         self.l_buffer.backward_kill_word()
  290.  
  291.     
  292.     def unix_word_rubout(self, e):
  293.         self.l_buffer.unix_word_rubout()
  294.  
  295.     
  296.     def delete_horizontal_space(self, e):
  297.         pass
  298.  
  299.     
  300.     def kill_region(self, e):
  301.         pass
  302.  
  303.     
  304.     def copy_region_as_kill(self, e):
  305.         pass
  306.  
  307.     
  308.     def copy_region_to_clipboard(self, e):
  309.         if self.enable_win32_clipboard:
  310.             mark = min(self.l_buffer.mark, len(self.l_buffer.line_buffer))
  311.             cursor = min(self.l_buffer.point, len(self.l_buffer.line_buffer))
  312.             if self.l_buffer.mark == -1:
  313.                 return None
  314.             begin = min(cursor, mark)
  315.             end = max(cursor, mark)
  316.             toclipboard = ''.join(self.l_buffer.line_buffer[begin:end])
  317.             clipboard.SetClipboardText(str(toclipboard))
  318.         
  319.  
  320.     
  321.     def copy_backward_word(self, e):
  322.         pass
  323.  
  324.     
  325.     def copy_forward_word(self, e):
  326.         pass
  327.  
  328.     
  329.     def paste(self, e):
  330.         if self.enable_win32_clipboard:
  331.             txt = clipboard.get_clipboard_text_and_convert(False)
  332.             self.insert_text(txt)
  333.         
  334.  
  335.     
  336.     def paste_mulitline_code(self, e):
  337.         reg = re.compile('\r?\n')
  338.         if self.enable_win32_clipboard:
  339.             txt = clipboard.get_clipboard_text_and_convert(False)
  340.             t = reg.split(txt)
  341.             t = _[1]
  342.             if t != [
  343.                 '']:
  344.                 self.insert_text(t[0])
  345.                 self.add_history(self.l_buffer.copy())
  346.                 self.paste_line_buffer = t[1:]
  347.                 log('multi: %s' % self.paste_line_buffer)
  348.                 return True
  349.             return False
  350.         self.enable_win32_clipboard
  351.  
  352.     
  353.     def ipython_paste(self, e):
  354.         if self.enable_win32_clipboard:
  355.             txt = clipboard.get_clipboard_text_and_convert(self.enable_ipython_paste_list_of_lists)
  356.             if self.enable_ipython_paste_for_paths:
  357.                 if len(txt) < 300 and '\t' not in txt and '\n' not in txt:
  358.                     txt = txt.replace('\\', '/').replace(' ', '\\ ')
  359.                 
  360.             
  361.             self.insert_text(txt)
  362.         
  363.  
  364.     
  365.     def yank(self, e):
  366.         pass
  367.  
  368.     
  369.     def yank_pop(self, e):
  370.         pass
  371.  
  372.     
  373.     def digit_argument(self, e):
  374.         pass
  375.  
  376.     
  377.     def universal_argument(self, e):
  378.         pass
  379.  
  380.     
  381.     def delete_char_or_list(self, e):
  382.         pass
  383.  
  384.     
  385.     def start_kbd_macro(self, e):
  386.         pass
  387.  
  388.     
  389.     def end_kbd_macro(self, e):
  390.         pass
  391.  
  392.     
  393.     def call_last_kbd_macro(self, e):
  394.         pass
  395.  
  396.     
  397.     def re_read_init_file(self, e):
  398.         pass
  399.  
  400.     
  401.     def abort(self, e):
  402.         self._bell()
  403.  
  404.     
  405.     def do_uppercase_version(self, e):
  406.         pass
  407.  
  408.     
  409.     def prefix_meta(self, e):
  410.         self.next_meta = True
  411.  
  412.     
  413.     def undo(self, e):
  414.         self.l_buffer.pop_undo()
  415.  
  416.     
  417.     def revert_line(self, e):
  418.         pass
  419.  
  420.     
  421.     def tilde_expand(self, e):
  422.         pass
  423.  
  424.     
  425.     def set_mark(self, e):
  426.         self.l_buffer.set_mark()
  427.  
  428.     
  429.     def exchange_point_and_mark(self, e):
  430.         pass
  431.  
  432.     
  433.     def character_search(self, e):
  434.         pass
  435.  
  436.     
  437.     def character_search_backward(self, e):
  438.         pass
  439.  
  440.     
  441.     def insert_comment(self, e):
  442.         pass
  443.  
  444.     
  445.     def dump_functions(self, e):
  446.         pass
  447.  
  448.     
  449.     def dump_variables(self, e):
  450.         pass
  451.  
  452.     
  453.     def dump_macros(self, e):
  454.         pass
  455.  
  456.     
  457.     def init_editing_mode(self, e):
  458.         self._bind_exit_key('Control-d')
  459.         self._bind_exit_key('Control-z')
  460.         self._bind_key('Shift-space', self.self_insert)
  461.         self._bind_key('Control-space', self.self_insert)
  462.         self._bind_key('Return', self.accept_line)
  463.         self._bind_key('Left', self.backward_char)
  464.         self._bind_key('Control-b', self.backward_char)
  465.         self._bind_key('Right', self.forward_char)
  466.         self._bind_key('Control-f', self.forward_char)
  467.         self._bind_key('BackSpace', self.backward_delete_char)
  468.         self._bind_key('Home', self.beginning_of_line)
  469.         self._bind_key('End', self.end_of_line)
  470.         self._bind_key('Delete', self.delete_char)
  471.         self._bind_key('Control-d', self.delete_char)
  472.         self._bind_key('Clear', self.clear_screen)
  473.  
  474.  
  475.  
  476. def commonprefix(m):
  477.     if not m:
  478.         return ''
  479.     prefix = m[0]
  480.     for item in m:
  481.         for i in range(len(prefix)):
  482.             if prefix[:i + 1].lower() != item[:i + 1].lower():
  483.                 prefix = prefix[:i]
  484.                 if i == 0:
  485.                     return ''
  486.                 break
  487.                 continue
  488.             i == 0
  489.         
  490.     
  491.     return prefix
  492.  
  493.