src/gtk1/tbargtk.cpp

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