]> git.saurik.com Git - wxWidgets.git/blob - src/gtk1/tbargtk.cpp
wxPostScriptDC::DrawText now uses descent to determine baseline (instead of rough...
[wxWidgets.git] / src / gtk1 / tbargtk.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: tbargtk.cpp
3 // Purpose: GTK toolbar
4 // Author: Robert Roebling
5 // RCS-ID: $Id$
6 // Copyright: (c) Robert Roebling
7 // Licence: wxWindows licence
8 /////////////////////////////////////////////////////////////////////////////
9
10 #ifdef __GNUG__
11 #pragma implementation "tbargtk.h"
12 #endif
13
14 #include "wx/toolbar.h"
15
16 #if wxUSE_TOOLBAR
17
18 #include "wx/frame.h"
19
20 #include "glib.h"
21 #include "gdk/gdk.h"
22 #include "gtk/gtk.h"
23
24 //-----------------------------------------------------------------------------
25 // idle system
26 //-----------------------------------------------------------------------------
27
28 extern void wxapp_install_idle_handler();
29 extern bool g_isIdle;
30
31 //-----------------------------------------------------------------------------
32 // data
33 //-----------------------------------------------------------------------------
34
35 extern bool g_blockEventsOnDrag;
36 extern wxCursor g_globalCursor;
37
38 //-----------------------------------------------------------------------------
39 // "clicked" (internal from gtk_toolbar)
40 //-----------------------------------------------------------------------------
41
42 static void gtk_toolbar_callback( GtkWidget *WXUNUSED(widget), wxToolBarTool *tool )
43 {
44 if (g_isIdle)
45 wxapp_install_idle_handler();
46
47 if (tool->m_owner->m_blockNextEvent)
48 {
49 tool->m_owner->m_blockNextEvent = FALSE;
50 return;
51 }
52
53 if (g_blockEventsOnDrag) return;
54 if (!tool->m_enabled) return;
55
56 if (tool->m_isToggle)
57 {
58 tool->m_toggleState = !tool->m_toggleState;
59
60 if (tool->m_bitmap2.Ok())
61 {
62 wxBitmap bitmap = tool->m_bitmap1;
63 if (tool->m_toggleState) bitmap = tool->m_bitmap2;
64
65 GtkPixmap *pixmap = GTK_PIXMAP( tool->m_pixmap );
66
67 GdkBitmap *mask = (GdkBitmap *) NULL;
68 if (bitmap.GetMask()) mask = bitmap.GetMask()->GetBitmap();
69
70 gtk_pixmap_set( pixmap, bitmap.GetPixmap(), mask );
71 }
72 }
73
74 tool->m_owner->OnLeftClick( tool->m_index, tool->m_toggleState );
75 }
76
77 //-----------------------------------------------------------------------------
78 // "enter_notify_event"
79 //-----------------------------------------------------------------------------
80
81 static gint gtk_toolbar_enter_callback( GtkWidget *WXUNUSED(widget),
82 GdkEventCrossing *WXUNUSED(gdk_event), wxToolBarTool *tool )
83 {
84 if (g_isIdle) wxapp_install_idle_handler();
85
86 if (g_blockEventsOnDrag) return TRUE;
87
88
89 wxToolBar *tb = tool->m_owner;
90
91 #if (GTK_MINOR_VERSION == 0)
92 /* we grey-out the tip text of disabled tool in GTK 1.0 */
93 if (tool->m_enabled)
94 {
95 if (tb->m_fg->red != 0)
96 {
97 tb->m_fg->red = 0;
98 tb->m_fg->green = 0;
99 tb->m_fg->blue = 0;
100 gdk_color_alloc( gtk_widget_get_colormap( GTK_WIDGET(tb->m_toolbar) ), tb->m_fg );
101
102 gtk_tooltips_set_colors( GTK_TOOLBAR(tb->m_toolbar)->tooltips, tb->m_bg, tb->m_fg );
103 }
104 }
105 else
106 {
107 if (tb->m_fg->red == 0)
108 {
109 tb->m_fg->red = 33000;
110 tb->m_fg->green = 33000;
111 tb->m_fg->blue = 33000;
112 gdk_color_alloc( gtk_widget_get_colormap( GTK_WIDGET(tb->m_toolbar) ), tb->m_fg );
113 gtk_tooltips_set_colors( GTK_TOOLBAR(tb->m_toolbar)->tooltips, tb->m_bg, tb->m_fg );
114 }
115 }
116 #endif
117
118 /* emit the event */
119
120 tb->OnMouseEnter( tool->m_index );
121
122 return FALSE;
123 }
124
125 //-----------------------------------------------------------------------------
126 // InsertChild callback for wxToolBar
127 //-----------------------------------------------------------------------------
128
129 static void wxInsertChildInToolBar( wxToolBar* WXUNUSED(parent), wxWindow* WXUNUSED(child) )
130 {
131 /* we don't do anything here but pray */
132 }
133
134 //-----------------------------------------------------------------------------
135 // wxToolBar
136 //-----------------------------------------------------------------------------
137
138 IMPLEMENT_DYNAMIC_CLASS(wxToolBar,wxControl)
139
140 BEGIN_EVENT_TABLE(wxToolBar, wxControl)
141 EVT_IDLE(wxToolBar::OnIdle)
142 END_EVENT_TABLE()
143
144 wxToolBar::wxToolBar()
145 {
146 }
147
148 wxToolBar::wxToolBar( wxWindow *parent, wxWindowID id,
149 const wxPoint& pos, const wxSize& size,
150 long style, const wxString& name )
151 {
152 Create( parent, id, pos, size, style, name );
153 }
154
155 wxToolBar::~wxToolBar()
156 {
157 delete m_fg;
158 delete m_bg;
159 }
160
161 bool wxToolBar::Create( wxWindow *parent, wxWindowID id,
162 const wxPoint& pos, const wxSize& size,
163 long style, const wxString& name )
164 {
165 m_needParent = TRUE;
166 m_blockNextEvent = FALSE;
167 m_insertCallback = (wxInsertChildFunction)wxInsertChildInToolBar;
168
169 if (!PreCreation( parent, pos, size ) ||
170 !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
171 {
172 wxFAIL_MSG( wxT("wxToolBar creation failed") );
173 return FALSE;
174 }
175
176 m_tools.DeleteContents( TRUE );
177
178 m_toolbar = GTK_TOOLBAR( gtk_toolbar_new( GTK_ORIENTATION_HORIZONTAL,
179 GTK_TOOLBAR_ICONS ) );
180
181 m_separation = 7;
182 gtk_toolbar_set_space_size( m_toolbar, m_separation );
183 m_hasToolAlready = FALSE;
184
185 if (style & wxTB_DOCKABLE)
186 {
187 m_widget = gtk_handle_box_new();
188 gtk_container_add( GTK_CONTAINER(m_widget), GTK_WIDGET(m_toolbar) );
189 gtk_widget_show( GTK_WIDGET(m_toolbar) );
190
191 #if (GTK_MINOR_VERSION > 0)
192 if (style & wxTB_FLAT)
193 gtk_handle_box_set_shadow_type( GTK_HANDLE_BOX(m_widget), GTK_SHADOW_NONE );
194 #endif
195 }
196 else
197 {
198 m_widget = GTK_WIDGET(m_toolbar);
199 }
200
201 gtk_toolbar_set_tooltips( GTK_TOOLBAR(m_toolbar), TRUE );
202
203 #if (GTK_MINOR_VERSION > 0)
204 if (style & wxTB_FLAT)
205 gtk_toolbar_set_button_relief( GTK_TOOLBAR(m_toolbar), GTK_RELIEF_NONE );
206 #endif
207
208 m_fg = new GdkColor;
209 m_fg->red = 0;
210 m_fg->green = 0;
211 m_fg->blue = 0;
212 gdk_color_alloc( gtk_widget_get_colormap( GTK_WIDGET(m_toolbar) ), m_fg );
213
214 m_bg = new GdkColor;
215 m_bg->red = 65535;
216 m_bg->green = 65535;
217 m_bg->blue = 50000;
218 gdk_color_alloc( gtk_widget_get_colormap( GTK_WIDGET(m_toolbar) ), m_bg );
219
220 #if (GTK_MINOR_VERSION > 0)
221 gtk_tooltips_force_window( GTK_TOOLBAR(m_toolbar)->tooltips );
222
223 GtkStyle *g_style =
224 gtk_style_copy(
225 gtk_widget_get_style(
226 GTK_TOOLBAR(m_toolbar)->tooltips->tip_window ) );
227
228 g_style->bg[GTK_STATE_NORMAL] = *m_bg;
229 gtk_widget_set_style( GTK_TOOLBAR(m_toolbar)->tooltips->tip_window, g_style );
230 #else
231 gtk_tooltips_set_colors( GTK_TOOLBAR(m_toolbar)->tooltips, m_bg, m_fg );
232 #endif
233
234 m_xMargin = 0;
235 m_yMargin = 0;
236
237 m_parent->DoAddChild( this );
238
239 PostCreation();
240
241 Show( TRUE );
242
243 return TRUE;
244 }
245
246 bool wxToolBar::OnLeftClick( int toolIndex, bool toggleDown )
247 {
248 wxCommandEvent event( wxEVT_COMMAND_TOOL_CLICKED, toolIndex );
249 event.SetEventObject(this);
250 event.SetInt( toolIndex );
251 event.SetExtraLong((long) toggleDown);
252
253 GetEventHandler()->ProcessEvent(event);
254
255 return TRUE;
256 }
257
258 void wxToolBar::OnRightClick( int toolIndex, float WXUNUSED(x), float WXUNUSED(y) )
259 {
260 wxCommandEvent event( wxEVT_COMMAND_TOOL_RCLICKED, toolIndex );
261 event.SetEventObject( this );
262 event.SetInt( toolIndex );
263
264 GetEventHandler()->ProcessEvent(event);
265 }
266
267 void wxToolBar::OnMouseEnter( int toolIndex )
268 {
269 wxCommandEvent event( wxEVT_COMMAND_TOOL_ENTER, GetId() );
270 event.SetEventObject(this);
271 event.SetInt( toolIndex );
272
273 GetEventHandler()->ProcessEvent(event);
274 }
275
276 wxToolBarTool *wxToolBar::AddTool( int toolIndex, const wxBitmap& bitmap,
277 const wxBitmap& pushedBitmap, bool toggle,
278 wxCoord WXUNUSED(xPos), wxCoord WXUNUSED(yPos), wxObject *clientData,
279 const wxString& helpString1, const wxString& helpString2 )
280 {
281 m_hasToolAlready = TRUE;
282
283 wxCHECK_MSG( bitmap.Ok(), (wxToolBarTool *)NULL,
284 wxT("invalid bitmap for wxToolBar icon") );
285
286 wxCHECK_MSG( bitmap.GetBitmap() == NULL, (wxToolBarTool *)NULL,
287 wxT("wxToolBar doesn't support GdkBitmap") );
288
289 wxCHECK_MSG( bitmap.GetPixmap() != NULL, (wxToolBarTool *)NULL,
290 wxT("wxToolBar::Add needs a wxBitmap") );
291
292 GtkWidget *tool_pixmap = (GtkWidget *)NULL;
293
294 GdkPixmap *pixmap = bitmap.GetPixmap();
295
296 GdkBitmap *mask = (GdkBitmap *)NULL;
297 if ( bitmap.GetMask() )
298 mask = bitmap.GetMask()->GetBitmap();
299
300 tool_pixmap = gtk_pixmap_new( pixmap, mask );
301 #if (GTK_MINOR_VERSION > 0)
302 gtk_pixmap_set_build_insensitive( GTK_PIXMAP(tool_pixmap), TRUE );
303 #endif
304
305 gtk_misc_set_alignment( GTK_MISC(tool_pixmap), 0.5, 0.5 );
306
307 wxToolBarTool *tool = new wxToolBarTool( this, toolIndex, bitmap, pushedBitmap,
308 toggle, clientData,
309 helpString1, helpString2,
310 tool_pixmap );
311
312 GtkToolbarChildType ctype = toggle ? GTK_TOOLBAR_CHILD_TOGGLEBUTTON
313 : GTK_TOOLBAR_CHILD_BUTTON;
314
315 GtkWidget *item = gtk_toolbar_append_element
316 (
317 m_toolbar,
318 ctype,
319 (GtkWidget *)NULL,
320 (const char *)NULL,
321 helpString1.mbc_str(),
322 "",
323 tool_pixmap,
324 (GtkSignalFunc)gtk_toolbar_callback,
325 (gpointer)tool
326 );
327
328 tool->m_item = item;
329
330 GtkRequisition req;
331 (* GTK_WIDGET_CLASS( GTK_OBJECT(m_widget)->klass )->size_request ) (m_widget, &req );
332 m_width = req.width + m_xMargin;
333 m_height = req.height + 2*m_yMargin + 4;
334
335 gtk_signal_connect( GTK_OBJECT(tool->m_item),
336 "enter_notify_event",
337 GTK_SIGNAL_FUNC(gtk_toolbar_enter_callback),
338 (gpointer)tool );
339
340 m_tools.Append( tool );
341
342 return tool;
343 }
344
345 bool wxToolBar::AddControl(wxControl *control)
346 {
347 wxCHECK_MSG( control, FALSE, wxT("toolbar: can't insert NULL control") );
348
349 wxCHECK_MSG( control->GetParent() == this, FALSE,
350 wxT("control must have toolbar as parent") );
351
352 m_hasToolAlready = TRUE;
353
354 wxToolBarTool *tool = new wxToolBarTool(control);
355
356 tool -> m_item = NULL;
357 gtk_toolbar_append_widget( m_toolbar, control->m_widget, (const char *) NULL, (const char *) NULL );
358
359 GtkRequisition req;
360 (* GTK_WIDGET_CLASS( GTK_OBJECT(m_widget)->klass )->size_request ) (m_widget, &req );
361 m_width = req.width + m_xMargin;
362 m_height = req.height + 2*m_yMargin + 4;
363
364 m_tools.Append( tool );
365
366 return TRUE;
367 }
368
369 void wxToolBar::AddSeparator()
370 {
371 gtk_toolbar_append_space( m_toolbar );
372 }
373
374 bool wxToolBar::DeleteTool(int toolIndex)
375 {
376 wxNode *node = m_tools.First();
377 while (node)
378 {
379 wxToolBarTool *tool = (wxToolBarTool*)node->Data();
380 if (tool->m_index == toolIndex)
381 {
382 if (tool->m_control)
383 tool->m_control->Destroy();
384 else
385 gtk_widget_destroy( tool->m_item );
386 m_tools.DeleteNode( node );
387
388 return TRUE;
389 }
390 node = node->Next();
391 }
392
393 return FALSE;
394 }
395
396 void wxToolBar::ClearTools()
397 {
398 wxFAIL_MSG( wxT("wxToolBar::ClearTools not implemented") );
399 }
400
401 bool wxToolBar::Realize()
402 {
403 return TRUE;
404 }
405
406 void wxToolBar::EnableTool(int toolIndex, bool enable)
407 {
408 wxNode *node = m_tools.First();
409 while (node)
410 {
411 wxToolBarTool *tool = (wxToolBarTool*)node->Data();
412 if (tool->m_index == toolIndex)
413 {
414 tool->m_enabled = enable;
415
416 #if (GTK_MINOR_VERSION > 0)
417 /* we don't disable the tools for GTK 1.0 as the bitmaps don't get
418 greyed anyway and this also disables tooltips */
419 if (tool->m_item)
420 gtk_widget_set_sensitive( tool->m_item, enable );
421 #endif
422
423 return;
424 }
425 node = node->Next();
426 }
427
428 wxFAIL_MSG( wxT("wrong toolbar index") );
429 }
430
431 void wxToolBar::ToggleTool( int toolIndex, bool toggle )
432 {
433 wxNode *node = m_tools.First();
434 while (node)
435 {
436 wxToolBarTool *tool = (wxToolBarTool*)node->Data();
437 if (tool->m_index == toolIndex)
438 {
439 if ((tool->m_item) && (GTK_IS_TOGGLE_BUTTON(tool->m_item)))
440 {
441 tool->m_toggleState = toggle;
442
443 if (tool->m_bitmap2.Ok())
444 {
445 wxBitmap bitmap = tool->m_bitmap1;
446 if (tool->m_toggleState) bitmap = tool->m_bitmap2;
447
448 GtkPixmap *pixmap = GTK_PIXMAP( tool->m_pixmap );
449
450 GdkBitmap *mask = (GdkBitmap *) NULL;
451 if (bitmap.GetMask()) mask = bitmap.GetMask()->GetBitmap();
452
453 gtk_pixmap_set( pixmap, bitmap.GetPixmap(), mask );
454 }
455
456 m_blockNextEvent = TRUE; // we cannot use gtk_signal_disconnect here
457
458 gtk_toggle_button_set_state( GTK_TOGGLE_BUTTON(tool->m_item), toggle );
459 }
460
461 return;
462 }
463 node = node->Next();
464 }
465
466 wxFAIL_MSG( wxT("wrong toolbar index") );
467 }
468
469 wxObject *wxToolBar::GetToolClientData( int index ) const
470 {
471 wxNode *node = m_tools.First();
472 while (node)
473 {
474 wxToolBarTool *tool = (wxToolBarTool*)node->Data();
475 if (tool->m_index == index) return tool->m_clientData;;
476 node = node->Next();
477 }
478
479 wxFAIL_MSG( wxT("wrong toolbar index") );
480
481 return (wxObject*)NULL;
482 }
483
484 bool wxToolBar::GetToolState(int toolIndex) const
485 {
486 wxNode *node = m_tools.First();
487 while (node)
488 {
489 wxToolBarTool *tool = (wxToolBarTool*)node->Data();
490 if (tool->m_index == toolIndex) return tool->m_toggleState;
491 node = node->Next();
492 }
493
494 wxFAIL_MSG( wxT("wrong toolbar index") );
495
496 return FALSE;
497 }
498
499 bool wxToolBar::GetToolEnabled(int toolIndex) const
500 {
501 wxNode *node = m_tools.First();
502 while (node)
503 {
504 wxToolBarTool *tool = (wxToolBarTool*)node->Data();
505 if (tool->m_index == toolIndex) return tool->m_enabled;
506 node = node->Next();
507 }
508
509 wxFAIL_MSG( wxT("wrong toolbar index") );
510
511 return FALSE;
512 }
513
514 void wxToolBar::SetMargins( int x, int y )
515 {
516 wxCHECK_RET( !m_hasToolAlready, wxT("wxToolBar::SetMargins must be called before adding tool.") );
517
518 if (x > 1) gtk_toolbar_append_space( m_toolbar ); // oh well
519
520 m_xMargin = x;
521 m_yMargin = y;
522 }
523
524 void wxToolBar::SetToolPacking( int WXUNUSED(packing) )
525 {
526 wxFAIL_MSG( wxT("wxToolBar::SetToolPacking not implemented") );
527 }
528
529 void wxToolBar::SetToolSeparation( int separation )
530 {
531 gtk_toolbar_set_space_size( m_toolbar, separation );
532 m_separation = separation;
533 }
534
535 int wxToolBar::GetToolPacking()
536 {
537 return 0;
538 }
539
540 int wxToolBar::GetToolSeparation()
541 {
542 return m_separation;
543 }
544
545 wxString wxToolBar::GetToolLongHelp(int toolIndex)
546 {
547 wxNode *node = m_tools.First();
548 while (node)
549 {
550 wxToolBarTool *tool = (wxToolBarTool*)node->Data();
551 if (tool->m_index == toolIndex)
552 {
553 return tool->m_longHelpString;
554 }
555 node = node->Next();
556 }
557
558 wxFAIL_MSG( wxT("wrong toolbar index") );
559
560 return wxT("");
561 }
562
563 wxString wxToolBar::GetToolShortHelp(int toolIndex)
564 {
565 wxNode *node = m_tools.First();
566 while (node)
567 {
568 wxToolBarTool *tool = (wxToolBarTool*)node->Data();
569 if (tool->m_index == toolIndex)
570 {
571 return tool->m_shortHelpString;
572 }
573 node = node->Next();
574 }
575
576 wxFAIL_MSG( wxT("wrong toolbar index") );
577
578 return wxT("");
579 }
580
581 void wxToolBar::SetToolLongHelp(int toolIndex, const wxString& helpString)
582 {
583 wxNode *node = m_tools.First();
584 while (node)
585 {
586 wxToolBarTool *tool = (wxToolBarTool*)node->Data();
587 if (tool->m_index == toolIndex)
588 {
589 tool->m_longHelpString = helpString;
590 return;
591 }
592 node = node->Next();
593 }
594
595 wxFAIL_MSG( wxT("wrong toolbar index") );
596
597 return;
598 }
599
600 void wxToolBar::SetToolShortHelp(int toolIndex, const wxString& helpString)
601 {
602 wxNode *node = m_tools.First();
603 while (node)
604 {
605 wxToolBarTool *tool = (wxToolBarTool*)node->Data();
606 if (tool->m_index == toolIndex)
607 {
608 tool->m_shortHelpString = helpString;
609 return;
610 }
611 node = node->Next();
612 }
613
614 wxFAIL_MSG( wxT("wrong toolbar index") );
615
616 return;
617 }
618
619 void wxToolBar::OnIdle( wxIdleEvent &WXUNUSED(ievent) )
620 {
621 wxEvtHandler* evtHandler = GetEventHandler();
622
623 wxNode* node = m_tools.First();
624 while (node)
625 {
626 wxToolBarTool* tool = (wxToolBarTool*) node->Data();
627
628 wxUpdateUIEvent event( tool->m_index );
629 event.SetEventObject(this);
630
631 if (evtHandler->ProcessEvent( event ))
632 {
633 if (event.GetSetEnabled())
634 EnableTool(tool->m_index, event.GetEnabled());
635 if (event.GetSetChecked())
636 ToggleTool(tool->m_index, event.GetChecked());
637 /*
638 if (event.GetSetText())
639 // Set tooltip?
640 */
641 }
642
643 node = node->Next();
644 }
645 }
646
647 void wxToolBar::OnInternalIdle()
648 {
649 wxCursor cursor = m_cursor;
650 if (g_globalCursor.Ok()) cursor = g_globalCursor;
651
652 if (cursor.Ok())
653 {
654 /* I now set the cursor the anew in every OnInternalIdle call
655 as setting the cursor in a parent window also effects the
656 windows above so that checking for the current cursor is
657 not possible. */
658
659 if (HasFlag(wxTB_DOCKABLE))
660 {
661 /* if the toolbar is dockable, then m_widget stands for the
662 GtkHandleBox widget, which uses its own window so that we
663 can set the cursor for it. if the toolbar is not dockable,
664 m_widget comes from m_toolbar which uses its parent's
665 window ("windowless windows") and thus we cannot set the
666 cursor. */
667 gdk_window_set_cursor( m_widget->window, cursor.GetCursor() );
668 }
669
670 wxNode *node = m_tools.First();
671 while (node)
672 {
673 wxToolBarTool *tool = (wxToolBarTool*)node->Data();
674 node = node->Next();
675
676 if (!tool->m_item || !tool->m_item->window)
677 continue;
678 else
679 gdk_window_set_cursor( tool->m_item->window, cursor.GetCursor() );
680 }
681 }
682
683 UpdateWindowUI();
684 }
685
686 #endif