Added style parameter to wxPopupWindow ctors so they match the Create method.
[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 #ifdef __GNUG__
19 #pragma implementation "toplevel.h"
20 #endif
21
22 #ifdef __VMS
23 #define XIconifyWindow XICONIFYWINDOW
24 #endif
25
26 #include "wx/defs.h"
27
28 #include "wx/dialog.h"
29 #include "wx/control.h"
30 #include "wx/app.h"
31 #include "wx/dcclient.h"
32
33 #include <glib.h>
34 #include <gdk/gdk.h>
35 #include <gtk/gtk.h>
36 #include <gdk/gdkkeysyms.h>
37 #include <gdk/gdkx.h>
38
39 #include "wx/gtk/win_gtk.h"
40
41 // ----------------------------------------------------------------------------
42 // idle system
43 // ----------------------------------------------------------------------------
44
45 extern void wxapp_install_idle_handler();
46 extern bool g_isIdle;
47 extern int g_openDialogs;
48
49 // ----------------------------------------------------------------------------
50 // event tables
51 // ----------------------------------------------------------------------------
52
53 // ----------------------------------------------------------------------------
54 // data
55 // ----------------------------------------------------------------------------
56
57 extern wxList wxPendingDelete;
58
59 // ----------------------------------------------------------------------------
60 // debug
61 // ----------------------------------------------------------------------------
62
63 #ifdef __WXDEBUG__
64
65 extern void debug_focus_in( GtkWidget* widget, const wxChar* name, const wxChar *window );
66
67 #endif
68
69 // ============================================================================
70 // implementation
71 // ============================================================================
72
73 // ----------------------------------------------------------------------------
74 // GTK callbacks
75 // ----------------------------------------------------------------------------
76
77 //-----------------------------------------------------------------------------
78 // "focus" from m_window
79 //-----------------------------------------------------------------------------
80
81 static gint gtk_frame_focus_callback( GtkWidget *widget, GtkDirectionType WXUNUSED(d), wxWindow *WXUNUSED(win) )
82 {
83 if (g_isIdle)
84 wxapp_install_idle_handler();
85
86 // This disables GTK's tab traversal
87 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus" );
88 return TRUE;
89 }
90
91 //-----------------------------------------------------------------------------
92 // "size_allocate"
93 //-----------------------------------------------------------------------------
94
95 static void gtk_frame_size_callback( GtkWidget *WXUNUSED(widget), GtkAllocation* alloc, wxTopLevelWindowGTK *win )
96 {
97 if (g_isIdle)
98 wxapp_install_idle_handler();
99
100 if (!win->m_hasVMT)
101 return;
102
103 if ((win->m_width != alloc->width) || (win->m_height != alloc->height))
104 {
105 /*
106 wxPrintf( "OnSize from " );
107 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
108 wxPrintf( win->GetClassInfo()->GetClassName() );
109 wxPrintf( " %d %d %d %d\n", (int)alloc->x,
110 (int)alloc->y,
111 (int)alloc->width,
112 (int)alloc->height );
113 */
114
115 win->m_width = alloc->width;
116 win->m_height = alloc->height;
117 win->m_queuedFullRedraw = TRUE;
118 win->GtkUpdateSize();
119 }
120 }
121
122 //-----------------------------------------------------------------------------
123 // "delete_event"
124 //-----------------------------------------------------------------------------
125
126 static gint gtk_frame_delete_callback( GtkWidget *WXUNUSED(widget), GdkEvent *WXUNUSED(event), wxTopLevelWindowGTK *win )
127 {
128 if (g_isIdle)
129 wxapp_install_idle_handler();
130
131 if (win->IsEnabled() &&
132 (g_openDialogs == 0 || (win->GetExtraStyle() & wxTOPLEVEL_EX_DIALOG)))
133 win->Close();
134
135 return TRUE;
136 }
137
138
139 //-----------------------------------------------------------------------------
140 // "configure_event"
141 //-----------------------------------------------------------------------------
142
143 static gint
144 #if (GTK_MINOR_VERSION > 0)
145 gtk_frame_configure_callback( GtkWidget *WXUNUSED(widget), GdkEventConfigure *WXUNUSED(event), wxTopLevelWindowGTK *win )
146 #else
147 gtk_frame_configure_callback( GtkWidget *WXUNUSED(widget), GdkEventConfigure *event, wxTopLevelWindowGTK *win )
148 #endif
149 {
150 if (g_isIdle)
151 wxapp_install_idle_handler();
152
153 if (!win->m_hasVMT)
154 return FALSE;
155
156 #if (GTK_MINOR_VERSION > 0)
157 int x = 0;
158 int y = 0;
159 gdk_window_get_root_origin( win->m_widget->window, &x, &y );
160 win->m_x = x;
161 win->m_y = y;
162 #else
163 win->m_x = event->x;
164 win->m_y = event->y;
165 #endif
166
167 wxMoveEvent mevent( wxPoint(win->m_x,win->m_y), win->GetId() );
168 mevent.SetEventObject( win );
169 win->GetEventHandler()->ProcessEvent( mevent );
170
171 return FALSE;
172 }
173
174 //-----------------------------------------------------------------------------
175 // "realize" from m_widget
176 //-----------------------------------------------------------------------------
177
178 /* we cannot MWM hints and icons before the widget has been realized,
179 so we do this directly after realization */
180
181 static void
182 gtk_frame_realized_callback( GtkWidget * WXUNUSED(widget), wxTopLevelWindowGTK *win )
183 {
184 if (g_isIdle)
185 wxapp_install_idle_handler();
186
187 /* All this is for Motif Window Manager "hints" and is supposed to be
188 recognized by other WM as well. Not tested. */
189 gdk_window_set_decorations(win->m_widget->window,
190 (GdkWMDecoration)win->m_gdkDecor);
191 gdk_window_set_functions(win->m_widget->window,
192 (GdkWMFunction)win->m_gdkFunc);
193
194 /* GTK's shrinking/growing policy */
195 if ((win->m_gdkFunc & GDK_FUNC_RESIZE) == 0)
196 gtk_window_set_policy(GTK_WINDOW(win->m_widget), 0, 0, 1);
197 else
198 gtk_window_set_policy(GTK_WINDOW(win->m_widget), 1, 1, 1);
199
200 /* reset the icon */
201 wxIcon iconOld = win->GetIcon();
202 if ( iconOld != wxNullIcon )
203 {
204 wxIcon icon( iconOld );
205 win->SetIcon( wxNullIcon );
206 win->SetIcon( icon );
207 }
208
209 /* we set the focus to the child that accepts the focus. this
210 doesn't really have to be done in "realize" but why not? */
211 wxWindowList::Node *node = win->GetChildren().GetFirst();
212 while (node)
213 {
214 wxWindow *child = node->GetData();
215 if (child->AcceptsFocus())
216 {
217 child->SetFocus();
218 break;
219 }
220
221 node = node->GetNext();
222 }
223 }
224
225 //-----------------------------------------------------------------------------
226 // "map_event" from m_widget
227 //-----------------------------------------------------------------------------
228
229 static void
230 gtk_frame_map_callback( GtkWidget * WXUNUSED(widget),
231 GdkEvent * WXUNUSED(event),
232 wxTopLevelWindow *win )
233 {
234 win->SetIconizeState(FALSE);
235 }
236
237 //-----------------------------------------------------------------------------
238 // "unmap_event" from m_widget
239 //-----------------------------------------------------------------------------
240
241 static void
242 gtk_frame_unmap_callback( GtkWidget * WXUNUSED(widget),
243 GdkEvent * WXUNUSED(event),
244 wxTopLevelWindow *win )
245 {
246 win->SetIconizeState(TRUE);
247 }
248
249 //-----------------------------------------------------------------------------
250 // "expose_event" of m_client
251 //-----------------------------------------------------------------------------
252
253 static int gtk_window_expose_callback( GtkWidget *widget, GdkEventExpose *gdk_event, wxWindow *win )
254 {
255 GtkPizza *pizza = GTK_PIZZA(widget);
256
257 gtk_paint_flat_box (win->m_widget->style, pizza->bin_window, GTK_STATE_NORMAL,
258 GTK_SHADOW_NONE, &gdk_event->area, win->m_widget, "base", 0, 0, -1, -1);
259
260 return TRUE;
261 }
262
263 //-----------------------------------------------------------------------------
264 // "draw" of m_client
265 //-----------------------------------------------------------------------------
266
267
268 static void gtk_window_draw_callback( GtkWidget *widget, GdkRectangle *rect, wxWindow *win )
269 {
270 GtkPizza *pizza = GTK_PIZZA(widget);
271
272 gtk_paint_flat_box (win->m_widget->style, pizza->bin_window, GTK_STATE_NORMAL,
273 GTK_SHADOW_NONE, rect, win->m_widget, "base", 0, 0, -1, -1);
274 }
275
276 // ----------------------------------------------------------------------------
277 // wxTopLevelWindowGTK itself
278 // ----------------------------------------------------------------------------
279
280 //-----------------------------------------------------------------------------
281 // InsertChild for wxTopLevelWindowGTK
282 //-----------------------------------------------------------------------------
283
284 /* Callback for wxTopLevelWindowGTK. This very strange beast has to be used because
285 * C++ has no virtual methods in a constructor. We have to emulate a
286 * virtual function here as wxWindows requires different ways to insert
287 * a child in container classes. */
288
289 static void wxInsertChildInTopLevelWindow( wxTopLevelWindowGTK* parent, wxWindow* child )
290 {
291 wxASSERT( GTK_IS_WIDGET(child->m_widget) );
292
293 if (!parent->m_insertInClientArea)
294 {
295 /* these are outside the client area */
296 wxTopLevelWindowGTK* frame = (wxTopLevelWindowGTK*) parent;
297 gtk_pizza_put( GTK_PIZZA(frame->m_mainWidget),
298 GTK_WIDGET(child->m_widget),
299 child->m_x,
300 child->m_y,
301 child->m_width,
302 child->m_height );
303 }
304 else
305 {
306 /* these are inside the client area */
307 gtk_pizza_put( GTK_PIZZA(parent->m_wxwindow),
308 GTK_WIDGET(child->m_widget),
309 child->m_x,
310 child->m_y,
311 child->m_width,
312 child->m_height );
313 }
314
315 /* resize on OnInternalIdle */
316 parent->GtkUpdateSize();
317 }
318
319 // ----------------------------------------------------------------------------
320 // wxTopLevelWindowGTK creation
321 // ----------------------------------------------------------------------------
322
323 void wxTopLevelWindowGTK::Init()
324 {
325 m_sizeSet = FALSE;
326 m_miniEdge = 0;
327 m_miniTitle = 0;
328 m_mainWidget = (GtkWidget*) NULL;
329 m_insertInClientArea = TRUE;
330 m_isFrame = TRUE;
331 m_isIconized = FALSE;
332 m_fsIsShowing = FALSE;
333 m_themeEnabled = TRUE;
334 m_gdkDecor = m_gdkFunc = 0;
335 }
336
337 bool wxTopLevelWindowGTK::Create( wxWindow *parent,
338 wxWindowID id,
339 const wxString& title,
340 const wxPoint& pos,
341 const wxSize& sizeOrig,
342 long style,
343 const wxString &name )
344 {
345 // always create a frame of some reasonable, even if arbitrary, size (at
346 // least for MSW compatibility)
347 wxSize size = sizeOrig;
348 if ( size.x == -1 || size.y == -1 )
349 {
350 wxSize sizeDpy = wxGetDisplaySize();
351 if ( size.x == -1 )
352 size.x = sizeDpy.x / 3;
353 if ( size.y == -1 )
354 size.y = sizeDpy.y / 5;
355 }
356
357 wxTopLevelWindows.Append( this );
358
359 m_needParent = FALSE;
360
361 if (!PreCreation( parent, pos, size ) ||
362 !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
363 {
364 wxFAIL_MSG( wxT("wxTopLevelWindowGTK creation failed") );
365 return FALSE;
366 }
367
368 m_title = title;
369
370 m_insertCallback = (wxInsertChildFunction) wxInsertChildInTopLevelWindow;
371
372 GtkWindowType win_type = GTK_WINDOW_TOPLEVEL;
373
374 if (style & wxFRAME_TOOL_WINDOW)
375 win_type = GTK_WINDOW_POPUP;
376
377 if (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG)
378 win_type = GTK_WINDOW_DIALOG;
379
380 m_widget = gtk_window_new( win_type );
381
382 if (m_parent && (GTK_IS_WINDOW(m_parent->m_widget)) &&
383 (HasFlag(wxFRAME_FLOAT_ON_PARENT) || (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG)))
384 {
385 gtk_window_set_transient_for( GTK_WINDOW(m_widget), GTK_WINDOW(m_parent->m_widget) );
386 }
387
388 if (!name.IsEmpty())
389 gtk_window_set_wmclass( GTK_WINDOW(m_widget), name.mb_str(), name.mb_str() );
390
391 #ifdef __WXDEBUG__
392 debug_focus_in( m_widget, wxT("wxTopLevelWindowGTK::m_widget"), name );
393 #endif
394
395 gtk_window_set_title( GTK_WINDOW(m_widget), title.mbc_str() );
396 GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
397
398 gtk_signal_connect( GTK_OBJECT(m_widget), "delete_event",
399 GTK_SIGNAL_FUNC(gtk_frame_delete_callback), (gpointer)this );
400
401 /* m_mainWidget holds the toolbar, the menubar and the client area */
402 m_mainWidget = gtk_pizza_new();
403 gtk_widget_show( m_mainWidget );
404 GTK_WIDGET_UNSET_FLAGS( m_mainWidget, GTK_CAN_FOCUS );
405 gtk_container_add( GTK_CONTAINER(m_widget), m_mainWidget );
406
407 /* for m_mainWidget themes */
408 gtk_signal_connect( GTK_OBJECT(m_mainWidget), "expose_event",
409 GTK_SIGNAL_FUNC(gtk_window_expose_callback), (gpointer)this );
410 gtk_signal_connect( GTK_OBJECT(m_mainWidget), "draw",
411 GTK_SIGNAL_FUNC(gtk_window_draw_callback), (gpointer)this );
412
413 #ifdef __WXDEBUG__
414 debug_focus_in( m_mainWidget, wxT("wxTopLevelWindowGTK::m_mainWidget"), name );
415 #endif
416
417 /* m_wxwindow only represents the client area without toolbar and menubar */
418 m_wxwindow = gtk_pizza_new();
419 gtk_widget_show( m_wxwindow );
420 gtk_container_add( GTK_CONTAINER(m_mainWidget), m_wxwindow );
421
422 #ifdef __WXDEBUG__
423 debug_focus_in( m_wxwindow, wxT("wxTopLevelWindowGTK::m_wxwindow"), name );
424 #endif
425
426 /* we donm't allow the frame to get the focus as otherwise
427 the frame will grab it at arbitrary focus changes. */
428 GTK_WIDGET_UNSET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );
429
430 if (m_parent) m_parent->AddChild( this );
431
432 /* the user resized the frame by dragging etc. */
433 gtk_signal_connect( GTK_OBJECT(m_widget), "size_allocate",
434 GTK_SIGNAL_FUNC(gtk_frame_size_callback), (gpointer)this );
435
436 PostCreation();
437
438 if ((m_x != -1) || (m_y != -1))
439 gtk_widget_set_uposition( m_widget, m_x, m_y );
440 gtk_widget_set_usize( m_widget, m_width, m_height );
441
442 /* we cannot set MWM hints and icons before the widget has
443 been realized, so we do this directly after realization */
444 gtk_signal_connect( GTK_OBJECT(m_widget), "realize",
445 GTK_SIGNAL_FUNC(gtk_frame_realized_callback), (gpointer) this );
446
447 /* the only way to get the window size is to connect to this event */
448 gtk_signal_connect( GTK_OBJECT(m_widget), "configure_event",
449 GTK_SIGNAL_FUNC(gtk_frame_configure_callback), (gpointer)this );
450
451 /* map and unmap for iconized state */
452 gtk_signal_connect( GTK_OBJECT(m_widget), "map_event",
453 GTK_SIGNAL_FUNC(gtk_frame_map_callback), (gpointer)this );
454 gtk_signal_connect( GTK_OBJECT(m_widget), "unmap_event",
455 GTK_SIGNAL_FUNC(gtk_frame_unmap_callback), (gpointer)this );
456
457 /* the only way to get the window size is to connect to this event */
458 gtk_signal_connect( GTK_OBJECT(m_widget), "configure_event",
459 GTK_SIGNAL_FUNC(gtk_frame_configure_callback), (gpointer)this );
460
461 /* disable native tab traversal */
462 gtk_signal_connect( GTK_OBJECT(m_widget), "focus",
463 GTK_SIGNAL_FUNC(gtk_frame_focus_callback), (gpointer)this );
464
465
466 /* decorations */
467 if ((m_miniEdge > 0) || (style & wxSIMPLE_BORDER) || (style & wxNO_BORDER))
468 {
469 m_gdkDecor = 0;
470 m_gdkFunc = 0;
471 }
472 else
473 {
474 m_gdkDecor = (long) GDK_DECOR_BORDER;
475 m_gdkFunc = (long) GDK_FUNC_MOVE;
476
477 // All this is for Motif Window Manager "hints" and is supposed to be
478 // recognized by other WM as well. Not tested.
479 if ((style & wxCAPTION) != 0)
480 m_gdkDecor |= GDK_DECOR_TITLE;
481 if ((style & wxSYSTEM_MENU) != 0)
482 {
483 m_gdkFunc |= GDK_FUNC_CLOSE;
484 m_gdkDecor |= GDK_DECOR_MENU;
485 }
486 if ((style & wxMINIMIZE_BOX) != 0)
487 {
488 m_gdkFunc |= GDK_FUNC_MINIMIZE;
489 m_gdkDecor |= GDK_DECOR_MINIMIZE;
490 }
491 if ((style & wxMAXIMIZE_BOX) != 0)
492 {
493 m_gdkFunc |= GDK_FUNC_MAXIMIZE;
494 m_gdkDecor |= GDK_DECOR_MAXIMIZE;
495 }
496 if ((style & wxRESIZE_BORDER) != 0)
497 {
498 m_gdkFunc |= GDK_FUNC_RESIZE;
499 m_gdkDecor |= GDK_DECOR_RESIZEH;
500 }
501 }
502
503 return TRUE;
504 }
505
506 wxTopLevelWindowGTK::~wxTopLevelWindowGTK()
507 {
508 m_isBeingDeleted = TRUE;
509
510 wxTopLevelWindows.DeleteObject( this );
511
512 if (wxTheApp->GetTopWindow() == this)
513 wxTheApp->SetTopWindow( (wxWindow*) NULL );
514
515 if ((wxTopLevelWindows.Number() == 0) &&
516 (wxTheApp->GetExitOnFrameDelete()))
517 {
518 wxTheApp->ExitMainLoop();
519 }
520 }
521
522 bool wxTopLevelWindowGTK::ShowFullScreen(bool show, long style )
523 {
524 if (show == m_fsIsShowing) return FALSE; // return what?
525
526 m_fsIsShowing = show;
527
528 if (show)
529 {
530 m_fsSaveGdkFunc = m_gdkFunc;
531 m_fsSaveGdkDecor = m_gdkDecor;
532 m_fsSaveFlag = style;
533 GetPosition( &m_fsSaveFrame.x, &m_fsSaveFrame.y );
534 GetSize( &m_fsSaveFrame.width, &m_fsSaveFrame.height );
535
536 gtk_widget_hide( m_widget );
537 gtk_widget_unrealize( m_widget );
538
539 m_gdkDecor = (long) GDK_DECOR_BORDER;
540 m_gdkFunc = (long) GDK_FUNC_MOVE;
541
542 int x;
543 int y;
544 wxDisplaySize( &x, &y );
545 SetSize( 0, 0, x, y );
546
547 gtk_widget_realize( m_widget );
548 gtk_widget_show( m_widget );
549 }
550 else
551 {
552 gtk_widget_hide( m_widget );
553 gtk_widget_unrealize( m_widget );
554
555 m_gdkFunc = m_fsSaveGdkFunc;
556 m_gdkDecor = m_fsSaveGdkDecor;
557
558 SetSize( m_fsSaveFrame.x, m_fsSaveFrame.y, m_fsSaveFrame.width, m_fsSaveFrame.height );
559
560 gtk_widget_realize( m_widget );
561 gtk_widget_show( m_widget );
562 }
563
564 return TRUE;
565 }
566
567 // ----------------------------------------------------------------------------
568 // overridden wxWindow methods
569 // ----------------------------------------------------------------------------
570
571 bool wxTopLevelWindowGTK::Show( bool show )
572 {
573 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
574
575 if (show && !m_sizeSet)
576 {
577 /* by calling GtkOnSize here, we don't have to call
578 either after showing the frame, which would entail
579 much ugly flicker or from within the size_allocate
580 handler, because GTK 1.1.X forbids that. */
581
582 GtkOnSize( m_x, m_y, m_width, m_height );
583 }
584
585 return wxWindow::Show( show );
586 }
587
588 void wxTopLevelWindowGTK::DoMoveWindow(int WXUNUSED(x), int WXUNUSED(y), int WXUNUSED(width), int WXUNUSED(height) )
589 {
590 wxFAIL_MSG( wxT("DoMoveWindow called for wxTopLevelWindowGTK") );
591 }
592
593 void wxTopLevelWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags )
594 {
595 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
596
597 /* this shouldn't happen: wxFrameGTK, wxMDIParentFrame and wxMDIChildFrame have m_wxwindow */
598 wxASSERT_MSG( (m_wxwindow != NULL), wxT("invalid frame") );
599
600 /* avoid recursions */
601 if (m_resizing)
602 return;
603 m_resizing = TRUE;
604
605 int old_x = m_x;
606 int old_y = m_y;
607
608 int old_width = m_width;
609 int old_height = m_height;
610
611 if ((sizeFlags & wxSIZE_ALLOW_MINUS_ONE) == 0)
612 {
613 if (x != -1) m_x = x;
614 if (y != -1) m_y = y;
615 if (width != -1) m_width = width;
616 if (height != -1) m_height = height;
617 }
618 else
619 {
620 m_x = x;
621 m_y = y;
622 m_width = width;
623 m_height = height;
624 }
625
626 /*
627 if ((sizeFlags & wxSIZE_AUTO_WIDTH) == wxSIZE_AUTO_WIDTH)
628 {
629 if (width == -1) m_width = 80;
630 }
631
632 if ((sizeFlags & wxSIZE_AUTO_HEIGHT) == wxSIZE_AUTO_HEIGHT)
633 {
634 if (height == -1) m_height = 26;
635 }
636 */
637
638 if ((m_minWidth != -1) && (m_width < m_minWidth)) m_width = m_minWidth;
639 if ((m_minHeight != -1) && (m_height < m_minHeight)) m_height = m_minHeight;
640 if ((m_maxWidth != -1) && (m_width > m_maxWidth)) m_width = m_maxWidth;
641 if ((m_maxHeight != -1) && (m_height > m_maxHeight)) m_height = m_maxHeight;
642
643 if ((m_x != -1) || (m_y != -1))
644 {
645 if ((m_x != old_x) || (m_y != old_y))
646 {
647 gtk_widget_set_uposition( m_widget, m_x, m_y );
648 }
649 }
650
651 if ((m_width != old_width) || (m_height != old_height))
652 {
653 gtk_widget_set_usize( m_widget, m_width, m_height );
654
655 /* we set the size in GtkOnSize, i.e. mostly the actual resizing is
656 done either directly before the frame is shown or in idle time
657 so that different calls to SetSize() don't lead to flicker. */
658 m_sizeSet = FALSE;
659 }
660
661 m_resizing = FALSE;
662 }
663
664 void wxTopLevelWindowGTK::DoGetClientSize( int *width, int *height ) const
665 {
666 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
667
668 wxWindow::DoGetClientSize( width, height );
669 if (height)
670 {
671 /* mini edge */
672 *height -= m_miniEdge*2 + m_miniTitle;
673 }
674 if (width)
675 {
676 *width -= m_miniEdge*2;
677 }
678 }
679
680 void wxTopLevelWindowGTK::DoSetClientSize( int width, int height )
681 {
682 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
683
684 DoSetSize(-1, -1,
685 width + m_miniEdge*2, height + m_miniEdge*2 + m_miniTitle, 0);
686 }
687
688 void wxTopLevelWindowGTK::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y),
689 int width, int height )
690 {
691 // due to a bug in gtk, x,y are always 0
692 // m_x = x;
693 // m_y = y;
694
695 /* avoid recursions */
696 if (m_resizing) return;
697 m_resizing = TRUE;
698
699 if ( m_wxwindow == NULL ) return;
700
701 m_width = width;
702 m_height = height;
703
704 /* wxMDIChildFrame derives from wxFrameGTK but it _is_ a wxWindow as it uses
705 wxWindow::Create to create it's GTK equivalent. m_mainWidget is only
706 set in wxFrameGTK::Create so it is used to check what kind of frame we
707 have here. if m_mainWidget is NULL it is a wxMDIChildFrame and so we
708 skip the part which handles m_frameMenuBar, m_frameToolBar and (most
709 importantly) m_mainWidget */
710
711 if ((m_minWidth != -1) && (m_width < m_minWidth)) m_width = m_minWidth;
712 if ((m_minHeight != -1) && (m_height < m_minHeight)) m_height = m_minHeight;
713 if ((m_maxWidth != -1) && (m_width > m_maxWidth)) m_width = m_maxWidth;
714 if ((m_maxHeight != -1) && (m_height > m_maxHeight)) m_height = m_maxHeight;
715
716 if (m_mainWidget)
717 {
718 /* set size hints */
719 gint flag = 0; // GDK_HINT_POS;
720 if ((m_minWidth != -1) || (m_minHeight != -1)) flag |= GDK_HINT_MIN_SIZE;
721 if ((m_maxWidth != -1) || (m_maxHeight != -1)) flag |= GDK_HINT_MAX_SIZE;
722 GdkGeometry geom;
723 geom.min_width = m_minWidth;
724 geom.min_height = m_minHeight;
725 geom.max_width = m_maxWidth;
726 geom.max_height = m_maxHeight;
727 gtk_window_set_geometry_hints( GTK_WINDOW(m_widget),
728 (GtkWidget*) NULL,
729 &geom,
730 (GdkWindowHints) flag );
731
732 /* I revert back to wxGTK's original behaviour. m_mainWidget holds the
733 * menubar, the toolbar and the client area, which is represented by
734 * m_wxwindow.
735 * this hurts in the eye, but I don't want to call SetSize()
736 * because I don't want to call any non-native functions here. */
737
738 int client_x = m_miniEdge;
739 int client_y = m_miniEdge + m_miniTitle;
740 int client_w = m_width - 2*m_miniEdge;
741 int client_h = m_height - 2*m_miniEdge - m_miniTitle;
742 gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
743 m_wxwindow,
744 client_x, client_y, client_w, client_h );
745 }
746 else
747 {
748 /* if there is no m_mainWidget between m_widget and m_wxwindow there
749 is no need to set the size or position of m_wxwindow. */
750 }
751
752 m_sizeSet = TRUE;
753
754 // send size event to frame
755 wxSizeEvent event( wxSize(m_width,m_height), GetId() );
756 event.SetEventObject( this );
757 GetEventHandler()->ProcessEvent( event );
758
759 m_resizing = FALSE;
760 }
761
762 void wxTopLevelWindowGTK::OnInternalIdle()
763 {
764 if (!m_sizeSet && GTK_WIDGET_REALIZED(m_wxwindow))
765 {
766 GtkOnSize( m_x, m_y, m_width, m_height );
767
768 // we'll come back later
769 if (g_isIdle)
770 wxapp_install_idle_handler();
771 return;
772 }
773
774 wxWindow::OnInternalIdle();
775 }
776
777
778 // ----------------------------------------------------------------------------
779 // frame title/icon
780 // ----------------------------------------------------------------------------
781
782 void wxTopLevelWindowGTK::SetTitle( const wxString &title )
783 {
784 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
785
786 m_title = title;
787 gtk_window_set_title( GTK_WINDOW(m_widget), title.mbc_str() );
788 }
789
790 void wxTopLevelWindowGTK::SetIcon( const wxIcon &icon )
791 {
792 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
793
794 wxTopLevelWindowBase::SetIcon(icon);
795
796 if ( !m_icon.Ok() )
797 return;
798
799 if (!m_widget->window)
800 return;
801
802 wxMask *mask = icon.GetMask();
803 GdkBitmap *bm = (GdkBitmap *) NULL;
804 if (mask) bm = mask->GetBitmap();
805
806 gdk_window_set_icon( m_widget->window, (GdkWindow *) NULL, icon.GetPixmap(), bm );
807 }
808
809 // ----------------------------------------------------------------------------
810 // frame state: maximized/iconized/normal
811 // ----------------------------------------------------------------------------
812
813 void wxTopLevelWindowGTK::Maximize(bool WXUNUSED(maximize))
814 {
815 wxFAIL_MSG( _T("not implemented") );
816 }
817
818 bool wxTopLevelWindowGTK::IsMaximized() const
819 {
820 // wxFAIL_MSG( _T("not implemented") );
821
822 // This is an approximation
823 return FALSE;
824 }
825
826 void wxTopLevelWindowGTK::Restore()
827 {
828 wxFAIL_MSG( _T("not implemented") );
829 }
830
831 void wxTopLevelWindowGTK::Iconize( bool iconize )
832 {
833 if (iconize)
834 {
835 GdkWindow *window = m_widget->window;
836
837 // you should do it later, for example from OnCreate() handler
838 wxCHECK_RET( window, _T("frame not created yet - can't iconize") );
839
840 XIconifyWindow( GDK_WINDOW_XDISPLAY( window ),
841 GDK_WINDOW_XWINDOW( window ),
842 DefaultScreen( GDK_DISPLAY() ) );
843 }
844 }
845
846 bool wxTopLevelWindowGTK::IsIconized() const
847 {
848 return m_isIconized;
849 }
850
851 void wxTopLevelWindowGTK::SetIconizeState(bool iconize)
852 {
853 if ( iconize != m_isIconized )
854 {
855 m_isIconized = iconize;
856 (void)SendIconizeEvent(iconize);
857 }
858 }
859