Since many days I was looking for simple text editor program using wxPython and didn't get to find anywhere but finally I found here. This is really a great thread to get information regarding to wxPython.

... and you are spamming what in your signature? Stop it, it's rude!

Just experimented putting red text in a listbox:

# load, sort, clear and add to wxPython's
# wx.ListBox(parent, id, pos, size, choices, style, name)
# choices is a list of strings
#
# style -->
# wx.LB_SINGLE  single-selection list (default)
# wx.LB_MULTIPLE  multiple-selection list, the user can toggle
#   multiple items on and off
# wx.LB_EXTENDED  extended-selection list, the user can select multiple
#  items using the SHIFT key, the mouse or special key combinations
# wx.LB_HSCROLL  create horizontal scrollbar if contents are too wide
#  (Windows only)
# wx.LB_ALWAYS_SB  always show a vertical scrollbar
# wx.LB_NEEDED_SB  Only create a vertical scrollbar if needed (default)
# wx.LB_SORT  The listbox contents are sorted in alphabetical order
# source from:  Sneekula 2008

import wx

class MyFrame(wx.Frame):
    def __init__(self, parent, mytitle, name_list):
        wx.Frame.__init__(self, parent, wx.ID_ANY, mytitle)
        self.SetBackgroundColour("brown")
        self.name_list = list(name_list)

        self.listbox = wx.ListBox(self, wx.ID_ANY, choices=[],
            style=wx.LB_EXTENDED)
        self.listbox.Bind(wx.EVT_LISTBOX, self.listboxClick)
        # optional text color for the list box
        self.listbox.SetForegroundColour("red")

        # create buttons
        self.load_button = wx.Button(self, wx.ID_ANY, "load ListBox")
        self.clear_button = wx.Button(self, wx.ID_ANY, "clear ListBox")
        self.sort_button = wx.Button(self, wx.ID_ANY, "sort ListBox")
        self.add_button = wx.Button(self, wx.ID_ANY, "add to ListBox")
        # bind mouse event to an action
        self.load_button.Bind(wx.EVT_BUTTON, self.load_buttonClick)
        self.clear_button.Bind(wx.EVT_BUTTON, self.clear_buttonClick)
        self.sort_button.Bind(wx.EVT_BUTTON, self.sort_buttonClick)
        self.add_button.Bind(wx.EVT_BUTTON, self.add_buttonClick)
        # create an output widget
        s1 = "load the list box ...\n"
        s2 = "to select a single item left click on the item\n"
        s3 = "to select a range of items shift click items\n"
        s4 = "to select multiple items ctrl click on items"
        self.text_out = wx.TextCtrl(self, wx.ID_ANY,
            value=(s1+s2+s3+s4), size=(300, 95),
            style=wx.TE_MULTILINE|wx.HSCROLL|wx.TE_READONLY)

        sizer = wx.GridBagSizer(vgap=5, hgap=5)
        # pos=(row, column)  span=(rowspan, columnspan)
        # wx.ALL puts the specified border on all sides
        sizer.Add(self.load_button, pos=(0, 0), flag=wx.ALL, border=5)
        sizer.Add(self.add_button, pos=(0, 1), flag=wx.ALL, border=5)
        # listbox spans 6 rows and 2 columns
        sizer.Add(self.listbox, pos=(1, 0), span=(6, 2),
            flag=wx.ALL|wx.EXPAND, border=5)
        sizer.Add(self.clear_button, pos=(7, 1), flag=wx.ALL, border=5)
        sizer.Add(self.sort_button, pos=(7, 0), flag=wx.ALL, border=5)
        sizer.Add(self.text_out, pos=(8, 0), span=(2, 2),
            flag=wx.ALL, border=5)
        self.SetSizer(sizer)

        # size the frame so all the widgets fit
        self.Fit()

    def add_buttonClick(self, event):
        """add another item to the listbox"""
        text = wx.GetTextFromUser('Enter new item', 'Add to listbox')
        if text != '':
            self.listbox.Append(text)

    def load_buttonClick(self, event):
        """load the name list into the bistbox"""
        # use self.listbox.Set(self.name_list) or ...
        for name in self.name_list:
            self.listbox.Append(name)

    def clear_buttonClick(self, event):
        """clear all items from the listbox"""
        self.listbox.Clear()
        self.text_out.ChangeValue("")

    def sort_buttonClick(self, event):
        """sort the items in the listbox"""
        # GetItems() is new in wxPython2.8
        # puts the listbox items into a list
        name_list = self.listbox.GetItems()
        name_list.sort()
        # Set() clears and reloads the listbox
        self.listbox.Set(name_list)

    def listboxClick(self, event):
        """display the selected ListBox item(s)"""
        """
        # for single item select use this ...
        selected_item = self.listbox.GetStringSelection()
        s = "You selected " + selected_item
        self.label.SetLabel(s)
        """
        name_list = self.listbox.GetItems()
        # for multiple and single item select use this ...
        pos_tuple = self.listbox.GetSelections()
        selected_list = []
        for pos in pos_tuple:
            selected_list.append(name_list[pos])
        s = "You selected " + str(selected_list)
        self.text_out.ChangeValue(s)


