Python als Ersatz für Classic Visual Basic

pacman -Suy
pacman -S mingw-w64-x86_64-gtk3 mingw-w64-x86_64-python3-gobject

python3 test.py

import gi
gi.require_version('Gtk', '3.0')
from gi.repository import Gtk

class MainWindow(Gtk.Window):
    def __init__(self):
        Gtk.Window.__init__(self, title="Hello World from Python+GTK")
        
        # Create button.
        self.hello_world_button = Gtk.Button(label="Say “Hello World”")
        self.hello_world_button.connect(
            'clicked',
            self.on_hello_world_button_clicked
        )
        self.add(self.hello_world_button)
    
    # Event handler called when the button gets clicked.
    def on_hello_world_button_clicked(self, widget):
        info_dialog = Gtk.MessageDialog(
            self, 
            Gtk.DialogFlags.MODAL,
            Gtk.MessageType.INFO,
            Gtk.ButtonsType.CLOSE,
            "Hello World!"
        )
        info_dialog.run()
        info_dialog.destroy()

main_window = MainWindow()
main_window.connect('destroy', Gtk.main_quit)
main_window.show_all()
Gtk.main()

import gi
gi.require_version('Gtk', '3.0')
from gi.repository import Gtk

class MainWindow(Gtk.Window):
    def __init__(self):
        Gtk.Window.__init__(self, title="Drawing Window")
    
    def do_draw(self, cr):
        
        # Print to the console when the window gets drawn.
        print('do_draw')
        
        # Fill background in blue.
        cr.set_source_rgba(0, 0, 255)
        cr.paint()
        
        # Draw diagonal line from top left to bottom right.
        allocation = self.get_allocation()
        cr.set_source_rgba(255, 0, 0);
        cr.set_line_width(3)
        cr.move_to(0, 0)
        cr.line_to(allocation.width, allocation.height)
        cr.stroke()

win = MainWindow()
win.connect('destroy', Gtk.main_quit)
win.show_all()
Gtk.main()

<?xml version="1.0" encoding="UTF-8"?>
<!-- Generated with glade 3.22.1 -->
<interface>
  <requires lib="gtk+" version="3.20"/>
  <object class="GtkWindow" id="MainWindow">
    <property name="can_focus">False</property>
    <property name="title" translatable="yes">Glade Greeter</property>
    <signal name="destroy" handler="on_destroy" swapped="no"/>
    <child>
      <placeholder/>
    </child>
    <child>
      <object class="GtkBox">
        <property name="visible">True</property>
        <property name="can_focus">False</property>
        <property name="margin_left">6</property>
        <property name="margin_right">6</property>
        <property name="margin_top">6</property>
        <property name="margin_bottom">6</property>
        <property name="orientation">vertical</property>
        <property name="spacing">6</property>
        <child>
          <object class="GtkLabel">
            <property name="visible">True</property>
            <property name="can_focus">False</property>
            <property name="halign">start</property>
            <property name="label" translatable="yes">
              Select a name and press the button to greet the person.
            </property>
          </object>
          <packing>
            <property name="expand">False</property>
            <property name="fill">True</property>
            <property name="position">0</property>
          </packing>
        </child>
        <child>
          <object class="GtkSearchEntry" id="names_filter_searchentry">
            <property name="visible">True</property>
            <property name="can_focus">True</property>
            <property name="primary_icon_name">edit-find-symbolic</property>
            <property name="primary_icon_activatable">False</property>
            <property name="primary_icon_sensitive">False</property>
            <signal
              name="search-changed"
              handler="on_names_filter_searchentry_changed"
              swapped="no"
            />
          </object>
          <packing>
            <property name="expand">False</property>
            <property name="fill">True</property>
            <property name="position">1</property>
          </packing>
        </child>
        <child>
          <object class="GtkTreeView" id="names_treeview">
            <property name="visible">True</property>
            <property name="can_focus">True</property>
            <property name="headers_visible">False</property>
            <property name="headers_clickable">False</property>
            <property name="enable_search">False</property>
            <child internal-child="selection">
              <object class="GtkTreeSelection"/>
            </child>
          </object>
          <packing>
            <property name="expand">True</property>
            <property name="fill">True</property>
            <property name="position">2</property>
          </packing>
        </child>
        <child>
          <object class="GtkButton" id="greet_button">
            <property name="label" translatable="yes">_Greet</property>
            <property name="visible">True</property>
            <property name="can_focus">True</property>
            <property name="receives_default">True</property>
            <property name="halign">center</property>
            <property name="use_underline">True</property>
            <signal
              name="clicked"
              handler="on_greet_button_clicked"
              swapped="no"
            />
          </object>
          <packing>
            <property name="expand">False</property>
            <property name="fill">True</property>
            <property name="position">3</property>
          </packing>
        </child>
      </object>
    </child>
  </object>
