1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/msw/toolbar.cpp
4 // Author: Julian Smart
8 // Copyright: (c) Julian Smart
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
12 // ============================================================================
14 // ============================================================================
16 // ----------------------------------------------------------------------------
18 // ----------------------------------------------------------------------------
20 // For compilers that support precompilation, includes "wx.h".
21 #include "wx/wxprec.h"
27 #if wxUSE_TOOLBAR && wxUSE_TOOLBAR_NATIVE && !defined(__SMARTPHONE__)
29 #include "wx/toolbar.h"
32 #include "wx/msw/wrapcctl.h" // include <commctrl.h> "properly"
33 #include "wx/dynarray.h"
37 #include "wx/settings.h"
38 #include "wx/bitmap.h"
39 #include "wx/dcmemory.h"
40 #include "wx/control.h"
41 #include "wx/app.h" // for GetComCtl32Version
43 #include "wx/stattext.h"
46 #include "wx/sysopt.h"
47 #include "wx/dcclient.h"
49 #include "wx/msw/private.h"
50 #include "wx/msw/dc.h"
53 #include "wx/msw/uxtheme.h"
56 // this define controls whether the code for button colours remapping (only
57 // useful for 16 or 256 colour images) is active at all, it's always turned off
58 // for CE where it doesn't compile (and is probably not needed anyhow) and may
59 // also be turned off for other systems if you always use 24bpp images and so
62 #define wxREMAP_BUTTON_COLOURS
63 #endif // !__WXWINCE__
65 // ----------------------------------------------------------------------------
67 // ----------------------------------------------------------------------------
69 // these standard constants are not always defined in compilers headers
73 #define TBSTYLE_LIST 0x1000
74 #define TBSTYLE_FLAT 0x0800
77 #ifndef TBSTYLE_TRANSPARENT
78 #define TBSTYLE_TRANSPARENT 0x8000
81 #ifndef TBSTYLE_TOOLTIPS
82 #define TBSTYLE_TOOLTIPS 0x0100
87 #define TB_SETSTYLE (WM_USER + 56)
88 #define TB_GETSTYLE (WM_USER + 57)
92 #define TB_HITTEST (WM_USER + 69)
96 #define TB_GETMAXSIZE (WM_USER + 83)
99 // these values correspond to those used by comctl32.dll
100 #define DEFAULTBITMAPX 16
101 #define DEFAULTBITMAPY 15
103 // ----------------------------------------------------------------------------
105 // ----------------------------------------------------------------------------
107 IMPLEMENT_DYNAMIC_CLASS(wxToolBar
, wxControl
)
119 style ( wxNO_BORDER | wxTB_HORIZONTAL)
128 BEGIN_EVENT_TABLE(wxToolBar
, wxToolBarBase
)
129 EVT_MOUSE_EVENTS(wxToolBar::OnMouseEvent
)
130 EVT_SYS_COLOUR_CHANGED(wxToolBar::OnSysColourChanged
)
131 EVT_ERASE_BACKGROUND(wxToolBar::OnEraseBackground
)
134 // ----------------------------------------------------------------------------
136 // ----------------------------------------------------------------------------
138 class wxToolBarTool
: public wxToolBarToolBase
141 wxToolBarTool(wxToolBar
*tbar
,
143 const wxString
& label
,
144 const wxBitmap
& bmpNormal
,
145 const wxBitmap
& bmpDisabled
,
147 wxObject
*clientData
,
148 const wxString
& shortHelp
,
149 const wxString
& longHelp
)
150 : wxToolBarToolBase(tbar
, id
, label
, bmpNormal
, bmpDisabled
, kind
,
151 clientData
, shortHelp
, longHelp
)
157 wxToolBarTool(wxToolBar
*tbar
, wxControl
*control
, const wxString
& label
)
158 : wxToolBarToolBase(tbar
, control
, label
)
160 if ( IsControl() && !m_label
.empty() )
162 // create a control to render the control's label
163 m_staticText
= new wxStaticText
170 wxALIGN_CENTRE
| wxST_NO_AUTORESIZE
181 virtual ~wxToolBarTool()
186 virtual void SetLabel(const wxString
& label
)
188 if ( label
== m_label
)
191 wxToolBarToolBase::SetLabel(label
);
194 m_staticText
->SetLabel(label
);
196 // we need to update the label shown in the toolbar because it has a
197 // pointer to the internal buffer of the old label
199 // TODO: use TB_SETBUTTONINFO
202 wxStaticText
* GetStaticText()
204 wxASSERT_MSG( IsControl(),
205 _T("only makes sense for embedded control tools") );
210 // set/get the number of separators which we use to cover the space used by
211 // a control in the toolbar
212 void SetSeparatorsCount(size_t count
) { m_nSepCount
= count
; }
213 size_t GetSeparatorsCount() const { return m_nSepCount
; }
217 wxStaticText
*m_staticText
;
219 DECLARE_NO_COPY_CLASS(wxToolBarTool
)
222 // ----------------------------------------------------------------------------
224 // ----------------------------------------------------------------------------
226 // return the rectangle of the item at the given index
228 // returns an empty (0, 0, 0, 0) rectangle if fails so the caller may compare
229 // r.right or r.bottom with 0 to check for this
230 static RECT
wxGetTBItemRect(HWND hwnd
, int index
)
234 // note that we use TB_GETITEMRECT and not TB_GETRECT because the latter
235 // only appeared in v4.70 of comctl32.dll
236 if ( !::SendMessage(hwnd
, TB_GETITEMRECT
, index
, (LPARAM
)&r
) )
238 wxLogLastError(wxT("TB_GETITEMRECT"));
249 // ============================================================================
251 // ============================================================================
253 // ----------------------------------------------------------------------------
255 // ----------------------------------------------------------------------------
257 wxToolBarToolBase
*wxToolBar::CreateTool(int id
,
258 const wxString
& label
,
259 const wxBitmap
& bmpNormal
,
260 const wxBitmap
& bmpDisabled
,
262 wxObject
*clientData
,
263 const wxString
& shortHelp
,
264 const wxString
& longHelp
)
266 return new wxToolBarTool(this, id
, label
, bmpNormal
, bmpDisabled
, kind
,
267 clientData
, shortHelp
, longHelp
);
271 wxToolBar::CreateTool(wxControl
*control
, const wxString
& label
)
273 return new wxToolBarTool(this, control
, label
);
276 // ----------------------------------------------------------------------------
277 // wxToolBar construction
278 // ----------------------------------------------------------------------------
280 void wxToolBar::Init()
283 m_disabledImgList
= NULL
;
287 m_defaultWidth
= DEFAULTBITMAPX
;
288 m_defaultHeight
= DEFAULTBITMAPY
;
293 bool wxToolBar::Create(wxWindow
*parent
,
298 const wxString
& name
)
300 // common initialisation
301 if ( !CreateControl(parent
, id
, pos
, size
, style
, wxDefaultValidator
, name
) )
306 // MSW-specific initialisation
307 if ( !MSWCreateToolbar(pos
, size
) )
310 wxSetCCUnicodeFormat(GetHwnd());
312 // workaround for flat toolbar on Windows XP classic style: we have to set
313 // the style after creating the control; doing it at creation time doesn't work
315 if ( style
& wxTB_FLAT
)
317 LRESULT style
= GetMSWToolbarStyle();
319 if ( !(style
& TBSTYLE_FLAT
) )
320 ::SendMessage(GetHwnd(), TB_SETSTYLE
, 0, style
| TBSTYLE_FLAT
);
322 #endif // wxUSE_UXTHEME
327 bool wxToolBar::MSWCreateToolbar(const wxPoint
& pos
, const wxSize
& size
)
329 if ( !MSWCreateControl(TOOLBARCLASSNAME
, wxEmptyString
, pos
, size
) )
332 // toolbar-specific post initialisation
333 ::SendMessage(GetHwnd(), TB_BUTTONSTRUCTSIZE
, sizeof(TBBUTTON
), 0);
335 #ifdef TB_SETEXTENDEDSTYLE
336 if ( wxApp::GetComCtl32Version() >= 471 )
337 ::SendMessage(GetHwnd(), TB_SETEXTENDEDSTYLE
, 0, TBSTYLE_EX_DRAWDDARROWS
);
343 void wxToolBar::Recreate()
345 const HWND hwndOld
= GetHwnd();
348 // we haven't been created yet, no need to recreate
352 // get the position and size before unsubclassing the old toolbar
353 const wxPoint pos
= GetPosition();
354 const wxSize size
= GetSize();
358 if ( !MSWCreateToolbar(pos
, size
) )
361 wxFAIL_MSG( _T("recreating the toolbar failed") );
366 // reparent all our children under the new toolbar
367 for ( wxWindowList::compatibility_iterator node
= m_children
.GetFirst();
369 node
= node
->GetNext() )
371 wxWindow
*win
= node
->GetData();
372 if ( !win
->IsTopLevel() )
373 ::SetParent(GetHwndOf(win
), GetHwnd());
376 // only destroy the old toolbar now --
377 // after all the children had been reparented
378 ::DestroyWindow(hwndOld
);
380 // it is for the old bitmap control and can't be used with the new one
383 ::DeleteObject((HBITMAP
) m_hBitmap
);
387 if ( m_disabledImgList
)
389 delete m_disabledImgList
;
390 m_disabledImgList
= NULL
;
396 wxToolBar::~wxToolBar()
398 // we must refresh the frame size when the toolbar is deleted but the frame
399 // is not - otherwise toolbar leaves a hole in the place it used to occupy
400 SendSizeEventToParent();
403 ::DeleteObject((HBITMAP
) m_hBitmap
);
405 delete m_disabledImgList
;
408 wxSize
wxToolBar::DoGetBestSize() const
413 if ( !::SendMessage(GetHwnd(), TB_GETMAXSIZE
, 0, (LPARAM
)&size
) )
415 // maybe an old (< 0x400) Windows version? try to approximate the
416 // toolbar size ourselves
417 sizeBest
= GetToolSize();
418 sizeBest
.y
+= 2 * ::GetSystemMetrics(SM_CYBORDER
); // Add borders
419 sizeBest
.x
*= GetToolsCount();
421 // reverse horz and vertical components if necessary
425 sizeBest
.x
= sizeBest
.y
;
429 else // TB_GETMAXSIZE succeeded
431 // but it could still return an incorrect result due to what appears to
432 // be a bug in old comctl32.dll versions which don't handle controls in
433 // the toolbar correctly, so work around it (see SF patch 1902358)
434 if ( !IsVertical() && wxApp::GetComCtl32Version() < 600 )
436 // calculate the toolbar width in alternative way
437 const RECT rcFirst
= wxGetTBItemRect(GetHwnd(), 0);
438 const RECT rcLast
= wxGetTBItemRect(GetHwnd(), GetToolsCount() - 1);
440 const int widthAlt
= rcLast
.right
- rcFirst
.left
;
441 if ( widthAlt
> size
.cx
)
445 sizeBest
.x
= size
.cx
;
446 sizeBest
.y
= size
.cy
;
451 // Without the extra height, DoGetBestSize can report a size that's
452 // smaller than the actual window, causing windows to overlap slightly
453 // in some circumstances, leading to missing borders (especially noticeable
455 if (!(GetWindowStyle() & wxTB_NODIVIDER
))
460 CacheBestSize(sizeBest
);
465 WXDWORD
wxToolBar::MSWGetStyle(long style
, WXDWORD
*exstyle
) const
467 // toolbars never have border, giving one to them results in broken
469 WXDWORD msStyle
= wxControl::MSWGetStyle
471 (style
& ~wxBORDER_MASK
) | wxBORDER_NONE
, exstyle
474 if ( !(style
& wxTB_NO_TOOLTIPS
) )
475 msStyle
|= TBSTYLE_TOOLTIPS
;
477 if ( style
& (wxTB_FLAT
| wxTB_HORZ_LAYOUT
) )
479 // static as it doesn't change during the program lifetime
480 static const int s_verComCtl
= wxApp::GetComCtl32Version();
482 // comctl32.dll 4.00 doesn't support the flat toolbars and using this
483 // style with 6.00 (part of Windows XP) leads to the toolbar with
484 // incorrect background colour - and not using it still results in the
485 // correct (flat) toolbar, so don't use it there
486 if ( s_verComCtl
> 400 && s_verComCtl
< 600 )
487 msStyle
|= TBSTYLE_FLAT
| TBSTYLE_TRANSPARENT
;
489 if ( s_verComCtl
>= 470 && style
& wxTB_HORZ_LAYOUT
)
490 msStyle
|= TBSTYLE_LIST
;
493 if ( style
& wxTB_NODIVIDER
)
494 msStyle
|= CCS_NODIVIDER
;
496 if ( style
& wxTB_NOALIGN
)
497 msStyle
|= CCS_NOPARENTALIGN
;
499 if ( style
& wxTB_VERTICAL
)
502 if( style
& wxTB_BOTTOM
)
503 msStyle
|= CCS_BOTTOM
;
505 if ( style
& wxTB_RIGHT
)
506 msStyle
|= CCS_RIGHT
;
511 // ----------------------------------------------------------------------------
512 // adding/removing tools
513 // ----------------------------------------------------------------------------
515 bool wxToolBar::DoInsertTool(size_t WXUNUSED(pos
),
516 wxToolBarToolBase
* WXUNUSED(tool
))
518 // nothing special to do here - we really create the toolbar buttons in
520 InvalidateBestSize();
524 bool wxToolBar::DoDeleteTool(size_t pos
, wxToolBarToolBase
*tool
)
526 // the main difficulty we have here is with the controls in the toolbars:
527 // as we (sometimes) use several separators to cover up the space used by
528 // them, the indices are not the same for us and the toolbar
530 // first determine the position of the first button to delete: it may be
531 // different from pos if we use several separators to cover the space used
533 wxToolBarToolsList::compatibility_iterator node
;
534 for ( node
= m_tools
.GetFirst(); node
; node
= node
->GetNext() )
536 wxToolBarToolBase
*tool2
= node
->GetData();
539 // let node point to the next node in the list
540 node
= node
->GetNext();
545 if ( tool2
->IsControl() )
546 pos
+= ((wxToolBarTool
*)tool2
)->GetSeparatorsCount() - 1;
549 // now determine the number of buttons to delete and the area taken by them
550 size_t nButtonsToDelete
= 1;
552 // get the size of the button we're going to delete
553 const RECT r
= wxGetTBItemRect(GetHwnd(), pos
);
555 int width
= r
.right
- r
.left
;
557 if ( tool
->IsControl() )
559 nButtonsToDelete
= ((wxToolBarTool
*)tool
)->GetSeparatorsCount();
560 width
*= nButtonsToDelete
;
563 // do delete all buttons
564 m_nButtons
-= nButtonsToDelete
;
565 while ( nButtonsToDelete
-- > 0 )
567 if ( !::SendMessage(GetHwnd(), TB_DELETEBUTTON
, pos
, 0) )
569 wxLogLastError(wxT("TB_DELETEBUTTON"));
575 // and finally reposition all the controls after this button (the toolbar
576 // takes care of all normal items)
577 for ( /* node -> first after deleted */ ; node
; node
= node
->GetNext() )
579 wxToolBarTool
*tool2
= (wxToolBarTool
*)node
->GetData();
580 if ( tool2
->IsControl() )
582 wxControl
* const control
= tool2
->GetControl();
585 control
->GetPosition(&x
, NULL
);
586 control
->Move(x
- width
, wxDefaultCoord
);
588 wxStaticText
* const staticText
= tool2
->GetStaticText();
590 staticText
->Move(x
- width
, wxDefaultCoord
);
594 InvalidateBestSize();
599 void wxToolBar::CreateDisabledImageList()
601 if (m_disabledImgList
!= NULL
)
603 delete m_disabledImgList
;
604 m_disabledImgList
= NULL
;
607 // as we can't use disabled image list with older versions of comctl32.dll,
608 // don't even bother creating it
609 if ( wxApp::GetComCtl32Version() >= 470 )
611 // search for the first disabled button img in the toolbar, if any
612 for ( wxToolBarToolsList::compatibility_iterator
613 node
= m_tools
.GetFirst(); node
; node
= node
->GetNext() )
615 wxToolBarToolBase
*tool
= node
->GetData();
616 wxBitmap bmpDisabled
= tool
->GetDisabledBitmap();
617 if ( bmpDisabled
.Ok() )
619 m_disabledImgList
= new wxImageList
623 bmpDisabled
.GetMask() != NULL
,
630 // we don't have any disabled bitmaps
634 bool wxToolBar::Realize()
636 const size_t nTools
= GetToolsCount();
641 #ifdef wxREMAP_BUTTON_COLOURS
642 // don't change the values of these constants, they can be set from the
643 // user code via wxSystemOptions
652 // the user-specified option overrides anything, but if it wasn't set, only
653 // remap the buttons on 8bpp displays as otherwise the bitmaps usually look
654 // much worse after remapping
655 static const wxChar
*remapOption
= wxT("msw.remap");
656 const int remapValue
= wxSystemOptions::HasOption(remapOption
)
657 ? wxSystemOptions::GetOptionInt(remapOption
)
658 : wxDisplayDepth() <= 8 ? Remap_Buttons
661 #endif // wxREMAP_BUTTON_COLOURS
663 // delete all old buttons, if any
664 for ( size_t pos
= 0; pos
< m_nButtons
; pos
++ )
666 if ( !::SendMessage(GetHwnd(), TB_DELETEBUTTON
, 0, 0) )
668 wxLogDebug(wxT("TB_DELETEBUTTON failed"));
672 // First, add the bitmap: we use one bitmap for all toolbar buttons
673 // ----------------------------------------------------------------
675 wxToolBarToolsList::compatibility_iterator node
;
679 if ( HasFlag(wxTB_NOICONS
) )
681 // no icons, don't leave space for them
685 else // do show icons
687 // if we already have a bitmap, we'll replace the existing one --
688 // otherwise we'll install a new one
689 HBITMAP oldToolBarBitmap
= (HBITMAP
)m_hBitmap
;
691 sizeBmp
.x
= m_defaultWidth
;
692 sizeBmp
.y
= m_defaultHeight
;
694 const wxCoord totalBitmapWidth
= m_defaultWidth
*
695 wx_truncate_cast(wxCoord
, nTools
),
696 totalBitmapHeight
= m_defaultHeight
;
698 // Create a bitmap and copy all the tool bitmaps into it
699 wxMemoryDC dcAllButtons
;
700 wxBitmap
bitmap(totalBitmapWidth
, totalBitmapHeight
);
701 dcAllButtons
.SelectObject(bitmap
);
703 #ifdef wxREMAP_BUTTON_COLOURS
704 if ( remapValue
!= Remap_TransparentBg
)
705 #endif // wxREMAP_BUTTON_COLOURS
707 // VZ: why do we hardcode grey colour for CE?
708 dcAllButtons
.SetBackground(wxBrush(
710 wxColour(0xc0, 0xc0, 0xc0)
711 #else // !__WXWINCE__
712 GetBackgroundColour()
713 #endif // __WXWINCE__/!__WXWINCE__
715 dcAllButtons
.Clear();
718 m_hBitmap
= bitmap
.GetHBITMAP();
719 HBITMAP hBitmap
= (HBITMAP
)m_hBitmap
;
721 #ifdef wxREMAP_BUTTON_COLOURS
722 if ( remapValue
== Remap_Bg
)
724 dcAllButtons
.SelectObject(wxNullBitmap
);
726 // Even if we're not remapping the bitmap
727 // content, we still have to remap the background.
728 hBitmap
= (HBITMAP
)MapBitmap((WXHBITMAP
) hBitmap
,
729 totalBitmapWidth
, totalBitmapHeight
);
731 dcAllButtons
.SelectObject(bitmap
);
733 #endif // wxREMAP_BUTTON_COLOURS
735 // the button position
738 // the number of buttons (not separators)
741 CreateDisabledImageList();
742 for ( node
= m_tools
.GetFirst(); node
; node
= node
->GetNext() )
744 wxToolBarToolBase
*tool
= node
->GetData();
745 if ( tool
->IsButton() )
747 const wxBitmap
& bmp
= tool
->GetNormalBitmap();
749 const int w
= bmp
.GetWidth();
750 const int h
= bmp
.GetHeight();
754 int xOffset
= wxMax(0, (m_defaultWidth
- w
)/2);
755 int yOffset
= wxMax(0, (m_defaultHeight
- h
)/2);
757 // notice the last parameter: do use mask
758 dcAllButtons
.DrawBitmap(bmp
, x
+ xOffset
, yOffset
, true);
762 wxFAIL_MSG( _T("invalid tool button bitmap") );
765 // also deal with disabled bitmap if we want to use them
766 if ( m_disabledImgList
)
768 wxBitmap bmpDisabled
= tool
->GetDisabledBitmap();
769 #if wxUSE_IMAGE && wxUSE_WXDIB
770 if ( !bmpDisabled
.Ok() )
772 // no disabled bitmap specified but we still need to
773 // fill the space in the image list with something, so
774 // we grey out the normal bitmap
776 imgGreyed
= bmp
.ConvertToImage().ConvertToGreyscale();
778 #ifdef wxREMAP_BUTTON_COLOURS
779 if ( remapValue
== Remap_Buttons
)
781 // we need to have light grey background colour for
782 // MapBitmap() to work correctly
783 for ( int y
= 0; y
< h
; y
++ )
785 for ( int x
= 0; x
< w
; x
++ )
787 if ( imgGreyed
.IsTransparent(x
, y
) )
788 imgGreyed
.SetRGB(x
, y
,
790 wxLIGHT_GREY
->Green(),
791 wxLIGHT_GREY
->Blue());
795 #endif // wxREMAP_BUTTON_COLOURS
797 bmpDisabled
= wxBitmap(imgGreyed
);
799 #endif // wxUSE_IMAGE
801 #ifdef wxREMAP_BUTTON_COLOURS
802 if ( remapValue
== Remap_Buttons
)
803 MapBitmap(bmpDisabled
.GetHBITMAP(), w
, h
);
804 #endif // wxREMAP_BUTTON_COLOURS
806 m_disabledImgList
->Add(bmpDisabled
);
809 // still inc width and number of buttons because otherwise the
810 // subsequent buttons will all be shifted which is rather confusing
811 // (and like this you'd see immediately which bitmap was bad)
817 dcAllButtons
.SelectObject(wxNullBitmap
);
819 // don't delete this HBITMAP!
820 bitmap
.SetHBITMAP(0);
822 #ifdef wxREMAP_BUTTON_COLOURS
823 if ( remapValue
== Remap_Buttons
)
825 // Map to system colours
826 hBitmap
= (HBITMAP
)MapBitmap((WXHBITMAP
) hBitmap
,
827 totalBitmapWidth
, totalBitmapHeight
);
829 #endif // wxREMAP_BUTTON_COLOURS
831 bool addBitmap
= true;
833 if ( oldToolBarBitmap
)
835 #ifdef TB_REPLACEBITMAP
836 if ( wxApp::GetComCtl32Version() >= 400 )
838 TBREPLACEBITMAP replaceBitmap
;
839 replaceBitmap
.hInstOld
= NULL
;
840 replaceBitmap
.hInstNew
= NULL
;
841 replaceBitmap
.nIDOld
= (UINT_PTR
)oldToolBarBitmap
;
842 replaceBitmap
.nIDNew
= (UINT_PTR
)hBitmap
;
843 replaceBitmap
.nButtons
= nButtons
;
844 if ( !::SendMessage(GetHwnd(), TB_REPLACEBITMAP
,
845 0, (LPARAM
) &replaceBitmap
) )
847 wxFAIL_MSG(wxT("Could not replace the old bitmap"));
850 ::DeleteObject(oldToolBarBitmap
);
856 #endif // TB_REPLACEBITMAP
858 // we can't replace the old bitmap, so we will add another one
859 // (awfully inefficient, but what else to do?) and shift the bitmap
860 // indices accordingly
863 bitmapId
= m_nButtons
;
867 if ( addBitmap
) // no old bitmap or we can't replace it
869 TBADDBITMAP addBitmap
;
871 addBitmap
.nID
= (UINT_PTR
)hBitmap
;
872 if ( ::SendMessage(GetHwnd(), TB_ADDBITMAP
,
873 (WPARAM
) nButtons
, (LPARAM
)&addBitmap
) == -1 )
875 wxFAIL_MSG(wxT("Could not add bitmap to toolbar"));
879 // disable image lists are only supported in comctl32.dll 4.70+
880 if ( wxApp::GetComCtl32Version() >= 470 )
882 HIMAGELIST hil
= m_disabledImgList
883 ? GetHimagelistOf(m_disabledImgList
)
886 // notice that we set the image list even if don't have one right
887 // now as we could have it before and need to reset it in this case
888 HIMAGELIST oldImageList
= (HIMAGELIST
)
889 ::SendMessage(GetHwnd(), TB_SETDISABLEDIMAGELIST
, 0, (LPARAM
)hil
);
891 // delete previous image list if any
893 ::DeleteObject(oldImageList
);
897 // don't call SetToolBitmapSize() as we don't want to change the values of
898 // m_defaultWidth/Height
899 if ( !::SendMessage(GetHwnd(), TB_SETBITMAPSIZE
, 0,
900 MAKELONG(sizeBmp
.x
, sizeBmp
.y
)) )
902 wxLogLastError(_T("TB_SETBITMAPSIZE"));
905 // Next add the buttons and separators
906 // -----------------------------------
908 TBBUTTON
*buttons
= new TBBUTTON
[nTools
];
910 // this array will hold the indices of all controls in the toolbar
911 wxArrayInt controlIds
;
913 bool lastWasRadio
= false;
915 for ( node
= m_tools
.GetFirst(); node
; node
= node
->GetNext() )
917 wxToolBarToolBase
*tool
= node
->GetData();
919 // don't add separators to the vertical toolbar with old comctl32.dll
920 // versions as they didn't handle this properly
921 if ( IsVertical() && tool
->IsSeparator() &&
922 wxApp::GetComCtl32Version() <= 472 )
927 TBBUTTON
& button
= buttons
[i
];
929 wxZeroMemory(button
);
931 bool isRadio
= false;
932 switch ( tool
->GetStyle() )
934 case wxTOOL_STYLE_CONTROL
:
935 button
.idCommand
= tool
->GetId();
936 // fall through: create just a separator too
938 case wxTOOL_STYLE_SEPARATOR
:
939 button
.fsState
= TBSTATE_ENABLED
;
940 button
.fsStyle
= TBSTYLE_SEP
;
943 case wxTOOL_STYLE_BUTTON
:
944 if ( !HasFlag(wxTB_NOICONS
) )
945 button
.iBitmap
= bitmapId
;
947 if ( HasFlag(wxTB_TEXT
) )
949 const wxString
& label
= tool
->GetLabel();
950 if ( !label
.empty() )
951 button
.iString
= (INT_PTR
)label
.wx_str();
954 button
.idCommand
= tool
->GetId();
956 if ( tool
->IsEnabled() )
957 button
.fsState
|= TBSTATE_ENABLED
;
958 if ( tool
->IsToggled() )
959 button
.fsState
|= TBSTATE_CHECKED
;
961 switch ( tool
->GetKind() )
964 button
.fsStyle
= TBSTYLE_CHECKGROUP
;
968 // the first item in the radio group is checked by
969 // default to be consistent with wxGTK and the menu
971 button
.fsState
|= TBSTATE_CHECKED
;
973 if (tool
->Toggle(true))
975 DoToggleTool(tool
, true);
978 else if ( tool
->IsToggled() )
980 wxToolBarToolsList::compatibility_iterator nodePrev
= node
->GetPrevious();
981 int prevIndex
= i
- 1;
984 TBBUTTON
& prevButton
= buttons
[prevIndex
];
985 wxToolBarToolBase
*tool
= nodePrev
->GetData();
986 if ( !tool
->IsButton() || tool
->GetKind() != wxITEM_RADIO
)
989 if ( tool
->Toggle(false) )
990 DoToggleTool(tool
, false);
992 prevButton
.fsState
&= ~TBSTATE_CHECKED
;
993 nodePrev
= nodePrev
->GetPrevious();
1002 button
.fsStyle
= TBSTYLE_CHECK
;
1006 button
.fsStyle
= TBSTYLE_BUTTON
;
1009 case wxITEM_DROPDOWN
:
1010 button
.fsStyle
= TBSTYLE_DROPDOWN
;
1014 wxFAIL_MSG( _T("unexpected toolbar button kind") );
1015 button
.fsStyle
= TBSTYLE_BUTTON
;
1023 lastWasRadio
= isRadio
;
1028 if ( !::SendMessage(GetHwnd(), TB_ADDBUTTONS
, (WPARAM
)i
, (LPARAM
)buttons
) )
1030 wxLogLastError(wxT("TB_ADDBUTTONS"));
1035 // Deal with the controls finally
1036 // ------------------------------
1038 // adjust the controls size to fit nicely in the toolbar
1041 for ( node
= m_tools
.GetFirst(); node
; node
= node
->GetNext(), index
++ )
1043 wxToolBarTool
*tool
= (wxToolBarTool
*)node
->GetData();
1045 // we calculate the running y coord for vertical toolbars so we need to
1046 // get the items size for all items but for the horizontal ones we
1047 // don't need to deal with the non controls
1048 bool isControl
= tool
->IsControl();
1049 if ( !isControl
&& !IsVertical() )
1052 const RECT r
= wxGetTBItemRect(GetHwnd(), index
);
1055 // can only be control if isVertical
1056 y
+= r
.bottom
- r
.top
;
1061 wxControl
*control
= tool
->GetControl();
1062 wxStaticText
* const staticText
= tool
->GetStaticText();
1064 wxSize size
= control
->GetSize();
1065 wxSize staticTextSize
;
1068 staticTextSize
= staticText
->GetSize();
1069 staticTextSize
.y
+= 3; // margin between control and its label
1072 // the position of the leftmost controls corner
1073 int left
= wxDefaultCoord
;
1075 // TB_SETBUTTONINFO message is only supported by comctl32.dll 4.71+
1076 #ifdef TB_SETBUTTONINFO
1077 // available in headers, now check whether it is available now
1078 // (during run-time)
1079 if ( wxApp::GetComCtl32Version() >= 471 )
1081 // set the (underlying) separators width to be that of the
1084 tbbi
.cbSize
= sizeof(tbbi
);
1085 tbbi
.dwMask
= TBIF_SIZE
;
1086 tbbi
.cx
= (WORD
)size
.x
;
1087 if ( !::SendMessage(GetHwnd(), TB_SETBUTTONINFO
,
1088 tool
->GetId(), (LPARAM
)&tbbi
) )
1090 // the id is probably invalid?
1091 wxLogLastError(wxT("TB_SETBUTTONINFO"));
1095 #endif // comctl32.dll 4.71
1096 // TB_SETBUTTONINFO unavailable
1098 // try adding several separators to fit the controls width
1099 int widthSep
= r
.right
- r
.left
;
1105 tbb
.fsState
= TBSTATE_ENABLED
;
1106 tbb
.fsStyle
= TBSTYLE_SEP
;
1108 size_t nSeparators
= size
.x
/ widthSep
;
1109 for ( size_t nSep
= 0; nSep
< nSeparators
; nSep
++ )
1111 if ( !::SendMessage(GetHwnd(), TB_INSERTBUTTON
,
1112 index
, (LPARAM
)&tbb
) )
1114 wxLogLastError(wxT("TB_INSERTBUTTON"));
1120 // remember the number of separators we used - we'd have to
1121 // delete all of them later
1122 ((wxToolBarTool
*)tool
)->SetSeparatorsCount(nSeparators
);
1124 // adjust the controls width to exactly cover the separators
1125 size
.x
= (nSeparators
+ 1)*widthSep
;
1126 control
->SetSize(size
.x
, wxDefaultCoord
);
1129 // position the control itself correctly vertically centering it on the
1130 // icon area of the toolbar
1131 int height
= r
.bottom
- r
.top
- staticTextSize
.y
;
1133 int diff
= height
- size
.y
;
1134 if ( diff
< 0 || !HasFlag(wxTB_TEXT
) )
1136 // not enough room for the static text
1140 // recalculate height & diff without the staticText control
1141 height
= r
.bottom
- r
.top
;
1142 diff
= height
- size
.y
;
1145 // the control is too high, resize to fit
1146 control
->SetSize(wxDefaultCoord
, height
- 2);
1151 else // enough space for both the control and the label
1163 y
+= height
+ 2 * GetMargins().y
;
1165 else // horizontal toolbar
1167 if ( left
== wxDefaultCoord
)
1173 control
->Move(left
, top
+ (diff
+ 1) / 2);
1176 staticText
->Move(left
+ (size
.x
- staticTextSize
.x
)/2,
1177 r
.bottom
- staticTextSize
.y
);
1181 // the max index is the "real" number of buttons - i.e. counting even the
1182 // separators which we added just for aligning the controls
1185 if ( !IsVertical() )
1187 if ( m_maxRows
== 0 )
1188 // if not set yet, only one row
1191 else if ( m_nButtons
> 0 ) // vertical non empty toolbar
1193 // if not set yet, have one column
1195 SetRows(m_nButtons
);
1198 InvalidateBestSize();
1204 // ----------------------------------------------------------------------------
1206 // ----------------------------------------------------------------------------
1208 bool wxToolBar::MSWCommand(WXUINT
WXUNUSED(cmd
), WXWORD id_
)
1210 // cast to signed is important as we compare this id with (signed) ints in
1211 // FindById() and without the cast we'd get a positive int from a
1212 // "negative" (i.e. > 32767) WORD
1213 const int id
= (signed short)id_
;
1215 wxToolBarToolBase
*tool
= FindById(id
);
1219 bool toggled
= false; // just to suppress warnings
1221 LRESULT state
= ::SendMessage(GetHwnd(), TB_GETSTATE
, id
, 0);
1223 if ( tool
->CanBeToggled() )
1225 toggled
= (state
& TBSTATE_CHECKED
) != 0;
1227 // ignore the event when a radio button is released, as this doesn't
1228 // seem to happen at all, and is handled otherwise
1229 if ( tool
->GetKind() == wxITEM_RADIO
&& !toggled
)
1232 tool
->Toggle(toggled
);
1233 UnToggleRadioGroup(tool
);
1236 // Without the two lines of code below, if the toolbar was repainted during
1237 // OnLeftClick(), then it could end up without the tool bitmap temporarily
1238 // (see http://lists.nongnu.org/archive/html/lmi/2008-10/msg00014.html).
1239 // The Update() call bellow ensures that this won't happen, by repainting
1240 // invalidated areas of the toolbar immediately.
1242 // To complicate matters, the tool would be drawn in depressed state (this
1243 // code is called when mouse button is released, not pressed). That's not
1244 // ideal, having the tool pressed for the duration of OnLeftClick()
1245 // provides the user with useful visual clue that the app is busy reacting
1246 // to the event. So we manually put the tool into pressed state, handle the
1247 // event and then finally restore tool's original state.
1248 ::SendMessage(GetHwnd(), TB_SETSTATE
, id
, MAKELONG(state
| TBSTATE_PRESSED
, 0));
1251 bool allowLeftClick
= OnLeftClick(id
, toggled
);
1253 // restore the unpressed state
1254 ::SendMessage(GetHwnd(), TB_SETSTATE
, id
, MAKELONG(state
, 0));
1256 // OnLeftClick() can veto the button state change - for buttons which
1257 // may be toggled only, of couse
1258 if ( !allowLeftClick
&& tool
->CanBeToggled() )
1261 tool
->Toggle(!toggled
);
1263 ::SendMessage(GetHwnd(), TB_CHECKBUTTON
, id
, MAKELONG(!toggled
, 0));
1269 bool wxToolBar::MSWOnNotify(int WXUNUSED(idCtrl
),
1271 WXLPARAM
*WXUNUSED(result
))
1273 LPNMHDR hdr
= (LPNMHDR
)lParam
;
1274 if ( hdr
->code
== TBN_DROPDOWN
)
1276 LPNMTOOLBAR tbhdr
= (LPNMTOOLBAR
)lParam
;
1278 wxCommandEvent
evt(wxEVT_COMMAND_TOOL_DROPDOWN_CLICKED
, tbhdr
->iItem
);
1279 if ( HandleWindowEvent(evt
) )
1281 // Event got handled, don't display default popup menu
1285 const wxToolBarToolBase
* const tool
= FindById(tbhdr
->iItem
);
1286 wxCHECK_MSG( tool
, false, _T("drop down message for unknown tool") );
1288 wxMenu
* const menu
= tool
->GetDropdownMenu();
1292 // Display popup menu below button
1293 const RECT r
= wxGetTBItemRect(GetHwnd(), GetToolPos(tbhdr
->iItem
));
1295 PopupMenu(menu
, r
.left
, r
.bottom
);
1301 if( !HasFlag(wxTB_NO_TOOLTIPS
) )
1304 // First check if this applies to us
1306 // the tooltips control created by the toolbar is sometimes Unicode, even
1307 // in an ANSI application - this seems to be a bug in comctl32.dll v5
1308 UINT code
= hdr
->code
;
1309 if ( (code
!= (UINT
) TTN_NEEDTEXTA
) && (code
!= (UINT
) TTN_NEEDTEXTW
) )
1312 HWND toolTipWnd
= (HWND
)::SendMessage(GetHwnd(), TB_GETTOOLTIPS
, 0, 0);
1313 if ( toolTipWnd
!= hdr
->hwndFrom
)
1316 LPTOOLTIPTEXT ttText
= (LPTOOLTIPTEXT
)lParam
;
1317 int id
= (int)ttText
->hdr
.idFrom
;
1319 wxToolBarToolBase
*tool
= FindById(id
);
1321 return HandleTooltipNotify(code
, lParam
, tool
->GetShortHelp());
1323 wxUnusedVar(lParam
);
1330 // ----------------------------------------------------------------------------
1332 // ----------------------------------------------------------------------------
1334 void wxToolBar::SetToolBitmapSize(const wxSize
& size
)
1336 wxToolBarBase::SetToolBitmapSize(size
);
1338 ::SendMessage(GetHwnd(), TB_SETBITMAPSIZE
, 0, MAKELONG(size
.x
, size
.y
));
1341 void wxToolBar::SetRows(int nRows
)
1343 if ( nRows
== m_maxRows
)
1345 // avoid resizing the frame uselessly
1349 // TRUE in wParam means to create at least as many rows, FALSE -
1352 ::SendMessage(GetHwnd(), TB_SETROWS
,
1353 MAKEWPARAM(nRows
, !(GetWindowStyle() & wxTB_VERTICAL
)),
1361 // The button size is bigger than the bitmap size
1362 wxSize
wxToolBar::GetToolSize() const
1364 // TB_GETBUTTONSIZE is supported from version 4.70
1365 #if defined(_WIN32_IE) && (_WIN32_IE >= 0x300 ) \
1366 && !( defined(__GNUWIN32__) && !wxCHECK_W32API_VERSION( 1, 0 ) ) \
1367 && !defined (__DIGITALMARS__)
1368 if ( wxApp::GetComCtl32Version() >= 470 )
1370 DWORD dw
= ::SendMessage(GetHwnd(), TB_GETBUTTONSIZE
, 0, 0);
1372 return wxSize(LOWORD(dw
), HIWORD(dw
));
1375 #endif // comctl32.dll 4.70+
1378 return wxSize(m_defaultWidth
+ 8, m_defaultHeight
+ 7);
1383 wxToolBarToolBase
*GetItemSkippingDummySpacers(const wxToolBarToolsList
& tools
,
1386 wxToolBarToolsList::compatibility_iterator current
= tools
.GetFirst();
1388 for ( ; current
; current
= current
->GetNext() )
1391 return current
->GetData();
1393 wxToolBarTool
*tool
= (wxToolBarTool
*)current
->GetData();
1394 size_t separators
= tool
->GetSeparatorsCount();
1396 // if it is a normal button, sepcount == 0, so skip 1 item (the button)
1397 // otherwise, skip as many items as the separator count, plus the
1399 index
-= separators
? separators
+ 1 : 1;
1405 wxToolBarToolBase
*wxToolBar::FindToolForPosition(wxCoord x
, wxCoord y
) const
1410 int index
= (int)::SendMessage(GetHwnd(), TB_HITTEST
, 0, (LPARAM
)&pt
);
1412 // MBN: when the point ( x, y ) is close to the toolbar border
1413 // TB_HITTEST returns m_nButtons ( not -1 )
1414 if ( index
< 0 || (size_t)index
>= m_nButtons
)
1415 // it's a separator or there is no tool at all there
1416 return (wxToolBarToolBase
*)NULL
;
1418 // when TB_SETBUTTONINFO is available (both during compile- and run-time),
1419 // we don't use the dummy separators hack
1420 #ifdef TB_SETBUTTONINFO
1421 if ( wxApp::GetComCtl32Version() >= 471 )
1423 return m_tools
.Item((size_t)index
)->GetData();
1426 #endif // TB_SETBUTTONINFO
1428 return GetItemSkippingDummySpacers( m_tools
, (size_t) index
);
1432 void wxToolBar::UpdateSize()
1434 wxPoint pos
= GetPosition();
1435 ::SendMessage(GetHwnd(), TB_AUTOSIZE
, 0, 0);
1436 if (pos
!= GetPosition())
1439 // In case Realize is called after the initial display (IOW the programmer
1440 // may have rebuilt the toolbar) give the frame the option of resizing the
1441 // toolbar to full width again, but only if the parent is a frame and the
1442 // toolbar is managed by the frame. Otherwise assume that some other
1443 // layout mechanism is controlling the toolbar size and leave it alone.
1444 SendSizeEventToParent();
1447 // ----------------------------------------------------------------------------
1449 // ---------------------------------------------------------------------------
1451 // get the TBSTYLE of the given toolbar window
1452 long wxToolBar::GetMSWToolbarStyle() const
1454 return ::SendMessage(GetHwnd(), TB_GETSTYLE
, 0, 0L);
1457 void wxToolBar::SetWindowStyleFlag(long style
)
1459 // the style bits whose changes force us to recreate the toolbar
1460 static const long MASK_NEEDS_RECREATE
= wxTB_TEXT
| wxTB_NOICONS
;
1462 const long styleOld
= GetWindowStyle();
1464 wxToolBarBase::SetWindowStyleFlag(style
);
1466 // don't recreate an empty toolbar: not only this is unnecessary, but it is
1467 // also fatal as we'd then try to recreate the toolbar when it's just being
1469 if ( GetToolsCount() &&
1470 (style
& MASK_NEEDS_RECREATE
) != (styleOld
& MASK_NEEDS_RECREATE
) )
1472 // to remove the text labels, simply re-realizing the toolbar is enough
1473 // but I don't know of any way to add the text to an existing toolbar
1474 // other than by recreating it entirely
1479 // ----------------------------------------------------------------------------
1481 // ----------------------------------------------------------------------------
1483 void wxToolBar::DoEnableTool(wxToolBarToolBase
*tool
, bool enable
)
1485 ::SendMessage(GetHwnd(), TB_ENABLEBUTTON
,
1486 (WPARAM
)tool
->GetId(), (LPARAM
)MAKELONG(enable
, 0));
1489 void wxToolBar::DoToggleTool(wxToolBarToolBase
*tool
, bool toggle
)
1491 ::SendMessage(GetHwnd(), TB_CHECKBUTTON
,
1492 (WPARAM
)tool
->GetId(), (LPARAM
)MAKELONG(toggle
, 0));
1495 void wxToolBar::DoSetToggle(wxToolBarToolBase
*WXUNUSED(tool
), bool WXUNUSED(toggle
))
1497 // VZ: AFAIK, the button has to be created either with TBSTYLE_CHECK or
1498 // without, so we really need to delete the button and recreate it here
1499 wxFAIL_MSG( _T("not implemented") );
1502 void wxToolBar::SetToolNormalBitmap( int id
, const wxBitmap
& bitmap
)
1504 wxToolBarTool
* tool
= static_cast<wxToolBarTool
*>(FindById(id
));
1507 wxCHECK_RET( tool
->IsButton(), wxT("Can only set bitmap on button tools."));
1509 tool
->SetNormalBitmap(bitmap
);
1514 void wxToolBar::SetToolDisabledBitmap( int id
, const wxBitmap
& bitmap
)
1516 wxToolBarTool
* tool
= static_cast<wxToolBarTool
*>(FindById(id
));
1519 wxCHECK_RET( tool
->IsButton(), wxT("Can only set bitmap on button tools."));
1521 tool
->SetDisabledBitmap(bitmap
);
1526 // ----------------------------------------------------------------------------
1528 // ----------------------------------------------------------------------------
1530 // Responds to colour changes, and passes event on to children.
1531 void wxToolBar::OnSysColourChanged(wxSysColourChangedEvent
& event
)
1533 wxRGBToColour(m_backgroundColour
, ::GetSysColor(COLOR_BTNFACE
));
1535 // Remap the buttons
1538 // Relayout the toolbar
1539 int nrows
= m_maxRows
;
1540 m_maxRows
= 0; // otherwise SetRows() wouldn't do anything
1545 // let the event propagate further
1549 void wxToolBar::OnMouseEvent(wxMouseEvent
& event
)
1551 if ( event
.Leaving() )
1555 OnMouseEnter(wxID_ANY
);
1563 if ( event
.RightDown() )
1565 // find the tool under the mouse
1566 wxCoord x
= 0, y
= 0;
1567 event
.GetPosition(&x
, &y
);
1569 wxToolBarToolBase
*tool
= FindToolForPosition(x
, y
);
1570 OnRightClick(tool
? tool
->GetId() : -1, x
, y
);
1578 // This handler is required to allow the toolbar to be set to a non-default
1579 // colour: for example, when it must blend in with a notebook page.
1580 void wxToolBar::OnEraseBackground(wxEraseEvent
& event
)
1582 RECT rect
= wxGetClientRect(GetHwnd());
1584 wxDC
*dc
= event
.GetDC();
1586 wxMSWDCImpl
*impl
= (wxMSWDCImpl
*) dc
->GetImpl();
1587 HDC hdc
= GetHdcOf(*impl
);
1589 int majorVersion
, minorVersion
;
1590 wxGetOsVersion(& majorVersion
, & minorVersion
);
1593 // we may need to draw themed colour so that we appear correctly on
1594 // e.g. notebook page under XP with themes but only do it if the parent
1595 // draws themed background itself
1596 if ( !UseBgCol() && !GetParent()->UseBgCol() )
1598 wxUxThemeEngine
*theme
= wxUxThemeEngine::GetIfActive();
1602 hr
= theme
->DrawThemeParentBackground(GetHwnd(), hdc
, &rect
);
1606 // it can also return S_FALSE which seems to simply say that it
1607 // didn't draw anything but no error really occurred
1609 wxLogApiError(_T("DrawThemeParentBackground(toolbar)"), hr
);
1613 // Only draw a rebar theme on Vista, since it doesn't jive so well with XP
1614 if ( !UseBgCol() && majorVersion
>= 6 )
1616 wxUxThemeEngine
*theme
= wxUxThemeEngine::GetIfActive();
1619 wxUxThemeHandle
hTheme(this, L
"REBAR");
1622 wxRect rect
= GetClientRect();
1623 wxCopyRectToRECT(rect
, r
);
1625 HRESULT hr
= theme
->DrawThemeBackground(hTheme
, hdc
, 0, 0, & r
, NULL
);
1629 // it can also return S_FALSE which seems to simply say that it
1630 // didn't draw anything but no error really occurred
1632 wxLogApiError(_T("DrawThemeParentBackground(toolbar)"), hr
);
1636 #endif // wxUSE_UXTHEME
1638 // we need to always draw our background under XP, as otherwise it doesn't
1639 // appear correctly with some themes (e.g. Zune one)
1640 if ( majorVersion
== 5 ||
1641 UseBgCol() || (GetMSWToolbarStyle() & TBSTYLE_TRANSPARENT
) )
1643 // do draw our background
1645 // notice that this 'dumb' implementation may cause flicker for some of
1646 // the controls in which case they should intercept wxEraseEvent and
1647 // process it themselves somehow
1648 AutoHBRUSH
hBrush(wxColourToRGB(GetBackgroundColour()));
1650 wxCHANGE_HDC_MAP_MODE(hdc
, MM_TEXT
);
1651 ::FillRect(hdc
, &rect
, hBrush
);
1653 else // we have no non default background colour
1655 // let the system do it for us
1660 bool wxToolBar::HandleSize(WXWPARAM
WXUNUSED(wParam
), WXLPARAM lParam
)
1662 // wait until we have some tools
1663 if ( !GetToolsCount() )
1666 // calculate our minor dimension ourselves - we're confusing the standard
1667 // logic (TB_AUTOSIZE) with our horizontal toolbars and other hacks
1668 const RECT r
= wxGetTBItemRect(GetHwnd(), 0);
1676 w
= r
.right
- r
.left
;
1679 w
*= (m_nButtons
+ m_maxRows
- 1)/m_maxRows
;
1686 if (HasFlag( wxTB_FLAT
))
1687 h
= r
.bottom
- r
.top
- 3;
1689 h
= r
.bottom
- r
.top
;
1692 // FIXME: hardcoded separator line height...
1693 h
+= HasFlag(wxTB_NODIVIDER
) ? 4 : 6;
1698 if ( MAKELPARAM(w
, h
) != lParam
)
1700 // size really changed
1704 // message processed
1708 bool wxToolBar::HandlePaint(WXWPARAM wParam
, WXLPARAM lParam
)
1710 // erase any dummy separators which were used
1711 // for aligning the controls if any here
1713 // first of all, are there any controls at all?
1714 wxToolBarToolsList::compatibility_iterator node
;
1715 for ( node
= m_tools
.GetFirst(); node
; node
= node
->GetNext() )
1717 if ( node
->GetData()->IsControl() )
1722 // no controls, nothing to erase
1725 wxSize clientSize
= GetClientSize();
1726 int majorVersion
, minorVersion
;
1727 wxGetOsVersion(& majorVersion
, & minorVersion
);
1729 // prepare the DC on which we'll be drawing
1730 wxClientDC
dc(this);
1731 dc
.SetBrush(wxBrush(GetBackgroundColour(), wxSOLID
));
1732 dc
.SetPen(*wxTRANSPARENT_PEN
);
1735 if ( !::GetUpdateRect(GetHwnd(), &r
, FALSE
) )
1736 // nothing to redraw anyhow
1740 wxCopyRECTToRect(r
, rectUpdate
);
1742 dc
.SetClippingRegion(rectUpdate
);
1744 // draw the toolbar tools, separators &c normally
1745 wxControl::MSWWindowProc(WM_PAINT
, wParam
, lParam
);
1747 // for each control in the toolbar find all the separators intersecting it
1750 // NB: this is really the only way to do it as we don't know if a separator
1751 // corresponds to a control (i.e. is a dummy one) or a real one
1753 for ( node
= m_tools
.GetFirst(); node
; node
= node
->GetNext() )
1755 wxToolBarTool
*tool
= (wxToolBarTool
*)node
->GetData();
1756 if ( tool
->IsControl() )
1758 // get the control rect in our client coords
1759 wxControl
*control
= tool
->GetControl();
1760 wxStaticText
*staticText
= tool
->GetStaticText();
1761 wxRect rectCtrl
= control
->GetRect();
1762 wxRect
rectStaticText(0,0,0,0);
1765 rectStaticText
= staticText
->GetRect();
1768 // iterate over all buttons
1770 int count
= ::SendMessage(GetHwnd(), TB_BUTTONCOUNT
, 0, 0);
1771 for ( int n
= 0; n
< count
; n
++ )
1773 // is it a separator?
1774 if ( !::SendMessage(GetHwnd(), TB_GETBUTTON
,
1777 wxLogDebug(_T("TB_GETBUTTON failed?"));
1782 if ( tbb
.fsStyle
!= TBSTYLE_SEP
)
1785 // get the bounding rect of the separator
1786 RECT r
= wxGetTBItemRect(GetHwnd(), n
);
1790 // does it intersect the control?
1792 wxCopyRECTToRect(r
, rectItem
);
1793 if ( rectCtrl
.Intersects(rectItem
) || (staticText
&& rectStaticText
.Intersects(rectItem
)))
1795 // yes, do erase it!
1797 bool haveRefreshed
= false;
1800 if ( !UseBgCol() && !GetParent()->UseBgCol() )
1802 // Don't use DrawThemeBackground
1804 else if ( !UseBgCol() && majorVersion
>= 6 )
1806 wxUxThemeEngine
*theme
= wxUxThemeEngine::GetIfActive();
1809 wxUxThemeHandle
hTheme(this, L
"REBAR");
1813 // Draw the whole background since the pattern may be position sensitive;
1814 // but clip it to the area of interest.
1816 r
.right
= clientSize
.x
;
1818 r
.bottom
= clientSize
.y
;
1820 wxMSWDCImpl
*impl
= (wxMSWDCImpl
*) dc
.GetImpl();
1821 HRESULT hr
= theme
->DrawThemeBackground(hTheme
, GetHdcOf(*impl
), 0, 0, & r
, & clipRect
);
1823 haveRefreshed
= true;
1829 dc
.DrawRectangle(rectItem
);
1832 if ( rectCtrl
.Intersects(rectItem
) )
1834 // Necessary in case we use a no-paint-on-size
1835 // style in the parent: the controls can disappear
1836 control
->Refresh(false);
1839 if ( staticText
&& rectStaticText
.Intersects(rectItem
) )
1841 // Necessary in case we use a no-paint-on-size
1842 // style in the parent: the controls can disappear
1843 staticText
->Refresh(false);
1852 void wxToolBar::HandleMouseMove(WXWPARAM
WXUNUSED(wParam
), WXLPARAM lParam
)
1854 wxCoord x
= GET_X_LPARAM(lParam
),
1855 y
= GET_Y_LPARAM(lParam
);
1856 wxToolBarToolBase
* tool
= FindToolForPosition( x
, y
);
1858 // has the current tool changed?
1859 if ( tool
!= m_pInTool
)
1862 OnMouseEnter(tool
? tool
->GetId() : wxID_ANY
);
1866 WXLRESULT
wxToolBar::MSWWindowProc(WXUINT nMsg
, WXWPARAM wParam
, WXLPARAM lParam
)
1871 // we don't handle mouse moves, so always pass the message to
1872 // wxControl::MSWWindowProc (HandleMouseMove just calls OnMouseEnter)
1873 HandleMouseMove(wParam
, lParam
);
1877 if ( HandleSize(wParam
, lParam
) )
1883 // refreshing the controls in the toolbar inside a composite window
1884 // results in an endless stream of WM_PAINT messages -- and seems
1885 // to be unnecessary anyhow as everything works just fine without
1886 // any special workarounds in this case
1887 if ( !IsDoubleBuffered() && HandlePaint(wParam
, lParam
) )
1890 #endif // __WXWINCE__
1893 return wxControl::MSWWindowProc(nMsg
, wParam
, lParam
);
1896 // ----------------------------------------------------------------------------
1897 // private functions
1898 // ----------------------------------------------------------------------------
1900 #ifdef wxREMAP_BUTTON_COLOURS
1902 WXHBITMAP
wxToolBar::MapBitmap(WXHBITMAP bitmap
, int width
, int height
)
1908 wxLogLastError(_T("CreateCompatibleDC"));
1913 SelectInHDC
bmpInHDC(hdcMem
, (HBITMAP
)bitmap
);
1917 wxLogLastError(_T("SelectObject"));
1922 wxCOLORMAP
*cmap
= wxGetStdColourMap();
1924 for ( int i
= 0; i
< width
; i
++ )
1926 for ( int j
= 0; j
< height
; j
++ )
1928 COLORREF pixel
= ::GetPixel(hdcMem
, i
, j
);
1930 for ( size_t k
= 0; k
< wxSTD_COL_MAX
; k
++ )
1932 COLORREF col
= cmap
[k
].from
;
1933 if ( abs(GetRValue(pixel
) - GetRValue(col
)) < 10 &&
1934 abs(GetGValue(pixel
) - GetGValue(col
)) < 10 &&
1935 abs(GetBValue(pixel
) - GetBValue(col
)) < 10 )
1937 if ( cmap
[k
].to
!= pixel
)
1938 ::SetPixel(hdcMem
, i
, j
, cmap
[k
].to
);
1948 #endif // wxREMAP_BUTTON_COLOURS
1950 #endif // wxUSE_TOOLBAR