applied numpad keys patch

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

diff --git a/src/msw/tbar95.cpp b/src/msw/tbar95.cpp
index e101ced821957b67ec9cee21c60a357ea985c16e..7d209cc8016112118752b7f25e2e016d62c4d31d 100644 (file)
--- a/src/msw/tbar95.cpp
+++ b/src/msw/tbar95.cpp
@@ -35,6 +35,7 @@
     #include "wx/dynarray.h"
     #include "wx/settings.h"
     #include "wx/bitmap.h"
     #include "wx/dynarray.h"
     #include "wx/settings.h"
     #include "wx/bitmap.h"

+    #include "wx/dcmemory.h"

 #endif
 
 #if wxUSE_TOOLBAR && defined(__WIN95__) && wxUSE_TOOLBAR_NATIVE
 #endif
 
 #if wxUSE_TOOLBAR && defined(__WIN95__) && wxUSE_TOOLBAR_NATIVE


@@ -49,10 +50,10 @@
 
 #ifndef __TWIN32__
 
 
 #ifndef __TWIN32__
 

-#ifdef __GNUWIN32_OLD__
-    #include "wx/msw/gnuwin32/extra.h"
-#else
+#if defined(__WIN95__) && !((defined(__GNUWIN32_OLD__) || defined(__TWIN32__)) && !defined(__CYGWIN10__))

     #include <commctrl.h>
     #include <commctrl.h>

+#else
+    #include "wx/msw/gnuwin32/extra.h"

 #endif
 
 #endif // __TWIN32__
 #endif
 
 #endif // __TWIN32__


@@ -60,6 +61,18 @@
 #include "wx/msw/dib.h"
 #include "wx/app.h"         // for GetComCtl32Version
 
 #include "wx/msw/dib.h"
 #include "wx/app.h"         // for GetComCtl32Version
 

+// ----------------------------------------------------------------------------
+// conditional compilation
+// ----------------------------------------------------------------------------
+
+// wxWindows previously always considered that toolbar buttons have light grey
+// (0xc0c0c0) background and so ignored any bitmap masks - however, this
+// doesn't work with XPMs which then appear to have black background. To make
+// this work, we must respect the bitmap masks - which we do now. This should
+// be ok in any case, but to restore 100% compatible with the old version
+// behaviour, you can set this to 0.
+#define USE_BITMAP_MASKS 1
+

 // ----------------------------------------------------------------------------
 // constants
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // constants
 // ----------------------------------------------------------------------------


@@ -95,13 +108,14 @@
 // private function prototypes
 // ----------------------------------------------------------------------------
 
 // private function prototypes
 // ----------------------------------------------------------------------------
 

-static void wxMapBitmap(HBITMAP hBitmap, int width, int height);
+// adjust toolbar bitmap colours
+// static void wxMapBitmap(HBITMAP hBitmap, int width, int height);

 
 // ----------------------------------------------------------------------------
 // wxWin macros
 // ----------------------------------------------------------------------------
 
 
 // ----------------------------------------------------------------------------
 // wxWin macros
 // ----------------------------------------------------------------------------
 

-IMPLEMENT_DYNAMIC_CLASS(wxToolBar, wxControl)
+IMPLEMENT_DYNAMIC_CLASS(wxToolBar, wxToolBarBase)

 
 BEGIN_EVENT_TABLE(wxToolBar, wxToolBarBase)
     EVT_MOUSE_EVENTS(wxToolBar::OnMouseEvent)
 
 BEGIN_EVENT_TABLE(wxToolBar, wxToolBarBase)
     EVT_MOUSE_EVENTS(wxToolBar::OnMouseEvent)


