]> git.saurik.com Git - wxWidgets.git/blob - src/common/tbarbase.cpp
overflow fix
[wxWidgets.git] / src / common / tbarbase.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: common/tbarbase.cpp
3 // Purpose: wxToolBarBase implementation
4 // Author: Julian Smart
5 // Modified by: VZ at 11.12.99 (wxScrollableToolBar splitted off)
6 // Created: 04/01/98
7 // RCS-ID: $Id$
8 // Copyright: (c) Julian Smart and Markus Holzem
9 // Licence: wxWindows license
10 /////////////////////////////////////////////////////////////////////////////
11
12 // ============================================================================
13 // declarations
14 // ============================================================================
15
16 // ----------------------------------------------------------------------------
17 // headers
18 // ----------------------------------------------------------------------------
19
20 #ifdef __GNUG__
21 #pragma implementation "tbarbase.h"
22 #endif
23
24 // For compilers that support precompilation, includes "wx.h".
25 #include "wx/wxprec.h"
26
27 #ifdef __BORLANDC__
28 #pragma hdrstop
29 #endif
30
31 #if wxUSE_TOOLBAR
32
33 #ifndef WX_PRECOMP
34 #include "wx/control.h"
35 #endif
36
37 #include "wx/frame.h"
38 #include "wx/image.h"
39 #include "wx/settings.h"
40
41 #include "wx/tbarbase.h"
42
43 // ----------------------------------------------------------------------------
44 // wxWindows macros
45 // ----------------------------------------------------------------------------
46
47 IMPLEMENT_CLASS(wxToolBarBase, wxControl)
48
49 BEGIN_EVENT_TABLE(wxToolBarBase, wxControl)
50 EVT_IDLE(wxToolBarBase::OnIdle)
51 END_EVENT_TABLE()
52
53 #include "wx/listimpl.cpp"
54
55 WX_DEFINE_LIST(wxToolBarToolsList);
56
57 // ============================================================================
58 // implementation
59 // ============================================================================
60
61 // ----------------------------------------------------------------------------
62 // wxToolBarToolBase
63 // ----------------------------------------------------------------------------
64
65 bool wxToolBarToolBase::Enable(bool enable)
66 {
67 if ( m_enabled == enable )
68 return FALSE;
69
70 m_enabled = enable;
71
72 return TRUE;
73 }
74
75 bool wxToolBarToolBase::Toggle(bool toggle)
76 {
77 wxASSERT_MSG( CanBeToggled(), _T("can't toggle this tool") );
78
79 if ( m_toggled == toggle )
80 return FALSE;
81
82 m_toggled = toggle;
83
84 return TRUE;
85 }
86
87 bool wxToolBarToolBase::SetToggle(bool toggle)
88 {
89 wxItemKind kind = toggle ? wxITEM_CHECK : wxITEM_NORMAL;
90 if ( m_kind == kind )
91 return FALSE;
92
93 m_kind = kind;
94
95 return TRUE;
96 }
97
98 bool wxToolBarToolBase::SetShortHelp(const wxString& help)
99 {
100 if ( m_shortHelpString == help )
101 return FALSE;
102
103 m_shortHelpString = help;
104
105 return TRUE;
106 }
107
108 bool wxToolBarToolBase::SetLongHelp(const wxString& help)
109 {
110 if ( m_longHelpString == help )
111 return FALSE;
112
113 m_longHelpString = help;
114
115 return TRUE;
116 }
117
118 wxToolBarToolBase::~wxToolBarToolBase()
119 {
120 }
121
122 // ----------------------------------------------------------------------------
123 // wxToolBarBase adding/deleting items
124 // ----------------------------------------------------------------------------
125
126 wxToolBarBase::wxToolBarBase()
127 {
128 // the list owns the pointers
129 m_tools.DeleteContents(TRUE);
130
131 m_xMargin = m_yMargin = 0;
132
133 m_maxRows = m_maxCols = 0;
134 }
135
136 wxToolBarToolBase *wxToolBarBase::DoAddTool(int id,
137 const wxString& label,
138 const wxBitmap& bitmap,
139 const wxBitmap& bmpDisabled,
140 wxItemKind kind,
141 const wxString& shortHelp,
142 const wxString& longHelp,
143 wxObject *clientData,
144 wxCoord WXUNUSED(xPos),
145 wxCoord WXUNUSED(yPos))
146 {
147 return InsertTool(GetToolsCount(), id, label, bitmap, bmpDisabled,
148 kind, shortHelp, longHelp, clientData);
149 }
150
151 wxToolBarToolBase *wxToolBarBase::InsertTool(size_t pos,
152 int id,
153 const wxString& label,
154 const wxBitmap& bitmap,
155 const wxBitmap& bmpDisabled,
156 wxItemKind kind,
157 const wxString& shortHelp,
158 const wxString& longHelp,
159 wxObject *clientData)
160 {
161 wxCHECK_MSG( pos <= GetToolsCount(), (wxToolBarToolBase *)NULL,
162 _T("invalid position in wxToolBar::InsertTool()") );
163
164 wxToolBarToolBase *tool = CreateTool(id, label, bitmap, bmpDisabled, kind,
165 clientData, shortHelp, longHelp);
166
167 if ( !InsertTool(pos, tool) )
168 {
169 delete tool;
170
171 return NULL;
172 }
173
174 return tool;
175 }
176
177 wxToolBarToolBase *wxToolBarBase::AddTool(wxToolBarToolBase *tool)
178 {
179 return InsertTool(GetToolsCount(), tool);
180 }
181
182 wxToolBarToolBase *
183 wxToolBarBase::InsertTool(size_t pos, wxToolBarToolBase *tool)
184 {
185 wxCHECK_MSG( pos <= GetToolsCount(), (wxToolBarToolBase *)NULL,
186 _T("invalid position in wxToolBar::InsertTool()") );
187
188 if ( !tool || !DoInsertTool(pos, tool) )
189 {
190 return NULL;
191 }
192
193 m_tools.Insert(pos, tool);
194
195 return tool;
196 }
197
198 wxToolBarToolBase *wxToolBarBase::AddControl(wxControl *control)
199 {
200 return InsertControl(GetToolsCount(), control);
201 }
202
203 wxToolBarToolBase *wxToolBarBase::InsertControl(size_t pos, wxControl *control)
204 {
205 wxCHECK_MSG( control, (wxToolBarToolBase *)NULL,
206 _T("toolbar: can't insert NULL control") );
207
208 wxCHECK_MSG( control->GetParent() == this, (wxToolBarToolBase *)NULL,
209 _T("control must have toolbar as parent") );
210
211 wxCHECK_MSG( pos <= GetToolsCount(), (wxToolBarToolBase *)NULL,
212 _T("invalid position in wxToolBar::InsertControl()") );
213
214 wxToolBarToolBase *tool = CreateTool(control);
215
216 if ( !InsertTool(pos, tool) )
217 {
218 delete tool;
219
220 return NULL;
221 }
222
223 return tool;
224 }
225
226 wxControl *wxToolBarBase::FindControl( int id )
227 {
228 for ( wxToolBarToolsList::Node* node = m_tools.GetFirst();
229 node;
230 node = node->GetNext() )
231 {
232 const wxToolBarToolBase * const tool = node->GetData();
233 if ( tool->IsControl() )
234 {
235 wxControl * const control = tool->GetControl();
236
237 if ( !control )
238 {
239 wxFAIL_MSG( _T("NULL control in toolbar?") );
240 }
241 else if ( control->GetId() == id )
242 {
243 // found
244 return control;
245 }
246 }
247 }
248
249 return NULL;
250 }
251
252 wxToolBarToolBase *wxToolBarBase::AddSeparator()
253 {
254 return InsertSeparator(GetToolsCount());
255 }
256
257 wxToolBarToolBase *wxToolBarBase::InsertSeparator(size_t pos)
258 {
259 wxCHECK_MSG( pos <= GetToolsCount(), (wxToolBarToolBase *)NULL,
260 _T("invalid position in wxToolBar::InsertSeparator()") );
261
262 wxToolBarToolBase *tool = CreateTool(wxID_SEPARATOR,
263 wxEmptyString,
264 wxNullBitmap, wxNullBitmap,
265 wxITEM_SEPARATOR, (wxObject *)NULL,
266 wxEmptyString, wxEmptyString);
267
268 if ( !tool || !DoInsertTool(pos, tool) )
269 {
270 delete tool;
271
272 return NULL;
273 }
274
275 m_tools.Insert(pos, tool);
276
277 return tool;
278 }
279
280 wxToolBarToolBase *wxToolBarBase::RemoveTool(int id)
281 {
282 size_t pos = 0;
283 wxToolBarToolsList::Node *node;
284 for ( node = m_tools.GetFirst(); node; node = node->GetNext() )
285 {
286 if ( node->GetData()->GetId() == id )
287 break;
288
289 pos++;
290 }
291
292 if ( !node )
293 {
294 // don't give any error messages - sometimes we might call RemoveTool()
295 // without knowing whether the tool is or not in the toolbar
296 return (wxToolBarToolBase *)NULL;
297 }
298
299 wxToolBarToolBase *tool = node->GetData();
300 if ( !DoDeleteTool(pos, tool) )
301 {
302 return (wxToolBarToolBase *)NULL;
303 }
304
305 // the node would delete the data, so set it to NULL to avoid this
306 node->SetData(NULL);
307
308 m_tools.DeleteNode(node);
309
310 return tool;
311 }
312
313 bool wxToolBarBase::DeleteToolByPos(size_t pos)
314 {
315 wxCHECK_MSG( pos < GetToolsCount(), FALSE,
316 _T("invalid position in wxToolBar::DeleteToolByPos()") );
317
318 wxToolBarToolsList::Node *node = m_tools.Item(pos);
319
320 if ( !DoDeleteTool(pos, node->GetData()) )
321 {
322 return FALSE;
323 }
324
325 m_tools.DeleteNode(node);
326
327 return TRUE;
328 }
329
330 bool wxToolBarBase::DeleteTool(int id)
331 {
332 size_t pos = 0;
333 wxToolBarToolsList::Node *node;
334 for ( node = m_tools.GetFirst(); node; node = node->GetNext() )
335 {
336 if ( node->GetData()->GetId() == id )
337 break;
338
339 pos++;
340 }
341
342 if ( !node || !DoDeleteTool(pos, node->GetData()) )
343 {
344 return FALSE;
345 }
346
347 m_tools.DeleteNode(node);
348
349 return TRUE;
350 }
351
352 wxToolBarToolBase *wxToolBarBase::FindById(int id) const
353 {
354 wxToolBarToolBase *tool = (wxToolBarToolBase *)NULL;
355
356 for ( wxToolBarToolsList::Node *node = m_tools.GetFirst();
357 node;
358 node = node->GetNext() )
359 {
360 tool = node->GetData();
361 if ( tool->GetId() == id )
362 {
363 // found
364 break;
365 }
366
367 tool = NULL;
368 }
369
370 return tool;
371 }
372
373 void wxToolBarBase::ClearTools()
374 {
375 m_tools.Clear();
376 }
377
378 bool wxToolBarBase::Realize()
379 {
380 return TRUE;
381 }
382
383 wxToolBarBase::~wxToolBarBase()
384 {
385 }
386
387 // ----------------------------------------------------------------------------
388 // wxToolBarBase tools state
389 // ----------------------------------------------------------------------------
390
391 void wxToolBarBase::EnableTool(int id, bool enable)
392 {
393 wxToolBarToolBase *tool = FindById(id);
394 if ( tool )
395 {
396 if ( tool->Enable(enable) )
397 {
398 DoEnableTool(tool, enable);
399 }
400 }
401 }
402
403 void wxToolBarBase::ToggleTool(int id, bool toggle)
404 {
405 wxToolBarToolBase *tool = FindById(id);
406 if ( tool && tool->CanBeToggled() )
407 {
408 if ( tool->Toggle(toggle) )
409 {
410 DoToggleTool(tool, toggle);
411 }
412 }
413 }
414
415 void wxToolBarBase::SetToggle(int id, bool toggle)
416 {
417 wxToolBarToolBase *tool = FindById(id);
418 if ( tool )
419 {
420 if ( tool->SetToggle(toggle) )
421 {
422 DoSetToggle(tool, toggle);
423 }
424 }
425 }
426
427 void wxToolBarBase::SetToolShortHelp(int id, const wxString& help)
428 {
429 wxToolBarToolBase *tool = FindById(id);
430 if ( tool )
431 {
432 (void)tool->SetShortHelp(help);
433 }
434 }
435
436 void wxToolBarBase::SetToolLongHelp(int id, const wxString& help)
437 {
438 wxToolBarToolBase *tool = FindById(id);
439 if ( tool )
440 {
441 (void)tool->SetLongHelp(help);
442 }
443 }
444
445 wxObject *wxToolBarBase::GetToolClientData(int id) const
446 {
447 wxToolBarToolBase *tool = FindById(id);
448
449 return tool ? tool->GetClientData() : (wxObject *)NULL;
450 }
451
452 void wxToolBarBase::SetToolClientData(int id, wxObject *clientData)
453 {
454 wxToolBarToolBase *tool = FindById(id);
455
456 wxCHECK_RET( tool, _T("no such tool in wxToolBar::SetToolClientData") );
457
458 tool->SetClientData(clientData);
459 }
460
461 bool wxToolBarBase::GetToolState(int id) const
462 {
463 wxToolBarToolBase *tool = FindById(id);
464 wxCHECK_MSG( tool, FALSE, _T("no such tool") );
465
466 return tool->IsToggled();
467 }
468
469 bool wxToolBarBase::GetToolEnabled(int id) const
470 {
471 wxToolBarToolBase *tool = FindById(id);
472 wxCHECK_MSG( tool, FALSE, _T("no such tool") );
473
474 return tool->IsEnabled();
475 }
476
477 wxString wxToolBarBase::GetToolShortHelp(int id) const
478 {
479 wxToolBarToolBase *tool = FindById(id);
480 wxCHECK_MSG( tool, _T(""), _T("no such tool") );
481
482 return tool->GetShortHelp();
483 }
484
485 wxString wxToolBarBase::GetToolLongHelp(int id) const
486 {
487 wxToolBarToolBase *tool = FindById(id);
488 wxCHECK_MSG( tool, _T(""), _T("no such tool") );
489
490 return tool->GetLongHelp();
491 }
492
493 // ----------------------------------------------------------------------------
494 // wxToolBarBase geometry
495 // ----------------------------------------------------------------------------
496
497 void wxToolBarBase::SetMargins(int x, int y)
498 {
499 m_xMargin = x;
500 m_yMargin = y;
501 }
502
503 void wxToolBarBase::SetRows(int WXUNUSED(nRows))
504 {
505 // nothing
506 }
507
508 // ----------------------------------------------------------------------------
509 // event processing
510 // ----------------------------------------------------------------------------
511
512 // Only allow toggle if returns TRUE
513 bool wxToolBarBase::OnLeftClick(int id, bool toggleDown)
514 {
515 wxCommandEvent event(wxEVT_COMMAND_TOOL_CLICKED, id);
516 event.SetEventObject(this);
517
518 // we use SetInt() to make wxCommandEvent::IsChecked() return toggleDown
519 event.SetInt((int)toggleDown);
520
521 // and SetExtraLong() for backwards compatibility
522 event.SetExtraLong((long)toggleDown);
523
524 // Send events to this toolbar instead (and thence up the window hierarchy)
525 GetEventHandler()->ProcessEvent(event);
526
527 return TRUE;
528 }
529
530 // Call when right button down.
531 void wxToolBarBase::OnRightClick(int id,
532 long WXUNUSED(x),
533 long WXUNUSED(y))
534 {
535 wxCommandEvent event(wxEVT_COMMAND_TOOL_RCLICKED, id);
536 event.SetEventObject(this);
537 event.SetInt(id);
538
539 GetEventHandler()->ProcessEvent(event);
540 }
541
542 // Called when the mouse cursor enters a tool bitmap (no button pressed).
543 // Argument is -1 if mouse is exiting the toolbar.
544 // Note that for this event, the id of the window is used,
545 // and the integer parameter of wxCommandEvent is used to retrieve
546 // the tool id.
547 void wxToolBarBase::OnMouseEnter(int id)
548 {
549 wxCommandEvent event(wxEVT_COMMAND_TOOL_ENTER, GetId());
550 event.SetEventObject(this);
551 event.SetInt(id);
552
553 wxFrame *frame = wxDynamicCast(GetParent(), wxFrame);
554 if( frame )
555 {
556 wxToolBarToolBase* tool = id == -1 ? (wxToolBarToolBase*)0 : FindById(id);
557 wxString help = tool ? tool->GetLongHelp() : wxString();
558 frame->DoGiveHelp( help, id != -1 );
559 }
560
561 (void)GetEventHandler()->ProcessEvent(event);
562 }
563
564 // ----------------------------------------------------------------------------
565 // UI updates
566 // ----------------------------------------------------------------------------
567
568 void wxToolBarBase::OnIdle(wxIdleEvent& event)
569 {
570 DoToolbarUpdates();
571
572 event.Skip();
573 }
574
575 // Do the toolbar button updates (check for EVT_UPDATE_UI handlers)
576 void wxToolBarBase::DoToolbarUpdates()
577 {
578 wxWindow* parent = this;
579 while (parent->GetParent())
580 parent = parent->GetParent();
581
582 // This kind of #ifdef is a good way to annoy people. It breaks
583 // apps, but only on one platform and due to a hack in officially
584 // platform independent code. It took me hours to fix this. RR.
585 //
586 // #ifdef __WXMSW__
587 // wxWindow* focusWin = wxFindFocusDescendant(parent);
588 // #else
589 wxWindow* focusWin = (wxWindow*) NULL;
590 // #endif
591
592 wxEvtHandler* evtHandler = focusWin ? focusWin->GetEventHandler() : GetEventHandler() ;
593
594 for ( wxToolBarToolsList::Node* node = m_tools.GetFirst();
595 node;
596 node = node->GetNext() )
597 {
598 int id = node->GetData()->GetId();
599
600 wxUpdateUIEvent event(id);
601 event.SetEventObject(this);
602
603 if ( evtHandler->ProcessEvent(event) )
604 {
605 if ( event.GetSetEnabled() )
606 EnableTool(id, event.GetEnabled());
607 if ( event.GetSetChecked() )
608 ToggleTool(id, event.GetChecked());
609 #if 0
610 if ( event.GetSetText() )
611 // Set tooltip?
612 #endif // 0
613 }
614 }
615 }
616
617 // Helper function, used by wxCreateGreyedImage
618
619 static void wxGreyOutImage( const wxImage& src,
620 wxImage& dest,
621 const wxColour& darkCol,
622 const wxColour& lightCol,
623 const wxColour& bgCol )
624 {
625 // Second attempt, just making things monochrome
626 int width = src.GetWidth();
627 int height = src.GetHeight();
628
629 int redCur, greenCur, blueCur;
630 for ( int x = 0; x < width; x++ )
631 {
632 for ( int y = 1; y < height; y++ )
633 {
634 redCur = src.GetRed(x, y);
635 greenCur = src.GetGreen(x, y);
636 blueCur = src.GetBlue(x, y);
637
638 // Change light things to the background colour
639 if ( redCur >= (lightCol.Red() - 50) && greenCur >= (lightCol.Green() - 50) && blueCur >= (lightCol.Blue() - 50) )
640 {
641 dest.SetRGB(x,y, bgCol.Red(), bgCol.Green(), bgCol.Blue());
642 }
643 else if ( redCur == bgCol.Red() && greenCur == bgCol.Green() && blueCur == bgCol.Blue() )
644 {
645 // Leave the background colour as-is
646 // dest.SetRGB(x,y, bgCol.Red(), bgCol.Green(), bgCol.Blue());
647 }
648 else // if ( redCur <= darkCol.Red() && greenCur <= darkCol.Green() && blueCur <= darkCol.Blue() )
649 {
650 // Change dark things to really dark
651 dest.SetRGB(x,y, darkCol.Red(), darkCol.Green(), darkCol.Blue());
652 }
653 }
654 }
655 }
656
657 /*
658 * Make a greyed-out image suitable for disabled buttons.
659 * This code is adapted from wxNewBitmapButton in FL.
660 */
661
662 bool wxCreateGreyedImage(const wxImage& in, wxImage& out)
663 {
664 out = in.Copy();
665
666 // assuming the pixels along the edges are of the background color
667 wxColour bgCol(in.GetRed(0, 0), in.GetGreen(0, 0), in.GetBlue(0, 0));
668
669 wxColour darkCol = wxSystemSettings::GetColour(wxSYS_COLOUR_3DSHADOW) ;
670 wxColour lightCol = wxSystemSettings::GetColour(wxSYS_COLOUR_3DHIGHLIGHT) ;
671
672 wxGreyOutImage(in, out, darkCol, lightCol, bgCol);
673
674 return TRUE;
675 }
676
677 #endif // wxUSE_TOOLBAR