Add some version checks to help compiling on OSX.

[wxWidgets.git] / src / msw / toolbar.cpp

diff --git a/src/msw/toolbar.cpp b/src/msw/toolbar.cpp
index 1a9e9efe866e06e663958cc04adf811bbd92b3f2..6ad75a3cd1623bfd0b0269908a27ec9f4faa5c54 100644 (file)
--- a/src/msw/toolbar.cpp
+++ b/src/msw/toolbar.cpp
@@ -36,6 +36,7 @@
     #include "wx/intl.h"
     #include "wx/settings.h"
     #include "wx/bitmap.h"
     #include "wx/intl.h"
     #include "wx/settings.h"
     #include "wx/bitmap.h"

+    #include "wx/region.h"

     #include "wx/dcmemory.h"
     #include "wx/control.h"
     #include "wx/app.h"         // for GetComCtl32Version
     #include "wx/dcmemory.h"
     #include "wx/control.h"
     #include "wx/app.h"         // for GetComCtl32Version


@@ -335,17 +336,11 @@ bool wxToolBar::Create(wxWindow *parent,
 
     wxSetCCUnicodeFormat(GetHwnd());
 
 
     wxSetCCUnicodeFormat(GetHwnd());
 

-    // workaround for flat toolbar on Windows XP classic style: we have to set
-    // the style after creating the control; doing it at creation time doesn't work
-#if wxUSE_UXTHEME
-    if ( style & wxTB_FLAT )
-    {
-        LRESULT style = GetMSWToolbarStyle();
-
-        if ( !(style & TBSTYLE_FLAT) )
-            ::SendMessage(GetHwnd(), TB_SETSTYLE, 0, style | TBSTYLE_FLAT);
-    }
-#endif // wxUSE_UXTHEME
+    // we always erase our background on WM_PAINT so there is no need to do it
+    // in WM_ERASEBKGND too (by default this won't be done but if the toolbar
+    // has a non default background colour, then it would be used in both
+    // places resulting in flicker)
+    SetBackgroundStyle(wxBG_STYLE_PAINT);

 
     return true;
 }
 
     return true;
 }


@@ -410,11 +405,7 @@ void wxToolBar::Recreate()
         m_hBitmap = 0;
     }
 
         m_hBitmap = 0;
     }
 

-    if ( m_disabledImgList )
-    {
-        delete m_disabledImgList;
-        m_disabledImgList = NULL;
-    }
+    wxDELETE(m_disabledImgList);

 
     Realize();
 }
 
     Realize();
 }


@@ -500,21 +491,11 @@ WXDWORD wxToolBar::MSWGetStyle(long style, WXDWORD *exstyle) const
     if ( !(style & wxTB_NO_TOOLTIPS) )
         msStyle |= TBSTYLE_TOOLTIPS;
 
     if ( !(style & wxTB_NO_TOOLTIPS) )
         msStyle |= TBSTYLE_TOOLTIPS;
 

-    if ( style & (wxTB_FLAT | wxTB_HORZ_LAYOUT) )
-    {
-        // static as it doesn't change during the program lifetime
-        static const int s_verComCtl = wxApp::GetComCtl32Version();
-
-        // comctl32.dll 4.00 doesn't support the flat toolbars and using this
-        // style with 6.00 (part of Windows XP) leads to the toolbar with
-        // incorrect background colour - and not using it still results in the
-        // correct (flat) toolbar, so don't use it there
-        if ( s_verComCtl > 400 && s_verComCtl < 600 )
-            msStyle |= TBSTYLE_FLAT | TBSTYLE_TRANSPARENT;
-
-        if ( s_verComCtl >= 470 && style & wxTB_HORZ_LAYOUT )
-            msStyle |= TBSTYLE_LIST;
-    }
+    if ( style & wxTB_FLAT && wxApp::GetComCtl32Version() > 400 )
+        msStyle |= TBSTYLE_FLAT;
+
+    if ( style & wxTB_HORZ_LAYOUT && wxApp::GetComCtl32Version() >= 470 )
+        msStyle |= TBSTYLE_LIST;

 
     if ( style & wxTB_NODIVIDER )
         msStyle |= CCS_NODIVIDER;
 
     if ( style & wxTB_NODIVIDER )
         msStyle |= CCS_NODIVIDER;


