]> 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
Fix recreating of wxBitmapComboBox using untyped client data.
[wxWidgets.git] / src / os2 / toolbar.cpp
... / ...
CommitLineData
1/////////////////////////////////////////////////////////////////////////////
2// Name: src/os2/toolbar.cpp
3// Purpose: wxToolBar
4// Author: David Webster
5// Modified by:
6// Created: 06/30/02
7// Copyright: (c) David Webster
8// Licence: wxWindows licence
9/////////////////////////////////////////////////////////////////////////////
10
11// For compilers that support precompilation, includes "wx.h".
12#include "wx/wxprec.h"
13
14#if wxUSE_TOOLBAR && wxUSE_TOOLBAR_NATIVE
15
16#include "wx/toolbar.h"
17
18#ifndef WX_PRECOMP
19 #include "wx/settings.h"
20 #include "wx/window.h"
21 #include "wx/frame.h"
22 #include "wx/app.h"
23 #include "wx/dcclient.h"
24 #include "wx/dcmemory.h"
25#endif
26
27#include "wx/tooltip.h"
28#include "wx/os2/dcclient.h"
29
30bool wxToolBar::m_bInitialized = false;
31
32// ----------------------------------------------------------------------------
33// private classes
34// ----------------------------------------------------------------------------
35
36class wxToolBarTool : public wxToolBarToolBase
37{
38public:
39 inline wxToolBarTool( wxToolBar* pTbar
40 ,int vId
41 ,const wxString& rsLabel
42 ,const wxBitmap& rBitmap1
43 ,const wxBitmap& rBitmap2
44 ,wxItemKind vKind
45 ,wxObject* pClientData
46 ,const wxString& rsShortHelpString
47 ,const wxString& rsLongHelpString
48 ) : wxToolBarToolBase( pTbar
49 ,vId
50 ,rsLabel
51 ,rBitmap1
52 ,rBitmap2
53 ,vKind
54 ,pClientData
55 ,rsShortHelpString
56 ,rsLongHelpString
57 )
58 {
59 }
60
61 inline wxToolBarTool( wxToolBar* pTbar
62 ,wxControl* pControl
63 ,const wxString& label
64 ) : wxToolBarToolBase( pTbar
65 ,pControl
66 ,label
67 )
68 {
69 }
70
71 void SetSize(const wxSize& rSize)
72 {
73 m_vWidth = rSize.x;
74 m_vHeight = rSize.y;
75 }
76
77 wxCoord GetWidth(void) const { return m_vWidth; }
78 wxCoord GetHeight(void) const { return m_vHeight; }
79
80 wxCoord m_vX;
81 wxCoord m_vY;
82 wxCoord m_vWidth;
83 wxCoord m_vHeight;
84}; // end of CLASS wxToolBarTool
85
86// ----------------------------------------------------------------------------
87// wxWin macros
88// ----------------------------------------------------------------------------
89
90IMPLEMENT_DYNAMIC_CLASS(wxToolBar, wxControl)
91
92BEGIN_EVENT_TABLE(wxToolBar, wxToolBarBase)
93 EVT_SIZE(wxToolBar::OnSize)
94 EVT_PAINT(wxToolBar::OnPaint)
95 EVT_KILL_FOCUS(wxToolBar::OnKillFocus)
96 EVT_MOUSE_EVENTS(wxToolBar::OnMouseEvent)
97 EVT_TIMER(-1, wxToolBar::OnTimer)
98END_EVENT_TABLE()
99
100// ============================================================================
101// implementation
102// ============================================================================
103
104// ----------------------------------------------------------------------------
105// tool bar tools creation
106// ----------------------------------------------------------------------------
107
108wxToolBarToolBase* wxToolBar::CreateTool(
109 int nId
110, const wxString& rsLabel
111, const wxBitmap& rBmpNormal
112, const wxBitmap& rBmpDisabled
113, wxItemKind eKind
114, wxObject* pClientData
115, const wxString& rsShortHelp
116, const wxString& rsLongHelp
117)
118{
119 return new wxToolBarTool( this
120 ,nId
121 ,rsLabel
122 ,rBmpNormal
123 ,rBmpDisabled
124 ,eKind
125 ,pClientData
126 ,rsShortHelp
127 ,rsLongHelp
128 );
129} // end of wxToolBarSimple::CreateTool
130
131wxToolBarToolBase *wxToolBar::CreateTool(
132 wxControl* pControl
133, const wxString& label
134)
135{
136 return new wxToolBarTool( this
137 ,pControl
138 ,label
139 );
140} // end of wxToolBarSimple::CreateTool
141
142// ----------------------------------------------------------------------------
143// wxToolBarSimple creation
144// ----------------------------------------------------------------------------
145
146void wxToolBar::Init()
147{
148 m_nCurrentRowsOrColumns = 0;
149
150 m_vLastX = m_vLastY = 0;
151 m_vMaxWidth = m_vMaxHeight = 0;
152 m_nPressedTool = m_nCurrentTool = -1;
153 m_vXPos = m_vYPos = -1;
154 m_vTextX = m_vTextY = 0;
155
156 m_toolPacking = 1;
157 m_toolSeparation = 5;
158
159 m_defaultWidth = 16;
160 m_defaultHeight = 15;
161
162 m_pToolTip = NULL;
163} // end of wxToolBar::Init
164
165wxToolBarToolBase* wxToolBar::DoAddTool(
166 int vId
167, const wxString& rsLabel
168, const wxBitmap& rBitmap
169, const wxBitmap& rBmpDisabled
170, wxItemKind eKind
171, const wxString& rsShortHelp
172, const wxString& rsLongHelp
173, wxObject* pClientData
174, wxCoord vXPos
175, wxCoord vYPos
176)
177{
178 //
179 // Rememeber the position for DoInsertTool()
180 //
181 m_vXPos = vXPos;
182 m_vYPos = vYPos;
183
184 return wxToolBarBase::DoAddTool( vId
185 ,rsLabel
186 ,rBitmap
187 ,rBmpDisabled
188 ,eKind
189 ,rsShortHelp
190 ,rsLongHelp
191 ,pClientData
192 ,vXPos
193 ,vYPos
194 );
195} // end of wxToolBar::DoAddTool
196
197bool wxToolBar::DeleteTool(
198 int nId
199)
200{
201 bool bOk = wxToolBarBase::DeleteTool(nId);
202
203 if (bOk)
204 {
205 Realize();
206 }
207 return bOk;
208} // end of wxToolBar::DeleteTool
209
210bool wxToolBar::DeleteToolByPos(
211 size_t nPos
212)
213{
214 bool bOk = wxToolBarBase::DeleteToolByPos(nPos);
215
216 if (bOk)
217 {
218 Realize();
219 }
220 return bOk;
221} // end of wxToolBar::DeleteTool
222
223wxToolBarToolBase* wxToolBar::InsertControl(
224 size_t nPos
225, wxControl* pControl
226)
227{
228 wxToolBarToolBase* pTool = wxToolBarBase::InsertControl( nPos
229 ,pControl
230 );
231 if (m_bInitialized)
232 {
233 Realize();
234 Refresh();
235 }
236 return pTool;
237} // end of wxToolBar::InsertControl
238
239wxToolBarToolBase* wxToolBar::InsertSeparator(
240 size_t nPos
241)
242{
243 wxToolBarToolBase* pTool = wxToolBarBase::InsertSeparator(nPos);
244
245 if (m_bInitialized)
246 {
247 Realize();
248 Refresh();
249 }
250 return pTool;
251} // end of wxToolBar::InsertSeparator
252
253wxToolBarToolBase* wxToolBar::InsertTool(
254 size_t nPos
255, int nId
256, const wxString& rsLabel
257, const wxBitmap& rBitmap
258, const wxBitmap& rBmpDisabled
259, wxItemKind eKind
260, const wxString& rsShortHelp
261, const wxString& rsLongHelp
262, wxObject* pClientData
263)
264{
265 wxToolBarToolBase* pTool = wxToolBarBase::InsertTool( nPos
266 ,nId
267 ,rsLabel
268 ,rBitmap
269 ,rBmpDisabled
270 ,eKind
271 ,rsShortHelp
272 ,rsLongHelp
273 ,pClientData
274 );
275 if (m_bInitialized)
276 {
277 Realize();
278 Refresh();
279 }
280 return pTool;
281} // end of wxToolBar::InsertTool
282
283bool wxToolBar::DoInsertTool( size_t WXUNUSED(nPos),
284 wxToolBarToolBase* pToolBase )
285{
286 wxToolBarTool* pTool = (wxToolBarTool *)pToolBase;
287
288 pTool->m_vX = m_vXPos;
289 if (pTool->m_vX == -1)
290 pTool->m_vX = m_xMargin;
291
292 pTool->m_vY = m_vYPos;
293 if (pTool->m_vY == -1)
294 pTool->m_vX = m_yMargin;
295
296 pTool->SetSize(GetToolSize());
297
298 if (pTool->IsButton())
299 {
300 //
301 // Calculate reasonable max size in case Layout() not called
302 //
303 if ((pTool->m_vX + pTool->GetNormalBitmap().GetWidth() + m_xMargin) > m_vMaxWidth)
304 m_vMaxWidth = (wxCoord)((pTool->m_vX + pTool->GetWidth() + m_xMargin));
305
306 if ((pTool->m_vY + pTool->GetNormalBitmap().GetHeight() + m_yMargin) > m_vMaxHeight)
307 m_vMaxHeight = (wxCoord)((pTool->m_vY + pTool->GetHeight() + m_yMargin));
308 }
309 return true;
310} // end of wxToolBar::DoInsertTool
311
312bool wxToolBar::DoDeleteTool( size_t WXUNUSED(nPos),
313 wxToolBarToolBase* pTool )
314{
315 pTool->Detach();
316 Refresh();
317 return true;
318} // end of wxToolBar::DoDeleteTool
319
320bool wxToolBar::Create( wxWindow* pParent,
321 wxWindowID vId,
322 const wxPoint& rPos,
323 const wxSize& rSize,
324 long lStyle,
325 const wxString& rsName )
326{
327 if ( !wxWindow::Create( pParent
328 ,vId
329 ,rPos
330 ,rSize
331 ,lStyle
332 ,rsName
333 ))
334 return false;
335
336 // Set it to grey (or other 3D face colour)
337 SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_MENUBAR));
338 SetFont(*wxSMALL_FONT);
339
340 if (GetWindowStyleFlag() & (wxTB_LEFT | wxTB_RIGHT))
341 {
342 m_vLastX = 7;
343 m_vLastY = 3;
344
345 m_maxRows = 32000; // a lot
346 m_maxCols = 1;
347 }
348 else
349 {
350 m_vLastX = 3;
351 m_vLastY = 7;
352
353 m_maxRows = 1;
354 m_maxCols = 32000; // a lot
355 }
356 SetCursor(*wxSTANDARD_CURSOR);
357
358 //
359 // The toolbar's tools, if they have labels and the winTB_TEXT
360 // style is set, then we need to take into account the size of
361 // the text when drawing tool bitmaps and the text
362 //
363 if (HasFlag(wxTB_TEXT))
364 {
365 wxClientDC vDC(this);
366
367 vDC.SetFont(GetFont());
368 vDC.GetTextExtent( wxT("XXXX")
369 ,&m_vTextX
370 ,&m_vTextY
371 );
372 }
373
374 //
375 // Position it
376 //
377 int nX = rPos.x;
378 int nY = rPos.y;
379 int nWidth = rSize.x;
380 int nHeight = rSize.y;
381
382 if (lStyle & (wxTB_TOP | wxTB_BOTTOM))
383 {
384 if (nWidth <= 0)
385 {
386 nWidth = pParent->GetClientSize().x;
387 }
388 if (nHeight <= 0)
389 {
390 if (lStyle & wxTB_TEXT)
391 nHeight = m_defaultHeight + m_vTextY;
392 else
393 nHeight = m_defaultHeight;
394 }
395 }
396 else
397 {
398 if (nHeight <= 0)
399 {
400 nHeight = pParent->GetClientSize().y;
401 }
402 if (nWidth <= 0)
403 {
404 if (lStyle & wxTB_TEXT)
405 nWidth = m_vTextX + (int)(m_vTextX/2); // a little margin
406 else
407 nWidth = m_defaultWidth + (int)(m_defaultWidth/2); // a little margin
408 }
409 }
410 if (nX < 0)
411 nX = 0;
412 if (nY < 0)
413 nY = 0;
414
415 SetSize( nX
416 ,nY
417 ,nWidth
418 ,nHeight
419 );
420 return true;
421} // end of wxToolBar::Create
422
423wxToolBar::~wxToolBar()
424{
425 wxDELETE(m_pToolTip);
426} // end of wxToolBar::~wxToolBar
427
428bool wxToolBar::Realize()
429{
430 int nMaxToolWidth = 0;
431 int nMaxToolHeight = 0;
432
433 m_nCurrentRowsOrColumns = 0;
434 m_vLastX = m_xMargin;
435 m_vLastY = m_yMargin;
436 m_vMaxWidth = 0;
437 m_vMaxHeight = 0;
438
439
440 //
441 // Find the maximum tool width and height
442 //
443 wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst();
444
445 while (node )
446 {
447 wxToolBarTool* pTool = (wxToolBarTool *)node->GetData();
448
449 if (HasFlag(wxTB_TEXT) && !pTool->GetLabel().empty())
450 {
451 //
452 // Set the height according to the font and the border size
453 //
454 if (pTool->GetWidth() > m_vTextX)
455 nMaxToolWidth = pTool->GetWidth() + 4;
456 else
457 nMaxToolWidth = m_vTextX;
458 if (pTool->GetHeight() + m_vTextY > nMaxToolHeight)
459 nMaxToolHeight = pTool->GetHeight() + m_vTextY;
460 }
461 else
462 {
463 if (pTool->GetWidth() > nMaxToolWidth )
464 nMaxToolWidth = pTool->GetWidth() + 4;
465 if (pTool->GetHeight() > nMaxToolHeight)
466 nMaxToolHeight = pTool->GetHeight();
467 }
468 node = node->GetNext();
469 }
470
471 wxCoord vTbWidth = 0L;
472 wxCoord vTbHeight = 0L;
473
474 GetSize( &vTbWidth
475 ,&vTbHeight
476 );
477 if (vTbHeight < nMaxToolHeight)
478 {
479 SetSize( -1L
480 ,-1L
481 ,vTbWidth
482 ,nMaxToolHeight + 4
483 );
484 if (GetParent()->IsKindOf(CLASSINFO(wxFrame)))
485 {
486 wxFrame* pFrame = wxDynamicCast(GetParent(), wxFrame);
487
488 if (pFrame)
489 pFrame->PositionToolBar();
490 }
491 }
492
493 int nSeparatorSize = m_toolSeparation;
494
495 node = m_tools.GetFirst();
496 while (node)
497 {
498 wxToolBarTool* pTool = (wxToolBarTool *)node->GetData();
499
500 if (pTool->IsSeparator())
501 {
502 if (GetWindowStyleFlag() & (wxTB_TOP | wxTB_BOTTOM))
503 {
504 pTool->m_vX = m_vLastX + nSeparatorSize;
505 pTool->m_vHeight = m_defaultHeight + m_vTextY;
506 if (m_nCurrentRowsOrColumns >= m_maxCols)
507 m_vLastY += nSeparatorSize;
508 else
509 m_vLastX += nSeparatorSize * 4;
510 }
511 else
512 {
513 pTool->m_vY = m_vLastY + nSeparatorSize;
514 pTool->m_vHeight = m_defaultHeight + m_vTextY;
515 if (m_nCurrentRowsOrColumns >= m_maxRows)
516 m_vLastX += nSeparatorSize;
517 else
518 m_vLastY += nSeparatorSize * 4;
519 }
520 }
521 else if (pTool->IsButton())
522 {
523 if (GetWindowStyleFlag() & (wxTB_TOP | wxTB_BOTTOM))
524 {
525 if (m_nCurrentRowsOrColumns >= m_maxCols)
526 {
527 m_nCurrentRowsOrColumns = 0;
528 m_vLastX = m_xMargin;
529 m_vLastY += nMaxToolHeight + m_toolPacking;
530 }
531 pTool->m_vX = m_vLastX + (nMaxToolWidth - ((int)(nMaxToolWidth/2) + (int)(pTool->GetWidth()/2)));
532 if (HasFlag(wxTB_TEXT))
533 pTool->m_vY = m_vLastY + nSeparatorSize - 2; // just bit of adjustment
534 else
535 pTool->m_vY = m_vLastY + (nMaxToolHeight - (int)(pTool->GetHeight()/2));
536 m_vLastX += nMaxToolWidth + m_toolPacking + m_toolSeparation;
537 }
538 else
539 {
540 if (m_nCurrentRowsOrColumns >= m_maxRows)
541 {
542 m_nCurrentRowsOrColumns = 0;
543 m_vLastX += (nMaxToolWidth + m_toolPacking);
544 m_vLastY = m_yMargin;
545 }
546 pTool->m_vX = m_vLastX + pTool->GetWidth();
547 if ( HasFlag(wxTB_TEXT) && !pTool->GetLabel().empty() )
548 pTool->m_vY = m_vLastY + (nMaxToolHeight - m_vTextY) + m_toolPacking;
549 else
550 pTool->m_vY = m_vLastY + (nMaxToolHeight - (int)(pTool->GetHeight()/2));
551 m_vLastY += nMaxToolHeight + m_toolPacking + m_toolSeparation;
552 }
553 m_nCurrentRowsOrColumns++;
554 }
555 else
556 {
557 // TODO: support the controls
558 }
559
560 if (m_vLastX > m_maxWidth)
561 m_maxWidth = m_vLastX;
562 if (m_vLastY > m_maxHeight)
563 m_maxHeight = m_vLastY;
564
565 node = node->GetNext();
566 }
567
568 if (GetWindowStyleFlag() & (wxTB_TOP | wxTB_BOTTOM))
569 m_maxWidth += nMaxToolWidth;
570 else
571 m_maxHeight += nMaxToolHeight;
572
573 m_maxWidth += m_xMargin;
574 m_maxHeight += m_yMargin;
575 m_bInitialized = true;
576 return true;
577} // end of wxToolBar::Realize
578
579// ----------------------------------------------------------------------------
580// event handlers
581// ----------------------------------------------------------------------------
582
583void wxToolBar::OnPaint (
584 wxPaintEvent& WXUNUSED(rEvent)
585)
586{
587 wxPaintDC vDc(this);
588
589 PrepareDC(vDc);
590
591 static int nCount = 0;
592
593 //
594 // Prevent reentry of OnPaint which would cause wxMemoryDC errors.
595 //
596 if (nCount > 0)
597 return;
598 nCount++;
599
600 wxPMDCImpl *impl = (wxPMDCImpl*) vDc.GetImpl();
601 ::WinFillRect(impl->GetHPS(), &impl->m_vRclPaint, GetBackgroundColour().GetPixel());
602 for ( wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst();
603 node;
604 node = node->GetNext() )
605 {
606 wxToolBarTool* pTool = (wxToolBarTool*)node->GetData();
607
608 if (pTool->IsButton() )
609 DrawTool(vDc, pTool);
610 if (pTool->IsSeparator())
611 {
612 wxColour gray85(85, 85, 85);
613 wxPen vDarkGreyPen( gray85, 1, wxSOLID );
614 int nX;
615 int nY;
616 int nHeight = 0;
617 int nWidth = 0;
618
619 vDc.SetPen(vDarkGreyPen);
620 if (HasFlag(wxTB_TEXT))
621 {
622 if (HasFlag(wxTB_TOP) || HasFlag(wxTB_BOTTOM))
623 {
624 nX = pTool->m_vX;
625 nY = pTool->m_vY - (m_vTextY - 6);
626 nHeight = (m_vTextY - 2) + pTool->GetHeight();
627 }
628 else
629 {
630 nX = pTool->m_vX + m_xMargin + 10;
631 nY = pTool->m_vY + m_vTextY + m_toolSeparation;
632 nWidth = pTool->GetWidth() > m_vTextX ? pTool->GetWidth() : m_vTextX;
633 }
634 }
635 else
636 {
637 nX = pTool->m_vX;
638 nY = pTool->m_vY;
639 if (HasFlag(wxTB_TOP) || HasFlag(wxTB_BOTTOM))
640 nHeight = pTool->GetHeight() - 2;
641 else
642 {
643 nX += m_xMargin + 10;
644 nY += m_yMargin + m_toolSeparation;
645 nWidth = pTool->GetWidth();
646 }
647 }
648 vDc.DrawLine(nX, nY, nX + nWidth, nY + nHeight);
649 }
650 }
651 nCount--;
652} // end of wxToolBar::OnPaint
653
654void wxToolBar::OnSize (
655 wxSizeEvent& WXUNUSED(rEvent)
656)
657{
658#if wxUSE_CONSTRAINTS
659 if (GetAutoLayout())
660 Layout();
661#endif
662} // end of wxToolBar::OnSize
663
664void wxToolBar::OnKillFocus(
665 wxFocusEvent& WXUNUSED(rEvent)
666)
667{
668 OnMouseEnter(m_nPressedTool = m_nCurrentTool = -1);
669} // end of wxToolBar::OnKillFocus
670
671void wxToolBar::OnMouseEvent(
672 wxMouseEvent& rEvent
673)
674{
675 POINTL vPoint;
676 HWND hWnd;
677 wxCoord vX;
678 wxCoord vY;
679 HPOINTER hPtr = ::WinQuerySysPointer(HWND_DESKTOP, SPTR_ARROW, FALSE);
680
681 ::WinSetPointer(HWND_DESKTOP, hPtr);
682 ::WinQueryPointerPos(HWND_DESKTOP, &vPoint);
683 hWnd = ::WinWindowFromPoint(HWND_DESKTOP, &vPoint, TRUE);
684 if (hWnd != (HWND)GetHwnd())
685 {
686 m_vToolTimer.Stop();
687 return;
688 }
689
690 rEvent.GetPosition(&vX, &vY);
691
692 wxToolBarTool* pTool = (wxToolBarTool *)FindToolForPosition( vX
693 ,vY
694 );
695
696 if (rEvent.LeftDown())
697 {
698 CaptureMouse();
699 }
700 if (rEvent.LeftUp())
701 {
702 ReleaseMouse();
703 }
704
705 if (!pTool)
706 {
707 m_vToolTimer.Stop();
708 if (m_nCurrentTool > -1)
709 {
710 if (rEvent.LeftIsDown())
711 SpringUpButton(m_nCurrentTool);
712 pTool = (wxToolBarTool *)FindById(m_nCurrentTool);
713 if (pTool && !pTool->IsToggled())
714 {
715 RaiseTool( pTool, FALSE );
716 }
717 m_nCurrentTool = -1;
718 OnMouseEnter(-1);
719 }
720 return;
721 }
722 if (!rEvent.IsButton())
723 {
724 if (pTool->GetId() != m_nCurrentTool)
725 {
726 //
727 // If the left button is kept down and moved over buttons,
728 // press those buttons.
729 //
730 if (rEvent.LeftIsDown() && pTool->IsEnabled())
731 {
732 SpringUpButton(m_nCurrentTool);
733 if (pTool->CanBeToggled())
734 {
735 pTool->Toggle();
736 }
737 DrawTool(pTool);
738 }
739 wxToolBarTool* pOldTool = (wxToolBarTool*)FindById(m_nCurrentTool);
740
741 if (pOldTool && !pTool->IsToggled())
742 RaiseTool( pOldTool, FALSE );
743 m_nCurrentTool = pTool->GetId();
744 OnMouseEnter(m_nCurrentTool);
745 if (!pTool->GetShortHelp().empty())
746 {
747 if (m_pToolTip)
748 delete m_pToolTip;
749 m_pToolTip = new wxToolTip(pTool->GetShortHelp());
750 m_vXMouse = (wxCoord)vPoint.x;
751 m_vYMouse = (wxCoord)vPoint.y;
752 m_vToolTimer.Start(1000L, TRUE);
753 }
754 if (!pTool->IsToggled())
755 RaiseTool(pTool);
756 }
757 return;
758 }
759
760 // Left button pressed.
761 if (rEvent.LeftDown() && pTool->IsEnabled())
762 {
763 if (pTool->CanBeToggled())
764 {
765 pTool->Toggle();
766 }
767 DrawTool(pTool);
768 }
769 else if (rEvent.RightDown())
770 {
771 OnRightClick( pTool->GetId()
772 ,vX
773 ,vY
774 );
775 }
776
777 //
778 // Left Button Released. Only this action confirms selection.
779 // If the button is enabled and it is not a toggle tool and it is
780 // in the pressed state, then raise the button and call OnLeftClick.
781 //
782 if (rEvent.LeftUp() && pTool->IsEnabled() )
783 {
784 //
785 // Pass the OnLeftClick event to tool
786 //
787 if (!OnLeftClick( pTool->GetId()
788 ,pTool->IsToggled()) &&
789 pTool->CanBeToggled())
790 {
791 //
792 // If it was a toggle, and OnLeftClick says No Toggle allowed,
793 // then change it back
794 //
795 pTool->Toggle();
796 }
797 DrawTool(pTool);
798 }
799} // end of wxToolBar::OnMouseEvent
800
801// ----------------------------------------------------------------------------
802// drawing
803// ----------------------------------------------------------------------------
804
805void wxToolBar::DrawTool( wxToolBarToolBase* pTool )
806{
807 wxClientDC vDc(this);
808
809 DrawTool( vDc, pTool );
810} // end of wxToolBar::DrawTool
811
812void wxToolBar::DrawTool( wxDC& rDc, wxToolBarToolBase* pToolBase )
813{
814 wxToolBarTool* pTool = (wxToolBarTool *)pToolBase;
815 wxColour gray85( 85,85,85 );
816 wxPen vDarkGreyPen( gray85, 1, wxSOLID );
817 wxBitmap vBitmap = pTool->GetNormalBitmap();
818 bool bUseMask = false;
819 wxMask* pMask = NULL;
820
821 PrepareDC(rDc);
822
823 if (!vBitmap.IsOk())
824 return;
825 if ((pMask = vBitmap.GetMask()) != NULL)
826 if (pMask->GetMaskBitmap() != NULLHANDLE)
827 bUseMask = true;
828
829 if (!pTool->IsToggled())
830 {
831 LowerTool(pTool, FALSE);
832 if (!pTool->IsEnabled())
833 {
834 wxColour vColor(wxT("GREY"));
835
836 rDc.SetTextForeground(vColor);
837 if (!pTool->GetDisabledBitmap().IsOk())
838 pTool->SetDisabledBitmap(wxDisableBitmap( vBitmap
839 ,(long)GetBackgroundColour().GetPixel()
840 ));
841 rDc.DrawBitmap( pTool->GetDisabledBitmap()
842 ,pTool->m_vX
843 ,pTool->m_vY
844 ,bUseMask
845 );
846 }
847 else
848 {
849 rDc.SetTextForeground(*wxBLACK);
850 rDc.DrawBitmap( vBitmap
851 ,pTool->m_vX
852 ,pTool->m_vY
853 ,bUseMask
854 );
855 }
856 if (m_windowStyle & wxTB_3DBUTTONS)
857 {
858 RaiseTool(pTool);
859 }
860 if ( HasFlag(wxTB_TEXT) && !pTool->GetLabel().empty() )
861 {
862 wxCoord vX;
863 wxCoord vY;
864 wxCoord vLeft = pTool->m_vX - (int)(pTool->GetWidth()/2);
865
866 rDc.SetFont(GetFont());
867 rDc.GetTextExtent( pTool->GetLabel()
868 ,&vX
869 ,&vY
870 );
871 if (pTool->GetWidth() > vX) // large tools
872 {
873 vLeft = pTool->m_vX + (pTool->GetWidth() - vX);
874 GetSize(&vX, &vY);
875 rDc.DrawText( pTool->GetLabel()
876 ,vLeft
877 ,vY - m_vTextY - 1
878 );
879 }
880 else // normal tools
881 {
882 vLeft += (wxCoord)((m_vTextX - vX)/2);
883 rDc.DrawText( pTool->GetLabel()
884 ,vLeft
885 ,pTool->m_vY + m_vTextY - 1 // a bit of margin
886 );
887 }
888 }
889 }
890 else
891 {
892 wxColour vColor(wxT("GREY"));
893
894 LowerTool(pTool);
895 rDc.SetTextForeground(vColor);
896 if (!pTool->GetDisabledBitmap().IsOk())
897 pTool->SetDisabledBitmap(wxDisableBitmap( vBitmap
898 ,(long)GetBackgroundColour().GetPixel()
899 ));
900 rDc.DrawBitmap( pTool->GetDisabledBitmap()
901 ,pTool->m_vX
902 ,pTool->m_vY
903 ,bUseMask
904 );
905 if ( HasFlag(wxTB_TEXT) && !pTool->GetLabel().empty() )
906 {
907 wxCoord vX;
908 wxCoord vY;
909 wxCoord vLeft = pTool->m_vX - (int)(pTool->GetWidth()/2);
910
911 rDc.SetFont(GetFont());
912 rDc.GetTextExtent( pTool->GetLabel()
913 ,&vX
914 ,&vY
915 );
916 vLeft += (wxCoord)((m_vTextX - vX)/2);
917 rDc.DrawText( pTool->GetLabel()
918 ,vLeft
919 ,pTool->m_vY + m_vTextY - 1 // a bit of margin
920 );
921 }
922 }
923} // end of wxToolBar::DrawTool
924
925// ----------------------------------------------------------------------------
926// toolbar geometry
927// ----------------------------------------------------------------------------
928
929void wxToolBar::SetRows(
930 int nRows
931)
932{
933 wxCHECK_RET( nRows != 0, wxT("max number of rows must be > 0") );
934
935 m_maxCols = (GetToolsCount() + nRows - 1) / nRows;
936 Refresh();
937} // end of wxToolBar::SetRows
938
939wxToolBarToolBase* wxToolBar::FindToolForPosition(
940 wxCoord vX
941, wxCoord vY
942) const
943{
944 wxCoord vTBarHeight = 0;
945
946 GetSize( NULL
947 ,&vTBarHeight
948 );
949 vY = vTBarHeight - vY;
950 wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst();
951 while (node)
952 {
953 wxToolBarTool* pTool = (wxToolBarTool *)node->GetData();
954
955 if ( HasFlag(wxTB_TEXT) && !pTool->GetLabel().empty() )
956 {
957 if ((vX >= (pTool->m_vX - ((wxCoord)(pTool->GetWidth()/2) - 2))) &&
958 (vY >= (pTool->m_vY - 2)) &&
959 (vX <= (pTool->m_vX + pTool->GetWidth())) &&
960 (vY <= (pTool->m_vY + pTool->GetHeight() + m_vTextY + 2)))
961 {
962 return pTool;
963 }
964 }
965 else
966 {
967 if ((vX >= pTool->m_vX) &&
968 (vY >= pTool->m_vY) &&
969 (vX <= (pTool->m_vX + pTool->GetWidth())) &&
970 (vY <= (pTool->m_vY + pTool->GetHeight())))
971 {
972 return pTool;
973 }
974 }
975 node = node->GetNext();
976 }
977 return NULL;
978} // end of wxToolBar::FindToolForPosition
979
980// ----------------------------------------------------------------------------
981// tool state change handlers
982// ----------------------------------------------------------------------------
983
984void wxToolBar::DoEnableTool(
985 wxToolBarToolBase* pTool
986, bool WXUNUSED(bEnable)
987)
988{
989 DrawTool(pTool);
990} // end of wxToolBar::DoEnableTool
991
992void wxToolBar::DoToggleTool(
993 wxToolBarToolBase* pTool
994, bool WXUNUSED(bToggle)
995)
996{
997 DrawTool(pTool);
998} // end of wxToolBar::DoToggleTool
999
1000void wxToolBar::DoSetToggle(
1001 wxToolBarToolBase* WXUNUSED(pTool)
1002, bool WXUNUSED(bToggle)
1003)
1004{
1005 // nothing to do
1006} // end of wxToolBar::DoSetToggle
1007
1008//
1009// Okay, so we've left the tool we're in ... we must check if the tool we're
1010// leaving was a 'sprung push button' and if so, spring it back to the up
1011// state.
1012//
1013void wxToolBar::SpringUpButton(
1014 int vId
1015)
1016{
1017 wxToolBarToolBase* pTool = FindById(vId);
1018
1019 if (pTool && pTool->CanBeToggled())
1020 {
1021 if (pTool->IsToggled())
1022 pTool->Toggle();
1023
1024 DrawTool(pTool);
1025 }
1026} // end of wxToolBar::SpringUpButton
1027
1028// ----------------------------------------------------------------------------
1029// private helpers
1030// ----------------------------------------------------------------------------
1031
1032void wxToolBar::LowerTool ( wxToolBarToolBase* pToolBase,
1033 bool bLower )
1034{
1035 wxToolBarTool* pTool = (wxToolBarTool*)pToolBase;
1036 wxCoord vX;
1037 wxCoord vY;
1038 wxCoord vWidth;
1039 wxCoord vHeight;
1040 wxColour gray85( 85,85,85 );
1041 wxPen vDarkGreyPen( gray85, 1, wxSOLID );
1042 wxPen vClearPen( GetBackgroundColour(), 1, wxSOLID );
1043 wxClientDC vDC(this);
1044
1045 if (!pTool)
1046 return;
1047
1048 if (pTool->IsSeparator())
1049 return;
1050
1051 //
1052 // We only do this for flat toolbars
1053 //
1054 if (!HasFlag(wxTB_FLAT))
1055 return;
1056
1057 if (HasFlag(wxTB_TEXT) && !pTool->GetLabel().empty())
1058 {
1059 if (pTool->GetWidth() > m_vTextX)
1060 {
1061 vX = pTool->m_vX - 2;
1062 vWidth = pTool->GetWidth() + 4;
1063 }
1064 else
1065 {
1066 vX = pTool->m_vX - (wxCoord)(pTool->GetWidth()/2);
1067 vWidth = m_vTextX + 4;
1068 }
1069 vY = pTool->m_vY - 2;
1070 vHeight = pTool->GetHeight() + m_vTextY + 2;
1071 }
1072 else
1073 {
1074 vX = pTool->m_vX - 2;
1075 vY = pTool->m_vY - 2;
1076 vWidth = pTool->GetWidth() + 4;
1077 vHeight = pTool->GetHeight() + 4;
1078 }
1079 if (bLower)
1080 {
1081 vDC.SetPen(*wxWHITE_PEN);
1082 vDC.DrawLine(vX + vWidth, vY + vHeight, vX, vY + vHeight);
1083 vDC.DrawLine(vX + vWidth, vY, vX + vWidth, vY + vHeight);
1084 vDC.SetPen(vDarkGreyPen);
1085 vDC.DrawLine(vX, vY, vX + vWidth, vY);
1086 vDC.DrawLine(vX, vY + vHeight, vX, vY);
1087 }
1088 else
1089 {
1090 vDC.SetPen(vClearPen);
1091 vDC.DrawLine(vX + vWidth, vY + vHeight, vX, vY + vHeight);
1092 vDC.DrawLine(vX + vWidth, vY, vX + vWidth, vY + vHeight);
1093 vDC.DrawLine(vX, vY, vX + vWidth, vY);
1094 vDC.DrawLine(vX, vY + vHeight, vX, vY);
1095 }
1096} // end of WinGuiBase_CToolBarTool::LowerTool
1097
1098void wxToolBar::RaiseTool ( wxToolBarToolBase* pToolBase,
1099 bool bRaise )
1100{
1101 wxToolBarTool* pTool = (wxToolBarTool*)pToolBase;
1102 wxCoord vX;
1103 wxCoord vY;
1104 wxCoord vWidth;
1105 wxCoord vHeight;
1106 wxColour gray85( 85,85,85 );
1107 wxPen vDarkGreyPen( gray85, 1, wxSOLID );
1108 wxPen vClearPen( GetBackgroundColour(), 1, wxSOLID );
1109 wxClientDC vDC(this);
1110
1111 if (!pTool)
1112 return;
1113
1114 if (pTool->IsSeparator())
1115 return;
1116
1117 if (!pTool->IsEnabled())
1118 return;
1119
1120 //
1121 // We only do this for flat toolbars
1122 //
1123 if (!HasFlag(wxTB_FLAT))
1124 return;
1125
1126 if (HasFlag(wxTB_TEXT) && !pTool->GetLabel().empty())
1127 {
1128 if (pTool->GetWidth() > m_vTextX)
1129 {
1130 vX = pTool->m_vX - 2;
1131 vWidth = pTool->GetWidth() + 4;
1132 }
1133 else
1134 {
1135 vX = pTool->m_vX - (wxCoord)(pTool->GetWidth()/2);
1136 vWidth = m_vTextX + 4;
1137 }
1138 vY = pTool->m_vY - 2;
1139 vHeight = pTool->GetHeight() + m_vTextY + 2;
1140 }
1141 else
1142 {
1143 vX = pTool->m_vX - 2;
1144 vY = pTool->m_vY - 2;
1145 vWidth = pTool->GetWidth() + 4;
1146 vHeight = pTool->GetHeight() + 4;
1147 }
1148 if (bRaise)
1149 {
1150 vDC.SetPen(vDarkGreyPen);
1151 vDC.DrawLine(vX + vWidth, vY + vHeight, vX, vY + vHeight);
1152 vDC.DrawLine(vX + vWidth, vY, vX + vWidth, vY + vHeight);
1153 vDC.SetPen(*wxWHITE_PEN);
1154 vDC.DrawLine(vX, vY, vX + vWidth, vY);
1155 vDC.DrawLine(vX, vY + vHeight, vX, vY);
1156 }
1157 else
1158 {
1159 vDC.SetPen(vClearPen);
1160 vDC.DrawLine(vX + vWidth, vY + vHeight, vX, vY + vHeight);
1161 vDC.DrawLine(vX + vWidth, vY, vX + vWidth, vY + vHeight);
1162 vDC.DrawLine(vX, vY, vX + vWidth, vY);
1163 vDC.DrawLine(vX, vY + vHeight, vX, vY);
1164 }
1165} // end of wxToolBar::RaiseTool
1166
1167void wxToolBar::OnTimer ( wxTimerEvent& rEvent )
1168{
1169 if (rEvent.GetId() == m_vToolTimer.GetId())
1170 {
1171 wxPoint vPos( m_vXMouse, m_vYMouse );
1172
1173 m_pToolTip->DisplayToolTipWindow(vPos);
1174 m_vToolTimer.Stop();
1175 m_vToolExpTimer.Start(4000L, TRUE);
1176 }
1177 else if (rEvent.GetId() == m_vToolExpTimer.GetId())
1178 {
1179 m_pToolTip->HideToolTipWindow();
1180 GetParent()->Refresh();
1181 m_vToolExpTimer.Stop();
1182 }
1183} // end of wxToolBar::OnTimer
1184
1185#endif // ndef for wxUSE_TOOLBAR && wxUSE_TOOLBAR_NATIVE
wxWidgets (Impactor)