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