pjs/cmd/winfe/taskbar.cpp

/* -*- 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.
 */
///
//
// $Revision: 3.1 $
//
// TASKBAR.CPP
//
// DESCRIPTION:
//		This file contains the implementations of the various task bar related
//		classes.
//
// AUTHOR: Scott Jones
//
///


/**	INCLUDE	**/
#include "stdafx.h"
#include "taskbar.h"
#include "statbar.h"
#include "hiddenfr.h"
#include "feutil.h"
#include "prefapi.h"

#ifdef _DEBUG
#undef THIS_FILE
static char	BASED_CODE THIS_FILE[] = __FILE__;
#endif

#define SPACE_BETWEEN_ICONS 3
#define TASKBAR_ADDMENU (WM_USER + 200)

/****************************************************************************
*
*	Class: CTaskBarButtonDropTarget
*
*	DESCRIPTION:
*		
*		Some taskbar buttons may want to be drop targets.  So here's the class.
*
****************************************************************************/

DROPEFFECT CTaskBarButtonDropTarget::ProcessDragEnter(CWnd *pWnd, COleDataObject *pDataObject, 
			DWORD dwKeyState, CPoint point)
{

	DROPEFFECT deReturn = DROPEFFECT_NONE;
	
	// Only interested in bookmarks
	if (pDataObject->IsDataAvailable(
		::RegisterClipboardFormat(NETSCAPE_BOOKMARK_FORMAT)))
	{
		deReturn = DROPEFFECT_COPY;

	}

	return(deReturn);

}

DROPEFFECT CTaskBarButtonDropTarget::ProcessDragOver(CWnd *pWnd, COleDataObject *pDataObject, 
			DWORD dwKeyState, CPoint point)
{
	DROPEFFECT deReturn = DROPEFFECT_NONE;
	
	// Only interested in bookmarks
	if (pDataObject->IsDataAvailable(
		::RegisterClipboardFormat(NETSCAPE_BOOKMARK_FORMAT)))
	{
		deReturn = DROPEFFECT_COPY;
	}

	return(deReturn);

}

BOOL CBrowserButtonDropTarget::ProcessDrop(CWnd *pWnd, COleDataObject *pDataObject, 
			DROPEFFECT dropEffect, CPoint point)
{
	BOOL bRtn = FALSE;
	
	// Only interested in bookmarks
    CLIPFORMAT cfBookmark = ::RegisterClipboardFormat(NETSCAPE_BOOKMARK_FORMAT);
	if (pDataObject->IsDataAvailable(cfBookmark))
	{
		// TODO: for now, just dump it at the top like the CTRL-D accelerator
		// does. Later, we want to put it in a designated scrap folder or
		// something.
		HGLOBAL hBookmark = pDataObject->GetGlobalData(cfBookmark);
		LPBOOKMARKITEM pBookmark = (LPBOOKMARKITEM)::GlobalLock(hBookmark);
		ASSERT(pBookmark != NULL);

		CGenericFrame * pFrame = (CGenericFrame * )FEU_GetLastActiveFrame();
		if (pFrame) {
			char *urlType = NET_ParseURL(pBookmark->szAnchor, GET_PROTOCOL_PART);

			BOOL bNewWindow = (XP_STRCASECMP(urlType, "file:") == 0) ||
				(XP_STRCASECMP(urlType, "http:") == 0) || 
				(XP_STRCASECMP(urlType, "https:") == 0);


			if(bNewWindow)
                // This checks for existing window with given URL
                FE_LoadUrl(pBookmark->szAnchor, LOAD_URL_NAVIGATOR);
			else
				pFrame->GetMainContext()->NormalGetUrl(pBookmark->szAnchor);
		}
		//this needs to become what we are dropping onto
		::GlobalUnlock(hBookmark);

		bRtn = TRUE;
	}
	return bRtn;
}

DROPEFFECT CComposerButtonDropTarget::ProcessDragEnter(CWnd *pWnd, COleDataObject *pDataObject, 
			DWORD dwKeyState, CPoint point)
{

	DROPEFFECT deReturn = DROPEFFECT_NONE;
	
	// Only interested in bookmarks
    CLIPFORMAT cfBookmark = ::RegisterClipboardFormat(NETSCAPE_BOOKMARK_FORMAT);

	if (pDataObject->IsDataAvailable(cfBookmark))
	{
		HGLOBAL hBookmark = pDataObject->GetGlobalData(cfBookmark);
		LPBOOKMARKITEM pBookmark = (LPBOOKMARKITEM)::GlobalLock(hBookmark);
		ASSERT(pBookmark != NULL);

		if(pBookmark)
		{
			char *urlType = NET_ParseURL(pBookmark->szAnchor, GET_PROTOCOL_PART);

			BOOL bAccept = (XP_STRCASECMP(urlType, "file:") == 0) ||
				(XP_STRCASECMP(urlType, "http:") == 0) || 
				(XP_STRCASECMP(urlType, "https:") == 0);

			if(bAccept)
				deReturn = DROPEFFECT_COPY;
		}

	}

	return(deReturn);

}

DROPEFFECT CComposerButtonDropTarget::ProcessDragOver(CWnd *pWnd, COleDataObject *pDataObject, 
			DWORD dwKeyState, CPoint point)
{
	DROPEFFECT deReturn = DROPEFFECT_NONE;
	
	// Only interested in bookmarks
    CLIPFORMAT cfBookmark = ::RegisterClipboardFormat(NETSCAPE_BOOKMARK_FORMAT);

	if (pDataObject->IsDataAvailable(cfBookmark))
	{
		HGLOBAL hBookmark = pDataObject->GetGlobalData(cfBookmark);
		LPBOOKMARKITEM pBookmark = (LPBOOKMARKITEM)::GlobalLock(hBookmark);
		ASSERT(pBookmark != NULL);

		if(pBookmark)
		{
			char *urlType = NET_ParseURL(pBookmark->szAnchor, GET_PROTOCOL_PART);

			BOOL bAccept = (XP_STRCASECMP(urlType, "file:") == 0) ||
				(XP_STRCASECMP(urlType, "http:") == 0) || 
				(XP_STRCASECMP(urlType, "https:") == 0);

			if(bAccept)
				deReturn = DROPEFFECT_COPY;
		}
	}

	return(deReturn);

}

BOOL CComposerButtonDropTarget::ProcessDrop(CWnd *pWnd, COleDataObject *pDataObject, 
			DROPEFFECT dropEffect, CPoint point)
{
	BOOL bRtn = FALSE;
	
	// Only interested in bookmarks
    CLIPFORMAT cfBookmark = ::RegisterClipboardFormat(NETSCAPE_BOOKMARK_FORMAT);
	if (pDataObject->IsDataAvailable(cfBookmark))
	{
		// TODO: for now, just dump it at the top like the CTRL-D accelerator
		// does. Later, we want to put it in a designated scrap folder or
		// something.
		HGLOBAL hBookmark = pDataObject->GetGlobalData(cfBookmark);
		LPBOOKMARKITEM pBookmark = (LPBOOKMARKITEM)::GlobalLock(hBookmark);
		ASSERT(pBookmark != NULL);
		CGenericFrame * pFrame = (CGenericFrame * )FEU_GetLastActiveFrame();

		if(pFrame)
		{
            FE_LoadUrl(pBookmark->szAnchor, LOAD_URL_COMPOSER);
		}

		//this needs to become what we are dropping onto
		::GlobalUnlock(hBookmark);

		bRtn = TRUE;
	}
	return bRtn;
}

DROPEFFECT CMessengerButtonDropTarget::ProcessDragEnter(CWnd *pWnd, COleDataObject *pDataObject, 
			DWORD dwKeyState, CPoint point)
{

	DROPEFFECT deReturn = DROPEFFECT_NONE;
	
	// Only interested in bookmarks
    CLIPFORMAT cfBookmark = ::RegisterClipboardFormat(NETSCAPE_BOOKMARK_FORMAT);

	if (pDataObject->IsDataAvailable(cfBookmark))
	{
		HGLOBAL hBookmark = pDataObject->GetGlobalData(cfBookmark);
		LPBOOKMARKITEM pBookmark = (LPBOOKMARKITEM)::GlobalLock(hBookmark);
		ASSERT(pBookmark != NULL);

		if(pBookmark)
		{
			char *urlType = NET_ParseURL(pBookmark->szAnchor, GET_PROTOCOL_PART);

			BOOL bAccept = (XP_STRCASECMP(urlType, "mailbox:") == 0);

			if(bAccept)
				deReturn = DROPEFFECT_COPY;
		}
	}
	return(deReturn);

}

DROPEFFECT CMessengerButtonDropTarget::ProcessDragOver(CWnd *pWnd, COleDataObject *pDataObject, 
			DWORD dwKeyState, CPoint point)
{
	DROPEFFECT deReturn = DROPEFFECT_NONE;
	
	// Only interested in bookmarks
    CLIPFORMAT cfBookmark = ::RegisterClipboardFormat(NETSCAPE_BOOKMARK_FORMAT);

	if (pDataObject->IsDataAvailable(cfBookmark))
	{
		HGLOBAL hBookmark = pDataObject->GetGlobalData(cfBookmark);
		LPBOOKMARKITEM pBookmark = (LPBOOKMARKITEM)::GlobalLock(hBookmark);
		ASSERT(pBookmark != NULL);

		if(pBookmark)
		{
			char *urlType = NET_ParseURL(pBookmark->szAnchor, GET_PROTOCOL_PART);

			BOOL bAccept = (XP_STRCASECMP(urlType, "mailbox:") == 0);

			if(bAccept)
				deReturn = DROPEFFECT_COPY;
		}
	}
	return(deReturn);

}

BOOL CMessengerButtonDropTarget::ProcessDrop(CWnd *pWnd, COleDataObject *pDataObject, 
			DROPEFFECT dropEffect, CPoint point)
{
	BOOL bRtn = FALSE;
	
	// Only interested in bookmarks
    CLIPFORMAT cfBookmark = ::RegisterClipboardFormat(NETSCAPE_BOOKMARK_FORMAT);
	if (pDataObject->IsDataAvailable(cfBookmark))
	{
		// TODO: for now, just dump it at the top like the CTRL-D accelerator
		// does. Later, we want to put it in a designated scrap folder or
		// something.
		HGLOBAL hBookmark = pDataObject->GetGlobalData(cfBookmark);
		LPBOOKMARKITEM pBookmark = (LPBOOKMARKITEM)::GlobalLock(hBookmark);
		ASSERT(pBookmark != NULL);

		CGenericFrame * pFrame = (CGenericFrame * )FEU_GetLastActiveFrame();
		if (pFrame) {
			char *urlType = NET_ParseURL(pBookmark->szAnchor, GET_PROTOCOL_PART);
	
			BOOL bAccept = (XP_STRCASECMP(urlType, "mailbox:") == 0);

			if(bAccept)
				pFrame->GetMainContext()->NormalGetUrl(pBookmark->szAnchor);
	

		}
		//this needs to become what we are dropping onto
		::GlobalUnlock(hBookmark);

		bRtn = TRUE;
	}
	return bRtn;
}

DROPEFFECT CCollabraButtonDropTarget::ProcessDragEnter(CWnd *pWnd, COleDataObject *pDataObject, 
			DWORD dwKeyState, CPoint point)
{

	DROPEFFECT deReturn = DROPEFFECT_NONE;
	
	// Only interested in bookmarks
    CLIPFORMAT cfBookmark = ::RegisterClipboardFormat(NETSCAPE_BOOKMARK_FORMAT);

	if (pDataObject->IsDataAvailable(cfBookmark))
	{
		HGLOBAL hBookmark = pDataObject->GetGlobalData(cfBookmark);
		LPBOOKMARKITEM pBookmark = (LPBOOKMARKITEM)::GlobalLock(hBookmark);
		ASSERT(pBookmark != NULL);

		if(pBookmark)
		{
			char *urlType = NET_ParseURL(pBookmark->szAnchor, GET_PROTOCOL_PART);

			BOOL bAccept = (XP_STRCASECMP(urlType, "news:") == 0) ||
							   (XP_STRCASECMP(urlType, "snews:") == 0);

			if(bAccept)
				deReturn = DROPEFFECT_COPY;
		}
	}
	return(deReturn);

}

DROPEFFECT CCollabraButtonDropTarget::ProcessDragOver(CWnd *pWnd, COleDataObject *pDataObject, 
			DWORD dwKeyState, CPoint point)
{
	DROPEFFECT deReturn = DROPEFFECT_NONE;
	
	// Only interested in bookmarks
    CLIPFORMAT cfBookmark = ::RegisterClipboardFormat(NETSCAPE_BOOKMARK_FORMAT);

	if (pDataObject->IsDataAvailable(cfBookmark))
	{
		HGLOBAL hBookmark = pDataObject->GetGlobalData(cfBookmark);
		LPBOOKMARKITEM pBookmark = (LPBOOKMARKITEM)::GlobalLock(hBookmark);
		ASSERT(pBookmark != NULL);

		if(pBookmark)
		{
			char *urlType = NET_ParseURL(pBookmark->szAnchor, GET_PROTOCOL_PART);

			BOOL bAccept = (XP_STRCASECMP(urlType, "news:") == 0) ||
							   (XP_STRCASECMP(urlType, "snews:") == 0);

			if(bAccept)
				deReturn = DROPEFFECT_COPY;
		}
	}
	return(deReturn);

}

BOOL CCollabraButtonDropTarget::ProcessDrop(CWnd *pWnd, COleDataObject *pDataObject, 
			DROPEFFECT dropEffect, CPoint point)
{
	BOOL bRtn = FALSE;
	
	// Only interested in bookmarks
    CLIPFORMAT cfBookmark = ::RegisterClipboardFormat(NETSCAPE_BOOKMARK_FORMAT);
	if (pDataObject->IsDataAvailable(cfBookmark))
	{
		// TODO: for now, just dump it at the top like the CTRL-D accelerator
		// does. Later, we want to put it in a designated scrap folder or
		// something.
		HGLOBAL hBookmark = pDataObject->GetGlobalData(cfBookmark);
		LPBOOKMARKITEM pBookmark = (LPBOOKMARKITEM)::GlobalLock(hBookmark);
		ASSERT(pBookmark != NULL);
		
		CGenericFrame * pFrame = (CGenericFrame * )FEU_GetLastActiveFrame();
		if (pFrame) {
	
			if (pFrame) {
				char *urlType = NET_ParseURL(pBookmark->szAnchor, GET_PROTOCOL_PART);
			
				BOOL bAccept = (XP_STRCASECMP(urlType, "news:") == 0) ||
							   (XP_STRCASECMP(urlType, "snews:") == 0);

				if(bAccept)
					pFrame->GetMainContext()->NormalGetUrl(pBookmark->szAnchor);
			}
		}
		//this needs to become what we are dropping onto
		::GlobalUnlock(hBookmark);

		bRtn = TRUE;
	}
	return bRtn;
}


