]> git.saurik.com Git - wxWidgets.git/blob - src/gtk/tbargtk.cpp
minor tab height bug fix
[wxWidgets.git] / src / gtk / tbargtk.cpp
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 // ============================================================================
12 // declarations
13 // ============================================================================
14
15 // ----------------------------------------------------------------------------
16 // headers
17 // ----------------------------------------------------------------------------
18
19 // For compilers that support precompilation, includes "wx.h".
20 #include "wx/wxprec.h"
21
22 #if wxUSE_TOOLBAR_NATIVE
23
24 #include "wx/toolbar.h"
25
26 #ifndef WX_PRECOMP
27 #include "wx/frame.h"
28 #endif
29
30 // FIXME: Use GtkImage instead of GtkPixmap. Use the new toolbar API for when gtk runtime is new enough?
31 // Beware that the new and old toolbar API may not be mixed in usage.
32 #include <gtk/gtkversion.h>
33 #ifdef GTK_DISABLE_DEPRECATED
34 #undef GTK_DISABLE_DEPRECATED
35 #endif
36
37 #include "wx/gtk/private.h"
38
39 // ----------------------------------------------------------------------------
40 // globals
41 // ----------------------------------------------------------------------------
42
43 // data
44 extern bool g_blockEventsOnDrag;
45 extern wxCursor g_globalCursor;
46
47 // ----------------------------------------------------------------------------
48 // private functions
49 // ----------------------------------------------------------------------------
50
51 // translate wxWidgets toolbar style flags to GTK orientation and style
52 static void GetGtkStyle(long style,
53 GtkOrientation *orient, GtkToolbarStyle *gtkStyle)
54 {
55 *orient = ( style & wxTB_LEFT || style & wxTB_RIGHT ) ? GTK_ORIENTATION_VERTICAL : GTK_ORIENTATION_HORIZONTAL;
56
57
58 if ( style & wxTB_TEXT )
59 {
60 *gtkStyle = style & wxTB_NOICONS
61 ? GTK_TOOLBAR_TEXT
62 : (
63 style & wxTB_HORZ_LAYOUT ? GTK_TOOLBAR_BOTH_HORIZ :
64 GTK_TOOLBAR_BOTH);
65 }
66 else // no text, hence we must have the icons or what would we show?
67 {
68 *gtkStyle = GTK_TOOLBAR_ICONS;
69 }
70 }
71
72 // ----------------------------------------------------------------------------
73 // wxToolBarTool
74 // ----------------------------------------------------------------------------
75
76 class wxToolBarTool : public wxToolBarToolBase
77 {
78 public:
79 wxToolBarTool(wxToolBar *tbar,
80 int id,
81 const wxString& label,
82 const wxBitmap& bitmap1,
83 const wxBitmap& bitmap2,
84 wxItemKind kind,
85 wxObject *clientData,
86 const wxString& shortHelpString,
87 const wxString& longHelpString)
88 : wxToolBarToolBase(tbar, id, label, bitmap1, bitmap2, kind,
89 clientData, shortHelpString, longHelpString)
90 {
91 Init();
92 }
93
94 wxToolBarTool(wxToolBar *tbar, wxControl *control)
95 : wxToolBarToolBase(tbar, control)
96 {
97 Init();
98 }
99
100 // is this a radio button?
101 //
102 // unlike GetKind(), can be called for any kind of tools, not just buttons
103 bool IsRadio() const { return IsButton() && GetKind() == wxITEM_RADIO; }
104
105 // this is only called for the normal buttons, i.e. not separators nor
106 // controls
107 GtkToolbarChildType GetGtkChildType() const
108 {
109 switch ( GetKind() )
110 {
111 case wxITEM_CHECK:
112 return GTK_TOOLBAR_CHILD_TOGGLEBUTTON;
113
114 case wxITEM_RADIO:
115 return GTK_TOOLBAR_CHILD_RADIOBUTTON;
116
117 default:
118 wxFAIL_MSG( _T("unknown toolbar child type") );
119 // fall through
120
121 case wxITEM_NORMAL:
122 return GTK_TOOLBAR_CHILD_BUTTON;
123 }
124 }
125
126 void SetImage(const wxBitmap& bitmap)
127 {
128 if (bitmap.Ok())
129 {
130 // setting from pixmap doesn't seem to work right, but pixbuf works well
131 gtk_image_set_from_pixbuf((GtkImage*)m_image, bitmap.GetPixbuf());
132 }
133 }
134
135 GtkWidget *m_item;
136 GtkWidget *m_image;
137
138 protected:
139 void Init();
140 };
141
142 // ----------------------------------------------------------------------------
143 // wxWin macros
144 // ----------------------------------------------------------------------------
145
146 IMPLEMENT_DYNAMIC_CLASS(wxToolBar, wxControl)
147
148 // ============================================================================
149 // implementation
150 // ============================================================================
151
152 //-----------------------------------------------------------------------------
153 // "clicked" (internal from gtk_toolbar)
154 //-----------------------------------------------------------------------------
155
156 extern "C" {
157 static void gtk_toolbar_callback( GtkWidget *WXUNUSED(widget),
158 wxToolBarTool *tool )
159 {
160 if (g_isIdle)
161 wxapp_install_idle_handler();
162
163 wxToolBar *tbar = (wxToolBar *)tool->GetToolBar();
164
165 if (tbar->m_blockEvent) return;
166
167 if (g_blockEventsOnDrag) return;
168 if (!tool->IsEnabled()) return;
169
170 if (tool->CanBeToggled())
171 {
172 tool->Toggle();
173
174 tool->SetImage(tool->GetBitmap());
175
176 if ( tool->IsRadio() && !tool->IsToggled() )
177 {
178 // radio button went up, don't report this as a wxWin event
179 return;
180 }
181 }
182
183 if( !tbar->OnLeftClick( tool->GetId(), tool->IsToggled() ) && tool->CanBeToggled() )
184 {
185 // revert back
186 tool->Toggle();
187
188 tool->SetImage(tool->GetBitmap());
189 }
190 }
191 }
192
193 //-----------------------------------------------------------------------------
194 // "enter_notify_event" / "leave_notify_event"
195 //-----------------------------------------------------------------------------
196
197 extern "C" {
198 static gint gtk_toolbar_tool_callback( GtkWidget *WXUNUSED(widget),
199 GdkEventCrossing *gdk_event,
200 wxToolBarTool *tool )
201 {
202 // don't need to install idle handler, its done from "event" signal
203
204 if (g_blockEventsOnDrag) return TRUE;
205
206 wxToolBar *tb = (wxToolBar *)tool->GetToolBar();
207
208 // emit the event
209 if( gdk_event->type == GDK_ENTER_NOTIFY )
210 tb->OnMouseEnter( tool->GetId() );
211 else
212 tb->OnMouseEnter( -1 );
213
214 return FALSE;
215 }
216 }
217
218 //-----------------------------------------------------------------------------
219 // InsertChild callback for wxToolBar
220 //-----------------------------------------------------------------------------
221
222 static void wxInsertChildInToolBar( wxToolBar* WXUNUSED(parent),
223 wxWindow* WXUNUSED(child) )
224 {
225 // we don't do anything here
226 }
227
228 // ----------------------------------------------------------------------------
229 // wxToolBarTool
230 // ----------------------------------------------------------------------------
231
232 void wxToolBarTool::Init()
233 {
234 m_item =
235 m_image = NULL;
236 }
237
238 wxToolBarToolBase *wxToolBar::CreateTool(int id,
239 const wxString& text,
240 const wxBitmap& bitmap1,
241 const wxBitmap& bitmap2,
242 wxItemKind kind,
243 wxObject *clientData,
244 const wxString& shortHelpString,
245 const wxString& longHelpString)
246 {
247 return new wxToolBarTool(this, id, text, bitmap1, bitmap2, kind,
248 clientData, shortHelpString, longHelpString);
249 }
250
251 wxToolBarToolBase *wxToolBar::CreateTool(wxControl *control)
252 {
253 return new wxToolBarTool(this, control);
254 }
255
256 //-----------------------------------------------------------------------------
257 // wxToolBar construction
258 //-----------------------------------------------------------------------------
259
260 void wxToolBar::Init()
261 {
262 m_toolbar = (GtkToolbar *)NULL;
263 m_blockEvent = false;
264 m_defaultWidth = 32;
265 m_defaultHeight = 32;
266 }
267
268 wxToolBar::~wxToolBar()
269 {
270 }
271
272 bool wxToolBar::Create( wxWindow *parent,
273 wxWindowID id,
274 const wxPoint& pos,
275 const wxSize& size,
276 long style,
277 const wxString& name )
278 {
279 m_needParent = true;
280 m_insertCallback = (wxInsertChildFunction)wxInsertChildInToolBar;
281
282 if ( !PreCreation( parent, pos, size ) ||
283 !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
284 {
285 wxFAIL_MSG( wxT("wxToolBar creation failed") );
286
287 return false;
288 }
289
290 FixupStyle();
291
292 m_toolbar = GTK_TOOLBAR( gtk_toolbar_new() );
293 GtkSetStyle();
294
295 // Doesn't work this way.
296 // GtkToolbarSpaceStyle space_style = GTK_TOOLBAR_SPACE_EMPTY;
297 // gtk_widget_style_set (GTK_WIDGET (m_toolbar), "space_style", &space_style, NULL);
298
299 SetToolSeparation(7);
300
301 if (style & wxTB_DOCKABLE)
302 {
303 m_widget = gtk_handle_box_new();
304 gtk_container_add( GTK_CONTAINER(m_widget), GTK_WIDGET(m_toolbar) );
305 gtk_widget_show( GTK_WIDGET(m_toolbar) );
306
307 if (style & wxTB_FLAT)
308 gtk_handle_box_set_shadow_type( GTK_HANDLE_BOX(m_widget), GTK_SHADOW_NONE );
309 }
310 else
311 {
312 m_widget = gtk_event_box_new();
313 gtk_container_add( GTK_CONTAINER(m_widget), GTK_WIDGET(m_toolbar) );
314 ConnectWidget( m_widget );
315 gtk_widget_show(GTK_WIDGET(m_toolbar));
316 }
317
318 // FIXME: there is no such function for toolbars in 2.0
319 #if 0
320 if (style & wxTB_FLAT)
321 gtk_toolbar_set_button_relief( GTK_TOOLBAR(m_toolbar), GTK_RELIEF_NONE );
322 #endif
323
324 m_parent->DoAddChild( this );
325
326 PostCreation(size);
327
328 return true;
329 }
330
331 GdkWindow *wxToolBar::GTKGetWindow(wxArrayGdkWindows& windows) const
332 {
333 return GTK_WIDGET(m_toolbar)->window;
334 }
335
336 void wxToolBar::GtkSetStyle()
337 {
338 GtkOrientation orient;
339 GtkToolbarStyle style;
340 GetGtkStyle(GetWindowStyle(), &orient, &style);
341
342 gtk_toolbar_set_orientation(m_toolbar, orient);
343 gtk_toolbar_set_style(m_toolbar, style);
344 gtk_toolbar_set_tooltips(m_toolbar, !(style & wxTB_NO_TOOLTIPS));
345 }
346
347 void wxToolBar::SetWindowStyleFlag( long style )
348 {
349 wxToolBarBase::SetWindowStyleFlag(style);
350
351 if ( m_toolbar )
352 GtkSetStyle();
353 }
354
355 bool wxToolBar::DoInsertTool(size_t pos, wxToolBarToolBase *toolBase)
356 {
357 wxToolBarTool* tool = wx_static_cast(wxToolBarTool*, toolBase);
358
359 if ( tool->IsButton() )
360 {
361 if ( !HasFlag(wxTB_NOICONS) )
362 {
363 wxBitmap bitmap = tool->GetNormalBitmap();
364
365 wxCHECK_MSG( bitmap.Ok(), false,
366 wxT("invalid bitmap for wxToolBar icon") );
367
368 tool->m_image = gtk_image_new();
369 tool->SetImage(bitmap);
370
371 gtk_misc_set_alignment((GtkMisc*)tool->m_image, 0.5, 0.5);
372 }
373 }
374
375 const int posGtk = int(pos);
376
377 switch ( tool->GetStyle() )
378 {
379 case wxTOOL_STYLE_BUTTON:
380 // for a radio button we need the widget which starts the radio
381 // group it belongs to, i.e. the first radio button immediately
382 // preceding this one
383 {
384 GtkWidget *widget = NULL;
385
386 if ( tool->IsRadio() )
387 {
388 wxToolBarToolsList::compatibility_iterator node
389 = wxToolBarToolsList::compatibility_iterator();
390 if ( pos )
391 node = m_tools.Item(pos - 1);
392
393 while ( node )
394 {
395 wxToolBarTool *toolNext = (wxToolBarTool *)node->GetData();
396 if ( !toolNext->IsRadio() )
397 break;
398
399 widget = toolNext->m_item;
400
401 node = node->GetPrevious();
402 }
403
404 if ( !widget )
405 {
406 // this is the first button in the radio button group,
407 // it will be toggled automatically by GTK so bring the
408 // internal flag in sync
409 tool->Toggle(true);
410 }
411 }
412
413 tool->m_item = gtk_toolbar_insert_element
414 (
415 m_toolbar,
416 tool->GetGtkChildType(),
417 widget,
418 tool->GetLabel().empty()
419 ? NULL
420 : (const char*) wxGTK_CONV( tool->GetLabel() ),
421 tool->GetShortHelp().empty()
422 ? NULL
423 : (const char*) wxGTK_CONV( tool->GetShortHelp() ),
424 "", // tooltip_private_text (?)
425 tool->m_image,
426 (GtkSignalFunc)gtk_toolbar_callback,
427 (gpointer)tool,
428 posGtk
429 );
430
431 wxCHECK_MSG(tool->m_item != NULL, false, _T("gtk_toolbar_insert_element() failed"));
432
433 g_signal_connect (tool->m_item, "enter_notify_event",
434 G_CALLBACK (gtk_toolbar_tool_callback),
435 tool);
436 g_signal_connect (tool->m_item, "leave_notify_event",
437 G_CALLBACK (gtk_toolbar_tool_callback),
438 tool);
439 }
440 break;
441
442 case wxTOOL_STYLE_SEPARATOR:
443 gtk_toolbar_insert_space( m_toolbar, posGtk );
444
445 // skip the rest
446 return true;
447
448 case wxTOOL_STYLE_CONTROL:
449 gtk_toolbar_insert_widget(
450 m_toolbar,
451 tool->GetControl()->m_widget,
452 (const char *) NULL,
453 (const char *) NULL,
454 posGtk
455 );
456 break;
457 }
458
459 GtkRequisition req;
460 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(m_widget) )->size_request )
461 (m_widget, &req );
462 m_width = req.width + m_xMargin;
463 m_height = req.height + 2*m_yMargin;
464 InvalidateBestSize();
465
466 return true;
467 }
468
469 bool wxToolBar::DoDeleteTool(size_t pos, wxToolBarToolBase *toolBase)
470 {
471 wxToolBarTool* tool = wx_static_cast(wxToolBarTool*, toolBase);
472
473 switch ( tool->GetStyle() )
474 {
475 case wxTOOL_STYLE_CONTROL:
476 tool->GetControl()->Destroy();
477 break;
478
479 case wxTOOL_STYLE_BUTTON:
480 gtk_widget_destroy( tool->m_item );
481 break;
482
483 case wxTOOL_STYLE_SEPARATOR:
484 gtk_toolbar_remove_space( m_toolbar, pos );
485 break;
486 }
487
488 InvalidateBestSize();
489 return true;
490 }
491
492 // ----------------------------------------------------------------------------
493 // wxToolBar tools state
494 // ----------------------------------------------------------------------------
495
496 void wxToolBar::DoEnableTool(wxToolBarToolBase *toolBase, bool enable)
497 {
498 wxToolBarTool* tool = wx_static_cast(wxToolBarTool*, toolBase);
499
500 if (tool->m_item)
501 {
502 gtk_widget_set_sensitive( tool->m_item, enable );
503 }
504 }
505
506 void wxToolBar::DoToggleTool( wxToolBarToolBase *toolBase, bool toggle )
507 {
508 wxToolBarTool* tool = wx_static_cast(wxToolBarTool*, toolBase);
509
510 GtkWidget *item = tool->m_item;
511 if ( item && GTK_IS_TOGGLE_BUTTON(item) )
512 {
513 tool->SetImage(tool->GetBitmap());
514
515 m_blockEvent = true;
516
517 gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(item), toggle );
518
519 m_blockEvent = false;
520 }
521 }
522
523 void wxToolBar::DoSetToggle(wxToolBarToolBase * WXUNUSED(tool),
524 bool WXUNUSED(toggle))
525 {
526 // VZ: absolutely no idea about how to do it
527 wxFAIL_MSG( _T("not implemented") );
528 }
529
530 // ----------------------------------------------------------------------------
531 // wxToolBar geometry
532 // ----------------------------------------------------------------------------
533
534 wxToolBarToolBase *wxToolBar::FindToolForPosition(wxCoord WXUNUSED(x),
535 wxCoord WXUNUSED(y)) const
536 {
537 // VZ: GTK+ doesn't seem to have such thing
538 wxFAIL_MSG( _T("wxToolBar::FindToolForPosition() not implemented") );
539
540 return (wxToolBarToolBase *)NULL;
541 }
542
543 void wxToolBar::SetMargins( int x, int y )
544 {
545 wxCHECK_RET( GetToolsCount() == 0,
546 wxT("wxToolBar::SetMargins must be called before adding tools.") );
547
548 m_xMargin = x;
549 m_yMargin = y;
550 }
551
552 void wxToolBar::SetToolSeparation( int separation )
553 {
554 // FIXME: this function disappeared
555 #if 0
556 gtk_toolbar_set_space_size( m_toolbar, separation );
557 #endif
558
559 m_toolSeparation = separation;
560 }
561
562 void wxToolBar::SetToolShortHelp( int id, const wxString& helpString )
563 {
564 wxToolBarTool* tool = wx_static_cast(wxToolBarTool*, FindById(id));
565
566 if ( tool )
567 {
568 (void)tool->SetShortHelp(helpString);
569 gtk_tooltips_set_tip(m_toolbar->tooltips, tool->m_item,
570 wxGTK_CONV( helpString ), "");
571 }
572 }
573
574 // ----------------------------------------------------------------------------
575 // wxToolBar idle handling
576 // ----------------------------------------------------------------------------
577
578 void wxToolBar::OnInternalIdle()
579 {
580 // Check if we have to show window now
581 if (GtkShowFromOnIdle()) return;
582
583 wxCursor cursor = m_cursor;
584 if (g_globalCursor.Ok()) cursor = g_globalCursor;
585
586 if (cursor.Ok())
587 {
588 /* I now set the cursor the anew in every OnInternalIdle call
589 as setting the cursor in a parent window also effects the
590 windows above so that checking for the current cursor is
591 not possible. */
592
593 if (HasFlag(wxTB_DOCKABLE) && (m_widget->window))
594 {
595 /* if the toolbar is dockable, then m_widget stands for the
596 GtkHandleBox widget, which uses its own window so that we
597 can set the cursor for it. if the toolbar is not dockable,
598 m_widget comes from m_toolbar which uses its parent's
599 window ("windowless windows") and thus we cannot set the
600 cursor. */
601 gdk_window_set_cursor( m_widget->window, cursor.GetCursor() );
602 }
603
604 wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst();
605 while ( node )
606 {
607 wxToolBarTool *tool = (wxToolBarTool *)node->GetData();
608 node = node->GetNext();
609
610 GtkWidget *item = tool->m_item;
611 if ( item )
612 {
613 GdkWindow *window = item->window;
614
615 if ( window )
616 {
617 gdk_window_set_cursor( window, cursor.GetCursor() );
618 }
619 }
620 }
621 }
622
623 if (wxUpdateUIEvent::CanUpdate(this))
624 UpdateWindowUI(wxUPDATE_UI_FROMIDLE);
625 }
626
627
628 // ----------------------------------------------------------------------------
629
630 // static
631 wxVisualAttributes
632 wxToolBar::GetClassDefaultAttributes(wxWindowVariant WXUNUSED(variant))
633 {
634 return GetDefaultAttributesFromGTKWidget(gtk_toolbar_new);
635 }
636
637 #endif // wxUSE_TOOLBAR_NATIVE