Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-10-31 22:25:30 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
2622817cf4
gecko-dev/cmd/winfe/usertlbr.cpp
hyatt%netscape.com 1b5b8fb32a Landing the WinFE RDF branch.
1998-07-23 17:48:39 +00:00

2531 lines
67 KiB
C++
Raw Blame History

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
*
* The contents of this file are subject to the Netscape Public License
* Version 1.0 (the "NPL"); you may not use this file except in
* compliance with the NPL. You may obtain a copy of the NPL at
* http://www.mozilla.org/NPL/
*
* Software distributed under the NPL is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
* for the specific language governing rights and limitations under the
* NPL.
*
* The Initial Developer of this code under the NPL is Netscape
* Communications Corporation. Portions created by Netscape are
* Copyright (C) 1998 Netscape Communications Corporation. All Rights
* Reserved.
*/
#include "stdafx.h"
#include "usertlbr.h"
#include "shcut.h"
#include "dropmenu.h"
#include "prefapi.h"
#include "rdfliner.h"
#include "urlbar.h"
extern "C" {
#include "xpgetstr.h"
};
// The Nav Center vocab element
extern "C" RDF_NCVocab gNavCenter;
#define TEXT_CHARACTERS_SHOWN 9
#define BORDERSIZE 2
#define TEXTVERTMARGIN 1
#define TEXTONLYVERTMARGIN 2
#define BITMAPVERTMARGIN 2
#define TEXT_BITMAPVERTMARGIN 1
#define HORIZMARGINSIZE 4
#define LEFT_TOOLBAR_MARGIN 10
#define RIGHT_TOOLBAR_MARGIN 20
#define SPACE_BETWEEN_BUTTONS 2
#define MAX_TOOLBAR_BUTTONS 60
#define MAX_TOOLBAR_ROWS 3
int CRDFToolbar::m_nMinToolbarButtonChars = 15;
int CRDFToolbar::m_nMaxToolbarButtonChars = 30;
//////////////////////////////////////////////////////////////////////////////////////
// CRDFToolbarButtonDropTarget
//////////////////////////////////////////////////////////////////////////////////////
DROPEFFECT CRDFToolbarButtonDropTarget::ProcessDragEnter(CWnd *pWnd, COleDataObject *pDataObject,
DWORD dwKeyState, CPoint point)
{
// Drop target is only used for drops directly onto folder personal toolbar buttons.
// This drop target is NOT used for the Aurora selector bar drops.
return ProcessDragOver(pWnd, pDataObject, dwKeyState, point);
}
DROPEFFECT CRDFToolbarButtonDropTarget::ProcessDragOver(CWnd *pWnd, COleDataObject *pDataObject,
DWORD dwKeyState, CPoint point)
{
CRDFToolbarButton* pButton = (CRDFToolbarButton*)m_pButton;
// Treat as a drop onto the folder.
return RDFGLOBAL_TranslateDropAction(pButton->GetNode(), pDataObject, 2);
}
BOOL CRDFToolbarButtonDropTarget::ProcessDrop(CWnd *pWnd, COleDataObject *pDataObject,
DROPEFFECT dropEffect, CPoint point)
{
// Treat as a drop onto the folder.
CRDFToolbarButton* pButton = (CRDFToolbarButton*)m_pButton;
RDFGLOBAL_PerformDrop(pDataObject, pButton->GetNode(), 2);
return TRUE;
}
//////////////////////////////////////////////////////////////////////////////////////
// CRDFToolbarButton
//////////////////////////////////////////////////////////////////////////////////////
static HBITMAP m_hbmpBM = NULL;
static HBITMAP m_hbmpBMSelected = NULL;
static HBITMAP m_hbmpFolder = NULL;
static HBITMAP m_hbmpSelectedFolder = NULL;
static HBITMAP m_hbmpFolderOpen = NULL;
static int nBitmapRefCount = 0;
CRDFToolbarButton::CRDFToolbarButton()
{
m_bShouldShowRMMenu = TRUE;
m_Node = NULL;
m_uCurBMID = 0;
currentRow = 0;
m_pTreeView = NULL;
}
CRDFToolbarButton::~CRDFToolbarButton()
{
if(m_Node && HT_IsContainer(m_Node))
{
nBitmapRefCount--;
if(nBitmapRefCount == 0)
{
if(m_hbmpBM)
{
DeleteObject(m_hbmpBM);
}
if(m_hbmpFolder)
{
DeleteObject(m_hbmpFolder);
}
if(m_hbmpSelectedFolder)
{
DeleteObject(m_hbmpSelectedFolder);
}
if(m_hbmpFolderOpen)
{
DeleteObject(m_hbmpFolderOpen);
}
if(m_hbmpBMSelected)
{
DeleteObject(m_hbmpBMSelected);
}
}
}
}
int CRDFToolbarButton::Create(CWnd *pParent, int nToolbarStyle, CSize noviceButtonSize, CSize advancedButtonSize,
LPCTSTR pButtonText, LPCTSTR pToolTipText,
LPCTSTR pStatusText,
CSize bitmapSize, int nMaxTextChars, int nMinTextChars, BOOKMARKITEM bookmark,
HT_Resource pNode, DWORD dwButtonStyle )
{
m_bookmark = bookmark;
BOOL bResult = CToolbarButton::Create(pParent, nToolbarStyle, noviceButtonSize, advancedButtonSize,
pButtonText, pToolTipText, pStatusText, 0, 0,
bitmapSize, TRUE, 0, nMaxTextChars, nMinTextChars, dwButtonStyle);
if(bResult)
{
SetNode(pNode);
UpdateIconInfo();
if (m_menu.m_hMenu == NULL || (m_menu.m_hMenu != NULL && !IsMenu(m_menu.m_hMenu)))
m_menu.CreatePopupMenu();
}
return bResult;
}
void CRDFToolbarButton::UpdateIconInfo()
{
m_nIconType = DetermineIconType(m_Node, UseLargeIcons());
UINT oldBitmapID = m_nBitmapID;
m_nBitmapID = GetBitmapID();
if (m_nBitmapID != oldBitmapID)
{
HDC hDC = ::GetDC(m_hWnd);
HPALETTE hPalette = WFE_GetUIPalette(GetParentFrame());
HBITMAP hBitmap = WFE_LookupLoadAndEnterBitmap(hDC, m_nBitmapID, TRUE, hPalette,
sysInfo.m_clrBtnFace, RGB(255, 0, 255));
::ReleaseDC(m_hWnd, hDC);
SetBitmap(hBitmap, TRUE);
if (m_nBitmapID == IDB_PICTURES)
SetBitmapSize(CSize(23,21)); // Command buttons
else SetBitmapSize(CSize(23,17)); // Personal toolbar buttons
}
m_nBitmapIndex = GetBitmapIndex();
}
CSize CRDFToolbarButton::GetMinimalButtonSize(void)
{
CString szText(HT_GetNodeName(m_Node));
return GetButtonSizeFromChars(szText, m_nMinTextChars);
}
CSize CRDFToolbarButton::GetMaximalButtonSize(void)
{
CString szText(HT_GetNodeName(m_Node));
return GetButtonSizeFromChars(szText, m_nMaxTextChars);
}
void CRDFToolbarButton::OnAction(void)
{
if(m_Node)
{
char* url = HT_GetNodeURL(m_Node);
if (strncmp(url, "command:", 8) == 0)
{
// We're a command, baby. Look up our FE command and execute it.
UINT nCommand = theApp.m_pBrowserCommandMap->GetFEResource(url);
WFE_GetOwnerFrame(this)->PostMessage(WM_COMMAND, MAKEWPARAM(nCommand, nCommand), 0);
}
else if (!HT_IsContainer(m_Node))
{
CAbstractCX * pCX = FEU_GetLastActiveFrameContext();
ASSERT(pCX != NULL);
if (pCX != NULL)
{
if (!HT_Launch(m_Node, pCX->GetContext()))
pCX->NormalGetUrl((LPTSTR)HT_GetNodeURL(m_Node));
}
}
}
}
void CRDFToolbarButton::FillInOleDataSource(COleDataSource *pDataSource)
{
CLIPFORMAT cfHTNode = (CLIPFORMAT)RegisterClipboardFormat(NETSCAPE_HTNODE_FORMAT);
HANDLE hString = GlobalAlloc(GMEM_MOVEABLE|GMEM_DDESHARE,1);
pDataSource->CacheGlobalData(cfHTNode, hString);
// Need to "select" the button in the view. Hack.
HT_View theView = HT_GetView(m_Node);
HT_SetSelectedView(HT_GetPane(theView), theView); // Make sure this view is selected in the pane.
HT_SetSelection(m_Node);
// Now the view is sufficient
RDFGLOBAL_BeginDrag(pDataSource, HT_GetView(m_Node));
}
BOOKMARKITEM CRDFToolbarButton::GetBookmarkItem(void)
{
return m_bookmark;
}
void CRDFToolbarButton::SetBookmarkItem(BOOKMARKITEM bookmark)
{
/* m_bookmark = bookmark;
CString strText(bookmark.szText);
CToolbarButton::SetText(strText);
*/
}
void CRDFToolbarButton::SetNode(HT_Resource pNode, BOOL bAddRef)
{
if (pNode == NULL)
return;
m_Node = pNode;
// if it's a header and we haven't already loaded the bitmaps, load the bitmaps
if(HT_IsContainer(pNode) && bAddRef)
{
HDC hDC = ::GetDC(m_hWnd);
HINSTANCE hInstance = AfxGetResourceHandle();
WFE_InitializeUIPalette(hDC);
HPALETTE hPalette = WFE_GetUIPalette(GetParentFrame());
if(nBitmapRefCount == 0)
{
m_hbmpBM = WFE_LoadTransparentBitmap(hInstance, hDC, sysInfo.m_clrMenu, RGB(255, 0, 255),
hPalette, IDB_BOOKMARK_ITEM);
m_hbmpBMSelected = WFE_LoadTransparentBitmap(hInstance, hDC,sysInfo.m_clrHighlight,
RGB(255, 0, 255), hPalette, IDB_BOOKMARK_ITEM);
m_hbmpFolder = WFE_LoadTransparentBitmap(hInstance, hDC,sysInfo.m_clrMenu, RGB(255, 0, 255),
hPalette, IDB_BOOKMARK_FOLDER2);
m_hbmpSelectedFolder = WFE_LoadTransparentBitmap(hInstance, hDC, sysInfo.m_clrHighlight, RGB(255, 0, 255),
hPalette, IDB_BOOKMARK_FOLDER2);
m_hbmpFolderOpen = WFE_LoadTransparentBitmap(hInstance, hDC, sysInfo.m_clrHighlight,
RGB(255, 0, 255), hPalette, IDB_BOOKMARK_FOLDER_OPEN);
}
nBitmapRefCount++;
::ReleaseDC(m_hWnd, hDC);
}
}
void CRDFToolbarButton::EditTextChanged(char *pText)
{
if (pText)
{
HT_SetNodeName(m_Node, pText);
SetText(pText);
SetToolTipText(pText);
delete []pText;
}
RemoveTextEdit();
if (foundOnRDFToolbar())
((CRDFToolbar*)GetParent())->LayoutButtons(-1);
}
void CRDFToolbarButton::DrawPicturesAndTextMode(HDC hDC, CRect rect)
{
if (foundOnRDFToolbar())
{
CRDFToolbar* theToolbar = (CRDFToolbar*)GetParent();
void* data;
HT_GetNodeData(HT_TopNode(theToolbar->GetHTView()), gNavCenter->toolbarBitmapPosition, HT_COLUMN_STRING, &data);
if (data)
{
CString position((char*)data);
if (position == "top")
{
DrawBitmapOnTop(hDC, rect);
return;
}
}
}
DrawBitmapOnSide(hDC, rect);
}
void CRDFToolbarButton::DrawPicturesMode(HDC hDC, CRect rect)
{
if (foundOnRDFToolbar())
{
CRDFToolbar* theToolbar = (CRDFToolbar*)GetParent();
void* data;
HT_GetNodeData(HT_TopNode(theToolbar->GetHTView()), gNavCenter->toolbarBitmapPosition, HT_COLUMN_STRING, &data);
if (data)
{
CString position((char*)data);
if (position == "top")
{
DrawBitmapOnTop(hDC, rect);
return;
}
}
}
DrawBitmapOnSide(hDC, rect);
}
void CRDFToolbarButton::DrawButtonText(HDC hDC, CRect rcTxt, CSize sizeTxt, CString strTxt)
{
if (foundOnRDFToolbar())
{
hasCustomTextColor = TRUE;
switch (m_eState)
{
case eDISABLED:
customTextColor = ((CRDFToolbar*)GetParent())->GetDisabledColor();
if (customTextColor == -1)
{
hasCustomTextColor = FALSE;
}
break;
case eBUTTON_UP:
customTextColor = ((CRDFToolbar*)GetParent())->GetRolloverColor();
break;
case eBUTTON_DOWN:
customTextColor = ((CRDFToolbar*)GetParent())->GetPressedColor();
break;
case eNORMAL:
customTextColor = ((CRDFToolbar*)GetParent())->GetForegroundColor();
break;
}
if (m_bDepressed)
customTextColor = ((CRDFToolbar*)GetParent())->GetPressedColor();
}
CToolbarButton::DrawButtonText(hDC, rcTxt, sizeTxt, strTxt);
}
CSize CRDFToolbarButton::GetButtonSizeFromChars(CString s, int c)
{
if(m_nToolbarStyle != TB_TEXT)
{
if (foundOnRDFToolbar())
{
CRDFToolbar* theToolbar = (CRDFToolbar*)GetParent();
void* data;
HT_GetNodeData(HT_TopNode(theToolbar->GetHTView()), gNavCenter->toolbarBitmapPosition, HT_COLUMN_STRING, &data);
if (data)
{
CString position((char*)data);
if (position == "top")
{
return GetBitmapOnTopSize(s, c);
}
}
}
return(GetBitmapOnSideSize(s, c));
}
else
return(GetTextOnlySize(s, c));
}
void CRDFToolbarButton::GetPicturesAndTextModeTextRect(CRect &rect)
{
if (foundOnRDFToolbar())
{
CRDFToolbar* theToolbar = (CRDFToolbar*)GetParent();
void* data;
HT_GetNodeData(HT_TopNode(theToolbar->GetHTView()), gNavCenter->toolbarBitmapPosition, HT_COLUMN_STRING, &data);
if (data)
{
CString position((char*)data);
if (position == "top")
{
GetBitmapOnTopTextRect(rect);
return;
}
}
}
GetBitmapOnSideTextRect(rect);
}
void CRDFToolbarButton::GetPicturesModeTextRect(CRect &rect)
{
if (foundOnRDFToolbar())
{
CRDFToolbar* theToolbar = (CRDFToolbar*)GetParent();
void* data;
HT_GetNodeData(HT_TopNode(theToolbar->GetHTView()), gNavCenter->toolbarBitmapPosition, HT_COLUMN_STRING, &data);
if (data)
{
CString position((char*)data);
if (position == "top")
{
GetBitmapOnTopTextRect(rect);
return;
}
}
}
GetBitmapOnSideTextRect(rect);
}
BOOL CRDFToolbarButton::CreateRightMouseMenu(void)
{
if (m_bShouldShowRMMenu)
{
m_MenuCommandMap.Clear();
HT_View theView = HT_GetView(m_Node);
HT_SetSelectedView(HT_GetPane(theView), theView); // Make sure this view is selected in the pane.
HT_SetSelection(m_Node); // Make sure the node is the selection in the view.
HT_Cursor theCursor = HT_NewContextualMenuCursor(theView, PR_FALSE, PR_FALSE);
if (theCursor != NULL)
{
// We have a cursor. Attempt to iterate
HT_MenuCmd theCommand;
while (HT_NextContextMenuItem(theCursor, &theCommand))
{
char* menuName = HT_GetMenuCmdName(theCommand);
if (theCommand == HT_CMD_SEPARATOR)
m_menu.AppendMenu(MF_SEPARATOR);
else
{
// Add the command to our command map
CRDFMenuCommand* rdfCommand = new CRDFMenuCommand(menuName, theCommand);
int index = m_MenuCommandMap.AddCommand(rdfCommand);
m_menu.AppendMenu(MF_ENABLED, index+FIRST_HT_MENU_ID, menuName);
}
}
HT_DeleteCursor(theCursor);
}
}
return m_bShouldShowRMMenu;
}
CWnd* CRDFToolbarButton::GetMenuParent(void)
{
return this;
}
BOOL CRDFToolbarButton::OnCommand(UINT wParam, LONG lParam)
{
BOOL bRtn = TRUE;
if (wParam >= FIRST_HT_MENU_ID && wParam <= LAST_HT_MENU_ID)
{
// A selection was made from the context menu.
// Use the menu map to get the HT command value
CRDFMenuCommand* theCommand = (CRDFMenuCommand*)(m_MenuCommandMap.GetCommand((int)wParam-FIRST_HT_MENU_ID));
if (theCommand)
{
HT_MenuCmd htCommand = theCommand->GetHTCommand();
HT_DoMenuCmd(HT_GetPane(GetHTView()), htCommand);
}
return bRtn;
}
if(wParam == ID_HOTLIST_VIEW || wParam == ID_HOTLIST_ADDCURRENTTOHOTLIST)
{
GetParentFrame()->SendMessage(WM_COMMAND, wParam, lParam);
}
else if(wParam == ID_DELETE_BUTTON)
{
HT_RemoveChild(HT_GetParent(m_Node), m_Node);
}
else if(wParam == ID_BUTTON_PROPERTIES)
{
// PROPERTIES
}
else if(wParam == ID_RENAME_BUTTON)
{
AddTextEdit();
SetTextEditText(m_pButtonText);
}
// Only interested in commands from bookmark quick file menu
else if ((wParam >= FIRST_BOOKMARK_MENU_ID))
{
void * pBookmark = NULL;
m_BMMenuMap.Lookup(wParam, pBookmark);
if (pBookmark != NULL)
{
HT_Resource theNode = (HT_Resource)pBookmark;
CAbstractCX *pCX = FEU_GetLastActiveFrameContext();
ASSERT(pCX != NULL);
if (pCX != NULL)
{
if (!HT_Launch(theNode, pCX->GetContext()))
pCX->NormalGetUrl((LPTSTR)HT_GetNodeURL(theNode));
}
}
}
else
{
bRtn = CRDFToolbarButtonBase::OnCommand(wParam, lParam);
}
return(bRtn);
}
///////////////////////////////////////////////////////////////////////////////////
// CRDFToolbarButton Messages
///////////////////////////////////////////////////////////////////////////////////
BEGIN_MESSAGE_MAP(CRDFToolbarButton, CRDFToolbarButtonBase)
//{{AFX_MSG_MAP(CRDFToolbarButton)
ON_MESSAGE(NSDRAGMENUOPEN, OnDragMenuOpen)
ON_MESSAGE(DM_FILLINMENU, OnFillInMenu)
ON_MESSAGE(DT_DROPOCCURRED, OnDropMenuDropOccurred)
ON_MESSAGE(DT_DRAGGINGOCCURRED, OnDropMenuDraggingOccurred)
ON_MESSAGE(DM_MENUCLOSED, OnDropMenuClosed)
ON_WM_SYSCOLORCHANGE()
ON_WM_PAINT()
ON_WM_MOUSEACTIVATE()
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
int CRDFToolbarButton::OnMouseActivate( CWnd* pDesktopWnd, UINT nHitTest, UINT message )
{
m_bButtonDown = TRUE;
return MA_ACTIVATE;
}
void CRDFToolbarButton::OnPaint()
{
CRect updateRect;
GetUpdateRect(&updateRect);
CPaintDC dcPaint(this); // device context for painting
CRect rcClient;
GetClientRect(&rcClient);
HDC hSrcDC = dcPaint.m_hDC;
HPALETTE hPalette;
HPALETTE hOldPalette;
CFrameWnd* pParent = WFE_GetOwnerFrame(this);
hPalette = WFE_GetUIPalette(pParent);
hOldPalette= ::SelectPalette(hSrcDC, hPalette, FALSE);
HDC hMemDC = ::CreateCompatibleDC(hSrcDC);
if(hMemDC)
{
HPALETTE hOldMemPalette = ::SelectPalette(hMemDC, hPalette, FALSE);
HBITMAP hbmMem = CreateCompatibleBitmap(hSrcDC,
rcClient.Width(),
rcClient.Height());
//
// Select the bitmap into the off-screen DC.
//
HBITMAP hbmOld = (HBITMAP)::SelectObject(hMemDC, hbmMem);
// if we are not enabled then must make sure that button state is normal
if(!m_bEnabled)
{
m_eState = eNORMAL;
}
CRect innerRect = rcClient;
innerRect.InflateRect(-BORDERSIZE, -BORDERSIZE);
int oldMode = ::SetBkMode(hMemDC, TRANSPARENT);
if (foundOnRDFToolbar())
{
CRDFToolbar* pToolbar = (CRDFToolbar*)GetParent();
if (pToolbar->GetBackgroundImage() == NULL ||
(pToolbar->GetBackgroundImage() != NULL &&
!pToolbar->GetBackgroundImage()->FrameSuccessfullyLoaded()))
{
// Fill with our background color.
HBRUSH hRegBrush = (HBRUSH) ::CreateSolidBrush(pToolbar->GetBackgroundColor());
::FillRect(hMemDC, rcClient, hRegBrush);
}
else
{
// There is a background. Let's do a tile on the rect corresponding to our position
// in the parent toolbar.
CWnd* pGrandParent = pToolbar->GetParent();
CRect offsetRect(rcClient);
MapWindowPoints(pGrandParent, &offsetRect);
// Now we want to fill the given rectangle.
PaintBackground(hMemDC, rcClient, pToolbar->GetBackgroundImage(), offsetRect.left, offsetRect.top);
}
}
else
{
::FillRect(hMemDC, rcClient, sysInfo.m_hbrBtnFace);
}
if(m_nToolbarStyle == TB_PICTURESANDTEXT)
{
DrawPicturesAndTextMode(hMemDC, innerRect);
}
else if(m_nToolbarStyle == TB_PICTURES)
{
DrawPicturesMode(hMemDC, innerRect);
}
else
{
DrawTextMode(hMemDC, innerRect);
}
// Now, draw 3d visual button effects, depending on our state
switch (m_eState)
{
case eBUTTON_UP:
{
if( m_nChecked == 0 )
DrawUpButton(hMemDC, rcClient);
else
DrawDownButton(hMemDC, rcClient);
}
break;
case eBUTTON_CHECKED:
{
// A checked button but NOT mousing over - no black border
DrawCheckedButton(hMemDC, rcClient);
}
break;
case eBUTTON_DOWN:
{
DrawDownButton(hMemDC, rcClient);
}
break;
case eDISABLED:
{
if(m_nChecked == 2)
DrawCheckedButton(hMemDC, rcClient);
}
break;
case eNORMAL:
{
if (m_bDepressed)
DrawDownButton(hMemDC, rcClient); // Looks like it's locked down.
}
}
::SetBkMode(hMemDC, oldMode);
::BitBlt(hSrcDC, 0, 0, rcClient.Width(), rcClient.Height(), hMemDC, 0, 0,
SRCCOPY);
::SelectPalette(hMemDC, hOldMemPalette, FALSE);
::SelectPalette(hSrcDC, hOldPalette, FALSE);
::SelectObject(hMemDC, hbmOld);
::DeleteObject(hbmMem);
::DeleteDC(hMemDC);
}
}
LRESULT CRDFToolbarButton::OnDragMenuOpen(WPARAM wParam, LPARAM lParam)
{
// Set our drop menu's user data.
if (m_pDropMenu)
m_pDropMenu->SetUserData(m_Node);
if(m_Node == NULL || !HT_IsContainer(m_Node))
return 1;
m_uCurBMID = FIRST_BOOKMARK_MENU_ID;
m_pCachedDropMenu = (CDropMenu *)lParam; // Set our drop menu
PRBool isOpen;
HT_Resource theNode = (HT_Resource)m_pCachedDropMenu->GetUserData();
HT_GetOpenState(theNode, &isOpen);
if (isOpen)
FillInMenu(theNode);
else HT_SetOpenState(theNode, (PRBool)TRUE);
return 1;
}
LRESULT CRDFToolbarButton::OnFillInMenu(WPARAM wParam, LPARAM lParam)
{
// Set our drop menu's user data.
if (m_pDropMenu)
m_pDropMenu->SetUserData(m_Node);
m_pCachedDropMenu = (CDropMenu *)lParam; // Set our drop menu
PRBool isOpen;
HT_Resource theNode = (HT_Resource)m_pCachedDropMenu->GetUserData();
HT_GetOpenState(theNode, &isOpen);
if (isOpen)
FillInMenu(theNode);
else HT_SetOpenState(theNode, (PRBool)TRUE);
return 1;
}
LRESULT CRDFToolbarButton::OnDropMenuDraggingOccurred(WPARAM wParam, LPARAM lParam)
{
CDropMenuDragData* pData = (CDropMenuDragData*)lParam;
UINT nCommand = pData->m_nCommand;
MenuSelectionType eSelType = pData->eSelType;
void * pBookmarkInsertAfter = NULL;
m_BMMenuMap.Lookup(nCommand, pBookmarkInsertAfter);
HT_Resource theNode = (HT_Resource)pBookmarkInsertAfter;
int dragFraction = 2;
if (eSelType == eON)
dragFraction = 2;
else if (eSelType == eBELOW)
dragFraction = 3;
else if (eSelType == eABOVE)
dragFraction = 1;
// Next we get the result.
DROPEFFECT answer = RDFGLOBAL_TranslateDropAction(theNode, pData->m_pDataSource, dragFraction);
// Place the result into our data structure for the droptarget to use.
pData->m_DropEffect = answer;
return 1;
}
LRESULT CRDFToolbarButton::OnDropMenuDropOccurred(WPARAM wParam, LPARAM lParam)
{
CDropMenuDragData* pData = (CDropMenuDragData*)lParam;
UINT nCommand = pData->m_nCommand;
MenuSelectionType eSelType = pData->eSelType;
void * pBookmarkInsertAfter = NULL;
m_BMMenuMap.Lookup(nCommand, pBookmarkInsertAfter);
HT_Resource theNode = (HT_Resource)pBookmarkInsertAfter;
int dragFraction = 2;
if (eSelType == eON)
dragFraction = 2;
else if (eSelType == eBELOW)
dragFraction = 3;
else if (eSelType == eABOVE)
dragFraction = 1;
RDFGLOBAL_PerformDrop(pData->m_pDataSource, theNode, dragFraction);
delete pData; // Clean this structure up.
return 1;
}
LRESULT CRDFToolbarButton::OnDropMenuClosed(WPARAM wParam, LPARAM lParam)
{
int nCount;
if(m_pDropMenu != NULL)
{
HT_Resource theNode = (HT_Resource)m_pDropMenu->GetUserData();
nCount = m_pDropMenu->GetMenuItemCount();
// clean out the menu
for(int i = nCount - 1; i >= 0; i--)
{
m_pDropMenu->DeleteMenu(i, MF_BYPOSITION);
}
m_pDropMenu->DestroyDropMenu();
delete m_pDropMenu;
m_pDropMenu = NULL;
if (theNode != NULL)
HT_SetOpenState(theNode, (PRBool)FALSE);
}
return 1;
}
void CRDFToolbarButton::OnSysColorChange( )
{
if(nBitmapRefCount > 0)
{
VERIFY(::DeleteObject(m_hbmpBM));
VERIFY(::DeleteObject(m_hbmpBMSelected));
VERIFY(::DeleteObject(m_hbmpFolder));
VERIFY(::DeleteObject(m_hbmpSelectedFolder));
VERIFY(::DeleteObject(m_hbmpFolderOpen));
HINSTANCE hInstance = AfxGetResourceHandle();
HDC hDC = ::GetDC(m_hWnd);
WFE_InitializeUIPalette(hDC);
HPALETTE hPalette = WFE_GetUIPalette(GetParentFrame());
m_hbmpBM = WFE_LoadTransparentBitmap(hInstance, hDC, sysInfo.m_clrMenu, RGB(255, 0, 255),
hPalette, IDB_BOOKMARK_ITEM);
m_hbmpBMSelected = WFE_LoadTransparentBitmap(hInstance, hDC,sysInfo.m_clrHighlight,
RGB(255, 0, 255), hPalette, IDB_BOOKMARK_ITEM);
m_hbmpFolder = WFE_LoadTransparentBitmap(hInstance, hDC,sysInfo.m_clrMenu, RGB(255, 0, 255),
hPalette, IDB_BOOKMARK_FOLDER2);
m_hbmpSelectedFolder = WFE_LoadTransparentBitmap(hInstance, hDC,sysInfo.m_clrHighlight, RGB(255, 0, 255),
hPalette, IDB_BOOKMARK_FOLDER2);
m_hbmpFolderOpen = WFE_LoadTransparentBitmap(hInstance, hDC, sysInfo.m_clrHighlight,
RGB(255, 0, 255), hPalette, IDB_BOOKMARK_FOLDER_OPEN);
::ReleaseDC(m_hWnd, hDC);
}
if(m_bBitmapFromParent)
{
HDC hDC = ::GetDC(m_hWnd);
HPALETTE hPalette = WFE_GetUIPalette(GetParentFrame());
HBITMAP hBitmap = WFE_LookupLoadAndEnterBitmap(hDC, m_nBitmapID, TRUE, hPalette,
sysInfo.m_clrBtnFace, RGB(255, 0, 255));
::ReleaseDC(m_hWnd, hDC);
SetBitmap(hBitmap, TRUE);
}
CToolbarButton::OnSysColorChange();
}
///////////////////////////////////////////////////////////////////////////
// CRDFToolbarButton Helpers
///////////////////////////////////////////////////////////////////////////
void CRDFToolbarButton::FillInMenu(HT_Resource theNode)
{
// Determine our position
/* CWnd* frame = GetTopLevelFrame();
CPoint point(0, GetRequiredButtonSize().cy);
MapWindowPoints(frame, &point, 1);
*/
if (!m_bDepressed)
{
CPoint point = RequestMenuPlacement();
m_pTreeView = CNSNavFrame::CreateFramedRDFViewFromResource(NULL, point.x, point.y, 300, 500, m_Node);
SetDepressed(TRUE);
m_pTreeView->SetRDFButton(this);
CRDFToolbarHolder* pHolder = (CRDFToolbarHolder*)(GetParent()->GetParent()->GetParent());
if (pHolder->GetCurrentButton() != NULL)
{
pHolder->GetCurrentButton()->GetTreeView()->DeleteNavCenter();
pHolder->SetCurrentButton(this);
}
}
else
{
// Delete NavCenter.
m_pTreeView->DeleteNavCenter();
m_pTreeView = NULL;
}
/*
m_pCachedDropMenu->CreateOverflowMenuItem(ID_HOTLIST_VIEW, CString(szLoadString(IDS_MORE_BOOKMARKS)), NULL, NULL );
HT_Cursor theCursor = HT_NewCursor(theNode);
HT_Resource theItem = NULL;
while (theItem = HT_GetNextItem(theCursor))
{
IconType nIconType = DetermineIconType(theItem, FALSE);
void* pCustomIcon = NULL;
if (nIconType == LOCAL_FILE)
pCustomIcon = FetchLocalFileIcon(theItem);
else if (nIconType == ARBITRARY_URL)
pCustomIcon = FetchCustomIcon(theItem, m_pCachedDropMenu, FALSE);
HT_SetNodeFEData(theItem, this);
if (HT_IsContainer(theItem))
{
CDropMenu *pSubMenu = new CDropMenu;
pSubMenu->SetUserData(theItem);
CString csAmpersandString = FEU_EscapeAmpersand(HT_GetNodeName(theItem));
m_pCachedDropMenu->AppendMenu(MF_POPUP, m_uCurBMID, pSubMenu, FALSE,
csAmpersandString, TRUE, m_hbmpFolder, m_hbmpFolderOpen, pCustomIcon, nIconType);
m_BMMenuMap.SetAt(m_uCurBMID, theItem);
m_uCurBMID++;
}
else if (!HT_IsSeparator(theItem))
{
CString csAmpersandString = FEU_EscapeAmpersand(HT_GetNodeName(theItem));
m_pCachedDropMenu->AppendMenu(MF_STRING, m_uCurBMID, csAmpersandString, TRUE,
m_hbmpBM, m_hbmpBMSelected, pCustomIcon, nIconType);
m_BMMenuMap.SetAt(m_uCurBMID, theItem);
m_uCurBMID++;
}
else
{
m_pCachedDropMenu->AppendMenu(MF_SEPARATOR, 0, TRUE, NULL, NULL);
}
}
HT_DeleteCursor(theCursor);
m_pCachedDropMenu = NULL;
*/
}
UINT CRDFToolbarButton::GetBitmapID(void)
{
if (m_Node)
{
if (strncmp(HT_GetNodeURL(m_Node), "command:", 8) == 0)
{
// We're an internal command.
return IDB_PICTURES;
}
else if (HT_IsContainer(m_Node))
return IDB_BUTTON_FOLDER;
else return IDB_USERBTN;
}
return IDB_USERBTN;
}
UINT CRDFToolbarButton::GetBitmapIndex(void)
{
if (m_Node)
{
if (strncmp(HT_GetNodeURL(m_Node), "command:", 8) == 0)
{
// We're an internal command. Access the command bitmap strip.
return theApp.m_pCommandToolbarIndices->GetFEResource(HT_GetNodeURL(m_Node));
}
}
return 0;
}
void CRDFToolbarButton::SetTextWithoutResize(CString text)
{
if(m_pButtonText != NULL)
{
XP_FREE(m_pButtonText);
}
m_pButtonText = (LPTSTR)XP_ALLOC(text.GetLength() +1);
XP_STRCPY(m_pButtonText, text);
}
BOOL CRDFToolbarButton::NeedsUpdate()
{
// Only internal commands need updating via the OnUpdateCmdUI handler.
// All other buttons are enabled/disabled using the appropriate HT calls.
if (m_Node && strncmp(HT_GetNodeURL(m_Node), "command:", 8) == 0)
{
m_nCommand = theApp.m_pBrowserCommandMap->GetFEResource(HT_GetNodeURL(m_Node));
return TRUE;
}
return FALSE;
}
void CRDFToolbarButton::LoadComplete(HT_Resource r)
{
Invalidate();
}
void CRDFToolbarButton::DrawCustomIcon(HDC hDC, int x, int y)
{
if (foundOnRDFToolbar())
{
CRDFToolbar* pToolbar = (CRDFToolbar*)GetParent();
CRDFImage* pCustomImage = DrawArbitraryURL(m_Node, x, y, m_bitmapSize.cx, m_bitmapSize.cy, hDC,
pToolbar->GetBackgroundColor(),
this, UseLargeIcons());
if (!pCustomImage->FrameSuccessfullyLoaded())
return;
// Adjust the toolbar button's width and height.
long width = pCustomImage->bmpInfo->bmiHeader.biWidth;
long height = pCustomImage->bmpInfo->bmiHeader.biHeight;
if (width > m_bitmapSize.cx || height > m_bitmapSize.cy)
{
SetBitmapSize(CSize(width, height));
CSize buttonSize = GetMinimalButtonSize(); // Only care about height.
// Grow the toolbar if necessary.
if (buttonSize.cy > pToolbar->GetRowHeight())
{
pToolbar->SetRowHeight(buttonSize.cy);
pToolbar->LayoutButtons(-1);
GetParentFrame()->RecalcLayout();
}
else
{
// We're too small. Need to adjust our bitmap height.
int diff = pToolbar->GetRowHeight() - buttonSize.cy;
SetBitmapSize(CSize(width, height + diff));
}
}
}
}
void CRDFToolbarButton::DrawLocalIcon(HDC hDC, int x, int y)
{
if (m_Node)
DrawLocalFileIcon(m_Node, x, y, hDC);
}
void CRDFToolbarButton::DrawButtonBitmap(HDC hDC, CRect rcImg)
{
BTN_STATE eState = m_eState;
if(m_eState == eBUTTON_CHECKED)
// A checked button has same bitmap as the normal state with no mouse-over
eState = eNORMAL;
else if(m_eState == eBUTTON_UP && m_nChecked == 2)
// if we are in the mouse over mode, but indeterminate we want our bitmap to have a disabled look
eState = eDISABLED;
UpdateIconInfo();
// Create a scratch DC and select our bitmap into it.
HDC pBmpDC = ::CreateCompatibleDC(hDC);
HPALETTE hPalette = WFE_GetUIPalette(GetParentFrame());
CBitmap BmpImg;
CPoint ptDst;
HBITMAP hOldBmp;
HPALETTE hOldPal;
if (m_hBmpImg != NULL)
{
HINSTANCE hInst = AfxGetResourceHandle();
HBITMAP hBmpImg;
hBmpImg = m_hBmpImg;
hOldBmp = (HBITMAP)::SelectObject(pBmpDC, hBmpImg);
hOldPal = ::SelectPalette(pBmpDC, WFE_GetUIPalette(NULL), TRUE);
::RealizePalette(pBmpDC);
}
// Get the image dimensions
int realBitmapHeight;
if(m_nIconType == LOCAL_FILE)
{
realBitmapHeight = 16;
m_bitmapSize.cx = 16;
}
else if (m_nIconType == ARBITRARY_URL)
{
realBitmapHeight = m_bitmapSize.cy;
}
else
{
if (m_nBitmapID == IDB_PICTURES)
realBitmapHeight = 21; // Height of command buttons
else realBitmapHeight = 17; // Height of personal toolbar button bitmaps.
}
// Center the image within the button
ptDst.x = (rcImg.Width() >= m_bitmapSize.cx) ?
rcImg.left + (((rcImg.Width() - m_bitmapSize.cx) + 1) / 2) : rcImg.left;
ptDst.y = (rcImg.Height() >= realBitmapHeight) ?
rcImg.top + (((rcImg.Height() - realBitmapHeight) + 1) / 2) : rcImg.top;
// If we're in the checked state, shift the image one pixel
if (m_eState == eBUTTON_CHECKED || (m_eState == eBUTTON_UP && m_nChecked == 1))
{
ptDst.x += 1;
ptDst.y += 1;
}
// Call the handy transparent blit function to paint the bitmap over
// whatever colors exist.
CPoint bitmapStart;
if(m_bIsResourceID)
bitmapStart = CPoint(m_nBitmapIndex * m_bitmapSize.cx, m_bEnabled ? realBitmapHeight * eState : realBitmapHeight);
if(m_bIsResourceID)
{
if(m_nIconType == LOCAL_FILE)
{
DrawLocalIcon(hDC, ptDst.x, ptDst.y);
}
else if (m_nIconType == ARBITRARY_URL)
{
DrawCustomIcon(hDC, ptDst.x, ptDst.y);
}
else
FEU_TransBlt( hDC, ptDst.x, ptDst.y, m_bitmapSize.cx, realBitmapHeight,
pBmpDC, bitmapStart.x, bitmapStart.y ,WFE_GetUIPalette(NULL),
GetSysColor(COLOR_BTNFACE));
//::BitBlt(hDC, ptDst.x, ptDst.y, m_bitmapSize.cx, realBitmapHeight,
// pBmpDC, bitmapStart.x, bitmapStart.y, SRCCOPY);
}
if (m_hBmpImg != NULL)
{
// Cleanup
::SelectObject(pBmpDC, hOldBmp);
::SelectPalette(pBmpDC, hOldPal, TRUE);
::DeleteDC(pBmpDC);
}
}
///////////////////////////////////////////////////////////////////////////
// Class CRDFSeparatorButton
///////////////////////////////////////////////////////////////////////////
BEGIN_MESSAGE_MAP(CRDFSeparatorButton, CRDFToolbarButton)
//{{AFX_MSG_MAP(CRDFSeparatorButton)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
CSize CRDFSeparatorButton::GetButtonSizeFromChars(CString s, int c)
{
return CSize(8, 8);
}
void CRDFSeparatorButton::DrawButtonBitmap(HDC hDC, CRect rcImg)
{
CDC* pDC = CDC::FromHandle(hDC);
CRect clientRect;
GetClientRect(&clientRect);
COLORREF shadowColor = ::GetSysColor(COLOR_3DSHADOW);
COLORREF highlightColor = ::GetSysColor(COLOR_3DLIGHT);
if (foundOnRDFToolbar())
{
CRDFToolbar* pToolbar = (CRDFToolbar*)GetParent();
shadowColor = pToolbar->GetShadowColor();
highlightColor = pToolbar->GetHighlightColor();
}
HPEN hShadowPen = (HPEN)::CreatePen(PS_SOLID, 1, shadowColor);
HPEN hHighlightPen = (HPEN)::CreatePen(PS_SOLID, 1, highlightColor);
HPEN hOldPen = (HPEN)(pDC->SelectObject(hShadowPen));
pDC->MoveTo(3, 3);
pDC->LineTo(3, clientRect.bottom - 2);
(HPEN)(pDC->SelectObject(hHighlightPen));
pDC->MoveTo(4, 3);
pDC->LineTo(4, clientRect.bottom - 2);
pDC->SelectObject(hOldPen);
VERIFY(::DeleteObject(hShadowPen));
VERIFY(::DeleteObject(hHighlightPen));
}
///////////////////////////////////////////////////////////////////////////
// Class CRDFToolbarDropTarget
///////////////////////////////////////////////////////////////////////////
void CRDFToolbarDropTarget::Toolbar(CRDFToolbar *pToolbar)
{
m_pToolbar = pToolbar;
}
DROPEFFECT CRDFToolbarDropTarget::OnDragEnter(CWnd * pWnd, COleDataObject * pDataObject,
DWORD dwKeyState, CPoint point)
{
return OnDragOver(pWnd, pDataObject, dwKeyState, point);
}
DROPEFFECT CRDFToolbarDropTarget::OnDragOver(CWnd * pWnd, COleDataObject * pDataObject,
DWORD dwKeyState, CPoint point )
{
int nStartX = 0;
RECT buttonRect;
int currentRow = 0;
CRDFToolbarButton* pButton = NULL;
for(int i = 0; i < m_pToolbar->GetNumButtons(); i++)
{
pButton = (CRDFToolbarButton*)(m_pToolbar->GetNthButton(i));
pButton->GetClientRect(&buttonRect);
pButton->MapWindowPoints(m_pToolbar, &buttonRect);
nStartX += (buttonRect.right - buttonRect.left) + SPACE_BETWEEN_BUTTONS;
if (currentRow != pButton->GetRow())
{
currentRow++;
nStartX = LEFT_TOOLBAR_MARGIN + (buttonRect.right - buttonRect.left) + SPACE_BETWEEN_BUTTONS;
}
if(point.x < nStartX && (point.y >= buttonRect.top && point.y <= buttonRect.bottom))
break;
pButton = NULL;
}
HT_Resource theNode = pButton ? pButton->GetNode() : HT_TopNode(m_pToolbar->GetHTView());
m_pToolbar->SetDragButton(pButton);
if (pButton == NULL)
m_pToolbar->SetDragFraction(2);
else
{
// Do the whole computation of drag fraction. Cache our drag fraction and button.
CRect rect;
pButton->GetClientRect(&rect);
if (HT_IsContainer(pButton->GetNode()))
{
if (point.x <= rect.Width()/3)
m_pToolbar->SetDragFraction(1);
else if (point.x <= 2*(rect.Width()/3))
m_pToolbar->SetDragFraction(2);
else m_pToolbar->SetDragFraction(3);
}
else if (point.x <= rect.Width()/2)
m_pToolbar->SetDragFraction(1);
else m_pToolbar->SetDragFraction(2);
}
return RDFGLOBAL_TranslateDropAction(theNode, pDataObject, m_pToolbar->GetDragFraction());
}
BOOL CRDFToolbarDropTarget::OnDrop(CWnd * pWnd, COleDataObject * pDataObject,
DROPEFFECT dropEffect, CPoint point)
{
HT_Resource theNode = HT_TopNode(m_pToolbar->GetHTView());
if (m_pToolbar->GetDragButton())
theNode = m_pToolbar->GetDragButton()->GetNode();
RDFGLOBAL_PerformDrop(pDataObject, theNode, m_pToolbar->GetDragFraction());
return TRUE;
}
// End CRDFToolbarDropTarget implementation
///////////////////////////////////////////////////////////////////////////
// Class CRDFToolbar
///////////////////////////////////////////////////////////////////////////
#define LINKTOOLBARHEIGHT 21
#define COMMANDTOOLBARHEIGHT 42
#define SPACE_BETWEEN_ROWS 2
// The Event Handler for HT notifications on the toolbars
static void toolbarNotifyProcedure (HT_Notification ns, HT_Resource n, HT_Event whatHappened,
void *token, uint32 tokenType)
{
static int toolbarIDCounter = 0;
CRDFToolbarHolder* theToolbarHolder = (CRDFToolbarHolder*)ns->data;
if (theToolbarHolder == NULL)
return;
HT_View theView = HT_GetView(n);
// The pane has to handle some events. These will go here.
if (whatHappened == HT_EVENT_VIEW_SELECTED)
{
}
if (theView == NULL)
return;
if (whatHappened == HT_EVENT_VIEW_ADDED)
{
CRDFToolbar* theNewToolbar = CRDFToolbar::CreateUserToolbar(theView, theToolbarHolder->GetCachedParentWindow());
CButtonToolbarWindow *pWindow = new CButtonToolbarWindow(theNewToolbar,
theApp.m_pToolbarStyle, 43, 27, eSMALL_HTAB);
theToolbarHolder->AddNewWindow(ID_PERSONAL_TOOLBAR+toolbarIDCounter, pWindow, toolbarIDCounter, 43, 27, 1,
HT_GetNodeName(HT_TopNode(theNewToolbar->GetHTView())),theApp.m_pToolbarStyle, TRUE, FALSE);
toolbarIDCounter++;
theToolbarHolder->GetCachedParentWindow()->RecalcLayout();
}
else if (whatHappened == HT_EVENT_VIEW_DELETED)
{
CRDFToolbar* pToolbar = (CRDFToolbar*)HT_GetViewFEData(theView);
pToolbar->SetHTView(NULL);
delete pToolbar;
HT_SetViewFEData(theView, NULL);
}
else if (whatHappened == HT_EVENT_NODE_VPROP_CHANGED && HT_TopNode(theView) == n)
{
}
else if (whatHappened == HT_EVENT_NODE_EDIT && HT_TopNode(theView) == n)
{
// Edit being performed on a selector bar item. (STILL TO DO)
}
else if (whatHappened == HT_EVENT_VIEW_WORKSPACE_REFRESH)
{
}
// If the pane doesn't handle the event, then a view does.
else
{
CRDFToolbar* pToolbar = (CRDFToolbar*)HT_GetViewFEData(theView);
if (pToolbar != NULL)
pToolbar->HandleEvent(ns, n, whatHappened);
}
}
void CRDFToolbar::HandleEvent(HT_Notification ns, HT_Resource n, HT_Event whatHappened)
{
HT_View theView = m_ToolbarView;
if (theView != NULL)
{
if (whatHappened == HT_EVENT_NODE_OPENCLOSE_CHANGED)
{
PRBool openState;
HT_GetOpenState(n, &openState);
if (openState)
{
if (n == HT_TopNode(theView))
{
// Initial population of the toolbar. We should only receive this event once.
FillInToolbar();
}
else
{
// Toolbar button menu. Populate it.
CRDFToolbarButton* theButton = (CRDFToolbarButton*)(HT_GetNodeFEData(n));
theButton->FillInMenu(n);
}
}
}
else if (whatHappened == HT_EVENT_VIEW_REFRESH)
{
LayoutButtons(-1);
}
else if (HT_TopNode(theView) == HT_GetParent(n))
{
// Aside from the opening/closing, we only respond to events that occurred on the top node of
// the view or the immediate children (the buttons on the toolbar).
if (whatHappened == HT_EVENT_NODE_DELETED_DATA ||
whatHappened == HT_EVENT_NODE_DELETED_NODATA)
{
// Delete the button
if (HT_EVENT_NODE_DELETED_DATA == whatHappened)
{
// Destroy the toolbar button
CRDFToolbarButton* pButton = (CRDFToolbarButton*)HT_GetNodeFEData(n);
if (m_hWnd)
RemoveButton(pButton);
else DecrementButtonCount();
delete pButton;
}
}
else if (whatHappened == HT_EVENT_NODE_ADDED)
{
AddHTButton(n);
LayoutButtons(-1);
}
else if (whatHappened == HT_EVENT_NODE_EDIT)
{
CRDFToolbarButton* pButton = (CRDFToolbarButton*)HT_GetNodeFEData(n);
pButton->AddTextEdit();
}
else if (whatHappened == HT_EVENT_NODE_VPROP_CHANGED)
{
CRDFToolbarButton* pButton = (CRDFToolbarButton*)HT_GetNodeFEData(n);
if (pButton->m_hWnd)
{
pButton->SetText(HT_GetNodeName(n)); // Update our name.
LayoutButtons(-1);
}
}
}
}
}
CRDFToolbar::CRDFToolbar(HT_View htView, int nMaxButtons, int nToolbarStyle, int nPicturesAndTextHeight,
int nPicturesHeight, int nTextHeight)
: CNSToolbar2(nMaxButtons, nToolbarStyle, nPicturesAndTextHeight, nPicturesHeight, nTextHeight)
{
// Set our view and point HT at us.
m_pBackgroundImage = NULL;
m_ToolbarView = htView;
HT_SetViewFEData(htView, this);
m_nNumberOfRows = 1;
m_nRowHeight = LINKTOOLBARHEIGHT;
void* data;
HT_GetNodeData(HT_TopNode(GetHTView()), gNavCenter->toolbarBitmapPosition, HT_COLUMN_STRING, &data);
if (data)
{
CString position((char*)data);
if (position == "top")
m_nRowHeight = COMMANDTOOLBARHEIGHT;
}
}
CRDFToolbar* CRDFToolbar::CreateUserToolbar(HT_View theView, CWnd* pParent)
{
CRDFToolbar* pToolbar = new CRDFToolbar(theView, MAX_TOOLBAR_BUTTONS, theApp.m_pToolbarStyle, 43, 27, 27);
if (pToolbar->Create(pParent))
{
// Top node is already open. Fill it in.
PRBool openState;
HT_Resource topNode = HT_TopNode(theView);
HT_GetOpenState(topNode, &openState);
if (openState)
pToolbar->FillInToolbar();
else HT_SetOpenState(topNode, PR_TRUE); // Let the callback kick in.
}
return pToolbar;
}
CRDFToolbar::~CRDFToolbar()
{
m_ToolbarView = NULL;
}
int CRDFToolbar::Create(CWnd *pParent)
{
int result = CNSToolbar2::Create(pParent);
if(!result)
return FALSE;
m_DropTarget.Register(this);
m_DropTarget.Toolbar(this);
DragAcceptFiles(FALSE);
HT_Resource topNode = HT_TopNode(GetHTView());
BOOL fixedSize = FALSE;
void* data;
HT_GetNodeData(topNode, gNavCenter->toolbarButtonsFixedSize, HT_COLUMN_STRING, &data);
if (data)
{
CString answer((char*)data);
if (answer.GetLength() > 0 && (answer.GetAt(0) == 'y' || answer.GetAt(0) == 'Y'))
fixedSize = TRUE;
}
SetButtonsSameWidth(fixedSize);
return result;
}
void CRDFToolbar::FillInToolbar()
{
if (!m_ToolbarView)
return;
HT_Resource top = HT_TopNode(m_ToolbarView);
HT_Cursor cursor = HT_NewCursor(top);
if (cursor == NULL)
return;
HT_Resource item = NULL;
while (item = HT_GetNextItem(cursor))
AddHTButton(item);
HT_DeleteCursor(cursor);
LayoutButtons(-1);
}
void CRDFToolbar::AddHTButton(HT_Resource item)
{
BOOKMARKITEM bookmark;
XP_STRCPY(bookmark.szText, HT_GetNodeName(item));
XP_STRCPY(bookmark.szAnchor, HT_GetNodeURL(item));
CString csAmpersandString = FEU_EscapeAmpersand(CString(bookmark.szText));
CString tooltipText(bookmark.szText); // Default is to use the name for the tooltip
CString statusBarText(bookmark.szAnchor); // and the URL for the status bar text.
// Fetch the button's tooltip and status bar text.
void* data;
HT_GetNodeData(item, gNavCenter->buttonTooltipText, HT_COLUMN_STRING, &data);
if (data)
tooltipText = (char*)data;
HT_GetNodeData(item, gNavCenter->buttonStatusbarText, HT_COLUMN_STRING, &data);
if (data)
statusBarText = (char*)data;
CRDFToolbarButton* pButton = NULL;
if (HT_IsURLBar(item))
pButton = new CURLBarButton;
else if (HT_IsSeparator(item))
{
pButton = new CRDFSeparatorButton;
tooltipText = "Separator";
statusBarText = "Separator";
}
else pButton = new CRDFToolbarButton;
pButton->Create(this, theApp.m_pToolbarStyle, CSize(60,42), CSize(85, 25), csAmpersandString,
tooltipText, statusBarText, CSize(23,17),
m_nMaxToolbarButtonChars, m_nMinToolbarButtonChars, bookmark,
item, (HT_IsContainer(item) ? TB_HAS_DRAGABLE_MENU | TB_HAS_IMMEDIATE_MENU : 0));
if(HT_IsContainer(item))
{
CRDFToolbarButtonDropTarget *pDropTarget = new CRDFToolbarButtonDropTarget;
pButton->SetDropTarget(pDropTarget);
}
HT_SetNodeFEData(item, pButton);
CSize buttonSize = pButton->GetMinimalButtonSize(); // Only care about height.
if (buttonSize.cy > m_nRowHeight)
{
m_nRowHeight = buttonSize.cy;
GetParentFrame()->RecalcLayout();
}
else if (buttonSize.cy < m_nRowHeight)
{
CSize size = pButton->GetBitmapSize();
pButton->SetBitmapSize(CSize(size.cx, size.cy + (m_nRowHeight - buttonSize.cy)));
}
m_pButtonArray[m_nNumButtons] = pButton;
m_nNumButtons++;
if(CheckMaxButtonSizeChanged(pButton, TRUE) && !HT_IsURLBar(item) && !HT_IsSeparator(item))
{
ChangeButtonSizes();
}
else
{
CSize size = pButton->GetRequiredButtonSize();
int nWidth = size.cx;
if (m_bButtonsSameWidth && !HT_IsURLBar(item) && !HT_IsSeparator(item))
nWidth = m_nMaxButtonWidth;
//make sure it's the size of the largest button so far
pButton->SetButtonSize(CSize(nWidth, m_nMaxButtonHeight));
}
// Update the button if it's a command.
if (pButton->NeedsUpdate())
{
pButton->OnUpdateCmdUI(GetTopLevelFrame(), FALSE);
}
}
void CRDFToolbar::ChangeButtonSizes(void)
{
int nWidth;
HT_Cursor cursor = HT_NewCursor(HT_TopNode(m_ToolbarView));
HT_Resource item;
while (item = HT_GetNextItem(cursor))
{
CRDFToolbarButton* pButton = (CRDFToolbarButton*)(HT_GetNodeFEData(item));
if (!HT_IsSeparator(item) && !HT_IsURLBar(item) && pButton)
{
if(!m_bButtonsSameWidth)
{
CSize size = pButton->GetRequiredButtonSize();
nWidth = size.cx;
}
else
nWidth = m_nMaxButtonWidth;
pButton->SetButtonSize(CSize(nWidth, m_nMaxButtonHeight));
}
}
HT_DeleteCursor(cursor);
}
int CRDFToolbar::GetHeight(void)
{
return m_nNumberOfRows * (m_nRowHeight + SPACE_BETWEEN_ROWS) + SPACE_BETWEEN_ROWS;
}
void CRDFToolbar::SetMinimumRows(int rowWidth)
{
int rowCount = 1;
int totalLine = 0;
int rowSpace = rowWidth - RIGHT_TOOLBAR_MARGIN - LEFT_TOOLBAR_MARGIN;
if (rowSpace <= 0)
{
SetRows(rowCount);
return;
}
HT_Cursor cursor = HT_NewCursor(HT_TopNode(m_ToolbarView));
if (!cursor)
return;
HT_Resource item;
while ((item = HT_GetNextItem(cursor)))
{
// Get the current button
CRDFToolbarButton* pButton = (CRDFToolbarButton*)(HT_GetNodeFEData(item));
if (!pButton) // Separator
continue;
CSize s = pButton->GetMinimalButtonSize();
int tempTotal = totalLine + s.cx;
if (tempTotal > rowSpace)
{
rowCount++;
totalLine = s.cx;
}
else totalLine = tempTotal;
totalLine += SPACE_BETWEEN_BUTTONS;
}
HT_DeleteCursor(cursor);
SetRows(rowCount);
}
void CRDFToolbar::ComputeLayoutInfo(CRDFToolbarButton* pButton, int numChars, int rowWidth,
int& usedSpace)
{
CString originalText = HT_GetNodeName(pButton->GetNode());
int currCount = originalText.GetLength();
// Start off at the maximal string
CString strTxt = originalText;
if (currCount > numChars)
{
strTxt = originalText.Left(numChars-3) + "...";
}
pButton->SetTextWithoutResize(strTxt);
if (!m_bButtonsSameWidth || HT_IsURLBar(pButton->GetNode()) || HT_IsSeparator(pButton->GetNode()))
pButton->SetButtonSize(pButton->GetButtonSizeFromChars(strTxt, numChars));
// Determine how much additional padding we'll use to fill out a row if this button doesn't fit.
int rowUsage = usedSpace % rowWidth;
if (rowUsage == 0)
rowUsage = rowWidth;
int additionalPadding = rowWidth - rowUsage;
int tempTotal = rowUsage + pButton->GetButtonSize().cx;
// The button doesn't fit. Flesh out this row and start a new one.
if (tempTotal > rowWidth)
usedSpace += additionalPadding;
// Add this button to the row.
usedSpace += pButton->GetButtonSize().cx + SPACE_BETWEEN_BUTTONS;
// Set this button's row information, so it knows which row it is currently residing on.
int currentRow = usedSpace/rowWidth;
if (usedSpace % rowWidth == 0)
currentRow--;
pButton->SetRow(currentRow);
}
void CRDFToolbar::LayoutButtons(int nIndex)
{
int width = m_nWidth;
if (width <= 0)
{
CRect rect;
GetParentFrame()->GetClientRect(&rect);
width = rect.Width();
}
int numButtonsAtMin = 0;
int numButtonsAtMax = 0;
int idealSpace = 0;
// First quickly determine what the minimum # of rows we consume is. This is our allowed space.
int oldRows = GetRows();
int rowWidth = width-RIGHT_TOOLBAR_MARGIN-LEFT_TOOLBAR_MARGIN;
if (rowWidth <= 0 && m_nWidth > 0)
rowWidth = m_nWidth - RIGHT_TOOLBAR_MARGIN - LEFT_TOOLBAR_MARGIN;
SetMinimumRows(width);
int newRows = GetRows();
int allowedSpace = rowWidth * GetRows(); // Toolbar width * numRows
int usedSpace = 0;
int numChars = 0; // Start off trying to fit the whole thing on the toolbar.
int minChars = 0;
HT_Cursor cursor = HT_NewCursor(HT_TopNode(m_ToolbarView));
if (!cursor)
return;
HT_Resource item;
while ((item = HT_GetNextItem(cursor)))
{
// Get the current button
CRDFToolbarButton* pButton = (CRDFToolbarButton*)(HT_GetNodeFEData(item));
if (!pButton)
continue;
if (numChars == 0)
{
numChars = pButton->GetMaxTextCharacters();
minChars = pButton->GetMinTextCharacters();
}
// See how much this num chars takes up
ComputeLayoutInfo(pButton, numChars, rowWidth, usedSpace);
}
HT_DeleteCursor(cursor);
while (usedSpace > allowedSpace && numChars > minChars)
{
usedSpace = 0;
numChars--;
// Let's see what we can fit.
HT_Cursor cursor = HT_NewCursor(HT_TopNode(m_ToolbarView));
if (!cursor)
return;
HT_Resource item;
while ((item = HT_GetNextItem(cursor)))
{
// Get the current button
CRDFToolbarButton* pButton = (CRDFToolbarButton*)(HT_GetNodeFEData(item));
if (!pButton) // Separator
continue;
// See how much this num chars takes up
ComputeLayoutInfo(pButton, numChars, rowWidth, usedSpace);
}
HT_DeleteCursor(cursor);
}
int nStartX = LEFT_TOOLBAR_MARGIN;
int nStartY = SPACE_BETWEEN_ROWS;
int row = 0;
// Now we have to handle springs
// Initialize our spring counter (we're using this to track the number of springs
// on each toolbar row).
int* springCounter = new int[newRows];
int* rowPadding = new int[newRows];
for (int init=0; init < newRows; init++) { springCounter[init] = 0; }
for (int init2=0; init2 < newRows; init2++) { rowPadding[init2] = 0; }
// Count the springs on each row, as well as the padding on each row.
cursor = HT_NewCursor(HT_TopNode(m_ToolbarView));
if (!cursor)
return;
while ((item = HT_GetNextItem(cursor)))
{
// Get the current button
CRDFToolbarButton* pButton = (CRDFToolbarButton*)(HT_GetNodeFEData(item));
if (!pButton)
continue;
if (pButton->IsSpring())
{
springCounter[row]++;
}
CSize buttonSize = pButton->GetButtonSize(); // The size we must be
int tempTotal = nStartX + buttonSize.cx;
if (tempTotal > (width - RIGHT_TOOLBAR_MARGIN))
{
// Compute row padding
int rowPad = width - RIGHT_TOOLBAR_MARGIN - nStartX;
// Store the row padding information
rowPadding[row] = rowPad;
// Move to the next row.
nStartX = LEFT_TOOLBAR_MARGIN;
nStartY += m_nRowHeight + SPACE_BETWEEN_ROWS;
row++;
}
nStartX += buttonSize.cx + SPACE_BETWEEN_BUTTONS;
}
rowPadding[row] = width - RIGHT_TOOLBAR_MARGIN - nStartX;
HT_DeleteCursor(cursor);
// Now we know the number of springs on each row, and we know how much available padding
// we have on each row. Expand the springs' sizes so that all space on rows with springs
// is consumed.
cursor = HT_NewCursor(HT_TopNode(m_ToolbarView));
if (!cursor)
return;
while ((item = HT_GetNextItem(cursor)))
{
// Get the current button
CRDFToolbarButton* pButton = (CRDFToolbarButton*)(HT_GetNodeFEData(item));
if (!pButton)
continue;
CSize buttonSize = pButton->GetButtonSize(); // The size we must be
int row = pButton->GetRow();
if (pButton->IsSpring())
{
// Expand the spring
int numSprings = springCounter[row];
int rowPad = rowPadding[row];
int addPadding = rowPad;
if (numSprings > 1)
{
springCounter[row]--;
addPadding = rowPad / numSprings;
rowPadding[row] -= addPadding;
}
pButton->SetButtonSize(CSize(buttonSize.cx + addPadding, buttonSize.cy));
}
}
HT_DeleteCursor(cursor);
// Clean up. Delete our temporary arrays.
delete []springCounter;
delete []rowPadding;
// That's it. lay them out with this number of characters.
nStartX = LEFT_TOOLBAR_MARGIN;
nStartY = SPACE_BETWEEN_ROWS;
row = 0;
CSize buttonSize;
CString strTxt;
cursor = HT_NewCursor(HT_TopNode(m_ToolbarView));
if (!cursor)
return;
while ((item = HT_GetNextItem(cursor)))
{
// Get the current button
CRDFToolbarButton* pButton = (CRDFToolbarButton*)(HT_GetNodeFEData(item));
if (!pButton)
continue;
buttonSize = pButton->GetButtonSize(); // The size we must be
int tempTotal = nStartX + buttonSize.cx;
if (tempTotal > (width - RIGHT_TOOLBAR_MARGIN))
{
nStartX = LEFT_TOOLBAR_MARGIN;
nStartY += m_nRowHeight + SPACE_BETWEEN_ROWS;
}
if (buttonSize.cy < m_nRowHeight)
{
CSize size = pButton->GetBitmapSize();
pButton->SetBitmapSize(CSize(size.cx, size.cy + (m_nRowHeight - buttonSize.cy)));
}
pButton->MoveWindow(nStartX, nStartY,
buttonSize.cx, m_nRowHeight);
nStartX += buttonSize.cx + SPACE_BETWEEN_BUTTONS;
}
HT_DeleteCursor(cursor);
m_nWidth = width;
if (oldRows != newRows)
GetParentFrame()->RecalcLayout();
}
void CRDFToolbar::WidthChanged(int animWidth)
{
CRect rect;
GetParentFrame()->GetClientRect(&rect);
int width = rect.Width() - animWidth;
int numButtonsAtMin = 0;
int numButtonsAtMax = 0;
int idealSpace = 0;
// First quickly determine what the minimum # of rows we consume is. This is our allowed space.
int oldRows = GetRows();
int rowWidth = width-RIGHT_TOOLBAR_MARGIN-LEFT_TOOLBAR_MARGIN;
if (rowWidth <= 0 && m_nWidth > 0)
rowWidth = m_nWidth - RIGHT_TOOLBAR_MARGIN - LEFT_TOOLBAR_MARGIN;
SetMinimumRows(width);
int newRows = GetRows();
int allowedSpace = rowWidth * GetRows(); // Toolbar width * numRows
int usedSpace = 0;
int numChars = 0; // Start off trying to fit the whole thing on the toolbar.
int minChars = 0;
HT_Cursor cursor = HT_NewCursor(HT_TopNode(m_ToolbarView));
if (!cursor)
return;
HT_Resource item;
while ((item = HT_GetNextItem(cursor)))
{
// Get the current button
CRDFToolbarButton* pButton = (CRDFToolbarButton*)(HT_GetNodeFEData(item));
if (!pButton) // Separator
continue;
if (numChars == 0)
{
numChars = pButton->GetMaxTextCharacters();
minChars = pButton->GetMinTextCharacters();
}
// See how much this num chars takes up
ComputeLayoutInfo(pButton, numChars, rowWidth, usedSpace);
}
HT_DeleteCursor(cursor);
while (usedSpace > allowedSpace && numChars > minChars)
{
usedSpace = 0;
numChars--;
// Let's see what we can fit.
HT_Cursor cursor = HT_NewCursor(HT_TopNode(m_ToolbarView));
if (!cursor)
return;
HT_Resource item;
while ((item = HT_GetNextItem(cursor)))
{
// Get the current button
CRDFToolbarButton* pButton = (CRDFToolbarButton*)(HT_GetNodeFEData(item));
if (!pButton)
continue;
// See how much this num chars takes up
ComputeLayoutInfo(pButton, numChars, rowWidth, usedSpace);
}
HT_DeleteCursor(cursor);
}
// That's it. lay them out with this number of characters.
int nStartX = LEFT_TOOLBAR_MARGIN;
int nStartY = SPACE_BETWEEN_ROWS;
int row = 0;
// Now we have to handle springs
// Initialize our spring counter (we're using this to track the number of springs
// on each toolbar row).
int* springCounter = new int[newRows];
int* rowPadding = new int[newRows];
for (int init=0; init < newRows; init++) { springCounter[init] = 0; }
for (int init2=0; init2 < newRows; init2++) { rowPadding[init2] = 0; }
// Count the springs on each row, as well as the padding on each row.
cursor = HT_NewCursor(HT_TopNode(m_ToolbarView));
if (!cursor)
return;
while ((item = HT_GetNextItem(cursor)))
{
// Get the current button
CRDFToolbarButton* pButton = (CRDFToolbarButton*)(HT_GetNodeFEData(item));
if (!pButton)
continue;
if (pButton->IsSpring())
{
springCounter[row]++;
}
CSize buttonSize = pButton->GetButtonSize(); // The size we must be
int tempTotal = nStartX + buttonSize.cx;
if (tempTotal > (width - RIGHT_TOOLBAR_MARGIN))
{
// Compute row padding
int rowPad = width - RIGHT_TOOLBAR_MARGIN - nStartX;
// Store the row padding information
rowPadding[row] = rowPad;
// Move to the next row.
nStartX = LEFT_TOOLBAR_MARGIN;
nStartY += m_nRowHeight + SPACE_BETWEEN_ROWS;
row++;
}
nStartX += buttonSize.cx + SPACE_BETWEEN_BUTTONS;
}
rowPadding[row] = width - RIGHT_TOOLBAR_MARGIN - nStartX;
HT_DeleteCursor(cursor);
// Now we know the number of springs on each row, and we know how much available padding
// we have on each row. Expand the springs' sizes so that all space on rows with springs
// is consumed.
cursor = HT_NewCursor(HT_TopNode(m_ToolbarView));
if (!cursor)
return;
while ((item = HT_GetNextItem(cursor)))
{
// Get the current button
CRDFToolbarButton* pButton = (CRDFToolbarButton*)(HT_GetNodeFEData(item));
if (!pButton)
continue;
CSize buttonSize = pButton->GetButtonSize(); // The size we must be
int row = pButton->GetRow();
if (pButton->IsSpring())
{
// Expand the spring
int numSprings = springCounter[row];
int rowPad = rowPadding[row];
int addPadding = rowPad;
if (numSprings > 1)
{
springCounter[row]--;
addPadding = rowPad / numSprings;
rowPadding[row] -= addPadding;
}
pButton->SetButtonSize(CSize(buttonSize.cx + addPadding, buttonSize.cy));
}
}
HT_DeleteCursor(cursor);
// Clean up. Delete our temporary arrays.
delete []springCounter;
delete []rowPadding;
nStartX = LEFT_TOOLBAR_MARGIN;
nStartY = SPACE_BETWEEN_ROWS;
row = 0;
CSize buttonSize;
CString strTxt;
cursor = HT_NewCursor(HT_TopNode(m_ToolbarView));
if (!cursor)
return;
while ((item = HT_GetNextItem(cursor)))
{
// Get the current button
CRDFToolbarButton* pButton = (CRDFToolbarButton*)(HT_GetNodeFEData(item));
if (!pButton)
continue;
buttonSize = pButton->GetButtonSize(); // The size we must be
int tempTotal = nStartX + buttonSize.cx;
if (tempTotal > (width - RIGHT_TOOLBAR_MARGIN))
{
nStartX = LEFT_TOOLBAR_MARGIN;
nStartY += m_nRowHeight + SPACE_BETWEEN_ROWS;
}
if (buttonSize.cy < m_nRowHeight)
{
CSize size = pButton->GetBitmapSize();
pButton->SetBitmapSize(CSize(size.cx, size.cy + (m_nRowHeight - buttonSize.cy)));
}
pButton->MoveWindow(nStartX, nStartY,
buttonSize.cx, m_nRowHeight);
nStartX += buttonSize.cx + SPACE_BETWEEN_BUTTONS;
}
HT_DeleteCursor(cursor);
m_nWidth = width;
if (oldRows != newRows)
GetParentFrame()->RecalcLayout();
}
int CRDFToolbar::GetRowWidth()
{
return m_nWidth - RIGHT_TOOLBAR_MARGIN - LEFT_TOOLBAR_MARGIN - SPACE_BETWEEN_BUTTONS;
}
void CRDFToolbar::OnPaint(void)
{
CRect rcClient, updateRect, buttonRect, intersectRect;
GetClientRect(&rcClient);
GetUpdateRect(&updateRect);
CPaintDC dcPaint(this);
// background color
HT_Resource top = HT_TopNode(GetHTView());
void* data;
COLORREF backgroundColor = GetSysColor(COLOR_BTNFACE);
COLORREF shadowColor = backgroundColor;
COLORREF highlightColor = backgroundColor;
HT_GetNodeData(top, gNavCenter->viewBGColor, HT_COLUMN_STRING, &data);
if (data)
{
WFE_ParseColor((char*)data, &backgroundColor);
}
Compute3DColors(backgroundColor, highlightColor, shadowColor);
if (m_BackgroundColor != backgroundColor)
{
// Ensure proper filling in of parent space with the background color.
SetBackgroundColor(backgroundColor);
GetParent()->Invalidate();
}
SetShadowColor(shadowColor);
SetHighlightColor(highlightColor);
// Foreground color
COLORREF foregroundColor = GetSysColor(COLOR_BTNTEXT);
HT_GetNodeData(top, gNavCenter->viewFGColor, HT_COLUMN_STRING, &data);
if (data)
{
WFE_ParseColor((char*)data, &foregroundColor);
}
SetForegroundColor(foregroundColor);
// Rollover color
COLORREF rolloverColor = RGB(0, 0, 255);
HT_GetNodeData(top, gNavCenter->viewRolloverColor, HT_COLUMN_STRING, &data);
if (data)
{
WFE_ParseColor((char*)data, &rolloverColor);
}
SetRolloverColor(rolloverColor);
// Pressed color
COLORREF pressedColor = RGB(0, 0, 128);
HT_GetNodeData(top, gNavCenter->viewPressedColor, HT_COLUMN_STRING, &data);
if (data)
{
WFE_ParseColor((char*)data, &pressedColor);
}
SetPressedColor(pressedColor);
// Disabled color
COLORREF disabledColor = -1;
HT_GetNodeData(top, gNavCenter->viewDisabledColor, HT_COLUMN_STRING, &data);
if (data)
{
WFE_ParseColor((char*)data, &disabledColor);
}
SetDisabledColor(disabledColor);
// Background image URL
CString backgroundImageURL = "";
HT_GetNodeData(top, gNavCenter->viewBGURL, HT_COLUMN_STRING, &data);
if (data)
backgroundImageURL = (char*)data;
SetBackgroundImage(NULL); // Clear out the BG image.
HBRUSH hRegBrush = (HBRUSH) ::CreateSolidBrush(backgroundColor);
if (backgroundImageURL != "")
{
// There's a background that needs to be drawn.
SetBackgroundImage(LookupImage(backgroundImageURL, NULL));
}
if (GetBackgroundImage() &&
GetBackgroundImage()->FrameSuccessfullyLoaded())
{
PaintBackground(dcPaint.m_hDC, &rcClient, GetBackgroundImage(), 0);
}
else
{
::FillRect(dcPaint.m_hDC, &rcClient, hRegBrush);
}
VERIFY(::DeleteObject(hRegBrush));
for (int i = 0; i < m_nNumButtons; i++)
{
m_pButtonArray[i]->GetClientRect(&buttonRect);
m_pButtonArray[i]->MapWindowPoints(this, &buttonRect);
if(intersectRect.IntersectRect(updateRect, buttonRect))
{
MapWindowPoints(m_pButtonArray[i], &intersectRect);
m_pButtonArray[i]->RedrawWindow(&intersectRect);
}
}
}
///////////////////////////////////////////////////////////////////////////////////
// CRDFToolbar Messages
///////////////////////////////////////////////////////////////////////////////////
BEGIN_MESSAGE_MAP(CRDFToolbar, CNSToolbar2)
//{{AFX_MSG_MAP(CNSToolbar2)
ON_WM_RBUTTONDOWN()
ON_WM_PAINT()
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
void CRDFToolbar::OnRButtonDown(UINT nFlags, CPoint point)
{
HT_SetSelectedView(HT_GetPane(GetHTView()), GetHTView());
HT_SetSelection(HT_TopNode(GetHTView()));
m_MenuCommandMap.Clear();
HT_Cursor theCursor = HT_NewContextualMenuCursor(m_ToolbarView, PR_FALSE, PR_TRUE);
CMenu menu;
ClientToScreen(&point);
if (menu.CreatePopupMenu() != 0 && theCursor != NULL)
{
// We have a cursor. Attempt to iterate
HT_MenuCmd theCommand;
while (HT_NextContextMenuItem(theCursor, &theCommand))
{
char* menuName = HT_GetMenuCmdName(theCommand);
if (theCommand == HT_CMD_SEPARATOR)
menu.AppendMenu(MF_SEPARATOR);
else
{
// Add the command to our command map
CRDFMenuCommand* rdfCommand = new CRDFMenuCommand(menuName, theCommand);
int index = m_MenuCommandMap.AddCommand(rdfCommand);
menu.AppendMenu(MF_ENABLED, index+FIRST_HT_MENU_ID, menuName);
}
}
HT_DeleteCursor(theCursor);
menu.TrackPopupMenu(TPM_LEFTALIGN | TPM_RIGHTBUTTON, point.x, point.y, this, NULL);
menu.DestroyMenu();
}
}
BOOL CRDFToolbar::OnCommand( WPARAM wParam, LPARAM lParam )
{
if (wParam >= FIRST_HT_MENU_ID && wParam <= LAST_HT_MENU_ID)
{
// A selection was made from the context menu.
// Use the menu map to get the HT command value
CRDFMenuCommand* theCommand = (CRDFMenuCommand*)(m_MenuCommandMap.GetCommand((int)wParam-FIRST_HT_MENU_ID));
if (theCommand)
{
HT_MenuCmd htCommand = theCommand->GetHTCommand();
HT_DoMenuCmd(HT_GetPane(m_ToolbarView), htCommand);
}
return TRUE;
}
return((BOOL)GetParentFrame()->SendMessage(WM_COMMAND, wParam, lParam));
}
// ==========================================================
// CRDFDragToolbar
// Contains a single RDF toolbar.
// Handles drawing of backgrounds etc. etc.
// ==========================================================
BEGIN_MESSAGE_MAP(CRDFDragToolbar, CDragToolbar)
//{{AFX_MSG_MAP(CRDFToolbarButton)
ON_WM_PAINT()
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
#define OPEN_BUTTON_WIDTH 9
#define CLOSED_BUTTON_WIDTH 40
#define CLOSED_BUTTON_HEIGHT 10
#define DT_RIGHT_MARGIN 1 //Margin between end of toolbar and right border of Navigator
#define DRAGGING_BORDER_HEIGHT 2
#define NOTOOL -1
#define HTAB_TOP_START 0
#define HTAB_TOP_HEIGHT 7
#define HTAB_MIDDLE_START 8
#define HTAB_MIDDLE_HEIGHT 6
#define HTAB_BOTTOM_START 15
#define HTAB_BOTTOM_HEIGHT 3
extern HBITMAP m_hTabBitmap;
void CRDFDragToolbar::OnPaint(void)
{
CPaintDC dcPaint(this); // device context for painting
CRect rect;
GetClientRect(&rect);
// Use our toolbar background color (or background image TODO)
CRDFToolbar* pToolbar = (CRDFToolbar*)m_pToolbar->GetToolbar();
HBRUSH brFace = (HBRUSH) ::CreateSolidBrush(pToolbar->GetBackgroundColor());
::FillRect(dcPaint.m_hDC, &rect, brFace);
VERIFY(::DeleteObject(brFace));
CDC *pDC = &dcPaint;
HPALETTE hOldPal = ::SelectPalette(pDC->m_hDC, WFE_GetUIPalette(GetParentFrame()), FALSE);
if(m_hTabBitmap != NULL)
{
// Create a scratch DC and select our bitmap into it.
CDC * pBmpDC = new CDC;
pBmpDC->CreateCompatibleDC(pDC);
HBITMAP hOldBmp = (HBITMAP)::SelectObject(pBmpDC->m_hDC ,m_hTabBitmap);
HPALETTE hOldPalette = ::SelectPalette(pBmpDC->m_hDC, WFE_GetUIPalette(NULL), TRUE);
::RealizePalette(pBmpDC->m_hDC);
CPoint bitmapStart(!m_bMouseInTab ? 0 : OPEN_BUTTON_WIDTH ,HTAB_TOP_START);
//First do top of the tab
::BitBlt(pDC->m_hDC, 0, 0, OPEN_BUTTON_WIDTH, HTAB_TOP_HEIGHT,
pBmpDC->m_hDC, bitmapStart.x, bitmapStart.y, SRCCOPY);
//Now do the middle portion of the tab
int y = HTAB_TOP_HEIGHT;
bitmapStart.y = HTAB_MIDDLE_START;
while(y < rect.bottom - HTAB_BOTTOM_HEIGHT)
{
::BitBlt(pDC->m_hDC, 0, y, OPEN_BUTTON_WIDTH, HTAB_MIDDLE_HEIGHT,
pBmpDC->m_hDC, bitmapStart.x, bitmapStart.y, SRCCOPY);
y += HTAB_MIDDLE_HEIGHT;
}
// Now do the bottom of the tab
y = rect.bottom - HTAB_BOTTOM_HEIGHT;
bitmapStart.y = HTAB_BOTTOM_START;
::BitBlt(pDC->m_hDC, 0, y, OPEN_BUTTON_WIDTH, HTAB_BOTTOM_HEIGHT,
pBmpDC->m_hDC, bitmapStart.x, bitmapStart.y, SRCCOPY);
// Cleanup
::SelectObject(pBmpDC->m_hDC, hOldBmp);
::SelectPalette(pBmpDC->m_hDC, hOldPalette, TRUE);
::SelectPalette(pDC->m_hDC, hOldPal, TRUE);
pBmpDC->DeleteDC();
delete pBmpDC;
}
if(m_bDragging)
{
CBrush brush(RGB(0, 0, 0));
CBrush *pOldBrush = (CBrush*)dcPaint.SelectObject(&brush);
//rect.left += OPEN_BUTTON_WIDTH;
dcPaint.FrameRect(&rect, &brush);
dcPaint.SelectObject(pOldBrush);
brush.DeleteObject();
}
}
// ==========================================================
// CRDFToolbarHolder
// The container of all the toolbars
// ==========================================================
CRDFToolbarHolder::CRDFToolbarHolder(int maxToolbars, CFrameWnd* pParentWindow)
:CCustToolbar(maxToolbars)
{
m_pCachedParentWindow = pParentWindow;
m_pCurrentButton = NULL;
}
CRDFToolbarHolder::~CRDFToolbarHolder()
{
if (m_ToolbarPane)
{
HT_Pane oldPane = m_ToolbarPane;
m_ToolbarPane = NULL;
HT_DeletePane(oldPane);
}
}
void CRDFToolbarHolder::InitializeRDFData()
{
HT_Notification ns = new HT_NotificationStruct;
XP_BZERO(ns, sizeof(HT_NotificationStruct));
ns->notifyProc = toolbarNotifyProcedure;
ns->data = this;
// Construct the pane and give it our notification struct
HT_Pane newPane = HT_NewToolbarPane(ns);
if (newPane)
{
SetHTPane(newPane);
HT_SetPaneFEData(newPane, this);
}
}
CIsomorphicCommandMap* CIsomorphicCommandMap::InitializeCommandMap(const CString& initType)
{
CIsomorphicCommandMap* result = new CIsomorphicCommandMap();
if (initType == "Browser Commands")
{
// Enter the builtin browser commands into the map.
result->AddItem("command:back", ID_NAVIGATE_BACK);
result->AddItem("command:forward", ID_NAVIGATE_FORWARD);
result->AddItem("command:reload", ID_NAVIGATE_RELOAD);
result->AddItem("command:home", ID_GO_HOME);
result->AddItem("command:print", ID_FILE_PRINT);
result->AddItem("command:stop", ID_NAVIGATE_INTERRUPT);
}
else if (initType == "Command Toolbar Bitmap Indices")
{
result->AddItem("command:back", 0);
result->AddItem("command:forward", 1);
result->AddItem("command:reload", 2);
result->AddItem("command:home", 3);
result->AddItem("command:print", 7);
result->AddItem("command:stop", 11);
}
return result;
}
void CIsomorphicCommandMap::AddItem(CString xpItem, UINT feResource)
{
char buffer[20];
_itoa((int)feResource, buffer, 10);
mapFromXPToFE.SetAt(xpItem, CString(buffer));
mapFromFEToXP.SetAt(CString(buffer), xpItem);
}
void CIsomorphicCommandMap::RemoveXPItem(CString xpItem)
{
CString result;
mapFromXPToFE.Lookup(xpItem, result);
mapFromXPToFE.RemoveKey(xpItem);
mapFromFEToXP.RemoveKey(result);
}
void CIsomorphicCommandMap::RemoveFEItem(UINT feResource)
{
char buffer[20];
_itoa((int)feResource, buffer, 10);
CString resource(buffer);
CString result;
mapFromFEToXP.Lookup(resource, result);
mapFromXPToFE.RemoveKey(result);
mapFromFEToXP.RemoveKey(resource);
}
UINT CIsomorphicCommandMap::GetFEResource(CString xpItem)
{
CString result;
mapFromXPToFE.Lookup(xpItem, result);
return (atoi(result));
}
CString CIsomorphicCommandMap::GetXPResource(UINT feResource)
{
char buffer[20];
_itoa((int)feResource, buffer, 10);
CString resource(buffer);
CString result;
mapFromFEToXP.Lookup(resource, result);
return result;
}
Reference in New Issue View Git Blame Copy Permalink