/****************************************************************************
*
*	Class: CTaskIcon
*
*	DESCRIPTION:
*		This class represents the abstraction of a task icon object. It
*		encapsulates the data that is used to construct CTaskIconWnd objects.
*
****************************************************************************/

/****************************************************************************
*
*	CTaskIcon::CTaskIcon
*
*	PARAMETERS:
*		idTask		- task identifier
*		pwndNotify	- pointer to window desiring notification
*		dwMessage	- user-defined callback message
*		idBmpLarge	- bitmap resource ID for large icon
*		idBmpSmall	- bitmap resource ID for small icon
*		idTip		- string resource ID of tool tip text
*
* 	RETURNS:
*		N/A
*
*	DESCRIPTION:
*   	Constructor.
*
****************************************************************************/

CTaskIcon::CTaskIcon(UINT idTask, CWnd * pwndNotify, DWORD dwMessage,
	UINT idBmpLarge, int indexBitmapLarge, UINT idBmpSmall, int indexBitmapSmall, UINT idHorizText,
	UINT idVertText, UINT idDockedTip, UINT idFloatingTip)
{
	m_idTask = idTask;
	m_pwndNotify = pwndNotify;
	m_dwMessage = dwMessage;
	m_idBmpLarge = idBmpLarge;
	m_idBmpSmall = idBmpSmall;
	m_indexBmpLarge = indexBitmapLarge;
	m_indexBmpSmall = indexBitmapSmall;
	m_idHorizText = idHorizText;
	m_idVertText = idVertText;
	m_idDockedTip = idDockedTip;
	m_idFloatingTip = idFloatingTip;

} // END OF FUNCTION CTaskIcon::CTaskIcon()

/****************************************************************************
*
*  CTaskIcon::~CTaskIcon
*
*  PARAMETERS:
*     N/A
*
*  RETURNS:
*     N/A
*
*  DESCRIPTION:
*     Destructor.
*
****************************************************************************/

CTaskIcon::~CTaskIcon()
{
} // END OF FUNCTION CTaskIcon::~CTaskIcon()


/****************************************************************************
*
*	Class: CTaskIconArray
*
*	DESCRIPTION:
*		This is a container class for holding CTaskIcon objects.
*
****************************************************************************/

/****************************************************************************
*
*	CTaskIconArray::FindByID
*
*	PARAMETERS:
*		idTask	- id of icon object to be found
*
*	RETURNS:
*		Index of the object if found, -1 if not.
*
*	DESCRIPTION:
*		This function is called to search the list for an icon object with
*		the given task identifier.
*
****************************************************************************/

int CTaskIconArray::FindByID(UINT idTask)
{
	int nRtn = -1;
	
	BOOL bFound = FALSE;
	for (int i = 0; (i < GetSize()) && !bFound; i++)
	{
		if (Get(i)->GetTaskID() == idTask)
		{
			bFound = TRUE;
			nRtn = i;
		}
	}
	
	return(nRtn);

} // END OF	FUNCTION CTaskIconArray::FindByID()

/****************************************************************************
*
*	CTaskIconArray::DeleteAll
*
*	PARAMETERS:
*		None
*
*	RETURNS:
*		void
*
*	DESCRIPTION:
*		This functions is called to delete all of the CTaskIcon objects
*		in the container.
*
****************************************************************************/

void CTaskIconArray::DeleteAll()
{
	int nSize = GetSize();

	for (int i = 0; i < nSize; i++)
	{
		CTaskIcon * pIcon = Get(i);
		delete pIcon;
	}
	RemoveAll();

} // END OF	FUNCTION CTaskIconArray::DeleteAll()


/****************************************************************************
*
*	Class: CTaskIconWnd
*
*	DESCRIPTION:
*		This object represents a notification icon. It can be embeded within
*		a task bar and provides mouse notifications to a given window. It is
*		a window that paints its own bitmap, displays tool tip text, processes
*		mouse events, etc.
*
****************************************************************************/

BEGIN_MESSAGE_MAP(CTaskIconWnd, CTaskIconWndBase)
	//{{AFX_MSG_MAP(CTaskIconWnd)
	ON_WM_LBUTTONDOWN()
	ON_WM_LBUTTONUP()
	ON_WM_RBUTTONDOWN()
	ON_WM_RBUTTONUP()
	ON_WM_MOUSEMOVE()
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/****************************************************************************
*
*	CTaskIconWnd::CTaskIconWnd
*
*	PARAMETERS:
*		None
*
* 	RETURNS:
*		N/A
*
*	DESCRIPTION:
*   	Constructor. Instantiate the object, then call the Create() function.
*
****************************************************************************/

CTaskIconWnd::CTaskIconWnd()
{

} // END OF FUNCTION CTaskIconWnd::CTaskIconWnd()

/****************************************************************************
*
*  CTaskIconWnd::~CTaskIconWnd
*
*  PARAMETERS:
*     N/A
*
*  RETURNS:
*     N/A
*
*  DESCRIPTION:
*     Destructor.
*
****************************************************************************/

CTaskIconWnd::~CTaskIconWnd()
{
	
} // END OF FUNCTION CTaskIconWnd::~CTaskIconWnd()

/****************************************************************************
*
*	CTaskIconWnd::Create
*
*	PARAMETERS:
*		idTask		- task identifier
*		pwndNotify	- pointer to window desiring notification
*		dwMessage	- user-defined callback message
*		idBmp		- bitmap resource ID
*		idTip		- string resource ID of tool tip text
*		pParent		- pointer to parent
*		rc			- window rectangle, if desired
*
*	RETURNS:
*		TRUE if creation is successful.
*
*	DESCRIPTION:
*		This function should be called after construction to actually create
*		the task icon window.
*
****************************************************************************/

BOOL CTaskIconWnd::Create(UINT idTask, CWnd * pwndNotify, DWORD dwMessage,
	UINT idBmp, int nBitmapIndex, UINT idHorizText, UINT idVertText,
	UINT idText, UINT idTip, int nToolbarStyle, CSize noviceSize, CSize advancedSize,
	CSize bitmapSize, CWnd * pParent, const CRect & rc /*= (0,0,0,0)*/)
{
	m_idTask = idTask;
	m_pwndNotify = pwndNotify;
	m_dwMessage = dwMessage;
	m_idHorizText = idHorizText;
	m_idVertText = idVertText;

	CString text , tip;

	text.LoadString(idText);
	tip.LoadString(idTip);

	BOOL bRtn = CTaskIconWndBase::Create(pParent, nToolbarStyle, noviceSize, advancedSize,
										 (const char*)text, (const char*)tip, "",
										 idBmp, nBitmapIndex, bitmapSize, FALSE, idTask, 
										 SHOW_ALL_CHARACTERS, 0);

	if(bRtn)
	{
		AddDropTargetIfStandardButton();
	}

 	return(bRtn);
   
} // END OF FUNCTION CTaskIconWnd::Create()

/****************************************************************************
*
*	CTaskIconWnd::PostNcDestroy
*
*	PARAMETERS:
*		None
*
*	RETURNS:
*		void
*
*	DESCRIPTION:
*		We override this function to add auto-cleanup to the window.
*
****************************************************************************/

void CTaskIconWnd::PostNcDestroy()
{
	delete this;

} // END OF	FUNCTION CTaskIconWnd::PostNcDestroy()

void CTaskIconWnd::AddDropTargetIfStandardButton(void)
{
	switch(m_idTask)
	{
		case ID_TOOLS_WEB:
			SetDropTarget(new(CBrowserButtonDropTarget));
			break;
		case ID_TOOLS_EDITOR:
			SetDropTarget(new(CComposerButtonDropTarget));
			break;
		case ID_TOOLS_INBOX:
			SetDropTarget(new(CMessengerButtonDropTarget));
			break;
		case ID_TOOLS_NEWS:
			SetDropTarget(new(CCollabraButtonDropTarget));
			break;
	}

}

/****************************************************************************
*
*	CTaskIconWnd::OnLButtonDown
*
*	PARAMETERS:
*		nFlags	- not used
*		point	- not used
*
*	RETURNS:
*		void
*
*	DESCRIPTION:
*		Handler for the WM_LBUTTONDOWN message. We send the notification to
*		the window that's set to get them from this icon.
*
****************************************************************************/

void CTaskIconWnd::OnLButtonDown(UINT nFlags, CPoint point) 
{
	CTaskIconWndBase::OnLButtonDown(nFlags, point);

	ASSERT(m_pwndNotify != NULL);
	if (m_pwndNotify != NULL)
	{
		m_pwndNotify->SendMessage(CASTUINT(m_dwMessage), m_idTask, WM_LBUTTONDOWN);
	}
	
} // END OF	FUNCTION CTaskIconWnd::OnLButtonDown()

/****************************************************************************
*
*	CTaskIconWnd::OnLButtonUp
*
*	PARAMETERS:
*		nFlags	- not used
*		point	- not used
*
*	RETURNS:
*		void
*
*	DESCRIPTION:
*		Handler for the WM_LBUTTONUP message. We send the notification to the
*		window that's set to get them from this icon.
*
****************************************************************************/

void CTaskIconWnd::OnLButtonUp(UINT nFlags, CPoint point) 
{
	CTaskIconWndBase::OnLButtonUp(nFlags, point);

	ASSERT(m_pwndNotify != NULL);
	if (m_pwndNotify != NULL)
	{
		m_pwndNotify->SendMessage(CASTUINT(m_dwMessage), m_idTask, WM_LBUTTONUP);
	}
	
} // END OF	FUNCTION CTaskIconWnd::OnLButtonUp()

/****************************************************************************
*
*	CTaskIconWnd::OnRButtonDown
*
*	PARAMETERS:
*		nFlags	- not used
*		point	- not used
*
*	RETURNS:
*		void
*
*	DESCRIPTION:
*		Handler for the WM_RBUTTONDOWN message. We just translate it to a
*		notification for the window that's set to get them from this icon.
*
****************************************************************************/

void CTaskIconWnd::OnRButtonDown(UINT nFlags, CPoint point) 
{
	CTaskIconWndBase::OnRButtonDown(nFlags, point);

	ASSERT(m_pwndNotify != NULL);
	if (m_pwndNotify != NULL)
	{
		m_pwndNotify->SendMessage(CASTUINT(m_dwMessage), m_idTask, WM_RBUTTONDOWN);
	}
	
} // END OF	FUNCTION CTaskIconWnd::OnRButtonDown()

/****************************************************************************
*
*	CTaskIconWnd::OnRButtonUp
*
*	PARAMETERS:
*		nFlags	- not used
*		point	- not used
*
*	RETURNS:
*		void
*
*	DESCRIPTION:
*		Handler for the WM_RBUTTONUP message. We just translate it to a
*		notification for the window that's set to get them from this icon.
*
****************************************************************************/

void CTaskIconWnd::OnRButtonUp(UINT nFlags, CPoint point) 
{
	CTaskIconWndBase::OnRButtonUp(nFlags, point);

	ASSERT(m_pwndNotify != NULL);
	if (m_pwndNotify != NULL)
	{
		m_pwndNotify->SendMessage(CASTUINT(m_dwMessage), m_idTask, WM_RBUTTONUP);
	}
	
} // END OF	FUNCTION CTaskIconWnd::OnRButtonUp()

/****************************************************************************
*
*	CTaskIconWnd::OnMouseMove
*
*	PARAMETERS:
*		nFlags	- not used
*		point	- not used
*
*	RETURNS:
*		void
*
*	DESCRIPTION:
*		Handler for the WM_MOUSEMOVE message. We send the notification to the
*		window that's set to get them from this icon.
*
****************************************************************************/

void CTaskIconWnd::OnMouseMove(UINT nFlags, CPoint point) 
{
	CTaskIconWndBase::OnMouseMove(nFlags, point);
	
	ASSERT(m_pwndNotify != NULL);
	if (m_pwndNotify != NULL)
	{
		m_pwndNotify->SendMessage(CASTUINT(m_dwMessage), m_idTask, WM_MOUSEMOVE);
	}
	
} // END OF	FUNCTION CTaskIconWnd::OnMouseMove()


/****************************************************************************
*
*	Class: CTaskIconWndArray
*
*	DESCRIPTION:
*		This is a container class for holding CTaskIconWnd objects.
*
****************************************************************************/

/****************************************************************************
*
*	CTaskIconWndArray::FindByID
*
*	PARAMETERS:
*		idTask	- id of icon object to be found
*
*	RETURNS:
*		Index of the object if found, -1 if not.
*
*	DESCRIPTION:
*		This function is called to search the list for an icon window with
*		the given task identifier.
*
****************************************************************************/

int CTaskIconWndArray::FindByID(UINT idTask)
{
	int nRtn = -1;
	
	BOOL bFound = FALSE;
	for (int i = 0; (i < GetSize()) && !bFound; i++)
	{
		if (Get(i)->GetTaskID() == idTask)
		{
			bFound = TRUE;
			nRtn = i;
		}
	}
	
	return(nRtn);

} // END OF	FUNCTION CTaskIconWndArray::FindByID()

/****************************************************************************
*
*	CTaskIconWndArray::DeleteAll
*
*	PARAMETERS:
*		None
*
*	RETURNS:
*		void
*
*	DESCRIPTION:
*		This functions is called to delete all of the CTaskIconWnd objects
*		in the container.
*
****************************************************************************/

void CTaskIconWndArray::DeleteAll()
{
	for (int i = 0; i < GetSize(); i++)
	{
		CTaskIconWnd * pIcon = Get(i++);
		if (pIcon != NULL)
		{
			pIcon->DestroyWindow();
			// no need to call delete - pIcon has auto cleanup
		}
	}
	RemoveAll();

} // END OF	FUNCTION CTaskIconWndArray::DeleteAll()


/****************************************************************************
*
*	Class: CTaskBar
*
*	DESCRIPTION:
*		This is the base class for task bar objects. All polymorphic functions
*		common to the floating, docked, or other derived task bars are
*		implemented here.
*
*		This is an abstract base class - you must instantiate one of the
*		derived types. Also, objects of this class are auto-deleting, you
*		must allocate them on the heap.
*
****************************************************************************/

