def layoutWidgets(self):
        """
        Создание и настройка кнопок и виджетов
        """
        mainSizer = wx.BoxSizer(wx.VERTICAL)
        self.fgSizer = wx.FlexGridSizer(rows=3, cols=3, vgap=5, hgap=5)
        btnSizer = wx.BoxSizer(wx.HORIZONTAL)
        font = wx.Font(22, wx.FONTFAMILY_DEFAULT, wx.FONTSTYLE_NORMAL,
                       wx.FONTWEIGHT_BOLD)
        size = (100, 100)
        self.button1 = buttons.GenToggleButton(self, size=size, name="btn1")
        self.button2 = buttons.GenToggleButton(self, size=size, name="btn2")
        self.button3 = buttons.GenToggleButton(self, size=size, name="btn3")
        self.button4 = buttons.GenToggleButton(self, size=size, name="btn4")
        self.button5 = buttons.GenToggleButton(self, size=size, name="btn5")
        self.button6 = buttons.GenToggleButton(self, size=size, name="btn6")
        self.button7 = buttons.GenToggleButton(self, size=size, name="btn7")
        self.button8 = buttons.GenToggleButton(self, size=size, name="btn8")
        self.button9 = buttons.GenToggleButton(self, size=size, name="btn9")
        self.normalBtnColour = self.button1.GetBackgroundColour()

        self.widgets = [
            self.button1, self.button2, self.button3, self.button4,
            self.button5, self.button6, self.button7, self.button8,
            self.button9
        ]

        # изменение шрифта кнопок и привязка к событию
        for button in self.widgets:
            button.SetFont(font)
            button.Bind(wx.EVT_BUTTON, self.onToggle)

        # добавление виджета на сайзер
        self.fgSizer.AddMany(self.widgets)
        mainSizer.Add(self.fgSizer, 0, wx.ALL | wx.CENTER, 5)

        self.endTurnBtn = wx.Button(self, label="Завершить ход")
        self.endTurnBtn.Bind(wx.EVT_BUTTON, self.onEndTurn)
        self.endTurnBtn.Disable()
        btnSizer.Add(self.endTurnBtn, 0, wx.ALL | wx.CENTER, 5)

        startOverBtn = wx.Button(self, label="Перезапуск игры")
        startOverBtn.Bind(wx.EVT_BUTTON, self.onRestart)
        btnSizer.Add(startOverBtn, 0, wx.ALL | wx.CENTER, 5)
        mainSizer.Add(btnSizer, 0, wx.CENTER)

        self.methodsToWin = [
            (self.button1, self.button2, self.button3),
            (self.button4, self.button5, self.button6),
            (self.button7, self.button8, self.button9),
            # победа по горизонтали
            (self.button1, self.button4, self.button7),
            (self.button2, self.button5, self.button8),
            (self.button3, self.button6, self.button9),
            # победа по вертикали
            (self.button1, self.button5, self.button9),
            (self.button3, self.button5, self.button7)
        ]
        # победа по диагонали
        self.SetSizer(mainSizer)
Ejemplo n.º 2
0
    def layoutWidgets(self):
        """
Create and layout the widgets
"""
        mainSizer = wx.BoxSizer(wx.VERTICAL)
        self.fgSizer = wx.FlexGridSizer(rows=3, cols=3, vgap=5, hgap=5)
        #btnSizer = wx.BoxSizer(wx.HORIZONTAL)
        font = wx.Font(22, wx.FONTFAMILY_DEFAULT, wx.FONTSTYLE_NORMAL,
                       wx.FONTWEIGHT_BOLD)

        size = (100, 100)
        self.button1 = buttons.GenToggleButton(self, size=size, name="btn1")
        self.button2 = buttons.GenToggleButton(self, size=size, name="btn2")
        self.button3 = buttons.GenToggleButton(self, size=size, name="btn3")
        self.button4 = buttons.GenToggleButton(self, size=size, name="btn4")
        self.button5 = buttons.GenToggleButton(self, size=size, name="btn5")
        self.button6 = buttons.GenToggleButton(self, size=size, name="btn6")
        self.button7 = buttons.GenToggleButton(self, size=size, name="btn7")
        self.button8 = buttons.GenToggleButton(self, size=size, name="btn8")
        #self.button9 = buttons.GenToggleButton(self, size=size, name="btn9")
        #self.button9 = wx.BitmapButton(self, wx.ID_ANY, self.contbmp, pos=(150,300), style=wx.NO_BORDER)
        self.normalBtnColour = self.button1.GetBackgroundColour()

        self.widgets = [
            self.button1, self.button2, self.button3, self.button4,
            self.button5, self.button6, self.button7, self.button8
        ]

        # change all the main game buttons' font and bind them to an event
        for button in self.widgets:
            button.SetFont(font)
            button.Bind(wx.EVT_BUTTON, self.onToggle)

        # add the widgets to the sizers
        self.fgSizer.AddMany(self.widgets)
        mainSizer.Add(self.fgSizer, 0, wx.ALL | wx.CENTER, 5)

        self.endTurnBtn = wx.Button(self, label="End Turn")
        self.endTurnBtn.Bind(wx.EVT_BUTTON, self.onEndTurn)
        self.endTurnBtn.Disable()
        btnSizer.Add(self.endTurnBtn, 0, wx.ALL | wx.CENTER, 5)

        startOverBtn = wx.Button(self, label="Restart")
        startOverBtn.Bind(wx.EVT_BUTTON, self.onRestart)
        btnSizer.Add(startOverBtn, 0, wx.ALL | wx.CENTER, 5)
        mainSizer.Add(btnSizer, 0, wx.CENTER)

        self.methodsToWin = [
            (self.button1, self.button2, self.button3),
            (self.button4, self.button5, self.button6),
            # vertical ways to win
            (self.button1, self.button4, self.button7),
            (self.button2, self.button5, self.button8),
            # diagonal ways to win
            (self.button3, self.button5, self.button7)
        ]

        self.SetSizer(mainSizer)
Ejemplo n.º 3
0
    def __init__(self):
        wx.Frame.__init__(self, None, wx.ID_ANY, "Button Tutorial")
        panel = wx.Panel(self, wx.ID_ANY)

        # create a normal toggle button
        button = wx.ToggleButton(panel, label="Press Me")
        button.Bind(wx.EVT_TOGGLEBUTTON, self.onToggle)

        # create a generic toggle button
        gen_toggle_button = buttons.GenToggleButton(panel, -1,
                                                    "Generic Toggle")
        gen_toggle_button.Bind(wx.EVT_BUTTON, self.onGenericToggle)

        # create a normal bitmap button
        bmp = wx.Bitmap("img/new.ico", wx.BITMAP_TYPE_ANY)
        bmapBtn = wx.BitmapButton(panel,
                                  id=wx.ID_ANY,
                                  bitmap=bmp,
                                  size=(bmp.GetWidth() + 10,
                                        bmp.GetHeight() + 10))

        # create a generic bitmap button
        genBmapBtn = buttons.GenBitmapButton(panel, bitmap=bmp)

        sizer = wx.BoxSizer(wx.VERTICAL)
        sizer.Add(button, 0, wx.ALL, 5)
        sizer.Add(gen_toggle_button, 0, wx.ALL, 5)
        sizer.Add(bmapBtn, 0, wx.ALL, 5)
        sizer.Add(genBmapBtn, 0, wx.ALL, 5)
        panel.SetSizer(sizer)
Ejemplo n.º 4
0
    def SetPV(self, pv=None):
        "set pv, either an epics.PV object or a pvname"
        if pv is None:
            return
        if isinstance(pv, epics.PV):
            self.pv = pv
        elif isinstance(pv, (str, unicode)):
            self.pv = epics.PV(pv)
            self.pv.connect()

        epics.poll()
        self.pv.connection_callbacks.append(self.OnEpicsConnect)

        self.pv.get_ctrlvars()

        self.OnPVChange(self.pv.get(as_string=True))
        self.pv.add_callback(self._pvEvent, wid=self.GetId())

        pv_value = pv.get(as_string=True)
        enum_strings = pv.enum_strs

        sizer = wx.BoxSizer(self.orientation)
        self.buttons = []
        if enum_strings is not None:
            for i, label in enumerate(enum_strings):
                b = buttons.GenToggleButton(self, -1, label)
                self.buttons.append(b)
                b.Bind(wx.EVT_BUTTON, Closure(self._onButton, index=i))
                b.Bind(wx.EVT_RIGHT_DOWN, self._onRightDown)
                sizer.Add(b, flag=wx.ALL)
                b.SetToggle(label == pv_value)

        self.SetAutoLayout(True)
        self.SetSizer(sizer)
        sizer.Fit(self)
Ejemplo n.º 5
0
    def __init__(self):
        wx.Frame.__init__(self, None, -1, "Generic Button Example",
                            size=(500, 500))
        panel = wx.Panel(self, -1)
        sizer = wx.FlexGridSizer(1, 3, 20, 20)
        b = wx.Button(panel, -1, 'A wx.Button')
        b.SetDefault()
        sizer.Add(b)
        b = wx.Button(panel, -1, 'non-default wx.Button')
        sizer.Add(b)
        sizer.Add((10,10))
        b = buttons.GenButton(panel, -1, 'Genric Button')#基本的通用按钮
        sizer.Add(b)

        b = buttons.GenButton(panel, -1, 'disabled Generic')#无效的通用按钮
        b.Enable(False)
        sizer.Add(b)
        b = buttons.GenButton(panel, -1, 'F')#自定义尺寸和颜色的按钮
        b.SetFont(wx.Font(20, wx.SWISS, wx.NORMAL, wx.BOLD, False))
        b.SetBezelWidth(5)
        b.SetBackgroundColour("Navy")
        b.SetForegroundColour("white")
        b.SetToolTipString("This is a BIG button...")
        sizer.Add(b)
        bmp = wx.Image("Pause.png", wx.BITMAP_TYPE_PNG).ConvertToBitmap()
        b = buttons.GenBitmapButton(panel, -1, bmp)#通用位图按钮
        sizer.Add(b)
        self.btest = buttons.GenBitmapToggleButton(panel, -1, bmp)#通用位图开关按钮
        sizer.Add(self.btest)
        b = buttons.GenBitmapTextButton(panel, -1, bmp, 'Bitmapped Text',size=(375, 75))#位图文本按钮
        b.SetUseFocusIndicator(False)
        sizer.Add(b)
        b = buttons.GenToggleButton(panel, -1, 'Toggle Button')#通用开关按钮
        sizer.Add(b)
        panel.SetSizer(sizer)