@@ -200,6 +214,9 @@ bool wxToolBar::Create(wxWindow *parent,
     if (style & wxBORDER)
         msflags |= WS_BORDER;
 
     if (style & wxBORDER)
         msflags |= WS_BORDER;
 

+   if ( style & wxCLIP_SIBLINGS )
+        msflags |= WS_CLIPSIBLINGS;
+

 #ifdef TBSTYLE_TOOLTIPS
     msflags |= TBSTYLE_TOOLTIPS;
 #endif
 #ifdef TBSTYLE_TOOLTIPS
     msflags |= TBSTYLE_TOOLTIPS;
 #endif


@@ -245,7 +262,18 @@ bool wxToolBar::Create(wxWindow *parent,
 
 wxToolBar::~wxToolBar()
 {
 
 wxToolBar::~wxToolBar()
 {

-    if (m_hBitmap)
+    // we must refresh the frame size when the toolbar is deleted but the frame
+    // is not - otherwise toolbar leaves a hole in the place it used to occupy
+    //
+    // NB: a frame is being deleted only if it is not any longer in
+    //     wxTopLevelWindows list
+    wxFrame *frame = wxDynamicCast(GetParent(), wxFrame);
+    if ( frame && wxTopLevelWindows.Find(frame) )
+    {
+        frame->SendSizeEvent();
+    }
+
+    if ( m_hBitmap )

     {
         ::DeleteObject((HBITMAP) m_hBitmap);
     }
     {
         ::DeleteObject((HBITMAP) m_hBitmap);
     }


@@ -267,8 +295,32 @@ bool wxToolBar::DoInsertTool(size_t WXUNUSED(pos),
 
 bool wxToolBar::DoDeleteTool(size_t pos, wxToolBarToolBase *tool)
 {
 
 bool wxToolBar::DoDeleteTool(size_t pos, wxToolBarToolBase *tool)
 {

-    // normally, we only delete one button, but we use several separators to
-    // cover the space used by one control sometimes (with old comctl32.dll)
+    // the main difficulty we have here is with the controls in the toolbars:
+    // as we (sometimes) use several separators to cover up the space used by
+    // them, the indices are not the same for us and the toolbar
+
+    // first determine the position of the first button to delete: it may be
+    // different from pos if we use several separators to cover the space used
+    // by a control
+    wxToolBarToolsList::Node *node;
+    for ( node = m_tools.GetFirst(); node; node = node->GetNext() )
+    {
+        wxToolBarToolBase *tool2 = node->GetData();
+        if ( tool2 == tool )
+        {
+            // let node point to the next node in the list
+            node = node->GetNext();
+
+            break;
+        }
+
+        if ( tool2->IsControl() )
+        {
+            pos += ((wxToolBarTool *)tool2)->GetSeparatorsCount() - 1;
+        }
+    }
+
+    // now determine the number of buttons to delete and the area taken by them

     size_t nButtonsToDelete = 1;
 
     // get the size of the button we're going to delete
     size_t nButtonsToDelete = 1;
 
     // get the size of the button we're going to delete


@@ -287,11 +339,13 @@ bool wxToolBar::DoDeleteTool(size_t pos, wxToolBarToolBase *tool)
         width *= nButtonsToDelete;
     }
 
         width *= nButtonsToDelete;
     }
 

+    // do delete all buttons
+    m_nButtons -= nButtonsToDelete;

     while ( nButtonsToDelete-- > 0 )
     {
         if ( !::SendMessage(GetHwnd(), TB_DELETEBUTTON, pos, 0) )
         {
     while ( nButtonsToDelete-- > 0 )
     {
         if ( !::SendMessage(GetHwnd(), TB_DELETEBUTTON, pos, 0) )
         {

-            wxLogLastError("TB_DELETEBUTTON");
+            wxLogLastError(wxT("TB_DELETEBUTTON"));

 
             return FALSE;
         }
 
             return FALSE;
         }


@@ -299,11 +353,9 @@ bool wxToolBar::DoDeleteTool(size_t pos, wxToolBarToolBase *tool)
 
     tool->Detach();
 
 
     tool->Detach();
 

-    m_nButtons -= nButtonsToDelete;
-
-    // reposition all the controls after this button
-    wxToolBarToolsList::Node *node = m_tools.Item(pos);
-    for ( node = node->GetNext(); node; node = node->GetNext() )
+    // and finally reposition all the controls after this button (the toolbar
+    // takes care of all normal items)
+    for ( /* node -> first after deleted */ ; node; node = node->GetNext() )

     {
         wxToolBarToolBase *tool2 = node->GetData();
         if ( tool2->IsControl() )
     {
         wxToolBarToolBase *tool2 = node->GetData();
         if ( tool2->IsControl() )


@@ -339,7 +391,17 @@ bool wxToolBar::Realize()
     int totalBitmapWidth = (int)(m_defaultWidth * nTools);
     int totalBitmapHeight = (int)m_defaultHeight;
 
     int totalBitmapWidth = (int)(m_defaultWidth * nTools);
     int totalBitmapHeight = (int)m_defaultHeight;
 

-    // Create a bitmap for all the tool bitmaps
+    // Create a bitmap and copy all the tool bitmaps to it
+#if USE_BITMAP_MASKS
+    wxMemoryDC dcAllButtons;
+    wxBitmap bitmap(totalBitmapWidth, totalBitmapHeight);
+    dcAllButtons.SelectObject(bitmap);
+    dcAllButtons.SetBackground(*wxLIGHT_GREY_BRUSH);
+    dcAllButtons.Clear();
+
+    m_hBitmap = bitmap.GetHBITMAP();
+    HBITMAP hBitmap = (HBITMAP)m_hBitmap;
+#else // !USE_BITMAP_MASKS

     HBITMAP hBitmap = ::CreateCompatibleBitmap(ScreenHDC(),
                                                totalBitmapWidth,
                                                totalBitmapHeight);
     HBITMAP hBitmap = ::CreateCompatibleBitmap(ScreenHDC(),
                                                totalBitmapWidth,
                                                totalBitmapHeight);


@@ -352,11 +414,11 @@ bool wxToolBar::Realize()
 
     m_hBitmap = (WXHBITMAP)hBitmap;
 
 
     m_hBitmap = (WXHBITMAP)hBitmap;
 

-    // Now blit all the tools onto this bitmap

     HDC memoryDC = ::CreateCompatibleDC(NULL);
     HBITMAP oldBitmap = (HBITMAP) ::SelectObject(memoryDC, hBitmap);
 
     HDC memoryDC2 = ::CreateCompatibleDC(NULL);
     HDC memoryDC = ::CreateCompatibleDC(NULL);
     HBITMAP oldBitmap = (HBITMAP) ::SelectObject(memoryDC, hBitmap);
 
     HDC memoryDC2 = ::CreateCompatibleDC(NULL);

+#endif // USE_BITMAP_MASKS/!USE_BITMAP_MASKS

 
     // the button position
     wxCoord x = 0;
 
     // the button position
     wxCoord x = 0;


@@ -370,17 +432,23 @@ bool wxToolBar::Realize()
         wxToolBarToolBase *tool = node->GetData();
         if ( tool->IsButton() )
         {
         wxToolBarToolBase *tool = node->GetData();
         if ( tool->IsButton() )
         {

-            HBITMAP hbmp = GetHbitmapOf(tool->GetBitmap1());
-            if ( hbmp )
+            const wxBitmap& bmp = tool->GetBitmap1();
+            if ( bmp.Ok() )

             {
             {

+#if USE_BITMAP_MASKS
+                // notice the last parameter: do use mask
+                dcAllButtons.DrawBitmap(tool->GetBitmap1(), x, 0, TRUE);
+#else // !USE_BITMAP_MASKS
+                HBITMAP hbmp = GetHbitmapOf(bmp);

                 HBITMAP oldBitmap2 = (HBITMAP)::SelectObject(memoryDC2, hbmp);
                 if ( !BitBlt(memoryDC, x, 0,  m_defaultWidth, m_defaultHeight,
                              memoryDC2, 0, 0, SRCCOPY) )
                 {
                 HBITMAP oldBitmap2 = (HBITMAP)::SelectObject(memoryDC2, hbmp);
                 if ( !BitBlt(memoryDC, x, 0,  m_defaultWidth, m_defaultHeight,
                              memoryDC2, 0, 0, SRCCOPY) )
                 {

-                    wxLogLastError("BitBlt");
+                    wxLogLastError(wxT("BitBlt"));

                 }
 
                 ::SelectObject(memoryDC2, oldBitmap2);
                 }
 
                 ::SelectObject(memoryDC2, oldBitmap2);

+#endif // USE_BITMAP_MASKS/!USE_BITMAP_MASKS

             }
             else
             {
             }
             else
             {


@@ -397,12 +465,19 @@ bool wxToolBar::Realize()
         node = node->GetNext();
     }
 
         node = node->GetNext();
     }
 

+#if USE_BITMAP_MASKS
+    dcAllButtons.SelectObject(wxNullBitmap);
+
+    // don't delete this HBITMAP!
+    bitmap.SetHBITMAP(0);
+#else // !USE_BITMAP_MASKS

     ::SelectObject(memoryDC, oldBitmap);
     ::DeleteDC(memoryDC);
     ::DeleteDC(memoryDC2);
     ::SelectObject(memoryDC, oldBitmap);
     ::DeleteDC(memoryDC);
     ::DeleteDC(memoryDC2);

+#endif // USE_BITMAP_MASKS/!USE_BITMAP_MASKS

 
     // Map to system colours
 
     // Map to system colours

-    wxMapBitmap(hBitmap, totalBitmapWidth, totalBitmapHeight);
+    MapBitmap((WXHBITMAP) hBitmap, totalBitmapWidth, totalBitmapHeight);

 
     int bitmapId = 0;
 
 
     int bitmapId = 0;
 


@@ -446,7 +521,7 @@ bool wxToolBar::Realize()
         {
             if ( !::SendMessage(GetHwnd(), TB_DELETEBUTTON, 0, 0) )
             {
         {
             if ( !::SendMessage(GetHwnd(), TB_DELETEBUTTON, 0, 0) )
             {

-                wxLogLastError("TB_DELETEBUTTON");
+                wxLogDebug(wxT("TB_DELETEBUTTON failed"));

             }
         }
 
             }
         }
 


@@ -518,7 +593,7 @@ bool wxToolBar::Realize()
     if ( !::SendMessage(GetHwnd(), TB_ADDBUTTONS,
                         (WPARAM)i, (LPARAM)buttons) )
     {
     if ( !::SendMessage(GetHwnd(), TB_ADDBUTTONS,
                         (WPARAM)i, (LPARAM)buttons) )
     {

-        wxLogLastError("TB_ADDBUTTONS");
+        wxLogLastError(wxT("TB_ADDBUTTONS"));

     }
 
     delete [] buttons;
     }
 
     delete [] buttons;


@@ -547,7 +622,7 @@ bool wxToolBar::Realize()
         if ( !SendMessage(GetHwnd(), TB_GETITEMRECT,
                           index, (LPARAM)(LPRECT)&r) )
         {
         if ( !SendMessage(GetHwnd(), TB_GETITEMRECT,
                           index, (LPARAM)(LPRECT)&r) )
         {

-            wxLogLastError("TB_GETITEMRECT");
+            wxLogLastError(wxT("TB_GETITEMRECT"));

         }
 
         // TB_SETBUTTONINFO message is only supported by comctl32.dll 4.71+
         }
 
         // TB_SETBUTTONINFO message is only supported by comctl32.dll 4.71+


@@ -566,7 +641,7 @@ bool wxToolBar::Realize()
                                   tool->GetId(), (LPARAM)&tbbi) )
                 {
                     // the id is probably invalid?
                                   tool->GetId(), (LPARAM)&tbbi) )
                 {
                     // the id is probably invalid?

-                    wxLogLastError("TB_SETBUTTONINFO");
+                    wxLogLastError(wxT("TB_SETBUTTONINFO"));

                 }
             }
             else
                 }
             }
             else


@@ -580,7 +655,7 @@ bool wxToolBar::Realize()
                 TBBUTTON tbb;
                 wxZeroMemory(tbb);
                 tbb.idCommand = 0;
                 TBBUTTON tbb;
                 wxZeroMemory(tbb);
                 tbb.idCommand = 0;

-                tbb.fsState = TBSTATE_ENABLED | TBSTATE_HIDDEN;
+                tbb.fsState = TBSTATE_ENABLED;

                 tbb.fsStyle = TBSTYLE_SEP;
 
                 size_t nSeparators = size.x / widthSep;
                 tbb.fsStyle = TBSTYLE_SEP;
 
                 size_t nSeparators = size.x / widthSep;


@@ -589,7 +664,7 @@ bool wxToolBar::Realize()
                     if ( !SendMessage(GetHwnd(), TB_INSERTBUTTON,
                                       index, (LPARAM)&tbb) )
                     {
                     if ( !SendMessage(GetHwnd(), TB_INSERTBUTTON,
                                       index, (LPARAM)&tbb) )
                     {

-                        wxLogLastError("TB_INSERTBUTTON");
+                        wxLogLastError(wxT("TB_INSERTBUTTON"));

                     }
 
                     index++;
                     }
 
                     index++;


@@ -645,7 +720,7 @@ bool wxToolBar::Realize()
 // message handlers
 // ----------------------------------------------------------------------------
 
 // message handlers
 // ----------------------------------------------------------------------------
 

-bool wxToolBar::MSWCommand(WXUINT cmd, WXWORD id)
+bool wxToolBar::MSWCommand(WXUINT WXUNUSED(cmd), WXWORD id)

 {
     wxToolBarToolBase *tool = FindById((int)id);
     if ( !tool )
 {
     wxToolBarToolBase *tool = FindById((int)id);
     if ( !tool )


@@ -675,7 +750,7 @@ bool wxToolBar::MSWCommand(WXUINT cmd, WXWORD id)
 
 bool wxToolBar::MSWOnNotify(int WXUNUSED(idCtrl),
                             WXLPARAM lParam,
 
 bool wxToolBar::MSWOnNotify(int WXUNUSED(idCtrl),
                             WXLPARAM lParam,

-                            WXLPARAM *result)
+                            WXLPARAM *WXUNUSED(result))

 {
     // First check if this applies to us
     NMHDR *hdr = (NMHDR *)lParam;
 {
     // First check if this applies to us
     NMHDR *hdr = (NMHDR *)lParam;


@@ -705,11 +780,17 @@ bool wxToolBar::MSWOnNotify(int WXUNUSED(idCtrl),
         {
             ttText->lpszText = (wxChar *)help.c_str();
         }
         {
             ttText->lpszText = (wxChar *)help.c_str();
         }

-#if (_WIN32_IE >= 0x0300)

         else
         {
         else
         {

-            // FIXME this is a temp hack only until I understand better what
-            //       must be done in both ANSI and Unicode builds
+#if wxUSE_UNICODE
+            ttText->lpszText = (wxChar *)help.c_str();
+#else
+            // VZ: I don't know why it happens, but the versions of
+            //     comctl32.dll starting from 4.70 sometimes send TTN_NEEDTEXTW
+            //     even to ANSI programs (normally, this message is supposed
+            //     to be sent to Unicode programs only) - hence we need to
+            //     handle it as well, otherwise no tooltips will be shown in
+            //     this case

 
             size_t lenAnsi = help.Len();
             #ifdef __MWERKS__
 
             size_t lenAnsi = help.Len();
             #ifdef __MWERKS__


@@ -730,8 +811,8 @@ bool wxToolBar::MSWOnNotify(int WXUNUSED(idCtrl),
             dst[lenUnicode] = 0;
 
             delete [] pwz;
             dst[lenUnicode] = 0;
 
             delete [] pwz;

+#endif

         }
         }

-#endif // _WIN32_IE >= 0x0300

     }
 
     // For backward compatibility...
     }
 
     // For backward compatibility...


@@ -775,7 +856,8 @@ void wxToolBar::SetRows(int nRows)
 wxSize wxToolBar::GetToolSize() const
 {
     // TB_GETBUTTONSIZE is supported from version 4.70
 wxSize wxToolBar::GetToolSize() const
 {
     // TB_GETBUTTONSIZE is supported from version 4.70

-#if defined(_WIN32_IE) && (_WIN32_IE >= 0x300 )
+#if defined(_WIN32_IE) && (_WIN32_IE >= 0x300 ) \
+    && !( defined(__GNUWIN32__) && !wxCHECK_W32API_VERSION( 1, 0 ) )

     if ( wxTheApp->GetComCtl32Version() >= 470 )
     {
         DWORD dw = ::SendMessage(GetHwnd(), TB_GETBUTTONSIZE, 0, 0);
     if ( wxTheApp->GetComCtl32Version() >= 470 )
     {
         DWORD dw = ::SendMessage(GetHwnd(), TB_GETBUTTONSIZE, 0, 0);


@@ -814,15 +896,7 @@ void wxToolBar::UpdateSize()
     wxFrame *frame = wxDynamicCast(GetParent(), wxFrame);
     if ( frame )
     {
     wxFrame *frame = wxDynamicCast(GetParent(), wxFrame);
     if ( frame )
     {

-        // don't change the size, we just need to generate a WM_SIZE
-        RECT r;
-        if ( !GetWindowRect(GetHwndOf(frame), &r) )
-        {
-            wxLogLastError(_T("GetWindowRect"));
-        }
-
-        (void)::SendMessage(GetHwndOf(frame), WM_SIZE, SIZE_RESTORED,
-                            MAKELPARAM(r.right - r.left, r.bottom - r.top));
+        frame->SendSizeEvent();

     }
 }
 
     }
 }
 


@@ -842,7 +916,7 @@ void wxToolBar::DoToggleTool(wxToolBarToolBase *tool, bool toggle)
                   (WPARAM)tool->GetId(), (LPARAM)MAKELONG(toggle, 0));
 }
 
                   (WPARAM)tool->GetId(), (LPARAM)MAKELONG(toggle, 0));
 }
 

-void wxToolBar::DoSetToggle(wxToolBarToolBase *tool, bool toggle)
+void wxToolBar::DoSetToggle(wxToolBarToolBase *WXUNUSED(tool), bool WXUNUSED(toggle))

 {
     // VZ: AFAIK, the button has to be created either with TBSTYLE_CHECK or
     //     without, so we really need to delete the button and recreate it here
 {
     // VZ: AFAIK, the button has to be created either with TBSTYLE_CHECK or
     //     without, so we really need to delete the button and recreate it here


@@ -856,16 +930,20 @@ void wxToolBar::DoSetToggle(wxToolBarToolBase *tool, bool toggle)
 // Responds to colour changes, and passes event on to children.
 void wxToolBar::OnSysColourChanged(wxSysColourChangedEvent& event)
 {
 // Responds to colour changes, and passes event on to children.
 void wxToolBar::OnSysColourChanged(wxSysColourChangedEvent& event)
 {

-    m_backgroundColour = wxColour(GetRValue(GetSysColor(COLOR_BTNFACE)),
-          GetGValue(GetSysColor(COLOR_BTNFACE)), GetBValue(GetSysColor(COLOR_BTNFACE)));
+    wxRGBToColour(m_backgroundColour, ::GetSysColor(COLOR_BTNFACE));

 
     // Remap the buttons
     Realize();
 
 
     // Remap the buttons
     Realize();
 

+    // Relayout the toolbar
+    int nrows = m_maxRows;
+    m_maxRows = 0;      // otherwise SetRows() wouldn't do anything
+    SetRows(nrows);
+

     Refresh();
 
     Refresh();
 

-    // Propagate the event to the non-top-level children
-    wxWindow::OnSysColourChanged(event);
+    // let the event propagate further
+    event.Skip();

 }
 
 void wxToolBar::OnMouseEvent(wxMouseEvent& event)
 }
 
 void wxToolBar::OnMouseEvent(wxMouseEvent& event)


@@ -932,102 +1010,122 @@ long wxToolBar::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
 // private functions
 // ----------------------------------------------------------------------------
 
 // private functions
 // ----------------------------------------------------------------------------
 

-// These are the default colors used to map the bitmap colors to the current
-// system colors. Note that they are in BGR format because this is what Windows
-// wants (and not RGB)
-
-#define BGR_BUTTONTEXT      (RGB(000,000,000))  // black
-#define BGR_BUTTONSHADOW    (RGB(128,128,128))  // dark grey
-#define BGR_BUTTONFACE      (RGB(192,192,192))  // bright grey
-#define BGR_BUTTONHILIGHT   (RGB(255,255,255))  // white
-#define BGR_BACKGROUNDSEL   (RGB(000,000,255))  // blue
-#define BGR_BACKGROUND      (RGB(255,000,255))  // magenta
+bool wxToolBar::sm_coloursInit = FALSE;
+long wxToolBar::sm_stdColours[6];

 
 

-void wxMapBitmap(HBITMAP hBitmap, int width, int height)
+void wxToolBar::MapBitmap(WXHBITMAP bitmap, int width, int height)

 {
 {

-  COLORMAP ColorMap[] =
-  {
-    {BGR_BUTTONTEXT,    COLOR_BTNTEXT},     // black
-    {BGR_BUTTONSHADOW,  COLOR_BTNSHADOW},   // dark grey
-    {BGR_BUTTONFACE,    COLOR_BTNFACE},     // bright grey
-    {BGR_BUTTONHILIGHT, COLOR_BTNHIGHLIGHT},// white
-/*    {BGR_BACKGROUNDSEL, COLOR_HIGHLIGHT},   // blue */
-    {BGR_BACKGROUND,    COLOR_WINDOW}       // magenta
-  };
-
-  int NUM_MAPS = (sizeof(ColorMap)/sizeof(COLORMAP));
-  int n;
-  for ( n = 0; n < NUM_MAPS; n++)
-  {
-    ColorMap[n].to = ::GetSysColor(ColorMap[n].to);
-  }
-
-  HBITMAP hbmOld;
-  HDC hdcMem = CreateCompatibleDC(NULL);
-
-  if (hdcMem)
-  {
-    hbmOld = (HBITMAP) SelectObject(hdcMem, hBitmap);
-
-    int i, j, k;
-    for ( i = 0; i < width; i++)
+    if (!sm_coloursInit)

     {
     {

-        for ( j = 0; j < height; j++)
+        // When a bitmap is loaded, the RGB values can change. So we need to have a
+        // reference bitmap which can tell us what the RGB values change to.
+        wxBitmap stdColourBitmap("wxBITMAP_STD_COLOURS", wxBITMAP_TYPE_RESOURCE);
+        if (stdColourBitmap.Ok())

         {
         {

-            COLORREF pixel = ::GetPixel(hdcMem, i, j);
-/*
-            BYTE red = GetRValue(pixel);
-            BYTE green = GetGValue(pixel);
-            BYTE blue = GetBValue(pixel);
-*/
-
-            for ( k = 0; k < NUM_MAPS; k ++)
+            wxMemoryDC memDC;
+            memDC.SelectObject(stdColourBitmap);
+
+            int i = 0;
+            wxColour colour;
+            for (i = 0; i < 6; i++)

             {
             {

-                if ( ColorMap[k].from == pixel )
-                {
-                    /* COLORREF actualPixel = */ ::SetPixel(hdcMem, i, j, ColorMap[k].to);
-                    break;
-                }
+                memDC.GetPixel(i, 0, & colour);
+                sm_stdColours[i] = RGB(colour.Red(), colour.Green(), colour.Blue());

             }
             }

+            sm_coloursInit = TRUE;
+            memDC.SelectObject(wxNullBitmap);
+        }
+        else
+        {
+            sm_stdColours[0] = RGB(000,000,000) ;
+            sm_stdColours[1] = RGB(128,128,128) ;
+            sm_stdColours[2] = RGB(192,192,192) ;
+            sm_stdColours[3] = RGB(255,255,255) ;
+            sm_stdColours[4] = RGB(000,000,255) ;
+            sm_stdColours[5] = RGB(255,000,255) ;
+            sm_coloursInit = TRUE;

         }
     }
 
         }
     }
 

+    HBITMAP hBitmap = (HBITMAP) bitmap;
+
+    COLORMAP ColorMap[5];
+
+    ColorMap[0].from = sm_stdColours[0]; ColorMap[0].to = COLOR_BTNTEXT;      // black        (0, 0 0)
+    ColorMap[1].from = sm_stdColours[1]; ColorMap[1].to = COLOR_BTNSHADOW;    // dark grey    (128, 128, 128)
+    ColorMap[2].from = sm_stdColours[2]; ColorMap[2].to = COLOR_BTNFACE;      // bright grey  (192, 192, 192)
+    ColorMap[3].from = sm_stdColours[3]; ColorMap[3].to = COLOR_BTNHIGHLIGHT; // white        (255, 255, 255)
+    //  ColorMap[4].from = sm_stdColours[4]; ColorMap[4].to = COLOR_HIGHLIGHT;  // blue         (0, 0, 255)
+    ColorMap[4].from = sm_stdColours[5]; ColorMap[4].to = COLOR_WINDOW;       // magenta      (255, 0, 255)
+
+    for ( int n = 0; n < WXSIZEOF(ColorMap); n++)
+    {
+        ColorMap[n].to = ::GetSysColor(ColorMap[n].to);
+    }
+
+    HBITMAP hbmOld;
+    HDC hdcMem = CreateCompatibleDC(NULL);
+
+    if (hdcMem)
+    {
+        hbmOld = (HBITMAP) SelectObject(hdcMem, hBitmap);
+
+        for ( int i = 0; i < width; i++ )
+        {
+            for ( int j = 0; j < height; j++ )
+            {
+                COLORREF pixel = ::GetPixel(hdcMem, i, j);
+
+                for ( int k = 0; k < WXSIZEOF(ColorMap); k++ )
+                {
+                    int distance = abs( GetRValue( pixel ) - GetRValue( ColorMap[k].from )) ;
+                    distance = max( distance , abs(GetGValue(pixel ) - GetGValue( ColorMap[k].from ))) ;
+                    distance = max( distance , abs(GetBValue(pixel ) - GetBValue( ColorMap[k].from ))) ;
+                    if ( distance < 0x10 )
+                    {
+                        ::SetPixel(hdcMem, i, j, ColorMap[k].to);
+                        break;
+                    }
+                }
+            }
+        }

 
 

-    SelectObject(hdcMem, hbmOld);
-    DeleteObject(hdcMem);
-  }

 
 

+        SelectObject(hdcMem, hbmOld);
+        DeleteObject(hdcMem);
+    }

 }
 
 // Some experiments...
 #if 0
 }
 
 // Some experiments...
 #if 0

-  // What we want to do is create another bitmap which has a depth of 4,
-  // and set the bits. So probably we want to convert this HBITMAP into a
-  // DIB, then call SetDIBits.
-  // AAAGH. The stupid thing is that if newBitmap has a depth of 4 (less than that of
-  // the screen), then SetDIBits fails.
-  HBITMAP newBitmap = ::CreateBitmap(totalBitmapWidth, totalBitmapHeight, 1, 4, NULL);
-  HANDLE newDIB = ::BitmapToDIB((HBITMAP) m_hBitmap, NULL);
-  LPBITMAPINFOHEADER lpbmi = (LPBITMAPINFOHEADER) GlobalLock(newDIB);
-
-  dc = ::GetDC(NULL);
+// What we want to do is create another bitmap which has a depth of 4,
+// and set the bits. So probably we want to convert this HBITMAP into a
+// DIB, then call SetDIBits.
+// AAAGH. The stupid thing is that if newBitmap has a depth of 4 (less than that of
+// the screen), then SetDIBits fails.
+HBITMAP newBitmap = ::CreateBitmap(totalBitmapWidth, totalBitmapHeight, 1, 4, NULL);
+HANDLE newDIB = ::BitmapToDIB((HBITMAP) m_hBitmap, NULL);
+LPBITMAPINFOHEADER lpbmi = (LPBITMAPINFOHEADER) GlobalLock(newDIB);
+
+dc = ::GetDC(NULL);

 //  LPBITMAPINFOHEADER lpbmi = (LPBITMAPINFOHEADER) newDIB;
 
 //  LPBITMAPINFOHEADER lpbmi = (LPBITMAPINFOHEADER) newDIB;
 

-  int result = ::SetDIBits(dc, newBitmap, 0, lpbmi->biHeight, FindDIBBits((LPSTR)lpbmi), (LPBITMAPINFO)lpbmi,
-    DIB_PAL_COLORS);
-  DWORD err = GetLastError();
+int result = ::SetDIBits(dc, newBitmap, 0, lpbmi->biHeight, FindDIBBits((LPSTR)lpbmi), (LPBITMAPINFO)lpbmi,
+                         DIB_PAL_COLORS);
+DWORD err = GetLastError();

 
 

-  ::ReleaseDC(NULL, dc);
+::ReleaseDC(NULL, dc);

 
 

-  // Delete the DIB
-  GlobalUnlock (newDIB);
-  GlobalFree (newDIB);
+// Delete the DIB
+GlobalUnlock (newDIB);
+GlobalFree (newDIB);

 
 //  WXHBITMAP hBitmap2 = wxCreateMappedBitmap((WXHINSTANCE) wxGetInstance(), (WXHBITMAP) m_hBitmap);
 
 //  WXHBITMAP hBitmap2 = wxCreateMappedBitmap((WXHINSTANCE) wxGetInstance(), (WXHBITMAP) m_hBitmap);

-  // Substitute our new bitmap for the old one
-  ::DeleteObject((HBITMAP) m_hBitmap);
-  m_hBitmap = (WXHBITMAP) newBitmap;
+// Substitute our new bitmap for the old one
+::DeleteObject((HBITMAP) m_hBitmap);
+m_hBitmap = (WXHBITMAP) newBitmap;

 #endif
 
 
 #endif // wxUSE_TOOLBAR && Win95
 #endif
 
 
 #endif // wxUSE_TOOLBAR && Win95

+