src/gtk/toplevel.cpp

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