rcPythonShell.py

Go to the documentation of this file.

#!/usr/local/bin/python
#
#                               Copyright 2005
#                                     by
#                        The Board of Trustees of the
#                     Leland Stanford Junior University.
#                            All rights reserved.
#

__facility__ = "Online"
__abstract__ = "Python shell class for the ScriptEngine"
__author__   = "S. Tuvi <stuvi@SLAC.Stanford.edu> SLAC - GLAST LAT I&T/Online"
__date__     = "2005/07/23 00:08:27"
__updated__  = "$Date: 2005/09/22 00:29:30 $"
__version__  = "$Revision: 1.5 $"
__release__  = "$Name: HEAD $"
__credits__  = "SLAC"

import LICOS.copyright_SLAC

import os, sys
from code import InteractiveInterpreter as Interpreter
from qt import *

class rcPythonShell(QWidget):
  """!\brief Python Shell widget.

  This widget is based on the QTextEdit widget and allows
  the execution of ad-hoc Python commands within the confines
  of the script engine.
  """
  def __init__(self,parent = None,name = None,fl = 0):
    """!\brief rcPythonShell constructor.

    """
    QWidget.__init__(self,parent,name,fl)

    if not name:
      self.setName("rcPythonShell")

    self.__parent = parent

    Form2Layout = QGridLayout(self,1,1,0,6,"Form2Layout")

    self.__teShell = PythonShellWidget(locals=sys.modules['__main__'].__dict__, log='', parent=self)

    Form2Layout.addWidget(self.__teShell,0,0)

    self.languageChange()

    self.resize(QSize(291,219).expandedTo(self.minimumSizeHint()))

  def getParent(self):
    """!\brief Retrieve the parent GUI

    \return Parent GUI
    """
    return self.__parent

  def getWidget(self):
    """!\brief Retrieve the comment panel widget

    \return CommentEntryWidget instance
    """
    return self.__teShell

  def languageChange(self):
    """!\brief languageChange

    """
    self.setCaption(self.tr("rcPythonShell"))

