This commit was manufactured by cvs2svn to create tag 'WX_2_1_11'.

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/tags/WX_2_1_11@4580 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

utils/wxPython/demo/Main.py

@@ -42,11 +42,12 @@ _treeList = [
 
     ('Miscellaneous', [ 'DragAndDrop', 'CustomDragAndDrop', 'FontEnumerator',
                         'wxTimer', 'wxValidator', 'wxGLCanvas', 'DialogUnits',
-                        'wxImage', 'PrintFramework', 'wxOGL', 'PythonEvents']),
+                        'wxImage', 'PrintFramework', 'wxOGL', 'PythonEvents',
+                        'Threads']),
 
-    ('wxPython Library', ['OldSizers', 'Layoutf', 'wxScrolledMessageDialog',
+    ('wxPython Library', ['Layoutf', 'wxScrolledMessageDialog',
                           'wxMultipleChoiceDialog', 'wxPlotCanvas', 'wxFloatBar',
-                          'PyShell']),
+                          'PyShell', 'wxCalendar']),
 
     ('Cool Contribs', ['pyTree', 'hangman', 'SlashDot', 'XMLtreeview']),
 
@@ -161,6 +162,7 @@ class wxPythonDemo(wxFrame):
         (w, self.charHeight) = self.log.GetTextExtent('X')
         self.WriteText('wxPython Demo Log:\n')
 
+        self.Show(true)
 
         # add the windows to the splitter and split it.
         if _useSplitter:

utils/wxPython/demo/Threads.py

