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)
 804     {
 805         // make sure window has a non-default position, so when it is shown
 806         // again, it won't be repositioned by WM as if it were a new window
 807         gtk_window_move((GtkWindow*)m_widget, m_x, m_y);
 808     }
 809     else if (!m_sizeSet)
 810     {
 811         /* by calling GtkOnSize here, we don't have to call
 812            either after showing the frame, which would entail
 813            much ugly flicker or from within the size_allocate
 814            handler, because GTK 1.1.X forbids that. */
 815
 816         GtkOnSize();
 817     }
 818
 819     return wxTopLevelWindowBase::Show(show);
 820 }
 821
 822 void wxTopLevelWindowGTK::Raise()
 823 {
 824     gtk_window_present( GTK_WINDOW( m_widget ) );
 825 }
 826
 827 void wxTopLevelWindowGTK::DoMoveWindow(int WXUNUSED(x), int WXUNUSED(y), int WXUNUSED(width), int WXUNUSED(height) )
 828 {
 829     wxFAIL_MSG( wxT("DoMoveWindow called for wxTopLevelWindowGTK") );
 830 }
 831
 832 // ----------------------------------------------------------------------------
 833 // window geometry
 834 // ----------------------------------------------------------------------------
 835
 836 void wxTopLevelWindowGTK::GTKDoGetSize(int *width, int *height) const
 837 {
 838     return wxTopLevelWindowBase::DoGetSize(width, height);
 839 }
 840
 841 void wxTopLevelWindowGTK::GTKDoSetSize(int width, int height)
 842 {
 843     // avoid recursions
 844     if (m_resizing)
 845         return;
 846     m_resizing = true;
 847
 848     int old_width = m_width;
 849     int old_height = m_height;
 850
 851     if ( width != -1 )
 852         m_width = width;
 853     if ( height != -1 )
 854         m_height = height;
 855
 856     // GPE's window manager doesn't like size hints at all, esp. when the user
 857     // has to use the virtual keyboard, so don't constrain size there
 858 #ifndef __WXGPE__
 859     int minWidth = GetMinWidth(),
 860         minHeight = GetMinHeight(),
 861         maxWidth = GetMaxWidth(),
 862         maxHeight = GetMaxHeight();
 863
 864     if ( minWidth != -1 && m_width < minWidth )
 865         m_width = minWidth;
 866     if ( minHeight != -1 && m_height < minHeight )
 867         m_height = minHeight;
 868     if ( maxWidth != -1 && m_width > maxWidth )
 869         m_width = maxWidth;
 870     if ( maxHeight != -1 && m_height > maxHeight )
 871         m_height = maxHeight;
 872 #endif // __WXGPE__
 873
 874     if ( m_width != old_width || m_height != old_height )
 875     {
 876         gtk_window_resize( GTK_WINDOW(m_widget), m_width, m_height );
 877
 878         /* we set the size in GtkOnSize, i.e. mostly the actual resizing is
 879            done either directly before the frame is shown or in idle time
 880            so that different calls to SetSize() don't lead to flicker. */
 881         m_sizeSet = false;
 882     }
 883
 884     m_resizing = false;
 885 }
 886
 887 void wxTopLevelWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags )
 888 {
 889     wxCHECK_RET( m_widget, wxT("invalid frame") );
 890
 891     // this shouldn't happen: wxFrame, wxMDIParentFrame and wxMDIChildFrame have m_wxwindow
 892     wxASSERT_MSG( (m_wxwindow != NULL), wxT("invalid frame") );
 893
 894
 895     // deal with the position first
 896     int old_x = m_x;
 897     int old_y = m_y;
 898
 899     if ( !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE) )
 900     {
 901         // -1 means "use existing" unless the flag above is specified
 902         if ( x != -1 )
 903             m_x = x;
 904         if ( y != -1 )
 905             m_y = y;
 906     }
 907     else // wxSIZE_ALLOW_MINUS_ONE
 908     {
 909         m_x = x;
 910         m_y = y;
 911     }
 912
 913     if ( m_x != old_x || m_y != old_y )
 914     {
 915         gtk_window_move( GTK_WINDOW(m_widget), m_x, m_y );
 916     }
 917
 918
 919     // and now change the size: as we want to set the size of the entire
 920     // window, including decorations, we must adjust the size passed to
 921     // GTKDoSetSize() which takes with the size of undecorated frame only
 922     if ( width != -1 || height != -1 )
 923     {
 924         int wTotal,
 925             hTotal;
 926         DoGetSize(&wTotal, &hTotal);
 927
 928         int wUndec,
 929             hUndec;
 930         GTKDoGetSize(&wUndec, &hUndec);
 931
 932         if ( width != -1 )
 933             width -= wTotal - wUndec;
 934         if ( height != -1 )
 935             height -= hTotal - hUndec;
 936     }
 937
 938     GTKDoSetSize(width, height);
 939 }
 940
 941 void wxTopLevelWindowGTK::DoGetSize(int *width, int *height) const
 942 {
 943     wxCHECK_RET( m_widget, wxT("invalid frame") );
 944
 945     if ( !m_widget->window )
 946     {
 947         // this can happen if we're called before the window is realized, so
 948         // don't assert but just return the stored values
 949         GTKDoGetSize(width, height);
 950         return;
 951     }
 952
 953     GdkRectangle rect;
 954     gdk_window_get_frame_extents(m_widget->window, &rect);
 955
 956     if ( width )
 957         *width = rect.width;
 958     if ( height )
 959         *height = rect.height;
 960 }
 961
 962 void wxTopLevelWindowGTK::DoGetClientSize( int *width, int *height ) const
 963 {
 964     if ( IsIconized() )
 965     {
 966         // for consistency with wxMSW, client area is supposed to be empty for
 967         // the iconized windows
 968         if ( width )
 969             *width = 0;
 970         if ( height )
 971             *height = 0;
 972
 973         return;
 974     }
 975
 976     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 977
 978     if (height)
 979     {
 980         *height = m_height - 2 * m_miniEdge - m_miniTitle;
 981         if (*height < 0)
 982             *height = 0;
 983     }
 984     if (width)
 985     {
 986         *width = m_width - 2 * m_miniEdge;
 987         if (*width < 0)
 988             *width = 0;
 989     }
 990 }
 991
 992 void wxTopLevelWindowGTK::DoSetClientSize( int width, int height )
 993 {
 994     GTKDoSetSize(width + m_miniEdge*2, height  + m_miniEdge*2 + m_miniTitle);
 995 }
 996
 997 void wxTopLevelWindowGTK::DoSetSizeHints( int minW, int minH,
 998                                           int maxW, int maxH,
 999                                           int incW, int incH )
