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