src/common/framecmn.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        src/common/framecmn.cpp
// Purpose:     common (for all platforms) wxFrame functions
// Author:      Julian Smart, Vadim Zeitlin
// Created:     01/02/97
// Id:          $Id$
// Copyright:   (c) 1998 Robert Roebling and Julian Smart
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

// ============================================================================
// declarations
// ============================================================================

// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------

// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#include "wx/frame.h"

#ifndef WX_PRECOMP
    #include "wx/menu.h"
    #include "wx/menuitem.h"
    #include "wx/dcclient.h"
    #include "wx/toolbar.h"
    #include "wx/statusbr.h"
#endif // WX_PRECOMP

extern WXDLLEXPORT_DATA(const char) wxFrameNameStr[] = "frame";
extern WXDLLEXPORT_DATA(const char) wxStatusLineNameStr[] = "status_line";

// ----------------------------------------------------------------------------
// event table
// ----------------------------------------------------------------------------

#if wxUSE_MENUS && wxUSE_STATUSBAR

BEGIN_EVENT_TABLE(wxFrameBase, wxTopLevelWindow)
    EVT_MENU_OPEN(wxFrameBase::OnMenuOpen)
    EVT_MENU_CLOSE(wxFrameBase::OnMenuClose)

    EVT_MENU_HIGHLIGHT_ALL(wxFrameBase::OnMenuHighlight)
END_EVENT_TABLE()

#endif // wxUSE_MENUS && wxUSE_STATUSBAR

// ============================================================================
// implementation
// ============================================================================

// ----------------------------------------------------------------------------
// XTI
// ----------------------------------------------------------------------------

wxDEFINE_FLAGS( wxFrameStyle )
wxBEGIN_FLAGS( wxFrameStyle )
// new style border flags, we put them first to
// use them for streaming out
wxFLAGS_MEMBER(wxBORDER_SIMPLE)
wxFLAGS_MEMBER(wxBORDER_SUNKEN)
wxFLAGS_MEMBER(wxBORDER_DOUBLE)
wxFLAGS_MEMBER(wxBORDER_RAISED)
wxFLAGS_MEMBER(wxBORDER_STATIC)
wxFLAGS_MEMBER(wxBORDER_NONE)

// old style border flags
wxFLAGS_MEMBER(wxSIMPLE_BORDER)
wxFLAGS_MEMBER(wxSUNKEN_BORDER)
wxFLAGS_MEMBER(wxDOUBLE_BORDER)
wxFLAGS_MEMBER(wxRAISED_BORDER)
wxFLAGS_MEMBER(wxSTATIC_BORDER)
wxFLAGS_MEMBER(wxBORDER)

// standard window styles
wxFLAGS_MEMBER(wxTAB_TRAVERSAL)
wxFLAGS_MEMBER(wxCLIP_CHILDREN)
wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW)
wxFLAGS_MEMBER(wxWANTS_CHARS)
wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE)
wxFLAGS_MEMBER(wxALWAYS_SHOW_SB )
wxFLAGS_MEMBER(wxVSCROLL)
wxFLAGS_MEMBER(wxHSCROLL)

// frame styles
wxFLAGS_MEMBER(wxSTAY_ON_TOP)
wxFLAGS_MEMBER(wxCAPTION)
#if WXWIN_COMPATIBILITY_2_6
wxFLAGS_MEMBER(wxTHICK_FRAME)
#endif // WXWIN_COMPATIBILITY_2_6
wxFLAGS_MEMBER(wxSYSTEM_MENU)
wxFLAGS_MEMBER(wxRESIZE_BORDER)
#if WXWIN_COMPATIBILITY_2_6
wxFLAGS_MEMBER(wxRESIZE_BOX)
#endif // WXWIN_COMPATIBILITY_2_6
wxFLAGS_MEMBER(wxCLOSE_BOX)
wxFLAGS_MEMBER(wxMAXIMIZE_BOX)
wxFLAGS_MEMBER(wxMINIMIZE_BOX)

wxFLAGS_MEMBER(wxFRAME_TOOL_WINDOW)
wxFLAGS_MEMBER(wxFRAME_FLOAT_ON_PARENT)

wxFLAGS_MEMBER(wxFRAME_SHAPED)
wxEND_FLAGS( wxFrameStyle )

wxIMPLEMENT_DYNAMIC_CLASS_XTI(wxFrame, wxTopLevelWindow, "wx/frame.h")

wxBEGIN_PROPERTIES_TABLE(wxFrame)
wxEVENT_PROPERTY( Menu, wxEVT_COMMAND_MENU_SELECTED, wxCommandEvent)

wxPROPERTY( Title,wxString, SetTitle, GetTitle, wxString(), 0 /*flags*/, \
           wxT("Helpstring"), wxT("group"))
wxPROPERTY_FLAGS( WindowStyle, wxFrameStyle, long, SetWindowStyleFlag, \
                 GetWindowStyleFlag, wxEMPTY_PARAMETER_VALUE, 0 /*flags*/, \
                 wxT("Helpstring"), wxT("group")) // style
wxPROPERTY( MenuBar, wxMenuBar *, SetMenuBar, GetMenuBar, wxEMPTY_PARAMETER_VALUE, \
           0 /*flags*/, wxT("Helpstring"), wxT("group"))
wxEND_PROPERTIES_TABLE()

wxEMPTY_HANDLERS_TABLE(wxFrame)

wxCONSTRUCTOR_6( wxFrame, wxWindow*, Parent, wxWindowID, Id, wxString, Title, \
                wxPoint, Position, wxSize, Size, long, WindowStyle)

// ----------------------------------------------------------------------------
// construction/destruction
// ----------------------------------------------------------------------------

