]> git.saurik.com Git - wxWidgets.git/blob - src/univ/toolbar.cpp
fixed compilation problem with old gcc releases
[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 #ifdef __GNUG__
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/toolbar.h"
42 #include "wx/image.h"
43
44 // ----------------------------------------------------------------------------
45 // constants
46 // ----------------------------------------------------------------------------
47
48 // value meaning that m_widthSeparator is not initialized
49 static const wxCoord INVALID_WIDTH = -1;
50
51 // ----------------------------------------------------------------------------
52 // wxToolBarTool: our implementation of wxToolBarToolBase
53 // ----------------------------------------------------------------------------
54
55 class WXDLLEXPORT wxToolBarTool : public wxToolBarToolBase
56 {
57 public:
58 wxToolBarTool( wxToolBarBase *tbar = (wxToolBarBase *)NULL,
59 int id = wxID_SEPARATOR,
60 const wxBitmap& bitmap1 = wxNullBitmap,
61 const wxBitmap& bitmap2 = wxNullBitmap,
62 bool toggle = FALSE,
63 wxObject *clientData = (wxObject *) NULL,
64 const wxString& shortHelpString = wxEmptyString,
65 const wxString& longHelpString = wxEmptyString )
66 : wxToolBarToolBase(tbar, id, bitmap1, bitmap2, toggle, clientData,
67 shortHelpString, longHelpString)
68 {
69 // no position yet
70 m_x =
71 m_y = -1;
72
73 // not pressed yet
74 m_isInverted = FALSE;
75 }
76
77 // is this tool pressed, even temporarily? (this is different from being
78 // permanently toggled which is what IsToggled() returns)
79 bool IsPressed() const
80 { return CanBeToggled() ? IsToggled() != m_isInverted : m_isInverted; }
81
82 // are we temporarily pressed/unpressed?
83 bool IsInverted() const { return m_isInverted; }
84
85 // press the tool temporarily by inverting its toggle state
86 void Invert() { m_isInverted = !m_isInverted; }
87
88 public:
89 // the tool position (the size is known by the toolbar itself)
90 int m_x,
91 m_y;
92
93 private:
94 // TRUE if the tool is pressed
95 bool m_isInverted;
96 };
97
98 // ============================================================================
99 // wxToolBar implementation
100 // ============================================================================
101
102 IMPLEMENT_DYNAMIC_CLASS(wxToolBar, wxControl);
103
104 // ----------------------------------------------------------------------------
105 // wxToolBar creation
106 // ----------------------------------------------------------------------------
107
108 void wxToolBar::Init()
109 {
110 // no tools yet
111 m_needsLayout = FALSE;
112
113 // unknown widths for the tools and separators
114 m_widthSeparator = INVALID_WIDTH;
115
116 m_maxWidth =
117 m_maxHeight = 0;
118
119 m_toolPressed = NULL;
120 m_toolCurrent = NULL;
121
122 wxRenderer *renderer = GetRenderer();
123
124 SetToolBitmapSize(renderer->GetToolBarButtonSize(&m_widthSeparator));
125 SetMargins(renderer->GetToolBarMargin());
126 }
127
128 bool wxToolBar::Create(wxWindow *parent,
129 wxWindowID id,
130 const wxPoint& pos,
131 const wxSize& size,
132 long style,
133 const wxString& name)
134 {
135 if ( !wxToolBarBase::Create(parent, id, pos, size, style,
136 wxDefaultValidator, name) )
137 {
138 return FALSE;
139 }
140
141 CreateInputHandler(wxINP_HANDLER_TOOLBAR);
142
143 SetBestSize(size);
144
145 return TRUE;
146 }
147
148 wxToolBar::~wxToolBar()
149 {
150 }
151
152 // ----------------------------------------------------------------------------
153 // wxToolBar tool-related methods
154 // ----------------------------------------------------------------------------
155
156 wxToolBarToolBase *wxToolBar::FindToolForPosition(wxCoord x, wxCoord y) const
157 {
158 // check the "other" direction first: it must be inside the toolbar or we
159 // don't risk finding anything
160 if ( IsVertical() )
161 {
162 if ( x < 0 || x > m_maxWidth )
163 return NULL;
164
165 // we always use x, even for a vertical toolbar, this makes the code
166 // below simpler
167 x = y;
168 }
169 else // horizontal
170 {
171 if ( y < 0 || y > m_maxHeight )
172 return NULL;
173 }
174
175 for ( wxToolBarToolsList::Node *node = m_tools.GetFirst();
176 node;
177 node = node->GetNext() )
178 {
179 wxToolBarToolBase *tool = node->GetData();
180 wxRect rectTool = GetToolRect(tool);
181
182 wxCoord startTool, endTool;
183 GetRectLimits(rectTool, &startTool, &endTool);
184
185 if ( x >= startTool && x <= endTool )
186 {
187 // don't return the separators from here, they don't accept any
188 // input anyhow
189 return tool->IsSeparator() ? NULL : tool;
190 }
191 }
192
193 return NULL;
194 }
195
196 void wxToolBar::SetToolShortHelp(int id, const wxString& help)
197 {
198 wxToolBarToolBase *tool = FindById(id);
199
200 wxCHECK_RET( tool, _T("SetToolShortHelp: no such tool") );
201
202 tool->SetShortHelp(help);
203 }
204
205 bool wxToolBar::DoInsertTool(size_t WXUNUSED(pos),
206 wxToolBarToolBase * WXUNUSED(tool))
207 {
208 // recalculate the toolbar geometry before redrawing it the next time
209 m_needsLayout = TRUE;
210
211 // and ensure that we indeed are going to redraw
212 Refresh();
213
214 return TRUE;
215 }
216
217 bool wxToolBar::DoDeleteTool(size_t WXUNUSED(pos),
218 wxToolBarToolBase * WXUNUSED(tool))
219 {
220 // as above
221 m_needsLayout = TRUE;
222
223 Refresh();
224
225 return TRUE;
226 }
227
228 void wxToolBar::DoEnableTool(wxToolBarToolBase *tool, bool enable)
229 {
230 // created disabled-state bitmap on demand
231 if ( !enable && !tool->GetDisabledBitmap().Ok() )
232 {
233 wxImage image( tool->GetNormalBitmap() );
234
235 // TODO: don't hardcode 180
236 unsigned char bg_red = 180;
237 unsigned char bg_green = 180;
238 unsigned char bg_blue = 180;
239
240 unsigned char mask_red = image.GetMaskRed();
241 unsigned char mask_green = image.GetMaskGreen();
242 unsigned char mask_blue = image.GetMaskBlue();
243
244 bool has_mask = image.HasMask();
245
246 int x,y;
247 for (y = 0; y < image.GetHeight(); y++)
248 {
249 for (x = 0; x < image.GetWidth(); x++)
250 {
251 unsigned char red = image.GetRed(x,y);
252 unsigned char green = image.GetGreen(x,y);
253 unsigned char blue = image.GetBlue(x,y);
254 if (!has_mask || red != mask_red || green != mask_green || blue != mask_blue)
255 {
256 red = (((wxInt32) red - bg_red) >> 1) + bg_red;
257 green = (((wxInt32) green - bg_green) >> 1) + bg_green;
258 blue = (((wxInt32) blue - bg_blue) >> 1) + bg_blue;
259 image.SetRGB( x, y, red, green, blue );
260 }
261 }
262 }
263
264 for (y = 0; y < image.GetHeight(); y++)
265 {
266 for (x = y % 2; x < image.GetWidth(); x += 2)
267 {
268 unsigned char red = image.GetRed(x,y);
269 unsigned char green = image.GetGreen(x,y);
270 unsigned char blue = image.GetBlue(x,y);
271 if (!has_mask || red != mask_red || green != mask_green || blue != mask_blue)
272 {
273 red = (((wxInt32) red - bg_red) >> 1) + bg_red;
274 green = (((wxInt32) green - bg_green) >> 1) + bg_green;
275 blue = (((wxInt32) blue - bg_blue) >> 1) + bg_blue;
276 image.SetRGB( x, y, red, green, blue );
277 }
278 }
279 }
280
281 tool->SetDisabledBitmap( image.ConvertToBitmap() );
282 }
283
284 RefreshTool(tool);
285 }
286
287 void wxToolBar::DoToggleTool(wxToolBarToolBase *tool, bool WXUNUSED(toggle))
288 {
289 // note that if we're called the tool did change state (the base class
290 // checks for it), so it's not necessary to check for this again here
291 RefreshTool(tool);
292 }
293
294 void wxToolBar::DoSetToggle(wxToolBarToolBase *tool, bool WXUNUSED(toggle))
295 {
296 RefreshTool(tool);
297 }
298
299 wxToolBarToolBase *wxToolBar::CreateTool(int id,
300 const wxBitmap& bitmap1,
301 const wxBitmap& bitmap2,
302 bool toggle,
303 wxObject *clientData,
304 const wxString& shortHelpString,
305 const wxString& longHelpString)
306 {
307 return new wxToolBarTool( this, id, bitmap1, bitmap2, toggle,
308 clientData, shortHelpString, longHelpString);
309 }
310
311 wxToolBarToolBase *wxToolBar::CreateTool(wxControl *control)
312 {
313 wxFAIL_MSG( wxT("Toolbar doesn't support controls yet (TODO)") );
314
315 return NULL;
316 }
317
318 // ----------------------------------------------------------------------------
319 // wxToolBar geometry
320 // ----------------------------------------------------------------------------
321
322 wxRect wxToolBar::GetToolRect(wxToolBarToolBase *toolBase) const
323 {
324 const wxToolBarTool *tool = (wxToolBarTool *)toolBase;
325
326 wxRect rect;
327
328 wxCHECK_MSG( tool, rect, _T("GetToolRect: NULL tool") );
329
330 // ensure that we always have the valid tool position
331 if ( m_needsLayout )
332 {
333 wxConstCast(this, wxToolBar)->DoLayout();
334 }
335
336 rect.x = tool->m_x - m_xMargin;
337 rect.y = tool->m_y - m_yMargin;
338
339 if ( IsVertical() )
340 {
341 rect.width = m_defaultWidth;
342 rect.height = tool->IsSeparator() ? m_widthSeparator : m_defaultHeight;
343 }
344 else // horizontal
345 {
346 rect.width = tool->IsSeparator() ? m_widthSeparator : m_defaultWidth;
347 rect.height = m_defaultHeight;
348 }
349
350 rect.width += 2*m_xMargin;
351 rect.height += 2*m_yMargin;
352
353 return rect;
354 }
355
356 bool wxToolBar::Realize()
357 {
358 if ( !wxToolBarBase::Realize() )
359 return FALSE;
360
361 m_needsLayout = TRUE;
362 DoLayout();
363
364 SetBestSize(wxDefaultSize);
365
366 return TRUE;
367 }
368
369 void wxToolBar::DoLayout()
370 {
371 wxASSERT_MSG( m_needsLayout, _T("why are we called?") );
372
373 m_needsLayout = FALSE;
374
375 wxCoord x = m_xMargin,
376 y = m_yMargin;
377
378 const wxCoord widthTool = IsVertical() ? m_defaultHeight : m_defaultWidth;
379 wxCoord margin = IsVertical() ? m_xMargin : m_yMargin,
380 *pCur = IsVertical() ? &y : &x;
381
382 // calculate the positions of all elements
383 for ( wxToolBarToolsList::Node *node = m_tools.GetFirst();
384 node;
385 node = node->GetNext() )
386 {
387 wxToolBarTool *tool = (wxToolBarTool *) node->GetData();
388
389 tool->m_x = x;
390 tool->m_y = y;
391
392 *pCur += (tool->IsSeparator() ? m_widthSeparator : widthTool) + margin;
393 }
394
395 // calculate the total toolbar size
396 wxCoord xMin = m_defaultWidth + 2*m_xMargin,
397 yMin = m_defaultHeight + 2*m_yMargin;
398
399 m_maxWidth = x < xMin ? xMin : x;
400 m_maxHeight = y < yMin ? yMin : y;
401 }
402
403 wxSize wxToolBar::DoGetBestClientSize() const
404 {
405 return wxSize(m_maxWidth, m_maxHeight);
406 }
407
408 // ----------------------------------------------------------------------------
409 // wxToolBar drawing
410 // ----------------------------------------------------------------------------
411
412 void wxToolBar::RefreshTool(wxToolBarToolBase *tool)
413 {
414 RefreshRect(GetToolRect(tool));
415 }
416
417 void wxToolBar::GetRectLimits(const wxRect& rect,
418 wxCoord *start,
419 wxCoord *end) const
420 {
421 wxCHECK_RET( start && end, _T("NULL pointer in GetRectLimits") );
422
423 if ( IsVertical() )
424 {
425 *start = rect.GetTop();
426 *end = rect.GetBottom();
427 }
428 else // horizontal
429 {
430 *start = rect.GetLeft();
431 *end = rect.GetRight();
432 }
433 }
434
435 void wxToolBar::DoDraw(wxControlRenderer *renderer)
436 {
437 // prepare the variables used below
438 wxDC& dc = renderer->GetDC();
439 wxRenderer *rend = renderer->GetRenderer();
440 // dc.SetFont(GetFont()); -- uncomment when we support labels
441
442 // draw the border separating us from the menubar (if there is no menubar
443 // we probably shouldn't draw it?)
444 if ( !IsVertical() )
445 {
446 rend->DrawHorizontalLine(dc, 0, 0, GetClientSize().x);
447 }
448
449 // get the update rect and its limits depending on the orientation
450 wxRect rectUpdate = GetUpdateClientRect();
451 wxCoord start, end;
452 GetRectLimits(rectUpdate, &start, &end);
453
454 // and redraw all the tools intersecting it
455 for ( wxToolBarToolsList::Node *node = m_tools.GetFirst();
456 node;
457 node = node->GetNext() )
458 {
459 wxToolBarToolBase *tool = node->GetData();
460 wxRect rectTool = GetToolRect(tool);
461 wxCoord startTool, endTool;
462 GetRectLimits(rectTool, &startTool, &endTool);
463
464 if ( endTool < start )
465 {
466 // we're still to the left of the area to redraw
467 continue;
468 }
469
470 if ( startTool > end )
471 {
472 // we're beyond the area to redraw, nothing left to do
473 break;
474 }
475
476 // deal with the flags
477 int flags = 0;
478
479 if ( tool->IsEnabled() )
480 {
481 // the toolbars without wxTB_FLAT don't react to the mouse hovering
482 if ( HasFlag(wxTB_FLAT) && (tool == m_toolCurrent) )
483 flags |= wxCONTROL_CURRENT;
484 }
485 else // disabled tool
486 {
487 flags |= wxCONTROL_DISABLED;
488 }
489
490 if ( tool == m_toolPressed )
491 flags |= wxCONTROL_FOCUSED;
492
493 if ( ((wxToolBarTool *)tool)->IsPressed() )
494 flags |= wxCONTROL_PRESSED;
495
496 wxString label;
497 wxBitmap bitmap;
498 if ( !tool->IsSeparator() )
499 {
500 label = tool->GetLabel();
501 bitmap = tool->GetBitmap();
502 }
503 //else: leave both the label and the bitmap invalid to draw a separator
504
505 rend->DrawToolBarButton(dc, label, bitmap, rectTool, flags);
506 }
507 }
508
509 // ----------------------------------------------------------------------------
510 // wxToolBar actions
511 // ----------------------------------------------------------------------------
512
513 void wxToolBar::Press()
514 {
515 wxCHECK_RET( m_toolCurrent, _T("no tool to press?") );
516
517 wxLogTrace(_T("toolbar"),
518 _T("Button '%s' pressed."),
519 m_toolCurrent->GetShortHelp().c_str());
520
521 // this is the tool whose state is going to change
522 m_toolPressed = (wxToolBarTool *)m_toolCurrent;
523
524 // we must toggle it regardless of whether it is a checkable tool or not,
525 // so use Invert() and not Toggle() here
526 m_toolPressed->Invert();
527
528 RefreshTool(m_toolPressed);
529 }
530
531 void wxToolBar::Release()
532 {
533 wxCHECK_RET( m_toolPressed, _T("no tool to release?") );
534
535 wxLogTrace(_T("toolbar"),
536 _T("Button '%s' released."),
537 m_toolCurrent->GetShortHelp().c_str());
538
539 wxASSERT_MSG( m_toolPressed->IsInverted(), _T("release unpressed button?") );
540
541 m_toolPressed->Invert();
542
543 RefreshTool(m_toolPressed);
544 }
545
546 void wxToolBar::Toggle()
547 {
548 m_toolCurrent = m_toolPressed;
549
550 Release();
551
552 Click();
553 }
554
555 void wxToolBar::Click()
556 {
557 wxCHECK_RET( m_toolCurrent, _T("no tool to click?") );
558
559 bool isToggled;
560 if ( m_toolCurrent->CanBeToggled() )
561 {
562 m_toolCurrent->Toggle();
563
564 RefreshTool(m_toolCurrent);
565
566 isToggled = m_toolCurrent->IsToggled();
567 }
568 else // simple non-checkable tool
569 {
570 isToggled = FALSE;
571 }
572
573 OnLeftClick(m_toolCurrent->GetId(), isToggled);
574 }
575
576 bool wxToolBar::PerformAction(const wxControlAction& action,
577 long numArg,
578 const wxString& strArg)
579 {
580 if ( action == wxACTION_TOOLBAR_TOGGLE )
581 Toggle();
582 else if ( action == wxACTION_TOOLBAR_PRESS )
583 Press();
584 else if ( action == wxACTION_TOOLBAR_RELEASE )
585 Release();
586 else if ( action == wxACTION_TOOLBAR_CLICK )
587 Click();
588 else if ( action == wxACTION_TOOLBAR_ENTER )
589 {
590 wxToolBarToolBase *toolCurrentOld = m_toolCurrent;
591 m_toolCurrent = FindById((int)numArg);
592
593 if ( m_toolCurrent != toolCurrentOld )
594 {
595 // the appearance of the current tool only changes for the flat
596 // toolbars
597 if ( HasFlag(wxTB_FLAT) )
598 {
599 // and only if the tool was/is enabled
600 if ( toolCurrentOld && toolCurrentOld->IsEnabled() )
601 RefreshTool(toolCurrentOld);
602
603 if ( m_toolCurrent )
604 {
605 if ( m_toolCurrent->IsEnabled() )
606 RefreshTool(m_toolCurrent);
607 }
608 else
609 {
610 wxFAIL_MSG( _T("no current tool in wxACTION_TOOLBAR_ENTER?") );
611 }
612 }
613 }
614 }
615 else if ( action == wxACTION_TOOLBAR_LEAVE )
616 {
617 if ( m_toolCurrent )
618 {
619 wxToolBarToolBase *toolCurrentOld = m_toolCurrent;
620 m_toolCurrent = NULL;
621
622 RefreshTool(toolCurrentOld);
623 }
624 }
625 else
626 return wxControl::PerformAction(action, numArg, strArg);
627
628 return TRUE;
629 }
630
631 // ============================================================================
632 // wxStdToolbarInputHandler implementation
633 // ============================================================================
634
635 wxStdToolbarInputHandler::wxStdToolbarInputHandler(wxInputHandler *handler)
636 : wxStdButtonInputHandler(handler)
637 {
638 }
639
640 bool wxStdToolbarInputHandler::HandleKey(wxInputConsumer *consumer,
641 const wxKeyEvent& event,
642 bool pressed)
643 {
644 // TODO: when we have a current button we should allow the arrow
645 // keys to move it
646 return wxStdInputHandler::HandleKey(consumer, event, pressed);
647 }
648
649 bool wxStdToolbarInputHandler::HandleMouse(wxInputConsumer *consumer,
650 const wxMouseEvent& event)
651 {
652 // don't let the base class press the disabled buttons but simply ignore
653 // all events on them
654 wxToolBar *tbar = wxStaticCast(consumer->GetInputWindow(), wxToolBar);
655 wxToolBarToolBase *tool = tbar->FindToolForPosition(event.GetX(), event.GetY());
656
657 if ( !tool || !tool->IsEnabled() )
658 return TRUE;
659
660 return wxStdButtonInputHandler::HandleMouse(consumer, event);
661 }
662
663 bool wxStdToolbarInputHandler::HandleMouseMove(wxInputConsumer *consumer,
664 const wxMouseEvent& event)
665 {
666 if ( !wxStdButtonInputHandler::HandleMouseMove(consumer, event) )
667 {
668 wxToolBarToolBase *tool;
669
670 if ( event.Leaving() )
671 {
672 tool = NULL;
673 }
674 else
675 {
676 wxToolBar *tbar = wxStaticCast(consumer->GetInputWindow(), wxToolBar);
677 tool = tbar->FindToolForPosition(event.GetX(), event.GetY());
678 }
679
680 if ( tool )
681 consumer->PerformAction(wxACTION_TOOLBAR_ENTER, tool->GetId());
682 else
683 consumer->PerformAction(wxACTION_TOOLBAR_LEAVE);
684
685 return TRUE;
686 }
687
688 return FALSE;
689 }
690
691 bool wxStdToolbarInputHandler::HandleFocus(wxInputConsumer *consumer,
692 const wxFocusEvent& event)
693 {
694 // we shouldn't be left with a highlighted button
695 consumer->PerformAction(wxACTION_TOOLBAR_LEAVE);
696
697 return TRUE;
698 }
699
700 bool wxStdToolbarInputHandler::HandleActivation(wxInputConsumer *consumer,
701 bool activated)
702 {
703 // as above
704 if ( !activated )
705 consumer->PerformAction(wxACTION_TOOLBAR_LEAVE);
706
707 return TRUE;
708 }
709
710 #endif // wxUSE_TOOLBAR
711