WxPython Book — Code Section Inventory

class wx.Panel(Window)
Possible constructors:

__init__(self, parent, id=ID_ANY, pos=DefaultPosition,
         size=DefaultSize, style=TAB_TRAVERSAL,
         name=PanelNameStr) -> None

panel = wx.Panel(parent=parent)

pip install -U wxpython

import wx

xcode-select --install

pip install -U wxPython

python3 -m pip install wxPython
py -3.12 -m pip install wxPython

import wx
print(wx.version())

python -c "import sys; print(sys.executable)"

import wx

app = wx.App()
frame = wx.Frame(None, title="First wx program")
panel = wx.Panel(frame)
text = wx.StaticText(panel, label ="Hello World")

frame.Show()
app.MainLoop()

import wx

class ClickCounter(wx.Frame):
    def __init__(self):
        super().__init__(None, title='Click Counter',
                         size = (175, 90))
        self.clicks = 0

        frame_sizer = wx.BoxSizer(orient=wx.HORIZONTAL)
        self.SetSizer(frame_sizer)

        # Make a panel and add it to the frame's sizer
        panel = wx.Panel(self)
        panel_sizer = wx.BoxSizer(orient=wx.VERTICAL)
        panel.SetSizer(panel_sizer)
        frame_sizer.Add(panel)

        # Make some widgets--first, a button
        button = wx.Button(panel, label='Click Me')
        panel_sizer.Add(button, flag=wx.ALL, border=5)
        button.Bind(wx.EVT_BUTTON, self.handle_button)
        
        # Next, a "static text" widget
        self.text = wx.StaticText(panel,
                            label='No clicks so far.')
        panel_sizer.Add(self.text)

    def handle_button(self, event):
        self.clicks += 1
        self.text.SetLabel('Clicks so far: ' +
                           str(self.clicks))

if __name__ == '__main__':
    app = wx.App()
    ClickCounter().Show()
    app.MainLoop()