wxFrameBase::wxFrameBase()
{
#if wxUSE_MENUS
    m_frameMenuBar = NULL;
#endif // wxUSE_MENUS

#if wxUSE_TOOLBAR
    m_frameToolBar = NULL;
#endif // wxUSE_TOOLBAR

#if wxUSE_STATUSBAR
    m_frameStatusBar = NULL;
#endif // wxUSE_STATUSBAR

    m_statusBarPane = 0;
}

wxFrameBase::~wxFrameBase()
{
    // this destructor is required for Darwin
}

wxFrame *wxFrameBase::New(wxWindow *parent,
                          wxWindowID id,
                          const wxString& title,
                          const wxPoint& pos,
                          const wxSize& size,
                          long style,
                          const wxString& name)
{
    return new wxFrame(parent, id, title, pos, size, style, name);
}

void wxFrameBase::DeleteAllBars()
{
#if wxUSE_MENUS
    wxDELETE(m_frameMenuBar);
#endif // wxUSE_MENUS

#if wxUSE_STATUSBAR
    wxDELETE(m_frameStatusBar);
#endif // wxUSE_STATUSBAR

#if wxUSE_TOOLBAR
    wxDELETE(m_frameToolBar);
#endif // wxUSE_TOOLBAR
}

bool wxFrameBase::IsOneOfBars(const wxWindow *win) const
{
#if wxUSE_MENUS
    if ( win == GetMenuBar() )
        return true;
#endif // wxUSE_MENUS

#if wxUSE_STATUSBAR
    if ( win == GetStatusBar() )
        return true;
#endif // wxUSE_STATUSBAR

#if wxUSE_TOOLBAR
    if ( win == GetToolBar() )
        return true;
#endif // wxUSE_TOOLBAR

    wxUnusedVar(win);

    return false;
}

// ----------------------------------------------------------------------------
// wxFrame size management: we exclude the areas taken by menu/status/toolbars
// from the client area, so the client area is what's really available for the
// frame contents
// ----------------------------------------------------------------------------

// get the origin of the client area in the client coordinates
wxPoint wxFrameBase::GetClientAreaOrigin() const
{
    wxPoint pt = wxTopLevelWindow::GetClientAreaOrigin();

#if wxUSE_TOOLBAR && !defined(__WXUNIVERSAL__)
    wxToolBar *toolbar = GetToolBar();
    if ( toolbar && toolbar->IsShown() )
    {
        int w, h;
        toolbar->GetSize(&w, &h);

        if ( toolbar->GetWindowStyleFlag() & wxTB_VERTICAL )
        {
            pt.x += w;
        }
        else
        {
            pt.y += h;
        }
    }
#endif // wxUSE_TOOLBAR

    return pt;
}

// ----------------------------------------------------------------------------
// misc
// ----------------------------------------------------------------------------

#if wxUSE_MENUS

bool wxFrameBase::ProcessCommand(int id)
{
    wxMenuBar *bar = GetMenuBar();
    if ( !bar )
        return false;

    wxMenuItem *item = bar->FindItem(id);
    if ( !item )
        return false;

    return ProcessCommand(item);
}

bool wxFrameBase::ProcessCommand(wxMenuItem *item)
{
    wxCommandEvent commandEvent(wxEVT_COMMAND_MENU_SELECTED, item->GetId());
    commandEvent.SetEventObject(this);

    if (!item->IsEnabled())
        return true;

    if ((item->GetKind() == wxITEM_RADIO) && item->IsChecked() )
        return true;

    if (item->IsCheckable())
    {
        item->Toggle();

        // use the new value
        commandEvent.SetInt(item->IsChecked());
    }

    return HandleWindowEvent(commandEvent);
}

#endif // wxUSE_MENUS

// Do the UI update processing for this window. This is
// provided for the application to call if it wants to
// force a UI update, particularly for the menus and toolbar.
void wxFrameBase::UpdateWindowUI(long flags)
{
    wxWindowBase::UpdateWindowUI(flags);

#if wxUSE_TOOLBAR
    if (GetToolBar())
        GetToolBar()->UpdateWindowUI(flags);
#endif

#if wxUSE_MENUS
    if (GetMenuBar())
    {
        // If coming from an idle event, we only want to update the menus if
        // we're in the wxUSE_IDLEMENUUPDATES configuration, otherwise they
        // will be update when the menu is opened later
#if !wxUSE_IDLEMENUUPDATES
        if ( !(flags & wxUPDATE_UI_FROMIDLE) )
#endif // wxUSE_IDLEMENUUPDATES
            DoMenuUpdates();
    }
#endif // wxUSE_MENUS
}

// ----------------------------------------------------------------------------
// event handlers for status bar updates from menus
// ----------------------------------------------------------------------------

#if wxUSE_MENUS && wxUSE_STATUSBAR

void wxFrameBase::OnMenuHighlight(wxMenuEvent& event)
{
#if wxUSE_STATUSBAR
    (void)ShowMenuHelp(event.GetMenuId());
#endif // wxUSE_STATUSBAR
}

void wxFrameBase::OnMenuOpen(wxMenuEvent& event)
{
#if wxUSE_IDLEMENUUPDATES
    wxUnusedVar(event);
#else // !wxUSE_IDLEMENUUPDATES
    // as we didn't update the menus from idle time, do it now
    DoMenuUpdates(event.GetMenu());
#endif // wxUSE_IDLEMENUUPDATES/!wxUSE_IDLEMENUUPDATES
}

void wxFrameBase::OnMenuClose(wxMenuEvent& WXUNUSED(event))
{
    DoGiveHelp(wxEmptyString, false);
}

#endif // wxUSE_MENUS && wxUSE_STATUSBAR

