src/gtk/toplevel.cpp

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