trunk/VTBFileUtil2/ScanUtility.cxx

// Vance Thrift and Biller File Utility 2
//
// Douglas Thrift
//
// $Id: ScanUtility.cxx,v 1.14 2003/09/03 22:58:38 douglas Exp $

#include "ScanUtility.h"

ScanUtility::ScanUtility() : DiscBrowse()
{
        number = count++;

        utilities.insert(pair<unsigned, ScanUtility*>(number, this));

        title = programName + " - Scan Utility";

        // start
        wizard[0].dwSize = sizeof(wizard[0]);
        wizard[0].dwFlags = PSP_DEFAULT | PSP_USETITLE | PSP_USEHEADERTITLE |
                PSP_USEHEADERSUBTITLE;
        wizard[0].hInstance = gui.instance;
        wizard[0].pszTemplate = MAKEINTRESOURCE(IDD_START);
        wizard[0].pszTitle = title.c_str();
        wizard[0].pfnDlgProc = start;
        wizard[0].lParam = number;
        wizard[0].pszHeaderTitle = "Start";
        wizard[0].pszHeaderSubTitle = "Change any settings before scanning.";

        // select
        wizard[1].dwSize = sizeof(wizard[1]);
        wizard[1].dwFlags = PSP_DEFAULT | PSP_USETITLE | PSP_USEHEADERTITLE |
                PSP_USEHEADERSUBTITLE;
        wizard[1].hInstance = gui.instance;
        wizard[1].pszTemplate = MAKEINTRESOURCE(IDD_SELECT);
        wizard[1].pszTitle = title.c_str();
        wizard[1].pfnDlgProc = select;
        wizard[1].lParam = number;
        wizard[1].pszHeaderTitle = "Select";
        wizard[1].pszHeaderSubTitle = "Choose the scanned document to save.";

        // enter
        wizard[2].dwSize = sizeof(wizard[2]);
        wizard[2].dwFlags = PSP_DEFAULT | PSP_USETITLE | PSP_USEHEADERTITLE |
                PSP_USEHEADERSUBTITLE;
        wizard[2].hInstance = gui.instance;
        wizard[2].pszTemplate = MAKEINTRESOURCE(IDD_ENTER);
        wizard[2].pszTitle = title.c_str();
        wizard[2].pfnDlgProc = enter;
        wizard[2].lParam = number;
        wizard[2].pszHeaderTitle = "Enter";
        wizard[2].pszHeaderSubTitle = "Input the client information.";

        // confirm
        wizard[3].dwSize = sizeof(wizard[3]);
        wizard[3].dwFlags = PSP_DEFAULT | PSP_USETITLE | PSP_USEHEADERTITLE |
                PSP_USEHEADERSUBTITLE;
        wizard[3].hInstance = gui.instance;
        wizard[3].pszTemplate = MAKEINTRESOURCE(IDD_CONFIRM);
        wizard[3].pszTitle = title.c_str();
        wizard[3].pfnDlgProc = confirm;
        wizard[3].lParam = number;
        wizard[3].pszHeaderTitle = "Confirm";
        wizard[3].pszHeaderSubTitle = "Make sure the file information is correct.";

        // complete
        wizard[4].dwSize = sizeof(wizard[3]);
        wizard[4].dwFlags = PSP_DEFAULT | PSP_USETITLE | PSP_USEHEADERTITLE |
                PSP_USEHEADERSUBTITLE;
        wizard[4].hInstance = gui.instance;
        wizard[4].pszTemplate = MAKEINTRESOURCE(IDD_DONE);
        wizard[4].pszTitle = title.c_str();
        wizard[4].pfnDlgProc = done;
        wizard[4].lParam = number;
        wizard[4].pszHeaderTitle = "Done";
        wizard[4].pszHeaderSubTitle = "Exit or start over for another scan.";
}

ScanUtility::~ScanUtility()
{
        utilities.erase(number);
}

void ScanUtility::run(void)
{
        loadDirs();

        PROPSHEETHEADER header;

        // header
        header.dwSize = sizeof(header);
        header.dwFlags = PSH_DEFAULT | PSH_HEADER | PSH_PROPSHEETPAGE |
                PSH_USEICONID | PSH_WIZARD97 | PSH_WIZARDHASFINISH;
        header.hwndParent = NULL;
        header.hInstance = gui.instance;
        header.pszIcon = MAKEINTRESOURCE(IDI_VTB_ICON);
        header.nPages = 5;
        header.nStartPage = 0;
        header.ppsp = wizard;
        header.pszbmHeader = MAKEINTRESOURCE(IDB_VTB_BMP);

        PropertySheet(&header);
        saveDirs();
}

