home *** CD-ROM | disk | FTP | other *** search
/ PC Welt 2006 November (DVD) / PCWELT_11_2006.ISO / casper / filesystem.squashfs / usr / lib / rhythmbox / plugins / pythonconsole.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2006-08-30  |  11.9 KB  |  355 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. import string
  5. import sys
  6. import re
  7. import traceback
  8. import gobject
  9. import gtk
  10. import pango
  11. from gettext import gettext as _
  12. import rhythmdb
  13. import rb
  14. ui_str = '\n<ui>\n  <menubar name="MenuBar">\n    <menu name="ToolsMenu" action="Tools">\n      <placeholder name="ToolsOps_5">\n        <menuitem name="PythonConsole" action="PythonConsole"/>\n      </placeholder>\n    </menu>\n  </menubar>\n</ui>\n'
  15.  
  16. class PythonConsolePlugin(rb.Plugin):
  17.     
  18.     def __init__(self):
  19.         rb.Plugin.__init__(self)
  20.         self.window = None
  21.  
  22.     
  23.     def activate(self, shell):
  24.         data = dict()
  25.         manager = shell.get_player().get_property('ui-manager')
  26.         action = gtk.Action('PythonConsole', _('_Python Console'), _("Show Rhythmbox's python console"), 'gnome-mime-text-x-python')
  27.         action.connect('activate', self.show_console, shell)
  28.         data['action_group'] = gtk.ActionGroup('PythonConsolePluginActions')
  29.         data['action_group'].add_action(action)
  30.         manager.insert_action_group(data['action_group'], 0)
  31.         data['ui_id'] = manager.add_ui_from_string(ui_str)
  32.         manager.ensure_update()
  33.         shell.set_data('PythonConsolePluginInfo', data)
  34.  
  35.     
  36.     def deactivate(self, shell):
  37.         data = shell.get_data('PythonConsolePluginInfo')
  38.         manager = shell.get_player().get_property('ui-manager')
  39.         manager.remove_ui(data['ui_id'])
  40.         manager.remove_action_group(data['action_group'])
  41.         manager.ensure_update()
  42.         shell.set_data('PythonConsolePluginInfo', None)
  43.         if self.window is not None:
  44.             self.window.destroy()
  45.         
  46.  
  47.     
  48.     def show_console(self, action, shell):
  49.         if not self.window:
  50.             ns = {
  51.                 '__builtins__': __builtins__,
  52.                 'rb': rb,
  53.                 'rhythmdb': rhythmdb,
  54.                 'shell': shell }
  55.             console = PythonConsole(namespace = ns, destroy_cb = self.destroy_console)
  56.             console.set_size_request(600, 400)
  57.             console.eval('print "' + _("You can access the main window through the 'shell' variable :") + '\\n%s" % shell', False)
  58.             self.window = gtk.Window()
  59.             self.window.set_title('Rhythmbox Python Console')
  60.             self.window.add(console)
  61.             self.window.connect('destroy', self.destroy_console)
  62.             self.window.show_all()
  63.         else:
  64.             self.window.show_all()
  65.         self.window.grab_focus()
  66.  
  67.     
  68.     def destroy_console(self, *args):
  69.         self.window.destroy()
  70.         self.window = None
  71.  
  72.  
  73.  
  74. class PythonConsole(gtk.ScrolledWindow):
  75.     
  76.     def __init__(self, namespace = { }, destroy_cb = None):
  77.         gtk.ScrolledWindow.__init__(self)
  78.         self.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
  79.         self.set_shadow_type(gtk.SHADOW_IN)
  80.         self.view = gtk.TextView()
  81.         self.view.modify_font(pango.FontDescription('Monospace'))
  82.         self.view.set_editable(True)
  83.         self.view.set_wrap_mode(gtk.WRAP_WORD_CHAR)
  84.         self.add(self.view)
  85.         self.view.show()
  86.         buffer = self.view.get_buffer()
  87.         self.normal = buffer.create_tag('normal')
  88.         self.error = buffer.create_tag('error')
  89.         self.error.set_property('foreground', 'red')
  90.         self.command = buffer.create_tag('command')
  91.         self.command.set_property('foreground', 'blue')
  92.         self._PythonConsole__spaces_pattern = re.compile('^\\s+')
  93.         self.namespace = namespace
  94.         self.destroy_cb = destroy_cb
  95.         buffer.create_mark('input-line', buffer.get_end_iter(), True)
  96.         buffer.insert(buffer.get_end_iter(), '>>> ')
  97.         buffer.create_mark('input', buffer.get_end_iter(), True)
  98.         self.history = [
  99.             '']
  100.         self.history_pos = 0
  101.         self.current_command = ''
  102.         self.namespace['__history__'] = self.history
  103.         self.stdout = gtkoutfile(self, sys.stdout.fileno(), self.normal)
  104.         self.stderr = gtkoutfile(self, sys.stderr.fileno(), self.error)
  105.         self.view.connect('key-press-event', self._PythonConsole__key_press_event_cb)
  106.         buffer.connect('mark-set', self._PythonConsole__mark_set_cb)
  107.  
  108.     
  109.     def __key_press_event_cb(self, view, event):
  110.         if event.keyval == gtk.keysyms.d and event.state == gtk.gdk.CONTROL_MASK:
  111.             self.destroy()
  112.         elif event.keyval == gtk.keysyms.Return and event.state == gtk.gdk.CONTROL_MASK:
  113.             buffer = view.get_buffer()
  114.             inp_mark = buffer.get_mark('input')
  115.             inp = buffer.get_iter_at_mark(inp_mark)
  116.             cur = buffer.get_end_iter()
  117.             line = buffer.get_text(inp, cur)
  118.             self.current_command = self.current_command + line + '\n'
  119.             self.history_add(line)
  120.             cur = buffer.get_end_iter()
  121.             buffer.insert(cur, '\n... ')
  122.             cur = buffer.get_end_iter()
  123.             buffer.move_mark(inp_mark, cur)
  124.             spaces = re.match(self._PythonConsole__spaces_pattern, line)
  125.             if spaces is not None:
  126.                 buffer.insert(cur, line[spaces.start():spaces.end()])
  127.                 cur = buffer.get_end_iter()
  128.             
  129.             buffer.place_cursor(cur)
  130.             gobject.idle_add(self.scroll_to_end)
  131.             return True
  132.         elif event.keyval == gtk.keysyms.Return:
  133.             buffer = view.get_buffer()
  134.             lin_mark = buffer.get_mark('input-line')
  135.             inp_mark = buffer.get_mark('input')
  136.             inp = buffer.get_iter_at_mark(inp_mark)
  137.             cur = buffer.get_end_iter()
  138.             line = buffer.get_text(inp, cur)
  139.             self.current_command = self.current_command + line + '\n'
  140.             self.history_add(line)
  141.             lin = buffer.get_iter_at_mark(lin_mark)
  142.             buffer.apply_tag(self.command, lin, cur)
  143.             buffer.insert(cur, '\n')
  144.             self._PythonConsole__run(self.current_command)
  145.             self.current_command = ''
  146.             cur = buffer.get_end_iter()
  147.             buffer.move_mark(lin_mark, cur)
  148.             buffer.insert(cur, '>>> ')
  149.             cur = buffer.get_end_iter()
  150.             buffer.move_mark(inp_mark, cur)
  151.             buffer.place_cursor(cur)
  152.             gobject.idle_add(self.scroll_to_end)
  153.             return True
  154.         elif event.keyval == gtk.keysyms.KP_Down or event.keyval == gtk.keysyms.Down:
  155.             view.emit_stop_by_name('key_press_event')
  156.             self.history_down()
  157.             gobject.idle_add(self.scroll_to_end)
  158.             return True
  159.         elif event.keyval == gtk.keysyms.KP_Up or event.keyval == gtk.keysyms.Up:
  160.             view.emit_stop_by_name('key_press_event')
  161.             self.history_up()
  162.             gobject.idle_add(self.scroll_to_end)
  163.             return True
  164.         elif event.keyval == gtk.keysyms.KP_Left and event.keyval == gtk.keysyms.Left or event.keyval == gtk.keysyms.BackSpace:
  165.             buffer = view.get_buffer()
  166.             inp = buffer.get_iter_at_mark(buffer.get_mark('input'))
  167.             cur = buffer.get_iter_at_mark(buffer.get_insert())
  168.             return inp.compare(cur) == 0
  169.         elif event.keyval == gtk.keysyms.Home:
  170.             buffer = view.get_buffer()
  171.             inp = buffer.get_iter_at_mark(buffer.get_mark('input'))
  172.             if event.state == gtk.gdk.SHIFT_MASK:
  173.                 buffer.move_mark_by_name('insert', inp)
  174.             else:
  175.                 buffer.place_cursor(inp)
  176.             return True
  177.         
  178.  
  179.     
  180.     def __mark_set_cb(self, buffer, iter, name):
  181.         input = buffer.get_iter_at_mark(buffer.get_mark('input'))
  182.         pos = buffer.get_iter_at_mark(buffer.get_insert())
  183.         self.view.set_editable(pos.compare(input) != -1)
  184.  
  185.     
  186.     def get_command_line(self):
  187.         buffer = self.view.get_buffer()
  188.         inp = buffer.get_iter_at_mark(buffer.get_mark('input'))
  189.         cur = buffer.get_end_iter()
  190.         return buffer.get_text(inp, cur)
  191.  
  192.     
  193.     def set_command_line(self, command):
  194.         buffer = self.view.get_buffer()
  195.         mark = buffer.get_mark('input')
  196.         inp = buffer.get_iter_at_mark(mark)
  197.         cur = buffer.get_end_iter()
  198.         buffer.delete(inp, cur)
  199.         buffer.insert(inp, command)
  200.         buffer.select_range(buffer.get_iter_at_mark(mark), buffer.get_end_iter())
  201.         self.view.grab_focus()
  202.  
  203.     
  204.     def history_add(self, line):
  205.         if line.strip() != '':
  206.             self.history_pos = len(self.history)
  207.             self.history[self.history_pos - 1] = line
  208.             self.history.append('')
  209.         
  210.  
  211.     
  212.     def history_up(self):
  213.         if self.history_pos > 0:
  214.             self.history[self.history_pos] = self.get_command_line()
  215.             self.history_pos = self.history_pos - 1
  216.             self.set_command_line(self.history[self.history_pos])
  217.         
  218.  
  219.     
  220.     def history_down(self):
  221.         if self.history_pos < len(self.history) - 1:
  222.             self.history[self.history_pos] = self.get_command_line()
  223.             self.history_pos = self.history_pos + 1
  224.             self.set_command_line(self.history[self.history_pos])
  225.         
  226.  
  227.     
  228.     def scroll_to_end(self):
  229.         iter = self.view.get_buffer().get_end_iter()
  230.         self.view.scroll_to_iter(iter, 0.0)
  231.         return False
  232.  
  233.     
  234.     def write(self, text, tag = None):
  235.         buffer = self.view.get_buffer()
  236.         if tag is None:
  237.             buffer.insert(buffer.get_end_iter(), text)
  238.         else:
  239.             buffer.insert_with_tags(buffer.get_end_iter(), text, tag)
  240.         gobject.idle_add(self.scroll_to_end)
  241.  
  242.     
  243.     def eval(self, command, display_command = False):
  244.         buffer = self.view.get_buffer()
  245.         lin = buffer.get_mark('input-line')
  246.         buffer.delete(buffer.get_iter_at_mark(lin), buffer.get_end_iter())
  247.         if isinstance(command, list) or isinstance(command, tuple):
  248.             for c in command:
  249.                 if display_command:
  250.                     self.write('>>> ' + c + '\n', self.command)
  251.                 
  252.                 self._PythonConsole__run(c)
  253.             
  254.         elif display_command:
  255.             self.write('>>> ' + c + '\n', self.command)
  256.         
  257.         self._PythonConsole__run(command)
  258.         cur = buffer.get_end_iter()
  259.         buffer.move_mark_by_name('input-line', cur)
  260.         buffer.insert(cur, '>>> ')
  261.         cur = buffer.get_end_iter()
  262.         buffer.move_mark_by_name('input', cur)
  263.         self.view.scroll_to_iter(buffer.get_end_iter(), 0.0)
  264.  
  265.     
  266.     def __run(self, command):
  267.         sys.stdout = self.stdout
  268.         self.stdout = sys.stdout
  269.         sys.stderr = self.stderr
  270.         self.stderr = sys.stderr
  271.         
  272.         try:
  273.             
  274.             try:
  275.                 r = eval(command, self.namespace, self.namespace)
  276.                 if r is not None:
  277.                     print `r`
  278.             except SyntaxError:
  279.                 exec command in self.namespace
  280.  
  281.         except:
  282.             if hasattr(sys, 'last_type') and sys.last_type == SystemExit:
  283.                 self.destroy()
  284.             else:
  285.                 traceback.print_exc()
  286.  
  287.         sys.stdout = self.stdout
  288.         self.stdout = sys.stdout
  289.         sys.stderr = self.stderr
  290.         self.stderr = sys.stderr
  291.  
  292.     
  293.     def destroy(self):
  294.         if self.destroy_cb is not None:
  295.             self.destroy_cb()
  296.         
  297.  
  298.  
  299.  
  300. class gtkoutfile:
  301.     '''A fake output file object.  It sends output to a TK test widget,
  302. \tand if asked for a file number, returns one set on instance creation'''
  303.     
  304.     def __init__(self, console, fn, tag):
  305.         self.fn = fn
  306.         self.console = console
  307.         self.tag = tag
  308.  
  309.     
  310.     def close(self):
  311.         pass
  312.  
  313.     
  314.     def flush(self):
  315.         pass
  316.  
  317.     
  318.     def fileno(self):
  319.         return self.fn
  320.  
  321.     
  322.     def isatty(self):
  323.         return 0
  324.  
  325.     
  326.     def read(self, a):
  327.         return ''
  328.  
  329.     
  330.     def readline(self):
  331.         return ''
  332.  
  333.     
  334.     def readlines(self):
  335.         return []
  336.  
  337.     
  338.     def write(self, s):
  339.         self.console.write(s, self.tag)
  340.  
  341.     
  342.     def writelines(self, l):
  343.         self.console.write(l, self.tag)
  344.  
  345.     
  346.     def seek(self, a):
  347.         raise IOError, (29, 'Illegal seek')
  348.  
  349.     
  350.     def tell(self):
  351.         raise IOError, (29, 'Illegal seek')
  352.  
  353.     truncate = tell
  354.  
  355.