# encoding: utf-8 -*- test-case-name: # FIXME: Need to add tests. # ipython1.frontend.wx.tests.test_wx_frontend -*- """Classes to provide a Wx frontend to the IPython.kernel.core.interpreter. This class inherits from ConsoleWidget, that provides a console-like widget to provide a text-rendering widget suitable for a terminal. """ __docformat__ = "restructuredtext en" #------------------------------------------------------------------------------- # Copyright (C) 2008 The IPython Development Team # # Distributed under the terms of the BSD License. The full license is in # the file COPYING, distributed as part of this software. #------------------------------------------------------------------------------- #------------------------------------------------------------------------------- # Imports #------------------------------------------------------------------------------- # Major library imports import re import __builtin__ from time import sleep import sys from threading import Lock import string import wx from wx import stc # Ipython-specific imports. from IPython.frontend._process import PipedProcess from console_widget import ConsoleWidget from IPython.frontend.prefilterfrontend import PrefilterFrontEnd #------------------------------------------------------------------------------- # Constants #------------------------------------------------------------------------------- _COMPLETE_BUFFER_BG = '#FAFAF1' # Nice green _INPUT_BUFFER_BG = '#FDFFD3' # Nice yellow _ERROR_BG = '#FFF1F1' # Nice red _COMPLETE_BUFFER_MARKER = 31 _ERROR_MARKER = 30 _INPUT_MARKER = 29 prompt_in1 = \ '\n\x01\x1b[0;34m\x02In [\x01\x1b[1;34m\x02$number\x01\x1b[0;34m\x02]: \x01\x1b[0m\x02' prompt_out = \ '\x01\x1b[0;31m\x02Out[\x01\x1b[1;31m\x02$number\x01\x1b[0;31m\x02]: \x01\x1b[0m\x02' #------------------------------------------------------------------------------- # Classes to implement the Wx frontend #------------------------------------------------------------------------------- class WxController(ConsoleWidget, PrefilterFrontEnd): """Classes to provide a Wx frontend to the IPython.kernel.core.interpreter. This class inherits from ConsoleWidget, that provides a console-like widget to provide a text-rendering widget suitable for a terminal. """ output_prompt_template = string.Template(prompt_out) input_prompt_template = string.Template(prompt_in1) # Print debug info on what is happening to the console. debug = False # The title of the terminal, as captured through the ANSI escape # sequences. def _set_title(self, title): return self.Parent.SetTitle(title) def _get_title(self): return self.Parent.GetTitle() title = property(_get_title, _set_title) # The buffer being edited. # We are duplicating the definition here because of multiple # inheritence def _set_input_buffer(self, string): ConsoleWidget._set_input_buffer(self, string) self._colorize_input_buffer() def _get_input_buffer(self): """ Returns the text in current edit buffer. """ return ConsoleWidget._get_input_buffer(self) input_buffer = property(_get_input_buffer, _set_input_buffer) #-------------------------------------------------------------------------- # Private Attributes #-------------------------------------------------------------------------- # A flag governing the behavior of the input. Can be: # # 'readline' for readline-like behavior with a prompt # and an edit buffer. # 'raw_input' similar to readline, but triggered by a raw-input # call. Can be used by subclasses to act differently. # 'subprocess' for sending the raw input directly to a # subprocess. # 'buffering' for buffering of the input, that will be used # when the input state switches back to another state. _input_state = 'readline' # Attribute to store reference to the pipes of a subprocess, if we # are running any. _running_process = False # A queue for writing fast streams to the screen without flooding the # event loop _out_buffer = [] # A lock to lock the _out_buffer to make sure we don't empty it # while it is being swapped _out_buffer_lock = Lock() # The different line markers used to higlight the prompts. _markers = dict() #-------------------------------------------------------------------------- # Public API #-------------------------------------------------------------------------- def __init__(self, parent, id=wx.ID_ANY, pos=wx.DefaultPosition, size=wx.DefaultSize, style=wx.CLIP_CHILDREN, *args, **kwds): """ Create Shell instance. """ ConsoleWidget.__init__(self, parent, id, pos, size, style) PrefilterFrontEnd.__init__(self, **kwds) # Marker for complete buffer. self.MarkerDefine(_COMPLETE_BUFFER_MARKER, stc.STC_MARK_BACKGROUND, background=_COMPLETE_BUFFER_BG) # Marker for current input buffer. self.MarkerDefine(_INPUT_MARKER, stc.STC_MARK_BACKGROUND, background=_INPUT_BUFFER_BG) # Marker for tracebacks. self.MarkerDefine(_ERROR_MARKER, stc.STC_MARK_BACKGROUND, background=_ERROR_BG) # A time for flushing the write buffer BUFFER_FLUSH_TIMER_ID = 100 self._buffer_flush_timer = wx.Timer(self, BUFFER_FLUSH_TIMER_ID) wx.EVT_TIMER(self, BUFFER_FLUSH_TIMER_ID, self._buffer_flush) if 'debug' in kwds: self.debug = kwds['debug'] kwds.pop('debug') # Inject self in namespace, for debug if self.debug: self.shell.user_ns['self'] = self def raw_input(self, prompt): """ A replacement from python's raw_input. """ self.new_prompt(prompt) self._input_state = 'raw_input' if hasattr(self, '_cursor'): del self._cursor self.SetCursor(wx.StockCursor(wx.CURSOR_CROSS)) self.waiting = True self.__old_on_enter = self._on_enter def my_on_enter(): self.waiting = False self._on_enter = my_on_enter # XXX: Busy waiting, ugly. while self.waiting: wx.Yield() sleep(0.1) self._on_enter = self.__old_on_enter self._input_state = 'buffering' self._cursor = wx.BusyCursor() return self.input_buffer.rstrip('\n') def system_call(self, command_string): self._input_state = 'subprocess' self._running_process = PipedProcess(command_string, out_callback=self.buffered_write, end_callback = self._end_system_call) self._running_process.start() # XXX: another one of these polling loops to have a blocking # call wx.Yield() while self._running_process: wx.Yield() sleep(0.1) # Be sure to flush the buffer. self._buffer_flush(event=None) def do_calltip(self): """ Analyse current and displays useful calltip for it. """ if self.debug: print >>sys.__stdout__, "do_calltip" separators = re.compile('[\s\{\}\[\]\(\)\= ,:]') symbol = self.input_buffer symbol_string = separators.split(symbol)[-1] base_symbol_string = symbol_string.split('.')[0] if base_symbol_string in self.shell.user_ns: symbol = self.shell.user_ns[base_symbol_string] elif base_symbol_string in self.shell.user_global_ns: symbol = self.shell.user_global_ns[base_symbol_string] elif base_symbol_string in __builtin__.__dict__: symbol = __builtin__.__dict__[base_symbol_string] else: return False try: for name in symbol_string.split('.')[1:] + ['__doc__']: symbol = getattr(symbol, name) self.AutoCompCancel() wx.Yield() self.CallTipShow(self.GetCurrentPos(), symbol) except: # The retrieve symbol couldn't be converted to a string pass def _popup_completion(self, create=False): """ Updates the popup completion menu if it exists. If create is true, open the menu. """ if self.debug: print >>sys.__stdout__, "_popup_completion" line = self.input_buffer if (self.AutoCompActive() and line and not line[-1] == '.') \ or create==True: suggestion, completions = self.complete(line) offset=0 if completions: complete_sep = re.compile('[\s\{\}\[\]\(\)\= ,:]') residual = complete_sep.split(line)[-1] offset = len(residual) self.pop_completion(completions, offset=offset) if self.debug: print >>sys.__stdout__, completions def buffered_write(self, text): """ A write method for streams, that caches the stream in order to avoid flooding the event loop. This can be called outside of the main loop, in separate threads. """ self._out_buffer_lock.acquire() self._out_buffer.append(text) self._out_buffer_lock.release() if not self._buffer_flush_timer.IsRunning(): wx.CallAfter(self._buffer_flush_timer.Start, milliseconds=100, oneShot=True) #-------------------------------------------------------------------------- # LineFrontEnd interface #-------------------------------------------------------------------------- def execute(self, python_string, raw_string=None): self._input_state = 'buffering' self.CallTipCancel() self._cursor = wx.BusyCursor() if raw_string is None: raw_string = python_string end_line = self.current_prompt_line \ + max(1, len(raw_string.split('\n'))-1) for i in range(self.current_prompt_line, end_line): if i in self._markers: self.MarkerDeleteHandle(self._markers[i]) self._markers[i] = self.MarkerAdd(i, _COMPLETE_BUFFER_MARKER) # Update the display: wx.Yield() self.GotoPos(self.GetLength()) PrefilterFrontEnd.execute(self, python_string, raw_string=raw_string) def save_output_hooks(self): self.__old_raw_input = __builtin__.raw_input PrefilterFrontEnd.save_output_hooks(self) def capture_output(self): __builtin__.raw_input = self.raw_input self.SetLexer(stc.STC_LEX_NULL) PrefilterFrontEnd.capture_output(self) def release_output(self): __builtin__.raw_input = self.__old_raw_input PrefilterFrontEnd.release_output(self) self.SetLexer(stc.STC_LEX_PYTHON) def after_execute(self): PrefilterFrontEnd.after_execute(self) # Clear the wait cursor if hasattr(self, '_cursor'): del self._cursor self.SetCursor(wx.StockCursor(wx.CURSOR_CHAR)) def show_traceback(self): start_line = self.GetCurrentLine() PrefilterFrontEnd.show_traceback(self) wx.Yield() for i in range(start_line, self.GetCurrentLine()): self._markers[i] = self.MarkerAdd(i, _ERROR_MARKER) #-------------------------------------------------------------------------- # ConsoleWidget interface #-------------------------------------------------------------------------- def new_prompt(self, prompt): """ Display a new prompt, and start a new input buffer. """ self._input_state = 'readline' ConsoleWidget.new_prompt(self, prompt) i = self.current_prompt_line self._markers[i] = self.MarkerAdd(i, _INPUT_MARKER) def write(self, *args, **kwargs): # Avoid multiple inheritence, be explicit about which # parent method class gets called ConsoleWidget.write(self, *args, **kwargs) def _on_key_down(self, event, skip=True): """ Capture the character events, let the parent widget handle them, and put our logic afterward. """ # FIXME: This method needs to be broken down in smaller ones. current_line_number = self.GetCurrentLine() if event.KeyCode in (ord('c'), ord('C')) and event.ControlDown(): # Capture Control-C if self._input_state == 'subprocess': if self.debug: print >>sys.__stderr__, 'Killing running process' self._running_process.process.kill() elif self._input_state == 'buffering': if self.debug: print >>sys.__stderr__, 'Raising KeyboardInterrupt' raise KeyboardInterrupt # XXX: We need to make really sure we # get back to a prompt. elif self._input_state == 'subprocess' and ( ( event.KeyCode<256 and not event.ControlDown() ) or ( event.KeyCode in (ord('d'), ord('D')) and event.ControlDown())): # We are running a process, we redirect keys. ConsoleWidget._on_key_down(self, event, skip=skip) char = chr(event.KeyCode) # Deal with some inconsistency in wx keycodes: if char == '\r': char = '\n' elif not event.ShiftDown(): char = char.lower() if event.ControlDown() and event.KeyCode in (ord('d'), ord('D')): char = '\04' self._running_process.process.stdin.write(char) self._running_process.process.stdin.flush() elif event.KeyCode in (ord('('), 57): # Calltips event.Skip() self.do_calltip() elif self.AutoCompActive() and not event.KeyCode == ord('\t'): event.Skip() if event.KeyCode in (wx.WXK_BACK, wx.WXK_DELETE): wx.CallAfter(self._popup_completion, create=True) elif not event.KeyCode in (wx.WXK_UP, wx.WXK_DOWN, wx.WXK_LEFT, wx.WXK_RIGHT, wx.WXK_ESCAPE): wx.CallAfter(self._popup_completion) else: # Up history if event.KeyCode == wx.WXK_UP and ( ( current_line_number == self.current_prompt_line and event.Modifiers in (wx.MOD_NONE, wx.MOD_WIN) ) or event.ControlDown() ): new_buffer = self.get_history_previous( self.input_buffer) if new_buffer is not None: self.input_buffer = new_buffer if self.GetCurrentLine() > self.current_prompt_line: # Go to first line, for seemless history up. self.GotoPos(self.current_prompt_pos) # Down history elif event.KeyCode == wx.WXK_DOWN and ( ( current_line_number == self.LineCount -1 and event.Modifiers in (wx.MOD_NONE, wx.MOD_WIN) ) or event.ControlDown() ): new_buffer = self.get_history_next() if new_buffer is not None: self.input_buffer = new_buffer # Tab-completion elif event.KeyCode == ord('\t'): last_line = self.input_buffer.split('\n')[-1] if not re.match(r'^\s*$', last_line): self.complete_current_input() if self.AutoCompActive(): wx.CallAfter(self._popup_completion, create=True) else: event.Skip() else: ConsoleWidget._on_key_down(self, event, skip=skip) def _on_key_up(self, event, skip=True): """ Called when any key is released. """ if event.KeyCode in (59, ord('.')): # Intercepting '.' event.Skip() wx.CallAfter(self._popup_completion, create=True) else: ConsoleWidget._on_key_up(self, event, skip=skip) def _on_enter(self): """ Called on return key down, in readline input_state. """ if self.debug: print >>sys.__stdout__, repr(self.input_buffer) PrefilterFrontEnd._on_enter(self) #-------------------------------------------------------------------------- # EditWindow API #-------------------------------------------------------------------------- def OnUpdateUI(self, event): """ Override the OnUpdateUI of the EditWindow class, to prevent syntax highlighting both for faster redraw, and for more consistent look and feel. """ if not self._input_state == 'readline': ConsoleWidget.OnUpdateUI(self, event) #-------------------------------------------------------------------------- # Private API #-------------------------------------------------------------------------- def _end_system_call(self): """ Called at the end of a system call. """ self._input_state = 'buffering' self._running_process = False def _buffer_flush(self, event): """ Called by the timer to flush the write buffer. This is always called in the mainloop, by the wx timer. """ self._out_buffer_lock.acquire() _out_buffer = self._out_buffer self._out_buffer = [] self._out_buffer_lock.release() self.write(''.join(_out_buffer), refresh=False) def _colorize_input_buffer(self): """ Keep the input buffer lines at a bright color. """ if not self._input_state in ('readline', 'raw_input'): return end_line = self.GetCurrentLine() if not sys.platform == 'win32': end_line += 1 for i in range(self.current_prompt_line, end_line): if i in self._markers: self.MarkerDeleteHandle(self._markers[i]) self._markers[i] = self.MarkerAdd(i, _INPUT_MARKER) if __name__ == '__main__': class MainWindow(wx.Frame): def __init__(self, parent, id, title): wx.Frame.__init__(self, parent, id, title, size=(300,250)) self._sizer = wx.BoxSizer(wx.VERTICAL) self.shell = WxController(self) self._sizer.Add(self.shell, 1, wx.EXPAND) self.SetSizer(self._sizer) self.SetAutoLayout(1) self.Show(True) app = wx.PySimpleApp() frame = MainWindow(None, wx.ID_ANY, 'Ipython') frame.shell.SetFocus() frame.SetSize((680, 460)) self = frame.shell app.MainLoop()