BEGIN_MESSAGE_MAP(CTaskBar, CTaskBarBase)
	//{{AFX_MSG_MAP(CTaskBar)
	ON_WM_PAINT()
	ON_WM_SIZE()
	ON_WM_PALETTECHANGED()
	ON_WM_SYSCOLORCHANGE()
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/****************************************************************************
*
*	CTaskBar::CTaskBar
*
*	PARAMETERS:
*		None
*
*	RETURNS:
*		N/A
*
*	DESCRIPTION:
*		Constructor
*
****************************************************************************/

CTaskBar::CTaskBar(int nToolbarStyle)
{
	// Derived classes must override these
	m_noviceButtonSize.cx = 0;
	m_noviceButtonSize.cy = 0;
	m_advancedButtonSize.cx = 0;
	m_advancedButtonSize.cy = 0;

	m_IconSize.cx = 0;
	m_IconSize.cy = 0;

	m_nDragBarWidth = 0;
	m_nIconSpace = 0;
	m_nToolbarStyle = nToolbarStyle;

	m_nMaxButtonWidth = m_nMaxButtonHeight = 0;

	m_bHorizontal = TRUE;

} // END OF	FUNCTION CTaskBar::CTaskBar()

/****************************************************************************
*
*	CTaskBar::~CTaskBar
*
*	PARAMETERS:
*		N/A
*
*	RETURNS:
*		N/A
*
*	DESCRIPTION:
*		Destructor.
*
****************************************************************************/

CTaskBar::~CTaskBar()
{

} // END OF	FUNCTION CTaskBar::~CTaskBar()


/****************************************************************************
*
*	CTaskBar::PostNcDestroy
*
*	PARAMETERS:
*		None
*
*	RETURNS:
*		void
*
*	DESCRIPTION:
*		We override this function to add auto-cleanup to the window.
*
****************************************************************************/

void CTaskBar::PostNcDestroy()
{
	delete this;

} // END OF	FUNCTION CTaskBar::PostNcDestroy()

/****************************************************************************
*
*	CTaskBar::OnSize
*
*	PARAMETERS:
*		nType, cs, cy	- not used
*
*	RETURNS:
*		void
*
*	DESCRIPTION:
*		We process the WM_SIZE message so we can reposition our icons.
*
****************************************************************************/

void CTaskBar::OnSize(UINT nType, int cx, int cy) 
{
	CTaskBarBase::OnSize(nType, cx, cy);
	LayoutIcons();

} // END OF	FUNCTION CTaskBar::OnSize()

/****************************************************************************
*
*	CTaskBar::OnPaint
*
*	PARAMETERS:
*		None
*
*	RETURNS:
*		void
*
*	DESCRIPTION:
*		Overridden to do special painting for the task bar. This includes
*		faking a title bar and a minimize control.
*
****************************************************************************/

void CTaskBar::OnPaint() 
{
	// Do not call CTaskBarBase::OnPaint() for painting messages
	CPaintDC dc(this); // device context for painting

	HPALETTE hPalette = WFE_GetUIPalette(GetParentFrame());
	HPALETTE hOldPalette = ::SelectPalette(dc.m_hDC, hPalette, FALSE);
	DoPaint(dc);
	// Should get unselect when destroy.
	::SelectPalette(dc.m_hDC, hOldPalette, TRUE);
	
} // END OF	FUNCTION CTaskBar::OnPaint()

void CTaskBar::OnPaletteChanged( CWnd* pFocusWnd )
{
	if (pFocusWnd != this) {
		HPALETTE hPalette = WFE_GetUIPalette(GetParentFrame());
		if (WFE_IsGlobalPalette(hPalette)) {
			HDC hDC = ::GetDC(m_hWnd);
			HPALETTE hOldPalette = ::SelectPalette(hDC, hPalette, FALSE);
			::SelectPalette(hDC, hOldPalette, TRUE);
			::ReleaseDC(m_hWnd, hDC);
		}
		Invalidate(FALSE);
	}
}


void CTaskBar::OnSysColorChange(void)
{

	theApp.GetTaskBarMgr().ReloadIconBitmaps(this);

}

/****************************************************************************
*
*	CTaskBar::AddTaskIcon
*
*	PARAMETERS:
*		idTask		- task identifier
*		pwndNotify	- pointer to window desiring notification
*		dwMessage	- user-defined callback message
*		idBmp		- bitmap resource ID
*		idTip		- string resource ID of tool tip text
*
*	RETURNS:
*		TRUE if successful, FALSE if not.
*
*	DESCRIPTION:
*		This function is called to add an icon to the task bar.	Notifications
*		(mouse events) are then sent to the window identified by pwndNotify.
*
****************************************************************************/

BOOL CTaskBar::AddTaskIcon(UINT idTask, CWnd * pwndNotify, DWORD dwMessage,
	HBITMAP hBitmap, int nBitmapIndex, UINT idHorizText, UINT idVertText,
	UINT idText, UINT idTip, int nToolbarStyle)
{
	BOOL bRtn = FALSE;
	
	// Create new task icon object and add it to the list
	CTaskIconWnd * pIcon = new CTaskIconWnd;
	ASSERT(pIcon != NULL);
	if (pIcon != NULL)
	{
		bRtn = pIcon->Create(idTask, pwndNotify, dwMessage, 0, nBitmapIndex, idHorizText, idVertText,
							 idText, idTip, nToolbarStyle, m_noviceButtonSize, m_advancedButtonSize,
							 m_IconSize, this);

		pIcon->SetBitmap(hBitmap, TRUE);

		CSize size = pIcon->GetRequiredButtonSize();
		
		if(m_nToolbarStyle != TB_PICTURESANDTEXT)
		{
			//for the moment we need to make the docked bar smaller than it should be
			//in order to make things fit
			size.cy -= 2;
		}

		if(size.cx > m_nMaxButtonWidth)
			m_nMaxButtonWidth = size.cx;

		if(size.cy > m_nMaxButtonHeight)
			m_nMaxButtonHeight = size.cy;

		m_TaskIconWndList.Add(pIcon);
		
		// Note: our icons will be sized/positioned in our OnSize()
	}
	
	return(bRtn);

} // END OF	FUNCTION CTaskBar::AddTaskIcon()

/****************************************************************************
*
*	CTaskBar::ReplaceTaskIcon
*
*	PARAMETERS:
*		idTask	- task identifier
*		idBmp	- new bitmap resource ID
*
*	RETURNS:
*		TRUE if the icon was successfully replaced, FALSE if not (such as
*		when no existing icon with the given ID is found).
*
*	DESCRIPTION:
*		This function is called to replace an existing icon in the task bar
*		whenever it is desirable to show a different image, but retain the
*		notification handler and other information for the icon.
*
****************************************************************************/

BOOL CTaskBar::ReplaceTaskIcon(UINT idTask, UINT idBmp, int nBitmapIndex)
{
	BOOL bRtn = FALSE;
	
	int i = m_TaskIconWndList.FindByID(idTask);
	if (i > -1)
	{
		bRtn = TRUE;
		
		CTaskIconWnd * pIcon = m_TaskIconWndList.Get(i);
		pIcon->SetBmpID(idBmp);
		pIcon->ReplaceBitmap(idBmp, nBitmapIndex);
	}
	
	return(bRtn);

} // END OF	FUNCTION CTaskBar::ReplaceTaskIcon()

/****************************************************************************
*
*	CTaskBar::RemoveTaskIcon
*
*	PARAMETERS:
*		idTask	- task identifier
*
*	RETURNS:
*		TRUE if the icon was successfully removed from the task bar, FALSE
*		if not (such as when no existing icon with the given ID is found).
*
*	DESCRIPTION:
*		This function is called to remove an icon from the task bar when it
*		is no longer desirable to have it displayed. This is the only case
*		where this function is useful, since cleanup is performed
*		automatically when the task bar is destroyed.
*
****************************************************************************/

BOOL CTaskBar::RemoveTaskIcon(UINT idTask)
{
	BOOL bRtn = FALSE;
	
	int i = m_TaskIconWndList.FindByID(idTask);
	if (i > -1)
	{
		bRtn = TRUE;
		
		CTaskIconWnd * pIcon = m_TaskIconWndList.Get(i);
		pIcon->DestroyWindow();	// no need to delete - it's auto cleanup
		m_TaskIconWndList.RemoveAt(i);
		
		// Note: our icons will be re-sized/positioned in our OnSize()
	}
	
	return(bRtn);

} // END OF	FUNCTION CTaskBar::RemoveTaskIcon()

/****************************************************************************
*
*	CTaskBar::CalcDesiredDim
*
*	PARAMETERS:
*		None
*
*	RETURNS:
*		The width and height that the task bar requires to draw itself
*
*	DESCRIPTION:
*		This function is called to determine the dimensions that the Task
*		Bar window will require.
*
****************************************************************************/

CSize CTaskBar::CalcDesiredDim()
{
	CSize sizeRtn;
	CSize sizeButton;

	// Make it wide enough for all icons, plus the margin
	int nNumIcons = m_TaskIconWndList.GetSize();

	CSize buttonSize(m_nMaxButtonWidth, m_nMaxButtonHeight);

	if(m_bHorizontal)
	{
		sizeRtn.cy = 0;
		sizeRtn.cx = 0;
		for(int i = 0; i < nNumIcons; i++)
		{
			CTaskIconWnd *pIcon = (CTaskIconWnd*)m_TaskIconWndList[i];

			sizeButton = pIcon->GetRequiredButtonSize();
			sizeRtn.cx += sizeButton.cx; 

		}

		sizeRtn.cx += ((nNumIcons + 1) * m_nIconSpace);

		// Must allow for drag bar
		sizeRtn.cx += m_nDragBarWidth;
		
		// Make height proportional to the icon height
		sizeRtn.cy = buttonSize.cy + 6;
	}
	else // if vertical
	{
		sizeRtn.cy = sizeRtn.cx = 0;

		for(int i = 0; i < nNumIcons; i++)
		{
			CTaskIconWnd *pIcon = (CTaskIconWnd*)m_TaskIconWndList[i];

			sizeButton = pIcon->GetRequiredButtonSize();
			sizeRtn.cy += sizeButton.cy; 

		}

		sizeRtn.cy += ((nNumIcons + 1) * m_nIconSpace);

		// Must all for drag bar
		sizeRtn.cy += m_nDragBarWidth;

		//currently magic numbers to make it look the same size as when in horizontal position
		sizeRtn.cx = buttonSize.cx + 6;
	}
	
	#ifdef WIN32
		int nBorderWidth = ::GetSystemMetrics(SM_CXSIZEFRAME);
	#else
		int nBorderWidth = ::GetSystemMetrics(SM_CXFRAME);
	#endif

	sizeRtn.cx += nBorderWidth;
	//add the title bar
	sizeRtn.cy += GetSystemMetrics(SM_CYCAPTION);
	return(sizeRtn);
	
} // END OF	FUNCTION CTaskBar::CalcDesiredDim()

/****************************************************************************
*
*	CTaskBar::GetButtonDimensions
*
*	PARAMETERS:
*		None
*
*	RETURNS:
*		The size of a button depending upon the mode we are in
*
*	DESCRIPTION:
*		This function is called to determine the dimensions of a button on
*		the taskbar
*
****************************************************************************/
CSize CTaskBar::GetButtonDimensions(void)
{
		return( m_nToolbarStyle == TB_PICTURESANDTEXT ? m_noviceButtonSize : m_advancedButtonSize);
} // END OF FUNCTION CTaskBar::GetButtonDimensions()

/****************************************************************************
*
*	CTaskBar::SetTaskBarStyle
*
*	PARAMETERS:
*		nToolbarStyle The style we are changing to
*
*	RETURNS:
*		nothing
*
*	DESCRIPTION:
*		This function is called to change the taskbar style to nToolbarStyle
*
****************************************************************************/

void CTaskBar::SetTaskBarStyle(int nToolbarStyle)
{
	m_nToolbarStyle = nToolbarStyle;
	m_bShowText = m_nToolbarStyle != TB_PICTURES;
	ChangeButtonStyle();
}

  /****************************************************************************
*
*	CTaskBar::LayoutIcons
*
*	PARAMETERS:
*		None
*
*	RETURNS:
*		void
*
*	DESCRIPTION:
*		This protected helper function is called to arrange the task icons
*		appropriately within the task bar.
*
****************************************************************************/

void CTaskBar::LayoutIcons()
{
	int nX, nY;
	int nHSpace, nVSpace;

	// The idea is to space the icons evenly, allowing for the grab bar.
	CRect rc;
	GetClientRect(&rc);
	
	int nNumIcons = m_TaskIconWndList.GetSize();
	// If taskbar is horizontal, buttons have same height but different widths.  If
	// vertical, buttons have same width, but different heights.
	CSize sameSize = CSize(m_nMaxButtonWidth, m_nMaxButtonHeight);
	CSize individualButtonSize;

	if(m_bHorizontal)
	{
		rc.left += m_nDragBarWidth;

		nX = rc.left + m_nIconSpace;
		nVSpace = ((rc.Height() - (sameSize.cy)) + 1) / 2;
		nVSpace = (nVSpace > 0) ? nVSpace : 0;
		nY = rc.top + nVSpace;
	}
	else // if vertical
	{
		rc.top += m_nDragBarHeight;

		nY = rc.top + m_nIconSpace;
		nHSpace = ((rc.Width() - sameSize.cx) + 1) / 2;
		nHSpace = (nHSpace > 0) ? nHSpace : 0;
		nX = rc.left + nHSpace;
	}

	// Now re-size & re-position the icons
	for (int i = 0; i < m_TaskIconWndList.GetSize(); i++)
	{
		CTaskIconWnd * pIcon = m_TaskIconWndList.Get(i);
		individualButtonSize = pIcon->GetRequiredButtonSize();


		if(m_bHorizontal)
		{
			pIcon->MoveWindow(nX, nY, individualButtonSize.cx, sameSize.cy);
			nX += (individualButtonSize.cx + m_nIconSpace);
		}
		else
		{
			pIcon->MoveWindow(nX, nY, sameSize.cx, individualButtonSize.cy);
			nY += (individualButtonSize.cy + m_nIconSpace);
		}
	}

} // END OF	FUNCTION CTaskBar::LayoutIcons()

/****************************************************************************
*
*	CTaskBar::DragBarHitTest
*
*	PARAMETERS:
*		pt	- point to test
*
*	RETURNS:
*		TRUE if the given point lies within our drag bar, FALSE if not
*
*	DESCRIPTION:
*		This protected helper function is called to determine whether a
*		given point lies within our drag bar area.
*
****************************************************************************/

