Exemplo n.º 1
0
class XYZVectGUI(xyzGUI):
    def __init__(self,
                 master=None,
                 name='VectXYZ',
                 callback=None,
                 callbackX=None,
                 widthX=100,
                 heightX=26,
                 wheelPadX=4,
                 labcfgX={'text': None},
                 widthY=100,
                 heightY=26,
                 wheelPadY=4,
                 labcfgY={'text': None},
                 callbackY=None,
                 widthZ=100,
                 heightZ=26,
                 wheelPadZ=4,
                 callbackZ=None,
                 labcfgZ={'text': None},
                 **kw):

        xyzGUI.__init__(self, master, name, callback, callbackX, widthX,
                        heightX, wheelPadX, labcfgX, widthY, heightY,
                        wheelPadY, labcfgY, callbackY, widthZ, heightZ,
                        wheelPadZ, callbackZ, labcfgZ)

    def createEntries(self, master):
        self.f = Tkinter.Frame(master)
        self.f.grid(column=1, rowspan=6)

        self.entryX = NormVectEntry(master=self.f, label='Vector X', width=18)
        self.entryX.grid(row=0, column=0)
        self.entryX.callbacks.AddCallback(self.entryX_cb)

        self.thumbx = ThumbWheel(master=self.f,
                                 width=self.widthX,
                                 height=self.heightX,
                                 labcfg=self.labcfgX,
                                 wheelPad=self.wheelPadX)
        self.thumbx.callbacks.AddCallback(self.thumbx_cb)
        self.thumbx.grid(row=1, column=0)

        self.entryY = NormVectEntry(master=self.f, label='Vector Y', width=18)
        self.entryY.grid(row=2, column=0)
        self.entryY.callbacks.AddCallback(self.entryY_cb)

        self.thumby = ThumbWheel(master=self.f,
                                 width=self.widthY,
                                 height=self.heightY,
                                 labcfg=self.labcfgY,
                                 wheelPad=self.wheelPadY)
        self.thumby.callbacks.AddCallback(self.thumby_cb)
        self.thumby.grid(row=3, column=0)

        self.entryZ = NormVectEntry(master=self.f, label='Vector Z', width=18)
        self.entryZ.grid(row=4, column=0)
        self.entryZ.callbacks.AddCallback(self.entryZ_cb)

        self.thumbz = ThumbWheel(master=self.f,
                                 width=self.widthZ,
                                 height=self.heightZ,
                                 labcfg=self.labcfgZ,
                                 wheelPad=self.wheelPadZ)
        self.thumbz.callbacks.AddCallback(self.thumbz_cb)
        self.thumbz.grid(row=5, column=0)

        self.f.pack(side='top', expand=1)

        self.setVector([1.0, 0, 0], 'x')
        self.setVector([0.0, 1, 0], 'y')
        self.setVector([0.0, 0, 1], 'z')

    def set(self, x, y, z, v1, v2, v3):
        # called from outside
        self.thumbx.setValue(x)
        self.thumby.setValue(y)
        self.thumbz.setValue(z)
        self.entryX.set(v1)
        self.entryY.set(v2)
        self.entryZ.set(v3)

    def entryX_cb(self, events=None):
        self.callbacks.CallCallbacks(self.entryX.point)

    def entryY_cb(self, events=None):
        self.callbacks.CallCallbacks(self.entryY.point)

    def entryZ_cb(self, events=None):
        self.callbacks.CallCallbacks(self.entryZ.point)