@@ -0,0 +1,238 @@
+
+from wxPython.wx import *
+
+import thread
+import time
+from   whrandom import random
+
+#----------------------------------------------------------------------
+
+wxEVT_UPDATE_BARGRAPH = 25015
+
+def EVT_UPDATE_BARGRAPH(win, func):
+    win.Connect(-1, -1, wxEVT_UPDATE_BARGRAPH, func)
+
+
+class UpdateBarEvent(wxPyEvent):
+    def __init__(self, barNum, value):
+        wxPyEvent.__init__(self)
+        self.SetEventType(wxEVT_UPDATE_BARGRAPH)
+        self.barNum = barNum
+        self.value = value
+
+
+#----------------------------------------------------------------------
+
+class CalcBarThread:
+    def __init__(self, win, barNum, val):
+        self.win = win
+        self.barNum = barNum
+        self.val = val
+
+    def Start(self):
+        self.keepGoing = self.running = true
+        thread.start_new_thread(self.Run, ())
+
+    def Stop(self):
+        self.keepGoing = false
+
+    def IsRunning(self):
+        return self.running
+
+    def Run(self):
+        while self.keepGoing:
+            evt = UpdateBarEvent(self.barNum, int(self.val))
+            wxPostEvent(self.win, evt)
+            del evt
+
+            sleeptime = (random() * 2) + 0.5
+            #print self.barNum, 'sleeping for', sleeptime
+            time.sleep(sleeptime)
+
+            sleeptime = sleeptime * 5
+            if int(random() * 2):
+                self.val = self.val + sleeptime
+            else:
+                self.val = self.val - sleeptime
+
+            if self.val < 0: self.val = 0
+            if self.val > 300: self.val = 300
+
+        self.running = false
+
+#----------------------------------------------------------------------
+
+
+class GraphWindow(wxWindow):
+    def __init__(self, parent, labels):
+        wxWindow.__init__(self, parent, -1)
+
+        self.values = []
+        for label in labels:
+            self.values.append((label, 0))
+
+        self.font = wxFont(12, wxSWISS, wxNORMAL, wxBOLD)
+        self.SetFont(self.font)
+
+        self.colors = [ wxRED, wxGREEN, wxBLUE, wxCYAN,
+                        wxNamedColour("Yellow"), wxNamedColor("Navy") ]
+
+
+    def SetValue(self, index, value):
+        assert index < len(self.values)
+        cur = self.values[index]
+        self.values[index:index+1] = [(cur[0], value)]
+
+
+    def SetFont(self, font):
+        wxWindow.SetFont(self, font)
+        wmax = hmax = 0
+        for label, val in self.values:
+            w,h = self.GetTextExtent(label)
+            if w > wmax: wmax = w
+            if h > hmax: hmax = h
+        self.linePos = wmax + 10
+        self.barHeight = hmax
+
+
+    def Draw(self, dc, size):
+        dc.SetFont(self.font)
+        dc.SetTextForeground(wxBLUE)
+        dc.SetBackground(wxBrush(self.GetBackgroundColour()))
+        dc.Clear()
+        dc.SetPen(wxPen(wxBLACK, 3, wxSOLID))
+        dc.DrawLine(self.linePos, 0, self.linePos, size.height-10)
+
+        bh = ypos = self.barHeight
+        for x in range(len(self.values)):
+            label, val = self.values[x]
+            dc.DrawText(label, 5, ypos)
+
+            if val:
+                color = self.colors[ x % len(self.colors) ]
+                dc.SetPen(wxPen(color))
+                dc.SetBrush(wxBrush(color))
+                dc.DrawRectangle(self.linePos+3, ypos, val, bh)
+
+            ypos = ypos + 2*bh
+            if ypos > size.height-10:
+                break
+
+
+    def OnPaint(self, evt):
+        size = self.GetSize()
+        bmp = wxEmptyBitmap(size.width, size.height)
+        dc = wxMemoryDC()
+        dc.SelectObject(bmp)
+        self.Draw(dc, size)
+
+        wdc = wxPaintDC(self)
+        wdc.BeginDrawing()
+        wdc.Blit(0,0, size.width, size.height, dc, 0,0)
+        wdc.EndDrawing()
+
+
+    def OnEraseBackground(self, evt):
+        pass
+
+
+
+
+#----------------------------------------------------------------------
+
+class TestFrame(wxFrame):
+    def __init__(self, parent, log):
+        wxFrame.__init__(self, parent, -1, "Thread Test", size=(450,300))
+        self.log = log
+
+        #self.CenterOnParent()
+
+        panel = wxPanel(self, -1)
+        panel.SetFont(wxFont(10, wxSWISS, wxNORMAL, wxBOLD))
+        wxStaticText(panel, -1,
+                     "This demo shows multiple threads interacting with this\n"
+                     "window by sending events to it.", wxPoint(5,5))
+        panel.Fit()
+
+        self.graph = GraphWindow(self, ['Zero', 'One', 'Two', 'Three', 'Four',
+                                        'Five', 'Six', 'Seven'])
+
+        sizer = wxBoxSizer(wxVERTICAL)
+        sizer.Add(panel, 0, wxEXPAND)
+        sizer.Add(self.graph, 1, wxEXPAND)
+
+        self.SetSizer(sizer)
+        self.SetAutoLayout(true)
+
+        #self.graph.SetValue(0, 25)
+        #self.graph.SetValue(1, 50)
+        #self.graph.SetValue(2, 75)
+        #self.graph.SetValue(3, 100)
+
+        EVT_UPDATE_BARGRAPH(self, self.OnUpdate)
+        self.threads = []
+        self.threads.append(CalcBarThread(self, 0, 50))
+        self.threads.append(CalcBarThread(self, 1, 75))
+        self.threads.append(CalcBarThread(self, 2, 100))
+        self.threads.append(CalcBarThread(self, 3, 150))
+        self.threads.append(CalcBarThread(self, 4, 225))
+        self.threads.append(CalcBarThread(self, 5, 300))
+        self.threads.append(CalcBarThread(self, 6, 250))
+        self.threads.append(CalcBarThread(self, 7, 175))
+
+        for t in self.threads:
+            t.Start()
+
+
+
+    def OnUpdate(self, evt):
+        self.graph.SetValue(evt.barNum, evt.value)
+        self.graph.Refresh(false)
+
+
+    def OnCloseWindow(self, evt):
+        busy = wxBusyInfo("One moment please, waiting for threads to die...")
+        for t in self.threads:
+            t.Stop()
+        running = 1
+        while running:
+            running = 0
+            for t in self.threads:
+                running = running + t.IsRunning()
+            time.sleep(0.1)
+        self.Destroy()
+
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+    win = TestFrame(frame, log)
+    frame.otherWin = win
+    win.Show(true)
+    return None
+
+#----------------------------------------------------------------------
+
+
+
+
+overview = """\
+The main issue with multi-threaded GUI programming is the thread safty
+of the GUI itself.  On most platforms the GUI is not thread safe and
+so any cross platform GUI Toolkit and applications written with it
+need to take that into account.
+
+The solution is to only allow interaction with the GUI from a single
+thread, but this often severly limits what can be done in an
+application and makes it difficult to use additional threads at all.
+
+Since wxPython already makes extensive use of event handlers, it is a
+logical extension to allow events to be sent to GUI objects from
+alternate threads.  A function called wxPostEvent allows you to do
+this.  It accepts an event and an event handler (window) and instead
+of sending the event immediately in the current context like
+ProcessEvent does, it processes it later from the context of the GUI
+thread.
+
+"""

