src/msw/tbar95.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        tbar95.cpp
   3 // Purpose:     wxToolBar95
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     04/01/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart and Markus Holzem
   9 // Licence:     wxWindows license
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #ifdef __GNUG__
  13 #pragma implementation "tbar95.h"
  14 #endif
  15
  16 // For compilers that support precompilation, includes "wx.h".
  17 #include "wx/wxprec.h"
  18
  19 #ifdef __BORLANDC__
  20 #pragma hdrstop
  21 #endif
  22
  23 #ifndef WX_PRECOMP
  24 #include "wx/wx.h"
  25 #endif
  26
  27 #if wxUSE_BUTTONBAR && wxUSE_TOOLBAR && defined(__WIN95__)
  28
  29 #if !defined(__GNUWIN32__) && !defined(__SALFORDC__)
  30 #include "malloc.h"
  31 #endif
  32
  33 #include <windows.h>
  34
  35 #if (defined(__WIN95__) && !defined(__GNUWIN32__)) || defined(__TWIN32__)
  36 #include <commctrl.h>
  37 #endif
  38
  39 #ifndef __TWIN32__
  40 #ifdef __GNUWIN32__
  41 #include "wx/msw/gnuwin32/extra.h"
  42 #endif
  43 #endif
  44
  45 #include "wx/msw/dib.h"
  46 #include "wx/tbar95.h"
  47 #include "wx/app.h"
  48 #include "wx/msw/private.h"
  49
  50 // Styles
  51 #ifndef TBSTYLE_FLAT
  52 #define TBSTYLE_LIST            0x1000
  53 #define TBSTYLE_FLAT            0x0800
  54 #define TBSTYLE_TRANSPARENT     0x8000
  55 #endif
  56  // use TBSTYLE_TRANSPARENT if you use TBSTYLE_FLAT
  57
  58 // Messages
  59 #ifndef TB_GETSTYLE
  60 #define TB_GETSTYLE             (WM_USER + 57)
  61 #define TB_SETSTYLE             (WM_USER + 56)
  62 #endif
  63
  64 /* Hint from a newsgroup for custom flatbar drawing:
  65 Set the TBSTYLE_CUSTOMERASE style, then handle the
  66 NM_CUSTOMDRAW message and do your custom drawing.
  67 */
  68
  69 #define DEFAULTBITMAPX   16
  70 #define DEFAULTBITMAPY   15
  71 #define DEFAULTBUTTONX   24
  72 #define DEFAULTBUTTONY   24
  73 #define DEFAULTBARHEIGHT 27
  74
  75 #if !USE_SHARED_LIBRARY
  76 IMPLEMENT_DYNAMIC_CLASS(wxToolBar95, wxToolBarBase)
  77 #endif
  78
  79 BEGIN_EVENT_TABLE(wxToolBar95, wxToolBarBase)
  80     EVT_SIZE(wxToolBar95::OnSize)
  81     EVT_PAINT(wxToolBar95::OnPaint)
  82     EVT_MOUSE_EVENTS(wxToolBar95::OnMouseEvent)
  83     EVT_KILL_FOCUS(wxToolBar95::OnKillFocus)
  84     EVT_SYS_COLOUR_CHANGED(wxToolBar95::OnSysColourChanged)
  85 END_EVENT_TABLE()
  86
  87 static void wxMapBitmap(HBITMAP hBitmap, int width, int height);
  88
  89 wxToolBar95::wxToolBar95()
  90 {
  91   m_maxWidth = -1;
  92   m_maxHeight = -1;
  93   m_hBitmap = 0;
  94   m_defaultWidth = DEFAULTBITMAPX;
  95   m_defaultHeight = DEFAULTBITMAPY;
  96 }
  97
  98 bool wxToolBar95::Create(wxWindow *parent,
  99                          wxWindowID id,
 100                          const wxPoint& pos,
 101                          const wxSize& size,
 102                          long style,
 103                          const wxString& name)
 104 {
 105   m_backgroundColour = wxColour(GetRValue(GetSysColor(COLOR_BTNFACE)),
 106                                 GetGValue(GetSysColor(COLOR_BTNFACE)),
 107                                 GetBValue(GetSysColor(COLOR_BTNFACE)));
 108   m_foregroundColour = *wxBLACK ;
 109
 110   wxASSERT_MSG( (style & wxTB_VERTICAL) == 0,
 111                 "Sorry, wxToolBar95 under Windows 95 only "
 112                 "supports horizontal orientation." );
 113
 114   m_maxWidth = -1;
 115   m_maxHeight = -1;
 116
 117   m_hBitmap = 0;
 118
 119   m_defaultWidth = DEFAULTBITMAPX;
 120   m_defaultHeight = DEFAULTBITMAPY;
 121   SetName(name);
 122
 123   m_windowStyle = style;
 124
 125   SetFont(wxSystemSettings::GetSystemFont(wxSYS_DEFAULT_GUI_FONT));
 126   SetParent(parent);
 127
 128   int x = pos.x;
 129   int y = pos.y;
 130   int width = size.x;
 131   int height = size.y;
 132
 133   if (width <= 0)
 134     width = 100;
 135   if (height <= 0)
 136     height = 30;
 137   if (x < 0)
 138     x = 0;
 139   if (y < 0)
 140     y = 0;
 141
 142   m_windowId = (id < 0 ? NewControlId() : id);
 143   DWORD msflags = 0;
 144   if (style & wxBORDER)
 145     msflags |= WS_BORDER;
 146   msflags |= WS_CHILD | WS_VISIBLE | TBSTYLE_TOOLTIPS;
 147
 148   if (style & wxTB_FLAT)
 149   {
 150     if (wxTheApp->GetComCtl32Version() > 400)
 151         msflags |= TBSTYLE_FLAT;
 152   }
 153
 154   bool want3D;
 155   WXDWORD exStyle = Determine3DEffects(WS_EX_CLIENTEDGE, &want3D) ;
 156
 157   // Even with extended styles, need to combine with WS_BORDER
 158   // for them to look right.
 159   if ( want3D || wxStyleHasBorder(m_windowStyle) )
 160       msflags |= WS_BORDER;
 161
 162   // Create the toolbar control.
 163   HWND hWndToolbar = CreateWindowEx
 164                      (
 165                       exStyle,                  // Extended styles.
 166                       TOOLBARCLASSNAME,         // Class name for the toolbar.
 167                       "",                       // No default text.
 168                       msflags,                  // Styles
 169                       x, y, width, height,      // Standard toolbar size and position.
 170                       (HWND) parent->GetHWND(), // Parent window of the toolbar.
 171                       (HMENU)m_windowId,        // Toolbar ID.
 172                       wxGetInstance(),          // Current instance.
 173                       NULL                      // No class data.
 174                      );
 175
 176   wxCHECK_MSG( hWndToolbar, FALSE, "Toolbar creation failed" );
 177
 178   // Toolbar-specific initialisation
 179   ::SendMessage(hWndToolbar, TB_BUTTONSTRUCTSIZE,
 180                 (WPARAM)sizeof(TBBUTTON), (LPARAM)0);
 181
 182   m_hWnd = (WXHWND) hWndToolbar;
 183   if (parent)
 184       parent->AddChild(this);
 185
 186   SubclassWin((WXHWND)hWndToolbar);
 187
 188   return TRUE;
 189 }
 190
 191 wxToolBar95::~wxToolBar95()
 192 {
 193   UnsubclassWin();
 194
 195   if (m_hBitmap)
 196   {
 197     ::DeleteObject((HBITMAP) m_hBitmap);
 198     m_hBitmap = 0;
 199   }
 200 }
 201
 202 bool wxToolBar95::CreateTools()
 203 {
 204   if (m_tools.Number() == 0)
 205     return FALSE;
 206
 207   HBITMAP oldToolBarBitmap = (HBITMAP) m_hBitmap;
 208
 209   int totalBitmapWidth = (int)(m_defaultWidth * m_tools.Number());
 210   int totalBitmapHeight = (int)m_defaultHeight;
 211
 212   // Create a bitmap for all the tool bitmaps
 213   HDC dc = ::GetDC(NULL);
 214   m_hBitmap = (WXHBITMAP) ::CreateCompatibleBitmap(dc, totalBitmapWidth, totalBitmapHeight);
 215   ::ReleaseDC(NULL, dc);
 216
 217   // Now blit all the tools onto this bitmap
 218   HDC memoryDC = ::CreateCompatibleDC(NULL);
 219   HBITMAP oldBitmap = (HBITMAP) ::SelectObject(memoryDC, (HBITMAP) m_hBitmap);
 220
 221   HDC memoryDC2 = ::CreateCompatibleDC(NULL);
 222   int x = 0;
 223   wxNode *node = m_tools.First();
 224   int noButtons = 0;
 225   while (node)
 226   {
 227     wxToolBarTool *tool = (wxToolBarTool *)node->Data();
 228     if ((tool->m_toolStyle != wxTOOL_STYLE_SEPARATOR) && tool->m_bitmap1.Ok() && tool->m_bitmap1.GetHBITMAP())
 229     {
 230 //      wxPalette *palette = tool->m_bitmap1->GetPalette();
 231
 232       HBITMAP oldBitmap2 = (HBITMAP) ::SelectObject(memoryDC2, (HBITMAP) tool->m_bitmap1.GetHBITMAP());
 233       /* int bltResult = */
 234       BitBlt(memoryDC, x, 0, (int) m_defaultWidth, (int) m_defaultHeight, memoryDC2,
 235                         0, 0, SRCCOPY);
 236       ::SelectObject(memoryDC2, oldBitmap2);
 237       x += (int)m_defaultWidth;
 238       noButtons ++;
 239     }
 240     node = node->Next();
 241   }
 242   ::SelectObject(memoryDC, oldBitmap);
 243   ::DeleteDC(memoryDC);
 244   ::DeleteDC(memoryDC2);
 245
 246   // Map to system colours
 247   wxMapBitmap((HBITMAP) m_hBitmap, totalBitmapWidth, totalBitmapHeight);
 248
 249   if ( oldToolBarBitmap )
 250   {
 251     TBREPLACEBITMAP replaceBitmap;
 252     replaceBitmap.hInstOld = NULL;
 253     replaceBitmap.hInstNew = NULL;
 254     replaceBitmap.nIDOld = (UINT) oldToolBarBitmap;
 255     replaceBitmap.nIDNew = (UINT) (HBITMAP) m_hBitmap;
 256     replaceBitmap.nButtons = noButtons;
 257     if (::SendMessage((HWND) GetHWND(), TB_REPLACEBITMAP, (WPARAM) 0, (LPARAM) &replaceBitmap) == -1)
 258       wxFAIL_MSG("Could not add bitmap to toolbar");
 259
 260     ::DeleteObject((HBITMAP) oldToolBarBitmap);
 261
 262     // Now delete all the buttons
 263     int i = 0;
 264     while ( TRUE )
 265     {
 266         // TODO: What about separators???? They don't have an id!
 267         if ( ! ::SendMessage( (HWND) GetHWND(), TB_DELETEBUTTON, i, 0 ) )
 268             break;
 269     }
 270   }
 271   else
 272   {
 273     TBADDBITMAP addBitmap;
 274     addBitmap.hInst = 0;
 275     addBitmap.nID = (UINT)m_hBitmap;
 276     if (::SendMessage((HWND) GetHWND(), TB_ADDBITMAP, (WPARAM) noButtons, (LPARAM) &addBitmap) == -1)
 277       wxFAIL_MSG("Could not add bitmap to toolbar");
 278   }
 279
 280   // Now add the buttons.
 281   TBBUTTON buttons[50];
 282
 283   node = m_tools.First();
 284   int i = 0;
 285   int bitmapId = 0;
 286   while (node)
 287   {
 288     wxToolBarTool *tool = (wxToolBarTool *)node->Data();
 289     if (tool->m_toolStyle == wxTOOL_STYLE_SEPARATOR)
 290     {
 291       buttons[i].iBitmap = 0;
 292       buttons[i].idCommand = 0;
 293
 294       buttons[i].fsState = TBSTATE_ENABLED;
 295       buttons[i].fsStyle = TBSTYLE_SEP;
 296       buttons[i].dwData = 0L;
 297       buttons[i].iString = 0;
 298     }
 299     else
 300     {
 301       buttons[i].iBitmap = bitmapId;
 302       buttons[i].idCommand = tool->m_index;
 303
 304       buttons[i].fsState = 0;
 305       if (tool->m_enabled)
 306         buttons[i].fsState |= TBSTATE_ENABLED;
 307       if (tool->m_toggleState)
 308         buttons[i].fsState |= TBSTATE_CHECKED;
 309       buttons[i].fsStyle = tool->m_isToggle ? TBSTYLE_CHECK : TBSTYLE_BUTTON;
 310       buttons[i].dwData = 0L;
 311       buttons[i].iString = 0;
 312
 313       bitmapId ++;
 314     }
 315
 316     i ++;
 317     node = node->Next();
 318   }
 319
 320   long rc = ::SendMessage((HWND) GetHWND(), TB_ADDBUTTONS, (WPARAM)i, (LPARAM)& buttons);
 321
 322   wxCHECK_MSG( rc, FALSE, "failed to add buttons to the toolbar" );
 323
 324   (void)::SendMessage((HWND) GetHWND(), TB_AUTOSIZE, (WPARAM)0, (LPARAM) 0);
 325
 326   SetRows(m_maxRows);
 327
 328   return TRUE;
 329 }
 330
 331 bool wxToolBar95::MSWCommand(WXUINT cmd, WXWORD id)
 332 {
 333   wxNode *node = m_tools.Find((long)id);
 334   if (!node)
 335     return FALSE;
 336   wxToolBarTool *tool = (wxToolBarTool *)node->Data();
 337   if (tool->m_isToggle)
 338     tool->m_toggleState = (1 == (1 & (int)::SendMessage((HWND) GetHWND(), TB_GETSTATE, (WPARAM) id, (LPARAM) 0)));
 339
 340   BOOL ret = OnLeftClick((int)id, tool->m_toggleState);
 341   if (ret == FALSE && tool->m_isToggle)
 342   {
 343     tool->m_toggleState = !tool->m_toggleState;
 344     ::SendMessage((HWND) GetHWND(), TB_CHECKBUTTON, (WPARAM)id, (LPARAM)MAKELONG(tool->m_toggleState, 0));
 345   }
 346   return TRUE;
 347 }
 348
 349 bool wxToolBar95::MSWNotify(WXWPARAM WXUNUSED(wParam),
 350                             WXLPARAM lParam,
 351                             WXLPARAM *result)
 352 {
 353     // First check if this applies to us
 354     NMHDR *hdr = (NMHDR *)lParam;
 355
 356     // the tooltips control created by the toolbar is sometimes Unicode, even in
 357     // an ANSI application
 358     if ( (hdr->code != TTN_NEEDTEXTA) && (hdr->code != TTN_NEEDTEXTW) )
 359         return FALSE;
 360
 361     HWND toolTipWnd = (HWND)::SendMessage((HWND)GetHWND(), TB_GETTOOLTIPS, 0, 0);
 362     if ( toolTipWnd != hdr->hwndFrom )
 363         return FALSE;
 364
 365     LPTOOLTIPTEXT ttText = (LPTOOLTIPTEXT)lParam;
 366     int id = (int)ttText->hdr.idFrom;
 367     wxNode *node = m_tools.Find((long)id);
 368     if (!node)
 369         return FALSE;
 370
 371     wxToolBarTool *tool = (wxToolBarTool *)node->Data();
 372
 373     const wxString& help = tool->m_shortHelpString;
 374
 375     if ( !help.IsEmpty() )
 376     {
 377         if ( hdr->code == TTN_NEEDTEXTA )
 378         {
 379             ttText->lpszText = (char *)help.c_str();
 380         }
 381 #if (_WIN32_IE >= 0x0300)
 382         else
 383         {
 384             // FIXME this is a temp hack only until I understand better what
 385             //       must be done in both ANSI and Unicode builds
 386
 387             size_t lenAnsi = help.Len();
 388             #ifdef __MWERKS__
 389                 // MetroWerks doesn't like calling mbstowcs with NULL argument
 390                 size_t lenUnicode = 2*lenAnsi;
 391             #else
 392                 size_t lenUnicode = mbstowcs(NULL, help, lenAnsi);
 393             #endif
 394
 395             // using the pointer of right type avoids us doing all sorts of
 396             // pointer arithmetics ourselves
 397             wchar_t *dst = (wchar_t *)ttText->szText,
 398                     *pwz = new wchar_t[lenUnicode + 1];
 399             mbstowcs(pwz, help, lenAnsi + 1);
 400             memcpy(dst, pwz, lenUnicode*sizeof(wchar_t));
 401
 402             // put the terminating _wide_ NUL
 403             dst[lenUnicode] = 0;
 404
 405             delete [] pwz;
 406         }
 407 #endif // _WIN32_IE >= 0x0300
 408     }
 409
 410     // For backward compatibility...
 411     OnMouseEnter(tool->m_index);
 412
 413     return TRUE;
 414 }
 415
 416 void wxToolBar95::SetToolBitmapSize(const wxSize& size)
 417 {
 418   m_defaultWidth = size.x;
 419   m_defaultHeight = size.y;
 420   ::SendMessage((HWND) GetHWND(), TB_SETBITMAPSIZE, 0, (LPARAM) MAKELONG ((int)size.x, (int)size.y));
 421 }
 422
 423 void wxToolBar95::SetRows(int nRows)
 424 {
 425   RECT rect;
 426   ::SendMessage((HWND) GetHWND(), TB_SETROWS, MAKEWPARAM(nRows, TRUE), (LPARAM) & rect);
 427   m_maxWidth = (rect.right - rect.left + 2);
 428   m_maxHeight = (rect.bottom - rect.top + 2);
 429 }
 430
 431 wxSize wxToolBar95::GetMaxSize() const
 432 {
 433   if ((m_maxWidth == -1) || (m_maxHeight == -1))
 434   {
 435     RECT rect;
 436     ::SendMessage((HWND) GetHWND(), TB_SETROWS, MAKEWPARAM(m_maxRows, TRUE), (LPARAM) & rect);
 437     ((wxToolBar95 *)this)->m_maxWidth = (rect.right - rect.left + 2); // ???
 438     ((wxToolBar95 *)this)->m_maxHeight = (rect.bottom - rect.top + 2); // ???
 439   }
 440   return wxSize(m_maxWidth, m_maxHeight);
 441 }
 442
 443 void wxToolBar95::GetSize(int *w, int *h) const
 444 {
 445   wxWindow::GetSize(w, h);
 446   // For some reason, the returned height is several pixels bigger than that
 447   // displayed!
 448   // Taking this fudge factor out now, it seems fine without it.
 449 //  *h -= 2;
 450 }
 451
 452 // The button size is bigger than the bitmap size
 453 wxSize wxToolBar95::GetToolSize() const
 454 {
 455   return wxSize(m_defaultWidth + 8, m_defaultHeight + 7);
 456 }
 457
 458 void wxToolBar95::EnableTool(int toolIndex, bool enable)
 459 {
 460   wxNode *node = m_tools.Find((long)toolIndex);
 461   if (node)
 462   {
 463     wxToolBarTool *tool = (wxToolBarTool *)node->Data();
 464     tool->m_enabled = enable;
 465     ::SendMessage((HWND) GetHWND(), TB_ENABLEBUTTON, (WPARAM)toolIndex, (LPARAM)MAKELONG(enable, 0));
 466   }
 467 }
 468
 469 void wxToolBar95::ToggleTool(int toolIndex, bool toggle)
 470 {
 471   wxNode *node = m_tools.Find((long)toolIndex);
 472   if (node)
 473   {
 474     wxToolBarTool *tool = (wxToolBarTool *)node->Data();
 475     if (tool->m_isToggle)
 476     {
 477       tool->m_toggleState = toggle;
 478       ::SendMessage((HWND) GetHWND(), TB_CHECKBUTTON, (WPARAM)toolIndex, (LPARAM)MAKELONG(toggle, 0));
 479     }
 480   }
 481 }
 482
 483 bool wxToolBar95::GetToolState(int toolIndex) const
 484 {
 485     return (::SendMessage((HWND) GetHWND(), TB_ISBUTTONCHECKED, (WPARAM)toolIndex, (LPARAM)0) != 0);
 486 }
 487
 488 void wxToolBar95::ClearTools()
 489 {
 490   // TODO: Don't know how to reset the toolbar bitmap, as yet.
 491   // But adding tools and calling CreateTools should probably
 492   // recreate a buttonbar OK.
 493   wxToolBarBase::ClearTools();
 494 }
 495
 496 // If pushedBitmap is NULL, a reversed version of bitmap is
 497 // created and used as the pushed/toggled image.
 498 // If toggle is TRUE, the button toggles between the two states.
 499 wxToolBarTool *wxToolBar95::AddTool(int index, const wxBitmap& bitmap, const wxBitmap& pushedBitmap,
 500              bool toggle, long xPos, long yPos, wxObject *clientData, const wxString& helpString1, const wxString& helpString2)
 501 {
 502   wxToolBarTool *tool = new wxToolBarTool(index, bitmap, wxNullBitmap, toggle, xPos, yPos, helpString1, helpString2);
 503   tool->m_clientData = clientData;
 504
 505   if (xPos > -1)
 506     tool->m_x = xPos;
 507   else
 508     tool->m_x = m_xMargin;
 509
 510   if (yPos > -1)
 511     tool->m_y = yPos;
 512   else
 513     tool->m_y = m_yMargin;
 514
 515   tool->SetSize(GetToolSize().x, GetToolSize().y);
 516
 517   m_tools.Append((long)index, tool);
 518   return tool;
 519 }
 520
 521 // Responds to colour changes, and passes event on to children.
 522 void wxToolBar95::OnSysColourChanged(wxSysColourChangedEvent& event)
 523 {
 524     m_backgroundColour = wxColour(GetRValue(GetSysColor(COLOR_BTNFACE)),
 525           GetGValue(GetSysColor(COLOR_BTNFACE)), GetBValue(GetSysColor(COLOR_BTNFACE)));
 526
 527     // Remap the buttons
 528     CreateTools();
 529
 530     Default();
 531
 532     Refresh();
 533
 534     // Propagate the event to the non-top-level children
 535     wxWindow::OnSysColourChanged(event);
 536 }
 537
 538 void wxToolBar95::OnMouseEvent(wxMouseEvent& event)
 539 {
 540     if (event.RightDown())
 541     {
 542         // For now, we don't have an id. Later we could
 543         // try finding the tool.
 544         OnRightClick((int)-1, event.GetX(), event.GetY());
 545     }
 546     else
 547     {
 548         Default();
 549     }
 550 }
 551
 552 // These are the default colors used to map the bitmap colors
 553 // to the current system colors
 554
 555 #define BGR_BUTTONTEXT      (RGB(000,000,000))  // black
 556 #define BGR_BUTTONSHADOW    (RGB(128,128,128))  // dark grey
 557 #define BGR_BUTTONFACE      (RGB(192,192,192))  // bright grey
 558 #define BGR_BUTTONHILIGHT   (RGB(255,255,255))  // white
 559 #define BGR_BACKGROUNDSEL   (RGB(255,000,000))  // blue
 560 #define BGR_BACKGROUND      (RGB(255,000,255))  // magenta
 561
 562 void wxMapBitmap(HBITMAP hBitmap, int width, int height)
 563 {
 564   COLORMAP ColorMap[] = {
 565     {BGR_BUTTONTEXT,    COLOR_BTNTEXT},     // black
 566     {BGR_BUTTONSHADOW,  COLOR_BTNSHADOW},   // dark grey
 567     {BGR_BUTTONFACE,    COLOR_BTNFACE},     // bright grey
 568     {BGR_BUTTONHILIGHT, COLOR_BTNHIGHLIGHT},// white
 569     {BGR_BACKGROUNDSEL, COLOR_HIGHLIGHT},   // blue
 570     {BGR_BACKGROUND,    COLOR_WINDOW}       // magenta
 571   };
 572
 573   int NUM_MAPS = (sizeof(ColorMap)/sizeof(COLORMAP));
 574   int n;
 575   for ( n = 0; n < NUM_MAPS; n++)
 576   {
 577     ColorMap[n].to = ::GetSysColor(ColorMap[n].to);
 578   }
 579
 580   HBITMAP hbmOld;
 581   HDC hdcMem = CreateCompatibleDC(NULL);
 582
 583   if (hdcMem)
 584   {
 585     hbmOld = (HBITMAP) SelectObject(hdcMem, hBitmap);
 586
 587     int i, j, k;
 588     for ( i = 0; i < width; i++)
 589     {
 590         for ( j = 0; j < height; j++)
 591         {
 592             COLORREF pixel = ::GetPixel(hdcMem, i, j);
 593 /*
 594             BYTE red = GetRValue(pixel);
 595             BYTE green = GetGValue(pixel);
 596             BYTE blue = GetBValue(pixel);
 597 */
 598
 599             for ( k = 0; k < NUM_MAPS; k ++)
 600             {
 601                 if ( ColorMap[k].from == pixel )
 602                 {
 603                     /* COLORREF actualPixel = */ ::SetPixel(hdcMem, i, j, ColorMap[k].to);
 604                     break;
 605                 }
 606             }
 607         }
 608     }
 609
 610
 611     SelectObject(hdcMem, hbmOld);
 612     DeleteObject(hdcMem);
 613   }
 614
 615 }
 616
 617 // Some experiments...
 618 #if 0
 619   // What we want to do is create another bitmap which has a depth of 4,
 620   // and set the bits. So probably we want to convert this HBITMAP into a
 621   // DIB, then call SetDIBits.
 622   // AAAGH. The stupid thing is that if newBitmap has a depth of 4 (less than that of
 623   // the screen), then SetDIBits fails.
 624   HBITMAP newBitmap = ::CreateBitmap(totalBitmapWidth, totalBitmapHeight, 1, 4, NULL);
 625   HANDLE newDIB = ::BitmapToDIB((HBITMAP) m_hBitmap, NULL);
 626   LPBITMAPINFOHEADER lpbmi = (LPBITMAPINFOHEADER) GlobalLock(newDIB);
 627
 628   dc = ::GetDC(NULL);
 629 //  LPBITMAPINFOHEADER lpbmi = (LPBITMAPINFOHEADER) newDIB;
 630
 631   int result = ::SetDIBits(dc, newBitmap, 0, lpbmi->biHeight, FindDIBBits((LPSTR)lpbmi), (LPBITMAPINFO)lpbmi,
 632     DIB_PAL_COLORS);
 633   DWORD err = GetLastError();
 634
 635   ::ReleaseDC(NULL, dc);
 636
 637   // Delete the DIB
 638   GlobalUnlock (newDIB);
 639   GlobalFree (newDIB);
 640
 641 //  WXHBITMAP hBitmap2 = wxCreateMappedBitmap((WXHINSTANCE) wxGetInstance(), (WXHBITMAP) m_hBitmap);
 642   // Substitute our new bitmap for the old one
 643   ::DeleteObject((HBITMAP) m_hBitmap);
 644   m_hBitmap = (WXHBITMAP) newBitmap;
 645 #endif
 646
 647
 648 #endif