home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / lib / gedit-2 / plugins / pythonconsole / console.pyc (.txt) < prev   
Encoding:
Python Compiled Bytecode  |  2009-04-20  |  11.1 KB  |  311 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import string
  5. import sys
  6. import re
  7. import traceback
  8. import gobject
  9. import gtk
  10. import pango
  11. from config import PythonConsoleConfig
  12. __all__ = ('PythonConsole', 'OutFile')
  13.  
  14. class PythonConsole(gtk.ScrolledWindow):
  15.     
  16.     def __init__(self, namespace = { }):
  17.         gtk.ScrolledWindow.__init__(self)
  18.         self.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
  19.         self.set_shadow_type(gtk.SHADOW_IN)
  20.         self.view = gtk.TextView()
  21.         self.view.modify_font(pango.FontDescription('Monospace'))
  22.         self.view.set_editable(True)
  23.         self.view.set_wrap_mode(gtk.WRAP_WORD_CHAR)
  24.         self.add(self.view)
  25.         self.view.show()
  26.         buffer = self.view.get_buffer()
  27.         self.normal = buffer.create_tag('normal')
  28.         self.error = buffer.create_tag('error')
  29.         self.command = buffer.create_tag('command')
  30.         PythonConsoleConfig.add_handler(self.apply_preferences)
  31.         self.apply_preferences()
  32.         self._PythonConsole__spaces_pattern = re.compile('^\\s+')
  33.         self.namespace = namespace
  34.         self.block_command = False
  35.         buffer.create_mark('input-line', buffer.get_end_iter(), True)
  36.         buffer.insert(buffer.get_end_iter(), '>>> ')
  37.         buffer.create_mark('input', buffer.get_end_iter(), True)
  38.         self.history = [
  39.             '']
  40.         self.history_pos = 0
  41.         self.current_command = ''
  42.         self.namespace['__history__'] = self.history
  43.         self.stdout = OutFile(self, sys.stdout.fileno(), self.normal)
  44.         self.stderr = OutFile(self, sys.stderr.fileno(), self.error)
  45.         self.view.connect('key-press-event', self._PythonConsole__key_press_event_cb)
  46.         buffer.connect('mark-set', self._PythonConsole__mark_set_cb)
  47.  
  48.     
  49.     def apply_preferences(self, *args):
  50.         config = PythonConsoleConfig()
  51.         self.error.set_property('foreground', config.color_error)
  52.         self.command.set_property('foreground', config.color_command)
  53.  
  54.     
  55.     def stop(self):
  56.         self.namespace = None
  57.  
  58.     
  59.     def __key_press_event_cb(self, view, event):
  60.         modifier_mask = gtk.accelerator_get_default_mod_mask()
  61.         event_state = event.state & modifier_mask
  62.         if event.keyval == gtk.keysyms.d and event_state == gtk.gdk.CONTROL_MASK:
  63.             self.destroy()
  64.         elif event.keyval == gtk.keysyms.Return and event_state == gtk.gdk.CONTROL_MASK:
  65.             buffer = view.get_buffer()
  66.             inp_mark = buffer.get_mark('input')
  67.             inp = buffer.get_iter_at_mark(inp_mark)
  68.             cur = buffer.get_end_iter()
  69.             line = buffer.get_text(inp, cur)
  70.             self.current_command = self.current_command + line + '\n'
  71.             self.history_add(line)
  72.             cur = buffer.get_end_iter()
  73.             buffer.insert(cur, '\n... ')
  74.             cur = buffer.get_end_iter()
  75.             buffer.move_mark(inp_mark, cur)
  76.             spaces = re.match(self._PythonConsole__spaces_pattern, line)
  77.             if spaces is not None:
  78.                 buffer.insert(cur, line[spaces.start():spaces.end()])
  79.                 cur = buffer.get_end_iter()
  80.             
  81.             buffer.place_cursor(cur)
  82.             gobject.idle_add(self.scroll_to_end)
  83.             return True
  84.         if event.keyval == gtk.keysyms.Return:
  85.             buffer = view.get_buffer()
  86.             lin_mark = buffer.get_mark('input-line')
  87.             inp_mark = buffer.get_mark('input')
  88.             inp = buffer.get_iter_at_mark(inp_mark)
  89.             cur = buffer.get_end_iter()
  90.             line = buffer.get_text(inp, cur)
  91.             self.current_command = self.current_command + line + '\n'
  92.             self.history_add(line)
  93.             lin = buffer.get_iter_at_mark(lin_mark)
  94.             buffer.apply_tag(self.command, lin, cur)
  95.             buffer.insert(cur, '\n')
  96.             cur_strip = self.current_command.rstrip()
  97.             if (cur_strip.endswith(':') or self.current_command[-2:] != '\n\n') and self.block_command:
  98.                 self.block_command = True
  99.                 com_mark = '... '
  100.             elif cur_strip.endswith('\\'):
  101.                 com_mark = '... '
  102.             else:
  103.                 self._PythonConsole__run(self.current_command)
  104.                 self.current_command = ''
  105.                 self.block_command = False
  106.                 com_mark = '>>> '
  107.             cur = buffer.get_end_iter()
  108.             buffer.move_mark(lin_mark, cur)
  109.             buffer.insert(cur, com_mark)
  110.             cur = buffer.get_end_iter()
  111.             buffer.move_mark(inp_mark, cur)
  112.             buffer.place_cursor(cur)
  113.             gobject.idle_add(self.scroll_to_end)
  114.             return True
  115.         if event.keyval == gtk.keysyms.KP_Down or event.keyval == gtk.keysyms.Down:
  116.             view.emit_stop_by_name('key_press_event')
  117.             self.history_down()
  118.             gobject.idle_add(self.scroll_to_end)
  119.             return True
  120.         if event.keyval == gtk.keysyms.KP_Up or event.keyval == gtk.keysyms.Up:
  121.             view.emit_stop_by_name('key_press_event')
  122.             self.history_up()
  123.             gobject.idle_add(self.scroll_to_end)
  124.             return True
  125.         if event.keyval == gtk.keysyms.KP_Left and event.keyval == gtk.keysyms.Left or event.keyval == gtk.keysyms.BackSpace:
  126.             buffer = view.get_buffer()
  127.             inp = buffer.get_iter_at_mark(buffer.get_mark('input'))
  128.             cur = buffer.get_iter_at_mark(buffer.get_insert())
  129.             if inp.compare(cur) == 0:
  130.                 return True
  131.             return False
  132.         if (event.keyval == gtk.keysyms.KP_Home or event.keyval == gtk.keysyms.Home) and event_state == event_state & (gtk.gdk.SHIFT_MASK | gtk.gdk.CONTROL_MASK):
  133.             buffer = view.get_buffer()
  134.             inp = buffer.get_iter_at_mark(buffer.get_mark('input'))
  135.             return True
  136.  
  137.     
  138.     def __mark_set_cb(self, buffer, iter, name):
  139.         input = buffer.get_iter_at_mark(buffer.get_mark('input'))
  140.         pos = buffer.get_iter_at_mark(buffer.get_insert())
  141.         self.view.set_editable(pos.compare(input) != -1)
  142.  
  143.     
  144.     def get_command_line(self):
  145.         buffer = self.view.get_buffer()
  146.         inp = buffer.get_iter_at_mark(buffer.get_mark('input'))
  147.         cur = buffer.get_end_iter()
  148.         return buffer.get_text(inp, cur)
  149.  
  150.     
  151.     def set_command_line(self, command):
  152.         buffer = self.view.get_buffer()
  153.         mark = buffer.get_mark('input')
  154.         inp = buffer.get_iter_at_mark(mark)
  155.         cur = buffer.get_end_iter()
  156.         buffer.delete(inp, cur)
  157.         buffer.insert(inp, command)
  158.         self.view.grab_focus()
  159.  
  160.     
  161.     def history_add(self, line):
  162.         if line.strip() != '':
  163.             self.history_pos = len(self.history)
  164.             self.history[self.history_pos - 1] = line
  165.             self.history.append('')
  166.         
  167.  
  168.     
  169.     def history_up(self):
  170.         if self.history_pos > 0:
  171.             self.history[self.history_pos] = self.get_command_line()
  172.             self.history_pos = self.history_pos - 1
  173.             self.set_command_line(self.history[self.history_pos])
  174.         
  175.  
  176.     
  177.     def history_down(self):
  178.         if self.history_pos < len(self.history) - 1:
  179.             self.history[self.history_pos] = self.get_command_line()
  180.             self.history_pos = self.history_pos + 1
  181.             self.set_command_line(self.history[self.history_pos])
  182.         
  183.  
  184.     
  185.     def scroll_to_end(self):
  186.         iter = self.view.get_buffer().get_end_iter()
  187.         self.view.scroll_to_iter(iter, 0)
  188.         return False
  189.  
  190.     
  191.     def write(self, text, tag = None):
  192.         buffer = self.view.get_buffer()
  193.         if tag is None:
  194.             buffer.insert(buffer.get_end_iter(), text)
  195.         else:
  196.             buffer.insert_with_tags(buffer.get_end_iter(), text, tag)
  197.         gobject.idle_add(self.scroll_to_end)
  198.  
  199.     
  200.     def eval(self, command, display_command = False):
  201.         buffer = self.view.get_buffer()
  202.         lin = buffer.get_mark('input-line')
  203.         buffer.delete(buffer.get_iter_at_mark(lin), buffer.get_end_iter())
  204.         if isinstance(command, list) or isinstance(command, tuple):
  205.             for c in command:
  206.                 if display_command:
  207.                     self.write('>>> ' + c + '\n', self.command)
  208.                 
  209.                 self._PythonConsole__run(c)
  210.             
  211.         elif display_command:
  212.             self.write('>>> ' + c + '\n', self.command)
  213.         
  214.         self._PythonConsole__run(command)
  215.         cur = buffer.get_end_iter()
  216.         buffer.move_mark_by_name('input-line', cur)
  217.         buffer.insert(cur, '>>> ')
  218.         cur = buffer.get_end_iter()
  219.         buffer.move_mark_by_name('input', cur)
  220.         self.view.scroll_to_iter(buffer.get_end_iter(), 0)
  221.  
  222.     
  223.     def __run(self, command):
  224.         sys.stdout = self.stdout
  225.         self.stdout = sys.stdout
  226.         sys.stderr = self.stderr
  227.         self.stderr = sys.stderr
  228.         command = command.decode('utf8')
  229.         
  230.         try:
  231.             
  232.             try:
  233.                 r = eval(command, self.namespace, self.namespace)
  234.                 if r is not None:
  235.                     print `r`
  236.             except SyntaxError:
  237.                 exec command in self.namespace
  238.  
  239.         except:
  240.             if hasattr(sys, 'last_type') and sys.last_type == SystemExit:
  241.                 self.destroy()
  242.             else:
  243.                 traceback.print_exc()
  244.  
  245.         sys.stdout = self.stdout
  246.         self.stdout = sys.stdout
  247.         sys.stderr = self.stderr
  248.         self.stderr = sys.stderr
  249.  
  250.     
  251.     def destroy(self):
  252.         pass
  253.  
  254.  
  255.  
  256. class OutFile:
  257.     '''A fake output file object. It sends output to a TK test widget,
  258. \tand if asked for a file number, returns one set on instance creation'''
  259.     
  260.     def __init__(self, console, fn, tag):
  261.         self.fn = fn
  262.         self.console = console
  263.         self.tag = tag
  264.  
  265.     
  266.     def close(self):
  267.         pass
  268.  
  269.     
  270.     def flush(self):
  271.         pass
  272.  
  273.     
  274.     def fileno(self):
  275.         return self.fn
  276.  
  277.     
  278.     def isatty(self):
  279.         return 0
  280.  
  281.     
  282.     def read(self, a):
  283.         return ''
  284.  
  285.     
  286.     def readline(self):
  287.         return ''
  288.  
  289.     
  290.     def readlines(self):
  291.         return []
  292.  
  293.     
  294.     def write(self, s):
  295.         self.console.write(s, self.tag)
  296.  
  297.     
  298.     def writelines(self, l):
  299.         self.console.write(l, self.tag)
  300.  
  301.     
  302.     def seek(self, a):
  303.         raise IOError, (29, 'Illegal seek')
  304.  
  305.     
  306.     def tell(self):
  307.         raise IOError, (29, 'Illegal seek')
  308.  
  309.     truncate = tell
  310.  
  311.