]> git.saurik.com Git - wxWidgets.git/blob - src/msw/tbar95.cpp
compilation fix for wxUSE_DBGHELP==0 after latest changes
[wxWidgets.git] / src / msw / tbar95.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/msw/tbar95.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/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/sysopt.h"
47
48 #include "wx/msw/private.h"
49
50 #if wxUSE_UXTHEME
51 #include "wx/msw/uxtheme.h"
52 #endif
53
54 // this define controls whether the code for button colours remapping (only
55 // useful for 16 or 256 colour images) is active at all, it's always turned off
56 // for CE where it doesn't compile (and is probably not needed anyhow) and may
57 // also be turned off for other systems if you always use 24bpp images and so
58 // never need it
59 #ifndef __WXWINCE__
60 #define wxREMAP_BUTTON_COLOURS
61 #endif // !__WXWINCE__
62
63 // ----------------------------------------------------------------------------
64 // constants
65 // ----------------------------------------------------------------------------
66
67 // these standard constants are not always defined in compilers headers
68
69 // Styles
70 #ifndef TBSTYLE_FLAT
71 #define TBSTYLE_LIST 0x1000
72 #define TBSTYLE_FLAT 0x0800
73 #endif
74
75 #ifndef TBSTYLE_TRANSPARENT
76 #define TBSTYLE_TRANSPARENT 0x8000
77 #endif
78
79 #ifndef TBSTYLE_TOOLTIPS
80 #define TBSTYLE_TOOLTIPS 0x0100
81 #endif
82
83 // Messages
84 #ifndef TB_GETSTYLE
85 #define TB_SETSTYLE (WM_USER + 56)
86 #define TB_GETSTYLE (WM_USER + 57)
87 #endif
88
89 #ifndef TB_HITTEST
90 #define TB_HITTEST (WM_USER + 69)
91 #endif
92
93 #ifndef TB_GETMAXSIZE
94 #define TB_GETMAXSIZE (WM_USER + 83)
95 #endif
96
97 // these values correspond to those used by comctl32.dll
98 #define DEFAULTBITMAPX 16
99 #define DEFAULTBITMAPY 15
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 = 0;
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 _T("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 private:
214 size_t m_nSepCount;
215 wxStaticText *m_staticText;
216
217 DECLARE_NO_COPY_CLASS(wxToolBarTool)
218 };
219
220 // ============================================================================
221 // implementation
222 // ============================================================================
223
224 // ----------------------------------------------------------------------------
225 // wxToolBarTool
226 // ----------------------------------------------------------------------------
227
228 wxToolBarToolBase *wxToolBar::CreateTool(int id,
229 const wxString& label,
230 const wxBitmap& bmpNormal,
231 const wxBitmap& bmpDisabled,
232 wxItemKind kind,
233 wxObject *clientData,
234 const wxString& shortHelp,
235 const wxString& longHelp)
236 {
237 return new wxToolBarTool(this, id, label, bmpNormal, bmpDisabled, kind,
238 clientData, shortHelp, longHelp);
239 }
240
241 wxToolBarToolBase *
242 wxToolBar::CreateTool(wxControl *control, const wxString& label)
243 {
244 return new wxToolBarTool(this, control, label);
245 }
246
247 // ----------------------------------------------------------------------------
248 // wxToolBar construction
249 // ----------------------------------------------------------------------------
250
251 void wxToolBar::Init()
252 {
253 m_hBitmap = 0;
254 m_disabledImgList = NULL;
255
256 m_nButtons = 0;
257
258 m_defaultWidth = DEFAULTBITMAPX;
259 m_defaultHeight = DEFAULTBITMAPY;
260
261 m_pInTool = NULL;
262 }
263
264 bool wxToolBar::Create(wxWindow *parent,
265 wxWindowID id,
266 const wxPoint& pos,
267 const wxSize& size,
268 long style,
269 const wxString& name)
270 {
271 // common initialisation
272 if ( !CreateControl(parent, id, pos, size, style, wxDefaultValidator, name) )
273 return false;
274
275 FixupStyle();
276
277 // MSW-specific initialisation
278 if ( !MSWCreateToolbar(pos, size) )
279 return false;
280
281 wxSetCCUnicodeFormat(GetHwnd());
282
283 // workaround for flat toolbar on Windows XP classic style: we have to set
284 // the style after creating the control; doing it at creation time doesn't work
285 #if wxUSE_UXTHEME
286 if ( style & wxTB_FLAT )
287 {
288 LRESULT style = GetMSWToolbarStyle();
289
290 if ( !(style & TBSTYLE_FLAT) )
291 ::SendMessage(GetHwnd(), TB_SETSTYLE, 0, style | TBSTYLE_FLAT);
292 }
293 #endif // wxUSE_UXTHEME
294
295 return true;
296 }
297
298 bool wxToolBar::MSWCreateToolbar(const wxPoint& pos, const wxSize& size)
299 {
300 if ( !MSWCreateControl(TOOLBARCLASSNAME, wxEmptyString, pos, size) )
301 return false;
302
303 // toolbar-specific post initialisation
304 ::SendMessage(GetHwnd(), TB_BUTTONSTRUCTSIZE, sizeof(TBBUTTON), 0);
305
306 #ifdef TB_SETEXTENDEDSTYLE
307 if ( wxApp::GetComCtl32Version() >= 471 )
308 ::SendMessage(GetHwnd(), TB_SETEXTENDEDSTYLE, 0, TBSTYLE_EX_DRAWDDARROWS);
309 #endif
310
311 return true;
312 }
313
314 void wxToolBar::Recreate()
315 {
316 const HWND hwndOld = GetHwnd();
317 if ( !hwndOld )
318 {
319 // we haven't been created yet, no need to recreate
320 return;
321 }
322
323 // get the position and size before unsubclassing the old toolbar
324 const wxPoint pos = GetPosition();
325 const wxSize size = GetSize();
326
327 UnsubclassWin();
328
329 if ( !MSWCreateToolbar(pos, size) )
330 {
331 // what can we do?
332 wxFAIL_MSG( _T("recreating the toolbar failed") );
333
334 return;
335 }
336
337 // reparent all our children under the new toolbar
338 for ( wxWindowList::compatibility_iterator node = m_children.GetFirst();
339 node;
340 node = node->GetNext() )
341 {
342 wxWindow *win = node->GetData();
343 if ( !win->IsTopLevel() )
344 ::SetParent(GetHwndOf(win), GetHwnd());
345 }
346
347 // only destroy the old toolbar now --
348 // after all the children had been reparented
349 ::DestroyWindow(hwndOld);
350
351 // it is for the old bitmap control and can't be used with the new one
352 if ( m_hBitmap )
353 {
354 ::DeleteObject((HBITMAP) m_hBitmap);
355 m_hBitmap = 0;
356 }
357
358 if ( m_disabledImgList )
359 {
360 delete m_disabledImgList;
361 m_disabledImgList = NULL;
362 }
363
364 Realize();
365 }
366
367 wxToolBar::~wxToolBar()
368 {
369 // we must refresh the frame size when the toolbar is deleted but the frame
370 // is not - otherwise toolbar leaves a hole in the place it used to occupy
371 wxFrame *frame = wxDynamicCast(GetParent(), wxFrame);
372 if ( frame && !frame->IsBeingDeleted() )
373 frame->SendSizeEvent();
374
375 if ( m_hBitmap )
376 ::DeleteObject((HBITMAP) m_hBitmap);
377
378 delete m_disabledImgList;
379 }
380
381 wxSize wxToolBar::DoGetBestSize() const
382 {
383 wxSize sizeBest;
384
385 SIZE size;
386 if ( !::SendMessage(GetHwnd(), TB_GETMAXSIZE, 0, (LPARAM)&size) )
387 {
388 // maybe an old (< 0x400) Windows version? try to approximate the
389 // toolbar size ourselves
390 sizeBest = GetToolSize();
391 sizeBest.y += 2 * ::GetSystemMetrics(SM_CYBORDER); // Add borders
392 sizeBest.x *= GetToolsCount();
393
394 // reverse horz and vertical components if necessary
395 if ( IsVertical() )
396 {
397 int t = sizeBest.x;
398 sizeBest.x = sizeBest.y;
399 sizeBest.y = t;
400 }
401 }
402 else
403 {
404 sizeBest.x = size.cx;
405 sizeBest.y = size.cy;
406 }
407
408 if (!IsVertical() && !(GetWindowStyle() & wxTB_NODIVIDER))
409 sizeBest.y += 1;
410
411 CacheBestSize(sizeBest);
412
413 return sizeBest;
414 }
415
416 WXDWORD wxToolBar::MSWGetStyle(long style, WXDWORD *exstyle) const
417 {
418 // toolbars never have border, giving one to them results in broken
419 // appearance
420 WXDWORD msStyle = wxControl::MSWGetStyle
421 (
422 (style & ~wxBORDER_MASK) | wxBORDER_NONE, exstyle
423 );
424
425 if ( !(style & wxTB_NO_TOOLTIPS) )
426 msStyle |= TBSTYLE_TOOLTIPS;
427
428 if ( style & (wxTB_FLAT | wxTB_HORZ_LAYOUT) )
429 {
430 // static as it doesn't change during the program lifetime
431 static const int s_verComCtl = wxApp::GetComCtl32Version();
432
433 // comctl32.dll 4.00 doesn't support the flat toolbars and using this
434 // style with 6.00 (part of Windows XP) leads to the toolbar with
435 // incorrect background colour - and not using it still results in the
436 // correct (flat) toolbar, so don't use it there
437 if ( s_verComCtl > 400 && s_verComCtl < 600 )
438 msStyle |= TBSTYLE_FLAT | TBSTYLE_TRANSPARENT;
439
440 if ( s_verComCtl >= 470 && style & wxTB_HORZ_LAYOUT )
441 msStyle |= TBSTYLE_LIST;
442 }
443
444 if ( style & wxTB_NODIVIDER )
445 msStyle |= CCS_NODIVIDER;
446
447 if ( style & wxTB_NOALIGN )
448 msStyle |= CCS_NOPARENTALIGN;
449
450 if ( style & wxTB_VERTICAL )
451 msStyle |= CCS_VERT;
452
453 if( style & wxTB_BOTTOM )
454 msStyle |= CCS_BOTTOM;
455
456 if ( style & wxTB_RIGHT )
457 msStyle |= CCS_RIGHT;
458
459 return msStyle;
460 }
461
462 // ----------------------------------------------------------------------------
463 // adding/removing tools
464 // ----------------------------------------------------------------------------
465
466 bool wxToolBar::DoInsertTool(size_t WXUNUSED(pos), wxToolBarToolBase *tool)
467 {
468 // nothing special to do here - we really create the toolbar buttons in
469 // Realize() later
470 tool->Attach(this);
471
472 InvalidateBestSize();
473 return true;
474 }
475
476 bool wxToolBar::DoDeleteTool(size_t pos, wxToolBarToolBase *tool)
477 {
478 // the main difficulty we have here is with the controls in the toolbars:
479 // as we (sometimes) use several separators to cover up the space used by
480 // them, the indices are not the same for us and the toolbar
481
482 // first determine the position of the first button to delete: it may be
483 // different from pos if we use several separators to cover the space used
484 // by a control
485 wxToolBarToolsList::compatibility_iterator node;
486 for ( node = m_tools.GetFirst(); node; node = node->GetNext() )
487 {
488 wxToolBarToolBase *tool2 = node->GetData();
489 if ( tool2 == tool )
490 {
491 // let node point to the next node in the list
492 node = node->GetNext();
493
494 break;
495 }
496
497 if ( tool2->IsControl() )
498 pos += ((wxToolBarTool *)tool2)->GetSeparatorsCount() - 1;
499 }
500
501 // now determine the number of buttons to delete and the area taken by them
502 size_t nButtonsToDelete = 1;
503
504 // get the size of the button we're going to delete
505 RECT r;
506 if ( !::SendMessage(GetHwnd(), TB_GETITEMRECT, pos, (LPARAM)&r) )
507 {
508 wxLogLastError(_T("TB_GETITEMRECT"));
509 }
510
511 int width = r.right - r.left;
512
513 if ( tool->IsControl() )
514 {
515 nButtonsToDelete = ((wxToolBarTool *)tool)->GetSeparatorsCount();
516 width *= nButtonsToDelete;
517 tool->GetControl()->Destroy();
518 }
519
520 // do delete all buttons
521 m_nButtons -= nButtonsToDelete;
522 while ( nButtonsToDelete-- > 0 )
523 {
524 if ( !::SendMessage(GetHwnd(), TB_DELETEBUTTON, pos, 0) )
525 {
526 wxLogLastError(wxT("TB_DELETEBUTTON"));
527
528 return false;
529 }
530 }
531
532 tool->Detach();
533
534 // and finally reposition all the controls after this button (the toolbar
535 // takes care of all normal items)
536 for ( /* node -> first after deleted */ ; node; node = node->GetNext() )
537 {
538 wxToolBarTool *tool2 = (wxToolBarTool*)node->GetData();
539 if ( tool2->IsControl() )
540 {
541 int x;
542 wxControl *control = tool2->GetControl();
543 control->GetPosition(&x, NULL);
544 control->Move(x - width, wxDefaultCoord);
545
546 wxStaticText* staticText = tool2->GetStaticText();
547 staticText->Move(x - width, wxDefaultCoord);
548 }
549 }
550
551 InvalidateBestSize();
552
553 return true;
554 }
555
556 void wxToolBar::CreateDisabledImageList()
557 {
558 if (m_disabledImgList != NULL)
559 {
560 delete m_disabledImgList;
561 m_disabledImgList = NULL;
562 }
563
564 // as we can't use disabled image list with older versions of comctl32.dll,
565 // don't even bother creating it
566 if ( wxApp::GetComCtl32Version() >= 470 )
567 {
568 // search for the first disabled button img in the toolbar, if any
569 for ( wxToolBarToolsList::compatibility_iterator
570 node = m_tools.GetFirst(); node; node = node->GetNext() )
571 {
572 wxToolBarToolBase *tool = node->GetData();
573 wxBitmap bmpDisabled = tool->GetDisabledBitmap();
574 if ( bmpDisabled.Ok() )
575 {
576 m_disabledImgList = new wxImageList
577 (
578 m_defaultWidth,
579 m_defaultHeight,
580 bmpDisabled.GetMask() != NULL,
581 GetToolsCount()
582 );
583 break;
584 }
585 }
586
587 // we don't have any disabled bitmaps
588 }
589 }
590
591 bool wxToolBar::Realize()
592 {
593 const size_t nTools = GetToolsCount();
594 if ( nTools == 0 )
595 // nothing to do
596 return true;
597
598 #ifdef wxREMAP_BUTTON_COLOURS
599 // don't change the values of these constants, they can be set from the
600 // user code via wxSystemOptions
601 enum
602 {
603 Remap_None = -1,
604 Remap_Bg,
605 Remap_Buttons,
606 Remap_TransparentBg
607 };
608
609 // the user-specified option overrides anything, but if it wasn't set, only
610 // remap the buttons on 8bpp displays as otherwise the bitmaps usually look
611 // much worse after remapping
612 static const wxChar *remapOption = wxT("msw.remap");
613 const int remapValue = wxSystemOptions::HasOption(remapOption)
614 ? wxSystemOptions::GetOptionInt(remapOption)
615 : wxDisplayDepth() <= 8 ? Remap_Buttons
616 : Remap_None;
617
618 #endif // wxREMAP_BUTTON_COLOURS
619
620 // delete all old buttons, if any
621 for ( size_t pos = 0; pos < m_nButtons; pos++ )
622 {
623 if ( !::SendMessage(GetHwnd(), TB_DELETEBUTTON, 0, 0) )
624 {
625 wxLogDebug(wxT("TB_DELETEBUTTON failed"));
626 }
627 }
628
629 // First, add the bitmap: we use one bitmap for all toolbar buttons
630 // ----------------------------------------------------------------
631
632 wxToolBarToolsList::compatibility_iterator node;
633 int bitmapId = 0;
634
635 wxSize sizeBmp;
636 if ( HasFlag(wxTB_NOICONS) )
637 {
638 // no icons, don't leave space for them
639 sizeBmp.x =
640 sizeBmp.y = 0;
641 }
642 else // do show icons
643 {
644 // if we already have a bitmap, we'll replace the existing one --
645 // otherwise we'll install a new one
646 HBITMAP oldToolBarBitmap = (HBITMAP)m_hBitmap;
647
648 sizeBmp.x = m_defaultWidth;
649 sizeBmp.y = m_defaultHeight;
650
651 const wxCoord totalBitmapWidth = m_defaultWidth *
652 wx_truncate_cast(wxCoord, nTools),
653 totalBitmapHeight = m_defaultHeight;
654
655 // Create a bitmap and copy all the tool bitmaps into it
656 wxMemoryDC dcAllButtons;
657 wxBitmap bitmap(totalBitmapWidth, totalBitmapHeight);
658 dcAllButtons.SelectObject(bitmap);
659
660 #ifdef wxREMAP_BUTTON_COLOURS
661 if ( remapValue != Remap_TransparentBg )
662 #endif // wxREMAP_BUTTON_COLOURS
663 {
664 // VZ: why do we hardcode grey colour for CE?
665 dcAllButtons.SetBackground(wxBrush(
666 #ifdef __WXWINCE__
667 wxColour(0xc0, 0xc0, 0xc0)
668 #else // !__WXWINCE__
669 GetBackgroundColour()
670 #endif // __WXWINCE__/!__WXWINCE__
671 ));
672 dcAllButtons.Clear();
673 }
674
675 m_hBitmap = bitmap.GetHBITMAP();
676 HBITMAP hBitmap = (HBITMAP)m_hBitmap;
677
678 #ifdef wxREMAP_BUTTON_COLOURS
679 if ( remapValue == Remap_Bg )
680 {
681 dcAllButtons.SelectObject(wxNullBitmap);
682
683 // Even if we're not remapping the bitmap
684 // content, we still have to remap the background.
685 hBitmap = (HBITMAP)MapBitmap((WXHBITMAP) hBitmap,
686 totalBitmapWidth, totalBitmapHeight);
687
688 dcAllButtons.SelectObject(bitmap);
689 }
690 #endif // wxREMAP_BUTTON_COLOURS
691
692 // the button position
693 wxCoord x = 0;
694
695 // the number of buttons (not separators)
696 int nButtons = 0;
697
698 CreateDisabledImageList();
699 for ( node = m_tools.GetFirst(); node; node = node->GetNext() )
700 {
701 wxToolBarToolBase *tool = node->GetData();
702 if ( tool->IsButton() )
703 {
704 const wxBitmap& bmp = tool->GetNormalBitmap();
705
706 const int w = bmp.GetWidth();
707 const int h = bmp.GetHeight();
708
709 if ( bmp.Ok() )
710 {
711 int xOffset = wxMax(0, (m_defaultWidth - w)/2);
712 int yOffset = wxMax(0, (m_defaultHeight - h)/2);
713
714 // notice the last parameter: do use mask
715 dcAllButtons.DrawBitmap(bmp, x + xOffset, yOffset, true);
716 }
717 else
718 {
719 wxFAIL_MSG( _T("invalid tool button bitmap") );
720 }
721
722 // also deal with disabled bitmap if we want to use them
723 if ( m_disabledImgList )
724 {
725 wxBitmap bmpDisabled = tool->GetDisabledBitmap();
726 #if wxUSE_IMAGE && wxUSE_WXDIB
727 if ( !bmpDisabled.Ok() )
728 {
729 // no disabled bitmap specified but we still need to
730 // fill the space in the image list with something, so
731 // we grey out the normal bitmap
732 wxImage
733 imgGreyed = bmp.ConvertToImage().ConvertToGreyscale();
734
735 #ifdef wxREMAP_BUTTON_COLOURS
736 if ( remapValue == Remap_Buttons )
737 {
738 // we need to have light grey background colour for
739 // MapBitmap() to work correctly
740 for ( int y = 0; y < h; y++ )
741 {
742 for ( int x = 0; x < w; x++ )
743 {
744 if ( imgGreyed.IsTransparent(x, y) )
745 imgGreyed.SetRGB(x, y,
746 wxLIGHT_GREY->Red(),
747 wxLIGHT_GREY->Green(),
748 wxLIGHT_GREY->Blue());
749 }
750 }
751 }
752 #endif // wxREMAP_BUTTON_COLOURS
753
754 bmpDisabled = wxBitmap(imgGreyed);
755 }
756 #endif // wxUSE_IMAGE
757
758 #ifdef wxREMAP_BUTTON_COLOURS
759 if ( remapValue == Remap_Buttons )
760 MapBitmap(bmpDisabled.GetHBITMAP(), w, h);
761 #endif // wxREMAP_BUTTON_COLOURS
762
763 m_disabledImgList->Add(bmpDisabled);
764 }
765
766 // still inc width and number of buttons because otherwise the
767 // subsequent buttons will all be shifted which is rather confusing
768 // (and like this you'd see immediately which bitmap was bad)
769 x += m_defaultWidth;
770 nButtons++;
771 }
772 }
773
774 dcAllButtons.SelectObject(wxNullBitmap);
775
776 // don't delete this HBITMAP!
777 bitmap.SetHBITMAP(0);
778
779 #ifdef wxREMAP_BUTTON_COLOURS
780 if ( remapValue == Remap_Buttons )
781 {
782 // Map to system colours
783 hBitmap = (HBITMAP)MapBitmap((WXHBITMAP) hBitmap,
784 totalBitmapWidth, totalBitmapHeight);
785 }
786 #endif // wxREMAP_BUTTON_COLOURS
787
788 bool addBitmap = true;
789
790 if ( oldToolBarBitmap )
791 {
792 #ifdef TB_REPLACEBITMAP
793 if ( wxApp::GetComCtl32Version() >= 400 )
794 {
795 TBREPLACEBITMAP replaceBitmap;
796 replaceBitmap.hInstOld = NULL;
797 replaceBitmap.hInstNew = NULL;
798 replaceBitmap.nIDOld = (UINT) oldToolBarBitmap;
799 replaceBitmap.nIDNew = (UINT) hBitmap;
800 replaceBitmap.nButtons = nButtons;
801 if ( !::SendMessage(GetHwnd(), TB_REPLACEBITMAP,
802 0, (LPARAM) &replaceBitmap) )
803 {
804 wxFAIL_MSG(wxT("Could not replace the old bitmap"));
805 }
806
807 ::DeleteObject(oldToolBarBitmap);
808
809 // already done
810 addBitmap = false;
811 }
812 else
813 #endif // TB_REPLACEBITMAP
814 {
815 // we can't replace the old bitmap, so we will add another one
816 // (awfully inefficient, but what else to do?) and shift the bitmap
817 // indices accordingly
818 addBitmap = true;
819
820 bitmapId = m_nButtons;
821 }
822 }
823
824 if ( addBitmap ) // no old bitmap or we can't replace it
825 {
826 TBADDBITMAP addBitmap;
827 addBitmap.hInst = 0;
828 addBitmap.nID = (UINT) hBitmap;
829 if ( ::SendMessage(GetHwnd(), TB_ADDBITMAP,
830 (WPARAM) nButtons, (LPARAM)&addBitmap) == -1 )
831 {
832 wxFAIL_MSG(wxT("Could not add bitmap to toolbar"));
833 }
834 }
835
836 // disable image lists are only supported in comctl32.dll 4.70+
837 if ( wxApp::GetComCtl32Version() >= 470 )
838 {
839 HIMAGELIST hil = m_disabledImgList
840 ? GetHimagelistOf(m_disabledImgList)
841 : 0;
842
843 // notice that we set the image list even if don't have one right
844 // now as we could have it before and need to reset it in this case
845 HIMAGELIST oldImageList = (HIMAGELIST)
846 ::SendMessage(GetHwnd(), TB_SETDISABLEDIMAGELIST, 0, (LPARAM)hil);
847
848 // delete previous image list if any
849 if ( oldImageList )
850 ::DeleteObject(oldImageList);
851 }
852 }
853
854 // don't call SetToolBitmapSize() as we don't want to change the values of
855 // m_defaultWidth/Height
856 if ( !::SendMessage(GetHwnd(), TB_SETBITMAPSIZE, 0,
857 MAKELONG(sizeBmp.x, sizeBmp.y)) )
858 {
859 wxLogLastError(_T("TB_SETBITMAPSIZE"));
860 }
861
862 // Next add the buttons and separators
863 // -----------------------------------
864
865 TBBUTTON *buttons = new TBBUTTON[nTools];
866
867 // this array will hold the indices of all controls in the toolbar
868 wxArrayInt controlIds;
869
870 bool lastWasRadio = false;
871 int i = 0;
872 for ( node = m_tools.GetFirst(); node; node = node->GetNext() )
873 {
874 wxToolBarToolBase *tool = node->GetData();
875
876 // don't add separators to the vertical toolbar with old comctl32.dll
877 // versions as they didn't handle this properly
878 if ( IsVertical() && tool->IsSeparator() &&
879 wxApp::GetComCtl32Version() <= 472 )
880 {
881 continue;
882 }
883
884 TBBUTTON& button = buttons[i];
885
886 wxZeroMemory(button);
887
888 bool isRadio = false;
889 switch ( tool->GetStyle() )
890 {
891 case wxTOOL_STYLE_CONTROL:
892 button.idCommand = tool->GetId();
893 // fall through: create just a separator too
894
895 case wxTOOL_STYLE_SEPARATOR:
896 button.fsState = TBSTATE_ENABLED;
897 button.fsStyle = TBSTYLE_SEP;
898 break;
899
900 case wxTOOL_STYLE_BUTTON:
901 if ( !HasFlag(wxTB_NOICONS) )
902 button.iBitmap = bitmapId;
903
904 if ( HasFlag(wxTB_TEXT) )
905 {
906 const wxString& label = tool->GetLabel();
907 if ( !label.empty() )
908 button.iString = (int)label.wx_str();
909 }
910
911 button.idCommand = tool->GetId();
912
913 if ( tool->IsEnabled() )
914 button.fsState |= TBSTATE_ENABLED;
915 if ( tool->IsToggled() )
916 button.fsState |= TBSTATE_CHECKED;
917
918 switch ( tool->GetKind() )
919 {
920 case wxITEM_RADIO:
921 button.fsStyle = TBSTYLE_CHECKGROUP;
922
923 if ( !lastWasRadio )
924 {
925 // the first item in the radio group is checked by
926 // default to be consistent with wxGTK and the menu
927 // radio items
928 button.fsState |= TBSTATE_CHECKED;
929
930 if (tool->Toggle(true))
931 {
932 DoToggleTool(tool, true);
933 }
934 }
935 else if (tool->IsToggled())
936 {
937 wxToolBarToolsList::compatibility_iterator nodePrev = node->GetPrevious();
938 int prevIndex = i - 1;
939 while ( nodePrev )
940 {
941 TBBUTTON& prevButton = buttons[prevIndex];
942 wxToolBarToolBase *tool = nodePrev->GetData();
943 if ( !tool->IsButton() || tool->GetKind() != wxITEM_RADIO )
944 break;
945
946 if ( tool->Toggle(false) )
947 DoToggleTool(tool, false);
948
949 prevButton.fsState = TBSTATE_ENABLED;
950 nodePrev = nodePrev->GetPrevious();
951 prevIndex--;
952 }
953 }
954
955 isRadio = true;
956 break;
957
958 case wxITEM_CHECK:
959 button.fsStyle = TBSTYLE_CHECK;
960 break;
961
962 case wxITEM_NORMAL:
963 button.fsStyle = TBSTYLE_BUTTON;
964 break;
965
966 case wxITEM_DROPDOWN:
967 button.fsStyle = TBSTYLE_DROPDOWN;
968 break;
969
970 default:
971 wxFAIL_MSG( _T("unexpected toolbar button kind") );
972 button.fsStyle = TBSTYLE_BUTTON;
973 break;
974 }
975
976 bitmapId++;
977 break;
978 }
979
980 lastWasRadio = isRadio;
981
982 i++;
983 }
984
985 if ( !::SendMessage(GetHwnd(), TB_ADDBUTTONS, (WPARAM)i, (LPARAM)buttons) )
986 {
987 wxLogLastError(wxT("TB_ADDBUTTONS"));
988 }
989
990 delete [] buttons;
991
992 // Deal with the controls finally
993 // ------------------------------
994
995 // adjust the controls size to fit nicely in the toolbar
996 int y = 0;
997 size_t index = 0;
998 for ( node = m_tools.GetFirst(); node; node = node->GetNext(), index++ )
999 {
1000 wxToolBarTool *tool = (wxToolBarTool*)node->GetData();
1001
1002 // we calculate the running y coord for vertical toolbars so we need to
1003 // get the items size for all items but for the horizontal ones we
1004 // don't need to deal with the non controls
1005 bool isControl = tool->IsControl();
1006 if ( !isControl && !IsVertical() )
1007 continue;
1008
1009 // note that we use TB_GETITEMRECT and not TB_GETRECT because the
1010 // latter only appeared in v4.70 of comctl32.dll
1011 RECT r;
1012 if ( !::SendMessage(GetHwnd(), TB_GETITEMRECT,
1013 index, (LPARAM)(LPRECT)&r) )
1014 {
1015 wxLogLastError(wxT("TB_GETITEMRECT"));
1016 }
1017
1018 if ( !isControl )
1019 {
1020 // can only be control if isVertical
1021 y += r.bottom - r.top;
1022
1023 continue;
1024 }
1025
1026 wxControl *control = tool->GetControl();
1027 wxStaticText * const staticText = tool->GetStaticText();
1028
1029 wxSize size = control->GetSize();
1030 wxSize staticTextSize;
1031 if ( staticText )
1032 {
1033 staticTextSize = staticText->GetSize();
1034 staticTextSize.y += 3; // margin between control and its label
1035 }
1036
1037 // the position of the leftmost controls corner
1038 int left = wxDefaultCoord;
1039
1040 // TB_SETBUTTONINFO message is only supported by comctl32.dll 4.71+
1041 #ifdef TB_SETBUTTONINFO
1042 // available in headers, now check whether it is available now
1043 // (during run-time)
1044 if ( wxApp::GetComCtl32Version() >= 471 )
1045 {
1046 // set the (underlying) separators width to be that of the
1047 // control
1048 TBBUTTONINFO tbbi;
1049 tbbi.cbSize = sizeof(tbbi);
1050 tbbi.dwMask = TBIF_SIZE;
1051 tbbi.cx = (WORD)size.x;
1052 if ( !::SendMessage(GetHwnd(), TB_SETBUTTONINFO,
1053 tool->GetId(), (LPARAM)&tbbi) )
1054 {
1055 // the id is probably invalid?
1056 wxLogLastError(wxT("TB_SETBUTTONINFO"));
1057 }
1058 }
1059 else
1060 #endif // comctl32.dll 4.71
1061 // TB_SETBUTTONINFO unavailable
1062 {
1063 // try adding several separators to fit the controls width
1064 int widthSep = r.right - r.left;
1065 left = r.left;
1066
1067 TBBUTTON tbb;
1068 wxZeroMemory(tbb);
1069 tbb.idCommand = 0;
1070 tbb.fsState = TBSTATE_ENABLED;
1071 tbb.fsStyle = TBSTYLE_SEP;
1072
1073 size_t nSeparators = size.x / widthSep;
1074 for ( size_t nSep = 0; nSep < nSeparators; nSep++ )
1075 {
1076 if ( !::SendMessage(GetHwnd(), TB_INSERTBUTTON,
1077 index, (LPARAM)&tbb) )
1078 {
1079 wxLogLastError(wxT("TB_INSERTBUTTON"));
1080 }
1081
1082 index++;
1083 }
1084
1085 // remember the number of separators we used - we'd have to
1086 // delete all of them later
1087 ((wxToolBarTool *)tool)->SetSeparatorsCount(nSeparators);
1088
1089 // adjust the controls width to exactly cover the separators
1090 size.x = (nSeparators + 1)*widthSep;
1091 control->SetSize(size.x, wxDefaultCoord);
1092 }
1093
1094 // position the control itself correctly vertically centering it on the
1095 // icon area of the toolbar
1096 int height = r.bottom - r.top - staticTextSize.y;
1097
1098 int diff = height - size.y;
1099 if ( diff < 0 || !HasFlag(wxTB_TEXT) )
1100 {
1101 // not enough room for the static text
1102 if ( staticText )
1103 staticText->Hide();
1104
1105 // recalculate height & diff without the staticText control
1106 height = r.bottom - r.top;
1107 diff = height - size.y;
1108 if ( diff < 0 )
1109 {
1110 // the control is too high, resize to fit
1111 control->SetSize(wxDefaultCoord, height - 2);
1112
1113 diff = 2;
1114 }
1115 }
1116 else // enough space for both the control and the label
1117 {
1118 if ( staticText )
1119 staticText->Show();
1120 }
1121
1122 int top;
1123 if ( IsVertical() )
1124 {
1125 left = 0;
1126 top = y;
1127
1128 y += height + 2 * GetMargins().y;
1129 }
1130 else // horizontal toolbar
1131 {
1132 if ( left == wxDefaultCoord )
1133 left = r.left;
1134
1135 top = r.top;
1136 }
1137
1138 control->Move(left, top + (diff + 1) / 2);
1139 if ( staticText )
1140 {
1141 staticText->Move(left + (size.x - staticTextSize.x)/2,
1142 r.bottom - staticTextSize.y);
1143 }
1144 }
1145
1146 // the max index is the "real" number of buttons - i.e. counting even the
1147 // separators which we added just for aligning the controls
1148 m_nButtons = index;
1149
1150 if ( !IsVertical() )
1151 {
1152 if ( m_maxRows == 0 )
1153 // if not set yet, only one row
1154 SetRows(1);
1155 }
1156 else if ( m_nButtons > 0 ) // vertical non empty toolbar
1157 {
1158 // if not set yet, have one column
1159 m_maxRows = 1;
1160 SetRows(m_nButtons);
1161 }
1162
1163 InvalidateBestSize();
1164 UpdateSize();
1165
1166 return true;
1167 }
1168
1169 // ----------------------------------------------------------------------------
1170 // message handlers
1171 // ----------------------------------------------------------------------------
1172
1173 bool wxToolBar::MSWCommand(WXUINT WXUNUSED(cmd), WXWORD id)
1174 {
1175 wxToolBarToolBase *tool = FindById((int)id);
1176 if ( !tool )
1177 return false;
1178
1179 bool toggled = false; // just to suppress warnings
1180
1181 if ( tool->CanBeToggled() )
1182 {
1183 LRESULT state = ::SendMessage(GetHwnd(), TB_GETSTATE, id, 0);
1184 toggled = (state & TBSTATE_CHECKED) != 0;
1185
1186 // ignore the event when a radio button is released, as this doesn't
1187 // seem to happen at all, and is handled otherwise
1188 if ( tool->GetKind() == wxITEM_RADIO && !toggled )
1189 return true;
1190
1191 tool->Toggle(toggled);
1192 UnToggleRadioGroup(tool);
1193 }
1194
1195 // OnLeftClick() can veto the button state change - for buttons which
1196 // may be toggled only, of couse
1197 if ( !OnLeftClick((int)id, toggled) && tool->CanBeToggled() )
1198 {
1199 // revert back
1200 tool->Toggle(!toggled);
1201
1202 ::SendMessage(GetHwnd(), TB_CHECKBUTTON, id, MAKELONG(!toggled, 0));
1203 }
1204
1205 return true;
1206 }
1207
1208 bool wxToolBar::MSWOnNotify(int WXUNUSED(idCtrl),
1209 WXLPARAM lParam,
1210 WXLPARAM *WXUNUSED(result))
1211 {
1212 LPNMHDR hdr = (LPNMHDR)lParam;
1213 if ( hdr->code == TBN_DROPDOWN )
1214 {
1215 LPNMTOOLBAR tbhdr = (LPNMTOOLBAR)lParam;
1216
1217 wxCommandEvent evt(wxEVT_COMMAND_TOOL_DROPDOWN_CLICKED, tbhdr->iItem);
1218 if ( GetEventHandler()->ProcessEvent(evt) )
1219 {
1220 // Event got handled, don't display default popup menu
1221 return false;
1222 }
1223
1224 const wxToolBarToolBase * const tool = FindById(tbhdr->iItem);
1225 wxCHECK_MSG( tool, false, _T("drop down message for unknown tool") );
1226
1227 wxMenu * const menu = tool->GetDropdownMenu();
1228 if ( !menu )
1229 return false;
1230
1231 // Display popup menu below button
1232 RECT r;
1233 if (::SendMessage(GetHwnd(), TB_GETITEMRECT, GetToolPos(tbhdr->iItem), (LPARAM)&r))
1234 PopupMenu(menu, r.left, r.bottom);
1235
1236 return true;
1237 }
1238
1239
1240 if( !HasFlag(wxTB_NO_TOOLTIPS) )
1241 {
1242 #if wxUSE_TOOLTIPS
1243 // First check if this applies to us
1244
1245 // the tooltips control created by the toolbar is sometimes Unicode, even
1246 // in an ANSI application - this seems to be a bug in comctl32.dll v5
1247 UINT code = hdr->code;
1248 if ( (code != (UINT) TTN_NEEDTEXTA) && (code != (UINT) TTN_NEEDTEXTW) )
1249 return false;
1250
1251 HWND toolTipWnd = (HWND)::SendMessage(GetHwnd(), TB_GETTOOLTIPS, 0, 0);
1252 if ( toolTipWnd != hdr->hwndFrom )
1253 return false;
1254
1255 LPTOOLTIPTEXT ttText = (LPTOOLTIPTEXT)lParam;
1256 int id = (int)ttText->hdr.idFrom;
1257
1258 wxToolBarToolBase *tool = FindById(id);
1259 if ( tool )
1260 return HandleTooltipNotify(code, lParam, tool->GetShortHelp());
1261 #else
1262 wxUnusedVar(lParam);
1263 #endif
1264 }
1265
1266 return false;
1267 }
1268
1269 // ----------------------------------------------------------------------------
1270 // toolbar geometry
1271 // ----------------------------------------------------------------------------
1272
1273 void wxToolBar::SetToolBitmapSize(const wxSize& size)
1274 {
1275 wxToolBarBase::SetToolBitmapSize(size);
1276
1277 ::SendMessage(GetHwnd(), TB_SETBITMAPSIZE, 0, MAKELONG(size.x, size.y));
1278 }
1279
1280 void wxToolBar::SetRows(int nRows)
1281 {
1282 if ( nRows == m_maxRows )
1283 {
1284 // avoid resizing the frame uselessly
1285 return;
1286 }
1287
1288 // TRUE in wParam means to create at least as many rows, FALSE -
1289 // at most as many
1290 RECT rect;
1291 ::SendMessage(GetHwnd(), TB_SETROWS,
1292 MAKEWPARAM(nRows, !(GetWindowStyle() & wxTB_VERTICAL)),
1293 (LPARAM) &rect);
1294
1295 m_maxRows = nRows;
1296
1297 UpdateSize();
1298 }
1299
1300 // The button size is bigger than the bitmap size
1301 wxSize wxToolBar::GetToolSize() const
1302 {
1303 // TB_GETBUTTONSIZE is supported from version 4.70
1304 #if defined(_WIN32_IE) && (_WIN32_IE >= 0x300 ) \
1305 && !( defined(__GNUWIN32__) && !wxCHECK_W32API_VERSION( 1, 0 ) ) \
1306 && !defined (__DIGITALMARS__)
1307 if ( wxApp::GetComCtl32Version() >= 470 )
1308 {
1309 DWORD dw = ::SendMessage(GetHwnd(), TB_GETBUTTONSIZE, 0, 0);
1310
1311 return wxSize(LOWORD(dw), HIWORD(dw));
1312 }
1313 else
1314 #endif // comctl32.dll 4.70+
1315 {
1316 // defaults
1317 return wxSize(m_defaultWidth + 8, m_defaultHeight + 7);
1318 }
1319 }
1320
1321 static
1322 wxToolBarToolBase *GetItemSkippingDummySpacers(const wxToolBarToolsList& tools,
1323 size_t index )
1324 {
1325 wxToolBarToolsList::compatibility_iterator current = tools.GetFirst();
1326
1327 for ( ; current ; current = current->GetNext() )
1328 {
1329 if ( index == 0 )
1330 return current->GetData();
1331
1332 wxToolBarTool *tool = (wxToolBarTool *)current->GetData();
1333 size_t separators = tool->GetSeparatorsCount();
1334
1335 // if it is a normal button, sepcount == 0, so skip 1 item (the button)
1336 // otherwise, skip as many items as the separator count, plus the
1337 // control itself
1338 index -= separators ? separators + 1 : 1;
1339 }
1340
1341 return 0;
1342 }
1343
1344 wxToolBarToolBase *wxToolBar::FindToolForPosition(wxCoord x, wxCoord y) const
1345 {
1346 POINT pt;
1347 pt.x = x;
1348 pt.y = y;
1349 int index = (int)::SendMessage(GetHwnd(), TB_HITTEST, 0, (LPARAM)&pt);
1350
1351 // MBN: when the point ( x, y ) is close to the toolbar border
1352 // TB_HITTEST returns m_nButtons ( not -1 )
1353 if ( index < 0 || (size_t)index >= m_nButtons )
1354 // it's a separator or there is no tool at all there
1355 return (wxToolBarToolBase *)NULL;
1356
1357 // when TB_SETBUTTONINFO is available (both during compile- and run-time),
1358 // we don't use the dummy separators hack
1359 #ifdef TB_SETBUTTONINFO
1360 if ( wxApp::GetComCtl32Version() >= 471 )
1361 {
1362 return m_tools.Item((size_t)index)->GetData();
1363 }
1364 else
1365 #endif // TB_SETBUTTONINFO
1366 {
1367 return GetItemSkippingDummySpacers( m_tools, (size_t) index );
1368 }
1369 }
1370
1371 void wxToolBar::UpdateSize()
1372 {
1373 wxPoint pos = GetPosition();
1374 ::SendMessage(GetHwnd(), TB_AUTOSIZE, 0, 0);
1375 if (pos != GetPosition())
1376 Move(pos);
1377
1378 // In case Realize is called after the initial display (IOW the programmer
1379 // may have rebuilt the toolbar) give the frame the option of resizing the
1380 // toolbar to full width again, but only if the parent is a frame and the
1381 // toolbar is managed by the frame. Otherwise assume that some other
1382 // layout mechanism is controlling the toolbar size and leave it alone.
1383 wxFrame *frame = wxDynamicCast(GetParent(), wxFrame);
1384 if ( frame && frame->GetToolBar() == this )
1385 {
1386 frame->SendSizeEvent();
1387 }
1388 }
1389
1390 // ----------------------------------------------------------------------------
1391 // toolbar styles
1392 // ---------------------------------------------------------------------------
1393
1394 // get the TBSTYLE of the given toolbar window
1395 long wxToolBar::GetMSWToolbarStyle() const
1396 {
1397 return ::SendMessage(GetHwnd(), TB_GETSTYLE, 0, 0L);
1398 }
1399
1400 void wxToolBar::SetWindowStyleFlag(long style)
1401 {
1402 // the style bits whose changes force us to recreate the toolbar
1403 static const long MASK_NEEDS_RECREATE = wxTB_TEXT | wxTB_NOICONS;
1404
1405 const long styleOld = GetWindowStyle();
1406
1407 wxToolBarBase::SetWindowStyleFlag(style);
1408
1409 // don't recreate an empty toolbar: not only this is unnecessary, but it is
1410 // also fatal as we'd then try to recreate the toolbar when it's just being
1411 // created
1412 if ( GetToolsCount() &&
1413 (style & MASK_NEEDS_RECREATE) != (styleOld & MASK_NEEDS_RECREATE) )
1414 {
1415 // to remove the text labels, simply re-realizing the toolbar is enough
1416 // but I don't know of any way to add the text to an existing toolbar
1417 // other than by recreating it entirely
1418 Recreate();
1419 }
1420 }
1421
1422 // ----------------------------------------------------------------------------
1423 // tool state
1424 // ----------------------------------------------------------------------------
1425
1426 void wxToolBar::DoEnableTool(wxToolBarToolBase *tool, bool enable)
1427 {
1428 ::SendMessage(GetHwnd(), TB_ENABLEBUTTON,
1429 (WPARAM)tool->GetId(), (LPARAM)MAKELONG(enable, 0));
1430 }
1431
1432 void wxToolBar::DoToggleTool(wxToolBarToolBase *tool, bool toggle)
1433 {
1434 ::SendMessage(GetHwnd(), TB_CHECKBUTTON,
1435 (WPARAM)tool->GetId(), (LPARAM)MAKELONG(toggle, 0));
1436 }
1437
1438 void wxToolBar::DoSetToggle(wxToolBarToolBase *WXUNUSED(tool), bool WXUNUSED(toggle))
1439 {
1440 // VZ: AFAIK, the button has to be created either with TBSTYLE_CHECK or
1441 // without, so we really need to delete the button and recreate it here
1442 wxFAIL_MSG( _T("not implemented") );
1443 }
1444
1445 void wxToolBar::SetToolNormalBitmap( int id, const wxBitmap& bitmap )
1446 {
1447 wxToolBarTool* tool = wx_static_cast(wxToolBarTool*, FindById(id));
1448 if ( tool )
1449 {
1450 wxCHECK_RET( tool->IsButton(), wxT("Can only set bitmap on button tools."));
1451
1452 tool->SetNormalBitmap(bitmap);
1453 Realize();
1454 }
1455 }
1456
1457 void wxToolBar::SetToolDisabledBitmap( int id, const wxBitmap& bitmap )
1458 {
1459 wxToolBarTool* tool = wx_static_cast(wxToolBarTool*, FindById(id));
1460 if ( tool )
1461 {
1462 wxCHECK_RET( tool->IsButton(), wxT("Can only set bitmap on button tools."));
1463
1464 tool->SetDisabledBitmap(bitmap);
1465 Realize();
1466 }
1467 }
1468
1469 // ----------------------------------------------------------------------------
1470 // event handlers
1471 // ----------------------------------------------------------------------------
1472
1473 // Responds to colour changes, and passes event on to children.
1474 void wxToolBar::OnSysColourChanged(wxSysColourChangedEvent& event)
1475 {
1476 wxRGBToColour(m_backgroundColour, ::GetSysColor(COLOR_BTNFACE));
1477
1478 // Remap the buttons
1479 Realize();
1480
1481 // Relayout the toolbar
1482 int nrows = m_maxRows;
1483 m_maxRows = 0; // otherwise SetRows() wouldn't do anything
1484 SetRows(nrows);
1485
1486 Refresh();
1487
1488 // let the event propagate further
1489 event.Skip();
1490 }
1491
1492 void wxToolBar::OnMouseEvent(wxMouseEvent& event)
1493 {
1494 if ( event.Leaving() )
1495 {
1496 if ( m_pInTool )
1497 {
1498 OnMouseEnter(wxID_ANY);
1499 m_pInTool = NULL;
1500 }
1501
1502 event.Skip();
1503 return;
1504 }
1505
1506 if ( event.RightDown() )
1507 {
1508 // find the tool under the mouse
1509 wxCoord x = 0, y = 0;
1510 event.GetPosition(&x, &y);
1511
1512 wxToolBarToolBase *tool = FindToolForPosition(x, y);
1513 OnRightClick(tool ? tool->GetId() : -1, x, y);
1514 }
1515 else
1516 {
1517 event.Skip();
1518 }
1519 }
1520
1521 // This handler is required to allow the toolbar to be set to a non-default
1522 // colour: for example, when it must blend in with a notebook page.
1523 void wxToolBar::OnEraseBackground(wxEraseEvent& event)
1524 {
1525 RECT rect = wxGetClientRect(GetHwnd());
1526 HDC hdc = GetHdcOf((*event.GetDC()));
1527
1528 int majorVersion, minorVersion;
1529 wxGetOsVersion(& majorVersion, & minorVersion);
1530
1531 #if wxUSE_UXTHEME
1532 // we may need to draw themed colour so that we appear correctly on
1533 // e.g. notebook page under XP with themes but only do it if the parent
1534 // draws themed background itself
1535 if ( !UseBgCol() && !GetParent()->UseBgCol() )
1536 {
1537 wxUxThemeEngine *theme = wxUxThemeEngine::GetIfActive();
1538 if ( theme )
1539 {
1540 HRESULT
1541 hr = theme->DrawThemeParentBackground(GetHwnd(), hdc, &rect);
1542 if ( hr == S_OK )
1543 return;
1544
1545 // it can also return S_FALSE which seems to simply say that it
1546 // didn't draw anything but no error really occurred
1547 if ( FAILED(hr) )
1548 wxLogApiError(_T("DrawThemeParentBackground(toolbar)"), hr);
1549 }
1550 }
1551
1552 // Only draw a rebar theme on Vista, since it doesn't jive so well with XP
1553 if ( !UseBgCol() && majorVersion >= 6 )
1554 {
1555 wxUxThemeEngine *theme = wxUxThemeEngine::GetIfActive();
1556 if ( theme )
1557 {
1558 wxUxThemeHandle hTheme(this, L"REBAR");
1559
1560 RECT r;
1561 wxRect rect = GetClientRect();
1562 wxCopyRectToRECT(rect, r);
1563
1564 HRESULT hr = theme->DrawThemeBackground(hTheme, hdc, 0, 0, & r, NULL);
1565 if ( hr == S_OK )
1566 return;
1567
1568 // it can also return S_FALSE which seems to simply say that it
1569 // didn't draw anything but no error really occurred
1570 if ( FAILED(hr) )
1571 wxLogApiError(_T("DrawThemeParentBackground(toolbar)"), hr);
1572 }
1573 }
1574
1575 #endif // wxUSE_UXTHEME
1576
1577 if ( UseBgCol() || (GetMSWToolbarStyle() & TBSTYLE_TRANSPARENT) )
1578 {
1579 // do draw our background
1580 //
1581 // notice that this 'dumb' implementation may cause flicker for some of
1582 // the controls in which case they should intercept wxEraseEvent and
1583 // process it themselves somehow
1584 AutoHBRUSH hBrush(wxColourToRGB(GetBackgroundColour()));
1585
1586 wxCHANGE_HDC_MAP_MODE(hdc, MM_TEXT);
1587 ::FillRect(hdc, &rect, hBrush);
1588 }
1589 else // we have no non default background colour
1590 {
1591 // let the system do it for us
1592 event.Skip();
1593 }
1594 }
1595
1596 bool wxToolBar::HandleSize(WXWPARAM WXUNUSED(wParam), WXLPARAM lParam)
1597 {
1598 // calculate our minor dimension ourselves - we're confusing the standard
1599 // logic (TB_AUTOSIZE) with our horizontal toolbars and other hacks
1600 RECT r;
1601 if ( ::SendMessage(GetHwnd(), TB_GETITEMRECT, 0, (LPARAM)&r) )
1602 {
1603 int w, h;
1604
1605 if ( IsVertical() )
1606 {
1607 w = r.right - r.left;
1608 if ( m_maxRows )
1609 {
1610 w *= (m_nButtons + m_maxRows - 1)/m_maxRows;
1611 }
1612 h = HIWORD(lParam);
1613 }
1614 else
1615 {
1616 w = LOWORD(lParam);
1617 if (HasFlag( wxTB_FLAT ))
1618 h = r.bottom - r.top - 3;
1619 else
1620 h = r.bottom - r.top;
1621 if ( m_maxRows )
1622 {
1623 // FIXME: hardcoded separator line height...
1624 h += HasFlag(wxTB_NODIVIDER) ? 4 : 6;
1625 h *= m_maxRows;
1626 }
1627 }
1628
1629 if ( MAKELPARAM(w, h) != lParam )
1630 {
1631 // size really changed
1632 SetSize(w, h);
1633 }
1634
1635 // message processed
1636 return true;
1637 }
1638
1639 return false;
1640 }
1641
1642 bool wxToolBar::HandlePaint(WXWPARAM wParam, WXLPARAM lParam)
1643 {
1644 // erase any dummy separators which were used
1645 // for aligning the controls if any here
1646
1647 // first of all, are there any controls at all?
1648 wxToolBarToolsList::compatibility_iterator node;
1649 for ( node = m_tools.GetFirst(); node; node = node->GetNext() )
1650 {
1651 if ( node->GetData()->IsControl() )
1652 break;
1653 }
1654
1655 if ( !node )
1656 // no controls, nothing to erase
1657 return false;
1658
1659 wxSize clientSize = GetClientSize();
1660 int majorVersion, minorVersion;
1661 wxGetOsVersion(& majorVersion, & minorVersion);
1662
1663 // prepare the DC on which we'll be drawing
1664 wxClientDC dc(this);
1665 dc.SetBrush(wxBrush(GetBackgroundColour(), wxSOLID));
1666 dc.SetPen(*wxTRANSPARENT_PEN);
1667
1668 RECT r;
1669 if ( !::GetUpdateRect(GetHwnd(), &r, FALSE) )
1670 // nothing to redraw anyhow
1671 return false;
1672
1673 wxRect rectUpdate;
1674 wxCopyRECTToRect(r, rectUpdate);
1675
1676 dc.SetClippingRegion(rectUpdate);
1677
1678 // draw the toolbar tools, separators &c normally
1679 wxControl::MSWWindowProc(WM_PAINT, wParam, lParam);
1680
1681 // for each control in the toolbar find all the separators intersecting it
1682 // and erase them
1683 //
1684 // NB: this is really the only way to do it as we don't know if a separator
1685 // corresponds to a control (i.e. is a dummy one) or a real one
1686 // otherwise
1687 for ( node = m_tools.GetFirst(); node; node = node->GetNext() )
1688 {
1689 wxToolBarTool *tool = (wxToolBarTool*)node->GetData();
1690 if ( tool->IsControl() )
1691 {
1692 // get the control rect in our client coords
1693 wxControl *control = tool->GetControl();
1694 wxStaticText *staticText = tool->GetStaticText();
1695 wxRect rectCtrl = control->GetRect();
1696 wxRect rectStaticText(0,0,0,0);
1697 if ( staticText )
1698 {
1699 rectStaticText = staticText->GetRect();
1700 }
1701
1702 // iterate over all buttons
1703 TBBUTTON tbb;
1704 int count = ::SendMessage(GetHwnd(), TB_BUTTONCOUNT, 0, 0);
1705 for ( int n = 0; n < count; n++ )
1706 {
1707 // is it a separator?
1708 if ( !::SendMessage(GetHwnd(), TB_GETBUTTON,
1709 n, (LPARAM)&tbb) )
1710 {
1711 wxLogDebug(_T("TB_GETBUTTON failed?"));
1712
1713 continue;
1714 }
1715
1716 if ( tbb.fsStyle != TBSTYLE_SEP )
1717 continue;
1718
1719 // get the bounding rect of the separator
1720 RECT r;
1721 if ( !::SendMessage(GetHwnd(), TB_GETITEMRECT,
1722 n, (LPARAM)&r) )
1723 {
1724 wxLogDebug(_T("TB_GETITEMRECT failed?"));
1725
1726 continue;
1727 }
1728
1729 // does it intersect the control?
1730 wxRect rectItem;
1731 wxCopyRECTToRect(r, rectItem);
1732 if ( rectCtrl.Intersects(rectItem) || (staticText && rectStaticText.Intersects(rectItem)))
1733 {
1734 // yes, do erase it!
1735
1736 bool haveRefreshed = false;
1737
1738 #if wxUSE_UXTHEME
1739 if ( !UseBgCol() && !GetParent()->UseBgCol() )
1740 {
1741 // Don't use DrawThemeBackground
1742 }
1743 else if ( !UseBgCol() && majorVersion >= 6 )
1744 {
1745 wxUxThemeEngine *theme = wxUxThemeEngine::GetIfActive();
1746 if ( theme )
1747 {
1748 wxUxThemeHandle hTheme(this, L"REBAR");
1749
1750 RECT clipRect = r;
1751
1752 // Draw the whole background since the pattern may be position sensitive;
1753 // but clip it to the area of interest.
1754 r.left = 0;
1755 r.right = clientSize.x;
1756 r.top = 0;
1757 r.bottom = clientSize.y;
1758
1759 HRESULT hr = theme->DrawThemeBackground(hTheme, (HDC) dc.GetHDC(), 0, 0, & r, & clipRect);
1760 if ( hr == S_OK )
1761 haveRefreshed = true;
1762 }
1763 }
1764 #endif
1765
1766 if (!haveRefreshed)
1767 dc.DrawRectangle(rectItem);
1768 }
1769
1770 if ( rectCtrl.Intersects(rectItem) )
1771 {
1772 // Necessary in case we use a no-paint-on-size
1773 // style in the parent: the controls can disappear
1774 control->Refresh(false);
1775 }
1776
1777 if ( staticText && rectStaticText.Intersects(rectItem) )
1778 {
1779 // Necessary in case we use a no-paint-on-size
1780 // style in the parent: the controls can disappear
1781 staticText->Refresh(false);
1782 }
1783 }
1784 }
1785 }
1786
1787 return true;
1788 }
1789
1790 void wxToolBar::HandleMouseMove(WXWPARAM WXUNUSED(wParam), WXLPARAM lParam)
1791 {
1792 wxCoord x = GET_X_LPARAM(lParam),
1793 y = GET_Y_LPARAM(lParam);
1794 wxToolBarToolBase* tool = FindToolForPosition( x, y );
1795
1796 // has the current tool changed?
1797 if ( tool != m_pInTool )
1798 {
1799 m_pInTool = tool;
1800 OnMouseEnter(tool ? tool->GetId() : wxID_ANY);
1801 }
1802 }
1803
1804 WXLRESULT wxToolBar::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
1805 {
1806 switch ( nMsg )
1807 {
1808 case WM_MOUSEMOVE:
1809 // we don't handle mouse moves, so always pass the message to
1810 // wxControl::MSWWindowProc (HandleMouseMove just calls OnMouseEnter)
1811 HandleMouseMove(wParam, lParam);
1812 break;
1813
1814 case WM_SIZE:
1815 if ( HandleSize(wParam, lParam) )
1816 return 0;
1817 break;
1818
1819 #ifndef __WXWINCE__
1820 case WM_PAINT:
1821 if ( HandlePaint(wParam, lParam) )
1822 return 0;
1823 #endif
1824
1825 default:
1826 break;
1827 }
1828
1829 return wxControl::MSWWindowProc(nMsg, wParam, lParam);
1830 }
1831
1832 // ----------------------------------------------------------------------------
1833 // private functions
1834 // ----------------------------------------------------------------------------
1835
1836 #ifdef wxREMAP_BUTTON_COLOURS
1837
1838 WXHBITMAP wxToolBar::MapBitmap(WXHBITMAP bitmap, int width, int height)
1839 {
1840 MemoryHDC hdcMem;
1841
1842 if ( !hdcMem )
1843 {
1844 wxLogLastError(_T("CreateCompatibleDC"));
1845
1846 return bitmap;
1847 }
1848
1849 SelectInHDC bmpInHDC(hdcMem, (HBITMAP)bitmap);
1850
1851 if ( !bmpInHDC )
1852 {
1853 wxLogLastError(_T("SelectObject"));
1854
1855 return bitmap;
1856 }
1857
1858 wxCOLORMAP *cmap = wxGetStdColourMap();
1859
1860 for ( int i = 0; i < width; i++ )
1861 {
1862 for ( int j = 0; j < height; j++ )
1863 {
1864 COLORREF pixel = ::GetPixel(hdcMem, i, j);
1865
1866 for ( size_t k = 0; k < wxSTD_COL_MAX; k++ )
1867 {
1868 COLORREF col = cmap[k].from;
1869 if ( abs(GetRValue(pixel) - GetRValue(col)) < 10 &&
1870 abs(GetGValue(pixel) - GetGValue(col)) < 10 &&
1871 abs(GetBValue(pixel) - GetBValue(col)) < 10 )
1872 {
1873 if ( cmap[k].to != pixel )
1874 ::SetPixel(hdcMem, i, j, cmap[k].to);
1875 break;
1876 }
1877 }
1878 }
1879 }
1880
1881 return bitmap;
1882 }
1883
1884 #endif // wxREMAP_BUTTON_COLOURS
1885
1886 #endif // wxUSE_TOOLBAR