name_list = [
"Erich",
"Udo",
"Jens",
"Bjorn",
"Heidrun",
"Klaus",
"Ulla",
"Volger",
"Helmut",
"Freja",
"Larry",
"Andreas",
"Harry"
]

app = wx.App(0)
# create the MyFrame instance and then show the frame
MyFrame(None, 'wx.ListBox ops', name_list).Show()
app.MainLoop()

Just experimented putting red text in a listbox:

# load, sort, clear and add to wxPython's
# wx.ListBox(parent, id, pos, size, choices, style, name)
# choices is a list of strings
#
# style -->
# wx.LB_SINGLE  single-selection list (default)
# wx.LB_MULTIPLE  multiple-selection list, the user can toggle
#   multiple items on and off
# wx.LB_EXTENDED  extended-selection list, the user can select multiple
#  items using the SHIFT key, the mouse or special key combinations
# wx.LB_HSCROLL  create horizontal scrollbar if contents are too wide
#  (Windows only)
# wx.LB_ALWAYS_SB  always show a vertical scrollbar
# wx.LB_NEEDED_SB  Only create a vertical scrollbar if needed (default)
# wx.LB_SORT  The listbox contents are sorted in alphabetical order
# source from:  Sneekula 2008

import wx

class MyFrame(wx.Frame):
    def __init__(self, parent, mytitle, name_list):
        wx.Frame.__init__(self, parent, wx.ID_ANY, mytitle)
        self.SetBackgroundColour("brown")
        self.name_list = list(name_list)

        self.listbox = wx.ListBox(self, wx.ID_ANY, choices=[],
            style=wx.LB_EXTENDED)
        self.listbox.Bind(wx.EVT_LISTBOX, self.listboxClick)
        # optional text color for the list box
        self.listbox.SetForegroundColour("red")

        # create buttons
        self.load_button = wx.Button(self, wx.ID_ANY, "load ListBox")
        self.clear_button = wx.Button(self, wx.ID_ANY, "clear ListBox")
        self.sort_button = wx.Button(self, wx.ID_ANY, "sort ListBox")
        self.add_button = wx.Button(self, wx.ID_ANY, "add to ListBox")
        # bind mouse event to an action
        self.load_button.Bind(wx.EVT_BUTTON, self.load_buttonClick)
        self.clear_button.Bind(wx.EVT_BUTTON, self.clear_buttonClick)
        self.sort_button.Bind(wx.EVT_BUTTON, self.sort_buttonClick)
        self.add_button.Bind(wx.EVT_BUTTON, self.add_buttonClick)
        # create an output widget
        s1 = "load the list box ...\n"
        s2 = "to select a single item left click on the item\n"
        s3 = "to select a range of items shift click items\n"
        s4 = "to select multiple items ctrl click on items"
        self.text_out = wx.TextCtrl(self, wx.ID_ANY,
            value=(s1+s2+s3+s4), size=(300, 95),
            style=wx.TE_MULTILINE|wx.HSCROLL|wx.TE_READONLY)

        sizer = wx.GridBagSizer(vgap=5, hgap=5)
        # pos=(row, column)  span=(rowspan, columnspan)
        # wx.ALL puts the specified border on all sides
        sizer.Add(self.load_button, pos=(0, 0), flag=wx.ALL, border=5)
        sizer.Add(self.add_button, pos=(0, 1), flag=wx.ALL, border=5)
        # listbox spans 6 rows and 2 columns
        sizer.Add(self.listbox, pos=(1, 0), span=(6, 2),
            flag=wx.ALL|wx.EXPAND, border=5)
        sizer.Add(self.clear_button, pos=(7, 1), flag=wx.ALL, border=5)
        sizer.Add(self.sort_button, pos=(7, 0), flag=wx.ALL, border=5)
        sizer.Add(self.text_out, pos=(8, 0), span=(2, 2),
            flag=wx.ALL, border=5)
        self.SetSizer(sizer)

        # size the frame so all the widgets fit
        self.Fit()

    def add_buttonClick(self, event):
        """add another item to the listbox"""
        text = wx.GetTextFromUser('Enter new item', 'Add to listbox')
        if text != '':
            self.listbox.Append(text)

    def load_buttonClick(self, event):
        """load the name list into the bistbox"""
        # use self.listbox.Set(self.name_list) or ...
        for name in self.name_list:
            self.listbox.Append(name)

    def clear_buttonClick(self, event):
        """clear all items from the listbox"""
        self.listbox.Clear()
        self.text_out.ChangeValue("")

    def sort_buttonClick(self, event):
        """sort the items in the listbox"""
        # GetItems() is new in wxPython2.8
        # puts the listbox items into a list
        name_list = self.listbox.GetItems()
        name_list.sort()
        # Set() clears and reloads the listbox
        self.listbox.Set(name_list)

    def listboxClick(self, event):
        """display the selected ListBox item(s)"""
        """
        # for single item select use this ...
        selected_item = self.listbox.GetStringSelection()
        s = "You selected " + selected_item
        self.label.SetLabel(s)
        """
        name_list = self.listbox.GetItems()
        # for multiple and single item select use this ...
        pos_tuple = self.listbox.GetSelections()
        selected_list = []
        for pos in pos_tuple:
            selected_list.append(name_list[pos])
        s = "You selected " + str(selected_list)
        self.text_out.ChangeValue(s)


