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.
824 lines
18 KiB
824 lines
18 KiB
/*++
|
|
|
|
Copyright (c) 1996 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
coverpg.c
|
|
|
|
Abstract:
|
|
|
|
Functions for working with cover pages
|
|
|
|
Environment:
|
|
|
|
Windows XP fax driver user interface
|
|
|
|
Revision History:
|
|
|
|
02/05/96 -davidx-
|
|
Created it.
|
|
|
|
10/20/99 -danl-
|
|
Get server name properly in GetServerCoverPageDirs.
|
|
|
|
mm/dd/yy -author-
|
|
description
|
|
|
|
--*/
|
|
|
|
#include "faxui.h"
|
|
#include <faxreg.h>
|
|
#include <shlobj.h>
|
|
#include <shellapi.h>
|
|
#include <commdlg.h>
|
|
#include "faxutil.h"
|
|
|
|
#define STRSAFE_NO_DEPRECATE
|
|
#include <strsafe.h>
|
|
|
|
|
|
//
|
|
// Suffix string appended to all user cover page filenames
|
|
//
|
|
|
|
static TCHAR PersonalSuffixStr[64];
|
|
|
|
|
|
|
|
VOID
|
|
InsertOneCoverPageFilenameToList(
|
|
HWND hwndList,
|
|
LPTSTR pFilename,
|
|
INT flags
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Insert one cover page filename into the list of cover pages
|
|
|
|
Arguments:
|
|
|
|
hwndList - Handle to list window
|
|
pFilename - Name of the cover page file
|
|
flags - Flags to be associated with the list item
|
|
|
|
Return Value:
|
|
|
|
NONE
|
|
|
|
--*/
|
|
|
|
{
|
|
INT listIndex;
|
|
LPTSTR pBuffer = NULL;
|
|
|
|
//
|
|
// Add " (Personal)" suffix to all user cover pages
|
|
//
|
|
|
|
if ((flags & CPFLAG_SERVERCP) == 0) {
|
|
|
|
if (IsEmptyString(PersonalSuffixStr))
|
|
{
|
|
if(!LoadString(g_hResource, IDS_USERCP_SUFFIX, PersonalSuffixStr, 64))
|
|
{
|
|
Assert(FALSE);
|
|
}
|
|
}
|
|
|
|
if (pBuffer = MemAlloc(SizeOfString(pFilename) + SizeOfString(PersonalSuffixStr)))
|
|
{
|
|
_tcscpy(pBuffer, pFilename);
|
|
_tcscat(pBuffer, PersonalSuffixStr);
|
|
|
|
flags |= CPFLAG_SUFFIX;
|
|
pFilename = pBuffer;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Insert the cover page filename into the list
|
|
//
|
|
|
|
listIndex = (INT)SendMessage(hwndList, CB_ADDSTRING, 0, (LPARAM) pFilename);
|
|
|
|
if (listIndex != CB_ERR)
|
|
SendMessage(hwndList, CB_SETITEMDATA, listIndex, flags);
|
|
|
|
MemFree(pBuffer);
|
|
}
|
|
|
|
|
|
|
|
VOID
|
|
AddCoverPagesToList(
|
|
PCPDATA pCPInfo,
|
|
HWND hwndList,
|
|
LPTSTR pSelected,
|
|
INT nDirs
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Add the cover page files in the specified directory to a list
|
|
|
|
Arguments:
|
|
|
|
pCPInfo - Points to cover page information
|
|
hwndList - Handle to a list window
|
|
pSelected - Currently selected cover page
|
|
nDirs - Cover page directory index
|
|
|
|
Return Value:
|
|
|
|
NONE
|
|
|
|
--*/
|
|
|
|
{
|
|
WIN32_FIND_DATA findData;
|
|
TCHAR filename[MAX_PATH];
|
|
HANDLE hFindFile;
|
|
LPTSTR pDirPath, pExtension;
|
|
INT dirLen, fileLen, flags;
|
|
TCHAR tszPathName[MAX_PATH] = {0};
|
|
TCHAR* pPathEnd;
|
|
|
|
//
|
|
// Are we working on server or user cover pages?
|
|
//
|
|
|
|
flags = nDirs | ((nDirs < pCPInfo->nServerDirs) ? CPFLAG_SERVERCP : 0);
|
|
pDirPath = pCPInfo->pDirPath[nDirs];
|
|
|
|
if (IsEmptyString(pDirPath))
|
|
return;
|
|
|
|
_tcsncpy(tszPathName, pDirPath, ARR_SIZE(tszPathName)-1);
|
|
tszPathName[ARR_SIZE(tszPathName) - 1] = TEXT('\0');
|
|
pPathEnd = _tcschr(tszPathName, '\0');
|
|
|
|
//
|
|
// Look at the directory prefix of the currently selected cover page file
|
|
//
|
|
|
|
if ((dirLen = _tcslen(pDirPath)) >= MAX_PATH - MAX_FILENAME_EXT - 1)
|
|
{
|
|
Error(("Directory name too long: %ws\n", pDirPath));
|
|
return;
|
|
}
|
|
|
|
_tcscpy(filename, pDirPath);
|
|
|
|
if (!pSelected || _tcsnicmp(pDirPath, pSelected, dirLen) != EQUAL_STRING)
|
|
{
|
|
pSelected = NULL;
|
|
}
|
|
else
|
|
{
|
|
pSelected += dirLen;
|
|
}
|
|
|
|
//
|
|
// Generate a specification for the files we're interested in
|
|
//
|
|
_tcscat(filename, FAX_COVER_PAGE_MASK);
|
|
|
|
//
|
|
// Call FindFirstFile/FindNextFile to enumerate the files
|
|
// matching our specification
|
|
//
|
|
|
|
hFindFile = FindFirstFile(filename, &findData);
|
|
if (hFindFile == INVALID_HANDLE_VALUE)
|
|
{
|
|
return;
|
|
}
|
|
|
|
do
|
|
{
|
|
//
|
|
// Exclude directories and hidden files
|
|
//
|
|
|
|
if (findData.dwFileAttributes & (FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_DIRECTORY))
|
|
continue;
|
|
|
|
//
|
|
// Make sure we have enough room to store the full pathname
|
|
//
|
|
|
|
if ((fileLen = _tcslen(findData.cFileName)) <= MAX_FILENAME_EXT)
|
|
continue;
|
|
|
|
if (fileLen + dirLen >= MAX_PATH)
|
|
{
|
|
Error(("Filename too long: %ws%ws\n", pDirPath, findData.cFileName));
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// Compare with the currently selected cover page filename
|
|
//
|
|
if (pSelected && _tcsicmp(pSelected, findData.cFileName) == EQUAL_STRING)
|
|
{
|
|
pSelected = NULL;
|
|
flags |= CPFLAG_SELECTED;
|
|
}
|
|
else
|
|
{
|
|
flags &= ~CPFLAG_SELECTED;
|
|
}
|
|
|
|
|
|
_tcsncpy(pPathEnd, findData.cFileName, MAX_PATH - dirLen);
|
|
if(!IsValidCoverPage(tszPathName))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// Don't display the filename extension
|
|
//
|
|
if (pExtension = _tcsrchr(findData.cFileName, TEXT(FILENAME_EXT))) {
|
|
*pExtension = NUL;
|
|
}
|
|
|
|
//
|
|
// Add the cover page name to the list window
|
|
//
|
|
|
|
InsertOneCoverPageFilenameToList(hwndList, findData.cFileName, flags);
|
|
|
|
} while (FindNextFile(hFindFile, &findData));
|
|
|
|
FindClose(hFindFile);
|
|
}
|
|
|
|
|
|
VOID
|
|
InitCoverPageList(
|
|
PCPDATA pCPInfo,
|
|
HWND hwndList,
|
|
LPTSTR pSelectedCoverPage
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Generate a list of available cover pages (both server and user)
|
|
|
|
Arguments:
|
|
|
|
pCPInfo - Points to cover page information
|
|
hwndList - Handle to the list window
|
|
pSelectedCoverPage - Name of currently selected cover page file
|
|
|
|
Return Value:
|
|
|
|
NONE
|
|
|
|
--*/
|
|
|
|
{
|
|
INT itemFlags, index;
|
|
|
|
//
|
|
// Validate input parameters
|
|
//
|
|
|
|
if (pCPInfo == NULL || hwndList == NULL)
|
|
return;
|
|
|
|
//
|
|
// Disable redraw on the list and reset its content
|
|
//
|
|
|
|
SendMessage(hwndList, WM_SETREDRAW, FALSE, 0);
|
|
SendMessage(hwndList, CB_RESETCONTENT, FALSE, 0);
|
|
|
|
//
|
|
// Add server and user cover pages to the list
|
|
//
|
|
|
|
for (index=0; index < pCPInfo->nDirs; index++)
|
|
AddCoverPagesToList(pCPInfo, hwndList, pSelectedCoverPage, index);
|
|
|
|
//
|
|
// Highlight the currently selected cover page
|
|
//
|
|
|
|
index = (INT)SendMessage(hwndList, CB_GETCOUNT, 0, 0);
|
|
|
|
if (index > 0) {
|
|
|
|
//
|
|
// Go through each list item and check if it should be selected
|
|
//
|
|
|
|
while (--index >= 0) {
|
|
|
|
itemFlags = (INT)SendMessage(hwndList, CB_GETITEMDATA, index, 0);
|
|
|
|
if (itemFlags != CB_ERR && (itemFlags & CPFLAG_SELECTED)) {
|
|
|
|
SendMessage(hwndList, CB_SETCURSEL, index, 0);
|
|
break;
|
|
}
|
|
}
|
|
|
|
//
|
|
// If nothing is selected, select the first item by default
|
|
//
|
|
|
|
if (index < 0)
|
|
SendMessage(hwndList, CB_SETCURSEL, 0, 0);
|
|
}
|
|
|
|
//
|
|
// Enable redraw on the list window
|
|
//
|
|
|
|
SendMessage(hwndList, WM_SETREDRAW, TRUE, 0);
|
|
}
|
|
|
|
|
|
INT
|
|
GetSelectedCoverPage(
|
|
PCPDATA pCPInfo,
|
|
IN HWND hwndList,
|
|
OUT LPTSTR lptstrFullPath,
|
|
IN UINT cchstrFullPath,
|
|
OUT LPTSTR lptstrFileName,
|
|
IN UINT cchstrFileName,
|
|
OUT BOOL * pbIsServerPage
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Retrieves the currently selected cover page name and returns its flags.
|
|
|
|
Provides both its full path and short name and indicates if it is a server cover page or not.
|
|
If the cover page is a personal cover page the returned cover page name is a full path to it.
|
|
If the cover page is a server cover page the returned cover page is just the file name.
|
|
|
|
|
|
Arguments:
|
|
|
|
pCPInfo - Points to cover page information
|
|
hwndList - Handle to the list window
|
|
lptstrFullPath - Points to a buffer for storing the selected cover page full path.
|
|
if lptstrFullPath is NULL the full path is not returned.
|
|
cchstrFullPath - The size of lptstrFullPath in TCHARs.
|
|
lptstrFileName - Points to a buffer for storing the selected cover page file name.
|
|
This parameter can be NULL in which case the file name will not be provided.
|
|
cchstrFileName - The size of lptstrFileName in TCHARs.
|
|
pbIsServerPage - Points to a BOOL variable that is set to TRUE if the selected cover page is a server cover page.
|
|
|
|
Return Value:
|
|
|
|
Flags associated with the currently selected item
|
|
Negative (CB_ERR) if there is an error or the CB is empty (no *.COV files)
|
|
|
|
--*/
|
|
|
|
{
|
|
LPTSTR pDirPath, pFilename;
|
|
INT selIndex, itemFlags, nameLen;
|
|
HRESULT hRc = E_FAIL;
|
|
|
|
//
|
|
// Default to empty string in case of an error
|
|
//
|
|
|
|
if (lptstrFullPath) {
|
|
lptstrFullPath[0] = NUL;
|
|
}
|
|
|
|
if (lptstrFileName) {
|
|
lptstrFileName[0]=NUL;
|
|
}
|
|
|
|
|
|
if (pCPInfo == NULL || hwndList == NULL) {
|
|
return CB_ERR;
|
|
}
|
|
|
|
|
|
//
|
|
// Get currently selected item index
|
|
//
|
|
|
|
// It's possible if there is no item in the combo-box (in case there are no *.COV files)
|
|
if ((selIndex = (INT)SendMessage(hwndList, CB_GETCURSEL, 0, 0)) == CB_ERR) {
|
|
return selIndex;
|
|
}
|
|
|
|
|
|
//
|
|
// Get the flags associated with the currently selected item
|
|
//
|
|
|
|
itemFlags = (INT)SendMessage(hwndList, CB_GETITEMDATA, selIndex, 0);
|
|
|
|
//
|
|
// Let the caller know if this is a server cover page
|
|
//
|
|
*pbIsServerPage=itemFlags & CPFLAG_SERVERCP;
|
|
|
|
|
|
if ((itemFlags != CB_ERR) && (lptstrFullPath || lptstrFileName)) {
|
|
|
|
Assert((itemFlags & CPFLAG_DIRINDEX) < pCPInfo->nDirs);
|
|
pDirPath = pCPInfo->pDirPath[itemFlags & CPFLAG_DIRINDEX];
|
|
|
|
//
|
|
// assemble the full pathname for the cover page file
|
|
// directory prefix
|
|
// display name
|
|
// filename extension
|
|
//
|
|
|
|
|
|
pFilename = NULL;
|
|
|
|
if ((nameLen = (INT)SendMessage(hwndList, CB_GETLBTEXTLEN, selIndex, 0)) != CB_ERR &&
|
|
(pFilename = MemAlloc(sizeof(TCHAR) * (nameLen + 1))) &&
|
|
SendMessage(hwndList, CB_GETLBTEXT, selIndex, (LPARAM) pFilename) != CB_ERR)
|
|
{
|
|
//
|
|
// If the cover page filename has a suffix, we need to remove it first
|
|
//
|
|
|
|
if (itemFlags & CPFLAG_SUFFIX) {
|
|
|
|
INT suffixLen = _tcslen(PersonalSuffixStr);
|
|
|
|
if (nameLen >= suffixLen &&
|
|
_tcscmp(pFilename + (nameLen - suffixLen), PersonalSuffixStr) == EQUAL_STRING)
|
|
{
|
|
*(pFilename + (nameLen - suffixLen)) = NUL;
|
|
|
|
} else
|
|
Error(("Corrupted cover page filename: %ws\n", pFilename));
|
|
|
|
}
|
|
|
|
if (lptstrFullPath)
|
|
{
|
|
hRc = StringCchPrintf(lptstrFullPath, cchstrFullPath, TEXT("%s%s%s"),
|
|
pDirPath,
|
|
pFilename,
|
|
FAX_COVER_PAGE_FILENAME_EXT);
|
|
|
|
if(FAILED(hRc))
|
|
{
|
|
itemFlags = CB_ERR;
|
|
Assert(0);
|
|
}
|
|
}
|
|
|
|
if (lptstrFileName)
|
|
{
|
|
hRc = StringCchPrintf(lptstrFileName, cchstrFileName, TEXT("%s%s"),
|
|
pFilename,
|
|
FAX_COVER_PAGE_FILENAME_EXT);
|
|
if(FAILED(hRc))
|
|
{
|
|
itemFlags = CB_ERR;
|
|
Assert(0);
|
|
}
|
|
}
|
|
|
|
} else {
|
|
itemFlags = CB_ERR;
|
|
}
|
|
|
|
|
|
MemFree(pFilename);
|
|
}
|
|
|
|
return itemFlags;
|
|
}
|
|
|
|
|
|
|
|
BOOL
|
|
GetServerCoverPageDirs(
|
|
LPTSTR lptstrServerName,
|
|
LPTSTR lptstrPrinterName,
|
|
PCPDATA pCPInfo
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Find the directories in which the server cover pages are stored
|
|
|
|
Arguments:
|
|
|
|
lptstrServerName - server name
|
|
|
|
Return Value:
|
|
|
|
TRUE if successful, FALSE otherwise
|
|
|
|
--*/
|
|
|
|
{
|
|
BOOL status = FALSE;
|
|
LPTSTR pServerDir = NULL;
|
|
LPTSTR pServerSubDir, p;
|
|
|
|
Assert(pCPInfo);
|
|
Assert(lptstrPrinterName);
|
|
|
|
pServerDir = MemAlloc(sizeof(TCHAR) * MAX_PATH);
|
|
if (!pServerDir) {
|
|
Error(("Memory allocation failed\n"));
|
|
goto exit;
|
|
}
|
|
|
|
|
|
if ( !GetServerCpDir(lptstrServerName,
|
|
pServerDir,
|
|
MAX_PATH)
|
|
)
|
|
{
|
|
Error(("GetServerCpDir failed\n"));
|
|
goto exit;
|
|
}
|
|
|
|
pCPInfo->pDirPath[pCPInfo->nDirs] = pServerDir;
|
|
pCPInfo->nDirs += 1;
|
|
pCPInfo->nServerDirs += 1;
|
|
status = TRUE;
|
|
|
|
//
|
|
// Find a subdirectory for the specified printer
|
|
//
|
|
|
|
if (p = _tcsrchr(lptstrPrinterName, FAX_PATH_SEPARATOR_CHR))
|
|
p++;
|
|
else
|
|
p = lptstrPrinterName;
|
|
|
|
if ((_tcslen(pServerDir) + _tcslen(p) + 1 < MAX_PATH ) &&
|
|
(pServerSubDir = MemAlloc(sizeof(TCHAR) * MAX_PATH)))
|
|
{
|
|
_sntprintf( pServerSubDir,
|
|
MAX_PATH -1,
|
|
TEXT("%s\\%s"),
|
|
pServerDir,
|
|
p);
|
|
pServerSubDir[MAX_PATH -1] = _T('\0');
|
|
|
|
pCPInfo->pDirPath[pCPInfo->nDirs] = pServerSubDir;
|
|
pCPInfo->nDirs += 1;
|
|
pCPInfo->nServerDirs += 1;
|
|
}
|
|
|
|
|
|
//
|
|
// Clean up before returning to caller
|
|
//
|
|
|
|
exit:
|
|
if (!status) {
|
|
MemFree(pServerDir);
|
|
}
|
|
|
|
|
|
return status;
|
|
}
|
|
|
|
|
|
|
|
VOID
|
|
AppendPathSeparator(
|
|
LPTSTR pDirPath
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Append a path separator (if necessary) at the end of a directory name
|
|
|
|
Arguments:
|
|
|
|
pDirPath - Points to a directory name
|
|
|
|
Return Value:
|
|
|
|
NONE
|
|
|
|
--*/
|
|
|
|
{
|
|
INT length;
|
|
TCHAR* pLast = NULL;
|
|
|
|
//
|
|
// Calculate the length of directory string
|
|
//
|
|
|
|
length = _tcslen(pDirPath);
|
|
|
|
if (length >= MAX_PATH-1 || length < 1)
|
|
return;
|
|
|
|
//
|
|
// If the last character is not a path separator,
|
|
// append a path separator at the end
|
|
//
|
|
pLast = _tcsrchr(pDirPath,TEXT('\\'));
|
|
if( !( pLast && (*_tcsinc(pLast)) == '\0' ) )
|
|
{
|
|
// the last character is not a separator, add one...
|
|
_tcscat(pDirPath, TEXT("\\"));
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
BOOL
|
|
UseServerCp(
|
|
LPTSTR lptstrServerName
|
|
)
|
|
{
|
|
HANDLE FaxHandle = NULL;
|
|
BOOL Rval = FALSE;
|
|
|
|
if (!FaxConnectFaxServer( lptstrServerName, &FaxHandle ))
|
|
{
|
|
Verbose(("Can't connect to the fax server %s",lptstrServerName));
|
|
goto exit;
|
|
}
|
|
|
|
if (!FaxGetPersonalCoverPagesOption( FaxHandle, &Rval))
|
|
{
|
|
Error(("FaxGetPersonalCoverPagesOption failed: %d\n", GetLastError()));
|
|
goto exit;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// the return value means server cover pages only
|
|
//
|
|
Rval = !Rval;
|
|
}
|
|
|
|
|
|
exit:
|
|
if (FaxHandle)
|
|
{
|
|
if (!FaxClose( FaxHandle ))
|
|
{
|
|
Verbose(("Can't close the fax handle %x",FaxHandle));
|
|
}
|
|
}
|
|
|
|
return Rval;
|
|
}
|
|
|
|
|
|
|
|
PCPDATA
|
|
AllocCoverPageInfo(
|
|
LPTSTR lptstrServerName,
|
|
LPTSTR lptstrPrinterName,
|
|
BOOL ServerCpOnly
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Allocate memory to hold cover page information
|
|
|
|
Arguments:
|
|
|
|
lptstrServerName - server name
|
|
ServerCpOnly - flag says if he function should use server CP only
|
|
|
|
Return Value:
|
|
|
|
Pointer to a CPDATA structure, NULL if there is an error
|
|
|
|
--*/
|
|
|
|
{
|
|
PCPDATA pCPInfo;
|
|
INT nDirs;
|
|
LPTSTR pDirPath, pUserCPDir, pSavedPtr;
|
|
|
|
|
|
if (pCPInfo = MemAllocZ(sizeof(CPDATA))) {
|
|
|
|
//
|
|
// Find the directory in which the server cover pages are stored
|
|
//
|
|
|
|
if (! GetServerCoverPageDirs(lptstrServerName, lptstrPrinterName, pCPInfo))
|
|
Error(("Couldn't get server cover page directories\n"));
|
|
|
|
//
|
|
// Find the directory in which the user cover pages are stored
|
|
//
|
|
|
|
if (ServerCpOnly == FALSE &&
|
|
(pUserCPDir = pSavedPtr = GetUserCoverPageDir()))
|
|
{
|
|
while (pUserCPDir && pCPInfo->nDirs < MAX_COVERPAGE_DIRS) {
|
|
|
|
LPTSTR pNextDir = pUserCPDir;
|
|
|
|
//
|
|
// Find the next semicolon character
|
|
//
|
|
|
|
pNextDir = _tcschr(pNextDir,TEXT(';'));
|
|
if (pNextDir != NUL )
|
|
{
|
|
_tcsnset(pNextDir,TEXT('\0'),1);
|
|
_tcsinc(pNextDir);
|
|
}
|
|
|
|
//
|
|
// Make sure the directory name is not too long
|
|
//
|
|
|
|
if (_tcslen(pUserCPDir) < MAX_PATH) {
|
|
|
|
if (! (pDirPath = MemAlloc(sizeof(TCHAR) * MAX_PATH)))
|
|
break;
|
|
|
|
pCPInfo->pDirPath[pCPInfo->nDirs++] = pDirPath;
|
|
_tcscpy(pDirPath, pUserCPDir);
|
|
}
|
|
|
|
pUserCPDir = pNextDir;
|
|
}
|
|
|
|
MemFree(pSavedPtr);
|
|
}
|
|
|
|
//
|
|
// Append path separators at the end if necessary
|
|
//
|
|
|
|
for (nDirs=0; nDirs < pCPInfo->nDirs; nDirs++) {
|
|
|
|
AppendPathSeparator(pCPInfo->pDirPath[nDirs]);
|
|
Verbose(("Cover page directory: %ws\n", pCPInfo->pDirPath[nDirs]));
|
|
}
|
|
}
|
|
|
|
return pCPInfo;
|
|
}
|
|
|
|
|
|
|
|
VOID
|
|
FreeCoverPageInfo(
|
|
PCPDATA pCPInfo
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Free up memory used for cover page information
|
|
|
|
Arguments:
|
|
|
|
pCPInfo - Points to cover page information to be freed
|
|
|
|
Return Value:
|
|
|
|
NONE
|
|
|
|
--*/
|
|
|
|
{
|
|
if (pCPInfo) {
|
|
|
|
INT index;
|
|
|
|
for (index=0; index < pCPInfo->nDirs; index++)
|
|
MemFree(pCPInfo->pDirPath[index]);
|
|
|
|
MemFree(pCPInfo);
|
|
}
|
|
}
|