class ProgressWindow(FramelessWindow):
def __init__(self, parent, generator):
super(ProgressWindow, self).__init__(parent)
self.__generator = generator
self.__progress_view = QPlainTextEdit(self)
self.__highlighter = Highlighter(self.__progress_view.document())
self.__progress_view.textChanged.connect(self.__on_progress_text)
self.addContentWidget(self.__progress_view)
self.menu = QMenu(self.__generator, self)
close_action = QAction("Close", self.menu)
close_action.triggered.connect(self.close)
self.menu.addAction(close_action)
self.addMenu(self.menu)
def generator(self):
return self.__generator
@Slot(str)
def appendProgress(self, text):
self.__progress_view.appendPlainText(text)
@Slot()
def __on_progress_text(self):
self.__progress_view.verticalScrollBar().setValue(
self.__progress_view.verticalScrollBar().maximum())
class ShellWidget(QWidget):
run_shell = Signal(Bot, str)
def __init__(self, bot, parent):
super(ShellWidget, self).__init__(parent)
self.bot = bot
self.widget_layout = QVBoxLayout(self)
self.setLayout(self.widget_layout)
self.output_widget = QPlainTextEdit(self)
self.output_widget.setReadOnly(True)
self.highlighter = ShellHighlighter(self.output_widget.document())
self.widget_layout.addWidget(self.output_widget)
self.input_widget = QLineEdit(self)
self.widget_layout.addWidget(self.input_widget)
self.send_button = QPushButton(self)
self.send_button.setText("Send")
self.send_button.clicked.connect(self.on_send_button_clicked)
self.widget_layout.addWidget(self.send_button)
@Slot()
def on_send_button_clicked(self):
text = self.input_widget.text()
self.output_widget.appendPlainText("$: {}".format(text))
self.run_shell.emit(self.bot, text)
self.input_widget.clear()
@Slot(Bot, str)
def append_shell(self, bot, message):
if self.bot == bot:
self.output_widget.appendPlainText(message)
class EventViewerPanel(QPlainTextEdit):
def __init__(self, log_handler: GUILogHandler):
self.log_handler = log_handler
QPlainTextEdit.__init__(self)
self.setMinimumWidth(500)
self.setMinimumHeight(200)
self._dynamic = False
self.setWindowTitle("Event viewer")
self.activateWindow()
layout = QVBoxLayout()
self.text_box = QPlainTextEdit()
self.text_box.setReadOnly(True)
self.text_box.setMaximumBlockCount(1000)
layout.addWidget(self.text_box)
self.setLayout(layout)
log_handler.append_log_statement.connect(self.val_changed)
@QtCore.Slot(str)
def val_changed(self, value):
self.text_box.appendPlainText(value)
class PyDMLogDisplay(QWidget, LogLevels):
"""
Standard display for Log Output
This widget handles instantating a ``GuiHandler`` and displaying log
messages to a ``QPlainTextEdit``. The level of the log can be changed from
inside the widget itself, allowing users to select from any of the
``.levels`` specified by the widget.
Parameters
----------
parent : QObject, optional
logname : str
Name of log to display in widget
level : logging.Level
Initial level of log display
"""
Q_ENUMS(LogLevels)
LogLevels = LogLevels
terminator = '\n'
default_format = '%(asctime)s %(message)s'
default_level = logging.INFO
def __init__(self, parent=None, logname=None, level=logging.NOTSET):
QWidget.__init__(self, parent=parent)
# Create Widgets
self.label = QLabel('Minimum displayed log level: ', parent=self)
self.combo = QComboBox(parent=self)
self.text = QPlainTextEdit(parent=self)
self.text.setReadOnly(True)
self.clear_btn = QPushButton("Clear", parent=self)
# Create layout
layout = QVBoxLayout()
level_control = QHBoxLayout()
level_control.addWidget(self.label)
level_control.addWidget(self.combo)
layout.addLayout(level_control)
layout.addWidget(self.text)
layout.addWidget(self.clear_btn)
self.setLayout(layout)
# Allow QCombobox to control log level
for log_level, value in LogLevels.as_dict().items():
self.combo.addItem(log_level, value)
self.combo.currentIndexChanged[str].connect(self.setLevel)
# Allow QPushButton to clear log text
self.clear_btn.clicked.connect(self.clear)
# Create a handler with the default format
self.handler = GuiHandler(level=level, parent=self)
self.logFormat = self.default_format
self.handler.message.connect(self.write)
# Create logger. Either as a root or given logname
self.log = None
self.level = None
self.logName = logname or ''
self.logLevel = level
self.destroyed.connect(functools.partial(logger_destroyed, self.log))
def sizeHint(self):
return QSize(400, 300)
@Property(LogLevels)
def logLevel(self):
return self.level
@logLevel.setter
def logLevel(self, level):
if level != self.level:
self.level = level
idx = self.combo.findData(level)
self.combo.setCurrentIndex(idx)
@Property(str)
def logName(self):
"""Name of associated log"""
return self.log.name
@logName.setter
def logName(self, name):
# Disconnect prior log from handler
if self.log:
self.log.removeHandler(self.handler)
# Reattach handler to new handler
self.log = logging.getLogger(name)
# Ensure that the log matches level of handler
# only if the handler level is less than the log.
if self.log.level < self.handler.level:
self.log.setLevel(self.handler.level)
# Attach preconfigured handler
self.log.addHandler(self.handler)
@Property(str)
def logFormat(self):
"""Format for log messages"""
return self.handler.formatter._fmt
@logFormat.setter
def logFormat(self, fmt):
self.handler.setFormatter(logging.Formatter(fmt))
@Slot(str)
def write(self, message):
"""Write a message to the log display"""
# We split the incoming message by new lines. In prior iterations of
# this widget it was discovered that large blocks of text cause issues
# at the Qt level.
for msg in message.split(self.terminator):
self.text.appendPlainText(msg)
@Slot()
def clear(self):
"""Clear the text area."""
self.text.clear()
@Slot(str)
def setLevel(self, level):
"""Set the level of the contained logger"""
# Get the level from the incoming string specification
try:
level = getattr(logging, level.upper())
except AttributeError as exc:
logger.exception("Invalid logging level specified %s",
level.upper())
else:
# Set the existing handler and logger to this level
self.handler.setLevel(level)
if self.log.level > self.handler.level or self.log.level == logging.NOTSET:
self.log.setLevel(self.handler.level)
class FileDialog(QDialog):
def __init__(self,
file_name,
job_name,
job_number,
realization,
iteration,
parent=None):
super(FileDialog, self).__init__(parent)
self.setWindowTitle("{} # {} Realization: {} Iteration: {}".format(
job_name, job_number, realization, iteration))
try:
self._file = open(file_name, "r")
except OSError as error:
self._mb = QMessageBox(
QMessageBox.Critical,
"Error opening file",
error.strerror,
QMessageBox.Ok,
self,
)
self._mb.finished.connect(self.accept)
self._mb.show()
return
self._view = QPlainTextEdit()
self._view.setReadOnly(True)
self._view.setWordWrapMode(QTextOption.NoWrap)
# for moving the actual slider
self._view.verticalScrollBar().sliderMoved.connect(self._update_cursor)
# for mouse wheel and keyboard arrows
self._view.verticalScrollBar().valueChanged.connect(
self._update_cursor)
self._view.setFont(QFontDatabase.systemFont(QFontDatabase.FixedFont))
self._follow_mode = False
self._init_layout()
self._init_thread()
self.show()
@Slot()
def _stop_thread(self):
self._thread.quit()
self._thread.wait()
def _init_layout(self):
self.setMinimumWidth(600)
self.setMinimumHeight(400)
dialog_buttons = QDialogButtonBox(QDialogButtonBox.Ok)
dialog_buttons.accepted.connect(self.accept)
self._copy_all_button = dialog_buttons.addButton(
"Copy All", QDialogButtonBox.ActionRole)
self._copy_all_button.clicked.connect(self._copy_all)
self._follow_button = dialog_buttons.addButton(
"Follow", QDialogButtonBox.ActionRole)
self._follow_button.setCheckable(True)
self._follow_button.toggled.connect(self._enable_follow_mode)
self._enable_follow_mode(self._follow_mode)
layout = QVBoxLayout(self)
layout.addWidget(self._view)
layout.addWidget(dialog_buttons)
def _init_thread(self):
self._thread = QThread()
self._worker = FileUpdateWorker(self._file)
self._worker.moveToThread(self._thread)
self._worker.read.connect(self._append_text)
self._thread.started.connect(self._worker.setup)
self._thread.finished.connect(self._worker.stop)
self._thread.finished.connect(self._worker.deleteLater)
self.finished.connect(self._stop_thread)
self._thread.start()
def _copy_all(self) -> None:
text = self._view.toPlainText()
QApplication.clipboard().setText(text, QClipboard.Clipboard)
pass
def _update_cursor(self, value: int) -> None:
if not self._view.textCursor().hasSelection():
block = self._view.document().findBlockByLineNumber(value)
cursor = QTextCursor(block)
self._view.setTextCursor(cursor)
def _enable_follow_mode(self, enable: bool) -> None:
if enable:
self._view.moveCursor(QTextCursor.End)
self._view.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self._view.verticalScrollBar().setDisabled(True)
self._view.setTextInteractionFlags(Qt.NoTextInteraction)
self._follow_mode = True
else:
self._view.verticalScrollBar().setDisabled(False)
self._view.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
self._view.setTextInteractionFlags(Qt.TextSelectableByMouse
| Qt.TextSelectableByKeyboard)
self._follow_mode = False
def _append_text(self, text: str) -> None:
# Remove trailing newline as appendPlainText adds this
if text[-1:] == "\n":
text = text[:-1]
if self._follow_mode:
self._view.moveCursor(QTextCursor.End)
self._view.appendPlainText(text)
class PyDMLogDisplay(QWidget, LogLevels):
"""
Standard display for Log Output
This widget handles instantating a ``GuiHandler`` and displaying log
messages to a ``QPlainTextEdit``. The level of the log can be changed from
inside the widget itself, allowing users to select from any of the
``.levels`` specified by the widget.
Parameters
----------
parent : QObject, optional
logname : str
Name of log to display in widget
level : logging.Level
Initial level of log display
"""
Q_ENUMS(LogLevels)
LogLevels = LogLevels
terminator = '\n'
default_format = '%(asctime)s %(message)s'
default_level = logging.INFO
def __init__(self, parent=None, logname=None, level=logging.NOTSET):
QWidget.__init__(self, parent=parent)
# Create Widgets
self.label = QLabel('Minimum displayed log level: ', parent=self)
self.combo = QComboBox(parent=self)
self.text = QPlainTextEdit(parent=self)
self.text.setReadOnly(True)
self.clear_btn = QPushButton("Clear", parent=self)
# Create layout
layout = QVBoxLayout()
level_control = QHBoxLayout()
level_control.addWidget(self.label)
level_control.addWidget(self.combo)
layout.addLayout(level_control)
layout.addWidget(self.text)
layout.addWidget(self.clear_btn)
self.setLayout(layout)
# Allow QCombobox to control log level
for log_level, value in LogLevels.as_dict().items():
self.combo.addItem(log_level, value)
self.combo.currentIndexChanged[str].connect(self.setLevel)
# Allow QPushButton to clear log text
self.clear_btn.clicked.connect(self.clear)
# Create a handler with the default format
self.handler = GuiHandler(level=level, parent=self)
self.logFormat = self.default_format
self.handler.message.connect(self.write)
# Create logger. Either as a root or given logname
self.log = None
self.level = None
self.logName = logname or ''
self.logLevel = level
self.destroyed.connect(functools.partial(logger_destroyed, self.log))
def sizeHint(self):
return QSize(400, 300)
@Property(LogLevels)
def logLevel(self):
return self.level
@logLevel.setter
def logLevel(self, level):
if level != self.level:
self.level = level
idx = self.combo.findData(level)
self.combo.setCurrentIndex(idx)
@Property(str)
def logName(self):
"""Name of associated log"""
return self.log.name
@logName.setter
def logName(self, name):
# Disconnect prior log from handler
if self.log:
self.log.removeHandler(self.handler)
# Reattach handler to new handler
self.log = logging.getLogger(name)
# Ensure that the log matches level of handler
# only if the handler level is less than the log.
if self.log.level < self.handler.level:
self.log.setLevel(self.handler.level)
# Attach preconfigured handler
self.log.addHandler(self.handler)
@Property(str)
def logFormat(self):
"""Format for log messages"""
return self.handler.formatter._fmt
@logFormat.setter
def logFormat(self, fmt):
self.handler.setFormatter(logging.Formatter(fmt))
@Slot(str)
def write(self, message):
"""Write a message to the log display"""
# We split the incoming message by new lines. In prior iterations of
# this widget it was discovered that large blocks of text cause issues
# at the Qt level.
for msg in message.split(self.terminator):
self.text.appendPlainText(msg)
@Slot()
def clear(self):
"""Clear the text area."""
self.text.clear()
@Slot(str)
def setLevel(self, level):
"""Set the level of the contained logger"""
# Get the level from the incoming string specification
try:
level = getattr(logging, level.upper())
except AttributeError as exc:
logger.exception("Invalid logging level specified %s",
level.upper())
else:
# Set the existing handler and logger to this level
self.handler.setLevel(level)
if self.log.level > self.handler.level or self.log.level == logging.NOTSET:
self.log.setLevel(self.handler.level)