src/msw/frame.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        msw/frame.cpp
// Purpose:     wxFrame
// Author:      Julian Smart
// Modified by:
// Created:     01/02/97
// RCS-ID:      $Id$
// Copyright:   (c) Julian Smart and Markus Holzem
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

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

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

#ifdef __GNUG__
    #pragma implementation "frame.h"
#endif

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

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#ifndef WX_PRECOMP
    #include "wx/frame.h"
    #include "wx/app.h"
    #include "wx/menu.h"
    #include "wx/utils.h"
    #include "wx/dialog.h"
    #include "wx/settings.h"
    #include "wx/dcclient.h"
    #include "wx/mdi.h"
    #include "wx/panel.h"
#endif // WX_PRECOMP

#include "wx/msw/private.h"

#if wxUSE_STATUSBAR
    #include "wx/statusbr.h"
    #include "wx/generic/statusbr.h"
#endif // wxUSE_STATUSBAR

#if wxUSE_TOOLBAR
    #include "wx/toolbar.h"
#endif // wxUSE_TOOLBAR

#include "wx/menuitem.h"
#include "wx/log.h"

#ifdef __WXUNIVERSAL__
    #include "wx/univ/theme.h"
    #include "wx/univ/colschem.h"
#endif // __WXUNIVERSAL__

// ----------------------------------------------------------------------------
// globals
// ----------------------------------------------------------------------------

extern const wxChar *wxFrameClassName;

#if wxUSE_MENUS_NATIVE
extern wxMenu *wxCurrentPopupMenu;
#endif // wxUSE_MENUS_NATIVE

// ----------------------------------------------------------------------------
// event tables
// ----------------------------------------------------------------------------

BEGIN_EVENT_TABLE(wxFrame, wxFrameBase)
    EVT_ACTIVATE(wxFrame::OnActivate)
    EVT_SYS_COLOUR_CHANGED(wxFrame::OnSysColourChanged)
END_EVENT_TABLE()

IMPLEMENT_DYNAMIC_CLASS(wxFrame, wxWindow)

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

// ----------------------------------------------------------------------------
// static class members
// ----------------------------------------------------------------------------

#if wxUSE_STATUSBAR
    #if wxUSE_NATIVE_STATUSBAR
        bool wxFrame::m_useNativeStatusBar = TRUE;
    #else
        bool wxFrame::m_useNativeStatusBar = FALSE;
    #endif
#endif // wxUSE_NATIVE_STATUSBAR

// ----------------------------------------------------------------------------
// creation/destruction
// ----------------------------------------------------------------------------

void wxFrame::Init()
{
#if wxUSE_TOOLTIPS
    m_hwndToolTip = 0;
#endif

    // Data to save/restore when calling ShowFullScreen
    m_fsStatusBarFields = 0;
    m_fsStatusBarHeight = 0;
    m_fsToolBarHeight = 0;
//  m_fsMenu = 0;

    m_wasMinimized = FALSE;

    m_winLastFocused = (wxWindow *)NULL;
}

bool wxFrame::Create(wxWindow *parent,
                     wxWindowID id,
                     const wxString& title,
                     const wxPoint& pos,
                     const wxSize& size,
                     long style,
                     const wxString& name)
{
    if ( !wxTopLevelWindow::Create(parent, id, title, pos, size, style, name) )
        return FALSE;

    SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_APPWORKSPACE));

    wxModelessWindows.Append(this);

    return TRUE;
}

wxFrame::~wxFrame()
{
    m_isBeingDeleted = TRUE;

    DeleteAllBars();
}

// Get size *available for subwindows* i.e. excluding menu bar, toolbar etc.
void wxFrame::DoGetClientSize(int *x, int *y) const
{
  RECT rect;
  ::GetClientRect(GetHwnd(), &rect);

#if wxUSE_STATUSBAR
  if ( GetStatusBar() && GetStatusBar()->IsShown() )
  {
    int statusX, statusY;
    GetStatusBar()->GetClientSize(&statusX, &statusY);
    rect.bottom -= statusY;
  }
#endif // wxUSE_STATUSBAR

  wxPoint pt(GetClientAreaOrigin());
  rect.bottom -= pt.y;
  rect.right -= pt.x;

  if ( x )
    *x = rect.right;
  if ( y )
    *y = rect.bottom;
}

void wxFrame::DoSetClientSize(int width, int height)
{
    // leave enough space for the status bar if we have (and show) it
#if wxUSE_STATUSBAR
    wxStatusBar *statbar = GetStatusBar();
    if ( statbar && statbar->IsShown() )
    {
        height += statbar->GetSize().y;
    }
#endif // wxUSE_STATUSBAR

    wxTopLevelWindow::DoSetClientSize(width, height);
}

// ----------------------------------------------------------------------------
// wxFrame: various geometry-related functions
// ----------------------------------------------------------------------------

void wxFrame::Raise()
{
#ifdef __WIN16__
    // no SetForegroundWindow() in Win16
    wxFrameBase::Raise();
#else // Win32
    ::SetForegroundWindow(GetHwnd());
#endif // Win16/32
}

// generate an artificial resize event
void wxFrame::SendSizeEvent()
{
    if ( !m_iconized )
    {
        RECT r = wxGetWindowRect(GetHwnd());

        (void)::PostMessage(GetHwnd(), WM_SIZE,
                            IsMaximized() ? SIZE_MAXIMIZED : SIZE_RESTORED,
                            MAKELPARAM(r.right - r.left, r.bottom - r.top));
    }
}

#if wxUSE_STATUSBAR
wxStatusBar *wxFrame::OnCreateStatusBar(int number,
                                        long style,
                                        wxWindowID id,
                                        const wxString& name)
{
    wxStatusBar *statusBar = NULL;

#if wxUSE_NATIVE_STATUSBAR
    if ( !UsesNativeStatusBar() )
    {
        statusBar = (wxStatusBar *)new wxStatusBarGeneric(this, id, style);
    }
    else
#endif
    {
        statusBar = new wxStatusBar(this, id, style, name);
    }

    statusBar->SetFieldsCount(number);

    return statusBar;
}

