rcCommentPanel.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__ = "Comment panel 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.6 $"
__release__  = "$Name: HEAD $"
__credits__  = "SLAC"

import LICOS.copyright_SLAC

from   qt import *
import os
import time

class rcCommentPanel(QWidget):
  """!\brief ScriptEngine comment panel class.

  """
  def __init__(self,parent = None,name = None,fl = 0):
    """!\brief rcCommentPanel constructor.

    \param parent Parent GUI
    \param name   GUI name
    \param fl     GUI flags
    """
    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):
    """!\brief Retrieve the comment panel widget

    \return CommentEntryWidget instance
    """
    return self.__teComments

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

    """
    self.setCaption(self.tr("rcComments"))

class CommentEntryWidget(QTextEdit):
  """!\brief Comment entry widget

  This widget is based on the QTextEdit widget and allows
  the entry and storage of comments entered by an operator.
  """
  def __init__(self, parent=None):
    """!\brief CommentEntryWidget constructor

    \param parent Parent GUI
    """
    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):
    """!\brief Return the timestamps of the comments entered so far.

    \return A list of timestamps.
    """
    return self.__timeStamps

  def clearHistory(self):
    """!\brief Clear the comment history.

    """
    self.__history = []
    self.__timeStamps = []

  def clearDisplay(self):
    """!\brief Clear the display buffer.

    """
    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):
    """!\brief Set the prompt for comment entry.

    \param prompt Prompt string
    """
    self.__prompt = prompt

  def getPrompt(self):
    """!\brief Retrieve the current prompt.

    \return Prompt string
    """
    return self.__prompt

  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 enterComment(self, comment, addToHistory=0, source='system'):
    """!\brief Enter a comment programmatically.

    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):
    """!\brief Force comment entry if the user hasn't pressed the Enter key yet.

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

  def __run(self, addToHistory=1):
    """!\brief Display/store the comment.

    Display the comment in the textedit window and based on
    \a addHistory value store it in the history.

    \param addToHistory If 1, store the comment in the history (default).
                        If 0, do not store the comment in the history.
    """
    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):
    """!\brief Clear input line buffer

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

  def insertText(self, text, offsetY=0, absX=0, overwrite=0):
    """!\brief Insert text at a given position.

    \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
    \param overwrite Overwrite flag
    """
    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):
    """!\brief Insert text at the current cursor position.

    \param text      Text to be inserted
    \param posY      Relative Y position
    \param posX      Relative X 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):
    """!\brief Handle user input a key at a time.

    \param e Key event
    """
    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):
    """!\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(QString(self.__history[self.pointer]))


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

    """
    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.

    """
    if not self.isReadOnly():
      self.__insertText(self.clip.text())
    ev.accept()
    return

---