src/gtk/toplevel.cpp

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