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('???')
