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