page01create.cpp

This ZIP archive includes the sources (and executable) for the FileTest utility, written by Ladisla

/*****************************************************************************/
/* Page01Create.cpp                       Copyright (c) Ladislav Zezula 2004 */
/*---------------------------------------------------------------------------*/
/* Description:                                                              */
/*---------------------------------------------------------------------------*/
/*   Date    Ver   Who  Comment                                              */
/* --------  ----  ---  -------                                              */
/* 06.03.04  1.00  Lad  The first version of Page01Create.cpp                */
/*****************************************************************************/

#include "FileTest.h"
#include "resource.h"

//-----------------------------------------------------------------------------
// Flags

static TFlagInfo DesiredAccessValues[] =
{
    {FILE_READ_DATA,         _T("FILE_READ_DATA/FILE_LIST_DIRECTORY"),     TRUE},
    {FILE_WRITE_DATA,        _T("FILE_WRITE_DATA/FILE_ADD_FILE"),          TRUE},
    {FILE_APPEND_DATA,       _T("FILE_APPEND_DATA/FILE_ADD_SUBDIRECTORY"), TRUE},
    {FILE_READ_EA,           _T("FILE_READ_EA"),                           TRUE},
    {FILE_WRITE_EA,          _T("FILE_WRITE_EA"),                          TRUE},
    {FILE_EXECUTE,           _T("FILE_EXECUTE/FILE_TRAVERSE"),             TRUE},
    {FILE_DELETE_CHILD,      _T("FILE_DELETE_CHILD"),                      TRUE},
    {FILE_READ_ATTRIBUTES,   _T("FILE_READ_ATTRIBUTES"),                   TRUE},
    {FILE_WRITE_ATTRIBUTES,  _T("FILE_WRITE_ATTRIBUTES"),                  TRUE},
    {DELETE,                 _T("DELETE"),                                 TRUE},
    {READ_CONTROL,           _T("READ_CONTROL"),                           TRUE},
    {WRITE_DAC,              _T("WRITE_DAC"),                              TRUE},
    {WRITE_OWNER,            _T("WRITE_OWNER"),                            TRUE},
    {SYNCHRONIZE,            _T("SYNCHRONIZE"),                            TRUE},
    {GENERIC_READ,           _T("GENERIC_READ"),                           TRUE},
    {GENERIC_WRITE,          _T("GENERIC_WRITE"),                          TRUE},
    {GENERIC_EXECUTE,        _T("GENERIC_EXECUTE"),                        TRUE},
    {GENERIC_ALL,            _T("GENERIC_ALL"),                            TRUE},
    {0, 0, 0}
};

static TFlagInfo FileAttributesValues[] =
{
    {FILE_ATTRIBUTE_READONLY,            _T("FILE_ATTRIBUTE_READONLY"),            TRUE},
    {FILE_ATTRIBUTE_HIDDEN,              _T("FILE_ATTRIBUTE_HIDDEN"),              TRUE},
    {FILE_ATTRIBUTE_SYSTEM,              _T("FILE_ATTRIBUTE_SYSTEM"),              TRUE},
    {OLD_DOS_VOLID,                      _T("OLD_DOS_VOLID"),                      FALSE},
    {FILE_ATTRIBUTE_DIRECTORY,           _T("FILE_ATTRIBUTE_DIRECTORY"),           TRUE},
    {FILE_ATTRIBUTE_ARCHIVE,             _T("FILE_ATTRIBUTE_ARCHIVE"),             TRUE},
    {FILE_ATTRIBUTE_DEVICE,              _T("FILE_ATTRIBUTE_DEVICE"),              TRUE},
    {FILE_ATTRIBUTE_NORMAL,              _T("FILE_ATTRIBUTE_NORMAL"),              TRUE},
    {FILE_ATTRIBUTE_TEMPORARY,           _T("FILE_ATTRIBUTE_TEMPORARY"),           TRUE},
    {FILE_ATTRIBUTE_SPARSE_FILE,         _T("FILE_ATTRIBUTE_SPARSE_FILE"),         TRUE},
    {FILE_ATTRIBUTE_REPARSE_POINT,       _T("FILE_ATTRIBUTE_REPARSE_POINT"),       TRUE},
    {FILE_ATTRIBUTE_COMPRESSED,          _T("FILE_ATTRIBUTE_COMPRESSED"),          TRUE},
    {FILE_ATTRIBUTE_OFFLINE,             _T("FILE_ATTRIBUTE_OFFLINE"),             TRUE},
    {FILE_ATTRIBUTE_NOT_CONTENT_INDEXED, _T("FILE_ATTRIBUTE_NOT_CONTENT_INDEXED"), TRUE},
    {FILE_ATTRIBUTE_ENCRYPTED,           _T("FILE_ATTRIBUTE_ENCRYPTED"),           TRUE},

    {FILE_FLAG_WRITE_THROUGH,            _T("FILE_FLAG_WRITE_THROUGH"),            TRUE},
    {FILE_FLAG_OVERLAPPED,               _T("FILE_FLAG_OVERLAPPED"),               TRUE},
    {FILE_FLAG_NO_BUFFERING,             _T("FILE_FLAG_NO_BUFFERING"),             TRUE},
    {FILE_FLAG_RANDOM_ACCESS,            _T("FILE_FLAG_RANDOM_ACCESS"),            TRUE},
    {FILE_FLAG_SEQUENTIAL_SCAN,          _T("FILE_FLAG_SEQUENTIAL_SCAN"),          TRUE},
    {FILE_FLAG_DELETE_ON_CLOSE,          _T("FILE_FLAG_DELETE_ON_CLOSE"),          TRUE},
    {FILE_FLAG_BACKUP_SEMANTICS,         _T("FILE_FLAG_BACKUP_SEMANTICS"),         TRUE},
    {FILE_FLAG_POSIX_SEMANTICS,          _T("FILE_FLAG_POSIX_SEMANTICS"),          TRUE},
    {FILE_FLAG_OPEN_REPARSE_POINT,       _T("FILE_FLAG_OPEN_REPARSE_POINT"),       TRUE},
    {FILE_FLAG_OPEN_NO_RECALL,           _T("FILE_FLAG_OPEN_NO_RECALL"),           TRUE},
    {FILE_FLAG_FIRST_PIPE_INSTANCE,      _T("FILE_FLAG_FIRST_PIPE_INSTANCE"),      TRUE},
    {0, 0, 0}
};