</interface>

import gi
gi.require_version('Gtk', '3.0')
from gi.repository import Gtk

class MainWindow:
    def __init__(self):
        
        # Load window from file.
        builder = Gtk.Builder()
        builder.add_from_file('MainWindow.glade')
        
        # Names treeview.
        self.names_treeview = builder.get_object('names_treeview')
        
        # Add a text column.
        cellrenderer = Gtk.CellRendererText()
        name_column = Gtk.TreeViewColumn("Name", cellrenderer, text=0)
        name_column.set_sort_column_id(0)
        self.names_treeview.append_column(name_column)
        
        # Add some names.
        model = Gtk.ListStore(str)
        model.append(["Benjamin"])
        model.append(["Charles"])
        model.append(["alfred"])
        model.append(["Alfred"])
        model.append(["David"])
        model.append(["charles"])
        model.append(["david"])
        model.append(["benjamin"])
        
        # Create filter.
        self.names_filter = model.filter_new()
        self.names_treeview.set_model(self.names_filter)
        self.current_names_filter = ""
        self.names_filter.set_visible_func(self.names_filter_func)
        
        # Connect signal handlers.
        builder.connect_signals(self)
        
        # Expose the GTK window object.
        self.window = builder.get_object('MainWindow')
    
    def on_destroy(self, *args):
        Gtk.main_quit()
    
    def on_greet_button_clicked(self, button):
        names_selection = self.names_treeview.get_selection()
        (tm, ti) = names_selection.get_selected()
        if ti is None:
            warning_dialog = Gtk.MessageDialog(
                self.window,
                Gtk.DialogFlags.MODAL,
                Gtk.MessageType.WARNING,
                Gtk.ButtonsType.CLOSE,
                "Please select a name."
            )
            warning_dialog.run()
            warning_dialog.destroy()
            return
        selected_name = tm.get_value(ti, 0)
        info_dialog = Gtk.MessageDialog(
            self.window,
            Gtk.DialogFlags.MODAL,
            Gtk.MessageType.INFO,
            Gtk.ButtonsType.CLOSE,
            "Hello " + selected_name + "!"
        )
        info_dialog.run()
        info_dialog.destroy()
    
    # Update the filter for the names treeview when the content of the
    # search textbox changes.
    def on_names_filter_searchentry_changed(self, edit):
        self.current_names_filter = edit.get_text()
        self.names_filter.refilter()
    
    # Filter data in the names treeview.
    def names_filter_func(self, model, iter, data):
        
        # No filter set.
        if (
            self.current_names_filter is None or
            self.current_names_filter == ""
        ):
            return True
        
        # Check if the item should be shown.
        return model[iter][0].lower().startswith(
            self.current_names_filter.lower()
        )

win = MainWindow().window
win.show_all()
Gtk.main()

sudo apt install python3-opengl

sudo apt install python3-numpy

# Sample losely based on:
# http://www.opengl-tutorial.org/beginners-tutorials/tutorial-2-the-first-triangle/

import gi
gi.require_version('Gtk', '3.0')
from gi.repository import Gtk
from OpenGL.GL import *
from OpenGL.GL import shaders
import numpy as np

