wxPython-zombie 3.1.5.8__cp313-cp313-win_amd64.whl

wx/demo/Timer.py

@@ -0,0 +1,275 @@
+#!/usr/bin/env python
+
+import  time
+import  wx
+import  wx.lib.scrolledpanel as sp
+
+#----------------------------------------------------------------------
+
+
+header = """\
+This demo shows the various ways that wx.Timers can be used in your code.  Just
+select one of the buttons in the left column to start a timer in the indicated way,
+and watch the log window below for messages printed when the timer event or callback
+happens.  Clicking the corresponding button on the right will stop that timer.  Since
+timers are not owned by any other wx object you should hold on to a reference to the
+timer until you are completely finished with it. """
+
+doc1 = """\
+Binding an event handler to the wx.EVT_TIMER event is the
+preferred way to use the wx.Timer class directly.  It makes
+handling timer events work just like normal window events.  You
+just need to specify the window that is to receive the event in
+the wx.Timer constructor.  If that window needs to be able to
+receive events from more than one timer then you can optionally
+specify an ID for the timer and the event binding.
+"""
+
+
+doc2 = """\
+wx.CallLater is a convenience class for wx.Timer.  You just
+specify the timeout in milliseconds and a callable object, along
+with any args or keyword args you would like to be passed to your
+callable, and wx.CallLater takes care of the rest.  If you don't
+need to get the return value of the callable or to restart the
+timer then there is no need to hold a reference to this object.
+"""
+
+
+doc3 = """\
+If you derive a class from wx.Timer and give it a Notify method
+then it will be called when the timer expires.
+"""
+
+
+doc4 = """\
+wx.PyTimer is the old way (a kludge that goes back all the way to
+the first version of wxPython) to bind a timer directly to a
+callable.  You should migrate any code that uses this method to
+use EVT_TIMER instead as this may be deprecated in the future.
+"""
+
+
+class TestPanel(sp.ScrolledPanel):
+    def __init__(self, parent, log):
+        self.log = log
+        sp.ScrolledPanel.__init__(self, parent, -1)
+
+        outsideSizer = wx.BoxSizer(wx.VERTICAL)
+
+        text = wx.StaticText(self, -1, "wx.Timer", style=wx.ALIGN_CENTRE)
+        text.SetFont(wx.Font(24, wx.FONTFAMILY_SWISS, wx.FONTSTYLE_NORMAL, wx.FONTWEIGHT_BOLD, False))
+        text.SetSize(text.GetBestSize())
+        text.SetForegroundColour(wx.BLUE)
+        outsideSizer.Add(text, 0, wx.EXPAND|wx.ALL, 5)
+        outsideSizer.Add(wx.StaticText(self, -1, header), 0, wx.ALIGN_CENTER|wx.ALL, 5)
+        outsideSizer.Add(wx.StaticLine(self, -1), 0, wx.EXPAND)
+        outsideSizer.Add((20,20))
+
+
+        t1b1 = wx.Button(self, -1, "EVT_TIMER")
+        t1b2 = wx.Button(self, -1, "stop timer")
+        t1st = wx.StaticText(self, -1, doc1)
+        t1b2.Disable()
+        self.Bind(wx.EVT_BUTTON, self.OnTest1Start, t1b1)
+        self.Bind(wx.EVT_BUTTON, self.OnTest1Stop,  t1b2)
+
+        # Bind all EVT_TIMER events to self.OnTest1Timer
+        self.Bind(wx.EVT_TIMER, self.OnTest1Timer)
+
+
+        t2b1 = wx.Button(self, -1, "wx.CallLater")
+        t2b2 = wx.Button(self, -1, "stop timer")
+        t2st = wx.StaticText(self, -1, doc2)
+        t2b2.Disable()
+        self.Bind(wx.EVT_BUTTON, self.OnTest2Start, t2b1)
+        self.Bind(wx.EVT_BUTTON, self.OnTest2Stop,  t2b2)
+
+        t3b1 = wx.Button(self, -1, "self.Notify")
+        t3b2 = wx.Button(self, -1, "stop timer")
+        t3st = wx.StaticText(self, -1, doc3)
+        t3b2.Disable()
+        self.Bind(wx.EVT_BUTTON, self.OnTest3Start, t3b1)
+        self.Bind(wx.EVT_BUTTON, self.OnTest3Stop,  t3b2)
+
+        t4b1 = wx.Button(self, -1, "wx.PyTimer")
+        t4b2 = wx.Button(self, -1, "stop timer")
+        t4st = wx.StaticText(self, -1, doc4)
+        t4b2.Disable()
+        self.Bind(wx.EVT_BUTTON, self.OnTest4Start, t4b1)
+        self.Bind(wx.EVT_BUTTON, self.OnTest4Stop,  t4b2)
+
+
+        self.t1b2 = t1b2
+        self.t2b2 = t2b2
+        self.t3b2 = t3b2
+        self.t4b2 = t4b2
+
+        fgs = wx.FlexGridSizer(cols=3, hgap=10, vgap=10)
+        fgs.Add(t1b1)
+        fgs.Add(t1b2)
+        fgs.Add(t1st)
+
+        fgs.Add(t2b1)
+        fgs.Add(t2b2)
+        fgs.Add(t2st)
+
+        fgs.Add(t3b1)
+        fgs.Add(t3b2)
+        fgs.Add(t3st)
+
+        fgs.Add(t4b1)
+        fgs.Add(t4b2)
+        fgs.Add(t4st)
+
+        outsideSizer.Add(fgs, 0, wx.ALIGN_CENTER|wx.ALL, 10)
+        self.SetSizer(outsideSizer)
+        self.SetupScrolling()
+
+
+    # Test 1 shows how to use a timer to generate EVT_TIMER
+    # events, by passing self to the wx.Timer constructor.  The
+    # event is bound above to the OnTest1Timer method.
+
+    def OnTest1Start(self, evt):
+        self.t1 = wx.Timer(self)
+        self.t1.Start(1000)
+        self.log.write("EVT_TIMER timer started\n")
+        self.t1b2.Enable()
+
+    def OnTest1Stop(self, evt):
+        self.t1.Stop()
+        self.log.write("EVT_TIMER timer stopped\n")
+        del self.t1
+        self.t1b2.Disable()
+
+    def OnTest1Timer(self, evt):
+        self.log.write("got EVT_TIMER event\n")
+
+
+
+    # Test 2 shows how to use the wx.CallLater class.
+
+    def OnTest2Start(self, evt):
+        # Call OnTest2Timer one second in the future, passing some
+        # optional arbitrary args.  There is no need to hold a
+        # reference to this one, unless we want to manipulate or query
+        # it later like we do in the two methods below
+        self.t2 = wx.CallLater(1000, self.OnTest2Timer,
+                                'a', 'b', 'c', one=1, two=2)
+        self.log.write("CallLater scheduled\n")
+        self.t2b2.Enable()
+
+    def OnTest2Stop(self, evt):
+        self.t2.Stop()
+        self.log.write("CallLater stopped, last return value was: %s\n" %
+                       repr(self.t2.GetResult()))
+        del self.t2
+        self.t2b2.Disable()
+
+    def OnTest2Timer(self, *args, **kw):
+        self.log.write("CallLater called with args=%s, kwargs=%s\n" % (args, kw))
+
+        # Normally a FutureCall is one-shot, but we can make it
+        # recurring just by calling Restart.  We can even use a
+        # different timeout or pass differnt args this time.
+        self.t2.Restart(1500, "restarted")
+
+        # The return value of this function is saved and can be
+        # retrieved later.  See OnTest2Stop above.
+        return "This is my return value"
+
+
+
+    # Test 3 shows how to use a class derived from wx.Timer.  See
+    # also the NotifyTimer class below.
+
+    def OnTest3Start(self, evt):
+        self.t3 = NotifyTimer(self.log)
+        self.t3.Start(1000)
+        self.log.write("NotifyTimer timer started\n")
+        self.t3b2.Enable()
+
+    def OnTest3Stop(self, evt):
+        self.t3.Stop()
+        self.log.write("NotifyTimer timer stopped\n")
+        del self.t3
+        self.t3b2.Disable()
+
+
+
+    # Test 4 shows the old way (a kludge that goes back all the
+    # way to the first version of wxPython) to bind a timer
+    # directly to a callable.  You should migrate any code that
+    # uses this method to use EVT_TIMER instead as this may be
+    # deprecated in the future.
+    def OnTest4Start(self, evt):
+        self.t4 = wx.PyTimer(self.OnTest4Timer)
+        self.t4.Start(1000)
+        self.log.write("wx.PyTimer timer started\n")
+        self.t4b2.Enable()
+
+    def OnTest4Stop(self, evt):
+        self.t4.Stop()
+        self.log.write("wx.PyTimer timer stopped\n")
+        del self.t4
+        self.t4b2.Disable()
+
+    def OnTest4Timer(self):
+        self.log.write("got wx.PyTimer event\n")
+
+
+    def ShutdownDemo(self):
+        for t in ['t1', 't2', 't3', 't4']:
+            if hasattr(self, t):
+                print('Stopping:', t)
+                timer = getattr(self, t)
+                timer.Stop()
+
+#----------------------------------------------------------------------
+
+
+# When deriving from wx.Timer you must provide a Notify method
+# that will be called when the timer expires.
+class NotifyTimer(wx.Timer):
+    def __init__(self, log):
+        wx.Timer.__init__(self)
+        self.log = log
+
+    def Notify(self):
+        self.log.write("got NotifyTimer event\n")
+
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+    win = TestPanel(nb, log)
+    return win
+
+
+#----------------------------------------------------------------------
+
+overview = """<html><body>
+<h2><center>wx.Timer</center></h2>
+
+The wx.Timer class allows you to execute code at specified intervals
+from within the wxPython event loop. Timers can be one-shot or
+repeating.  This demo shows the principle method of using a timer
+(with events) as well as the convenient wx.FutureCall class.  Also
+there are two other usage patterns shown here that have been preserved
+for backwards compatibility.
+
+</body></html>
+"""
+
+
+
+if __name__ == '__main__':
+    import sys,os
+    import run
+    run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
+
+
+

