wxPython-zombie 3.1.5.8__cp313-cp313-win_amd64.whl

wx/demo/OwnerDrawnComboBox.py

@@ -0,0 +1,152 @@
+#!/usr/bin/env python
+
+import wx
+import wx.adv
+
+#----------------------------------------------------------------------
+# This ComboBox class graphically displays the various pen styles that
+# are available, making it easy for the user to choose the style they
+# want.
+
+class PenStyleComboBox(wx.adv.OwnerDrawnComboBox):
+
+    # Overridden from OwnerDrawnComboBox, called to draw each
+    # item in the list
+    def OnDrawItem(self, dc, rect, item, flags):
+        if item == wx.NOT_FOUND:
+            # painting the control, but there is no valid item selected yet
+            return
+
+        r = wx.Rect(*rect)  # make a copy
+        r.Deflate(3, 5)
+
+        penStyle = wx.PENSTYLE_SOLID
+        if item == 1:
+            penStyle = wx.PENSTYLE_TRANSPARENT
+        elif item == 2:
+            penStyle = wx.PENSTYLE_DOT
+        elif item == 3:
+            penStyle = wx.PENSTYLE_LONG_DASH
+        elif item == 4:
+            penStyle = wx.PENSTYLE_SHORT_DASH
+        elif item == 5:
+            penStyle = wx.PENSTYLE_DOT_DASH
+        elif item == 6:
+            penStyle = wx.PENSTYLE_BDIAGONAL_HATCH
+        elif item == 7:
+            penStyle = wx.PENSTYLE_CROSSDIAG_HATCH
+        elif item == 8:
+            penStyle = wx.PENSTYLE_FDIAGONAL_HATCH
+        elif item == 9:
+            penStyle = wx.PENSTYLE_CROSS_HATCH
+        elif item == 10:
+            penStyle = wx.PENSTYLE_HORIZONTAL_HATCH
+        elif item == 11:
+            penStyle = wx.PENSTYLE_VERTICAL_HATCH
+
+        pen = wx.Pen(dc.GetTextForeground(), 3, penStyle)
+        dc.SetPen(pen)
+
+        if flags & wx.adv.ODCB_PAINTING_CONTROL:
+            # for painting the control itself
+            dc.DrawLine( r.x+5, r.y+r.height/2, r.x+r.width - 5, r.y+r.height/2 )
+
+        else:
+            # for painting the items in the popup
+            dc.DrawText(self.GetString( item ),
+                        r.x + 3,
+                        (r.y + 0) + ( (r.height/2) - dc.GetCharHeight() )/2
+                        )
+            dc.DrawLine( r.x+5, r.y+((r.height/4)*3)+1, r.x+r.width - 5, r.y+((r.height/4)*3)+1 )
+
+
+    # Overridden from OwnerDrawnComboBox, called for drawing the
+    # background area of each item.
+    def OnDrawBackground(self, dc, rect, item, flags):
+        # If the item is selected, or its item # iseven, or we are painting the
+        # combo control itself, then use the default rendering.
+        if (item & 1 == 0 or flags & (wx.adv.ODCB_PAINTING_CONTROL |
+                                      wx.adv.ODCB_PAINTING_SELECTED)):
+            wx.adv.OwnerDrawnComboBox.OnDrawBackground(self, dc, rect, item, flags)
+            return
+
+        # Otherwise, draw every other background with different colour.
+        bgCol = wx.Colour(240,240,250)
+        dc.SetBrush(wx.Brush(bgCol))
+        dc.SetPen(wx.Pen(bgCol))
+        dc.DrawRectangle(rect);
+
+
+
+    # Overridden from OwnerDrawnComboBox, should return the height
+    # needed to display an item in the popup, or -1 for default
+    def OnMeasureItem(self, item):
+        # Simply demonstrate the ability to have variable-height items
+        if item & 1:
+            return 36
+        else:
+            return 24
+
+    # Overridden from OwnerDrawnComboBox.  Callback for item width, or
+    # -1 for default/undetermined
+    def OnMeasureItemWidth(self, item):
+        return -1; # default - will be measured from text width
+
+
+
+
+#----------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+    def __init__(self, parent, log):
+        self.log = log
+        wx.Panel.__init__(self, parent, -1)
+
+        penStyles = [
+            "Solid",
+            "Transparent",
+            "Dot",
+            "Long Dash",
+            "Short Dash",
+            "Dot Dash",
+            "Backward Diagonal Hatch",
+            "Cross-diagonal Hatch",
+            "Forward Diagonal Hatch",
+            "Cross Hatch",
+            "Horizontal Hatch",
+            "Vertical Hatch",
+            ]
+
+        wx.StaticText(self, -1, "Pen Styles:", (20, 20))
+        pscb = PenStyleComboBox(self, choices=penStyles, style=wx.CB_READONLY,
+                                pos=(20,40), size=(250, -1))
+
+        self.pscb = pscb
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+    win = TestPanel(nb, log)
+    return win
+
+#----------------------------------------------------------------------
+
+
+
+overview = """<html><body>
+<h2><center>wx.combo.OwnerDrawnComboBox</center></h2>
+
+wx.combo.OwnerDrawnComboBox is a combobox with owner-drawn list
+items. In essence, it is a wx.combo.ComboCtrl with wx.VListBox popup and
+wx.ControlWithItems interface.
+
+</body></html>
+"""
+
+
+
+if __name__ == '__main__':
+    import sys,os
+    import run
+    run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+

