← Back to branch summary

~registry/dolphin-emu/triforce

« back to all changes in this revision

Viewing changes to Externals/wxWidgets3/src/gtk/toolbar.cpp

  • Committer: Sérgio Benjamim
  • Date: 2015-02-13 05:54:40 UTC
  • Revision ID: sergio_br2@yahoo.com.br-20150213055440-ey2rt3sjpy27km78
Dolphin Triforce branch from code.google, commit b957980 (4.0-315).

Show diffs side-by-side

added added

removed removed

Lines of Context:
Externals/wxWidgets3/src/gtk/toolbar.cpp
 
1
/////////////////////////////////////////////////////////////////////////////
 
2
// Name:        src/gtk/toolbar.cpp
 
3
// Purpose:     GTK toolbar
 
4
// Author:      Robert Roebling
 
5
// Modified:    13.12.99 by VZ to derive from wxToolBarBase
 
6
// Copyright:   (c) Robert Roebling
 
7
// Licence:     wxWindows licence
 
8
/////////////////////////////////////////////////////////////////////////////
 
9
 
 
10
// For compilers that support precompilation, includes "wx.h".
 
11
#include "wx/wxprec.h"
 
12
 
 
13
#if wxUSE_TOOLBAR_NATIVE
 
14
 
 
15
#include "wx/toolbar.h"
 
16
 
 
17
#include <gtk/gtk.h>
 
18
#include "wx/gtk/private.h"
 
19
#include "wx/gtk/private/gtk2-compat.h"
 
20
 
 
21
// ----------------------------------------------------------------------------
 
22
// globals
 
23
// ----------------------------------------------------------------------------
 
24
 
 
25
// data
 
26
extern bool       g_blockEventsOnDrag;
 
27
extern wxCursor   g_globalCursor;
 
28
 
 
29
// ----------------------------------------------------------------------------
 
30
// wxToolBarTool
 
31
// ----------------------------------------------------------------------------
 
32
 
 
33
class wxToolBarTool : public wxToolBarToolBase
 
34
{
 
35
public:
 
36
    wxToolBarTool(wxToolBar *tbar,
 
37
                  int id,
 
38
                  const wxString& label,
 
39
                  const wxBitmap& bitmap1,
 
40
                  const wxBitmap& bitmap2,
 
41
                  wxItemKind kind,
 
42
                  wxObject *clientData,
 
43
                  const wxString& shortHelpString,
 
44
                  const wxString& longHelpString)
 
45
        : wxToolBarToolBase(tbar, id, label, bitmap1, bitmap2, kind,
 
46
                            clientData, shortHelpString, longHelpString)
 
47
    {
 
48
        m_item = NULL;
 
49
    }
 
50
 
 
51
    wxToolBarTool(wxToolBar *tbar, wxControl *control, const wxString& label)
 
52
        : wxToolBarToolBase(tbar, control, label)
 
53
    {
 
54
        m_item = NULL;
 
55
    }
 
56
 
 
57
    void SetImage();
 
58
    void CreateDropDown();
 
59
    void ShowDropdown(GtkToggleButton* button);
 
60
 
 
61
    GtkToolItem* m_item;
 
62
};
 
63
 
 
64
// ----------------------------------------------------------------------------
 
65
// wxWin macros
 
66
// ----------------------------------------------------------------------------
 
67
 
 
68
IMPLEMENT_DYNAMIC_CLASS(wxToolBar, wxControl)
 
69
 
 
70
// ============================================================================
 
71
// implementation
 
72
// ============================================================================
 
73
 
 
74
//-----------------------------------------------------------------------------
 
75
// "clicked" from m_item
 
76
//-----------------------------------------------------------------------------
 
77
 
 
78
extern "C" {
 
79
static void item_clicked(GtkToolButton*, wxToolBarTool* tool)
 
80
{
 
81
    if (g_blockEventsOnDrag) return;
 
82
 
 
83
    tool->GetToolBar()->OnLeftClick(tool->GetId(), false);
 
84
}
 
85
}
 
86
 
 
87
//-----------------------------------------------------------------------------
 
88
// "toggled" from m_item
 
89
//-----------------------------------------------------------------------------
 