map<unsigned, ScanUtility*> ScanUtility::utilities;
map<HWND, ScanUtility*> ScanUtility::windows;

void ScanUtility::loadDirs(void)
{
        HKEY key;

        if (RegOpenKeyEx(HKEY_CURRENT_USER,
                "Software\\DouglasThrift\\VTBFileUtil2", 0, KEY_QUERY_VALUE, &key) ==
                ERROR_SUCCESS)
        {
                DWORD type;
                char data[MAX_PATH];
                DWORD size = MAX_PATH;

                if (RegQueryValueEx(key, "ScanDir", NULL, &type, LPBYTE(data), &size)
                        == ERROR_SUCCESS)
                {
                        data[size - 1] = '\0';

                        switch (type)
                        {
                        case REG_EXPAND_SZ:
                                {
                                        char folder[MAX_PATH];

                                        ExpandEnvironmentStrings(data, folder, MAX_PATH);

                                        scanDir = tail(folder);
                                }
                                break;
                        case REG_SZ:
                                scanDir = tail(data);
                                break;
                        default:
                                setScanDir();
                                break;
                        }
                }
                else
                {
                        setScanDir();
                }

                size = MAX_PATH;

                if (RegQueryValueEx(key, "SaveDir", NULL, &type, LPBYTE(data), &size)
                        == ERROR_SUCCESS)
                {
                        data[size - 1] = '\0';

                        switch (type)
                        {
                        case REG_EXPAND_SZ:
                                {
                                        char folder[MAX_PATH];

                                        ExpandEnvironmentStrings(data, folder, MAX_PATH);

                                        saveDir = tail(folder);
                                }
                                break;
                        case REG_SZ:
                                saveDir = tail(data);
                                break;
                        default:
                                setSaveDir();
                                break;
                        }
                }
                else
                {
                        setSaveDir();
                }

                RegCloseKey(key);
        }
        else
        {
                setScanDir();
                setSaveDir();
        }

        if (debug) cerr << "scanDir = " << scanDir << "\n"
                << "saveDir = " << saveDir << "\n";
}

void ScanUtility::saveDirs(void)
{
        HKEY key;

        if (RegCreateKeyEx(HKEY_CURRENT_USER,
                "Software\\DouglasThrift\\VTBFileUtil2", 0, NULL,
                REG_OPTION_NON_VOLATILE, KEY_QUERY_VALUE | KEY_SET_VALUE, NULL, &key,
                NULL) == ERROR_SUCCESS)
        {
                DWORD type;
                char data[MAX_PATH];
                DWORD size = MAX_PATH;

                if (RegQueryValueEx(key, "ScanDir", NULL, &type, LPBYTE(data), &size)
                        == ERROR_SUCCESS)
                {
                        data[size - 1] = '\0';
                }
                else
                {
                        data[0] = '\0';
                }

                if (scanDir != data || type != REG_SZ)
                {
                        if (RegSetValueEx(key, "ScanDir", 0, REG_SZ,
                                LPBYTE(scanDir.c_str()), scanDir.length() + 1) !=
                                ERROR_SUCCESS)
                        {
                                error();
                        }
                }

                size = MAX_PATH;

                if (RegQueryValueEx(key, "SaveDir", NULL, &type, LPBYTE(data), &size)
                        == ERROR_SUCCESS)
                {
                        data[size - 1] = '\0';
                }
                else
                {
                        data[0] = '\0';
                }

                if (saveDir != data || type != REG_SZ)
                {
                        if (RegSetValueEx(key, "SaveDir", 0, REG_SZ,
                                LPBYTE(saveDir.c_str()), saveDir.length() + 1) !=
                                ERROR_SUCCESS)
                        {
                                error();
                        }
                }

                RegCloseKey(key);
        }
        else
        {
                error();
        }
}

