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