90
 
 
91
extern "C" {
 
92
static void item_toggled(GtkToggleToolButton* button, wxToolBarTool* tool)
 
93
{
 
94
    if (g_blockEventsOnDrag) return;
 
95
 
 
96
    const bool active = gtk_toggle_tool_button_get_active(button) != 0;
 
97
    tool->Toggle(active);
 
98
    if (!active && tool->GetKind() == wxITEM_RADIO)
 
99
        return;
 
100
 
 
101
    if (!tool->GetToolBar()->OnLeftClick(tool->GetId(), active))
 
102
    {
 
103
        // revert back
 
104
        tool->Toggle();
 
105
    }
 
106
}
 
107
}
 
108
 
 
109
//-----------------------------------------------------------------------------
 
110
// "button_press_event" from m_item child
 
111
//-----------------------------------------------------------------------------
 
112
 
 
113
extern "C" {
 
114
static gboolean
 
115
button_press_event(GtkWidget*, GdkEventButton* event, wxToolBarTool* tool)
 
116
{
 
117
    if (event->button != 3)
 
118
        return FALSE;
 
119
 
 
120
    if (g_blockEventsOnDrag) return TRUE;
 
121
 
 
122
    tool->GetToolBar()->OnRightClick(
 
123
        tool->GetId(), int(event->x), int(event->y));
 
124
 
 
125
    return TRUE;
 
126
}
 
127
}
 
128
 
 
129
//-----------------------------------------------------------------------------
 
130
// "child_detached" from m_widget
 
131
//-----------------------------------------------------------------------------
 
132
 
 
133
extern "C" {
 
134
static void child_detached(GtkWidget*, GtkToolbar* toolbar, void*)
 
135
{
 
136
    // disable showing overflow arrow when toolbar is detached,
 
137
    // otherwise toolbar collapses to just an arrow
 
138
    gtk_toolbar_set_show_arrow(toolbar, false);
 
139
}
 
140
}
 
141
 
 
142
//-----------------------------------------------------------------------------
 
143
// "child_attached" from m_widget
 
144
//-----------------------------------------------------------------------------
 
145
 
 
146
extern "C" {
 
147
static void child_attached(GtkWidget*, GtkToolbar* toolbar, void*)
 
148
{
 
149
    gtk_toolbar_set_show_arrow(toolbar, true);
 
150
}
 
151
}
 
152
 
 
153
//-----------------------------------------------------------------------------
 
154
// "enter_notify_event" / "leave_notify_event" from m_item
 
155
//-----------------------------------------------------------------------------
 
156
 
 
157
extern "C" {
 
158
static gboolean
 
159
enter_notify_event(GtkWidget*, GdkEventCrossing* event, wxToolBarTool* tool)
 
160
{
 
161
    if (g_blockEventsOnDrag) return TRUE;
 
162
 
 
163
    int id = -1;
 
164
    if (event->type == GDK_ENTER_NOTIFY)
 
165
        id = tool->GetId();
 
166
    tool->GetToolBar()->OnMouseEnter(id);
 
167
 
 
168
    return FALSE;
 
169
}
 
170
}
 
171
 
 
172
//-----------------------------------------------------------------------------
 
173
// "expose_event" from GtkImage inside m_item
 
174
//-----------------------------------------------------------------------------
 
175
 
 
176
extern "C" {
 
177
static gboolean
 
178
#ifdef __WXGTK3__
 
179
image_draw(GtkWidget* widget, cairo_t* cr, wxToolBarTool* tool)
 
180
#else
 
181
image_expose_event(GtkWidget* widget, GdkEventExpose*, wxToolBarTool* tool)
 
182
#endif
 
183
{
 
184
    const wxBitmap& bitmap = tool->GetDisabledBitmap();
 
185
    if (tool->IsEnabled() || !bitmap.IsOk())
 
186
        return false;
 
187
 
 
188
    // draw disabled bitmap ourselves, GtkImage has no way to specify it
 
189
    GtkAllocation alloc;
 
190
    gtk_widget_get_allocation(widget, &alloc);
 
191
    GtkRequisition req;
 
192
    gtk_widget_get_requisition(widget, &req);
 
193
    const int x = alloc.x + (alloc.width - req.width) / 2;
 
194
    const int y = alloc.y + (alloc.height - req.height) / 2;
 
195
#ifdef __WXGTK3__
 
196
    bitmap.Draw(cr, x, y);
 
197
#else
 
198
    gdk_draw_pixbuf(
 
199
        gtk_widget_get_window(widget), gtk_widget_get_style(widget)->black_gc, bitmap.GetPixbuf(),
 
200
        0, 0, x, y,
 
201
        -1, -1, GDK_RGB_DITHER_NORMAL, 0, 0);
 
202
#endif
 
203
    return true;
 
204
}
 
205
}
 
