src/gtk/toplevel.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/gtk/toplevel.cpp
   3 // Purpose:
   4 // Author:      Robert Roebling
   5 // Id:          $Id$
   6 // Copyright:   (c) 1998 Robert Roebling
   7 // Licence:     wxWindows licence
   8 /////////////////////////////////////////////////////////////////////////////
   9
  10 // For compilers that support precompilation, includes "wx.h".
  11 #include "wx/wxprec.h"
  12
  13 // ============================================================================
  14 // declarations
  15 // ============================================================================
  16
  17 // ----------------------------------------------------------------------------
  18 // headers
  19 // ----------------------------------------------------------------------------
  20
  21 #ifdef __VMS
  22 #define XIconifyWindow XICONIFYWINDOW
  23 #endif
  24
  25 #include "wx/toplevel.h"
  26
  27 #ifndef WX_PRECOMP
  28     #include "wx/log.h"
  29     #include "wx/app.h"
  30     #include "wx/dcclient.h"
  31     #include "wx/dialog.h"
  32     #include "wx/timer.h"
  33     #include "wx/settings.h"
  34     #include "wx/control.h"
  35 #endif
  36
  37 #include "wx/gtk/private.h"
  38 #include "wx/evtloop.h"
  39
  40 #include <glib.h>
  41 #include <gdk/gdk.h>
  42 #include <gtk/gtk.h>
  43 #include <gdk/gdkkeysyms.h>
  44 #include <gdk/gdkx.h>
  45
  46 #include "wx/gtk/win_gtk.h"
  47
  48 #include "wx/unix/utilsx11.h"
  49
  50 // XA_CARDINAL
  51 #include <X11/Xatom.h>
  52
  53 // ----------------------------------------------------------------------------
  54 // data
  55 // ----------------------------------------------------------------------------
  56
  57 extern int              g_openDialogs;
  58 extern wxWindowGTK     *g_delayedFocus;
  59
  60 // the frame that is currently active (i.e. its child has focus). It is
  61 // used to generate wxActivateEvents
  62 static wxTopLevelWindowGTK *g_activeFrame = (wxTopLevelWindowGTK*) NULL;
  63 static wxTopLevelWindowGTK *g_lastActiveFrame = (wxTopLevelWindowGTK*) NULL;
  64
  65 // if we detect that the app has got/lost the focus, we set this variable to
  66 // either TRUE or FALSE and an activate event will be sent during the next
  67 // OnIdle() call and it is reset to -1: this value means that we shouldn't
  68 // send any activate events at all
  69 static int g_sendActivateEvent = -1;
  70
  71 //-----------------------------------------------------------------------------
  72 // RequestUserAttention related functions
  73 //-----------------------------------------------------------------------------
  74
  75 extern "C" {
  76 static void wxgtk_window_set_urgency_hint (GtkWindow *win,
  77                                            gboolean setting)
  78 {
  79     wxASSERT_MSG( GTK_WIDGET_REALIZED(win), wxT("wxgtk_window_set_urgency_hint: GdkWindow not realized") );
  80     GdkWindow *window = GTK_WIDGET(win)->window;
  81     XWMHints *wm_hints;
  82
  83     wm_hints = XGetWMHints(GDK_WINDOW_XDISPLAY(window), GDK_WINDOW_XWINDOW(window));
  84
  85     if (!wm_hints)
  86         wm_hints = XAllocWMHints();
  87
  88     if (setting)
  89         wm_hints->flags |= XUrgencyHint;
  90     else
  91         wm_hints->flags &= ~XUrgencyHint;
  92
  93     XSetWMHints(GDK_WINDOW_XDISPLAY(window), GDK_WINDOW_XWINDOW(window), wm_hints);
  94     XFree(wm_hints);
  95 }
  96
  97 static gboolean gtk_frame_urgency_timer_callback( wxTopLevelWindowGTK *win )
  98 {
  99 #if GTK_CHECK_VERSION(2,7,0)
 100     if(!gtk_check_version(2,7,0))
 101         gtk_window_set_urgency_hint(GTK_WINDOW( win->m_widget ), FALSE);
 102     else
 103 #endif
 104         wxgtk_window_set_urgency_hint(GTK_WINDOW( win->m_widget ), FALSE);
 105
 106     win->m_urgency_hint = -2;
 107     return FALSE;
 108 }
 109 }
 110
 111 //-----------------------------------------------------------------------------
 112 // "focus_in_event"
 113 //-----------------------------------------------------------------------------
 114
 115 extern "C" {
 116 static gboolean gtk_frame_focus_in_callback( GtkWidget *widget,
 117                                          GdkEvent *WXUNUSED(event),
 118                                          wxTopLevelWindowGTK *win )
 119 {
 120     if (g_isIdle)
 121         wxapp_install_idle_handler();
 122
 123     switch ( g_sendActivateEvent )
 124     {
 125         case -1:
 126             // we've got focus from outside, synthetize wxActivateEvent
 127             g_sendActivateEvent = 1;
 128             break;
 129
 130         case 0:
 131             // another our window just lost focus, it was already ours before
 132             // - don't send any wxActivateEvent
 133             g_sendActivateEvent = -1;
 134             break;
 135     }
 136
 137     g_activeFrame = win;
 138     g_lastActiveFrame = g_activeFrame;
 139
 140     // wxPrintf( wxT("active: %s\n"), win->GetTitle().c_str() );
 141
 142     // MR: wxRequestUserAttention related block
 143     switch( win->m_urgency_hint )
 144     {
 145         default:
 146             g_source_remove( win->m_urgency_hint );
 147             // no break, fallthrough to remove hint too
 148         case -1:
 149 #if GTK_CHECK_VERSION(2,7,0)
 150             if(!gtk_check_version(2,7,0))
 151                 gtk_window_set_urgency_hint(GTK_WINDOW( widget ), FALSE);
 152             else
 153 #endif
 154             {
 155                 wxgtk_window_set_urgency_hint(GTK_WINDOW( widget ), FALSE);
 156             }
 157
 158             win->m_urgency_hint = -2;
 159             break;
 160
 161         case -2: break;
 162     }
 163
 164     wxLogTrace(wxT("activate"), wxT("Activating frame %p (from focus_in)"), g_activeFrame);
 165     wxActivateEvent event(wxEVT_ACTIVATE, true, g_activeFrame->GetId());
 166     event.SetEventObject(g_activeFrame);
 167     g_activeFrame->GetEventHandler()->ProcessEvent(event);
 168
 169     return FALSE;
 170 }
 171 }
 172
 173 //-----------------------------------------------------------------------------
 174 // "focus_out_event"
 175 //-----------------------------------------------------------------------------
 176
 177 extern "C" {
 178 static gboolean gtk_frame_focus_out_callback( GtkWidget *widget,
 179                                           GdkEventFocus *WXUNUSED(gdk_event),
 180                                           wxTopLevelWindowGTK *win )
 181 {
 182     if (g_isIdle)
 183         wxapp_install_idle_handler();
 184
 185     // if the focus goes out of our app alltogether, OnIdle() will send
 186     // wxActivateEvent, otherwise gtk_window_focus_in_callback() will reset
 187     // g_sendActivateEvent to -1
 188     g_sendActivateEvent = 0;
 189
 190     // wxASSERT_MSG( (g_activeFrame == win), wxT("TLW deactivatd although it wasn't active") );
 191
 192     // wxPrintf( wxT("inactive: %s\n"), win->GetTitle().c_str() );
 193
 194     if (g_activeFrame)
 195     {
 196         wxLogTrace(wxT("activate"), wxT("Activating frame %p (from focus_in)"), g_activeFrame);
 197         wxActivateEvent event(wxEVT_ACTIVATE, false, g_activeFrame->GetId());
 198         event.SetEventObject(g_activeFrame);
 199         g_activeFrame->GetEventHandler()->ProcessEvent(event);
 200
 201         g_activeFrame = NULL;
 202     }
 203
 204     return FALSE;
 205 }
 206 }
 207
 208 //-----------------------------------------------------------------------------
 209 // "focus" from m_window
 210 //-----------------------------------------------------------------------------
 211
 212 extern "C" {
 213 static gboolean gtk_frame_focus_callback( GtkWidget *widget, GtkDirectionType WXUNUSED(d), wxWindow *WXUNUSED(win) )
 214 {
 215     if (g_isIdle)
 216         wxapp_install_idle_handler();
 217
 218     // This disables GTK's tab traversal
 219     g_signal_stop_emission_by_name (widget, "focus");
 220     return TRUE;
 221 }
 222 }
 223
 224 //-----------------------------------------------------------------------------
 225 // "size_allocate"
 226 //-----------------------------------------------------------------------------
 227
 228 extern "C" {
 229 static void gtk_frame_size_callback( GtkWidget *WXUNUSED(widget), GtkAllocation* alloc, wxTopLevelWindowGTK *win )
 230 {
 231     if (g_isIdle)
 232         wxapp_install_idle_handler();
 233
 234     if (!win->m_hasVMT)
 235         return;
 236
 237     if ((win->m_width != alloc->width) || (win->m_height != alloc->height))
 238     {
 239 /*
 240         wxPrintf( wxT("gtk_frame_size_callback from ") );
 241         if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
 242            wxPrintf( win->GetClassInfo()->GetClassName() );
 243         wxPrintf( wxT(" %d %d %d %d\n"), (int)alloc->x,
 244                                 (int)alloc->y,
 245                                 (int)alloc->width,
 246                                 (int)alloc->height );
 247 */
 248
 249         win->m_width = alloc->width;
 250         win->m_height = alloc->height;
 251         win->GtkUpdateSize();
 252     }
 253 }
 254 }
 255
 256 //-----------------------------------------------------------------------------
 257 // "delete_event"
 258 //-----------------------------------------------------------------------------
 259
 260 extern "C" {
 261 static gboolean
 262 gtk_frame_delete_callback( GtkWidget *WXUNUSED(widget),
 263                            GdkEvent *WXUNUSED(event),
 264                            wxTopLevelWindowGTK *win )
 265 {
 266     if (g_isIdle)
 267         wxapp_install_idle_handler();
 268
 269     if (win->IsEnabled() &&
 270         (g_openDialogs == 0 || (win->GetExtraStyle() & wxTOPLEVEL_EX_DIALOG) ||
 271          win->IsGrabbed()))
 272         win->Close();
 273
 274     return TRUE;
 275 }
 276 }
 277
 278
 279 //-----------------------------------------------------------------------------
 280 // "configure_event"
 281 //-----------------------------------------------------------------------------
 282
 283 extern "C" {
 284 static gboolean
 285 gtk_frame_configure_callback( GtkWidget *WXUNUSED(widget),
 286                               GdkEventConfigure *WXUNUSED(event),
 287                               wxTopLevelWindowGTK *win )
 288 {
 289     if (g_isIdle)
 290         wxapp_install_idle_handler();
 291
 292     if (!win->m_hasVMT || !win->IsShown())
 293         return FALSE;
 294
 295
 296     int x = 0;
 297     int y = 0;
 298     gdk_window_get_root_origin( win->m_widget->window, &x, &y );
 299     win->m_x = x;
 300     win->m_y = y;
 301
 302     wxMoveEvent mevent( wxPoint(win->m_x,win->m_y), win->GetId() );
 303     mevent.SetEventObject( win );
 304     win->GetEventHandler()->ProcessEvent( mevent );
 305
 306     return FALSE;
 307 }
 308 }
 309
 310 //-----------------------------------------------------------------------------
 311 // "realize" from m_widget
 312 //-----------------------------------------------------------------------------
 313
 314 // we cannot MWM hints and icons before the widget has been realized,
 315 // so we do this directly after realization
 316
 317 extern "C" {
 318 static void
 319 gtk_frame_realized_callback( GtkWidget * WXUNUSED(widget),
 320                              wxTopLevelWindowGTK *win )
 321 {
 322     if (g_isIdle)
 323         wxapp_install_idle_handler();
 324
 325     // All this is for Motif Window Manager "hints" and is supposed to be
 326     // recognized by other WM as well. Not tested.
 327     gdk_window_set_decorations(win->m_widget->window,
 328                                (GdkWMDecoration)win->m_gdkDecor);
 329     gdk_window_set_functions(win->m_widget->window,
 330                                (GdkWMFunction)win->m_gdkFunc);
 331
 332     // GTK's shrinking/growing policy
 333     if ((win->m_gdkFunc & GDK_FUNC_RESIZE) == 0)
 334         gtk_window_set_resizable(GTK_WINDOW(win->m_widget), FALSE);
 335     else
 336         gtk_window_set_policy(GTK_WINDOW(win->m_widget), 1, 1, 1);
 337
 338     // reset the icon
 339     wxIconBundle iconsOld = win->GetIcons();
 340     if ( iconsOld.GetIcon(-1).Ok() )
 341     {
 342         win->SetIcon( wxNullIcon );
 343         win->SetIcons( iconsOld );
 344     }
 345 }
 346 }
 347
 348 //-----------------------------------------------------------------------------
 349 // "map_event" from m_widget
 350 //-----------------------------------------------------------------------------
 351
 352 extern "C" {
 353 static void
 354 gtk_frame_map_callback( GtkWidget * WXUNUSED(widget),
 355                         GdkEvent * WXUNUSED(event),
 356                         wxTopLevelWindow *win )
 357 {
 358     win->SetIconizeState(false);
 359 }
 360 }
 361
 362 //-----------------------------------------------------------------------------
 363 // "unmap_event" from m_widget
 364 //-----------------------------------------------------------------------------
 365
 366 extern "C" {
 367 static void
 368 gtk_frame_unmap_callback( GtkWidget * WXUNUSED(widget),
 369                           GdkEvent * WXUNUSED(event),
 370                           wxTopLevelWindow *win )
 371 {
 372     win->SetIconizeState(true);
 373 }
 374 }
 375
 376 //-----------------------------------------------------------------------------
 377 // "expose_event" of m_client
 378 //-----------------------------------------------------------------------------
 379
 380 extern "C" {
 381 static gboolean
 382 gtk_window_expose_callback( GtkWidget *widget,
 383                             GdkEventExpose *gdk_event,
 384                             wxWindow *win )
 385 {
 386     GtkPizza *pizza = GTK_PIZZA(widget);
 387
 388     gtk_paint_flat_box (win->m_widget->style,
 389                         pizza->bin_window, GTK_STATE_NORMAL,
 390                         GTK_SHADOW_NONE,
 391                         &gdk_event->area,
 392                         win->m_widget,
 393                         (char *)"base",
 394                         0, 0, -1, -1);
 395
 396     return FALSE;
 397 }
 398 }
 399
 400 // ----------------------------------------------------------------------------
 401 // wxTopLevelWindowGTK itself
 402 // ----------------------------------------------------------------------------
 403
 404 //-----------------------------------------------------------------------------
 405 // InsertChild for wxTopLevelWindowGTK
 406 //-----------------------------------------------------------------------------
 407
 408 /* Callback for wxTopLevelWindowGTK. This very strange beast has to be used because
 409  * C++ has no virtual methods in a constructor. We have to emulate a
 410  * virtual function here as wxWidgets requires different ways to insert
 411  * a child in container classes. */
 412
 413 static void wxInsertChildInTopLevelWindow( wxTopLevelWindowGTK* parent, wxWindow* child )
 414 {
 415     wxASSERT( GTK_IS_WIDGET(child->m_widget) );
 416
 417     if (!parent->m_insertInClientArea)
 418     {
 419         // these are outside the client area
 420         wxTopLevelWindowGTK* frame = (wxTopLevelWindowGTK*) parent;
 421         gtk_pizza_put( GTK_PIZZA(frame->m_mainWidget),
 422                          GTK_WIDGET(child->m_widget),
 423                          child->m_x,
 424                          child->m_y,
 425                          child->m_width,
 426                          child->m_height );
 427     }
 428     else
 429     {
 430         // these are inside the client area
 431         gtk_pizza_put( GTK_PIZZA(parent->m_wxwindow),
 432                          GTK_WIDGET(child->m_widget),
 433                          child->m_x,
 434                          child->m_y,
 435                          child->m_width,
 436                          child->m_height );
 437     }
 438 }
 439
 440 // ----------------------------------------------------------------------------
 441 // wxTopLevelWindowGTK creation
 442 // ----------------------------------------------------------------------------
 443
 444 void wxTopLevelWindowGTK::Init()
 445 {
 446     m_sizeSet = false;
 447     m_miniEdge = 0;
 448     m_miniTitle = 0;
 449     m_mainWidget = (GtkWidget*) NULL;
 450     m_insertInClientArea = true;
 451     m_isIconized = false;
 452     m_fsIsShowing = false;
 453     m_themeEnabled = true;
 454     m_gdkDecor = m_gdkFunc = 0;
 455     m_grabbed = false;
 456
 457     m_urgency_hint = -2;
 458 }
 459
 460 bool wxTopLevelWindowGTK::Create( wxWindow *parent,
 461                                   wxWindowID id,
 462                                   const wxString& title,
 463                                   const wxPoint& pos,
 464                                   const wxSize& sizeOrig,
 465                                   long style,
 466                                   const wxString &name )
 467 {
 468     // always create a frame of some reasonable, even if arbitrary, size (at
 469     // least for MSW compatibility)
 470     wxSize size = sizeOrig;
 471     size.x = WidthDefault(size.x);
 472     size.y = HeightDefault(size.y);
 473
 474     wxTopLevelWindows.Append( this );
 475
 476     m_needParent = false;
 477
 478     if (!PreCreation( parent, pos, size ) ||
 479         !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
 480     {
 481         wxFAIL_MSG( wxT("wxTopLevelWindowGTK creation failed") );
 482         return false;
 483     }
 484
 485     m_title = title;
 486
 487     m_insertCallback = (wxInsertChildFunction) wxInsertChildInTopLevelWindow;
 488
 489     // NB: m_widget may be !=NULL if it was created by derived class' Create,
 490     //     e.g. in wxTaskBarIconAreaGTK
 491     if (m_widget == NULL)
 492     {
 493         if (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG)
 494         {
 495             m_widget = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 496             // Tell WM that this is a dialog window and make it center
 497             // on parent by default (this is what GtkDialog ctor does):
 498             gtk_window_set_type_hint(GTK_WINDOW(m_widget),
 499                                      GDK_WINDOW_TYPE_HINT_DIALOG);
 500             gtk_window_set_position(GTK_WINDOW(m_widget),
 501                                     GTK_WIN_POS_CENTER_ON_PARENT);
 502         }
 503         else
 504         {
 505             m_widget = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 506 #if GTK_CHECK_VERSION(2,1,0)
 507             if (!gtk_check_version(2,1,0))
 508             {
 509                 if (style & wxFRAME_TOOL_WINDOW)
 510                 {
 511                     gtk_window_set_type_hint(GTK_WINDOW(m_widget),
 512                                              GDK_WINDOW_TYPE_HINT_UTILITY);
 513
 514                     // On some WMs, like KDE, a TOOL_WINDOW will still show
 515                     // on the taskbar, but on Gnome a TOOL_WINDOW will not.
 516                     // For consistency between WMs and with Windows, we
 517                     // should set the NO_TASKBAR flag which will apply
 518                     // the set_skip_taskbar_hint if it is available,
 519                     // ensuring no taskbar entry will appear.
 520                     style |= wxFRAME_NO_TASKBAR;
 521                 }
 522             }
 523 #endif
 524         }
 525     }
 526
 527     wxWindow *topParent = wxGetTopLevelParent(m_parent);
 528     if (topParent && (((GTK_IS_WINDOW(topParent->m_widget)) &&
 529                        (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG)) ||
 530                        (style & wxFRAME_FLOAT_ON_PARENT)))
 531     {
 532         gtk_window_set_transient_for( GTK_WINDOW(m_widget),
 533                                       GTK_WINDOW(topParent->m_widget) );
 534     }
 535
 536 #if GTK_CHECK_VERSION(2,2,0)
 537     if (!gtk_check_version(2,2,0))
 538     {
 539         if (style & wxFRAME_NO_TASKBAR)
 540         {
 541             gtk_window_set_skip_taskbar_hint(GTK_WINDOW(m_widget), TRUE);
 542         }
 543     }
 544 #endif
 545
 546 #ifdef __WXGTK24__
 547     if (!gtk_check_version(2,4,0))
 548     {
 549         if (style & wxSTAY_ON_TOP)
 550         {
 551             gtk_window_set_keep_above(GTK_WINDOW(m_widget), TRUE);
 552         }
 553     }
 554 #endif
 555
 556 #if 0
 557     if (!name.empty())
 558         gtk_window_set_role( GTK_WINDOW(m_widget), wxGTK_CONV( name ) );
 559 #endif
 560
 561     gtk_window_set_title( GTK_WINDOW(m_widget), wxGTK_CONV( title ) );
 562     GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
 563
 564     g_signal_connect (m_widget, "delete_event",
 565                       G_CALLBACK (gtk_frame_delete_callback), this);
 566
 567     // m_mainWidget holds the toolbar, the menubar and the client area
 568     m_mainWidget = gtk_pizza_new();
 569     gtk_widget_show( m_mainWidget );
 570     GTK_WIDGET_UNSET_FLAGS( m_mainWidget, GTK_CAN_FOCUS );
 571     gtk_container_add( GTK_CONTAINER(m_widget), m_mainWidget );
 572
 573     if (m_miniEdge == 0) // wxMiniFrame has its own version.
 574     {
 575        // For m_mainWidget themes
 576        g_signal_connect (m_mainWidget, "expose_event",
 577                          G_CALLBACK (gtk_window_expose_callback), this);
 578     }
 579
 580     // m_wxwindow only represents the client area without toolbar and menubar
 581     m_wxwindow = gtk_pizza_new();
 582     gtk_widget_show( m_wxwindow );
 583     gtk_container_add( GTK_CONTAINER(m_mainWidget), m_wxwindow );
 584
 585     // we donm't allow the frame to get the focus as otherwise
 586     // the frame will grab it at arbitrary focus changes
 587     GTK_WIDGET_UNSET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );
 588
 589     if (m_parent) m_parent->AddChild( this );
 590
 591     // the user resized the frame by dragging etc.
 592     g_signal_connect (m_widget, "size_allocate",
 593                       G_CALLBACK (gtk_frame_size_callback), this);
 594
 595     PostCreation();
 596
 597     if ((m_x != -1) || (m_y != -1))
 598         gtk_widget_set_uposition( m_widget, m_x, m_y );
 599
 600     gtk_window_set_default_size( GTK_WINDOW(m_widget), m_width, m_height );
 601
 602     //  we cannot set MWM hints and icons before the widget has
 603     //  been realized, so we do this directly after realization
 604     g_signal_connect (m_widget, "realize",
 605                       G_CALLBACK (gtk_frame_realized_callback), this);
 606
 607     // map and unmap for iconized state
 608     g_signal_connect (m_widget, "map_event",
 609                       G_CALLBACK (gtk_frame_map_callback), this);
 610     g_signal_connect (m_widget, "unmap_event",
 611                       G_CALLBACK (gtk_frame_unmap_callback), this);
 612
 613     // the only way to get the window size is to connect to this event
 614     g_signal_connect (m_widget, "configure_event",
 615                       G_CALLBACK (gtk_frame_configure_callback), this);
 616
 617     // disable native tab traversal
 618     g_signal_connect (m_widget, "focus",
 619                       G_CALLBACK (gtk_frame_focus_callback), this);
 620
 621     // activation
 622     g_signal_connect_after (m_widget, "focus_in_event",
 623                       G_CALLBACK (gtk_frame_focus_in_callback), this);
 624     g_signal_connect_after (m_widget, "focus_out_event",
 625                       G_CALLBACK (gtk_frame_focus_out_callback), this);
 626
 627     // decorations
 628     if ((style & wxSIMPLE_BORDER) || (style & wxNO_BORDER))
 629     {
 630         m_gdkDecor = 0;
 631         m_gdkFunc = 0;
 632     }
 633     else
 634     if (m_miniEdge > 0)
 635     {
 636         m_gdkDecor = 0;
 637         m_gdkFunc = 0;
 638
 639         if ((style & wxRESIZE_BORDER) != 0)
 640            m_gdkFunc |= GDK_FUNC_RESIZE;
 641     }
 642     else
 643     {
 644         m_gdkDecor = (long) GDK_DECOR_BORDER;
 645         m_gdkFunc = (long) GDK_FUNC_MOVE;
 646
 647         // All this is for Motif Window Manager "hints" and is supposed to be
 648         // recognized by other WMs as well.
 649         if ((style & wxCAPTION) != 0)
 650         {
 651             m_gdkDecor |= GDK_DECOR_TITLE;
 652         }
 653         if ((style & wxCLOSE_BOX) != 0)
 654         {
 655             m_gdkFunc |= GDK_FUNC_CLOSE;
 656         }
 657         if ((style & wxSYSTEM_MENU) != 0)
 658         {
 659             m_gdkDecor |= GDK_DECOR_MENU;
 660         }
 661         if ((style & wxMINIMIZE_BOX) != 0)
 662         {
 663             m_gdkFunc |= GDK_FUNC_MINIMIZE;
 664             m_gdkDecor |= GDK_DECOR_MINIMIZE;
 665         }
 666         if ((style & wxMAXIMIZE_BOX) != 0)
 667         {
 668             m_gdkFunc |= GDK_FUNC_MAXIMIZE;
 669             m_gdkDecor |= GDK_DECOR_MAXIMIZE;
 670         }
 671         if ((style & wxRESIZE_BORDER) != 0)
 672         {
 673            m_gdkFunc |= GDK_FUNC_RESIZE;
 674            m_gdkDecor |= GDK_DECOR_RESIZEH;
 675         }
 676     }
 677
 678     return true;
 679 }
 680
 681 wxTopLevelWindowGTK::~wxTopLevelWindowGTK()
 682 {
 683     if (m_grabbed)
 684     {
 685         wxFAIL_MSG(_T("Window still grabbed"));
 686         RemoveGrab();
 687     }
 688
 689     m_isBeingDeleted = true;
 690
 691     // it may also be GtkScrolledWindow in the case of an MDI child
 692     if (GTK_IS_WINDOW(m_widget))
 693     {
 694         gtk_window_set_focus( GTK_WINDOW(m_widget), NULL );
 695     }
 696
 697     if (g_activeFrame == this)
 698         g_activeFrame = NULL;
 699     if (g_lastActiveFrame == this)
 700         g_lastActiveFrame = NULL;
 701 }
 702
 703
 704
 705 bool wxTopLevelWindowGTK::ShowFullScreen(bool show, long style )
 706 {
 707     if (show == m_fsIsShowing)
 708         return false; // return what?
 709
 710     m_fsIsShowing = show;
 711
 712     wxX11FullScreenMethod method =
 713         wxGetFullScreenMethodX11((WXDisplay*)GDK_DISPLAY(),
 714                                  (WXWindow)GDK_ROOT_WINDOW());
 715
 716 #if GTK_CHECK_VERSION(2,2,0)
 717     // NB: gtk_window_fullscreen() uses freedesktop.org's WMspec extensions
 718     //     to switch to fullscreen, which is not always available. We must
 719     //     check if WM supports the spec and use legacy methods if it
 720     //     doesn't.
 721     if ( (method == wxX11_FS_WMSPEC) && !gtk_check_version(2,2,0) )
 722     {
 723         if (show)
 724             gtk_window_fullscreen( GTK_WINDOW( m_widget ) );
 725         else
 726             gtk_window_unfullscreen( GTK_WINDOW( m_widget ) );
 727     }
 728     else
 729 #endif // GTK+ >= 2.2.0
 730     {
 731         GdkWindow *window = m_widget->window;
 732
 733         if (show)
 734         {
 735             m_fsSaveFlag = style;
 736             GetPosition( &m_fsSaveFrame.x, &m_fsSaveFrame.y );
 737             GetSize( &m_fsSaveFrame.width, &m_fsSaveFrame.height );
 738
 739             int screen_width,screen_height;
 740             wxDisplaySize( &screen_width, &screen_height );
 741
 742             gint client_x, client_y, root_x, root_y;
 743             gint width, height;
 744
 745             if (method != wxX11_FS_WMSPEC)
 746             {
 747                 // don't do it always, Metacity hates it
 748                 m_fsSaveGdkFunc = m_gdkFunc;
 749                 m_fsSaveGdkDecor = m_gdkDecor;
 750                 m_gdkFunc = m_gdkDecor = 0;
 751                 gdk_window_set_decorations(window, (GdkWMDecoration)0);
 752                 gdk_window_set_functions(window, (GdkWMFunction)0);
 753             }
 754
 755             gdk_window_get_origin (m_widget->window, &root_x, &root_y);
 756             gdk_window_get_geometry (m_widget->window, &client_x, &client_y,
 757                          &width, &height, NULL);
 758
 759             gdk_window_move_resize (m_widget->window, -client_x, -client_y,
 760                         screen_width + 1, screen_height + 1);
 761
 762             wxSetFullScreenStateX11((WXDisplay*)GDK_DISPLAY(),
 763                                     (WXWindow)GDK_ROOT_WINDOW(),
 764                                     (WXWindow)GDK_WINDOW_XWINDOW(window),
 765                                     show, &m_fsSaveFrame, method);
 766         }
 767         else // hide
 768         {
 769             if (method != wxX11_FS_WMSPEC)
 770             {
 771                 // don't do it always, Metacity hates it
 772                 m_gdkFunc = m_fsSaveGdkFunc;
 773                 m_gdkDecor = m_fsSaveGdkDecor;
 774                 gdk_window_set_decorations(window, (GdkWMDecoration)m_gdkDecor);
 775                 gdk_window_set_functions(window, (GdkWMFunction)m_gdkFunc);
 776             }
 777
 778             wxSetFullScreenStateX11((WXDisplay*)GDK_DISPLAY(),
 779                                     (WXWindow)GDK_ROOT_WINDOW(),
 780                                     (WXWindow)GDK_WINDOW_XWINDOW(window),
 781                                     show, &m_fsSaveFrame, method);
 782
 783             SetSize(m_fsSaveFrame.x, m_fsSaveFrame.y,
 784                     m_fsSaveFrame.width, m_fsSaveFrame.height);
 785         }
 786     }
 787
 788     // documented behaviour is to show the window if it's still hidden when
 789     // showing it full screen
 790     if ( show && !IsShown() )
 791         Show();
 792
 793     return true;
 794 }
 795
 796 // ----------------------------------------------------------------------------
 797 // overridden wxWindow methods
 798 // ----------------------------------------------------------------------------
 799
 800 bool wxTopLevelWindowGTK::Show( bool show )
 801 {
 802     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 803
 804     if (show == IsShown())
 805         return true;
 806
 807     if (show && !m_sizeSet)
 808     {
 809         /* by calling GtkOnSize here, we don't have to call
 810            either after showing the frame, which would entail
 811            much ugly flicker or from within the size_allocate
 812            handler, because GTK 1.1.X forbids that. */
 813
 814         GtkOnSize( m_x, m_y, m_width, m_height );
 815     }
 816
 817     // This seems no longer to be needed and the call
 818     // itself is deprecated.
 819     //
 820     //if (show)
 821     //    gtk_widget_set_uposition( m_widget, m_x, m_y );
 822
 823     return wxWindow::Show( show );
 824 }
 825
 826 void wxTopLevelWindowGTK::Raise()
 827 {
 828     gtk_window_present( GTK_WINDOW( m_widget ) );
 829 }
 830
 831 void wxTopLevelWindowGTK::DoMoveWindow(int WXUNUSED(x), int WXUNUSED(y), int WXUNUSED(width), int WXUNUSED(height) )
 832 {
 833     wxFAIL_MSG( wxT("DoMoveWindow called for wxTopLevelWindowGTK") );
 834 }
 835
 836 void wxTopLevelWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags )
 837 {
 838     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 839
 840     // this shouldn't happen: wxFrame, wxMDIParentFrame and wxMDIChildFrame have m_wxwindow
 841     wxASSERT_MSG( (m_wxwindow != NULL), wxT("invalid frame") );
 842
 843     // avoid recursions
 844     if (m_resizing)
 845         return;
 846     m_resizing = true;
 847
 848     int old_x = m_x;
 849     int old_y = m_y;
 850
 851     int old_width = m_width;
 852     int old_height = m_height;
 853
 854     if ((sizeFlags & wxSIZE_ALLOW_MINUS_ONE) == 0)
 855     {
 856         if (x != -1) m_x = x;
 857         if (y != -1) m_y = y;
 858     }
 859     else
 860     {
 861         m_x = x;
 862         m_y = y;
 863     }
 864     if (width != -1) m_width = width;
 865     if (height != -1) m_height = height;
 866
 867 /*
 868     if ((sizeFlags & wxSIZE_AUTO_WIDTH) == wxSIZE_AUTO_WIDTH)
 869     {
 870         if (width == -1) m_width = 80;
 871     }
 872
 873     if ((sizeFlags & wxSIZE_AUTO_HEIGHT) == wxSIZE_AUTO_HEIGHT)
 874     {
 875        if (height == -1) m_height = 26;
 876     }
 877 */
 878
 879     int minWidth = GetMinWidth(),
 880         minHeight = GetMinHeight(),
 881         maxWidth = GetMaxWidth(),
 882         maxHeight = GetMaxHeight();
 883
 884 #ifdef __WXGPE__
 885     // GPE's window manager doesn't like size hints
 886     // at all, esp. when the user has to use the
 887     // virtual keyboard.
 888     minWidth = -1;
 889     minHeight = -1;
 890     maxWidth = -1;
 891     maxHeight = -1;
 892 #endif
 893
 894     if ((minWidth != -1) && (m_width < minWidth)) m_width = minWidth;
 895     if ((minHeight != -1) && (m_height < minHeight)) m_height = minHeight;
 896     if ((maxWidth != -1) && (m_width > maxWidth)) m_width = maxWidth;
 897     if ((maxHeight != -1) && (m_height > maxHeight)) m_height = maxHeight;
 898
 899     if ((m_x != -1) || (m_y != -1))
 900     {
 901         if ((m_x != old_x) || (m_y != old_y))
 902         {
 903             gtk_widget_set_uposition( m_widget, m_x, m_y );
 904         }
 905     }
 906
 907     if ((m_width != old_width) || (m_height != old_height))
 908     {
 909         if (m_widget->window)
 910             gdk_window_resize( m_widget->window, m_width, m_height );
 911         else
 912             gtk_window_set_default_size( GTK_WINDOW(m_widget), m_width, m_height );
 913
 914         /* we set the size in GtkOnSize, i.e. mostly the actual resizing is
 915            done either directly before the frame is shown or in idle time
 916            so that different calls to SetSize() don't lead to flicker. */
 917         m_sizeSet = false;
 918     }
 919
 920     m_resizing = false;
 921 }
 922
 923 void wxTopLevelWindowGTK::DoGetClientSize( int *width, int *height ) const
 924 {
 925     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 926
 927     wxWindow::DoGetClientSize( width, height );
 928     if (height)
 929     {
 930         // mini edge
 931         *height -= m_miniEdge*2 + m_miniTitle;
 932     }
 933     if (width)
 934     {
 935         *width -= m_miniEdge*2;
 936     }
 937 }
 938
 939 void wxTopLevelWindowGTK::DoSetClientSize( int width, int height )
 940 {
 941     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 942
 943     DoSetSize(-1, -1,
 944               width + m_miniEdge*2, height  + m_miniEdge*2 + m_miniTitle, 0);
 945 }
 946
 947 void wxTopLevelWindowGTK::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y),
 948                                      int width, int height )
 949 {
 950     // due to a bug in gtk, x,y are always 0
 951     // m_x = x;
 952     // m_y = y;
 953
 954     // avoid recursions
 955     if (m_resizing) return;
 956     m_resizing = true;
 957
 958     if ( m_wxwindow == NULL ) return;
 959
 960     m_width = width;
 961     m_height = height;
 962
 963     /* wxMDIChildFrame derives from wxFrame but it _is_ a wxWindow as it uses
 964        wxWindow::Create to create it's GTK equivalent. m_mainWidget is only
 965        set in wxFrame::Create so it is used to check what kind of frame we
 966        have here. if m_mainWidget is NULL it is a wxMDIChildFrame and so we
 967        skip the part which handles m_frameMenuBar, m_frameToolBar and (most
 968        importantly) m_mainWidget */
 969
 970     int minWidth = GetMinWidth(),
 971         minHeight = GetMinHeight(),
 972         maxWidth = GetMaxWidth(),
 973         maxHeight = GetMaxHeight();
 974
 975 #ifdef __WXGPE__
 976     // GPE's window manager doesn't like size hints
 977     // at all, esp. when the user has to use the
 978     // virtual keyboard.
 979     minWidth = -1;
 980     minHeight = -1;
 981     maxWidth = -1;
 982     maxHeight = -1;
 983 #endif
 984
 985     if ((minWidth != -1) && (m_width < minWidth)) m_width = minWidth;
 986     if ((minHeight != -1) && (m_height < minHeight)) m_height = minHeight;
 987     if ((maxWidth != -1) && (m_width > maxWidth)) m_width = maxWidth;
 988     if ((maxHeight != -1) && (m_height > maxHeight)) m_height = maxHeight;
 989
 990     if (m_mainWidget)
 991     {
 992         // set size hints
 993         gint            flag = 0; // GDK_HINT_POS;
 994         GdkGeometry     geom;
 995
 996         if ((minWidth != -1) || (minHeight != -1)) flag |= GDK_HINT_MIN_SIZE;
 997         if ((maxWidth != -1) || (maxHeight != -1)) flag |= GDK_HINT_MAX_SIZE;
 998
 999         geom.min_width = minWidth;
1000         geom.min_height = minHeight;
1001
1002             // Because of the way we set GDK_HINT_MAX_SIZE above, if either of
1003             // maxHeight or maxWidth is set, we must set them both, else the
1004             // remaining -1 will be taken literally.
1005
1006             // I'm certain this also happens elsewhere, and is the probable
1007             // cause of other such things as:
1008             // Gtk-WARNING **: gtk_widget_size_allocate():
1009             //       attempt to allocate widget with width 65535 and height 600
1010             // but I don't have time to track them all now..
1011             //
1012             // Really we need to encapulate all this height/width business and
1013             // stop any old method from ripping at the members directly and
1014             // scattering -1's without regard for who might resolve them later.
1015
1016         geom.max_width = ( maxHeight == -1 ) ? maxWidth
1017                          : ( maxWidth == -1 ) ? wxGetDisplaySize().GetWidth()
1018                            : maxWidth ;
1019
1020         geom.max_height = ( maxWidth == -1 ) ? maxHeight    // ( == -1 here )
1021                           : ( maxHeight == -1 ) ? wxGetDisplaySize().GetHeight()
1022                             : maxHeight ;
1023
1024         gtk_window_set_geometry_hints( GTK_WINDOW(m_widget),
1025                                        (GtkWidget*) NULL,
1026                                        &geom,
1027                                        (GdkWindowHints) flag );
1028
1029         /* I revert back to wxGTK's original behaviour. m_mainWidget holds the
1030          * menubar, the toolbar and the client area, which is represented by
1031          * m_wxwindow.
1032          * this hurts in the eye, but I don't want to call SetSize()
1033          * because I don't want to call any non-native functions here. */
1034
1035         int client_x = m_miniEdge;
1036         int client_y = m_miniEdge + m_miniTitle;
1037         int client_w = m_width - 2*m_miniEdge;
1038         int client_h = m_height - 2*m_miniEdge - m_miniTitle;
1039
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( m_x, m_y, m_width, m_height );
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 }