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


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