VA-Control-for-linux/reference/decompiled/my_menu.py

# uncompyle6 version 3.9.3
# Python bytecode version base 2.6 (62161)
# Decompiled from: Python 3.9.25 (main, Oct 31 2025, 23:16:49) 
# [GCC 14.2.0]
# Embedded file name: my_menu.pyc
# Compiled at: 2023-05-16 13:01:50
import mytime, wx, wx.lib.agw.flatmenu as flm, os.path, sys, traceback, one_unit, string
mac_names = 'posix'

class my_MenuBar(flm.FlatMenuBar):

    def __init__(self, parent, buttons=True):
        import inspect
        self.parent = parent
        self.program_title = ''
        self.buttons = buttons
        self.display_buffer = None
        self.menuCount = 0
        self.spacing = 5
        self.close_button = None
        self.minimize_button = None
        self.maximize_button = None
        flm.FlatMenuBar.__init__(self, self.parent, -1, options=flm.FM_OPT_IS_LCD | flm.FM_OPT_MINIBAR)
        if os.name in mac_names or one_unit.app.highDPI == False:
            self.font = wx.Font(8, wx.FONTFAMILY_DEFAULT, wx.FONTSTYLE_NORMAL, wx.FONTWEIGHT_NORMAL, False)
        else:
            self.font = wx.Font(8.0 / one_unit.app.displayScale[0], wx.FONTFAMILY_DEFAULT, wx.FONTSTYLE_NORMAL, wx.FONTWEIGHT_NORMAL, False)
        if os.name not in mac_names:
            self.Bind(wx.EVT_LEFT_DOWN, self.OnLeftDown)
            self.Bind(wx.EVT_LEFT_UP, self.OnLeftUp)
            self.Bind(wx.EVT_MOTION, self.OnMotion)
            self.display_buffer = None
            self.close_button = None
            self.minimize_button = None
            self.maximize_button = None
            self.left_down = False
            self.moved_screen = False
            self.mousePointAtClick = 0
            self.mousePointInFocus = 0
            self.Bind(wx.EVT_MOUSE_CAPTURE_LOST, (lambda x: None))
        if os.name in mac_names:
            self.osxbar = wx.MenuBar()
        return

    def SetSize(self, size):
        if os.name in mac_names:
            super(my_MenuBar, self).SetSize((size[0], 0))
            self.parent.SetMenuBar(self.osxbar)
        else:
            super(my_MenuBar, self).SetSize(size)
        if size[0] > 500:
            self.spacing = (size[0] - 500) / 10
        if self.spacing > 25:
            self.spacing = 25
        return

    def SetTitle(self, title):
        if self.GetSize()[0] > 300:
            self.program_title = title
        else:
            self.program_title = ''
        self.Refresh()
        return

    def GetTitle(self):
        return self.program_title

    def Append(self, menu, text):
        self.menuCount += 1
        super(my_MenuBar, self).Append(menu, text)
        if os.name in mac_names:
            self.osxbar.Append(menu.osxmenu, text)
        return

    def AppendIcons(self):
        if self.buttons == False:
            return
        bitmapdir = os.path.normpath(one_unit.app.cwd + '/bitmaps')
        self.close_button = wx.Bitmap(bitmapdir + '/close.png')
        self.minimize_button = wx.Bitmap(bitmapdir + '/minimize.png')
        try:
            CanMaximize = self.parent.CanMaximize
        except:
            CanMaximize = False

        if CanMaximize == True:
            self.maximize_button = wx.Bitmap(bitmapdir + '/maximize.png')
            self.restore_button = wx.Bitmap(bitmapdir + '/restore.png')
        if os.name in mac_names:
            self.parent.SetMenuBar(self.osxbar)
        return

    def OnLeftDown(self, e):
        x = e.GetX()
        self.left_down = True
        self.getOrReleaseMouseCapture(True)
        self.mousePointAtClick = e.GetPosition()
        self.parent.OnLeftDown(e)
        w = self.GetSize()[0] - 10
        if self.spacing > 5:
            w -= self.spacing / 2
        if self.close_button:
            if x < w and x > w - self.close_button.GetSize()[0]:
                self.parent.OnClose(e)
                self.left_down = False
                return
            w = w - self.close_button.GetSize()[0] - self.spacing
        if self.maximize_button:
            if x < w and x > w - self.maximize_button.GetSize()[0]:
                if self.parent.IsMaximized():
                    self.parent.Maximize(False)
                else:
                    self.parent.Maximize(True)
                return
            w = w - self.maximize_button.GetSize()[0] - self.spacing
        if self.minimize_button:
            if x < w and x > w - self.minimize_button.GetSize()[0]:
                self.parent.Iconize(True)
                self.left_down = False
                return
            w = w - self.minimize_button.GetSize()[0] - self.spacing
        super(my_MenuBar, self).OnLeftDown(e)
        return

    def OnPaint(self, e):
        if self.left_down:
            dc = wx.WindowDC(self)
            return
        else:
            super(my_MenuBar, self).OnPaint(e)
            if self.display_buffer == None:
                (w, h) = self.GetSize()
                self.display_buffer = wx.EmptyBitmap(w, h)
            if self.GetSize() != self.display_buffer.GetSize():
                (w, h) = self.GetSize()
                self.display_buffer = wx.EmptyBitmap(w, h)
            dc = wx.WindowDC(self)
            w = self.GetSize()[0] - 10
            if self.spacing > 5:
                w -= self.spacing / 2
            if self.close_button:
                w = w - self.close_button.GetSize()[0]
                dc.DrawBitmap(self.close_button, w, -3)
            if self.maximize_button:
                w = w - self.maximize_button.GetSize()[0] - self.spacing
                if self.parent.maximized == False:
                    dc.DrawBitmap(self.maximize_button, w, -3)
                else:
                    dc.DrawBitmap(self.restore_button, w, -3)
            if self.minimize_button:
                w = w - self.minimize_button.GetSize()[0] - self.spacing
                dc.DrawBitmap(self.minimize_button, w, -3)
            dc.SetFont(self.font)
            (tw, th) = dc.GetTextExtent(self.program_title)
            left = self.menuCount * 44
            right = w
            pos = (left + right) / 2 - tw / 2
            dc.DrawText(self.program_title, pos, self.GetSize()[1] / 2 - 5)
            return

    def OnLeftUp(self, event):
        self.left_down = False
        self.getOrReleaseMouseCapture(False)
        if self.moved_screen == True:
            self.moved_screen = False
            self.changed = True
            self.Refresh()
        self.parent.OnLeftUp(event)
        return

    def OnMotion(self, e):
        if self.parent.__name__ == 'GraphicalNetworkWindow':
            self.parent.OnMotion(e)
            return
        if e.Dragging() and self.left_down == True:
            actMousePoint = e.GetPosition()
            oldAppScreenPos = self.parent.GetPosition()
            mouseMoveDelta = actMousePoint - self.mousePointAtClick
            newAppScreenPos = oldAppScreenPos + mouseMoveDelta
            self.parent.Move(newAppScreenPos)
            self.moved_screen = True
        return

    def OnMenuDismissed(self, *args, **kwargs):
        """
            Called whenever a menu item (even the main menu entry itself) was selected.
            This method is used to make sure that the mouse capture for the flat menu bar
            (i.e. the window it belongs to) is released. Else the user might do unwanted
            window movements or is not able to click on action buttons (needs to click twice)
        
            @param self: The class object itself
            @param e: The event handler object
        """
        self.left_down = False
        self.getOrReleaseMouseCapture(False)
        return flm.FlatMenuBar.OnMenuDismissed(self, *args, **kwargs)

    def getOrReleaseMouseCapture(self, capture):
        """
            Captures the mouse for this class object (which keeps a wxWidgets frame or a compatible
            wxWidgets object). The mouse will only be captured or released if the class object hasCapture
            method returns the correct value.
           
            @param self: The class object itself
            @param capture: True or false. True get the mouse capture for this class, false release it
        """
        if capture and not self.HasCapture():
            self.CaptureMouse()
        if not capture and self.HasCapture():
            self.ReleaseMouse()
        return