name_list = [
"Erich",
"Udo",
"Jens",
"Bjorn",
"Heidrun",
"Klaus",
"Ulla",
"Volger",
"Helmut",
"Freja",
"Larry",
"Andreas",
"Harry"
]

app = wx.App(0)
# create the MyFrame instance and then show the frame
MyFrame(None, 'wx.ListBox ops', name_list).Show()
app.MainLoop()

Oh darn, those accidental duplicate posts in DaniWeb!

To get individual lines coloured, you need to use the wx.ListCtrl():

# exploring wxPython's
# wx.ListCtrl(parent, id, pos, size, style)
# a fancier list box with a lot of mix-in options
# some of the styles =
# wx.LC_REPORT  report mode
# wx.LC_HRULES  draws horizontal rules between rows in report mode
# wx.LC_VRULES  draws vertical rules between columns in report mode
# some methods =
# InsertColumn(col, heading, format=wx.LIST_FORMAT_LEFT, width=-1)
# Original Source: zoe
# explore SetItemTextColour(item, colour) to colour individual lines

import wx

class MyFrame(wx.Frame):
    def __init__(self, parent, data):
        # use default size and position
        wx.Frame.__init__(self, parent, wx.ID_ANY,
            'Test the wx.ListCtrl()',
            size=(400, 220))
        self.SetBackgroundColour("yellow")
        # make data available to the instance
        self.data = data

        # create the list control
        self.lc = wx.ListCtrl(self, wx.ID_ANY, size=(-1, 120),
             style=wx.LC_REPORT|wx.SUNKEN_BORDER|wx.LC_HRULES)
        # select an item (left mouse click on it) and bind to an action
        self.lc.Bind(wx.EVT_LIST_ITEM_SELECTED,self.onAction)
        
        self.loadList()

        # set text color of items/lines 1, 3, 5 in list to red
        # needs style wx.LC_REPORT
        # do this after the list is loaded
        self.lc.SetItemTextColour(1, 'red')
        self.lc.SetItemTextColour(3, 'red')
        self.lc.SetItemTextColour(5, 'red')

        # create an output widget
        self.label = wx.StaticText(self, wx.ID_ANY, "Select a name")

        # use a vertical boxsizer for the widget placement
        sizer_v = wx.BoxSizer(wx.VERTICAL)
        sizer_v.Add(self.lc, 1, flag=wx.ALL|wx.EXPAND, border=10)
        sizer_v.Add(self.label, 0, flag=wx.ALL|wx.EXPAND, border=10)
        self.SetSizer(sizer_v)

    def loadList(self):
        # first the columns with header titles
        self.lc.InsertColumn(col=0,heading="Name",width=200)
        #self.lc.SetColumnWidth(0, 200)
        self.lc.InsertColumn(col=1,heading="Age",format=wx.LIST_FORMAT_RIGHT)
        self.lc.InsertColumn(col=2,heading="Weight",format=wx.LIST_FORMAT_RIGHT)

        # now each data row
        for key, val in self.data.items():
            # set max_rows, change if need be
            max_rows = 1000
            # also sets/updates row index starting at 0
            index = self.lc.InsertStringItem(max_rows, val[0])
            self.lc.SetStringItem(index, 1, val[1])
            self.lc.SetStringItem(index, 2, val[2])
            # needed by GetItemData()
            self.lc.SetItemData(index, key)

    def onAction(self, event):
        """ some action code"""
        # -1 --> get the first item that matches the specified flags
        # wx.LIST_NEXT_ALL  search for subsequent item by index
        # wx.LIST_STATE_SELECTED  get the selected item
        ix_selected = self.lc.GetNextItem(item=-1,
            geometry=wx.LIST_NEXT_ALL,
            state=wx.LIST_STATE_SELECTED)
        # get the value of the key in dictionary self.data
        data_value = self.data[self.lc.GetItemData(ix_selected)]
        # pick the name (first item in the value tuple)
        name = ' --> ' + data_value[0]
        self.label.SetLabel(str(data_value) + name)
        # testing --> index and name only
        ix = self.lc.GetFirstSelected()
        print ix, self.lc.GetItemText(ix)


