/* -*- 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()