| | 1 | |
| | 2 | import wx |
| | 3 | import images |
| | 4 | |
| | 5 | #--------------------------------------------------------------------------- |
| | 6 | |
| | 7 | class TestToolBar(wx.Frame): |
| | 8 | def __init__(self, parent, log): |
| | 9 | wx.Frame.__init__(self, parent, -1, 'Test ToolBar', size=(500, 300)) |
| | 10 | self.log = log |
| | 11 | self.timer = None |
| | 12 | self.Bind(wx.EVT_CLOSE, self.OnCloseWindow) |
| | 13 | |
| | 14 | wx.Window(self, -1).SetBackgroundColour(wx.NamedColour("WHITE")) |
| | 15 | |
| | 16 | # Use the wxFrame internals to create the toolbar and associate it all |
| | 17 | # in one tidy method call. |
| | 18 | tb = self.CreateToolBar( wx.TB_HORIZONTAL |
| | 19 | | wx.NO_BORDER |
| | 20 | | wx.TB_FLAT |
| | 21 | #| wx.TB_TEXT |
| | 22 | ) |
| | 23 | |
| | 24 | # Here's a 'simple' toolbar example, and how to bind it using SetToolBar() |
| | 25 | #tb = wx.ToolBarSimple(self, -1, wx.DefaultPosition, wx.DefaultSize, |
| | 26 | # wx.TB_HORIZONTAL | wx.NO_BORDER | wx.TB_FLAT) |
| | 27 | #self.SetToolBar(tb) |
| | 28 | # But we're doing it a different way here. |
| | 29 | |
| | 30 | log.write("Default toolbar tool size: %s\n" % tb.GetToolBitmapSize()) |
| | 31 | |
| | 32 | self.CreateStatusBar() |
| | 33 | |
| | 34 | tsize = (16,16) |
| | 35 | new_bmp = wx.ArtProvider.GetBitmap(wx.ART_NEW, wx.ART_TOOLBAR, tsize) |
| | 36 | open_bmp = wx.ArtProvider.GetBitmap(wx.ART_FILE_OPEN, wx.ART_TOOLBAR, tsize) |
| | 37 | copy_bmp = wx.ArtProvider.GetBitmap(wx.ART_COPY, wx.ART_TOOLBAR, tsize) |
| | 38 | paste_bmp= wx.ArtProvider.GetBitmap(wx.ART_PASTE, wx.ART_TOOLBAR, tsize) |
| | 39 | |
| | 40 | tb.SetToolBitmapSize(tsize) |
| | 41 | |
| | 42 | tb.AddSimpleTool(10, new_bmp, "New", "Long help for 'New'") |
| | 43 | #tb.AddLabelTool(10, "New", new_bmp, shortHelp="New", longHelp="Long help for 'New'") |
| | 44 | self.Bind(wx.EVT_TOOL, self.OnToolClick, id=10) |
| | 45 | self.Bind(wx.EVT_TOOL_RCLICKED, self.OnToolRClick, id=10) |
| | 46 | |
| | 47 | tb.AddSimpleTool(20, open_bmp, "Open", "Long help for 'Open'") |
| | 48 | self.Bind(wx.EVT_TOOL, self.OnToolClick, id=20) |
| | 49 | self.Bind(wx.EVT_TOOL_RCLICKED, self.OnToolRClick, id=20) |
| | 50 | |
| | 51 | tb.AddSeparator() |
| | 52 | tb.AddSimpleTool(30, copy_bmp, "Copy", "Long help for 'Copy'") |
| | 53 | self.Bind(wx.EVT_TOOL, self.OnToolClick, id=30) |
| | 54 | self.Bind(wx.EVT_TOOL_RCLICKED, self.OnToolRClick, id=30) |
| | 55 | |
| | 56 | tb.AddSimpleTool(40, paste_bmp, "Paste", "Long help for 'Paste'") |
| | 57 | self.Bind(wx.EVT_TOOL, self.OnToolClick, id=40) |
| | 58 | self.Bind(wx.EVT_TOOL_RCLICKED, self.OnToolRClick, id=40) |
| | 59 | |
| | 60 | tb.AddSeparator() |
| | 61 | |
| | 62 | tool = tb.AddCheckTool(50, images.getTog1Bitmap(), |
| | 63 | shortHelp="Toggle this") |
| | 64 | self.Bind(wx.EVT_TOOL, self.OnToolClick, id=50) |
| | 65 | |
| | 66 | ## tb.AddCheckTool(60, images.getTog1Bitmap(), images.getTog2Bitmap(), |
| | 67 | ## shortHelp="Toggle with 2 bitmaps") |
| | 68 | ## self.Bind(EVT_TOOL, self.OnToolClick, id=60) |
| | 69 | |
| | 70 | self.Bind(wx.EVT_TOOL_ENTER, self.OnToolEnter) |
| | 71 | self.Bind(wx.EVT_TOOL_RCLICKED, self.OnToolRClick) # Match all |
| | 72 | self.Bind(wx.EVT_TIMER, self.OnClearSB) |
| | 73 | |
| | 74 | tb.AddSeparator() |
| | 75 | cbID = wx.NewId() |
| | 76 | |
| | 77 | tb.AddControl( |
| | 78 | wx.ComboBox( |
| | 79 | tb, cbID, "", choices=["", "This", "is a", "wxComboBox"], |
| | 80 | size=(150,-1), style=wx.CB_DROPDOWN |
| | 81 | )) |
| | 82 | |
| | 83 | self.Bind(wx.EVT_COMBOBOX, self.OnCombo, id=cbID) |
| | 84 | tb.AddControl(wx.TextCtrl(tb, -1, "Toolbar controls!!", size=(150, -1))) |
| | 85 | |
| | 86 | # Final thing to do for a toolbar is call the Realize() method. This |
| | 87 | # causes it to render (more or less, that is). |
| | 88 | tb.Realize() |
| | 89 | |
| | 90 | |
| | 91 | def OnToolClick(self, event): |
| | 92 | self.log.WriteText("tool %s clicked\n" % event.GetId()) |
| | 93 | tb = self.GetToolBar() |
| | 94 | tb.EnableTool(10, not tb.GetToolEnabled(10)) |
| | 95 | |
| | 96 | def OnToolRClick(self, event): |
| | 97 | self.log.WriteText("tool %s right-clicked\n" % event.GetId()) |
| | 98 | |
| | 99 | def OnCombo(self, event): |
| | 100 | self.log.WriteText("combobox item selected: %s\n" % event.GetString()) |
| | 101 | |
| | 102 | def OnToolEnter(self, event): |
| | 103 | self.log.WriteText('OnToolEnter: %s, %s\n' % (event.GetId(), event.GetInt())) |
| | 104 | |
| | 105 | if self.timer is None: |
| | 106 | self.timer = wx.Timer(self) |
| | 107 | |
| | 108 | if self.timer.IsRunning(): |
| | 109 | self.timer.Stop() |
| | 110 | |
| | 111 | self.timer.Start(2000) |
| | 112 | event.Skip() |
| | 113 | |
| | 114 | |
| | 115 | def OnClearSB(self, event): # called for the timer event handler |
| | 116 | self.SetStatusText("") |
| | 117 | self.timer.Stop() |
| | 118 | self.timer = None |
| | 119 | |
| | 120 | |
| | 121 | def OnCloseWindow(self, event): |
| | 122 | if self.timer is not None: |
| | 123 | self.timer.Stop() |
| | 124 | self.timer = None |
| | 125 | self.Destroy() |
| | 126 | |
| | 127 | #--------------------------------------------------------------------------- |
| | 128 | |
| | 129 | class TestPanel(wx.Panel): |
| | 130 | def __init__(self, parent, log): |
| | 131 | self.log = log |
| | 132 | wx.Panel.__init__(self, parent, -1) |
| | 133 | |
| | 134 | b = wx.Button(self, -1, "Show the ToolBar sample", (50,50)) |
| | 135 | self.Bind(wx.EVT_BUTTON, self.OnButton, b) |
| | 136 | |
| | 137 | |
| | 138 | def OnButton(self, evt): |
| | 139 | win = TestToolBar(self, self.log) |
| | 140 | win.Show(True) |
| | 141 | |
| | 142 | |
| | 143 | #--------------------------------------------------------------------------- |
| | 144 | |
| | 145 | |
| | 146 | def runTest(frame, nb, log): |
| | 147 | win = TestPanel(nb, log) |
| | 148 | return win |
| | 149 | |
| | 150 | #--------------------------------------------------------------------------- |
| | 151 | |
| | 152 | |
| | 153 | |
| | 154 | |
| | 155 | overview = """\ |
| | 156 | wx.ToolBar is a narrow strip of icons on one side of a frame (top, bottom, sides) |
| | 157 | that acts much like a menu does, except it is always visible. Additionally, actual |
| | 158 | wxWindows controls, such as wx.TextCtrl or wx.ComboBox, can be added to the toolbar |
| | 159 | and used from within it. |
| | 160 | |
| | 161 | Toolbar creation is a two-step process. First, the toolbar is defined using the |
| | 162 | various Add* methods of wx.ToolBar. Once all is set up, then wx.Toolbar.Realize() |
| | 163 | must be called to render it. |
| | 164 | |
| | 165 | wx.Toolbar events are also propogated as Menu events; this is especially handy when |
| | 166 | you have a menu bar that contains items that carry out the same function. For example, |
| | 167 | it is not uncommon to have a little 'floppy' toolbar icon to 'save' the current file |
| | 168 | (whatever it is) as well as a FILE/SAVE menu item that does the same thing. In this |
| | 169 | case, both events can be captured and acted upon using the same event handler |
| | 170 | with no ill effects. |
| | 171 | |
| | 172 | If there are cases where a toolbar icon should *not* be associated with a menu item, |
| | 173 | use a unique ID to trap it. |
| | 174 | |
| | 175 | There are a number of ways to create a toolbar for a wx.Frame. wx.Frame.CreateToolBar() |
| | 176 | does all the work except it adds no buttons at all unless you override the virtual method |
| | 177 | OnCreateToolBar(). On the other hand, you can just subclass wx.ToolBar and then use |
| | 178 | wx.Frame.SetToolBar() instead. |
| | 179 | |
| | 180 | Note that wx.TB_DOCKABLE is only supported under GTK. An attempt to alleviate this |
| | 181 | is provided in wx.lib.floatbar, but it is not formally supported. |
| | 182 | """ |
| | 183 | |
| | 184 | |
| | 185 | if __name__ == '__main__': |
| | 186 | import sys,os |
| | 187 | import run |
| | 188 | run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:]) |
| | 189 | |
projects / wxWidgets.git / blame_incremental