# data to load the listctrl in the form of a dictionary
# the header is ('Name', 'Age', 'Weight')
data = {
1 : ('Heidi Kalumpa', '36', '127'),
2 : ('Frank Maruco', '27', '234'),
3 : ('Larry Pestraus', '19', '315'),
4 : ('Serge Romanowski', '59', '147'),
5 : ('Carolus Arm', '94', '102'),
6 : ('Michel Sargnagel', '21', '175')
}

app = wx.App(0)
# create a MyFrame instance and show the frame
MyFrame(None, data).Show()
app.MainLoop()

I would like to suggest to change this class little:

Add import in beginning:

import sys

and define MyFrame:

class MyFrame(wx.Frame):
    def __init__(self, parent, mytitle, mysize, filename=None):
        wx.Frame.__init__(self, parent, wx.ID_ANY, mytitle, size=mysize)
        
        stc_edit = MySTC(self)
        
        # open a Python code file you have in the working folder
        # or give full path name
        if not filename:    self.filename=sys.argv[0]
        else:               self.filename = filename
        stc_edit.SetText(open(self.filename).read())
        stc_edit.EmptyUndoBuffer()
        stc_edit.Colourise(0, -1)
        
        # line numbers in the margin
        stc_edit.SetMarginType(1, stc.STC_MARGIN_NUMBER)
        stc_edit.SetMarginWidth(1, 25)

Then it is not sensitive to filename the program is using, and it is possible to set the filename from programme.

@tonyjv
Kind of poor to use commandline arguments in a GUI environment. If you want to swell the code given, it would be best to use wxPython's excellent wx.FileDialog widget.

It is not using command line, only prevent hard coding of programs name by reading it from argv[0] instead of literal string.

This is just a quick example of how i use empty wx.BoxSizer() to hold spaces for borders ect. It makes the layout much easier to controll the borders, widgets ect on multiple panels as the programs i design get much bigger and more complicated. There is probably a much easier, faster and simpler way to do this, but this is the method i came up with as i dont know any other.

import wx

