Re: Re: Looking for an "on/off" toggle control

'''
    onoffbutton.py

    A custom class On/Off clickable.

    Events: EVT_ON_OFF          Generic event on binary change

            EVT_ON              The control changed to On

            EVT_OFF             The control changed to Off

    Event Notes:
        All events return GetValue() i.e.

            def OnOff(self,event):
                current_value = event.GetValue()

    Functions:
        GetValue()              Returns numeric value in the control On (True) = 1 Off (False) = 0

        SetValue(int)           Set numeric value in the control
        SetLabel(str)           Set label for the control
        SetToolTip(str)         Set tooltip for the control
        SetForegroundColour     Set text colour
        SetBackgroundColour     Set background colour

        Enable(Bool)            Enable/Disable the control
                                On Disable the control value is frozen

        IsEnabled()             Is the control Enabled - Returns True/False

    Default Values:
        initial -       0 (False) Off
        
    Issues:
        I traded the ability to scale the image for any sensible ability to
        change the label font size, as I rarely use the label of a checkbox,
        instead opting to use a statictext to the left of it.
        
Author:     J Healey
Created:    14/01/2021
Copyright:  J Healey - 2021
License:    GPL 3 or any later version
Email:      [email protected]
'''

import wx

#Events OnOff, On and Off
oobEVT_ON_OFF = wx.NewEventType()
EVT_ON_OFF = wx.PyEventBinder(oobEVT_ON_OFF, 1)
oobEVT_ON = wx.NewEventType()
EVT_ON = wx.PyEventBinder(oobEVT_ON, 1)
oobEVT_OFF = wx.NewEventType()
EVT_OFF = wx.PyEventBinder(oobEVT_OFF, 1)

class OnOffEvent(wx.PyCommandEvent):
    """ Event sent from the :class:`OnOff` when the control changes. """

    def __init__(self, eventType, eventId=1, value=0):
        """
        Default class constructor.

        :param `eventType`: the event type;
        :param `eventId`: the event identifier.
        """

        wx.PyCommandEvent.__init__(self, eventType, eventId)
        self._eventType = eventType
        self.value = value

    def GetValue(self):
        """
        Retrieve the value of the control at the time
        this event was generated."""
        return self.value

