def __init__(self, set_callback, ok_callback):
debug.mainthreadTest()
self.gtk = gtk.HBox()
self.set_callback = set_callback
self.historian = historian.Historian(self.setCB,
self.sensitize)
# Buttons: Previous, OK, and next.
self.prevbutton = gtkutils.prevButton()
gtklogger.connect(self.prevbutton, "clicked", self.historian.prevCB)
tooltips.set_tooltip_text(self.prevbutton,
"Recall the previous selection modification operation.")
self.gtk.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", ok_callback)
self.gtk.pack_start(self.okbutton, expand=1, fill=1, padding=2)
tooltips.set_tooltip_text(self.okbutton,
"Perform the selection modification operation.")
self.okbutton.set_sensitive(0)
self.nextbutton = gtkutils.nextButton()
gtklogger.connect(self.nextbutton, "clicked", self.historian.nextCB)
tooltips.set_tooltip_text(self.nextbutton,
"Recall the next selection modification operation.")
self.gtk.pack_start(self.nextbutton, expand=0, fill=0, padding=2)
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 __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):
debug.mainthreadTest()
widgetscope.WidgetScope.__init__(self, None)
self.gtk = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.gtk.set_title(oofname)
initial_width, initial_height = map(int,
runtimeflags.geometry.split('x'))
self.gtk.set_default_size(initial_width, initial_height)
gtklogger.newTopLevelWidget(self.gtk, oofname)
gtklogger.connect(self.gtk, "delete-event", self.deleteEventCB)
gtklogger.connect_passive(self.gtk, "configure-event")
self.gtk.connect("destroy", self.destroyCB)
guitop.setTop(self)
self.mainbox = gtk.VBox()
self.gtk.add(self.mainbox)
self.menubar = gtk.MenuBar()
self.mainbox.pack_start(self.menubar, expand=0, fill=0)
accelgrp = gtk.AccelGroup()
self.gtk.add_accel_group(accelgrp)
self.mainmenu = mainmenu.OOF
self.oofmenu = gfxmenu.gtkOOFMenuBar(self.mainmenu,
bar=self.menubar,
accelgroup=accelgrp)
gtklogger.setWidgetName(self.oofmenu, "MenuBar")
self.pageChooserFrame = gtk.Frame()
self.pageChooserFrame.set_shadow_type(gtk.SHADOW_IN)
self.mainbox.pack_start(self.pageChooserFrame,
expand=0,
fill=0,
padding=2)
align = gtk.Alignment(xalign=0.5)
self.pageChooserFrame.add(align)
chooserBox = gtk.HBox()
chooserBox.set_border_width(2)
gtklogger.setWidgetName(chooserBox, 'Navigation')
align.add(chooserBox)
self.historian = historian.Historian(self.historianCB,
self.sensitizeHistory)
label = gtk.Label('Task: ')
label.set_alignment(1.0, 0.5)
chooserBox.pack_start(label, expand=0, fill=0)
self.prevHistoryButton = gtkutils.StockButton(gtk.STOCK_GOTO_FIRST)
chooserBox.pack_start(self.prevHistoryButton,
expand=0,
fill=0,
padding=3)
gtklogger.setWidgetName(self.prevHistoryButton, 'PrevHist')
gtklogger.connect(self.prevHistoryButton, 'clicked',
self.historian.prevCB)
tooltips.set_tooltip_text(
self.prevHistoryButton,
"Go to the chronologically previously page.")
self.prevPageButton = gtkutils.StockButton(gtk.STOCK_GO_BACK)
chooserBox.pack_start(self.prevPageButton, expand=0, fill=0, padding=3)
gtklogger.setWidgetName(self.prevPageButton, 'Prev')
gtklogger.connect(self.prevPageButton, 'clicked', self.prevPageCB)
self.pageChooser = chooser.ChooserWidget([],
callback=self.pageChooserCB,
name="PageMenu")
chooserBox.pack_start(self.pageChooser.gtk, expand=0, fill=0)
self.currentPageName = None
self.nextPageButton = gtkutils.StockButton(gtk.STOCK_GO_FORWARD)
chooserBox.pack_start(self.nextPageButton, expand=0, fill=0, padding=3)
gtklogger.setWidgetName(self.nextPageButton, 'Next')
gtklogger.connect(self.nextPageButton, 'clicked', self.nextPageCB)
self.nextHistoryButton = gtkutils.StockButton(gtk.STOCK_GOTO_LAST)
chooserBox.pack_start(self.nextHistoryButton,
expand=0,
fill=0,
padding=3)
gtklogger.setWidgetName(self.nextHistoryButton, 'NextHist')
gtklogger.connect(self.nextHistoryButton, 'clicked',
self.historian.nextCB)
tooltips.set_tooltip_text(self.nextHistoryButton,
"Go to the chronologically next page.")
# Find the font size, so widgets can be sized appropriately.
# digitsize and charsize are in pixels.
self.digitsize, self.charsize = gtkutils.widgetFontSizes(self.gtk)
# Add a GUI callback to the "OOF2" or "OOF3D" windows item.
oof_item = getattr(self.mainmenu.Windows, oofname)
oof_item.add_gui_callback(self.menu_raise)
# Frame around main pages. GUI pages are added and removed
# from it by installPage().
self.pageframe = gtk.Frame()
self.pageframe.set_shadow_type(gtk.SHADOW_IN)
self.mainbox.pack_start(self.pageframe, expand=1, fill=1)
# Add pages that may have been created before the main GUI was built.
for pagename, i in zip(pagenames, range(len(allPages))):
self.addPage(allPages[pagename], i)
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, name, toolbox, method):
debug.mainthreadTest()
toolboxGUI.GfxToolbox.__init__(self, name, toolbox)
self.method = method # RegisteredClass of selection methods
self.points = [] # locations of mouse events
# Was a modifier key pressed during the last button event?
self.shift = 0
self.ctrl = 0
outerbox = gtk.VBox(spacing=2)
self.gtk.add(outerbox)
## scroll = gtk.ScrolledWindow()
## scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
## outerbox.pack_start(scroll, expand=1, fill=1)
# Retrieve the registered class factory from the subclass.
self.selectionMethodFactory = self.methodFactory()
# self.selectionMethodFactory = regclassfactory.RegisteredClassFactory(
# method.registry, title="Method:", name="Method")
## scroll.add_with_viewport(self.selectionMethodFactory.gtk)
outerbox.pack_start(self.selectionMethodFactory.gtk, expand=1, fill=1)
self.historian = historian.Historian(self.setHistory,
self.sensitizeHistory)
self.selectionMethodFactory.set_callback(self.historian.stateChangeCB)
# 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 history
frame = gtk.Frame('History')
frame.set_shadow_type(gtk.SHADOW_IN)
outerbox.pack_start(frame, expand=0, fill=0)
vbox = gtk.VBox()
frame.add(vbox)
table = gtk.Table(rows=2, columns=3)
vbox.pack_start(table, expand=0, fill=0)
table.attach(gtk.Label('down'), 0,1, 0,1, xoptions=0, yoptions=0)
table.attach(gtk.Label('up'), 0,1, 1,2, xoptions=0, yoptions=0)
self.xdownentry = gtk.Entry()
self.ydownentry = gtk.Entry()
self.xupentry = gtk.Entry()
self.yupentry = gtk.Entry()
gtklogger.setWidgetName(self.xdownentry, 'xdown')
gtklogger.setWidgetName(self.ydownentry, 'ydown')
gtklogger.setWidgetName(self.xupentry, 'xup')
gtklogger.setWidgetName(self.yupentry, 'yup') # yessirree, Bob!
entries = [self.xdownentry, self.ydownentry, self.xupentry, self.yupentry]
if config.dimension() == 3:
self.zdownentry = gtk.Entry()
self.zupentry = gtk.Entry()
gtklogger.setWidgetName(self.zdownentry, 'zdown')
gtklogger.setWidgetName(self.zdownentry, 'zup')
entries.append(self.zdownentry)
entries.append(self.zupentry)
self.entrychangedsignals = []
for entry in entries:
entry.set_size_request(12*guitop.top().digitsize, -1)
self.entrychangedsignals.append(
gtklogger.connect(entry, "changed", self.poschanged))
table.attach(self.xdownentry, 1,2, 0,1)
table.attach(self.ydownentry, 2,3, 0,1)
table.attach(self.xupentry, 1,2, 1,2)
table.attach(self.yupentry, 2,3, 1,2)
if config.dimension() == 3:
table.attach(self.zdownentry, 3,4, 0,1)
table.attach(self.zupentry, 3,4, 1,2)
hbox = gtk.HBox(spacing=2)
vbox.pack_start(hbox, expand=0, fill=0)
self.prevmethodbutton = gtkutils.prevButton()
self.repeatbutton = gtkutils.StockButton(gtk.STOCK_REFRESH, 'Repeat')
gtklogger.setWidgetName(self.repeatbutton, 'Repeat')
self.nextmethodbutton = gtkutils.nextButton()
hbox.pack_start(self.prevmethodbutton, expand=0, fill=0)
hbox.pack_start(self.repeatbutton, expand=1, fill=0)
hbox.pack_start(self.nextmethodbutton, expand=0, fill=0)
gtklogger.connect(self.repeatbutton, 'clicked', self.repeatCB)
gtklogger.connect(self.repeatbutton, 'button-release-event',
self.repeateventCB)
gtklogger.connect(self.prevmethodbutton, 'clicked',
self.historian.prevCB)
gtklogger.connect(self.nextmethodbutton, 'clicked',
self.historian.nextCB)
tooltips.set_tooltip_text(self.prevmethodbutton,
"Recall the settings and mouse coordinates for the previous selection method.")
tooltips.set_tooltip_text(self.nextmethodbutton,
"Recall the settings and mouse coordinates for the next selection method.")
tooltips.set_tooltip_text(self.repeatbutton,
"Execute the selection method as if the mouse had been clicked at the above coordinates. Hold the shift key to retain the previous selection. Hold the control key to toggle the selection state of the selected pixels.")
# 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.toolbox.gfxwindow(),
'layers changed'),
self.setInfo_subthread)
]
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()
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)
