]>
Commit | Line | Data |
---|---|---|
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/defs.h" | |
23 | ||
24 | #include "wx/dialog.h" | |
25 | #include "wx/control.h" | |
26 | #include "wx/app.h" | |
27 | #include "wx/menu.h" | |
28 | #if wxUSE_TOOLBAR | |
29 | #include "wx/toolbar.h" | |
30 | #endif | |
31 | #if wxUSE_STATUSBAR | |
32 | #include "wx/statusbr.h" | |
33 | #endif | |
34 | #include "wx/dcclient.h" | |
35 | ||
36 | #include <glib.h> | |
37 | #include <gdk/gdk.h> | |
38 | #include <gtk/gtk.h> | |
39 | #include <gdk/gdkkeysyms.h> | |
40 | #include <gdk/gdkx.h> | |
41 | ||
42 | #include "wx/gtk/win_gtk.h" | |
43 | ||
44 | // ---------------------------------------------------------------------------- | |
45 | // constants | |
46 | // ---------------------------------------------------------------------------- | |
47 | ||
48 | const int wxMENU_HEIGHT = 27; | |
49 | const int wxSTATUS_HEIGHT = 25; | |
50 | const int wxPLACE_HOLDER = 0; | |
51 | ||
52 | // ---------------------------------------------------------------------------- | |
53 | // idle system | |
54 | // ---------------------------------------------------------------------------- | |
55 | ||
56 | extern void wxapp_install_idle_handler(); | |
57 | extern bool g_isIdle; | |
58 | extern int g_openDialogs; | |
59 | ||
60 | // ---------------------------------------------------------------------------- | |
61 | // event tables | |
62 | // ---------------------------------------------------------------------------- | |
63 | ||
64 | #ifndef __WXUNIVERSAL__ | |
65 | IMPLEMENT_DYNAMIC_CLASS(wxFrame, wxTopLevelWindow) | |
66 | #endif | |
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), wxFrameGTK *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), wxFrameGTK *win ) | |
95 | { | |
96 | if (!win->m_hasVMT) return; | |
97 | ||
98 | win->m_menuBarDetached = TRUE; | |
99 | win->GtkUpdateSize(); | |
100 | } | |
101 | ||
102 | #endif // wxUSE_MENUS_NATIVE | |
103 | ||
104 | #if wxUSE_TOOLBAR | |
105 | //----------------------------------------------------------------------------- | |
106 | // "child_attached" of tool bar | |
107 | //----------------------------------------------------------------------------- | |
108 | ||
109 | static void gtk_toolbar_attached_callback( GtkWidget *WXUNUSED(widget), GtkWidget *WXUNUSED(child), wxFrameGTK *win ) | |
110 | { | |
111 | if (!win->m_hasVMT) return; | |
112 | ||
113 | win->m_toolBarDetached = FALSE; | |
114 | ||
115 | win->GtkUpdateSize(); | |
116 | } | |
117 | ||
118 | //----------------------------------------------------------------------------- | |
119 | // "child_detached" of tool bar | |
120 | //----------------------------------------------------------------------------- | |
121 | ||
122 | static void gtk_toolbar_detached_callback( GtkWidget *WXUNUSED(widget), GtkWidget *WXUNUSED(child), wxFrameGTK *win ) | |
123 | { | |
124 | if (g_isIdle) | |
125 | wxapp_install_idle_handler(); | |
126 | ||
127 | if (!win->m_hasVMT) return; | |
128 | ||
129 | win->m_toolBarDetached = TRUE; | |
130 | win->GtkUpdateSize(); | |
131 | } | |
132 | #endif // wxUSE_TOOLBAR | |
133 | ||
134 | ||
135 | // ---------------------------------------------------------------------------- | |
136 | // wxFrameGTK itself | |
137 | // ---------------------------------------------------------------------------- | |
138 | ||
139 | //----------------------------------------------------------------------------- | |
140 | // InsertChild for wxFrameGTK | |
141 | //----------------------------------------------------------------------------- | |
142 | ||
143 | /* Callback for wxFrameGTK. This very strange beast has to be used because | |
144 | * C++ has no virtual methods in a constructor. We have to emulate a | |
145 | * virtual function here as wxWindows requires different ways to insert | |
146 | * a child in container classes. */ | |
147 | ||
148 | static void wxInsertChildInFrame( wxFrameGTK* parent, wxWindow* child ) | |
149 | { | |
150 | wxASSERT( GTK_IS_WIDGET(child->m_widget) ); | |
151 | ||
152 | if (!parent->m_insertInClientArea) | |
153 | { | |
154 | /* these are outside the client area */ | |
155 | wxFrameGTK* frame = (wxFrameGTK*) parent; | |
156 | gtk_pizza_put( GTK_PIZZA(frame->m_mainWidget), | |
157 | GTK_WIDGET(child->m_widget), | |
158 | child->m_x, | |
159 | child->m_y, | |
160 | child->m_width, | |
161 | child->m_height ); | |
162 | ||
163 | #if wxUSE_TOOLBAR_NATIVE | |
164 | /* we connect to these events for recalculating the client area | |
165 | space when the toolbar is floating */ | |
166 | if (wxIS_KIND_OF(child,wxToolBar)) | |
167 | { | |
168 | wxToolBar *toolBar = (wxToolBar*) child; | |
169 | if (toolBar->GetWindowStyle() & wxTB_DOCKABLE) | |
170 | { | |
171 | gtk_signal_connect( GTK_OBJECT(toolBar->m_widget), "child_attached", | |
172 | GTK_SIGNAL_FUNC(gtk_toolbar_attached_callback), (gpointer)parent ); | |
173 | ||
174 | gtk_signal_connect( GTK_OBJECT(toolBar->m_widget), "child_detached", | |
175 | GTK_SIGNAL_FUNC(gtk_toolbar_detached_callback), (gpointer)parent ); | |
176 | } | |
177 | } | |
178 | #endif // wxUSE_TOOLBAR | |
179 | } | |
180 | else | |
181 | { | |
182 | /* these are inside the client area */ | |
183 | gtk_pizza_put( GTK_PIZZA(parent->m_wxwindow), | |
184 | GTK_WIDGET(child->m_widget), | |
185 | child->m_x, | |
186 | child->m_y, | |
187 | child->m_width, | |
188 | child->m_height ); | |
189 | } | |
190 | ||
191 | /* resize on OnInternalIdle */ | |
192 | parent->GtkUpdateSize(); | |
193 | } | |
194 | ||
195 | // ---------------------------------------------------------------------------- | |
196 | // wxFrameGTK creation | |
197 | // ---------------------------------------------------------------------------- | |
198 | ||
199 | void wxFrameGTK::Init() | |
200 | { | |
201 | m_menuBarDetached = FALSE; | |
202 | m_toolBarDetached = FALSE; | |
203 | } | |
204 | ||
205 | bool wxFrameGTK::Create( wxWindow *parent, | |
206 | wxWindowID id, | |
207 | const wxString& title, | |
208 | const wxPoint& pos, | |
209 | const wxSize& sizeOrig, | |
210 | long style, | |
211 | const wxString &name ) | |
212 | { | |
213 | bool rt = wxTopLevelWindow::Create(parent, id, title, pos, sizeOrig, | |
214 | style, name); | |
215 | m_insertCallback = (wxInsertChildFunction) wxInsertChildInFrame; | |
216 | return rt; | |
217 | } | |
218 | ||
219 | wxFrameGTK::~wxFrameGTK() | |
220 | { | |
221 | m_isBeingDeleted = TRUE; | |
222 | DeleteAllBars(); | |
223 | } | |
224 | ||
225 | // ---------------------------------------------------------------------------- | |
226 | // overridden wxWindow methods | |
227 | // ---------------------------------------------------------------------------- | |
228 | ||
229 | void wxFrameGTK::DoGetClientSize( int *width, int *height ) const | |
230 | { | |
231 | wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") ); | |
232 | ||
233 | wxTopLevelWindow::DoGetClientSize( width, height ); | |
234 | ||
235 | if (height) | |
236 | { | |
237 | #if wxUSE_MENUS_NATIVE | |
238 | /* menu bar */ | |
239 | if (m_frameMenuBar) | |
240 | { | |
241 | if (!m_menuBarDetached) | |
242 | (*height) -= wxMENU_HEIGHT; | |
243 | else | |
244 | (*height) -= wxPLACE_HOLDER; | |
245 | } | |
246 | #endif // wxUSE_MENUS_NATIVE | |
247 | ||
248 | #if wxUSE_STATUSBAR | |
249 | /* status bar */ | |
250 | if (m_frameStatusBar && m_frameStatusBar->IsShown()) | |
251 | (*height) -= wxSTATUS_HEIGHT; | |
252 | #endif // wxUSE_STATUSBAR | |
253 | ||
254 | #if wxUSE_TOOLBAR | |
255 | /* tool bar */ | |
256 | if (m_frameToolBar && m_frameToolBar->IsShown()) | |
257 | { | |
258 | if (m_toolBarDetached) | |
259 | { | |
260 | *height -= wxPLACE_HOLDER; | |
261 | } | |
262 | else | |
263 | { | |
264 | int x, y; | |
265 | m_frameToolBar->GetSize( &x, &y ); | |
266 | if ( m_frameToolBar->GetWindowStyle() & wxTB_VERTICAL ) | |
267 | { | |
268 | *width -= x; | |
269 | } | |
270 | else | |
271 | { | |
272 | *height -= y; | |
273 | } | |
274 | } | |
275 | } | |
276 | #endif // wxUSE_TOOLBAR | |
277 | } | |
278 | } | |
279 | ||
280 | void wxFrameGTK::DoSetClientSize( int width, int height ) | |
281 | { | |
282 | wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") ); | |
283 | ||
284 | #if wxUSE_MENUS_NATIVE | |
285 | /* menu bar */ | |
286 | if (m_frameMenuBar) | |
287 | { | |
288 | if (!m_menuBarDetached) | |
289 | height += wxMENU_HEIGHT; | |
290 | else | |
291 | height += wxPLACE_HOLDER; | |
292 | } | |
293 | #endif // wxUSE_MENUS_NATIVE | |
294 | ||
295 | #if wxUSE_STATUSBAR | |
296 | /* status bar */ | |
297 | if (m_frameStatusBar && m_frameStatusBar->IsShown()) height += wxSTATUS_HEIGHT; | |
298 | #endif | |
299 | ||
300 | #if wxUSE_TOOLBAR | |
301 | /* tool bar */ | |
302 | if (m_frameToolBar && m_frameToolBar->IsShown()) | |
303 | { | |
304 | if (m_toolBarDetached) | |
305 | { | |
306 | height += wxPLACE_HOLDER; | |
307 | } | |
308 | else | |
309 | { | |
310 | int x, y; | |
311 | m_frameToolBar->GetSize( &x, &y ); | |
312 | if ( m_frameToolBar->GetWindowStyle() & wxTB_VERTICAL ) | |
313 | { | |
314 | width += x; | |
315 | } | |
316 | else | |
317 | { | |
318 | height += y; | |
319 | } | |
320 | } | |
321 | } | |
322 | #endif | |
323 | ||
324 | wxTopLevelWindow::DoSetClientSize( width, height ); | |
325 | } | |
326 | ||
327 | void wxFrameGTK::GtkOnSize( int WXUNUSED(x), int WXUNUSED(y), | |
328 | int width, int height ) | |
329 | { | |
330 | // due to a bug in gtk, x,y are always 0 | |
331 | // m_x = x; | |
332 | // m_y = y; | |
333 | ||
334 | /* avoid recursions */ | |
335 | if (m_resizing) return; | |
336 | m_resizing = TRUE; | |
337 | ||
338 | /* this shouldn't happen: wxFrameGTK, wxMDIParentFrame and wxMDIChildFrame have m_wxwindow */ | |
339 | wxASSERT_MSG( (m_wxwindow != NULL), wxT("invalid frame") ); | |
340 | ||
341 | m_width = width; | |
342 | m_height = height; | |
343 | ||
344 | /* space occupied by m_frameToolBar and m_frameMenuBar */ | |
345 | int client_area_x_offset = 0, | |
346 | client_area_y_offset = 0; | |
347 | ||
348 | /* wxMDIChildFrame derives from wxFrameGTK but it _is_ a wxWindow as it uses | |
349 | wxWindow::Create to create it's GTK equivalent. m_mainWidget is only | |
350 | set in wxFrameGTK::Create so it is used to check what kind of frame we | |
351 | have here. if m_mainWidget is NULL it is a wxMDIChildFrame and so we | |
352 | skip the part which handles m_frameMenuBar, m_frameToolBar and (most | |
353 | importantly) m_mainWidget */ | |
354 | ||
355 | if ((m_minWidth != -1) && (m_width < m_minWidth)) m_width = m_minWidth; | |
356 | if ((m_minHeight != -1) && (m_height < m_minHeight)) m_height = m_minHeight; | |
357 | if ((m_maxWidth != -1) && (m_width > m_maxWidth)) m_width = m_maxWidth; | |
358 | if ((m_maxHeight != -1) && (m_height > m_maxHeight)) m_height = m_maxHeight; | |
359 | ||
360 | if (m_mainWidget) | |
361 | { | |
362 | /* set size hints */ | |
363 | gint flag = 0; // GDK_HINT_POS; | |
364 | if ((m_minWidth != -1) || (m_minHeight != -1)) flag |= GDK_HINT_MIN_SIZE; | |
365 | if ((m_maxWidth != -1) || (m_maxHeight != -1)) flag |= GDK_HINT_MAX_SIZE; | |
366 | GdkGeometry geom; | |
367 | geom.min_width = m_minWidth; | |
368 | geom.min_height = m_minHeight; | |
369 | geom.max_width = m_maxWidth; | |
370 | geom.max_height = m_maxHeight; | |
371 | gtk_window_set_geometry_hints( GTK_WINDOW(m_widget), | |
372 | (GtkWidget*) NULL, | |
373 | &geom, | |
374 | (GdkWindowHints) flag ); | |
375 | ||
376 | /* I revert back to wxGTK's original behaviour. m_mainWidget holds the | |
377 | * menubar, the toolbar and the client area, which is represented by | |
378 | * m_wxwindow. | |
379 | * this hurts in the eye, but I don't want to call SetSize() | |
380 | * because I don't want to call any non-native functions here. */ | |
381 | ||
382 | #if wxUSE_MENUS_NATIVE | |
383 | if (m_frameMenuBar) | |
384 | { | |
385 | int xx = m_miniEdge; | |
386 | int yy = m_miniEdge + m_miniTitle; | |
387 | int ww = m_width - 2*m_miniEdge; | |
388 | int hh = wxMENU_HEIGHT; | |
389 | if (m_menuBarDetached) hh = wxPLACE_HOLDER; | |
390 | m_frameMenuBar->m_x = xx; | |
391 | m_frameMenuBar->m_y = yy; | |
392 | m_frameMenuBar->m_width = ww; | |
393 | m_frameMenuBar->m_height = hh; | |
394 | gtk_pizza_set_size( GTK_PIZZA(m_mainWidget), | |
395 | m_frameMenuBar->m_widget, | |
396 | xx, yy, ww, hh ); | |
397 | client_area_y_offset += hh; | |
398 | } | |
399 | #endif // wxUSE_MENUS_NATIVE | |
400 | ||
401 | #if wxUSE_TOOLBAR | |
402 | if ((m_frameToolBar) && m_frameToolBar->IsShown() && | |
403 | (m_frameToolBar->m_widget->parent == m_mainWidget)) | |
404 | { | |
405 | int xx = m_miniEdge; | |
406 | int yy = m_miniEdge + m_miniTitle; | |
407 | #if wxUSE_MENUS_NATIVE | |
408 | if (m_frameMenuBar) | |
409 | { | |
410 | if (!m_menuBarDetached) | |
411 | yy += wxMENU_HEIGHT; | |
412 | else | |
413 | yy += wxPLACE_HOLDER; | |
414 | } | |
415 | #endif // wxUSE_MENUS_NATIVE | |
416 | ||
417 | m_frameToolBar->m_x = xx; | |
418 | m_frameToolBar->m_y = yy; | |
419 | ||
420 | /* don't change the toolbar's reported height/width */ | |
421 | int ww, hh; | |
422 | if ( m_frameToolBar->GetWindowStyle() & wxTB_VERTICAL ) | |
423 | { | |
424 | ww = m_toolBarDetached ? wxPLACE_HOLDER | |
425 | : m_frameToolBar->m_width; | |
426 | hh = m_height - 2*m_miniEdge; | |
427 | ||
428 | client_area_x_offset += ww; | |
429 | } | |
430 | else | |
431 | { | |
432 | ww = m_width - 2*m_miniEdge; | |
433 | hh = m_toolBarDetached ? wxPLACE_HOLDER | |
434 | : m_frameToolBar->m_height; | |
435 | ||
436 | client_area_y_offset += hh; | |
437 | } | |
438 | ||
439 | gtk_pizza_set_size( GTK_PIZZA(m_mainWidget), | |
440 | m_frameToolBar->m_widget, | |
441 | xx, yy, ww, hh ); | |
442 | } | |
443 | #endif // wxUSE_TOOLBAR | |
444 | ||
445 | int client_x = client_area_x_offset + m_miniEdge; | |
446 | int client_y = client_area_y_offset + m_miniEdge + m_miniTitle; | |
447 | int client_w = m_width - client_area_x_offset - 2*m_miniEdge; | |
448 | int client_h = m_height - client_area_y_offset- 2*m_miniEdge - m_miniTitle; | |
449 | gtk_pizza_set_size( GTK_PIZZA(m_mainWidget), | |
450 | m_wxwindow, | |
451 | client_x, client_y, client_w, client_h ); | |
452 | } | |
453 | else | |
454 | { | |
455 | /* if there is no m_mainWidget between m_widget and m_wxwindow there | |
456 | is no need to set the size or position of m_wxwindow. */ | |
457 | } | |
458 | ||
459 | #if wxUSE_STATUSBAR | |
460 | if (m_frameStatusBar && m_frameStatusBar->IsShown()) | |
461 | { | |
462 | int xx = 0 + m_miniEdge; | |
463 | int yy = m_height - wxSTATUS_HEIGHT - m_miniEdge - client_area_y_offset; | |
464 | int ww = m_width - 2*m_miniEdge; | |
465 | int hh = wxSTATUS_HEIGHT; | |
466 | m_frameStatusBar->m_x = xx; | |
467 | m_frameStatusBar->m_y = yy; | |
468 | m_frameStatusBar->m_width = ww; | |
469 | m_frameStatusBar->m_height = hh; | |
470 | gtk_pizza_set_size( GTK_PIZZA(m_wxwindow), | |
471 | m_frameStatusBar->m_widget, | |
472 | xx, yy, ww, hh ); | |
473 | gtk_widget_draw( m_frameStatusBar->m_widget, (GdkRectangle*) NULL ); | |
474 | } | |
475 | #endif // wxUSE_STATUSBAR | |
476 | ||
477 | m_sizeSet = TRUE; | |
478 | ||
479 | // send size event to frame | |
480 | wxSizeEvent event( wxSize(m_width,m_height), GetId() ); | |
481 | event.SetEventObject( this ); | |
482 | GetEventHandler()->ProcessEvent( event ); | |
483 | ||
484 | #if wxUSE_STATUSBAR | |
485 | // send size event to status bar | |
486 | if (m_frameStatusBar) | |
487 | { | |
488 | wxSizeEvent event2( wxSize(m_frameStatusBar->m_width,m_frameStatusBar->m_height), m_frameStatusBar->GetId() ); | |
489 | event2.SetEventObject( m_frameStatusBar ); | |
490 | m_frameStatusBar->GetEventHandler()->ProcessEvent( event2 ); | |
491 | } | |
492 | #endif // wxUSE_STATUSBAR | |
493 | ||
494 | m_resizing = FALSE; | |
495 | } | |
496 | ||
497 | void wxFrameGTK::OnInternalIdle() | |
498 | { | |
499 | wxTopLevelWindow::OnInternalIdle(); | |
500 | ||
501 | #if wxUSE_MENUS_NATIVE | |
502 | if (m_frameMenuBar) m_frameMenuBar->OnInternalIdle(); | |
503 | #endif // wxUSE_MENUS_NATIVE | |
504 | #if wxUSE_TOOLBAR | |
505 | if (m_frameToolBar) m_frameToolBar->OnInternalIdle(); | |
506 | #endif | |
507 | #if wxUSE_STATUSBAR | |
508 | if (m_frameStatusBar) m_frameStatusBar->OnInternalIdle(); | |
509 | #endif | |
510 | } | |
511 | ||
512 | // ---------------------------------------------------------------------------- | |
513 | // menu/tool/status bar stuff | |
514 | // ---------------------------------------------------------------------------- | |
515 | ||
516 | #if wxUSE_MENUS_NATIVE | |
517 | ||
518 | void wxFrameGTK::DetachMenuBar() | |
519 | { | |
520 | wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") ); | |
521 | wxASSERT_MSG( (m_wxwindow != NULL), wxT("invalid frame") ); | |
522 | ||
523 | if ( m_frameMenuBar ) | |
524 | { | |
525 | m_frameMenuBar->UnsetInvokingWindow( this ); | |
526 | ||
527 | if (m_frameMenuBar->GetWindowStyle() & wxMB_DOCKABLE) | |
528 | { | |
529 | gtk_signal_disconnect_by_func( GTK_OBJECT(m_frameMenuBar->m_widget), | |
530 | GTK_SIGNAL_FUNC(gtk_menu_attached_callback), (gpointer)this ); | |
531 | ||
532 | gtk_signal_disconnect_by_func( GTK_OBJECT(m_frameMenuBar->m_widget), | |
533 | GTK_SIGNAL_FUNC(gtk_menu_detached_callback), (gpointer)this ); | |
534 | } | |
535 | ||
536 | gtk_container_remove( GTK_CONTAINER(m_mainWidget), m_frameMenuBar->m_widget ); | |
537 | gtk_widget_ref( m_frameMenuBar->m_widget ); | |
538 | gtk_widget_unparent( m_frameMenuBar->m_widget ); | |
539 | } | |
540 | ||
541 | wxFrameBase::DetachMenuBar(); | |
542 | } | |
543 | ||
544 | void wxFrameGTK::AttachMenuBar( wxMenuBar *menuBar ) | |
545 | { | |
546 | wxFrameBase::AttachMenuBar(menuBar); | |
547 | ||
548 | if (m_frameMenuBar) | |
549 | { | |
550 | m_frameMenuBar->SetInvokingWindow( this ); | |
551 | ||
552 | m_frameMenuBar->SetParent(this); | |
553 | gtk_pizza_put( GTK_PIZZA(m_mainWidget), | |
554 | m_frameMenuBar->m_widget, | |
555 | m_frameMenuBar->m_x, | |
556 | m_frameMenuBar->m_y, | |
557 | m_frameMenuBar->m_width, | |
558 | m_frameMenuBar->m_height ); | |
559 | ||
560 | if (menuBar->GetWindowStyle() & wxMB_DOCKABLE) | |
561 | { | |
562 | gtk_signal_connect( GTK_OBJECT(menuBar->m_widget), "child_attached", | |
563 | GTK_SIGNAL_FUNC(gtk_menu_attached_callback), (gpointer)this ); | |
564 | ||
565 | gtk_signal_connect( GTK_OBJECT(menuBar->m_widget), "child_detached", | |
566 | GTK_SIGNAL_FUNC(gtk_menu_detached_callback), (gpointer)this ); | |
567 | } | |
568 | ||
569 | m_frameMenuBar->Show( TRUE ); | |
570 | } | |
571 | ||
572 | /* resize window in OnInternalIdle */ | |
573 | m_sizeSet = FALSE; | |
574 | } | |
575 | ||
576 | #endif // wxUSE_MENUS_NATIVE | |
577 | ||
578 | #if wxUSE_TOOLBAR | |
579 | ||
580 | wxToolBar* wxFrameGTK::CreateToolBar( long style, wxWindowID id, const wxString& name ) | |
581 | { | |
582 | wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") ); | |
583 | ||
584 | m_insertInClientArea = FALSE; | |
585 | ||
586 | m_frameToolBar = wxFrameBase::CreateToolBar( style, id, name ); | |
587 | ||
588 | m_insertInClientArea = TRUE; | |
589 | ||
590 | m_sizeSet = FALSE; | |
591 | ||
592 | return m_frameToolBar; | |
593 | } | |
594 | ||
595 | void wxFrameGTK::SetToolBar(wxToolBar *toolbar) | |
596 | { | |
597 | wxFrameBase::SetToolBar(toolbar); | |
598 | ||
599 | if (m_frameToolBar) | |
600 | { | |
601 | /* insert into toolbar area if not already there */ | |
602 | if ((m_frameToolBar->m_widget->parent) && | |
603 | (m_frameToolBar->m_widget->parent != m_mainWidget)) | |
604 | { | |
605 | GetChildren().DeleteObject( m_frameToolBar ); | |
606 | ||
607 | gtk_widget_reparent( m_frameToolBar->m_widget, m_mainWidget ); | |
608 | GtkUpdateSize(); | |
609 | } | |
610 | } | |
611 | } | |
612 | ||
613 | #endif // wxUSE_TOOLBAR | |
614 | ||
615 | #if wxUSE_STATUSBAR | |
616 | ||
617 | wxStatusBar* wxFrameGTK::CreateStatusBar(int number, | |
618 | long style, | |
619 | wxWindowID id, | |
620 | const wxString& name) | |
621 | { | |
622 | wxASSERT_MSG( (m_widget != NULL), wxT("invalid frame") ); | |
623 | ||
624 | // because it will change when toolbar is added | |
625 | m_sizeSet = FALSE; | |
626 | ||
627 | return wxFrameBase::CreateStatusBar( number, style, id, name ); | |
628 | } | |
629 | ||
630 | void wxFrameGTK::PositionStatusBar() | |
631 | { | |
632 | if ( !m_frameStatusBar ) | |
633 | return; | |
634 | ||
635 | m_sizeSet = FALSE; | |
636 | } | |
637 | #endif // wxUSE_STATUSBAR | |
638 |