]> git.saurik.com Git - wxWidgets.git/blob - src/univ/toolbar.cpp
removing old files
[wxWidgets.git] / src / univ / toolbar.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/univ/toolbar.cpp
3 // Purpose: implementation of wxToolBar for wxUniversal
4 // Author: Robert Roebling, Vadim Zeitlin (universalization)
5 // Modified by:
6 // Created: 20.02.02
7 // Id: $Id$
8 // Copyright: (c) 2001 Robert Roebling,
9 // (c) 2002 SciTech Software, Inc. (www.scitechsoft.com)
10 // Licence: wxWindows licence
11 /////////////////////////////////////////////////////////////////////////////
12
13 // ============================================================================
14 // declarations
15 // ============================================================================
16
17 // ----------------------------------------------------------------------------
18 // headers
19 // ----------------------------------------------------------------------------
20
21 // For compilers that support precompilation, includes "wx.h".
22 #include "wx/wxprec.h"
23
24 #ifdef __BORLANDC__
25 #pragma hdrstop
26 #endif
27
28 #if wxUSE_TOOLBAR
29
30 #include "wx/toolbar.h"
31
32 #ifndef WX_PRECOMP
33 #include "wx/utils.h"
34 #include "wx/app.h"
35 #include "wx/log.h"
36 #include "wx/frame.h"
37 #include "wx/dc.h"
38 #include "wx/image.h"
39 #endif
40
41 #include "wx/univ/renderer.h"
42
43 // ----------------------------------------------------------------------------
44 // wxStdToolbarInputHandler: translates SPACE and ENTER keys and the left mouse
45 // click into button press/release actions
46 // ----------------------------------------------------------------------------
47
48 class WXDLLEXPORT wxStdToolbarInputHandler : public wxStdInputHandler
49 {
50 public:
51 wxStdToolbarInputHandler(wxInputHandler *inphand);
52
53 virtual bool HandleKey(wxInputConsumer *consumer,
54 const wxKeyEvent& event,
55 bool pressed);
56 virtual bool HandleMouse(wxInputConsumer *consumer,
57 const wxMouseEvent& event);
58 virtual bool HandleMouseMove(wxInputConsumer *consumer, const wxMouseEvent& event);
59 virtual bool HandleFocus(wxInputConsumer *consumer, const wxFocusEvent& event);
60 virtual bool HandleActivation(wxInputConsumer *consumer, bool activated);
61
62 private:
63 wxWindow *m_winCapture;
64 wxToolBarToolBase *m_toolCapture;
65 wxToolBarToolBase *m_toolLast;
66 };
67
68 // ----------------------------------------------------------------------------
69 // constants
70 // ----------------------------------------------------------------------------
71
72 // value meaning that m_widthSeparator is not initialized
73 static const wxCoord INVALID_WIDTH = wxDefaultCoord;
74
75 // ----------------------------------------------------------------------------
76 // wxToolBarTool: our implementation of wxToolBarToolBase
77 // ----------------------------------------------------------------------------
78
79 class WXDLLEXPORT wxToolBarTool : public wxToolBarToolBase
80 {
81 public:
82 wxToolBarTool(wxToolBar *tbar,
83 int id,
84 const wxString& label,
85 const wxBitmap& bmpNormal,
86 const wxBitmap& bmpDisabled,
87 wxItemKind kind,
88 wxObject *clientData,
89 const wxString& shortHelp,
90 const wxString& longHelp)
91 : wxToolBarToolBase(tbar, id, label, bmpNormal, bmpDisabled, kind,
92 clientData, shortHelp, longHelp)
93 {
94 // no position yet
95 m_x =
96 m_y = wxDefaultCoord;
97 m_width =
98 m_height = 0;
99
100 // not pressed yet
101 m_isInverted = false;
102
103 // mouse not here yet
104 m_underMouse = false;
105 }
106
107 wxToolBarTool(wxToolBar *tbar, wxControl *control, const wxString& label)
108 : wxToolBarToolBase(tbar, control, label)
109 {
110 // no position yet
111 m_x =
112 m_y = wxDefaultCoord;
113 m_width =
114 m_height = 0;
115
116 // not pressed yet
117 m_isInverted = false;
118
119 // mouse not here yet
120 m_underMouse = false;
121 }
122
123 // is this tool pressed, even temporarily? (this is different from being
124 // permanently toggled which is what IsToggled() returns)
125 bool IsPressed() const
126 { return CanBeToggled() ? IsToggled() != m_isInverted : m_isInverted; }
127
128 // are we temporarily pressed/unpressed?
129 bool IsInverted() const { return m_isInverted; }
130
131 // press the tool temporarily by inverting its toggle state
132 void Invert() { m_isInverted = !m_isInverted; }
133
134 // Set underMouse
135 void SetUnderMouse( bool under = true ) { m_underMouse = under; }
136 bool IsUnderMouse() { return m_underMouse; }
137
138 public:
139 // the tool position (for controls)
140 wxCoord m_x;
141 wxCoord m_y;
142 wxCoord m_width;
143 wxCoord m_height;
144
145 private:
146 // true if the tool is pressed
147 bool m_isInverted;
148
149 // true if the tool is under the mouse
150 bool m_underMouse;
151 };
152
153 // ============================================================================
154 // wxToolBar implementation
155 // ============================================================================
156
157 IMPLEMENT_DYNAMIC_CLASS(wxToolBar, wxControl)
158
159 // ----------------------------------------------------------------------------
160 // wxToolBar creation
161 // ----------------------------------------------------------------------------
162
163 void wxToolBar::Init()
164 {
165 // no tools yet
166 m_needsLayout = false;
167
168 // unknown widths for the tools and separators
169 m_widthSeparator = INVALID_WIDTH;
170
171 m_maxWidth =
172 m_maxHeight = 0;
173
174 wxRenderer *renderer = GetRenderer();
175
176 SetToolBitmapSize(renderer->GetToolBarButtonSize(&m_widthSeparator));
177 SetMargins(renderer->GetToolBarMargin());
178 }
179
180 bool wxToolBar::Create(wxWindow *parent,
181 wxWindowID id,
182 const wxPoint& pos,
183 const wxSize& size,
184 long style,
185 const wxString& name)
186 {
187 if ( !wxToolBarBase::Create(parent, id, pos, size, style,
188 wxDefaultValidator, name) )
189 {
190 return false;
191 }
192
193 FixupStyle();
194
195 CreateInputHandler(wxINP_HANDLER_TOOLBAR);
196
197 SetInitialSize(size);
198
199 return true;
200 }
201
202 wxToolBar::~wxToolBar()
203 {
204 // Make sure the toolbar is removed from the parent.
205 SetSize(0,0);
206 }
207
208 void wxToolBar::SetMargins(int x, int y)
209 {
210 // This required for similar visual effects under
211 // native platforms and wxUniv.
212 wxToolBarBase::SetMargins( x + 3, y + 3 );
213 }
214
215 // ----------------------------------------------------------------------------
216 // wxToolBar tool-related methods
217 // ----------------------------------------------------------------------------
218
219 wxToolBarToolBase *wxToolBar::FindToolForPosition(wxCoord x, wxCoord y) const
220 {
221 // check the "other" direction first: it must be inside the toolbar or we
222 // don't risk finding anything
223 if ( IsVertical() )
224 {
225 if ( x < 0 || x > m_maxWidth )
226 return NULL;
227
228 // we always use x, even for a vertical toolbar, this makes the code
229 // below simpler
230 x = y;
231 }
232 else // horizontal
233 {
234 if ( y < 0 || y > m_maxHeight )
235 return NULL;
236 }
237
238 for ( wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst();
239 node;
240 node = node->GetNext() )
241 {
242 wxToolBarToolBase *tool = node->GetData();
243 wxRect rectTool = GetToolRect(tool);
244
245 wxCoord startTool, endTool;
246 GetRectLimits(rectTool, &startTool, &endTool);
247
248 if ( x >= startTool && x <= endTool )
249 {
250 // don't return the separators from here, they don't accept any
251 // input anyhow
252 return tool->IsSeparator() ? NULL : tool;
253 }
254 }
255
256 return NULL;
257 }
258
259 void wxToolBar::SetToolShortHelp(int id, const wxString& help)
260 {
261 wxToolBarToolBase *tool = FindById(id);
262
263 wxCHECK_RET( tool, _T("SetToolShortHelp: no such tool") );
264
265 tool->SetShortHelp(help);
266 }
267
268 bool wxToolBar::DoInsertTool(size_t WXUNUSED(pos),
269 wxToolBarToolBase * WXUNUSED(tool))
270 {
271 // recalculate the toolbar geometry before redrawing it the next time
272 m_needsLayout = true;
273
274 // and ensure that we indeed are going to redraw
275 Refresh();
276
277 return true;
278 }
279
280 bool wxToolBar::DoDeleteTool(size_t WXUNUSED(pos),
281 wxToolBarToolBase * WXUNUSED(tool))
282 {
283 // as above
284 m_needsLayout = true;
285
286 Refresh();
287
288 return true;
289 }
290
291 void wxToolBar::DoEnableTool(wxToolBarToolBase *tool, bool enable)
292 {
293 #if wxUSE_IMAGE
294 // created disabled-state bitmap on demand
295 if ( !enable && !tool->GetDisabledBitmap().Ok() )
296 {
297 wxImage image(tool->GetNormalBitmap().ConvertToImage());
298
299 tool->SetDisabledBitmap(image.ConvertToGreyscale());
300 }
301 #endif // wxUSE_IMAGE
302
303 RefreshTool(tool);
304 }
305
306 void wxToolBar::DoToggleTool(wxToolBarToolBase *tool, bool WXUNUSED(toggle))
307 {
308 // note that if we're called the tool did change state (the base class
309 // checks for it), so it's not necessary to check for this again here
310 RefreshTool(tool);
311 }
312
313 void wxToolBar::DoSetToggle(wxToolBarToolBase *tool, bool WXUNUSED(toggle))
314 {
315 RefreshTool(tool);
316 }
317
318 wxToolBarToolBase *wxToolBar::CreateTool(int id,
319 const wxString& label,
320 const wxBitmap& bmpNormal,
321 const wxBitmap& bmpDisabled,
322 wxItemKind kind,
323 wxObject *clientData,
324 const wxString& shortHelp,
325 const wxString& longHelp)
326 {
327 return new wxToolBarTool(this, id, label, bmpNormal, bmpDisabled, kind,
328 clientData, shortHelp, longHelp);
329 }
330
331 wxToolBarToolBase *
332 wxToolBar::CreateTool(wxControl *control, const wxString& label)
333 {
334 return new wxToolBarTool(this, control, label);
335 }
336
337 // ----------------------------------------------------------------------------
338 // wxToolBar geometry
339 // ----------------------------------------------------------------------------
340
341 wxRect wxToolBar::GetToolRect(wxToolBarToolBase *toolBase) const
342 {
343 const wxToolBarTool *tool = (wxToolBarTool *)toolBase;
344
345 wxRect rect;
346
347 wxCHECK_MSG( tool, rect, _T("GetToolRect: NULL tool") );
348
349 // ensure that we always have the valid tool position
350 if ( m_needsLayout )
351 {
352 wxConstCast(this, wxToolBar)->DoLayout();
353 }
354
355 rect.x = tool->m_x - m_xMargin;
356 rect.y = tool->m_y - m_yMargin;
357
358 if ( IsVertical() )
359 {
360 if (tool->IsButton())
361 {
362 if(!HasFlag(wxTB_TEXT))
363 {
364 rect.width = m_defaultWidth;
365 rect.height = m_defaultHeight;
366 }
367 else
368 {
369 rect.width = m_defaultWidth +
370 GetFont().GetPointSize() * tool->GetLabel().length();
371 rect.height = m_defaultHeight;
372 }
373 }
374 else if (tool->IsSeparator())
375 {
376 rect.width = m_defaultWidth;
377 rect.height = m_widthSeparator;
378 }
379 else // control
380 {
381 rect.width = tool->m_width;
382 rect.height = tool->m_height;
383 }
384 }
385 else // horizontal
386 {
387 if (tool->IsButton())
388 {
389 if(!HasFlag(wxTB_TEXT))
390 {
391 rect.width = m_defaultWidth;
392 rect.height = m_defaultHeight;
393 }
394 else
395 {
396 rect.width = m_defaultWidth +
397 GetFont().GetPointSize() * tool->GetLabel().length();
398 rect.height = m_defaultHeight;
399 }
400 }
401 else if (tool->IsSeparator())
402 {
403 rect.width = m_widthSeparator;
404 rect.height = m_defaultHeight;
405 }
406 else // control
407 {
408 rect.width = tool->m_width;
409 rect.height = tool->m_height;
410 }
411 }
412
413 rect.width += 2*m_xMargin;
414 rect.height += 2*m_yMargin;
415
416 return rect;
417 }
418
419 bool wxToolBar::Realize()
420 {
421 if ( !wxToolBarBase::Realize() )
422 return false;
423
424 m_needsLayout = true;
425 DoLayout();
426
427 // the first item in the radio group is checked by default to be consistent
428 // with wxGTK and the menu radio items
429 int radioGroupCount = 0;
430
431 for ( wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst();
432 node;
433 node = node->GetNext() )
434 {
435 wxToolBarTool *tool = (wxToolBarTool*) node->GetData();
436
437 if ( !tool->IsButton() || tool->GetKind() != wxITEM_RADIO )
438 {
439 radioGroupCount = 0;
440 continue;
441 }
442
443 bool toggle = !radioGroupCount++;
444 if ( tool->Toggle(toggle) )
445 {
446 DoToggleTool(tool, toggle);
447 }
448 }
449
450 SetInitialSize(wxDefaultSize);
451
452 return true;
453 }
454
455 void wxToolBar::SetWindowStyleFlag( long style )
456 {
457 wxToolBarBase::SetWindowStyleFlag(style);
458
459 m_needsLayout = true;
460
461 Refresh();
462 }
463
464 void wxToolBar::DoLayout()
465 {
466 wxASSERT_MSG( m_needsLayout, _T("why are we called?") );
467
468 m_needsLayout = false;
469
470 wxCoord x = m_xMargin,
471 y = m_yMargin;
472
473 wxCoord widthTool = 0, maxWidthTool = 0;
474 wxCoord heightTool = 0, maxHeightTool = 0;
475 wxCoord margin = IsVertical() ? m_xMargin : m_yMargin;
476 wxCoord *pCur = IsVertical() ? &y : &x;
477
478 // calculate the positions of all elements
479 for ( wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst();
480 node;
481 node = node->GetNext() )
482 {
483 wxToolBarTool *tool = (wxToolBarTool *) node->GetData();
484
485 tool->m_x = x;
486 tool->m_y = y;
487
488 // TODO ugly number fiddling
489 if (tool->IsButton())
490 {
491 if (IsVertical())
492 {
493 widthTool = m_defaultHeight;
494 heightTool = m_defaultWidth;
495 if(HasFlag(wxTB_TEXT))
496 heightTool += GetFont().GetPointSize() * tool->GetLabel().length();
497 }
498 else
499 {
500 widthTool = m_defaultWidth;
501 if(HasFlag(wxTB_TEXT))
502 widthTool += GetFont().GetPointSize() * tool->GetLabel().length();
503
504 heightTool = m_defaultHeight;
505 }
506
507 if(widthTool > maxWidthTool) // Record max width of tool
508 {
509 maxWidthTool = widthTool;
510 }
511
512 if(heightTool > maxHeightTool) // Record max width of tool
513 {
514 maxHeightTool = heightTool;
515 }
516
517 *pCur += widthTool;
518 }
519 else if (tool->IsSeparator())
520 {
521 *pCur += m_widthSeparator;
522 }
523 else if (!IsVertical()) // horizontal control
524 {
525 wxControl *control = tool->GetControl();
526 wxSize size = control->GetSize();
527 tool->m_y += (m_defaultHeight - size.y)/2;
528 tool->m_width = size.x;
529 tool->m_height = size.y;
530
531 *pCur += tool->m_width;
532 }
533 *pCur += margin;
534 }
535
536 // calculate the total toolbar size
537 wxCoord xMin, yMin;
538
539 if(!HasFlag(wxTB_TEXT))
540 {
541 xMin = m_defaultWidth + 2*m_xMargin;
542 yMin = m_defaultHeight + 2*m_yMargin;
543 }
544 else
545 {
546 if (IsVertical())
547 {
548 xMin = heightTool + 2*m_xMargin;
549 yMin = widthTool + 2*m_xMargin;
550 }
551 else
552 {
553 xMin = maxWidthTool + 2*m_xMargin;
554 yMin = heightTool + 2*m_xMargin;
555 }
556 }
557
558 m_maxWidth = x < xMin ? xMin : x;
559 m_maxHeight = y < yMin ? yMin : y;
560 }
561
562 wxSize wxToolBar::DoGetBestClientSize() const
563 {
564 return wxSize(m_maxWidth, m_maxHeight);
565 }
566
567 void wxToolBar::DoSetSize(int x, int y, int width, int height, int sizeFlags)
568 {
569 int old_width, old_height;
570 GetSize(&old_width, &old_height);
571
572 wxToolBarBase::DoSetSize(x, y, width, height, sizeFlags);
573
574 // Correct width and height if needed.
575 if ( width == wxDefaultCoord || height == wxDefaultCoord )
576 {
577 int tmp_width, tmp_height;
578 GetSize(&tmp_width, &tmp_height);
579
580 if ( width == wxDefaultCoord )
581 width = tmp_width;
582 if ( height == wxDefaultCoord )
583 height = tmp_height;
584 }
585
586 // We must refresh the frame size when the toolbar changes size
587 // otherwise the toolbar can be shown incorrectly
588 if ( old_width != width || old_height != height )
589 {
590 // But before we send the size event check it
591 // we have a frame that is not being deleted.
592 wxFrame *frame = wxDynamicCast(GetParent(), wxFrame);
593 if ( frame && !frame->IsBeingDeleted() )
594 {
595 frame->SendSizeEvent();
596 }
597 }
598 }
599
600 // ----------------------------------------------------------------------------
601 // wxToolBar drawing
602 // ----------------------------------------------------------------------------
603
604 void wxToolBar::RefreshTool(wxToolBarToolBase *tool)
605 {
606 RefreshRect(GetToolRect(tool));
607 }
608
609 void wxToolBar::GetRectLimits(const wxRect& rect,
610 wxCoord *start,
611 wxCoord *end) const
612 {
613 wxCHECK_RET( start && end, _T("NULL pointer in GetRectLimits") );
614
615 if ( IsVertical() )
616 {
617 *start = rect.GetTop();
618 *end = rect.GetBottom();
619 }
620 else // horizontal
621 {
622 *start = rect.GetLeft();
623 *end = rect.GetRight();
624 }
625 }
626
627 void wxToolBar::DoDraw(wxControlRenderer *renderer)
628 {
629 // prepare the variables used below
630 wxDC& dc = renderer->GetDC();
631 wxRenderer *rend = renderer->GetRenderer();
632 dc.SetFont(GetFont());
633
634 // draw the border separating us from the menubar (if there is no menubar
635 // we probably shouldn't draw it?)
636 if ( !IsVertical() )
637 {
638 rend->DrawHorizontalLine(dc, 0, 0, GetClientSize().x);
639 }
640
641 // get the update rect and its limits depending on the orientation
642 wxRect rectUpdate = GetUpdateClientRect();
643 wxCoord start, end;
644 GetRectLimits(rectUpdate, &start, &end);
645
646 // and redraw all the tools intersecting it
647 for ( wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst();
648 node;
649 node = node->GetNext() )
650 {
651 wxToolBarTool *tool = (wxToolBarTool*) node->GetData();
652 wxRect rectTool = GetToolRect(tool);
653 wxCoord startTool, endTool;
654 GetRectLimits(rectTool, &startTool, &endTool);
655
656 if ( endTool < start )
657 {
658 // we're still to the left of the area to redraw
659 continue;
660 }
661
662 if ( startTool > end )
663 {
664 // we're beyond the area to redraw, nothing left to do
665 break;
666 }
667
668 if (tool->IsSeparator() && !HasFlag(wxTB_FLAT))
669 {
670 // Draw separators only in flat mode
671 continue;
672 }
673
674 // deal with the flags
675 int flags = 0;
676
677 if ( tool->IsEnabled() )
678 {
679 // The toolbars without wxTB_FLAT don't react to the mouse hovering
680 if ( !HasFlag(wxTB_FLAT) || tool->IsUnderMouse() )
681 flags |= wxCONTROL_CURRENT;
682 }
683 else // disabled tool
684 {
685 flags |= wxCONTROL_DISABLED;
686 }
687
688 //if ( tool == m_toolCaptured )
689 // flags |= wxCONTROL_FOCUSED;
690
691 if ( tool->IsPressed() )
692 flags = wxCONTROL_PRESSED;
693
694 wxString label;
695 wxBitmap bitmap;
696 if ( !tool->IsSeparator() )
697 {
698 label = tool->GetLabel();
699 bitmap = tool->GetBitmap();
700 }
701 //else: leave both the label and the bitmap invalid to draw a separator
702
703 if ( !tool->IsControl() )
704 {
705 int tbStyle = 0;
706 if(HasFlag(wxTB_TEXT))
707 {
708 tbStyle |= wxTB_TEXT;
709 }
710
711 if(HasFlag(wxTB_VERTICAL))
712 {
713 tbStyle |= wxTB_VERTICAL;
714 }
715 else
716 {
717 tbStyle |= wxTB_HORIZONTAL;
718 }
719 rend->DrawToolBarButton(dc, label, bitmap, rectTool, flags, tool->GetStyle(), tbStyle);
720 }
721 else // control
722 {
723 wxControl *control = tool->GetControl();
724 control->Move(tool->m_x, tool->m_y);
725 }
726 }
727 }
728
729 // ----------------------------------------------------------------------------
730 // wxToolBar actions
731 // ----------------------------------------------------------------------------
732
733 bool wxToolBar::PerformAction(const wxControlAction& action,
734 long numArg,
735 const wxString& strArg)
736 {
737 wxToolBarTool *tool = (wxToolBarTool*) FindById(numArg);
738 if (!tool)
739 return false;
740
741 if ( action == wxACTION_TOOLBAR_TOGGLE )
742 {
743 PerformAction( wxACTION_BUTTON_RELEASE, numArg );
744
745 PerformAction( wxACTION_BUTTON_CLICK, numArg );
746
747 // Set mouse leave toolbar button range (If still in the range,
748 // toolbar button would get focus again
749 PerformAction( wxACTION_TOOLBAR_LEAVE, numArg );
750 }
751 else if ( action == wxACTION_TOOLBAR_PRESS )
752 {
753 wxLogTrace(_T("toolbar"), _T("Button '%s' pressed."), tool->GetShortHelp().c_str());
754
755 tool->Invert();
756
757 RefreshTool( tool );
758 }
759 else if ( action == wxACTION_TOOLBAR_RELEASE )
760 {
761 wxLogTrace(_T("toolbar"), _T("Button '%s' released."), tool->GetShortHelp().c_str());
762
763 wxASSERT_MSG( tool->IsInverted(), _T("release unpressed button?") );
764
765 if(tool->IsInverted())
766 {
767 tool->Invert();
768 }
769
770 RefreshTool( tool );
771 }
772 else if ( action == wxACTION_TOOLBAR_CLICK )
773 {
774 bool isToggled;
775 if ( tool->CanBeToggled() )
776 {
777 if ( tool->IsButton() && tool->GetKind() == wxITEM_RADIO )
778 {
779 UnToggleRadioGroup(tool);
780 tool->Toggle(true);
781 }
782 else
783 {
784 tool->Toggle();
785 }
786
787 RefreshTool( tool );
788
789 isToggled = tool->IsToggled();
790 }
791 else // simple non-checkable tool
792 {
793 isToggled = false;
794 }
795 OnLeftClick( tool->GetId(), isToggled );
796 }
797 else if ( action == wxACTION_TOOLBAR_ENTER )
798 {
799 wxCHECK_MSG( tool, false, _T("no tool to enter?") );
800
801 if ( HasFlag(wxTB_FLAT) && tool->IsEnabled() )
802 {
803 tool->SetUnderMouse( true );
804
805 if ( !tool->IsToggled() )
806 RefreshTool( tool );
807 }
808 }
809 else if ( action == wxACTION_TOOLBAR_LEAVE )
810 {
811 wxCHECK_MSG( tool, false, _T("no tool to leave?") );
812
813 if ( HasFlag(wxTB_FLAT) && tool->IsEnabled() )
814 {
815 tool->SetUnderMouse( false );
816
817 if ( !tool->IsToggled() )
818 RefreshTool( tool );
819 }
820 }
821 else
822 return wxControl::PerformAction(action, numArg, strArg);
823
824 return true;
825 }
826
827 /* static */
828 wxInputHandler *wxToolBar::GetStdInputHandler(wxInputHandler *handlerDef)
829 {
830 static wxStdToolbarInputHandler s_handler(handlerDef);
831
832 return &s_handler;
833 }
834
835 // ============================================================================
836 // wxStdToolbarInputHandler implementation
837 // ============================================================================
838
839 wxStdToolbarInputHandler::wxStdToolbarInputHandler(wxInputHandler *handler)
840 : wxStdInputHandler(handler)
841 {
842 m_winCapture = NULL;
843 m_toolCapture = NULL;
844 m_toolLast = NULL;
845 }
846
847 bool wxStdToolbarInputHandler::HandleKey(wxInputConsumer *consumer,
848 const wxKeyEvent& event,
849 bool pressed)
850 {
851 // TODO: when we have a current button we should allow the arrow
852 // keys to move it
853 return wxStdInputHandler::HandleKey(consumer, event, pressed);
854 }
855
856 bool wxStdToolbarInputHandler::HandleMouse(wxInputConsumer *consumer,
857 const wxMouseEvent& event)
858 {
859 wxToolBar *tbar = wxStaticCast(consumer->GetInputWindow(), wxToolBar);
860 wxToolBarToolBase *tool = tbar->FindToolForPosition(event.GetX(), event.GetY());
861
862 if ( event.Button(1) )
863 {
864
865 if ( event.LeftDown() || event.LeftDClick() )
866 {
867 if ( !tool || !tool->IsEnabled() )
868 return true;
869
870 m_winCapture = tbar;
871 m_winCapture->CaptureMouse();
872
873 m_toolCapture = tool;
874
875 consumer->PerformAction( wxACTION_BUTTON_PRESS, tool->GetId() );
876
877 return true;
878 }
879 else if ( event.LeftUp() )
880 {
881 if ( m_winCapture )
882 {
883 m_winCapture->ReleaseMouse();
884 m_winCapture = NULL;
885 }
886
887 if (m_toolCapture)
888 {
889 if ( tool == m_toolCapture )
890 consumer->PerformAction( wxACTION_BUTTON_TOGGLE, m_toolCapture->GetId() );
891 else
892 consumer->PerformAction( wxACTION_TOOLBAR_LEAVE, m_toolCapture->GetId() );
893 }
894
895 m_toolCapture = NULL;
896
897 return true;
898 }
899 //else: don't do anything special about the double click
900 }
901
902 return wxStdInputHandler::HandleMouse(consumer, event);
903 }
904
905 bool wxStdToolbarInputHandler::HandleMouseMove(wxInputConsumer *consumer,
906 const wxMouseEvent& event)
907 {
908 if ( !wxStdInputHandler::HandleMouseMove(consumer, event) )
909 {
910 wxToolBar *tbar = wxStaticCast(consumer->GetInputWindow(), wxToolBar);
911
912 wxToolBarTool *tool;
913 if ( event.Leaving() )
914 {
915 // We cannot possibly be over a tool when
916 // leaving the toolbar
917 tool = NULL;
918 }
919 else
920 {
921 tool = (wxToolBarTool*) tbar->FindToolForPosition( event.GetX(), event.GetY() );
922 }
923
924 if (m_toolCapture)
925 {
926 // During capture we only care of the captured tool
927 if (tool && (tool != m_toolCapture))
928 tool = NULL;
929
930 if (tool == m_toolLast)
931 return true;
932
933 if (tool)
934 consumer->PerformAction( wxACTION_BUTTON_PRESS, m_toolCapture->GetId() );
935 else
936 consumer->PerformAction( wxACTION_BUTTON_RELEASE, m_toolCapture->GetId() );
937
938 m_toolLast = tool;
939 }
940 else
941 {
942 if (tool == m_toolLast)
943 return true;
944
945 if (m_toolLast)
946 {
947 // Leave old tool if any
948 consumer->PerformAction( wxACTION_TOOLBAR_LEAVE, m_toolLast->GetId() );
949 }
950
951 if (tool)
952 {
953 // Enter new tool if any
954 consumer->PerformAction( wxACTION_TOOLBAR_ENTER, tool->GetId() );
955 }
956
957 m_toolLast = tool;
958 }
959
960 return true;
961 }
962
963 return false;
964 }
965
966 bool wxStdToolbarInputHandler::HandleFocus(wxInputConsumer *consumer,
967 const wxFocusEvent& WXUNUSED(event))
968 {
969 if ( m_toolCapture )
970 {
971 // We shouldn't be left with a highlighted button
972 consumer->PerformAction( wxACTION_TOOLBAR_LEAVE, m_toolCapture->GetId() );
973 }
974
975 return true;
976 }
977
978 bool wxStdToolbarInputHandler::HandleActivation(wxInputConsumer *consumer,
979 bool activated)
980 {
981 if (m_toolCapture && !activated)
982 {
983 // We shouldn't be left with a highlighted button
984 consumer->PerformAction( wxACTION_TOOLBAR_LEAVE, m_toolCapture->GetId() );
985 }
986
987 return true;
988 }
989
990 #endif // wxUSE_TOOLBAR