home *** CD-ROM | disk | FTP | other *** search
/ Tools / WinSN5.0Ver.iso / NETSCAP.50 / WIN1998.ZIP / ns / cmd / winfe / tlbutton.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1998-04-08  |  53.4 KB  |  2,291 lines
  1. /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
  2.  *
  3.  * The contents of this file are subject to the Netscape Public License
  4.  * Version 1.0 (the "NPL"); you may not use this file except in
  5.  * compliance with the NPL.  You may obtain a copy of the NPL at
  6.  * http://www.mozilla.org/NPL/
  7.  *
  8.  * Software distributed under the NPL is distributed on an "AS IS" basis,
  9.  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
  10.  * for the specific language governing rights and limitations under the
  11.  * NPL.
  12.  *
  13.  * The Initial Developer of this code under the NPL is Netscape
  14.  * Communications Corporation.  Portions created by Netscape are
  15.  * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
  16.  * Reserved.
  17.  */
  18.  
  19. // Created August 19, 1996 by Scott Putterman
  20.  
  21. #include "stdafx.h"
  22. #include "tlbutton.h"
  23. #include "mainfrm.h"
  24. #include "ipframe.h"
  25.  
  26. #define TEXT_CHARACTERS_SHOWN 9
  27. #define BORDERSIZE 2
  28. #define TEXTVERTMARGIN 1
  29. #define TEXTONLYVERTMARGIN 2
  30. #define BITMAPVERTMARGIN 2
  31. #define TEXT_BITMAPVERTMARGIN 1
  32. #define HORIZMARGINSIZE 4
  33.  
  34. #define IDT_MENU        16383
  35. #define MENU_DELAY_MS    500
  36.  
  37. #define IDT_BUTTONFOCUS 16410
  38. #define BUTTONFOCUS_DELAY_MS 10
  39.  
  40. static CToolbarButton *pCurrentButton = NULL;
  41.  
  42. void WFE_ParseButtonString(UINT nID, CString &statusStr, CString &toolTipStr, CString &textStr)
  43. {
  44.  
  45.         CString str1;
  46.  
  47.         str1.LoadString(nID);
  48.  
  49.         int nNewLineIndex = str1.Find('\n');
  50.     
  51.         if(nNewLineIndex == -1)
  52.         {
  53.             statusStr = str1;
  54.             toolTipStr = statusStr;
  55.             textStr = statusStr;
  56.         }
  57.         else
  58.         {
  59.             statusStr = str1.Left(nNewLineIndex);
  60.             str1 = str1.Right( str1.GetLength() - (nNewLineIndex + 1));
  61.  
  62.             nNewLineIndex = str1.Find('\n');
  63.             if( nNewLineIndex == -1)
  64.             {
  65.                 toolTipStr = str1;
  66.                 textStr = toolTipStr;
  67.             }
  68.             else
  69.             {
  70.                 toolTipStr = str1.Left(nNewLineIndex);
  71.                 textStr = str1.Right(str1.GetLength() - (nNewLineIndex + 1));
  72.             }
  73.         }
  74.  
  75.  
  76.  
  77. }
  78.  
  79. CButtonEditWnd::~CButtonEditWnd()
  80. {
  81.  
  82. }
  83.  
  84.  
  85. void CButtonEditWnd::SetToolbarButtonOwner(CToolbarButton *pOwner)
  86. {
  87.     m_pOwner = pOwner;
  88. }
  89.  
  90. BOOL CButtonEditWnd::PreTranslateMessage ( MSG * msg )
  91. {
  92.    if ( msg->message == WM_KEYDOWN)
  93.    {
  94.       switch(msg->wParam)
  95.       {
  96.          case VK_RETURN:
  97.          {
  98.             m_pOwner->EditTextChanged(m_pOwner->GetTextEditText());
  99.             return TRUE; // Bail out, since m_pOwner has been deleted.
  100.  
  101.          }
  102.          case VK_ESCAPE:
  103.              m_pOwner->RemoveTextEdit();
  104.              break;
  105.       }
  106.    }
  107.    
  108.    return CEdit::PreTranslateMessage ( msg );
  109. }
  110.  
  111. //////////////////////////////////////////////////////////////////////////
  112. //                    Messages for CButtonEditWnd
  113. //////////////////////////////////////////////////////////////////////////
  114.  
  115. BEGIN_MESSAGE_MAP(CButtonEditWnd, CEdit)
  116.     //{{AFX_MSG_MAP(CWnd)
  117.      ON_WM_DESTROY()
  118.     ON_WM_KILLFOCUS()
  119.     //}}AFX_MSG_MAP
  120. END_MESSAGE_MAP()
  121.  
  122. void CButtonEditWnd::OnDestroy( )
  123. {
  124.     delete this;
  125.  
  126. }
  127.   
  128. void CButtonEditWnd::OnKillFocus( CWnd* pNewWnd )
  129. {
  130.      m_pOwner->RemoveTextEdit();
  131. }
  132.  
  133. ////////////////////////////////////////////////////
  134.  
  135. void CALLBACK EXPORT NSButtonMenuTimerProc(
  136.     HWND hwnd,    // handle of window for timer messages 
  137.     UINT uMsg,    // WM_TIMER message
  138.     UINT idEvent,    // timer identifier
  139.     ULONG dwTime     // current system time
  140.     );
  141.  
  142. void CToolbarButtonCmdUI::Enable(BOOL bOn)
  143. {
  144.  
  145.     if(bOn != ((CToolbarButton*)m_pOther)->IsEnabled())
  146.     {
  147.  
  148.         ((CToolbarButton*)m_pOther)->Enable(bOn);
  149.  
  150.         m_pOther->Invalidate();
  151.     }
  152.  
  153.     m_bEnableChanged = TRUE;
  154. }
  155.  
  156. void CToolbarButtonCmdUI::SetCheck( int nCheck)
  157. {
  158.  
  159.  
  160.     if( nCheck != ((CToolbarButton*)m_pOther)->GetCheck())
  161.     {
  162.         ((CToolbarButton*)m_pOther)->SetCheck(nCheck);
  163.         m_pOther->Invalidate();
  164.  
  165.     }
  166.  
  167.  
  168. }
  169.  
  170.  
  171. DROPEFFECT CToolbarButtonDropTarget::OnDragEnter(CWnd * pWnd,
  172.     COleDataObject * pDataObject, DWORD dwKeyState, CPoint point)
  173. {
  174.     DROPEFFECT deReturn;
  175.  
  176.     // Only interested in bookmarks
  177.     deReturn = ProcessDragEnter(pWnd, pDataObject, dwKeyState, point);
  178.     if(deReturn != DROPEFFECT_NONE)
  179.         pWnd->SendMessage(NSDRAGGINGONBUTTON, 0, 0);
  180.  
  181.     return(deReturn);
  182.  
  183. } 
  184.  
  185.  
  186. DROPEFFECT CToolbarButtonDropTarget::OnDragOver(CWnd * pWnd,
  187.     COleDataObject * pDataObject, DWORD dwKeyState, CPoint point)
  188. {
  189.     
  190.     return ProcessDragOver(pWnd, pDataObject, dwKeyState, point);
  191. } 
  192.  
  193.  
  194. BOOL CToolbarButtonDropTarget::OnDrop(CWnd * pWnd,
  195.     COleDataObject * pDataObject, DROPEFFECT dropEffect, CPoint point)
  196. {
  197.  
  198.     return ProcessDrop(pWnd, pDataObject, dropEffect, point);
  199.     
  200. } 
  201.  
  202. CToolbarButton::CToolbarButton()
  203. {
  204.     m_nIconType = BUILTIN_BITMAP;
  205.     m_pBitmapFile = NULL;
  206.     m_pButtonText = NULL;
  207.     m_pToolTipText = NULL;
  208.     m_pStatusText = NULL;
  209.     m_bMenuShowing =FALSE;
  210.     m_bButtonDown = FALSE;
  211.     m_bHaveFocus = FALSE;
  212.     m_bIsResourceID = TRUE;
  213.     m_hFocusTimer = 0;
  214.     m_pDropMenu = NULL;
  215.     m_pDropTarget = NULL;
  216.     m_bDraggingOnButton = FALSE;
  217.     m_hBmpImg = NULL;
  218.     m_nChecked = 0;
  219.     m_bPicturesOnly = FALSE;
  220.     m_bDoOnButtonDown = FALSE;
  221.     m_dwButtonStyle = 0;
  222.     m_bDepressed = FALSE;
  223.     hasCustomTextColor = FALSE;
  224.     hasCustomBGColor = FALSE;
  225. }
  226.  
  227.  
  228. CToolbarButton::~CToolbarButton()
  229. {
  230.     if(m_pButtonText != NULL)
  231.     {
  232.         XP_FREE(m_pButtonText);
  233.     }
  234.  
  235.     if(m_pToolTipText != NULL)
  236.     {
  237.         XP_FREE(m_pToolTipText);
  238.     }
  239.  
  240.     if(m_pStatusText != NULL)
  241.     {
  242.         XP_FREE(m_pStatusText);
  243.     }
  244.  
  245.     if(m_pBitmapFile != NULL)
  246.     {
  247.         XP_FREE(m_pBitmapFile);
  248.     }
  249.  
  250.     if(m_pDropMenu != NULL)
  251.     {
  252.         delete m_pDropMenu;
  253.     }
  254.  
  255.     if(m_pDropTarget != NULL)
  256.     {
  257.         delete m_pDropTarget;
  258.     }
  259.  
  260.     if(m_hBmpImg != NULL && !m_bBitmapFromParent)
  261.         DeleteObject(m_hBmpImg);
  262.  
  263.     if(pCurrentButton == this)
  264.         pCurrentButton = NULL;
  265. }
  266.  
  267. int CToolbarButton::Create(CWnd *pParent, int nToolbarStyle, CSize noviceButtonSize,
  268.                            CSize advancedButtonSize,  LPCTSTR pButtonText, LPCTSTR pToolTipText,
  269.                            LPCTSTR pStatusText, UINT nBitmapID, UINT nBitmapIndex, CSize bitmapSize, 
  270.                            BOOL bNeedsUpdate, UINT nCommand, int nMaxTextChars, int nMinTextChars,
  271.                            DWORD dwButtonStyle)
  272. {
  273.     
  274.  
  275.  
  276.     m_nBitmapID = nBitmapID;
  277.     m_nBitmapIndex = nBitmapIndex;
  278.     m_nToolbarStyle = nToolbarStyle;
  279.     m_noviceButtonSize = noviceButtonSize;
  280.     m_advancedButtonSize = advancedButtonSize;
  281.     m_bitmapSize = bitmapSize;
  282.     m_bEnabled = TRUE;
  283.     m_bNeedsUpdate = bNeedsUpdate;
  284.     m_nCommand = nCommand;
  285.     m_nMaxTextChars = nMaxTextChars;
  286.     m_nMinTextChars = nMinTextChars;
  287.     m_dwButtonStyle = dwButtonStyle;
  288.     m_pTextEdit = NULL;
  289.  
  290.     CSize size = GetButtonSize();
  291.  
  292.     CRect rect(100, 100, size.cx, size.cy);
  293.     CBrush brush;
  294.  
  295.     int bRtn = CWnd::Create( theApp.NSToolBarClass, NULL, 
  296.                     WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CLIPCHILDREN | CS_PARENTDC,
  297.                     rect, pParent, nCommand, NULL);
  298.  
  299.     HINSTANCE hInst = AfxGetResourceHandle();
  300.  
  301.     CDC * pDC=GetDC();
  302.     if(m_bIsResourceID)
  303.     {
  304.         // if we haven't been given a bitmap yet, we don't want to load this
  305.         if(m_nBitmapID != 0)
  306.         {
  307.             WFE_InitializeUIPalette(pDC->m_hDC);
  308.             HPALETTE hPalette= WFE_GetUIPalette(GetParentFrame());
  309.             HPALETTE hOldPalette = SelectPalette(pDC->m_hDC, hPalette, FALSE);
  310.             m_hBmpImg = WFE_LoadTransparentBitmap(hInst, pDC->m_hDC, sysInfo.m_clrBtnFace, RGB(255, 0, 255), hPalette, m_nBitmapID);
  311.             SelectPalette(pDC->m_hDC, hOldPalette, TRUE);
  312.         }
  313.     }
  314.     else
  315.         m_hBmpImg = WFE_LoadBitmapFromFile(m_pBitmapFile);
  316.  
  317.     ReleaseDC(pDC);
  318.  
  319.     m_bBitmapFromParent = FALSE;
  320.  
  321.     SetText(pButtonText);
  322.  
  323.     if(pToolTipText != NULL)
  324.     {
  325.         m_pToolTipText = (LPTSTR)XP_ALLOC(XP_STRLEN(pToolTipText) + 1);
  326.         XP_STRCPY(m_pToolTipText, pToolTipText);
  327.     }
  328.  
  329.  
  330.     m_pStatusText = (LPTSTR) XP_ALLOC(XP_STRLEN(pStatusText) + 1);
  331.     XP_STRCPY(m_pStatusText, pStatusText);
  332.  
  333.     // Force initialization in SetStyle()
  334.     m_dwButtonStyle = DWORD(-1);
  335.     
  336.     //Code moved to function so style can be set separately
  337.     SetStyle(dwButtonStyle);
  338.  
  339.     m_eState = eNORMAL;
  340.  
  341.     return bRtn;
  342. }
  343.  
  344. void CToolbarButton::SetStyle(DWORD dwButtonStyle)
  345. {
  346.     // If no change from current style, then do nothing
  347.     if( m_dwButtonStyle == dwButtonStyle ){
  348.         return;
  349.     }
  350.     m_dwButtonStyle = dwButtonStyle;
  351.     CSize size = GetButtonSize();
  352.     
  353.     if(dwButtonStyle & TB_HAS_TIMED_MENU || dwButtonStyle & TB_HAS_IMMEDIATE_MENU)
  354.     {
  355.         // Create menu if not already done
  356.         // Menu contents are appended and removed every time its used,
  357.         //  so we don't need to delete items here
  358.         if(!(dwButtonStyle & TB_HAS_DRAGABLE_MENU 
  359.             && m_menu.m_hMenu != NULL
  360.             && !IsMenu(m_menu.m_hMenu)))
  361.             m_menu.CreatePopupMenu();
  362.     }
  363.     else if(dwButtonStyle & TB_HAS_DROPDOWN_TOOLBAR){
  364.         // Even though the styles are bit flags,
  365.         //    DROPDOWN_TOOLBAR style cannot be used with the MENU STYLES
  366.         SetDoOnButtonDown(TRUE);   
  367.     }
  368.  
  369.     // Create tooltip only if we have text and it wasn't created before
  370.     if(m_pToolTipText != NULL && !IsWindow(m_ToolTip.m_hWnd))
  371.     {
  372. #ifdef WIN32
  373.         m_ToolTip.Create(this, TTS_ALWAYSTIP);
  374. #else
  375.         m_ToolTip.Create(this);
  376. #endif
  377.  
  378.         if(dwButtonStyle & TB_DYNAMIC_TOOLTIP)
  379.         {
  380.             CRect tipRect(0, 0, size.cx, size.cy);
  381.             m_ToolTip.AddTool(this, LPSTR_TEXTCALLBACK, (m_nCommand == 0) ? NULL : &tipRect,
  382.                               m_nCommand);
  383.         }
  384.         else
  385.         {
  386.             m_ToolTip.AddTool(this, m_pToolTipText);
  387.         }
  388.  
  389.         m_ToolTip.Activate(TRUE);
  390.         m_ToolTip.SetDelayTime(250);
  391.     }
  392. }
  393.  
  394. int CToolbarButton::Create(CWnd *pParent, int nToolbarStyle, CSize noviceButtonSize, CSize advancedButtonSize,
  395.                LPCTSTR pButtonText, LPCTSTR pToolTipText, 
  396.                LPCTSTR pStatusText, LPCTSTR pBitmapFile,
  397.                CSize m_bitmapSize, BOOL bNeedsUpdate, UINT nCommand, int nMaxTextChars, int nMinTextChars,
  398.                DWORD dwButtonStyle)
  399. {
  400.  
  401.     m_bIsResourceID = FALSE;
  402.  
  403.     m_pBitmapFile = (LPTSTR) XP_ALLOC(XP_STRLEN(pBitmapFile) + 1);
  404.     XP_STRCPY(m_pBitmapFile, pBitmapFile);
  405.  
  406.     return Create(pParent, nToolbarStyle, noviceButtonSize, advancedButtonSize, pButtonText, pToolTipText,
  407.                   pStatusText, 0, 0, m_bitmapSize, bNeedsUpdate, nCommand, nMaxTextChars, nMinTextChars,
  408.                   dwButtonStyle);
  409.  
  410.  
  411. }
  412.  
  413. void CToolbarButton::SetText(LPCTSTR pButtonText)
  414. {
  415.     CSize oldSize = GetRequiredButtonSize();
  416.  
  417.     if(m_pButtonText != NULL)
  418.     {
  419.         XP_FREE(m_pButtonText);
  420.     }
  421.  
  422.     m_pButtonText = (LPTSTR)XP_ALLOC(XP_STRLEN(pButtonText) +1);
  423.     XP_STRCPY(m_pButtonText, pButtonText);
  424.  
  425.     CSize newSize = GetRequiredButtonSize();
  426.  
  427.     if((m_nToolbarStyle == TB_PICTURESANDTEXT || m_nToolbarStyle == TB_TEXT) && ::IsWindow(m_hWnd))
  428.     {
  429.         RedrawWindow();
  430.     }
  431.  
  432.     if(oldSize != newSize)
  433.         GetParent()->SendMessage(TB_SIZECHANGED, 0, (LPARAM)m_hWnd);
  434.  
  435. }
  436.  
  437. void CToolbarButton::SetButtonCommand(UINT nCommand)
  438. {
  439. #ifdef XP_WIN32
  440.     CToolInfo ToolInfo;
  441.     UINT nID =  (m_dwButtonStyle & TB_DYNAMIC_TOOLTIP) ? m_nCommand: 0;
  442.     
  443.     m_ToolTip.GetToolInfo(ToolInfo,this,nID);
  444.     ToolInfo.uId =   (m_dwButtonStyle & TB_DYNAMIC_TOOLTIP) ? nCommand: 0;
  445.     m_ToolTip.SetToolInfo(&ToolInfo);
  446.     m_nCommand = nCommand;
  447. #else
  448.     TOOLINFO ToolInfo;
  449.     UINT nID =  (m_dwButtonStyle & TB_DYNAMIC_TOOLTIP) ? m_nCommand: 0;
  450.     
  451.     m_ToolTip.GetToolInfo(&ToolInfo);
  452.     ToolInfo.uId =   (m_dwButtonStyle & TB_DYNAMIC_TOOLTIP) ? nCommand: 0;
  453.     m_ToolTip.SetToolInfo(&ToolInfo);
  454.     m_nCommand = nCommand;
  455. #endif
  456. }
  457.  
  458. void CToolbarButton::SetToolTipText(LPCSTR pToolTipText)
  459.  
  460. {
  461.     if (pToolTipText == NULL) 
  462.         return;
  463.  
  464.     if(m_pToolTipText != NULL)
  465.     {
  466.         XP_FREE(m_pToolTipText);
  467.     }
  468.     m_pToolTipText = (LPTSTR)XP_ALLOC(XP_STRLEN(pToolTipText) +1);
  469.     XP_STRCPY(m_pToolTipText, pToolTipText);
  470.     UINT nID = (m_dwButtonStyle & TB_DYNAMIC_TOOLTIP) ? m_nCommand: 0;
  471.     m_ToolTip.UpdateTipText(m_pToolTipText, this, nID);
  472. }
  473.  
  474. void CToolbarButton::SetStatusText(LPCSTR pStatusText)
  475. {
  476.     if (pStatusText == NULL)
  477.         return;
  478.  
  479.     if(m_pStatusText != NULL)
  480.     {
  481.         XP_FREE(m_pStatusText);
  482.     }
  483.     m_pStatusText = (LPTSTR)XP_ALLOC(XP_STRLEN(pStatusText) +1);
  484.     XP_STRCPY(m_pStatusText, pStatusText);
  485. }
  486.  
  487. void CToolbarButton::SetBitmap(HBITMAP hBmpImg, BOOL bParentOwns)
  488. {
  489.     if(m_hBmpImg != NULL && !m_bBitmapFromParent)
  490.         ::DeleteObject(m_hBmpImg);
  491.  
  492.     m_hBmpImg = hBmpImg;
  493.     m_bBitmapFromParent = bParentOwns;
  494. }
  495.  
  496. void CToolbarButton::ReplaceBitmap(UINT nBitmapID, UINT nBitmapIndex)
  497. {
  498.     m_nBitmapID = nBitmapID;
  499.     m_nBitmapIndex = nBitmapIndex;
  500.  
  501.     m_bIsResourceID = TRUE;
  502.     RedrawWindow();
  503. }
  504.  
  505. void CToolbarButton::ReplaceBitmap(LPCTSTR pBitmapFile)
  506. {
  507.  
  508.     if(m_pBitmapFile != NULL)
  509.     {
  510.         XP_FREE(m_pBitmapFile);
  511.     }
  512.  
  513.     m_pBitmapFile = (LPTSTR)XP_ALLOC(XP_STRLEN(pBitmapFile) +1);
  514.     XP_STRCPY(m_pBitmapFile, pBitmapFile);
  515.  
  516.     m_bIsResourceID = FALSE;
  517.     RedrawWindow();
  518. }
  519.  
  520. void CToolbarButton::ReplaceBitmap(HBITMAP hBmpImg, UINT nBitmapIndex, BOOL bParentOwns)
  521. {
  522.     SetBitmap(hBmpImg, bParentOwns);
  523.     ReplaceBitmap(0, nBitmapIndex);
  524. }
  525.  
  526. void CToolbarButton::ReplaceBitmapIndex(UINT nBitmapIndex)
  527. {
  528.     if(m_nBitmapIndex != nBitmapIndex)
  529.     {
  530.         m_nBitmapIndex = nBitmapIndex;
  531.         RedrawWindow();
  532.     }
  533. }
  534.  
  535. CSize CToolbarButton::GetButtonSize(void)
  536. {
  537.     return(m_nToolbarStyle == TB_PICTURESANDTEXT ? m_noviceButtonSize : m_advancedButtonSize);
  538. }
  539.  
  540. CSize CToolbarButton::GetRequiredButtonSize(void)
  541. {
  542.     return GetButtonSizeFromChars(m_pButtonText, m_nMaxTextChars);
  543. }
  544.  
  545. CSize CToolbarButton::GetButtonSizeFromChars(CString s, int c)
  546. {
  547.     CSize size;
  548.  
  549.     if(m_nToolbarStyle == TB_PICTURESANDTEXT)
  550.     {
  551.         size = GetBitmapOnTopSize(s, c);
  552.     }
  553.     else if (m_nToolbarStyle == TB_PICTURES)
  554.     {
  555.         size = GetBitmapOnlySize();
  556.     }
  557.     else if(m_nToolbarStyle == TB_TEXT)
  558.     {
  559.         size = GetTextOnlySize(s, c);
  560.     }
  561.  
  562.     return size;
  563. }
  564.  
  565. CSize CToolbarButton::GetMinimalButtonSize(void)
  566. {
  567.     return GetButtonSizeFromChars(m_pButtonText, m_nMinTextChars);
  568. }
  569.  
  570. CSize CToolbarButton::GetMaximalButtonSize(void)
  571. {
  572.     return GetButtonSizeFromChars(m_pButtonText, m_nMaxTextChars);
  573. }
  574.  
  575. void CToolbarButton::CheckForMinimalSize(void)
  576. {
  577.     // A button is at its minimal size if its
  578.     // current horizontal extent is <= its minimal horizontal extent.
  579.     atMinimalSize = (GetButtonSize().cx <= GetMinimalButtonSize().cx);
  580. }
  581.  
  582. void CToolbarButton::CheckForMaximalSize(void)
  583. {
  584.     // A button is at its maximal size if its
  585.     // current horizontal extent is >= its maximal horizontal extent.
  586.     atMaximalSize = (GetButtonSize().cx >= GetMaximalButtonSize().cx);
  587. }
  588.  
  589. BOOL CToolbarButton::AtMinimalSize(void)
  590. {
  591.     CheckForMinimalSize();
  592.     return atMinimalSize;
  593. }
  594.  
  595. BOOL CToolbarButton::AtMaximalSize(void)
  596. {
  597.     CheckForMaximalSize();
  598.     return atMaximalSize;
  599. }
  600.  
  601. void CToolbarButton::SetBitmapSize(CSize sizeImage)
  602. {
  603.     m_bitmapSize = sizeImage;
  604.     RedrawWindow();
  605. }
  606.  
  607. void CToolbarButton::SetButtonSize(CSize buttonSize)
  608. {
  609.     if(m_nToolbarStyle == TB_PICTURESANDTEXT)
  610.     {
  611.         m_noviceButtonSize  = buttonSize;
  612.     }
  613.     else
  614.     {
  615.         m_advancedButtonSize = buttonSize;
  616.     }
  617. }
  618.  
  619. void CToolbarButton::SetDropTarget(CToolbarButtonDropTarget *pDropTarget)
  620. {
  621.  
  622.     m_pDropTarget = pDropTarget;
  623.  
  624.     m_pDropTarget->Register(this);
  625.     m_pDropTarget->SetButton(this);
  626. }
  627.  
  628. void CToolbarButton::SetCheck(int nCheck)
  629. {
  630.     m_nChecked = nCheck;
  631.     switch(nCheck)
  632.     {
  633.         case 0: m_eState = eNORMAL;
  634.                 break;
  635.         case 1: m_eState = eBUTTON_CHECKED; //eBUTTON_DOWN;
  636.                 break;
  637.         case 2: m_eState = eDISABLED;
  638.                 break;
  639.     }
  640.  
  641. }
  642.  
  643. int CToolbarButton::GetCheck(void)
  644. {
  645.     return m_nChecked;
  646. }
  647.  
  648. void CToolbarButton::SetPicturesOnly(int bPicturesOnly)
  649. {
  650.     m_bPicturesOnly = bPicturesOnly;
  651.     SetButtonMode(TB_PICTURES);
  652. }
  653.  
  654. void CToolbarButton::SetButtonMode(int nToolbarStyle)
  655. {
  656.     if(m_bPicturesOnly)
  657.         m_nToolbarStyle = TB_PICTURES;
  658.     else
  659.         m_nToolbarStyle = nToolbarStyle;
  660. }
  661.  
  662. void CToolbarButton::FillInButtonData(LPBUTTONITEM pButton)
  663. {
  664.     pButton->button = m_hWnd;
  665.     
  666. }
  667.  
  668. void CToolbarButton::ButtonDragged(void)
  669. {
  670.     KillTimer(m_hMenuTimer);
  671.     m_eState = eNORMAL;
  672.     RedrawWindow();
  673. }
  674.  
  675. void CToolbarButton::AddTextEdit(void)
  676. {
  677.     if(!m_pTextEdit)
  678.     {
  679.         m_pTextEdit = new CButtonEditWnd;
  680.  
  681.         if(m_pTextEdit)
  682.         {
  683.             CRect rect;
  684.             HDC hDC = ::GetDC(m_hWnd);
  685.             HFONT hFont = WFE_GetUIFont(hDC);
  686.             HFONT hOldFont = (HFONT)::SelectObject(hDC, hFont);
  687.             TEXTMETRIC tm;
  688.  
  689.             GetTextMetrics(hDC, &tm);
  690.             int height = tm.tmHeight;
  691.  
  692.             ::SelectObject(hDC, hOldFont);
  693.             ::ReleaseDC(m_hWnd, hDC);
  694.  
  695.             GetTextRect(rect);
  696.             if(rect.Height() > height)
  697.             {
  698.                 rect.top += (rect.Height() - height) / 2;
  699.                 rect.bottom -= (rect.Height() - height) / 2;
  700.             }
  701.  
  702.             BOOL bRtn = m_pTextEdit->Create(ES_AUTOHSCROLL, rect, this, 0);
  703.  
  704.             if(!bRtn)
  705.             {
  706.                 delete m_pTextEdit;
  707.                 m_pTextEdit = NULL;
  708.             }
  709.             else
  710.             {
  711.                 m_pTextEdit->ShowWindow(SW_SHOW);
  712.                 HDC hDC = ::GetDC(m_hWnd);
  713.  
  714.                 HFONT hFont = WFE_GetUIFont(hDC);
  715.                 CFont *font = (CFont*) CFont::FromHandle(hFont);
  716.                 m_pTextEdit->SetFont(font);
  717.                 ::ReleaseDC(m_hWnd, hDC);
  718.                 m_pTextEdit->SetFocus();
  719.                 m_pTextEdit->SetToolbarButtonOwner(this);
  720.             }
  721.  
  722.         }
  723.  
  724.     }
  725. }
  726.  
  727. void CToolbarButton::RemoveTextEdit(void)
  728. {
  729.     if(m_pTextEdit)
  730.     {
  731.         m_pTextEdit->PostMessage(WM_DESTROY, 0, 0);
  732.         m_pTextEdit = NULL;
  733.  
  734.     }
  735.  
  736. }
  737.  
  738. void CToolbarButton::SetTextEditText(char *pText)
  739. {
  740.     if(m_pTextEdit)
  741.     {
  742.         m_pTextEdit->ReplaceSel(pText);
  743.         m_pTextEdit->SetSel(0, strlen(pText), TRUE);
  744.     }
  745.  
  746. }
  747.  
  748. // the string returned must be deleted
  749. char * CToolbarButton::GetTextEditText(void)
  750. {
  751.     char str[1000];
  752.  
  753.     if(m_pTextEdit)
  754.     {
  755.         int size = m_pTextEdit->GetWindowText(str, 1000);
  756.         if(size > 0)
  757.         {
  758.             char *newStr = new char[size + 1];
  759.             strcpy(newStr, str);
  760.             return newStr;
  761.         }
  762.     }
  763.  
  764.     return NULL;
  765.  
  766. }
  767.  
  768. void CToolbarButton::EditTextChanged(char *pText)
  769. {
  770.     SetText(pText);
  771. }
  772.  
  773.  
  774. //////////////////////////////////////////////////////////////////////////
  775. //                    Messages for CToolbarButton
  776. //////////////////////////////////////////////////////////////////////////
  777.  
  778. BEGIN_MESSAGE_MAP(CToolbarButton, CWnd)
  779.     //{{AFX_MSG_MAP(CWnd)
  780.      ON_WM_PAINT()
  781.     ON_WM_LBUTTONDOWN()
  782.     ON_WM_LBUTTONUP()
  783.     ON_WM_RBUTTONDOWN()
  784.     ON_WM_MOUSEMOVE()
  785.     ON_WM_SHOWWINDOW()
  786.     ON_WM_ERASEBKGND()
  787. #ifdef _WIN32
  788.     ON_WM_CAPTURECHANGED()
  789. #endif
  790.     ON_WM_GETDLGCODE()
  791.     ON_WM_KEYDOWN()
  792.     ON_MESSAGE(TTN_NEEDTEXT, OnToolTipNeedText) 
  793.     ON_WM_TIMER()
  794.     ON_MESSAGE(NSDRAGMENUOPEN, OnDragMenuOpen)
  795.     ON_MESSAGE(NSDRAGGINGONBUTTON, OnDraggingOnButton)
  796.     ON_WM_PALETTECHANGED()
  797.     ON_WM_SYSCOLORCHANGE()
  798.     ON_WM_CTLCOLOR()
  799.     //}}AFX_MSG_MAP
  800.  
  801. END_MESSAGE_MAP()
  802.  
  803. void CToolbarButton::OnLButtonDown(UINT nFlags, CPoint point)
  804. {
  805.     if(m_bEnabled)
  806.     {
  807.         // Show the button down look
  808.         m_eState = eBUTTON_DOWN;
  809.         m_bDraggingOnButton = FALSE;
  810.         if(m_dwButtonStyle & TB_HAS_TIMED_MENU)
  811.         {
  812.             m_hMenuTimer = SetTimer(IDT_MENU, MENU_DELAY_MS, NULL);
  813.         }
  814.         else if(m_dwButtonStyle & TB_HAS_IMMEDIATE_MENU)
  815.         {
  816.             m_hMenuTimer = SetTimer(IDT_MENU, 0, NULL);
  817.         }
  818.  
  819.         RedrawWindow();
  820.     }
  821.     if(m_pToolTipText != NULL)
  822.     {
  823.         MSG msg = *(GetCurrentMessage());
  824.         m_ToolTip.RelayEvent(&msg);
  825.     }
  826.  
  827.     // Do action immediately if this is set
  828.     if( m_bDoOnButtonDown )
  829.         OnAction();
  830.     else 
  831.         m_bButtonDown = TRUE;
  832. }
  833.  
  834. void CToolbarButton::OnMouseMove(UINT nFlags, CPoint point)
  835. {
  836.     // Make sure we're activated (button look)
  837.     if (!m_bHaveFocus)
  838.     {
  839.             if(GetTopLevelFrame() == GetActiveWindow() || GetTopLevelFrame() == AfxGetMainWnd())
  840.             {
  841.                 m_bHaveFocus = TRUE;
  842.                 if(m_hFocusTimer == 0)
  843.                 {
  844.                     if(pCurrentButton)
  845.                         pCurrentButton->RemoveButtonFocus();
  846.                     pCurrentButton = this;
  847.                     m_hFocusTimer = SetTimer(IDT_BUTTONFOCUS, BUTTONFOCUS_DELAY_MS, NULL);
  848.  
  849.                     BOOL bStatusText = (strcmp(m_pStatusText, "") != 0);
  850.                     char status[1000];
  851.  
  852.                     if(m_dwButtonStyle & TB_DYNAMIC_STATUS){
  853.                         WFE_GetOwnerFrame(this)->SendMessage(TB_FILLINSTATUS, (WPARAM)m_nCommand, (LPARAM) status);
  854.                         WFE_GetOwnerFrame(this)->SendMessage( WM_SETMESSAGESTRING,
  855.                                                            (WPARAM) 0, (LPARAM) status );
  856.                     }
  857.                     else if ( bStatusText) {
  858.                         WFE_GetOwnerFrame(this)->SendMessage( WM_SETMESSAGESTRING,
  859.                                                            (WPARAM)0, (LPARAM) m_pStatusText );
  860.                     }
  861.  
  862.                 }
  863.  
  864.                 if(m_pToolTipText != NULL)
  865.                 {
  866.                     m_ToolTip.Activate(TRUE);
  867.                     MSG msg = *(GetCurrentMessage());
  868.                     m_ToolTip.RelayEvent(&msg);
  869.                 }
  870.  
  871.                 if(m_bEnabled)
  872.                 {
  873.                     m_eState = (nFlags & MK_LBUTTON) ? eBUTTON_DOWN : eBUTTON_UP;
  874.                     RedrawWindow();
  875.                     UpdateWindow();
  876.                 }
  877.             }
  878.     }
  879.  
  880.     if(GetTopLevelFrame() == GetActiveWindow() || GetTopLevelFrame() == AfxGetMainWnd())
  881.     {
  882.         if(m_pToolTipText!= NULL)
  883.         {
  884.             MSG msg = *(GetCurrentMessage());
  885.             m_ToolTip.RelayEvent(&msg);
  886.         }
  887.     }
  888.  
  889.  
  890.  
  891. }
  892.  
  893. void CToolbarButton::OnLButtonUp(UINT nFlags, CPoint point)
  894. {
  895.     if(m_bEnabled)
  896.     {
  897.         if (m_bHaveFocus)
  898.         {
  899.             // Do action only if not done on button down
  900.             if(!m_bDoOnButtonDown)
  901.             {
  902.                 // Cursor is still over the button, so back to button up look
  903.                 m_eState = eBUTTON_UP;
  904.                 if(m_bButtonDown)
  905.                     OnAction();
  906.             }
  907.         }
  908.         else
  909.         {
  910.             // Restore borderless look
  911.             if(m_nChecked == 0)
  912.                 m_eState = eNORMAL;
  913.         }
  914.         
  915.         RedrawWindow();
  916.     }
  917.     if(m_dwButtonStyle & TB_HAS_TIMED_MENU)
  918.     {
  919.         KillTimer(m_hMenuTimer);
  920.     }
  921.     if(m_pToolTipText != NULL)
  922.     {
  923.         MSG msg = *(GetCurrentMessage());
  924.         m_ToolTip.RelayEvent(&msg);
  925.     }
  926.     m_bButtonDown = FALSE;
  927.  
  928. }
  929.  
  930. void CToolbarButton::OnRButtonDown(UINT nFlags, CPoint point)
  931. {
  932.     if (CreateRightMouseMenu())
  933.     {
  934.         DisplayAndTrackMenu();
  935.     }
  936.  
  937.     if(m_pToolTipText != NULL)
  938.     {
  939.         MSG msg = *(GetCurrentMessage());
  940.         m_ToolTip.RelayEvent(&msg);
  941.     }
  942.  
  943.  
  944. }
  945.  
  946. void CToolbarButton::OnKeyDown( UINT nChar, UINT nRepCnt, UINT nFlags )
  947. {
  948.     int i = 0;
  949.     i++;
  950.  
  951. }
  952.   
  953.  
  954. BOOL CToolbarButton::OnCommand(UINT wParam,LONG lParam)
  955. {
  956.     return((BOOL)GetParentFrame()->SendMessage(WM_COMMAND, wParam, lParam));
  957. }
  958.  
  959.  
  960. BOOL CToolbarButton::OnNotify( WPARAM wParam, LPARAM lParam, LRESULT* pResult )
  961. {
  962.     NMHDR *hdr = (NMHDR*)lParam;
  963.     if(hdr->code == TTN_NEEDTEXT)
  964.     {
  965.         int command = (int) wParam;
  966.         LPTOOLTIPTEXT lpttt = (LPTOOLTIPTEXT) lParam; 
  967.  
  968.         GetParentFrame()->SendMessage(TB_FILLINTOOLTIP, WPARAM(m_hWnd), lParam);
  969.         return TRUE;
  970.     }
  971. #ifdef _WIN32
  972.     else
  973.         return (CWnd::OnNotify(wParam, lParam, pResult));
  974. #else
  975.     return FALSE;
  976. #endif
  977. }
  978.  
  979. void CToolbarButton::OnPaint()
  980. {
  981.     CRect updateRect;
  982.  
  983.     GetUpdateRect(&updateRect);
  984.  
  985.     CPaintDC dcPaint(this);    // device context for painting
  986.     CRect rcClient;
  987.     GetClientRect(&rcClient);
  988.     
  989.     HDC hSrcDC = dcPaint.m_hDC;
  990.  
  991.     HPALETTE hPalette;
  992.     HPALETTE hOldPalette;
  993.     CFrameWnd* pParent = WFE_GetOwnerFrame(this); 
  994.     hPalette = WFE_GetUIPalette(pParent);
  995.     hOldPalette= ::SelectPalette(hSrcDC, hPalette, FALSE);
  996.     
  997.     CFrameGlue *pGlue = CFrameGlue::GetFrameGlue(pParent);
  998.     if (pParent && pGlue && (pParent->IsKindOf(RUNTIME_CLASS(CGenericFrame)) ||
  999.         pParent->IsKindOf(RUNTIME_CLASS(CInPlaceFrame)))) {
  1000.         CFrameGlue *pGlue = CFrameGlue::GetFrameGlue(pParent);
  1001.         if (pGlue && !pGlue->IsBackGroundPalette()) {
  1002.             hOldPalette= ::SelectPalette(hSrcDC, hPalette, TRUE);
  1003.             ::RealizePalette(hSrcDC);
  1004.         }
  1005.         else {
  1006.             hOldPalette= ::SelectPalette(hSrcDC, hPalette, FALSE);
  1007.         }
  1008.     }
  1009.     else {
  1010.         hOldPalette= ::SelectPalette(hSrcDC, hPalette, TRUE);
  1011.         ::RealizePalette(hSrcDC);
  1012.     }
  1013.     HDC hMemDC = ::CreateCompatibleDC(hSrcDC);
  1014.     if(hMemDC)
  1015.     {
  1016.         HPALETTE hOldMemPalette = ::SelectPalette(hMemDC, hPalette, FALSE);
  1017.  
  1018.         HBITMAP hbmMem = CreateCompatibleBitmap(hSrcDC,
  1019.                                         rcClient.Width(),
  1020.                                         rcClient.Height());
  1021.  
  1022.         //
  1023.         // Select the bitmap into the off-screen DC.
  1024.         //
  1025.  
  1026.         HBITMAP hbmOld = (HBITMAP)::SelectObject(hMemDC, hbmMem);
  1027.  
  1028.         COLORREF rgbOldBk;
  1029.         
  1030.         // Use the button face color as our background
  1031.         HBRUSH brFace = sysInfo.m_hbrBtnFace;
  1032.         
  1033.         if (m_bDepressed)
  1034.         {
  1035.             // Use the button shadow color as our background instead.
  1036.             brFace = ::CreateSolidBrush(sysInfo.m_clrBtnShadow);
  1037.             ::SetBkColor(hMemDC, sysInfo.m_clrBtnShadow);
  1038.         }
  1039.         else if (hasCustomBGColor)
  1040.         {
  1041.             // Use the button's custom background
  1042.             brFace = ::CreateSolidBrush(customBGColor);
  1043.         }
  1044.         else ::SetBkColor(hMemDC, sysInfo.m_clrBtnFace); // Use button face color.
  1045.  
  1046.         ::FillRect(hMemDC, rcClient, brFace);
  1047.         
  1048.         if (m_bDepressed)
  1049.         {
  1050.             ::DeleteObject(brFace);
  1051.         }
  1052.  
  1053.         // if we are not enabled then must make sure that button state is normal
  1054.         if(!m_bEnabled)
  1055.         {
  1056.             m_eState = eNORMAL;
  1057.         }
  1058.  
  1059.         CRect innerRect = rcClient;
  1060.  
  1061.         innerRect.InflateRect(-BORDERSIZE, -BORDERSIZE);
  1062.  
  1063.         if(m_nToolbarStyle == TB_PICTURESANDTEXT)
  1064.         {
  1065.             DrawPicturesAndTextMode(hMemDC, innerRect);
  1066.         }
  1067.         else if(m_nToolbarStyle == TB_PICTURES)
  1068.         {
  1069.             DrawPicturesMode(hMemDC, innerRect);
  1070.         }
  1071.         else
  1072.         {
  1073.             DrawTextMode(hMemDC, innerRect);
  1074.         }
  1075.  
  1076.         // Now, draw 3d visual button effects, depending on our state
  1077.         switch (m_eState)
  1078.         {
  1079.             case eBUTTON_UP:
  1080.             {
  1081.                 if( m_nChecked == 0 )
  1082.                     DrawUpButton(hMemDC, rcClient);
  1083.                 else
  1084.                     DrawDownButton(hMemDC, rcClient);
  1085.             }
  1086.             break;
  1087.             
  1088.             case eBUTTON_CHECKED:
  1089.             {
  1090.                 // A checked button but NOT mousing over - no black border
  1091.                 DrawCheckedButton(hMemDC, rcClient);
  1092.             }
  1093.             break;
  1094.  
  1095.             case eBUTTON_DOWN:
  1096.             {
  1097.                 DrawDownButton(hMemDC, rcClient);
  1098.             }
  1099.             break;
  1100.  
  1101.             case eDISABLED:
  1102.             {
  1103.                 if(m_nChecked == 2)
  1104.                     DrawCheckedButton(hMemDC, rcClient);
  1105.  
  1106.             }
  1107.             break;
  1108.  
  1109.             case eNORMAL:
  1110.             {
  1111.                 if (m_bDepressed)
  1112.                     DrawDownButton(hMemDC, rcClient); // Looks like it's locked down.
  1113.             }
  1114.         }
  1115.  
  1116.         ::SetBkColor(hMemDC, rgbOldBk);
  1117.  
  1118.         ::BitBlt(hSrcDC, 0, 0, rcClient.Width(), rcClient.Height(), hMemDC, 0, 0,
  1119.                         SRCCOPY);
  1120.  
  1121.         ::SelectPalette(hMemDC, hOldMemPalette, FALSE);
  1122.         ::SelectPalette(hSrcDC, hOldPalette, FALSE);
  1123.  
  1124.         ::SelectObject(hMemDC, hbmOld);
  1125.         ::DeleteObject(hbmMem);
  1126.  
  1127.         ::DeleteDC(hMemDC);
  1128.     }
  1129. }
  1130.  
  1131. void CToolbarButton::OnShowWindow( BOOL bShow, UINT nStatus )
  1132. {
  1133.     m_bEraseBackground = bShow;
  1134. }
  1135.  
  1136. BOOL CToolbarButton::OnEraseBkgnd( CDC* pDC )
  1137. {
  1138.     if ( m_bEraseBackground ) {
  1139.         m_bEraseBackground = FALSE;
  1140.         return (BOOL) Default();
  1141.     } else {
  1142.         return TRUE;
  1143.     }
  1144. }
  1145.  
  1146. void CToolbarButton::OnCaptureChanged( CWnd* pWnd )
  1147. {
  1148. }
  1149.  
  1150. UINT CToolbarButton::OnGetDlgCode(void )
  1151. {
  1152.     return DLGC_WANTALLKEYS;
  1153.  
  1154. }
  1155.  
  1156. LRESULT CToolbarButton::OnToolTipNeedText(WPARAM wParam, LPARAM lParam)
  1157. {
  1158.     LPTOOLTIPTEXT lpttt = (LPTOOLTIPTEXT) lParam;
  1159.     GetParentFrame()->SendMessage(TB_FILLINTOOLTIP, WPARAM(m_hWnd), lParam);
  1160.  
  1161.     return 1;
  1162. }
  1163.  
  1164. void CToolbarButton::OnTimer( UINT  nIDEvent )
  1165. {
  1166.     if(nIDEvent == IDT_MENU)
  1167.     {
  1168.         KillTimer( IDT_MENU );
  1169.  
  1170.         SetState(eBUTTON_DOWN);
  1171.  
  1172.         RedrawWindow();
  1173.  
  1174.  
  1175.         if(m_dwButtonStyle & TB_HAS_DRAGABLE_MENU)
  1176.         {
  1177.             CPoint point = RequestMenuPlacement();
  1178.  
  1179.             if(m_pDropMenu == NULL || !m_pDropMenu->IsOpen())
  1180.             {
  1181.                 int nCount;
  1182.                 if(m_pDropMenu != NULL)
  1183.                 {
  1184.                     nCount = m_pDropMenu->GetMenuItemCount();
  1185.  
  1186.                     // clean out the menu before adding to it
  1187.                     for(int i = nCount - 1; i >= 0; i--)
  1188.                     {
  1189.                         m_pDropMenu->DeleteMenu(i, MF_BYPOSITION);
  1190.                     }
  1191.                     m_pDropMenu->DestroyDropMenu();
  1192.                     delete m_pDropMenu;
  1193.                 }
  1194.  
  1195.                 m_pDropMenu = new CDropMenu;
  1196.  
  1197.                 SendMessage(NSDRAGMENUOPEN, (WPARAM)GetButtonCommand(), (LPARAM)m_pDropMenu);
  1198.  
  1199.                 nCount = m_pDropMenu->GetMenuItemCount();
  1200.  
  1201.                 if(nCount > 0)
  1202.                 {
  1203.                     CDropMenuDropTarget *dropTarget = new CDropMenuDropTarget(m_pDropMenu);
  1204.  
  1205.                     m_pDropMenu->TrackDropMenu(this, point.x, point.y, m_bDraggingOnButton, dropTarget, m_bDraggingOnButton);
  1206.                 }
  1207.             }
  1208.             
  1209.         }
  1210.         else
  1211.         {
  1212.  
  1213.             CPoint point(0, GetButtonSize().cy);
  1214.             ClientToScreen(&point);
  1215.  
  1216.             CMenu &pMenu = GetButtonMenu();
  1217.  
  1218. #ifdef _WIN32
  1219.             WFE_GetOwnerFrame(this)->SendMessage(NSBUTTONMENUOPEN, MAKEWPARAM(GetButtonCommand(), 0 ),(LPARAM)pMenu.m_hMenu);
  1220. #else
  1221.             WFE_GetOwnerFrame(this)->SendMessage(NSBUTTONMENUOPEN, (WPARAM) GetButtonCommand(), MAKELPARAM(pMenu.m_hMenu, 0));
  1222. #endif
  1223.             SetMenuShowing(TRUE);
  1224.  
  1225.             CWnd *pWnd = WFE_GetOwnerFrame(this);
  1226.             CRect rect;
  1227.             GetWindowRect(&rect);
  1228.  
  1229.             pMenu.TrackPopupMenu(TPM_LEFTALIGN,point.x, point.y, pWnd ? pWnd : this, &rect);
  1230.                 
  1231.             SetMenuShowing(FALSE);
  1232.  
  1233.             int nCount = pMenu.GetMenuItemCount();
  1234.  
  1235.             for(int i = 0; i < nCount ; i++)
  1236.             {
  1237.                 pMenu.DeleteMenu(0, MF_BYPOSITION);
  1238.             }
  1239.  
  1240.         }
  1241.  
  1242.         SetState( eNORMAL);
  1243.         RedrawWindow();
  1244.     }
  1245.     if(nIDEvent == IDT_BUTTONFOCUS)
  1246.     {
  1247.         RemoveButtonFocus();
  1248.     }
  1249.  
  1250.  
  1251. }
  1252.  
  1253. LRESULT CToolbarButton::OnDragMenuOpen(WPARAM wParam, LPARAM lParam)
  1254. {
  1255.     GetParentFrame()->SendMessage(NSDRAGMENUOPEN,wParam, lParam);
  1256.  
  1257.     return 1;
  1258. }
  1259.  
  1260. LRESULT CToolbarButton::OnDraggingOnButton(WPARAM wParam, LPARAM lParam)
  1261. {
  1262.  
  1263.     m_bDraggingOnButton = TRUE;
  1264.     if(m_dwButtonStyle & TB_HAS_TIMED_MENU)
  1265.     {
  1266.         m_hMenuTimer = SetTimer(IDT_MENU, MENU_DELAY_MS, NULL);
  1267.     }
  1268.     else if(m_dwButtonStyle & TB_HAS_IMMEDIATE_MENU)
  1269.     {
  1270.         m_hMenuTimer = SetTimer(IDT_MENU, 0, NULL);
  1271.     }
  1272.  
  1273.     return 1;
  1274. }
  1275.  
  1276. void CToolbarButton::OnPaletteChanged( CWnd* pFocusWnd )
  1277. {
  1278.     if (pFocusWnd != this ) {
  1279.         Invalidate();
  1280.         UpdateWindow();
  1281.     }
  1282.  
  1283. }
  1284.  
  1285. void CToolbarButton::OnSysColorChange( )
  1286. {
  1287.     if(!m_bBitmapFromParent)
  1288.     {
  1289.         if(m_bIsResourceID)
  1290.         {
  1291.             if(m_hBmpImg)
  1292.                 ::DeleteObject(m_hBmpImg);
  1293.  
  1294.             HINSTANCE hInst = AfxGetResourceHandle();
  1295.             HDC hDC = ::GetDC(m_hWnd);
  1296.  
  1297.             HPALETTE hPalette= WFE_GetUIPalette(GetParentFrame());
  1298.             m_hBmpImg = WFE_LoadTransparentBitmap(hInst, hDC, sysInfo.m_clrBtnFace, RGB(255, 0, 255), hPalette, m_nBitmapID);
  1299.             
  1300.             ::ReleaseDC(m_hWnd, hDC);
  1301.             Invalidate();
  1302.         }
  1303.     }
  1304. }
  1305.  
  1306. HBRUSH CToolbarButton::OnCtlColor( CDC* pDC, CWnd* pWnd, UINT nCtlColor )
  1307. {
  1308.     if(pWnd == m_pTextEdit && nCtlColor == CTLCOLOR_EDIT)
  1309.     {
  1310.  
  1311.         pDC->SetBkColor(sysInfo.m_clrBtnFace);
  1312.         pDC->SetTextColor(sysInfo.m_clrBtnText);
  1313.         return sysInfo.m_hbrBtnFace;
  1314.     }
  1315.  
  1316.     return NULL;
  1317. }
  1318.  
  1319. //////////////////////////////////////////////////////////////////////////
  1320. //                    Helper Functions for CToolbarButton
  1321. //////////////////////////////////////////////////////////////////////////
  1322.  
  1323. void CToolbarButton::DrawPicturesAndTextMode(HDC hDC, CRect rect)
  1324. {
  1325.  
  1326.     DrawBitmapOnTop(hDC, rect);
  1327. }
  1328.  
  1329. void CToolbarButton::DrawPicturesMode(HDC hDC, CRect rect)
  1330. {
  1331.  
  1332.     DrawButtonBitmap(hDC, rect);
  1333.  
  1334. }
  1335.  
  1336. void CToolbarButton::DrawTextMode(HDC hDC, CRect rect)
  1337. {
  1338.  
  1339.     DrawTextOnly(hDC, rect);
  1340. }
  1341.  
  1342. void CToolbarButton::DrawBitmapOnTop(HDC hDC, CRect rect)
  1343. {
  1344.     CRect bitmapRect = rect;
  1345.  
  1346.     //goes 2 pixels from top
  1347.     bitmapRect.top += BITMAPVERTMARGIN;
  1348.     // Adjust the image rect
  1349.     bitmapRect.bottom = bitmapRect.top + m_bitmapSize.cy;
  1350.     
  1351.     DrawButtonBitmap(hDC, bitmapRect);
  1352.  
  1353.         // must make room for text . Note that our owner is
  1354.     // responsible for making sure our overall height is big enough to
  1355.     // hold both text and graphics.
  1356.     CString strTxt(m_pButtonText);
  1357.  
  1358.     if(m_nMaxTextChars != SHOW_ALL_CHARACTERS)
  1359.     {
  1360.          strTxt = strTxt.Left(m_nMaxTextChars);
  1361.     }
  1362.  
  1363.     HFONT font = WFE_GetUIFont(hDC);
  1364.  
  1365.     HFONT hOldFont = (HFONT)::SelectObject(hDC, font);
  1366.  
  1367.     SIZE sizeTxt;
  1368.  
  1369.     CRect sizeRect(0,0,150,0);
  1370.     ::DrawText(hDC, strTxt, strTxt.GetLength(), &sizeRect, DT_CALCRECT | DT_WORDBREAK);
  1371.     sizeTxt.cx = sizeRect.Width();
  1372.     sizeTxt.cy = sizeRect.Height();
  1373.  
  1374.     // text's baseline should be 3 pixels from bottom
  1375.     CRect txtRect = rect;
  1376.  
  1377.     txtRect.top = bitmapRect.bottom +TEXT_BITMAPVERTMARGIN;
  1378.     
  1379.     DrawButtonText(hDC, txtRect, sizeTxt, strTxt);
  1380.  
  1381.     ::SelectObject(hDC, hOldFont);
  1382.  
  1383. }
  1384.  
  1385. void CToolbarButton::DrawBitmapOnSide(HDC hDC, CRect rect)
  1386. {
  1387.  
  1388.     CRect bitmapRect = rect;
  1389.  
  1390.     bitmapRect.right = m_bitmapSize.cx + BORDERSIZE;
  1391.  
  1392.     DrawButtonBitmap(hDC, bitmapRect);
  1393.  
  1394.     CString strTxt(m_pButtonText);
  1395.  
  1396.     if(m_nMaxTextChars != SHOW_ALL_CHARACTERS)
  1397.     {
  1398.          strTxt = strTxt.Left(m_nMaxTextChars);
  1399.     }
  1400.  
  1401.     HFONT font = WFE_GetUIFont(hDC);
  1402.  
  1403.     HFONT hOldFont = (HFONT)::SelectObject(hDC, font);
  1404.  
  1405.     SIZE sizeTxt;
  1406. #if defined (WIN32)
  1407.     ::GetTextExtentPoint32(hDC, (LPCSTR)strTxt, strTxt.GetLength(), &sizeTxt);
  1408. #else
  1409.     DWORD dwSize = ::GetTextExtent(hDC, (LPCSTR)strTxt, strTxt.GetLength());
  1410.     sizeTxt.cx = LOWORD(dwSize);
  1411.     sizeTxt.cy = HIWORD(dwSize);
  1412. #endif
  1413.  
  1414.     CRect txtRect = rect;
  1415.  
  1416.     txtRect.left = bitmapRect.right;
  1417.  
  1418.     DrawButtonText(hDC, txtRect, sizeTxt, strTxt);
  1419.  
  1420.     ::SelectObject(hDC, hOldFont);
  1421. }
  1422.  
  1423. void CToolbarButton::DrawTextOnly(HDC hDC, CRect rect)
  1424. {
  1425.  
  1426.     CString strTxt(m_pButtonText);
  1427.  
  1428.     if(m_nMaxTextChars != SHOW_ALL_CHARACTERS)
  1429.     {
  1430.          strTxt = strTxt.Left(m_nMaxTextChars);
  1431.     }
  1432.  
  1433.     HFONT font = WFE_GetUIFont(hDC);
  1434.  
  1435.     HFONT hOldFont = (HFONT)::SelectObject(hDC, font);
  1436.  
  1437.  
  1438.     SIZE sizeTxt;
  1439.  
  1440.     CRect sizeRect(0,0,150,0);
  1441.     ::DrawText(hDC, strTxt, strTxt.GetLength(), &sizeRect, DT_CALCRECT | DT_WORDBREAK);
  1442.     sizeTxt.cx = sizeRect.Width();
  1443.     sizeTxt.cy = sizeRect.Height();
  1444.  
  1445.     CRect txtRect = rect;
  1446.  
  1447.     DrawButtonText(hDC, txtRect, sizeTxt, strTxt);
  1448.  
  1449.  
  1450.     ::SelectObject(hDC, hOldFont);
  1451. }
  1452.  
  1453. void CToolbarButton::DrawButtonText(HDC hDC, CRect rcTxt, CSize sizeTxt, CString strTxt)
  1454. {
  1455.  
  1456.     int nOldBkMode = ::SetBkMode(hDC, TRANSPARENT);
  1457.  
  1458.  
  1459.     if(m_bEnabled)
  1460.     {
  1461.         UINT nFormat = strTxt.Find('\n') != -1 ? 0 : DT_SINGLELINE | DT_VCENTER;
  1462.  
  1463.         COLORREF oldColor;
  1464.  
  1465.         if (hasCustomTextColor)
  1466.         {
  1467.             oldColor = ::SetTextColor(hDC, customTextColor);
  1468.         }
  1469.         else if(m_eState == eNORMAL || m_eState == eBUTTON_CHECKED)
  1470.         {
  1471.             oldColor = ::SetTextColor(hDC, sysInfo.m_clrBtnText);
  1472.             if (m_bDepressed)
  1473.                 oldColor = ::SetTextColor(hDC, RGB(255,255,255));
  1474.         }
  1475.         else if (m_eState == eBUTTON_DOWN)
  1476.         {
  1477.             oldColor = ::SetTextColor(hDC, RGB(0, 0, 128));
  1478.         }
  1479.         else if(m_eState == eBUTTON_UP)
  1480.         {
  1481.             oldColor = ::SetTextColor(hDC, RGB(0, 0, 255));
  1482.         }
  1483.  
  1484.         DrawText(hDC, (LPCSTR)strTxt, -1, &rcTxt, DT_CENTER | DT_EXTERNALLEADING | nFormat);
  1485.  
  1486.         ::SetTextColor(hDC, oldColor);
  1487.     }
  1488.     else
  1489.     {
  1490.         CRect textRect = rcTxt;
  1491.  
  1492.         
  1493.         textRect.left = textRect.left + (textRect.Width() - sizeTxt.cx) / 2;
  1494.         textRect.top = textRect.top + (textRect.Height() - sizeTxt.cy) / 2;
  1495.  
  1496.         CRect textBackgroundRect = textRect;
  1497.  
  1498. #ifdef XP_WIN32
  1499.         if(sysInfo.m_bWin4)
  1500.         {
  1501.             
  1502.             TEXTMETRIC tm;
  1503.             
  1504.             GetTextMetrics(hDC, &tm);
  1505.  
  1506.             int descent = tm.tmDescent;
  1507.             int retVal = DrawState(hDC, NULL, NULL, (LPARAM)strTxt.LockBuffer(), 0, textRect.left, textRect.top, 0, 0, DST_TEXT | DSS_DISABLED);
  1508.             strTxt.UnlockBuffer();
  1509.  
  1510.         }
  1511.         else
  1512. #endif
  1513.         {
  1514.             UINT nFormat = strTxt.Find('\n') != -1 ? 0 : DT_SINGLELINE;
  1515.  
  1516.             textBackgroundRect.left +=1;
  1517.             textBackgroundRect.top +=1;
  1518.             
  1519.             COLORREF oldColor = ::SetTextColor(hDC,  GetSysColor(COLOR_BTNHIGHLIGHT )); // white
  1520.             ::DrawText( hDC, (LPCSTR) strTxt, -1, &textBackgroundRect,   DT_EXTERNALLEADING | nFormat);
  1521.             ::SetTextColor(hDC, GetSysColor( COLOR_GRAYTEXT ) );
  1522.             ::DrawText(hDC, (LPCSTR) strTxt, -1, &textRect,   DT_EXTERNALLEADING | nFormat);
  1523.             ::SetTextColor(hDC, oldColor );
  1524.         }
  1525.     }
  1526.  
  1527.     ::SetBkMode(hDC, nOldBkMode);
  1528. }
  1529.  
  1530.  
  1531. void CToolbarButton::DrawButtonBitmap(HDC hDC, CRect rcImg)
  1532. {
  1533.     if(m_hBmpImg != NULL)
  1534.     {
  1535.         // Create a scratch DC and select our bitmap into it.
  1536.         HDC pBmpDC  = ::CreateCompatibleDC(hDC);
  1537.         HPALETTE hPalette = WFE_GetUIPalette(GetParentFrame());
  1538.  
  1539.         CBitmap BmpImg;
  1540.  
  1541.         CPoint ptDst;
  1542.  
  1543.         HINSTANCE hInst = AfxGetResourceHandle();
  1544.  
  1545.  
  1546.         HBITMAP hBmpImg;
  1547.  
  1548.         hBmpImg = m_hBmpImg;
  1549.  
  1550.         HBITMAP hOldBmp = (HBITMAP)::SelectObject(pBmpDC, hBmpImg);
  1551.         HPALETTE hOldPal = ::SelectPalette(pBmpDC, WFE_GetUIPalette(NULL), TRUE);
  1552.         ::RealizePalette(pBmpDC);
  1553.         // Get the image dimensions
  1554.         CSize sizeImg;
  1555.         BITMAP bmp;
  1556.  
  1557.         ::GetObject(hBmpImg, sizeof(bmp), &bmp);
  1558.         sizeImg.cx = bmp.bmWidth;
  1559.         sizeImg.cy = bmp.bmHeight;
  1560.  
  1561.         // Center the image within the button    
  1562.         ptDst.x = (rcImg.Width() >= m_bitmapSize.cx) ?
  1563.             rcImg.left + (((rcImg.Width() - m_bitmapSize.cx) + 1) / 2) : 0;
  1564.         
  1565.         ptDst.y = rcImg.top; 
  1566.         // If we're in the checked state, shift the image one pixel
  1567.         if (m_eState == eBUTTON_CHECKED || (m_eState == eBUTTON_UP && m_nChecked == 1))
  1568.         {
  1569.             ptDst.x += 1;
  1570.             ptDst.y += 1;
  1571.         }
  1572.     
  1573.         // Call the handy transparent blit function to paint the bitmap over
  1574.         // whatever colors exist.
  1575.         
  1576.         CPoint bitmapStart;
  1577.  
  1578.         BTN_STATE eState = m_eState;
  1579.  
  1580.         if(m_eState == eBUTTON_CHECKED)
  1581.             // A checked button has same bitmap as the normal state with no mouse-over
  1582.             eState = eNORMAL;
  1583.         else if(m_eState == eBUTTON_UP && m_nChecked == 2)
  1584.             // if we are in the mouse over mode, but indeterminate we want our bitmap to have a disabled look
  1585.             eState = eDISABLED;
  1586.  
  1587.         if(m_bIsResourceID)
  1588.             bitmapStart = CPoint(m_nBitmapIndex * m_bitmapSize.cx, m_bEnabled ? m_bitmapSize.cy * eState : m_bitmapSize.cy);
  1589.  
  1590.         if(m_bIsResourceID)  
  1591.         {
  1592.             UpdateIconInfo();
  1593.             if(m_nIconType == LOCAL_FILE)
  1594.             {
  1595.                 DrawLocalIcon(hDC, ptDst.x, ptDst.y);
  1596.             }
  1597.             else if (m_nIconType == ARBITRARY_URL)
  1598.             {
  1599.                 DrawCustomIcon(hDC, ptDst.x, ptDst.y);
  1600.             }
  1601.             else       
  1602.                 ::BitBlt(hDC, ptDst.x, ptDst.y, m_bitmapSize.cx, m_bitmapSize.cy, 
  1603.                      pBmpDC, bitmapStart.x, bitmapStart.y, SRCCOPY);
  1604.         }
  1605.         else
  1606.         {
  1607.             CSize destSize;
  1608.  
  1609.             if(sizeImg.cx > sizeImg.cy)
  1610.             {
  1611.                 destSize.cx = m_bitmapSize.cx;
  1612.                 destSize.cy = (int)(m_bitmapSize.cy * ((double)sizeImg.cy / sizeImg.cx));
  1613.             }
  1614.             else
  1615.             {
  1616.                 destSize.cx = (int)(m_bitmapSize.cx * ((double)sizeImg.cx/ sizeImg.cy));
  1617.                 destSize.cy = m_bitmapSize.cy;
  1618.             }
  1619.             StretchBlt(hDC, ptDst.x, ptDst.y, destSize.cx, destSize.cy,
  1620.                         pBmpDC, 0, 0, sizeImg.cx, sizeImg.cy, SRCCOPY);
  1621.         }
  1622.  
  1623.         // Cleanup
  1624.  
  1625.         ::SelectObject(pBmpDC, hOldBmp);
  1626.         ::SelectPalette(pBmpDC, hOldPal, TRUE);
  1627.         ::DeleteDC(pBmpDC);
  1628.  
  1629.     }
  1630. }
  1631.  
  1632. /****************************************************************************
  1633. *
  1634. *    Function: DrawUpButton
  1635. *
  1636. *    PARAMETERS:
  1637. *        pDC        - pointer to DC to draw on
  1638. *        rect    - client rect to draw in
  1639. *
  1640. *    RETURNS:
  1641. *        void
  1642. *
  1643. *    DESCRIPTION:
  1644. *        Protected helper function for drawing the 3d "up button" look.
  1645. *        This is a static function so it may be called without instantiating
  1646. *        the object.
  1647. *
  1648. ****************************************************************************/
  1649. void CToolbarButton::DrawUpButton(HDC hDC, CRect & rect)
  1650. {
  1651.     HBRUSH br = ::CreateSolidBrush(::GetSysColor(COLOR_BTNHIGHLIGHT));
  1652.  
  1653.     CRect rc(rect.left+1, rect.top+1, rect.right, 2);
  1654.     ::FillRect(hDC, rc, br);
  1655.     rc.SetRect(rect.left+1, rect.top+1, rect.left+2, rect.bottom - 1);
  1656.     ::FillRect(hDC, rc, br);
  1657.     ::DeleteObject(br);
  1658.     
  1659.     br = ::CreateSolidBrush((RGB(0, 0, 0)));
  1660.     // Extra focus indication is solid black rect around outside
  1661.     // Looks more like "Win3.0" style buttons
  1662.     FrameRect(hDC, &rect, br );
  1663.  
  1664.     // Hilight
  1665.     // Shadow
  1666.     ::DeleteObject(br);
  1667.     br = ::CreateSolidBrush(::GetSysColor(COLOR_BTNSHADOW));
  1668.     rc.SetRect(rect.left+1, rect.bottom - 2, rect.right - 1 , rect.bottom - 1);
  1669.     ::FillRect(hDC, rc, br);
  1670.     rc.SetRect(rect.right - 2, rect.top, rect.right - 1, rect.bottom - 1);
  1671.     ::FillRect(hDC, rc, br);
  1672.     ::DeleteObject(br);
  1673. } 
  1674. /****************************************************************************
  1675. *
  1676. *    FUNCTION:  DrawDownButton
  1677. *
  1678. *    PARAMETERS:
  1679. *        pDC        - pointer to DC to draw on
  1680. *        rect    - client rect to draw in
  1681. *
  1682. *    RETURNS:
  1683. *        void
  1684. *
  1685. *    DESCRIPTION:
  1686. *        Protected helper function for drawing the 3d "down button" look.
  1687. *        This is a static function so it may be called without instantiating
  1688. *        the object.
  1689. *
  1690. ****************************************************************************/
  1691.  
  1692. void CToolbarButton::DrawDownButton(HDC hDC, CRect & rect)
  1693. {
  1694.     DrawCheckedButton(hDC, rect);
  1695.     HBRUSH br = ::CreateSolidBrush((RGB(0, 0, 0)));
  1696.  
  1697.     ::FrameRect(hDC, &rect, br );
  1698.     ::DeleteObject(br);
  1699. }
  1700.  
  1701. /****************************************************************************
  1702. *
  1703. *    FUNCTION:  DrawCheckedButton
  1704. *
  1705. *    PARAMETERS:
  1706. *        pDC        - pointer to DC to draw on
  1707. *        rect    - client rect to draw in
  1708. *
  1709. *    RETURNS:
  1710. *        void
  1711. *
  1712. *    DESCRIPTION:
  1713. *        Protected helper function for drawing the 3d "down button" look.
  1714. *        This is a static function so it may be called without instantiating
  1715. *        the object.
  1716. *
  1717. ****************************************************************************/
  1718.  
  1719. void CToolbarButton::DrawCheckedButton(HDC hDC, CRect & rect)
  1720. {
  1721.     // Hilight
  1722.     CRect rc(rect.left+1, rect.bottom - 2, rect.right - 1, rect.bottom - 1);
  1723.     HBRUSH br = ::CreateSolidBrush(::GetSysColor(COLOR_BTNHIGHLIGHT));
  1724.     ::FillRect(hDC, rc, br);
  1725.     rc.SetRect(rect.right - 2, rect.top+1, rect.right - 1, rect.bottom - 1);
  1726.     ::FillRect(hDC, rc, br);
  1727.     
  1728.     // Shadow
  1729.     ::DeleteObject(br);
  1730.     br = ::CreateSolidBrush(::GetSysColor(COLOR_BTNSHADOW));
  1731.     rc.SetRect(rect.left+1, rect.top+1, rect.right - 1, 2);
  1732.     ::FillRect(hDC, rc, br);
  1733.     rc.SetRect(rect.left+1, rect.top+1, rect.left+2, rect.bottom - 1);
  1734.     ::FillRect(hDC, rc, br);
  1735.     ::DeleteObject(br);
  1736. }
  1737.  
  1738. void CALLBACK EXPORT NSButtonMenuTimerProc(
  1739.     HWND hwnd,    // handle of window for timer messages 
  1740.     UINT uMsg,    // WM_TIMER message
  1741.     UINT idEvent,    // timer identifier
  1742.     ULONG dwTime     // current system time
  1743.     )
  1744. {
  1745. }
  1746.  
  1747. CSize CToolbarButton::GetBitmapOnTopSize(CString strTxt, int c)
  1748. {
  1749.  
  1750.     HDC hDC = ::GetDC(m_hWnd);
  1751.  
  1752.     if (c == 0)
  1753.     {
  1754.         strTxt = "";
  1755.     }
  1756.     else if(c != SHOW_ALL_CHARACTERS)
  1757.     {
  1758.          if (strTxt.GetLength() > c)
  1759.              strTxt = strTxt.Left(c - 3) + "...";
  1760.          else strTxt = strTxt.Left(c);
  1761.     }
  1762.  
  1763.     HFONT font = WFE_GetUIFont(hDC);
  1764.  
  1765.     HFONT hOldFont = (HFONT)::SelectObject(hDC, font);
  1766.     
  1767.     CRect textRect(0,0,150,0);
  1768.  
  1769.     CSize sizeTxt;
  1770.  
  1771.     if(strTxt.IsEmpty())
  1772.         sizeTxt.cx = sizeTxt.cy = 0;
  1773.     else
  1774.     {
  1775.         DrawText(hDC, strTxt, strTxt.GetLength(), &textRect, DT_CALCRECT | DT_WORDBREAK);
  1776.         sizeTxt.cx = textRect.Width();
  1777.         sizeTxt.cy = textRect.Height();
  1778.     }
  1779.  
  1780.     int nWidth, nHeight;
  1781.  
  1782.     ::SelectObject(hDC, hOldFont);
  1783.  
  1784.     nWidth = ((m_bitmapSize.cx > sizeTxt.cx) ? m_bitmapSize.cx : sizeTxt.cx) + (2 * BORDERSIZE) + HORIZMARGINSIZE;
  1785.     nHeight = m_bitmapSize.cy + sizeTxt.cy + TEXTVERTMARGIN + TEXT_BITMAPVERTMARGIN + BITMAPVERTMARGIN + (2 *BORDERSIZE);
  1786.  
  1787.     ::ReleaseDC(m_hWnd, hDC);
  1788.  
  1789.  
  1790.     return CSize(nWidth, nHeight);
  1791. }
  1792.  
  1793. CSize CToolbarButton::GetBitmapOnlySize(void)
  1794. {
  1795.  
  1796.     int nWidth, nHeight;
  1797.  
  1798.  
  1799.     nWidth = m_bitmapSize.cx + (2 * BORDERSIZE) + HORIZMARGINSIZE;
  1800.     nHeight = m_bitmapSize.cy + (2 * BORDERSIZE);
  1801.  
  1802.     return CSize(nWidth, nHeight);
  1803.  
  1804. }
  1805.  
  1806. CSize CToolbarButton::GetBitmapOnSideSize(CString strTxt, int c)
  1807. {
  1808.  
  1809.     HDC hDC = ::GetDC(m_hWnd);
  1810.  
  1811.     if(c != SHOW_ALL_CHARACTERS)
  1812.     {
  1813.          if (strTxt.GetLength() > c)
  1814.              strTxt = strTxt.Left(c - 3) + "...";
  1815.          else strTxt = strTxt.Left(c);
  1816.     }
  1817.  
  1818.     HFONT font = WFE_GetUIFont(hDC);
  1819.  
  1820.     HFONT hOldFont = (HFONT)::SelectObject(hDC, font);
  1821.     
  1822.     SIZE sizeTxt;
  1823. #if defined (_WIN32)
  1824.     ::GetTextExtentPoint32(hDC, (LPCSTR)strTxt, strTxt.GetLength(), &sizeTxt);
  1825. #else
  1826.     DWORD dwSize = ::GetTextExtent(hDC, (LPCSTR)strTxt, strTxt.GetLength());
  1827.     sizeTxt.cx = LOWORD(dwSize);
  1828.     sizeTxt.cy = HIWORD(dwSize);
  1829. #endif
  1830.  
  1831.     ::SelectObject(hDC, hOldFont);
  1832.  
  1833.     int nWidth, nHeight;
  1834.  
  1835.     nWidth = sizeTxt.cx + m_bitmapSize.cx + (2 * BORDERSIZE) + HORIZMARGINSIZE;
  1836.     nHeight =((m_bitmapSize.cy > sizeTxt.cy) ? m_bitmapSize.cy : sizeTxt.cy) + (2 * BORDERSIZE);
  1837.  
  1838.     ::ReleaseDC(m_hWnd, hDC);
  1839.     return CSize(nWidth, nHeight);
  1840. }
  1841.  
  1842. CSize CToolbarButton::GetTextOnlySize(CString strTxt, int c)
  1843. {
  1844.  
  1845.     HDC hDC = ::GetDC(m_hWnd);
  1846.  
  1847.     if(c != SHOW_ALL_CHARACTERS)
  1848.     {
  1849.          if (strTxt.GetLength() > c)
  1850.              strTxt = strTxt.Left(c - 3) + "...";
  1851.          else strTxt = strTxt.Left(c);
  1852.     }
  1853.  
  1854.     HFONT font = WFE_GetUIFont(hDC);
  1855.  
  1856.     HFONT hOldFont = (HFONT)::SelectObject(hDC, font);
  1857.     
  1858.     CRect textRect(0,0,150,0);
  1859.  
  1860.     CSize sizeTxt;
  1861.  
  1862.     if(strTxt.IsEmpty())
  1863.         sizeTxt.cx = sizeTxt.cy = 0;
  1864.     else
  1865.     {
  1866.         DrawText(hDC, strTxt, strTxt.GetLength(), &textRect, DT_CALCRECT | DT_WORDBREAK);
  1867.  
  1868.         sizeTxt.cx = textRect.Width();
  1869.         sizeTxt.cy = textRect.Height();
  1870.     }
  1871.  
  1872.     int nWidth, nHeight;
  1873.  
  1874.     ::SelectObject(hDC, hOldFont);
  1875.  
  1876.     nWidth = sizeTxt.cx +  (2 * BORDERSIZE) + HORIZMARGINSIZE;
  1877.     nHeight = sizeTxt.cy + (2 * BORDERSIZE) + (2 * TEXTONLYVERTMARGIN);
  1878.  
  1879.     ::ReleaseDC(m_hWnd, hDC);
  1880.  
  1881.     return CSize(nWidth, nHeight);
  1882.  
  1883. }
  1884.  
  1885.  void CToolbarButton::OnUpdateCmdUI(CFrameWnd* pTarget, BOOL bDisableIfNoHndler)
  1886. {
  1887.     m_state.m_pOther = this;
  1888.  
  1889.     m_state.m_nID = m_nCommand;
  1890.  
  1891.     m_state.DoUpdate(pTarget, bDisableIfNoHndler);
  1892. }
  1893.  
  1894.  void CToolbarButton::RemoveButtonFocus(void)
  1895.  {
  1896.  
  1897.     BOOL bStatusText = (strcmp(m_pStatusText, "") != 0);
  1898.     POINT point;
  1899.  
  1900.     KillTimer(IDT_BUTTONFOCUS);
  1901.     m_hFocusTimer = 0;
  1902.     GetCursorPos(&point);
  1903.  
  1904.     CRect rcClient;
  1905.     GetWindowRect(&rcClient);
  1906.  
  1907.     if (!rcClient.PtInRect(point))
  1908.     {
  1909.         m_bHaveFocus = FALSE;
  1910.  
  1911.         if ( bStatusText && WFE_GetOwnerFrame(this) != NULL) {
  1912.             WFE_GetOwnerFrame(this)->SendMessage( WM_SETMESSAGESTRING,
  1913.                                            (WPARAM) 0, (LPARAM) "" );
  1914.         }
  1915.  
  1916.     
  1917.         //if we lose capture and we don't have a menu showing we just want to show
  1918.         //the normal state.  If we have a menu showing we want to show the button down
  1919.         //state
  1920.         if(m_nChecked == 1)
  1921.         {
  1922.             m_eState = eBUTTON_CHECKED;
  1923.             RedrawWindow();
  1924.         }
  1925.         else if(m_nChecked == 2)
  1926.         {
  1927.             m_eState = eDISABLED;
  1928.             RedrawWindow();
  1929.         }
  1930.         else if(m_eState != eNORMAL && !m_bMenuShowing)
  1931.         {
  1932.             if(m_nChecked == 0)
  1933.             {
  1934.                 m_eState = eNORMAL;
  1935.                 RedrawWindow();
  1936.             }
  1937.         }
  1938.         else if(m_bMenuShowing)
  1939.         {
  1940.             m_eState = eBUTTON_CHECKED; //eBUTTON_DOWN;
  1941.             RedrawWindow();
  1942.         }
  1943.         else if(m_bEnabled)
  1944.         {
  1945.             if(m_nChecked == 0)
  1946.             {
  1947.                 m_eState = eNORMAL;
  1948.                 RedrawWindow();
  1949.             }
  1950.         }
  1951.         UpdateWindow();
  1952.         pCurrentButton = NULL;
  1953.     }
  1954.     else
  1955.         m_hFocusTimer = SetTimer(IDT_BUTTONFOCUS, BUTTONFOCUS_DELAY_MS, NULL);
  1956.  }
  1957.  
  1958.  BOOL CToolbarButton::CreateRightMouseMenu(void)
  1959.  {
  1960.      if((m_dwButtonStyle & TB_HAS_TIMED_MENU) && m_bEnabled)
  1961.     {
  1962.  
  1963.         #ifdef _WIN32
  1964.             GetParentFrame()->SendMessage(NSBUTTONMENUOPEN, MAKEWPARAM(m_nCommand, 0 ),(LPARAM)m_menu.m_hMenu);
  1965.         #else
  1966.             GetParentFrame()->SendMessage(NSBUTTONMENUOPEN, (WPARAM)m_nCommand, MAKELPARAM(m_menu.m_hMenu,0));
  1967.         #endif
  1968.         return TRUE;
  1969.     }
  1970.  
  1971.     return FALSE;
  1972.  }
  1973.  
  1974.  void CToolbarButton::DisplayAndTrackMenu(void)
  1975.  {
  1976.  
  1977.     m_eState = eBUTTON_DOWN;
  1978.     RedrawWindow();
  1979.  
  1980.     CPoint point = RequestMenuPlacement();
  1981.     
  1982.     CWnd *pWnd = GetMenuParent();
  1983.     CRect rect;
  1984.     GetWindowRect(&rect);
  1985.     KillTimer(IDT_BUTTONFOCUS);
  1986.     m_hFocusTimer = 0;
  1987.  
  1988.     m_menu.TrackPopupMenu(TPM_LEFTALIGN | TPM_RIGHTBUTTON,point.x, point.y, pWnd ? pWnd : this, &rect);
  1989.     
  1990.     int nCount = m_menu.GetMenuItemCount();
  1991.  
  1992.     for(int i = 0; i < nCount ; i++)
  1993.     {
  1994.         m_menu.DeleteMenu(0, MF_BYPOSITION);
  1995.     }
  1996.  
  1997.     if(m_nChecked == 0)
  1998.         m_eState = eNORMAL;
  1999.     RedrawWindow();
  2000.  
  2001.  }
  2002.  
  2003.  CWnd* CToolbarButton::GetMenuParent(void)
  2004.  {
  2005.     return GetParentFrame();
  2006.  }
  2007.  
  2008.  void CToolbarButton::GetTextRect(CRect &rect)
  2009.  {
  2010.     GetClientRect(rect);
  2011.  
  2012.     rect.InflateRect(-BORDERSIZE, -BORDERSIZE);
  2013.  
  2014.  
  2015.     if(m_nToolbarStyle == TB_PICTURESANDTEXT)
  2016.     {
  2017.         GetPicturesAndTextModeTextRect(rect);
  2018.     }
  2019.     else if(m_nToolbarStyle == TB_PICTURES)
  2020.     {
  2021.         GetPicturesModeTextRect(rect);
  2022.     }
  2023.     else
  2024.     {
  2025.         GetTextModeTextRect(rect);
  2026.     }
  2027.  
  2028.  
  2029.  }
  2030.  
  2031.  void CToolbarButton::GetPicturesAndTextModeTextRect(CRect &rect)
  2032.  {
  2033.     GetBitmapOnTopTextRect(rect);
  2034.  }
  2035.  
  2036.  void CToolbarButton::GetPicturesModeTextRect(CRect &rect)
  2037.  {
  2038.     // there is no text
  2039.     rect.SetRect(0,0,0,0);
  2040.  
  2041.  }
  2042.  
  2043.  
  2044.  void CToolbarButton::GetTextModeTextRect(CRect &rect)
  2045.  {
  2046.     GetTextOnlyTextRect(rect);
  2047.  }
  2048.  
  2049.  void CToolbarButton::GetBitmapOnTopTextRect(CRect &rect)
  2050.  {
  2051.     CRect bitmapRect = rect;
  2052.  
  2053.     //goes 2 pixels from top
  2054.     bitmapRect.top += BITMAPVERTMARGIN;
  2055.     // Adjust the image rect
  2056.     bitmapRect.bottom = bitmapRect.top + m_bitmapSize.cy;
  2057.     
  2058.     rect.top = bitmapRect.bottom +TEXT_BITMAPVERTMARGIN;
  2059.  
  2060.  }
  2061.  
  2062.  void CToolbarButton::GetTextOnlyTextRect(CRect &rect)
  2063.  {
  2064.         
  2065.  }
  2066.  
  2067.  void CToolbarButton::GetBitmapOnSideTextRect(CRect &rect)
  2068.  {
  2069.     CRect bitmapRect = rect;
  2070.  
  2071.     bitmapRect.right = m_bitmapSize.cx + BORDERSIZE;
  2072.  
  2073.     rect.left = bitmapRect.right;
  2074.  
  2075.  }
  2076.  
  2077. // End CToolbar Implementation
  2078.  
  2079. //////////////////////////////////////////////////////////////////////////////////////
  2080. //                            CDragableToolbarButton
  2081. //////////////////////////////////////////////////////////////////////////////////////
  2082.  
  2083. CDragableToolbarButton::CDragableToolbarButton()
  2084. {
  2085.     m_bDragging = FALSE;
  2086. }
  2087.  
  2088. //////////////////////////////////////////////////////////////////////////
  2089. //                    Messages for CDragableToolbarButton
  2090. //////////////////////////////////////////////////////////////////////////
  2091.  
  2092. BEGIN_MESSAGE_MAP(CDragableToolbarButton, CToolbarButton)
  2093.     //{{AFX_MSG_MAP(CWnd)
  2094.     ON_WM_LBUTTONDOWN()
  2095.     ON_WM_LBUTTONUP()
  2096.     ON_WM_MOUSEMOVE()
  2097.     ON_WM_TIMER()
  2098.     //}}AFX_MSG_MAP
  2099.  
  2100. END_MESSAGE_MAP()
  2101.  
  2102. void CDragableToolbarButton::OnLButtonUp(UINT nFlags, CPoint point)
  2103. {
  2104.     CToolbarButton::OnLButtonUp(nFlags, point);
  2105.  
  2106.     if(m_bDragging)
  2107.     {
  2108.         ReleaseCapture();
  2109.         m_bDragging = FALSE;
  2110.     }
  2111. }
  2112.  
  2113. void CDragableToolbarButton::OnLButtonDown(UINT nFlags, CPoint point)
  2114. {
  2115.     m_bDragging = TRUE;
  2116.  
  2117.     m_draggingPoint = point;
  2118.  
  2119.     CToolbarButton::OnLButtonDown(nFlags, point);
  2120.  
  2121. }
  2122.  
  2123. void CDragableToolbarButton::OnMouseMove(UINT nFlags, CPoint point)
  2124. {
  2125.     if(m_bDragging)
  2126.     {
  2127.         if((abs(point.x - m_draggingPoint.x) > 5)
  2128.              || (abs(point.y - m_draggingPoint.y) > 5))
  2129.         {
  2130.             ButtonDragged();
  2131.             m_bDragging = FALSE;
  2132.  
  2133.             GetParent()->PostMessage(NSBUTTONDRAGGING, 0,(LPARAM)m_hWnd);
  2134.             return;
  2135.         }
  2136.     }
  2137.     CToolbarButton::OnMouseMove(nFlags, point);
  2138. }
  2139.  
  2140. void CDragableToolbarButton::OnTimer( UINT  nIDEvent )
  2141. {
  2142.     CToolbarButton::OnTimer(nIDEvent);
  2143.  
  2144.     if(nIDEvent == IDT_MENU)
  2145.     {
  2146.         m_bDragging = FALSE;
  2147.     }
  2148. }
  2149. // End CDragableToolbarButton Implementation
  2150.  
  2151. //////////////////////////////////////////////////////////////////////////////////////
  2152. //                            CStationaryToolbarButton
  2153. //////////////////////////////////////////////////////////////////////////////////////
  2154. int CStationaryToolbarButton::Create(CWnd *pParent, int nToolbarStyle, 
  2155.                                 CSize noviceButtonSize, CSize advancedButtonSize,
  2156.                                 LPCTSTR pButtonText, LPCTSTR pToolTipText, 
  2157.                                 LPCTSTR pStatusText, UINT nBitmapID, UINT nBitmapIndex,
  2158.                                 CSize bitmapSize, BOOL bNeedsUpdate, UINT nCommand, 
  2159.                                 int nMaxTextChars, DWORD dwButtonStyle, int nMinTextChars)
  2160. {
  2161.     
  2162.     return(CToolbarButton::Create(pParent, nToolbarStyle, noviceButtonSize, advancedButtonSize,
  2163.                            pButtonText, pToolTipText, pStatusText, nBitmapID, nBitmapIndex, 
  2164.                            bitmapSize, bNeedsUpdate,
  2165.                            nCommand, nMaxTextChars, nMinTextChars, dwButtonStyle));
  2166.  
  2167.  
  2168. }
  2169.  
  2170. int CStationaryToolbarButton::Create(CWnd *pParent, int nToolbarStyle, 
  2171.                                     CSize noviceButtonSize, CSize advancedButtonSize,
  2172.                                     LPCTSTR pButtonText, LPCTSTR pToolTipText, 
  2173.                                     LPCTSTR pStatusText, LPCTSTR pBitmapFile,
  2174.                                     CSize bitmapSize, BOOL bNeedsUpdate, UINT nCommand, 
  2175.                                     int nMaxTextChars, DWORD dwButtonStyle, int nMinTextChars)
  2176. {
  2177.     return(CToolbarButton::Create(pParent, nToolbarStyle, noviceButtonSize, advancedButtonSize,
  2178.                            pButtonText, pToolTipText, pStatusText, pBitmapFile, 
  2179.                            bitmapSize, bNeedsUpdate,
  2180.                            nCommand, nMaxTextChars, nMinTextChars, dwButtonStyle));
  2181.  
  2182. }
  2183.  
  2184.  
  2185. //////////////////////////////////////////////////////////////////////////
  2186. //                    Messages for CStationaryToolbarButton
  2187. //////////////////////////////////////////////////////////////////////////
  2188.  
  2189. BEGIN_MESSAGE_MAP(CStationaryToolbarButton, CToolbarButton)
  2190.     //{{AFX_MSG_MAP(CWnd)
  2191.     ON_WM_LBUTTONDOWN()
  2192.     ON_WM_LBUTTONUP()
  2193.     ON_WM_MOUSEMOVE()
  2194.     //}}AFX_MSG_MAP
  2195.  
  2196. END_MESSAGE_MAP()
  2197.  
  2198. void CStationaryToolbarButton::OnLButtonUp(UINT nFlags, CPoint point)
  2199. {
  2200.     CToolbarButton::OnLButtonUp(nFlags, point);
  2201. }
  2202.  
  2203. void CStationaryToolbarButton::OnLButtonDown(UINT nFlags, CPoint point)
  2204. {
  2205.     CToolbarButton::OnLButtonDown(nFlags, point);
  2206. }
  2207.  
  2208. void CStationaryToolbarButton::OnMouseMove(UINT nFlags, CPoint point)
  2209. {
  2210.     CToolbarButton::OnMouseMove(nFlags, point);
  2211. }
  2212. // End CStationaryToolbar Implementation
  2213.  
  2214.  
  2215.  
  2216.  
  2217.  
  2218.  //////////////////////////////////////////////////////////////////////////////////////
  2219. //                            CCommandToolbarButton
  2220. //////////////////////////////////////////////////////////////////////////////////////
  2221.  
  2222. CCommandToolbarButton::CCommandToolbarButton()
  2223. {
  2224.     m_pActionOwner = NULL;
  2225. }
  2226.  
  2227. int CCommandToolbarButton::Create(CWnd *pParent, int nToolbarStyle, CSize noviceButtonSize, CSize advancedButtonSize,
  2228.                                 LPCTSTR pButtonText, LPCTSTR pToolTipText, 
  2229.                                 LPCTSTR pStatusText, UINT nBitmapID, UINT nBitmapIndex,
  2230.                                 CSize bitmapSize, UINT nCommand, int nMaxTextChars, DWORD dwButtonStyle, int nMinTextChars)
  2231. {
  2232.     
  2233.     return(CStationaryToolbarButton::Create(pParent, nToolbarStyle, noviceButtonSize, advancedButtonSize,
  2234.                            pButtonText, pToolTipText, pStatusText, nBitmapID, nBitmapIndex, bitmapSize, TRUE,
  2235.                            nCommand, nMaxTextChars, dwButtonStyle, nMinTextChars));
  2236.  
  2237.  
  2238. }
  2239.  
  2240. int CCommandToolbarButton::Create(CWnd *pParent, int nToolbarStyle, CSize noviceButtonSize, CSize advancedButtonSize,
  2241.                                   LPCTSTR pButtonText, LPCTSTR pToolTipText, 
  2242.                                   LPCTSTR pStatusText, LPCTSTR pBitmapFile,
  2243.                                   CSize bitmapSize, UINT nCommand, int nMaxTextChars, DWORD dwButtonStyle, int nMinTextChars)
  2244. {
  2245.     return(CStationaryToolbarButton::Create(pParent, nToolbarStyle, noviceButtonSize, advancedButtonSize,
  2246.                            pButtonText, pToolTipText, pStatusText, pBitmapFile, bitmapSize, TRUE,
  2247.                            nCommand, nMaxTextChars, dwButtonStyle, nMinTextChars));
  2248.  
  2249. }
  2250.  
  2251. void CCommandToolbarButton::OnAction(void)
  2252. {
  2253.      CWnd *pActionOwner;
  2254.  
  2255.      if(m_pActionOwner == NULL)
  2256.         pActionOwner = WFE_GetOwnerFrame(this);
  2257.      else
  2258.         pActionOwner = m_pActionOwner;
  2259.  
  2260. #ifdef _WIN32
  2261.     pActionOwner->PostMessage(WM_COMMAND, MAKEWPARAM(m_nCommand, m_nCommand), 0);
  2262. #else
  2263.     pActionOwner->PostMessage(WM_COMMAND, (WPARAM) m_nCommand, MAKELPARAM(this->m_hWnd, 0));
  2264. #endif
  2265. }
  2266.  
  2267.  void CCommandToolbarButton::FillInOleDataSource(COleDataSource *pDataSource)
  2268.  {
  2269.  
  2270.     HGLOBAL hCommandButton = GlobalAlloc(GMEM_DDESHARE | GMEM_ZEROINIT, sizeof(COMMANDBUTTONITEM));
  2271.     if(!hCommandButton) {
  2272.         return;
  2273.     }
  2274.  
  2275.     LPCOMMANDBUTTONITEM pCommandButton = (LPCOMMANDBUTTONITEM)GlobalLock(hCommandButton);
  2276.     
  2277.     CToolbarButton::FillInButtonData(&(pCommandButton->buttonInfo));
  2278.  
  2279.     GlobalUnlock(hCommandButton);
  2280.  
  2281.     // Create the DataSourceObject
  2282.     pDataSource->CacheGlobalData(RegisterClipboardFormat(NETSCAPE_COMMAND_BUTTON_FORMAT), hCommandButton);
  2283.   
  2284.  
  2285.  }
  2286.  
  2287.  void CCommandToolbarButton::SetActionMessageOwner(CWnd *pActionOwner)
  2288.  {
  2289.      m_pActionOwner = pActionOwner;
  2290.  }
  2291.