void ScanUtility::setScanDir(HWND parent)
{
        BROWSEINFO info;

        info.hwndOwner = parent;
        info.pidlRoot = NULL;
        info.pszDisplayName = NULL;
        info.lpszTitle = "Select the Scan Directory";
        info.ulFlags = BIF_RETURNONLYFSDIRS | BIF_STATUSTEXT;
        info.lpfn = browse;
        info.lParam = MAKELPARAM(number, true);
        info.iImage = 0;

        do
        {
                LPITEMIDLIST id = SHBrowseForFolder(&info);

                if (id != NULL)
                {
                        char folder[MAX_PATH];

                        if (SHGetPathFromIDList(id, folder)) scanDir = tail(folder);
                }

                LPMALLOC destruct;

                SHGetMalloc(&destruct);
                destruct->Free(id);
                destruct->Release();

                if (scanDir == "")
                {
                        switch (MessageBox(parent, "Scan Directory needs to be selected.",
                                title.c_str(), MB_ABORTRETRYIGNORE | MB_ICONERROR))
                        {
                        case IDABORT:
                                exit(1);
                                break;
                        case IDRETRY:
                                break;
                        case IDIGNORE:
                                Beep(2200, 250);
                                Beep(1100, 500);
                                Beep(3300, 250);
                                exit(2);
                                break;
                        }
                }
        }
        while (scanDir == "");

        if (debug) cerr << "scanDir = " << scanDir << "\n";
}

void ScanUtility::setSaveDir(HWND parent)
{
        BROWSEINFO info;

        info.hwndOwner = parent;
        info.pidlRoot = NULL;
        info.pszDisplayName = NULL;
        info.lpszTitle = "Select the Save Directory";
        info.ulFlags = BIF_RETURNONLYFSDIRS | BIF_STATUSTEXT;
        info.lpfn = browse;
        info.lParam = MAKELPARAM(number, false);
        info.iImage = 0;

        do
        {
                LPITEMIDLIST id = SHBrowseForFolder(&info);

                if (id != NULL)
                {
                        char folder[MAX_PATH];

                        if (SHGetPathFromIDList(id, folder)) saveDir = tail(folder);
                }

                LPMALLOC destruct;

                SHGetMalloc(&destruct);
                destruct->Free(id);
                destruct->Release();

                if (saveDir == "")
                {
                        switch (MessageBox(parent, "Scan Directory needs to be selected.",
                                title.c_str(), MB_ABORTRETRYIGNORE | MB_ICONERROR))
                        {
                        case IDABORT:
                                exit(1);
                                break;
                        case IDRETRY:
                                break;
                        case IDIGNORE:
                                Beep(2200, 250);
                                Beep(1100, 500);
                                Beep(3300, 250);
                                exit(2);
                                break;
                        }
                }
        }
        while (saveDir == "");

        if (debug) cerr << "saveDir = " << saveDir << "\n";
}

void ScanUtility::populate(HWND parent)
{
        set<string> scans;

        do
        {
                string scan = scanDir + "SCAN????_000." +
                        IndividualClient::getExtension();
                WIN32_FIND_DATA found;
                HANDLE finder = FindFirstFile(scan.c_str(), &found);

                if (finder != INVALID_HANDLE_VALUE)
                {
                        do
                        {
                                scans.insert(found.cFileName);
                        }
                        while (FindNextFile(finder, &found));

                        FindClose(finder);
                }
                else
                {
                        error(parent);
                }

                if (scans.empty())
                {
                        if (MessageBox(parent, "No scanned documents found.",
                                title.c_str(), MB_RETRYCANCEL | MB_ICONQUESTION) == IDCANCEL)
                                break;
                }
        }
        while (scans.empty());

        if (scans.empty())
        {
                PropSheet_PressButton(GetParent(parent), PSBTN_BACK);
        }
        else
        {
                SHFILEINFO info;
                HIMAGELIST icons = HIMAGELIST(SHGetFileInfo((*scans.begin()).c_str(),
                        0, &info, sizeof(info), SHGFI_SMALLICON | SHGFI_SYSICONINDEX));

                ListView_SetImageList(GetDlgItem(parent, IDC_SELECT_SCANS), icons,
                        LVSIL_SMALL);

                if (debug) cerr << "scans = {\n";

                for (set<string>::iterator itor = scans.begin(); itor != scans.end();
                        itor++)
                {
                        if (debug) cerr << "   " << *itor << "\n";

                        char scan[MAX_PATH];

                        sprintf(scan, "%s", (*itor).c_str());

                        LVITEM item;

                        item.mask = LVIF_IMAGE | LVIF_TEXT;
                        item.iItem = 0;
                        item.iSubItem = 0;
                        item.pszText = scan;
                        item.iImage = info.iIcon;

                        ListView_InsertItem(GetDlgItem(parent, IDC_SELECT_SCANS), &item);
                }

                if (debug) cerr << "}\n";

                ListView_SetItemState(GetDlgItem(parent, IDC_SELECT_SCANS), 0,
                        LVIS_SELECTED, LVIS_SELECTED);
        }
}

