src/gtk/toplevel.cpp

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