static TFlagInfo ShareAccessValues[] =
{
    {FILE_SHARE_READ,   _T("FILE_SHARE_READ"),   TRUE},
    {FILE_SHARE_WRITE,  _T("FILE_SHARE_WRITE"),  TRUE},
    {FILE_SHARE_DELETE, _T("FILE_SHARE_DELETE"), TRUE},
    {0, 0, 0}
};

//-----------------------------------------------------------------------------
// Helper functions

static int SetOperationResult(HWND hDlg, int nError)
{
    TPropSheetData * pData = (TPropSheetData *)GetWindowLongPtr(hDlg, DWLP_USER);
    BOOL bEnable = TRUE;

    // Set the last error and the handle
    SetLastErrorText(hDlg, IDC_LAST_ERROR, nError);

    if(IsHandleInvalid(pData->hFile))
    {
        SetDlgItemText(hDlg, IDC_FILE_HANDLE, _T("INVALID_HANDLE_VALUE"));
        bEnable = FALSE;
    }
    else
        Hex2DlgTextPtr(hDlg, IDC_FILE_HANDLE, (DWORD_PTR)pData->hFile);

    EnableWindow(GetDlgItem(hDlg, IDC_CLOSEHINT), bEnable);
    EnableWindow(GetDlgItem(hDlg, IDC_CLOSEHANDLE), bEnable);
    return nError;
}

static int SaveDialog(HWND hDlg)
{
    TPropSheetData * pData = (TPropSheetData *)GetWindowLongPtr(hDlg, DWLP_USER);
    HWND hCombo = GetDlgItem(hDlg, IDC_CREATE_DISPOSITION);

    GetDlgItemText(hDlg, IDC_DIRECTORY_NAME, pData->szDirName, _tsize(pData->szDirName));
    GetDlgItemText(hDlg, IDC_FILE_NAME, pData->szFileName1, _tsize(pData->szFileName1));
    pData->dwDesiredAccess     = DlgText2Hex32(hDlg, IDC_DESIRED_ACCESS);
    pData->dwFileAttributes    = DlgText2Hex32(hDlg, IDC_FILE_ATTRIBUTES);
    pData->dwShareAccess       = DlgText2Hex32(hDlg, IDC_SHARE_ACCESS);
    pData->dwCreateDisposition = ComboBox_GetCurSel(hCombo) + 1;
    pData->bUseTransaction = (IsDlgButtonChecked(hDlg, IDC_TRANSACTED) == BST_CHECKED);
    return ERROR_SUCCESS;
}

//-----------------------------------------------------------------------------
// Message handlers

