def connect_app_signals (self,app):
"""connects standard app signals to appropriate methods."""
self._app = app;
QObject.connect(app,PYSIGNAL("solver.begin"),self.xcurry(self.solver_begin,_argslice=slice(1,2)));
QObject.connect(app,PYSIGNAL("solver.iter"),self.xcurry(self.solver_iter,_argslice=slice(1,2)));
QObject.connect(app,PYSIGNAL("solver.end"),self.xcurry(self.solver_end,_argslice=slice(1,2)));
QObject.connect(app,PYSIGNAL("isConnected()"),self.xcurry(self.reset));
def __init__(self,parent,name,name1='',udi_root=None,caption=None,prec=(None,'g'),maxwidth=None):
self._tw = DataDraggableTreeWidget(ClickableTreeWidget)(parent);
self._tw.setHeaderLabels([name1,'',name]);
self._tw.setRootIsDecorated(True);
self._tw.setSortingEnabled(False);
self._tw.header().setResizeMode(0,QHeaderView.ResizeToContents);
self._tw.header().setResizeMode(1,QHeaderView.ResizeToContents);
self._tw.header().setResizeMode(2,QHeaderView.ResizeToContents);
self._tw.header().setStretchLastSection(False);
self._tw.header().setResizeMode(QHeaderView.ResizeToContents);
self._tw.header().hide();
setattr(self._tw,'_maxwidth',maxwidth or HierBrowser.MaxWidth);
# self._tw.header().setResizeMode(QHeaderView.Fixed);
# for col in (0,1,2):
# self._tw.setColumnWidthMode(col,QListView.Maximum);
# self._tw.setFocus();
QObject.connect(self._tw,SIGNAL('itemExpanded(QTreeWidgetItem*)'),
self._expand_item_content);
QObject.connect(self._tw,PYSIGNAL('mouseButtonClicked()'),self._process_item_click);
QObject.connect(self._tw,PYSIGNAL('itemContextMenuRequested()'),self._show_context_menu);
# self._tw.connect(self._tw,SIGNAL('doubleClicked(QListViewItem*)'),
# self.display_item);
# connect the get_drag_item method for drag-and-drop
self._tw.get_drag_item = self.get_drag_item;
self._tw.get_drag_item_type = self.get_drag_item_type;
# enable UDIs, if udi root is not none
self.set_udi_root(udi_root);
# initialize precision
self._tw._prec = prec;
# for debugging purposes
QObject.connect(self._tw,SIGNAL("itemClicked(QTreeWidgetItem*)"),self._print_item);
def add_page(self, name=None, icon=None):
page = Timba.Grid.Page(self,
self._maintab,
max_nx=self.max_nx,
max_ny=self.max_ny)
wpage = page.wtop()
wpage._page = page
_dprint(2, 'name', name, 'icon', icon)
index = self._maintab.count()
# generate page name, if none is supplied
if name is None:
name = 'Page %d' % (index + 1)
page.set_name(name, True)
# auto_name = True
else:
page.set_name(name)
page.set_icon(icon)
# add page to tab
icon = icon or QIcon()
_dprint(2, 'addTab:', name, icon)
self._maintab.addTab(wpage, icon, name)
self._maintab.setCurrentIndex(index)
QWidget.connect(wpage, PYSIGNAL("layoutChanged()"),
self._set_layout_button)
wpage._change_icon = curry(self._maintab.setTabIcon, index)
QWidget.connect(wpage, PYSIGNAL("setIcon()"), wpage._change_icon)
wpage._rename = curry(self._maintab.setTabText, index)
QWidget.connect(wpage, PYSIGNAL("setName()"), wpage._rename)
return page
def __init__(self, gw, dataitem, cellspec={}, default_open=None, **opts):
GriddedPlugin.__init__(self, gw, dataitem, cellspec=cellspec)
HierBrowser.__init__(self,
self.wparent(),
"value",
"field",
udi_root=dataitem.udi)
# adjust columns when font changes
QObject.connect(self.wtop(), PYSIGNAL("fontChanged()"),
self._resize_sections)
self.set_widgets(self.wtop(), dataitem.caption, icon=self.icon())
self._rec = None
self._default_open = default_open
if dataitem.data is not None:
self.set_data(dataitem)
# add number format menu
context_menu = self.cell_menu()
if context_menu is not None:
context_menu.addSeparator()
_dprint(3, self.get_precision())
menu = PrecisionPopupMenu(context_menu, prec=self.get_precision())
qa = context_menu.addMenu(menu)
qa.setIcon(pixmaps.precplus.icon())
qa.setText('Number format')
QWidget.connect(menu, PYSIGNAL("setPrecision()"),
self._set_prec_from_menu)
def __init__(self, name, page, parent):
QObject.__init__(self, parent)
QObject.connect(self, PYSIGNAL("updated()"), parent,
PYSIGNAL("updated()"))
self.name = name
self.page = page
self.rec = record(name=name, page=page)
def _allocate_grid(self, **kwds):
"""Allocates self._cells: a grid of cells from a workspace.
All keywords are passed to gridded_workspace.allocate_cells()."""
# if a previous position in grid was saved, try to reuse it
if hasattr(self, '_gridpos'):
kwds['position'] = self._gridpos
self._cells = self._gw.allocate_cells(nrow=self._nrow,
ncol=self._ncol,
udi=self._dataitem.udi,
**kwds)
if not self._cells:
raise Timba.Grid.Error, "unable to allocate cells"
# save new position
leadcell = self._cells[0]
self._gridpos = leadcell.grid_position()
_dprint(2, id(self), ': allocated', len(self._cells),
'cells at position', self._gridpos)
# connect signal: remove dataitem when cells are closed
leadcell.connect(
PYSIGNAL("wiped()"),
self._currier.xcurry(Timba.Grid.Services.removeDataItem,
_args=(self._dataitem, ),
_argslice=slice(0)))
# connect signal: float cells
leadcell.connect(PYSIGNAL("float()"), self.float_cells)
def _allocate_float(self):
"""internal helper func: creates a float window when first called."""
try:
float_window = self._float_window
except AttributeError:
self._float_window = float_window = Timba.Grid.Floater(
self._gw.wtop())
QObject.connect(float_window, PYSIGNAL("closed()"), self._unfloat)
float_window.setWindowTitle(self._dataitem.name)
# allocate single cell or grid
if self._totsize == 1:
# notitle=True: do not create cell titlebar
cell = Timba.Grid.Cell(float_window, (0, 0), notitle=True)
self._float_cells = (cell, )
float_window.setCentralWidget(cell.wtop())
else:
self._float_grid = Timba.Grid.Page(self._gw, float_window,
self._ncol, self._nrow)
# allocate grid of fixed cells (fixed means no drop support and
# no change of viewer allowed)
self._float_cells = self._float_grid.allocate_cells(
nrow=self._nrow, ncol=self._ncol, fixed_cells=True)
float_window.setCentralWidget(self._float_grid.wtop())
# connect signal: remove dataitem when cells are closed
self._float_cells[0].connect(PYSIGNAL("closed()"), self.close)
return float_window
def __init__(self, name, udi, parent, viewer=None):
QObject.__init__(self, parent)
QObject.connect(self, PYSIGNAL("updated()"), parent,
PYSIGNAL("updated()"))
self.name = name
self.rec = record(name=name, udi=udi)
# resolve viewer to actual viewer class (or None if none specified),
# and rec.viewer to viewer name; set icon based on viewer
if viewer is None:
self.icon = QIcon
self.enabled = True
self.viewer = None
else:
if isinstance(viewer, str):
self.rec.viewer = viewer
self.viewer = Grid.Services.getViewerByName(viewer)
elif callable(viewer):
self.rec.viewer = getattr(viewer, 'viewer_name',
viewer.__name__)
self.viewer = viewer
else:
raise TypeError("illegal viewer argument " + str(viewer))
if self.viewer is not None:
self.icon = getattr(self.viewer, 'icon', QIcon)
self.enabled = True
else:
self.icon = QIcon
self.enabled = False
def __init__(self, parent, max_nx=4, max_ny=4, use_hide=None):
# dictionary of UDIs -> list of GridDataItem objects
self._dataitems = dict()
# highlighted item
self._highlight = None
# currier
self._currier = PersistentCurrier()
self.curry = self._currier.curry
self.xcurry = self._currier.xcurry
self._maintab = QTabWidget(parent)
self._maintab.setTabPosition(QTabWidget.North)
QWidget.connect(self._maintab, SIGNAL("currentChanged(int)"),
self._set_layout_button)
self.max_nx = max_nx
self.max_ny = max_ny
# set of parents for corners of the maintab (added on demand when GUI is built)
self._tb_corners = {}
#------ add page
newpage = self.add_tool_button(
Qt.TopLeftCorner,
pixmaps.tab_new_raised.icon(),
tooltip="open new page. You can also drop data items here.",
class_=self.DataDropButton,
click=self.add_page)
newpage._dropitem = xcurry(Timba.Grid.Services.addDataItem,
_argslice=slice(0, 1),
newpage=True)
QWidget.connect(newpage, PYSIGNAL("itemDropped()"), newpage._dropitem)
#------ new panels button
self._new_panel = self.add_tool_button(
Qt.TopLeftCorner,
pixmaps.view_right.icon(),
tooltip=
"add more panels to this page. You can also drop data items here.",
class_=self.DataDropButton,
click=self._add_more_panels)
self._new_panel._dropitem = xcurry(Timba.Grid.Services.addDataItem,
_argslice=slice(0, 1),
newcell=True)
QWidget.connect(self._new_panel, PYSIGNAL("itemDropped()"),
self._new_panel._dropitem)
#------ align button
self.add_tool_button(Qt.TopLeftCorner,
pixmaps.view_split.icon(),
tooltip="align panels on this page",
click=self._align_grid)
#------ remove page
self.add_tool_button(Qt.TopRightCorner,
pixmaps.tab_remove.icon(),
tooltip="remove this page",
click=self.remove_current_page)
# init first page
self.add_page()
def execute_tdl_job(self, _tdlmod, ns, func, name, job_id):
"""executes a predefined TDL job given by func"""
self._tdlexec_menu.hide()
try:
# log job
TDLOptions.dump_log(
"running TDL job '%s' (%s)" %
(name, ("job id '%s'" % job_id if job_id else "no job id")))
busy = BusyIndicator()
func(meqds.mqs(), self)
# no errors, so clear error list, if any
self.clear_errors()
self.show_message("TDL job '" + name + "' executed.",
transient=True)
busy = None
except:
(etype, exc, tb) = sys.exc_info()
_dprint(0, 'exception running TDL job', func.__name__)
traceback.print_exception(etype, exc, tb)
# use TDL add_error() to process the error, since this automatically
# adds location information. However, we want to remove ourselves
# from the stack traceback first
tb = traceback.extract_tb(tb)
# pop everything leading up to our filename
while tb[0][0] != _MODULE_FILENAME:
tb.pop(0)
# pop frame with our filename, this should leave only TDL-code frames
tb.pop(0)
ns.AddError(exc, tb, error_limit=None)
msg = "TDL job '" + name + "' failed"
self._error_window.set_errors(ns.GetErrors(), message=msg)
self.emit(PYSIGNAL("showEditor()"), self)
busy = None
def _reset_errors(self, nerr):
"""helper method, resets error markers and such. Usually tied to a hasErrors() signal
from an error window"""
if not self._enabled:
return
self._error_at_line = {}
self._error_selections = []
self._current_error_selection = QTextEdit.ExtraSelection()
nerr_local = 0
if nerr:
error_locations = self._error_window.get_error_locations()
for err_num, filename, line, column, suberror in error_locations:
if filename == self._filename:
nerr_local += 1
# make cursor corresponding to line containing the error
cursor = QTextCursor(self._find_block_by_linenumber(line))
cursor.select(QTextCursor.LineUnderCursor)
# make selection object
qsel = QTextEdit.ExtraSelection()
qsel.cursor = cursor
if suberror:
qsel.format = self._format_suberror
else:
qsel.format = self._format_error
# insert into error_at_line list
self._error_at_line[line - 1] = len(
self._error_selections), cursor
# append to list of error selections
self._error_selections.append(qsel)
self._editor.setExtraSelections(self._error_selections)
else:
self._editor.setExtraSelections([])
self.emit(PYSIGNAL("hasErrors()"), self, nerr_local)
def _compile_main_file(self):
# self._tb_opts.setOn(False);
self.clear_errors()
if self._document.isModified():
self._save_file()
self.emit(PYSIGNAL("compileFile()"), self, self._mainfile
or self._filename)
def _save_profile(self, name):
if self.profiles.has_section(name):
if QMessageBox.warning(
self, "Overwriting profile", """<P>Do you really want to
overwrite the existing profile '%s'?</P>""" % name,
QMessageBox.Ok | QMessageBox.Cancel,
QMessageBox.Ok) != QMessageBox.Ok:
return
newprof = False
else:
self.profiles.add_section(name)
newprof = True
TDLOptions.save_to_config(self.profiles, name)
try:
ff = file(PROFILE_FILE, "wt")
for section in sorted(self.profiles.sections()):
ff.write("[%s]\n" % section)
for opt, value in sorted(self.profiles.items(section)):
ff.write("%s = %s\n" % (opt.lower(), value))
ff.write("\n")
ff.close()
except:
dprintf(0, "error writing %s" % PROFILE_FILE)
traceback.print_exc()
QMessageBox.warning(
self, "Error saving profile",
"""<P>There was an error writing to the %s file,
profile was not saved.</P>""" % PROFILE_FILE)
if newprof:
self.emit(PYSIGNAL("refreshProfiles()"))
def load_file(self, filename, text=None, readonly=False, mainfile=None):
"""loads editor content.
filename is filename. text is file contents, if none then file will be re-read.
readonly is True for readonly mode.
If mainfile is not None, then this editor is "slaved" to the mainfile. This is the
case for files included from other modules.
"""
self.clear_message()
if not os.access(filename, os.W_OK):
readonly = True
# load text from file if not supplied
if text is None:
text = open(filename).read()
self._filename = filename
# sets as as the mainfile or as a submodule of a main file
self._set_mainfile(mainfile)
# set save icons, etc.
self._qa_revert.setEnabled(True)
self._basename = os.path.basename(filename)
self._readonly = readonly
self._file_disktime = filename and _file_mod_time(filename)
self._document.setPlainText(text)
self._document.setModified(False)
self._editor.setReadOnly(not os.access(self._filename, os.W_OK))
self._text_modified(False)
# to reset labels
QApplication.processEvents(QEventLoop.ExcludeUserInputEvents)
# emit signals
self.emit(PYSIGNAL("fileLoaded()"), self, filename)
# if module is a main-level file (i.e. not slaved to another mainfile),
# pre-import it so that compile-time menus become available
self._tdlmod = None
if not mainfile:
self.import_content()
def __init__(self, gw, dataitem, cellspec={}, default_open=None, **opts):
browsers.GriddedPlugin.__init__(self, gw, dataitem, cellspec=cellspec)
self._wedit = TDLEditor(self.wparent())
self.set_widgets(self.wtop(), dataitem.caption, icon=self.icon())
if dataitem.data is not None:
self.set_data(dataitem)
QObject.connect(self.wtop(), PYSIGNAL("fontChanged()"),
self.wtop().adjust_editor_font)
def __init__(self,
gw,
parent_widget,
max_nx=5,
max_ny=5,
fixed_cells=False):
self._topgrid = QSplitter(Qt.Vertical, parent_widget)
self._gw = gw
self.max_nx = max_nx
self.max_ny = max_ny
self.max_items = max_nx * max_ny
self._rows = []
self._frag_tag = None
self._pagename = self._autoname = ''
self._icon = QIcon()
self._icon_cou = False
# possible layout formats (nrow,ncol)
self._layouts = [(1, 1)]
for i in range(2, self.max_nx + 1):
self._layouts += [(i, i - 1), (i, i)]
# create cells matrix
for irow in range(self.max_ny):
row = self.GridRow(self._topgrid)
row.hide()
self._rows.append(row)
for icol in range(self.max_nx):
pos = (self, irow, icol)
cell = Timba.Grid.Cell(row,
pos,
fixed_cell=fixed_cells,
page=self)
row._cells.append(cell)
cell._clear_slot = curry(self._clear_cell, cell)
QWidget.connect(cell.wtop(), PYSIGNAL("closed()"),
cell._clear_slot)
cell._drop_slot = curry(self.drop_cell_item, cell)
QWidget.connect(cell.wtop(), PYSIGNAL("itemDropped()"),
cell._drop_slot)
cell._cv_slot = curry(self.change_viewer, cell)
QWidget.connect(cell.wtop(), PYSIGNAL("changeViewer()"),
cell._cv_slot)
# cell._display_slot = curry(self._display_data_item,parent=weakref.ref(cell));
# QWidget.connect(cell.wtop(),PYSIGNAL("displayDataItem()"),
# cell._display_slot);
# prepare layout
self.set_layout(0)
def visQAction (self,parent=None):
try: return self._qa_vis;
except AttributeError: pass;
qa = self._qa_vis = QAction(self.icon,"Show/hide "+self.name,parent);
qa.setCheckable(True);
qa.setChecked(self.isVisible());
QObject.connect(qa,SIGNAL("triggered(bool)"),self.setVisible);
QObject.connect(self,PYSIGNAL("visible()"),qa.setChecked);
return qa;
def set_errors(self,
error_list,
emit_signal=True,
show_item=True,
message="TDL compile failed"):
"""Shows an error list. errlist should be a sequence of Exception
objects following the TDL error convention.
message is a status message
If show_item=True, highlights the first error
If emit_signal=True, emits a hasErrors(nerr) pysignal
"""
_dprint(1, "set_errors: list of", len(error_list), "entries")
_dprint(1, "current list has", len(self._error_list), "entries")
# do nothing if already set
if self._error_list is error_list:
return
self.clear_errors(emit_signal=False)
self._error_list = error_list
self._error_locations = []
# list of error locations
self._error_items = []
self._toplevel_error_items = []
if error_list:
self._populate_error_list(self._werrlist,
error_list,
toplevel=True)
nerr = len(self._toplevel_error_items)
self._error_count_label.setText('%s: <b>%d</b> errors' %
(message, nerr))
self.setWindowTitle("TDL Errors: %d" % nerr)
if emit_signal:
self.emit(PYSIGNAL("hasErrors"), nerr)
if show_item:
self._show_error_item(self._toplevel_error_items[0])
self.show()
# self._highlight_error(0);
# disable run control until something gets modified
# self._qa_run.setVisible(False);
else:
if emit_signal:
self.emit(PYSIGNAL("hasErrors"), 0)
self.setWindowTitle("TDL Errors")
self.hide()
def clear_errors(self, emit_signal=True):
"""clears the error list. If emit_signal=True, emits a hasErrors(0) pysignal"""
if emit_signal:
self.emit(PYSIGNAL("hasErrors"), 0)
self._error_items = self._toplevel_error_items = None
self.setWindowTitle("TDL Errors")
self._werrlist.clear()
self._error_count_label.setText('')
self._error_list = []
self._error_locations = []
self._item_shown = None
self.hide()
def _highlight_error_item(self, item, emit_signal=True):
"""highlights the given error item. If emit_signal=True, emits a
showError(index,filename,line,column) or showError(None) pysignal.
"""
if item:
self.show()
toplevel_index = item._toplevel_index
self._qa_prev_err.setEnabled(toplevel_index > 0)
self._qa_next_err.setEnabled(
toplevel_index < len(self._toplevel_error_items) - 1)
# does item contain a location attribute?
errloc = getattr(item, '_err_location', None)
if errloc:
# indicate location
_dprint(1, "highlighting error in", errloc)
if emit_signal:
self.emit(PYSIGNAL("showError"), *errloc)
return
# if we fell through to here, then no error has been shown -- emit appropriate signal
if emit_signal:
self.emit(PYSIGNAL("showError"), None, None, None, None)
def __init__ (self,panel,parent):
QToolButton.__init__(self,parent);
self._panel = panel;
self._label = [ "("+panel.shortname+")",panel.shortname+" " ];
self.setIcon(panel.icon);
self.setText(self._label[int(panel.isVisible())]);
self.setToolButtonStyle(Qt.ToolButtonTextBesideIcon);
self.setToolTip("Show "+panel.name);
QObject.connect(self,SIGNAL("clicked()"),self._toggle);
QObject.connect(panel,PYSIGNAL("visible()"),self._show_panel);
self._default_palette = self.palette();
self._flash_palette = QPalette(self.palette());
self._flash_palette.setBrush(QPalette.Background,QBrush(QColor("yellow")));
def _save_file(self, filename=None, text=None, force=False, save_as=False):
"""Saves text. If force=False, checks modification times in case
the file has been modified by another program.
If force=True, saves unconditionally.
If no filename is known, asks for one.
Returns True if file was successfully saved, else None."""
filename = filename or self._filename
if filename and not save_as:
if not force:
if not self.sync_external_file(filename=filename, ask=True):
return None
else: # no filename, ask for one
try:
dialog = self._save_as_dialog
dialog.setDirectory(dialog.directory())
# hopefully this rescan the directory
except AttributeError:
self._save_as_dialog = dialog = QFileDialog(
self, "Saved TDL Script")
dialog.resize(800, dialog.height())
dialog.setMode(QFileDialog.AnyFile)
dialog.setNameFilters(
["TDL scripts (*.tdl *.py)", "All files (*.*)"])
dialog.setViewMode(QFileDialog.Detail)
if dialog.exec_() != QDialog.Accepted:
return None
filename = str(dialog.selectedFiles()[0])
# save the file
if text is None:
text = str(self._editor.document().toPlainText())
try:
outfile = open(filename, "w").write(text)
except IOError:
(exctype, excvalue, tb) = sys.exc_info()
_dprint(0, 'exception', sys.exc_info(), 'saving TDL file',
filename)
self.show_message("""<b>Error writing <tt>%s</tt>:
<i>%s (%s)</i></b>""" % (filename, excvalue, exctype.__name__),
error=True,
transient=True)
return None
# saved successfully, update stuff
self._filename = filename
self._qa_revert.setEnabled(True)
self._basename = os.path.basename(filename)
self._file_disktime = _file_mod_time(filename)
self._document.setModified(False)
self.emit(PYSIGNAL("fileSaved()"), self, filename)
return self._filename
def __init__(self, name, parent, menu=None, load=None, gui_parent=None):
"""Creates a folder of bookmarks, and the associated menu.
If 'menu' is not None, bookmarks will be added to the supplied menu, else a new one will be created.
If load is set to a list (of bookmarks records), folder will be loaded.
'parent' is parent object. 'gui_parent' is parent object for menus (or else 'parent' will be used.)
"""
QObject.__init__(self, parent)
self.name = name
self._gui_parent = gui_parent
self._bklist = []
self._qas = []
if menu:
self._menu = menu
self._have_initial_menu = True
else:
self._menu = QMenu(str(name), gui_parent or parent)
self._menu.setIcon(self.icon())
self._have_initial_menu = False
if load is not None:
self.load(load)
QObject.connect(self, PYSIGNAL("showBookmark()"), self.parent(),
PYSIGNAL("showBookmark()"))
QObject.connect(self, PYSIGNAL("showPagemark()"), self.parent(),
PYSIGNAL("showPagemark()"))
def get_context_menu(self):
try:
menu = self._context_menu
except AttributeError:
# create menu on the fly when first called for this item
viewer_list = self._content is not None and self._viewable and \
Grid.Services.getViewerList(self._content,self._udi)
# create menu
menu = self._context_menu = QMenu(self.treeWidget())
menu._callbacks = []
menu.addAction(self._desc or self._name
or str(self.text(0))).setSeparator(True)
# insert Copy item
copy_qa = menu.addAction(pixmaps.editcopy.icon(),
'&Copy to clipboard',
self.copy_to_clipboard,
Qt.CTRL + Qt.Key_Insert)
# create "Precision" submenu
if self._strfunc:
self._prec_menu = PrecisionPopupMenu(menu, prec=self._prec)
qa = menu.addMenu(self._prec_menu)
qa.setText('Number format')
qa.setIcon(pixmaps.precplus.icon())
QWidget.connect(self._prec_menu,
PYSIGNAL("setPrecision()"),
self._set_prec_frommenu)
# create "display with" entries
if viewer_list:
# create display submenus
menu1 = self._display_menu1 = menu.addMenu(
pixmaps.viewmag.icon(), "Display with")
menu2 = self._display_menu2 = menu.addMenu(
pixmaps.viewmag_plus.icon(), "New display with")
for v in viewer_list:
# create entry for viewer
name = getattr(v, 'viewer_name', v.__name__)
try:
icon = v.icon()
except AttributeError:
icon = QIcon()
# add entry to both menus ("Display with" and "New display with")
menu1.addAction(icon,name, \
self.xcurry(self.emit_display_signal,viewer=v,_argslice=slice(0)))
menu2.addAction(icon,name, \
self.xcurry(self.emit_display_signal,viewer=v,newcell=True,_argslice=slice(0)))
# set the precision submenu to the right setting
return menu
def __init__(self,
app,
verbose=0,
size=(500, 500),
poll_app=None,
*args,
**kwargs):
"""create and populate the main application window"""
global gui
gui = self
#------ starts the main app object and event thread, if not already started
self._qapp = mainapp()
#------ init base classes
verbosity.__init__(self, verbose, name=app.name() + "/gui")
_dprint(1, "initializing")
QMainWindow.__init__(self, *args)
self.app = app
self._connected = False
self.populate(size=size, *args, **kwargs)
#------ set size
self.setCentralWidget(self.splitter)
sz = self.size().expandedTo(QSize(size[0], size[1]))
self.resize(sz)
# events from remote application are emitted as PYSIGNALS taking
# two arguments. Connect some standard handlers here
#QObject.connect(self,PYSIGNAL("hello"),self._attached_server_event);
#QObject.connect(self,PYSIGNAL("hello"),self.xcurry(self._update_app_state));
#QObject.connect(self,PYSIGNAL("bye"),self._detached_server_event);
#QObject.connect(self,PYSIGNAL("bye"),self.xcurry(self._update_app_state));
QObject.connect(self, PYSIGNAL("app.notify.state"),
self.xcurry(self._update_app_state))
#------ start timer when in polling mode
if poll_app:
self.startTimer(poll_app)
global splash_screen
if splash_screen is not None:
splash_screen.finish(self)
_dprint(2, "init complete") \
def set_widgets(self,
widgets,
captions=None,
icon=None,
enable_viewers=True):
"""Sets widget contents. Should only be called once.
widgets: a sequence of one widget per cell, counting across
the block, then down. If only a 1x1 block is allocated,
content may be a single widget.
captions: is an list of captions of the same size as widgets.
If None is supplied, the dataitem caption is used instead.
enable_viewers: if False, certain GUI functions will be disabled
"""
if isinstance(widgets, QWidget):
if len(self._cells) != 1:
raise ValueError(
"len of widgets argument does not match cell layout")
widgets = (widgets, )
else:
try:
n = len(widgets)
except:
raise TypeError(
"widgets argument must be a QWidget or a list of QWidgets")
if len(widgets) != len(self._cells):
raise ValueError(
"len of widgets argument does not match cell layout")
self._content = widgets
self._icon = icon
if captions is None:
self._captions = getattr(self._dataitem, 'caption',
self._dataitem.udi)
else:
self._captions = captions
_dprint(2, id(self), ': set content', widgets)
# initialize cells with contents
self._init_cells(self._cells, enable_viewers=enable_viewers)
# connect displayDataItem() signal from contents
for w in widgets:
QWidget.connect(w, PYSIGNAL("displayDataItem()"),
self._display_sub_item)
def connect_app_signals(self, app):
"""connects standard app signals to appropriate methods."""
self._app = app
QObject.connect(app, PYSIGNAL("vis.channel.open"),
self.xcurry(self.start, _argslice=slice(1, 2)))
QObject.connect(app, PYSIGNAL("vis.header"),
self.xcurry(self.header, _argslice=slice(1, 2)))
QObject.connect(app, PYSIGNAL("vis.num.tiles"),
self.xcurry(self.update, _argslice=slice(1, 2)))
QObject.connect(app, PYSIGNAL("vis.footer"),
self.xcurry(self.footer, _argslice=slice(1, 2)))
QObject.connect(app, PYSIGNAL("vis.channel.closed"),
self.xcurry(self.close, _argslice=slice(1, 2)))
QObject.connect(app, PYSIGNAL("isConnected()"),
self.xcurry(self.reset))
def _text_modified(self, mod=True):
self._modified = mod
self.emit(PYSIGNAL("textModified()"), self, bool(mod))
self._tb_save.setAutoRaise(not mod)
self._qa_revert.setEnabled(mod)
#if mod:
#self._tb_save.setBackgroundRole(QPalette.ToolTipBase);
#else:
#self._tb_save.setBackgroundRole(QPalette.Button);
if self._filename:
label = '<b>' + self._basename + '</b>'
self._pathlabel.setToolTip(self._filename)
else:
label = ''
self._pathlabel.setToolTip('')
if self._readonly:
label = '[r/o] ' + label
if mod:
self._clear_transients()
label = '[mod] ' + label
self._pathlabel.setText(label)
def ubsubscribe_nodelist(callback):
QObject.disconnect(nodelist, PYSIGNAL("loaded()"), callback)
def subscribe_forest_state(callback):
"""Adds a subscriber to node state changes. Callback must take one
argument: the new forest state"""
global _forest_state_obj
QObject.connect(_forest_state_obj, PYSIGNAL("state()"), callback)