// Implement internal behaviour (menu updating on some platforms)
void wxFrameBase::OnInternalIdle()
{
    wxTopLevelWindow::OnInternalIdle();

#if wxUSE_MENUS && wxUSE_IDLEMENUUPDATES
    if (wxUpdateUIEvent::CanUpdate(this))
        DoMenuUpdates();
#endif
}

// ----------------------------------------------------------------------------
// status bar stuff
// ----------------------------------------------------------------------------

#if wxUSE_STATUSBAR

wxStatusBar* wxFrameBase::CreateStatusBar(int number,
                                          long style,
                                          wxWindowID id,
                                          const wxString& name)
{
    // the main status bar can only be created once (or else it should be
    // deleted before calling CreateStatusBar() again)
    wxCHECK_MSG( !m_frameStatusBar, NULL,
                 wxT("recreating status bar in wxFrame") );

    SetStatusBar(OnCreateStatusBar(number, style, id, name));

    return m_frameStatusBar;
}

wxStatusBar *wxFrameBase::OnCreateStatusBar(int number,
                                            long style,
                                            wxWindowID id,
                                            const wxString& name)
{
    wxStatusBar *statusBar = new wxStatusBar(this, id, style, name);

    statusBar->SetFieldsCount(number);

    return statusBar;
}

void wxFrameBase::SetStatusText(const wxString& text, int number)
{
    wxCHECK_RET( m_frameStatusBar != NULL, wxT("no statusbar to set text for") );

    m_frameStatusBar->SetStatusText(text, number);
}

void wxFrameBase::SetStatusWidths(int n, const int widths_field[] )
{
    wxCHECK_RET( m_frameStatusBar != NULL, wxT("no statusbar to set widths for") );

    m_frameStatusBar->SetStatusWidths(n, widths_field);

    PositionStatusBar();
}

void wxFrameBase::PushStatusText(const wxString& text, int number)
{
    wxCHECK_RET( m_frameStatusBar != NULL, wxT("no statusbar to set text for") );

    m_frameStatusBar->PushStatusText(text, number);
}

void wxFrameBase::PopStatusText(int number)
{
    wxCHECK_RET( m_frameStatusBar != NULL, wxT("no statusbar to set text for") );

    m_frameStatusBar->PopStatusText(number);
}

bool wxFrameBase::ShowMenuHelp(int menuId)
{
#if wxUSE_MENUS
    // if no help string found, we will clear the status bar text
    //
    // NB: wxID_NONE is used for (sub)menus themselves by wxMSW
    wxString helpString;
    if ( menuId != wxID_SEPARATOR && menuId != wxID_NONE )
    {
        const wxMenuItem * const item = FindItemInMenuBar(menuId);
        if ( item && !item->IsSeparator() )
            helpString = item->GetHelp();

        // notice that it's ok if we don't find the item because it might
        // belong to the popup menu, so don't assert here
    }

    DoGiveHelp(helpString, true);

    return !helpString.empty();
#else // !wxUSE_MENUS
    return false;
#endif // wxUSE_MENUS/!wxUSE_MENUS
}

void wxFrameBase::SetStatusBar(wxStatusBar *statBar)
{
    bool hadBar = m_frameStatusBar != NULL;
    m_frameStatusBar = statBar;

    if ( (m_frameStatusBar != NULL) != hadBar )
    {
        PositionStatusBar();

        DoLayout();
    }
}

#endif // wxUSE_STATUSBAR

#if wxUSE_MENUS || wxUSE_TOOLBAR
void wxFrameBase::DoGiveHelp(const wxString& help, bool show)
{
#if wxUSE_STATUSBAR
    if ( m_statusBarPane < 0 )
    {
        // status bar messages disabled
        return;
    }

    wxStatusBar *statbar = GetStatusBar();
    if ( !statbar )
        return;

    wxString text;
    if ( show )
    {
        // remember the old status bar text if this is the first time we're
        // called since the menu has been opened as we're going to overwrite it
        // in our DoGiveHelp() and we want to restore it when the menu is
        // closed
        //
        // note that it would be logical to do this in OnMenuOpen() but under
        // MSW we get an EVT_MENU_HIGHLIGHT before EVT_MENU_OPEN, strangely
        // enough, and so this doesn't work and instead we use the ugly trick
        // with using special m_oldStatusText value as "menu opened" (but it is
        // arguably better than adding yet another member variable to wxFrame
        // on all platforms)
        if ( m_oldStatusText.empty() )
        {
            m_oldStatusText = statbar->GetStatusText(m_statusBarPane);
            if ( m_oldStatusText.empty() )
            {
                // use special value to prevent us from doing this the next time
                m_oldStatusText += wxT('\0');
            }
        }

        m_lastHelpShown =
        text = help;
    }
    else // hide help, restore the original text
    {
        // clear the last shown help string but remember its value
        wxString lastHelpShown;
        lastHelpShown.swap(m_lastHelpShown);

        // also clear the old status text but remember it too to restore it
        // below
        text.swap(m_oldStatusText);

        if ( statbar->GetStatusText(m_statusBarPane) != lastHelpShown )
        {
            // if the text was changed with an explicit SetStatusText() call
            // from the user code in the meanwhile, do not overwrite it with
            // the old status bar contents -- this is almost certainly not what
            // the user expects and would be very hard to avoid from user code
            return;
        }
    }

    statbar->SetStatusText(text, m_statusBarPane);
#else
    wxUnusedVar(help);
    wxUnusedVar(show);
#endif // wxUSE_STATUSBAR
}
#endif // wxUSE_MENUS || wxUSE_TOOLBAR