wx/demo/ToggleButton.py

@@ -0,0 +1,54 @@
+#!/usr/bin/env python
+
+import  wx
+import images
+
+#----------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+    def __init__(self, parent, log):
+        wx.Panel.__init__(self, parent, -1)
+        self.log = log
+        panel = wx.Panel(self, -1)
+        buttons = wx.BoxSizer(wx.HORIZONTAL)
+
+        for word in "These are toggle buttons".split():
+            b = wx.ToggleButton(panel, -1, word)
+            self.Bind(wx.EVT_TOGGLEBUTTON, self.OnToggle, b)
+            buttons.Add(b, flag=wx.ALL, border=5)
+
+        panel.SetAutoLayout(True)
+        panel.SetSizer(buttons)
+        buttons.Fit(panel)
+        panel.Move((50,50))
+
+        b = wx.ToggleButton(self, -1, "can have bitmaps too", pos=(50,125))
+        b.SetBitmap(images.Mondrian.Bitmap)
+        b.SetInitialSize() # adjust default size for the bitmap
+        self.Bind(wx.EVT_TOGGLEBUTTON, self.OnToggle, b)
+
+    def OnToggle(self, evt):
+        self.log.write("Button %d toggled\n" % evt.GetId())
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+    win = TestPanel(nb, log)
+    return win
+
+
+#----------------------------------------------------------------------
+
+
+overview = """\
+wx.ToggleButton is a button that stays pressed when clicked by the user.
+In other words, it is similar to wxCheckBox in functionality but looks like a
+wxButton.
+"""
+
+
+
+if __name__ == '__main__':
+    import sys,os
+    import run
+    run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])