class SpacerExample(wx.Frame):
        def __init__(self):
            wx.Frame.__init__(self, None, title = "Spacer example", size = (350, 370))
            panel = wx.Panel(self)

            font = wx.Font(20, wx.SWISS, wx.NORMAL, wx.NORMAL, False, "Mangal")
            title = wx.StaticText(panel, label = "Border using sizers", style = wx.ALIGN_CENTRE)
            title.SetFont(font)
            
            set1text = wx.StaticText(panel, label = "Please enter something")
            set1box = wx.TextCtrl(panel)

            set2text = wx.StaticText(panel , label = "Please enter something else")
            set2box = wx.TextCtrl(panel)

            set3text = wx.StaticText(panel, label = "Please enter something else again")
            set3box = wx.TextCtrl(panel)

            save = wx.Button(panel, label = "Save")
            cancel = wx.Button(panel, label = "Cancel")

            #these are my spaces in the main column
            topspace = wx.BoxSizer()
            vertspc1 = wx.BoxSizer()
            vertspc2 = wx.BoxSizer()
            vertspc3 = wx.BoxSizer()
            vertspc4 = wx.BoxSizer()
            vertspc5 = wx.BoxSizer()
            #these spacers are my right and left borders
            hzlspc1 = wx.BoxSizer()
            hzlspc2 = wx.BoxSizer()
            #this is the space between my buttons
            hzlspc3 = wx.BoxSizer()

            buttonarr = wx.BoxSizer()
            buttonarr.Add(cancel, proportion = 3, flag = wx.EXPAND)
            buttonarr.Add(hzlspc3, proportion = 1)
            buttonarr.Add(save, proportion = 3, flag = wx.EXPAND)
            #this organises the main column of my programme
            mainsizer = wx.BoxSizer(wx.VERTICAL)
            mainsizer.Add(topspace, proportion = 1)
            mainsizer.Add(title, proportion = 4, flag = wx.EXPAND)
            mainsizer.Add(vertspc1, proportion = 1)
            mainsizer.Add(set1text, proportion = 2)
            mainsizer.Add(set1box, proportion = 2, flag = wx.EXPAND)
            mainsizer.Add(vertspc2, proportion = 2)
            mainsizer.Add(set2text, proportion = 2)
            mainsizer.Add(set2box, proportion = 2, flag = wx.EXPAND)
            mainsizer.Add(vertspc3, proportion = 2)
            mainsizer.Add(set3text, proportion = 2)
            mainsizer.Add(set3box, proportion = 2, flag = wx.EXPAND)
            mainsizer.Add(vertspc4, proportion = 2)
            mainsizer.Add(buttonarr, proportion = 2, flag = wx.EXPAND)
            mainsizer.Add(vertspc5, proportion = 2)
            #this adds the left and right border
            layout = wx.BoxSizer()
            layout.Add(hzlspc1, proportion = 1)
            layout.Add(mainsizer, proportion = 8)
            layout.Add(hzlspc2, proportion = 1)
            #this sets the sizers in action, i only need to set the top one
            panel.SetSizer(layout)
            

app = wx.App(redirect=False)
window = SpacerExample()
window.Show()
app.MainLoop()

I like to keep my code minimalistic, and i will admit this way of doing things can get hectic when multiple panels/botton arrangements are involved but this is the only way i know how to do this and get my desired results, i hope this helps and i hope someone more experienced can show you the perfect method.

Here is example of simple wx program using functions to set common options to widgets, see http://www.daniweb.com/forums/post1374954.html#post1374954

Program is missing the final action and progress bar part, it is exercise for the reader. Not so much comments in the program, also.

import os
import wx