ScanUtility* ScanUtility::which(HWND window)
{
        map<HWND, ScanUtility*>::iterator itor = windows.find(window);

        return itor->second;
}

ScanUtility* ScanUtility::which(HWND window, LPARAM l)
{
        LPPROPSHEETPAGE page = LPPROPSHEETPAGE(l);
        map<unsigned, ScanUtility*>::iterator itor = utilities.find(page->lParam);

        windows.insert(pair<HWND, ScanUtility*>(window, itor->second));

        return itor->second;
}

int ScanUtility::browse(HWND dialog, UINT msg, LPARAM l, LPARAM d)
{
        map<unsigned, ScanUtility*>::iterator itor = utilities.find(LOWORD(d));
        ScanUtility* data = itor->second;

        switch (msg)
        {
        case BFFM_INITIALIZED:
                center(dialog);
                SendMessage(dialog, BFFM_SETOKTEXT, 0,
                        LPARAM(toWide("&Select").c_str()));
                SendMessage(dialog, BFFM_SETEXPANDED, FALSE, CSIDL_DRIVES);
                SendMessage(dialog, BFFM_SETSELECTION, TRUE, LPARAM(HIWORD(d) ?
                        data->scanDir.c_str() : data->saveDir.c_str()));
                break;
        case BFFM_SELCHANGED:
                {
                        SHFILEINFO info;

                        SHGetFileInfo(LPCSTR(l), 0, &info, sizeof(info), SHGFI_DISPLAYNAME
                                | SHGFI_PIDL);
                        SendMessage(dialog, BFFM_SETSTATUSTEXT, 0,
                                LPARAM(info.szDisplayName));

                        char folder[MAX_PATH];

                        if (!SHGetPathFromIDList(LPCITEMIDLIST(l), folder))
                        {
                                SendMessage(dialog, BFFM_ENABLEOK, 0, 0);
                        }
                        else
                        {
                                SendMessage(dialog, BFFM_SETSTATUSTEXT, 0, LPARAM(folder));
                        }
                }
                break;
        }

        return 0;
}