wx/demo/ToolBar.py

@@ -0,0 +1,249 @@
+#!/usr/bin/env python
+
+import  wx
+import  images
+
+FRAMETB = True
+TBFLAGS = ( wx.TB_HORIZONTAL
+            | wx.NO_BORDER
+            | wx.TB_FLAT
+            #| wx.TB_TEXT
+            #| wx.TB_HORZ_LAYOUT
+            )
+
+#---------------------------------------------------------------------------
+
+class TestSearchCtrl(wx.SearchCtrl):
+    maxSearches = 5
+
+    def __init__(self, parent, id=-1, value="",
+                 pos=wx.DefaultPosition, size=wx.DefaultSize, style=0,
+                 doSearch=None):
+        style |= wx.TE_PROCESS_ENTER
+        wx.SearchCtrl.__init__(self, parent, id, value, pos, size, style)
+        self.Bind(wx.EVT_TEXT_ENTER, self.OnTextEntered)
+        self.Bind(wx.EVT_SEARCHCTRL_SEARCH_BTN, self.OnTextEntered)
+        self.Bind(wx.EVT_MENU_RANGE, self.OnMenuItem, id=1, id2=self.maxSearches)
+        self.doSearch = doSearch
+        self.searches = []
+
+    def OnTextEntered(self, evt):
+        text = self.GetValue()
+        if self.doSearch(text):
+            self.searches.append(text)
+            if len(self.searches) > self.maxSearches:
+                del self.searches[0]
+            self.SetMenu(self.MakeMenu())
+        self.SetValue("")
+
+    def OnMenuItem(self, evt):
+        text = self.searches[evt.GetId()-1]
+        self.doSearch(text)
+
+    def MakeMenu(self):
+        menu = wx.Menu()
+        item = menu.Append(-1, "Recent Searches")
+        item.Enable(False)
+        for idx, txt in enumerate(self.searches):
+            menu.Append(1+idx, txt)
+        return menu
+
+
+class TestToolBar(wx.Frame):
+    def __init__(self, parent, log):
+        wx.Frame.__init__(self, parent, -1, 'Test ToolBar', size=(600, 400))
+        self.log = log
+        self.timer = None
+        self.Bind(wx.EVT_CLOSE, self.OnCloseWindow)
+
+        client = wx.Panel(self)
+        client.SetBackgroundColour(wx.WHITE)
+
+        if FRAMETB:
+            # Use the wxFrame internals to create the toolbar and
+            # associate it all in one tidy method call.  By using
+            # CreateToolBar or SetToolBar the "client area" of the
+            # frame will be adjusted to exclude the toolbar.
+            tb = self.CreateToolBar( TBFLAGS )
+
+            # Here's a 'simple' toolbar example, and how to bind it using SetToolBar()
+            #tb = wx.ToolBarSimple(self, -1, wx.DefaultPosition, wx.DefaultSize,
+            #               wx.TB_HORIZONTAL | wx.NO_BORDER | wx.TB_FLAT)
+            #self.SetToolBar(tb)
+            # But we're doing it a different way here.
+
+        else:
+            # The toolbar can also be a child of another widget, and
+            # be managed by a sizer, although there may be some
+            # implications of doing this on some platforms.
+            tb = wx.ToolBar(client, style=TBFLAGS)
+            sizer = wx.BoxSizer(wx.VERTICAL)
+            sizer.Add(tb, 0, wx.EXPAND)
+            client.SetSizer(sizer)
+
+        log.write("Default toolbar tool size: %s\n" % tb.GetToolBitmapSize())
+
+        self.CreateStatusBar()
+
+        tsize = (24,24)
+        new_bmp =  wx.ArtProvider.GetBitmap(wx.ART_NEW, wx.ART_TOOLBAR, tsize)
+        open_bmp = wx.ArtProvider.GetBitmap(wx.ART_FILE_OPEN, wx.ART_TOOLBAR, tsize)
+        copy_bmp = wx.ArtProvider.GetBitmap(wx.ART_COPY, wx.ART_TOOLBAR, tsize)
+        paste_bmp= wx.ArtProvider.GetBitmap(wx.ART_PASTE, wx.ART_TOOLBAR, tsize)
+
+        tb.SetToolBitmapSize(tsize)
+
+        #tb.AddTool(10, new_bmp, "New", "Long help for 'New'")
+        tb.AddTool(10, "New", new_bmp, wx.NullBitmap, wx.ITEM_NORMAL, "New", "Long help for 'New'", None)
+        self.Bind(wx.EVT_TOOL, self.OnToolClick, id=10)
+        self.Bind(wx.EVT_TOOL_RCLICKED, self.OnToolRClick, id=10)
+
+        #tb.AddTool(20, open_bmp, "Open", "Long help for 'Open'")
+        tb.AddTool(20, "Open", open_bmp, wx.NullBitmap, wx.ITEM_NORMAL, "Open", "Long help for 'Open'", None)
+        self.Bind(wx.EVT_TOOL, self.OnToolClick, id=20)
+        self.Bind(wx.EVT_TOOL_RCLICKED, self.OnToolRClick, id=20)
+
+        tb.AddSeparator()
+        tb.AddTool(30, "Copy", copy_bmp, wx.NullBitmap, wx.ITEM_NORMAL, "Copy", "Long help for 'Copy'", None)
+        self.Bind(wx.EVT_TOOL, self.OnToolClick, id=30)
+        self.Bind(wx.EVT_TOOL_RCLICKED, self.OnToolRClick, id=30)
+
+        tb.AddTool(40, "Paste", paste_bmp, wx.NullBitmap, wx.ITEM_NORMAL, "Paste", "Long help for 'Paste'", None)
+        self.Bind(wx.EVT_TOOL, self.OnToolClick, id=40)
+        self.Bind(wx.EVT_TOOL_RCLICKED, self.OnToolRClick, id=40)
+
+        tb.AddSeparator()
+
+        #tool = tb.AddCheckTool(50, images.Tog1.GetBitmap(), shortHelp="Toggle this")
+        tool = tb.AddTool(50, "Checkable", images.Tog1.GetBitmap(),
+                          shortHelp="Toggle this",  kind=wx.ITEM_CHECK)
+        self.Bind(wx.EVT_TOOL, self.OnToolClick, id=50)
+
+        self.Bind(wx.EVT_TOOL_ENTER, self.OnToolEnter)
+        self.Bind(wx.EVT_TOOL_RCLICKED, self.OnToolRClick) # Match all
+        self.Bind(wx.EVT_TIMER, self.OnClearSB)
+
+        tb.AddSeparator()
+        cbID = wx.NewIdRef()
+
+        tb.AddControl(
+            wx.ComboBox(
+                tb, cbID, "", choices=["", "This", "is a", "wx.ComboBox"],
+                size=(150,-1), style=wx.CB_DROPDOWN
+                ))
+        self.Bind(wx.EVT_COMBOBOX, self.OnCombo, id=cbID)
+
+        tb.AddStretchableSpace()
+        search = TestSearchCtrl(tb, size=(150,-1), doSearch=self.DoSearch)
+        tb.AddControl(search)
+
+        # Final thing to do for a toolbar is call the Realize() method. This
+        # causes it to render (more or less, that is).
+        tb.Realize()
+
+
+    def DoSearch(self,  text):
+        # called by TestSearchCtrl
+        self.log.WriteText("DoSearch: %s\n" % text)
+        # return true to tell the search ctrl to remember the text
+        return True
+
+    def OnToolClick(self, event):
+        self.log.WriteText("tool %s clicked\n" % event.GetId())
+        #tb = self.GetToolBar()
+        tb = event.GetEventObject()
+        tb.EnableTool(10, not tb.GetToolEnabled(10))
+
+    def OnToolRClick(self, event):
+        self.log.WriteText("tool %s right-clicked\n" % event.GetId())
+
+    def OnCombo(self, event):
+        self.log.WriteText("combobox item selected: %s\n" % event.GetString())
+
+    def OnToolEnter(self, event):
+        self.log.WriteText('OnToolEnter: %s, %s\n' % (event.GetId(), event.GetInt()))
+
+        if self.timer is None:
+            self.timer = wx.Timer(self)
+
+        if self.timer.IsRunning():
+            self.timer.Stop()
+
+        self.timer.Start(2000)
+        event.Skip()
+
+    def OnClearSB(self, event):  # called for the timer event handler
+        self.SetStatusText("")
+        self.timer.Stop()
+        self.timer = None
+
+    def OnCloseWindow(self, event):
+        if self.timer is not None:
+            self.timer.Stop()
+            self.timer = None
+        self.Destroy()
+
+#---------------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+    def __init__(self, parent, log):
+        self.log = log
+        wx.Panel.__init__(self, parent, -1)
+
+        b = wx.Button(self, -1, "Show the ToolBar sample", (50,50))
+        self.Bind(wx.EVT_BUTTON, self.OnButton, b)
+
+
+    def OnButton(self, evt):
+        win = TestToolBar(self, self.log)
+        win.Show(True)
+        self.frame = win
+
+
+#---------------------------------------------------------------------------
+
+
+def runTest(frame, nb, log):
+    win = TestPanel(nb, log)
+    return win
+
+#---------------------------------------------------------------------------
+
+
+
+
+overview = """\
+wx.ToolBar is a narrow strip of icons on one side of a frame (top, bottom, sides)
+that acts much like a menu does, except it is always visible. Additionally, actual
+wxWindows controls, such as wx.TextCtrl or wx.ComboBox, can be added to the toolbar
+and used from within it.
+
+Toolbar creation is a two-step process. First, the toolbar is defined using the
+various Add* methods of wx.ToolBar. Once all is set up, then wx.Toolbar.Realize()
+must be called to render it.
+
+wx.Toolbar events are also propagated as Menu events; this is especially handy when
+you have a menu bar that contains items that carry out the same function. For example,
+it is not uncommon to have a little 'floppy' toolbar icon to 'save' the current file
+(whatever it is) as well as a FILE/SAVE menu item that does the same thing. In this
+case, both events can be captured and acted upon using the same event handler
+with no ill effects.
+
+If there are cases where a toolbar icon should *not* be associated with a menu item,
+use a unique ID to trap it.
+
+There are a number of ways to create a toolbar for a wx.Frame. wx.Frame.CreateToolBar()
+does all the work except it adds no buttons at all unless you override the virtual method
+OnCreateToolBar(). On the other hand, you can just subclass wx.ToolBar and then use
+wx.Frame.SetToolBar() instead.
+
+Note that wx.TB_DOCKABLE is only supported under GTK. An attempt to alleviate this
+is provided in wx.lib.floatbar, but it is not formally supported.
+"""
+
+
+if __name__ == '__main__':
+    import sys,os
+    import run
+    run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+