void wxFrame::PositionStatusBar()
{
    if ( !m_frameStatusBar )
        return;

    int w, h;
    GetClientSize(&w, &h);
    int sw, sh;
    m_frameStatusBar->GetSize(&sw, &sh);

    // Since we wish the status bar to be directly under the client area,
    // we use the adjusted sizes without using wxSIZE_NO_ADJUSTMENTS.
    m_frameStatusBar->SetSize(0, h, w, sh);
}
#endif // wxUSE_STATUSBAR

#if wxUSE_MENUS_NATIVE

void wxFrame::AttachMenuBar(wxMenuBar *menubar)
{
    wxFrameBase::AttachMenuBar(menubar);

    if ( !menubar )
    {
        // actually remove the menu from the frame
        m_hMenu = (WXHMENU)0;
        InternalSetMenuBar();
    }
    else // set new non NULL menu bar
    {
        // Can set a menubar several times.
        if ( menubar->GetHMenu() )
        {
            m_hMenu = menubar->GetHMenu();
        }
        else // no HMENU yet
        {
            m_hMenu = menubar->Create();

            if ( !m_hMenu )
            {
                wxFAIL_MSG( _T("failed to create menu bar") );
                return;
            }
        }

        InternalSetMenuBar();
    }
}

void wxFrame::InternalSetMenuBar()
{
#ifndef __WXMICROWIN__
    if ( !::SetMenu(GetHwnd(), (HMENU)m_hMenu) )
    {
        wxLogLastError(wxT("SetMenu"));
    }
#endif
}

#endif // wxUSE_MENUS_NATIVE

// Responds to colour changes, and passes event on to children.
void wxFrame::OnSysColourChanged(wxSysColourChangedEvent& event)
{
    SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_APPWORKSPACE));
    Refresh();

#if wxUSE_STATUSBAR
    if ( m_frameStatusBar )
    {
        wxSysColourChangedEvent event2;
        event2.SetEventObject( m_frameStatusBar );
        m_frameStatusBar->GetEventHandler()->ProcessEvent(event2);
    }
#endif // wxUSE_STATUSBAR

    // Propagate the event to the non-top-level children
    wxWindow::OnSysColourChanged(event);
}

// Pass TRUE to show full screen, FALSE to restore.
bool wxFrame::ShowFullScreen(bool show, long style)
{
    if ( IsFullScreen() == show )
        return FALSE;

    if (show)
    {
#if wxUSE_TOOLBAR
        wxToolBar *theToolBar = GetToolBar();
        if (theToolBar)
            theToolBar->GetSize(NULL, &m_fsToolBarHeight);

        // zap the toolbar, menubar, and statusbar

        if ((style & wxFULLSCREEN_NOTOOLBAR) && theToolBar)
        {
            theToolBar->SetSize(-1,0);
            theToolBar->Show(FALSE);
        }
#endif // wxUSE_TOOLBAR

#ifndef __WXMICROWIN__
        if (style & wxFULLSCREEN_NOMENUBAR)
            SetMenu((HWND)GetHWND(), (HMENU) NULL);
#endif

#if wxUSE_STATUSBAR
        wxStatusBar *theStatusBar = GetStatusBar();
        if (theStatusBar)
            theStatusBar->GetSize(NULL, &m_fsStatusBarHeight);

        // Save the number of fields in the statusbar
        if ((style & wxFULLSCREEN_NOSTATUSBAR) && theStatusBar)
        {
            //m_fsStatusBarFields = theStatusBar->GetFieldsCount();
            //SetStatusBar((wxStatusBar*) NULL);
            //delete theStatusBar;
            theStatusBar->Show(FALSE);
        }
        else
            m_fsStatusBarFields = 0;
#endif // wxUSE_STATUSBAR
    }
    else
    {
#if wxUSE_TOOLBAR
        wxToolBar *theToolBar = GetToolBar();

        // restore the toolbar, menubar, and statusbar
        if (theToolBar && (m_fsStyle & wxFULLSCREEN_NOTOOLBAR))
        {
            theToolBar->SetSize(-1, m_fsToolBarHeight);
            theToolBar->Show(TRUE);
        }
#endif // wxUSE_TOOLBAR

#if wxUSE_STATUSBAR
        if ( m_fsStyle & wxFULLSCREEN_NOSTATUSBAR )
        {
            //CreateStatusBar(m_fsStatusBarFields);
            if (GetStatusBar())
            {
                GetStatusBar()->Show(TRUE);
                PositionStatusBar();
            }
        }
#endif // wxUSE_STATUSBAR

#ifndef __WXMICROWIN__
        if ((m_fsStyle & wxFULLSCREEN_NOMENUBAR) && (m_hMenu != 0))
            SetMenu((HWND)GetHWND(), (HMENU)m_hMenu);
#endif
    }

    return wxFrameBase::ShowFullScreen(show, style);
}

// Default activation behaviour - set the focus for the first child
// subwindow found.
void wxFrame::OnActivate(wxActivateEvent& event)
{
    if ( event.GetActive() )
    {
        // restore focus to the child which was last focused
        wxLogTrace(_T("focus"), _T("wxFrame %08x activated."), m_hWnd);

        wxWindow *parent = m_winLastFocused ? m_winLastFocused->GetParent()
                                            : NULL;
        if ( !parent )
        {
            parent = this;
        }

        wxSetFocusToChild(parent, &m_winLastFocused);
    }
    else // deactivating
    {
        // remember the last focused child if it is our child
        m_winLastFocused = FindFocus();

        // so we NULL it out if it's a child from some other frame
        wxWindow *win = m_winLastFocused;
        while ( win )
        {
            if ( win->IsTopLevel() )
            {
                if ( win != this )
                {
                    m_winLastFocused = NULL;
                }

                break;
            }

            win = win->GetParent();
        }

        wxLogTrace(_T("focus"),
                   _T("wxFrame %08x deactivated, last focused: %08x."),
                   m_hWnd,
                   m_winLastFocused ? GetHwndOf(m_winLastFocused)
                                    : NULL);

        event.Skip();
    }
}

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

#if wxUSE_TOOLBAR

wxToolBar* wxFrame::CreateToolBar(long style, wxWindowID id, const wxString& name)
{
    if ( wxFrameBase::CreateToolBar(style, id, name) )
    {
        PositionToolBar();
    }

    return m_frameToolBar;
}

