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


e7928601176762d4e7d4fb46ab6181a9f7a0c0a7
[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 gboolean gtk_frame_focus_out_callback( GtkWidget *widget,
171 GdkEventFocus *WXUNUSED(gdk_event),
172 wxTopLevelWindowGTK *win )
173 {
174 // if the focus goes out of our app alltogether, OnIdle() will send
175 // wxActivateEvent, otherwise gtk_window_focus_in_callback() will reset
176 // g_sendActivateEvent to -1
177 g_sendActivateEvent = 0;
178
179 // wxASSERT_MSG( (g_activeFrame == win), wxT("TLW deactivatd although it wasn't active") );
180
181 // wxPrintf( wxT("inactive: %s\n"), win->GetTitle().c_str() );
182
183 if (g_activeFrame)
184 {
185 wxLogTrace(wxT("activate"), wxT("Activating frame %p (from focus_in)"), g_activeFrame);
186 wxActivateEvent event(wxEVT_ACTIVATE, false, g_activeFrame->GetId());
187 event.SetEventObject(g_activeFrame);
188 g_activeFrame->GetEventHandler()->ProcessEvent(event);
189
190 g_activeFrame = NULL;
191 }
192
193 return FALSE;
194 }
195 }
196
197 //-----------------------------------------------------------------------------
198 // "size_allocate"
199 //-----------------------------------------------------------------------------
200
201 extern "C" {
202 static void gtk_frame_size_callback( GtkWidget *WXUNUSED(widget), GtkAllocation* alloc, wxTopLevelWindowGTK *win )
203 {
204 if (!win->m_hasVMT)
205 return;
206
207 if ((win->m_width != alloc->width) || (win->m_height != alloc->height))
208 {
209 /*
210 wxPrintf( wxT("gtk_frame_size_callback from ") );
211 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
212 wxPrintf( win->GetClassInfo()->GetClassName() );
213 wxPrintf( wxT(" %d %d %d %d\n"), (int)alloc->x,
214 (int)alloc->y,
215 (int)alloc->width,
216 (int)alloc->height );
217 */
218
219 // Tell the wxWindow class about the new size
220 win->m_width = alloc->width;
221 win->m_height = alloc->height;
222
223 win->GtkUpdateSize();
224 }
225 }
226 }
227
228 // ----------------------------------------------------------------------------
229 // "size_request"
230 // ----------------------------------------------------------------------------
231
232 extern "C" {
233 void wxgtk_tlw_size_request_callback(GtkWidget * WXUNUSED(widget),
234 GtkRequisition *requisition,
235 wxTopLevelWindowGTK *win)
236 {
237 // we must return the size of the window without WM decorations, otherwise
238 // GTK+ gets confused, so don't call just GetSize() here
239 int w, h;
240 win->GTKDoGetSize(&w, &h);
241
242 requisition->height = h;
243 requisition->width = w;
244 }
245 }
246 //-----------------------------------------------------------------------------
247 // "delete_event"
248 //-----------------------------------------------------------------------------
249
250 extern "C" {
251 static gboolean
252 gtk_frame_delete_callback( GtkWidget *WXUNUSED(widget),
253 GdkEvent *WXUNUSED(event),
254 wxTopLevelWindowGTK *win )
255 {
256 if (win->IsEnabled() &&
257 (g_openDialogs == 0 || (win->GetExtraStyle() & wxTOPLEVEL_EX_DIALOG) ||
258 win->IsGrabbed()))
259 win->Close();
260
261 return TRUE;
262 }
263 }
264
265
266 //-----------------------------------------------------------------------------
267 // "configure_event"
268 //-----------------------------------------------------------------------------
269
270 extern "C" {
271 static gboolean
272 gtk_frame_configure_callback( GtkWidget* widget,
273 GdkEventConfigure *WXUNUSED(event),
274 wxTopLevelWindowGTK *win )
275 {
276 if (!win->m_hasVMT || !win->IsShown())
277 return FALSE;
278
279 wxPoint point;
280 gtk_window_get_position((GtkWindow*)widget, &point.x, &point.y);
281
282 win->m_x = point.x;
283 win->m_y = point.y;
284 wxMoveEvent mevent(point, win->GetId());
285 mevent.SetEventObject( win );
286 win->GetEventHandler()->ProcessEvent( mevent );
287
288 return FALSE;
289 }
290 }
291
292 //-----------------------------------------------------------------------------
293 // "realize" from m_widget
294 //-----------------------------------------------------------------------------
295
296 // we cannot MWM hints and icons before the widget has been realized,
297 // so we do this directly after realization
298
299 extern "C" {
300 static void
301 gtk_frame_realized_callback( GtkWidget * WXUNUSED(widget),
302 wxTopLevelWindowGTK *win )
303 {
304 // All this is for Motif Window Manager "hints" and is supposed to be
305 // recognized by other WM as well. Not tested.
306 gdk_window_set_decorations(win->m_widget->window,
307 (GdkWMDecoration)win->m_gdkDecor);
308 gdk_window_set_functions(win->m_widget->window,
309 (GdkWMFunction)win->m_gdkFunc);
310
311 // GTK's shrinking/growing policy
312 if ((win->m_gdkFunc & GDK_FUNC_RESIZE) == 0)
313 gtk_window_set_resizable(GTK_WINDOW(win->m_widget), FALSE);
314 else
315 gtk_window_set_policy(GTK_WINDOW(win->m_widget), 1, 1, 1);
316
317 // reset the icon
318 wxIconBundle iconsOld = win->GetIcons();
319 if ( !iconsOld.IsEmpty() )
320 {
321 win->SetIcon( wxNullIcon );
322 win->SetIcons( iconsOld );
323 }
324 }
325 }
326
327 //-----------------------------------------------------------------------------
328 // "map_event" from m_widget
329 //-----------------------------------------------------------------------------
330
331 extern "C" {
332 static gboolean
333 gtk_frame_map_callback( GtkWidget * WXUNUSED(widget),
334 GdkEvent * WXUNUSED(event),
335 wxTopLevelWindow *win )
336 {
337 win->SetIconizeState(false);
338 return false;
339 }
340 }
341
342 //-----------------------------------------------------------------------------
343 // "unmap_event" from m_widget
344 //-----------------------------------------------------------------------------
345
346 extern "C" {
347 static gboolean
348 gtk_frame_unmap_callback( GtkWidget * WXUNUSED(widget),
349 GdkEvent * WXUNUSED(event),
350 wxTopLevelWindow *win )
351 {
352 win->SetIconizeState(true);
353 return false;
354 }
355 }
356
357 //-----------------------------------------------------------------------------
358 // "expose_event" of m_client
359 //-----------------------------------------------------------------------------
360
361 extern "C" {
362 static gboolean
363 gtk_window_expose_callback( GtkWidget *widget,
364 GdkEventExpose *gdk_event,
365 wxWindow *win )
366 {
367 GtkPizza *pizza = GTK_PIZZA(widget);
368
369 gtk_paint_flat_box (win->m_widget->style,
370 pizza->bin_window, GTK_STATE_NORMAL,
371 GTK_SHADOW_NONE,
372 &gdk_event->area,
373 win->m_widget,
374 (char *)"base",
375 0, 0, -1, -1);
376
377 return FALSE;
378 }
379 }
380
381 // ----------------------------------------------------------------------------
382 // wxTopLevelWindowGTK itself
383 // ----------------------------------------------------------------------------
384
385 //-----------------------------------------------------------------------------
386 // InsertChild for wxTopLevelWindowGTK
387 //-----------------------------------------------------------------------------
388
389 /* Callback for wxTopLevelWindowGTK. This very strange beast has to be used because
390 * C++ has no virtual methods in a constructor. We have to emulate a
391 * virtual function here as wxWidgets requires different ways to insert
392 * a child in container classes. */
393
394 static void wxInsertChildInTopLevelWindow( wxTopLevelWindowGTK* parent, wxWindow* child )
395 {
396 wxASSERT( GTK_IS_WIDGET(child->m_widget) );
397
398 if (!parent->m_insertInClientArea)
399 {
400 // these are outside the client area
401 wxTopLevelWindowGTK* frame = (wxTopLevelWindowGTK*) parent;
402 gtk_pizza_put( GTK_PIZZA(frame->m_mainWidget),
403 child->m_widget,
404 child->m_x,
405 child->m_y,
406 child->m_width,
407 child->m_height );
408 }
409 else
410 {
411 // these are inside the client area
412 gtk_pizza_put( GTK_PIZZA(parent->m_wxwindow),
413 child->m_widget,
414 child->m_x,
415 child->m_y,
416 child->m_width,
417 child->m_height );
418 }
419 }
420
421 // ----------------------------------------------------------------------------
422 // wxTopLevelWindowGTK creation
423 // ----------------------------------------------------------------------------
424
425 void wxTopLevelWindowGTK::Init()
426 {
427 m_sizeSet = false;
428 m_miniEdge = 0;
429 m_miniTitle = 0;
430 m_mainWidget = (GtkWidget*) NULL;
431 m_insertInClientArea = true;
432 m_isIconized = false;
433 m_fsIsShowing = false;
434 m_fsSaveFlag = 0;
435 m_themeEnabled = true;
436 m_gdkDecor = m_gdkFunc = 0;
437 m_grabbed = false;
438
439 m_urgency_hint = -2;
440 }
441
442 bool wxTopLevelWindowGTK::Create( wxWindow *parent,
443 wxWindowID id,
444 const wxString& title,
445 const wxPoint& pos,
446 const wxSize& sizeOrig,
447 long style,
448 const wxString &name )
449 {
450 // always create a frame of some reasonable, even if arbitrary, size (at
451 // least for MSW compatibility)
452 wxSize size = sizeOrig;
453 size.x = WidthDefault(size.x);
454 size.y = HeightDefault(size.y);
455
456 wxTopLevelWindows.Append( this );
457
458 if (!PreCreation( parent, pos, size ) ||
459 !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
460 {
461 wxFAIL_MSG( wxT("wxTopLevelWindowGTK creation failed") );
462 return false;
463 }
464
465 m_title = title;
466
467 m_insertCallback = (wxInsertChildFunction) wxInsertChildInTopLevelWindow;
468
469 // NB: m_widget may be !=NULL if it was created by derived class' Create,
470 // e.g. in wxTaskBarIconAreaGTK
471 if (m_widget == NULL)
472 {
473 if (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG)
474 {
475 m_widget = gtk_window_new(GTK_WINDOW_TOPLEVEL);
476 // Tell WM that this is a dialog window and make it center
477 // on parent by default (this is what GtkDialog ctor does):
478 gtk_window_set_type_hint(GTK_WINDOW(m_widget),
479 GDK_WINDOW_TYPE_HINT_DIALOG);
480 gtk_window_set_position(GTK_WINDOW(m_widget),
481 GTK_WIN_POS_CENTER_ON_PARENT);
482 }
483 else
484 {
485 m_widget = gtk_window_new(GTK_WINDOW_TOPLEVEL);
486 #if GTK_CHECK_VERSION(2,1,0)
487 if (!gtk_check_version(2,1,0))
488 {
489 if (style & wxFRAME_TOOL_WINDOW)
490 {
491 gtk_window_set_type_hint(GTK_WINDOW(m_widget),
492 GDK_WINDOW_TYPE_HINT_UTILITY);
493
494 // On some WMs, like KDE, a TOOL_WINDOW will still show
495 // on the taskbar, but on Gnome a TOOL_WINDOW will not.
496 // For consistency between WMs and with Windows, we
497 // should set the NO_TASKBAR flag which will apply
498 // the set_skip_taskbar_hint if it is available,
499 // ensuring no taskbar entry will appear.
500 style |= wxFRAME_NO_TASKBAR;
501 }
502 }
503 #endif
504 }
505 }
506
507 wxWindow *topParent = wxGetTopLevelParent(m_parent);
508 if (topParent && (((GTK_IS_WINDOW(topParent->m_widget)) &&
509 (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG)) ||
510 (style & wxFRAME_FLOAT_ON_PARENT)))
511 {
512 gtk_window_set_transient_for( GTK_WINDOW(m_widget),
513 GTK_WINDOW(topParent->m_widget) );
514 }
515
516 #if GTK_CHECK_VERSION(2,2,0)
517 if (!gtk_check_version(2,2,0))
518 {
519 if (style & wxFRAME_NO_TASKBAR)
520 {
521 gtk_window_set_skip_taskbar_hint(GTK_WINDOW(m_widget), TRUE);
522 }
523 }
524 #endif
525
526 #ifdef __WXGTK24__
527 if (!gtk_check_version(2,4,0))
528 {
529 if (style & wxSTAY_ON_TOP)
530 {
531 gtk_window_set_keep_above(GTK_WINDOW(m_widget), TRUE);
532 }
533 }
534 #endif
535
536 #if 0
537 if (!name.empty())
538 gtk_window_set_role( GTK_WINDOW(m_widget), wxGTK_CONV( name ) );
539 #endif
540
541 gtk_window_set_title( GTK_WINDOW(m_widget), wxGTK_CONV( title ) );
542 GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
543
544 g_signal_connect (m_widget, "delete_event",
545 G_CALLBACK (gtk_frame_delete_callback), this);
546
547 // m_mainWidget holds the toolbar, the menubar and the client area
548 m_mainWidget = gtk_pizza_new();
549 gtk_widget_show( m_mainWidget );
550 GTK_WIDGET_UNSET_FLAGS( m_mainWidget, GTK_CAN_FOCUS );
551 gtk_container_add( GTK_CONTAINER(m_widget), m_mainWidget );
552
553 if (m_miniEdge == 0) // wxMiniFrame has its own version.
554 {
555 // For m_mainWidget themes
556 g_signal_connect (m_mainWidget, "expose_event",
557 G_CALLBACK (gtk_window_expose_callback), this);
558 }
559
560 // m_wxwindow only represents the client area without toolbar and menubar
561 m_wxwindow = gtk_pizza_new();
562 gtk_widget_show( m_wxwindow );
563 gtk_container_add( GTK_CONTAINER(m_mainWidget), m_wxwindow );
564
565 // we donm't allow the frame to get the focus as otherwise
566 // the frame will grab it at arbitrary focus changes
567 GTK_WIDGET_UNSET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );
568
569 if (m_parent) m_parent->AddChild( this );
570
571 // the user resized the frame by dragging etc.
572 g_signal_connect (m_widget, "size_allocate",
573 G_CALLBACK (gtk_frame_size_callback), this);
574
575 g_signal_connect (m_widget, "size_request",
576 G_CALLBACK (wxgtk_tlw_size_request_callback), this);
577 PostCreation();
578
579 if ((m_x != -1) || (m_y != -1))
580 gtk_widget_set_uposition( m_widget, m_x, m_y );
581
582 gtk_window_set_default_size( GTK_WINDOW(m_widget), m_width, m_height );
583
584 // we cannot set MWM hints and icons before the widget has
585 // been realized, so we do this directly after realization
586 g_signal_connect (m_widget, "realize",
587 G_CALLBACK (gtk_frame_realized_callback), this);
588
589 // map and unmap for iconized state
590 g_signal_connect (m_widget, "map_event",
591 G_CALLBACK (gtk_frame_map_callback), this);
592 g_signal_connect (m_widget, "unmap_event",
593 G_CALLBACK (gtk_frame_unmap_callback), this);
594
595 // for wxMoveEvent
596 g_signal_connect (m_widget, "configure_event",
597 G_CALLBACK (gtk_frame_configure_callback), this);
598
599 // activation
600 g_signal_connect_after (m_widget, "focus_in_event",
601 G_CALLBACK (gtk_frame_focus_in_callback), this);
602 g_signal_connect_after (m_widget, "focus_out_event",
603 G_CALLBACK (gtk_frame_focus_out_callback), 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 if (m_miniEdge > 0)
613 {
614 m_gdkDecor = 0;
615 m_gdkFunc = 0;
616
617 if ((style & wxRESIZE_BORDER) != 0)
618 m_gdkFunc |= GDK_FUNC_RESIZE;
619 }
620 else
621 {
622 m_gdkDecor = (long) GDK_DECOR_BORDER;
623 m_gdkFunc = (long) GDK_FUNC_MOVE;
624
625 // All this is for Motif Window Manager "hints" and is supposed to be
626 // recognized by other WMs as well.
627 if ((style & wxCAPTION) != 0)
628 {
629 m_gdkDecor |= GDK_DECOR_TITLE;
630 }
631 if ((style & wxCLOSE_BOX) != 0)
632 {
633 m_gdkFunc |= GDK_FUNC_CLOSE;
634 }
635 if ((style & wxSYSTEM_MENU) != 0)
636 {
637 m_gdkDecor |= GDK_DECOR_MENU;
638 }
639 if ((style & wxMINIMIZE_BOX) != 0)
640 {
641 m_gdkFunc |= GDK_FUNC_MINIMIZE;
642 m_gdkDecor |= GDK_DECOR_MINIMIZE;
643 }
644 if ((style & wxMAXIMIZE_BOX) != 0)
645 {
646 m_gdkFunc |= GDK_FUNC_MAXIMIZE;
647 m_gdkDecor |= GDK_DECOR_MAXIMIZE;
648 }
649 if ((style & wxRESIZE_BORDER) != 0)
650 {
651 m_gdkFunc |= GDK_FUNC_RESIZE;
652 m_gdkDecor |= GDK_DECOR_RESIZEH;
653 }
654 }
655
656 return true;
657 }
658
659 wxTopLevelWindowGTK::~wxTopLevelWindowGTK()
660 {
661 if (m_grabbed)
662 {
663 wxFAIL_MSG(_T("Window still grabbed"));
664 RemoveGrab();
665 }
666
667 m_isBeingDeleted = true;
668
669 // it may also be GtkScrolledWindow in the case of an MDI child
670 if (GTK_IS_WINDOW(m_widget))
671 {
672 gtk_window_set_focus( GTK_WINDOW(m_widget), NULL );
673 }
674
675 if (g_activeFrame == this)
676 g_activeFrame = NULL;
677 if (g_lastActiveFrame == this)
678 g_lastActiveFrame = NULL;
679 }
680
681 bool wxTopLevelWindowGTK::EnableCloseButton( bool enable )
682 {
683 if (enable)
684 m_gdkFunc |= GDK_FUNC_CLOSE;
685 else
686 m_gdkFunc &= ~GDK_FUNC_CLOSE;
687
688 if (GTK_WIDGET_REALIZED(m_widget) && (m_widget->window))
689 gdk_window_set_functions( m_widget->window, (GdkWMFunction)m_gdkFunc );
690
691 return true;
692 }
693
694 bool wxTopLevelWindowGTK::ShowFullScreen(bool show, long style )
695 {
696 if (show == m_fsIsShowing)
697 return false; // return what?
698
699 m_fsIsShowing = show;
700
701 wxX11FullScreenMethod method =
702 wxGetFullScreenMethodX11((WXDisplay*)GDK_DISPLAY(),
703 (WXWindow)GDK_ROOT_WINDOW());
704
705 #if GTK_CHECK_VERSION(2,2,0)
706 // NB: gtk_window_fullscreen() uses freedesktop.org's WMspec extensions
707 // to switch to fullscreen, which is not always available. We must
708 // check if WM supports the spec and use legacy methods if it
709 // doesn't.
710 if ( (method == wxX11_FS_WMSPEC) && !gtk_check_version(2,2,0) )
711 {
712 if (show)
713 {
714 m_fsSaveFlag = style;
715 gtk_window_fullscreen( GTK_WINDOW( m_widget ) );
716 }
717 else
718 {
719 m_fsSaveFlag = 0;
720 gtk_window_unfullscreen( GTK_WINDOW( m_widget ) );
721 }
722 }
723 else
724 #endif // GTK+ >= 2.2.0
725 {
726 GdkWindow *window = m_widget->window;
727
728 if (show)
729 {
730 m_fsSaveFlag = style;
731 GetPosition( &m_fsSaveFrame.x, &m_fsSaveFrame.y );
732 GetSize( &m_fsSaveFrame.width, &m_fsSaveFrame.height );
733
734 int screen_width,screen_height;
735 wxDisplaySize( &screen_width, &screen_height );
736
737 gint client_x, client_y, root_x, root_y;
738 gint width, height;
739
740 if (method != wxX11_FS_WMSPEC)
741 {
742 // don't do it always, Metacity hates it
743 m_fsSaveGdkFunc = m_gdkFunc;
744 m_fsSaveGdkDecor = m_gdkDecor;
745 m_gdkFunc = m_gdkDecor = 0;
746 gdk_window_set_decorations(window, (GdkWMDecoration)0);
747 gdk_window_set_functions(window, (GdkWMFunction)0);
748 }
749
750 gdk_window_get_origin (m_widget->window, &root_x, &root_y);
751 gdk_window_get_geometry (m_widget->window, &client_x, &client_y,
752 &width, &height, NULL);
753
754 gdk_window_move_resize (m_widget->window, -client_x, -client_y,
755 screen_width + 1, screen_height + 1);
756
757 wxSetFullScreenStateX11((WXDisplay*)GDK_DISPLAY(),
758 (WXWindow)GDK_ROOT_WINDOW(),
759 (WXWindow)GDK_WINDOW_XWINDOW(window),
760 show, &m_fsSaveFrame, method);
761 }
762 else // hide
763 {
764 m_fsSaveFlag = 0;
765 if (method != wxX11_FS_WMSPEC)
766 {
767 // don't do it always, Metacity hates it
768 m_gdkFunc = m_fsSaveGdkFunc;
769 m_gdkDecor = m_fsSaveGdkDecor;
770 gdk_window_set_decorations(window, (GdkWMDecoration)m_gdkDecor);
771 gdk_window_set_functions(window, (GdkWMFunction)m_gdkFunc);
772 }
773
774 wxSetFullScreenStateX11((WXDisplay*)GDK_DISPLAY(),
775 (WXWindow)GDK_ROOT_WINDOW(),
776 (WXWindow)GDK_WINDOW_XWINDOW(window),
777 show, &m_fsSaveFrame, method);
778
779 SetSize(m_fsSaveFrame.x, m_fsSaveFrame.y,
780 m_fsSaveFrame.width, m_fsSaveFrame.height);
781 }
782 }
783
784 // documented behaviour is to show the window if it's still hidden when
785 // showing it full screen
786 if ( show && !IsShown() )
787 Show();
788
789 return true;
790 }
791
792 // ----------------------------------------------------------------------------
793 // overridden wxWindow methods
794 // ----------------------------------------------------------------------------
795
796 bool wxTopLevelWindowGTK::Show( bool show )
797 {
798 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
799
800 if (show == IsShown())
801 return false;
802
803 if (show && !m_sizeSet)
804 {
805 /* by calling GtkOnSize here, we don't have to call
806 either after showing the frame, which would entail
807 much ugly flicker or from within the size_allocate
808 handler, because GTK 1.1.X forbids that. */
809
810 GtkOnSize();
811 }
812
813 wxTopLevelWindowBase::Show(show);
814
815 if (!show)
816 {
817 // make sure window has a non-default position, so when it is shown
818 // again, it won't be repositioned by WM as if it were a new window
819 // Note that this must be done _after_ the window is hidden.
820 gtk_window_move((GtkWindow*)m_widget, m_x, m_y);
821 }
822
823 return true;
824 }
825
826 void wxTopLevelWindowGTK::Raise()
827 {
828 gtk_window_present( GTK_WINDOW( m_widget ) );
829 }
830
831 void wxTopLevelWindowGTK::DoMoveWindow(int WXUNUSED(x), int WXUNUSED(y), int WXUNUSED(width), int WXUNUSED(height) )
832 {
833 wxFAIL_MSG( wxT("DoMoveWindow called for wxTopLevelWindowGTK") );
834 }
835
836 // ----------------------------------------------------------------------------
837 // window geometry
838 // ----------------------------------------------------------------------------
839
840 void wxTopLevelWindowGTK::GTKDoGetSize(int *width, int *height) const
841 {
842 return wxTopLevelWindowBase::DoGetSize(width, height);
843 }
844
845 void wxTopLevelWindowGTK::GTKDoSetSize(int width, int height)
846 {
847 // avoid recursions
848 if (m_resizing)
849 return;
850 m_resizing = true;
851
852 int old_width = m_width;
853 int old_height = m_height;
854
855 if ( width != -1 )
856 m_width = width;
857 if ( height != -1 )
858 m_height = height;
859
860 ConstrainSize();
861
862 if ( m_width != old_width || m_height != old_height )
863 {
864 gtk_window_resize( GTK_WINDOW(m_widget), m_width, m_height );
865
866 /* we set the size in GtkOnSize, i.e. mostly the actual resizing is
867 done either directly before the frame is shown or in idle time
868 so that different calls to SetSize() don't lead to flicker. */
869 m_sizeSet = false;
870 }
871
872 m_resizing = false;
873 }
874
875 void wxTopLevelWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags )
876 {
877 wxCHECK_RET( m_widget, wxT("invalid frame") );
878
879 // this shouldn't happen: wxFrame, wxMDIParentFrame and wxMDIChildFrame have m_wxwindow
880 wxASSERT_MSG( (m_wxwindow != NULL), wxT("invalid frame") );
881
882
883 // deal with the position first
884 int old_x = m_x;
885 int old_y = m_y;
886
887 if ( !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE) )
888 {
889 // -1 means "use existing" unless the flag above is specified
890 if ( x != -1 )
891 m_x = x;
892 if ( y != -1 )
893 m_y = y;
894 }
895 else // wxSIZE_ALLOW_MINUS_ONE
896 {
897 m_x = x;
898 m_y = y;
899 }
900
901 if ( m_x != old_x || m_y != old_y )
902 {
903 gtk_window_move( GTK_WINDOW(m_widget), m_x, m_y );
904 }
905
906
907 // and now change the size: as we want to set the size of the entire
908 // window, including decorations, we must adjust the size passed to
909 // GTKDoSetSize() which takes with the size of undecorated frame only
910 if ( width != -1 || height != -1 )
911 {
912 int wTotal,
913 hTotal;
914 DoGetSize(&wTotal, &hTotal);
915
916 int wUndec,
917 hUndec;
918 GTKDoGetSize(&wUndec, &hUndec);
919
920 if ( width != -1 )
921 width -= wTotal - wUndec;
922 if ( height != -1 )
923 height -= hTotal - hUndec;
924 }
925
926 GTKDoSetSize(width, height);
927 }
928
929 void wxTopLevelWindowGTK::DoGetSize(int *width, int *height) const
930 {
931 wxCHECK_RET( m_widget, wxT("invalid frame") );
932
933 if ( !m_widget->window )
934 {
935 // this can happen if we're called before the window is realized, so
936 // don't assert but just return the stored values
937 GTKDoGetSize(width, height);
938 return;
939 }
940
941 GdkRectangle rect;
942 gdk_window_get_frame_extents(m_widget->window, &rect);
943
944 if ( width )
945 *width = rect.width;
946 if ( height )
947 *height = rect.height;
948 }
949
950 void wxTopLevelWindowGTK::DoGetClientSize( int *width, int *height ) const
951 {
952 if ( IsIconized() )
953 {
954 // for consistency with wxMSW, client area is supposed to be empty for
955 // the iconized windows
956 if ( width )
957 *width = 0;
958 if ( height )
959 *height = 0;
960
961 return;
962 }
963
964 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
965
966 if (height)
967 {
968 *height = m_height - 2 * m_miniEdge - m_miniTitle;
969 if (*height < 0)
970 *height = 0;
971 }
972 if (width)
973 {
974 *width = m_width - 2 * m_miniEdge;
975 if (*width < 0)
976 *width = 0;
977 }
978 }
979
980 void wxTopLevelWindowGTK::DoSetClientSize( int width, int height )
981 {
982 GTKDoSetSize(width + m_miniEdge*2, height + m_miniEdge*2 + m_miniTitle);
983 }
984
985 void wxTopLevelWindowGTK::DoSetSizeHints( int minW, int minH,
986 int maxW, int maxH,
987 int incW, int incH )
988 {
989 wxTopLevelWindowBase::DoSetSizeHints( minW, minH, maxW, maxH, incW, incH );
990
991 const wxSize minSize = GetMinSize();
992 const wxSize maxSize = GetMaxSize();
993 GdkGeometry hints;
994 int hints_mask = 0;
995 if (minSize.x > 0 || minSize.y > 0)
996 {
997 hints_mask |= GDK_HINT_MIN_SIZE;
998 hints.min_width = minSize.x > 0 ? minSize.x : 0;
999 hints.min_height = minSize.y > 0 ? minSize.y : 0;
1000 }
1001 if (maxSize.x > 0 || maxSize.y > 0)
1002 {
1003 hints_mask |= GDK_HINT_MAX_SIZE;
1004 hints.max_width = maxSize.x > 0 ? maxSize.x : INT_MAX;
1005 hints.max_height = maxSize.y > 0 ? maxSize.y : INT_MAX;
1006 }
1007 if (incW > 0 || incH > 0)
1008 {
1009 hints_mask |= GDK_HINT_RESIZE_INC;
1010 hints.width_inc = incW > 0 ? incW : 1;
1011 hints.height_inc = incH > 0 ? incH : 1;
1012 }
1013 gtk_window_set_geometry_hints(
1014 (GtkWindow*)m_widget, NULL, &hints, (GdkWindowHints)hints_mask);
1015 }
1016
1017
1018 void wxTopLevelWindowGTK::GtkOnSize()
1019 {
1020 // avoid recursions
1021 if (m_resizing) return;
1022 m_resizing = true;
1023
1024 if ( m_wxwindow == NULL ) return;
1025
1026 ConstrainSize();
1027
1028 if (m_mainWidget)
1029 {
1030 gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
1031 m_wxwindow,
1032 0, 0, m_width, m_height);
1033 }
1034
1035 m_sizeSet = true;
1036
1037 // send size event to frame
1038 wxSizeEvent event( wxSize(m_width,m_height), GetId() );
1039 event.SetEventObject( this );
1040 GetEventHandler()->ProcessEvent( event );
1041
1042 m_resizing = false;
1043 }
1044
1045 void wxTopLevelWindowGTK::OnInternalIdle()
1046 {
1047 if (!m_sizeSet && GTK_WIDGET_REALIZED(m_wxwindow))
1048 {
1049 GtkOnSize();
1050
1051 // we'll come back later
1052 return;
1053 }
1054
1055 // set the focus if not done yet and if we can already do it
1056 if ( GTK_WIDGET_REALIZED(m_wxwindow) )
1057 {
1058 if ( g_delayedFocus &&
1059 wxGetTopLevelParent((wxWindow*)g_delayedFocus) == this )
1060 {
1061 wxLogTrace(_T("focus"),
1062 _T("Setting focus from wxTLW::OnIdle() to %s(%s)"),
1063 g_delayedFocus->GetClassInfo()->GetClassName(),
1064 g_delayedFocus->GetLabel().c_str());
1065
1066 g_delayedFocus->SetFocus();
1067 g_delayedFocus = NULL;
1068 }
1069 }
1070
1071 wxWindow::OnInternalIdle();
1072
1073 // Synthetize activate events.
1074 if ( g_sendActivateEvent != -1 )
1075 {
1076 bool activate = g_sendActivateEvent != 0;
1077
1078 // if (!activate) wxPrintf( wxT("de") );
1079 // wxPrintf( wxT("activate\n") );
1080
1081 // do it only once
1082 g_sendActivateEvent = -1;
1083
1084 wxTheApp->SetActive(activate, (wxWindow *)g_lastActiveFrame);
1085 }
1086 }
1087
1088 // ----------------------------------------------------------------------------
1089 // frame title/icon
1090 // ----------------------------------------------------------------------------
1091
1092 void wxTopLevelWindowGTK::SetTitle( const wxString &title )
1093 {
1094 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
1095
1096 if ( title == m_title )
1097 return;
1098
1099 m_title = title;
1100
1101 gtk_window_set_title( GTK_WINDOW(m_widget), wxGTK_CONV( title ) );
1102 }
1103
1104 void wxTopLevelWindowGTK::SetIcons( const wxIconBundle &icons )
1105 {
1106 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
1107
1108 wxTopLevelWindowBase::SetIcons( icons );
1109
1110 GList *list = NULL;
1111
1112 const size_t numIcons = icons.GetIconCount();
1113 for ( size_t i = 0; i < numIcons; i++ )
1114 {
1115 list = g_list_prepend(list, icons.GetIconByIndex(i).GetPixbuf());
1116 }
1117
1118 gtk_window_set_icon_list(GTK_WINDOW(m_widget), list);
1119 g_list_free(list);
1120 }
1121
1122 // ----------------------------------------------------------------------------
1123 // frame state: maximized/iconized/normal
1124 // ----------------------------------------------------------------------------
1125
1126 void wxTopLevelWindowGTK::Maximize(bool maximize)
1127 {
1128 if (maximize)
1129 gtk_window_maximize( GTK_WINDOW( m_widget ) );
1130 else
1131 gtk_window_unmaximize( GTK_WINDOW( m_widget ) );
1132 }
1133
1134 bool wxTopLevelWindowGTK::IsMaximized() const
1135 {
1136 if(!m_widget->window)
1137 return false;
1138
1139 return gdk_window_get_state(m_widget->window) & GDK_WINDOW_STATE_MAXIMIZED;
1140 }
1141
1142 void wxTopLevelWindowGTK::Restore()
1143 {
1144 // "Present" seems similar enough to "restore"
1145 gtk_window_present( GTK_WINDOW( m_widget ) );
1146 }
1147
1148 void wxTopLevelWindowGTK::Iconize( bool iconize )
1149 {
1150 if (iconize)
1151 gtk_window_iconify( GTK_WINDOW( m_widget ) );
1152 else
1153 gtk_window_deiconify( GTK_WINDOW( m_widget ) );
1154 }
1155
1156 bool wxTopLevelWindowGTK::IsIconized() const
1157 {
1158 return m_isIconized;
1159 }
1160
1161 void wxTopLevelWindowGTK::SetIconizeState(bool iconize)
1162 {
1163 if ( iconize != m_isIconized )
1164 {
1165 m_isIconized = iconize;
1166 (void)SendIconizeEvent(iconize);
1167 }
1168 }
1169
1170 void wxTopLevelWindowGTK::AddGrab()
1171 {
1172 if (!m_grabbed)
1173 {
1174 m_grabbed = true;
1175 gtk_grab_add( m_widget );
1176 wxEventLoop().Run();
1177 gtk_grab_remove( m_widget );
1178 }
1179 }
1180
1181 void wxTopLevelWindowGTK::RemoveGrab()
1182 {
1183 if (m_grabbed)
1184 {
1185 gtk_main_quit();
1186 m_grabbed = false;
1187 }
1188 }
1189
1190
1191 // helper
1192 static bool do_shape_combine_region(GdkWindow* window, const wxRegion& region)
1193 {
1194 if (window)
1195 {
1196 if (region.IsEmpty())
1197 {
1198 gdk_window_shape_combine_mask(window, NULL, 0, 0);
1199 }
1200 else
1201 {
1202 gdk_window_shape_combine_region(window, region.GetRegion(), 0, 0);
1203 return true;
1204 }
1205 }
1206 return false;
1207 }
1208
1209
1210 bool wxTopLevelWindowGTK::SetShape(const wxRegion& region)
1211 {
1212 wxCHECK_MSG( HasFlag(wxFRAME_SHAPED), false,
1213 _T("Shaped windows must be created with the wxFRAME_SHAPED style."));
1214
1215 GdkWindow *window = NULL;
1216 if (m_wxwindow)
1217 {
1218 window = GTK_PIZZA(m_wxwindow)->bin_window;
1219 do_shape_combine_region(window, region);
1220 }
1221 window = m_widget->window;
1222 return do_shape_combine_region(window, region);
1223 }
1224
1225 bool wxTopLevelWindowGTK::IsActive()
1226 {
1227 return (this == (wxTopLevelWindowGTK*)g_activeFrame);
1228 }
1229
1230 void wxTopLevelWindowGTK::RequestUserAttention(int flags)
1231 {
1232 bool new_hint_value = false;
1233
1234 // FIXME: This is a workaround to focus handling problem
1235 // If RequestUserAttention is called for example right after a wxSleep, OnInternalIdle hasn't
1236 // yet been processed, and the internal focus system is not up to date yet.
1237 // wxYieldIfNeeded ensures the processing of it, but can have unwanted side effects - MR
1238 ::wxYieldIfNeeded();
1239
1240 if(m_urgency_hint >= 0)
1241 g_source_remove(m_urgency_hint);
1242
1243 m_urgency_hint = -2;
1244
1245 if( GTK_WIDGET_REALIZED(m_widget) && !IsActive() )
1246 {
1247 new_hint_value = true;
1248
1249 if (flags & wxUSER_ATTENTION_INFO)
1250 {
1251 m_urgency_hint = g_timeout_add(5000, (GSourceFunc)gtk_frame_urgency_timer_callback, this);
1252 } else {
1253 m_urgency_hint = -1;
1254 }
1255 }
1256
1257 #if GTK_CHECK_VERSION(2,7,0)
1258 if(!gtk_check_version(2,7,0))
1259 gtk_window_set_urgency_hint(GTK_WINDOW( m_widget ), new_hint_value);
1260 else
1261 #endif
1262 wxgtk_window_set_urgency_hint(GTK_WINDOW( m_widget ), new_hint_value);
1263 }
1264
1265 void wxTopLevelWindowGTK::SetWindowStyleFlag( long style )
1266 {
1267 #if defined(__WXGTK24__) || GTK_CHECK_VERSION(2,2,0)
1268 // Store which styles were changed
1269 long styleChanges = style ^ m_windowStyle;
1270 #endif
1271
1272 // Process wxWindow styles. This also updates the internal variable
1273 // Therefore m_windowStyle bits carry now the _new_ style values
1274 wxWindow::SetWindowStyleFlag(style);
1275
1276 // just return for now if widget does not exist yet
1277 if (!m_widget)
1278 return;
1279
1280 #ifdef __WXGTK24__
1281 if ( (styleChanges & wxSTAY_ON_TOP) && !gtk_check_version(2,4,0) )
1282 gtk_window_set_keep_above(GTK_WINDOW(m_widget), m_windowStyle & wxSTAY_ON_TOP);
1283 #endif // GTK+ 2.4
1284 #if GTK_CHECK_VERSION(2,2,0)
1285 if ( (styleChanges & wxFRAME_NO_TASKBAR) && !gtk_check_version(2,2,0) )
1286 {
1287 gtk_window_set_skip_taskbar_hint(GTK_WINDOW(m_widget), m_windowStyle & wxFRAME_NO_TASKBAR);
1288 }
1289 #endif // GTK+ 2.2
1290 }
1291
1292 #include <X11/Xlib.h>
1293
1294 /* Get the X Window between child and the root window.
1295 This should usually be the WM managed XID */
1296 static Window wxGetTopmostWindowX11(Display *dpy, Window child)
1297 {
1298 Window root, parent;
1299 Window* children;
1300 unsigned int nchildren;
1301
1302 XQueryTree(dpy, child, &root, &parent, &children, &nchildren);
1303 XFree(children);
1304
1305 while (parent != root) {
1306 child = parent;
1307 XQueryTree(dpy, child, &root, &parent, &children, &nchildren);
1308 XFree(children);
1309 }
1310
1311 return child;
1312 }
1313
1314 bool wxTopLevelWindowGTK::SetTransparent(wxByte alpha)
1315 {
1316 if (!m_widget || !m_widget->window)
1317 return false;
1318
1319 Display* dpy = GDK_WINDOW_XDISPLAY (m_widget->window);
1320 // We need to get the X Window that has the root window as the immediate parent
1321 // and m_widget->window as a child. This should be the X Window that the WM manages and
1322 // from which the opacity property is checked from.
1323 Window win = wxGetTopmostWindowX11(dpy, GDK_WINDOW_XID (m_widget->window));
1324
1325 unsigned int opacity = alpha * 0x1010101;
1326
1327 // Using pure Xlib to not have a GTK version check mess due to gtk2.0 not having GdkDisplay
1328 if (alpha == 0xff)
1329 XDeleteProperty(dpy, win, XInternAtom(dpy, "_NET_WM_WINDOW_OPACITY", False));
1330 else
1331 XChangeProperty(dpy, win, XInternAtom(dpy, "_NET_WM_WINDOW_OPACITY", False),
1332 XA_CARDINAL, 32, PropModeReplace,
1333 (unsigned char *) &opacity, 1L);
1334 XSync(dpy, False);
1335 return true;
1336 }
1337
1338 bool wxTopLevelWindowGTK::CanSetTransparent()
1339 {
1340 // allow to override automatic detection as it's far from perfect
1341 static const wxChar *SYSOPT_TRANSPARENT = wxT("gtk.tlw.can-set-transparent");
1342 if ( wxSystemOptions::HasOption(SYSOPT_TRANSPARENT) )
1343 {
1344 return wxSystemOptions::GetOptionInt(SYSOPT_TRANSPARENT) != 0;
1345 }
1346
1347 #if GTK_CHECK_VERSION(2,10,0)
1348 if (!gtk_check_version(2,10,0))
1349 {
1350 return (gtk_widget_is_composited (m_widget));
1351 }
1352 else
1353 #endif // In case of lower versions than gtk+-2.10.0 we could look for _NET_WM_CM_Sn ourselves
1354 {
1355 return false;
1356 }
1357
1358 #if 0 // Don't be optimistic here for the sake of wxAUI
1359 int opcode, event, error;
1360 // Check for the existence of a RGBA visual instead?
1361 return XQueryExtension(gdk_x11_get_default_xdisplay (),
1362 "Composite", &opcode, &event, &error);
1363 #endif
1364 }
wxWidgets (Impactor)