FRAGMENT_SHADER_SOURCE = '''\
#version 330
out vec3 color;
void main() {
  color = vec3(1.0, 0.0, 0.0);   // Constant red.
}'''

VERTEX_SHADER_SOURCE = '''\
#version 330
in vec4 position;
void main() {
  gl_Position = position;
}'''

class TestGLArea(Gtk.GLArea):
    def __init__(self):
        Gtk.GLArea.__init__(self)
        self.connect('realize', self.on_realize)
        self.connect('render', self.on_render)
    
    # The `realize` signal is emitted when the widget is added to a window.
    def on_realize(self, area):
        ctx = self.get_context()
        ctx.make_current()
        err = self.get_error()
        if err:
            print("Error occurred: {}".format(err))
            Gtk.main_quit()
        
        # Create shader programs.
        vertex_shader_program = shaders.compileShader(
            VERTEX_SHADER_SOURCE, GL_VERTEX_SHADER
        )
        fragment_shader_program = shaders.compileShader(
            FRAGMENT_SHADER_SOURCE, GL_FRAGMENT_SHADER
        )
        self.shader_program = shaders.compileProgram(
            vertex_shader_program, fragment_shader_program
        )
        
        # Create Vertex Array Object (VAO).
        self.create_object()
    
    # Creates the VAO.
    def create_object(self):
        
        # Create a new VAO and bind it.
        vertex_array_object = glGenVertexArrays(1)
        glBindVertexArray(vertex_array_object)
        
        # Generate buffers to hold our vertices.
        vertex_buffer = glGenBuffers(1)
        glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer)
        
        # Get the position of the `position` in parameter of our shader and bind
        # it.
        position = glGetAttribLocation(self.shader_program, 'position')
        glEnableVertexAttribArray(position)
        
        # Describe the position data layout in the buffer.
        # 3 elements per vertex of type float.
        glVertexAttribPointer(
            position, 3, GL_FLOAT, False, 0, ctypes.c_void_p(0)
        )
        
        # Send the vertex data over to the buffer.  We define only one triangle.
        # Currently lists cannot yet be passed to `glBufferData` directly, thus
        # we have to use a NumPy array.
        vertices = np.array(
            [
                -0.6, -0.6, 0.0,
                 0.0,  0.6, 0.0,
                 0.6, -0.6, 0.0
            ],
            dtype=np.float32
        )
        
        # The second parameter of `glBufferData` expects the size of the array
        # buffer in bytes.
        glBufferData(GL_ARRAY_BUFFER, 36, vertices, GL_STATIC_DRAW)
        
        # Unbind the VAO and other stuff.
        glBindVertexArray(0)
        glDisableVertexAttribArray(position)
        glBindBuffer(GL_ARRAY_BUFFER, 0)
        
        self.vob = vertex_array_object
    
    # `render` signal is emitted when the GLArea is ready to draw its content.
    def on_render(self, area, ctx):
        
        # Fill background in blue.
        glClearColor(0, 0, 1, 1)
        glClear(GL_COLOR_BUFFER_BIT)
        
        # Draw rectangle filled in red.
        glUseProgram(self.shader_program)
        glBindVertexArray(self.vob)
        
        # Draw triangle, start index in position data, count of array elements.
        glDrawArrays(GL_TRIANGLES, 0, 3)
        
        glBindVertexArray(0)
        glUseProgram(0)

class MainWindow(Gtk.Window):
    def __init__(self):
        Gtk.Window.__init__(self, title="OpenGL Triangle Demo")
        self.set_default_size(800, 600)
        glarea = TestGLArea()
        self.add(glarea)

win = MainWindow()
win.connect('destroy', Gtk.main_quit)
win.show_all()
Gtk.main()

import gi
gi.require_version('Gtk', '3.0')
from gi.repository import GLib, Gtk

def timer_tick(*args):
    print("Timer fired.")
    return True

# Make the timer fire every 1200 ms.
GLib.timeout_add(1200, timer_tick)

# Run main loop.
Gtk.main()

sudo apt install g++
sudo apt install python3-dev
sudo apt install python3-pip
sudo apt install python3-setuptools
sudo pip3 install wxPython