utils/wxPython/demo/wxCalendar.py

@@ -0,0 +1,441 @@
+#! /usr/local/bin/python
+#----------------------------------------------------------------------------
+# Name:         CalendPanel.py
+# Purpose:      Calendar control display testing on panel
+#
+# Author:       Lorne White (email: lwhite1@planet.eon.net)
+#
+# Created:
+# Version       0.5 1999/11/03
+# Licence:      wxWindows license
+#----------------------------------------------------------------------------
+
+from wxPython.wx           import *
+from wxPython.lib.calendar import wxCalendar, Month
+
+
+import os
+dir_path = os.getcwd()
+
+
+# highlighted days in month
+
+test_days ={ 0: [],
+            1: [3, 7, 9, 21],
+            2: [2, 10, 4, 9],
+            3: [4, 20, 29],
+            4: [1, 12, 22],
+            5: [2, 10, 15],
+            6: [4, 8, 17],
+            7: [6, 7, 8],
+            8: [5, 10, 20],
+            9: [1, 2, 5, 29],
+           10: [2, 4, 6, 22],
+           11: [6, 9, 12, 28, 29],
+           12: [8, 9, 10, 11, 20] }
+
+# test of full window calendar control functions
+
+def GetMonthList():
+    monthlist = []
+    for i in range(13):
+        name = Month[i]
+        if name != None:
+            monthlist.append(name)
+    return monthlist
+
+class TestPanel(wxPanel):
+    def __init__(self, parent, log):
+        wxPanel.__init__(self, parent, -1)
+
+        self.log = log
+
+        self.calend = wxCalendar(self, -1, wxPoint(100, 50), wxSize(200, 180))
+
+        start_month = 11
+        start_year = 1999
+
+# month list from DateTime module
+
+        monthlist = GetMonthList()
+
+        self.date = wxComboBox(self, 10, Month[start_month], wxPoint(100, 20), wxSize(90, -1), monthlist, wxCB_DROPDOWN)
+        EVT_COMBOBOX(self, 10, self.EvtComboBox)
+
+# set start month and year
+
+        self.calend.SetMonth(start_month)
+        self.calend.SetYear(start_year)
+
+# set attributes of calendar
+
+        self.calend.HideTitle()
+        self.calend.HideGrid()
+
+# display routine
+
+        self.ResetDisplay()
+
+# mouse click event
+
+        self.Connect(self.calend.GetId(), -1, 2100, self.MouseClick)
+
+# scroll bar for month selection
+
+        self.scroll = wxScrollBar(self, 40, wxPoint(100, 240), wxSize(200, 20), wxSB_HORIZONTAL)
+        self.scroll.SetScrollbar(start_month-1, 1, 12, 1, TRUE)
+        EVT_COMMAND_SCROLL(self, 40, self.Scroll)
+
+# spin control for year selection
+
+        self.dtext = wxTextCtrl(self, -1, str(start_year), wxPoint(200, 20), wxSize(60, -1))
+        h = self.dtext.GetSize().height
+
+        self.spin = wxSpinButton(self, 20, wxPoint(270, 20), wxSize(h*2, h))
+        self.spin.SetRange(1980, 2010)
+        self.spin.SetValue(start_year)
+        EVT_SPIN(self, 20, self.OnSpin)
+
+# button for calendar dialog test
+
+        wxStaticText(self, -1, "Test Calendar Dialog", wxPoint(350, 50)).SetBackgroundColour(wxNamedColour('Red'))
+
+        bmp = wxBitmap('bitmaps/Calend.bmp', wxBITMAP_TYPE_BMP)
+        self.but = wxBitmapButton(self, 60, bmp, wxPoint(380, 80))#, wxSize(30, 30))
+        EVT_BUTTON(self, 60, self.TestDlg)
+
+# button for calendar window test
+
+        wxStaticText(self, -1, "Test Calendar Window", wxPoint(350, 150)).SetBackgroundColour(wxNamedColour('Blue'))
+
+        bmp = wxBitmap('bitmaps/Calend.bmp', wxBITMAP_TYPE_BMP)
+        self.but = wxBitmapButton(self, 160, bmp, wxPoint(380, 180))#, wxSize(30, 30))
+        EVT_BUTTON(self, 160, self.TestFrame)
+
+# calendar dialog
+
+    def TestDlg(self, event):
+        dlg = CalenDlg(self, self.log)
+        dlg.Centre()
+        dlg.ShowModal()
+        dlg.Destroy()
+
+# calendar window test
+
+    def TestFrame(self, event):
+        frame = CalendFrame(self, -1, "Test Calendar", self.log)
+        frame.Show(true)
+        return true
+
+# month and year control events
+
+    def OnSpin(self, event):
+        year = event.GetPosition()
+        self.dtext.SetValue(str(year))
+        self.calend.SetYear(year)
+        self.calend.Refresh()
+
+    def EvtComboBox(self, event):
+        name = event.GetString()
+        self.log.WriteText('EvtComboBox: %s\n' % name)
+        monthval = self.date.FindString(name)
+        self.scroll.SetScrollbar(monthval, 1, 12, 1, TRUE)
+
+        self.calend.SetMonth(monthval+1)
+        self.ResetDisplay()
+
+    def Scroll(self, event):
+        value = self.scroll.GetThumbPosition()
+        monthval = int(value)+1
+        self.calend.SetMonth(monthval)
+        self.ResetDisplay()
+        self.log.WriteText('Month: %s\n' % value)
+
+        name = Month[monthval]
+        self.date.SetValue(name)
+
+# log mouse events
+
+    def MouseClick(self, evt):
+        text = '%s CLICK   %02d/%02d/%d' % (evt.click, evt.day, evt.month, evt.year)  # format date
+        self.log.WriteText('Date Selected: ' + text + '\n')
+
+    def OnCloseWindow(self, event):
+        self.Destroy()
+
+# set the highlighted days for the calendar
+
+    def ResetDisplay(self):
+        month = self.calend.GetMonth()
+        try:
+            set_days = test_days[month]
+        except:
+            set_days = [1, 5, 12]
+
+        self.calend.SetSelDay(set_days)
+        self.calend.Refresh()
+
+# increment and decrement toolbar controls
+
+    def OnIncYear(self, event):
+        self.calend.IncYear()
+        self.ResetDisplay()
+
+    def OnDecYear(self, event):
+        self.calend.DecYear()
+        self.ResetDisplay()
+
+    def OnIncMonth(self, event):
+        self.calend.IncMonth()
+        self.ResetDisplay()
+
+    def OnDecMonth(self, event):
+        self.calend.DecMonth()
+        self.ResetDisplay()
+
+    def OnCurrent(self, event):
+        self.calend.SetCurrentDay()
+        self.ResetDisplay()
+
+# test the calendar control in a dialog
+
+class CalenDlg(wxDialog):
+    def __init__(self, parent, log):
+        self.log = log
+        wxDialog.__init__(self, parent, -1, "Test Calendar", wxPyDefaultPosition, wxSize(280, 300))
+
+        start_month = 2
+        start_year = 1999
+
+# get month list from DateTime
+
+        monthlist = GetMonthList()
+
+# select the month
+
+        self.date = wxComboBox(self, 100, Month[start_month], wxPoint(20, 20), wxSize(90, -1), monthlist, wxCB_DROPDOWN)
+        EVT_COMBOBOX(self, 100, self.EvtComboBox)
+
+# alternate spin button to control the month
+
+        h = self.date.GetSize().height
+        self.m_spin = wxSpinButton(self, 120, wxPoint(130, 20), wxSize(h*2, h), wxSP_VERTICAL)
+        self.m_spin.SetRange(1, 12)
+        self.m_spin.SetValue(start_month)
+
+        EVT_SPIN(self, 120, self.OnMonthSpin)
+
+# spin button to conrol the year
+
+        self.dtext = wxTextCtrl(self, -1, str(start_year), wxPoint(160, 20), wxSize(60, -1))
+        h = self.dtext.GetSize().height
+
+        self.y_spin = wxSpinButton(self, 20, wxPoint(220, 20), wxSize(h*2, h), wxSP_VERTICAL)
+        self.y_spin.SetRange(1980, 2010)
+        self.y_spin.SetValue(start_year)
+
+        EVT_SPIN(self, 20, self.OnYrSpin)
+
+# set the calendar and attributes
+
+        self.calend = wxCalendar(self, -1, wxPoint(20, 60), wxSize(240, 200))
+        self.calend.SetMonth(start_month)
+        self.calend.SetYear(start_year)
+
+        self.calend.HideTitle()
+        self.ResetDisplay()
+
+        self.Connect(self.calend.GetId(), -1, 2100, self.MouseClick)
+
+# log the mouse clicks
+
+    def MouseClick(self, evt):
+        text = '%s CLICK   %02d/%02d/%d' % (evt.click, evt.day, evt.month, evt.year)  # format date
+        self.log.WriteText('Date Selected: ' + text + '\n')
+
+        if evt.click == 'DLEFT':
+            self.EndModal(wxID_OK)
+
+# month and year spin selection routines
+
+    def OnMonthSpin(self, event):
+        month = event.GetPosition()
+        self.date.SetValue(Month[month])
+        self.calend.SetMonth(month)
+        self.calend.Refresh()
+
+    def OnYrSpin(self, event):
+        year = event.GetPosition()
+        self.dtext.SetValue(str(year))
+        self.calend.SetYear(year)
+        self.calend.Refresh()
+
+    def EvtComboBox(self, event):
+        name = event.GetString()
+        self.log.WriteText('EvtComboBox: %s\n' % name)
+        monthval = self.date.FindString(name)
+        self.m_spin.SetValue(monthval+1)
+
+        self.calend.SetMonth(monthval+1)
+        self.ResetDisplay()
+
+# set the calendar for highlighted days
+
+    def ResetDisplay(self):
+        month = self.calend.GetMonth()
+        try:
+            set_days = test_days[month]
+        except:
+            set_days = [1, 5, 12]
+
+        self.calend.SetSelDay(set_days)
+        self.calend.Refresh()
+
+# test of full window calendar control functions
+
+class CalendFrame(wxFrame):
+    def __init__(self, parent, id, title, log):
+        wxFrame.__init__(self, parent, id, title, wxPyDefaultPosition, wxSize(400, 400))
+
+        self.log = log
+        self.CreateStatusBar()
+        self.mainmenu = wxMenuBar()
+        menu = wxMenu()
+
+        menu = self.MakeFileMenu()
+        self.mainmenu.Append(menu, '&File')
+
+        self.MakeToolMenu()             # toolbar
+
+        self.SetMenuBar(self.mainmenu)
+        self.calend = wxCalendar(self, -1)
+        self.calend.SetCurrentDay()
+        self.calend.grid_color = 'BLUE'
+        self.ResetDisplay()
+
+        self.Connect(self.calend.GetId(), -1, 2100, self.MouseClick)
+
+    def MouseClick(self, evt):
+        text = '%s CLICK   %02d/%02d/%d' % (evt.click, evt.day, evt.month, evt.year)  # format date
+        self.log.WriteText('Date Selected: ' + text + '\n')
+
+    def OnCloseWindow(self, event):
+        self.Destroy()
+
+    def ResetDisplay(self):
+        month = self.calend.GetMonth()
+        try:
+            set_days = test_days[month]
+        except:
+            set_days = [1, 5, 12]
+
+        self.calend.SetSelDay(set_days)
+        self.calend.Refresh()
+
+    def OnIncYear(self, event):
+        self.calend.IncYear()
+        self.ResetDisplay()
+
+    def OnDecYear(self, event):
+        self.calend.DecYear()
+        self.ResetDisplay()
+
+    def OnIncMonth(self, event):
+        self.calend.IncMonth()
+        self.ResetDisplay()
+
+    def OnDecMonth(self, event):
+        self.calend.DecMonth()
+        self.ResetDisplay()
+
+    def OnCurrent(self, event):
+        self.calend.SetCurrentDay()
+        self.ResetDisplay()
+
+    def MakeFileMenu(self):
+        menu = wxMenu()
+
+        mID = NewId()
+        menu.Append(mID, 'Decrement', 'Next')
+        EVT_MENU(self, mID, self.OnDecMonth)
+
+        mID = NewId()
+        menu.Append(mID, 'Increment', 'Dec')
+        EVT_MENU(self, mID, self.OnIncMonth)
+
+        menu.AppendSeparator()
+
+        mID = NewId()
+        menu.Append(mID, 'E&xit', 'Exit')
+        EVT_MENU(self, mID, self.OnCloseWindow)
+
+        return menu
+
+    def MakeToolMenu(self):
+        tb = self.CreateToolBar(wxTB_HORIZONTAL|wxNO_BORDER)
+
+        bmp_path = 'bitmaps/'
+        SetToolPath(self, tb, 10, bmp_path + 'DbDec.bmp', 'Dec Year')
+        EVT_TOOL(self, 10, self.OnDecYear)
+
+        SetToolPath(self, tb, 15, bmp_path + 'Dec.bmp', 'Dec Month')
+        EVT_TOOL(self, 15, self.OnDecMonth)
+
+        SetToolPath(self, tb, 30, bmp_path + 'Pt.bmp', 'Current Month')
+        EVT_TOOL(self, 30, self.OnCurrent)
+
+        SetToolPath(self, tb, 40, bmp_path + 'Inc.bmp', 'Inc Month')
+        EVT_TOOL(self, 40, self.OnIncMonth)
+
+        SetToolPath(self, tb, 45, bmp_path + 'DbInc.bmp', 'Inc Year')
+        EVT_TOOL(self, 45, self.OnIncYear)
+
+        tb.Realize()
+
+def SetToolPath(self, tb, id, bmp, title):
+    global dir_path
+    tb.AddTool(id, wxBitmap(os.path.join(dir_path, bmp), wxBITMAP_TYPE_BMP), wxNullBitmap, false, -1, -1, title, title)
+
+
+class MyApp(wxApp):
+    def OnInit(self):
+        frame = CalendFrame(NULL, -1, "Test Calendar")
+        frame.Show(true)
+        self.SetTopWindow(frame)
+        return true
+
+#---------------------------------------------------------------------------
+
+def MessageDlg(self, message, type = 'Message'):
+    dlg = wxMessageDialog(self, message, type, wxOK | wxICON_INFORMATION)
+    dlg.ShowModal()
+    dlg.Destroy()
+
+#---------------------------------------------------------------------------
+
+def main():
+    app = MyApp(0)
+    app.MainLoop()
+
+
+if __name__ == '__main__':
+    main()
+
+
+#---------------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+    win = TestPanel(nb, log)
+    return win
+
+#---------------------------------------------------------------------------
+
+
+overview = """\
+This control provides a calendar control class for displaying and selecting dates.
+
+See example for various methods used to set display month, year, and highlighted dates (different colour).
+
+by Lorne White
+
+"""

