]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/msw/tbarmsw.cpp
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
info about digitalmars in header
[wxWidgets.git] / src / msw / tbarmsw.cpp
... / ...
CommitLineData
1/////////////////////////////////////////////////////////////////////////////
2// Name: tbarmsw.cpp
3// Purpose: wxToolBar
4// Author: Julian Smart
5// Modified by: 13.12.99 by VZ during toolbar classes reorganization
6// Created: 04/01/98
7// RCS-ID: $Id$
8// Copyright: (c) Julian Smart
9// Licence: wxWindows licence
10/////////////////////////////////////////////////////////////////////////////
11
12// ============================================================================
13// declarations
14// ============================================================================
15
16// ----------------------------------------------------------------------------
17// headers
18// ----------------------------------------------------------------------------
19
20#ifdef __GNUG__
21 #pragma implementation "tbarmsw.h"
22#endif
23
24// For compilers that support precompilation, includes "wx.h".
25#include "wx/wxprec.h"
26
27#ifdef __BORLANDC__
28 #pragma hdrstop
29#endif
30
31#ifndef WX_PRECOMP
32 #include "wx/wx.h"
33#endif
34
35#if wxUSE_TOOLBAR && defined(__WIN16__)
36
37#if !defined(__GNUWIN32__) && !defined(__SALFORDC__)
38 #include "malloc.h"
39#endif
40
41#if !defined(__MWERKS__) && !defined(__SALFORDC__)
42 #include <memory.h>
43#endif
44
45#include <stdlib.h>
46
47#include "wx/msw/tbarmsw.h"
48#include "wx/event.h"
49#include "wx/app.h"
50#include "wx/bitmap.h"
51#include "wx/msw/private.h"
52#include "wx/msw/dib.h"
53
54// ----------------------------------------------------------------------------
55// constants
56// ----------------------------------------------------------------------------
57
58#define DEFAULTBITMAPX 16
59#define DEFAULTBITMAPY 15
60#define DEFAULTBUTTONX 24
61#define DEFAULTBUTTONY 22
62#define DEFAULTBARHEIGHT 27
63
64//
65// States (not all of them currently used)
66//
67#define wxTBSTATE_CHECKED 0x01 // radio button is checked
68#define wxTBSTATE_PRESSED 0x02 // button is being depressed (any style)
69#define wxTBSTATE_ENABLED 0x04 // button is enabled
70#define wxTBSTATE_HIDDEN 0x08 // button is hidden
71#define wxTBSTATE_INDETERMINATE 0x10 // button is indeterminate
72
73// ----------------------------------------------------------------------------
74// private classes
75// ----------------------------------------------------------------------------
76
77class WXDLLEXPORT wxToolBarTool : public wxToolBarToolBase
78{
79public:
80 wxToolBarTool(wxToolBar *tbar,
81 int id,
82 const wxBitmap& bmpNormal,
83 const wxBitmap& bmpDisabled,
84 bool toggle,
85 wxObject *clientData,
86 const wxString& shortHelp,
87 const wxString& longHelp)
88 : wxToolBarToolBase(tbar, id, bmpNormal, bmpDisabled, toggle,
89 clientData, shortHelp, longHelp)
90 {
91 }
92
93 wxToolBarTool(wxToolBar *tbar, wxControl *control)
94 : wxToolBarToolBase(tbar, control)
95 {
96 }
97
98 void SetSize(const wxSize& size)
99 {
100 m_width = size.x;
101 m_height = size.y;
102 }
103
104 long GetWidth() const { return m_width; }
105 long GetHeight() const { return m_height; }
106
107 wxCoord m_x;
108 wxCoord m_y;
109 wxCoord m_width;
110 wxCoord m_height;
111};
112
113// ----------------------------------------------------------------------------
114// wxWin macros
115// ----------------------------------------------------------------------------
116
117#if !USE_SHARED_LIBRARY
118IMPLEMENT_DYNAMIC_CLASS(wxToolBar, wxToolBarBase)
119
120BEGIN_EVENT_TABLE(wxToolBar, wxToolBarBase)
121 EVT_PAINT(wxToolBar::OnPaint)
122 EVT_MOUSE_EVENTS(wxToolBar::OnMouseEvent)
123END_EVENT_TABLE()
124#endif
125
126// ============================================================================
127// implementation
128// ============================================================================
129
130// ----------------------------------------------------------------------------
131// wxToolBarTool
132// ----------------------------------------------------------------------------
133
134wxToolBarToolBase *wxToolBar::CreateTool(int id,
135 const wxString& label,
136 const wxBitmap& bmpNormal,
137 const wxBitmap& bmpDisabled,
138 wxItemKind kind,
139 wxObject *clientData,
140 const wxString& shortHelp,
141 const wxString& longHelp)
142{
143 return new wxToolBarTool(this, id, label, bmpNormal, bmpDisabled, kind,
144 clientData, shortHelp, longHelp);
145}
146
147wxToolBarToolBase *wxToolBar::CreateTool(wxControl *control)
148{
149 return new wxToolBarTool(this, control);
150}
151
152// ----------------------------------------------------------------------------
153// wxToolBar
154// ----------------------------------------------------------------------------
155
156void wxToolBar::Init()
157{
158 m_hbrDither = 0;
159 m_rgbFace = 0;
160 m_rgbShadow = 0;
161 m_rgbHilight = 0;
162 m_rgbFrame = 0;
163 m_hdcMono = 0;
164 m_hbmMono = 0;
165 m_hbmDefault = 0;
166
167 m_defaultWidth = DEFAULTBITMAPX;
168 m_defaultHeight = DEFAULTBITMAPY;
169
170 m_xPos =
171 m_yPos = -1;
172
173 m_maxWidth = m_maxHeight = 0;
174 m_pressedTool = m_currentTool = -1;
175 m_toolPacking = 1;
176 m_toolSeparation = 5;
177}
178
179bool wxToolBar::Create(wxWindow *parent,
180 wxWindowID id,
181 const wxPoint& pos,
182 const wxSize& size,
183 long style,
184 const wxString& name)
185{
186 if ( !wxWindow::Create(parent, id, pos, size, style, name) )
187 return FALSE;
188
189 if ( style & wxTB_HORIZONTAL )
190 {
191 m_lastX = 3;
192 m_lastY = 7;
193 }
194 else
195 {
196 m_lastX = 7;
197 m_lastY = 3;
198 }
199
200 // Set it to grey
201 SetBackgroundColour(wxColour(192, 192, 192));
202
203 InitGlobalObjects();
204
205 return TRUE;
206}
207
208wxToolBar::~wxToolBar()
209{
210 FreeGlobalObjects();
211}
212
213void wxToolBar::SetToolBitmapSize(const wxSize& size)
214{
215 m_defaultWidth = size.x;
216 m_defaultHeight = size.y;
217
218 FreeGlobalObjects();
219 InitGlobalObjects();
220}
221
222// The button size is bigger than the bitmap size
223wxSize wxToolBar::GetToolSize() const
224{
225 return wxSize(m_defaultWidth + 8, m_defaultHeight + 7);
226}
227
228wxToolBarToolBase *wxToolBar::FindToolForPosition(wxCoord x, wxCoord y) const
229{
230 wxToolBarToolsList::Node *node = m_tools.GetFirst();
231 while (node)
232 {
233 wxToolBarTool *tool = (wxToolBarTool *)node->GetData();
234 if ((x >= tool->m_x) && (y >= tool->m_y) &&
235 (x <= (tool->m_x + tool->GetWidth())) &&
236 (y <= (tool->m_y + tool->GetHeight())))
237 {
238 return tool;
239 }
240
241 node = node->GetNext();
242 }
243
244 return (wxToolBarToolBase *)NULL;
245}
246
247wxToolBarToolBase *wxToolBar::AddTool(int id,
248 const wxBitmap& bitmap,
249 const wxBitmap& pushedBitmap,
250 bool toggle,
251 wxCoord xPos,
252 wxCoord yPos,
253 wxObject *clientData,
254 const wxString& helpString1,
255 const wxString& helpString2)
256{
257 // rememeber the position for DoInsertTool()
258 m_xPos = xPos;
259 m_yPos = yPos;
260
261 return wxToolBarBase::AddTool(id, bitmap, pushedBitmap, toggle,
262 xPos, yPos, clientData,
263 helpString1, helpString2);
264}
265
266void wxToolBar::OnPaint(wxPaintEvent& event)
267{
268 wxPaintDC dc(this);
269
270 static int wxOnPaintCount = 0;
271
272 // Prevent reentry of OnPaint which would cause
273 // wxMemoryDC errors.
274 if (wxOnPaintCount > 0)
275 return;
276 wxOnPaintCount++;
277
278 wxToolBarToolsList::Node *node = m_tools.GetFirst();
279 while (node)
280 {
281 wxToolBarToolBase *tool = node->GetData();
282 if ( tool->GetStyle()!= wxTOOL_STYLE_BUTTON )
283 {
284 int state = tool->IsEnabled() ? wxTBSTATE_ENABLED : 0;
285 if ( tool->IsToggled() )
286 state |= wxTBSTATE_CHECKED;
287
288 DrawTool(dc, tool, state);
289 }
290
291 node = node->GetNext();
292 }
293
294 wxOnPaintCount--;
295}
296
297// If a Button is disabled, then NO function (besides leaving
298// or entering) should be carried out. Therefore the additions
299// of 'enabled' testing (Stefan Hammes).
300void wxToolBar::OnMouseEvent(wxMouseEvent& event)
301{
302 static wxToolBarToolBase *eventCurrentTool = NULL;
303 wxClientDC dc(this);
304
305 if (event.Leaving())
306 {
307 m_currentTool = -1;
308 if (eventCurrentTool && eventCurrentTool->IsEnabled())
309 {
310 ::ReleaseCapture();
311 int state = wxTBSTATE_ENABLED;
312 if (eventCurrentTool->IsToggled())
313 state |= wxTBSTATE_CHECKED;
314 DrawTool(dc, eventCurrentTool, state);
315 eventCurrentTool = NULL;
316 }
317 OnMouseEnter(-1);
318 return;
319 }
320
321 wxCoord x, y;
322 event.GetPosition(&x, &y);
323 wxToolBarToolBase *tool = FindToolForPosition(x, y);
324
325 if (!tool)
326 {
327 if (eventCurrentTool && eventCurrentTool->IsEnabled())
328 {
329 ::ReleaseCapture();
330
331 int state = wxTBSTATE_ENABLED;
332 if (eventCurrentTool->IsToggled())
333 state |= wxTBSTATE_CHECKED;
334 DrawTool(dc, eventCurrentTool, state);
335 eventCurrentTool = NULL;
336 }
337 if (m_currentTool > -1)
338 {
339 m_currentTool = -1;
340 OnMouseEnter(-1);
341 }
342 return;
343 }
344
345 if (!event.Dragging() && !event.IsButton())
346 {
347 if (tool->GetId() != m_currentTool)
348 {
349 OnMouseEnter(m_currentTool = tool->GetId());
350 return;
351 }
352 }
353 if (event.Dragging() && tool->IsEnabled())
354 {
355 if (eventCurrentTool)
356 {
357 // Might have dragged outside tool
358 if (eventCurrentTool != tool)
359 {
360 int state = wxTBSTATE_ENABLED;
361 if (tool->IsToggled())
362 state |= wxTBSTATE_CHECKED;
363 DrawTool(dc, tool, state);
364 eventCurrentTool = NULL;
365 return;
366 }
367 }
368 else
369 {
370 if (tool && event.LeftIsDown() && tool->IsEnabled())
371 {
372 eventCurrentTool = tool;
373 ::SetCapture((HWND) GetHWND());
374 int state = wxTBSTATE_ENABLED|wxTBSTATE_PRESSED;
375 if (tool->IsToggled())
376 state |= wxTBSTATE_CHECKED;
377 DrawTool(dc, tool, state);
378 }
379 }
380 }
381 if (event.LeftDown() && tool->IsEnabled())
382 {
383 eventCurrentTool = tool;
384 ::SetCapture((HWND) GetHWND());
385 int state = wxTBSTATE_ENABLED|wxTBSTATE_PRESSED;
386 if (tool->IsToggled())
387 state |= wxTBSTATE_CHECKED;
388 DrawTool(dc, tool, state);
389 }
390 else if (event.LeftUp() && tool->IsEnabled())
391 {
392 if (eventCurrentTool)
393 ::ReleaseCapture();
394 if (eventCurrentTool == tool)
395 {
396 if (tool->CanBeToggled())
397 {
398 tool->Toggle();
399 if (!OnLeftClick(tool->GetId(), tool->IsToggled()))
400 {
401 tool->Toggle();
402 }
403 int state = wxTBSTATE_ENABLED;
404 if (tool->IsToggled())
405 state |= wxTBSTATE_CHECKED;
406 DrawTool(dc, tool, state);
407 }
408 else
409 {
410 int state = wxTBSTATE_ENABLED;
411 if (tool->IsToggled())
412 state |= wxTBSTATE_CHECKED;
413 DrawTool(dc, tool, state);
414 OnLeftClick(tool->GetId(), tool->IsToggled());
415 }
416 }
417 eventCurrentTool = NULL;
418 }
419 else if (event.RightDown() && tool->IsEnabled())
420 {
421 OnRightClick(tool->GetId(), x, y);
422 }
423}
424
425void wxToolBar::DoEnableTool(wxToolBarToolBase *tool, bool WXUNUSED(enable))
426{
427 DoRedrawTool(tool);
428}
429
430void wxToolBar::DoToggleTool(wxToolBarToolBase *tool, bool WXUNUSED(toggle))
431{
432 DoRedrawTool(tool);
433}
434
435void wxToolBar::DoSetToggle(wxToolBarToolBase * WXUNUSED(tool),
436 bool WXUNUSED(toggle))
437{
438 // nothing to do
439}
440
441void wxToolBar::DoRedrawTool(wxToolBarToolBase *tool)
442{
443 wxClientDC dc(this);
444
445 DrawTool(dc, tool);
446}
447
448void wxToolBar::DrawTool(wxDC& dc, wxToolBarToolBase *toolBase, int state)
449{
450 wxToolBarTool *tool = (wxToolBarTool *)toolBase;
451
452 DrawButton(dc.GetHDC(),
453 tool->m_x, tool->m_y,
454 tool->GetWidth(), tool->GetHeight(),
455 tool, state);
456}
457
458void wxToolBar::DrawTool(wxDC& dc, wxToolBarToolBase *tool)
459{
460 int state = 0;
461 if (tool->IsEnabled())
462 state |= wxTBSTATE_ENABLED;
463 if (tool->IsToggled())
464 state |= wxTBSTATE_CHECKED;
465 // how can i access the PRESSED state???
466
467 DrawTool(dc, tool, state);
468}
469
470bool wxToolBar::DoDeleteTool(size_t WXUNUSED(pos),
471 wxToolBarToolBase *tool)
472{
473 // VZ: didn't test whether it works, but why not...
474 tool->Detach();
475
476 Refresh();
477
478 return TRUE;
479}
480
481bool wxToolBar::DoInsertTool(size_t pos, wxToolBarToolBase *toolBase)
482{
483 wxToolBarTool *tool = (wxToolBarTool *)toolBase;
484
485 wxCHECK_MSG( !tool->IsControl(), FALSE,
486 _T("generic wxToolBar doesn't support controls") );
487
488 // TODO: use the mapping code from wxToolBar95 to get it right in this class
489#if !defined(__WIN32__) && !defined(__WIN386__)
490 wxBitmap bmpDisabled;
491 if (tool->CanBeToggled())
492 {
493 HBITMAP hbmp = CreateMappedBitmap((WXHINSTANCE)wxGetInstance(),
494 GetHbitmapOf(tool->GetBitmap1()));
495
496 wxBitmap bmp;
497 bmp.SetHBITMAP((WXHBITMAP)hbmp);
498 tool->SetBitmap2(bmp);
499 }
500#endif
501
502 tool->m_x = m_xPos;
503 if ( tool->m_x == -1 )
504 tool->m_x = m_xMargin;
505
506 tool->m_y = m_yPos;
507 if ( tool->m_y == -1 )
508 tool->m_y = m_yMargin;
509
510 tool->SetSize(GetToolSize());
511
512 if ( tool->IsButton() )
513 {
514 // Calculate reasonable max size in case Layout() not called
515 if ((tool->m_x + tool->GetBitmap1().GetWidth() + m_xMargin) > m_maxWidth)
516 m_maxWidth = (tool->m_x + tool->GetWidth() + m_xMargin);
517
518 if ((tool->m_y + tool->GetBitmap1().GetHeight() + m_yMargin) > m_maxHeight)
519 m_maxHeight = (tool->m_y + tool->GetHeight() + m_yMargin);
520 }
521
522 return TRUE;
523}
524
525bool wxToolBar::Realize()
526{
527 m_currentRowsOrColumns = 0;
528 m_lastX = m_xMargin;
529 m_lastY = m_yMargin;
530 int maxToolWidth = 0;
531 int maxToolHeight = 0;
532 m_maxWidth = 0;
533 m_maxHeight = 0;
534
535 // Find the maximum tool width and height
536 wxToolBarToolsList::Node *node = m_tools.GetFirst();
537 while (node)
538 {
539 wxToolBarTool *tool = (wxToolBarTool *)node->GetData();
540 if (tool->GetWidth() > maxToolWidth)
541 maxToolWidth = tool->GetWidth();
542 if (tool->GetHeight() > maxToolHeight)
543 maxToolHeight = tool->GetHeight();
544 node = node->GetNext();
545 }
546
547 int separatorSize = m_toolSeparation;
548
549 node = m_tools.GetFirst();
550 while (node)
551 {
552 wxToolBarTool *tool = (wxToolBarTool *)node->GetData();
553 if (tool->GetStyle() == wxTOOL_STYLE_SEPARATOR)
554 {
555 if ( GetWindowStyleFlag() & wxTB_HORIZONTAL )
556 {
557 if (m_currentRowsOrColumns >= m_maxCols)
558 m_lastY += separatorSize;
559 else
560 m_lastX += separatorSize;
561 }
562 else
563 {
564 if (m_currentRowsOrColumns >= m_maxRows)
565 m_lastX += separatorSize;
566 else
567 m_lastY += separatorSize;
568 }
569 }
570 else if (tool->GetStyle() == wxTOOL_STYLE_BUTTON)
571 {
572 if ( GetWindowStyleFlag() & wxTB_HORIZONTAL )
573 {
574 if (m_currentRowsOrColumns >= m_maxCols)
575 {
576 m_currentRowsOrColumns = 0;
577 m_lastX = m_xMargin;
578 m_lastY += maxToolHeight + m_toolPacking;
579 }
580 tool->m_x = (long) (m_lastX + (maxToolWidth - tool->GetWidth())/2.0);
581 tool->m_y = (long) (m_lastY + (maxToolHeight - tool->GetHeight())/2.0);
582
583 m_lastX += maxToolWidth + m_toolPacking;
584 }
585 else
586 {
587 if (m_currentRowsOrColumns >= m_maxRows)
588 {
589 m_currentRowsOrColumns = 0;
590 m_lastX += (maxToolWidth + m_toolPacking);
591 m_lastY = m_yMargin;
592 }
593 tool->m_x = (long) (m_lastX + (maxToolWidth - tool->GetWidth())/2.0);
594 tool->m_y = (long) (m_lastY + (maxToolHeight - tool->GetHeight())/2.0);
595
596 m_lastY += maxToolHeight + m_toolPacking;
597 }
598 m_currentRowsOrColumns ++;
599 }
600
601 if (m_lastX > m_maxWidth)
602 m_maxWidth = m_lastX;
603 if (m_lastY > m_maxHeight)
604 m_maxHeight = m_lastY;
605
606 node = node->GetNext();
607 }
608
609 if ( GetWindowStyleFlag() & wxTB_HORIZONTAL )
610 {
611 m_maxWidth += maxToolWidth;
612 m_maxHeight += maxToolHeight;
613 }
614 else
615 {
616 m_maxWidth += maxToolWidth;
617 m_maxHeight += maxToolHeight;
618 }
619
620 m_maxWidth += m_xMargin;
621 m_maxHeight += m_yMargin;
622
623 SetSize(m_maxWidth, m_maxHeight);
624
625 return TRUE;
626}
627
628bool wxToolBar::InitGlobalObjects()
629{
630 GetSysColors();
631 if (!CreateDitherBrush())
632 return FALSE;
633
634 m_hdcMono = (WXHDC) CreateCompatibleDC(NULL);
635 if (!m_hdcMono)
636 return FALSE;
637
638 m_hbmMono = (WXHBITMAP) CreateBitmap((int)GetToolSize().x, (int)GetToolSize().y, 1, 1, NULL);
639 if (!m_hbmMono)
640 return FALSE;
641
642 m_hbmDefault = (WXHBITMAP) SelectObject((HDC) m_hdcMono, (HBITMAP) m_hbmMono);
643 return TRUE;
644}
645
646void wxToolBar::FreeGlobalObjects()
647{
648 FreeDitherBrush();
649
650 if (m_hdcMono) {
651 if (m_hbmDefault)
652 {
653 SelectObject((HDC) m_hdcMono, (HBITMAP) m_hbmDefault);
654 m_hbmDefault = 0;
655 }
656 DeleteDC((HDC) m_hdcMono); // toast the DCs
657 }
658 m_hdcMono = 0;
659
660 if (m_hbmMono)
661 DeleteObject((HBITMAP) m_hbmMono);
662 m_hbmMono = 0;
663}
664
665// ----------------------------------------------------------------------------
666// drawing routines
667// ----------------------------------------------------------------------------
668
669void wxToolBar::PatB(WXHDC hdc,int x,int y,int dx,int dy, long rgb)
670{
671 RECT rc;
672
673 rc.left = x;
674 rc.top = y;
675 rc.right = x + dx;
676 rc.bottom = y + dy;
677
678 SetBkColor((HDC) hdc,rgb);
679 ExtTextOut((HDC) hdc,0,0,ETO_OPAQUE,&rc,NULL,0,NULL);
680}
681
682
683// create a mono bitmap mask:
684// 1's where color == COLOR_BTNFACE || COLOR_HILIGHT
685// 0's everywhere else
686
687void wxToolBar::CreateMask(WXHDC hdc, int xoffset, int yoffset, int dx, int dy)
688{
689 HDC globalDC = ::GetDC(NULL);
690 HDC hdcGlyphs = CreateCompatibleDC((HDC) globalDC);
691 ReleaseDC(NULL, (HDC) globalDC);
692
693 // krj - create a new bitmap and copy the image from hdc.
694 //HBITMAP bitmapOld = SelectObject(hdcGlyphs, hBitmap);
695 HBITMAP hBitmap = CreateCompatibleBitmap((HDC) hdc, dx, dy);
696 HBITMAP bitmapOld = (HBITMAP) SelectObject(hdcGlyphs, hBitmap);
697 BitBlt(hdcGlyphs, 0,0, dx, dy, (HDC) hdc, 0, 0, SRCCOPY);
698
699 // initalize whole area with 1's
700 PatBlt((HDC) m_hdcMono, 0, 0, dx, dy, WHITENESS);
701
702 // create mask based on color bitmap
703 // convert this to 1's
704 SetBkColor(hdcGlyphs, m_rgbFace);
705 BitBlt((HDC) m_hdcMono, xoffset, yoffset, (int)GetToolBitmapSize().x, (int)GetToolBitmapSize().y,
706 hdcGlyphs, 0, 0, SRCCOPY);
707 // convert this to 1's
708 SetBkColor(hdcGlyphs, m_rgbHilight);
709 // OR in the new 1's
710 BitBlt((HDC) m_hdcMono, xoffset, yoffset, (int)GetToolBitmapSize().x, (int)GetToolBitmapSize().y,
711 hdcGlyphs, 0, 0, SRCPAINT);
712
713 SelectObject(hdcGlyphs, bitmapOld);
714 DeleteObject(hBitmap);
715 DeleteDC(hdcGlyphs);
716}
717
718void wxToolBar::DrawBlankButton(WXHDC hdc, int x, int y, int dx, int dy, int state)
719{
720 // face color
721 PatB(hdc, x, y, dx, dy, m_rgbFace);
722
723 if (state & wxTBSTATE_PRESSED) {
724 PatB(hdc, x + 1, y, dx - 2, 1, m_rgbFrame);
725 PatB(hdc, x + 1, y + dy - 1, dx - 2, 1, m_rgbFrame);
726 PatB(hdc, x, y + 1, 1, dy - 2, m_rgbFrame);
727 PatB(hdc, x + dx - 1, y +1, 1, dy - 2, m_rgbFrame);
728 PatB(hdc, x + 1, y + 1, 1, dy-2, m_rgbShadow);
729 PatB(hdc, x + 1, y + 1, dx-2, 1, m_rgbShadow);
730 }
731 else {
732 PatB(hdc, x + 1, y, dx - 2, 1, m_rgbFrame);
733 PatB(hdc, x + 1, y + dy - 1, dx - 2, 1, m_rgbFrame);
734 PatB(hdc, x, y + 1, 1, dy - 2, m_rgbFrame);
735 PatB(hdc, x + dx - 1, y + 1, 1, dy - 2, m_rgbFrame);
736 dx -= 2;
737 dy -= 2;
738 PatB(hdc, x + 1, y + 1, 1, dy - 1, m_rgbHilight);
739 PatB(hdc, x + 1, y + 1, dx - 1, 1, m_rgbHilight);
740 PatB(hdc, x + dx, y + 1, 1, dy, m_rgbShadow);
741 PatB(hdc, x + 1, y + dy, dx, 1, m_rgbShadow);
742 PatB(hdc, x + dx - 1, y + 2, 1, dy - 2, m_rgbShadow);
743 PatB(hdc, x + 2, y + dy - 1, dx - 2, 1, m_rgbShadow);
744 }
745}
746
747void wxToolBar::DrawButton(WXHDC hdc, int x, int y, int dx, int dy,
748 wxToolBarToolBase *toolBase, int state)
749{
750 wxToolBarTool *tool = (wxToolBarTool *)toolBase;
751
752 int yOffset;
753 HBRUSH hbrOld, hbr;
754 BOOL bMaskCreated = FALSE;
755 int xButton = 0; // assume button is down
756 int dxFace, dyFace;
757 int xCenterOffset;
758
759 dxFace = dx;
760 dyFace = dy;
761
762// HBITMAP hBitmap = (HBITMAP) tool->m_bitmap1.GetHBITMAP();
763 HDC globalDC = ::GetDC(NULL);
764 HDC hdcGlyphs = CreateCompatibleDC(globalDC);
765 ReleaseDC(NULL, globalDC);
766
767 // get the proper button look - up or down.
768 if (!(state & (wxTBSTATE_PRESSED | wxTBSTATE_CHECKED))) {
769 xButton = dx; // use 'up' version of button
770 dxFace -= 2;
771 dyFace -= 2; // extents to ignore button highlight
772 }
773
774 DrawBlankButton(hdc, x, y, dx, dy, state);
775
776
777 // move coordinates inside border and away from upper left highlight.
778 // the extents change accordingly.
779 x += 2;
780 y += 2;
781 dxFace -= 3;
782 dyFace -= 3;
783
784 // Using bmpDisabled can cause problems (don't know why!)
785#if !defined(__WIN32__) && !defined(__WIN386__)
786 HBITMAP bitmapOld;
787 if (tool->GetBitmap2().Ok())
788 bitmapOld = GetHbitmapOf(tool->GetBitmap2());
789 else
790 bitmapOld = GetHbitmapOf(tool->GetBitmap1());
791#else
792 HBITMAP bitmapOld = GetHbitmapOf(tool->GetBitmap1());
793#endif
794
795 bitmapOld = (HBITMAP)SelectObject(hdcGlyphs, bitmapOld);
796
797 // calculate offset of face from (x,y). y is always from the top,
798 // so the offset is easy. x needs to be centered in face.
799 yOffset = 1;
800 xCenterOffset = (dxFace - (int)GetToolBitmapSize().x)/2;
801 if (state & (wxTBSTATE_PRESSED | wxTBSTATE_CHECKED))
802 {
803 // pressed state moves down and to the right
804 // (x moves automatically as face size grows)
805 yOffset++;
806 }
807
808 // now put on the face
809 if (state & wxTBSTATE_ENABLED) {
810 // regular version
811 BitBlt((HDC) hdc, x+xCenterOffset, y + yOffset, (int)GetToolBitmapSize().x, (int)GetToolBitmapSize().y,
812 hdcGlyphs, 0, 0, SRCCOPY);
813 } else {
814 // disabled version (or indeterminate)
815 bMaskCreated = TRUE;
816 CreateMask((WXHDC) hdcGlyphs, xCenterOffset, yOffset, dxFace, dyFace);
817// CreateMask(hBitmap, xCenterOffset, yOffset, dxFace, dyFace);
818
819 SetTextColor((HDC) hdc, 0L); // 0's in mono -> 0 (for ROP)
820 SetBkColor((HDC) hdc, 0x00FFFFFF); // 1's in mono -> 1
821
822 // draw glyph's white understrike
823 if (!(state & wxTBSTATE_INDETERMINATE)) {
824 hbr = CreateSolidBrush(m_rgbHilight);
825 if (hbr) {
826 hbrOld = (HBRUSH) SelectObject((HDC) hdc, hbr);
827 if (hbrOld) {
828 // draw hilight color where we have 0's in the mask
829 BitBlt((HDC) hdc, x + 1, y + 1, dxFace, dyFace, (HDC) m_hdcMono, 0, 0, 0x00B8074A);
830 SelectObject((HDC) hdc, hbrOld);
831 }
832 DeleteObject(hbr);
833 }
834 }
835
836 // gray out glyph
837 hbr = CreateSolidBrush(m_rgbShadow);
838 if (hbr) {
839 hbrOld = (HBRUSH) SelectObject((HDC) hdc, hbr);
840 if (hbrOld) {
841 // draw the shadow color where we have 0's in the mask
842 BitBlt((HDC) hdc, x, y, dxFace, dyFace, (HDC) m_hdcMono, 0, 0, 0x00B8074A);
843 SelectObject((HDC) hdc, hbrOld);
844 }
845 DeleteObject(hbr);
846 }
847
848 if (state & wxTBSTATE_CHECKED) {
849 BitBlt((HDC) m_hdcMono, 1, 1, dxFace - 1, dyFace - 1, (HDC) m_hdcMono, 0, 0, SRCAND);
850 }
851 }
852
853 if (state & (wxTBSTATE_CHECKED | wxTBSTATE_INDETERMINATE)) {
854
855 hbrOld = (HBRUSH) SelectObject((HDC) hdc, (HBRUSH) m_hbrDither);
856 if (hbrOld) {
857
858 if (!bMaskCreated)
859 CreateMask((WXHDC) hdcGlyphs, xCenterOffset, yOffset, dxFace, dyFace);
860// CreateMask(hBitmap, xCenterOffset, yOffset, dxFace, dyFace);
861
862 SetTextColor((HDC) hdc, 0L); // 0 -> 0
863 SetBkColor((HDC) hdc, 0x00FFFFFF); // 1 -> 1
864
865 // only draw the dither brush where the mask is 1's
866 BitBlt((HDC) hdc, x, y, dxFace, dyFace, (HDC) m_hdcMono, 0, 0, 0x00E20746);
867
868 SelectObject((HDC) hdc, hbrOld);
869 }
870 }
871 SelectObject(hdcGlyphs, bitmapOld);
872 DeleteDC(hdcGlyphs);
873}
874
875// ----------------------------------------------------------------------------
876// drawing helpers
877// ----------------------------------------------------------------------------
878
879void wxToolBar::GetSysColors()
880{
881 static COLORREF rgbSaveFace = 0xffffffffL,
882 rgbSaveShadow = 0xffffffffL,
883 rgbSaveHilight = 0xffffffffL,
884 rgbSaveFrame = 0xffffffffL;
885
886 // For now, override these because the colour replacement isn't working,
887 // and we get inconsistent colours. Assume all buttons are grey for the moment.
888
889// m_rgbFace = GetSysColor(COLOR_BTNFACE);
890 m_rgbFace = RGB(192,192,192);
891// m_rgbShadow = GetSysColor(COLOR_BTNSHADOW);
892 m_rgbShadow = RGB(128,128,128);
893// m_rgbHilight = GetSysColor(COLOR_BTNHIGHLIGHT);
894 m_rgbHilight = RGB(255, 255, 255);
895
896 m_rgbFrame = GetSysColor(COLOR_WINDOWFRAME);
897
898 if (rgbSaveFace!=m_rgbFace || rgbSaveShadow!=m_rgbShadow
899 || rgbSaveHilight!=m_rgbHilight || rgbSaveFrame!=m_rgbFrame)
900 {
901 rgbSaveFace = m_rgbFace;
902 rgbSaveShadow = m_rgbShadow;
903 rgbSaveHilight = m_rgbHilight;
904 rgbSaveFrame = m_rgbFrame;
905
906 // Update the brush for pushed-in buttons
907 CreateDitherBrush();
908 }
909}
910
911WXHBITMAP wxToolBar::CreateDitherBitmap()
912{
913 BITMAPINFO* pbmi;
914 HBITMAP hbm;
915 HDC hdc;
916 int i;
917 long patGray[8];
918 DWORD rgb;
919
920 pbmi = (BITMAPINFO *)malloc(sizeof(BITMAPINFOHEADER) + 16*sizeof(RGBQUAD));
921 memset(pbmi, 0, (sizeof(BITMAPINFOHEADER) + 16*sizeof(RGBQUAD)));
922
923 pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
924 pbmi->bmiHeader.biWidth = 8;
925 pbmi->bmiHeader.biHeight = 8;
926 pbmi->bmiHeader.biPlanes = 1;
927 pbmi->bmiHeader.biBitCount = 1;
928 pbmi->bmiHeader.biCompression = BI_RGB;
929
930// rgb = GetSysColor(COLOR_BTNFACE);
931 rgb = RGB(192,192,192);
932
933 pbmi->bmiColors[0].rgbBlue = GetBValue(rgb);
934 pbmi->bmiColors[0].rgbGreen = GetGValue(rgb);
935 pbmi->bmiColors[0].rgbRed = GetRValue(rgb);
936 pbmi->bmiColors[0].rgbReserved = 0;
937
938// rgb = GetSysColor(COLOR_BTNHIGHLIGHT);
939 rgb = RGB(255, 255, 255);
940
941 pbmi->bmiColors[1].rgbBlue = GetBValue(rgb);
942 pbmi->bmiColors[1].rgbGreen = GetGValue(rgb);
943 pbmi->bmiColors[1].rgbRed = GetRValue(rgb);
944 pbmi->bmiColors[1].rgbReserved = 0;
945
946 /* initialize the brushes */
947
948 for (i = 0; i < 8; i++)
949 if (i & 1)
950 patGray[i] = 0xAAAA5555L; // 0x11114444L; // lighter gray
951 else
952 patGray[i] = 0x5555AAAAL; // 0x11114444L; // lighter gray
953
954 hdc = ::GetDC(NULL);
955
956 hbm = CreateDIBitmap(hdc, &pbmi->bmiHeader, CBM_INIT, patGray, pbmi, DIB_RGB_COLORS);
957
958 ReleaseDC(NULL, hdc);
959 free(pbmi);
960
961 return (WXHBITMAP)hbm;
962}
963
964bool wxToolBar::CreateDitherBrush()
965{
966 HBITMAP hbmGray;
967 HBRUSH hbrSave;
968 if (m_hbrDither)
969 return TRUE;
970 hbmGray = (HBITMAP) CreateDitherBitmap();
971
972 if (hbmGray)
973 {
974 hbrSave = (HBRUSH) m_hbrDither;
975 m_hbrDither = (WXHBRUSH) CreatePatternBrush(hbmGray);
976 DeleteObject(hbmGray);
977 if (m_hbrDither)
978 {
979 if (hbrSave)
980 {
981 DeleteObject(hbrSave);
982 }
983 return TRUE;
984 }
985 else
986 {
987 m_hbrDither = (WXHBRUSH) hbrSave;
988 }
989 }
990
991 return FALSE;
992}
993
994bool wxToolBar::FreeDitherBrush(void)
995{
996 if (m_hbrDither)
997 DeleteObject((HBRUSH) m_hbrDither);
998 m_hbrDither = 0;
999 return TRUE;
1000}
1001
1002typedef struct tagCOLORMAP2
1003{
1004 COLORREF bgrfrom;
1005 COLORREF bgrto;
1006 COLORREF sysColor;
1007} COLORMAP2;
1008
1009// these are the default colors used to map the dib colors
1010// to the current system colors
1011
1012#define BGR_BUTTONTEXT (RGB(000,000,000)) // black
1013#define BGR_BUTTONSHADOW (RGB(128,128,128)) // dark grey
1014#define BGR_BUTTONFACE (RGB(192,192,192)) // bright grey
1015#define BGR_BUTTONHILIGHT (RGB(255,255,255)) // white
1016#define BGR_BACKGROUNDSEL (RGB(255,000,000)) // blue
1017#define BGR_BACKGROUND (RGB(255,000,255)) // magenta
1018#define FlipColor(rgb) (RGB(GetBValue(rgb), GetGValue(rgb), GetRValue(rgb)))
1019
1020WXHBITMAP wxToolBar::CreateMappedBitmap(WXHINSTANCE WXUNUSED(hInstance), void *info)
1021{
1022 LPBITMAPINFOHEADER lpBitmapInfo = (LPBITMAPINFOHEADER)info;
1023 HDC hdc, hdcMem = NULL;
1024
1025 DWORD FAR *p;
1026 LPSTR lpBits;
1027 HBITMAP hbm = NULL, hbmOld;
1028 int numcolors, i;
1029 int wid, hgt;
1030 static COLORMAP2 ColorMap[] = {
1031 {BGR_BUTTONTEXT, BGR_BUTTONTEXT, COLOR_BTNTEXT}, // black
1032 {BGR_BUTTONSHADOW, BGR_BUTTONSHADOW, COLOR_BTNSHADOW}, // dark grey
1033 {BGR_BUTTONFACE, BGR_BUTTONFACE, COLOR_BTNFACE}, // bright grey
1034 {BGR_BUTTONHILIGHT, BGR_BUTTONHILIGHT, COLOR_BTNHIGHLIGHT},// white
1035 {BGR_BACKGROUNDSEL, BGR_BACKGROUNDSEL, COLOR_HIGHLIGHT}, // blue
1036 {BGR_BACKGROUND, BGR_BACKGROUND, COLOR_WINDOW} // magenta
1037 };
1038
1039 #define NUM_MAPS (sizeof(ColorMap)/sizeof(COLORMAP2))
1040
1041 if (!lpBitmapInfo)
1042 return 0;
1043
1044 //
1045 // So what are the new colors anyway ?
1046 //
1047 for (i=0; i < (int) NUM_MAPS; i++) {
1048 ColorMap[i].bgrto = (long unsigned int) FlipColor(GetSysColor((int)ColorMap[i].sysColor));
1049 }
1050
1051 p = (DWORD FAR *)(((LPSTR)lpBitmapInfo) + lpBitmapInfo->biSize);
1052
1053 /* Replace button-face and button-shadow colors with the current values
1054 */
1055 numcolors = 16;
1056
1057 while (numcolors-- > 0) {
1058 for (i = 0; i < (int) NUM_MAPS; i++) {
1059 if (*p == ColorMap[i].bgrfrom) {
1060 *p = ColorMap[i].bgrto;
1061 break;
1062 }
1063 }
1064 p++;
1065 }
1066
1067 /* First skip over the header structure */
1068 lpBits = (LPSTR)(lpBitmapInfo + 1);
1069
1070 /* Skip the color table entries, if any */
1071 lpBits += (1 << (lpBitmapInfo->biBitCount)) * sizeof(RGBQUAD);
1072
1073 /* Create a color bitmap compatible with the display device */
1074 i = wid = (int)lpBitmapInfo->biWidth;
1075 hgt = (int)lpBitmapInfo->biHeight;
1076 hdc = ::GetDC(NULL);
1077
1078 hdcMem = CreateCompatibleDC(hdc);
1079 if (hdcMem) {
1080// hbm = CreateDiscardableBitmap(hdc, i, hgt);
1081 hbm = CreateCompatibleBitmap(hdc, i, hgt);
1082 if (hbm) {
1083 hbmOld = (HBITMAP) SelectObject(hdcMem, hbm);
1084
1085 // set the main image
1086 StretchDIBits(hdcMem, 0, 0, wid, hgt, 0, 0, wid, hgt, lpBits,
1087 (LPBITMAPINFO)lpBitmapInfo, DIB_RGB_COLORS, SRCCOPY);
1088
1089 SelectObject(hdcMem, hbmOld);
1090 }
1091
1092 DeleteObject(hdcMem);
1093 }
1094
1095 ReleaseDC(NULL, hdc);
1096
1097 return (WXHBITMAP) hbm;
1098}
1099
1100WXHBITMAP wxToolBar::CreateMappedBitmap(WXHINSTANCE hInstance, WXHBITMAP hBitmap)
1101{
1102 HANDLE hDIB = wxDIB::ConvertFromBitmap((HBITMAP) hBitmap);
1103 if ( !hDIB )
1104 return 0;
1105
1106 WXHBITMAP newBitmap = CreateMappedBitmap(hInstance, GlobalPtr(hDIB));
1107
1108 GlobalFree(hDIB);
1109
1110 return newBitmap;
1111}
1112
1113#endif // wxUSE_TOOLBAR
1114
wxWidgets (Impactor)