wx/demo/PDFViewer.py

@@ -0,0 +1,109 @@
+#!/usr/bin/env python
+
+import wx
+
+try:
+    from wx.lib.pdfviewer import pdfViewer, pdfButtonPanel
+    havePyPdf = True
+except ImportError:
+    havePyPdf = False
+
+#----------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+    def __init__(self, parent, log):
+        wx.Panel.__init__(self, parent, -1)
+        hsizer = wx.BoxSizer( wx.HORIZONTAL )
+        vsizer = wx.BoxSizer( wx.VERTICAL )
+        self.buttonpanel = pdfButtonPanel(self, wx.ID_ANY,
+                                wx.DefaultPosition, wx.DefaultSize, 0)
+        vsizer.Add(self.buttonpanel, 0, wx.GROW|wx.LEFT|wx.RIGHT|wx.TOP, 5)
+        self.viewer = pdfViewer( self, wx.ID_ANY, wx.DefaultPosition,
+                                wx.DefaultSize, wx.HSCROLL|wx.VSCROLL|wx.SUNKEN_BORDER)
+        vsizer.Add(self.viewer, 1, wx.GROW|wx.LEFT|wx.RIGHT|wx.BOTTOM, 5)
+        loadbutton = wx.Button(self, wx.ID_ANY, "Load PDF file",
+                                wx.DefaultPosition, wx.DefaultSize, 0 )
+        vsizer.Add(loadbutton, 0, wx.ALIGN_CENTER|wx.ALL, 5)
+        hsizer.Add(vsizer, 1, wx.GROW|wx.ALL, 5)
+        self.SetSizer(hsizer)
+        self.SetAutoLayout(True)
+
+        # introduce buttonpanel and viewer to each other
+        self.buttonpanel.viewer = self.viewer
+        self.viewer.buttonpanel = self.buttonpanel
+
+        self.Bind(wx.EVT_BUTTON, self.OnLoadButton, loadbutton)
+
+    def OnLoadButton(self, event):
+        dlg = wx.FileDialog(self, wildcard="*.pdf")
+        if dlg.ShowModal() == wx.ID_OK:
+            wx.BeginBusyCursor()
+            self.viewer.LoadFile(dlg.GetPath())
+            wx.EndBusyCursor()
+        dlg.Destroy()
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+    if havePyPdf:
+        win = TestPanel(nb, log)
+        return win
+    else:
+        from wx.lib.msgpanel import MessagePanel
+        win = MessagePanel(nb,
+                           'This demo requires either the\n'
+                           'PyMuPDF see http://pythonhosted.org/PyMuPDF\n'
+                           'or\n'
+                           'PyPDF2 see http://pythonhosted.org/PyPDF2\n'
+                           'package installed.\n',
+                           'Sorry', wx.ICON_WARNING)
+        return win
+
+overview = """\
+<html><body>
+<h2>wx.lib.pdfviewer</h2>
+
+The wx.lib.pdfviewer.pdfViewer class is derived from wx.ScrolledWindow
+and can display and print PDF files. The whole file can be scrolled from
+end to end at whatever magnification (zoom-level) is specified.
+
+<p> The viewer checks for the <b>PyMuPDF</b> then the <b>PyPDF2</b> package.
+If neither are installed an import error exception will be raised.
+
+<p>PyMuPDF contains the Python bindings for the underlying MuPDF library, a cross platform,
+complete PDF rendering library that is GPL licenced. PyMuPDF version 1.9.2 or later is required.
+
+<p>Further details on PyMuPDF can be found via http://pythonhosted.org/PyMuPDF
+
+<p>PyPDF2 provides a PdfFileReader class that is used to read the content stream of a PDF
+file which is subsequently rendered by the viewer itself.
+Please note that this is not a complete implementation of the pdf specification and
+will probably fail to render any random PDF file you supply. However it does seem to
+behave correctly with files that have been produced by ReportLab using Western languages.
+The main limitation is that it doesn't currently support embedded fonts.
+
+<p>Additional details on PyPDF2 can be found via http://pythonhosted.org/PyPDF2
+
+<p> There is an optional pdfButtonPanel class, derived from wx.lib.agw.buttonpanel,
+that can be placed, for example, at the top of the scrolled viewer window,
+and which contains navigation and zoom controls.
+
+<p>Alternatively you can drive the viewer from controls in your own application.
+Externally callable methods are: LoadFile, Save, Print, SetZoom, and GoPage.
+(See pdfviewer.__init__.py)
+
+<p> The viewer renders the pdf file content using Cairo if installed,
+otherwise wx.GraphicsContext is used. Printing is achieved by writing
+directly to a wx.PrintDC and using wx.Printer.
+
+</body></html>
+"""
+
+#----------------------------------------------------------------------
+
+if __name__ == '__main__':
+    import sys,os
+    import run
+    run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
+

