src/gtk/toplevel.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/gtk/toplevel.cpp
   3 // Purpose:
   4 // Author:      Robert Roebling
   5 // Id:          $Id$
   6 // Copyright:   (c) 1998 Robert Roebling
   7 // Licence:     wxWindows licence
   8 /////////////////////////////////////////////////////////////////////////////
   9
  10 // For compilers that support precompilation, includes "wx.h".
  11 #include "wx/wxprec.h"
  12
  13 // ============================================================================
  14 // declarations
  15 // ============================================================================
  16
  17 // ----------------------------------------------------------------------------
  18 // headers
  19 // ----------------------------------------------------------------------------
  20
  21 #ifdef __VMS
  22 #define XIconifyWindow XICONIFYWINDOW
  23 #endif
  24
  25 #include "wx/toplevel.h"
  26
  27 #ifndef WX_PRECOMP
  28     #include "wx/log.h"
  29     #include "wx/app.h"
  30     #include "wx/dcclient.h"
  31 #endif
  32
  33 #include "wx/dialog.h"
  34 #include "wx/control.h"
  35 #include "wx/gtk/private.h"
  36 #include "wx/timer.h"
  37 #include "wx/settings.h"
  38 #include "wx/evtloop.h"
  39
  40 #include <glib.h>
  41 #include <gdk/gdk.h>
  42 #include <gtk/gtk.h>
  43 #include <gdk/gdkkeysyms.h>
  44 #include <gdk/gdkx.h>
  45
  46 #include "wx/gtk/win_gtk.h"
  47
  48 #include "wx/unix/utilsx11.h"
  49
  50 // XA_CARDINAL
  51 #include <X11/Xatom.h>
  52
  53 // ----------------------------------------------------------------------------
  54 // data
  55 // ----------------------------------------------------------------------------
  56
  57 extern wxList           wxPendingDelete;
  58
  59 extern int              g_openDialogs;
  60 extern wxWindowGTK     *g_delayedFocus;
  61
  62 // the frame that is currently active (i.e. its child has focus). It is
  63 // used to generate wxActivateEvents
  64 static wxTopLevelWindowGTK *g_activeFrame = (wxTopLevelWindowGTK*) NULL;
  65 static wxTopLevelWindowGTK *g_lastActiveFrame = (wxTopLevelWindowGTK*) NULL;
  66
  67 // if we detect that the app has got/lost the focus, we set this variable to
  68 // either TRUE or FALSE and an activate event will be sent during the next
  69 // OnIdle() call and it is reset to -1: this value means that we shouldn't
  70 // send any activate events at all
  71 static int g_sendActivateEvent = -1;
  72
  73 //-----------------------------------------------------------------------------
  74 // RequestUserAttention related functions
  75 //-----------------------------------------------------------------------------
  76
  77 extern "C" {
  78 static void wxgtk_window_set_urgency_hint (GtkWindow *win,
  79                                            gboolean setting)
  80 {
  81     wxASSERT_MSG( GTK_WIDGET_REALIZED(win), wxT("wxgtk_window_set_urgency_hint: GdkWindow not realized") );
  82     GdkWindow *window = GTK_WIDGET(win)->window;
  83     XWMHints *wm_hints;
  84
  85     wm_hints = XGetWMHints(GDK_WINDOW_XDISPLAY(window), GDK_WINDOW_XWINDOW(window));
  86
  87     if (!wm_hints)
  88         wm_hints = XAllocWMHints();
  89
  90     if (setting)
  91         wm_hints->flags |= XUrgencyHint;
  92     else
  93         wm_hints->flags &= ~XUrgencyHint;
  94
  95     XSetWMHints(GDK_WINDOW_XDISPLAY(window), GDK_WINDOW_XWINDOW(window), wm_hints);
  96     XFree(wm_hints);
  97 }
  98
  99 static gboolean gtk_frame_urgency_timer_callback( wxTopLevelWindowGTK *win )
 100 {
 101 #if GTK_CHECK_VERSION(2,7,0)
 102     if(!gtk_check_version(2,7,0))
 103         gtk_window_set_urgency_hint(GTK_WINDOW( win->m_widget ), FALSE);
 104     else
 105 #endif
 106         wxgtk_window_set_urgency_hint(GTK_WINDOW( win->m_widget ), FALSE);
 107
 108     win->m_urgency_hint = -2;
 109     return FALSE;
 110 }
 111 }
 112
 113 //-----------------------------------------------------------------------------
 114 // "focus_in_event"
 115 //-----------------------------------------------------------------------------
 116
 117 extern "C" {
 118 static gboolean gtk_frame_focus_in_callback( GtkWidget *widget,
 119                                          GdkEvent *WXUNUSED(event),
 120                                          wxTopLevelWindowGTK *win )
 121 {
 122     if (g_isIdle)
 123         wxapp_install_idle_handler();
 124
 125     switch ( g_sendActivateEvent )
 126     {
 127         case -1:
 128             // we've got focus from outside, synthetize wxActivateEvent
 129             g_sendActivateEvent = 1;
 130             break;
 131
 132         case 0:
 133             // another our window just lost focus, it was already ours before
 134             // - don't send any wxActivateEvent
 135             g_sendActivateEvent = -1;
 136             break;
 137     }
 138
 139     g_activeFrame = win;
 140     g_lastActiveFrame = g_activeFrame;
 141
 142     // wxPrintf( wxT("active: %s\n"), win->GetTitle().c_str() );
 143
 144     // MR: wxRequestUserAttention related block
 145     switch( win->m_urgency_hint )
 146     {
 147         default:
 148             g_source_remove( win->m_urgency_hint );
 149             // no break, fallthrough to remove hint too
 150         case -1:
 151 #if GTK_CHECK_VERSION(2,7,0)
 152             if(!gtk_check_version(2,7,0))
 153                 gtk_window_set_urgency_hint(GTK_WINDOW( widget ), FALSE);
 154             else
 155 #endif
 156             {
 157                 wxgtk_window_set_urgency_hint(GTK_WINDOW( widget ), FALSE);
 158             }
 159
 160             win->m_urgency_hint = -2;
 161             break;
 162
 163         case -2: break;
 164     }
 165
 166     wxLogTrace(wxT("activate"), wxT("Activating frame %p (from focus_in)"), g_activeFrame);
 167     wxActivateEvent event(wxEVT_ACTIVATE, true, g_activeFrame->GetId());
 168     event.SetEventObject(g_activeFrame);
 169     g_activeFrame->GetEventHandler()->ProcessEvent(event);
 170
 171     return FALSE;
 172 }
 173 }
 174
 175 //-----------------------------------------------------------------------------
 176 // "focus_out_event"
 177 //-----------------------------------------------------------------------------
 178
 179 extern "C" {
 180 static gboolean gtk_frame_focus_out_callback( GtkWidget *widget,
 181                                           GdkEventFocus *WXUNUSED(gdk_event),
 182                                           wxTopLevelWindowGTK *win )
 183 {
 184     if (g_isIdle)
 185         wxapp_install_idle_handler();
 186
 187     // if the focus goes out of our app alltogether, OnIdle() will send
 188     // wxActivateEvent, otherwise gtk_window_focus_in_callback() will reset
 189     // g_sendActivateEvent to -1
 190     g_sendActivateEvent = 0;
 191
 192     // wxASSERT_MSG( (g_activeFrame == win), wxT("TLW deactivatd although it wasn't active") );
 193
 194     // wxPrintf( wxT("inactive: %s\n"), win->GetTitle().c_str() );
 195
 196     if (g_activeFrame)
 197     {
 198         wxLogTrace(wxT("activate"), wxT("Activating frame %p (from focus_in)"), g_activeFrame);
 199         wxActivateEvent event(wxEVT_ACTIVATE, false, g_activeFrame->GetId());
 200         event.SetEventObject(g_activeFrame);
 201         g_activeFrame->GetEventHandler()->ProcessEvent(event);
 202
 203         g_activeFrame = NULL;
 204     }
 205
 206     return FALSE;
 207 }
 208 }
 209
 210 //-----------------------------------------------------------------------------
 211 // "focus" from m_window
 212 //-----------------------------------------------------------------------------
 213
 214 extern "C" {
 215 static gboolean gtk_frame_focus_callback( GtkWidget *widget, GtkDirectionType WXUNUSED(d), wxWindow *WXUNUSED(win) )
 216 {
 217     if (g_isIdle)
 218         wxapp_install_idle_handler();
 219
 220     // This disables GTK's tab traversal
 221     g_signal_stop_emission_by_name (widget, "focus");
 222     return TRUE;
 223 }
 224 }
 225
 226 //-----------------------------------------------------------------------------
 227 // "size_allocate"
 228 //-----------------------------------------------------------------------------
 229
 230 extern "C" {
 231 static void gtk_frame_size_callback( GtkWidget *WXUNUSED(widget), GtkAllocation* alloc, wxTopLevelWindowGTK *win )
 232 {
 233     if (g_isIdle)
 234         wxapp_install_idle_handler();
 235
 236     if (!win->m_hasVMT)
 237         return;
 238
 239     if ((win->m_width != alloc->width) || (win->m_height != alloc->height))
 240     {
 241 /*
 242         wxPrintf( "OnSize from " );
 243         if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
 244            wxPrintf( win->GetClassInfo()->GetClassName() );
 245         wxPrintf( " %d %d %d %d\n", (int)alloc->x,
 246                                 (int)alloc->y,
 247                                 (int)alloc->width,
 248                                 (int)alloc->height );
 249 */
 250
 251         win->m_width = alloc->width;
 252         win->m_height = alloc->height;
 253         win->GtkUpdateSize();
 254     }
 255 }
 256 }
 257
 258 //-----------------------------------------------------------------------------
 259 // "delete_event"
 260 //-----------------------------------------------------------------------------
 261
 262 extern "C" {
 263 static gboolean
 264 gtk_frame_delete_callback( GtkWidget *WXUNUSED(widget),
 265                            GdkEvent *WXUNUSED(event),
 266                            wxTopLevelWindowGTK *win )
 267 {
 268     if (g_isIdle)
 269         wxapp_install_idle_handler();
 270
 271     if (win->IsEnabled() &&
 272         (g_openDialogs == 0 || (win->GetExtraStyle() & wxTOPLEVEL_EX_DIALOG) ||
 273          win->IsGrabbed()))
 274         win->Close();
 275
 276     return TRUE;
 277 }
 278 }
 279
 280
 281 //-----------------------------------------------------------------------------
 282 // "configure_event"
 283 //-----------------------------------------------------------------------------
 284
 285 extern "C" {
 286 static gboolean
 287 gtk_frame_configure_callback( GtkWidget *WXUNUSED(widget),
 288                               GdkEventConfigure *WXUNUSED(event),
 289                               wxTopLevelWindowGTK *win )
 290 {
 291     if (g_isIdle)
 292         wxapp_install_idle_handler();
 293
 294     if (!win->m_hasVMT || !win->IsShown())
 295         return FALSE;
 296
 297
 298     int x = 0;
 299     int y = 0;
 300     gdk_window_get_root_origin( win->m_widget->window, &x, &y );
 301     win->m_x = x;
 302     win->m_y = y;
 303
 304     wxMoveEvent mevent( wxPoint(win->m_x,win->m_y), win->GetId() );
 305     mevent.SetEventObject( win );
 306     win->GetEventHandler()->ProcessEvent( mevent );
 307
 308     return FALSE;
 309 }
 310 }
 311
 312 //-----------------------------------------------------------------------------
 313 // "realize" from m_widget
 314 //-----------------------------------------------------------------------------
 315
 316 // we cannot MWM hints and icons before the widget has been realized,
 317 // so we do this directly after realization
 318
 319 extern "C" {
 320 static void
 321 gtk_frame_realized_callback( GtkWidget * WXUNUSED(widget),
 322                              wxTopLevelWindowGTK *win )
 323 {
 324     if (g_isIdle)
 325         wxapp_install_idle_handler();
 326
 327     // All this is for Motif Window Manager "hints" and is supposed to be
 328     // recognized by other WM as well. Not tested.
 329     gdk_window_set_decorations(win->m_widget->window,
 330                                (GdkWMDecoration)win->m_gdkDecor);
 331     gdk_window_set_functions(win->m_widget->window,
 332                                (GdkWMFunction)win->m_gdkFunc);
 333
 334     // GTK's shrinking/growing policy
 335     if ((win->m_gdkFunc & GDK_FUNC_RESIZE) == 0)
 336         gtk_window_set_resizable(GTK_WINDOW(win->m_widget), FALSE);
 337     else
 338         gtk_window_set_policy(GTK_WINDOW(win->m_widget), 1, 1, 1);
 339
 340     // reset the icon
 341     wxIconBundle iconsOld = win->GetIcons();
 342     if ( iconsOld.GetIcon(-1).Ok() )
 343     {
 344         win->SetIcon( wxNullIcon );
 345         win->SetIcons( iconsOld );
 346     }
 347 }
 348 }
 349
 350 //-----------------------------------------------------------------------------
 351 // "map_event" from m_widget
 352 //-----------------------------------------------------------------------------
 353
 354 extern "C" {
 355 static void
 356 gtk_frame_map_callback( GtkWidget * WXUNUSED(widget),
 357                         GdkEvent * WXUNUSED(event),
 358                         wxTopLevelWindow *win )
 359 {
 360     win->SetIconizeState(false);
 361 }
 362 }
 363
 364 //-----------------------------------------------------------------------------
 365 // "unmap_event" from m_widget
 366 //-----------------------------------------------------------------------------
 367
 368 extern "C" {
 369 static void
 370 gtk_frame_unmap_callback( GtkWidget * WXUNUSED(widget),
 371                           GdkEvent * WXUNUSED(event),
 372                           wxTopLevelWindow *win )
 373 {
 374     win->SetIconizeState(true);
 375 }
 376 }
 377
 378 //-----------------------------------------------------------------------------
 379 // "expose_event" of m_client
 380 //-----------------------------------------------------------------------------
 381
 382 extern "C" {
 383 static gboolean
 384 gtk_window_expose_callback( GtkWidget *widget,
 385                             GdkEventExpose *gdk_event,
 386                             wxWindow *win )
 387 {
 388     GtkPizza *pizza = GTK_PIZZA(widget);
 389
 390     gtk_paint_flat_box (win->m_widget->style,
 391                         pizza->bin_window, GTK_STATE_NORMAL,
 392                         GTK_SHADOW_NONE,
 393                         &gdk_event->area,
 394                         win->m_widget,
 395                         (char *)"base",
 396                         0, 0, -1, -1);
 397
 398     return FALSE;
 399 }
 400 }
 401
 402 // ----------------------------------------------------------------------------
 403 // wxTopLevelWindowGTK itself
 404 // ----------------------------------------------------------------------------
 405
 406 //-----------------------------------------------------------------------------
 407 // InsertChild for wxTopLevelWindowGTK
 408 //-----------------------------------------------------------------------------
 409
 410 /* Callback for wxTopLevelWindowGTK. This very strange beast has to be used because
 411  * C++ has no virtual methods in a constructor. We have to emulate a
 412  * virtual function here as wxWidgets requires different ways to insert
 413  * a child in container classes. */
 414
 415 static void wxInsertChildInTopLevelWindow( wxTopLevelWindowGTK* parent, wxWindow* child )
 416 {
 417     wxASSERT( GTK_IS_WIDGET(child->m_widget) );
 418
 419     if (!parent->m_insertInClientArea)
 420     {
 421         // these are outside the client area
 422         wxTopLevelWindowGTK* frame = (wxTopLevelWindowGTK*) parent;
 423         gtk_pizza_put( GTK_PIZZA(frame->m_mainWidget),
 424                          GTK_WIDGET(child->m_widget),
 425                          child->m_x,
 426                          child->m_y,
 427                          child->m_width,
 428                          child->m_height );
 429     }
 430     else
 431     {
 432         // these are inside the client area
 433         gtk_pizza_put( GTK_PIZZA(parent->m_wxwindow),
 434                          GTK_WIDGET(child->m_widget),
 435                          child->m_x,
 436                          child->m_y,
 437                          child->m_width,
 438                          child->m_height );
 439     }
 440
 441     // resize on OnInternalIdle
 442     parent->GtkUpdateSize();
 443 }
 444
 445 // ----------------------------------------------------------------------------
 446 // wxTopLevelWindowGTK creation
 447 // ----------------------------------------------------------------------------
 448
 449 void wxTopLevelWindowGTK::Init()
 450 {
 451     m_sizeSet = false;
 452     m_miniEdge = 0;
 453     m_miniTitle = 0;
 454     m_mainWidget = (GtkWidget*) NULL;
 455     m_insertInClientArea = true;
 456     m_isIconized = false;
 457     m_fsIsShowing = false;
 458     m_themeEnabled = true;
 459     m_gdkDecor = m_gdkFunc = 0;
 460     m_grabbed = false;
 461
 462     m_urgency_hint = -2;
 463 }
 464
 465 bool wxTopLevelWindowGTK::Create( wxWindow *parent,
 466                                   wxWindowID id,
 467                                   const wxString& title,
 468                                   const wxPoint& pos,
 469                                   const wxSize& sizeOrig,
 470                                   long style,
 471                                   const wxString &name )
 472 {
 473     // always create a frame of some reasonable, even if arbitrary, size (at
 474     // least for MSW compatibility)
 475     wxSize size = sizeOrig;
 476     size.x = WidthDefault(size.x);
 477     size.y = HeightDefault(size.y);
 478
 479     wxTopLevelWindows.Append( this );
 480
 481     m_needParent = false;
 482
 483     if (!PreCreation( parent, pos, size ) ||
 484         !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
 485     {
 486         wxFAIL_MSG( wxT("wxTopLevelWindowGTK creation failed") );
 487         return false;
 488     }
 489
 490     m_title = title;
 491
 492     m_insertCallback = (wxInsertChildFunction) wxInsertChildInTopLevelWindow;
 493
 494     // NB: m_widget may be !=NULL if it was created by derived class' Create,
 495     //     e.g. in wxTaskBarIconAreaGTK
 496     if (m_widget == NULL)
 497     {
 498         if (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG)
 499         {
 500             m_widget = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 501             // Tell WM that this is a dialog window and make it center
 502             // on parent by default (this is what GtkDialog ctor does):
 503             gtk_window_set_type_hint(GTK_WINDOW(m_widget),
 504                                      GDK_WINDOW_TYPE_HINT_DIALOG);
 505             gtk_window_set_position(GTK_WINDOW(m_widget),
 506                                     GTK_WIN_POS_CENTER_ON_PARENT);
 507         }
 508         else
 509         {
 510             m_widget = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 511 #if GTK_CHECK_VERSION(2,1,0)
 512             if (!gtk_check_version(2,1,0))
 513             {
 514                 if (style & wxFRAME_TOOL_WINDOW)
 515                 {
 516                     gtk_window_set_type_hint(GTK_WINDOW(m_widget),
 517                                              GDK_WINDOW_TYPE_HINT_UTILITY);
 518
 519                     // On some WMs, like KDE, a TOOL_WINDOW will still show
 520                     // on the taskbar, but on Gnome a TOOL_WINDOW will not.
 521                     // For consistency between WMs and with Windows, we
 522                     // should set the NO_TASKBAR flag which will apply
 523                     // the set_skip_taskbar_hint if it is available,
 524                     // ensuring no taskbar entry will appear.
 525                     style |= wxFRAME_NO_TASKBAR;
 526                 }
 527             }
 528 #endif
 529         }
 530     }
 531
 532     wxWindow *topParent = wxGetTopLevelParent(m_parent);
 533     if (topParent && (((GTK_IS_WINDOW(topParent->m_widget)) &&
 534                        (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG)) ||
 535                        (style & wxFRAME_FLOAT_ON_PARENT)))
 536     {
 537         gtk_window_set_transient_for( GTK_WINDOW(m_widget),
 538                                       GTK_WINDOW(topParent->m_widget) );
 539     }
 540
 541 #if GTK_CHECK_VERSION(2,2,0)
 542     if (!gtk_check_version(2,2,0))
 543     {
 544         if (style & wxFRAME_NO_TASKBAR)
 545         {
 546             gtk_window_set_skip_taskbar_hint(GTK_WINDOW(m_widget), TRUE);
 547         }
 548     }
 549 #endif
 550
 551 #ifdef __WXGTK24__
 552     if (!gtk_check_version(2,4,0))
 553     {
 554         if (style & wxSTAY_ON_TOP)
 555         {
 556             gtk_window_set_keep_above(GTK_WINDOW(m_widget), TRUE);
 557         }
 558     }
 559 #endif
 560
 561     if (!name.empty())
 562         gtk_window_set_wmclass( GTK_WINDOW(m_widget), wxGTK_CONV( name ), wxGTK_CONV( name ) );
 563
 564     gtk_window_set_title( GTK_WINDOW(m_widget), wxGTK_CONV( title ) );
 565     GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
 566
 567     g_signal_connect (m_widget, "delete_event",
 568                       G_CALLBACK (gtk_frame_delete_callback), this);
 569
 570     // m_mainWidget holds the toolbar, the menubar and the client area
 571     m_mainWidget = gtk_pizza_new();
 572     gtk_widget_show( m_mainWidget );
 573     GTK_WIDGET_UNSET_FLAGS( m_mainWidget, GTK_CAN_FOCUS );
 574     gtk_container_add( GTK_CONTAINER(m_widget), m_mainWidget );
 575
 576     if (m_miniEdge == 0) // wxMiniFrame has its own version.
 577     {
 578        // For m_mainWidget themes
 579        g_signal_connect (m_mainWidget, "expose_event",
 580                          G_CALLBACK (gtk_window_expose_callback), this);
 581     }
 582
 583     // m_wxwindow only represents the client area without toolbar and menubar
 584     m_wxwindow = gtk_pizza_new();
 585     gtk_widget_show( m_wxwindow );
 586     gtk_container_add( GTK_CONTAINER(m_mainWidget), m_wxwindow );
 587
 588     // we donm't allow the frame to get the focus as otherwise
 589     // the frame will grab it at arbitrary focus changes
 590     GTK_WIDGET_UNSET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );
 591
 592     if (m_parent) m_parent->AddChild( this );
 593
 594     // the user resized the frame by dragging etc.
 595     g_signal_connect (m_widget, "size_allocate",
 596                       G_CALLBACK (gtk_frame_size_callback), this);
 597
 598     PostCreation();
 599
 600     if ((m_x != -1) || (m_y != -1))
 601         gtk_widget_set_uposition( m_widget, m_x, m_y );
 602
 603     gtk_window_set_default_size( GTK_WINDOW(m_widget), m_width, m_height );
 604
 605     //  we cannot set MWM hints and icons before the widget has
 606     //  been realized, so we do this directly after realization
 607     g_signal_connect (m_widget, "realize",
 608                       G_CALLBACK (gtk_frame_realized_callback), this);
 609
 610     // map and unmap for iconized state
 611     g_signal_connect (m_widget, "map_event",
 612                       G_CALLBACK (gtk_frame_map_callback), this);
 613     g_signal_connect (m_widget, "unmap_event",
 614                       G_CALLBACK (gtk_frame_unmap_callback), this);
 615
 616     // the only way to get the window size is to connect to this event
 617     g_signal_connect (m_widget, "configure_event",
 618                       G_CALLBACK (gtk_frame_configure_callback), this);
 619
 620     // disable native tab traversal
 621     g_signal_connect (m_widget, "focus",
 622                       G_CALLBACK (gtk_frame_focus_callback), this);
 623
 624     // activation
 625     g_signal_connect_after (m_widget, "focus_in_event",
 626                       G_CALLBACK (gtk_frame_focus_in_callback), this);
 627     g_signal_connect_after (m_widget, "focus_out_event",
 628                       G_CALLBACK (gtk_frame_focus_out_callback), this);
 629
 630     // decorations
 631     if ((m_miniEdge > 0) || (style & wxSIMPLE_BORDER) || (style & wxNO_BORDER))
 632     {
 633         m_gdkDecor = 0;
 634         m_gdkFunc = 0;
 635     }
 636     else
 637     {
 638         m_gdkDecor = (long) GDK_DECOR_BORDER;
 639         m_gdkFunc = (long) GDK_FUNC_MOVE;
 640
 641         // All this is for Motif Window Manager "hints" and is supposed to be
 642         // recognized by other WMs as well.
 643         if ((style & wxCAPTION) != 0)
 644         {
 645             m_gdkDecor |= GDK_DECOR_TITLE;
 646         }
 647         if ((style & wxCLOSE_BOX) != 0)
 648         {
 649             m_gdkFunc |= GDK_FUNC_CLOSE;
 650         }
 651         if ((style & wxSYSTEM_MENU) != 0)
 652         {
 653             m_gdkDecor |= GDK_DECOR_MENU;
 654         }
 655         if ((style & wxMINIMIZE_BOX) != 0)
 656         {
 657             m_gdkFunc |= GDK_FUNC_MINIMIZE;
 658             m_gdkDecor |= GDK_DECOR_MINIMIZE;
 659         }
 660         if ((style & wxMAXIMIZE_BOX) != 0)
 661         {
 662             m_gdkFunc |= GDK_FUNC_MAXIMIZE;
 663             m_gdkDecor |= GDK_DECOR_MAXIMIZE;
 664         }
 665         if ((style & wxRESIZE_BORDER) != 0)
 666         {
 667            m_gdkFunc |= GDK_FUNC_RESIZE;
 668            m_gdkDecor |= GDK_DECOR_RESIZEH;
 669         }
 670     }
 671
 672     return true;
 673 }
 674
 675 wxTopLevelWindowGTK::~wxTopLevelWindowGTK()
 676 {
 677     if (m_grabbed)
 678     {
 679         wxFAIL_MSG(_T("Window still grabbed"));
 680         RemoveGrab();
 681     }
 682
 683     m_isBeingDeleted = true;
 684
 685     // it may also be GtkScrolledWindow in the case of an MDI child
 686     if (GTK_IS_WINDOW(m_widget))
 687     {
 688         gtk_window_set_focus( GTK_WINDOW(m_widget), NULL );
 689     }
 690
 691     if (g_activeFrame == this)
 692         g_activeFrame = NULL;
 693     if (g_lastActiveFrame == this)
 694         g_lastActiveFrame = NULL;
 695 }
 696
 697
 698
 699 bool wxTopLevelWindowGTK::ShowFullScreen(bool show, long style )
 700 {
 701     if (show == m_fsIsShowing)
 702         return false; // return what?
 703
 704     m_fsIsShowing = show;
 705
 706     wxX11FullScreenMethod method =
 707         wxGetFullScreenMethodX11((WXDisplay*)GDK_DISPLAY(),
 708                                  (WXWindow)GDK_ROOT_WINDOW());
 709
 710 #if GTK_CHECK_VERSION(2,2,0)
 711     // NB: gtk_window_fullscreen() uses freedesktop.org's WMspec extensions
 712     //     to switch to fullscreen, which is not always available. We must
 713     //     check if WM supports the spec and use legacy methods if it
 714     //     doesn't.
 715     if ( (method == wxX11_FS_WMSPEC) && !gtk_check_version(2,2,0) )
 716     {
 717         if (show)
 718             gtk_window_fullscreen( GTK_WINDOW( m_widget ) );
 719         else
 720             gtk_window_unfullscreen( GTK_WINDOW( m_widget ) );
 721     }
 722     else
 723 #endif // GTK+ >= 2.2.0
 724     {
 725         GdkWindow *window = m_widget->window;
 726
 727         if (show)
 728         {
 729             m_fsSaveFlag = style;
 730             GetPosition( &m_fsSaveFrame.x, &m_fsSaveFrame.y );
 731             GetSize( &m_fsSaveFrame.width, &m_fsSaveFrame.height );
 732
 733             int screen_width,screen_height;
 734             wxDisplaySize( &screen_width, &screen_height );
 735
 736             gint client_x, client_y, root_x, root_y;
 737             gint width, height;
 738
 739             if (method != wxX11_FS_WMSPEC)
 740             {
 741                 // don't do it always, Metacity hates it
 742                 m_fsSaveGdkFunc = m_gdkFunc;
 743                 m_fsSaveGdkDecor = m_gdkDecor;
 744                 m_gdkFunc = m_gdkDecor = 0;
 745                 gdk_window_set_decorations(window, (GdkWMDecoration)0);
 746                 gdk_window_set_functions(window, (GdkWMFunction)0);
 747             }
 748
 749             gdk_window_get_origin (m_widget->window, &root_x, &root_y);
 750             gdk_window_get_geometry (m_widget->window, &client_x, &client_y,
 751                          &width, &height, NULL);
 752
 753             gdk_window_move_resize (m_widget->window, -client_x, -client_y,
 754                         screen_width + 1, screen_height + 1);
 755
 756             wxSetFullScreenStateX11((WXDisplay*)GDK_DISPLAY(),
 757                                     (WXWindow)GDK_ROOT_WINDOW(),
 758                                     (WXWindow)GDK_WINDOW_XWINDOW(window),
 759                                     show, &m_fsSaveFrame, method);
 760         }
 761         else // hide
 762         {
 763             if (method != wxX11_FS_WMSPEC)
 764             {
 765                 // don't do it always, Metacity hates it
 766                 m_gdkFunc = m_fsSaveGdkFunc;
 767                 m_gdkDecor = m_fsSaveGdkDecor;
 768                 gdk_window_set_decorations(window, (GdkWMDecoration)m_gdkDecor);
 769                 gdk_window_set_functions(window, (GdkWMFunction)m_gdkFunc);
 770             }
 771
 772             wxSetFullScreenStateX11((WXDisplay*)GDK_DISPLAY(),
 773                                     (WXWindow)GDK_ROOT_WINDOW(),
 774                                     (WXWindow)GDK_WINDOW_XWINDOW(window),
 775                                     show, &m_fsSaveFrame, method);
 776
 777             SetSize(m_fsSaveFrame.x, m_fsSaveFrame.y,
 778                     m_fsSaveFrame.width, m_fsSaveFrame.height);
 779         }
 780     }
 781
 782     // documented behaviour is to show the window if it's still hidden when
 783     // showing it full screen
 784     if ( show && !IsShown() )
 785         Show();
 786
 787     return true;
 788 }
 789
 790 // ----------------------------------------------------------------------------
 791 // overridden wxWindow methods
 792 // ----------------------------------------------------------------------------
 793
 794 bool wxTopLevelWindowGTK::Show( bool show )
 795 {
 796     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 797
 798     if (show && !m_sizeSet)
 799     {
 800         /* by calling GtkOnSize here, we don't have to call
 801            either after showing the frame, which would entail
 802            much ugly flicker or from within the size_allocate
 803            handler, because GTK 1.1.X forbids that. */
 804
 805         GtkOnSize( m_x, m_y, m_width, m_height );
 806     }
 807
 808     if (show)
 809         gtk_widget_set_uposition( m_widget, m_x, m_y );
 810
 811     return wxWindow::Show( show );
 812 }
 813
 814 void wxTopLevelWindowGTK::Raise()
 815 {
 816     gtk_window_present( GTK_WINDOW( m_widget ) );
 817 }
 818
 819 void wxTopLevelWindowGTK::DoMoveWindow(int WXUNUSED(x), int WXUNUSED(y), int WXUNUSED(width), int WXUNUSED(height) )
 820 {
 821     wxFAIL_MSG( wxT("DoMoveWindow called for wxTopLevelWindowGTK") );
 822 }
 823
 824 void wxTopLevelWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags )
 825 {
 826     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 827
 828     // this shouldn't happen: wxFrame, wxMDIParentFrame and wxMDIChildFrame have m_wxwindow
 829     wxASSERT_MSG( (m_wxwindow != NULL), wxT("invalid frame") );
 830
 831     // avoid recursions
 832     if (m_resizing)
 833         return;
 834     m_resizing = true;
 835
 836     int old_x = m_x;
 837     int old_y = m_y;
 838
 839     int old_width = m_width;
 840     int old_height = m_height;
 841
 842     if ((sizeFlags & wxSIZE_ALLOW_MINUS_ONE) == 0)
 843     {
 844         if (x != -1) m_x = x;
 845         if (y != -1) m_y = y;
 846     }
 847     else
 848     {
 849         m_x = x;
 850         m_y = y;
 851     }
 852     if (width != -1) m_width = width;
 853     if (height != -1) m_height = height;
 854
 855 /*
 856     if ((sizeFlags & wxSIZE_AUTO_WIDTH) == wxSIZE_AUTO_WIDTH)
 857     {
 858         if (width == -1) m_width = 80;
 859     }
 860
 861     if ((sizeFlags & wxSIZE_AUTO_HEIGHT) == wxSIZE_AUTO_HEIGHT)
 862     {
 863        if (height == -1) m_height = 26;
 864     }
 865 */
 866
 867     int minWidth = GetMinWidth(),
 868         minHeight = GetMinHeight(),
 869         maxWidth = GetMaxWidth(),
 870         maxHeight = GetMaxHeight();
 871
 872 #ifdef __WXGPE__
 873     // GPE's window manager doesn't like size hints
 874     // at all, esp. when the user has to use the
 875     // virtual keyboard.
 876     minWidth = -1;
 877     minHeight = -1;
 878     maxWidth = -1;
 879     maxHeight = -1;
 880 #endif
 881
 882     if ((minWidth != -1) && (m_width < minWidth)) m_width = minWidth;
 883     if ((minHeight != -1) && (m_height < minHeight)) m_height = minHeight;
 884     if ((maxWidth != -1) && (m_width > maxWidth)) m_width = maxWidth;
 885     if ((maxHeight != -1) && (m_height > maxHeight)) m_height = maxHeight;
 886
 887     if ((m_x != -1) || (m_y != -1))
 888     {
 889         if ((m_x != old_x) || (m_y != old_y))
 890         {
 891             gtk_widget_set_uposition( m_widget, m_x, m_y );
 892         }
 893     }
 894
 895     if ((m_width != old_width) || (m_height != old_height))
 896     {
 897         if (m_widget->window)
 898             gdk_window_resize( m_widget->window, m_width, m_height );
 899         else
 900             gtk_window_set_default_size( GTK_WINDOW(m_widget), m_width, m_height );
 901
 902         /* we set the size in GtkOnSize, i.e. mostly the actual resizing is
 903            done either directly before the frame is shown or in idle time
 904            so that different calls to SetSize() don't lead to flicker. */
 905         m_sizeSet = false;
 906     }
 907
 908     m_resizing = false;
 909 }
 910
 911 void wxTopLevelWindowGTK::DoGetClientSize( int *width, int *height ) const
 912 {
 913     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 914
 915     wxWindow::DoGetClientSize( width, height );
 916     if (height)
 917     {
 918         // mini edge
 919         *height -= m_miniEdge*2 + m_miniTitle;
 920     }
 921     if (width)
 922     {
 923         *width -= m_miniEdge*2;
 924     }
 925 }
 926
 927 void wxTopLevelWindowGTK::DoSetClientSize( int width, int height )
 928 {
 929     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 930
 931     DoSetSize(-1, -1,
 932               width + m_miniEdge*2, height  + m_miniEdge*2 + m_miniTitle, 0);
 933 }
 934
 935 void wxTopLevelWindowGTK::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y),
 936                                      int width, int height )
 937 {
 938     // due to a bug in gtk, x,y are always 0
 939     // m_x = x;
 940     // m_y = y;
 941
 942     // avoid recursions
 943     if (m_resizing) return;
 944     m_resizing = true;
 945
 946     if ( m_wxwindow == NULL ) return;
 947
 948     m_width = width;
 949     m_height = height;
 950
 951     /* wxMDIChildFrame derives from wxFrame but it _is_ a wxWindow as it uses
 952        wxWindow::Create to create it's GTK equivalent. m_mainWidget is only
 953        set in wxFrame::Create so it is used to check what kind of frame we
 954        have here. if m_mainWidget is NULL it is a wxMDIChildFrame and so we
 955        skip the part which handles m_frameMenuBar, m_frameToolBar and (most
 956        importantly) m_mainWidget */
 957
 958     int minWidth = GetMinWidth(),
 959         minHeight = GetMinHeight(),
 960         maxWidth = GetMaxWidth(),
 961         maxHeight = GetMaxHeight();
 962
 963 #ifdef __WXGPE__
 964     // GPE's window manager doesn't like size hints
 965     // at all, esp. when the user has to use the
 966     // virtual keyboard.
 967     minWidth = -1;
 968     minHeight = -1;
 969     maxWidth = -1;
 970     maxHeight = -1;
 971 #endif
 972
 973     if ((minWidth != -1) && (m_width < minWidth)) m_width = minWidth;
 974     if ((minHeight != -1) && (m_height < minHeight)) m_height = minHeight;
 975     if ((maxWidth != -1) && (m_width > maxWidth)) m_width = maxWidth;
 976     if ((maxHeight != -1) && (m_height > maxHeight)) m_height = maxHeight;
 977
 978     if (m_mainWidget)
 979     {
 980         // set size hints
 981         gint            flag = 0; // GDK_HINT_POS;
 982         GdkGeometry     geom;
 983
 984         if ((minWidth != -1) || (minHeight != -1)) flag |= GDK_HINT_MIN_SIZE;
 985         if ((maxWidth != -1) || (maxHeight != -1)) flag |= GDK_HINT_MAX_SIZE;
 986
 987         geom.min_width = minWidth;
 988         geom.min_height = minHeight;
 989
 990             // Because of the way we set GDK_HINT_MAX_SIZE above, if either of
 991             // maxHeight or maxWidth is set, we must set them both, else the
 992             // remaining -1 will be taken literally.
 993
 994             // I'm certain this also happens elsewhere, and is the probable
 995             // cause of other such things as:
 996             // Gtk-WARNING **: gtk_widget_size_allocate():
 997             //       attempt to allocate widget with width 65535 and height 600
 998             // but I don't have time to track them all now..
 999             //
1000             // Really we need to encapulate all this height/width business and
1001             // stop any old method from ripping at the members directly and
1002             // scattering -1's without regard for who might resolve them later.
1003
1004         geom.max_width = ( maxHeight == -1 ) ? maxWidth
1005                          : ( maxWidth == -1 ) ? wxGetDisplaySize().GetWidth()
1006                            : maxWidth ;
1007
1008         geom.max_height = ( maxWidth == -1 ) ? maxHeight    // ( == -1 here )
1009                           : ( maxHeight == -1 ) ? wxGetDisplaySize().GetHeight()
1010                             : maxHeight ;
1011
1012         gtk_window_set_geometry_hints( GTK_WINDOW(m_widget),
1013                                        (GtkWidget*) NULL,
1014                                        &geom,
1015                                        (GdkWindowHints) flag );
1016
1017         /* I revert back to wxGTK's original behaviour. m_mainWidget holds the
1018          * menubar, the toolbar and the client area, which is represented by
1019          * m_wxwindow.
1020          * this hurts in the eye, but I don't want to call SetSize()
1021          * because I don't want to call any non-native functions here. */
1022
1023         int client_x = m_miniEdge;
1024         int client_y = m_miniEdge + m_miniTitle;
1025         int client_w = m_width - 2*m_miniEdge;
1026         int client_h = m_height - 2*m_miniEdge - m_miniTitle;
1027
1028         gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
1029                               m_wxwindow,
1030                               client_x, client_y, client_w, client_h );
1031     }
1032     else
1033     {
1034         // If there is no m_mainWidget between m_widget and m_wxwindow there
1035         // is no need to set the size or position of m_wxwindow.
1036     }
1037
1038     m_sizeSet = true;
1039
1040     // send size event to frame
1041     wxSizeEvent event( wxSize(m_width,m_height), GetId() );
1042     event.SetEventObject( this );
1043     GetEventHandler()->ProcessEvent( event );
1044
1045     m_resizing = false;
1046 }
1047
1048 void wxTopLevelWindowGTK::OnInternalIdle()
1049 {
1050     if (!m_sizeSet && GTK_WIDGET_REALIZED(m_wxwindow))
1051     {
1052         GtkOnSize( m_x, m_y, m_width, m_height );
1053
1054         // we'll come back later
1055         if (g_isIdle)
1056             wxapp_install_idle_handler();
1057         return;
1058     }
1059
1060     // set the focus if not done yet and if we can already do it
1061     if ( GTK_WIDGET_REALIZED(m_wxwindow) )
1062     {
1063         if ( g_delayedFocus &&
1064              wxGetTopLevelParent((wxWindow*)g_delayedFocus) == this )
1065         {
1066             wxLogTrace(_T("focus"),
1067                        _T("Setting focus from wxTLW::OnIdle() to %s(%s)"),
1068                        g_delayedFocus->GetClassInfo()->GetClassName(),
1069                        g_delayedFocus->GetLabel().c_str());
1070
1071             g_delayedFocus->SetFocus();
1072             g_delayedFocus = NULL;
1073         }
1074     }
1075
1076     wxWindow::OnInternalIdle();
1077
1078     // Synthetize activate events.
1079     if ( g_sendActivateEvent != -1 )
1080     {
1081         bool activate = g_sendActivateEvent != 0;
1082
1083         // if (!activate) wxPrintf( wxT("de") );
1084         // wxPrintf( wxT("activate\n") );
1085
1086         // do it only once
1087         g_sendActivateEvent = -1;
1088
1089         wxTheApp->SetActive(activate, (wxWindow *)g_lastActiveFrame);
1090     }
1091 }
1092
1093 // ----------------------------------------------------------------------------
1094 // frame title/icon
1095 // ----------------------------------------------------------------------------
1096
1097 void wxTopLevelWindowGTK::SetTitle( const wxString &title )
1098 {
1099     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
1100
1101     if ( title == m_title )
1102         return;
1103
1104     m_title = title;
1105
1106     gtk_window_set_title( GTK_WINDOW(m_widget), wxGTK_CONV( title ) );
1107 }
1108
1109 void wxTopLevelWindowGTK::SetIcon( const wxIcon &icon )
1110 {
1111     SetIcons( wxIconBundle( icon ) );
1112 }
1113
1114 void wxTopLevelWindowGTK::SetIcons( const wxIconBundle &icons )
1115 {
1116     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
1117
1118     wxTopLevelWindowBase::SetIcons( icons );
1119
1120     GList *list = NULL;
1121     size_t max = icons.m_icons.GetCount();
1122
1123     for (size_t i = 0; i < max; i++)
1124     {
1125         if (icons.m_icons[i].Ok())
1126         {
1127             list = g_list_prepend(list, icons.m_icons[i].GetPixbuf());
1128         }
1129     }
1130     gtk_window_set_icon_list(GTK_WINDOW(m_widget), list);
1131     g_list_free(list);
1132 }
1133
1134 // ----------------------------------------------------------------------------
1135 // frame state: maximized/iconized/normal
1136 // ----------------------------------------------------------------------------
1137
1138 void wxTopLevelWindowGTK::Maximize(bool maximize)
1139 {
1140     if (maximize)
1141         gtk_window_maximize( GTK_WINDOW( m_widget ) );
1142     else
1143         gtk_window_unmaximize( GTK_WINDOW( m_widget ) );
1144 }
1145
1146 bool wxTopLevelWindowGTK::IsMaximized() const
1147 {
1148     if(!m_widget->window)
1149         return false;
1150
1151     return gdk_window_get_state(m_widget->window) & GDK_WINDOW_STATE_MAXIMIZED;
1152 }
1153
1154 void wxTopLevelWindowGTK::Restore()
1155 {
1156     // "Present" seems similar enough to "restore"
1157     gtk_window_present( GTK_WINDOW( m_widget ) );
1158 }
1159
1160 void wxTopLevelWindowGTK::Iconize( bool iconize )
1161 {
1162     if (iconize)
1163         gtk_window_iconify( GTK_WINDOW( m_widget ) );
1164     else
1165         gtk_window_deiconify( GTK_WINDOW( m_widget ) );
1166 }
1167
1168 bool wxTopLevelWindowGTK::IsIconized() const
1169 {
1170     return m_isIconized;
1171 }
1172
1173 void wxTopLevelWindowGTK::SetIconizeState(bool iconize)
1174 {
1175     if ( iconize != m_isIconized )
1176     {
1177         m_isIconized = iconize;
1178         (void)SendIconizeEvent(iconize);
1179     }
1180 }
1181
1182 void wxTopLevelWindowGTK::AddGrab()
1183 {
1184     if (!m_grabbed)
1185     {
1186         m_grabbed = true;
1187         gtk_grab_add( m_widget );
1188         wxEventLoop().Run();
1189         gtk_grab_remove( m_widget );
1190     }
1191 }
1192
1193 void wxTopLevelWindowGTK::RemoveGrab()
1194 {
1195     if (m_grabbed)
1196     {
1197         gtk_main_quit();
1198         m_grabbed = false;
1199     }
1200 }
1201
1202
1203 // helper
1204 static bool do_shape_combine_region(GdkWindow* window, const wxRegion& region)
1205 {
1206     if (window)
1207     {
1208         if (region.IsEmpty())
1209         {
1210             gdk_window_shape_combine_mask(window, NULL, 0, 0);
1211         }
1212         else
1213         {
1214             gdk_window_shape_combine_region(window, region.GetRegion(), 0, 0);
1215             return true;
1216         }
1217     }
1218     return false;
1219 }
1220
1221
1222 bool wxTopLevelWindowGTK::SetShape(const wxRegion& region)
1223 {
1224     wxCHECK_MSG( HasFlag(wxFRAME_SHAPED), false,
1225                  _T("Shaped windows must be created with the wxFRAME_SHAPED style."));
1226
1227     GdkWindow *window = NULL;
1228     if (m_wxwindow)
1229     {
1230         window = GTK_PIZZA(m_wxwindow)->bin_window;
1231         do_shape_combine_region(window, region);
1232     }
1233     window = m_widget->window;
1234     return do_shape_combine_region(window, region);
1235 }
1236
1237 bool wxTopLevelWindowGTK::IsActive()
1238 {
1239     return (this == (wxTopLevelWindowGTK*)g_activeFrame);
1240 }
1241
1242 void wxTopLevelWindowGTK::RequestUserAttention(int flags)
1243 {
1244     bool new_hint_value = false;
1245
1246     // FIXME: This is a workaround to focus handling problem
1247     // If RequestUserAttention is called for example right after a wxSleep, OnInternalIdle hasn't
1248     // yet been processed, and the internal focus system is not up to date yet.
1249     // wxYieldIfNeeded ensures the processing of it, but can have unwanted side effects - MR
1250     ::wxYieldIfNeeded();
1251
1252     if(m_urgency_hint >= 0)
1253         g_source_remove(m_urgency_hint);
1254
1255     m_urgency_hint = -2;
1256
1257     if( GTK_WIDGET_REALIZED(m_widget) && !IsActive() )
1258     {
1259         new_hint_value = true;
1260
1261         if (flags & wxUSER_ATTENTION_INFO)
1262         {
1263             m_urgency_hint = g_timeout_add(5000, (GSourceFunc)gtk_frame_urgency_timer_callback, this);
1264         } else {
1265             m_urgency_hint = -1;
1266         }
1267     }
1268
1269 #if GTK_CHECK_VERSION(2,7,0)
1270     if(!gtk_check_version(2,7,0))
1271         gtk_window_set_urgency_hint(GTK_WINDOW( m_widget ), new_hint_value);
1272     else
1273 #endif
1274         wxgtk_window_set_urgency_hint(GTK_WINDOW( m_widget ), new_hint_value);
1275 }
1276
1277 void wxTopLevelWindowGTK::SetWindowStyleFlag( long style )
1278 {
1279 #if defined(__WXGTK24__) || GTK_CHECK_VERSION(2,2,0)
1280     // Store which styles were changed
1281     long styleChanges = style ^ m_windowStyle;
1282 #endif
1283
1284     // Process wxWindow styles. This also updates the internal variable
1285     // Therefore m_windowStyle bits carry now the _new_ style values
1286     wxWindow::SetWindowStyleFlag(style);
1287
1288     // just return for now if widget does not exist yet
1289     if (!m_widget)
1290         return;
1291
1292 #ifdef __WXGTK24__
1293     if ( (styleChanges & wxSTAY_ON_TOP) && !gtk_check_version(2,4,0) )
1294         gtk_window_set_keep_above(GTK_WINDOW(m_widget), m_windowStyle & wxSTAY_ON_TOP);
1295 #endif // GTK+ 2.4
1296 #if GTK_CHECK_VERSION(2,2,0)
1297     if ( (styleChanges & wxFRAME_NO_TASKBAR) && !gtk_check_version(2,2,0) )
1298     {
1299         gtk_window_set_skip_taskbar_hint(GTK_WINDOW(m_widget), m_windowStyle & wxFRAME_NO_TASKBAR);
1300     }
1301 #endif // GTK+ 2.2
1302 }