class OnOffButton(wx.Control):

    def __init__(self, parent, id=wx.ID_ANY, label="", pos=wx.DefaultPosition, size=wx.DefaultSize, initial=0, style=wx.BORDER_NONE, mono=False, border=True, name="OnOff_Button"):
        """
        Default class constructor.

        @param parent:  Parent window. Must not be None.
        @param id:      identifier. A value of -1 indicates a default value.
        @param label:   control label.
        @param pos:     Position. If the position (-1, -1) is specified
                        then a default position is chosen.
        @param size:    If the default size (-1, -1) is specified then the minimum size is chosen.
        @param initial: Initial value 0 False or 1 True - default False.
        @param style:   control border style.
        @param mono:    True or False makes the image monochrome or colour - default False
        @param border:  True or False adds a border to the image - default True
        @param name:    Widget name.
        """

        wx.Control.__init__(self, parent, id, pos=pos, size=size, style=style, name=name)
        self._initial = initial
        self._frozen_value = initial
        self._label = label
        self._pos = pos
        self._size = size
        self._name = name
        self._id = id
        self._mono = mono
        self._border = border
        self._style = style
        self.OnClr = 'green' 
        self.OffClr = 'red' 
        if self._mono:
            self.OnClr = self.OffClr = 'white' 
        if self._initial > 1:
            self._initial = 1
        if self._initial < 0:
            self._initial = 0

        self._Value = initial

        # Initialize images
        self.InitialiseBitmaps()
        self.onoff = wx.StaticBitmap(self, -1, bitmap=wx.Bitmap(self._img))
        self.label = wx.StaticText(self, -1, self._label)

        # Bind the event
        self.onoff.Bind(wx.EVT_LEFT_DOWN, self.OnOff)

        sizer = wx.BoxSizer(wx.HORIZONTAL)
        sizer.Add(self.onoff, 0, 0, 0)
        sizer.Add(self.label, 0, wx.ALIGN_CENTRE, 0)
        self.SetImage(self._initial)
        self.SetSizerAndFit(sizer)
        self.Show()

    def InitialiseBitmaps(self):
        self._bitmaps = {
            "On": self.SetImageSize(self._CreateBitmap("On")),
            "Off": self.SetImageSize(self._CreateBitmap("Off")),
            "Disable": self.SetImageSize(self._CreateBitmap("Disable")),
            }
        if self._initial <= 0:
            self._img = self._bitmaps['Off']
        elif self._initial >= 1:
            self._img = self._bitmaps['On']

    def _CreateBitmap(self, type):
        bmp = wx.Bitmap(80, 36)
        dc = wx.MemoryDC(bmp)
        dc.SetBackgroundMode(wx.TRANSPARENT)
        bg = self.GetBackgroundColour()
        fg = self.GetForegroundColour()
        brush = wx.Brush(bg)  
        dc.SetBackground(brush)
        dc.Clear() 
        
        dc.SetBrush(brush) 
        if self._border:
            dc.DrawRoundedRectangle(2,3,70,33,16.0)
        if type == "On":
            dc.SetBrush(wx.Brush(self.OnClr)) 
        elif type == "Off":
            dc.SetBrush(wx.Brush(self.OffClr)) 
        else:
            dc.SetBrush(wx.Brush('grey')) 
        dc.DrawRoundedRectangle(12,9,48,21,10.0)
        dc.SetBrush(wx.Brush(fg))
        if type == "On":
            dc.DrawCircle(52,19,12)
        else:
            dc.DrawCircle(22,19,12)
        bmp = dc.GetAsBitmap((0, 0, 80, 36))
        return bmp

    def SetImageSize(self,img):
        imgsize = img.GetSize()
        imgh = imgsize[1]
        imgw = imgsize[0]
        w = self._size[0]
        h = self._size[1]
        if w <= 0:
            w = 20
        if h <= 0:
            h = 12
        img = img.ConvertToImage()
        img = img.Scale(w,h,quality=wx.IMAGE_QUALITY_HIGH)
        return img

    def SetValue(self,value):
        if value > 1:
            value = 1
        if value < 0:
            value = 0
        self._Value = value
        self.SetImage(value)
        self.Update()

    def GetValue(self):
        return self._Value

    def SetLabel(self,label):
        self.label.SetLabel(label)
        self.Update()

    def GetLabel(self,label):
        return self.label.GetLabel()

    def IsEnabled(self):
        return wx.Control.IsEnabled(self)

    def Enable(self, value):
        if value and self.IsEnabled(): # If value = current state do nothing
            return
        if not value and not self.IsEnabled():
            return
        wx.Control.Enable(self, value)
        self.Update()
        if value:
            #Enable via callafter in case someone has been stabbing away on the disabled control
            wx.CallAfter(self.OnReset)
        else:
            #Disable - Freeze the controls Value and change bitmap
            self._frozen_value = self.GetValue()
            self._img = self._bitmaps['Disable']
            self.onoff.SetBitmap(wx.Bitmap(self._img))
            self.onoff.SetToolTip(self._name+" - [Disabled]")

    def SetToolTip(self, tip):
        wx.Control.SetToolTip(self,tip)
        self.Refresh()

    def SetForegroundColour(self, colour):
        wx.Control.SetForegroundColour(self, colour)
        self.InitialiseBitmaps()
        self.SetImage(self._Value)        
        self.Refresh()

    def SetBackgroundColour(self, colour):
        wx.Control.SetBackgroundColour(self, colour)
        self.InitialiseBitmaps()
        self.SetImage(self._Value)        
        self.Refresh()

    def OnReset(self):
        #Reset the control to the state it was in when it was Disabled
        self.SetValue(self._frozen_value)
        self.SetImage(self._frozen_value)

    def OnOff(self, event):
        state = self._Value
        if state == 0:
            state = 1
        else:
            state = 0

        if state:
            self.SetValue(1)
            value = 1
            #event change
            event = OnOffEvent(oobEVT_ON_OFF, self.GetId(), value)
            event.SetEventObject(self)
            self.GetEventHandler().ProcessEvent(event)
            #event On
            event = OnOffEvent(oobEVT_ON, self.GetId(), value)
            event.SetEventObject(self)
            self.GetEventHandler().ProcessEvent(event)
        else:
            self.SetValue(0)
            value = 0
            #event change
            event = OnOffEvent(oobEVT_ON_OFF, self.GetId(), value)
            event.SetEventObject(self)
            self.GetEventHandler().ProcessEvent(event)
            #event Off
            event = OnOffEvent(oobEVT_OFF, self.GetId(), value)
            event.SetEventObject(self)
            self.GetEventHandler().ProcessEvent(event)
        self.SetImage(value)

    def SetImage(self, value):
        #Set appropriate image and tooltip
        tp = self.GetToolTip()
        if not self.IsEnabled():
            self._img = self._bitmaps['Disable']
            if tp != None:
                tt = tp.GetTip()+" - [Currently Disabled]"
            else:
                tt = "[Disabled]"
        else:
            if value <= 0:
                self._img = self._bitmaps['Off']
                if tp != None:
                    tt = tp.GetTip()+" - [Currently Off]"
                else:
                    tt = "[ Off ]"
            else:
                self._img = self._bitmaps['On']
                if tp != None:
                    tt = tp.GetTip()+" - [Currently On]"
                else:
                    tt = "[ On ]"

        self.onoff.SetBitmap(wx.Bitmap(self._img))
        self.onoff.SetToolTip(tt)
        self.Layout()