wx/demo/PageSetupDialog.py

@@ -0,0 +1,70 @@
+#!/usr/bin/env python
+
+import wx
+
+#---------------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+    def __init__(self, parent, log):
+        self.log = log
+        wx.Panel.__init__(self, parent, -1)
+
+        b = wx.Button(self, -1, "Create and Show a PageSetupDialog", (50,50))
+        self.Bind(wx.EVT_BUTTON, self.OnButton, b)
+
+
+    def OnButton(self, evt):
+        data = wx.PageSetupDialogData()
+        data.SetMarginTopLeft( (15, 15) )
+        data.SetMarginBottomRight( (15, 15) )
+        #data.SetDefaultMinMargins(True)
+        data.SetPaperId(wx.PAPER_LETTER)
+
+        dlg = wx.PageSetupDialog(self, data)
+
+        if dlg.ShowModal() == wx.ID_OK:
+            data = dlg.GetPageSetupData()
+            tl = data.GetMarginTopLeft()
+            br = data.GetMarginBottomRight()
+            self.log.WriteText('Margins are: %s %s\n' % (str(tl), str(br)))
+
+        dlg.Destroy()
+
+
+#---------------------------------------------------------------------------
+
+
+def runTest(frame, nb, log):
+    win = TestPanel(nb, log)
+    return win
+
+
+#---------------------------------------------------------------------------
+
+
+overview = """\
+This class represents the page setup common dialog. The page setup dialog is standard
+from Windows 95 on, replacing the print setup dialog (which is retained in Windows
+and wxWindows for backward compatibility). On Windows 95 and NT 4.0 and above,
+the page setup dialog is native to the windowing system, otherwise it is emulated.
+
+The page setup dialog contains controls for paper size (A4, A5 etc.), orientation
+(landscape or portrait), and controls for setting left, top, right and bottom margin
+sizes in millimetres.
+
+When the dialog has been closed, you need to query the <code>wx.PageSetupDialogData</code> object
+associated with the dialog.
+
+Note that the OK and Cancel buttons do not destroy the dialog; this must be done by
+the application. As with other dialogs, do not destroy the dialog until you are done
+with the data, and, conversely, do not use the wx.PageSetupDialogData after the
+dialog is destroyed.
+
+
+"""
+
+
+if __name__ == '__main__':
+    import sys,os
+    import run
+    run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])