206
 
 
207
//-----------------------------------------------------------------------------
 
208
// "toggled" from dropdown menu button
 
209
//-----------------------------------------------------------------------------
 
210
 
 
211
extern "C" {
 
212
static void arrow_toggled(GtkToggleButton* button, wxToolBarTool* tool)
 
213
{
 
214
    if (gtk_toggle_button_get_active(button))
 
215
    {
 
216
        tool->ShowDropdown(button);
 
217
        gtk_toggle_button_set_active(button, false);
 
218
    }
 
219
}
 
220
}
 
221
 
 
222
//-----------------------------------------------------------------------------
 
223
// "button_press_event" from dropdown menu button
 
224
//-----------------------------------------------------------------------------
 
225
 
 
226
extern "C" {
 
227
static gboolean
 
228
arrow_button_press_event(GtkToggleButton* button, GdkEventButton* event, wxToolBarTool* tool)
 
229
{
 
230
    if (event->button == 1)
 
231
    {
 
232
        g_signal_handlers_block_by_func(button, (void*)arrow_toggled, tool);
 
233
        gtk_toggle_button_set_active(button, true);
 
234
        tool->ShowDropdown(button);
 
235
        gtk_toggle_button_set_active(button, false);
 
236
        g_signal_handlers_unblock_by_func(button, (void*)arrow_toggled, tool);
 
237
        return true;
 
238
    }
 
239
    return false;
 
240
}
 
241
}
 
242
 
 
243
void wxToolBar::AddChildGTK(wxWindowGTK* child)
 
244
{
 
245
    GtkWidget* align = gtk_alignment_new(0.5, 0.5, 0, 0);
 
246
    gtk_widget_show(align);
 
247
    gtk_container_add(GTK_CONTAINER(align), child->m_widget);
 
248
    GtkToolItem* item = gtk_tool_item_new();
 
249
    gtk_container_add(GTK_CONTAINER(item), align);
 
250
    // position will be corrected in DoInsertTool if necessary
 
251
    gtk_toolbar_insert(GTK_TOOLBAR(gtk_bin_get_child(GTK_BIN(m_widget))), item, -1);
 
252
}
 
253
 
 
254
// ----------------------------------------------------------------------------
 
255
// wxToolBarTool
 
256
// ----------------------------------------------------------------------------
 
257
 
 
258
void wxToolBarTool::SetImage()
 
259
{
 
260
    const wxBitmap& bitmap = GetNormalBitmap();
 
261
    wxCHECK_RET(bitmap.IsOk(), "invalid bitmap for wxToolBar icon");
 
262
 
 
263
    GtkWidget* image = gtk_tool_button_get_icon_widget(GTK_TOOL_BUTTON(m_item));
 
264
    // always use pixbuf, because pixmap mask does not
 
265
    // work with disabled images in some themes
 
266
    gtk_image_set_from_pixbuf(GTK_IMAGE(image), bitmap.GetPixbuf());
 
267
}
 
268
 
 
269
// helper to create a dropdown menu item
 
270
void wxToolBarTool::CreateDropDown()
 
271
{
 
272
    gtk_tool_item_set_homogeneous(m_item, false);
 
273
    GtkOrientation orient = GTK_ORIENTATION_HORIZONTAL;
 
274
    GtkArrowType arrowType = GTK_ARROW_DOWN;
 
275
    if (GetToolBar()->HasFlag(wxTB_LEFT | wxTB_RIGHT))
 
276
    {
 
277
        orient = GTK_ORIENTATION_VERTICAL;
 
278
        arrowType = GTK_ARROW_RIGHT;
 
279
    }
 
280
    GtkWidget* box = gtk_box_new(orient, 0);
 
281
    GtkWidget* arrow = gtk_arrow_new(arrowType, GTK_SHADOW_NONE);
 
282
    GtkWidget* tool_button = gtk_bin_get_child(GTK_BIN(m_item));
 
283
    gtk_widget_reparent(tool_button, box);
 
284
    GtkWidget* arrow_button = gtk_toggle_button_new();
 
285
    gtk_button_set_relief(GTK_BUTTON(arrow_button),
 
286
        gtk_tool_item_get_relief_style(GTK_TOOL_ITEM(m_item)));
 
287
    gtk_container_add(GTK_CONTAINER(arrow_button), arrow);
 
288
    gtk_container_add(GTK_CONTAINER(box), arrow_button);
 
289
    gtk_widget_show_all(box);
 
290
    gtk_container_add(GTK_CONTAINER(m_item), box);
 
291
 
 
292
    g_signal_connect(arrow_button, "toggled", G_CALLBACK(arrow_toggled), this);
 
293
    g_signal_connect(arrow_button, "button_press_event",
 
294
        G_CALLBACK(arrow_button_press_event), this);
 
295
}
 
