]> git.saurik.com Git - wxWidgets.git/blame - src/gtk/toplevel.cpp
guard code for mac / quickdraw
[wxWidgets.git] / src / gtk / toplevel.cpp
CommitLineData
7d9f12f3 1/////////////////////////////////////////////////////////////////////////////
cb8cc250 2// Name: src/gtk/toplevel.cpp
7d9f12f3
VS
3// Purpose:
4// Author: Robert Roebling
5// Id: $Id$
6// Copyright: (c) 1998 Robert Roebling
65571936 7// Licence: wxWindows licence
7d9f12f3
VS
8/////////////////////////////////////////////////////////////////////////////
9
93763ad5
WS
10// For compilers that support precompilation, includes "wx.h".
11#include "wx/wxprec.h"
12
7d9f12f3
VS
13// ============================================================================
14// declarations
15// ============================================================================
16
17// ----------------------------------------------------------------------------
18// headers
19// ----------------------------------------------------------------------------
20
7d9f12f3
VS
21#ifdef __VMS
22#define XIconifyWindow XICONIFYWINDOW
23#endif
24
e1bf3ad3 25#include "wx/toplevel.h"
e4db172a
WS
26
27#ifndef WX_PRECOMP
d281df50
PC
28 #include "wx/frame.h"
29 #include "wx/icon.h"
e4db172a 30 #include "wx/log.h"
670f9935 31 #include "wx/app.h"
e4db172a
WS
32#endif
33
fab591c5 34#include "wx/gtk/private.h"
924b84ab 35#include "wx/evtloop.h"
a95a6eb4 36#include "wx/sysopt.h"
7d9f12f3 37
7d9f12f3 38#include <gtk/gtk.h>
7d9f12f3
VS
39#include <gdk/gdkx.h>
40
41#include "wx/gtk/win_gtk.h"
42
f618020a
MB
43#include "wx/unix/utilsx11.h"
44
8a9650ea
RR
45// XA_CARDINAL
46#include <X11/Xatom.h>
47
e2f3bc41
VZ
48#if wxUSE_LIBHILDON
49 #include <hildon-widgets/hildon-program.h>
50 #include <hildon-widgets/hildon-window.h>
51#endif // wxUSE_LIBHILDON
52
7d9f12f3
VS
53// ----------------------------------------------------------------------------
54// data
55// ----------------------------------------------------------------------------
56
64c11164
VZ
57// this is incremented while a modal dialog is shown
58int wxOpenModalDialogsCount = 0;
59
06fda9e8
RR
60extern wxWindowGTK *g_delayedFocus;
61
62// the frame that is currently active (i.e. its child has focus). It is
63// used to generate wxActivateEvents
64static wxTopLevelWindowGTK *g_activeFrame = (wxTopLevelWindowGTK*) NULL;
65static wxTopLevelWindowGTK *g_lastActiveFrame = (wxTopLevelWindowGTK*) NULL;
66
67// if we detect that the app has got/lost the focus, we set this variable to
68// either TRUE or FALSE and an activate event will be sent during the next
69// OnIdle() call and it is reset to -1: this value means that we shouldn't
70// send any activate events at all
0a164d4c 71static int g_sendActivateEvent = -1;
06fda9e8 72
dca92ddf
MR
73//-----------------------------------------------------------------------------
74// RequestUserAttention related functions
75//-----------------------------------------------------------------------------
76
77extern "C" {
78static void wxgtk_window_set_urgency_hint (GtkWindow *win,
79 gboolean setting)
80{
81 wxASSERT_MSG( GTK_WIDGET_REALIZED(win), wxT("wxgtk_window_set_urgency_hint: GdkWindow not realized") );
82 GdkWindow *window = GTK_WIDGET(win)->window;
83 XWMHints *wm_hints;
84
85 wm_hints = XGetWMHints(GDK_WINDOW_XDISPLAY(window), GDK_WINDOW_XWINDOW(window));
86
87 if (!wm_hints)
88 wm_hints = XAllocWMHints();
89
90 if (setting)
91 wm_hints->flags |= XUrgencyHint;
92 else
93 wm_hints->flags &= ~XUrgencyHint;
94
95 XSetWMHints(GDK_WINDOW_XDISPLAY(window), GDK_WINDOW_XWINDOW(window), wm_hints);
96 XFree(wm_hints);
97}
98
92ed8bec 99static gboolean gtk_frame_urgency_timer_callback( wxTopLevelWindowGTK *win )
dca92ddf 100{
2ec371fd 101#if GTK_CHECK_VERSION(2,7,0)
dca92ddf 102 if(!gtk_check_version(2,7,0))
ef1a9be4 103 gtk_window_set_urgency_hint(GTK_WINDOW( win->m_widget ), FALSE);
dca92ddf
MR
104 else
105#endif
ef1a9be4 106 wxgtk_window_set_urgency_hint(GTK_WINDOW( win->m_widget ), FALSE);
dca92ddf 107
ef1a9be4 108 win->m_urgency_hint = -2;
dca92ddf
MR
109 return FALSE;
110}
111}
112
06fda9e8
RR
113//-----------------------------------------------------------------------------
114// "focus_in_event"
115//-----------------------------------------------------------------------------
116
865bb325 117extern "C" {
4c20ee63 118static gboolean gtk_frame_focus_in_callback( GtkWidget *widget,
06fda9e8
RR
119 GdkEvent *WXUNUSED(event),
120 wxTopLevelWindowGTK *win )
121{
06fda9e8
RR
122 switch ( g_sendActivateEvent )
123 {
124 case -1:
125 // we've got focus from outside, synthetize wxActivateEvent
126 g_sendActivateEvent = 1;
127 break;
128
129 case 0:
130 // another our window just lost focus, it was already ours before
131 // - don't send any wxActivateEvent
132 g_sendActivateEvent = -1;
133 break;
134 }
135
136 g_activeFrame = win;
137 g_lastActiveFrame = g_activeFrame;
0a164d4c 138
06fda9e8 139 // wxPrintf( wxT("active: %s\n"), win->GetTitle().c_str() );
0a164d4c 140
dca92ddf 141 // MR: wxRequestUserAttention related block
ef1a9be4 142 switch( win->m_urgency_hint )
dca92ddf
MR
143 {
144 default:
92ed8bec 145 g_source_remove( win->m_urgency_hint );
dca92ddf
MR
146 // no break, fallthrough to remove hint too
147 case -1:
2ec371fd 148#if GTK_CHECK_VERSION(2,7,0)
dca92ddf
MR
149 if(!gtk_check_version(2,7,0))
150 gtk_window_set_urgency_hint(GTK_WINDOW( widget ), FALSE);
151 else
152#endif
153 {
154 wxgtk_window_set_urgency_hint(GTK_WINDOW( widget ), FALSE);
155 }
156
ef1a9be4 157 win->m_urgency_hint = -2;
dca92ddf
MR
158 break;
159
160 case -2: break;
161 }
162
06fda9e8 163 wxLogTrace(wxT("activate"), wxT("Activating frame %p (from focus_in)"), g_activeFrame);
0a164d4c 164 wxActivateEvent event(wxEVT_ACTIVATE, true, g_activeFrame->GetId());
06fda9e8
RR
165 event.SetEventObject(g_activeFrame);
166 g_activeFrame->GetEventHandler()->ProcessEvent(event);
167
4c20ee63 168 return FALSE;
06fda9e8 169}
865bb325 170}
06fda9e8
RR
171
172//-----------------------------------------------------------------------------
173// "focus_out_event"
174//-----------------------------------------------------------------------------
175
865bb325 176extern "C" {
e4161a2a
VZ
177static
178gboolean gtk_frame_focus_out_callback(GtkWidget * WXUNUSED(widget),
179 GdkEventFocus *WXUNUSED(gdk_event),
180 wxTopLevelWindowGTK * WXUNUSED(win))
06fda9e8 181{
06fda9e8
RR
182 // if the focus goes out of our app alltogether, OnIdle() will send
183 // wxActivateEvent, otherwise gtk_window_focus_in_callback() will reset
184 // g_sendActivateEvent to -1
185 g_sendActivateEvent = 0;
0a164d4c 186
06fda9e8 187 // wxASSERT_MSG( (g_activeFrame == win), wxT("TLW deactivatd although it wasn't active") );
0a164d4c 188
06fda9e8 189 // wxPrintf( wxT("inactive: %s\n"), win->GetTitle().c_str() );
06fda9e8 190
cc0c05cd
JS
191 if (g_activeFrame)
192 {
193 wxLogTrace(wxT("activate"), wxT("Activating frame %p (from focus_in)"), g_activeFrame);
0a164d4c 194 wxActivateEvent event(wxEVT_ACTIVATE, false, g_activeFrame->GetId());
cc0c05cd
JS
195 event.SetEventObject(g_activeFrame);
196 g_activeFrame->GetEventHandler()->ProcessEvent(event);
197
198 g_activeFrame = NULL;
199 }
0a164d4c 200
4c20ee63 201 return FALSE;
06fda9e8 202}
865bb325 203}
7d9f12f3 204
290cd301
PC
205//-----------------------------------------------------------------------------
206
207// Get cached size of WM decorations for given GdkWMDecoration.
208static wxSize& GetDecorSize(int decor)
209{
210 // In testing, only the title bar and GDK_DECOR_BORDER made a difference.
211 // 4 possible combinations of title bar and border
212 static wxSize size[4];
213
214 int index = 0;
215 // title bar
216 if (decor & (GDK_DECOR_MENU | GDK_DECOR_MINIMIZE | GDK_DECOR_MAXIMIZE | GDK_DECOR_TITLE))
217 index = 1;
218 // border
219 if (decor & GDK_DECOR_BORDER)
220 index |= 2;
221 return size[index];
222}
223
7d9f12f3 224//-----------------------------------------------------------------------------
cca410b3 225// "size_allocate" from m_wxwindow
7d9f12f3
VS
226//-----------------------------------------------------------------------------
227
865bb325 228extern "C" {
cca410b3
PC
229static void
230size_allocate(GtkWidget*, GtkAllocation* alloc, wxTopLevelWindowGTK* win)
7d9f12f3 231{
cca410b3
PC
232 if (win->m_oldClientWidth != alloc->width ||
233 win->m_oldClientHeight != alloc->height)
234 {
235 win->m_oldClientWidth = alloc->width;
236 win->m_oldClientHeight = alloc->height;
0ab0d0e1
PC
237
238 wxSize size(win->m_widget->allocation.width,
239 win->m_widget->allocation.height);
cca410b3 240 if (!win->IsFullScreen())
0ab0d0e1
PC
241 size += win->m_decorSize;
242 win->m_width = size.x;
243 win->m_height = size.y;
244
cca410b3
PC
245 if (!win->IsIconized())
246 {
0ab0d0e1 247 wxSizeEvent event(size, win->GetId());
cca410b3
PC
248 event.SetEventObject(win);
249 win->GetEventHandler()->ProcessEvent(event);
250 }
251 // else the window is currently unmapped, don't generate size events
7d9f12f3
VS
252 }
253}
865bb325 254}
7d9f12f3 255
6e264997
VZ
256// ----------------------------------------------------------------------------
257// "size_request"
258// ----------------------------------------------------------------------------
259
260extern "C" {
290cd301 261static
6e264997
VZ
262void wxgtk_tlw_size_request_callback(GtkWidget * WXUNUSED(widget),
263 GtkRequisition *requisition,
264 wxTopLevelWindowGTK *win)
265{
266 // we must return the size of the window without WM decorations, otherwise
267 // GTK+ gets confused, so don't call just GetSize() here
290cd301 268 win->GTKDoGetSize(&requisition->width, &requisition->height);
6e264997
VZ
269}
270}
290cd301 271
7d9f12f3
VS
272//-----------------------------------------------------------------------------
273// "delete_event"
274//-----------------------------------------------------------------------------
275
865bb325 276extern "C" {
5d4c0833
MR
277static gboolean
278gtk_frame_delete_callback( GtkWidget *WXUNUSED(widget),
279 GdkEvent *WXUNUSED(event),
280 wxTopLevelWindowGTK *win )
7d9f12f3 281{
7d9f12f3 282 if (win->IsEnabled() &&
64c11164 283 (wxOpenModalDialogsCount == 0 || (win->GetExtraStyle() & wxTOPLEVEL_EX_DIALOG) ||
5152b0e5 284 win->IsGrabbed()))
7d9f12f3
VS
285 win->Close();
286
287 return TRUE;
288}
865bb325 289}
7d9f12f3
VS
290
291
292//-----------------------------------------------------------------------------
293// "configure_event"
294//-----------------------------------------------------------------------------
295
865bb325 296extern "C" {
5d4c0833 297static gboolean
dc89b7bf 298gtk_frame_configure_callback( GtkWidget* widget,
5d4c0833
MR
299 GdkEventConfigure *WXUNUSED(event),
300 wxTopLevelWindowGTK *win )
7d9f12f3 301{
48f72114 302 if (!win->m_hasVMT || !win->IsShown())
7d9f12f3
VS
303 return FALSE;
304
dc89b7bf
PC
305 wxPoint point;
306 gtk_window_get_position((GtkWindow*)widget, &point.x, &point.y);
32f2ebbf 307
afde1667
PC
308 win->m_x = point.x;
309 win->m_y = point.y;
310 wxMoveEvent mevent(point, win->GetId());
311 mevent.SetEventObject( win );
312 win->GetEventHandler()->ProcessEvent( mevent );
7d9f12f3
VS
313
314 return FALSE;
315}
865bb325 316}
7d9f12f3
VS
317
318//-----------------------------------------------------------------------------
319// "realize" from m_widget
320//-----------------------------------------------------------------------------
321
e1f14d22
RR
322// we cannot MWM hints and icons before the widget has been realized,
323// so we do this directly after realization
7d9f12f3 324
865bb325 325extern "C" {
7d9f12f3 326static void
6aeb6f2a
VZ
327gtk_frame_realized_callback( GtkWidget * WXUNUSED(widget),
328 wxTopLevelWindowGTK *win )
7d9f12f3 329{
e1f14d22
RR
330 // All this is for Motif Window Manager "hints" and is supposed to be
331 // recognized by other WM as well. Not tested.
82c9f85c 332 gdk_window_set_decorations(win->m_widget->window,
f819b4a3 333 (GdkWMDecoration)win->m_gdkDecor);
82c9f85c 334 gdk_window_set_functions(win->m_widget->window,
f819b4a3 335 (GdkWMFunction)win->m_gdkFunc);
7d9f12f3 336
e1f14d22 337 // GTK's shrinking/growing policy
f819b4a3 338 if ((win->m_gdkFunc & GDK_FUNC_RESIZE) == 0)
43a52404 339 gtk_window_set_resizable(GTK_WINDOW(win->m_widget), FALSE);
7d9f12f3 340 else
8e729eb4 341 gtk_window_set_policy(GTK_WINDOW(win->m_widget), 1, 1, 1);
7d9f12f3 342
e1f14d22 343 // reset the icon
7efaed4d 344 wxIconBundle iconsOld = win->GetIcons();
5a5cdd31 345 if ( !iconsOld.IsEmpty() )
7d9f12f3 346 {
7d9f12f3 347 win->SetIcon( wxNullIcon );
7efaed4d 348 win->SetIcons( iconsOld );
7d9f12f3 349 }
7d9f12f3 350}
865bb325 351}
7d9f12f3
VS
352
353//-----------------------------------------------------------------------------
354// "map_event" from m_widget
355//-----------------------------------------------------------------------------
356
865bb325 357extern "C" {
0e795b05 358static gboolean
290cd301 359gtk_frame_map_callback( GtkWidget* widget,
7d9f12f3
VS
360 GdkEvent * WXUNUSED(event),
361 wxTopLevelWindow *win )
362{
290cd301
PC
363 // Calculate size of WM decorations.
364 // Done here in case WM does not support the _NET_FRAME_EXTENTS property.
365 if (win->IsDecorCacheable() && !win->IsFullScreen())
366 {
367 GdkRectangle rect;
368 gdk_window_get_frame_extents(widget->window, &rect);
369 int w, h;
370 gdk_drawable_get_size(widget->window, &w, &h);
0ab0d0e1
PC
371 const wxSize decorSize = wxSize(rect.width - w, rect.height - h);
372 if (win->m_decorSize != decorSize)
290cd301
PC
373 {
374 // Update window size and frame extents cache
375 win->m_width = rect.width;
376 win->m_height = rect.height;
0ab0d0e1
PC
377 win->m_decorSize = decorSize;
378 GetDecorSize(win->m_gdkDecor) = decorSize;
290cd301
PC
379 }
380 }
381
2a74bd27
PC
382 const bool wasIconized = win->IsIconized();
383
0a164d4c 384 win->SetIconizeState(false);
27242d85 385
2a74bd27
PC
386 if (wasIconized)
387 {
388 // Because GetClientSize() returns (0,0) when IsIconized() is true,
389 // a size event must be generated, just in case GetClientSize() was
390 // called while iconized. This specifically happens when restoring a
391 // tlw that was "rolled up" with some WMs.
392 // Queue a resize rather than sending size event directly to allow
393 // children to be made visible first.
394 win->m_oldClientWidth = 0;
395 gtk_widget_queue_resize(win->m_wxwindow);
396 }
27242d85 397
0e795b05 398 return false;
7d9f12f3 399}
865bb325 400}
7d9f12f3
VS
401
402//-----------------------------------------------------------------------------
403// "unmap_event" from m_widget
404//-----------------------------------------------------------------------------
405
865bb325 406extern "C" {
0e795b05 407static gboolean
7d9f12f3
VS
408gtk_frame_unmap_callback( GtkWidget * WXUNUSED(widget),
409 GdkEvent * WXUNUSED(event),
410 wxTopLevelWindow *win )
411{
cb8cc250 412 win->SetIconizeState(true);
0e795b05 413 return false;
7d9f12f3 414}
865bb325 415}
7d9f12f3 416
290cd301
PC
417//-----------------------------------------------------------------------------
418// "property_notify_event" from m_widget
419//-----------------------------------------------------------------------------
420
421extern "C" {
422static gboolean property_notify_event(
423 GtkWidget*, GdkEventProperty* event, wxTopLevelWindowGTK* win)
424{
425 // Watch for changes to _NET_FRAME_EXTENTS property
426 static GdkAtom property = gdk_atom_intern("_NET_FRAME_EXTENTS", false);
427 if (event->state == GDK_PROPERTY_NEW_VALUE && event->atom == property &&
428 win->IsDecorCacheable() && !win->IsFullScreen())
429 {
ff654490
VZ
430 Atom xproperty = gdk_x11_atom_to_xatom_for_display(
431 gdk_drawable_get_display(event->window), property);
290cd301
PC
432 Atom type;
433 int format;
434 gulong nitems, bytes_after;
435 long* data = NULL;
436 Status status = XGetWindowProperty(
437 gdk_x11_drawable_get_xdisplay(event->window),
438 gdk_x11_drawable_get_xid(event->window),
439 xproperty,
440 0, 4, false, XA_CARDINAL,
441 &type, &format, &nitems, &bytes_after, (guchar**)&data);
442 if (status == Success && data && nitems == 4)
443 {
0ab0d0e1 444 const wxSize decorSize =
290cd301 445 wxSize(int(data[0] + data[1]), int(data[2] + data[3]));
0ab0d0e1 446 if (win->m_decorSize != decorSize)
290cd301
PC
447 {
448 // Update window size and frame extents cache
0ab0d0e1
PC
449 win->m_width += decorSize.x - win->m_decorSize.x;
450 win->m_height += decorSize.y - win->m_decorSize.y;
290cd301
PC
451 if (win->m_width < 0) win->m_width = 0;
452 if (win->m_height < 0) win->m_height = 0;
0ab0d0e1
PC
453 win->m_decorSize = decorSize;
454 GetDecorSize(win->m_gdkDecor) = decorSize;
2a74bd27
PC
455 win->m_oldClientWidth = 0;
456 gtk_widget_queue_resize(win->m_wxwindow);
290cd301
PC
457 }
458 }
459 if (data)
460 XFree(data);
461 }
462 return false;
463}
464}
465
013151c7
JS
466BEGIN_EVENT_TABLE(wxTopLevelWindowGTK, wxTopLevelWindowBase)
467 EVT_SYS_COLOUR_CHANGED(wxTopLevelWindowGTK::OnSysColourChanged)
468END_EVENT_TABLE()
469
470
7d9f12f3
VS
471// ----------------------------------------------------------------------------
472// wxTopLevelWindowGTK creation
473// ----------------------------------------------------------------------------
474
475void wxTopLevelWindowGTK::Init()
476{
7d9f12f3 477 m_mainWidget = (GtkWidget*) NULL;
0a164d4c
WS
478 m_isIconized = false;
479 m_fsIsShowing = false;
480 m_themeEnabled = true;
f819b4a3 481 m_gdkDecor = m_gdkFunc = 0;
0a164d4c 482 m_grabbed = false;
dca92ddf 483
ef1a9be4 484 m_urgency_hint = -2;
7d9f12f3
VS
485}
486
487bool wxTopLevelWindowGTK::Create( wxWindow *parent,
f819b4a3
VS
488 wxWindowID id,
489 const wxString& title,
490 const wxPoint& pos,
491 const wxSize& sizeOrig,
492 long style,
493 const wxString &name )
7d9f12f3
VS
494{
495 // always create a frame of some reasonable, even if arbitrary, size (at
496 // least for MSW compatibility)
497 wxSize size = sizeOrig;
1111cedc 498 size.x = WidthDefault(size.x);
66202a7e 499 size.y = HeightDefault(size.y);
7d9f12f3
VS
500
501 wxTopLevelWindows.Append( this );
502
7d9f12f3
VS
503 if (!PreCreation( parent, pos, size ) ||
504 !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
505 {
506 wxFAIL_MSG( wxT("wxTopLevelWindowGTK creation failed") );
0a164d4c 507 return false;
7d9f12f3
VS
508 }
509
510 m_title = title;
511
63c5efa3
VS
512 // NB: m_widget may be !=NULL if it was created by derived class' Create,
513 // e.g. in wxTaskBarIconAreaGTK
514 if (m_widget == NULL)
515 {
e2f3bc41
VZ
516#if wxUSE_LIBHILDON
517 // we must create HildonWindow and not a normal GtkWindow as the latter
518 // doesn't look correctly in Maemo environment and it must also be
519 // registered with the main program object
520 m_widget = hildon_window_new();
521 hildon_program_add_window(wxTheApp->GetHildonProgram(),
522 HILDON_WINDOW(m_widget));
523#else // !wxUSE_LIBHILDON
cca410b3 524 m_widget = gtk_window_new(GTK_WINDOW_TOPLEVEL);
63c5efa3
VS
525 if (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG)
526 {
4d8d6490
VS
527 // Tell WM that this is a dialog window and make it center
528 // on parent by default (this is what GtkDialog ctor does):
529 gtk_window_set_type_hint(GTK_WINDOW(m_widget),
530 GDK_WINDOW_TYPE_HINT_DIALOG);
531 gtk_window_set_position(GTK_WINDOW(m_widget),
532 GTK_WIN_POS_CENTER_ON_PARENT);
63c5efa3 533 }
4d8d6490
VS
534 else
535 {
ff654490 536 if (style & wxFRAME_TOOL_WINDOW)
11475235 537 {
ff654490
VZ
538 gtk_window_set_type_hint(GTK_WINDOW(m_widget),
539 GDK_WINDOW_TYPE_HINT_UTILITY);
540
541 // On some WMs, like KDE, a TOOL_WINDOW will still show
542 // on the taskbar, but on Gnome a TOOL_WINDOW will not.
543 // For consistency between WMs and with Windows, we
544 // should set the NO_TASKBAR flag which will apply
545 // the set_skip_taskbar_hint if it is available,
546 // ensuring no taskbar entry will appear.
547 style |= wxFRAME_NO_TASKBAR;
11475235 548 }
4d8d6490 549 }
e2f3bc41 550#endif // wxUSE_LIBHILDON/!wxUSE_LIBHILDON
63c5efa3 551 }
7d9f12f3 552
e25c7537
VS
553 wxWindow *topParent = wxGetTopLevelParent(m_parent);
554 if (topParent && (((GTK_IS_WINDOW(topParent->m_widget)) &&
0a164d4c
WS
555 (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG)) ||
556 (style & wxFRAME_FLOAT_ON_PARENT)))
7cd95599 557 {
e25c7537
VS
558 gtk_window_set_transient_for( GTK_WINDOW(m_widget),
559 GTK_WINDOW(topParent->m_widget) );
7cd95599 560 }
7d9f12f3 561
ff654490 562 if (style & wxFRAME_NO_TASKBAR)
2be125e6 563 {
ff654490 564 gtk_window_set_skip_taskbar_hint(GTK_WINDOW(m_widget), TRUE);
2be125e6 565 }
2be125e6 566
ff654490 567 if (style & wxSTAY_ON_TOP)
2fca39c9 568 {
ff654490 569 gtk_window_set_keep_above(GTK_WINDOW(m_widget), TRUE);
2fca39c9 570 }
2fca39c9 571
5503a51c 572#if 0
0a164d4c 573 if (!name.empty())
5503a51c
MR
574 gtk_window_set_role( GTK_WINDOW(m_widget), wxGTK_CONV( name ) );
575#endif
7d9f12f3 576
fab591c5 577 gtk_window_set_title( GTK_WINDOW(m_widget), wxGTK_CONV( title ) );
7d9f12f3
VS
578 GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
579
9fa72bd2
MR
580 g_signal_connect (m_widget, "delete_event",
581 G_CALLBACK (gtk_frame_delete_callback), this);
7d9f12f3 582
cca410b3
PC
583 // m_mainWidget is a GtkVBox, holding the bars and client area (m_wxwindow)
584 m_mainWidget = gtk_vbox_new(false, 0);
7d9f12f3
VS
585 gtk_widget_show( m_mainWidget );
586 GTK_WIDGET_UNSET_FLAGS( m_mainWidget, GTK_CAN_FOCUS );
587 gtk_container_add( GTK_CONTAINER(m_widget), m_mainWidget );
588
cca410b3 589 // m_wxwindow is the client area
08f53168 590 m_wxwindow = wxPizza::New();
7d9f12f3
VS
591 gtk_widget_show( m_wxwindow );
592 gtk_container_add( GTK_CONTAINER(m_mainWidget), m_wxwindow );
593
e1f14d22
RR
594 // we donm't allow the frame to get the focus as otherwise
595 // the frame will grab it at arbitrary focus changes
7d9f12f3
VS
596 GTK_WIDGET_UNSET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );
597
598 if (m_parent) m_parent->AddChild( this );
599
cca410b3
PC
600 g_signal_connect(m_wxwindow, "size_allocate",
601 G_CALLBACK(size_allocate), this);
7d9f12f3 602
6e264997
VZ
603 g_signal_connect (m_widget, "size_request",
604 G_CALLBACK (wxgtk_tlw_size_request_callback), this);
7d9f12f3
VS
605 PostCreation();
606
607 if ((m_x != -1) || (m_y != -1))
608 gtk_widget_set_uposition( m_widget, m_x, m_y );
6aeb6f2a 609
e1f14d22
RR
610 // we cannot set MWM hints and icons before the widget has
611 // been realized, so we do this directly after realization
9fa72bd2
MR
612 g_signal_connect (m_widget, "realize",
613 G_CALLBACK (gtk_frame_realized_callback), this);
7d9f12f3 614
e1f14d22 615 // map and unmap for iconized state
9fa72bd2
MR
616 g_signal_connect (m_widget, "map_event",
617 G_CALLBACK (gtk_frame_map_callback), this);
618 g_signal_connect (m_widget, "unmap_event",
619 G_CALLBACK (gtk_frame_unmap_callback), this);
7d9f12f3 620
dc89b7bf 621 // for wxMoveEvent
9fa72bd2
MR
622 g_signal_connect (m_widget, "configure_event",
623 G_CALLBACK (gtk_frame_configure_callback), this);
7d9f12f3 624
06fda9e8 625 // activation
4c20ee63 626 g_signal_connect_after (m_widget, "focus_in_event",
9fa72bd2 627 G_CALLBACK (gtk_frame_focus_in_callback), this);
4c20ee63 628 g_signal_connect_after (m_widget, "focus_out_event",
9fa72bd2 629 G_CALLBACK (gtk_frame_focus_out_callback), this);
0a164d4c 630
290cd301
PC
631 gtk_widget_add_events(m_widget, GDK_PROPERTY_CHANGE_MASK);
632 g_signal_connect(m_widget, "property_notify_event",
633 G_CALLBACK(property_notify_event), this);
634
e1f14d22 635 // decorations
85a0a12a 636 if ((style & wxSIMPLE_BORDER) || (style & wxNO_BORDER))
f819b4a3
VS
637 {
638 m_gdkDecor = 0;
639 m_gdkFunc = 0;
640 }
641 else
642 {
290cd301
PC
643 m_gdkDecor = GDK_DECOR_BORDER;
644 m_gdkFunc = GDK_FUNC_MOVE;
82c9f85c 645
f819b4a3 646 // All this is for Motif Window Manager "hints" and is supposed to be
e1f14d22 647 // recognized by other WMs as well.
f819b4a3 648 if ((style & wxCAPTION) != 0)
c3d8ee42 649 {
f819b4a3 650 m_gdkDecor |= GDK_DECOR_TITLE;
c3d8ee42 651 }
850c6ed4 652 if ((style & wxCLOSE_BOX) != 0)
f819b4a3
VS
653 {
654 m_gdkFunc |= GDK_FUNC_CLOSE;
c3d8ee42
VS
655 }
656 if ((style & wxSYSTEM_MENU) != 0)
657 {
f819b4a3
VS
658 m_gdkDecor |= GDK_DECOR_MENU;
659 }
660 if ((style & wxMINIMIZE_BOX) != 0)
661 {
662 m_gdkFunc |= GDK_FUNC_MINIMIZE;
663 m_gdkDecor |= GDK_DECOR_MINIMIZE;
664 }
665 if ((style & wxMAXIMIZE_BOX) != 0)
666 {
667 m_gdkFunc |= GDK_FUNC_MAXIMIZE;
668 m_gdkDecor |= GDK_DECOR_MAXIMIZE;
669 }
670 if ((style & wxRESIZE_BORDER) != 0)
671 {
672 m_gdkFunc |= GDK_FUNC_RESIZE;
673 m_gdkDecor |= GDK_DECOR_RESIZEH;
674 }
675 }
676
0ab0d0e1
PC
677 m_decorSize = GetDecorSize(m_gdkDecor);
678
679 // m_sizeDecor needs to be set before calling GTKDoGetSize
290cd301
PC
680 int w, h;
681 GTKDoGetSize(&w, &h);
682 gtk_window_set_default_size(GTK_WINDOW(m_widget), w, h);
683
0a164d4c 684 return true;
7d9f12f3
VS
685}
686
687wxTopLevelWindowGTK::~wxTopLevelWindowGTK()
688{
e2f3bc41 689#if wxUSE_LIBHILDON
1510ba2c
VZ
690 // it can also be a (standard) dialog
691 if ( HILDON_IS_WINDOW(m_widget) )
692 {
693 hildon_program_remove_window(wxTheApp->GetHildonProgram(),
694 HILDON_WINDOW(m_widget));
695 }
e2f3bc41
VZ
696#endif // wxUSE_LIBHILDON
697
5152b0e5
JS
698 if (m_grabbed)
699 {
4362c705 700 wxFAIL_MSG(_T("Window still grabbed"));
5152b0e5
JS
701 RemoveGrab();
702 }
1cbee0b4 703
0a164d4c 704 m_isBeingDeleted = true;
6aeb6f2a 705
710968c3
VZ
706 // it may also be GtkScrolledWindow in the case of an MDI child
707 if (GTK_IS_WINDOW(m_widget))
708 {
709 gtk_window_set_focus( GTK_WINDOW(m_widget), NULL );
710 }
0a164d4c 711
06fda9e8
RR
712 if (g_activeFrame == this)
713 g_activeFrame = NULL;
714 if (g_lastActiveFrame == this)
715 g_lastActiveFrame = NULL;
7d9f12f3
VS
716}
717
0d635035
RR
718bool wxTopLevelWindowGTK::EnableCloseButton( bool enable )
719{
720 if (enable)
721 m_gdkFunc |= GDK_FUNC_CLOSE;
722 else
723 m_gdkFunc &= ~GDK_FUNC_CLOSE;
a6cdd521 724
0d635035
RR
725 if (GTK_WIDGET_REALIZED(m_widget) && (m_widget->window))
726 gdk_window_set_functions( m_widget->window, (GdkWMFunction)m_gdkFunc );
a6cdd521 727
0d635035
RR
728 return true;
729}
8a9650ea 730
1529bc41 731bool wxTopLevelWindowGTK::ShowFullScreen(bool show, long)
7d9f12f3 732{
8a8997c3 733 if (show == m_fsIsShowing)
0a164d4c 734 return false; // return what?
7d9f12f3
VS
735
736 m_fsIsShowing = show;
0a164d4c 737
1542ea39 738 wxX11FullScreenMethod method =
8166ab43
VS
739 wxGetFullScreenMethodX11((WXDisplay*)GDK_DISPLAY(),
740 (WXWindow)GDK_ROOT_WINDOW());
1542ea39 741
feb1c9fb
VS
742 // NB: gtk_window_fullscreen() uses freedesktop.org's WMspec extensions
743 // to switch to fullscreen, which is not always available. We must
744 // check if WM supports the spec and use legacy methods if it
745 // doesn't.
ff654490 746 if ( method == wxX11_FS_WMSPEC )
7d9f12f3 747 {
feb1c9fb
VS
748 if (show)
749 gtk_window_fullscreen( GTK_WINDOW( m_widget ) );
750 else
751 gtk_window_unfullscreen( GTK_WINDOW( m_widget ) );
7d9f12f3
VS
752 }
753 else
754 {
feb1c9fb
VS
755 GdkWindow *window = m_widget->window;
756
757 if (show)
8166ab43 758 {
feb1c9fb
VS
759 GetPosition( &m_fsSaveFrame.x, &m_fsSaveFrame.y );
760 GetSize( &m_fsSaveFrame.width, &m_fsSaveFrame.height );
761
762 int screen_width,screen_height;
763 wxDisplaySize( &screen_width, &screen_height );
764
765 gint client_x, client_y, root_x, root_y;
766 gint width, height;
767
ff654490
VZ
768 m_fsSaveGdkFunc = m_gdkFunc;
769 m_fsSaveGdkDecor = m_gdkDecor;
770 m_gdkFunc = m_gdkDecor = 0;
771 gdk_window_set_decorations(window, (GdkWMDecoration)0);
772 gdk_window_set_functions(window, (GdkWMFunction)0);
feb1c9fb
VS
773
774 gdk_window_get_origin (m_widget->window, &root_x, &root_y);
775 gdk_window_get_geometry (m_widget->window, &client_x, &client_y,
776 &width, &height, NULL);
777
778 gdk_window_move_resize (m_widget->window, -client_x, -client_y,
779 screen_width + 1, screen_height + 1);
780
781 wxSetFullScreenStateX11((WXDisplay*)GDK_DISPLAY(),
782 (WXWindow)GDK_ROOT_WINDOW(),
783 (WXWindow)GDK_WINDOW_XWINDOW(window),
784 show, &m_fsSaveFrame, method);
785 }
3b2931fb 786 else // hide
feb1c9fb 787 {
ff654490
VZ
788 m_gdkFunc = m_fsSaveGdkFunc;
789 m_gdkDecor = m_fsSaveGdkDecor;
790 gdk_window_set_decorations(window, (GdkWMDecoration)m_gdkDecor);
791 gdk_window_set_functions(window, (GdkWMFunction)m_gdkFunc);
feb1c9fb
VS
792
793 wxSetFullScreenStateX11((WXDisplay*)GDK_DISPLAY(),
794 (WXWindow)GDK_ROOT_WINDOW(),
795 (WXWindow)GDK_WINDOW_XWINDOW(window),
796 show, &m_fsSaveFrame, method);
797
798 SetSize(m_fsSaveFrame.x, m_fsSaveFrame.y,
799 m_fsSaveFrame.width, m_fsSaveFrame.height);
8166ab43 800 }
7d9f12f3 801 }
8166ab43 802
3b2931fb
VZ
803 // documented behaviour is to show the window if it's still hidden when
804 // showing it full screen
1529bc41 805 if (show)
3b2931fb
VZ
806 Show();
807
0a164d4c 808 return true;
7d9f12f3
VS
809}
810
811// ----------------------------------------------------------------------------
812// overridden wxWindow methods
813// ----------------------------------------------------------------------------
814
815bool wxTopLevelWindowGTK::Show( bool show )
816{
82b978d7 817 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
7d9f12f3 818
cca410b3 819 if (show && !IsShown())
7d9f12f3 820 {
cca410b3
PC
821 // size_allocate signals occur in reverse order (bottom to top).
822 // Things work better if the initial wxSizeEvents are sent (from the
823 // top down), before the initial size_allocate signals occur.
824 wxSizeEvent event(GetSize(), GetId());
825 event.SetEventObject(this);
826 GetEventHandler()->ProcessEvent(event);
7d9f12f3 827 }
0a164d4c 828
cca410b3 829 bool change = wxTopLevelWindowBase::Show(show);
aa34396c 830
cca410b3 831 if (change && !show)
aa34396c
PC
832 {
833 // make sure window has a non-default position, so when it is shown
834 // again, it won't be repositioned by WM as if it were a new window
835 // Note that this must be done _after_ the window is hidden.
836 gtk_window_move((GtkWindow*)m_widget, m_x, m_y);
837 }
838
cca410b3 839 return change;
7d9f12f3
VS
840}
841
a2ac55f5
RR
842void wxTopLevelWindowGTK::Raise()
843{
a2ac55f5 844 gtk_window_present( GTK_WINDOW( m_widget ) );
a2ac55f5
RR
845}
846
7d9f12f3
VS
847void wxTopLevelWindowGTK::DoMoveWindow(int WXUNUSED(x), int WXUNUSED(y), int WXUNUSED(width), int WXUNUSED(height) )
848{
849 wxFAIL_MSG( wxT("DoMoveWindow called for wxTopLevelWindowGTK") );
850}
851
a6cdd521
VZ
852// ----------------------------------------------------------------------------
853// window geometry
854// ----------------------------------------------------------------------------
855
6e264997
VZ
856void wxTopLevelWindowGTK::GTKDoGetSize(int *width, int *height) const
857{
290cd301
PC
858 wxSize size(m_width, m_height);
859 if (!IsFullScreen())
a6cdd521 860 {
0ab0d0e1 861 size -= m_decorSize;
290cd301
PC
862 if (size.x < 0) size.x = 0;
863 if (size.y < 0) size.y = 0;
a6cdd521 864 }
290cd301
PC
865 if (width) *width = size.x;
866 if (height) *height = size.y;
a6cdd521
VZ
867}
868
7d9f12f3
VS
869void wxTopLevelWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags )
870{
a6cdd521 871 wxCHECK_RET( m_widget, wxT("invalid frame") );
82b978d7 872
a6cdd521 873 // deal with the position first
7d9f12f3
VS
874 int old_x = m_x;
875 int old_y = m_y;
876
a6cdd521 877 if ( !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE) )
7d9f12f3 878 {
a6cdd521
VZ
879 // -1 means "use existing" unless the flag above is specified
880 if ( x != -1 )
881 m_x = x;
882 if ( y != -1 )
883 m_y = y;
7d9f12f3 884 }
a6cdd521 885 else // wxSIZE_ALLOW_MINUS_ONE
7d9f12f3
VS
886 {
887 m_x = x;
888 m_y = y;
7d9f12f3 889 }
7d9f12f3 890
a6cdd521 891 if ( m_x != old_x || m_y != old_y )
7d9f12f3 892 {
a6cdd521 893 gtk_window_move( GTK_WINDOW(m_widget), m_x, m_y );
7d9f12f3 894 }
7d9f12f3 895
290cd301
PC
896 const wxSize oldSize(m_width, m_height);
897 if (width >= 0)
898 m_width = width;
899 if (height >= 0)
900 m_height = height;
901 ConstrainSize();
902 if (m_width != oldSize.x || m_height != oldSize.y)
a6cdd521 903 {
290cd301
PC
904 int w, h;
905 GTKDoGetSize(&w, &h);
906 gtk_window_resize(GTK_WINDOW(m_widget), w, h);
cca410b3
PC
907
908 GetClientSize(&m_oldClientWidth, &m_oldClientHeight);
909 wxSizeEvent event(GetSize(), GetId());
910 event.SetEventObject(this);
911 GetEventHandler()->ProcessEvent(event);
7d9f12f3 912 }
7d9f12f3
VS
913}
914
915void wxTopLevelWindowGTK::DoGetClientSize( int *width, int *height ) const
916{
cca410b3
PC
917 wxASSERT_MSG(m_widget, wxT("invalid frame"));
918
bb596005
VZ
919 if ( IsIconized() )
920 {
921 // for consistency with wxMSW, client area is supposed to be empty for
922 // the iconized windows
923 if ( width )
924 *width = 0;
925 if ( height )
926 *height = 0;
bb596005 927 }
cca410b3 928 else
290cd301 929 {
cca410b3 930 GTKDoGetSize(width, height);
290cd301 931 }
7d9f12f3
VS
932}
933
9379c0d7
RR
934void wxTopLevelWindowGTK::DoSetSizeHints( int minW, int minH,
935 int maxW, int maxH,
936 int incW, int incH )
7d9f12f3 937{
9379c0d7 938 wxTopLevelWindowBase::DoSetSizeHints( minW, minH, maxW, maxH, incW, incH );
d6c11fa9
PC
939
940 const wxSize minSize = GetMinSize();
941 const wxSize maxSize = GetMaxSize();
942 GdkGeometry hints;
943 int hints_mask = 0;
944 if (minSize.x > 0 || minSize.y > 0)
945 {
946 hints_mask |= GDK_HINT_MIN_SIZE;
0ab0d0e1 947 hints.min_width = minSize.x - m_decorSize.x;
290cd301
PC
948 if (hints.min_width < 0)
949 hints.min_width = 0;
0ab0d0e1 950 hints.min_height = minSize.y - m_decorSize.y;
290cd301
PC
951 if (hints.min_height < 0)
952 hints.min_height = 0;
d6c11fa9
PC
953 }
954 if (maxSize.x > 0 || maxSize.y > 0)
955 {
956 hints_mask |= GDK_HINT_MAX_SIZE;
0ab0d0e1 957 hints.max_width = maxSize.x - m_decorSize.x;
290cd301
PC
958 if (hints.max_width < 0)
959 hints.max_width = INT_MAX;
0ab0d0e1 960 hints.max_height = maxSize.y - m_decorSize.y;
290cd301
PC
961 if (hints.max_height < 0)
962 hints.max_height = INT_MAX;
d6c11fa9
PC
963 }
964 if (incW > 0 || incH > 0)
7d9f12f3 965 {
d6c11fa9
PC
966 hints_mask |= GDK_HINT_RESIZE_INC;
967 hints.width_inc = incW > 0 ? incW : 1;
968 hints.height_inc = incH > 0 ? incH : 1;
9379c0d7 969 }
d6c11fa9
PC
970 gtk_window_set_geometry_hints(
971 (GtkWindow*)m_widget, NULL, &hints, (GdkWindowHints)hints_mask);
9379c0d7 972}
7d9f12f3 973
290cd301
PC
974bool wxTopLevelWindowGTK::IsDecorCacheable() const
975{
976 return true;
977}
978
7d9f12f3
VS
979void wxTopLevelWindowGTK::OnInternalIdle()
980{
6aeb6f2a
VZ
981 // set the focus if not done yet and if we can already do it
982 if ( GTK_WIDGET_REALIZED(m_wxwindow) )
983 {
cc06fe74
MB
984 if ( g_delayedFocus &&
985 wxGetTopLevelParent((wxWindow*)g_delayedFocus) == this )
6aeb6f2a 986 {
2b5f62a0
VZ
987 wxLogTrace(_T("focus"),
988 _T("Setting focus from wxTLW::OnIdle() to %s(%s)"),
989 g_delayedFocus->GetClassInfo()->GetClassName(),
990 g_delayedFocus->GetLabel().c_str());
991
6aeb6f2a
VZ
992 g_delayedFocus->SetFocus();
993 g_delayedFocus = NULL;
994 }
995 }
996
7d9f12f3 997 wxWindow::OnInternalIdle();
0a164d4c 998
06fda9e8
RR
999 // Synthetize activate events.
1000 if ( g_sendActivateEvent != -1 )
1001 {
1002 bool activate = g_sendActivateEvent != 0;
0a164d4c 1003
576f7127
RR
1004 // if (!activate) wxPrintf( wxT("de") );
1005 // wxPrintf( wxT("activate\n") );
0a164d4c 1006
06fda9e8
RR
1007 // do it only once
1008 g_sendActivateEvent = -1;
1009
1010 wxTheApp->SetActive(activate, (wxWindow *)g_lastActiveFrame);
1011 }
7d9f12f3
VS
1012}
1013
7d9f12f3
VS
1014// ----------------------------------------------------------------------------
1015// frame title/icon
1016// ----------------------------------------------------------------------------
1017
1018void wxTopLevelWindowGTK::SetTitle( const wxString &title )
1019{
82b978d7
RD
1020 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
1021
cb8cc250
WS
1022 if ( title == m_title )
1023 return;
1024
7d9f12f3 1025 m_title = title;
cb8cc250 1026
fab591c5 1027 gtk_window_set_title( GTK_WINDOW(m_widget), wxGTK_CONV( title ) );
7d9f12f3
VS
1028}
1029
f618020a
MB
1030void wxTopLevelWindowGTK::SetIcons( const wxIconBundle &icons )
1031{
82b978d7 1032 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
f618020a
MB
1033
1034 wxTopLevelWindowBase::SetIcons( icons );
1035
87e53e2a 1036 GList *list = NULL;
87e53e2a 1037
52734360
VZ
1038 const size_t numIcons = icons.GetIconCount();
1039 for ( size_t i = 0; i < numIcons; i++ )
52d6235d 1040 {
52734360 1041 list = g_list_prepend(list, icons.GetIconByIndex(i).GetPixbuf());
87e53e2a 1042 }
52734360 1043
87e53e2a
VS
1044 gtk_window_set_icon_list(GTK_WINDOW(m_widget), list);
1045 g_list_free(list);
f618020a
MB
1046}
1047
7d9f12f3
VS
1048// ----------------------------------------------------------------------------
1049// frame state: maximized/iconized/normal
1050// ----------------------------------------------------------------------------
1051
8805e155 1052void wxTopLevelWindowGTK::Maximize(bool maximize)
7d9f12f3 1053{
8805e155
RR
1054 if (maximize)
1055 gtk_window_maximize( GTK_WINDOW( m_widget ) );
1056 else
1057 gtk_window_unmaximize( GTK_WINDOW( m_widget ) );
7d9f12f3
VS
1058}
1059
1060bool wxTopLevelWindowGTK::IsMaximized() const
1061{
d8e1fe80
VS
1062 if(!m_widget->window)
1063 return false;
1064
1065 return gdk_window_get_state(m_widget->window) & GDK_WINDOW_STATE_MAXIMIZED;
7d9f12f3
VS
1066}
1067
1068void wxTopLevelWindowGTK::Restore()
1069{
8805e155
RR
1070 // "Present" seems similar enough to "restore"
1071 gtk_window_present( GTK_WINDOW( m_widget ) );
7d9f12f3
VS
1072}
1073
1074void wxTopLevelWindowGTK::Iconize( bool iconize )
1075{
8805e155
RR
1076 if (iconize)
1077 gtk_window_iconify( GTK_WINDOW( m_widget ) );
1078 else
1079 gtk_window_deiconify( GTK_WINDOW( m_widget ) );
7d9f12f3
VS
1080}
1081
1082bool wxTopLevelWindowGTK::IsIconized() const
1083{
1084 return m_isIconized;
1085}
1086
1087void wxTopLevelWindowGTK::SetIconizeState(bool iconize)
1088{
1089 if ( iconize != m_isIconized )
1090 {
1091 m_isIconized = iconize;
1092 (void)SendIconizeEvent(iconize);
1093 }
1094}
1095
5152b0e5
JS
1096void wxTopLevelWindowGTK::AddGrab()
1097{
1098 if (!m_grabbed)
1099 {
0a164d4c 1100 m_grabbed = true;
5152b0e5 1101 gtk_grab_add( m_widget );
b46b1d59 1102 wxGUIEventLoop().Run();
5152b0e5
JS
1103 gtk_grab_remove( m_widget );
1104 }
1105}
1106
1107void wxTopLevelWindowGTK::RemoveGrab()
1108{
1109 if (m_grabbed)
1110 {
1111 gtk_main_quit();
0a164d4c 1112 m_grabbed = false;
5152b0e5
JS
1113 }
1114}
801225c1 1115
1542ea39
RD
1116
1117// helper
1118static bool do_shape_combine_region(GdkWindow* window, const wxRegion& region)
1119{
1120 if (window)
1121 {
1122 if (region.IsEmpty())
1123 {
1124 gdk_window_shape_combine_mask(window, NULL, 0, 0);
1125 }
1126 else
1127 {
0a164d4c 1128 gdk_window_shape_combine_region(window, region.GetRegion(), 0, 0);
0a164d4c 1129 return true;
1542ea39
RD
1130 }
1131 }
0a164d4c 1132 return false;
1542ea39
RD
1133}
1134
1135
1136bool wxTopLevelWindowGTK::SetShape(const wxRegion& region)
1137{
0a164d4c 1138 wxCHECK_MSG( HasFlag(wxFRAME_SHAPED), false,
6a7e6411
RD
1139 _T("Shaped windows must be created with the wxFRAME_SHAPED style."));
1140
1542ea39
RD
1141 GdkWindow *window = NULL;
1142 if (m_wxwindow)
1143 {
08f53168 1144 do_shape_combine_region(m_wxwindow->window, region);
1542ea39
RD
1145 }
1146 window = m_widget->window;
1147 return do_shape_combine_region(window, region);
1148}
1149
6b30a44e 1150bool wxTopLevelWindowGTK::IsActive()
35ff90a0 1151{
06fda9e8 1152 return (this == (wxTopLevelWindowGTK*)g_activeFrame);
35ff90a0 1153}
dca92ddf
MR
1154
1155void wxTopLevelWindowGTK::RequestUserAttention(int flags)
1156{
1157 bool new_hint_value = false;
1158
1159 // FIXME: This is a workaround to focus handling problem
1160 // If RequestUserAttention is called for example right after a wxSleep, OnInternalIdle hasn't
1161 // yet been processed, and the internal focus system is not up to date yet.
1162 // wxYieldIfNeeded ensures the processing of it, but can have unwanted side effects - MR
1163 ::wxYieldIfNeeded();
1164
dca92ddf 1165 if(m_urgency_hint >= 0)
92ed8bec 1166 g_source_remove(m_urgency_hint);
dca92ddf 1167
ef1a9be4 1168 m_urgency_hint = -2;
dca92ddf
MR
1169
1170 if( GTK_WIDGET_REALIZED(m_widget) && !IsActive() )
1171 {
1172 new_hint_value = true;
1173
1174 if (flags & wxUSER_ATTENTION_INFO)
1175 {
92ed8bec 1176 m_urgency_hint = g_timeout_add(5000, (GSourceFunc)gtk_frame_urgency_timer_callback, this);
dca92ddf 1177 } else {
ef1a9be4 1178 m_urgency_hint = -1;
dca92ddf
MR
1179 }
1180 }
1181
2ec371fd 1182#if GTK_CHECK_VERSION(2,7,0)
dca92ddf
MR
1183 if(!gtk_check_version(2,7,0))
1184 gtk_window_set_urgency_hint(GTK_WINDOW( m_widget ), new_hint_value);
1185 else
1186#endif
1187 wxgtk_window_set_urgency_hint(GTK_WINDOW( m_widget ), new_hint_value);
1188}
015dca24
MR
1189
1190void wxTopLevelWindowGTK::SetWindowStyleFlag( long style )
1191{
1192 // Store which styles were changed
1193 long styleChanges = style ^ m_windowStyle;
1194
1195 // Process wxWindow styles. This also updates the internal variable
1196 // Therefore m_windowStyle bits carry now the _new_ style values
1197 wxWindow::SetWindowStyleFlag(style);
1198
1199 // just return for now if widget does not exist yet
1200 if (!m_widget)
1201 return;
1202
ff654490
VZ
1203 if ( styleChanges & wxSTAY_ON_TOP )
1204 {
1205 gtk_window_set_keep_above(GTK_WINDOW(m_widget),
1206 m_windowStyle & wxSTAY_ON_TOP);
1207 }
1208
1209 if ( styleChanges & wxFRAME_NO_TASKBAR )
8fb82418 1210 {
ff654490
VZ
1211 gtk_window_set_skip_taskbar_hint(GTK_WINDOW(m_widget),
1212 m_windowStyle & wxFRAME_NO_TASKBAR);
8fb82418 1213 }
015dca24 1214}
07e49707 1215
07e49707
MR
1216/* Get the X Window between child and the root window.
1217 This should usually be the WM managed XID */
1218static Window wxGetTopmostWindowX11(Display *dpy, Window child)
1219{
1220 Window root, parent;
1221 Window* children;
1222 unsigned int nchildren;
1223
1224 XQueryTree(dpy, child, &root, &parent, &children, &nchildren);
1225 XFree(children);
1226
1227 while (parent != root) {
1228 child = parent;
1229 XQueryTree(dpy, child, &root, &parent, &children, &nchildren);
1230 XFree(children);
1231 }
1232
1233 return child;
1234}
1235
1236bool wxTopLevelWindowGTK::SetTransparent(wxByte alpha)
1237{
3eecbda8 1238 if (!m_widget || !m_widget->window)
07e49707
MR
1239 return false;
1240
1241 Display* dpy = GDK_WINDOW_XDISPLAY (m_widget->window);
1242 // We need to get the X Window that has the root window as the immediate parent
1243 // and m_widget->window as a child. This should be the X Window that the WM manages and
1244 // from which the opacity property is checked from.
1245 Window win = wxGetTopmostWindowX11(dpy, GDK_WINDOW_XID (m_widget->window));
1246
07e49707
MR
1247
1248 // Using pure Xlib to not have a GTK version check mess due to gtk2.0 not having GdkDisplay
1249 if (alpha == 0xff)
1250 XDeleteProperty(dpy, win, XInternAtom(dpy, "_NET_WM_WINDOW_OPACITY", False));
1251 else
d48687a0
PC
1252 {
1253 long opacity = alpha * 0x1010101L;
07e49707
MR
1254 XChangeProperty(dpy, win, XInternAtom(dpy, "_NET_WM_WINDOW_OPACITY", False),
1255 XA_CARDINAL, 32, PropModeReplace,
1256 (unsigned char *) &opacity, 1L);
d48687a0 1257 }
07e49707
MR
1258 XSync(dpy, False);
1259 return true;
1260}
1261
1262bool wxTopLevelWindowGTK::CanSetTransparent()
1263{
a95a6eb4
VZ
1264 // allow to override automatic detection as it's far from perfect
1265 static const wxChar *SYSOPT_TRANSPARENT = wxT("gtk.tlw.can-set-transparent");
1266 if ( wxSystemOptions::HasOption(SYSOPT_TRANSPARENT) )
1267 {
1268 return wxSystemOptions::GetOptionInt(SYSOPT_TRANSPARENT) != 0;
1269 }
1270
60169b7a
MR
1271#if GTK_CHECK_VERSION(2,10,0)
1272 if (!gtk_check_version(2,10,0))
1273 {
0b241226 1274 return (gtk_widget_is_composited (m_widget));
60169b7a
MR
1275 }
1276 else
1277#endif // In case of lower versions than gtk+-2.10.0 we could look for _NET_WM_CM_Sn ourselves
1278 {
1279 return false;
1280 }
1281
1282#if 0 // Don't be optimistic here for the sake of wxAUI
07e49707
MR
1283 int opcode, event, error;
1284 // Check for the existence of a RGBA visual instead?
1285 return XQueryExtension(gdk_x11_get_default_xdisplay (),
1286 "Composite", &opcode, &event, &error);
60169b7a 1287#endif
07e49707 1288}
013151c7
JS
1289
1290void wxTopLevelWindowGTK::OnSysColourChanged(wxSysColourChangedEvent& event)
1291{
1292 // We don't know the order in which top-level windows will
1293 // be notified, so we need to clear the system objects
1294 // for each top-level window.
1295 extern void wxClearGtkSystemObjects();
1296 wxClearGtkSystemObjects();
1297
1298 // wxWindowBase::OnSysColourChanged will propagate event
1299 // to children
1300 event.Skip();
1301}