wx/demo/PenAndBrushStyles.py

@@ -0,0 +1,208 @@
+#!/usr/bin/env python
+# (c) 2021 Zombie
+
+import wx
+import images
+
+
+pen_styles = [#"wx.PENSTYLE_INVALID",
+              "wx.PENSTYLE_SOLID",
+              "wx.PENSTYLE_DOT",
+              "wx.PENSTYLE_LONG_DASH",
+              "wx.PENSTYLE_SHORT_DASH",
+              "wx.PENSTYLE_DOT_DASH",
+              "wx.PENSTYLE_USER_DASH",
+              "wx.PENSTYLE_TRANSPARENT",
+              "wx.PENSTYLE_BDIAGONAL_HATCH",
+              "wx.PENSTYLE_CROSSDIAG_HATCH",
+              "wx.PENSTYLE_FDIAGONAL_HATCH",
+              "wx.PENSTYLE_CROSS_HATCH",
+              "wx.PENSTYLE_HORIZONTAL_HATCH",
+              "wx.PENSTYLE_VERTICAL_HATCH",
+              "wx.PENSTYLE_FIRST_HATCH",
+              "wx.PENSTYLE_LAST_HATCH"
+              ]
+
+if 'wxMSW' in wx.PlatformInfo:
+    pen_styles.append("wx.PENSTYLE_STIPPLE_MASK_OPAQUE")
+    pen_styles.append("wx.PENSTYLE_STIPPLE_MASK")
+    pen_styles.append("wx.PENSTYLE_STIPPLE")
+
+brush_styles = [#"wx.BRUSHSTYLE_INVALID",
+                "wx.BRUSHSTYLE_SOLID",
+                "wx.BRUSHSTYLE_TRANSPARENT",
+                "wx.BRUSHSTYLE_STIPPLE_MASK_OPAQUE",
+                "wx.BRUSHSTYLE_STIPPLE_MASK",
+                "wx.BRUSHSTYLE_STIPPLE",
+                "wx.BRUSHSTYLE_BDIAGONAL_HATCH",
+                "wx.BRUSHSTYLE_CROSSDIAG_HATCH",
+                "wx.BRUSHSTYLE_FDIAGONAL_HATCH",
+                "wx.BRUSHSTYLE_CROSS_HATCH",
+                "wx.BRUSHSTYLE_HORIZONTAL_HATCH",
+                "wx.BRUSHSTYLE_VERTICAL_HATCH",
+                "wx.BRUSHSTYLE_FIRST_HATCH",
+                "wx.BRUSHSTYLE_LAST_HATCH"
+                ]
+
+class BasePanel(wx.Panel):
+    def __init__(self, parent):
+        wx.Panel.__init__(self, parent, style=wx.SUNKEN_BORDER|wx.WANTS_CHARS)
+
+        self.SetBackgroundStyle(wx.BG_STYLE_CUSTOM)
+
+        self.Bind(wx.EVT_SIZE, self.OnSize)
+        self.Bind(wx.EVT_PAINT, self.OnPaint)
+
+
+    def OnSize(self, event):
+        event.Skip()
+        self.Refresh()
+
+
+class PenPanel(BasePanel):
+
+    def __init__(self, parent, pen_name):
+        BasePanel.__init__(self, parent)
+        self.pen_name = pen_name
+
+
+    def OnPaint(self, event):
+        width, height = self.GetClientSize()
+
+        dc = wx.AutoBufferedPaintDC(self)
+        dc.SetBackground(wx.WHITE_BRUSH)
+        dc.Clear()
+
+        font = wx.SystemSettings.GetFont(wx.SYS_DEFAULT_GUI_FONT)
+        font.MakeSmaller()
+        dc.SetFont(font)
+        w, labelHeight = dc.GetTextExtent('Wy')
+
+        name = self.pen_name
+
+        if "STIPPLE" in name:
+            bmp = images.Smiles.GetBitmap()
+            penWidth = 8 #bmp.GetHeight()
+            pen = wx.Pen(wx.BLUE, penWidth, eval(name))
+            pen.SetStipple(bmp)
+        else:
+            penWidth = 3
+            if 'HATCH' in name:
+                penWidth = 8
+            pen = wx.Pen(wx.BLUE, penWidth, eval(name))
+
+        if "USER" in name:
+            # dash values represent units on, off, on. off...
+            pen.SetDashes([2, 5, 2, 2])
+            name += " ([2, 5, 2, 2])"
+
+        dc.SetTextForeground(wx.BLACK)
+        dc.DrawText(name, 1, 1)
+
+        dc.SetPen(pen)
+        y = labelHeight + (height - labelHeight) // 2
+        dc.DrawLine(5, y, width-5, y)
+
+
+class BrushPanel(BasePanel):
+    def __init__(self, parent, brush_name):
+        BasePanel.__init__(self, parent)
+        self.brush_name = brush_name
+
+
+    def OnPaint(self, event):
+        width, height = self.GetClientSize()
+
+        dc = wx.AutoBufferedPaintDC(self)
+        dc.SetBackground(wx.WHITE_BRUSH)
+        dc.Clear()
+
+        font = wx.SystemSettings.GetFont(wx.SYS_DEFAULT_GUI_FONT)
+        font.MakeSmaller()
+        dc.SetFont(font)
+        w, labelHeight = dc.GetTextExtent('Wy')
+
+        dc.SetPen(wx.TRANSPARENT_PEN)
+        name = self.brush_name
+
+        if "STIPPLE" in name:
+            bmp = images.Smiles.GetBitmap()
+            bmp.SetMask(None)
+            brush = wx.Brush(bmp)
+        else:
+            brush = wx.Brush(wx.BLUE, eval(name))
+
+        dc.SetTextForeground(wx.BLACK)
+        dc.DrawText(name, 1, 1)
+
+        dc.SetBrush(brush)
+        dc.DrawRectangle(5, labelHeight+2, width-10, height-labelHeight-5-2)
+
+
+
+class TestPanel(wx.Panel):
+    def __init__(self, *args, **kw):
+        wx.Panel.__init__(self, *args, **kw)
+
+        font = wx.SystemSettings.GetFont(wx.SYS_DEFAULT_GUI_FONT)
+        font.SetWeight(wx.FONTWEIGHT_BOLD)
+
+        mainSizer = wx.BoxSizer(wx.VERTICAL)
+        label1 = wx.StaticText(self, -1, "Pen Styles:")
+        label1.SetFont(font)
+
+        mainSizer.Add(label1, 0, wx.EXPAND|wx.ALL, 10)
+
+        gs1 = wx.GridSizer(rows=5, cols=4, vgap=3, hgap=3)
+
+        for pen_name in pen_styles:
+            small = PenPanel(self, pen_name)
+            gs1.Add(small, 0, wx.EXPAND)
+
+        mainSizer.Add(gs1, 1, wx.EXPAND|wx.LEFT|wx.RIGHT|wx.BOTTOM, 10)
+
+        label2 = wx.StaticText(self, -1, "Brush Styles:")
+        label2.SetFont(font)
+
+        mainSizer.Add(label2, 0, wx.EXPAND|wx.ALL, 10)
+
+        gs2 = wx.GridSizer(rows=4, cols=4, vgap=3, hgap=3)
+
+        for brush_name in brush_styles:
+            small = BrushPanel(self, brush_name)
+            gs2.Add(small, 0, wx.EXPAND)
+
+        mainSizer.Add(gs2, 1, wx.EXPAND|wx.LEFT|wx.RIGHT|wx.BOTTOM, 10)
+
+        self.SetSizer(mainSizer)
+
+
+
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+    win = TestPanel(nb)
+    return win
+
+#----------------------------------------------------------------------
+
+
+
+overview = """<html><body>
+<h2><center>Pen and Brush Styles</center></h2>
+
+This sample shows an e3xample of drawing with each of the available
+wx.Pen and wx.Brush styles.
+
+</body></html>
+"""
+
+
+if __name__ == '__main__':
+    import sys,os
+    import run
+    run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+
+
+

