About how to create my custom book control?

I need some functionality to my custom book control, I take as base the labelbook,
I can’t get to add the labels of the pages to the combobox creating the child pages in the AddPage() method.
I place a combobox to understand how works the code but i want change it to menus to control the page change behavior I try to copy and simplify the labelbook code to my custom control

here the custom control code testbook.py file

import wx

wxEVT_MENUNOTEBOOK_PAGE_CHANGED = wx.wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED
wxEVT_MENUNOTEBOOK_PAGE_CHANGING = wx.wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING
wxEVT_MENUNOTEBOOK_PAGE_CLOSING = wx.NewEventType()
wxEVT_MENUNOTEBOOK_PAGE_CLOSED = wx.NewEventType()

EVT_MENUNOTEBOOK_PAGE_CHANGED = wx.EVT_NOTEBOOK_PAGE_CHANGED
EVT_MENUNOTEBOOK_PAGE_CHANGING = wx.EVT_NOTEBOOK_PAGE_CHANGING
EVT_MENUNOTEBOOK_PAGE_CLOSING = wx.PyEventBinder(wxEVT_MENUNOTEBOOK_PAGE_CLOSING, 1)
EVT_MENUNOTEBOOK_PAGE_CLOSED = wx.PyEventBinder(wxEVT_MENUNOTEBOOK_PAGE_CLOSED, 1)


class menubookevent(wx.PyCommandEvent):
    def __init__(self, eventType, eventId=-1, sel=-1, oldsel=-1):
        wx.PyCommandEvent.__init__(self, eventType, eventId)

        self._eventType = eventType
        self._sel = sel
        self._oldSel = oldsel
        self._allowed = True

    def SetSelection(self, s):
        self._sel = s

    def SetOldSelection(self, s):
        self._oldsel = s

    def GetSelection(self):
        return self._sel

    def GetOldSelection(self):
        return self._oldsel

    def Veto(self):
        self._allowed = False

    def Allow(self):
        self._allowed = True

    def IsAllowed(self):
        return self._allowed
        

class PageInfo(object):
    def __init__(self, strCaption="", enabled=True):

        self._pos = wx.Point()
        self._size = wx.Size()
        self._strCaption = strCaption
        self._captionRect = wx.Rect()
        self._bEnabled = enabled

    def SetCaption(self, value):
        self._strCaption = value

    def GetCaptino(self):
        return self._strCaption

    def GetEnabled(self):
        return self._bEnabled

    def EnableMenu(self, enabled):
        self._bEnabled = enabled

    # posible no usar
    
    def SetPosition(self, value):
        self._pos = value

    def GetPosition(self):
        return self._pos

    def SetSize(self, value):
        self._size = value

    def GetSize(self):
        return self._size

    def SetTextRect(self, rect):
        self._captionRect = rect

    def GetTextRect(self):
        return self._captionRect

    # no usara? hasta aqui

class MenuContainer(wx.Panel):
    def __init__(self, parent, id=wx.ID_ANY, pos=wx.DefaultPosition, size=wx.DefaultSize, style=0, name="MenuContainer"):
        wx.Panel.__init__(self, parent, id, pos, size, style, name)

        self._nIndex = -1
        self._bCollapsed = False
        self._pagesInfoVec = []

        self._menuWidth = 200
        self.cs = []
        self.cb = wx.ComboBox(self, -1, "default", wx.DefaultPosition, wx.DefaultSize, self.cs)

        for i in xrange(len(self._pagesInfoVec)):
            self.cs.append(self._pagesInfoVec[i].GetCaptino())
            self.cb.SetValue(self._pagesInfoVec[self._nIndex].GetCaptino()) 
        #self.cb = wx.ComboBox(self, -1, "default", wx.DefaultPosition, wx.DefaultSize, self.cs)

    def AddPage(self, caption, selected=False):
        self._pagesInfoVec.append(PageInfo(caption))
        if selected or len(self._pagesInfoVec) == 1:
            self._nIndex = len(self._pagesInfoVec)-1
            self.cs.append(self._pagesInfoVec[self._nIndex].GetCaptino())
            #self.cb.SetValue(self._pagesInfoVec[self._nIndex].GetCaptino())
        
        self.cb.Refresh()
        self.Refresh()

    def InsertPage(self, page_idx, caption, selected=False):
        self._pagesInfoVec.insert(page_idx, PageInfo(caption))
        if selected or len(self._pagesInfoVec) == 1:
            self._nIndex = len(self._pagesInfoVec)-1
        self.Refresh()

    def GetEnabled(self, page):
        if page >= len(self._pagesInfoVec):
            return True
        pgeInfo = self._pagesInfoVec[page]
        return pgeInfo.GetEnabled()

    def EnableMenu(self, page, enabled=True):
        if page >= len(self._pagesInfoVec):
            return
        pgInfo = self._pagesInfoVec[page]
        pgInfo.EnableMenu(enabled)

    def GetMenuWidth(self):
        return self._menuWidth

