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


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