def __init__(self, stock_id, labelstr=None, reverse=False, markup=False, align=None): debug.mainthreadTest() gtk.Button.__init__(self) image = gtk.Image() image.set_from_stock(stock_id, gtk.ICON_SIZE_BUTTON) hbox = gtk.HBox() self.markup = markup self.reverse = reverse if reverse: if labelstr: if markup: self.label = gtk.Label() self.label.set_markup(labelstr + ' ') else: self.label = gtk.Label(labelstr + ' ') if align is not None: self.label.set_alignment(align, 0.5) hbox.pack_start(self.label, expand=1, fill=1) hbox.pack_start(image, expand=0, fill=0) else: # not reverse hbox.pack_start(image, expand=0, fill=0) if labelstr: if markup: self.label = gtk.Label() self.label.set_markup(' ' + labelstr) else: self.label = gtk.Label(' ' + labelstr) if align is not None: self.label.set_alignment(align, 0.5) hbox.pack_start(self.label, expand=1, fill=1) self.add(hbox)
def updateAAList(self): # update list of named active areas debug.mainthreadTest() ms = self.getCurrentMS() if ms is not None: self.aalist.update(ms.getObject().activeAreaNames()) else: self.aalist.update([])
def updateGUI(self): debug.mainthreadTest() self.lesson = self.tutor.lessons[self.index] # current lesson if self.lesson.subject is not None: self.subject.set_text(self.lesson.subject) else: self.subject.set_text("????") self.slideIndex.set_text("%d/%d" % ((self.index+1), len(self.tutor.lessons))) bfr = self.textview.get_buffer() bfr.set_text("") comments = Comment(self.lesson.comments) for i in range(len(comments)): comment = comments[i] font = comments.isBold(i) if font: bfr.insert_with_tags(bfr.get_end_iter(), comment, self.boldTag) else: bfr.insert(bfr.get_end_iter(), comment) for s in self.scrollsignals: s.block() self.msgscroll.get_hadjustment().set_value(0.) self.msgscroll.get_vadjustment().set_value(0.) for s in self.scrollsignals: s.unblock() self.sensitize() self.gtk.show_all()
def renderMethodCell(self, column, cell_renderer, model, iter): debug.mainthreadTest() layer = model[iter][0] if self.settings.longlayernames: cell_renderer.set_property('text', `layer`) else: cell_renderer.set_property('text', layer.short_name())
def down(self, x, y, shift, ctrl): # mouse down debug.mainthreadTest() self.selmeth = self.selectionMethodFactory.getRegistration() self.selectionMethodFactory.set_defaults() self.gfxwindow().setRubberband(self.selmeth.getRubberBand(self.selmeth)) # Start collecting points self.points = [primitives.Point(x,y)]
def setCoordDisplay(self, selectionMethodReg, points): debug.mainthreadTest() for sig in self.entrychangedsignals: sig.block() try: if 'down' in selectionMethodReg.events: self.xdownentry.set_text(("%-8g" % points[0].x).rstrip()) self.ydownentry.set_text(("%-8g" % points[0].y).rstrip()) if config.dimension() == 3: self.zdownentry.set_text(("%-8g" % points[0].z).rstrip()) else: self.xdownentry.set_text('--') self.ydownentry.set_text('--') if config.dimension() == 3: self.zdownentry.set_text('--') if 'up' in selectionMethodReg.events: self.xupentry.set_text(("%-8g" % points[-1].x).rstrip()) self.yupentry.set_text(("%-8g" % points[-1].y).rstrip()) if config.dimension() == 3: self.zupentry.set_text(("%-8g" % points[-1].z).rstrip()) else: self.xupentry.set_text('--') self.yupentry.set_text('--') if config.dimension() == 3: self.zdownentry.set_text('--') finally: for sig in self.entrychangedsignals: sig.unblock()
def move(self, x, y, shift, ctrl): debug.mainthreadTest() if config.dimension() == 2: self.xtext.set_text("%-11.4g" % x) self.ytext.set_text("%-11.4g" % y) point = primitives.Point(x,y) elif config.dimension() == 3: point = self.gfxwindow().oofcanvas.screenCoordsTo3DCoords(x,y) if point is not None: self.xtext.set_text("%-11.4g" % point[0]) self.ytext.set_text("%-11.4g" % point[1]) self.ztext.set_text("%-11.4g" % point[2]) if self.skeleton_context and point is not None: skel = self.skeleton_context.getObject() node = skel.nearestNode(point) if node: pos = node.position() self.nodextext.set_text("%-11.4g" % pos.x) self.nodeytext.set_text("%-11.4g" % pos.y) if config.dimension() == 3: self.nodeztext.set_text("%-11.4g" % pos.z) self.set_pintext(node) else: self.nodextext.set_text('') self.nodeytext.set_text('') if config.dimension() == 3: self.nodeztext.set_text('') self.set_pintext(None) gtklogger.checkpoint("Pin Nodes toolbox move event")
def _switchpacking(parent, child): # Toggle the 'expand' and 'fill' gtk packing properties of the # child. debug.mainthreadTest() expand, fill, padding, pack_type = parent.query_child_packing(child) parent.set_child_packing(child, expand=not expand, fill=not fill, padding=padding, pack_type=pack_type)
def close(self): debug.mainthreadTest() if self.modeobj: self.modeobj.destroy() map(switchboard.removeCallback, self.sbcallbacks) self.sbcallbacks = [] toolboxGUI.GfxToolbox.close(self)
def ok_sensitize(self): debug.mainthreadTest() skelcontext = self.getSkeletonContext() self.historybox.okbutton.set_sensitive( skelcontext is not None and not skelcontext.query_reservation() and self.factory.isValid())
def __init__(self,params,old_base,delta_class,scope=None,name=None): debug.mainthreadTest() parameterwidgets.ParameterWidget.__init__(self, gtk.HBox(), scope, name) self.params = params # VBox for the color patch. self.vbox = gtk.VBox() self.delta = delta_class(160,40) # self.gtk.pack_start(self.vbox, expand=0, fill=0) # self.slider = LabelledSliderSet(["Red", "Green", "Blue"]) self.vbox.pack_start(self.slider.gtk, expand=1, fill=1) self.vbox.pack_start(self.delta.gtk, expand=0, fill=0) # if old_base: self.gdkcol = self.gtk.get_colormap().alloc_color( int(65535*old_base.getRed()), int(65535*old_base.getGreen()), int(65535*old_base.getBlue())) else: self.gdkcol = self.gtk.get_colormap().alloc_color(0,0,0) # self.delta.set_background(self.gdkcol) # self.set_values() # Copies values from params to the sliders. # self.slider.set_callback(self.newrgb) self.widgetChanged(1, interactive=0)
def fill_polygon(self, polygon): debug.mainthreadTest() if type(polygon) == types.ListType: p = primitives.makeCompoundPolygon(polygon) self.canvas.fill_polygon(p) else: self.canvas.fill_polygon(polygon)
def draw_polygon(self, polygon): debug.mainthreadTest() if type(polygon) == types.ListType: for pgon in polygon: self.canvas.draw_polygon(pgon) else: self.canvas.draw_polygon(polygon)
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 updateStatus(self): debug.mainthreadTest() meshctxt = self.currentMeshContext() if meshctxt: self.statusLabel.set_text(meshctxt.status.tag) else: self.statusLabel.set_text("No mesh!")
def sensitize(self): debug.mainthreadTest() msok = self.currentMS() is not None skelok = msok and self.currentSkeleton() is not None meshok = (skelok and self.currentMesh() is not None and not self.currentMesh().query_reservation()) meshsync = meshok and not self.currentMesh().outOfSync() if meshok: mesh = self.currentMesh() neqns = len(mesh.all_subproblem_equations()) nflds = len(mesh.all_subproblem_fields()) bclist = self.bclist.getBCName() is not None if TESTINGPAPER: self.bcNew.set_sensitive(meshsync and (neqns > 0 or nflds > 0)) else: self.bcNew.set_sensitive(meshsync and (neqns > 0 and nflds > 0)) self.bcDel.set_sensitive(bclist and meshok) self.bcEdit.set_sensitive(bclist and meshsync) self.bcCopy.set_sensitive(bclist) # self.bcEnableDisable.set_sensitive(bclist) self.bcCopyAll.set_sensitive(bclist) self.bcRename.set_sensitive(bclist and meshok) self.bcCopyAll.set_sensitive(len(self.bclist)>0)
def __init__(self,params,old_base,delta_class,scope=None,name=None): debug.mainthreadTest() parameterwidgets.ParameterWidget.__init__(self, gtk.HBox(), scope, name) self.params = params self.vbox = gtk.VBox() self.delta = delta_class(160,40) # self.gtk.pack_start(self.vbox, expand=0, fill=0) # self.slider = LabelledSliderSet(["Gray"], min=[0.0],max=[1.0]) # self.vbox.pack_start(self.slider.gtk, expand=0, fill=0) self.vbox.pack_start(self.delta.gtk, expand=0, fill=0) # if old_base: self.gdkcol = self.gtk.get_colormap().alloc_color( int(65535*old_base.getRed()), int(65535*old_base.getGreen()), int(65535*old_base.getBlue())) else: self.gdkcol = self.gtk.get_colormap().alloc_color(0,0,0) self.delta.set_background(self.gdkcol) self.set_values() self.slider.set_callback(self.newgray) self.widgetChanged(1, interactive=0)
def update(self): debug.mainthreadTest() loop = self.loop_check() parameterwidgets.EnumWidget.update(self) if loop == 0: inactive_names = director.loopables elif loop == 1: inactive_names = director.unloopables else: # Loop is -1, sequencing failed. inactive_names = director.loopables + director.unloopables # Interface branch inactive_names = inactive_names + ["Non-sequenceable"] namelist = [n for n in list(self.enumclass.names) if n not in inactive_names] if len(namelist) > 0: self.widget.gtk.set_sensitive(1) self.widget.update(namelist, self.enumclass.helpdict) # Actually set the widget value, since the parameter may # have been previously set to a disallowed option. # "self.value" and "self.enumclass" are defined in the parent. self.value = self.enumclass(self.widget.get_value()) self.widgetChanged(1, interactive=0) else: self.widget.gtk.set_sensitive(0) self.widget.update(["No edge sequence"]) self.widgetChanged(0, interactive=0)
def buttonCB(self, obj): debug.mainthreadTest() if self.button.get_active(): self.label.set_text('true') else: self.label.set_text('false') self.widgetChanged(1, interactive=1)
def makeSingleWidget(self, param, tablepos, scope): debug.mainthreadTest() widget = param.makeWidget(scope=scope) self.widgets.append(widget) self.sbcallbacks += [ switchboard.requestCallbackMain(('validity', widget), self.vcheck, tablepos), switchboard.requestCallbackMain(widget, self.widgetChangeCB) ] self.validities[tablepos] = widget.isValid() label = gtk.Label(param.name + ' =') label.set_alignment(1.0, 0.5) self.labels.append(label) if param.tip: tooltips.set_tooltip_text(label,param.tip) if widget.expandable: yoptions = gtk.EXPAND | gtk.FILL self.expandable = True else: yoptions = 0 if self.showLabels: self.gtk.attach(label, 0, 1, tablepos, tablepos+1, xpadding=5, xoptions=gtk.FILL, yoptions=yoptions) self.gtk.attach(widget.gtk, 1, 2, tablepos, tablepos+1, xpadding=5, xoptions=gtk.EXPAND|gtk.FILL, yoptions=yoptions)
def show(self): debug.mainthreadTest() # Don't use self.gtk.show_all(), since it will show collapsed items. for data in self.guidata.values(): data.show() self.table.show() self.gtk.show()
def __init__(self, param, scope=None, name=None): debug.mainthreadTest() hbox = gtk.HBox() xlabel = gtk.Label("x:") xlabel.set_alignment(1.0, 0.5) self.xwidget = FloatWidget(parameter.FloatParameter('Tweedledum', 0), name="X") ylabel = gtk.Label("y:") ylabel.set_alignment(1.0, 0.5) self.ywidget = FloatWidget(parameter.FloatParameter('Tweedledee', 0), name="Y") hbox.pack_start(xlabel, expand=0, fill=0, padding=2) hbox.pack_start(self.xwidget.gtk, expand=1, fill=1) hbox.pack_start(ylabel, expand=0, fill=0, padding=2) hbox.pack_start(self.ywidget.gtk, expand=1, fill=1) self.sbcallbacks=[ switchboard.requestCallbackMain(self.xwidget, self.widgetChangeCB), switchboard.requestCallbackMain(self.ywidget, self.widgetChangeCB) ] ParameterWidget.__init__(self, hbox, scope=scope, name=name) self.set_value(param.value) self.widgetChanged(self.xwidget.isValid() and self.ywidget.isValid(), interactive=0)
def setByRegistration(self, registration, interactive=0): debug.mainthreadTest() # setByRegistration() is almost the same as optionCB(), except # that it makes no attempt to set the new parameters from the # old ones, since it's not being used to switch between # convertible classes. In fact, it may be used to switch to a # new instance of the same class, so it's important to throw # out the old parameter values. if self.includeRegistration(registration): if self.paramWidget is not None: self.paramWidget.destroy() self.options.set_state(registration.name()) self.getBase(registration) self.options.set_state(registration.name()) self.currentOption = registration self.paramWidget = self.makeWidget(registration) if self.readonly: self.makeUneditable() ## After the widget has once been set interactively, its ## default value isn't used. self.useDefault = self.useDefault and not interactive self.widgetChanged(self.paramWidget.isValid(), interactive) self.box.pack_start(self.paramWidget.gtk, fill=self.fill, expand=self.expand) self.show() if hasattr(registration, 'tip'): tooltips.set_tooltip_text(self.options.gtk,registration.tip)
def update(self, registry, objlist=[]): # Called during initialization and whenever the registry changes. debug.mainthreadTest() self.registry = registry self.table.foreach(gtk.Object.destroy) # clear the table row = 0 if self.title: self.table.attach(gtk.Label(self.title), 0,2, row,row+1, yoptions=0, ypadding=5) row += 1 self.table.attach(gtk.HSeparator(), 0,2, row,row+1, yoptions=0, ypadding=3) row += 1 self.guidata = {} # RegistrationGUIData, keyed by reg name for registration in registry: if self.includeRegistration(registration): data = RegistrationGUIData(registration, self) self.guidata[registration.name()] = data self.table.attach(data.button(), 0,1, row,row+1, xoptions=0, yoptions=0, xpadding=3, ypadding=3) self.table.attach(data.label(), 1,2, row,row+1, xoptions=gtk.EXPAND|gtk.FILL, yoptions=0) self.table.attach(data.box(), 1,2, row+1,row+2, xoptions=gtk.EXPAND|gtk.FILL, yoptions=0, xpadding=3, ypadding=3) self.table.attach(gtk.HSeparator(), 0,2, row+2, row+3, xoptions=gtk.EXPAND|gtk.FILL, yoptions=0) row += 3 self.table.resize(rows=row-1, columns=2) # remove last gtk.HSeparator if objlist is not None: self.set(*objlist) self.widgetCB(interactive=0)
def __init__(self, toolbox, table, row): debug.mainthreadTest() pixelinfoplugin.PixelInfoPlugIn.__init__(self, toolbox) self.label = gtk.Label('Orientation=') self.label.set_alignment(1.0, 0.5) table.attach(self.label, 0,1, row,row+1, xpadding=5, xoptions=gtk.FILL) self.vbox = gtk.VBox() self.param = parameter.ConvertibleRegisteredParameter( 'dummy', orientationmatrix.Orientation) self.widget = self.param.makeWidget() # RegisteredClassFactory self.widget.makeReadOnly() self.text = gtk.Entry() self.text.set_editable(0) self.vbox.pack_start(self.text, expand=0, fill=0) self.current_mode = 'text' table.attach(self.vbox, 1,2, row,row+1, xpadding=5, xoptions=gtk.EXPAND|gtk.FILL) self.sbcbs = [ switchboard.requestCallbackMain( 'materials changed in microstructure', self.materialchanged), switchboard.requestCallbackMain('OrientationMap changed', self.materialchanged), switchboard.requestCallbackMain('material changed', self.materialchanged), switchboard.requestCallbackMain('prop_added_to_material', self.materialchanged), switchboard.requestCallbackMain('prop_removed_from_material', self.materialchanged), switchboard.requestCallbackMain(self.widget, self.widgetcb) ] self.update(None)
def update(self, where): debug.mainthreadTest() microstructure = self.toolbox.findMicrostructure() if microstructure and where is not None: orientsource = orientmapdata.getOrientationAtPoint( microstructure, where) if orientsource: orientation, source = orientsource # orientation is a COrientation instance. It has to # be converted into an orientationmatrix.Orientation # object so that we can make (ab)use of the # ConvertibleRegisteredClass machinery. abg = orientation.abg() if self.param.value is not None: klass = self.param.value.__class__ reg = self.param.value.getRegistration() else: reg = orientationmatrix.Orientation.registry[0] klass = reg.subclass base = orientationmatrix.Abg( *[a*180./math.pi for a in (abg.alpha(), abg.beta(), abg.gamma())]) newvalue = klass(*reg.from_base(None, base)) self.param.value = newvalue self.widget.set(newvalue, interactive=False) self.set_mode("widget") self.label.set_text('Orientation=\n(%s)' % source) else: # orientsource is None self.text.set_text("<No Orientation>") self.set_mode("text") self.label.set_text('Orientation=') else: # microstructure is None or where is None self.text.set_text("<No Microstructure>") self.set_mode("text") self.label.set_text('Orientation=')
def __init__(self, value, outputtree, scope=None, name=None): debug.mainthreadTest() frame = gtk.Frame() self.vbox = gtk.VBox() frame.add(self.vbox) # top part is a bunch of chooser widgets representing the # LabelTree of outputs. self.treewidget = \ gfxLabelTree.LabelTreeChooserWidget(outputtree, callback=self.treeCB, name=name) self.vbox.pack_start(self.treewidget.gtk, expand=0, fill=0) # bottom part is a ParameterTable self.parambox = gtk.VBox() gtklogger.setWidgetName(self.parambox, "Parameters") self.paramtable = None self.params = [] self.paramhier = [] self.vbox.pack_start(self.parambox, expand=0, fill=0) parameterwidgets.ParameterWidget.__init__(self, frame, scope, name) widgetscope.WidgetScope.__init__(self, scope) if value is not None: self.set_value(value) else: self.set_value(outputtree.numberOneChild())
def move_info(self, point, homogtext, shapetext, labeltext): debug.mainthreadTest() self.showPosition(point) self.homogtext.set_text(homogtext) self.shapetext.set_text(shapetext) self.statusText.set_text(labeltext) gtklogger.checkpoint("Move Node toolbox info updated")
def destroyParameterTable(self): debug.mainthreadTest() if self.paramtable is not None: table = self.paramtable self.paramtable = None table.destroy() switchboard.removeCallback(self.sbcallback)
def _set_button_sensitivities(self, u,r,c,i): debug.mainthreadTest() self.undobutton.set_sensitive(u) self.redobutton.set_sensitive(r) self.clearbutton.set_sensitive(c) self.invertbutton.set_sensitive(i) self.sensitizeHistory()
def changedCB(self, gtkobj): debug.mainthreadTest() self.widgetChanged(self.validValue(self.gtk.get_text()), interactive=1)
def renderSubproblemOrder(self, column, cell_renderer, model, iter): debug.mainthreadTest() rowno = model.get_path(iter)[0] cell_renderer.set_property('text', `rowno`)
def currentSubProblemContext(self): debug.mainthreadTest() selection = self.subpListView.get_selection() model, iter = selection.get_selected() if iter: return model[iter][0]
def sensitize(self): ## TODO OPT: This is called an awful lot. Can it be reduced? ## Does it matter? debug.mainthreadTest() meshctxt = self.currentMeshContext() meshok = (meshctxt is not None and not meshctxt.query_reservation() and not meshctxt.outOfSync()) timedependent = meshctxt and meshctxt.timeDependent() if meshok: ninit = len(meshctxt.initializers) + meshctxt.n_initialized_bcs() anyinits = ninit > 0 endtime = self.endTime(meshctxt) else: ninit = 0 anyinits = False endtime = None subpctxt = self.currentSubProblemContext() # currently selected subProb subpok = subpctxt is not None and not subpctxt.query_reservation() fld, bc = self.selectedFieldOrBC() fieldok = fld is not None bcok = bc is not None # list of all subproblems to be solved if meshok: subprobs = [s for s in meshctxt.subproblems() if (s.solver_mode and s.solveFlag)] else: subprobs = [] solversok = len(subprobs) > 0 # can subproblems be solved? nsolvers = 0 for subp in subprobs: subpobj = subp.getObject() solversok = (solversok and subp.materialsConsistent() and not subp.query_reservation() and subpobj.n_active_eqns() > 0 and subpobj.n_active_fields() > 0) if subp.solver_mode: nsolvers += 1 self.setSolverButton.set_sensitive(subpok) self.copySolverButton.set_sensitive(subpok and subpctxt.solver_mode is not None) self.copyAllSolversButton.set_sensitive(meshok and nsolvers > 0) self.removeSolverButton.set_sensitive(subpok and subpctxt.solver_mode is not None) self.removeAllSolversButton.set_sensitive(meshok and nsolvers > 0) if subpok: suborder = subpctxt.solveOrder nsubs = meshctxt.nSubproblems() self.firstButton.set_sensitive(subpok and suborder > 0) self.earlierButton.set_sensitive(subpok and suborder > 0) self.laterButton.set_sensitive(subpok and suborder < nsubs-1) self.lastButton.set_sensitive(subpok and suborder < nsubs-1) ### Initialization Pane sensitization self.initview.set_sensitive(meshok) self.fieldinitbutton.set_sensitive(meshok and (fieldok or bcok)) self.copyinitbutton.set_sensitive(meshok and ninit > 0) self.clearinitbutton.set_sensitive( meshok and ( (fieldok and meshctxt.get_initializer(fld) is not None) or (bcok and bc.get_initializer() is not None))) self.clearallinitsbutton.set_sensitive(meshok and ninit > 0) self.applyinitbutton.set_sensitive(anyinits) self.applyinitattimebutton.set_sensitive(anyinits) ## Time pane sensitization self.endtimeEntry.set_sensitive(meshok) # self.stepsizeEntry.set_sensitive(meshok) timesok = (meshok and ((endtime is not None and meshctxt.getCurrentTime() <= endtime) or not timedependent)) self.solveButton.set_sensitive(timesok and solversok and meshctxt.status.solvable) if (meshctxt is not None and isinstance(meshctxt.status, (meshstatus.Solving, meshstatus.Solved)) and timedependent): self.solveButton.relabel("Continue") else: self.solveButton.relabel("Solve") self.statusDetailButton.set_sensitive(meshctxt is not None) gtklogger.checkpoint("Solver page sensitized")
def build(self, interactive): debug.mainthreadTest() # elclasses = masterelement.getMasterElementEnumClasses() nclasses = len(elementshape.enumClasses) # elgeometries = masterelement.getMasterElementGeometries() # Build the widgets if self.table is None or nclasses != self.nclasses: self.nclasses = nclasses if self.table: self.table.destroy() self.tablelabels = [] self.table = gtk.Table(rows=2+nclasses, columns=2) self.gtk.add(self.table) # Choosers for mapping and interpolation order self.mapchooser = chooser.ChooserWidget([], callback=self.orderCB, name="Map") self.funchooser = chooser.ChooserWidget([], callback=self.orderCB, name="Func") label = gtk.Label('mapping order') tooltips.set_tooltip_text(label,'Polynomial order of the functions used to map master elements to physical space.') label.set_alignment(1.0, 0.5) self.tablelabels.append(label) self.table.attach(label, 0, 1, 0, 1, xpadding=5, xoptions=gtk.FILL) self.table.attach(self.mapchooser.gtk, 1, 2, 0, 1, xpadding=5, xoptions=gtk.EXPAND|gtk.FILL) label = gtk.Label('interpolation order:') tooltips.set_tooltip_text(label,'Polynomial order of the functions used to interpolate within elements.') label.set_alignment(1.0, 0.5) self.tablelabels.append(label) self.table.attach(label, 0, 1, 1, 2, xpadding=5, xoptions=gtk.FILL) self.table.attach(self.funchooser.gtk, 1, 2, 1, 2, xpadding=5, xoptions=gtk.EXPAND|gtk.FILL) # Choosers for each element geometry row = 2 self.classwidgets = [] for geometry, elclass in elementshape.enumClasses.items(): label = gtk.Label(geometry+' element:') tooltips.set_tooltip_text( label, 'Type of finite element to use for %s elements' % geometry) label.set_alignment(1.0, 0.5) self.tablelabels.append(label) self.table.attach(label, 0,1, row,row+1, xoptions=gtk.FILL) ewidget = chooser.ChooserWidget([], name="%s element"%geometry) self.classwidgets.append((elclass, ewidget)) self.table.attach(ewidget.gtk, 1,2, row,row+1, xpadding=5, xoptions=gtk.EXPAND|gtk.FILL) row += 1 # Set the allowed values for each chooser. # Find out which mapping and interpolation orders have to be listed. maporderset = set() funorderset = set() for elclass in elementshape.enumClasses.values(): for elname in elclass.names: el = masterelement.getMasterElementFromEnum(elclass(elname)) maporderset.add(el.map_order()) funorderset.add(el.fun_order()) maporders = list(maporderset) maporders.sort() funorders = list(funorderset) funorders.sort() # List the orders in the widgets self.mapchooser.update([`order` for order in maporders]) self.funchooser.update([`order` for order in funorders]) try: current_map = int(self.mapchooser.get_value()) current_fun = int(self.funchooser.get_value()) except: # If the choosers don't have values, it's because there # aren't any elements defined. self.widgetChanged(validity=0, interactive=interactive) else: # Find and list the element types for the current shape ok = True for elclass, ewidget in self.classwidgets: elements = masterelement.getMasterElementsFromEnumClass(elclass) okels = [el for el in elements if el.map_order() == current_map and el.fun_order() == current_fun] ok = ok and len(okels) > 0 ewidget.update([el.name() for el in okels], elclass.helpdict) self.widgetChanged(validity=ok, interactive=interactive)
def cleanUp(self): debug.mainthreadTest() switchboard.removeCallback(self.sbcallback) parameterwidgets.ParameterWidget.cleanUp(self) del self.classwidgets del self.tablelabels
def makeWidgets(self): debug.mainthreadTest() tablepos = 0 self._doMakeWidgets(self, tablepos, self.paramhier)
def entryCB(self, entry): debug.mainthreadTest() self.widgetChanged(self.autocheck.get_active() and self.validText(self.text.get_text()), interactive=1)
def show(self): debug.mainthreadTest() self.gtk.show_all()
def unblock_signal(self): debug.mainthreadTest() self.signal.unblock()
def get_value(self): debug.mainthreadTest() return self.button.get_active()
def get_value(self): debug.mainthreadTest() if not self.autocheck.get_active(): return automatic.automatic return self.text.get_text()
def sensitize(self): debug.mainthreadTest() ParameterDialog.sensitize(self) self.dialog.set_response_sensitive(self.APPLY, self.table.isValid())
def get_value(self): debug.mainthreadTest() return self.gtk.get_text().lstrip()
def hide(self): debug.mainthreadTest() self.dialog.hide()
def set_value(self, newvalue): debug.mainthreadTest() valuestr = ` newvalue ` self.gtk.set_text(valuestr) self.gtk.set_position(0) # makes MSD visible
def close(self): debug.mainthreadTest() switchboard.removeCallback(self.sbcallback) self.dialog.destroy() self.destroyScope()
def _button_hook(self): debug.mainthreadTest() okbutton = self.dialog.add_button(gtk.STOCK_OK, self.OK) applybutton = self.dialog.add_button(gtk.STOCK_APPLY, self.APPLY) cancelbutton = self.dialog.add_button(gtk.STOCK_CANCEL, self.CANCEL) self.dialog.set_default_response(self.OK)
def __init__(self, toolbox, table, row): debug.mainthreadTest() pixelinfoplugin.PixelInfoPlugIn.__init__(self, toolbox) # Colorv is set by "update" and "nonsense", it can be None (no # color), -1 (Nonsense), or a color.Color object. # Statefulness is needed to remain consistent when a user # switches from RGB to HSV or vice versa. self.colorv = None label = gtk.Label('image=') label.set_alignment(1.0, 0.5) table.attach(label, 0, 1, row, row + 1, xpadding=5, xoptions=gtk.FILL) self.imagetext = gtk.Entry() gtklogger.setWidgetName(self.imagetext, "Image") self.imagetext.set_size_request(12 * guitop.top().charsize, -1) self.imagetext.set_editable(0) table.attach(self.imagetext, 1, 2, row, row + 1, xpadding=5, xoptions=gtk.EXPAND | gtk.FILL) selectorbox = gtk.HBox() self.rgb_selector = gtk.RadioButton(group=None, label="RGB") tooltips.set_tooltip_text( self.rgb_selector, "View color values in Red-Green-Blue format.") selectorbox.add(self.rgb_selector) self.hsv_selector = gtk.RadioButton(group=self.rgb_selector, label="HSV") tooltips.set_tooltip_text( self.hsv_selector, "View color values in Hue-Saturation-Value format.") selectorbox.add(self.hsv_selector) self.rgb_selector.set_active(1) # Default. # Because this is a two-element group of radio buttons, only # need to connect to the toggle signal on one of the buttons. # If more buttons get added, this strategy will fail. gtklogger.setWidgetName(self.rgb_selector, "RGB selector") # "toggle" signal is not actually logged. # gtklogger.connect(self.rgb_selector, "toggled", self.selector_cb) gtklogger.setWidgetName(self.hsv_selector, "HSV selector") gtklogger.connect(self.rgb_selector, "clicked", self.selector_cb) gtklogger.connect(self.hsv_selector, "clicked", self.selector_cb) table.attach(selectorbox, 0, 2, row + 1, row + 2, xoptions=gtk.EXPAND | gtk.FILL) self.label1 = gtk.Label('red=') self.label1.set_alignment(1.0, 0.5) table.attach(self.label1, 0, 1, row + 2, row + 3, xpadding=5, xoptions=gtk.FILL) self.text1 = gtk.Entry() gtklogger.setWidgetName(self.text1, 'Text 1') self.text1.set_size_request(10 * guitop.top().digitsize, -1) self.text1.set_editable(0) table.attach(self.text1, 1, 2, row + 2, row + 3, xpadding=5, xoptions=gtk.EXPAND | gtk.FILL) self.label2 = gtk.Label('green=') self.label2.set_alignment(1.0, 0.5) table.attach(self.label2, 0, 1, row + 3, row + 4, xpadding=5, xoptions=gtk.FILL) self.text2 = gtk.Entry() gtklogger.setWidgetName(self.text2, 'Text 2') self.text2.set_size_request(10 * guitop.top().digitsize, -1) self.text2.set_editable(0) table.attach(self.text2, 1, 2, row + 3, row + 4, xpadding=5, xoptions=gtk.EXPAND | gtk.FILL) self.label3 = gtk.Label('blue=') self.label3.set_alignment(1.0, 0.5) table.attach(self.label3, 0, 1, row + 4, row + 5, xpadding=5, xoptions=gtk.FILL) self.text3 = gtk.Entry() gtklogger.setWidgetName(self.text3, 'Text 3') self.text3.set_size_request(10 * guitop.top().digitsize, -1) self.text3.set_editable(0) table.attach(self.text3, 1, 2, row + 4, row + 5, xpadding=5, xoptions=gtk.EXPAND | gtk.FILL) self.sbcallbacks = [ switchboard.requestCallbackMain('modified image', self.image_changed) ]
def sensitize(self): debug.mainthreadTest() self.dialog.set_response_sensitive(self.OK, self.table.isValid())
def sensitizeHistory(self): debug.mainthreadTest() self.nextbutton.set_sensitive(self.historian.nextSensitive()) self.prevbutton.set_sensitive(self.historian.prevSensitive())
def run(self): debug.mainthreadTest() self.table.show() return self.dialog.run() # shows dialog & makes it modal
def prevButton(): debug.mainthreadTest() button = StockButton(gtk.STOCK_GO_BACK, 'Prev') gtklogger.setWidgetName(button, "Prev") return button
def sensitize(self): debug.mainthreadTest() self.clear.set_sensitive(self.toolbox.currentQuery() != (None, None)) self.prev.set_sensitive(not self.toolbox.queries.atBottom()) self.next.set_sensitive(not self.toolbox.queries.atTop())
def destroy(self): debug.mainthreadTest() self.gtk.destroy()
def nextButton(): debug.mainthreadTest() button = StockButton(gtk.STOCK_GO_FORWARD, 'Next', reverse=True) gtklogger.setWidgetName(button, "Next") return button
def get_value(self): debug.mainthreadTest() return strfunction.XYTStrFunction(self.gtk.get_text().lstrip())
def set_value(self, newvalue): debug.mainthreadTest() if newvalue is not None: self.gtk.set_text(newvalue.funcstr) else: self.gtk.set_text('')
def sliderCB(self, slider, val): debug.mainthreadTest() self.widgetChanged(1, interactive=1)
def nonsense(self): debug.mainthreadTest() self.materialtext.set_text('???')