src/msw/tbarmsw.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        tbarmsw.cpp
   3 // Purpose:     wxToolBarMSW
   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 "tbarmsw.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.h"
  25 #endif
  26
  27 #if wxUSE_BUTTONBAR && wxUSE_TOOLBAR
  28
  29 #ifndef __GNUWIN32__
  30 #include "malloc.h"
  31 #endif
  32
  33 #ifndef __MWERKS__
  34 #include <memory.h>
  35 #endif
  36 #include <stdlib.h>
  37
  38 #include "wx/tbarmsw.h"
  39 #include "wx/app.h"
  40 #include "wx/msw/private.h"
  41 #include "wx/msw/dib.h"
  42
  43 #define DEFAULTBITMAPX   16
  44 #define DEFAULTBITMAPY   15
  45 #define DEFAULTBUTTONX   24
  46 #define DEFAULTBUTTONY   22
  47 #define DEFAULTBARHEIGHT 27
  48
  49 /////// Non-Windows 95 implementation
  50
  51 #if !wxUSE_IMAGE_LOADING_IN_MSW
  52 #error If wxUSE_IMAGE_LOADING_IN_MSW is set to 0, then wxUSE_BUTTONBAR must be set to 0 too.
  53 #endif
  54
  55 #if !USE_SHARED_LIBRARY
  56 IMPLEMENT_DYNAMIC_CLASS(wxToolBarMSW, wxToolBarBase)
  57
  58 BEGIN_EVENT_TABLE(wxToolBarMSW, wxToolBarBase)
  59         EVT_SIZE(wxToolBarMSW::OnSize)
  60         EVT_PAINT(wxToolBarMSW::OnPaint)
  61         EVT_MOUSE_EVENTS(wxToolBarMSW::OnMouseEvent)
  62 END_EVENT_TABLE()
  63 #endif
  64
  65 wxToolBarMSW::wxToolBarMSW(void)
  66 {
  67   m_hbrDither = 0;
  68   m_rgbFace = 0;
  69   m_rgbShadow = 0;
  70   m_rgbHilight = 0;
  71   m_rgbFrame = 0;
  72   m_hdcMono = 0;
  73   m_hbmMono = 0;
  74   m_hbmDefault = 0;
  75   m_defaultWidth = DEFAULTBITMAPX;
  76   m_defaultHeight = DEFAULTBITMAPY;
  77 }
  78
  79 bool wxToolBarMSW::Create(wxWindow *parent, wxWindowID id, const wxPoint& pos, const wxSize& size,
  80             long style, const wxString& name)
  81 {
  82         if ( ! wxWindow::Create(parent, id, pos, size, style, name) )
  83                 return FALSE;
  84
  85   if ( style & wxTB_HORIZONTAL )
  86     { m_lastX = 3; m_lastY = 7; }
  87   else
  88     { m_lastX = 7; m_lastY = 3; }
  89   m_maxWidth = m_maxHeight = 0;
  90   m_pressedTool = m_currentTool = -1;
  91   m_xMargin = 0;
  92   m_yMargin = 0;
  93   m_toolPacking = 1;
  94   m_toolSeparation = 5;
  95
  96   // Set it to grey
  97   SetBackgroundColour(wxColour(192, 192, 192));
  98
  99   m_hbrDither = 0;
 100   m_rgbFace = 0;
 101   m_rgbShadow = 0;
 102   m_rgbHilight = 0;
 103   m_rgbFrame = 0;
 104   m_hdcMono = 0;
 105   m_hbmMono = 0;
 106   m_hbmDefault = 0;
 107   m_defaultWidth = DEFAULTBITMAPX;
 108   m_defaultHeight = DEFAULTBITMAPY;
 109
 110   InitGlobalObjects();
 111
 112   return TRUE;
 113 }
 114
 115 wxToolBarMSW::~wxToolBarMSW(void)
 116 {
 117   FreeGlobalObjects();
 118 }
 119
 120 void wxToolBarMSW::SetToolBitmapSize(const wxSize& size)
 121 {
 122   m_defaultWidth = size.x; m_defaultHeight = size.y;
 123   FreeGlobalObjects();
 124   InitGlobalObjects();
 125 }
 126
 127 // The button size is bigger than the bitmap size
 128 wxSize wxToolBarMSW::GetToolSize(void) const
 129 {
 130   return wxSize(m_defaultWidth + 8, m_defaultHeight + 7);
 131 }
 132
 133 void wxToolBarMSW::OnPaint(wxPaintEvent& event)
 134 {
 135   wxPaintDC dc(this);
 136
 137   static int wxOnPaintCount = 0;
 138
 139   // Prevent reentry of OnPaint which would cause
 140   // wxMemoryDC errors.
 141   if (wxOnPaintCount > 0)
 142     return;
 143   wxOnPaintCount ++;
 144
 145   wxNode *node = m_tools.First();
 146   while (node)
 147   {
 148     wxToolBarTool *tool = (wxToolBarTool *)node->Data();
 149     if (tool->m_toolStyle != wxTOOL_STYLE_SEPARATOR)
 150     {
 151       int state = wxTBSTATE_ENABLED;
 152       if (!tool->m_enabled)
 153         state = 0;
 154       if (tool->m_isToggle && tool->m_toggleState)
 155         state |= wxTBSTATE_CHECKED;
 156       DrawTool(dc, tool, state);
 157     }
 158     node = node->Next();
 159   }
 160   wxOnPaintCount --;
 161 }
 162
 163 void wxToolBarMSW::OnSize(wxSizeEvent& event)
 164 {
 165   wxToolBarBase::OnSize(event);
 166 }
 167
 168 // If a Button is disabled, then NO function (besides leaving
 169 // or entering) should be carried out. Therefore the additions
 170 // of 'enabled' testing (Stefan Hammes).
 171 void wxToolBarMSW::OnMouseEvent(wxMouseEvent& event)
 172 {
 173   static wxToolBarTool *eventCurrentTool = NULL;
 174   wxClientDC dc(this);
 175
 176   if (event.Leaving())
 177   {
 178     m_currentTool = -1;
 179     if (eventCurrentTool && eventCurrentTool->m_enabled)
 180     {
 181       ::ReleaseCapture();
 182       int state = wxTBSTATE_ENABLED;
 183       if (eventCurrentTool->m_toggleState)
 184         state |= wxTBSTATE_CHECKED;
 185       DrawTool(dc, eventCurrentTool, state);
 186       eventCurrentTool = NULL;
 187     }
 188     OnMouseEnter(-1);
 189     return;
 190   }
 191
 192   long x, y;
 193   event.Position(&x, &y);
 194   wxToolBarTool *tool = FindToolForPosition(x, y);
 195
 196   if (!tool)
 197   {
 198     if (eventCurrentTool && eventCurrentTool->m_enabled)
 199     {
 200       ::ReleaseCapture();
 201
 202       int state = wxTBSTATE_ENABLED;
 203       if (eventCurrentTool->m_toggleState)
 204         state |= wxTBSTATE_CHECKED;
 205       DrawTool(dc, eventCurrentTool, state);
 206       eventCurrentTool = NULL;
 207     }
 208     if (m_currentTool > -1)
 209     {
 210       m_currentTool = -1;
 211       OnMouseEnter(-1);
 212     }
 213     return;
 214   }
 215
 216   if (!event.Dragging() && !event.IsButton())
 217   {
 218     if (tool->m_index != m_currentTool)
 219     {
 220       OnMouseEnter(tool->m_index);
 221       m_currentTool = tool->m_index;
 222       return;
 223     }
 224   }
 225   if (event.Dragging() && tool->m_enabled)
 226   {
 227     if (eventCurrentTool)
 228     {
 229       // Might have dragged outside tool
 230       if (eventCurrentTool != tool)
 231       {
 232         int state = wxTBSTATE_ENABLED;
 233         if (tool->m_toggleState)
 234           state |= wxTBSTATE_CHECKED;
 235         DrawTool(dc, tool, state);
 236         eventCurrentTool = NULL;
 237         return;
 238       }
 239     }
 240     else
 241     {
 242       if (tool && event.LeftIsDown() && tool->m_enabled)
 243       {
 244         eventCurrentTool = tool;
 245         ::SetCapture((HWND) GetHWND());
 246         int state = wxTBSTATE_ENABLED|wxTBSTATE_PRESSED;
 247         if (tool->m_toggleState)
 248           state |= wxTBSTATE_CHECKED;
 249         DrawTool(dc, tool, state);
 250       }
 251     }
 252   }
 253   if (event.LeftDown() && tool->m_enabled)
 254   {
 255     eventCurrentTool = tool;
 256     ::SetCapture((HWND) GetHWND());
 257     int state = wxTBSTATE_ENABLED|wxTBSTATE_PRESSED;
 258     if (tool->m_toggleState)
 259       state |= wxTBSTATE_CHECKED;
 260     DrawTool(dc, tool, state);
 261   }
 262   else if (event.LeftUp() && tool->m_enabled)
 263   {
 264     if (eventCurrentTool)
 265       ::ReleaseCapture();
 266     if (eventCurrentTool == tool)
 267     {
 268       if (tool->m_isToggle)
 269       {
 270         tool->m_toggleState = !tool->m_toggleState;
 271         if (!OnLeftClick(tool->m_index, tool->m_toggleState))
 272         {
 273           tool->m_toggleState = !tool->m_toggleState;
 274         }
 275         int state = wxTBSTATE_ENABLED;
 276         if (tool->m_toggleState)
 277           state |= wxTBSTATE_CHECKED;
 278         DrawTool(dc, tool, state);
 279       }
 280       else
 281       {
 282         int state = wxTBSTATE_ENABLED;
 283         if (tool->m_toggleState)
 284           state |= wxTBSTATE_CHECKED;
 285         DrawTool(dc, tool, state);
 286         OnLeftClick(tool->m_index, tool->m_toggleState);
 287       }
 288     }
 289     eventCurrentTool = NULL;
 290   }
 291   else if (event.RightDown() && tool->m_enabled)
 292   {
 293     OnRightClick(tool->m_index, x, y);
 294   }
 295 }
 296
 297 // This function enables/disables a toolbar tool and redraws it.
 298 // If that would not be done, the enabling/disabling wouldn't be
 299 // visible on the screen.
 300 void wxToolBarMSW::EnableTool(int toolIndex, bool enable)
 301 {
 302   wxNode *node = m_tools.Find((long)toolIndex);
 303   if (node)
 304   {
 305         wxClientDC dc(this);
 306
 307     // at first do the enabling/disabling in the base class
 308     wxToolBarBase::EnableTool(toolIndex,enable);
 309     // then calculate the state of the tool and draw it
 310     wxToolBarTool *tool = (wxToolBarTool *)node->Data();
 311     int state = 0;
 312     if(tool->m_toggleState) state |= wxTBSTATE_CHECKED;
 313     if(tool->m_enabled) state |= wxTBSTATE_ENABLED;
 314     // how can i access the PRESSED state???
 315     DrawTool(dc, tool,state);
 316   }
 317 }
 318
 319 void wxToolBarMSW::DrawTool(wxDC& dc, wxToolBarTool *tool, int state)
 320 {
 321   DrawButton(dc.GetHDC(), (int)tool->m_x, (int)tool->m_y, (int)tool->GetWidth(), (int)tool->GetHeight(), tool, state);
 322 }
 323
 324 void wxToolBarMSW::DrawTool(wxDC& dc, wxMemoryDC& , wxToolBarTool *tool)
 325 {
 326   int state = wxTBSTATE_ENABLED;
 327   if (!tool->m_enabled)
 328     state = 0;
 329   if (tool->m_toggleState)
 330     state |= wxTBSTATE_CHECKED;
 331   DrawTool(dc, tool, state);
 332 }
 333
 334 // If pushedBitmap is NULL, a reversed version of bitmap is
 335 // created and used as the pushed/toggled image.
 336 // If toggle is TRUE, the button toggles between the two states.
 337 wxToolBarTool *wxToolBarMSW::AddTool(int index, const wxBitmap& bitmap, const wxBitmap& pushedBitmap,
 338              bool toggle, long xPos, long yPos, wxObject *clientData, const wxString& helpString1, const wxString& helpString2)
 339 {
 340   // Using bitmap2 can cause problems (don't know why!)
 341
 342   // TODO: use the mapping code from wxToolBar95 to get it right in this class
 343 #if !defined(__WIN32__) && !defined(__WIN386__)
 344   wxBitmap bitmap2;
 345   if (toggle)
 346   {
 347     bitmap2.SetHBITMAP( (WXHBITMAP) CreateMappedBitmap(wxGetInstance(), (HBITMAP) ((wxBitmap& )bitmap).GetHBITMAP()));
 348   }
 349
 350   wxToolBarTool *tool = new wxToolBarTool(index, bitmap, bitmap2, toggle, xPos, yPos, helpString1, helpString2);
 351 #else
 352   wxToolBarTool *tool = new wxToolBarTool(index, bitmap, wxNullBitmap, toggle, xPos, yPos, helpString1, helpString2);
 353 #endif
 354
 355   tool->m_clientData = clientData;
 356
 357   if (xPos > -1)
 358     tool->m_x = xPos;
 359   else
 360     tool->m_x = m_xMargin;
 361
 362   if (yPos > -1)
 363     tool->m_y = yPos;
 364   else
 365     tool->m_y = m_yMargin;
 366
 367   tool->m_deleteSecondBitmap = TRUE;
 368   tool->SetSize(GetToolSize().x, GetToolSize().y);
 369
 370   // Calculate reasonable max size in case Layout() not called
 371   if ((tool->m_x + bitmap.GetWidth() + m_xMargin) > m_maxWidth)
 372     m_maxWidth = (tool->m_x + tool->GetWidth() + m_xMargin);
 373
 374   if ((tool->m_y + bitmap.GetHeight() + m_yMargin) > m_maxHeight)
 375     m_maxHeight = (tool->m_y + tool->GetHeight() + m_yMargin);
 376
 377   m_tools.Append((long)index, tool);
 378   return tool;
 379 }
 380
 381 void wxToolBarMSW::Layout(void)
 382 {
 383   m_currentRowsOrColumns = 0;
 384   m_lastX = m_xMargin;
 385   m_lastY = m_yMargin;
 386   int maxToolWidth = 0;
 387   int maxToolHeight = 0;
 388   m_maxWidth = 0;
 389   m_maxHeight = 0;
 390
 391   // Find the maximum tool width and height
 392   wxNode *node = m_tools.First();
 393   while (node)
 394   {
 395     wxToolBarTool *tool = (wxToolBarTool *)node->Data();
 396     if (tool->GetWidth() > maxToolWidth)
 397       maxToolWidth = (int)tool->GetWidth();
 398     if (tool->GetHeight() > maxToolHeight)
 399       maxToolHeight = (int)tool->GetHeight();
 400     node = node->Next();
 401   }
 402
 403   int separatorSize = m_toolSeparation;
 404
 405   node = m_tools.First();
 406   while (node)
 407   {
 408     wxToolBarTool *tool = (wxToolBarTool *)node->Data();
 409     if (tool->m_toolStyle == wxTOOL_STYLE_SEPARATOR)
 410     {
 411       if ( GetWindowStyleFlag() & wxTB_HORIZONTAL )
 412       {
 413         if (m_currentRowsOrColumns >= m_maxCols)
 414           m_lastY += separatorSize;
 415         else
 416           m_lastX += separatorSize;
 417       }
 418       else
 419       {
 420         if (m_currentRowsOrColumns >= m_maxRows)
 421           m_lastX += separatorSize;
 422         else
 423           m_lastY += separatorSize;
 424       }
 425     }
 426     else if (tool->m_toolStyle == wxTOOL_STYLE_BUTTON)
 427     {
 428       if ( GetWindowStyleFlag() & wxTB_HORIZONTAL )
 429       {
 430         if (m_currentRowsOrColumns >= m_maxCols)
 431         {
 432           m_currentRowsOrColumns = 0;
 433           m_lastX = m_xMargin;
 434           m_lastY += maxToolHeight + m_toolPacking;
 435         }
 436         tool->m_x = (long) (m_lastX + (maxToolWidth - tool->GetWidth())/2.0);
 437         tool->m_y = (long) (m_lastY + (maxToolHeight - tool->GetHeight())/2.0);
 438
 439         m_lastX += maxToolWidth + m_toolPacking;
 440       }
 441       else
 442       {
 443         if (m_currentRowsOrColumns >= m_maxRows)
 444         {
 445           m_currentRowsOrColumns = 0;
 446           m_lastX += (maxToolWidth + m_toolPacking);
 447           m_lastY = m_yMargin;
 448         }
 449         tool->m_x = (long) (m_lastX + (maxToolWidth - tool->GetWidth())/2.0);
 450         tool->m_y = (long) (m_lastY + (maxToolHeight - tool->GetHeight())/2.0);
 451
 452         m_lastY += maxToolHeight + m_toolPacking;
 453       }
 454       m_currentRowsOrColumns ++;
 455     }
 456
 457     if (m_lastX > m_maxWidth)
 458       m_maxWidth = m_lastX;
 459     if (m_lastY > m_maxHeight)
 460       m_maxHeight = m_lastY;
 461
 462     node = node->Next();
 463   }
 464   if ( GetWindowStyleFlag() & wxTB_HORIZONTAL )
 465     m_maxWidth += maxToolWidth;
 466   else
 467     m_maxHeight += maxToolHeight;
 468
 469   m_maxWidth += m_xMargin;
 470   m_maxHeight += m_yMargin;
 471 }
 472
 473
 474 bool wxToolBarMSW::InitGlobalObjects(void)
 475 {
 476   GetSysColors();
 477   if (!CreateDitherBrush())
 478     return FALSE;
 479
 480   m_hdcMono = (WXHDC) CreateCompatibleDC(NULL);
 481   if (!m_hdcMono)
 482       return FALSE;
 483
 484   m_hbmMono = (WXHBITMAP) CreateBitmap((int)GetToolSize().x, (int)GetToolSize().y, 1, 1, NULL);
 485   if (!m_hbmMono)
 486       return FALSE;
 487
 488   m_hbmDefault = (WXHBITMAP) SelectObject((HDC) m_hdcMono, (HBITMAP) m_hbmMono);
 489   return TRUE;
 490 }
 491
 492 void wxToolBarMSW::FreeGlobalObjects(void)
 493 {
 494     FreeDitherBrush();
 495
 496     if (m_hdcMono) {
 497         if (m_hbmDefault)
 498         {
 499             SelectObject((HDC) m_hdcMono, (HBITMAP) m_hbmDefault);
 500             m_hbmDefault = 0;
 501         }
 502         DeleteDC((HDC) m_hdcMono);              // toast the DCs
 503     }
 504     m_hdcMono = 0;
 505
 506     if (m_hbmMono)
 507                 DeleteObject((HBITMAP) m_hbmMono);
 508     m_hbmMono = 0;
 509 }
 510
 511
 512 void wxToolBarMSW::PatB(WXHDC hdc,int x,int y,int dx,int dy, long rgb)
 513 {
 514     RECT    rc;
 515
 516     rc.left   = x;
 517     rc.top    = y;
 518     rc.right  = x + dx;
 519     rc.bottom = y + dy;
 520
 521     SetBkColor((HDC) hdc,rgb);
 522     ExtTextOut((HDC) hdc,0,0,ETO_OPAQUE,&rc,NULL,0,NULL);
 523 }
 524
 525
 526 // create a mono bitmap mask:
 527 //   1's where color == COLOR_BTNFACE || COLOR_HILIGHT
 528 //   0's everywhere else
 529
 530 void wxToolBarMSW::CreateMask(WXHDC hdc, int xoffset, int yoffset, int dx, int dy)
 531 {
 532     HDC globalDC = ::GetDC(NULL);
 533     HDC hdcGlyphs = CreateCompatibleDC((HDC) globalDC);
 534     ReleaseDC(NULL, (HDC) globalDC);
 535
 536     // krj - create a new bitmap and copy the image from hdc.
 537     //HBITMAP bitmapOld = SelectObject(hdcGlyphs, hBitmap);
 538     HBITMAP hBitmap = CreateCompatibleBitmap((HDC) hdc, dx, dy);
 539     HBITMAP bitmapOld = (HBITMAP) SelectObject(hdcGlyphs, hBitmap);
 540     BitBlt(hdcGlyphs, 0,0, dx, dy, (HDC) hdc, 0, 0, SRCCOPY);
 541
 542     // initalize whole area with 1's
 543     PatBlt((HDC) m_hdcMono, 0, 0, dx, dy, WHITENESS);
 544
 545     // create mask based on color bitmap
 546     // convert this to 1's
 547     SetBkColor(hdcGlyphs, m_rgbFace);
 548     BitBlt((HDC) m_hdcMono, xoffset, yoffset, (int)GetToolBitmapSize().x, (int)GetToolBitmapSize().y,
 549         hdcGlyphs, 0, 0, SRCCOPY);
 550     // convert this to 1's
 551     SetBkColor(hdcGlyphs, m_rgbHilight);
 552     // OR in the new 1's
 553     BitBlt((HDC) m_hdcMono, xoffset, yoffset, (int)GetToolBitmapSize().x, (int)GetToolBitmapSize().y,
 554         hdcGlyphs, 0, 0, SRCPAINT);
 555
 556     SelectObject(hdcGlyphs, bitmapOld);
 557     DeleteObject(hBitmap);
 558     DeleteDC(hdcGlyphs);
 559 }
 560
 561 void wxToolBarMSW::DrawBlankButton(WXHDC hdc, int x, int y, int dx, int dy, int state)
 562 {
 563     // face color
 564     PatB(hdc, x, y, dx, dy, m_rgbFace);
 565
 566     if (state & wxTBSTATE_PRESSED) {
 567         PatB(hdc, x + 1, y, dx - 2, 1, m_rgbFrame);
 568         PatB(hdc, x + 1, y + dy - 1, dx - 2, 1, m_rgbFrame);
 569         PatB(hdc, x, y + 1, 1, dy - 2, m_rgbFrame);
 570         PatB(hdc, x + dx - 1, y +1, 1, dy - 2, m_rgbFrame);
 571         PatB(hdc, x + 1, y + 1, 1, dy-2, m_rgbShadow);
 572         PatB(hdc, x + 1, y + 1, dx-2, 1, m_rgbShadow);
 573     }
 574     else {
 575         PatB(hdc, x + 1, y, dx - 2, 1, m_rgbFrame);
 576         PatB(hdc, x + 1, y + dy - 1, dx - 2, 1, m_rgbFrame);
 577         PatB(hdc, x, y + 1, 1, dy - 2, m_rgbFrame);
 578         PatB(hdc, x + dx - 1, y + 1, 1, dy - 2, m_rgbFrame);
 579         dx -= 2;
 580         dy -= 2;
 581         PatB(hdc, x + 1, y + 1, 1, dy - 1, m_rgbHilight);
 582         PatB(hdc, x + 1, y + 1, dx - 1, 1, m_rgbHilight);
 583         PatB(hdc, x + dx, y + 1, 1, dy, m_rgbShadow);
 584         PatB(hdc, x + 1, y + dy, dx, 1,   m_rgbShadow);
 585         PatB(hdc, x + dx - 1, y + 2, 1, dy - 2, m_rgbShadow);
 586         PatB(hdc, x + 2, y + dy - 1, dx - 2, 1,   m_rgbShadow);
 587     }
 588 }
 589
 590 void wxToolBarMSW::DrawButton(WXHDC hdc, int x, int y, int dx, int dy, wxToolBarTool *tool, int state)
 591 {
 592     int yOffset;
 593     HBRUSH hbrOld, hbr;
 594     BOOL bMaskCreated = FALSE;
 595     int xButton = 0;            // assume button is down
 596     int dxFace, dyFace;
 597     int xCenterOffset;
 598
 599     dxFace = dx;
 600     dyFace = dy;
 601
 602 //    HBITMAP hBitmap = (HBITMAP) tool->m_bitmap1.GetHBITMAP();
 603     HDC globalDC = ::GetDC(NULL);
 604     HDC hdcGlyphs = CreateCompatibleDC(globalDC);
 605     ReleaseDC(NULL, globalDC);
 606
 607     // get the proper button look - up or down.
 608     if (!(state & (wxTBSTATE_PRESSED | wxTBSTATE_CHECKED))) {
 609         xButton = dx;   // use 'up' version of button
 610         dxFace -= 2;
 611         dyFace -= 2;    // extents to ignore button highlight
 612     }
 613
 614     DrawBlankButton(hdc, x, y, dx, dy, state);
 615
 616
 617     // move coordinates inside border and away from upper left highlight.
 618     // the extents change accordingly.
 619     x += 2;
 620     y += 2;
 621     dxFace -= 3;
 622     dyFace -= 3;
 623
 624     // Using bitmap2 can cause problems (don't know why!)
 625 #if !defined(__WIN32__) && !defined(__WIN386__)
 626     HBITMAP bitmapOld;
 627     if (tool->m_bitmap2.Ok())
 628       bitmapOld = (HBITMAP) SelectObject(hdcGlyphs, (HBITMAP) tool->m_bitmap2.GetHBITMAP());
 629     else
 630       bitmapOld = (HBITMAP) SelectObject(hdcGlyphs, (HBITMAP) tool->m_bitmap1.GetHBITMAP());
 631 #else
 632     HBITMAP bitmapOld = (HBITMAP) SelectObject(hdcGlyphs, (HBITMAP) tool->m_bitmap1.GetHBITMAP());
 633 #endif
 634
 635     // calculate offset of face from (x,y).  y is always from the top,
 636     // so the offset is easy.  x needs to be centered in face.
 637     yOffset = 1;
 638     xCenterOffset = (dxFace - (int)GetToolBitmapSize().x)/2;
 639     if (state & (wxTBSTATE_PRESSED | wxTBSTATE_CHECKED))
 640     {
 641         // pressed state moves down and to the right
 642         // (x moves automatically as face size grows)
 643         yOffset++;
 644     }
 645
 646     // now put on the face
 647     if (state & wxTBSTATE_ENABLED) {
 648         // regular version
 649         BitBlt((HDC) hdc, x+xCenterOffset, y + yOffset, (int)GetToolBitmapSize().x, (int)GetToolBitmapSize().y,
 650             hdcGlyphs, 0, 0, SRCCOPY);
 651     } else {
 652         // disabled version (or indeterminate)
 653         bMaskCreated = TRUE;
 654         CreateMask((WXHDC) hdcGlyphs, xCenterOffset, yOffset, dxFace, dyFace);
 655 //        CreateMask(hBitmap, xCenterOffset, yOffset, dxFace, dyFace);
 656
 657         SetTextColor((HDC) hdc, 0L);     // 0's in mono -> 0 (for ROP)
 658         SetBkColor((HDC) hdc, 0x00FFFFFF); // 1's in mono -> 1
 659
 660         // draw glyph's white understrike
 661         if (!(state & wxTBSTATE_INDETERMINATE)) {
 662             hbr = CreateSolidBrush(m_rgbHilight);
 663             if (hbr) {
 664                 hbrOld = (HBRUSH) SelectObject((HDC) hdc, hbr);
 665                 if (hbrOld) {
 666                     // draw hilight color where we have 0's in the mask
 667                     BitBlt((HDC) hdc, x + 1, y + 1, dxFace, dyFace, (HDC) m_hdcMono, 0, 0, 0x00B8074A);
 668                     SelectObject((HDC) hdc, hbrOld);
 669                 }
 670                 DeleteObject(hbr);
 671             }
 672         }
 673
 674         // gray out glyph
 675         hbr = CreateSolidBrush(m_rgbShadow);
 676         if (hbr) {
 677             hbrOld = (HBRUSH) SelectObject((HDC) hdc, hbr);
 678             if (hbrOld) {
 679                 // draw the shadow color where we have 0's in the mask
 680                 BitBlt((HDC) hdc, x, y, dxFace, dyFace, (HDC) m_hdcMono, 0, 0, 0x00B8074A);
 681                 SelectObject((HDC) hdc, hbrOld);
 682             }
 683             DeleteObject(hbr);
 684         }
 685
 686         if (state & wxTBSTATE_CHECKED) {
 687             BitBlt((HDC) m_hdcMono, 1, 1, dxFace - 1, dyFace - 1, (HDC) m_hdcMono, 0, 0, SRCAND);
 688         }
 689     }
 690
 691     if (state & (wxTBSTATE_CHECKED | wxTBSTATE_INDETERMINATE)) {
 692
 693         hbrOld = (HBRUSH) SelectObject((HDC) hdc, (HBRUSH) m_hbrDither);
 694         if (hbrOld) {
 695
 696             if (!bMaskCreated)
 697                 CreateMask((WXHDC) hdcGlyphs, xCenterOffset, yOffset, dxFace, dyFace);
 698 //                CreateMask(hBitmap, xCenterOffset, yOffset, dxFace, dyFace);
 699
 700             SetTextColor((HDC) hdc, 0L);                // 0 -> 0
 701             SetBkColor((HDC) hdc, 0x00FFFFFF);  // 1 -> 1
 702
 703             // only draw the dither brush where the mask is 1's
 704             BitBlt((HDC) hdc, x, y, dxFace, dyFace, (HDC) m_hdcMono, 0, 0, 0x00E20746);
 705
 706             SelectObject((HDC) hdc, hbrOld);
 707         }
 708     }
 709     SelectObject(hdcGlyphs, bitmapOld);
 710     DeleteDC(hdcGlyphs);
 711 }
 712
 713 void wxToolBarMSW::GetSysColors(void)
 714 {
 715         static COLORREF rgbSaveFace    = 0xffffffffL,
 716                         rgbSaveShadow  = 0xffffffffL,
 717                         rgbSaveHilight = 0xffffffffL,
 718                         rgbSaveFrame   = 0xffffffffL;
 719
 720     // For now, override these because the colour replacement isn't working,
 721     // and we get inconsistent colours. Assume all buttons are grey for the moment.
 722
 723 //      m_rgbFace    = GetSysColor(COLOR_BTNFACE);
 724         m_rgbFace = RGB(192,192,192);
 725 //      m_rgbShadow  = GetSysColor(COLOR_BTNSHADOW);
 726         m_rgbShadow = RGB(128,128,128);
 727 //      m_rgbHilight = GetSysColor(COLOR_BTNHIGHLIGHT);
 728         m_rgbHilight = RGB(255, 255, 255);
 729
 730         m_rgbFrame   = GetSysColor(COLOR_WINDOWFRAME);
 731
 732         if (rgbSaveFace!=m_rgbFace || rgbSaveShadow!=m_rgbShadow
 733                 || rgbSaveHilight!=m_rgbHilight || rgbSaveFrame!=m_rgbFrame)
 734         {
 735                 rgbSaveFace    = m_rgbFace;
 736                 rgbSaveShadow  = m_rgbShadow;
 737                 rgbSaveHilight = m_rgbHilight;
 738         rgbSaveFrame   = m_rgbFrame;
 739
 740                 // Update the brush for pushed-in buttons
 741                 CreateDitherBrush();
 742         }
 743 }
 744
 745 WXHBITMAP wxToolBarMSW::CreateDitherBitmap()
 746 {
 747     BITMAPINFO* pbmi;
 748     HBITMAP hbm;
 749     HDC hdc;
 750     int i;
 751     long patGray[8];
 752     DWORD rgb;
 753
 754     pbmi = (BITMAPINFO *)malloc(sizeof(BITMAPINFOHEADER) + 16*sizeof(RGBQUAD));
 755     memset(pbmi, 0, (sizeof(BITMAPINFOHEADER) + 16*sizeof(RGBQUAD)));
 756
 757     pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
 758     pbmi->bmiHeader.biWidth = 8;
 759     pbmi->bmiHeader.biHeight = 8;
 760     pbmi->bmiHeader.biPlanes = 1;
 761     pbmi->bmiHeader.biBitCount = 1;
 762     pbmi->bmiHeader.biCompression = BI_RGB;
 763
 764 //    rgb = GetSysColor(COLOR_BTNFACE);
 765     rgb = RGB(192,192,192);
 766
 767     pbmi->bmiColors[0].rgbBlue  = GetBValue(rgb);
 768     pbmi->bmiColors[0].rgbGreen = GetGValue(rgb);
 769     pbmi->bmiColors[0].rgbRed   = GetRValue(rgb);
 770     pbmi->bmiColors[0].rgbReserved = 0;
 771
 772 //    rgb = GetSysColor(COLOR_BTNHIGHLIGHT);
 773     rgb = RGB(255, 255, 255);
 774
 775     pbmi->bmiColors[1].rgbBlue  = GetBValue(rgb);
 776     pbmi->bmiColors[1].rgbGreen = GetGValue(rgb);
 777     pbmi->bmiColors[1].rgbRed   = GetRValue(rgb);
 778     pbmi->bmiColors[1].rgbReserved = 0;
 779
 780     /* initialize the brushes */
 781
 782     for (i = 0; i < 8; i++)
 783        if (i & 1)
 784            patGray[i] = 0xAAAA5555L;   //  0x11114444L; // lighter gray
 785        else
 786            patGray[i] = 0x5555AAAAL;   //  0x11114444L; // lighter gray
 787
 788     hdc = ::GetDC(NULL);
 789
 790     hbm = CreateDIBitmap(hdc, &pbmi->bmiHeader, CBM_INIT, patGray, pbmi, DIB_RGB_COLORS);
 791
 792     ReleaseDC(NULL, hdc);
 793     free(pbmi);
 794
 795     return (WXHBITMAP)hbm;
 796 }
 797
 798 bool wxToolBarMSW::CreateDitherBrush(void)
 799 {
 800         HBITMAP hbmGray;
 801         HBRUSH hbrSave;
 802         if (m_hbrDither)
 803           return TRUE;
 804         hbmGray = (HBITMAP) CreateDitherBitmap();
 805
 806         if (hbmGray)
 807         {
 808                 hbrSave = (HBRUSH) m_hbrDither;
 809                 m_hbrDither = (WXHBRUSH) CreatePatternBrush(hbmGray);
 810                 DeleteObject(hbmGray);
 811                 if (m_hbrDither)
 812                 {
 813                         if (hbrSave)
 814                         {
 815                                 DeleteObject(hbrSave);
 816                         }
 817                         return TRUE;
 818                 }
 819                 else
 820                 {
 821                         m_hbrDither = (WXHBRUSH) hbrSave;
 822                 }
 823         }
 824
 825         return FALSE;
 826 }
 827
 828 bool wxToolBarMSW::FreeDitherBrush(void)
 829 {
 830     if (m_hbrDither)
 831       DeleteObject((HBRUSH) m_hbrDither);
 832     m_hbrDither = 0;
 833     return TRUE;
 834 }
 835
 836 typedef struct tagCOLORMAP2
 837 {
 838     COLORREF bgrfrom;
 839     COLORREF bgrto;
 840     COLORREF sysColor;
 841 } COLORMAP2;
 842
 843 // these are the default colors used to map the dib colors
 844 // to the current system colors
 845
 846 #define BGR_BUTTONTEXT      (RGB(000,000,000))  // black
 847 #define BGR_BUTTONSHADOW    (RGB(128,128,128))  // dark grey
 848 #define BGR_BUTTONFACE      (RGB(192,192,192))  // bright grey
 849 #define BGR_BUTTONHILIGHT   (RGB(255,255,255))  // white
 850 #define BGR_BACKGROUNDSEL   (RGB(255,000,000))  // blue
 851 #define BGR_BACKGROUND      (RGB(255,000,255))  // magenta
 852 #define FlipColor(rgb)      (RGB(GetBValue(rgb), GetGValue(rgb), GetRValue(rgb)))
 853
 854 WXHBITMAP wxToolBarMSW::CreateMappedBitmap(WXHINSTANCE WXUNUSED(hInstance), void *info)
 855 {
 856   LPBITMAPINFOHEADER lpBitmapInfo = (LPBITMAPINFOHEADER)info;
 857   HDC                   hdc, hdcMem = NULL;
 858
 859   DWORD FAR             *p;
 860   LPSTR                 lpBits;
 861   HBITMAP               hbm = NULL, hbmOld;
 862   int numcolors, i;
 863   int wid, hgt;
 864   static COLORMAP2 ColorMap[] = {
 865     {BGR_BUTTONTEXT,    BGR_BUTTONTEXT,    COLOR_BTNTEXT},     // black
 866     {BGR_BUTTONSHADOW,  BGR_BUTTONSHADOW,  COLOR_BTNSHADOW},   // dark grey
 867     {BGR_BUTTONFACE,    BGR_BUTTONFACE,    COLOR_BTNFACE},     // bright grey
 868     {BGR_BUTTONHILIGHT, BGR_BUTTONHILIGHT, COLOR_BTNHIGHLIGHT},// white
 869     {BGR_BACKGROUNDSEL, BGR_BACKGROUNDSEL, COLOR_HIGHLIGHT},   // blue
 870     {BGR_BACKGROUND,    BGR_BACKGROUND,    COLOR_WINDOW}       // magenta
 871   };
 872
 873   #define NUM_MAPS (sizeof(ColorMap)/sizeof(COLORMAP2))
 874
 875   if (!lpBitmapInfo)
 876         return 0;
 877
 878   //
 879   // So what are the new colors anyway ?
 880   //
 881   for (i=0; i < (int) NUM_MAPS; i++) {
 882      ColorMap[i].bgrto = (long unsigned int) FlipColor(GetSysColor((int)ColorMap[i].sysColor));
 883   }
 884
 885   p = (DWORD FAR *)(((LPSTR)lpBitmapInfo) + lpBitmapInfo->biSize);
 886
 887   /* Replace button-face and button-shadow colors with the current values
 888    */
 889   numcolors = 16;
 890
 891   while (numcolors-- > 0) {
 892       for (i = 0; i < (int) NUM_MAPS; i++) {
 893           if (*p == ColorMap[i].bgrfrom) {
 894           *p = ColorMap[i].bgrto;
 895               break;
 896           }
 897       }
 898       p++;
 899   }
 900
 901   /* First skip over the header structure */
 902   lpBits = (LPSTR)(lpBitmapInfo + 1);
 903
 904   /* Skip the color table entries, if any */
 905   lpBits += (1 << (lpBitmapInfo->biBitCount)) * sizeof(RGBQUAD);
 906
 907   /* Create a color bitmap compatible with the display device */
 908   i = wid = (int)lpBitmapInfo->biWidth;
 909   hgt = (int)lpBitmapInfo->biHeight;
 910   hdc = ::GetDC(NULL);
 911
 912   hdcMem = CreateCompatibleDC(hdc);
 913   if (hdcMem) {
 914 //    hbm = CreateDiscardableBitmap(hdc, i, hgt);
 915     hbm = CreateCompatibleBitmap(hdc, i, hgt);
 916     if (hbm) {
 917         hbmOld = (HBITMAP) SelectObject(hdcMem, hbm);
 918
 919         // set the main image
 920         StretchDIBits(hdcMem, 0, 0, wid, hgt, 0, 0, wid, hgt, lpBits,
 921                    (LPBITMAPINFO)lpBitmapInfo, DIB_RGB_COLORS, SRCCOPY);
 922
 923         SelectObject(hdcMem, hbmOld);
 924     }
 925
 926     DeleteObject(hdcMem);
 927   }
 928
 929   ReleaseDC(NULL, hdc);
 930
 931   return (WXHBITMAP) hbm;
 932 }
 933
 934 WXHBITMAP wxToolBarMSW::CreateMappedBitmap(WXHINSTANCE hInstance, WXHBITMAP hBitmap)
 935 {
 936   HANDLE hDIB = BitmapToDIB((HBITMAP) hBitmap, 0);
 937   if (hDIB)
 938   {
 939 #ifdef __WINDOWS_386__
 940     LPBITMAPINFOHEADER lpbmInfoHdr = (LPBITMAPINFOHEADER)MK_FP32(GlobalLock(hDIB));
 941 #else
 942     LPBITMAPINFOHEADER lpbmInfoHdr = (LPBITMAPINFOHEADER)GlobalLock(hDIB);
 943 #endif
 944     HBITMAP newBitmap = (HBITMAP) CreateMappedBitmap((WXHINSTANCE) wxGetInstance(), lpbmInfoHdr);
 945     GlobalUnlock(hDIB);
 946     GlobalFree(hDIB);
 947     return (WXHBITMAP) newBitmap;
 948   }
 949   return 0;
 950 }
 951
 952 #endif