#####################################################################
# the 'configure' methods:
#####################################################################

    def configure(self, **kw):
        for key, value in kw.items():
            # the 'set parameter' callbacks
            if key == 'labcfgX': self.setLabel(value, 'x')
            elif key == 'labcfgY': self.setLabel(value, 'y')
            elif key == 'labcfg': self.setLabel(value, 'z')

            elif key == 'continuousX': self.setContinuous(value, 'x')
            elif key == 'continuousY': self.setContinuous(value, 'y')
            elif key == 'continuousZ': self.setContinuous(value, 'z')

            elif key == 'precisionX': self.setPrecision(value, 'x')
            elif key == 'precisionY': self.setPrecision(value, 'y')
            elif key == 'precisionZ': self.setPrecision(value, 'z')

            elif key == 'typeX': self.setType(value, 'x')
            elif key == 'typeY': self.setType(value, 'y')
            elif key == 'typeZ': self.setType(value, 'z')

            elif key == 'minX': self.setMin(value, 'x')
            elif key == 'minY': self.setMin(value, 'y')
            elif key == 'minZ': self.setMin(value, 'z')

            elif key == 'maxX': self.setMax(value, 'x')
            elif key == 'maxY': self.setMax(value, 'y')
            elif key == 'maxZ': self.setMax(value, 'z')

            elif key == 'oneTurnX': self.setOneTurn(value, 'x')
            elif key == 'oneTurnY': self.setOneTurn(value, 'y')
            elif key == 'oneTurnZ': self.setOneTurn(value, 'z')

            elif key == 'showLabelX': self.setShowLabel(value, 'x')
            elif key == 'showLabelY': self.setShowLabel(value, 'y')
            elif key == 'showLabelZ': self.setShowLabel(value, 'z')

            elif key == 'incrementX': self.setIncrement(value, 'x')
            elif key == 'incrementY': self.setIncrement(value, 'y')
            elif key == 'incrementZ': self.setIncrement(value, 'z')

            elif key == 'vectX': self.setVector(value, 'x')
            elif key == 'vectY': self.setVector(value, 'y')
            elif key == 'vectZ':
                self.setVector(value, 'z')

                ####################################################

            elif key == 'lockTypeX':
                self.lockType(value, 'x')
            elif key == 'lockTypeY':
                self.lockType(value, 'y')
            elif key == 'lockTypeZ':
                self.lockType(value, 'z')

            elif key == 'lockMinX':
                self.lockMin(value, 'x')
            elif key == 'lockMinY':
                self.lockMin(value, 'y')
            elif key == 'lockMinZ':
                self.lockMin(value, 'z')

            elif key == 'lockBMinX':
                self.lockBMin(value, 'x')
            elif key == 'lockBMinY':
                self.lockBMin(value, 'y')
            elif key == 'lockBMinZ':
                self.lockBMin(value, 'z')

            elif key == 'lockMaxX':
                self.lockMax(value, 'x')
            elif key == 'lockMaxY':
                self.lockMax(value, 'y')
            elif key == 'lockMaxZ':
                self.lockMax(value, 'z')

            elif key == 'lockBMaxX':
                self.lockBMax(value, 'x')
            elif key == 'lockBMaxY':
                self.lockBMax(value, 'y')
            elif key == 'lockBMaxZ':
                self.lockBMax(value, 'z')

            elif key == 'lockIncrementX':
                self.lockIncrement(value, 'x')
            elif key == 'lockIncrementY':
                self.lockIncrement(value, 'y')
            elif key == 'lockIncrementZ':
                self.lockIncrement(value, 'z')

            elif key == 'lockBIncrementX':
                self.lockBIncrement(value, 'x')
            elif key == 'lockBIncrementY':
                self.lockBIncrement(value, 'y')
            elif key == 'lockBIncrementZ':
                self.lockBIncrement(value, 'z')

            elif key == 'lockPrecisionX':
                self.lockPrecision(value, 'x')
            elif key == 'lockPrecisionY':
                self.lockPrecision(value, 'y')
            elif key == 'lockPrecisionZ':
                self.lockPrecision(value, 'z')

            elif key == 'lockShowLabelX':
                self.lockShowLabel(value, 'x')
            elif key == 'lockShowLabelY':
                self.lockShowLabel(value, 'y')
            elif key == 'lockShowLabelZ':
                self.lockShowLabel(value, 'z')

            elif key == 'lockValueX':
                self.lockValue(value, 'x')
            elif key == 'lockValueY':
                self.lockValue(value, 'y')
            elif key == 'lockValueZ':
                self.lockValue(value, 'z')

            elif key == 'lockContinuousX':
                self.lockContinuous(value, 'x')
            elif key == 'lockContinuousY':
                self.lockContinuous(value, 'y')
            elif key == 'lockContinuousZ':
                self.lockContinuous(value, 'z')

            elif key == 'lockOneTurnX':
                self.lockOneTurn(value, 'x')
            elif key == 'lockOneTurnY':
                self.lockOneTurn(value, 'y')
            elif key == 'lockOneTurnZ':
                self.lockOneTurn(value, 'z')

    def setVector(self, value, mode):
        if mode == 'x':
            self.entryX.set(value)
        if mode == 'y':
            self.entryY.set(value)
        if mode == 'z':
            self.entryZ.set(value)