BOOL CTaskBar::DragBarHitTest(const CPoint & pt)
{
	CRect rc;
	GetClientRect(&rc);

	if(m_bHorizontal)
	{
		rc.right = m_nDragBarWidth;
	}
	else
	{
		rc.bottom = m_nDragBarHeight;
	}
	
	return(rc.PtInRect(pt));

} // END OF	FUNCTION CTaskBar::DragBarHitTest()


void CTaskBar::ChangeButtonStyle(void)
{
	int nCount = m_TaskIconWndList.GetSize();

	m_nMaxButtonWidth = m_nMaxButtonHeight = 0;

	for(int i = 0; i < nCount; i++)
	{
		CTaskIconWnd *pIcon = (CTaskIconWnd*)m_TaskIconWndList[i];

		pIcon->SetButtonMode(m_nToolbarStyle);

		CSize size = pIcon->GetRequiredButtonSize();
		
		if(m_nToolbarStyle != TB_PICTURESANDTEXT)
		{
			//for the moment we need to make the docked bar smaller than it should be
			//in order to make things fit
			size.cy -= 2;
		}

		if(size.cx > m_nMaxButtonWidth)
			m_nMaxButtonWidth = size.cx;

		if(size.cy > m_nMaxButtonHeight)
			m_nMaxButtonHeight = size.cy;

	}

}

void CTaskBar::ChangeButtonText(void)
{

	int nCount = m_TaskIconWndList.GetSize();

	m_nMaxButtonWidth = m_nMaxButtonHeight = 0;

	for(int i = 0; i < nCount; i++)
	{
		CTaskIconWnd *pIcon = (CTaskIconWnd*)m_TaskIconWndList[i];

		int idText = m_bHorizontal ? pIcon->GetHorizTextID() : pIcon->GetVertTextID();
		CString csText;
		csText.LoadString(idText);

		pIcon->SetText(csText);
		
		// Need to recalculate the maximum sizes
		CSize size = pIcon->GetRequiredButtonSize();
		
		if(size.cx > m_nMaxButtonWidth)
			m_nMaxButtonWidth = size.cx;

		if(size.cy > m_nMaxButtonHeight)
			m_nMaxButtonHeight = size.cy;
	}
}

void CTaskBar::ReplaceButtonBitmap(int nIndex, HBITMAP hBitmap)
{

	CTaskIconWnd *pIcon = (CTaskIconWnd*)m_TaskIconWndList[nIndex];

	pIcon->SetBitmap(hBitmap, TRUE);

	pIcon->Invalidate();

}

/****************************************************************************
*
*	Class: CFloatingTaskBar
*
*	DESCRIPTION:
*		This derived version of CTaskBar provides a "floating" task bar. It
*		is in the form of a custom popup window.
*
****************************************************************************/

/****************************************************************************
*
*	CONSTANTS
*
****************************************************************************/
static const UINT uID_DOCK = 0xff;	// Docking button ID
static const int nDOCK_BTN_W = 13;
static const int nDOCK_BTN_H = 13;

BEGIN_MESSAGE_MAP(CFloatingTaskBar, CFloatingTaskBarBase)
	//{{AFX_MSG_MAP(CFloatingTaskBar)
	ON_WM_CLOSE()
	ON_WM_MOUSEMOVE()
	ON_BN_CLICKED(uID_DOCK, OnDock)
	ON_WM_LBUTTONDBLCLK()
	ON_WM_RBUTTONUP()
	ON_WM_MOVE()
	ON_COMMAND(ID_TBAR_ALWAYSONTOP, OnAlwaysOnTop)
	ON_COMMAND(ID_TBAR_SHOWTEXT, OnShowText)
	ON_COMMAND(ID_TBAR_POSITION, OnPosition)
	ON_MESSAGE(TASKBAR_ADDMENU, OnAddMenu)
	ON_WM_SYSCOMMAND()
	ON_WM_INITMENU()
	ON_WM_CREATE()
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/****************************************************************************
*
*	CFloatingTaskBar::CFloatingTaskBar
*
*	PARAMETERS:
*		bOnTop		- TRUE if the 'always on top' style should be used
*		bShowText	- TRUE if button text should be shown
*		bHorizontal	- TRUE if task bar is oriented horizontally
*
*	RETURNS:
*		N/A
*
*	DESCRIPTION:
*		Constructor.
*
****************************************************************************/

CFloatingTaskBar::CFloatingTaskBar(int nToolbarStyle, BOOL bOnTop /*=TRUE*/, BOOL bHorizontal /*=TRUE*/)
	: CTaskBar(nToolbarStyle)
{
	m_noviceButtonSize.cx = 65;
	m_noviceButtonSize.cy = 43;
	m_advancedButtonSize.cx = 34;
	m_advancedButtonSize.cy = 24;

	m_IconSize.cx = 32;
	m_IconSize.cy = 22;

	m_nDragBarWidth = m_nDragBarHeight = 0;

	m_nIconSpace = 4;
	m_bActive = FALSE;
	
	m_bOnTop = bOnTop;
	m_bHorizontal = bHorizontal;
	m_bShowText = nToolbarStyle != TB_PICTURES;
	
} // END OF	FUNCTION CFloatingTaskBar::CFloatingTaskBar()

/****************************************************************************
*
*	CFloatingTaskBar::~CFloatingTaskBar
*
*	PARAMETERS:
*		N/A
*
*	RETURNS:
*		N/A
*
*	DESCRIPTION:
*		Destructor.
*
****************************************************************************/

CFloatingTaskBar::~CFloatingTaskBar()
{
	int test = 0;
} // END OF	FUNCTION CFloatingTaskBar::~CFloatingTaskBar()

/****************************************************************************
*
*	CFloatingTaskBar::Create
*
*	PARAMETERS:
*		pParent	- pointer to parent window
*
*	RETURNS:
*		TRUE if creation is successful, FALSE if not.
*
*	DESCRIPTION:
*		This function must be called after construction to create the task
*		bar.
*
****************************************************************************/

BOOL CFloatingTaskBar::Create(CWnd * pParent)
{
	BOOL bRtn = FALSE;
	
	CBrush brush;

	CString strClass = theApp.NSToolBarClass;
	
	CString strName("");
	DWORD dwExStyle = m_bOnTop ? WS_EX_TOPMOST : 0;

#ifdef WIN32
	bRtn = CFloatingTaskBarBase::CreateEx(dwExStyle | WS_EX_TOOLWINDOW | WS_EX_WINDOWEDGE, (const char *)strClass,
	(const char *)strName, WS_DLGFRAME | WS_BORDER | WS_POPUP | WS_SYSMENU ,
		0, 0, 0, 0, pParent->GetSafeHwnd(), NULL);
#else 
	bRtn = CFloatingTaskBarBase::CreateEx(dwExStyle, (const char *)strClass,
	(const char *)strName, WS_CAPTION | WS_POPUP | WS_SYSMENU ,
		0, 0, 0, 0, pParent->GetSafeHwnd(), NULL);
#endif


	return(bRtn);
	
} // END OF	FUNCTION CFloatingTaskBar::Create()

int CFloatingTaskBar::OnCreate( LPCREATESTRUCT lpCreateStruct )
{
	CFloatingTaskBarBase::OnCreate(lpCreateStruct);

	PostMessage(TASKBAR_ADDMENU, 0, 0L);
	return 0;
}
 

LRESULT CFloatingTaskBar::OnAddMenu(WPARAM wParam, LPARAM lParam)
{
	CMenu *pSysMenu = GetSystemMenu(FALSE);

	pSysMenu->RemoveMenu(SC_MAXIMIZE, MF_BYCOMMAND);
	pSysMenu->RemoveMenu(SC_MINIMIZE, MF_BYCOMMAND);
	pSysMenu->RemoveMenu(SC_RESTORE, MF_BYCOMMAND);
	pSysMenu->RemoveMenu(SC_SIZE, MF_BYCOMMAND);

	pSysMenu->InsertMenu(0, CASTUINT(MF_BYPOSITION | MF_STRING), ID_TBAR_ALWAYSONTOP, szLoadString(IDS_TASKBAR_ONTOP));
	pSysMenu->InsertMenu(1, CASTUINT(MF_BYPOSITION | MF_STRING), CASTUINT(ID_TBAR_POSITION), szLoadString(CASTUINT(m_bHorizontal ? IDS_VERTICAL : IDS_HORIZONTAL)));
	pSysMenu->InsertMenu(2, CASTUINT(MF_BYPOSITION | MF_STRING), CASTUINT(ID_TBAR_SHOWTEXT), szLoadString(CASTUINT(m_bShowText ? IDS_TASKBAR_HIDETEXT : IDS_TASKBAR_SHOWTEXT))); 
	pSysMenu->InsertMenu(3, CASTUINT(MF_BYPOSITION | MF_SEPARATOR));

	return 1;
}
/****************************************************************************
*
*	CFloatingTaskBar::OnClose
*
*	PARAMETERS:
*		None
*
*	RETURNS:
*		void
*
*	DESCRIPTION:
*		We process WM_CLOSE so we can actually dock instead.
*
****************************************************************************/

void CFloatingTaskBar::OnClose()
{
	// Tell the task bar Manager to dock
	OnDock();
	
} // END OF	FUNCTION CFloatingTaskBar::OnClose()

/****************************************************************************
*
*	CFloatingTaskBar::OnDock
*
*	PARAMETERS:
*		None
*
*	RETURNS:
*		void
*
*	DESCRIPTION:
*		This is the handler for the dock button. It can be called to dock
*		the task bar (change to docked state).
*
****************************************************************************/

void CFloatingTaskBar::OnDock()
{
	((CNetscapeApp *)AfxGetApp())->GetTaskBarMgr().OnDockTaskBar();

} // END OF	FUNCTION CFloatingTaskBar::OnDock()

/****************************************************************************
*
*	CFloatingTaskBar::DoPaint
*
*	PARAMETERS:
*		dc	- reference to dc for painting
*
*	RETURNS:
*		void
*
*	DESCRIPTION:
*		Virtual handler for the paint message. Here's where we do all our
*		specialized drawing for our task bar.
*
****************************************************************************/

void CFloatingTaskBar::DoPaint(CPaintDC & dc)
{
	
} // END OF	FUNCTION CFloatingTaskBar::DoPaint()

/****************************************************************************
*
*	CFloatingTaskBar::PaintDragBar
*
*	PARAMETERS:
*		pdc	- pointer to dc to draw on
*
*	RETURNS:
*		void
*
*	DESCRIPTION:
*		Protected helper for painting our custom window caption.
*
****************************************************************************/

void CFloatingTaskBar::PaintDragBar(CDC * pdc)
{
	CRect rcClient;
	GetClientRect(&rcClient);
	
	if(m_bHorizontal)
	{
		// Draw a 3-d border to the right of the drag bar
		CRect rcTmp(m_nDragBarWidth, 0, m_nDragBarWidth + 1, rcClient.bottom);
		CBrush brShadow(::GetSysColor(COLOR_BTNSHADOW));
		pdc->FillRect(rcTmp, &brShadow);
		rcTmp.OffsetRect(1, 0);
		CBrush brHilight(::GetSysColor(COLOR_BTNHIGHLIGHT));
		pdc->FillRect(rcTmp, &brHilight);

		// Draw a 3-d "grip"
		for (int i = nDOCK_BTN_H + 2; i < (rcClient.bottom - 2); i += 3)
		{
			rcTmp.SetRect(1, i, m_nDragBarWidth - 1, i + 1);
			pdc->FillRect(rcTmp, &brShadow);
			rcTmp.SetRect(1, i + 1, m_nDragBarWidth - 1, i + 2);
			pdc->FillRect(rcTmp, &brHilight);
		}
	}
	else // if vertical
	{
		CRect rcTmp(0, m_nDragBarHeight, rcClient.right, m_nDragBarWidth + 1);
		CBrush brShadow(::GetSysColor(COLOR_BTNSHADOW));
		pdc->FillRect(rcTmp, &brShadow);
		rcTmp.OffsetRect(0, 1);
		CBrush brHilight(::GetSysColor(COLOR_BTNHIGHLIGHT));
		pdc->FillRect(rcTmp, &brHilight);

		// Draw a 3-d "grip"
		for (int i = nDOCK_BTN_W + 2; i < (rcClient.right - 2); i += 3)
		{
			rcTmp.SetRect(i, 1, i + 1, m_nDragBarHeight - 1);
			pdc->FillRect(rcTmp, &brShadow);
			rcTmp.SetRect(i + 1, 1,  i + 2, m_nDragBarHeight - 1);
			pdc->FillRect(rcTmp, &brHilight);
		}



	}
	
} // END OF	FUNCTION CFloatingTaskBar::PaintDragBar()

/****************************************************************************
*
*	CFloatingTaskBar::OnMouseMove
*
*	PARAMETERS:
*		nFlags	- control key flags
*		point	- cursor coordinate
*
*	RETURNS:
*		void
*
*	DESCRIPTION:
*		We process this message to allow the user to move the floating task
*		bar around, since we're not a normal window and have no title bar.
*
****************************************************************************/

void CFloatingTaskBar::OnMouseMove(UINT nFlags, CPoint point) 
{
	CFloatingTaskBarBase::OnMouseMove(nFlags, point);

	// Are we being dragged?
	if (nFlags & MK_LBUTTON)
	{
		// By the drag bar?
		if (DragBarHitTest(point))
		{
			// Start the drag process
			CRect rc;
			GetWindowRect(&rc);
			CRectTracker Tracker(&rc, CRectTracker::solidLine);
			Tracker.m_sizeMin.cx = rc.Width();
			Tracker.m_sizeMin.cy = rc.Height();
			ClientToScreen(&point);
			if (Tracker.Track(this, point, FALSE, GetDesktopWindow()))
			{
				// User released and position changed
				rc = Tracker.m_rect;
				ClientToScreen(&rc);
				MoveWindow(&rc);
				
				// Inform task bar manager of our new position
				((CNetscapeApp *)AfxGetApp())->GetTaskBarMgr().SetLastFloatPos(
					rc.TopLeft());
			}
		}
	}
		
} // END OF	FUNCTION CFloatingTaskBar::OnMouseMove()

/****************************************************************************
*
*	CFloatingTaskBar::OnLButtonDblClk
*
*	PARAMETERS:
*		nFlags	- control key flags
*		point	- cursor coordinate
*
*	RETURNS:
*		void
*
*	DESCRIPTION:
*		We process this message so user can dock us by double-clicking on
*		the drag bar.
*
****************************************************************************/