if __name__ == '__main__':

    class MyFrame(wx.Frame):

        def __init__(self, parent):

            wx.Frame.__init__(self, parent, -1, "On/Off Demo")

            panel = wx.Panel(self)
            panel.SetBackgroundColour("lightgreen")
            
            self.onoff = OnOffButton(panel, -1, label="80 X 48", pos=(50, 50), size=(80,48), initial=1)
            self.onoff1 = OnOffButton(panel, -1, label="60 X 36 No border", pos=(50, 100), size=(60,36), initial=1, border=False)
            self.onoff2 = OnOffButton(panel, -1, "40 x 24", pos=(50, 150), size =(40,24), initial=0)
            self.onoff3 = OnOffButton(panel, -1, "30 x 18 Mono", pos=(50, 200), size =(30,18), initial=0, mono=True)
            self.onoff4 = OnOffButton(panel, -1, " Minimum Mono No border", pos=(50, 250), initial=0, mono=True, border=False)
            self.onoff5 = OnOffButton(panel, -1, " Minimum 20 X 16", pos=(50, 300), initial=0)
            self.txt = wx.TextCtrl(panel, -1, "On", size=(50,30), pos=(220,50))
            self.txt1 = wx.TextCtrl(panel, -1, "Off", size=(50,30), pos=(220,100))
            self.onoff.Bind(EVT_ON_OFF, self.OnOff)
            self.Bind(EVT_ON, self.SwOn)
            self.Bind(EVT_OFF, self.SwOff)
            self.onoff1.Bind(EVT_ON_OFF, self.OnOff1)

        def OnOff(self, event):
            if event.GetValue():
                self.txt.SetValue("On")
            else:
                self.txt.SetValue("Off")
            event.Skip()

        def OnOff1(self, event):
            if event.GetValue():
                self.txt1.SetValue("On")
            else:
                self.txt1.SetValue("Off")
            event.Skip()

        def SwOn(self, event):
            obj = event.GetEventObject()
            print(obj.Name + " On")

        def SwOff(self, event):
            obj = event.GetEventObject()
            print(obj.Name + " Off")

    app = wx.App()
    frame = MyFrame(None)
    app.SetTopWindow(frame)
    frame.Show()
    app.MainLoop()