Ejemplo n.º 6
0
    def __init__(self, parent, pv=None, orientation=wx.HORIZONTAL, **kw):

        wx.Panel.__init__(self, parent, wx.ID_ANY, **kw)
        pvCtrlMixin.__init__(self, pv=pv)

        pv.wait_for_connection()
        pv_value = pv.get(as_string=True)
        enum_strings = pv.enum_strs

        if enum_strings is None:
            self._warn('pvEnumButtons needs an enum PV')
            return

        sizer = wx.BoxSizer(orientation)
        self.buttons = []
        if enum_strings is not None:
            for i, label in enumerate(enum_strings):
                b = buttons.GenToggleButton(self, -1, label)
                self.buttons.append(b)
                b.Bind(wx.EVT_BUTTON, Closure(self._onButton, index=i))
                sizer.Add(b, flag=wx.ALL)
                b.SetToggle(label == pv_value)

        self.SetAutoLayout(True)
        self.SetSizer(sizer)
        sizer.Fit(self)
Ejemplo n.º 7
0
    def __init__(self, *args, **kwargs):
        wx.Dialog.__init__(self, *args, **kwargs)
        self.SetSize((550, 500))
        self.fbb = filebrowse.FileBrowseButton(self,
                                               -1, (0, 0),
                                               size=(450, -1),
                                               labelText="File",
                                               changeCallback=self.fbbCallback)
        wx.StaticText(self, -1, "Port mapping", (20, 40))
        self.gd_portmap = PortMapGrid(self, -1, (0, 60), (220, 300))

        wx.StaticText(self, -1, "Chart Type", (260, 40))
        self.cmb_charttype = wx.ComboBox(self, -1, "Grid dB-Mag", (260, 60),
                                         (160, -1),
                                         ["Grid dB-Mag", "Grid Angle"],
                                         wx.CB_DROPDOWN | wx.CB_READONLY)

        wx.StaticText(self, -1, "Curves", (260, 90))
        self.clb_splist = wx.CheckListBox(self, -1, (260, 110), (160, 250))

        posy = 110
        self.btn_spfilter = []
        for b in ["CC", "CD", "DC", "DD"]:
            btn = buttons.GenToggleButton(self, -1, "All %s's" % b,
                                          (440, posy))
            posy += 30
            self.btn_spfilter.append(btn)
            btn.Bind(wx.EVT_BUTTON, self.OnSPFilter)

        wx.Button(self, wx.ID_OK, "OK", (100, 400))
        wx.Button(self, wx.ID_CANCEL, "Cancel", (200, 400))
Ejemplo n.º 8
0
 def __init__(self,x,y,height,width,name,mode,parent):
         if(mode==1):    #Flat Button
                 wx.Button(parent,-1,name,pos=(x,y),size=(height,width),style=wx.NO_BORDER)
         elif(mode==2):
                 buttons.GenToggleButton(parent, -1,label=name,pos=(x,y))
         elif(mode==4):
                 btn = platebtn.PlateButton(parent, label=name, pos=(x,y),size=(height,width),style=platebtn.PB_STYLE_GRADIENT)
         else:   #Normal Button
                 wx.Button(parent,-1,name,pos=(x,y),size=(height,width))
Ejemplo n.º 9
0
    def __init__(self):
        wx.Frame.__init__(self,
                          None,
                          -1,
                          'Generic Button Example',
                          size=(500, 400))
        panel = wx.Panel(self, -1)

        #Can also have rows=x. Can cause errors if set wrongly
        #Don't need the n = ... part, but helped for troubleshooting
        sizer = wx.FlexGridSizer(cols=3, vgap=20, hgap=20)
        b = wx.Button(panel, -1, "A wx.Button")
        b.SetDefault()
        sizer.Add(b)

        #Interesting, can reuse b, now that it is saved to sizer
        b = wx.Button(panel, -1, "non-default wx.Button")
        sizer.Add(b)

        sizer.Add((10, 10))

        b = buttons.GenButton(panel, -1, 'Generic Button')
        sizer.Add(b)

        b = buttons.GenButton(panel, -1, 'disabled Generic')
        b.Enable(False)
        sizer.Add(b)

        b = buttons.GenButton(panel, -1, 'bigger')
        b.SetFont(wx.Font(20, wx.SWISS, wx.NORMAL, wx.BOLD, False))
        b.SetBezelWidth(5)
        #?? Does capitalisation matter
        b.SetBackgroundColour("Navy")
        b.SetForegroundColour("white")
        b.SetToolTipString("This is a BIG button...")
        sizer.Add(b)

        bmp = wx.Image("bitmap.bmp", wx.BITMAP_TYPE_BMP).ConvertToBitmap()
        b = buttons.GenBitmapButton(panel, -1, bmp)
        sizer.Add(b)

        b = buttons.GenBitmapToggleButton(panel, -1, bmp)
        sizer.Add(b)

        b = buttons.GenBitmapTextButton(panel,
                                        -1,
                                        bmp,
                                        "Bitmapped Text",
                                        size=(175, 175))
        #?? What do again
        b.SetUseFocusIndicator(False)
        sizer.Add(b)

        b = buttons.GenToggleButton(panel, -1, "ToggleButton")
        sizer.Add(b)

        panel.SetSizer(sizer)
Ejemplo n.º 10
0
    def layoutWidgets(self):
        # Create and layout the widgets

        mainSizer = wx.BoxSizer(wx.VERTICAL)
        self.fgSizer = wx.FlexGridSizer(rows=3, cols=3, vgap=5, hgap=5)
        font = wx.Font(24, wx.FONTFAMILY_DEFAULT, wx.FONTSTYLE_NORMAL,
                       wx.FONTWEIGHT_BOLD)

        size = (120, 120)
        self.button1 = buttons.GenToggleButton(self, size=size)
        self.button2 = buttons.GenToggleButton(self, size=size)
        self.button3 = buttons.GenToggleButton(self, size=size)
        self.button4 = buttons.GenToggleButton(self, size=size)
        self.button5 = buttons.GenToggleButton(self, size=size)
        self.button6 = buttons.GenToggleButton(self, size=size)
        self.button7 = buttons.GenToggleButton(self, size=size)
        self.button8 = buttons.GenToggleButton(self, size=size)
        self.button9 = buttons.GenToggleButton(self, size=size)
        self.widgets = [self.button1, self.button2, self.button3,
                        self.button4, self.button5, self.button6,
                        self.button7, self.button8, self.button9]

        for button in self.widgets:
            button.SetFont(font)
            button.Bind(wx.EVT_BUTTON, self.onToggle)

        self.fgSizer.AddMany(self.widgets)
        mainSizer.Add(self.fgSizer, 0, wx.ALL | wx.CENTER, 5)

        endTurnBtn = wx.Button(self, label="End Turn")
        endTurnBtn.Bind(wx.EVT_BUTTON, self.onEndTurn)
        mainSizer.Add(endTurnBtn, 0, wx.ALL | wx.CENTER, 5)

        self.methodsToWin = [(self.button1, self.button2, self.button3),
                             (self.button4, self.button5, self.button6),
                             (self.button7, self.button8, self.button9),
                             # vertical ways to win
                             (self.button1, self.button4, self.button7),
                             (self.button2, self.button5, self.button8),
                             (self.button3, self.button6, self.button9),
                             # diagonal ways to win
                             (self.button1, self.button5, self.button9),
                             (self.button3, self.button5, self.button7)]

        self.SetSizer(mainSizer)
Ejemplo n.º 11
0
    def __init__(self):
        wx.Frame.__init__(self,
                          None,
                          -1,
                          "Generic Button Example",
                          size=(500, 350))
        panel = wx.Panel(self, -1)

        sizer = wx.FlexGridSizer(3, 3, 20, 20)
        b = wx.Button(panel, -1, "A wx.Button")
        b.SetDefault()
        sizer.Add(b)

        b = wx.Button(panel, -1, "non-default wx.Button")
        sizer.Add(b)

        b = buttons.GenButton(panel, -1, "Generic Button")
        sizer.Add(b)

        b = buttons.GenButton(panel, -1, "disabled Generic")
        b.Enable(False)
        sizer.Add(b)

        b = buttons.GenButton(panel, -1, "bigger")
        b.SetFont(wx.Font(20, wx.SWISS, wx.NORMAL, wx.BOLD))
        b.SetBezelWidth(5)
        b.SetBackgroundColour("Navy")
        b.SetForegroundColour("white")
        b.SetToolTip("This is a BIG button!")
        sizer.Add(b)

        bmp = wx.Image("img/button-off.png",
                       wx.BITMAP_TYPE_PNG).ConvertToBitmap()

        b = buttons.GenBitmapButton(panel, -1, bmp)
        sizer.Add(b)

        b = buttons.GenBitmapToggleButton(panel, -1, bmp)
        sizer.Add(b)

        b = buttons.GenBitmapTextButton(panel,
                                        -1,
                                        bmp,
                                        "Bitmap Text",
                                        size=(175, 75))
        b.SetUseFocusIndicator(False)
        sizer.Add(b)

        b = buttons.GenToggleButton(panel, -1, "Toggle Button")
        sizer.Add(b)

        panel.SetSizer(sizer)
Ejemplo n.º 12
0
    def __init__(self):
        wx.Frame.__init__(self,
                          None,
                          -1,
                          'Generic Button Example',
                          size=(500, 350))
        panel = wx.Panel(self, -1)

        sizer = wx.FlexGridSizer(1, 3, 20, 20)
        b = wx.Button(panel, -1, "A wx.Button")
        b.SetDefault()
        sizer.Add(b)

        b = wx.Button(panel, -1, "non-default wx.Button")
        sizer.Add(b)
        sizer.Add((10, 10))

        b = buttons.GenButton(panel, -1, 'Generic Button')
        sizer.Add(b)

        b = buttons.GenButton(panel, -1, 'disabled Generic')
        b.Enable(False)
        sizer.Add(b)

        b = buttons.GenButton(panel, -1, 'bigger')
        b.SetFont(wx.Font(20, wx.SWISS, wx.NORMAL, wx.BOLD, False))
        b.SetBezelWidth(5)
        b.SetBackgroundColour("Navy")
        b.SetForegroundColour("white")
        b.SetToolTipString("This is a BIG button...")
        sizer.Add(b)

        bmp = wx.Image("bitmap.bmp", wx.BITMAP_TYPE_BMP).ConvertToBitmap()
        b = buttons.GenBitmapButton(panel, -1, bmp)
        sizer.Add(b)

        b = buttons.GenBitmapToggleButton(panel, -1, bmp)
        sizer.Add(b)

        b = buttons.GenBitmapTextButton(panel,
                                        -1,
                                        bmp,
                                        "Bitmapped Text",
                                        size=(175, 75))
        b.SetUseFocusIndicator(False)
        sizer.Add(b)

        b = buttons.GenToggleButton(panel, -1, "Toggle Button")
        sizer.Add(b)

        panel.SetSizer(sizer)
