def __init__(self, params, kset, scope=None, name=None): debug.mainthreadTest() self.params = params self.kset = kset SymmetricMatrixInput.__init__(self, 'C', 6, 6, value=None, scope=scope, name=name) # # Make default blocks according to the kset dictionary. for (k, f) in self.floats.items(): if k in self.kset: pass else: f.gtk.set_editable(0) f.gtk.set_sensitive(0) # # Connect the "obvious" callbacks. Child classes may add # additional callbacks. for k in self.kset: # "activate" needs a dummy argument for the "event" slot. gtklogger.connect(self.floats[k].gtk, "activate", self.new_c, None) gtklogger.connect(self.floats[k].gtk, "focus_out_event", self.new_c)
def __init__(self, params, scope=None, name=None, verbose=False): debug.mainthreadTest() kset = { (0, 0): 'c11', (0, 1): 'c12', (0, 2): 'c13', (2, 2): 'c33', (3, 3): 'c44', (0, 3): 'c14' } AnisoWidgetBase.__init__(self, params, kset, scope=scope, name=name, verbose=verbose) # self.widgets[(5, 5)].gtk.set_editable(1) self.widgets[(5, 5)].gtk.set_sensitive(1) # gtklogger.connect(self.widgets[(5, 5)].gtk, "activate", self.new_c66, None) gtklogger.connect(self.widgets[(5, 5)].gtk, "focus_out_event", self.new_c66) # self.set_values()
def __init__(self, progress): debug.mainthreadTest() self.lock = lock.Lock() progressbar.ProgressBar.__init__(self, progress) self.dismissable = False progress.setProgressBar(self) self.gtk = gtk.Frame() self.gtk.set_shadow_type(gtk.SHADOW_IN) vbox = gtk.VBox(spacing=2) self.gtk.add(vbox) hbox = gtk.HBox(spacing=2) vbox.pack_start(hbox, expand=0, fill=0, padding=2) self.gtkprogressbar = gtk.ProgressBar() self.gtkprogressbar.set_orientation(gtk.PROGRESS_LEFT_TO_RIGHT) hbox.pack_start(self.gtkprogressbar, expand=1, fill=1) self.stopbutton = gtkutils.StockButton(gtk.STOCK_STOP, "Stop") gtklogger.setWidgetName(self.stopbutton, "Stop%d" % self.idcounter) self.idcounter += 1 gtklogger.connect(self.stopbutton, "clicked", self.stopButtonCB) hbox.pack_start(self.stopbutton, expand=0, fill=0) self.timeout_id = None
def __init__(self, table, row, parent): self.deleteButton = gtk.Button('-') table.attach(self.deleteButton, 0,1, row+1,row+2, xoptions=gtk.FILL, yoptions=0, xpadding=0, ypadding=0) gtklogger.setWidgetName(self.deleteButton, 'Delete%d' % row) gtklogger.connect(self.deleteButton, 'clicked', parent.deleteRowCB, row) tooltips.set_tooltip_text(self.deleteButton, "Delete this group definition.") self.colEntry = gtk.Entry() table.attach(self.colEntry, 1,2, row+1,row+2, xoptions=0, yoptions=0, xpadding=0, ypadding=0) self.colSignal = gtklogger.connect(self.colEntry, 'changed', parent.changedCB) gtklogger.setWidgetName(self.colEntry, 'Column%d' % row) tooltips.set_tooltip_text( self.colEntry, 'A column number. Points in the data file with different ' 'values in this column will be assigned to different pixel groups.' ) self.nameEntry = gtk.Entry() self.nameEntry.set_text('group_%s') table.attach(self.nameEntry, 2,3, row+1,row+2, xoptions=gtk.FILL|gtk.EXPAND, yoptions=0, xpadding=0, ypadding=0) self.nameSignal = gtklogger.connect(self.nameEntry, 'changed', parent.changedCB) gtklogger.setWidgetName(self.nameEntry, 'Name%d' % row) tooltips.set_tooltip_text( self.nameEntry, 'The name to assign to the group. A "%s" in the name ' 'will be replaced by the contents of the column.' )
def __init__(self, toolbox): # The 'toolbox' argument here is the non-gui toolbox # corresponding to one of the inner toolboxes. It doesn't # matter which one. toolboxGUI.GfxToolbox.__init__(self, "Skeleton Selection", toolbox) vbox = gtk.VBox(spacing=2) self.gtk.add(vbox) bbox = gtk.HBox(spacing=2) gtklogger.setWidgetName(bbox, "Select") vbox.pack_start(bbox, expand=0, fill=0) bbox.pack_start(gtk.Label("Select: "), expand=0, fill=0) self.tbbox = gtk.Frame() # holds SkeletonSelectionToolboxModes vbox.pack_start(self.tbbox, expand=1, fill=1) group = None self.tbdict = {} for mode in skeletonselmodebase.SkeletonSelectionMode.modes: if group: button = gtk.RadioButton(label=mode.name, group=group) else: button = gtk.RadioButton(label=mode.name) group = button bbox.pack_start(button, expand=0, fill=0) gtklogger.setWidgetName(button, mode.name) gtklogger.connect(button, 'clicked', self.switchModeCB, mode.name) ## Get the actual toolbox for each mode. tb = self.gfxwindow().getToolboxByName(mode.toolboxName()) tbgui = SkeletonSelectionToolboxModeGUI(mode, tb) self.tbdict[mode.name] = tbgui self.activecallbacks = [] self.currentMode = None
def __init__(self): oofGUI.MainPage.__init__(self, name="Introduction", ordering=0, tip="Welcome to %s!" % name) vbox = gtk.VBox() self.gtk.add(vbox) scroll = gtk.ScrolledWindow() gtklogger.logScrollBars(scroll, "Scroll") scroll.set_policy(gtk.POLICY_NEVER, gtk.POLICY_ALWAYS) vbox.pack_start(scroll, expand=1, fill=1) self.textarea = fixedwidthtext.FixedWidthTextView() scroll.set_shadow_type(gtk.SHADOW_IN) scroll.add(self.textarea) self.textarea.set_editable(0) self.textarea.set_cursor_visible(0) self.textarea.set_wrap_mode(gtk.WRAP_WORD) buttonbox = gtk.HBox(homogeneous=1, spacing=2) buttonbox.set_border_width(2) vbox.pack_start(buttonbox, expand=0, fill=0) self.labels = ['Welcome', 'Credits', 'Copyright', 'Disclaimer'] self.buttons = [gtk.ToggleButton(x) for x in self.labels] for button, label in zip(self.buttons, self.labels): buttonbox.pack_start(button, expand=1, fill=1) gtklogger.setWidgetName(button, label) gtklogger.connect(button, 'clicked', self.buttonCB, label) self.buttons[0].set_active(1)
def __init__(self, namelist, callback=None, callbackargs=(), update_callback=None, update_callback_args=(), button_callback=None, button_callback_args=(), buttontext="New...", separator_func=None): ChooserWidget.__init__(self, namelist, callback=callback, callbackargs=callbackargs, update_callback=update_callback, update_callback_args=update_callback_args, helpdict={}, separator_func=separator_func) self.button_callback = button_callback self.button_callback_args = button_callback_args # Wrap the ChooserWidget's gtk in a GtkHBox and make it become self.gtk hbox = gtk.HBox() hbox.pack_start(self.gtk, expand=1, fill=1, padding=2) self.gtk = hbox self.newbutton = gtk.Button(buttontext) hbox.pack_start(self.newbutton, expand=0, fill=0, padding=2) gtklogger.connect(self.newbutton, 'clicked', self.newbuttonCB)
def __init__(self): oofGUI.MainPage.__init__(self, name="Introduction", ordering=0, tip="Welcome to %s!"%name) vbox = gtk.VBox() self.gtk.add(vbox) scroll = gtk.ScrolledWindow() gtklogger.logScrollBars(scroll, "Scroll") scroll.set_policy(gtk.POLICY_NEVER, gtk.POLICY_ALWAYS) vbox.pack_start(scroll, expand=1, fill=1) self.textarea = fixedwidthtext.FixedWidthTextView() scroll.set_shadow_type(gtk.SHADOW_IN) scroll.add(self.textarea) self.textarea.set_editable(0) self.textarea.set_cursor_visible(0) self.textarea.set_wrap_mode(gtk.WRAP_WORD) buttonbox = gtk.HBox(homogeneous=1, spacing=2) buttonbox.set_border_width(2) vbox.pack_start(buttonbox, expand=0, fill=0) self.labels = ['Welcome', 'Credits', 'Copyright', 'Disclaimer'] self.buttons = [gtk.ToggleButton(x) for x in self.labels] for button, label in zip(self.buttons, self.labels): buttonbox.pack_start(button, expand=1, fill=1) gtklogger.setWidgetName(button, label) gtklogger.connect(button, 'clicked', self.buttonCB, label) self.buttons[0].set_active(1)
def __init__(self, params, scope=None, name=None, verbose=False): debug.mainthreadTest() kset = { (0, 0): 'c11', (0, 1): 'c12', (0, 2): 'c13', (2, 2): 'c33', (3, 3): 'c44' } AnisoWidgetBase.__init__(self, params, kset, scope=scope, name=name, verbose=verbose) # # Base class will have blocked c66, so unblock it. self.floats[(5, 5)].gtk.set_editable(1) self.floats[(5, 5)].gtk.set_sensitive(1) # ... and connect a special callback. gtklogger.connect(self.floats[(5, 5)].gtk, "activate", self.new_c66, None) gtklogger.connect(self.floats[(5, 5)].gtk, "focus_out_event", self.new_c66) # self.set_values()
def __init__(self, progress): debug.mainthreadTest() self.lock = lock.Lock() progressbar.ProgressBar.__init__(self, progress) self.dismissable = False progress.setProgressBar(self) self.gtk = gtk.Frame() self.gtk.set_shadow_type(gtk.SHADOW_IN) vbox = gtk.VBox(spacing=2) self.gtk.add(vbox) hbox = gtk.HBox(spacing=2) vbox.pack_start(hbox, expand=0, fill=0, padding=2) self.gtkprogressbar = gtk.ProgressBar() self.gtkprogressbar.set_orientation(gtk.PROGRESS_LEFT_TO_RIGHT) hbox.pack_start(self.gtkprogressbar, expand=1, fill=1) self.stopbutton = gtkutils.StockButton(gtk.STOCK_STOP, "Stop") gtklogger.setWidgetName(self.stopbutton, "Stop%d" % self.idcounter) self.idcounter += 1 gtklogger.connect(self.stopbutton, 'clicked', self.stopButtonCB) hbox.pack_start(self.stopbutton, expand=0, fill=0) self.timeout_id = None
def __init__(self, param, scope=None, name=None): ParameterWidget.__init__(self, gtk.HBox(), scope=scope, name=name) self.autocheck = gtk.CheckButton() gtklogger.setWidgetName(self.autocheck, 'Auto') self.text = gtk.Entry() gtklogger.setWidgetName(self.text, 'Text') self.gtk.pack_start(self.autocheck, expand=0, fill=0) self.gtk.pack_start(self.text, expand=1, fill=1) gtklogger.connect(self.autocheck, "clicked", self.checkCB) self.textsignal = gtklogger.connect(self.text, 'changed', self.entryCB)
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, param, scope=None, name=None): debug.mainthreadTest() MatrixInput.__init__(self, 3, 6, value=None, scope=scope, name=name) for (k, f) in self.widgets.items(): if k not in self.excluded: f.gtk.set_editable(0) f.gtk.set_sensitive(0) else: gtklogger.connect(f.gtk, "activate", self.new_value, None) gtklogger.connect(f.gtk, "focus_out_event", self.new_value) self.set_values(param.value)
def __init__(self, param, scope=None, name=None): debug.mainthreadTest() MatrixInput.__init__(self, "", 3,6, value=None, scope=scope, name=name) for (k,f) in self.floats.items(): if k not in self.excluded: f.gtk.set_editable(0) f.gtk.set_sensitive(0) else: gtklogger.connect(f.gtk, "activate", self.new_value, None) gtklogger.connect(f.gtk, "focus_out_event", self.new_value) self.set_values(param.value)
def __init__(self, param, scope=None, name=None, verbose=False): debug.mainthreadTest() SymmetricMatrixInput.__init__(self,"",3,3,value=None,scope=scope, name=name, verbose=verbose) for (k,f) in self.floats.items(): if k not in self.settable: f.gtk.set_editable(0) f.gtk.set_sensitive(0) else: gtklogger.connect(f.gtk, "activate", self.new_value, None) gtklogger.connect(f.gtk, "focus_out_event", self.new_value) self.set_values(param.value)
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, param, scope=None, name=None): debug.mainthreadTest() MatrixInput.__init__(self,"",3,6,value=None,scope=scope,name=name) for i in range(3): for j in range(6): gtklogger.connect(self.floats[(i, j)].gtk, "activate", self.new_value, None) gtklogger.connect(self.floats[(i, j)].gtk, "focus_out_event", self.new_value) self.set_values(param.value)
def __init__(self, param, scope=None, name=None): debug.mainthreadTest() MatrixInput.__init__(self, 3, 6, value=None, scope=scope, name=name) for i in range(3): for j in range(6): gtklogger.connect(self.widgets[(i, j)].gtk, "activate", self.new_value, None) gtklogger.connect(self.widgets[(i, j)].gtk, "focus_out_event", self.new_value) self.set_values(param.value)
def __init__(self, mode, title=None, filename=None, params=None, pattern=False): debug.mainthreadTest() widgetscope.WidgetScope.__init__(self, None) self.dialog = gtklogger.Dialog() self.set_title(title) gtklogger.newTopLevelWidget(self.dialog, self.dialog.get_title()) self.filechooser = gtk.FileChooserWidget(action=_modes[mode]) self.dialog.set_default_size(500, 300) self.filechooser.show() self.dialog.vbox.pack_start(self.filechooser, expand=1, fill=1) gtklogger.setWidgetName(self.filechooser, "FileChooser") gtklogger.connect(self.filechooser, 'selection-changed', self.selectionchangedCB) self.dialog.add_button(gtk.STOCK_OK, self.OK) self.dialog.add_button(gtk.STOCK_CANCEL, self.CANCEL) self.dialog.set_default_response(self.OK) self.pattern = (pattern and (mode=='r')) if self.pattern: # TODO: Fix aesthetics of the widgets. self.filechooser.set_select_multiple(True) self.patternrow = gtk.HBox() self.patternrow.pack_start(gtk.Label("Pattern: "), expand=0, fill=0, padding=5) self.pattern_entry = gtk.Entry() self.pattern_entry.set_editable(1) self.pattern_entry.set_text("*") gtklogger.connect(self.pattern_entry, 'changed', self.patternchangedCB) self.patternrow.pack_start(self.pattern_entry, expand=1, fill=1, padding=5) self.patternrow.show_all() if params is None: self.table = None if self.pattern: self.filechooser.set_extra_widget(self.patternrow) else: self.table = parameterwidgets.ParameterTable(params, scope=self, name="Parameters") self.sbcallback = switchboard.requestCallbackMain( ('validity', self.table), self.validityCB) if not self.pattern: self.filechooser.set_extra_widget(self.table.gtk) else: vbox = gtk.VBox() vbox.pack_start(self.patternrow) vbox.pack_start(self.table.gtk) vbox.show() self.filechooser.set_extra_widget(vbox) if filename is not None: self.filechooser.set_current_name(filename)
def __init__(self, params, scope=None, name=None): debug.mainthreadTest() kset = {(0,0): 'c11', (0,1): 'c12', (0,2): 'c13', (2,2): 'c33', (3,3): 'c44', (0,3): 'c14' } AnisoWidgetBase.__init__(self, params, kset, scope=scope, name=name) # self.floats[(5,5)].gtk.set_editable(1) self.floats[(5,5)].gtk.set_sensitive(1) # gtklogger.connect(self.floats[(5,5)].gtk, "activate", self.new_c66, None) gtklogger.connect(self.floats[(5,5)].gtk, "focus_out_event", self.new_c66) # self.set_values()
def __init__(self, param, scope=None, name=None, compact=False): debug.mainthreadTest() if param.value: labelstr = 'true' else: labelstr = 'false' self.label = gtk.Label(labelstr) ParameterWidget.__init__(self, gtk.Frame(), scope=scope, compact=compact) if not compact: self.button = gtk.CheckButton() self.button.add(self.label) self.gtk.add(self.button) else: self.button = gtk.ToggleButton() align = gtk.Alignment(xalign=0.5, xscale=0.0) align.add(self.button) self.gtk.add(align) # name is assigned to the button, not the frame, because it's # the button that gets connected. gtklogger.setWidgetName(self.button, name) self.signal = gtklogger.connect(self.button, 'clicked', self.buttonCB) self.set_value(param.value)
def _CheckOOFMenuItem_construct_gui(self, base, parent_menu, accelgroup): debug.mainthreadTest() new_gtkitem = gtk.CheckMenuItem() new_gtkitem.add(self.gtklabel(new_gtkitem)) gtklogger.setWidgetName(new_gtkitem, self.name) try: self.gtkitem.append(new_gtkitem) except AttributeError: self.gtkitem = [new_gtkitem] new_gtkitem.connect("destroy", self.gtkitem_destroyed) # Set the state of the button. This calls the callback, so we do # it here before the callback is connected. new_gtkitem.set_active(self.value) if self.accel is not None and accelgroup is not None: new_gtkitem.add_accelerator('activate', accelgroup, ord(self.accel), gtk.gdk.MOD1_MASK, gtk.ACCEL_VISIBLE) # Handler IDs are added in the same order as items, so there # is item-for-item correspondence of the lists. new_handler = gtklogger.connect(new_gtkitem, 'activate', CheckMenuCallBackWrapper(self)) try: self.handlerid.append(new_handler) except AttributeError: self.handlerid = [new_handler] if not self.enabled(): new_gtkitem.set_sensitive(0) parent_menu.insert(new_gtkitem, self.gui_order())
def build_eqnTable(self): debug.mainthreadTest() self.eqntable.foreach(gtk.Object.destroy) # clear the table self.eqnbuttons = {} eqlist = equation.allEquations self.eqntable.resize(len(eqlist), 3) row = 0 for eqn in eqlist: label = gtk.Label(utils.underscore2space(eqn.name())) label.set_alignment(1.0, 0.5) self.eqntable.attach(label, 0, 1, row, row + 1, xoptions=gtk.FILL, yoptions=0) button = gtk.CheckButton('active') gtklogger.setWidgetName(button, eqn.name() + " active") signal = gtklogger.connect(button, 'clicked', self.eqnButtonCB, eqn) self.eqnbuttons[(eqn.name(), "active")] = ButtonSignal(button, signal) tooltips.set_tooltip_text(button, 'Active equations will be solved.') self.eqntable.attach(button, 2, 3, row, row + 1, xoptions=0, yoptions=0) ## Moved to time dependence page # if eqn.get_kinetic()>0 and config.devel()>=1: # button = gtk.CheckButton('kinetic') # gtklogger.setWidgetName(button, eqn.name() + " kinetic") # signal = gtklogger.connect(button, 'clicked', self.eqnKineticCB, # eqn) # self.eqnbuttons[(eqn.name(), "kinetic")] = ButtonSignal(button, # signal) # self.eqntable.attach(button, 3,4, row, row+1, # xoptions=0, yoptions=0) # if eqn.get_dynamics()>0 and config.devel()>=1: # button = gtk.CheckButton('dynamic') # gtklogger.setWidgetName(button, eqn.name() + " dynamic") # signal = gtklogger.connect(button, 'clicked', # self.eqnDynamicCB, eqn) # self.eqnbuttons[(eqn.name(), "dynamic")] = ButtonSignal(button, # signal) # self.eqntable.attach(button, 4,5, row, row+1, # xoptions=0, yoptions=0) row += 1 self.eqntable.attach(gtk.VSeparator(), 1, 2, 0, len(eqlist), xoptions=0, yoptions=gtk.EXPAND | gtk.FILL) self.eqntable.set_col_spacing(0, 3)
def __init__(self, gfxtoolbox): SkeletonInfoModeGUI.__init__(self, gfxtoolbox) row = 0 self.labelmaster((0, 1), (row, row + 1), 'index=') self.index = self.entrymaster((1, 2), (row, row + 1), editable=True) gtklogger.setWidgetName(self.index, "Index") self.indexChangedSignal = gtklogger.connect(self.index, 'changed', self.indexChangedCB) gtklogger.connect(self.index, 'activate', self.indexChangeDoneCB) row += 1 self.labelmaster((0, 1), (row, row + 1), 'elements=') self.elem = self.makeObjList("Element", (1, 2), (row, row + 1)) row += 1 if config.dimension() == 3: self.labelmaster((0, 1), (row, row + 1), 'faces=') self.faces = self.makeObjList("Face", (1, 2), (row, row + 1)) row += 1 self.labelmaster((0, 1), (row, row + 1), 'nodes=') self.nodes = self.makeObjList("Node", (1, 2), (row, row + 1)) row += 1 self.labelmaster((0, 1), (row, row + 1), 'length=') self.length = self.entrymaster((1, 2), (row, row + 1)) gtklogger.setWidgetName(self.length, "Length") row += 1 self.labelmaster((0, 1), (row, row + 1), 'homogeneity=') self.homog = self.entrymaster((1, 2), (row, row + 1)) gtklogger.setWidgetName(self.homog, "Homogeneity") row += 1 self.labelmaster((0, 1), (row, row + 1), 'segment groups=') self.group = self.entrymaster((1, 2), (row, row + 1)) gtklogger.setWidgetName(self.group, "Groups") self.group.set_sensitive( False) # TODO: remove this line when implemented row += 1 self.labelmaster((0, 1), (row, row + 1), 'boundary=') self.bndy = self.entrymaster((1, 2), (row, row + 1)) gtklogger.setWidgetName(self.bndy, "Boundary") row += 1
def __init__(self, param, scope=None, name=None): debug.mainthreadTest() widget = gtk.Entry() widget.set_size_request(10 * guitop.top().charsize, -1) ParameterWidget.__init__(self, widget, scope=scope, name=name) self.signal = gtklogger.connect(widget, 'changed', self.changedCB) self.set_value(param.value) self.widgetChanged(self.validValue(param.value), interactive=0)
def __init__(self, param, scope=None, name=None): debug.mainthreadTest() widget = gtk.Entry() widget.set_size_request(10*guitop.top().charsize, -1) ParameterWidget.__init__(self, widget, scope=scope, name=name) self.signal = gtklogger.connect(widget, 'changed', self.changedCB) self.set_value(param.value) self.widgetChanged(self.validValue(param.value), interactive=0)
def __init__(self, params, scope=None, name=None): debug.mainthreadTest() kset = {(0,0): 'c11', (0,1): 'c12', (0,2): 'c13', (2,2): 'c33', (3,3): 'c44' } AnisoWidgetBase.__init__(self, params, kset, scope=scope, name=name) # # Base class will have blocked c66, so unblock it. self.floats[(5,5)].gtk.set_editable(1) self.floats[(5,5)].gtk.set_sensitive(1) # ... and connect a special callback. gtklogger.connect(self.floats[(5,5)].gtk, "activate", self.new_c66, None) gtklogger.connect(self.floats[(5,5)].gtk, "focus_out_event", self.new_c66) # self.set_values()
def __init__(self, param, scope, name=None, verbose=False): debug.mainthreadTest() # Find the enclosing mesh widget. self.meshwidget = scope.findWidget(lambda x: isinstance( x, whowidget.WhoWidget) and x.whoclass is mesh.meshes) self.gtk = gtk.Frame() vbox = gtk.VBox() self.gtk.add(vbox) meshname = self.meshwidget.get_value() try: self.meshobj = mesh.meshes[meshname] except KeyError: # no mesh! self.meshobj = None vbox.add(gtk.Label('No mesh!')) else: # In the proxy case, the behavior is to set the line # width, etc. for all the cross sections in whatever mesh # is referred to. It doesn't make sense to single out # individual cross-sections in this case, since they'll # change when the proxy resolution changes. The set_value # and get_value functions must also detect the proxy case # and behave a little differently, since the chooser # doesn't get built in that case. if isinstance(self.meshobj, whoville.WhoProxy): vbox.add(gtk.Label('Selected')) else: self.chooser = chooser.MultiListWidget( self.meshobj.allCrossSectionNames(), name="List") self.selected = gtk.CheckButton("Selected") gtklogger.setWidgetName(self.selected, "Selected") gtklogger.connect(self.selected, "clicked", self.selectedCB) vbox.pack_start(self.selected, expand=0, fill=0) vbox.pack_start(self.chooser.gtk, expand=0, fill=0) parameterwidgets.ParameterWidget.__init__(self, self.gtk, scope, name=name, expandable=True, verbose=verbose) self.set_value(param.value) self.gtk.show_all()
def build_fieldTable(self): debug.mainthreadTest() self.fieldtable.foreach(gtk.Object.destroy) # clear the table self.fieldbuttons = {} self.fieldtable.resize(len(allCompoundFields), 6) self.fieldtable.attach(gtk.VSeparator(), 1,2, 0,len(allCompoundFields), xoptions=0, yoptions=gtk.EXPAND|gtk.FILL) self.fieldtable.set_col_spacing(0, 3) row = 0 for fname, fld in allCompoundFields.items(): label = gtk.Label(fname) label.set_alignment(1.0, 0.5) self.fieldtable.attach(label, 0,1, row,row+1, xoptions=gtk.FILL, yoptions=0) button = gtk.CheckButton('defined') gtklogger.setWidgetName(button, fname+" defined") signal = gtklogger.connect(button, 'clicked', self.fieldDefineCB, fld) self.fieldbuttons[(fname, "defined")] = ButtonSignal(button, signal) self.fieldtable.attach(button, 2,3, row, row+1, xoptions=0, yoptions=0) self.setFieldDefineTip(button, fld) button = gtk.CheckButton('active') gtklogger.setWidgetName(button, fname+" active") signal = gtklogger.connect(button, 'clicked', self.fieldActiveCB, fld) self.fieldbuttons[(fname, "active")] = ButtonSignal(button, signal) self.fieldtable.attach(button, 3,4, row, row+1, xoptions=0, yoptions=0) self.setFieldActiveTip(button, fld) if config.dimension() == 2: button = gtk.CheckButton('in-plane') gtklogger.setWidgetName(button, fname + " in-plane") signal = gtklogger.connect(button, 'clicked', self.fieldInPlaneCB, fld) self.fieldbuttons[(fname, "inplane")] = ButtonSignal(button, signal) self.fieldtable.attach(button, 4,5, row, row+1, xoptions=0, yoptions=0) self.setFieldInPlaneTip(button, fld) row += 1
def __init__(self, gfxtoolbox): SkeletonInfoModeGUI.__init__(self, gfxtoolbox) row = 0 self.labelmaster((0, 1), (row, row + 1), 'index=') self.index = self.entrymaster((1, 2), (row, row + 1), editable=True) gtklogger.setWidgetName(self.index, "Index") self.indexChangedSignal = gtklogger.connect(self.index, 'changed', self.indexChangedCB) gtklogger.connect(self.index, 'activate', self.indexChangeDoneCB) row += 1 self.labelmaster((0, 1), (row, row + 1), 'position=') self.pos = self.entrymaster((1, 2), (row, row + 1)) gtklogger.setWidgetName(self.pos, "Position") row += 1 self.labelmaster((0, 1), (row, row + 1), 'mobility=') self.mobility = self.entrymaster((1, 2), (row, row + 1)) gtklogger.setWidgetName(self.mobility, "Mobility") row += 1 self.labelmaster((0, 1), (row, row + 1), 'elements=') self.elem = self.makeObjList("Element", (1, 2), (row, row + 1)) row += 1 if config.dimension() == 3: self.labelmaster((0, 1), (row, row + 1), 'faces=') self.faces = self.makeObjList("Face", (1, 2), (row, row + 1)) row += 1 self.labelmaster((0, 1), (row, row + 1), 'segments=') self.segs = self.makeObjList("Segment", (1, 2), (row, row + 1)) row += 1 self.labelmaster((0, 1), (row, row + 1), 'node groups=') self.group = self.entrymaster((1, 2), (row, row + 1)) gtklogger.setWidgetName(self.group, "Group") row += 1 self.labelmaster((0, 1), (row, row + 1), 'boundary=') self.bndy = self.entrymaster((1, 2), (row, row + 1)) gtklogger.setWidgetName(self.bndy, "Boundary") row += 1
def __init__(self, param, scope, name=None): debug.mainthreadTest() # Find the enclosing mesh widget. self.meshwidget = scope.findWidget( lambda x: isinstance(x, whowidget.WhoWidget) and x.whoclass is mesh.meshes) self.gtk = gtk.Frame() vbox = gtk.VBox() self.gtk.add(vbox) meshname = self.meshwidget.get_value() try: self.meshobj = mesh.meshes[meshname] except KeyError: # no mesh! self.meshobj = None vbox.add(gtk.Label('No mesh!')) else: # In the proxy case, the behavior is to set the line # width, etc. for all the cross sections in whatever mesh # is referred to. It doesn't make sense to single out # individual cross-sections in this case, since they'll # change when the proxy resolution changes. The set_value # and get_value functions must also detect the proxy case # and behave a little differently, since the chooser # doesn't get built in that case. if isinstance(self.meshobj, whoville.WhoProxy): vbox.add(gtk.Label('Selected')) else: self.chooser = chooser.MultiListWidget( self.meshobj.allCrossSectionNames(), name="List") self.selected = gtk.CheckButton("Selected") gtklogger.setWidgetName(self.selected, "Selected") gtklogger.connect(self.selected, "clicked", self.selectedCB) vbox.pack_start(self.selected, expand=0, fill=0) vbox.pack_start(self.chooser.gtk, expand=0, fill=0) parameterwidgets.ParameterWidget.__init__(self, self.gtk, scope, name=name, expandable=True) self.set_value(param.value) self.gtk.show_all()
def _OOFMenuItem_construct_gui(self, base, parent_menu, accelgroup): # "base" is this menu item's OOF menu parent, and "parent_menu" is # the to-be-constructed GtkMenuItem's gtk container. debug.mainthreadTest() if not (self.secret or self.getOption('cli_only')): new_gtkitem = gtk.MenuItem() # Built with no label. gtklogger.setWidgetName(new_gtkitem, self.name) new_gtkitem.add(self.gtklabel(new_gtkitem)) try: self.gtkitem.append(new_gtkitem) except AttributeError: self.gtkitem = [new_gtkitem] new_gtkitem.connect("destroy", self.gtkitem_destroyed) parent_menu.insert(new_gtkitem, self.gui_order()) if self.help_menu: base.gtkhelpmenu = 1 new_gtkitem.set_right_justified(True) if (self.callback is None) and (self.gui_callback is None) \ and self.children_visible(): new_gtkmenu = gtk.Menu() try: self.gtkmenu.append(new_gtkmenu) except AttributeError: self.gtkmenu = [new_gtkmenu] gtklogger.set_submenu(new_gtkitem, new_gtkmenu) for item in self.items: item.construct_gui(self, new_gtkmenu, accelgroup) # recursive! else: # no submenu, create command gtklogger.connect(new_gtkitem, 'activate', MenuCallBackWrapper(self)) if self.accel is not None and accelgroup is not None: new_gtkitem.add_accelerator('activate', accelgroup, ord(self.accel), gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE) if not self.enabled(): new_gtkitem.set_sensitive(0)
def __init__(self, toolbox): # The 'toolbox' argument here is the non-gui toolbox # corresponding to one of the inner toolboxes. It doesn't # matter which one. toolboxGUI.GfxToolbox.__init__(self, toolbox) vbox = gtk.VBox(spacing=2) self.gtk.add(vbox) bbox = gtk.HBox(spacing=2) gtklogger.setWidgetName(bbox, "Select") vbox.pack_start(bbox, expand=0, fill=0) bbox.pack_start(gtk.Label("Select: "), expand=0, fill=0) self.tbbox = gtk.Frame() # holds SkelSelToolboxModeGUIs vbox.pack_start(self.tbbox, expand=1, fill=1) group = None self.tbdict = {} modebuttons = [] skeletonselectionmodes.initialize() for mode in skeletonselmodebase.SkeletonSelectionMode.modes: if group: button = gtk.RadioButton(label=mode.name, group=group) else: button = gtk.RadioButton(label=mode.name) group = button modebuttons.append(button) gtklogger.setWidgetName(button, mode.name) gtklogger.connect(button, 'clicked', self.switchModeCB, mode.name) # Get the actual toolbox for each mode tb = self.gfxwindow().getToolboxByName(mode.toolboxName()) tbgui = tbclasses[mode.name](tb, tb.method) self.tbdict[mode.name] = tbgui table = gtk.Table(columns=2, rows=2) bbox.pack_start(table, expand=0, fill=0) table.attach(modebuttons[0], 0,1, 0,1) table.attach(modebuttons[1], 1,2, 0,1) table.attach(modebuttons[2], 0,1, 1,2) table.attach(modebuttons[3], 1,2, 1,2) self.currentMode = None self.setMode(skeletonselmodebase.firstMode().name)
def _OOFMenuItem_construct_gui(self, base, parent_menu, accelgroup): # "base" is this menu item's OOF menu parent, and "parent_menu" is # the to-be-constructed GtkMenuItem's gtk container. debug.mainthreadTest() if not (self.secret or self.getOption('cli_only')): new_gtkitem = gtk.MenuItem() # Built with no label. gtklogger.setWidgetName(new_gtkitem, self.name) new_gtkitem.add(self.gtklabel(new_gtkitem)) try: self.gtkitem.append(new_gtkitem) except AttributeError: self.gtkitem = [new_gtkitem] new_gtkitem.connect("destroy", self.gtkitem_destroyed) parent_menu.insert(new_gtkitem, self.gui_order()) if self.help_menu: base.gtkhelpmenu = 1 new_gtkitem.set_right_justified(True) if (self.callback is None) and (self.gui_callback is None) \ and self.children_visible(): new_gtkmenu = gtk.Menu() try: self.gtkmenu.append(new_gtkmenu) except AttributeError: self.gtkmenu=[new_gtkmenu] gtklogger.set_submenu(new_gtkitem, new_gtkmenu) for item in self.items: item.construct_gui(self, new_gtkmenu, accelgroup) # recursive! else: # no submenu, create command gtklogger.connect(new_gtkitem, 'activate', MenuCallBackWrapper(self)) if self.accel is not None and accelgroup is not None: new_gtkitem.add_accelerator('activate', accelgroup, ord(self.accel), gtk.gdk.CONTROL_MASK, gtk.ACCEL_VISIBLE) if not self.enabled(): new_gtkitem.set_sensitive(0)
def __init__(self, param, scope=None, name=None): debug.mainthreadTest() frame = gtk.Frame() frame.set_shadow_type(gtk.SHADOW_IN) self.table = gtk.Table(rows=1, columns=3) self.table.set_row_spacings(0) self.table.set_col_spacings(0) frame.add(self.table) gtklogger.setWidgetName(self.table, 'GroupTable') addbutton = gtk.Button('+') gtklogger.setWidgetName(addbutton, "Add") gtklogger.connect(addbutton, 'clicked', self.addCB) self.table.attach(addbutton, 0,1, 0,1, xoptions=gtk.FILL, yoptions=0, xpadding=0, ypadding=0) tooltips.set_tooltip_text(addbutton, "Add a new group definition.") clabel = gtk.Label("Column") clabel.set_alignment(0.0, 0.5) cframe = gtk.Frame() cframe.set_shadow_type(gtk.SHADOW_OUT) cframe.add(clabel) self.table.attach(cframe, 1,2, 0,1, xoptions=gtk.FILL|gtk.EXPAND, yoptions=gtk.FILL, xpadding=0, ypadding=0) nlabel = gtk.Label("Name") nlabel.set_alignment(0.0, 0.5) nframe = gtk.Frame() nframe.set_shadow_type(gtk.SHADOW_OUT) nframe.add(nlabel) self.table.attach(nframe, 2,3, 0,1, xoptions=gtk.FILL|gtk.EXPAND, yoptions=gtk.FILL, xpadding=0, ypadding=0) self.rows = [] # list of GCWidgetRow objects parameterwidgets.ParameterWidget.__init__(self, frame, scope=scope, name=name) if param.value is not None: self.set_value(param.value) self.widgetChanged(self.checkValue(), interactive=0)
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, param=None, scope=None, name=None, framed=True): vbox = gtk.VBox(spacing=2) if framed: parameterwidgets.ParameterWidget.__init__(self, gtk.Frame(), scope=scope, name=name) self.gtk.add(vbox) else: parameterwidgets.ParameterWidget.__init__(self, vbox, scope=scope, name=name) self.chooser = chooser.ChooserWidget(DestinationParamWidget.namelist, callback=self.chooserCB, name='Chooser') vbox.pack_start(self.chooser.gtk, expand=0, fill=0) bbox = gtk.HBox(spacing=2, homogeneous=True) vbox.pack_start(bbox, expand=0, fill=0) newbutton = gtkutils.StockButton(gtk.STOCK_NEW, "New...") gtklogger.setWidgetName(newbutton, "New") bbox.pack_start(newbutton, expand=1, fill=1) gtklogger.connect(newbutton, 'clicked', self.newCB) self.clearbutton = gtkutils.StockButton(gtk.STOCK_CLEAR, "Clear") gtklogger.setWidgetName(self.clearbutton, "Clear") bbox.pack_start(self.clearbutton, expand=1, fill=1) gtklogger.connect(self.clearbutton, 'clicked', self.clearCB) self.sbcallbacks = [ switchboard.requestCallbackMain('destinations changed', self.rebuild) ] self.rebuild() if param and param.value is not None: self.set_value(param.value) self.widgetChanged(1, interactive=0) _allDestinationWidgets.add(self)
def __init__(self, params, kset, scope=None, name=None): debug.mainthreadTest() self.params = params self.kset = kset SymmetricMatrixInput.__init__(self, 'C', 6,6, value=None, scope=scope, name=name) # # Make default blocks according to the kset dictionary. for (k,f) in self.floats.items(): if k in self.kset: pass else: f.gtk.set_editable(0) f.gtk.set_sensitive(0) # # Connect the "obvious" callbacks. Child classes may add # additional callbacks. for k in self.kset: # "activate" needs a dummy argument for the "event" slot. gtklogger.connect(self.floats[k].gtk, "activate",self.new_c,None) gtklogger.connect(self.floats[k].gtk, "focus_out_event",self.new_c)
def __init__(self, set_callback, ok_callback): debug.mainthreadTest() self.gtk = gtk.HBox() self.set_callback = set_callback self.historian = historian.Historian(self.setCB, self.sensitize) # Buttons: Previous, OK, and next. self.prevbutton = gtkutils.prevButton() gtklogger.connect(self.prevbutton, "clicked", self.historian.prevCB) tooltips.set_tooltip_text(self.prevbutton, "Recall the previous selection modification operation.") self.gtk.pack_start(self.prevbutton, expand=0, fill=0, padding=2) self.okbutton = gtk.Button(stock=gtk.STOCK_OK) gtklogger.setWidgetName(self.okbutton, 'OK') gtklogger.connect(self.okbutton, "clicked", ok_callback) self.gtk.pack_start(self.okbutton, expand=1, fill=1, padding=2) tooltips.set_tooltip_text(self.okbutton, "Perform the selection modification operation.") self.okbutton.set_sensitive(0) self.nextbutton = gtkutils.nextButton() gtklogger.connect(self.nextbutton, "clicked", self.historian.nextCB) tooltips.set_tooltip_text(self.nextbutton, "Recall the next selection modification operation.") self.gtk.pack_start(self.nextbutton, expand=0, fill=0, padding=2)
def makeTimeBox(self): # Construct and return, but don't install, a box containing # the time slider and other widgets. timebox = gtk.HBox(spacing=2) gtklogger.setWidgetName(timebox, 'time') timebox.pack_start(gtk.Label("time:"), expand=False, fill=False, padding=2) self.prevtimeButton = gtkutils.StockButton(gtk.STOCK_GO_BACK) gtklogger.setWidgetName(self.prevtimeButton, "prev") gtklogger.connect(self.prevtimeButton, 'clicked', self.prevtimeCB) timebox.pack_start(self.prevtimeButton, expand=False, fill=False) tooltips.set_tooltip_text(self.prevtimeButton, "Go to the previous stored time.") self.nexttimeButton = gtkutils.StockButton(gtk.STOCK_GO_FORWARD) gtklogger.setWidgetName(self.nexttimeButton, "next") gtklogger.connect(self.nexttimeButton, 'clicked', self.nexttimeCB) timebox.pack_start(self.nexttimeButton, expand=False, fill=False) tooltips.set_tooltip_text(self.nexttimeButton, "Go to the next stored time.") # The slider/entry combo has immediate==False because we don't # want to update until the user is done typing a time. self.timeslider = labelledslider.FloatLabelledSlider( value=0.0, vmin=0, vmax=0, step=0.01, callback=self.timeSliderCB, name='timeslider', immediate=False) self.timeslider.set_policy(gtk.UPDATE_DISCONTINUOUS) timebox.pack_start(self.timeslider.gtk, expand=True, fill=True) self.timeslider.set_tooltips(slider="Select an interpolation time.", entry="Enter an interpolation time.") return timebox
def __init__(self, gfxtoolbox): SkeletonInfoModeGUI.__init__(self, gfxtoolbox) self.labelmaster((0, 1), (0, 1), 'index=') self.index = self.entrymaster((1, 2), (0, 1), editable=True) gtklogger.setWidgetName(self.index, "Index") self.indexChangedSignal = gtklogger.connect(self.index, 'changed', self.indexChangedCB) gtklogger.connect(self.index, 'activate', self.indexChangeDoneCB) self.labelmaster((0, 1), (1, 2), 'elements=') self.elem = self.makeObjList("Element", (1, 2), (1, 2)) self.labelmaster((0, 1), (2, 3), 'segments=') self.segs = self.makeObjList("Segment", (1, 2), (2, 3)) self.labelmaster((0, 1), (3, 4), 'nodes=') self.nodes = self.makeObjList("Node", (1, 2), (3, 4)) self.labelmaster((0, 1), (4, 5), 'area=') self.area = self.entrymaster((1, 2), (4, 5)) gtklogger.setWidgetName(self.area, "Area") self.labelmaster((0, 1), (5, 6), 'homogeneity=') self.homog = self.entrymaster((1, 2), (5, 6)) gtklogger.setWidgetName(self.homog, "Homogeneity") self.homog.set_sensitive( False) # TODO 3.1: remove this when implemented self.labelmaster((0, 1), (6, 7), 'face groups=') self.group = self.entrymaster((1, 2), (6, 7)) gtklogger.setWidgetName(self.group, "Groups") self.group.set_sensitive( False) # TODO 3.1: remove this when implemented self.labelmaster((0, 1), (7, 8), 'boundary=') self.bndy = self.entrymaster((1, 2), (7, 8)) gtklogger.setWidgetName(self.bndy, "Boundary")
def __init__(self, param=None, scope=None, name=None, framed=True, verbose=False): debug.mainthreadTest() vbox = gtk.VBox(spacing=2) if framed: parameterwidgets.ParameterWidget.__init__(self, gtk.Frame(), scope=scope, name=name, verbose=verbose) self.gtk.add(vbox) else: parameterwidgets.ParameterWidget.__init__(self, vbox, scope=scope, name=name, verbose=verbose) self.chooser = chooser.ChooserWidget([], callback=self.chooserCB, name='Chooser') vbox.pack_start(self.chooser.gtk, expand=False, fill=False) bbox = gtk.HBox(spacing=2, homogeneous=True) vbox.pack_start(bbox, expand=0, fill=0) newbutton = gtkutils.StockButton(gtk.STOCK_NEW, "New...") gtklogger.setWidgetName(newbutton, "New") bbox.pack_start(newbutton, expand=True, fill=True) gtklogger.connect(newbutton, 'clicked', self.newCB) tooltips.set_tooltip_text(newbutton, "Open a new file for output.") self.rewindbutton = gtkutils.StockButton(gtk.STOCK_MEDIA_REWIND, "Rewind") gtklogger.setWidgetName(self.rewindbutton, "Rewind") bbox.pack_start(self.rewindbutton, expand=True, fill=True) gtklogger.connect(self.rewindbutton, 'clicked', self.rewindCB) tooltips.set_tooltip_text( self.rewindbutton, "Rewind the selected file. Data will be lost.") self.clearbutton = gtkutils.StockButton(gtk.STOCK_CLEAR, "Clear") gtklogger.setWidgetName(self.clearbutton, "Clear") bbox.pack_start(self.clearbutton, expand=True, fill=True) gtklogger.connect(self.clearbutton, 'clicked', self.clearCB) tooltips.set_tooltip_text( self.clearbutton, "Close all files and remove them from the list.") self.sbcallback = switchboard.requestCallbackMain( 'output destinations changed', self.rebuild) self.rebuild() if param and param.value is not None: self.set_value(param.value) self.widgetChanged(True, interactive=False)
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, pixelinfotoolbox): debug.mainthreadTest() toolboxGUI.GfxToolbox.__init__(self, "Pixel Info", pixelinfotoolbox) mainbox = gtk.VBox() self.gtk.add(mainbox) self.table = gtk.Table(rows=3, columns=2) mainbox.pack_start(self.table, expand=0, fill=0) label = gtk.Label('x=') label.set_alignment(1.0, 0.5) self.table.attach(label, 0,1, 0,1, xpadding=5, xoptions=gtk.FILL) self.xtext = gtk.Entry() gtklogger.setWidgetName(self.xtext, "X") self.xtext.set_size_request(10*guitop.top().digitsize, -1) self.table.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) self.table.attach(label, 0,1, 1,2, xpadding=5, xoptions=gtk.FILL) self.ytext = gtk.Entry() gtklogger.setWidgetName(self.ytext, "Y") self.ytext.set_size_request(10*guitop.top().digitsize, -1) self.table.attach(self.ytext, 1,2, 1,2, xpadding=5, xoptions=gtk.EXPAND|gtk.FILL) self.xtsignal = gtklogger.connect(self.xtext, 'changed', self.pointChanged) self.ytsignal = gtklogger.connect(self.ytext, 'changed', self.pointChanged) box = gtk.HBox(homogeneous=True, spacing=2) self.updatebutton = gtkutils.StockButton(gtk.STOCK_REFRESH, 'Update') box.pack_start(self.updatebutton, expand=1, fill=1) gtklogger.setWidgetName(self.updatebutton, "Update") gtklogger.connect(self.updatebutton, 'clicked', self.updateButtonCB) self.clearbutton = gtkutils.StockButton(gtk.STOCK_CLEAR, 'Clear') box.pack_start(self.clearbutton, expand=1, fill=1) gtklogger.setWidgetName(self.clearbutton, "Clear") gtklogger.connect(self.clearbutton, 'clicked', self.clearButtonCB) self.table.attach(box, 0,2, 2,3, xpadding=5, xoptions=gtk.EXPAND|gtk.FILL, yoptions=0) self.updatebutton.set_sensitive(0) self.clearbutton.set_sensitive(0) self.buildGUI() self.sbcallbacks = [ switchboard.requestCallbackMain(pixelinfotoolbox, self.update), switchboard.requestCallbackMain('new pixelinfo plugin', self.buildGUI), switchboard.requestCallbackMain((self.gfxwindow(), 'layers changed'), self.update) ]
def __init__(self, param, scope=None, name=None): debug.mainthreadTest() if param.value: labelstr = 'true' else: labelstr = 'false' self.label = gtk.Label(labelstr) ParameterWidget.__init__(self, gtk.Frame(), scope=scope) self.button = gtk.CheckButton() self.gtk.add(self.button) self.button.add(self.label) # name is assigned to the button, not the frame, because it's # the button that gets connected. gtklogger.setWidgetName(self.button, name) self.signal = gtklogger.connect(self.button, 'clicked', self.buttonCB) self.set_value(param.value)
def addMoreWidgets(self, vbox): # Widgets below the file list. hbox = gtk.HBox() vbox.pack_start(hbox, expand=False, fill=False) label = gtk.Label('File:') hbox.pack_start(gtk.Label('File:'), expand=False, fill=False) self.fileEntry = gtk.Entry() gtklogger.setWidgetName(self.fileEntry, 'File') self.fileEntrySignal = gtklogger.connect(self.fileEntry, 'changed', self.entryChangeCB) hbox.pack_start(self.fileEntry, expand=True, fill=True) # Add file-name completion in the fileEntry widget. The # fileList already has file-name completion in it. self.completion = gtk.EntryCompletion() self.fileEntry.set_completion(self.completion) self.completion.set_model(self.fileList.liststore) self.completion.set_text_column(0)
def __init__(self, namelist, callback=None, name=None): # If a callback is provided, it's called a *lot* of times. # It's called for every keystroke in the entry part of the # widget and every time a selection is made in the list part # of the widget. debug.mainthreadTest() liststore = gtk.ListStore(gobject.TYPE_STRING) self.combobox = gtk.ComboBoxEntry(liststore, 0) if name: gtklogger.setWidgetName(self.combobox, name) self.gtk = self.combobox self.namelist = [] self.current_string = None self.update(namelist) self.signal = gtklogger.connect(self.combobox, 'changed', self.changedCB) self.callback = callback
def __init__(self, scope, name=None): debug.mainthreadTest() parameterwidgets.ParameterWidget.__init__(self, gtk.HBox(), scope=scope, name=name) self.times = [] self.signals = [] self.sbcallbacks = [] self.earliestButton = gtkutils.StockButton(gtk.STOCK_MEDIA_REWIND) gtklogger.setWidgetName(self.earliestButton, 'earliest') self.signals.append(gtklogger.connect(self.earliestButton, 'clicked', self.extremeCB, placeholder.earliest)) self.gtk.pack_start(self.earliestButton, expand=0, fill=0) tooltips.set_tooltip_text(self.earliestButton, "Use the earliest stored time.") self.prevButton = gtkutils.StockButton(gtk.STOCK_GO_BACK) gtklogger.setWidgetName(self.prevButton, "Prev") self.signals.append(gtklogger.connect(self.prevButton, 'clicked', self.prevCB)) self.gtk.pack_start(self.prevButton, expand=0, fill=0) tooltips.set_tooltip_text(self.prevButton, "Go to an earlier time saved in the mesh.") self.text = gtk.Entry() gtklogger.setWidgetName(self.text, 'Text') self.signals.append(gtklogger.connect(self.text, 'changed', self.entryCB)) self.gtk.pack_start(self.text, expand=1, fill=1) self.nextButton = gtkutils.StockButton(gtk.STOCK_GO_FORWARD) gtklogger.setWidgetName(self.nextButton, "Next") gtklogger.connect(self.nextButton, 'clicked', self.nextCB) self.gtk.pack_start(self.nextButton, expand=0, fill=0) tooltips.set_tooltip_text(self.nextButton, "Go to a later time saved in the mesh.") self.latestButton = gtkutils.StockButton(gtk.STOCK_MEDIA_FORWARD) gtklogger.setWidgetName(self.latestButton, 'latest') self.signals.append(gtklogger.connect(self.latestButton, 'clicked', self.extremeCB, placeholder.latest)) self.gtk.pack_start(self.latestButton, expand=0, fill=0) tooltips.set_tooltip_text(self.latestButton, "Use the latest stored time.") self.mode = placeholder.latest # 'earliest', 'latest', or None
def __init__(self, registration, rclfactory): debug.mainthreadTest() self.registration = registration self.rclfactory = rclfactory self._button = gtk.CheckButton() gtklogger.setWidgetName(self._button, registration.name()+'Toggle') # We could use an Expander instead of a CheckButton here, but # it might be confusing. The check button makes it clear that # a method is selected. Just expanding an Expander might not # be so obvious, especially if a Registration has no # Parameters. Also, the whole RegisteredClassListFactory # would have to be redone. self._signal = gtklogger.connect(self._button, 'clicked', self.buttonCB) self._box = gtk.VBox() self._label = gtk.Label(registration.name()) self._label.set_alignment(0.0, 0.5) if hasattr(registration, 'tip'): tooltips.set_tooltip_text(self._label,registration.tip) self.sbcallback = None self.makeWidget()
def __init__(self, param=None, scope=None, name=None, framed=True): debug.mainthreadTest() vbox = gtk.VBox(spacing=2) if framed: parameterwidgets.ParameterWidget.__init__(self, gtk.Frame(), scope=scope, name=name) self.gtk.add(vbox) else: parameterwidgets.ParameterWidget.__init__(self, vbox, scope=scope, name=name) self.chooser = chooser.ChooserWidget([], callback=self.chooserCB, name='Chooser') vbox.pack_start(self.chooser.gtk, expand=False, fill=False) bbox = gtk.HBox(spacing=2, homogeneous=True) vbox.pack_start(bbox, expand=0, fill=0) newbutton = gtkutils.StockButton(gtk.STOCK_NEW, "New...") gtklogger.setWidgetName(newbutton, "New") bbox.pack_start(newbutton, expand=True, fill=True) gtklogger.connect(newbutton, 'clicked', self.newCB) tooltips.set_tooltip_text(newbutton, "Open a new file for output.") self.rewindbutton = gtkutils.StockButton(gtk.STOCK_MEDIA_REWIND, "Rewind") gtklogger.setWidgetName(self.rewindbutton, "Rewind") bbox.pack_start(self.rewindbutton, expand=True, fill=True) gtklogger.connect(self.rewindbutton, 'clicked', self.rewindCB) tooltips.set_tooltip_text( self.rewindbutton, "Rewind the selected file. Data will be lost.") self.clearbutton = gtkutils.StockButton(gtk.STOCK_CLEAR, "Clear") gtklogger.setWidgetName(self.clearbutton, "Clear") bbox.pack_start(self.clearbutton, expand=True, fill=True) gtklogger.connect(self.clearbutton, 'clicked', self.clearCB) tooltips.set_tooltip_text( self.clearbutton, "Close all files and remove them from the list.") self.sbcallback = switchboard.requestCallbackMain( 'output destinations changed', self.rebuild) self.rebuild() if param and param.value is not None: self.set_value(param.value) self.widgetChanged(True, interactive=False)
def _RadioOOFMenuItem_construct_gui(self, base, parent_menu, accelgroup): debug.mainthreadTest() try: gtkgroup = self.group.gtk except AttributeError: new_gtkitem = gtk.RadioMenuItem(group=None) gtklogger.setWidgetName(new_gtkitem, self.name) self.group.gtk = [new_gtkitem] else: new_gtkitem = gtk.RadioMenuItem(group=gtkgroup[-1]) new_gtkitem.add(self.gtklabel(new_gtkitem)) # Set the state of the button. This calls the callback, so we do # it here before the callback is connected. new_gtkitem.set_active(self.value) try: self.gtkitem.append(new_gtkitem) except AttributeError: self.gtkitem = [new_gtkitem] new_gtkitem.connect("destroy", self.gtkitem_destroyed) if self.accel is not None and accelgroup is not None: new_gtkitem.add_accelerator('activate', accelgroup, ord(self.accel), gtk.gdk.MOD1_MASK, gtk.ACCEL_VISIBLE) new_handlerid = gtklogger.connect(new_gtkitem, 'activate', RadioMenuCallBackWrapper(self)) try: self.handlerid.append(new_handlerid) except AttributeError: self.handlerid = [new_handlerid] if self.getOption('disabled'): new_gtkitem.set_sensitive(0) parent_menu.add(new_gtkitem)
def __init__(self, namelist, callback=None, callbackargs=(), update_callback=None, update_callback_args=(), helpdict={}, name=None, separator_func=None): debug.mainthreadTest() assert name is not None # If this is used as a base class for another widget, self.gtk # will be redefined. So if a ChooserWidget function needs to # refer to the ComboBox gtk widget, it must use # self.combobox instead of self.gtk. liststore = gtk.ListStore(gobject.TYPE_STRING) self.combobox = gtk.ComboBox(liststore) if name: gtklogger.setWidgetName(self.combobox, name) cell = gtk.CellRendererText() self.combobox.pack_start(cell, True) self.combobox.set_cell_data_func(cell, self.cell_layout_data_func) # 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.combobox.set_row_separator_func(separator_func) self.gtk = self.combobox self.current_string = None self.callback = callback self.callbackargs = callbackargs self.helpdict = {} self.tipmap = {} # see cell_layout_data_func() self.signal = gtklogger.connect(self.combobox, 'changed', self.changedCB) # make sure that the update_callback isn't installed until # after the widget is initialized. self.update_callback = None self.update_callback_args = () self.update(namelist, helpdict) self.update_callback = update_callback self.update_callback_args = update_callback_args