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