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