@@ -531,6 +512,15 @@ WXDWORD wxToolBar::MSWGetStyle(long style, WXDWORD *exstyle) const
     if ( style & wxTB_RIGHT )
         msStyle |= CCS_RIGHT;
 
     if ( style & wxTB_RIGHT )
         msStyle |= CCS_RIGHT;
 

+    // always use TBSTYLE_TRANSPARENT because the background is not drawn
+    // correctly without it in all themes and, for whatever reason, the control
+    // also flickers horribly when it is resized if this style is not used
+    //
+    // note that this is implicitly enabled by the native toolbar itself when
+    // TBSTYLE_FLAT is used (i.e. it's impossible to use TBSTYLE_FLAT without
+    // TBSTYLE_TRANSPARENT) but turn it on explicitly in any case
+    msStyle |= TBSTYLE_TRANSPARENT;
+

     return msStyle;
 }
 
     return msStyle;
 }
 


@@ -616,11 +606,7 @@ bool wxToolBar::DoDeleteTool(size_t pos, wxToolBarToolBase *tool)
 
 void wxToolBar::CreateDisabledImageList()
 {
 
 void wxToolBar::CreateDisabledImageList()
 {

-    if (m_disabledImgList != NULL)
-    {
-        delete m_disabledImgList;
-        m_disabledImgList = NULL;
-    }
+    wxDELETE(m_disabledImgList);

 
     // as we can't use disabled image list with older versions of comctl32.dll,
     // don't even bother creating it
 
     // as we can't use disabled image list with older versions of comctl32.dll,
     // don't even bother creating it


@@ -632,12 +618,13 @@ void wxToolBar::CreateDisabledImageList()
         {
             wxToolBarToolBase *tool = node->GetData();
             wxBitmap bmpDisabled = tool->GetDisabledBitmap();
         {
             wxToolBarToolBase *tool = node->GetData();
             wxBitmap bmpDisabled = tool->GetDisabledBitmap();

-            if ( bmpDisabled.Ok() )
+            if ( bmpDisabled.IsOk() )

             {
             {

+                const wxSize sizeBitmap = bmpDisabled.GetSize();

                 m_disabledImgList = new wxImageList
                                         (
                 m_disabledImgList = new wxImageList
                                         (

-                                            m_defaultWidth,
-                                            m_defaultHeight,
+                                            sizeBitmap.x,
+                                            sizeBitmap.y,

                                             bmpDisabled.GetMask() != NULL,
                                             GetToolsCount()
                                         );
                                             bmpDisabled.GetMask() != NULL,
                                             GetToolsCount()
                                         );


@@ -757,7 +744,7 @@ bool wxToolBar::Realize()
                 const int w = bmp.GetWidth();
                 const int h = bmp.GetHeight();
 
                 const int w = bmp.GetWidth();
                 const int h = bmp.GetHeight();
 

-                if ( bmp.Ok() )
+                if ( bmp.IsOk() )

                 {
                     int xOffset = wxMax(0, (m_defaultWidth - w)/2);
                     int yOffset = wxMax(0, (m_defaultHeight - h)/2);
                 {
                     int xOffset = wxMax(0, (m_defaultWidth - w)/2);
                     int yOffset = wxMax(0, (m_defaultHeight - h)/2);


@@ -775,7 +762,7 @@ bool wxToolBar::Realize()
                 {
                     wxBitmap bmpDisabled = tool->GetDisabledBitmap();
 #if wxUSE_IMAGE && wxUSE_WXDIB
                 {
                     wxBitmap bmpDisabled = tool->GetDisabledBitmap();
 #if wxUSE_IMAGE && wxUSE_WXDIB

-                    if ( !bmpDisabled.Ok() )
+                    if ( !bmpDisabled.IsOk() )

                     {
                         // no disabled bitmap specified but we still need to
                         // fill the space in the image list with something, so
                     {
                         // no disabled bitmap specified but we still need to
                         // fill the space in the image list with something, so


@@ -940,6 +927,10 @@ bool wxToolBar::Realize()
                     // so we need a valid id for it and not wxID_SEPARATOR
                     // which is used by spacers by default
                     tool->AllocSpacerId();
                     // so we need a valid id for it and not wxID_SEPARATOR
                     // which is used by spacers by default
                     tool->AllocSpacerId();

+
+                    // also set the number of separators so that the logic in
+                    // HandlePaint() works correctly
+                    tool->SetSeparatorsCount(1);

                 }
 
                 button.idCommand = tool->GetId();
                 }
 
                 button.idCommand = tool->GetId();


@@ -1196,7 +1187,11 @@ bool wxToolBar::Realize()
 
 void wxToolBar::UpdateStretchableSpacersSize()
 {
 
 void wxToolBar::UpdateStretchableSpacersSize()
 {

-    // we can't resize the spacers if TB_SETBUTTONINFO is not supported
+#ifdef TB_SETBUTTONINFO
+    // we can't resize the spacers if TB_SETBUTTONINFO is not supported (we
+    // could try to do it with multiple separators as for the controls but this
+    // is too painful and it just doesn't seem to be worth doing for the
+    // ancient systems)

     if ( wxApp::GetComCtl32Version() < 471 )
         return;
 
     if ( wxApp::GetComCtl32Version() < 471 )
         return;
 


@@ -1217,13 +1212,13 @@ void wxToolBar::UpdateStretchableSpacersSize()
     // reduce their size if there is not enough place for all tools
     const int totalSize = IsVertical() ? GetClientSize().y : GetClientSize().x;
     const int extraSize = totalSize - m_totalFixedSize;
     // reduce their size if there is not enough place for all tools
     const int totalSize = IsVertical() ? GetClientSize().y : GetClientSize().x;
     const int extraSize = totalSize - m_totalFixedSize;

-    const int sizeSpacer = extraSize > 0 ? extraSize / numSpaces : 0;
+    const int sizeSpacer = extraSize > 0 ? extraSize / numSpaces : 1;

 
     // the last spacer should consume all remaining space if we have too much
     // of it (which can be greater than sizeSpacer because of the rounding)
     const int sizeLastSpacer = extraSize > 0
                                 ? extraSize - (numSpaces - 1)*sizeSpacer
 
     // the last spacer should consume all remaining space if we have too much
     // of it (which can be greater than sizeSpacer because of the rounding)
     const int sizeLastSpacer = extraSize > 0
                                 ? extraSize - (numSpaces - 1)*sizeSpacer

-                                : 0;
+                                : 1;

 
     // cumulated offset by which we need to move all the following controls to
     // the right: while the toolbar takes care of the normal items, we must
 
     // cumulated offset by which we need to move all the following controls to
     // the right: while the toolbar takes care of the normal items, we must


@@ -1263,6 +1258,7 @@ void wxToolBar::UpdateStretchableSpacersSize()
             offset += tbbi.cx - (rcOld.right - rcOld.left);
         }
     }
             offset += tbbi.cx - (rcOld.right - rcOld.left);
         }
     }

+#endif // TB_SETBUTTONINFO

 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------


@@ -1300,7 +1296,7 @@ bool wxToolBar::MSWCommand(WXUINT WXUNUSED(cmd), WXWORD id_)
     // Without the two lines of code below, if the toolbar was repainted during
     // OnLeftClick(), then it could end up without the tool bitmap temporarily
     // (see http://lists.nongnu.org/archive/html/lmi/2008-10/msg00014.html).
     // Without the two lines of code below, if the toolbar was repainted during
     // OnLeftClick(), then it could end up without the tool bitmap temporarily
     // (see http://lists.nongnu.org/archive/html/lmi/2008-10/msg00014.html).

-    // The Update() call bellow ensures that this won't happen, by repainting
+    // The Update() call below ensures that this won't happen, by repainting

     // invalidated areas of the toolbar immediately.
     //
     // To complicate matters, the tool would be drawn in depressed state (this
     // invalidated areas of the toolbar immediately.
     //
     // To complicate matters, the tool would be drawn in depressed state (this


@@ -1327,7 +1323,7 @@ bool wxToolBar::MSWCommand(WXUINT WXUNUSED(cmd), WXWORD id_)
     ::SendMessage(GetHwnd(), TB_SETSTATE, id, MAKELONG(state, 0));
 
     // OnLeftClick() can veto the button state change - for buttons which
     ::SendMessage(GetHwnd(), TB_SETSTATE, id, MAKELONG(state, 0));
 
     // OnLeftClick() can veto the button state change - for buttons which

-    // may be toggled only, of couse
+    // may be toggled only, of course.

     if ( !allowLeftClick && tool->CanBeToggled() )
     {
         // revert back
     if ( !allowLeftClick && tool->CanBeToggled() )
     {
         // revert back


@@ -1698,131 +1694,165 @@ bool wxToolBar::HandleSize(WXWPARAM WXUNUSED(wParam), WXLPARAM lParam)
     return true;
 }
 
     return true;
 }
 

-#ifndef __WXWINCE__
-
-void wxToolBar::MSWEraseRect(wxDC& dc, const wxRect& rectItem)
-{
-    dc.DrawRectangle(rectItem);
-}
+#ifdef wxHAS_MSW_BACKGROUND_ERASE_HOOK

 
 bool wxToolBar::HandlePaint(WXWPARAM wParam, WXLPARAM lParam)
 {
 
 bool wxToolBar::HandlePaint(WXWPARAM wParam, WXLPARAM lParam)
 {

-    // erase any dummy separators which were used only for reserving space in
-    // the toolbar (either for a control or just for a stretchable space)
-
-    // first of all, are there any controls at all?
-    wxToolBarToolsList::compatibility_iterator node;
-    for ( node = m_tools.GetFirst(); node; node = node->GetNext() )
+    // we must prevent the dummy separators corresponding to controls or
+    // stretchable spaces from being seen: we used to do it by painting over
+    // them but this, unsurprisingly, resulted in a lot of flicker so now we
+    // prevent the toolbar from painting them at all
+
+    // compute the region containing all dummy separators which we don't want
+    // to be seen
+    wxRegion rgnDummySeps;
+    const wxRect rectTotal = GetClientRect();
+    int toolIndex = 0;
+    for ( wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst();
+          node;
+          node = node->GetNext() )

     {
     {

-        wxToolBarToolBase * const tool = node->GetData();
+        wxToolBarTool * const
+            tool = static_cast<wxToolBarTool *>(node->GetData());
+

         if ( tool->IsControl() || tool->IsStretchableSpace() )
         if ( tool->IsControl() || tool->IsStretchableSpace() )

-            break;
+        {
+            const size_t numSeps = tool->GetSeparatorsCount();
+            for ( size_t n = 0; n < numSeps; n++, toolIndex++ )
+            {
+                // for some reason TB_GETITEMRECT returns a rectangle 1 pixel
+                // shorter than the full window size (at least under Windows 7)
+                // but we need to erase the full width/height below
+                RECT rcItem = wxGetTBItemRect(GetHwnd(), toolIndex);
+                if ( IsVertical() )
+                {
+                    rcItem.left = 0;
+                    rcItem.right = rectTotal.width;
+                }
+                else
+                {
+                    rcItem.top = 0;
+                    rcItem.bottom = rectTotal.height;
+                }
+
+                rgnDummySeps.Union(wxRectFromRECT(rcItem));
+            }
+        }
+        else
+        {
+            // normal tools never correspond to more than one native button
+            toolIndex++;
+        }

     }
 
     }
 

-    if ( !node )
+    if ( rgnDummySeps.IsOk() )

     {
     {

-        // no controls, nothing to erase
-        return false;
+        // exclude the area occupied by the controls and stretchable spaces
+        // from the update region to prevent the toolbar from drawing
+        // separators in it
+        if ( !::ValidateRgn(GetHwnd(), GetHrgnOf(rgnDummySeps)) )
+        {
+            wxLogLastError(wxT("ValidateRgn()"));
+        }

     }
 
     }
 

-    // prepare the DC on which we'll be drawing
-    wxClientDC dc(this);
-    dc.SetBrush(GetBackgroundColour());
-    dc.SetPen(*wxTRANSPARENT_PEN);
+    // still let the native control draw everything else normally but set up a
+    // hook to be able to process the next WM_ERASEBKGND sent to our parent
+    // because toolbar will ask it to erase its background from its WM_PAINT
+    // handler (when using TBSTYLE_TRANSPARENT which we do always use)
+    //
+    // installing hook is not completely trivial as all kinds of strange
+    // situations are possible: sometimes we can be called recursively from
+    // inside the native toolbar WM_PAINT handler so the hook might already be
+    // installed and sometimes the native toolbar might not send WM_ERASEBKGND
+    // to the parent at all for whatever reason, so deal with all these cases
+    wxWindow * const parent = GetParent();
+    const bool hadHook = parent->MSWHasEraseBgHook();
+    if ( !hadHook )
+        GetParent()->MSWSetEraseBgHook(this);

 
 

-    RECT rcUpdate;
-    if ( !::GetUpdateRect(GetHwnd(), &rcUpdate, FALSE) )
-    {
-        // nothing to redraw anyhow
-        return false;
-    }
+    MSWDefWindowProc(WM_PAINT, wParam, lParam);

 
 

-    const wxRect rectUpdate = wxRectFromRECT(rcUpdate);
-    dc.SetClippingRegion(rectUpdate);
+    if ( !hadHook )
+        GetParent()->MSWSetEraseBgHook(NULL);

 
 

-    // draw the toolbar tools, separators &c normally
-    wxControl::MSWWindowProc(WM_PAINT, wParam, lParam);

 
 

-    // for each control in the toolbar find all the separators intersecting it
-    // and erase them
-    //
-    // NB: this is really the only way to do it as we don't know if a separator
-    //     corresponds to a control (i.e. is a dummy one) or a real one
-    //     otherwise
-    int toolIndex = 0;
-    for ( node = m_tools.GetFirst(); node; node = node->GetNext(), toolIndex++ )
+    if ( rgnDummySeps.IsOk() )

     {
     {

-        wxToolBarTool *tool = (wxToolBarTool*)node->GetData();
-        if ( tool->IsControl() )
-        {
-            // get the control rect in our client coords
-            wxControl *control = tool->GetControl();
-            wxStaticText *staticText = tool->GetStaticText();
-            wxRect rectCtrl = control->GetRect();
-            wxRect rectStaticText;
-            if ( staticText )
-                rectStaticText = staticText->GetRect();
-
-            if ( !rectCtrl.Intersects(rectUpdate) &&
-                    (!staticText || !rectStaticText.Intersects(rectUpdate)) )
-                continue;
+        // erase the dummy separators region ourselves now as nobody painted
+        // over them
+        WindowHDC hdc(GetHwnd());
+        ::SelectClipRgn(hdc, GetHrgnOf(rgnDummySeps));
+        MSWDoEraseBackground(hdc);
+    }

 
 

-            // iterate over all buttons to find all separators intersecting
-            // this control
-            TBBUTTON tbb;
-            int count = ::SendMessage(GetHwnd(), TB_BUTTONCOUNT, 0, 0);
-            for ( int n = 0; n < count; n++ )
-            {
-                // is it a separator?
-                if ( !::SendMessage(GetHwnd(), TB_GETBUTTON,
-                                    n, (LPARAM)&tbb) )
-                {
-                    wxLogDebug(wxT("TB_GETBUTTON failed?"));
+    return true;
+}

 
 

-                    continue;
-                }
+WXHBRUSH wxToolBar::MSWGetToolbarBgBrush()
+{
+    // we conservatively use a solid brush here but we could also use a themed
+    // brush by using DrawThemeBackground() to create a bitmap brush (it'd need
+    // to be invalidated whenever the toolbar is resized and, also, correctly
+    // aligned using SetBrushOrgEx() before each use -- there is code for doing
+    // this in wxNotebook already so it'd need to be refactored into wxWindow)
+    //
+    // however inasmuch as there is a default background for the toolbar at all
+    // (and this is not a trivial question as different applications use very
+    // different colours), it seems to be a solid one and using REBAR
+    // background brush as we used to do before doesn't look good at all under
+    // Windows 7 (and probably Vista too), so for now we just keep it simple
+    wxColour const
+        colBg = m_hasBgCol ? GetBackgroundColour()
+                           : wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE);
+    wxBrush * const
+        brush = wxTheBrushList->FindOrCreateBrush(colBg);
+
+    return brush ? static_cast<WXHBRUSH>(brush->GetResourceHandle()) : 0;
+}

 
 

-                if ( tbb.fsStyle != TBSTYLE_SEP )
-                    continue;
+WXHBRUSH wxToolBar::MSWGetBgBrushForChild(WXHDC hDC, wxWindowMSW *child)
+{
+    WXHBRUSH hbr = wxToolBarBase::MSWGetBgBrushForChild(hDC, child);
+    if ( hbr )
+        return hbr;

 
 

-                // get the bounding rect of the separator
-                RECT r = wxGetTBItemRect(GetHwnd(), n);
-                if ( !r.right )
-                    continue;
+    // the base class version only returns a brush for erasing children
+    // background if we have a non-default background colour but as the toolbar
+    // doesn't erase its own background by default, we need to always do it for
+    // (semi-)transparent children
+    if ( child->GetParent() == this && child->HasTransparentBackground() )
+        return MSWGetToolbarBgBrush();

 
 

-                const wxRect rectItem = wxRectFromRECT(r);
+    return 0;
+}

 
 

-                // does it intersect the update region at all?
-                if ( !rectUpdate.Intersects(rectItem) )
-                    continue;
+void wxToolBar::MSWDoEraseBackground(WXHDC hDC)
+{
+    wxFillRect(GetHwnd(), (HDC)hDC, (HBRUSH)MSWGetToolbarBgBrush());
+}

 
 

-                // does it intersect the control itself or its label?
-                //
-                // if it does, refresh it so it's redrawn on top of the
-                // background
-                if ( rectCtrl.Intersects(rectItem) )
-                    control->Refresh(false);
-                else if ( staticText && rectStaticText.Intersects(rectItem) )
-                    staticText->Refresh(false);
-                else
-                    continue;
+bool wxToolBar::MSWEraseBgHook(WXHDC hDC)
+{
+    // toolbar WM_PAINT handler offsets the DC origin before sending
+    // WM_ERASEBKGND to the parent but as we handle it in the toolbar itself,
+    // we need to reset it back
+    HDC hdc = (HDC)hDC;
+    POINT ptOldOrg;
+    if ( !::SetWindowOrgEx(hdc, 0, 0, &ptOldOrg) )
+    {
+        wxLogLastError(wxT("SetWindowOrgEx(tbar-bg-hdc)"));
+        return false;
+    }

 
 

-                MSWEraseRect(dc, rectItem);
-            }
-        }
-        else if ( tool->IsStretchableSpace() )
-        {
-            const wxRect
-                rectItem = wxRectFromRECT(wxGetTBItemRect(GetHwnd(), toolIndex));
+    MSWDoEraseBackground(hDC);

 
 

-            if ( rectUpdate.Intersects(rectItem) )
-                MSWEraseRect(dc, rectItem);
-        }
-    }
+    ::SetWindowOrgEx(hdc, ptOldOrg.x, ptOldOrg.y, NULL);

 
     return true;
 }
 
     return true;
 }

-#endif // __WXWINCE__
+
+#endif // wxHAS_MSW_BACKGROUND_ERASE_HOOK

 
 void wxToolBar::HandleMouseMove(WXWPARAM WXUNUSED(wParam), WXLPARAM lParam)
 {
 
 void wxToolBar::HandleMouseMove(WXWPARAM WXUNUSED(wParam), WXLPARAM lParam)
 {


@@ -1853,7 +1883,7 @@ WXLRESULT wxToolBar::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam
                 return 0;
             break;
 
                 return 0;
             break;
 

-#ifndef __WXWINCE__
+#ifdef wxHAS_MSW_BACKGROUND_ERASE_HOOK

         case WM_PAINT:
             // refreshing the controls in the toolbar inside a composite window
             // results in an endless stream of WM_PAINT messages -- and seems
         case WM_PAINT:
             // refreshing the controls in the toolbar inside a composite window
             // results in an endless stream of WM_PAINT messages -- and seems


@@ -1862,7 +1892,7 @@ WXLRESULT wxToolBar::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam
             if ( !IsDoubleBuffered() && HandlePaint(wParam, lParam) )
                 return 0;
             break;
             if ( !IsDoubleBuffered() && HandlePaint(wParam, lParam) )
                 return 0;
             break;

-#endif // __WXWINCE__
+#endif // wxHAS_MSW_BACKGROUND_ERASE_HOOK

     }
 
     return wxControl::MSWWindowProc(nMsg, wParam, lParam);
     }
 
     return wxControl::MSWWindowProc(nMsg, wParam, lParam);