Ejemplo n.º 13
0
 def createThicknessGrid(self, buttonSize):
     self.thicknessIdMap = {}
     self.thicknessButtons = {}
     thicknessGrid = wx.GridSizer(cols=self.NUM_COLS, hgap=2, vgap=2)
     for x in range(1, self.maxThickness + 1):
         b = buttons.GenToggleButton(self, -1, str(x), size=buttonSize)
         b.SetBezelWidth(1)
         b.SetUseFocusIndicator(False)
         self.Bind(wx.EVT_BUTTON, self.OnSetThickness, b)
         thicknessGrid.Add(b, 0)
         self.thicknessIdMap[b.GetId()] = x
         self.thicknessButtons[x] = b
     self.thicknessButtons[1].SetToggle(True)
     return thicknessGrid
Ejemplo n.º 14
0
    def __init__(self):
        wx.Frame.__init__(self, None, wx.ID_ANY, "RC Extreme!")
        panel = wx.Panel(self, wx.ID_ANY)

        button = wx.ToggleButton(panel, label="Autopilot")
        button.Bind(wx.EVT_TOGGLEBUTTON, self.onToggle)

        gen_toggle_button = buttons.GenToggleButton(panel, -1, "User Control")
        gen_toggle_button.Bind(wx.EVT_BUTTON, self.onGenericToggle)

        sizer = wx.BoxSizer(wx.HORIZONTAL)
        sizer.Add(button, 0, wx.ALL, 5)
        sizer.Add(gen_toggle_button, 0, wx.ALL, 5)
        panel.SetSizer(sizer)
Ejemplo n.º 15
0
    def __init__(self):
        wx.Frame.__init__(self,
                          None,
                          -1,
                          'Generic Button Example',
                          size=(500, 350))
        panel = wx.Panel(self, -1)
        sizer = wx.FlexGridSizer(4, 3, 20, 20)
        b = wx.Button(panel, -1, "A wx.Button")
        b.SetDefault()
        sizer.Add(b)
        b = wx.Button(panel, -1, "non-default wx.Button")
        sizer.Add(b)
        sizer.Add((10, 10))

        b = buttons.GenButton(panel, -1,
                              'Generic Button')  # Базовая типовая кнопка
        sizer.Add(b)
        b = buttons.GenButton(
            panel, -1, 'disabled Generic')  # Блокированная типовая кнопка
        b.Enable(False)
        sizer.Add(b)
        b = buttons.GenButton(
            panel, -1,
            'bigger')  # Кнопка с заданным пользователем размером и цветом
        b.SetFont(wx.Font(20, wx.SWISS, wx.NORMAL, wx.BOLD, False))
        b.SetBezelWidth(5)
        b.SetBackgroundColour("Navy")
        b.SetForegroundColour("white")
        b.SetToolTip("This is a BIG button...")
        sizer.Add(b)

        bmp = wx.Image("bird.png", wx.BITMAP_TYPE_PNG).ConvertToBitmap()
        b = buttons.GenBitmapButton(
            panel, -1, bmp)  # Типовая кнопка с битовым изображением
        sizer.Add(b)
        b = buttons.GenBitmapToggleButton(panel, -1, bmp)
        sizer.Add(b)  # Типовая кнопка-переключатель с битовым изображением
        b = buttons.GenBitmapTextButton(
            panel, -1, bmp, "Bitmapped Text",
            size=(175, 75))  # Кнопка с битовым изображением и текстом
        b.SetUseFocusIndicator(False)
        sizer.Add(b)
        b = buttons.GenToggleButton(
            panel, -1, "Toggle Button")  # Типовая кнопка-переключатель
        sizer.Add(b)
        panel.SetSizer(sizer)
Ejemplo n.º 16
0
 def __init__(self):
     wx.Frame.__init__(self,
                       None,
                       -1,
                       "Generic Button Example",
                       size=(500, 350))
     panel = wx.Panel(self, -1)
     sizer = wx.FlexGridSizer(1, 3, 20, 20)
     b = wx.Button(panel, -1, "A wx.Button")
     b.SetDefault()
     b.SetToolTipString("a wx.Button")
     sizer.Add(b)
     b = wx.Button(panel, -1, "non-default wx.Button")
     sizer.Add(b)
     sizer.Add((10, 10))
     b = buttons.GenButton(panel, -1, "Genric Button")
     sizer.Add(b)
     b = buttons.GenButton(panel, -1, "disabled Generic")
     b.Enable(False)
     sizer.Add(b)
     b = buttons.GenButton(panel, -1, 'bigger')
     b.SetFont(wx.Font(20, wx.SWISS, wx.NORMAL, wx.BOLD, False))
     b.SetBezelWidth(5)
     b.SetBackgroundColour("Navy")
     b.SetForegroundColour("white")
     b.SetToolTipString("this is a Big button..")
     sizer.Add(b)
     bmp = wx.Bitmap("img/002.jpg", wx.BITMAP_TYPE_JPEG)
     b = buttons.GenBitmapButton(panel, -1, bmp)
     sizer.Add(b)
     b = buttons.GenBitmapToggleButton(panel, -1, bmp)
     sizer.Add(b)
     b = buttons.GenBitmapTextButton(panel,
                                     -1,
                                     bmp,
                                     "Bitmapped Text",
                                     size=(175, 75))
     self.Bind(wx.EVT_BUTTON, self.OnClick, b)
     b.SetUseFocusIndicator(False)
     sizer.Add(b)
     b = buttons.GenToggleButton(panel, -1, "Toggle Button")
     sizer.Add(b)
     b = wx.ToggleButton(panel, -1, "on/off")
     self.Bind(wx.EVT_TOGGLEBUTTON, self.OnClick, b)
     sizer.Add(b)
     panel.SetSizer(sizer)
Ejemplo n.º 17
0
    def __init__(self):
        wx.Frame.__init__(self, None, -1, 'Generic Button Example',
                          size=(500, 350))
        panel = wx.Panel(self, -1)

        sizer = wx.FlexGridSizer(4, 3, 20, 20)
        btn = wx.Button(panel, -1, "A wx.Button")
        btn.SetDefault()
        sizer.Add(btn)

        btn = wx.Button(panel, -1, "Non-default wx.Button")
        sizer.Add(btn)
        sizer.Add((10, 10))

        btn = buttons.GenButton(panel, -1, 'Generic Button')  # 基本的通用按钮
        sizer.Add(btn)

        btn = buttons.GenButton(panel, -1, 'Disabled Generic')  # 无效的通用按钮
        btn.Enable(False)
        sizer.Add(btn)

        btn = buttons.GenButton(panel, -1, 'Bigger')  # 自定义尺寸和颜色的按钮
        btn.SetFont(wx.Font(20, wx.SWISS, wx.NORMAL, wx.BOLD, False))
        btn.SetBezelWidth(5)
        btn.SetBackgroundColour("Navy")
        btn.SetForegroundColour("White")
        btn.SetToolTipString("This is a BIG button...")
        sizer.Add(btn)

        bmp = wx.Image("bitmap.bmp", wx.BITMAP_TYPE_BMP).ConvertToBitmap()
        btn = buttons.GenBitmapButton(panel, -1, bmp)  # 通用位图按钮
        sizer.Add(btn)

        btn = buttons.GenBitmapToggleButton(panel, -1, bmp)  # 通用位图开关按钮
        sizer.Add(btn)

        btn = buttons.GenBitmapTextButton(panel, -1, bmp, "Bitmap Text",
                                          size=(175, 75))  # 位图文本按钮
        btn.SetUseFocusIndicator(False)
        sizer.Add(btn)

        btn = buttons.GenToggleButton(panel, -1, "Toggle Button")  # 通用开关按钮
        sizer.Add(btn)

        panel.SetSizer(sizer)
Ejemplo n.º 18
0
 def __init__(self):
     wx.Frame.__init__(self,
                       None,
                       -1,
                       'Generic Button Example',
                       size=(500, 350))
     panel = wx.Panel(self, -1)
     sizer = wx.FlexGridSizer(1, 3, 20, 20)
     b = wx.Button(panel, -1, "A wx.Button")
     b.SetDefault()
     sizer.Add(b)
     b = wx.Button(panel, -1, "non-default wx.Button")
     sizer.Add(b)
     sizer.Add((10, 10))
     b = buttons.GenButton(panel, -1, 'Generic Button')
     sizer.Add(b)
     b = buttons.GenButton(panel, -1, 'disabled Generic')
     b.Enable(False)
     sizer.Add(b)
     b = buttons.GenButton(panel, -1, 'bigger')
     b.SetFont(wx.Font(20, wx.SWISS, wx.NORMAL, wx.BOLD, False))
     b.SetBezelWidth(5)
     b.SetBackgroundColour("Navy")
     b.SetForegroundColour("white")
     b.SetToolTipString("This is a BIG button...")
     sizer.Add(b)
     bmp = wx.Image(
         "C:\\Users\\Ashish\\.eclipse\\231700603\\configuration\\org.eclipse.equinox.launcher\\com.jrockit.mc.rcp.application_5.3.0.159881\\splash.bmp",
         wx.BITMAP_TYPE_BMP).ConvertToBitmap()
     b = buttons.GenBitmapButton(panel, -1, bmp)
     sizer.Add(b)
     b = buttons.GenBitmapToggleButton(panel, -1, bmp)
     sizer.Add(b)
     b = buttons.GenBitmapTextButton(panel,
                                     -1,
                                     bmp,
                                     "Bitmapped Text",
                                     size=(175, 75))
     b.SetUseFocusIndicator(False)
     sizer.Add(b)
     b = buttons.GenToggleButton(panel, -1, "Toggle Button")
     sizer.Add(b)
     panel.SetSizer(sizer)