static int OnInitDialog(HWND hDlg, LPARAM lParam)
{
    PROPSHEETPAGE * pPage = (PROPSHEETPAGE *)lParam;
    HWND hCancelButton = GetDlgItem(GetParent(hDlg), IDCANCEL);
    HWND hOKButton = GetDlgItem(GetParent(hDlg), IDOK);
    HWND hCombo = GetDlgItem(hDlg, IDC_CREATE_DISPOSITION);

    SetWindowLongPtr(hDlg, DWLP_USER, (LONG)pPage->lParam);
    CenterWindow(GetParent(hDlg));

    // Initialize dialog
    InitDialogControls(hDlg, MAKEINTRESOURCE(IDD_PAGE01_CREATE));

    // Initialize the combo box with operations
    if(hCombo != NULL)
        ComboBox_SetCurSel(hCombo, OPEN_ALWAYS - 1);

    // Initialize the buttons
    // Hide "OK" button and change "Cancel" to "Exit"
    if(hCancelButton != NULL && hOKButton != NULL)
    {
        TCHAR szButton[256] = _T("");

        LoadString(g_hInst, IDS_EXIT, szButton, _tsize(szButton));
        DestroyWindow(hOKButton);
        SetWindowText(hCancelButton, szButton);
    }

    return TRUE;
}

static int OnSetActive(HWND hDlg)
{
    TPropSheetData * pData = (TPropSheetData *)GetWindowLongPtr(hDlg, DWLP_USER);
    TCHAR * szName;
    BOOL bEnabled = FALSE;
    int nChecked;

    // Set directory name
    szName = pData->szDirName;
    if(!_tcsncmp(szName, _T("\\??\\"), 4))
        szName += 4;
    SetDlgItemText(hDlg, IDC_DIRECTORY_NAME, szName);
    
    // Set file name
    if((pData->dwCreateOptions & FILE_OPEN_BY_FILE_ID) == 0)
    {
        szName = pData->szFileName1;
        if(!_tcsncmp(szName, _T("\\??\\"), 4))
            szName += 4;
        SetDlgItemText(hDlg, IDC_FILE_NAME, szName);
    }

    // Set the various create options
    Hex2DlgText32(hDlg, IDC_DESIRED_ACCESS, pData->dwDesiredAccess);
    Hex2DlgText32(hDlg, IDC_FILE_ATTRIBUTES, pData->dwFileAttributes);
    Hex2DlgText32(hDlg, IDC_SHARE_ACCESS, pData->dwShareAccess);

    // Enable/disable transaction
    bEnabled = (pfnCreateFileTransacted != NULL && IsHandleValid(pData->hTransaction));
    EnableDlgItems(hDlg, bEnabled, IDC_TRANSACTED, 0);
    nChecked = (bEnabled && pData->bUseTransaction) ? BST_CHECKED : BST_UNCHECKED;
    CheckDlgButton(hDlg, IDC_TRANSACTED, nChecked);

    SetOperationResult(hDlg, 0);
    return TRUE;
}

static int OnKillActive(HWND hDlg)
{
    SaveDialog(hDlg);
    return TRUE;
}

static int OnBrowseDirClick(HWND hDlg)
{
    return BrowseForDirectory(hDlg, IDC_DIRECTORY_NAME, IDS_SELECT_DIRECTORY);
}

static int OnBrowseFileClick(HWND hDlg)
{
    return BrowseForFile(hDlg, 0, MAKEINTRESOURCE(IDC_FILE_NAME), IDS_SELECT_FILE, IDS_FILTER_ALL);
}

static int OnDesiredAccessClick(HWND hDlg)
{
    TFlagDialogData DesiredAccessData;

    DesiredAccessData.hParent  = hDlg;
    DesiredAccessData.nIDTitle = IDS_DESIRED_ACCESS;
    DesiredAccessData.dwFlags  = DlgText2Hex32(hDlg, IDC_DESIRED_ACCESS);
    DesiredAccessData.nFlags   = sizeof(DesiredAccessValues) / sizeof(TFlagInfo);
    DesiredAccessData.Flags    = DesiredAccessValues;

    FlagsDialog(&DesiredAccessData);
    Hex2DlgText32(hDlg, IDC_DESIRED_ACCESS, DesiredAccessData.dwFlags);
    return TRUE;
}

static int OnFileAttributesClick(HWND hDlg)
{
    TFlagDialogData FileAttributesData;

    FileAttributesData.hParent  = hDlg;
    FileAttributesData.nIDTitle = IDS_FILE_ATTRIBUTES;
    FileAttributesData.dwFlags  = DlgText2Hex32(hDlg, IDC_FILE_ATTRIBUTES);
    FileAttributesData.nFlags   = sizeof(FileAttributesValues) / sizeof(TFlagInfo);
    FileAttributesData.Flags    = FileAttributesValues;

    FlagsDialog(&FileAttributesData);
    Hex2DlgText32(hDlg, IDC_FILE_ATTRIBUTES, FileAttributesData.dwFlags);
    return TRUE;
}

