archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4 Commits
1 Branch
0 Tags
1.5 GiB
 
 
 
 
 
 
Tree: 5c6fe3db62
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '5c6fe3db62'
${ noResults }
windows-server-2003/inetcore/outlookexpress/mailnews/spooler/spoolui.cpp

1930 lines
54 KiB
Raw Blame History

/////////////////////////////////////////////////////////////////////////////
// Copyright (C) 1993-1996 Microsoft Corporation. All Rights Reserved.
//
// MODULE: spoolui.cpp
//
// PURPOSE: Implements the spooler UI dialogs.
//
#include "pch.hxx"
#include "resource.h"
#include "spoolui.h"
#include "goptions.h"
#include "imnact.h"
#include "thormsgs.h"
#include "shlwapip.h"
#include "spengine.h"
#include "ourguid.h"
#include "demand.h"
#include "menures.h"
#include "multiusr.h"
ASSERTDATA
static const char c_szWndProc[] = "WndProc";
//
// FUNCTION: CSpoolerDlg::CSpoolerDlg()
//
// PURPOSE: Initializes the member variables of the spooler ui object.
//
CSpoolerDlg::CSpoolerDlg()
{
m_cRef = 1;
m_pBindCtx = NULL;
m_hwnd = NULL;
m_hwndOwner = NULL;
m_hwndEvents = NULL;
m_hwndErrors = NULL;
InitializeCriticalSection(&m_cs);
m_himlImages = NULL;
m_fTack = FALSE;
m_iTab = 0;
m_fIdle = FALSE;
m_fErrors = FALSE;
m_fShutdown = FALSE;
m_fSaveSize = FALSE;
m_fExpanded = TRUE;
ZeroMemory(&m_rcDlg, sizeof(RECT));
m_cyCollapsed = 0;
m_szCount[0] = '\0';
m_hIcon=NULL;
m_hIconSm=NULL;
m_dwIdentCookie = 0;
}
//
// FUNCTION: CSpoolerDlg::~CSpoolerDlg()
//
// PURPOSE: Frees any resources allocated during the life of the class.
//
CSpoolerDlg::~CSpoolerDlg()
{
GoIdle(TRUE, FALSE, FALSE);
if (m_hwnd && IsWindow(m_hwnd))
DestroyWindow(m_hwnd);
if (m_himlImages)
ImageList_Destroy(m_himlImages);
SafeRelease(m_pBindCtx);
DeleteCriticalSection(&m_cs);
if (m_hIcon)
SideAssert(DestroyIcon(m_hIcon));
if (m_hIconSm)
SideAssert(DestroyIcon(m_hIconSm));
}
//
// FUNCTION: CSpoolerDlg::Init()
//
// PURPOSE: Creates the spooler dialog. The dialog is not initially
// visible.
//
// PARAMETERS:
// <in> hwndOwner - Handle of the window to parent the dialog to.
//
// RETURN VALUE:
// S_OK - The dialog was created and initialized
// E_OUTOFMEMORY - The dialog could not be created
// E_INVALIDARG - Think about it.
//
HRESULT CSpoolerDlg::Init(HWND hwndOwner)
{
int iReturn = -1;
HWND hwnd, hwndActive;
// Verify the arguments
if (!IsWindow(hwndOwner))
return (E_INVALIDARG);
// Make a copy
m_hwndOwner = hwndOwner;
// Invoke the dialog
hwndActive = GetForegroundWindow();
hwnd = CreateDialogParam(g_hLocRes, MAKEINTRESOURCE(iddSpoolerDlg), m_hwndOwner,
SpoolerDlgProc, (LPARAM) this);
if (hwndActive != GetForegroundWindow())
SetForegroundWindow(hwndActive);
// Set the dialog icon
m_hIcon = (HICON) LoadImage(g_hLocRes, MAKEINTRESOURCE(idiMail), IMAGE_ICON, 32, 32, 0);
SendMessage(hwnd, WM_SETICON, ICON_BIG, (LPARAM)m_hIcon);
m_hIconSm = (HICON) LoadImage(g_hLocRes, MAKEINTRESOURCE(idiMail), IMAGE_ICON, 16, 16, 0);
SendMessage(hwnd, WM_SETICON, ICON_SMALL, (LPARAM)m_hIconSm);
SetTaskCounts(0, 0);
// Register with identity manager
SideAssert(SUCCEEDED(MU_RegisterIdentityNotifier((IUnknown *)(ISpoolerUI *)this, &m_dwIdentCookie)));
return (IsWindow(hwnd) ? S_OK : E_OUTOFMEMORY);
}
HRESULT CSpoolerDlg::QueryInterface(REFIID riid, LPVOID *ppvObj)
{
if (NULL == *ppvObj)
return (E_INVALIDARG);
*ppvObj = NULL;
if (IsEqualIID(riid, IID_IUnknown))
*ppvObj = (LPVOID)(IUnknown *)(ISpoolerUI *) this;
else if (IsEqualIID(riid, IID_ISpoolerUI))
*ppvObj = (LPVOID)(ISpoolerUI *) this;
else if (IsEqualIID(riid, IID_IIdentityChangeNotify))
*ppvObj = (LPVOID)(IIdentityChangeNotify *) this;
if (NULL == *ppvObj)
return (E_NOINTERFACE);
AddRef();
return (S_OK);
}
ULONG CSpoolerDlg::AddRef(void)
{
m_cRef++;
return (m_cRef);
}
ULONG CSpoolerDlg::Release(void)
{
ULONG cRefT = --m_cRef;
if (0 == m_cRef)
delete this;
return (cRefT);
}
//
// FUNCTION: CSpoolerDlg::RegisterBindContext()
//
// PURPOSE: Allows the spooler engine to provide us with a bind context
// interface for us to call back into.
//
// PARAMETERS:
// <in> pBindCtx - Pointer to the engine's bind context interface
//
// RETURN VALUE:
// E_INVALIDARG
// S_OK
//
HRESULT CSpoolerDlg::RegisterBindContext(ISpoolerBindContext *pBindCtx)
{
if (NULL == pBindCtx)
return (E_INVALIDARG);
EnterCriticalSection(&m_cs);
m_pBindCtx = pBindCtx;
m_pBindCtx->AddRef();
LeaveCriticalSection(&m_cs);
return (S_OK);
}
//
// FUNCTION: CSpoolerDlg::InsertEvent()
//
// PURPOSE: Allows a caller to insert an event into our event list UI.
//
// PARAMETERS:
// <in> eid - Event ID for this new event
// <in> pszDescription - Description of the event
//
// RETURN VALUE:
// E_INVALIDARG
// SP_E_UNINITIALIZED
// E_OUTOFMEMORY
//
HRESULT CSpoolerDlg::InsertEvent(EVENTID eid, LPCTSTR pszDescription,
LPCWSTR pwszConnection)
{
HRESULT hr=S_OK;
LV_ITEM lvi;
int iItem = -1;
TCHAR szRes[CCHMAX_STRINGRES];
// Verify the arguments
if (0 == pszDescription)
return (E_INVALIDARG);
EnterCriticalSection(&m_cs);
// Make sure the listview has been initialized
if (!IsWindow(m_hwndEvents))
hr = SP_E_UNINITIALIZED;
else
{
// Insert the item into the listview
ZeroMemory(&lvi, sizeof(LV_ITEM));
lvi.mask = LVIF_TEXT | LVIF_PARAM | LVIF_IMAGE;
lvi.iItem = ListView_GetItemCount(m_hwndEvents);
lvi.iSubItem = 0;
lvi.lParam = (LPARAM) eid;
lvi.iImage = IMAGE_BLANK;
if (IS_INTRESOURCE(pszDescription))
{
AthLoadString(PtrToUlong(pszDescription), szRes, ARRAYSIZE(szRes));
lvi.pszText = szRes;
}
else
lvi.pszText = (LPTSTR) pszDescription;
iItem = ListView_InsertItem(m_hwndEvents, &lvi);
Assert(iItem != -1);
if (iItem == -1)
hr = E_OUTOFMEMORY;
else
{
LVITEMW lviw = {0};
lviw.iSubItem = 2;
lviw.pszText = (LPWSTR)pwszConnection;
SendMessage(m_hwndEvents, LVM_SETITEMTEXTW, (WPARAM)iItem, (LPARAM)&lviw);
}
}
LeaveCriticalSection(&m_cs);
return hr;
}
//
// FUNCTION: CSpoolerDlg::InsertError()
//
// PURPOSE: Allows a task to insert an error into our error list UI.
//
// PARAMETERS:
// <in> eid - The event ID of the event that had the error.
// <in> pszError - Description of the error.
//
// RETURN VALUE:
// E_INVALIDARG
// SP_E_UNINITIALIZED
// E_OUTOFMEMORY
//
HRESULT CSpoolerDlg::InsertError(EVENTID eid, LPCTSTR pszError)
{
HRESULT hr = S_OK;
LBDATA *pData = NULL;
int nItem;
HDC hdc;
HFONT hfont;
// Verify the arguments
if (0 == pszError)
return (E_INVALIDARG);
EnterCriticalSection(&m_cs);
// Make sure the listview has been initialized
if (!IsWindow(m_hwndErrors))
hr = SP_E_UNINITIALIZED;
else
{
// Allocate a struct for the item data
if (!MemAlloc((LPVOID *) &pData, sizeof(LBDATA)))
{
hr = E_OUTOFMEMORY;
goto exit;
}
pData->eid = eid;
// Check to see if we need to load the string ourselves
if (IS_INTRESOURCE(pszError))
{
pData->pszText = AthLoadString(PtrToUlong(pszError), 0, 0);
}
else
pData->pszText = PszDupA(pszError);
// Get the size of the string
hfont = (HFONT) SendMessage(m_hwnd, WM_GETFONT, 0, 0);
hdc = GetDC(m_hwndErrors);
SelectFont(hdc, hfont);
SetRect(&(pData->rcText), 0, 0, m_cxErrors - BULLET_WIDTH - 4, 0);
// bug #47453, add DT_INTERNAL flag so that on FE platform (PRC and TC)
// two list items is not overlapping.
DrawText(hdc, pData->pszText, -1, &(pData->rcText), DT_CALCRECT | DT_WORDBREAK | DT_INTERNAL);
ReleaseDC(m_hwndErrors, hdc);
pData->rcText.bottom += 4;
// Add the item data
nItem = ListBox_AddItemData(m_hwndErrors, pData);
}
exit:
LeaveCriticalSection(&m_cs);
return hr;
}
//
// FUNCTION: CSpoolerDlg::UpdateEventState()
//
// PURPOSE: Allows a task to update the description and state of an event.
//
// PARAMETERS:
// <in> eid - ID of the event to update
// <in> nImage - Image to display for the item. If this is -1,
// the image is not changed.
// <in> pszDescription - Description for the item. If this is NULL, the
// description is not changed.
// <in> pszStatus - Status of the item. If this is NULL, the status
// is not changed.
//
// RETURN VALUE:
// E_INVALIDARG
// SP_E_UNINITIALIZED
// SP_E_EVENTNOTFOUND
// E_UNEXPECTED
//
HRESULT CSpoolerDlg::UpdateEventState(EVENTID eid, INT nImage,
LPCTSTR pszDescription, LPCTSTR pszStatus)
{
LV_ITEM lvi;
LV_FINDINFO lvfi;
int iItem = -1;
BOOL fSuccess = FALSE;
HRESULT hr = S_OK;
TCHAR szRes[CCHMAX_STRINGRES];
EnterCriticalSection(&m_cs);
ZeroMemory(&lvi, sizeof(LV_ITEM));
// See if we're initialized
if (!IsWindow(m_hwndEvents))
{
hr = SP_E_UNINITIALIZED;
goto exit;
}
// Start by finding the event in our list
lvfi.flags = LVFI_PARAM;
lvfi.psz = 0;
lvfi.lParam = eid;
iItem = ListView_FindItem(m_hwndEvents, -1, &lvfi);
if (-1 == iItem)
{
hr = SP_E_EVENTNOTFOUND;
goto exit;
}
// Update the image and description
lvi.mask = 0;
lvi.iItem = iItem;
lvi.iSubItem = 0;
// Set up the image info
if (-1 != nImage)
{
lvi.mask = LVIF_IMAGE;
lvi.iImage = nImage;
}
// Set up the description text
if (NULL != pszDescription)
{
// Check to see if we need to load the string ourselves
if (IS_INTRESOURCE(pszDescription))
{
AthLoadString(PtrToUlong(pszDescription), szRes, ARRAYSIZE(szRes));
lvi.pszText = szRes;
}
else
lvi.pszText = (LPTSTR) pszDescription;
lvi.mask |= LVIF_TEXT;
}
if (lvi.mask)
fSuccess = ListView_SetItem(m_hwndEvents, &lvi);
// Update the status
if (NULL != pszStatus)
{
// Check to see if we need to load the string ourselves
if (IS_INTRESOURCE(pszStatus))
{
AthLoadString(PtrToUlong(pszStatus), szRes, ARRAYSIZE(szRes));
lvi.pszText = szRes;
}
else
lvi.pszText = (LPTSTR) pszStatus;
lvi.mask = LVIF_TEXT;
lvi.iSubItem = 1;
ListView_SetItemText(m_hwndEvents, lvi.iItem, 1, lvi.pszText); /* fSuccess = fSuccess && */
}
hr = fSuccess ? S_OK : E_UNEXPECTED;
exit:
LeaveCriticalSection(&m_cs);
return (hr);
}
//
// FUNCTION: CSpoolerDlg::SetProgressRange()
//
// PURPOSE: Resets the progress bar to zero, and then sets the upper bound
// to the specified amount.
//
// PARAMETERS:
// <in> wMax - New maximum range for the progress bar
//
// RETURN VALUE:
// E_INVALIDARG
// SP_E_UNINITIALIZED
// S_OK
//
HRESULT CSpoolerDlg::SetProgressRange(WORD wMax)
{
HWND hwndProg = GetDlgItem(m_hwnd, IDC_SP_PROGRESS_BAR);
HRESULT hr = S_OK;
if (wMax == 0)
return (E_INVALIDARG);
EnterCriticalSection(&m_cs);
// Make sure we have a progress bar
if (!IsWindow(hwndProg))
hr = SP_E_UNINITIALIZED;
else
{
// Reset the progress bar
SendMessage(hwndProg, PBM_SETPOS, 0, 0);
// Set the new range
SendMessage(hwndProg, PBM_SETRANGE, 0, MAKELPARAM(0, wMax));
}
LeaveCriticalSection(&m_cs);
return (hr);
}
//
// FUNCTION: CSpoolerDlg::IncrementProgress()
//
// PURPOSE: Increments the progress bar by a specified amount.
//
// PARAMETERS:
// <in> wDelta - Amount to increment the progress bar by
//
// RETURN VALUE:
// E_INVALIDARG
// SP_E_UNINITIALIZED
// S_OK
//
HRESULT CSpoolerDlg::IncrementProgress(WORD wDelta)
{
HRESULT hr = S_OK;
EnterCriticalSection(&m_cs);
if (!IsWindow(m_hwnd))
hr = SP_E_UNINITIALIZED;
else
SendDlgItemMessage(m_hwnd, IDC_SP_PROGRESS_BAR, PBM_DELTAPOS, wDelta, 0);
LeaveCriticalSection(&m_cs);
return (hr);
}
//
// FUNCTION: CSpoolerDlg::SetProgressPosition()
//
// PURPOSE: Sets the progress bar to a specific position.
//
// PARAMETERS:
// <in> wPos - Position to set progress bar to
//
// RETURN VALUE:
// E_INVALIDARG
// SP_E_UNINITIALIZED
// S_OK
//
HRESULT CSpoolerDlg::SetProgressPosition(WORD wPos)
{
HRESULT hr = S_OK;
EnterCriticalSection(&m_cs);
if (wPos < 0)
hr = E_INVALIDARG;
else if (!IsWindow(m_hwnd))
hr = SP_E_UNINITIALIZED;
else
SendDlgItemMessage(m_hwnd, IDC_SP_PROGRESS_BAR, PBM_SETPOS, wPos, 0);
LeaveCriticalSection(&m_cs);
return (hr);
}
//
// FUNCTION: CSpoolerDlg::SetGeneralProgress()
//
// PURPOSE: Allows the caller to update the general progress text.
//
// PARAMETERS:
// <in> pszProgress - New progress string
//
// RETURN VALUE:
// SP_E_UNINITIALIZED
// S_OK
//
HRESULT CSpoolerDlg::SetGeneralProgress(LPCTSTR pszProgress)
{
HRESULT hr = S_OK;
EnterCriticalSection(&m_cs);
if (!IsWindow(m_hwnd))
hr = SP_E_UNINITIALIZED;
else
{
if (pszProgress)
SetDlgItemText(m_hwnd, IDC_SP_GENERAL_PROG, pszProgress);
else
SetDlgItemText(m_hwnd, IDC_SP_GENERAL_PROG, _T(""));
}
LeaveCriticalSection(&m_cs);
return (hr);
}
//
// FUNCTION: CSpoolerDlg::SetSpecificProgress()
//
// PURPOSE: Allows the caller to update the specific progress text.
//
// PARAMETERS:
// <in> pszProgress - New progress string
//
// RETURN VALUE:
// SP_E_UNINITIALIZED
// S_OK
//
HRESULT CSpoolerDlg::SetSpecificProgress(LPCTSTR pszProgress)
{
HRESULT hr = S_OK;
EnterCriticalSection(&m_cs);
if (!IsWindow(m_hwnd))
hr = SP_E_UNINITIALIZED;
else
{
TCHAR szRes[CCHMAX_STRINGRES];
if (IS_INTRESOURCE(pszProgress))
{
AthLoadString(PtrToUlong(pszProgress), szRes, ARRAYSIZE(szRes));
pszProgress = szRes;
}
if (pszProgress)
SetDlgItemText(m_hwnd, IDC_SP_SPECIFIC_PROG, pszProgress);
else
SetDlgItemText(m_hwnd, IDC_SP_SPECIFIC_PROG, _T(""));
}
LeaveCriticalSection(&m_cs);
return (hr);
}
//
// FUNCTION: CSpoolerDlg::SetAnimation()
//
// PURPOSE: Allows the caller to choose which animation is playing
//
// PARAMETERS:
// <in> nAnimationID - New resource id for the animation
// <in> fPlay - TRUE if we should start animating it.
//
// RETURN VALUE:
// SP_E_UNINITIALIZED
// S_OK
//
HRESULT CSpoolerDlg::SetAnimation(int nAnimationID, BOOL fPlay)
{
HRESULT hr = S_OK;
HWND hwndAni;
EnterCriticalSection(&m_cs);
#ifndef _WIN64
if (!IsWindow(m_hwnd) || !IsWindow(GetDlgItem(m_hwnd, IDC_SP_ANIMATE)))
hr = SP_E_UNINITIALIZED;
else
{
hwndAni = GetDlgItem(m_hwnd, IDC_SP_ANIMATE);
Animate_Close(hwndAni);
if (IsWindow(m_hwnd) && IsWindow(GetDlgItem(m_hwnd, IDC_SP_ANIMATE)))
{
Animate_OpenEx(hwndAni, g_hLocRes, MAKEINTRESOURCE(nAnimationID));
if (fPlay)
Animate_Play(hwndAni, 0, -1, -1);
}
}
#endif // _WIN64
LeaveCriticalSection(&m_cs);
return (hr);
}
//
// FUNCTION: CSpoolerDlg::EnsureVisible()
//
// PURPOSE: Ensures that the specified event is visible within the listview
//
// PARAMETERS:
// <in> eid - Event ID to make sure is visible
//
// RETURN VALUE:
// SP_E_UNINITIALIZED
// SP_E_EVENTNOTFOUND
// S_OK
//
HRESULT CSpoolerDlg::EnsureVisible(EVENTID eid)
{
LV_FINDINFO lvfi;
int iItem = -1;
HRESULT hr = S_OK;
EnterCriticalSection(&m_cs);
// See if we're initialized
if (!IsWindow(m_hwndEvents))
hr = SP_E_UNINITIALIZED;
else
{
// Start by finding the event in our list
lvfi.flags = LVFI_PARAM;
lvfi.psz = 0;
lvfi.lParam = eid;
iItem = ListView_FindItem(m_hwndEvents, -1, &lvfi);
// Now tell the listview to make sure it's visible
if (-1 != iItem)
ListView_EnsureVisible(m_hwndEvents, iItem, FALSE);
hr = (iItem == -1) ? SP_E_EVENTNOTFOUND : S_OK;
}
LeaveCriticalSection(&m_cs);
return (hr);
}
//
// FUNCTION: CSpoolerDlg::ShowWindow()
//
// PURPOSE: Shows or hides the spooler dialog
//
// PARAMETERS:
// <in> nCmdShow - This is the same as the ShowWindow() API
//
// RETURN VALUE:
// SP_E_UNINITIALIZED
// S_OK
//
HRESULT CSpoolerDlg::ShowWindow(int nCmdShow)
{
HRESULT hr = S_OK;
EnterCriticalSection(&m_cs);
if (!IsWindow(m_hwnd))
hr = SP_E_UNINITIALIZED;
else
{
::ShowWindow(m_hwnd, nCmdShow);
if (m_pBindCtx)
m_pBindCtx->OnUIChange(nCmdShow == SW_SHOW);
}
LeaveCriticalSection(&m_cs);
return (hr);
}
//
// FUNCTION: CSpoolerDlg::StartDelivery()
//
// PURPOSE: Tells the dialog the delivery has begun.
//
// RETURN VALUE:
// S_OK
// SP_E_UNINITIALIZED
//
HRESULT CSpoolerDlg::StartDelivery(void)
{
HRESULT hr = SP_E_UNINITIALIZED;
EnterCriticalSection(&m_cs);
if (IsWindow(m_hwnd))
{
//Animate_Play(GetDlgItem(m_hwnd, IDC_SP_ANIMATE), 0, -1, -1);
TabCtrl_SetCurSel(GetDlgItem(m_hwnd, IDC_SP_TABS), TAB_TASKS);
OnTabChange(0);
ToggleStatics(FALSE);
SetDlgItemText(m_hwnd, IDC_SP_GENERAL_PROG, _T(""));
SetDlgItemText(m_hwnd, IDC_SP_SPECIFIC_PROG, _T(""));
EnableWindow(GetDlgItem(m_hwnd, IDC_SP_STOP), FALSE);
hr = S_OK;
}
LeaveCriticalSection(&m_cs);
return (hr);
}
//
// FUNCTION: CSpoolerDlg::ClearEvents()
//
// PURPOSE: Clears any events and errors out of the listviews.
//
// RETURN VALUE:
// S_OK
// SP_E_UNINITIALIZED
//
HRESULT CSpoolerDlg::ClearEvents(void)
{
HRESULT hr = SP_E_UNINITIALIZED;
EnterCriticalSection(&m_cs);
if (IsWindow(m_hwnd))
{
m_fErrors = FALSE;
EnableWindow(GetDlgItem(m_hwnd, IDC_SP_STOP), FALSE);
ListView_DeleteAllItems(m_hwndEvents);
ListBox_ResetContent(m_hwndErrors);
hr = S_OK;
}
LeaveCriticalSection(&m_cs);
return (hr);
}
HRESULT CSpoolerDlg::SetTaskCounts(DWORD cSucceeded, DWORD cTotal)
{
TCHAR szBuf[CCHMAX_STRINGRES];
HRESULT hr = SP_E_UNINITIALIZED;
EnterCriticalSection(&m_cs);
if (IsWindow(m_hwnd))
{
wnsprintf(szBuf, ARRAYSIZE(szBuf), m_szCount, cSucceeded, cTotal);
SetDlgItemText(m_hwnd, IDC_SP_OVERALL_STATUS, szBuf);
hr = S_OK;
}
LeaveCriticalSection(&m_cs);
return (hr);
}
HRESULT CSpoolerDlg::AreThereErrors(void)
{
EnterCriticalSection(&m_cs);
HRESULT hr = (m_fErrors ? S_OK : S_FALSE);
LeaveCriticalSection(&m_cs);
return hr;
}
HRESULT CSpoolerDlg::Shutdown(void)
{
CHAR szRes[255];
EnterCriticalSection(&m_cs);
m_fShutdown = TRUE;
if (IsWindow(m_hwnd))
{
EnableWindow(GetDlgItem(m_hwnd, IDC_SP_STOP), FALSE);
EnableWindow(GetDlgItem(m_hwnd, IDC_SP_MINIMIZE), TRUE);
LoadString(g_hLocRes, idsClose, szRes, ARRAYSIZE(szRes));
SetDlgItemText(m_hwnd, IDC_SP_MINIMIZE, szRes);
}
LeaveCriticalSection(&m_cs);
return S_OK;
}
//
// FUNCTION: CSpoolerDlg::GoIdle()
//
// PURPOSE: Tells the dialog the delivery has ended.
//
// PARAMETERS:
// <in> fErrors - TRUE if errors occured during the download.
//
// RETURN VALUE:
// S_OK
// SP_E_UNINITIALIZED
//
HRESULT CSpoolerDlg::GoIdle(BOOL fErrors, BOOL fShutdown, BOOL fNoSync)
{
HRESULT hr = SP_E_UNINITIALIZED;
TCHAR szRes[CCHMAX_STRINGRES];
EnterCriticalSection(&m_cs);
if (IsWindow(m_hwnd))
{
// Stop the animation
#ifndef _WIN64
Animate_Close(GetDlgItem(m_hwnd, IDC_SP_ANIMATE));
#endif
hr = S_OK;
ToggleStatics(TRUE);
EnableWindow(GetDlgItem(m_hwnd, IDC_SP_STOP), FALSE);
if (ISFLAGSET(fErrors, SPSTATE_CANCEL))
{
m_fErrors = TRUE;
ExpandCollapse(TRUE);
TabCtrl_SetCurSel(GetDlgItem(m_hwnd, IDC_SP_TABS), TAB_TASKS);
OnTabChange(0);
AthLoadString(idsSpoolerUserCancel, szRes, ARRAYSIZE(szRes));
SetDlgItemText(m_hwnd, IDC_SP_IDLETEXT, szRes);
SendDlgItemMessage(m_hwnd, IDC_SP_IDLEICON, STM_SETICON,
(WPARAM) LoadIcon(g_hLocRes, MAKEINTRESOURCE(idiError)), 0);
}
// Also if there were errors, we should switch to the error page
else if (fErrors)
{
m_fErrors = TRUE;
ExpandCollapse(TRUE);
TabCtrl_SetCurSel(GetDlgItem(m_hwnd, IDC_SP_TABS), TAB_ERRORS);
OnTabChange(0);
AthLoadString(idsSpoolerIdleErrors, szRes, ARRAYSIZE(szRes));
SetDlgItemText(m_hwnd, IDC_SP_IDLETEXT, szRes);
SendDlgItemMessage(m_hwnd, IDC_SP_IDLEICON, STM_SETICON,
(WPARAM) LoadIcon(g_hLocRes, MAKEINTRESOURCE(idiError)), 0);
}
else
{
AthLoadString(idsSpoolerIdle, szRes, ARRAYSIZE(szRes));
SetDlgItemText(m_hwnd, IDC_SP_IDLETEXT, szRes);
SendDlgItemMessage(m_hwnd, IDC_SP_IDLEICON, STM_SETICON,
(WPARAM) LoadIcon(g_hLocRes, MAKEINTRESOURCE(idiMailNews)), 0);
if (fNoSync)
AthMessageBoxW(m_hwnd, MAKEINTRESOURCEW(idsAthena), MAKEINTRESOURCEW(idsNothingToSync), NULL, MB_OK | MB_ICONEXCLAMATION);
// Determine if we need to hide the dialog
UINT state = (UINT) SendDlgItemMessage(m_hwnd, IDC_SP_TOOLBAR, TB_GETSTATE, IDC_SP_TACK, 0);
if (!(state & TBSTATE_CHECKED))
ShowWindow(SW_HIDE);
}
}
LeaveCriticalSection(&m_cs);
return (hr);
}
//
// FUNCTION: CSpoolerDlg::IsDialogMessage()
//
// PURPOSE: Allows the dialog to retrieve messages from the message loop.
//
// PARAMETERS:
// <in> pMsg - Pointer to the message for us to examine.
//
// RETURN VALUE:
// Returns S_OK if we eat the message, S_FALSE otherwise.
//
HRESULT CSpoolerDlg::IsDialogMessage(LPMSG pMsg)
{
HRESULT hr;
BOOL fEaten = FALSE;
BOOL fBack = FALSE;
EnterCriticalSection(&m_cs);
// Intended for modeless timeout dialog running on this thread?
HWND hwndTimeout = (HWND)TlsGetValue(g_dwTlsTimeout);
if (hwndTimeout && ::IsDialogMessage(hwndTimeout, pMsg))
return(S_OK);
if (pMsg->message == WM_KEYDOWN && (GetAsyncKeyState(VK_CONTROL) < 0))
{
switch (pMsg->wParam)
{
case VK_TAB:
fBack = GetAsyncKeyState(VK_SHIFT) < 0;
break;
case VK_PRIOR: // VK_PAGE_UP
case VK_NEXT: // VK_PAGE_DOWN
fBack = (pMsg->wParam == VK_PRIOR);
break;
default:
goto NoKeys;
}
int iCur = TabCtrl_GetCurSel(GetDlgItem(m_hwnd, IDC_SP_TABS));
// tab in reverse if shift is down
if (fBack)
iCur += (TAB_MAX - 1);
else
iCur++;
iCur %= TAB_MAX;
TabCtrl_SetCurSel(GetDlgItem(m_hwnd, IDC_SP_TABS), iCur);
OnTabChange(NULL);
}
NoKeys:
if (IsWindow(m_hwnd) && IsWindowVisible(m_hwnd))
fEaten = ::IsDialogMessage(m_hwnd, pMsg);
LeaveCriticalSection(&m_cs);
return (fEaten ? S_OK : S_FALSE);
}
//
// FUNCTION: CSpoolerDlg::GetWindow()
//
// PURPOSE: Returns the handle to the spooler dialog window.
//
// PARAMETERS:
// <out> pHwnd - Where we return the handle.
//
// RETURN VALUE:
// E_INVALIDARG
// SP_E_UNINITIALIZED
// S_OK
//
HRESULT CSpoolerDlg::GetWindow(HWND *pHwnd)
{
HRESULT hr=S_OK;
if (NULL == pHwnd)
return E_INVALIDARG;
EnterCriticalSection(&m_cs);
if (!IsWindow(m_hwnd))
hr = SP_E_UNINITIALIZED;
else
*pHwnd = m_hwnd;
LeaveCriticalSection(&m_cs);
return (S_OK);
}
HRESULT CSpoolerDlg::Close(void)
{
HRESULT hr = S_OK;
EnterCriticalSection(&m_cs);
if (!IsWindow(m_hwnd))
hr = SP_E_UNINITIALIZED;
else
DestroyWindow(m_hwnd);
// Unregister with Identity manager
if (m_dwIdentCookie != 0)
{
MU_UnregisterIdentityNotifier(m_dwIdentCookie);
m_dwIdentCookie = 0;
}
LeaveCriticalSection(&m_cs);
return (hr);
}
HRESULT CSpoolerDlg::ChangeHangupOption(BOOL fEnable, DWORD dwOption)
{
::ShowWindow(GetDlgItem(m_hwnd, IDC_SP_HANGUP), fEnable ? SW_SHOW : SW_HIDE);
::EnableWindow(GetDlgItem(m_hwnd, IDC_SP_HANGUP), fEnable);
SendDlgItemMessage(m_hwnd, IDC_SP_HANGUP, BM_SETCHECK, dwOption, 0);
return (S_OK);
}
//
// FUNCTION: CSpoolerDlg::PostDlgProc()
//
// PURPOSE: Dialog callback for the spooler dialog proc.
//
INT_PTR CALLBACK CSpoolerDlg::SpoolerDlgProc(HWND hwnd, UINT uMsg, WPARAM wParam,
LPARAM lParam)
{
CSpoolerDlg *pThis = (CSpoolerDlg *) GetWindowLongPtr(hwnd, DWLP_USER);
LRESULT lResult;
// Pass to spooler bind context
if (pThis && pThis->m_pBindCtx && pThis->m_pBindCtx->OnWindowMessage(hwnd, uMsg, wParam, lParam) == S_OK)
return (TRUE);
switch (uMsg)
{
case WM_INITDIALOG:
// Stash the this pointer so we can use it later
Assert(lParam);
SetWindowLongPtr(hwnd, DWLP_USER, lParam);
pThis = (CSpoolerDlg *) lParam;
return (BOOL) HANDLE_WM_INITDIALOG(hwnd, wParam, lParam,
pThis->OnInitDialog);
case WM_COMMAND:
if (pThis)
HANDLE_WM_COMMAND(hwnd, wParam, lParam, pThis->OnCommand);
return (TRUE);
case WM_NOTIFY:
if (pThis)
{
lResult = HANDLE_WM_NOTIFY(hwnd, wParam, lParam, pThis->OnNotify);
SetDlgMsgResult(hwnd, WM_NOTIFY, lResult);
}
return (TRUE);
case WM_DRAWITEM:
if (pThis)
HANDLE_WM_DRAWITEM(hwnd, wParam, lParam, pThis->OnDrawItem);
return (TRUE);
case WM_MEASUREITEM:
if (pThis)
HANDLE_WM_MEASUREITEM(hwnd, wParam, lParam, pThis->OnMeasureItem);
return (TRUE);
case WM_DELETEITEM:
if (pThis)
HANDLE_WM_DELETEITEM(hwnd, wParam, lParam, pThis->OnDeleteItem);
return (TRUE);
#if 0
case WM_SYSCOLORCHANGE:
case WM_SETTINGCHANGE:
if (pThis)
HANDLE_WM_SYSCOLORCHANGE(hwnd, wParam, lParam, pThis->OnSysColorChange);
return (TRUE);
#endif
case WM_CLOSE:
if (pThis)
HANDLE_WM_CLOSE(hwnd, wParam, lParam, pThis->OnClose);
return (TRUE);
case WM_DESTROY:
if (pThis)
HANDLE_WM_DESTROY(hwnd, wParam, lParam, pThis->OnDestroy);
return (TRUE);
case IMAIL_SHOWWINDOW:
::ShowWindow(hwnd, (int) lParam);
if (pThis)
pThis->ToggleStatics(lParam == SW_HIDE);
return (TRUE);
case WM_QUERYENDSESSION:
if (pThis && pThis->m_pBindCtx)
{
SetWindowLongPtr(hwnd, DWLP_MSGRESULT, pThis->m_pBindCtx->QueryEndSession(wParam, lParam));
return (TRUE);
}
break;
case WM_CONTEXTMENU:
if (pThis)
{
HANDLE_WM_CONTEXTMENU(hwnd, wParam, lParam, pThis->OnContextMenu);
return (TRUE);
}
break;
}
return (FALSE);
}
//
// FUNCTION: CSpoolerDlg::OnInitDialog()
//
// PURPOSE: Initializes the dialog.
//
// PARAMETERS:
// <in> hwnd - Handle of the dialog window.
// <in> hwndFocus - Handle of the control that will start with the focus.
// <in> lParam - Extra data being passed to the dialog.
//
// RETURN VALUE:
// Return TRUE to set the focus to hwndFocus
//
BOOL CSpoolerDlg::OnInitDialog(HWND hwnd, HWND hwndFocus, LPARAM lParam)
{
m_hwnd = hwnd;
// Bug #38692 - Set the font correctly for Intl charsets
SetIntlFont(hwnd);
SetIntlFont(GetDlgItem(hwnd, IDC_SP_GENERAL_PROG));
SetIntlFont(GetDlgItem(hwnd, IDC_SP_SPECIFIC_PROG));
SetIntlFont(GetDlgItem(hwnd, IDC_SP_EVENTS));
SetIntlFont(GetDlgItem(hwnd, IDC_SP_ERRORS));
SetIntlFont(GetDlgItem(hwnd, IDC_SP_IDLETEXT));
// Initialize the controls on the dialog
InitializeTabs();
InitializeLists();
InitializeAnimation();
InitializeToolbar();
ToggleStatics(TRUE);
// Hide the Hangup when done deal.
// ::ShowWindow(GetDlgItem(m_hwnd, IDC_SP_HANGUP), SW_HIDE);
// Set the hangup when done option
Button_SetCheck(GetDlgItem(m_hwnd, IDC_SP_HANGUP), DwGetOption(OPT_DIALUP_HANGUP_DONE));
// Get some information from the dialog template we'll need later
GetDlgItemText(m_hwnd, IDC_SP_OVERALL_STATUS, m_szCount, ARRAYSIZE(m_szCount));
// Initialize the rectangles that we'll need for sizing later
RECT rcSep;
GetWindowRect(GetDlgItem(hwnd, IDC_SP_SEPARATOR), &rcSep);
GetWindowRect(hwnd, &m_rcDlg);
m_cyCollapsed = rcSep.top - m_rcDlg.top;
// Load the window size from the registry
WINDOWPLACEMENT wp;
wp.length = sizeof(WINDOWPLACEMENT);
if (GetOption(OPT_SPOOLERDLGPOS, (LPVOID*) &wp, sizeof(WINDOWPLACEMENT)))
{
wp.showCmd = SW_HIDE;
SetWindowPlacement(hwnd, &wp);
ExpandCollapse(m_cyCollapsed < (DWORD) ((wp.rcNormalPosition.bottom - wp.rcNormalPosition.top)), FALSE);
}
else
{
// Center the dialog on the screen.
CenterDialog(hwnd);
ExpandCollapse(FALSE, FALSE);
}
// Set the state of the thumbtack
DWORD dwTack;
if (DwGetOption(OPT_SPOOLERTACK))
{
SendDlgItemMessage(hwnd, IDC_SP_TOOLBAR, TB_SETSTATE, IDC_SP_TACK,
MAKELONG(TBSTATE_CHECKED | TBSTATE_ENABLED, 0));
SendMessage(hwnd, WM_COMMAND, IDC_SP_TACK, 0);
}
// Disable the stop button
EnableWindow(GetDlgItem(hwnd, IDC_SP_STOP), FALSE);
// Subclass the list box
HWND hwnderr = GetDlgItem(hwnd, IDC_SP_ERRORS);
WNDPROC proc = (WNDPROC) GetWindowLongPtr(hwnderr, GWLP_WNDPROC);
SetProp(hwnderr, c_szWndProc, proc);
SetWindowLongPtr(hwnderr, GWLP_WNDPROC, (LPARAM) ListSubClassProc);
// BUG: 44376. ATOK11 has a hidden window. If we return TRUE user will do a setfocus on US, at this point the browser
// thread is block waiting for the spooler to complete and when ATOK gets a WM_ACTIVATE they interthreadsendmsg on our blocked
// browser window with inf. timeout. So we hang at startup. Don't set focus in here at startup time.
return (FALSE);
}
//
// FUNCTION: CSpoolerDlg::OnCommand()
//
// PURPOSE: Handle the various command messages dispatched from the dialog
//
void CSpoolerDlg::OnCommand(HWND hwnd, int id, HWND hwndCtl, UINT codeNotify)
{
switch (id)
{
case IDCANCEL:
case IDC_SP_MINIMIZE:
if (m_fShutdown)
{
Assert(m_pBindCtx);
EnableWindow(GetDlgItem(hwnd, IDC_SP_MINIMIZE), FALSE);
m_pBindCtx->UIShutdown();
}
else
ShowWindow(SW_HIDE);
break;
case IDC_SP_STOP:
if (m_pBindCtx)
{
m_pBindCtx->Cancel();
if (GetFocus() == GetDlgItem(hwnd, IDC_SP_STOP))
SetFocus(GetDlgItem(hwnd, IDC_SP_MINIMIZE));
EnableWindow(GetDlgItem(hwnd, IDC_SP_STOP), FALSE);
}
break;
case IDC_SP_TACK:
{
UINT state = (UINT) SendDlgItemMessage(m_hwnd, IDC_SP_TOOLBAR, TB_GETSTATE,
IDC_SP_TACK, 0);
SendDlgItemMessage(m_hwnd, IDC_SP_TOOLBAR, TB_CHANGEBITMAP,
IDC_SP_TACK,
MAKELPARAM(state & TBSTATE_CHECKED ? IMAGE_TACK_IN : IMAGE_TACK_OUT, 0));
}
break;
case IDC_SP_DETAILS:
m_fSaveSize = TRUE;
ExpandCollapse(!m_fExpanded);
break;
case IDC_SP_HANGUP:
SetDwOption(OPT_DIALUP_HANGUP_DONE, BST_CHECKED == Button_GetCheck(hwndCtl), NULL, 0);
break;
}
}
//
// FUNCTION: CSpoolerDlg::OnNotify
//
// PURPOSE: Handles notifications from the common controls on the dialog.
//
LRESULT CSpoolerDlg::OnNotify(HWND hwnd, int idFrom, LPNMHDR pnmhdr)
{
switch (pnmhdr->code)
{
case TCN_SELCHANGE:
OnTabChange(pnmhdr);
return (0);
}
return (0);
}
//
// FUNCTION: CSpoolerDlg::OnDrawItem()
//
// PURPOSE: Draws the link buttons
//
// PARAMETERS:
// <in> hwnd - Handle of the dialog window
// <in> lpDrawItem - Pointer to a DRAWITEMSTRUCT with the info needed to
// draw the button.
//
void CSpoolerDlg::OnDrawItem(HWND hwnd, const DRAWITEMSTRUCT* lpDrawItem)
{
HDC hdc = lpDrawItem->hDC;
COLORREF clrText, clrBack;
RECT rcText, rcFocus;
SIZE size;
BOOL fSelected = (lpDrawItem->itemState & ODS_SELECTED) &&
(GetFocus() == lpDrawItem->hwndItem);
Assert(lpDrawItem->CtlType == ODT_LISTBOX);
if (lpDrawItem->itemID == -1)
goto exit;
// Draw the bullet first
ImageList_Draw(m_himlImages,
IMAGE_BULLET,
hdc,
BULLET_INDENT,
lpDrawItem->rcItem.top,
fSelected ? ILD_SELECTED | ILD_TRANSPARENT : ILD_TRANSPARENT);
// Set up the text rectangle
rcText = lpDrawItem->rcItem;
rcText.left += BULLET_WIDTH;
// Set up the text and background colors
clrBack = SetBkColor(hdc, GetSysColor(fSelected ? COLOR_HIGHLIGHT : COLOR_WINDOW));
clrText = SetTextColor(hdc, GetSysColor(fSelected ? COLOR_HIGHLIGHTTEXT : COLOR_WINDOWTEXT));
// Draw the text
FillRect(hdc, &rcText, (HBRUSH)IntToPtr((fSelected ? COLOR_HIGHLIGHT : COLOR_WINDOW) + 1));
InflateRect(&rcText, -2, -2);
DrawText(hdc, ((LBDATA *) lpDrawItem->itemData)->pszText, -1, &rcText, DT_NOCLIP | DT_WORDBREAK);
// If we need a focus rect, do that too
if (lpDrawItem->itemState & ODS_FOCUS)
{
rcFocus = lpDrawItem->rcItem;
rcFocus.left += BULLET_WIDTH;
// InflateRect(&rcFocus, -2, -2);
DrawFocusRect(hdc, &rcFocus);
}
SetBkColor(hdc, clrBack);
SetTextColor(hdc, clrText);
exit:
return;
}
void CSpoolerDlg::OnMeasureItem(HWND hwnd, MEASUREITEMSTRUCT *pMeasureItem)
{
LBDATA *pData = NULL;
EnterCriticalSection(&m_cs);
// Set the height of the item
if (NULL != (pData = (LBDATA *) ListBox_GetItemData(m_hwndErrors, pMeasureItem->itemID)))
{
pMeasureItem->itemHeight = pData->rcText.bottom;
}
LeaveCriticalSection(&m_cs);
}
void CSpoolerDlg::OnDeleteItem(HWND hwnd, const DELETEITEMSTRUCT * lpDeleteItem)
{
EnterCriticalSection(&m_cs);
if (lpDeleteItem->itemData)
{
SafeMemFree(((LBDATA *)lpDeleteItem->itemData)->pszText);
MemFree((LPVOID) lpDeleteItem->itemData);
}
LeaveCriticalSection(&m_cs);
}
//
// FUNCTION: CSpoolerDlg::OnClose()
//
// PURPOSE: Handles the WM_CLOSE notification by sending an IDCANCEL to
// the dialog.
//
void CSpoolerDlg::OnClose(HWND hwnd)
{
SendMessage(hwnd, WM_COMMAND, IDC_SP_MINIMIZE, 0);
}
//
// FUNCTION: CSpoolerDlg::OnDestroy()
//
// PURPOSE: Handles the WM_DESTROY notification by freeing the memory stored
// in the listview items.
//
void CSpoolerDlg::OnDestroy(HWND hwnd)
{
#ifndef _WIN64
Animate_Close(GetDlgItem(m_hwnd, IDC_SP_ANIMATE));
#endif
// Save the window placement
WINDOWPLACEMENT wp;
wp.length = sizeof(WINDOWPLACEMENT);
if (GetWindowPlacement(hwnd, &wp))
{
if (!m_fSaveSize)
{
// Load the old size out of the registry
WINDOWPLACEMENT wp2;
if (GetOption(OPT_SPOOLERDLGPOS, (LPVOID*) &wp2, sizeof(WINDOWPLACEMENT)))
{
wp.rcNormalPosition.bottom = wp.rcNormalPosition.top + (wp2.rcNormalPosition.bottom - wp2.rcNormalPosition.top);
}
else
{
wp.rcNormalPosition.bottom = wp.rcNormalPosition.top + m_cyCollapsed;
}
}
SetOption(OPT_SPOOLERDLGPOS, (LPVOID) &wp, sizeof(WINDOWPLACEMENT), NULL, 0);
}
DWORD dwState;
dwState = (DWORD) SendDlgItemMessage(m_hwnd, IDC_SP_TOOLBAR, TB_GETSTATE, IDC_SP_TACK, 0);
SetDwOption(OPT_SPOOLERTACK, !!(dwState & TBSTATE_CHECKED), NULL, 0);
HIMAGELIST himl;
himl = (HIMAGELIST)SendDlgItemMessage(m_hwnd, IDC_SP_TOOLBAR, TB_GETIMAGELIST, 0, 0);
if (himl)
ImageList_Destroy(himl);
HWND hwnderr = GetDlgItem(hwnd, IDC_SP_ERRORS);
WNDPROC proc = (WNDPROC)GetProp(hwnderr, c_szWndProc);
if (proc != NULL)
{
SetWindowLongPtr(hwnderr, GWLP_WNDPROC, (LPARAM)proc);
RemoveProp(hwnderr, c_szWndProc);
}
}
//
// FUNCTION: CSpoolerDlg::InitializeTabs()
//
// PURPOSE: Initializes the tab control on the dialog.
//
// RETURN VALUE:
// TRUE if everything succeeded, FALSE otherwise.
//
BOOL CSpoolerDlg::InitializeTabs(void)
{
HWND hwndTabs = GetDlgItem(m_hwnd, IDC_SP_TABS);
TC_ITEM tci;
TCHAR szRes[CCHMAX_STRINGRES];
// "Tasks"
tci.mask = TCIF_TEXT;
tci.pszText = AthLoadString(idsTasks, szRes, ARRAYSIZE(szRes));
TabCtrl_InsertItem(hwndTabs, 0, &tci);
// "Errors"
tci.pszText = AthLoadString(idsErrors, szRes, ARRAYSIZE(szRes));
TabCtrl_InsertItem(hwndTabs, 1, &tci);
return (TRUE);
}
//
// FUNCTION: CSpoolerDlg::InitializeLists()
//
// PURPOSE: Initializes the list control on the dialog.
//
// RETURN VALUE:
// TRUE if everything succeeded, FALSE otherwise.
//
BOOL CSpoolerDlg::InitializeLists(void)
{
LV_COLUMN lvc;
TCHAR szRes[CCHMAX_STRINGRES];
RECT rcClient;
DWORD cx;
// Store the handle for the events list since we use it frequently
m_hwndEvents = GetDlgItem(m_hwnd, IDC_SP_EVENTS);
// Get the size of the client rect of the listview
GetClientRect(m_hwndEvents, &rcClient);
// "Tasks" column
lvc.mask = LVCF_FMT | LVCF_SUBITEM | LVCF_TEXT | LVCF_WIDTH;
lvc.fmt = LVCFMT_CENTER;
lvc.cx = rcClient.right / 2;
lvc.pszText = AthLoadString(idsTasks, szRes, ARRAYSIZE(szRes));
lvc.iSubItem = 0;
ListView_InsertColumn(m_hwndEvents, 0, &lvc);
// "Status" column
cx = (rcClient.right / 2 - GetSystemMetrics(SM_CXVSCROLL)) / 2;
lvc.cx = cx;
lvc.pszText = AthLoadString(idsStatusCol, szRes, ARRAYSIZE(szRes));
lvc.iSubItem = 1;
ListView_InsertColumn(m_hwndEvents, 1, &lvc);
// "Connection" column
lvc.cx = cx;
lvc.pszText = AthLoadString(idsConnection, szRes, ARRAYSIZE(szRes));
lvc.iSubItem = 2;
ListView_InsertColumn(m_hwndEvents, 2, &lvc);
// Set the listview image list
m_himlImages = ImageList_LoadBitmap(g_hLocRes, MAKEINTRESOURCE(idbSpooler), 16, 0,
RGB(255, 0, 255));
if (m_himlImages)
ListView_SetImageList(m_hwndEvents, m_himlImages, LVSIL_SMALL);
// The listview looks better if we use full row select
ListView_SetExtendedListViewStyle(m_hwndEvents, LVS_EX_FULLROWSELECT | LVS_EX_INFOTIP);
// Initialize the Error list
m_hwndErrors = GetDlgItem(m_hwnd, IDC_SP_ERRORS);
::ShowWindow(m_hwndErrors, FALSE);
EnableWindow(m_hwndErrors, FALSE);
// Save the width of the error list
GetClientRect(m_hwndErrors, &rcClient);
m_cxErrors = rcClient.right;
return (TRUE);
}
//
// FUNCTION: CSpoolerDlg::InitializeAnimation()
//
// PURPOSE: Initializes the animation controls on the dialog.
//
// RETURN VALUE:
// TRUE if everything succeeded, FALSE otherwise.
//
BOOL CSpoolerDlg::InitializeAnimation(void)
{
#ifndef _WIN64
HWND hwndAni = GetDlgItem(m_hwnd, IDC_SP_ANIMATE);
Animate_OpenEx(hwndAni, g_hLocRes, MAKEINTRESOURCE(idanOutbox));
#endif
return (0);
}
//
// FUNCTION: CSpoolerDlg::InitializeToolbar()
//
// PURPOSE: What dialog would be complete without a toolbar, eh?
//
// RETURN VALUE:
// TRUE if everything succeeded, FALSE otherwise.
//
BOOL CSpoolerDlg::InitializeToolbar(void)
{
HWND hwndTool;
RECT rcTabs;
POINT point;
HIMAGELIST himlImages = ImageList_LoadBitmap(g_hLocRes, MAKEINTRESOURCE(idbSpooler), 16, 0,
RGB(255, 0, 255));
GetWindowRect(GetDlgItem(m_hwnd, IDC_SP_TABS), &rcTabs);
point.x = rcTabs.right - 22;
point.y = rcTabs.bottom + 3;
ScreenToClient(m_hwnd, &point);
hwndTool = CreateWindowEx(0, TOOLBARCLASSNAME, NULL,
CCS_NODIVIDER | CCS_NORESIZE | CCS_NOPARENTALIGN |
WS_VISIBLE | WS_CHILD | WS_CLIPSIBLINGS | TBSTYLE_FLAT,
point.x, point.y, 22, 22,
m_hwnd, (HMENU) IDC_SP_TOOLBAR,
g_hInst, 0);
if (hwndTool)
{
#ifndef WIN16
TBBUTTON tb = { IMAGE_TACK_OUT, IDC_SP_TACK, TBSTATE_ENABLED, TBSTYLE_CHECK, {0, 0}, 0, 0 };
#else
TBBUTTON tb = { IMAGE_TACK_OUT, IDC_SP_TACK, TBSTATE_ENABLED, TBSTYLE_CHECK, 0, 0 };
#endif
SendMessage(hwndTool, TB_SETIMAGELIST, 0, (LPARAM) himlImages);
SendMessage(hwndTool, TB_BUTTONSTRUCTSIZE, sizeof(TBBUTTON), 0);
SendMessage(hwndTool, TB_SETBUTTONSIZE, 0, MAKELONG(14, 14));
SendMessage(hwndTool, TB_SETBITMAPSIZE, 0, MAKELONG(14, 14));
SendMessage(hwndTool, TB_ADDBUTTONS, 1, (LPARAM) &tb);
}
return (0);
}
//
// FUNCTION: CSpoolerDlg::ExpandCollapse()
//
// PURPOSE: Takes care of showing and hiding the "details" part of the
// error dialog.
//
// PARAMETERS:
// <in> fExpand - TRUE if we should be expanding the dialog.
//
void CSpoolerDlg::ExpandCollapse(BOOL fExpand, BOOL fSetFocus)
{
RECT rcSep;
TCHAR szBuf[64];
m_fExpanded = fExpand;
GetWindowRect(GetDlgItem(m_hwnd, IDC_SP_SEPARATOR), &rcSep);
if (!m_fExpanded)
SetWindowPos(m_hwnd, 0, 0, 0, m_rcDlg.right - m_rcDlg.left,
m_cyCollapsed, SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
else
SetWindowPos(m_hwnd, 0, 0, 0, m_rcDlg.right - m_rcDlg.left,
m_rcDlg.bottom - m_rcDlg.top, SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
// Make sure the entire dialog is visible on the screen. If not,
// then push it up
RECT rc;
RECT rcWorkArea;
GetWindowRect(m_hwnd, &rc);
SystemParametersInfo(SPI_GETWORKAREA, 0, (LPVOID) &rcWorkArea, 0);
if (rc.bottom > rcWorkArea.bottom)
{
rc.top = max(0, (int) rc.top - (rc.bottom - rcWorkArea.bottom));
SetWindowPos(m_hwnd, 0, rc.left, rc.top, 0, 0, SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
}
AthLoadString(m_fExpanded ? idsHideDetails : idsShowDetails, szBuf,
ARRAYSIZE(szBuf));
SetDlgItemText(m_hwnd, IDC_SP_DETAILS, szBuf);
if (fExpand)
{
switch (m_iTab)
{
case TAB_TASKS:
UpdateLists(TRUE, FALSE, FALSE);
break;
case TAB_ERRORS:
UpdateLists(FALSE, TRUE, FALSE);
break;
}
}
else
UpdateLists(FALSE, FALSE, FALSE);
// Raid-34387: Spooler: Closing details with ALT-D while focus is on a task disables keyboard input
if (!fExpand && fSetFocus)
SetFocus(GetDlgItem(m_hwnd, IDC_SP_DETAILS));
}
//
// FUNCTION: CSpoolerDlg::OnTabChange()
//
// PURPOSE: Gets called in response to the user changing which tab is
// the selected tab. In response, we update which listview
// is currently visible.
//
// PARAMETERS:
// <in> pnmhdr - Pointer to the notification information
//
void CSpoolerDlg::OnTabChange(LPNMHDR pnmhdr)
{
HWND hwndDisable1, hwndDisable2 = 0, hwndEnable;
// Find out which tab is currently active
m_iTab = TabCtrl_GetCurSel(GetDlgItem(m_hwnd, IDC_SP_TABS));
if (-1 == m_iTab)
return;
// Update which listview is visible
switch (m_iTab)
{
case TAB_TASKS:
// Hide the error listview, show the tasks list
UpdateLists(TRUE, FALSE, FALSE);
break;
case TAB_ERRORS:
// Hide the error listview, show the tasks list
UpdateLists(FALSE, TRUE, FALSE);
break;
}
}
//
// FUNCTION: CSpoolerDlg::UpdateLists()
//
// PURPOSE: Does the work of hiding and showing the lists when the
// tab selection changes.
//
// PARAMETERS:
// <in> fEvents - TRUE to display the events list
// <in> fErrors - TRUE to display the error list
// <in> fHistory - TRUE to display the history list
//
void CSpoolerDlg::UpdateLists(BOOL fEvents, BOOL fErrors, BOOL fHistory)
{
if (IsWindow(m_hwndEvents))
{
EnableWindow(m_hwndEvents, fEvents);
::ShowWindow(m_hwndEvents, fEvents ? SW_SHOWNA : SW_HIDE);
}
if (IsWindow(m_hwndErrors))
{
EnableWindow(m_hwndErrors, fErrors);
::ShowWindow(m_hwndErrors, fErrors ? SW_SHOWNA : SW_HIDE);
}
}
void CSpoolerDlg::ToggleStatics(BOOL fIdle)
{
m_fIdle = fIdle;
if (fIdle)
{
EnableWindow(GetDlgItem(m_hwnd, IDC_SP_GENERAL_PROG), FALSE);
EnableWindow(GetDlgItem(m_hwnd, IDC_SP_SPECIFIC_PROG), FALSE);
EnableWindow(GetDlgItem(m_hwnd, IDC_SP_ANIMATE), FALSE);
EnableWindow(GetDlgItem(m_hwnd, IDC_SP_IDLETEXT), TRUE);
EnableWindow(GetDlgItem(m_hwnd, IDC_SP_IDLEICON), TRUE);
::ShowWindow(GetDlgItem(m_hwnd, IDC_SP_GENERAL_PROG), SW_HIDE);
::ShowWindow(GetDlgItem(m_hwnd, IDC_SP_SPECIFIC_PROG), SW_HIDE);
::ShowWindow(GetDlgItem(m_hwnd, IDC_SP_ANIMATE), SW_HIDE);
::ShowWindow(GetDlgItem(m_hwnd, IDC_SP_IDLETEXT), SW_SHOWNA);
::ShowWindow(GetDlgItem(m_hwnd, IDC_SP_IDLEICON), SW_SHOWNA);
}
else
{
EnableWindow(GetDlgItem(m_hwnd, IDC_SP_GENERAL_PROG), TRUE);
EnableWindow(GetDlgItem(m_hwnd, IDC_SP_SPECIFIC_PROG), TRUE);
EnableWindow(GetDlgItem(m_hwnd, IDC_SP_ANIMATE), TRUE);
EnableWindow(GetDlgItem(m_hwnd, IDC_SP_IDLETEXT), FALSE);
EnableWindow(GetDlgItem(m_hwnd, IDC_SP_IDLEICON), FALSE);
::ShowWindow(GetDlgItem(m_hwnd, IDC_SP_GENERAL_PROG), SW_SHOWNA);
::ShowWindow(GetDlgItem(m_hwnd, IDC_SP_SPECIFIC_PROG), SW_SHOWNA);
::ShowWindow(GetDlgItem(m_hwnd, IDC_SP_ANIMATE), SW_SHOWNA);
::ShowWindow(GetDlgItem(m_hwnd, IDC_SP_IDLETEXT), SW_HIDE);
::ShowWindow(GetDlgItem(m_hwnd, IDC_SP_IDLEICON), SW_HIDE);
}
}
void CSpoolerDlg::OnContextMenu(HWND hwnd, HWND hwndContext, UINT xPos, UINT yPos)
{
POINT pt = {xPos, yPos};
RECT rcError;
LBDATA *pData = NULL;
// Check to see if the error window is visible
if (!IsWindowVisible(m_hwndErrors))
return;
// Check to see if the click was within the error window
GetWindowRect(m_hwndErrors, &rcError);
if (!PtInRect(&rcError, pt))
return;
// Do the context menu
HMENU hMenu = CreatePopupMenu();
// Add a "Copy..." item
TCHAR szRes[CCHMAX_STRINGRES];
AthLoadString(idsCopyTT, szRes, ARRAYSIZE(szRes));
// Add it to the menu
InsertMenu(hMenu, -1, MF_BYPOSITION | MF_STRING, ID_COPY, szRes);
// If the click is on an item in the listbox, then enable the command
ScreenToClient(m_hwndErrors, &pt);
DWORD iItem = (DWORD) SendMessage(m_hwndErrors, LB_ITEMFROMPOINT, 0, MAKELPARAM(pt.x, pt.y));
if (iItem != -1)
{
EnterCriticalSection(&m_cs);
pData = (LBDATA *) ListBox_GetItemData(m_hwndErrors, iItem);
LeaveCriticalSection(&m_cs);
}
if (iItem == -1 || NULL == pData || ((LBDATA*)-1) == pData)
EnableMenuItem(hMenu, ID_COPY, MF_BYCOMMAND | MF_GRAYED);
// Show the menu
DWORD id;
id = TrackPopupMenuEx(hMenu, TPM_RETURNCMD | TPM_LEFTALIGN | TPM_RIGHTBUTTON | TPM_NONOTIFY,
xPos, yPos, m_hwndErrors, NULL);
if (id == ID_COPY)
{
// Get the item data for the item they clicked on
LPTSTR pszDup;
EnterCriticalSection(&m_cs);
// Set the height of the item
if (NULL != pData && ((LBDATA*)-1) != pData)
{
// Dupe the string. Clipboard owns the copy.
pszDup = PszDupA(pData->pszText);
// Put it on the clipboard
OpenClipboard(m_hwndErrors);
EmptyClipboard();
SetClipboardData(CF_TEXT, pszDup);
CloseClipboard();
}
LeaveCriticalSection(&m_cs);
}
if (hMenu)
DestroyMenu(hMenu);
}
HRESULT CSpoolerDlg::QuerySwitchIdentities()
{
DWORD_PTR dwResult;
if (!IsWindowEnabled(m_hwnd))
return E_PROCESS_CANCELLED_SWITCH;
if (m_pBindCtx)
{
dwResult = m_pBindCtx->QueryEndSession(0, ENDSESSION_LOGOFF);
SetWindowLongPtr(m_hwnd, DWLP_MSGRESULT, dwResult);
if (dwResult != TRUE)
return E_PROCESS_CANCELLED_SWITCH;
}
return S_OK;
}
HRESULT CSpoolerDlg::SwitchIdentities()
{
return S_OK;
}
HRESULT CSpoolerDlg::IdentityInformationChanged(DWORD dwType)
{
return S_OK;
}
LRESULT CALLBACK CSpoolerDlg::ListSubClassProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
if (uMsg == WM_KEYDOWN && wParam == 'C')
{
if (0 > GetAsyncKeyState(VK_CONTROL))
{
int iSel = (int) SendMessage(hwnd, LB_GETCURSEL, 0, 0);
if (LB_ERR != iSel)
{
LBDATA *pData = NULL;
LPTSTR pszDup;
// Set the height of the item
if (NULL != (pData = (LBDATA *) ListBox_GetItemData(hwnd, iSel)))
{
// Dupe the string. Clipboard owns the copy.
pszDup = PszDupA(pData->pszText);
// Put it on the clipboard
OpenClipboard(hwnd);
EmptyClipboard();
SetClipboardData(CF_TEXT, pszDup);
CloseClipboard();
}
}
}
}
WNDPROC wp = (WNDPROC) GetProp(hwnd, c_szWndProc);
return (CallWindowProc(wp, hwnd, uMsg, wParam, lParam));
}