1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/msw/tbar95.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"
48 #include "wx/msw/private.h"
51 #include "wx/msw/uxtheme.h"
54 // this define controls whether the code for button colours remapping (only
55 // useful for 16 or 256 colour images) is active at all, it's always turned off
56 // for CE where it doesn't compile (and is probably not needed anyhow) and may
57 // also be turned off for other systems if you always use 24bpp images and so
60 #define wxREMAP_BUTTON_COLOURS
61 #endif // !__WXWINCE__
63 // ----------------------------------------------------------------------------
65 // ----------------------------------------------------------------------------
67 // these standard constants are not always defined in compilers headers
71 #define TBSTYLE_LIST 0x1000
72 #define TBSTYLE_FLAT 0x0800
75 #ifndef TBSTYLE_TRANSPARENT
76 #define TBSTYLE_TRANSPARENT 0x8000
79 #ifndef TBSTYLE_TOOLTIPS
80 #define TBSTYLE_TOOLTIPS 0x0100
85 #define TB_SETSTYLE (WM_USER + 56)
86 #define TB_GETSTYLE (WM_USER + 57)
90 #define TB_HITTEST (WM_USER + 69)
94 #define TB_GETMAXSIZE (WM_USER + 83)
97 // these values correspond to those used by comctl32.dll
98 #define DEFAULTBITMAPX 16
99 #define DEFAULTBITMAPY 15
101 // ----------------------------------------------------------------------------
103 // ----------------------------------------------------------------------------
105 IMPLEMENT_DYNAMIC_CLASS(wxToolBar
, wxControl
)
117 style ( wxNO_BORDER | wxTB_HORIZONTAL)
126 BEGIN_EVENT_TABLE(wxToolBar
, wxToolBarBase
)
127 EVT_MOUSE_EVENTS(wxToolBar::OnMouseEvent
)
128 EVT_SYS_COLOUR_CHANGED(wxToolBar::OnSysColourChanged
)
129 EVT_ERASE_BACKGROUND(wxToolBar::OnEraseBackground
)
132 // ----------------------------------------------------------------------------
134 // ----------------------------------------------------------------------------
136 class wxToolBarTool
: public wxToolBarToolBase
139 wxToolBarTool(wxToolBar
*tbar
,
141 const wxString
& label
,
142 const wxBitmap
& bmpNormal
,
143 const wxBitmap
& bmpDisabled
,
145 wxObject
*clientData
,
146 const wxString
& shortHelp
,
147 const wxString
& longHelp
)
148 : wxToolBarToolBase(tbar
, id
, label
, bmpNormal
, bmpDisabled
, kind
,
149 clientData
, shortHelp
, longHelp
)
155 wxToolBarTool(wxToolBar
*tbar
, wxControl
*control
, const wxString
& label
)
156 : wxToolBarToolBase(tbar
, control
, label
)
158 if ( IsControl() && !m_label
.empty() )
160 // create a control to render the control's label
161 m_staticText
= new wxStaticText
168 wxALIGN_CENTRE
| wxST_NO_AUTORESIZE
179 virtual ~wxToolBarTool()
184 virtual void SetLabel(const wxString
& label
)
186 if ( label
== m_label
)
189 wxToolBarToolBase::SetLabel(label
);
192 m_staticText
->SetLabel(label
);
194 // we need to update the label shown in the toolbar because it has a
195 // pointer to the internal buffer of the old label
197 // TODO: use TB_SETBUTTONINFO
200 wxStaticText
* GetStaticText()
202 wxASSERT_MSG( IsControl(),
203 _T("only makes sense for embedded control tools") );
208 // set/get the number of separators which we use to cover the space used by
209 // a control in the toolbar
210 void SetSeparatorsCount(size_t count
) { m_nSepCount
= count
; }
211 size_t GetSeparatorsCount() const { return m_nSepCount
; }
215 wxStaticText
*m_staticText
;
217 DECLARE_NO_COPY_CLASS(wxToolBarTool
)
220 // ============================================================================
222 // ============================================================================
224 // ----------------------------------------------------------------------------
226 // ----------------------------------------------------------------------------
228 wxToolBarToolBase
*wxToolBar::CreateTool(int id
,
229 const wxString
& label
,
230 const wxBitmap
& bmpNormal
,
231 const wxBitmap
& bmpDisabled
,
233 wxObject
*clientData
,
234 const wxString
& shortHelp
,
235 const wxString
& longHelp
)
237 return new wxToolBarTool(this, id
, label
, bmpNormal
, bmpDisabled
, kind
,
238 clientData
, shortHelp
, longHelp
);
242 wxToolBar::CreateTool(wxControl
*control
, const wxString
& label
)
244 return new wxToolBarTool(this, control
, label
);
247 // ----------------------------------------------------------------------------
248 // wxToolBar construction
249 // ----------------------------------------------------------------------------
251 void wxToolBar::Init()
254 m_disabledImgList
= NULL
;
258 m_defaultWidth
= DEFAULTBITMAPX
;
259 m_defaultHeight
= DEFAULTBITMAPY
;
264 bool wxToolBar::Create(wxWindow
*parent
,
269 const wxString
& name
)
271 // common initialisation
272 if ( !CreateControl(parent
, id
, pos
, size
, style
, wxDefaultValidator
, name
) )
277 // MSW-specific initialisation
278 if ( !MSWCreateToolbar(pos
, size
) )
281 wxSetCCUnicodeFormat(GetHwnd());
283 // workaround for flat toolbar on Windows XP classic style: we have to set
284 // the style after creating the control; doing it at creation time doesn't work
286 if ( style
& wxTB_FLAT
)
288 LRESULT style
= GetMSWToolbarStyle();
290 if ( !(style
& TBSTYLE_FLAT
) )
291 ::SendMessage(GetHwnd(), TB_SETSTYLE
, 0, style
| TBSTYLE_FLAT
);
293 #endif // wxUSE_UXTHEME
298 bool wxToolBar::MSWCreateToolbar(const wxPoint
& pos
, const wxSize
& size
)
300 if ( !MSWCreateControl(TOOLBARCLASSNAME
, wxEmptyString
, pos
, size
) )
303 // toolbar-specific post initialisation
304 ::SendMessage(GetHwnd(), TB_BUTTONSTRUCTSIZE
, sizeof(TBBUTTON
), 0);
306 #ifdef TB_SETEXTENDEDSTYLE
307 if ( wxApp::GetComCtl32Version() >= 471 )
308 ::SendMessage(GetHwnd(), TB_SETEXTENDEDSTYLE
, 0, TBSTYLE_EX_DRAWDDARROWS
);
311 // Fix a bug on e.g. the Silver theme on WinXP where control backgrounds
312 // are incorrectly drawn, by forcing the background to a specific colour.
313 int majorVersion
, minorVersion
;
314 wxGetOsVersion(& majorVersion
, & minorVersion
);
315 if (majorVersion
< 6)
316 SetBackgroundColour(GetBackgroundColour());
321 void wxToolBar::Recreate()
323 const HWND hwndOld
= GetHwnd();
326 // we haven't been created yet, no need to recreate
330 // get the position and size before unsubclassing the old toolbar
331 const wxPoint pos
= GetPosition();
332 const wxSize size
= GetSize();
336 if ( !MSWCreateToolbar(pos
, size
) )
339 wxFAIL_MSG( _T("recreating the toolbar failed") );
344 // reparent all our children under the new toolbar
345 for ( wxWindowList::compatibility_iterator node
= m_children
.GetFirst();
347 node
= node
->GetNext() )
349 wxWindow
*win
= node
->GetData();
350 if ( !win
->IsTopLevel() )
351 ::SetParent(GetHwndOf(win
), GetHwnd());
354 // only destroy the old toolbar now --
355 // after all the children had been reparented
356 ::DestroyWindow(hwndOld
);
358 // it is for the old bitmap control and can't be used with the new one
361 ::DeleteObject((HBITMAP
) m_hBitmap
);
365 if ( m_disabledImgList
)
367 delete m_disabledImgList
;
368 m_disabledImgList
= NULL
;
374 wxToolBar::~wxToolBar()
376 // we must refresh the frame size when the toolbar is deleted but the frame
377 // is not - otherwise toolbar leaves a hole in the place it used to occupy
378 wxFrame
*frame
= wxDynamicCast(GetParent(), wxFrame
);
379 if ( frame
&& !frame
->IsBeingDeleted() )
380 frame
->SendSizeEvent();
383 ::DeleteObject((HBITMAP
) m_hBitmap
);
385 delete m_disabledImgList
;
388 wxSize
wxToolBar::DoGetBestSize() const
393 if ( !::SendMessage(GetHwnd(), TB_GETMAXSIZE
, 0, (LPARAM
)&size
) )
395 // maybe an old (< 0x400) Windows version? try to approximate the
396 // toolbar size ourselves
397 sizeBest
= GetToolSize();
398 sizeBest
.y
+= 2 * ::GetSystemMetrics(SM_CYBORDER
); // Add borders
399 sizeBest
.x
*= GetToolsCount();
401 // reverse horz and vertical components if necessary
405 sizeBest
.x
= sizeBest
.y
;
411 sizeBest
.x
= size
.cx
;
412 sizeBest
.y
= size
.cy
;
417 // Without the extra height, DoGetBestSize can report a size that's
418 // smaller than the actual window, causing windows to overlap slightly
419 // in some circumstances, leading to missing borders (especially noticeable
421 if (!(GetWindowStyle() & wxTB_NODIVIDER
))
426 CacheBestSize(sizeBest
);
431 WXDWORD
wxToolBar::MSWGetStyle(long style
, WXDWORD
*exstyle
) const
433 // toolbars never have border, giving one to them results in broken
435 WXDWORD msStyle
= wxControl::MSWGetStyle
437 (style
& ~wxBORDER_MASK
) | wxBORDER_NONE
, exstyle
440 if ( !(style
& wxTB_NO_TOOLTIPS
) )
441 msStyle
|= TBSTYLE_TOOLTIPS
;
443 if ( style
& (wxTB_FLAT
| wxTB_HORZ_LAYOUT
) )
445 // static as it doesn't change during the program lifetime
446 static const int s_verComCtl
= wxApp::GetComCtl32Version();
448 // comctl32.dll 4.00 doesn't support the flat toolbars and using this
449 // style with 6.00 (part of Windows XP) leads to the toolbar with
450 // incorrect background colour - and not using it still results in the
451 // correct (flat) toolbar, so don't use it there
452 if ( s_verComCtl
> 400 && s_verComCtl
< 600 )
453 msStyle
|= TBSTYLE_FLAT
| TBSTYLE_TRANSPARENT
;
455 if ( s_verComCtl
>= 470 && style
& wxTB_HORZ_LAYOUT
)
456 msStyle
|= TBSTYLE_LIST
;
459 if ( style
& wxTB_NODIVIDER
)
460 msStyle
|= CCS_NODIVIDER
;
462 if ( style
& wxTB_NOALIGN
)
463 msStyle
|= CCS_NOPARENTALIGN
;
465 if ( style
& wxTB_VERTICAL
)
468 if( style
& wxTB_BOTTOM
)
469 msStyle
|= CCS_BOTTOM
;
471 if ( style
& wxTB_RIGHT
)
472 msStyle
|= CCS_RIGHT
;
477 // ----------------------------------------------------------------------------
478 // adding/removing tools
479 // ----------------------------------------------------------------------------
481 bool wxToolBar::DoInsertTool(size_t WXUNUSED(pos
), wxToolBarToolBase
*tool
)
483 // nothing special to do here - we really create the toolbar buttons in
487 InvalidateBestSize();
491 bool wxToolBar::DoDeleteTool(size_t pos
, wxToolBarToolBase
*tool
)
493 // the main difficulty we have here is with the controls in the toolbars:
494 // as we (sometimes) use several separators to cover up the space used by
495 // them, the indices are not the same for us and the toolbar
497 // first determine the position of the first button to delete: it may be
498 // different from pos if we use several separators to cover the space used
500 wxToolBarToolsList::compatibility_iterator node
;
501 for ( node
= m_tools
.GetFirst(); node
; node
= node
->GetNext() )
503 wxToolBarToolBase
*tool2
= node
->GetData();
506 // let node point to the next node in the list
507 node
= node
->GetNext();
512 if ( tool2
->IsControl() )
513 pos
+= ((wxToolBarTool
*)tool2
)->GetSeparatorsCount() - 1;
516 // now determine the number of buttons to delete and the area taken by them
517 size_t nButtonsToDelete
= 1;
519 // get the size of the button we're going to delete
521 if ( !::SendMessage(GetHwnd(), TB_GETITEMRECT
, pos
, (LPARAM
)&r
) )
523 wxLogLastError(_T("TB_GETITEMRECT"));
526 int width
= r
.right
- r
.left
;
528 if ( tool
->IsControl() )
530 nButtonsToDelete
= ((wxToolBarTool
*)tool
)->GetSeparatorsCount();
531 width
*= nButtonsToDelete
;
532 tool
->GetControl()->Destroy();
535 // do delete all buttons
536 m_nButtons
-= nButtonsToDelete
;
537 while ( nButtonsToDelete
-- > 0 )
539 if ( !::SendMessage(GetHwnd(), TB_DELETEBUTTON
, pos
, 0) )
541 wxLogLastError(wxT("TB_DELETEBUTTON"));
549 // and finally reposition all the controls after this button (the toolbar
550 // takes care of all normal items)
551 for ( /* node -> first after deleted */ ; node
; node
= node
->GetNext() )
553 wxToolBarTool
*tool2
= (wxToolBarTool
*)node
->GetData();
554 if ( tool2
->IsControl() )
557 wxControl
*control
= tool2
->GetControl();
558 control
->GetPosition(&x
, NULL
);
559 control
->Move(x
- width
, wxDefaultCoord
);
561 wxStaticText
* staticText
= tool2
->GetStaticText();
562 staticText
->Move(x
- width
, wxDefaultCoord
);
566 InvalidateBestSize();
571 void wxToolBar::CreateDisabledImageList()
573 if (m_disabledImgList
!= NULL
)
575 delete m_disabledImgList
;
576 m_disabledImgList
= NULL
;
579 // as we can't use disabled image list with older versions of comctl32.dll,
580 // don't even bother creating it
581 if ( wxApp::GetComCtl32Version() >= 470 )
583 // search for the first disabled button img in the toolbar, if any
584 for ( wxToolBarToolsList::compatibility_iterator
585 node
= m_tools
.GetFirst(); node
; node
= node
->GetNext() )
587 wxToolBarToolBase
*tool
= node
->GetData();
588 wxBitmap bmpDisabled
= tool
->GetDisabledBitmap();
589 if ( bmpDisabled
.Ok() )
591 m_disabledImgList
= new wxImageList
595 bmpDisabled
.GetMask() != NULL
,
602 // we don't have any disabled bitmaps
606 bool wxToolBar::Realize()
608 const size_t nTools
= GetToolsCount();
613 #ifdef wxREMAP_BUTTON_COLOURS
614 // don't change the values of these constants, they can be set from the
615 // user code via wxSystemOptions
624 // the user-specified option overrides anything, but if it wasn't set, only
625 // remap the buttons on 8bpp displays as otherwise the bitmaps usually look
626 // much worse after remapping
627 static const wxChar
*remapOption
= wxT("msw.remap");
628 const int remapValue
= wxSystemOptions::HasOption(remapOption
)
629 ? wxSystemOptions::GetOptionInt(remapOption
)
630 : wxDisplayDepth() <= 8 ? Remap_Buttons
633 #endif // wxREMAP_BUTTON_COLOURS
635 // delete all old buttons, if any
636 for ( size_t pos
= 0; pos
< m_nButtons
; pos
++ )
638 if ( !::SendMessage(GetHwnd(), TB_DELETEBUTTON
, 0, 0) )
640 wxLogDebug(wxT("TB_DELETEBUTTON failed"));
644 // First, add the bitmap: we use one bitmap for all toolbar buttons
645 // ----------------------------------------------------------------
647 wxToolBarToolsList::compatibility_iterator node
;
651 if ( HasFlag(wxTB_NOICONS
) )
653 // no icons, don't leave space for them
657 else // do show icons
659 // if we already have a bitmap, we'll replace the existing one --
660 // otherwise we'll install a new one
661 HBITMAP oldToolBarBitmap
= (HBITMAP
)m_hBitmap
;
663 sizeBmp
.x
= m_defaultWidth
;
664 sizeBmp
.y
= m_defaultHeight
;
666 const wxCoord totalBitmapWidth
= m_defaultWidth
*
667 wx_truncate_cast(wxCoord
, nTools
),
668 totalBitmapHeight
= m_defaultHeight
;
670 // Create a bitmap and copy all the tool bitmaps into it
671 wxMemoryDC dcAllButtons
;
672 wxBitmap
bitmap(totalBitmapWidth
, totalBitmapHeight
);
673 dcAllButtons
.SelectObject(bitmap
);
675 #ifdef wxREMAP_BUTTON_COLOURS
676 if ( remapValue
!= Remap_TransparentBg
)
677 #endif // wxREMAP_BUTTON_COLOURS
679 // VZ: why do we hardcode grey colour for CE?
680 dcAllButtons
.SetBackground(wxBrush(
682 wxColour(0xc0, 0xc0, 0xc0)
683 #else // !__WXWINCE__
684 GetBackgroundColour()
685 #endif // __WXWINCE__/!__WXWINCE__
687 dcAllButtons
.Clear();
690 m_hBitmap
= bitmap
.GetHBITMAP();
691 HBITMAP hBitmap
= (HBITMAP
)m_hBitmap
;
693 #ifdef wxREMAP_BUTTON_COLOURS
694 if ( remapValue
== Remap_Bg
)
696 dcAllButtons
.SelectObject(wxNullBitmap
);
698 // Even if we're not remapping the bitmap
699 // content, we still have to remap the background.
700 hBitmap
= (HBITMAP
)MapBitmap((WXHBITMAP
) hBitmap
,
701 totalBitmapWidth
, totalBitmapHeight
);
703 dcAllButtons
.SelectObject(bitmap
);
705 #endif // wxREMAP_BUTTON_COLOURS
707 // the button position
710 // the number of buttons (not separators)
713 CreateDisabledImageList();
714 for ( node
= m_tools
.GetFirst(); node
; node
= node
->GetNext() )
716 wxToolBarToolBase
*tool
= node
->GetData();
717 if ( tool
->IsButton() )
719 const wxBitmap
& bmp
= tool
->GetNormalBitmap();
721 const int w
= bmp
.GetWidth();
722 const int h
= bmp
.GetHeight();
726 int xOffset
= wxMax(0, (m_defaultWidth
- w
)/2);
727 int yOffset
= wxMax(0, (m_defaultHeight
- h
)/2);
729 // notice the last parameter: do use mask
730 dcAllButtons
.DrawBitmap(bmp
, x
+ xOffset
, yOffset
, true);
734 wxFAIL_MSG( _T("invalid tool button bitmap") );
737 // also deal with disabled bitmap if we want to use them
738 if ( m_disabledImgList
)
740 wxBitmap bmpDisabled
= tool
->GetDisabledBitmap();
741 #if wxUSE_IMAGE && wxUSE_WXDIB
742 if ( !bmpDisabled
.Ok() )
744 // no disabled bitmap specified but we still need to
745 // fill the space in the image list with something, so
746 // we grey out the normal bitmap
748 imgGreyed
= bmp
.ConvertToImage().ConvertToGreyscale();
750 #ifdef wxREMAP_BUTTON_COLOURS
751 if ( remapValue
== Remap_Buttons
)
753 // we need to have light grey background colour for
754 // MapBitmap() to work correctly
755 for ( int y
= 0; y
< h
; y
++ )
757 for ( int x
= 0; x
< w
; x
++ )
759 if ( imgGreyed
.IsTransparent(x
, y
) )
760 imgGreyed
.SetRGB(x
, y
,
762 wxLIGHT_GREY
->Green(),
763 wxLIGHT_GREY
->Blue());
767 #endif // wxREMAP_BUTTON_COLOURS
769 bmpDisabled
= wxBitmap(imgGreyed
);
771 #endif // wxUSE_IMAGE
773 #ifdef wxREMAP_BUTTON_COLOURS
774 if ( remapValue
== Remap_Buttons
)
775 MapBitmap(bmpDisabled
.GetHBITMAP(), w
, h
);
776 #endif // wxREMAP_BUTTON_COLOURS
778 m_disabledImgList
->Add(bmpDisabled
);
781 // still inc width and number of buttons because otherwise the
782 // subsequent buttons will all be shifted which is rather confusing
783 // (and like this you'd see immediately which bitmap was bad)
789 dcAllButtons
.SelectObject(wxNullBitmap
);
791 // don't delete this HBITMAP!
792 bitmap
.SetHBITMAP(0);
794 #ifdef wxREMAP_BUTTON_COLOURS
795 if ( remapValue
== Remap_Buttons
)
797 // Map to system colours
798 hBitmap
= (HBITMAP
)MapBitmap((WXHBITMAP
) hBitmap
,
799 totalBitmapWidth
, totalBitmapHeight
);
801 #endif // wxREMAP_BUTTON_COLOURS
803 bool addBitmap
= true;
805 if ( oldToolBarBitmap
)
807 #ifdef TB_REPLACEBITMAP
808 if ( wxApp::GetComCtl32Version() >= 400 )
810 TBREPLACEBITMAP replaceBitmap
;
811 replaceBitmap
.hInstOld
= NULL
;
812 replaceBitmap
.hInstNew
= NULL
;
813 replaceBitmap
.nIDOld
= (UINT
) oldToolBarBitmap
;
814 replaceBitmap
.nIDNew
= (UINT
) hBitmap
;
815 replaceBitmap
.nButtons
= nButtons
;
816 if ( !::SendMessage(GetHwnd(), TB_REPLACEBITMAP
,
817 0, (LPARAM
) &replaceBitmap
) )
819 wxFAIL_MSG(wxT("Could not replace the old bitmap"));
822 ::DeleteObject(oldToolBarBitmap
);
828 #endif // TB_REPLACEBITMAP
830 // we can't replace the old bitmap, so we will add another one
831 // (awfully inefficient, but what else to do?) and shift the bitmap
832 // indices accordingly
835 bitmapId
= m_nButtons
;
839 if ( addBitmap
) // no old bitmap or we can't replace it
841 TBADDBITMAP addBitmap
;
843 addBitmap
.nID
= (UINT
) hBitmap
;
844 if ( ::SendMessage(GetHwnd(), TB_ADDBITMAP
,
845 (WPARAM
) nButtons
, (LPARAM
)&addBitmap
) == -1 )
847 wxFAIL_MSG(wxT("Could not add bitmap to toolbar"));
851 // disable image lists are only supported in comctl32.dll 4.70+
852 if ( wxApp::GetComCtl32Version() >= 470 )
854 HIMAGELIST hil
= m_disabledImgList
855 ? GetHimagelistOf(m_disabledImgList
)
858 // notice that we set the image list even if don't have one right
859 // now as we could have it before and need to reset it in this case
860 HIMAGELIST oldImageList
= (HIMAGELIST
)
861 ::SendMessage(GetHwnd(), TB_SETDISABLEDIMAGELIST
, 0, (LPARAM
)hil
);
863 // delete previous image list if any
865 ::DeleteObject(oldImageList
);
869 // don't call SetToolBitmapSize() as we don't want to change the values of
870 // m_defaultWidth/Height
871 if ( !::SendMessage(GetHwnd(), TB_SETBITMAPSIZE
, 0,
872 MAKELONG(sizeBmp
.x
, sizeBmp
.y
)) )
874 wxLogLastError(_T("TB_SETBITMAPSIZE"));
877 // Next add the buttons and separators
878 // -----------------------------------
880 TBBUTTON
*buttons
= new TBBUTTON
[nTools
];
882 // this array will hold the indices of all controls in the toolbar
883 wxArrayInt controlIds
;
885 bool lastWasRadio
= false;
887 for ( node
= m_tools
.GetFirst(); node
; node
= node
->GetNext() )
889 wxToolBarToolBase
*tool
= node
->GetData();
891 // don't add separators to the vertical toolbar with old comctl32.dll
892 // versions as they didn't handle this properly
893 if ( IsVertical() && tool
->IsSeparator() &&
894 wxApp::GetComCtl32Version() <= 472 )
899 TBBUTTON
& button
= buttons
[i
];
901 wxZeroMemory(button
);
903 bool isRadio
= false;
904 switch ( tool
->GetStyle() )
906 case wxTOOL_STYLE_CONTROL
:
907 button
.idCommand
= tool
->GetId();
908 // fall through: create just a separator too
910 case wxTOOL_STYLE_SEPARATOR
:
911 button
.fsState
= TBSTATE_ENABLED
;
912 button
.fsStyle
= TBSTYLE_SEP
;
915 case wxTOOL_STYLE_BUTTON
:
916 if ( !HasFlag(wxTB_NOICONS
) )
917 button
.iBitmap
= bitmapId
;
919 if ( HasFlag(wxTB_TEXT
) )
921 const wxString
& label
= tool
->GetLabel();
922 if ( !label
.empty() )
923 button
.iString
= (int)label
.wx_str();
926 button
.idCommand
= tool
->GetId();
928 if ( tool
->IsEnabled() )
929 button
.fsState
|= TBSTATE_ENABLED
;
930 if ( tool
->IsToggled() )
931 button
.fsState
|= TBSTATE_CHECKED
;
933 switch ( tool
->GetKind() )
936 button
.fsStyle
= TBSTYLE_CHECKGROUP
;
940 // the first item in the radio group is checked by
941 // default to be consistent with wxGTK and the menu
943 button
.fsState
|= TBSTATE_CHECKED
;
945 if (tool
->Toggle(true))
947 DoToggleTool(tool
, true);
950 else if ( tool
->IsToggled() )
952 wxToolBarToolsList::compatibility_iterator nodePrev
= node
->GetPrevious();
953 int prevIndex
= i
- 1;
956 TBBUTTON
& prevButton
= buttons
[prevIndex
];
957 wxToolBarToolBase
*tool
= nodePrev
->GetData();
958 if ( !tool
->IsButton() || tool
->GetKind() != wxITEM_RADIO
)
961 if ( tool
->Toggle(false) )
962 DoToggleTool(tool
, false);
964 prevButton
.fsState
&= TBSTATE_CHECKED
;
965 nodePrev
= nodePrev
->GetPrevious();
974 button
.fsStyle
= TBSTYLE_CHECK
;
978 button
.fsStyle
= TBSTYLE_BUTTON
;
981 case wxITEM_DROPDOWN
:
982 button
.fsStyle
= TBSTYLE_DROPDOWN
;
986 wxFAIL_MSG( _T("unexpected toolbar button kind") );
987 button
.fsStyle
= TBSTYLE_BUTTON
;
995 lastWasRadio
= isRadio
;
1000 if ( !::SendMessage(GetHwnd(), TB_ADDBUTTONS
, (WPARAM
)i
, (LPARAM
)buttons
) )
1002 wxLogLastError(wxT("TB_ADDBUTTONS"));
1007 // Deal with the controls finally
1008 // ------------------------------
1010 // adjust the controls size to fit nicely in the toolbar
1013 for ( node
= m_tools
.GetFirst(); node
; node
= node
->GetNext(), index
++ )
1015 wxToolBarTool
*tool
= (wxToolBarTool
*)node
->GetData();
1017 // we calculate the running y coord for vertical toolbars so we need to
1018 // get the items size for all items but for the horizontal ones we
1019 // don't need to deal with the non controls
1020 bool isControl
= tool
->IsControl();
1021 if ( !isControl
&& !IsVertical() )
1024 // note that we use TB_GETITEMRECT and not TB_GETRECT because the
1025 // latter only appeared in v4.70 of comctl32.dll
1027 if ( !::SendMessage(GetHwnd(), TB_GETITEMRECT
,
1028 index
, (LPARAM
)(LPRECT
)&r
) )
1030 wxLogLastError(wxT("TB_GETITEMRECT"));
1035 // can only be control if isVertical
1036 y
+= r
.bottom
- r
.top
;
1041 wxControl
*control
= tool
->GetControl();
1042 wxStaticText
* const staticText
= tool
->GetStaticText();
1044 wxSize size
= control
->GetSize();
1045 wxSize staticTextSize
;
1048 staticTextSize
= staticText
->GetSize();
1049 staticTextSize
.y
+= 3; // margin between control and its label
1052 // the position of the leftmost controls corner
1053 int left
= wxDefaultCoord
;
1055 // TB_SETBUTTONINFO message is only supported by comctl32.dll 4.71+
1056 #ifdef TB_SETBUTTONINFO
1057 // available in headers, now check whether it is available now
1058 // (during run-time)
1059 if ( wxApp::GetComCtl32Version() >= 471 )
1061 // set the (underlying) separators width to be that of the
1064 tbbi
.cbSize
= sizeof(tbbi
);
1065 tbbi
.dwMask
= TBIF_SIZE
;
1066 tbbi
.cx
= (WORD
)size
.x
;
1067 if ( !::SendMessage(GetHwnd(), TB_SETBUTTONINFO
,
1068 tool
->GetId(), (LPARAM
)&tbbi
) )
1070 // the id is probably invalid?
1071 wxLogLastError(wxT("TB_SETBUTTONINFO"));
1075 #endif // comctl32.dll 4.71
1076 // TB_SETBUTTONINFO unavailable
1078 // try adding several separators to fit the controls width
1079 int widthSep
= r
.right
- r
.left
;
1085 tbb
.fsState
= TBSTATE_ENABLED
;
1086 tbb
.fsStyle
= TBSTYLE_SEP
;
1088 size_t nSeparators
= size
.x
/ widthSep
;
1089 for ( size_t nSep
= 0; nSep
< nSeparators
; nSep
++ )
1091 if ( !::SendMessage(GetHwnd(), TB_INSERTBUTTON
,
1092 index
, (LPARAM
)&tbb
) )
1094 wxLogLastError(wxT("TB_INSERTBUTTON"));
1100 // remember the number of separators we used - we'd have to
1101 // delete all of them later
1102 ((wxToolBarTool
*)tool
)->SetSeparatorsCount(nSeparators
);
1104 // adjust the controls width to exactly cover the separators
1105 size
.x
= (nSeparators
+ 1)*widthSep
;
1106 control
->SetSize(size
.x
, wxDefaultCoord
);
1109 // position the control itself correctly vertically centering it on the
1110 // icon area of the toolbar
1111 int height
= r
.bottom
- r
.top
- staticTextSize
.y
;
1113 int diff
= height
- size
.y
;
1114 if ( diff
< 0 || !HasFlag(wxTB_TEXT
) )
1116 // not enough room for the static text
1120 // recalculate height & diff without the staticText control
1121 height
= r
.bottom
- r
.top
;
1122 diff
= height
- size
.y
;
1125 // the control is too high, resize to fit
1126 control
->SetSize(wxDefaultCoord
, height
- 2);
1131 else // enough space for both the control and the label
1143 y
+= height
+ 2 * GetMargins().y
;
1145 else // horizontal toolbar
1147 if ( left
== wxDefaultCoord
)
1153 control
->Move(left
, top
+ (diff
+ 1) / 2);
1156 staticText
->Move(left
+ (size
.x
- staticTextSize
.x
)/2,
1157 r
.bottom
- staticTextSize
.y
);
1161 // the max index is the "real" number of buttons - i.e. counting even the
1162 // separators which we added just for aligning the controls
1165 if ( !IsVertical() )
1167 if ( m_maxRows
== 0 )
1168 // if not set yet, only one row
1171 else if ( m_nButtons
> 0 ) // vertical non empty toolbar
1173 // if not set yet, have one column
1175 SetRows(m_nButtons
);
1178 InvalidateBestSize();
1184 // ----------------------------------------------------------------------------
1186 // ----------------------------------------------------------------------------
1188 bool wxToolBar::MSWCommand(WXUINT
WXUNUSED(cmd
), WXWORD id_
)
1190 // cast to signed is important as we compare this id with (signed) ints in
1191 // FindById() and without the cast we'd get a positive int from a
1192 // "negative" (i.e. > 32767) WORD
1193 const int id
= (signed short)id_
;
1195 wxToolBarToolBase
*tool
= FindById(id
);
1199 bool toggled
= false; // just to suppress warnings
1201 if ( tool
->CanBeToggled() )
1203 LRESULT state
= ::SendMessage(GetHwnd(), TB_GETSTATE
, id
, 0);
1204 toggled
= (state
& TBSTATE_CHECKED
) != 0;
1206 // ignore the event when a radio button is released, as this doesn't
1207 // seem to happen at all, and is handled otherwise
1208 if ( tool
->GetKind() == wxITEM_RADIO
&& !toggled
)
1211 tool
->Toggle(toggled
);
1212 UnToggleRadioGroup(tool
);
1215 // OnLeftClick() can veto the button state change - for buttons which
1216 // may be toggled only, of couse
1217 if ( !OnLeftClick(id
, toggled
) && tool
->CanBeToggled() )
1220 tool
->Toggle(!toggled
);
1222 ::SendMessage(GetHwnd(), TB_CHECKBUTTON
, id
, MAKELONG(!toggled
, 0));
1228 bool wxToolBar::MSWOnNotify(int WXUNUSED(idCtrl
),
1230 WXLPARAM
*WXUNUSED(result
))
1232 LPNMHDR hdr
= (LPNMHDR
)lParam
;
1233 if ( hdr
->code
== TBN_DROPDOWN
)
1235 LPNMTOOLBAR tbhdr
= (LPNMTOOLBAR
)lParam
;
1237 wxCommandEvent
evt(wxEVT_COMMAND_TOOL_DROPDOWN_CLICKED
, tbhdr
->iItem
);
1238 if ( GetEventHandler()->ProcessEvent(evt
) )
1240 // Event got handled, don't display default popup menu
1244 const wxToolBarToolBase
* const tool
= FindById(tbhdr
->iItem
);
1245 wxCHECK_MSG( tool
, false, _T("drop down message for unknown tool") );
1247 wxMenu
* const menu
= tool
->GetDropdownMenu();
1251 // Display popup menu below button
1253 if (::SendMessage(GetHwnd(), TB_GETITEMRECT
, GetToolPos(tbhdr
->iItem
), (LPARAM
)&r
))
1254 PopupMenu(menu
, r
.left
, r
.bottom
);
1260 if( !HasFlag(wxTB_NO_TOOLTIPS
) )
1263 // First check if this applies to us
1265 // the tooltips control created by the toolbar is sometimes Unicode, even
1266 // in an ANSI application - this seems to be a bug in comctl32.dll v5
1267 UINT code
= hdr
->code
;
1268 if ( (code
!= (UINT
) TTN_NEEDTEXTA
) && (code
!= (UINT
) TTN_NEEDTEXTW
) )
1271 HWND toolTipWnd
= (HWND
)::SendMessage(GetHwnd(), TB_GETTOOLTIPS
, 0, 0);
1272 if ( toolTipWnd
!= hdr
->hwndFrom
)
1275 LPTOOLTIPTEXT ttText
= (LPTOOLTIPTEXT
)lParam
;
1276 int id
= (int)ttText
->hdr
.idFrom
;
1278 wxToolBarToolBase
*tool
= FindById(id
);
1280 return HandleTooltipNotify(code
, lParam
, tool
->GetShortHelp());
1282 wxUnusedVar(lParam
);
1289 // ----------------------------------------------------------------------------
1291 // ----------------------------------------------------------------------------
1293 void wxToolBar::SetToolBitmapSize(const wxSize
& size
)
1295 wxToolBarBase::SetToolBitmapSize(size
);
1297 ::SendMessage(GetHwnd(), TB_SETBITMAPSIZE
, 0, MAKELONG(size
.x
, size
.y
));
1300 void wxToolBar::SetRows(int nRows
)
1302 if ( nRows
== m_maxRows
)
1304 // avoid resizing the frame uselessly
1308 // TRUE in wParam means to create at least as many rows, FALSE -
1311 ::SendMessage(GetHwnd(), TB_SETROWS
,
1312 MAKEWPARAM(nRows
, !(GetWindowStyle() & wxTB_VERTICAL
)),
1320 // The button size is bigger than the bitmap size
1321 wxSize
wxToolBar::GetToolSize() const
1323 // TB_GETBUTTONSIZE is supported from version 4.70
1324 #if defined(_WIN32_IE) && (_WIN32_IE >= 0x300 ) \
1325 && !( defined(__GNUWIN32__) && !wxCHECK_W32API_VERSION( 1, 0 ) ) \
1326 && !defined (__DIGITALMARS__)
1327 if ( wxApp::GetComCtl32Version() >= 470 )
1329 DWORD dw
= ::SendMessage(GetHwnd(), TB_GETBUTTONSIZE
, 0, 0);
1331 return wxSize(LOWORD(dw
), HIWORD(dw
));
1334 #endif // comctl32.dll 4.70+
1337 return wxSize(m_defaultWidth
+ 8, m_defaultHeight
+ 7);
1342 wxToolBarToolBase
*GetItemSkippingDummySpacers(const wxToolBarToolsList
& tools
,
1345 wxToolBarToolsList::compatibility_iterator current
= tools
.GetFirst();
1347 for ( ; current
; current
= current
->GetNext() )
1350 return current
->GetData();
1352 wxToolBarTool
*tool
= (wxToolBarTool
*)current
->GetData();
1353 size_t separators
= tool
->GetSeparatorsCount();
1355 // if it is a normal button, sepcount == 0, so skip 1 item (the button)
1356 // otherwise, skip as many items as the separator count, plus the
1358 index
-= separators
? separators
+ 1 : 1;
1364 wxToolBarToolBase
*wxToolBar::FindToolForPosition(wxCoord x
, wxCoord y
) const
1369 int index
= (int)::SendMessage(GetHwnd(), TB_HITTEST
, 0, (LPARAM
)&pt
);
1371 // MBN: when the point ( x, y ) is close to the toolbar border
1372 // TB_HITTEST returns m_nButtons ( not -1 )
1373 if ( index
< 0 || (size_t)index
>= m_nButtons
)
1374 // it's a separator or there is no tool at all there
1375 return (wxToolBarToolBase
*)NULL
;
1377 // when TB_SETBUTTONINFO is available (both during compile- and run-time),
1378 // we don't use the dummy separators hack
1379 #ifdef TB_SETBUTTONINFO
1380 if ( wxApp::GetComCtl32Version() >= 471 )
1382 return m_tools
.Item((size_t)index
)->GetData();
1385 #endif // TB_SETBUTTONINFO
1387 return GetItemSkippingDummySpacers( m_tools
, (size_t) index
);
1391 void wxToolBar::UpdateSize()
1393 wxPoint pos
= GetPosition();
1394 ::SendMessage(GetHwnd(), TB_AUTOSIZE
, 0, 0);
1395 if (pos
!= GetPosition())
1398 // In case Realize is called after the initial display (IOW the programmer
1399 // may have rebuilt the toolbar) give the frame the option of resizing the
1400 // toolbar to full width again, but only if the parent is a frame and the
1401 // toolbar is managed by the frame. Otherwise assume that some other
1402 // layout mechanism is controlling the toolbar size and leave it alone.
1403 wxFrame
*frame
= wxDynamicCast(GetParent(), wxFrame
);
1404 if ( frame
&& frame
->GetToolBar() == this )
1406 frame
->SendSizeEvent();
1410 // ----------------------------------------------------------------------------
1412 // ---------------------------------------------------------------------------
1414 // get the TBSTYLE of the given toolbar window
1415 long wxToolBar::GetMSWToolbarStyle() const
1417 return ::SendMessage(GetHwnd(), TB_GETSTYLE
, 0, 0L);
1420 void wxToolBar::SetWindowStyleFlag(long style
)
1422 // the style bits whose changes force us to recreate the toolbar
1423 static const long MASK_NEEDS_RECREATE
= wxTB_TEXT
| wxTB_NOICONS
;
1425 const long styleOld
= GetWindowStyle();
1427 wxToolBarBase::SetWindowStyleFlag(style
);
1429 // don't recreate an empty toolbar: not only this is unnecessary, but it is
1430 // also fatal as we'd then try to recreate the toolbar when it's just being
1432 if ( GetToolsCount() &&
1433 (style
& MASK_NEEDS_RECREATE
) != (styleOld
& MASK_NEEDS_RECREATE
) )
1435 // to remove the text labels, simply re-realizing the toolbar is enough
1436 // but I don't know of any way to add the text to an existing toolbar
1437 // other than by recreating it entirely
1442 // ----------------------------------------------------------------------------
1444 // ----------------------------------------------------------------------------
1446 void wxToolBar::DoEnableTool(wxToolBarToolBase
*tool
, bool enable
)
1448 ::SendMessage(GetHwnd(), TB_ENABLEBUTTON
,
1449 (WPARAM
)tool
->GetId(), (LPARAM
)MAKELONG(enable
, 0));
1452 void wxToolBar::DoToggleTool(wxToolBarToolBase
*tool
, bool toggle
)
1454 ::SendMessage(GetHwnd(), TB_CHECKBUTTON
,
1455 (WPARAM
)tool
->GetId(), (LPARAM
)MAKELONG(toggle
, 0));
1458 void wxToolBar::DoSetToggle(wxToolBarToolBase
*WXUNUSED(tool
), bool WXUNUSED(toggle
))
1460 // VZ: AFAIK, the button has to be created either with TBSTYLE_CHECK or
1461 // without, so we really need to delete the button and recreate it here
1462 wxFAIL_MSG( _T("not implemented") );
1465 void wxToolBar::SetToolNormalBitmap( int id
, const wxBitmap
& bitmap
)
1467 wxToolBarTool
* tool
= wx_static_cast(wxToolBarTool
*, FindById(id
));
1470 wxCHECK_RET( tool
->IsButton(), wxT("Can only set bitmap on button tools."));
1472 tool
->SetNormalBitmap(bitmap
);
1477 void wxToolBar::SetToolDisabledBitmap( int id
, const wxBitmap
& bitmap
)
1479 wxToolBarTool
* tool
= wx_static_cast(wxToolBarTool
*, FindById(id
));
1482 wxCHECK_RET( tool
->IsButton(), wxT("Can only set bitmap on button tools."));
1484 tool
->SetDisabledBitmap(bitmap
);
1489 // ----------------------------------------------------------------------------
1491 // ----------------------------------------------------------------------------
1493 // Responds to colour changes, and passes event on to children.
1494 void wxToolBar::OnSysColourChanged(wxSysColourChangedEvent
& event
)
1496 wxRGBToColour(m_backgroundColour
, ::GetSysColor(COLOR_BTNFACE
));
1498 // Remap the buttons
1501 // Relayout the toolbar
1502 int nrows
= m_maxRows
;
1503 m_maxRows
= 0; // otherwise SetRows() wouldn't do anything
1508 // let the event propagate further
1512 void wxToolBar::OnMouseEvent(wxMouseEvent
& event
)
1514 if ( event
.Leaving() )
1518 OnMouseEnter(wxID_ANY
);
1526 if ( event
.RightDown() )
1528 // find the tool under the mouse
1529 wxCoord x
= 0, y
= 0;
1530 event
.GetPosition(&x
, &y
);
1532 wxToolBarToolBase
*tool
= FindToolForPosition(x
, y
);
1533 OnRightClick(tool
? tool
->GetId() : -1, x
, y
);
1541 // This handler is required to allow the toolbar to be set to a non-default
1542 // colour: for example, when it must blend in with a notebook page.
1543 void wxToolBar::OnEraseBackground(wxEraseEvent
& event
)
1545 RECT rect
= wxGetClientRect(GetHwnd());
1546 HDC hdc
= GetHdcOf((*event
.GetDC()));
1548 int majorVersion
, minorVersion
;
1549 wxGetOsVersion(& majorVersion
, & minorVersion
);
1552 // we may need to draw themed colour so that we appear correctly on
1553 // e.g. notebook page under XP with themes but only do it if the parent
1554 // draws themed background itself
1555 if ( !UseBgCol() && !GetParent()->UseBgCol() )
1557 wxUxThemeEngine
*theme
= wxUxThemeEngine::GetIfActive();
1561 hr
= theme
->DrawThemeParentBackground(GetHwnd(), hdc
, &rect
);
1565 // it can also return S_FALSE which seems to simply say that it
1566 // didn't draw anything but no error really occurred
1568 wxLogApiError(_T("DrawThemeParentBackground(toolbar)"), hr
);
1572 // Only draw a rebar theme on Vista, since it doesn't jive so well with XP
1573 if ( !UseBgCol() && majorVersion
>= 6 )
1575 wxUxThemeEngine
*theme
= wxUxThemeEngine::GetIfActive();
1578 wxUxThemeHandle
hTheme(this, L
"REBAR");
1581 wxRect rect
= GetClientRect();
1582 wxCopyRectToRECT(rect
, r
);
1584 HRESULT hr
= theme
->DrawThemeBackground(hTheme
, hdc
, 0, 0, & r
, NULL
);
1588 // it can also return S_FALSE which seems to simply say that it
1589 // didn't draw anything but no error really occurred
1591 wxLogApiError(_T("DrawThemeParentBackground(toolbar)"), hr
);
1595 #endif // wxUSE_UXTHEME
1597 if ( UseBgCol() || (GetMSWToolbarStyle() & TBSTYLE_TRANSPARENT
) )
1599 // do draw our background
1601 // notice that this 'dumb' implementation may cause flicker for some of
1602 // the controls in which case they should intercept wxEraseEvent and
1603 // process it themselves somehow
1604 AutoHBRUSH
hBrush(wxColourToRGB(GetBackgroundColour()));
1606 wxCHANGE_HDC_MAP_MODE(hdc
, MM_TEXT
);
1607 ::FillRect(hdc
, &rect
, hBrush
);
1609 else // we have no non default background colour
1611 // let the system do it for us
1616 bool wxToolBar::HandleSize(WXWPARAM
WXUNUSED(wParam
), WXLPARAM lParam
)
1618 // calculate our minor dimension ourselves - we're confusing the standard
1619 // logic (TB_AUTOSIZE) with our horizontal toolbars and other hacks
1621 if ( ::SendMessage(GetHwnd(), TB_GETITEMRECT
, 0, (LPARAM
)&r
) )
1627 w
= r
.right
- r
.left
;
1630 w
*= (m_nButtons
+ m_maxRows
- 1)/m_maxRows
;
1637 if (HasFlag( wxTB_FLAT
))
1638 h
= r
.bottom
- r
.top
- 3;
1640 h
= r
.bottom
- r
.top
;
1643 // FIXME: hardcoded separator line height...
1644 h
+= HasFlag(wxTB_NODIVIDER
) ? 4 : 6;
1649 if ( MAKELPARAM(w
, h
) != lParam
)
1651 // size really changed
1655 // message processed
1662 bool wxToolBar::HandlePaint(WXWPARAM wParam
, WXLPARAM lParam
)
1664 // erase any dummy separators which were used
1665 // for aligning the controls if any here
1667 // first of all, are there any controls at all?
1668 wxToolBarToolsList::compatibility_iterator node
;
1669 for ( node
= m_tools
.GetFirst(); node
; node
= node
->GetNext() )
1671 if ( node
->GetData()->IsControl() )
1676 // no controls, nothing to erase
1679 wxSize clientSize
= GetClientSize();
1680 int majorVersion
, minorVersion
;
1681 wxGetOsVersion(& majorVersion
, & minorVersion
);
1683 // prepare the DC on which we'll be drawing
1684 wxClientDC
dc(this);
1685 dc
.SetBrush(wxBrush(GetBackgroundColour(), wxSOLID
));
1686 dc
.SetPen(*wxTRANSPARENT_PEN
);
1689 if ( !::GetUpdateRect(GetHwnd(), &r
, FALSE
) )
1690 // nothing to redraw anyhow
1694 wxCopyRECTToRect(r
, rectUpdate
);
1696 dc
.SetClippingRegion(rectUpdate
);
1698 // draw the toolbar tools, separators &c normally
1699 wxControl::MSWWindowProc(WM_PAINT
, wParam
, lParam
);
1701 // for each control in the toolbar find all the separators intersecting it
1704 // NB: this is really the only way to do it as we don't know if a separator
1705 // corresponds to a control (i.e. is a dummy one) or a real one
1707 for ( node
= m_tools
.GetFirst(); node
; node
= node
->GetNext() )
1709 wxToolBarTool
*tool
= (wxToolBarTool
*)node
->GetData();
1710 if ( tool
->IsControl() )
1712 // get the control rect in our client coords
1713 wxControl
*control
= tool
->GetControl();
1714 wxStaticText
*staticText
= tool
->GetStaticText();
1715 wxRect rectCtrl
= control
->GetRect();
1716 wxRect
rectStaticText(0,0,0,0);
1719 rectStaticText
= staticText
->GetRect();
1722 // iterate over all buttons
1724 int count
= ::SendMessage(GetHwnd(), TB_BUTTONCOUNT
, 0, 0);
1725 for ( int n
= 0; n
< count
; n
++ )
1727 // is it a separator?
1728 if ( !::SendMessage(GetHwnd(), TB_GETBUTTON
,
1731 wxLogDebug(_T("TB_GETBUTTON failed?"));
1736 if ( tbb
.fsStyle
!= TBSTYLE_SEP
)
1739 // get the bounding rect of the separator
1741 if ( !::SendMessage(GetHwnd(), TB_GETITEMRECT
,
1744 wxLogDebug(_T("TB_GETITEMRECT failed?"));
1749 // does it intersect the control?
1751 wxCopyRECTToRect(r
, rectItem
);
1752 if ( rectCtrl
.Intersects(rectItem
) || (staticText
&& rectStaticText
.Intersects(rectItem
)))
1754 // yes, do erase it!
1756 bool haveRefreshed
= false;
1759 if ( !UseBgCol() && !GetParent()->UseBgCol() )
1761 // Don't use DrawThemeBackground
1763 else if ( !UseBgCol() && majorVersion
>= 6 )
1765 wxUxThemeEngine
*theme
= wxUxThemeEngine::GetIfActive();
1768 wxUxThemeHandle
hTheme(this, L
"REBAR");
1772 // Draw the whole background since the pattern may be position sensitive;
1773 // but clip it to the area of interest.
1775 r
.right
= clientSize
.x
;
1777 r
.bottom
= clientSize
.y
;
1779 HRESULT hr
= theme
->DrawThemeBackground(hTheme
, (HDC
) dc
.GetHDC(), 0, 0, & r
, & clipRect
);
1781 haveRefreshed
= true;
1787 dc
.DrawRectangle(rectItem
);
1790 if ( rectCtrl
.Intersects(rectItem
) )
1792 // Necessary in case we use a no-paint-on-size
1793 // style in the parent: the controls can disappear
1794 control
->Refresh(false);
1797 if ( staticText
&& rectStaticText
.Intersects(rectItem
) )
1799 // Necessary in case we use a no-paint-on-size
1800 // style in the parent: the controls can disappear
1801 staticText
->Refresh(false);
1810 void wxToolBar::HandleMouseMove(WXWPARAM
WXUNUSED(wParam
), WXLPARAM lParam
)
1812 wxCoord x
= GET_X_LPARAM(lParam
),
1813 y
= GET_Y_LPARAM(lParam
);
1814 wxToolBarToolBase
* tool
= FindToolForPosition( x
, y
);
1816 // has the current tool changed?
1817 if ( tool
!= m_pInTool
)
1820 OnMouseEnter(tool
? tool
->GetId() : wxID_ANY
);
1824 WXLRESULT
wxToolBar::MSWWindowProc(WXUINT nMsg
, WXWPARAM wParam
, WXLPARAM lParam
)
1829 // we don't handle mouse moves, so always pass the message to
1830 // wxControl::MSWWindowProc (HandleMouseMove just calls OnMouseEnter)
1831 HandleMouseMove(wParam
, lParam
);
1835 if ( HandleSize(wParam
, lParam
) )
1841 if ( HandlePaint(wParam
, lParam
) )
1849 return wxControl::MSWWindowProc(nMsg
, wParam
, lParam
);
1852 // ----------------------------------------------------------------------------
1853 // private functions
1854 // ----------------------------------------------------------------------------
1856 #ifdef wxREMAP_BUTTON_COLOURS
1858 WXHBITMAP
wxToolBar::MapBitmap(WXHBITMAP bitmap
, int width
, int height
)
1864 wxLogLastError(_T("CreateCompatibleDC"));
1869 SelectInHDC
bmpInHDC(hdcMem
, (HBITMAP
)bitmap
);
1873 wxLogLastError(_T("SelectObject"));
1878 wxCOLORMAP
*cmap
= wxGetStdColourMap();
1880 for ( int i
= 0; i
< width
; i
++ )
1882 for ( int j
= 0; j
< height
; j
++ )
1884 COLORREF pixel
= ::GetPixel(hdcMem
, i
, j
);
1886 for ( size_t k
= 0; k
< wxSTD_COL_MAX
; k
++ )
1888 COLORREF col
= cmap
[k
].from
;
1889 if ( abs(GetRValue(pixel
) - GetRValue(col
)) < 10 &&
1890 abs(GetGValue(pixel
) - GetGValue(col
)) < 10 &&
1891 abs(GetBValue(pixel
) - GetBValue(col
)) < 10 )
1893 if ( cmap
[k
].to
!= pixel
)
1894 ::SetPixel(hdcMem
, i
, j
, cmap
[k
].to
);
1904 #endif // wxREMAP_BUTTON_COLOURS
1906 #endif // wxUSE_TOOLBAR