Ejemplo n.º 19
0
    def __init__(self, parent, log):
        self.log = log
        wx.Panel.__init__(self, parent, -1)

        self.recordingKeys = False
        self.stopwatchKeys = wx.StopWatch()
        self.uisim = wx.UIActionSimulator()
        
        
        # create widgets and bind events
        keyLabel = wx.StaticText(self, -1, "Key Events")
        keyLabel.SetFont(wx.FFont(18, wx.SWISS, wx.FONTFLAG_BOLD))
        
        self.txt = wx.TextCtrl(self, size=(300,-1))
        self.txt.Bind(wx.EVT_KEY_DOWN, self.OnTxtKeyDown)
        self.txt.Bind(wx.EVT_KEY_UP, self.OnTxtKeyUp)
        
        self.recordBtn = buttons.GenToggleButton(self, -1, "Record")
        self.Bind(wx.EVT_BUTTON, self.OnToggleRecordKeys, self.recordBtn)
        self.recordBtn.SetToolTipString(
            "Click this button and then type some keys in the\n"
            "textctrl.  Click here again when done.")
        
        self.playbackKeysBtn = buttons.GenButton(self, -1, "Playback")
        self.Bind(wx.EVT_BUTTON, self.OnPlaybackKeys, self.playbackKeysBtn)
        self.playbackKeysBtn.SetToolTipString(
            "Record some key events and then click here to\n"
            "replay the recorded events.")
        self.playbackKeysBtn.Disable()
        
        
        # create the layout
        gbs = wx.GridBagSizer(10,10)
        gbs.Add(keyLabel, (0,0), span=(1,2))
        gbs.Add(self.txt, (1,1), span=(1,2))
        btnsizer = wx.BoxSizer(wx.HORIZONTAL)
        btnsizer.Add(self.recordBtn)
        btnsizer.Add((10,10))
        btnsizer.Add(self.playbackKeysBtn)
        gbs.Add(btnsizer, (2,1), span=(1,2))
        
        self.Sizer = wx.BoxSizer()
        self.Sizer.Add(gbs, 1, wx.EXPAND|wx.ALL, 20)
Ejemplo n.º 20
0
 def createCostGrid(self, color):
     self.costGridDict = {}
     self.costGridToggleList = {}
     costGrid = wx.GridSizer(cols=self.COLS_NUM, hgap=5, vgap=5)
     for eachCost in self.costCategory():
         #button = wx.ToggleButton(self,id=-1,label=eachCost,size=(80,80))
         button = buttons.GenToggleButton(self,
                                          id=-1,
                                          label=str(eachCost),
                                          size=(80, 80))
         button.SetBezelWidth(3)
         button.SetUseFocusIndicator(False)
         button.SetForegroundColour('Blue')
         button.SetBackgroundColour(color)
         self.Bind(wx.EVT_BUTTON, self.callAddCost, button)
         button.SetFont(fonts.Fonts.romanBold12())
         costGrid.Add(button, 1)
         self.costGridDict[button.GetId()] = eachCost
         self.costGridToggleList[eachCost] = button
     #self.costGridToggleList[self.costCategory()[0]]
     return costGrid
Ejemplo n.º 21
0
    def init_board(self):
        """ Initialize the game's GUI """
        main_sizer = wx.BoxSizer(wx.VERTICAL)
        self.fg_sizer = wx.FlexGridSizer(rows=3, cols=3, vgap=5, hgap=5)
        font = wx.Font(22, wx.FONTFAMILY_DEFAULT, wx.FONTSTYLE_NORMAL,
                       wx.FONTWEIGHT_BOLD)
        self.match_name = wx.StaticText(self, -1, style=wx.ALIGN_CENTER)
        main_sizer.Add(self.match_name, 0, wx.ALL | wx.CENTER, 5)

        self.buttons = []
        for i in range(9):
            button = buttons.GenToggleButton(self, id=i, size=(100, 100))
            button.SetFont(font)
            button.Bind(wx.EVT_BUTTON, self.button_click)
            self.buttons.append(button)

        self.fg_sizer.AddMany(self.buttons)
        main_sizer.Add(self.fg_sizer, 0, wx.ALL | wx.CENTER, 5)
        self.status_prompt = wx.StaticText(self, -1, style=wx.ALIGN_CENTER)
        self.status_prompt.SetLabel("Waiting for opponent")
        main_sizer.Add(self.status_prompt, 0, wx.ALL | wx.CENTER, 5)
        self.SetSizer(main_sizer)
Ejemplo n.º 22
0
    def __init__(self, prnt, cnt):
        self.win = wx.ScrolledWindow.__init__(self,
                                              parent=prnt,
                                              id=-1,
                                              size=wx.DefaultSize)
        self.SetScrollbars(1, 1, 100, 100)  #####
        self.FitInside()  ######
        png = wx.Image((cfg.path_img + "cerca19x19.png"),
                       wx.BITMAP_TYPE_PNG).ConvertToBitmap()
        #wx.Frame.__init__(self, id=wx.NewId(), name='',
        #      parent=prnt, pos=wx.Point(0, 0),
        #      style=wx.DEFAULT_FRAME_STYLE, title=ttl)
        #self.SetIcon(wx.Icon(cfg.path_img+"/null.ico", wx.BITMAP_TYPE_ICO))
        #self.SetFont(wx.Font(12, wx.SWISS, wx.NORMAL, wx.NORMAL, False))
        #self.SetClientSize(wx.Size(680, 400))

        self.cnt = cnt
        Nid = wx.NewId()
        self.ttl = cnt[0]
        tcpart = cnt[1][0].upper()
        self.t_cpart = tcpart
        self.tcpart = tcpart + "1"
        self.rec = cnt[2]
        self.AggMenu = cnt[3]
        self.IDMENU = cnt[4]
        self.CMD = cnt[5]
        #self.font=self.GetFont()
        self.__MDI__ = wx.GetApp().GetPhasisMdi()

        self.font = self.__MDI__.font
        self.SetFont(self.font)

        self.CnAz = self.__MDI__.GetConnAZ()
        self.annoc = self.__MDI__.GetAnnoC()
        self.datacon = self.__MDI__.GetDataC()
        self.dzDatiAzienda = self.__MDI__.dzDatiAzienda
        self.sMERCE = ""

        self.pnl = wx.Panel(
            id=wx.NewId(),
            name='panel1',
            parent=self,
            pos=wx.Point(0, 0),
            size=wx.DLG_SZE(self, 680 / 2, 400 / 2),  #size=wx.Size(680, 400),
            style=wx.SIMPLE_BORDER | wx.TAB_TRAVERSAL)
        self.pnl.SetFont(self.font)

        self.lc = wx.ListCtrl(self.pnl, Nid, wx.DLG_PNT(self, 5, 5),
                              wx.DLG_SZE(self.pnl, 335, 130),
                              wx.LC_REPORT | wx.LC_HRULES | wx.LC_VRULES)
        wx.StaticLine(self.pnl, -1, wx.DLG_PNT(self.pnl, 5, 140),
                      wx.DLG_SZE(self.pnl, 335, -1))
        self.lcod = wx.StaticText(self.pnl, -1, _("Codice :"),
                                  wx.DLG_PNT(self.pnl, 5, 147))
        self.cod = wx.TextCtrl(self.pnl, Nid, "",
                               wx.DLG_PNT(self.pnl, 55, 145),
                               wx.DLG_SZE(self.pnl, 70, cfg.DIMFONTDEFAULT),
                               wx.TE_PROCESS_ENTER)
        self.codbar = wx.TextCtrl(self.pnl, Nid, "",
                                  wx.DLG_PNT(self.pnl, 55, 145),
                                  wx.DLG_SZE(self.pnl, 70, cfg.DIMFONTDEFAULT))
        wx.StaticText(self.pnl, -1, _("Descrizione :"),
                      wx.DLG_PNT(self.pnl, 5, 162))
        self.descriz = wx.TextCtrl(
            self.pnl, Nid, "", wx.DLG_PNT(self.pnl, 55, 160),
            wx.DLG_SZE(self.pnl, 125, cfg.DIMFONTDEFAULT), wx.TE_PROCESS_ENTER)
        self.rbSEMP = wx.RadioButton(self.pnl, Nid, cfg.vcSEMP,
                                     wx.DLG_PNT(self.pnl, 180, 145),
                                     wx.DLG_SZE(self.pnl, 50, 10), wx.RB_GROUP)
        self.rbDETT = wx.RadioButton(self.pnl, Nid, cfg.vcDETT,
                                     wx.DLG_PNT(self.pnl, 230, 145),
                                     wx.DLG_SZE(self.pnl, 50, 10))
        self.tipos = wx.TextCtrl(self.pnl, -1, "S",
                                 wx.DLG_PNT(self.pnl, 280, 145))
        self.ccod = wx.BitmapButton(
            self.pnl,
            -1,
            png,  #buttons.GenButton(self.pnl, Nid, "...",#wx.Button(self.pnl , Nid, "...", 
            wx.DLG_PNT(self.pnl, 130, 145),
            wx.DLG_SZE(self.pnl, cfg.btnSzeSH, cfg.btnSzeV))
        self.ccodbar = buttons.GenToggleButton(
            self.pnl, Nid, "|''|'|", wx.DLG_PNT(self.pnl, 145, 145),
            wx.DLG_SZE(self.pnl, cfg.btnSzeSH, cfg.btnSzeV))
        self.cdes = wx.BitmapButton(
            self.pnl,
            -1,
            png,  #buttons.GenButton(self.pnl, Nid, "...",#wx.Button(self.pnl , Nid, "...", 
            wx.DLG_PNT(self.pnl, 185, 160),
            wx.DLG_SZE(self.pnl, cfg.btnSzeSH, cfg.btnSzeV))
        wx.StaticText(self.pnl, -1, _("Cat. Merc. :"),
                      wx.DLG_PNT(self.pnl, 5, 182))
        self.MERCE = wx.ComboBox(self.pnl, Nid, "",
                                 wx.DLG_PNT(self.pnl, 55, 180),
                                 wx.DLG_SZE(self.pnl, 100, -1), [],
                                 wx.CB_DROPDOWN | wx.CB_SORT)
        self.vMERCE = wx.TextCtrl(self.pnl, -1, "",
                                  wx.DLG_PNT(self.pnl, 155, 180))

        self.stampa = wx.Button(
            self.pnl, Nid, cfg.vcstampa, wx.DLG_PNT(self.pnl, 275, 145),
            wx.DLG_SZE(self.pnl, cfg.btnSzeLH, cfg.btnSzeV))
        self.ok = wx.Button(self.pnl, Nid, cfg.vcconf,
                            wx.DLG_PNT(self.pnl, 210, 160),
                            wx.DLG_SZE(self.pnl, cfg.btnSzeLH, cfg.btnSzeV))
        self.canc = wx.Button(self.pnl, Nid, cfg.vccanc,
                              wx.DLG_PNT(self.pnl, 275, 160),
                              wx.DLG_SZE(self.pnl, cfg.btnSzeLH, cfg.btnSzeV))

        for x in self.pnl.GetChildren():
            x.SetFont(self.font)

        self.canc.SetFocus()
        #self.SetFont(self.font)

        #box_sizer = wx.BoxSizer(wx.VERTICAL)
        #box_sizer.Add(self.pnl, 0, wx.EXPAND|wx.ALL,5)
        #self.SetAutoLayout(1)
        #self.SetSizer(box_sizer)
        #box_sizer.Fit(self)

        box = wx.GridSizer(1, 1)
        box.Add(self.pnl, 0, wx.ALIGN_CENTER | wx.ALL, 10)
        self.SetSizer(box)
        box.Fit(self)

        self.canc.Bind(wx.EVT_BUTTON, self.Close)
        self.Bind(wx.EVT_CLOSE, self.Close)
        self.ok.Bind(wx.EVT_BUTTON, self.Ok)
        self.lc.Bind(wx.EVT_LEFT_DCLICK, self.DblClick)
        self.cdes.Bind(wx.EVT_BUTTON, self.FndArt)
        self.rbSEMP.Bind(wx.EVT_RADIOBUTTON, self.RadioB)
        self.rbDETT.Bind(wx.EVT_RADIOBUTTON, self.RadioB)
        self.lc.Bind(wx.EVT_LIST_ITEM_ACTIVATED, self.LstAct)
        self.lc.Bind(wx.EVT_LIST_ITEM_SELECTED, self.LstSlct)
        self.descriz.Bind(wx.EVT_TEXT_ENTER, self.FndArt)
        self.cod.Bind(wx.EVT_TEXT_ENTER, self.FndArt)
        self.codbar.Bind(wx.EVT_TEXT_ENTER, self.FndArt)
        self.ccodbar.Bind(wx.EVT_BUTTON, self.SelCodBar)
        self.ccod.Bind(wx.EVT_BUTTON, self.FndArt)
        self.stampa.Bind(wx.EVT_BUTTON, self.Stampa)
        self.MERCE.Bind(wx.EVT_TEXT_ENTER, self.MERCESF)
        self.MERCE.Bind(wx.EVT_COMBOBOX, self.SelMERCE)
        self.Start(self)
