/[pcsx2_0.9.7]/trunk/3rdparty/wxWidgets/src/common/framecmn.cpp
ViewVC logotype

Annotation of /trunk/3rdparty/wxWidgets/src/common/framecmn.cpp

Parent Directory Parent Directory | Revision Log Revision Log


Revision 31 - (hide annotations) (download)
Tue Sep 7 03:24:11 2010 UTC (10 years, 4 months ago) by william
File size: 15761 byte(s)
committing r3113 initial commit again...
1 william 31 /////////////////////////////////////////////////////////////////////////////
2     // Name: src/common/framecmn.cpp
3     // Purpose: common (for all platforms) wxFrame functions
4     // Author: Julian Smart, Vadim Zeitlin
5     // Created: 01/02/97
6     // Id: $Id: framecmn.cpp 51463 2008-01-30 21:31:03Z VZ $
7     // Copyright: (c) 1998 Robert Roebling and Julian Smart
8     // Licence: wxWindows licence
9     /////////////////////////////////////////////////////////////////////////////
10    
11     // ============================================================================
12     // declarations
13     // ============================================================================
14    
15     // ----------------------------------------------------------------------------
16     // headers
17     // ----------------------------------------------------------------------------
18    
19     // For compilers that support precompilation, includes "wx.h".
20     #include "wx/wxprec.h"
21    
22     #ifdef __BORLANDC__
23     #pragma hdrstop
24     #endif
25    
26     #include "wx/frame.h"
27    
28     #ifndef WX_PRECOMP
29     #include "wx/menu.h"
30     #include "wx/menuitem.h"
31     #include "wx/dcclient.h"
32     #include "wx/toolbar.h"
33     #include "wx/statusbr.h"
34     #endif // WX_PRECOMP
35    
36     // ----------------------------------------------------------------------------
37     // event table
38     // ----------------------------------------------------------------------------
39    
40     #if wxUSE_MENUS && wxUSE_STATUSBAR
41    
42     BEGIN_EVENT_TABLE(wxFrameBase, wxTopLevelWindow)
43     EVT_MENU_OPEN(wxFrameBase::OnMenuOpen)
44     EVT_MENU_CLOSE(wxFrameBase::OnMenuClose)
45    
46     EVT_MENU_HIGHLIGHT_ALL(wxFrameBase::OnMenuHighlight)
47     END_EVENT_TABLE()
48    
49     #endif // wxUSE_MENUS && wxUSE_STATUSBAR
50    
51     // ============================================================================
52     // implementation
53     // ============================================================================
54    
55     // ----------------------------------------------------------------------------
56     // construction/destruction
57     // ----------------------------------------------------------------------------
58    
59     wxFrameBase::wxFrameBase()
60     {
61     #if wxUSE_MENUS
62     m_frameMenuBar = NULL;
63     #endif // wxUSE_MENUS
64    
65     #if wxUSE_TOOLBAR
66     m_frameToolBar = NULL;
67     #endif // wxUSE_TOOLBAR
68    
69     #if wxUSE_STATUSBAR
70     m_frameStatusBar = NULL;
71     #endif // wxUSE_STATUSBAR
72    
73     m_statusBarPane = 0;
74     }
75    
76     wxFrameBase::~wxFrameBase()
77     {
78     // this destructor is required for Darwin
79     }
80    
81     wxFrame *wxFrameBase::New(wxWindow *parent,
82     wxWindowID id,
83     const wxString& title,
84     const wxPoint& pos,
85     const wxSize& size,
86     long style,
87     const wxString& name)
88     {
89     return new wxFrame(parent, id, title, pos, size, style, name);
90     }
91    
92     void wxFrameBase::DeleteAllBars()
93     {
94     #if wxUSE_MENUS
95     if ( m_frameMenuBar )
96     {
97     delete m_frameMenuBar;
98     m_frameMenuBar = (wxMenuBar *) NULL;
99     }
100     #endif // wxUSE_MENUS
101    
102     #if wxUSE_STATUSBAR
103     if ( m_frameStatusBar )
104     {
105     delete m_frameStatusBar;
106     m_frameStatusBar = (wxStatusBar *) NULL;
107     }
108     #endif // wxUSE_STATUSBAR
109    
110     #if wxUSE_TOOLBAR
111     if ( m_frameToolBar )
112     {
113     delete m_frameToolBar;
114     m_frameToolBar = (wxToolBar *) NULL;
115     }
116     #endif // wxUSE_TOOLBAR
117     }
118    
119     bool wxFrameBase::IsOneOfBars(const wxWindow *win) const
120     {
121     #if wxUSE_MENUS
122     if ( win == GetMenuBar() )
123     return true;
124     #endif // wxUSE_MENUS
125    
126     #if wxUSE_STATUSBAR
127     if ( win == GetStatusBar() )
128     return true;
129     #endif // wxUSE_STATUSBAR
130    
131     #if wxUSE_TOOLBAR
132     if ( win == GetToolBar() )
133     return true;
134     #endif // wxUSE_TOOLBAR
135    
136     return false;
137     }
138    
139     // ----------------------------------------------------------------------------
140     // wxFrame size management: we exclude the areas taken by menu/status/toolbars
141     // from the client area, so the client area is what's really available for the
142     // frame contents
143     // ----------------------------------------------------------------------------
144    
145     // get the origin of the client area in the client coordinates
146     wxPoint wxFrameBase::GetClientAreaOrigin() const
147     {
148     wxPoint pt = wxTopLevelWindow::GetClientAreaOrigin();
149    
150     #if wxUSE_TOOLBAR && !defined(__WXUNIVERSAL__)
151     wxToolBar *toolbar = GetToolBar();
152     if ( toolbar && toolbar->IsShown() )
153     {
154     int w, h;
155     toolbar->GetSize(&w, &h);
156    
157     if ( toolbar->GetWindowStyleFlag() & wxTB_VERTICAL )
158     {
159     pt.x += w;
160     }
161     else
162     {
163     pt.y += h;
164     }
165     }
166     #endif // wxUSE_TOOLBAR
167    
168     return pt;
169     }
170    
171    
172     void wxFrameBase::SendSizeEvent()
173     {
174     const wxSize size = GetSize();
175     wxSizeEvent event( size, GetId() );
176     event.SetEventObject( this );
177     GetEventHandler()->AddPendingEvent( event );
178    
179     #ifdef __WXGTK__
180     // SendSizeEvent is typically called when a toolbar is shown
181     // or hidden, but sending the size event alone is not enough
182     // to trigger a full layout.
183     ((wxFrame*)this)->GtkOnSize(
184     #ifndef __WXGTK20__
185     0, 0, size.x, size.y
186     #endif // __WXGTK20__
187     );
188     #endif // __WXGTK__
189     }
190    
191    
192     // ----------------------------------------------------------------------------
193     // misc
194     // ----------------------------------------------------------------------------
195    
196     bool wxFrameBase::ProcessCommand(int id)
197     {
198     #if wxUSE_MENUS
199     wxMenuBar *bar = GetMenuBar();
200     if ( !bar )
201     return false;
202    
203     wxCommandEvent commandEvent(wxEVT_COMMAND_MENU_SELECTED, id);
204     commandEvent.SetEventObject(this);
205    
206     wxMenuItem *item = bar->FindItem(id);
207     if (item)
208     {
209     if (!item->IsEnabled())
210     return true;
211    
212     if ((item->GetKind() == wxITEM_RADIO) && item->IsChecked() )
213     return true;
214    
215     if (item->IsCheckable())
216     {
217     item->Toggle();
218    
219     // use the new value
220     commandEvent.SetInt(item->IsChecked());
221     }
222     }
223    
224     return GetEventHandler()->ProcessEvent(commandEvent);
225     #else // !wxUSE_MENUS
226     return false;
227     #endif // wxUSE_MENUS/!wxUSE_MENUS
228     }
229    
230     // Do the UI update processing for this window. This is
231     // provided for the application to call if it wants to
232     // force a UI update, particularly for the menus and toolbar.
233     void wxFrameBase::UpdateWindowUI(long flags)
234     {
235     wxWindowBase::UpdateWindowUI(flags);
236    
237     #if wxUSE_TOOLBAR
238     if (GetToolBar())
239     GetToolBar()->UpdateWindowUI(flags);
240     #endif
241    
242     #if wxUSE_MENUS
243     if (GetMenuBar())
244     {
245     if ((flags & wxUPDATE_UI_FROMIDLE) && !wxUSE_IDLEMENUUPDATES)
246     {
247     // If coming from an idle event, we only
248     // want to update the menus if we're
249     // in the wxUSE_IDLEMENUUPDATES configuration:
250     // so if we're not, do nothing
251     }
252     else
253     DoMenuUpdates();
254     }
255     #endif // wxUSE_MENUS
256     }
257    
258     // ----------------------------------------------------------------------------
259     // event handlers for status bar updates from menus
260     // ----------------------------------------------------------------------------
261    
262     #if wxUSE_MENUS && wxUSE_STATUSBAR
263    
264     void wxFrameBase::OnMenuHighlight(wxMenuEvent& event)
265     {
266     #if wxUSE_STATUSBAR
267     (void)ShowMenuHelp(GetStatusBar(), event.GetMenuId());
268     #endif // wxUSE_STATUSBAR
269     }
270    
271     #if !wxUSE_IDLEMENUUPDATES
272     void wxFrameBase::OnMenuOpen(wxMenuEvent& event)
273     #else
274     void wxFrameBase::OnMenuOpen(wxMenuEvent& WXUNUSED(event))
275     #endif
276     {
277     #if !wxUSE_IDLEMENUUPDATES
278     DoMenuUpdates(event.GetMenu());
279     #endif // !wxUSE_IDLEMENUUPDATES
280     }
281    
282     void wxFrameBase::OnMenuClose(wxMenuEvent& WXUNUSED(event))
283     {
284     // do we have real status text to restore?
285     if ( !m_oldStatusText.empty() )
286     {
287     if ( m_statusBarPane >= 0 )
288     {
289     wxStatusBar *statbar = GetStatusBar();
290     if ( statbar )
291     statbar->SetStatusText(m_oldStatusText, m_statusBarPane);
292     }
293    
294     m_oldStatusText.clear();
295     }
296     }
297    
298     #endif // wxUSE_MENUS && wxUSE_STATUSBAR
299    
300     // Implement internal behaviour (menu updating on some platforms)
301     void wxFrameBase::OnInternalIdle()
302     {
303     wxTopLevelWindow::OnInternalIdle();
304    
305     #if wxUSE_MENUS && wxUSE_IDLEMENUUPDATES
306     if (wxUpdateUIEvent::CanUpdate(this))
307     DoMenuUpdates();
308     #endif
309     }
310    
311     // ----------------------------------------------------------------------------
312     // status bar stuff
313     // ----------------------------------------------------------------------------
314    
315     #if wxUSE_STATUSBAR
316    
317     wxStatusBar* wxFrameBase::CreateStatusBar(int number,
318     long style,
319     wxWindowID id,
320     const wxString& name)
321     {
322     // the main status bar can only be created once (or else it should be
323     // deleted before calling CreateStatusBar() again)
324     wxCHECK_MSG( !m_frameStatusBar, (wxStatusBar *)NULL,
325     wxT("recreating status bar in wxFrame") );
326    
327     SetStatusBar(OnCreateStatusBar(number, style, id, name));
328    
329     return m_frameStatusBar;
330     }
331    
332     wxStatusBar *wxFrameBase::OnCreateStatusBar(int number,
333     long style,
334     wxWindowID id,
335     const wxString& name)
336     {
337     wxStatusBar *statusBar = new wxStatusBar(this, id, style, name);
338    
339     statusBar->SetFieldsCount(number);
340    
341     return statusBar;
342     }
343    
344     void wxFrameBase::SetStatusText(const wxString& text, int number)
345     {
346     wxCHECK_RET( m_frameStatusBar != NULL, wxT("no statusbar to set text for") );
347    
348     m_frameStatusBar->SetStatusText(text, number);
349     }
350    
351     void wxFrameBase::SetStatusWidths(int n, const int widths_field[] )
352     {
353     wxCHECK_RET( m_frameStatusBar != NULL, wxT("no statusbar to set widths for") );
354    
355     m_frameStatusBar->SetStatusWidths(n, widths_field);
356    
357     PositionStatusBar();
358     }
359    
360     void wxFrameBase::PushStatusText(const wxString& text, int number)
361     {
362     wxCHECK_RET( m_frameStatusBar != NULL, wxT("no statusbar to set text for") );
363    
364     m_frameStatusBar->PushStatusText(text, number);
365     }
366    
367     void wxFrameBase::PopStatusText(int number)
368     {
369     wxCHECK_RET( m_frameStatusBar != NULL, wxT("no statusbar to set text for") );
370    
371     m_frameStatusBar->PopStatusText(number);
372     }
373    
374     bool wxFrameBase::ShowMenuHelp(wxStatusBar *WXUNUSED(statbar), int menuId)
375     {
376     #if wxUSE_MENUS
377     // if no help string found, we will clear the status bar text
378     wxString helpString;
379     bool show = menuId != wxID_SEPARATOR && menuId != -2 /* wxID_TITLE */;
380    
381     if ( show )
382     {
383     wxMenuBar *menuBar = GetMenuBar();
384     if ( menuBar )
385     {
386     // it's ok if we don't find the item because it might belong
387     // to the popup menu
388     wxMenuItem *item = menuBar->FindItem(menuId);
389     if ( item )
390     helpString = item->GetHelp();
391     }
392     }
393    
394     DoGiveHelp(helpString, show);
395    
396     return !helpString.empty();
397     #else // !wxUSE_MENUS
398     return false;
399     #endif // wxUSE_MENUS/!wxUSE_MENUS
400     }
401    
402     void wxFrameBase::SetStatusBar(wxStatusBar *statBar)
403     {
404     bool hadBar = m_frameStatusBar != NULL;
405     m_frameStatusBar = statBar;
406    
407     if ( (m_frameStatusBar != NULL) != hadBar )
408     {
409     PositionStatusBar();
410    
411     DoLayout();
412     }
413     }
414    
415     #endif // wxUSE_STATUSBAR
416    
417     #if wxUSE_MENUS || wxUSE_TOOLBAR
418     void wxFrameBase::DoGiveHelp(const wxString& text, bool show)
419     {
420     #if wxUSE_STATUSBAR
421     if ( m_statusBarPane < 0 )
422     {
423     // status bar messages disabled
424     return;
425     }
426    
427     wxStatusBar *statbar = GetStatusBar();
428     if ( !statbar )
429     return;
430    
431     wxString help;
432     if ( show )
433     {
434     help = text;
435    
436     // remember the old status bar text if this is the first time we're
437     // called since the menu has been opened as we're going to overwrite it
438     // in our DoGiveHelp() and we want to restore it when the menu is
439     // closed
440     //
441     // note that it would be logical to do this in OnMenuOpen() but under
442     // MSW we get an EVT_MENU_HIGHLIGHT before EVT_MENU_OPEN, strangely
443     // enough, and so this doesn't work and instead we use the ugly trick
444     // with using special m_oldStatusText value as "menu opened" (but it is
445     // arguably better than adding yet another member variable to wxFrame
446     // on all platforms)
447     if ( m_oldStatusText.empty() )
448     {
449     m_oldStatusText = statbar->GetStatusText(m_statusBarPane);
450     if ( m_oldStatusText.empty() )
451     {
452     // use special value to prevent us from doing this the next time
453     m_oldStatusText += _T('\0');
454     }
455     }
456     }
457     else // hide the status bar text
458     {
459     // i.e. restore the old one
460     help = m_oldStatusText;
461    
462     // make sure we get the up to date text when showing it the next time
463     m_oldStatusText.clear();
464     }
465    
466     statbar->SetStatusText(help, m_statusBarPane);
467     #else
468     wxUnusedVar(text);
469     wxUnusedVar(show);
470     #endif // wxUSE_STATUSBAR
471     }
472     #endif // wxUSE_MENUS || wxUSE_TOOLBAR
473    
474    
475     // ----------------------------------------------------------------------------
476     // toolbar stuff
477     // ----------------------------------------------------------------------------
478    
479     #if wxUSE_TOOLBAR
480    
481     wxToolBar* wxFrameBase::CreateToolBar(long style,
482     wxWindowID id,
483     const wxString& name)
484     {
485     // the main toolbar can't be recreated (unless it was explicitly deleted
486     // before)
487     wxCHECK_MSG( !m_frameToolBar, (wxToolBar *)NULL,
488     wxT("recreating toolbar in wxFrame") );
489    
490     if ( style == -1 )
491     {
492     // use default style
493     //
494     // NB: we don't specify the default value in the method declaration
495     // because
496     // a) this allows us to have different defaults for different
497     // platforms (even if we don't have them right now)
498     // b) we don't need to include wx/toolbar.h in the header then
499     style = wxBORDER_NONE | wxTB_HORIZONTAL | wxTB_FLAT;
500     }
501    
502     SetToolBar(OnCreateToolBar(style, id, name));
503    
504     return m_frameToolBar;
505     }
506    
507     wxToolBar* wxFrameBase::OnCreateToolBar(long style,
508     wxWindowID id,
509     const wxString& name)
510     {
511     #if defined(__WXWINCE__) && defined(__POCKETPC__)
512     return new wxToolMenuBar(this, id,
513     wxDefaultPosition, wxDefaultSize,
514     style, name);
515     #else
516     return new wxToolBar(this, id,
517     wxDefaultPosition, wxDefaultSize,
518     style, name);
519     #endif
520     }
521    
522     void wxFrameBase::SetToolBar(wxToolBar *toolbar)
523     {
524     bool hadBar = m_frameToolBar != NULL;
525     m_frameToolBar = toolbar;
526    
527     if ( (m_frameToolBar != NULL) != hadBar )
528     {
529     PositionToolBar();
530    
531     DoLayout();
532     }
533     }
534    
535     #endif // wxUSE_TOOLBAR
536    
537     // ----------------------------------------------------------------------------
538     // menus
539     // ----------------------------------------------------------------------------
540    
541     #if wxUSE_MENUS
542    
543     // update all menus
544     void wxFrameBase::DoMenuUpdates(wxMenu* menu)
545     {
546     if (menu)
547     {
548     wxEvtHandler* source = GetEventHandler();
549     menu->UpdateUI(source);
550     }
551     else
552     {
553     wxMenuBar* bar = GetMenuBar();
554     if (bar != NULL)
555     bar->UpdateMenus();
556     }
557     }
558    
559     void wxFrameBase::DetachMenuBar()
560     {
561     if ( m_frameMenuBar )
562     {
563     m_frameMenuBar->Detach();
564     m_frameMenuBar = NULL;
565     }
566     }
567    
568     void wxFrameBase::AttachMenuBar(wxMenuBar *menubar)
569     {
570     if ( menubar )
571     {
572     menubar->Attach((wxFrame *)this);
573     m_frameMenuBar = menubar;
574     }
575     }
576    
577     void wxFrameBase::SetMenuBar(wxMenuBar *menubar)
578     {
579     if ( menubar == GetMenuBar() )
580     {
581     // nothing to do
582     return;
583     }
584    
585     DetachMenuBar();
586    
587     this->AttachMenuBar(menubar);
588     }
589    
590     #endif // wxUSE_MENUS

  ViewVC Help
Powered by ViewVC 1.1.22