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 *WXUNUSED(widget),
 273                               GdkEventConfigure *WXUNUSED(event),
 274                               wxTopLevelWindowGTK *win )
 275 {
 276     if (!win->m_hasVMT || !win->IsShown())
 277         return FALSE;
 278
 279
 280     int x = 0;
 281     int y = 0;
 282     gdk_window_get_root_origin( win->m_widget->window, &x, &y );
 283     win->m_x = x;
 284     win->m_y = y;
 285
 286     wxMoveEvent mevent( wxPoint(win->m_x,win->m_y), win->GetId() );
 287     mevent.SetEventObject( win );
 288     win->GetEventHandler()->ProcessEvent( mevent );
 289
 290     return FALSE;
 291 }
 292 }
 293
 294 //-----------------------------------------------------------------------------
 295 // "realize" from m_widget
 296 //-----------------------------------------------------------------------------
 297
 298 // we cannot MWM hints and icons before the widget has been realized,
 299 // so we do this directly after realization
 300
 301 extern "C" {
 302 static void
 303 gtk_frame_realized_callback( GtkWidget * WXUNUSED(widget),
 304                              wxTopLevelWindowGTK *win )
 305 {
 306     // All this is for Motif Window Manager "hints" and is supposed to be
 307     // recognized by other WM as well. Not tested.
 308     gdk_window_set_decorations(win->m_widget->window,
 309                                (GdkWMDecoration)win->m_gdkDecor);
 310     gdk_window_set_functions(win->m_widget->window,
 311                                (GdkWMFunction)win->m_gdkFunc);
 312
 313     // GTK's shrinking/growing policy
 314     if ((win->m_gdkFunc & GDK_FUNC_RESIZE) == 0)
 315         gtk_window_set_resizable(GTK_WINDOW(win->m_widget), FALSE);
 316     else
 317         gtk_window_set_policy(GTK_WINDOW(win->m_widget), 1, 1, 1);
 318
 319     // reset the icon
 320     wxIconBundle iconsOld = win->GetIcons();
 321     if ( !iconsOld.IsEmpty() )
 322     {
 323         win->SetIcon( wxNullIcon );
 324         win->SetIcons( iconsOld );
 325     }
 326 }
 327 }
 328
 329 //-----------------------------------------------------------------------------
 330 // "map_event" from m_widget
 331 //-----------------------------------------------------------------------------
 332
 333 extern "C" {
 334 static gboolean
 335 gtk_frame_map_callback( GtkWidget * WXUNUSED(widget),
 336                         GdkEvent * WXUNUSED(event),
 337                         wxTopLevelWindow *win )
 338 {
 339     win->SetIconizeState(false);
 340     return false;
 341 }
 342 }
 343
 344 //-----------------------------------------------------------------------------
 345 // "unmap_event" from m_widget
 346 //-----------------------------------------------------------------------------
 347
 348 extern "C" {
 349 static gboolean
 350 gtk_frame_unmap_callback( GtkWidget * WXUNUSED(widget),
 351                           GdkEvent * WXUNUSED(event),
 352                           wxTopLevelWindow *win )
 353 {
 354     win->SetIconizeState(true);
 355     return false;
 356 }
 357 }
 358
 359 //-----------------------------------------------------------------------------
 360 // "expose_event" of m_client
 361 //-----------------------------------------------------------------------------
 362
 363 extern "C" {
 364 static gboolean
 365 gtk_window_expose_callback( GtkWidget *widget,
 366                             GdkEventExpose *gdk_event,
 367                             wxWindow *win )
 368 {
 369     GtkPizza *pizza = GTK_PIZZA(widget);
 370
 371     gtk_paint_flat_box (win->m_widget->style,
 372                         pizza->bin_window, GTK_STATE_NORMAL,
 373                         GTK_SHADOW_NONE,
 374                         &gdk_event->area,
 375                         win->m_widget,
 376                         (char *)"base",
 377                         0, 0, -1, -1);
 378
 379     return FALSE;
 380 }
 381 }
 382
 383 // ----------------------------------------------------------------------------
 384 // wxTopLevelWindowGTK itself
 385 // ----------------------------------------------------------------------------
 386
 387 //-----------------------------------------------------------------------------
 388 // InsertChild for wxTopLevelWindowGTK
 389 //-----------------------------------------------------------------------------
 390
 391 /* Callback for wxTopLevelWindowGTK. This very strange beast has to be used because
 392  * C++ has no virtual methods in a constructor. We have to emulate a
 393  * virtual function here as wxWidgets requires different ways to insert
 394  * a child in container classes. */
 395
 396 static void wxInsertChildInTopLevelWindow( wxTopLevelWindowGTK* parent, wxWindow* child )
 397 {
 398     wxASSERT( GTK_IS_WIDGET(child->m_widget) );
 399
 400     if (!parent->m_insertInClientArea)
 401     {
 402         // these are outside the client area
 403         wxTopLevelWindowGTK* frame = (wxTopLevelWindowGTK*) parent;
 404         gtk_pizza_put( GTK_PIZZA(frame->m_mainWidget),
 405                          child->m_widget,
 406                          child->m_x,
 407                          child->m_y,
 408                          child->m_width,
 409                          child->m_height );
 410     }
 411     else
 412     {
 413         // these are inside the client area
 414         gtk_pizza_put( GTK_PIZZA(parent->m_wxwindow),
 415                          child->m_widget,
 416                          child->m_x,
 417                          child->m_y,
 418                          child->m_width,
 419                          child->m_height );
 420     }
 421 }
 422
 423 // ----------------------------------------------------------------------------
 424 // wxTopLevelWindowGTK creation
 425 // ----------------------------------------------------------------------------
 426
 427 void wxTopLevelWindowGTK::Init()
 428 {
 429     m_sizeSet = false;
 430     m_miniEdge = 0;
 431     m_miniTitle = 0;
 432     m_mainWidget = (GtkWidget*) NULL;
 433     m_insertInClientArea = true;
 434     m_isIconized = false;
 435     m_fsIsShowing = false;
 436     m_fsSaveFlag = 0;
 437     m_themeEnabled = true;
 438     m_gdkDecor = m_gdkFunc = 0;
 439     m_grabbed = false;
 440
 441     m_urgency_hint = -2;
 442 }
 443
 444 bool wxTopLevelWindowGTK::Create( wxWindow *parent,
 445                                   wxWindowID id,
 446                                   const wxString& title,
 447                                   const wxPoint& pos,
 448                                   const wxSize& sizeOrig,
 449                                   long style,
 450                                   const wxString &name )
 451 {
 452     // always create a frame of some reasonable, even if arbitrary, size (at
 453     // least for MSW compatibility)
 454     wxSize size = sizeOrig;
 455     size.x = WidthDefault(size.x);
 456     size.y = HeightDefault(size.y);
 457
 458     wxTopLevelWindows.Append( this );
 459
 460     m_needParent = false;
 461
 462     if (!PreCreation( parent, pos, size ) ||
 463         !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
 464     {
 465         wxFAIL_MSG( wxT("wxTopLevelWindowGTK creation failed") );
 466         return false;
 467     }
 468
 469     m_title = title;
 470
 471     m_insertCallback = (wxInsertChildFunction) wxInsertChildInTopLevelWindow;
 472
 473     // NB: m_widget may be !=NULL if it was created by derived class' Create,
 474     //     e.g. in wxTaskBarIconAreaGTK
 475     if (m_widget == NULL)
 476     {
 477         if (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG)
 478         {
 479             m_widget = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 480             // Tell WM that this is a dialog window and make it center
 481             // on parent by default (this is what GtkDialog ctor does):
 482             gtk_window_set_type_hint(GTK_WINDOW(m_widget),
 483                                      GDK_WINDOW_TYPE_HINT_DIALOG);
 484             gtk_window_set_position(GTK_WINDOW(m_widget),
 485                                     GTK_WIN_POS_CENTER_ON_PARENT);
 486         }
 487         else
 488         {
 489             m_widget = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 490 #if GTK_CHECK_VERSION(2,1,0)
 491             if (!gtk_check_version(2,1,0))
 492             {
 493                 if (style & wxFRAME_TOOL_WINDOW)
 494                 {
 495                     gtk_window_set_type_hint(GTK_WINDOW(m_widget),
 496                                              GDK_WINDOW_TYPE_HINT_UTILITY);
 497
 498                     // On some WMs, like KDE, a TOOL_WINDOW will still show
 499                     // on the taskbar, but on Gnome a TOOL_WINDOW will not.
 500                     // For consistency between WMs and with Windows, we
 501                     // should set the NO_TASKBAR flag which will apply
 502                     // the set_skip_taskbar_hint if it is available,
 503                     // ensuring no taskbar entry will appear.
 504                     style |= wxFRAME_NO_TASKBAR;
 505                 }
 506             }
 507 #endif
 508         }
 509     }
 510
 511     wxWindow *topParent = wxGetTopLevelParent(m_parent);
 512     if (topParent && (((GTK_IS_WINDOW(topParent->m_widget)) &&
 513                        (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG)) ||
 514                        (style & wxFRAME_FLOAT_ON_PARENT)))
 515     {
 516         gtk_window_set_transient_for( GTK_WINDOW(m_widget),
 517                                       GTK_WINDOW(topParent->m_widget) );
 518     }
 519
 520 #if GTK_CHECK_VERSION(2,2,0)
 521     if (!gtk_check_version(2,2,0))
 522     {
 523         if (style & wxFRAME_NO_TASKBAR)
 524         {
 525             gtk_window_set_skip_taskbar_hint(GTK_WINDOW(m_widget), TRUE);
 526         }
 527     }
 528 #endif
 529
 530 #ifdef __WXGTK24__
 531     if (!gtk_check_version(2,4,0))
 532     {
 533         if (style & wxSTAY_ON_TOP)
 534         {
 535             gtk_window_set_keep_above(GTK_WINDOW(m_widget), TRUE);
 536         }
 537     }
 538 #endif
 539
 540 #if 0
 541     if (!name.empty())
 542         gtk_window_set_role( GTK_WINDOW(m_widget), wxGTK_CONV( name ) );
 543 #endif
 544
 545     gtk_window_set_title( GTK_WINDOW(m_widget), wxGTK_CONV( title ) );
 546     GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
 547
 548     g_signal_connect (m_widget, "delete_event",
 549                       G_CALLBACK (gtk_frame_delete_callback), this);
 550
 551     // m_mainWidget holds the toolbar, the menubar and the client area
 552     m_mainWidget = gtk_pizza_new();
 553     gtk_widget_show( m_mainWidget );
 554     GTK_WIDGET_UNSET_FLAGS( m_mainWidget, GTK_CAN_FOCUS );
 555     gtk_container_add( GTK_CONTAINER(m_widget), m_mainWidget );
 556
 557     if (m_miniEdge == 0) // wxMiniFrame has its own version.
 558     {
 559        // For m_mainWidget themes
 560        g_signal_connect (m_mainWidget, "expose_event",
 561                          G_CALLBACK (gtk_window_expose_callback), this);
 562     }
 563
 564     // m_wxwindow only represents the client area without toolbar and menubar
 565     m_wxwindow = gtk_pizza_new();
 566     gtk_widget_show( m_wxwindow );
 567     gtk_container_add( GTK_CONTAINER(m_mainWidget), m_wxwindow );
 568
 569     // we donm't allow the frame to get the focus as otherwise
 570     // the frame will grab it at arbitrary focus changes
 571     GTK_WIDGET_UNSET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );
 572
 573     if (m_parent) m_parent->AddChild( this );
 574
 575     // the user resized the frame by dragging etc.
 576     g_signal_connect (m_widget, "size_allocate",
 577                       G_CALLBACK (gtk_frame_size_callback), this);
 578
 579     g_signal_connect (m_widget, "size_request",
 580                       G_CALLBACK (wxgtk_tlw_size_request_callback), this);
 581     PostCreation();
 582
 583     if ((m_x != -1) || (m_y != -1))
 584         gtk_widget_set_uposition( m_widget, m_x, m_y );
 585
 586     gtk_window_set_default_size( GTK_WINDOW(m_widget), m_width, m_height );
 587
 588     //  we cannot set MWM hints and icons before the widget has
 589     //  been realized, so we do this directly after realization
 590     g_signal_connect (m_widget, "realize",
 591                       G_CALLBACK (gtk_frame_realized_callback), this);
 592
 593     // map and unmap for iconized state
 594     g_signal_connect (m_widget, "map_event",
 595                       G_CALLBACK (gtk_frame_map_callback), this);
 596     g_signal_connect (m_widget, "unmap_event",
 597                       G_CALLBACK (gtk_frame_unmap_callback), this);
 598
 599     // the only way to get the window size is to connect to this event
 600     g_signal_connect (m_widget, "configure_event",
 601                       G_CALLBACK (gtk_frame_configure_callback), this);
 602
 603     // activation
 604     g_signal_connect_after (m_widget, "focus_in_event",
 605                       G_CALLBACK (gtk_frame_focus_in_callback), this);
 606     g_signal_connect_after (m_widget, "focus_out_event",
 607                       G_CALLBACK (gtk_frame_focus_out_callback), this);
 608
 609     // decorations
 610     if ((style & wxSIMPLE_BORDER) || (style & wxNO_BORDER))
 611     {
 612         m_gdkDecor = 0;
 613         m_gdkFunc = 0;
 614     }
 615     else
 616     if (m_miniEdge > 0)
 617     {
 618         m_gdkDecor = 0;
 619         m_gdkFunc = 0;
 620
 621         if ((style & wxRESIZE_BORDER) != 0)
 622            m_gdkFunc |= GDK_FUNC_RESIZE;
 623     }
 624     else
 625     {
 626         m_gdkDecor = (long) GDK_DECOR_BORDER;
 627         m_gdkFunc = (long) GDK_FUNC_MOVE;
 628
 629         // All this is for Motif Window Manager "hints" and is supposed to be
 630         // recognized by other WMs as well.
 631         if ((style & wxCAPTION) != 0)
 632         {
 633             m_gdkDecor |= GDK_DECOR_TITLE;
 634         }
 635         if ((style & wxCLOSE_BOX) != 0)
 636         {
 637             m_gdkFunc |= GDK_FUNC_CLOSE;
 638         }
 639         if ((style & wxSYSTEM_MENU) != 0)
 640         {
 641             m_gdkDecor |= GDK_DECOR_MENU;
 642         }
 643         if ((style & wxMINIMIZE_BOX) != 0)
 644         {
 645             m_gdkFunc |= GDK_FUNC_MINIMIZE;
 646             m_gdkDecor |= GDK_DECOR_MINIMIZE;
 647         }
 648         if ((style & wxMAXIMIZE_BOX) != 0)
 649         {
 650             m_gdkFunc |= GDK_FUNC_MAXIMIZE;
 651             m_gdkDecor |= GDK_DECOR_MAXIMIZE;
 652         }
 653         if ((style & wxRESIZE_BORDER) != 0)
 654         {
 655            m_gdkFunc |= GDK_FUNC_RESIZE;
 656            m_gdkDecor |= GDK_DECOR_RESIZEH;
 657         }
 658     }
 659
 660     return true;
 661 }
 662
 663 wxTopLevelWindowGTK::~wxTopLevelWindowGTK()
 664 {
 665     if (m_grabbed)
 666     {
 667         wxFAIL_MSG(_T("Window still grabbed"));
 668         RemoveGrab();
 669     }
 670
 671     m_isBeingDeleted = true;
 672
 673     // it may also be GtkScrolledWindow in the case of an MDI child
 674     if (GTK_IS_WINDOW(m_widget))
 675     {
 676         gtk_window_set_focus( GTK_WINDOW(m_widget), NULL );
 677     }
 678
 679     if (g_activeFrame == this)
 680         g_activeFrame = NULL;
 681     if (g_lastActiveFrame == this)
 682         g_lastActiveFrame = NULL;
 683 }
 684
 685 bool wxTopLevelWindowGTK::EnableCloseButton( bool enable )
 686 {
 687     if (enable)
 688         m_gdkFunc |= GDK_FUNC_CLOSE;
 689     else
 690         m_gdkFunc &= ~GDK_FUNC_CLOSE;
 691
 692     if (GTK_WIDGET_REALIZED(m_widget) && (m_widget->window))
 693         gdk_window_set_functions( m_widget->window, (GdkWMFunction)m_gdkFunc );
 694
 695     return true;
 696 }
 697
 698 bool wxTopLevelWindowGTK::ShowFullScreen(bool show, long style )
 699 {
 700     if (show == m_fsIsShowing)
 701         return false; // return what?
 702
 703     m_fsIsShowing = show;
 704
 705     wxX11FullScreenMethod method =
 706         wxGetFullScreenMethodX11((WXDisplay*)GDK_DISPLAY(),
 707                                  (WXWindow)GDK_ROOT_WINDOW());
 708
 709 #if GTK_CHECK_VERSION(2,2,0)
 710     // NB: gtk_window_fullscreen() uses freedesktop.org's WMspec extensions
 711     //     to switch to fullscreen, which is not always available. We must
 712     //     check if WM supports the spec and use legacy methods if it
 713     //     doesn't.
 714     if ( (method == wxX11_FS_WMSPEC) && !gtk_check_version(2,2,0) )
 715     {
 716         if (show)
 717         {
 718             m_fsSaveFlag = style;
 719             gtk_window_fullscreen( GTK_WINDOW( m_widget ) );
 720         }
 721         else
 722         {
 723             m_fsSaveFlag = 0;
 724             gtk_window_unfullscreen( GTK_WINDOW( m_widget ) );
 725         }
 726     }
 727     else
 728 #endif // GTK+ >= 2.2.0
 729     {
 730         GdkWindow *window = m_widget->window;
 731
 732         if (show)
 733         {
 734             m_fsSaveFlag = style;
 735             GetPosition( &m_fsSaveFrame.x, &m_fsSaveFrame.y );
 736             GetSize( &m_fsSaveFrame.width, &m_fsSaveFrame.height );
 737
 738             int screen_width,screen_height;
 739             wxDisplaySize( &screen_width, &screen_height );
 740
 741             gint client_x, client_y, root_x, root_y;
 742             gint width, height;
 743
 744             if (method != wxX11_FS_WMSPEC)
 745             {
 746                 // don't do it always, Metacity hates it
 747                 m_fsSaveGdkFunc = m_gdkFunc;
 748                 m_fsSaveGdkDecor = m_gdkDecor;
 749                 m_gdkFunc = m_gdkDecor = 0;
 750                 gdk_window_set_decorations(window, (GdkWMDecoration)0);
 751                 gdk_window_set_functions(window, (GdkWMFunction)0);
 752             }
 753
 754             gdk_window_get_origin (m_widget->window, &root_x, &root_y);
 755             gdk_window_get_geometry (m_widget->window, &client_x, &client_y,
 756                          &width, &height, NULL);
 757
 758             gdk_window_move_resize (m_widget->window, -client_x, -client_y,
 759                         screen_width + 1, screen_height + 1);
 760
 761             wxSetFullScreenStateX11((WXDisplay*)GDK_DISPLAY(),
 762                                     (WXWindow)GDK_ROOT_WINDOW(),
 763                                     (WXWindow)GDK_WINDOW_XWINDOW(window),
 764                                     show, &m_fsSaveFrame, method);
 765         }
 766         else // hide
 767         {
 768             m_fsSaveFlag = 0;
 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();
 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 // ----------------------------------------------------------------------------
 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 }