Ejemplo n.º 23
0
    def __init__(self, parent, log):
        wx.Panel.__init__(self, parent, -1)
        self.log = log
        ##self.SetBackgroundColour("sky blue")

        sizer = wx.FlexGridSizer(1, 3, 20, 20)

        # A regular button, selected as the default button
        b = wx.Button(self, -1, "A real button")
        b.SetDefault()
        self.Bind(wx.EVT_BUTTON, self.OnButton, b)
        sizer.Add(b)

        # Same thing, but NOT set as the default button
        b = wx.Button(self, -1, "non-default")
        self.Bind(wx.EVT_BUTTON, self.OnButton, b)
        sizer.Add(b)
        sizer.Add((10, 10))

        # Plain old text button based off GenButton()
        b = buttons.GenButton(self, -1, 'Hello')
        self.Bind(wx.EVT_BUTTON, self.OnButton, b)
        sizer.Add(b)

        # Plain old text button, disabled.
        b = buttons.GenButton(self, -1, 'disabled')
        self.Bind(wx.EVT_BUTTON, self.OnButton, b)
        b.Enable(False)
        sizer.Add(b)

        # This time, we let the botton be as big as it can be.
        # Also, this one is fancier, with custom colors and bezel size.
        b = buttons.GenButton(self, -1, 'bigger')
        self.Bind(wx.EVT_BUTTON, self.OnBiggerButton, b)
        b.SetFont(wx.Font(20, wx.SWISS, wx.NORMAL, wx.BOLD, False))
        b.SetBezelWidth(5)
        b.SetMinSize(wx.DefaultSize)
        b.SetBackgroundColour("Navy")
        b.SetForegroundColour(wx.WHITE)
        b.SetToolTipString("This is a BIG button...")
        # let the sizer set best size
        sizer.Add(b, flag=wx.ADJUST_MINSIZE)

        # An image button
        bmp = images.Test2.GetBitmap()
        b = buttons.GenBitmapButton(self, -1, bmp)
        self.Bind(wx.EVT_BUTTON, self.OnButton, b)
        sizer.Add(b)

        # An image button, disabled.
        bmp = images.Test2.GetBitmap()
        b = buttons.GenBitmapButton(self, -1, bmp)
        self.Bind(wx.EVT_BUTTON, self.OnButton, b)
        sizer.Add(b)
        b.Enable(False)

        # An image button, using a mask to get rid of the
        # undesireable part of the image
        b = buttons.GenBitmapButton(self, -1, None)
        self.Bind(wx.EVT_BUTTON, self.OnButton, b)
        bmp = images.Bulb1.GetBitmap()
        mask = wx.Mask(bmp, wx.BLUE)
        bmp.SetMask(mask)
        b.SetBitmapLabel(bmp)
        bmp = images.Bulb2.GetBitmap()
        mask = wx.Mask(bmp, wx.BLUE)
        bmp.SetMask(mask)
        b.SetBitmapSelected(bmp)
        b.SetInitialSize()
        sizer.Add(b)

        # A toggle button
        b = buttons.GenToggleButton(self, -1, "Toggle Button")
        self.Bind(wx.EVT_BUTTON, self.OnToggleButton, b)
        sizer.Add(b)

        # An image toggle button
        b = buttons.GenBitmapToggleButton(self, -1, None)
        self.Bind(wx.EVT_BUTTON, self.OnToggleButton, b)
        bmp = images.Bulb1.GetBitmap()
        mask = wx.Mask(bmp, wx.BLUE)
        bmp.SetMask(mask)
        b.SetBitmapLabel(bmp)
        bmp = images.Bulb2.GetBitmap()
        mask = wx.Mask(bmp, wx.BLUE)
        bmp.SetMask(mask)
        b.SetBitmapSelected(bmp)
        b.SetToggle(True)
        b.SetInitialSize()
        sizer.Add(b)

        # A bitmap button with text.
        b = buttons.GenBitmapTextButton(self,
                                        -1,
                                        None,
                                        "Bitmapped Text",
                                        size=(200, 45))
        self.Bind(wx.EVT_BUTTON, self.OnButton, b)
        bmp = images.Bulb1.GetBitmap()
        mask = wx.Mask(bmp, wx.BLUE)
        bmp.SetMask(mask)
        b.SetBitmapLabel(bmp)
        bmp = images.Bulb2.GetBitmap()
        mask = wx.Mask(bmp, wx.BLUE)
        bmp.SetMask(mask)
        b.SetBitmapSelected(bmp)
        b.SetUseFocusIndicator(False)
        b.SetInitialSize()
        sizer.Add(b)

        # a flat text button
        b = buttons.GenButton(self,
                              -1,
                              'Flat buttons too!',
                              style=wx.BORDER_NONE)
        self.Bind(wx.EVT_BUTTON, self.OnButton, b)
        sizer.Add(b, flag=wx.ALIGN_CENTER_VERTICAL)

        # A flat image button
        bmp = images.Test2.GetBitmap()
        bmp.SetMaskColour("blue")
        b = buttons.GenBitmapButton(self, -1, bmp, style=wx.BORDER_NONE)
        self.Bind(wx.EVT_BUTTON, self.OnButton, b)
        sizer.Add(b)
        ##b.SetBackgroundColour("sky blue")
        ##b.SetBackgroundColour("pink")

        b = buttons.ThemedGenButton(self, -1, 'Drawn with native renderer')
        self.Bind(wx.EVT_BUTTON, self.OnButton, b)
        sizer.Add(b)

        border = wx.BoxSizer(wx.VERTICAL)
        border.Add(sizer, 0, wx.ALL, 25)
        self.SetSizer(border)
Ejemplo n.º 24
0
    def __init__(self, parent, ID, doodle):
        wx.Panel.__init__(self, parent, ID, style=wx.RAISED_BORDER)

        numCols = 4
        spacing = 4

        btnSize = wx.Size(self.BMP_SIZE + 2 * self.BMP_BORDER,
                          self.BMP_SIZE + 2 * self.BMP_BORDER)

        # Make a grid of buttons for each colour.  Attach each button
        # event to self.OnSetColour.  The button ID is the same as the
        # key in the colour dictionary.
        self.clrBtns = {}
        colours = doodle.menuColours
        keys = colours.keys()
        keys.sort()
        cGrid = wx.GridSizer(cols=numCols, hgap=2, vgap=2)
        for k in keys:
            bmp = self.MakeBitmap(colours[k])
            b = buttons.GenBitmapToggleButton(self, k, bmp, size=btnSize)
            b.SetBezelWidth(1)
            b.SetUseFocusIndicator(False)
            wx.EVT_BUTTON(self, k, self.OnSetColour)
            cGrid.Add(b, 0)
            self.clrBtns[colours[k]] = b
        self.clrBtns[colours[keys[0]]].SetToggle(True)

        # Make a grid of buttons for the thicknesses.  Attach each button
        # event to self.OnSetThickness.  The button ID is the same as the
        # thickness value.
        self.thknsBtns = {}
        tGrid = wx.GridSizer(cols=numCols, hgap=2, vgap=2)
        for x in range(1, doodle.maxThickness + 1):
            b = buttons.GenToggleButton(self, x, str(x), size=btnSize)
            b.SetBezelWidth(1)
            b.SetUseFocusIndicator(False)
            wx.EVT_BUTTON(self, x, self.OnSetThickness)
            tGrid.Add(b, 0)
            self.thknsBtns[x] = b
        self.thknsBtns[1].SetToggle(True)

        # Make a colour indicator window, it is registerd as a listener
        # with the doodle window so it will be notified when the settings
        # change
        ci = ColourIndicator(self)
        doodle.AddListener(ci)
        doodle.Notify()
        self.doodle = doodle

        # Make a box sizer and put the two grids and the indicator
        # window in it.
        box = wx.BoxSizer(wx.VERTICAL)
        box.Add(cGrid, 0, wx.ALL, spacing)
        box.Add(tGrid, 0, wx.ALL, spacing)
        box.Add(ci, 0, wx.EXPAND | wx.ALL, spacing)
        self.SetSizer(box)
        self.SetAutoLayout(True)

        # Resize this window so it is just large enough for the
        # minimum requirements of the sizer.
        box.Fit(self)
