]> git.saurik.com Git - wxWidgets.git/blob - src/gtk/toplevel.cpp
projects / wxWidgets.git / blob
? search:


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