import wx
class ClickCounter(wx.Frame):
     def __init__(self):
        super().__init__(None, title='Click Counter',
                         size = (175, 90)

self.clicks = 0

frame_sizer = wx.BoxSizer(orient=wx.HORIZONTAL)
self.SetSizer(frame_sizer)

panel = wx.Panel(self)
frame_sizer.Add(panel)

panel_sizer = wx.BoxSizer(orient=wx.VERTICAL)
panel.SetSizer(panel_sizer)

button = wx.Button(panel, label='Click Me')

panel_sizer.Add(button, flag=wx.ALL, border=5)

button.Bind(wx.EVT_BUTTON, self.handle_button)

# Next, a "static text" widget
self.text = wx.StaticText(panel,
                          label='No clicks yet.')
self.text.SetMinSize((120, -1))
panel_sizer.Add(self.text, flag=wx.ALL, border=5)

def handle_button(self, event):
    self.clicks += 1
    self.text.SetLabel('Clicks so far: ' +
                       str(self.clicks))

if __name__ == '__main__':
    app = wx.App()
    ClickCounter().Show()
    app.MainLoop()

import wx

class MyGui(wx.Frame):

    def __init__(self):
        super().__init__(None, title='My GUI')

        # Make a sizer for MyGui, and call SetSizer

        # Make one or more panels, and for each one,
        # make a sizer and connect it to the panel.

        # Add each panel to the sizer for the GUI.

        # Make some widgets and add each one to the
        # sizer for some panel.
       
        # Bind functions to widgets.

    # Define functions to be called by widgets.

    def function_name(self, event):
        # Code to handle event

if __name__ == '__main__':
    app = wx.App()
    MyGui().Show()
    app.MainLoop()

slider = wx.Slider(panel_2,
                   value = 50,
                   minValue = 0,
                   maxValue = 100,
                   size = (200, 50),
                   style = wx.SL_HORIZONTAL)

slider = wx.Slider(panel_2, value = 50, minValue = 0,
                   maxValue = 100, size = (200, 50),
                   style = wx.SL_HORIZONTAL)

slider = wx.Slider(
    panel_2, value=50, minValue=0, maxValue=100,
    size=(200, 50), style=wx.SL_HORIZONTAL)

label = wx.StaticText(parent, label=text)

button = wx.Button(parent, label=label)
button.Bind(wx.EVT_BUTTON, handler)

ctrl = wx.TextCtrl(parent)
text = ctrl.GetValue()

ctrl = wx.TextCtrl(parent, style=wx.TE_MULTILINE)
text = ctrl.GetValue()
text = ctrl.GetLineText(lineNo)
ctrl.SetValue(text)

ctrl = wx.TextCtrl(parent, style=wx.TE_PASSWORD)
text = ctrl.GetValue()

checkbox = wx.CheckBox(parent, label=text)
boolean = checkbox.GetValue()

radio = wx.RadioButton(parent, label=text)
boolean = radio.GetValue()

path = path_to_image_file
bmp = wx.Bitmap(path, wx.BITMAP_TYPE_ANY)
static_bitmap = wx.StaticBitmap(parent, bitmap=bmp)

combo = wx.ComboBox(parent, choices=list_of_strings)
text = combo.GetValue()

listbox = wx.ListBox(parent, choices=list_of_strings)
index = listbox.GetSelection()
if index >= 0:
    text = listbox.GetString(index)

slider = wx.Slider(parent)
value = slider.GetValue()
slider.SetValue(value)

panel = wx.Panel(parent)

ok_button = wx.Button(label='OK', parent=panel_2)

Add(self, window, proportion=0, flag=0, border=0, userData=None)
my_sizer.Add(ok_button, border=5)

my_button.Add(panel_2) # illegal

path = path_to_image_file
bmp = wx.Bitmap(path, wx.BITMAP_TYPE_ANY)
static_bitmap = wx.StaticBitmap(parent, bitmap=bmp)

sizer.Add(static_bitmap)

path = path_to_image_file
img = wx.Image(path, wx.BITMAP_TYPE_ANY)

# Rotate image around center point
(w, h) = (img.GetWidth() // 2, img.GetHeight() // 2)
img = img.Rotate(angle=0.5,
                 rotationCentre=wx.Point(w, h))
bmp = wx.Bitmap(img)
static_bitmap = wx.StaticBitmap(panel, bitmap=bmp)
sizer.Add(static_bitmap)

widget = wx.WidgetType(parent, other_args)

frame = wx.Frame(None, title=title,
                 size=(width, height)))

frame_sizer = wx.BoxSizer(orient=wx.HORIZONTAL)
frame.SetSizer(frame_sizer)

panel = wx.Panel(frame)
frame_sizer.Add(panel)

sizer = wx.BoxSizer(orient=wx.HORIZONTAL)
panel.SetSizer(sizer)

button = wx.Button(panel, label=text)
sizer.Add(button)

sizer = wx.WrapSizer(orient = wx.HORIZONTAL) # default

sizer = wx.WrapSizer(orient = wx.VERTICAL)

sizer = wx.BoxSizer(orient = wx.HORIZONTAL)

sizer = wx.BoxSizer(orient = wx.VERTICAL)

sizer = wx.StaticBoxSizer(orient, parent, label)

sizer = wx.GridSizer(cols=cols, vgap=v, hgap=h)

sizer = wx.GridSizer(rows=rows, cols=cols,
                     vgap=v, hgap=h)

sizer = wx.FlexGridSizer(cols=cols, vgap=v, hgap=h)

sizer = wx.GridBagSizer(vgap=v, hgap=h)

sizer.Add(widget, pos=wx.GBPosition(row=row,
                                    col=column))

sizer.Add(widget, pos=wx.GBPosition(row=row,
                                    col=column),
                  span=wx.GBSpan(rowspan=rows,
                                 colspan=columns))

wx.Size(width = 1, height = 1)

button.Bind(wx.EVT_BUTTON, self.function)

def button_function(self, event):
    # do something

self.text = wx.StaticText(...)

def handle_button(self, _event):
    self.clicks += 1
    self.text.SetLabel('Clicks so far: ' +
                       str(self.clicks))

self.entry = wx.TextCtrl(parent)

button.Bind(wx.EVT_BUTTON, self.get_entry)

def get_entry(self, event):
    text = self.entry.GetValue()

menubar = wx.MenuBar()
frame.SetMenuBar(menubar)

file_menu = wx.Menu()
menubar.Append(file_menu, 'File')

open_item = wx.MenuItem(file_menu, id=1, text='Open')
save_item = wx.MenuItem(file_menu, id=2, text='Save')

file_menu.Append(open_item)
file_menu.Append(save_item)

open_item = file_menu.Append(1, 'Open')
save_item = file_menu.Append(2, 'Save')

file_menu.Bind(wx.EVT_MENU, self.open_fcn, open_item)
file_menu.Bind(wx.EVT_MENU, self.save_fcn, save_item)

def open_fcn(self, event):
    # Code to do something

def save_fcn(self, event):
    # Code to do something

open_item = file_menu.Append(1, '&Open\\tCtrl+O')

button = wx.Button(parent, id, label)

ok_button = wx.Button(panel, label='OK')
ok_button = wx.Button(panel, wx.ID_OK)

open_item = file_menu.Append(1, '&Open\\tCtrl+O')
save_item = file_menu.Append(2, '&Save\\tCtrl+S')

open_item = file_menu.Append(wx.ID_OPEN)
save_item = file_menu.Append(wx.ID_SAVE)

open_button = wx.Button(panel, wx.ID_OPEN)

file_menu.Bind(wx.EVT_MENU, self.save_fcn,
               save_item)

MY_ID = wx.NewIdRef()

file_menu.Append(MY_ID, self.my_fcn, 'Crevulate')
self.Bind(wx.EVT_MENU, self.my_fcn, id=MY_ID)

menu_item = file_menu.Append(wx.ID_ANY, 'Crevulate')
self.Bind(wx.EVT_MENU, self.my_fcn, menu_item)

menu.AppendSeparator()

submenu = wx.Menu()

item = submenu.Append(id, text)

menu.AppendSubMenu(submenu, text, help)

size_menu = wx.Menu()

size1 = size_menu.Append(wx.ID_ANY, "Small")
size2 = size_menu.Append(wx.ID_ANY, "Medium")
size3 = size_menu.Append(wx.ID_ANY, "Large")

edit_menu.AppendSubMenu(size_menu, "Font size")

size_menu.Bind(wx.EVT_MENU, self.change_size)

def change_size(self, event):
    menubar = self.frame.GetMenuBar()
    item = menubar.FindItemById(event.GetId())
    label = item.GetItemLabelText()
    print(label)

tipString = wx.ToolTip(tip) # tip is an ordinary string
widget.SetToolTip(tipString)

frame.CreateStatusBar()

menu_item = menu.Append(parentMenu, id, text,
                        helpString)

sizer.Add(widget/sizer)

sizer.Add(widget/sizer, proportion, flag, border)

gb_sizer.Add(widget/sizer, pos=wx.GBPosition(row, col))

gb_sizer.Add(widget/sizer, pos, span, flag, border)

sizer.Add(widget/sizer, proportion, flag, border)

sizer.Add(button, 0, wx.TOP | wx.LEFT, 12)

panel = wx.Panel(frame)
panel_sizer = wx.BoxSizer(orient=wx.HORIZONTAL)
panel.SetSizer(panel_sizer)

button = wx.Button(panel, label="Push Me")
sizer_1 = wx.BoxSizer(orient=wx.HORIZONTAL)
sizer_2 = wx.BoxSizer(orient=wx.HORIZONTAL)

sizer_1.Add(button, 0, wx.LEFT | wx.RIGHT, 40)
sizer_2.Add(sizer_1, 0, wx.TOP | wx.BOTTOM, 20)
panel_sizer.Add(sizer_2)

sizer.AddSpacer(size=pixels)

def spacers(self, widget, left, right, top, bottom):

    hbox = wx.BoxSizer(wx.HORIZONTAL)
    hbox.AddSpacer(left)
    hbox.Add(widget)
    hbox.AddSpacer(right)

    vbox = wx.BoxSizer(wx.VERTICAL)
    vbox.AddSpacer(top)
    vbox.Add(hbox)
    vbox.AddSpacer(bottom)

    return vbox # Note that this returns a sizer

panel = wx.Panel(frame)
button = wx.Button(panel3, label="Button")
sizer = self.add_spacers(button3, 10, 20, 30, 40)
panel3.SetSizer(sizer)

sizer.AddStretchSpacer(prop)

sizer.Add(window, proportion, flag, border)

sizer.AddGrowableRow(idx, proportion)

sizer.AddGrowableCol(idx, proportion)

edit_area = wx.TextCtrl(panel, style=wx.TE_MULTILINE)

sizer = wx.BoxSizer(orient=wx.HORIZONTAL)
panel.SetSizer(sizer)
sizer.Add(edit_area, 1, wx.EXPAND)

window.CentreOnScreen(direction)

screen = wx.Display(0)

geometry = screen.GetGeometry()
(w, h) = (geometry.GetWidth(), geometry.GetHeight())

rectangle = screen.GetClientArea()
(left, top, width, height) = rectangle

wx.GetTextFromUser(message, caption,
                         default_value='')

wx.GetPasswordFromUser(message, caption,
                             default_value='')

wx.GetNumberFromUser(message, prompt, caption, value, min=0, max=100)

wx.GetFontFromUser(parent, fontInit, caption)

wx.GetColourFromUser(parent, colInit, caption)

def get_yes_or_no(self, message):
    query = message.strip()
    if query[-1] != '?':
        query += '?'
    dlg = wx.MessageDialog(parent=None,
                           message=query,
                           style=wx.YES_NO)
    return dlg.ShowModal() == wx.ID_YES

dlg = wx.SomePredefinedDialog(parent, other_arguments)
if dlg.ShowModal() == wx.ID_OK:
    # Use dialog results
dlg.Destroy()

with wx.SomePredefinedDialog(parent,
                             other_arguments) as dlg:
    if dlg.ShowModal() == wx.ID_OK:
        # Use dialog results

dlg = wx.MessageDialog(parent, message, caption, style)

dlg = wx.MessageDialog(parent = frame,
                       message = 'This is the message',
                       caption = 'This is the caption')
result = dlg.ShowModal()

dlg = wx.TextEntryDialog(parent, message, caption,
                         value, style)

with wx.TextEntryDialog(parent = self.frame,
                        message = 'What is your name?',
                        caption = 'Caption',
                        value='Type here') as dlg:
    if dlg.ShowModal() == wx.ID_OK:
        print(dlg.GetValue())
    else:
        print('Dialog was cancelled.')

style = wx.TE_MULTILINE | wx.OK | wx.CANCEL

style = wx.TE_MULTILINE | wx.TextEntryDialogStyle

dlg = wx.PasswordEntryDialog(parent, message,
                             caption, defaultValue)

dlg = wx.NumberEntryDialog(parent, message, prompt,
                           caption, value, min, max)

if dlg.ShowModal() == wx.ID_OK:
    number = dlg.GetValue()

dlg = wx.FileDialog(parent, message)

wx.FileDialog(parent, message, style=wx.FD_MULTIPLE)

dialog = wx.FileDialog(self.frame, "Open Text File",
                       style=wx.FD_OPEN)
if dialog.ShowModal() == wx.ID_OK:
    pathname = dialog.GetPath()
    # Your code to read the file goes here
dialog.Destroy()

dialog = wx.FileDialog(None, "Save Text File",
                       style=wx.FD_SAVE)
if dialog.ShowModal() == wx.ID_OK:
    pathname = dialog.GetPath()
    # Your code to save the file goes here
dialog.Destroy()

with wx.DirDialog(frame,
                  message='Choose a directory') as dlg:
    if dlg.ShowModal() == wx.ID_OK:
        path = dlg.GetPath()

with wx.DirDialog(frame,
                  message='Choose directories:',
                  style=wx.DD_MULTIPLE) as dlg:
    if dlg.ShowModal() == wx.ID_OK:
        paths = dlg.GetPaths()

data = wx.FindReplaceData()
data.SetFindString('abc')
data.SetFlags(wx.FR_WHOLEWORD)

self.dlg = wx.FindReplaceDialog(parent, data=data,
                             style=wx.FR_REPLACEDIALOG)
self.dlg.Show()

self.frame.Bind(wx.EVT_FIND_CLOSE, self.on_find_close)

def on_find_close(self, event):
    self.dlg.Destroy()

dlg = wx.SingleChoiceDialog(parent, message,
                            caption, choices)

dlg = wx.MultiChoiceDialog(parent, message,
                           caption, choices)

dlg = FontDialog(parent)

dlg = FontDialog(parent, data)

with wx.FontDialog(parent) as dlg:
    if dlg.ShowModal() == wx.ID_OK:
        font = dlg.GetFontData().GetChosenFont()

wx.richtext.SymbolPickerDialog(symbol, initialFont, normalTextFont, parent)

from wx.richtext import SymbolPickerDialog

with SymbolPickerDialog('', '', '', self.frame) as dlg:
    if dlg.ShowModal() == wx.ID_OK:
        print(dlg.GetFontName(), dlg.GetSymbol())

data = wx.ColourData()
with wx.ColourDialog(parent, data) as dlg:
    if dlg.ShowModal() == wx.ID_OK:
        print(dlg.GetColourData().GetColour())

import wx.lib.colourchooser.pycolourchooser as pycc

def open_dialog(self, _evt):
    dlg = wx.Frame(self.frame)
    panel = pycc.PyColourChooser(dlg, id=-1)
    panel.Bind(pycc.EVT_COLOUR_CHANGED,
               self.on_colour_changed)
    dlg.Fit()
    dlg.Show()

def on_colour_changed(self, event):
    colour = event.GetColour()
    print(colour)

dlg = wx.MessageDialog(parent=self.frame,
                       message='Do you love me?',
                       caption='Valentine',
                       style = wx.YES_NO)

result = dlg.ShowModal()
answers = {wx.ID_YES: 'Yes', wx.ID_NO: 'No'}
print(answers[result])

class MyCustomDialog(wx.Dialog):
    def __init__(self, parent):
        super().__init__(parent, title="title")
        # Add widgets to self

def set_font_size(self, new_size):
    font = self.text_ctrl.GetFont()
    font.SetFractionalPointSize(new_size)
    self.text_ctrl.SetFont(font)

dlg = MyModalDialog(parent)
if dlg.ShowModal() == wx.ID_OK:
    print(dlg.result)
dlg.Destroy()

font = self.text_ctrl.GetFont()
font_size = font.GetFractionalPointSize()

dlg = FontSizeDialog(self.text_ctrl, font_size)
if dlg.ShowModal() == wx.ID_OK:
    self.set_font_size(dlg.result)
dlg.Destroy()

class FontSizeDialog(wx.Dialog):
    def __init__(self, parent, current_size):
        super().__init__(parent, title='Font Size')
        sizer = wx.BoxSizer(wx.VERTICAL)
        self.SetSizer(sizer)

        label = wx.StaticText(self,
                              label='Font size:')
        sizer.Add(label, flag=wx.ALL, border=5)
        
        self.slider = wx.Slider(
            self, value=int(current_size),
            minValue=8, maxValue=96,
            style=wx.SL_LABELS)
        sizer.Add(self.slider, flag=wx.ALL, border=5)

        ok_button = wx.Button(self, id=wx.ID_OK)
        sizer.Add(ok_button, flag=wx.ALL, border=5)
        ok_button.Bind(wx.EVT_BUTTON, self.ok)

        sizer.Fit(self)

    def ok(self, event):
        self.result = self.slider.GetValue()
        self.EndModal(wx.ID_OK)

import wx.lib.newevent

FontSizeChangedEvent, EVT_FONT_SIZE_CHANGED = (
            wx.lib.newevent.NewCommandEvent() )

self.dlg = None

button = wx.Button(panel, label='Set Font Size')
sizer.Add(button, flag=wx.ALL, border=5)
button.Bind(wx.EVT_BUTTON, self.nonmodal_font_size)

self.slider.Bind(wx.EVT_SLIDER, self.slider_changed)
self.Bind(wx.EVT_CLOSE, self.on_close)

def slider_changed(self, event):
    value = self.slider.GetValue()
    evt = FontSizeChangedEvent(self.GetId(),
                               value=value)
    wx.PostEvent(self, evt)

def on_close(self, event):
    self.Destroy()

def nonmodal_font_size(self, event):
    font = self.text_ctrl.GetFont()
    size = font.GetFractionalPointSize()

    if self.dlg is None:
        self.dlg = FontSizeNonModalDialog(self, size)
        
        self.dlg.Bind(EVT_FONT_SIZE_CHANGED,
                      self.on_font_change_event)
        self.dlg.Bind(wx.EVT_WINDOW_DESTROY,
                      self.on_dlg_destroyed)
        
        self.dlg.Show()
    else:
        self.dlg.Raise()

font = self.text_ctrl.GetFont()
font_size = font.GetFractionalPointSize()

def on_font_change_event(self, event):
    new_size = event.value
    self.set_font_size(new_size)

def on_dlg_destroyed(self, event):
    self.dlg = None
    event.Skip()

import wx, transformer_logic

class TransformerClass(wx.Frame):
    def __init__(self):
        super().__init__(None,
                         title='Identity Transformer',
                         size=(500, 600))

        transformers = list(
            transformer_logic.transformers.keys())

        # Create a frame and one panel
        panel = wx.Panel(self)
        control_panel = wx.Panel(panel)

        # Define widgets as instance variables

        self.input_area = wx.TextCtrl(
                panel, style = wx.TE_MULTILINE)

        self.output_area = wx.TextCtrl(
            panel, style = wx.TE_MULTILINE)
        
        transform_button = wx.Button(
            control_panel, label = 'Transform')

        self.chooser = wx.ComboBox(
            control_panel, choices = transformers)

        self.create_menus()
            
        # Use a sizer to arrange widgets in a panel

        sizer = wx.BoxSizer(orient = wx.VERTICAL)
        panel.SetSizer(sizer)

        sizer.Add(self.input_area, 1, wx.EXPAND)
        sizer.Add(self.output_area,with wx.FileDialog(None, "Save Text File" 1, wx.EXPAND)
        sizer.Add(control_panel)

        control_sizer = wx.BoxSizer(wx.HORIZONTAL)
        control_panel.SetSizer(control_sizer)
        
        control_sizer.Add(10, 0, 0)
        control_sizer.Add(self.chooser)
        control_sizer.Add(50, 0, 0)
        control_sizer.Add(transform_button)
        
        # Bind an action to the active widget
        
        transform_button.Bind(
            wx.EVT_BUTTON, self.transform)


    def create_menus(self):
        menubar = wx.MenuBar()
        self.SetMenuBar(menubar)

        file_menu = wx.Menu()
        menubar.Append(file_menu, "&File")

        open_item = file_menu.Append(wx.ID_OPEN,
                         "&Open original\\tCtrl+O")
        save_item = file_menu.Append(wx.ID_SAVE,
                         "&Save transformed\\tCtrl+S")

        self.Bind(wx.EVT_MENU, self.open_original,
                  open_item)
        self.Bind(wx.EVT_MENU, self.save_transformed,
                  save_item)


    def transform(self, _event):
        transformer = self.chooser.GetValue()
        lines = self.input_area.GetValue().splitlines()
        result = transformer_logic.transform(
            transformer, lines)

        if isinstance(result, list):
            self.output_area.SetValue(
                '\\n'.join(result))
        else:
            self.output_area.SetValue(
                self.chooser.GetValue() +
                ' function returned: ' +
                str(result))

        # Update window title
        self.SetTitle(f'{transformer} Transformer')

    def open_original(self, _event):
        style = wx.FD_OPEN | wx.FD_FILE_MUST_EXIST

        with wx.FileDialog(self, "Open Text File",
            style = style) as dialog:
            if dialog.ShowModal() == wx.ID_OK:
                pathname = dialog.GetPath()
                try:
                    with open(pathname, 'r') as file:
                        content = file.read()
                    self.input_area.SetValue(content)
                except Exception:
                    msg = 'Not a valid text file.'
                    wx.MessageDialog(self,
                                     msg).ShowModal()
   
    def save_transformed(self, _event):
        with wx.FileDialog(None, "Save Text File",
                           style=wx.FD_SAVE) as dialog:
            if dialog.ShowModal() == wx.ID_OK:
                pathname = dialog.GetPath()
                with open(pathname, 'w') as file:
                    content=self.output_area.GetValue()
                    file.write(content)

# Run the program
if __name__ == '__main__':
    app = wx.App()
    frame = TransformerClass()
    frame.Show()
    app.MainLoop()

def identity(lines):
    return lines

def reverse_lines(lines): # <- (translator, lines)
    reversed_lines = lines[:]
    for i in range(0, len(lines)):
        reversed_lines[i] = lines[i][::-1]
    return reversed_lines

def shuffle(lines):
    import random
    copy = lines[:]
    random.shuffle(copy)
    return copy

# There are two steps to adding a transformer:
# (1) Add a function above. It should take a list
#     of lines and return a list of lines.
# (2) Add display name and function name to the
#     following dictionary.
transformers = {
    'Identity': identity,
    'Reverse lines': reverse_lines,
    'Shuffle' : shuffle
    }

def transform(choice, lines):
    return transformers[choice](lines)

button.Bind(wx.EVT_BUTTON,self.print_button)

def print_button(self, event):
    print("The special button was clicked.")

def print_button(self, event):
    print("The special button was clicked.")
    event.Skip()

self.text_ctrl.Bind(wx.EVT_CHAR, self.handle_char)

def handle_char(self, event):
    kc = event.GetKeyCode()
    if ord('0') <= kc <= ord('9'):
        event.Skip()

self.text_ctrl.Bind(wx.EVT_TEXT_ENTER, self.do_enter)

def do_enter(self, event):
    value = self.text_ctrl.GetValue()
    if self.text_ctrl.GetValue().isdigit():
        print(f'Do something with {value}.')
    else:
        wx.Bell()
    event.Skip()

widget.Disable()

widget.Enable()

panel.Layout()
frame.Layout()
frame.Fit()

import wx

class GuiFrame(wx.Frame):

    def __init__(self):
        super().__init__(None, title='GuiFrame')
        # Populate this Frame as 'self'
        self.Show()

if __name__ == '__main__':
    app = wx.App()
    GuiFrame()
    app.MainLoop()

import wx

class GuiApp(wx.App):

    def __init__(self):
        super().__init__()
        # Do any needed initializations...

    def OnInit(self):
        frame = wx.Frame(None, title='GuiApp')
        # Populate the frame
        frame.Show()
        return True

if __name__ == '__main__':
    app = GuiApp()
    app.MainLoop()

import wx

class GuiClass:
    
    def __init__(self):
        frame = wx.Frame(None, title='Gui Class')
        # Populate the frame
        frame.Show()

if __name__ == '__main__':
    app = wx.App()
    GuiClass()
    app.MainLoop()

class Gui(wx.Frame):
    def __init__(self):
        super().__init__(None, title='Gui')
        # Gui code

class MainApplication(wx.App):
    def OnInit(self):
        self.gui = Gui()
        self.gui.Show()
        return True
    # Application code

if __name__ == '__main__':
    app = MainApplication()
    app.MainLoop()

book = wx.Listbook(parent) # or some other type

page = wx.Panel(book) # or some other window
book.AddPage(page, text='page name')

book.InsertSubPage(pagePos, page, text)

book.AddSubPage(page, text)

bmp = wx.ArtProvider.GetBitmap(icon, wx.ART_TOOLBAR,
                               size=(16, 16))

book.SetImages(list_of_bitmaps)

book.AddPage(page, text='page name', imageId=index)

for i in range(0, 10):
    button = wx.Button(panel, label=f'{i}')
    sizer.Add(button, border=5)
    button.Bind(wx.EVT_BUTTON, self.handle_event)

panel.Bind(wx.EVT_BUTTON, self.handle_event)

def handle_event(self, event):
    obj = event.GetEventObject()
    print('Button label =', obj.GetLabel())

labels = ['+', '-', '*', '/']

for i in range(0, 4):
    button = wx.Button(panel, label=labels[i])
    button.Bind(wx.EVT_BUTTON,
                lambda event, arg_1=i, arg_2=labels[i]:
                    self.do_btn(event, arg_1, arg_2))

def do_btn(self, event, arg_1, arg_2):
    print(f'{arg_1=}, {arg_2=}')

info = wx.FontInfo(24).FaceName("Helvetica").Bold()
font = wx.Font(info)

my_text = wx.StaticText(panel, label='Pay attention!')
my_text.SetFont(font)

font = widget.GetFont()

font.SetFaceName('Inconsolata')
font.SetPointSize(24)
font.SetWeight(wx.FONTWEIGHT_BOLD)
font.SetStyle(wx.FONTSTYLE_ITALIC)

font = widget.GetFont()
font.SetWeight(wx.FONTWEIGHT_BOLD)
widget.SetFont(font)

font.SetFamily(wx.FONTFAMILY_TELETYPE)
font.SetFaceName("Inconsolata")

desired_font = "BoogieWoogie"

enumerator = wx.FontEnumerator()
enumerator.EnumerateFacenames()
fonts = enumerator.GetFacenames()
if desired_font in fonts:
    font.SetFaceName(desired_font)

widget.SetBackgroundColour(colour)
widget.SetForegroundColour(colour)

file_menu.AppendSeparator()

BOLD = 101
ITALIC = 102

edit_menu.Append(wx.ID_ANY, "Bold", kind=wx.ITEM_CHECK)
check2 = wx.MenuItem(edit_menu, ITALIC, text="Italic",
                     kind=wx.ITEM_CHECK)
edit_menu.Append(check1)
edit_menu.Append(check2)

HIGH = 1000
MEDIUM = 999
LOW = 800

high = wx.MenuItem(security_menu, HIGH, "High",
                   kind=wx.ITEM_RADIO)
medium = wx.MenuItem(security_menu, MEDIUM, "Medium",
                   kind=wx.ITEM_RADIO)
low = wx.MenuItem(security_menu, LOW, "Low",
                   kind=wx.ITEM_RADIO)
security_menu.Append(high)
security_menu.Append(medium)
security_menu.Append(low)

menu_item.SetBitmap(bitmap)

img = wx.Image(path_to_file, wx.BITMAP_TYPE_PNG)
bmp = img.ConvertToBitmap()

bitmap = wx.ArtProvider.GetBitmap(
             id,
             client=wx.ART_OTHER,
             size=wx.DefaultSize)

text_ctrl = wx.TextCtrl(panel)

text_ctrl.SetHint(hint)

text = text_ctrl.GetValue()

text_ctrl = wx.TextCtrl(panel, style=wx.TE_MULTILINE)

text_ctrl = wx.TextCtrl(parent, style=style)

text_ctrl.SetFont(font)
text_ctrl.Refresh() # not usually necessary

location = text_ctrl.GetValue().find(string, start)

text_ctrl.SetSelection(start, end)

text_ctrl.Remove(start, end)
text_ctrl.WriteText(replacement)
text_ctrl.SetInsertionPoint(start + len(replacement))

text = text_ctrl.GetValue()
text_ctrl.SetValue(text)

text_ctrl.GetRange(start, end)

pos = text_ctrl.GetInsertionPoint()
text_ctrl.SetInsertionPoint(pos)

text_ctrl.SetInsertionPointEnd()

text = text_ctrl.GetValue()
pos = text.find(target, start) # -1 if not found

start, end.SetSelection(start, end)

text_ctrl.WriteText(text)

text_ctrl.AppendText(text)

text_ctrl.Remove(start, end)

text_ctrl.Replace(start, end, replacement)

text = text_ctrl.GetValue()
search_from = text_ctrl.GetInsertionPoint()

start = text.find(target, search_from)
end = start + len(target)
text_ctrl.Replace(start, end, replacement)

search_from = end

(start, end) = text_ctrl.GetSelection()

attr = wx.TextAttr()

text_ctrl.GetStyle(start, attr)

font = attr.GetFont()

font.SetFaceName('Impact')
font.MakeBold()
font.MakeItalic()
font.SetPointSize(24)

attr.SetFont(font)

text_ctrl.SetStyle(start, end, attr)

attr = wx.TextAttr()
attr.SetTextColour(wx.RED)
attr.SetBackgroundColour(wx.Colour(255, 255, 0))
text_ctrl.SetStyle(start, end, attr)

radio_button.SetValue(True)

levels = ['Low', 'Medium', 'High']
self.radio_box = wx.RadioBox(panel5,
                             label='Security Level',
                             choices=levels,
                             style=wx.RA_SPECIFY_ROWS)
sizer5.Add(self.radio_box, flag=wx.ALL, border=5)

boolean = radio_button.GetValue()

radio_button = self.radio_box.GetStringSelection()

self.radio_button.Bind(wx.EVT_RADIOBUTTON, self.do_btn)

self.radio_box.Bind(wx.EVT_RADIOBOX, self.do_box)

self.slider = wx.Slider(panel,
                        id = wx.ID_ANY, value = 50,
                        minValue = 0, maxValue = 100,
                        size = wx.Size(width, height),
                        style = wx.SL_HORIZONTAL)

self.slider.Bind(wx.EVT_SLIDER, handler)

gauge = wx.Gauge(panel, id = wx.ID_ANY, range = 100,
                 size = wx.Size(width, height),
                 style = wx.GA_HORIZONTAL)

spin = wx.SpinCtrl(panel, id = wx.ID_ANY,
                   min = 0, max = 100, initial = value)

spin.Bind(wx.EVT_SPINCTRL, handler)

self.tree = wx.TreeCtrl(panel)
root = self.tree.AddRoot("Name of root")

item = self.tree.AppendItem(root, 'Item name')

subitem = self.tree.AppendItem(item, 'Subitem name')

self.tree.Bind(wx.EVT_TREE_SEL_CHANGED, handler)

select = self.tree.GetSelection()
text = self.tree.GetItemText(select)

view = wx.ListView(parent)

view.AppendColumn(col, heading, width=width)

view.Append(entry)

view.Bind(wx.EVT_LIST_ITEM_SELECTED, handler)

def function(self, event):
     print(event.GetIndex(), event.GetText())

self.view = wx.ListView(panel)

self.view.AppendColumn("Planet", width=150)
self.view.AppendColumn("Mass", width=80)
self.view.AppendColumn("Distance (AU)",
                       width=120)

self.view.Append(["Venus", "0.815", "0.72"])
self.view.Append(["Earth", "1.00", "1.00"])
self.view.Append(["Mars", "0.1075", "1.52"])

import wx.grid

grid = wx.grid.Grid(parent)
grid.CreateGrid(numRows, numCols)

sizer.Add(self.grid, 1, wx.EXPAND | wx.ALL, 5)

grid.Bind(wx.grid.EVT_GRID_CELL_CHANGED, handler)

splitter = wx.SplitterWindow(parent)

left = wx.Panel(splitter)
right = wx.Panel(splitter)

splitter.SplitVertically(left, right)
splitter.SetSashGravity(0.5)

parent_sizer.Add(splitter, 1, wx.EXPAND | wx.ALL)