296
 
 
297
void wxToolBarTool::ShowDropdown(GtkToggleButton* button)
 
298
{
 
299
    wxToolBarBase* toolbar = GetToolBar();
 
300
    wxCommandEvent event(wxEVT_TOOL_DROPDOWN, GetId());
 
301
    if (!toolbar->HandleWindowEvent(event))
 
302
    {
 
303
        wxMenu* menu = GetDropdownMenu();
 
304
        if (menu)
 
305
        {
 
306
            GtkAllocation alloc;
 
307
            gtk_widget_get_allocation(GTK_WIDGET(button), &alloc);
 
308
            int x = alloc.x;
 
309
            int y = alloc.y;
 
310
            if (toolbar->HasFlag(wxTB_LEFT | wxTB_RIGHT))
 
311
                x += alloc.width;
 
312
            else
 
313
                y += alloc.height;
 
314
            toolbar->PopupMenu(menu, x, y);
 
315
        }
 
316
    }
 
317
}
 
318
 
 
319
wxToolBarToolBase *wxToolBar::CreateTool(int id,
 
320
                                         const wxString& text,
 
321
                                         const wxBitmap& bitmap1,
 
322
                                         const wxBitmap& bitmap2,
 
323
                                         wxItemKind kind,
 
324
                                         wxObject *clientData,
 
325
                                         const wxString& shortHelpString,
 
326
                                         const wxString& longHelpString)
 
327
{
 
328
    return new wxToolBarTool(this, id, text, bitmap1, bitmap2, kind,
 
329
                             clientData, shortHelpString, longHelpString);
 
330
}
 
331
 
 
332
wxToolBarToolBase *
 
333
wxToolBar::CreateTool(wxControl *control, const wxString& label)
 
334
{
 
335
    return new wxToolBarTool(this, control, label);
 
336
}
 
337
 
 
338
//-----------------------------------------------------------------------------
 
339
// wxToolBar construction
 
340
//-----------------------------------------------------------------------------
 
341
 
 
342
void wxToolBar::Init()
 
343
{
 
344
    m_toolbar = NULL;
 
345
    m_tooltips = NULL;
 
346
}
 
347
 
 
348
wxToolBar::~wxToolBar()
 
349
{
 
350
#ifndef __WXGTK3__
 
351
    if (m_tooltips) // always NULL if GTK >= 2.12
 
352
    {
 
353
        gtk_object_destroy(GTK_OBJECT(m_tooltips));
 
354
        g_object_unref(m_tooltips);
 
355
    }
 
356
#endif
 
357
}
 
358
 
 
359
bool wxToolBar::Create( wxWindow *parent,
 
360
                        wxWindowID id,
 
361
                        const wxPoint& pos,
 
362
                        const wxSize& size,
 
363
                        long style,
 
364
                        const wxString& name )
 
