]> git.saurik.com Git - wxWidgets.git/blob - src/msw/tbar95.cpp
multilib mode compilation fix
[wxWidgets.git] / src / msw / tbar95.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: 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 #ifdef __GNUG__
21 #pragma implementation "tbar95.h"
22 #endif
23
24 // For compilers that support precompilation, includes "wx.h".
25 #include "wx/wxprec.h"
26
27 #ifdef __BORLANDC__
28 #pragma hdrstop
29 #endif
30
31 #ifndef WX_PRECOMP
32 #include "wx/frame.h"
33 #include "wx/log.h"
34 #include "wx/intl.h"
35 #include "wx/dynarray.h"
36 #include "wx/settings.h"
37 #include "wx/bitmap.h"
38 #include "wx/dcmemory.h"
39 #include "wx/control.h"
40 #endif
41
42 #if wxUSE_TOOLBAR && defined(__WIN95__) && wxUSE_TOOLBAR_NATIVE
43
44 #include "wx/toolbar.h"
45
46 #if !defined(__GNUWIN32__) && !defined(__SALFORDC__)
47 #include "malloc.h"
48 #endif
49
50 #include "wx/msw/private.h"
51
52 #if defined(__WIN95__) && !(defined(__GNUWIN32_OLD__) && !defined(__CYGWIN10__))
53 #include <commctrl.h>
54 #else
55 #include "wx/msw/gnuwin32/extra.h"
56 #endif
57
58 #include "wx/msw/missing.h"
59
60 #include "wx/app.h" // for GetComCtl32Version
61
62 #if defined(__MWERKS__) && defined(__WXMSW__)
63 // including <windef.h> for max definition doesn't seem
64 // to work using CodeWarrior 6 Windows. So we define it
65 // here. (Otherwise we get a undefined identifier 'max'
66 // later on in this file.) (Added by dimitri@shortcut.nl)
67 # ifndef max
68 # define max(a,b) (((a) > (b)) ? (a) : (b))
69 # endif
70
71 #endif
72
73 // ----------------------------------------------------------------------------
74 // conditional compilation
75 // ----------------------------------------------------------------------------
76
77 // wxWindows previously always considered that toolbar buttons have light grey
78 // (0xc0c0c0) background and so ignored any bitmap masks - however, this
79 // doesn't work with XPMs which then appear to have black background. To make
80 // this work, we must respect the bitmap masks - which we do now. This should
81 // be ok in any case, but to restore 100% compatible with the old version
82 // behaviour, you can set this to 0.
83 #define USE_BITMAP_MASKS 1
84
85 // ----------------------------------------------------------------------------
86 // constants
87 // ----------------------------------------------------------------------------
88
89 // these standard constants are not always defined in compilers headers
90
91 // Styles
92 #ifndef TBSTYLE_FLAT
93 #define TBSTYLE_LIST 0x1000
94 #define TBSTYLE_FLAT 0x0800
95 #endif
96
97 #ifndef TBSTYLE_TRANSPARENT
98 #define TBSTYLE_TRANSPARENT 0x8000
99 #endif
100
101 #ifndef TBSTYLE_TOOLTIPS
102 #define TBSTYLE_TOOLTIPS 0x0100
103 #endif
104
105 // Messages
106 #ifndef TB_GETSTYLE
107 #define TB_SETSTYLE (WM_USER + 56)
108 #define TB_GETSTYLE (WM_USER + 57)
109 #endif
110
111 #ifndef TB_HITTEST
112 #define TB_HITTEST (WM_USER + 69)
113 #endif
114
115 // these values correspond to those used by comctl32.dll
116 #define DEFAULTBITMAPX 16
117 #define DEFAULTBITMAPY 15
118 #define DEFAULTBUTTONX 24
119 #define DEFAULTBUTTONY 24
120 #define DEFAULTBARHEIGHT 27
121
122 // ----------------------------------------------------------------------------
123 // wxWin macros
124 // ----------------------------------------------------------------------------
125
126 IMPLEMENT_DYNAMIC_CLASS(wxToolBar, wxControl)
127
128 BEGIN_EVENT_TABLE(wxToolBar, wxToolBarBase)
129 EVT_MOUSE_EVENTS(wxToolBar::OnMouseEvent)
130 EVT_SYS_COLOUR_CHANGED(wxToolBar::OnSysColourChanged)
131 END_EVENT_TABLE()
132
133 // ----------------------------------------------------------------------------
134 // private classes
135 // ----------------------------------------------------------------------------
136
137 class wxToolBarTool : public wxToolBarToolBase
138 {
139 public:
140 wxToolBarTool(wxToolBar *tbar,
141 int id,
142 const wxString& label,
143 const wxBitmap& bmpNormal,
144 const wxBitmap& bmpDisabled,
145 wxItemKind kind,
146 wxObject *clientData,
147 const wxString& shortHelp,
148 const wxString& longHelp)
149 : wxToolBarToolBase(tbar, id, label, bmpNormal, bmpDisabled, kind,
150 clientData, shortHelp, longHelp)
151 {
152 m_nSepCount = 0;
153 }
154
155 wxToolBarTool(wxToolBar *tbar, wxControl *control)
156 : wxToolBarToolBase(tbar, control)
157 {
158 m_nSepCount = 1;
159 }
160
161 virtual void SetLabel(const wxString& label)
162 {
163 if ( label == m_label )
164 return;
165
166 wxToolBarToolBase::SetLabel(label);
167
168 // we need to update the label shown in the toolbar because it has a
169 // pointer to the internal buffer of the old label
170 //
171 // TODO: use TB_SETBUTTONINFO
172 }
173
174 // set/get the number of separators which we use to cover the space used by
175 // a control in the toolbar
176 void SetSeparatorsCount(size_t count) { m_nSepCount = count; }
177 size_t GetSeparatorsCount() const { return m_nSepCount; }
178
179 private:
180 size_t m_nSepCount;
181
182 DECLARE_NO_COPY_CLASS(wxToolBarTool)
183 };
184
185
186 // ============================================================================
187 // implementation
188 // ============================================================================
189
190 // ----------------------------------------------------------------------------
191 // wxToolBarTool
192 // ----------------------------------------------------------------------------
193
194 wxToolBarToolBase *wxToolBar::CreateTool(int id,
195 const wxString& label,
196 const wxBitmap& bmpNormal,
197 const wxBitmap& bmpDisabled,
198 wxItemKind kind,
199 wxObject *clientData,
200 const wxString& shortHelp,
201 const wxString& longHelp)
202 {
203 return new wxToolBarTool(this, id, label, bmpNormal, bmpDisabled, kind,
204 clientData, shortHelp, longHelp);
205 }
206
207 wxToolBarToolBase *wxToolBar::CreateTool(wxControl *control)
208 {
209 return new wxToolBarTool(this, control);
210 }
211
212 // ----------------------------------------------------------------------------
213 // wxToolBar construction
214 // ----------------------------------------------------------------------------
215
216 void wxToolBar::Init()
217 {
218 m_hBitmap = 0;
219
220 m_nButtons = 0;
221
222 m_defaultWidth = DEFAULTBITMAPX;
223 m_defaultHeight = DEFAULTBITMAPY;
224
225 m_pInTool = 0;
226 }
227
228 bool wxToolBar::Create(wxWindow *parent,
229 wxWindowID id,
230 const wxPoint& pos,
231 const wxSize& size,
232 long style,
233 const wxString& name)
234 {
235 // common initialisation
236 if ( !CreateControl(parent, id, pos, size, style, wxDefaultValidator, name) )
237 return FALSE;
238
239 // MSW-specific initialisation
240 if ( !MSWCreateToolbar(pos, size) )
241 return FALSE;
242
243 // set up the colors and fonts
244 SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_MENUBAR));
245 SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));
246
247 return TRUE;
248 }
249
250 bool wxToolBar::MSWCreateToolbar(const wxPoint& pos, const wxSize& size)
251 {
252 if ( !MSWCreateControl(TOOLBARCLASSNAME, wxEmptyString, pos, size) )
253 return FALSE;
254
255 // toolbar-specific post initialisation
256 ::SendMessage(GetHwnd(), TB_BUTTONSTRUCTSIZE, sizeof(TBBUTTON), 0);
257
258 return TRUE;
259 }
260
261 void wxToolBar::Recreate()
262 {
263 const HWND hwndOld = GetHwnd();
264 if ( !hwndOld )
265 {
266 // we haven't been created yet, no need to recreate
267 return;
268 }
269
270 // get the position and size before unsubclassing the old toolbar
271 const wxPoint pos = GetPosition();
272 const wxSize size = GetSize();
273
274 UnsubclassWin();
275
276 if ( !MSWCreateToolbar(pos, size) )
277 {
278 // what can we do?
279 wxFAIL_MSG( _T("recreating the toolbar failed") );
280
281 return;
282 }
283
284 // reparent all our children under the new toolbar
285 for ( wxWindowList::compatibility_iterator node = m_children.GetFirst();
286 node;
287 node = node->GetNext() )
288 {
289 wxWindow *win = node->GetData();
290 if ( !win->IsTopLevel() )
291 ::SetParent(GetHwndOf(win), GetHwnd());
292 }
293
294 // only destroy the old toolbar now -- after all the children had been
295 // reparented
296 ::DestroyWindow(hwndOld);
297
298 // it is for the old bitmap control and can't be used with the new one
299 if ( m_hBitmap )
300 {
301 ::DeleteObject((HBITMAP) m_hBitmap);
302 m_hBitmap = 0;
303 }
304
305 Realize();
306 UpdateSize();
307 }
308
309 wxToolBar::~wxToolBar()
310 {
311 // we must refresh the frame size when the toolbar is deleted but the frame
312 // is not - otherwise toolbar leaves a hole in the place it used to occupy
313 wxFrame *frame = wxDynamicCast(GetParent(), wxFrame);
314 if ( frame && !frame->IsBeingDeleted() )
315 {
316 frame->SendSizeEvent();
317 }
318
319 if ( m_hBitmap )
320 {
321 ::DeleteObject((HBITMAP) m_hBitmap);
322 }
323 }
324
325 wxSize wxToolBar::DoGetBestSize() const
326 {
327 wxSize sizeBest = GetToolSize();
328 sizeBest.x *= GetToolsCount();
329
330 // reverse horz and vertical components if necessary
331 return HasFlag(wxTB_VERTICAL) ? wxSize(sizeBest.y, sizeBest.x) : sizeBest;
332 }
333
334 WXDWORD wxToolBar::MSWGetStyle(long style, WXDWORD *exstyle) const
335 {
336 // toolbars never have border, giving one to them results in broken
337 // appearance
338 WXDWORD msStyle = wxControl::MSWGetStyle
339 (
340 (style & ~wxBORDER_MASK) | wxBORDER_NONE, exstyle
341 );
342
343 // always include this one, it never hurts and setting it later only if we
344 // do have tooltips wouldn't work
345 msStyle |= TBSTYLE_TOOLTIPS;
346
347 if ( style & (wxTB_FLAT | wxTB_HORZ_LAYOUT) )
348 {
349 // static as it doesn't change during the program lifetime
350 static int s_verComCtl = wxTheApp->GetComCtl32Version();
351
352 // comctl32.dll 4.00 doesn't support the flat toolbars and using this
353 // style with 6.00 (part of Windows XP) leads to the toolbar with
354 // incorrect background colour - and not using it still results in the
355 // correct (flat) toolbar, so don't use it there
356 if ( s_verComCtl > 400 && s_verComCtl < 600 )
357 {
358 msStyle |= TBSTYLE_FLAT | TBSTYLE_TRANSPARENT;
359 }
360
361 if ( s_verComCtl >= 470 && style & wxTB_HORZ_LAYOUT )
362 {
363 msStyle |= TBSTYLE_LIST;
364 }
365 }
366
367 if ( style & wxTB_NODIVIDER )
368 msStyle |= CCS_NODIVIDER;
369
370 if ( style & wxTB_NOALIGN )
371 msStyle |= CCS_NOPARENTALIGN;
372
373 if ( style & wxTB_VERTICAL )
374 msStyle |= CCS_VERT;
375
376 return msStyle;
377 }
378
379 // ----------------------------------------------------------------------------
380 // adding/removing tools
381 // ----------------------------------------------------------------------------
382
383 bool wxToolBar::DoInsertTool(size_t WXUNUSED(pos), wxToolBarToolBase *tool)
384 {
385 // nothing special to do here - we really create the toolbar buttons in
386 // Realize() later
387 tool->Attach(this);
388
389 return TRUE;
390 }
391
392 bool wxToolBar::DoDeleteTool(size_t pos, wxToolBarToolBase *tool)
393 {
394 // the main difficulty we have here is with the controls in the toolbars:
395 // as we (sometimes) use several separators to cover up the space used by
396 // them, the indices are not the same for us and the toolbar
397
398 // first determine the position of the first button to delete: it may be
399 // different from pos if we use several separators to cover the space used
400 // by a control
401 wxToolBarToolsList::compatibility_iterator node;
402 for ( node = m_tools.GetFirst(); node; node = node->GetNext() )
403 {
404 wxToolBarToolBase *tool2 = node->GetData();
405 if ( tool2 == tool )
406 {
407 // let node point to the next node in the list
408 node = node->GetNext();
409
410 break;
411 }
412
413 if ( tool2->IsControl() )
414 {
415 pos += ((wxToolBarTool *)tool2)->GetSeparatorsCount() - 1;
416 }
417 }
418
419 // now determine the number of buttons to delete and the area taken by them
420 size_t nButtonsToDelete = 1;
421
422 // get the size of the button we're going to delete
423 RECT r;
424 if ( !::SendMessage(GetHwnd(), TB_GETITEMRECT, pos, (LPARAM)&r) )
425 {
426 wxLogLastError(_T("TB_GETITEMRECT"));
427 }
428
429 int width = r.right - r.left;
430
431 if ( tool->IsControl() )
432 {
433 nButtonsToDelete = ((wxToolBarTool *)tool)->GetSeparatorsCount();
434
435 width *= nButtonsToDelete;
436 }
437
438 // do delete all buttons
439 m_nButtons -= nButtonsToDelete;
440 while ( nButtonsToDelete-- > 0 )
441 {
442 if ( !::SendMessage(GetHwnd(), TB_DELETEBUTTON, pos, 0) )
443 {
444 wxLogLastError(wxT("TB_DELETEBUTTON"));
445
446 return FALSE;
447 }
448 }
449
450 tool->Detach();
451
452 // and finally reposition all the controls after this button (the toolbar
453 // takes care of all normal items)
454 for ( /* node -> first after deleted */ ; node; node = node->GetNext() )
455 {
456 wxToolBarToolBase *tool2 = node->GetData();
457 if ( tool2->IsControl() )
458 {
459 int x;
460 wxControl *control = tool2->GetControl();
461 control->GetPosition(&x, NULL);
462 control->Move(x - width, -1);
463 }
464 }
465
466 return TRUE;
467 }
468
469 bool wxToolBar::Realize()
470 {
471 const size_t nTools = GetToolsCount();
472 if ( nTools == 0 )
473 {
474 // nothing to do
475 return TRUE;
476 }
477
478 const bool isVertical = HasFlag(wxTB_VERTICAL);
479
480 // delete all old buttons, if any
481 for ( size_t pos = 0; pos < m_nButtons; pos++ )
482 {
483 if ( !::SendMessage(GetHwnd(), TB_DELETEBUTTON, 0, 0) )
484 {
485 wxLogDebug(wxT("TB_DELETEBUTTON failed"));
486 }
487 }
488
489 // First, add the bitmap: we use one bitmap for all toolbar buttons
490 // ----------------------------------------------------------------
491
492 wxToolBarToolsList::compatibility_iterator node;
493 int bitmapId = 0;
494
495 wxSize sizeBmp;
496 if ( HasFlag(wxTB_NOICONS) )
497 {
498 // no icons, don't leave space for them
499 sizeBmp.x =
500 sizeBmp.y = 0;
501 }
502 else // do show icons
503 {
504 // if we already have a bitmap, we'll replace the existing one --
505 // otherwise we'll install a new one
506 HBITMAP oldToolBarBitmap = (HBITMAP)m_hBitmap;
507
508 sizeBmp.x = m_defaultWidth;
509 sizeBmp.y = m_defaultHeight;
510
511 const wxCoord totalBitmapWidth = m_defaultWidth * nTools,
512 totalBitmapHeight = m_defaultHeight;
513
514 // Create a bitmap and copy all the tool bitmaps to it
515 #if USE_BITMAP_MASKS
516 wxMemoryDC dcAllButtons;
517 wxBitmap bitmap(totalBitmapWidth, totalBitmapHeight);
518 dcAllButtons.SelectObject(bitmap);
519 dcAllButtons.SetBackground(*wxLIGHT_GREY_BRUSH);
520 dcAllButtons.Clear();
521
522 m_hBitmap = bitmap.GetHBITMAP();
523 HBITMAP hBitmap = (HBITMAP)m_hBitmap;
524 #else // !USE_BITMAP_MASKS
525 HBITMAP hBitmap = ::CreateCompatibleBitmap(ScreenHDC(),
526 totalBitmapWidth,
527 totalBitmapHeight);
528 if ( !hBitmap )
529 {
530 wxLogLastError(_T("CreateCompatibleBitmap"));
531
532 return FALSE;
533 }
534
535 m_hBitmap = (WXHBITMAP)hBitmap;
536
537 MemoryHDC memoryDC;
538 SelectInHDC hdcSelector(memoryDC, hBitmap);
539
540 MemoryHDC memoryDC2;
541 #endif // USE_BITMAP_MASKS/!USE_BITMAP_MASKS
542
543 // the button position
544 wxCoord x = 0;
545
546 // the number of buttons (not separators)
547 int nButtons = 0;
548
549 for ( node = m_tools.GetFirst(); node; node = node->GetNext() )
550 {
551 wxToolBarToolBase *tool = node->GetData();
552 if ( tool->IsButton() )
553 {
554 const wxBitmap& bmp = tool->GetNormalBitmap();
555 if ( bmp.Ok() )
556 {
557 #if USE_BITMAP_MASKS
558 // notice the last parameter: do use mask
559 dcAllButtons.DrawBitmap(bmp, x, 0, TRUE);
560 #else // !USE_BITMAP_MASKS
561 SelectInHDC hdcSelector2(memoryDC2, GetHbitmapOf(bmp));
562 if ( !BitBlt(memoryDC,
563 x, 0, m_defaultWidth, m_defaultHeight,
564 memoryDC2,
565 0, 0, SRCCOPY) )
566 {
567 wxLogLastError(wxT("BitBlt"));
568 }
569 #endif // USE_BITMAP_MASKS/!USE_BITMAP_MASKS
570 }
571 else
572 {
573 wxFAIL_MSG( _T("invalid tool button bitmap") );
574 }
575
576 // still inc width and number of buttons because otherwise the
577 // subsequent buttons will all be shifted which is rather confusing
578 // (and like this you'd see immediately which bitmap was bad)
579 x += m_defaultWidth;
580 nButtons++;
581 }
582 }
583
584 #if USE_BITMAP_MASKS
585 dcAllButtons.SelectObject(wxNullBitmap);
586
587 // don't delete this HBITMAP!
588 bitmap.SetHBITMAP(0);
589 #endif // USE_BITMAP_MASKS/!USE_BITMAP_MASKS
590
591 // Map to system colours
592 hBitmap = (HBITMAP)MapBitmap((WXHBITMAP) hBitmap,
593 totalBitmapWidth, totalBitmapHeight);
594
595 bool addBitmap = TRUE;
596
597 if ( oldToolBarBitmap )
598 {
599 #ifdef TB_REPLACEBITMAP
600 if ( wxTheApp->GetComCtl32Version() >= 400 )
601 {
602 TBREPLACEBITMAP replaceBitmap;
603 replaceBitmap.hInstOld = NULL;
604 replaceBitmap.hInstNew = NULL;
605 replaceBitmap.nIDOld = (UINT) oldToolBarBitmap;
606 replaceBitmap.nIDNew = (UINT) hBitmap;
607 replaceBitmap.nButtons = nButtons;
608 if ( !::SendMessage(GetHwnd(), TB_REPLACEBITMAP,
609 0, (LPARAM) &replaceBitmap) )
610 {
611 wxFAIL_MSG(wxT("Could not replace the old bitmap"));
612 }
613
614 ::DeleteObject(oldToolBarBitmap);
615
616 // already done
617 addBitmap = FALSE;
618 }
619 else
620 #endif // TB_REPLACEBITMAP
621 {
622 // we can't replace the old bitmap, so we will add another one
623 // (awfully inefficient, but what else to do?) and shift the bitmap
624 // indices accordingly
625 addBitmap = TRUE;
626
627 bitmapId = m_nButtons;
628 }
629 }
630
631 if ( addBitmap ) // no old bitmap or we can't replace it
632 {
633 TBADDBITMAP addBitmap;
634 addBitmap.hInst = 0;
635 addBitmap.nID = (UINT) hBitmap;
636 if ( ::SendMessage(GetHwnd(), TB_ADDBITMAP,
637 (WPARAM) nButtons, (LPARAM)&addBitmap) == -1 )
638 {
639 wxFAIL_MSG(wxT("Could not add bitmap to toolbar"));
640 }
641 }
642 }
643
644 // don't call SetToolBitmapSize() as we don't want to change the values of
645 // m_defaultWidth/Height
646 if ( !::SendMessage(GetHwnd(), TB_SETBITMAPSIZE, 0,
647 MAKELONG(sizeBmp.x, sizeBmp.y)) )
648 {
649 wxLogLastError(_T("TB_SETBITMAPSIZE"));
650 }
651
652 // Next add the buttons and separators
653 // -----------------------------------
654
655 TBBUTTON *buttons = new TBBUTTON[nTools];
656
657 // this array will hold the indices of all controls in the toolbar
658 wxArrayInt controlIds;
659
660 bool lastWasRadio = FALSE;
661 int i = 0;
662 for ( node = m_tools.GetFirst(); node; node = node->GetNext() )
663 {
664 wxToolBarToolBase *tool = node->GetData();
665
666 // don't add separators to the vertical toolbar with old comctl32.dll
667 // versions as they didn't handle this properly
668 if ( isVertical && tool->IsSeparator() &&
669 wxTheApp->GetComCtl32Version() <= 472 )
670 {
671 continue;
672 }
673
674
675 TBBUTTON& button = buttons[i];
676
677 wxZeroMemory(button);
678
679 bool isRadio = FALSE;
680 switch ( tool->GetStyle() )
681 {
682 case wxTOOL_STYLE_CONTROL:
683 button.idCommand = tool->GetId();
684 // fall through: create just a separator too
685
686 case wxTOOL_STYLE_SEPARATOR:
687 button.fsState = TBSTATE_ENABLED;
688 button.fsStyle = TBSTYLE_SEP;
689 break;
690
691 case wxTOOL_STYLE_BUTTON:
692 if ( !HasFlag(wxTB_NOICONS) )
693 button.iBitmap = bitmapId;
694
695 if ( HasFlag(wxTB_TEXT) )
696 {
697 const wxString& label = tool->GetLabel();
698 if ( !label.empty() )
699 {
700 button.iString = (int)label.c_str();
701 }
702 }
703
704 button.idCommand = tool->GetId();
705
706 if ( tool->IsEnabled() )
707 button.fsState |= TBSTATE_ENABLED;
708 if ( tool->IsToggled() )
709 button.fsState |= TBSTATE_CHECKED;
710
711 switch ( tool->GetKind() )
712 {
713 case wxITEM_RADIO:
714 button.fsStyle = TBSTYLE_CHECKGROUP;
715
716 if ( !lastWasRadio )
717 {
718 // the first item in the radio group is checked by
719 // default to be consistent with wxGTK and the menu
720 // radio items
721 button.fsState |= TBSTATE_CHECKED;
722
723 tool->Toggle(TRUE);
724 }
725
726 isRadio = TRUE;
727 break;
728
729 case wxITEM_CHECK:
730 button.fsStyle = TBSTYLE_CHECK;
731 break;
732
733 default:
734 wxFAIL_MSG( _T("unexpected toolbar button kind") );
735 // fall through
736
737 case wxITEM_NORMAL:
738 button.fsStyle = TBSTYLE_BUTTON;
739 }
740
741 bitmapId++;
742 break;
743 }
744
745 lastWasRadio = isRadio;
746
747 i++;
748 }
749
750 if ( !::SendMessage(GetHwnd(), TB_ADDBUTTONS, (WPARAM)i, (LPARAM)buttons) )
751 {
752 wxLogLastError(wxT("TB_ADDBUTTONS"));
753 }
754
755 delete [] buttons;
756
757 // Deal with the controls finally
758 // ------------------------------
759
760 // adjust the controls size to fit nicely in the toolbar
761 int y = 0;
762 size_t index = 0;
763 for ( node = m_tools.GetFirst(); node; node = node->GetNext(), index++ )
764 {
765 wxToolBarToolBase *tool = node->GetData();
766
767 // we calculate the running y coord for vertical toolbars so we need to
768 // get the items size for all items but for the horizontal ones we
769 // don't need to deal with the non controls
770 bool isControl = tool->IsControl();
771 if ( !isControl && !isVertical )
772 continue;
773
774 // note that we use TB_GETITEMRECT and not TB_GETRECT because the
775 // latter only appeared in v4.70 of comctl32.dll
776 RECT r;
777 if ( !SendMessage(GetHwnd(), TB_GETITEMRECT,
778 index, (LPARAM)(LPRECT)&r) )
779 {
780 wxLogLastError(wxT("TB_GETITEMRECT"));
781 }
782
783 if ( !isControl )
784 {
785 // can only be control if isVertical
786 y += r.bottom - r.top;
787
788 continue;
789 }
790
791 wxControl *control = tool->GetControl();
792
793 wxSize size = control->GetSize();
794
795 // the position of the leftmost controls corner
796 int left = -1;
797
798 // TB_SETBUTTONINFO message is only supported by comctl32.dll 4.71+
799 #if defined(_WIN32_IE) && (_WIN32_IE >= 0x400 )
800 // available in headers, now check whether it is available now
801 // (during run-time)
802 if ( wxTheApp->GetComCtl32Version() >= 471 )
803 {
804 // set the (underlying) separators width to be that of the
805 // control
806 TBBUTTONINFO tbbi;
807 tbbi.cbSize = sizeof(tbbi);
808 tbbi.dwMask = TBIF_SIZE;
809 tbbi.cx = size.x;
810 if ( !SendMessage(GetHwnd(), TB_SETBUTTONINFO,
811 tool->GetId(), (LPARAM)&tbbi) )
812 {
813 // the id is probably invalid?
814 wxLogLastError(wxT("TB_SETBUTTONINFO"));
815 }
816 }
817 else
818 #endif // comctl32.dll 4.71
819 // TB_SETBUTTONINFO unavailable
820 {
821 // try adding several separators to fit the controls width
822 int widthSep = r.right - r.left;
823 left = r.left;
824
825 TBBUTTON tbb;
826 wxZeroMemory(tbb);
827 tbb.idCommand = 0;
828 tbb.fsState = TBSTATE_ENABLED;
829 tbb.fsStyle = TBSTYLE_SEP;
830
831 size_t nSeparators = size.x / widthSep;
832 for ( size_t nSep = 0; nSep < nSeparators; nSep++ )
833 {
834 if ( !SendMessage(GetHwnd(), TB_INSERTBUTTON,
835 index, (LPARAM)&tbb) )
836 {
837 wxLogLastError(wxT("TB_INSERTBUTTON"));
838 }
839
840 index++;
841 }
842
843 // remember the number of separators we used - we'd have to
844 // delete all of them later
845 ((wxToolBarTool *)tool)->SetSeparatorsCount(nSeparators);
846
847 // adjust the controls width to exactly cover the separators
848 control->SetSize((nSeparators + 1)*widthSep, -1);
849 }
850
851 // position the control itself correctly vertically
852 int height = r.bottom - r.top;
853 int diff = height - size.y;
854 if ( diff < 0 )
855 {
856 // the control is too high, resize to fit
857 control->SetSize(-1, height - 2);
858
859 diff = 2;
860 }
861
862 int top;
863 if ( isVertical )
864 {
865 left = 0;
866 top = y;
867
868 y += height + 2*GetMargins().y;
869 }
870 else // horizontal toolbar
871 {
872 if ( left == -1 )
873 left = r.left;
874
875 top = r.top;
876 }
877
878 control->Move(left, top + (diff + 1) / 2);
879 }
880
881 // the max index is the "real" number of buttons - i.e. counting even the
882 // separators which we added just for aligning the controls
883 m_nButtons = index;
884
885 if ( !isVertical )
886 {
887 if ( m_maxRows == 0 )
888 {
889 // if not set yet, only one row
890 SetRows(1);
891 }
892 }
893 else if ( m_nButtons > 0 ) // vertical non empty toolbar
894 {
895 if ( m_maxRows == 0 )
896 {
897 // if not set yet, have one column
898 SetRows(m_nButtons);
899 }
900 }
901
902 return TRUE;
903 }
904
905 // ----------------------------------------------------------------------------
906 // message handlers
907 // ----------------------------------------------------------------------------
908
909 bool wxToolBar::MSWCommand(WXUINT WXUNUSED(cmd), WXWORD id)
910 {
911 wxToolBarToolBase *tool = FindById((int)id);
912 if ( !tool )
913 return FALSE;
914
915 if ( tool->CanBeToggled() )
916 {
917 LRESULT state = ::SendMessage(GetHwnd(), TB_GETSTATE, id, 0);
918 tool->Toggle((state & TBSTATE_CHECKED) != 0);
919 }
920
921 bool toggled = tool->IsToggled();
922
923 // avoid sending the event when a radio button is released, this is not
924 // interesting
925 if ( !tool->CanBeToggled() || tool->GetKind() != wxITEM_RADIO || toggled )
926 {
927 // OnLeftClick() can veto the button state change - for buttons which
928 // may be toggled only, of couse
929 if ( !OnLeftClick((int)id, toggled) && tool->CanBeToggled() )
930 {
931 // revert back
932 toggled = !toggled;
933 tool->SetToggle(toggled);
934
935 ::SendMessage(GetHwnd(), TB_CHECKBUTTON, id, MAKELONG(toggled, 0));
936 }
937 }
938
939 return TRUE;
940 }
941
942 bool wxToolBar::MSWOnNotify(int WXUNUSED(idCtrl),
943 WXLPARAM lParam,
944 WXLPARAM *WXUNUSED(result))
945 {
946 #if wxUSE_TOOLTIPS
947 // First check if this applies to us
948 NMHDR *hdr = (NMHDR *)lParam;
949
950 // the tooltips control created by the toolbar is sometimes Unicode, even
951 // in an ANSI application - this seems to be a bug in comctl32.dll v5
952 UINT code = hdr->code;
953 if ( (code != (UINT) TTN_NEEDTEXTA) && (code != (UINT) TTN_NEEDTEXTW) )
954 return FALSE;
955
956 HWND toolTipWnd = (HWND)::SendMessage((HWND)GetHWND(), TB_GETTOOLTIPS, 0, 0);
957 if ( toolTipWnd != hdr->hwndFrom )
958 return FALSE;
959
960 LPTOOLTIPTEXT ttText = (LPTOOLTIPTEXT)lParam;
961 int id = (int)ttText->hdr.idFrom;
962
963 wxToolBarToolBase *tool = FindById(id);
964 if ( !tool )
965 return FALSE;
966
967 return HandleTooltipNotify(code, lParam, tool->GetShortHelp());
968 #else
969 return FALSE;
970 #endif
971 }
972
973 // ----------------------------------------------------------------------------
974 // toolbar geometry
975 // ----------------------------------------------------------------------------
976
977 void wxToolBar::SetToolBitmapSize(const wxSize& size)
978 {
979 wxToolBarBase::SetToolBitmapSize(size);
980
981 ::SendMessage(GetHwnd(), TB_SETBITMAPSIZE, 0, MAKELONG(size.x, size.y));
982 }
983
984 void wxToolBar::SetRows(int nRows)
985 {
986 if ( nRows == m_maxRows )
987 {
988 // avoid resizing the frame uselessly
989 return;
990 }
991
992 // TRUE in wParam means to create at least as many rows, FALSE -
993 // at most as many
994 RECT rect;
995 ::SendMessage(GetHwnd(), TB_SETROWS,
996 MAKEWPARAM(nRows, !(GetWindowStyle() & wxTB_VERTICAL)),
997 (LPARAM) &rect);
998
999 m_maxRows = nRows;
1000
1001 UpdateSize();
1002 }
1003
1004 // The button size is bigger than the bitmap size
1005 wxSize wxToolBar::GetToolSize() const
1006 {
1007 // TB_GETBUTTONSIZE is supported from version 4.70
1008 #if defined(_WIN32_IE) && (_WIN32_IE >= 0x300 ) \
1009 && !( defined(__GNUWIN32__) && !wxCHECK_W32API_VERSION( 1, 0 ) )
1010 if ( wxTheApp->GetComCtl32Version() >= 470 )
1011 {
1012 DWORD dw = ::SendMessage(GetHwnd(), TB_GETBUTTONSIZE, 0, 0);
1013
1014 return wxSize(LOWORD(dw), HIWORD(dw));
1015 }
1016 else
1017 #endif // comctl32.dll 4.70+
1018 {
1019 // defaults
1020 return wxSize(m_defaultWidth + 8, m_defaultHeight + 7);
1021 }
1022 }
1023
1024 static
1025 wxToolBarToolBase *GetItemSkippingDummySpacers(const wxToolBarToolsList& tools,
1026 size_t index )
1027 {
1028 wxToolBarToolsList::compatibility_iterator current = tools.GetFirst();
1029
1030 for ( ; current != 0; current = current->GetNext() )
1031 {
1032 if ( index == 0 )
1033 return current->GetData();
1034
1035 wxToolBarTool *tool = (wxToolBarTool *)current->GetData();
1036 size_t separators = tool->GetSeparatorsCount();
1037
1038 // if it is a normal button, sepcount == 0, so skip 1 item (the button)
1039 // otherwise, skip as many items as the separator count, plus the
1040 // control itself
1041 index -= separators ? separators + 1 : 1;
1042 }
1043
1044 return 0;
1045 }
1046
1047 wxToolBarToolBase *wxToolBar::FindToolForPosition(wxCoord x, wxCoord y) const
1048 {
1049 POINT pt;
1050 pt.x = x;
1051 pt.y = y;
1052 int index = (int)::SendMessage(GetHwnd(), TB_HITTEST, 0, (LPARAM)&pt);
1053 // MBN: when the point ( x, y ) is close to the toolbar border
1054 // TB_HITTEST returns m_nButtons ( not -1 )
1055 if ( index < 0 || (size_t)index >= m_nButtons )
1056 {
1057 // it's a separator or there is no tool at all there
1058 return (wxToolBarToolBase *)NULL;
1059 }
1060
1061 // if comctl32 version < 4.71 wxToolBar95 adds dummy spacers
1062 #if defined(_WIN32_IE) && (_WIN32_IE >= 0x400 )
1063 if ( wxTheApp->GetComCtl32Version() >= 471 )
1064 {
1065 return m_tools.Item((size_t)index)->GetData();
1066 }
1067 else
1068 #endif
1069 {
1070 return GetItemSkippingDummySpacers( m_tools, (size_t) index );
1071 }
1072 }
1073
1074 void wxToolBar::UpdateSize()
1075 {
1076 // the toolbar size changed
1077 SendMessage(GetHwnd(), TB_AUTOSIZE, 0, 0);
1078
1079 // we must also refresh the frame after the toolbar size (possibly) changed
1080 wxFrame *frame = wxDynamicCast(GetParent(), wxFrame);
1081 if ( frame )
1082 {
1083 frame->SendSizeEvent();
1084 }
1085 }
1086
1087 // ----------------------------------------------------------------------------
1088 // toolbar styles
1089 // ---------------------------------------------------------------------------
1090
1091 void wxToolBar::SetWindowStyleFlag(long style)
1092 {
1093 // the style bits whose changes force us to recreate the toolbar
1094 static const long MASK_NEEDS_RECREATE = wxTB_TEXT | wxTB_NOICONS;
1095
1096 const long styleOld = GetWindowStyle();
1097
1098 wxToolBarBase::SetWindowStyleFlag(style);
1099
1100 // don't recreate an empty toolbar: not only this is unnecessary, but it is
1101 // also fatal as we'd then try to recreate the toolbar when it's just being
1102 // created
1103 if ( GetToolsCount() &&
1104 (style & MASK_NEEDS_RECREATE) != (styleOld & MASK_NEEDS_RECREATE) )
1105 {
1106 // to remove the text labels, simply re-realizing the toolbar is enough
1107 // but I don't know of any way to add the text to an existing toolbar
1108 // other than by recreating it entirely
1109 Recreate();
1110 }
1111 }
1112
1113 // ----------------------------------------------------------------------------
1114 // tool state
1115 // ----------------------------------------------------------------------------
1116
1117 void wxToolBar::DoEnableTool(wxToolBarToolBase *tool, bool enable)
1118 {
1119 ::SendMessage(GetHwnd(), TB_ENABLEBUTTON,
1120 (WPARAM)tool->GetId(), (LPARAM)MAKELONG(enable, 0));
1121 }
1122
1123 void wxToolBar::DoToggleTool(wxToolBarToolBase *tool, bool toggle)
1124 {
1125 ::SendMessage(GetHwnd(), TB_CHECKBUTTON,
1126 (WPARAM)tool->GetId(), (LPARAM)MAKELONG(toggle, 0));
1127 }
1128
1129 void wxToolBar::DoSetToggle(wxToolBarToolBase *WXUNUSED(tool), bool WXUNUSED(toggle))
1130 {
1131 // VZ: AFAIK, the button has to be created either with TBSTYLE_CHECK or
1132 // without, so we really need to delete the button and recreate it here
1133 wxFAIL_MSG( _T("not implemented") );
1134 }
1135
1136 // ----------------------------------------------------------------------------
1137 // event handlers
1138 // ----------------------------------------------------------------------------
1139
1140 // Responds to colour changes, and passes event on to children.
1141 void wxToolBar::OnSysColourChanged(wxSysColourChangedEvent& event)
1142 {
1143 wxRGBToColour(m_backgroundColour, ::GetSysColor(COLOR_BTNFACE));
1144
1145 // Remap the buttons
1146 Realize();
1147
1148 // Relayout the toolbar
1149 int nrows = m_maxRows;
1150 m_maxRows = 0; // otherwise SetRows() wouldn't do anything
1151 SetRows(nrows);
1152
1153 Refresh();
1154
1155 // let the event propagate further
1156 event.Skip();
1157 }
1158
1159 void wxToolBar::OnMouseEvent(wxMouseEvent& event)
1160 {
1161 if (event.Leaving() && m_pInTool)
1162 {
1163 OnMouseEnter( -1 );
1164 event.Skip();
1165 return;
1166 }
1167
1168 if (event.RightDown())
1169 {
1170 // For now, we don't have an id. Later we could
1171 // try finding the tool.
1172 OnRightClick((int)-1, event.GetX(), event.GetY());
1173 }
1174 else
1175 {
1176 event.Skip();
1177 }
1178 }
1179
1180 bool wxToolBar::HandleSize(WXWPARAM WXUNUSED(wParam), WXLPARAM lParam)
1181 {
1182 // calculate our minor dimension ourselves - we're confusing the standard
1183 // logic (TB_AUTOSIZE) with our horizontal toolbars and other hacks
1184 RECT r;
1185 if ( ::SendMessage(GetHwnd(), TB_GETITEMRECT, 0, (LPARAM)&r) )
1186 {
1187 int w, h;
1188
1189 if ( GetWindowStyle() & wxTB_VERTICAL )
1190 {
1191 w = r.right - r.left;
1192 if ( m_maxRows )
1193 {
1194 w *= (m_nButtons + m_maxRows - 1)/m_maxRows;
1195 }
1196 h = HIWORD(lParam);
1197 }
1198 else
1199 {
1200 w = LOWORD(lParam);
1201 if (HasFlag( wxTB_FLAT ))
1202 h = r.bottom - r.top - 3;
1203 else
1204 h = r.bottom - r.top;
1205 if ( m_maxRows )
1206 {
1207 // FIXME: hardcoded separator line height...
1208 h += HasFlag(wxTB_NODIVIDER) ? 4 : 6;
1209 h *= m_maxRows;
1210 }
1211 }
1212
1213 if ( MAKELPARAM(w, h) != lParam )
1214 {
1215 // size really changed
1216 SetSize(w, h);
1217 }
1218
1219 // message processed
1220 return TRUE;
1221 }
1222
1223 return FALSE;
1224 }
1225
1226 bool wxToolBar::HandlePaint(WXWPARAM wParam, WXLPARAM lParam)
1227 {
1228 // erase any dummy separators which we used for aligning the controls if
1229 // any here
1230
1231 // first of all, do we have any controls at all?
1232 wxToolBarToolsList::compatibility_iterator node;
1233 for ( node = m_tools.GetFirst(); node; node = node->GetNext() )
1234 {
1235 if ( node->GetData()->IsControl() )
1236 break;
1237 }
1238
1239 if ( !node )
1240 {
1241 // no controls, nothing to erase
1242 return FALSE;
1243 }
1244
1245 // prepare the DC on which we'll be drawing
1246 wxClientDC dc(this);
1247 dc.SetBrush(wxBrush(GetBackgroundColour(), wxSOLID));
1248 dc.SetPen(*wxTRANSPARENT_PEN);
1249
1250 RECT r;
1251 if ( !GetUpdateRect(GetHwnd(), &r, FALSE) )
1252 {
1253 // nothing to redraw anyhow
1254 return FALSE;
1255 }
1256
1257 wxRect rectUpdate;
1258 wxCopyRECTToRect(r, rectUpdate);
1259
1260 dc.SetClippingRegion(rectUpdate);
1261
1262 // draw the toolbar tools, separators &c normally
1263 wxControl::MSWWindowProc(WM_PAINT, wParam, lParam);
1264
1265 // for each control in the toolbar find all the separators intersecting it
1266 // and erase them
1267 //
1268 // NB: this is really the only way to do it as we don't know if a separator
1269 // corresponds to a control (i.e. is a dummy one) or a real one
1270 // otherwise
1271 for ( node = m_tools.GetFirst(); node; node = node->GetNext() )
1272 {
1273 wxToolBarToolBase *tool = node->GetData();
1274 if ( tool->IsControl() )
1275 {
1276 // get the control rect in our client coords
1277 wxControl *control = tool->GetControl();
1278 wxRect rectCtrl = control->GetRect();
1279
1280 // iterate over all buttons
1281 TBBUTTON tbb;
1282 int count = ::SendMessage(GetHwnd(), TB_BUTTONCOUNT, 0, 0);
1283 for ( int n = 0; n < count; n++ )
1284 {
1285 // is it a separator?
1286 if ( !::SendMessage(GetHwnd(), TB_GETBUTTON,
1287 n, (LPARAM)&tbb) )
1288 {
1289 wxLogDebug(_T("TB_GETBUTTON failed?"));
1290
1291 continue;
1292 }
1293
1294 if ( tbb.fsStyle != TBSTYLE_SEP )
1295 continue;
1296
1297 // get the bounding rect of the separator
1298 RECT r;
1299 if ( !::SendMessage(GetHwnd(), TB_GETITEMRECT,
1300 n, (LPARAM)&r) )
1301 {
1302 wxLogDebug(_T("TB_GETITEMRECT failed?"));
1303
1304 continue;
1305 }
1306
1307 // does it intersect the control?
1308 wxRect rectItem;
1309 wxCopyRECTToRect(r, rectItem);
1310 if ( rectCtrl.Intersects(rectItem) )
1311 {
1312 // yes, do erase it!
1313 dc.DrawRectangle(rectItem);
1314 }
1315 }
1316 }
1317 }
1318
1319 return TRUE;
1320 }
1321
1322 void wxToolBar::HandleMouseMove(WXWPARAM WXUNUSED(wParam), WXLPARAM lParam)
1323 {
1324 wxCoord x = GET_X_LPARAM(lParam),
1325 y = GET_Y_LPARAM(lParam);
1326 wxToolBarToolBase* tool = FindToolForPosition( x, y );
1327
1328 // cursor left current tool
1329 if( tool != m_pInTool && !tool )
1330 {
1331 m_pInTool = 0;
1332 OnMouseEnter( -1 );
1333 }
1334
1335 // cursor entered a tool
1336 if( tool != m_pInTool && tool )
1337 {
1338 m_pInTool = tool;
1339 OnMouseEnter( tool->GetId() );
1340 }
1341 }
1342
1343 long wxToolBar::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
1344 {
1345 switch ( nMsg )
1346 {
1347 case WM_SIZE:
1348 if ( HandleSize(wParam, lParam) )
1349 return 0;
1350 break;
1351
1352 case WM_MOUSEMOVE:
1353 // we don't handle mouse moves, so always pass the message to
1354 // wxControl::MSWWindowProc
1355 HandleMouseMove(wParam, lParam);
1356 break;
1357
1358 case WM_PAINT:
1359 if ( HandlePaint(wParam, lParam) )
1360 return 0;
1361 }
1362
1363 return wxControl::MSWWindowProc(nMsg, wParam, lParam);
1364 }
1365
1366 // ----------------------------------------------------------------------------
1367 // private functions
1368 // ----------------------------------------------------------------------------
1369
1370 WXHBITMAP wxToolBar::MapBitmap(WXHBITMAP bitmap, int width, int height)
1371 {
1372 MemoryHDC hdcMem;
1373
1374 if ( !hdcMem )
1375 {
1376 wxLogLastError(_T("CreateCompatibleDC"));
1377
1378 return bitmap;
1379 }
1380
1381 SelectInHDC bmpInHDC(hdcMem, (HBITMAP)bitmap);
1382
1383 if ( !bmpInHDC )
1384 {
1385 wxLogLastError(_T("SelectObject"));
1386
1387 return bitmap;
1388 }
1389
1390 wxCOLORMAP *cmap = wxGetStdColourMap();
1391
1392 for ( int i = 0; i < width; i++ )
1393 {
1394 for ( int j = 0; j < height; j++ )
1395 {
1396 COLORREF pixel = ::GetPixel(hdcMem, i, j);
1397
1398 for ( size_t k = 0; k < wxSTD_COL_MAX; k++ )
1399 {
1400 COLORREF col = cmap[k].from;
1401 if ( abs(GetRValue(pixel) - GetRValue(col)) < 10 &&
1402 abs(GetGValue(pixel) - GetGValue(col)) < 10 &&
1403 abs(GetBValue(pixel) - GetBValue(col)) < 10 )
1404 {
1405 ::SetPixel(hdcMem, i, j, cmap[k].to);
1406 break;
1407 }
1408 }
1409 }
1410 }
1411
1412 return bitmap;
1413
1414 // VZ: I leave here my attempts to map the bitmap to the system colours
1415 // faster by using BitBlt() even though it's broken currently - but
1416 // maybe someone else can finish it? It should be faster than iterating
1417 // over all pixels...
1418 #if 0
1419 MemoryHDC hdcMask, hdcDst;
1420 if ( !hdcMask || !hdcDst )
1421 {
1422 wxLogLastError(_T("CreateCompatibleDC"));
1423
1424 return bitmap;
1425 }
1426
1427 // create the target bitmap
1428 HBITMAP hbmpDst = ::CreateCompatibleBitmap(hdcDst, width, height);
1429 if ( !hbmpDst )
1430 {
1431 wxLogLastError(_T("CreateCompatibleBitmap"));
1432
1433 return bitmap;
1434 }
1435
1436 // create the monochrome mask bitmap
1437 HBITMAP hbmpMask = ::CreateBitmap(width, height, 1, 1, 0);
1438 if ( !hbmpMask )
1439 {
1440 wxLogLastError(_T("CreateBitmap(mono)"));
1441
1442 ::DeleteObject(hbmpDst);
1443
1444 return bitmap;
1445 }
1446
1447 SelectInHDC bmpInDst(hdcDst, hbmpDst),
1448 bmpInMask(hdcMask, hbmpMask);
1449
1450 // for each colour:
1451 for ( n = 0; n < NUM_OF_MAPPED_COLOURS; n++ )
1452 {
1453 // create the mask for this colour
1454 ::SetBkColor(hdcMem, ColorMap[n].from);
1455 ::BitBlt(hdcMask, 0, 0, width, height, hdcMem, 0, 0, SRCCOPY);
1456
1457 // replace this colour with the target one in the dst bitmap
1458 HBRUSH hbr = ::CreateSolidBrush(ColorMap[n].to);
1459 HGDIOBJ hbrOld = ::SelectObject(hdcDst, hbr);
1460
1461 ::MaskBlt(hdcDst, 0, 0, width, height,
1462 hdcMem, 0, 0,
1463 hbmpMask, 0, 0,
1464 MAKEROP4(PATCOPY, SRCCOPY));
1465
1466 (void)::SelectObject(hdcDst, hbrOld);
1467 ::DeleteObject(hbr);
1468 }
1469
1470 ::DeleteObject((HBITMAP)bitmap);
1471
1472 return (WXHBITMAP)hbmpDst;
1473 #endif // 0
1474 }
1475
1476 #endif // wxUSE_TOOLBAR && Win95
1477