class MyForm(wx.Frame):
    def __init__(self):
        wx.Frame.__init__(self, None, wx.ID_ANY, "Remote Administrator v1.0", (500,500), (425,280))

        self.font = wx.Font(8, wx.FONTFAMILY_DEFAULT, wx.FONTSTYLE_NORMAL,
                            wx.FONTWEIGHT_NORMAL, 0, 'Microsoft Sans Serif')
        self.dictcomputers={
            u"Atel": [(u'PC%i' % n) for n in range(1,1+12)],
            u"Sint-Andries": [(u'PC%i' % n) for n in range(1,1+8)],
            u"Permee": [(u'PC%i' % n) for n in range(1,1+5)] }

        self.panel = wx.Panel(self, wx.ID_ANY)
        self.listcomputers = wx.ListBox(self.panel, 1, (8,16), (120, 150),
                                        [], wx.LB_MULTIPLE)
        self.listcomputers.SetBackgroundColour(wx.Colour(255, 255, 255))
        self.font_and_cursor(self.listcomputers)
        self.listcomputers.Bind(wx.EVT_LISTBOX, self.onlistcomputers)

        start = wx.Button(self.panel, -1, 'Start', (8, 176), (75, 23))
        start.Bind(wx.EVT_BUTTON, self.onStart)

        self.timer = wx.Slider(self.panel, -1, 0, 0, 10,
                               (136, 48), (104, 45),
                               wx.SL_HORIZONTAL | wx.SL_AUTOTICKS | wx.SL_BOTTOM |
                               wx.SL_RIGHT | wx.SL_LABELS)
        self.timer.Bind(wx.EVT_SLIDER, self.onAdjust)
        
        label = wx.StaticText(self.panel, -1, 'Timer:', (144,32), (100, 23))
        self.font_and_cursor(label)

        radios = (self.make_radio('Shutdown', 88), self.make_radio('Logoff', 112), self.make_radio('Reboot', 136))

        self.CreateStatusBar()
        
        loc = wx.ComboBox(self.panel, -1, 'Select Location',
                          (269, 21), (121, 21), self.dictcomputers.keys())
        loc.SetBackgroundColour(wx.Colour(255, 255, 255))
        self.font_and_cursor(loc)
        loc.Bind(wx.EVT_COMBOBOX, self.onLocation)
        
        self.progressbar = wx.Gauge(self.panel, -1, 100,
                                    (264, 128), (137, 17))
        self.font_and_cursor(self.progressbar)
        self.progressbar.SetValue(0)

    def font_and_cursor(self, widget):
        widget.SetFont(self.font)
        widget.SetCursor(wx.StockCursor(wx.CURSOR_DEFAULT))


    def make_radio(self, label, pos):
        Radio = wx.RadioButton(self.panel, -1, label, (136, pos), (104, 24))
        Radio.SetFont(self.font)
        Radio.SetCursor(wx.StockCursor(wx.CURSOR_DEFAULT))
        Radio.SetValue(0)
        Radio.Bind(wx.EVT_RADIOBUTTON, self.onRadio)
        return Radio

    def onLocation(self, event):
        self.location = event.GetEventObject().GetValue()
        self.Hide()
        self.Update()
        self.Refresh()
        self.Show()      
        self.SetStatusText(self.location)
        self.listcomputers.Set(self.dictcomputers[self.location])
        self.pclst = []
       
    def onlistcomputers(self, event):
        self.pclst = [event.GetEventObject().GetItems()[pc] for pc in event.GetEventObject().GetSelections()]
        self.SetStatusText("Selected Computers: %s" % ', '.join(self.pclst))
        
    def onAdjust(self, event):
        self.SetStatusText("Timer set to: %s " % (event.GetEventObject().GetValue()))

    def onRadio(self, event):
        action = event.GetEventObject().GetLabel()
        self.action = action
        self.SetStatusText("Selected " + action)
               
    def onStart(self, event):
        if event.GetEventObject().GetLabel() == "Start":
            try:
                if not self.pclst[0]:
                    raise IndexError
                message = ("Doing %s %s at %s, computer%s: %s" %
                       (self.action,
                        'in %s seconds' % self.timer.GetValue() if self.timer.GetValue() else 'immediately',
                        self.location,
                        's' if len(self.pclst)>1 else '',
                        ', '.join(self.pclst) ) )
            except AttributeError:
                self.SetStatusText("Failed starting actions")
                wx.MessageBox('Not all required fields are filled in!\nPlease correct this and try again.', 'Error')
            except IndexError:
                self.SetStatusText("Failed starting actions")
                wx.MessageBox('No PC selected!\nPlease correct this and try again.', 'Error')
            else:
                self.SetStatusText(message)


if __name__ == "__main__":
    app = wx.App(False)
    frame = MyForm()
    frame.Show()
    app.MainLoop()

I like personally the wx.FlexGridSizer than all the sizers.
with FlexGridSizer and the normal wx.BoxSizer you can make layouts that you realy desire.
;)

One way to create a rainbow effect:

# explore wxPython's
# GradientFillLinear(rect, initialColour, destColour, nDirection=EAST)

import wx