void CFloatingTaskBar::OnLButtonDblClk(UINT nFlags, CPoint point) 
{
	CFloatingTaskBarBase::OnLButtonDblClk(nFlags, point);
	
	if (DragBarHitTest(point))
	{
		OnDock();
	}
	
} // END OF	FUNCTION CFloatingTaskBar::OnLButtonDblClk()

/****************************************************************************
*
*	CFloatingTaskBar::OnRButtonUp
*
*	PARAMETERS:
*		nFlags	- control key flags
*		point	- cursor coordinate
*
*	RETURNS:
*		void
*
*	DESCRIPTION:
*		We process this handler so we can display the right mouse pop-up
*		menu.
*
****************************************************************************/

void CFloatingTaskBar::OnRButtonUp(UINT nFlags, CPoint point) 
{
	CMenu Menu;
	if (Menu.LoadMenu(IDR_TASKBAR_POPUP))
	{
		CMenu * pSubMenu = Menu.GetSubMenu(0);
		SetMenuState(pSubMenu);
		ClientToScreen(&point);
		pSubMenu->TrackPopupMenu(TPM_LEFTALIGN | TPM_LEFTBUTTON,
			point.x, point.y, this);
	}
	
	CFloatingTaskBarBase::OnRButtonUp(nFlags, point);
	
} // END OF	FUNCTION CFloatingTaskBar::OnRButtonUp()

void CFloatingTaskBar::OnMove( int x, int y )
{
	CPoint point(x - GetSystemMetrics(SM_CXDLGFRAME),y - GetSystemMetrics(SM_CYCAPTION) -  GetSystemMetrics(SM_CYDLGFRAME));

	// Inform task bar manager of our new position
	((CNetscapeApp *)AfxGetApp())->GetTaskBarMgr().SetLastFloatPos(point);

	CFloatingTaskBarBase::OnMove(x,y);

}

/****************************************************************************
*
*	CFloatingTaskBar::SetMenuState
*
*	PARAMETERS:
*		pMenu	- pointer to popup menu
*
*	RETURNS:
*		void
*
*	DESCRIPTION:
*		Helper function for setting the right mouse popup menu's state.
*
****************************************************************************/

void CFloatingTaskBar::SetMenuState(CMenu * pMenu)
{
	pMenu->CheckMenuItem(ID_TBAR_ALWAYSONTOP,
		m_bOnTop ? MF_CHECKED : MF_UNCHECKED);
	pMenu->ModifyMenu(ID_TBAR_POSITION, MF_BYCOMMAND | MF_STRING, CASTINT(ID_TBAR_POSITION),
                      szLoadString(CASTINT(m_bHorizontal ? IDS_VERTICAL : IDS_HORIZONTAL)) );
	pMenu->ModifyMenu(ID_TBAR_SHOWTEXT, MF_BYCOMMAND | MF_STRING, CASTINT(ID_TBAR_SHOWTEXT),
					  szLoadString(CASTINT(m_bShowText ? IDS_TASKBAR_HIDETEXT : IDS_TASKBAR_SHOWTEXT))); 



} // END OF	FUNCTION CFloatingTaskBar::SetMenuState()

/****************************************************************************
*
*	CFloatingTaskBar::OnAlwaysOnTop
*
*	PARAMETERS:
*		None
*
*	RETURNS:
*		void
*
*	DESCRIPTION:
*		Command handler for the "Always On Top" menu item.
*
****************************************************************************/

