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