X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/4e15f6c57a5897f0e1e332100e4261fd84167ce0..19e30148e18cc99296b26503c155e5cef59045f4:/src/msw/tbar95.cpp?ds=inline diff --git a/src/msw/tbar95.cpp b/src/msw/tbar95.cpp index 64ca4f176c..7c6515ff12 100644 --- a/src/msw/tbar95.cpp +++ b/src/msw/tbar95.cpp @@ -1,6 +1,6 @@ ///////////////////////////////////////////////////////////////////////////// // Name: msw/tbar95.cpp -// Purpose: wxToolBar95 +// Purpose: wxToolBar // Author: Julian Smart // Modified by: // Created: 04/01/98 @@ -29,13 +29,19 @@ #endif #ifndef WX_PRECOMP + #include "wx/frame.h" #include "wx/log.h" #include "wx/intl.h" #include "wx/dynarray.h" #include "wx/settings.h" + #include "wx/bitmap.h" + #include "wx/dcmemory.h" + #include "wx/control.h" #endif -#if wxUSE_BUTTONBAR && wxUSE_TOOLBAR && defined(__WIN95__) +#if wxUSE_TOOLBAR && defined(__WIN95__) && wxUSE_TOOLBAR_NATIVE + +#include "wx/toolbar.h" #if !defined(__GNUWIN32__) && !defined(__SALFORDC__) #include "malloc.h" @@ -45,18 +51,40 @@ #ifndef __TWIN32__ -#ifdef __GNUWIN32_OLD__ - #include "wx/msw/gnuwin32/extra.h" -#else +#if defined(__WIN95__) && !((defined(__GNUWIN32_OLD__) || defined(__TWIN32__)) && !defined(__CYGWIN10__)) #include +#else + #include "wx/msw/gnuwin32/extra.h" #endif #endif // __TWIN32__ #include "wx/msw/dib.h" -#include "wx/tbar95.h" #include "wx/app.h" // for GetComCtl32Version +#if defined(__MWERKS__) && defined(__WXMSW__) +// including for max definition doesn't seem +// to work using CodeWarrior 6 Windows. So we define it +// here. (Otherwise we get a undefined identifier 'max' +// later on in this file.) (Added by dimitri@shortcut.nl) +# ifndef max +# define max(a,b) (((a) > (b)) ? (a) : (b)) +# endif + +#endif + +// ---------------------------------------------------------------------------- +// 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 // ---------------------------------------------------------------------------- @@ -67,14 +95,24 @@ #ifndef TBSTYLE_FLAT #define TBSTYLE_LIST 0x1000 #define TBSTYLE_FLAT 0x0800 +#endif + +#ifndef TBSTYLE_TRANSPARENT #define TBSTYLE_TRANSPARENT 0x8000 #endif - // use TBSTYLE_TRANSPARENT if you use TBSTYLE_FLAT + +#ifndef TBSTYLE_TOOLTIPS + #define TBSTYLE_TOOLTIPS 0x0100 +#endif // Messages #ifndef TB_GETSTYLE - #define TB_GETSTYLE (WM_USER + 57) #define TB_SETSTYLE (WM_USER + 56) + #define TB_GETSTYLE (WM_USER + 57) +#endif + +#ifndef TB_HITTEST + #define TB_HITTEST (WM_USER + 69) #endif // these values correspond to those used by comctl32.dll @@ -85,67 +123,149 @@ #define DEFAULTBARHEIGHT 27 // ---------------------------------------------------------------------------- -// function prototypes +// wxWin macros // ---------------------------------------------------------------------------- -static void wxMapBitmap(HBITMAP hBitmap, int width, int height); +IMPLEMENT_DYNAMIC_CLASS(wxToolBar, wxToolBarBase) + +BEGIN_EVENT_TABLE(wxToolBar, wxToolBarBase) + EVT_MOUSE_EVENTS(wxToolBar::OnMouseEvent) + EVT_SYS_COLOUR_CHANGED(wxToolBar::OnSysColourChanged) +END_EVENT_TABLE() // ---------------------------------------------------------------------------- -// wxWin macros +// private classes // ---------------------------------------------------------------------------- -#if !USE_SHARED_LIBRARY - IMPLEMENT_DYNAMIC_CLASS(wxToolBar95, wxToolBarBase) -#endif +class wxToolBarTool : public wxToolBarToolBase +{ +public: + wxToolBarTool(wxToolBar *tbar, + int id, + const wxString& label, + const wxBitmap& bmpNormal, + const wxBitmap& bmpDisabled, + wxItemKind kind, + wxObject *clientData, + const wxString& shortHelp, + const wxString& longHelp) + : wxToolBarToolBase(tbar, id, label, bmpNormal, bmpDisabled, kind, + clientData, shortHelp, longHelp) + { + m_nSepCount = 0; + } + + wxToolBarTool(wxToolBar *tbar, wxControl *control) + : wxToolBarToolBase(tbar, control) + { + m_nSepCount = 1; + } + + virtual void SetLabel(const wxString& label) + { + if ( label == m_label ) + return; + + wxToolBarToolBase::SetLabel(label); + + // we need to update the label shown in the toolbar because it has a + // pointer to the internal buffer of the old label + // + // TODO: use TB_SETBUTTONINFO + } + + // set/get the number of separators which we use to cover the space used by + // a control in the toolbar + void SetSeparatorsCount(size_t count) { m_nSepCount = count; } + size_t GetSeparatorsCount() const { return m_nSepCount; } + +private: + size_t m_nSepCount; +}; -BEGIN_EVENT_TABLE(wxToolBar95, wxToolBarBase) - EVT_MOUSE_EVENTS(wxToolBar95::OnMouseEvent) - EVT_SYS_COLOUR_CHANGED(wxToolBar95::OnSysColourChanged) -END_EVENT_TABLE() // ============================================================================ // implementation // ============================================================================ // ---------------------------------------------------------------------------- -// wxToolBar95 construction +// wxToolBarTool +// ---------------------------------------------------------------------------- + +wxToolBarToolBase *wxToolBar::CreateTool(int id, + const wxString& label, + const wxBitmap& bmpNormal, + const wxBitmap& bmpDisabled, + wxItemKind kind, + wxObject *clientData, + const wxString& shortHelp, + const wxString& longHelp) +{ + return new wxToolBarTool(this, id, label, bmpNormal, bmpDisabled, kind, + clientData, shortHelp, longHelp); +} + +wxToolBarToolBase *wxToolBar::CreateTool(wxControl *control) +{ + return new wxToolBarTool(this, control); +} + +// ---------------------------------------------------------------------------- +// wxToolBar construction // ---------------------------------------------------------------------------- -void wxToolBar95::Init() +void wxToolBar::Init() { - m_maxWidth = -1; - m_maxHeight = -1; m_hBitmap = 0; + + m_nButtons = 0; + m_defaultWidth = DEFAULTBITMAPX; m_defaultHeight = DEFAULTBITMAPY; + + m_pInTool = 0; } -bool wxToolBar95::Create(wxWindow *parent, - wxWindowID id, - const wxPoint& pos, - const wxSize& size, - long style, - const wxString& name) +bool wxToolBar::Create(wxWindow *parent, + wxWindowID id, + const wxPoint& pos, + const wxSize& size, + long style, + const wxString& name) { - wxASSERT_MSG( (style & wxTB_VERTICAL) == 0, - wxT("Sorry, wxToolBar95 under Windows 95 only " - "supports horizontal orientation.") ); + // toolbars never have border, giving one to them results in broken + // appearance + style &= ~wxBORDER_MASK; + style |= wxBORDER_NONE; // common initialisation - if ( !CreateControl(parent, id, pos, size, style, name) ) + if ( !CreateControl(parent, id, pos, size, style, wxDefaultValidator, name) ) return FALSE; // prepare flags - DWORD msflags = 0; // WS_VISIBLE | WS_CHILD always included - if (style & wxBORDER) - msflags |= WS_BORDER; - msflags |= TBSTYLE_TOOLTIPS; + DWORD msflags = TBSTYLE_TOOLTIPS; // WS_VISIBLE | WS_CHILD always included - if (style & wxTB_FLAT) + if ( style & wxCLIP_SIBLINGS ) + msflags |= WS_CLIPSIBLINGS; + + if ( style & wxTB_FLAT ) { - if (wxTheApp->GetComCtl32Version() > 400) - msflags |= TBSTYLE_FLAT; + // static as it doesn't change during the program lifetime + static int s_verComCtl = wxTheApp->GetComCtl32Version(); + + // comctl32.dll 4.00 doesn't support the flat toolbars and using this + // style with 6.00 (part of Windows XP) leads to the toolbar with + // incorrect background colour - and not using it still results in the + // correct (flat) toolbar, so don't use it there + if ( s_verComCtl > 400 && s_verComCtl < 600 ) + { + msflags |= TBSTYLE_FLAT | TBSTYLE_TRANSPARENT; + } } + if (style & wxTB_NODIVIDER) + msflags |= CCS_NODIVIDER; + if (style & wxTB_NOALIGN) + msflags |= CCS_NOPARENTALIGN; // MSW-specific initialisation if ( !wxControl::MSWCreateControl(TOOLBARCLASSNAME, msflags) ) @@ -155,10 +275,8 @@ bool wxToolBar95::Create(wxWindow *parent, ::SendMessage(GetHwnd(), TB_BUTTONSTRUCTSIZE, sizeof(TBBUTTON), 0); // set up the colors and fonts - wxRGBToColour(m_backgroundColour, GetSysColor(COLOR_BTNFACE)); - m_foregroundColour = *wxBLACK; - - SetFont(wxSystemSettings::GetSystemFont(wxSYS_DEFAULT_GUI_FONT)); + SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_MENUBAR)); + SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT)); // position it int x = pos.x; @@ -180,190 +298,309 @@ bool wxToolBar95::Create(wxWindow *parent, return TRUE; } -wxToolBar95::~wxToolBar95() +wxToolBar::~wxToolBar() { - UnsubclassWin(); + // 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 + wxFrame *frame = wxDynamicCast(GetParent(), wxFrame); + if ( frame && !frame->IsBeingDeleted() ) + { + frame->SendSizeEvent(); + } - if (m_hBitmap) + if ( m_hBitmap ) { ::DeleteObject((HBITMAP) m_hBitmap); } } -void wxToolBar95::ClearTools() +// ---------------------------------------------------------------------------- +// adding/removing tools +// ---------------------------------------------------------------------------- + +bool wxToolBar::DoInsertTool(size_t WXUNUSED(pos), + wxToolBarToolBase *tool) { - // TODO: Don't know how to reset the toolbar bitmap, as yet. - // But adding tools and calling CreateTools should probably - // recreate a buttonbar OK. - wxToolBarBase::ClearTools(); + // nothing special to do here - we really create the toolbar buttons in + // Realize() later + tool->Attach(this); + + return TRUE; } -bool wxToolBar95::AddControl(wxControl *control) +bool wxToolBar::DoDeleteTool(size_t pos, wxToolBarToolBase *tool) { - wxCHECK_MSG( control, FALSE, _T("toolbar: can't insert NULL control") ); + // 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(); - wxCHECK_MSG( control->GetParent() == this, FALSE, - _T("control must have toolbar as parent") ); + break; + } - wxToolBarTool *tool = new wxToolBarTool(control); + if ( tool2->IsControl() ) + { + pos += ((wxToolBarTool *)tool2)->GetSeparatorsCount() - 1; + } + } - m_tools.Append(control->GetId(), tool); + // now determine the number of buttons to delete and the area taken by them + size_t nButtonsToDelete = 1; - return TRUE; -} + // get the size of the button we're going to delete + RECT r; + if ( !::SendMessage(GetHwnd(), TB_GETITEMRECT, pos, (LPARAM)&r) ) + { + wxLogLastError(_T("TB_GETITEMRECT")); + } -wxToolBarTool *wxToolBar95::AddTool(int index, - const wxBitmap& bitmap, - const wxBitmap& pushedBitmap, - bool toggle, - long xPos, long yPos, - wxObject *clientData, - const wxString& helpString1, - const wxString& helpString2) -{ - wxToolBarTool *tool = new wxToolBarTool(index, bitmap, wxNullBitmap, - toggle, xPos, yPos, - helpString1, helpString2); - tool->m_clientData = clientData; + int width = r.right - r.left; - if (xPos > -1) - tool->m_x = xPos; - else - tool->m_x = m_xMargin; + if ( tool->IsControl() ) + { + nButtonsToDelete = ((wxToolBarTool *)tool)->GetSeparatorsCount(); - if (yPos > -1) - tool->m_y = yPos; - else - tool->m_y = m_yMargin; + width *= nButtonsToDelete; + } + + // do delete all buttons + m_nButtons -= nButtonsToDelete; + while ( nButtonsToDelete-- > 0 ) + { + if ( !::SendMessage(GetHwnd(), TB_DELETEBUTTON, pos, 0) ) + { + wxLogLastError(wxT("TB_DELETEBUTTON")); - tool->SetSize(GetToolSize().x, GetToolSize().y); + return FALSE; + } + } - m_tools.Append((long)index, tool); + tool->Detach(); - return tool; + // 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() ) + { + int x; + wxControl *control = tool2->GetControl(); + control->GetPosition(&x, NULL); + control->Move(x - width, -1); + } + } + + return TRUE; } -bool wxToolBar95::CreateTools() +bool wxToolBar::Realize() { - size_t nTools = m_tools.GetCount(); + size_t nTools = GetToolsCount(); if ( nTools == 0 ) - return FALSE; + { + // nothing to do + return TRUE; + } + + bool isVertical = (GetWindowStyle() & wxTB_VERTICAL) != 0; + + // First, add the bitmap: we use one bitmap for all toolbar buttons + // ---------------------------------------------------------------- - HBITMAP oldToolBarBitmap = (HBITMAP) m_hBitmap; + // if we already have a bitmap, we'll replace the existing one - otherwise + // we'll install a new one + HBITMAP oldToolBarBitmap = (HBITMAP)m_hBitmap; int totalBitmapWidth = (int)(m_defaultWidth * nTools); int totalBitmapHeight = (int)m_defaultHeight; - // Create a bitmap for all the tool bitmaps - HDC dc = ::GetDC(NULL); - m_hBitmap = (WXHBITMAP) ::CreateCompatibleBitmap(dc, - totalBitmapWidth, - totalBitmapHeight); - ::ReleaseDC(NULL, dc); + // 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); + if ( !hBitmap ) + { + wxLogLastError(_T("CreateCompatibleBitmap")); + + return FALSE; + } + + m_hBitmap = (WXHBITMAP)hBitmap; - // Now blit all the tools onto this bitmap HDC memoryDC = ::CreateCompatibleDC(NULL); - HBITMAP oldBitmap = (HBITMAP) ::SelectObject(memoryDC, (HBITMAP)m_hBitmap); + HBITMAP oldBitmap = (HBITMAP) ::SelectObject(memoryDC, hBitmap); HDC memoryDC2 = ::CreateCompatibleDC(NULL); +#endif // USE_BITMAP_MASKS/!USE_BITMAP_MASKS // the button position wxCoord x = 0; // the number of buttons (not separators) - int noButtons = 0; + int nButtons = 0; - wxNode *node = m_tools.First(); - while (node) + wxToolBarToolsList::Node *node = m_tools.GetFirst(); + while ( node ) { - wxToolBarTool *tool = (wxToolBarTool *)node->Data(); - if ( tool->m_toolStyle == wxTOOL_STYLE_BUTTON && tool->m_bitmap1.Ok() ) + wxToolBarToolBase *tool = node->GetData(); + if ( tool->IsButton() ) { - HBITMAP hbmp = GetHbitmapOf(tool->m_bitmap1); - if ( hbmp ) + const wxBitmap& bmp = tool->GetNormalBitmap(); + if ( bmp.Ok() ) { +#if USE_BITMAP_MASKS + // notice the last parameter: do use mask + dcAllButtons.DrawBitmap(bmp, 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) ) { - wxLogLastError("BitBlt"); + wxLogLastError(wxT("BitBlt")); } ::SelectObject(memoryDC2, oldBitmap2); - - x += m_defaultWidth; - noButtons++; +#endif // USE_BITMAP_MASKS/!USE_BITMAP_MASKS } + else + { + wxFAIL_MSG( _T("invalid tool button bitmap") ); + } + + // still inc width and number of buttons because otherwise the + // subsequent buttons will all be shifted which is rather confusing + // (and like this you'd see immediately which bitmap was bad) + x += m_defaultWidth; + nButtons++; } - node = node->Next(); + + 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); +#endif // USE_BITMAP_MASKS/!USE_BITMAP_MASKS // Map to system colours - wxMapBitmap((HBITMAP) m_hBitmap, totalBitmapWidth, totalBitmapHeight); + hBitmap = (HBITMAP)MapBitmap((WXHBITMAP) hBitmap, + totalBitmapWidth, totalBitmapHeight); + + int bitmapId = 0; + + bool addBitmap = TRUE; if ( oldToolBarBitmap ) { - TBREPLACEBITMAP replaceBitmap; - replaceBitmap.hInstOld = NULL; - replaceBitmap.hInstNew = NULL; - replaceBitmap.nIDOld = (UINT) oldToolBarBitmap; - replaceBitmap.nIDNew = (UINT) (HBITMAP) m_hBitmap; - replaceBitmap.nButtons = noButtons; - if ( ::SendMessage(GetHwnd(), TB_REPLACEBITMAP, - 0, (LPARAM) &replaceBitmap) == -1 ) +#ifdef TB_REPLACEBITMAP + if ( wxTheApp->GetComCtl32Version() >= 400 ) { - wxFAIL_MSG(wxT("Could not add bitmap to toolbar")); + TBREPLACEBITMAP replaceBitmap; + replaceBitmap.hInstOld = NULL; + replaceBitmap.hInstNew = NULL; + replaceBitmap.nIDOld = (UINT) oldToolBarBitmap; + replaceBitmap.nIDNew = (UINT) hBitmap; + replaceBitmap.nButtons = nButtons; + if ( !::SendMessage(GetHwnd(), TB_REPLACEBITMAP, + 0, (LPARAM) &replaceBitmap) ) + { + wxFAIL_MSG(wxT("Could not replace the old bitmap")); + } + + ::DeleteObject(oldToolBarBitmap); + + // already done + addBitmap = FALSE; } + else +#endif // TB_REPLACEBITMAP + { + // we can't replace the old bitmap, so we will add another one + // (awfully inefficient, but what else to do?) and shift the bitmap + // indices accordingly + addBitmap = TRUE; - ::DeleteObject((HBITMAP) oldToolBarBitmap); + bitmapId = m_nButtons; + } // Now delete all the buttons - int i = 0; - while ( TRUE ) + for ( size_t pos = 0; pos < m_nButtons; pos++ ) { - // TODO: What about separators???? They don't have an id! - if ( ! ::SendMessage( GetHwnd(), TB_DELETEBUTTON, i, 0 ) ) - break; + if ( !::SendMessage(GetHwnd(), TB_DELETEBUTTON, 0, 0) ) + { + wxLogDebug(wxT("TB_DELETEBUTTON failed")); + } } } - else + + if ( addBitmap ) // no old bitmap or we can't replace it { TBADDBITMAP addBitmap; addBitmap.hInst = 0; - addBitmap.nID = (UINT)m_hBitmap; + addBitmap.nID = (UINT) hBitmap; if ( ::SendMessage(GetHwnd(), TB_ADDBITMAP, - (WPARAM) noButtons, (LPARAM)&addBitmap) == -1 ) + (WPARAM) nButtons, (LPARAM)&addBitmap) == -1 ) { wxFAIL_MSG(wxT("Could not add bitmap to toolbar")); } } - // Now add the buttons. + // Next add the buttons and separators + // ----------------------------------- + TBBUTTON *buttons = new TBBUTTON[nTools]; - // this array will holds the indices of all controls in the toolbar + // this array will hold the indices of all controls in the toolbar wxArrayInt controlIds; + bool lastWasRadio = FALSE; int i = 0; - int bitmapId = 0; - - node = m_tools.First(); - while (node) + for ( node = m_tools.GetFirst(); node; node = node->GetNext() ) { - wxToolBarTool *tool = (wxToolBarTool *)node->Data(); + wxToolBarToolBase *tool = node->GetData(); + + // don't add separators to the vertical toolbar - looks ugly + if ( isVertical && tool->IsSeparator() ) + continue; + TBBUTTON& button = buttons[i]; wxZeroMemory(button); - switch ( tool->m_toolStyle ) + bool isRadio = FALSE; + switch ( tool->GetStyle() ) { case wxTOOL_STYLE_CONTROL: - controlIds.Add(i); - button.idCommand = tool->m_index; + button.idCommand = tool->GetId(); // fall through: create just a separator too case wxTOOL_STYLE_SEPARATOR: @@ -373,63 +610,160 @@ bool wxToolBar95::CreateTools() case wxTOOL_STYLE_BUTTON: button.iBitmap = bitmapId; - button.idCommand = tool->m_index; - if (tool->m_enabled) + if ( HasFlag(wxTB_TEXT) && !tool->GetLabel().empty() ) + { + button.iString = (int)tool->GetLabel().c_str(); + } + + button.idCommand = tool->GetId(); + + if ( tool->IsEnabled() ) button.fsState |= TBSTATE_ENABLED; - if (tool->m_toggleState) + if ( tool->IsToggled() ) button.fsState |= TBSTATE_CHECKED; - button.fsStyle = tool->m_isToggle ? TBSTYLE_CHECK - : TBSTYLE_BUTTON; + + switch ( tool->GetKind() ) + { + case wxITEM_RADIO: + button.fsStyle = TBSTYLE_CHECKGROUP; + + if ( !lastWasRadio ) + { + // the first item in the radio group is checked by + // default to be consistent with wxGTK and the menu + // radio items + button.fsState |= TBSTATE_CHECKED; + + tool->Toggle(TRUE); + } + + isRadio = TRUE; + break; + + case wxITEM_CHECK: + button.fsStyle = TBSTYLE_CHECK; + break; + + default: + wxFAIL_MSG( _T("unexpected toolbar button kind") ); + // fall through + + case wxITEM_NORMAL: + button.fsStyle = TBSTYLE_BUTTON; + } bitmapId++; break; } + lastWasRadio = isRadio; + i++; - node = node->Next(); } - 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; - // TBBUTTONINFO struct declaration is missing from mingw32 headers -#ifndef __GNUWIN32__ + // Deal with the controls finally + // ------------------------------ + // adjust the controls size to fit nicely in the toolbar - size_t nControls = controlIds.GetCount(); - for ( size_t nCtrl = 0; nCtrl < nControls; nCtrl++ ) + int y = 0; + size_t index = 0; + for ( node = m_tools.GetFirst(); node; node = node->GetNext(), index++ ) { - wxToolBarTool *tool = (wxToolBarTool *) - m_tools.Nth(controlIds[nCtrl])->Data(); + wxToolBarToolBase *tool = node->GetData(); + + // we calculate the running y coord for vertical toolbars so we need to + // get the items size for all items but for the horizontal ones we + // don't need to deal with the non controls + bool isControl = tool->IsControl(); + if ( !isControl && !isVertical ) + continue; + + // note that we use TB_GETITEMRECT and not TB_GETRECT because the + // latter only appeared in v4.70 of comctl32.dll + RECT r; + if ( !SendMessage(GetHwnd(), TB_GETITEMRECT, + index, (LPARAM)(LPRECT)&r) ) + { + wxLogLastError(wxT("TB_GETITEMRECT")); + } + + if ( !isControl ) + { + // can only be control if isVertical + y += r.bottom - r.top; + + continue; + } + wxControl *control = tool->GetControl(); wxSize size = control->GetSize(); - // set the (underlying) separators width to be that of the control - TBBUTTONINFO tbbi; - tbbi.cbSize = sizeof(tbbi); - tbbi.dwMask = TBIF_SIZE; - tbbi.cx = size.x; - if ( !SendMessage(GetHwnd(), TB_SETBUTTONINFO, - tool->m_index, (LPARAM)&tbbi) ) + // the position of the leftmost controls corner + int left = -1; + + // TB_SETBUTTONINFO message is only supported by comctl32.dll 4.71+ +#if defined(_WIN32_IE) && (_WIN32_IE >= 0x400 ) + // available in headers, now check whether it is available now + // (during run-time) + if ( wxTheApp->GetComCtl32Version() >= 471 ) { - // the index is probably invalid - wxLogLastError("TB_SETBUTTONINFO"); + // set the (underlying) separators width to be that of the + // control + TBBUTTONINFO tbbi; + tbbi.cbSize = sizeof(tbbi); + tbbi.dwMask = TBIF_SIZE; + tbbi.cx = size.x; + if ( !SendMessage(GetHwnd(), TB_SETBUTTONINFO, + tool->GetId(), (LPARAM)&tbbi) ) + { + // the id is probably invalid? + wxLogLastError(wxT("TB_SETBUTTONINFO")); + } } - - // and position the control itself correctly vertically - RECT r; - if ( !SendMessage(GetHwnd(), TB_GETRECT, - tool->m_index, (LPARAM)(LPRECT)&r) ) + else +#endif // comctl32.dll 4.71 + // TB_SETBUTTONINFO unavailable { - wxLogLastError("TB_GETRECT"); + // try adding several separators to fit the controls width + int widthSep = r.right - r.left; + left = r.left; + + TBBUTTON tbb; + wxZeroMemory(tbb); + tbb.idCommand = 0; + tbb.fsState = TBSTATE_ENABLED; + tbb.fsStyle = TBSTYLE_SEP; + + size_t nSeparators = size.x / widthSep; + for ( size_t nSep = 0; nSep < nSeparators; nSep++ ) + { + if ( !SendMessage(GetHwnd(), TB_INSERTBUTTON, + index, (LPARAM)&tbb) ) + { + wxLogLastError(wxT("TB_INSERTBUTTON")); + } + + index++; + } + + // remember the number of separators we used - we'd have to + // delete all of them later + ((wxToolBarTool *)tool)->SetSeparatorsCount(nSeparators); + + // adjust the controls width to exactly cover the separators + control->SetSize((nSeparators + 1)*widthSep, -1); } + // position the control itself correctly vertically int height = r.bottom - r.top; int diff = height - size.y; if ( diff < 0 ) @@ -440,13 +774,45 @@ bool wxToolBar95::CreateTools() diff = 2; } - control->Move(r.left, r.top + diff / 2); + int top; + if ( isVertical ) + { + left = 0; + top = y; + + y += height + 2*GetMargins().y; + } + else // horizontal toolbar + { + if ( left == -1 ) + left = r.left; + + top = r.top; + } + + control->Move(left, top + (diff + 1) / 2); } -#endif // __GNUWIN32__ - (void)::SendMessage(GetHwnd(), TB_AUTOSIZE, (WPARAM)0, (LPARAM) 0); + // the max index is the "real" number of buttons - i.e. counting even the + // separators which we added just for aligning the controls + m_nButtons = index; - SetRows(m_maxRows); + if ( !isVertical ) + { + if ( m_maxRows == 0 ) + { + // if not set yet, only one row + SetRows(1); + } + } + else if ( m_nButtons > 0 ) // vertical non empty toolbar + { + if ( m_maxRows == 0 ) + { + // if not set yet, have one column + SetRows(m_nButtons); + } + } return TRUE; } @@ -455,33 +821,42 @@ bool wxToolBar95::CreateTools() // message handlers // ---------------------------------------------------------------------------- -bool wxToolBar95::MSWCommand(WXUINT cmd, WXWORD id) +bool wxToolBar::MSWCommand(WXUINT WXUNUSED(cmd), WXWORD id) { - wxNode *node = m_tools.Find((long)id); - if (!node) + wxToolBarToolBase *tool = FindById((int)id); + if ( !tool ) return FALSE; - wxToolBarTool *tool = (wxToolBarTool *)node->Data(); - if (tool->m_isToggle) + if ( tool->CanBeToggled() ) { LRESULT state = ::SendMessage(GetHwnd(), TB_GETSTATE, id, 0); - tool->m_toggleState = state & TBSTATE_CHECKED; + tool->Toggle((state & TBSTATE_CHECKED) != 0); } - BOOL ret = OnLeftClick((int)id, tool->m_toggleState); - if ( ret == FALSE && tool->m_isToggle ) + bool toggled = tool->IsToggled(); + + // avoid sending the event when a radio button is released, this is not + // interesting + if ( !tool->CanBeToggled() || tool->GetKind() != wxITEM_RADIO || toggled ) { - tool->m_toggleState = !tool->m_toggleState; - ::SendMessage(GetHwnd(), TB_CHECKBUTTON, - (WPARAM)id, (LPARAM)MAKELONG(tool->m_toggleState, 0)); + // OnLeftClick() can veto the button state change - for buttons which + // may be toggled only, of couse + if ( !OnLeftClick((int)id, toggled) && tool->CanBeToggled() ) + { + // revert back + toggled = !toggled; + tool->SetToggle(toggled); + + ::SendMessage(GetHwnd(), TB_CHECKBUTTON, id, MAKELONG(toggled, 0)); + } } return TRUE; } -bool wxToolBar95::MSWOnNotify(int WXUNUSED(idCtrl), +bool wxToolBar::MSWOnNotify(int WXUNUSED(idCtrl), WXLPARAM lParam, - WXLPARAM *result) + WXLPARAM *WXUNUSED(result)) { // First check if this applies to us NMHDR *hdr = (NMHDR *)lParam; @@ -498,13 +873,12 @@ bool wxToolBar95::MSWOnNotify(int WXUNUSED(idCtrl), LPTOOLTIPTEXT ttText = (LPTOOLTIPTEXT)lParam; int id = (int)ttText->hdr.idFrom; - wxNode *node = m_tools.Find((long)id); - if (!node) - return FALSE; - wxToolBarTool *tool = (wxToolBarTool *)node->Data(); + wxToolBarToolBase *tool = FindById(id); + if ( !tool ) + return FALSE; - const wxString& help = tool->m_shortHelpString; + const wxString& help = tool->GetShortHelp(); if ( !help.IsEmpty() ) { @@ -512,15 +886,22 @@ bool wxToolBar95::MSWOnNotify(int WXUNUSED(idCtrl), { ttText->lpszText = (wxChar *)help.c_str(); } -#if (_WIN32_IE >= 0x0300) 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__ + #if defined( __MWERKS__ ) || defined( __CYGWIN__ ) // MetroWerks doesn't like calling mbstowcs with NULL argument + // neither Cygwin does size_t lenUnicode = 2*lenAnsi; #else size_t lenUnicode = mbstowcs(NULL, help, lenAnsi); @@ -537,92 +918,209 @@ bool wxToolBar95::MSWOnNotify(int WXUNUSED(idCtrl), dst[lenUnicode] = 0; delete [] pwz; +#endif } -#endif // _WIN32_IE >= 0x0300 } - // For backward compatibility... - OnMouseEnter(tool->m_index); - return TRUE; } // ---------------------------------------------------------------------------- -// sizing stuff +// toolbar geometry // ---------------------------------------------------------------------------- -void wxToolBar95::SetToolBitmapSize(const wxSize& size) +void wxToolBar::SetToolBitmapSize(const wxSize& size) { wxToolBarBase::SetToolBitmapSize(size); ::SendMessage(GetHwnd(), TB_SETBITMAPSIZE, 0, MAKELONG(size.x, size.y)); } -void wxToolBar95::SetRows(int nRows) +void wxToolBar::SetRows(int nRows) { - // TRUE in wParam means to create at least as many rows + if ( nRows == m_maxRows ) + { + // avoid resizing the frame uselessly + return; + } + + // TRUE in wParam means to create at least as many rows, FALSE - + // at most as many RECT rect; ::SendMessage(GetHwnd(), TB_SETROWS, - MAKEWPARAM(nRows, TRUE), (LPARAM) &rect); - - m_maxWidth = (rect.right - rect.left + 2); - m_maxHeight = (rect.bottom - rect.top + 2); + MAKEWPARAM(nRows, !(GetWindowStyle() & wxTB_VERTICAL)), + (LPARAM) &rect); m_maxRows = nRows; + + UpdateSize(); } -wxSize wxToolBar95::GetMaxSize() const +// The button size is bigger than the bitmap size +wxSize wxToolBar::GetToolSize() const { - if ( (m_maxWidth == -1) || (m_maxHeight == -1) ) + // TB_GETBUTTONSIZE is supported from version 4.70 +#if defined(_WIN32_IE) && (_WIN32_IE >= 0x300 ) \ + && !( defined(__GNUWIN32__) && !wxCHECK_W32API_VERSION( 1, 0 ) ) + if ( wxTheApp->GetComCtl32Version() >= 470 ) { - // it has a side effect of filling m_maxWidth/Height variables - ((wxToolBar95 *)this)->SetRows(m_maxRows); // const_cast - } + DWORD dw = ::SendMessage(GetHwnd(), TB_GETBUTTONSIZE, 0, 0); - return wxSize(m_maxWidth, m_maxHeight); + return wxSize(LOWORD(dw), HIWORD(dw)); + } + else +#endif // comctl32.dll 4.70+ + { + // defaults + return wxSize(m_defaultWidth + 8, m_defaultHeight + 7); + } } -// The button size is bigger than the bitmap size -wxSize wxToolBar95::GetToolSize() const +static +wxToolBarToolBase *GetItemSkippingDummySpacers(const wxToolBarToolsList& tools, + size_t index ) { - // FIXME: this is completely bogus (VZ) - return wxSize(m_defaultWidth + 8, m_defaultHeight + 7); + wxToolBarToolsList::Node* current = tools.GetFirst(); + + for ( ; current != 0; current = current->GetNext() ) + { + if ( index == 0 ) + return current->GetData(); + + wxToolBarTool *tool = (wxToolBarTool *)current->GetData(); + size_t separators = tool->GetSeparatorsCount(); + + // if it is a normal button, sepcount == 0, so skip 1 item (the button) + // otherwise, skip as many items as the separator count, plus the + // control itself + index -= separators ? separators + 1 : 1; + } + + return 0; } -// ---------------------------------------------------------------------------- -// tool state -// ---------------------------------------------------------------------------- +wxToolBarToolBase *wxToolBar::FindToolForPosition(wxCoord x, wxCoord y) const +{ + POINT pt; + pt.x = x; + pt.y = y; + int index = (int)::SendMessage(GetHwnd(), TB_HITTEST, 0, (LPARAM)&pt); + // MBN: when the point ( x, y ) is close to the toolbar border + // TB_HITTEST returns m_nButtons ( not -1 ) + if ( index < 0 || (size_t)index >= m_nButtons ) + { + // it's a separator or there is no tool at all there + return (wxToolBarToolBase *)NULL; + } + + // if comctl32 version < 4.71 wxToolBar95 adds dummy spacers +#if defined(_WIN32_IE) && (_WIN32_IE >= 0x400 ) + if ( wxTheApp->GetComCtl32Version() >= 471 ) + { + return m_tools.Item((size_t)index)->GetData(); + } + else +#endif + { + return GetItemSkippingDummySpacers( m_tools, (size_t) index ); + } +} -void wxToolBar95::EnableTool(int toolIndex, bool enable) +void wxToolBar::UpdateSize() { - wxNode *node = m_tools.Find((long)toolIndex); - if (node) + // the toolbar size changed + SendMessage(GetHwnd(), TB_AUTOSIZE, 0, 0); + + // we must also refresh the frame after the toolbar size (possibly) changed + wxFrame *frame = wxDynamicCast(GetParent(), wxFrame); + if ( frame ) { - wxToolBarTool *tool = (wxToolBarTool *)node->Data(); - tool->m_enabled = enable; - ::SendMessage(GetHwnd(), TB_ENABLEBUTTON, - (WPARAM)toolIndex, (LPARAM)MAKELONG(enable, 0)); + frame->SendSizeEvent(); } } -void wxToolBar95::ToggleTool(int toolIndex, bool toggle) +// ---------------------------------------------------------------------------- +// toolbar styles +// --------------------------------------------------------------------------- + +void wxToolBar::SetWindowStyleFlag(long style) { - wxNode *node = m_tools.Find((long)toolIndex); - if (node) + // there doesn't seem to be any reasonably simple way to prevent the + // toolbar from showing the icons so for now we don't honour wxTB_NOICONS + if ( (style & wxTB_TEXT) != (GetWindowStyle() & wxTB_TEXT) ) { - wxToolBarTool *tool = (wxToolBarTool *)node->Data(); - if (tool->m_isToggle) + // update the strings of all toolbar buttons + // + // NB: we can only do it using TB_SETBUTTONINFO which is available + // in comctl32.dll >= 4.71 only +#if defined(_WIN32_IE) && (_WIN32_IE >= 0x400 ) + if ( wxTheApp->GetComCtl32Version() >= 471 ) { - tool->m_toggleState = toggle; - ::SendMessage(GetHwnd(), TB_CHECKBUTTON, - (WPARAM)toolIndex, (LPARAM)MAKELONG(toggle, 0)); + // set the (underlying) separators width to be that of the + // control + TBBUTTONINFO tbbi; + tbbi.cbSize = sizeof(tbbi); + tbbi.dwMask = TBIF_TEXT; + if ( !(style & wxTB_TEXT) ) + { + // don't show the text - remove the labels + tbbi.pszText = NULL; + } + + for ( wxToolBarToolsList::Node *node = m_tools.GetFirst(); + node; + node = node->GetNext() ) + { + wxToolBarToolBase *tool = node->GetData(); + if ( !tool->IsButton() ) + { + continue; + } + + if ( style & wxTB_TEXT ) + { + // cast is harmless + tbbi.pszText = (wxChar *)tool->GetLabel().c_str(); + } + + if ( !SendMessage(GetHwnd(), TB_SETBUTTONINFO, + tool->GetId(), (LPARAM)&tbbi) ) + { + // the id is probably invalid? + wxLogLastError(wxT("TB_SETBUTTONINFO")); + } + } + + UpdateSize(); + Refresh(); } +#endif // comctl32.dll 4.71 } + + wxToolBarBase::SetWindowStyleFlag(style); } -bool wxToolBar95::GetToolState(int toolIndex) const +// ---------------------------------------------------------------------------- +// tool state +// ---------------------------------------------------------------------------- + +void wxToolBar::DoEnableTool(wxToolBarToolBase *tool, bool enable) { - return (::SendMessage(GetHwnd(), TB_ISBUTTONCHECKED, (WPARAM)toolIndex, (LPARAM)0) != 0); + ::SendMessage(GetHwnd(), TB_ENABLEBUTTON, + (WPARAM)tool->GetId(), (LPARAM)MAKELONG(enable, 0)); +} + +void wxToolBar::DoToggleTool(wxToolBarToolBase *tool, bool toggle) +{ + ::SendMessage(GetHwnd(), TB_CHECKBUTTON, + (WPARAM)tool->GetId(), (LPARAM)MAKELONG(toggle, 0)); +} + +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 + wxFAIL_MSG( _T("not implemented") ); } // ---------------------------------------------------------------------------- @@ -630,21 +1128,25 @@ bool wxToolBar95::GetToolState(int toolIndex) const // ---------------------------------------------------------------------------- // Responds to colour changes, and passes event on to children. -void wxToolBar95::OnSysColourChanged(wxSysColourChangedEvent& event) +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 - CreateTools(); + Realize(); + + // Relayout the toolbar + int nrows = m_maxRows; + m_maxRows = 0; // otherwise SetRows() wouldn't do anything + SetRows(nrows); Refresh(); - // Propagate the event to the non-top-level children - wxWindow::OnSysColourChanged(event); + // let the event propagate further + event.Skip(); } -void wxToolBar95::OnMouseEvent(wxMouseEvent& event) +void wxToolBar::OnMouseEvent(wxMouseEvent& event) { if (event.RightDown()) { @@ -658,107 +1160,305 @@ void wxToolBar95::OnMouseEvent(wxMouseEvent& event) } } +bool wxToolBar::HandleSize(WXWPARAM wParam, WXLPARAM lParam) +{ + // calculate our minor dimenstion ourselves - we're confusing the standard + // logic (TB_AUTOSIZE) with our horizontal toolbars and other hacks + RECT r; + if ( ::SendMessage(GetHwnd(), TB_GETITEMRECT, 0, (LPARAM)&r) ) + { + int w, h; + + if ( GetWindowStyle() & wxTB_VERTICAL ) + { + w = r.right - r.left; + if ( m_maxRows ) + { + w *= (m_nButtons + m_maxRows - 1)/m_maxRows; + } + h = HIWORD(lParam); + } + else + { + w = LOWORD(lParam); + if (HasFlag( wxTB_FLAT )) + h = r.bottom - r.top - 3; + else + h = r.bottom - r.top; + if ( m_maxRows ) + { + // FIXME: 6 is hardcoded separator line height... + //h += 6; + if (HasFlag(wxTB_NODIVIDER)) + h += 3; + else + h += 6; + h *= m_maxRows; + } + } + + if ( MAKELPARAM(w, h) != lParam ) + { + // size really changed + SetSize(w, h); + } + + // message processed + return TRUE; + } + + return FALSE; +} + +bool wxToolBar::HandlePaint(WXWPARAM wParam, WXLPARAM lParam) +{ + // erase any dummy separators which we used for aligning the controls if + // any here + + // first of all, do we have any controls at all? + wxToolBarToolsList::Node *node; + for ( node = m_tools.GetFirst(); node; node = node->GetNext() ) + { + if ( node->GetData()->IsControl() ) + break; + } + + if ( !node ) + { + // no controls, nothing to erase + return FALSE; + } + + // prepare the DC on which we'll be drawing + wxClientDC dc(this); + dc.SetBrush(wxBrush(GetBackgroundColour(), wxSOLID)); + dc.SetPen(*wxTRANSPARENT_PEN); + + RECT r; + if ( !GetUpdateRect(GetHwnd(), &r, FALSE) ) + { + // nothing to redraw anyhow + return FALSE; + } + + wxRect rectUpdate; + wxCopyRECTToRect(r, rectUpdate); + + dc.SetClippingRegion(rectUpdate); + + // draw the toolbar tools, separators &c normally + wxControl::MSWWindowProc(WM_PAINT, wParam, lParam); + + // for each control in the toolbar find all the separators intersecting it + // and erase them + // + // NB: this is really the only way to do it as we don't know if a separator + // corresponds to a control (i.e. is a dummy one) or a real one + // otherwise + for ( node = m_tools.GetFirst(); node; node = node->GetNext() ) + { + wxToolBarToolBase *tool = node->GetData(); + if ( tool->IsControl() ) + { + // get the control rect in our client coords + wxControl *control = tool->GetControl(); + wxRect rectCtrl = control->GetRect(); + + // iterate over all buttons + TBBUTTON tbb; + int count = ::SendMessage(GetHwnd(), TB_BUTTONCOUNT, 0, 0); + for ( int n = 0; n < count; n++ ) + { + // is it a separator? + if ( !::SendMessage(GetHwnd(), TB_GETBUTTON, + n, (LPARAM)&tbb) ) + { + wxLogDebug(_T("TB_GETBUTTON failed?")); + + continue; + } + + if ( tbb.fsStyle != TBSTYLE_SEP ) + continue; + + // get the bounding rect of the separator + RECT r; + if ( !::SendMessage(GetHwnd(), TB_GETITEMRECT, + n, (LPARAM)&r) ) + { + wxLogDebug(_T("TB_GETITEMRECT failed?")); + + continue; + } + + // does it intersect the control? + wxRect rectItem; + wxCopyRECTToRect(r, rectItem); + if ( rectCtrl.Intersects(rectItem) ) + { + // yes, do erase it! + dc.DrawRectangle(rectItem); + } + } + } + } + + return TRUE; +} + +void wxToolBar::HandleMouseMove(WXWPARAM wParam, WXLPARAM lParam) +{ + wxCoord x = GET_X_LPARAM(lParam), + y = GET_Y_LPARAM(lParam); + wxToolBarToolBase* tool = FindToolForPosition( x, y ); + + // cursor left current tool + if( tool != m_pInTool && !tool ) + { + m_pInTool = 0; + OnMouseEnter( -1 ); + } + + // cursor entered a tool + if( tool != m_pInTool && tool ) + { + m_pInTool = tool; + OnMouseEnter( tool->GetId() ); + } +} + +long wxToolBar::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam) +{ + switch ( nMsg ) + { + case WM_SIZE: + if ( HandleSize(wParam, lParam) ) + return 0; + break; + + case WM_MOUSEMOVE: + // we don't handle mouse moves, so always pass the message to + // wxControl::MSWWindowProc + HandleMouseMove(wParam, lParam); + break; + + case WM_PAINT: + if ( HandlePaint(wParam, lParam) ) + return 0; + } + + return wxControl::MSWWindowProc(nMsg, wParam, lParam); +} + // ---------------------------------------------------------------------------- // private functions // ---------------------------------------------------------------------------- -// These are the default colors used to map the bitmap colors -// to the current system colors +WXHBITMAP wxToolBar::MapBitmap(WXHBITMAP bitmap, int width, int height) +{ + MemoryHDC hdcMem; -// VZ: why are they BGR and not RGB? just to confuse the people or is there a -// deeper reason? -#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(255,000,000)) // blue -#define BGR_BACKGROUND (RGB(255,000,255)) // magenta + if ( !hdcMem ) + { + wxLogLastError(_T("CreateCompatibleDC")); -void wxMapBitmap(HBITMAP hBitmap, 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++) - { - for ( j = 0; j < height; j++) + return bitmap; + } + + SelectInHDC bmpInHDC(hdcMem, (HBITMAP)bitmap); + + if ( !bmpInHDC ) + { + wxLogLastError(_T("SelectObject")); + + return bitmap; + } + + wxCOLORMAP *cmap = wxGetStdColourMap(); + + for ( int i = 0; i < width; i++ ) + { + for ( int j = 0; j < height; j++ ) { 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 ++) + for ( size_t k = 0; k < wxSTD_COL_MAX; k++ ) { - if ( ColorMap[k].from == pixel ) + COLORREF col = cmap[k].from; + if ( abs(GetRValue(pixel) - GetRValue(col)) < 10 && + abs(GetGValue(pixel) - GetGValue(col)) < 10 && + abs(GetBValue(pixel) - GetBValue(col)) < 10 ) { - /* COLORREF actualPixel = */ ::SetPixel(hdcMem, i, j, ColorMap[k].to); + ::SetPixel(hdcMem, i, j, cmap[k].to); break; } } } } + return bitmap; + + // VZ: I leave here my attempts to map the bitmap to the system colours + // faster by using BitBlt() even though it's broken currently - but + // maybe someone else can finish it? It should be faster than iterating + // over all pixels... +#if 0 + MemoryHDC hdcMask, hdcDst; + if ( !hdcMask || !hdcDst ) + { + wxLogLastError(_T("CreateCompatibleDC")); + + return bitmap; + } + + // create the target bitmap + HBITMAP hbmpDst = ::CreateCompatibleBitmap(hdcDst, width, height); + if ( !hbmpDst ) + { + wxLogLastError(_T("CreateCompatibleBitmap")); - SelectObject(hdcMem, hbmOld); - DeleteObject(hdcMem); - } + return bitmap; + } -} + // create the monochrome mask bitmap + HBITMAP hbmpMask = ::CreateBitmap(width, height, 1, 1, 0); + if ( !hbmpMask ) + { + wxLogLastError(_T("CreateBitmap(mono)")); -// 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); -// LPBITMAPINFOHEADER lpbmi = (LPBITMAPINFOHEADER) newDIB; - - int result = ::SetDIBits(dc, newBitmap, 0, lpbmi->biHeight, FindDIBBits((LPSTR)lpbmi), (LPBITMAPINFO)lpbmi, - DIB_PAL_COLORS); - DWORD err = GetLastError(); - - ::ReleaseDC(NULL, dc); - - // Delete the DIB - GlobalUnlock (newDIB); - GlobalFree (newDIB); - -// WXHBITMAP hBitmap2 = wxCreateMappedBitmap((WXHINSTANCE) wxGetInstance(), (WXHBITMAP) m_hBitmap); - // Substitute our new bitmap for the old one - ::DeleteObject((HBITMAP) m_hBitmap); - m_hBitmap = (WXHBITMAP) newBitmap; -#endif + ::DeleteObject(hbmpDst); + + return bitmap; + } + + SelectInHDC bmpInDst(hdcDst, hbmpDst), + bmpInMask(hdcMask, hbmpMask); + + // for each colour: + for ( n = 0; n < NUM_OF_MAPPED_COLOURS; n++ ) + { + // create the mask for this colour + ::SetBkColor(hdcMem, ColorMap[n].from); + ::BitBlt(hdcMask, 0, 0, width, height, hdcMem, 0, 0, SRCCOPY); + + // replace this colour with the target one in the dst bitmap + HBRUSH hbr = ::CreateSolidBrush(ColorMap[n].to); + HGDIOBJ hbrOld = ::SelectObject(hdcDst, hbr); + + ::MaskBlt(hdcDst, 0, 0, width, height, + hdcMem, 0, 0, + hbmpMask, 0, 0, + MAKEROP4(PATCOPY, SRCCOPY)); + + (void)::SelectObject(hdcDst, hbrOld); + ::DeleteObject(hbr); + } + + ::DeleteObject((HBITMAP)bitmap); + + return (WXHBITMAP)hbmpDst; +#endif // 0 +} +#endif // wxUSE_TOOLBAR && Win95 -#endif // !(wxUSE_TOOLBAR && Win95)