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