]> git.saurik.com Git - wxWidgets.git/blob - src/os2/toolbar.cpp
projects / wxWidgets.git / blob
? search:


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