projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Fix GetClientSize() when scrollbars are present
[wxWidgets.git] / 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/evtloop.h"
35 #include "wx/sysopt.h"
36
37 #include <gtk/gtk.h>
38 #ifdef GDK_WINDOWING_X11
39 #include <gdk/gdkx.h>
40 #include <X11/Xatom.h> // XA_CARDINAL
41 #include "wx/unix/utilsx11.h"
42 #endif
43
44 #include "wx/gtk/private.h"
45 #include "wx/gtk/private/gtk2-compat.h"
46 #include "wx/gtk/private/win_gtk.h"
47
48 #if wxUSE_LIBHILDON
49 #include <hildon-widgets/hildon-program.h>
50 #include <hildon-widgets/hildon-window.h>
51 #endif // wxUSE_LIBHILDON
52
53 #if wxUSE_LIBHILDON2
54 #include <hildon/hildon.h>
55 #endif // wxUSE_LIBHILDON2
56
57 // ----------------------------------------------------------------------------
58 // data
59 // ----------------------------------------------------------------------------
60
61 // this is incremented while a modal dialog is shown
62 int wxOpenModalDialogsCount = 0;
63
64 // the frame that is currently active (i.e. its child has focus). It is
65 // used to generate wxActivateEvents
66 static wxTopLevelWindowGTK *g_activeFrame = NULL;
67 static wxTopLevelWindowGTK *g_lastActiveFrame = NULL;
68
69 // if we detect that the app has got/lost the focus, we set this variable to
70 // either TRUE or FALSE and an activate event will be sent during the next
71 // OnIdle() call and it is reset to -1: this value means that we shouldn't
72 // send any activate events at all
73 static int g_sendActivateEvent = -1;
74
75 // Whether _NET_REQUEST_FRAME_EXTENTS support is working
76 // 0 == not tested yet, 1 == working, 2 == broken
77 static int gs_requestFrameExtentsStatus;
78
79 //-----------------------------------------------------------------------------
80 // RequestUserAttention related functions
81 //-----------------------------------------------------------------------------
82
83 #ifndef __WXGTK3__
84 static void wxgtk_window_set_urgency_hint (GtkWindow *win,
85 gboolean setting)
86 {
87 #if GTK_CHECK_VERSION(2,7,0)
88 if (gtk_check_version(2,7,0) == NULL)
89 gtk_window_set_urgency_hint(win, setting);
90 else
91 #endif
92 {
93 #ifdef GDK_WINDOWING_X11
94 GdkWindow* window = gtk_widget_get_window(GTK_WIDGET(win));
95 wxCHECK_RET(window, "wxgtk_window_set_urgency_hint: GdkWindow not realized");
96
97 Display* dpy = GDK_WINDOW_XDISPLAY(window);
98 Window xid = GDK_WINDOW_XID(window);
99 XWMHints* wm_hints = XGetWMHints(dpy, xid);
100
101 if (!wm_hints)
102 wm_hints = XAllocWMHints();
103
104 if (setting)
105 wm_hints->flags |= XUrgencyHint;
106 else
107 wm_hints->flags &= ~XUrgencyHint;
108
109 XSetWMHints(dpy, xid, wm_hints);
110 XFree(wm_hints);
111 #endif // GDK_WINDOWING_X11
112 }
113 }
114 #define gtk_window_set_urgency_hint wxgtk_window_set_urgency_hint
115 #endif
116
117 extern "C" {
118 static gboolean gtk_frame_urgency_timer_callback( wxTopLevelWindowGTK *win )
119 {
120 gtk_window_set_urgency_hint(GTK_WINDOW(win->m_widget), false);
121
122 win->m_urgency_hint = -2;
123 return FALSE;
124 }
125 }
126
127 //-----------------------------------------------------------------------------
128 // "focus_in_event"
129 //-----------------------------------------------------------------------------
130
131 extern "C" {
132 static gboolean gtk_frame_focus_in_callback( GtkWidget *widget,
133 GdkEvent *WXUNUSED(event),
134 wxTopLevelWindowGTK *win )
135 {
136 switch ( g_sendActivateEvent )
137 {
138 case -1:
139 // we've got focus from outside, synthetize wxActivateEvent
140 g_sendActivateEvent = 1;
141 break;
142
143 case 0:
144 // another our window just lost focus, it was already ours before
145 // - don't send any wxActivateEvent
146 g_sendActivateEvent = -1;
147 break;
148 }
149
150 g_activeFrame = win;
151 g_lastActiveFrame = g_activeFrame;
152
153 // wxPrintf( wxT("active: %s\n"), win->GetTitle().c_str() );
154
155 // MR: wxRequestUserAttention related block
156 switch( win->m_urgency_hint )
157 {
158 default:
159 g_source_remove( win->m_urgency_hint );
160 // no break, fallthrough to remove hint too
161 case -1:
162 gtk_window_set_urgency_hint(GTK_WINDOW(widget), false);
163 win->m_urgency_hint = -2;
164 break;
165
166 case -2: break;
167 }
168
169 wxLogTrace(wxT("activate"), wxT("Activating frame %p (from focus_in)"), g_activeFrame);
170 wxActivateEvent event(wxEVT_ACTIVATE, true, g_activeFrame->GetId());
171 event.SetEventObject(g_activeFrame);
172 g_activeFrame->HandleWindowEvent(event);
173
174 return FALSE;
175 }
176 }
177
178 //-----------------------------------------------------------------------------
179 // "focus_out_event"
180 //-----------------------------------------------------------------------------
181
182 extern "C" {
183 static
184 gboolean gtk_frame_focus_out_callback(GtkWidget * WXUNUSED(widget),
185 GdkEventFocus *WXUNUSED(gdk_event),
186 wxTopLevelWindowGTK * WXUNUSED(win))
187 {
188 // if the focus goes out of our app altogether, OnIdle() will send
189 // wxActivateEvent, otherwise gtk_window_focus_in_callback() will reset
190 // g_sendActivateEvent to -1
191 g_sendActivateEvent = 0;
192
193 // wxASSERT_MSG( (g_activeFrame == win), wxT("TLW deactivatd although it wasn't active") );
194
195 // wxPrintf( wxT("inactive: %s\n"), win->GetTitle().c_str() );
196
197 if (g_activeFrame)
198 {
199 wxLogTrace(wxT("activate"), wxT("Activating frame %p (from focus_in)"), g_activeFrame);
200 wxActivateEvent event(wxEVT_ACTIVATE, false, g_activeFrame->GetId());
201 event.SetEventObject(g_activeFrame);
202 g_activeFrame->HandleWindowEvent(event);
203
204 g_activeFrame = NULL;
205 }
206
207 return FALSE;
208 }
209 }
210
211 //-----------------------------------------------------------------------------
212 // "size_allocate" from m_wxwindow
213 //-----------------------------------------------------------------------------
214
215 extern "C" {
216 static void
217 size_allocate(GtkWidget*, GtkAllocation* alloc, wxTopLevelWindowGTK* win)
218 {
219 if (win->m_oldClientWidth != alloc->width ||
220 win->m_oldClientHeight != alloc->height)
221 {
222 win->m_oldClientWidth = alloc->width;
223 win->m_oldClientHeight = alloc->height;
224
225 GtkAllocation a;
226 gtk_widget_get_allocation(win->m_widget, &a);
227 wxSize size(a.width, a.height);
228 size += win->m_decorSize;
229 win->m_width = size.x;
230 win->m_height = size.y;
231
232 if (!win->IsIconized())
233 {
234 wxSizeEvent event(size, win->GetId());
235 event.SetEventObject(win);
236 win->HandleWindowEvent(event);
237 }
238 // else the window is currently unmapped, don't generate size events
239 }
240 }
241 }
242
243 //-----------------------------------------------------------------------------
244 // "delete_event"
245 //-----------------------------------------------------------------------------
246
247 extern "C" {
248 static gboolean
249 gtk_frame_delete_callback( GtkWidget *WXUNUSED(widget),
250 GdkEvent *WXUNUSED(event),
251 wxTopLevelWindowGTK *win )
252 {
253 if (win->IsEnabled() &&
254 (wxOpenModalDialogsCount == 0 || (win->GetExtraStyle() & wxTOPLEVEL_EX_DIALOG) ||
255 win->IsGrabbed()))
256 win->Close();
257
258 return TRUE;
259 }
260 }
261
262 //-----------------------------------------------------------------------------
263 // "configure_event"
264 //-----------------------------------------------------------------------------
265
266 extern "C" {
267 static gboolean
268 gtk_frame_configure_callback( GtkWidget* widget,
269 GdkEventConfigure *WXUNUSED(event),
270 wxTopLevelWindowGTK *win )
271 {
272 if (!win->IsShown())
273 return FALSE;
274
275 wxPoint point;
276 gtk_window_get_position((GtkWindow*)widget, &point.x, &point.y);
277
278 win->m_x = point.x;
279 win->m_y = point.y;
280 wxMoveEvent mevent(point, win->GetId());
281 mevent.SetEventObject( win );
282 win->HandleWindowEvent( mevent );
283
284 return FALSE;
285 }
286 }
287
288 //-----------------------------------------------------------------------------
289 // "realize" from m_widget
290 //-----------------------------------------------------------------------------
291
292 // we cannot the WM hints and icons before the widget has been realized,
293 // so we do this directly after realization
294
295 void wxTopLevelWindowGTK::GTKHandleRealized()
296 {
297 wxNonOwnedWindow::GTKHandleRealized();
298
299 gdk_window_set_decorations(gtk_widget_get_window(m_widget),
300 (GdkWMDecoration)m_gdkDecor);
301 gdk_window_set_functions(gtk_widget_get_window(m_widget),
302 (GdkWMFunction)m_gdkFunc);
303
304 // GTK's shrinking/growing policy
305 if ( !(m_gdkFunc & GDK_FUNC_RESIZE) )
306 gtk_window_set_resizable(GTK_WINDOW(m_widget), FALSE);
307 #ifndef __WXGTK3__
308 else
309 gtk_window_set_policy(GTK_WINDOW(m_widget), 1, 1, 1);
310 #endif
311
312 const wxIconBundle& icons = GetIcons();
313 if (icons.GetIconCount())
314 SetIcons(icons);
315
316 #ifdef __WXGTK3__
317 if (gtk_window_get_has_resize_grip(GTK_WINDOW(m_widget)))
318 {
319 // Grip window can end up obscured, probably due to deferred show.
320 // Reset grip to ensure it is visible.
321 gtk_window_set_has_resize_grip(GTK_WINDOW(m_widget), false);
322 gtk_window_set_has_resize_grip(GTK_WINDOW(m_widget), true);
323 }
324 #endif
325 }
326
327 //-----------------------------------------------------------------------------
328 // "map_event" from m_widget
329 //-----------------------------------------------------------------------------
330
331 extern "C" {
332 static gboolean
333 gtk_frame_map_callback( GtkWidget*,
334 GdkEvent * WXUNUSED(event),
335 wxTopLevelWindow *win )
336 {
337 const bool wasIconized = win->IsIconized();
338 if (wasIconized)
339 {
340 // Because GetClientSize() returns (0,0) when IsIconized() is true,
341 // a size event must be generated, just in case GetClientSize() was
342 // called while iconized. This specifically happens when restoring a
343 // tlw that was "rolled up" with some WMs.
344 // Queue a resize rather than sending size event directly to allow
345 // children to be made visible first.
346 win->m_oldClientWidth = 0;
347 gtk_widget_queue_resize(win->m_wxwindow);
348 }
349 // it is possible for m_isShown to be false here, see bug #9909
350 if (win->wxWindowBase::Show(true))
351 {
352 wxShowEvent eventShow(win->GetId(), true);
353 eventShow.SetEventObject(win);
354 win->GetEventHandler()->ProcessEvent(eventShow);
355 }
356
357 // restore focus-on-map setting in case ShowWithoutActivating() was called
358 gtk_window_set_focus_on_map(GTK_WINDOW(win->m_widget), true);
359
360 return false;
361 }
362 }
363
364 //-----------------------------------------------------------------------------
365 // "window-state-event" from m_widget
366 //-----------------------------------------------------------------------------
367
368 extern "C" {
369 static gboolean
370 gtk_frame_window_state_callback( GtkWidget* WXUNUSED(widget),
371 GdkEventWindowState *event,
372 wxTopLevelWindow *win )
373 {
374 if (event->changed_mask & GDK_WINDOW_STATE_ICONIFIED)
375 win->SetIconizeState((event->new_window_state & GDK_WINDOW_STATE_ICONIFIED) != 0);
376
377 // if maximized bit changed and it is now set
378 if (event->changed_mask & event->new_window_state & GDK_WINDOW_STATE_MAXIMIZED)
379 {
380 wxMaximizeEvent evt(win->GetId());
381 evt.SetEventObject(win);
382 win->HandleWindowEvent(evt);
383 }
384
385 if (event->changed_mask & GDK_WINDOW_STATE_FULLSCREEN)
386 win->m_fsIsShowing = (event->new_window_state & GDK_WINDOW_STATE_FULLSCREEN) != 0;
387
388 return false;
389 }
390 }
391
392 //-----------------------------------------------------------------------------
393
394 bool wxGetFrameExtents(GdkWindow* window, int* left, int* right, int* top, int* bottom)
395 {
396 #ifdef GDK_WINDOWING_X11
397 static GdkAtom property = gdk_atom_intern("_NET_FRAME_EXTENTS", false);
398 GdkDisplay* display = gdk_window_get_display(window);
399 Atom xproperty = gdk_x11_atom_to_xatom_for_display(display, property);
400 Atom type;
401 int format;
402 gulong nitems, bytes_after;
403 guchar* data;
404 Status status = XGetWindowProperty(
405 GDK_DISPLAY_XDISPLAY(display),
406 GDK_WINDOW_XID(window),
407 xproperty,
408 0, 4, false, XA_CARDINAL,
409 &type, &format, &nitems, &bytes_after, &data);
410 const bool success = status == Success && data && nitems == 4;
411 if (success)
412 {
413 long* p = (long*)data;
414 if (left) *left = int(p[0]);
415 if (right) *right = int(p[1]);
416 if (top) *top = int(p[2]);
417 if (bottom) *bottom = int(p[3]);
418 }
419 if (data)
420 XFree(data);
421 return success;
422 #else
423 return false;
424 #endif
425 }
426
427 #ifdef GDK_WINDOWING_X11
428 //-----------------------------------------------------------------------------
429 // "property_notify_event" from m_widget
430 //-----------------------------------------------------------------------------
431
432 extern "C" {
433 static gboolean property_notify_event(
434 GtkWidget*, GdkEventProperty* event, wxTopLevelWindowGTK* win)
435 {
436 // Watch for changes to _NET_FRAME_EXTENTS property
437 static GdkAtom property = gdk_atom_intern("_NET_FRAME_EXTENTS", false);
438 if (event->state == GDK_PROPERTY_NEW_VALUE && event->atom == property)
439 {
440 if (win->m_netFrameExtentsTimerId)
441 {
442 // WM support for _NET_REQUEST_FRAME_EXTENTS is working
443 gs_requestFrameExtentsStatus = 1;
444 g_source_remove(win->m_netFrameExtentsTimerId);
445 win->m_netFrameExtentsTimerId = 0;
446 }
447
448 wxSize decorSize = win->m_decorSize;
449 int left, right, top, bottom;
450 if (wxGetFrameExtents(event->window, &left, &right, &top, &bottom))
451 decorSize.Set(left + right, top + bottom);
452
453 win->GTKUpdateDecorSize(decorSize);
454 }
455 return false;
456 }
457 }
458
459 extern "C" {
460 static gboolean request_frame_extents_timeout(void* data)
461 {
462 // WM support for _NET_REQUEST_FRAME_EXTENTS is broken
463 gs_requestFrameExtentsStatus = 2;
464 gdk_threads_enter();
465 wxTopLevelWindowGTK* win = static_cast<wxTopLevelWindowGTK*>(data);
466 win->m_netFrameExtentsTimerId = 0;
467 wxSize decorSize = win->m_decorSize;
468 int left, right, top, bottom;
469 if (wxGetFrameExtents(gtk_widget_get_window(win->m_widget), &left, &right, &top, &bottom))
470 decorSize.Set(left + right, top + bottom);
471 win->GTKUpdateDecorSize(decorSize);
472 gdk_threads_leave();
473 return false;
474 }
475 }
476 #endif // GDK_WINDOWING_X11
477
478 // ----------------------------------------------------------------------------
479 // wxTopLevelWindowGTK creation
480 // ----------------------------------------------------------------------------
481
482 void wxTopLevelWindowGTK::Init()
483 {
484 m_mainWidget = NULL;
485 m_isIconized = false;
486 m_fsIsShowing = false;
487 m_themeEnabled = true;
488 m_gdkDecor =
489 m_gdkFunc = 0;
490 m_grabbed = false;
491 m_deferShow = true;
492 m_deferShowAllowed = true;
493 m_updateDecorSize = true;
494 m_netFrameExtentsTimerId = 0;
495 m_incWidth = m_incHeight = 0;
496
497 m_urgency_hint = -2;
498 }
499
500 bool wxTopLevelWindowGTK::Create( wxWindow *parent,
501 wxWindowID id,
502 const wxString& title,
503 const wxPoint& pos,
504 const wxSize& sizeOrig,
505 long style,
506 const wxString &name )
507 {
508 // always create a frame of some reasonable, even if arbitrary, size (at
509 // least for MSW compatibility)
510 wxSize size = sizeOrig;
511 size.x = WidthDefault(size.x);
512 size.y = HeightDefault(size.y);
513
514 wxTopLevelWindows.Append( this );
515
516 if (!PreCreation( parent, pos, size ) ||
517 !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
518 {
519 wxFAIL_MSG( wxT("wxTopLevelWindowGTK creation failed") );
520 return false;
521 }
522
523 m_title = title;
524
525 // NB: m_widget may be !=NULL if it was created by derived class' Create,
526 // e.g. in wxTaskBarIconAreaGTK
527 if (m_widget == NULL)
528 {
529 #if wxUSE_LIBHILDON || wxUSE_LIBHILDON2
530 // we must create HildonWindow and not a normal GtkWindow as the latter
531 // doesn't look correctly in Maemo environment and it must also be
532 // registered with the main program object
533 m_widget = hildon_window_new();
534 hildon_program_add_window(wxTheApp->GetHildonProgram(),
535 HILDON_WINDOW(m_widget));
536 #else // !wxUSE_LIBHILDON || !wxUSE_LIBHILDON2
537 m_widget = gtk_window_new(GTK_WINDOW_TOPLEVEL);
538 if (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG)
539 {
540 // Tell WM that this is a dialog window and make it center
541 // on parent by default (this is what GtkDialog ctor does):
542 gtk_window_set_type_hint(GTK_WINDOW(m_widget),
543 GDK_WINDOW_TYPE_HINT_DIALOG);
544 gtk_window_set_position(GTK_WINDOW(m_widget),
545 GTK_WIN_POS_CENTER_ON_PARENT);
546 }
547 else
548 {
549 if (style & wxFRAME_TOOL_WINDOW)
550 {
551 gtk_window_set_type_hint(GTK_WINDOW(m_widget),
552 GDK_WINDOW_TYPE_HINT_UTILITY);
553
554 // On some WMs, like KDE, a TOOL_WINDOW will still show
555 // on the taskbar, but on Gnome a TOOL_WINDOW will not.
556 // For consistency between WMs and with Windows, we
557 // should set the NO_TASKBAR flag which will apply
558 // the set_skip_taskbar_hint if it is available,
559 // ensuring no taskbar entry will appear.
560 style |= wxFRAME_NO_TASKBAR;
561 }
562 }
563 #endif // wxUSE_LIBHILDON || wxUSE_LIBHILDON2/!wxUSE_LIBHILDON || !wxUSE_LIBHILDON2
564
565 g_object_ref(m_widget);
566 }
567
568 wxWindow *topParent = wxGetTopLevelParent(m_parent);
569 if (topParent && (((GTK_IS_WINDOW(topParent->m_widget)) &&
570 (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG)) ||
571 (style & wxFRAME_FLOAT_ON_PARENT)))
572 {
573 gtk_window_set_transient_for( GTK_WINDOW(m_widget),
574 GTK_WINDOW(topParent->m_widget) );
575 }
576
577 if (style & wxFRAME_NO_TASKBAR)
578 {
579 gtk_window_set_skip_taskbar_hint(GTK_WINDOW(m_widget), TRUE);
580 }
581
582 if (style & wxSTAY_ON_TOP)
583 {
584 gtk_window_set_keep_above(GTK_WINDOW(m_widget), TRUE);
585 }
586 if (style & wxMAXIMIZE)
587 gtk_window_maximize(GTK_WINDOW(m_widget));
588
589 #if 0
590 if (!name.empty())
591 gtk_window_set_role( GTK_WINDOW(m_widget), wxGTK_CONV( name ) );
592 #endif
593
594 gtk_window_set_title( GTK_WINDOW(m_widget), wxGTK_CONV( title ) );
595 gtk_widget_set_can_focus(m_widget, false);
596
597 g_signal_connect (m_widget, "delete_event",
598 G_CALLBACK (gtk_frame_delete_callback), this);
599
600 // m_mainWidget is a GtkVBox, holding the bars and client area (m_wxwindow)
601 m_mainWidget = gtk_vbox_new(false, 0);
602 gtk_widget_show( m_mainWidget );
603 gtk_widget_set_can_focus(m_mainWidget, false);
604 gtk_container_add( GTK_CONTAINER(m_widget), m_mainWidget );
605
606 // m_wxwindow is the client area
607 m_wxwindow = wxPizza::New();
608 gtk_widget_show( m_wxwindow );
609 gtk_container_add( GTK_CONTAINER(m_mainWidget), m_wxwindow );
610
611 // we donm't allow the frame to get the focus as otherwise
612 // the frame will grab it at arbitrary focus changes
613 gtk_widget_set_can_focus(m_wxwindow, false);
614
615 if (m_parent) m_parent->AddChild( this );
616
617 g_signal_connect(m_wxwindow, "size_allocate",
618 G_CALLBACK(size_allocate), this);
619
620 PostCreation();
621
622 #ifndef __WXGTK3__
623 if ((m_x != -1) || (m_y != -1))
624 gtk_widget_set_uposition( m_widget, m_x, m_y );
625 #endif
626
627 // for some reported size corrections
628 g_signal_connect (m_widget, "map_event",
629 G_CALLBACK (gtk_frame_map_callback), this);
630
631 // for iconized state
632 g_signal_connect (m_widget, "window_state_event",
633 G_CALLBACK (gtk_frame_window_state_callback), this);
634
635
636 // for wxMoveEvent
637 g_signal_connect (m_widget, "configure_event",
638 G_CALLBACK (gtk_frame_configure_callback), this);
639
640 // activation
641 g_signal_connect_after (m_widget, "focus_in_event",
642 G_CALLBACK (gtk_frame_focus_in_callback), this);
643 g_signal_connect_after (m_widget, "focus_out_event",
644 G_CALLBACK (gtk_frame_focus_out_callback), this);
645
646 // GTK processes key events at the top level first, which handles for
647 // menu accelerators and shortcuts before passing the event on to the
648 // focus child window to begin propagation. We want to propagate
649 // first, so we connect gtk_window_propagate_key_event to
650 // key_press_event.
651 g_signal_connect (m_widget, "key_press_event",
652 G_CALLBACK (gtk_window_propagate_key_event), NULL);
653
654 #ifdef GDK_WINDOWING_X11
655 #ifdef __WXGTK3__
656 if (GDK_IS_X11_SCREEN(gtk_window_get_screen(GTK_WINDOW(m_widget))))
657 #endif
658 {
659 gtk_widget_add_events(m_widget, GDK_PROPERTY_CHANGE_MASK);
660 g_signal_connect(m_widget, "property_notify_event",
661 G_CALLBACK(property_notify_event), this);
662 }
663 #endif // GDK_WINDOWING_X11
664
665 // translate wx decorations styles into Motif WM hints (they are recognized
666 // by other WMs as well)
667
668 // always enable moving the window as we have no separate flag for enabling
669 // it
670 m_gdkFunc = GDK_FUNC_MOVE;
671
672 if ( style & wxCLOSE_BOX )
673 m_gdkFunc |= GDK_FUNC_CLOSE;
674
675 if ( style & wxMINIMIZE_BOX )
676 m_gdkFunc |= GDK_FUNC_MINIMIZE;
677
678 if ( style & wxMAXIMIZE_BOX )
679 m_gdkFunc |= GDK_FUNC_MAXIMIZE;
680
681 if ( (style & wxSIMPLE_BORDER) || (style & wxNO_BORDER) )
682 {
683 m_gdkDecor = 0;
684 }
685 else // have border
686 {
687 m_gdkDecor = GDK_DECOR_BORDER;
688
689 if ( style & wxCAPTION )
690 m_gdkDecor |= GDK_DECOR_TITLE;
691
692 if ( style & wxSYSTEM_MENU )
693 m_gdkDecor |= GDK_DECOR_MENU;
694
695 if ( style & wxMINIMIZE_BOX )
696 m_gdkDecor |= GDK_DECOR_MINIMIZE;
697
698 if ( style & wxMAXIMIZE_BOX )
699 m_gdkDecor |= GDK_DECOR_MAXIMIZE;
700
701 if ( style & wxRESIZE_BORDER )
702 {
703 m_gdkFunc |= GDK_FUNC_RESIZE;
704 m_gdkDecor |= GDK_DECOR_RESIZEH;
705 }
706 }
707
708 // GTK sometimes chooses very small size if max size hint is not explicitly set
709 DoSetSizeHints(m_minWidth, m_minHeight, m_maxWidth, m_maxHeight, m_incWidth, m_incHeight);
710
711 m_decorSize = GetCachedDecorSize();
712 int w, h;
713 GTKDoGetSize(&w, &h);
714 gtk_window_set_default_size(GTK_WINDOW(m_widget), w, h);
715
716 return true;
717 }
718
719 wxTopLevelWindowGTK::~wxTopLevelWindowGTK()
720 {
721 if ( m_netFrameExtentsTimerId )
722 {
723 // Don't let the timer callback fire as the window pointer passed to it
724 // will become invalid very soon.
725 g_source_remove(m_netFrameExtentsTimerId);
726 }
727
728 #if wxUSE_LIBHILDON || wxUSE_LIBHILDON2
729 // it can also be a (standard) dialog
730 if ( HILDON_IS_WINDOW(m_widget) )
731 {
732 hildon_program_remove_window(wxTheApp->GetHildonProgram(),
733 HILDON_WINDOW(m_widget));
734 }
735 #endif // wxUSE_LIBHILDON || wxUSE_LIBHILDON2
736
737 if (m_grabbed)
738 {
739 wxFAIL_MSG(wxT("Window still grabbed"));
740 RemoveGrab();
741 }
742
743 SendDestroyEvent();
744
745 // it may also be GtkScrolledWindow in the case of an MDI child
746 if (GTK_IS_WINDOW(m_widget))
747 {
748 gtk_window_set_focus( GTK_WINDOW(m_widget), NULL );
749 }
750
751 if (g_activeFrame == this)
752 g_activeFrame = NULL;
753 if (g_lastActiveFrame == this)
754 g_lastActiveFrame = NULL;
755 }
756
757 bool wxTopLevelWindowGTK::EnableCloseButton( bool enable )
758 {
759 if (enable)
760 m_gdkFunc |= GDK_FUNC_CLOSE;
761 else
762 m_gdkFunc &= ~GDK_FUNC_CLOSE;
763
764 GdkWindow* window = gtk_widget_get_window(m_widget);
765 if (window)
766 gdk_window_set_functions(window, (GdkWMFunction)m_gdkFunc);
767
768 return true;
769 }
770
771 bool wxTopLevelWindowGTK::ShowFullScreen(bool show, long)
772 {
773 if (show == m_fsIsShowing)
774 return false; // return what?
775
776 m_fsIsShowing = show;
777
778 #ifdef GDK_WINDOWING_X11
779 Display* xdpy = GDK_DISPLAY_XDISPLAY(gtk_widget_get_display(m_widget));
780 Window xroot = GDK_WINDOW_XID(gtk_widget_get_root_window(m_widget));
781 wxX11FullScreenMethod method = wxGetFullScreenMethodX11(xdpy, (WXWindow)xroot);
782
783 // NB: gtk_window_fullscreen() uses freedesktop.org's WMspec extensions
784 // to switch to fullscreen, which is not always available. We must
785 // check if WM supports the spec and use legacy methods if it
786 // doesn't.
787 if ( method == wxX11_FS_WMSPEC )
788 #endif // GDK_WINDOWING_X11
789 {
790 if (show)
791 gtk_window_fullscreen( GTK_WINDOW( m_widget ) );
792 else
793 gtk_window_unfullscreen( GTK_WINDOW( m_widget ) );
794 }
795 #ifdef GDK_WINDOWING_X11
796 else
797 {
798 GdkWindow* window = gtk_widget_get_window(m_widget);
799 Window xid = GDK_WINDOW_XID(window);
800
801 if (show)
802 {
803 GetPosition( &m_fsSaveFrame.x, &m_fsSaveFrame.y );
804 GetSize( &m_fsSaveFrame.width, &m_fsSaveFrame.height );
805
806 GdkScreen* screen = gtk_widget_get_screen(m_widget);
807 const int screen_width = gdk_screen_get_width(screen);
808 const int screen_height = gdk_screen_get_height(screen);
809
810 gint client_x, client_y, root_x, root_y;
811 gint width, height;
812
813 m_fsSaveGdkFunc = m_gdkFunc;
814 m_fsSaveGdkDecor = m_gdkDecor;
815 m_gdkFunc = m_gdkDecor = 0;
816 gdk_window_set_decorations(window, (GdkWMDecoration)0);
817 gdk_window_set_functions(window, (GdkWMFunction)0);
818
819 gdk_window_get_origin(window, &root_x, &root_y);
820 gdk_window_get_geometry(window, &client_x, &client_y, &width, &height);
821
822 gdk_window_move_resize(
823 window, -client_x, -client_y, screen_width + 1, screen_height + 1);
824
825 wxSetFullScreenStateX11(xdpy,
826 (WXWindow)xroot,
827 (WXWindow)xid,
828 show, &m_fsSaveFrame, method);
829 }
830 else // hide
831 {
832 m_gdkFunc = m_fsSaveGdkFunc;
833 m_gdkDecor = m_fsSaveGdkDecor;
834 gdk_window_set_decorations(window, (GdkWMDecoration)m_gdkDecor);
835 gdk_window_set_functions(window, (GdkWMFunction)m_gdkFunc);
836
837 wxSetFullScreenStateX11(xdpy,
838 (WXWindow)xroot,
839 (WXWindow)xid,
840 show, &m_fsSaveFrame, method);
841
842 SetSize(m_fsSaveFrame.x, m_fsSaveFrame.y,
843 m_fsSaveFrame.width, m_fsSaveFrame.height);
844 }
845 }
846 #endif // GDK_WINDOWING_X11
847
848 // documented behaviour is to show the window if it's still hidden when
849 // showing it full screen
850 if (show)
851 Show();
852
853 return true;
854 }
855
856 // ----------------------------------------------------------------------------
857 // overridden wxWindow methods
858 // ----------------------------------------------------------------------------
859
860 void wxTopLevelWindowGTK::Refresh( bool WXUNUSED(eraseBackground), const wxRect *WXUNUSED(rect) )
861 {
862 wxCHECK_RET( m_widget, wxT("invalid frame") );
863
864 gtk_widget_queue_draw( m_widget );
865
866 GdkWindow* window = NULL;
867 if (m_wxwindow)
868 window = gtk_widget_get_window(m_wxwindow);
869 if (window)
870 gdk_window_invalidate_rect(window, NULL, true);
871 }
872
873 bool wxTopLevelWindowGTK::Show( bool show )
874 {
875 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
876
877 #ifdef GDK_WINDOWING_X11
878 bool deferShow = show && !m_isShown && m_deferShow;
879 if (deferShow)
880 {
881 deferShow = m_deferShowAllowed && gs_requestFrameExtentsStatus != 2 &&
882 !gtk_widget_get_realized(m_widget) &&
883 g_signal_handler_find(m_widget,
884 GSignalMatchType(G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_DATA),
885 g_signal_lookup("property_notify_event", GTK_TYPE_WIDGET),
886 0, NULL, NULL, this);
887 if (deferShow)
888 {
889 GdkScreen* screen = gtk_widget_get_screen(m_widget);
890 GdkAtom atom = gdk_atom_intern("_NET_REQUEST_FRAME_EXTENTS", false);
891 deferShow = gdk_x11_screen_supports_net_wm_hint(screen, atom) != 0;
892
893 // If _NET_REQUEST_FRAME_EXTENTS not supported, don't allow changes
894 // to m_decorSize, it breaks saving/restoring window size with
895 // GetSize()/SetSize() because it makes window bigger between each
896 // restore and save.
897 m_updateDecorSize = deferShow;
898 }
899
900 m_deferShow = deferShow;
901 }
902 if (deferShow)
903 {
904 // Initial show. If WM supports _NET_REQUEST_FRAME_EXTENTS, defer
905 // calling gtk_widget_show() until _NET_FRAME_EXTENTS property
906 // notification is received, so correct frame extents are known.
907 // This allows resizing m_widget to keep the overall size in sync with
908 // what wxWidgets expects it to be without an obvious change in the
909 // window size immediately after it becomes visible.
910
911 // Realize m_widget, so m_widget->window can be used. Realizing normally
912 // causes the widget tree to be size_allocated, which generates size
913 // events in the wrong order. However, the size_allocates will not be
914 // done if the allocation is not the default (1,1).
915 GtkAllocation alloc;
916 gtk_widget_get_allocation(m_widget, &alloc);
917 const int alloc_width = alloc.width;
918 if (alloc_width == 1)
919 {
920 alloc.width = 2;
921 gtk_widget_set_allocation(m_widget, &alloc);
922 }
923 gtk_widget_realize(m_widget);
924 if (alloc_width == 1)
925 {
926 alloc.width = 1;
927 gtk_widget_set_allocation(m_widget, &alloc);
928 }
929
930 // send _NET_REQUEST_FRAME_EXTENTS
931 XClientMessageEvent xevent;
932 memset(&xevent, 0, sizeof(xevent));
933 xevent.type = ClientMessage;
934 GdkWindow* window = gtk_widget_get_window(m_widget);
935 xevent.window = GDK_WINDOW_XID(window);
936 xevent.message_type = gdk_x11_atom_to_xatom_for_display(
937 gdk_window_get_display(window),
938 gdk_atom_intern("_NET_REQUEST_FRAME_EXTENTS", false));
939 xevent.format = 32;
940 Display* display = GDK_DISPLAY_XDISPLAY(gdk_window_get_display(window));
941 XSendEvent(display, DefaultRootWindow(display), false,
942 SubstructureNotifyMask | SubstructureRedirectMask,
943 (XEvent*)&xevent);
944
945 if (gs_requestFrameExtentsStatus == 0)
946 {
947 // if WM does not respond to request within 1 second,
948 // we assume support for _NET_REQUEST_FRAME_EXTENTS is not working
949 m_netFrameExtentsTimerId =
950 g_timeout_add(1000, request_frame_extents_timeout, this);
951 }
952
953 // defer calling gtk_widget_show()
954 m_isShown = true;
955 return true;
956 }
957 #endif // GDK_WINDOWING_X11
958
959 if (show && !gtk_widget_get_realized(m_widget))
960 {
961 // size_allocate signals occur in reverse order (bottom to top).
962 // Things work better if the initial wxSizeEvents are sent (from the
963 // top down), before the initial size_allocate signals occur.
964 wxSizeEvent event(GetSize(), GetId());
965 event.SetEventObject(this);
966 HandleWindowEvent(event);
967 }
968
969 bool change = base_type::Show(show);
970
971 if (change && !show)
972 {
973 // make sure window has a non-default position, so when it is shown
974 // again, it won't be repositioned by WM as if it were a new window
975 // Note that this must be done _after_ the window is hidden.
976 gtk_window_move((GtkWindow*)m_widget, m_x, m_y);
977 }
978
979 return change;
980 }
981
982 void wxTopLevelWindowGTK::ShowWithoutActivating()
983 {
984 if (!m_isShown)
985 {
986 gtk_window_set_focus_on_map(GTK_WINDOW(m_widget), false);
987 Show(true);
988 }
989 }
990
991 void wxTopLevelWindowGTK::Raise()
992 {
993 gtk_window_present( GTK_WINDOW( m_widget ) );
994 }
995
996 void wxTopLevelWindowGTK::DoMoveWindow(int WXUNUSED(x), int WXUNUSED(y), int WXUNUSED(width), int WXUNUSED(height) )
997 {
998 wxFAIL_MSG( wxT("DoMoveWindow called for wxTopLevelWindowGTK") );
999 }
1000
1001 // ----------------------------------------------------------------------------
1002 // window geometry
1003 // ----------------------------------------------------------------------------
1004
1005 void wxTopLevelWindowGTK::GTKDoGetSize(int *width, int *height) const
1006 {
1007 wxSize size(m_width, m_height);
1008 size -= m_decorSize;
1009 if (size.x < 0) size.x = 0;
1010 if (size.y < 0) size.y = 0;
1011 #if wxUSE_LIBHILDON2
1012 if (width) {
1013 if (size.x == 720)
1014 *width = 696;
1015 else
1016 *width = size.x;
1017 }
1018 if (height) {
1019 if (size.y == 420)
1020 *height = 396;
1021 else if (size.y == 270)
1022 *height = 246;
1023 else
1024 *height = size.y;
1025 }
1026 #else // wxUSE_LIBHILDON2
1027 if (width) *width = size.x;
1028 if (height) *height = size.y;
1029 #endif // wxUSE_LIBHILDON2 /!wxUSE_LIBHILDON2
1030 }
1031
1032 void wxTopLevelWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags )
1033 {
1034 wxCHECK_RET( m_widget, wxT("invalid frame") );
1035
1036 // deal with the position first
1037 int old_x = m_x;
1038 int old_y = m_y;
1039
1040 if ( !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE) )
1041 {
1042 // -1 means "use existing" unless the flag above is specified
1043 if ( x != -1 )
1044 m_x = x;
1045 if ( y != -1 )
1046 m_y = y;
1047 }
1048 else // wxSIZE_ALLOW_MINUS_ONE
1049 {
1050 m_x = x;
1051 m_y = y;
1052 }
1053
1054 if ( m_x != old_x || m_y != old_y )
1055 {
1056 gtk_window_move( GTK_WINDOW(m_widget), m_x, m_y );
1057 }
1058
1059 const wxSize oldSize(m_width, m_height);
1060 if (width >= 0)
1061 m_width = width;
1062 if (height >= 0)
1063 m_height = height;
1064 ConstrainSize();
1065 if (m_width < 1) m_width = 1;
1066 if (m_height < 1) m_height = 1;
1067 if (m_width != oldSize.x || m_height != oldSize.y)
1068 {
1069 m_deferShowAllowed = true;
1070
1071 int w, h;
1072 GTKDoGetSize(&w, &h);
1073 gtk_window_resize(GTK_WINDOW(m_widget), w, h);
1074
1075 GetClientSize(&m_oldClientWidth, &m_oldClientHeight);
1076 wxSizeEvent event(GetSize(), GetId());
1077 event.SetEventObject(this);
1078 HandleWindowEvent(event);
1079 }
1080 }
1081
1082 void wxTopLevelWindowGTK::DoSetClientSize(int width, int height)
1083 {
1084 base_type::DoSetClientSize(width, height);
1085
1086 // Since client size is being explicitly set, don't change it later
1087 // Has to be done after calling base because it calls SetSize,
1088 // which sets this true
1089 m_deferShowAllowed = false;
1090 }
1091
1092 void wxTopLevelWindowGTK::DoGetClientSize( int *width, int *height ) const
1093 {
1094 wxASSERT_MSG(m_widget, wxT("invalid frame"));
1095
1096 if ( IsIconized() )
1097 {
1098 // for consistency with wxMSW, client area is supposed to be empty for
1099 // the iconized windows
1100 if ( width )
1101 *width = 0;
1102 if ( height )
1103 *height = 0;
1104 }
1105 else
1106 {
1107 GTKDoGetSize(width, height);
1108 }
1109 }
1110
1111 void wxTopLevelWindowGTK::DoSetSizeHints( int minW, int minH,
1112 int maxW, int maxH,
1113 int incW, int incH )
1114 {
1115 base_type::DoSetSizeHints(minW, minH, maxW, maxH, incW, incH);
1116 m_incWidth = incW;
1117 m_incHeight = incH;
1118
1119 const wxSize minSize = GetMinSize();
1120 const wxSize maxSize = GetMaxSize();
1121 GdkGeometry hints;
1122 // always set both min and max hints, otherwise GTK will
1123 // make assumptions we don't want about the unset values
1124 int hints_mask = GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE;
1125 hints.min_width = 1;
1126 hints.min_height = 1;
1127 hints.max_width = INT_MAX;
1128 hints.max_height = INT_MAX;
1129 if (minSize.x > m_decorSize.x)
1130 hints.min_width = minSize.x - m_decorSize.x;
1131 if (minSize.y > m_decorSize.y)
1132 hints.min_height = minSize.y - m_decorSize.y;
1133 if (maxSize.x > 0)
1134 {
1135 hints.max_width = maxSize.x - m_decorSize.x;
1136 if (hints.max_width < hints.min_width)
1137 hints.max_width = hints.min_width;
1138 }
1139 if (maxSize.y > 0)
1140 {
1141 hints.max_height = maxSize.y - m_decorSize.y;
1142 if (hints.max_height < hints.min_height)
1143 hints.max_height = hints.min_height;
1144 }
1145 if (incW > 0 || incH > 0)
1146 {
1147 hints_mask |= GDK_HINT_RESIZE_INC;
1148 hints.width_inc = incW > 0 ? incW : 1;
1149 hints.height_inc = incH > 0 ? incH : 1;
1150 }
1151 gtk_window_set_geometry_hints(
1152 (GtkWindow*)m_widget, NULL, &hints, (GdkWindowHints)hints_mask);
1153 }
1154
1155 #ifdef GDK_WINDOWING_X11
1156 void wxTopLevelWindowGTK::GTKUpdateDecorSize(const wxSize& decorSize)
1157 {
1158 if (!IsMaximized() && !IsFullScreen())
1159 GetCachedDecorSize() = decorSize;
1160 if (m_updateDecorSize && m_decorSize != decorSize)
1161 {
1162 const wxSize diff = decorSize - m_decorSize;
1163 m_decorSize = decorSize;
1164 bool resized = false;
1165 if (m_minWidth > 0 || m_minHeight > 0 || m_maxWidth > 0 || m_maxHeight > 0)
1166 {
1167 // update size hints, they depend on m_decorSize
1168 DoSetSizeHints(m_minWidth, m_minHeight, m_maxWidth, m_maxHeight, m_incWidth, m_incHeight);
1169 }
1170 if (m_deferShow)
1171 {
1172 // keep overall size unchanged by shrinking m_widget
1173 int w, h;
1174 GTKDoGetSize(&w, &h);
1175 // but not if size would be less than minimum, it won't take effect
1176 if (w >= m_minWidth - decorSize.x && h >= m_minHeight - decorSize.y )
1177 {
1178 gtk_window_resize(GTK_WINDOW(m_widget), w, h);
1179 resized = true;
1180 }
1181 }
1182 if (!resized)
1183 {
1184 // adjust overall size to match change in frame extents
1185 m_width += diff.x;
1186 m_height += diff.y;
1187 if (m_width < 1) m_width = 1;
1188 if (m_height < 1) m_height = 1;
1189 m_oldClientWidth = 0;
1190 gtk_widget_queue_resize(m_wxwindow);
1191 }
1192 }
1193 if (m_deferShow)
1194 {
1195 // gtk_widget_show() was deferred, do it now
1196 m_deferShow = false;
1197 GetClientSize(&m_oldClientWidth, &m_oldClientHeight);
1198 wxSizeEvent sizeEvent(GetSize(), GetId());
1199 sizeEvent.SetEventObject(this);
1200 HandleWindowEvent(sizeEvent);
1201
1202 gtk_widget_show(m_widget);
1203
1204 wxShowEvent showEvent(GetId(), true);
1205 showEvent.SetEventObject(this);
1206 HandleWindowEvent(showEvent);
1207 }
1208 }
1209 #endif // GDK_WINDOWING_X11
1210
1211 wxSize& wxTopLevelWindowGTK::GetCachedDecorSize()
1212 {
1213 static wxSize size[8];
1214
1215 int index = 0;
1216 // title bar
1217 if (m_gdkDecor & (GDK_DECOR_MENU | GDK_DECOR_MINIMIZE | GDK_DECOR_MAXIMIZE | GDK_DECOR_TITLE))
1218 index = 1;
1219 // border
1220 if (m_gdkDecor & GDK_DECOR_BORDER)
1221 index |= 2;
1222 // utility window decor can be different
1223 if (m_windowStyle & wxFRAME_TOOL_WINDOW)
1224 index |= 4;
1225 return size[index];
1226 }
1227
1228 void wxTopLevelWindowGTK::OnInternalIdle()
1229 {
1230 wxTopLevelWindowBase::OnInternalIdle();
1231
1232 // Synthetize activate events.
1233 if ( g_sendActivateEvent != -1 )
1234 {
1235 bool activate = g_sendActivateEvent != 0;
1236
1237 // if (!activate) wxPrintf( wxT("de") );
1238 // wxPrintf( wxT("activate\n") );
1239
1240 // do it only once
1241 g_sendActivateEvent = -1;
1242
1243 wxTheApp->SetActive(activate, (wxWindow *)g_lastActiveFrame);
1244 }
1245 }
1246
1247 // ----------------------------------------------------------------------------
1248 // frame title/icon
1249 // ----------------------------------------------------------------------------
1250
1251 void wxTopLevelWindowGTK::SetTitle( const wxString &title )
1252 {
1253 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
1254
1255 if ( title == m_title )
1256 return;
1257
1258 m_title = title;
1259
1260 gtk_window_set_title( GTK_WINDOW(m_widget), wxGTK_CONV( title ) );
1261 }
1262
1263 void wxTopLevelWindowGTK::SetIcons( const wxIconBundle &icons )
1264 {
1265 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
1266
1267 base_type::SetIcons(icons);
1268
1269 // Setting icons before window is realized can cause a GTK assertion if
1270 // another TLW is realized before this one, and it has this one as it's
1271 // transient parent. The life demo exibits this problem.
1272 if (gtk_widget_get_realized(m_widget))
1273 {
1274 GList* list = NULL;
1275 for (size_t i = icons.GetIconCount(); i--;)
1276 list = g_list_prepend(list, icons.GetIconByIndex(i).GetPixbuf());
1277 gtk_window_set_icon_list(GTK_WINDOW(m_widget), list);
1278 g_list_free(list);
1279 }
1280 }
1281
1282 // ----------------------------------------------------------------------------
1283 // frame state: maximized/iconized/normal
1284 // ----------------------------------------------------------------------------
1285
1286 void wxTopLevelWindowGTK::Maximize(bool maximize)
1287 {
1288 if (maximize)
1289 gtk_window_maximize( GTK_WINDOW( m_widget ) );
1290 else
1291 gtk_window_unmaximize( GTK_WINDOW( m_widget ) );
1292 }
1293
1294 bool wxTopLevelWindowGTK::IsMaximized() const
1295 {
1296 GdkWindow* window = NULL;
1297 if (m_widget)
1298 window = gtk_widget_get_window(m_widget);
1299 return window && (gdk_window_get_state(window) & GDK_WINDOW_STATE_MAXIMIZED);
1300 }
1301
1302 void wxTopLevelWindowGTK::Restore()
1303 {
1304 // "Present" seems similar enough to "restore"
1305 gtk_window_present( GTK_WINDOW( m_widget ) );
1306 }
1307
1308 void wxTopLevelWindowGTK::Iconize( bool iconize )
1309 {
1310 if (iconize)
1311 gtk_window_iconify( GTK_WINDOW( m_widget ) );
1312 else
1313 gtk_window_deiconify( GTK_WINDOW( m_widget ) );
1314 }
1315
1316 bool wxTopLevelWindowGTK::IsIconized() const
1317 {
1318 return m_isIconized;
1319 }
1320
1321 void wxTopLevelWindowGTK::SetIconizeState(bool iconize)
1322 {
1323 if ( iconize != m_isIconized )
1324 {
1325 m_isIconized = iconize;
1326 (void)SendIconizeEvent(iconize);
1327 }
1328 }
1329
1330 void wxTopLevelWindowGTK::AddGrab()
1331 {
1332 if (!m_grabbed)
1333 {
1334 m_grabbed = true;
1335 gtk_grab_add( m_widget );
1336 wxGUIEventLoop().Run();
1337 gtk_grab_remove( m_widget );
1338 }
1339 }
1340
1341 void wxTopLevelWindowGTK::RemoveGrab()
1342 {
1343 if (m_grabbed)
1344 {
1345 gtk_main_quit();
1346 m_grabbed = false;
1347 }
1348 }
1349
1350 bool wxTopLevelWindowGTK::IsActive()
1351 {
1352 return (this == (wxTopLevelWindowGTK*)g_activeFrame);
1353 }
1354
1355 void wxTopLevelWindowGTK::RequestUserAttention(int flags)
1356 {
1357 bool new_hint_value = false;
1358
1359 // FIXME: This is a workaround to focus handling problem
1360 // If RequestUserAttention is called for example right after a wxSleep, OnInternalIdle
1361 // hasn't yet been processed, and the internal focus system is not up to date yet.
1362 // YieldFor(wxEVT_CATEGORY_UI) ensures the processing of it (hopefully it
1363 // won't have side effects) - MR
1364 wxEventLoopBase::GetActive()->YieldFor(wxEVT_CATEGORY_UI);
1365
1366 if(m_urgency_hint >= 0)
1367 g_source_remove(m_urgency_hint);
1368
1369 m_urgency_hint = -2;
1370
1371 if( gtk_widget_get_realized(m_widget) && !IsActive() )
1372 {
1373 new_hint_value = true;
1374
1375 if (flags & wxUSER_ATTENTION_INFO)
1376 {
1377 m_urgency_hint = g_timeout_add(5000, (GSourceFunc)gtk_frame_urgency_timer_callback, this);
1378 } else {
1379 m_urgency_hint = -1;
1380 }
1381 }
1382
1383 gtk_window_set_urgency_hint(GTK_WINDOW(m_widget), new_hint_value);
1384 }
1385
1386 void wxTopLevelWindowGTK::SetWindowStyleFlag( long style )
1387 {
1388 // Store which styles were changed
1389 long styleChanges = style ^ m_windowStyle;
1390
1391 // Process wxWindow styles. This also updates the internal variable
1392 // Therefore m_windowStyle bits carry now the _new_ style values
1393 wxWindow::SetWindowStyleFlag(style);
1394
1395 // just return for now if widget does not exist yet
1396 if (!m_widget)
1397 return;
1398
1399 if ( styleChanges & wxSTAY_ON_TOP )
1400 {
1401 gtk_window_set_keep_above(GTK_WINDOW(m_widget),
1402 m_windowStyle & wxSTAY_ON_TOP);
1403 }
1404
1405 if ( styleChanges & wxFRAME_NO_TASKBAR )
1406 {
1407 gtk_window_set_skip_taskbar_hint(GTK_WINDOW(m_widget),
1408 m_windowStyle & wxFRAME_NO_TASKBAR);
1409 }
1410 }
1411
1412 bool wxTopLevelWindowGTK::SetTransparent(wxByte alpha)
1413 {
1414 GdkWindow* window = NULL;
1415 if (m_widget)
1416 window = gtk_widget_get_window(m_widget);
1417 if (window == NULL)
1418 return false;
1419
1420 #ifdef GDK_WINDOWING_X11
1421 Display* dpy = GDK_WINDOW_XDISPLAY(window);
1422 Window win = GDK_WINDOW_XID(window);
1423
1424 // Using pure Xlib to not have a GTK version check mess due to gtk2.0 not having GdkDisplay
1425 if (alpha == 0xff)
1426 XDeleteProperty(dpy, win, XInternAtom(dpy, "_NET_WM_WINDOW_OPACITY", False));
1427 else
1428 {
1429 long opacity = alpha * 0x1010101L;
1430 XChangeProperty(dpy, win, XInternAtom(dpy, "_NET_WM_WINDOW_OPACITY", False),
1431 XA_CARDINAL, 32, PropModeReplace,
1432 (unsigned char *) &opacity, 1L);
1433 }
1434 XSync(dpy, False);
1435 return true;
1436 #else // !GDK_WINDOWING_X11
1437 return false;
1438 #endif // GDK_WINDOWING_X11 / !GDK_WINDOWING_X11
1439 }
1440
1441 bool wxTopLevelWindowGTK::CanSetTransparent()
1442 {
1443 // allow to override automatic detection as it's far from perfect
1444 const wxString SYSOPT_TRANSPARENT = "gtk.tlw.can-set-transparent";
1445 if ( wxSystemOptions::HasOption(SYSOPT_TRANSPARENT) )
1446 {
1447 return wxSystemOptions::GetOptionInt(SYSOPT_TRANSPARENT) != 0;
1448 }
1449
1450 #ifdef __WXGTK3__
1451 return gtk_widget_is_composited(m_widget) != 0;
1452 #else
1453 #if GTK_CHECK_VERSION(2,10,0)
1454 if (!gtk_check_version(2,10,0))
1455 {
1456 return gtk_widget_is_composited(m_widget) != 0;
1457 }
1458 else
1459 #endif // In case of lower versions than gtk+-2.10.0 we could look for _NET_WM_CM_Sn ourselves
1460 {
1461 return false;
1462 }
1463 #endif // !__WXGTK3__
1464
1465 #if 0 // Don't be optimistic here for the sake of wxAUI
1466 int opcode, event, error;
1467 // Check for the existence of a RGBA visual instead?
1468 return XQueryExtension(gdk_x11_get_default_xdisplay (),
1469 "Composite", &opcode, &event, &error);
1470 #endif
1471 }
wxWidgets (Impactor)