Ejemplo n.º 25
0
	def __init__(self, parent, ID, doodle):
		wx.Panel.__init__(self, parent, ID, style=wx.RAISED_BORDER)

		numCols = 4
		spacing = 4

		btnSize = wx.Size(self.BMP_SIZE + 2*self.BMP_BORDER,
						  self.BMP_SIZE + 2*self.BMP_BORDER)

		self.clrBtns = {}
		colours = doodle.menuColours
		keys = list(colours.keys())
		keys.sort()
		cGrid = wx.GridSizer(cols=numCols, hgap=2, vgap=2)
		for k in keys:
			bmp = self.MakeBitmap(colours[k])
			b = buttons.GenBitmapToggleButton(self, k, bmp, size=btnSize )
			b.SetBezelWidth(1)
			b.SetUseFocusIndicator(False)
			self.Bind(wx.EVT_BUTTON, self.OnSetColour, b)
			cGrid.Add(b, 0)
			self.clrBtns[colours[k]] = b
		
		self.clrBtns[colours[keys[0]]].SetToggle(True)

		self.thknsBtns = {}
		tGrid = wx.GridSizer(cols=numCols, hgap=2, vgap=2)
		for x in range(1, doodle.maxThickness+1):
			b = buttons.GenToggleButton(self, x, str(x), size=btnSize)
			b.SetBezelWidth(1)
			b.SetUseFocusIndicator(False)
			self.Bind(wx.EVT_BUTTON, self.OnSetThickness, b)
			tGrid.Add(b, 0)
			self.thknsBtns[x] = b
			
		self.thknsBtns[1].SetToggle(True)


		ci = ColourIndicator(self)
		doodle.AddListener(ci)
		doodle.Notify()
		self.doodle = doodle

		box = wx.BoxSizer(wx.VERTICAL)
		box.Add(cGrid, 0, wx.ALL, spacing)
		box.Add(tGrid, 0, wx.ALL, spacing)
		box.Add(ci, 0, wx.EXPAND|wx.ALL, spacing)
		
		if 1:
			e = wx.FontEnumerator()
			e.EnumerateFacenames()
			elist= e.GetFacenames()
			self.lb1 = wx.ListBox(self, -1, wx.DefaultPosition, (200, -1),
							 elist, wx.LB_SINGLE)
			self.Bind(wx.EVT_LISTBOX, self.OnSelect, id=self.lb1.GetId())
			box.Add(self.lb1, 0, wx.EXPAND|wx.ALL)
		
		self.SetSizer(box)
		self.SetAutoLayout(True)

		# Resize this window so it is just large enough for the
		# minimum requirements of the sizer.
		box.Fit(self)
