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