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


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