]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/msw/toolbar.cpp
Fix wrong return value from wxWebViewIE::Find() in 64 bit build.
[wxWidgets.git] / src / msw / toolbar.cpp
... / ...
CommitLineData
1/////////////////////////////////////////////////////////////////////////////
2// Name: src/msw/toolbar.cpp
3// Purpose: wxToolBar
4// Author: Julian Smart
5// Modified by:
6// Created: 04/01/98
7// RCS-ID: $Id$
8// Copyright: (c) Julian Smart
9// Licence: wxWindows licence
10/////////////////////////////////////////////////////////////////////////////
11
12// ============================================================================
13// declarations
14// ============================================================================
15
16// ----------------------------------------------------------------------------
17// headers
18// ----------------------------------------------------------------------------
19
20// For compilers that support precompilation, includes "wx.h".
21#include "wx/wxprec.h"
22
23#ifdef __BORLANDC__
24 #pragma hdrstop
25#endif
26
27#if wxUSE_TOOLBAR && wxUSE_TOOLBAR_NATIVE && !defined(__SMARTPHONE__)
28
29#include "wx/toolbar.h"
30
31#ifndef WX_PRECOMP
32 #include "wx/msw/wrapcctl.h" // include <commctrl.h> "properly"
33 #include "wx/dynarray.h"
34 #include "wx/frame.h"
35 #include "wx/log.h"
36 #include "wx/intl.h"
37 #include "wx/settings.h"
38 #include "wx/bitmap.h"
39 #include "wx/region.h"
40 #include "wx/dcmemory.h"
41 #include "wx/control.h"
42 #include "wx/app.h" // for GetComCtl32Version
43 #include "wx/image.h"
44 #include "wx/stattext.h"
45#endif
46
47#include "wx/artprov.h"
48#include "wx/sysopt.h"
49#include "wx/dcclient.h"
50#include "wx/scopedarray.h"
51
52#include "wx/msw/private.h"
53#include "wx/msw/dc.h"
54
55#if wxUSE_UXTHEME
56#include "wx/msw/uxtheme.h"
57#endif
58
59// this define controls whether the code for button colours remapping (only
60// useful for 16 or 256 colour images) is active at all, it's always turned off
61// for CE where it doesn't compile (and is probably not needed anyhow) and may
62// also be turned off for other systems if you always use 24bpp images and so
63// never need it
64#ifndef __WXWINCE__
65 #define wxREMAP_BUTTON_COLOURS
66#endif // !__WXWINCE__
67
68// ----------------------------------------------------------------------------
69// constants
70// ----------------------------------------------------------------------------
71
72// these standard constants are not always defined in compilers headers
73
74// Styles
75#ifndef TBSTYLE_FLAT
76 #define TBSTYLE_LIST 0x1000
77 #define TBSTYLE_FLAT 0x0800
78#endif
79
80#ifndef TBSTYLE_TRANSPARENT
81 #define TBSTYLE_TRANSPARENT 0x8000
82#endif
83
84#ifndef TBSTYLE_TOOLTIPS
85 #define TBSTYLE_TOOLTIPS 0x0100
86#endif
87
88// Messages
89#ifndef TB_GETSTYLE
90 #define TB_SETSTYLE (WM_USER + 56)
91 #define TB_GETSTYLE (WM_USER + 57)
92#endif
93
94#ifndef TB_HITTEST
95 #define TB_HITTEST (WM_USER + 69)
96#endif
97
98#ifndef TB_GETMAXSIZE
99 #define TB_GETMAXSIZE (WM_USER + 83)
100#endif
101
102// ----------------------------------------------------------------------------
103// wxWin macros
104// ----------------------------------------------------------------------------
105
106IMPLEMENT_DYNAMIC_CLASS(wxToolBar, wxControl)
107
108/*
109 TOOLBAR PROPERTIES
110 tool
111 bitmap
112 bitmap2
113 tooltip
114 longhelp
115 radio (bool)
116 toggle (bool)
117 separator
118 style ( wxNO_BORDER | wxTB_HORIZONTAL)
119 bitmapsize
120 margins
121 packing
122 separation
123
124 dontattachtoframe
125*/
126
127BEGIN_EVENT_TABLE(wxToolBar, wxToolBarBase)
128 EVT_MOUSE_EVENTS(wxToolBar::OnMouseEvent)
129 EVT_SYS_COLOUR_CHANGED(wxToolBar::OnSysColourChanged)
130 EVT_ERASE_BACKGROUND(wxToolBar::OnEraseBackground)
131END_EVENT_TABLE()
132
133// ----------------------------------------------------------------------------
134// private classes
135// ----------------------------------------------------------------------------
136
137class wxToolBarTool : public wxToolBarToolBase
138{
139public:
140 wxToolBarTool(wxToolBar *tbar,
141 int id,
142 const wxString& label,
143 const wxBitmap& bmpNormal,
144 const wxBitmap& bmpDisabled,
145 wxItemKind kind,
146 wxObject *clientData,
147 const wxString& shortHelp,
148 const wxString& longHelp)
149 : wxToolBarToolBase(tbar, id, label, bmpNormal, bmpDisabled, kind,
150 clientData, shortHelp, longHelp)
151 {
152 m_nSepCount = 0;
153 m_staticText = NULL;
154 }
155
156 wxToolBarTool(wxToolBar *tbar, wxControl *control, const wxString& label)
157 : wxToolBarToolBase(tbar, control, label)
158 {
159 if ( IsControl() && !m_label.empty() )
160 {
161 // create a control to render the control's label
162 m_staticText = new wxStaticText
163 (
164 m_tbar,
165 wxID_ANY,
166 m_label,
167 wxDefaultPosition,
168 wxDefaultSize,
169 wxALIGN_CENTRE | wxST_NO_AUTORESIZE
170 );
171 }
172 else // no label
173 {
174 m_staticText = NULL;
175 }
176
177 m_nSepCount = 1;
178 }
179
180 virtual ~wxToolBarTool()
181 {
182 delete m_staticText;
183 }
184
185 virtual void SetLabel(const wxString& label)
186 {
187 if ( label == m_label )
188 return;
189
190 wxToolBarToolBase::SetLabel(label);
191
192 if ( m_staticText )
193 m_staticText->SetLabel(label);
194
195 // we need to update the label shown in the toolbar because it has a
196 // pointer to the internal buffer of the old label
197 //
198 // TODO: use TB_SETBUTTONINFO
199 }
200
201 wxStaticText* GetStaticText()
202 {
203 wxASSERT_MSG( IsControl(),
204 wxT("only makes sense for embedded control tools") );
205
206 return m_staticText;
207 }
208
209 // set/get the number of separators which we use to cover the space used by
210 // a control in the toolbar
211 void SetSeparatorsCount(size_t count) { m_nSepCount = count; }
212 size_t GetSeparatorsCount() const { return m_nSepCount; }
213
214 // we need ids for the spacers which we want to modify later on, this
215 // function will allocate a valid/unique id for a spacer if not done yet
216 void AllocSpacerId()
217 {
218 if ( m_id == wxID_SEPARATOR )
219 m_id = wxWindow::NewControlId();
220 }
221
222 // this method is used for controls only and offsets the control by the
223 // given amount (in pixels) in horizontal direction
224 void MoveBy(int offset)
225 {
226 wxControl * const control = GetControl();
227
228 control->Move(control->GetPosition().x + offset, wxDefaultCoord);
229
230 if ( m_staticText )
231 {
232 m_staticText->Move(m_staticText->GetPosition().x + offset,
233 wxDefaultCoord);
234 }
235 }
236
237private:
238 size_t m_nSepCount;
239 wxStaticText *m_staticText;
240
241 wxDECLARE_NO_COPY_CLASS(wxToolBarTool);
242};
243
244// ----------------------------------------------------------------------------
245// helper functions
246// ----------------------------------------------------------------------------
247
248// return the rectangle of the item at the given index
249//
250// returns an empty (0, 0, 0, 0) rectangle if fails so the caller may compare
251// r.right or r.bottom with 0 to check for this
252static RECT wxGetTBItemRect(HWND hwnd, int index)
253{
254 RECT r;
255
256 // note that we use TB_GETITEMRECT and not TB_GETRECT because the latter
257 // only appeared in v4.70 of comctl32.dll
258 if ( !::SendMessage(hwnd, TB_GETITEMRECT, index, (LPARAM)&r) )
259 {
260 wxLogLastError(wxT("TB_GETITEMRECT"));
261
262 r.top =
263 r.left =
264 r.right =
265 r.bottom = 0;
266 }
267
268 return r;
269}
270
271// ============================================================================
272// implementation
273// ============================================================================
274
275// ----------------------------------------------------------------------------
276// wxToolBarTool
277// ----------------------------------------------------------------------------
278
279wxToolBarToolBase *wxToolBar::CreateTool(int id,
280 const wxString& label,
281 const wxBitmap& bmpNormal,
282 const wxBitmap& bmpDisabled,
283 wxItemKind kind,
284 wxObject *clientData,
285 const wxString& shortHelp,
286 const wxString& longHelp)
287{
288 return new wxToolBarTool(this, id, label, bmpNormal, bmpDisabled, kind,
289 clientData, shortHelp, longHelp);
290}
291
292wxToolBarToolBase *
293wxToolBar::CreateTool(wxControl *control, const wxString& label)
294{
295 return new wxToolBarTool(this, control, label);
296}
297
298// ----------------------------------------------------------------------------
299// wxToolBar construction
300// ----------------------------------------------------------------------------
301
302void wxToolBar::Init()
303{
304 m_hBitmap = 0;
305 m_disabledImgList = NULL;
306
307 m_nButtons = 0;
308 m_totalFixedSize = 0;
309
310 // even though modern Windows applications typically use 24*24 (or even
311 // 32*32) size for their bitmaps, the native control itself still uses the
312 // old 16*15 default size (see TB_SETBITMAPSIZE documentation in MSDN), so
313 // default to it so that we don't call SetToolBitmapSize() unnecessarily in
314 // wxToolBarBase::AdjustToolBitmapSize()
315 m_defaultWidth = 16;
316 m_defaultHeight = 15;
317
318 m_pInTool = NULL;
319}
320
321bool wxToolBar::Create(wxWindow *parent,
322 wxWindowID id,
323 const wxPoint& pos,
324 const wxSize& size,
325 long style,
326 const wxString& name)
327{
328 // common initialisation
329 if ( !CreateControl(parent, id, pos, size, style, wxDefaultValidator, name) )
330 return false;
331
332 FixupStyle();
333
334 // MSW-specific initialisation
335 if ( !MSWCreateToolbar(pos, size) )
336 return false;
337
338 wxSetCCUnicodeFormat(GetHwnd());
339
340 // we always erase our background on WM_PAINT so there is no need to do it
341 // in WM_ERASEBKGND too (by default this won't be done but if the toolbar
342 // has a non default background colour, then it would be used in both
343 // places resulting in flicker)
344 if (wxApp::GetComCtl32Version() >= 600)
345 {
346 SetBackgroundStyle(wxBG_STYLE_PAINT);
347 }
348
349 return true;
350}
351
352bool wxToolBar::MSWCreateToolbar(const wxPoint& pos, const wxSize& size)
353{
354 if ( !MSWCreateControl(TOOLBARCLASSNAME, wxEmptyString, pos, size) )
355 return false;
356
357 // toolbar-specific post initialisation
358 ::SendMessage(GetHwnd(), TB_BUTTONSTRUCTSIZE, sizeof(TBBUTTON), 0);
359
360#ifdef TB_SETEXTENDEDSTYLE
361 if ( wxApp::GetComCtl32Version() >= 471 )
362 ::SendMessage(GetHwnd(), TB_SETEXTENDEDSTYLE, 0, TBSTYLE_EX_DRAWDDARROWS);
363#endif
364
365 return true;
366}
367
368void wxToolBar::Recreate()
369{
370 const HWND hwndOld = GetHwnd();
371 if ( !hwndOld )
372 {
373 // we haven't been created yet, no need to recreate
374 return;
375 }
376
377 // get the position and size before unsubclassing the old toolbar
378 const wxPoint pos = GetPosition();
379 const wxSize size = GetSize();
380
381 UnsubclassWin();
382
383 if ( !MSWCreateToolbar(pos, size) )
384 {
385 // what can we do?
386 wxFAIL_MSG( wxT("recreating the toolbar failed") );
387
388 return;
389 }
390
391 // reparent all our children under the new toolbar
392 for ( wxWindowList::compatibility_iterator node = m_children.GetFirst();
393 node;
394 node = node->GetNext() )
395 {
396 wxWindow *win = node->GetData();
397 if ( !win->IsTopLevel() )
398 ::SetParent(GetHwndOf(win), GetHwnd());
399 }
400
401 // only destroy the old toolbar now --
402 // after all the children had been reparented
403 ::DestroyWindow(hwndOld);
404
405 // it is for the old bitmap control and can't be used with the new one
406 if ( m_hBitmap )
407 {
408 ::DeleteObject((HBITMAP) m_hBitmap);
409 m_hBitmap = 0;
410 }
411
412 wxDELETE(m_disabledImgList);
413
414 Realize();
415}
416
417wxToolBar::~wxToolBar()
418{
419 // we must refresh the frame size when the toolbar is deleted but the frame
420 // is not - otherwise toolbar leaves a hole in the place it used to occupy
421 SendSizeEventToParent();
422
423 if ( m_hBitmap )
424 ::DeleteObject((HBITMAP) m_hBitmap);
425
426 delete m_disabledImgList;
427}
428
429wxSize wxToolBar::DoGetBestSize() const
430{
431 wxSize sizeBest;
432
433 SIZE size;
434 if ( !::SendMessage(GetHwnd(), TB_GETMAXSIZE, 0, (LPARAM)&size) )
435 {
436 // maybe an old (< 0x400) Windows version? try to approximate the
437 // toolbar size ourselves
438 sizeBest = GetToolSize();
439 sizeBest.y += 2 * ::GetSystemMetrics(SM_CYBORDER); // Add borders
440 sizeBest.x *= GetToolsCount();
441
442 // reverse horz and vertical components if necessary
443 if ( IsVertical() )
444 {
445 int t = sizeBest.x;
446 sizeBest.x = sizeBest.y;
447 sizeBest.y = t;
448 }
449 }
450 else // TB_GETMAXSIZE succeeded
451 {
452 // but it could still return an incorrect result due to what appears to
453 // be a bug in old comctl32.dll versions which don't handle controls in
454 // the toolbar correctly, so work around it (see SF patch 1902358)
455 if ( !IsVertical() && wxApp::GetComCtl32Version() < 600 )
456 {
457 // calculate the toolbar width in alternative way
458 const RECT rcFirst = wxGetTBItemRect(GetHwnd(), 0);
459 const RECT rcLast = wxGetTBItemRect(GetHwnd(), GetToolsCount() - 1);
460
461 const int widthAlt = rcLast.right - rcFirst.left;
462 if ( widthAlt > size.cx )
463 size.cx = widthAlt;
464 }
465
466 sizeBest.x = size.cx;
467 sizeBest.y = size.cy;
468 }
469
470 if ( !IsVertical() )
471 {
472 // Without the extra height, DoGetBestSize can report a size that's
473 // smaller than the actual window, causing windows to overlap slightly
474 // in some circumstances, leading to missing borders (especially noticeable
475 // in AUI layouts).
476 if (!(GetWindowStyle() & wxTB_NODIVIDER))
477 sizeBest.y += 2;
478 sizeBest.y ++;
479 }
480
481 CacheBestSize(sizeBest);
482
483 return sizeBest;
484}
485
486WXDWORD wxToolBar::MSWGetStyle(long style, WXDWORD *exstyle) const
487{
488 // toolbars never have border, giving one to them results in broken
489 // appearance
490 WXDWORD msStyle = wxControl::MSWGetStyle
491 (
492 (style & ~wxBORDER_MASK) | wxBORDER_NONE, exstyle
493 );
494
495 if ( !(style & wxTB_NO_TOOLTIPS) )
496 msStyle |= TBSTYLE_TOOLTIPS;
497
498 if ( style & wxTB_FLAT && wxApp::GetComCtl32Version() > 400 )
499 msStyle |= TBSTYLE_FLAT;
500
501 if ( style & wxTB_HORZ_LAYOUT && wxApp::GetComCtl32Version() >= 470 )
502 msStyle |= TBSTYLE_LIST;
503
504 if ( style & wxTB_NODIVIDER )
505 msStyle |= CCS_NODIVIDER;
506
507 if ( style & wxTB_NOALIGN )
508 msStyle |= CCS_NOPARENTALIGN;
509
510 if ( style & wxTB_VERTICAL )
511 msStyle |= CCS_VERT;
512
513 if( style & wxTB_BOTTOM )
514 msStyle |= CCS_BOTTOM;
515
516 if ( style & wxTB_RIGHT )
517 msStyle |= CCS_RIGHT;
518
519 // always use TBSTYLE_TRANSPARENT because the background is not drawn
520 // correctly without it in all themes and, for whatever reason, the control
521 // also flickers horribly when it is resized if this style is not used
522 //
523 // note that this is implicitly enabled by the native toolbar itself when
524 // TBSTYLE_FLAT is used (i.e. it's impossible to use TBSTYLE_FLAT without
525 // TBSTYLE_TRANSPARENT) but turn it on explicitly in any case
526 msStyle |= TBSTYLE_TRANSPARENT;
527
528 return msStyle;
529}
530
531// ----------------------------------------------------------------------------
532// adding/removing tools
533// ----------------------------------------------------------------------------
534
535bool wxToolBar::DoInsertTool(size_t WXUNUSED(pos),
536 wxToolBarToolBase * WXUNUSED(tool))
537{
538 // nothing special to do here - we really create the toolbar buttons in
539 // Realize() later
540 InvalidateBestSize();
541 return true;
542}
543
544bool wxToolBar::DoDeleteTool(size_t pos, wxToolBarToolBase *tool)
545{
546 // the main difficulty we have here is with the controls in the toolbars:
547 // as we (sometimes) use several separators to cover up the space used by
548 // them, the indices are not the same for us and the toolbar
549
550 // first determine the position of the first button to delete: it may be
551 // different from pos if we use several separators to cover the space used
552 // by a control
553 wxToolBarToolsList::compatibility_iterator node;
554 for ( node = m_tools.GetFirst(); node; node = node->GetNext() )
555 {
556 wxToolBarToolBase *tool2 = node->GetData();
557 if ( tool2 == tool )
558 {
559 // let node point to the next node in the list
560 node = node->GetNext();
561
562 break;
563 }
564
565 if ( tool2->IsControl() )
566 pos += ((wxToolBarTool *)tool2)->GetSeparatorsCount() - 1;
567 }
568
569 // now determine the number of buttons to delete and the area taken by them
570 size_t nButtonsToDelete = 1;
571
572 // get the size of the button we're going to delete
573 const RECT r = wxGetTBItemRect(GetHwnd(), pos);
574
575 int delta = IsVertical() ? r.bottom - r.top : r.right - r.left;
576
577 if ( tool->IsControl() )
578 {
579 nButtonsToDelete = ((wxToolBarTool *)tool)->GetSeparatorsCount();
580
581 if ( !IsVertical() )
582 delta *= nButtonsToDelete;
583 }
584
585 m_totalFixedSize -= delta;
586
587 // do delete all buttons
588 m_nButtons -= nButtonsToDelete;
589 while ( nButtonsToDelete-- > 0 )
590 {
591 if ( !::SendMessage(GetHwnd(), TB_DELETEBUTTON, pos, 0) )
592 {
593 wxLogLastError(wxT("TB_DELETEBUTTON"));
594
595 return false;
596 }
597 }
598
599 // and finally rearrange the tools
600
601 // search for any stretch spacers before the removed tool
602 bool hasPrecedingStrechables = false;
603 for ( wxToolBarToolsList::compatibility_iterator nodeStch = m_tools.GetFirst();
604 nodeStch != node; nodeStch = nodeStch->GetNext() )
605 {
606 if ( ((wxToolBarTool*)nodeStch->GetData())->IsStretchable() )
607 {
608 hasPrecedingStrechables = true;
609 break;
610 }
611 }
612
613 if ( hasPrecedingStrechables )
614 {
615 // if the removed tool is preceded by stretch spacers
616 // just redistribute the space
617 UpdateStretchableSpacersSize();
618 }
619 else
620 {
621 // reposition all the controls after this button but before any
622 // stretch spacer (the toolbar takes care of all normal items)
623 for ( /* node -> first after deleted */ ; node; node = node->GetNext() )
624 {
625 wxToolBarTool *tool2 = (wxToolBarTool*)node->GetData();
626
627 if ( tool2->IsControl() )
628 {
629 tool2->MoveBy(-delta);
630 }
631
632 // if a stretch spacer is found just redistribute the available space
633 else if ( tool2->IsStretchable() )
634 {
635 UpdateStretchableSpacersSize();
636 break;
637 }
638 }
639 }
640
641 InvalidateBestSize();
642
643 return true;
644}
645
646void wxToolBar::CreateDisabledImageList()
647{
648 wxDELETE(m_disabledImgList);
649
650 // as we can't use disabled image list with older versions of comctl32.dll,
651 // don't even bother creating it
652 if ( wxApp::GetComCtl32Version() >= 470 )
653 {
654 // search for the first disabled button img in the toolbar, if any
655 for ( wxToolBarToolsList::compatibility_iterator
656 node = m_tools.GetFirst(); node; node = node->GetNext() )
657 {
658 wxToolBarToolBase *tool = node->GetData();
659 wxBitmap bmpDisabled = tool->GetDisabledBitmap();
660 if ( bmpDisabled.IsOk() )
661 {
662 const wxSize sizeBitmap = bmpDisabled.GetSize();
663 m_disabledImgList = new wxImageList
664 (
665 sizeBitmap.x,
666 sizeBitmap.y,
667 bmpDisabled.GetMask() != NULL,
668 GetToolsCount()
669 );
670 break;
671 }
672 }
673
674 // we don't have any disabled bitmaps
675 }
676}
677
678bool wxToolBar::Realize()
679{
680 if ( !wxToolBarBase::Realize() )
681 return false;
682
683 const size_t nTools = GetToolsCount();
684
685#ifdef wxREMAP_BUTTON_COLOURS
686 // don't change the values of these constants, they can be set from the
687 // user code via wxSystemOptions
688 enum
689 {
690 Remap_None = -1,
691 Remap_Bg,
692 Remap_Buttons,
693 Remap_TransparentBg
694 };
695
696 // the user-specified option overrides anything, but if it wasn't set, only
697 // remap the buttons on 8bpp displays as otherwise the bitmaps usually look
698 // much worse after remapping
699 static const wxChar *remapOption = wxT("msw.remap");
700 const int remapValue = wxSystemOptions::HasOption(remapOption)
701 ? wxSystemOptions::GetOptionInt(remapOption)
702 : wxDisplayDepth() <= 8 ? Remap_Buttons
703 : Remap_None;
704
705#endif // wxREMAP_BUTTON_COLOURS
706
707 // delete all old buttons, if any
708 for ( size_t pos = 0; pos < m_nButtons; pos++ )
709 {
710 if ( !::SendMessage(GetHwnd(), TB_DELETEBUTTON, 0, 0) )
711 {
712 wxLogDebug(wxT("TB_DELETEBUTTON failed"));
713 }
714 }
715
716 // First, add the bitmap: we use one bitmap for all toolbar buttons
717 // ----------------------------------------------------------------
718
719 wxToolBarToolsList::compatibility_iterator node;
720 int bitmapId = 0;
721
722 if ( !HasFlag(wxTB_NOICONS) )
723 {
724 // if we already have a bitmap, we'll replace the existing one --
725 // otherwise we'll install a new one
726 HBITMAP oldToolBarBitmap = (HBITMAP)m_hBitmap;
727
728 const wxCoord totalBitmapWidth = m_defaultWidth *
729 wx_truncate_cast(wxCoord, nTools),
730 totalBitmapHeight = m_defaultHeight;
731
732 // Create a bitmap and copy all the tool bitmaps into it
733 wxMemoryDC dcAllButtons;
734 wxBitmap bitmap(totalBitmapWidth, totalBitmapHeight);
735 dcAllButtons.SelectObject(bitmap);
736
737#ifdef wxREMAP_BUTTON_COLOURS
738 if ( remapValue != Remap_TransparentBg )
739#endif // wxREMAP_BUTTON_COLOURS
740 {
741 // VZ: why do we hardcode grey colour for CE?
742 dcAllButtons.SetBackground(wxBrush(
743#ifdef __WXWINCE__
744 wxColour(0xc0, 0xc0, 0xc0)
745#else // !__WXWINCE__
746 GetBackgroundColour()
747#endif // __WXWINCE__/!__WXWINCE__
748 ));
749 dcAllButtons.Clear();
750 }
751
752 m_hBitmap = bitmap.GetHBITMAP();
753 HBITMAP hBitmap = (HBITMAP)m_hBitmap;
754
755#ifdef wxREMAP_BUTTON_COLOURS
756 if ( remapValue == Remap_Bg )
757 {
758 dcAllButtons.SelectObject(wxNullBitmap);
759
760 // Even if we're not remapping the bitmap
761 // content, we still have to remap the background.
762 hBitmap = (HBITMAP)MapBitmap((WXHBITMAP) hBitmap,
763 totalBitmapWidth, totalBitmapHeight);
764
765 dcAllButtons.SelectObject(bitmap);
766 }
767#endif // wxREMAP_BUTTON_COLOURS
768
769 // the button position
770 wxCoord x = 0;
771
772 // the number of buttons (not separators)
773 int nButtons = 0;
774
775 CreateDisabledImageList();
776 for ( node = m_tools.GetFirst(); node; node = node->GetNext() )
777 {
778 wxToolBarToolBase *tool = node->GetData();
779 if ( tool->IsButton() )
780 {
781 const wxBitmap& bmp = tool->GetNormalBitmap();
782
783 const int w = bmp.GetWidth();
784 const int h = bmp.GetHeight();
785
786 if ( bmp.IsOk() )
787 {
788 int xOffset = wxMax(0, (m_defaultWidth - w)/2);
789 int yOffset = wxMax(0, (m_defaultHeight - h)/2);
790
791 // notice the last parameter: do use mask
792 dcAllButtons.DrawBitmap(bmp, x + xOffset, yOffset, true);
793 }
794 else
795 {
796 wxFAIL_MSG( wxT("invalid tool button bitmap") );
797 }
798
799 // also deal with disabled bitmap if we want to use them
800 if ( m_disabledImgList )
801 {
802 wxBitmap bmpDisabled = tool->GetDisabledBitmap();
803#if wxUSE_IMAGE && wxUSE_WXDIB
804 if ( !bmpDisabled.IsOk() )
805 {
806 // no disabled bitmap specified but we still need to
807 // fill the space in the image list with something, so
808 // we grey out the normal bitmap
809 wxImage
810 imgGreyed = bmp.ConvertToImage().ConvertToGreyscale();
811
812#ifdef wxREMAP_BUTTON_COLOURS
813 if ( remapValue == Remap_Buttons )
814 {
815 // we need to have light grey background colour for
816 // MapBitmap() to work correctly
817 for ( int y = 0; y < h; y++ )
818 {
819 for ( int x = 0; x < w; x++ )
820 {
821 if ( imgGreyed.IsTransparent(x, y) )
822 imgGreyed.SetRGB(x, y,
823 wxLIGHT_GREY->Red(),
824 wxLIGHT_GREY->Green(),
825 wxLIGHT_GREY->Blue());
826 }
827 }
828 }
829#endif // wxREMAP_BUTTON_COLOURS
830
831 bmpDisabled = wxBitmap(imgGreyed);
832 }
833#endif // wxUSE_IMAGE
834
835#ifdef wxREMAP_BUTTON_COLOURS
836 if ( remapValue == Remap_Buttons )
837 MapBitmap(bmpDisabled.GetHBITMAP(), w, h);
838#endif // wxREMAP_BUTTON_COLOURS
839
840 m_disabledImgList->Add(bmpDisabled);
841 }
842
843 // still inc width and number of buttons because otherwise the
844 // subsequent buttons will all be shifted which is rather confusing
845 // (and like this you'd see immediately which bitmap was bad)
846 x += m_defaultWidth;
847 nButtons++;
848 }
849 }
850
851 dcAllButtons.SelectObject(wxNullBitmap);
852
853 // don't delete this HBITMAP!
854 bitmap.SetHBITMAP(0);
855
856#ifdef wxREMAP_BUTTON_COLOURS
857 if ( remapValue == Remap_Buttons )
858 {
859 // Map to system colours
860 hBitmap = (HBITMAP)MapBitmap((WXHBITMAP) hBitmap,
861 totalBitmapWidth, totalBitmapHeight);
862 }
863#endif // wxREMAP_BUTTON_COLOURS
864
865 bool addBitmap = true;
866
867 if ( oldToolBarBitmap )
868 {
869#ifdef TB_REPLACEBITMAP
870 if ( wxApp::GetComCtl32Version() >= 400 )
871 {
872 TBREPLACEBITMAP replaceBitmap;
873 replaceBitmap.hInstOld = NULL;
874 replaceBitmap.hInstNew = NULL;
875 replaceBitmap.nIDOld = (UINT_PTR)oldToolBarBitmap;
876 replaceBitmap.nIDNew = (UINT_PTR)hBitmap;
877 replaceBitmap.nButtons = nButtons;
878 if ( !::SendMessage(GetHwnd(), TB_REPLACEBITMAP,
879 0, (LPARAM) &replaceBitmap) )
880 {
881 wxFAIL_MSG(wxT("Could not replace the old bitmap"));
882 }
883
884 ::DeleteObject(oldToolBarBitmap);
885
886 // already done
887 addBitmap = false;
888 }
889 else
890#endif // TB_REPLACEBITMAP
891 {
892 // we can't replace the old bitmap, so we will add another one
893 // (awfully inefficient, but what else to do?) and shift the bitmap
894 // indices accordingly
895 addBitmap = true;
896
897 bitmapId = m_nButtons;
898 }
899 }
900
901 if ( addBitmap ) // no old bitmap or we can't replace it
902 {
903 TBADDBITMAP addBitmap;
904 addBitmap.hInst = 0;
905 addBitmap.nID = (UINT_PTR)hBitmap;
906 if ( ::SendMessage(GetHwnd(), TB_ADDBITMAP,
907 (WPARAM) nButtons, (LPARAM)&addBitmap) == -1 )
908 {
909 wxFAIL_MSG(wxT("Could not add bitmap to toolbar"));
910 }
911 }
912
913 // disable image lists are only supported in comctl32.dll 4.70+
914 if ( wxApp::GetComCtl32Version() >= 470 )
915 {
916 HIMAGELIST hil = m_disabledImgList
917 ? GetHimagelistOf(m_disabledImgList)
918 : 0;
919
920 // notice that we set the image list even if don't have one right
921 // now as we could have it before and need to reset it in this case
922 HIMAGELIST oldImageList = (HIMAGELIST)
923 ::SendMessage(GetHwnd(), TB_SETDISABLEDIMAGELIST, 0, (LPARAM)hil);
924
925 // delete previous image list if any
926 if ( oldImageList )
927 ::DeleteObject(oldImageList);
928 }
929 }
930
931
932 // Next add the buttons and separators
933 // -----------------------------------
934
935 wxScopedArray<TBBUTTON> buttons(new TBBUTTON[nTools]);
936
937 // this array will hold the indices of all controls in the toolbar
938 wxArrayInt controlIds;
939
940 bool lastWasRadio = false;
941 int i = 0;
942 for ( node = m_tools.GetFirst(); node; node = node->GetNext() )
943 {
944 wxToolBarTool *tool = static_cast<wxToolBarTool *>(node->GetData());
945
946 // don't add separators to the vertical toolbar with old comctl32.dll
947 // versions as they didn't handle this properly
948 if ( IsVertical() && tool->IsSeparator() &&
949 wxApp::GetComCtl32Version() <= 472 )
950 {
951 continue;
952 }
953
954 TBBUTTON& button = buttons[i];
955
956 wxZeroMemory(button);
957
958 bool isRadio = false;
959 switch ( tool->GetStyle() )
960 {
961 case wxTOOL_STYLE_CONTROL:
962 case wxTOOL_STYLE_SEPARATOR:
963 if ( tool->IsStretchableSpace() )
964 {
965 // we're going to modify the size of this button later and
966 // so we need a valid id for it and not wxID_SEPARATOR
967 // which is used by spacers by default
968 tool->AllocSpacerId();
969
970 // also set the number of separators so that the logic in
971 // HandlePaint() works correctly
972 tool->SetSeparatorsCount(1);
973 }
974
975 button.idCommand = tool->GetId();
976 button.fsState = TBSTATE_ENABLED;
977 button.fsStyle = TBSTYLE_SEP;
978 break;
979
980 case wxTOOL_STYLE_BUTTON:
981 if ( !HasFlag(wxTB_NOICONS) )
982 button.iBitmap = bitmapId;
983
984 if ( HasFlag(wxTB_TEXT) )
985 {
986 const wxString& label = tool->GetLabel();
987 if ( !label.empty() )
988 button.iString = (INT_PTR) wxMSW_CONV_LPCTSTR(label);
989 }
990
991 button.idCommand = tool->GetId();
992
993 if ( tool->IsEnabled() )
994 button.fsState |= TBSTATE_ENABLED;
995 if ( tool->IsToggled() )
996 button.fsState |= TBSTATE_CHECKED;
997
998 switch ( tool->GetKind() )
999 {
1000 case wxITEM_RADIO:
1001 button.fsStyle = TBSTYLE_CHECKGROUP;
1002
1003 if ( !lastWasRadio )
1004 {
1005 // the first item in the radio group is checked by
1006 // default to be consistent with wxGTK and the menu
1007 // radio items
1008 button.fsState |= TBSTATE_CHECKED;
1009
1010 if (tool->Toggle(true))
1011 {
1012 DoToggleTool(tool, true);
1013 }
1014 }
1015 else if ( tool->IsToggled() )
1016 {
1017 wxToolBarToolsList::compatibility_iterator nodePrev = node->GetPrevious();
1018 int prevIndex = i - 1;
1019 while ( nodePrev )
1020 {
1021 TBBUTTON& prevButton = buttons[prevIndex];
1022 wxToolBarToolBase *tool = nodePrev->GetData();
1023 if ( !tool->IsButton() || tool->GetKind() != wxITEM_RADIO )
1024 break;
1025
1026 if ( tool->Toggle(false) )
1027 DoToggleTool(tool, false);
1028
1029 prevButton.fsState &= ~TBSTATE_CHECKED;
1030 nodePrev = nodePrev->GetPrevious();
1031 prevIndex--;
1032 }
1033 }
1034
1035 isRadio = true;
1036 break;
1037
1038 case wxITEM_CHECK:
1039 button.fsStyle = TBSTYLE_CHECK;
1040 break;
1041
1042 case wxITEM_NORMAL:
1043 button.fsStyle = TBSTYLE_BUTTON;
1044 break;
1045
1046 case wxITEM_DROPDOWN:
1047 button.fsStyle = TBSTYLE_DROPDOWN;
1048 break;
1049
1050 default:
1051 wxFAIL_MSG( wxT("unexpected toolbar button kind") );
1052 button.fsStyle = TBSTYLE_BUTTON;
1053 break;
1054 }
1055
1056 // Instead of using fixed widths for all buttons, size them
1057 // automatically according to the size of their bitmap and text
1058 // label, if present. This particularly matters for toolbars
1059 // with the wxTB_HORZ_LAYOUT style: they look hideously ugly
1060 // without autosizing when the labels have even slightly
1061 // different lengths.
1062 button.fsStyle |= TBSTYLE_AUTOSIZE;
1063
1064 bitmapId++;
1065 break;
1066 }
1067
1068 lastWasRadio = isRadio;
1069
1070 i++;
1071 }
1072
1073 if ( !::SendMessage(GetHwnd(), TB_ADDBUTTONS, i, (LPARAM)buttons.get()) )
1074 {
1075 wxLogLastError(wxT("TB_ADDBUTTONS"));
1076 }
1077
1078
1079 // Adjust controls and stretchable spaces
1080 // --------------------------------------
1081
1082 // adjust the controls size to fit nicely in the toolbar and compute its
1083 // total size while doing it
1084 m_totalFixedSize = 0;
1085 int toolIndex = 0;
1086 for ( node = m_tools.GetFirst(); node; node = node->GetNext(), toolIndex++ )
1087 {
1088 wxToolBarTool * const tool = (wxToolBarTool*)node->GetData();
1089
1090 const RECT r = wxGetTBItemRect(GetHwnd(), toolIndex);
1091
1092 if ( !tool->IsControl() )
1093 {
1094 if ( IsVertical() )
1095 m_totalFixedSize += r.bottom - r.top;
1096 else
1097 m_totalFixedSize += r.right - r.left;
1098
1099 continue;
1100 }
1101
1102 if ( IsVertical() )
1103 {
1104 // don't embed controls in the vertical toolbar, this doesn't look
1105 // good and wxGTK doesn't do it neither (and the code below can't
1106 // deal with this case)
1107 continue;
1108 }
1109
1110 wxControl * const control = tool->GetControl();
1111 wxStaticText * const staticText = tool->GetStaticText();
1112
1113 wxSize size = control->GetSize();
1114 wxSize staticTextSize;
1115 if ( staticText )
1116 {
1117 staticTextSize = staticText->GetSize();
1118 staticTextSize.y += 3; // margin between control and its label
1119 }
1120
1121 // TB_SETBUTTONINFO message is only supported by comctl32.dll 4.71+
1122#ifdef TB_SETBUTTONINFO
1123 // available in headers, now check whether it is available now
1124 // (during run-time)
1125 if ( wxApp::GetComCtl32Version() >= 471 )
1126 {
1127 // set the (underlying) separators width to be that of the
1128 // control
1129 TBBUTTONINFO tbbi;
1130 tbbi.cbSize = sizeof(tbbi);
1131 tbbi.dwMask = TBIF_SIZE;
1132 tbbi.cx = (WORD)size.x;
1133 if ( !::SendMessage(GetHwnd(), TB_SETBUTTONINFO,
1134 tool->GetId(), (LPARAM)&tbbi) )
1135 {
1136 // the id is probably invalid?
1137 wxLogLastError(wxT("TB_SETBUTTONINFO"));
1138 }
1139 }
1140 else
1141#endif // comctl32.dll 4.71
1142 // TB_SETBUTTONINFO unavailable
1143 {
1144 // try adding several separators to fit the controls width
1145 int widthSep = r.right - r.left;
1146
1147 TBBUTTON tbb;
1148 wxZeroMemory(tbb);
1149 tbb.idCommand = 0;
1150 tbb.fsState = TBSTATE_ENABLED;
1151 tbb.fsStyle = TBSTYLE_SEP;
1152
1153 size_t nSeparators = size.x / widthSep;
1154 for ( size_t nSep = 0; nSep < nSeparators; nSep++ )
1155 {
1156 if ( !::SendMessage(GetHwnd(), TB_INSERTBUTTON,
1157 toolIndex, (LPARAM)&tbb) )
1158 {
1159 wxLogLastError(wxT("TB_INSERTBUTTON"));
1160 }
1161
1162 toolIndex++;
1163 }
1164
1165 // remember the number of separators we used - we'd have to
1166 // delete all of them later
1167 tool->SetSeparatorsCount(nSeparators);
1168
1169 // adjust the controls width to exactly cover the separators
1170 size.x = (nSeparators + 1)*widthSep;
1171 control->SetSize(size.x, wxDefaultCoord);
1172 }
1173
1174 // position the control itself correctly vertically centering it on the
1175 // icon area of the toolbar
1176 int height = r.bottom - r.top - staticTextSize.y;
1177
1178 int diff = height - size.y;
1179 if ( diff < 0 || !HasFlag(wxTB_TEXT) )
1180 {
1181 // not enough room for the static text
1182 if ( staticText )
1183 staticText->Hide();
1184
1185 // recalculate height & diff without the staticText control
1186 height = r.bottom - r.top;
1187 diff = height - size.y;
1188 if ( diff < 0 )
1189 {
1190 // the control is too high, resize to fit
1191 control->SetSize(wxDefaultCoord, height - 2);
1192
1193 diff = 2;
1194 }
1195 }
1196 else // enough space for both the control and the label
1197 {
1198 if ( staticText )
1199 staticText->Show();
1200 }
1201
1202 control->Move(r.left, r.top + (diff + 1) / 2);
1203 if ( staticText )
1204 {
1205 staticText->Move(r.left + (size.x - staticTextSize.x)/2,
1206 r.bottom - staticTextSize.y);
1207 }
1208
1209 m_totalFixedSize += size.x;
1210 }
1211
1212 // the max index is the "real" number of buttons - i.e. counting even the
1213 // separators which we added just for aligning the controls
1214 m_nButtons = toolIndex;
1215
1216 if ( !IsVertical() )
1217 {
1218 if ( m_maxRows == 0 )
1219 // if not set yet, only one row
1220 SetRows(1);
1221 }
1222 else if ( m_nButtons > 0 ) // vertical non empty toolbar
1223 {
1224 // if not set yet, have one column
1225 m_maxRows = 1;
1226 SetRows(m_nButtons);
1227 }
1228
1229 InvalidateBestSize();
1230 UpdateSize();
1231
1232 return true;
1233}
1234
1235void wxToolBar::UpdateStretchableSpacersSize()
1236{
1237#ifdef TB_SETBUTTONINFO
1238 // we can't resize the spacers if TB_SETBUTTONINFO is not supported (we
1239 // could try to do it with multiple separators as for the controls but this
1240 // is too painful and it just doesn't seem to be worth doing for the
1241 // ancient systems)
1242 if ( wxApp::GetComCtl32Version() < 471 )
1243 return;
1244
1245 // check if we have any stretchable spacers in the first place
1246 unsigned numSpaces = 0;
1247 wxToolBarToolsList::compatibility_iterator node;
1248 for ( node = m_tools.GetFirst(); node; node = node->GetNext() )
1249 {
1250 wxToolBarTool * const tool = (wxToolBarTool*)node->GetData();
1251 if ( tool->IsStretchableSpace() )
1252 numSpaces++;
1253 }
1254
1255 if ( !numSpaces )
1256 return;
1257
1258 // we do, adjust their size: either distribute the extra size among them or
1259 // reduce their size if there is not enough place for all tools
1260 const int totalSize = IsVertical() ? GetClientSize().y : GetClientSize().x;
1261 const int extraSize = totalSize - m_totalFixedSize;
1262 const int sizeSpacer = extraSize > 0 ? extraSize / numSpaces : 1;
1263
1264 // the last spacer should consume all remaining space if we have too much
1265 // of it (which can be greater than sizeSpacer because of the rounding)
1266 const int sizeLastSpacer = extraSize > 0
1267 ? extraSize - (numSpaces - 1)*sizeSpacer
1268 : 1;
1269
1270 // cumulated offset by which we need to move all the following controls to
1271 // the right: while the toolbar takes care of the normal items, we must
1272 // move the controls manually ourselves to ensure they remain at the
1273 // correct place
1274 int offset = 0;
1275 int toolIndex = 0;
1276 for ( node = m_tools.GetFirst(); node; node = node->GetNext(), toolIndex++ )
1277 {
1278 wxToolBarTool * const tool = (wxToolBarTool*)node->GetData();
1279
1280 if ( tool->IsControl() && offset )
1281 {
1282 tool->MoveBy(offset);
1283
1284 continue;
1285 }
1286
1287 if ( !tool->IsStretchableSpace() )
1288 continue;
1289
1290 const RECT rcOld = wxGetTBItemRect(GetHwnd(), toolIndex);
1291
1292 WinStruct<TBBUTTONINFO> tbbi;
1293 tbbi.dwMask = TBIF_SIZE;
1294 tbbi.cx = --numSpaces ? sizeSpacer : sizeLastSpacer;
1295
1296 if ( !::SendMessage(GetHwnd(), TB_SETBUTTONINFO,
1297 tool->GetId(), (LPARAM)&tbbi) )
1298 {
1299 wxLogLastError(wxT("TB_SETBUTTONINFO"));
1300 }
1301 else
1302 {
1303 // we successfully resized this one, move all the controls after it
1304 // by the corresponding amount (may be positive or negative)
1305 offset += tbbi.cx - (rcOld.right - rcOld.left);
1306 }
1307 }
1308#endif // TB_SETBUTTONINFO
1309}
1310
1311// ----------------------------------------------------------------------------
1312// message handlers
1313// ----------------------------------------------------------------------------
1314
1315bool wxToolBar::MSWCommand(WXUINT WXUNUSED(cmd), WXWORD id_)
1316{
1317 // cast to signed is important as we compare this id with (signed) ints in
1318 // FindById() and without the cast we'd get a positive int from a
1319 // "negative" (i.e. > 32767) WORD
1320 const int id = (signed short)id_;
1321
1322 wxToolBarToolBase *tool = FindById(id);
1323 if ( !tool )
1324 return false;
1325
1326 bool toggled = false; // just to suppress warnings
1327
1328 LRESULT state = ::SendMessage(GetHwnd(), TB_GETSTATE, id, 0);
1329
1330 if ( tool->CanBeToggled() )
1331 {
1332 toggled = (state & TBSTATE_CHECKED) != 0;
1333
1334 // ignore the event when a radio button is released, as this doesn't
1335 // seem to happen at all, and is handled otherwise
1336 if ( tool->GetKind() == wxITEM_RADIO && !toggled )
1337 return true;
1338
1339 tool->Toggle(toggled);
1340 UnToggleRadioGroup(tool);
1341 }
1342
1343 // Without the two lines of code below, if the toolbar was repainted during
1344 // OnLeftClick(), then it could end up without the tool bitmap temporarily
1345 // (see http://lists.nongnu.org/archive/html/lmi/2008-10/msg00014.html).
1346 // The Update() call below ensures that this won't happen, by repainting
1347 // invalidated areas of the toolbar immediately.
1348 //
1349 // To complicate matters, the tool would be drawn in depressed state (this
1350 // code is called when mouse button is released, not pressed). That's not
1351 // ideal, having the tool pressed for the duration of OnLeftClick()
1352 // provides the user with useful visual clue that the app is busy reacting
1353 // to the event. So we manually put the tool into pressed state, handle the
1354 // event and then finally restore tool's original state.
1355 ::SendMessage(GetHwnd(), TB_SETSTATE, id, MAKELONG(state | TBSTATE_PRESSED, 0));
1356 Update();
1357
1358 bool allowLeftClick = OnLeftClick(id, toggled);
1359
1360 // Restore the unpressed state. Enabled/toggled state might have been
1361 // changed since so take care of it.
1362 if (tool->IsEnabled())
1363 state |= TBSTATE_ENABLED;
1364 else
1365 state &= ~TBSTATE_ENABLED;
1366 if (tool->IsToggled())
1367 state |= TBSTATE_CHECKED;
1368 else
1369 state &= ~TBSTATE_CHECKED;
1370 ::SendMessage(GetHwnd(), TB_SETSTATE, id, MAKELONG(state, 0));
1371
1372 // OnLeftClick() can veto the button state change - for buttons which
1373 // may be toggled only, of course.
1374 if ( !allowLeftClick && tool->CanBeToggled() )
1375 {
1376 // revert back
1377 tool->Toggle(!toggled);
1378
1379 ::SendMessage(GetHwnd(), TB_CHECKBUTTON, id, MAKELONG(!toggled, 0));
1380 }
1381
1382 return true;
1383}
1384
1385bool wxToolBar::MSWOnNotify(int WXUNUSED(idCtrl),
1386 WXLPARAM lParam,
1387 WXLPARAM *WXUNUSED(result))
1388{
1389 LPNMHDR hdr = (LPNMHDR)lParam;
1390 if ( hdr->code == TBN_DROPDOWN )
1391 {
1392 LPNMTOOLBAR tbhdr = (LPNMTOOLBAR)lParam;
1393
1394 wxCommandEvent evt(wxEVT_TOOL_DROPDOWN, tbhdr->iItem);
1395 if ( HandleWindowEvent(evt) )
1396 {
1397 // Event got handled, don't display default popup menu
1398 return false;
1399 }
1400
1401 const wxToolBarToolBase * const tool = FindById(tbhdr->iItem);
1402 wxCHECK_MSG( tool, false, wxT("drop down message for unknown tool") );
1403
1404 wxMenu * const menu = tool->GetDropdownMenu();
1405 if ( !menu )
1406 return false;
1407
1408 // Display popup menu below button
1409 const RECT r = wxGetTBItemRect(GetHwnd(), GetToolPos(tbhdr->iItem));
1410 if ( r.right )
1411 PopupMenu(menu, r.left, r.bottom);
1412
1413 return true;
1414 }
1415
1416
1417 if( !HasFlag(wxTB_NO_TOOLTIPS) )
1418 {
1419#if wxUSE_TOOLTIPS
1420 // First check if this applies to us
1421
1422 // the tooltips control created by the toolbar is sometimes Unicode, even
1423 // in an ANSI application - this seems to be a bug in comctl32.dll v5
1424 UINT code = hdr->code;
1425 if ( (code != (UINT) TTN_NEEDTEXTA) && (code != (UINT) TTN_NEEDTEXTW) )
1426 return false;
1427
1428 HWND toolTipWnd = (HWND)::SendMessage(GetHwnd(), TB_GETTOOLTIPS, 0, 0);
1429 if ( toolTipWnd != hdr->hwndFrom )
1430 return false;
1431
1432 LPTOOLTIPTEXT ttText = (LPTOOLTIPTEXT)lParam;
1433 int id = (int)ttText->hdr.idFrom;
1434
1435 wxToolBarToolBase *tool = FindById(id);
1436 if ( tool )
1437 return HandleTooltipNotify(code, lParam, tool->GetShortHelp());
1438#else
1439 wxUnusedVar(lParam);
1440#endif
1441 }
1442
1443 return false;
1444}
1445
1446// ----------------------------------------------------------------------------
1447// toolbar geometry
1448// ----------------------------------------------------------------------------
1449
1450void wxToolBar::SetToolBitmapSize(const wxSize& size)
1451{
1452 wxToolBarBase::SetToolBitmapSize(size);
1453
1454 ::SendMessage(GetHwnd(), TB_SETBITMAPSIZE, 0, MAKELONG(size.x, size.y));
1455}
1456
1457void wxToolBar::SetRows(int nRows)
1458{
1459 if ( nRows == m_maxRows )
1460 {
1461 // avoid resizing the frame uselessly
1462 return;
1463 }
1464
1465 // TRUE in wParam means to create at least as many rows, FALSE -
1466 // at most as many
1467 RECT rect;
1468 ::SendMessage(GetHwnd(), TB_SETROWS,
1469 MAKEWPARAM(nRows, !(GetWindowStyle() & wxTB_VERTICAL)),
1470 (LPARAM) &rect);
1471
1472 m_maxRows = nRows;
1473
1474 UpdateSize();
1475}
1476
1477// The button size is bigger than the bitmap size
1478wxSize wxToolBar::GetToolSize() const
1479{
1480 // TB_GETBUTTONSIZE is supported from version 4.70
1481#if defined(_WIN32_IE) && (_WIN32_IE >= 0x300 ) \
1482 && !( defined(__GNUWIN32__) && !wxCHECK_W32API_VERSION( 1, 0 ) ) \
1483 && !defined (__DIGITALMARS__)
1484 if ( wxApp::GetComCtl32Version() >= 470 )
1485 {
1486 DWORD dw = ::SendMessage(GetHwnd(), TB_GETBUTTONSIZE, 0, 0);
1487
1488 return wxSize(LOWORD(dw), HIWORD(dw));
1489 }
1490 else
1491#endif // comctl32.dll 4.70+
1492 {
1493 // defaults
1494 return wxSize(m_defaultWidth + 8, m_defaultHeight + 7);
1495 }
1496}
1497
1498static
1499wxToolBarToolBase *GetItemSkippingDummySpacers(const wxToolBarToolsList& tools,
1500 size_t index )
1501{
1502 wxToolBarToolsList::compatibility_iterator current = tools.GetFirst();
1503
1504 for ( ; current ; current = current->GetNext() )
1505 {
1506 if ( index == 0 )
1507 return current->GetData();
1508
1509 wxToolBarTool *tool = (wxToolBarTool *)current->GetData();
1510 size_t separators = tool->GetSeparatorsCount();
1511
1512 // if it is a normal button, sepcount == 0, so skip 1 item (the button)
1513 // otherwise, skip as many items as the separator count, plus the
1514 // control itself
1515 index -= separators ? separators + 1 : 1;
1516 }
1517
1518 return 0;
1519}
1520
1521wxToolBarToolBase *wxToolBar::FindToolForPosition(wxCoord x, wxCoord y) const
1522{
1523 POINT pt;
1524 pt.x = x;
1525 pt.y = y;
1526 int index = (int)::SendMessage(GetHwnd(), TB_HITTEST, 0, (LPARAM)&pt);
1527
1528 // MBN: when the point ( x, y ) is close to the toolbar border
1529 // TB_HITTEST returns m_nButtons ( not -1 )
1530 if ( index < 0 || (size_t)index >= m_nButtons )
1531 // it's a separator or there is no tool at all there
1532 return NULL;
1533
1534 // when TB_SETBUTTONINFO is available (both during compile- and run-time),
1535 // we don't use the dummy separators hack
1536#ifdef TB_SETBUTTONINFO
1537 if ( wxApp::GetComCtl32Version() >= 471 )
1538 {
1539 return m_tools.Item((size_t)index)->GetData();
1540 }
1541 else
1542#endif // TB_SETBUTTONINFO
1543 {
1544 return GetItemSkippingDummySpacers( m_tools, (size_t) index );
1545 }
1546}
1547
1548void wxToolBar::UpdateSize()
1549{
1550 wxPoint pos = GetPosition();
1551 ::SendMessage(GetHwnd(), TB_AUTOSIZE, 0, 0);
1552 if (pos != GetPosition())
1553 Move(pos);
1554
1555 // In case Realize is called after the initial display (IOW the programmer
1556 // may have rebuilt the toolbar) give the frame the option of resizing the
1557 // toolbar to full width again, but only if the parent is a frame and the
1558 // toolbar is managed by the frame. Otherwise assume that some other
1559 // layout mechanism is controlling the toolbar size and leave it alone.
1560 SendSizeEventToParent();
1561}
1562
1563// ----------------------------------------------------------------------------
1564// toolbar styles
1565// ---------------------------------------------------------------------------
1566
1567// get the TBSTYLE of the given toolbar window
1568long wxToolBar::GetMSWToolbarStyle() const
1569{
1570 return ::SendMessage(GetHwnd(), TB_GETSTYLE, 0, 0L);
1571}
1572
1573void wxToolBar::SetWindowStyleFlag(long style)
1574{
1575 // the style bits whose changes force us to recreate the toolbar
1576 static const long MASK_NEEDS_RECREATE = wxTB_TEXT | wxTB_NOICONS;
1577
1578 const long styleOld = GetWindowStyle();
1579
1580 wxToolBarBase::SetWindowStyleFlag(style);
1581
1582 // don't recreate an empty toolbar: not only this is unnecessary, but it is
1583 // also fatal as we'd then try to recreate the toolbar when it's just being
1584 // created
1585 if ( GetToolsCount() &&
1586 (style & MASK_NEEDS_RECREATE) != (styleOld & MASK_NEEDS_RECREATE) )
1587 {
1588 // to remove the text labels, simply re-realizing the toolbar is enough
1589 // but I don't know of any way to add the text to an existing toolbar
1590 // other than by recreating it entirely
1591 Recreate();
1592 }
1593}
1594
1595// ----------------------------------------------------------------------------
1596// tool state
1597// ----------------------------------------------------------------------------
1598
1599void wxToolBar::DoEnableTool(wxToolBarToolBase *tool, bool enable)
1600{
1601 ::SendMessage(GetHwnd(), TB_ENABLEBUTTON,
1602 (WPARAM)tool->GetId(), (LPARAM)MAKELONG(enable, 0));
1603}
1604
1605void wxToolBar::DoToggleTool(wxToolBarToolBase *tool, bool toggle)
1606{
1607 ::SendMessage(GetHwnd(), TB_CHECKBUTTON,
1608 (WPARAM)tool->GetId(), (LPARAM)MAKELONG(toggle, 0));
1609}
1610
1611void wxToolBar::DoSetToggle(wxToolBarToolBase *WXUNUSED(tool), bool WXUNUSED(toggle))
1612{
1613 // VZ: AFAIK, the button has to be created either with TBSTYLE_CHECK or
1614 // without, so we really need to delete the button and recreate it here
1615 wxFAIL_MSG( wxT("not implemented") );
1616}
1617
1618void wxToolBar::SetToolNormalBitmap( int id, const wxBitmap& bitmap )
1619{
1620 wxToolBarTool* tool = static_cast<wxToolBarTool*>(FindById(id));
1621 if ( tool )
1622 {
1623 wxCHECK_RET( tool->IsButton(), wxT("Can only set bitmap on button tools."));
1624
1625 tool->SetNormalBitmap(bitmap);
1626 Realize();
1627 }
1628}
1629
1630void wxToolBar::SetToolDisabledBitmap( int id, const wxBitmap& bitmap )
1631{
1632 wxToolBarTool* tool = static_cast<wxToolBarTool*>(FindById(id));
1633 if ( tool )
1634 {
1635 wxCHECK_RET( tool->IsButton(), wxT("Can only set bitmap on button tools."));
1636
1637 tool->SetDisabledBitmap(bitmap);
1638 Realize();
1639 }
1640}
1641
1642// ----------------------------------------------------------------------------
1643// event handlers
1644// ----------------------------------------------------------------------------
1645
1646// Responds to colour changes, and passes event on to children.
1647void wxToolBar::OnSysColourChanged(wxSysColourChangedEvent& event)
1648{
1649 wxRGBToColour(m_backgroundColour, ::GetSysColor(COLOR_BTNFACE));
1650
1651 // Remap the buttons
1652 Realize();
1653
1654 // Relayout the toolbar
1655 int nrows = m_maxRows;
1656 m_maxRows = 0; // otherwise SetRows() wouldn't do anything
1657 SetRows(nrows);
1658
1659 Refresh();
1660
1661 // let the event propagate further
1662 event.Skip();
1663}
1664
1665void wxToolBar::OnMouseEvent(wxMouseEvent& event)
1666{
1667 if ( event.Leaving() )
1668 {
1669 if ( m_pInTool )
1670 {
1671 OnMouseEnter(wxID_ANY);
1672 m_pInTool = NULL;
1673 }
1674
1675 event.Skip();
1676 return;
1677 }
1678
1679 if ( event.RightDown() )
1680 {
1681 // find the tool under the mouse
1682 wxCoord x = 0, y = 0;
1683 event.GetPosition(&x, &y);
1684
1685 wxToolBarToolBase *tool = FindToolForPosition(x, y);
1686 OnRightClick(tool ? tool->GetId() : -1, x, y);
1687 }
1688 else
1689 {
1690 event.Skip();
1691 }
1692}
1693
1694// This handler is needed to fix problems with painting the background of
1695// toolbar icons with comctl32.dll < 6.0.
1696void wxToolBar::OnEraseBackground(wxEraseEvent& event)
1697{
1698#ifdef wxHAS_MSW_BACKGROUND_ERASE_HOOK
1699 MSWDoEraseBackground(event.GetDC()->GetHDC());
1700#endif // wxHAS_MSW_BACKGROUND_ERASE_HOOK
1701}
1702
1703bool wxToolBar::HandleSize(WXWPARAM WXUNUSED(wParam), WXLPARAM lParam)
1704{
1705 // wait until we have some tools
1706 if ( !GetToolsCount() )
1707 return false;
1708
1709 // calculate our minor dimension ourselves - we're confusing the standard
1710 // logic (TB_AUTOSIZE) with our horizontal toolbars and other hacks
1711 const RECT r = wxGetTBItemRect(GetHwnd(), 0);
1712 if ( !r.right )
1713 return false;
1714
1715 int w, h;
1716
1717 if ( IsVertical() )
1718 {
1719 w = r.right - r.left;
1720 if ( m_maxRows )
1721 {
1722 w *= (m_nButtons + m_maxRows - 1)/m_maxRows;
1723 }
1724 h = HIWORD(lParam);
1725 }
1726 else
1727 {
1728 w = LOWORD(lParam);
1729 if (HasFlag( wxTB_FLAT ))
1730 h = r.bottom - r.top - 3;
1731 else
1732 h = r.bottom - r.top;
1733 if ( m_maxRows )
1734 {
1735 // FIXME: hardcoded separator line height...
1736 h += HasFlag(wxTB_NODIVIDER) ? 4 : 6;
1737 h *= m_maxRows;
1738 }
1739 }
1740
1741 if ( MAKELPARAM(w, h) != lParam )
1742 {
1743 // size really changed
1744 SetSize(w, h);
1745 }
1746
1747 UpdateStretchableSpacersSize();
1748
1749 // message processed
1750 return true;
1751}
1752
1753#ifdef wxHAS_MSW_BACKGROUND_ERASE_HOOK
1754
1755bool wxToolBar::HandlePaint(WXWPARAM wParam, WXLPARAM lParam)
1756{
1757 // we must prevent the dummy separators corresponding to controls or
1758 // stretchable spaces from being seen: we used to do it by painting over
1759 // them but this, unsurprisingly, resulted in a lot of flicker so now we
1760 // prevent the toolbar from painting them at all
1761
1762 // compute the region containing all dummy separators which we don't want
1763 // to be seen
1764 wxRegion rgnDummySeps;
1765 const wxRect rectTotal = GetClientRect();
1766 int toolIndex = 0;
1767 for ( wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst();
1768 node;
1769 node = node->GetNext() )
1770 {
1771 wxToolBarTool * const
1772 tool = static_cast<wxToolBarTool *>(node->GetData());
1773
1774 if ( tool->IsControl() || tool->IsStretchableSpace() )
1775 {
1776 const size_t numSeps = tool->GetSeparatorsCount();
1777 for ( size_t n = 0; n < numSeps; n++, toolIndex++ )
1778 {
1779 // for some reason TB_GETITEMRECT returns a rectangle 1 pixel
1780 // shorter than the full window size (at least under Windows 7)
1781 // but we need to erase the full width/height below
1782 RECT rcItem = wxGetTBItemRect(GetHwnd(), toolIndex);
1783 if ( IsVertical() )
1784 {
1785 rcItem.left = 0;
1786 rcItem.right = rectTotal.width;
1787 }
1788 else
1789 {
1790 rcItem.top = 0;
1791 rcItem.bottom = rectTotal.height;
1792 }
1793
1794 rgnDummySeps.Union(wxRectFromRECT(rcItem));
1795 }
1796 }
1797 else
1798 {
1799 // normal tools never correspond to more than one native button
1800 toolIndex++;
1801 }
1802 }
1803
1804 if ( rgnDummySeps.IsOk() )
1805 {
1806 // exclude the area occupied by the controls and stretchable spaces
1807 // from the update region to prevent the toolbar from drawing
1808 // separators in it
1809 if ( !::ValidateRgn(GetHwnd(), GetHrgnOf(rgnDummySeps)) )
1810 {
1811 wxLogLastError(wxT("ValidateRgn()"));
1812 }
1813 }
1814
1815 // still let the native control draw everything else normally but set up a
1816 // hook to be able to process the next WM_ERASEBKGND sent to our parent
1817 // because toolbar will ask it to erase its background from its WM_PAINT
1818 // handler (when using TBSTYLE_TRANSPARENT which we do always use)
1819 //
1820 // installing hook is not completely trivial as all kinds of strange
1821 // situations are possible: sometimes we can be called recursively from
1822 // inside the native toolbar WM_PAINT handler so the hook might already be
1823 // installed and sometimes the native toolbar might not send WM_ERASEBKGND
1824 // to the parent at all for whatever reason, so deal with all these cases
1825 wxWindow * const parent = GetParent();
1826 const bool hadHook = parent->MSWHasEraseBgHook();
1827 if ( !hadHook )
1828 GetParent()->MSWSetEraseBgHook(this);
1829
1830 MSWDefWindowProc(WM_PAINT, wParam, lParam);
1831
1832 if ( !hadHook )
1833 GetParent()->MSWSetEraseBgHook(NULL);
1834
1835
1836 if ( rgnDummySeps.IsOk() )
1837 {
1838 // erase the dummy separators region ourselves now as nobody painted
1839 // over them
1840 WindowHDC hdc(GetHwnd());
1841 ::SelectClipRgn(hdc, GetHrgnOf(rgnDummySeps));
1842 MSWDoEraseBackground(hdc);
1843 }
1844
1845 return true;
1846}
1847
1848WXHBRUSH wxToolBar::MSWGetToolbarBgBrush()
1849{
1850 // we conservatively use a solid brush here but we could also use a themed
1851 // brush by using DrawThemeBackground() to create a bitmap brush (it'd need
1852 // to be invalidated whenever the toolbar is resized and, also, correctly
1853 // aligned using SetBrushOrgEx() before each use -- there is code for doing
1854 // this in wxNotebook already so it'd need to be refactored into wxWindow)
1855 //
1856 // however inasmuch as there is a default background for the toolbar at all
1857 // (and this is not a trivial question as different applications use very
1858 // different colours), it seems to be a solid one and using REBAR
1859 // background brush as we used to do before doesn't look good at all under
1860 // Windows 7 (and probably Vista too), so for now we just keep it simple
1861 wxColour const
1862 colBg = m_hasBgCol ? GetBackgroundColour()
1863 : wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE);
1864 wxBrush * const
1865 brush = wxTheBrushList->FindOrCreateBrush(colBg);
1866
1867 return brush ? static_cast<WXHBRUSH>(brush->GetResourceHandle()) : 0;
1868}
1869
1870WXHBRUSH wxToolBar::MSWGetBgBrushForChild(WXHDC hDC, wxWindowMSW *child)
1871{
1872 WXHBRUSH hbr = wxToolBarBase::MSWGetBgBrushForChild(hDC, child);
1873 if ( hbr )
1874 return hbr;
1875
1876 // the base class version only returns a brush for erasing children
1877 // background if we have a non-default background colour but as the toolbar
1878 // doesn't erase its own background by default, we need to always do it for
1879 // (semi-)transparent children
1880 if ( child->GetParent() == this && child->HasTransparentBackground() )
1881 return MSWGetToolbarBgBrush();
1882
1883 return 0;
1884}
1885
1886void wxToolBar::MSWDoEraseBackground(WXHDC hDC)
1887{
1888 wxFillRect(GetHwnd(), (HDC)hDC, (HBRUSH)MSWGetToolbarBgBrush());
1889}
1890
1891bool wxToolBar::MSWEraseBgHook(WXHDC hDC)
1892{
1893 // toolbar WM_PAINT handler offsets the DC origin before sending
1894 // WM_ERASEBKGND to the parent but as we handle it in the toolbar itself,
1895 // we need to reset it back
1896 HDC hdc = (HDC)hDC;
1897 POINT ptOldOrg;
1898 if ( !::SetWindowOrgEx(hdc, 0, 0, &ptOldOrg) )
1899 {
1900 wxLogLastError(wxT("SetWindowOrgEx(tbar-bg-hdc)"));
1901 return false;
1902 }
1903
1904 MSWDoEraseBackground(hDC);
1905
1906 ::SetWindowOrgEx(hdc, ptOldOrg.x, ptOldOrg.y, NULL);
1907
1908 return true;
1909}
1910
1911#endif // wxHAS_MSW_BACKGROUND_ERASE_HOOK
1912
1913void wxToolBar::HandleMouseMove(WXWPARAM WXUNUSED(wParam), WXLPARAM lParam)
1914{
1915 wxCoord x = GET_X_LPARAM(lParam),
1916 y = GET_Y_LPARAM(lParam);
1917 wxToolBarToolBase* tool = FindToolForPosition( x, y );
1918
1919 // has the current tool changed?
1920 if ( tool != m_pInTool )
1921 {
1922 m_pInTool = tool;
1923 OnMouseEnter(tool ? tool->GetId() : wxID_ANY);
1924 }
1925}
1926
1927WXLRESULT wxToolBar::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
1928{
1929 switch ( nMsg )
1930 {
1931 case WM_MOUSEMOVE:
1932 // we don't handle mouse moves, so always pass the message to
1933 // wxControl::MSWWindowProc (HandleMouseMove just calls OnMouseEnter)
1934 HandleMouseMove(wParam, lParam);
1935 break;
1936
1937 case WM_SIZE:
1938 if ( HandleSize(wParam, lParam) )
1939 return 0;
1940 break;
1941
1942#ifdef wxHAS_MSW_BACKGROUND_ERASE_HOOK
1943 case WM_PAINT:
1944 // refreshing the controls in the toolbar inside a composite window
1945 // results in an endless stream of WM_PAINT messages -- and seems
1946 // to be unnecessary anyhow as everything works just fine without
1947 // any special workarounds in this case
1948 if ( !IsDoubleBuffered() && HandlePaint(wParam, lParam) )
1949 return 0;
1950 break;
1951#endif // wxHAS_MSW_BACKGROUND_ERASE_HOOK
1952 }
1953
1954 return wxControl::MSWWindowProc(nMsg, wParam, lParam);
1955}
1956
1957// ----------------------------------------------------------------------------
1958// private functions
1959// ----------------------------------------------------------------------------
1960
1961#ifdef wxREMAP_BUTTON_COLOURS
1962
1963WXHBITMAP wxToolBar::MapBitmap(WXHBITMAP bitmap, int width, int height)
1964{
1965 MemoryHDC hdcMem;
1966
1967 if ( !hdcMem )
1968 {
1969 wxLogLastError(wxT("CreateCompatibleDC"));
1970
1971 return bitmap;
1972 }
1973
1974 SelectInHDC bmpInHDC(hdcMem, (HBITMAP)bitmap);
1975
1976 if ( !bmpInHDC )
1977 {
1978 wxLogLastError(wxT("SelectObject"));
1979
1980 return bitmap;
1981 }
1982
1983 wxCOLORMAP *cmap = wxGetStdColourMap();
1984
1985 for ( int i = 0; i < width; i++ )
1986 {
1987 for ( int j = 0; j < height; j++ )
1988 {
1989 COLORREF pixel = ::GetPixel(hdcMem, i, j);
1990
1991 for ( size_t k = 0; k < wxSTD_COL_MAX; k++ )
1992 {
1993 COLORREF col = cmap[k].from;
1994 if ( abs(GetRValue(pixel) - GetRValue(col)) < 10 &&
1995 abs(GetGValue(pixel) - GetGValue(col)) < 10 &&
1996 abs(GetBValue(pixel) - GetBValue(col)) < 10 )
1997 {
1998 if ( cmap[k].to != pixel )
1999 ::SetPixel(hdcMem, i, j, cmap[k].to);
2000 break;
2001 }
2002 }
2003 }
2004 }
2005
2006 return bitmap;
2007}
2008
2009#endif // wxREMAP_BUTTON_COLOURS
2010
2011#endif // wxUSE_TOOLBAR