class MyFrame(wx.Frame):
    def __init__(self, parent, mytitle, mysize):
        wx.Frame.__init__(self, parent, -1, mytitle, size=mysize)
        self.SetBackgroundColour('black')
        # bind the frame to the paint event canvas
        wx.EVT_PAINT(self, self.onPaint)

    def onPaint(self, event=None):
        # the wxPython drawing canvas
        dc = wx.PaintDC(self)

        # create rainbow effect in three adjoining sections
        # section1, color gradient from red to yellow
        dc.GradientFillLinear((10, 10, 200, 100), 'red', 'yellow')
        # section2, color gradient from yellow to green
        dc.GradientFillLinear((210, 10, 200, 100), 'yellow', 'green')
        # section3, color gradient from green to blue
        dc.GradientFillLinear((410, 10, 200, 100), 'green', 'blue')


app = wx.App(0)
mytitle = "GradientFillLinear() Rainbow"
width = 630
height = 155
MyFrame(None, mytitle, (width, height)).Show()
app.MainLoop()

Creating a small LED clock with wxPython:

# wxPython's wx.gizmos.LEDNumberCtrl() widget
# can be used for an LED clock

import wx
import wx.gizmos
import time

class LedClock(wx.Frame):
    """
    create an LED clock showing the current time
    """
    def __init__(self, parent=None):
        wx.Frame.__init__(self, parent, -1, title='LED Clock',
            size=(320, 100))
        # default colors are green on black
        self.led = wx.gizmos.LEDNumberCtrl(self, -1,
            style=wx.gizmos.LED_ALIGN_CENTER)
        # set up a timer
        self.timer = wx.Timer(self, -1)
        # update clock digits every second (1000ms)
        self.timer.Start(1000)
        # bind the timer to a method
        self.Bind(wx.EVT_TIMER, self.update_clock)

    def update_clock(self, event):
        # get the current time tuple from the computer
        current = time.localtime(time.time())
        # time string can have characters 0..9, -, period, or space
        ts = time.strftime("%H %M %S", current)
        self.led.SetValue(ts)


app = wx.App(0)
LedClock().Show()
app.MainLoop()

