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