pip3 install wxPython --user

import wx

class MainFrame(wx.Frame):
    def __init__(self, parent, title):
        super(MainFrame, self).__init__(parent, title=title)
        
        self.panel = wx.Panel(self)
        
        # Add a vertical box with two rows:
        # First row: Horizontal box containing the name textbox label and the
        #    name textbox.
        # Second row: "Greet" button centered horizontally.
        vbox = wx.BoxSizer(wx.VERTICAL)
        hbox = wx.BoxSizer(wx.HORIZONTAL)
        
        # Name textbox label.
        self.info_static = wx.StaticText(
            self.panel,
            wx.ID_ANY,
            "Your &name:"
        ) 
        hbox.Add(
            self.info_static,
            0,
            wx.ALIGN_CENTER_VERTICAL | wx.ALIGN_LEFT | wx.RIGHT,
            border=10
        )
        
        # Name textbox.
        self.name_textbox = wx.TextCtrl(self.panel)
        hbox.Add(
            self.name_textbox,
            1,
            wx.EXPAND | wx.ALIGN_LEFT
        )
        
        vbox.Add(
            hbox,
            0,
            wx.ALIGN_CENTER_VERTICAL | wx.EXPAND | wx.ALL,
            border=10
        )
        
        # Greet button.
        self.greet_button = wx.Button(
            self.panel,
            wx.ID_OK,
            "&Greet",
        )
        self.greet_button.SetDefault()
        self.greet_button.Bind(
            wx.EVT_BUTTON,
            self.on_greet_button_clicked
        )
        vbox.Add(
            self.greet_button,
            0,
            wx.CENTER | wx.BOTTOM,
            border=10
        )
        
        self.panel.SetSizer(vbox)
        
        self.Show()
    
    def on_greet_button_clicked(self, event):
        wx.MessageBox(
            message="Hello " + self.name_textbox.GetValue() + "!",
            caption="Welcome!",
            style=wx.OK | wx.ICON_INFORMATION
        )

app = wx.App(False)
frame = MainFrame(None, "Greeter")
app.MainLoop()

# More information:
# https://wiki.wxpython.org/DoubleBufferedDrawing
# https://wiki.wxpython.org/BufferedCanvas

import random
import wx

class MainFrame(wx.Frame):
    _buffer = None
    
    def __init__(self):
        super().__init__(
            None,
            wx.ID_ANY,
            "wxPython Confetti",
            style=wx.DEFAULT_FRAME_STYLE | wx.NO_FULL_REPAINT_ON_RESIZE,
            size=(600, 400)
        )
        
        # Recommended when `BufferedPaintDC` is used on `EVT_PAINT`.
        # https://wxpython.org/Phoenix/docs/html/wx.BufferedPaintDC.html
        self.SetBackgroundStyle(wx.BG_STYLE_PAINT)
        
        self.Bind(wx.EVT_PAINT, self.on_paint)
        self.Bind(wx.EVT_SIZE, self.on_size)
        
        self.create_new_buffer()
        
        self.timer = wx.Timer(self)
        self.Bind(wx.EVT_TIMER, self.on_timer, self.timer)
        self.timer.Start(10)
    
    # Blit buffer to the screen.
    def on_paint(self, event):
        
        # `BufferedPaintDC` copies its content to the screen before it gets
        # deleted.
        dc = wx.BufferedPaintDC(self, self._buffer)
    
    # Create a new buffer and blit it to the screen.
    def on_size(self, event):
        self.create_new_buffer()
        self.update()
    
    # Add a new confetti.
    def on_timer(self, event):
        self.draw_confetti()
        self.update()
    
    # Update screen from buffer. 
    def update(self):
        self.Refresh(eraseBackground=False)
    
    # Create a new buffer according to the client size and fill it with a random
    # color.
    def create_new_buffer(self):
        width, height = self.ClientSize
        self._buffer = wx.Bitmap(
            width if width > 0 else 1,
            height if height > 0 else 1
        )
        dc = wx.MemoryDC()
        dc.SelectObject(self._buffer)
        dc.SetBackground(wx.Brush(self.random_color()))
        dc.Clear()
    
    # Draw a new confetti with random position, size, and color on the buffer.
    # TODO:  Handle client size (0, 0).
    def draw_confetti(self):
        width, height = self.ClientSize
        confetti_max_size = int(min(width, height) * .2)
        posx = random.randint(
            -confetti_max_size,
            width + confetti_max_size - 1
        )
        posy = random.randint(
            -confetti_max_size,
            height + confetti_max_size - 1
        )
        confetti_size = random.randint(
            int(confetti_max_size * .5),
            confetti_max_size
        )
        
        dc = wx.MemoryDC()
        dc.SelectObject(self._buffer)
        
        # We use a `GraphicsContext` to draw onto the bitmap because it supports
        # anti-aliasing even on Windows.
        # TODO:  Handle the case where the creation of the `GraphicsContext`
        # fails because it is not supported by the OS. 
        gc = wx.GraphicsContext.Create(dc)
        gc.SetBrush(wx.Brush(self.random_color()))
        gc.DrawEllipse(posx, posy, confetti_size, confetti_size)
        
        # The memory DC must be deleted before we call `Refresh` or the system
        # requests repaint of the window; this is done automatically here
        # because the variable goes out of scope.  Otherwise we would have to
        # use `del dc` or `dc.SelectObject(wx.NullBitmap)`.
    
    # Returns a random pastel color.
    def random_color(self):
        return wx.Colour(
            random.randint(100, 255),
            random.randint(100, 255),
            random.randint(100, 255)
        )