void wxFrame::PositionToolBar()
{
    RECT rect;
    ::GetClientRect(GetHwnd(), &rect);

#if wxUSE_STATUSBAR
    if ( GetStatusBar() )
    {
        int statusX, statusY;
        GetStatusBar()->GetClientSize(&statusX, &statusY);
        rect.bottom -= statusY;
    }
#endif // wxUSE_STATUSBAR

    if ( GetToolBar() && GetToolBar()->IsShown() )
    {
        int tw, th;
        GetToolBar()->GetSize(&tw, &th);

        if ( GetToolBar()->GetWindowStyleFlag() & wxTB_VERTICAL )
        {
            th = rect.bottom;
        }
        else
        {
            tw = rect.right;
        }

        // Use the 'real' MSW position here
        GetToolBar()->SetSize(0, 0, tw, th, wxSIZE_NO_ADJUSTMENTS);
    }
}
#endif // wxUSE_TOOLBAR

// ----------------------------------------------------------------------------
// frame state (iconized/maximized/...)
// ----------------------------------------------------------------------------

// propagate our state change to all child frames: this allows us to emulate X
// Windows behaviour where child frames float independently of the parent one
// on the desktop, but are iconized/restored with it
void wxFrame::IconizeChildFrames(bool bIconize)
{
    for ( wxWindowList::Node *node = GetChildren().GetFirst();
          node;
          node = node->GetNext() )
    {
        wxWindow *win = node->GetData();

        // iconizing the frames with this style under Win95 shell puts them at
        // the bottom of the screen (as the MDI children) instead of making
        // them appear in the taskbar because they are, by virtue of this
        // style, not managed by the taskbar - instead leave Windows take care
        // of them
#ifdef __WIN95__
        if ( win->GetWindowStyle() & wxFRAME_TOOL_WINDOW )
            continue;
#endif // Win95

        // the child MDI frames are a special case and should not be touched by
        // the parent frame - instead, they are managed by the user
        wxFrame *frame = wxDynamicCast(win, wxFrame);
        if ( frame
#if wxUSE_MDI_ARCHITECTURE
                && !wxDynamicCast(frame, wxMDIChildFrame)
#endif // wxUSE_MDI_ARCHITECTURE
           )
        {
            // we don't want to restore the child frames which had been
            // iconized even before we were iconized, so save the child frame
            // status when iconizing the parent frame and check it when
            // restoring it
            if ( bIconize )
            {
                frame->m_wasMinimized = frame->IsIconized();
            }

            // this test works for both iconizing and restoring
            if ( !frame->m_wasMinimized )
                frame->Iconize(bIconize);
        }
    }
}

WXHICON wxFrame::GetDefaultIcon() const
{
    return (WXHICON)(wxSTD_FRAME_ICON ? wxSTD_FRAME_ICON
                                      : wxDEFAULT_FRAME_ICON);
}

// ===========================================================================
// message processing
// ===========================================================================

// ---------------------------------------------------------------------------
// preprocessing
// ---------------------------------------------------------------------------

bool wxFrame::MSWTranslateMessage(WXMSG* pMsg)
{
    if ( wxWindow::MSWTranslateMessage(pMsg) )
        return TRUE;

#if wxUSE_MENUS && wxUSE_ACCEL && !defined(__WXUNIVERSAL__)
    // try the menu bar accels
    wxMenuBar *menuBar = GetMenuBar();
    if ( !menuBar )
        return FALSE;

    const wxAcceleratorTable& acceleratorTable = menuBar->GetAccelTable();
    return acceleratorTable.Translate(this, pMsg);
#else
    return FALSE;
#endif // wxUSE_MENUS && wxUSE_ACCEL
}

// ---------------------------------------------------------------------------
// our private (non virtual) message handlers
// ---------------------------------------------------------------------------

bool wxFrame::HandlePaint()
{
    RECT rect;
    if ( GetUpdateRect(GetHwnd(), &rect, FALSE) )
    {
#ifndef __WXMICROWIN__
        if ( m_iconized )
        {
            HICON hIcon = m_icon.Ok() ? GetHiconOf(m_icon)
                                      : (HICON)GetDefaultIcon();

            // Hold a pointer to the dc so long as the OnPaint() message
            // is being processed
            PAINTSTRUCT ps;
            HDC hdc = ::BeginPaint(GetHwnd(), &ps);

            // Erase background before painting or we get white background
            MSWDefWindowProc(WM_ICONERASEBKGND, (WORD)(LONG)ps.hdc, 0L);

            if ( hIcon )
            {
                RECT rect;
                ::GetClientRect(GetHwnd(), &rect);

                // FIXME: why hardcoded?
                static const int icon_width = 32;
                static const int icon_height = 32;

                int icon_x = (int)((rect.right - icon_width)/2);
                int icon_y = (int)((rect.bottom - icon_height)/2);

                ::DrawIcon(hdc, icon_x, icon_y, hIcon);
            }

            ::EndPaint(GetHwnd(), &ps);

            return TRUE;
        }
        else
 #endif
        {
            return wxWindow::HandlePaint();
        }
    }
    else
    {
        // nothing to paint - processed
        return TRUE;
    }
}

bool wxFrame::HandleSize(int x, int y, WXUINT id)
{
    bool processed = FALSE;
#ifndef __WXMICROWIN__

    switch ( id )
    {
        case SIZENORMAL:
            // only do it it if we were iconized before, otherwise resizing the
            // parent frame has a curious side effect of bringing it under it's
            // children
            if ( !m_iconized )
                break;

            // restore all child frames too
            IconizeChildFrames(FALSE);

            (void)SendIconizeEvent(FALSE);

            // fall through

        case SIZEFULLSCREEN:
            m_iconized = FALSE;
            break;

        case SIZEICONIC:
            // iconize all child frames too
            IconizeChildFrames(TRUE);

            (void)SendIconizeEvent();

            m_iconized = TRUE;
            break;
    }
#endif

    if ( !m_iconized )
    {
#if wxUSE_STATUSBAR
        PositionStatusBar();
#endif // wxUSE_STATUSBAR

#if wxUSE_TOOLBAR
        PositionToolBar();
#endif // wxUSE_TOOLBAR

        wxSizeEvent event(wxSize(x, y), m_windowId);
        event.SetEventObject( this );
        processed = GetEventHandler()->ProcessEvent(event);
    }

    return processed;
}

