]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/gtk/tbargtk.cpp
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
guard code for mac / quickdraw
[wxWidgets.git] / src / gtk / tbargtk.cpp
... / ...
CommitLineData
1/////////////////////////////////////////////////////////////////////////////
2// Name: src/gtk/tbargtk.cpp
3// Purpose: GTK toolbar
4// Author: Robert Roebling
5// Modified: 13.12.99 by VZ to derive from wxToolBarBase
6// RCS-ID: $Id$
7// Copyright: (c) Robert Roebling
8// Licence: wxWindows licence
9/////////////////////////////////////////////////////////////////////////////
10
11// For compilers that support precompilation, includes "wx.h".
12#include "wx/wxprec.h"
13
14#if wxUSE_TOOLBAR_NATIVE
15
16#include "wx/toolbar.h"
17
18#ifndef WX_PRECOMP
19 #include "wx/menu.h"
20#endif
21
22// FIXME: Use GtkImage instead of GtkPixmap. Use the new toolbar API for when gtk runtime is new enough?
23// Beware that the new and old toolbar API may not be mixed in usage.
24#undef GTK_DISABLE_DEPRECATED
25
26#include "wx/gtk/private.h"
27
28/* XPM */
29static const char *arrow_down_xpm[] = {
30/* columns rows colors chars-per-pixel */
31"7 7 2 1",
32" c None",
33". c Black",
34/* pixels */
35" ",
36" ",
37" ",
38".......",
39" ..... ",
40" ... ",
41" . "
42};
43
44
45// ----------------------------------------------------------------------------
46// globals
47// ----------------------------------------------------------------------------
48
49// data
50extern bool g_blockEventsOnDrag;
51extern wxCursor g_globalCursor;
52
53// ----------------------------------------------------------------------------
54// private functions
55// ----------------------------------------------------------------------------
56
57// translate wxWidgets toolbar style flags to GTK orientation and style
58static void GetGtkStyle(long style,
59 GtkOrientation *orient, GtkToolbarStyle *gtkStyle)
60{
61 *orient = ( style & wxTB_LEFT || style & wxTB_RIGHT ) ? GTK_ORIENTATION_VERTICAL : GTK_ORIENTATION_HORIZONTAL;
62
63
64 if ( style & wxTB_TEXT )
65 {
66 *gtkStyle = style & wxTB_NOICONS
67 ? GTK_TOOLBAR_TEXT
68 : (
69 style & wxTB_HORZ_LAYOUT ? GTK_TOOLBAR_BOTH_HORIZ :
70 GTK_TOOLBAR_BOTH);
71 }
72 else // no text, hence we must have the icons or what would we show?
73 {
74 *gtkStyle = GTK_TOOLBAR_ICONS;
75 }
76}
77
78// ----------------------------------------------------------------------------
79// wxToolBarTool
80// ----------------------------------------------------------------------------
81
82class wxToolBarTool : public wxToolBarToolBase
83{
84public:
85 wxToolBarTool(wxToolBar *tbar,
86 int id,
87 const wxString& label,
88 const wxBitmap& bitmap1,
89 const wxBitmap& bitmap2,
90 wxItemKind kind,
91 wxObject *clientData,
92 const wxString& shortHelpString,
93 const wxString& longHelpString)
94 : wxToolBarToolBase(tbar, id, label, bitmap1, bitmap2, kind,
95 clientData, shortHelpString, longHelpString)
96 {
97 Init();
98 }
99
100 wxToolBarTool(wxToolBar *tbar, wxControl *control, const wxString& label)
101 : wxToolBarToolBase(tbar, control, label)
102 {
103 Init();
104 }
105
106 // is this a radio button?
107 //
108 // unlike GetKind(), can be called for any kind of tools, not just buttons
109 bool IsRadio() const { return IsButton() && GetKind() == wxITEM_RADIO; }
110
111 // this is only called for the normal buttons, i.e. not separators nor
112 // controls
113 GtkToolbarChildType GetGtkChildType() const
114 {
115 switch ( GetKind() )
116 {
117 case wxITEM_CHECK:
118 return GTK_TOOLBAR_CHILD_TOGGLEBUTTON;
119
120 case wxITEM_RADIO:
121 return GTK_TOOLBAR_CHILD_RADIOBUTTON;
122
123 default:
124 wxFAIL_MSG( _T("unknown toolbar child type") );
125 // fall through
126
127 case wxITEM_DROPDOWN:
128 case wxITEM_NORMAL:
129 return GTK_TOOLBAR_CHILD_BUTTON;
130 }
131 }
132
133 void SetImage(const wxBitmap& bitmap)
134 {
135 if (bitmap.Ok())
136 {
137 // setting from pixmap doesn't seem to work right, but pixbuf works well
138 gtk_image_set_from_pixbuf((GtkImage*)m_image, bitmap.GetPixbuf());
139 }
140 }
141
142 GtkWidget *m_item;
143 GtkWidget *m_image;
144
145protected:
146 void Init();
147};
148
149// ----------------------------------------------------------------------------
150// wxWin macros
151// ----------------------------------------------------------------------------
152
153IMPLEMENT_DYNAMIC_CLASS(wxToolBar, wxControl)
154
155// ============================================================================
156// implementation
157// ============================================================================
158
159//-----------------------------------------------------------------------------
160// "clicked" (internal from gtk_toolbar)
161//-----------------------------------------------------------------------------
162
163extern "C" {
164static void gtk_toolbar_callback( GtkWidget *widget,
165 wxToolBarTool *tool )
166{
167 wxToolBar *tbar = (wxToolBar *)tool->GetToolBar();
168
169 if (tbar->m_blockEvent) return;
170
171 if (g_blockEventsOnDrag) return;
172 if (!tool->IsEnabled()) return;
173
174 if (tool->CanBeToggled())
175 {
176 if (tool->IsRadio() &&
177 gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON(widget)) &&
178 tool->IsToggled())
179 {
180 // pressed an already pressed radio button
181 return;
182 }
183
184 tool->Toggle();
185
186 tool->SetImage(tool->GetBitmap());
187
188 if ( tool->IsRadio() && !tool->IsToggled() )
189 {
190 // radio button went up, don't report this as a wxWin event
191 return;
192 }
193 }
194
195 if( !tbar->OnLeftClick( tool->GetId(), tool->IsToggled() ) && tool->CanBeToggled() )
196 {
197 // revert back
198 tool->Toggle();
199
200 tool->SetImage(tool->GetBitmap());
201 }
202}
203}
204
205//-----------------------------------------------------------------------------
206// "right-click"
207//-----------------------------------------------------------------------------
208extern "C" {
209static gboolean gtk_toolbar_tool_rclick_callback(GtkWidget *WXUNUSED(widget),
210 GdkEventButton *event,
211 wxToolBarToolBase *tool)
212{
213 if (event->button != 3)
214 return FALSE;
215
216 wxToolBar *tbar = (wxToolBar *)tool->GetToolBar();
217
218 if (tbar->m_blockEvent) return TRUE;
219
220 if (g_blockEventsOnDrag) return TRUE;
221 if (!tool->IsEnabled()) return TRUE;
222
223 tbar->OnRightClick( tool->GetId(), (int)event->x, (int)event->y );
224
225 return TRUE;
226}
227}
228
229//-----------------------------------------------------------------------------
230// "enter_notify_event" / "leave_notify_event" from dropdown
231//-----------------------------------------------------------------------------
232
233extern "C" {
234static gint gtk_toolbar_buddy_enter_callback( GtkWidget *WXUNUSED(widget),
235 GdkEventCrossing *WXUNUSED(gdk_event),
236 GtkWidget *tool )
237{
238 guint8 state = GTK_WIDGET_STATE( tool );
239 state |= GTK_STATE_PRELIGHT;
240 gtk_widget_set_state( tool, (GtkStateType) state );
241 return FALSE;
242}
243
244static gint gtk_toolbar_buddy_leave_callback( GtkWidget *WXUNUSED(widget),
245 GdkEventCrossing *WXUNUSED(gdk_event),
246 GtkWidget *tool )
247{
248 guint8 state = GTK_WIDGET_STATE( tool );
249 state &= ~GTK_STATE_PRELIGHT;
250 gtk_widget_set_state( tool, (GtkStateType) state );
251 return FALSE;
252}
253}
254
255//-----------------------------------------------------------------------------
256// "left-click" on dropdown
257//-----------------------------------------------------------------------------
258
259extern "C"
260{
261static void gtk_pop_tb_hide_callback( GtkWidget *WXUNUSED(menu), GtkToggleButton *button )
262{
263 gtk_toggle_button_set_active( button, FALSE );
264}
265
266static gboolean gtk_toolbar_dropdown_lclick_callback(GtkWidget *widget,
267 GdkEventButton *event,
268 wxToolBarToolBase *tool)
269{
270 if (event->button != 1)
271 return FALSE;
272
273 wxToolBar *tbar = (wxToolBar *)tool->GetToolBar();
274
275 if (tbar->m_blockEvent) return FALSE;
276
277 if (g_blockEventsOnDrag) return FALSE;
278 if (!tool->IsEnabled()) return FALSE;
279
280 wxCommandEvent evt(wxEVT_COMMAND_TOOL_DROPDOWN_CLICKED, tool->GetId() );
281 if ( tbar->GetEventHandler()->ProcessEvent(evt) )
282 {
283 return TRUE;
284 }
285
286 wxMenu * const menu = tool->GetDropdownMenu();
287 if (!menu)
288 return TRUE;
289
290 // simulate press
291 gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(widget), TRUE );
292
293 g_signal_connect (menu->m_menu, "hide",
294 G_CALLBACK (gtk_pop_tb_hide_callback),
295 widget);
296
297 tbar->PopupMenu( menu, widget->allocation.x,
298 widget->allocation.y + widget->allocation.height );
299
300
301 return TRUE;
302}
303}
304
305//-----------------------------------------------------------------------------
306// "enter_notify_event" / "leave_notify_event"
307//-----------------------------------------------------------------------------
308
309extern "C" {
310static gint gtk_toolbar_tool_callback( GtkWidget *WXUNUSED(widget),
311 GdkEventCrossing *gdk_event,
312 wxToolBarTool *tool )
313{
314 if (g_blockEventsOnDrag) return TRUE;
315
316 wxToolBar *tb = (wxToolBar *)tool->GetToolBar();
317
318 // emit the event
319 if( gdk_event->type == GDK_ENTER_NOTIFY )
320 tb->OnMouseEnter( tool->GetId() );
321 else
322 tb->OnMouseEnter( -1 );
323
324 return FALSE;
325}
326}
327
328//-----------------------------------------------------------------------------
329// "size_request" from m_toolbar
330//-----------------------------------------------------------------------------
331
332extern "C" {
333static void
334size_request(GtkWidget*, GtkRequisition* req, wxToolBar* win)
335{
336 const wxSize margins = win->GetMargins();
337 req->width += margins.x;
338 req->height += 2 * margins.y;
339}
340}
341
342//-----------------------------------------------------------------------------
343// InsertChild callback for wxToolBar
344//-----------------------------------------------------------------------------
345
346static void wxInsertChildInToolBar( wxWindow* WXUNUSED(parent),
347 wxWindow* child)
348{
349 // Child widget will be inserted into GtkToolbar by DoInsertTool. Ref it
350 // here so reparenting into wxToolBar doesn't delete it.
351 g_object_ref(child->m_widget);
352}
353
354// ----------------------------------------------------------------------------
355// wxToolBarTool
356// ----------------------------------------------------------------------------
357
358void wxToolBarTool::Init()
359{
360 m_item =
361 m_image = NULL;
362}
363
364wxToolBarToolBase *wxToolBar::CreateTool(int id,
365 const wxString& text,
366 const wxBitmap& bitmap1,
367 const wxBitmap& bitmap2,
368 wxItemKind kind,
369 wxObject *clientData,
370 const wxString& shortHelpString,
371 const wxString& longHelpString)
372{
373 return new wxToolBarTool(this, id, text, bitmap1, bitmap2, kind,
374 clientData, shortHelpString, longHelpString);
375}
376
377wxToolBarToolBase *
378wxToolBar::CreateTool(wxControl *control, const wxString& label)
379{
380 return new wxToolBarTool(this, control, label);
381}
382
383//-----------------------------------------------------------------------------
384// wxToolBar construction
385//-----------------------------------------------------------------------------
386
387void wxToolBar::Init()
388{
389 m_toolbar = (GtkToolbar *)NULL;
390 m_blockEvent = false;
391 m_defaultWidth = 32;
392 m_defaultHeight = 32;
393}
394
395wxToolBar::~wxToolBar()
396{
397}
398
399bool wxToolBar::Create( wxWindow *parent,
400 wxWindowID id,
401 const wxPoint& pos,
402 const wxSize& size,
403 long style,
404 const wxString& name )
405{
406 m_insertCallback = wxInsertChildInToolBar;
407
408 if ( !PreCreation( parent, pos, size ) ||
409 !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
410 {
411 wxFAIL_MSG( wxT("wxToolBar creation failed") );
412
413 return false;
414 }
415
416 FixupStyle();
417
418 m_toolbar = GTK_TOOLBAR( gtk_toolbar_new() );
419 GtkSetStyle();
420
421 // Doesn't work this way.
422 // GtkToolbarSpaceStyle space_style = GTK_TOOLBAR_SPACE_EMPTY;
423 // gtk_widget_style_set (GTK_WIDGET (m_toolbar), "space_style", &space_style, NULL);
424
425 SetToolSeparation(7);
426
427 if (style & wxTB_DOCKABLE)
428 {
429 m_widget = gtk_handle_box_new();
430 gtk_container_add( GTK_CONTAINER(m_widget), GTK_WIDGET(m_toolbar) );
431 gtk_widget_show( GTK_WIDGET(m_toolbar) );
432
433 if (style & wxTB_FLAT)
434 gtk_handle_box_set_shadow_type( GTK_HANDLE_BOX(m_widget), GTK_SHADOW_NONE );
435 }
436 else
437 {
438 m_widget = gtk_event_box_new();
439 gtk_container_add( GTK_CONTAINER(m_widget), GTK_WIDGET(m_toolbar) );
440 ConnectWidget( m_widget );
441 gtk_widget_show(GTK_WIDGET(m_toolbar));
442 }
443
444 // FIXME: there is no such function for toolbars in 2.0
445#if 0
446 if (style & wxTB_FLAT)
447 gtk_toolbar_set_button_relief( GTK_TOOLBAR(m_toolbar), GTK_RELIEF_NONE );
448#endif
449
450 m_parent->DoAddChild( this );
451
452 PostCreation(size);
453
454 g_signal_connect_after(m_toolbar, "size_request",
455 G_CALLBACK(size_request), this);
456
457 return true;
458}
459
460GdkWindow *wxToolBar::GTKGetWindow(wxArrayGdkWindows& WXUNUSED(windows)) const
461{
462 return GTK_WIDGET(m_toolbar)->window;
463}
464
465void wxToolBar::GtkSetStyle()
466{
467 GtkOrientation orient;
468 GtkToolbarStyle style;
469 GetGtkStyle(GetWindowStyle(), &orient, &style);
470
471 gtk_toolbar_set_orientation(m_toolbar, orient);
472 gtk_toolbar_set_style(m_toolbar, style);
473 gtk_toolbar_set_tooltips(m_toolbar, !(style & wxTB_NO_TOOLTIPS));
474}
475
476void wxToolBar::SetWindowStyleFlag( long style )
477{
478 wxToolBarBase::SetWindowStyleFlag(style);
479
480 if ( m_toolbar )
481 GtkSetStyle();
482}
483
484bool wxToolBar::DoInsertTool(size_t pos, wxToolBarToolBase *toolBase)
485{
486 wxToolBarTool* tool = wx_static_cast(wxToolBarTool*, toolBase);
487
488 if ( tool->IsButton() )
489 {
490 if ( !HasFlag(wxTB_NOICONS) )
491 {
492 wxBitmap bitmap = tool->GetNormalBitmap();
493
494 wxCHECK_MSG( bitmap.Ok(), false,
495 wxT("invalid bitmap for wxToolBar icon") );
496
497 tool->m_image = gtk_image_new();
498 tool->SetImage(bitmap);
499
500 gtk_misc_set_alignment((GtkMisc*)tool->m_image, 0.5, 0.5);
501 }
502 }
503
504 int posGtk = 0;
505 if ( pos > 0 )
506 {
507 for ( size_t i = 0; i < pos; i++ )
508 {
509 posGtk++;
510
511 // if we have a dropdown menu, we use 2 GTK tools internally
512 wxToolBarToolsList::compatibility_iterator node = m_tools.Item( i );
513 wxToolBarTool * const tool2 = (wxToolBarTool*) node->GetData();
514 if ( tool2->IsButton() && tool2->GetKind() == wxITEM_DROPDOWN )
515 posGtk++;
516 }
517 }
518
519
520 switch ( tool->GetStyle() )
521 {
522 case wxTOOL_STYLE_BUTTON:
523 // for a radio button we need the widget which starts the radio
524 // group it belongs to, i.e. the first radio button immediately
525 // preceding this one
526 {
527 GtkWidget *widget = NULL;
528
529 if ( tool->IsRadio() )
530 {
531 wxToolBarToolsList::compatibility_iterator node
532 = wxToolBarToolsList::compatibility_iterator();
533 if ( pos )
534 node = m_tools.Item(pos - 1);
535
536 while ( node )
537 {
538 wxToolBarTool *toolNext = (wxToolBarTool *)node->GetData();
539 if ( !toolNext->IsRadio() )
540 break;
541
542 widget = toolNext->m_item;
543
544 node = node->GetPrevious();
545 }
546
547 if ( !widget )
548 {
549 // this is the first button in the radio button group,
550 // it will be toggled automatically by GTK so bring the
551 // internal flag in sync
552 tool->Toggle(true);
553 }
554 }
555
556 tool->m_item = gtk_toolbar_insert_element
557 (
558 m_toolbar,
559 tool->GetGtkChildType(),
560 widget,
561 tool->GetLabel().empty()
562 ? NULL
563 : (const char*) wxGTK_CONV( tool->GetLabel() ),
564 tool->GetShortHelp().empty()
565 ? NULL
566 : (const char*) wxGTK_CONV( tool->GetShortHelp() ),
567 "", // tooltip_private_text (?)
568 tool->m_image,
569 (GtkSignalFunc)gtk_toolbar_callback,
570 (gpointer)tool,
571 posGtk
572 );
573
574 wxCHECK_MSG(tool->m_item != NULL, false, _T("gtk_toolbar_insert_element() failed"));
575
576 g_signal_connect (tool->m_item, "enter_notify_event",
577 G_CALLBACK (gtk_toolbar_tool_callback),
578 tool);
579 g_signal_connect (tool->m_item, "leave_notify_event",
580 G_CALLBACK (gtk_toolbar_tool_callback),
581 tool);
582 g_signal_connect(tool->m_item, "button-press-event",
583 G_CALLBACK (gtk_toolbar_tool_rclick_callback),
584 tool);
585
586 if (tool->GetKind() == wxITEM_DROPDOWN)
587 {
588 GdkPixbuf *pixbuf = gdk_pixbuf_new_from_xpm_data( arrow_down_xpm );
589 GtkWidget *dropdown = gtk_toggle_button_new();
590 GtkWidget *image = gtk_image_new_from_pixbuf( pixbuf );
591 gtk_widget_show( image );
592 gtk_container_add( GTK_CONTAINER(dropdown), image );
593
594 if (GetWindowStyle() & wxTB_FLAT)
595 gtk_button_set_relief( GTK_BUTTON(dropdown), GTK_RELIEF_NONE );
596 GTK_WIDGET_UNSET_FLAGS (dropdown, GTK_CAN_FOCUS);
597 gtk_widget_show( dropdown );
598
599 g_signal_connect (dropdown, "enter_notify_event",
600 G_CALLBACK (gtk_toolbar_buddy_enter_callback),
601 tool->m_item);
602 g_signal_connect (dropdown, "leave_notify_event",
603 G_CALLBACK (gtk_toolbar_buddy_leave_callback),
604 tool->m_item);
605 g_signal_connect(dropdown, "button-press-event",
606 G_CALLBACK (gtk_toolbar_dropdown_lclick_callback),
607 tool);
608
609 GtkRequisition req;
610 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(tool->m_item) )->size_request )
611 (tool->m_item, &req );
612 gtk_widget_set_size_request( dropdown, -1, req.height );
613
614 gtk_toolbar_insert_widget(
615 m_toolbar,
616 dropdown,
617 (const char *) NULL,
618 (const char *) NULL,
619 posGtk+1
620 );
621 }
622 }
623 break;
624
625 case wxTOOL_STYLE_SEPARATOR:
626 gtk_toolbar_insert_space( m_toolbar, posGtk );
627
628 // skip the rest
629 return true;
630
631 case wxTOOL_STYLE_CONTROL:
632 GtkWidget* align = gtk_alignment_new(0.5, 0.5, 0, 0);
633 gtk_widget_show(align);
634 gtk_container_add((GtkContainer*)align, tool->GetControl()->m_widget);
635 gtk_toolbar_insert_widget(
636 m_toolbar,
637 align,
638 (const char *) NULL,
639 (const char *) NULL,
640 posGtk
641 );
642 // release reference obtained by wxInsertChildInToolBar
643 g_object_unref(tool->GetControl()->m_widget);
644 break;
645 }
646
647 InvalidateBestSize();
648
649 return true;
650}
651
652bool wxToolBar::DoDeleteTool(size_t pos, wxToolBarToolBase *toolBase)
653{
654 wxToolBarTool* tool = wx_static_cast(wxToolBarTool*, toolBase);
655
656 switch ( tool->GetStyle() )
657 {
658 case wxTOOL_STYLE_CONTROL:
659 tool->GetControl()->Destroy();
660 break;
661
662 case wxTOOL_STYLE_BUTTON:
663 gtk_widget_destroy( tool->m_item );
664 break;
665
666 case wxTOOL_STYLE_SEPARATOR:
667 gtk_toolbar_remove_space( m_toolbar, pos );
668 break;
669 }
670
671 InvalidateBestSize();
672 return true;
673}
674
675// ----------------------------------------------------------------------------
676// wxToolBar tools state
677// ----------------------------------------------------------------------------
678
679void wxToolBar::DoEnableTool(wxToolBarToolBase *toolBase, bool enable)
680{
681 wxToolBarTool* tool = wx_static_cast(wxToolBarTool*, toolBase);
682
683 if (tool->m_item)
684 {
685 gtk_widget_set_sensitive( tool->m_item, enable );
686 }
687}
688
689void wxToolBar::DoToggleTool( wxToolBarToolBase *toolBase, bool toggle )
690{
691 wxToolBarTool* tool = wx_static_cast(wxToolBarTool*, toolBase);
692
693 GtkWidget *item = tool->m_item;
694 if ( item && GTK_IS_TOGGLE_BUTTON(item) )
695 {
696 tool->SetImage(tool->GetBitmap());
697
698 m_blockEvent = true;
699
700 gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(item), toggle );
701
702 m_blockEvent = false;
703 }
704}
705
706void wxToolBar::DoSetToggle(wxToolBarToolBase * WXUNUSED(tool),
707 bool WXUNUSED(toggle))
708{
709 // VZ: absolutely no idea about how to do it
710 wxFAIL_MSG( _T("not implemented") );
711}
712
713// ----------------------------------------------------------------------------
714// wxToolBar geometry
715// ----------------------------------------------------------------------------
716
717wxToolBarToolBase *wxToolBar::FindToolForPosition(wxCoord WXUNUSED(x),
718 wxCoord WXUNUSED(y)) const
719{
720 // VZ: GTK+ doesn't seem to have such thing
721 wxFAIL_MSG( _T("wxToolBar::FindToolForPosition() not implemented") );
722
723 return (wxToolBarToolBase *)NULL;
724}
725
726void wxToolBar::SetMargins( int x, int y )
727{
728 wxCHECK_RET( GetToolsCount() == 0,
729 wxT("wxToolBar::SetMargins must be called before adding tools.") );
730
731 m_xMargin = x;
732 m_yMargin = y;
733}
734
735void wxToolBar::SetToolSeparation( int separation )
736{
737 // FIXME: this function disappeared
738#if 0
739 gtk_toolbar_set_space_size( m_toolbar, separation );
740#endif
741
742 m_toolSeparation = separation;
743}
744
745void wxToolBar::SetToolShortHelp( int id, const wxString& helpString )
746{
747 wxToolBarTool* tool = wx_static_cast(wxToolBarTool*, FindById(id));
748
749 if ( tool )
750 {
751 (void)tool->SetShortHelp(helpString);
752 gtk_tooltips_set_tip(m_toolbar->tooltips, tool->m_item,
753 wxGTK_CONV( helpString ), "");
754 }
755}
756
757void wxToolBar::SetToolNormalBitmap( int id, const wxBitmap& bitmap )
758{
759 wxToolBarTool* tool = wx_static_cast(wxToolBarTool*, FindById(id));
760 if ( tool )
761 {
762 wxCHECK_RET( tool->IsButton(), wxT("Can only set bitmap on button tools."));
763
764 tool->SetNormalBitmap(bitmap);
765 tool->SetImage(tool->GetBitmap());
766 }
767}
768
769void wxToolBar::SetToolDisabledBitmap( int id, const wxBitmap& bitmap )
770{
771 wxToolBarTool* tool = wx_static_cast(wxToolBarTool*, FindById(id));
772 if ( tool )
773 {
774 wxCHECK_RET( tool->IsButton(), wxT("Can only set bitmap on button tools."));
775
776 tool->SetDisabledBitmap(bitmap);
777 tool->SetImage(tool->GetBitmap());
778 }
779}
780
781// ----------------------------------------------------------------------------
782// wxToolBar idle handling
783// ----------------------------------------------------------------------------
784
785void wxToolBar::OnInternalIdle()
786{
787 // Check if we have to show window now
788 if (GtkShowFromOnIdle()) return;
789
790 wxCursor cursor = m_cursor;
791 if (g_globalCursor.Ok()) cursor = g_globalCursor;
792
793 if (cursor.Ok())
794 {
795 /* I now set the cursor the anew in every OnInternalIdle call
796 as setting the cursor in a parent window also effects the
797 windows above so that checking for the current cursor is
798 not possible. */
799
800 if (HasFlag(wxTB_DOCKABLE) && (m_widget->window))
801 {
802 /* if the toolbar is dockable, then m_widget stands for the
803 GtkHandleBox widget, which uses its own window so that we
804 can set the cursor for it. if the toolbar is not dockable,
805 m_widget comes from m_toolbar which uses its parent's
806 window ("windowless windows") and thus we cannot set the
807 cursor. */
808 gdk_window_set_cursor( m_widget->window, cursor.GetCursor() );
809 }
810
811 wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst();
812 while ( node )
813 {
814 wxToolBarTool *tool = (wxToolBarTool *)node->GetData();
815 node = node->GetNext();
816
817 GtkWidget *item = tool->m_item;
818 if ( item )
819 {
820 GdkWindow *window = item->window;
821
822 if ( window )
823 {
824 gdk_window_set_cursor( window, cursor.GetCursor() );
825 }
826 }
827 }
828 }
829
830 if (wxUpdateUIEvent::CanUpdate(this))
831 UpdateWindowUI(wxUPDATE_UI_FROMIDLE);
832}
833
834
835// ----------------------------------------------------------------------------
836
837// static
838wxVisualAttributes
839wxToolBar::GetClassDefaultAttributes(wxWindowVariant WXUNUSED(variant))
840{
841 return GetDefaultAttributesFromGTKWidget(gtk_toolbar_new);
842}
843
844#endif // wxUSE_TOOLBAR_NATIVE
wxWidgets (Impactor)