Ejemplo n.º 26
0
    def __init__(self, parent, id, title, par):
        #wx.Frame.__init__(self,parent,id,title,style = wx.DEFAULT_FRAME_STYLE & ~wx.MAXIMIZE_BOX ^ wx.RESIZE_BORDER)
        wx.Frame.__init__(self, parent, id, title)
        #self.child = ChildFrame(self)
        self.par = par

        #My Menubar
        self.appMenuBar = wx.MenuBar()
        self.appFileMenu = wx.Menu()
        self.appOpenMenu = self.appFileMenu.Append(wx.ID_OPEN, '&Open')
        self.appQuitMenu = self.appFileMenu.Append(wx.ID_EXIT, '&Quit')
        self.appMenuBar.Append(self.appFileMenu, '&File')

        #My Toolbar
        self.appToolBar = self.CreateToolBar()

        openIcon = wx.ArtProvider.GetBitmap(wx.ART_FOLDER_OPEN, wx.ART_TOOLBAR,
                                            (32, 32))
        self.appOpenTool = self.appToolBar.AddSimpleTool(-1, openIcon, 'Open')

        quitIcon = wx.ArtProvider.GetBitmap(wx.ART_DELETE, wx.ART_TOOLBAR,
                                            (32, 32))
        self.appQuitTool = self.appToolBar.AddSimpleTool(-1, quitIcon, 'Quit')

        saveIcon = wx.ArtProvider.GetBitmap(wx.ART_FILE_SAVE, wx.ART_TOOLBAR,
                                            (32, 32))
        self.appSaveTool = self.appToolBar.AddSimpleTool(-1, saveIcon, 'Save')

        #My Labels
        self.emptyTxt = wx.StaticText(self, -1, label=u'')

        self.wavelengthTxt = wx.StaticText(self, -1, label=u'Wavelength')
        self.wavelengthTxt.SetFont(wx.Font(12, wx.SWISS, wx.NORMAL, wx.BOLD))

        self.incidentAlphaTxt = wx.StaticText(self,
                                              -1,
                                              label=u'Incidence Angle')
        self.incidentAlphaTxt.SetFont(wx.Font(12, wx.SWISS, wx.NORMAL,
                                              wx.BOLD))

        self.sampleToDetectorDistanceTxt = wx.StaticText(self,
                                                         -1,
                                                         label=u'SDD')
        self.sampleToDetectorDistanceTxt.SetFont(
            wx.Font(12, wx.SWISS, wx.NORMAL, wx.BOLD))

        self.verticalPixelOnDetectorTxt = wx.StaticText(self, -1, label=u'Hor')
        self.verticalPixelOnDetectorTxt.SetFont(
            wx.Font(12, wx.SWISS, wx.NORMAL, wx.BOLD))

        self.horizontalPixelOnDetectorTxt = wx.StaticText(self,
                                                          -1,
                                                          label=u'Ver')
        self.horizontalPixelOnDetectorTxt.SetFont(
            wx.Font(12, wx.SWISS, wx.NORMAL, wx.BOLD))

        self.cropSizeTxt = wx.StaticText(self, -1, label=u'Size')
        self.cropSizeTxt.SetFont(wx.Font(12, wx.SWISS, wx.NORMAL, wx.BOLD))

        self.upperLimitColorMapTxt = wx.StaticText(self, -1, label=u'Max')
        self.upperLimitColorMapTxt.SetFont(
            wx.Font(10, wx.SWISS, wx.NORMAL, wx.BOLD))

        self.lowerLimitColorMapTxt = wx.StaticText(self, -1, label=u'Min')
        self.lowerLimitColorMapTxt.SetFont(
            wx.Font(10, wx.SWISS, wx.NORMAL, wx.BOLD))

        self.lowerLimitXAxisTxt = wx.StaticText(self, -1, label=u'X-axis Min')
        self.lowerLimitXAxisTxt.SetFont(
            wx.Font(12, wx.SWISS, wx.NORMAL, wx.BOLD))

        self.lowerLimitYAxisTxt = wx.StaticText(self, -1, label=u'Y-axis Min')
        self.lowerLimitYAxisTxt.SetFont(
            wx.Font(12, wx.SWISS, wx.NORMAL, wx.BOLD))

        self.upperLimitXAxisTxt = wx.StaticText(self, -1, label=u'X-axis Max')
        self.upperLimitXAxisTxt.SetFont(
            wx.Font(12, wx.SWISS, wx.NORMAL, wx.BOLD))

        self.upperLimitYAxisTxt = wx.StaticText(self, -1, label=u'Y-axis Max')
        self.upperLimitYAxisTxt.SetFont(
            wx.Font(12, wx.SWISS, wx.NORMAL, wx.BOLD))

        self.borderThicknessTxt = wx.StaticText(self, -1, label=u'Borderline')
        self.borderThicknessTxt.SetFont(
            wx.Font(10, wx.SWISS, wx.NORMAL, wx.BOLD))

        self.tickFontSizeTxt = wx.StaticText(self, -1, label=u'Font size')
        self.tickFontSizeTxt.SetFont(wx.Font(10, wx.SWISS, wx.NORMAL, wx.BOLD))

        self.tickLengthTxt = wx.StaticText(self, -1, label=u'Tick length')
        self.tickLengthTxt.SetFont(wx.Font(10, wx.SWISS, wx.NORMAL, wx.BOLD))

        self.tickWidthTxt = wx.StaticText(self, -1, label=u'Tick width')
        self.tickWidthTxt.SetFont(wx.Font(10, wx.SWISS, wx.NORMAL, wx.BOLD))

        self.densityPixelTxt = wx.StaticText(self, -1, label=u'Pixel')
        self.densityPixelTxt.SetFont(wx.Font(12, wx.SWISS, wx.NORMAL, wx.BOLD))

        self.lowerLimitQAxisTxt = wx.StaticText(self, -1, label=u'q_inf')
        self.lowerLimitQAxisTxt.SetFont(
            wx.Font(12, wx.SWISS, wx.NORMAL, wx.BOLD))

        self.upperLimitQAxisTxt = wx.StaticText(self, -1, label=u'q_sup')
        self.upperLimitQAxisTxt.SetFont(
            wx.Font(12, wx.SWISS, wx.NORMAL, wx.BOLD))

        #My buttons
        self.runBtn = wx.Button(self, -1, label='RUN', size=(100, 50))
        self.runBtn.SetFont(wx.Font(12, wx.SWISS, wx.NORMAL, wx.BOLD))

        self.integrateBtn = wx.Button(self, -1, label='Plot', size=(100, 50))
        self.integrateBtn.SetFont(wx.Font(12, wx.SWISS, wx.NORMAL, wx.BOLD))

        self.integrateOverQzKeepQxyBtn = wx.ToggleButton(self,
                                                         -1,
                                                         label='QZ(I vs. QXY)')
        self.integrateOverQxyKeepQxzBtn = wx.ToggleButton(
            self, -1, label='QXY(I vs. QXZ)')
        self.integrateOverQxzKeepQxyBtn = wx.ToggleButton(
            self, -1, label='QXZ(I vs. QXY)')
        self.integrateOverQxyKeepQzBtn = wx.ToggleButton(self,
                                                         -1,
                                                         label='QXY(I vs. QZ)')

        self.plotQzQxyBtn = btn.GenToggleButton(self, -1, label='I(QZ,QXY)')
        self.plotQxzQxyBtn = btn.GenToggleButton(self, -1, label='I(QXZ,QXY)')

        self.logScaleBtn = wx.ToggleButton(self, -1, label='Log Scale')

        self.compareBtn = wx.Button(self, -1, label='Compare', size=(100, 50))
        self.compareBtn.SetFont(wx.Font(12, wx.SWISS, wx.NORMAL, wx.BOLD))

        self.plotAgainBtn = wx.Button(self, -1, label='Replot', size=(100, 50))
        self.plotAgainBtn.SetFont(wx.Font(12, wx.SWISS, wx.NORMAL, wx.BOLD))

        #My Sliders(The current frequency is 100 -the fifth position in the args-)
        self.lowerLimitColorMapSlider = wx.Slider(self,
                                                  -1,
                                                  0,
                                                  0,
                                                  100,
                                                  style=wx.SL_VERTICAL,
                                                  size=(-1, 250))
        #self.SlideCMLow.SetTickFreq(10, 1)
        self.upperLimitColorMapSlider = wx.Slider(self,
                                                  -1,
                                                  100,
                                                  0,
                                                  100,
                                                  style=wx.SL_VERTICAL,
                                                  size=(-1, 250))
        #self.SlideCMUpp.SetTickFreq(10, 1)

        #My Inputs
        self.wavelengthEdt = wx.TextCtrl(self, -1, value=u'0.138')
        self.wavelengthEdt.SetFont(wx.Font(12, wx.SWISS, wx.NORMAL, wx.NORMAL))

        self.incidentAlphaEdt = wx.TextCtrl(self, -1, value=u'0.3')
        self.incidentAlphaEdt.SetFont(
            wx.Font(12, wx.SWISS, wx.NORMAL, wx.NORMAL))

        self.sampleToDetectorDistanceEdt = wx.TextCtrl(self, -1, value=u'0.1')
        self.sampleToDetectorDistanceEdt.SetFont(
            wx.Font(12, wx.SWISS, wx.NORMAL, wx.NORMAL))

        self.verticalPixelOnDetectorEdt = wx.TextCtrl(self, -1, value=u'NONE')
        self.verticalPixelOnDetectorEdt.SetFont(
            wx.Font(12, wx.SWISS, wx.NORMAL, wx.NORMAL))

        self.horizontalPixelOnDetectorEdt = wx.TextCtrl(self,
                                                        -1,
                                                        value=u'NONE')
        self.horizontalPixelOnDetectorEdt.SetFont(
            wx.Font(12, wx.SWISS, wx.NORMAL, wx.NORMAL))

        self.densityPixelEdt = wx.TextCtrl(self, -1, value=u'172')
        self.densityPixelEdt.SetFont(
            wx.Font(12, wx.SWISS, wx.NORMAL, wx.NORMAL))

        self.upperLimitQAxisEdt = wx.TextCtrl(self, -1, value=u'0.0')
        self.upperLimitQAxisEdt.SetFont(
            wx.Font(12, wx.SWISS, wx.NORMAL, wx.BOLD))

        self.lowerLimitQAxisEdt = wx.TextCtrl(self, -1, value=u'0.0')
        self.lowerLimitQAxisEdt.SetFont(
            wx.Font(12, wx.SWISS, wx.NORMAL, wx.BOLD))

        #My Plot Inputs
        self.lowerLimitXAxisEdt = wx.TextCtrl(self, -1, value=wx.EmptyString)
        self.lowerLimitXAxisEdt.SetFont(
            wx.Font(12, wx.SWISS, wx.NORMAL, wx.NORMAL))

        self.upperLimitXAxisEdt = wx.TextCtrl(self, -1, value=wx.EmptyString)
        self.upperLimitXAxisEdt.SetFont(
            wx.Font(12, wx.SWISS, wx.NORMAL, wx.NORMAL))

        self.lowerLimitYAxisEdt = wx.TextCtrl(self, -1, value=wx.EmptyString)
        self.lowerLimitYAxisEdt.SetFont(
            wx.Font(12, wx.SWISS, wx.NORMAL, wx.NORMAL))

        self.upperLimitYAxisEdt = wx.TextCtrl(self, -1, value=wx.EmptyString)
        self.upperLimitYAxisEdt.SetFont(
            wx.Font(12, wx.SWISS, wx.NORMAL, wx.NORMAL))

        self.borderThicknessEdt = wx.TextCtrl(self, -1, value='2')
        self.borderThicknessEdt.SetFont(
            wx.Font(10, wx.SWISS, wx.NORMAL, wx.NORMAL))

        self.tickFontSizeEdt = wx.TextCtrl(self, -1, value='12')
        self.tickFontSizeEdt.SetFont(
            wx.Font(10, wx.SWISS, wx.NORMAL, wx.NORMAL))

        self.tickLengthEdt = wx.TextCtrl(self, -1, value='6')
        self.tickLengthEdt.SetFont(wx.Font(10, wx.SWISS, wx.NORMAL, wx.NORMAL))

        self.tickWidthEdt = wx.TextCtrl(self, -1, value='2')
        self.tickWidthEdt.SetFont(wx.Font(10, wx.SWISS, wx.NORMAL, wx.NORMAL))

        #My Text Output
        self.statusMessageTxt = wx.StaticText(self,
                                              -1,
                                              label=u'WAIT ORDERS',
                                              size=wx.Size(350, 50),
                                              style=wx.ST_NO_AUTORESIZE)
        self.statusMessageTxt.SetBackgroundColour(wx.BLUE)
        self.statusMessageTxt.SetForegroundColour(wx.WHITE)
        self.statusMessageTxt.SetFont(wx.Font(14, wx.SWISS, wx.NORMAL,
                                              wx.BOLD))

        self.cropSizeEdt = wx.StaticText(self, -1, label=u'HxV')
        self.cropSizeEdt.SetFont(wx.Font(12, wx.SWISS, wx.NORMAL, wx.NORMAL))

        self.upperLimitColorMapSliderTxt = wx.StaticText(self,
                                                         -1,
                                                         label=u'None')
        self.upperLimitColorMapSliderTxt.SetFont(
            wx.Font(10, wx.SWISS, wx.NORMAL, wx.BOLD))

        self.lowerLimitColorMapSliderTxt = wx.StaticText(self,
                                                         -1,
                                                         label=u'None')
        self.lowerLimitColorMapSliderTxt.SetFont(
            wx.Font(10, wx.SWISS, wx.NORMAL, wx.BOLD))

        #My Design
        self.SetMenuBar(self.appMenuBar)
        self.appToolBar.Realize()

        # Parameter Box
        self.parametersBox = wx.StaticBox(self, -1, 'Parameters')
        self.parametersBox.SetFont(wx.Font(10, wx.SWISS, wx.NORMAL, wx.NORMAL))

        parametersBoxSizer = wx.StaticBoxSizer(self.parametersBox, wx.VERTICAL)

        parametersGridSizer = wx.GridBagSizer(hgap=10, vgap=10)
        parametersGridSizer.Add(self.emptyTxt, (0, 5), (1, 2), wx.EXPAND)
        parametersGridSizer.Add(self.wavelengthTxt, (0, 1), (1, 2), wx.EXPAND)
        parametersGridSizer.Add(self.wavelengthEdt, (0, 3), (1, 2), wx.EXPAND)
        parametersGridSizer.Add(self.incidentAlphaTxt, (1, 1), (1, 2),
                                wx.EXPAND)
        parametersGridSizer.Add(self.incidentAlphaEdt, (1, 3), (1, 2),
                                wx.EXPAND)
        parametersGridSizer.Add(self.sampleToDetectorDistanceTxt, (2, 1),
                                (1, 2), wx.EXPAND)
        parametersGridSizer.Add(self.sampleToDetectorDistanceEdt, (2, 3),
                                (1, 2), wx.EXPAND)
        parametersBoxSizer.Add(parametersGridSizer,
                               -1,
                               flag=wx.EXPAND | wx.ALL,
                               border=10)

        # Direct Beam Box
        self.directBeamBox = wx.StaticBox(self, -1, 'Direct Beam')
        self.directBeamBox.SetFont(wx.Font(10, wx.SWISS, wx.NORMAL, wx.NORMAL))

        directBeamBoxSizer = wx.StaticBoxSizer(self.directBeamBox, wx.VERTICAL)

        directBeamGridSizer = wx.GridBagSizer(hgap=10, vgap=10)
        directBeamGridSizer.Add(self.verticalPixelOnDetectorTxt, (0, 1),
                                (1, 1), wx.EXPAND)
        directBeamGridSizer.Add(self.verticalPixelOnDetectorEdt, (0, 2),
                                (1, 1), wx.EXPAND)
        directBeamGridSizer.Add(self.horizontalPixelOnDetectorTxt, (0, 3),
                                (1, 1), wx.EXPAND)
        directBeamGridSizer.Add(self.horizontalPixelOnDetectorEdt, (0, 4),
                                (1, 1), wx.EXPAND)
        directBeamBoxSizer.Add(directBeamGridSizer,
                               -1,
                               flag=wx.EXPAND | wx.ALL,
                               border=10)

        # Crop Region Box
        self.cropRegionBox = wx.StaticBox(self, -1, 'Selection')
        self.cropRegionBox.SetFont(wx.Font(10, wx.SWISS, wx.NORMAL, wx.NORMAL))

        cropRegionBoxSizer = wx.StaticBoxSizer(self.cropRegionBox, wx.VERTICAL)

        cropRegionBoxGridSizer = wx.GridBagSizer(hgap=10, vgap=10)
        cropRegionBoxGridSizer.Add(self.cropSizeTxt, (0, 1), (1, 1), wx.EXPAND)
        cropRegionBoxGridSizer.Add(self.cropSizeEdt, (0, 2), (1, 1), wx.EXPAND)
        cropRegionBoxGridSizer.Add(self.densityPixelTxt, (0, 5), (1, 1),
                                   wx.EXPAND)
        cropRegionBoxGridSizer.Add(self.densityPixelEdt, (0, 6), (1, 1),
                                   wx.EXPAND)
        cropRegionBoxSizer.Add(cropRegionBoxGridSizer,
                               -1,
                               flag=wx.EXPAND | wx.ALL,
                               border=10)

        # Figure Box
        self.figureBox = wx.StaticBox(self, -1, 'Figure')
        self.figureBox.SetFont(wx.Font(10, wx.SWISS, wx.NORMAL, wx.NORMAL))

        figureBoxSizer = wx.StaticBoxSizer(self.figureBox, wx.VERTICAL)

        figureBoxGridSizer = wx.GridBagSizer(hgap=10, vgap=10)
        figureBoxGridSizer.Add(directBeamBoxSizer, (0, 0), (3, 8),
                               flag=wx.RIGHT | wx.LEFT | wx.EXPAND,
                               border=5)
        figureBoxGridSizer.Add(cropRegionBoxSizer, (3, 0), (3, 8),
                               flag=wx.RIGHT | wx.LEFT | wx.EXPAND,
                               border=5)
        figureBoxSizer.Add(figureBoxGridSizer,
                           -1,
                           flag=wx.EXPAND | wx.ALL,
                           border=10)

        # Integration Box
        self.integrationBox = wx.StaticBox(self, -1, 'Integration')
        self.integrationBox.SetFont(wx.Font(10, wx.SWISS, wx.NORMAL,
                                            wx.NORMAL))

        integrationBoxSizer = wx.StaticBoxSizer(self.integrationBox,
                                                wx.VERTICAL)

        integrationBoxGridSizer = wx.GridBagSizer(hgap=10, vgap=10)
        integrationBoxGridSizer.Add(self.integrateOverQxyKeepQzBtn, (0, 0),
                                    (1, 1),
                                    flag=wx.RIGHT | wx.LEFT | wx.EXPAND,
                                    border=5)
        integrationBoxGridSizer.Add(self.integrateOverQxyKeepQxzBtn, (1, 0),
                                    (1, 1),
                                    flag=wx.RIGHT | wx.LEFT | wx.EXPAND,
                                    border=5)
        integrationBoxGridSizer.Add(self.integrateOverQxzKeepQxyBtn, (2, 0),
                                    (1, 1),
                                    flag=wx.RIGHT | wx.LEFT | wx.EXPAND,
                                    border=5)
        integrationBoxGridSizer.Add(self.integrateOverQzKeepQxyBtn, (3, 0),
                                    (1, 1),
                                    flag=wx.RIGHT | wx.LEFT | wx.EXPAND,
                                    border=5)
        integrationBoxGridSizer.Add(self.integrateBtn, (2, 1), (2, 1))
        integrationBoxGridSizer.Add(self.compareBtn, (0, 1), (2, 1))
        integrationBoxGridSizer.Add(self.lowerLimitQAxisTxt, (0, 2), (1, 1))
        integrationBoxGridSizer.Add(self.lowerLimitQAxisEdt, (1, 2), (1, 1))
        integrationBoxGridSizer.Add(self.upperLimitQAxisTxt, (2, 2), (1, 1))
        integrationBoxGridSizer.Add(self.upperLimitQAxisEdt, (3, 2), (1, 1))
        integrationBoxSizer.Add(integrationBoxGridSizer,
                                -1,
                                flag=wx.EXPAND | wx.ALL,
                                border=10)

        # ColorMap Slider
        self.sliderBox = wx.StaticBox(self, -1, label="")
        sliderBoxSizer = wx.StaticBoxSizer(self.sliderBox, wx.VERTICAL)

        sliderBoxGridSizer = wx.GridBagSizer(hgap=2, vgap=2)
        sliderBoxGridSizer.Add(self.upperLimitColorMapTxt, (0, 0), (1, 2),
                               flag=wx.RIGHT | wx.LEFT | wx.EXPAND,
                               border=2)
        sliderBoxGridSizer.Add(self.upperLimitColorMapSlider, (1, 0), (4, 2),
                               flag=wx.RIGHT | wx.LEFT | wx.EXPAND,
                               border=2)
        sliderBoxGridSizer.Add(self.upperLimitColorMapSliderTxt, (5, 0),
                               (1, 2),
                               flag=wx.RIGHT | wx.LEFT | wx.EXPAND,
                               border=2)
        sliderBoxGridSizer.Add(self.lowerLimitColorMapTxt, (0, 2), (1, 2),
                               flag=wx.RIGHT | wx.LEFT | wx.EXPAND,
                               border=2)
        sliderBoxGridSizer.Add(self.lowerLimitColorMapSlider, (1, 2), (4, 2),
                               flag=wx.RIGHT | wx.LEFT | wx.EXPAND,
                               border=2)
        sliderBoxGridSizer.Add(self.lowerLimitColorMapSliderTxt, (5, 2),
                               (1, 2),
                               flag=wx.RIGHT | wx.LEFT | wx.EXPAND,
                               border=2)
        sliderBoxGridSizer.Add(self.logScaleBtn, (6, 0), (1, 4),
                               flag=wx.RIGHT | wx.LEFT | wx.EXPAND,
                               border=2)
        sliderBoxSizer.Add(sliderBoxGridSizer,
                           -1,
                           flag=wx.EXPAND | wx.ALL,
                           border=1)

        # Figure customization
        self.plotBox = wx.StaticBox(self, -1, 'Plot')
        self.plotBox.SetFont(wx.Font(10, wx.SWISS, wx.NORMAL, wx.NORMAL))

        plotBoxSizer = wx.StaticBoxSizer(self.plotBox, wx.VERTICAL)

        plotBoxGridSizer = wx.GridBagSizer(hgap=10, vgap=10)
        plotBoxGridSizer.Add(sliderBoxSizer, (0, 0), (9, 1),
                             flag=wx.RIGHT | wx.LEFT | wx.EXPAND,
                             border=5)

        plotBoxGridSizer.Add(self.lowerLimitXAxisTxt, (0, 2), (1, 1),
                             wx.EXPAND)
        plotBoxGridSizer.Add(self.lowerLimitXAxisEdt, (0, 3), (1, 1),
                             flag=wx.RIGHT | wx.EXPAND,
                             border=10)
        plotBoxGridSizer.Add(self.upperLimitXAxisTxt, (1, 2), (1, 1),
                             wx.EXPAND)
        plotBoxGridSizer.Add(self.upperLimitXAxisEdt, (1, 3), (1, 1),
                             flag=wx.RIGHT | wx.EXPAND,
                             border=10)
        plotBoxGridSizer.Add(self.lowerLimitYAxisTxt, (2, 2), (1, 1),
                             wx.EXPAND)
        plotBoxGridSizer.Add(self.lowerLimitYAxisEdt, (2, 3), (1, 1),
                             flag=wx.RIGHT | wx.EXPAND,
                             border=10)
        plotBoxGridSizer.Add(self.upperLimitYAxisTxt, (3, 2), (1, 1),
                             wx.EXPAND)
        plotBoxGridSizer.Add(self.upperLimitYAxisEdt, (3, 3), (1, 1),
                             flag=wx.RIGHT | wx.EXPAND,
                             border=10)
        plotBoxGridSizer.Add(self.tickFontSizeTxt, (4, 2), (1, 1), wx.EXPAND)
        plotBoxGridSizer.Add(self.tickFontSizeEdt, (4, 3), (1, 1),
                             flag=wx.RIGHT | wx.EXPAND,
                             border=10)
        plotBoxGridSizer.Add(self.tickWidthTxt, (5, 2), (1, 1), wx.EXPAND)
        plotBoxGridSizer.Add(self.tickWidthEdt, (5, 3), (1, 1),
                             flag=wx.RIGHT | wx.EXPAND,
                             border=10)
        plotBoxGridSizer.Add(self.tickLengthTxt, (6, 2), (1, 1), wx.EXPAND)
        plotBoxGridSizer.Add(self.tickLengthEdt, (6, 3), (1, 1),
                             flag=wx.RIGHT | wx.EXPAND,
                             border=10)
        plotBoxGridSizer.Add(self.borderThicknessTxt, (7, 2), (1, 1),
                             wx.EXPAND)
        plotBoxGridSizer.Add(self.borderThicknessEdt, (7, 3), (1, 1),
                             flag=wx.RIGHT | wx.EXPAND,
                             border=10)
        plotBoxGridSizer.Add(self.plotAgainBtn, (8, 3), (1, 1),
                             flag=wx.RIGHT | wx.LEFT | wx.EXPAND,
                             border=10)
        plotBoxSizer.Add(plotBoxGridSizer,
                         -1,
                         flag=wx.EXPAND | wx.ALL,
                         border=5)

        root = wx.GridBagSizer(2, 2)
        root.Add(parametersBoxSizer, (0, 0), (2, 6),
                 flag=wx.RIGHT | wx.LEFT | wx.EXPAND,
                 border=20)
        root.Add(self.statusMessageTxt, (2, 0), (2, 6),
                 flag=wx.EXPAND | wx.LEFT | wx.RIGHT,
                 border=20)
        root.Add(figureBoxSizer, (4, 0), (3, 6),
                 flag=wx.RIGHT | wx.LEFT | wx.EXPAND,
                 border=20)
        root.Add(self.plotQxzQxyBtn, (7, 0), (2, 2),
                 flag=wx.ALL | wx.EXPAND,
                 border=20)
        root.Add(self.plotQzQxyBtn, (7, 2), (2, 2),
                 flag=wx.ALL | wx.EXPAND,
                 border=20)
        root.Add(self.runBtn, (7, 4), (2, 2),
                 flag=wx.ALL | wx.EXPAND,
                 border=20)
        root.Add(plotBoxSizer, (0, 6), (5, 5),
                 flag=wx.RIGHT | wx.LEFT | wx.EXPAND,
                 border=20)
        root.Add(integrationBoxSizer, (5, 6), (4, 5),
                 flag=wx.BOTTOM | wx.RIGHT | wx.LEFT | wx.EXPAND,
                 border=20)
        self.SetSizerAndFit(root)