wx/demo/ToolTip.py

@@ -0,0 +1,71 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import wx
+
+
+class TestPanel(wx.Panel):
+    def __init__(self, parent, log):
+        self.log = log
+        wx.Panel.__init__(self, parent, -1)
+
+        self.tt1 = wx.ToolTip("This is a wx.ToolTip.")
+        self.tt2 = wx.ToolTip("This is\na multi-line\nToolTip.")
+        self.tt3 = wx.ToolTip("Disabled ToolTips.")
+        self.tt4 = wx.ToolTip("I will change this on the next line.")
+        self.tt4.SetTip("ToolTip.GetTip(tt1) = %s" % self.tt1.GetTip())
+        self.tt5 = wx.ToolTip("hmmm")
+        self.tt6 = wx.ToolTip("wxPython (Phoenix)\n" * 10)
+        self.tt7 = wx.ToolTip("Enable ToolTips.")
+        self.tt8 = wx.ToolTip("bla bla bla " * 50)
+        ## self.tt8.SetMaxWidth(-1)
+        self.tt8.SetMaxWidth(0)
+
+        wx.StaticText(self, -1, "Hover over a button to see a tool tip", (250,30))
+        self.btn1 = wx.Button(self, -1, "Simple ToolTip", pos=(50, 30))
+        self.btn1.SetToolTip(self.tt1)
+        self.btn2 = wx.Button(self, -1, "Multi-Line ToolTip", pos=(50, 60))
+        self.btn2.SetToolTip(self.tt2)
+        self.btn3 = wx.Button(self, -1, "Disable ToolTips (if supported)", pos=(50, 90))
+        self.btn3.SetToolTip(self.tt3)
+        self.btn3.Bind(wx.EVT_BUTTON, self.OnDisableToolTips)
+        self.btn4 = wx.Button(self, -1, "ToolTip.GetTip(self.tt1) = %s" % self.tt1.GetTip(), pos=(50, 120))
+        self.btn4.SetToolTip(self.tt4)
+        self.btn5 = wx.Button(self, -1, "ToolTip.GetWindow(self.tt2) = %s" % self.tt2.GetWindow(), pos=(50, 150))
+        self.btn5.SetToolTip(self.tt5)
+        self.tt5.SetTip("ToolTip.GetWindow(tt2) = %s" % self.tt2.GetWindow())
+        self.btn6 = wx.Button(self, -1, "ToolTip.SetMaxWidth(-1)", pos=(50, 180))
+        self.btn6.SetToolTip(self.tt6)
+        self.btn7 = wx.Button(self, -1, "Enable ToolTips", pos=(50, 210))
+        self.btn7.SetToolTip(self.tt7)
+        self.btn7.Bind(wx.EVT_BUTTON, self.OnEnableToolTips)
+        self.btn8 = wx.Button(self, -1, "ToolTip.SetMaxWidth(0)", pos=(50, 240))
+        self.btn8.SetToolTip(self.tt8)
+        self.btn9 = wx.Button(self, -1, "ToolTip set by string", pos=(50, 270))
+        self.btn9.SetToolTip("ToolTip set without a wx.ToolTip")
+
+    def OnDisableToolTips(self, event):
+        wx.ToolTip.Enable(False)
+
+    def OnEnableToolTips(self, event):
+        wx.ToolTip.Enable(True)
+
+
+def runTest(frame, nb, log):
+    win = TestPanel(nb, log)
+    return win
+
+
+#---------------------------------------------------------------------------
+
+
+overview = """\
+wx.ToolTip
+"""
+
+
+if __name__ == '__main__':
+    import sys
+    import os
+    import run
+    run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])