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


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