static int OnShareAccessClick(HWND hDlg)
{
    TFlagDialogData ShareAccessData;

    ShareAccessData.hParent  = hDlg;
    ShareAccessData.nIDTitle = IDS_SHARE_ACCESS;
    ShareAccessData.dwFlags  = DlgText2Hex32(hDlg, IDC_SHARE_ACCESS);
    ShareAccessData.nFlags   = sizeof(ShareAccessValues) / sizeof(TFlagInfo);
    ShareAccessData.Flags    = ShareAccessValues;

    FlagsDialog(&ShareAccessData);
    Hex2DlgText32(hDlg, IDC_SHARE_ACCESS, ShareAccessData.dwFlags);
    return TRUE;
}

static int OnOpenFileClick(HWND hDlg)
{
    TPropSheetData * pData = (TPropSheetData *)GetWindowLongPtr(hDlg, DWLP_USER);
    int nError = ERROR_SUCCESS;

    if(IsHandleValid(pData->hFile))
    {
        MessageBoxRc(hDlg, IDS_WARNING, IDS_FILE_ALREADY_OPEN);
        return TRUE;
    }

    // Get the values from dialog controls to the dialog data
    SaveDialog(hDlg);

    // Change the directory (If any)
    if(pData->szDirName[0] != 0)
    {
        if(!SetCurrentDirectory(pData->szDirName))
        {
            nError = GetLastError();
            MessageBoxRc(hDlg, IDS_ERROR, IDS_E_CHANGEDIR, pData->szDirName, nError);
        }
    }                          

    // Prepare the file open
    if(nError == ERROR_SUCCESS)
    {
        if(pData->bUseTransaction == FALSE)
        {
            pData->hFile = CreateFile(pData->szFileName1,
                                      pData->dwDesiredAccess,
                                      pData->dwShareAccess,
                                      NULL,
                                      pData->dwCreateDisposition,
                                      pData->dwFileAttributes,
                                      NULL);
        }
        else
        {
            pData->hFile = pfnCreateFileTransacted(pData->szFileName1,
                                                   pData->dwDesiredAccess,
                                                   pData->dwShareAccess,
                                                   NULL,
                                                   pData->dwCreateDisposition,
                                                   pData->dwFileAttributes,
                                                   NULL,
                                                   pData->hTransaction,
                                                   NULL,
                                                   NULL);
        }

        if(IsHandleInvalid(pData->hFile))
            nError = GetLastError();

        SetOperationResult(hDlg, nError);
    }
    return TRUE;
}

static int OnCloseHandleClick(HWND hDlg)
{
    TPropSheetData * pData = (TPropSheetData *)GetWindowLongPtr(hDlg, DWLP_USER);
    int nError = ERROR_SUCCESS;

    if(IsHandleValid(pData->hFile))
    {
        if(!CloseHandle(pData->hFile))
            nError = GetLastError();
    }

    pData->hFile = NULL;
    SetOperationResult(hDlg, nError);
    return TRUE;
}

//-----------------------------------------------------------------------------
// Dialog procedure

static int OnCommand(HWND hDlg, UINT nNotify, UINT nIDCtrl)
{
    if(nNotify == BN_CLICKED)
    {
        switch(nIDCtrl)
        {
            case IDC_BROWSE_DIR:
                OnBrowseDirClick(hDlg);
                return TRUE;

            case IDC_BROWSE_FILE:
                OnBrowseFileClick(hDlg);
                return TRUE;

            case IDC_BROWSE_DESIRED_ACCESS:
                return OnDesiredAccessClick(hDlg);

            case IDC_BROWSE_FILE_ATTRIBUTES:
                return OnFileAttributesClick(hDlg);
        
            case IDC_BROWSE_SHARE_ACCESS:
                return OnShareAccessClick(hDlg);

            case IDC_OPEN_FILE:
                return OnOpenFileClick(hDlg);

            case IDC_CLOSEHANDLE:
                return OnCloseHandleClick(hDlg);
        }
    }

    return FALSE;
}

static int OnNotify(HWND hDlg, NMHDR * pNMHDR)
{
    switch(pNMHDR->code)
    {
        case PSN_SETACTIVE:
            return OnSetActive(hDlg);

        case PSN_KILLACTIVE:
            return OnKillActive(hDlg);
    }
    return FALSE;
}

INT_PTR CALLBACK PageProc01(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    switch(uMsg)
    {
        case WM_INITDIALOG:
            return OnInitDialog(hDlg, lParam);

        case WM_COMMAND:
            return OnCommand(hDlg, HIWORD(wParam), LOWORD(wParam));

        case WM_NOTIFY:
            return OnNotify(hDlg, (NMHDR *)lParam);
    }
    return FALSE;
}