def __init__(self, fpsw, scope=None, label=""):
debug.mainthreadTest()
self.fpsw = fpsw # parent FluxProfileSetWidget
self.gtk = gtk.HBox()
self.label = gtk.Label(label + " = ")
self.widget = regclassfactory.RegisteredClassFactory(
profile.ProfileXT.registry, scope=scope, name=label)
self.sbcb = switchboard.requestCallbackMain(self.widget, self.rcfCB)
self.gtk.pack_start(self.label, expand=0, fill=0)
self.gtk.pack_start(self.widget.gtk, expand=1, fill=1)
self.show()
def __init__(self):
self.built = False
oofGUI.MainPage.__init__(self, name="Active %s"%Spacestring,
ordering=71.1,
tip="Modify active %s."%spacestring)
mainbox = gtk.VBox(spacing=2)
self.gtk.add(mainbox)
# Microstructure widget, centered at the top of the page.
align = gtk.Alignment(xalign=0.5)
mainbox.pack_start(align, expand=0, fill=0)
centerbox = gtk.HBox(spacing=3)
align.add(centerbox)
label = gtk.Label('Microstructure=')
label.set_alignment(1.0, 0.5)
centerbox.pack_start(label, expand=0, fill=0)
self.mswidget = whowidget.WhoWidget(microstructure.microStructures,
scope=self)
centerbox.pack_start(self.mswidget.gtk[0], expand=0, fill=0)
mainpane = gtk.HPaned()
gtklogger.setWidgetName(mainpane, 'Pane')
mainbox.pack_start(mainpane, expand=1, fill=1)
gtklogger.connect_passive(mainpane, 'notify::position')
# Active area status in the left half of the main pane.
vbox = gtk.VBox()
mainpane.pack1(vbox, resize=1, shrink=0)
aasframe = gtk.Frame("Active %s Status"%Spacestring)
aasframe.set_shadow_type(gtk.SHADOW_IN)
vbox.pack_start(aasframe, expand=0, fill=0, padding=2)
self.aainfo = gtk.Label()
gtklogger.setWidgetName(self.aainfo, "Status")
## self.aainfo.set_alignment(0.0, 0.5)
aasframe.add(self.aainfo)
naaframe = gtk.Frame("Named Active %ss"%Spacestring)
naaframe.set_shadow_type(gtk.SHADOW_IN)
vbox.pack_start(naaframe, expand=1, fill=1)
naabox = gtk.VBox()
naaframe.add(naabox)
self.aalist = chooser.ScrolledChooserListWidget(
callback=self.aalistCB, dbcallback=self.aalistCB2,
name="NamedAreas")
naabox.pack_start(self.aalist.gtk, expand=1, fill=1, padding=2)
bbox = gtk.HBox()
naabox.pack_start(bbox, expand=0, fill=0, padding=2)
self.storebutton = gtk.Button("Store...")
bbox.pack_start(self.storebutton, expand=1, fill=0)
gtklogger.setWidgetName(self.storebutton, "Store")
gtklogger.connect(self.storebutton, 'clicked', self.storeCB)
tooltips.set_tooltip_text(
self.storebutton,
"Save the current active %s for future use."%spacestring)
self.renamebutton = gtk.Button("Rename...")
bbox.pack_start(self.renamebutton, expand=1, fill=0)
gtklogger.setWidgetName(self.renamebutton, "Rename")
gtklogger.connect(self.renamebutton, 'clicked', self.renameCB)
tooltips.set_tooltip_text(self.renamebutton,
"Rename the selected saved active %s."%spacestring)
self.deletebutton = gtk.Button("Delete")
bbox.pack_start(self.deletebutton, expand=1, fill=0)
gtklogger.setWidgetName(self.deletebutton, "Delete")
gtklogger.connect(self.deletebutton, 'clicked', self.deleteCB)
tooltips.set_tooltip_text(self.deletebutton,
"Delete the selected saved active %s."%spacestring)
self.restorebutton = gtk.Button("Restore")
bbox.pack_start(self.restorebutton, expand=1, fill=0)
gtklogger.setWidgetName(self.restorebutton, "Restore")
gtklogger.connect(self.restorebutton, 'clicked', self.restoreCB)
tooltips.set_tooltip_text(self.restorebutton,
"Use the selected saved active %s."%spacestring)
# Active area modification methods in the right half of the main pane
modframe = gtk.Frame("Active %s Modification"%Spacestring)
gtklogger.setWidgetName(modframe, "Modify")
modframe.set_shadow_type(gtk.SHADOW_IN)
mainpane.pack2(modframe, resize=0, shrink=0)
modbox = gtk.VBox()
modframe.add(modbox)
## scroll = gtk.ScrolledWindow()
## scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
## modbox.pack_start(scroll, expand=1, fill=1)
self.activeareaModFactory = regclassfactory.RegisteredClassFactory(
activeareamod.ActiveAreaModifier.registry, title="Method:",
scope=self, name="Method")
## scroll.add_with_viewport(self.activeareaModFactory.gtk)
modbox.pack_start(self.activeareaModFactory.gtk, expand=1, fill=1)
self.historian = historian.Historian(self.activeareaModFactory.set,
self.sensitizeHistory,
setCBkwargs={'interactive':1})
self.activeareaModFactory.set_callback(self.historian.stateChangeCB)
# Prev, OK, and Next buttons
hbox = gtk.HBox()
modbox.pack_start(hbox, expand=0, fill=0, padding=2)
self.prevbutton = gtkutils.prevButton()
hbox.pack_start(self.prevbutton, expand=0, fill=0, padding=2)
gtklogger.connect(self.prevbutton, 'clicked', self.historian.prevCB)
tooltips.set_tooltip_text(
self.prevbutton,
'Recall the previous active %s modification operation.'%spacestring)
self.okbutton = gtk.Button(stock=gtk.STOCK_OK)
hbox.pack_start(self.okbutton, expand=1, fill=1, padding=2)
gtklogger.setWidgetName(self.okbutton, "OK")
gtklogger.connect(self.okbutton, 'clicked', self.okbuttonCB)
tooltips.set_tooltip_text(
self.okbutton,
'Perform the active %s modification operation defined above.'
%spacestring)
self.nextbutton = gtkutils.nextButton()
hbox.pack_start(self.nextbutton, expand=0, fill=0, padding=2)
gtklogger.connect(self.nextbutton, 'clicked', self.historian.nextCB)
tooltips.set_tooltip_text(
self.nextbutton,
"Recall the next active %s modification operation."%spacestring)
# Undo, Redo, Override
hbox = gtk.HBox()
modbox.pack_start(hbox, expand=0, fill=0, padding=2)
self.undobutton = gtk.Button(stock=gtk.STOCK_UNDO)
hbox.pack_start(self.undobutton, expand=1, fill=0)
gtklogger.setWidgetName(self.undobutton, "Undo")
gtklogger.connect(self.undobutton, 'clicked', self.undoCB)
tooltips.set_tooltip_text(self.undobutton,
"Undo the previous operation.")
self.redobutton = gtk.Button(stock=gtk.STOCK_REDO)
hbox.pack_start(self.redobutton, expand=1, fill=0)
gtklogger.setWidgetName(self.redobutton, "Redo")
gtklogger.connect(self.redobutton, 'clicked', self.redoCB)
tooltips.set_tooltip_text(self.redobutton, "Redo an undone operation.")
self.overridebutton = gtk.ToggleButton('Override')
hbox.pack_start(self.overridebutton, expand=1, fill=0)
gtklogger.setWidgetName(self.overridebutton, "Override")
self.overridesignal = gtklogger.connect(self.overridebutton,
'clicked', self.overrideCB)
tooltips.set_tooltip_text(self.overridebutton,
"Temporarily activate the entire microstructure.")
# Switchboard signals
self.sbcallbacks = [
switchboard.requestCallback(self.mswidget,
self.mswidgetCB),
switchboard.requestCallback("active area modified",
self.aamodified),
switchboard.requestCallbackMain("stored active areas changed",
self.storedAAChanged),
switchboard.requestCallbackMain(('validity',
self.activeareaModFactory),
self.validityChangeCB)
]
self.built = True
def methodFactory(self):
return regclassfactory.RegisteredClassFactory(
self.method.registry, title="Method:", name="Method")
def __init__(self, parent):
debug.mainthreadTest()
self.parent = parent
self.gtk = gtk.Frame()
gtklogger.setWidgetName(self.gtk, 'Selection')
self.gtk.set_shadow_type(gtk.SHADOW_IN)
self.vbox = gtk.VBox()
self.gtk.add(self.vbox)
self.actionbox = gtk.VBox()
self.vbox.pack_start(self.actionbox, expand=1, fill=1)
self.historyline = gtk.VBox()
self.vbox.pack_start(self.historyline, expand=0, fill=0, padding=4)
for modeobj in parent.modedict.values():
modeobj.factory = regclassfactory.RegisteredClassFactory(
modeobj.mode.modifierclass.registry,
title="Action: ",
scope=parent, name=modeobj.name()+"Action")
modeobj.historybox = HistoryBox(self.setCB, self.okCB)
gtklogger.setWidgetName(modeobj.historybox.gtk,
modeobj.name()+"History")
modeobj.factory.set_callback(
modeobj.historybox.historian.stateChangeCB)
# Sensitize the history stuff when the selections are modified.
switchboard.requestCallbackMain(modeobj.mode.modifierappliedsignal,
modeobj.modifierApplied)
switchboard.requestCallbackMain(('validity', modeobj.factory),
modeobj.validityChangeCB)
# Slightly misleading name, includes undo, redo and clear.
self.undoredoline = gtk.HBox()
self.undo_button = gtk.Button(stock=gtk.STOCK_UNDO)
gtklogger.setWidgetName(self.undo_button, 'Undo')
gtklogger.connect(self.undo_button, "clicked", self.undoCB)
tooltips.set_tooltip_text(self.undo_button,
"Undo the latest selection operation.")
self.undoredoline.pack_start(self.undo_button, expand=1, fill=0)
self.redo_button = gtk.Button(stock=gtk.STOCK_REDO)
gtklogger.setWidgetName(self.redo_button, 'Redo')
gtklogger.connect(self.redo_button, "clicked", self.redoCB)
tooltips.set_tooltip_text(self.redo_button,
'Redo the latest undone selection operation.')
self.undoredoline.pack_start(self.redo_button, expand=1, fill=0)
self.clear_button = gtk.Button(stock=gtk.STOCK_CLEAR)
gtklogger.setWidgetName(self.clear_button, 'Clear')
gtklogger.connect(self.clear_button, "clicked", self.clearCB)
tooltips.set_tooltip_text(self.clear_button,
'Reset selection by clearing the current selection.')
self.undoredoline.pack_start(self.clear_button, expand=1, fill=0)
self.invert_button = gtk.Button("Invert")
gtklogger.setWidgetName(self.invert_button, 'Invert')
gtklogger.connect(self.invert_button, "clicked", self.invertCB)
tooltips.set_tooltip_text(self.invert_button,'Toggle the current selection.')
self.undoredoline.pack_start(self.invert_button, expand=1, fill=0)
self.vbox.pack_start(self.undoredoline, expand=0, fill=0, padding=2)
# Add all the action and history widgets. They do not
# all get shown, see this class's "show" routine for the drill.
for modeobj in parent.modedict.values():
self.actionbox.pack_start(modeobj.factory.gtk, expand=1, fill=1)
self.historyline.pack_start(modeobj.historybox.gtk,
expand=0, fill=0)
self.sensitize()
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 __init__(self):
self.postponed_update = False
oofGUI.MainPage.__init__(self, name="Skeleton", ordering=120,
tip='Construct and modify mesh skeletons')
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.skelwidget = whowidget.WhoWidget(whoville.getClass('Skeleton'),
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.skelwidget.gtk[0], expand=1, fill=1)
label = gtk.Label('Skeleton=')
label.set_alignment(1.0, 0.5)
centerbox.pack_start(label, expand=0, fill=0)
centerbox.pack_start(self.skelwidget.gtk[1], expand=1, fill=1)
# 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.new_skeleton_CB)
tooltips.set_tooltip_text(self.newbutton,"Create a new skeleton from the current microstructure.")
bbox.pack_start(self.newbutton, expand=1, fill=1)
self.simplebutton = gtk.Button('Simple...')
gtklogger.setWidgetName(self.simplebutton, "Simple")
gtklogger.connect(self.simplebutton, 'clicked', self.simple_skeleton_CB)
tooltips.set_tooltip_text(self.simplebutton,"Create a new skeleton from the current microstructure in a naive fashion, by creating one quadrilateral or two triangular elements per pixel. Material boundaries will be inherently jagged, which may cause errors in finite element solutions.")
bbox.pack_start(self.simplebutton, expand=1, fill=1)
self.autobutton = gtk.Button('Auto...')
gtklogger.setWidgetName(self.autobutton, 'Auto')
gtklogger.connect(self.autobutton, 'clicked', self.autoCB)
tooltips.set_tooltip_text(self.autobutton,"Create and automatically refine a Skeleton.")
bbox.pack_start(self.autobutton, expand=1, fill=1)
self.renamebutton = gtkutils.StockButton(gtk.STOCK_EDIT, 'Rename...')
gtklogger.setWidgetName(self.renamebutton, "Rename")
gtklogger.connect(self.renamebutton, 'clicked', self.rename_skeleton_CB)
tooltips.set_tooltip_text(self.renamebutton,"Rename the current skeleton.")
bbox.pack_start(self.renamebutton, expand=1, fill=1)
self.copybutton = gtkutils.StockButton(gtk.STOCK_COPY, 'Copy...')
gtklogger.setWidgetName(self.copybutton, 'Copy')
gtklogger.connect(self.copybutton, 'clicked', self.copy_skeleton_CB)
tooltips.set_tooltip_text(self.copybutton,"Copy the current skeleton.")
bbox.pack_start(self.copybutton, expand=1, fill=1)
self.deletebutton = gtkutils.StockButton(gtk.STOCK_DELETE, 'Delete')
gtklogger.setWidgetName(self.deletebutton, 'Delete')
gtklogger.connect(self.deletebutton, 'clicked', self.delete_skeletonCB)
tooltips.set_tooltip_text(self.deletebutton,"Delete the current skeleton.")
bbox.pack_start(self.deletebutton, expand=1, fill=1)
self.savebutton = gtkutils.StockButton(gtk.STOCK_SAVE, 'Save...')
gtklogger.setWidgetName(self.savebutton, "Save")
gtklogger.connect(self.savebutton, 'clicked', self.save_skeletonCB)
tooltips.set_tooltip_text(self.savebutton,
"Save the current skeleton to a file.")
bbox.pack_start(self.savebutton, expand=1, fill=1)
mainpane = gtk.HPaned()
gtklogger.setWidgetName(mainpane, 'Pane')
mainbox.pack_start(mainpane, expand=1, fill=1)
gtklogger.connect_passive(mainpane, 'notify::position')
self.skelframe = gtk.Frame(label="Skeleton Status")
self.skelframe.set_shadow_type(gtk.SHADOW_IN)
mainpane.pack1(self.skelframe, resize=1, shrink=0)
scroll = gtk.ScrolledWindow()
gtklogger.logScrollBars(scroll, "StatusScroll")
scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scroll.set_shadow_type(gtk.SHADOW_IN)
self.skelframe.add(scroll)
self.skelinfo = fixedwidthtext.FixedWidthTextView()
gtklogger.setWidgetName(self.skelinfo, "SkeletonText")
self.skelinfo.set_wrap_mode(gtk.WRAP_WORD)
self.skelinfo.set_editable(False)
self.skelinfo.set_cursor_visible(False)
self.boldTag = self.skelinfo.get_buffer().create_tag(
"bold", weight=pango.WEIGHT_BOLD)
scroll.add(self.skelinfo)
# End of left-side of skeleton info frame.
# Start of right-side
skelmodframe = gtk.Frame(label="Skeleton Modification")
gtklogger.setWidgetName(skelmodframe, 'Modification')
skelmodframe.set_shadow_type(gtk.SHADOW_IN)
skelmodbox = gtk.VBox(spacing=3)
skelmodframe.add(skelmodbox)
self.skelmod = regclassfactory.RegisteredClassFactory(
skeletonmodifier.SkeletonModifier.registry,
title="method: ",
callback=self.skelmodCB,
expand=0, fill=0, scope=self, name="Method")
self.historian = historian.Historian(self.skelmod.set,
self.sensitizeHistory,
setCBkwargs={'interactive':1})
skelmodbox.pack_start(self.skelmod.gtk,expand=1,fill=1)
# Buttons for "Previous", "OK", and "Next"
hbox = gtk.HBox()
self.prevskelmodbutton = gtkutils.prevButton()
gtklogger.connect(self.prevskelmodbutton, 'clicked', self.prevskelmod)
tooltips.set_tooltip_text(self.prevskelmodbutton,
'Recall the previous skeleton modification operation.')
hbox.pack_start(self.prevskelmodbutton, 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.okskelmod)
tooltips.set_tooltip_text(self.okbutton,
'Perform the skeleton modification operation defined above.')
hbox.pack_start(self.okbutton, expand=1, fill=1, padding=5)
self.nextskelmodbutton = gtkutils.nextButton()
gtklogger.connect(self.nextskelmodbutton, 'clicked', self.nextskelmod)
tooltips.set_tooltip_text(self.nextskelmodbutton,
'Recall the next skeleton modification operation.')
hbox.pack_start(self.nextskelmodbutton, expand=0, fill=0, padding=2)
skelmodbox.pack_start(hbox, expand=0, fill=0, padding=2)
# Buttons for "Undo", "Redo"
hbox = gtk.HBox()
self.undobutton = gtk.Button(stock=gtk.STOCK_UNDO)
gtklogger.setWidgetName(self.undobutton, 'Undo')
gtklogger.connect(self.undobutton, 'clicked', self.undoskelmod)
tooltips.set_tooltip_text(self.undobutton,
'Undo the latest skeleton modification.')
hbox.pack_start(self.undobutton, expand=1, fill=0, padding=10)
self.redobutton = gtk.Button(stock=gtk.STOCK_REDO)
gtklogger.setWidgetName(self.redobutton, 'Redo')
gtklogger.connect(self.redobutton, 'clicked', self.redoskelmod)
tooltips.set_tooltip_text(self.redobutton,
'Redo the latest undone skeleton modification.')
hbox.pack_start(self.redobutton, expand=1, fill=0, padding=10)
skelmodbox.pack_start(hbox, expand=0, fill=0, padding=2)
mainpane.pack2(skelmodframe, resize=0, shrink=0)
# End of right-side
self.sbcallbacks = [
switchboard.requestCallback("made reservation",
self.update_ok_button),
switchboard.requestCallback("cancelled reservation",
self.update_ok_button),
switchboard.requestCallback("skeleton homogeneity changed",
self.homogeneityChangeCB),
switchboard.requestCallbackMain("Skeleton modified",
self.recordModifier),
switchboard.requestCallback(('who changed', 'Skeleton'),
self.changeSkeleton),
switchboard.requestCallbackMain(SkeletonModifier,
self.updateskelmod),
switchboard.requestCallbackMain(("new who", "Microstructure"),
self.newMicrostructure),
switchboard.requestCallbackMain(("new who", 'Skeleton'),
self.newSkeleton),
# Pages should catch the signal from updates to the widget
# which don't originate on this page, e.g. deletions via
# menu command.
switchboard.requestCallback(self.skelwidget, self.skel_update),
switchboard.requestCallback(('validity', self.skelmod),
self.validityChangeCB),
# Node movements can change the homogeneity of elements,
# thus changing the state.
switchboard.requestCallback("skeleton nodes moved", self.nodesMoved)
]
def __init__(self):
oofGUI.MainPage.__init__(self, name="Image", ordering=50,
tip='Manipulate Images')
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)
label = gtk.Label('Microstructure=')
label.set_alignment(1.0, 0.5)
centerbox.pack_start(label, expand=0, fill=0)
self.imagewidget = whowidget.WhoWidget(imagecontext.imageContexts)
centerbox.pack_start(self.imagewidget.gtk[0], expand=0, fill=0)
label = gtk.Label('Image=')
label.set_alignment(1.0, 0.5)
centerbox.pack_start(label, expand=0, fill=0)
centerbox.pack_start(self.imagewidget.gtk[1], expand=0, fill=0)
align = gtk.Alignment(xalign=0.5)
mainbox.pack_start(align, expand=0, fill=0)
centerbox = gtk.HBox(homogeneous=1, spacing=3)
align.add(centerbox)
self.loadbutton = gtk.Button('Load...')
gtklogger.setWidgetName(self.loadbutton, 'Load')
centerbox.pack_start(self.loadbutton, expand=1, fill=1)
gtklogger.connect(self.loadbutton, 'clicked', self.loadCB)
tooltips.set_tooltip_text(self.loadbutton,
'Load a new image into an existing Microstructure')
self.copybutton = gtkutils.StockButton(gtk.STOCK_COPY, 'Copy...')
gtklogger.setWidgetName(self.copybutton, 'Copy')
gtklogger.connect(self.copybutton, 'clicked', self.copyCB)
centerbox.pack_start(self.copybutton, expand=1, fill=1)
tooltips.set_tooltip_text(self.copybutton,
'Copy the current image. The copy can be in the same or a different Microstructure.')
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 image.')
centerbox.pack_start(self.renamebutton, expand=1, 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 image.')
centerbox.pack_start(self.deletebutton, expand=1, 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 image to a file.')
centerbox.pack_start(self.savebutton, expand=1, fill=1)
self.autogroupbutton = gtk.Button('Group...')
gtklogger.setWidgetName(self.autogroupbutton, 'Group')
gtklogger.connect(self.autogroupbutton, 'clicked', self.autogroupCB)
centerbox.pack_start(self.autogroupbutton, expand=1, fill=1, padding=2)
if config.dimension() == 2:
tooltips.set_tooltip_text(self.autogroupbutton,
"Create a pixel group in the current image's microstructure for each color pixel in the image.")
elif config.dimension() == 3:
tooltips.set_tooltip_text(self.autogroupbutton,
"Create a voxel group in the current image's microstructure for each color voxel in the image.")
mainpane = gtk.HPaned()
gtklogger.setWidgetName(mainpane, 'Pane')
mainbox.pack_start(mainpane, expand=1, fill=1)
gtklogger.connect_passive(mainpane, 'notify::position')
frame = gtk.Frame('Image Information')
frame.set_shadow_type(gtk.SHADOW_IN)
mainpane.pack1(frame, resize=True, shrink=False)
scroll = gtk.ScrolledWindow()
gtklogger.logScrollBars(scroll, "StatusScroll")
scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
frame.add(scroll)
self.infoarea = fixedwidthtext.FixedWidthTextView()
self.infoarea.set_wrap_mode(gtk.WRAP_WORD)
self.infoarea.set_editable(False)
self.infoarea.set_cursor_visible(False)
scroll.add_with_viewport(self.infoarea)
frame = gtk.Frame('Image Modification')
frame.set_shadow_type(gtk.SHADOW_IN)
mainpane.pack2(frame, resize=False, shrink=False)
vbox = gtk.VBox()
frame.add(vbox)
## scroll = gtk.ScrolledWindow() # scroll window for image mod method
## scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
## vbox.pack_start(scroll, expand=1, fill=1)
self.imageModFactory = regclassfactory.RegisteredClassFactory(
imagemodifier.ImageModifier.registry,
title="Method:", name="Method")
## scroll.add_with_viewport(self.imageModFactory.gtk)
vbox.pack_start(self.imageModFactory.gtk, expand=1, fill=1)
self.historian = historian.Historian(self.imageModFactory.set,
self.sensitizeHistory,
setCBkwargs={'interactive':1})
self.imageModFactory.set_callback(self.historian.stateChangeCB)
# Prev, OK, and Next buttons
hbox = gtk.HBox()
vbox.pack_start(hbox, expand=0, fill=0, padding=2)
self.prevmethodbutton = gtkutils.prevButton()
gtklogger.connect(self.prevmethodbutton, 'clicked',
self.historian.prevCB)
hbox.pack_start(self.prevmethodbutton, expand=0, fill=0, padding=2)
tooltips.set_tooltip_text(self.prevmethodbutton,
'Recall the previous image modification operation.')
self.okbutton = gtk.Button(stock=gtk.STOCK_OK)
gtklogger.setWidgetName(self.okbutton, 'OK')
hbox.pack_start(self.okbutton, expand=1, fill=1, padding=5)
gtklogger.connect(self.okbutton, 'clicked', self.okbuttonCB)
tooltips.set_tooltip_text(self.okbutton,
'Perform the image modification operation defined above.')
self.nextmethodbutton = gtkutils.nextButton()
gtklogger.connect(self.nextmethodbutton, 'clicked',
self.historian.nextCB)
hbox.pack_start(self.nextmethodbutton, expand=0, fill=0, padding=2)
tooltips.set_tooltip_text(self.nextmethodbutton,
"Recall the next image modification operation.")
# Undo and Redo buttons
hbox = gtk.HBox()
vbox.pack_start(hbox, expand=0, fill=0, padding=2)
self.undobutton = gtk.Button(stock=gtk.STOCK_UNDO)
gtklogger.setWidgetName(self.undobutton, 'Undo')
gtklogger.connect(self.undobutton, 'clicked', self.undoCB)
tooltips.set_tooltip_text(self.undobutton,'Undo the latest image modification.')
hbox.pack_start(self.undobutton, expand=1, fill=0, padding=10)
self.redobutton = gtk.Button(stock=gtk.STOCK_REDO)
gtklogger.setWidgetName(self.redobutton, 'Redo')
gtklogger.connect(self.redobutton, 'clicked', self.redoCB)
tooltips.set_tooltip_text(self.redobutton,
'Redo the latest undone image modification.')
hbox.pack_start(self.redobutton, expand=1, fill=0, padding=10)
self.sbcallbacks = [
switchboard.requestCallbackMain(('new who', 'Microstructure'),
self.newMicrostructureCB),
switchboard.requestCallbackMain(('new who', 'Image'),
self.newImageCB),
switchboard.requestCallbackMain(('remove who', 'Image'),
self.rmWhoCB),
switchboard.requestCallbackMain('modified image',
self.modifiedImageCB),
switchboard.requestCallbackMain(imagemodifier.ImageModifier,
self.updateImageModifiers),
switchboard.requestCallbackMain(self.imagewidget,
self.iWidgetChanged),
switchboard.requestCallbackMain(('validity',
self.imageModFactory),
self.validityChangeCB),
switchboard.requestCallbackMain(('WhoDoUndo buffer change',
'Image'),
self.whoBufChangeCB)
]
def __init__(self):
debug.mainthreadTest()
oofGUI.MainPage.__init__(self,
name="%s Selection" % Pixstring,
ordering=71,
tip="Modify the set of selected %ss." %
pixstring)
mainbox = gtk.VBox(spacing=2)
self.gtk.add(mainbox)
# Microstructure widget, centered at the top of the page.
align = gtk.Alignment(xalign=0.5)
mainbox.pack_start(align, expand=0, fill=0)
centerbox = gtk.HBox(spacing=3)
align.add(centerbox)
label = gtk.Label('Microstructure=')
label.set_alignment(1.0, 0.5)
centerbox.pack_start(label, expand=0, fill=0)
self.mswidget = whowidget.WhoWidget(microstructure.microStructures,
scope=self)
centerbox.pack_start(self.mswidget.gtk[0], expand=0, fill=0)
mainpane = gtk.HPaned()
gtklogger.setWidgetName(mainpane, 'Pane')
mainbox.pack_start(mainpane, expand=1, fill=1)
gtklogger.connect_passive(mainpane, 'notify::position')
# Pixel selection status in the left half of the main pane
pssframe = gtk.Frame("%s Selection Status" % Pixstring)
pssframe.set_shadow_type(gtk.SHADOW_IN)
mainpane.pack1(pssframe, resize=1, shrink=0)
self.datascroll = gtk.ScrolledWindow()
gtklogger.logScrollBars(self.datascroll, "DataScroll")
pssframe.add(self.datascroll)
self.datascroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.psdata = fixedwidthtext.FixedWidthTextView()
gtklogger.setWidgetName(self.psdata, 'DataView')
self.psdata.set_editable(0)
self.psdata.set_cursor_visible(False)
self.psdata.set_wrap_mode(gtk.WRAP_WORD)
self.datascroll.add_with_viewport(self.psdata)
# Selection method in the right half of the main pane
modframe = gtk.Frame("%s Selection Modification" % Pixstring)
gtklogger.setWidgetName(modframe, "SelectionModification")
modframe.set_shadow_type(gtk.SHADOW_IN)
mainpane.pack2(modframe, resize=0, shrink=0)
vbox = gtk.VBox()
modframe.add(vbox)
## scroll = gtk.ScrolledWindow()
## scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
## vbox.add(scroll)
self.selectionModFactory = regclassfactory.RegisteredClassFactory(
pixelselectionmod.SelectionModifier.registry,
title="Method:",
scope=self,
name="Method")
vbox.pack_start(self.selectionModFactory.gtk, expand=1, fill=1)
## scroll.add_with_viewport(self.selectionModFactory.gtk)
self.historian = historian.Historian(self.selectionModFactory.set,
self.sensitizeHistory,
setCBkwargs={'interactive': 1})
self.selectionModFactory.set_callback(self.historian.stateChangeCB)
# Prev, OK, and Next buttons
hbox = gtk.HBox()
vbox.pack_start(hbox, expand=0, fill=0, padding=2)
self.prevmethodbutton = gtkutils.prevButton()
gtklogger.connect(self.prevmethodbutton, 'clicked',
self.historian.prevCB)
hbox.pack_start(self.prevmethodbutton, expand=0, fill=0, padding=2)
tooltips.set_tooltip_text(
self.prevmethodbutton,
'Recall the previous selection modification operation.')
self.okbutton = gtk.Button(stock=gtk.STOCK_OK)
gtklogger.setWidgetName(self.okbutton, "OK")
hbox.pack_start(self.okbutton, expand=1, fill=1, padding=2)
gtklogger.connect(self.okbutton, 'clicked', self.okbuttonCB)
tooltips.set_tooltip_text(
self.okbutton,
'Perform the selection modification operation defined above.')
self.nextmethodbutton = gtkutils.nextButton()
gtklogger.connect(self.nextmethodbutton, 'clicked',
self.historian.nextCB)
hbox.pack_start(self.nextmethodbutton, expand=0, fill=0, padding=2)
tooltips.set_tooltip_text(
self.nextmethodbutton,
"Recall the next selection modification operation.")
# Undo, Redo, and Clear buttons
hbox = gtk.HBox()
vbox.pack_start(hbox, expand=0, fill=0, padding=2)
self.undobutton = gtk.Button(stock=gtk.STOCK_UNDO)
self.redobutton = gtk.Button(stock=gtk.STOCK_REDO)
hbox.pack_start(self.undobutton, expand=1, fill=0)
hbox.pack_start(self.redobutton, expand=1, fill=0)
gtklogger.setWidgetName(self.undobutton, "Undo")
gtklogger.setWidgetName(self.redobutton, "Redo")
gtklogger.connect(self.undobutton, 'clicked', self.undoCB)
gtklogger.connect(self.redobutton, 'clicked', self.redoCB)
tooltips.set_tooltip_text(
self.undobutton,
"Undo the previous %s selection operation." % pixstring)
tooltips.set_tooltip_text(
self.redobutton,
"Redo an undone %s selection operation." % pixstring)
self.clearbutton = gtk.Button(stock=gtk.STOCK_CLEAR)
hbox.pack_start(self.clearbutton, expand=1, fill=0)
gtklogger.setWidgetName(self.clearbutton, "Clear")
gtklogger.connect(self.clearbutton, 'clicked', self.clearCB)
tooltips.set_tooltip_text(self.clearbutton,
"Unselect all %ss." % pixstring)
self.sbcallbacks = [
switchboard.requestCallbackMain(self.mswidget, self.mswidgetCB),
switchboard.requestCallbackMain('pixel selection changed',
self.selectionChanged),
switchboard.requestCallbackMain('modified pixel selection',
self.updateHistory),
switchboard.requestCallbackMain(
pixelselectionmod.SelectionModifier,
self.updateSelectionModifiers),
switchboard.requestCallbackMain(
('validity', self.selectionModFactory), self.validityChangeCB)
]
def __init__(self):
self.built = False
oofGUI.MainPage.__init__(self,
name="Boundary Analysis",
ordering=271,
tip="Examine the boundaries of the system.")
self.timeparam = placeholder.TimeParameter('time', value=0.0)
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,
callback=self.meshCB,
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)
align = gtk.Alignment(xalign=0.5)
mainbox.pack_start(align, expand=0, fill=0)
centerbox = gtk.HBox(spacing=3)
align.add(centerbox)
self.timeWidget = self.timeparam.makeWidget(scope=self)
centerbox.pack_start(gtk.Label("Time:"), expand=0, fill=0)
centerbox.pack_start(self.timeWidget.gtk, expand=0, fill=0)
mainpane = gtk.HPaned()
gtklogger.setWidgetName(mainpane, 'Pane')
mainbox.pack_start(mainpane, expand=1, fill=1)
gtklogger.connect_passive(mainpane, 'notify::position')
leftbox = gtk.VBox()
mainpane.pack1(leftbox, resize=1, shrink=0) # ??
boundarylistframe = gtk.Frame("Boundaries")
gtklogger.setWidgetName(boundarylistframe, 'frame')
boundarylistframe.set_shadow_type(gtk.SHADOW_IN)
leftbox.pack_start(boundarylistframe, expand=1, fill=1)
self.bdylist = chooser.ScrolledChooserListWidget(
callback=self.boundarylistCB,
dbcallback=self.doubleclickCB,
autoselect=1,
name="BoundaryList")
boundarylistframe.add(self.bdylist.gtk)
rightbox = gtk.VBox()
mainpane.pack2(rightbox, resize=1, shrink=0) # ??
analyzerframe = gtk.Frame("Boundary Operation")
analyzerframe.set_shadow_type(gtk.SHADOW_IN)
rightbox.pack_start(analyzerframe, expand=1, fill=1)
self.analysisWidget = regclassfactory.RegisteredClassFactory(
meshbdyanalysis.MeshBdyAnalyzer.registry,
scope=self,
name="BdyAnalyzerRCF")
analyzerframe.add(self.analysisWidget.gtk)
self.buildBottomRow(mainbox)
# hbox2 = gtk.HBox(homogeneous=True)
# namebox.pack_start(hbox2, expand=0, fill=0)
# self.create_button = gtkutils.StockButton(gtk.STOCK_NEW, 'Create...')
# hbox2.pack_start(self.create_button, expand=1, fill=1)
# gtklogger.setWidgetName(self.create_button, 'Set')
# gtklogger.connect(self.create_button, 'clicked', self.createCB)
# tooltips.set_tooltip_text(
# self.create_button,
# "Assign a name to the current analysis operation,"
# " so that it can be retrieved later.")
# self.retrieve_button = gtkutils.StockButton(gtk.STOCK_REFRESH,
# 'Retrieve...')
# hbox2.pack_start(self.retrieve_button, expand=1, fill=1)
# gtklogger.connect(self.retrieve_button, 'clicked', self.retrieveCB)
# tooltips.set_tooltip_text(self.retrieve_button,
# 'Retrieve a name analysis.')
# hbox3 = gtk.HBox(homogeneous=True)
# namebox.pack_start(hbox3, expand=0, fill=0)
# self.savenamed_button = gtkutils.StockButton(gtk.STOCK_SAVE_AS,
# 'Save...')
# hbox3.pack_start(self.savenamed_button, expand=1, fill=1)
# gtklogger.setWidgetName(self.savenamed_button, 'Save')
# gtklogger.connect(self.savenamed_button, 'clicked', self.savenamedCB)
# tooltips.set_tooltip_text(self.savenamed_button,
# 'Save definitions of named analyses to a file.')
# self.delete_button = gtkutils.StockButton(gtk.STOCK_DELETE, 'Delete...')
# hbox3.pack_start(self.delete_button, expand=1, fill=1)
# gtklogger.setWidgetName(self.delete_button, 'Delete')
# gtklogger.connect(self.delete_button, 'clicked', self.deleteCB)
# tooltips.set_tooltip_text(self.delete_button,
# "Delete a named analysis operation")
# # Destination
# destframe = gtk.Frame("Destination")
# destframe.set_shadow_type(gtk.SHADOW_IN)
# hbox.pack_start(destframe, expand=1, fill=1, padding=3)
# destbox = gtk.HBox()
# destframe.add(destbox)
# self.destwidget = outputdestinationwidget.TextDestinationWidget(
# name="Destination", framed=False)
# destbox.pack_start(self.destwidget.gtk, expand=1, fill=1, padding=2)
# # Go button
# self.gobutton = gtkutils.StockButton(gtk.STOCK_EXECUTE, "Go!")
# gtklogger.setWidgetName(self.gobutton, 'Go')
# gtklogger.connect(self.gobutton, "clicked", self.goCB)
# tooltips.set_tooltip_text(self.gobutton,
# "Send the output to the destination.")
# hbox.pack_end(self.gobutton, expand=1, fill=1, padding=2)
self.built = True
switchboard.requestCallbackMain(("new who", "Mesh"), self.newmeshCB)
switchboard.requestCallbackMain(("new who", "Skeleton"),
self.newskelCB)
switchboard.requestCallbackMain(self.meshwidget, self.meshwidgetCB)
switchboard.requestCallbackMain("mesh changed", self.meshchangedCB)
switchboard.requestCallbackMain(self.analysisWidget,
self.analysisWidgetCB)
switchboard.requestCallbackMain("new boundary created", self.newbdyCB)
switchboard.requestCallbackMain("boundary removed", self.newbdyCB)
switchboard.requestCallbackMain("boundary renamed", self.newbdyCB)
switchboard.requestCallbackMain("named boundary analyses changed",
self.analysesChangedCB)
switchboard.requestCallbackMain("retrieve boundary analysis",
self.retrieve_analysis)
switchboard.requestCallbackMain(('validity', self.timeWidget),
self.validityChangeCB)
switchboard.requestCallbackMain("mesh status changed",
self.meshchangedCB)
def __init__(self):
oofGUI.MainPage.__init__(self,
name="Pin Nodes",
ordering=120.1,
tip='Pin and unpin nodes')
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.skelwidget = whowidget.WhoWidget(whoville.getClass('Skeleton'),
callback=self.select_skeletonCB)
label = gtk.Label('Microstructure=')
label.set_alignment(1.0, 0.5)
centerbox.pack_start(label, expand=0, fill=0)
centerbox.pack_start(self.skelwidget.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.skelwidget.gtk[1], expand=0, fill=0)
mainpane = gtk.HPaned()
gtklogger.setWidgetName(mainpane, 'Pane')
mainbox.pack_start(mainpane, expand=1, fill=1)
gtklogger.connect_passive(mainpane, 'notify::position')
# Pinned nodes status in the left half of the main pane
pnsframe = gtk.Frame("Pinned Nodes Status")
pnsframe.set_shadow_type(gtk.SHADOW_IN)
self.datascroll = gtk.ScrolledWindow()
gtklogger.logScrollBars(self.datascroll, "StatusScroll")
pnsframe.add(self.datascroll)
self.datascroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
self.psdata = fixedwidthtext.FixedWidthTextView()
self.psdata.set_editable(False)
self.psdata.set_wrap_mode(gtk.WRAP_WORD)
self.psdata.set_cursor_visible(False)
self.datascroll.add_with_viewport(self.psdata)
mainpane.pack1(pnsframe, resize=1, shrink=0)
# Pin nodes method
modframe = gtk.Frame("Pin Nodes Methods")
gtklogger.setWidgetName(modframe, 'Modify')
modframe.set_shadow_type(gtk.SHADOW_IN)
modbox = gtk.VBox() # will have "methods" and "buttons"
modframe.add(modbox)
self.pinModFactory = regclassfactory.RegisteredClassFactory(
pinnodesmodifier.PinNodesModifier.registry,
title="Method:",
scope=self,
name="Method")
modbox.pack_start(self.pinModFactory.gtk, expand=1, fill=1, padding=2)
# buttons
hbox1 = gtk.HBox()
modbox.pack_start(hbox1, 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,
"Pin nodes with the selected method.")
self.undobutton = gtk.Button(stock=gtk.STOCK_UNDO)
gtklogger.setWidgetName(self.undobutton, 'Undo')
gtklogger.connect(self.undobutton, "clicked", self.undoCB)
tooltips.set_tooltip_text(self.undobutton, "Undo the latest action.")
self.redobutton = gtk.Button(stock=gtk.STOCK_REDO)
gtklogger.setWidgetName(self.redobutton, 'Redo')
gtklogger.connect(self.redobutton, "clicked", self.redoCB)
tooltips.set_tooltip_text(self.redobutton,
"Redo the latest undone action.")
hbox1.pack_start(self.undobutton, expand=0, fill=1, padding=2)
hbox1.pack_start(self.okbutton, expand=1, fill=1, padding=2)
hbox1.pack_end(self.redobutton, expand=0, fill=1, padding=2)
hbox2 = gtk.HBox(homogeneous=1)
modbox.pack_start(hbox2, expand=0, fill=0, padding=2)
self.unpinallbutton = gtk.Button("Unpin All")
gtklogger.setWidgetName(self.unpinallbutton, 'Unpin All')
gtklogger.connect(self.unpinallbutton, "clicked", self.unpinallCB)
tooltips.set_tooltip_text(self.unpinallbutton,
"Unpin all the pinned nodes.")
self.invertbutton = gtk.Button("Invert")
gtklogger.setWidgetName(self.invertbutton, 'Invert')
gtklogger.connect(self.invertbutton, "clicked", self.invertCB)
tooltips.set_tooltip_text(
self.invertbutton,
"Invert - pin the unpinned and unpin the pinned.")
hbox2.pack_start(self.unpinallbutton, expand=1, fill=1, padding=2)
hbox2.pack_start(self.invertbutton, expand=1, fill=1, padding=2)
mainpane.pack2(modframe, resize=0, shrink=0)
# Switchboard callbacks
switchboard.requestCallbackMain(('who changed', 'Skeleton'),
self.changeSkeleton)
switchboard.requestCallbackMain(('new who', 'Microstructure'),
self.newMS)
switchboard.requestCallbackMain("new pinned nodes",
self.newNodesPinned)
switchboard.requestCallbackMain(self.skelwidget, self.skel_update)
switchboard.requestCallbackMain("made reservation",
self.reservationChanged)
switchboard.requestCallbackMain("cancelled reservation",
self.reservationChanged)
def __init__(self):
oofGUI.MainPage.__init__(
self,
name="Analysis",
ordering=259,
tip="Query the mesh, examine fields and fluxes.")
self.timeparam = placeholder.TimeParameter('time', value=0.0)
mainbox = gtk.VBox()
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)
# The mesh widget callback is not required, because the field
# and flux widgets in the "output" widget (which are members
# of a parameter table, which is a component of the
# OutputWidget) are context-sensitive and update themselves
# automatically.
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)
centerbox = gtk.HBox(spacing=3)
align.add(centerbox)
self.timeWidget = self.timeparam.makeWidget(scope=self)
centerbox.pack_start(gtk.Label("Time:"), expand=0, fill=0)
centerbox.pack_start(self.timeWidget.gtk, expand=0, fill=0)
mainvpane = gtk.VPaned()
mainbox.pack_start(mainvpane, expand=1, fill=1)
self.topPane = gtk.HPaned()
gtklogger.setWidgetName(self.topPane, 'top')
mainvpane.pack1(self.topPane, resize=1, shrink=0)
self.btmPane = gtk.HPaned()
gtklogger.setWidgetName(self.btmPane, 'bottom')
mainvpane.pack2(self.btmPane, resize=1, shrink=0)
# The four panes (Output, Domain, Operation, and Sampling) are
# contained in the top and bottom HPaneds. The dividers
# between the sub panes are synchronized with each other.
# Since Paneds don't have a dedicated signal indicating that
# their dividers have been moved, we have to use the the
# generic 'notify' signal.
self.paneSignals = {
self.topPane:
gtklogger.connect(self.topPane, 'notify::position',
self.paneMovedCB, self.btmPane),
self.btmPane:
gtklogger.connect(self.btmPane, 'notify::position',
self.paneMovedCB, self.topPane)
}
# Output
self.outputframe = gtk.Frame(label="Output")
self.outputframe.set_shadow_type(gtk.SHADOW_IN)
output_scroll = gtk.ScrolledWindow()
gtklogger.logScrollBars(output_scroll, "Output")
output_scroll.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
self.outputframe.add(output_scroll)
output_box = gtk.VBox()
self.output_obj = outputwidget.ValueOutputParameterWidget(
value=None, scope=self, name="Outputs")
output_box.pack_start(self.output_obj.gtk, expand=0, fill=0)
output_scroll.add_with_viewport(output_box)
self.topPane.pack1(self.outputframe, resize=1, shrink=pshrink)
# Operation
self.operationframe = gtk.Frame(label="Operation")
self.operationframe.set_shadow_type(gtk.SHADOW_IN)
op_scroll = gtk.ScrolledWindow()
gtklogger.logScrollBars(op_scroll, "Operation")
op_scroll.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
self.op_obj = regclassfactory.RegisteredClassFactory(
analyze.DataOperation.registry,
scope=self,
name="OperationRCF",
callback=self.newOperationCB)
self.operationframe.add(op_scroll)
operation_box = gtk.VBox()
operation_box.pack_start(self.op_obj.gtk, expand=0, fill=0)
op_scroll.add_with_viewport(operation_box)
self.btmPane.pack1(self.operationframe, resize=1, shrink=pshrink)
# Domain
self.domainframe = gtk.Frame(label="Domain")
self.domainframe.set_shadow_type(gtk.SHADOW_IN)
dom_scroll = gtk.ScrolledWindow()
gtklogger.logScrollBars(dom_scroll, "Domain")
dom_scroll.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
self.domain_obj = regclassfactory.RegisteredClassFactory(
analysisdomain.Domain.registry,
scope=self,
name="DomainRCF",
callback=self.newDomainCB)
self.domainframe.add(dom_scroll)
dom_scroll.add_with_viewport(self.domain_obj.gtk)
self.topPane.pack2(self.domainframe, resize=1, shrink=pshrink)
# Sampling. The SampleRCF class uses the WidgetScope
# mechanism to find the Operation and Domain widgets, so that
# it can display only the relevant SampleSet classes.
self.sampleframe = gtk.Frame(label="Sampling")
self.sampleframe.set_shadow_type(gtk.SHADOW_IN)
sam_scroll = gtk.ScrolledWindow()
gtklogger.logScrollBars(sam_scroll, "Sampling")
sam_scroll.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
self.sample_obj = sampleregclassfactory.SampleRCF(
scope=self, name="Sampling", callback=self.newSampleCB)
self.sampleframe.add(sam_scroll)
sam_scroll.add_with_viewport(self.sample_obj.gtk)
self.btmPane.pack2(self.sampleframe, resize=1, shrink=pshrink)
self.buildBottomRow(mainbox)
# Whenever fields or fluxes are defined or undefined on the
# mesh, we need to update the output object widget, and
# possibly invalidate the currently-displayed data, once we
# start displaying data.
switchboard.requestCallbackMain(("new who", "Mesh"), self.new_mesh)
switchboard.requestCallbackMain(("new who", "Skeleton"), self.new_skel)
switchboard.requestCallbackMain(self.timeWidget,
self.sensitize_widgets)
switchboard.requestCallbackMain(self.domain_obj,
self.sensitize_widgets)
switchboard.requestCallbackMain(self.op_obj, self.sensitize_widgets)
switchboard.requestCallbackMain(self.output_obj,
self.sensitize_widgets)
switchboard.requestCallbackMain(self.destwidget,
self.sensitize_widgets)
switchboard.requestCallbackMain("named analyses changed",
self.analysesChanged)
switchboard.requestCallbackMain("mesh status changed",
self.sensitize_widgets)
switchboard.requestCallbackMain(self.domain_obj,
self.setNamedAnalysisChooser)
switchboard.requestCallbackMain(self.op_obj,
self.setNamedAnalysisChooser)
switchboard.requestCallbackMain(self.output_obj,
self.setNamedAnalysisChooser)
switchboard.requestCallbackMain(self.sample_obj,
self.setNamedAnalysisChooser)
def __init__(self, toolbox, method):
debug.mainthreadTest()
toolboxGUI.GfxToolbox.__init__(self, toolbox)
self.method = method # RegisteredClass of selection methods
self.currentGUI = None
self.currentMouseHandler = mousehandler.nullHandler
outerbox = gtk.VBox(spacing=2)
self.gtk.add(outerbox)
# Create an instance of each SelectionMethod's
# SelectionMethodGUI and store it in a dictionary keyed by the
# method's registration.
self.methodGUIs = {
reg.subclass: reg.gui(self)
for reg in method.registry if hasattr(reg, 'gui')
}
self.selectionMethodFactory = regclassfactory.RegisteredClassFactory(
method.registry,
title="Method:",
name="Method",
scope=self,
callback=self.changedSelectionMethod,
widgetdict=self.methodGUIs)
outerbox.pack_start(self.selectionMethodFactory.gtk, expand=1, fill=1)
# Undo, Redo, Clear, and Invert buttons. The callbacks for
# these have to be defined in the derived classes.
hbox = gtk.HBox(homogeneous=True, spacing=2)
outerbox.pack_start(hbox, expand=0, fill=0)
self.undobutton = gtk.Button(stock=gtk.STOCK_UNDO)
self.redobutton = gtk.Button(stock=gtk.STOCK_REDO)
hbox.pack_start(self.undobutton, expand=1, fill=1)
hbox.pack_start(self.redobutton, expand=1, fill=1)
gtklogger.setWidgetName(self.undobutton, "Undo")
gtklogger.setWidgetName(self.redobutton, "Redo")
gtklogger.connect(self.undobutton, 'clicked', self.undoCB)
gtklogger.connect(self.redobutton, 'clicked', self.redoCB)
tooltips.set_tooltip_text(self.undobutton,
"Undo the previous selection operation.")
tooltips.set_tooltip_text(self.redobutton,
"Redo an undone selection operation.")
self.clearbutton = gtk.Button(stock=gtk.STOCK_CLEAR)
gtklogger.setWidgetName(self.clearbutton, "Clear")
hbox.pack_start(self.clearbutton, expand=1, fill=1)
gtklogger.connect(self.clearbutton, 'clicked', self.clearCB)
tooltips.set_tooltip_text(self.clearbutton, "Unselect all objects.")
self.invertbutton = gtk.Button('Invert')
gtklogger.setWidgetName(self.invertbutton, "Invert")
hbox.pack_start(self.invertbutton, expand=1, fill=1)
gtklogger.connect(self.invertbutton, 'clicked', self.invertCB)
tooltips.set_tooltip_text(
self.invertbutton,
"Select all unselected objects, and deselect all selected objects."
)
# Selection information
hbox = gtk.HBox()
outerbox.pack_start(hbox, expand=0, fill=0)
hbox.pack_start(gtk.Label('Selection size: '), expand=0, fill=0)
self.sizetext = gtk.Entry()
gtklogger.setWidgetName(self.sizetext, 'size')
hbox.pack_start(self.sizetext, expand=1, fill=1)
self.sizetext.set_editable(False)
self.sizetext.set_size_request(12 * guitop.top().digitsize, -1)
self.setInfo()
# switchboard callbacks
self.sbcallbacks = [
switchboard.requestCallbackMain(method,
self.updateSelectionMethods),
switchboard.requestCallback((self.gfxwindow(), 'layers changed'),
self.setInfo_subthread),
switchboard.requestCallbackMain(
(self.gfxwindow(), 'layers changed'), self.layerChangeCB)
]
# Make sure that the initial state is self-consistent
self.changedSelectionMethod(
self.selectionMethodFactory.getRegistration())
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()
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)
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
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)
