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