diff options
Diffstat (limited to 'build_tools/larch7/larch0/gui/front/uim.py')
-rw-r--r-- | build_tools/larch7/larch0/gui/front/uim.py | 1327 |
1 files changed, 0 insertions, 1327 deletions
diff --git a/build_tools/larch7/larch0/gui/front/uim.py b/build_tools/larch7/larch0/gui/front/uim.py deleted file mode 100644 index 71e106b..0000000 --- a/build_tools/larch7/larch0/gui/front/uim.py +++ /dev/null @@ -1,1327 +0,0 @@ -#!/usr/bin/env python -# -*- coding: UTF-8 -*- -# -# uim.py -# -# (c) Copyright 2010 Michael Towers (larch42 at googlemail dot com) -# -# This file is part of the larch project. -# -# larch is free software; you can redistribute it and/or modify -# it under the terms of the GNU General Public License as published by -# the Free Software Foundation; either version 2 of the License, or -# (at your option) any later version. -# -# larch is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -# GNU General Public License for more details. -# -# You should have received a copy of the GNU General Public License -# along with larch; if not, write to the Free Software Foundation, Inc., -# 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA -# -#---------------------------------------------------------------------------- -# 2010.18.07 - -#TODO? -# Fetching of image and icon files via a sort of url-like mechanism, I -# suppose initially using the 'base:' prefix might be ok. -# Then the cwd of the gui script would be irrelevant. - -#New file dialog for accessing the 'server' end. - - -"""UIM - User Interface Module - -The aim is to provide a means of creating graphical user interfaces of -moderate complexity while abstracting the interface to the actual underlying -toolkit in such a way that (at least potentially) an alternative toolkit -could be used. -[At present this aspect is rather theoretical since only a pyqt based -version has been written.] - -The gui layout is specified as a python data structure, using widget types, -parameter and signal names independent of the underlying toolkit. All -widgets are accessible by their tag, which must be specified. - -A widget is defined by a call to the 'widget' method of the GuiApp instance. -The first argument is the widget type, the second is the widget tag, the -remaining ones must be named, they form the parameters to the constructor. -If the widget is a 'container' (i.e. if it contains other widgets), it will -need a 'layout' parameter defining the layout of its contents. - -There is also a 'widgetlist' method which accepts a list of widget -definitions, each definition being itself a list. The first entry in a -definition is the widget type, the second is the widget tag, the -third is a dictionary containing all the parameters. For convenience (I'm not -sure if I will keep this, though) any entries after the dictionary will be -treated as signal names. These are just added to the parameter dictionary -with value '' (enabling the signal with its default tag). - -Signals have signatures/keys comprising the tag of the emitting widget and -the signal name (separated by '*'), and this will by default also be the tag -by which the signal is known for connection purposes. But this can be -overridden, for example to allow several widgets to emit the same signal. -In the latter case the widget tag can (optionally) be passed as the first -argument to the signal handler. - -Passing signal names as parameters to a widget constructor enables these -signals. They can later be disabled, if desired. - -Connect and disconnect methods are available, to associate (or dissociate) -handler functions with (/from) signals. -""" - -import os, sys, traceback, threading -from PyQt4 import QtGui, QtCore, QtWebKit -from collections import deque -#try: -# import json -#except: -# import simplejson as json - -#++++++++++++++++++++++++++++++++++++++++++++++++++++ -#TODO -# Add more widgets -# Add more attribute handling -# Add more signal handling - -#---------------------------------------------------- - -def debug(text): - sys.stderr.write("GUI: %s\n" % text) - sys.stderr.flush() - - -# Widget Base Classes - essentially used as 'Mixins' >>>>>>>>>>>>>>>> -class WBase: - def x__tt(self, text): - """Set tooltip. - """ - self.setToolTip(text) #qt - - def x__text(self, text=""): - """Set widget text. - """ - self.setText(text) #qt - - def x__enable(self, on): - """Enable/Disable widget. on should be True to enable the widget - (display it in its normal, active state), False to disable it - (which will normally be paler and non-interactive). - """ - self.setEnabled(on) #qt - - def x__focus(self): - self.setFocus() #qt - - def x__width(self, w): - """Set the minimum width for the widget. - """ - self.setMinimumWidth(w) #qt - - def x__typewriter(self, on): - """Use a typewriter (fixed spacing) font. - """ - if on: - f = QtGui.QFont(self.font()) #qt - f.setFamily("Courier") #qt - self.setFont(f) #qt - - def x__busycursor(self, on): - """Set/clear the busy-cursor for this widget. - """ - if on: - self.setCursor(QtCore.Qt.BusyCursor) #qt - else: - self.unsetCursor() #qt - - -class BBase: - """Button mixin. - """ - def x__icon(self, icon): - self.setIcon(self.style().standardIcon(icondict[icon])) #qt - -#qt -icondict = { "left" : QtGui.QStyle.SP_ArrowLeft, - "right" : QtGui.QStyle.SP_ArrowRight, - "down" : QtGui.QStyle.SP_ArrowDown, - "up" : QtGui.QStyle.SP_ArrowUp, - "reload" : QtGui.QStyle.SP_BrowserReload, - } - -class Container: - """This just adds layout management for widgets which contain - other widgets. - """ - def x__layout(self, layout, immediate=False): - """A layout specifies and organizes the contents of a widget. - Note that the layouting is not immediately performed by default as - it is unlikely that all the contained widgets have been defined yet. - """ - self._layout = layout - if immediate: - self.x__pack() - - def x__pack(self): - """A layout call specifies and organizes the contents of a widget. - The layout can be a layout manager list, or a single widget name - (or an empty string, which will cause a warning to be issued, but - may be useful during development). - - There are three sorts of thing which can appear in layout manager - lists (apart from the layout type at the head of the list and an - optional attribute dict as second item). There can be named - widgets, there can be further layout managers (specified as lists, - nested as deeply as you like) and there can be layout widgets, - like spacers and separators. - - A layout widget can have optional arguments, which are separated - by commas, e.g. 'VLINE,3' passes the argument '3' to the VLINE - constructor. - """ - # getattr avoids having to have an __init__() for Container. - if getattr(self, '_layout', None): - if self._layout != '$': - self.setLayout(self.getlayout(self._layout)) - self._layout = '$' - else: - debug("No layout set on '%s'" % self.w_name) - - def getlayout(self, item): - if isinstance(item, list): - try: - # Create a layout manager instance - layoutmanager = layout_table[item[0]]() - assert isinstance(layoutmanager, Layout) - except: - gui_error("Unknown layout type: %s" % item[0]) - if (len(item) > 1) and isinstance(item[1], dict): - dictarg = item[1] - ilist = item[2:] - else: - dictarg = {} - ilist = item[1:] - # Build up the list of objects to lay out - # If the layout manager is a GRID, accept only grid rows ('+') - if isinstance(layoutmanager, GRID): - args = [] - rowlen = None - for i in ilist: - if isinstance(i, list) and (i[0] == '+'): - args.append(self.getlayoutlist(i[1:], grid=True)) - if rowlen == None: - rowlen = len(i) - elif len(i) != rowlen: - gui_error("Grid (%s) row lengths unequal" - % self.w_name) - else: - gui_error("Grid (%s) layouts must consist of grid" - " rows ('+')" % self.w_name) - else: - # Otherwise the elements of the argument list can be: - # A sub-layout - # A widget - # A SPACE - args = self.getlayoutlist(ilist) - layoutmanager.do_layout(args) - # Attributes - for key, val in dictarg: - handler = "x__" + key - if hasattr(layoutmanager, handler): - getattr(layoutmanager, handler)(val) - return layoutmanager - - else: - # It must be a widget, which will need to be put in a box (qt) - return self.getlayout(['VBOX', item]) - - def getlayoutlist(self, items, grid=False): - objects = [] - for i in items: - if isinstance(i, list): - obj = self.getlayout(i) - else: - parts = i.split(',') - i = parts[0] - args = parts[1:] - try: - obj = layout_table[i](*args) - if not (isinstance(obj, SPACE) # or a separator line - or isinstance(obj, QtGui.QWidget)): #qt - assert (grid and isinstance(obj, Span)) - except: - obj = guiapp.getwidget(i) - if obj != None: - if isinstance(obj, Container): - obj.x__pack() - else: - gui_error("Bad item in layout of '%s': '%s'" - % (self.w_name, i)) - objects.append(obj) - return objects - - -class XContainer(Container): - """This is a mixin class for containers which can contain more than - one layout. - """ - def x__layout(self, layout): - gui_error("An extended container (%s) has no 'layout' method" - % self.w_name) - - -class TopLevel(Container): - def x__show(self): - self.set_visible() - - def set_visible(self, on=True): - self.setVisible(on) #qt - - def x__size(self, w_h): - w, h = [int(i) for i in w_h.split("_")] - self.resize(w, h) #qt - - def x__icon(self, iconpath): - guiapp.setWindowIcon(QtGui.QIcon(iconpath)) #qt - - def x__title(self, text): - self.setWindowTitle(text) #qt - - def x__getSize(self): - s = self.size() #qt - return "%d_%d" % (s.width(), s.height()) #qt - - def x__getScreenSize(self): - dw = guiapp.desktop() #qt - geom = dw.screenGeometry(self) #qt - return "%d_%d" % (geom.width(), geom.height()) #qt - -#<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< - -class Window(QtGui.QWidget, TopLevel): #qt - """This is needed to trap window closing events. It also supports - a 'busy' mechanism. - """ - def __init__(self): - QtGui.QWidget.__init__(self) #qt - self.closesignal = "" - self.busystate = False - self.busy_lock = threading.Lock() - - def closeEvent(self, event): #qt - if self.closesignal: - guiapp.sendsignal(self.closesignal) - event.ignore() #qt - return - QtGui.QWidget.closeEvent(self, event) #qt - - def x__closesignal(self, text): - self.closesignal = text - - def x__busy(self, widgets, on, busycursor=True): - """This activates (or deactivates, for on=False) a 'busy' mechanism, - which can be one or both of the following: - Make the application's cursor change to the 'busy cursor'. - Disable a group of widgets. - There is a lock to prevent the busy state from being set when it - is already active. - """ - # I couldn't get the following calls to work: - # w.setCursor(QtCore.Qt.BusyCursor) - # w.unsetCursor() - self.busy_lock.acquire() - if on: - if self.busystate: - debug("*ERROR* Attempt to set busy state twice") - self.busy_lock.release() - return - self.busycursor = busycursor - if busycursor: - guiapp.setOverrideCursor(QtCore.Qt.BusyCursor) #qt - else: - if not self.busystate: - debug("*ERROR* Attempt to release busy state twice") - self.busy_lock.release() - return - if self.busycursor: - guiapp.restoreOverrideCursor() #qt - self.busystate = on - self.busy_lock.release() - for wn in widgets: - w = guiapp.getwidget(wn) - if w: - w.setEnabled(not on) #qt - else: - debug("*ERROR* No widget '%s'" % wn) - - -class Dialog(QtGui.QDialog, TopLevel): - def __init__(self): - QtGui.QDialog.__init__(self) #qt - - def x__showmodal(self): - return self.exec_() == QtGui.QDialog.Accepted #qt - - -class DialogButtons(QtGui.QDialogButtonBox): #qt - def __init__(self): - return - - def x__buttons(self, args): - """This keyword argument MUST be present. - """ - buttons = 0 - for a in args: - try: - b = getattr(QtGui.QDialogButtonBox, a) #qt - assert isinstance(b, int) #qt - buttons |= b #qt - except: - gui_warning("Unknown Dialog button: %s" % a) - QtGui.QDialogButtonBox.__init__(self, buttons) #qt - - def x__dialog(self, dname): - """This must be set or else the dialog buttons won't do anything. - """ - self._dialog = guiapp.getwidget(dname) - self.connect(self, QtCore.SIGNAL("clicked(QAbstractButton *)"), #qt - self._clicked) #qt - - def _clicked(self, button): #qt - if self.buttonRole(button) == self.AcceptRole: #qt - self._dialog.accept() #qt - else: - self._dialog.reject() #qt - - -def textLineDialog(label=None, title=None, text="", pw=False): - if label == None: - label = "Enter the value here:" - if title == None: - title = "Enter Information" - if pw: - echo = QtGui.QLineEdit.Password #qt - else: - echo = QtGui.QLineEdit.Normal #qt - result, ok = QtGui.QInputDialog.getText(None, #qt - title, label, echo, text) #qt - return (ok, unicode(result)) - - -def listDialog(label=None, title=None, items=[], current=0): - if label == None: - label = "Choose one of the entries" - if title == None: - title = "Select an item" - item, ok = QtGui.QInputDialog.getItem(None, title, label, items, - current, editable=False) #qt - return (ok, unicode(item)) - - -def confirmDialog(message, title=None): - if title == None: - title = "Confirmation" - return (QtGui.QMessageBox.question(None, title, message, #qt - QtGui.QMessageBox.Yes | QtGui.QMessageBox.Cancel) == #qt - QtGui.QMessageBox.Yes) #qt - - -def infoDialog(message, title=None): - if title == None: - title = "Information" - QtGui.QMessageBox.information(None, title, message) #qt - - -#+++++++++++++++++++++++++++ -# Error handling -def gui_error(message, title=None): - if title == None: - title = "Error" - QtGui.QMessageBox.critical(None, title, message) #qt - guiapp.exit(1) #qt - -def gui_warning(message, title=None): - if title == None: - title = "Warning" - QtGui.QMessageBox.warning(None, title, message) #qt - -def onexcept(text): - debug(traceback.format_exc()) - gui_error(text, "Exception") -#--------------------------- - -fileDialogDir = "/" -def fileDialog(message, start=None, title=None, dir=False, create=False, - file=None, urls=None, filter=None): - # filter is a list: first a textual description, then acceptable glob filenames - global fileDialogDir - if not start: - start = fileDialogDir - dlg = QtGui.QFileDialog(None, message, start) #qt - if title: - dlg.setWindowTitle(title) #qt - dlg.setReadOnly(not create) #qt - if dir: - dlg.setFileMode(dlg.Directory) #qt - elif not create: - dlg.setFileMode(dlg.ExistingFile) #qt - if filter: - dlg.setNameFilter("%s (%s)" % (filter[0], " ".join(filter[1:]))) #qt - - if urls: - urlsqt = [ QtCore.QUrl.fromLocalFile(u[0]) for u in urls ] #qt - urlsqt.append(QtCore.QUrl.fromLocalFile( - QtGui.QDesktopServices.storageLocation( - QtGui.QDesktopServices.HomeLocation))) - - dlg.setSidebarUrls(urlsqt) #qt - - if file: - dlg.selectFile(file) - - if dlg.exec_(): - path = str(dlg.selectedFiles()[0]).strip() - if os.path.isdir(path): - fileDialogDir = path - elif os.path.isfile(path): - fileDialogDir = os.path.dirname(path) - return path - else: - return "" - - -class Stack(QtGui.QStackedWidget, XContainer): #qt - def __init__(self): - QtGui.QStackedWidget.__init__(self) #qt - self.x_twidgets = [] - - def x__pages(self, pages): - self.x_twidgets = pages - - def x__pack(self): - for name in self.x_twidgets: - w = guiapp.getwidget(name) - w.x__pack() - self.addWidget(w) #qt - - def x__set(self, index=0): - self.setCurrentIndex(index) #qt - - -class Notebook(QtGui.QTabWidget, XContainer): #qt - def __init__(self): - QtGui.QTabWidget.__init__(self) #qt - self.x_tabs = [] - self.x_twidgets = [] - - def x__changed(self, name=''): - guiapp.signal(self, 'changed', name, 'currentChanged(int)') #qt - - def x__tabs(self, tabs): - self.x_twidgets = tabs - - def x__pack(self): - for name, title in self.x_twidgets: - w = guiapp.getwidget(name) - w.x__pack() - self.addTab(w, title) #qt - self.x_tabs.append([name, w]) - - def x__set(self, index=0): - self.setCurrentIndex(index) #qt - - def x__enableTab(self, index, on): - self.setTabEnabled(index, on) #qt - - -class Page(QtGui.QWidget, Container): #qt - def __init__(self): - QtGui.QWidget.__init__(self) #qt - - def x__enable(self, on): - """Enable/Disable widget. on should be True to enable the widget - (display it in its normal, active state), False to disable it - (which will normally be paler and non-interactive). - """ - self.setEnabled(on) #qt - - -class Frame(QtGui.QGroupBox, WBase, Container): #qt - def __init__(self): - QtGui.QGroupBox.__init__(self) #qt - self._text = None - - def x__text(self, text): - self._text = text - self.setTitle(text) #qt - -# A hack to improve spacing - def setLayout(self, layout): - topgap = 10 if self._text else 0 - layout.setContentsMargins(0, topgap, 0, 0) #qt - QtGui.QGroupBox.setLayout(self, layout) - - -class OptionalFrame(Frame): #qt - def __init__(self): #qt - Frame.__init__(self) #qt - self.setCheckable(True) #qt - self.setChecked(False) #qt - - def x__toggled(self, name=''): - guiapp.signal(self, 'toggled', name, 'toggled(bool)') #qt - - def x__opton(self, on): - self.setChecked(on) #qt - -#TODO: Is this still needed? (I think it's a qt bug) - def x__enable_hack(self): #qt - if not self.isChecked(): #qt - self.setChecked(True) #qt - self.setChecked(False) #qt - - def x__active(self): - return self.isChecked() #qt - - -def read_markup(markup): - def read_markup0(mlist): - text = '' - for i in mlist: - text += read_markup(i) if isinstance(i, list) else i - return text - tag = markup[0] - if tag == '': - return read_markup0(markup[1:]) - elif tag in ('h1', 'h2', 'h3', 'h4', 'p', 'em', 'strong'): - return '<%s>%s</%s>' % (tag, read_markup0(markup[1:]), tag) - elif tag == 'color': - return '<span style="color:%s;">%s</span>' % (markup[1], - read_markup0(markup[2:])) - return "Markup parse error" - - -class Label(QtGui.QLabel, WBase): #qt - def __init__(self): - QtGui.QLabel.__init__(self) #qt - - def x__markup(self, markup): - self.setText(read_markup(markup)) #qt - - def x__image(self, path): - self.setPixmap(QtGui.QPixmap(path)) #qt - - def x__align(self, pos): - if pos == "center": - a = QtCore.Qt.AlignCenter #qt - else: - a = QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter #qt - self.setAlignment(a) #qt - - -class Button(QtGui.QPushButton, WBase, BBase): #qt - def __init__(self): - QtGui.QPushButton.__init__(self) #qt - - def x__clicked(self, name=''): - guiapp.signal(self, 'clicked', name, 'clicked()') #qt - - -class ToggleButton(QtGui.QPushButton, WBase, BBase): #qt - def __init__(self): - QtGui.QPushButton.__init__(self) #qt - self.setCheckable(True) #qt - - def x__toggled(self, name=''): - guiapp.signal(self, 'toggled', name, 'toggled(bool)') #qt - - def x__set(self, on): - self.setChecked(on) #qt - - -class CheckBox(QtGui.QCheckBox, WBase): #qt - def __init__(self): - QtGui.QCheckBox.__init__(self) #qt - - def x__toggled(self, name=''): - # A bit of work is needed to get True/False state #qt - # instead of 0/1/2 #qt - guiapp.signal(self, 'toggled', name, - 'toggled(bool)', self.s_toggled) #qt - - def s_toggled(self, state): #qt - """Convert the argument to True/False. - """ #qt - return (state != QtCore.Qt.Unchecked,) #qt - - def x__set(self, on): - self.setCheckState(2 if on else 0) #qt - - def x__active(self): - return self.checkState() != QtCore.Qt.Unchecked #qt - - -class RadioButton(QtGui.QRadioButton, WBase): #qt - def __init__(self): - QtGui.QPushButton.__init__(self) #qt - - def x__toggled(self, name=''): - guiapp.signal(self, 'toggled', name, 'toggled(bool)') #qt - - def x__set(self, on): - self.setChecked(on) #qt - - def x__active(self): - return self.isChecked() #qt - - -class ComboBox(QtGui.QComboBox, WBase): #qt - def __init__(self): - QtGui.QComboBox.__init__(self) #qt - - def x__changed(self, name=''): - guiapp.signal(self, 'changed', name, 'currentIndexChanged(int)') #qt - - def x__changedstr(self, name=''): - guiapp.signal(self, 'changedstr', name, - 'currentIndexChanged(const QString &)') #qt - - def x__set(self, items, index=0): - self.blockSignals(True) - self.clear() #qt - if items: - self.addItems(items) #qt - self.setCurrentIndex(index) #qt - self.blockSignals(False) - - -class ListChoice(QtGui.QListWidget, WBase): #qt - def __init__(self): - QtGui.QListWidget.__init__(self) #qt - - def x__changed(self, name=''): - guiapp.signal(self, 'changed', name, 'currentRowChanged(int)') #qt - - def x__set(self, items, index=0): - self.blockSignals(True) - self.clear() #qt - if items: - self.addItems(items) #qt - self.setCurrentRow(index) #qt - self.blockSignals(False) - - -class List(QtGui.QTreeWidget, WBase): #qt - # Only using top-level items of the tree - def __init__(self): - QtGui.QTreeWidget.__init__(self) #qt - self.mode = "" - self.setSelectionMode(QtGui.QAbstractItemView.ExtendedSelection) #qt - self.setRootIsDecorated(False) #qt - self._hcompact = False # used for scheduling header-compaction - - def x__select(self, name=''): - guiapp.signal(self, 'select', name, - 'itemSelectionChanged()', self.s_select) #qt - - def x__clicked(self, name=''): - guiapp.signal(self, 'clicked', name, - 'itemClicked(QTreeWidgetItem *,int)', self.s_clicked) #qt - - def s_select(self): - # Signal a selection change, passing the new selection list (indexes) - s = [self.indexOfTopLevelItem(i) for i in self.selectedItems()] #qt - if self.mode == "Single": - return s - else: - return (s,) - - def s_clicked(self, item, col): #qt - """This is intended for activating a user-defined editing function. - Tests showed that this is called after the selection is changed, so - if using this signal, use it only in 'Single' selection mode and - use this, not 'select' to record selection changes. Clicking on the - selected row should start editing the cell, otherwise just change - the selection. - """ - ix = self.indexOfTopLevelItem(item) #qt - return (ix, col) - - def x__selectionmode(self, sm): - self.mode = sm - if sm == "None": - self.setSelectionMode(QtGui.QAbstractItemView.NoSelection) #qt - elif sm == "Single": - self.setSelectionMode(QtGui.QAbstractItemView.SingleSelection) #qt - else: - self.mode = "" - self.setSelectionMode(QtGui.QAbstractItemView.ExtendedSelection) #qt - - def x__headers(self, headers): #qt - self.setHeaderLabels(headers) #qt - if self._hcompact: - self._compact() - - def x__set(self, items, index=0): #qt - # Note that each item must be a tuple/list containing - # entries for each column. - self.clear() #qt - c = 0 - for i in items: - item = QtGui.QTreeWidgetItem(self, i) #qt - self.addTopLevelItem(item) #qt - if c == index: - self.setCurrentItem(item) - c += 1 - if self._hcompact: - self._compact() - - def x__compact(self, on=True): - self._hcompact = on - if on: - self._compact() - - def _compact(self): - for i in range(self.columnCount()): #qt - self.resizeColumnToContents(i) #qt - - -class LineEdit(QtGui.QLineEdit, WBase): #qt - def __init__(self): - QtGui.QLineEdit.__init__(self) #qt - - def x__enter(self, name=''): - guiapp.signal(self, 'enter', name, 'returnPressed()') #qt - - def x__changed(self, name=''): - guiapp.signal(self, 'changed', name, 'textEdited(const QString &)') #qt - - def x__get(self): - return unicode(self.text()) #qt - - def x__ro(self, ro): - self.setReadOnly(ro) #qt - - def x__pw(self, star): - self.setEchoMode(QtGui.QLineEdit.Password if star == "+" #qt - else QtGui.QLineEdit.NoEcho if star == "-" #qt - else QtGui.QLineEdit.Normal) #qt - - -class CheckList(QtGui.QWidget, WBase): #qt - def __init__(self): - QtGui.QWidget.__init__(self) #qt - self.box = QtGui.QVBoxLayout(self) #qt - self.title = None - if text: #qt - l.addWidget(QtGui.QLabel(text)) #qt - self.widget = QtGui.QListWidget() #qt - l.addWidget(self.widget) #qt - - def x__title(self, text): - if self.title: - self.title.setText(text) #qt - else: - self.title = QtGui.QLabel(text) #qt - self.box.insertWidget(0, self.title) #qt - - def x__checked(self, index): - return (self.widget.item(index).checkState() == #qt - QtCore.Qt.Checked) #qt - - def x__set(self, items): - self.widget.blockSignals(True) #qt - self.widget.clear() #qt - if items: - for s, c in items: - wi = QtGui.QListWidgetItem(s, self.widget) #qt - wi.setCheckState(QtCore.Qt.Checked if c #qt - else QtCore.Qt.Unchecked) #qt - self.blockSignals(False) #qt - - -class TextEdit(QtGui.QTextEdit, WBase): #qt - def __init__(self): - QtGui.QTextEdit.__init__(self) #qt - - def x__ro(self, ro): - self.setReadOnly(ro) #qt - - def x__append_and_scroll(self, text): - self.append(text) #qt - self.ensureCursorVisible() #qt - - def x__get(self): - return unicode(self.toPlainText()) #qt - - def x__undo(self): - QtGui.QTextEdit.undo(self) #qt - - def x__redo(self): - QtGui.QTextEdit.redo(self) #qt - - def x__copy(self): - QtGui.QTextEdit.copy(self) #qt - - def x__cut(self): - QtGui.QTextEdit.cut(self) #qt - - def x__paste(self): - QtGui.QTextEdit.paste(self) #qt - - -class HtmlView(QtWebKit.QWebView, WBase): #qt - def __init__(self): - QtWebKit.QWebView.__init__(self) #qt - - def x__html(self, content): - self.setHtml(content) #qt - - def x__setUrl(self, url): - self.load(QtCore.QUrl(url)) #qt - - def x__prev(self): - self.back() #qt - - def x__next(self): - self.forward() #qt - - -class SpinBox(QtGui.QDoubleSpinBox, WBase): #qt - def __init__(self): - QtGui.QDoubleSpinBox.__init__(self) #qt - self.step = None - - def x__changed(self, name=''): - guiapp.signal(self, 'changed', name, 'valueChanged(double)') #qt - - def x__min(self, min): - self.setMinimum(min) - - def x__max(self, max): - self.setMaximum(max) - - def x__decimals(self, dec): - self.setDecimals(dec) - if not self.step: - self.setSingleStep(10**(-dec)) - - def x__step(self, step): - self.setSingleStep(step) - - def x__value(self, val): - self.setValue(val) - - -class ProgressBar(QtGui.QProgressBar, WBase): #qt - def __init__(self): - QtGui.QProgressBar.__init__(self) #qt - - def x__set(self, value): - self.setValue(value) #qt - - def x__max(self, max): - self.setMaximum(max) #qt - - - -# Layout classes -class Layout: - """A mixin base class for all layout widgets. - """ - pass - -boxmargin=3 -class _BOX(Layout): - def do_layout(self, items): - self.setContentsMargins(boxmargin, boxmargin, boxmargin, boxmargin) #qt - for wl in items: - if isinstance(wl, QtGui.QWidget): #qt - self.addWidget(wl) #qt - elif isinstance(wl, SPACE): #qt - if wl.size: #qt - self.addSpacing(wl.size) #qt - self.addStretch() #qt - elif isinstance(wl, Layout): #qt - self.addLayout(wl) #qt - else: #qt - gui_error("Invalid Box entry: %s" % repr(wl)) - - -class VBOX(QtGui.QVBoxLayout, _BOX): #qt - def __init__(self): - QtGui.QVBoxLayout.__init__(self) #qt - - -class HBOX(QtGui.QHBoxLayout, _BOX): #qt - def __init__(self): - QtGui.QHBoxLayout.__init__(self) #qt - - -class GRID(QtGui.QGridLayout, Layout): #qt - def __init__(self): - QtGui.QGridLayout.__init__(self) #qt - - def do_layout(self, rows): - y = -1 - for row in rows: - y += 1 - x = -1 - for wl in row: - x += 1 - if isinstance(wl, Span): - continue - # Determine the row and column spans - x1 = x + 1 - while (x1 < len(row)) and isinstance(row[x1], CSPAN): - x1 += 1 - y1 = y + 1 - while (y1 < len(rows)) and isinstance(rows[y1][x], RSPAN): - y1 += 1 - - if isinstance(wl, QtGui.QWidget): #qt - self.addWidget(wl, y, x, y1-y, x1-x) #qt - elif isinstance(wl, Layout): - self.addLayout(wl, y, x, y1-y, x1-x) #qt - elif isinstance(wl, SPACE): - self.addItem(QtGui.QSpacerItem(wl.size, wl.height), - y, x, y1-y, x1-x) #qt - else: - gui_error("Invalid entry in Grid layout: %s" % repr(wl)) - - -class SPACE: - """Can be used in boxes and grids. In boxes only size is of interest, - and it also means vertical size in the case of a vbox. In grids size - is the width. - """ - def __init__(self, size_width='0', height='0'): #qt - self.size = int(size_width) #qt - self.height = int(height) #qt - - -class Span: - """Class to group special grid layout objects together - it doesn't - actually do anything itself, but is used for checking object types. - """ - pass - - -class CSPAN(Span): - """Column-span layout item. It doesn't do anything itself, but it is used - by the Grid layout constructor. - """ - pass - - -class RSPAN(Span): - """Row-span layout item. It doesn't do anything itself, but it is used - by the Grid layout constructor. - """ - pass - - -class HLINE(QtGui.QFrame): #qt - def __init__(self, pad=None): - QtGui.QFrame.__init__(self) #qt - self.setFrameShape(QtGui.QFrame.HLine) #qt - if pad: - self.setFixedHeight(1 + 2*int(pad)) #qt - - -class VLINE(QtGui.QFrame): #qt - def __init__(self, pad=None): - QtGui.QFrame.__init__(self) #qt - self.setFrameShape(QtGui.QFrame.VLine) #qt - if pad: - self.setFixedWidth(1 + 2*int(pad)) #qt - - -class DATA: - """This is not really a widget, it just holds a dictionary of - potentially internationalized messages. - """ - def x__messages(self, mdict): - self.messages = mdict - - def x__get(self, key): - return self.messages.get(key) - - -class Uim(QtGui.QApplication): - """This class represents an application gui, possibly with more than - one top level window. - """ - timers = [] # timer objects - - def __init__(self): - global guiapp - guiapp = self - self.eno = QtCore.QEvent.registerEventType() #qt - QtGui.QApplication.__init__(self, []) #qt - self.setQuitOnLastWindowClosed(False) #qt - - self.widgets = {} # all widgets, key = widget tag - self.signal_dict = {} # signal connections, key = signature - - # callback list for event loop: (callback, arglist) pairs: - self.idle_calls = deque() - - - def event(self, e): - if e.type() == self.eno: - # Process item from list - cb, a = self.idle_calls.popleft() - cb(*a) - return True - else: - return QtGui.QApplication.event(self, e) #qt - - - def run(self): - self.exec_() #qt - - -# def quit(self): -# self.quit() #qt - - - def addwidget(self, fullname, wo): - if self.widgets.has_key(fullname): - gui_error("Attempted to define widget '%s' twice." % fullname) - self.widgets[fullname] = wo - - - def getwidget(self, w): - widget = self.widgets.get(w) - if widget == None: - gui_warning("Unknown widget: %s" % w) - return widget - - - def show(self, windowname): - self.getwidget(windowname).setVisible() - - - def command(self, cmdtext, *args): - cmd = specials_table.get(cmdtext) - if not cmd: - w, m = cmdtext.split(".") - wo = self.getwidget(w) - cmd = getattr(wo, 'x__' + m) - return cmd(*args) - - - def widget(self, wtype, wname, args): - wobj = widget_table[wtype]() - wobj.w_name = wname - - # Attributes - for key, val in args.iteritems(): - handler = "x__" + key - if hasattr(wobj, handler): - getattr(wobj, handler)(val) -# Unrecognized attributes are ignored ... - - self.addwidget(wname, wobj) - - - def widgetlist(self, wlist): - for w in wlist: - # Add simple signals - for s in w[3:]: - w[2][s] = '' - self.widget(w[0], w[1], w[2]) - - - def signal(self, source, signal, name=None, xsignal=None, convert=None): - """Enable or disable a signal. - Signal.signals is a dictionary of enabled signals. - The key is constructed from the widget name and the formal signal name. - The name of the signal which actually gets generated will be the - same as the key unless the 'name' parameter is set. See the - 'Signal' class for further details. - If 'name' is None (not ''!), the signal will be disabled. - """ - widsig = source.w_name + '*' + signal - if name == None: - s = Signal.signals.get(widsig) - if not s: - gui_error("Can't disable signal '%s' - it's not enabled" - % widsig) - s.disconnect() # Probably not necessary in qt - del(Signal.signals[widsig]) - else: - if Signal.signals.has_key(widsig): - gui_error("Signal already connected: %s" % widsig) - Signal.signals[widsig] = Signal(source, signal, name, xsignal, - convert) - - - def connect(self, signal, function): - if self.signal_dict.has_key(signal): - self.signal_dict[signal].append(function) - else: - self.signal_dict[signal] = [function] - - - def connectlist(self, *slotlist): - for s in slotlist: - self.connect(*s) - - - def disconnect(self, signal, function): - try: - l = self.signal_dict[signal] - l.remove(function) - except: - gui_error("Slot disconnection for signal '%s' failed" - % signal) - - - def sendsignal(self, name, *args): - # When there are no slots a debug message is output. - slots = self.signal_dict.get(name) - if slots: - try: - for slot in slots: - slot(*args) - except: - gui_error("Signal handling error:\n %s" - % traceback.format_exc()) - else: - debug("Unhandled signal: %s %s" % (name, repr(args))) - - - def idle_add(self, callback, *args): - self.idle_calls.append((callback, args)) - e = QtCore.QEvent(self.eno) #qt - self.postEvent(self, e) #qt - - - def timer(self, callback, period): - """Start a timer which calls the callback function on timeout. - Only if the callback returns True will the timer be retriggered. - """ - Uim.timers.append(Timer(callback, period)) - - -class Timer(QtCore.QTimer): #qt - def __init__(self, timers, callback, period): - QtCore.QTimer.__init__(self) #qt - self.x_callback = callback - self.connect(self, QtCore.SIGNAL("timeout()"), #qt - self.x_timeout) - self.start(int(period * 1000)) #qt - - def x_timeout(self): - if not self.x_callback(): - self.stop() #qt - Uim.timers.remove(self) - - - -class Signal: - """Each instance represents a single connection. - """ - signals = {} # Enabled signals - - def __init__(self, source, signal, name, xsignal, convert): - """'source' is the widget object which initiates the signal. - 'signal' is the signal name. - If 'name' is given (not empty), the signal will get this as its name, - and this name may be used for more than one connection. - Otherwise the name is built from the name of the source widget and - the signal type as 'source*signal' and this is unique. - If 'name' begins with '+' an additional argument, the source - widget name, will be inserted at the head of the argument list. - 'xsignal' is a toolkit specific signal descriptor. - 'convert' is an optional function (default None) - toolkit specific - - to perform signal argument conversions. - """ - self.widsig = '%s*%s' % (source.w_name, signal) - #+ For disconnect? - self.xsignal = xsignal - #- - self.convert = convert # Argument conversion function - self.tag = name if name else self.widsig - self.wname = source.w_name if self.tag[0] == '+' else None - if not source.connect(source, QtCore.SIGNAL(xsignal), #qt - self.signal): - gui_error("Couldn't enable signal '%s'" % self.widsig) - - def signal(self, *args): - if self.convert: - args = self.convert(*args) - if self.wname: - guiapp.sendsignal(self.tag, self.wname, *args) - else: - guiapp.sendsignal(self.tag, *args) - - def disconnect(self): - w = guiapp.getwidget(self.widsig.split('*')[0]) - w.disconnect(w, QtCore.SIGNAL(self.xsignal), self.signal) #qt - - - -#+++++++++++++++++++++++++++ -# Catch all unhandled errors. -def errorTrap(type, value, tb): - etext = "".join(traceback.format_exception(type, value, tb)) - debug(etext) - gui_error(etext, "This error could not be handled.") - -sys.excepthook = errorTrap -#--------------------------- - -widget_table = { - "DATA": DATA, - "Window": Window, - "Dialog": Dialog, - "DialogButtons": DialogButtons, - "Notebook": Notebook, - "Stack": Stack, - "Page": Page, - "Frame": Frame, - "Button": Button, - "ToggleButton": ToggleButton, - "RadioButton": RadioButton, - "CheckBox": CheckBox, - "Label": Label, - "CheckList": CheckList, - "List": List, - "OptionalFrame": OptionalFrame, - "ComboBox": ComboBox, - "ListChoice": ListChoice, - "LineEdit": LineEdit, - "TextEdit": TextEdit, - "HtmlView": HtmlView, - "SpinBox": SpinBox, - "ProgressBar": ProgressBar, -} - -specials_table = { - "textLineDialog": textLineDialog, - "infoDialog": infoDialog, - "confirmDialog": confirmDialog, - "errorDialog": gui_error, - "warningDialog": gui_warning, - "fileDialog": fileDialog, - "listDialog": listDialog, -} - -layout_table = { - "VBOX": VBOX, - "HBOX": HBOX, - "GRID": GRID, -# "+": GRIDROW, - "-": CSPAN, - "|": RSPAN, - "*": SPACE, - "VLINE": VLINE, - "HLINE": HLINE, -} - |