def newCanvas(self):
# Create the canvas object.
debug.mainthreadTest()
view = None
if self.oofcanvas:
view = self.oofcanvas.get_view()
self.oofcanvas.widget().destroy()
self.oofcanvas = oofcanvas3d.OOFCanvas3D() #self.settings)
self.oofcanvas.set_bgColor(self.settings.bgcolor)
self.canvasFrame.add(self.oofcanvas.widget())
# Retrieving the drawing area and initiating the logging.
canvasdrawingarea = self.oofcanvas.widget()
init_canvas_logging(canvasdrawingarea)
# Since the drawing area isn't a gtk widget it must be adopted
# by its frame in order to record and replay events.
gtklogger.adoptGObject(canvasdrawingarea, self.canvasFrame,
access_function=findCanvasDrawingArea,
access_kwargs={"windowname":self.name})
# Setting the connection.
gtklogger.connect_passive(canvasdrawingarea, "event")
self.oofcanvas.set_mouse_callback(self.mouseCB)
# self.oofcanvas.widget().connect("configure-event",
# self.canvasConfigureCB)
#self.oofcanvas.set_rubberband(self.rubberband)
#if view is not None:
# self.oofcanvas.set_view(view)
self.oofcanvas.show()
def __init__(self,
value=None,
vmin=0,
vmax=1,
step=0.01,
callback=None,
clipperclass=None,
name=None,
immediate=True):
# "callback" is called when the user moves the slider. If
# immediate==True, then the callback will be called when any
# character is typed in the Entry. If it's false, the
# callback won't be called until the entry loses focus.
debug.mainthreadTest()
self.immediate = immediate
self.gtk = gtk.HPaned()
if value is None:
value = vmin
self.clipperclass = clipperclass or DefaultClipper
self.clipper = self.clipperclass(vmin, vmax)
if name is not None:
gtklogger.setWidgetName(self.gtk, name)
self.adjustment = gtk.Adjustment(value=value,
lower=vmin,
upper=vmax,
step_incr=step,
page_incr=step)
self.slider = gtk.HScale(self.adjustment)
gtklogger.setWidgetName(self.slider, "slider")
gtklogger.adoptGObject(self.adjustment,
self.slider,
access_method=self.slider.get_adjustment)
self.slider.set_size_request(100, -1)
self.gtk.pack1(self.slider, resize=True, shrink=True)
self.slider.set_draw_value(False) # we'll display the value ourselves
self.adjustmentsignal = gtklogger.connect(self.adjustment,
'value-changed',
self.text_from_slider)
self.entry = gtk.Entry()
gtklogger.setWidgetName(self.entry, "entry")
self.gtk.pack2(self.entry, resize=True, shrink=True)
# Make sure that the Entry is big enough to hold the min and
# max values, or at least 8 digits.
width = max(len( ` vmin `), len( ` vmax `), 8)
self.entry.set_size_request(width * guitop.top().digitsize, -1)
self.entrysignal = gtklogger.connect(self.entry, 'changed',
self.entry_changed)
self.set_value(value)
self.callback = callback
self.changed = False
gtklogger.connect(self.entry, 'activate', self.slider_from_text)
gtklogger.connect(self.entry, 'focus-out-event', self.entry_lost_focus)
def __init__(self,
tree,
expand=1,
callback=None,
name=None,
*callbackargs,
**callbackkwargs):
debug.mainthreadTest()
self.tree = tree # associated LabelTree
self.callback = callback
self.callbackargs = callbackargs
self.callbackkwargs = callbackkwargs
self.rccb = None
# Create a TreeStore that mirrors the LabelTree. The first
# column is the label, and the second is the LabelTree node.
self.treestore = gtk.TreeStore(gobject.TYPE_STRING,
gobject.TYPE_PYOBJECT)
self.gtk = gtk.TreeView(model=self.treestore)
gtklogger.setWidgetName(self.gtk, name)
self.gtk.set_property("headers-visible", False)
tvcol = gtk.TreeViewColumn()
self.gtk.append_column(tvcol)
cell = gtk.CellRendererText()
tvcol.pack_start(cell, expand=False)
tvcol.set_attributes(cell,
text=0) # display column 0 of the tree store
selection = self.gtk.get_selection()
gtklogger.adoptGObject(selection,
self.gtk,
access_method=self.gtk.get_selection)
self.selection_signal = gtklogger.connect(selection, 'changed',
self.selectionChangedCB)
selection.set_select_function(self.selectFn)
gtklogger.connect(self.gtk, 'row-activated', self.activateRowCB)
gtklogger.connect_passive(self.gtk, 'row-expanded')
gtklogger.connect_passive(self.gtk, 'row-collapsed')
self.lt2treeiter = {}
self.current_selection = None # a LabelTreeNode
for node in tree.nodes:
self.constructGUI(node, None)
self.gtk.connect("destroy", self.destroyCB)
self.autoSelect()
self.gtk.show_all()
self.sbcallbacks = [
switchboard.requestCallbackMain((tree, "insert"), self.insertCB),
switchboard.requestCallbackMain((tree, "delete"), self.deleteCB),
switchboard.requestCallbackMain((tree, "rename"), self.renameCB)
]
def __init__(self,
objlist=None,
displaylist=[],
callback=None,
dbcallback=None,
autoselect=True,
helpdict={},
comparator=None,
markup=False,
name=None,
separator_func=None,
cbargs=None,
cbkwargs=None):
debug.mainthreadTest()
self.liststore = gtk.ListStore(gobject.TYPE_STRING,
gobject.TYPE_PYOBJECT)
self.treeview = gtk.TreeView(self.liststore)
self.gtk = self.treeview
self.treeview.set_property("headers-visible", 0)
cell = gtk.CellRendererText()
if markup:
# Expect to find pango markup in displaylist, which is
# stored in column 0 of the ListStore.
self.tvcol = gtk.TreeViewColumn("", cell, markup=0)
else:
self.tvcol = gtk.TreeViewColumn("", cell)
self.treeview.append_column(self.tvcol)
self.tvcol.add_attribute(cell, 'text', 0)
self.autoselect = autoselect
self.callback = callback or (lambda x, interactive=False: None)
self.dbcallback = dbcallback or (lambda x: None)
self.cbargs = cbargs or []
self.cbkwargs = cbkwargs or {}
self.comparator = comparator or (lambda x, y: x == y)
self.activatesignal = gtklogger.connect(self.treeview, 'row-activated',
self.rowactivatedCB)
# If separator_func is provided, it must be a function that
# takes a gtk.TreeModel and gtk.TreeIter as arguments, and
# return True if the row given by model[iter] is to be
# represented by a separator in the TreeView.
if separator_func:
self.treeview.set_row_separator_func(separator_func)
if name:
gtklogger.setWidgetName(self.treeview, name)
selection = self.treeview.get_selection()
gtklogger.adoptGObject(selection,
self.treeview,
access_method=self.treeview.get_selection)
self.selectsignal = gtklogger.connect(selection, 'changed',
self.selectionchangedCB)
self.update(objlist or [], displaylist, helpdict=helpdict)
def __init__(self, tree, expand=1, callback=None, name=None,
*callbackargs, **callbackkwargs):
debug.mainthreadTest()
self.tree = tree # associated LabelTree
self.callback = callback
self.callbackargs = callbackargs
self.callbackkwargs = callbackkwargs
self.rccb = None
# Create a TreeStore that mirrors the LabelTree. The first
# column is the label, and the second is the LabelTree node.
self.treestore = gtk.TreeStore(gobject.TYPE_STRING,
gobject.TYPE_PYOBJECT)
self.gtk = gtk.TreeView(model=self.treestore)
gtklogger.setWidgetName(self.gtk, name)
self.gtk.set_property("headers-visible", False)
tvcol = gtk.TreeViewColumn()
self.gtk.append_column(tvcol)
cell = gtk.CellRendererText()
tvcol.pack_start(cell, expand=False)
tvcol.set_attributes(cell, text=0) # display column 0 of the tree store
selection = self.gtk.get_selection()
gtklogger.adoptGObject(selection, self.gtk,
access_method=self.gtk.get_selection)
self.selection_signal = gtklogger.connect(selection, 'changed',
self.selectionChangedCB)
selection.set_select_function(self.selectFn)
gtklogger.connect(self.gtk, 'row-activated', self.activateRowCB)
gtklogger.connect_passive(self.gtk, 'row-expanded')
gtklogger.connect_passive(self.gtk, 'row-collapsed')
self.lt2treeiter = {}
self.current_selection = None # a LabelTreeNode
for node in tree.nodes:
self.constructGUI(node, None)
self.gtk.connect("destroy", self.destroyCB)
self.autoSelect()
self.gtk.show_all()
self.sbcallbacks = [
switchboard.requestCallbackMain((tree, "insert"), self.insertCB),
switchboard.requestCallbackMain((tree, "delete"), self.deleteCB),
switchboard.requestCallbackMain((tree, "rename"), self.renameCB)
]
def __init__(self, objlist=None, displaylist=[], callback=None,
dbcallback=None, autoselect=True, helpdict={},
comparator=None, markup=False,
name=None, separator_func=None):
debug.mainthreadTest()
self.liststore = gtk.ListStore(gobject.TYPE_STRING,
gobject.TYPE_PYOBJECT)
self.treeview = gtk.TreeView(self.liststore)
self.gtk = self.treeview
self.treeview.set_property("headers-visible", 0)
cell = gtk.CellRendererText()
if markup:
# Expect to find pango markup in displaylist, which is
# stored in column 0 of the ListStore.
self.tvcol = gtk.TreeViewColumn("", cell, markup=0)
else:
self.tvcol = gtk.TreeViewColumn("", cell)
self.treeview.append_column(self.tvcol)
self.tvcol.add_attribute(cell, 'text', 0)
self.autoselect = autoselect
self.callback = callback or (lambda x, interactive=False: None)
self.dbcallback = dbcallback or (lambda x: None)
self.comparator = comparator or (lambda x, y: x == y)
self.activatesignal = gtklogger.connect(self.treeview, 'row-activated',
self.rowactivatedCB)
# If separator_func is provided, it must be a function that
# takes a gtk.TreeModel and gtk.TreeIter as arguments, and
# return True if the row given by model[iter] is to be
# represented by a separator in the TreeView.
if separator_func:
self.treeview.set_row_separator_func(separator_func)
if name:
gtklogger.setWidgetName(self.treeview, name)
selection = self.treeview.get_selection()
gtklogger.adoptGObject(selection, self.treeview,
access_method=self.treeview.get_selection)
self.selectsignal = gtklogger.connect(selection, 'changed',
self.selectionchangedCB)
self.update(objlist or [], displaylist, helpdict=helpdict)
def __init__(self, value=None, vmin=0, vmax=1, step=0.01, callback=None, name=None, immediate=True):
# "callback" is called when the user moves the slider. If
# immediate==True, then the callback will be called when any
# character is typed in the Entry. If it's false, the
# callback won't be called until the entry loses focus.
debug.mainthreadTest()
self.immediate = immediate
self.gtk = gtk.HPaned()
if value is None:
value = vmin
if name is not None:
gtklogger.setWidgetName(self.gtk, name)
self.adjustment = gtk.Adjustment(value=value, lower=vmin, upper=vmax, step_incr=step, page_incr=step)
self.slider = gtk.HScale(self.adjustment)
gtklogger.setWidgetName(self.slider, "slider")
gtklogger.adoptGObject(self.adjustment, self.slider, access_method=self.slider.get_adjustment)
self.slider.set_size_request(100, -1)
self.gtk.pack1(self.slider, resize=True, shrink=True)
self.slider.set_draw_value(False) # we'll display the value ourselves
self.adjustmentsignal = gtklogger.connect(self.adjustment, "value-changed", self.text_from_slider)
self.entry = gtk.Entry()
gtklogger.setWidgetName(self.entry, "entry")
self.gtk.pack2(self.entry, resize=True, shrink=True)
# Make sure that the Entry is big enough to hold the min and
# max values, or at least 8 digits.
width = max(len(` vmin `), len(` vmax `), 8)
self.entry.set_size_request(width * guitop.top().digitsize, -1)
self.entrysignal = gtklogger.connect(self.entry, "changed", self.entry_changed)
self.set_value(value)
self.callback = callback
self.changed = False
gtklogger.connect(self.entry, "activate", self.slider_from_text)
gtklogger.connect(self.entry, "focus-out-event", self.entry_lost_focus)
def __init__(self):
self.built = False
oofGUI.MainPage.__init__(
self, name="FE Mesh", ordering=200,
tip="Create a Finite Element Mesh from a Skeleton.")
mainbox = gtk.VBox(spacing=2)
self.gtk.add(mainbox)
align = gtk.Alignment(xalign=0.5)
mainbox.pack_start(align, expand=0, fill=0)
centerbox = gtk.HBox(spacing=3)
align.add(centerbox)
self.meshwidget = whowidget.WhoWidget(ooflib.engine.mesh.meshes,
scope=self)
label = gtk.Label("Microstructure=")
label.set_alignment(1.0, 0.5)
centerbox.pack_start(label, expand=0, fill=0)
centerbox.pack_start(self.meshwidget.gtk[0], expand=0, fill=0)
label = gtk.Label("Skeleton=")
label.set_alignment(1.0, 0.5)
centerbox.pack_start(label, expand=0, fill=0)
centerbox.pack_start(self.meshwidget.gtk[1], expand=0, fill=0)
label = gtk.Label("Mesh=")
label.set_alignment(1.0, 0.5)
centerbox.pack_start(label, expand=0, fill=0)
centerbox.pack_start(self.meshwidget.gtk[2], expand=0, fill=0)
# Centered box of buttons
align = gtk.Alignment(xalign=0.5)
mainbox.pack_start(align, expand=0, fill=0)
bbox = gtk.HBox(homogeneous=1, spacing=3)
align.add(bbox)
self.newbutton = gtkutils.StockButton(gtk.STOCK_NEW, "New...")
gtklogger.setWidgetName(self.newbutton, 'New')
gtklogger.connect(self.newbutton, 'clicked', self.newCB)
tooltips.set_tooltip_text(
self.newbutton, "Create a new mesh from the current skeleton.")
bbox.pack_start(self.newbutton, expand=0, fill=1)
self.renamebutton = gtkutils.StockButton(gtk.STOCK_EDIT, "Rename...")
gtklogger.setWidgetName(self.renamebutton, 'Rename')
gtklogger.connect(self.renamebutton, 'clicked', self.renameCB)
tooltips.set_tooltip_text(self.renamebutton,"Rename the current mesh.")
bbox.pack_start(self.renamebutton, expand=0, fill=1)
self.copybutton = gtkutils.StockButton(gtk.STOCK_COPY, "Copy...")
gtklogger.setWidgetName(self.copybutton, 'Copy')
gtklogger.connect(self.copybutton, 'clicked', self.copyCB)
tooltips.set_tooltip_text(self.copybutton,"Copy the current mesh.")
bbox.pack_start(self.copybutton, expand=0, fill=1)
self.deletebutton = gtkutils.StockButton(gtk.STOCK_DELETE, "Delete")
gtklogger.setWidgetName(self.deletebutton, 'Delete')
gtklogger.connect(self.deletebutton, 'clicked', self.deleteCB)
tooltips.set_tooltip_text(self.deletebutton,"Delete the current mesh.")
bbox.pack_start(self.deletebutton, expand=0, fill=1)
self.savebutton = gtkutils.StockButton(gtk.STOCK_SAVE, "Save...")
gtklogger.setWidgetName(self.savebutton, 'Save')
gtklogger.connect(self.savebutton, 'clicked', self.saveCB)
tooltips.set_tooltip_text(self.savebutton,
"Save the current mesh to a file.")
bbox.pack_start(self.savebutton, expand=0, fill=1)
mainpane = gtk.HPaned()
gtklogger.setWidgetName(mainpane, 'Pane')
mainbox.pack_start(mainpane, expand=1, fill=1)
gtklogger.connect_passive(mainpane, 'notify::position')
leftbox = gtk.VPaned()
mainpane.pack1(leftbox, resize=1, shrink=0)
infoframe = gtk.Frame('Mesh Information')
infoframe.set_shadow_type(gtk.SHADOW_IN)
leftbox.pack1(infoframe, resize=1, shrink=1)
scroll = gtk.ScrolledWindow()
gtklogger.logScrollBars(scroll, "MeshInfo")
scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scroll.set_shadow_type(gtk.SHADOW_IN)
infoframe.add(scroll)
self.infoarea = fixedwidthtext.FixedWidthTextView()
gtklogger.setWidgetName(self.infoarea, 'info')
self.infoarea.set_cursor_visible(False)
self.infoarea.set_editable(False)
scroll.add(self.infoarea)
###
## Subproblem creation, deletion, etc.
#subprobframe = gtk.Frame('Subproblems')
#gtklogger.setWidgetName(subprobframe, 'Subproblems')
#subprobframe.set_shadow_type(gtk.SHADOW_IN)
#leftbox.pack2(subprobframe, resize=1, shrink=1)
#subpbox = gtk.VBox()
#subprobframe.add(subpbox)
#self.subpchooser = chooser.ScrolledChooserListWidget(
#callback=self.subpchooserCB,
#dbcallback=self.subprobEditCB,
#name="subprobChooser")
#subpbox.pack_start(self.subpchooser.gtk, expand=1, fill=1)
#subpbuttons1 = gtk.HBox(homogeneous=True, spacing=2)
#subpbuttons2 = gtk.HBox(homogeneous=True, spacing=2)
#subpbox.pack_start(subpbuttons1, expand=0, fill=0)
#subpbox.pack_start(subpbuttons2, expand=0, fill=0)
# Subproblem creation, deletion, etc.
subprobframe = gtk.Frame('Subproblems')
gtklogger.setWidgetName(subprobframe, 'Subproblems')
subprobframe.set_shadow_type(gtk.SHADOW_IN)
leftbox.pack2(subprobframe, resize=1, shrink=1)
subpbox = gtk.VBox()
subprobframe.add(subpbox)
innerframe = gtk.Frame()
innerframe.set_shadow_type(gtk.SHADOW_IN)
subpbox.pack_start(innerframe, expand=1, fill=1)
self.subpScroll = gtk.ScrolledWindow()
gtklogger.logScrollBars(self.subpScroll, "SubproblemScroll")
self.subpScroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
innerframe.add(self.subpScroll)
self.subprobList = gtk.ListStore(gobject.TYPE_PYOBJECT)
self.subpListView = gtk.TreeView(self.subprobList)
gtklogger.setWidgetName(self.subpListView, "SubproblemList")
self.subpScroll.add(self.subpListView)
gtklogger.adoptGObject(self.subprobList, self.subpListView,
access_method=self.subpListView.get_model)
# Catch selection changes
gtklogger.adoptGObject(self.subpListView.get_selection(),
self.subpListView,
access_method=self.subpListView.get_selection)
self.subpselsig = gtklogger.connect(self.subpListView.get_selection(),
'changed', self.subpSelectCB)
# Catch double clicks or returns
gtklogger.connect(self.subpListView, 'row-activated',
self.subprobEditCB)
# Subproblem name in the column 1
namecell = gtk.CellRendererText()
namecol = gtk.TreeViewColumn("Subproblem")
namecol.set_resizable(True)
namecol.pack_start(namecell, expand=True)
namecol.set_cell_data_func(namecell, self.renderSubproblemName)
self.subpListView.append_column(namecol)
# Subproblem consistency in the column 2
consistencycell = gtk.CellRendererText()
consistencycol = gtk.TreeViewColumn("Consistent?")
consistencycol.set_resizable(True)
consistencycol.pack_start(consistencycell, expand=True)
consistencycol.set_cell_data_func(consistencycell, self.renderSubproblemConsistency)
self.subpListView.append_column(consistencycol)
# Subproblem type in the column 3
typecell = gtk.CellRendererText()
typecol = gtk.TreeViewColumn("Type")
typecol.set_resizable(True)
typecol.pack_start(typecell, expand=True)
typecol.set_cell_data_func(typecell, self.renderSubproblemType)
self.subpListView.append_column(typecol)
# Buttons at the bottom of the subproblem pane
subpbuttons1 = gtk.HBox(homogeneous=True, spacing=2)
subpbuttons2 = gtk.HBox(homogeneous=True, spacing=2)
subpbox.pack_start(subpbuttons1, expand=0, fill=0)
subpbox.pack_start(subpbuttons2, expand=0, fill=0)
###
self.subprobNew = gtkutils.StockButton(gtk.STOCK_NEW, "New...")
gtklogger.setWidgetName(self.subprobNew, "New")
gtklogger.connect(self.subprobNew, "clicked", self.subprobNewCB)
tooltips.set_tooltip_text(self.subprobNew,"Create a new subproblem.")
subpbuttons1.pack_start(self.subprobNew, expand=1, fill=1)
self.subprobRename = gtk.Button("Rename...")
gtklogger.setWidgetName(self.subprobRename, "Rename")
gtklogger.connect(self.subprobRename, "clicked", self.subprobRenameCB)
tooltips.set_tooltip_text(self.subprobRename,
"Rename the selected subproblem")
subpbuttons1.pack_start(self.subprobRename, expand=1, fill=1)
self.subprobEdit = gtkutils.StockButton(gtk.STOCK_EDIT, "Edit...")
gtklogger.setWidgetName(self.subprobEdit, "Edit")
gtklogger.connect(self.subprobEdit, 'clicked', self.subprobEditCB)
tooltips.set_tooltip_text(self.subprobEdit,
"Edit the selected subproblem.")
subpbuttons1.pack_start(self.subprobEdit, expand=1, fill=1)
self.subprobCopy = gtkutils.StockButton(gtk.STOCK_COPY, "Copy...")
gtklogger.setWidgetName(self.subprobCopy, "Copy")
gtklogger.connect(self.subprobCopy, "clicked", self.subprobCopyCB)
tooltips.set_tooltip_text(self.subprobCopy,
"Copy the selected subproblem.")
subpbuttons2.pack_start(self.subprobCopy, expand=1, fill=1)
## subpbuttons2.pack_start(gtk.HBox(), expand=1, fill=1) # filler
self.subprobInfo = gtk.Button("Info")
gtklogger.setWidgetName(self.subprobInfo, "Info")
gtklogger.connect(self.subprobInfo, 'clicked', self.subprobInfoCB)
tooltips.set_tooltip_text(self.subprobInfo,
"Print information about the selected subproblem")
subpbuttons2.pack_start(self.subprobInfo, expand=1, fill=1)
self.subprobDelete = gtkutils.StockButton(gtk.STOCK_DELETE, "Delete")
gtklogger.setWidgetName(self.subprobDelete, "Delete")
gtklogger.connect(self.subprobDelete, "clicked", self.subprobDeleteCB)
tooltips.set_tooltip_text(self.subprobDelete,
"Delete the selected subproblem.")
subpbuttons2.pack_start(self.subprobDelete, expand=1, fill=1)
# Right hand side for element operations
elementopsframe = gtk.Frame(label="Mesh Operations")
gtklogger.setWidgetName(elementopsframe, 'ElementOps')
elementopsframe.set_shadow_type(gtk.SHADOW_IN)
mainpane.pack2(elementopsframe, resize=0, shrink=0)
elementopsbox = gtk.VBox(spacing=3)
elementopsframe.add(elementopsbox)
self.elementops = regclassfactory.RegisteredClassFactory(
meshmod.MeshModification.registry,
title="Method:",
callback=self.elementopsCB,
expand=0, fill=0, scope=self, name="Method")
elementopsbox.pack_start(self.elementops.gtk, expand=1, fill=1)
self.historian = historian.Historian(self.elementops.set,
self.sensitizeHistory,
setCBkwargs={'interactive':1})
# Prev, OK, Next
hbox = gtk.HBox()
elementopsbox.pack_start(hbox, expand=0, fill=0, padding=2)
self.prevbutton = gtkutils.prevButton()
gtklogger.connect(self.prevbutton, 'clicked', self.prevCB)
tooltips.set_tooltip_text(self.prevbutton,
"Recall the previous mesh element operation.")
hbox.pack_start(self.prevbutton, expand=0, fill=0, padding=2)
self.okbutton = gtk.Button(stock=gtk.STOCK_OK)
gtklogger.setWidgetName(self.okbutton, 'OK')
gtklogger.connect(self.okbutton, 'clicked', self.okCB)
tooltips.set_tooltip_text(self.okbutton,
'Perform the mesh operation defined above.')
hbox.pack_start(self.okbutton, expand=1, fill=1, padding=5)
self.nextbutton = gtkutils.nextButton()
gtklogger.connect(self.nextbutton, 'clicked', self.nextCB)
tooltips.set_tooltip_text(self.nextbutton,
'Recall the next mesh element operation.')
hbox.pack_start(self.nextbutton, expand=0, fill=0, padding=2)
self.built = True
# lastStatus is used to prevent update_info() from being
# called when a nominal status change hasn't really changed
# anything.
self.lastStatus = None
switchboard.requestCallbackMain("Mesh modified",
self.recordModifier)
switchboard.requestCallbackMain("mesh changed", self.meshchangeCB)
switchboard.requestCallbackMain(("new who", "Microstructure"),
self.newMSorSkeleton)
switchboard.requestCallbackMain(("new who", "Skeleton"),
self.newMSorSkeleton)
switchboard.requestCallbackMain(("new who", "Mesh"),
self.newMesh)
switchboard.requestCallbackMain(("new who", "SubProblem"),
self.newSubProblem)
switchboard.requestCallbackMain(("rename who", "SubProblem"),
self.renamedSubProblem)
switchboard.requestCallbackMain(("remove who", "SubProblem"),
self.removeSubProblem)
switchboard.requestCallbackMain(self.meshwidget, self.meshwidgetCB)
switchboard.requestCallbackMain("equation activated",
self.equationCB)
switchboard.requestCallbackMain("mesh status changed",
self.statusChanged)
# switchboard.requestCallbackMain("mesh boundaries changed",
# self.newMeshBoundaries)
switchboard.requestCallbackMain(('validity', self.elementops),
self.validityChangeCB)
def preinitialize(self, name, gfxmanager, clone):
debug.mainthreadTest()
self.gtk = None
self.closed = None # State data used at window-close time.
self.name = name
self.oofcanvas = None
self.realized = 0
self.zoomed = 0
self.settings = ghostgfxwindow.GfxSettings()
self.mouseHandler = mousehandler.nullHandler # doesn't do anything
self.rubberband = rubberband.NoRubberBand()
#self.contourmapdata = None
# Build all the GTK objects for the interior of the box. These
# actually get added to the window itself after the SubWindow
# __init__ call. They need to be created first so the
# GhostGfxWindow can operate on them, and then create the menus
# which are handed off to the SubWindow.
self.mainpane = gtk.VPaned()
gtklogger.setWidgetName(self.mainpane, 'Pane0')
# Panes dividing upper pane horizontally into 3 parts.
# paned1's left half contains paned2.
self.paned1 = gtk.HPaned()
gtklogger.setWidgetName(self.paned1, "Pane1")
self.mainpane.pack1(self.paned1, resize=True)
gtklogger.connect_passive(self.paned1, 'size-allocate')
# paned2 is in left half of paned1
self.paned2 = gtk.HPaned()
gtklogger.setWidgetName(self.paned2, "Pane2")
self.paned1.pack1(self.paned2, resize=True)
gtklogger.connect_passive(self.paned2, 'size-allocate')
# The toolbox is in the left half of paned2 (ie the left frame of 3)
toolboxframe = gtk.Frame()
toolboxframe.set_shadow_type(gtk.SHADOW_IN)
self.paned2.pack1(toolboxframe, resize=True)
gtklogger.connect_passive(toolboxframe, 'size-allocate')
# Box containing the toolbox label and the scroll window for
# the toolbox itself.
toolboxbox1 = gtk.VBox()
toolboxframe.add(toolboxbox1)
hbox = gtk.HBox()
toolboxbox1.pack_start(hbox, expand=0, fill=0, padding=2)
hbox.pack_start(gtk.Label("Toolbox:"), expand=0, fill=0, padding=3)
self.toolboxchooser = chooser.ChooserWidget([],
callback=self.switchToolbox,
name="TBChooser")
hbox.pack_start(self.toolboxchooser.gtk, expand=1, fill=1, padding=3)
# Scroll window for the toolbox itself.
toolboxbox2 = gtk.ScrolledWindow()
gtklogger.logScrollBars(toolboxbox2, 'TBScroll')
toolboxbox2.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
toolboxbox1.pack_start(toolboxbox2, expand=1, fill=1)
# Actually, the tool box goes inside yet another box, so that
# we have a gtk.VBox that we can refer to later.
self.toolboxbody = gtk.VBox()
toolboxbox2.add_with_viewport(self.toolboxbody)
self.toolboxGUIs = [] # GUI wrappers for toolboxes.
self.current_toolbox = None
# The canvas is in the right half of paned2 (ie the middle
# pane of 3).
# TODO: make this a table with compact, view control buttons,
# for now, just a frame with the gtkglext window.
self.canvasBox = gtk.VBox()
self.toolbarFrame = gtk.Frame()
self.toolbarFrame.set_shadow_type(gtk.SHADOW_IN)
self.canvasBox.pack_start(self.toolbarFrame, expand=0, fill=0, padding=0)
self.toolbar = toolbarGUI.ToolBar(self)
self.toolbarFrame.add(self.toolbar.gtk)
self.toolbar.gtk.show()
self.canvasFrame = gtk.Frame()
self.canvasFrame.set_shadow_type(gtk.SHADOW_IN)
gtklogger.setWidgetName(self.canvasFrame, "Canvas")
self.canvasBox.pack_start(self.canvasFrame, expand=1, fill=1, padding=0)
self.paned2.pack2(self.canvasBox, resize=True)
# HACK. Set the position of the toolbox/canvas divider. This
# prevents the toolbox pane from coming up minimized.
self.paned2.set_position(300)
# Bottom part of main pane is a list of layers. The actual
# DisplayLayer objects are stored in self.display.
layerFrame = gtk.Frame(label='Layers')
self.mainpane.pack2(layerFrame, resize=False)
self.layerScroll = gtk.ScrolledWindow()
gtklogger.logScrollBars(self.layerScroll, "LayerScroll")
self.layerScroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
layerFrame.add(self.layerScroll)
self.layerList = gtk.ListStore(gobject.TYPE_PYOBJECT)
self.layerListView = gtk.TreeView(self.layerList)
gtklogger.setWidgetName(self.layerListView, "LayerList")
self.layerListView.set_row_separator_func(self.layerRowSepFunc)
self.layerListView.set_reorderable(True)
self.layerListView.set_fixed_height_mode(False)
self.layerScroll.add(self.layerListView)
gtklogger.adoptGObject(self.layerList, self.layerListView,
access_method=self.layerListView.get_model)
# The row-deleted and row-inserted signals are used to detect
# when the user has reordered rows manually. When the program
# does anything that might cause these signals to be emitted,
# it must first call suppressRowOpSignals.
self.rowOpSignals = [
gtklogger.connect(self.layerList, "row-deleted",
self.listRowDeletedCB),
gtklogger.connect(self.layerList, "row-inserted",
self.listRowInsertedCB)
]
self.destination_path = None
showcell = gtk.CellRendererToggle()
showcol = gtk.TreeViewColumn("Show")
showcol.pack_start(showcell, expand=False)
showcol.set_cell_data_func(showcell, self.renderShowCell)
self.layerListView.append_column(showcol)
gtklogger.adoptGObject(showcell, self.layerListView,
access_function=gtklogger.findCellRenderer,
access_kwargs={'col':0, 'rend':0})
gtklogger.connect(showcell, 'toggled', self.showcellCB)
## cmapcell = gtk.CellRendererToggle()
## cmapcell.set_radio(True)
## cmapcol = gtk.TreeViewColumn("Map")
## cmapcol.pack_start(cmapcell, expand=False)
## cmapcol.set_cell_data_func(cmapcell, self.renderCMapCell)
## self.layerListView.append_column(cmapcol)
## gtklogger.adoptGObject(cmapcell, self.layerListView,
## access_function='findCellRenderer',
## access_kwargs={'col':1, 'rend':0})
## gtklogger.connect(cmapcell, 'toggled', self.cmapcellCB)
layercell = gtk.CellRendererText()
layercol = gtk.TreeViewColumn("What")
layercol.set_resizable(True)
layercol.pack_start(layercell, expand=True)
layercol.set_cell_data_func(layercell, self.renderLayerCell)
self.layerListView.append_column(layercol)
methodcell = gtk.CellRendererText()
methodcol = gtk.TreeViewColumn("How")
methodcol.set_resizable(True)
methodcol.pack_start(methodcell, expand=True)
methodcol.set_cell_data_func(methodcell, self.renderMethodCell)
self.layerListView.append_column(methodcol)
gtklogger.adoptGObject(self.layerListView.get_selection(),
self.layerListView,
access_method=self.layerListView.get_selection)
self.selsignal = gtklogger.connect(self.layerListView.get_selection(),
'changed', self.selectionChangedCB)
gtklogger.connect(self.layerListView, 'row-activated',
self.layerDoubleClickCB)
def __init__(self, parent, mesh=None):
debug.mainthreadTest()
self.parent = parent # Reference to the enclosing BoundaryCondPage.
self.current_mesh = mesh
debug.mainthreadTest()
self.bcliststore = gtk.ListStore(gobject.TYPE_STRING,
gobject.TYPE_PYOBJECT)
self.sortedlist = gtk.TreeModelSort(self.bcliststore)
self.gtk = gtk.TreeView(self.sortedlist)
gtklogger.setWidgetName(self.gtk, "BCList")
# Enable/disable column
enablecell = gtk.CellRendererToggle()
enablecol = gtk.TreeViewColumn("Enable")
enablecol.pack_start(enablecell, expand=False)
enablecol.set_cell_data_func(enablecell, self.renderEnableCell)
self.gtk.append_column(enablecol)
gtklogger.adoptGObject(enablecell,
self.gtk,
access_function=gtklogger.findCellRenderer,
access_kwargs={
'col': 0,
'rend': 0
})
gtklogger.connect(enablecell, 'toggled', self.enableCellCB)
## Click on the column header to sort by Enabled status.
## Currently commented out because clicking on a toggle cell
## when sorting by Enable may trigger an instant re-sort,
## which moves the clicked cell.
# gtklogger.adoptGObject(enablecol, self.gtk,
# access_method=gtk.TreeView.get_column,
# access_args=(0,))
# gtklogger.connect_passive(enablecol, 'clicked')
# enablecol.set_sort_column_id(self.sortByEnableID)
# self.sortedlist.set_sort_func(self.sortByEnableID, self.sortByEnableFn)
# Boundary condition name column
bcnamecell = gtk.CellRendererText()
bcnamecol = gtk.TreeViewColumn('Name')
bcnamecol.pack_start(bcnamecell, expand=False)
bcnamecol.set_attributes(bcnamecell, text=0)
self.gtk.append_column(bcnamecol)
gtklogger.adoptGObject(bcnamecol,
self.gtk,
access_method=gtk.TreeView.get_column,
access_args=(1, ))
gtklogger.connect_passive(bcnamecol, 'clicked')
bcnamecol.set_sort_column_id(self.sortByNameID)
self.sortedlist.set_sort_func(self.sortByNameID, self.sortByNameFn)
# Boundary name column
bdycell = gtk.CellRendererText()
bdycol = gtk.TreeViewColumn('Boundary')
bdycol.pack_start(bdycell, expand=True)
bdycol.set_cell_data_func(bdycell, self.renderBdy)
self.gtk.append_column(bdycol)
gtklogger.adoptGObject(bdycol,
self.gtk,
access_method=gtk.TreeView.get_column,
access_args=(2, ))
gtklogger.connect_passive(bdycol, 'clicked')
bdycol.set_sort_column_id(self.sortByBdyID)
self.sortedlist.set_sort_func(self.sortByBdyID, self.sortByBdyFn)
# Boundary condition column
bccell = gtk.CellRendererText()
bccol = gtk.TreeViewColumn('Condition')
bccol.pack_start(bccell, expand=True)
bccol.set_cell_data_func(bccell, self.renderBC)
self.gtk.append_column(bccol)
selection = self.gtk.get_selection()
gtklogger.adoptGObject(selection,
self.gtk,
access_method=self.gtk.get_selection)
self.signals = (gtklogger.connect(selection, 'changed', self.selectCB),
gtklogger.connect(self.gtk, 'row-activated',
self.doubleClickCB))
# Set initial sorting method
self.lastsortcol = bcnamecol
self.sortedlist.set_sort_column_id(self.sortByNameID,
gtk.SORT_ASCENDING)
def __init__(self):
oofGUI.MainPage.__init__(
self, name="Solver",
ordering=240,
tip="Find solutions for static and time-dependent problems.")
mainbox = gtk.VBox(spacing=2)
self.gtk.add(mainbox)
align = gtk.Alignment(xalign=0.5)
mainbox.pack_start(align, expand=0, fill=0)
centerbox = gtk.HBox(spacing=3)
align.add(centerbox)
self.meshwidget = whowidget.WhoWidget(ooflib.engine.mesh.meshes,
scope=self)
switchboard.requestCallbackMain(self.meshwidget, self.meshCB)
label = gtk.Label("Microstructure=")
label.set_alignment(1.0, 0.5)
centerbox.pack_start(label, expand=0, fill=0)
centerbox.pack_start(self.meshwidget.gtk[0], expand=0, fill=0)
label = gtk.Label("Skeleton=")
label.set_alignment(1.0, 0.5)
centerbox.pack_start(label, expand=0, fill=0)
centerbox.pack_start(self.meshwidget.gtk[1], expand=0, fill=0)
label = gtk.Label("Mesh=")
label.set_alignment(1.0, 0.5)
centerbox.pack_start(label, expand=0, fill=0)
centerbox.pack_start(self.meshwidget.gtk[2], expand=0, fill=0)
mainvpane = gtk.VPaned()
gtklogger.setWidgetName(mainvpane, 'VPane')
mainbox.pack_start(mainvpane, expand=1, fill=1)
gtklogger.connect_passive(mainvpane, 'notify::position')
# Subproblem pane
## TODO: Make it possible to reorder the subproblems by
## drag and drop.
subprobframe = gtk.Frame('Solvers')
gtklogger.setWidgetName(subprobframe, "Subproblems")
subprobframe.set_shadow_type(gtk.SHADOW_IN)
mainvpane.pack1(subprobframe, resize=1, shrink=0)
subpvbox = gtk.VBox() # contains scrolled list and buttons
subpvbox.set_border_width(3)
subprobframe.add(subpvbox)
innerframe = gtk.Frame()
innerframe.set_shadow_type(gtk.SHADOW_IN)
subpvbox.pack_start(innerframe, expand=1, fill=1)
self.subpScroll = gtk.ScrolledWindow()
gtklogger.logScrollBars(self.subpScroll, "SubproblemScroll")
self.subpScroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
innerframe.add(self.subpScroll)
self.subprobList = gtk.ListStore(gobject.TYPE_PYOBJECT)
self.subpListView = gtk.TreeView(self.subprobList)
gtklogger.setWidgetName(self.subpListView, "SubproblemList")
self.subpScroll.add(self.subpListView)
gtklogger.adoptGObject(self.subprobList, self.subpListView,
access_method=self.subpListView.get_model)
# Catch selection changes
gtklogger.adoptGObject(self.subpListView.get_selection(),
self.subpListView,
access_method=self.subpListView.get_selection)
self.subpselsig = gtklogger.connect(self.subpListView.get_selection(),
'changed', self.subpSelectCB)
# Catch double clicks or returns
gtklogger.connect(self.subpListView, 'row-activated',
self.subpActivateRowCB)
# Order number in the first column
ordercell = gtk.CellRendererText()
ordercol = gtk.TreeViewColumn("Order")
ordercol.set_resizable(False)
ordercol.pack_start(ordercell, expand=False)
ordercol.set_cell_data_func(ordercell, self.renderSubproblemOrder)
self.subpListView.append_column(ordercol)
# Checkbox in the second column
solvecell = gtk.CellRendererToggle()
solvecol = gtk.TreeViewColumn("Solve?")
solvecol.pack_start(solvecell, expand=False)
solvecol.set_cell_data_func(solvecell, self.renderSolveCell)
self.subpListView.append_column(solvecol)
gtklogger.adoptGObject(solvecell, self.subpListView,
access_function=gtklogger.findCellRenderer,
access_kwargs={'col':1, 'rend':0})
gtklogger.connect(solvecell, 'toggled', self.solvecellCB)
# Subproblem name in the third column
namecell = gtk.CellRendererText()
namecol = gtk.TreeViewColumn("Subproblem")
namecol.set_resizable(True)
namecol.pack_start(namecell, expand=True)
namecol.set_cell_data_func(namecell, self.renderSubproblemName)
self.subpListView.append_column(namecol)
# Solver in the fourth column
solvercell = gtk.CellRendererText()
solvercol = gtk.TreeViewColumn("Solver")
solvercol.set_resizable(True)
solvercol.pack_start(solvercell, expand=True)
solvercol.set_cell_data_func(solvercell, self.renderSubproblemSolver)
self.subpListView.append_column(solvercol)
# Buttons at the bottom of the subproblem pane
subpbbox = gtk.HBox(homogeneous=True)
subpvbox.pack_start(subpbbox, expand=0, fill=0)
# Set Solver
self.setSolverButton = gtkutils.StockButton(gtk.STOCK_ADD, "Set...")
gtklogger.setWidgetName(self.setSolverButton, "Set")
gtklogger.connect(self.setSolverButton, 'clicked', self.setSolverCB)
subpbbox.pack_start(self.setSolverButton, expand=0, fill=1)
tooltips.set_tooltip_text(self.setSolverButton,
"Assign a solver to the selected subproblem.")
# Copy Solver
self.copySolverButton = gtkutils.StockButton(gtk.STOCK_COPY, "Copy...")
gtklogger.setWidgetName(self.copySolverButton, "Copy")
gtklogger.connect(self.copySolverButton, 'clicked', self.copySolverCB)
subpbbox.pack_start(self.copySolverButton, expand=0, fill=1)
tooltips.set_tooltip_text(self.copySolverButton,"Copy the selected solver to another subproblem, possibly in another mesh.")
# Copy All Solvers
self.copyAllSolversButton = gtkutils.StockButton(gtk.STOCK_COPY,
"Copy All...")
gtklogger.setWidgetName(self.copyAllSolversButton, "CopyAll")
gtklogger.connect(self.copyAllSolversButton, 'clicked',
self.copyAllSolversCB)
subpbbox.pack_start(self.copyAllSolversButton, expand=0, fill=1)
tooltips.set_tooltip_text(self.copyAllSolversButton,"Copy all solvers to identically named subproblems in another mesh.")
# Remove Solver
self.removeSolverButton = gtkutils.StockButton(gtk.STOCK_REMOVE,
"Remove")
gtklogger.setWidgetName(self.removeSolverButton, "Remove")
gtklogger.connect(self.removeSolverButton, 'clicked',
self.removeSolverCB)
subpbbox.pack_start(self.removeSolverButton, expand=0, fill=1)
tooltips.set_tooltip_text(self.removeSolverButton,
"Delete the solver from the selected subproblem.")
# Remove all solvers
self.removeAllSolversButton = gtkutils.StockButton(gtk.STOCK_CLEAR,
"Remove All")
gtklogger.setWidgetName(self.removeAllSolversButton, "RemoveAll")
gtklogger.connect(self.removeAllSolversButton, 'clicked',
self.removeAllSolversCB)
subpbbox.pack_start(self.removeAllSolversButton, expand=0, fill=1)
tooltips.set_tooltip_text(self.removeAllSolversButton,
"Remove the solver from all subproblems.")
# Second row of buttons at the bottom of the subproblem pane
subpbbox = gtk.HBox(homogeneous=True)
subpvbox.pack_start(subpbbox, expand=0, fill=0)
# Solve this subproblem first
self.firstButton = gtkutils.StockButton(gtk.STOCK_GOTO_FIRST, "First",
align=0.0)
gtklogger.setWidgetName(self.firstButton, "First")
gtklogger.connect(self.firstButton, 'clicked', self.firstButtonCB)
subpbbox.pack_start(self.firstButton, expand=0, fill=1)
tooltips.set_tooltip_text(self.firstButton,"Solve the selected subproblem first when iterating over subproblems.")
# Solve this subproblem earlier
self.earlierButton = gtkutils.StockButton(gtk.STOCK_GO_BACK, "Earlier",
align=0.0)
gtklogger.setWidgetName(self.earlierButton, "Earlier")
gtklogger.connect(self.earlierButton, 'clicked', self.earlierButtonCB)
subpbbox.pack_start(self.earlierButton, expand=0, fill=1)
tooltips.set_tooltip_text(self.earlierButton,"Solve the selected subproblem before the one above it in the list when iterating over subproblems.")
# Solve this subproblem later
self.laterButton = gtkutils.StockButton(gtk.STOCK_GO_FORWARD, "Later",
reverse=True, align=1.0)
gtklogger.setWidgetName(self.laterButton, "Later")
gtklogger.connect(self.laterButton, 'clicked', self.laterButtonCB)
subpbbox.pack_start(self.laterButton, expand=0, fill=1)
tooltips.set_tooltip_text(self.laterButton,"Solve the selected subproblem after the next one in the list when iterating over subproblems.")
# Solve this subproblem last
self.lastButton = gtkutils.StockButton(gtk.STOCK_GOTO_LAST, "Last",
reverse=True, align=1.0)
gtklogger.setWidgetName(self.lastButton, "Last")
gtklogger.connect(self.lastButton, 'clicked', self.lastButtonCB)
subpbbox.pack_start(self.lastButton, expand=0, fill=1)
tooltips.set_tooltip_text(self.lastButton,"Solve the selected subproblem last when iterating over subproblems.")
# Field Initializers
initframe = gtk.Frame('Initialization')
gtklogger.setWidgetName(initframe, "FieldInit")
initframe.set_shadow_type(gtk.SHADOW_IN)
mainvpane.pack2(initframe, resize=1, shrink=0)
ivbox = gtk.VBox()
ivbox.set_border_width(3)
initframe.add(ivbox)
self.initscroll = gtk.ScrolledWindow()
gtklogger.logScrollBars(self.initscroll, "Scroll")
self.initscroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.initscroll.set_shadow_type(gtk.SHADOW_IN)
ivbox.pack_start(self.initscroll, expand=1, fill=1)
# The ListStore just contains the defined Fields. The
# TreeView displays their names and initializers.
self.initlist = gtk.ListStore(gobject.TYPE_PYOBJECT)
self.initview = gtk.TreeView(self.initlist)
gtklogger.setWidgetName(self.initview, 'Initializers')
self.initscroll.add(self.initview)
self.initview.set_headers_clickable(False)
fieldnamecell = gtk.CellRendererText()
fieldnamecol = gtk.TreeViewColumn('Field or BC')
self.initview.append_column(fieldnamecol)
fieldnamecol.pack_start(fieldnamecell, expand=False)
fieldnamecol.set_cell_data_func(fieldnamecell, self.renderFieldName)
fieldinitcell = gtk.CellRendererText()
fieldinitcol = gtk.TreeViewColumn('Initializer')
self.initview.append_column(fieldinitcol)
fieldinitcol.pack_start(fieldinitcell, expand=True)
fieldinitcol.set_cell_data_func(fieldinitcell, self.renderFieldInit)
selection = self.initview.get_selection()
gtklogger.adoptGObject(selection, self.initview,
access_method=self.initview.get_selection)
self.initselsignal = gtklogger.connect(selection, 'changed',
self.initSelectCB)
gtklogger.connect(self.initview, 'row-activated',
self.initActivateRowCB)
bbox = gtk.HBox(homogeneous=True)
ivbox.pack_start(bbox, expand=0, fill=0)
# Set button
self.fieldinitbutton=gtkutils.StockButton(gtk.STOCK_ADD, 'Set...')
gtklogger.setWidgetName(self.fieldinitbutton, "Set")
gtklogger.connect(self.fieldinitbutton, 'clicked',
self.fieldinitbuttonCB)
tooltips.set_tooltip_text(self.fieldinitbutton,'Initialized the selected field.')
bbox.pack_start(self.fieldinitbutton, expand=0, fill=1)
# Copy button
self.copyinitbutton = gtkutils.StockButton(gtk.STOCK_COPY, "Copy...")
gtklogger.setWidgetName(self.copyinitbutton, 'CopyInit')
gtklogger.connect(self.copyinitbutton, 'clicked', self.copyinitCB)
bbox.pack_start(self.copyinitbutton, expand=0, fill=1)
tooltips.set_tooltip_text(self.copyinitbutton,
"Copy field initializers from the current mesh to another mesh.")
# Clear Initializer button
self.clearinitbutton = gtkutils.StockButton(gtk.STOCK_REMOVE, "Clear")
gtklogger.setWidgetName(self.clearinitbutton, "Clear")
gtklogger.connect(self.clearinitbutton, 'clicked', self.clearinitCB)
bbox.pack_start(self.clearinitbutton, expand=0, fill=1)
tooltips.set_tooltip_text(self.clearinitbutton,
"Remove the selected field initializer from the current mesh.")
# Clear All Initializers button
self.clearallinitsbutton = gtkutils.StockButton(gtk.STOCK_CLEAR,
"Clear All")
gtklogger.setWidgetName(self.clearallinitsbutton, 'ClearAll')
gtklogger.connect(self.clearallinitsbutton, 'clicked',
self.clearallinitsCB)
bbox.pack_start(self.clearallinitsbutton, expand=0, fill=1)
tooltips.set_tooltip_text(self.clearallinitsbutton,
"Remove the field initializers from the current mesh.")
# Second row of buttons in the Field Initialization pane
bbox = gtk.HBox(homogeneous=True)
ivbox.pack_start(bbox, expand=0, fill=1)
# Apply button
self.applyinitbutton = gtkutils.StockButton(gtk.STOCK_APPLY, "Apply")
gtklogger.setWidgetName(self.applyinitbutton, "Apply")
gtklogger.connect(self.applyinitbutton, 'clicked', self.applyinitCB)
tooltips.set_tooltip_text(self.applyinitbutton,
"Apply initializers to all fields at the current time.")
bbox.pack_start(self.applyinitbutton, expand=0, fill=1)
# Apply At button
self.applyinitattimebutton = gtkutils.StockButton(gtk.STOCK_APPLY,
"Apply at time...")
gtklogger.setWidgetName(self.applyinitattimebutton, "ApplyAt")
gtklogger.connect(self.applyinitattimebutton, 'clicked',
self.applyinitatCB)
tooltips.set_tooltip_text(self.applyinitattimebutton,
"Reset the current time and apply all field initializers.")
bbox.pack_start(self.applyinitattimebutton, expand=0, fill=1)
# Table containing status, time entries and Solve button
table = gtk.Table(rows=2, columns=4)
mainbox.pack_start(table, expand=0, fill=1)
# The start time isn't set directly by the user, except by
# applying field initializers at a given time. It's displayed
# in a desensitized gtk.Entry.
label = gtk.Label('current time=')
label.set_alignment(1.0, 0.5)
table.attach(label, 0,1, 0,1, xpadding=3, xoptions=~gtk.EXPAND)
self.currentTimeEntry = gtk.Entry()
self.currentTimeEntry.set_sensitive(False) # never sensitive
table.attach(self.currentTimeEntry, 1,2, 0,1, xpadding=3)
# End time is set by the user.
label = gtk.Label('end time=')
label.set_alignment(1.0, 0.5)
table.attach(label, 0,1, 1,2, xpadding=3, xoptions=~gtk.EXPAND)
self.endtimeEntry = gtk.Entry()
gtklogger.setWidgetName(self.endtimeEntry, 'end')
gtklogger.connect(self.endtimeEntry, 'changed', self.timeChangeCB)
table.attach(self.endtimeEntry, 1,2, 1,2, xpadding=3)
# # Step size is set by the user and changed by the program.
# label = gtk.Label('step size=')
# label.set_alignment(1.0, 0.5)
# table.attach(label, 0,1, 2,3, xpadding=3, xoptions=~gtk.EXPAND)
# self.stepsizeEntry = gtk.Entry()
# gtklogger.setWidgetName(self.stepsizeEntry, 'stepsize')
# self.stepsizeSig = gtklogger.connect(self.stepsizeEntry, 'changed',
# self.timeChangeCB)
# table.attach(self.stepsizeEntry, 1,2, 2,3, xpadding=3)
statusFrame = gtk.Frame("Status")
statusFrame.set_shadow_type(gtk.SHADOW_IN)
vbox = gtk.VBox()
statusFrame.add(vbox)
self.statusLabel = gtk.Label()
self.statusLabel.set_alignment(0.5, 0.5)
table.attach(statusFrame, 2,3, 0,3, xpadding=3)
vbox.pack_start(self.statusLabel, expand=0, fill=0)
align = gtk.Alignment(xalign=0.5)
vbox.pack_start(align, expand=0, fill=0, padding=3)
self.statusDetailButton = gtk.Button("Details...")
gtklogger.setWidgetName(self.statusDetailButton, 'status')
gtklogger.connect(self.statusDetailButton, 'clicked', self.statusCB)
align.add(self.statusDetailButton)
solveFrame0 = gtk.Frame()
solveFrame0.set_shadow_type(gtk.SHADOW_OUT)
solveFrame1 = gtk.Frame()
solveFrame1.set_shadow_type(gtk.SHADOW_IN)
solveFrame0.add(solveFrame1)
table.attach(solveFrame0, 3,4, 0,3, xpadding=3,
xoptions=~gtk.EXPAND)
self.solveButton = gtkutils.StockButton(gtk.STOCK_EXECUTE,
'<b>Solve</b>', markup=True)
self.solveButton.set_border_width(4)
gtklogger.setWidgetName(self.solveButton, 'solve')
gtklogger.connect(self.solveButton, 'clicked', self.solveCB)
solveFrame1.add(self.solveButton)
switchboard.requestCallbackMain("field defined", self.defineFldCB)
switchboard.requestCallbackMain("field initializer set", self.initFldCB)
switchboard.requestCallbackMain("subproblem changed",
self.subproblemsChangedCB)
switchboard.requestCallbackMain("mesh changed",
self.subproblemsChangedCB)
switchboard.requestCallbackMain("subproblem solvability changed",
self.subpSolverChangedCB)
switchboard.requestCallbackMain("subproblem solver changed",
self.subpSolverChangedCB)
switchboard.requestCallbackMain("subproblem solvers changed",
self.subpSolversChangedCB),
switchboard.requestCallbackMain("subproblems reordered",
self.subproblemsChangedCB),
switchboard.requestCallbackMain(("new who", "SubProblem"),
self.subproblemsChangedCB)
switchboard.requestCallbackMain(("rename who", "SubProblem"),
self.subproblemsChangedCB)
switchboard.requestCallbackMain(("remove who", "SubProblem"),
self.subproblemsChangedCB)
switchboard.requestCallbackMain("time changed",
self.meshTimeChangedCB)
switchboard.requestCallbackMain("mesh solved", self.meshSolvedCB)
switchboard.requestCallbackMain("mesh status changed",
self.statusChangedCB)
switchboard.requestCallbackMain("made reservation",
self.reservationCB)
switchboard.requestCallbackMain("cancelled reservation",
self.reservationCB)
def preinitialize(self, name, gfxmanager, clone):
debug.mainthreadTest()
self.gtk = None
self.closed = None # State data used at window-close time.
self.name = name
self.oofcanvas = None
self.realized = 0
self.zoomed = 0
self.settings = ghostgfxwindow.GfxSettings()
self.mouseHandler = mousehandler.nullHandler # doesn't do anything
self.rubberband = rubberband.NoRubberBand()
#self.contourmapdata = None
# Build all the GTK objects for the interior of the box. These
# actually get added to the window itself after the SubWindow
# __init__ call. They need to be created first so the
# GhostGfxWindow can operate on them, and then create the menus
# which are handed off to the SubWindow.
self.mainpane = gtk.VPaned()
gtklogger.setWidgetName(self.mainpane, 'Pane0')
# Panes dividing upper pane horizontally into 3 parts.
# paned1's left half contains paned2.
self.paned1 = gtk.HPaned()
gtklogger.setWidgetName(self.paned1, "Pane1")
self.mainpane.pack1(self.paned1, resize=True)
gtklogger.connect_passive(self.paned1, 'size-allocate')
# paned2 is in left half of paned1
self.paned2 = gtk.HPaned()
gtklogger.setWidgetName(self.paned2, "Pane2")
self.paned1.pack1(self.paned2, resize=True)
gtklogger.connect_passive(self.paned2, 'size-allocate')
# The toolbox is in the left half of paned2 (ie the left frame of 3)
toolboxframe = gtk.Frame()
toolboxframe.set_shadow_type(gtk.SHADOW_IN)
self.paned2.pack1(toolboxframe, resize=True)
gtklogger.connect_passive(toolboxframe, 'size-allocate')
# Box containing the toolbox label and the scroll window for
# the toolbox itself.
toolboxbox1 = gtk.VBox()
toolboxframe.add(toolboxbox1)
hbox = gtk.HBox()
toolboxbox1.pack_start(hbox, expand=0, fill=0, padding=2)
hbox.pack_start(gtk.Label("Toolbox:"), expand=0, fill=0, padding=3)
self.toolboxchooser = chooser.ChooserWidget(
[], callback=self.switchToolbox, name="TBChooser")
hbox.pack_start(self.toolboxchooser.gtk, expand=1, fill=1, padding=3)
# Scroll window for the toolbox itself.
toolboxbox2 = gtk.ScrolledWindow()
gtklogger.logScrollBars(toolboxbox2, 'TBScroll')
toolboxbox2.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
toolboxbox1.pack_start(toolboxbox2, expand=1, fill=1)
# Actually, the tool box goes inside yet another box, so that
# we have a gtk.VBox that we can refer to later.
self.toolboxbody = gtk.VBox()
toolboxbox2.add_with_viewport(self.toolboxbody)
self.toolboxGUIs = [] # GUI wrappers for toolboxes.
self.current_toolbox = None
# The canvas is in the right half of paned2 (ie the middle
# pane of 3).
# TODO: make this a table with compact, view control buttons,
# for now, just a frame with the gtkglext window.
self.canvasBox = gtk.VBox()
self.toolbarFrame = gtk.Frame()
self.toolbarFrame.set_shadow_type(gtk.SHADOW_IN)
self.canvasBox.pack_start(self.toolbarFrame,
expand=0,
fill=0,
padding=0)
self.toolbar = toolbarGUI.ToolBar(self)
self.toolbarFrame.add(self.toolbar.gtk)
self.toolbar.gtk.show()
self.canvasFrame = gtk.Frame()
self.canvasFrame.set_shadow_type(gtk.SHADOW_IN)
gtklogger.setWidgetName(self.canvasFrame, "Canvas")
self.canvasBox.pack_start(self.canvasFrame,
expand=1,
fill=1,
padding=0)
self.paned2.pack2(self.canvasBox, resize=True)
# HACK. Set the position of the toolbox/canvas divider. This
# prevents the toolbox pane from coming up minimized.
self.paned2.set_position(300)
# Bottom part of main pane is a list of layers. The actual
# DisplayLayer objects are stored in self.display.
layerFrame = gtk.Frame(label='Layers')
self.mainpane.pack2(layerFrame, resize=False)
self.layerScroll = gtk.ScrolledWindow()
gtklogger.logScrollBars(self.layerScroll, "LayerScroll")
self.layerScroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
layerFrame.add(self.layerScroll)
self.layerList = gtk.ListStore(gobject.TYPE_PYOBJECT)
self.layerListView = gtk.TreeView(self.layerList)
gtklogger.setWidgetName(self.layerListView, "LayerList")
self.layerListView.set_row_separator_func(self.layerRowSepFunc)
self.layerListView.set_reorderable(True)
self.layerListView.set_fixed_height_mode(False)
self.layerScroll.add(self.layerListView)
gtklogger.adoptGObject(self.layerList,
self.layerListView,
access_method=self.layerListView.get_model)
# The row-deleted and row-inserted signals are used to detect
# when the user has reordered rows manually. When the program
# does anything that might cause these signals to be emitted,
# it must first call suppressRowOpSignals.
self.rowOpSignals = [
gtklogger.connect(self.layerList, "row-deleted",
self.listRowDeletedCB),
gtklogger.connect(self.layerList, "row-inserted",
self.listRowInsertedCB)
]
self.destination_path = None
showcell = gtk.CellRendererToggle()
showcol = gtk.TreeViewColumn("Show")
showcol.pack_start(showcell, expand=False)
showcol.set_cell_data_func(showcell, self.renderShowCell)
self.layerListView.append_column(showcol)
gtklogger.adoptGObject(showcell,
self.layerListView,
access_function=gtklogger.findCellRenderer,
access_kwargs={
'col': 0,
'rend': 0
})
gtklogger.connect(showcell, 'toggled', self.showcellCB)
## cmapcell = gtk.CellRendererToggle()
## cmapcell.set_radio(True)
## cmapcol = gtk.TreeViewColumn("Map")
## cmapcol.pack_start(cmapcell, expand=False)
## cmapcol.set_cell_data_func(cmapcell, self.renderCMapCell)
## self.layerListView.append_column(cmapcol)
## gtklogger.adoptGObject(cmapcell, self.layerListView,
## access_function='findCellRenderer',
## access_kwargs={'col':1, 'rend':0})
## gtklogger.connect(cmapcell, 'toggled', self.cmapcellCB)
layercell = gtk.CellRendererText()
layercol = gtk.TreeViewColumn("What")
layercol.set_resizable(True)
layercol.pack_start(layercell, expand=True)
layercol.set_cell_data_func(layercell, self.renderLayerCell)
self.layerListView.append_column(layercol)
methodcell = gtk.CellRendererText()
methodcol = gtk.TreeViewColumn("How")
methodcol.set_resizable(True)
methodcol.pack_start(methodcell, expand=True)
methodcol.set_cell_data_func(methodcell, self.renderMethodCell)
self.layerListView.append_column(methodcol)
gtklogger.adoptGObject(self.layerListView.get_selection(),
self.layerListView,
access_method=self.layerListView.get_selection)
self.selsignal = gtklogger.connect(self.layerListView.get_selection(),
'changed', self.selectionChangedCB)
gtklogger.connect(self.layerListView, 'row-activated',
self.layerDoubleClickCB)
def preinitialize(self, name, gfxmanager, clone):
# preinitialize is called by GfxWindowBase.__init__ on the
# main thread *before* GhostGfxWindow.__init__ is called.
debug.mainthreadTest()
self.gtk = None
self.closed = None # State data used at window-close time.
self.name = name
self.oofcanvas = None
self.realized = 0
self.zoomed = 0
self.settings = ghostgfxwindow.GfxSettings()
self.mouseHandler = mousehandler.nullHandler # doesn't do anything
# Build all the GTK objects for the interior of the box. These
# actually get added to the window itself after the SubWindow
# __init__ call. They need to be created first so the
# GhostGfxWindow can operate on them, and then create the menus
# which are handed off to the SubWindow.
self.mainpane = gtk.VPaned()
gtklogger.setWidgetName(self.mainpane, 'Pane0')
# Pane dividing upper pane horizontally into 2 parts.
self.paned1 = gtk.HPaned()
gtklogger.setWidgetName(self.paned1, "Pane2")
# "resize=True" here means that when the window is resized
# vertically, the canvas and toolboxes will resize, but the
# layer list won't. It also makes the layer list compact when
# the window is first opened. This is what we want. However,
# on some systems (those using Unity WM, maybe) the layer list
# is completely collapsed in the initial window, which is
# unfriendly but not fatal. Ubuntu 17.10 doesn't have the
# problem so it's not going to be fixed.
self.mainpane.pack1(self.paned1, resize=True)
gtklogger.connect_passive(self.paned1, 'size-allocate')
# The toolbox is in the left half of paned1 (ie the left frame of 3)
toolboxframe = gtk.Frame()
toolboxframe.set_shadow_type(gtk.SHADOW_IN)
self.paned1.pack1(toolboxframe, resize=True)
## TODO OPT: Does the frame size really need to be logged? It
## should just follow from the pane size.
gtklogger.setWidgetName(toolboxframe, "ToolboxFrame")
gtklogger.connect_passive(toolboxframe, 'size-allocate')
# Box containing the toolbox label and the scroll window for
# the toolbox itself.
toolboxbox1 = gtk.VBox()
toolboxframe.add(toolboxbox1)
hbox = gtk.HBox()
toolboxbox1.pack_start(hbox, expand=0, fill=0, padding=2)
hbox.pack_start(gtk.Label("Toolbox:"), expand=0, fill=0, padding=3)
self.toolboxchooser = chooser.ChooserWidget(
[], callback=self.switchToolbox, name="TBChooser")
hbox.pack_start(self.toolboxchooser.gtk, expand=1, fill=1, padding=3)
# Scroll window for the toolbox itself.
toolboxbox2 = gtk.ScrolledWindow()
gtklogger.logScrollBars(toolboxbox2, 'TBScroll')
toolboxbox2.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
toolboxbox1.pack_start(toolboxbox2, expand=1, fill=1)
# Actually, the tool box goes inside yet another box, so that
# we have a gtk.VBox that we can refer to later.
self.toolboxbody = gtk.VBox()
toolboxbox2.add_with_viewport(self.toolboxbody)
self.toolboxGUIs = [] # GUI wrappers for toolboxes.
self.current_toolbox = None
# The canvas is in the right half of paned1. The toolbar goes
# on top of the canvas.
self.canvasBox = gtk.VBox()
toolbarFrame = gtk.Frame()
toolbarFrame.set_shadow_type(gtk.SHADOW_IN)
self.canvasBox.pack_start(toolbarFrame, expand=0, fill=0, padding=0)
self.toolbarBox = gtk.VBox()
toolbarFrame.add(self.toolbarBox)
self.canvasFrame = gtk.Frame()
self.canvasFrame.set_shadow_type(gtk.SHADOW_IN)
gtklogger.setWidgetName(self.canvasFrame, "Canvas")
self.canvasBox.pack_start(self.canvasFrame,
expand=1,
fill=1,
padding=0)
self.paned1.pack2(self.canvasBox, resize=True)
# Bottom part of main pane is a list of layers. The actual
# DisplayLayer objects are stored in self.display.
layerFrame = gtk.Frame(label='Layers')
self.mainpane.pack2(layerFrame, resize=False)
self.layerScroll = gtk.ScrolledWindow()
gtklogger.logScrollBars(self.layerScroll, "LayerScroll")
self.layerScroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
layerFrame.add(self.layerScroll)
self.layerList = gtk.ListStore(gobject.TYPE_PYOBJECT)
self.layerListView = gtk.TreeView(self.layerList)
gtklogger.setWidgetName(self.layerListView, "LayerList")
self.layerListView.set_row_separator_func(self.layerRowSepFunc)
self.layerListView.set_reorderable(True)
self.layerListView.set_fixed_height_mode(False)
self.layerScroll.add(self.layerListView)
gtklogger.adoptGObject(self.layerList,
self.layerListView,
access_method=self.layerListView.get_model)
# Handle right-clicks on the layer list. They pop up the
# Layer menu.
gtklogger.connect(self.layerListView, 'button-press-event',
self.layerListButtonCB)
# The row-deleted and row-inserted signals are used to detect
# when the user has reordered rows manually. When the program
# does anything that might cause these signals to be emitted,
# it must first call suppressRowOpSignals.
self.rowOpSignals = [
gtklogger.connect(self.layerList, "row-deleted",
self.listRowDeletedCB),
gtklogger.connect(self.layerList, "row-inserted",
self.listRowInsertedCB)
]
self.destination_path = None
showcell = gtk.CellRendererToggle()
showcol = gtk.TreeViewColumn("Show")
showcol.pack_start(showcell, expand=False)
showcol.set_cell_data_func(showcell, self.renderShowCell)
self.layerListView.append_column(showcol)
gtklogger.adoptGObject(showcell,
self.layerListView,
access_function=gtklogger.findCellRenderer,
access_kwargs={
'col': 0,
'rend': 0
})
gtklogger.connect(showcell, 'toggled', self.showcellCB)
## cmapcell = gtk.CellRendererToggle()
## cmapcell.set_radio(True)
## cmapcol = gtk.TreeViewColumn("Map")
## cmapcol.pack_start(cmapcell, expand=False)
## cmapcol.set_cell_data_func(cmapcell, self.renderCMapCell)
## self.layerListView.append_column(cmapcol)
## gtklogger.adoptGObject(cmapcell, self.layerListView,
## access_function='findCellRenderer',
## access_kwargs={'col':1, 'rend':0})
## gtklogger.connect(cmapcell, 'toggled', self.cmapcellCB)
layercell = gtk.CellRendererText()
layercol = gtk.TreeViewColumn("What")
layercol.set_resizable(True)
layercol.pack_start(layercell, expand=True)
layercol.set_cell_data_func(layercell, self.renderLayerCell)
self.layerListView.append_column(layercol)
methodcell = gtk.CellRendererText()
methodcol = gtk.TreeViewColumn("How")
methodcol.set_resizable(True)
methodcol.pack_start(methodcell, expand=True)
methodcol.set_cell_data_func(methodcell, self.renderMethodCell)
self.layerListView.append_column(methodcol)
gtklogger.adoptGObject(self.layerListView.get_selection(),
self.layerListView,
access_method=self.layerListView.get_selection)
self.selsignal = gtklogger.connect(self.layerListView.get_selection(),
'changed', self.selectionChangedCB)
gtklogger.connect(self.layerListView, 'row-activated',
self.layerDoubleClickCB)
def __init__(self, parent, mesh=None):
debug.mainthreadTest()
self.parent = parent # Reference to the enclosing BoundaryCondPage.
self.current_mesh = mesh
debug.mainthreadTest()
self.bcliststore = gtk.ListStore(gobject.TYPE_STRING,
gobject.TYPE_PYOBJECT)
self.sortedlist = gtk.TreeModelSort(self.bcliststore)
self.gtk = gtk.TreeView(self.sortedlist)
gtklogger.setWidgetName(self.gtk, "BCList")
# Enable/disable column
enablecell = gtk.CellRendererToggle()
enablecol = gtk.TreeViewColumn("Enable")
enablecol.pack_start(enablecell, expand=False)
enablecol.set_cell_data_func(enablecell, self.renderEnableCell)
self.gtk.append_column(enablecol)
gtklogger.adoptGObject(enablecell, self.gtk,
access_function=gtklogger.findCellRenderer,
access_kwargs={'col':0, 'rend':0})
gtklogger.connect(enablecell, 'toggled', self.enableCellCB)
## Click on the column header to sort by Enabled status.
## Currently commented out because clicking on a toggle cell
## when sorting by Enable may trigger an instant re-sort,
## which moves the clicked cell.
# gtklogger.adoptGObject(enablecol, self.gtk,
# access_method=gtk.TreeView.get_column,
# access_args=(0,))
# gtklogger.connect_passive(enablecol, 'clicked')
# enablecol.set_sort_column_id(self.sortByEnableID)
# self.sortedlist.set_sort_func(self.sortByEnableID, self.sortByEnableFn)
# Boundary condition name column
bcnamecell = gtk.CellRendererText()
bcnamecol = gtk.TreeViewColumn('Name')
bcnamecol.pack_start(bcnamecell, expand=False)
bcnamecol.set_attributes(bcnamecell, text=0)
self.gtk.append_column(bcnamecol)
gtklogger.adoptGObject(bcnamecol, self.gtk,
access_method=gtk.TreeView.get_column,
access_args=(1,))
gtklogger.connect_passive(bcnamecol, 'clicked')
bcnamecol.set_sort_column_id(self.sortByNameID)
self.sortedlist.set_sort_func(self.sortByNameID, self.sortByNameFn)
# Boundary name column
bdycell = gtk.CellRendererText()
bdycol = gtk.TreeViewColumn('Boundary')
bdycol.pack_start(bdycell, expand=True)
bdycol.set_cell_data_func(bdycell, self.renderBdy)
self.gtk.append_column(bdycol)
gtklogger.adoptGObject(bdycol, self.gtk,
access_method=gtk.TreeView.get_column,
access_args=(2,))
gtklogger.connect_passive(bdycol, 'clicked')
bdycol.set_sort_column_id(self.sortByBdyID)
self.sortedlist.set_sort_func(self.sortByBdyID, self.sortByBdyFn)
# Boundary condition column
bccell = gtk.CellRendererText()
bccol = gtk.TreeViewColumn('Condition')
bccol.pack_start(bccell, expand=True)
bccol.set_cell_data_func(bccell, self.renderBC)
self.gtk.append_column(bccol)
selection = self.gtk.get_selection()
gtklogger.adoptGObject(selection, self.gtk,
access_method=self.gtk.get_selection)
self.signals = (
gtklogger.connect(selection, 'changed', self.selectCB),
gtklogger.connect(self.gtk, 'row-activated', self.doubleClickCB)
)
# Set initial sorting method
self.lastsortcol = bcnamecol
self.sortedlist.set_sort_column_id(self.sortByNameID,
gtk.SORT_ASCENDING)
def __init__(self):
oofGUI.MainPage.__init__(
self,
name="Scheduled Output",
ordering=235,
tip="Set output quantities to be computed during time evolution.")
mainbox = gtk.VBox(spacing=2)
self.gtk.add(mainbox)
align = gtk.Alignment(xalign=0.5)
mainbox.pack_start(align, expand=0, fill=0)
centerbox = gtk.HBox(spacing=3)
align.add(centerbox)
self.meshwidget = whowidget.WhoWidget(ooflib.engine.mesh.meshes,
scope=self)
switchboard.requestCallbackMain(self.meshwidget, self.meshCB)
label = gtk.Label("Microstructure=")
label.set_alignment(1.0, 0.5)
centerbox.pack_start(label, expand=0, fill=0)
centerbox.pack_start(self.meshwidget.gtk[0], expand=0, fill=0)
label = gtk.Label("Skeleton=")
label.set_alignment(1.0, 0.5)
centerbox.pack_start(label, expand=0, fill=0)
centerbox.pack_start(self.meshwidget.gtk[1], expand=0, fill=0)
label = gtk.Label("Mesh=")
label.set_alignment(1.0, 0.5)
centerbox.pack_start(label, expand=0, fill=0)
centerbox.pack_start(self.meshwidget.gtk[2], expand=0, fill=0)
align = gtk.Alignment(xalign=0.5)
mainbox.pack_start(align, expand=0, fill=0, padding=3)
align.add(
gtk.Label(
"Skip this page if you're only solving static problems."))
# The four columns (enable, output, schedule, and destination)
# are each displayed in their own gtk.TreeView, each of which
# is in a pane of a gtk.HPaned. It would have been better to
# put each column in a different gtk.TreeViewColumn in the
# same gtk.TreeView, but that would have made it hard to put
# buttons at the bottom of each column.
hpane0 = gtk.HPaned()
gtklogger.setWidgetName(hpane0, 'HPane0')
gtklogger.connect_passive(hpane0, 'notify::position')
mainbox.pack_start(hpane0, expand=1, fill=1)
hpaneL = gtk.HPaned()
gtklogger.setWidgetName(hpaneL, 'HPaneL')
gtklogger.connect_passive(hpaneL, 'notify::position')
hpane0.pack1(hpaneL, resize=True, shrink=False)
hpaneR = gtk.HPaned()
gtklogger.setWidgetName(hpaneR, 'HPane2')
gtklogger.connect_passive(hpaneR, 'notify::position')
hpane0.pack2(hpaneR, resize=True, shrink=False)
self.outputList = gtk.ListStore(gobject.TYPE_PYOBJECT)
# The "Enable" column has a check box for each output
self.enableFrame = gtk.Frame()
self.enableFrame.set_shadow_type(gtk.SHADOW_IN)
hpaneL.pack1(self.enableFrame, resize=False, shrink=False)
vbox = gtk.VBox()
self.enableFrame.add(vbox)
self.enableView = gtk.TreeView(self.outputList)
gtklogger.setWidgetName(self.enableView, "enable")
vbox.pack_start(self.enableView, expand=True, fill=True)
self.enablecell = gtk.CellRendererToggle()
enablecol = gtk.TreeViewColumn("")
enablecol.set_resizable(False)
enablecol.pack_start(self.enablecell, expand=False)
enablecol.set_cell_data_func(self.enablecell, self.renderEnableCell)
self.enableView.append_column(enablecol)
gtklogger.adoptGObject(self.enablecell,
self.enableView,
access_function=gtklogger.findCellRenderer,
access_kwargs={
'col': 0,
'rend': 0
})
gtklogger.connect(self.enablecell, 'toggled', self.enableCellCB)
# Extra space at the bottom of the column. The other columns
# have button boxes at the bottom, so this one needs a strut
# to keep its rows aligned with the others.
self.enableStrut = gtk.VBox()
vbox.pack_start(self.enableStrut, expand=False, fill=False)
# The "Output" pane lists the name of each output
self.outputFrame = gtk.Frame()
self.outputFrame.set_shadow_type(gtk.SHADOW_IN)
gtklogger.setWidgetName(self.outputFrame, "Output")
hpaneL.pack2(self.outputFrame, resize=True, shrink=False)
outputVBox = gtk.VBox()
self.outputFrame.add(outputVBox)
self.outputView = gtk.TreeView(self.outputList)
gtklogger.setWidgetName(self.outputView, "list")
outputVBox.pack_start(self.outputView, expand=True, fill=True)
self.outputHScroll = gtk.HScrollbar()
outputVBox.pack_start(self.outputHScroll, expand=False, fill=False)
self.outputView.set_hadjustment(self.outputHScroll.get_adjustment())
self.outputcell = gtk.CellRendererText()
outputcol = gtk.TreeViewColumn("Output")
outputcol.pack_start(self.outputcell, expand=True)
outputcol.set_cell_data_func(self.outputcell, self.renderOutputCell)
self.outputView.append_column(outputcol)
gtklogger.connect(self.outputView, 'row-activated',
self.outputDoubleClickCB)
# Buttons for the Output pane. The extra VBox is used so that
# the sizes of the button boxes can be synchronized.
self.outputBBox = gtk.VBox(homogeneous=True)
outputVBox.pack_start(self.outputBBox, expand=False, fill=False)
bbox = gtk.HBox(homogeneous=False)
self.outputBBox.pack_start(bbox, expand=True, fill=True)
# New Output
self.newOutputButton = gtkutils.StockButton(gtk.STOCK_NEW, "New")
gtklogger.setWidgetName(self.newOutputButton, "New")
gtklogger.connect(self.newOutputButton, 'clicked', self.newOutputCB)
bbox.pack_start(self.newOutputButton, expand=True, fill=True)
tooltips.set_tooltip_text(self.newOutputButton,
"Define a new output operation.")
# Edit Output
self.editOutputButton = gtkutils.StockButton(gtk.STOCK_EDIT, "Edit")
gtklogger.setWidgetName(self.editOutputButton, "Edit")
gtklogger.connect(self.editOutputButton, 'clicked', self.editOutputCB)
bbox.pack_start(self.editOutputButton, expand=True, fill=True)
tooltips.set_tooltip_text(self.editOutputButton,
"Redefine the selected output operation.")
# Copy Output
self.copyOutputButton = gtkutils.StockButton(gtk.STOCK_COPY, "Copy")
gtklogger.setWidgetName(self.copyOutputButton, "Copy")
gtklogger.connect(self.copyOutputButton, 'clicked', self.copyOutputCB)
bbox.pack_start(self.copyOutputButton, expand=True, fill=True)
tooltips.set_tooltip_text(
self.copyOutputButton,
"Copy the selected output and its schedule and destination.")
# Second row of buttons
bbox = gtk.HBox(homogeneous=False)
self.outputBBox.pack_start(bbox, expand=True, fill=True)
# Rename Output
self.renameOutputButton = gtkutils.StockButton(gtk.STOCK_EDIT,
"Rename")
gtklogger.setWidgetName(self.renameOutputButton, "Rename")
gtklogger.connect(self.renameOutputButton, 'clicked', self.renameCB)
bbox.pack_start(self.renameOutputButton, expand=True, fill=True)
tooltips.set_tooltip_text(self.renameOutputButton,
"Rename the selected output operation.")
# Delete Output
self.deleteOutputButton = gtkutils.StockButton(gtk.STOCK_DELETE,
"Delete")
gtklogger.setWidgetName(self.deleteOutputButton, "Delete")
gtklogger.connect(self.deleteOutputButton, 'clicked',
self.deleteOutputCB)
tooltips.set_tooltip_text(self.deleteOutputButton,
"Delete the selected output operation.")
bbox.pack_start(self.deleteOutputButton, expand=True, fill=True)
# Delete all outputs
self.deleteAllButton = gtkutils.StockButton(gtk.STOCK_DELETE,
"Delete All")
gtklogger.setWidgetName(self.deleteAllButton, "DeleteAll")
gtklogger.connect(self.deleteAllButton, 'clicked', self.deleteAllCB)
bbox.pack_start(self.deleteAllButton, expand=True, fill=True)
tooltips.set_tooltip_text(self.deleteAllButton,
"Delete all output operations")
# Schedule pane
self.schedFrame = gtk.Frame()
self.schedFrame.set_shadow_type(gtk.SHADOW_IN)
gtklogger.setWidgetName(self.schedFrame, "Schedule")
hpaneR.pack1(self.schedFrame, resize=True, shrink=False)
scheduleVBox = gtk.VBox()
self.schedFrame.add(scheduleVBox)
self.schedView = gtk.TreeView(self.outputList)
gtklogger.setWidgetName(self.schedView, "list")
scheduleVBox.pack_start(self.schedView, expand=True, fill=True)
schedHScroll = gtk.HScrollbar()
scheduleVBox.pack_start(schedHScroll, expand=False, fill=False)
self.schedView.set_hadjustment(schedHScroll.get_adjustment())
self.schedcell = gtk.CellRendererText()
schedcol = gtk.TreeViewColumn("Schedule")
schedcol.pack_start(self.schedcell, expand=True)
schedcol.set_cell_data_func(self.schedcell, self.renderScheduleCB)
self.schedView.append_column(schedcol)
gtklogger.connect(self.schedView, 'row-activated',
self.schedDoubleClickCB)
# Buttons for the Schedule pane.
self.schedBBox = gtk.VBox(homogeneous=True)
scheduleVBox.pack_start(self.schedBBox, expand=False, fill=False)
bbox = gtk.HBox(homogeneous=False)
self.schedBBox.pack_start(bbox, expand=True, fill=True)
# Set Schedule
self.setScheduleButton = gtkutils.StockButton(gtk.STOCK_NEW, "Set")
gtklogger.setWidgetName(self.setScheduleButton, "New")
gtklogger.connect(self.setScheduleButton, 'clicked', self.setSchedCB)
bbox.pack_start(self.setScheduleButton, expand=True, fill=True)
tooltips.set_tooltip_text(self.setScheduleButton,
"Add a Schedule to the selected Output")
# Copy Schedule
self.copyScheduleButton = gtkutils.StockButton(gtk.STOCK_COPY, "Copy")
gtklogger.setWidgetName(self.copyScheduleButton, "Copy")
gtklogger.connect(self.copyScheduleButton, 'clicked', self.copySchedCB)
bbox.pack_start(self.copyScheduleButton, expand=True, fill=True)
tooltips.set_tooltip_text(
self.copyScheduleButton,
"Copy the selected Schedule to another Output")
# Second row of buttons in the Schedule pane
bbox = gtk.HBox(homogeneous=False)
self.schedBBox.pack_start(bbox, expand=True, fill=True)
# Delete Schedule
self.deleteScheduleButton = gtkutils.StockButton(
gtk.STOCK_DELETE, "Delete")
gtklogger.setWidgetName(self.deleteScheduleButton, "Delete")
gtklogger.connect(self.deleteScheduleButton, 'clicked',
self.deleteSchedCB)
bbox.pack_start(self.deleteScheduleButton, expand=True, fill=True)
tooltips.set_tooltip_text(self.deleteScheduleButton,
"Delete the selected Schedule.")
# Destination pane
self.destFrame = gtk.Frame()
self.destFrame.set_shadow_type(gtk.SHADOW_IN)
gtklogger.setWidgetName(self.destFrame, "Destination")
hpaneR.pack2(self.destFrame, resize=True, shrink=False)
destVBox = gtk.VBox()
self.destFrame.add(destVBox)
destScroll = gtk.ScrolledWindow()
destScroll.set_shadow_type(gtk.SHADOW_NONE)
destScroll.set_policy(gtk.POLICY_ALWAYS, gtk.POLICY_ALWAYS)
destVBox.pack_start(destScroll, expand=True, fill=True)
self.destView = gtk.TreeView(self.outputList)
gtklogger.setWidgetName(self.destView, "list")
destScroll.add(self.destView)
self.destcell = gtk.CellRendererText()
destcol = gtk.TreeViewColumn("Destination")
destcol.pack_start(self.destcell, expand=True)
destcol.set_cell_data_func(self.destcell, self.renderDestinationCB)
self.destView.append_column(destcol)
gtklogger.connect(self.destView, 'row-activated',
self.destDoubleClickCB)
# Buttons for the Destination pane
self.destBBox = gtk.VBox(homogeneous=True)
destVBox.pack_start(self.destBBox, expand=False, fill=True)
bbox = gtk.HBox(homogeneous=False)
self.destBBox.pack_start(bbox, expand=True, fill=True)
# Set Destination
self.setDestinationButton = gtkutils.StockButton(gtk.STOCK_NEW, "Set")
gtklogger.setWidgetName(self.setDestinationButton, "Set")
gtklogger.connect(self.setDestinationButton, 'clicked',
self.setDestinationCB)
bbox.pack_start(self.setDestinationButton, expand=True, fill=True)
tooltips.set_tooltip_text(
self.setDestinationButton,
"Assign a destination to the selected Output")
# Delete Dest
self.deleteDestButton = gtkutils.StockButton(gtk.STOCK_DELETE,
"Delete")
gtklogger.setWidgetName(self.deleteDestButton, "Delete")
gtklogger.connect(self.deleteDestButton, 'clicked', self.deleteDestCB)
bbox.pack_start(self.deleteDestButton, expand=True, fill=True)
tooltips.set_tooltip_text(self.deleteDestButton,
"Delete the selected Destination.")
# Second row of buttons in the Dest pane
bbox = gtk.HBox(homogeneous=False)
self.destBBox.pack_start(bbox, expand=True, fill=True)
# Rewind
self.rewindDestButton = gtkutils.StockButton(gtk.STOCK_MEDIA_REWIND,
"Rewind")
gtklogger.setWidgetName(self.rewindDestButton, "Rewind")
gtklogger.connect(self.rewindDestButton, 'clicked',
self.rewindDestinationCB)
bbox.pack_start(self.rewindDestButton, expand=True, fill=True)
tooltips.set_tooltip_text(self.rewindDestButton,
"Go back to the start of the output file.")
# Rewind All
self.rewindAllDestsButton = gtkutils.StockButton(
gtk.STOCK_MEDIA_REWIND, "Rewind All")
gtklogger.setWidgetName(self.rewindAllDestsButton, "RewindAll")
gtklogger.connect(self.rewindAllDestsButton, 'clicked',
self.rewindAllDestinationsCB)
bbox.pack_start(self.rewindAllDestsButton, expand=True, fill=True)
tooltips.set_tooltip_text(self.rewindAllDestsButton,
"Go back to the start of all output files.")
# Synchronize the vertical scrolling of all the panes.
self.schedView.set_vadjustment(destScroll.get_vadjustment())
self.outputView.set_vadjustment(destScroll.get_vadjustment())
self.enableView.set_vadjustment(destScroll.get_vadjustment())
self.allViews = (self.enableView, self.outputView, self.schedView,
self.destView)
# This is a hack. Some of the dialogs use widgets that need
# to find out what the current Output is, using the
# WidgetScope mechanism. The TreeView isn't a
# ParameterWidget, so it doesn't use WidgetScopes. So here we
# construct a ParameterWidget just so that it can be found.
# It's kept up to date with the selected Output. It's not
# actually placed in the GUI.
self.dummyOutputParam = parameter.RegisteredParameter(
'output', scheduledoutput.ScheduledOutput)
self.dummyOutputWidget = self.dummyOutputParam.makeWidget(scope=self)
# Catch selection changes in the lists
self.selectionsignals = {}
for view in self.allViews:
gtklogger.adoptGObject(view.get_selection(),
view,
access_method=view.get_selection)
self.selectionsignals[view] = gtklogger.connect(
view.get_selection(), 'changed', self.selectionCB)
switchboard.requestCallbackMain("scheduled outputs changed",
self.outputsChangedCB)
switchboard.requestCallbackMain("new scheduled output",
self.newOutputSBCB)
switchboard.requestCallbackMain("gtk font changed", self.setSizes)
def __init__(self):
oofGUI.MainPage.__init__(
self, name="Scheduled Output", ordering=235,
tip="Set output quantities to be computed during time evolution.")
mainbox = gtk.VBox(spacing=2)
self.gtk.add(mainbox)
align = gtk.Alignment(xalign=0.5)
mainbox.pack_start(align, expand=0, fill=0)
centerbox = gtk.HBox(spacing=3)
align.add(centerbox)
self.meshwidget = whowidget.WhoWidget(ooflib.engine.mesh.meshes,
scope=self)
switchboard.requestCallbackMain(self.meshwidget, self.meshCB)
label = gtk.Label("Microstructure=")
label.set_alignment(1.0, 0.5)
centerbox.pack_start(label, expand=0, fill=0)
centerbox.pack_start(self.meshwidget.gtk[0], expand=0, fill=0)
label = gtk.Label("Skeleton=")
label.set_alignment(1.0, 0.5)
centerbox.pack_start(label, expand=0, fill=0)
centerbox.pack_start(self.meshwidget.gtk[1], expand=0, fill=0)
label = gtk.Label("Mesh=")
label.set_alignment(1.0, 0.5)
centerbox.pack_start(label, expand=0, fill=0)
centerbox.pack_start(self.meshwidget.gtk[2], expand=0, fill=0)
align = gtk.Alignment(xalign=0.5)
mainbox.pack_start(align, expand=0, fill=0, padding=3)
align.add(gtk.Label(
"Skip this page if you're only solving static problems."))
# The four columns (enable, output, schedule, and destination)
# are each displayed in their own gtk.TreeView, each of which
# is in a pane of a gtk.HPaned. It would have been better to
# put each column in a different gtk.TreeViewColumn in the
# same gtk.TreeView, but that would have made it hard to put
# buttons at the bottom of each column.
hpane0 = gtk.HPaned()
gtklogger.setWidgetName(hpane0, 'HPane0')
gtklogger.connect_passive(hpane0, 'notify::position')
mainbox.pack_start(hpane0, expand=1, fill=1)
hpaneL = gtk.HPaned()
gtklogger.setWidgetName(hpaneL, 'HPaneL')
gtklogger.connect_passive(hpaneL, 'notify::position')
hpane0.pack1(hpaneL, resize=True, shrink=False)
hpaneR = gtk.HPaned()
gtklogger.setWidgetName(hpaneR, 'HPane2')
gtklogger.connect_passive(hpaneR, 'notify::position')
hpane0.pack2(hpaneR, resize=True, shrink=False)
self.outputList = gtk.ListStore(gobject.TYPE_PYOBJECT)
# The "Enable" column has a check box for each output
self.enableFrame = gtk.Frame()
self.enableFrame.set_shadow_type(gtk.SHADOW_IN)
hpaneL.pack1(self.enableFrame, resize=False, shrink=False)
vbox = gtk.VBox()
self.enableFrame.add(vbox)
self.enableView = gtk.TreeView(self.outputList)
gtklogger.setWidgetName(self.enableView, "enable")
vbox.pack_start(self.enableView, expand=True, fill=True)
self.enablecell = gtk.CellRendererToggle()
enablecol = gtk.TreeViewColumn("")
enablecol.set_resizable(False)
enablecol.pack_start(self.enablecell, expand=False)
enablecol.set_cell_data_func(self.enablecell, self.renderEnableCell)
self.enableView.append_column(enablecol)
gtklogger.adoptGObject(self.enablecell, self.enableView,
access_function=gtklogger.findCellRenderer,
access_kwargs={'col':0, 'rend':0})
gtklogger.connect(self.enablecell, 'toggled', self.enableCellCB)
# Extra space at the bottom of the column. The other columns
# have button boxes at the bottom, so this one needs a strut
# to keep its rows aligned with the others.
self.enableStrut = gtk.VBox()
vbox.pack_start(self.enableStrut, expand=False, fill=False)
# The "Output" pane lists the name of each output
self.outputFrame = gtk.Frame()
self.outputFrame.set_shadow_type(gtk.SHADOW_IN)
gtklogger.setWidgetName(self.outputFrame, "Output")
hpaneL.pack2(self.outputFrame, resize=True, shrink=False)
outputVBox = gtk.VBox()
self.outputFrame.add(outputVBox)
self.outputView = gtk.TreeView(self.outputList)
gtklogger.setWidgetName(self.outputView, "list")
outputVBox.pack_start(self.outputView, expand=True, fill=True)
self.outputHScroll = gtk.HScrollbar()
outputVBox.pack_start(self.outputHScroll, expand=False, fill=False)
self.outputView.set_hadjustment(self.outputHScroll.get_adjustment())
self.outputcell = gtk.CellRendererText()
outputcol = gtk.TreeViewColumn("Output")
outputcol.pack_start(self.outputcell, expand=True)
outputcol.set_cell_data_func(self.outputcell, self.renderOutputCell)
self.outputView.append_column(outputcol)
gtklogger.connect(self.outputView, 'row-activated',
self.outputDoubleClickCB)
# Buttons for the Output pane. The extra VBox is used so that
# the sizes of the button boxes can be synchronized.
self.outputBBox = gtk.VBox(homogeneous=True)
outputVBox.pack_start(self.outputBBox, expand=False, fill=False)
bbox = gtk.HBox(homogeneous=False)
self.outputBBox.pack_start(bbox, expand=True, fill=True)
# New Output
self.newOutputButton = gtkutils.StockButton(gtk.STOCK_NEW, "New")
gtklogger.setWidgetName(self.newOutputButton, "New")
gtklogger.connect(self.newOutputButton, 'clicked', self.newOutputCB)
bbox.pack_start(self.newOutputButton, expand=True, fill=True)
tooltips.set_tooltip_text(self.newOutputButton,
"Define a new output operation.")
# Edit Output
self.editOutputButton = gtkutils.StockButton(gtk.STOCK_EDIT, "Edit")
gtklogger.setWidgetName(self.editOutputButton, "Edit")
gtklogger.connect(self.editOutputButton, 'clicked', self.editOutputCB)
bbox.pack_start(self.editOutputButton, expand=True, fill=True)
tooltips.set_tooltip_text(self.editOutputButton,
"Redefine the selected output operation.")
# Copy Output
self.copyOutputButton = gtkutils.StockButton(gtk.STOCK_COPY, "Copy")
gtklogger.setWidgetName(self.copyOutputButton, "Copy")
gtklogger.connect(self.copyOutputButton, 'clicked', self.copyOutputCB)
bbox.pack_start(self.copyOutputButton, expand=True, fill=True)
tooltips.set_tooltip_text(self.copyOutputButton,
"Copy the selected output and its schedule and destination.")
# Second row of buttons
bbox = gtk.HBox(homogeneous=False)
self.outputBBox.pack_start(bbox, expand=True, fill=True)
# Rename Output
self.renameOutputButton = gtkutils.StockButton(gtk.STOCK_EDIT, "Rename")
gtklogger.setWidgetName(self.renameOutputButton, "Rename")
gtklogger.connect(self.renameOutputButton, 'clicked', self.renameCB)
bbox.pack_start(self.renameOutputButton, expand=True, fill=True)
tooltips.set_tooltip_text(self.renameOutputButton,
"Rename the selected output operation.")
# Delete Output
self.deleteOutputButton = gtkutils.StockButton(gtk.STOCK_DELETE,
"Delete")
gtklogger.setWidgetName(self.deleteOutputButton, "Delete")
gtklogger.connect(self.deleteOutputButton, 'clicked',
self.deleteOutputCB)
tooltips.set_tooltip_text(self.deleteOutputButton,
"Delete the selected output operation.")
bbox.pack_start(self.deleteOutputButton, expand=True, fill=True)
# Delete all outputs
self.deleteAllButton = gtkutils.StockButton(gtk.STOCK_DELETE,
"Delete All")
gtklogger.setWidgetName(self.deleteAllButton, "DeleteAll")
gtklogger.connect(self.deleteAllButton, 'clicked', self.deleteAllCB)
bbox.pack_start(self.deleteAllButton, expand=True, fill=True)
tooltips.set_tooltip_text(self.deleteAllButton,
"Delete all output operations")
# Schedule pane
self.schedFrame = gtk.Frame()
self.schedFrame.set_shadow_type(gtk.SHADOW_IN)
gtklogger.setWidgetName(self.schedFrame, "Schedule")
hpaneR.pack1(self.schedFrame, resize=True, shrink=False)
scheduleVBox = gtk.VBox()
self.schedFrame.add(scheduleVBox)
self.schedView = gtk.TreeView(self.outputList)
gtklogger.setWidgetName(self.schedView, "list")
scheduleVBox.pack_start(self.schedView, expand=True, fill=True)
schedHScroll = gtk.HScrollbar()
scheduleVBox.pack_start(schedHScroll, expand=False, fill=False)
self.schedView.set_hadjustment(schedHScroll.get_adjustment())
self.schedcell = gtk.CellRendererText()
schedcol = gtk.TreeViewColumn("Schedule")
schedcol.pack_start(self.schedcell, expand=True)
schedcol.set_cell_data_func(self.schedcell, self.renderScheduleCB)
self.schedView.append_column(schedcol)
gtklogger.connect(self.schedView, 'row-activated',
self.schedDoubleClickCB)
# Buttons for the Schedule pane.
self.schedBBox = gtk.VBox(homogeneous=True)
scheduleVBox.pack_start(self.schedBBox, expand=False, fill=False)
bbox = gtk.HBox(homogeneous=False)
self.schedBBox.pack_start(bbox, expand=True, fill=True)
# Set Schedule
self.setScheduleButton = gtkutils.StockButton(gtk.STOCK_NEW, "Set")
gtklogger.setWidgetName(self.setScheduleButton, "New")
gtklogger.connect(self.setScheduleButton, 'clicked', self.setSchedCB)
bbox.pack_start(self.setScheduleButton, expand=True, fill=True)
tooltips.set_tooltip_text(self.setScheduleButton,
"Add a Schedule to the selected Output")
# Copy Schedule
self.copyScheduleButton = gtkutils.StockButton(gtk.STOCK_COPY, "Copy")
gtklogger.setWidgetName(self.copyScheduleButton, "Copy")
gtklogger.connect(self.copyScheduleButton, 'clicked', self.copySchedCB)
bbox.pack_start(self.copyScheduleButton, expand=True, fill=True)
tooltips.set_tooltip_text(self.copyScheduleButton,
"Copy the selected Schedule to another Output")
# Second row of buttons in the Schedule pane
bbox = gtk.HBox(homogeneous=False)
self.schedBBox.pack_start(bbox, expand=True, fill=True)
# Delete Schedule
self.deleteScheduleButton = gtkutils.StockButton(gtk.STOCK_DELETE,
"Delete")
gtklogger.setWidgetName(self.deleteScheduleButton, "Delete")
gtklogger.connect(self.deleteScheduleButton, 'clicked',
self.deleteSchedCB)
bbox.pack_start(self.deleteScheduleButton, expand=True, fill=True)
tooltips.set_tooltip_text(self.deleteScheduleButton,
"Delete the selected Schedule.")
# Destination pane
self.destFrame = gtk.Frame()
self.destFrame.set_shadow_type(gtk.SHADOW_IN)
gtklogger.setWidgetName(self.destFrame, "Destination")
hpaneR.pack2(self.destFrame, resize=True, shrink=False)
destVBox = gtk.VBox()
self.destFrame.add(destVBox)
destScroll = gtk.ScrolledWindow()
destScroll.set_shadow_type(gtk.SHADOW_NONE)
destScroll.set_policy(gtk.POLICY_ALWAYS, gtk.POLICY_ALWAYS)
destVBox.pack_start(destScroll, expand=True, fill=True)
self.destView = gtk.TreeView(self.outputList)
gtklogger.setWidgetName(self.destView, "list")
destScroll.add(self.destView)
self.destcell = gtk.CellRendererText()
destcol = gtk.TreeViewColumn("Destination")
destcol.pack_start(self.destcell, expand=True)
destcol.set_cell_data_func(self.destcell, self.renderDestinationCB)
self.destView.append_column(destcol)
gtklogger.connect(self.destView, 'row-activated',
self.destDoubleClickCB)
# Buttons for the Destination pane
self.destBBox = gtk.VBox(homogeneous=True)
destVBox.pack_start(self.destBBox, expand=False, fill=True)
bbox = gtk.HBox(homogeneous=False)
self.destBBox.pack_start(bbox, expand=True, fill=True)
# Set Destination
self.setDestinationButton = gtkutils.StockButton(gtk.STOCK_NEW, "Set")
gtklogger.setWidgetName(self.setDestinationButton, "Set")
gtklogger.connect(self.setDestinationButton, 'clicked',
self.setDestinationCB)
bbox.pack_start(self.setDestinationButton, expand=True, fill=True)
tooltips.set_tooltip_text(self.setDestinationButton,
"Assign a destination to the selected Output")
# Delete Dest
self.deleteDestButton = gtkutils.StockButton(gtk.STOCK_DELETE,
"Delete")
gtklogger.setWidgetName(self.deleteDestButton, "Delete")
gtklogger.connect(self.deleteDestButton, 'clicked',
self.deleteDestCB)
bbox.pack_start(self.deleteDestButton, expand=True, fill=True)
tooltips.set_tooltip_text(self.deleteDestButton,
"Delete the selected Destination.")
# Second row of buttons in the Dest pane
bbox = gtk.HBox(homogeneous=False)
self.destBBox.pack_start(bbox, expand=True, fill=True)
# Rewind
self.rewindDestButton = gtkutils.StockButton(gtk.STOCK_MEDIA_REWIND,
"Rewind")
gtklogger.setWidgetName(self.rewindDestButton, "Rewind")
gtklogger.connect(self.rewindDestButton, 'clicked',
self.rewindDestinationCB)
bbox.pack_start(self.rewindDestButton, expand=True, fill=True)
tooltips.set_tooltip_text(self.rewindDestButton,
"Go back to the start of the output file.")
# Rewind All
self.rewindAllDestsButton = gtkutils.StockButton(gtk.STOCK_MEDIA_REWIND,
"Rewind All")
gtklogger.setWidgetName(self.rewindAllDestsButton, "RewindAll")
gtklogger.connect(self.rewindAllDestsButton, 'clicked',
self.rewindAllDestinationsCB)
bbox.pack_start(self.rewindAllDestsButton, expand=True, fill=True)
tooltips.set_tooltip_text(self.rewindAllDestsButton,
"Go back to the start of all output files.")
# Synchronize the vertical scrolling of all the panes.
self.schedView.set_vadjustment(destScroll.get_vadjustment())
self.outputView.set_vadjustment(destScroll.get_vadjustment())
self.enableView.set_vadjustment(destScroll.get_vadjustment())
self.allViews = (self.enableView, self.outputView, self.schedView,
self.destView)
# This is a hack. Some of the dialogs use widgets that need
# to find out what the current Output is, using the
# WidgetScope mechanism. The TreeView isn't a
# ParameterWidget, so it doesn't use WidgetScopes. So here we
# construct a ParameterWidget just so that it can be found.
# It's kept up to date with the selected Output. It's not
# actually placed in the GUI.
self.dummyOutputParam = parameter.RegisteredParameter(
'output', scheduledoutput.ScheduledOutput)
self.dummyOutputWidget = self.dummyOutputParam.makeWidget(scope=self)
# Catch selection changes in the lists
self.selectionsignals = {}
for view in self.allViews:
gtklogger.adoptGObject(view.get_selection(), view,
access_method=view.get_selection)
self.selectionsignals[view] = gtklogger.connect(
view.get_selection(), 'changed', self.selectionCB)
switchboard.requestCallbackMain("scheduled outputs changed",
self.outputsChangedCB)
switchboard.requestCallbackMain("new scheduled output",
self.newOutputSBCB)
switchboard.requestCallbackMain("gtk font changed", self.setSizes)
def __init__(self):
oofGUI.MainPage.__init__(
self, name="Solver",
ordering=240,
tip="Find solutions for static and time-dependent problems.")
mainbox = gtk.VBox(spacing=2)
self.gtk.add(mainbox)
align = gtk.Alignment(xalign=0.5)
mainbox.pack_start(align, expand=0, fill=0)
centerbox = gtk.HBox(spacing=3)
align.add(centerbox)
self.meshwidget = whowidget.WhoWidget(ooflib.engine.mesh.meshes,
scope=self)
switchboard.requestCallbackMain(self.meshwidget, self.meshCB)
label = gtk.Label("Microstructure=")
label.set_alignment(1.0, 0.5)
centerbox.pack_start(label, expand=0, fill=0)
centerbox.pack_start(self.meshwidget.gtk[0], expand=0, fill=0)
label = gtk.Label("Skeleton=")
label.set_alignment(1.0, 0.5)
centerbox.pack_start(label, expand=0, fill=0)
centerbox.pack_start(self.meshwidget.gtk[1], expand=0, fill=0)
label = gtk.Label("Mesh=")
label.set_alignment(1.0, 0.5)
centerbox.pack_start(label, expand=0, fill=0)
centerbox.pack_start(self.meshwidget.gtk[2], expand=0, fill=0)
mainvpane = gtk.VPaned()
gtklogger.setWidgetName(mainvpane, 'VPane')
mainbox.pack_start(mainvpane, expand=1, fill=1)
gtklogger.connect_passive(mainvpane, 'notify::position')
# Subproblem pane
## TODO 3.1: Make it possible to reorder the subproblems by
## drag and drop.
subprobframe = gtk.Frame('Solvers')
gtklogger.setWidgetName(subprobframe, "Subproblems")
subprobframe.set_shadow_type(gtk.SHADOW_IN)
mainvpane.pack1(subprobframe, resize=1, shrink=0)
subpvbox = gtk.VBox() # contains scrolled list and buttons
subpvbox.set_border_width(3)
subprobframe.add(subpvbox)
innerframe = gtk.Frame()
innerframe.set_shadow_type(gtk.SHADOW_IN)
subpvbox.pack_start(innerframe, expand=1, fill=1)
self.subpScroll = gtk.ScrolledWindow()
gtklogger.logScrollBars(self.subpScroll, "SubproblemScroll")
self.subpScroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
innerframe.add(self.subpScroll)
self.subprobList = gtk.ListStore(gobject.TYPE_PYOBJECT)
self.subpListView = gtk.TreeView(self.subprobList)
gtklogger.setWidgetName(self.subpListView, "SubproblemList")
self.subpScroll.add(self.subpListView)
gtklogger.adoptGObject(self.subprobList, self.subpListView,
access_method=self.subpListView.get_model)
# Catch selection changes
gtklogger.adoptGObject(self.subpListView.get_selection(),
self.subpListView,
access_method=self.subpListView.get_selection)
self.subpselsig = gtklogger.connect(self.subpListView.get_selection(),
'changed', self.subpSelectCB)
# Catch double clicks or returns
gtklogger.connect(self.subpListView, 'row-activated',
self.subpActivateRowCB)
# Order number in the first column
ordercell = gtk.CellRendererText()
ordercol = gtk.TreeViewColumn("Order")
ordercol.set_resizable(False)
ordercol.pack_start(ordercell, expand=False)
ordercol.set_cell_data_func(ordercell, self.renderSubproblemOrder)
self.subpListView.append_column(ordercol)
# Checkbox in the second column
solvecell = gtk.CellRendererToggle()
solvecol = gtk.TreeViewColumn("Solve?")
solvecol.pack_start(solvecell, expand=False)
solvecol.set_cell_data_func(solvecell, self.renderSolveCell)
self.subpListView.append_column(solvecol)
gtklogger.adoptGObject(solvecell, self.subpListView,
access_function=gtklogger.findCellRenderer,
access_kwargs={'col':1, 'rend':0})
gtklogger.connect(solvecell, 'toggled', self.solvecellCB)
# Subproblem name in the third column
namecell = gtk.CellRendererText()
namecol = gtk.TreeViewColumn("Subproblem")
namecol.set_resizable(True)
namecol.pack_start(namecell, expand=True)
namecol.set_cell_data_func(namecell, self.renderSubproblemName)
self.subpListView.append_column(namecol)
# Solver in the fourth column
solvercell = gtk.CellRendererText()
solvercol = gtk.TreeViewColumn("Solver")
solvercol.set_resizable(True)
solvercol.pack_start(solvercell, expand=True)
solvercol.set_cell_data_func(solvercell, self.renderSubproblemSolver)
self.subpListView.append_column(solvercol)
# Buttons at the bottom of the subproblem pane
subpbbox = gtk.HBox(homogeneous=True)
subpvbox.pack_start(subpbbox, expand=0, fill=0)
# Set Solver
self.setSolverButton = gtkutils.StockButton(gtk.STOCK_ADD, "Set...")
gtklogger.setWidgetName(self.setSolverButton, "Set")
gtklogger.connect(self.setSolverButton, 'clicked', self.setSolverCB)
subpbbox.pack_start(self.setSolverButton, expand=0, fill=1)
tooltips.set_tooltip_text(self.setSolverButton,
"Assign a solver to the selected subproblem.")
# Copy Solver
self.copySolverButton = gtkutils.StockButton(gtk.STOCK_COPY, "Copy...")
gtklogger.setWidgetName(self.copySolverButton, "Copy")
gtklogger.connect(self.copySolverButton, 'clicked', self.copySolverCB)
subpbbox.pack_start(self.copySolverButton, expand=0, fill=1)
tooltips.set_tooltip_text(
self.copySolverButton,
"Copy the selected solver to another subproblem,"
" possibly in another mesh.")
# Copy All Solvers
self.copyAllSolversButton = gtkutils.StockButton(gtk.STOCK_COPY,
"Copy All...")
gtklogger.setWidgetName(self.copyAllSolversButton, "CopyAll")
gtklogger.connect(self.copyAllSolversButton, 'clicked',
self.copyAllSolversCB)
subpbbox.pack_start(self.copyAllSolversButton, expand=0, fill=1)
tooltips.set_tooltip_text(
self.copyAllSolversButton,
"Copy all solvers to identically named subproblems in another mesh.")
# Remove Solver
self.removeSolverButton = gtkutils.StockButton(gtk.STOCK_REMOVE,
"Remove")
gtklogger.setWidgetName(self.removeSolverButton, "Remove")
gtklogger.connect(self.removeSolverButton, 'clicked',
self.removeSolverCB)
subpbbox.pack_start(self.removeSolverButton, expand=0, fill=1)
tooltips.set_tooltip_text(self.removeSolverButton,
"Delete the solver from the selected subproblem.")
# Remove all solvers
self.removeAllSolversButton = gtkutils.StockButton(gtk.STOCK_CLEAR,
"Remove All")
gtklogger.setWidgetName(self.removeAllSolversButton, "RemoveAll")
gtklogger.connect(self.removeAllSolversButton, 'clicked',
self.removeAllSolversCB)
subpbbox.pack_start(self.removeAllSolversButton, expand=0, fill=1)
tooltips.set_tooltip_text(self.removeAllSolversButton,
"Remove the solver from all subproblems.")
# Second row of buttons at the bottom of the subproblem pane
subpbbox = gtk.HBox(homogeneous=True)
subpvbox.pack_start(subpbbox, expand=0, fill=0)
# Solve this subproblem first
self.firstButton = gtkutils.StockButton(gtk.STOCK_GOTO_FIRST, "First",
align=0.0)
gtklogger.setWidgetName(self.firstButton, "First")
gtklogger.connect(self.firstButton, 'clicked', self.firstButtonCB)
subpbbox.pack_start(self.firstButton, expand=0, fill=1)
tooltips.set_tooltip_text(
self.firstButton,
"Solve the selected subproblem first when iterating"
" over subproblems.")
# Solve this subproblem earlier
self.earlierButton = gtkutils.StockButton(gtk.STOCK_GO_BACK, "Earlier",
align=0.0)
gtklogger.setWidgetName(self.earlierButton, "Earlier")
gtklogger.connect(self.earlierButton, 'clicked', self.earlierButtonCB)
subpbbox.pack_start(self.earlierButton, expand=0, fill=1)
tooltips.set_tooltip_text(
self.earlierButton,
"Solve the selected subproblem before the one above it"
" in the list when iterating over subproblems.")
# Solve this subproblem later
self.laterButton = gtkutils.StockButton(gtk.STOCK_GO_FORWARD, "Later",
reverse=True, align=1.0)
gtklogger.setWidgetName(self.laterButton, "Later")
gtklogger.connect(self.laterButton, 'clicked', self.laterButtonCB)
subpbbox.pack_start(self.laterButton, expand=0, fill=1)
tooltips.set_tooltip_text(
self.laterButton,
"Solve the selected subproblem after the next one in the"
" list when iterating over subproblems.")
# Solve this subproblem last
self.lastButton = gtkutils.StockButton(gtk.STOCK_GOTO_LAST, "Last",
reverse=True, align=1.0)
gtklogger.setWidgetName(self.lastButton, "Last")
gtklogger.connect(self.lastButton, 'clicked', self.lastButtonCB)
subpbbox.pack_start(self.lastButton, expand=0, fill=1)
tooltips.set_tooltip_text(
self.lastButton,
"Solve the selected subproblem last when iterating"
" over subproblems.")
# Field Initializers
initframe = gtk.Frame('Initialization')
gtklogger.setWidgetName(initframe, "FieldInit")
initframe.set_shadow_type(gtk.SHADOW_IN)
mainvpane.pack2(initframe, resize=1, shrink=0)
ivbox = gtk.VBox()
ivbox.set_border_width(3)
initframe.add(ivbox)
self.initscroll = gtk.ScrolledWindow()
gtklogger.logScrollBars(self.initscroll, "Scroll")
self.initscroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.initscroll.set_shadow_type(gtk.SHADOW_IN)
ivbox.pack_start(self.initscroll, expand=1, fill=1)
# The ListStore just contains the defined Fields. The
# TreeView displays their names and initializers.
self.initlist = gtk.ListStore(gobject.TYPE_PYOBJECT)
self.initview = gtk.TreeView(self.initlist)
gtklogger.setWidgetName(self.initview, 'Initializers')
self.initscroll.add(self.initview)
self.initview.set_headers_clickable(False)
fieldnamecell = gtk.CellRendererText()
fieldnamecol = gtk.TreeViewColumn('Field or BC')
self.initview.append_column(fieldnamecol)
fieldnamecol.pack_start(fieldnamecell, expand=False)
fieldnamecol.set_cell_data_func(fieldnamecell, self.renderFieldName)
fieldinitcell = gtk.CellRendererText()
fieldinitcol = gtk.TreeViewColumn('Initializer')
self.initview.append_column(fieldinitcol)
fieldinitcol.pack_start(fieldinitcell, expand=True)
fieldinitcol.set_cell_data_func(fieldinitcell, self.renderFieldInit)
selection = self.initview.get_selection()
gtklogger.adoptGObject(selection, self.initview,
access_method=self.initview.get_selection)
self.initselsignal = gtklogger.connect(selection, 'changed',
self.initSelectCB)
gtklogger.connect(self.initview, 'row-activated',
self.initActivateRowCB)
bbox = gtk.HBox(homogeneous=True)
ivbox.pack_start(bbox, expand=0, fill=0)
# Set button
self.fieldinitbutton=gtkutils.StockButton(gtk.STOCK_ADD, 'Set...')
gtklogger.setWidgetName(self.fieldinitbutton, "Set")
gtklogger.connect(self.fieldinitbutton, 'clicked',
self.fieldinitbuttonCB)
tooltips.set_tooltip_text(
self.fieldinitbutton,'Initialized the selected field.')
bbox.pack_start(self.fieldinitbutton, expand=0, fill=1)
# Copy button
self.copyinitbutton = gtkutils.StockButton(gtk.STOCK_COPY,
"Copy All...")
gtklogger.setWidgetName(self.copyinitbutton, 'CopyInit')
gtklogger.connect(self.copyinitbutton, 'clicked', self.copyinitCB)
bbox.pack_start(self.copyinitbutton, expand=0, fill=1)
tooltips.set_tooltip_text(self.copyinitbutton,
"Copy field initializers from the current mesh to another mesh.")
# Clear Initializer button
self.clearinitbutton = gtkutils.StockButton(gtk.STOCK_REMOVE, "Clear")
gtklogger.setWidgetName(self.clearinitbutton, "Clear")
gtklogger.connect(self.clearinitbutton, 'clicked', self.clearinitCB)
bbox.pack_start(self.clearinitbutton, expand=0, fill=1)
tooltips.set_tooltip_text(self.clearinitbutton,
"Remove the selected field initializer from the current mesh.")
# Clear All Initializers button
self.clearallinitsbutton = gtkutils.StockButton(gtk.STOCK_CLEAR,
"Clear All")
gtklogger.setWidgetName(self.clearallinitsbutton, 'ClearAll')
gtklogger.connect(self.clearallinitsbutton, 'clicked',
self.clearallinitsCB)
bbox.pack_start(self.clearallinitsbutton, expand=0, fill=1)
tooltips.set_tooltip_text(self.clearallinitsbutton,
"Remove the field initializers from the current mesh.")
# Second row of buttons in the Field Initialization pane
bbox = gtk.HBox(homogeneous=True)
ivbox.pack_start(bbox, expand=0, fill=1)
# Apply button
self.applyinitbutton = gtkutils.StockButton(gtk.STOCK_APPLY, "Apply")
gtklogger.setWidgetName(self.applyinitbutton, "Apply")
gtklogger.connect(self.applyinitbutton, 'clicked', self.applyinitCB)
tooltips.set_tooltip_text(self.applyinitbutton,
"Apply initializers to all fields at the current time.")
bbox.pack_start(self.applyinitbutton, expand=0, fill=1)
# Apply At button
self.applyinitattimebutton = gtkutils.StockButton(gtk.STOCK_APPLY,
"Apply at time...")
gtklogger.setWidgetName(self.applyinitattimebutton, "ApplyAt")
gtklogger.connect(self.applyinitattimebutton, 'clicked',
self.applyinitatCB)
tooltips.set_tooltip_text(self.applyinitattimebutton,
"Reset the current time and apply all field initializers.")
bbox.pack_start(self.applyinitattimebutton, expand=0, fill=1)
# Table containing status, time entries and Solve button
table = gtk.Table(rows=2, columns=4)
mainbox.pack_start(table, expand=0, fill=1)
# The start time isn't set directly by the user, except by
# applying field initializers at a given time. It's displayed
# in a desensitized gtk.Entry.
label = gtk.Label('current time=')
label.set_alignment(1.0, 0.5)
table.attach(label, 0,1, 0,1, xpadding=3, xoptions=~gtk.EXPAND)
self.currentTimeEntry = gtk.Entry()
self.currentTimeEntry.set_sensitive(False) # never sensitive
table.attach(self.currentTimeEntry, 1,2, 0,1, xpadding=3)
# End time is set by the user.
label = gtk.Label('end time=')
label.set_alignment(1.0, 0.5)
table.attach(label, 0,1, 1,2, xpadding=3, xoptions=~gtk.EXPAND)
self.endtimeEntry = gtk.Entry()
gtklogger.setWidgetName(self.endtimeEntry, 'end')
gtklogger.connect(self.endtimeEntry, 'changed', self.timeChangeCB)
table.attach(self.endtimeEntry, 1,2, 1,2, xpadding=3)
statusFrame = gtk.Frame("Status")
statusFrame.set_shadow_type(gtk.SHADOW_IN)
vbox = gtk.VBox()
statusFrame.add(vbox)
self.statusLabel = gtk.Label()
self.statusLabel.set_alignment(0.5, 0.5)
table.attach(statusFrame, 2,3, 0,3, xpadding=3)
vbox.pack_start(self.statusLabel, expand=0, fill=0)
align = gtk.Alignment(xalign=0.5)
vbox.pack_start(align, expand=0, fill=0, padding=3)
self.statusDetailButton = gtk.Button("Details...")
gtklogger.setWidgetName(self.statusDetailButton, 'status')
gtklogger.connect(self.statusDetailButton, 'clicked', self.statusCB)
align.add(self.statusDetailButton)
solveFrame0 = gtk.Frame()
solveFrame0.set_shadow_type(gtk.SHADOW_OUT)
solveFrame1 = gtk.Frame()
solveFrame1.set_shadow_type(gtk.SHADOW_IN)
solveFrame0.add(solveFrame1)
table.attach(solveFrame0, 3,4, 0,3, xpadding=3,
xoptions=~gtk.EXPAND)
self.solveButton = gtkutils.StockButton(gtk.STOCK_EXECUTE,
'<b>Solve</b>', markup=True)
self.solveButton.set_border_width(4)
gtklogger.setWidgetName(self.solveButton, 'solve')
gtklogger.connect(self.solveButton, 'clicked', self.solveCB)
solveFrame1.add(self.solveButton)
switchboard.requestCallbackMain("field defined", self.defineFldCB)
switchboard.requestCallbackMain("field initializer set", self.initFldCB)
switchboard.requestCallbackMain("subproblem changed",
self.subproblemsChangedCB)
switchboard.requestCallbackMain("mesh changed",
self.subproblemsChangedCB)
switchboard.requestCallbackMain("subproblem solvability changed",
self.subpSolverChangedCB)
switchboard.requestCallbackMain("subproblem solver changed",
self.subpSolverChangedCB)
switchboard.requestCallbackMain("subproblem solvers changed",
self.subpSolversChangedCB),
switchboard.requestCallbackMain("subproblems reordered",
self.subproblemsChangedCB),
switchboard.requestCallbackMain(("new who", "SubProblem"),
self.subproblemsChangedCB)
switchboard.requestCallbackMain(("rename who", "SubProblem"),
self.subproblemsChangedCB)
switchboard.requestCallbackMain(("remove who", "SubProblem"),
self.subproblemsChangedCB)
switchboard.requestCallbackMain("time changed",
self.meshTimeChangedCB)
switchboard.requestCallbackMain("mesh solved", self.meshSolvedCB)
switchboard.requestCallbackMain("mesh status changed",
self.statusChangedCB)
switchboard.requestCallbackMain("made reservation",
self.reservationCB)
switchboard.requestCallbackMain("cancelled reservation",
self.reservationCB)
def __init__(self):
oofGUI.MainPage.__init__(
self,
name="Scheduled Output",
ordering=235,
tip="Set output quantities to be computed during time evolution.")
mainbox = gtk.VBox(spacing=2)
self.gtk.add(mainbox)
align = gtk.Alignment(xalign=0.5)
mainbox.pack_start(align, expand=0, fill=0)
centerbox = gtk.HBox(spacing=3)
align.add(centerbox)
self.meshwidget = whowidget.WhoWidget(ooflib.engine.mesh.meshes,
scope=self)
switchboard.requestCallbackMain(self.meshwidget, self.meshCB)
label = gtk.Label("Microstructure=")
label.set_alignment(1.0, 0.5)
centerbox.pack_start(label, expand=0, fill=0)
centerbox.pack_start(self.meshwidget.gtk[0], expand=0, fill=0)
label = gtk.Label("Skeleton=")
label.set_alignment(1.0, 0.5)
centerbox.pack_start(label, expand=0, fill=0)
centerbox.pack_start(self.meshwidget.gtk[1], expand=0, fill=0)
label = gtk.Label("Mesh=")
label.set_alignment(1.0, 0.5)
centerbox.pack_start(label, expand=0, fill=0)
centerbox.pack_start(self.meshwidget.gtk[2], expand=0, fill=0)
align = gtk.Alignment(xalign=0.5)
mainbox.pack_start(align, expand=0, fill=0, padding=3)
align.add(
gtk.Label(
"Skip this page if you're only solving static problems."))
outputFrame = gtk.Frame()
gtklogger.setWidgetName(outputFrame, 'Output')
outputFrame.set_shadow_type(gtk.SHADOW_IN)
mainbox.pack_start(outputFrame, expand=1, fill=1)
outputBox = gtk.VBox(spacing=2)
outputFrame.add(outputBox)
# Buttons for creating, editing, and removing Outputs
bbox = gtk.HBox(homogeneous=True, spacing=2)
outputBox.pack_start(bbox, expand=False, fill=False)
# New Output
self.newOutputButton = gtkutils.StockButton(gtk.STOCK_NEW, "New")
gtklogger.setWidgetName(self.newOutputButton, "New")
gtklogger.connect(self.newOutputButton, 'clicked', self.newOutputCB)
bbox.pack_start(self.newOutputButton, expand=True, fill=True)
tooltips.set_tooltip_text(self.newOutputButton,
"Define a new output operation.")
# Rename Output
self.renameOutputButton = gtkutils.StockButton(gtk.STOCK_EDIT,
"Rename")
gtklogger.setWidgetName(self.renameOutputButton, "Rename")
gtklogger.connect(self.renameOutputButton, 'clicked', self.renameCB)
bbox.pack_start(self.renameOutputButton, expand=True, fill=True)
tooltips.set_tooltip_text(self.renameOutputButton,
"Rename the selected output operation.")
# Edit Output
self.editOutputButton = gtkutils.StockButton(gtk.STOCK_EDIT, "Edit")
gtklogger.setWidgetName(self.editOutputButton, "Edit")
gtklogger.connect(self.editOutputButton, 'clicked', self.editOutputCB)
bbox.pack_start(self.editOutputButton, expand=True, fill=True)
tooltips.set_tooltip_text(self.editOutputButton,
"Redefine the selected output operation.")
# Copy Output
self.copyOutputButton = gtkutils.StockButton(gtk.STOCK_COPY, "Copy")
gtklogger.setWidgetName(self.copyOutputButton, "Copy")
gtklogger.connect(self.copyOutputButton, 'clicked', self.copyOutputCB)
bbox.pack_start(self.copyOutputButton, expand=True, fill=True)
tooltips.set_tooltip_text(self.copyOutputButton,
"Copy the selected output.")
# Second row of buttons
bbox = gtk.HBox(homogeneous=True, spacing=2)
outputBox.pack_start(bbox, expand=False, fill=False)
# Delete Output
self.deleteOutputButton = gtkutils.StockButton(gtk.STOCK_DELETE,
"Delete")
gtklogger.setWidgetName(self.deleteOutputButton, "Delete")
gtklogger.connect(self.deleteOutputButton, 'clicked',
self.deleteOutputCB)
tooltips.set_tooltip_text(self.deleteOutputButton,
"Delete the selected output operation.")
bbox.pack_start(self.deleteOutputButton, expand=True, fill=True)
# Delete all outputs
self.deleteAllButton = gtkutils.StockButton(gtk.STOCK_DELETE,
"Delete All")
gtklogger.setWidgetName(self.deleteAllButton, "DeleteAll")
gtklogger.connect(self.deleteAllButton, 'clicked', self.deleteAllCB)
bbox.pack_start(self.deleteAllButton, expand=True, fill=True)
tooltips.set_tooltip_text(self.deleteAllButton,
"Delete all output operations")
# Rewind
self.rewindDestButton = gtkutils.StockButton(gtk.STOCK_MEDIA_REWIND,
"Rewind")
gtklogger.setWidgetName(self.rewindDestButton, "Rewind")
gtklogger.connect(self.rewindDestButton, 'clicked',
self.rewindDestinationCB)
bbox.pack_start(self.rewindDestButton, expand=True, fill=True)
tooltips.set_tooltip_text(self.rewindDestButton,
"Go back to the start of the output file.")
# Rewind All
self.rewindAllDestsButton = gtkutils.StockButton(
gtk.STOCK_MEDIA_REWIND, "Rewind All")
gtklogger.setWidgetName(self.rewindAllDestsButton, "RewindAll")
gtklogger.connect(self.rewindAllDestsButton, 'clicked',
self.rewindAllDestinationsCB)
bbox.pack_start(self.rewindAllDestsButton, expand=True, fill=True)
tooltips.set_tooltip_text(self.rewindAllDestsButton,
"Go back to the start of all output files.")
# List of Outputs
outputScroll = gtk.ScrolledWindow()
gtklogger.logScrollBars(outputScroll, "OutputScroll")
outputBox.pack_start(outputScroll, expand=True, fill=True)
outputScroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_ALWAYS)
self.outputList = gtk.ListStore(gobject.TYPE_PYOBJECT)
self.outputView = gtk.TreeView(self.outputList)
outputScroll.add(self.outputView)
gtklogger.setWidgetName(self.outputView, "OutputList")
# Catch double clicks
gtklogger.connect(self.outputView, 'row-activated',
self.outputDoubleClickCB)
# Catch selection changes
gtklogger.adoptGObject(self.outputView.get_selection(),
self.outputView,
access_method=self.outputView.get_selection)
self.selectionSignal = gtklogger.connect(
self.outputView.get_selection(), 'changed', self.selectionCB)
# Enable/disable column
enableCell = gtk.CellRendererToggle()
enableCol = gtk.TreeViewColumn("Enable")
enableCol.pack_start(enableCell, expand=False)
enableCol.set_resizable(False)
enableCol.set_cell_data_func(enableCell, self.renderEnableCell)
self.outputView.append_column(enableCol)
gtklogger.adoptGObject(enableCell,
self.outputView,
access_function=gtklogger.findCellRenderer,
access_kwargs={
'col': 0,
'rend': 0
})
gtklogger.connect(enableCell, 'toggled', self.enableCellCB)
# Output name column
self.outputCell = gtk.CellRendererText()
outputCol = gtk.TreeViewColumn("Output")
outputCol.pack_start(self.outputCell, expand=True)
outputCol.set_cell_data_func(self.outputCell, self.renderOutputCell)
self.outputView.append_column(outputCol)
# Output schedule column
self.schedCell = gtk.CellRendererText()
schedCol = gtk.TreeViewColumn("Schedule")
schedCol.pack_start(self.schedCell, expand=True)
schedCol.set_cell_data_func(self.schedCell, self.renderScheduleCB)
self.outputView.append_column(schedCol)
# Output destination column
self.destCell = gtk.CellRendererText()
destCol = gtk.TreeViewColumn("Destination")
destCol.pack_start(self.destCell, expand=True)
destCol.set_cell_data_func(self.destCell, self.renderDestinationCB)
self.outputView.append_column(destCol)
switchboard.requestCallbackMain("scheduled outputs changed",
self.outputsChangedCB)
switchboard.requestCallbackMain("new scheduled output",
self.newOutputSBCB)
def __init__(self, vwrtoolbox):
debug.mainthreadTest()
toolboxGUI.GfxToolbox.__init__(self, "Viewer", vwrtoolbox)
mainbox = gtk.VBox(spacing=3)
self.gtk.add(mainbox)
self.historian = historian.Historian(
setCB=self.restoreHistoricalView,
sensitizeCB=self.sensitize,
compareCB=lambda v1, v2: v1.equiv(v2))
# camera position
infoExpander = gtk.Expander("Camera Info")
gtklogger.setWidgetName(infoExpander, "CameraInfo")
infoFrame = gtk.Frame()
infoFrame.set_shadow_type(gtk.SHADOW_IN)
mainbox.pack_start(infoExpander, fill=0, expand=0)
infoExpander.add(infoFrame)
infoBox = gtk.VBox(spacing=3)
infoFrame.add(infoBox)
positionlabel = gtk.Label("Camera Position:")
infoBox.pack_start(positionlabel, fill=0, expand=0)
positiontable = gtk.Table(columns=3, rows=1)
infoBox.pack_start(positiontable, fill=0, expand=0)
self.camera_x = gtk.Entry()
gtklogger.setWidgetName(self.camera_x, "CameraX")
self.camera_x.set_size_request(ndigits * guitop.top().digitsize, -1)
self.camera_x.set_editable(0)
positiontable.attach(self.camera_x, 0, 1, 0, 1)
self.camera_y = gtk.Entry()
gtklogger.setWidgetName(self.camera_y, "CameraY")
self.camera_y.set_size_request(ndigits * guitop.top().digitsize, -1)
self.camera_y.set_editable(0)
positiontable.attach(self.camera_y, 1, 2, 0, 1)
self.camera_z = gtk.Entry()
gtklogger.setWidgetName(self.camera_z, "CameraZ")
self.camera_z.set_size_request(ndigits * guitop.top().digitsize, -1)
self.camera_z.set_editable(0)
positiontable.attach(self.camera_z, 2, 3, 0, 1)
focalpointlabel = gtk.Label("Focal Point:")
infoBox.pack_start(focalpointlabel, fill=0, expand=0)
focalpointtable = gtk.Table(columns=3, rows=1)
infoBox.pack_start(focalpointtable, fill=0, expand=0)
self.fp_x = gtk.Entry()
gtklogger.setWidgetName(self.fp_x, "FocalX")
self.fp_x.set_size_request(ndigits * guitop.top().digitsize, -1)
self.fp_x.set_editable(0)
focalpointtable.attach(self.fp_x, 0, 1, 0, 1)
self.fp_y = gtk.Entry()
gtklogger.setWidgetName(self.fp_y, "FocalY")
self.fp_y.set_size_request(ndigits * guitop.top().digitsize, -1)
self.fp_y.set_editable(0)
focalpointtable.attach(self.fp_y, 1, 2, 0, 1)
self.fp_z = gtk.Entry()
gtklogger.setWidgetName(self.fp_z, "FocalZ")
self.fp_z.set_size_request(ndigits * guitop.top().digitsize, -1)
self.fp_z.set_editable(0)
focalpointtable.attach(self.fp_z, 2, 3, 0, 1)
viewuplabel = gtk.Label("View Up Vector:")
infoBox.pack_start(viewuplabel, fill=0, expand=0)
viewuptable = gtk.Table(columns=3, rows=1)
infoBox.pack_start(viewuptable, fill=0, expand=0)
self.viewup_x = gtk.Entry()
gtklogger.setWidgetName(self.viewup_x, "ViewUpX")
self.viewup_x.set_size_request(ndigits * guitop.top().digitsize, -1)
self.viewup_x.set_editable(0)
viewuptable.attach(self.viewup_x, 0, 1, 0, 1)
self.viewup_y = gtk.Entry()
gtklogger.setWidgetName(self.viewup_y, "ViewUpY")
self.viewup_y.set_size_request(ndigits * guitop.top().digitsize, -1)
self.viewup_y.set_editable(0)
viewuptable.attach(self.viewup_y, 1, 2, 0, 1)
self.viewup_z = gtk.Entry()
gtklogger.setWidgetName(self.viewup_z, "ViewUpZ")
self.viewup_z.set_size_request(ndigits * guitop.top().digitsize, -1)
self.viewup_z.set_editable(0)
viewuptable.attach(self.viewup_z, 2, 3, 0, 1)
distancetable = gtk.Table(columns=2, rows=1)
infoBox.pack_start(distancetable, fill=0, expand=0)
distancelabel = gtk.Label("Distance:")
distancetable.attach(distancelabel, 0, 1, 0, 1)
self.distance = gtk.Entry()
gtklogger.setWidgetName(self.distance, "Distance")
self.distance.set_size_request(ndigits * guitop.top().digitsize, -1)
self.distance.set_editable(0)
distancetable.attach(self.distance, 1, 2, 0, 1)
angletable = gtk.Table(columns=2, rows=1)
infoBox.pack_start(angletable, fill=0, expand=0)
anglelabel = gtk.Label("View Angle:")
angletable.attach(anglelabel, 0, 1, 0, 1)
self.viewangle = gtk.Entry()
gtklogger.setWidgetName(self.viewangle, "ViewAngle")
self.viewangle.set_size_request(ndigits * guitop.top().digitsize, -1)
self.viewangle.set_editable(0)
angletable.attach(self.viewangle, 1, 2, 0, 1)
# Translation
transExpander = gtk.Expander("Translate")
gtklogger.setWidgetName(transExpander, "Translation")
mainbox.pack_start(transExpander, fill=0, expand=0)
transFrame = gtk.Frame()
transFrame.set_shadow_type(gtk.SHADOW_IN)
transExpander.add(transFrame)
transBox = gtk.VBox()
transFrame.add(transBox)
# dolly
dollyrow = gtk.HBox(homogeneous=1, spacing=2)
transBox.pack_start(dollyrow, expand=0, fill=1, padding=2)
inbutton = gtk.Button('Dolly In')
gtklogger.setWidgetName(inbutton, 'DollyIn')
tooltips.set_tooltip_text(
inbutton, "Translate camera towards focal point by given factor.")
dollyrow.pack_start(inbutton, expand=0, fill=1)
gtklogger.connect(inbutton, 'clicked', self.dollyin)
outbutton = gtk.Button('Dolly Out')
gtklogger.setWidgetName(outbutton, 'DollyOut')
tooltips.set_tooltip_text(
outbutton,
"Translate camera away from focal point by given factor.")
dollyrow.pack_start(outbutton, expand=0, fill=1)
gtklogger.connect(outbutton, 'clicked', self.dollyout)
fillbutton = gtk.Button('Fill')
gtklogger.setWidgetName(fillbutton, 'Fill')
tooltips.set_tooltip_text(
fillbutton, "Set the camera position so that the image"
" approximately fills the window.")
dollyrow.pack_start(fillbutton, expand=0, fill=1)
gtklogger.connect(fillbutton, 'clicked', self.dollyfill)
factorrow = gtk.HBox()
transBox.pack_start(factorrow, expand=0, fill=0, padding=2)
factorrow.pack_start(gtk.Label("Factor: "), expand=0, fill=0)
self.dollyfactor = gtk.Entry()
self.dollyfactor.set_editable(1)
self.dollyfactor.set_size_request(ndigits * guitop.top().digitsize, -1)
gtklogger.setWidgetName(self.dollyfactor, "DollyFactor")
self.dollyfactor.set_text("1.5")
tooltips.set_tooltip_text(
self.dollyfactor,
"Factor by which to multiply distance from camera to focal point.")
factorrow.pack_start(self.dollyfactor, expand=1, fill=1)
# track
trackrow = gtk.HBox(homogeneous=1, spacing=2)
transBox.pack_start(trackrow, expand=0, fill=1, padding=2)
horizbutton = gtk.Button('Horizontal')
tooltips.set_tooltip_text(horizbutton,
"Shift camera and focal point horizontally")
trackrow.pack_start(horizbutton, expand=0, fill=1)
gtklogger.connect(horizbutton, 'clicked', self.trackh)
vertbutton = gtk.Button('Vertical')
tooltips.set_tooltip_text(vertbutton,
"Shift camera and focal point vertically")
trackrow.pack_start(vertbutton, expand=0, fill=1)
gtklogger.connect(vertbutton, 'clicked', self.trackv)
recenterbutton = gtk.Button('Recenter')
tooltips.set_tooltip_text(
recenterbutton, "Recenter the microstructure in the viewport.")
trackrow.pack_start(recenterbutton, expand=0, fill=1)
gtklogger.connect(recenterbutton, 'clicked', self.recenter)
distrow = gtk.HBox()
transBox.pack_start(distrow, expand=0, fill=0, padding=2)
distrow.pack_start(gtk.Label("Distance: "), expand=0, fill=0)
self.trackdist = gtk.Entry()
self.trackdist.set_editable(1)
self.trackdist.set_size_request(ndigits * guitop.top().digitsize, -1)
self.trackdist.set_text("10.0")
tooltips.set_tooltip_text(
self.trackdist,
"Distance by which to track camera, in pixel units.")
distrow.pack_start(self.trackdist, expand=1, fill=1)
#rotate
rotateExpander = gtk.Expander("Rotate")
rotateFrame = gtk.Frame()
rotateFrame.set_shadow_type(gtk.SHADOW_IN)
mainbox.pack_start(rotateExpander, fill=0, expand=0)
rotateBox = gtk.VBox()
rotateExpander.add(rotateFrame)
rotateFrame.add(rotateBox)
rotrow1 = gtk.HBox(homogeneous=1, spacing=2)
rotateBox.pack_start(rotrow1, expand=0, fill=1, padding=2)
rollbutton = gtk.Button('Roll')
tooltips.set_tooltip_text(rollbutton,
"Rotate about direction of projection.")
rotrow1.pack_start(rollbutton, expand=0, fill=1)
gtklogger.connect(rollbutton, 'clicked', self.roll)
pitchbutton = gtk.Button('Pitch')
tooltips.set_tooltip_text(
pitchbutton,
"Rotate about cross product of direction of projection and"
" view up vector centered at camera position.")
rotrow1.pack_start(pitchbutton, expand=0, fill=1)
gtklogger.connect(pitchbutton, 'clicked', self.pitch)
yawbutton = gtk.Button('Yaw')
tooltips.set_tooltip_text(
yawbutton,
"Rotate about view up vector centered at camera position.")
rotrow1.pack_start(yawbutton, expand=0, fill=1)
gtklogger.connect(yawbutton, 'clicked', self.yaw)
rotrow2 = gtk.HBox(homogeneous=1, spacing=2)
rotateBox.pack_start(rotrow2, expand=0, fill=1, padding=2)
azbutton = gtk.Button('Azimuth')
tooltips.set_tooltip_text(
azbutton, "Rotate about view up vector centered at focal point.")
rotrow2.pack_start(azbutton, expand=0, fill=1)
gtklogger.connect(azbutton, 'clicked', self.azimuth)
elbutton = gtk.Button('Elevation')
tooltips.set_tooltip_text(
elbutton,
"Rotate about cross product of direction of projection and"
" view up vector centered at focal point")
rotrow2.pack_start(elbutton, expand=0, fill=1)
gtklogger.connect(elbutton, 'clicked', self.elevation)
anglerow = gtk.HBox()
rotateBox.pack_start(anglerow, expand=0, fill=0, padding=2)
anglerow.pack_start(gtk.Label("Angle: "), expand=0, fill=0)
self.angle = gtk.Entry()
self.angle.set_editable(1)
self.angle.set_size_request(ndigits * guitop.top().digitsize, -1)
self.angle.set_text("10.0")
tooltips.set_tooltip_text(self.angle,
"Angle by which to rotate, in degrees.")
anglerow.pack_start(self.angle, expand=1, fill=1)
# Zoom
zoomExpander = gtk.Expander('Zoom')
gtklogger.setWidgetName(zoomExpander, 'Zoom')
mainbox.pack_start(zoomExpander, fill=0, expand=0)
zoomFrame = gtk.Frame()
zoomFrame.set_shadow_type(gtk.SHADOW_IN)
zoomExpander.add(zoomFrame)
zoomBox = gtk.VBox()
zoomFrame.add(zoomBox)
buttonbox = gtk.HBox(homogeneous=1, spacing=2)
zoomBox.pack_start(buttonbox, expand=0, fill=0)
zoominbutton = gtk.Button('In')
gtklogger.setWidgetName(zoominbutton, 'In')
gtklogger.connect(zoominbutton, 'clicked', self.zoomInCB)
buttonbox.pack_start(zoominbutton, expand=1, fill=1)
tooltips.set_tooltip_text(
zoominbutton,
"Zoom in (decrease the viewing angle) by the given factor.")
zoomoutbutton = gtk.Button('Out')
gtklogger.setWidgetName(zoomoutbutton, 'Out')
gtklogger.connect(zoomoutbutton, 'clicked', self.zoomOutCB)
buttonbox.pack_start(zoomoutbutton, expand=1, fill=1)
tooltips.set_tooltip_text(
zoomoutbutton,
"Zoom out (increase the viewing angle) by the given factor.")
zoomfillbutton = gtk.Button('Fill')
gtklogger.setWidgetName(zoomfillbutton, 'Fill')
gtklogger.connect(zoomfillbutton, 'clicked', self.zoomFillCB)
buttonbox.pack_start(zoomfillbutton, expand=1, fill=1)
tooltips.set_tooltip_text(
zoomfillbutton,
"Set the viewing angle so that the image fills the window.")
zoomrow = gtk.HBox()
zoomBox.pack_start(zoomrow, expand=0, fill=0)
zoomrow.pack_start(gtk.Label("Factor: "), expand=0, fill=0)
self.zoomfactor = gtk.Entry()
self.zoomfactor.set_text("1.1")
self.zoomfactor.set_editable(1)
gtklogger.setWidgetName(self.zoomfactor, "Factor")
gtklogger.connect_passive(self.zoomfactor, "changed")
tooltips.set_tooltip_text(
self.zoomfactor, "Factor by which to multiply the camera angle.")
zoomrow.pack_start(self.zoomfactor, expand=1, fill=1)
# Clipping planes
clippingExpander = gtk.Expander("Clip")
clippingFrame = gtk.Frame()
gtklogger.setWidgetName(clippingExpander, "Clipping")
clippingFrame.set_shadow_type(gtk.SHADOW_IN)
mainbox.pack_start(clippingExpander, fill=1, expand=1)
clippingExpander.add(clippingFrame)
clippingBox = gtk.VBox()
clippingFrame.add(clippingBox)
clippingScroll = gtk.ScrolledWindow()
gtklogger.logScrollBars(clippingScroll, "Scroll")
clippingScroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
clippingBox.pack_start(clippingScroll, expand=1, fill=1)
self.clippingList = gtk.ListStore(gobject.TYPE_PYOBJECT,
gobject.TYPE_INT)
self.clippingListView = gtk.TreeView(self.clippingList)
gtklogger.setWidgetName(self.clippingListView, "ClippingList")
clippingScroll.add(self.clippingListView)
gtklogger.adoptGObject(self.clippingList,
self.clippingListView,
access_method=self.clippingListView.get_model)
gtklogger.adoptGObject(
self.clippingListView.get_selection(),
self.clippingListView,
access_method=self.clippingListView.get_selection)
self.clipSelectSignal = gtklogger.connect(
self.clippingListView.get_selection(), 'changed',
self.clipSelectionChangedCB)
gtklogger.connect(self.clippingListView, 'row-activated',
self.editClipCB)
# A check button that enables or disables a clipping plane
enablecell = gtk.CellRendererToggle()
enablecol = gtk.TreeViewColumn("On")
enablecol.pack_start(enablecell, expand=False)
enablecol.set_cell_data_func(enablecell, self.renderEnableCell)
self.clippingListView.append_column(enablecol)
gtklogger.adoptGObject(enablecell,
self.clippingListView,
access_function=gtklogger.findCellRenderer,
access_kwargs={
'col': 0,
'rend': 0
})
gtklogger.connect(enablecell, 'toggled', self.enableCellCB)
# A check button for inverting the plane
flipcell = gtk.CellRendererToggle()
flipcol = gtk.TreeViewColumn("Flip")
flipcol.pack_start(flipcell, expand=False)
flipcol.set_cell_data_func(flipcell, self.renderFlipCell)
self.clippingListView.append_column(flipcol)
gtklogger.adoptGObject(flipcell,
self.clippingListView,
access_function=gtklogger.findCellRenderer,
access_kwargs={
'col': 1,
'rend': 0
})
gtklogger.connect(flipcell, 'toggled', self.flipCellCB)
# The normal to the clipping plane
normalcell = gtk.CellRendererText()
normalcol = gtk.TreeViewColumn("Normal")
normalcol.set_resizable(True)
normalcol.pack_start(normalcell, expand=True)
normalcol.set_cell_data_func(normalcell, self.renderNormalCol)
self.clippingListView.append_column(normalcol)
# The offset
offsetcell = gtk.CellRendererText()
offsetcol = gtk.TreeViewColumn("Offset")
offsetcol.set_resizable(True)
offsetcol.pack_start(offsetcell, expand=True)
offsetcol.set_cell_data_func(offsetcell, self.renderOffsetCol)
self.clippingListView.append_column(offsetcol)
# Buttons for operating on clipping planes
bbox = gtk.HBox()
bbox.set_homogeneous(True)
clippingBox.pack_start(bbox, expand=0, fill=0)
newclipbutton = gtk.Button("New")
gtklogger.setWidgetName(newclipbutton, "New")
gtklogger.connect(newclipbutton, 'clicked', self.newClipCB)
tooltips.set_tooltip_text(newclipbutton, "Add a clipping plane.")
bbox.pack_start(newclipbutton)
self.editclipbutton = gtk.Button("Edit")
gtklogger.setWidgetName(self.editclipbutton, "Edit")
gtklogger.connect(self.editclipbutton, 'clicked', self.editClipCB)
tooltips.set_tooltip_text(self.editclipbutton,
"Edit a clipping plane.")
bbox.pack_start(self.editclipbutton)
self.delclipbutton = gtk.Button("Delete")
gtklogger.setWidgetName(self.delclipbutton, "Delete")
gtklogger.connect(self.delclipbutton, 'clicked', self.delClipCB)
tooltips.set_tooltip_text(self.delclipbutton,
"Delete a clipping plane.")
bbox.pack_start(self.delclipbutton)
# Second row of buttons for clipping plane operations
bbox = gtk.HBox()
bbox.set_homogeneous(True)
clippingBox.pack_start(bbox, expand=0, fill=0)
self.invclipButton = gtk.CheckButton("Invert All")
gtklogger.setWidgetName(self.invclipButton, "Invert")
gtklogger.connect(self.invclipButton, 'clicked', self.invClipCB)
tooltips.set_tooltip_text(self.invclipButton,
"Invert clipping sense globally")
bbox.pack_start(self.invclipButton)
self.suppressButton = gtk.CheckButton("Suppress All")
gtklogger.setWidgetName(self.suppressButton, "Suppress")
gtklogger.connect(self.suppressButton, 'clicked', self.suppressCB)
tooltips.set_tooltip_text(self.suppressButton,
"Suppress all clipping planes.")
bbox.pack_start(self.suppressButton)
## TODO 3.1: Clipping plane operations
## Delete all
## Save/Load?
## Copy to/from other window
## Click & drag editing
# save and restore
historyFrame = gtk.Frame("Save and Restore Views")
historyFrame.set_shadow_type(gtk.SHADOW_IN)
mainbox.pack_start(historyFrame, fill=0, expand=0)
viewTable = gtk.Table(columns=2, rows=3)
historyFrame.add(viewTable)
align = gtk.Alignment(xalign=0.9, yalign=0.5)
align.add(gtk.Label("Restore:"))
viewTable.attach(align, 0, 1, 0, 1)
self.viewChooser = chooser.ChooserWidget(viewertoolbox.viewNames(),
callback=self.setViewCB,
name="viewChooser")
viewTable.attach(self.viewChooser.gtk, 1, 2, 0, 1)
saveViewButton = gtk.Button("Save...")
tooltips.set_tooltip_text(saveViewButton,
"Save the current view settings.")
gtklogger.setWidgetName(saveViewButton, "Save")
gtklogger.connect(saveViewButton, 'clicked', self.saveViewCB)
viewTable.attach(saveViewButton, 0, 1, 1, 2)
deleteViewButton = gtk.Button("Delete...")
tooltips.set_tooltip_text(deleteViewButton, "Delete a saved view.")
gtklogger.setWidgetName(deleteViewButton, "Delete")
gtklogger.connect(deleteViewButton, 'clicked', self.deleteViewCB)
viewTable.attach(deleteViewButton, 1, 2, 1, 2)
self.prevViewButton = gtkutils.prevButton()
gtklogger.setWidgetName(self.prevViewButton, "Prev")
gtklogger.connect(self.prevViewButton, 'clicked',
self.historian.prevCB)
tooltips.set_tooltip_text(self.prevViewButton,
"Reinstate the previous view.")
viewTable.attach(self.prevViewButton, 0, 1, 2, 3)
self.nextViewButton = gtkutils.nextButton()
gtklogger.setWidgetName(self.nextViewButton, "Next")
gtklogger.connect(self.nextViewButton, 'clicked',
self.historian.nextCB)
tooltips.set_tooltip_text(self.nextViewButton,
"Reinstate the next view.")
viewTable.attach(self.nextViewButton, 1, 2, 2, 3)
# # position information
# voxelinfoFrame = gtk.Frame("Voxel Info")
# voxelinfoFrame.set_shadow_type(gtk.SHADOW_IN)
# mainbox.pack_start(voxelinfoFrame)
# voxelinfoBox = gtk.VBox()
# voxelinfoFrame.add(voxelinfoBox)
# voxelinfotable = gtk.Table(rows=3,columns=2)
# voxelinfoBox.pack_start(voxelinfotable, expand=False, fill=False)
# label = gtk.Label('x=')
# label.set_alignment(1.0, 0.5)
# voxelinfotable.attach(label, 0,1, 0,1, xpadding=5, xoptions=gtk.FILL)
# self.xtext = gtk.Entry()
# self.xtext.set_size_request(ndigits*guitop.top().digitsize, -1)
# voxelinfotable.attach(self.xtext, 1,2, 0,1,
# xpadding=5, xoptions=gtk.EXPAND|gtk.FILL)
# label = gtk.Label('y=')
# label.set_alignment(1.0, 0.5)
# voxelinfotable.attach(label, 0,1, 1,2, xpadding=5, xoptions=gtk.FILL)
# self.ytext = gtk.Entry()
# self.ytext.set_size_request(ndigits*guitop.top().digitsize, -1)
# voxelinfotable.attach(self.ytext, 1,2, 1,2,
# xpadding=5, xoptions=gtk.EXPAND|gtk.FILL)
# label = gtk.Label('z=')
# label.set_alignment(1.0, 0.5)
# voxelinfotable.attach(label, 0,1, 2,3, xpadding=5, xoptions=gtk.FILL)
# self.ztext = gtk.Entry()
# self.ztext.set_size_request(ndigits*guitop.top().digitsize, -1)
# voxelinfotable.attach(self.ztext, 1,2, 2,3,
# xpadding=5, xoptions=gtk.EXPAND|gtk.FILL)
self.sbcallbacks = [
switchboard.requestCallbackMain("view changed",
self.viewChangedCB),
switchboard.requestCallbackMain("view restored",
self.viewRestoredCB),
switchboard.requestCallbackMain("new view", self.newViewCB),
switchboard.requestCallbackMain("view deleted",
self.viewDeletedCB),
switchboard.requestCallbackMain("clip planes changed",
self.updateClipList)
]
self.sensitize()