]> git.saurik.com Git - wxWidgets.git/blob - src/gtk1/frame.cpp
remove unfinished impl
[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 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
19 #pragma implementation "frame.h"
20 #endif
21
22 // For compilers that support precompilation, includes "wx.h".
23 #include "wx/wxprec.h"
24
25 #include "wx/defs.h"
26
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 "wx/gtk/private.h"
41
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 wxSTATUS_HEIGHT = 25;
52 const int wxPLACE_HOLDER = 0;
53
54 // ----------------------------------------------------------------------------
55 // idle system
56 // ----------------------------------------------------------------------------
57
58 extern void wxapp_install_idle_handler();
59 extern bool g_isIdle;
60 extern int g_openDialogs;
61
62 // ----------------------------------------------------------------------------
63 // event tables
64 // ----------------------------------------------------------------------------
65
66 IMPLEMENT_DYNAMIC_CLASS(wxFrame, wxTopLevelWindow)
67
68 // ============================================================================
69 // implementation
70 // ============================================================================
71
72 // ----------------------------------------------------------------------------
73 // GTK callbacks
74 // ----------------------------------------------------------------------------
75
76 #if wxUSE_MENUS_NATIVE
77
78 //-----------------------------------------------------------------------------
79 // "child_attached" of menu bar
80 //-----------------------------------------------------------------------------
81
82 static void gtk_menu_attached_callback( GtkWidget *WXUNUSED(widget), GtkWidget *WXUNUSED(child), wxFrame *win )
83 {
84 if (!win->m_hasVMT) return;
85
86 win->m_menuBarDetached = FALSE;
87 win->GtkUpdateSize();
88 }
89
90 //-----------------------------------------------------------------------------
91 // "child_detached" of menu bar
92 //-----------------------------------------------------------------------------
93
94 static void gtk_menu_detached_callback( GtkWidget *WXUNUSED(widget), GtkWidget *WXUNUSED(child), wxFrame *win )
95 {
96 if (g_isIdle)
97 wxapp_install_idle_handler();
98
99 if (!win->m_hasVMT) return;
100
101 // Raise the client area area
102 gdk_window_raise( win->m_wxwindow->window );
103
104 win->m_menuBarDetached = TRUE;
105 win->GtkUpdateSize();
106 }
107
108 #endif // wxUSE_MENUS_NATIVE
109
110 #if wxUSE_TOOLBAR
111 //-----------------------------------------------------------------------------
112 // "child_attached" of tool bar
113 //-----------------------------------------------------------------------------
114
115 static void gtk_toolbar_attached_callback( GtkWidget *WXUNUSED(widget), GtkWidget *WXUNUSED(child), wxFrame *win )
116 {
117 if (!win->m_hasVMT) return;
118
119 win->m_toolBarDetached = FALSE;
120 win->GtkUpdateSize();
121 }
122
123 //-----------------------------------------------------------------------------
124 // "child_detached" of tool bar
125 //-----------------------------------------------------------------------------
126
127 static void gtk_toolbar_detached_callback( GtkWidget *WXUNUSED(widget), GtkWidget *WXUNUSED(child), wxFrame *win )
128 {
129 if (g_isIdle)
130 wxapp_install_idle_handler();
131
132 if (!win->m_hasVMT) return;
133
134 // Raise the client area area
135 gdk_window_raise( win->m_wxwindow->window );
136
137 win->m_toolBarDetached = TRUE;
138 win->GtkUpdateSize();
139 }
140 #endif // wxUSE_TOOLBAR
141
142
143 // ----------------------------------------------------------------------------
144 // wxFrame itself
145 // ----------------------------------------------------------------------------
146
147 //-----------------------------------------------------------------------------
148 // InsertChild for wxFrame
149 //-----------------------------------------------------------------------------
150
151 /* Callback for wxFrame. This very strange beast has to be used because
152 * C++ has no virtual methods in a constructor. We have to emulate a
153 * virtual function here as wxWidgets requires different ways to insert
154 * a child in container classes. */
155
156 static void wxInsertChildInFrame( wxFrame* parent, wxWindow* child )
157 {
158 wxASSERT( GTK_IS_WIDGET(child->m_widget) );
159
160 if (!parent->m_insertInClientArea)
161 {
162 // These are outside the client area
163 wxFrame* frame = (wxFrame*) parent;
164 gtk_pizza_put( GTK_PIZZA(frame->m_mainWidget),
165 GTK_WIDGET(child->m_widget),
166 child->m_x,
167 child->m_y,
168 child->m_width,
169 child->m_height );
170
171 #if wxUSE_TOOLBAR_NATIVE
172 // We connect to these events for recalculating the client area
173 // space when the toolbar is floating
174 if (wxIS_KIND_OF(child,wxToolBar))
175 {
176 wxToolBar *toolBar = (wxToolBar*) child;
177 if (toolBar->GetWindowStyle() & wxTB_DOCKABLE)
178 {
179 gtk_signal_connect( GTK_OBJECT(toolBar->m_widget), "child_attached",
180 GTK_SIGNAL_FUNC(gtk_toolbar_attached_callback), (gpointer)parent );
181
182 gtk_signal_connect( GTK_OBJECT(toolBar->m_widget), "child_detached",
183 GTK_SIGNAL_FUNC(gtk_toolbar_detached_callback), (gpointer)parent );
184 }
185 }
186 #endif // wxUSE_TOOLBAR
187 }
188 else
189 {
190 // These are inside the client area
191 gtk_pizza_put( GTK_PIZZA(parent->m_wxwindow),
192 GTK_WIDGET(child->m_widget),
193 child->m_x,
194 child->m_y,
195 child->m_width,
196 child->m_height );
197 }
198
199 // Resize on OnInternalIdle
200 parent->GtkUpdateSize();
201 }
202
203 // ----------------------------------------------------------------------------
204 // wxFrame creation
205 // ----------------------------------------------------------------------------
206
207 void wxFrame::Init()
208 {
209 m_menuBarDetached = FALSE;
210 m_toolBarDetached = FALSE;
211 m_menuBarHeight = 2;
212 }
213
214 bool wxFrame::Create( wxWindow *parent,
215 wxWindowID id,
216 const wxString& title,
217 const wxPoint& pos,
218 const wxSize& sizeOrig,
219 long style,
220 const wxString &name )
221 {
222 bool rt = wxTopLevelWindow::Create(parent, id, title, pos, sizeOrig,
223 style, name);
224 m_insertCallback = (wxInsertChildFunction) wxInsertChildInFrame;
225
226 return rt;
227 }
228
229 wxFrame::~wxFrame()
230 {
231 m_isBeingDeleted = TRUE;
232 DeleteAllBars();
233 }
234
235 // ----------------------------------------------------------------------------
236 // overridden wxWindow methods
237 // ----------------------------------------------------------------------------
238
239 void wxFrame::DoGetClientSize( int *width, int *height ) const
240 {
241 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
242
243 wxTopLevelWindow::DoGetClientSize( width, height );
244
245 if (height)
246 {
247 #if wxUSE_MENUS_NATIVE
248 // menu bar
249 if (m_frameMenuBar)
250 {
251 if (!m_menuBarDetached)
252 (*height) -= m_menuBarHeight;
253 else
254 (*height) -= wxPLACE_HOLDER;
255 }
256 #endif // wxUSE_MENUS_NATIVE
257
258 #if wxUSE_STATUSBAR
259 // status bar
260 if (m_frameStatusBar && m_frameStatusBar->IsShown())
261 (*height) -= wxSTATUS_HEIGHT;
262 #endif // wxUSE_STATUSBAR
263
264 #if wxUSE_TOOLBAR
265 // tool bar
266 if (m_frameToolBar && m_frameToolBar->IsShown())
267 {
268 if (m_toolBarDetached)
269 {
270 *height -= wxPLACE_HOLDER;
271 }
272 else
273 {
274 int x, y;
275 m_frameToolBar->GetSize( &x, &y );
276 if ( m_frameToolBar->GetWindowStyle() & wxTB_VERTICAL )
277 {
278 *width -= x;
279 }
280 else
281 {
282 *height -= y;
283 }
284 }
285 }
286 #endif // wxUSE_TOOLBAR
287 }
288 }
289
290 void wxFrame::DoSetClientSize( int width, int height )
291 {
292 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
293
294 #if wxUSE_MENUS_NATIVE
295 // menu bar
296 if (m_frameMenuBar)
297 {
298 if (!m_menuBarDetached)
299 height += m_menuBarHeight;
300 else
301 height += wxPLACE_HOLDER;
302 }
303 #endif // wxUSE_MENUS_NATIVE
304
305 #if wxUSE_STATUSBAR
306 // status bar
307 if (m_frameStatusBar && m_frameStatusBar->IsShown()) height += wxSTATUS_HEIGHT;
308 #endif
309
310 #if wxUSE_TOOLBAR
311 // tool bar
312 if (m_frameToolBar && m_frameToolBar->IsShown())
313 {
314 if (m_toolBarDetached)
315 {
316 height += wxPLACE_HOLDER;
317 }
318 else
319 {
320 int x, y;
321 m_frameToolBar->GetSize( &x, &y );
322 if ( m_frameToolBar->GetWindowStyle() & wxTB_VERTICAL )
323 {
324 width += x;
325 }
326 else
327 {
328 height += y;
329 }
330 }
331 }
332 #endif
333
334 wxTopLevelWindow::DoSetClientSize( width, height );
335 }
336
337 void wxFrame::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y),
338 int width, int height )
339 {
340 // due to a bug in gtk, x,y are always 0
341 // m_x = x;
342 // m_y = y;
343
344 // avoid recursions
345 if (m_resizing) return;
346 m_resizing = TRUE;
347
348 // this shouldn't happen: wxFrame, wxMDIParentFrame and wxMDIChildFrame have m_wxwindow
349 wxASSERT_MSG( (m_wxwindow != NULL), wxT("invalid frame") );
350
351 m_width = width;
352 m_height = height;
353
354 // space occupied by m_frameToolBar and m_frameMenuBar
355 int client_area_x_offset = 0,
356 client_area_y_offset = 0;
357
358 /* wxMDIChildFrame derives from wxFrame but it _is_ a wxWindow as it uses
359 wxWindow::Create to create it's GTK equivalent. m_mainWidget is only
360 set in wxFrame::Create so it is used to check what kind of frame we
361 have here. if m_mainWidget is NULL it is a wxMDIChildFrame and so we
362 skip the part which handles m_frameMenuBar, m_frameToolBar and (most
363 importantly) m_mainWidget */
364
365 int minWidth = GetMinWidth(),
366 minHeight = GetMinHeight(),
367 maxWidth = GetMaxWidth(),
368 maxHeight = GetMaxHeight();
369
370 if ((minWidth != -1) && (m_width < minWidth)) m_width = minWidth;
371 if ((minHeight != -1) && (m_height < minHeight)) m_height = minHeight;
372 if ((maxWidth != -1) && (m_width > maxWidth)) m_width = maxWidth;
373 if ((maxHeight != -1) && (m_height > maxHeight)) m_height = maxHeight;
374
375 if (m_mainWidget)
376 {
377 // set size hints
378 gint flag = 0; // GDK_HINT_POS;
379 if ((minWidth != -1) || (minHeight != -1)) flag |= GDK_HINT_MIN_SIZE;
380 if ((maxWidth != -1) || (maxHeight != -1)) flag |= GDK_HINT_MAX_SIZE;
381 GdkGeometry geom;
382 geom.min_width = minWidth;
383 geom.min_height = minHeight;
384 geom.max_width = maxWidth;
385 geom.max_height = maxHeight;
386 gtk_window_set_geometry_hints( GTK_WINDOW(m_widget),
387 (GtkWidget*) NULL,
388 &geom,
389 (GdkWindowHints) flag );
390
391 // I revert back to wxGTK's original behaviour. m_mainWidget holds
392 // the menubar, the toolbar and the client area, which is represented
393 // by m_wxwindow.
394 // This hurts in the eye, but I don't want to call SetSize()
395 // because I don't want to call any non-native functions here.
396
397 #if wxUSE_MENUS_NATIVE
398 if (m_frameMenuBar)
399 {
400 int xx = m_miniEdge;
401 int yy = m_miniEdge + m_miniTitle;
402 int ww = m_width - 2*m_miniEdge;
403 int hh = m_menuBarHeight;
404 if (m_menuBarDetached) hh = wxPLACE_HOLDER;
405 m_frameMenuBar->m_x = xx;
406 m_frameMenuBar->m_y = yy;
407 m_frameMenuBar->m_width = ww;
408 m_frameMenuBar->m_height = hh;
409 gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
410 m_frameMenuBar->m_widget,
411 xx, yy, ww, hh );
412 client_area_y_offset += hh;
413 }
414 #endif // wxUSE_MENUS_NATIVE
415
416 #if wxUSE_TOOLBAR
417 if ((m_frameToolBar) && m_frameToolBar->IsShown() &&
418 (m_frameToolBar->m_widget->parent == m_mainWidget))
419 {
420 int xx = m_miniEdge;
421 int yy = m_miniEdge + m_miniTitle;
422 #if wxUSE_MENUS_NATIVE
423 if (m_frameMenuBar)
424 {
425 if (!m_menuBarDetached)
426 yy += m_menuBarHeight;
427 else
428 yy += wxPLACE_HOLDER;
429 }
430 #endif // wxUSE_MENUS_NATIVE
431
432 m_frameToolBar->m_x = xx;
433 m_frameToolBar->m_y = yy;
434
435 // don't change the toolbar's reported height/width
436 int ww, hh;
437 if ( m_frameToolBar->GetWindowStyle() & wxTB_VERTICAL )
438 {
439 ww = m_toolBarDetached ? wxPLACE_HOLDER
440 : m_frameToolBar->m_width;
441 hh = m_height - 2*m_miniEdge;
442
443 client_area_x_offset += ww;
444 }
445 else
446 {
447 ww = m_width - 2*m_miniEdge;
448 hh = m_toolBarDetached ? wxPLACE_HOLDER
449 : m_frameToolBar->m_height;
450
451 client_area_y_offset += hh;
452 }
453
454 gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
455 m_frameToolBar->m_widget,
456 xx, yy, ww, hh );
457 }
458 #endif // wxUSE_TOOLBAR
459
460 int client_x = client_area_x_offset + m_miniEdge;
461 int client_y = client_area_y_offset + m_miniEdge + m_miniTitle;
462 int client_w = m_width - client_area_x_offset - 2*m_miniEdge;
463 int client_h = m_height - client_area_y_offset- 2*m_miniEdge - m_miniTitle;
464 gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
465 m_wxwindow,
466 client_x, client_y, client_w, client_h );
467 }
468 else
469 {
470 // If there is no m_mainWidget between m_widget and m_wxwindow there
471 // is no need to set the size or position of m_wxwindow.
472 }
473
474 #if wxUSE_STATUSBAR
475 if (m_frameStatusBar && m_frameStatusBar->IsShown())
476 {
477 int xx = 0 + m_miniEdge;
478 int yy = m_height - wxSTATUS_HEIGHT - m_miniEdge - client_area_y_offset;
479 int ww = m_width - 2*m_miniEdge;
480 int hh = wxSTATUS_HEIGHT;
481 m_frameStatusBar->m_x = xx;
482 m_frameStatusBar->m_y = yy;
483 m_frameStatusBar->m_width = ww;
484 m_frameStatusBar->m_height = hh;
485 gtk_pizza_set_size( GTK_PIZZA(m_wxwindow),
486 m_frameStatusBar->m_widget,
487 xx, yy, ww, hh );
488 gtk_widget_draw( m_frameStatusBar->m_widget, (GdkRectangle*) NULL );
489 }
490 #endif // wxUSE_STATUSBAR
491
492 m_sizeSet = TRUE;
493
494 // send size event to frame
495 wxSizeEvent event( wxSize(m_width,m_height), GetId() );
496 event.SetEventObject( this );
497 GetEventHandler()->ProcessEvent( event );
498
499 #if wxUSE_STATUSBAR
500 // send size event to status bar
501 if (m_frameStatusBar)
502 {
503 wxSizeEvent event2( wxSize(m_frameStatusBar->m_width,m_frameStatusBar->m_height), m_frameStatusBar->GetId() );
504 event2.SetEventObject( m_frameStatusBar );
505 m_frameStatusBar->GetEventHandler()->ProcessEvent( event2 );
506 }
507 #endif // wxUSE_STATUSBAR
508
509 m_resizing = FALSE;
510 }
511
512 void wxFrame::OnInternalIdle()
513 {
514 wxFrameBase::OnInternalIdle();
515
516 #if wxUSE_MENUS_NATIVE
517 if (m_frameMenuBar) m_frameMenuBar->OnInternalIdle();
518 #endif // wxUSE_MENUS_NATIVE
519 #if wxUSE_TOOLBAR
520 if (m_frameToolBar) m_frameToolBar->OnInternalIdle();
521 #endif
522 #if wxUSE_STATUSBAR
523 if (m_frameStatusBar)
524 {
525 m_frameStatusBar->OnInternalIdle();
526
527 // There may be controls in the status bar that
528 // need to be updated
529 for ( wxWindowList::compatibility_iterator node = m_frameStatusBar->GetChildren().GetFirst();
530 node;
531 node = node->GetNext() )
532 {
533 wxWindow *child = node->GetData();
534 child->OnInternalIdle();
535 }
536 }
537 #endif
538 }
539
540 // ----------------------------------------------------------------------------
541 // menu/tool/status bar stuff
542 // ----------------------------------------------------------------------------
543
544 #if wxUSE_MENUS_NATIVE
545
546 void wxFrame::DetachMenuBar()
547 {
548 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
549 wxASSERT_MSG( (m_wxwindow != NULL), wxT("invalid frame") );
550
551 if ( m_frameMenuBar )
552 {
553 m_frameMenuBar->UnsetInvokingWindow( this );
554
555 if (m_frameMenuBar->GetWindowStyle() & wxMB_DOCKABLE)
556 {
557 gtk_signal_disconnect_by_func( GTK_OBJECT(m_frameMenuBar->m_widget),
558 GTK_SIGNAL_FUNC(gtk_menu_attached_callback), (gpointer)this );
559
560 gtk_signal_disconnect_by_func( GTK_OBJECT(m_frameMenuBar->m_widget),
561 GTK_SIGNAL_FUNC(gtk_menu_detached_callback), (gpointer)this );
562 }
563
564 gtk_widget_ref( m_frameMenuBar->m_widget );
565
566 gtk_container_remove( GTK_CONTAINER(m_mainWidget), m_frameMenuBar->m_widget );
567 }
568
569 wxFrameBase::DetachMenuBar();
570 }
571
572 void wxFrame::AttachMenuBar( wxMenuBar *menuBar )
573 {
574 wxFrameBase::AttachMenuBar(menuBar);
575
576 if (m_frameMenuBar)
577 {
578 m_frameMenuBar->SetInvokingWindow( this );
579
580 m_frameMenuBar->SetParent(this);
581 gtk_pizza_put( GTK_PIZZA(m_mainWidget),
582 m_frameMenuBar->m_widget,
583 m_frameMenuBar->m_x,
584 m_frameMenuBar->m_y,
585 m_frameMenuBar->m_width,
586 m_frameMenuBar->m_height );
587
588 if (menuBar->GetWindowStyle() & wxMB_DOCKABLE)
589 {
590 gtk_signal_connect( GTK_OBJECT(menuBar->m_widget), "child_attached",
591 GTK_SIGNAL_FUNC(gtk_menu_attached_callback), (gpointer)this );
592
593 gtk_signal_connect( GTK_OBJECT(menuBar->m_widget), "child_detached",
594 GTK_SIGNAL_FUNC(gtk_menu_detached_callback), (gpointer)this );
595 }
596
597 gtk_widget_show( m_frameMenuBar->m_widget );
598
599 UpdateMenuBarSize();
600 }
601 else
602 {
603 m_menuBarHeight = 2;
604 GtkUpdateSize(); // resize window in OnInternalIdle
605 }
606 }
607
608 void wxFrame::UpdateMenuBarSize()
609 {
610 GtkRequisition req;
611
612 req.width = 2;
613 req.height = 2;
614
615 // this is called after Remove with a NULL m_frameMenuBar
616 if ( m_frameMenuBar )
617 (* GTK_WIDGET_CLASS( GTK_OBJECT_GET_CLASS(m_frameMenuBar->m_widget) )->size_request )
618 (m_frameMenuBar->m_widget, &req );
619
620 m_menuBarHeight = req.height;
621
622 // resize window in OnInternalIdle
623
624 GtkUpdateSize();
625 }
626
627 #endif // wxUSE_MENUS_NATIVE
628
629 #if wxUSE_TOOLBAR
630
631 wxToolBar* wxFrame::CreateToolBar( long style, wxWindowID id, const wxString& name )
632 {
633 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
634
635 m_insertInClientArea = FALSE;
636
637 m_frameToolBar = wxFrameBase::CreateToolBar( style, id, name );
638
639 m_insertInClientArea = TRUE;
640
641 GtkUpdateSize();
642
643 return m_frameToolBar;
644 }
645
646 void wxFrame::SetToolBar(wxToolBar *toolbar)
647 {
648 bool hadTbar = m_frameToolBar != NULL;
649
650 wxFrameBase::SetToolBar(toolbar);
651
652 if ( m_frameToolBar )
653 {
654 // insert into toolbar area if not already there
655 if ((m_frameToolBar->m_widget->parent) &&
656 (m_frameToolBar->m_widget->parent != m_mainWidget))
657 {
658 GetChildren().DeleteObject( m_frameToolBar );
659
660 gtk_widget_reparent( m_frameToolBar->m_widget, m_mainWidget );
661 GtkUpdateSize();
662 }
663 }
664 else // toolbar unset
665 {
666 // still need to update size if it had been there before
667 if ( hadTbar )
668 {
669 GtkUpdateSize();
670 }
671 }
672 }
673
674 #endif // wxUSE_TOOLBAR
675
676 #if wxUSE_STATUSBAR
677
678 wxStatusBar* wxFrame::CreateStatusBar(int number,
679 long style,
680 wxWindowID id,
681 const wxString& name)
682 {
683 wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") );
684
685 // because it will change when toolbar is added
686 GtkUpdateSize();
687
688 return wxFrameBase::CreateStatusBar( number, style, id, name );
689 }
690
691 void wxFrame::SetStatusBar(wxStatusBar *statbar)
692 {
693 bool hadStatBar = m_frameStatusBar != NULL;
694
695 wxFrameBase::SetStatusBar(statbar);
696
697 if (hadStatBar && !m_frameStatusBar)
698 GtkUpdateSize();
699 }
700
701 void wxFrame::PositionStatusBar()
702 {
703 if ( !m_frameStatusBar )
704 return;
705
706 GtkUpdateSize();
707 }
708 #endif // wxUSE_STATUSBAR
709