INT_PTR ScanUtility::start(HWND dialog, UINT msg, WPARAM w, LPARAM l)
{
        ScanUtility* data = which(dialog);

        switch (msg)
        {
        case WM_INITDIALOG:
                center(GetParent(dialog));
                SendMessage(GetParent(dialog), WM_SETICON, ICON_BIG, LPARAM(gui.icon));
                
                data = which(dialog, l);

                {
                        ostringstream instructions;

                        instructions << "1. If you need instructions, you should not be ru"
                                << "nning this program in Scan Utility mode.\n"
                                << "2. Otherwise, go forth and scan.\n"
                                << "3. Then come back and click Next.\n";

                        SetDlgItemText(dialog, IDC_START_INSTRUCTIONS,
                                instructions.str().c_str());
                }
                break;
        case WM_NOTIFY:
                {
                        LPNMHDR nm = LPNMHDR(l);

                        switch (nm->code)
                        {
                        case PSN_SETACTIVE:
                                PropSheet_SetWizButtons(GetParent(dialog), PSWIZB_FINISH |
                                        PSWIZB_NEXT);

                                {
                                        SHFILEINFO info;

                                        SHGetFileInfo(data->scanDir.c_str(), 0, &info,
                                                sizeof(info), SHGFI_ICONLOCATION);

                                        HICON icon = ExtractIcon(gui.instance, info.szDisplayName,
                                                info.iIcon);

                                        SendDlgItemMessage(dialog, IDC_START_SCAN_ICON,
                                                STM_SETIMAGE, IMAGE_ICON, LPARAM(icon));
                                        SHGetFileInfo(data->saveDir.c_str(), 0, &info,
                                                sizeof(info), SHGFI_ICONLOCATION);

                                        icon = ExtractIcon(gui.instance, info.szDisplayName,
                                                info.iIcon);

                                        SendDlgItemMessage(dialog, IDC_START_SAVE_ICON,
                                                STM_SETIMAGE, IMAGE_ICON, LPARAM(icon));
                                }

                                {
                                        char folder[38];

                                        PathCompactPathEx(folder, data->scanDir.substr(0,
                                                data->scanDir.length() - 1).c_str(), 38, 0);
                                        SetDlgItemText(dialog, IDC_START_SCAN_TEXT, folder);
                                        PathCompactPathEx(folder, data->saveDir.substr(0,
                                                data->saveDir.length() - 1).c_str(), 38, 0);
                                        SetDlgItemText(dialog, IDC_START_SAVE_TEXT, folder);
                                }
                                break;
                        case PSN_WIZNEXT:
                                SetCurrentDirectory(data->scanDir.c_str());
                                break;
                        }
                }
                break;
        case WM_COMMAND:
                switch (LOWORD(w))
                {
                case IDC_START_SCAN_BROWSE:
                        data->setScanDir(dialog);

                        {
                                SHFILEINFO info;

                                SHGetFileInfo(data->scanDir.c_str(), 0, &info, sizeof(info),
                                        SHGFI_ICONLOCATION);

                                HICON icon = ExtractIcon(gui.instance, info.szDisplayName,
                                        info.iIcon);

                                SendDlgItemMessage(dialog, IDC_START_SCAN_ICON, STM_SETIMAGE,
                                        IMAGE_ICON, LPARAM(icon));
                        }

                        {
                                char folder[38];

                                PathCompactPathEx(folder, data->scanDir.substr(0,
                                        data->scanDir.length() - 1).c_str(), 38, 0);
                                SetDlgItemText(dialog, IDC_START_SCAN_TEXT, folder);
                        }
                        break;
                case IDC_START_SAVE_BROWSE:
                        data->setSaveDir(dialog);

                        {
                                SHFILEINFO info;

                                SHGetFileInfo(data->saveDir.c_str(), 0, &info, sizeof(info),
                                        SHGFI_ICONLOCATION);

                                HICON icon = ExtractIcon(gui.instance, info.szDisplayName,
                                        info.iIcon);

                                SendDlgItemMessage(dialog, IDC_START_SAVE_ICON, STM_SETIMAGE,
                                        IMAGE_ICON, LPARAM(icon));
                        }

                        {
                                char folder[38];

                                PathCompactPathEx(folder, data->saveDir.substr(0,
                                        data->saveDir.length() - 1).c_str(), 38, 0);
                                SetDlgItemText(dialog, IDC_START_SAVE_TEXT, folder);
                        }
                        break;
                }
                break;
        }

        return FALSE;
}