// ----------------------------------------------------------------------------
// toolbar stuff
// ----------------------------------------------------------------------------

#if wxUSE_TOOLBAR

wxToolBar* wxFrameBase::CreateToolBar(long style,
                                      wxWindowID id,
                                      const wxString& name)
{
    // the main toolbar can't be recreated (unless it was explicitly deleted
    // before)
    wxCHECK_MSG( !m_frameToolBar, NULL,
                 wxT("recreating toolbar in wxFrame") );

    if ( style == -1 )
    {
        // use default style
        //
        // NB: we don't specify the default value in the method declaration
        //     because
        //      a) this allows us to have different defaults for different
        //         platforms (even if we don't have them right now)
        //      b) we don't need to include wx/toolbar.h in the header then
        style = wxBORDER_NONE | wxTB_HORIZONTAL | wxTB_FLAT;
    }

    SetToolBar(OnCreateToolBar(style, id, name));

    return m_frameToolBar;
}

wxToolBar* wxFrameBase::OnCreateToolBar(long style,
                                        wxWindowID id,
                                        const wxString& name)
{
#if defined(__WXWINCE__) && defined(__POCKETPC__)
    return new wxToolMenuBar(this, id,
                         wxDefaultPosition, wxDefaultSize,
                         style, name);
#else
    return new wxToolBar(this, id,
                         wxDefaultPosition, wxDefaultSize,
                         style, name);
#endif
}

void wxFrameBase::SetToolBar(wxToolBar *toolbar)
{
    if ( (toolbar != NULL) != (m_frameToolBar != NULL) )
    {
        // the toolbar visibility must have changed so we need to both position
        // the toolbar itself (if it appeared) and to relayout the frame
        // contents in any case

        if ( toolbar )
        {
            // we need to assign it to m_frameToolBar for PositionToolBar() to
            // do anything
            m_frameToolBar = toolbar;
            PositionToolBar();
        }
        //else: tricky: do not reset m_frameToolBar yet as otherwise DoLayout()
        //      wouldn't recognize the (still existing) toolbar as one of our
        //      bars and wouldn't layout the single child of the frame correctly


        // and this is even more tricky: we want DoLayout() to recognize the
        // old toolbar for the purpose of not counting it among our non-bar
        // children but we don't want to reserve any more space for it so we
        // temporarily hide it
        if ( m_frameToolBar )
            m_frameToolBar->Hide();

        DoLayout();

        if ( m_frameToolBar )
            m_frameToolBar->Show();
    }

    // this might have been already done above but it's simpler to just always
    // do it unconditionally instead of testing for whether we already did it
    m_frameToolBar = toolbar;
}

#endif // wxUSE_TOOLBAR

// ----------------------------------------------------------------------------
// menus
// ----------------------------------------------------------------------------

#if wxUSE_MENUS

// update all menus
void wxFrameBase::DoMenuUpdates(wxMenu* menu)
{
    if (menu)
    {
        wxEvtHandler* source = GetEventHandler();
        menu->UpdateUI(source);
    }
    else
    {
        wxMenuBar* bar = GetMenuBar();
        if (bar != NULL)
            bar->UpdateMenus();
    }
}

void wxFrameBase::DetachMenuBar()
{
    if ( m_frameMenuBar )
    {
        m_frameMenuBar->Detach();
        m_frameMenuBar = NULL;
    }
}

void wxFrameBase::AttachMenuBar(wxMenuBar *menubar)
{
    if ( menubar )
    {
        menubar->Attach((wxFrame *)this);
        m_frameMenuBar = menubar;
    }
}

void wxFrameBase::SetMenuBar(wxMenuBar *menubar)
{
    if ( menubar == GetMenuBar() )
    {
        // nothing to do
        return;
    }

    DetachMenuBar();

    this->AttachMenuBar(menubar);
}

wxMenuItem *wxFrameBase::FindItemInMenuBar(int menuId) const
{
    const wxMenuBar * const menuBar = GetMenuBar();

    return menuBar ? menuBar->FindItem(menuId) : NULL;
}

