]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/os2/toolbar.cpp
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
SetBackground with a bitmap is only implemented in wxUniversal
[wxWidgets.git] / src / os2 / toolbar.cpp
... / ...
CommitLineData
1/////////////////////////////////////////////////////////////////////////////
2// Name: toolbar.cpp
3// Purpose: wxToolBar
4// Author: David Webster
5// Modified by:
6// Created: 06/30/02
7// RCS-ID: $Id$
8// Copyright: (c) David Webster
9// Licence: wxWindows licence
10/////////////////////////////////////////////////////////////////////////////
11
12// For compilers that support precompilation, includes "wx.h".
13#include "wx/wxprec.h"
14
15#if wxUSE_TOOLBAR && wxUSE_TOOLBAR_NATIVE
16
17#ifndef WX_PRECOMP
18 #include "wx/settings.h"
19 #include "wx/window.h"
20 #include "wx/frame.h"
21 #include "wx/app.h"
22 #include "wx/dcclient.h"
23 #include "wx/dcmemory.h"
24#endif
25
26#include "wx/tooltip.h"
27#include "wx/toolbar.h"
28
29bool wxToolBar::m_bInitialized = FALSE;
30
31// ---------------------------------------------------------------------------
32// Helper for taking a regular bitmap and giving it a disabled look
33// ---------------------------------------------------------------------------
34wxBitmap wxDisableBitmap(
35 const wxBitmap& rBmp
36, long lColor
37)
38{
39 wxMask* pMask = rBmp.GetMask();
40
41 if (!pMask)
42 return(wxNullBitmap);
43
44 DEVOPENSTRUC vDop = {0L, "DISPLAY", NULL, 0L, 0L, 0L, 0L, 0L, 0L};
45 SIZEL vSize = {0, 0};
46 HDC hDC = ::DevOpenDC(vHabmain, OD_MEMORY, "*", 5L, (PDEVOPENDATA)&vDop, NULLHANDLE);
47 HPS hPS = ::GpiCreatePS(vHabmain, hDC, &vSize, PU_PELS | GPIA_ASSOC);
48 BITMAPINFOHEADER2 vHeader;
49 BITMAPINFO2 vInfo;
50 ERRORID vError;
51 wxString sError;
52 HBITMAP hBitmap = (HBITMAP)rBmp.GetHBITMAP();
53 HBITMAP hOldBitmap = NULLHANDLE;
54 HBITMAP hOldMask = NULLHANDLE;
55 HBITMAP hMask = (HBITMAP)rBmp.GetMask()->GetMaskBitmap();
56 unsigned char* pucBits; // buffer that will contain the bitmap data
57 unsigned char* pucData; // pointer to use to traverse bitmap data
58 unsigned char* pucBitsMask; // buffer that will contain the mask data
59 unsigned char* pucDataMask; // pointer to use to traverse mask data
60 LONG lScans = 0L;
61 LONG lScansSet = 0L;
62 bool bpp16 = (wxDisplayDepth() == 16);
63
64 memset(&vHeader, '\0', 16);
65 vHeader.cbFix = 16;
66
67 memset(&vInfo, '\0', 16);
68 vInfo.cbFix = 16;
69 vInfo.cx = (ULONG)rBmp.GetWidth();
70 vInfo.cy = (ULONG)rBmp.GetHeight();
71 vInfo.cPlanes = 1;
72 vInfo.cBitCount = 24; // Set to desired count going in
73
74 //
75 // Create the buffers for data....all wxBitmaps are 24 bit internally
76 //
77 int nBytesPerLine = rBmp.GetWidth() * 3;
78 int nSizeDWORD = sizeof(DWORD);
79 int nLineBoundary = nBytesPerLine % nSizeDWORD;
80 int nPadding = 0;
81 int i;
82 int j;
83
84 //
85 // Bitmap must be ina double-word alligned address so we may
86 // have some padding to worry about
87 //
88 if (nLineBoundary > 0)
89 {
90 nPadding = nSizeDWORD - nLineBoundary;
91 nBytesPerLine += nPadding;
92 }
93 pucBits = (unsigned char *)malloc(nBytesPerLine * rBmp.GetHeight());
94 memset(pucBits, '\0', (nBytesPerLine * rBmp.GetHeight()));
95 pucBitsMask = (unsigned char *)malloc(nBytesPerLine * rBmp.GetHeight());
96 memset(pucBitsMask, '\0', (nBytesPerLine * rBmp.GetHeight()));
97
98 //
99 // Extract the bitmap and mask data
100 //
101 if ((hOldBitmap = ::GpiSetBitmap(hPS, hBitmap)) == HBM_ERROR)
102 {
103 vError = ::WinGetLastError(vHabmain);
104 sError = wxPMErrorToStr(vError);
105 }
106 ::GpiQueryBitmapInfoHeader(hBitmap, &vHeader);
107 vInfo.cBitCount = 24;
108 if ((lScans = ::GpiQueryBitmapBits( hPS
109 ,0L
110 ,(LONG)rBmp.GetHeight()
111 ,(PBYTE)pucBits
112 ,&vInfo
113 )) == GPI_ALTERROR)
114 {
115 vError = ::WinGetLastError(vHabmain);
116 sError = wxPMErrorToStr(vError);
117 }
118 if ((hOldMask = ::GpiSetBitmap(hPS, hMask)) == HBM_ERROR)
119 {
120 vError = ::WinGetLastError(vHabmain);
121 sError = wxPMErrorToStr(vError);
122 }
123 ::GpiQueryBitmapInfoHeader(hMask, &vHeader);
124 vInfo.cBitCount = 24;
125 if ((lScans = ::GpiQueryBitmapBits( hPS
126 ,0L
127 ,(LONG)rBmp.GetHeight()
128 ,(PBYTE)pucBitsMask
129 ,&vInfo
130 )) == GPI_ALTERROR)
131 {
132 vError = ::WinGetLastError(vHabmain);
133 sError = wxPMErrorToStr(vError);
134 }
135 if (( hMask = ::GpiSetBitmap(hPS, hOldMask)) == HBM_ERROR)
136 {
137 vError = ::WinGetLastError(vHabmain);
138 sError = wxPMErrorToStr(vError);
139 }
140 pucData = pucBits;
141 pucDataMask = pucBitsMask;
142
143 //
144 // Get the mask value
145 //
146 for (i = 0; i < rBmp.GetHeight(); i++)
147 {
148 for (j = 0; j < rBmp.GetWidth(); j++)
149 {
150 // Byte 1
151 if (bpp16 && *pucDataMask == 0xF8) // 16 bit display gobblygook
152 {
153 *pucData = 0x7F;
154 pucData++;
155 }
156 else if (*pucDataMask == 0xFF) // set to grey
157 {
158 *pucData = 0x7F;
159 pucData++;
160 }
161 else
162 {
163 *pucData = ((unsigned char)(lColor >> 16));
164 pucData++;
165 }
166
167 // Byte 2
168 if (bpp16 && *(pucDataMask + 1) == 0xFC) // 16 bit display gobblygook
169 {
170 *pucData = 0x7F;
171 pucData++;
172 }
173 else if (*(pucDataMask + 1) == 0xFF) // set to grey
174 {
175 *pucData = 0x7F;
176 pucData++;
177 }
178 else
179 {
180 *pucData = ((unsigned char)(lColor >> 8));
181 pucData++;
182 }
183
184 // Byte 3
185 if (bpp16 && *(pucDataMask + 2) == 0xF8) // 16 bit display gobblygook
186 {
187 *pucData = 0x7F;
188 pucData++;
189 }
190 else if (*(pucDataMask + 2) == 0xFF) // set to grey
191 {
192 *pucData = 0x7F;
193 pucData++;
194 }
195 else
196 {
197 *pucData = ((unsigned char)lColor);
198 pucData++;
199 }
200 pucDataMask += 3;
201 }
202 for (j = 0; j < nPadding; j++)
203 {
204 pucData++;
205 pucDataMask++;
206 }
207 }
208
209 //
210 // Create a new bitmap and set the modified bits
211 //
212 wxBitmap vNewBmp( rBmp.GetWidth()
213 ,rBmp.GetHeight()
214 ,24
215 );
216 HBITMAP hNewBmp = (HBITMAP)vNewBmp.GetHBITMAP();
217
218 if ((hOldBitmap = ::GpiSetBitmap(hPS, hNewBmp)) == HBM_ERROR)
219 {
220 vError = ::WinGetLastError(vHabmain);
221 sError = wxPMErrorToStr(vError);
222 }
223 if ((lScansSet = ::GpiSetBitmapBits( hPS
224 ,0L
225 ,(LONG)rBmp.GetHeight()
226 ,(PBYTE)pucBits
227 ,&vInfo
228 )) == GPI_ALTERROR)
229
230 {
231 vError = ::WinGetLastError(vHabmain);
232 sError = wxPMErrorToStr(vError);
233 }
234 wxMask* pNewMask;
235
236 pNewMask = new wxMask(pMask->GetMaskBitmap());
237 vNewBmp.SetMask(pNewMask);
238 free(pucBits);
239 ::GpiSetBitmap(hPS, NULLHANDLE);
240 ::GpiDestroyPS(hPS);
241 ::DevCloseDC(hDC);
242 if (vNewBmp.Ok())
243 return(vNewBmp);
244 return(wxNullBitmap);
245} // end of wxDisableBitmap
246
247// ----------------------------------------------------------------------------
248// private classes
249// ----------------------------------------------------------------------------
250
251class wxToolBarTool : public wxToolBarToolBase
252{
253public:
254 inline wxToolBarTool( wxToolBar* pTbar
255 ,int vId
256 ,const wxString& rsLabel
257 ,const wxBitmap& rBitmap1
258 ,const wxBitmap& rBitmap2
259 ,wxItemKind vKind
260 ,wxObject* pClientData
261 ,const wxString& rsShortHelpString
262 ,const wxString& rsLongHelpString
263 ) : wxToolBarToolBase( pTbar
264 ,vId
265 ,rsLabel
266 ,rBitmap1
267 ,rBitmap2
268 ,vKind
269 ,pClientData
270 ,rsShortHelpString
271 ,rsLongHelpString
272 )
273 {
274 }
275
276 inline wxToolBarTool( wxToolBar* pTbar
277 ,wxControl* pControl
278 ) : wxToolBarToolBase( pTbar
279 ,pControl
280 )
281 {
282 }
283
284 void SetSize(const wxSize& rSize)
285 {
286 m_vWidth = rSize.x;
287 m_vHeight = rSize.y;
288 }
289
290 wxCoord GetWidth(void) const { return m_vWidth; }
291 wxCoord GetHeight(void) const { return m_vHeight; }
292
293 wxCoord m_vX;
294 wxCoord m_vY;
295 wxCoord m_vWidth;
296 wxCoord m_vHeight;
297}; // end of CLASS wxToolBarTool
298
299// ----------------------------------------------------------------------------
300// wxWin macros
301// ----------------------------------------------------------------------------
302
303IMPLEMENT_DYNAMIC_CLASS(wxToolBar, wxToolBarBase)
304
305BEGIN_EVENT_TABLE(wxToolBar, wxToolBarBase)
306 EVT_SIZE(wxToolBar::OnSize)
307 EVT_PAINT(wxToolBar::OnPaint)
308 EVT_KILL_FOCUS(wxToolBar::OnKillFocus)
309 EVT_MOUSE_EVENTS(wxToolBar::OnMouseEvent)
310 EVT_TIMER(-1, wxToolBar::OnTimer)
311END_EVENT_TABLE()
312
313// ============================================================================
314// implementation
315// ============================================================================
316
317// ----------------------------------------------------------------------------
318// tool bar tools creation
319// ----------------------------------------------------------------------------
320
321wxToolBarToolBase* wxToolBar::CreateTool(
322 int nId
323, const wxString& rsLabel
324, const wxBitmap& rBmpNormal
325, const wxBitmap& rBmpDisabled
326, wxItemKind eKind
327, wxObject* pClientData
328, const wxString& rsShortHelp
329, const wxString& rsLongHelp
330)
331{
332 return new wxToolBarTool( this
333 ,nId
334 ,rsLabel
335 ,rBmpNormal
336 ,rBmpDisabled
337 ,eKind
338 ,pClientData
339 ,rsShortHelp
340 ,rsLongHelp
341 );
342} // end of wxToolBarSimple::CreateTool
343
344wxToolBarToolBase *wxToolBar::CreateTool(
345 wxControl* pControl
346)
347{
348 return new wxToolBarTool( this
349 ,pControl
350 );
351} // end of wxToolBarSimple::CreateTool
352
353// ----------------------------------------------------------------------------
354// wxToolBarSimple creation
355// ----------------------------------------------------------------------------
356
357void wxToolBar::Init()
358{
359 m_nCurrentRowsOrColumns = 0;
360
361 m_vLastX = m_vLastY = 0;
362 m_vMaxWidth = m_vMaxHeight = 0;
363 m_nPressedTool = m_nCurrentTool = -1;
364 m_vXPos = m_vYPos = -1;
365 m_vTextX = m_vTextY = 0;
366
367 m_toolPacking = 1;
368 m_toolSeparation = 5;
369
370 m_defaultWidth = 16;
371 m_defaultHeight = 15;
372
373 m_pToolTip = NULL;
374} // end of wxToolBar::Init
375
376wxToolBarToolBase* wxToolBar::DoAddTool(
377 int vId
378, const wxString& rsLabel
379, const wxBitmap& rBitmap
380, const wxBitmap& rBmpDisabled
381, wxItemKind eKind
382, const wxString& rsShortHelp
383, const wxString& rsLongHelp
384, wxObject* pClientData
385, wxCoord vXPos
386, wxCoord vYPos
387)
388{
389 //
390 // Rememeber the position for DoInsertTool()
391 //
392 m_vXPos = vXPos;
393 m_vYPos = vYPos;
394
395 return wxToolBarBase::DoAddTool( vId
396 ,rsLabel
397 ,rBitmap
398 ,rBmpDisabled
399 ,eKind
400 ,rsShortHelp
401 ,rsLongHelp
402 ,pClientData
403 ,vXPos
404 ,vYPos
405 );
406} // end of wxToolBar::DoAddTool
407
408bool wxToolBar::DeleteTool(
409 int nId
410)
411{
412 bool bOk = wxToolBarBase::DeleteTool(nId);
413
414 if (bOk)
415 {
416 Realize();
417 }
418 return bOk;
419} // end of wxToolBar::DeleteTool
420
421bool wxToolBar::DeleteToolByPos(
422 size_t nPos
423)
424{
425 bool bOk = wxToolBarBase::DeleteToolByPos(nPos);
426
427 if (bOk)
428 {
429 Realize();
430 }
431 return bOk;
432} // end of wxToolBar::DeleteTool
433
434wxToolBarToolBase* wxToolBar::InsertControl(
435 size_t nPos
436, wxControl* pControl
437)
438{
439 wxToolBarToolBase* pTool = wxToolBarBase::InsertControl( nPos
440 ,pControl
441 );
442 if (m_bInitialized)
443 {
444 Realize();
445 Refresh();
446 }
447 return pTool;
448} // end of wxToolBar::InsertControl
449
450wxToolBarToolBase* wxToolBar::InsertSeparator(
451 size_t nPos
452)
453{
454 wxToolBarToolBase* pTool = wxToolBarBase::InsertSeparator(nPos);
455
456 if (m_bInitialized)
457 {
458 Realize();
459 Refresh();
460 }
461 return pTool;
462} // end of wxToolBar::InsertSeparator
463
464wxToolBarToolBase* wxToolBar::InsertTool(
465 size_t nPos
466, int nId
467, const wxString& rsLabel
468, const wxBitmap& rBitmap
469, const wxBitmap& rBmpDisabled
470, wxItemKind eKind
471, const wxString& rsShortHelp
472, const wxString& rsLongHelp
473, wxObject* pClientData
474)
475{
476 wxToolBarToolBase* pTool = wxToolBarBase::InsertTool( nPos
477 ,nId
478 ,rsLabel
479 ,rBitmap
480 ,rBmpDisabled
481 ,eKind
482 ,rsShortHelp
483 ,rsLongHelp
484 ,pClientData
485 );
486 if (m_bInitialized)
487 {
488 Realize();
489 Refresh();
490 }
491 return pTool;
492} // end of wxToolBar::InsertTool
493
494bool wxToolBar::DoInsertTool(
495 size_t WXUNUSED(nPos)
496, wxToolBarToolBase* pToolBase
497)
498{
499 wxToolBarTool* pTool = (wxToolBarTool *)pToolBase;
500
501 pTool->m_vX = m_vXPos;
502 if (pTool->m_vX == -1)
503 pTool->m_vX = m_xMargin;
504
505 pTool->m_vY = m_vYPos;
506 if (pTool->m_vY == -1)
507 pTool->m_vX = m_yMargin;
508
509 pTool->SetSize(GetToolSize());
510
511 if (pTool->IsButton())
512 {
513 //
514 // Calculate reasonable max size in case Layout() not called
515 //
516 if ((pTool->m_vX + pTool->GetNormalBitmap().GetWidth() + m_xMargin) > m_vMaxWidth)
517 m_vMaxWidth = (wxCoord)((pTool->m_vX + pTool->GetWidth() + m_xMargin));
518
519 if ((pTool->m_vY + pTool->GetNormalBitmap().GetHeight() + m_yMargin) > m_vMaxHeight)
520 m_vMaxHeight = (wxCoord)((pTool->m_vY + pTool->GetHeight() + m_yMargin));
521 }
522 return TRUE;
523} // end of wxToolBar::DoInsertTool
524
525bool wxToolBar::DoDeleteTool(
526 size_t WXUNUSED(nPos)
527, wxToolBarToolBase* pTool
528)
529{
530 pTool->Detach();
531 Refresh();
532 return TRUE;
533} // end of wxToolBar::DoDeleteTool
534
535bool wxToolBar::Create(
536 wxWindow* pParent
537, wxWindowID vId
538, const wxPoint& rPos
539, const wxSize& rSize
540, long lStyle
541, const wxString& rsName
542)
543{
544 if ( !wxWindow::Create( pParent
545 ,vId
546 ,rPos
547 ,rSize
548 ,lStyle
549 ,rsName
550 ))
551 return FALSE;
552
553 // Set it to grey (or other 3D face colour)
554 SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_MENUBAR));
555 SetFont(*wxSMALL_FONT);
556
557 if (GetWindowStyleFlag() & wxTB_VERTICAL)
558 {
559 m_vLastX = 7;
560 m_vLastY = 3;
561
562 m_maxRows = 32000; // a lot
563 m_maxCols = 1;
564 }
565 else
566 {
567 m_vLastX = 3;
568 m_vLastY = 7;
569
570 m_maxRows = 1;
571 m_maxCols = 32000; // a lot
572 }
573 SetCursor(*wxSTANDARD_CURSOR);
574
575 //
576 // The toolbar's tools, if they have labels and the winTB_TEXT
577 // style is set, then we need to take into account the size of
578 // the text when drawing tool bitmaps and the text
579 //
580 if (HasFlag(wxTB_TEXT))
581 {
582 wxClientDC vDC(this);
583
584 vDC.SetFont(GetFont());
585 vDC.GetTextExtent( "XXXX"
586 ,&m_vTextX
587 ,&m_vTextY
588 );
589 }
590
591 //
592 // Position it
593 //
594 int nX = rPos.x;
595 int nY = rPos.y;
596 int nWidth = rSize.x;
597 int nHeight = rSize.y;
598 wxFrame* pFrame = wxDynamicCast(GetParent(), wxFrame);
599
600 if (lStyle & wxTB_HORIZONTAL)
601 {
602 if (nWidth <= 0)
603 {
604 nWidth = pParent->GetClientSize().x;
605 }
606 if (nHeight <= 0)
607 {
608 if (lStyle & wxTB_TEXT)
609 nHeight = m_defaultHeight + m_vTextY;
610 else
611 nHeight = m_defaultHeight;
612 }
613 }
614 else
615 {
616 if (nHeight <= 0)
617 {
618 nHeight = pParent->GetClientSize().y;
619 }
620 if (nWidth <= 0)
621 {
622 if (lStyle & wxTB_TEXT)
623 nWidth = m_vTextX + (int)(m_vTextX/2); // a little margin
624 else
625 nWidth = m_defaultWidth + (int)(m_defaultWidth/2); // a little margin
626 }
627 }
628 if (nX < 0)
629 nX = 0;
630 if (nY < 0)
631 nY = 0;
632
633 SetSize( nX
634 ,nY
635 ,nWidth
636 ,nHeight
637 );
638 return TRUE;
639} // end of wxToolBar::Create
640
641wxToolBar::~wxToolBar()
642{
643 if (m_pToolTip)
644 {
645 delete m_pToolTip;
646 m_pToolTip = NULL;
647 }
648} // end of wxToolBar::~wxToolBar
649
650bool wxToolBar::Realize()
651{
652 int nMaxToolWidth = 0;
653 int nMaxToolHeight = 0;
654 int nX;
655 int nY;
656
657 m_nCurrentRowsOrColumns = 0;
658 m_vLastX = m_xMargin;
659 m_vLastY = m_yMargin;
660 m_vMaxWidth = 0;
661 m_vMaxHeight = 0;
662
663
664 //
665 // Find the maximum tool width and height
666 //
667 wxToolBarToolsList::Node* pNode = m_tools.GetFirst();
668
669 while (pNode )
670 {
671 wxToolBarTool* pTool = (wxToolBarTool *)pNode->GetData();
672
673 if (HasFlag(wxTB_TEXT) && !pTool->GetLabel().IsEmpty())
674 {
675 //
676 // Set the height according to the font and the border size
677 //
678 if (pTool->GetWidth() > m_vTextX)
679 nMaxToolWidth = pTool->GetWidth() + 4;
680 else
681 nMaxToolWidth = m_vTextX;
682 if (pTool->GetHeight() + m_vTextY > nMaxToolHeight)
683 nMaxToolHeight = pTool->GetHeight() + m_vTextY;
684 }
685 else
686 {
687 if (pTool->GetWidth() > nMaxToolWidth )
688 nMaxToolWidth = pTool->GetWidth() + 4;
689 if (pTool->GetHeight() > nMaxToolHeight)
690 nMaxToolHeight = pTool->GetHeight();
691 }
692 pNode = pNode->GetNext();
693 }
694
695 wxCoord vTbWidth = 0L;
696 wxCoord vTbHeight = 0L;
697
698 GetSize( &vTbWidth
699 ,&vTbHeight
700 );
701 if (vTbHeight < nMaxToolHeight)
702 {
703 SetSize( -1L
704 ,-1L
705 ,vTbWidth
706 ,nMaxToolHeight + 4
707 );
708 if (GetParent()->IsKindOf(CLASSINFO(wxFrame)))
709 {
710 wxFrame* pFrame = wxDynamicCast(GetParent(), wxFrame);
711
712 if (pFrame)
713 pFrame->PositionToolBar();
714 }
715 }
716
717 int nSeparatorSize = m_toolSeparation;
718
719 pNode = m_tools.GetFirst();
720 while (pNode)
721 {
722 wxToolBarTool* pTool = (wxToolBarTool *)pNode->GetData();
723
724 if (pTool->IsSeparator())
725 {
726 if (GetWindowStyleFlag() & wxTB_HORIZONTAL)
727 {
728 pTool->m_vX = m_vLastX + nSeparatorSize;
729 pTool->m_vHeight = m_defaultHeight + m_vTextY;
730 if (m_nCurrentRowsOrColumns >= m_maxCols)
731 m_vLastY += nSeparatorSize;
732 else
733 m_vLastX += nSeparatorSize * 4;
734 }
735 else
736 {
737 pTool->m_vY = m_vLastY + nSeparatorSize;
738 pTool->m_vHeight = m_defaultHeight + m_vTextY;
739 if (m_nCurrentRowsOrColumns >= m_maxRows)
740 m_vLastX += nSeparatorSize;
741 else
742 m_vLastY += nSeparatorSize * 4;
743 }
744 }
745 else if (pTool->IsButton())
746 {
747 if (GetWindowStyleFlag() & wxTB_HORIZONTAL)
748 {
749 if (m_nCurrentRowsOrColumns >= m_maxCols)
750 {
751 m_nCurrentRowsOrColumns = 0;
752 m_vLastX = m_xMargin;
753 m_vLastY += nMaxToolHeight + m_toolPacking;
754 }
755 pTool->m_vX = m_vLastX + (nMaxToolWidth - ((int)(nMaxToolWidth/2) + (int)(pTool->GetWidth()/2)));
756 if (HasFlag(wxTB_TEXT))
757 pTool->m_vY = m_vLastY + nSeparatorSize - 2; // just bit of adjustment
758 else
759 pTool->m_vY = m_vLastY + (nMaxToolHeight - (int)(pTool->GetHeight()/2));
760 m_vLastX += nMaxToolWidth + m_toolPacking + m_toolSeparation;
761 }
762 else
763 {
764 if (m_nCurrentRowsOrColumns >= m_maxRows)
765 {
766 m_nCurrentRowsOrColumns = 0;
767 m_vLastX += (nMaxToolWidth + m_toolPacking);
768 m_vLastY = m_yMargin;
769 }
770 pTool->m_vX = m_vLastX + pTool->GetWidth();
771 if (HasFlag(wxTB_TEXT) && !pTool->GetLabel().IsNull())
772 pTool->m_vY = m_vLastY + (nMaxToolHeight - m_vTextY) + m_toolPacking;
773 else
774 pTool->m_vY = m_vLastY + (nMaxToolHeight - (int)(pTool->GetHeight()/2));
775 m_vLastY += nMaxToolHeight + m_toolPacking + m_toolSeparation;
776 }
777 m_nCurrentRowsOrColumns++;
778 }
779 else
780 {
781 // TODO: support the controls
782 }
783
784 if (m_vLastX > m_maxWidth)
785 m_maxWidth = m_vLastX;
786 if (m_vLastY > m_maxHeight)
787 m_maxHeight = m_vLastY;
788
789 pNode = pNode->GetNext();
790 }
791
792 if ( GetWindowStyleFlag() & wxTB_HORIZONTAL )
793 m_maxWidth += nMaxToolWidth;
794 else
795 m_maxHeight += nMaxToolHeight;
796
797 m_maxWidth += m_xMargin;
798 m_maxHeight += m_yMargin;
799 m_bInitialized = TRUE;
800 return TRUE;
801} // end of wxToolBar::Realize
802
803// ----------------------------------------------------------------------------
804// event handlers
805// ----------------------------------------------------------------------------
806
807void wxToolBar::OnPaint (
808 wxPaintEvent& WXUNUSED(rEvent)
809)
810{
811 wxPaintDC vDc(this);
812
813 PrepareDC(vDc);
814
815 static int nCount = 0;
816
817 //
818 // Prevent reentry of OnPaint which would cause wxMemoryDC errors.
819 //
820 if (nCount > 0)
821 return;
822 nCount++;
823
824 ::WinFillRect(vDc.GetHPS(), &vDc.m_vRclPaint, GetBackgroundColour().GetPixel());
825 for ( wxToolBarToolsList::Node* pNode = m_tools.GetFirst();
826 pNode;
827 pNode = pNode->GetNext() )
828 {
829 wxToolBarTool* pTool = (wxToolBarTool*)pNode->GetData();
830
831 if (pTool->IsButton() )
832 DrawTool(vDc, pTool);
833 if (pTool->IsSeparator())
834 {
835 wxPen vDarkGreyPen( wxColour(85, 85, 85)
836 ,1
837 ,wxSOLID
838 );
839 int nX;
840 int nY;
841 int nHeight = 0;
842 int nWidth = 0;
843
844 vDc.SetPen(vDarkGreyPen);
845 if (HasFlag(wxTB_TEXT))
846 {
847 if (HasFlag(wxTB_HORIZONTAL))
848 {
849 nX = pTool->m_vX;
850 nY = pTool->m_vY - (m_vTextY - 6);
851 nHeight = (m_vTextY - 2) + pTool->GetHeight();
852 }
853 else
854 {
855 nX = pTool->m_vX + m_xMargin + 10;
856 nY = pTool->m_vY + m_vTextY + m_toolSeparation;
857 nWidth = pTool->GetWidth() > m_vTextX ? pTool->GetWidth() : m_vTextX;
858 }
859 }
860 else
861 {
862 nX = pTool->m_vX;
863 nY = pTool->m_vY;
864 if (HasFlag(wxTB_HORIZONTAL))
865 nHeight = pTool->GetHeight() - 2;
866 else
867 {
868 nX += m_xMargin + 10;
869 nY += m_yMargin + m_toolSeparation;
870 nWidth = pTool->GetWidth();
871 }
872 }
873 vDc.DrawLine(nX, nY, nX + nWidth, nY + nHeight);
874 }
875 }
876 nCount--;
877} // end of wxToolBar::OnPaint
878
879void wxToolBar::OnSize (
880 wxSizeEvent& WXUNUSED(rEvent)
881)
882{
883#if wxUSE_CONSTRAINTS
884 if (GetAutoLayout())
885 Layout();
886#endif
887} // end of wxToolBar::OnSize
888
889void wxToolBar::OnKillFocus(
890 wxFocusEvent& WXUNUSED(rEvent)
891)
892{
893 OnMouseEnter(m_nPressedTool = m_nCurrentTool = -1);
894} // end of wxToolBar::OnKillFocus
895
896void wxToolBar::OnMouseEvent(
897 wxMouseEvent& rEvent
898)
899{
900 POINTL vPoint;
901 HWND hWnd;
902 wxCoord vX;
903 wxCoord vY;
904 HPOINTER hPtr = ::WinQuerySysPointer(HWND_DESKTOP, SPTR_ARROW, FALSE);
905
906 ::WinSetPointer(HWND_DESKTOP, hPtr);
907 ::WinQueryPointerPos(HWND_DESKTOP, &vPoint);
908 hWnd = ::WinWindowFromPoint(HWND_DESKTOP, &vPoint, TRUE);
909 if (hWnd != (HWND)GetHwnd())
910 {
911 m_vToolTimer.Stop();
912 return;
913 }
914
915 rEvent.GetPosition(&vX, &vY);
916
917 wxToolBarTool* pTool = (wxToolBarTool *)FindToolForPosition( vX
918 ,vY
919 );
920
921 if (rEvent.LeftDown())
922 {
923 CaptureMouse();
924 }
925 if (rEvent.LeftUp())
926 {
927 ReleaseMouse();
928 }
929
930 if (!pTool)
931 {
932 m_vToolTimer.Stop();
933 if (m_nCurrentTool > -1)
934 {
935 if (rEvent.LeftIsDown())
936 SpringUpButton(m_nCurrentTool);
937 pTool = (wxToolBarTool *)FindById(m_nCurrentTool);
938 if (pTool && !pTool->IsToggled())
939 {
940 RaiseTool( pTool
941 ,FALSE
942 );
943 }
944 m_nCurrentTool = -1;
945 OnMouseEnter(-1);
946 }
947 return;
948 }
949 if (!rEvent.IsButton())
950 {
951 if (pTool->GetId() != m_nCurrentTool)
952 {
953 //
954 // If the left button is kept down and moved over buttons,
955 // press those buttons.
956 //
957 if (rEvent.LeftIsDown() && pTool->IsEnabled())
958 {
959 SpringUpButton(m_nCurrentTool);
960 if (pTool->CanBeToggled())
961 {
962 pTool->Toggle();
963 }
964 DrawTool(pTool);
965 }
966 wxToolBarTool* pOldTool = (wxToolBarTool*)FindById(m_nCurrentTool);
967
968 if (pOldTool && !pTool->IsToggled())
969 RaiseTool( pOldTool
970 ,FALSE
971 );
972 m_nCurrentTool = pTool->GetId();
973 OnMouseEnter(m_nCurrentTool);
974 if (!pTool->GetShortHelp().IsEmpty())
975 {
976 if (m_pToolTip)
977 delete m_pToolTip;
978 m_pToolTip = new wxToolTip(pTool->GetShortHelp());
979 m_vXMouse = (wxCoord)vPoint.x;
980 m_vYMouse = (wxCoord)vPoint.y;
981 m_vToolTimer.Start(1000L, TRUE);
982 }
983 if (!pTool->IsToggled())
984 RaiseTool(pTool);
985 }
986 return;
987 }
988
989 // Left button pressed.
990 if (rEvent.LeftDown() && pTool->IsEnabled())
991 {
992 if (pTool->CanBeToggled())
993 {
994 pTool->Toggle();
995 }
996 DrawTool(pTool);
997 }
998 else if (rEvent.RightDown())
999 {
1000 OnRightClick( pTool->GetId()
1001 ,vX
1002 ,vY
1003 );
1004 }
1005
1006 //
1007 // Left Button Released. Only this action confirms selection.
1008 // If the button is enabled and it is not a toggle tool and it is
1009 // in the pressed state, then raise the button and call OnLeftClick.
1010 //
1011 if (rEvent.LeftUp() && pTool->IsEnabled() )
1012 {
1013 //
1014 // Pass the OnLeftClick event to tool
1015 //
1016 if (!OnLeftClick( pTool->GetId()
1017 ,pTool->IsToggled()) &&
1018 pTool->CanBeToggled())
1019 {
1020 //
1021 // If it was a toggle, and OnLeftClick says No Toggle allowed,
1022 // then change it back
1023 //
1024 pTool->Toggle();
1025 }
1026 DrawTool(pTool);
1027 }
1028} // end of wxToolBar::OnMouseEvent
1029
1030// ----------------------------------------------------------------------------
1031// drawing
1032// ----------------------------------------------------------------------------
1033
1034void wxToolBar::DrawTool(
1035 wxToolBarToolBase* pTool
1036)
1037{
1038 wxClientDC vDc(this);
1039
1040 DrawTool( vDc
1041 ,pTool
1042 );
1043} // end of wxToolBar::DrawTool
1044
1045void wxToolBar::DrawTool(
1046 wxDC& rDc
1047, wxToolBarToolBase* pToolBase
1048)
1049{
1050 wxToolBarTool* pTool = (wxToolBarTool *)pToolBase;
1051 wxPen vDarkGreyPen( wxColour( 85,85,85 )
1052 ,1
1053 ,wxSOLID
1054 );
1055 wxPen vWhitePen( wxT("WHITE")
1056 ,1
1057 ,wxSOLID
1058 );
1059 wxPen vBlackPen( wxT("BLACK")
1060 ,1
1061 ,wxSOLID
1062 );
1063 wxBitmap vBitmap = pTool->GetNormalBitmap();
1064 bool bUseMask = FALSE;
1065 wxMask* pMask = NULL;
1066 RECTL vRect;
1067
1068 PrepareDC(rDc);
1069
1070 if (!vBitmap.Ok())
1071 return;
1072 if ((pMask = vBitmap.GetMask()) != NULL)
1073 if (pMask->GetMaskBitmap() != NULLHANDLE)
1074 bUseMask = TRUE;
1075
1076 if (!pTool->IsToggled())
1077 {
1078 LowerTool(pTool, FALSE);
1079 if (!pTool->IsEnabled())
1080 {
1081 wxColour vColor("GREY");
1082
1083 rDc.SetTextForeground(vColor);
1084 if (!pTool->GetDisabledBitmap().Ok())
1085 pTool->SetDisabledBitmap(wxDisableBitmap( vBitmap
1086 ,(long)GetBackgroundColour().GetPixel()
1087 ));
1088 rDc.DrawBitmap( pTool->GetDisabledBitmap()
1089 ,pTool->m_vX
1090 ,pTool->m_vY
1091 ,bUseMask
1092 );
1093 }
1094 else
1095 {
1096 wxColour vColor("BLACK");
1097
1098 rDc.SetTextForeground(vColor);
1099 rDc.DrawBitmap( vBitmap
1100 ,pTool->m_vX
1101 ,pTool->m_vY
1102 ,bUseMask
1103 );
1104 }
1105 if (m_windowStyle & wxTB_3DBUTTONS)
1106 {
1107 RaiseTool(pTool);
1108 }
1109 if (HasFlag(wxTB_TEXT) && !pTool->GetLabel().IsNull())
1110 {
1111 wxCoord vX;
1112 wxCoord vY;
1113 wxCoord vLeft = pTool->m_vX - (int)(pTool->GetWidth()/2);
1114
1115 rDc.SetFont(GetFont());
1116 rDc.GetTextExtent( pTool->GetLabel()
1117 ,&vX
1118 ,&vY
1119 );
1120 if (pTool->GetWidth() > vX) // large tools
1121 {
1122 vLeft = pTool->m_vX + (pTool->GetWidth() - vX);
1123 GetSize(&vX, &vY);
1124 rDc.DrawText( pTool->GetLabel()
1125 ,vLeft
1126 ,vY - (m_vTextY - 2)
1127 );
1128 }
1129 else // normal tools
1130 {
1131 vLeft += (wxCoord)((m_vTextX - vX)/2);
1132 rDc.DrawText( pTool->GetLabel()
1133 ,vLeft
1134 ,pTool->m_vY + m_vTextY + 4 // a bit of margin
1135 );
1136 }
1137 }
1138 }
1139 else
1140 {
1141 wxColour vColor("GREY");
1142
1143 LowerTool(pTool);
1144 rDc.SetTextForeground(vColor);
1145 if (!pTool->GetDisabledBitmap().Ok())
1146 pTool->SetDisabledBitmap(wxDisableBitmap( vBitmap
1147 ,(long)GetBackgroundColour().GetPixel()
1148 ));
1149 rDc.DrawBitmap( pTool->GetDisabledBitmap()
1150 ,pTool->m_vX
1151 ,pTool->m_vY
1152 ,bUseMask
1153 );
1154 if (HasFlag(wxTB_TEXT) && !pTool->GetLabel().IsNull())
1155 {
1156 wxCoord vX;
1157 wxCoord vY;
1158 wxCoord vLeft = pTool->m_vX - (int)(pTool->GetWidth()/2);
1159
1160 rDc.SetFont(GetFont());
1161 rDc.GetTextExtent( pTool->GetLabel()
1162 ,&vX
1163 ,&vY
1164 );
1165 vLeft += (wxCoord)((m_vTextX - vX)/2);
1166 rDc.DrawText( pTool->GetLabel()
1167 ,vLeft
1168 ,pTool->m_vY + m_vTextY + 4 // a bit of margin
1169 );
1170 }
1171 }
1172} // end of wxToolBar::DrawTool
1173
1174// ----------------------------------------------------------------------------
1175// toolbar geometry
1176// ----------------------------------------------------------------------------
1177
1178void wxToolBar::SetRows(
1179 int nRows
1180)
1181{
1182 wxCHECK_RET( nRows != 0, _T("max number of rows must be > 0") );
1183
1184 m_maxCols = (GetToolsCount() + nRows - 1) / nRows;
1185 Refresh();
1186} // end of wxToolBar::SetRows
1187
1188wxToolBarToolBase* wxToolBar::FindToolForPosition(
1189 wxCoord vX
1190, wxCoord vY
1191) const
1192{
1193 wxCoord vTextX = 0;
1194 wxCoord vTextY = 0;
1195 wxCoord vTBarHeight = 0;
1196
1197 GetSize( NULL
1198 ,&vTBarHeight
1199 );
1200 vY = vTBarHeight - vY;
1201 wxToolBarToolsList::Node* pNode = m_tools.GetFirst();
1202 while (pNode)
1203 {
1204 wxToolBarTool* pTool = (wxToolBarTool *)pNode->GetData();
1205
1206 if (HasFlag(wxTB_TEXT) && !pTool->GetLabel().IsNull())
1207 {
1208 if ((vX >= (pTool->m_vX - ((wxCoord)(pTool->GetWidth()/2) - 2))) &&
1209 (vY >= (pTool->m_vY - 2)) &&
1210 (vX <= (pTool->m_vX + pTool->GetWidth())) &&
1211 (vY <= (pTool->m_vY + pTool->GetHeight() + m_vTextY + 2)))
1212 {
1213 return pTool;
1214 }
1215 }
1216 else
1217 {
1218 if ((vX >= pTool->m_vX) &&
1219 (vY >= pTool->m_vY) &&
1220 (vX <= (pTool->m_vX + pTool->GetWidth())) &&
1221 (vY <= (pTool->m_vY + pTool->GetHeight())))
1222 {
1223 return pTool;
1224 }
1225 }
1226 pNode = pNode->GetNext();
1227 }
1228 return (wxToolBarToolBase *)NULL;
1229} // end of wxToolBar::FindToolForPosition
1230
1231// ----------------------------------------------------------------------------
1232// tool state change handlers
1233// ----------------------------------------------------------------------------
1234
1235void wxToolBar::DoEnableTool(
1236 wxToolBarToolBase* pTool
1237, bool WXUNUSED(bEnable)
1238)
1239{
1240 DrawTool(pTool);
1241} // end of wxToolBar::DoEnableTool
1242
1243void wxToolBar::DoToggleTool(
1244 wxToolBarToolBase* pTool
1245, bool WXUNUSED(bToggle)
1246)
1247{
1248 DrawTool(pTool);
1249} // end of wxToolBar::DoToggleTool
1250
1251void wxToolBar::DoSetToggle(
1252 wxToolBarToolBase* WXUNUSED(pTool)
1253, bool WXUNUSED(bToggle)
1254)
1255{
1256 // nothing to do
1257} // end of wxToolBar::DoSetToggle
1258
1259//
1260// Okay, so we've left the tool we're in ... we must check if the tool we're
1261// leaving was a 'sprung push button' and if so, spring it back to the up
1262// state.
1263//
1264void wxToolBar::SpringUpButton(
1265 int vId
1266)
1267{
1268 wxToolBarToolBase* pTool = FindById(vId);
1269
1270 if (pTool && pTool->CanBeToggled())
1271 {
1272 if (pTool->IsToggled())
1273 pTool->Toggle();
1274
1275 DrawTool(pTool);
1276 }
1277} // end of wxToolBar::SpringUpButton
1278
1279// ----------------------------------------------------------------------------
1280// private helpers
1281// ----------------------------------------------------------------------------
1282
1283void wxToolBar::LowerTool (
1284 wxToolBarToolBase* pToolBase
1285, bool bLower
1286)
1287{
1288 wxToolBarTool* pTool = (wxToolBarTool*)pToolBase;
1289 wxCoord vX;
1290 wxCoord vY;
1291 wxCoord vWidth;
1292 wxCoord vHeight;
1293 wxPen vDarkGreyPen( wxColour(85, 85, 85)
1294 ,1
1295 ,wxSOLID
1296 );
1297 wxPen vWhitePen( "WHITE"
1298 ,1
1299 ,wxSOLID
1300 );
1301 wxPen vClearPen( GetBackgroundColour()
1302 ,1
1303 ,wxSOLID
1304 );
1305 wxClientDC vDC(this);
1306
1307 if (!pTool)
1308 return;
1309
1310 if (pTool->IsSeparator())
1311 return;
1312
1313 //
1314 // We only do this for flat toolbars
1315 //
1316 if (!HasFlag(wxTB_FLAT))
1317 return;
1318
1319 if (HasFlag(wxTB_TEXT) && !pTool->GetLabel().IsEmpty())
1320 {
1321 if (pTool->GetWidth() > m_vTextX)
1322 {
1323 vX = pTool->m_vX - 2;
1324 vWidth = pTool->GetWidth() + 4;
1325 }
1326 else
1327 {
1328 vX = pTool->m_vX - (wxCoord)(pTool->GetWidth()/2);
1329 vWidth = m_vTextX + 4;
1330 }
1331 vY = pTool->m_vY - 2;
1332 vHeight = pTool->GetHeight() + m_vTextY + 2;
1333 }
1334 else
1335 {
1336 vX = pTool->m_vX - 2;
1337 vY = pTool->m_vY - 2;
1338 vWidth = pTool->GetWidth() + 4;
1339 vHeight = pTool->GetHeight() + 4;
1340 }
1341 if (bLower)
1342 {
1343 vDC.SetPen(vWhitePen);
1344 vDC.DrawLine(vX + vWidth, vY + vHeight, vX, vY + vHeight);
1345 vDC.DrawLine(vX + vWidth, vY, vX + vWidth, vY + vHeight);
1346 vDC.SetPen(vDarkGreyPen);
1347 vDC.DrawLine(vX, vY, vX + vWidth, vY);
1348 vDC.DrawLine(vX, vY + vHeight, vX, vY);
1349 }
1350 else
1351 {
1352 vDC.SetPen(vClearPen);
1353 vDC.DrawLine(vX + vWidth, vY + vHeight, vX, vY + vHeight);
1354 vDC.DrawLine(vX + vWidth, vY, vX + vWidth, vY + vHeight);
1355 vDC.DrawLine(vX, vY, vX + vWidth, vY);
1356 vDC.DrawLine(vX, vY + vHeight, vX, vY);
1357 }
1358} // end of WinGuiBase_CToolBarTool::LowerTool
1359
1360void wxToolBar::RaiseTool (
1361 wxToolBarToolBase* pToolBase
1362, bool bRaise
1363)
1364{
1365 wxToolBarTool* pTool = (wxToolBarTool*)pToolBase;
1366 wxCoord vX;
1367 wxCoord vY;
1368 wxCoord vWidth;
1369 wxCoord vHeight;
1370 wxPen vDarkGreyPen( wxColour(85, 85, 85)
1371 ,1
1372 ,wxSOLID
1373 );
1374 wxPen vWhitePen( "WHITE"
1375 ,1
1376 ,wxSOLID
1377 );
1378 wxPen vClearPen( GetBackgroundColour()
1379 ,1
1380 ,wxSOLID
1381 );
1382 wxClientDC vDC(this);
1383
1384 if (!pTool)
1385 return;
1386
1387 if (pTool->IsSeparator())
1388 return;
1389
1390 if (!pTool->IsEnabled())
1391 return;
1392
1393 //
1394 // We only do this for flat toolbars
1395 //
1396 if (!HasFlag(wxTB_FLAT))
1397 return;
1398
1399 if (HasFlag(wxTB_TEXT) && !pTool->GetLabel().IsEmpty())
1400 {
1401 if (pTool->GetWidth() > m_vTextX)
1402 {
1403 vX = pTool->m_vX - 2;
1404 vWidth = pTool->GetWidth() + 4;
1405 }
1406 else
1407 {
1408 vX = pTool->m_vX - (wxCoord)(pTool->GetWidth()/2);
1409 vWidth = m_vTextX + 4;
1410 }
1411 vY = pTool->m_vY - 2;
1412 vHeight = pTool->GetHeight() + m_vTextY + 2;
1413 }
1414 else
1415 {
1416 vX = pTool->m_vX - 2;
1417 vY = pTool->m_vY - 2;
1418 vWidth = pTool->GetWidth() + 4;
1419 vHeight = pTool->GetHeight() + 4;
1420 }
1421 if (bRaise)
1422 {
1423 vDC.SetPen(vDarkGreyPen);
1424 vDC.DrawLine(vX + vWidth, vY + vHeight, vX, vY + vHeight);
1425 vDC.DrawLine(vX + vWidth, vY, vX + vWidth, vY + vHeight);
1426 vDC.SetPen(vWhitePen);
1427 vDC.DrawLine(vX, vY, vX + vWidth, vY);
1428 vDC.DrawLine(vX, vY + vHeight, vX, vY);
1429 }
1430 else
1431 {
1432 vDC.SetPen(vClearPen);
1433 vDC.DrawLine(vX + vWidth, vY + vHeight, vX, vY + vHeight);
1434 vDC.DrawLine(vX + vWidth, vY, vX + vWidth, vY + vHeight);
1435 vDC.DrawLine(vX, vY, vX + vWidth, vY);
1436 vDC.DrawLine(vX, vY + vHeight, vX, vY);
1437 }
1438} // end of wxToolBar::RaiseTool
1439
1440void wxToolBar::OnTimer (
1441 wxTimerEvent& rEvent
1442)
1443{
1444 if (rEvent.GetId() == m_vToolTimer.GetTimerId())
1445 {
1446 wxPoint vPos( m_vXMouse
1447 ,m_vYMouse
1448 );
1449
1450 m_pToolTip->DisplayToolTipWindow(vPos);
1451 m_vToolTimer.Stop();
1452 m_vToolExpTimer.Start(4000L, TRUE);
1453 }
1454 else if (rEvent.GetId() == m_vToolExpTimer.GetTimerId())
1455 {
1456 m_pToolTip->HideToolTipWindow();
1457 GetParent()->Refresh();
1458 m_vToolExpTimer.Stop();
1459 }
1460} // end of wxToolBar::OnTimer
1461
1462#endif // ndef for wxUSE_TOOLBAR && wxUSE_TOOLBAR_NATIVE
wxWidgets (Impactor)