Exemplo n.º 2
0
class SelectionGUI:

    def __init__(self, master=None, viewerGui=None):

        if master is None:
            self.master = Tkinter.Toplevel()
            self.master.withdraw()
            self.master.title('Selection Settings')
            self.master.protocol('WM_DELETE_WINDOW', self.master.withdraw )
        else:
            self.master = master

        self.mainFrame = Tkinter.Frame(self.master, relief='ridge', borderwidth=3)

        # CONTOUR WIDTH
        if DejaVu.enableSelectionContour is True:
            lLabel =Tkinter.Label(self.mainFrame, text='Contour width:')
            lLabel.grid(row=0, column=0, sticky='w')
            self.contourSizeSlider = Slider.Slider(
                                        self.mainFrame,
                                        minval=0,
                                        maxval = 10,
                                        immediate=1,
                                        incr=1,
                                        labelformat = '%d',
                                        cursortype='int'
                                        )
            self.contourSizeSlider.frame.grid(row=0, column=1, columnspan=3)
            def setContourWidthSliderValue_cb(val):
                DejaVu.selectionContourSize = val
                viewerGui.viewer.Redraw()
            self.contourSizeSlider.AddCallback(setContourWidthSliderValue_cb)
        else:
            lLabel =Tkinter.Label(self.mainFrame, text='Contour selection is disabled')
            lLabel.grid(row=0, column=0, columnspan=3, sticky='w')

        # BACKGROUND COLOR
        lLabel =Tkinter.Label(self.mainFrame, text='Contour color:')
        lLabel.grid(row=1, column=0, sticky='w')
        lFunc = CallBackFunction(viewerGui.colorChooser.showColorChooser,'selection contour')
        self.contourColorButton = Tkinter.Button(self.mainFrame,
                                 #text='Contour color',
                                 width=7,
                                 background=TkColor(DejaVu.selectionContourColor),
                                 command=lFunc)
        self.contourColorButton.grid(row=1, column=1, columnspan=3)

        # PATTERN SIZE
        lLabel =Tkinter.Label(self.mainFrame, text='Pattern size:')
        lLabel.grid(row=2, column=0, sticky='w')
        
        def setPatternSizeSliderValue_cb(val):
            DejaVu.selectionPatternSize = val
            viewerGui.viewer.Redraw()

        self.patternSizeThumbwheel = ThumbWheel(
                             self.mainFrame, width=70, height=16, type=int,
                             value=DejaVu.selectionPatternSize,
                             callback=setPatternSizeSliderValue_cb,
                             continuous=True, oneTurn=10,
                             wheelPad=2, min=0, max=50)
        self.patternSizeThumbwheel.grid(row=2, column=1, columnspan=3)

        self.mainFrame.pack(side='top')

        self.updateWidgets()


    def show(self, event=None):
        #print "showSpinGui", self
        if self.master.winfo_ismapped() == 0:
            self.master.deiconify()
        self.master.lift()


    def hide(self, event=None):
        #print "hideSpinGui", self
        if self.master.winfo_ismapped() == 1:
            self.master.withdraw()


    def toggle(self, event=None):
        #print "toggleSpinGui", self
        if self.master.winfo_ismapped() == 1:
            self.master.withdraw()
        else:
            self.master.deiconify()
            self.master.lift()


    def setWithWidgets(self):
        if DejaVu.enableSelectionContour is True:
            DejaVu.selectionContourSize = self.contourSizeSlider.Get()
        DejaVu.selectionPatternSize = self.patternSizeThumbwheel.Get()


    def updateWidgets(self):
        if DejaVu.enableSelectionContour is True:
            self.contourSizeSlider.Set(DejaVu.selectionContourSize)
        self.contourColorButton.configure(background=TkColor(DejaVu.selectionContourColor))
        self.patternSizeThumbwheel.set(DejaVu.selectionPatternSize)