if __name__ == '__main__':
    app = wx.App(False)
    frame = MainFrame()
    frame.Show()
    app.MainLoop()

sudo apt install wxglade

<?xml version="1.0"?>
<!-- generated by wxGlade 0.8.0 on … -->

<application encoding="UTF-8" for_version="3.0" header_extension=".h" indent_amount="4" indent_symbol="space" is_template="0" language="python" option="0" overwrite="1" path="./gui.py" source_extension=".cpp" top_window="frame" use_gettext="0" use_new_namespace="1">
    <object class="MainFrame" name="frame" base="EditFrame">
        <title>wxGlade Greeter</title>
        <style>wxCAPTION|wxMINIMIZE_BOX|wxCLOSE_BOX|wxSYSTEM_MENU|wxCLIP_CHILDREN</style>
        <object class="wxBoxSizer" name="sizer_1" base="EditBoxSizer">
            <orient>wxVERTICAL</orient>
            <object class="sizeritem">
                <option>0</option>
                <border>10</border>
                <flag>wxLEFT|wxRIGHT|wxTOP</flag>
                <object class="wxStaticText" name="label_1" base="EditStaticText">
                    <label>Enter a &amp;name:</label>
                </object>
            </object>
            <object class="sizeritem">
                <option>0</option>
                <border>10</border>
                <flag>wxALL|wxEXPAND</flag>
                <object class="wxTextCtrl" name="name_textbox" base="EditTextCtrl">
                    <size>300, -1</size>
                </object>
            </object>
            <object class="sizeritem">
                <option>0</option>
                <border>10</border>
                <flag>wxALL|wxALIGN_CENTER</flag>
                <object class="wxButton" name="greet_button" base="EditButton">
                    <events>
                        <handler event="EVT_BUTTON">on_greet_button_clicked</handler>
                    </events>
                    <label>&amp;Greet</label>
                    <default>1</default>
                </object>
            </object>
        </object>
    </object>
</application>

# -*- coding: UTF-8 -*-
#
# generated by wxGlade 0.8.0 on …
#

import wx

# begin wxGlade: dependencies
# end wxGlade

# begin wxGlade: extracode
# end wxGlade


