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