I am experimenting with overlapping transparent images using wxPython. Here is something I came up with (used one of vegaseat's images):

# use wx.Image() to create two overlapping transparent images

import wx

class ImagePanel(wx.Panel):

    def __init__(self, parent):
        wx.Panel.__init__(self, parent, wx.ID_ANY)

        self.parent = parent
        # pick 2 image files you have in the working folder
        # (or give the full path)
        image_file1 = 'Duck_right.jpg'
        image_file2 = 'Duck_left.jpg'
        # default is type=wx.BITMAP_TYPE_ANY
        self.image1 = wx.Image(image_file1)
        self.image2 = wx.Image(image_file2)
        # need this ...
        self.image1.InitAlpha()
        self.image2.InitAlpha()
        # call on_paint() to create the canvas
        wx.EVT_PAINT(self, self.on_paint)

    def on_paint(self, event):
        dc = wx.PaintDC(self)
        # reduces flicker
        #dc = wx.BufferedDC(dc)
        # set the canvas background color to a light grey
        dc.SetBackground(wx.Brush("#D0D0D0"))
        #dc.SetBackground(wx.Brush("white"))  # if you like
        dc.Clear()

        # adjust r g b and alpha (transparency) of image
        # AdjustChannels(fr, fg, fb, fa)
        # adjust alphas from 0.0 to 1.0 to see the effects
        alpha1 = 0.5
        alpha2 = 0.7
        if self.image1.HasAlpha(): 
            image1 = self.image1.AdjustChannels(1.0, 1.0, 1.0, alpha1)
            image2 = self.image2.AdjustChannels(1.0, 1.0, 1.0, alpha2)
        else:
            image1 = self.image1
            image2 = self.image2
            self.parent.SetTitle("no alpha")

        # required to draw images on canvas
        bmp1 = wx.BitmapFromImage(image1)
        bmp2 = wx.BitmapFromImage(image2)
        # now draw the images
        dc.DrawBitmap(bmp2, 180, 10, True)
        dc.DrawBitmap(bmp1, 20, 70, True)
        

app = wx.App(0)
mytitle = "wx.Image transparent overlapping images"
mysize = (500, 400)
frame = wx.Frame(None, wx.ID_ANY, title=mytitle, size=mysize)
ImagePanel(frame)
frame.Show(True)
app.MainLoop()

Shows you how to use the Python module threading with wxPython:

# -*- coding: utf-8 -*- 

###########################################################################
## Python code partially generated with wxFormBuilder (version Apr 10 2012)
## http://www.wxformbuilder.org/
###########################################################################

import wx
import threading
import time

class MyFrame( wx.Frame ):

    def __init__( self, parent ):
        wx.Frame.__init__ ( self, parent, id = wx.ID_ANY, title = u"Seconds Counter", 
            pos = wx.DefaultPosition, size = wx.Size( 236,173 ), 
            style = wx.DEFAULT_FRAME_STYLE|wx.TAB_TRAVERSAL )

        self.SetSizeHintsSz( wx.DefaultSize, wx.DefaultSize )
        self.SetBackgroundColour( wx.Colour( 0, 0, 255 ) )

        bSizer1 = wx.BoxSizer( wx.VERTICAL )

        self.m_textCtrl = wx.TextCtrl( self, wx.ID_ANY, wx.EmptyString, wx.DefaultPosition, 
            wx.DefaultSize, 0 )
        self.m_textCtrl.SetFont( wx.Font( 20, 74, 90, 92, False, "Comic Sans MS" ) )

        bSizer1.Add( self.m_textCtrl, 0, wx.ALL, 5 )

        self.m_button_start = wx.Button( self, wx.ID_ANY, u"Start", wx.DefaultPosition, 
            wx.DefaultSize, 0 )
        bSizer1.Add( self.m_button_start, 0, wx.ALL, 5 )

        self.m_button_stop = wx.Button( self, wx.ID_ANY, u"Stop", wx.DefaultPosition, 
            wx.DefaultSize, 0 )
        bSizer1.Add( self.m_button_stop, 0, wx.ALL, 5 )

        self.SetSizer( bSizer1 )
        self.Layout()

        # Connect Events
        self.m_button_start.Bind( wx.EVT_LEFT_DOWN, self.m_button_startOnLeftDown )
        self.m_button_stop.Bind( wx.EVT_LEFT_DOWN, self.m_button_stopOnLeftDown )

    def m_button_startOnLeftDown( self, event ):
        self.counter = Counter(0, 1, self.m_textCtrl)
        self.counter.start()
        pass

    def m_button_stopOnLeftDown( self, event ):
        count = self.counter.finish()
        print(count)  # test
        pass


class Counter(threading.Thread):
    """
    create a thread object that will do the counting in a separate thread
    """
    def __init__(self, value, increment, display_widget):
        # init the thread
        threading.Thread.__init__(self)
        # initial value
        self.value = value
        # amount to increment
        self.increment = increment
        # controls the while loop in the run command
        self.alive = False
        # display widget
        self.display = display_widget

    def run(self):
        "this will run in a separate thread"
        self.alive = True
        while self.alive:
            # delay for 1 second
            time.sleep(1)
            self.value += self.increment
            print(self.value)  # test
            self.display.SetValue(str(self.value))

    def peek(self):
        "return the current value"
        return self.value

    def finish(self):
        "close the thread, return final value"
        # stop the while loop in 'run'
        self.alive = False
        return self.value



app = wx.App(0)
# create a MyFrame instance and show the frame
frame = MyFrame(None)
frame.Center()
frame.Show()
app.MainLoop()

# set up your wx application this way
# allows you to check if same app instance is already running

import wx

class MyApp(wx.App):
    def OnInit(self):
        name = "SingleApp - %s" % (wx.GetUserId())
        self.instance = wx.SingleInstanceChecker(name)
        # create a title
        mytitle = name
        if self.instance.IsAnotherRunning():
            message = "Another instance of %s is running" % mytitle
            wx.MessageBox(message, "Error")
            return False        
        self.frame = wx.Frame(parent=None, id=-1, size=(400,300), 
            pos=(150,150), title=mytitle)
        self.frame.Show()
        self.SetTopWindow(self.frame)
        return True

if __name__ == '__main__':
    # error redirection=0 to console
    app = MyApp(0)
    app.MainLoop()