wx/demo/Pickers.py

@@ -0,0 +1,120 @@
+#!/usr/bin/env python
+
+import wx
+
+#----------------------------------------------------------------------
+
+class TestPanel(wx.Panel):
+    def __init__(self, parent, log):
+        self.log = log
+        wx.Panel.__init__(self, parent, -1)
+
+        box = wx.BoxSizer(wx.VERTICAL)
+        title = wx.StaticText(self, -1, "Picker Controls")
+        title.SetFont(wx.FFont(24, wx.FONTFAMILY_SWISS, wx.FONTFLAG_BOLD))
+        title.SetForegroundColour("navy")
+        box.Add(title, 0, wx.ALIGN_CENTER|wx.ALL, 5)
+        #print(title.GetBestSize(), title.GetMinSize(), title.GetSize())
+
+        box.Add(wx.StaticLine(self), 0, wx.EXPAND)
+
+        fgs = wx.FlexGridSizer(cols=4, hgap=5, vgap=5)
+        fgs.AddGrowableCol(3)
+        fgs.Add((10,10))  # spacer
+        lbl = wx.StaticText(self, -1, "default style")
+        lbl.SetFont(wx.FFont(12, wx.FONTFAMILY_SWISS, wx.FONTFLAG_BOLD))
+        fgs.Add(lbl)
+        fgs.Add((10,10))  # spacer
+        lbl = wx.StaticText(self, -1, "with textctrl")
+        lbl.SetFont(wx.FFont(12, wx.FONTFAMILY_SWISS, wx.FONTFLAG_BOLD))
+        fgs.Add(lbl, 0, wx.ALIGN_CENTER)
+
+        fgs.Add(wx.StaticText(self, -1, "wx.ColourPickerCtrl:"), 0, wx.ALIGN_CENTER_VERTICAL)
+        cp1 = wx.ColourPickerCtrl(self)
+        fgs.Add(cp1, 0, wx.ALIGN_CENTER)
+        fgs.Add((10,10))  # spacer
+        cp2 = wx.ColourPickerCtrl(self, style=wx.CLRP_USE_TEXTCTRL)
+        cp2.SetTextCtrlProportion(5)
+        fgs.Add(cp2, 0, wx.EXPAND)
+        fgs.Add(wx.StaticText(self, -1, "        with label:"), 0, wx.ALIGN_CENTER_VERTICAL)
+        cp3 = wx.ColourPickerCtrl(self, style=wx.CLRP_SHOW_LABEL)
+        fgs.Add(cp3, 0, wx.ALIGN_CENTER)
+        fgs.Add((10,10))  # spacer
+        fgs.Add((10,10))  # spacer
+        self.Bind(wx.EVT_COLOURPICKER_CHANGED, self.OnPickColor, cp1)
+        self.Bind(wx.EVT_COLOURPICKER_CHANGED, self.OnPickColor, cp2)
+        self.Bind(wx.EVT_COLOURPICKER_CHANGED, self.OnPickColor, cp3)
+
+        fgs.Add(wx.StaticText(self, -1, "wx.DirPickerCtrl:"), 0, wx.ALIGN_CENTER_VERTICAL)
+        dp1 = wx.DirPickerCtrl(self)
+        fgs.Add(dp1, 0, wx.ALIGN_CENTER)
+        fgs.Add((10,10))  # spacer
+        dp2 = wx.DirPickerCtrl(self, style=wx.DIRP_USE_TEXTCTRL)
+        dp2.SetTextCtrlProportion(2)
+        fgs.Add(dp2, 0, wx.EXPAND)
+        self.Bind(wx.EVT_DIRPICKER_CHANGED, self.OnPickFileDir, dp1)
+        self.Bind(wx.EVT_DIRPICKER_CHANGED, self.OnPickFileDir, dp2)
+
+        fgs.Add(wx.StaticText(self, -1, "wx.FilePickerCtrl:"), 0, wx.ALIGN_CENTER_VERTICAL)
+        fp1 = wx.FilePickerCtrl(self)
+        fgs.Add(fp1, 0, wx.ALIGN_CENTER)
+        fgs.Add((10,10))  # spacer
+        fp2 = wx.FilePickerCtrl(self, style=wx.FLP_USE_TEXTCTRL)
+        fp2.SetTextCtrlProportion(2)
+        fgs.Add(fp2, 0, wx.EXPAND)
+        self.Bind(wx.EVT_FILEPICKER_CHANGED, self.OnPickFileDir, fp1)
+        self.Bind(wx.EVT_FILEPICKER_CHANGED, self.OnPickFileDir, fp2)
+
+        fgs.Add(wx.StaticText(self, -1, "wx.FontPickerCtrl:"), 0, wx.ALIGN_CENTER_VERTICAL)
+        fnt1 = wx.FontPickerCtrl(self, style=wx.FNTP_FONTDESC_AS_LABEL)
+        fgs.Add(fnt1, 0, wx.ALIGN_CENTER)
+        fgs.Add((10,10))  # spacer
+        fnt2 = wx.FontPickerCtrl(self, style=wx.FNTP_FONTDESC_AS_LABEL|wx.FNTP_USE_TEXTCTRL)
+        fnt2.SetTextCtrlProportion(2)
+        fgs.Add(fnt2, 0, wx.EXPAND)
+        self.Bind(wx.EVT_FONTPICKER_CHANGED, self.OnPickFont, fnt1)
+        self.Bind(wx.EVT_FONTPICKER_CHANGED, self.OnPickFont, fnt2)
+
+
+        box.Add(fgs, 1, wx.EXPAND|wx.ALL, 5)
+        self.SetSizer(box)
+
+
+    def OnPickColor(self, evt):
+        self.log.write("You chose: %s\n" % repr(evt.GetColour()))
+
+    def OnPickFileDir(self, evt):
+        self.log.write("You chose: %s\n" % repr(evt.GetPath()))
+
+    def OnPickFont(self, evt):
+        font = evt.GetFont()
+        self.log.write("You chose: %s\n" % font.GetNativeFontInfoUserDesc())
+
+#----------------------------------------------------------------------
+
+def runTest(frame, nb, log):
+    win = TestPanel(nb, log)
+    return win
+
+#----------------------------------------------------------------------
+
+
+
+overview = """<html><body>
+<h2><center>Picker Controls</center></h2>
+
+The Picker controls are either native or generic controls usually
+comprised of a button and with an optional text control next to it.
+The pickers enable the user to choose something using one of the
+common dialogs and then displays the result in some way.
+
+</body></html>
+"""
+
+
+
+if __name__ == '__main__':
+    import sys,os
+    import run
+    run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
+