Exemplo n.º 3
0
class SelectionGUI:
    def __init__(self, master=None, viewerGui=None):

        if master is None:
            self.master = Tkinter.Toplevel()
            self.master.withdraw()
            self.master.title('Selection Settings')
            self.master.protocol('WM_DELETE_WINDOW', self.master.withdraw)
        else:
            self.master = master

        self.mainFrame = Tkinter.Frame(self.master,
                                       relief='ridge',
                                       borderwidth=3)

        # CONTOUR WIDTH
        if DejaVu.enableSelectionContour is True:
            lLabel = Tkinter.Label(self.mainFrame, text='Contour width:')
            lLabel.grid(row=0, column=0, sticky='w')
            self.contourSizeSlider = Slider.Slider(self.mainFrame,
                                                   minval=0,
                                                   maxval=10,
                                                   immediate=1,
                                                   incr=1,
                                                   labelformat='%d',
                                                   cursortype='int')
            self.contourSizeSlider.frame.grid(row=0, column=1, columnspan=3)

            def setContourWidthSliderValue_cb(val):
                DejaVu.selectionContourSize = val
                viewerGui.viewer.Redraw()

            self.contourSizeSlider.AddCallback(setContourWidthSliderValue_cb)
        else:
            lLabel = Tkinter.Label(self.mainFrame,
                                   text='Contour selection is disabled')
            lLabel.grid(row=0, column=0, columnspan=3, sticky='w')

        # BACKGROUND COLOR
        lLabel = Tkinter.Label(self.mainFrame, text='Contour color:')
        lLabel.grid(row=1, column=0, sticky='w')
        lFunc = CallBackFunction(viewerGui.colorChooser.showColorChooser,
                                 'selection contour')
        self.contourColorButton = Tkinter.Button(
            self.mainFrame,
            #text='Contour color',
            width=7,
            background=TkColor(DejaVu.selectionContourColor),
            command=lFunc)
        self.contourColorButton.grid(row=1, column=1, columnspan=3)

        # PATTERN SIZE
        lLabel = Tkinter.Label(self.mainFrame, text='Pattern size:')
        lLabel.grid(row=2, column=0, sticky='w')

        def setPatternSizeSliderValue_cb(val):
            DejaVu.selectionPatternSize = val
            viewerGui.viewer.Redraw()

        self.patternSizeThumbwheel = ThumbWheel(
            self.mainFrame,
            width=70,
            height=16,
            type=int,
            value=DejaVu.selectionPatternSize,
            callback=setPatternSizeSliderValue_cb,
            continuous=True,
            oneTurn=10,
            wheelPad=2,
            min=0,
            max=50)
        self.patternSizeThumbwheel.grid(row=2, column=1, columnspan=3)

        self.mainFrame.pack(side='top')

        self.updateWidgets()

    def show(self, event=None):
        #print "showSpinGui", self
        if self.master.winfo_ismapped() == 0:
            self.master.deiconify()
        self.master.lift()

    def hide(self, event=None):
        #print "hideSpinGui", self
        if self.master.winfo_ismapped() == 1:
            self.master.withdraw()

    def toggle(self, event=None):
        #print "toggleSpinGui", self
        if self.master.winfo_ismapped() == 1:
            self.master.withdraw()
        else:
            self.master.deiconify()
            self.master.lift()

    def setWithWidgets(self):
        if DejaVu.enableSelectionContour is True:
            DejaVu.selectionContourSize = self.contourSizeSlider.Get()
        DejaVu.selectionPatternSize = self.patternSizeThumbwheel.Get()

    def updateWidgets(self):
        if DejaVu.enableSelectionContour is True:
            self.contourSizeSlider.Set(DejaVu.selectionContourSize)
        self.contourColorButton.configure(
            background=TkColor(DejaVu.selectionContourColor))
        self.patternSizeThumbwheel.set(DejaVu.selectionPatternSize)