utils/wxPython/demo/wxFloatBar.py

@@ -7,7 +7,10 @@ class TestFloatBar(wxFrame):
                          wxPoint(0,0), wxSize(500, 300))
         self.log = log
 
-        wxWindow(self, -1).SetBackgroundColour(wxNamedColour("WHITE"))
+        win = wxWindow(self, -1)
+        win.SetBackgroundColour(wxNamedColour("WHITE"))
+        wxStaticText(win, -1, "Drag the toolbar to float it,\n"
+                     "Toggle the last tool to remove the title.", wxPoint(15,15))
 
         tb = wxFloatBar(self, -1)
         self.SetToolBar(tb)
@@ -37,10 +40,6 @@ class TestFloatBar(wxFrame):
 
         tb.AddSeparator()
 
-        tb.AddTool(50, wxBitmap('bitmaps/tog1.bmp', wxBITMAP_TYPE_BMP),
-                        wxNullBitmap, true, -1, -1, "Toggle this")
-        EVT_TOOL(self, 50, self.OnToolClick)
-        EVT_TOOL_RCLICKED(self, 50, self.OnToolRClick)
 
         tb.AddTool(60, wxBitmap('bitmaps/tog1.bmp', wxBITMAP_TYPE_BMP),
                         wxBitmap('bitmaps/tog2.bmp', wxBITMAP_TYPE_BMP),
@@ -48,8 +47,8 @@ class TestFloatBar(wxFrame):
         EVT_TOOL(self, 60, self.OnToolClick)
         EVT_TOOL_RCLICKED(self, 60, self.OnToolRClick)
         tb.Realize()
-#        b = wxButton(tb, -1, "HELLO!")
-#        EVT_BUTTON(b, b.GetId(), self.test)
+
+        self.tb = tb
 
 
     def OnCloseWindow(self, event):
@@ -57,6 +56,11 @@ class TestFloatBar(wxFrame):
 
     def OnToolClick(self, event):
         self.log.WriteText("tool %s clicked\n" % event.GetId())
+        if event.GetId() == 60:
+            if event.GetExtraLong():
+                self.tb.SetTitle("")
+            else:
+                self.tb.SetTitle("Floating!")
 
     def OnToolRClick(self, event):
         self.log.WriteText("tool %s right-clicked\n" % event.GetId())
@@ -75,33 +79,8 @@ def runTest(frame, nb, log):
 overview = """\
 wxFloatBar is a subclass of wxToolBar, implemented in Python, which can be detached from its frame.
 
-Drag the toolbar with the mouse to make it float, and drag it back, or close it to make the toolbar
+Drag the toolbar with the mouse to make it float, and drag it back, or close it to make the toolbar return to its original position.
 
-return to its original position.
-
-wxFloatBar()
------------------------
-
-Default constructor.
-
-wxFloatBar(wxWindow* parent, wxWindowID id, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxTB_HORIZONTAL | wxNO_BORDER, const wxString& name = wxPanelNameStr)
-
-Constructs a floatable toolbar.
-
-Parameters
--------------------
-
-parent = Pointer to a parent window.
-
-id = Window identifier. If -1, will automatically create an identifier.
-
-pos = Window position. wxDefaultPosition is (-1, -1) which indicates that wxWindows should generate a default position for the window. If using the wxWindow class directly, supply an actual position.
-
-size = Window size. wxDefaultSize is (-1, -1) which indicates that wxWindows should generate a default size for the window.
-
-style = Window style. Se wxToolBar for details.
-
-name = Window name.
 """