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