]>
Commit | Line | Data |
---|---|---|
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 | 107 | IMPLEMENT_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 |
128 | BEGIN_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 | 132 | END_EVENT_TABLE() |
2bda0e17 | 133 | |
8a0681f9 VZ |
134 | // ---------------------------------------------------------------------------- |
135 | // private classes | |
136 | // ---------------------------------------------------------------------------- | |
137 | ||
138 | class wxToolBarTool : public wxToolBarToolBase | |
139 | { | |
140 | public: | |
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 | ||
215 | private: | |
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 | 230 | wxToolBarToolBase *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 |
243 | wxToolBarToolBase * |
244 | wxToolBar::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 | ||
253 | void 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 |
266 | bool 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 | 300 | bool 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 |
316 | void wxToolBar::Recreate() |
317 | { | |
318 | const HWND hwndOld = GetHwnd(); | |
319 | if ( !hwndOld ) | |
320 | { | |
321 | // we haven't been created yet, no need to recreate | |
322 | return; | |
323 | } | |
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 | 369 | wxToolBar::~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 |
383 | wxSize 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 | ||
426 | WXDWORD wxToolBar::MSWGetStyle(long style, WXDWORD *exstyle) const | |
427 | { | |
428 | // toolbars never have border, giving one to them results in broken | |
429 | // appearance | |
430 | WXDWORD msStyle = wxControl::MSWGetStyle | |
431 | ( | |
432 | (style & ~wxBORDER_MASK) | wxBORDER_NONE, exstyle | |
433 | ); | |
434 | ||
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 | 476 | bool 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 | 486 | bool 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 |
566 | void 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 | 601 | bool 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 | 1183 | bool 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 | 1223 | bool 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 | 1288 | void 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 | 1295 | void 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 | |
1316 | wxSize 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 |
1336 | static |
1337 | wxToolBarToolBase *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 | 1359 | wxToolBarToolBase *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 | 1386 | void 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 |
1410 | long wxToolBar::GetMSWToolbarStyle() const | |
1411 | { | |
1412 | return ::SendMessage(GetHwnd(), TB_GETSTYLE, 0, 0L); | |
1413 | } | |
1414 | ||
c631abda VZ |
1415 | void 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 | 1441 | void 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 | 1447 | void 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 | 1453 | void 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 |
1460 | void 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 | ||
1472 | void 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 | 1489 | void 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 | 1507 | void 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. | |
1538 | void 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 | 1618 | bool 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 | ||
1664 | bool 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 | 1813 | void 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 | 1827 | WXLRESULT 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 | 1861 | WXHBITMAP 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 |