INT_PTR ScanUtility::select(HWND dialog, UINT msg, WPARAM w, LPARAM l)
{
        ScanUtility* data = which(dialog);

        switch (msg)
        {
        case WM_INITDIALOG:
                data = which(dialog, l);

                {
                        ostringstream select;

                        select << "Select the scanned document that you need to save.";

                        SetDlgItemText(dialog, IDC_SELECT_TEXT, select.str().c_str());
                }

                {
                        LVCOLUMN column;

                        column.mask = LVCF_FMT | LVCF_TEXT | LVCF_WIDTH;
                        column.fmt = LVCFMT_IMAGE;
                        column.cx = 120;
                        column.pszText = "Scanned Documents";

                        ListView_InsertColumn(GetDlgItem(dialog, IDC_SELECT_SCANS), 0,
                                &column);
                }
                break;
        case WM_NOTIFY:
                if (w == IDC_SELECT_SCANS)
                {
                        LPNMITEMACTIVATE ni = LPNMITEMACTIVATE(l);

                        switch (ni->hdr.code)
                        {
                        case NM_DBLCLK:
                                if (ni->iItem != -1)
                                {
                                        char scan[MAX_PATH];

                                        ListView_GetItemText(GetDlgItem(dialog, IDC_SELECT_SCANS),
                                                ni->iItem, 0, scan, MAX_PATH);
                                        ShellExecute(dialog, NULL, scan, NULL, NULL,
                                                SW_SHOWDEFAULT);
                                }
                                break;
                        }
                }
                else
                {
                        LPNMHDR nm = LPNMHDR(l);

                        switch (nm->code)
                        {
                        case PSN_SETACTIVE:
                                PropSheet_SetWizButtons(GetParent(dialog), PSWIZB_BACK |
                                        PSWIZB_DISABLEDFINISH | PSWIZB_NEXT);
                                data->populate(dialog);
                                break;
                        case PSN_WIZBACK:
                                ListView_DeleteAllItems(GetDlgItem(dialog, IDC_SELECT_SCANS));
                                data->client.setFile("");
                                break;
                        case PSN_WIZNEXT:
                                {
                                        int index = ListView_GetNextItem(GetDlgItem(dialog,
                                                IDC_SELECT_SCANS), -1, LVNI_SELECTED);
                                        char scan[MAX_PATH];

                                        if (index != -1)
                                        {
                                                ListView_GetItemText(GetDlgItem(dialog,
                                                        IDC_SELECT_SCANS), index, 0, scan, MAX_PATH);
                                        }
                                        else
                                        {
                                                ListView_GetItemText(GetDlgItem(dialog,
                                                        IDC_SELECT_SCANS), 0, 0, scan, MAX_PATH);
                                        }

                                        data->scan = scan;
                                }

                                if (debug) cerr << "scan = " << data->scan << "\n";

                                ListView_DeleteAllItems(GetDlgItem(dialog, IDC_SELECT_SCANS));
                                break;
                        }
                }
                break;
        case WM_CONTEXTMENU:
                if (ListView_GetNextItem(GetDlgItem(dialog, IDC_SELECT_SCANS), -1,
                        LVNI_SELECTED) != -1)
                {
                        char scan[MAX_PATH];
                        POINT spot;
                        LVHITTESTINFO test;

                        test.pt.x = GET_X_LPARAM(l);
                        test.pt.y = GET_Y_LPARAM(l);

                        ScreenToClient(GetDlgItem(dialog, IDC_SELECT_SCANS), &test.pt);
                        ListView_HitTest(GetDlgItem(dialog, IDC_SELECT_SCANS), &test);

                        if (test.iItem != -1)
                        {
                                ListView_GetItemText(GetDlgItem(dialog, IDC_SELECT_SCANS),
                                        test.iItem, 0, scan, MAX_PATH);
                                
                                spot.x = test.pt.x;
                                spot.y = test.pt.y;
                        }
                        else if (GET_X_LPARAM(l) == -1 && GET_Y_LPARAM(l) == -1)
                        {
                                int index = ListView_GetNextItem(GetDlgItem(dialog,
                                        IDC_SELECT_SCANS), -1, LVNI_SELECTED);
                                RECT rect;

                                ListView_GetItemText(GetDlgItem(dialog, IDC_SELECT_SCANS),
                                        index, 0, scan, MAX_PATH);
                                ListView_EnsureVisible(GetDlgItem(dialog, IDC_SELECT_SCANS),
                                        index, FALSE);
                                ListView_GetItemRect(GetDlgItem(dialog, IDC_SELECT_SCANS),
                                        index, &rect, LVIR_SELECTBOUNDS);

                                spot.x = rect.left;
                                spot.y = rect.top;
                        }

                        ClientToScreen(GetDlgItem(dialog, IDC_SELECT_SCANS), &spot);

                        int code = TrackPopupMenuEx(data->popup, TPM_LEFTALIGN |
                                TPM_TOPALIGN | TPM_NONOTIFY | TPM_RETURNCMD | TPM_RIGHTBUTTON,
                                spot.x, spot.y, GetDlgItem(dialog, IDC_SELECT_SCANS), NULL);

                        switch (code)
                        {
                        case 1:
                                ShellExecute(dialog, NULL, scan, NULL, NULL, SW_SHOWDEFAULT);
                                break;
                        case 2:
                                {
                                        SHELLEXECUTEINFO info;

                                        info.cbSize = sizeof(info);
                                        info.fMask = SEE_MASK_INVOKEIDLIST;
                                        info.hwnd = dialog;
                                        info.lpVerb = "properties";
                                        info.lpFile = scan;
                                        info.lpParameters = NULL;
                                        info.lpDirectory = NULL;
                                        info.nShow = SW_SHOWDEFAULT;
                                        info.lpIDList = NULL;

                                        ShellExecuteEx(&info);
                                }
                                break;
                        }
                }
                break;
        }

        return FALSE;
}

