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_fsSaveFlag = 0;
 447     m_themeEnabled = true;
 448     m_gdkDecor = m_gdkFunc = 0;
 449     m_grabbed = false;
 450
 451     m_urgency_hint = -2;
 452 }
 453
 454 bool wxTopLevelWindowGTK::Create( wxWindow *parent,
 455                                   wxWindowID id,
 456                                   const wxString& title,
 457                                   const wxPoint& pos,
 458                                   const wxSize& sizeOrig,
 459                                   long style,
 460                                   const wxString &name )
 461 {
 462     // always create a frame of some reasonable, even if arbitrary, size (at
 463     // least for MSW compatibility)
 464     wxSize size = sizeOrig;
 465     size.x = WidthDefault(size.x);
 466     size.y = HeightDefault(size.y);
 467
 468     wxTopLevelWindows.Append( this );
 469
 470     m_needParent = false;
 471
 472     if (!PreCreation( parent, pos, size ) ||
 473         !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
 474     {
 475         wxFAIL_MSG( wxT("wxTopLevelWindowGTK creation failed") );
 476         return false;
 477     }
 478
 479     m_title = title;
 480
 481     m_insertCallback = (wxInsertChildFunction) wxInsertChildInTopLevelWindow;
 482
 483     // NB: m_widget may be !=NULL if it was created by derived class' Create,
 484     //     e.g. in wxTaskBarIconAreaGTK
 485     if (m_widget == NULL)
 486     {
 487         if (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG)
 488         {
 489             m_widget = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 490             // Tell WM that this is a dialog window and make it center
 491             // on parent by default (this is what GtkDialog ctor does):
 492             gtk_window_set_type_hint(GTK_WINDOW(m_widget),
 493                                      GDK_WINDOW_TYPE_HINT_DIALOG);
 494             gtk_window_set_position(GTK_WINDOW(m_widget),
 495                                     GTK_WIN_POS_CENTER_ON_PARENT);
 496         }
 497         else
 498         {
 499             m_widget = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 500 #if GTK_CHECK_VERSION(2,1,0)
 501             if (!gtk_check_version(2,1,0))
 502             {
 503                 if (style & wxFRAME_TOOL_WINDOW)
 504                 {
 505                     gtk_window_set_type_hint(GTK_WINDOW(m_widget),
 506                                              GDK_WINDOW_TYPE_HINT_UTILITY);
 507
 508                     // On some WMs, like KDE, a TOOL_WINDOW will still show
 509                     // on the taskbar, but on Gnome a TOOL_WINDOW will not.
 510                     // For consistency between WMs and with Windows, we
 511                     // should set the NO_TASKBAR flag which will apply
 512                     // the set_skip_taskbar_hint if it is available,
 513                     // ensuring no taskbar entry will appear.
 514                     style |= wxFRAME_NO_TASKBAR;
 515                 }
 516             }
 517 #endif
 518         }
 519     }
 520
 521     wxWindow *topParent = wxGetTopLevelParent(m_parent);
 522     if (topParent && (((GTK_IS_WINDOW(topParent->m_widget)) &&
 523                        (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG)) ||
 524                        (style & wxFRAME_FLOAT_ON_PARENT)))
 525     {
 526         gtk_window_set_transient_for( GTK_WINDOW(m_widget),
 527                                       GTK_WINDOW(topParent->m_widget) );
 528     }
 529
 530 #if GTK_CHECK_VERSION(2,2,0)
 531     if (!gtk_check_version(2,2,0))
 532     {
 533         if (style & wxFRAME_NO_TASKBAR)
 534         {
 535             gtk_window_set_skip_taskbar_hint(GTK_WINDOW(m_widget), TRUE);
 536         }
 537     }
 538 #endif
 539
 540 #ifdef __WXGTK24__
 541     if (!gtk_check_version(2,4,0))
 542     {
 543         if (style & wxSTAY_ON_TOP)
 544         {
 545             gtk_window_set_keep_above(GTK_WINDOW(m_widget), TRUE);
 546         }
 547     }
 548 #endif
 549
 550 #if 0
 551     if (!name.empty())
 552         gtk_window_set_role( GTK_WINDOW(m_widget), wxGTK_CONV( name ) );
 553 #endif
 554
 555     gtk_window_set_title( GTK_WINDOW(m_widget), wxGTK_CONV( title ) );
 556     GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
 557
 558     g_signal_connect (m_widget, "delete_event",
 559                       G_CALLBACK (gtk_frame_delete_callback), this);
 560
 561     // m_mainWidget holds the toolbar, the menubar and the client area
 562     m_mainWidget = gtk_pizza_new();
 563     gtk_widget_show( m_mainWidget );
 564     GTK_WIDGET_UNSET_FLAGS( m_mainWidget, GTK_CAN_FOCUS );
 565     gtk_container_add( GTK_CONTAINER(m_widget), m_mainWidget );
 566
 567     if (m_miniEdge == 0) // wxMiniFrame has its own version.
 568     {
 569        // For m_mainWidget themes
 570        g_signal_connect (m_mainWidget, "expose_event",
 571                          G_CALLBACK (gtk_window_expose_callback), this);
 572     }
 573
 574     // m_wxwindow only represents the client area without toolbar and menubar
 575     m_wxwindow = gtk_pizza_new();
 576     gtk_widget_show( m_wxwindow );
 577     gtk_container_add( GTK_CONTAINER(m_mainWidget), m_wxwindow );
 578
 579     // we donm't allow the frame to get the focus as otherwise
 580     // the frame will grab it at arbitrary focus changes
 581     GTK_WIDGET_UNSET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );
 582
 583     if (m_parent) m_parent->AddChild( this );
 584
 585     // the user resized the frame by dragging etc.
 586     g_signal_connect (m_widget, "size_allocate",
 587                       G_CALLBACK (gtk_frame_size_callback), this);
 588
 589     PostCreation();
 590
 591     if ((m_x != -1) || (m_y != -1))
 592         gtk_widget_set_uposition( m_widget, m_x, m_y );
 593
 594     gtk_window_set_default_size( GTK_WINDOW(m_widget), m_width, m_height );
 595
 596     //  we cannot set MWM hints and icons before the widget has
 597     //  been realized, so we do this directly after realization
 598     g_signal_connect (m_widget, "realize",
 599                       G_CALLBACK (gtk_frame_realized_callback), this);
 600
 601     // map and unmap for iconized state
 602     g_signal_connect (m_widget, "map_event",
 603                       G_CALLBACK (gtk_frame_map_callback), this);
 604     g_signal_connect (m_widget, "unmap_event",
 605                       G_CALLBACK (gtk_frame_unmap_callback), this);
 606
 607     // the only way to get the window size is to connect to this event
 608     g_signal_connect (m_widget, "configure_event",
 609                       G_CALLBACK (gtk_frame_configure_callback), this);
 610
 611     // disable native tab traversal
 612     g_signal_connect (m_widget, "focus",
 613                       G_CALLBACK (gtk_frame_focus_callback), this);
 614
 615     // activation
 616     g_signal_connect_after (m_widget, "focus_in_event",
 617                       G_CALLBACK (gtk_frame_focus_in_callback), this);
 618     g_signal_connect_after (m_widget, "focus_out_event",
 619                       G_CALLBACK (gtk_frame_focus_out_callback), this);
 620
 621     // decorations
 622     if ((style & wxSIMPLE_BORDER) || (style & wxNO_BORDER))
 623     {
 624         m_gdkDecor = 0;
 625         m_gdkFunc = 0;
 626     }
 627     else
 628     if (m_miniEdge > 0)
 629     {
 630         m_gdkDecor = 0;
 631         m_gdkFunc = 0;
 632
 633         if ((style & wxRESIZE_BORDER) != 0)
 634            m_gdkFunc |= GDK_FUNC_RESIZE;
 635     }
 636     else
 637     {
 638         m_gdkDecor = (long) GDK_DECOR_BORDER;
 639         m_gdkFunc = (long) GDK_FUNC_MOVE;
 640
 641         // All this is for Motif Window Manager "hints" and is supposed to be
 642         // recognized by other WMs as well.
 643         if ((style & wxCAPTION) != 0)
 644         {
 645             m_gdkDecor |= GDK_DECOR_TITLE;
 646         }
 647         if ((style & wxCLOSE_BOX) != 0)
 648         {
 649             m_gdkFunc |= GDK_FUNC_CLOSE;
 650         }
 651         if ((style & wxSYSTEM_MENU) != 0)
 652         {
 653             m_gdkDecor |= GDK_DECOR_MENU;
 654         }
 655         if ((style & wxMINIMIZE_BOX) != 0)
 656         {
 657             m_gdkFunc |= GDK_FUNC_MINIMIZE;
 658             m_gdkDecor |= GDK_DECOR_MINIMIZE;
 659         }
 660         if ((style & wxMAXIMIZE_BOX) != 0)
 661         {
 662             m_gdkFunc |= GDK_FUNC_MAXIMIZE;
 663             m_gdkDecor |= GDK_DECOR_MAXIMIZE;
 664         }
 665         if ((style & wxRESIZE_BORDER) != 0)
 666         {
 667            m_gdkFunc |= GDK_FUNC_RESIZE;
 668            m_gdkDecor |= GDK_DECOR_RESIZEH;
 669         }
 670     }
 671
 672     return true;
 673 }
 674
 675 wxTopLevelWindowGTK::~wxTopLevelWindowGTK()
 676 {
 677     if (m_grabbed)
 678     {
 679         wxFAIL_MSG(_T("Window still grabbed"));
 680         RemoveGrab();
 681     }
 682
 683     m_isBeingDeleted = true;
 684
 685     // it may also be GtkScrolledWindow in the case of an MDI child
 686     if (GTK_IS_WINDOW(m_widget))
 687     {
 688         gtk_window_set_focus( GTK_WINDOW(m_widget), NULL );
 689     }
 690
 691     if (g_activeFrame == this)
 692         g_activeFrame = NULL;
 693     if (g_lastActiveFrame == this)
 694         g_lastActiveFrame = NULL;
 695 }
 696
 697 bool wxTopLevelWindowGTK::EnableCloseButton( bool enable )
 698 {
 699     if (enable)
 700         m_gdkFunc |= GDK_FUNC_CLOSE;
 701     else
 702         m_gdkFunc &= ~GDK_FUNC_CLOSE;
 703
 704     if (GTK_WIDGET_REALIZED(m_widget) && (m_widget->window))
 705         gdk_window_set_functions( m_widget->window, (GdkWMFunction)m_gdkFunc );
 706
 707     return true;
 708 }
 709
 710 bool wxTopLevelWindowGTK::ShowFullScreen(bool show, long style )
 711 {
 712     if (show == m_fsIsShowing)
 713         return false; // return what?
 714
 715     m_fsIsShowing = show;
 716
 717     wxX11FullScreenMethod method =
 718         wxGetFullScreenMethodX11((WXDisplay*)GDK_DISPLAY(),
 719                                  (WXWindow)GDK_ROOT_WINDOW());
 720
 721 #if GTK_CHECK_VERSION(2,2,0)
 722     // NB: gtk_window_fullscreen() uses freedesktop.org's WMspec extensions
 723     //     to switch to fullscreen, which is not always available. We must
 724     //     check if WM supports the spec and use legacy methods if it
 725     //     doesn't.
 726     if ( (method == wxX11_FS_WMSPEC) && !gtk_check_version(2,2,0) )
 727     {
 728         if (show)
 729         {
 730             m_fsSaveFlag = style;
 731             gtk_window_fullscreen( GTK_WINDOW( m_widget ) );
 732         }
 733         else
 734         {
 735             m_fsSaveFlag = 0;
 736             gtk_window_unfullscreen( GTK_WINDOW( m_widget ) );
 737         }
 738     }
 739     else
 740 #endif // GTK+ >= 2.2.0
 741     {
 742         GdkWindow *window = m_widget->window;
 743
 744         if (show)
 745         {
 746             m_fsSaveFlag = style;
 747             GetPosition( &m_fsSaveFrame.x, &m_fsSaveFrame.y );
 748             GetSize( &m_fsSaveFrame.width, &m_fsSaveFrame.height );
 749
 750             int screen_width,screen_height;
 751             wxDisplaySize( &screen_width, &screen_height );
 752
 753             gint client_x, client_y, root_x, root_y;
 754             gint width, height;
 755
 756             if (method != wxX11_FS_WMSPEC)
 757             {
 758                 // don't do it always, Metacity hates it
 759                 m_fsSaveGdkFunc = m_gdkFunc;
 760                 m_fsSaveGdkDecor = m_gdkDecor;
 761                 m_gdkFunc = m_gdkDecor = 0;
 762                 gdk_window_set_decorations(window, (GdkWMDecoration)0);
 763                 gdk_window_set_functions(window, (GdkWMFunction)0);
 764             }
 765
 766             gdk_window_get_origin (m_widget->window, &root_x, &root_y);
 767             gdk_window_get_geometry (m_widget->window, &client_x, &client_y,
 768                          &width, &height, NULL);
 769
 770             gdk_window_move_resize (m_widget->window, -client_x, -client_y,
 771                         screen_width + 1, screen_height + 1);
 772
 773             wxSetFullScreenStateX11((WXDisplay*)GDK_DISPLAY(),
 774                                     (WXWindow)GDK_ROOT_WINDOW(),
 775                                     (WXWindow)GDK_WINDOW_XWINDOW(window),
 776                                     show, &m_fsSaveFrame, method);
 777         }
 778         else // hide
 779         {
 780             m_fsSaveFlag = 0;
 781             if (method != wxX11_FS_WMSPEC)
 782             {
 783                 // don't do it always, Metacity hates it
 784                 m_gdkFunc = m_fsSaveGdkFunc;
 785                 m_gdkDecor = m_fsSaveGdkDecor;
 786                 gdk_window_set_decorations(window, (GdkWMDecoration)m_gdkDecor);
 787                 gdk_window_set_functions(window, (GdkWMFunction)m_gdkFunc);
 788             }
 789
 790             wxSetFullScreenStateX11((WXDisplay*)GDK_DISPLAY(),
 791                                     (WXWindow)GDK_ROOT_WINDOW(),
 792                                     (WXWindow)GDK_WINDOW_XWINDOW(window),
 793                                     show, &m_fsSaveFrame, method);
 794
 795             SetSize(m_fsSaveFrame.x, m_fsSaveFrame.y,
 796                     m_fsSaveFrame.width, m_fsSaveFrame.height);
 797         }
 798     }
 799
 800     // documented behaviour is to show the window if it's still hidden when
 801     // showing it full screen
 802     if ( show && !IsShown() )
 803         Show();
 804
 805     return true;
 806 }
 807
 808 // ----------------------------------------------------------------------------
 809 // overridden wxWindow methods
 810 // ----------------------------------------------------------------------------
 811
 812 bool wxTopLevelWindowGTK::Show( bool show )
 813 {
 814     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 815
 816     if (show == IsShown())
 817         return true;
 818
 819     if (show && !m_sizeSet)
 820     {
 821         /* by calling GtkOnSize here, we don't have to call
 822            either after showing the frame, which would entail
 823            much ugly flicker or from within the size_allocate
 824            handler, because GTK 1.1.X forbids that. */
 825
 826         GtkOnSize();
 827     }
 828
 829     // This seems no longer to be needed and the call
 830     // itself is deprecated.
 831     //
 832     //if (show)
 833     //    gtk_widget_set_uposition( m_widget, m_x, m_y );
 834
 835     return wxWindow::Show( show );
 836 }
 837
 838 void wxTopLevelWindowGTK::Raise()
 839 {
 840     gtk_window_present( GTK_WINDOW( m_widget ) );
 841 }
 842
 843 void wxTopLevelWindowGTK::DoMoveWindow(int WXUNUSED(x), int WXUNUSED(y), int WXUNUSED(width), int WXUNUSED(height) )
 844 {
 845     wxFAIL_MSG( wxT("DoMoveWindow called for wxTopLevelWindowGTK") );
 846 }
 847
 848 // ----------------------------------------------------------------------------
 849 // window geometry
 850 // ----------------------------------------------------------------------------
 851
 852 void wxTopLevelWindowGTK::GTKDoSetSize(int width, int height)
 853 {
 854     // avoid recursions
 855     if (m_resizing)
 856         return;
 857     m_resizing = true;
 858
 859     int old_width = m_width;
 860     int old_height = m_height;
 861
 862     if ( width != -1 )
 863         m_width = width;
 864     if ( height != -1 )
 865         m_height = height;
 866
 867     // GPE's window manager doesn't like size hints at all, esp. when the user
 868     // has to use the virtual keyboard, so don't constrain size there
 869 #ifndef __WXGPE__
 870     int minWidth = GetMinWidth(),
 871         minHeight = GetMinHeight(),
 872         maxWidth = GetMaxWidth(),
 873         maxHeight = GetMaxHeight();
 874
 875     if ( minWidth != -1 && m_width < minWidth )
 876         m_width = minWidth;
 877     if ( minHeight != -1 && m_height < minHeight )
 878         m_height = minHeight;
 879     if ( maxWidth != -1 && m_width > maxWidth )
 880         m_width = maxWidth;
 881     if ( maxHeight != -1 && m_height > maxHeight )
 882         m_height = maxHeight;
 883 #endif // __WXGPE__
 884
 885     if ( m_width != old_width || m_height != old_height )
 886     {
 887         gtk_window_resize( GTK_WINDOW(m_widget), m_width, m_height );
 888
 889         /* we set the size in GtkOnSize, i.e. mostly the actual resizing is
 890            done either directly before the frame is shown or in idle time
 891            so that different calls to SetSize() don't lead to flicker. */
 892         m_sizeSet = false;
 893     }
 894
 895     m_resizing = false;
 896 }
 897
 898 void wxTopLevelWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags )
 899 {
 900     wxCHECK_RET( m_widget, wxT("invalid frame") );
 901
 902     // this shouldn't happen: wxFrame, wxMDIParentFrame and wxMDIChildFrame have m_wxwindow
 903     wxASSERT_MSG( (m_wxwindow != NULL), wxT("invalid frame") );
 904
 905
 906     // deal with the position first
 907     int old_x = m_x;
 908     int old_y = m_y;
 909
 910     if ( !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE) )
 911     {
 912         // -1 means "use existing" unless the flag above is specified
 913         if ( x != -1 )
 914             m_x = x;
 915         if ( y != -1 )
 916             m_y = y;
 917     }
 918     else // wxSIZE_ALLOW_MINUS_ONE
 919     {
 920         m_x = x;
 921         m_y = y;
 922     }
 923
 924     if ( m_x != old_x || m_y != old_y )
 925     {
 926         gtk_window_move( GTK_WINDOW(m_widget), m_x, m_y );
 927     }
 928
 929
 930     // and now change the size: as we want to set the size of the entire
 931     // window, including decorations, we must adjust the size passed to
 932     // GTKDoSetSize() which takes with the size of undecorated frame only
 933     if ( width != -1 || height != -1 )
 934     {
 935         int wTotal,
 936             hTotal;
 937         DoGetSize(&wTotal, &hTotal);
 938
 939         int wUndec,
 940             hUndec;
 941         wxTopLevelWindowBase::DoGetSize(&wUndec, &hUndec);
 942
 943         if ( width != -1 )
 944             width -= wTotal - wUndec;
 945         if ( height != -1 )
 946             height -= hTotal - hUndec;
 947     }
 948
 949     GTKDoSetSize(width, height);
 950 }
 951
 952 void wxTopLevelWindowGTK::DoGetSize(int *width, int *height) const
 953 {
 954     wxCHECK_RET( m_widget, wxT("invalid frame") );
 955
 956     if ( !m_widget->window )
 957     {
 958         // this can happen if we're called before the window is realized, so
 959         // don't assert but just return the stored values
 960         wxTopLevelWindowBase::DoGetSize(width, height);
 961         return;
 962     }
 963
 964     GdkRectangle rect;
 965     gdk_window_get_frame_extents(m_widget->window, &rect);
 966
 967     if ( width )
 968         *width = rect.width;
 969     if ( height )
 970         *height = rect.height;
 971 }
 972
 973 void wxTopLevelWindowGTK::DoGetClientSize( int *width, int *height ) const
 974 {
 975     if ( IsIconized() )
 976     {
 977         // for consistency with wxMSW, client area is supposed to be empty for
 978         // the iconized windows
 979         if ( width )
 980             *width = 0;
 981         if ( height )
 982             *height = 0;
 983
 984         return;
 985     }
 986
 987     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
 988
 989     if (height)
 990     {
 991         *height = m_height - 2 * m_miniEdge - m_miniTitle;
 992         if (*height < 0)
 993             *height = 0;
 994     }
 995     if (width)
 996     {
 997         *width = m_width - 2 * m_miniEdge;
 998         if (*width < 0)
 999             *width = 0;
1000     }
1001 }
1002
1003 void wxTopLevelWindowGTK::DoSetClientSize( int width, int height )
1004 {
1005     GTKDoSetSize(width + m_miniEdge*2, height  + m_miniEdge*2 + m_miniTitle);
1006 }
1007
1008 void wxTopLevelWindowGTK::DoSetSizeHints( int minW, int minH,
1009                                           int maxW, int maxH,
1010                                           int incW, int incH )
1011 {
1012     wxTopLevelWindowBase::DoSetSizeHints( minW, minH, maxW, maxH, incW, incH );
1013
1014     const wxSize minSize = GetMinSize();
1015     const wxSize maxSize = GetMaxSize();
1016     GdkGeometry hints;
1017     int hints_mask = 0;
1018     if (minSize.x > 0 || minSize.y > 0)
1019     {
1020         hints_mask |= GDK_HINT_MIN_SIZE;
1021         hints.min_width  = minSize.x > 0 ? minSize.x : 0;
1022         hints.min_height = minSize.y > 0 ? minSize.y : 0;
1023     }
1024     if (maxSize.x > 0 || maxSize.y > 0)
1025     {
1026         hints_mask |= GDK_HINT_MAX_SIZE;
1027         hints.max_width  = maxSize.x > 0 ? maxSize.x : INT_MAX;
1028         hints.max_height = maxSize.y > 0 ? maxSize.y : INT_MAX;
1029     }
1030     if (incW > 0 || incH > 0)
1031     {
1032         hints_mask |= GDK_HINT_RESIZE_INC;
1033         hints.width_inc  = incW > 0 ? incW : 1;
1034         hints.height_inc = incH > 0 ? incH : 1;
1035     }
1036     gtk_window_set_geometry_hints(
1037         (GtkWindow*)m_widget, NULL, &hints, (GdkWindowHints)hints_mask);
1038 }
1039
1040
1041 void wxTopLevelWindowGTK::GtkOnSize()
1042 {
1043     // avoid recursions
1044     if (m_resizing) return;
1045     m_resizing = true;
1046
1047     if ( m_wxwindow == NULL ) return;
1048
1049     /* wxMDIChildFrame derives from wxFrame but it _is_ a wxWindow as it uses
1050        wxWindow::Create to create it's GTK equivalent. m_mainWidget is only
1051        set in wxFrame::Create so it is used to check what kind of frame we
1052        have here. if m_mainWidget is NULL it is a wxMDIChildFrame and so we
1053        skip the part which handles m_frameMenuBar, m_frameToolBar and (most
1054        importantly) m_mainWidget */
1055
1056     int minWidth = GetMinWidth(),
1057         minHeight = GetMinHeight(),
1058         maxWidth = GetMaxWidth(),
1059         maxHeight = GetMaxHeight();
1060
1061 #ifdef __WXGPE__
1062     // GPE's window manager doesn't like size hints
1063     // at all, esp. when the user has to use the
1064     // virtual keyboard.
1065     minWidth = -1;
1066     minHeight = -1;
1067     maxWidth = -1;
1068     maxHeight = -1;
1069 #endif
1070
1071     if ((minWidth != -1) && (m_width < minWidth)) m_width = minWidth;
1072     if ((minHeight != -1) && (m_height < minHeight)) m_height = minHeight;
1073     if ((maxWidth != -1) && (m_width > maxWidth)) m_width = maxWidth;
1074     if ((maxHeight != -1) && (m_height > maxHeight)) m_height = maxHeight;
1075
1076     if (m_mainWidget)
1077     {
1078         // m_mainWidget holds the menubar, the toolbar and the client area,
1079         // which is represented by m_wxwindow.
1080         int client_x = m_miniEdge;
1081         int client_y = m_miniEdge + m_miniTitle;
1082         int client_w = m_width - 2*m_miniEdge;
1083         int client_h = m_height - 2*m_miniEdge - m_miniTitle;
1084         if (client_w < 0)
1085             client_w = 0;
1086         if (client_h < 0)
1087             client_h = 0;
1088
1089         // Let the parent perform the resize
1090         gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
1091                               m_wxwindow,
1092                               client_x, client_y, client_w, client_h );
1093     }
1094     else
1095     {
1096         // If there is no m_mainWidget between m_widget and m_wxwindow there
1097         // is no need to set the size or position of m_wxwindow.
1098     }
1099
1100     m_sizeSet = true;
1101
1102     // send size event to frame
1103     wxSizeEvent event( wxSize(m_width,m_height), GetId() );
1104     event.SetEventObject( this );
1105     GetEventHandler()->ProcessEvent( event );
1106
1107     m_resizing = false;
1108 }
1109
1110 void wxTopLevelWindowGTK::OnInternalIdle()
1111 {
1112     if (!m_sizeSet && GTK_WIDGET_REALIZED(m_wxwindow))
1113     {
1114         GtkOnSize();
1115
1116         // we'll come back later
1117         if (g_isIdle)
1118             wxapp_install_idle_handler();
1119         return;
1120     }
1121
1122     // set the focus if not done yet and if we can already do it
1123     if ( GTK_WIDGET_REALIZED(m_wxwindow) )
1124     {
1125         if ( g_delayedFocus &&
1126              wxGetTopLevelParent((wxWindow*)g_delayedFocus) == this )
1127         {
1128             wxLogTrace(_T("focus"),
1129                        _T("Setting focus from wxTLW::OnIdle() to %s(%s)"),
1130                        g_delayedFocus->GetClassInfo()->GetClassName(),
1131                        g_delayedFocus->GetLabel().c_str());
1132
1133             g_delayedFocus->SetFocus();
1134             g_delayedFocus = NULL;
1135         }
1136     }
1137
1138     wxWindow::OnInternalIdle();
1139
1140     // Synthetize activate events.
1141     if ( g_sendActivateEvent != -1 )
1142     {
1143         bool activate = g_sendActivateEvent != 0;
1144
1145         // if (!activate) wxPrintf( wxT("de") );
1146         // wxPrintf( wxT("activate\n") );
1147
1148         // do it only once
1149         g_sendActivateEvent = -1;
1150
1151         wxTheApp->SetActive(activate, (wxWindow *)g_lastActiveFrame);
1152     }
1153 }
1154
1155 // ----------------------------------------------------------------------------
1156 // frame title/icon
1157 // ----------------------------------------------------------------------------
1158
1159 void wxTopLevelWindowGTK::SetTitle( const wxString &title )
1160 {
1161     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
1162
1163     if ( title == m_title )
1164         return;
1165
1166     m_title = title;
1167
1168     gtk_window_set_title( GTK_WINDOW(m_widget), wxGTK_CONV( title ) );
1169 }
1170
1171 void wxTopLevelWindowGTK::SetIcon( const wxIcon &icon )
1172 {
1173     SetIcons( wxIconBundle( icon ) );
1174 }
1175
1176 void wxTopLevelWindowGTK::SetIcons( const wxIconBundle &icons )
1177 {
1178     wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
1179
1180     wxTopLevelWindowBase::SetIcons( icons );
1181
1182     GList *list = NULL;
1183     size_t max = icons.m_icons.GetCount();
1184
1185     for (size_t i = 0; i < max; i++)
1186     {
1187         if (icons.m_icons[i].Ok())
1188         {
1189             list = g_list_prepend(list, icons.m_icons[i].GetPixbuf());
1190         }
1191     }
1192     gtk_window_set_icon_list(GTK_WINDOW(m_widget), list);
1193     g_list_free(list);
1194 }
1195
1196 // ----------------------------------------------------------------------------
1197 // frame state: maximized/iconized/normal
1198 // ----------------------------------------------------------------------------
1199
1200 void wxTopLevelWindowGTK::Maximize(bool maximize)
1201 {
1202     if (maximize)
1203         gtk_window_maximize( GTK_WINDOW( m_widget ) );
1204     else
1205         gtk_window_unmaximize( GTK_WINDOW( m_widget ) );
1206 }
1207
1208 bool wxTopLevelWindowGTK::IsMaximized() const
1209 {
1210     if(!m_widget->window)
1211         return false;
1212
1213     return gdk_window_get_state(m_widget->window) & GDK_WINDOW_STATE_MAXIMIZED;
1214 }
1215
1216 void wxTopLevelWindowGTK::Restore()
1217 {
1218     // "Present" seems similar enough to "restore"
1219     gtk_window_present( GTK_WINDOW( m_widget ) );
1220 }
1221
1222 void wxTopLevelWindowGTK::Iconize( bool iconize )
1223 {
1224     if (iconize)
1225         gtk_window_iconify( GTK_WINDOW( m_widget ) );
1226     else
1227         gtk_window_deiconify( GTK_WINDOW( m_widget ) );
1228 }
1229
1230 bool wxTopLevelWindowGTK::IsIconized() const
1231 {
1232     return m_isIconized;
1233 }
1234
1235 void wxTopLevelWindowGTK::SetIconizeState(bool iconize)
1236 {
1237     if ( iconize != m_isIconized )
1238     {
1239         m_isIconized = iconize;
1240         (void)SendIconizeEvent(iconize);
1241     }
1242 }
1243
1244 void wxTopLevelWindowGTK::AddGrab()
1245 {
1246     if (!m_grabbed)
1247     {
1248         m_grabbed = true;
1249         gtk_grab_add( m_widget );
1250         wxEventLoop().Run();
1251         gtk_grab_remove( m_widget );
1252     }
1253 }
1254
1255 void wxTopLevelWindowGTK::RemoveGrab()
1256 {
1257     if (m_grabbed)
1258     {
1259         gtk_main_quit();
1260         m_grabbed = false;
1261     }
1262 }
1263
1264
1265 // helper
1266 static bool do_shape_combine_region(GdkWindow* window, const wxRegion& region)
1267 {
1268     if (window)
1269     {
1270         if (region.IsEmpty())
1271         {
1272             gdk_window_shape_combine_mask(window, NULL, 0, 0);
1273         }
1274         else
1275         {
1276             gdk_window_shape_combine_region(window, region.GetRegion(), 0, 0);
1277             return true;
1278         }
1279     }
1280     return false;
1281 }
1282
1283
1284 bool wxTopLevelWindowGTK::SetShape(const wxRegion& region)
1285 {
1286     wxCHECK_MSG( HasFlag(wxFRAME_SHAPED), false,
1287                  _T("Shaped windows must be created with the wxFRAME_SHAPED style."));
1288
1289     GdkWindow *window = NULL;
1290     if (m_wxwindow)
1291     {
1292         window = GTK_PIZZA(m_wxwindow)->bin_window;
1293         do_shape_combine_region(window, region);
1294     }
1295     window = m_widget->window;
1296     return do_shape_combine_region(window, region);
1297 }
1298
1299 bool wxTopLevelWindowGTK::IsActive()
1300 {
1301     return (this == (wxTopLevelWindowGTK*)g_activeFrame);
1302 }
1303
1304 void wxTopLevelWindowGTK::RequestUserAttention(int flags)
1305 {
1306     bool new_hint_value = false;
1307
1308     // FIXME: This is a workaround to focus handling problem
1309     // If RequestUserAttention is called for example right after a wxSleep, OnInternalIdle hasn't
1310     // yet been processed, and the internal focus system is not up to date yet.
1311     // wxYieldIfNeeded ensures the processing of it, but can have unwanted side effects - MR
1312     ::wxYieldIfNeeded();
1313
1314     if(m_urgency_hint >= 0)
1315         g_source_remove(m_urgency_hint);
1316
1317     m_urgency_hint = -2;
1318
1319     if( GTK_WIDGET_REALIZED(m_widget) && !IsActive() )
1320     {
1321         new_hint_value = true;
1322
1323         if (flags & wxUSER_ATTENTION_INFO)
1324         {
1325             m_urgency_hint = g_timeout_add(5000, (GSourceFunc)gtk_frame_urgency_timer_callback, this);
1326         } else {
1327             m_urgency_hint = -1;
1328         }
1329     }
1330
1331 #if GTK_CHECK_VERSION(2,7,0)
1332     if(!gtk_check_version(2,7,0))
1333         gtk_window_set_urgency_hint(GTK_WINDOW( m_widget ), new_hint_value);
1334     else
1335 #endif
1336         wxgtk_window_set_urgency_hint(GTK_WINDOW( m_widget ), new_hint_value);
1337 }
1338
1339 void wxTopLevelWindowGTK::SetWindowStyleFlag( long style )
1340 {
1341 #if defined(__WXGTK24__) || GTK_CHECK_VERSION(2,2,0)
1342     // Store which styles were changed
1343     long styleChanges = style ^ m_windowStyle;
1344 #endif
1345
1346     // Process wxWindow styles. This also updates the internal variable
1347     // Therefore m_windowStyle bits carry now the _new_ style values
1348     wxWindow::SetWindowStyleFlag(style);
1349
1350     // just return for now if widget does not exist yet
1351     if (!m_widget)
1352         return;
1353
1354 #ifdef __WXGTK24__
1355     if ( (styleChanges & wxSTAY_ON_TOP) && !gtk_check_version(2,4,0) )
1356         gtk_window_set_keep_above(GTK_WINDOW(m_widget), m_windowStyle & wxSTAY_ON_TOP);
1357 #endif // GTK+ 2.4
1358 #if GTK_CHECK_VERSION(2,2,0)
1359     if ( (styleChanges & wxFRAME_NO_TASKBAR) && !gtk_check_version(2,2,0) )
1360     {
1361         gtk_window_set_skip_taskbar_hint(GTK_WINDOW(m_widget), m_windowStyle & wxFRAME_NO_TASKBAR);
1362     }
1363 #endif // GTK+ 2.2
1364 }
1365
1366 #include <X11/Xlib.h>
1367
1368 /* Get the X Window between child and the root window.
1369    This should usually be the WM managed XID */
1370 static Window wxGetTopmostWindowX11(Display *dpy, Window child)
1371 {
1372     Window root, parent;
1373     Window* children;
1374     unsigned int nchildren;
1375
1376     XQueryTree(dpy, child, &root, &parent, &children, &nchildren);
1377     XFree(children);
1378
1379     while (parent != root) {
1380         child = parent;
1381         XQueryTree(dpy, child, &root, &parent, &children, &nchildren);
1382         XFree(children);
1383     }
1384
1385     return child;
1386 }
1387
1388 bool wxTopLevelWindowGTK::SetTransparent(wxByte alpha)
1389 {
1390     if (!m_widget || !m_widget->window)
1391         return false;
1392
1393     Display* dpy = GDK_WINDOW_XDISPLAY (m_widget->window);
1394     // We need to get the X Window that has the root window as the immediate parent
1395     // and m_widget->window as a child. This should be the X Window that the WM manages and
1396     // from which the opacity property is checked from.
1397     Window win = wxGetTopmostWindowX11(dpy, GDK_WINDOW_XID (m_widget->window));
1398
1399     unsigned int opacity = alpha * 0x1010101;
1400
1401     // Using pure Xlib to not have a GTK version check mess due to gtk2.0 not having GdkDisplay
1402     if (alpha == 0xff)
1403         XDeleteProperty(dpy, win, XInternAtom(dpy, "_NET_WM_WINDOW_OPACITY", False));
1404     else
1405         XChangeProperty(dpy, win, XInternAtom(dpy, "_NET_WM_WINDOW_OPACITY", False),
1406                         XA_CARDINAL, 32, PropModeReplace,
1407                         (unsigned char *) &opacity, 1L);
1408     XSync(dpy, False);
1409     return true;
1410 }
1411
1412 bool wxTopLevelWindowGTK::CanSetTransparent()
1413 {
1414 #if GTK_CHECK_VERSION(2,10,0)
1415     if (!gtk_check_version(2,10,0))
1416     {
1417         return (gtk_widget_is_composited (m_widget));
1418     }
1419     else
1420 #endif // In case of lower versions than gtk+-2.10.0 we could look for _NET_WM_CM_Sn ourselves
1421     {
1422         return false;
1423     }
1424
1425 #if 0 // Don't be optimistic here for the sake of wxAUI
1426     int opcode, event, error;
1427     // Check for the existence of a RGBA visual instead?
1428     return XQueryExtension(gdk_x11_get_default_xdisplay (),
1429                            "Composite", &opcode, &event, &error);
1430 #endif
1431 }