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     ConstrainSize();
1027
1028     if (m_mainWidget)
1029     {
1030         gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
1031                               m_wxwindow,
1032                               0, 0, m_width, m_height);
1033     }
1034
1035     m_sizeSet = true;
1036
1037     // send size event to frame
1038     wxSizeEvent event( wxSize(m_width,m_height), GetId() );
1039     event.SetEventObject( this );
1040     GetEventHandler()->ProcessEvent( event );
1041
1042     m_resizing = false;
1043 }
1044
1045 void wxTopLevelWindowGTK::OnInternalIdle()
1046 {
1047     if (!m_sizeSet && GTK_WIDGET_REALIZED(m_wxwindow))
1048     {
1049         GtkOnSize();
1050
1051         // we'll come back later
1052         return;
1053     }
1054
1055     // set the focus if not done yet and if we can already do it
1056     if ( GTK_WIDGET_REALIZED(m_wxwindow) )
1057     {
1058         if ( g_delayedFocus &&
1059              wxGetTopLevelParent((wxWindow*)g_delayedFocus) == this )
1060         {
1061             wxLogTrace(_T("focus"),
1062                        _T("Setting focus from wxTLW::OnIdle() to %s(%s)"),
1063                        g_delayedFocus->GetClassInfo()->GetClassName(),
1064                        g_delayedFocus->GetLabel().c_str());
1065
1066             g_delayedFocus->SetFocus();
1067             g_delayedFocus = NULL;
1068         }
1069     }
1070
1071     wxWindow::OnInternalIdle();
1072
1073     // Synthetize activate events.
1074     if ( g_sendActivateEvent != -1 )
1075     {
1076         bool activate = g_sendActivateEvent != 0;
1077
1078         // if (!activate) wxPrintf( wxT("de") );
1079         // wxPrintf( wxT("activate\n") );
1080
1081         // do it only once
1082         g_sendActivateEvent = -1;
1083
1084         wxTheApp->SetActive(activate, (wxWindow *)g_lastActiveFrame);
1085     }
1086 }
1087
1088 // ----------------------------------------------------------------------------
1089 // frame title/icon
1090 // ----------------------------------------------------------------------------
1091
1092 void wxTopLevelWindowGTK::SetTitle( const wxString &title )
1093 {
1094     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
1095
1096     if ( title == m_title )
1097         return;
1098
1099     m_title = title;
1100
1101     gtk_window_set_title( GTK_WINDOW(m_widget), wxGTK_CONV( title ) );
1102 }
1103
1104 void wxTopLevelWindowGTK::SetIcons( const wxIconBundle &icons )
1105 {
1106     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
1107
1108     wxTopLevelWindowBase::SetIcons( icons );
1109
1110     GList *list = NULL;
1111
1112     const size_t numIcons = icons.GetIconCount();
1113     for ( size_t i = 0; i < numIcons; i++ )
1114     {
1115         list = g_list_prepend(list, icons.GetIconByIndex(i).GetPixbuf());
1116     }
1117
1118     gtk_window_set_icon_list(GTK_WINDOW(m_widget), list);
1119     g_list_free(list);
1120 }
1121
1122 // ----------------------------------------------------------------------------
1123 // frame state: maximized/iconized/normal
1124 // ----------------------------------------------------------------------------
1125
1126 void wxTopLevelWindowGTK::Maximize(bool maximize)
1127 {
1128     if (maximize)
1129         gtk_window_maximize( GTK_WINDOW( m_widget ) );
1130     else
1131         gtk_window_unmaximize( GTK_WINDOW( m_widget ) );
1132 }
1133
1134 bool wxTopLevelWindowGTK::IsMaximized() const
1135 {
1136     if(!m_widget->window)
1137         return false;
1138
1139     return gdk_window_get_state(m_widget->window) & GDK_WINDOW_STATE_MAXIMIZED;
1140 }
1141
1142 void wxTopLevelWindowGTK::Restore()
1143 {
1144     // "Present" seems similar enough to "restore"
1145     gtk_window_present( GTK_WINDOW( m_widget ) );
1146 }
1147
1148 void wxTopLevelWindowGTK::Iconize( bool iconize )
1149 {
1150     if (iconize)
1151         gtk_window_iconify( GTK_WINDOW( m_widget ) );
1152     else
1153         gtk_window_deiconify( GTK_WINDOW( m_widget ) );
1154 }
1155
1156 bool wxTopLevelWindowGTK::IsIconized() const
1157 {
1158     return m_isIconized;
1159 }
1160
1161 void wxTopLevelWindowGTK::SetIconizeState(bool iconize)
1162 {
1163     if ( iconize != m_isIconized )
1164     {
1165         m_isIconized = iconize;
1166         (void)SendIconizeEvent(iconize);
1167     }
1168 }
1169
1170 void wxTopLevelWindowGTK::AddGrab()
1171 {
1172     if (!m_grabbed)
1173     {
1174         m_grabbed = true;
1175         gtk_grab_add( m_widget );
1176         wxEventLoop().Run();
1177         gtk_grab_remove( m_widget );
1178     }
1179 }
1180
1181 void wxTopLevelWindowGTK::RemoveGrab()
1182 {
1183     if (m_grabbed)
1184     {
1185         gtk_main_quit();
1186         m_grabbed = false;
1187     }
1188 }
1189
1190
1191 // helper
1192 static bool do_shape_combine_region(GdkWindow* window, const wxRegion& region)
1193 {
1194     if (window)
1195     {
1196         if (region.IsEmpty())
1197         {
1198             gdk_window_shape_combine_mask(window, NULL, 0, 0);
1199         }
1200         else
1201         {
1202             gdk_window_shape_combine_region(window, region.GetRegion(), 0, 0);
1203             return true;
1204         }
1205     }
1206     return false;
1207 }
1208
1209
1210 bool wxTopLevelWindowGTK::SetShape(const wxRegion& region)
1211 {
1212     wxCHECK_MSG( HasFlag(wxFRAME_SHAPED), false,
1213                  _T("Shaped windows must be created with the wxFRAME_SHAPED style."));
1214
1215     GdkWindow *window = NULL;
1216     if (m_wxwindow)
1217     {
1218         window = GTK_PIZZA(m_wxwindow)->bin_window;
1219         do_shape_combine_region(window, region);
1220     }
1221     window = m_widget->window;
1222     return do_shape_combine_region(window, region);
1223 }
1224
1225 bool wxTopLevelWindowGTK::IsActive()
1226 {
1227     return (this == (wxTopLevelWindowGTK*)g_activeFrame);
1228 }
1229
1230 void wxTopLevelWindowGTK::RequestUserAttention(int flags)
1231 {
1232     bool new_hint_value = false;
1233
1234     // FIXME: This is a workaround to focus handling problem
1235     // If RequestUserAttention is called for example right after a wxSleep, OnInternalIdle hasn't
1236     // yet been processed, and the internal focus system is not up to date yet.
1237     // wxYieldIfNeeded ensures the processing of it, but can have unwanted side effects - MR
1238     ::wxYieldIfNeeded();
1239
1240     if(m_urgency_hint >= 0)
1241         g_source_remove(m_urgency_hint);
1242
1243     m_urgency_hint = -2;
1244
1245     if( GTK_WIDGET_REALIZED(m_widget) && !IsActive() )
1246     {
1247         new_hint_value = true;
1248
1249         if (flags & wxUSER_ATTENTION_INFO)
1250         {
1251             m_urgency_hint = g_timeout_add(5000, (GSourceFunc)gtk_frame_urgency_timer_callback, this);
1252         } else {
1253             m_urgency_hint = -1;
1254         }
1255     }
1256
1257 #if GTK_CHECK_VERSION(2,7,0)
1258     if(!gtk_check_version(2,7,0))
1259         gtk_window_set_urgency_hint(GTK_WINDOW( m_widget ), new_hint_value);
1260     else
1261 #endif
1262         wxgtk_window_set_urgency_hint(GTK_WINDOW( m_widget ), new_hint_value);
1263 }
1264
1265 void wxTopLevelWindowGTK::SetWindowStyleFlag( long style )
1266 {
1267 #if defined(__WXGTK24__) || GTK_CHECK_VERSION(2,2,0)
1268     // Store which styles were changed
1269     long styleChanges = style ^ m_windowStyle;
1270 #endif
1271
1272     // Process wxWindow styles. This also updates the internal variable
1273     // Therefore m_windowStyle bits carry now the _new_ style values
1274     wxWindow::SetWindowStyleFlag(style);
1275
1276     // just return for now if widget does not exist yet
1277     if (!m_widget)
1278         return;
1279
1280 #ifdef __WXGTK24__
1281     if ( (styleChanges & wxSTAY_ON_TOP) && !gtk_check_version(2,4,0) )
1282         gtk_window_set_keep_above(GTK_WINDOW(m_widget), m_windowStyle & wxSTAY_ON_TOP);
1283 #endif // GTK+ 2.4
1284 #if GTK_CHECK_VERSION(2,2,0)
1285     if ( (styleChanges & wxFRAME_NO_TASKBAR) && !gtk_check_version(2,2,0) )
1286     {
1287         gtk_window_set_skip_taskbar_hint(GTK_WINDOW(m_widget), m_windowStyle & wxFRAME_NO_TASKBAR);
1288     }
1289 #endif // GTK+ 2.2
1290 }
1291
1292 #include <X11/Xlib.h>
1293
1294 /* Get the X Window between child and the root window.
1295    This should usually be the WM managed XID */
1296 static Window wxGetTopmostWindowX11(Display *dpy, Window child)
1297 {
1298     Window root, parent;
1299     Window* children;
1300     unsigned int nchildren;
1301
1302     XQueryTree(dpy, child, &root, &parent, &children, &nchildren);
1303     XFree(children);
1304
1305     while (parent != root) {
1306         child = parent;
1307         XQueryTree(dpy, child, &root, &parent, &children, &nchildren);
1308         XFree(children);
1309     }
1310
1311     return child;
1312 }
1313
1314 bool wxTopLevelWindowGTK::SetTransparent(wxByte alpha)
1315 {
1316     if (!m_widget || !m_widget->window)
1317         return false;
1318
1319     Display* dpy = GDK_WINDOW_XDISPLAY (m_widget->window);
1320     // We need to get the X Window that has the root window as the immediate parent
1321     // and m_widget->window as a child. This should be the X Window that the WM manages and
1322     // from which the opacity property is checked from.
1323     Window win = wxGetTopmostWindowX11(dpy, GDK_WINDOW_XID (m_widget->window));
1324
1325     unsigned int opacity = alpha * 0x1010101;
1326
1327     // Using pure Xlib to not have a GTK version check mess due to gtk2.0 not having GdkDisplay
1328     if (alpha == 0xff)
1329         XDeleteProperty(dpy, win, XInternAtom(dpy, "_NET_WM_WINDOW_OPACITY", False));
1330     else
1331         XChangeProperty(dpy, win, XInternAtom(dpy, "_NET_WM_WINDOW_OPACITY", False),
1332                         XA_CARDINAL, 32, PropModeReplace,
1333                         (unsigned char *) &opacity, 1L);
1334     XSync(dpy, False);
1335     return true;
1336 }
1337
1338 bool wxTopLevelWindowGTK::CanSetTransparent()
1339 {
1340     // allow to override automatic detection as it's far from perfect
1341     static const wxChar *SYSOPT_TRANSPARENT = wxT("gtk.tlw.can-set-transparent");
1342     if ( wxSystemOptions::HasOption(SYSOPT_TRANSPARENT) )
1343     {
1344         return wxSystemOptions::GetOptionInt(SYSOPT_TRANSPARENT) != 0;
1345     }
1346
1347 #if GTK_CHECK_VERSION(2,10,0)
1348     if (!gtk_check_version(2,10,0))
1349     {
1350         return (gtk_widget_is_composited (m_widget));
1351     }
1352     else
1353 #endif // In case of lower versions than gtk+-2.10.0 we could look for _NET_WM_CM_Sn ourselves
1354     {
1355         return false;
1356     }
1357
1358 #if 0 // Don't be optimistic here for the sake of wxAUI
1359     int opcode, event, error;
1360     // Check for the existence of a RGBA visual instead?
1361     return XQueryExtension(gdk_x11_get_default_xdisplay (),
1362                            "Composite", &opcode, &event, &error);
1363 #endif
1364 }