]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/gtk/toplevel.cpp
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Line-up interfaces to use size_t for GetCount()s.
[wxWidgets.git] / src / gtk / toplevel.cpp
... / ...
CommitLineData
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// ============================================================================
11// declarations
12// ============================================================================
13
14// ----------------------------------------------------------------------------
15// headers
16// ----------------------------------------------------------------------------
17
18// For compilers that support precompilation, includes "wx.h".
19#include "wx/wxprec.h"
20
21#ifdef __VMS
22#define XIconifyWindow XICONIFYWINDOW
23#endif
24
25#include "wx/defs.h"
26
27#include "wx/toplevel.h"
28#include "wx/log.h"
29#include "wx/dialog.h"
30#include "wx/control.h"
31#include "wx/app.h"
32#include "wx/dcclient.h"
33#include "wx/gtk/private.h"
34#include "wx/timer.h"
35#include "wx/settings.h"
36#include "wx/evtloop.h"
37
38#include <glib.h>
39#include <gdk/gdk.h>
40#include <gtk/gtk.h>
41#include <gdk/gdkkeysyms.h>
42#include <gdk/gdkx.h>
43
44#include "wx/gtk/win_gtk.h"
45
46#include "wx/unix/utilsx11.h"
47
48// XA_CARDINAL
49#include <X11/Xatom.h>
50
51// ----------------------------------------------------------------------------
52// data
53// ----------------------------------------------------------------------------
54
55extern wxList wxPendingDelete;
56
57extern int g_openDialogs;
58extern wxWindowGTK *g_delayedFocus;
59
60// the frame that is currently active (i.e. its child has focus). It is
61// used to generate wxActivateEvents
62static wxTopLevelWindowGTK *g_activeFrame = (wxTopLevelWindowGTK*) NULL;
63static wxTopLevelWindowGTK *g_lastActiveFrame = (wxTopLevelWindowGTK*) NULL;
64
65// if we detect that the app has got/lost the focus, we set this variable to
66// either TRUE or FALSE and an activate event will be sent during the next
67// OnIdle() call and it is reset to -1: this value means that we shouldn't
68// send any activate events at all
69static int g_sendActivateEvent = -1;
70
71//-----------------------------------------------------------------------------
72// RequestUserAttention related functions
73//-----------------------------------------------------------------------------
74
75extern "C" {
76static void wxgtk_window_set_urgency_hint (GtkWindow *win,
77 gboolean setting)
78{
79 wxASSERT_MSG( GTK_WIDGET_REALIZED(win), wxT("wxgtk_window_set_urgency_hint: GdkWindow not realized") );
80 GdkWindow *window = GTK_WIDGET(win)->window;
81 XWMHints *wm_hints;
82
83 wm_hints = XGetWMHints(GDK_WINDOW_XDISPLAY(window), GDK_WINDOW_XWINDOW(window));
84
85 if (!wm_hints)
86 wm_hints = XAllocWMHints();
87
88 if (setting)
89 wm_hints->flags |= XUrgencyHint;
90 else
91 wm_hints->flags &= ~XUrgencyHint;
92
93 XSetWMHints(GDK_WINDOW_XDISPLAY(window), GDK_WINDOW_XWINDOW(window), wm_hints);
94 XFree(wm_hints);
95}
96
97static gboolean gtk_frame_urgency_timer_callback( wxTopLevelWindowGTK *win )
98{
99#if defined(__WXGTK20__) && GTK_CHECK_VERSION(2,7,0)
100 if(!gtk_check_version(2,7,0))
101 gtk_window_set_urgency_hint(GTK_WINDOW( win->m_widget ), FALSE);
102 else
103#endif
104 wxgtk_window_set_urgency_hint(GTK_WINDOW( win->m_widget ), FALSE);
105
106 win->m_urgency_hint = -2;
107 return FALSE;
108}
109}
110
111//-----------------------------------------------------------------------------
112// "focus_in_event"
113//-----------------------------------------------------------------------------
114
115extern "C" {
116static gboolean gtk_frame_focus_in_callback( GtkWidget *widget,
117 GdkEvent *WXUNUSED(event),
118 wxTopLevelWindowGTK *win )
119{
120 if (g_isIdle)
121 wxapp_install_idle_handler();
122
123 switch ( g_sendActivateEvent )
124 {
125 case -1:
126 // we've got focus from outside, synthetize wxActivateEvent
127 g_sendActivateEvent = 1;
128 break;
129
130 case 0:
131 // another our window just lost focus, it was already ours before
132 // - don't send any wxActivateEvent
133 g_sendActivateEvent = -1;
134 break;
135 }
136
137 g_activeFrame = win;
138 g_lastActiveFrame = g_activeFrame;
139
140 // wxPrintf( wxT("active: %s\n"), win->GetTitle().c_str() );
141
142 // MR: wxRequestUserAttention related block
143 switch( win->m_urgency_hint )
144 {
145 default:
146 g_source_remove( win->m_urgency_hint );
147 // no break, fallthrough to remove hint too
148 case -1:
149#if defined(__WXGTK20__) && GTK_CHECK_VERSION(2,7,0)
150 if(!gtk_check_version(2,7,0))
151 gtk_window_set_urgency_hint(GTK_WINDOW( widget ), FALSE);
152 else
153#endif
154 {
155 wxgtk_window_set_urgency_hint(GTK_WINDOW( widget ), FALSE);
156 }
157
158 win->m_urgency_hint = -2;
159 break;
160
161 case -2: break;
162 }
163
164 wxLogTrace(wxT("activate"), wxT("Activating frame %p (from focus_in)"), g_activeFrame);
165 wxActivateEvent event(wxEVT_ACTIVATE, true, g_activeFrame->GetId());
166 event.SetEventObject(g_activeFrame);
167 g_activeFrame->GetEventHandler()->ProcessEvent(event);
168
169 return FALSE;
170}
171}
172
173//-----------------------------------------------------------------------------
174// "focus_out_event"
175//-----------------------------------------------------------------------------
176
177extern "C" {
178static gboolean gtk_frame_focus_out_callback( GtkWidget *widget,
179 GdkEventFocus *WXUNUSED(gdk_event),
180 wxTopLevelWindowGTK *win )
181{
182 if (g_isIdle)
183 wxapp_install_idle_handler();
184
185 // if the focus goes out of our app alltogether, OnIdle() will send
186 // wxActivateEvent, otherwise gtk_window_focus_in_callback() will reset
187 // g_sendActivateEvent to -1
188 g_sendActivateEvent = 0;
189
190 // wxASSERT_MSG( (g_activeFrame == win), wxT("TLW deactivatd although it wasn't active") );
191
192 // wxPrintf( wxT("inactive: %s\n"), win->GetTitle().c_str() );
193
194 if (g_activeFrame)
195 {
196 wxLogTrace(wxT("activate"), wxT("Activating frame %p (from focus_in)"), g_activeFrame);
197 wxActivateEvent event(wxEVT_ACTIVATE, false, g_activeFrame->GetId());
198 event.SetEventObject(g_activeFrame);
199 g_activeFrame->GetEventHandler()->ProcessEvent(event);
200
201 g_activeFrame = NULL;
202 }
203
204 return FALSE;
205}
206}
207
208//-----------------------------------------------------------------------------
209// "focus" from m_window
210//-----------------------------------------------------------------------------
211
212extern "C" {
213static gboolean gtk_frame_focus_callback( GtkWidget *widget, GtkDirectionType WXUNUSED(d), wxWindow *WXUNUSED(win) )
214{
215 if (g_isIdle)
216 wxapp_install_idle_handler();
217
218 // This disables GTK's tab traversal
219 g_signal_stop_emission_by_name (widget, "focus");
220 return TRUE;
221}
222}
223
224//-----------------------------------------------------------------------------
225// "size_allocate"
226//-----------------------------------------------------------------------------
227
228extern "C" {
229static void gtk_frame_size_callback( GtkWidget *WXUNUSED(widget), GtkAllocation* alloc, wxTopLevelWindowGTK *win )
230{
231 if (g_isIdle)
232 wxapp_install_idle_handler();
233
234 if (!win->m_hasVMT)
235 return;
236
237 if ((win->m_width != alloc->width) || (win->m_height != alloc->height))
238 {
239/*
240 wxPrintf( "OnSize from " );
241 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
242 wxPrintf( win->GetClassInfo()->GetClassName() );
243 wxPrintf( " %d %d %d %d\n", (int)alloc->x,
244 (int)alloc->y,
245 (int)alloc->width,
246 (int)alloc->height );
247*/
248
249 win->m_width = alloc->width;
250 win->m_height = alloc->height;
251 win->GtkUpdateSize();
252 }
253}
254}
255
256//-----------------------------------------------------------------------------
257// "delete_event"
258//-----------------------------------------------------------------------------
259
260extern "C" {
261static gboolean
262gtk_frame_delete_callback( GtkWidget *WXUNUSED(widget),
263 GdkEvent *WXUNUSED(event),
264 wxTopLevelWindowGTK *win )
265{
266 if (g_isIdle)
267 wxapp_install_idle_handler();
268
269 if (win->IsEnabled() &&
270 (g_openDialogs == 0 || (win->GetExtraStyle() & wxTOPLEVEL_EX_DIALOG) ||
271 win->IsGrabbed()))
272 win->Close();
273
274 return TRUE;
275}
276}
277
278
279//-----------------------------------------------------------------------------
280// "configure_event"
281//-----------------------------------------------------------------------------
282
283extern "C" {
284static gboolean
285gtk_frame_configure_callback( GtkWidget *WXUNUSED(widget),
286 GdkEventConfigure *WXUNUSED(event),
287 wxTopLevelWindowGTK *win )
288{
289 if (g_isIdle)
290 wxapp_install_idle_handler();
291
292 if (!win->m_hasVMT || !win->IsShown())
293 return FALSE;
294
295
296 int x = 0;
297 int y = 0;
298 gdk_window_get_root_origin( win->m_widget->window, &x, &y );
299 win->m_x = x;
300 win->m_y = y;
301
302 wxMoveEvent mevent( wxPoint(win->m_x,win->m_y), win->GetId() );
303 mevent.SetEventObject( win );
304 win->GetEventHandler()->ProcessEvent( mevent );
305
306 return FALSE;
307}
308}
309
310//-----------------------------------------------------------------------------
311// "realize" from m_widget
312//-----------------------------------------------------------------------------
313
314// we cannot MWM hints and icons before the widget has been realized,
315// so we do this directly after realization
316
317extern "C" {
318static void
319gtk_frame_realized_callback( GtkWidget * WXUNUSED(widget),
320 wxTopLevelWindowGTK *win )
321{
322 if (g_isIdle)
323 wxapp_install_idle_handler();
324
325 // All this is for Motif Window Manager "hints" and is supposed to be
326 // recognized by other WM as well. Not tested.
327 gdk_window_set_decorations(win->m_widget->window,
328 (GdkWMDecoration)win->m_gdkDecor);
329 gdk_window_set_functions(win->m_widget->window,
330 (GdkWMFunction)win->m_gdkFunc);
331
332 // GTK's shrinking/growing policy
333 if ((win->m_gdkFunc & GDK_FUNC_RESIZE) == 0)
334 gtk_window_set_resizable(GTK_WINDOW(win->m_widget), FALSE);
335 else
336 gtk_window_set_policy(GTK_WINDOW(win->m_widget), 1, 1, 1);
337
338 // reset the icon
339 wxIconBundle iconsOld = win->GetIcons();
340 if ( iconsOld.GetIcon(-1).Ok() )
341 {
342 win->SetIcon( wxNullIcon );
343 win->SetIcons( iconsOld );
344 }
345}
346}
347
348//-----------------------------------------------------------------------------
349// "map_event" from m_widget
350//-----------------------------------------------------------------------------
351
352extern "C" {
353static void
354gtk_frame_map_callback( GtkWidget * WXUNUSED(widget),
355 GdkEvent * WXUNUSED(event),
356 wxTopLevelWindow *win )
357{
358 win->SetIconizeState(false);
359}
360}
361
362//-----------------------------------------------------------------------------
363// "unmap_event" from m_widget
364//-----------------------------------------------------------------------------
365
366extern "C" {
367static void
368gtk_frame_unmap_callback( GtkWidget * WXUNUSED(widget),
369 GdkEvent * WXUNUSED(event),
370 wxTopLevelWindow *win )
371{
372 win->SetIconizeState(true);
373}
374}
375
376//-----------------------------------------------------------------------------
377// "expose_event" of m_client
378//-----------------------------------------------------------------------------
379
380extern "C" {
381static gboolean
382gtk_window_expose_callback( GtkWidget *widget,
383 GdkEventExpose *gdk_event,
384 wxWindow *win )
385{
386 GtkPizza *pizza = GTK_PIZZA(widget);
387
388 gtk_paint_flat_box (win->m_widget->style,
389 pizza->bin_window, GTK_STATE_NORMAL,
390 GTK_SHADOW_NONE,
391 &gdk_event->area,
392 win->m_widget,
393 (char *)"base",
394 0, 0, -1, -1);
395
396 return FALSE;
397}
398}
399
400// ----------------------------------------------------------------------------
401// wxTopLevelWindowGTK itself
402// ----------------------------------------------------------------------------
403
404//-----------------------------------------------------------------------------
405// InsertChild for wxTopLevelWindowGTK
406//-----------------------------------------------------------------------------
407
408/* Callback for wxTopLevelWindowGTK. This very strange beast has to be used because
409 * C++ has no virtual methods in a constructor. We have to emulate a
410 * virtual function here as wxWidgets requires different ways to insert
411 * a child in container classes. */
412
413static void wxInsertChildInTopLevelWindow( wxTopLevelWindowGTK* parent, wxWindow* child )
414{
415 wxASSERT( GTK_IS_WIDGET(child->m_widget) );
416
417 if (!parent->m_insertInClientArea)
418 {
419 // these are outside the client area
420 wxTopLevelWindowGTK* frame = (wxTopLevelWindowGTK*) parent;
421 gtk_pizza_put( GTK_PIZZA(frame->m_mainWidget),
422 GTK_WIDGET(child->m_widget),
423 child->m_x,
424 child->m_y,
425 child->m_width,
426 child->m_height );
427 }
428 else
429 {
430 // these are inside the client area
431 gtk_pizza_put( GTK_PIZZA(parent->m_wxwindow),
432 GTK_WIDGET(child->m_widget),
433 child->m_x,
434 child->m_y,
435 child->m_width,
436 child->m_height );
437 }
438
439 // resize on OnInternalIdle
440 parent->GtkUpdateSize();
441}
442
443// ----------------------------------------------------------------------------
444// wxTopLevelWindowGTK creation
445// ----------------------------------------------------------------------------
446
447void wxTopLevelWindowGTK::Init()
448{
449 m_sizeSet = false;
450 m_miniEdge = 0;
451 m_miniTitle = 0;
452 m_mainWidget = (GtkWidget*) NULL;
453 m_insertInClientArea = true;
454 m_isIconized = false;
455 m_fsIsShowing = false;
456 m_themeEnabled = true;
457 m_gdkDecor = m_gdkFunc = 0;
458 m_grabbed = false;
459
460 m_urgency_hint = -2;
461}
462
463bool wxTopLevelWindowGTK::Create( wxWindow *parent,
464 wxWindowID id,
465 const wxString& title,
466 const wxPoint& pos,
467 const wxSize& sizeOrig,
468 long style,
469 const wxString &name )
470{
471 // always create a frame of some reasonable, even if arbitrary, size (at
472 // least for MSW compatibility)
473 wxSize size = sizeOrig;
474 size.x = WidthDefault(size.x);
475 size.y = HeightDefault(size.y);
476
477 wxTopLevelWindows.Append( this );
478
479 m_needParent = false;
480
481 if (!PreCreation( parent, pos, size ) ||
482 !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
483 {
484 wxFAIL_MSG( wxT("wxTopLevelWindowGTK creation failed") );
485 return false;
486 }
487
488 m_title = title;
489
490 m_insertCallback = (wxInsertChildFunction) wxInsertChildInTopLevelWindow;
491
492 // NB: m_widget may be !=NULL if it was created by derived class' Create,
493 // e.g. in wxTaskBarIconAreaGTK
494 if (m_widget == NULL)
495 {
496 if (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG)
497 {
498 m_widget = gtk_window_new(GTK_WINDOW_TOPLEVEL);
499 // Tell WM that this is a dialog window and make it center
500 // on parent by default (this is what GtkDialog ctor does):
501 gtk_window_set_type_hint(GTK_WINDOW(m_widget),
502 GDK_WINDOW_TYPE_HINT_DIALOG);
503 gtk_window_set_position(GTK_WINDOW(m_widget),
504 GTK_WIN_POS_CENTER_ON_PARENT);
505 }
506 else
507 {
508 m_widget = gtk_window_new(GTK_WINDOW_TOPLEVEL);
509#if GTK_CHECK_VERSION(2,1,0)
510 if (!gtk_check_version(2,1,0))
511 {
512 if (style & wxFRAME_TOOL_WINDOW)
513 {
514 gtk_window_set_type_hint(GTK_WINDOW(m_widget),
515 GDK_WINDOW_TYPE_HINT_UTILITY);
516
517 // On some WMs, like KDE, a TOOL_WINDOW will still show
518 // on the taskbar, but on Gnome a TOOL_WINDOW will not.
519 // For consistency between WMs and with Windows, we
520 // should set the NO_TASKBAR flag which will apply
521 // the set_skip_taskbar_hint if it is available,
522 // ensuring no taskbar entry will appear.
523 style |= wxFRAME_NO_TASKBAR;
524 }
525 }
526#endif
527 }
528 }
529
530 wxWindow *topParent = wxGetTopLevelParent(m_parent);
531 if (topParent && (((GTK_IS_WINDOW(topParent->m_widget)) &&
532 (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG)) ||
533 (style & wxFRAME_FLOAT_ON_PARENT)))
534 {
535 gtk_window_set_transient_for( GTK_WINDOW(m_widget),
536 GTK_WINDOW(topParent->m_widget) );
537 }
538
539#if GTK_CHECK_VERSION(2,2,0)
540 if (!gtk_check_version(2,2,0))
541 {
542 if (style & wxFRAME_NO_TASKBAR)
543 {
544 gtk_window_set_skip_taskbar_hint(GTK_WINDOW(m_widget), TRUE);
545 }
546 }
547#endif
548
549#ifdef __WXGTK24__
550 if (!gtk_check_version(2,4,0))
551 {
552 if (style & wxSTAY_ON_TOP)
553 {
554 gtk_window_set_keep_above(GTK_WINDOW(m_widget), TRUE);
555 }
556 }
557#endif
558
559 if (!name.empty())
560 gtk_window_set_wmclass( GTK_WINDOW(m_widget), wxGTK_CONV( name ), wxGTK_CONV( name ) );
561
562 gtk_window_set_title( GTK_WINDOW(m_widget), wxGTK_CONV( title ) );
563 GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
564
565 g_signal_connect (m_widget, "delete_event",
566 G_CALLBACK (gtk_frame_delete_callback), this);
567
568 // m_mainWidget holds the toolbar, the menubar and the client area
569 m_mainWidget = gtk_pizza_new();
570 gtk_widget_show( m_mainWidget );
571 GTK_WIDGET_UNSET_FLAGS( m_mainWidget, GTK_CAN_FOCUS );
572 gtk_container_add( GTK_CONTAINER(m_widget), m_mainWidget );
573
574 if (m_miniEdge == 0) // wxMiniFrame has its own version.
575 {
576 // For m_mainWidget themes
577 g_signal_connect (m_mainWidget, "expose_event",
578 G_CALLBACK (gtk_window_expose_callback), this);
579 }
580
581 // m_wxwindow only represents the client area without toolbar and menubar
582 m_wxwindow = gtk_pizza_new();
583 gtk_widget_show( m_wxwindow );
584 gtk_container_add( GTK_CONTAINER(m_mainWidget), m_wxwindow );
585
586 // we donm't allow the frame to get the focus as otherwise
587 // the frame will grab it at arbitrary focus changes
588 GTK_WIDGET_UNSET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );
589
590 if (m_parent) m_parent->AddChild( this );
591
592 // the user resized the frame by dragging etc.
593 g_signal_connect (m_widget, "size_allocate",
594 G_CALLBACK (gtk_frame_size_callback), this);
595
596 PostCreation();
597
598 if ((m_x != -1) || (m_y != -1))
599 gtk_widget_set_uposition( m_widget, m_x, m_y );
600
601 gtk_window_set_default_size( GTK_WINDOW(m_widget), m_width, m_height );
602
603 // we cannot set MWM hints and icons before the widget has
604 // been realized, so we do this directly after realization
605 g_signal_connect (m_widget, "realize",
606 G_CALLBACK (gtk_frame_realized_callback), this);
607
608 // map and unmap for iconized state
609 g_signal_connect (m_widget, "map_event",
610 G_CALLBACK (gtk_frame_map_callback), this);
611 g_signal_connect (m_widget, "unmap_event",
612 G_CALLBACK (gtk_frame_unmap_callback), this);
613
614 // the only way to get the window size is to connect to this event
615 g_signal_connect (m_widget, "configure_event",
616 G_CALLBACK (gtk_frame_configure_callback), this);
617
618 // disable native tab traversal
619 g_signal_connect (m_widget, "focus",
620 G_CALLBACK (gtk_frame_focus_callback), this);
621
622 // activation
623 g_signal_connect_after (m_widget, "focus_in_event",
624 G_CALLBACK (gtk_frame_focus_in_callback), this);
625 g_signal_connect_after (m_widget, "focus_out_event",
626 G_CALLBACK (gtk_frame_focus_out_callback), this);
627
628 // decorations
629 if ((m_miniEdge > 0) || (style & wxSIMPLE_BORDER) || (style & wxNO_BORDER))
630 {
631 m_gdkDecor = 0;
632 m_gdkFunc = 0;
633 }
634 else
635 {
636 m_gdkDecor = (long) GDK_DECOR_BORDER;
637 m_gdkFunc = (long) GDK_FUNC_MOVE;
638
639 // All this is for Motif Window Manager "hints" and is supposed to be
640 // recognized by other WMs as well.
641 if ((style & wxCAPTION) != 0)
642 {
643 m_gdkDecor |= GDK_DECOR_TITLE;
644 }
645 if ((style & wxCLOSE_BOX) != 0)
646 {
647 m_gdkFunc |= GDK_FUNC_CLOSE;
648 }
649 if ((style & wxSYSTEM_MENU) != 0)
650 {
651 m_gdkDecor |= GDK_DECOR_MENU;
652 }
653 if ((style & wxMINIMIZE_BOX) != 0)
654 {
655 m_gdkFunc |= GDK_FUNC_MINIMIZE;
656 m_gdkDecor |= GDK_DECOR_MINIMIZE;
657 }
658 if ((style & wxMAXIMIZE_BOX) != 0)
659 {
660 m_gdkFunc |= GDK_FUNC_MAXIMIZE;
661 m_gdkDecor |= GDK_DECOR_MAXIMIZE;
662 }
663 if ((style & wxRESIZE_BORDER) != 0)
664 {
665 m_gdkFunc |= GDK_FUNC_RESIZE;
666 m_gdkDecor |= GDK_DECOR_RESIZEH;
667 }
668 }
669
670 return true;
671}
672
673wxTopLevelWindowGTK::~wxTopLevelWindowGTK()
674{
675 if (m_grabbed)
676 {
677 wxASSERT_MSG( false, _T("Window still grabbed"));
678 RemoveGrab();
679 }
680
681 m_isBeingDeleted = true;
682
683 // it may also be GtkScrolledWindow in the case of an MDI child
684 if (GTK_IS_WINDOW(m_widget))
685 {
686 gtk_window_set_focus( GTK_WINDOW(m_widget), NULL );
687 }
688
689 if (g_activeFrame == this)
690 g_activeFrame = NULL;
691 if (g_lastActiveFrame == this)
692 g_lastActiveFrame = NULL;
693}
694
695
696
697bool wxTopLevelWindowGTK::ShowFullScreen(bool show, long style )
698{
699 if (show == m_fsIsShowing)
700 return false; // return what?
701
702 m_fsIsShowing = show;
703
704 wxX11FullScreenMethod method =
705 wxGetFullScreenMethodX11((WXDisplay*)GDK_DISPLAY(),
706 (WXWindow)GDK_ROOT_WINDOW());
707
708#if GTK_CHECK_VERSION(2,2,0)
709 // NB: gtk_window_fullscreen() uses freedesktop.org's WMspec extensions
710 // to switch to fullscreen, which is not always available. We must
711 // check if WM supports the spec and use legacy methods if it
712 // doesn't.
713 if ( (method == wxX11_FS_WMSPEC) && !gtk_check_version(2,2,0) )
714 {
715 if (show)
716 gtk_window_fullscreen( GTK_WINDOW( m_widget ) );
717 else
718 gtk_window_unfullscreen( GTK_WINDOW( m_widget ) );
719 }
720 else
721#endif // GTK+ >= 2.2.0
722 {
723 GdkWindow *window = m_widget->window;
724
725 if (show)
726 {
727 m_fsSaveFlag = style;
728 GetPosition( &m_fsSaveFrame.x, &m_fsSaveFrame.y );
729 GetSize( &m_fsSaveFrame.width, &m_fsSaveFrame.height );
730
731 int screen_width,screen_height;
732 wxDisplaySize( &screen_width, &screen_height );
733
734 gint client_x, client_y, root_x, root_y;
735 gint width, height;
736
737 if (method != wxX11_FS_WMSPEC)
738 {
739 // don't do it always, Metacity hates it
740 m_fsSaveGdkFunc = m_gdkFunc;
741 m_fsSaveGdkDecor = m_gdkDecor;
742 m_gdkFunc = m_gdkDecor = 0;
743 gdk_window_set_decorations(window, (GdkWMDecoration)0);
744 gdk_window_set_functions(window, (GdkWMFunction)0);
745 }
746
747 gdk_window_get_origin (m_widget->window, &root_x, &root_y);
748 gdk_window_get_geometry (m_widget->window, &client_x, &client_y,
749 &width, &height, NULL);
750
751 gdk_window_move_resize (m_widget->window, -client_x, -client_y,
752 screen_width + 1, screen_height + 1);
753
754 wxSetFullScreenStateX11((WXDisplay*)GDK_DISPLAY(),
755 (WXWindow)GDK_ROOT_WINDOW(),
756 (WXWindow)GDK_WINDOW_XWINDOW(window),
757 show, &m_fsSaveFrame, method);
758 }
759 else // hide
760 {
761 if (method != wxX11_FS_WMSPEC)
762 {
763 // don't do it always, Metacity hates it
764 m_gdkFunc = m_fsSaveGdkFunc;
765 m_gdkDecor = m_fsSaveGdkDecor;
766 gdk_window_set_decorations(window, (GdkWMDecoration)m_gdkDecor);
767 gdk_window_set_functions(window, (GdkWMFunction)m_gdkFunc);
768 }
769
770 wxSetFullScreenStateX11((WXDisplay*)GDK_DISPLAY(),
771 (WXWindow)GDK_ROOT_WINDOW(),
772 (WXWindow)GDK_WINDOW_XWINDOW(window),
773 show, &m_fsSaveFrame, method);
774
775 SetSize(m_fsSaveFrame.x, m_fsSaveFrame.y,
776 m_fsSaveFrame.width, m_fsSaveFrame.height);
777 }
778 }
779
780 // documented behaviour is to show the window if it's still hidden when
781 // showing it full screen
782 if ( show && !IsShown() )
783 Show();
784
785 return true;
786}
787
788// ----------------------------------------------------------------------------
789// overridden wxWindow methods
790// ----------------------------------------------------------------------------
791
792bool wxTopLevelWindowGTK::Show( bool show )
793{
794 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
795
796 if (show && !m_sizeSet)
797 {
798 /* by calling GtkOnSize here, we don't have to call
799 either after showing the frame, which would entail
800 much ugly flicker or from within the size_allocate
801 handler, because GTK 1.1.X forbids that. */
802
803 GtkOnSize( m_x, m_y, m_width, m_height );
804 }
805
806 if (show)
807 gtk_widget_set_uposition( m_widget, m_x, m_y );
808
809 return wxWindow::Show( show );
810}
811
812void wxTopLevelWindowGTK::Raise()
813{
814 gtk_window_present( GTK_WINDOW( m_widget ) );
815}
816
817void wxTopLevelWindowGTK::DoMoveWindow(int WXUNUSED(x), int WXUNUSED(y), int WXUNUSED(width), int WXUNUSED(height) )
818{
819 wxFAIL_MSG( wxT("DoMoveWindow called for wxTopLevelWindowGTK") );
820}
821
822void wxTopLevelWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags )
823{
824 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
825
826 // this shouldn't happen: wxFrame, wxMDIParentFrame and wxMDIChildFrame have m_wxwindow
827 wxASSERT_MSG( (m_wxwindow != NULL), wxT("invalid frame") );
828
829 // avoid recursions
830 if (m_resizing)
831 return;
832 m_resizing = true;
833
834 int old_x = m_x;
835 int old_y = m_y;
836
837 int old_width = m_width;
838 int old_height = m_height;
839
840 if ((sizeFlags & wxSIZE_ALLOW_MINUS_ONE) == 0)
841 {
842 if (x != -1) m_x = x;
843 if (y != -1) m_y = y;
844 }
845 else
846 {
847 m_x = x;
848 m_y = y;
849 }
850 if (width != -1) m_width = width;
851 if (height != -1) m_height = height;
852
853/*
854 if ((sizeFlags & wxSIZE_AUTO_WIDTH) == wxSIZE_AUTO_WIDTH)
855 {
856 if (width == -1) m_width = 80;
857 }
858
859 if ((sizeFlags & wxSIZE_AUTO_HEIGHT) == wxSIZE_AUTO_HEIGHT)
860 {
861 if (height == -1) m_height = 26;
862 }
863*/
864
865 int minWidth = GetMinWidth(),
866 minHeight = GetMinHeight(),
867 maxWidth = GetMaxWidth(),
868 maxHeight = GetMaxHeight();
869
870#ifdef __WXGPE__
871 // GPE's window manager doesn't like size hints
872 // at all, esp. when the user has to use the
873 // virtual keyboard.
874 minWidth = -1;
875 minHeight = -1;
876 maxWidth = -1;
877 maxHeight = -1;
878#endif
879
880 if ((minWidth != -1) && (m_width < minWidth)) m_width = minWidth;
881 if ((minHeight != -1) && (m_height < minHeight)) m_height = minHeight;
882 if ((maxWidth != -1) && (m_width > maxWidth)) m_width = maxWidth;
883 if ((maxHeight != -1) && (m_height > maxHeight)) m_height = maxHeight;
884
885 if ((m_x != -1) || (m_y != -1))
886 {
887 if ((m_x != old_x) || (m_y != old_y))
888 {
889 gtk_widget_set_uposition( m_widget, m_x, m_y );
890 }
891 }
892
893 if ((m_width != old_width) || (m_height != old_height))
894 {
895 if (m_widget->window)
896 gdk_window_resize( m_widget->window, m_width, m_height );
897 else
898 gtk_window_set_default_size( GTK_WINDOW(m_widget), m_width, m_height );
899
900 /* we set the size in GtkOnSize, i.e. mostly the actual resizing is
901 done either directly before the frame is shown or in idle time
902 so that different calls to SetSize() don't lead to flicker. */
903 m_sizeSet = false;
904 }
905
906 m_resizing = false;
907}
908
909void wxTopLevelWindowGTK::DoGetClientSize( int *width, int *height ) const
910{
911 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
912
913 wxWindow::DoGetClientSize( width, height );
914 if (height)
915 {
916 // mini edge
917 *height -= m_miniEdge*2 + m_miniTitle;
918 }
919 if (width)
920 {
921 *width -= m_miniEdge*2;
922 }
923}
924
925void wxTopLevelWindowGTK::DoSetClientSize( int width, int height )
926{
927 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
928
929 DoSetSize(-1, -1,
930 width + m_miniEdge*2, height + m_miniEdge*2 + m_miniTitle, 0);
931}
932
933void wxTopLevelWindowGTK::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y),
934 int width, int height )
935{
936 // due to a bug in gtk, x,y are always 0
937 // m_x = x;
938 // m_y = y;
939
940 // avoid recursions
941 if (m_resizing) return;
942 m_resizing = true;
943
944 if ( m_wxwindow == NULL ) return;
945
946 m_width = width;
947 m_height = height;
948
949 /* wxMDIChildFrame derives from wxFrame but it _is_ a wxWindow as it uses
950 wxWindow::Create to create it's GTK equivalent. m_mainWidget is only
951 set in wxFrame::Create so it is used to check what kind of frame we
952 have here. if m_mainWidget is NULL it is a wxMDIChildFrame and so we
953 skip the part which handles m_frameMenuBar, m_frameToolBar and (most
954 importantly) m_mainWidget */
955
956 int minWidth = GetMinWidth(),
957 minHeight = GetMinHeight(),
958 maxWidth = GetMaxWidth(),
959 maxHeight = GetMaxHeight();
960
961#ifdef __WXGPE__
962 // GPE's window manager doesn't like size hints
963 // at all, esp. when the user has to use the
964 // virtual keyboard.
965 minWidth = -1;
966 minHeight = -1;
967 maxWidth = -1;
968 maxHeight = -1;
969#endif
970
971 if ((minWidth != -1) && (m_width < minWidth)) m_width = minWidth;
972 if ((minHeight != -1) && (m_height < minHeight)) m_height = minHeight;
973 if ((maxWidth != -1) && (m_width > maxWidth)) m_width = maxWidth;
974 if ((maxHeight != -1) && (m_height > maxHeight)) m_height = maxHeight;
975
976 if (m_mainWidget)
977 {
978 // set size hints
979 gint flag = 0; // GDK_HINT_POS;
980 GdkGeometry geom;
981
982 if ((minWidth != -1) || (minHeight != -1)) flag |= GDK_HINT_MIN_SIZE;
983 if ((maxWidth != -1) || (maxHeight != -1)) flag |= GDK_HINT_MAX_SIZE;
984
985 geom.min_width = minWidth;
986 geom.min_height = minHeight;
987
988 // Because of the way we set GDK_HINT_MAX_SIZE above, if either of
989 // maxHeight or maxWidth is set, we must set them both, else the
990 // remaining -1 will be taken literally.
991
992 // I'm certain this also happens elsewhere, and is the probable
993 // cause of other such things as:
994 // Gtk-WARNING **: gtk_widget_size_allocate():
995 // attempt to allocate widget with width 65535 and height 600
996 // but I don't have time to track them all now..
997 //
998 // Really we need to encapulate all this height/width business and
999 // stop any old method from ripping at the members directly and
1000 // scattering -1's without regard for who might resolve them later.
1001
1002 geom.max_width = ( maxHeight == -1 ) ? maxWidth
1003 : ( maxWidth == -1 ) ? wxGetDisplaySize().GetWidth()
1004 : maxWidth ;
1005
1006 geom.max_height = ( maxWidth == -1 ) ? maxHeight // ( == -1 here )
1007 : ( maxHeight == -1 ) ? wxGetDisplaySize().GetHeight()
1008 : maxHeight ;
1009
1010 gtk_window_set_geometry_hints( GTK_WINDOW(m_widget),
1011 (GtkWidget*) NULL,
1012 &geom,
1013 (GdkWindowHints) flag );
1014
1015 /* I revert back to wxGTK's original behaviour. m_mainWidget holds the
1016 * menubar, the toolbar and the client area, which is represented by
1017 * m_wxwindow.
1018 * this hurts in the eye, but I don't want to call SetSize()
1019 * because I don't want to call any non-native functions here. */
1020
1021 int client_x = m_miniEdge;
1022 int client_y = m_miniEdge + m_miniTitle;
1023 int client_w = m_width - 2*m_miniEdge;
1024 int client_h = m_height - 2*m_miniEdge - m_miniTitle;
1025
1026 gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
1027 m_wxwindow,
1028 client_x, client_y, client_w, client_h );
1029 }
1030 else
1031 {
1032 // If there is no m_mainWidget between m_widget and m_wxwindow there
1033 // is no need to set the size or position of m_wxwindow.
1034 }
1035
1036 m_sizeSet = true;
1037
1038 // send size event to frame
1039 wxSizeEvent event( wxSize(m_width,m_height), GetId() );
1040 event.SetEventObject( this );
1041 GetEventHandler()->ProcessEvent( event );
1042
1043 m_resizing = false;
1044}
1045
1046void wxTopLevelWindowGTK::OnInternalIdle()
1047{
1048 if (!m_sizeSet && GTK_WIDGET_REALIZED(m_wxwindow))
1049 {
1050 GtkOnSize( m_x, m_y, m_width, m_height );
1051
1052 // we'll come back later
1053 if (g_isIdle)
1054 wxapp_install_idle_handler();
1055 return;
1056 }
1057
1058 // set the focus if not done yet and if we can already do it
1059 if ( GTK_WIDGET_REALIZED(m_wxwindow) )
1060 {
1061 if ( g_delayedFocus &&
1062 wxGetTopLevelParent((wxWindow*)g_delayedFocus) == this )
1063 {
1064 wxLogTrace(_T("focus"),
1065 _T("Setting focus from wxTLW::OnIdle() to %s(%s)"),
1066 g_delayedFocus->GetClassInfo()->GetClassName(),
1067 g_delayedFocus->GetLabel().c_str());
1068
1069 g_delayedFocus->SetFocus();
1070 g_delayedFocus = NULL;
1071 }
1072 }
1073
1074 wxWindow::OnInternalIdle();
1075
1076 // Synthetize activate events.
1077 if ( g_sendActivateEvent != -1 )
1078 {
1079 bool activate = g_sendActivateEvent != 0;
1080
1081 // if (!activate) wxPrintf( wxT("de") );
1082 // wxPrintf( wxT("activate\n") );
1083
1084 // do it only once
1085 g_sendActivateEvent = -1;
1086
1087 wxTheApp->SetActive(activate, (wxWindow *)g_lastActiveFrame);
1088 }
1089}
1090
1091// ----------------------------------------------------------------------------
1092// frame title/icon
1093// ----------------------------------------------------------------------------
1094
1095void wxTopLevelWindowGTK::SetTitle( const wxString &title )
1096{
1097 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
1098
1099 if ( title == m_title )
1100 return;
1101
1102 m_title = title;
1103
1104 gtk_window_set_title( GTK_WINDOW(m_widget), wxGTK_CONV( title ) );
1105}
1106
1107void wxTopLevelWindowGTK::SetIcon( const wxIcon &icon )
1108{
1109 SetIcons( wxIconBundle( icon ) );
1110}
1111
1112void wxTopLevelWindowGTK::SetIcons( const wxIconBundle &icons )
1113{
1114 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
1115
1116 wxTopLevelWindowBase::SetIcons( icons );
1117
1118 GList *list = NULL;
1119 size_t max = icons.m_icons.GetCount();
1120
1121 for (size_t i = 0; i < max; i++)
1122 {
1123 if (icons.m_icons[i].Ok())
1124 {
1125 list = g_list_prepend(list, icons.m_icons[i].GetPixbuf());
1126 }
1127 }
1128 gtk_window_set_icon_list(GTK_WINDOW(m_widget), list);
1129 g_list_free(list);
1130}
1131
1132// ----------------------------------------------------------------------------
1133// frame state: maximized/iconized/normal
1134// ----------------------------------------------------------------------------
1135
1136void wxTopLevelWindowGTK::Maximize(bool maximize)
1137{
1138 if (maximize)
1139 gtk_window_maximize( GTK_WINDOW( m_widget ) );
1140 else
1141 gtk_window_unmaximize( GTK_WINDOW( m_widget ) );
1142}
1143
1144bool wxTopLevelWindowGTK::IsMaximized() const
1145{
1146 if(!m_widget->window)
1147 return false;
1148
1149 return gdk_window_get_state(m_widget->window) & GDK_WINDOW_STATE_MAXIMIZED;
1150}
1151
1152void wxTopLevelWindowGTK::Restore()
1153{
1154 // "Present" seems similar enough to "restore"
1155 gtk_window_present( GTK_WINDOW( m_widget ) );
1156}
1157
1158void wxTopLevelWindowGTK::Iconize( bool iconize )
1159{
1160 if (iconize)
1161 gtk_window_iconify( GTK_WINDOW( m_widget ) );
1162 else
1163 gtk_window_deiconify( GTK_WINDOW( m_widget ) );
1164}
1165
1166bool wxTopLevelWindowGTK::IsIconized() const
1167{
1168 return m_isIconized;
1169}
1170
1171void wxTopLevelWindowGTK::SetIconizeState(bool iconize)
1172{
1173 if ( iconize != m_isIconized )
1174 {
1175 m_isIconized = iconize;
1176 (void)SendIconizeEvent(iconize);
1177 }
1178}
1179
1180void wxTopLevelWindowGTK::AddGrab()
1181{
1182 if (!m_grabbed)
1183 {
1184 m_grabbed = true;
1185 gtk_grab_add( m_widget );
1186 wxEventLoop().Run();
1187 gtk_grab_remove( m_widget );
1188 }
1189}
1190
1191void wxTopLevelWindowGTK::RemoveGrab()
1192{
1193 if (m_grabbed)
1194 {
1195 gtk_main_quit();
1196 m_grabbed = false;
1197 }
1198}
1199
1200
1201// helper
1202static bool do_shape_combine_region(GdkWindow* window, const wxRegion& region)
1203{
1204 if (window)
1205 {
1206 if (region.IsEmpty())
1207 {
1208 gdk_window_shape_combine_mask(window, NULL, 0, 0);
1209 }
1210 else
1211 {
1212 gdk_window_shape_combine_region(window, region.GetRegion(), 0, 0);
1213 return true;
1214 }
1215 }
1216 return false;
1217}
1218
1219
1220bool wxTopLevelWindowGTK::SetShape(const wxRegion& region)
1221{
1222 wxCHECK_MSG( HasFlag(wxFRAME_SHAPED), false,
1223 _T("Shaped windows must be created with the wxFRAME_SHAPED style."));
1224
1225 GdkWindow *window = NULL;
1226 if (m_wxwindow)
1227 {
1228 window = GTK_PIZZA(m_wxwindow)->bin_window;
1229 do_shape_combine_region(window, region);
1230 }
1231 window = m_widget->window;
1232 return do_shape_combine_region(window, region);
1233}
1234
1235bool wxTopLevelWindowGTK::IsActive()
1236{
1237 return (this == (wxTopLevelWindowGTK*)g_activeFrame);
1238}
1239
1240void wxTopLevelWindowGTK::RequestUserAttention(int flags)
1241{
1242 bool new_hint_value = false;
1243
1244 // FIXME: This is a workaround to focus handling problem
1245 // If RequestUserAttention is called for example right after a wxSleep, OnInternalIdle hasn't
1246 // yet been processed, and the internal focus system is not up to date yet.
1247 // wxYieldIfNeeded ensures the processing of it, but can have unwanted side effects - MR
1248 ::wxYieldIfNeeded();
1249
1250 if(m_urgency_hint >= 0)
1251 g_source_remove(m_urgency_hint);
1252
1253 m_urgency_hint = -2;
1254
1255 if( GTK_WIDGET_REALIZED(m_widget) && !IsActive() )
1256 {
1257 new_hint_value = true;
1258
1259 if (flags & wxUSER_ATTENTION_INFO)
1260 {
1261 m_urgency_hint = g_timeout_add(5000, (GSourceFunc)gtk_frame_urgency_timer_callback, this);
1262 } else {
1263 m_urgency_hint = -1;
1264 }
1265 }
1266
1267#if defined(__WXGTK20__) && GTK_CHECK_VERSION(2,7,0)
1268 if(!gtk_check_version(2,7,0))
1269 gtk_window_set_urgency_hint(GTK_WINDOW( m_widget ), new_hint_value);
1270 else
1271#endif
1272 wxgtk_window_set_urgency_hint(GTK_WINDOW( m_widget ), new_hint_value);
1273}
1274
1275void wxTopLevelWindowGTK::SetWindowStyleFlag( long style )
1276{
1277 // Store which styles were changed
1278 long styleChanges = style ^ m_windowStyle;
1279
1280 // Process wxWindow styles. This also updates the internal variable
1281 // Therefore m_windowStyle bits carry now the _new_ style values
1282 wxWindow::SetWindowStyleFlag(style);
1283
1284 // just return for now if widget does not exist yet
1285 if (!m_widget)
1286 return;
1287
1288#ifdef __WXGTK24__
1289 if ( (styleChanges & wxSTAY_ON_TOP) && !gtk_check_version(2,4,0) )
1290 gtk_window_set_keep_above(GTK_WINDOW(m_widget), m_windowStyle & wxSTAY_ON_TOP);
1291#endif // GTK+ 2.4
1292#if GTK_CHECK_VERSION(2,2,0)
1293 if ( (styleChanges & wxFRAME_NO_TASKBAR) && !gtk_check_version(2,2,0) )
1294 {
1295 gtk_window_set_skip_taskbar_hint(GTK_WINDOW(m_widget), m_windowStyle & wxFRAME_NO_TASKBAR);
1296 }
1297#endif // GTK+ 2.2
1298}
wxWidgets (Impactor)