class MenuBookBase(wx.Panel):
    def __init__(self, parent, id=wx.ID_ANY, pos=wx.DefaultPosition, size= wx.DefaultSize,
                 style=0, name="MenuBookBase"):
        self._pages = None
        self._bInitializing = True
        self._pages = None
        self._bForceSelection = False
        self._windows = []

        wx.Panel.__init__(self, parent, id, pos, size, style, name)
        self._bInitializing = False

        #self.Bind(wx.EVT_NAVIGATION_KEY, self.OnNavigationKey)
        #self.Bind(wx.EVT_MOUSE_CAPTURE_LOST, lambda evt: True)

         #

        if not self._pages:
            return

        if isinstance(self, MenuBook):
            self._mainSizer = wx.BoxSizer(wx.VERTICAL)

        self.SetSizer(self._mainSizer)
        self._mainSizer.Add(self._pages, 0, wx.EXPAND)

        self._mainSizer.Layout()

        self._pages.Refresh()
       
        if self.GetSelection() >= 0:
            self._mainSizer.Detach(self._windows[self.GetSelection()])

        #

    def AddPage(self, page, text, select=False):
        if not page:
            return
        page.Reparent(self)
        self._windows.append(page)

        if select or len(self._windows) == 1:
            self.SetSelection(len(self._windows)-1)
        else:
            page.Hide()

        self._pages.AddPage(text, select)
        self.Refresh()

    def InsertPage(self, page_idx, page, text, select=False):
        if not page:
            return
        page.Reparent(self)

        self._windows.insert(page_idx, page)

        if select or len(self._windows) == 1:
            self.SetSelection(page_idx)
        else:
            page.Hide()

        self._pages.InsertPage(page_idx, text, select)
        self.Refresh()

    def DeletePage(self, page):
        if page >= len(self._windows) or page < 0:
            return
        event = menubookevent(wxEVT_MENUNOTEBOOK_PAGE_CLOSING, self.GetId())
        event.SetSelection(page)
        event.SetEventObject(self)
        self.GetEventHandler().ProcessEvent(event)

        if not event.IsAllowed():
            return False

        self.Freeze()

        pageRemoved = self._windows[page]

        if page == self.GetSelection():
            self._mainSizer.Detach(pageRemoved)
        
        self._windows.pop(page)

        pageRemoved.Destroy()
        self._mainSizer.Layout()
        self._pages.DoDeletePage(page)
        self.Thaw()

    def SetSelection(self, page):
        if page >= len(self._windows):
            return

        if not self.GetEnabled(page):
            return
        
        if page == self.GetSelection() and not self._bForceSelection:
            return
        oldSelection = self.GetSelection()

        event = menubookevent(wxEVT_MENUNOTEBOOK_PAGE_CHANGING, self.GetId())
        event.SetSelection(page)
        event.SetOldSelection(oldSelection)
        event.SetEventObject(self)
        self.GetEventHandler().ProcessEvent(event)

        if not event.IsAllowed() and not self._bForceSelection:
            return
        self.DoSetSelection(self._windows[page])
        self._pages._nIndex = page

        self._pages.Refresh()

        eventChanged = menubookevent(wxEVT_MENUNOTEBOOK_PAGE_CHANGED, self.GetId())
        eventChanged.SetEventObject(self)
        eventChanged.SetOldSelection(oldSelection)
        eventChanged.SetSelection(page)
        self.GetEventHandler().ProcessEvent(eventChanged)

    def GetSelection(self):
        if self._pages:
            return self._pages._nIndex
        else:
            return -1

    def DoSetSelection(self, window):
        curSel = self.GetSelection()
        self.Freeze()

        if curSel >= 0:
            self._mainSizer.Detach(self._windows[curSel])
            self._windows[curSel].Hide()

        #self._mainSizer.Insert(0. window, 1, wx.EXPAND)
        self._mainSizer.Add(window, 1, wx.EXPAND)

        window.Show()
        self._mainSizer.Layout()
        self.Thaw()

    def GetPageCount(self):
        return len(self._windows)

    def GetEnabled(self, page):
        return self._pages.GetEnabled(page)

    def GetPage(self, page):
        if page >= len(self._windows):
            return
        return self._windows[page]

    def GetCurrentPage(self):
        if self.GetSelection() < 0:
            return
        return self.GetPage(self.GetSelection())
    
    def ChangeSelection(self, page):
        if page < 0 or page >= self.GetPageCount():
            return 
        oldpage = self.GetSelection()
        self.DoSetSelection(page)
        return oldpage

    CurrentPage = property(GetCurrentPage, doc="see GetCurrentPage")


class MenuBook(MenuBookBase):
    def __init__(self, parent, id=wx.ID_ANY, pos=wx.DefaultPosition, size= wx.DefaultSize, 
                 style=0, name="MenuBook"):
        MenuBookBase.__init__(self, parent, id, pos, size, style, name)

        self._pages = self.CreatePageContainer()

        self._mainSizer = wx.BoxSizer(wx.VERTICAL)
        self.SetSizer(self._mainSizer)

        self._mainSizer.Add(self._pages, 0, wx.EXPAND)
        self._pages.SetSizeHints(self._pages.GetMenuWidth(), -1)
    
    def CreatePageContainer(self):
        return MenuContainer(self, wx.ID_ANY)




and here the sample where i use it

import wx
import testbook as mbook

class sample(wx.Frame):
    def __init__(self, parent, id, title):
        wx.Frame.__init__(self, parent, id, title)

        cb = mbook.MenuBook(self, -1)
        pnl = wx.Panel(cb, -1)
        pnl.SetBackgroundColour("RED")
        pnl2 = wx.Panel(cb, -1)
        pnl2.SetBackgroundColour("green")
        cb.AddPage(pnl, "red", True)
        cb.AddPage(pnl2, "green", True)
        cb.SetSelection(1)
        print(cb.GetPageCount())


app = wx.App()
win = sample(None, -1, "Sample").Show()
app.MainLoop()

if some python master can help me I will appreciate it

Take a look at the new(ish) wx.SimpleBook class in the recent releases. It is essentially a notebook-like class without any user visible controls for switching pages. Instead it is up to the application to switch the active page as needed. In the sample in the demo I added a button on each page to switch to a different page. You can easily do that with a menu instead. Using the wx.SimpleBook will probably save you a lot code that is just reinventing the wheel.

thanks Robin I’m using old wxpython version i need to update it to use the control