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