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();
 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     if (height)
 917     {
 918         *height = m_height - 2 * m_miniEdge + m_miniTitle;
 919         if (*height < 0)
 920             *height = 0;
 921     }
 922     if (width)
 923     {
 924         *width = m_width - 2 * m_miniEdge;
 925         if (*width < 0)
 926             *width = 0;
 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()
 939 {
 940     // avoid recursions
 941     if (m_resizing) return;
 942     m_resizing = true;
 943
 944     if ( m_wxwindow == NULL ) return;
 945
 946     /* wxMDIChildFrame derives from wxFrame but it _is_ a wxWindow as it uses
 947        wxWindow::Create to create it's GTK equivalent. m_mainWidget is only
 948        set in wxFrame::Create so it is used to check what kind of frame we
 949        have here. if m_mainWidget is NULL it is a wxMDIChildFrame and so we
 950        skip the part which handles m_frameMenuBar, m_frameToolBar and (most
 951        importantly) m_mainWidget */
 952
 953     int minWidth = GetMinWidth(),
 954         minHeight = GetMinHeight(),
 955         maxWidth = GetMaxWidth(),
 956         maxHeight = GetMaxHeight();
 957
 958 #ifdef __WXGPE__
 959     // GPE's window manager doesn't like size hints
 960     // at all, esp. when the user has to use the
 961     // virtual keyboard.
 962     minWidth = -1;
 963     minHeight = -1;
 964     maxWidth = -1;
 965     maxHeight = -1;
 966 #endif
 967
 968     if ((minWidth != -1) && (m_width < minWidth)) m_width = minWidth;
 969     if ((minHeight != -1) && (m_height < minHeight)) m_height = minHeight;
 970     if ((maxWidth != -1) && (m_width > maxWidth)) m_width = maxWidth;
 971     if ((maxHeight != -1) && (m_height > maxHeight)) m_height = maxHeight;
 972
 973     if (m_mainWidget)
 974     {
 975         // set size hints
 976         gint            flag = 0; // GDK_HINT_POS;
 977         GdkGeometry     geom;
 978
 979         if ((minWidth != -1) || (minHeight != -1)) flag |= GDK_HINT_MIN_SIZE;
 980         if ((maxWidth != -1) || (maxHeight != -1)) flag |= GDK_HINT_MAX_SIZE;
 981
 982         geom.min_width = minWidth;
 983         geom.min_height = minHeight;
 984
 985             // Because of the way we set GDK_HINT_MAX_SIZE above, if either of
 986             // maxHeight or maxWidth is set, we must set them both, else the
 987             // remaining -1 will be taken literally.
 988
 989             // I'm certain this also happens elsewhere, and is the probable
 990             // cause of other such things as:
 991             // Gtk-WARNING **: gtk_widget_size_allocate():
 992             //       attempt to allocate widget with width 65535 and height 600
 993             // but I don't have time to track them all now..
 994             //
 995             // Really we need to encapulate all this height/width business and
 996             // stop any old method from ripping at the members directly and
 997             // scattering -1's without regard for who might resolve them later.
 998
 999         geom.max_width = ( maxHeight == -1 ) ? maxWidth
1000                          : ( maxWidth == -1 ) ? wxGetDisplaySize().GetWidth()
1001                            : maxWidth ;
1002
1003         geom.max_height = ( maxWidth == -1 ) ? maxHeight    // ( == -1 here )
1004                           : ( maxHeight == -1 ) ? wxGetDisplaySize().GetHeight()
1005                             : maxHeight ;
1006
1007         gtk_window_set_geometry_hints( GTK_WINDOW(m_widget),
1008                                        (GtkWidget*) NULL,
1009                                        &geom,
1010                                        (GdkWindowHints) flag );
1011
1012         /* I revert back to wxGTK's original behaviour. m_mainWidget holds the
1013          * menubar, the toolbar and the client area, which is represented by
1014          * m_wxwindow.
1015          * this hurts in the eye, but I don't want to call SetSize()
1016          * because I don't want to call any non-native functions here. */
1017
1018         int client_x = m_miniEdge;
1019         int client_y = m_miniEdge + m_miniTitle;
1020         int client_w = m_width - 2*m_miniEdge;
1021         int client_h = m_height - 2*m_miniEdge - m_miniTitle;
1022         if (client_w < 0)
1023             client_w = 0;
1024         if (client_h < 0)
1025             client_h = 0;
1026
1027         gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
1028                               m_wxwindow,
1029                               client_x, client_y, client_w, client_h );
1030     }
1031     else
1032     {
1033         // If there is no m_mainWidget between m_widget and m_wxwindow there
1034         // is no need to set the size or position of m_wxwindow.
1035     }
1036
1037     m_sizeSet = true;
1038
1039     // send size event to frame
1040     wxSizeEvent event( wxSize(m_width,m_height), GetId() );
1041     event.SetEventObject( this );
1042     GetEventHandler()->ProcessEvent( event );
1043
1044     m_resizing = false;
1045 }
1046
1047 void wxTopLevelWindowGTK::OnInternalIdle()
1048 {
1049     if (!m_sizeSet && GTK_WIDGET_REALIZED(m_wxwindow))
1050     {
1051         GtkOnSize();
1052
1053         // we'll come back later
1054         if (g_isIdle)
1055             wxapp_install_idle_handler();
1056         return;
1057     }
1058
1059     // set the focus if not done yet and if we can already do it
1060     if ( GTK_WIDGET_REALIZED(m_wxwindow) )
1061     {
1062         if ( g_delayedFocus &&
1063              wxGetTopLevelParent((wxWindow*)g_delayedFocus) == this )
1064         {
1065             wxLogTrace(_T("focus"),
1066                        _T("Setting focus from wxTLW::OnIdle() to %s(%s)"),
1067                        g_delayedFocus->GetClassInfo()->GetClassName(),
1068                        g_delayedFocus->GetLabel().c_str());
1069
1070             g_delayedFocus->SetFocus();
1071             g_delayedFocus = NULL;
1072         }
1073     }
1074
1075     wxWindow::OnInternalIdle();
1076
1077     // Synthetize activate events.
1078     if ( g_sendActivateEvent != -1 )
1079     {
1080         bool activate = g_sendActivateEvent != 0;
1081
1082         // if (!activate) wxPrintf( wxT("de") );
1083         // wxPrintf( wxT("activate\n") );
1084
1085         // do it only once
1086         g_sendActivateEvent = -1;
1087
1088         wxTheApp->SetActive(activate, (wxWindow *)g_lastActiveFrame);
1089     }
1090 }
1091
1092 // ----------------------------------------------------------------------------
1093 // frame title/icon
1094 // ----------------------------------------------------------------------------
1095
1096 void wxTopLevelWindowGTK::SetTitle( const wxString &title )
1097 {
1098     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
1099
1100     if ( title == m_title )
1101         return;
1102
1103     m_title = title;
1104
1105     gtk_window_set_title( GTK_WINDOW(m_widget), wxGTK_CONV( title ) );
1106 }
1107
1108 void wxTopLevelWindowGTK::SetIcon( const wxIcon &icon )
1109 {
1110     SetIcons( wxIconBundle( icon ) );
1111 }
1112
1113 void wxTopLevelWindowGTK::SetIcons( const wxIconBundle &icons )
1114 {
1115     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
1116
1117     wxTopLevelWindowBase::SetIcons( icons );
1118
1119     GList *list = NULL;
1120     size_t max = icons.m_icons.GetCount();
1121
1122     for (size_t i = 0; i < max; i++)
1123     {
1124         if (icons.m_icons[i].Ok())
1125         {
1126             list = g_list_prepend(list, icons.m_icons[i].GetPixbuf());
1127         }
1128     }
1129     gtk_window_set_icon_list(GTK_WINDOW(m_widget), list);
1130     g_list_free(list);
1131 }
1132
1133 // ----------------------------------------------------------------------------
1134 // frame state: maximized/iconized/normal
1135 // ----------------------------------------------------------------------------
1136
1137 void wxTopLevelWindowGTK::Maximize(bool maximize)
1138 {
1139     if (maximize)
1140         gtk_window_maximize( GTK_WINDOW( m_widget ) );
1141     else
1142         gtk_window_unmaximize( GTK_WINDOW( m_widget ) );
1143 }
1144
1145 bool wxTopLevelWindowGTK::IsMaximized() const
1146 {
1147     if(!m_widget->window)
1148         return false;
1149
1150     return gdk_window_get_state(m_widget->window) & GDK_WINDOW_STATE_MAXIMIZED;
1151 }
1152
1153 void wxTopLevelWindowGTK::Restore()
1154 {
1155     // "Present" seems similar enough to "restore"
1156     gtk_window_present( GTK_WINDOW( m_widget ) );
1157 }
1158
1159 void wxTopLevelWindowGTK::Iconize( bool iconize )
1160 {
1161     if (iconize)
1162         gtk_window_iconify( GTK_WINDOW( m_widget ) );
1163     else
1164         gtk_window_deiconify( GTK_WINDOW( m_widget ) );
1165 }
1166
1167 bool wxTopLevelWindowGTK::IsIconized() const
1168 {
1169     return m_isIconized;
1170 }
1171
1172 void wxTopLevelWindowGTK::SetIconizeState(bool iconize)
1173 {
1174     if ( iconize != m_isIconized )
1175     {
1176         m_isIconized = iconize;
1177         (void)SendIconizeEvent(iconize);
1178     }
1179 }
1180
1181 void wxTopLevelWindowGTK::AddGrab()
1182 {
1183     if (!m_grabbed)
1184     {
1185         m_grabbed = true;
1186         gtk_grab_add( m_widget );
1187         wxEventLoop().Run();
1188         gtk_grab_remove( m_widget );
1189     }
1190 }
1191
1192 void wxTopLevelWindowGTK::RemoveGrab()
1193 {
1194     if (m_grabbed)
1195     {
1196         gtk_main_quit();
1197         m_grabbed = false;
1198     }
1199 }
1200
1201
1202 // helper
1203 static bool do_shape_combine_region(GdkWindow* window, const wxRegion& region)
1204 {
1205     if (window)
1206     {
1207         if (region.IsEmpty())
1208         {
1209             gdk_window_shape_combine_mask(window, NULL, 0, 0);
1210         }
1211         else
1212         {
1213             gdk_window_shape_combine_region(window, region.GetRegion(), 0, 0);
1214             return true;
1215         }
1216     }
1217     return false;
1218 }
1219
1220
1221 bool wxTopLevelWindowGTK::SetShape(const wxRegion& region)
1222 {
1223     wxCHECK_MSG( HasFlag(wxFRAME_SHAPED), false,
1224                  _T("Shaped windows must be created with the wxFRAME_SHAPED style."));
1225
1226     GdkWindow *window = NULL;
1227     if (m_wxwindow)
1228     {
1229         window = GTK_PIZZA(m_wxwindow)->bin_window;
1230         do_shape_combine_region(window, region);
1231     }
1232     window = m_widget->window;
1233     return do_shape_combine_region(window, region);
1234 }
1235
1236 bool wxTopLevelWindowGTK::IsActive()
1237 {
1238     return (this == (wxTopLevelWindowGTK*)g_activeFrame);
1239 }
1240
1241 void wxTopLevelWindowGTK::RequestUserAttention(int flags)
1242 {
1243     bool new_hint_value = false;
1244
1245     // FIXME: This is a workaround to focus handling problem
1246     // If RequestUserAttention is called for example right after a wxSleep, OnInternalIdle hasn't
1247     // yet been processed, and the internal focus system is not up to date yet.
1248     // wxYieldIfNeeded ensures the processing of it, but can have unwanted side effects - MR
1249     ::wxYieldIfNeeded();
1250
1251     if(m_urgency_hint >= 0)
1252         g_source_remove(m_urgency_hint);
1253
1254     m_urgency_hint = -2;
1255
1256     if( GTK_WIDGET_REALIZED(m_widget) && !IsActive() )
1257     {
1258         new_hint_value = true;
1259
1260         if (flags & wxUSER_ATTENTION_INFO)
1261         {
1262             m_urgency_hint = g_timeout_add(5000, (GSourceFunc)gtk_frame_urgency_timer_callback, this);
1263         } else {
1264             m_urgency_hint = -1;
1265         }
1266     }
1267
1268 #if GTK_CHECK_VERSION(2,7,0)
1269     if(!gtk_check_version(2,7,0))
1270         gtk_window_set_urgency_hint(GTK_WINDOW( m_widget ), new_hint_value);
1271     else
1272 #endif
1273         wxgtk_window_set_urgency_hint(GTK_WINDOW( m_widget ), new_hint_value);
1274 }
1275
1276 void wxTopLevelWindowGTK::SetWindowStyleFlag( long style )
1277 {
1278 #if defined(__WXGTK24__) || GTK_CHECK_VERSION(2,2,0)
1279     // Store which styles were changed
1280     long styleChanges = style ^ m_windowStyle;
1281 #endif
1282
1283     // Process wxWindow styles. This also updates the internal variable
1284     // Therefore m_windowStyle bits carry now the _new_ style values
1285     wxWindow::SetWindowStyleFlag(style);
1286
1287     // just return for now if widget does not exist yet
1288     if (!m_widget)
1289         return;
1290
1291 #ifdef __WXGTK24__
1292     if ( (styleChanges & wxSTAY_ON_TOP) && !gtk_check_version(2,4,0) )
1293         gtk_window_set_keep_above(GTK_WINDOW(m_widget), m_windowStyle & wxSTAY_ON_TOP);
1294 #endif // GTK+ 2.4
1295 #if GTK_CHECK_VERSION(2,2,0)
1296     if ( (styleChanges & wxFRAME_NO_TASKBAR) && !gtk_check_version(2,2,0) )
1297     {
1298         gtk_window_set_skip_taskbar_hint(GTK_WINDOW(m_widget), m_windowStyle & wxFRAME_NO_TASKBAR);
1299     }
1300 #endif // GTK+ 2.2
1301 }
1302
1303 #include <X11/Xlib.h>
1304
1305 /* Get the X Window between child and the root window.
1306    This should usually be the WM managed XID */
1307 static Window wxGetTopmostWindowX11(Display *dpy, Window child)
1308 {
1309     Window root, parent;
1310     Window* children;
1311     unsigned int nchildren;
1312
1313     XQueryTree(dpy, child, &root, &parent, &children, &nchildren);
1314     XFree(children);
1315
1316     while (parent != root) {
1317         child = parent;
1318         XQueryTree(dpy, child, &root, &parent, &children, &nchildren);
1319         XFree(children);
1320     }
1321
1322     return child;
1323 }
1324
1325 bool wxTopLevelWindowGTK::SetTransparent(wxByte alpha)
1326 {
1327     if (!m_widget || !m_widget->window)
1328         return false;
1329
1330     Display* dpy = GDK_WINDOW_XDISPLAY (m_widget->window);
1331     // We need to get the X Window that has the root window as the immediate parent
1332     // and m_widget->window as a child. This should be the X Window that the WM manages and
1333     // from which the opacity property is checked from.
1334     Window win = wxGetTopmostWindowX11(dpy, GDK_WINDOW_XID (m_widget->window));
1335
1336     unsigned int opacity = alpha * 0x1010101;
1337
1338     // Using pure Xlib to not have a GTK version check mess due to gtk2.0 not having GdkDisplay
1339     if (alpha == 0xff)
1340         XDeleteProperty(dpy, win, XInternAtom(dpy, "_NET_WM_WINDOW_OPACITY", False));
1341     else
1342         XChangeProperty(dpy, win, XInternAtom(dpy, "_NET_WM_WINDOW_OPACITY", False),
1343                         XA_CARDINAL, 32, PropModeReplace,
1344                         (unsigned char *) &opacity, 1L);
1345     XSync(dpy, False);
1346     return true;
1347 }
1348
1349 bool wxTopLevelWindowGTK::CanSetTransparent()
1350 {
1351 #if GTK_CHECK_VERSION(2,10,0)
1352     if (!gtk_check_version(2,10,0))
1353     {
1354         if (gtk_widget_is_composited (m_widget))
1355             return true;
1356     }
1357     else
1358 #endif // In case of lower versions than gtk+-2.10.0 we could look for _NET_WM_CM_Sn ourselves
1359     {
1360         return false;
1361     }
1362
1363 #if 0 // Don't be optimistic here for the sake of wxAUI
1364     int opcode, event, error;
1365     // Check for the existence of a RGBA visual instead?
1366     return XQueryExtension(gdk_x11_get_default_xdisplay (),
1367                            "Composite", &opcode, &event, &error);
1368 #endif
1369 }