home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / lib / totem / plugins / pythonconsole / console.py next >
Encoding:
Python Source  |  2009-04-14  |  9.9 KB  |  312 lines
  1. # -*- coding: utf-8 -*-
  2.  
  3. # console.py -- Console widget
  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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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. # The Totem project hereby grant permission for non-gpl compatible GStreamer
  28. # plugins to be used and distributed together with GStreamer and Totem. This
  29. # permission are above and beyond the permissions granted by the GPL license
  30. # Totem is covered by.
  31. #
  32. # Monday 7th February 2005: Christian Schaller: Add exception clause.
  33. # See license_change file for details.
  34.  
  35. import string
  36. import sys
  37. import re
  38. import traceback
  39. import gobject
  40. import pango
  41. import gtk
  42.  
  43. class PythonConsole(gtk.ScrolledWindow):
  44.     def __init__(self, namespace = {}, destroy_cb = None):
  45.         gtk.ScrolledWindow.__init__(self)
  46.  
  47.         self.destroy_cb = destroy_cb
  48.         self.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC);
  49.         self.set_shadow_type(gtk.SHADOW_IN)
  50.         self.view = gtk.TextView()
  51.         self.view.modify_font(pango.FontDescription('Monospace'))
  52.         self.view.set_editable(True)
  53.         self.view.set_wrap_mode(gtk.WRAP_WORD_CHAR)
  54.         self.add(self.view)
  55.         self.view.show()
  56.  
  57.         buffer = self.view.get_buffer()
  58.         self.normal = buffer.create_tag("normal")
  59.         self.error  = buffer.create_tag("error")
  60.         self.error.set_property("foreground", "red")
  61.         self.command = buffer.create_tag("command")
  62.         self.command.set_property("foreground", "blue")
  63.  
  64.         self.__spaces_pattern = re.compile(r'^\s+')        
  65.         self.namespace = namespace
  66.  
  67.         self.block_command = False
  68.  
  69.         # Init first line
  70.         buffer.create_mark("input-line", buffer.get_end_iter(), True)
  71.         buffer.insert(buffer.get_end_iter(), ">>> ")
  72.         buffer.create_mark("input", buffer.get_end_iter(), True)
  73.  
  74.         # Init history
  75.         self.history = ['']
  76.         self.history_pos = 0
  77.         self.current_command = ''
  78.         self.namespace['__history__'] = self.history
  79.  
  80.         # Set up hooks for standard output.
  81.         self.stdout = OutFile(self, sys.stdout.fileno(), self.normal)
  82.         self.stderr = OutFile(self, sys.stderr.fileno(), self.error)
  83.         
  84.         # Signals
  85.         self.view.connect("key-press-event", self.__key_press_event_cb)
  86.         buffer.connect("mark-set", self.__mark_set_cb)
  87.         
  88.          
  89.     def __key_press_event_cb(self, view, event):
  90.         if event.keyval == gtk.keysyms.d and event.state == gtk.gdk.CONTROL_MASK:
  91.             self.destroy()
  92.         
  93.         elif event.keyval == gtk.keysyms.Return and event.state == gtk.gdk.CONTROL_MASK:
  94.             # Get the command
  95.             buffer = view.get_buffer()
  96.             inp_mark = buffer.get_mark("input")
  97.             inp = buffer.get_iter_at_mark(inp_mark)
  98.             cur = buffer.get_end_iter()
  99.             line = buffer.get_text(inp, cur)
  100.             self.current_command = self.current_command + line + "\n"
  101.             self.history_add(line)
  102.  
  103.             # Prepare the new line
  104.             cur = buffer.get_end_iter()
  105.             buffer.insert(cur, "\n... ")
  106.             cur = buffer.get_end_iter()
  107.             buffer.move_mark(inp_mark, cur)
  108.             
  109.             # Keep indentation of precendent line
  110.             spaces = re.match(self.__spaces_pattern, line)
  111.             if spaces is not None:
  112.                 buffer.insert(cur, line[spaces.start() : spaces.end()])
  113.                 cur = buffer.get_end_iter()
  114.                 
  115.             buffer.place_cursor(cur)
  116.             gobject.idle_add(self.scroll_to_end)
  117.             return True
  118.         
  119.         elif event.keyval == gtk.keysyms.Return:
  120.             # Get the marks
  121.             buffer = view.get_buffer()
  122.             lin_mark = buffer.get_mark("input-line")
  123.             inp_mark = buffer.get_mark("input")
  124.  
  125.             # Get the command line
  126.             inp = buffer.get_iter_at_mark(inp_mark)
  127.             cur = buffer.get_end_iter()
  128.             line = buffer.get_text(inp, cur)
  129.             self.current_command = self.current_command + line + "\n"
  130.             self.history_add(line)
  131.  
  132.             # Make the line blue
  133.             lin = buffer.get_iter_at_mark(lin_mark)
  134.             buffer.apply_tag(self.command, lin, cur)
  135.             buffer.insert(cur, "\n")
  136.             
  137.             cur_strip = self.current_command.rstrip()
  138.  
  139.             if cur_strip.endswith(":") \
  140.             or (self.current_command[-2:] != "\n\n" and self.block_command):
  141.                 # Unfinished block command
  142.                 self.block_command = True
  143.                 com_mark = "... "
  144.             elif cur_strip.endswith("\\"):
  145.                 com_mark = "... "
  146.             else:
  147.                 # Eval the command
  148.                 self.__run(self.current_command)
  149.                 self.current_command = ''
  150.                 self.block_command = False
  151.                 com_mark = ">>> "
  152.  
  153.             # Prepare the new line
  154.             cur = buffer.get_end_iter()
  155.             buffer.move_mark(lin_mark, cur)
  156.             buffer.insert(cur, com_mark)
  157.             cur = buffer.get_end_iter()
  158.             buffer.move_mark(inp_mark, cur)
  159.             buffer.place_cursor(cur)
  160.             gobject.idle_add(self.scroll_to_end)
  161.             return True
  162.  
  163.         elif event.keyval == gtk.keysyms.KP_Down or event.keyval == gtk.keysyms.Down:
  164.             # Next entry from history
  165.             view.emit_stop_by_name("key_press_event")
  166.             self.history_down()
  167.             gobject.idle_add(self.scroll_to_end)
  168.             return True
  169.  
  170.         elif event.keyval == gtk.keysyms.KP_Up or event.keyval == gtk.keysyms.Up:
  171.             # Previous entry from history
  172.             view.emit_stop_by_name("key_press_event")
  173.             self.history_up()
  174.             gobject.idle_add(self.scroll_to_end)
  175.             return True
  176.  
  177.         elif event.keyval == gtk.keysyms.KP_Left or event.keyval == gtk.keysyms.Left or \
  178.              event.keyval == gtk.keysyms.BackSpace:
  179.             buffer = view.get_buffer()
  180.             inp = buffer.get_iter_at_mark(buffer.get_mark("input"))
  181.             cur = buffer.get_iter_at_mark(buffer.get_insert())
  182.             return inp.compare(cur) == 0
  183.  
  184.         elif event.keyval == gtk.keysyms.Home:
  185.             # Go to the begin of the command instead of the begin of the line
  186.             buffer = view.get_buffer()
  187.             inp = buffer.get_iter_at_mark(buffer.get_mark("input"))
  188.             if event.state == gtk.gdk.SHIFT_MASK:
  189.                 buffer.move_mark_by_name("insert", inp)
  190.             else:
  191.                 buffer.place_cursor(inp)
  192.             return True
  193.         
  194.     def __mark_set_cb(self, buffer, iter, name):
  195.         input = buffer.get_iter_at_mark(buffer.get_mark("input"))
  196.         pos   = buffer.get_iter_at_mark(buffer.get_insert())
  197.         self.view.set_editable(pos.compare(input) != -1)
  198.  
  199.     def get_command_line(self):
  200.         buffer = self.view.get_buffer()
  201.         inp = buffer.get_iter_at_mark(buffer.get_mark("input"))
  202.         cur = buffer.get_end_iter()
  203.         return buffer.get_text(inp, cur)
  204.     
  205.     def set_command_line(self, command):
  206.         buffer = self.view.get_buffer()
  207.         mark = buffer.get_mark("input")
  208.         inp = buffer.get_iter_at_mark(mark)
  209.         cur = buffer.get_end_iter()
  210.         buffer.delete(inp, cur)
  211.         buffer.insert(inp, command)
  212.         buffer.select_range(buffer.get_iter_at_mark(mark), buffer.get_end_iter())
  213.         self.view.grab_focus()
  214.     
  215.     def history_add(self, line):
  216.         if line.strip() != '':
  217.             self.history_pos = len(self.history)
  218.             self.history[self.history_pos - 1] = line
  219.             self.history.append('')
  220.     
  221.     def history_up(self):
  222.         if self.history_pos > 0:
  223.             self.history[self.history_pos] = self.get_command_line()
  224.             self.history_pos = self.history_pos - 1
  225.             self.set_command_line(self.history[self.history_pos])
  226.             
  227.     def history_down(self):
  228.         if self.history_pos < len(self.history) - 1:
  229.             self.history[self.history_pos] = self.get_command_line()
  230.             self.history_pos = self.history_pos + 1
  231.             self.set_command_line(self.history[self.history_pos])
  232.     
  233.     def scroll_to_end(self):
  234.         iter = self.view.get_buffer().get_end_iter()
  235.         self.view.scroll_to_iter(iter, 0.0)
  236.         return False
  237.  
  238.     def write(self, text, tag = None):
  239.         buffer = self.view.get_buffer()
  240.         if tag is None:
  241.             buffer.insert(buffer.get_end_iter(), text)
  242.         else:
  243.             buffer.insert_with_tags(buffer.get_end_iter(), text, tag)
  244.         gobject.idle_add(self.scroll_to_end)
  245.      
  246.      def eval(self, command, display_command = False):
  247.         buffer = self.view.get_buffer()
  248.         lin = buffer.get_mark("input-line")
  249.         buffer.delete(buffer.get_iter_at_mark(lin),
  250.                       buffer.get_end_iter())
  251.  
  252.         if isinstance(command, list) or isinstance(command, tuple):
  253.              for c in command:
  254.                  if display_command:
  255.                      self.write(">>> " + c + "\n", self.command)
  256.                  self.__run(c)
  257.         else:
  258.              if display_command:
  259.                  self.write(">>> " + c + "\n", self.command)
  260.             self.__run(command) 
  261.  
  262.         cur = buffer.get_end_iter()
  263.         buffer.move_mark_by_name("input-line", cur)
  264.         buffer.insert(cur, ">>> ")
  265.         cur = buffer.get_end_iter()
  266.         buffer.move_mark_by_name("input", cur)
  267.         self.view.scroll_to_iter(buffer.get_end_iter(), 0.0)
  268.     
  269.      def __run(self, command):
  270.         sys.stdout, self.stdout = self.stdout, sys.stdout
  271.         sys.stderr, self.stderr = self.stderr, sys.stderr
  272.         
  273.         try:
  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.         except:
  281.             if hasattr(sys, 'last_type') and sys.last_type == SystemExit:
  282.                 self.destroy()
  283.             else:
  284.                 traceback.print_exc()
  285.  
  286.         sys.stdout, self.stdout = self.stdout, sys.stdout
  287.         sys.stderr, self.stderr = self.stderr, sys.stderr
  288.  
  289.     def destroy(self):
  290.         pass
  291.         #gtk.ScrolledWindow.destroy(self)
  292.         
  293. class OutFile:
  294.     """A fake output file object. It sends output to a TK test widget,
  295.     and if asked for a file number, returns one set on instance creation"""
  296.     def __init__(self, console, fn, tag):
  297.         self.fn = fn
  298.         self.console = console
  299.         self.tag = tag
  300.     def close(self):         pass
  301.     def flush(self):         pass
  302.     def fileno(self):        return self.fn
  303.     def isatty(self):        return 0
  304.     def read(self, a):       return ''
  305.     def readline(self):      return ''
  306.     def readlines(self):     return []
  307.     def write(self, s):      self.console.write(s, self.tag)
  308.     def writelines(self, l): self.console.write(l, self.tag)
  309.     def seek(self, a):       raise IOError, (29, 'Illegal seek')
  310.     def tell(self):          raise IOError, (29, 'Illegal seek')
  311.     truncate = tell
  312.