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 //    gtk_toolbar_set_space_style( m_toolbar, GTK_TOOLBAR_SPACE_LINE );
 182     m_separation = 5;
 183     gtk_toolbar_set_space_size( m_toolbar, m_separation );
 184     m_hasToolAlready = FALSE;
 185
 186     if (style & wxTB_DOCKABLE)
 187     {
 188         m_widget = gtk_handle_box_new();
 189         gtk_container_add( GTK_CONTAINER(m_widget), GTK_WIDGET(m_toolbar) );
 190         gtk_widget_show( GTK_WIDGET(m_toolbar) );
 191
 192 #if (GTK_MINOR_VERSION > 0)
 193         if (style & wxTB_FLAT)
 194             gtk_handle_box_set_shadow_type( GTK_HANDLE_BOX(m_widget), GTK_SHADOW_NONE );
 195 #endif
 196     }
 197     else
 198     {
 199         m_widget = GTK_WIDGET(m_toolbar);
 200     }
 201
 202     gtk_toolbar_set_tooltips( GTK_TOOLBAR(m_toolbar), TRUE );
 203
 204 #if (GTK_MINOR_VERSION > 0)
 205     if (style & wxTB_FLAT)
 206         gtk_toolbar_set_button_relief( GTK_TOOLBAR(m_toolbar), GTK_RELIEF_NONE );
 207 #endif
 208
 209     m_fg = new GdkColor;
 210     m_fg->red = 0;
 211     m_fg->green = 0;
 212     m_fg->blue = 0;
 213     gdk_color_alloc( gtk_widget_get_colormap( GTK_WIDGET(m_toolbar) ), m_fg );
 214
 215     m_bg = new GdkColor;
 216     m_bg->red = 65535;
 217     m_bg->green = 65535;
 218     m_bg->blue = 50000;
 219     gdk_color_alloc( gtk_widget_get_colormap( GTK_WIDGET(m_toolbar) ), m_bg );
 220
 221 #if (GTK_MINOR_VERSION > 0)
 222     gtk_tooltips_force_window( GTK_TOOLBAR(m_toolbar)->tooltips );
 223
 224     GtkStyle *g_style =
 225       gtk_style_copy(
 226          gtk_widget_get_style(
 227             GTK_TOOLBAR(m_toolbar)->tooltips->tip_window ) );
 228
 229     g_style->bg[GTK_STATE_NORMAL] = *m_bg;
 230     gtk_widget_set_style( GTK_TOOLBAR(m_toolbar)->tooltips->tip_window, g_style );
 231 #else
 232     gtk_tooltips_set_colors( GTK_TOOLBAR(m_toolbar)->tooltips, m_bg, m_fg );
 233 #endif
 234
 235     m_xMargin = 0;
 236     m_yMargin = 0;
 237
 238     m_parent->DoAddChild( this );
 239
 240     PostCreation();
 241
 242     Show( TRUE );
 243
 244     return TRUE;
 245 }
 246
 247 bool wxToolBar::OnLeftClick( int toolIndex, bool toggleDown )
 248 {
 249     wxCommandEvent event( wxEVT_COMMAND_TOOL_CLICKED, toolIndex );
 250     event.SetEventObject(this);
 251     event.SetInt( toolIndex );
 252     event.SetExtraLong((long) toggleDown);
 253
 254     GetEventHandler()->ProcessEvent(event);
 255
 256     return TRUE;
 257 }
 258
 259 void wxToolBar::OnRightClick( int toolIndex, float WXUNUSED(x), float WXUNUSED(y) )
 260 {
 261     wxCommandEvent event( wxEVT_COMMAND_TOOL_RCLICKED, toolIndex );
 262     event.SetEventObject( this );
 263     event.SetInt( toolIndex );
 264
 265     GetEventHandler()->ProcessEvent(event);
 266 }
 267
 268 void wxToolBar::OnMouseEnter( int toolIndex )
 269 {
 270     wxCommandEvent event( wxEVT_COMMAND_TOOL_ENTER, GetId() );
 271     event.SetEventObject(this);
 272     event.SetInt( toolIndex );
 273
 274     GetEventHandler()->ProcessEvent(event);
 275 }
 276
 277 wxToolBarTool *wxToolBar::AddTool( int toolIndex, const wxBitmap& bitmap,
 278   const wxBitmap& pushedBitmap, bool toggle,
 279   wxCoord WXUNUSED(xPos), wxCoord WXUNUSED(yPos), wxObject *clientData,
 280   const wxString& helpString1, const wxString& helpString2 )
 281 {
 282     m_hasToolAlready = TRUE;
 283
 284     wxCHECK_MSG( bitmap.Ok(), (wxToolBarTool *)NULL,
 285                  wxT("invalid bitmap for wxToolBar icon") );
 286
 287     wxCHECK_MSG( bitmap.GetBitmap() == NULL, (wxToolBarTool *)NULL,
 288                  wxT("wxToolBar doesn't support GdkBitmap") );
 289
 290     wxCHECK_MSG( bitmap.GetPixmap() != NULL, (wxToolBarTool *)NULL,
 291                  wxT("wxToolBar::Add needs a wxBitmap") );
 292
 293     GtkWidget *tool_pixmap = (GtkWidget *)NULL;
 294
 295     GdkPixmap *pixmap = bitmap.GetPixmap();
 296
 297     GdkBitmap *mask = (GdkBitmap *)NULL;
 298     if ( bitmap.GetMask() )
 299       mask = bitmap.GetMask()->GetBitmap();
 300
 301     tool_pixmap = gtk_pixmap_new( pixmap, mask );
 302 #if (GTK_MINOR_VERSION > 0)
 303     gtk_pixmap_set_build_insensitive( GTK_PIXMAP(tool_pixmap), TRUE );
 304 #endif
 305
 306     gtk_misc_set_alignment( GTK_MISC(tool_pixmap), 0.5, 0.5 );
 307
 308     wxToolBarTool *tool = new wxToolBarTool( this, toolIndex, bitmap, pushedBitmap,
 309                                              toggle, clientData,
 310                                              helpString1, helpString2,
 311                                              tool_pixmap );
 312
 313     GtkToolbarChildType ctype = toggle ? GTK_TOOLBAR_CHILD_TOGGLEBUTTON
 314                                        : GTK_TOOLBAR_CHILD_BUTTON;
 315
 316     GtkWidget *item = gtk_toolbar_append_element
 317                      (
 318                       m_toolbar,
 319                       ctype,
 320                       (GtkWidget *)NULL,
 321                       (const char *)NULL,
 322                       helpString1.mbc_str(),
 323                       "",
 324                       tool_pixmap,
 325                       (GtkSignalFunc)gtk_toolbar_callback,
 326                       (gpointer)tool
 327                      );
 328
 329     tool->m_item = item;
 330
 331     GtkRequisition req;
 332     (* GTK_WIDGET_CLASS( GTK_OBJECT(m_widget)->klass )->size_request ) (m_widget, &req );
 333     m_width = req.width;
 334     m_height = req.height;
 335
 336     gtk_signal_connect( GTK_OBJECT(tool->m_item),
 337                         "enter_notify_event",
 338                         GTK_SIGNAL_FUNC(gtk_toolbar_enter_callback),
 339                         (gpointer)tool );
 340
 341     m_tools.Append( tool );
 342
 343     return tool;
 344 }
 345
 346 bool wxToolBar::AddControl(wxControl *control)
 347 {
 348     wxCHECK_MSG( control, FALSE, wxT("toolbar: can't insert NULL control") );
 349
 350     wxCHECK_MSG( control->GetParent() == this, FALSE,
 351                  wxT("control must have toolbar as parent") );
 352
 353     m_hasToolAlready = TRUE;
 354
 355     wxToolBarTool *tool = new wxToolBarTool(control);
 356
 357     tool -> m_item = NULL;
 358     gtk_toolbar_append_widget( m_toolbar, control->m_widget, (const char *) NULL, (const char *) NULL );
 359
 360     GtkRequisition req;
 361     (* GTK_WIDGET_CLASS( GTK_OBJECT(m_widget)->klass )->size_request ) (m_widget, &req );
 362     m_width = req.width;
 363     m_height = req.height;
 364
 365     m_tools.Append( tool );
 366
 367     return TRUE;
 368 }
 369
 370 void wxToolBar::AddSeparator()
 371 {
 372     gtk_toolbar_append_space( m_toolbar );
 373 }
 374
 375 bool wxToolBar::DeleteTool(int toolIndex)
 376 {
 377     wxNode *node = m_tools.First();
 378     while (node)
 379     {
 380         wxToolBarTool *tool = (wxToolBarTool*)node->Data();
 381         if (tool->m_index == toolIndex)
 382         {
 383             if (tool->m_control)
 384                 tool->m_control->Destroy();
 385             else
 386                 gtk_widget_destroy( tool->m_item );
 387             m_tools.DeleteNode( node );
 388
 389             return TRUE;
 390         }
 391         node = node->Next();
 392     }
 393
 394     return FALSE;
 395 }
 396
 397 void wxToolBar::ClearTools()
 398 {
 399     wxFAIL_MSG( wxT("wxToolBar::ClearTools not implemented") );
 400 }
 401
 402 bool wxToolBar::Realize()
 403 {
 404     m_x = 0;
 405     m_y = 0;
 406     m_width = 100;
 407     m_height = 0;
 408
 409     wxNode *node = m_tools.First();
 410     while (node)
 411     {
 412         wxToolBarTool *tool = (wxToolBarTool*)node->Data();
 413         if (tool->m_bitmap1.Ok())
 414         {
 415             int tool_height = tool->m_bitmap1.GetHeight();
 416             if (tool_height > m_height) m_height = tool_height;
 417         }
 418
 419         node = node->Next();
 420     }
 421
 422     m_height += 5 + 2*m_yMargin;
 423
 424     return TRUE;
 425 }
 426
 427 void wxToolBar::EnableTool(int toolIndex, bool enable)
 428 {
 429     wxNode *node = m_tools.First();
 430     while (node)
 431     {
 432         wxToolBarTool *tool = (wxToolBarTool*)node->Data();
 433         if (tool->m_index == toolIndex)
 434         {
 435             tool->m_enabled = enable;
 436
 437 #if (GTK_MINOR_VERSION > 0)
 438             /* we don't disable the tools for GTK 1.0 as the bitmaps don't get
 439                greyed anyway and this also disables tooltips */
 440             if (tool->m_item)
 441                 gtk_widget_set_sensitive( tool->m_item, enable );
 442 #endif
 443
 444             return;
 445         }
 446         node = node->Next();
 447     }
 448
 449     wxFAIL_MSG( wxT("wrong toolbar index") );
 450 }
 451
 452 void wxToolBar::ToggleTool( int toolIndex, bool toggle )
 453 {
 454     wxNode *node = m_tools.First();
 455     while (node)
 456     {
 457         wxToolBarTool *tool = (wxToolBarTool*)node->Data();
 458         if (tool->m_index == toolIndex)
 459         {
 460             if ((tool->m_item) && (GTK_IS_TOGGLE_BUTTON(tool->m_item)))
 461             {
 462                 tool->m_toggleState = toggle;
 463
 464                 if (tool->m_bitmap2.Ok())
 465                 {
 466                     wxBitmap bitmap = tool->m_bitmap1;
 467                     if (tool->m_toggleState) bitmap = tool->m_bitmap2;
 468
 469                     GtkPixmap *pixmap = GTK_PIXMAP( tool->m_pixmap );
 470
 471                     GdkBitmap *mask = (GdkBitmap *) NULL;
 472                     if (bitmap.GetMask()) mask = bitmap.GetMask()->GetBitmap();
 473
 474                     gtk_pixmap_set( pixmap, bitmap.GetPixmap(), mask );
 475                 }
 476
 477                 m_blockNextEvent = TRUE;  // we cannot use gtk_signal_disconnect here
 478
 479                 gtk_toggle_button_set_state( GTK_TOGGLE_BUTTON(tool->m_item), toggle );
 480             }
 481
 482             return;
 483         }
 484         node = node->Next();
 485     }
 486
 487     wxFAIL_MSG( wxT("wrong toolbar index") );
 488 }
 489
 490 wxObject *wxToolBar::GetToolClientData( int index ) const
 491 {
 492     wxNode *node = m_tools.First();
 493     while (node)
 494     {
 495         wxToolBarTool *tool = (wxToolBarTool*)node->Data();
 496         if (tool->m_index == index) return tool->m_clientData;;
 497         node = node->Next();
 498     }
 499
 500     wxFAIL_MSG( wxT("wrong toolbar index") );
 501
 502     return (wxObject*)NULL;
 503 }
 504
 505 bool wxToolBar::GetToolState(int toolIndex) const
 506 {
 507     wxNode *node = m_tools.First();
 508     while (node)
 509     {
 510         wxToolBarTool *tool = (wxToolBarTool*)node->Data();
 511         if (tool->m_index == toolIndex) return tool->m_toggleState;
 512         node = node->Next();
 513     }
 514
 515     wxFAIL_MSG( wxT("wrong toolbar index") );
 516
 517     return FALSE;
 518 }
 519
 520 bool wxToolBar::GetToolEnabled(int toolIndex) const
 521 {
 522     wxNode *node = m_tools.First();
 523     while (node)
 524     {
 525         wxToolBarTool *tool = (wxToolBarTool*)node->Data();
 526         if (tool->m_index == toolIndex) return tool->m_enabled;
 527         node = node->Next();
 528     }
 529
 530     wxFAIL_MSG( wxT("wrong toolbar index") );
 531
 532     return FALSE;
 533 }
 534
 535 void wxToolBar::SetMargins( int x, int y )
 536 {
 537     wxCHECK_RET( !m_hasToolAlready, wxT("wxToolBar::SetMargins must be called before adding tool.") );
 538
 539     if (x > 2) gtk_toolbar_append_space( m_toolbar );  // oh well
 540
 541     m_xMargin = x;
 542     m_yMargin = y;
 543 }
 544
 545 void wxToolBar::SetToolPacking( int WXUNUSED(packing) )
 546 {
 547     wxFAIL_MSG( wxT("wxToolBar::SetToolPacking not implemented") );
 548 }
 549
 550 void wxToolBar::SetToolSeparation( int separation )
 551 {
 552     gtk_toolbar_set_space_size( m_toolbar, separation );
 553     m_separation = separation;
 554 }
 555
 556 int wxToolBar::GetToolPacking()
 557 {
 558     return 0;
 559 }
 560
 561 int wxToolBar::GetToolSeparation()
 562 {
 563     return m_separation;
 564 }
 565
 566 wxString wxToolBar::GetToolLongHelp(int toolIndex)
 567 {
 568     wxNode *node = m_tools.First();
 569     while (node)
 570     {
 571         wxToolBarTool *tool = (wxToolBarTool*)node->Data();
 572         if (tool->m_index == toolIndex)
 573         {
 574             return tool->m_longHelpString;
 575         }
 576         node = node->Next();
 577     }
 578
 579     wxFAIL_MSG( wxT("wrong toolbar index") );
 580
 581     return wxT("");
 582 }
 583
 584 wxString wxToolBar::GetToolShortHelp(int toolIndex)
 585 {
 586     wxNode *node = m_tools.First();
 587     while (node)
 588     {
 589         wxToolBarTool *tool = (wxToolBarTool*)node->Data();
 590         if (tool->m_index == toolIndex)
 591         {
 592             return tool->m_shortHelpString;
 593         }
 594         node = node->Next();
 595     }
 596
 597     wxFAIL_MSG( wxT("wrong toolbar index") );
 598
 599     return wxT("");
 600 }
 601
 602 void wxToolBar::SetToolLongHelp(int toolIndex, const wxString& helpString)
 603 {
 604     wxNode *node = m_tools.First();
 605     while (node)
 606     {
 607         wxToolBarTool *tool = (wxToolBarTool*)node->Data();
 608         if (tool->m_index == toolIndex)
 609         {
 610             tool->m_longHelpString = helpString;
 611             return;
 612         }
 613         node = node->Next();
 614     }
 615
 616     wxFAIL_MSG( wxT("wrong toolbar index") );
 617
 618     return;
 619 }
 620
 621 void wxToolBar::SetToolShortHelp(int toolIndex, const wxString& helpString)
 622 {
 623     wxNode *node = m_tools.First();
 624     while (node)
 625     {
 626         wxToolBarTool *tool = (wxToolBarTool*)node->Data();
 627         if (tool->m_index == toolIndex)
 628         {
 629             tool->m_shortHelpString = helpString;
 630             return;
 631         }
 632         node = node->Next();
 633     }
 634
 635     wxFAIL_MSG( wxT("wrong toolbar index") );
 636
 637     return;
 638 }
 639
 640 void wxToolBar::OnIdle( wxIdleEvent &WXUNUSED(ievent) )
 641 {
 642     wxEvtHandler* evtHandler = GetEventHandler();
 643
 644     wxNode* node = m_tools.First();
 645     while (node)
 646     {
 647         wxToolBarTool* tool = (wxToolBarTool*) node->Data();
 648
 649         wxUpdateUIEvent event( tool->m_index );
 650         event.SetEventObject(this);
 651
 652         if (evtHandler->ProcessEvent( event ))
 653         {
 654             if (event.GetSetEnabled())
 655                 EnableTool(tool->m_index, event.GetEnabled());
 656             if (event.GetSetChecked())
 657                 ToggleTool(tool->m_index, event.GetChecked());
 658 /*
 659             if (event.GetSetText())
 660                 // Set tooltip?
 661 */
 662         }
 663
 664         node = node->Next();
 665     }
 666 }
 667
 668 void wxToolBar::OnInternalIdle()
 669 {
 670     wxCursor cursor = m_cursor;
 671     if (g_globalCursor.Ok()) cursor = g_globalCursor;
 672
 673     if (cursor.Ok())
 674     {
 675         /* I now set the cursor the anew in every OnInternalIdle call
 676            as setting the cursor in a parent window also effects the
 677            windows above so that checking for the current cursor is
 678            not possible. */
 679
 680         if (HasFlag(wxTB_DOCKABLE))
 681         {
 682             /* if the toolbar is dockable, then m_widget stands for the
 683                GtkHandleBox widget, which uses its own window so that we
 684                can set the cursor for it. if the toolbar is not dockable,
 685                m_widget comes from m_toolbar which uses its parent's
 686                window ("windowless windows") and thus we cannot set the
 687                cursor. */
 688             gdk_window_set_cursor( m_widget->window, cursor.GetCursor() );
 689         }
 690
 691         wxNode *node = m_tools.First();
 692         while (node)
 693         {
 694             wxToolBarTool *tool = (wxToolBarTool*)node->Data();
 695             node = node->Next();
 696
 697             if (!tool->m_item || !tool->m_item->window)
 698                 continue;
 699             else
 700                 gdk_window_set_cursor( tool->m_item->window, cursor.GetCursor() );
 701         }
 702     }
 703
 704     UpdateWindowUI();
 705 }
 706
 707 #endif