/[pcsx2_0.9.7]/branch/r3113_0.9.7_beta/3rdparty/wxWidgets/include/wx/tbarbase.h
ViewVC logotype

Contents of /branch/r3113_0.9.7_beta/3rdparty/wxWidgets/include/wx/tbarbase.h

Parent Directory Parent Directory | Revision Log Revision Log


Revision 32 - (show annotations) (download)
Tue Sep 7 03:29:01 2010 UTC (9 years, 5 months ago) by william
File MIME type: text/plain
File size: 22517 byte(s)
branching from upstream revision (http://pcsx2.googlecode.com/svn/trunk
): r3113 to
https://svn.netsolutions.dnsalias.com/websvn/ps2/pcsx2/pcsx2_0.9.7/branch/r3113_0.9.7_beta
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: tbarbase.h 49563 2007-10-31 20:46:21Z VZ $
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 WXDLLIMPEXP_FWD_CORE wxToolBarBase;
28 class WXDLLIMPEXP_FWD_CORE wxToolBarToolBase;
29 class WXDLLIMPEXP_FWD_CORE 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 virtual ~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_LEFT | wxTB_RIGHT); }
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 // call this from derived class ctor/Create() to ensure that we have either
568 // wxTB_HORIZONTAL or wxTB_VERTICAL style, there is a lot of existing code
569 // which randomly checks either one or the other of them and gets confused
570 // if neither is set (and making one of them 0 is not an option neither as
571 // then the existing tests would break down)
572 void FixupStyle();
573
574 // un-toggle all buttons in the same radio group
575 void UnToggleRadioGroup(wxToolBarToolBase *tool);
576
577 // the list of all our tools
578 wxToolBarToolsList m_tools;
579
580 // the offset of the first tool
581 int m_xMargin;
582 int m_yMargin;
583
584 // the maximum number of toolbar rows/columns
585 int m_maxRows;
586 int m_maxCols;
587
588 // the tool packing and separation
589 int m_toolPacking,
590 m_toolSeparation;
591
592 // the size of the toolbar bitmaps
593 wxCoord m_defaultWidth, m_defaultHeight;
594
595 private:
596 DECLARE_EVENT_TABLE()
597 DECLARE_NO_COPY_CLASS(wxToolBarBase)
598 };
599
600 // Helper function for creating the image for disabled buttons
601 bool wxCreateGreyedImage(const wxImage& in, wxImage& out) ;
602
603 #endif // wxUSE_TOOLBAR
604
605 #endif
606 // _WX_TBARBASE_H_
607

  ViewVC Help
Powered by ViewVC 1.1.22