class MainFrame(wx.Frame):
    def __init__(self, *args, **kwds):
        # begin wxGlade: MainFrame.__init__
        kwds["style"] = kwds.get("style", 0) | wx.CAPTION | wx.CLIP_CHILDREN | wx.CLOSE_BOX | wx.MINIMIZE_BOX | wx.SYSTEM_MENU
        wx.Frame.__init__(self, *args, **kwds)
        self.name_textbox = wx.TextCtrl(self, wx.ID_ANY, "")
        self.greet_button = wx.Button(self, wx.ID_ANY, "&Greet")

        self.__set_properties()
        self.__do_layout()

        self.Bind(wx.EVT_BUTTON, self.on_greet_button_clicked, self.greet_button)
        # end wxGlade

    def __set_properties(self):
        # begin wxGlade: MainFrame.__set_properties
        self.SetTitle("wxGlade Greeter")
        self.name_textbox.SetMinSize((300, -1))
        self.greet_button.SetDefault()
        # end wxGlade

    def __do_layout(self):
        # begin wxGlade: MainFrame.__do_layout
        sizer_1 = wx.BoxSizer(wx.VERTICAL)
        label_1 = wx.StaticText(self, wx.ID_ANY, "Enter a &name:")
        sizer_1.Add(label_1, 0, wx.LEFT | wx.RIGHT | wx.TOP, 10)
        sizer_1.Add(self.name_textbox, 0, wx.ALL | wx.EXPAND, 10)
        sizer_1.Add(self.greet_button, 0, wx.ALIGN_CENTER | wx.ALL, 10)
        self.SetSizer(sizer_1)
        sizer_1.Fit(self)
        self.Layout()
        # end wxGlade

    def on_greet_button_clicked(self, event):  # wxGlade: MainFrame.<event_handler>
        print("Event handler 'on_greet_button_clicked' not implemented!")
        event.Skip()

# end of class MainFrame

import wx

# Import `gui.py` generated by wxGlade.
import gui

class MainFrame(gui.MainFrame):
    def __init__(self, *args, **kwds):
        gui.MainFrame.__init__(self, *args, **kwds)
    
    def on_greet_button_clicked(self, event):
        wx.MessageBox(
            message="Hello " + self.name_textbox.GetValue() + "!",
            caption="Welcome!",
            style=wx.OK | wx.ICON_INFORMATION
        )

class GreeterApp(wx.App):
    def OnInit(self):
        self.frame = MainFrame(None)
        self.frame.Show()
        return True

if __name__ == '__main__':
    app = GreeterApp(False)
    app.MainLoop()

<?xml version="1.0"?>
<application encoding="UTF-8" for_version="3.0" header_extension=".h" indent_amount="4" indent_symbol="space" is_template="0" language="XRC" option="0" overwrite="1" path="./gui.xrc" source_extension=".cpp" top_window="frame" use_gettext="0" use_new_namespace="1">
    <object class="xrcgreeter.MainFrame" name="frame" base="EditFrame">
        <title>wxGlade Greeter</title>
        <style>wxCAPTION|wxMINIMIZE_BOX|wxCLOSE_BOX|wxSYSTEM_MENU|wxCLIP_CHILDREN</style>
        <object class="wxBoxSizer" name="sizer_1" base="EditBoxSizer">
            <orient>wxVERTICAL</orient>
            <object class="sizeritem">
                <option>0</option>
                <border>10</border>
                <flag>wxLEFT|wxRIGHT|wxTOP</flag>
                <object class="wxStaticText" name="label_1" base="EditStaticText">
                    <label>Enter a &amp;name:</label>
                </object>
            </object>
            <object class="sizeritem">
                <option>0</option>
                <border>10</border>
                <flag>wxALL|wxEXPAND</flag>
                <object class="wxTextCtrl" name="name_textbox" base="EditTextCtrl">
                    <size>300, -1</size>
                </object>
            </object>
            <object class="sizeritem">
                <option>0</option>
                <border>10</border>
                <flag>wxALL|wxALIGN_CENTER</flag>
                <object class="wxButton" name="greet_button" base="EditButton">
                    <events>
                        <handler event="EVT_BUTTON">on_greet_button_clicked</handler>
                    </events>
                    <label>&amp;Greet</label>
                    <default>1</default>
                </object>
            </object>
        </object>
    </object>
