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