/*++

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);
    }
}