INT_PTR ScanUtility::enter(HWND dialog, UINT msg, WPARAM w, LPARAM l)
{
        ScanUtility* data = which(dialog);

        switch (msg)
        {
        case WM_INITDIALOG:
                data = which(dialog, l);

                {
                        ostringstream enter;

                        enter << "Enter the client name and number.";

                        SetDlgItemText(dialog, IDC_ENTER_TEXT, enter.str().c_str());
                }
                break;
        case WM_NOTIFY:
                {
                        LPNMHDR nm = LPNMHDR(l);

                        switch (nm->code)
                        {
                        case PSN_SETACTIVE:
                                if (data->client.getName() != "" && data->client.getNumber() !=
                                        0)
                                {
                                        PropSheet_SetWizButtons(GetParent(dialog), PSWIZB_BACK |
                                                PSWIZB_DISABLEDFINISH | PSWIZB_NEXT);
                                }
                                else
                                {
                                        PropSheet_SetWizButtons(GetParent(dialog), PSWIZB_BACK |
                                                PSWIZB_DISABLEDFINISH);
                                }

                                SetDlgItemText(dialog, IDC_ENTER_NAME,
                                        data->client.getName().c_str());

                                if (data->client.getNumber() != 0)
                                {
                                        SetDlgItemInt(dialog, IDC_ENTER_NUM,
                                                data->client.getNumber(), FALSE);
                                }
                                else
                                {
                                        SetDlgItemText(dialog, IDC_ENTER_NUM, "");
                                }
                                break;
                        case PSN_WIZBACK:
                                break;
                        case PSN_WIZNEXT:
                                if (debug)
                                {
                                        cerr << "client = {\n"
                                                << "   name = " << data->client.getName() << "\n"
                                                << "   number = " << data->client.getNumber() << "\n"
                                                << "   file = " << data->client.getFile() << "\n"
                                                << "}\n";
                                }

                                data->save = data->saveDir + '\\' + data->client.getFile();

                                if (debug) cerr << "save = " << data->save << "\n";
                                
                                break;
                        }
                }
                break;
        case WM_COMMAND:
                switch (LOWORD(w))
                {
                case IDC_ENTER_NAME:
                        {
                                char name[BUFSIZ];

                                GetDlgItemText(dialog, IDC_ENTER_NAME, name, BUFSIZ);

                                if (name != data->client.getName())
                                {
                                        data->client.setName(name);
                                }
                        }

                        if (data->client.getName() != "" && data->client.getNumber() != 0)
                        {
                                PropSheet_SetWizButtons(GetParent(dialog), PSWIZB_BACK |
                                        PSWIZB_DISABLEDFINISH | PSWIZB_NEXT);
                        }
                        else
                        {
                                PropSheet_SetWizButtons(GetParent(dialog), PSWIZB_BACK |
                                        PSWIZB_DISABLEDFINISH);
                        }
                        break;
                case IDC_ENTER_NUM:
                        {
                                unsigned number = GetDlgItemInt(dialog, IDC_ENTER_NUM, NULL,
                                        FALSE);

                                if (number != data->client.getNumber())
                                {
                                        data->client.setNumber(number);
                                }
                        }

                        if (data->client.getName() != "" && data->client.getNumber() != 0)
                        {
                                PropSheet_SetWizButtons(GetParent(dialog), PSWIZB_BACK |
                                        PSWIZB_DISABLEDFINISH | PSWIZB_NEXT);
                        }
                        else
                        {
                                PropSheet_SetWizButtons(GetParent(dialog), PSWIZB_BACK |
                                        PSWIZB_DISABLEDFINISH);
                        }
                        break;
                }
                break;
        }

        return FALSE;
}