#endif // wxUSE_MENUS
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	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$
	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	extern WXDLLEXPORT_DATA(const char) wxFrameNameStr[] = "frame";
	37	extern WXDLLEXPORT_DATA(const char) wxStatusLineNameStr[] = "status_line";
	38
	39	// ----------------------------------------------------------------------------
	40	// event table
	41	// ----------------------------------------------------------------------------
	42
	43	#if wxUSE_MENUS && wxUSE_STATUSBAR
	44
	45	BEGIN_EVENT_TABLE(wxFrameBase, wxTopLevelWindow)
	46	EVT_MENU_OPEN(wxFrameBase::OnMenuOpen)
	47	EVT_MENU_CLOSE(wxFrameBase::OnMenuClose)
	48
	49	EVT_MENU_HIGHLIGHT_ALL(wxFrameBase::OnMenuHighlight)
	50	END_EVENT_TABLE()
	51
	52	#endif // wxUSE_MENUS && wxUSE_STATUSBAR
	53
	54	// ============================================================================
	55	// implementation
	56	// ============================================================================
	57
	58	// ----------------------------------------------------------------------------
	59	// XTI
	60	// ----------------------------------------------------------------------------
	61
	62	wxDEFINE_FLAGS( wxFrameStyle )
	63	wxBEGIN_FLAGS( wxFrameStyle )
	64	// new style border flags, we put them first to
	65	// use them for streaming out
	66	wxFLAGS_MEMBER(wxBORDER_SIMPLE)
	67	wxFLAGS_MEMBER(wxBORDER_SUNKEN)
	68	wxFLAGS_MEMBER(wxBORDER_DOUBLE)
	69	wxFLAGS_MEMBER(wxBORDER_RAISED)
	70	wxFLAGS_MEMBER(wxBORDER_STATIC)
	71	wxFLAGS_MEMBER(wxBORDER_NONE)
	72
	73	// old style border flags
	74	wxFLAGS_MEMBER(wxSIMPLE_BORDER)
	75	wxFLAGS_MEMBER(wxSUNKEN_BORDER)
	76	wxFLAGS_MEMBER(wxDOUBLE_BORDER)
	77	wxFLAGS_MEMBER(wxRAISED_BORDER)
	78	wxFLAGS_MEMBER(wxSTATIC_BORDER)
	79	wxFLAGS_MEMBER(wxBORDER)
	80
	81	// standard window styles
	82	wxFLAGS_MEMBER(wxTAB_TRAVERSAL)
	83	wxFLAGS_MEMBER(wxCLIP_CHILDREN)
	84	wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW)
	85	wxFLAGS_MEMBER(wxWANTS_CHARS)
	86	wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE)
	87	wxFLAGS_MEMBER(wxALWAYS_SHOW_SB )
	88	wxFLAGS_MEMBER(wxVSCROLL)
	89	wxFLAGS_MEMBER(wxHSCROLL)
	90
	91	// frame styles
	92	wxFLAGS_MEMBER(wxSTAY_ON_TOP)
	93	wxFLAGS_MEMBER(wxCAPTION)
	94	#if WXWIN_COMPATIBILITY_2_6
	95	wxFLAGS_MEMBER(wxTHICK_FRAME)
	96	#endif // WXWIN_COMPATIBILITY_2_6
	97	wxFLAGS_MEMBER(wxSYSTEM_MENU)
	98	wxFLAGS_MEMBER(wxRESIZE_BORDER)
	99	#if WXWIN_COMPATIBILITY_2_6
	100	wxFLAGS_MEMBER(wxRESIZE_BOX)
	101	#endif // WXWIN_COMPATIBILITY_2_6
	102	wxFLAGS_MEMBER(wxCLOSE_BOX)
	103	wxFLAGS_MEMBER(wxMAXIMIZE_BOX)
	104	wxFLAGS_MEMBER(wxMINIMIZE_BOX)
	105
	106	wxFLAGS_MEMBER(wxFRAME_TOOL_WINDOW)
	107	wxFLAGS_MEMBER(wxFRAME_FLOAT_ON_PARENT)
	108
	109	wxFLAGS_MEMBER(wxFRAME_SHAPED)
	110	wxEND_FLAGS( wxFrameStyle )
	111
	112	wxIMPLEMENT_DYNAMIC_CLASS_XTI(wxFrame, wxTopLevelWindow, "wx/frame.h")
	113
	114	wxBEGIN_PROPERTIES_TABLE(wxFrame)
	115	wxEVENT_PROPERTY( Menu, wxEVT_COMMAND_MENU_SELECTED, wxCommandEvent)
	116
	117	wxPROPERTY( Title,wxString, SetTitle, GetTitle, wxString(), 0 /flags/, \
	118	wxT("Helpstring"), wxT("group"))
	119	wxPROPERTY_FLAGS( WindowStyle, wxFrameStyle, long, SetWindowStyleFlag, \
	120	GetWindowStyleFlag, wxEMPTY_PARAMETER_VALUE, 0 /flags/, \
	121	wxT("Helpstring"), wxT("group")) // style
	122	wxPROPERTY( MenuBar, wxMenuBar *, SetMenuBar, GetMenuBar, wxEMPTY_PARAMETER_VALUE, \
	123	0 /flags/, wxT("Helpstring"), wxT("group"))
	124	wxEND_PROPERTIES_TABLE()
	125
	126	wxEMPTY_HANDLERS_TABLE(wxFrame)
	127
	128	wxCONSTRUCTOR_6( wxFrame, wxWindow*, Parent, wxWindowID, Id, wxString, Title, \
	129	wxPoint, Position, wxSize, Size, long, WindowStyle)
	130
	131	// ----------------------------------------------------------------------------
	132	// construction/destruction
	133	// ----------------------------------------------------------------------------
	134
	135	wxFrameBase::wxFrameBase()
	136	{
	137	#if wxUSE_MENUS
	138	m_frameMenuBar = NULL;
	139	#endif // wxUSE_MENUS
	140
	141	#if wxUSE_TOOLBAR
	142	m_frameToolBar = NULL;
	143	#endif // wxUSE_TOOLBAR
	144
	145	#if wxUSE_STATUSBAR
	146	m_frameStatusBar = NULL;
	147	#endif // wxUSE_STATUSBAR
	148
	149	m_statusBarPane = 0;
	150	}
	151
	152	wxFrameBase::~wxFrameBase()
	153	{
	154	// this destructor is required for Darwin
	155	}
	156
	157	wxFrame wxFrameBase::New(wxWindow parent,
	158	wxWindowID id,
	159	const wxString& title,
	160	const wxPoint& pos,
	161	const wxSize& size,
	162	long style,
	163	const wxString& name)
	164	{
	165	return new wxFrame(parent, id, title, pos, size, style, name);
	166	}
	167
	168	void wxFrameBase::DeleteAllBars()
	169	{
	170	#if wxUSE_MENUS
	171	wxDELETE(m_frameMenuBar);
	172	#endif // wxUSE_MENUS
	173
	174	#if wxUSE_STATUSBAR
	175	wxDELETE(m_frameStatusBar);
	176	#endif // wxUSE_STATUSBAR
	177
	178	#if wxUSE_TOOLBAR
	179	wxDELETE(m_frameToolBar);
	180	#endif // wxUSE_TOOLBAR
	181	}
	182
	183	bool wxFrameBase::IsOneOfBars(const wxWindow *win) const
	184	{
	185	#if wxUSE_MENUS
	186	if ( win == GetMenuBar() )
	187	return true;
	188	#endif // wxUSE_MENUS
	189
	190	#if wxUSE_STATUSBAR
	191	if ( win == GetStatusBar() )
	192	return true;
	193	#endif // wxUSE_STATUSBAR
	194
	195	#if wxUSE_TOOLBAR
	196	if ( win == GetToolBar() )
	197	return true;
	198	#endif // wxUSE_TOOLBAR
	199
	200	wxUnusedVar(win);
	201
	202	return false;
	203	}
	204
	205	// ----------------------------------------------------------------------------
	206	// wxFrame size management: we exclude the areas taken by menu/status/toolbars
	207	// from the client area, so the client area is what's really available for the
	208	// frame contents
	209	// ----------------------------------------------------------------------------
	210
	211	// get the origin of the client area in the client coordinates
	212	wxPoint wxFrameBase::GetClientAreaOrigin() const
	213	{
	214	wxPoint pt = wxTopLevelWindow::GetClientAreaOrigin();
	215
	216	#if wxUSE_TOOLBAR && !defined(__WXUNIVERSAL__)
	217	wxToolBar *toolbar = GetToolBar();
	218	if ( toolbar && toolbar->IsShown() )
	219	{
	220	int w, h;
	221	toolbar->GetSize(&w, &h);
	222
	223	if ( toolbar->GetWindowStyleFlag() & wxTB_VERTICAL )
	224	{
	225	pt.x += w;
	226	}
	227	else
	228	{
	229	pt.y += h;
	230	}
	231	}
	232	#endif // wxUSE_TOOLBAR
	233
	234	return pt;
	235	}
	236
	237	// ----------------------------------------------------------------------------
	238	// misc
	239	// ----------------------------------------------------------------------------
	240
	241	#if wxUSE_MENUS
	242
	243	bool wxFrameBase::ProcessCommand(int id)
	244	{
	245	wxMenuBar *bar = GetMenuBar();
	246	if ( !bar )
	247	return false;
	248
	249	wxMenuItem *item = bar->FindItem(id);
	250	if ( !item )
	251	return false;
	252
	253	return ProcessCommand(item);
	254	}
	255
	256	bool wxFrameBase::ProcessCommand(wxMenuItem *item)
	257	{
	258	wxCommandEvent commandEvent(wxEVT_COMMAND_MENU_SELECTED, item->GetId());
	259	commandEvent.SetEventObject(this);
	260
	261	if (!item->IsEnabled())
	262	return true;
	263
	264	if ((item->GetKind() == wxITEM_RADIO) && item->IsChecked() )
	265	return true;
	266
	267	if (item->IsCheckable())
	268	{
	269	item->Toggle();
	270
	271	// use the new value
	272	commandEvent.SetInt(item->IsChecked());
	273	}
	274
	275	return HandleWindowEvent(commandEvent);
	276	}
	277
	278	#endif // wxUSE_MENUS
	279
	280	// Do the UI update processing for this window. This is
	281	// provided for the application to call if it wants to
	282	// force a UI update, particularly for the menus and toolbar.
	283	void wxFrameBase::UpdateWindowUI(long flags)
	284	{
	285	wxWindowBase::UpdateWindowUI(flags);
	286
	287	#if wxUSE_TOOLBAR
	288	if (GetToolBar())
	289	GetToolBar()->UpdateWindowUI(flags);
	290	#endif
	291
	292	#if wxUSE_MENUS
	293	if (GetMenuBar())
	294	{
	295	// If coming from an idle event, we only want to update the menus if
	296	// we're in the wxUSE_IDLEMENUUPDATES configuration, otherwise they
	297	// will be update when the menu is opened later
	298	#if !wxUSE_IDLEMENUUPDATES
	299	if ( !(flags & wxUPDATE_UI_FROMIDLE) )
	300	#endif // wxUSE_IDLEMENUUPDATES
	301	DoMenuUpdates();
	302	}
	303	#endif // wxUSE_MENUS
	304	}
	305
	306	// ----------------------------------------------------------------------------
	307	// event handlers for status bar updates from menus
	308	// ----------------------------------------------------------------------------
	309
	310	#if wxUSE_MENUS && wxUSE_STATUSBAR
	311
	312	void wxFrameBase::OnMenuHighlight(wxMenuEvent& event)
	313	{
	314	#if wxUSE_STATUSBAR
	315	(void)ShowMenuHelp(event.GetMenuId());
	316	#endif // wxUSE_STATUSBAR
	317	}
	318
	319	void wxFrameBase::OnMenuOpen(wxMenuEvent& event)
	320	{
	321	#if wxUSE_IDLEMENUUPDATES
	322	wxUnusedVar(event);
	323	#else // !wxUSE_IDLEMENUUPDATES
	324	// as we didn't update the menus from idle time, do it now
	325	DoMenuUpdates(event.GetMenu());
	326	#endif // wxUSE_IDLEMENUUPDATES/!wxUSE_IDLEMENUUPDATES
	327	}
	328
	329	void wxFrameBase::OnMenuClose(wxMenuEvent& WXUNUSED(event))
	330	{
	331	DoGiveHelp(wxEmptyString, false);
	332	}
	333
	334	#endif // wxUSE_MENUS && wxUSE_STATUSBAR
	335
	336	// Implement internal behaviour (menu updating on some platforms)
	337	void wxFrameBase::OnInternalIdle()
	338	{
	339	wxTopLevelWindow::OnInternalIdle();
	340
	341	#if wxUSE_MENUS && wxUSE_IDLEMENUUPDATES
	342	if (wxUpdateUIEvent::CanUpdate(this))
	343	DoMenuUpdates();
	344	#endif
	345	}
	346
	347	// ----------------------------------------------------------------------------
	348	// status bar stuff
	349	// ----------------------------------------------------------------------------
	350
	351	#if wxUSE_STATUSBAR
	352
	353	wxStatusBar* wxFrameBase::CreateStatusBar(int number,
	354	long style,
	355	wxWindowID id,
	356	const wxString& name)
	357	{
	358	// the main status bar can only be created once (or else it should be
	359	// deleted before calling CreateStatusBar() again)
	360	wxCHECK_MSG( !m_frameStatusBar, NULL,
	361	wxT("recreating status bar in wxFrame") );
	362
	363	SetStatusBar(OnCreateStatusBar(number, style, id, name));
	364
	365	return m_frameStatusBar;
	366	}
	367
	368	wxStatusBar *wxFrameBase::OnCreateStatusBar(int number,
	369	long style,
	370	wxWindowID id,
	371	const wxString& name)
	372	{
	373	wxStatusBar *statusBar = new wxStatusBar(this, id, style, name);
	374
	375	statusBar->SetFieldsCount(number);
	376
	377	return statusBar;
	378	}
	379
	380	void wxFrameBase::SetStatusText(const wxString& text, int number)
	381	{
	382	wxCHECK_RET( m_frameStatusBar != NULL, wxT("no statusbar to set text for") );
	383
	384	m_frameStatusBar->SetStatusText(text, number);
	385	}
	386
	387	void wxFrameBase::SetStatusWidths(int n, const int widths_field[] )
	388	{
	389	wxCHECK_RET( m_frameStatusBar != NULL, wxT("no statusbar to set widths for") );
	390
	391	m_frameStatusBar->SetStatusWidths(n, widths_field);
	392
	393	PositionStatusBar();
	394	}
	395
	396	void wxFrameBase::PushStatusText(const wxString& text, int number)
	397	{
	398	wxCHECK_RET( m_frameStatusBar != NULL, wxT("no statusbar to set text for") );
	399
	400	m_frameStatusBar->PushStatusText(text, number);
	401	}
	402
	403	void wxFrameBase::PopStatusText(int number)
	404	{
	405	wxCHECK_RET( m_frameStatusBar != NULL, wxT("no statusbar to set text for") );
	406
	407	m_frameStatusBar->PopStatusText(number);
	408	}
	409
	410	bool wxFrameBase::ShowMenuHelp(int menuId)
	411	{
	412	#if wxUSE_MENUS
	413	// if no help string found, we will clear the status bar text
	414	//
	415	// NB: wxID_NONE is used for (sub)menus themselves by wxMSW
	416	wxString helpString;
	417	if ( menuId != wxID_SEPARATOR && menuId != wxID_NONE )
	418	{
	419	const wxMenuItem * const item = FindItemInMenuBar(menuId);
	420	if ( item && !item->IsSeparator() )
	421	helpString = item->GetHelp();
	422
	423	// notice that it's ok if we don't find the item because it might
	424	// belong to the popup menu, so don't assert here
	425	}
	426
	427	DoGiveHelp(helpString, true);
	428
	429	return !helpString.empty();
	430	#else // !wxUSE_MENUS
	431	return false;
	432	#endif // wxUSE_MENUS/!wxUSE_MENUS
	433	}
	434
	435	void wxFrameBase::SetStatusBar(wxStatusBar *statBar)
	436	{
	437	bool hadBar = m_frameStatusBar != NULL;
	438	m_frameStatusBar = statBar;
	439
	440	if ( (m_frameStatusBar != NULL) != hadBar )
	441	{
	442	PositionStatusBar();
	443
	444	DoLayout();
	445	}
	446	}
	447
	448	#endif // wxUSE_STATUSBAR
	449
	450	#if wxUSE_MENUS \|\| wxUSE_TOOLBAR
	451	void wxFrameBase::DoGiveHelp(const wxString& help, bool show)
	452	{
	453	#if wxUSE_STATUSBAR
	454	if ( m_statusBarPane < 0 )
	455	{
	456	// status bar messages disabled
	457	return;
	458	}
	459
	460	wxStatusBar *statbar = GetStatusBar();
	461	if ( !statbar )
	462	return;
	463
	464	wxString text;
	465	if ( show )
	466	{
	467	// remember the old status bar text if this is the first time we're
	468	// called since the menu has been opened as we're going to overwrite it
	469	// in our DoGiveHelp() and we want to restore it when the menu is
	470	// closed
	471	//
	472	// note that it would be logical to do this in OnMenuOpen() but under
	473	// MSW we get an EVT_MENU_HIGHLIGHT before EVT_MENU_OPEN, strangely
	474	// enough, and so this doesn't work and instead we use the ugly trick
	475	// with using special m_oldStatusText value as "menu opened" (but it is
	476	// arguably better than adding yet another member variable to wxFrame
	477	// on all platforms)
	478	if ( m_oldStatusText.empty() )
	479	{
	480	m_oldStatusText = statbar->GetStatusText(m_statusBarPane);
	481	if ( m_oldStatusText.empty() )
	482	{
	483	// use special value to prevent us from doing this the next time
	484	m_oldStatusText += wxT('\0');
	485	}
	486	}
	487
	488	m_lastHelpShown =
	489	text = help;
	490	}
	491	else // hide help, restore the original text
	492	{
	493	// clear the last shown help string but remember its value
	494	wxString lastHelpShown;
	495	lastHelpShown.swap(m_lastHelpShown);
	496
	497	// also clear the old status text but remember it too to restore it
	498	// below
	499	text.swap(m_oldStatusText);
	500
	501	if ( statbar->GetStatusText(m_statusBarPane) != lastHelpShown )
	502	{
	503	// if the text was changed with an explicit SetStatusText() call
	504	// from the user code in the meanwhile, do not overwrite it with
	505	// the old status bar contents -- this is almost certainly not what
	506	// the user expects and would be very hard to avoid from user code
	507	return;
	508	}
	509	}
	510
	511	statbar->SetStatusText(text, m_statusBarPane);
	512	#else
	513	wxUnusedVar(help);
	514	wxUnusedVar(show);
	515	#endif // wxUSE_STATUSBAR
	516	}
	517	#endif // wxUSE_MENUS \|\| wxUSE_TOOLBAR
	518
	519
	520	// ----------------------------------------------------------------------------
	521	// toolbar stuff
	522	// ----------------------------------------------------------------------------
	523
	524	#if wxUSE_TOOLBAR
	525
	526	wxToolBar* wxFrameBase::CreateToolBar(long style,
	527	wxWindowID id,
	528	const wxString& name)
	529	{
	530	// the main toolbar can't be recreated (unless it was explicitly deleted
	531	// before)
	532	wxCHECK_MSG( !m_frameToolBar, NULL,
	533	wxT("recreating toolbar in wxFrame") );
	534
	535	if ( style == -1 )
	536	{
	537	// use default style
	538	//
	539	// NB: we don't specify the default value in the method declaration
	540	// because
	541	// a) this allows us to have different defaults for different
	542	// platforms (even if we don't have them right now)
	543	// b) we don't need to include wx/toolbar.h in the header then
	544	style = wxBORDER_NONE \| wxTB_HORIZONTAL \| wxTB_FLAT;
	545	}
	546
	547	SetToolBar(OnCreateToolBar(style, id, name));
	548
	549	return m_frameToolBar;
	550	}
	551
	552	wxToolBar* wxFrameBase::OnCreateToolBar(long style,
	553	wxWindowID id,
	554	const wxString& name)
	555	{
	556	#if defined(__WXWINCE__) && defined(__POCKETPC__)
	557	return new wxToolMenuBar(this, id,
	558	wxDefaultPosition, wxDefaultSize,
	559	style, name);
	560	#else
	561	return new wxToolBar(this, id,
	562	wxDefaultPosition, wxDefaultSize,
	563	style, name);
	564	#endif
	565	}
	566
	567	void wxFrameBase::SetToolBar(wxToolBar *toolbar)
	568	{
	569	if ( (toolbar != NULL) != (m_frameToolBar != NULL) )
	570	{
	571	// the toolbar visibility must have changed so we need to both position
	572	// the toolbar itself (if it appeared) and to relayout the frame
	573	// contents in any case
	574
	575	if ( toolbar )
	576	{
	577	// we need to assign it to m_frameToolBar for PositionToolBar() to
	578	// do anything
	579	m_frameToolBar = toolbar;
	580	PositionToolBar();
	581	}
	582	//else: tricky: do not reset m_frameToolBar yet as otherwise DoLayout()
	583	// wouldn't recognize the (still existing) toolbar as one of our
	584	// bars and wouldn't layout the single child of the frame correctly
	585
	586
	587	// and this is even more tricky: we want DoLayout() to recognize the
	588	// old toolbar for the purpose of not counting it among our non-bar
	589	// children but we don't want to reserve any more space for it so we
	590	// temporarily hide it
	591	if ( m_frameToolBar )
	592	m_frameToolBar->Hide();
	593
	594	DoLayout();
	595
	596	if ( m_frameToolBar )
	597	m_frameToolBar->Show();
	598	}
	599
	600	// this might have been already done above but it's simpler to just always
	601	// do it unconditionally instead of testing for whether we already did it
	602	m_frameToolBar = toolbar;
	603	}
	604
	605	#endif // wxUSE_TOOLBAR
	606
	607	// ----------------------------------------------------------------------------
	608	// menus
	609	// ----------------------------------------------------------------------------
	610
	611	#if wxUSE_MENUS
	612
	613	// update all menus
	614	void wxFrameBase::DoMenuUpdates(wxMenu* menu)
	615	{
	616	if (menu)
	617	{
	618	wxEvtHandler* source = GetEventHandler();
	619	menu->UpdateUI(source);
	620	}
	621	else
	622	{
	623	wxMenuBar* bar = GetMenuBar();
	624	if (bar != NULL)
	625	bar->UpdateMenus();
	626	}
	627	}
	628
	629	void wxFrameBase::DetachMenuBar()
	630	{
	631	if ( m_frameMenuBar )
	632	{
	633	m_frameMenuBar->Detach();
	634	m_frameMenuBar = NULL;
	635	}
	636	}
	637
	638	void wxFrameBase::AttachMenuBar(wxMenuBar *menubar)
	639	{
	640	if ( menubar )
	641	{
	642	menubar->Attach((wxFrame *)this);
	643	m_frameMenuBar = menubar;
	644	}
	645	}
	646
	647	void wxFrameBase::SetMenuBar(wxMenuBar *menubar)
	648	{
	649	if ( menubar == GetMenuBar() )
	650	{
	651	// nothing to do
	652	return;
	653	}
	654
	655	DetachMenuBar();
	656
	657	this->AttachMenuBar(menubar);
	658	}
	659
	660	wxMenuItem *wxFrameBase::FindItemInMenuBar(int menuId) const
	661	{
	662	const wxMenuBar * const menuBar = GetMenuBar();
	663
	664	return menuBar ? menuBar->FindItem(menuId) : NULL;
	665	}
	666
	667	#endif // wxUSE_MENUS