able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/printscan/fax/admin/faxclient/cfg/clientcp.c

1276 lines
27 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1996 Microsoft Corporation
Module Name:
clientcp.c
Abstract:
Functions for handling events in the "Client Cover Page" tab of
the fax client configuration property sheet
Environment:
Fax configuration applet
Revision History:
03/13/96 -davidx-
Created it.
mm/dd/yy -author-
description
--*/
#include <windows.h>
#include <windowsx.h>
#include <winfax.h>
#include <shlobj.h>
#include <shellapi.h>
#include <tchar.h>
#include <commdlg.h>
#include "faxutil.h"
#include "faxreg.h"
#include "faxcfgrs.h"
#include "faxhelp.h"
#include "faxcfg.h"
PCPDATA pCPInfo;
BOOL
ClientCoverPageProc(
HWND hDlg,
UINT message,
WPARAM wParam,
LPARAM lParam
)
/*++
Routine Description:
Procedure for handling the "Client Cover Page" tab
Arguments:
hDlg - Identifies the property sheet page
message - Specifies the message
wParam - Specifies additional message-specific information
lParam - Specifies additional message-specific information
Return Value:
Depends on the value of message parameter
--*/
{
INT cmdId;
switch (message) {
case WM_INITDIALOG:
pCPInfo = AllocCoverPageInfo();
InitCoverPageList(pCPInfo, hDlg);
return TRUE;
case WM_COMMAND:
switch (cmdId = GET_WM_COMMAND_ID(wParam, lParam)) {
case IDC_COVERPG_ADD:
case IDC_COVERPG_NEW:
case IDC_COVERPG_OPEN:
case IDC_COVERPG_REMOVE:
//
// User clicked one of the buttons for managing cover page files
//
cmdId = (cmdId == IDC_COVERPG_REMOVE) ? CPACTION_REMOVE :
(cmdId == IDC_COVERPG_OPEN) ? CPACTION_OPEN :
(cmdId == IDC_COVERPG_NEW) ? CPACTION_NEW : CPACTION_BROWSE;
ManageCoverPageList(hDlg,
pCPInfo,
GetDlgItem(hDlg, IDC_COVERPG_LIST),
cmdId);
break;
case IDC_COVERPG_LIST:
switch (GET_WM_COMMAND_CMD(wParam, lParam)) {
case LBN_SELCHANGE:
UpdateCoverPageControls(hDlg);
break;
case LBN_DBLCLK:
//
// Double-clicking in the cover page list is equivalent
// to pressing the "Open" button
//
ManageCoverPageList(hDlg,
pCPInfo,
GetDlgItem(hDlg, cmdId),
CPACTION_OPEN);
break;
}
break;
default:
return FALSE;
}
return TRUE;
case WM_NOTIFY:
switch (((NMHDR *) lParam)->code) {
case PSN_SETACTIVE:
break;
case PSN_APPLY:
return PSNRET_NOERROR;
}
break;
case WM_HELP:
case WM_CONTEXTMENU:
return HandleHelpPopup(hDlg, message, wParam, lParam, CLIENT_COVERPG_PAGE);
}
return FALSE;
}
//
// Find the filename portion given a filename:
// return a pointer to the '.' character if successful
// NULL if there is no extension
//
#define FindFilenameExtension(pFilename) _tcsrchr(pFilename, TEXT(FILENAME_EXT))
VOID
HandleOpenCoverPage(
HWND hDlg,
PCPDATA pCPInfo,
HWND hwndList,
LPTSTR pSelected,
INT action
)
/*++
Routine Description:
Edit the currently selected cover page file or
create a new cover page file
Arguments:
hDlg - Handle to the dialog window on which the list of cover pages is displayed
pCPInfo - Points to cover page information
hwndList - Handle to cover page listbox window
pSelected - Currently selected cover page filename
action - Open an existing cover page file or create a new one
Return Value:
NONE
--*/
{
MSG msg; // used for peeking messages
DWORD WaitObj;
TCHAR filename[MAX_PATH];
LPTSTR pExecutableName, pDirPath, pFilename;
SHELLEXECUTEINFO shellExeInfo = {
sizeof(SHELLEXECUTEINFO),
SEE_MASK_NOCLOSEPROCESS,
hDlg,
NULL,
NULL,
NULL,
NULL,
SW_SHOWNORMAL,
};
//
// Determine the default directory to run the cover page editor in:
//
if (action == CPACTION_NEW) {
//
// When creating a new cover page, the default directory is either
// the server cover page directory or the user cover page directory
// depending on whether the user is doing server adminstration.
//
pDirPath = pCPInfo->pDirPath[0];
pFilename = NULL;
SetEnvironmentVariable(TEXT("ClientCoverpage"),TEXT("1"));
} else {
INT flags;
//
// If the currently selected file is a link, resolve it first
//
lstrcpy(filename, pSelected);
if (!IsEmptyString(pSelected) &&
(flags = GetSelectedCoverPage(pCPInfo, hwndList, NULL)) > 0 &&
(flags & CPFLAG_LINK) &&
!ResolveShortcut(pSelected, filename))
{
DisplayMessageDialog(hDlg, 0, 0, IDS_RESOLVE_LINK_FAILED, pSelected);
return;
}
//
// Separate the filename into directory and filename components
//
if (pFilename = _tcsrchr(filename, TEXT(PATH_SEPARATOR))) {
*pFilename++ = NUL;
pDirPath = filename;
} else {
pFilename = filename;
pDirPath = NULL;
}
}
//
// Find the "Cover Page Editor" executable
//
if ((pExecutableName = GetCoverPageEditor()) == NULL) {
DisplayMessageDialog(hDlg, 0, 0, IDS_CANNOT_FIND_CPEDITOR);
return;
}
//
// Start cover page editor and wait for it to exit before proceeding
//
shellExeInfo.lpFile = pExecutableName;
shellExeInfo.lpDirectory = pDirPath;
shellExeInfo.lpParameters = MakeQuotedParameterString(pFilename);
DebugPrint((TEXT("Cover page editor: %ws\n"), pExecutableName));
DebugPrint((TEXT("Initial working directory: %ws\n"), pDirPath));
DebugPrint((TEXT("Cover page filename: %ws\n"), shellExeInfo.lpParameters));
// Disable the parent window.
EnableWindow( GetParent(hDlg), FALSE );
if (! ShellExecuteEx(&shellExeInfo)) {
DisplayMessageDialog(hDlg, 0, 0, IDS_CANNOT_OPEN_CPEDITOR, pExecutableName);
MemFree((PVOID)shellExeInfo.lpParameters);
MemFree((PVOID)pExecutableName);
return;
}
//
// Refresh the list of cover page files when we're done
//
MemFree((PVOID)shellExeInfo.lpParameters);
MemFree((PVOID)pExecutableName);
while (TRUE) {
// Wait for multiple objects in case of other messages coming.
WaitObj = MsgWaitForMultipleObjects( 1, &shellExeInfo.hProcess, FALSE, INFINITE, QS_ALLINPUT );
if (WaitObj == WAIT_OBJECT_0)
break;
// PeekMessage instead of GetMessage so we drain the message queue
while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE )) {
TranslateMessage( &msg );
DispatchMessage( &msg );
}
}
EnableWindow( GetParent(hDlg), TRUE );
InitCoverPageList(pCPInfo, hDlg);
SetEnvironmentVariable(TEXT("ClientCoverpage"),NULL);
}
VOID
HandleBrowseCoverPage(
HWND hDlg,
PCPDATA pCPInfo,
HWND hwndList,
LPTSTR pSelected
)
/*++
Routine Description:
Remove the currently selected cover page file
Arguments:
hDlg - Handle to the dialog window on which the list of cover pages is displayed
pCPInfo - Points to cover page information
hwndList - Handle to cover page listbox window
pSelected - Currently selected cover page filename
Return Value:
NONE
--*/
{
TCHAR filename[MAX_PATH];
TCHAR title[MAX_TITLE_LEN];
TCHAR filter[MAX_TITLE_LEN];
LPTSTR pExtension, pFilename;
LPTSTR pCPDir;
INT n;
OPENFILENAME ofn = {
sizeof(OPENFILENAME),
hDlg,
ghInstance,
filter,
NULL,
0,
1,
filename,
MAX_PATH,
NULL,
0,
NULL,
title,
OFN_FILEMUSTEXIST | OFN_NODEREFERENCELINKS | OFN_HIDEREADONLY,
0,
0,
NULL,
0,
NULL,
NULL,
};
//
// Figure out what the initial directory should be
//
if (! IsEmptyString(pSelected)) {
INT flags;
//
// Find out if the currently selected cover page file is a
// user cover page and whether it's a link
//
if ((flags = GetSelectedCoverPage(pCPInfo, hwndList, NULL)) > 0 &&
(flags & CPFLAG_LINK) &&
ResolveShortcut(pSelected, filename))
{
//
// Set the initial directory to the link destination
//
_tcscpy(pSelected, filename);
if (pFilename = _tcsrchr(pSelected, TEXT(PATH_SEPARATOR))) {
*pFilename = NUL;
ofn.lpstrInitialDir = pSelected;
}
}
}
//
// Compose the file-type filter string
//
LoadString(ghInstance, IDS_CP_FILETYPE, title, MAX_TITLE_LEN);
wsprintf(filter, TEXT("%s%c*%s%c"), title, NUL, CP_FILENAME_EXT, NUL);
LoadString(ghInstance, IDS_BROWSE_COVERPAGE, title, MAX_TITLE_LEN);
filename[0] = NUL;
//
// Present the "Open File" dialog
//
if (! GetOpenFileName(&ofn))
return;
//
// Make sure the selected filename has the correct extension
//
if ((pExtension = FindFilenameExtension(filename)) == NULL ||
_tcsicmp(pExtension, CP_FILENAME_EXT) != EQUAL_STRING)
{
DisplayMessageDialog(hDlg, 0, 0, IDS_BAD_CP_EXTENSION, CP_FILENAME_EXT);
return;
}
//
// Check if the selected file is already inside one of the
// cover page directories
//
for (n=0; n < pCPInfo->nDirs; n++) {
TCHAR Path[MAX_PATH];
if (_tcslen(pCPInfo->pDirPath[n]) + _tcslen(&filename[ofn.nFileOffset]) >= MAX_PATH) {
DisplayMessageDialog(hDlg, 0, 0, IDS_FILENAME_TOOLONG);
return;
}
_tcscpy(Path, pCPInfo->pDirPath[n]);
_tcscat(Path, &filename[ofn.nFileOffset]);
if (GetFileAttributes(Path) != 0xffffffff) {
DisplayMessageDialog(hDlg, 0, 0, IDS_CP_DUPLICATE, filename);
return;
}
}
//
// Add the selected cover page file to the first cover page directory
// Create the cover page directory if necessary
//
pCPDir = pCPInfo->pDirPath[0];
if (!pCPDir || IsEmptyString(pCPDir)) {
DisplayMessageDialog(hDlg, 0, 0, IDS_NO_COVERPG_DIR);
return;
}
CreateDirectory(pCPDir, NULL);
pFilename = &filename[ofn.nFileOffset];
_tcscpy(pSelected, pCPDir);
n = _tcslen(pSelected);
if (n + _tcslen(pFilename) >= MAX_PATH - MAX_FILENAME_EXT || pFilename >= pExtension) {
DisplayMessageDialog(hDlg, 0, 0, IDS_FILENAME_TOOLONG);
return;
}
_tcsncpy(pSelected + n, pFilename, (INT)(pExtension - pFilename));
n += (INT)(pExtension - pFilename);
if (pCPInfo->serverCP) {
//
// Copy the physical file for server cover pages
//
_tcscpy(pSelected + n, CP_FILENAME_EXT);
if (! CopyFile(filename, pSelected, TRUE)) {
DisplayMessageDialog(hDlg, 0, 0, IDS_COPY_FILE_FAILED, filename, pSelected);
return;
}
} else {
//
// Create the shortcut file for user cover page
//
_tcscpy(pSelected + n, LNK_FILENAME_EXT);
if (GetFileAttributes(pSelected) != 0xffffffff) {
DisplayMessageDialog(hDlg, 0, 0, IDS_CP_DUPLICATE, filename);
return;
}
if (! CreateShortcut(pSelected, filename)) {
DisplayMessageDialog(hDlg, 0, 0, IDS_CREATE_LINK_FAILED, pSelected, filename);
return;
}
}
//
// Refresh the cover page list - we're being lazy here in that
// we reset the entire list content
//
InitCoverPageList(pCPInfo, hDlg);
}
VOID
HandleRemoveCoverPage(
HWND hDlg,
PCPDATA pCPInfo,
HWND hwndList,
LPTSTR pFilename
)
/*++
Routine Description:
Remove the currently selected cover page file
Arguments:
hDlg - Handle to the dialog window on which the list of cover pages is displayed
pCPInfo - Points to cover page information
hwndList - Handle to cover page listbox window
pFilename - Currently selected cover page filename
Return Value:
NONE
--*/
{
//
// Display the confirmation dialog before proceeding
//
if (DisplayMessageDialog(hDlg,
MB_YESNO | MB_ICONWARNING | MB_DEFBUTTON2,
IDS_CONFIRM_DELETE,
IDS_DELETE_PROMPT,
pFilename) == IDYES)
{
if (DeleteFile(pFilename)) {
//
// Update the list box if the file is successfully removed
//
INT selIndex, count;
if ((selIndex = (INT)SendMessage(hwndList, LB_GETCURSEL, 0, 0)) != LB_ERR) {
SendMessage(hwndList, LB_DELETESTRING, selIndex, 0);
if ((count = (INT)SendMessage(hwndList, LB_GETCOUNT, 0, 0)) > 0) {
count --;
SendMessage(hwndList, LB_SETCURSEL, min(selIndex, count), 0);
}
}
UpdateCoverPageControls(hDlg);
} else
DisplayMessageDialog(hDlg, 0, 0, IDS_DELETE_FAILED, pFilename);
}
}
VOID
ManageCoverPageList(
HWND hDlg,
PCPDATA pCPInfo,
HWND hwndList,
INT action
)
/*++
Routine Description:
Perform various action to manage the list of cover pages
Arguments:
hDlg - Handle to the dialog window on which the list of cover pages is displayed
pCPInfo - Points to cover page information
hwndList - Handle to cover page listbox window
action - What action to perform on the cover page list
Return Value:
NONE
--*/
{
TCHAR filename[MAX_PATH];
//
// Get the name of currently selected cover page file
//
if (pCPInfo == NULL || hwndList == NULL)
return;
GetSelectedCoverPage(pCPInfo, hwndList, filename);
//
// Call appropriate function depends on the action parameter
//
switch (action) {
case CPACTION_OPEN:
if (IsEmptyString(filename))
break;
case CPACTION_NEW:
HandleOpenCoverPage(hDlg, pCPInfo, hwndList, filename, action);
break;
case CPACTION_BROWSE:
HandleBrowseCoverPage(hDlg, pCPInfo, hwndList, filename);
break;
case CPACTION_REMOVE:
if (! IsEmptyString(filename))
HandleRemoveCoverPage(hDlg, pCPInfo, hwndList, filename);
break;
}
}
VOID
UpdateCoverPageControls(
HWND hDlg
)
/*++
Routine Description:
Enable/disable buttons for manage cover page files
Arguments:
hDlg - Handle to the property page containing the cover page controls
Return Value:
NONE
--*/
{
HWND hwndOpen, hwndRemove;
//
// If all buttons are disabled, leave them alone here
//
if (! IsWindowEnabled(GetDlgItem(hDlg, IDC_COVERPG_NEW)))
return;
hwndOpen = GetDlgItem(hDlg, IDC_COVERPG_OPEN);
hwndRemove = GetDlgItem(hDlg, IDC_COVERPG_REMOVE);
if (SendDlgItemMessage(hDlg, IDC_COVERPG_LIST, LB_GETCURSEL, 0, 0) != LB_ERR) {
EnableWindow(hwndOpen, TRUE);
EnableWindow(hwndRemove, TRUE);
} else {
if (GetFocus() == hwndOpen || GetFocus() == hwndRemove)
SetFocus(GetDlgItem(hDlg, IDC_COVERPG_NEW));
EnableWindow(hwndOpen, FALSE);
EnableWindow(hwndRemove, FALSE);
}
}
VOID
AddCoverPagesToList(
PCPDATA pCPInfo,
HWND hwndList,
INT dirIndex
)
/*++
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
dirIndex - Cover page directory index
Return Value:
NONE
--*/
{
WIN32_FIND_DATA findData;
TCHAR filename[MAX_PATH];
HANDLE hFindFile;
LPTSTR pDirPath, pFilename, pExtension;
INT listIndex, dirLen, fileLen, flags;
//
// Copy the directory path to a local buffer
//
flags = dirIndex;
pDirPath = pCPInfo->pDirPath[dirIndex];
if (IsEmptyString(pDirPath))
return;
if ((dirLen = _tcslen(pDirPath)) >= MAX_PATH - MAX_FILENAME_EXT - 1) {
DebugPrint(( TEXT("Directory name too long: %ws\n"), pDirPath));
return;
}
_tcscpy(filename, pDirPath);
//
// Go through the following loop twice:
// Once to add the files with .ncp extension
// Again to add the files with .lnk extension
//
// Don't chase links for server based cover pages
//
do {
//
// Generate a specification for the files we're interested in
//
pFilename = &filename[dirLen];
*pFilename = TEXT('*');
_tcscpy(pFilename+1, (flags & CPFLAG_LINK) ? LNK_FILENAME_EXT : CP_FILENAME_EXT);
//
// Call FindFirstFile/FindNextFile to enumerate the files
// matching our specification
//
hFindFile = FindFirstFile(filename, &findData);
if (hFindFile != INVALID_HANDLE_VALUE) {
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) {
DebugPrint(( TEXT("Filename too long: %ws%ws\n"), pDirPath, findData.cFileName));
continue;
}
//
// If we're chasing links, make sure the link refers to
// a cover page file.
//
if (flags & CPFLAG_LINK) {
_tcscpy(pFilename, findData.cFileName);
if (! IsCoverPageShortcut(filename))
continue;
}
//
// Don't display the filename extension
//
if (pExtension = FindFilenameExtension(findData.cFileName))
*pExtension = NUL;
//
// Add the cover page name to the list window
//
listIndex = (INT)SendMessage(hwndList,
LB_ADDSTRING,
0,
(LPARAM) findData.cFileName);
if (listIndex != LB_ERR)
SendMessage(hwndList, LB_SETITEMDATA, listIndex, flags);
} while (FindNextFile(hFindFile, &findData));
FindClose(hFindFile);
}
flags ^= CPFLAG_LINK;
} while ((flags & CPFLAG_LINK) && ! pCPInfo->serverCP);
}
VOID
InitCoverPageList(
PCPDATA pCPInfo,
HWND hDlg
)
/*++
Routine Description:
Generate a list of available cover pages
Arguments:
pCPInfo - Points to cover page information
hDlg - Handle to the dialog window containing cover page list
Return Value:
NONE
--*/
{
HWND hwndList;
INT index, lastSel;
if ((hwndList = GetDlgItem(hDlg, IDC_COVERPG_LIST)) && pCPInfo) {
//
// Disable redraw on the list and reset its content
//
if ((lastSel = (INT)SendMessage(hwndList, LB_GETCURSEL, 0, 0)) == LB_ERR)
lastSel = 0;
SendMessage(hwndList, WM_SETREDRAW, FALSE, 0);
SendMessage(hwndList, LB_RESETCONTENT, 0, 0);
//
// Add cover pages to the list
//
for (index=0; index < pCPInfo->nDirs; index++)
AddCoverPagesToList(pCPInfo, hwndList, index);
//
// Highlight the first cover page in the list
//
if ((index = (INT)SendMessage(hwndList, LB_GETCOUNT, 0, 0)) > 0 && lastSel >= index)
lastSel = index - 1;
SendMessage(hwndList, LB_SETCURSEL, lastSel, 0);
//
// Enable redraw on the list window
//
SendMessage(hwndList, WM_SETREDRAW, TRUE, 0);
} else if (hwndList) {
SendMessage(hwndList, LB_RESETCONTENT, 0, 0);
}
UpdateCoverPageControls(hDlg);
}
INT
GetSelectedCoverPage(
PCPDATA pCPInfo,
HWND hwndList,
LPTSTR pBuffer
)
/*++
Routine Description:
Retrieve the currently selected cover page filename
Arguments:
pCPInfo - Points to cover page information
hwndList - Handle to the list window
pBuffer - Points to a buffer for storing the selected cover page filename
The size of the buffer is assumed to be MAX_PATH characters.
if pBuffer is NULL, we assume the called is interested in the item flags
Return Value:
Flags associated with the currently selected item
Negative if there is an error
--*/
{
LPTSTR pDirPath;
INT selIndex, itemFlags;
//
// Default to empty string in case of an error
//
if (pBuffer)
pBuffer[0] = NUL;
if (pCPInfo == NULL || hwndList == NULL)
return LB_ERR;
//
// Get currently selected item index
//
if ((selIndex = (INT)SendMessage(hwndList, LB_GETCURSEL, 0, 0)) == LB_ERR)
return selIndex;
//
// Get the flags associated with the currently selected item
//
itemFlags = (INT)SendMessage(hwndList, LB_GETITEMDATA, selIndex, 0);
if (itemFlags == LB_ERR || !pBuffer)
return itemFlags;
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
//
while (*pBuffer++ = *pDirPath++)
NULL;
pBuffer--;
SendMessage(hwndList, LB_GETTEXT, selIndex, (LPARAM) pBuffer);
_tcscat(pBuffer, (itemFlags & CPFLAG_LINK) ? LNK_FILENAME_EXT : CP_FILENAME_EXT);
return itemFlags;
}
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;
//
// 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
//
if (pDirPath[length-1] != TEXT(PATH_SEPARATOR)) {
pDirPath[length] = TEXT(PATH_SEPARATOR);
pDirPath[length+1] = NUL;
}
}
PCPDATA
AllocCoverPageInfo(
)
/*++
Routine Description:
Allocate memory to hold cover page information
Arguments:
hPrinter - Handle to a printer object if serverCP is TRUE
Return Value:
Pointer to a CPDATA structure, NULL if there is an error
NOTE:
Put this inside a critical section is the caller is concerned about
being thread safe.
--*/
{
PCPDATA pCPInfo;
INT nDirs;
LPTSTR pDirPath, pUserCPDir, pSavedPtr;
if (pCPInfo = MemAlloc(sizeof(CPDATA))) {
ZeroMemory(pCPInfo,sizeof(CPDATA));
if ( (pUserCPDir = MemAlloc(MAX_PATH)) && (pSavedPtr = pUserCPDir) && (GetClientCpDir(pUserCPDir,MAX_PATH)) ) {
//
// Find the directory in which the user cover pages are stored
//
while (*pUserCPDir && pCPInfo->nDirs < MAX_COVERPAGE_DIRS) {
LPTSTR pNextDir = pUserCPDir;
//
// Find the next semicolon character
//
while (*pNextDir && *pNextDir != TEXT(';'))
pNextDir++;
if (*pNextDir != NUL)
*pNextDir++ = NUL;
//
// Make sure the directory name is not too long
//
if (_tcslen(pUserCPDir) < MAX_PATH) {
if (! (pDirPath = AllocStringZ(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]);
DebugPrint(( TEXT("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);
}
}
LPTSTR
MakeQuotedParameterString(
LPTSTR pInputStr
)
/*++
Routine Description:
Make a copy of the input string and make sure it's in the same form
as expected by SHELLEXECUTEINFO.lpParameters.
Arguments:
pInputStr - Specifies the input string
Return Value:
Pointer to the processed parameter string
--*/
#define QUOTE TEXT('"')
{
LPTSTR pStr, pDestStr;
INT length;
//
// Special case: if the input string is NULL, simply return NULL
//
if (pInputStr == NULL)
return NULL;
//
// Figure out how long the resulting string is.
// Initial value is 3 = two extra quotes plus NUL terminator.
//
for (pStr=pInputStr, length=3; *pStr; pStr++)
length += (*pStr == QUOTE) ? 3 : 1;
//
// Copy the input string and replace quote characters
//
if (pStr = pDestStr = MemAlloc(length * sizeof(TCHAR))) {
*pStr++ = QUOTE;
while (*pInputStr) {
if ((*pStr++ = *pInputStr++) == QUOTE) {
*pStr++ = QUOTE;
*pStr++ = QUOTE;
}
}
*pStr++ = QUOTE;
*pStr = NUL;
}
return pDestStr;
}
LPTSTR GetCoverPageEditor()
{
LPTSTR Location;
HKEY hKey = OpenRegistryKey(HKEY_CURRENT_USER,REGKEY_FAX_SETUP,TRUE,0);
if (hKey == NULL) {
return NULL;
}
Location = GetRegistryStringExpand(hKey,REGVAL_CP_EDITOR,DEFAULT_COVERPAGE_EDITOR);
RegCloseKey(hKey);
return Location;
}
Reference in a new issue Copy permalink