INT_PTR ScanUtility::confirm(HWND dialog, UINT msg, WPARAM w, LPARAM l)
{
        ScanUtility* data = which(dialog);

        switch (msg)
        {
        case WM_INITDIALOG:
                data = which(dialog, l);

                {
                        ostringstream confirm;

                        confirm << "Confirm the client file\'s name and size.";

                        SetDlgItemText(dialog, IDC_CONFIRM_TEXT, confirm.str().c_str());
                }
                break;
        case WM_NOTIFY:
                {
                        LPNMHDR nm = LPNMHDR(l);

                        switch (nm->code)
                        {
                        case PSN_SETACTIVE:
                                CheckDlgButton(dialog, IDC_CONFIRM_GOOD, BST_UNCHECKED);
                                PropSheet_SetWizButtons(GetParent(dialog), PSWIZB_BACK |
                                        PSWIZB_DISABLEDFINISH);
                                SetDlgItemText(dialog, IDC_CONFIRM_FILE,
                                        data->client.getFile().c_str());

                                {
                                        HANDLE scan = CreateFile(data->scan.c_str(), GENERIC_READ,
                                                FILE_SHARE_READ, NULL, OPEN_EXISTING,
                                                FILE_ATTRIBUTE_NORMAL, NULL);
                                        DWORD bytes = GetFileSize(scan, NULL);

                                        CloseHandle(scan);

                                        ostringstream size;

                                        size << format(bytes);

                                        size.setf(ios_base::fixed, ios_base::floatfield);
                                        size.precision(2);
                                        
                                        FLOAT megabytes = FLOAT(bytes) / FLOAT(1024 * 1024);

                                        size << " bytes (" << megabytes << " MB)";

                                        SetDlgItemText(dialog, IDC_CONFIRM_SIZE,
                                                size.str().c_str());
                                }
                                break;
                        case PSN_WIZBACK:
                                break;
                        case PSN_WIZNEXT:
                                if (MoveFile(data->scan.c_str(), data->save.c_str()) == 0)
                                {
                                        do
                                        {
                                                LPVOID message;
                                                
                                                FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | 
                                                        FORMAT_MESSAGE_FROM_SYSTEM, NULL, GetLastError(),
                                                        0, LPTSTR(&message), 0, NULL);

                                                int code = MessageBox(dialog, LPCTSTR(message),
                                                        data->title.c_str(), MB_RETRYCANCEL |
                                                        MB_ICONEXCLAMATION);

                                                LocalFree(message);

                                                if (code == IDCANCEL)
                                                {
                                                        PropSheet_PressButton(GetParent(dialog),
                                                                PSBTN_BACK);
                                                        break;
                                                }
                                        }
                                        while (MoveFileEx(data->scan.c_str(), data->save.c_str(),
                                                MOVEFILE_REPLACE_EXISTING) == 0);
                                }
                                break;
                        }
                }
                break;
        case WM_COMMAND:
                switch (LOWORD(w))
                {
                case IDC_CONFIRM_GOOD:
                        if (IsDlgButtonChecked(dialog, IDC_CONFIRM_GOOD) == BST_CHECKED)
                        {
                                PropSheet_SetWizButtons(GetParent(dialog), PSWIZB_BACK |
                                        PSWIZB_DISABLEDFINISH | PSWIZB_NEXT);
                        }
                        else
                        {
                                PropSheet_SetWizButtons(GetParent(dialog), PSWIZB_BACK |
                                        PSWIZB_DISABLEDFINISH);
                        }
                        break;
                }
                break;
        }

        return FALSE;
}

INT_PTR ScanUtility::done(HWND dialog, UINT msg, WPARAM w, LPARAM l)
{
        ScanUtility* data = which(dialog);

        switch (msg)
        {
        case WM_INITDIALOG:
                data = which(dialog, l);

                {
                        ostringstream done;

                        done << "You are done saving the scanned document. Click Finish to"
                                << " exit or click Back to return to the beginning.";

                        SetDlgItemText(dialog, IDC_DONE_TEXT, done.str().c_str());
                }
                break;
        case WM_NOTIFY:
                {
                        LPNMHDR nm = LPNMHDR(l);

                        switch (nm->code)
                        {
                        case PSN_SETACTIVE:
                                PropSheet_SetWizButtons(GetParent(dialog), PSWIZB_BACK | 
                                        PSWIZB_FINISH);
                                break;
                        case PSN_WIZBACK:
                                data->client.setFile("");
                                PropSheet_SetCurSelByID(GetParent(dialog), IDD_START);
                                break;
                        case PSN_WIZFINISH:
                                break;
                        }
                }
                break;
        }

        return FALSE;
}
Revision:	288
Committed:	2003-09-03T15:58:38-07:00 (21 years, 10 months ago) by douglas
File size:	23219 byte(s)
Log Message:	Ran into some trouble on Windows 95, hopefully its fixed.