home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / wxos2233.zip / wxOS2-2_3_3.zip / wxWindows-2.3.3 / src / os2 / toolbar.cpp < prev    next >
C/C++ Source or Header  |  2002-08-27  |  48KB  |  1,463 lines
  1. /////////////////////////////////////////////////////////////////////////////
  2. // Name:        toolbar.cpp
  3. // Purpose:     wxToolBar
  4. // Author:      David Webster
  5. // Modified by:
  6. // Created:     06/30/02
  7. // RCS-ID:      $Id: TOOLBAR.CPP,v 1.20 2002/08/25 17:58:43 SN Exp $
  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.  
  29. bool                                wxToolBar::m_bInitialized = FALSE;
  30.  
  31. // ---------------------------------------------------------------------------
  32. // Helper for taking a regular bitmap and giving it a disabled look
  33. // ---------------------------------------------------------------------------
  34. wxBitmap 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.  
  251. class wxToolBarTool : public wxToolBarToolBase
  252. {
  253. public:
  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.  
  303. IMPLEMENT_DYNAMIC_CLASS(wxToolBar, wxToolBarBase)
  304.  
  305. BEGIN_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)
  311. END_EVENT_TABLE()
  312.  
  313. // ============================================================================
  314. // implementation
  315. // ============================================================================
  316.  
  317. // ----------------------------------------------------------------------------
  318. // tool bar tools creation
  319. // ----------------------------------------------------------------------------
  320.  
  321. wxToolBarToolBase* 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.  
  344. wxToolBarToolBase *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.  
  357. void 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.  
  376. wxToolBarToolBase* 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.  
  408. bool 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.  
  421. bool 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.  
  434. wxToolBarToolBase* 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.  
  450. wxToolBarToolBase* 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.  
  464. wxToolBarToolBase* 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.  
  494. bool 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.  
  525. bool 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.  
  535. bool 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.  
  641. wxToolBar::~wxToolBar()
  642. {
  643.     if (m_pToolTip)
  644.     {
  645.         delete m_pToolTip;
  646.         m_pToolTip = NULL;
  647.     }
  648. } // end of wxToolBar::~wxToolBar
  649.  
  650. bool 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.  
  807. void 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.  
  879. void 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.  
  889. void wxToolBar::OnKillFocus(
  890.   wxFocusEvent&                     WXUNUSED(rEvent)
  891. )
  892. {
  893.     OnMouseEnter(m_nPressedTool = m_nCurrentTool = -1);
  894. } // end of wxToolBar::OnKillFocus
  895.  
  896. void 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.  
  1034. void wxToolBar::DrawTool(
  1035.   wxToolBarToolBase*                pTool
  1036. )
  1037. {
  1038.     wxClientDC                      vDc(this);
  1039.  
  1040.     DrawTool( vDc
  1041.              ,pTool
  1042.             );
  1043. } // end of wxToolBar::DrawTool
  1044.  
  1045. void 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.  
  1178. void 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.  
  1188. wxToolBarToolBase* 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.  
  1235. void wxToolBar::DoEnableTool(
  1236.   wxToolBarToolBase*                pTool
  1237. , bool                              WXUNUSED(bEnable)
  1238. )
  1239. {
  1240.     DrawTool(pTool);
  1241. } // end of wxToolBar::DoEnableTool
  1242.  
  1243. void wxToolBar::DoToggleTool(
  1244.   wxToolBarToolBase*                pTool
  1245. , bool                              WXUNUSED(bToggle)
  1246. )
  1247. {
  1248.     DrawTool(pTool);
  1249. } // end of wxToolBar::DoToggleTool
  1250.  
  1251. void 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. //
  1264. void 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.  
  1283. void 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.  
  1360. void 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.  
  1440. void 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
  1463.