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