]>
Commit | Line | Data |
---|---|---|
1 | ///////////////////////////////////////////////////////////////////////////// | |
2 | // Name: wx/tbarbase.h | |
3 | // Purpose: Base class for toolbar classes | |
4 | // Author: Julian Smart | |
5 | // Modified by: | |
6 | // Created: 01/02/97 | |
7 | // RCS-ID: $Id$ | |
8 | // Copyright: (c) Julian Smart | |
9 | // Licence: wxWindows licence | |
10 | ///////////////////////////////////////////////////////////////////////////// | |
11 | ||
12 | #ifndef _WX_TBARBASE_H_ | |
13 | #define _WX_TBARBASE_H_ | |
14 | ||
15 | // ---------------------------------------------------------------------------- | |
16 | // headers | |
17 | // ---------------------------------------------------------------------------- | |
18 | ||
19 | #include "wx/defs.h" | |
20 | ||
21 | #if wxUSE_TOOLBAR | |
22 | ||
23 | #include "wx/bitmap.h" | |
24 | #include "wx/list.h" | |
25 | #include "wx/control.h" | |
26 | ||
27 | class WXDLLEXPORT wxToolBarBase; | |
28 | class WXDLLEXPORT wxToolBarToolBase; | |
29 | class WXDLLEXPORT wxImage; | |
30 | ||
31 | // ---------------------------------------------------------------------------- | |
32 | // constants | |
33 | // ---------------------------------------------------------------------------- | |
34 | ||
35 | extern WXDLLEXPORT_DATA(const wxChar*) wxToolBarNameStr; | |
36 | extern WXDLLEXPORT_DATA(const wxSize) wxDefaultSize; | |
37 | extern WXDLLEXPORT_DATA(const wxPoint) wxDefaultPosition; | |
38 | ||
39 | enum wxToolBarToolStyle | |
40 | { | |
41 | wxTOOL_STYLE_BUTTON = 1, | |
42 | wxTOOL_STYLE_SEPARATOR = 2, | |
43 | wxTOOL_STYLE_CONTROL | |
44 | }; | |
45 | ||
46 | // ---------------------------------------------------------------------------- | |
47 | // wxToolBarTool is a toolbar element. | |
48 | // | |
49 | // It has a unique id (except for the separators which always have id wxID_ANY), the | |
50 | // style (telling whether it is a normal button, separator or a control), the | |
51 | // state (toggled or not, enabled or not) and short and long help strings. The | |
52 | // default implementations use the short help string for the tooltip text which | |
53 | // is popped up when the mouse pointer enters the tool and the long help string | |
54 | // for the applications status bar. | |
55 | // ---------------------------------------------------------------------------- | |
56 | ||
57 | class WXDLLEXPORT wxToolBarToolBase : public wxObject | |
58 | { | |
59 | public: | |
60 | // ctors & dtor | |
61 | // ------------ | |
62 | ||
63 | wxToolBarToolBase(wxToolBarBase *tbar = (wxToolBarBase *)NULL, | |
64 | int toolid = wxID_SEPARATOR, | |
65 | const wxString& label = wxEmptyString, | |
66 | const wxBitmap& bmpNormal = wxNullBitmap, | |
67 | const wxBitmap& bmpDisabled = wxNullBitmap, | |
68 | wxItemKind kind = wxITEM_NORMAL, | |
69 | wxObject *clientData = (wxObject *) NULL, | |
70 | const wxString& shortHelpString = wxEmptyString, | |
71 | const wxString& longHelpString = wxEmptyString) | |
72 | : m_label(label), | |
73 | m_shortHelpString(shortHelpString), | |
74 | m_longHelpString(longHelpString) | |
75 | { | |
76 | m_tbar = tbar; | |
77 | m_id = toolid; | |
78 | if (m_id == wxID_ANY) | |
79 | m_id = wxNewId(); | |
80 | m_clientData = clientData; | |
81 | ||
82 | m_bmpNormal = bmpNormal; | |
83 | m_bmpDisabled = bmpDisabled; | |
84 | ||
85 | m_kind = kind; | |
86 | ||
87 | m_enabled = true; | |
88 | m_toggled = false; | |
89 | ||
90 | m_toolStyle = toolid == wxID_SEPARATOR ? wxTOOL_STYLE_SEPARATOR | |
91 | : wxTOOL_STYLE_BUTTON; | |
92 | } | |
93 | ||
94 | wxToolBarToolBase(wxToolBarBase *tbar, wxControl *control) | |
95 | { | |
96 | m_tbar = tbar; | |
97 | m_control = control; | |
98 | m_id = control->GetId(); | |
99 | ||
100 | m_kind = wxITEM_MAX; // invalid value | |
101 | ||
102 | m_enabled = true; | |
103 | m_toggled = false; | |
104 | ||
105 | m_toolStyle = wxTOOL_STYLE_CONTROL; | |
106 | } | |
107 | ||
108 | ~wxToolBarToolBase(){} | |
109 | ||
110 | // accessors | |
111 | // --------- | |
112 | ||
113 | // general | |
114 | int GetId() const { return m_id; } | |
115 | ||
116 | wxControl *GetControl() const | |
117 | { | |
118 | wxASSERT_MSG( IsControl(), _T("this toolbar tool is not a control") ); | |
119 | ||
120 | return m_control; | |
121 | } | |
122 | ||
123 | wxToolBarBase *GetToolBar() const { return m_tbar; } | |
124 | ||
125 | // style | |
126 | bool IsButton() const { return m_toolStyle == wxTOOL_STYLE_BUTTON; } | |
127 | bool IsControl() const { return m_toolStyle == wxTOOL_STYLE_CONTROL; } | |
128 | bool IsSeparator() const { return m_toolStyle == wxTOOL_STYLE_SEPARATOR; } | |
129 | int GetStyle() const { return m_toolStyle; } | |
130 | wxItemKind GetKind() const | |
131 | { | |
132 | wxASSERT_MSG( IsButton(), _T("only makes sense for buttons") ); | |
133 | ||
134 | return m_kind; | |
135 | } | |
136 | ||
137 | // state | |
138 | bool IsEnabled() const { return m_enabled; } | |
139 | bool IsToggled() const { return m_toggled; } | |
140 | bool CanBeToggled() const | |
141 | { return m_kind == wxITEM_CHECK || m_kind == wxITEM_RADIO; } | |
142 | ||
143 | // attributes | |
144 | const wxBitmap& GetNormalBitmap() const { return m_bmpNormal; } | |
145 | const wxBitmap& GetDisabledBitmap() const { return m_bmpDisabled; } | |
146 | ||
147 | const wxBitmap& GetBitmap() const | |
148 | { return IsEnabled() ? GetNormalBitmap() : GetDisabledBitmap(); } | |
149 | ||
150 | const wxString& GetLabel() const { return m_label; } | |
151 | ||
152 | const wxString& GetShortHelp() const { return m_shortHelpString; } | |
153 | const wxString& GetLongHelp() const { return m_longHelpString; } | |
154 | ||
155 | wxObject *GetClientData() const | |
156 | { | |
157 | if ( m_toolStyle == wxTOOL_STYLE_CONTROL ) | |
158 | { | |
159 | return (wxObject*)m_control->GetClientData(); | |
160 | } | |
161 | else | |
162 | { | |
163 | return m_clientData; | |
164 | } | |
165 | } | |
166 | ||
167 | // modifiers: return true if the state really changed | |
168 | bool Enable(bool enable); | |
169 | bool Toggle(bool toggle); | |
170 | bool SetToggle(bool toggle); | |
171 | bool SetShortHelp(const wxString& help); | |
172 | bool SetLongHelp(const wxString& help); | |
173 | ||
174 | void Toggle() { Toggle(!IsToggled()); } | |
175 | ||
176 | void SetNormalBitmap(const wxBitmap& bmp) { m_bmpNormal = bmp; } | |
177 | void SetDisabledBitmap(const wxBitmap& bmp) { m_bmpDisabled = bmp; } | |
178 | ||
179 | virtual void SetLabel(const wxString& label) { m_label = label; } | |
180 | ||
181 | void SetClientData(wxObject *clientData) | |
182 | { | |
183 | if ( m_toolStyle == wxTOOL_STYLE_CONTROL ) | |
184 | { | |
185 | m_control->SetClientData(clientData); | |
186 | } | |
187 | else | |
188 | { | |
189 | m_clientData = clientData; | |
190 | } | |
191 | } | |
192 | ||
193 | // add tool to/remove it from a toolbar | |
194 | virtual void Detach() { m_tbar = (wxToolBarBase *)NULL; } | |
195 | virtual void Attach(wxToolBarBase *tbar) { m_tbar = tbar; } | |
196 | ||
197 | protected: | |
198 | wxToolBarBase *m_tbar; // the toolbar to which we belong (may be NULL) | |
199 | ||
200 | // tool parameters | |
201 | int m_toolStyle; // see enum wxToolBarToolStyle | |
202 | int m_id; // the tool id, wxID_SEPARATOR for separator | |
203 | wxItemKind m_kind; // for normal buttons may be wxITEM_NORMAL/CHECK/RADIO | |
204 | ||
205 | // as controls have their own client data, no need to waste memory | |
206 | union | |
207 | { | |
208 | wxObject *m_clientData; | |
209 | wxControl *m_control; | |
210 | }; | |
211 | ||
212 | // tool state | |
213 | bool m_toggled; | |
214 | bool m_enabled; | |
215 | ||
216 | // normal and disabled bitmaps for the tool, both can be invalid | |
217 | wxBitmap m_bmpNormal; | |
218 | wxBitmap m_bmpDisabled; | |
219 | ||
220 | // the button label | |
221 | wxString m_label; | |
222 | ||
223 | // short and long help strings | |
224 | wxString m_shortHelpString; | |
225 | wxString m_longHelpString; | |
226 | ||
227 | DECLARE_DYNAMIC_CLASS_NO_COPY(wxToolBarToolBase) | |
228 | }; | |
229 | ||
230 | // a list of toolbar tools | |
231 | WX_DECLARE_EXPORTED_LIST(wxToolBarToolBase, wxToolBarToolsList); | |
232 | ||
233 | // ---------------------------------------------------------------------------- | |
234 | // the base class for all toolbars | |
235 | // ---------------------------------------------------------------------------- | |
236 | ||
237 | class WXDLLEXPORT wxToolBarBase : public wxControl | |
238 | { | |
239 | public: | |
240 | wxToolBarBase(); | |
241 | virtual ~wxToolBarBase(); | |
242 | ||
243 | // toolbar construction | |
244 | // -------------------- | |
245 | ||
246 | // the full AddTool() function | |
247 | // | |
248 | // If bmpDisabled is wxNullBitmap, a shadowed version of the normal bitmap | |
249 | // is created and used as the disabled image. | |
250 | wxToolBarToolBase *AddTool(int toolid, | |
251 | const wxString& label, | |
252 | const wxBitmap& bitmap, | |
253 | const wxBitmap& bmpDisabled, | |
254 | wxItemKind kind = wxITEM_NORMAL, | |
255 | const wxString& shortHelp = wxEmptyString, | |
256 | const wxString& longHelp = wxEmptyString, | |
257 | wxObject *data = NULL) | |
258 | { | |
259 | return DoAddTool(toolid, label, bitmap, bmpDisabled, kind, | |
260 | shortHelp, longHelp, data); | |
261 | } | |
262 | ||
263 | // the most common AddTool() version | |
264 | wxToolBarToolBase *AddTool(int toolid, | |
265 | const wxString& label, | |
266 | const wxBitmap& bitmap, | |
267 | const wxString& shortHelp = wxEmptyString, | |
268 | wxItemKind kind = wxITEM_NORMAL) | |
269 | { | |
270 | return AddTool(toolid, label, bitmap, wxNullBitmap, kind, shortHelp); | |
271 | } | |
272 | ||
273 | // add a check tool, i.e. a tool which can be toggled | |
274 | wxToolBarToolBase *AddCheckTool(int toolid, | |
275 | const wxString& label, | |
276 | const wxBitmap& bitmap, | |
277 | const wxBitmap& bmpDisabled = wxNullBitmap, | |
278 | const wxString& shortHelp = wxEmptyString, | |
279 | const wxString& longHelp = wxEmptyString, | |
280 | wxObject *data = NULL) | |
281 | { | |
282 | return AddTool(toolid, label, bitmap, bmpDisabled, wxITEM_CHECK, | |
283 | shortHelp, longHelp, data); | |
284 | } | |
285 | ||
286 | // add a radio tool, i.e. a tool which can be toggled and releases any | |
287 | // other toggled radio tools in the same group when it happens | |
288 | wxToolBarToolBase *AddRadioTool(int toolid, | |
289 | const wxString& label, | |
290 | const wxBitmap& bitmap, | |
291 | const wxBitmap& bmpDisabled = wxNullBitmap, | |
292 | const wxString& shortHelp = wxEmptyString, | |
293 | const wxString& longHelp = wxEmptyString, | |
294 | wxObject *data = NULL) | |
295 | { | |
296 | return AddTool(toolid, label, bitmap, bmpDisabled, wxITEM_RADIO, | |
297 | shortHelp, longHelp, data); | |
298 | } | |
299 | ||
300 | ||
301 | // insert the new tool at the given position, if pos == GetToolsCount(), it | |
302 | // is equivalent to AddTool() | |
303 | virtual wxToolBarToolBase *InsertTool | |
304 | ( | |
305 | size_t pos, | |
306 | int toolid, | |
307 | const wxString& label, | |
308 | const wxBitmap& bitmap, | |
309 | const wxBitmap& bmpDisabled = wxNullBitmap, | |
310 | wxItemKind kind = wxITEM_NORMAL, | |
311 | const wxString& shortHelp = wxEmptyString, | |
312 | const wxString& longHelp = wxEmptyString, | |
313 | wxObject *clientData = NULL | |
314 | ); | |
315 | ||
316 | virtual wxToolBarToolBase *AddTool (wxToolBarToolBase *tool); | |
317 | virtual wxToolBarToolBase *InsertTool (size_t pos, wxToolBarToolBase *tool); | |
318 | ||
319 | // add an arbitrary control to the toolbar (notice that | |
320 | // the control will be deleted by the toolbar and that it will also adjust | |
321 | // its position/size) | |
322 | // | |
323 | // NB: the control should have toolbar as its parent | |
324 | virtual wxToolBarToolBase *AddControl(wxControl *control); | |
325 | virtual wxToolBarToolBase *InsertControl(size_t pos, wxControl *control); | |
326 | ||
327 | // get the control with the given id or return NULL | |
328 | virtual wxControl *FindControl( int toolid ); | |
329 | ||
330 | // add a separator to the toolbar | |
331 | virtual wxToolBarToolBase *AddSeparator(); | |
332 | virtual wxToolBarToolBase *InsertSeparator(size_t pos); | |
333 | ||
334 | // remove the tool from the toolbar: the caller is responsible for actually | |
335 | // deleting the pointer | |
336 | virtual wxToolBarToolBase *RemoveTool(int toolid); | |
337 | ||
338 | // delete tool either by index or by position | |
339 | virtual bool DeleteToolByPos(size_t pos); | |
340 | virtual bool DeleteTool(int toolid); | |
341 | ||
342 | // delete all tools | |
343 | virtual void ClearTools(); | |
344 | ||
345 | // must be called after all buttons have been created to finish toolbar | |
346 | // initialisation | |
347 | virtual bool Realize(); | |
348 | ||
349 | // tools state | |
350 | // ----------- | |
351 | ||
352 | virtual void EnableTool(int toolid, bool enable); | |
353 | virtual void ToggleTool(int toolid, bool toggle); | |
354 | ||
355 | // Set this to be togglable (or not) | |
356 | virtual void SetToggle(int toolid, bool toggle); | |
357 | ||
358 | // set/get tools client data (not for controls) | |
359 | virtual wxObject *GetToolClientData(int toolid) const; | |
360 | virtual void SetToolClientData(int toolid, wxObject *clientData); | |
361 | ||
362 | // returns tool pos, or wxNOT_FOUND if tool isn't found | |
363 | virtual int GetToolPos(int id) const; | |
364 | ||
365 | // return true if the tool is toggled | |
366 | virtual bool GetToolState(int toolid) const; | |
367 | ||
368 | virtual bool GetToolEnabled(int toolid) const; | |
369 | ||
370 | virtual void SetToolShortHelp(int toolid, const wxString& helpString); | |
371 | virtual wxString GetToolShortHelp(int toolid) const; | |
372 | virtual void SetToolLongHelp(int toolid, const wxString& helpString); | |
373 | virtual wxString GetToolLongHelp(int toolid) const; | |
374 | ||
375 | // margins/packing/separation | |
376 | // -------------------------- | |
377 | ||
378 | virtual void SetMargins(int x, int y); | |
379 | void SetMargins(const wxSize& size) | |
380 | { SetMargins((int) size.x, (int) size.y); } | |
381 | virtual void SetToolPacking(int packing) | |
382 | { m_toolPacking = packing; } | |
383 | virtual void SetToolSeparation(int separation) | |
384 | { m_toolSeparation = separation; } | |
385 | ||
386 | virtual wxSize GetToolMargins() const { return wxSize(m_xMargin, m_yMargin); } | |
387 | virtual int GetToolPacking() const { return m_toolPacking; } | |
388 | virtual int GetToolSeparation() const { return m_toolSeparation; } | |
389 | ||
390 | // toolbar geometry | |
391 | // ---------------- | |
392 | ||
393 | // set the number of toolbar rows | |
394 | virtual void SetRows(int nRows); | |
395 | ||
396 | // the toolbar can wrap - limit the number of columns or rows it may take | |
397 | void SetMaxRowsCols(int rows, int cols) | |
398 | { m_maxRows = rows; m_maxCols = cols; } | |
399 | int GetMaxRows() const { return m_maxRows; } | |
400 | int GetMaxCols() const { return m_maxCols; } | |
401 | ||
402 | // get/set the size of the bitmaps used by the toolbar: should be called | |
403 | // before adding any tools to the toolbar | |
404 | virtual void SetToolBitmapSize(const wxSize& size) | |
405 | { m_defaultWidth = size.x; m_defaultHeight = size.y; }; | |
406 | virtual wxSize GetToolBitmapSize() const | |
407 | { return wxSize(m_defaultWidth, m_defaultHeight); } | |
408 | ||
409 | // the button size in some implementations is bigger than the bitmap size: | |
410 | // get the total button size (by default the same as bitmap size) | |
411 | virtual wxSize GetToolSize() const | |
412 | { return GetToolBitmapSize(); } ; | |
413 | ||
414 | // returns a (non separator) tool containing the point (x, y) or NULL if | |
415 | // there is no tool at this point (corrdinates are client) | |
416 | virtual wxToolBarToolBase *FindToolForPosition(wxCoord x, | |
417 | wxCoord y) const = 0; | |
418 | ||
419 | // find the tool by id | |
420 | wxToolBarToolBase *FindById(int toolid) const; | |
421 | ||
422 | // return true if this is a vertical toolbar, otherwise false | |
423 | bool IsVertical() const { return HasFlag(wxTB_VERTICAL); } | |
424 | ||
425 | ||
426 | // the old versions of the various methods kept for compatibility | |
427 | // don't use in the new code! | |
428 | // -------------------------------------------------------------- | |
429 | ||
430 | wxToolBarToolBase *AddTool(int toolid, | |
431 | const wxBitmap& bitmap, | |
432 | const wxBitmap& bmpDisabled, | |
433 | bool toggle = false, | |
434 | wxObject *clientData = NULL, | |
435 | const wxString& shortHelpString = wxEmptyString, | |
436 | const wxString& longHelpString = wxEmptyString) | |
437 | { | |
438 | return AddTool(toolid, wxEmptyString, | |
439 | bitmap, bmpDisabled, | |
440 | toggle ? wxITEM_CHECK : wxITEM_NORMAL, | |
441 | shortHelpString, longHelpString, clientData); | |
442 | } | |
443 | ||
444 | wxToolBarToolBase *AddTool(int toolid, | |
445 | const wxBitmap& bitmap, | |
446 | const wxString& shortHelpString = wxEmptyString, | |
447 | const wxString& longHelpString = wxEmptyString) | |
448 | { | |
449 | return AddTool(toolid, wxEmptyString, | |
450 | bitmap, wxNullBitmap, wxITEM_NORMAL, | |
451 | shortHelpString, longHelpString, NULL); | |
452 | } | |
453 | ||
454 | wxToolBarToolBase *AddTool(int toolid, | |
455 | const wxBitmap& bitmap, | |
456 | const wxBitmap& bmpDisabled, | |
457 | bool toggle, | |
458 | wxCoord xPos, | |
459 | wxCoord yPos = wxDefaultCoord, | |
460 | wxObject *clientData = NULL, | |
461 | const wxString& shortHelp = wxEmptyString, | |
462 | const wxString& longHelp = wxEmptyString) | |
463 | { | |
464 | return DoAddTool(toolid, wxEmptyString, bitmap, bmpDisabled, | |
465 | toggle ? wxITEM_CHECK : wxITEM_NORMAL, | |
466 | shortHelp, longHelp, clientData, xPos, yPos); | |
467 | } | |
468 | ||
469 | wxToolBarToolBase *InsertTool(size_t pos, | |
470 | int toolid, | |
471 | const wxBitmap& bitmap, | |
472 | const wxBitmap& bmpDisabled = wxNullBitmap, | |
473 | bool toggle = false, | |
474 | wxObject *clientData = NULL, | |
475 | const wxString& shortHelp = wxEmptyString, | |
476 | const wxString& longHelp = wxEmptyString) | |
477 | { | |
478 | return InsertTool(pos, toolid, wxEmptyString, bitmap, bmpDisabled, | |
479 | toggle ? wxITEM_CHECK : wxITEM_NORMAL, | |
480 | shortHelp, longHelp, clientData); | |
481 | } | |
482 | ||
483 | // event handlers | |
484 | // -------------- | |
485 | ||
486 | // NB: these functions are deprecated, use EVT_TOOL_XXX() instead! | |
487 | ||
488 | // Only allow toggle if returns true. Call when left button up. | |
489 | virtual bool OnLeftClick(int toolid, bool toggleDown); | |
490 | ||
491 | // Call when right button down. | |
492 | virtual void OnRightClick(int toolid, long x, long y); | |
493 | ||
494 | // Called when the mouse cursor enters a tool bitmap. | |
495 | // Argument is wxID_ANY if mouse is exiting the toolbar. | |
496 | virtual void OnMouseEnter(int toolid); | |
497 | ||
498 | // more deprecated functions | |
499 | // ------------------------- | |
500 | ||
501 | // use GetToolMargins() instead | |
502 | wxSize GetMargins() const { return GetToolMargins(); } | |
503 | ||
504 | // implementation only from now on | |
505 | // ------------------------------- | |
506 | ||
507 | size_t GetToolsCount() const { return m_tools.GetCount(); } | |
508 | ||
509 | // Do the toolbar button updates (check for EVT_UPDATE_UI handlers) | |
510 | virtual void UpdateWindowUI(long flags = wxUPDATE_UI_NONE) ; | |
511 | ||
512 | // don't want toolbars to accept the focus | |
513 | virtual bool AcceptsFocus() const { return false; } | |
514 | ||
515 | protected: | |
516 | // to implement in derived classes | |
517 | // ------------------------------- | |
518 | ||
519 | // create a new toolbar tool and add it to the toolbar, this is typically | |
520 | // implemented by just calling InsertTool() | |
521 | virtual wxToolBarToolBase *DoAddTool | |
522 | ( | |
523 | int toolid, | |
524 | const wxString& label, | |
525 | const wxBitmap& bitmap, | |
526 | const wxBitmap& bmpDisabled, | |
527 | wxItemKind kind, | |
528 | const wxString& shortHelp = wxEmptyString, | |
529 | const wxString& longHelp = wxEmptyString, | |
530 | wxObject *clientData = NULL, | |
531 | wxCoord xPos = wxDefaultCoord, | |
532 | wxCoord yPos = wxDefaultCoord | |
533 | ); | |
534 | ||
535 | // the tool is not yet inserted into m_tools list when this function is | |
536 | // called and will only be added to it if this function succeeds | |
537 | virtual bool DoInsertTool(size_t pos, wxToolBarToolBase *tool) = 0; | |
538 | ||
539 | // the tool is still in m_tools list when this function is called, it will | |
540 | // only be deleted from it if it succeeds | |
541 | virtual bool DoDeleteTool(size_t pos, wxToolBarToolBase *tool) = 0; | |
542 | ||
543 | // called when the tools enabled flag changes | |
544 | virtual void DoEnableTool(wxToolBarToolBase *tool, bool enable) = 0; | |
545 | ||
546 | // called when the tool is toggled | |
547 | virtual void DoToggleTool(wxToolBarToolBase *tool, bool toggle) = 0; | |
548 | ||
549 | // called when the tools "can be toggled" flag changes | |
550 | virtual void DoSetToggle(wxToolBarToolBase *tool, bool toggle) = 0; | |
551 | ||
552 | // the functions to create toolbar tools | |
553 | virtual wxToolBarToolBase *CreateTool(int toolid, | |
554 | const wxString& label, | |
555 | const wxBitmap& bmpNormal, | |
556 | const wxBitmap& bmpDisabled, | |
557 | wxItemKind kind, | |
558 | wxObject *clientData, | |
559 | const wxString& shortHelp, | |
560 | const wxString& longHelp) = 0; | |
561 | ||
562 | virtual wxToolBarToolBase *CreateTool(wxControl *control) = 0; | |
563 | ||
564 | // helper functions | |
565 | // ---------------- | |
566 | ||
567 | // un-toggle all buttons in the same radio group | |
568 | void UnToggleRadioGroup(wxToolBarToolBase *tool); | |
569 | ||
570 | // the list of all our tools | |
571 | wxToolBarToolsList m_tools; | |
572 | ||
573 | // the offset of the first tool | |
574 | int m_xMargin; | |
575 | int m_yMargin; | |
576 | ||
577 | // the maximum number of toolbar rows/columns | |
578 | int m_maxRows; | |
579 | int m_maxCols; | |
580 | ||
581 | // the tool packing and separation | |
582 | int m_toolPacking, | |
583 | m_toolSeparation; | |
584 | ||
585 | // the size of the toolbar bitmaps | |
586 | wxCoord m_defaultWidth, m_defaultHeight; | |
587 | ||
588 | private: | |
589 | DECLARE_EVENT_TABLE() | |
590 | DECLARE_NO_COPY_CLASS(wxToolBarBase) | |
591 | }; | |
592 | ||
593 | // Helper function for creating the image for disabled buttons | |
594 | bool wxCreateGreyedImage(const wxImage& in, wxImage& out) ; | |
595 | ||
596 | #endif // wxUSE_TOOLBAR | |
597 | ||
598 | #endif | |
599 | // _WX_TBARBASE_H_ | |
600 |