365
{
 
366
    if ( !PreCreation( parent, pos, size ) ||
 
367
         !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
 
368
    {
 
369
        wxFAIL_MSG( wxT("wxToolBar creation failed") );
 
370
 
 
371
        return false;
 
372
    }
 
373
 
 
374
    FixupStyle();
 
375
 
 
376
    m_toolbar = GTK_TOOLBAR( gtk_toolbar_new() );
 
377
#ifndef __WXGTK3__
 
378
    if (gtk_check_version(2, 12, 0))
 
379
    {
 
380
        m_tooltips = gtk_tooltips_new();
 
381
        g_object_ref(m_tooltips);
 
382
        gtk_object_sink(GTK_OBJECT(m_tooltips));
 
383
    }
 
384
#endif
 
385
    GtkSetStyle();
 
386
 
 
387
    if (style & wxTB_DOCKABLE)
 
388
    {
 
389
        m_widget = gtk_handle_box_new();
 
390
 
 
391
        g_signal_connect(m_widget, "child_detached",
 
392
            G_CALLBACK(child_detached), NULL);
 
393
        g_signal_connect(m_widget, "child_attached",
 
394
            G_CALLBACK(child_attached), NULL);
 
395
 
 
396
        if (style & wxTB_FLAT)
 
397
            gtk_handle_box_set_shadow_type( GTK_HANDLE_BOX(m_widget), GTK_SHADOW_NONE );
 
398
    }
 
399
    else
 
400
    {
 
401
        m_widget = gtk_event_box_new();
 
402
        ConnectWidget( m_widget );
 
403
    }
 
404
    g_object_ref(m_widget);
 
405
    gtk_container_add(GTK_CONTAINER(m_widget), GTK_WIDGET(m_toolbar));
 
406
    gtk_widget_show(GTK_WIDGET(m_toolbar));
 
407
 
 
408
    m_parent->DoAddChild( this );
 
409
 
 
410
    PostCreation(size);
 
411
 
 
412
    return true;
 
413
}
 
414
 
 
415
GdkWindow *wxToolBar::GTKGetWindow(wxArrayGdkWindows& WXUNUSED(windows)) const
 
416
{
 
417
    return gtk_widget_get_window(GTK_WIDGET(m_toolbar));
 
418
}
 
419
 
 
420
void wxToolBar::GtkSetStyle()
 
421
{
 
422
    GtkOrientation orient = GTK_ORIENTATION_HORIZONTAL;
 
423
    if (HasFlag(wxTB_LEFT | wxTB_RIGHT))
 
424
        orient = GTK_ORIENTATION_VERTICAL;
 
425
 
 
426
    GtkToolbarStyle style = GTK_TOOLBAR_ICONS;
 
427
    if (HasFlag(wxTB_NOICONS))
 
428
        style = GTK_TOOLBAR_TEXT;
 
429
    else if (HasFlag(wxTB_TEXT))
 
430
    {
 
431
        style = GTK_TOOLBAR_BOTH;
 
432
        if (HasFlag(wxTB_HORZ_LAYOUT))
 
433
            style = GTK_TOOLBAR_BOTH_HORIZ;
 
434
    }
 
435
 
 
436
#ifdef __WXGTK3__
 
437
    gtk_orientable_set_orientation(GTK_ORIENTABLE(m_toolbar), orient);
 
438
#else
 
439
    gtk_toolbar_set_orientation(m_toolbar, orient);
 
440
#endif
 
441
    gtk_toolbar_set_style(m_toolbar, style);
 
442
}
 
443
 
 
444
void wxToolBar::SetWindowStyleFlag( long style )
 
445
{
 
446
    wxToolBarBase::SetWindowStyleFlag(style);
 
447
 
 
448
    if ( m_toolbar )
 
449
        GtkSetStyle();
 
450
}
 
451
 
 
452
bool wxToolBar::Realize()
 
453
{
 
454
    if ( !wxToolBarBase::Realize() )
 
455
        return false;
 
456
 
 
457
    // bring the initial state of all the toolbar items in line with the
 
458
    // internal state if the latter was changed by calling wxToolBarTool::
 
459
    // Enable(): this works under MSW, where the toolbar items are only created
 
460
    // in Realize() which uses the internal state to determine the initial
 
461
    // button state, so make it work under GTK too
 
462
    for ( wxToolBarToolsList::const_iterator i = m_tools.begin();
 
463
          i != m_tools.end();
 
464
          ++i )
 
465
    {
 
466
        // by default the toolbar items are enabled and not toggled, so we only
 
467
        // have to do something if their internal state doesn't correspond to
 
468
        // this
 
469
        if ( !(*i)->IsEnabled() )
 
470
            DoEnableTool(*i, false);
 
471
        if ( (*i)->IsToggled() )
 
472
            DoToggleTool(*i, true);
 
473
    }
 
474
 
 
475
    return true;
 
476
}
 
477
 
 
478
bool wxToolBar::DoInsertTool(size_t pos, wxToolBarToolBase *toolBase)
 
479
{
 
480
    wxToolBarTool* tool = static_cast<wxToolBarTool*>(toolBase);
 
481
 
 
482
    GSList* radioGroup;
 
483
    GtkWidget* bin_child;
 
484
    switch ( tool->GetStyle() )
 
485
    {
 
486
        case wxTOOL_STYLE_BUTTON:
 
487
            switch (tool->GetKind())
 
488
            {
 
489
                case wxITEM_CHECK:
 
490
                    tool->m_item = gtk_toggle_tool_button_new();
 
491
                    g_signal_connect(tool->m_item, "toggled",
 
492
                        G_CALLBACK(item_toggled), tool);
 
493
                    break;
 
494
                case wxITEM_RADIO:
 
495
                    radioGroup = GetRadioGroup(pos);
 
496
                    if (!radioGroup)
 
497
                    {
 
498
                        // this is the first button in the radio button group,
 
499
                        // it will be toggled automatically by GTK so bring the
 
500
                        // internal flag in sync
 
501
                        tool->Toggle(true);
 
502
                    }
 
503
                    tool->m_item = gtk_radio_tool_button_new(radioGroup);
 
504
                    g_signal_connect(tool->m_item, "toggled",
 
505
                        G_CALLBACK(item_toggled), tool);
 
506
                    break;
 
507
                default:
 
508
                    wxFAIL_MSG("unknown toolbar child type");
 
509
                    // fall through
 
510
                case wxITEM_DROPDOWN:
 
511
                case wxITEM_NORMAL:
 
512
                    tool->m_item = gtk_tool_button_new(NULL, "");
 
513
                    g_signal_connect(tool->m_item, "clicked",
 
514
                        G_CALLBACK(item_clicked), tool);
 
515
                    break;
 
516
            }
 
517
            if (!HasFlag(wxTB_NOICONS))
 
518
            {
 
519
                GtkWidget* image = gtk_image_new();
 
520
                gtk_tool_button_set_icon_widget(
 
521
                    GTK_TOOL_BUTTON(tool->m_item), image);
 
522
                tool->SetImage();
 
523
                gtk_widget_show(image);
 
524
#ifdef __WXGTK3__
 
525
                g_signal_connect(image, "draw",
 
526
                    G_CALLBACK(image_draw), tool);
 
527
#else
 
528
                g_signal_connect(image, "expose_event",
 
529
                    G_CALLBACK(image_expose_event), tool);
 
530
#endif
 
531
            }
 
532
            if (!tool->GetLabel().empty())
 
533
            {
 
534
                gtk_tool_button_set_label(
 
535
                    GTK_TOOL_BUTTON(tool->m_item), wxGTK_CONV(tool->GetLabel()));
 
536
                // needed for labels in horizontal toolbar with wxTB_HORZ_LAYOUT
 
537
                gtk_tool_item_set_is_important(tool->m_item, true);
 
538
            }
 
539
            if (!HasFlag(wxTB_NO_TOOLTIPS) && !tool->GetShortHelp().empty())
 
540
            {
 
541
#if GTK_CHECK_VERSION(2, 12, 0)
 
542
                if (GTK_CHECK_VERSION(3,0,0) || gtk_check_version(2,12,0) == NULL)
 
543
                {
 
544
                    gtk_tool_item_set_tooltip_text(tool->m_item,
 
545
                        wxGTK_CONV(tool->GetShortHelp()));
 
546
                }
 
547
                else
 
548
#endif
 
549
                {
 
550
#ifndef __WXGTK3__
 
551
                    gtk_tool_item_set_tooltip(tool->m_item,
 
552
                        m_tooltips, wxGTK_CONV(tool->GetShortHelp()), "");
 
553
#endif
 
554
                }
 
555
            }
 
556
            bin_child = gtk_bin_get_child(GTK_BIN(tool->m_item));
 
557
            g_signal_connect(bin_child, "button_press_event",
 
558
                G_CALLBACK(button_press_event), tool);
 
559
            g_signal_connect(bin_child, "enter_notify_event",
 
560
                G_CALLBACK(enter_notify_event), tool);
 
561
            g_signal_connect(bin_child, "leave_notify_event",
 
562
                G_CALLBACK(enter_notify_event), tool);
 
563
 
 
564
            if (tool->GetKind() == wxITEM_DROPDOWN)
 
565
                tool->CreateDropDown();
 
566
            gtk_toolbar_insert(m_toolbar, tool->m_item, int(pos));
 
567
            break;
 
568
 
 
569
        case wxTOOL_STYLE_SEPARATOR:
 
570
            tool->m_item = gtk_separator_tool_item_new();
 
571
            if ( tool->IsStretchable() )
 
572
            {
 
573
                gtk_separator_tool_item_set_draw
 
574
                (
 
575
                    GTK_SEPARATOR_TOOL_ITEM(tool->m_item),
 
576
                    FALSE
 
577
                );
 
578
                gtk_tool_item_set_expand(tool->m_item, TRUE);
 
579
            }
 
580
            gtk_toolbar_insert(m_toolbar, tool->m_item, int(pos));
 
581
            break;
 
582
 
 
583
        case wxTOOL_STYLE_CONTROL:
 
584
            wxWindow* control = tool->GetControl();
 
585
            if (gtk_widget_get_parent(control->m_widget) == NULL)
 
586
                AddChildGTK(control);
 
587
            tool->m_item = GTK_TOOL_ITEM(gtk_widget_get_parent(gtk_widget_get_parent(control->m_widget)));
 
588
            if (gtk_toolbar_get_item_index(m_toolbar, tool->m_item) != int(pos))
 
589
            {
 
590
                g_object_ref(tool->m_item);
 
591
                gtk_container_remove(
 
592
                    GTK_CONTAINER(m_toolbar), GTK_WIDGET(tool->m_item));
 
593
                gtk_toolbar_insert(m_toolbar, tool->m_item, int(pos));
 
594
                g_object_unref(tool->m_item);
 
595
            }
 
596
            break;
 
597
    }
 
598
    gtk_widget_show(GTK_WIDGET(tool->m_item));
 
599
 
 
600
    InvalidateBestSize();
 
601
 
 
602
    return true;
 
603
}
 
604
 
 
605
bool wxToolBar::DoDeleteTool(size_t /* pos */, wxToolBarToolBase* toolBase)
 
606
{
 
607
    wxToolBarTool* tool = static_cast<wxToolBarTool*>(toolBase);
 
608
 
 
609
    if (tool->GetStyle() == wxTOOL_STYLE_CONTROL)
 
610
    {
 
611
        // don't destroy the control here as we can be called from
 
612
        // RemoveTool() and then we need to keep the control alive;
 
613
        // while if we're called from DeleteTool() the control will
 
614
        // be destroyed when wxToolBarToolBase itself is deleted
 
615
        GtkWidget* widget = tool->GetControl()->m_widget;
 
616
        gtk_container_remove(GTK_CONTAINER(gtk_widget_get_parent(widget)), widget);
 
617
    }
 
618
    gtk_widget_destroy(GTK_WIDGET(tool->m_item));
 
619
    tool->m_item = NULL;
 
620
 
 
621
    InvalidateBestSize();
 
622
    return true;
 
623
}
 
624
 
 
625
GSList* wxToolBar::GetRadioGroup(size_t pos)
 
626
{
 
627
    GSList* radioGroup = NULL;
 
628
    GtkToolItem* item = NULL;
 
629
    if (pos > 0)
 
630
    {
 
631
        item = gtk_toolbar_get_nth_item(m_toolbar, int(pos) - 1);
 
632
        if (!GTK_IS_RADIO_TOOL_BUTTON(item))
 
633
            item = NULL;
 
634
    }
 
635
    if (item == NULL && pos < m_tools.size())
 
636
    {
 
637
        item = gtk_toolbar_get_nth_item(m_toolbar, int(pos));
 
638
        if (!GTK_IS_RADIO_TOOL_BUTTON(item))
 
639
            item = NULL;
 
640
    }
 
641
    if (item)
 
642
        radioGroup = gtk_radio_tool_button_get_group((GtkRadioToolButton*)item);
 
643
    return radioGroup;
 
644
}
 
645
 
 
646
// ----------------------------------------------------------------------------
 
647
// wxToolBar tools state
 
648
// ----------------------------------------------------------------------------
 
649
 
 
650
void wxToolBar::DoEnableTool(wxToolBarToolBase *toolBase, bool enable)
 
651
{
 
652
    wxToolBarTool* tool = static_cast<wxToolBarTool*>(toolBase);
 
653
 
 
654
    if (tool->m_item)
 
655
        gtk_widget_set_sensitive(GTK_WIDGET(tool->m_item), enable);
 
656
}
 
657
 
 
658
void wxToolBar::DoToggleTool( wxToolBarToolBase *toolBase, bool toggle )
 
659
{
 
660
    wxToolBarTool* tool = static_cast<wxToolBarTool*>(toolBase);
 
661
 
 
662
    if (tool->m_item)
 
663
    {
 
664
        g_signal_handlers_block_by_func(tool->m_item, (void*)item_toggled, tool);
 
665
 
 
666
        gtk_toggle_tool_button_set_active(
 
667
            GTK_TOGGLE_TOOL_BUTTON(tool->m_item), toggle);
 
668
 
 
669
        g_signal_handlers_unblock_by_func(tool->m_item, (void*)item_toggled, tool);
 
670
    }
 
671
}
 
672
 
 
673
void wxToolBar::DoSetToggle(wxToolBarToolBase * WXUNUSED(tool),
 
674
                            bool WXUNUSED(toggle))
 
675
{
 
676
    // VZ: absolutely no idea about how to do it
 
677
    wxFAIL_MSG( wxT("not implemented") );
 
678
}
 
679
 
 
680
// ----------------------------------------------------------------------------
 
681
// wxToolBar geometry
 
682
// ----------------------------------------------------------------------------
 
683
 
 
684
wxSize wxToolBar::DoGetBestSize() const
 
685
{
 
686
    // Unfortunately, if overflow arrow is enabled GtkToolbar only reports size
 
687
    // of arrow. To get the real size, the arrow is temporarily disabled here.
 
688
    // This is gross, since it will cause a queue_resize, and could potentially
 
689
    // lead to an infinite loop. But there seems to be no alternative, short of
 
690
    // disabling the arrow entirely.
 
691
    gtk_toolbar_set_show_arrow(m_toolbar, false);
 
692
    const wxSize size = wxToolBarBase::DoGetBestSize();
 
693
    gtk_toolbar_set_show_arrow(m_toolbar, true);
 
694
    return size;
 
695
}
 
696
 
 
697
wxToolBarToolBase *wxToolBar::FindToolForPosition(wxCoord WXUNUSED(x),
 
698
                                                  wxCoord WXUNUSED(y)) const
 
699
{
 
700
    // VZ: GTK+ doesn't seem to have such thing
 
701
    wxFAIL_MSG( wxT("wxToolBar::FindToolForPosition() not implemented") );
 
702
 
 
703
    return NULL;
 
704
}
 
705
 
 
706
void wxToolBar::SetToolShortHelp( int id, const wxString& helpString )
 
707
{
 
708
    wxToolBarTool* tool = static_cast<wxToolBarTool*>(FindById(id));
 
709
 
 
710
    if ( tool )
 
711
    {
 
712
        (void)tool->SetShortHelp(helpString);
 
713
        if (tool->m_item)
 
714
        {
 
715
#if GTK_CHECK_VERSION(2, 12, 0)
 
716
            if (GTK_CHECK_VERSION(3,0,0) || gtk_check_version(2,12,0) == NULL)
 
717
            {
 
718
                gtk_tool_item_set_tooltip_text(tool->m_item,
 
719
                    wxGTK_CONV(helpString));
 
720
            }
 
721
            else
 
722
#endif
 
723
            {
 
724
#ifndef __WXGTK3__
 
725
                gtk_tool_item_set_tooltip(tool->m_item,
 
726
                    m_tooltips, wxGTK_CONV(helpString), "");
 
727
#endif
 
728
            }
 
729
        }
 
730
    }
 
731
}
 
732
 
 
733
void wxToolBar::SetToolNormalBitmap( int id, const wxBitmap& bitmap )
 
734
{
 
735
    wxToolBarTool* tool = static_cast<wxToolBarTool*>(FindById(id));
 
736
    if ( tool )
 
737
    {
 
738
        wxCHECK_RET( tool->IsButton(), wxT("Can only set bitmap on button tools."));
 
739
 
 
740
        tool->SetNormalBitmap(bitmap);
 
741
        tool->SetImage();
 
742
    }
 
743
}
 
744
 
 
745
void wxToolBar::SetToolDisabledBitmap( int id, const wxBitmap& bitmap )
 
746
{
 
747
    wxToolBarTool* tool = static_cast<wxToolBarTool*>(FindById(id));
 
748
    if ( tool )
 
749
    {
 
750
        wxCHECK_RET( tool->IsButton(), wxT("Can only set bitmap on button tools."));
 
751
 
 
752
        tool->SetDisabledBitmap(bitmap);
 
753
    }
 
754
}
 
755
 
 
756
// ----------------------------------------------------------------------------
 
757
 
 
758
// static
 
759
wxVisualAttributes
 
760
wxToolBar::GetClassDefaultAttributes(wxWindowVariant WXUNUSED(variant))
 
761
{
 
762
    return GetDefaultAttributesFromGTKWidget(gtk_toolbar_new());
 
763
}
 
764
 
 
765
#endif // wxUSE_TOOLBAR_NATIVE