1000 {
1001     wxTopLevelWindowBase::DoSetSizeHints( minW, minH, maxW, maxH, incW, incH );
1002
1003     const wxSize minSize = GetMinSize();
1004     const wxSize maxSize = GetMaxSize();
1005     GdkGeometry hints;
1006     int hints_mask = 0;
1007     if (minSize.x > 0 || minSize.y > 0)
1008     {
1009         hints_mask |= GDK_HINT_MIN_SIZE;
1010         hints.min_width  = minSize.x > 0 ? minSize.x : 0;
1011         hints.min_height = minSize.y > 0 ? minSize.y : 0;
1012     }
1013     if (maxSize.x > 0 || maxSize.y > 0)
1014     {
1015         hints_mask |= GDK_HINT_MAX_SIZE;
1016         hints.max_width  = maxSize.x > 0 ? maxSize.x : INT_MAX;
1017         hints.max_height = maxSize.y > 0 ? maxSize.y : INT_MAX;
1018     }
1019     if (incW > 0 || incH > 0)
1020     {
1021         hints_mask |= GDK_HINT_RESIZE_INC;
1022         hints.width_inc  = incW > 0 ? incW : 1;
1023         hints.height_inc = incH > 0 ? incH : 1;
1024     }
1025     gtk_window_set_geometry_hints(
1026         (GtkWindow*)m_widget, NULL, &hints, (GdkWindowHints)hints_mask);
1027 }
1028
1029
1030 void wxTopLevelWindowGTK::GtkOnSize()
1031 {
1032     // avoid recursions
1033     if (m_resizing) return;
1034     m_resizing = true;
1035
1036     if ( m_wxwindow == NULL ) return;
1037
1038     /* wxMDIChildFrame derives from wxFrame but it _is_ a wxWindow as it uses
1039        wxWindow::Create to create it's GTK equivalent. m_mainWidget is only
1040        set in wxFrame::Create so it is used to check what kind of frame we
1041        have here. if m_mainWidget is NULL it is a wxMDIChildFrame and so we
1042        skip the part which handles m_frameMenuBar, m_frameToolBar and (most
1043        importantly) m_mainWidget */
1044
1045     int minWidth = GetMinWidth(),
1046         minHeight = GetMinHeight(),
1047         maxWidth = GetMaxWidth(),
1048         maxHeight = GetMaxHeight();
1049
1050 #ifdef __WXGPE__
1051     // GPE's window manager doesn't like size hints
1052     // at all, esp. when the user has to use the
1053     // virtual keyboard.
1054     minWidth = -1;
1055     minHeight = -1;
1056     maxWidth = -1;
1057     maxHeight = -1;
1058 #endif
1059
1060     if ((minWidth != -1) && (m_width < minWidth)) m_width = minWidth;
1061     if ((minHeight != -1) && (m_height < minHeight)) m_height = minHeight;
1062     if ((maxWidth != -1) && (m_width > maxWidth)) m_width = maxWidth;
1063     if ((maxHeight != -1) && (m_height > maxHeight)) m_height = maxHeight;
1064
1065     if (m_mainWidget)
1066     {
1067         // m_mainWidget holds the menubar, the toolbar and the client area,
1068         // which is represented by m_wxwindow.
1069         int client_x = m_miniEdge;
1070         int client_y = m_miniEdge + m_miniTitle;
1071         int client_w = m_width - 2*m_miniEdge;
1072         int client_h = m_height - 2*m_miniEdge - m_miniTitle;
1073         if (client_w < 0)
1074             client_w = 0;
1075         if (client_h < 0)
1076             client_h = 0;
1077
1078         // Let the parent perform the resize
1079         gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
1080                               m_wxwindow,
1081                               client_x, client_y, client_w, client_h );
1082     }
1083     else
1084     {
1085         // If there is no m_mainWidget between m_widget and m_wxwindow there
1086         // is no need to set the size or position of m_wxwindow.
1087     }
1088
1089     m_sizeSet = true;
1090
1091     // send size event to frame
1092     wxSizeEvent event( wxSize(m_width,m_height), GetId() );
1093     event.SetEventObject( this );
1094     GetEventHandler()->ProcessEvent( event );
1095
1096     m_resizing = false;
1097 }
1098
1099 void wxTopLevelWindowGTK::OnInternalIdle()
1100 {
1101     if (!m_sizeSet && GTK_WIDGET_REALIZED(m_wxwindow))
1102     {
1103         GtkOnSize();
1104
1105         // we'll come back later
1106         return;
1107     }
1108
1109     // set the focus if not done yet and if we can already do it
1110     if ( GTK_WIDGET_REALIZED(m_wxwindow) )
1111     {
1112         if ( g_delayedFocus &&
1113              wxGetTopLevelParent((wxWindow*)g_delayedFocus) == this )
1114         {
1115             wxLogTrace(_T("focus"),
1116                        _T("Setting focus from wxTLW::OnIdle() to %s(%s)"),
1117                        g_delayedFocus->GetClassInfo()->GetClassName(),
1118                        g_delayedFocus->GetLabel().c_str());
1119
1120             g_delayedFocus->SetFocus();
1121             g_delayedFocus = NULL;
1122         }
1123     }
1124
1125     wxWindow::OnInternalIdle();
1126
1127     // Synthetize activate events.
1128     if ( g_sendActivateEvent != -1 )
1129     {
1130         bool activate = g_sendActivateEvent != 0;
1131
1132         // if (!activate) wxPrintf( wxT("de") );
1133         // wxPrintf( wxT("activate\n") );
1134
1135         // do it only once
1136         g_sendActivateEvent = -1;
1137
1138         wxTheApp->SetActive(activate, (wxWindow *)g_lastActiveFrame);
1139     }
1140 }
1141
1142 // ----------------------------------------------------------------------------
1143 // frame title/icon
1144 // ----------------------------------------------------------------------------
1145
1146 void wxTopLevelWindowGTK::SetTitle( const wxString &title )
1147 {
1148     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
1149
1150     if ( title == m_title )
1151         return;
1152
1153     m_title = title;
1154
1155     gtk_window_set_title( GTK_WINDOW(m_widget), wxGTK_CONV( title ) );
1156 }
1157
1158 void wxTopLevelWindowGTK::SetIcons( const wxIconBundle &icons )
1159 {
1160     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
1161
1162     wxTopLevelWindowBase::SetIcons( icons );
1163
1164     GList *list = NULL;
1165
1166     const size_t numIcons = icons.GetIconCount();
1167     for ( size_t i = 0; i < numIcons; i++ )
1168     {
1169         list = g_list_prepend(list, icons.GetIconByIndex(i).GetPixbuf());
1170     }
1171
1172     gtk_window_set_icon_list(GTK_WINDOW(m_widget), list);
1173     g_list_free(list);
1174 }
1175
1176 // ----------------------------------------------------------------------------
1177 // frame state: maximized/iconized/normal
1178 // ----------------------------------------------------------------------------
1179
1180 void wxTopLevelWindowGTK::Maximize(bool maximize)
1181 {
1182     if (maximize)
1183         gtk_window_maximize( GTK_WINDOW( m_widget ) );
1184     else
1185         gtk_window_unmaximize( GTK_WINDOW( m_widget ) );
1186 }
1187
1188 bool wxTopLevelWindowGTK::IsMaximized() const
1189 {
1190     if(!m_widget->window)
1191         return false;
1192
1193     return gdk_window_get_state(m_widget->window) & GDK_WINDOW_STATE_MAXIMIZED;
1194 }
1195
1196 void wxTopLevelWindowGTK::Restore()
1197 {
1198     // "Present" seems similar enough to "restore"
1199     gtk_window_present( GTK_WINDOW( m_widget ) );
1200 }
1201
1202 void wxTopLevelWindowGTK::Iconize( bool iconize )
1203 {
1204     if (iconize)
1205         gtk_window_iconify( GTK_WINDOW( m_widget ) );
1206     else
1207         gtk_window_deiconify( GTK_WINDOW( m_widget ) );
1208 }
1209
1210 bool wxTopLevelWindowGTK::IsIconized() const
1211 {
1212     return m_isIconized;
1213 }
1214
1215 void wxTopLevelWindowGTK::SetIconizeState(bool iconize)
1216 {
1217     if ( iconize != m_isIconized )
1218     {
1219         m_isIconized = iconize;
1220         (void)SendIconizeEvent(iconize);
1221     }
1222 }
1223
1224 void wxTopLevelWindowGTK::AddGrab()
1225 {
1226     if (!m_grabbed)
1227     {
1228         m_grabbed = true;
1229         gtk_grab_add( m_widget );
1230         wxEventLoop().Run();
1231         gtk_grab_remove( m_widget );
1232     }
1233 }
1234
1235 void wxTopLevelWindowGTK::RemoveGrab()
1236 {
1237     if (m_grabbed)
1238     {
1239         gtk_main_quit();
1240         m_grabbed = false;
1241     }
1242 }
1243
1244
1245 // helper
1246 static bool do_shape_combine_region(GdkWindow* window, const wxRegion& region)
1247 {
1248     if (window)
1249     {
1250         if (region.IsEmpty())
1251         {
1252             gdk_window_shape_combine_mask(window, NULL, 0, 0);
1253         }
1254         else
1255         {
1256             gdk_window_shape_combine_region(window, region.GetRegion(), 0, 0);
1257             return true;
1258         }
1259     }
1260     return false;
1261 }
1262
1263
1264 bool wxTopLevelWindowGTK::SetShape(const wxRegion& region)
1265 {
1266     wxCHECK_MSG( HasFlag(wxFRAME_SHAPED), false,
1267                  _T("Shaped windows must be created with the wxFRAME_SHAPED style."));
1268
1269     GdkWindow *window = NULL;
1270     if (m_wxwindow)
1271     {
1272         window = GTK_PIZZA(m_wxwindow)->bin_window;
1273         do_shape_combine_region(window, region);
1274     }
1275     window = m_widget->window;
1276     return do_shape_combine_region(window, region);
1277 }
1278
1279 bool wxTopLevelWindowGTK::IsActive()
1280 {
1281     return (this == (wxTopLevelWindowGTK*)g_activeFrame);
1282 }
1283
1284 void wxTopLevelWindowGTK::RequestUserAttention(int flags)
1285 {
1286     bool new_hint_value = false;
1287
1288     // FIXME: This is a workaround to focus handling problem
1289     // If RequestUserAttention is called for example right after a wxSleep, OnInternalIdle hasn't
1290     // yet been processed, and the internal focus system is not up to date yet.
1291     // wxYieldIfNeeded ensures the processing of it, but can have unwanted side effects - MR
1292     ::wxYieldIfNeeded();
1293
1294     if(m_urgency_hint >= 0)
1295         g_source_remove(m_urgency_hint);
1296
1297     m_urgency_hint = -2;
1298
1299     if( GTK_WIDGET_REALIZED(m_widget) && !IsActive() )
1300     {
1301         new_hint_value = true;
1302
1303         if (flags & wxUSER_ATTENTION_INFO)
1304         {
1305             m_urgency_hint = g_timeout_add(5000, (GSourceFunc)gtk_frame_urgency_timer_callback, this);
1306         } else {
1307             m_urgency_hint = -1;
1308         }
1309     }
1310
1311 #if GTK_CHECK_VERSION(2,7,0)
1312     if(!gtk_check_version(2,7,0))
1313         gtk_window_set_urgency_hint(GTK_WINDOW( m_widget ), new_hint_value);
1314     else
1315 #endif
1316         wxgtk_window_set_urgency_hint(GTK_WINDOW( m_widget ), new_hint_value);
1317 }
1318
1319 void wxTopLevelWindowGTK::SetWindowStyleFlag( long style )
1320 {
1321 #if defined(__WXGTK24__) || GTK_CHECK_VERSION(2,2,0)
1322     // Store which styles were changed
1323     long styleChanges = style ^ m_windowStyle;
1324 #endif
1325
1326     // Process wxWindow styles. This also updates the internal variable
1327     // Therefore m_windowStyle bits carry now the _new_ style values
1328     wxWindow::SetWindowStyleFlag(style);
1329
1330     // just return for now if widget does not exist yet
1331     if (!m_widget)
1332         return;
1333
1334 #ifdef __WXGTK24__
1335     if ( (styleChanges & wxSTAY_ON_TOP) && !gtk_check_version(2,4,0) )
1336         gtk_window_set_keep_above(GTK_WINDOW(m_widget), m_windowStyle & wxSTAY_ON_TOP);
1337 #endif // GTK+ 2.4
1338 #if GTK_CHECK_VERSION(2,2,0)
1339     if ( (styleChanges & wxFRAME_NO_TASKBAR) && !gtk_check_version(2,2,0) )
1340     {
1341         gtk_window_set_skip_taskbar_hint(GTK_WINDOW(m_widget), m_windowStyle & wxFRAME_NO_TASKBAR);
1342     }
1343 #endif // GTK+ 2.2
1344 }
1345
1346 #include <X11/Xlib.h>
1347
1348 /* Get the X Window between child and the root window.
1349    This should usually be the WM managed XID */
1350 static Window wxGetTopmostWindowX11(Display *dpy, Window child)
1351 {
1352     Window root, parent;
1353     Window* children;
1354     unsigned int nchildren;
1355
1356     XQueryTree(dpy, child, &root, &parent, &children, &nchildren);
1357     XFree(children);
1358
1359     while (parent != root) {
1360         child = parent;
1361         XQueryTree(dpy, child, &root, &parent, &children, &nchildren);
1362         XFree(children);
1363     }
1364
1365     return child;
1366 }
1367
1368 bool wxTopLevelWindowGTK::SetTransparent(wxByte alpha)
1369 {
1370     if (!m_widget || !m_widget->window)
1371         return false;
1372
1373     Display* dpy = GDK_WINDOW_XDISPLAY (m_widget->window);
1374     // We need to get the X Window that has the root window as the immediate parent
1375     // and m_widget->window as a child. This should be the X Window that the WM manages and
1376     // from which the opacity property is checked from.
1377     Window win = wxGetTopmostWindowX11(dpy, GDK_WINDOW_XID (m_widget->window));
1378
1379     unsigned int opacity = alpha * 0x1010101;
1380
1381     // Using pure Xlib to not have a GTK version check mess due to gtk2.0 not having GdkDisplay
1382     if (alpha == 0xff)
1383         XDeleteProperty(dpy, win, XInternAtom(dpy, "_NET_WM_WINDOW_OPACITY", False));
1384     else
1385         XChangeProperty(dpy, win, XInternAtom(dpy, "_NET_WM_WINDOW_OPACITY", False),
1386                         XA_CARDINAL, 32, PropModeReplace,
1387                         (unsigned char *) &opacity, 1L);
1388     XSync(dpy, False);
1389     return true;
1390 }
1391
1392 bool wxTopLevelWindowGTK::CanSetTransparent()
1393 {
1394     // allow to override automatic detection as it's far from perfect
1395     static const wxChar *SYSOPT_TRANSPARENT = wxT("gtk.tlw.can-set-transparent");
1396     if ( wxSystemOptions::HasOption(SYSOPT_TRANSPARENT) )
1397     {
1398         return wxSystemOptions::GetOptionInt(SYSOPT_TRANSPARENT) != 0;
1399     }
1400
1401 #if GTK_CHECK_VERSION(2,10,0)
1402     if (!gtk_check_version(2,10,0))
1403     {
1404         return (gtk_widget_is_composited (m_widget));
1405     }
1406     else
1407 #endif // In case of lower versions than gtk+-2.10.0 we could look for _NET_WM_CM_Sn ourselves
1408     {
1409         return false;
1410     }
1411
1412 #if 0 // Don't be optimistic here for the sake of wxAUI
1413     int opcode, event, error;
1414     // Check for the existence of a RGBA visual instead?
1415     return XQueryExtension(gdk_x11_get_default_xdisplay (),
1416                            "Composite", &opcode, &event, &error);
1417 #endif
1418 }