void CFloatingTaskBar::OnAlwaysOnTop() 
{
	if (m_bOnTop)
	{
		m_bOnTop = FALSE;
		SetWindowPos(&wndNoTopMost, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
	}
	else
	{
		m_bOnTop = TRUE;
		SetWindowPos(&wndTopMost, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
	}
	
	// Inform task bar manager of our new state
	((CNetscapeApp *)AfxGetApp())->GetTaskBarMgr().SetOnTop(m_bOnTop);
					
} // END OF	FUNCTION CFloatingTaskBar::OnAlwaysOnTop()

/****************************************************************************
*
*	CFloatingTaskBar::OnShowText
*
*	PARAMETERS:
*		None
*
*	RETURNS:
*		void
*
*	DESCRIPTION:
*		Command handler for "Show Text" menu item.
*
****************************************************************************/

void CFloatingTaskBar::OnShowText() 
{
	m_bShowText = !m_bShowText;
	
	// Inform task bar manager of our new state
	((CNetscapeApp *)AfxGetApp())->GetTaskBarMgr().SetSeparateTaskBarStyle(m_bShowText ?  TB_PICTURESANDTEXT : TB_PICTURES);

} // END OF	FUNCTION CFloatingTaskBar::OnShowText()

/****************************************************************************
*
*	CFloatingTaskBar::OnPosition
*
*	PARAMETERS:
*		None
*
*	RETURNS:
*		void
*
*	DESCRIPTION:
*		Command handler for changing the Horizonta/Vertical menu item.
*
****************************************************************************/

void CFloatingTaskBar::OnPosition() 
{
	m_bHorizontal = !m_bHorizontal;
		
	// We need to set the new button text.
	ChangeButtonText();

	// Inform task bar manager of our new state
	((CNetscapeApp *)AfxGetApp())->GetTaskBarMgr().SetHorizontal(m_bHorizontal);
	
} // END OF	FUNCTION CFloatingTaskBar::OnHorizontal()


void CFloatingTaskBar::OnSysCommand( UINT nID, LPARAM lParam )
{
	if(nID == ID_TBAR_ALWAYSONTOP)
		OnAlwaysOnTop();
	else if(nID == ID_TBAR_POSITION)
		OnPosition();
	else if(nID == ID_TBAR_SHOWTEXT)
		OnShowText();
	else
		CFloatingTaskBarBase::OnSysCommand(nID, lParam);


}

void CFloatingTaskBar::OnInitMenu( CMenu* pMenu )
{

	pMenu->CheckMenuItem(ID_TBAR_ALWAYSONTOP, m_bOnTop ? MF_CHECKED : MF_UNCHECKED);
	pMenu->ModifyMenu(ID_TBAR_POSITION, MF_BYCOMMAND | MF_STRING, CASTUINT(ID_TBAR_POSITION),
                     szLoadString(CASTUINT(m_bHorizontal ? IDS_VERTICAL : IDS_HORIZONTAL)) );
	pMenu->ModifyMenu(ID_TBAR_SHOWTEXT, MF_BYCOMMAND | MF_STRING, CASTUINT(ID_TBAR_SHOWTEXT),
					 szLoadString(CASTUINT(m_bShowText ? IDS_TASKBAR_HIDETEXT : IDS_TASKBAR_SHOWTEXT))); 

}

/****************************************************************************
*
*	Class: CDockedTaskBar
*
*	DESCRIPTION:
*		This derived version of CTaskBar provides a "docked" task bar. It is
*		in the form of a mini child window embedded within its parent
*		(normally a CNetscapeStatusBar).
*
****************************************************************************/

BEGIN_MESSAGE_MAP(CDockedTaskBar, CDockedTaskBarBase)
	//{{AFX_MSG_MAP(CDockedTaskBar)
	ON_WM_MOUSEMOVE()
	ON_WM_LBUTTONUP()
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/****************************************************************************
*
*	CDockedTaskBar::CDockedTaskBar
*
*	PARAMETERS:
*		None
*
*	RETURNS:
*		N/A
*
*	DESCRIPTION:
*		Constructor
*
****************************************************************************/

CDockedTaskBar::CDockedTaskBar(int nToolbarStyle)
: CTaskBar(nToolbarStyle)
{
	m_noviceButtonSize.cx = 27;
	m_noviceButtonSize.cy = 25;
	m_advancedButtonSize.cx = 27;
	m_advancedButtonSize.cy = 14;

	m_IconSize.cx = 25;
	m_IconSize.cy = 12;

	m_nDragBarWidth = 11;
	m_nIconSpace = 1;
	m_bShowText = FALSE;

} // END OF	FUNCTION CDockedTaskBar::CDockedTaskBar()

/****************************************************************************
*
*	CDockedTaskBar::~CDockedTaskBar
*
*	PARAMETERS:
*		N/A
*
*	RETURNS:
*		N/A
*
*	DESCRIPTION:
*		Destructor.
*
****************************************************************************/

CDockedTaskBar::~CDockedTaskBar()
{

} // END OF	FUNCTION CDockedTaskBar::~CDockedTaskBar()

/****************************************************************************
*
*	CDockedTaskBar::Create
*
*	PARAMETERS:
*		pParent	- pointer to the window in which the task bar is docked
*
*	RETURNS:
*		TRUE if creation is successful, FALSE if not.
*
*	DESCRIPTION:
*		This function must be called after construction to create the task
*		bar.
*
****************************************************************************/

BOOL CDockedTaskBar::Create(CWnd * pParent)
{
	BOOL bRtn = FALSE;
	
	CBrush brush;

	CString strClass = theApp.NSToolBarClass;
	
	CString strName;
	strName.LoadString(IDS_TBAR_NAME);
	bRtn = CDockedTaskBarBase::CreateEx(0, (const char *)strClass,
		(const char *)strName, WS_CHILD | WS_VISIBLE ,
		0, 0, 0, 0, pParent->GetSafeHwnd(), NULL);
		
	return(bRtn);
	
} // END OF	FUNCTION CDockedTaskBar::Create()

/****************************************************************************
*
*	CDockedTaskBar::DoPaint
*
*	PARAMETERS:
*		dc	- reference to dc for painting
*
*	RETURNS:
*		void
*
*	DESCRIPTION:
*		Virtual handler for the paint message. Here's where we do all our
*		specialized drawing for our task bar.
*
****************************************************************************/

void CDockedTaskBar::DoPaint(CPaintDC & dc)
{
	CRect rcClient;
	GetClientRect(&rcClient);
	
	// Draw a 3-d "grip" for the drag bar
	CRect rcTmp(rcClient);
	CBrush brHilight(::GetSysColor(COLOR_BTNHIGHLIGHT));
	CBrush brShadow(::GetSysColor(COLOR_BTNSHADOW));
	for (int i = 3; i < (rcClient.bottom - 2); i += 3)
	{
		rcTmp.SetRect(2, i, m_nDragBarWidth - 1, i + 1);
		dc.FillRect(rcTmp, &brShadow);
		rcTmp.SetRect(2, i + 1, m_nDragBarWidth - 1, i + 2);
		dc.FillRect(rcTmp, &brHilight);
	}

	// Draw a 3-d border to the right of the drag bar
	rcTmp.SetRect(m_nDragBarWidth, 0, m_nDragBarWidth + 1, rcClient.bottom);
	dc.FillRect(rcTmp, &brShadow);
	rcTmp.OffsetRect(1, 0);
	dc.FillRect(rcTmp, &brHilight);
	
	
	// Now draw our 3-d edge borders
	
	// Left and top edges
	rcTmp.SetRect(rcClient.left, rcClient.top, 1, rcClient.bottom);
	dc.FillRect(rcTmp, &brHilight);
	rcTmp.SetRect(rcClient.left, rcClient.top, rcClient.right, 1);
	dc.FillRect(rcTmp, &brHilight);
	
	// Right and bottom
	rcTmp.SetRect(rcClient.left, rcClient.bottom - 1, rcClient.right,
		rcClient.bottom);
	dc.FillRect(rcTmp, &brShadow);
	rcTmp.SetRect(rcClient.right - 1, rcClient.top, rcClient.right,
		rcClient.bottom);
	dc.FillRect(rcTmp, &brShadow);
	
} // END OF	FUNCTION CDockedTaskBar::DoPaint()

/****************************************************************************
*
*	CDockedTaskBar::OnMouseMove
*
*	PARAMETERS:
*		nFlags	- control key flags
*		point	- cursor coordinate
*
*	RETURNS:
*		void
*
*	DESCRIPTION:
*		We process this message to allow the user to drag the docked task
*		bar off and "undock" it.
*
****************************************************************************/

void CDockedTaskBar::OnMouseMove(UINT nFlags, CPoint point) 
{
	CDockedTaskBarBase::OnMouseMove(nFlags, point);

	// Are we being dragged?
	if (nFlags & MK_LBUTTON)
	{
		// By the drag bar?
		if (DragBarHitTest(point))
		{
			// Start the drag process
			CRect rc;
			GetWindowRect(&rc);
			CRectTracker Tracker(&rc, CRectTracker::solidLine);
			Tracker.m_sizeMin.cx = rc.Width();
			Tracker.m_sizeMin.cy = rc.Height();
			ClientToScreen(&point);
			if (Tracker.Track(this, point, FALSE, GetDesktopWindow()))
			{
				// User released, so undock.
				rc = Tracker.m_rect;
				ClientToScreen(&rc);
				OnUnDock(rc.TopLeft());
			}
		}
	}
		
} // END OF	FUNCTION CDockedTaskBar::OnMouseMove()

/****************************************************************************
*
*	CDockedTaskBar::OnLButtonUp
*
*	PARAMETERS:
*		nFlags	- control key flags
*		point	- cursor coordinate
*
*	RETURNS:
*		void
*
*	DESCRIPTION:
*		We process this message so user can un-dock us by clicking on
*		the drag bar.
*
****************************************************************************/

void CDockedTaskBar::OnLButtonUp(UINT nFlags, CPoint point) 
{
	CDockedTaskBarBase::OnLButtonUp(nFlags, point);
	
	if (DragBarHitTest(point))
	{
		OnUnDock();
	}
	
} // END OF	FUNCTION CDockedTaskBar::OnLButtonUp()

/****************************************************************************
*
*	CDockedTaskBar::OnUnDock
*
*	PARAMETERS:
*		ptUL	- upper left corner for new floating task bar, or -1,-1 
*				  for default location.
*
*	RETURNS:
*		void
*
*	DESCRIPTION:
*		This function is called to un-dock the task bar (changed to floating
*		state).
*
****************************************************************************/

void CDockedTaskBar::OnUnDock(CPoint & ptUL /*= (-1,-1)*/)
{
	((CNetscapeApp *)AfxGetApp())->GetTaskBarMgr().OnUnDockTaskBar(ptUL);

} // END OF	FUNCTION CDockedTaskBar::OnUnDock()


/****************************************************************************
*
*	Class: CTaskBarArray
*
*	DESCRIPTION:
*		This is a container class for holding CTaskBar objects.
*
****************************************************************************/

/****************************************************************************
*
*	CTaskBarArray::DeleteAll
*
*	PARAMETERS:
*		None
*
*	RETURNS:
*		void
*
*	DESCRIPTION:
*		This functions is called to delete all of the CTaskBar objects
*		in the container.
*
****************************************************************************/

void CTaskBarArray::DeleteAll()
{
	for (int i = 0; i < GetSize(); i++)
	{
		CTaskBar * pTaskBar = Get(i);
		if (pTaskBar != NULL)
		{
			pTaskBar->DestroyWindow();
			// no need to call delete - pTaskBar has auto cleanup
		}
	}
	RemoveAll();

} // END OF	FUNCTION CTaskBarArray::DeleteAll()

/****************************************************************************
*
*	CTaskBarArray::Find
*
*	PARAMETERS:
*		pTaskBar	- pointer to object to located
*
*	RETURNS:
*		Index of the object if found, -1 if not.
*
*	DESCRIPTION:
*		This function is called to search the list for a given object.
*
****************************************************************************/

int CTaskBarArray::Find(CTaskBar * pTaskBar)
{
	int nRtn = -1;
	
	BOOL bFound = FALSE;
	for (int i = 0; (i < GetSize()) && !bFound; i++)
	{
		if (Get(i) == pTaskBar)
		{
			nRtn = i;
			bFound = TRUE;
		}
	}
	
	return(nRtn);

} // END OF	FUNCTION CTaskBarArray::Find()


/****************************************************************************
*
*	Class: CTaskBarMgr
*
*	DESCRIPTION:
*		This class provides an object for managing all task bars within
*		the system. It maintains the abstract data for all active task icons
*		and handles the generation and switching between floating, docked or
*		other style task bars. All task bar operations should be piped though
*		this object so it can handle propagation to the appropriate active
*		task bar(s).
*
*		There are also some convenience functions available, for such actions
*		as adding a common set of task icons.
*
****************************************************************************/

/****************************************************************************
*
*	CTaskBarMgr::CTaskBarMgr
*
*	PARAMETERS:
*		None
*
*	RETURNS:
*		N/A
*
*	DESCRIPTION:
*		Constructor.
*
****************************************************************************/

CTaskBarMgr::CTaskBarMgr()
{
	m_bInitialized = FALSE;
	m_ptLastFloatPos = CPoint(-1, -1);
	m_dwStateFlags = 0;
	m_bSeparateTaskBarStyle = FALSE;
	m_nReference = 0;

} // END OF	FUNCTION CTaskBarMgr::CTaskBarMgr()

/****************************************************************************
*
*	CTaskBarMgr::~CTaskBarMgr
*
*	PARAMETERS:
*		N/A
*
*	RETURNS:
*		N/A
*
*	DESCRIPTION:
*		Destructor.
*
****************************************************************************/

CTaskBarMgr::~CTaskBarMgr()
{

} // END OF	FUNCTION CTaskBarMgr::~CTaskBarMgr()

/****************************************************************************
*
*	CTaskBarMgr::Init
*
*	PARAMETERS:
*		None
*
*	RETURNS:
*		TRUE if initialization is successful
*
*	DESCRIPTION:
*		This function must be called after construction to initialize the
*		task bar manager.
*
****************************************************************************/

BOOL CTaskBarMgr::Init()
{
	// Don't allow multiple initialization
	BOOL bRtn = !m_bInitialized;
	ASSERT(bRtn);
	if (bRtn)
	{
		m_bInitialized = TRUE;
		bRtn = CreateAllTaskBars();
	}
	
	return(bRtn);
	
} // END OF	FUNCTION CTaskBarMgr::Init()

void CTaskBarMgr::LoadPrefs(BOOL bAlwaysDock)
{
	CPoint ptTB;
	int32 x, y, nButtonStyle;
	PREF_GetIntPref("taskbar.x", &x);
	PREF_GetIntPref("taskbar.y", &y);
#ifdef XP_WIN32
	ptTB.x =x;
	ptTB.y =y;
#else
	ptTB.x =CASTINT(x);
	ptTB.y =CASTINT(y);
#endif
	SetLastFloatPos(ptTB);
	BOOL bFloating, bHorizontal, bOnTop;

	if(bAlwaysDock)
		bFloating = FALSE;
	else
		PREF_GetBoolPref("taskbar.floating", &bFloating);

	PREF_GetBoolPref("taskbar.horizontal", &bHorizontal);
	PREF_GetBoolPref("taskbar.ontop", &bOnTop);
    DWORD dwStates = 0;
	dwStates = dwStates | (bFloating ? TBAR_FLOATING : 0) | (bHorizontal ? TBAR_HORIZONTAL : 0) |
		(bOnTop ? TBAR_ONTOP : 0);
	SetStateFlags(dwStates);

	PREF_GetIntPref("taskbar.button_style", &nButtonStyle);
	if(nButtonStyle == -1)
		m_nTaskBarStyle = theApp.m_pToolbarStyle;
	else
	{
		m_nTaskBarStyle = CASTINT(nButtonStyle);
		m_bSeparateTaskBarStyle = TRUE;
	}

	Init();
	AddStandardIcons();
}

void CTaskBarMgr::SavePrefs(void)
{
	DWORD dwState = GetStateFlags();
	PREF_SetBoolPref("taskbar.floating", IsFloating());
	PREF_SetBoolPref("taskbar.horizontal", IsHorizontal());
	PREF_SetBoolPref("taskbar.ontop", IsOnTop());
	CPoint ptTB =GetLastFloatPos();
	PREF_SetIntPref("taskbar.x", ptTB.x);
	PREF_SetIntPref("taskbar.y", ptTB.y);

	if(m_bSeparateTaskBarStyle)
		PREF_SetIntPref("taskbar.button_style", m_nTaskBarStyle);
}

/**********************************************************************************************
*
*	CTaskBarMgr::AllTaskBars
*
*	PARAMETERS:
*		None
*
*	RETURNS:
*		TRUE if successful, FALSE if not.
*
*	DESCRIPTION:
*		Protected helper function for generating all task bars (either one
*		floating or any number of docked) from our abstract icon data list.
*
****************************************************************************/

BOOL CTaskBarMgr::CreateAllTaskBars()
{
	BOOL bRtn = FALSE;
	ASSERT(m_bInitialized);
	
	// Should be starting clean, or call DestroyAllTaskBars() first
	ASSERT(m_TaskBarList.GetSize() == 0);
	
	if (IsFloating())
	{
		// Create a single floating task bar
		bRtn = CreateFloatingTaskBar();
	}
	else
	{
		// Create docked task bars for each status bar
		for (int i = 0; i < m_StatBarList.GetSize(); i++)
		{
			CreateDockedTaskBar((CNetscapeStatusBar *)(m_StatBarList.GetAt(i)));
		}
	}
	
	return(bRtn);

} // END OF	FUNCTION CTaskBarMgr::CreateAllTaskBars()

/****************************************************************************
*
*	CTaskBarMgr::DestroyAllTaskBars
*
*	PARAMETERS:
*		None
*
*	RETURNS:
*		void
*
*	DESCRIPTION:
*		Protected helper function for destroying all active task bars,
*		floating or docked.
*
****************************************************************************/

void CTaskBarMgr::DestroyAllTaskBars()
{
	m_TaskBarList.DeleteAll();

	// Must return the status bar pane to 0 size
	for (int i = 0; i < m_StatBarList.GetSize(); i++)
	{
		CNetscapeStatusBar * pSB =
			(CNetscapeStatusBar *)m_StatBarList.GetAt(i);
        if( !pSB )
        { 
            continue;
        }
    	pSB->SetTaskBarPaneWidth( 0 );
	}
				
	m_StatBarMap.RemoveAll();
	
} // END OF	FUNCTION CTaskBarMgr::DestroyAllTaskBars()

/****************************************************************************
*
*	CTaskBarMgr::RegisterStatusBar
*
*	PARAMETERS:
*		pStatBar	- pointer to the status bar being registered
*
*	RETURNS:
*		void
*
*	DESCRIPTION:
*		This function should be called whenever a new status bar is	created
*		and it is desirable to have task bars docked within it. The new
*		status bar is added to the list maintained by the task bar manager -
*		UnRegisterStatusBar() should be called when the status bar is
*		destroyed or no longer wants to have task bars docked within it.
*
****************************************************************************/

void CTaskBarMgr::RegisterStatusBar(CNetscapeStatusBar * pStatBar)
{

	
	
	m_StatBarList.Add(pStatBar);
	
	// It's perfectly OK for frame windows to register their status bars
	// with us before we're initialized, but we don't create a task bar for
	// it unless we are (and if we're also in the docked state).
	if (m_bInitialized && !IsFloating())
	{
		CreateDockedTaskBar(pStatBar);
	}

} // END OF	FUNCTION CTaskBarMgr::RegisterStatusBar()

/****************************************************************************
*
*	CTaskBarMgr::UnRegisterStatusBar
*
*	PARAMETERS:
*		pStatBar	- pointer to the status bar being unregistered
*
*	RETURNS:
*		void
*
*	DESCRIPTION:
*		This function should be called whenever a status bar is destroyed or
*		no longer wants to have task bars docked within it. It removes it
*		from the list maintained by the task bar manager.
*
****************************************************************************/

void CTaskBarMgr::UnRegisterStatusBar(CNetscapeStatusBar * pStatBar)
{
	// Find the given status bar in our list
	BOOL bDone = FALSE;
	for (int i = 0; (i < m_StatBarList.GetSize()) && !bDone; i++)
	{
		CNetscapeStatusBar * pSB =
			(CNetscapeStatusBar *)m_StatBarList.GetAt(i);
		if (pSB == pStatBar)
		{
			// Found it, so take it out of our list
			bDone = TRUE;
			m_StatBarList.RemoveAt(i);
			
			// If there's a task bar embedded in this status bar, it will
			// be destroyed automatically, so don't worry about deleting
			// the object. However, we do need to eliminate it from our
			// list of active task bars, and break the association in the map.
			CTaskBar * pTB = NULL;
			if (m_StatBarMap.Lookup(pStatBar, (void * &)pTB))
			{
				// Remove map entry
				m_StatBarMap.RemoveKey(pStatBar);
				
				// Now remove the task bar from the list
				int i = m_TaskBarList.Find(pTB);
				if (i > -1)
				{
					m_TaskBarList.RemoveAt(i);
				}
			}
		}
	}

} // END OF	FUNCTION CTaskBarMgr::UnRegisterStatusBar()

/****************************************************************************
*
*	CTaskBarMgr::OnSizeStatusBar
*
*	PARAMETERS:
*		pStatBar	- pointer to the status bar whose size has changed
*
*	RETURNS:
*		void
*
*	DESCRIPTION:
*		This function is called by a registered status bar when it has been
*		resized. Since we have to be in control of all task bars, we're
*		responsible of repositioning any that are docked on the given status
*		bar.
*
****************************************************************************/

void CTaskBarMgr::OnSizeStatusBar(CNetscapeStatusBar * pStatBar)
{
	if (!IsFloating())
	{
		CDockedTaskBar * pTB = NULL;
		if (m_StatBarMap.Lookup(pStatBar, (void * &)pTB))
		{
			AdjustStatusPane(pTB, pStatBar);
			PlaceOnStatusBar(pTB, pStatBar);
		}
	}

} // END OF	FUNCTION CTaskBarMgr::OnSizeStatusBar()

/****************************************************************************
*
*	CTaskBarMgr::CreateDockedTaskBar
*
*	PARAMETERS:
*		pStatBar	- pointer to status bar that houses the task bar
*
*	RETURNS:
*		TRUE if successful, FALSE if not.
*
*	DESCRIPTION:
*		Protected helper function for specifically creating a docked task bar.
*
****************************************************************************/

BOOL CTaskBarMgr::CreateDockedTaskBar(CNetscapeStatusBar * pStatBar)
{
	BOOL bRtn = ((pStatBar != NULL) && ::IsWindow(pStatBar->GetSafeHwnd()));

	if (bRtn)
	{
		CDockedTaskBar * pTB = new CDockedTaskBar(TB_PICTURES);
		ASSERT(pTB != NULL);
		if (pTB != NULL)
		{
			// Create, add to active list and the map
			bRtn = pTB->Create(pStatBar);
			m_TaskBarList.Add(pTB);
			m_StatBarMap.SetAt(pStatBar, pTB);
			
			// Add the icons
			AddIconsToTaskBar(pTB);
			
			// Embed the thing in the status bar. This consists of changing
			// the pane info to the correct width and moving the task bar
			// to that location.
			AdjustStatusPane(pTB, pStatBar);
			PlaceOnStatusBar(pTB, pStatBar);
		}
	}	
	
	return(bRtn);
	
} // END OF	FUNCTION CTaskBarMgr::CreateDockedTaskBar()

/****************************************************************************
*
*	CTaskBarMgr::AdjustStatusPane
*
*	PARAMETERS:
*		pTaskBar	- pointer to task bar
*		pStatBar	- status bar that houses it
*
*	RETURNS:
*		void
*
*	DESCRIPTION:
*		Protected helper function for adjusting the status pane so that
*		the docked task bar will fit within it.
*
****************************************************************************/

void CTaskBarMgr::AdjustStatusPane(CDockedTaskBar * pTaskBar,
	CNetscapeStatusBar * pStatBar)
{
	CSize sizeTB = pTaskBar->CalcDesiredDim();
    pStatBar->SetTaskBarPaneWidth( sizeTB.cx );
} // END OF	FUNCTION CTaskBarMgr::AdjustStatusPane()

/****************************************************************************
*
*	CTaskBarMgr::PlaceOnStatusBar
*
*	PARAMETERS:
*		pTaskBar	- pointer to task bar to be positioned
*		pStatBar	- status bar that houses it
*
*	RETURNS:
*		void
*
*	DESCRIPTION:
*		This protected helper function is called to place a docked task bar
*		in the correct pane of a status bar. AdjustStatusPane() should have
*		been called at some prior time to set the pane to the proper width.
*
****************************************************************************/

void CTaskBarMgr::PlaceOnStatusBar(CDockedTaskBar * pTaskBar,
	CNetscapeStatusBar * pStatBar)
{
	pStatBar->SetTaskBarSize( pTaskBar );
} // END OF	FUNCTION CTaskBarMgr::PlaceOnStatusBar()

/****************************************************************************
*
*	CTaskBarMgr::PositionDockedTaskBars
*
*	PARAMETERS:
*		None
*
*	RETURNS:
*		void
*
*	DESCRIPTION:
*		Protected helper function called to position all task bars that are
*		docked within status bars. This is needed after icons are added or
*		removed dynamically. First, the status bar pane is set to the desired
*		width, then the task bar is positioned within it.
*
****************************************************************************/

void CTaskBarMgr::PositionDockedTaskBars()
{
	if (!IsFloating())
	{
		for (int i = 0; i < m_StatBarList.GetSize(); i++)
		{
			CNetscapeStatusBar * pSB =
				(CNetscapeStatusBar *)m_StatBarList.GetAt(i);
			CDockedTaskBar * pTB = NULL;
			if (m_StatBarMap.Lookup(pSB, (void * &)pTB))
			{
				AdjustStatusPane(pTB, pSB);
				PlaceOnStatusBar(pTB, pSB);
			}
		}
	}

} // END OF	FUNCTION CTaskBarMgr::PositionDockedTaskBars()

/****************************************************************************
*
*	CTaskBarMgr::PositionFloatingTaskBar
*
*	PARAMETERS:
*		None
*
*	RETURNS:
*		void
*
*	DESCRIPTION:
*		Protected helper function called to position the floating task bar.
*
****************************************************************************/

void CTaskBarMgr::PositionFloatingTaskBar()
{
	if (IsFloating())
	{
		// First, see how big it wants to be
		CTaskBar * pTB = m_TaskBarList.Get(0);
		ASSERT(pTB != NULL);
		CSize sizeTB = pTB->CalcDesiredDim();
		
		// For the upper left corner, we first try using the last known
		// coordinates, and if that fails, use the top right of the screen.
		int nX = 0, nY = 0;
		if (m_ptLastFloatPos != CPoint(-1, -1))
		{
			nX = m_ptLastFloatPos.x;
			nY = m_ptLastFloatPos.y;
		}
		else
		{
			CGenericFrame * pFrame = (CGenericFrame * )FEU_GetLastActiveFrame();
			ASSERT(pFrame != NULL);
			if (pFrame != NULL)
			{
				RECT rect;
				pFrame->GetWindowRect(&rect);
						
				int nCaptionHeight = ::GetSystemMetrics(SM_CYCAPTION);
	#ifdef WIN32
				int nBorderHeight = ::GetSystemMetrics(SM_CYSIZEFRAME);
	#else
				int nBorderHeight = ::GetSystemMetrics(SM_CYFRAME);
	#endif

				int nCaptionButtonWidth = ::GetSystemMetrics(SM_CXSIZE);
				CSize taskbarButtonSize = pTB->GetButtonDimensions();

				if(IsHorizontal())
				{

					nX = (int) (rect.right - sizeTB.cx - (( 4.5 * nCaptionButtonWidth )));
					nY = rect.top + nCaptionHeight + nBorderHeight + 2 - sizeTB.cy;
				}
				else
				{
					nX = (int) (rect.right + 2);
					nY = rect.top + nCaptionHeight + nBorderHeight;
				}
			}
				
			// DON'T set m_ptLastFloatPos here - leave it set to -1,-1 so
			// we default each time, until the user has moved the task bar
			// and it is set properly.
		}
		
		// make it repaint itself since it might have to repaint the drag bars.
		pTB->Invalidate();
		// Reposition the window
		// make sure it doesn't go off the screen
		int nScreenHeight = ::GetSystemMetrics(SM_CYFULLSCREEN);
		int nScreenWidth = ::GetSystemMetrics(SM_CXFULLSCREEN);

		if(nY > nScreenHeight + sizeTB.cy)
			nY = 0;
		else if(nY + sizeTB.cy > nScreenHeight)
			nY = nScreenHeight - sizeTB.cy;
		else if(nY < 0)
			nY = 0;

		if(nX > nScreenWidth + sizeTB.cx)
			nX = 0;
		else if(nX + sizeTB.cx > nScreenWidth)
			nX = nScreenWidth - sizeTB.cx;
		else if(nX < 0)
			nX = 0;


		pTB->MoveWindow(nX, nY, sizeTB.cx, sizeTB.cy);
	}

} // END OF	FUNCTION CTaskBarMgr::PositionFloatingTaskBar()

/****************************************************************************
*
*	CTaskBarMgr::CreateFloatingTaskBar
*
*	PARAMETERS:
*		None
*
*	RETURNS:
*		TRUE if successful, FALSE if not.
*
*	DESCRIPTION:
*		Protected helper function for specifically creating a floating task
*		bar.
*
****************************************************************************/

BOOL CTaskBarMgr::CreateFloatingTaskBar()
{
	BOOL bRtn = FALSE;

	CPoint oldPoint = m_ptLastFloatPos;

	CFloatingTaskBar * pTB = new CFloatingTaskBar(m_nTaskBarStyle, IsOnTop(), IsHorizontal());
	ASSERT(pTB != NULL);
	if (pTB != NULL)
	{
		bRtn = pTB->Create(AfxGetMainWnd());
		
		if (bRtn)
		{
			
			if(m_nReference > 0)
				pTB->ShowWindow(SW_SHOWNA);
			// Put it in our active list and fill it with existing icons
			m_TaskBarList.Add(pTB);
			AddIconsToTaskBar(pTB);
			m_ptLastFloatPos = oldPoint;
			PositionFloatingTaskBar();
		}
	}
	
	return(bRtn);
	
} // END OF	FUNCTION CTaskBarMgr::CreateFloatingTaskBar()

void CTaskBarMgr::ReloadIconBitmaps(CTaskBar *pTaskBar)
{

	HBITMAP hBitmap = NULL;
	int nSize = m_IconList.GetSize();

	int i;

	// First remove all of the bitmaps from the map.
	for(i = 0; i < nSize; i++)
	{
		CTaskIcon * pIcon = m_IconList.Get(i);
		int idBmp = pIcon->GetLargeBmpID();

		WFE_RemoveBitmapFromMap(idBmp);
			
		idBmp = pIcon->GetSmallBmpID();

		WFE_RemoveBitmapFromMap(idBmp);
	}

	// Now replace the bitmaps
	for(i = 0; i < nSize; i++)
	{
		CTaskIcon * pIcon = m_IconList.Get(i);
		int idBmp = IsFloating() ? pIcon->GetLargeBmpID() :
			pIcon->GetSmallBmpID();

		HDC hDC = GetDC(pTaskBar->m_hWnd);
		hBitmap = WFE_LookupLoadAndEnterBitmap(hDC, idBmp, TRUE, 
											WFE_GetUIPalette(pTaskBar->GetParentFrame()), 
											   GetSysColor(COLOR_BTNFACE), RGB(255, 0, 255));
		ReleaseDC(pTaskBar->m_hWnd, hDC);

		pTaskBar->ReplaceButtonBitmap(i, hBitmap);
	}

}

void CTaskBarMgr::Reference(BOOL bAdd)
{
	CFloatingTaskBar *pTB = NULL;

	if(IsFloating())
		pTB = (CFloatingTaskBar*)m_TaskBarList.Get(0);

	if(bAdd)
	{
		if(pTB && m_nReference == 0)
			pTB->ShowWindow(SW_SHOW);
		m_nReference++;
	}
	else
	{
		if(pTB && m_nReference == 1)
			pTB->ShowWindow(SW_HIDE);
		m_nReference--;
	}

}

void CTaskBarMgr::ChangeTaskBarsPalette(HWND hFocus)
{
	if(m_bInitialized)
	{
		int nSize = m_TaskBarList.GetSize();

		for (int i = 0; i < nSize; i++)
		{
			CTaskBar * pTB = m_TaskBarList.Get(i);

			pTB->SendMessage(WM_PALETTECHANGED, (WPARAM)hFocus, 0);

		}
	}
}

/****************************************************************************
*
*	CTaskBarMgr::AddIconsToTaskBar
*
*	PARAMETERS:
*		pTaskBar	- pointer to the task bar to be filled
*
*	RETURNS:
*		TRUE if successful, FALSE if a failure occurs.
*
*	DESCRIPTION:
*		Protected helper function for adding all of the icons in our list
*		to a given (presumably newly created) task bar.
*
****************************************************************************/

BOOL CTaskBarMgr::AddIconsToTaskBar(CTaskBar * pTaskBar)
{

	BOOL bRtn = TRUE;
	HBITMAP hBitmap = NULL;

	for (int i = 0; (i < m_IconList.GetSize()) && bRtn; i++)
	{
		CTaskIcon * pIcon = m_IconList.Get(i);
		int idBmp = IsFloating() ? pIcon->GetLargeBmpID() :
			pIcon->GetSmallBmpID();

		int idTip = IsFloating() ? pIcon->GetFloatingTipID() :
		    pIcon->GetDockedTipID();

		HDC hDC = GetDC(pTaskBar->m_hWnd);
		hBitmap = WFE_LookupLoadAndEnterBitmap(hDC, idBmp, TRUE, WFE_GetUIPalette(pTaskBar->GetParentFrame()), 
											   sysInfo.m_clrBtnFace, RGB(255, 0, 255));
		ReleaseDC(pTaskBar->m_hWnd, hDC);

		int nBitmapIndex = IsFloating() ? pIcon->GetLargeBitmapIndex() :
			pIcon->GetSmallBitmapIndex();
		
		int idText = IsHorizontal() ? pIcon->GetHorizTextID() : pIcon->GetVertTextID();
			
		bRtn = pTaskBar->AddTaskIcon(pIcon->GetTaskID(), pIcon->GetNotifyWnd(),
			pIcon->GetNotifyMessage(), hBitmap, nBitmapIndex, pIcon->GetHorizTextID(), 
			pIcon->GetVertTextID(), idText, idTip, 
			pTaskBar->GetTaskBarStyle());
	}
	
	return(bRtn);

} // END OF	FUNCTION CTaskBarMgr::AddIconsToTaskBar()

/****************************************************************************
*
*	CTaskBarMgr::AddStandardIcons
*
*	PARAMETERS:
*		None
*
*	RETURNS:
*		TRUE if successful, FALSE if not.
*
*	DESCRIPTION:
*		This function call be called to add the three default icons (Mail,
*		Web & News) to our icon list, and therefore to all active task bars.
*
****************************************************************************/

BOOL CTaskBarMgr::AddStandardIcons()
{
	BOOL bRtn = TRUE;
	
	bRtn = 	AddTaskIcon(ID_TOOLS_WEB, IDB_TASKBARL, BROWSER_ICON_INDEX, IDB_TASKBARS,
						BROWSER_ICON_INDEX,	IDS_NOTIFY_WEB_TIP, IDS_NOTIFY_WEB_TIP, 
						IDS_NOTIFY_WEB_TIP, IDS_TASKBAR_FLOAT_NAVTIP) &&
			AddTaskIcon(ID_TOOLS_INBOX, IDB_TASKBARL, UNKNOWN_MAIL_ICON_INDEX, IDB_TASKBARS,
						UNKNOWN_MAIL_ICON_INDEX, IDS_NOTIFY_MAIL1_TIP, IDS_NOTIFY_MAIL1_TIP,
						IDS_NOTIFY_MAIL1_TIP, IDS_TASKBAR_FLOAT_MAILTIP) &&
			AddTaskIcon(ID_TOOLS_NEWS, IDB_TASKBARL, NEWS_ICON_INDEX, IDB_TASKBARS,
						NEWS_ICON_INDEX, IDS_TASKBAR_NEWS_HTEXT, IDS_TASKBAR_NEWS_HTEXT, 
						IDS_NOTIFY_NEWS_TIP, IDS_TASKBAR_FLOAT_NEWSTIP) &&
			AddTaskIcon(ID_TOOLS_EDITOR, IDB_TASKBARL, COMPOSE_ICON_INDEX, IDB_TASKBARS,
						COMPOSE_ICON_INDEX, IDS_NOTIFY_COMPOSE_TIP, IDS_NOTIFY_COMPOSE_TIP, 
						IDS_NOTIFY_COMPOSE_TIP, IDS_TASKBAR_FLOAT_COMPOSETIP);
	
	return(bRtn);

} // END OF	FUNCTION CTaskBarMgr::AddStandardIcons

/****************************************************************************
*
*	CTaskBarMgr::AddTaskIcon
*
*	PARAMETERS:
*		idTask		- task identifier
*		idBmpLarge	- bitmap resource ID for large icon (floating)
*		idBmpSmall	- bitmap resource ID for small icon (docked)
*		idTip		- string resource ID of tool tip text
*
*	RETURNS:
*		TRUE if successful, FALSE if not.
*
*	DESCRIPTION:
*		This function is called to add a task icon to the list maintained
*		by the task bar manager. The appropriate icon window will then be
*		created and added to any active task bars, floating or docked.
*
*		Notifications (mouse events) for the new icon are sent to the default
*		window (main frame window) using the default message (MSG_TASK_NOTIFY).
*		To specify a different handler, call the overloaded version of this
*		function that takes	those parameters.
*
****************************************************************************/

BOOL CTaskBarMgr::AddTaskIcon(UINT idTask, UINT idBmpLarge, int nLargeIndex, UINT idBmpSmall,
							  int nSmallIndex,	UINT idHorizText, UINT idVertText,
							  UINT idDockedTip, UINT idFloatingTip)
{
	return(AddTaskIcon(idTask, AfxGetMainWnd(), MSG_TASK_NOTIFY, idBmpLarge, nLargeIndex,
		idBmpSmall, nSmallIndex, idHorizText, idVertText, idDockedTip, idFloatingTip));

} // END OF	FUNCTION CTaskBarMgr::AddTaskIcon()

/****************************************************************************
*
*	CTaskBarMgr::AddTaskIcon
*
*	PARAMETERS:
*		idTask		- task identifier
*		pwndNotify	- pointer to window desiring notification
*		dwMessage	- user-defined callback message
*		idBmpLarge	- bitmap resource ID for large icon (floating)
*		idBmpSmall	- bitmap resource ID for small icon (docked)
*		idHorizText - string resource ID for horizontal text
*		idVertText  - string resource ID for vertical text
*		idTip		- string resource ID of tool tip text
*
*	RETURNS:
*		TRUE if successful, FALSE if not.
*
*	DESCRIPTION:
*		This function is called to add a task icon to the list maintained
*		by the task bar manager. The appropriate icon window will then be
*		created and added to any active task bars, floating or docked.
*
*		Notifications (mouse events) for the new icon are sent to the window
*		identified by pwndNotify, using the message dwMessage. For the default
*		message and handlers, call the overloaded version of this function
*		that omits those parameters.
*
****************************************************************************/

BOOL CTaskBarMgr::AddTaskIcon(UINT idTask, CWnd * pwndNotify, DWORD dwMessage,
	UINT idBmpLarge, int nLargeIndex, UINT idBmpSmall, int nSmallIndex, 
	UINT idHorizText, UINT idVertText, UINT idDockedTip, UINT idFloatingTip)
{
	BOOL bRtn = TRUE;
	HBITMAP hBitmap;

	// First, create a new icon object and add to our list.
	CTaskIcon * pIcon = new CTaskIcon(idTask, pwndNotify, dwMessage,
		idBmpLarge, nLargeIndex,  idBmpSmall, nSmallIndex, idHorizText,
		idVertText, idDockedTip, idFloatingTip);
	ASSERT(pIcon != NULL);		
	m_IconList.Add(pIcon);
	
	// Now add the icon to any existing task bars
	int idBmp = IsFloating() ? idBmpLarge : idBmpSmall;
	int idTip = IsFloating() ? idFloatingTip : idDockedTip;
	int idText = IsHorizontal() ? idHorizText : idVertText;

	int nBitmapIndex = IsFloating() ? nLargeIndex : nSmallIndex;


	for (int i = 0; (i < m_TaskBarList.GetSize()) && bRtn; i++)
	{
		CTaskBar * pTB = m_TaskBarList.Get(i);

		HDC hDC = GetDC(pTB->m_hWnd);
		hBitmap = WFE_LookupLoadAndEnterBitmap(hDC, idBmp, TRUE, WFE_GetUIPalette(pTB->GetParentFrame()), sysInfo.m_clrBtnFace,
											   RGB(255, 0, 255));

		ReleaseDC(pTB->m_hWnd, hDC);
		
		bRtn = pTB->AddTaskIcon(idTask, pwndNotify, dwMessage, hBitmap, nBitmapIndex,
			idHorizText, idVertText, idText, idTip, IsFloating()? pTB->GetTaskBarStyle(): TB_PICTURES);
	}

	// Finally, since the size of the task bar has changed, we must
	// re-position all.
	if (IsFloating())
	{
		PositionFloatingTaskBar();
	}
	else
	{
		PositionDockedTaskBars();
	}
	
	return(bRtn);

} // END OF	FUNCTION CTaskBarMgr::AddTaskIcon()

/****************************************************************************
*
*	CTaskBarMgr::ReplaceTaskIcon
*
*	PARAMETERS:
*		idTask		- task identifier
*		idBmpLarge	- new bitmap resource ID for large icon (floating)
*		idBmpSmall	- new bitmap resource ID for small icon (docked)
*
*	RETURNS:
*		TRUE if the icon was successfully replaced, FALSE if not (such as
*		when no existing icon with the given ID is found).
*
*	DESCRIPTION:
*		This function is called to replace an existing icon in the task bar
*		whenever it is desirable to show a different image, but retain the
*		notification handler and other information for the icon. An example
*		of this would be changing the mail icon to show a different state.
*
****************************************************************************/

BOOL CTaskBarMgr::ReplaceTaskIcon(UINT idTask, UINT idBmpLarge, UINT idBmpSmall, int nIndex)
{
	BOOL bRtn = FALSE;

	if(!m_bInitialized)
		return FALSE;

	// Replace the bmps for the abstract icon object in our list
	int i = m_IconList.FindByID(idTask);
	ASSERT(i > -1);
	if (i > -1)
	{
		bRtn = TRUE;
		
		CTaskIcon * pIcon = m_IconList.Get(i);
		pIcon->SetLargeBmpID(idBmpLarge);
		pIcon->SetSmallBmpID(idBmpSmall);
		//take this out eventually and replace with passed in parameters
		pIcon->SetLargeBitmapIndex(nIndex);
		pIcon->SetSmallBitmapIndex(nIndex);
	
	
		// Now tell all active task bars to replace it
		for (i = 0; i < m_TaskBarList.GetSize(); i++)
		{
			CTaskBar * pTB = m_TaskBarList.Get(i);
			int idBmp = IsFloating() ? idBmpLarge : idBmpSmall;
			BOOL bOk = pTB->ReplaceTaskIcon(idTask, idBmp, nIndex);
			ASSERT(bOk);
		}
	}	
	return(bRtn);

} // END OF	FUNCTION CTaskBarMgr::ReplaceTaskIcon()

/****************************************************************************
*
*	CTaskBarMgr::RemoveTaskIcon
*
*	PARAMETERS:
*		idTask	- task identifier
*
*	RETURNS:
*		TRUE if the icon was successfully removed from the task bar, FALSE
*		if not (such as when no existing icon with the given ID is found).
*
*	DESCRIPTION:
*		This function is called to remove an icon from the task bar when it
*		is no longer desirable to have it displayed. This is the only case
*		where this function is useful, since cleanup is performed
*		automatically when the task bar is destroyed.
*
****************************************************************************/

BOOL CTaskBarMgr::RemoveTaskIcon(UINT idTask)
{
	BOOL bRtn = FALSE;

	// Remove the abstract icon object from our list
	int i = m_IconList.FindByID(idTask);
	ASSERT(i > -1);
	if (i > -1)
	{
		bRtn = TRUE;
		
		CTaskIcon * pIcon = m_IconList.Get(i);
		delete pIcon;
		m_IconList.RemoveAt(i);
	}
	
	// Just tell all active task bars to remove it
	for (i = 0; i < m_TaskBarList.GetSize(); i++)
	{
		CTaskBar * pTB = m_TaskBarList.Get(i);
		BOOL bOk = pTB->RemoveTaskIcon(idTask);
		ASSERT(bOk);
	}
		
	// Re-size/re-position the task bar(s)
	if (IsFloating())
	{
		PositionFloatingTaskBar();
	}
	else
	{
		PositionDockedTaskBars();
	}
	
	return(bRtn);

} // END OF	FUNCTION CTaskBarMgr::RemoveTaskIcon()

/****************************************************************************
*
*	CTaskBarMgr::OnDockTaskBar
*
*	PARAMETERS:
*		None
*
*	RETURNS:
*		void
*
*	DESCRIPTION:
*		This function is called to dock the task bar.
*
****************************************************************************/

void CTaskBarMgr::OnDockTaskBar()
{
	ASSERT(IsFloating());
	DestroyAllTaskBars();
	SetFloating(FALSE);
	CreateAllTaskBars();

} // END OF	FUNCTION CTaskBarMgr::OnDockTaskBar()

/****************************************************************************
*
*	CTaskBarMgr::OnUnDockTaskBar
*
*	PARAMETERS:
*		ptUL	- upper left corner for new floating task bar, or -1,-1 
*				  for default location.
*
*	RETURNS:
*		void
*
*	DESCRIPTION:
*		This function is called to un-dock the task bar (move to floating
*		state).
*
****************************************************************************/

void CTaskBarMgr::OnUnDockTaskBar(CPoint & ptUL /*= (-1,-1)*/)
{
	ASSERT(!IsFloating());
	DestroyAllTaskBars();
	SetFloating(TRUE);
	if (ptUL != CPoint(-1, -1))
	{
		m_ptLastFloatPos = ptUL;
	}
	CreateAllTaskBars();

} // END OF	FUNCTION CTaskBarMgr::OnUnDockTaskBar()


void CTaskBarMgr::SetSeparateTaskBarStyle(int nTaskBarStyle)
{
	m_bSeparateTaskBarStyle = TRUE;

	ChangeTaskBarStyle(nTaskBarStyle);

}

void CTaskBarMgr::SetTaskBarStyle(int nTaskBarStyle)
{
	if(!m_bSeparateTaskBarStyle)
	{
		ChangeTaskBarStyle(nTaskBarStyle);
	}
}

void CTaskBarMgr::ChangeTaskBarStyle(int nTaskBarStyle)
{
	m_nTaskBarStyle = nTaskBarStyle;
	if(IsFloating())
	{
		CTaskBar * pTB = m_TaskBarList.Get(0);
		pTB->SetTaskBarStyle(nTaskBarStyle);
		PositionFloatingTaskBar();
	}
}

/****************************************************************************
*
*	Class: CDockButton
*
*	DESCRIPTION:
*		This class represents the docking (minimize) button for the floating
*		task bar.
*
****************************************************************************/

/****************************************************************************
*
*	CONSTANTS
*
****************************************************************************/
static const int nIMG_WIDTH = 9;
static const int nIMG_HEIGHT = 9;

BEGIN_MESSAGE_MAP(CDockButton, CDockButtonBase)
	//{{AFX_MSG_MAP(CDockButton)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/****************************************************************************
*
*	CDockButton::CDockButton
*
*	PARAMETERS:
*		None
*
*	RETURNS:
*		N/A
*
*	DESCRIPTION:
*		Constructor.
*
****************************************************************************/

CDockButton::CDockButton()
{

} // END OF	FUNCTION CDockButton::CDockButton()

/****************************************************************************
*
*	CDockButton::Create
*
*	PARAMETERS:
*		rect		- rectangle for initial size/position
*		pwndParent	- pointer to parent window
*		uID			- control identifier
*
*	RETURNS:
*		TRUE if creation is successful, FALSE if an error occurs.
*
*	DESCRIPTION:
*		This function is called to create the button, after construction.
*
****************************************************************************/

BOOL CDockButton::Create(const CRect & rect, CWnd* pwndParent, UINT uID)
{
	BOOL bRtn = CDockButtonBase::Create("", WS_CHILD | WS_VISIBLE |
		BS_OWNERDRAW, rect, pwndParent, uID);
		
	return(bRtn);

} // END OF	FUNCTION CDockButton::Create()

/****************************************************************************
*
*	CDockButton::DrawItem
*
*	PARAMETERS:
*		None
*
*	RETURNS:
*		void
*
*	DESCRIPTION:
*		Overridden to draw the bitmap image on our button.
*
****************************************************************************/

void CDockButton::DrawItem(LPDRAWITEMSTRUCT lpDrawItem)
{
	ASSERT(lpDrawItem != NULL);

	CDC * pDC = CDC::FromHandle(lpDrawItem->hDC);
	CRect rcBtn(&(lpDrawItem->rcItem));
	
	// Since we're owner-draw, we must do everything. First paint the button
	// face.
	CBrush brFace(RGB(192, 192, 192));
	pDC->FillRect(rcBtn, &brFace);
	
	// Now the 3d border
	if (lpDrawItem->itemState & ODS_SELECTED)
	{
		// Draw depressed look
		DrawDownButton(pDC, rcBtn);
	}
	else
	{
		// Draw normal look
		DrawUpButton(pDC, rcBtn);
	}

	// Finally, paint our image. Shift down one pixel if in depressed state.
	if (lpDrawItem->itemState & ODS_SELECTED)
	{
		rcBtn.left += 1;
		rcBtn.top += 1;
	}
	DrawImage(pDC, rcBtn);
	
} // END OF FUNCTION CDockButton::DrawItem()

/****************************************************************************
*
*	CDockButton::DrawUpButton
*
*	PARAMETERS:
*		pDC		- pointer to DC to draw on
*		rect	- client rect to draw in
*
*	RETURNS:
*		void
*
*	DESCRIPTION:
*		Protected helper function for drawing the 3d "up button" look.
*
****************************************************************************/

void CDockButton::DrawUpButton(CDC * pDC, CRect & rect)
{
	// Hilight
	CRect rc(0, 0, rect.right, 1);
	CBrush br(::GetSysColor(COLOR_BTNHIGHLIGHT));
	pDC->FillRect(rc, &br);
	rc.SetRect(0, 0, 1, rect.bottom);
	pDC->FillRect(rc, &br);
	
	// Shadow
	br.DeleteObject();
	br.CreateSolidBrush(::GetSysColor(COLOR_BTNSHADOW));
	rc.SetRect(0, rect.bottom - 1, rect.right, rect.bottom);
	pDC->FillRect(rc, &br);
	rc.SetRect(rect.right - 1, 0, rect.right, rect.bottom);
	pDC->FillRect(rc, &br);

} // END OF	FUNCTION CDockButton::DrawUpButton()

/****************************************************************************
*
*	CDockButton::DrawDownButton
*
*	PARAMETERS:
*		pDC		- pointer to DC to draw on
*		rect	- client rect to draw in
*
*	RETURNS:
*		void
*
*	DESCRIPTION:
*		Protected helper function for drawing the 3d "down button" look.
*
****************************************************************************/

void CDockButton::DrawDownButton(CDC * pDC, CRect & rect)
{
	// Hilight
	CRect rc(0, rect.bottom - 1, rect.right, rect.bottom);
	CBrush br(::GetSysColor(COLOR_BTNHIGHLIGHT));
	pDC->FillRect(rc, &br);
	rc.SetRect(rect.right - 1, 0, rect.right, rect.bottom);
	pDC->FillRect(rc, &br);
	
	// Shadow
	br.DeleteObject();
	br.CreateSolidBrush(::GetSysColor(COLOR_BTNSHADOW));
	rc.SetRect(0, 0, rect.right, 1);
	pDC->FillRect(rc, &br);
	rc.SetRect(0, 0, 1, rect.bottom);
	pDC->FillRect(rc, &br);

} // END OF	FUNCTION CDockButton::DrawDownButton()

/****************************************************************************
*
*	CDockButton::DrawImage
*
*	PARAMETERS:
*		pDC		- pointer to DC to draw on
*		rect	- client rect to draw in
*
*	RETURNS:
*		void
*
*	DESCRIPTION:
*		Protected helper function for drawing our bitmap image on the button.
*
****************************************************************************/

void CDockButton::DrawImage(CDC * pDC, CRect & rect)
{
	// Create a scratch DC and select our bitmap into it.
	CDC * pBmpDC = new CDC;
	pBmpDC->CreateCompatibleDC(pDC);
	CBitmap bmp;
	bmp.LoadBitmap(IDB_DOCK_BTN);
	CBitmap * pOldBmp = pBmpDC->SelectObject(&bmp);
		
	// Center the image within the button	
	CPoint ptDst(rect.left + (((rect.Width() - nIMG_WIDTH) + 1) / 2),
		rect.top + (((rect.Height() - nIMG_HEIGHT) + 1) / 2));
		
	// Call the handy transparent blit function to paint the bitmap over
	// whatever colors exist.	
	::FEU_TransBlt(pBmpDC, pDC, CPoint(0, 0), ptDst, nIMG_WIDTH, nIMG_HEIGHT,WFE_GetUIPalette(GetParentFrame()));
	
	// Cleanup
	pBmpDC->SelectObject(pOldBmp);
	pBmpDC->DeleteDC();
	delete pBmpDC;
	bmp.DeleteObject();
	
} // END OF	FUNCTION CDockButton::DrawImage()