</application>

<?xml version="1.0" encoding="UTF-8"?>
<resource version="2.3.0.1">
    <object class="wxFrame" name="frame" subclass="xrcgreeter.MainFrame">
        <style>wxCAPTION|wxCLIP_CHILDREN|wxCLOSE_BOX|wxMINIMIZE_BOX|wxSYSTEM_MENU</style>
        <title>wxGlade Greeter</title>
        <object class="wxBoxSizer">
            <orient>wxVERTICAL</orient>
            <object class="sizeritem">
                <flag>wxLEFT|wxRIGHT|wxTOP</flag>
                <border>10</border>
                <object class="wxStaticText" name="label_1">
                    <label>Enter a &amp;name:</label>
                </object>
            </object>
            <object class="sizeritem">
                <flag>wxALL|wxEXPAND</flag>
                <border>10</border>
                <object class="wxTextCtrl" name="name_textbox">
                    <size>300, -1</size>
                </object>
            </object>
            <object class="sizeritem">
                <flag>wxALIGN_CENTER|wxALL</flag>
                <border>10</border>
                <object class="wxButton" name="greet_button">
                    <handler event="EVT_BUTTON">on_greet_button_clicked</handler>
                    <default>1</default>
                    <label>_Greet</label>
                </object>
            </object>
        </object>
    </object>
</resource>

import wx
from wx import xrc

class MainFrame(wx.Frame):
    def __init__(self):
        super().__init__()
        
        # We cannot access XRC content and bind event handlers here because the
        # window has not yet been created.  Therefore we handle the appropriate
        # event and perform initialization there.
        self.Bind(wx.EVT_WINDOW_CREATE, self.on_create)
    
    def on_create(self, event):
        self.Unbind(wx.EVT_WINDOW_CREATE)
        wx.CallAfter(self.post_init)
        event.Skip()
        return True
    
    def post_init(self):
        self.name_textbox = xrc.XRCCTRL(self, 'name_textbox')
        
        self.Bind(
            wx.EVT_BUTTON,
            self.on_greet_button_clicked,
            id=xrc.XRCID('greet_button')
        )
        
        # Alternative:
        #self.greet_button = xrc.XRCCTRL(self.wxframe, 'greet_button')
        #self.Bind(
        #    wx.EVT_BUTTON,
        #    self.on_greet_button_clicked,
        #    self.greet_button
        #)
    
    def on_greet_button_clicked(self, event):
        wx.MessageBox(
            message="Hello " + self.name_textbox.GetValue() + "!",
            caption="Welcome!",
            style=wx.OK | wx.ICON_INFORMATION
        )

class GreeterApp(wx.App):
    def OnInit(self):
        res = xrc.XmlResource('gui.xrc')
        frame = res.LoadFrame(None, 'frame')
        frame.Show()
        return True

if __name__ == '__main__':
    app = GreeterApp(False)
    app.MainLoop()

self.Bind(
    wx.EVT_BUTTON,
    self.on_greet_button_clicked,
    id=xrc.XRCID('greet_button')
)

import wx

class MainFrame(wx.Frame):
    def __init__(self, parent):
        wx.Frame.__init__(self, parent, wx.ID_ANY, "wx.Timer Demo")
        
        self.SetBackgroundColour(wx.RED) 
        
        self.timer = wx.Timer(self)
        self.Bind(wx.EVT_TIMER, self.on_timer, self.timer)
        self.timer.Start(800)
        
        self.Show()
    
    def on_timer(self, event):
        if self.GetBackgroundColour() == wx.RED:
            self.SetBackgroundColour(wx.BLUE)
        else:
            self.SetBackgroundColour(wx.RED)

app = wx.App(False)
frame = MainFrame(None)
app.MainLoop()

sudo apt install python3-tk

from tkinter import Button, Label, messagebox, Tk

