]> git.saurik.com Git - wxWidgets.git/blob - src/gtk/mdi.cpp
corrected off by 1 error in cMB2WC() call (thanks valgrind)
[wxWidgets.git] / src / gtk / mdi.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/gtk/mdi.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 #if wxUSE_MDI
14
15 #include "wx/mdi.h"
16
17 #ifndef WX_PRECOMP
18 #include "wx/intl.h"
19 #include "wx/menu.h"
20 #include "wx/dialog.h"
21 #endif
22
23 #include "wx/notebook.h"
24 #include "wx/gtk/private.h"
25
26 #include <gtk/gtk.h>
27 #include "wx/gtk/win_gtk.h"
28
29 //-----------------------------------------------------------------------------
30 // constants
31 //-----------------------------------------------------------------------------
32
33 const int wxMENU_HEIGHT = 27;
34
35 //-----------------------------------------------------------------------------
36 // globals
37 //-----------------------------------------------------------------------------
38
39 //-----------------------------------------------------------------------------
40 // "switch_page"
41 //-----------------------------------------------------------------------------
42
43 extern "C" {
44 static void
45 gtk_mdi_page_change_callback( GtkNotebook *WXUNUSED(widget),
46 GtkNotebookPage *page,
47 gint WXUNUSED(page_num),
48 wxMDIParentFrame *parent )
49 {
50 // send deactivate event to old child
51
52 wxMDIChildFrame *child = parent->GetActiveChild();
53 if (child)
54 {
55 wxActivateEvent event1( wxEVT_ACTIVATE, false, child->GetId() );
56 event1.SetEventObject( child);
57 child->GetEventHandler()->ProcessEvent( event1 );
58 }
59
60 // send activate event to new child
61
62 wxMDIClientWindow *client_window = parent->GetClientWindow();
63 if (!client_window)
64 return;
65
66 child = (wxMDIChildFrame*) NULL;
67
68 wxWindowList::compatibility_iterator node = client_window->GetChildren().GetFirst();
69 while ( node )
70 {
71 wxMDIChildFrame *child_frame = wxDynamicCast( node->GetData(), wxMDIChildFrame );
72
73 // child_frame can be NULL when this is called from dtor, probably
74 // because g_signal_connect (m_widget, "switch_page", (see below)
75 // isn't deleted early enough
76 if ( child_frame && child_frame->m_page == page )
77 {
78 child = child_frame;
79 break;
80 }
81 node = node->GetNext();
82 }
83
84 if (!child)
85 return;
86
87 wxActivateEvent event2( wxEVT_ACTIVATE, true, child->GetId() );
88 event2.SetEventObject( child);
89 child->GetEventHandler()->ProcessEvent( event2 );
90 }
91 }
92
93 //-----------------------------------------------------------------------------
94 // wxMDIParentFrame
95 //-----------------------------------------------------------------------------
96
97 IMPLEMENT_DYNAMIC_CLASS(wxMDIParentFrame,wxFrame)
98
99 void wxMDIParentFrame::Init()
100 {
101 m_justInserted = false;
102 m_clientWindow = (wxMDIClientWindow *) NULL;
103 }
104
105 wxMDIParentFrame::~wxMDIParentFrame()
106 {
107 }
108
109 bool wxMDIParentFrame::Create(wxWindow *parent,
110 wxWindowID id,
111 const wxString& title,
112 const wxPoint& pos,
113 const wxSize& size,
114 long style,
115 const wxString& name )
116 {
117 wxFrame::Create( parent, id, title, pos, size, style, name );
118
119 OnCreateClient();
120
121 return true;
122 }
123
124 void wxMDIParentFrame::GtkOnSize()
125 {
126 wxFrame::GtkOnSize();
127
128 wxMDIChildFrame *child_frame = GetActiveChild();
129 if (!child_frame) return;
130
131 wxMenuBar *menu_bar = child_frame->m_menuBar;
132 if (!menu_bar) return;
133 if (!menu_bar->m_widget) return;
134
135 menu_bar->m_x = 0;
136 menu_bar->m_y = 0;
137 menu_bar->m_width = m_width;
138 menu_bar->m_height = wxMENU_HEIGHT;
139 gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
140 menu_bar->m_widget,
141 0, 0, m_width, wxMENU_HEIGHT );
142 }
143
144 void wxMDIParentFrame::OnInternalIdle()
145 {
146 /* if a an MDI child window has just been inserted
147 it has to be brought to the top in idle time. we
148 simply set the last notebook page active as new
149 pages can only be appended at the end */
150
151 if (m_justInserted)
152 {
153 GtkNotebook *notebook = GTK_NOTEBOOK(m_clientWindow->m_widget);
154 gtk_notebook_set_current_page( notebook, g_list_length( notebook->children ) - 1 );
155
156 /* need to set the menubar of the child */
157 wxMDIChildFrame *active_child_frame = GetActiveChild();
158 if (active_child_frame != NULL)
159 {
160 wxMenuBar *menu_bar = active_child_frame->m_menuBar;
161 if (menu_bar)
162 {
163 menu_bar->m_width = m_width;
164 menu_bar->m_height = wxMENU_HEIGHT;
165 gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
166 menu_bar->m_widget,
167 0, 0, m_width, wxMENU_HEIGHT );
168 menu_bar->SetInvokingWindow(active_child_frame);
169 }
170 }
171 m_justInserted = false;
172 return;
173 }
174
175 wxFrame::OnInternalIdle();
176
177 wxMDIChildFrame *active_child_frame = GetActiveChild();
178 bool visible_child_menu = false;
179
180 wxWindowList::compatibility_iterator node = m_clientWindow->GetChildren().GetFirst();
181 while (node)
182 {
183 wxMDIChildFrame *child_frame = wxDynamicCast( node->GetData(), wxMDIChildFrame );
184
185 if ( child_frame )
186 {
187 wxMenuBar *menu_bar = child_frame->m_menuBar;
188 if ( menu_bar )
189 {
190 if (child_frame == active_child_frame)
191 {
192 if (menu_bar->Show(true))
193 {
194 menu_bar->m_width = m_width;
195 menu_bar->m_height = wxMENU_HEIGHT;
196 gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
197 menu_bar->m_widget,
198 0, 0, m_width, wxMENU_HEIGHT );
199 menu_bar->SetInvokingWindow( child_frame );
200 }
201 visible_child_menu = true;
202 }
203 else
204 {
205 if (menu_bar->Show(false))
206 {
207 menu_bar->UnsetInvokingWindow( child_frame );
208 }
209 }
210 }
211 }
212
213 node = node->GetNext();
214 }
215
216 /* show/hide parent menu bar as required */
217 if ((m_frameMenuBar) &&
218 (m_frameMenuBar->IsShown() == visible_child_menu))
219 {
220 if (visible_child_menu)
221 {
222 m_frameMenuBar->Show( false );
223 m_frameMenuBar->UnsetInvokingWindow( this );
224 }
225 else
226 {
227 m_frameMenuBar->Show( true );
228 m_frameMenuBar->SetInvokingWindow( this );
229
230 m_frameMenuBar->m_width = m_width;
231 m_frameMenuBar->m_height = wxMENU_HEIGHT;
232 gtk_pizza_set_size( GTK_PIZZA(m_mainWidget),
233 m_frameMenuBar->m_widget,
234 0, 0, m_width, wxMENU_HEIGHT );
235 }
236 }
237 }
238
239 wxMDIChildFrame *wxMDIParentFrame::GetActiveChild() const
240 {
241 if (!m_clientWindow) return (wxMDIChildFrame*) NULL;
242
243 GtkNotebook *notebook = GTK_NOTEBOOK(m_clientWindow->m_widget);
244 if (!notebook) return (wxMDIChildFrame*) NULL;
245
246 gint i = gtk_notebook_get_current_page( notebook );
247 if (i < 0) return (wxMDIChildFrame*) NULL;
248
249 GtkNotebookPage* page = (GtkNotebookPage*) (g_list_nth(notebook->children,i)->data);
250 if (!page) return (wxMDIChildFrame*) NULL;
251
252 wxWindowList::compatibility_iterator node = m_clientWindow->GetChildren().GetFirst();
253 while (node)
254 {
255 if ( wxPendingDelete.Member(node->GetData()) )
256 return (wxMDIChildFrame*) NULL;
257
258 wxMDIChildFrame *child_frame = wxDynamicCast( node->GetData(), wxMDIChildFrame );
259
260 if (!child_frame)
261 return (wxMDIChildFrame*) NULL;
262
263 if (child_frame->m_page == page)
264 return child_frame;
265
266 node = node->GetNext();
267 }
268
269 return (wxMDIChildFrame*) NULL;
270 }
271
272 wxMDIClientWindow *wxMDIParentFrame::GetClientWindow() const
273 {
274 return m_clientWindow;
275 }
276
277 wxMDIClientWindow *wxMDIParentFrame::OnCreateClient()
278 {
279 m_clientWindow = new wxMDIClientWindow( this );
280 return m_clientWindow;
281 }
282
283 void wxMDIParentFrame::ActivateNext()
284 {
285 if (m_clientWindow)
286 gtk_notebook_next_page( GTK_NOTEBOOK(m_clientWindow->m_widget) );
287 }
288
289 void wxMDIParentFrame::ActivatePrevious()
290 {
291 if (m_clientWindow)
292 gtk_notebook_prev_page( GTK_NOTEBOOK(m_clientWindow->m_widget) );
293 }
294
295 bool wxMDIParentFrame::HasVisibleMenubar() const
296 {
297 if (wxFrame::HasVisibleMenubar())
298 return true;
299
300 wxMDIChildFrame* active_child_frame = GetActiveChild();
301 wxMenuBar* menubar = NULL;
302 if (active_child_frame)
303 menubar = active_child_frame->m_menuBar;
304 return menubar && menubar->IsShown();
305 }
306
307 //-----------------------------------------------------------------------------
308 // wxMDIChildFrame
309 //-----------------------------------------------------------------------------
310
311 IMPLEMENT_DYNAMIC_CLASS(wxMDIChildFrame,wxFrame)
312
313 BEGIN_EVENT_TABLE(wxMDIChildFrame, wxFrame)
314 EVT_ACTIVATE(wxMDIChildFrame::OnActivate)
315 EVT_MENU_HIGHLIGHT_ALL(wxMDIChildFrame::OnMenuHighlight)
316 END_EVENT_TABLE()
317
318 wxMDIChildFrame::wxMDIChildFrame()
319 {
320 m_menuBar = (wxMenuBar *) NULL;
321 m_page = (GtkNotebookPage *) NULL;
322 }
323
324 wxMDIChildFrame::wxMDIChildFrame( wxMDIParentFrame *parent,
325 wxWindowID id, const wxString& title,
326 const wxPoint& WXUNUSED(pos), const wxSize& size,
327 long style, const wxString& name )
328 {
329 m_menuBar = (wxMenuBar *) NULL;
330 m_page = (GtkNotebookPage *) NULL;
331 Create( parent, id, title, wxDefaultPosition, size, style, name );
332 }
333
334 wxMDIChildFrame::~wxMDIChildFrame()
335 {
336 if (m_menuBar)
337 delete m_menuBar;
338 }
339
340 bool wxMDIChildFrame::Create( wxMDIParentFrame *parent,
341 wxWindowID id, const wxString& title,
342 const wxPoint& WXUNUSED(pos), const wxSize& size,
343 long style, const wxString& name )
344 {
345 m_title = title;
346
347 return wxWindow::Create( parent->GetClientWindow(), id, wxDefaultPosition, size, style, name );
348 }
349
350 bool wxMDIChildFrame::Destroy()
351 {
352 // delayed destruction: the frame will be deleted during
353 // the next idle loop iteration.
354 // I'm not sure if delayed destruction really makes so
355 // much sense for MDI child frames, actually, but hiding
356 // it doesn't make any sense.
357 if ( !wxPendingDelete.Member(this) )
358 wxPendingDelete.Append(this);
359
360 return true;
361 }
362
363 void wxMDIChildFrame::DoSetSize( int x, int y, int width, int height, int sizeFlags )
364 {
365 wxWindow::DoSetSize( x, y, width, height, sizeFlags );
366 }
367
368 void wxMDIChildFrame::AddChild( wxWindowBase *child )
369 {
370 wxWindow::AddChild(child);
371 }
372
373 void wxMDIChildFrame::SetMenuBar( wxMenuBar *menu_bar )
374 {
375 wxASSERT_MSG( m_menuBar == NULL, wxT("Only one menubar allowed") );
376
377 m_menuBar = menu_bar;
378
379 if (m_menuBar)
380 {
381 wxMDIParentFrame *mdi_frame = (wxMDIParentFrame*)m_parent->GetParent();
382
383 m_menuBar->SetParent( mdi_frame );
384
385 /* insert the invisible menu bar into the _parent_ mdi frame */
386 gtk_pizza_put( GTK_PIZZA(mdi_frame->m_mainWidget),
387 m_menuBar->m_widget,
388 0, 0, mdi_frame->m_width, wxMENU_HEIGHT );
389 }
390 }
391
392 wxMenuBar *wxMDIChildFrame::GetMenuBar() const
393 {
394 return m_menuBar;
395 }
396
397 void wxMDIChildFrame::Activate()
398 {
399 wxMDIParentFrame* parent = (wxMDIParentFrame*) GetParent();
400 GtkNotebook* notebook = GTK_NOTEBOOK(parent->m_widget);
401 gint pageno = gtk_notebook_page_num( notebook, m_widget );
402 gtk_notebook_set_current_page( notebook, pageno );
403 }
404
405 void wxMDIChildFrame::OnActivate( wxActivateEvent& WXUNUSED(event) )
406 {
407 }
408
409 void wxMDIChildFrame::OnMenuHighlight( wxMenuEvent& event )
410 {
411 #if wxUSE_STATUSBAR
412 wxMDIParentFrame *mdi_frame = (wxMDIParentFrame*)m_parent->GetParent();
413 if ( !ShowMenuHelp(event.GetMenuId()) )
414 {
415 // we don't have any help text for this item, but may be the MDI frame
416 // does?
417 mdi_frame->OnMenuHighlight(event);
418 }
419 #endif // wxUSE_STATUSBAR
420 }
421
422 void wxMDIChildFrame::SetTitle( const wxString &title )
423 {
424 if ( title == m_title )
425 return;
426
427 m_title = title;
428
429 wxMDIParentFrame* parent = (wxMDIParentFrame*) GetParent();
430 GtkNotebook* notebook = GTK_NOTEBOOK(parent->m_widget);
431 gtk_notebook_set_tab_label_text(notebook, m_widget, wxGTK_CONV( title ) );
432 }
433
434 //-----------------------------------------------------------------------------
435 // "size_allocate"
436 //-----------------------------------------------------------------------------
437
438 extern "C" {
439 static void gtk_page_size_callback( GtkWidget *WXUNUSED(widget), GtkAllocation* alloc, wxMDIChildFrame *win )
440 {
441 if ((win->m_x == alloc->x) &&
442 (win->m_y == alloc->y) &&
443 (win->m_width == alloc->width) &&
444 (win->m_height == alloc->height) &&
445 (win->m_sizeSet))
446 {
447 return;
448 }
449
450 win->SetSize( alloc->x, alloc->y, alloc->width, alloc->height );
451 }
452 }
453
454 //-----------------------------------------------------------------------------
455 // InsertChild callback for wxMDIClientWindow
456 //-----------------------------------------------------------------------------
457
458 static void wxInsertChildInMDI(wxWindow* parent, wxWindow* child)
459 {
460 wxMDIChildFrame* child_frame = wx_static_cast(wxMDIChildFrame*, child);
461 wxString s = child_frame->GetTitle();
462 if (s.IsNull()) s = _("MDI child");
463
464 GtkWidget *label_widget = gtk_label_new( s.mbc_str() );
465 gtk_misc_set_alignment( GTK_MISC(label_widget), 0.0, 0.5 );
466
467 g_signal_connect (child->m_widget, "size_allocate",
468 G_CALLBACK (gtk_page_size_callback), child);
469
470 GtkNotebook *notebook = GTK_NOTEBOOK(parent->m_widget);
471
472 gtk_notebook_append_page( notebook, child->m_widget, label_widget );
473
474 child_frame->m_page = (GtkNotebookPage*) (g_list_last(notebook->children)->data);
475
476 wxMDIParentFrame *parent_frame = wx_static_cast(wxMDIParentFrame*, parent->GetParent());
477 parent_frame->m_justInserted = true;
478 }
479
480 //-----------------------------------------------------------------------------
481 // wxMDIClientWindow
482 //-----------------------------------------------------------------------------
483
484 IMPLEMENT_DYNAMIC_CLASS(wxMDIClientWindow,wxWindow)
485
486 wxMDIClientWindow::wxMDIClientWindow()
487 {
488 }
489
490 wxMDIClientWindow::wxMDIClientWindow( wxMDIParentFrame *parent, long style )
491 {
492 CreateClient( parent, style );
493 }
494
495 wxMDIClientWindow::~wxMDIClientWindow()
496 {
497
498 }
499
500 bool wxMDIClientWindow::CreateClient( wxMDIParentFrame *parent, long style )
501 {
502 m_insertCallback = wxInsertChildInMDI;
503
504 if (!PreCreation( parent, wxDefaultPosition, wxDefaultSize ) ||
505 !CreateBase( parent, wxID_ANY, wxDefaultPosition, wxDefaultSize, style, wxDefaultValidator, wxT("wxMDIClientWindow") ))
506 {
507 wxFAIL_MSG( wxT("wxMDIClientWindow creation failed") );
508 return false;
509 }
510
511 m_widget = gtk_notebook_new();
512
513 g_signal_connect (m_widget, "switch_page",
514 G_CALLBACK (gtk_mdi_page_change_callback), parent);
515
516 gtk_notebook_set_scrollable( GTK_NOTEBOOK(m_widget), 1 );
517
518 m_parent->DoAddChild( this );
519
520 PostCreation();
521
522 Show( true );
523
524 return true;
525 }
526
527 #endif // wxUSE_MDI