]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/gtk/frame.cpp
Fixed typo.
[wxWidgets.git] / src / gtk / frame.cpp
... / ...
CommitLineData
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
51const int wxMENU_HEIGHT = 27;
52const int wxSTATUS_HEIGHT = 25;
53const int wxPLACE_HOLDER = 0;
54
55// ----------------------------------------------------------------------------
56// idle system
57// ----------------------------------------------------------------------------
58
59extern void wxapp_install_idle_handler();
60extern bool g_isIdle;
61extern int g_openDialogs;
62
63// ----------------------------------------------------------------------------
64// event tables
65// ----------------------------------------------------------------------------
66
67IMPLEMENT_DYNAMIC_CLASS(wxFrame,wxWindow)
68
69// ----------------------------------------------------------------------------
70// data
71// ----------------------------------------------------------------------------
72
73extern wxList wxPendingDelete;
74
75// ----------------------------------------------------------------------------
76// debug
77// ----------------------------------------------------------------------------
78
79#ifdef __WXDEBUG__
80
81extern 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
97static 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
111static 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
142static 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
157static 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
169static 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
182static 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
195static 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
211static gint
212#if (GTK_MINOR_VERSION > 0)
213gtk_frame_configure_callback( GtkWidget *WXUNUSED(widget), GdkEventConfigure *WXUNUSED(event), wxFrame *win )
214#else
215gtk_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
249static gint
250gtk_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)))
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 return FALSE;
326}
327
328// ----------------------------------------------------------------------------
329// wxFrame itself
330// ----------------------------------------------------------------------------
331
332//-----------------------------------------------------------------------------
333// InsertChild for wxFrame
334//-----------------------------------------------------------------------------
335
336/* Callback for wxFrame. This very strange beast has to be used because
337 * C++ has no virtual methods in a constructor. We have to emulate a
338 * virtual function here as wxWindows requires different ways to insert
339 * a child in container classes. */
340
341static void wxInsertChildInFrame( wxFrame* parent, wxWindow* child )
342{
343 wxASSERT( GTK_IS_WIDGET(child->m_widget) );
344
345 if (!parent->m_insertInClientArea)
346 {
347 /* these are outside the client area */
348 wxFrame* frame = (wxFrame*) parent;
349 gtk_pizza_put( GTK_PIZZA(frame->m_mainWidget),
350 GTK_WIDGET(child->m_widget),
351 child->m_x,
352 child->m_y,
353 child->m_width,
354 child->m_height );
355
356#if wxUSE_TOOLBAR_NATIVE
357 /* we connect to these events for recalculating the client area
358 space when the toolbar is floating */
359 if (wxIS_KIND_OF(child,wxToolBar))
360 {
361 wxToolBar *toolBar = (wxToolBar*) child;
362 if (toolBar->GetWindowStyle() & wxTB_DOCKABLE)
363 {
364 gtk_signal_connect( GTK_OBJECT(toolBar->m_widget), "child_attached",
365 GTK_SIGNAL_FUNC(gtk_toolbar_attached_callback), (gpointer)parent );
366
367 gtk_signal_connect( GTK_OBJECT(toolBar->m_widget), "child_detached",
368 GTK_SIGNAL_FUNC(gtk_toolbar_detached_callback), (gpointer)parent );
369 }
370 }
371#endif // wxUSE_TOOLBAR
372 }
373 else
374 {
375 /* these are inside the client area */
376 gtk_pizza_put( GTK_PIZZA(parent->m_wxwindow),
377 GTK_WIDGET(child->m_widget),
378 child->m_x,
379 child->m_y,
380 child->m_width,
381 child->m_height );
382 }
383
384 /* resize on OnInternalIdle */
385 parent->GtkUpdateSize();
386}
387
388// ----------------------------------------------------------------------------
389// wxFrame creation
390// ----------------------------------------------------------------------------
391
392void wxFrame::Init()
393{
394 m_sizeSet = FALSE;
395 m_miniEdge = 0;
396 m_miniTitle = 0;
397 m_mainWidget = (GtkWidget*) NULL;
398 m_menuBarDetached = FALSE;
399 m_toolBarDetached = FALSE;
400 m_insertInClientArea = TRUE;
401}
402
403bool wxFrame::Create( wxWindow *parent,
404 wxWindowID id,
405 const wxString &title,
406 const wxPoint &pos,
407 const wxSize &size,
408 long style,
409 const wxString &name )
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("wxFrame creation failed") );
419 return FALSE;
420 }
421
422 m_title = title;
423
424 m_insertCallback = (wxInsertChildFunction) wxInsertChildInFrame;
425
426 GtkWindowType win_type = GTK_WINDOW_TOPLEVEL;
427
428 m_widget = gtk_window_new( win_type );
429
430 if ((m_parent) && (HasFlag(wxFRAME_FLOAT_ON_PARENT)) && (GTK_IS_WINDOW(m_parent->m_widget)))
431 gtk_window_set_transient_for( GTK_WINDOW(m_widget), GTK_WINDOW(m_parent->m_widget) );
432
433 if (!name.IsEmpty())
434 gtk_window_set_wmclass( GTK_WINDOW(m_widget), name.mb_str(), name.mb_str() );
435
436#ifdef __WXDEBUG__
437 debug_focus_in( m_widget, wxT("wxFrame::m_widget"), name );
438#endif
439
440 gtk_window_set_title( GTK_WINDOW(m_widget), title.mbc_str() );
441 GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
442
443 gtk_signal_connect( GTK_OBJECT(m_widget), "delete_event",
444 GTK_SIGNAL_FUNC(gtk_frame_delete_callback), (gpointer)this );
445
446 /* m_mainWidget holds the toolbar, the menubar and the client area */
447 m_mainWidget = gtk_pizza_new();
448 gtk_widget_show( m_mainWidget );
449 GTK_WIDGET_UNSET_FLAGS( m_mainWidget, GTK_CAN_FOCUS );
450 gtk_container_add( GTK_CONTAINER(m_widget), m_mainWidget );
451
452#ifdef __WXDEBUG__
453 debug_focus_in( m_mainWidget, wxT("wxFrame::m_mainWidget"), name );
454#endif
455
456 /* m_wxwindow only represents the client area without toolbar and menubar */
457 m_wxwindow = gtk_pizza_new();
458 gtk_widget_show( m_wxwindow );
459 gtk_container_add( GTK_CONTAINER(m_mainWidget), m_wxwindow );
460
461#ifdef __WXDEBUG__
462 debug_focus_in( m_wxwindow, wxT("wxFrame::m_wxwindow"), name );
463#endif
464
465 /* we donm't allow the frame to get the focus as otherwise
466 the frame will grabit at arbitrary fcous changes. */
467 GTK_WIDGET_UNSET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );
468
469 if (m_parent) m_parent->AddChild( this );
470
471 /* the user resized the frame by dragging etc. */
472 gtk_signal_connect( GTK_OBJECT(m_widget), "size_allocate",
473 GTK_SIGNAL_FUNC(gtk_frame_size_callback), (gpointer)this );
474
475 PostCreation();
476
477 if ((m_x != -1) || (m_y != -1))
478 gtk_widget_set_uposition( m_widget, m_x, m_y );
479 gtk_widget_set_usize( m_widget, m_width, m_height );
480
481 /* we cannot set MWM hints and icons before the widget has
482 been realized, so we do this directly after realization */
483 gtk_signal_connect( GTK_OBJECT(m_widget), "realize",
484 GTK_SIGNAL_FUNC(gtk_frame_realized_callback), (gpointer) this );
485
486 /* the only way to get the window size is to connect to this event */
487 gtk_signal_connect( GTK_OBJECT(m_widget), "configure_event",
488 GTK_SIGNAL_FUNC(gtk_frame_configure_callback), (gpointer)this );
489
490 /* disable native tab traversal */
491 gtk_signal_connect( GTK_OBJECT(m_widget), "focus",
492 GTK_SIGNAL_FUNC(gtk_frame_focus_callback), (gpointer)this );
493
494 return TRUE;
495}
496
497wxFrame::~wxFrame()
498{
499 m_isBeingDeleted = TRUE;
500
501 DeleteAllBars();
502
503 wxTopLevelWindows.DeleteObject( this );
504
505 if (wxTheApp->GetTopWindow() == this)
506 wxTheApp->SetTopWindow( (wxWindow*) NULL );
507
508 if ((wxTopLevelWindows.Number() == 0) &&
509 (wxTheApp->GetExitOnFrameDelete()))
510 {
511 wxTheApp->ExitMainLoop();
512 }
513}
514
515// ----------------------------------------------------------------------------
516// overridden wxWindow methods
517// ----------------------------------------------------------------------------
518
519bool wxFrame::Show( bool show )
520{
521 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
522
523 if (show && !m_sizeSet)
524 {
525 /* by calling GtkOnSize here, we don't have to call
526 either after showing the frame, which would entail
527 much ugly flicker or from within the size_allocate
528 handler, because GTK 1.1.X forbids that. */
529
530 GtkOnSize( m_x, m_y, m_width, m_height );
531 }
532
533 return wxWindow::Show( show );
534}
535
536void wxFrame::DoMoveWindow(int WXUNUSED(x), int WXUNUSED(y), int WXUNUSED(width), int WXUNUSED(height) )
537{
538 wxFAIL_MSG( wxT("DoMoveWindow called for wxFrame") );
539}
540
541void wxFrame::DoSetSize( int x, int y, int width, int height, int sizeFlags )
542{
543 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
544
545 /* this shouldn't happen: wxFrame, wxMDIParentFrame and wxMDIChildFrame have m_wxwindow */
546 wxASSERT_MSG( (m_wxwindow != NULL), wxT("invalid frame") );
547
548 /* avoid recursions */
549 if (m_resizing)
550 return;
551 m_resizing = TRUE;
552
553 int old_x = m_x;
554 int old_y = m_y;
555
556 int old_width = m_width;
557 int old_height = m_height;
558
559 if ((sizeFlags & wxSIZE_ALLOW_MINUS_ONE) == 0)
560 {
561 if (x != -1) m_x = x;
562 if (y != -1) m_y = y;
563 if (width != -1) m_width = width;
564 if (height != -1) m_height = height;
565 }
566 else
567 {
568 m_x = x;
569 m_y = y;
570 m_width = width;
571 m_height = height;
572 }
573
574/*
575 if ((sizeFlags & wxSIZE_AUTO_WIDTH) == wxSIZE_AUTO_WIDTH)
576 {
577 if (width == -1) m_width = 80;
578 }
579
580 if ((sizeFlags & wxSIZE_AUTO_HEIGHT) == wxSIZE_AUTO_HEIGHT)
581 {
582 if (height == -1) m_height = 26;
583 }
584*/
585
586 if ((m_minWidth != -1) && (m_width < m_minWidth)) m_width = m_minWidth;
587 if ((m_minHeight != -1) && (m_height < m_minHeight)) m_height = m_minHeight;
588 if ((m_maxWidth != -1) && (m_width > m_maxWidth)) m_width = m_maxWidth;
589 if ((m_maxHeight != -1) && (m_height > m_maxHeight)) m_height = m_maxHeight;
590
591 if ((m_x != -1) || (m_y != -1))
592 {
593 if ((m_x != old_x) || (m_y != old_y))
594 {
595 gtk_widget_set_uposition( m_widget, m_x, m_y );
596 }
597 }
598
599 if ((m_width != old_width) || (m_height != old_height))
600 {
601 gtk_widget_set_usize( m_widget, m_width, m_height );
602
603 /* we set the size in GtkOnSize, i.e. mostly the actual resizing is
604 done either directly before the frame is shown or in idle time
605 so that different calls to SetSize() don't lead to flicker. */
606 m_sizeSet = FALSE;
607 }
608
609 m_resizing = FALSE;
610}
611
612void wxFrame::DoGetClientSize( int *width, int *height ) const
613{
614 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
615
616 wxWindow::DoGetClientSize( width, height );
617 if (height)
618 {
619 /* menu bar */
620 if (m_frameMenuBar)
621 {
622 if (!m_menuBarDetached)
623 (*height) -= wxMENU_HEIGHT;
624 else
625 (*height) -= wxPLACE_HOLDER;
626 }
627
628#if wxUSE_STATUSBAR
629 /* status bar */
630 if (m_frameStatusBar) (*height) -= wxSTATUS_HEIGHT;
631#endif // wxUSE_STATUSBAR
632
633#if wxUSE_TOOLBAR
634 /* tool bar */
635 if (m_frameToolBar)
636 {
637 if (m_toolBarDetached)
638 {
639 *height -= wxPLACE_HOLDER;
640 }
641 else
642 {
643 int x, y;
644 m_frameToolBar->GetSize( &x, &y );
645 if ( m_frameToolBar->GetWindowStyle() & wxTB_VERTICAL )
646 {
647 *width -= x;
648 }
649 else
650 {
651 *height -= y;
652 }
653 }
654 }
655#endif // wxUSE_TOOLBAR
656
657 /* mini edge */
658 *height -= m_miniEdge*2 + m_miniTitle;
659 }
660 if (width)
661 {
662 *width -= m_miniEdge*2;
663 }
664}
665
666void wxFrame::DoSetClientSize( int width, int height )
667{
668 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
669
670 /* menu bar */
671 if (m_frameMenuBar)
672 {
673 if (!m_menuBarDetached)
674 height += wxMENU_HEIGHT;
675 else
676 height += wxPLACE_HOLDER;
677 }
678
679#if wxUSE_STATUSBAR
680 /* status bar */
681 if (m_frameStatusBar) height += wxSTATUS_HEIGHT;
682#endif
683
684#if wxUSE_TOOLBAR
685 /* tool bar */
686 if (m_frameToolBar)
687 {
688 if (m_toolBarDetached)
689 {
690 height += wxPLACE_HOLDER;
691 }
692 else
693 {
694 int x, y;
695 m_frameToolBar->GetSize( &x, &y );
696 if ( m_frameToolBar->GetWindowStyle() & wxTB_VERTICAL )
697 {
698 width += x;
699 }
700 else
701 {
702 height += y;
703 }
704 }
705 }
706#endif
707
708 DoSetSize( -1, -1, width + m_miniEdge*2, height + m_miniEdge*2 + m_miniTitle, 0 );
709}
710
711void wxFrame::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y),
712 int width, int height )
713{
714 // due to a bug in gtk, x,y are always 0
715 // m_x = x;
716 // m_y = y;
717
718 /* avoid recursions */
719 if (m_resizing) return;
720 m_resizing = TRUE;
721
722 /* this shouldn't happen: wxFrame, wxMDIParentFrame and wxMDIChildFrame have m_wxwindow */
723 wxASSERT_MSG( (m_wxwindow != NULL), wxT("invalid frame") );
724
725 m_width = width;
726 m_height = height;
727
728 /* space occupied by m_frameToolBar and m_frameMenuBar */
729 int client_area_x_offset = 0,
730 client_area_y_offset = 0;
731
732 /* wxMDIChildFrame derives from wxFrame but it _is_ a wxWindow as it uses
733 wxWindow::Create to create it's GTK equivalent. m_mainWidget is only
734 set in wxFrame::Create so it is used to check what kind of frame we
735 have here. if m_mainWidget is NULL it is a wxMDIChildFrame and so we
736 skip the part which handles m_frameMenuBar, m_frameToolBar and (most
737 importantly) m_mainWidget */
738
739 if ((m_minWidth != -1) && (m_width < m_minWidth)) m_width = m_minWidth;
740 if ((m_minHeight != -1) && (m_height < m_minHeight)) m_height = m_minHeight;
741 if ((m_maxWidth != -1) && (m_width > m_maxWidth)) m_width = m_maxWidth;
742 if ((m_maxHeight != -1) && (m_height > m_maxHeight)) m_height = m_maxHeight;
743
744 if (m_mainWidget)
745 {
746 /* set size hints */
747 gint flag = 0; // GDK_HINT_POS;
748 if ((m_minWidth != -1) || (m_minHeight != -1)) flag |= GDK_HINT_MIN_SIZE;
749 if ((m_maxWidth != -1) || (m_maxHeight != -1)) flag |= GDK_HINT_MAX_SIZE;
750 GdkGeometry geom;
751 geom.min_width = m_minWidth;
752 geom.min_height = m_minHeight;
753 geom.max_width = m_maxWidth;
754 geom.max_height = m_maxHeight;
755 gtk_window_set_geometry_hints( GTK_WINDOW(m_widget),
756 (GtkWidget*) NULL,
757 &geom,
758 (GdkWindowHints) flag );
759
760 /* I revert back to wxGTK's original behaviour. m_mainWidget holds the
761 * menubar, the toolbar and the client area, which is represented by
762 * m_wxwindow.
763 * this hurts in the eye, but I don't want to call SetSize()
764 * because I don't want to call any non-native functions here. */
765
766 if (m_frameMenuBar)
767 {
768 int xx = m_miniEdge;
769 int yy = m_miniEdge + m_miniTitle;
770 int ww = m_width - 2*m_miniEdge;
771 int hh = wxMENU_HEIGHT;
772 if (m_menuBarDetached) hh = wxPLACE_HOLDER;
773 m_frameMenuBar->m_x = xx;
774 m_frameMenuBar->m_y = yy;
775 m_frameMenuBar->m_width = ww;
776 m_frameMenuBar->m_height = hh;
777 gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
778 m_frameMenuBar->m_widget,
779 xx, yy, ww, hh );
780 client_area_y_offset += hh;
781 }
782
783#if wxUSE_TOOLBAR
784 if ((m_frameToolBar) &&
785 (m_frameToolBar->m_widget->parent == m_mainWidget))
786 {
787 int xx = m_miniEdge;
788 int yy = m_miniEdge + m_miniTitle;
789 if (m_frameMenuBar)
790 {
791 if (!m_menuBarDetached)
792 yy += wxMENU_HEIGHT;
793 else
794 yy += wxPLACE_HOLDER;
795 }
796
797 m_frameToolBar->m_x = xx;
798 m_frameToolBar->m_y = yy;
799
800 /* don't change the toolbar's reported height/width */
801 int ww, hh;
802 if ( m_frameToolBar->GetWindowStyle() & wxTB_VERTICAL )
803 {
804 ww = m_toolBarDetached ? wxPLACE_HOLDER
805 : m_frameToolBar->m_width;
806 hh = m_height - 2*m_miniEdge;
807
808 client_area_x_offset += ww;
809 }
810 else
811 {
812 ww = m_width - 2*m_miniEdge;
813 hh = m_toolBarDetached ? wxPLACE_HOLDER
814 : m_frameToolBar->m_height;
815
816 client_area_y_offset += hh;
817 }
818
819 gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
820 m_frameToolBar->m_widget,
821 xx, yy, ww, hh );
822 }
823#endif // wxUSE_TOOLBAR
824
825 int client_x = client_area_x_offset + m_miniEdge;
826 int client_y = client_area_y_offset + m_miniEdge + m_miniTitle;
827 int client_w = m_width - client_area_x_offset - 2*m_miniEdge;
828 int client_h = m_height - client_area_y_offset- 2*m_miniEdge - m_miniTitle;
829 gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
830 m_wxwindow,
831 client_x, client_y, client_w, client_h );
832 }
833 else
834 {
835 /* if there is no m_mainWidget between m_widget and m_wxwindow there
836 is no need to set the size or position of m_wxwindow. */
837 }
838
839#if wxUSE_STATUSBAR
840 if (m_frameStatusBar)
841 {
842 int xx = 0 + m_miniEdge;
843 int yy = m_height - wxSTATUS_HEIGHT - m_miniEdge - client_area_y_offset;
844 int ww = m_width - 2*m_miniEdge;
845 int hh = wxSTATUS_HEIGHT;
846 m_frameStatusBar->m_x = xx;
847 m_frameStatusBar->m_y = yy;
848 m_frameStatusBar->m_width = ww;
849 m_frameStatusBar->m_height = hh;
850 gtk_pizza_set_size( GTK_PIZZA(m_wxwindow),
851 m_frameStatusBar->m_widget,
852 xx, yy, ww, hh );
853 gtk_widget_draw( m_frameStatusBar->m_widget, (GdkRectangle*) NULL );
854 }
855#endif
856
857 m_sizeSet = TRUE;
858
859 // send size event to frame
860 wxSizeEvent event( wxSize(m_width,m_height), GetId() );
861 event.SetEventObject( this );
862 GetEventHandler()->ProcessEvent( event );
863
864 // send size event to status bar
865 if (m_frameStatusBar)
866 {
867 wxSizeEvent event2( wxSize(m_frameStatusBar->m_width,m_frameStatusBar->m_height), m_frameStatusBar->GetId() );
868 event2.SetEventObject( m_frameStatusBar );
869 m_frameStatusBar->GetEventHandler()->ProcessEvent( event2 );
870 }
871
872 m_resizing = FALSE;
873}
874
875void wxFrame::MakeModal( bool modal )
876{
877 if (modal)
878 gtk_grab_add( m_widget );
879 else
880 gtk_grab_remove( m_widget );
881}
882
883void wxFrame::OnInternalIdle()
884{
885 if (!m_sizeSet && GTK_WIDGET_REALIZED(m_wxwindow))
886 {
887 GtkOnSize( m_x, m_y, m_width, m_height );
888
889 // we'll come back later
890 if (g_isIdle)
891 wxapp_install_idle_handler();
892 return;
893 }
894
895 if (m_frameMenuBar) m_frameMenuBar->OnInternalIdle();
896#if wxUSE_TOOLBAR
897 if (m_frameToolBar) m_frameToolBar->OnInternalIdle();
898#endif
899#if wxUSE_STATUSBAR
900 if (m_frameStatusBar) m_frameStatusBar->OnInternalIdle();
901#endif
902
903 wxWindow::OnInternalIdle();
904}
905
906// ----------------------------------------------------------------------------
907// menu/tool/status bar stuff
908// ----------------------------------------------------------------------------
909
910void wxFrame::SetMenuBar( wxMenuBar *menuBar )
911{
912 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
913 wxASSERT_MSG( (m_wxwindow != NULL), wxT("invalid frame") );
914
915 if (menuBar == m_frameMenuBar)
916 return;
917
918 if (m_frameMenuBar)
919 {
920 m_frameMenuBar->UnsetInvokingWindow( this );
921
922 if (m_frameMenuBar->GetWindowStyle() & wxMB_DOCKABLE)
923 {
924 gtk_signal_disconnect_by_func( GTK_OBJECT(m_frameMenuBar->m_widget),
925 GTK_SIGNAL_FUNC(gtk_menu_attached_callback), (gpointer)this );
926
927 gtk_signal_disconnect_by_func( GTK_OBJECT(m_frameMenuBar->m_widget),
928 GTK_SIGNAL_FUNC(gtk_menu_detached_callback), (gpointer)this );
929 }
930
931 gtk_container_remove( GTK_CONTAINER(m_mainWidget), m_frameMenuBar->m_widget );
932 gtk_widget_ref( m_frameMenuBar->m_widget );
933 gtk_widget_unparent( m_frameMenuBar->m_widget );
934 }
935
936 m_frameMenuBar = menuBar;
937
938 if (m_frameMenuBar)
939 {
940 m_frameMenuBar->SetInvokingWindow( this );
941
942 m_frameMenuBar->SetParent(this);
943 gtk_pizza_put( GTK_PIZZA(m_mainWidget),
944 m_frameMenuBar->m_widget,
945 m_frameMenuBar->m_x,
946 m_frameMenuBar->m_y,
947 m_frameMenuBar->m_width,
948 m_frameMenuBar->m_height );
949
950 if (menuBar->GetWindowStyle() & wxMB_DOCKABLE)
951 {
952 gtk_signal_connect( GTK_OBJECT(menuBar->m_widget), "child_attached",
953 GTK_SIGNAL_FUNC(gtk_menu_attached_callback), (gpointer)this );
954
955 gtk_signal_connect( GTK_OBJECT(menuBar->m_widget), "child_detached",
956 GTK_SIGNAL_FUNC(gtk_menu_detached_callback), (gpointer)this );
957 }
958
959 m_frameMenuBar->Show( TRUE );
960 }
961
962 /* resize window in OnInternalIdle */
963 m_sizeSet = FALSE;
964}
965
966#if wxUSE_TOOLBAR
967wxToolBar* wxFrame::CreateToolBar( long style, wxWindowID id, const wxString& name )
968{
969 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
970
971 m_insertInClientArea = FALSE;
972
973 m_frameToolBar = wxFrameBase::CreateToolBar( style, id, name );
974
975 m_insertInClientArea = TRUE;
976
977 m_sizeSet = FALSE;
978
979 return m_frameToolBar;
980}
981
982void wxFrame::SetToolBar(wxToolBar *toolbar)
983{
984 wxFrameBase::SetToolBar(toolbar);
985
986 if (m_frameToolBar)
987 {
988 /* insert into toolbar area if not already there */
989 if ((m_frameToolBar->m_widget->parent) &&
990 (m_frameToolBar->m_widget->parent != m_mainWidget))
991 {
992 GetChildren().DeleteObject( m_frameToolBar );
993
994 gtk_widget_reparent( m_frameToolBar->m_widget, m_mainWidget );
995 GtkUpdateSize();
996 }
997 }
998}
999
1000#endif // wxUSE_TOOLBAR
1001
1002#if wxUSE_STATUSBAR
1003
1004wxStatusBar* wxFrame::CreateStatusBar(int number,
1005 long style,
1006 wxWindowID id,
1007 const wxString& name)
1008{
1009 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
1010
1011 // because it will change when toolbar is added
1012 m_sizeSet = FALSE;
1013
1014 return wxFrameBase::CreateStatusBar( number, style, id, name );
1015}
1016
1017void wxFrame::PositionStatusBar()
1018{
1019 if ( !m_frameStatusBar )
1020 return;
1021
1022 m_sizeSet = FALSE;
1023}
1024#endif // wxUSE_STATUSBAR
1025
1026// ----------------------------------------------------------------------------
1027// frame title/icon
1028// ----------------------------------------------------------------------------
1029
1030void wxFrame::SetTitle( const wxString &title )
1031{
1032 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
1033
1034 m_title = title;
1035 gtk_window_set_title( GTK_WINDOW(m_widget), title.mbc_str() );
1036}
1037
1038void wxFrame::SetIcon( const wxIcon &icon )
1039{
1040 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
1041
1042 wxFrameBase::SetIcon(icon);
1043
1044 if ( !m_icon.Ok() )
1045 return;
1046
1047 if (!m_widget->window)
1048 return;
1049
1050 wxMask *mask = icon.GetMask();
1051 GdkBitmap *bm = (GdkBitmap *) NULL;
1052 if (mask) bm = mask->GetBitmap();
1053
1054 gdk_window_set_icon( m_widget->window, (GdkWindow *) NULL, icon.GetPixmap(), bm );
1055}
1056
1057// ----------------------------------------------------------------------------
1058// frame state: maximized/iconized/normal (TODO)
1059// ----------------------------------------------------------------------------
1060
1061void wxFrame::Maximize(bool WXUNUSED(maximize))
1062{
1063}
1064
1065bool wxFrame::IsMaximized() const
1066{
1067 return FALSE;
1068}
1069
1070void wxFrame::Restore()
1071{
1072}
1073
1074void wxFrame::Iconize( bool iconize )
1075{
1076 if (iconize)
1077 {
1078 XIconifyWindow( GDK_WINDOW_XDISPLAY( m_widget->window ),
1079 GDK_WINDOW_XWINDOW( m_widget->window ),
1080 DefaultScreen( GDK_DISPLAY() ) );
1081 }
1082}
1083
1084bool wxFrame::IsIconized() const
1085{
1086 return FALSE;
1087}