class my_Menu(flm.FlatMenu):

    def __init__(self, parent):
        self.parent = parent
        self.menuItems = {}
        self._mousePtAtStartup = None
        flm.FlatMenu.__init__(self)
        if os.name in mac_names:
            self.osxmenu = wx.Menu()
        return

    def Append(self, id, t1, t2):
        if os.name in mac_names:
            item = self.osxmenu.Append(id, t1, t2)
        else:
            item = super(my_Menu, self).Append(id, t1, t2, None)
        self.menuItems[id] = item
        return item

    def AppendSeparator(self):
        if os.name in mac_names:
            return self.osxmenu.AppendSeparator()
        return super(my_Menu, self).AppendSeparator()

    def AppendMenu(self, id, t1, menu):
        if os.name in mac_names:
            return self.osxmenu.AppendMenu(id, t1, menu.osxmenu)
        else:
            return super(my_Menu, self).AppendMenu(id, t1, menu, None)

    def AppendRadioItem(self, id, t1, t2):
        if os.name in mac_names:
            return self.osxmenu.AppendRadioItem(id, t1, t2)
        return super(my_Menu, self).AppendRadioItem(id, t1, t2)

    def AppendCheckItem(self, id, t1, t2):
        if os.name in mac_names:
            return self.osxmenu.AppendCheckItem(id, t1, t2)
        return super(my_Menu, self).AppendCheckItem(id, t1, t2)

    def Check(self, id, val):
        item = self.FindItem(id)
        if item != None:
            item.Check()
        else:
            try:
                if os.name in mac_names:
                    self.osxmenu.Check(id, val)
                super(my_Menu, self).Check(id, val)
            except:
                pass

        return

    def SetLabel(self, id, val):
        if os.name in mac_names:
            self.osxmenu.SetLabel(id, val)
        else:
            item = self.FindItem(id)
            item.SetText(val)
        return

    def GetLabel(self, id):
        if os.name in mac_names:
            return self.osxmenu.GetLabel(id)
        else:
            item = self.FindItem(id)
            return item.GetText()
        return

    def GetMenuItems(self):
        return self.menuItems

    def FindItemById(self, id):
        if os.name in mac_names:
            return self.osxmenu.FindItemById(id)
        else:
            return self.menuItems[id]
        return

    def Destroy(self, id):
        if os.name in mac_names:
            self.osxmenu.Delete(id)
        else:
            super(my_Menu, self).Destroy(self.menuItems[id])
        del self.menuItems[id]
        return



# okay decompiling pycode/my_menu.pyc