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