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     #include "wx/dialog.h"
  32     #include "wx/timer.h"
  33     #include "wx/settings.h"
  34     #include "wx/control.h"
  35 #endif
  36
  37 #include "wx/gtk/private.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 int              g_openDialogs;
  58 extern wxWindowGTK     *g_delayedFocus;
  59
  60 // the frame that is currently active (i.e. its child has focus). It is
  61 // used to generate wxActivateEvents
  62 static wxTopLevelWindowGTK *g_activeFrame = (wxTopLevelWindowGTK*) NULL;
  63 static wxTopLevelWindowGTK *g_lastActiveFrame = (wxTopLevelWindowGTK*) NULL;
  64
  65 // if we detect that the app has got/lost the focus, we set this variable to
  66 // either TRUE or FALSE and an activate event will be sent during the next
  67 // OnIdle() call and it is reset to -1: this value means that we shouldn't
  68 // send any activate events at all
  69 static int g_sendActivateEvent = -1;
  70
  71 //-----------------------------------------------------------------------------
  72 // RequestUserAttention related functions
  73 //-----------------------------------------------------------------------------
  74
  75 extern "C" {
  76 static void wxgtk_window_set_urgency_hint (GtkWindow *win,
  77                                            gboolean setting)
  78 {
  79     wxASSERT_MSG( GTK_WIDGET_REALIZED(win), wxT("wxgtk_window_set_urgency_hint: GdkWindow not realized") );
  80     GdkWindow *window = GTK_WIDGET(win)->window;
  81     XWMHints *wm_hints;
  82
  83     wm_hints = XGetWMHints(GDK_WINDOW_XDISPLAY(window), GDK_WINDOW_XWINDOW(window));
  84
  85     if (!wm_hints)
  86         wm_hints = XAllocWMHints();
  87
  88     if (setting)
  89         wm_hints->flags |= XUrgencyHint;
  90     else
  91         wm_hints->flags &= ~XUrgencyHint;
  92
  93     XSetWMHints(GDK_WINDOW_XDISPLAY(window), GDK_WINDOW_XWINDOW(window), wm_hints);
  94     XFree(wm_hints);
  95 }
  96
  97 static gboolean gtk_frame_urgency_timer_callback( wxTopLevelWindowGTK *win )
  98 {
  99 #if GTK_CHECK_VERSION(2,7,0)
 100     if(!gtk_check_version(2,7,0))
 101         gtk_window_set_urgency_hint(GTK_WINDOW( win->m_widget ), FALSE);
 102     else
 103 #endif
 104         wxgtk_window_set_urgency_hint(GTK_WINDOW( win->m_widget ), FALSE);
 105
 106     win->m_urgency_hint = -2;
 107     return FALSE;
 108 }
 109 }
 110
 111 //-----------------------------------------------------------------------------
 112 // "focus_in_event"
 113 //-----------------------------------------------------------------------------
 114
 115 extern "C" {
 116 static gboolean gtk_frame_focus_in_callback( GtkWidget *widget,
 117                                          GdkEvent *WXUNUSED(event),
 118                                          wxTopLevelWindowGTK *win )
 119 {
 120     if (g_isIdle)
 121         wxapp_install_idle_handler();
 122
 123     switch ( g_sendActivateEvent )
 124     {
 125         case -1:
 126             // we've got focus from outside, synthetize wxActivateEvent
 127             g_sendActivateEvent = 1;
 128             break;
 129
 130         case 0:
 131             // another our window just lost focus, it was already ours before
 132             // - don't send any wxActivateEvent
 133             g_sendActivateEvent = -1;
 134             break;
 135     }
 136
 137     g_activeFrame = win;
 138     g_lastActiveFrame = g_activeFrame;
 139
 140     // wxPrintf( wxT("active: %s\n"), win->GetTitle().c_str() );
 141
 142     // MR: wxRequestUserAttention related block
 143     switch( win->m_urgency_hint )
 144     {
 145         default:
 146             g_source_remove( win->m_urgency_hint );
 147             // no break, fallthrough to remove hint too
 148         case -1:
 149 #if GTK_CHECK_VERSION(2,7,0)
 150             if(!gtk_check_version(2,7,0))
 151                 gtk_window_set_urgency_hint(GTK_WINDOW( widget ), FALSE);
 152             else
 153 #endif
 154             {
 155                 wxgtk_window_set_urgency_hint(GTK_WINDOW( widget ), FALSE);
 156             }
 157
 158             win->m_urgency_hint = -2;
 159             break;
 160
 161         case -2: break;
 162     }
 163
 164     wxLogTrace(wxT("activate"), wxT("Activating frame %p (from focus_in)"), g_activeFrame);
 165     wxActivateEvent event(wxEVT_ACTIVATE, true, g_activeFrame->GetId());
 166     event.SetEventObject(g_activeFrame);
 167     g_activeFrame->GetEventHandler()->ProcessEvent(event);
 168
 169     return FALSE;
 170 }
 171 }
 172
 173 //-----------------------------------------------------------------------------
 174 // "focus_out_event"
 175 //-----------------------------------------------------------------------------
 176
 177 extern "C" {
 178 static gboolean gtk_frame_focus_out_callback( GtkWidget *widget,
 179                                           GdkEventFocus *WXUNUSED(gdk_event),
 180                                           wxTopLevelWindowGTK *win )
 181 {
 182     if (g_isIdle)
 183         wxapp_install_idle_handler();
 184
 185     // if the focus goes out of our app alltogether, OnIdle() will send
 186     // wxActivateEvent, otherwise gtk_window_focus_in_callback() will reset
 187     // g_sendActivateEvent to -1
 188     g_sendActivateEvent = 0;
 189
 190     // wxASSERT_MSG( (g_activeFrame == win), wxT("TLW deactivatd although it wasn't active") );
 191
 192     // wxPrintf( wxT("inactive: %s\n"), win->GetTitle().c_str() );
 193
 194     if (g_activeFrame)
 195     {
 196         wxLogTrace(wxT("activate"), wxT("Activating frame %p (from focus_in)"), g_activeFrame);
 197         wxActivateEvent event(wxEVT_ACTIVATE, false, g_activeFrame->GetId());
 198         event.SetEventObject(g_activeFrame);
 199         g_activeFrame->GetEventHandler()->ProcessEvent(event);
 200
 201         g_activeFrame = NULL;
 202     }
 203
 204     return FALSE;
 205 }
 206 }
 207
 208 //-----------------------------------------------------------------------------
 209 // "focus" from m_window
 210 //-----------------------------------------------------------------------------
 211
 212 extern "C" {
 213 static gboolean gtk_frame_focus_callback( GtkWidget *widget, GtkDirectionType WXUNUSED(d), wxWindow *WXUNUSED(win) )
 214 {
 215     if (g_isIdle)
 216         wxapp_install_idle_handler();
 217
 218     // This disables GTK's tab traversal
 219     g_signal_stop_emission_by_name (widget, "focus");
 220     return TRUE;
 221 }
 222 }
 223
 224 //-----------------------------------------------------------------------------
 225 // "size_allocate"
 226 //-----------------------------------------------------------------------------
 227
 228 extern "C" {
 229 static void gtk_frame_size_callback( GtkWidget *WXUNUSED(widget), GtkAllocation* alloc, wxTopLevelWindowGTK *win )
 230 {
 231     if (g_isIdle)
 232         wxapp_install_idle_handler();
 233
 234     if (!win->m_hasVMT)
 235         return;
 236
 237     if ((win->m_width != alloc->width) || (win->m_height != alloc->height))
 238     {
 239 /*
 240         wxPrintf( "OnSize from " );
 241         if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
 242            wxPrintf( win->GetClassInfo()->GetClassName() );
 243         wxPrintf( " %d %d %d %d\n", (int)alloc->x,
 244                                 (int)alloc->y,
 245                                 (int)alloc->width,
 246                                 (int)alloc->height );
 247 */
 248
 249         win->m_width = alloc->width;
 250         win->m_height = alloc->height;
 251         win->GtkUpdateSize();
 252     }
 253 }
 254 }
 255
 256 //-----------------------------------------------------------------------------
 257 // "delete_event"
 258 //-----------------------------------------------------------------------------
 259
 260 extern "C" {
 261 static gboolean
 262 gtk_frame_delete_callback( GtkWidget *WXUNUSED(widget),
 263                            GdkEvent *WXUNUSED(event),
 264                            wxTopLevelWindowGTK *win )
 265 {
 266     if (g_isIdle)
 267         wxapp_install_idle_handler();
 268
 269     if (win->IsEnabled() &&
 270         (g_openDialogs == 0 || (win->GetExtraStyle() & wxTOPLEVEL_EX_DIALOG) ||
 271          win->IsGrabbed()))
 272         win->Close();
 273
 274     return TRUE;
 275 }
 276 }
 277
 278
 279 //-----------------------------------------------------------------------------
 280 // "configure_event"
 281 //-----------------------------------------------------------------------------
 282
 283 extern "C" {
 284 static gboolean
 285 gtk_frame_configure_callback( GtkWidget *WXUNUSED(widget),
 286                               GdkEventConfigure *WXUNUSED(event),
 287                               wxTopLevelWindowGTK *win )
 288 {
 289     if (g_isIdle)
 290         wxapp_install_idle_handler();
 291
 292     if (!win->m_hasVMT || !win->IsShown())
 293         return FALSE;
 294
 295
 296     int x = 0;
 297     int y = 0;
 298     gdk_window_get_root_origin( win->m_widget->window, &x, &y );
 299     win->m_x = x;
 300     win->m_y = y;
 301
 302     wxMoveEvent mevent( wxPoint(win->m_x,win->m_y), win->GetId() );
 303     mevent.SetEventObject( win );
 304     win->GetEventHandler()->ProcessEvent( mevent );
 305
 306     return FALSE;
 307 }
 308 }
 309
 310 //-----------------------------------------------------------------------------
 311 // "realize" from m_widget
 312 //-----------------------------------------------------------------------------
 313
 314 // we cannot MWM hints and icons before the widget has been realized,
 315 // so we do this directly after realization
 316
 317 extern "C" {
 318 static void
 319 gtk_frame_realized_callback( GtkWidget * WXUNUSED(widget),
 320                              wxTopLevelWindowGTK *win )
 321 {
 322     if (g_isIdle)
 323         wxapp_install_idle_handler();
 324
 325     // All this is for Motif Window Manager "hints" and is supposed to be
 326     // recognized by other WM as well. Not tested.
 327     gdk_window_set_decorations(win->m_widget->window,
 328                                (GdkWMDecoration)win->m_gdkDecor);
 329     gdk_window_set_functions(win->m_widget->window,
 330                                (GdkWMFunction)win->m_gdkFunc);
 331
 332     // GTK's shrinking/growing policy
 333     if ((win->m_gdkFunc & GDK_FUNC_RESIZE) == 0)
 334         gtk_window_set_resizable(GTK_WINDOW(win->m_widget), FALSE);
 335     else
 336         gtk_window_set_policy(GTK_WINDOW(win->m_widget), 1, 1, 1);
 337
 338     // reset the icon
 339     wxIconBundle iconsOld = win->GetIcons();
 340     if ( iconsOld.GetIcon(-1).Ok() )
 341     {
 342         win->SetIcon( wxNullIcon );
 343         win->SetIcons( iconsOld );
 344     }
 345 }
 346 }
 347
 348 //-----------------------------------------------------------------------------
 349 // "map_event" from m_widget
 350 //-----------------------------------------------------------------------------
 351
 352 extern "C" {
 353 static void
 354 gtk_frame_map_callback( GtkWidget * WXUNUSED(widget),
 355                         GdkEvent * WXUNUSED(event),
 356                         wxTopLevelWindow *win )
 357 {
 358     win->SetIconizeState(false);
 359 }
 360 }
 361
 362 //-----------------------------------------------------------------------------
 363 // "unmap_event" from m_widget
 364 //-----------------------------------------------------------------------------
 365
 366 extern "C" {
 367 static void
 368 gtk_frame_unmap_callback( GtkWidget * WXUNUSED(widget),
 369                           GdkEvent * WXUNUSED(event),
 370                           wxTopLevelWindow *win )
 371 {
 372     win->SetIconizeState(true);
 373 }
 374 }
 375
 376 //-----------------------------------------------------------------------------
 377 // "expose_event" of m_client
 378 //-----------------------------------------------------------------------------
 379
 380 extern "C" {
 381 static gboolean
 382 gtk_window_expose_callback( GtkWidget *widget,
 383                             GdkEventExpose *gdk_event,
 384                             wxWindow *win )
 385 {
 386     GtkPizza *pizza = GTK_PIZZA(widget);
 387
 388     gtk_paint_flat_box (win->m_widget->style,
 389                         pizza->bin_window, GTK_STATE_NORMAL,
 390                         GTK_SHADOW_NONE,
 391                         &gdk_event->area,
 392                         win->m_widget,
 393                         (char *)"base",
 394                         0, 0, -1, -1);
 395
 396     return FALSE;
 397 }
 398 }
 399
 400 // ----------------------------------------------------------------------------
 401 // wxTopLevelWindowGTK itself
 402 // ----------------------------------------------------------------------------
 403
 404 //-----------------------------------------------------------------------------
 405 // InsertChild for wxTopLevelWindowGTK
 406 //-----------------------------------------------------------------------------
 407
 408 /* Callback for wxTopLevelWindowGTK. This very strange beast has to be used because
 409  * C++ has no virtual methods in a constructor. We have to emulate a
 410  * virtual function here as wxWidgets requires different ways to insert
 411  * a child in container classes. */
 412
 413 static void wxInsertChildInTopLevelWindow( wxTopLevelWindowGTK* parent, wxWindow* child )
 414 {
 415     wxASSERT( GTK_IS_WIDGET(child->m_widget) );
 416
 417     if (!parent->m_insertInClientArea)
 418     {
 419         // these are outside the client area
 420         wxTopLevelWindowGTK* frame = (wxTopLevelWindowGTK*) parent;
 421         gtk_pizza_put( GTK_PIZZA(frame->m_mainWidget),
 422                          GTK_WIDGET(child->m_widget),
 423                          child->m_x,
 424                          child->m_y,
 425                          child->m_width,
 426                          child->m_height );
 427     }
 428     else
 429     {
 430         // these are inside the client area
 431         gtk_pizza_put( GTK_PIZZA(parent->m_wxwindow),
 432                          GTK_WIDGET(child->m_widget),
 433                          child->m_x,
 434                          child->m_y,
 435                          child->m_width,
 436                          child->m_height );
 437     }
 438
 439     // resize on OnInternalIdle
 440     parent->GtkUpdateSize();
 441 }
 442
 443 // ----------------------------------------------------------------------------
 444 // wxTopLevelWindowGTK creation
 445 // ----------------------------------------------------------------------------
 446
 447 void wxTopLevelWindowGTK::Init()
 448 {
 449     m_sizeSet = false;
 450     m_miniEdge = 0;
 451     m_miniTitle = 0;
 452     m_mainWidget = (GtkWidget*) NULL;
 453     m_insertInClientArea = true;
 454     m_isIconized = false;
 455     m_fsIsShowing = false;
 456     m_themeEnabled = true;
 457     m_gdkDecor = m_gdkFunc = 0;
 458     m_grabbed = false;
 459
 460     m_urgency_hint = -2;
 461 }
 462
 463 bool wxTopLevelWindowGTK::Create( wxWindow *parent,
 464                                   wxWindowID id,
 465                                   const wxString& title,
 466                                   const wxPoint& pos,
 467                                   const wxSize& sizeOrig,
 468                                   long style,
 469                                   const wxString &name )
 470 {
 471     // always create a frame of some reasonable, even if arbitrary, size (at
 472     // least for MSW compatibility)
 473     wxSize size = sizeOrig;
 474     size.x = WidthDefault(size.x);
 475     size.y = HeightDefault(size.y);
 476
 477     wxTopLevelWindows.Append( this );
 478
 479     m_needParent = false;
 480
 481     if (!PreCreation( parent, pos, size ) ||
 482         !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
 483     {
 484         wxFAIL_MSG( wxT("wxTopLevelWindowGTK creation failed") );
 485         return false;
 486     }
 487
 488     m_title = title;
 489
 490     m_insertCallback = (wxInsertChildFunction) wxInsertChildInTopLevelWindow;
 491
 492     // NB: m_widget may be !=NULL if it was created by derived class' Create,
 493     //     e.g. in wxTaskBarIconAreaGTK
 494     if (m_widget == NULL)
 495     {
 496         if (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG)
 497         {
 498             m_widget = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 499             // Tell WM that this is a dialog window and make it center
 500             // on parent by default (this is what GtkDialog ctor does):
 501             gtk_window_set_type_hint(GTK_WINDOW(m_widget),
 502                                      GDK_WINDOW_TYPE_HINT_DIALOG);
 503             gtk_window_set_position(GTK_WINDOW(m_widget),
 504                                     GTK_WIN_POS_CENTER_ON_PARENT);
 505         }
 506         else
 507         {
 508             m_widget = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 509 #if GTK_CHECK_VERSION(2,1,0)
 510             if (!gtk_check_version(2,1,0))
 511             {
 512                 if (style & wxFRAME_TOOL_WINDOW)
 513                 {
 514                     gtk_window_set_type_hint(GTK_WINDOW(m_widget),
 515                                              GDK_WINDOW_TYPE_HINT_UTILITY);
 516
 517                     // On some WMs, like KDE, a TOOL_WINDOW will still show
 518                     // on the taskbar, but on Gnome a TOOL_WINDOW will not.
 519                     // For consistency between WMs and with Windows, we
 520                     // should set the NO_TASKBAR flag which will apply
 521                     // the set_skip_taskbar_hint if it is available,
 522                     // ensuring no taskbar entry will appear.
 523                     style |= wxFRAME_NO_TASKBAR;
 524                 }
 525             }
 526 #endif
 527         }
 528     }
 529
 530     wxWindow *topParent = wxGetTopLevelParent(m_parent);
 531     if (topParent && (((GTK_IS_WINDOW(topParent->m_widget)) &&
 532                        (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG)) ||
 533                        (style & wxFRAME_FLOAT_ON_PARENT)))
 534     {
 535         gtk_window_set_transient_for( GTK_WINDOW(m_widget),
 536                                       GTK_WINDOW(topParent->m_widget) );
 537     }
 538
 539 #if GTK_CHECK_VERSION(2,2,0)
 540     if (!gtk_check_version(2,2,0))
 541     {
 542         if (style & wxFRAME_NO_TASKBAR)
 543         {
 544             gtk_window_set_skip_taskbar_hint(GTK_WINDOW(m_widget), TRUE);
 545         }
 546     }
 547 #endif
 548
 549 #ifdef __WXGTK24__
 550     if (!gtk_check_version(2,4,0))
 551     {
 552         if (style & wxSTAY_ON_TOP)
 553         {
 554             gtk_window_set_keep_above(GTK_WINDOW(m_widget), TRUE);
 555         }
 556     }
 557 #endif
 558
 559 #if 0
 560     if (!name.empty())
 561         gtk_window_set_role( GTK_WINDOW(m_widget), wxGTK_CONV( name ) );
 562 #endif
 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 == IsShown())
 799         return true;
 800
 801     if (show && !m_sizeSet)
 802     {
 803         /* by calling GtkOnSize here, we don't have to call
 804            either after showing the frame, which would entail
 805            much ugly flicker or from within the size_allocate
 806            handler, because GTK 1.1.X forbids that. */
 807
 808         GtkOnSize( m_x, m_y, m_width, m_height );
 809     }
 810
 811     // This seems no longer to be needed and the call
 812     // itself is deprecated.
 813     //
 814     //if (show)
 815     //    gtk_widget_set_uposition( m_widget, m_x, m_y );
 816
 817     return wxWindow::Show( show );
 818 }
 819
 820 void wxTopLevelWindowGTK::Raise()
 821 {
 822     gtk_window_present( GTK_WINDOW( m_widget ) );
 823 }
 824
 825 void wxTopLevelWindowGTK::DoMoveWindow(int WXUNUSED(x), int WXUNUSED(y), int WXUNUSED(width), int WXUNUSED(height) )
 826 {
 827     wxFAIL_MSG( wxT("DoMoveWindow called for wxTopLevelWindowGTK") );
 828 }
 829
 830 void wxTopLevelWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags )
 831 {
 832     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 833
 834     // this shouldn't happen: wxFrame, wxMDIParentFrame and wxMDIChildFrame have m_wxwindow
 835     wxASSERT_MSG( (m_wxwindow != NULL), wxT("invalid frame") );
 836
 837     // avoid recursions
 838     if (m_resizing)
 839         return;
 840     m_resizing = true;
 841
 842     int old_x = m_x;
 843     int old_y = m_y;
 844
 845     int old_width = m_width;
 846     int old_height = m_height;
 847
 848     if ((sizeFlags & wxSIZE_ALLOW_MINUS_ONE) == 0)
 849     {
 850         if (x != -1) m_x = x;
 851         if (y != -1) m_y = y;
 852     }
 853     else
 854     {
 855         m_x = x;
 856         m_y = y;
 857     }
 858     if (width != -1) m_width = width;
 859     if (height != -1) m_height = height;
 860
 861 /*
 862     if ((sizeFlags & wxSIZE_AUTO_WIDTH) == wxSIZE_AUTO_WIDTH)
 863     {
 864         if (width == -1) m_width = 80;
 865     }
 866
 867     if ((sizeFlags & wxSIZE_AUTO_HEIGHT) == wxSIZE_AUTO_HEIGHT)
 868     {
 869        if (height == -1) m_height = 26;
 870     }
 871 */
 872
 873     int minWidth = GetMinWidth(),
 874         minHeight = GetMinHeight(),
 875         maxWidth = GetMaxWidth(),
 876         maxHeight = GetMaxHeight();
 877
 878 #ifdef __WXGPE__
 879     // GPE's window manager doesn't like size hints
 880     // at all, esp. when the user has to use the
 881     // virtual keyboard.
 882     minWidth = -1;
 883     minHeight = -1;
 884     maxWidth = -1;
 885     maxHeight = -1;
 886 #endif
 887
 888     if ((minWidth != -1) && (m_width < minWidth)) m_width = minWidth;
 889     if ((minHeight != -1) && (m_height < minHeight)) m_height = minHeight;
 890     if ((maxWidth != -1) && (m_width > maxWidth)) m_width = maxWidth;
 891     if ((maxHeight != -1) && (m_height > maxHeight)) m_height = maxHeight;
 892
 893     if ((m_x != -1) || (m_y != -1))
 894     {
 895         if ((m_x != old_x) || (m_y != old_y))
 896         {
 897             gtk_widget_set_uposition( m_widget, m_x, m_y );
 898         }
 899     }
 900
 901     if ((m_width != old_width) || (m_height != old_height))
 902     {
 903         if (m_widget->window)
 904             gdk_window_resize( m_widget->window, m_width, m_height );
 905         else
 906             gtk_window_set_default_size( GTK_WINDOW(m_widget), m_width, m_height );
 907
 908         /* we set the size in GtkOnSize, i.e. mostly the actual resizing is
 909            done either directly before the frame is shown or in idle time
 910            so that different calls to SetSize() don't lead to flicker. */
 911         m_sizeSet = false;
 912     }
 913
 914     m_resizing = false;
 915 }
 916
 917 void wxTopLevelWindowGTK::DoGetClientSize( int *width, int *height ) const
 918 {
 919     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 920
 921     wxWindow::DoGetClientSize( width, height );
 922     if (height)
 923     {
 924         // mini edge
 925         *height -= m_miniEdge*2 + m_miniTitle;
 926     }
 927     if (width)
 928     {
 929         *width -= m_miniEdge*2;
 930     }
 931 }
 932
 933 void wxTopLevelWindowGTK::DoSetClientSize( int width, int height )
 934 {
 935     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 936
 937     DoSetSize(-1, -1,
 938               width + m_miniEdge*2, height  + m_miniEdge*2 + m_miniTitle, 0);
 939 }
 940
 941 void wxTopLevelWindowGTK::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y),
 942                                      int width, int height )
 943 {
 944     // due to a bug in gtk, x,y are always 0
 945     // m_x = x;
 946     // m_y = y;
 947
 948     // avoid recursions
 949     if (m_resizing) return;
 950     m_resizing = true;
 951
 952     if ( m_wxwindow == NULL ) return;
 953
 954     m_width = width;
 955     m_height = height;
 956
 957     /* wxMDIChildFrame derives from wxFrame but it _is_ a wxWindow as it uses
 958        wxWindow::Create to create it's GTK equivalent. m_mainWidget is only
 959        set in wxFrame::Create so it is used to check what kind of frame we
 960        have here. if m_mainWidget is NULL it is a wxMDIChildFrame and so we
 961        skip the part which handles m_frameMenuBar, m_frameToolBar and (most
 962        importantly) m_mainWidget */
 963
 964     int minWidth = GetMinWidth(),
 965         minHeight = GetMinHeight(),
 966         maxWidth = GetMaxWidth(),
 967         maxHeight = GetMaxHeight();
 968
 969 #ifdef __WXGPE__
 970     // GPE's window manager doesn't like size hints
 971     // at all, esp. when the user has to use the
 972     // virtual keyboard.
 973     minWidth = -1;
 974     minHeight = -1;
 975     maxWidth = -1;
 976     maxHeight = -1;
 977 #endif
 978
 979     if ((minWidth != -1) && (m_width < minWidth)) m_width = minWidth;
 980     if ((minHeight != -1) && (m_height < minHeight)) m_height = minHeight;
 981     if ((maxWidth != -1) && (m_width > maxWidth)) m_width = maxWidth;
 982     if ((maxHeight != -1) && (m_height > maxHeight)) m_height = maxHeight;
 983
 984     if (m_mainWidget)
 985     {
 986         // set size hints
 987         gint            flag = 0; // GDK_HINT_POS;
 988         GdkGeometry     geom;
 989
 990         if ((minWidth != -1) || (minHeight != -1)) flag |= GDK_HINT_MIN_SIZE;
 991         if ((maxWidth != -1) || (maxHeight != -1)) flag |= GDK_HINT_MAX_SIZE;
 992
 993         geom.min_width = minWidth;
 994         geom.min_height = minHeight;
 995
 996             // Because of the way we set GDK_HINT_MAX_SIZE above, if either of
 997             // maxHeight or maxWidth is set, we must set them both, else the
 998             // remaining -1 will be taken literally.
 999
1000             // I'm certain this also happens elsewhere, and is the probable
1001             // cause of other such things as:
1002             // Gtk-WARNING **: gtk_widget_size_allocate():
1003             //       attempt to allocate widget with width 65535 and height 600
1004             // but I don't have time to track them all now..
1005             //
1006             // Really we need to encapulate all this height/width business and
1007             // stop any old method from ripping at the members directly and
1008             // scattering -1's without regard for who might resolve them later.
1009
1010         geom.max_width = ( maxHeight == -1 ) ? maxWidth
1011                          : ( maxWidth == -1 ) ? wxGetDisplaySize().GetWidth()
1012                            : maxWidth ;
1013
1014         geom.max_height = ( maxWidth == -1 ) ? maxHeight    // ( == -1 here )
1015                           : ( maxHeight == -1 ) ? wxGetDisplaySize().GetHeight()
1016                             : maxHeight ;
1017
1018         gtk_window_set_geometry_hints( GTK_WINDOW(m_widget),
1019                                        (GtkWidget*) NULL,
1020                                        &geom,
1021                                        (GdkWindowHints) flag );
1022
1023         /* I revert back to wxGTK's original behaviour. m_mainWidget holds the
1024          * menubar, the toolbar and the client area, which is represented by
1025          * m_wxwindow.
1026          * this hurts in the eye, but I don't want to call SetSize()
1027          * because I don't want to call any non-native functions here. */
1028
1029         int client_x = m_miniEdge;
1030         int client_y = m_miniEdge + m_miniTitle;
1031         int client_w = m_width - 2*m_miniEdge;
1032         int client_h = m_height - 2*m_miniEdge - m_miniTitle;
1033
1034         gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
1035                               m_wxwindow,
1036                               client_x, client_y, client_w, client_h );
1037     }
1038     else
1039     {
1040         // If there is no m_mainWidget between m_widget and m_wxwindow there
1041         // is no need to set the size or position of m_wxwindow.
1042     }
1043
1044     m_sizeSet = true;
1045
1046     // send size event to frame
1047     wxSizeEvent event( wxSize(m_width,m_height), GetId() );
1048     event.SetEventObject( this );
1049     GetEventHandler()->ProcessEvent( event );
1050
1051     m_resizing = false;
1052 }
1053
1054 void wxTopLevelWindowGTK::OnInternalIdle()
1055 {
1056     if (!m_sizeSet && GTK_WIDGET_REALIZED(m_wxwindow))
1057     {
1058         GtkOnSize( m_x, m_y, m_width, m_height );
1059
1060         // we'll come back later
1061         if (g_isIdle)
1062             wxapp_install_idle_handler();
1063         return;
1064     }
1065
1066     // set the focus if not done yet and if we can already do it
1067     if ( GTK_WIDGET_REALIZED(m_wxwindow) )
1068     {
1069         if ( g_delayedFocus &&
1070              wxGetTopLevelParent((wxWindow*)g_delayedFocus) == this )
1071         {
1072             wxLogTrace(_T("focus"),
1073                        _T("Setting focus from wxTLW::OnIdle() to %s(%s)"),
1074                        g_delayedFocus->GetClassInfo()->GetClassName(),
1075                        g_delayedFocus->GetLabel().c_str());
1076
1077             g_delayedFocus->SetFocus();
1078             g_delayedFocus = NULL;
1079         }
1080     }
1081
1082     wxWindow::OnInternalIdle();
1083
1084     // Synthetize activate events.
1085     if ( g_sendActivateEvent != -1 )
1086     {
1087         bool activate = g_sendActivateEvent != 0;
1088
1089         // if (!activate) wxPrintf( wxT("de") );
1090         // wxPrintf( wxT("activate\n") );
1091
1092         // do it only once
1093         g_sendActivateEvent = -1;
1094
1095         wxTheApp->SetActive(activate, (wxWindow *)g_lastActiveFrame);
1096     }
1097 }
1098
1099 // ----------------------------------------------------------------------------
1100 // frame title/icon
1101 // ----------------------------------------------------------------------------
1102
1103 void wxTopLevelWindowGTK::SetTitle( const wxString &title )
1104 {
1105     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
1106
1107     if ( title == m_title )
1108         return;
1109
1110     m_title = title;
1111
1112     gtk_window_set_title( GTK_WINDOW(m_widget), wxGTK_CONV( title ) );
1113 }
1114
1115 void wxTopLevelWindowGTK::SetIcon( const wxIcon &icon )
1116 {
1117     SetIcons( wxIconBundle( icon ) );
1118 }
1119
1120 void wxTopLevelWindowGTK::SetIcons( const wxIconBundle &icons )
1121 {
1122     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
1123
1124     wxTopLevelWindowBase::SetIcons( icons );
1125
1126     GList *list = NULL;
1127     size_t max = icons.m_icons.GetCount();
1128
1129     for (size_t i = 0; i < max; i++)
1130     {
1131         if (icons.m_icons[i].Ok())
1132         {
1133             list = g_list_prepend(list, icons.m_icons[i].GetPixbuf());
1134         }
1135     }
1136     gtk_window_set_icon_list(GTK_WINDOW(m_widget), list);
1137     g_list_free(list);
1138 }
1139
1140 // ----------------------------------------------------------------------------
1141 // frame state: maximized/iconized/normal
1142 // ----------------------------------------------------------------------------
1143
1144 void wxTopLevelWindowGTK::Maximize(bool maximize)
1145 {
1146     if (maximize)
1147         gtk_window_maximize( GTK_WINDOW( m_widget ) );
1148     else
1149         gtk_window_unmaximize( GTK_WINDOW( m_widget ) );
1150 }
1151
1152 bool wxTopLevelWindowGTK::IsMaximized() const
1153 {
1154     if(!m_widget->window)
1155         return false;
1156
1157     return gdk_window_get_state(m_widget->window) & GDK_WINDOW_STATE_MAXIMIZED;
1158 }
1159
1160 void wxTopLevelWindowGTK::Restore()
1161 {
1162     // "Present" seems similar enough to "restore"
1163     gtk_window_present( GTK_WINDOW( m_widget ) );
1164 }
1165
1166 void wxTopLevelWindowGTK::Iconize( bool iconize )
1167 {
1168     if (iconize)
1169         gtk_window_iconify( GTK_WINDOW( m_widget ) );
1170     else
1171         gtk_window_deiconify( GTK_WINDOW( m_widget ) );
1172 }
1173
1174 bool wxTopLevelWindowGTK::IsIconized() const
1175 {
1176     return m_isIconized;
1177 }
1178
1179 void wxTopLevelWindowGTK::SetIconizeState(bool iconize)
1180 {
1181     if ( iconize != m_isIconized )
1182     {
1183         m_isIconized = iconize;
1184         (void)SendIconizeEvent(iconize);
1185     }
1186 }
1187
1188 void wxTopLevelWindowGTK::AddGrab()
1189 {
1190     if (!m_grabbed)
1191     {
1192         m_grabbed = true;
1193         gtk_grab_add( m_widget );
1194         wxEventLoop().Run();
1195         gtk_grab_remove( m_widget );
1196     }
1197 }
1198
1199 void wxTopLevelWindowGTK::RemoveGrab()
1200 {
1201     if (m_grabbed)
1202     {
1203         gtk_main_quit();
1204         m_grabbed = false;
1205     }
1206 }
1207
1208
1209 // helper
1210 static bool do_shape_combine_region(GdkWindow* window, const wxRegion& region)
1211 {
1212     if (window)
1213     {
1214         if (region.IsEmpty())
1215         {
1216             gdk_window_shape_combine_mask(window, NULL, 0, 0);
1217         }
1218         else
1219         {
1220             gdk_window_shape_combine_region(window, region.GetRegion(), 0, 0);
1221             return true;
1222         }
1223     }
1224     return false;
1225 }
1226
1227
1228 bool wxTopLevelWindowGTK::SetShape(const wxRegion& region)
1229 {
1230     wxCHECK_MSG( HasFlag(wxFRAME_SHAPED), false,
1231                  _T("Shaped windows must be created with the wxFRAME_SHAPED style."));
1232
1233     GdkWindow *window = NULL;
1234     if (m_wxwindow)
1235     {
1236         window = GTK_PIZZA(m_wxwindow)->bin_window;
1237         do_shape_combine_region(window, region);
1238     }
1239     window = m_widget->window;
1240     return do_shape_combine_region(window, region);
1241 }
1242
1243 bool wxTopLevelWindowGTK::IsActive()
1244 {
1245     return (this == (wxTopLevelWindowGTK*)g_activeFrame);
1246 }
1247
1248 void wxTopLevelWindowGTK::RequestUserAttention(int flags)
1249 {
1250     bool new_hint_value = false;
1251
1252     // FIXME: This is a workaround to focus handling problem
1253     // If RequestUserAttention is called for example right after a wxSleep, OnInternalIdle hasn't
1254     // yet been processed, and the internal focus system is not up to date yet.
1255     // wxYieldIfNeeded ensures the processing of it, but can have unwanted side effects - MR
1256     ::wxYieldIfNeeded();
1257
1258     if(m_urgency_hint >= 0)
1259         g_source_remove(m_urgency_hint);
1260
1261     m_urgency_hint = -2;
1262
1263     if( GTK_WIDGET_REALIZED(m_widget) && !IsActive() )
1264     {
1265         new_hint_value = true;
1266
1267         if (flags & wxUSER_ATTENTION_INFO)
1268         {
1269             m_urgency_hint = g_timeout_add(5000, (GSourceFunc)gtk_frame_urgency_timer_callback, this);
1270         } else {
1271             m_urgency_hint = -1;
1272         }
1273     }
1274
1275 #if GTK_CHECK_VERSION(2,7,0)
1276     if(!gtk_check_version(2,7,0))
1277         gtk_window_set_urgency_hint(GTK_WINDOW( m_widget ), new_hint_value);
1278     else
1279 #endif
1280         wxgtk_window_set_urgency_hint(GTK_WINDOW( m_widget ), new_hint_value);
1281 }
1282
1283 void wxTopLevelWindowGTK::SetWindowStyleFlag( long style )
1284 {
1285 #if defined(__WXGTK24__) || GTK_CHECK_VERSION(2,2,0)
1286     // Store which styles were changed
1287     long styleChanges = style ^ m_windowStyle;
1288 #endif
1289
1290     // Process wxWindow styles. This also updates the internal variable
1291     // Therefore m_windowStyle bits carry now the _new_ style values
1292     wxWindow::SetWindowStyleFlag(style);
1293
1294     // just return for now if widget does not exist yet
1295     if (!m_widget)
1296         return;
1297
1298 #ifdef __WXGTK24__
1299     if ( (styleChanges & wxSTAY_ON_TOP) && !gtk_check_version(2,4,0) )
1300         gtk_window_set_keep_above(GTK_WINDOW(m_widget), m_windowStyle & wxSTAY_ON_TOP);
1301 #endif // GTK+ 2.4
1302 #if GTK_CHECK_VERSION(2,2,0)
1303     if ( (styleChanges & wxFRAME_NO_TASKBAR) && !gtk_check_version(2,2,0) )
1304     {
1305         gtk_window_set_skip_taskbar_hint(GTK_WINDOW(m_widget), m_windowStyle & wxFRAME_NO_TASKBAR);
1306     }
1307 #endif // GTK+ 2.2
1308 }
1309
1310 #include <X11/Xlib.h>
1311
1312 /* Get the X Window between child and the root window.
1313    This should usually be the WM managed XID */
1314 static Window wxGetTopmostWindowX11(Display *dpy, Window child)
1315 {
1316     Window root, parent;
1317     Window* children;
1318     unsigned int nchildren;
1319
1320     XQueryTree(dpy, child, &root, &parent, &children, &nchildren);
1321     XFree(children);
1322
1323     while (parent != root) {
1324         child = parent;
1325         XQueryTree(dpy, child, &root, &parent, &children, &nchildren);
1326         XFree(children);
1327     }
1328
1329     return child;
1330 }
1331
1332 bool wxTopLevelWindowGTK::SetTransparent(wxByte alpha)
1333 {
1334     if (!m_widget || !m_widget->window)
1335         return false;
1336
1337     Display* dpy = GDK_WINDOW_XDISPLAY (m_widget->window);
1338     // We need to get the X Window that has the root window as the immediate parent
1339     // and m_widget->window as a child. This should be the X Window that the WM manages and
1340     // from which the opacity property is checked from.
1341     Window win = wxGetTopmostWindowX11(dpy, GDK_WINDOW_XID (m_widget->window));
1342
1343     unsigned int opacity = alpha * 0x1010101;
1344
1345     // Using pure Xlib to not have a GTK version check mess due to gtk2.0 not having GdkDisplay
1346     if (alpha == 0xff)
1347         XDeleteProperty(dpy, win, XInternAtom(dpy, "_NET_WM_WINDOW_OPACITY", False));
1348     else
1349         XChangeProperty(dpy, win, XInternAtom(dpy, "_NET_WM_WINDOW_OPACITY", False),
1350                         XA_CARDINAL, 32, PropModeReplace,
1351                         (unsigned char *) &opacity, 1L);
1352     XSync(dpy, False);
1353     return true;
1354 }
1355
1356 bool wxTopLevelWindowGTK::CanSetTransparent()
1357 {
1358 #if GTK_CHECK_VERSION(2,10,0)
1359     if (!gtk_check_version(2,10,0))
1360     {
1361         if (gtk_widget_is_composited (m_widget))
1362             return true;
1363     }
1364     else
1365 #endif // In case of lower versions than gtk+-2.10.0 we could look for _NET_WM_CM_Sn ourselves
1366     {
1367         return false;
1368     }
1369
1370 #if 0 // Don't be optimistic here for the sake of wxAUI
1371     int opcode, event, error;
1372     // Check for the existence of a RGBA visual instead?
1373     return XQueryExtension(gdk_x11_get_default_xdisplay (),
1374                            "Composite", &opcode, &event, &error);
1375 #endif
1376 }