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