home *** CD-ROM | disk | FTP | other *** search
/ Tools / WinSN5.0Ver.iso / NETSCAP.50 / WIN1998.ZIP / ns / cmd / winfe / usertlbr.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1998-04-08  |  37.7 KB  |  1,352 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. #include "stdafx.h"
  20. #include "usertlbr.h"
  21. #include "shcut.h"
  22. #include "dropmenu.h"
  23. #include "prefapi.h"
  24. #include "rdfliner.h"
  25.  
  26. extern "C" {
  27. #include "xpgetstr.h"
  28. };
  29.  
  30. #define LEFT_TOOLBAR_MARGIN 10
  31. #define RIGHT_TOOLBAR_MARGIN 20
  32. #define SPACE_BETWEEN_BUTTONS 2
  33.  
  34. #define MAX_TOOLBAR_BUTTONS 60
  35. #define MAX_TOOLBAR_ROWS 3
  36.  
  37. int CLinkToolbar::m_nMinToolbarButtonChars = 15;
  38. int CLinkToolbar::m_nMaxToolbarButtonChars = 30;
  39.  
  40. //////////////////////////////////////////////////////////////////////////////////////
  41. //                            CLinkToolbarButtonDropTarget
  42. //////////////////////////////////////////////////////////////////////////////////////
  43.  
  44. DROPEFFECT CLinkToolbarButtonDropTarget::ProcessDragEnter(CWnd *pWnd, COleDataObject *pDataObject, 
  45.             DWORD dwKeyState, CPoint point)
  46. {
  47.  
  48.     // Drop target is only used for drops directly onto folder personal toolbar buttons.
  49.     // This drop target is NOT used for the Aurora selector bar drops.
  50.     return ProcessDragOver(pWnd, pDataObject, dwKeyState, point);
  51. }
  52.  
  53. DROPEFFECT CLinkToolbarButtonDropTarget::ProcessDragOver(CWnd *pWnd, COleDataObject *pDataObject, 
  54.             DWORD dwKeyState, CPoint point)
  55. {
  56.     CLinkToolbarButton* pButton = (CLinkToolbarButton*)m_pButton;
  57.  
  58.     // Treat as a drop onto the folder.
  59.     return RDFGLOBAL_TranslateDropAction(pButton->GetNode(), pDataObject, 2);
  60. }
  61.  
  62. BOOL CLinkToolbarButtonDropTarget::ProcessDrop(CWnd *pWnd, COleDataObject *pDataObject, 
  63.             DROPEFFECT dropEffect, CPoint point)
  64. {
  65.     // Treat as a drop onto the folder.
  66.     CLinkToolbarButton* pButton = (CLinkToolbarButton*)m_pButton;
  67.     RDFGLOBAL_PerformDrop(pDataObject, pButton->GetNode(), 2);
  68.     return TRUE;
  69. }
  70.  
  71. //////////////////////////////////////////////////////////////////////////////////////
  72. //                            CLinkToolbarButton
  73. //////////////////////////////////////////////////////////////////////////////////////
  74. static HBITMAP m_hbmpBM = NULL;
  75. static HBITMAP m_hbmpBMSelected = NULL;
  76. static HBITMAP m_hbmpFolder = NULL;
  77. static HBITMAP m_hbmpSelectedFolder = NULL;
  78. static HBITMAP m_hbmpFolderOpen =  NULL;
  79. static int nBitmapRefCount = 0;
  80.  
  81. CLinkToolbarButton::CLinkToolbarButton()
  82. {
  83.     m_bShouldShowRMMenu = TRUE;
  84.  
  85.     m_Node = NULL;
  86.  
  87.     m_uCurBMID = 0;
  88.  
  89.     currentRow = 0;
  90. }
  91.  
  92.  
  93. CLinkToolbarButton::~CLinkToolbarButton()
  94. {
  95.     if(m_Node && HT_IsContainer(m_Node))
  96.     {
  97.         nBitmapRefCount--;
  98.  
  99.         if(nBitmapRefCount == 0)
  100.         {
  101.             if(m_hbmpBM)
  102.             {
  103.                 DeleteObject(m_hbmpBM);
  104.             }
  105.  
  106.             if(m_hbmpFolder)
  107.             {
  108.                 DeleteObject(m_hbmpFolder);
  109.             }
  110.  
  111.             if(m_hbmpSelectedFolder)
  112.             {
  113.                 DeleteObject(m_hbmpSelectedFolder);
  114.             }
  115.  
  116.             if(m_hbmpFolderOpen)
  117.             {
  118.                 DeleteObject(m_hbmpFolderOpen);
  119.             }
  120.  
  121.             if(m_hbmpBMSelected)
  122.             {
  123.                 DeleteObject(m_hbmpBMSelected);
  124.             }
  125.         }
  126.  
  127.     }
  128. }
  129.  
  130. int CLinkToolbarButton::Create(CWnd *pParent, int nToolbarStyle, CSize noviceButtonSize, CSize advancedButtonSize,
  131.                                 LPCTSTR pButtonText, LPCTSTR pToolTipText,
  132.                                 LPCTSTR pStatusText, 
  133.                                 CSize bitmapSize, int nMaxTextChars, int nMinTextChars, BOOKMARKITEM bookmark,
  134.                                 HT_Resource pNode, DWORD dwButtonStyle )
  135. {
  136.     
  137.     m_bookmark = bookmark;
  138.  
  139.     char *protocol = NULL;
  140.  
  141.     BOOL bResult = CToolbarButton::Create(pParent, nToolbarStyle, noviceButtonSize, advancedButtonSize,
  142.         pButtonText, pToolTipText, pStatusText, 0, 0,
  143.         bitmapSize, TRUE, 0, nMaxTextChars, nMinTextChars, dwButtonStyle);
  144.  
  145.     if(bResult)
  146.     {
  147.         SetNode(pNode);
  148.         m_nIconType = DetermineIconType(pNode, UseLargeIcons());
  149.  
  150.         m_nBitmapID = GetBitmapID();
  151.         m_nBitmapIndex = GetBitmapIndex();
  152.  
  153.         HDC hDC = ::GetDC(m_hWnd);
  154.  
  155.         HPALETTE hPalette = WFE_GetUIPalette(GetParentFrame());
  156.         HBITMAP hBitmap = WFE_LookupLoadAndEnterBitmap(hDC, m_nBitmapID, TRUE, hPalette,
  157.                                                        sysInfo.m_clrBtnFace, RGB(255, 0, 255));
  158.         ::ReleaseDC(m_hWnd, hDC);
  159.  
  160.         SetBitmap(hBitmap, TRUE);
  161.         
  162.         if (m_menu.m_hMenu == NULL || (m_menu.m_hMenu != NULL && !IsMenu(m_menu.m_hMenu)))
  163.           m_menu.CreatePopupMenu();
  164.     }
  165.  
  166.     return bResult;
  167. }
  168.  
  169. CSize CLinkToolbarButton::GetMinimalButtonSize(void)
  170. {
  171.     CString szText(HT_GetNodeName(m_Node));
  172.     return GetButtonSizeFromChars(szText, m_nMinTextChars);
  173. }
  174.  
  175. CSize CLinkToolbarButton::GetMaximalButtonSize(void)
  176. {
  177.     CString szText(HT_GetNodeName(m_Node));
  178.     return GetButtonSizeFromChars(szText, m_nMaxTextChars);
  179. }
  180.  
  181. void CLinkToolbarButton::OnAction(void)
  182. {
  183.     if(m_Node && !HT_IsContainer(m_Node))
  184.     {
  185.             CAbstractCX * pCX = FEU_GetLastActiveFrameContext();
  186.             ASSERT(pCX != NULL);
  187.             if (pCX != NULL)
  188.             {
  189.                 pCX->NormalGetUrl((LPTSTR)HT_GetNodeURL(m_Node));
  190.             }
  191.     }
  192. }
  193.  
  194. void CLinkToolbarButton::FillInOleDataSource(COleDataSource *pDataSource)
  195. {
  196.     CLIPFORMAT cfHTNode = (CLIPFORMAT)RegisterClipboardFormat(NETSCAPE_HTNODE_FORMAT);
  197.     HANDLE hString = GlobalAlloc(GMEM_MOVEABLE|GMEM_DDESHARE,1);
  198.     pDataSource->CacheGlobalData(cfHTNode, hString);
  199.  
  200.     // Need to "select" the button in the view.  Hack.
  201.     HT_SetSelection(m_Node);
  202.  
  203.     // Now the view is sufficient
  204.     RDFGLOBAL_BeginDrag(pDataSource, HT_GetView(m_Node));
  205.     
  206. }
  207.  
  208. BOOKMARKITEM CLinkToolbarButton::GetBookmarkItem(void)
  209. {
  210.     return m_bookmark;
  211. }
  212.  
  213. void CLinkToolbarButton::SetBookmarkItem(BOOKMARKITEM bookmark)
  214. {
  215. /*    m_bookmark = bookmark;
  216.     CString strText(bookmark.szText);
  217.     CToolbarButton::SetText(strText);
  218.     */
  219. }
  220.  
  221. void CLinkToolbarButton::SetNode(HT_Resource pNode, BOOL bAddRef)
  222. {
  223.     if (pNode == NULL)
  224.         return;
  225.  
  226.     m_Node = pNode;
  227.     
  228.     // if it's a header and we haven't already loaded the bitmaps, load the bitmaps
  229.     if(HT_IsContainer(pNode) && bAddRef)
  230.     {    
  231.         HDC hDC = ::GetDC(m_hWnd);
  232.  
  233.         HINSTANCE hInstance = AfxGetResourceHandle();
  234.         WFE_InitializeUIPalette(hDC);
  235.         HPALETTE hPalette = WFE_GetUIPalette(GetParentFrame());
  236.         if(nBitmapRefCount == 0)
  237.         {
  238.             m_hbmpBM = WFE_LoadTransparentBitmap(hInstance, hDC, sysInfo.m_clrMenu, RGB(255, 0, 255),
  239.                                                  hPalette, IDB_BOOKMARK_ITEM);
  240.             m_hbmpBMSelected = WFE_LoadTransparentBitmap(hInstance, hDC,sysInfo.m_clrHighlight,
  241.                                                          RGB(255, 0, 255), hPalette, IDB_BOOKMARK_ITEM);
  242.             m_hbmpFolder = WFE_LoadTransparentBitmap(hInstance, hDC,sysInfo.m_clrMenu, RGB(255, 0, 255),
  243.                                                      hPalette, IDB_BOOKMARK_FOLDER2);
  244.  
  245.             m_hbmpSelectedFolder = WFE_LoadTransparentBitmap(hInstance, hDC, sysInfo.m_clrHighlight, RGB(255, 0, 255),
  246.                                                      hPalette, IDB_BOOKMARK_FOLDER2);
  247.  
  248.             m_hbmpFolderOpen = WFE_LoadTransparentBitmap(hInstance, hDC, sysInfo.m_clrHighlight,
  249.                                                          RGB(255, 0, 255), hPalette, IDB_BOOKMARK_FOLDER_OPEN);
  250.         }
  251.         nBitmapRefCount++;
  252.  
  253.         ::ReleaseDC(m_hWnd, hDC);
  254.     }
  255.  
  256. }
  257.  
  258. void CLinkToolbarButton::EditTextChanged(char *pText)
  259. {
  260.     if (pText)
  261.     {
  262.         HT_SetNodeName(m_Node, pText);
  263.         SetText(pText);    
  264.         SetToolTipText(pText);
  265.         delete []pText;
  266.     }
  267.     RemoveTextEdit();
  268.  
  269.     ((CLinkToolbar*)GetParent())->LayoutButtons(-1);
  270. }
  271.  
  272. void CLinkToolbarButton::DrawPicturesAndTextMode(HDC hDC, CRect rect)
  273. {
  274.      DrawBitmapOnSide(hDC, rect);
  275. }
  276.  
  277. void CLinkToolbarButton::DrawPicturesMode(HDC hDC, CRect rect)
  278. {
  279.     DrawBitmapOnSide(hDC, rect);
  280. }
  281.  
  282. void CLinkToolbarButton::DrawButtonText(HDC hDC, CRect rcTxt, CSize sizeTxt, CString strTxt)
  283. {
  284.     CToolbarButton::DrawButtonText(hDC, rcTxt, sizeTxt, strTxt);
  285. }
  286.  
  287. CSize CLinkToolbarButton::GetButtonSizeFromChars(CString s, int c)
  288. {
  289.     if(m_nToolbarStyle != TB_TEXT)
  290.         return(GetBitmapOnSideSize(s, c));
  291.     else
  292.         return(GetTextOnlySize(s, c));
  293. }
  294.  
  295. void CLinkToolbarButton::GetPicturesAndTextModeTextRect(CRect &rect)
  296. {
  297.     GetBitmapOnSideTextRect(rect);
  298. }
  299.  
  300. void CLinkToolbarButton::GetPicturesModeTextRect(CRect &rect)
  301. {
  302.     GetBitmapOnSideTextRect(rect);
  303. }
  304.  
  305.  
  306. BOOL CLinkToolbarButton::CreateRightMouseMenu(void)
  307. {
  308.     if (m_bShouldShowRMMenu)
  309.     {
  310.         m_MenuCommandMap.Clear();
  311.         HT_SetSelection(m_Node); // Make sure the node is the selection in the view.
  312.         HT_View theView = HT_GetView(m_Node);
  313.         HT_Cursor theCursor = HT_NewContextualMenuCursor(theView, PR_FALSE, PR_FALSE);
  314.         if (theCursor != NULL)
  315.         {
  316.             // We have a cursor. Attempt to iterate
  317.             HT_MenuCmd theCommand; 
  318.             while (HT_NextContextMenuItem(theCursor, &theCommand))
  319.             {
  320.                 char* menuName = HT_GetMenuCmdName(theCommand);
  321.                 if (theCommand == HT_CMD_SEPARATOR)
  322.                     m_menu.AppendMenu(MF_SEPARATOR);
  323.                 else
  324.                 {
  325.                     // Add the command to our command map
  326.                     CRDFMenuCommand* rdfCommand = new CRDFMenuCommand(menuName, theCommand);
  327.                     int index = m_MenuCommandMap.AddCommand(rdfCommand);
  328.                     m_menu.AppendMenu(MF_ENABLED, index+FIRST_HT_MENU_ID, menuName);
  329.                 }
  330.             }
  331.             HT_DeleteCursor(theCursor);
  332.         }
  333.     }
  334.     return m_bShouldShowRMMenu;
  335. }
  336.  
  337. CWnd* CLinkToolbarButton::GetMenuParent(void)
  338. {
  339.     return this;
  340. }
  341.  
  342. BOOL CLinkToolbarButton::OnCommand(UINT wParam, LONG lParam)
  343. {
  344.     BOOL bRtn = TRUE;
  345.     
  346.     if (wParam >= FIRST_HT_MENU_ID && wParam <= LAST_HT_MENU_ID)
  347.     {
  348.         // A selection was made from the context menu.
  349.         // Use the menu map to get the HT command value
  350.         CRDFMenuCommand* theCommand = (CRDFMenuCommand*)(m_MenuCommandMap.GetCommand((int)wParam-FIRST_HT_MENU_ID));
  351.         if (theCommand)
  352.         {
  353.             HT_MenuCmd htCommand = theCommand->GetHTCommand();
  354.             HT_DoMenuCmd(HT_GetPane(GetHTView()), htCommand);
  355.         }
  356.  
  357.         return bRtn;
  358.     }
  359.  
  360.     if(wParam == ID_HOTLIST_VIEW || wParam == ID_HOTLIST_ADDCURRENTTOHOTLIST)
  361.     {
  362.         GetParentFrame()->SendMessage(WM_COMMAND, wParam, lParam);
  363.     }
  364.     else if(wParam == ID_DELETE_BUTTON)
  365.     {
  366.         HT_RemoveChild(HT_GetParent(m_Node), m_Node);
  367.     }
  368.     else if(wParam == ID_BUTTON_PROPERTIES)
  369.     {
  370.         // PROPERTIES
  371.     }
  372.     else if(wParam == ID_RENAME_BUTTON)
  373.     {
  374.         AddTextEdit();
  375.         SetTextEditText(m_pButtonText);
  376.     }
  377.     // Only interested in commands from bookmark quick file menu
  378.     else if ((wParam >= FIRST_BOOKMARK_MENU_ID))
  379.     {
  380.         void * pBookmark = NULL;
  381.         m_BMMenuMap.Lookup(wParam, pBookmark);
  382.         if (pBookmark != NULL)
  383.         {
  384.             HT_Resource theNode = (HT_Resource)pBookmark;
  385.             CAbstractCX *pCX = FEU_GetLastActiveFrameContext();
  386.             ASSERT(pCX != NULL);
  387.             if (pCX != NULL)
  388.             {
  389.                 pCX->NormalGetUrl((LPTSTR)HT_GetNodeURL(theNode));
  390.             }
  391.         }
  392.     }
  393.     else 
  394.     {
  395.         bRtn = CLinkToolbarButtonBase::OnCommand(wParam, lParam);
  396.     }
  397.     
  398.     return(bRtn);
  399.     
  400. } 
  401.  
  402. ///////////////////////////////////////////////////////////////////////////////////
  403. //                                    CLinkToolbarButton Messages
  404. ///////////////////////////////////////////////////////////////////////////////////
  405.  
  406. BEGIN_MESSAGE_MAP(CLinkToolbarButton, CLinkToolbarButtonBase)
  407.     //{{AFX_MSG_MAP(CLinkToolbarButton)
  408.     ON_MESSAGE(NSDRAGMENUOPEN, OnDragMenuOpen) 
  409.     ON_MESSAGE(DM_FILLINMENU, OnFillInMenu)
  410.     ON_MESSAGE(DT_DROPOCCURRED, OnDropMenuDropOccurred)
  411.     ON_MESSAGE(DT_DRAGGINGOCCURRED, OnDropMenuDraggingOccurred)
  412.     ON_MESSAGE(DM_MENUCLOSED, OnDropMenuClosed)
  413.     ON_WM_SYSCOLORCHANGE()
  414.     //}}AFX_MSG_MAP
  415.  
  416. END_MESSAGE_MAP()
  417.  
  418. LRESULT CLinkToolbarButton::OnDragMenuOpen(WPARAM wParam, LPARAM lParam)
  419. {
  420. // Set our drop menu's user data.
  421.     if (m_pDropMenu)
  422.         m_pDropMenu->SetUserData(m_Node);
  423.  
  424.     if(m_Node == NULL || !HT_IsContainer(m_Node))
  425.         return 1;
  426.     m_uCurBMID = FIRST_BOOKMARK_MENU_ID;
  427.  
  428.     m_pCachedDropMenu = (CDropMenu *)lParam;  // Set our drop menu
  429.     PRBool isOpen;
  430.  
  431.     HT_Resource theNode = (HT_Resource)m_pCachedDropMenu->GetUserData();
  432.     HT_GetOpenState(theNode, &isOpen);
  433.     if (isOpen)
  434.         FillInMenu(theNode);
  435.     else HT_SetOpenState(theNode, (PRBool)TRUE);
  436.  
  437.     return 1;
  438.  
  439. }
  440.  
  441. LRESULT CLinkToolbarButton::OnFillInMenu(WPARAM wParam, LPARAM lParam)
  442. {
  443. // Set our drop menu's user data.
  444.     if (m_pDropMenu)
  445.         m_pDropMenu->SetUserData(m_Node);
  446.  
  447.     m_pCachedDropMenu = (CDropMenu *)lParam;  // Set our drop menu
  448.     PRBool isOpen;
  449.     HT_Resource theNode = (HT_Resource)m_pCachedDropMenu->GetUserData();
  450.     HT_GetOpenState(theNode, &isOpen);
  451.     if (isOpen)
  452.         FillInMenu(theNode);
  453.     else HT_SetOpenState(theNode, (PRBool)TRUE);
  454.     
  455.     return 1;
  456. }
  457.  
  458. LRESULT CLinkToolbarButton::OnDropMenuDraggingOccurred(WPARAM wParam, LPARAM lParam)
  459. {
  460.     CDropMenuDragData* pData = (CDropMenuDragData*)lParam;
  461.     UINT nCommand = pData->m_nCommand;
  462.     MenuSelectionType eSelType = pData->eSelType;
  463.  
  464.     void * pBookmarkInsertAfter = NULL;
  465.     m_BMMenuMap.Lookup(nCommand, pBookmarkInsertAfter);
  466.     HT_Resource theNode = (HT_Resource)pBookmarkInsertAfter;
  467.  
  468.     int dragFraction = 2;
  469.     if (eSelType == eON)
  470.         dragFraction = 2;
  471.     else if (eSelType == eBELOW)
  472.         dragFraction = 3;
  473.     else if (eSelType == eABOVE)
  474.         dragFraction = 1;
  475.  
  476.     // Next we get the result.
  477.     DROPEFFECT answer = RDFGLOBAL_TranslateDropAction(theNode, pData->m_pDataSource, dragFraction);
  478.     
  479.     // Place the result into our data structure for the droptarget to use.
  480.     pData->m_DropEffect = answer;
  481.     
  482.     return 1;
  483.  
  484. }
  485.  
  486. LRESULT CLinkToolbarButton::OnDropMenuDropOccurred(WPARAM wParam, LPARAM lParam)
  487. {
  488.     CDropMenuDragData* pData = (CDropMenuDragData*)lParam;
  489.     UINT nCommand = pData->m_nCommand;
  490.     MenuSelectionType eSelType = pData->eSelType;
  491.  
  492.     void * pBookmarkInsertAfter = NULL;
  493.     m_BMMenuMap.Lookup(nCommand, pBookmarkInsertAfter);
  494.     HT_Resource theNode = (HT_Resource)pBookmarkInsertAfter;
  495.  
  496.     int dragFraction = 2;
  497.     if (eSelType == eON)
  498.         dragFraction = 2;
  499.     else if (eSelType == eBELOW)
  500.         dragFraction = 3;
  501.     else if (eSelType == eABOVE)
  502.         dragFraction = 1;
  503.  
  504.     RDFGLOBAL_PerformDrop(pData->m_pDataSource, theNode, dragFraction);
  505.     
  506.     delete pData; // Clean this structure up.
  507.  
  508.     return 1;
  509. }
  510.     
  511. LRESULT CLinkToolbarButton::OnDropMenuClosed(WPARAM wParam, LPARAM lParam)
  512. {
  513.     int nCount;
  514.     if(m_pDropMenu != NULL)
  515.     {
  516.         HT_Resource theNode = (HT_Resource)m_pDropMenu->GetUserData();
  517.         nCount = m_pDropMenu->GetMenuItemCount();
  518.  
  519.         // clean out the menu 
  520.         for(int i = nCount - 1; i >= 0; i--)
  521.         {
  522.             m_pDropMenu->DeleteMenu(i, MF_BYPOSITION);
  523.         }
  524.         m_pDropMenu->DestroyDropMenu();
  525.         delete m_pDropMenu;
  526.         m_pDropMenu = NULL;
  527.  
  528.         if (theNode != NULL)
  529.             HT_SetOpenState(theNode, (PRBool)FALSE);
  530.     }
  531.     
  532.     return 1;
  533. }
  534.  
  535. void CLinkToolbarButton::OnSysColorChange( )
  536. {
  537.     if(nBitmapRefCount > 0)
  538.     {
  539.         VERIFY(::DeleteObject(m_hbmpBM));
  540.         VERIFY(::DeleteObject(m_hbmpBMSelected));
  541.         VERIFY(::DeleteObject(m_hbmpFolder));
  542.         VERIFY(::DeleteObject(m_hbmpSelectedFolder));
  543.         VERIFY(::DeleteObject(m_hbmpFolderOpen));
  544.         
  545.         HINSTANCE hInstance = AfxGetResourceHandle();
  546.         HDC hDC = ::GetDC(m_hWnd);
  547.         WFE_InitializeUIPalette(hDC);
  548.         HPALETTE hPalette = WFE_GetUIPalette(GetParentFrame());
  549.  
  550.         m_hbmpBM = WFE_LoadTransparentBitmap(hInstance, hDC, sysInfo.m_clrMenu, RGB(255, 0, 255),
  551.                                              hPalette, IDB_BOOKMARK_ITEM);
  552.         m_hbmpBMSelected = WFE_LoadTransparentBitmap(hInstance, hDC,sysInfo.m_clrHighlight,
  553.                                                      RGB(255, 0, 255), hPalette, IDB_BOOKMARK_ITEM);
  554.         m_hbmpFolder = WFE_LoadTransparentBitmap(hInstance, hDC,sysInfo.m_clrMenu, RGB(255, 0, 255),
  555.                                                  hPalette, IDB_BOOKMARK_FOLDER2);
  556.  
  557.         m_hbmpSelectedFolder = WFE_LoadTransparentBitmap(hInstance, hDC,sysInfo.m_clrHighlight, RGB(255, 0, 255),
  558.                                                  hPalette, IDB_BOOKMARK_FOLDER2);
  559.  
  560.         m_hbmpFolderOpen = WFE_LoadTransparentBitmap(hInstance, hDC, sysInfo.m_clrHighlight,
  561.                                                          RGB(255, 0, 255), hPalette, IDB_BOOKMARK_FOLDER_OPEN);
  562.  
  563.         ::ReleaseDC(m_hWnd, hDC);
  564.     }
  565.  
  566.     if(m_bBitmapFromParent)
  567.     {
  568.         HDC hDC = ::GetDC(m_hWnd);
  569.  
  570.         HPALETTE hPalette = WFE_GetUIPalette(GetParentFrame());
  571.  
  572.         HBITMAP hBitmap = WFE_LookupLoadAndEnterBitmap(hDC, m_nBitmapID, TRUE, hPalette,
  573.                                                        sysInfo.m_clrBtnFace, RGB(255, 0, 255));
  574.         ::ReleaseDC(m_hWnd, hDC);
  575.         SetBitmap(hBitmap, TRUE);
  576.     }
  577.     CToolbarButton::OnSysColorChange();
  578. }
  579.  
  580. ///////////////////////////////////////////////////////////////////////////
  581. //                            CLinkToolbarButton Helpers
  582. ///////////////////////////////////////////////////////////////////////////
  583.  
  584. void CLinkToolbarButton::FillInMenu(HT_Resource theNode)
  585. {
  586.     m_pCachedDropMenu->CreateOverflowMenuItem(ID_HOTLIST_VIEW, CString(szLoadString(IDS_MORE_BOOKMARKS)), NULL, NULL );
  587.  
  588.     HT_Cursor theCursor = HT_NewCursor(theNode);
  589.     HT_Resource theItem = NULL;
  590.     while (theItem = HT_GetNextItem(theCursor))
  591.     {
  592.         IconType nIconType = DetermineIconType(theItem, FALSE);
  593.         void* pCustomIcon = NULL;
  594.         if (nIconType == LOCAL_FILE)
  595.             pCustomIcon = FetchLocalFileIcon(theItem);
  596.         else if (nIconType == ARBITRARY_URL)
  597.             pCustomIcon = FetchCustomIcon(theItem, this, FALSE);
  598.  
  599.         HT_SetNodeFEData(theItem, this);
  600.  
  601.         if (HT_IsContainer(theItem))
  602.         {
  603.             CDropMenu *pSubMenu = new CDropMenu;
  604.             pSubMenu->SetUserData(theItem);
  605.  
  606.             CString csAmpersandString = FEU_EscapeAmpersand(HT_GetNodeName(theItem));
  607.  
  608.             m_pCachedDropMenu->AppendMenu(MF_POPUP, m_uCurBMID, pSubMenu, FALSE, 
  609.                 csAmpersandString, TRUE, m_hbmpFolder, m_hbmpFolderOpen, pCustomIcon, nIconType);
  610.             
  611.             m_BMMenuMap.SetAt(m_uCurBMID, theItem);
  612.             m_uCurBMID++;
  613.         }
  614.         else if (!HT_IsSeparator(theItem))
  615.         {
  616.             CString csAmpersandString = FEU_EscapeAmpersand(HT_GetNodeName(theItem));
  617.             m_pCachedDropMenu->AppendMenu(MF_STRING, m_uCurBMID, csAmpersandString, TRUE, 
  618.                 m_hbmpBM, m_hbmpBMSelected, pCustomIcon, nIconType);
  619.             m_BMMenuMap.SetAt(m_uCurBMID, theItem);
  620.             m_uCurBMID++;
  621.         }
  622.         else
  623.         {
  624.             m_pCachedDropMenu->AppendMenu(MF_SEPARATOR, 0, TRUE, NULL, NULL);
  625.         }
  626.     }
  627.     
  628.     HT_DeleteCursor(theCursor);
  629.     m_pCachedDropMenu = NULL;
  630. }
  631.  
  632. UINT CLinkToolbarButton::GetBitmapID(void)
  633. {
  634.     if (m_nBitmapID != 0)
  635.         return m_nBitmapID;
  636.  
  637.     if (m_Node && HT_IsContainer(m_Node))
  638.         return IDB_BUTTON_FOLDER;
  639.     else return IDB_USERBTN;
  640. }
  641.  
  642. UINT CLinkToolbarButton::GetBitmapIndex(void)
  643. {
  644.     return 0;
  645. }
  646.  
  647. void CLinkToolbarButton::SetTextWithoutResize(CString text)
  648. {
  649.     if(m_pButtonText != NULL)
  650.     {
  651.         XP_FREE(m_pButtonText);
  652.     }
  653.  
  654.     m_pButtonText = (LPTSTR)XP_ALLOC(text.GetLength() +1);
  655.     XP_STRCPY(m_pButtonText, text);
  656. }
  657.  
  658. void CLinkToolbarButton::LoadComplete(HT_Resource r)
  659. {
  660.     Invalidate();
  661. }
  662.  
  663. void CLinkToolbarButton::DrawCustomIcon(HDC hDC, int x, int y)
  664. {
  665.     int size = UseLargeIcons() ? 23 : 16;
  666.     DrawArbitraryURL(m_Node, x, y, size, size, hDC, 
  667.                     m_bDepressed ? (::GetSysColor(COLOR_BTNSHADOW)) :  (::GetSysColor(COLOR_BTNFACE)), 
  668.                      this, UseLargeIcons());
  669. }
  670.  
  671.  
  672. void CLinkToolbarButton::DrawLocalIcon(HDC hDC, int x, int y)
  673. {
  674.     if (m_Node)
  675.         DrawLocalFileIcon(m_Node, x, y, hDC);
  676. }
  677.  
  678.  
  679. ///////////////////////////////////////////////////////////////////////////
  680. //                            Class CLinkToolbarDropTarget
  681. ///////////////////////////////////////////////////////////////////////////
  682.  
  683. void CLinkToolbarDropTarget::Toolbar(CLinkToolbar *pToolbar)
  684. {
  685.     m_pToolbar = pToolbar;
  686. }
  687.  
  688. DROPEFFECT CLinkToolbarDropTarget::OnDragEnter(CWnd * pWnd,    COleDataObject * pDataObject,
  689.                                                DWORD dwKeyState, CPoint point)
  690. {
  691.     return OnDragOver(pWnd, pDataObject, dwKeyState, point);    
  692. }
  693.  
  694. DROPEFFECT CLinkToolbarDropTarget::OnDragOver(CWnd * pWnd, COleDataObject * pDataObject,
  695.                                               DWORD dwKeyState, CPoint point )
  696. {
  697.     int nStartX = 0;
  698.  
  699.     RECT buttonRect;
  700.  
  701.     int currentRow = 0;
  702.  
  703.     CLinkToolbarButton* pButton = NULL;
  704.  
  705.     for(int i = 0; i < m_pToolbar->GetNumButtons(); i++)
  706.     {
  707.         pButton = (CLinkToolbarButton*)(m_pToolbar->GetNthButton(i));
  708.         pButton->GetClientRect(&buttonRect);
  709.         pButton->MapWindowPoints(m_pToolbar, &buttonRect);
  710.         
  711.         nStartX += (buttonRect.right - buttonRect.left) + SPACE_BETWEEN_BUTTONS;
  712.         if (currentRow != pButton->GetRow())
  713.         {
  714.             currentRow++;
  715.             nStartX = LEFT_TOOLBAR_MARGIN + (buttonRect.right - buttonRect.left) + SPACE_BETWEEN_BUTTONS;
  716.         }
  717.  
  718.         if(point.x < nStartX && (point.y >= buttonRect.top && point.y <= buttonRect.bottom))
  719.            break;
  720.  
  721.         pButton = NULL;
  722.     }
  723.     
  724.     HT_Resource theNode = pButton ? pButton->GetNode() : HT_TopNode(HT_GetSelectedView(m_pToolbar->GetPane()));
  725.     
  726.     m_pToolbar->SetDragButton(pButton);
  727.  
  728.     if (pButton == NULL)
  729.         m_pToolbar->SetDragFraction(2);
  730.     else 
  731.     {
  732.         // Do the whole computation of drag fraction.  Cache our drag fraction and button.
  733.         CRect rect;
  734.         pButton->GetClientRect(&rect);
  735.         if (HT_IsContainer(pButton->GetNode()))
  736.         {
  737.             if (point.x <= rect.Width()/3)
  738.                 m_pToolbar->SetDragFraction(1);
  739.             else if (point.x <= 2*(rect.Width()/3))
  740.                 m_pToolbar->SetDragFraction(2);
  741.             else m_pToolbar->SetDragFraction(3);
  742.         }
  743.         else if (point.x <= rect.Width()/2)
  744.             m_pToolbar->SetDragFraction(1);
  745.         else m_pToolbar->SetDragFraction(2);
  746.     }
  747.  
  748.     return RDFGLOBAL_TranslateDropAction(theNode, pDataObject, m_pToolbar->GetDragFraction());
  749. }
  750.  
  751. BOOL CLinkToolbarDropTarget::OnDrop(CWnd * pWnd, COleDataObject * pDataObject,
  752.             DROPEFFECT dropEffect, CPoint point)
  753. {
  754.     HT_Resource theNode = HT_TopNode(HT_GetSelectedView(m_pToolbar->GetPane()));
  755.     if (m_pToolbar->GetDragButton())
  756.       theNode = m_pToolbar->GetDragButton()->GetNode();
  757.  
  758.     RDFGLOBAL_PerformDrop(pDataObject, theNode, m_pToolbar->GetDragFraction());
  759.     
  760.     return TRUE;
  761. }
  762.  
  763. // End CLinkToolbarDropTarget implementation
  764.  
  765. ///////////////////////////////////////////////////////////////////////////
  766. //                            Class CLinkToolbar
  767. ///////////////////////////////////////////////////////////////////////////
  768. #define LINKTOOLBARHEIGHT 21
  769. #define SPACE_BETWEEN_ROWS 2
  770.  
  771. // The Event Handler for HT notifications on the personal toolbar
  772. static void ptNotifyProcedure (HT_Notification ns, HT_Resource n, HT_Event whatHappened) 
  773. {
  774.   CLinkToolbar* theToolbar = (CLinkToolbar*)ns->data;
  775.   if (n != NULL)
  776.   {
  777.     HT_View theView = HT_GetView(n);
  778.     if (theView != NULL)
  779.     {
  780.         if (whatHappened == HT_EVENT_NODE_OPENCLOSE_CHANGED)
  781.         {
  782.             PRBool openState;
  783.             HT_GetOpenState(n, &openState);
  784.             if (openState)
  785.             {
  786.                 if (n == HT_TopNode(theView))
  787.                 {
  788.                     // Initial population of the toolbar. We should only receive this event once.
  789.                     theToolbar->FillInToolbar();
  790.                 }
  791.                 else 
  792.                 {
  793.                     // Toolbar button menu.  Populate it.
  794.                     CLinkToolbarButton* theButton = (CLinkToolbarButton*)(HT_GetNodeFEData(n));
  795.                     theButton->FillInMenu(n);
  796.                 }
  797.             }
  798.         }
  799.         else if (whatHappened == HT_EVENT_VIEW_REFRESH)
  800.         {
  801.             theToolbar->LayoutButtons(-1);
  802.         }
  803.         else if (HT_TopNode(theView) == HT_GetParent(n))
  804.         {
  805.             // Aside from the opening/closing, we only respond to events that occurred on the top node of
  806.             // the view or the immediate children (the buttons on the toolbar).
  807.             if (whatHappened == HT_EVENT_NODE_DELETED_DATA ||
  808.                  whatHappened == HT_EVENT_NODE_DELETED_NODATA)
  809.             {
  810.                 // Delete the button
  811.                 if (HT_EVENT_NODE_DELETED_DATA == whatHappened)
  812.                 {
  813.                     // Destroy the toolbar button
  814.                     CLinkToolbarButton* pButton = (CLinkToolbarButton*)HT_GetNodeFEData(n);
  815.                     if (theToolbar->m_hWnd)
  816.                       theToolbar->RemoveButton(pButton);
  817.                     else theToolbar->DecrementButtonCount();
  818.                     delete pButton;
  819.  
  820.                 }
  821.             }
  822.             else if (whatHappened == HT_EVENT_NODE_ADDED)
  823.             {
  824.                 theToolbar->AddHTButton(n);
  825.                 theToolbar->LayoutButtons(-1);
  826.             }
  827.             else if (whatHappened == HT_EVENT_NODE_VPROP_CHANGED)
  828.             {
  829.                 CLinkToolbarButton* pButton = (CLinkToolbarButton*)HT_GetNodeFEData(n);
  830.                 pButton->SetText(HT_GetNodeName(n)); // Update our name.
  831.                 theToolbar->LayoutButtons(-1);
  832.             }
  833.         }
  834.     }
  835.   }
  836. }
  837.  
  838. CLinkToolbar::CLinkToolbar(int nMaxButtons, int nToolbarStyle, int nPicturesAndTextHeight, int nPicturesHeight,
  839.                            int nTextHeight)
  840.      : CNSToolbar2(nMaxButtons, nToolbarStyle, nPicturesAndTextHeight, nPicturesHeight, nTextHeight)
  841. {
  842.     m_nNumberOfRows = 1;
  843.     
  844.     // Construct the notification struct used by HT
  845.     HT_Notification ns = new HT_NotificationStruct;
  846.     ns->notifyProc = ptNotifyProcedure;
  847.     ns->data = this;
  848.     
  849.     // Construct the pane and give it our notification struct
  850.     m_PersonalToolbarPane = HT_NewPersonalToolbarPane(ns);
  851.     if (m_PersonalToolbarPane)
  852.         HT_SetPaneFEData(m_PersonalToolbarPane, this);
  853. }
  854.  
  855. CLinkToolbar* CLinkToolbar::CreateUserToolbar(CWnd* pParent)
  856. {
  857.     // read in the maximum size we're allowing for personal toolbar items
  858.     int32 nMaxToolbarButtonChars;
  859.     int32 nMinToolbarButtonChars;
  860.  
  861.     if(PREF_GetIntPref("browser.personal_toolbar_button.max_chars", &nMaxToolbarButtonChars) ==
  862.         PREF_ERROR)
  863.         m_nMaxToolbarButtonChars = 30;
  864.     else
  865.         m_nMaxToolbarButtonChars = CASTINT(nMaxToolbarButtonChars);
  866.  
  867.     if(PREF_GetIntPref("browser.personal_toolbar_button.min_chars", &nMinToolbarButtonChars) ==
  868.         PREF_ERROR)
  869.         m_nMinToolbarButtonChars = 15;
  870.     else
  871.         m_nMinToolbarButtonChars = CASTINT(nMinToolbarButtonChars);
  872.  
  873.     CLinkToolbar* pToolbar = new CLinkToolbar(MAX_TOOLBAR_BUTTONS,theApp.m_pToolbarStyle, 43, 27, 27);
  874.  
  875.     if (pToolbar->Create(pParent))
  876.     {
  877.         pToolbar->SetButtonsSameWidth(FALSE);
  878.  
  879.         // Top node is already open.  Fill it in.
  880.         pToolbar->FillInToolbar();
  881.     }
  882.  
  883.     return pToolbar;
  884. }
  885.  
  886. CLinkToolbar::~CLinkToolbar()
  887. {
  888.     if (m_PersonalToolbarPane)
  889.     {
  890.         HT_Pane oldPane = m_PersonalToolbarPane;
  891.         m_PersonalToolbarPane = NULL;
  892.         HT_DeletePane(oldPane);
  893.     }
  894. }
  895.  
  896. int CLinkToolbar::Create(CWnd *pParent)
  897. {
  898.  
  899.     int result = CNSToolbar2::Create(pParent);
  900.  
  901.     if(!result)
  902.         return FALSE;
  903.  
  904.     m_DropTarget.Register(this);
  905.     m_DropTarget.Toolbar(this);
  906.  
  907.     DragAcceptFiles(FALSE);
  908.  
  909.     return result;
  910. }
  911.  
  912. void CLinkToolbar::FillInToolbar()
  913. {
  914.     if (!m_PersonalToolbarPane)
  915.         return;
  916.  
  917.     HT_View theView = HT_GetSelectedView(m_PersonalToolbarPane);
  918.     if (theView == NULL)
  919.         return;
  920.  
  921.     HT_Resource top = HT_TopNode(theView);
  922.     HT_Cursor cursor = HT_NewCursor(top);
  923.     if (cursor == NULL)
  924.         return;
  925.  
  926.     HT_Resource item = NULL;
  927.     while (item = HT_GetNextItem(cursor))
  928.         AddHTButton(item);
  929.  
  930.     HT_DeleteCursor(cursor);
  931.  
  932.     LayoutButtons(-1);
  933. }
  934.  
  935. void CLinkToolbar::AddHTButton(HT_Resource item)
  936. {
  937.     if (HT_IsSeparator(item))
  938.         return;
  939.  
  940.     CLinkToolbarButton* pButton = new CLinkToolbarButton;
  941.     BOOKMARKITEM bookmark;
  942.  
  943.     XP_STRCPY(bookmark.szText, HT_GetNodeName(item));
  944.     XP_STRCPY(bookmark.szAnchor, HT_GetNodeURL(item));
  945.  
  946.     CString csAmpersandString = FEU_EscapeAmpersand(CString(bookmark.szText));
  947.  
  948.     pButton->Create(this, theApp.m_pToolbarStyle, CSize(60,42), CSize(85, 25), csAmpersandString,
  949.                     bookmark.szText, bookmark.szAnchor, CSize(23,17), 
  950.                     m_nMaxToolbarButtonChars, m_nMinToolbarButtonChars, bookmark,
  951.                     item,
  952.                     (HT_IsContainer(item) ? TB_HAS_DRAGABLE_MENU | TB_HAS_IMMEDIATE_MENU : 0));
  953.         
  954.     if(HT_IsContainer(item))
  955.     {
  956.         CLinkToolbarButtonDropTarget *pDropTarget = new CLinkToolbarButtonDropTarget;
  957.         pButton->SetDropTarget(pDropTarget);
  958.     }
  959.  
  960.     HT_SetNodeFEData(item, pButton);
  961.  
  962.     AddButtonAtIndex(pButton); // Have to put the button in the array, since the toolbar base class depends on it.
  963. }
  964.  
  965. int CLinkToolbar::GetHeight(void)
  966. {
  967.     return m_nNumberOfRows * (LINKTOOLBARHEIGHT + SPACE_BETWEEN_ROWS) + SPACE_BETWEEN_ROWS;
  968. }
  969.  
  970.  
  971.  
  972. void CLinkToolbar::SetMinimumRows(int rowWidth)
  973. {
  974.     int rowCount = 1;
  975.     int totalLine = 0;
  976.     int rowSpace = rowWidth - RIGHT_TOOLBAR_MARGIN - LEFT_TOOLBAR_MARGIN;
  977.  
  978.     if (rowSpace <= 0)
  979.     {
  980.         SetRows(rowCount);
  981.         return;
  982.     }
  983.  
  984.     HT_Cursor cursor = HT_NewCursor(HT_TopNode(HT_GetSelectedView(m_PersonalToolbarPane)));
  985.     if (!cursor)
  986.         return;
  987.     HT_Resource item;
  988.     while (rowCount < MAX_TOOLBAR_ROWS && (item = HT_GetNextItem(cursor)))
  989.     {
  990.         // Get the current button
  991.         CLinkToolbarButton* pButton = (CLinkToolbarButton*)(HT_GetNodeFEData(item));
  992.         if (!pButton) // Separator
  993.             continue;
  994.  
  995.         CSize s = pButton->GetMinimalButtonSize();
  996.         int tempTotal = totalLine + s.cx;
  997.         if (tempTotal > rowSpace)
  998.         {
  999.             rowCount++;
  1000.             totalLine = s.cx;
  1001.         }
  1002.         else totalLine = tempTotal;
  1003.  
  1004.         totalLine += SPACE_BETWEEN_BUTTONS;
  1005.     }
  1006.     HT_DeleteCursor(cursor);
  1007.  
  1008.     SetRows(rowCount); 
  1009. }
  1010.     
  1011. void CLinkToolbar::ComputeLayoutInfo(CLinkToolbarButton* pButton, int numChars, int rowWidth, int& usedSpace)
  1012. {
  1013.    CString originalText = HT_GetNodeName(pButton->GetNode());
  1014.  
  1015.    int currCount = originalText.GetLength();
  1016.         
  1017.    // Start off at the maximal string
  1018.    CString strTxt = originalText;
  1019.  
  1020.    if (currCount > numChars)
  1021.    {
  1022.        strTxt = originalText.Left(numChars-3) + "...";
  1023.    }
  1024.    
  1025.    pButton->SetTextWithoutResize(strTxt);
  1026.    pButton->SetButtonSize(pButton->GetButtonSizeFromChars(strTxt, numChars));
  1027.  
  1028. // Determine how much additional padding we'll use to fill out a row if this button doesn't fit.
  1029.     int rowUsage = usedSpace % rowWidth;
  1030.     if (rowUsage == 0)
  1031.         rowUsage = rowWidth;
  1032.     int additionalPadding = rowWidth - rowUsage;
  1033.         
  1034.     int tempTotal = rowUsage + pButton->GetButtonSize().cx;
  1035.  
  1036. // The button doesn't fit.  Flesh out this row and start a new one.    
  1037.     if (tempTotal > rowWidth)
  1038.       usedSpace += additionalPadding;
  1039.     
  1040. // Add this button to the row.
  1041.     usedSpace += pButton->GetButtonSize().cx + SPACE_BETWEEN_BUTTONS;
  1042.  
  1043. // Set this button's row information, so it knows which row it is currently residing on.
  1044.     int currentRow = usedSpace/rowWidth;
  1045.     if (usedSpace % rowWidth == 0)
  1046.         currentRow--;
  1047.  
  1048.     pButton->SetRow(currentRow);
  1049.  
  1050. }
  1051.  
  1052. void CLinkToolbar::LayoutButtons(int nIndex)
  1053. {
  1054.     int width = m_nWidth;
  1055.  
  1056.     if (width <= 0)
  1057.     {
  1058.         CRect rect;
  1059.         GetParentFrame()->GetClientRect(&rect);
  1060.         width = rect.Width();
  1061.     }
  1062.     
  1063.     int numButtonsAtMin = 0;
  1064.     int numButtonsAtMax = 0;
  1065.     int idealSpace = 0;
  1066.    
  1067. // First quickly determine what the minimum # of rows we consume is.  This is our allowed space.
  1068.     int oldRows = GetRows();
  1069.  
  1070.     int rowWidth = width-RIGHT_TOOLBAR_MARGIN-LEFT_TOOLBAR_MARGIN;
  1071.     
  1072.     if (rowWidth <= 0 && m_nWidth > 0)
  1073.         rowWidth = m_nWidth - RIGHT_TOOLBAR_MARGIN - LEFT_TOOLBAR_MARGIN;
  1074.  
  1075.     SetMinimumRows(rowWidth);
  1076.  
  1077.     int newRows = GetRows();
  1078.  
  1079.     int allowedSpace = rowWidth * GetRows(); // Toolbar width * numRows
  1080.     int usedSpace = 0;
  1081.  
  1082.     int numChars = 0; // Start off trying to fit the whole thing on the toolbar.
  1083.     int minChars = 0;
  1084.     
  1085.     HT_Cursor cursor = HT_NewCursor(HT_TopNode(HT_GetSelectedView(m_PersonalToolbarPane)));
  1086.     if (!cursor)
  1087.         return;
  1088.     HT_Resource item;
  1089.     while ((item = HT_GetNextItem(cursor)))
  1090.     {
  1091.         // Get the current button
  1092.         CLinkToolbarButton* pButton = (CLinkToolbarButton*)(HT_GetNodeFEData(item));
  1093.         if (!pButton)
  1094.             continue;
  1095.  
  1096.         if (numChars == 0)
  1097.         {
  1098.             numChars = pButton->GetMaxTextCharacters();
  1099.             minChars = pButton->GetMinTextCharacters();
  1100.         }
  1101.  
  1102.         // See how much this num chars takes up
  1103.         ComputeLayoutInfo(pButton, numChars, rowWidth, usedSpace);
  1104.     }
  1105.     HT_DeleteCursor(cursor);
  1106.  
  1107.     while (usedSpace > allowedSpace && numChars > minChars)
  1108.     {
  1109.         usedSpace = 0;
  1110.         numChars--;
  1111.         // Let's see what we can fit.
  1112.         HT_Cursor cursor = HT_NewCursor(HT_TopNode(HT_GetSelectedView(m_PersonalToolbarPane)));
  1113.         if (!cursor)
  1114.             return;
  1115.         HT_Resource item;
  1116.         while ((item = HT_GetNextItem(cursor)))
  1117.         {
  1118.             // Get the current button
  1119.             CLinkToolbarButton* pButton = (CLinkToolbarButton*)(HT_GetNodeFEData(item));
  1120.             if (!pButton)  // Separator
  1121.                 continue;
  1122.  
  1123.             // See how much this num chars takes up
  1124.             ComputeLayoutInfo(pButton, numChars, rowWidth, usedSpace);
  1125.         }
  1126.         HT_DeleteCursor(cursor);
  1127.     }
  1128.  
  1129.     // That's it.  lay them out with this number of characters.
  1130.     
  1131.     int nStartX = LEFT_TOOLBAR_MARGIN;
  1132.     int nStartY = SPACE_BETWEEN_ROWS;
  1133.  
  1134.     int row = 0;
  1135.  
  1136.     CSize buttonSize;
  1137.     CString strTxt;
  1138.  
  1139.     cursor = HT_NewCursor(HT_TopNode(HT_GetSelectedView(m_PersonalToolbarPane)));
  1140.     if (!cursor)
  1141.         return;
  1142.     while ((item = HT_GetNextItem(cursor)))
  1143.     {
  1144.         // Get the current button
  1145.         CLinkToolbarButton* pButton = (CLinkToolbarButton*)(HT_GetNodeFEData(item));
  1146.         if (!pButton)  // Separator
  1147.             continue;
  1148.  
  1149.         buttonSize = pButton->GetButtonSize();  // The size we must be
  1150.         
  1151.         int tempTotal = nStartX + buttonSize.cx;
  1152.         if (tempTotal > (width - RIGHT_TOOLBAR_MARGIN))
  1153.         {
  1154.             nStartX = LEFT_TOOLBAR_MARGIN;
  1155.             nStartY += LINKTOOLBARHEIGHT + SPACE_BETWEEN_ROWS;
  1156.         }
  1157.  
  1158.         pButton->MoveWindow(nStartX, nStartY,
  1159.                                       buttonSize.cx, buttonSize.cy);
  1160.  
  1161.         nStartX += buttonSize.cx + SPACE_BETWEEN_BUTTONS;
  1162.     }
  1163.     HT_DeleteCursor(cursor);
  1164.  
  1165.     //record the width of our toolbar
  1166.     //if (nStartY == SPACE_BETWEEN_ROWS && nStartX < (width - RIGHT_TOOLBAR_MARGIN))
  1167.     //  m_nWidth = nStartX;
  1168.     //else 
  1169.        m_nWidth = width;
  1170.  
  1171.     if (oldRows != newRows)
  1172.         GetParentFrame()->RecalcLayout();    
  1173. }
  1174.  
  1175. void CLinkToolbar::WidthChanged(int animWidth)
  1176. {
  1177.     CRect rect;
  1178.    
  1179.     GetParentFrame()->GetClientRect(&rect);
  1180.     int width = rect.Width() - animWidth;
  1181.     
  1182.     int numButtonsAtMin = 0;
  1183.     int numButtonsAtMax = 0;
  1184.     int idealSpace = 0;
  1185.    
  1186. // First quickly determine what the minimum # of rows we consume is.  This is our allowed space.
  1187.     int oldRows = GetRows();
  1188.  
  1189.     int rowWidth = width-RIGHT_TOOLBAR_MARGIN-LEFT_TOOLBAR_MARGIN;
  1190.     
  1191.     if (rowWidth <= 0 && m_nWidth > 0)
  1192.         rowWidth = m_nWidth - RIGHT_TOOLBAR_MARGIN - LEFT_TOOLBAR_MARGIN;
  1193.  
  1194.     SetMinimumRows(rowWidth);
  1195.  
  1196.     int newRows = GetRows();
  1197.  
  1198.     int allowedSpace = rowWidth * GetRows(); // Toolbar width * numRows
  1199.     int usedSpace = 0;
  1200.  
  1201.     int numChars = 0; // Start off trying to fit the whole thing on the toolbar.
  1202.     int minChars = 0;
  1203.     HT_Cursor cursor = HT_NewCursor(HT_TopNode(HT_GetSelectedView(m_PersonalToolbarPane)));
  1204.     if (!cursor)
  1205.         return;
  1206.     HT_Resource item;
  1207.     while ((item = HT_GetNextItem(cursor)))
  1208.     {
  1209.         // Get the current button
  1210.         CLinkToolbarButton* pButton = (CLinkToolbarButton*)(HT_GetNodeFEData(item));
  1211.         if (!pButton)  // Separator
  1212.             continue;
  1213.  
  1214.         if (numChars == 0)
  1215.         {
  1216.             numChars = pButton->GetMaxTextCharacters();
  1217.             minChars = pButton->GetMinTextCharacters();
  1218.         }
  1219.  
  1220.         // See how much this num chars takes up
  1221.         ComputeLayoutInfo(pButton, numChars, rowWidth, usedSpace);
  1222.     }
  1223.     HT_DeleteCursor(cursor);
  1224.  
  1225.     while (usedSpace > allowedSpace && numChars > minChars)
  1226.     {
  1227.         usedSpace = 0;
  1228.         numChars--;
  1229.         // Let's see what we can fit.
  1230.         HT_Cursor cursor = HT_NewCursor(HT_TopNode(HT_GetSelectedView(m_PersonalToolbarPane)));
  1231.         if (!cursor)
  1232.             return;
  1233.         HT_Resource item;
  1234.         while ((item = HT_GetNextItem(cursor)))
  1235.         {
  1236.             // Get the current button
  1237.             CLinkToolbarButton* pButton = (CLinkToolbarButton*)(HT_GetNodeFEData(item));
  1238.             if (!pButton)
  1239.                 continue;
  1240.  
  1241.             // See how much this num chars takes up
  1242.             ComputeLayoutInfo(pButton, numChars, rowWidth, usedSpace);
  1243.         }
  1244.         HT_DeleteCursor(cursor);
  1245.     }
  1246.  
  1247.     // That's it.  lay them out with this number of characters.
  1248.     
  1249.     int nStartX = LEFT_TOOLBAR_MARGIN;
  1250.     int nStartY = SPACE_BETWEEN_ROWS;
  1251.  
  1252.     int row = 0;
  1253.  
  1254.     CSize buttonSize;
  1255.     CString strTxt;
  1256.  
  1257.     cursor = HT_NewCursor(HT_TopNode(HT_GetSelectedView(m_PersonalToolbarPane)));
  1258.     if (!cursor)
  1259.         return;
  1260.     
  1261.     while ((item = HT_GetNextItem(cursor)))
  1262.     {
  1263.         // Get the current button
  1264.         CLinkToolbarButton* pButton = (CLinkToolbarButton*)(HT_GetNodeFEData(item));
  1265.         if (!pButton)
  1266.             continue;
  1267.  
  1268.         buttonSize = pButton->GetButtonSize();  // The size we must be
  1269.         
  1270.         int tempTotal = nStartX + buttonSize.cx;
  1271.         if (tempTotal > (width - RIGHT_TOOLBAR_MARGIN))
  1272.         {
  1273.             nStartX = LEFT_TOOLBAR_MARGIN;
  1274.             nStartY += LINKTOOLBARHEIGHT + SPACE_BETWEEN_ROWS;
  1275.         }
  1276.  
  1277.         pButton->MoveWindow(nStartX, nStartY,
  1278.                                       buttonSize.cx, buttonSize.cy);
  1279.  
  1280.         nStartX += buttonSize.cx + SPACE_BETWEEN_BUTTONS;
  1281.     }
  1282.     HT_DeleteCursor(cursor);
  1283.  
  1284.  
  1285.     m_nWidth = width;
  1286.  
  1287.     if (oldRows != newRows)
  1288.         GetParentFrame()->RecalcLayout();
  1289. }
  1290.  
  1291.  
  1292.  
  1293. ///////////////////////////////////////////////////////////////////////////////////
  1294. //                                    CLinkToolbar Messages
  1295. ///////////////////////////////////////////////////////////////////////////////////
  1296.  
  1297. BEGIN_MESSAGE_MAP(CLinkToolbar, CNSToolbar2)
  1298.     //{{AFX_MSG_MAP(CNSToolbar2)
  1299.     ON_WM_RBUTTONDOWN()
  1300.     //}}AFX_MSG_MAP
  1301.  
  1302. END_MESSAGE_MAP()
  1303.  
  1304. void CLinkToolbar::OnRButtonDown(UINT nFlags, CPoint point)
  1305. {
  1306.     m_MenuCommandMap.Clear();
  1307.     HT_View theView = HT_GetSelectedView(m_PersonalToolbarPane);
  1308.     HT_Cursor theCursor = HT_NewContextualMenuCursor(theView, PR_FALSE, PR_TRUE);
  1309.     CMenu menu;
  1310.     ClientToScreen(&point);
  1311.     if (menu.CreatePopupMenu() != 0 && theCursor != NULL)
  1312.     {
  1313.         // We have a cursor. Attempt to iterate
  1314.         HT_MenuCmd theCommand; 
  1315.         while (HT_NextContextMenuItem(theCursor, &theCommand))
  1316.         {
  1317.             char* menuName = HT_GetMenuCmdName(theCommand);
  1318.             if (theCommand == HT_CMD_SEPARATOR)
  1319.                 menu.AppendMenu(MF_SEPARATOR);
  1320.             else
  1321.             {
  1322.                 // Add the command to our command map
  1323.                 CRDFMenuCommand* rdfCommand = new CRDFMenuCommand(menuName, theCommand);
  1324.                 int index = m_MenuCommandMap.AddCommand(rdfCommand);
  1325.                 menu.AppendMenu(MF_ENABLED, index+FIRST_HT_MENU_ID, menuName);
  1326.             }
  1327.         }
  1328.         HT_DeleteCursor(theCursor);
  1329.  
  1330.         menu.TrackPopupMenu(TPM_LEFTALIGN | TPM_RIGHTBUTTON, point.x, point.y, this, NULL);    
  1331.  
  1332.         menu.DestroyMenu();
  1333.     }
  1334. }
  1335.  
  1336. BOOL CLinkToolbar::OnCommand( WPARAM wParam, LPARAM lParam )
  1337. {
  1338.     if (wParam >= FIRST_HT_MENU_ID && wParam <= LAST_HT_MENU_ID)
  1339.     {
  1340.         // A selection was made from the context menu.
  1341.         // Use the menu map to get the HT command value
  1342.         CRDFMenuCommand* theCommand = (CRDFMenuCommand*)(m_MenuCommandMap.GetCommand((int)wParam-FIRST_HT_MENU_ID));
  1343.         if (theCommand)
  1344.         {
  1345.             HT_MenuCmd htCommand = theCommand->GetHTCommand();
  1346.             HT_DoMenuCmd(m_PersonalToolbarPane, htCommand);
  1347.         }
  1348.         return TRUE;
  1349.     }
  1350.     return((BOOL)GetParentFrame()->SendMessage(WM_COMMAND, wParam, lParam));
  1351. }
  1352.