class MainWindow:
    def __init__(self, master):
        self.master = master
        master.title("Tkinter Demo")
        master.geometry('320x160')
        
        pad = 10
        
        self.label = Label(
            master,
            text="Click the button to say \"Hello World!\""
        )
        self.label.pack(
            expand=True,
            padx=pad,
            pady=pad
        )
        
        self.greet_button = Button(
            master,
            text="Greet",
            command=self.on_greet_button_clicked
        )
        self.greet_button.pack(
            side='bottom',
            padx=pad,
            pady=pad,
            ipadx=pad * 1.5
        )
    
    def on_greet_button_clicked(self):
        messagebox.showinfo("Welcome", "Hello World!")

root = Tk()
win = MainWindow(root)
root.mainloop()

from tkinter import messagebox, Tk
from tkinter.ttk import Button, Label, Style

class MainWindow:
    def __init__(self, master):
        self.master = master
        master.title("Tkinter Demo")
        master.geometry('320x160')
        
        pad = 10
        
        self.label = Label(
            master,
            text="Click the button to say \"Hello World!\""
        )
        self.label.pack(
            expand=True,
            padx=pad,
            pady=pad
        )
        
        self.greet_button = Button(
            master,
            text="Greet",
            command=self.on_greet_button_clicked
        )
        self.greet_button.pack(
            side='bottom',
            padx=pad,
            pady=pad,
            ipadx=pad * 1.5
        )
    
    def on_greet_button_clicked(self):
        messagebox.showinfo("Welcome", "Hello World!")

root = Tk()

style = Style()
if 'vista' in style.theme_names():
    style.theme_use('vista')

win = MainWindow(root)
root.mainloop()

from tkinter import Tk, Canvas

main_window = Tk()
main_window.title("Tkinter Canvas Demo")
main_window.geometry('800x600')
canvas = Canvas(
    main_window,
    bg='blue',
    width=770,
    height=580,
    bd=10,
    relief='groove'
)
canvas.pack()
arc = canvas.create_arc(
    50, 50, 400, 400, start=0, extent=300, fill='red'
)
line = canvas.create_line(
    25, 25, 770, 580, width=2, fill='white'
)
oval = canvas.create_oval(
    500, 100, 700, 400, fill='yellow'
)
main_window.mainloop()

# Inspired by https://docs.python.org/2/library/sqlite3.html

import sqlite3

# Connect to database.
conn = sqlite3.connect('stocks.db')
c = conn.cursor()

# Create table.
c.execute('''
    CREATE TABLE stocks(
        date text, trans text, symbol text, qty real, price real
    )'''
)

# Insert a row of data.
c.execute(
    'INSERT INTO stocks VALUES (?, ?, ?, ?, ?)',
    ('2006-01-05', 'BUY', 'RHAT', 100, 35.14)
)

# Insert multiple rows of data at a time.
purchases = [
    ('2006-03-28', 'BUY', 'IBM', 1000, 45.00),
    ('2006-04-05', 'BUY', 'MSFT', 1000, 72.00),
    ('2006-04-06', 'SELL', 'IBM', 500, 53.00)
]
c.executemany('INSERT INTO stocks VALUES (?, ?, ?, ?, ?)', purchases)

# Select a single row based on the value of a certain column.
symbol = ('MSFT',)   # Tuple with just one element.
c.execute('SELECT * FROM stocks WHERE symbol = ?', symbol)
row = c.fetchone()
if row is None:
    print("No row for symbol 'MSFT' found.")
else:
    print(row)

# Print all rows.
for row in c.execute('SELECT * FROM stocks ORDER BY price'):
    print(row)

# Persist changes.
conn.commit()

# Close connection.
conn.close()

sudo apt install sqlitebrowser

import cairo

height = 600
width =  800

surface = cairo.PDFSurface('sample.pdf', width, height)
context = cairo.Context(ps)

# Fill background in blue.
context.set_source_rgba(0, 0, 255)
context.paint()

# Draw diagonal line from top left to bottom right.
context.set_source_rgba(255, 0, 0);
context.set_line_width(3)
context.move_to(0, 0)
context.line_to(width, height)
context.stroke()

surface.show_page()