]> git.saurik.com Git - wxWidgets.git/blob - src/msw/tbar95.cpp
projects / wxWidgets.git / blob
? search:


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