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


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