bool wxFrame::HandleCommand(WXWORD id, WXWORD cmd, WXHWND control)
{
    if ( control )
    {
        // In case it's e.g. a toolbar.
        wxWindow *win = wxFindWinFromHandle(control);
        if ( win )
            return win->MSWCommand(cmd, id);
    }

    // handle here commands from menus and accelerators
    if ( cmd == 0 || cmd == 1 )
    {
#if wxUSE_MENUS_NATIVE
        if ( wxCurrentPopupMenu )
        {
            wxMenu *popupMenu = wxCurrentPopupMenu;
            wxCurrentPopupMenu = NULL;

            return popupMenu->MSWCommand(cmd, id);
        }
#endif // wxUSE_MENUS_NATIVE

        if ( ProcessCommand(id) )
        {
            return TRUE;
        }
    }

    return FALSE;
}

bool wxFrame::HandleMenuSelect(WXWORD nItem, WXWORD flags, WXHMENU hMenu)
{
    int item;
    if ( flags == 0xFFFF && hMenu == 0 )
    {
        // menu was removed from screen
        item = -1;
    }
#ifndef __WXMICROWIN__
    else if ( !(flags & MF_POPUP) && !(flags & MF_SEPARATOR) )
    {
        item = nItem;
    }
#endif
    else
    {
#if wxUSE_STATUSBAR
        // don't give hints for separators (doesn't make sense) nor for the
        // items opening popup menus (they don't have them anyhow) but do clear
        // the status line - otherwise, we would be left with the help message
        // for the previous item which doesn't apply any more
        wxStatusBar *statbar = GetStatusBar();
        if ( statbar )
        {
            statbar->SetStatusText(wxEmptyString);
        }
#endif // wxUSE_STATUSBAR

        return FALSE;
    }

    wxMenuEvent event(wxEVT_MENU_HIGHLIGHT, item);
    event.SetEventObject( this );

    return GetEventHandler()->ProcessEvent(event);
}

// ---------------------------------------------------------------------------
// the window proc for wxFrame
// ---------------------------------------------------------------------------

