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