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