class XYZVectGUI(xyzGUI):

    def __init__(self, master=None, name='VectXYZ', callback=None,
                 callbackX=None, widthX=100, heightX=26, wheelPadX=4,
                 labcfgX={'text':None}, widthY=100, heightY=26, wheelPadY=4,
                 labcfgY={'text':None}, callbackY=None, widthZ=100,
                 heightZ=26, wheelPadZ=4, callbackZ=None,
                 labcfgZ={'text':None}, **kw):

        xyzGUI.__init__(self, master, name, callback, callbackX, widthX,
                        heightX, wheelPadX, labcfgX, widthY, heightY,
                        wheelPadY, labcfgY, callbackY, widthZ, heightZ,
                        wheelPadZ, callbackZ, labcfgZ)

        
    def createEntries(self, master):
        self.f = Tkinter.Frame(master)
	self.f.grid(column=1, rowspan=6)

        self.entryX = NormVectEntry(master=self.f, label='Vector X', width=18)
        self.entryX.grid(row=0,column=0)
        self.entryX.callbacks.AddCallback(self.entryX_cb)

        self.thumbx = ThumbWheel(master=self.f, width=self.widthX,
                                 height=self.heightX, labcfg=self.labcfgX,
                                 wheelPad=self.wheelPadX)
        self.thumbx.callbacks.AddCallback(self.thumbx_cb)
        self.thumbx.grid(row=1, column=0)

        self.entryY = NormVectEntry(master=self.f, label='Vector Y', width=18)
        self.entryY.grid(row=2,column=0)
        self.entryY.callbacks.AddCallback(self.entryY_cb)


        self.thumby = ThumbWheel(master=self.f, width=self.widthY,
                                 height=self.heightY, labcfg=self.labcfgY,
                                 wheelPad=self.wheelPadY)
        self.thumby.callbacks.AddCallback(self.thumby_cb)
        self.thumby.grid(row=3, column=0)

        self.entryZ = NormVectEntry(master=self.f, label='Vector Z', width=18)
        self.entryZ.grid(row=4,column=0)
        self.entryZ.callbacks.AddCallback(self.entryZ_cb)


        self.thumbz = ThumbWheel(master=self.f, width=self.widthZ,
                                 height=self.heightZ, labcfg=self.labcfgZ,
                                 wheelPad=self.wheelPadZ)
        self.thumbz.callbacks.AddCallback(self.thumbz_cb)
        self.thumbz.grid(row=5, column=0)

        self.f.pack(side='top', expand=1)

        self.setVector([1.0,0,0],'x')
        self.setVector([0.0,1,0],'y')
        self.setVector([0.0,0,1],'z')

    def set(self, x, y, z, v1, v2, v3):
        # called from outside
        self.thumbx.setValue(x)
        self.thumby.setValue(y)
        self.thumbz.setValue(z)
        self.entryX.set(v1)
        self.entryY.set(v2)
        self.entryZ.set(v3)


    def entryX_cb(self, events=None):
        self.callbacks.CallCallbacks(self.entryX.point)
        

    def entryY_cb(self, events=None):
        self.callbacks.CallCallbacks(self.entryY.point)


    def entryZ_cb(self, events=None):
        self.callbacks.CallCallbacks(self.entryZ.point)


 #####################################################################
 # the 'configure' methods:
 #####################################################################

    def configure(self, **kw):
        for key,value in kw.items():
            # the 'set parameter' callbacks
            if key=='labcfgX': self.setLabel(value,'x')
            elif key=='labcfgY': self.setLabel(value,'y')
            elif key=='labcfg': self.setLabel(value,'z')

            elif key=='continuousX': self.setContinuous(value,'x')
            elif key=='continuousY': self.setContinuous(value,'y')
            elif key=='continuousZ': self.setContinuous(value,'z')

            elif key=='precisionX': self.setPrecision(value,'x')
            elif key=='precisionY': self.setPrecision(value,'y')
            elif key=='precisionZ': self.setPrecision(value,'z')

            elif key=='typeX': self.setType(value,'x')
            elif key=='typeY': self.setType(value,'y')
            elif key=='typeZ': self.setType(value,'z')

            elif key=='minX': self.setMin(value,'x')
            elif key=='minY': self.setMin(value,'y')
            elif key=='minZ': self.setMin(value,'z')

            elif key=='maxX': self.setMax(value,'x')
            elif key=='maxY': self.setMax(value,'y')
            elif key=='maxZ': self.setMax(value,'z')

            elif key=='oneTurnX': self.setOneTurn(value,'x')
            elif key=='oneTurnY': self.setOneTurn(value,'y')
            elif key=='oneTurnZ': self.setOneTurn(value,'z')

            elif key=='showLabelX': self.setShowLabel(value,'x')
            elif key=='showLabelY': self.setShowLabel(value,'y')
            elif key=='showLabelZ': self.setShowLabel(value,'z')

            elif key=='incrementX': self.setIncrement(value,'x')
            elif key=='incrementY': self.setIncrement(value,'y')
            elif key=='incrementZ': self.setIncrement(value,'z')

            elif key=='vectX' : self.setVector(value,'x')
            elif key=='vectY' : self.setVector(value,'y')
            elif key=='vectZ' : self.setVector(value,'z')

            ####################################################

            elif key=='lockTypeX': self.lockType(value,'x')
            elif key=='lockTypeY': self.lockType(value,'y')
            elif key=='lockTypeZ': self.lockType(value,'z')

            elif key=='lockMinX': self.lockMin(value,'x')
            elif key=='lockMinY': self.lockMin(value,'y')
            elif key=='lockMinZ': self.lockMin(value,'z')

            elif key=='lockBMinX': self.lockBMin(value,'x')
            elif key=='lockBMinY': self.lockBMin(value,'y')
            elif key=='lockBMinZ': self.lockBMin(value,'z')

            elif key=='lockMaxX': self.lockMax(value,'x')
            elif key=='lockMaxY': self.lockMax(value,'y')
            elif key=='lockMaxZ': self.lockMax(value,'z')

            elif key=='lockBMaxX': self.lockBMax(value,'x')
            elif key=='lockBMaxY': self.lockBMax(value,'y')
            elif key=='lockBMaxZ': self.lockBMax(value,'z')

            elif key=='lockIncrementX': self.lockIncrement(value,'x')
            elif key=='lockIncrementY': self.lockIncrement(value,'y')
            elif key=='lockIncrementZ': self.lockIncrement(value,'z')

            elif key=='lockBIncrementX': self.lockBIncrement(value,'x')
            elif key=='lockBIncrementY': self.lockBIncrement(value,'y')
            elif key=='lockBIncrementZ': self.lockBIncrement(value,'z')

            elif key=='lockPrecisionX': self.lockPrecision(value,'x')
            elif key=='lockPrecisionY': self.lockPrecision(value,'y')
            elif key=='lockPrecisionZ': self.lockPrecision(value,'z')

            elif key=='lockShowLabelX': self.lockShowLabel(value,'x')
            elif key=='lockShowLabelY': self.lockShowLabel(value,'y')
            elif key=='lockShowLabelZ': self.lockShowLabel(value,'z')

            elif key=='lockValueX': self.lockValue(value,'x')
            elif key=='lockValueY': self.lockValue(value,'y')
            elif key=='lockValueZ': self.lockValue(value,'z')

            elif key=='lockContinuousX': self.lockContinuous(value,'x')
            elif key=='lockContinuousY': self.lockContinuous(value,'y')
            elif key=='lockContinuousZ': self.lockContinuous(value,'z')

            elif key=='lockOneTurnX': self.lockOneTurn(value,'x')
            elif key=='lockOneTurnY': self.lockOneTurn(value,'y')
            elif key=='lockOneTurnZ': self.lockOneTurn(value,'z')


    def setVector(self, value, mode):
       if mode == 'x':
           self.entryX.set(value)
       if mode == 'y':
            self.entryY.set(value)
       if mode == 'z':
            self.entryZ.set(value)