long wxFrame::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam)
{
    long rc = 0;
    bool processed = FALSE;

    switch ( message )
    {
        case WM_CLOSE:
            // if we can't close, tell the system that we processed the
            // message - otherwise it would close us
            processed = !Close();
            break;

        case WM_COMMAND:
            {
                WORD id, cmd;
                WXHWND hwnd;
                UnpackCommand((WXWPARAM)wParam, (WXLPARAM)lParam,
                              &id, &hwnd, &cmd);

                processed = HandleCommand(id, cmd, (WXHWND)hwnd);
            }
            break;

#ifndef __WXMICROWIN__
        case WM_MENUSELECT:
            {
                WXWORD item, flags;
                WXHMENU hmenu;
                UnpackMenuSelect(wParam, lParam, &item, &flags, &hmenu);

                processed = HandleMenuSelect(item, flags, hmenu);
            }
            break;
#endif

        case WM_PAINT:
            processed = HandlePaint();
            break;

#ifndef __WXMICROWIN__
        case WM_QUERYDRAGICON:
            {
                HICON hIcon = m_icon.Ok() ? GetHiconOf(m_icon)
                                          : (HICON)GetDefaultIcon();
                rc = (long)hIcon;
                processed = rc != 0;
            }
            break;
#endif

        case WM_SIZE:
            processed = HandleSize(LOWORD(lParam), HIWORD(lParam), wParam);
            break;
    }

    if ( !processed )
        rc = wxWindow::MSWWindowProc(message, wParam, lParam);

    return rc;
}
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: msw/frame.cpp
	3	// Purpose: wxFrame
	4	// Author: Julian Smart
	5	// Modified by:
	6	// Created: 01/02/97
	7	// RCS-ID: $Id$
	8	// Copyright: (c) Julian Smart and Markus Holzem
	9	// Licence: wxWindows licence
	10	/////////////////////////////////////////////////////////////////////////////
	11
	12	// ============================================================================
	13	// declarations
	14	// ============================================================================
	15
	16	// ----------------------------------------------------------------------------
	17	// headers
	18	// ----------------------------------------------------------------------------
	19
	20	#ifdef __GNUG__
	21	#pragma implementation "frame.h"
	22	#endif
	23
	24	// For compilers that support precompilation, includes "wx.h".
	25	#include "wx/wxprec.h"
	26
	27	#ifdef __BORLANDC__
	28	#pragma hdrstop
	29	#endif
	30
	31	#ifndef WX_PRECOMP
	32	#include "wx/frame.h"
	33	#include "wx/app.h"
	34	#include "wx/menu.h"
	35	#include "wx/utils.h"
	36	#include "wx/dialog.h"
	37	#include "wx/settings.h"
	38	#include "wx/dcclient.h"
	39	#include "wx/mdi.h"
	40	#include "wx/panel.h"
	41	#endif // WX_PRECOMP
	42
	43	#include "wx/msw/private.h"
	44
	45	#if wxUSE_STATUSBAR
	46	#include "wx/statusbr.h"
	47	#include "wx/generic/statusbr.h"
	48	#endif // wxUSE_STATUSBAR
	49
	50	#if wxUSE_TOOLBAR
	51	#include "wx/toolbar.h"
	52	#endif // wxUSE_TOOLBAR
	53
	54	#include "wx/menuitem.h"
	55	#include "wx/log.h"
	56
	57	#ifdef __WXUNIVERSAL__
	58	#include "wx/univ/theme.h"
	59	#include "wx/univ/colschem.h"
	60	#endif // __WXUNIVERSAL__
	61
	62	// ----------------------------------------------------------------------------
	63	// globals
	64	// ----------------------------------------------------------------------------
	65
	66	extern const wxChar *wxFrameClassName;
	67
	68	#if wxUSE_MENUS_NATIVE
	69	extern wxMenu *wxCurrentPopupMenu;
	70	#endif // wxUSE_MENUS_NATIVE
	71
	72	// ----------------------------------------------------------------------------
	73	// event tables
	74	// ----------------------------------------------------------------------------
	75
	76	BEGIN_EVENT_TABLE(wxFrame, wxFrameBase)
	77	EVT_ACTIVATE(wxFrame::OnActivate)
	78	EVT_SYS_COLOUR_CHANGED(wxFrame::OnSysColourChanged)
	79	END_EVENT_TABLE()
	80
	81	IMPLEMENT_DYNAMIC_CLASS(wxFrame, wxWindow)
	82
	83	// ============================================================================
	84	// implementation
	85	// ============================================================================
	86
	87	// ----------------------------------------------------------------------------
	88	// static class members
	89	// ----------------------------------------------------------------------------
	90
	91	#if wxUSE_STATUSBAR
	92	#if wxUSE_NATIVE_STATUSBAR
	93	bool wxFrame::m_useNativeStatusBar = TRUE;
	94	#else
	95	bool wxFrame::m_useNativeStatusBar = FALSE;
	96	#endif
	97	#endif // wxUSE_NATIVE_STATUSBAR
	98
	99	// ----------------------------------------------------------------------------
	100	// creation/destruction
	101	// ----------------------------------------------------------------------------
	102
	103	void wxFrame::Init()
	104	{
	105	#if wxUSE_TOOLTIPS
	106	m_hwndToolTip = 0;
	107	#endif
	108
	109	// Data to save/restore when calling ShowFullScreen
	110	m_fsStatusBarFields = 0;
	111	m_fsStatusBarHeight = 0;
	112	m_fsToolBarHeight = 0;
	113	// m_fsMenu = 0;
	114
	115	m_wasMinimized = FALSE;
	116
	117	m_winLastFocused = (wxWindow *)NULL;
	118	}
	119
	120	bool wxFrame::Create(wxWindow *parent,
	121	wxWindowID id,
	122	const wxString& title,
	123	const wxPoint& pos,
	124	const wxSize& size,
	125	long style,
	126	const wxString& name)
	127	{
	128	if ( !wxTopLevelWindow::Create(parent, id, title, pos, size, style, name) )
	129	return FALSE;
	130
	131	SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_APPWORKSPACE));
	132
	133	wxModelessWindows.Append(this);
	134
	135	return TRUE;
	136	}
	137
	138	wxFrame::~wxFrame()
	139	{
	140	m_isBeingDeleted = TRUE;
	141
	142	DeleteAllBars();
	143	}
	144
	145	// Get size available for subwindows i.e. excluding menu bar, toolbar etc.
	146	void wxFrame::DoGetClientSize(int x, int y) const
	147	{
	148	RECT rect;
	149	::GetClientRect(GetHwnd(), &rect);
	150
	151	#if wxUSE_STATUSBAR
	152	if ( GetStatusBar() && GetStatusBar()->IsShown() )
	153	{
	154	int statusX, statusY;
	155	GetStatusBar()->GetClientSize(&statusX, &statusY);
	156	rect.bottom -= statusY;
	157	}
	158	#endif // wxUSE_STATUSBAR
	159
	160	wxPoint pt(GetClientAreaOrigin());
	161	rect.bottom -= pt.y;
	162	rect.right -= pt.x;
	163
	164	if ( x )
	165	*x = rect.right;
	166	if ( y )
	167	*y = rect.bottom;
	168	}
	169
	170	void wxFrame::DoSetClientSize(int width, int height)
	171	{
	172	// leave enough space for the status bar if we have (and show) it
	173	#if wxUSE_STATUSBAR
	174	wxStatusBar *statbar = GetStatusBar();
	175	if ( statbar && statbar->IsShown() )
	176	{
	177	height += statbar->GetSize().y;
	178	}
	179	#endif // wxUSE_STATUSBAR
	180
	181	wxTopLevelWindow::DoSetClientSize(width, height);
	182	}
	183
	184	// ----------------------------------------------------------------------------
	185	// wxFrame: various geometry-related functions
	186	// ----------------------------------------------------------------------------
	187
	188	void wxFrame::Raise()
	189	{
	190	#ifdef __WIN16__
	191	// no SetForegroundWindow() in Win16
	192	wxFrameBase::Raise();
	193	#else // Win32
	194	::SetForegroundWindow(GetHwnd());
	195	#endif // Win16/32
	196	}
	197
	198	// generate an artificial resize event
	199	void wxFrame::SendSizeEvent()
	200	{
	201	if ( !m_iconized )
	202	{
	203	RECT r = wxGetWindowRect(GetHwnd());
	204
	205	(void)::PostMessage(GetHwnd(), WM_SIZE,
	206	IsMaximized() ? SIZE_MAXIMIZED : SIZE_RESTORED,
	207	MAKELPARAM(r.right - r.left, r.bottom - r.top));
	208	}
	209	}
	210
	211	#if wxUSE_STATUSBAR
	212	wxStatusBar *wxFrame::OnCreateStatusBar(int number,
	213	long style,
	214	wxWindowID id,
	215	const wxString& name)
	216	{
	217	wxStatusBar *statusBar = NULL;
	218
	219	#if wxUSE_NATIVE_STATUSBAR
	220	if ( !UsesNativeStatusBar() )
	221	{
	222	statusBar = (wxStatusBar *)new wxStatusBarGeneric(this, id, style);
	223	}
	224	else
	225	#endif
	226	{
	227	statusBar = new wxStatusBar(this, id, style, name);
	228	}
	229
	230	statusBar->SetFieldsCount(number);
	231
	232	return statusBar;
	233	}
	234
	235	void wxFrame::PositionStatusBar()
	236	{
	237	if ( !m_frameStatusBar )
	238	return;
	239
	240	int w, h;
	241	GetClientSize(&w, &h);
	242	int sw, sh;
	243	m_frameStatusBar->GetSize(&sw, &sh);
	244
	245	// Since we wish the status bar to be directly under the client area,
	246	// we use the adjusted sizes without using wxSIZE_NO_ADJUSTMENTS.
	247	m_frameStatusBar->SetSize(0, h, w, sh);
	248	}
	249	#endif // wxUSE_STATUSBAR
	250
	251	#if wxUSE_MENUS_NATIVE
	252
	253	void wxFrame::AttachMenuBar(wxMenuBar *menubar)
	254	{
	255	wxFrameBase::AttachMenuBar(menubar);
	256
	257	if ( !menubar )
	258	{
	259	// actually remove the menu from the frame
	260	m_hMenu = (WXHMENU)0;
	261	InternalSetMenuBar();
	262	}
	263	else // set new non NULL menu bar
	264	{
	265	// Can set a menubar several times.
	266	if ( menubar->GetHMenu() )
	267	{
	268	m_hMenu = menubar->GetHMenu();
	269	}
	270	else // no HMENU yet
	271	{
	272	m_hMenu = menubar->Create();
	273
	274	if ( !m_hMenu )
	275	{
	276	wxFAIL_MSG( _T("failed to create menu bar") );
	277	return;
	278	}
	279	}
	280
	281	InternalSetMenuBar();
	282	}
	283	}
	284
	285	void wxFrame::InternalSetMenuBar()
	286	{
	287	#ifndef __WXMICROWIN__
	288	if ( !::SetMenu(GetHwnd(), (HMENU)m_hMenu) )
	289	{
	290	wxLogLastError(wxT("SetMenu"));
	291	}
	292	#endif
	293	}
	294
	295	#endif // wxUSE_MENUS_NATIVE
	296
	297	// Responds to colour changes, and passes event on to children.
	298	void wxFrame::OnSysColourChanged(wxSysColourChangedEvent& event)
	299	{
	300	SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_APPWORKSPACE));
	301	Refresh();
	302
	303	#if wxUSE_STATUSBAR
	304	if ( m_frameStatusBar )
	305	{
	306	wxSysColourChangedEvent event2;
	307	event2.SetEventObject( m_frameStatusBar );
	308	m_frameStatusBar->GetEventHandler()->ProcessEvent(event2);
	309	}
	310	#endif // wxUSE_STATUSBAR
	311
	312	// Propagate the event to the non-top-level children
	313	wxWindow::OnSysColourChanged(event);
	314	}
	315
	316	// Pass TRUE to show full screen, FALSE to restore.
	317	bool wxFrame::ShowFullScreen(bool show, long style)
	318	{
	319	if ( IsFullScreen() == show )
	320	return FALSE;
	321
	322	if (show)
	323	{
	324	#if wxUSE_TOOLBAR
	325	wxToolBar *theToolBar = GetToolBar();
	326	if (theToolBar)
	327	theToolBar->GetSize(NULL, &m_fsToolBarHeight);
	328
	329	// zap the toolbar, menubar, and statusbar
	330
	331	if ((style & wxFULLSCREEN_NOTOOLBAR) && theToolBar)
	332	{
	333	theToolBar->SetSize(-1,0);
	334	theToolBar->Show(FALSE);
	335	}
	336	#endif // wxUSE_TOOLBAR
	337
	338	#ifndef __WXMICROWIN__
	339	if (style & wxFULLSCREEN_NOMENUBAR)
	340	SetMenu((HWND)GetHWND(), (HMENU) NULL);
	341	#endif
	342
	343	#if wxUSE_STATUSBAR
	344	wxStatusBar *theStatusBar = GetStatusBar();
	345	if (theStatusBar)
	346	theStatusBar->GetSize(NULL, &m_fsStatusBarHeight);
	347
	348	// Save the number of fields in the statusbar
	349	if ((style & wxFULLSCREEN_NOSTATUSBAR) && theStatusBar)
	350	{
	351	//m_fsStatusBarFields = theStatusBar->GetFieldsCount();
	352	//SetStatusBar((wxStatusBar*) NULL);
	353	//delete theStatusBar;
	354	theStatusBar->Show(FALSE);
	355	}
	356	else
	357	m_fsStatusBarFields = 0;
	358	#endif // wxUSE_STATUSBAR
	359	}
	360	else
	361	{
	362	#if wxUSE_TOOLBAR
	363	wxToolBar *theToolBar = GetToolBar();
	364
	365	// restore the toolbar, menubar, and statusbar
	366	if (theToolBar && (m_fsStyle & wxFULLSCREEN_NOTOOLBAR))
	367	{
	368	theToolBar->SetSize(-1, m_fsToolBarHeight);
	369	theToolBar->Show(TRUE);
	370	}
	371	#endif // wxUSE_TOOLBAR
	372
	373	#if wxUSE_STATUSBAR
	374	if ( m_fsStyle & wxFULLSCREEN_NOSTATUSBAR )
	375	{
	376	//CreateStatusBar(m_fsStatusBarFields);
	377	if (GetStatusBar())
	378	{
	379	GetStatusBar()->Show(TRUE);
	380	PositionStatusBar();
	381	}
	382	}
	383	#endif // wxUSE_STATUSBAR
	384
	385	#ifndef __WXMICROWIN__
	386	if ((m_fsStyle & wxFULLSCREEN_NOMENUBAR) && (m_hMenu != 0))
	387	SetMenu((HWND)GetHWND(), (HMENU)m_hMenu);
	388	#endif
	389	}
	390
	391	return wxFrameBase::ShowFullScreen(show, style);
	392	}
	393
	394	// Default activation behaviour - set the focus for the first child
	395	// subwindow found.
	396	void wxFrame::OnActivate(wxActivateEvent& event)
	397	{
	398	if ( event.GetActive() )
	399	{
	400	// restore focus to the child which was last focused
	401	wxLogTrace(_T("focus"), _T("wxFrame %08x activated."), m_hWnd);
	402
	403	wxWindow *parent = m_winLastFocused ? m_winLastFocused->GetParent()
	404	: NULL;
	405	if ( !parent )
	406	{
	407	parent = this;
	408	}
	409
	410	wxSetFocusToChild(parent, &m_winLastFocused);
	411	}
	412	else // deactivating
	413	{
	414	// remember the last focused child if it is our child
	415	m_winLastFocused = FindFocus();
	416
	417	// so we NULL it out if it's a child from some other frame
	418	wxWindow *win = m_winLastFocused;
	419	while ( win )
	420	{
	421	if ( win->IsTopLevel() )
	422	{
	423	if ( win != this )
	424	{
	425	m_winLastFocused = NULL;
	426	}
	427
	428	break;
	429	}
	430
	431	win = win->GetParent();
	432	}
	433
	434	wxLogTrace(_T("focus"),
	435	_T("wxFrame %08x deactivated, last focused: %08x."),
	436	m_hWnd,
	437	m_winLastFocused ? GetHwndOf(m_winLastFocused)
	438	: NULL);
	439
	440	event.Skip();
	441	}
	442	}
	443
	444	// ----------------------------------------------------------------------------
	445	// tool/status bar stuff
	446	// ----------------------------------------------------------------------------
	447
	448	#if wxUSE_TOOLBAR
	449
	450	wxToolBar* wxFrame::CreateToolBar(long style, wxWindowID id, const wxString& name)
	451	{
	452	if ( wxFrameBase::CreateToolBar(style, id, name) )
	453	{
	454	PositionToolBar();
	455	}
	456
	457	return m_frameToolBar;
	458	}
	459
	460	void wxFrame::PositionToolBar()
	461	{
	462	RECT rect;
	463	::GetClientRect(GetHwnd(), &rect);
	464
	465	#if wxUSE_STATUSBAR
	466	if ( GetStatusBar() )
	467	{
	468	int statusX, statusY;
	469	GetStatusBar()->GetClientSize(&statusX, &statusY);
	470	rect.bottom -= statusY;
	471	}
	472	#endif // wxUSE_STATUSBAR
	473
	474	if ( GetToolBar() && GetToolBar()->IsShown() )
	475	{
	476	int tw, th;
	477	GetToolBar()->GetSize(&tw, &th);
	478
	479	if ( GetToolBar()->GetWindowStyleFlag() & wxTB_VERTICAL )
	480	{
	481	th = rect.bottom;
	482	}
	483	else
	484	{
	485	tw = rect.right;
	486	}
	487
	488	// Use the 'real' MSW position here
	489	GetToolBar()->SetSize(0, 0, tw, th, wxSIZE_NO_ADJUSTMENTS);
	490	}
	491	}
	492	#endif // wxUSE_TOOLBAR
	493
	494	// ----------------------------------------------------------------------------
	495	// frame state (iconized/maximized/...)
	496	// ----------------------------------------------------------------------------
	497
	498	// propagate our state change to all child frames: this allows us to emulate X
	499	// Windows behaviour where child frames float independently of the parent one
	500	// on the desktop, but are iconized/restored with it
	501	void wxFrame::IconizeChildFrames(bool bIconize)
	502	{
	503	for ( wxWindowList::Node *node = GetChildren().GetFirst();
	504	node;
	505	node = node->GetNext() )
	506	{
	507	wxWindow *win = node->GetData();
	508
	509	// iconizing the frames with this style under Win95 shell puts them at
	510	// the bottom of the screen (as the MDI children) instead of making
	511	// them appear in the taskbar because they are, by virtue of this
	512	// style, not managed by the taskbar - instead leave Windows take care
	513	// of them
	514	#ifdef __WIN95__
	515	if ( win->GetWindowStyle() & wxFRAME_TOOL_WINDOW )
	516	continue;
	517	#endif // Win95
	518
	519	// the child MDI frames are a special case and should not be touched by
	520	// the parent frame - instead, they are managed by the user
	521	wxFrame *frame = wxDynamicCast(win, wxFrame);
	522	if ( frame
	523	#if wxUSE_MDI_ARCHITECTURE
	524	&& !wxDynamicCast(frame, wxMDIChildFrame)
	525	#endif // wxUSE_MDI_ARCHITECTURE
	526	)
	527	{
	528	// we don't want to restore the child frames which had been
	529	// iconized even before we were iconized, so save the child frame
	530	// status when iconizing the parent frame and check it when
	531	// restoring it
	532	if ( bIconize )
	533	{
	534	frame->m_wasMinimized = frame->IsIconized();
	535	}
	536
	537	// this test works for both iconizing and restoring
	538	if ( !frame->m_wasMinimized )
	539	frame->Iconize(bIconize);
	540	}
	541	}
	542	}
	543
	544	WXHICON wxFrame::GetDefaultIcon() const
	545	{
	546	return (WXHICON)(wxSTD_FRAME_ICON ? wxSTD_FRAME_ICON
	547	: wxDEFAULT_FRAME_ICON);
	548	}
	549
	550	// ===========================================================================
	551	// message processing
	552	// ===========================================================================
	553
	554	// ---------------------------------------------------------------------------
	555	// preprocessing
	556	// ---------------------------------------------------------------------------
	557
	558	bool wxFrame::MSWTranslateMessage(WXMSG* pMsg)
	559	{
	560	if ( wxWindow::MSWTranslateMessage(pMsg) )
	561	return TRUE;
	562
	563	#if wxUSE_MENUS && wxUSE_ACCEL && !defined(__WXUNIVERSAL__)
	564	// try the menu bar accels
	565	wxMenuBar *menuBar = GetMenuBar();
	566	if ( !menuBar )
	567	return FALSE;
	568
	569	const wxAcceleratorTable& acceleratorTable = menuBar->GetAccelTable();
	570	return acceleratorTable.Translate(this, pMsg);
	571	#else
	572	return FALSE;
	573	#endif // wxUSE_MENUS && wxUSE_ACCEL
	574	}
	575
	576	// ---------------------------------------------------------------------------
	577	// our private (non virtual) message handlers
	578	// ---------------------------------------------------------------------------
	579
	580	bool wxFrame::HandlePaint()
	581	{
	582	RECT rect;
	583	if ( GetUpdateRect(GetHwnd(), &rect, FALSE) )
	584	{
	585	#ifndef __WXMICROWIN__
	586	if ( m_iconized )
	587	{
	588	HICON hIcon = m_icon.Ok() ? GetHiconOf(m_icon)
	589	: (HICON)GetDefaultIcon();
	590
	591	// Hold a pointer to the dc so long as the OnPaint() message
	592	// is being processed
	593	PAINTSTRUCT ps;
	594	HDC hdc = ::BeginPaint(GetHwnd(), &ps);
	595
	596	// Erase background before painting or we get white background
	597	MSWDefWindowProc(WM_ICONERASEBKGND, (WORD)(LONG)ps.hdc, 0L);
	598
	599	if ( hIcon )
	600	{
	601	RECT rect;
	602	::GetClientRect(GetHwnd(), &rect);
	603
	604	// FIXME: why hardcoded?
	605	static const int icon_width = 32;
	606	static const int icon_height = 32;
	607
	608	int icon_x = (int)((rect.right - icon_width)/2);
	609	int icon_y = (int)((rect.bottom - icon_height)/2);
	610
	611	::DrawIcon(hdc, icon_x, icon_y, hIcon);
	612	}
	613
	614	::EndPaint(GetHwnd(), &ps);
	615
	616	return TRUE;
	617	}
	618	else
	619	#endif
	620	{
	621	return wxWindow::HandlePaint();
	622	}
	623	}
	624	else
	625	{
	626	// nothing to paint - processed
	627	return TRUE;
	628	}
	629	}
	630
	631	bool wxFrame::HandleSize(int x, int y, WXUINT id)
	632	{
	633	bool processed = FALSE;
	634	#ifndef __WXMICROWIN__
	635
	636	switch ( id )
	637	{
	638	case SIZENORMAL:
	639	// only do it it if we were iconized before, otherwise resizing the
	640	// parent frame has a curious side effect of bringing it under it's
	641	// children
	642	if ( !m_iconized )
	643	break;
	644
	645	// restore all child frames too
	646	IconizeChildFrames(FALSE);
	647
	648	(void)SendIconizeEvent(FALSE);
	649
	650	// fall through
	651
	652	case SIZEFULLSCREEN:
	653	m_iconized = FALSE;
	654	break;
	655
	656	case SIZEICONIC:
	657	// iconize all child frames too
	658	IconizeChildFrames(TRUE);
	659
	660	(void)SendIconizeEvent();
	661
	662	m_iconized = TRUE;
	663	break;
	664	}
	665	#endif
	666
	667	if ( !m_iconized )
	668	{
	669	#if wxUSE_STATUSBAR
	670	PositionStatusBar();
	671	#endif // wxUSE_STATUSBAR
	672
	673	#if wxUSE_TOOLBAR
	674	PositionToolBar();
	675	#endif // wxUSE_TOOLBAR
	676
	677	wxSizeEvent event(wxSize(x, y), m_windowId);
	678	event.SetEventObject( this );
	679	processed = GetEventHandler()->ProcessEvent(event);
	680	}
	681
	682	return processed;
	683	}
	684
	685	bool wxFrame::HandleCommand(WXWORD id, WXWORD cmd, WXHWND control)
	686	{
	687	if ( control )
	688	{
	689	// In case it's e.g. a toolbar.
	690	wxWindow *win = wxFindWinFromHandle(control);
	691	if ( win )
	692	return win->MSWCommand(cmd, id);
	693	}
	694
	695	// handle here commands from menus and accelerators
	696	if ( cmd == 0 \|\| cmd == 1 )
	697	{
	698	#if wxUSE_MENUS_NATIVE
	699	if ( wxCurrentPopupMenu )
	700	{
	701	wxMenu *popupMenu = wxCurrentPopupMenu;
	702	wxCurrentPopupMenu = NULL;
	703
	704	return popupMenu->MSWCommand(cmd, id);
	705	}
	706	#endif // wxUSE_MENUS_NATIVE
	707
	708	if ( ProcessCommand(id) )
	709	{
	710	return TRUE;
	711	}
	712	}
	713
	714	return FALSE;
	715	}
	716
	717	bool wxFrame::HandleMenuSelect(WXWORD nItem, WXWORD flags, WXHMENU hMenu)
	718	{
	719	int item;
	720	if ( flags == 0xFFFF && hMenu == 0 )
	721	{
	722	// menu was removed from screen
	723	item = -1;
	724	}
	725	#ifndef __WXMICROWIN__
	726	else if ( !(flags & MF_POPUP) && !(flags & MF_SEPARATOR) )
	727	{
	728	item = nItem;
	729	}
	730	#endif
	731	else
	732	{
	733	#if wxUSE_STATUSBAR
	734	// don't give hints for separators (doesn't make sense) nor for the
	735	// items opening popup menus (they don't have them anyhow) but do clear
	736	// the status line - otherwise, we would be left with the help message
	737	// for the previous item which doesn't apply any more
	738	wxStatusBar *statbar = GetStatusBar();
	739	if ( statbar )
	740	{
	741	statbar->SetStatusText(wxEmptyString);
	742	}
	743	#endif // wxUSE_STATUSBAR
	744
	745	return FALSE;
	746	}
	747
	748	wxMenuEvent event(wxEVT_MENU_HIGHLIGHT, item);
	749	event.SetEventObject( this );
	750
	751	return GetEventHandler()->ProcessEvent(event);
	752	}
	753
	754	// ---------------------------------------------------------------------------
	755	// the window proc for wxFrame
	756	// ---------------------------------------------------------------------------
	757
	758	long wxFrame::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam)
	759	{
	760	long rc = 0;
	761	bool processed = FALSE;
	762
	763	switch ( message )
	764	{
	765	case WM_CLOSE:
	766	// if we can't close, tell the system that we processed the
	767	// message - otherwise it would close us
	768	processed = !Close();
	769	break;
	770
	771	case WM_COMMAND:
	772	{
	773	WORD id, cmd;
	774	WXHWND hwnd;
	775	UnpackCommand((WXWPARAM)wParam, (WXLPARAM)lParam,
	776	&id, &hwnd, &cmd);
	777
	778	processed = HandleCommand(id, cmd, (WXHWND)hwnd);
	779	}
	780	break;
	781
	782	#ifndef __WXMICROWIN__
	783	case WM_MENUSELECT:
	784	{
	785	WXWORD item, flags;
	786	WXHMENU hmenu;
	787	UnpackMenuSelect(wParam, lParam, &item, &flags, &hmenu);
	788
	789	processed = HandleMenuSelect(item, flags, hmenu);
	790	}
	791	break;
	792	#endif
	793
	794	case WM_PAINT:
	795	processed = HandlePaint();
	796	break;
	797
	798	#ifndef __WXMICROWIN__
	799	case WM_QUERYDRAGICON:
	800	{
	801	HICON hIcon = m_icon.Ok() ? GetHiconOf(m_icon)
	802	: (HICON)GetDefaultIcon();
	803	rc = (long)hIcon;
	804	processed = rc != 0;
	805	}
	806	break;
	807	#endif
	808
	809	case WM_SIZE:
	810	processed = HandleSize(LOWORD(lParam), HIWORD(lParam), wParam);
	811	break;
	812	}
	813
	814	if ( !processed )
	815	rc = wxWindow::MSWWindowProc(message, wParam, lParam);
	816
	817	return rc;
	818	}
	819