rcCommentPanel.py

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

__facility__ = "Online"
__abstract__ = "Comment panel for RunControl"
__author__   = "S. Tuvi <stuvi@SLAC.Stanford.edu> SLAC - GLAST LAT I&T/Online"
__date__     = ("$Date: 2005/08/03 20:25:36 $").split(' ')[1]
__version__  = "$Revision: 2.4 $"
__release__  = "$Name: R04-12-00 $"
__credits__  = "SLAC"

import LATTE.copyright_SLAC

from   qt import *
import os
import time

class rcCommentPanel(QWidget):
  def __init__(self,parent = None,name = None,fl = 0):
    QWidget.__init__(self,parent,name,fl)

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


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

    self.__teComments = CommentEntryWidget(self)

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

    self.languageChange()

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

  def getWidget(self):
    return self.__teComments

  def languageChange(self):
    self.setCaption(self.tr("rcComments"))

class CommentEntryWidget(QTextEdit):
  def __init__(self, parent=None):
    QTextEdit.__init__(self, parent)

    self.__prompt = "--> "

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

    # user interface setup
    self.setTextFormat(QTextEdit.PlainText)
    self.setWrapPolicy(QTextEdit.Anywhere)
    # 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)
    self.connect(self, SIGNAL("clicked(int,int)"), self.handleClicked)

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

  def getHistory(self):
    return self.__history

  def getTimestamps(self):
    return self.__timeStamps

  def clearHistory(self):
    self.__history = []
    self.__timeStamps = []

  def clearDisplay(self):
    self.clear()
    self.write(self.__prompt)
    #if self.isReadOnly():
    #  self.enterComment('Comment entry is disabled.')
    #else:
    #  self.enterComment('Comment entry is enabled.')

  def setPrompt(self, prompt):
    self.__prompt = prompt

  def getPrompt(self):
    return self.__prompt

  def flush(self):
    """
    Simulate stdin, stdout, and stderr.
    """
    pass

  def isatty(self):
    """
    Simulate stdin, stdout, and stderr.
    """
    return 1

  def readline(self):
    """
    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):
    """
    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):
    """
    Simulate stdin, stdout, and stderr.
    """
    map(self.write, text)
    print "DO WE EVER GET HERE? IF YES, OPTIMIZATION POSSIBLE"

  def enterComment(self, comment, addToHistory=0, source='system'):
    """This can be called from a user script to add to comments.
    The text is prepended with \a source to indicate that it is a
    machine generated comment.

    \param comment      The text of the comment to be entered
    \param addtoHistory Whether this comment will be persistent or not
    \param source       The text to be prepended before the comment

    """
    self.line = comment.rstrip()
    if source != "":
      self.line = '[' + source + '] ' + self.line
    self.line = QString(self.line)
    self.write(self.line)
    self.__xLastBP, self.__yLastBP = self.xLast, self.yLast
    self.__xLastBP += 11 # Add the length of the timestamp
    self.write('\n')
    self.__run(addToHistory)

  def flushComment(self):
    if self.line.length() > 0:
      self.write('\n')
      self.__run()

  def __run(self, addToHistory=1):
    self.pointer = 0
    y, x = self.getCursorPosition()
    yFirst = y - len(self.lines) - 1
    self.setSelection(yFirst, 0, yFirst, 4)
    self.removeSelectedText()
    tStamp = time.gmtime()
    self.insertAt(time.strftime('[%H:%M:%S] ', tStamp), y - len(self.lines) - 1, 0)
    if addToHistory:
      self.__history.append(str(self.line))
      self.__timeStamps.append(tStamp)
    self.lines.append(str(self.line))
    self.write(self.__prompt)
    self.lines = []
    self.__clearLine()

  def __clearLine(self):
    """
    Clear input line buffer
    """
    self.line.truncate(0)
    self.point = 0

  def insertText(self, text, offsetY=0, absX=0, overwrite=0):
    """
    \param text     Text to be inserted
    \param offsetY  The position of the comment text relative to the current position
    \param absX     The absolute position of the comment text
    """
    posy = self.__yLastBP + offsetY
    posx = absX + 11 # Skip over the timestamp
    self.setCursorPosition(posy, posx)
    if overwrite:
      self.setSelection(posy, posx, posy, posx+len(text), 0)
      self.removeSelectedText()
    self.__insertText(QString(text), posy, posx)

  def __insertText(self, text, posY=0, posX=0):
    """
    Insert text at the current cursor position.
    """
    y, x = self.getCursorPosition()
    if posX != 0: x = posX
    if posY != 0: y = posY
    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):
    """
    Handle user input a key at a time.
    """

    if self.isReadOnly() or not self.isEnabled():
      e.ignore()
      return
    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 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):
    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):
    """
    Display the current item from the command history.
    """
    self.__deleteLine()
    self.__insertText(QString(self.__history[self.pointer]))


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

  def handleClicked(self, para, pos):
    """
    Keep the cursor after the last prompt.
    """
    if self.hasSelectedText():
      if len(self.selectedText()) > 0:
        self.clip.setText(self.selectedText())
    self.moveCursor(QTextEdit.MoveEnd, 0)
    return

  def contentsContextMenuEvent(self,ev):
    """
    Suppress the right button context menu.
    Instead paste the contents of the clipboard.
    """
    if not self.isReadOnly():
      self.__insertText(self.clip.text())
    ev.accept()
    return

---