Ejemplo n.º 27
0
    def createButtons(self):
        """ Create buttons to be used in game """
        # Crate grid sizer for buttons
        self.btn_sizer = wx.GridSizer(rows=3, cols=3, vgap=0, hgap=0)

        # Create buttons for game
        size = (200, 200)
        self.btn1 = buttons.GenToggleButton(self,
                                            size=size,
                                            style=wx.NO_BORDER
                                            | wx.ALIGN_CENTRE)
        self.btn2 = buttons.GenToggleButton(self,
                                            size=size,
                                            style=wx.NO_BORDER)
        self.btn3 = buttons.GenToggleButton(self,
                                            size=size,
                                            style=wx.NO_BORDER)
        self.btn4 = buttons.GenToggleButton(self,
                                            size=size,
                                            style=wx.NO_BORDER)
        self.btn5 = buttons.GenToggleButton(self,
                                            size=size,
                                            style=wx.NO_BORDER)
        self.btn6 = buttons.GenToggleButton(self,
                                            size=size,
                                            style=wx.NO_BORDER)
        self.btn7 = buttons.GenToggleButton(self,
                                            size=size,
                                            style=wx.NO_BORDER)
        self.btn8 = buttons.GenToggleButton(self,
                                            size=size,
                                            style=wx.NO_BORDER)
        self.btn9 = buttons.GenToggleButton(self,
                                            size=size,
                                            style=wx.NO_BORDER)
        #self.btn9 = wx.Button(self, id=wx.ID_ANY, label="test", size=size, style=wx.NO_BORDER)
        #self.btn9 = wx.BitmapButton(self, wx.ID_ANY, self.contbmp, pos=(150,300), style=wx.NO_BORDER)

        #self.btn1.SetBackgroundColour("Blue")

        txt = "I'm as clever as you."
        wrapped_txt = wordwrap(txt, 200, wx.ClientDC(self))
        self.btn1.SetLabel(wrapped_txt)
        # Get normal button color
        self.normal_btn_color = self.btn1.GetBackgroundColour()

        # Add buttons to a list
        self.btn_list = [
            self.btn1, self.btn2, self.btn3, self.btn4, self.btn5, self.btn6,
            self.btn7, self.btn8, self.btn9
        ]

        # Horizontal Wins
        self.btn_wins = [
            (self.btn1, self.btn2, self.btn3),
            (self.btn4, self.btn5, self.btn6),
            (self.btn7, self.btn8, self.btn9),
            # Vertical Wins
            (self.btn1, self.btn4, self.btn7),
            (self.btn2, self.btn5, self.btn8),
            (self.btn3, self.btn6, self.btn9),
            # Diagnol wins
            (self.btn1, self.btn5, self.btn9),
            (self.btn3, self.btn5, self.btn7)
        ]

        # Add buttons to btn_sizer and set font for each button
        for btn in self.btn_list:
            btn.SetFont(self.btn_font)
            #btn.setBackgroundColor("#9aeafe")
            self.btn_sizer.Add(btn)
            self.Bind(wx.EVT_BUTTON, self.onToggle, btn)

        self.restart_btn = wx.Button(self, -1, "Restart Game")