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


a0be42f520404ac819abbc5fd4a2009dfed5f1dd
[wxWidgets.git] / src / gtk1 / frame.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: frame.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 "frame.h"
20 #endif
21
22 #ifdef __VMS
23 #define XIconifyWindow XICONIFYWINDOW
24 #endif
25
26 #include "wx/frame.h"
27 #include "wx/dialog.h"
28 #include "wx/control.h"
29 #include "wx/app.h"
30 #include "wx/menu.h"
31 #if wxUSE_TOOLBAR
32 #include "wx/toolbar.h"
33 #endif
34 #if wxUSE_STATUSBAR
35 #include "wx/statusbr.h"
36 #endif
37 #include "wx/dcclient.h"
38
39 #include <glib.h>
40 #include <gdk/gdk.h>
41 #include <gtk/gtk.h>
42 #include <gdk/gdkkeysyms.h>
43 #include <gdk/gdkx.h>
44
45 #include "wx/gtk/win_gtk.h"
46
47 // ----------------------------------------------------------------------------
48 // constants
49 // ----------------------------------------------------------------------------
50
51 const int wxMENU_HEIGHT = 27;
52 const int wxSTATUS_HEIGHT = 25;
53 const int wxPLACE_HOLDER = 0;
54
55 // ----------------------------------------------------------------------------
56 // idle system
57 // ----------------------------------------------------------------------------
58
59 extern void wxapp_install_idle_handler();
60 extern bool g_isIdle;
61 extern int g_openDialogs;
62
63 // ----------------------------------------------------------------------------
64 // event tables
65 // ----------------------------------------------------------------------------
66
67 IMPLEMENT_DYNAMIC_CLASS(wxFrame,wxWindow)
68
69 // ----------------------------------------------------------------------------
70 // data
71 // ----------------------------------------------------------------------------
72
73 extern wxList wxPendingDelete;
74
75 // ----------------------------------------------------------------------------
76 // debug
77 // ----------------------------------------------------------------------------
78
79 #ifdef __WXDEBUG__
80
81 extern void debug_focus_in( GtkWidget* widget, const wxChar* name, const wxChar *window );
82
83 #endif
84
85 // ============================================================================
86 // implementation
87 // ============================================================================
88
89 // ----------------------------------------------------------------------------
90 // GTK callbacks
91 // ----------------------------------------------------------------------------
92
93 //-----------------------------------------------------------------------------
94 // "focus" from m_window
95 //-----------------------------------------------------------------------------
96
97 static gint gtk_frame_focus_callback( GtkWidget *widget, GtkDirectionType WXUNUSED(d), wxWindow *WXUNUSED(win) )
98 {
99 if (g_isIdle)
100 wxapp_install_idle_handler();
101
102 // This disables GTK's tab traversal
103 gtk_signal_emit_stop_by_name( GTK_OBJECT(widget), "focus" );
104 return TRUE;
105 }
106
107 //-----------------------------------------------------------------------------
108 // "size_allocate"
109 //-----------------------------------------------------------------------------
110
111 static void gtk_frame_size_callback( GtkWidget *WXUNUSED(widget), GtkAllocation* alloc, wxFrame *win )
112 {
113 if (g_isIdle)
114 wxapp_install_idle_handler();
115
116 if (!win->m_hasVMT)
117 return;
118
119 if ((win->m_width != alloc->width) || (win->m_height != alloc->height))
120 {
121 /*
122 wxPrintf( "OnSize from " );
123 if (win->GetClassInfo() && win->GetClassInfo()->GetClassName())
124 wxPrintf( win->GetClassInfo()->GetClassName() );
125 wxPrintf( " %d %d %d %d\n", (int)alloc->x,
126 (int)alloc->y,
127 (int)alloc->width,
128 (int)alloc->height );
129 */
130
131 win->m_width = alloc->width;
132 win->m_height = alloc->height;
133 win->m_queuedFullRedraw = TRUE;
134 win->GtkUpdateSize();
135 }
136 }
137
138 //-----------------------------------------------------------------------------
139 // "delete_event"
140 //-----------------------------------------------------------------------------
141
142 static gint gtk_frame_delete_callback( GtkWidget *WXUNUSED(widget), GdkEvent *WXUNUSED(event), wxFrame *win )
143 {
144 if (g_isIdle)
145 wxapp_install_idle_handler();
146
147 if ((g_openDialogs == 0) && (win->IsEnabled()))
148 win->Close();
149
150 return TRUE;
151 }
152
153 //-----------------------------------------------------------------------------
154 // "child_attached" of menu bar
155 //-----------------------------------------------------------------------------
156
157 static void gtk_menu_attached_callback( GtkWidget *WXUNUSED(widget), GtkWidget *WXUNUSED(child), wxFrame *win )
158 {
159 if (!win->m_hasVMT) return;
160
161 win->m_menuBarDetached = FALSE;
162 win->GtkUpdateSize();
163 }
164
165 //-----------------------------------------------------------------------------
166 // "child_detached" of menu bar
167 //-----------------------------------------------------------------------------
168
169 static void gtk_menu_detached_callback( GtkWidget *WXUNUSED(widget), GtkWidget *WXUNUSED(child), wxFrame *win )
170 {
171 if (!win->m_hasVMT) return;
172
173 win->m_menuBarDetached = TRUE;
174 win->GtkUpdateSize();
175 }
176
177 #if wxUSE_TOOLBAR
178 //-----------------------------------------------------------------------------
179 // "child_attached" of tool bar
180 //-----------------------------------------------------------------------------
181
182 static void gtk_toolbar_attached_callback( GtkWidget *WXUNUSED(widget), GtkWidget *WXUNUSED(child), wxFrame *win )
183 {
184 if (!win->m_hasVMT) return;
185
186 win->m_toolBarDetached = FALSE;
187
188 win->GtkUpdateSize();
189 }
190
191 //-----------------------------------------------------------------------------
192 // "child_detached" of tool bar
193 //-----------------------------------------------------------------------------
194
195 static void gtk_toolbar_detached_callback( GtkWidget *WXUNUSED(widget), GtkWidget *WXUNUSED(child), wxFrame *win )
196 {
197 if (g_isIdle)
198 wxapp_install_idle_handler();
199
200 if (!win->m_hasVMT) return;
201
202 win->m_toolBarDetached = TRUE;
203 win->GtkUpdateSize();
204 }
205 #endif // wxUSE_TOOLBAR
206
207 //-----------------------------------------------------------------------------
208 // "configure_event"
209 //-----------------------------------------------------------------------------
210
211 static gint
212 #if (GTK_MINOR_VERSION > 0)
213 gtk_frame_configure_callback( GtkWidget *WXUNUSED(widget), GdkEventConfigure *WXUNUSED(event), wxFrame *win )
214 #else
215 gtk_frame_configure_callback( GtkWidget *WXUNUSED(widget), GdkEventConfigure *event, wxFrame *win )
216 #endif
217 {
218 if (g_isIdle)
219 wxapp_install_idle_handler();
220
221 if (!win->m_hasVMT)
222 return FALSE;
223
224 #if (GTK_MINOR_VERSION > 0)
225 int x = 0;
226 int y = 0;
227 gdk_window_get_root_origin( win->m_widget->window, &x, &y );
228 win->m_x = x;
229 win->m_y = y;
230 #else
231 win->m_x = event->x;
232 win->m_y = event->y;
233 #endif
234
235 wxMoveEvent mevent( wxPoint(win->m_x,win->m_y), win->GetId() );
236 mevent.SetEventObject( win );
237 win->GetEventHandler()->ProcessEvent( mevent );
238
239 return FALSE;
240 }
241
242 //-----------------------------------------------------------------------------
243 // "realize" from m_widget
244 //-----------------------------------------------------------------------------
245
246 /* we cannot MWM hints and icons before the widget has been realized,
247 so we do this directly after realization */
248
249 static void
250 gtk_frame_realized_callback( GtkWidget * WXUNUSED(widget), wxFrame *win )
251 {
252 if (g_isIdle)
253 wxapp_install_idle_handler();
254
255 if ((win->m_miniEdge > 0) || (win->HasFlag(wxSIMPLE_BORDER)) || (win->HasFlag(wxNO_BORDER)))
256 {
257 /* This is a mini-frame or a borderless frame. */
258 gdk_window_set_decorations( win->m_widget->window, (GdkWMDecoration)0 );
259 gdk_window_set_functions( win->m_widget->window, (GdkWMFunction)0 );
260 }
261 else
262 {
263 /* All this is for Motif Window Manager "hints" and is supposed to be
264 recognized by other WM as well. Not tested. */
265 long decor = (long) GDK_DECOR_BORDER;
266 long func = (long) GDK_FUNC_MOVE;
267
268 if ((win->GetWindowStyle() & wxCAPTION) != 0)
269 decor |= GDK_DECOR_TITLE;
270 if ((win->GetWindowStyle() & wxSYSTEM_MENU) != 0)
271 {
272 decor |= GDK_DECOR_MENU;
273 func |= GDK_FUNC_CLOSE;
274 }
275 if ((win->GetWindowStyle() & wxMINIMIZE_BOX) != 0)
276 {
277 func |= GDK_FUNC_MINIMIZE;
278 decor |= GDK_DECOR_MINIMIZE;
279 }
280 if ((win->GetWindowStyle() & wxMAXIMIZE_BOX) != 0)
281 {
282 func |= GDK_FUNC_MAXIMIZE;
283 decor |= GDK_DECOR_MAXIMIZE;
284 }
285 if ((win->GetWindowStyle() & wxRESIZE_BORDER) != 0)
286 {
287 func |= GDK_FUNC_RESIZE;
288 decor |= GDK_DECOR_RESIZEH;
289 }
290
291 gdk_window_set_decorations( win->m_widget->window, (GdkWMDecoration)decor);
292 gdk_window_set_functions( win->m_widget->window, (GdkWMFunction)func);
293 }
294
295 /* GTK's shrinking/growing policy */
296 if ((win->GetWindowStyle() & wxRESIZE_BORDER) == 0)
297 gtk_window_set_policy(GTK_WINDOW(win->m_widget), 0, 0, 1);
298 else
299 gtk_window_set_policy(GTK_WINDOW(win->m_widget), 1, 1, 1);
300
301 /* reset the icon */
302 wxIcon iconOld = win->GetIcon();
303 if ( iconOld != wxNullIcon )
304 {
305 wxIcon icon( iconOld );
306 win->SetIcon( wxNullIcon );
307 win->SetIcon( icon );
308 }
309
310 /* we set the focus to the child that accepts the focus. this
311 doesn't really have to be done in "realize" but why not? */
312 wxWindowList::Node *node = win->GetChildren().GetFirst();
313 while (node)
314 {
315 wxWindow *child = node->GetData();
316 if (child->AcceptsFocus())
317 {
318 child->SetFocus();
319 break;
320 }
321
322 node = node->GetNext();
323 }
324 }
325
326 //-----------------------------------------------------------------------------
327 // "map_event" from m_widget
328 //-----------------------------------------------------------------------------
329
330 static void
331 gtk_frame_map_callback( GtkWidget * WXUNUSED(widget),
332 GdkEvent * WXUNUSED(event),
333 wxFrame *win )
334 {
335 win->m_isIconized = FALSE;
336 }
337
338 //-----------------------------------------------------------------------------
339 // "unmap_event" from m_widget
340 //-----------------------------------------------------------------------------
341
342 static void
343 gtk_frame_unmap_callback( GtkWidget * WXUNUSED(widget),
344 GdkEvent * WXUNUSED(event),
345 wxFrame *win )
346 {
347 win->m_isIconized = TRUE;
348 }
349
350 //-----------------------------------------------------------------------------
351 // "expose_event" of m_client
352 //-----------------------------------------------------------------------------
353
354 static int gtk_window_expose_callback( GtkWidget *widget, GdkEventExpose *gdk_event, wxWindow *win )
355 {
356 GtkPizza *pizza = GTK_PIZZA(widget);
357
358 gtk_paint_flat_box (win->m_widget->style, pizza->bin_window, GTK_STATE_NORMAL,
359 GTK_SHADOW_NONE, &gdk_event->area, win->m_widget, "base", 0, 0, -1, -1);
360
361 return TRUE;
362 }
363
364 //-----------------------------------------------------------------------------
365 // "draw" of m_client
366 //-----------------------------------------------------------------------------
367
368
369 static void gtk_window_draw_callback( GtkWidget *widget, GdkRectangle *rect, wxWindow *win )
370 {
371 GtkPizza *pizza = GTK_PIZZA(widget);
372
373 gtk_paint_flat_box (win->m_widget->style, pizza->bin_window, GTK_STATE_NORMAL,
374 GTK_SHADOW_NONE, rect, win->m_widget, "base", 0, 0, -1, -1);
375 }
376
377 // ----------------------------------------------------------------------------
378 // wxFrame itself
379 // ----------------------------------------------------------------------------
380
381 //-----------------------------------------------------------------------------
382 // InsertChild for wxFrame
383 //-----------------------------------------------------------------------------
384
385 /* Callback for wxFrame. This very strange beast has to be used because
386 * C++ has no virtual methods in a constructor. We have to emulate a
387 * virtual function here as wxWindows requires different ways to insert
388 * a child in container classes. */
389
390 static void wxInsertChildInFrame( wxFrame* parent, wxWindow* child )
391 {
392 wxASSERT( GTK_IS_WIDGET(child->m_widget) );
393
394 if (!parent->m_insertInClientArea)
395 {
396 /* these are outside the client area */
397 wxFrame* frame = (wxFrame*) parent;
398 gtk_pizza_put( GTK_PIZZA(frame->m_mainWidget),
399 GTK_WIDGET(child->m_widget),
400 child->m_x,
401 child->m_y,
402 child->m_width,
403 child->m_height );
404
405 #if wxUSE_TOOLBAR_NATIVE
406 /* we connect to these events for recalculating the client area
407 space when the toolbar is floating */
408 if (wxIS_KIND_OF(child,wxToolBar))
409 {
410 wxToolBar *toolBar = (wxToolBar*) child;
411 if (toolBar->GetWindowStyle() & wxTB_DOCKABLE)
412 {
413 gtk_signal_connect( GTK_OBJECT(toolBar->m_widget), "child_attached",
414 GTK_SIGNAL_FUNC(gtk_toolbar_attached_callback), (gpointer)parent );
415
416 gtk_signal_connect( GTK_OBJECT(toolBar->m_widget), "child_detached",
417 GTK_SIGNAL_FUNC(gtk_toolbar_detached_callback), (gpointer)parent );
418 }
419 }
420 #endif // wxUSE_TOOLBAR
421 }
422 else
423 {
424 /* these are inside the client area */
425 gtk_pizza_put( GTK_PIZZA(parent->m_wxwindow),
426 GTK_WIDGET(child->m_widget),
427 child->m_x,
428 child->m_y,
429 child->m_width,
430 child->m_height );
431 }
432
433 /* resize on OnInternalIdle */
434 parent->GtkUpdateSize();
435 }
436
437 // ----------------------------------------------------------------------------
438 // wxFrame creation
439 // ----------------------------------------------------------------------------
440
441 void wxFrame::Init()
442 {
443 m_sizeSet = FALSE;
444 m_miniEdge = 0;
445 m_miniTitle = 0;
446 m_mainWidget = (GtkWidget*) NULL;
447 m_menuBarDetached = FALSE;
448 m_toolBarDetached = FALSE;
449 m_insertInClientArea = TRUE;
450 m_isIconized = FALSE;
451 m_fsIsShowing = FALSE;
452 }
453
454 bool wxFrame::Create( wxWindow *parent,
455 wxWindowID id,
456 const wxString &title,
457 const wxPoint &pos,
458 const wxSize &size,
459 long style,
460 const wxString &name )
461 {
462 wxTopLevelWindows.Append( this );
463
464 m_needParent = FALSE;
465
466 if (!PreCreation( parent, pos, size ) ||
467 !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
468 {
469 wxFAIL_MSG( wxT("wxFrame creation failed") );
470 return FALSE;
471 }
472
473 m_title = title;
474
475 m_insertCallback = (wxInsertChildFunction) wxInsertChildInFrame;
476
477 GtkWindowType win_type = GTK_WINDOW_TOPLEVEL;
478
479 if (style & wxFRAME_TOOL_WINDOW)
480 win_type = GTK_WINDOW_POPUP;
481
482 m_widget = gtk_window_new( win_type );
483
484 if ((m_parent) && (HasFlag(wxFRAME_FLOAT_ON_PARENT)) && (GTK_IS_WINDOW(m_parent->m_widget)))
485 gtk_window_set_transient_for( GTK_WINDOW(m_widget), GTK_WINDOW(m_parent->m_widget) );
486
487 if (!name.IsEmpty())
488 gtk_window_set_wmclass( GTK_WINDOW(m_widget), name.mb_str(), name.mb_str() );
489
490 #ifdef __WXDEBUG__
491 debug_focus_in( m_widget, wxT("wxFrame::m_widget"), name );
492 #endif
493
494 gtk_window_set_title( GTK_WINDOW(m_widget), title.mbc_str() );
495 GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
496
497 gtk_signal_connect( GTK_OBJECT(m_widget), "delete_event",
498 GTK_SIGNAL_FUNC(gtk_frame_delete_callback), (gpointer)this );
499
500 /* m_mainWidget holds the toolbar, the menubar and the client area */
501 m_mainWidget = gtk_pizza_new();
502 gtk_widget_show( m_mainWidget );
503 GTK_WIDGET_UNSET_FLAGS( m_mainWidget, GTK_CAN_FOCUS );
504 gtk_container_add( GTK_CONTAINER(m_widget), m_mainWidget );
505
506 /* for m_mainWidget themes */
507 gtk_signal_connect( GTK_OBJECT(m_mainWidget), "expose_event",
508 GTK_SIGNAL_FUNC(gtk_window_expose_callback), (gpointer)this );
509 gtk_signal_connect( GTK_OBJECT(m_mainWidget), "draw",
510 GTK_SIGNAL_FUNC(gtk_window_draw_callback), (gpointer)this );
511
512 #ifdef __WXDEBUG__
513 debug_focus_in( m_mainWidget, wxT("wxFrame::m_mainWidget"), name );
514 #endif
515
516 /* m_wxwindow only represents the client area without toolbar and menubar */
517 m_wxwindow = gtk_pizza_new();
518 gtk_widget_show( m_wxwindow );
519 gtk_container_add( GTK_CONTAINER(m_mainWidget), m_wxwindow );
520
521 #ifdef __WXDEBUG__
522 debug_focus_in( m_wxwindow, wxT("wxFrame::m_wxwindow"), name );
523 #endif
524
525 /* we donm't allow the frame to get the focus as otherwise
526 the frame will grabit at arbitrary fcous changes. */
527 GTK_WIDGET_UNSET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );
528
529 if (m_parent) m_parent->AddChild( this );
530
531 /* the user resized the frame by dragging etc. */
532 gtk_signal_connect( GTK_OBJECT(m_widget), "size_allocate",
533 GTK_SIGNAL_FUNC(gtk_frame_size_callback), (gpointer)this );
534
535 PostCreation();
536
537 if ((m_x != -1) || (m_y != -1))
538 gtk_widget_set_uposition( m_widget, m_x, m_y );
539 gtk_widget_set_usize( m_widget, m_width, m_height );
540
541 /* we cannot set MWM hints and icons before the widget has
542 been realized, so we do this directly after realization */
543 gtk_signal_connect( GTK_OBJECT(m_widget), "realize",
544 GTK_SIGNAL_FUNC(gtk_frame_realized_callback), (gpointer) this );
545
546 /* the only way to get the window size is to connect to this event */
547 gtk_signal_connect( GTK_OBJECT(m_widget), "configure_event",
548 GTK_SIGNAL_FUNC(gtk_frame_configure_callback), (gpointer)this );
549
550 /* map and unmap for iconized state */
551 gtk_signal_connect( GTK_OBJECT(m_widget), "map_event",
552 GTK_SIGNAL_FUNC(gtk_frame_map_callback), (gpointer)this );
553 gtk_signal_connect( GTK_OBJECT(m_widget), "unmap_event",
554 GTK_SIGNAL_FUNC(gtk_frame_unmap_callback), (gpointer)this );
555
556 /* the only way to get the window size is to connect to this event */
557 gtk_signal_connect( GTK_OBJECT(m_widget), "configure_event",
558 GTK_SIGNAL_FUNC(gtk_frame_configure_callback), (gpointer)this );
559
560 /* disable native tab traversal */
561 gtk_signal_connect( GTK_OBJECT(m_widget), "focus",
562 GTK_SIGNAL_FUNC(gtk_frame_focus_callback), (gpointer)this );
563
564 return TRUE;
565 }
566
567 wxFrame::~wxFrame()
568 {
569 m_isBeingDeleted = TRUE;
570
571 DeleteAllBars();
572
573 wxTopLevelWindows.DeleteObject( this );
574
575 if (wxTheApp->GetTopWindow() == this)
576 wxTheApp->SetTopWindow( (wxWindow*) NULL );
577
578 if ((wxTopLevelWindows.Number() == 0) &&
579 (wxTheApp->GetExitOnFrameDelete()))
580 {
581 wxTheApp->ExitMainLoop();
582 }
583 }
584
585 bool wxFrame::ShowFullScreen(bool show, long style )
586 {
587 if (show == m_fsIsShowing) return FALSE; // return what?
588
589 m_fsIsShowing = show;
590
591 if (show)
592 {
593 m_fsSaveStyle = m_windowStyle;
594 m_fsSaveFlag = style;
595 GetPosition( &m_fsSaveFrame.x, &m_fsSaveFrame.y );
596 GetSize( &m_fsSaveFrame.width, &m_fsSaveFrame.height );
597
598 gtk_widget_hide( m_widget );
599 gtk_widget_unrealize( m_widget );
600
601 m_windowStyle = wxSIMPLE_BORDER;
602
603 int x;
604 int y;
605 wxDisplaySize( &x, &y );
606 SetSize( 0, 0, x, y );
607
608 gtk_widget_realize( m_widget );
609 gtk_widget_show( m_widget );
610 }
611 else
612 {
613 gtk_widget_hide( m_widget );
614 gtk_widget_unrealize( m_widget );
615
616 m_windowStyle = m_fsSaveStyle;
617
618 SetSize( m_fsSaveFrame.x, m_fsSaveFrame.y, m_fsSaveFrame.width, m_fsSaveFrame.height );
619
620 gtk_widget_realize( m_widget );
621 gtk_widget_show( m_widget );
622 }
623
624 return TRUE;
625 }
626
627 // ----------------------------------------------------------------------------
628 // overridden wxWindow methods
629 // ----------------------------------------------------------------------------
630
631 bool wxFrame::Show( bool show )
632 {
633 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
634
635 if (show && !m_sizeSet)
636 {
637 /* by calling GtkOnSize here, we don't have to call
638 either after showing the frame, which would entail
639 much ugly flicker or from within the size_allocate
640 handler, because GTK 1.1.X forbids that. */
641
642 GtkOnSize( m_x, m_y, m_width, m_height );
643 }
644
645 return wxWindow::Show( show );
646 }
647
648 void wxFrame::DoMoveWindow(int WXUNUSED(x), int WXUNUSED(y), int WXUNUSED(width), int WXUNUSED(height) )
649 {
650 wxFAIL_MSG( wxT("DoMoveWindow called for wxFrame") );
651 }
652
653 void wxFrame::DoSetSize( int x, int y, int width, int height, int sizeFlags )
654 {
655 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
656
657 /* this shouldn't happen: wxFrame, wxMDIParentFrame and wxMDIChildFrame have m_wxwindow */
658 wxASSERT_MSG( (m_wxwindow != NULL), wxT("invalid frame") );
659
660 /* avoid recursions */
661 if (m_resizing)
662 return;
663 m_resizing = TRUE;
664
665 int old_x = m_x;
666 int old_y = m_y;
667
668 int old_width = m_width;
669 int old_height = m_height;
670
671 if ((sizeFlags & wxSIZE_ALLOW_MINUS_ONE) == 0)
672 {
673 if (x != -1) m_x = x;
674 if (y != -1) m_y = y;
675 if (width != -1) m_width = width;
676 if (height != -1) m_height = height;
677 }
678 else
679 {
680 m_x = x;
681 m_y = y;
682 m_width = width;
683 m_height = height;
684 }
685
686 /*
687 if ((sizeFlags & wxSIZE_AUTO_WIDTH) == wxSIZE_AUTO_WIDTH)
688 {
689 if (width == -1) m_width = 80;
690 }
691
692 if ((sizeFlags & wxSIZE_AUTO_HEIGHT) == wxSIZE_AUTO_HEIGHT)
693 {
694 if (height == -1) m_height = 26;
695 }
696 */
697
698 if ((m_minWidth != -1) && (m_width < m_minWidth)) m_width = m_minWidth;
699 if ((m_minHeight != -1) && (m_height < m_minHeight)) m_height = m_minHeight;
700 if ((m_maxWidth != -1) && (m_width > m_maxWidth)) m_width = m_maxWidth;
701 if ((m_maxHeight != -1) && (m_height > m_maxHeight)) m_height = m_maxHeight;
702
703 if ((m_x != -1) || (m_y != -1))
704 {
705 if ((m_x != old_x) || (m_y != old_y))
706 {
707 gtk_widget_set_uposition( m_widget, m_x, m_y );
708 }
709 }
710
711 if ((m_width != old_width) || (m_height != old_height))
712 {
713 gtk_widget_set_usize( m_widget, m_width, m_height );
714
715 /* we set the size in GtkOnSize, i.e. mostly the actual resizing is
716 done either directly before the frame is shown or in idle time
717 so that different calls to SetSize() don't lead to flicker. */
718 m_sizeSet = FALSE;
719 }
720
721 m_resizing = FALSE;
722 }
723
724 void wxFrame::DoGetClientSize( int *width, int *height ) const
725 {
726 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
727
728 wxWindow::DoGetClientSize( width, height );
729 if (height)
730 {
731 /* menu bar */
732 if (m_frameMenuBar)
733 {
734 if (!m_menuBarDetached)
735 (*height) -= wxMENU_HEIGHT;
736 else
737 (*height) -= wxPLACE_HOLDER;
738 }
739
740 #if wxUSE_STATUSBAR
741 /* status bar */
742 if (m_frameStatusBar && m_frameStatusBar->IsShown()) (*height) -= wxSTATUS_HEIGHT;
743 #endif // wxUSE_STATUSBAR
744
745 #if wxUSE_TOOLBAR
746 /* tool bar */
747 if (m_frameToolBar && m_frameToolBar->IsShown())
748 {
749 if (m_toolBarDetached)
750 {
751 *height -= wxPLACE_HOLDER;
752 }
753 else
754 {
755 int x, y;
756 m_frameToolBar->GetSize( &x, &y );
757 if ( m_frameToolBar->GetWindowStyle() & wxTB_VERTICAL )
758 {
759 *width -= x;
760 }
761 else
762 {
763 *height -= y;
764 }
765 }
766 }
767 #endif // wxUSE_TOOLBAR
768
769 /* mini edge */
770 *height -= m_miniEdge*2 + m_miniTitle;
771 }
772 if (width)
773 {
774 *width -= m_miniEdge*2;
775 }
776 }
777
778 void wxFrame::DoSetClientSize( int width, int height )
779 {
780 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
781
782 /* menu bar */
783 if (m_frameMenuBar)
784 {
785 if (!m_menuBarDetached)
786 height += wxMENU_HEIGHT;
787 else
788 height += wxPLACE_HOLDER;
789 }
790
791 #if wxUSE_STATUSBAR
792 /* status bar */
793 if (m_frameStatusBar && m_frameStatusBar->IsShown()) height += wxSTATUS_HEIGHT;
794 #endif
795
796 #if wxUSE_TOOLBAR
797 /* tool bar */
798 if (m_frameToolBar && m_frameToolBar->IsShown())
799 {
800 if (m_toolBarDetached)
801 {
802 height += wxPLACE_HOLDER;
803 }
804 else
805 {
806 int x, y;
807 m_frameToolBar->GetSize( &x, &y );
808 if ( m_frameToolBar->GetWindowStyle() & wxTB_VERTICAL )
809 {
810 width += x;
811 }
812 else
813 {
814 height += y;
815 }
816 }
817 }
818 #endif
819
820 DoSetSize( -1, -1, width + m_miniEdge*2, height + m_miniEdge*2 + m_miniTitle, 0 );
821 }
822
823 void wxFrame::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y),
824 int width, int height )
825 {
826 // due to a bug in gtk, x,y are always 0
827 // m_x = x;
828 // m_y = y;
829
830 /* avoid recursions */
831 if (m_resizing) return;
832 m_resizing = TRUE;
833
834 /* this shouldn't happen: wxFrame, wxMDIParentFrame and wxMDIChildFrame have m_wxwindow */
835 wxASSERT_MSG( (m_wxwindow != NULL), wxT("invalid frame") );
836
837 m_width = width;
838 m_height = height;
839
840 /* space occupied by m_frameToolBar and m_frameMenuBar */
841 int client_area_x_offset = 0,
842 client_area_y_offset = 0;
843
844 /* wxMDIChildFrame derives from wxFrame but it _is_ a wxWindow as it uses
845 wxWindow::Create to create it's GTK equivalent. m_mainWidget is only
846 set in wxFrame::Create so it is used to check what kind of frame we
847 have here. if m_mainWidget is NULL it is a wxMDIChildFrame and so we
848 skip the part which handles m_frameMenuBar, m_frameToolBar and (most
849 importantly) m_mainWidget */
850
851 if ((m_minWidth != -1) && (m_width < m_minWidth)) m_width = m_minWidth;
852 if ((m_minHeight != -1) && (m_height < m_minHeight)) m_height = m_minHeight;
853 if ((m_maxWidth != -1) && (m_width > m_maxWidth)) m_width = m_maxWidth;
854 if ((m_maxHeight != -1) && (m_height > m_maxHeight)) m_height = m_maxHeight;
855
856 if (m_mainWidget)
857 {
858 /* set size hints */
859 gint flag = 0; // GDK_HINT_POS;
860 if ((m_minWidth != -1) || (m_minHeight != -1)) flag |= GDK_HINT_MIN_SIZE;
861 if ((m_maxWidth != -1) || (m_maxHeight != -1)) flag |= GDK_HINT_MAX_SIZE;
862 GdkGeometry geom;
863 geom.min_width = m_minWidth;
864 geom.min_height = m_minHeight;
865 geom.max_width = m_maxWidth;
866 geom.max_height = m_maxHeight;
867 gtk_window_set_geometry_hints( GTK_WINDOW(m_widget),
868 (GtkWidget*) NULL,
869 &geom,
870 (GdkWindowHints) flag );
871
872 /* I revert back to wxGTK's original behaviour. m_mainWidget holds the
873 * menubar, the toolbar and the client area, which is represented by
874 * m_wxwindow.
875 * this hurts in the eye, but I don't want to call SetSize()
876 * because I don't want to call any non-native functions here. */
877
878 if (m_frameMenuBar)
879 {
880 int xx = m_miniEdge;
881 int yy = m_miniEdge + m_miniTitle;
882 int ww = m_width - 2*m_miniEdge;
883 int hh = wxMENU_HEIGHT;
884 if (m_menuBarDetached) hh = wxPLACE_HOLDER;
885 m_frameMenuBar->m_x = xx;
886 m_frameMenuBar->m_y = yy;
887 m_frameMenuBar->m_width = ww;
888 m_frameMenuBar->m_height = hh;
889 gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
890 m_frameMenuBar->m_widget,
891 xx, yy, ww, hh );
892 client_area_y_offset += hh;
893 }
894
895 #if wxUSE_TOOLBAR
896 if ((m_frameToolBar) && m_frameToolBar->IsShown() &&
897 (m_frameToolBar->m_widget->parent == m_mainWidget))
898 {
899 int xx = m_miniEdge;
900 int yy = m_miniEdge + m_miniTitle;
901 if (m_frameMenuBar)
902 {
903 if (!m_menuBarDetached)
904 yy += wxMENU_HEIGHT;
905 else
906 yy += wxPLACE_HOLDER;
907 }
908
909 m_frameToolBar->m_x = xx;
910 m_frameToolBar->m_y = yy;
911
912 /* don't change the toolbar's reported height/width */
913 int ww, hh;
914 if ( m_frameToolBar->GetWindowStyle() & wxTB_VERTICAL )
915 {
916 ww = m_toolBarDetached ? wxPLACE_HOLDER
917 : m_frameToolBar->m_width;
918 hh = m_height - 2*m_miniEdge;
919
920 client_area_x_offset += ww;
921 }
922 else
923 {
924 ww = m_width - 2*m_miniEdge;
925 hh = m_toolBarDetached ? wxPLACE_HOLDER
926 : m_frameToolBar->m_height;
927
928 client_area_y_offset += hh;
929 }
930
931 gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
932 m_frameToolBar->m_widget,
933 xx, yy, ww, hh );
934 }
935 #endif // wxUSE_TOOLBAR
936
937 int client_x = client_area_x_offset + m_miniEdge;
938 int client_y = client_area_y_offset + m_miniEdge + m_miniTitle;
939 int client_w = m_width - client_area_x_offset - 2*m_miniEdge;
940 int client_h = m_height - client_area_y_offset- 2*m_miniEdge - m_miniTitle;
941 gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
942 m_wxwindow,
943 client_x, client_y, client_w, client_h );
944 }
945 else
946 {
947 /* if there is no m_mainWidget between m_widget and m_wxwindow there
948 is no need to set the size or position of m_wxwindow. */
949 }
950
951 #if wxUSE_STATUSBAR
952 if (m_frameStatusBar && m_frameStatusBar->IsShown())
953 {
954 int xx = 0 + m_miniEdge;
955 int yy = m_height - wxSTATUS_HEIGHT - m_miniEdge - client_area_y_offset;
956 int ww = m_width - 2*m_miniEdge;
957 int hh = wxSTATUS_HEIGHT;
958 m_frameStatusBar->m_x = xx;
959 m_frameStatusBar->m_y = yy;
960 m_frameStatusBar->m_width = ww;
961 m_frameStatusBar->m_height = hh;
962 gtk_pizza_set_size( GTK_PIZZA(m_wxwindow),
963 m_frameStatusBar->m_widget,
964 xx, yy, ww, hh );
965 gtk_widget_draw( m_frameStatusBar->m_widget, (GdkRectangle*) NULL );
966 }
967 #endif
968
969 m_sizeSet = TRUE;
970
971 // send size event to frame
972 wxSizeEvent event( wxSize(m_width,m_height), GetId() );
973 event.SetEventObject( this );
974 GetEventHandler()->ProcessEvent( event );
975
976 // send size event to status bar
977 if (m_frameStatusBar)
978 {
979 wxSizeEvent event2( wxSize(m_frameStatusBar->m_width,m_frameStatusBar->m_height), m_frameStatusBar->GetId() );
980 event2.SetEventObject( m_frameStatusBar );
981 m_frameStatusBar->GetEventHandler()->ProcessEvent( event2 );
982 }
983
984 m_resizing = FALSE;
985 }
986
987 void wxFrame::MakeModal( bool modal )
988 {
989 if (modal)
990 gtk_grab_add( m_widget );
991 else
992 gtk_grab_remove( m_widget );
993 }
994
995 void wxFrame::OnInternalIdle()
996 {
997 if (!m_sizeSet && GTK_WIDGET_REALIZED(m_wxwindow))
998 {
999 GtkOnSize( m_x, m_y, m_width, m_height );
1000
1001 // we'll come back later
1002 if (g_isIdle)
1003 wxapp_install_idle_handler();
1004 return;
1005 }
1006
1007 if (m_frameMenuBar) m_frameMenuBar->OnInternalIdle();
1008 #if wxUSE_TOOLBAR
1009 if (m_frameToolBar) m_frameToolBar->OnInternalIdle();
1010 #endif
1011 #if wxUSE_STATUSBAR
1012 if (m_frameStatusBar) m_frameStatusBar->OnInternalIdle();
1013 #endif
1014
1015 wxWindow::OnInternalIdle();
1016 }
1017
1018 // ----------------------------------------------------------------------------
1019 // menu/tool/status bar stuff
1020 // ----------------------------------------------------------------------------
1021
1022 void wxFrame::SetMenuBar( wxMenuBar *menuBar )
1023 {
1024 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
1025 wxASSERT_MSG( (m_wxwindow != NULL), wxT("invalid frame") );
1026
1027 if (menuBar == m_frameMenuBar)
1028 return;
1029
1030 if (m_frameMenuBar)
1031 {
1032 m_frameMenuBar->UnsetInvokingWindow( this );
1033
1034 if (m_frameMenuBar->GetWindowStyle() & wxMB_DOCKABLE)
1035 {
1036 gtk_signal_disconnect_by_func( GTK_OBJECT(m_frameMenuBar->m_widget),
1037 GTK_SIGNAL_FUNC(gtk_menu_attached_callback), (gpointer)this );
1038
1039 gtk_signal_disconnect_by_func( GTK_OBJECT(m_frameMenuBar->m_widget),
1040 GTK_SIGNAL_FUNC(gtk_menu_detached_callback), (gpointer)this );
1041 }
1042
1043 gtk_container_remove( GTK_CONTAINER(m_mainWidget), m_frameMenuBar->m_widget );
1044 gtk_widget_ref( m_frameMenuBar->m_widget );
1045 gtk_widget_unparent( m_frameMenuBar->m_widget );
1046 }
1047
1048 m_frameMenuBar = menuBar;
1049
1050 if (m_frameMenuBar)
1051 {
1052 m_frameMenuBar->SetInvokingWindow( this );
1053
1054 m_frameMenuBar->SetParent(this);
1055 gtk_pizza_put( GTK_PIZZA(m_mainWidget),
1056 m_frameMenuBar->m_widget,
1057 m_frameMenuBar->m_x,
1058 m_frameMenuBar->m_y,
1059 m_frameMenuBar->m_width,
1060 m_frameMenuBar->m_height );
1061
1062 if (menuBar->GetWindowStyle() & wxMB_DOCKABLE)
1063 {
1064 gtk_signal_connect( GTK_OBJECT(menuBar->m_widget), "child_attached",
1065 GTK_SIGNAL_FUNC(gtk_menu_attached_callback), (gpointer)this );
1066
1067 gtk_signal_connect( GTK_OBJECT(menuBar->m_widget), "child_detached",
1068 GTK_SIGNAL_FUNC(gtk_menu_detached_callback), (gpointer)this );
1069 }
1070
1071 m_frameMenuBar->Show( TRUE );
1072 }
1073
1074 /* resize window in OnInternalIdle */
1075 m_sizeSet = FALSE;
1076 }
1077
1078 #if wxUSE_TOOLBAR
1079 wxToolBar* wxFrame::CreateToolBar( long style, wxWindowID id, const wxString& name )
1080 {
1081 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
1082
1083 m_insertInClientArea = FALSE;
1084
1085 m_frameToolBar = wxFrameBase::CreateToolBar( style, id, name );
1086
1087 m_insertInClientArea = TRUE;
1088
1089 m_sizeSet = FALSE;
1090
1091 return m_frameToolBar;
1092 }
1093
1094 void wxFrame::SetToolBar(wxToolBar *toolbar)
1095 {
1096 wxFrameBase::SetToolBar(toolbar);
1097
1098 if (m_frameToolBar)
1099 {
1100 /* insert into toolbar area if not already there */
1101 if ((m_frameToolBar->m_widget->parent) &&
1102 (m_frameToolBar->m_widget->parent != m_mainWidget))
1103 {
1104 GetChildren().DeleteObject( m_frameToolBar );
1105
1106 gtk_widget_reparent( m_frameToolBar->m_widget, m_mainWidget );
1107 GtkUpdateSize();
1108 }
1109 }
1110 }
1111
1112 #endif // wxUSE_TOOLBAR
1113
1114 #if wxUSE_STATUSBAR
1115
1116 wxStatusBar* wxFrame::CreateStatusBar(int number,
1117 long style,
1118 wxWindowID id,
1119 const wxString& name)
1120 {
1121 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
1122
1123 // because it will change when toolbar is added
1124 m_sizeSet = FALSE;
1125
1126 return wxFrameBase::CreateStatusBar( number, style, id, name );
1127 }
1128
1129 void wxFrame::PositionStatusBar()
1130 {
1131 if ( !m_frameStatusBar )
1132 return;
1133
1134 m_sizeSet = FALSE;
1135 }
1136 #endif // wxUSE_STATUSBAR
1137
1138 // ----------------------------------------------------------------------------
1139 // frame title/icon
1140 // ----------------------------------------------------------------------------
1141
1142 void wxFrame::SetTitle( const wxString &title )
1143 {
1144 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
1145
1146 m_title = title;
1147 gtk_window_set_title( GTK_WINDOW(m_widget), title.mbc_str() );
1148 }
1149
1150 void wxFrame::SetIcon( const wxIcon &icon )
1151 {
1152 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
1153
1154 wxFrameBase::SetIcon(icon);
1155
1156 if ( !m_icon.Ok() )
1157 return;
1158
1159 if (!m_widget->window)
1160 return;
1161
1162 wxMask *mask = icon.GetMask();
1163 GdkBitmap *bm = (GdkBitmap *) NULL;
1164 if (mask) bm = mask->GetBitmap();
1165
1166 gdk_window_set_icon( m_widget->window, (GdkWindow *) NULL, icon.GetPixmap(), bm );
1167 }
1168
1169 // ----------------------------------------------------------------------------
1170 // frame state: maximized/iconized/normal
1171 // ----------------------------------------------------------------------------
1172
1173 void wxFrame::Maximize(bool WXUNUSED(maximize))
1174 {
1175 wxFAIL_MSG( _T("not implemented") );
1176 }
1177
1178 bool wxFrame::IsMaximized() const
1179 {
1180 wxFAIL_MSG( _T("not implemented") );
1181
1182 return FALSE;
1183 }
1184
1185 void wxFrame::Restore()
1186 {
1187 wxFAIL_MSG( _T("not implemented") );
1188 }
1189
1190 void wxFrame::Iconize( bool iconize )
1191 {
1192 if (iconize)
1193 {
1194 XIconifyWindow( GDK_WINDOW_XDISPLAY( m_widget->window ),
1195 GDK_WINDOW_XWINDOW( m_widget->window ),
1196 DefaultScreen( GDK_DISPLAY() ) );
1197 }
1198 }
1199
1200 bool wxFrame::IsIconized() const
1201 {
1202 return m_isIconized;
1203 }
wxWidgets (Impactor)