src/gtk/toplevel.cpp

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