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