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