class PythonShellWidget(QTextEdit):
  def __init__(self, locals=None, log='', parent=None):
    """!\brief PythonShellWidget constructor.

    \param locals The optional 'locals' argument specifies the dictionary in
                  which code will be executed; it defaults to a newly created
                  dictionary with key "__name__" set to "__console__" and key
                  "__doc__" set to None.
    \param log    The optional 'log' argument specifies the file in which the
                  interpreter session is to be logged.
    \param parent The optional 'parent' argument specifies the parent widget.
                  If no parent widget has been specified, it is possible to
                  exit the interpreter by Ctrl-D.
    """

    QTextEdit.__init__(self, parent)
    self.interpreter = Interpreter(locals)

    # session log
    self.log = log or ''

    self.parent = parent

    # to exit the main interpreter by a Ctrl-D if PyCute has no parent
    if os.name == 'nt' or os.name == 'dos':
      self.eofKey = Qt.Key_Z
    else:
      self.eofKey = Qt.Key_D

    # last line + last incomplete lines
    self.line    = QString()
    self.lines   = []
    # the cursor position in the last line
    self.point   = 0
    # flag: the interpreter needs more input to run the last lines.
    self.more    = 0
    # flag: readline() is being used for e.g. raw_input() and input()
    self.reading = 0
    # history
    self.history = []
    self.pointer = 0
    self.xLast   = 0
    self.yLast   = 0
    self.clip = QApplication.clipboard()


    # user interface setup
    self.setTextFormat(QTextEdit.PlainText)
    self.setWrapPolicy(QTextEdit.Anywhere)
    self.setCaption('Python Shell')
    # font
    if os.name == 'posix':
      font = QFont("Fixed", 12)
    elif os.name == 'nt' or os.name == 'dos':
      font = QFont("Courier New", 8)
    else:
      raise SystemExit, "FIXME for 'os2', 'mac', 'ce' or 'riscos'"
    font.setFixedPitch(1)
    self.setFont(font)

    # geometry
    height = 40*QFontMetrics(font).lineSpacing()
    request = QSize(600, height)
    if parent is not None:
      request = request.boundedTo(parent.size())
    self.resize(request)

    # interpreter prompt.
    try:
      sys.ps1
    except AttributeError:
      sys.ps1 = ">>> "
    try:
      sys.ps2
    except AttributeError:
      sys.ps2 = "... "

    # interpreter banner
    self.write('Python shell running Python %s on %s.\n' %
                (sys.version, sys.platform))
    self.write('Type "copyright", "credits" or "license"'
                ' for more information on Python.\n')
    self.write(sys.ps1)

    self.connect(self, SIGNAL("clicked(int,int)"), self.handleClicked)

  def redirectIO(self):
    """!\brief Redirect all console IO to this widget.

    """
    # capture all interactive input/output
    sys.stdout   = self
    sys.stderr   = self
    sys.stdin    = self

  def restoreIO(self):
    """!\brief Restore all console IO to their original targets.

    """
    sys.stdout   = sys.__stdout__
    sys.stderr   = sys.__stderr__
    sys.stdin    = sys.__stdin__

  def flush(self):
    """!\brief Simulate stdin, stdout, and stderr.

    """
    pass

  def isatty(self):
    """!\brief Simulate stdin, stdout, and stderr.

    """
    return 1

  def readline(self):
    """!\brief Simulate stdin, stdout, and stderr.

    """
    self.reading = 1
    self.__clearLine()
    self.moveCursor(QTextEdit.MoveEnd, 0)
    while self.reading:
      qApp.processOneEvent()
    if self.line.length() == 0:
      return '\n'
    else:
      return str(self.line)

  def write(self, text):
    """!\brief Simulate stdin, stdout, and stderr.

    """
    # The output of self.append(text) contains to many newline characters,
    # so work around QTextEdit's policy for handling newline characters.
    hack = self.text()
    hack.append(text)
    self.setText(hack)
    #self.setText(self.text().append(text)) # segmentation fault
    self.moveCursor(QTextEdit.MoveEnd, 0)
    self.yLast, self.xLast = self.getCursorPosition()

  def writelines(self, text):
    """!\brief Simulate stdin, stdout, and stderr.

    """
    map(self.write, text)
    print "DO WE EVER GET HERE? IF YES, OPTIMIZATION POSSIBLE"

  def fakeUser(self, lines):
    """!\brief Simulate a user.

    \param lines Sequence of strings, (Python statements).
    """
    for line in lines:
      self.line = QString(line.rstrip())
      self.write(self.line)
      self.write('\n')
      self.__run()

  def __run(self):
    """!\brief Execute entered Python statement.

    Append the last line to the history list, let the interpreter execute
    the last line(s), and clean up accounting for the interpreter results:
    (1) the interpreter succeeds
    (2) the interpreter fails, finds no errors and wants more line(s)
    (3) the interpreter fails, finds errors and writes them to sys.stderr
    """
    self.pointer = 0
    self.history.append(QString(self.line))
    self.lines.append(str(self.line))
    source = '\n'.join(self.lines)
    self.redirectIO()
    self.more = self.interpreter.runsource(source)
    self.restoreIO()
    if self.more:
      self.write(sys.ps2)
    else:
      self.write(sys.ps1)
      self.lines = []
    self.__clearLine()

  def __clearLine(self):
    """!\brief Clear input line buffer

    """
    self.line.truncate(0)
    self.point = 0

  def __insertText(self, text):
    """!\brief Insert text at the current cursor position.

    """
    y, x = self.getCursorPosition()
    self.insertAt(text, y, x)
    self.line.insert(self.point, text)
    self.point += text.length()
    self.setCursorPosition(y, x + text.length())

  def keyPressEvent(self, e):
    """!\brief Handle user input a key at a time.

    """
    text  = e.text()
    key   = e.key()
    ascii = e.ascii()

    if text.length() and ascii>=32 and ascii<127:
      self.__insertText(text)
      return

    if e.state() & Qt.ControlButton and key == self.eofKey:
      if self.parent is None:
        try:
          file = open(self.log, "w")
          file.write(str(self.text()))
          file.close()
        except:
          pass
        sys.exit()
      else:
        self.restoreIO()
        self.parent.getParent().hide()
      return

    if e.state() & Qt.ControlButton or e.state() & Qt.ShiftButton:
      e.ignore()
      return

    if key == Qt.Key_Backspace:
      if self.point:
        self.doKeyboardAction(QTextEdit.ActionBackspace)
        self.point -= 1
        self.line.remove(self.point, 1)
    elif key == Qt.Key_Delete:
      self.doKeyboardAction(QTextEdit.ActionDelete)
      self.line.remove(self.point, 1)
    elif key == Qt.Key_Return or key == Qt.Key_Enter:
      self.write('\n')
      if self.reading:
        self.reading = 0
      else:
          self.__run()
    elif key == Qt.Key_Tab:
      self.__insertText(text)
    elif key == Qt.Key_Left:
      if self.point:
        self.moveCursor(QTextEdit.MoveBackward, 0)
        self.point -= 1
    elif key == Qt.Key_Right:
      if self.point < self.line.length():
        self.moveCursor(QTextEdit.MoveForward, 0)
        self.point += 1
    elif key == Qt.Key_Home:
      self.setCursorPosition(self.yLast, self.xLast)
      self.point = 0
    elif key == Qt.Key_End:
      self.moveCursor(QTextEdit.MoveLineEnd, 0)
      self.point = self.line.length()
    elif key == Qt.Key_Up:
      if len(self.history):
        if self.pointer == 0:
          self.pointer = len(self.history)
        self.pointer -= 1
        self.__recall()
    elif key == Qt.Key_Down:
      if len(self.history):
        self.pointer += 1
        if self.pointer == len(self.history):
          self.pointer = 0
        self.__recall()
    elif key == Qt.Key_Escape:
      self.__deleteLine()
    else:
      e.ignore()

  def __deleteLine(self):
    """!\brief Delete a line.

    """
    self.setCursorPosition(self.yLast, self.xLast)
    self.setSelection(self.yLast, self.xLast,
                      self.yLast, self.paragraphLength(self.yLast))
    self.removeSelectedText()
    self.__clearLine()

  def __recall(self):
    """!\brief Display the current item from the command history.

    """
    self.__deleteLine()
    self.__insertText(self.history[self.pointer])


  def focusNextPrevChild(self, next):
    """!\brief Suppress tabbing to the next window in multi-line commands.

    """
    if next and self.more:
      return 0
    return QTextEdit.focusNextPrevChild(self, next)

  def handleClicked(self, para, pos):
    """!\brief Save the selected text to the clipboard.

    """
    if self.hasSelectedText():
      if len(self.selectedText()) > 0:
        self.clip.setText(self.selectedText())
    self.moveCursor(QTextEdit.MoveEnd, 0)
    return

  def contentsContextMenuEvent(self,ev):
    """!\brief Paste the contents of the clipboard to the cursor position.

    """
    self.__insertText(self.clip.text())
    ev.accept()
    return

---