trunk/VTBFileUtil2/ScanUtility.cxx

// Vance Thrift and Biller File Utility 2
//
// Douglas Thrift
//
// $Id: ScanUtility.cxx,v 1.6 2003/08/21 06:29:24 douglas Exp $

#include "ScanUtility.h"

ScanUtility::ScanUtility()
{
        number = count++;
        utilities.insert(pair<unsigned, ScanUtility*>(number, this));
        title = new char[programName.length() + 16];

        sprintf(title, "%s - Scan Utility", programName.c_str());
        loadDirs();
        
        // start
        wizard[0].dwSize = sizeof(wizard[0]);
        wizard[0].dwFlags = PSP_DEFAULT | PSP_USEHICON | PSP_USETITLE |
                PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE;
        wizard[0].hInstance = gui.instance;
        wizard[0].pszTemplate = MAKEINTRESOURCE(IDD_START);
        wizard[0].hIcon = gui.icon;
        wizard[0].pszTitle = title;
        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_USEHICON | PSP_USETITLE |
                PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE;
        wizard[1].hInstance = gui.instance;
        wizard[1].pszTemplate = MAKEINTRESOURCE(IDD_SELECT);
        wizard[1].hIcon = gui.icon;
        wizard[1].pszTitle = title;
        wizard[1].pfnDlgProc = select;
        wizard[1].lParam = number;
        wizard[1].pszHeaderTitle = "Select";
        wizard[1].pszHeaderSubTitle = "Choose the scanned document to save.";
}

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

        delete [] title;
}

void ScanUtility::run(void)
{
        PROPSHEETHEADER header;

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

        PropertySheet(&header);
}

unsigned ScanUtility::count = 0;
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 = folder;
                                }
                                break;
                        case REG_SZ:
                                scanDir = 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 = folder;
                                }
                                break;
                        case REG_SZ:
                                saveDir = 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 = folder;
                        }
                }

                LPMALLOC destruct;

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

                if (scanDir == "")
                {
                        switch (MessageBox(parent, "Scan Directory needs to be selected.",
                                programName.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 = folder;
                        }
                }

                LPMALLOC destruct;

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

                if (saveDir == "")
                {
                        switch (MessageBox(parent, "Scan Directory needs to be selected.",
                                programName.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);
                }

                if (scans.empty())
                {
                        if (MessageBox(parent, "No scanned documents found.",
                                programName.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);

                int index = 0;

                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 = index++;
                        item.iSubItem = 0;
                        item.state = LVIS_SELECTED;
                        item.stateMask = LVIS_SELECTED;
                        item.pszText = scan;
                        item.iImage = info.iIcon;

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

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

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:
                {
                        IShellFolder* object;

                        SHGetDesktopFolder(&object);

                        STRRET thing;
                        char* folder;

                        object->GetDisplayNameOf(LPCITEMIDLIST(l), SHGDN_FORPARSING,
                                &thing);
                        StrRetToStr(&thing, LPCITEMIDLIST(l), &folder);
                        SendMessage(dialog, BFFM_SETSTATUSTEXT, 0, LPARAM(folder));

                        if (PathIsUNCServer(folder))
                        {
                                SendMessage(dialog, BFFM_ENABLEOK, 0, 0);
                        }

                        CoTaskMemFree(folder);
                        object->Release();
                }
                break;
        }

        return 0;
}

INT_PTR ScanUtility::start(HWND dialog, UINT msg, WPARAM w, LPARAM l)
{
        map<HWND, ScanUtility*>::iterator itor = windows.find(dialog);
        ScanUtility* data = itor->second;

        switch (msg)
        {
        case WM_INITDIALOG:
                center(GetParent(dialog));
                {
                        LPPROPSHEETPAGE page = LPPROPSHEETPAGE(l);
                        map<unsigned, ScanUtility*>::iterator itor =
                                utilities.find(page->lParam);

                        windows.insert(pair<HWND, ScanUtility*>(dialog, itor->second));
                }
                {
                        ostringstream instructions;

                        instructions << "1.\tIf you need instructions, you should not be r"
                                << "unning this program\n\tin Scan Utility mode.\n"
                                << "2.\tOtherwise, go forth and scan.\n"
                                << "3.\tThen 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_NEXT);
                                {
                                        char folder[44];

                                        PathCompactPathEx(folder, data->scanDir.c_str(), 44, 0);
                                        SetDlgItemText(dialog, IDC_START_SCAN_TEXT, folder);
                                        PathCompactPathEx(folder, data->saveDir.c_str(), 44, 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);
                        {
                                char folder[44];

                                PathCompactPathEx(folder, data->scanDir.c_str(), 44, 0);
                                SetDlgItemText(dialog, IDC_START_SCAN_TEXT, folder);
                        }
                        break;
                case IDC_START_SAVE_BROWSE:
                        data->setSaveDir(dialog);
                        {
                                char folder[44];

                                PathCompactPathEx(folder, data->saveDir.c_str(), 44, 0);
                                SetDlgItemText(dialog, IDC_START_SAVE_TEXT, folder);
                        }
                        break;
                }
                break;
        }

        return FALSE;
}

INT_PTR ScanUtility::select(HWND dialog, UINT msg, WPARAM w, LPARAM l)
{
        map<HWND, ScanUtility*>::iterator itor = windows.find(dialog);
        ScanUtility* data = itor->second;

        switch (msg)
        {
        case WM_INITDIALOG:
                {
                        LPPROPSHEETPAGE page = LPPROPSHEETPAGE(l);
                        map<unsigned, ScanUtility*>::iterator itor =
                                utilities.find(page->lParam);

                        windows.insert(pair<HWND, ScanUtility*>(dialog, itor->second));
                }
                {
                        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)
                {
                        switch (ListView_GetSelectedCount(GetDlgItem(dialog,
                                IDC_SELECT_SCANS)))
                        {
                        case 1:
                                PropSheet_SetWizButtons(GetParent(dialog), PSWIZB_BACK |
                                        PSWIZB_NEXT);
                                break;
                        default:
                                PropSheet_SetWizButtons(GetParent(dialog), PSWIZB_BACK);
                                break;
                        }
                }
                else
                {
                        LPNMHDR nm = LPNMHDR(l);

                        switch (nm->code)
                        {
                        case PSN_SETACTIVE:
                                PropSheet_SetWizButtons(GetParent(dialog), PSWIZB_BACK);
                                data->populate(dialog);
                                break;
                        case PSN_WIZBACK:
                                ListView_DeleteAllItems(GetDlgItem(dialog, IDC_SELECT_SCANS));
                                break;
                        case PSN_WIZNEXT:
                                //
                                ListView_DeleteAllItems(GetDlgItem(dialog, IDC_SELECT_SCANS));
                                break;
                        }
                }
                break;
        case WM_COMMAND:
                break;
        }

        return FALSE;
}
Revision:	273
Committed:	2003-08-20T23:29:24-07:00 (21 years, 10 months ago) by douglas
File size:	12269 byte(s)
Log Message:	Did stuff.
#	User	Rev	Content
1	douglas	260	// Vance Thrift and Biller File Utility 2
2			//
3			// Douglas Thrift
4			//
5	douglas	273	// $Id: ScanUtility.cxx,v 1.6 2003/08/21 06:29:24 douglas Exp $
6	douglas	260
7			#include "ScanUtility.h"
8	douglas	265
9	douglas	268	ScanUtility::ScanUtility()
10			{
11			number = count++;
12			utilities.insert(pair<unsigned, ScanUtility*>(number, this));
13			title = new char[programName.length() + 16];
14
15			sprintf(title, "%s - Scan Utility", programName.c_str());
16	douglas	269	loadDirs();
17	douglas	268
18			// start
19	douglas	271	wizard[0].dwSize = sizeof(wizard[0]);
20			wizard[0].dwFlags = PSP_DEFAULT \| PSP_USEHICON \| PSP_USETITLE \|
21	douglas	268	PSP_USEHEADERTITLE \| PSP_USEHEADERSUBTITLE;
22	douglas	271	wizard[0].hInstance = gui.instance;
23			wizard[0].pszTemplate = MAKEINTRESOURCE(IDD_START);
24			wizard[0].hIcon = gui.icon;
25			wizard[0].pszTitle = title;
26			wizard[0].pfnDlgProc = start;
27			wizard[0].lParam = number;
28			wizard[0].pszHeaderTitle = "Start";
29			wizard[0].pszHeaderSubTitle = "Change any settings before scanning.";
30	douglas	273
31			// select
32			wizard[1].dwSize = sizeof(wizard[1]);
33			wizard[1].dwFlags = PSP_DEFAULT \| PSP_USEHICON \| PSP_USETITLE \|
34			PSP_USEHEADERTITLE \| PSP_USEHEADERSUBTITLE;
35			wizard[1].hInstance = gui.instance;
36			wizard[1].pszTemplate = MAKEINTRESOURCE(IDD_SELECT);
37			wizard[1].hIcon = gui.icon;
38			wizard[1].pszTitle = title;
39			wizard[1].pfnDlgProc = select;
40			wizard[1].lParam = number;
41			wizard[1].pszHeaderTitle = "Select";
42			wizard[1].pszHeaderSubTitle = "Choose the scanned document to save.";
43	douglas	268	}
44
45			ScanUtility::~ScanUtility()
46			{
47			utilities.erase(number);
48	douglas	269	saveDirs();
49
50	douglas	268	delete [] title;
51			}
52
53	douglas	265	void ScanUtility::run(void)
54			{
55	douglas	268	PROPSHEETHEADER header;
56	douglas	265
57	douglas	268	// header
58			header.dwSize = sizeof(header);
59	douglas	271	header.dwFlags = PSH_DEFAULT \| PSH_HEADER \| PSH_PROPSHEETPAGE \|
60			PSH_USEICONID \| PSH_WIZARD97;
61	douglas	268	header.hwndParent = NULL;
62			header.hInstance = gui.instance;
63			header.pszIcon = MAKEINTRESOURCE(IDI_VTB_ICON);
64	douglas	273	header.nPages = 2;
65	douglas	268	header.nStartPage = 0;
66	douglas	271	header.ppsp = wizard;
67	douglas	269	header.pszbmHeader = MAKEINTRESOURCE(IDB_VTB_BMP);
68	douglas	265
69	douglas	268	PropertySheet(&header);
70			}
71
72			unsigned ScanUtility::count = 0;
73			map<unsigned, ScanUtility*> ScanUtility::utilities;
74			map<HWND, ScanUtility*> ScanUtility::windows;
75
76	douglas	269	void ScanUtility::loadDirs(void)
77			{
78			HKEY key;
79
80			if (RegOpenKeyEx(HKEY_CURRENT_USER,
81	douglas	271	"Software\\DouglasThrift\\VTBFileUtil2", 0, KEY_QUERY_VALUE, &key) ==
82	douglas	269	ERROR_SUCCESS)
83			{
84			DWORD type;
85	douglas	271	char data[MAX_PATH];
86	douglas	269	DWORD size = MAX_PATH;
87
88	douglas	271	if (RegQueryValueEx(key, "ScanDir", NULL, &type, LPBYTE(data), &size)
89			== ERROR_SUCCESS)
90	douglas	269	{
91			data[size - 1] = '\0';
92
93			switch (type)
94			{
95			case REG_EXPAND_SZ:
96	douglas	273	{
97			char folder[MAX_PATH];
98
99			ExpandEnvironmentStrings(data, folder, MAX_PATH);
100
101			scanDir = folder;
102			}
103	douglas	269	break;
104			case REG_SZ:
105	douglas	271	scanDir = data;
106	douglas	269	break;
107			default:
108			setScanDir();
109			break;
110			}
111			}
112			else
113			{
114			setScanDir();
115			}
116
117			size = MAX_PATH;
118
119	douglas	271	if (RegQueryValueEx(key, "SaveDir", NULL, &type, LPBYTE(data), &size)
120			== ERROR_SUCCESS)
121	douglas	269	{
122			data[size - 1] = '\0';
123
124			switch (type)
125			{
126			case REG_EXPAND_SZ:
127	douglas	273	{
128			char folder[MAX_PATH];
129
130			ExpandEnvironmentStrings(data, folder, MAX_PATH);
131
132			saveDir = folder;
133			}
134	douglas	269	break;
135			case REG_SZ:
136	douglas	271	saveDir = data;
137	douglas	269	break;
138			default:
139			setSaveDir();
140			break;
141			}
142			}
143			else
144			{
145			setSaveDir();
146			}
147
148			RegCloseKey(key);
149			}
150			else
151			{
152			setScanDir();
153			setSaveDir();
154			}
155	douglas	271
156			if (debug) cerr << "scanDir = " << scanDir << "\n"
157	douglas	273	<< "saveDir = " << saveDir << "\n";
158	douglas	269	}
159
160			void ScanUtility::saveDirs(void)
161			{
162			HKEY key;
163
164			if (RegCreateKeyEx(HKEY_CURRENT_USER,
165			"Software\\DouglasThrift\\VTBFileUtil2", 0, NULL,
166	douglas	271	REG_OPTION_NON_VOLATILE, KEY_QUERY_VALUE \| KEY_SET_VALUE, NULL, &key,
167			NULL) == ERROR_SUCCESS)
168	douglas	269	{
169	douglas	271	DWORD type;
170			char data[MAX_PATH];
171			DWORD size = MAX_PATH;
172
173			if (RegQueryValueEx(key, "ScanDir", NULL, &type, LPBYTE(data), &size)
174			== ERROR_SUCCESS)
175	douglas	269	{
176	douglas	271	data[size - 1] = '\0';
177	douglas	269	}
178	douglas	271	else
179			{
180			data[0] = '\0';
181			}
182	douglas	269
183	douglas	273	if (scanDir != data \|\| type != REG_SZ)
184	douglas	269	{
185	douglas	273	if (RegSetValueEx(key, "ScanDir", 0, REG_SZ,
186			LPBYTE(scanDir.c_str()), scanDir.length() + 1) !=
187	douglas	271	ERROR_SUCCESS)
188			{
189			error();
190			}
191	douglas	269	}
192
193	douglas	271	size = MAX_PATH;
194
195			if (RegQueryValueEx(key, "SaveDir", NULL, &type, LPBYTE(data), &size)
196			== ERROR_SUCCESS)
197			{
198			data[size - 1] = '\0';
199			}
200			else
201			{
202			data[0] = '\0';
203			}
204
205	douglas	273	if (saveDir != data \|\| type != REG_SZ)
206	douglas	271	{
207	douglas	273	if (RegSetValueEx(key, "SaveDir", 0, REG_SZ,
208			LPBYTE(saveDir.c_str()), saveDir.length() + 1) !=
209	douglas	271	ERROR_SUCCESS)
210			{
211			error();
212			}
213			}
214
215	douglas	269	RegCloseKey(key);
216			}
217			else
218			{
219			error();
220			}
221			}
222
223			void ScanUtility::setScanDir(HWND parent)
224			{
225	douglas	271	BROWSEINFO info;
226	douglas	269
227	douglas	271	info.hwndOwner = parent;
228			info.pidlRoot = NULL;
229			info.pszDisplayName = NULL;
230			info.lpszTitle = "Select the Scan Directory";
231			info.ulFlags = BIF_RETURNONLYFSDIRS \| BIF_STATUSTEXT;
232			info.lpfn = browse;
233			info.lParam = MAKELPARAM(number, true);
234			info.iImage = 0;
235
236			do
237			{
238			LPITEMIDLIST id = SHBrowseForFolder(&info);
239
240			if (id != NULL)
241			{
242			char folder[MAX_PATH];
243
244			if (SHGetPathFromIDList(id, folder))
245			{
246			scanDir = folder;
247			}
248			}
249
250			LPMALLOC destruct;
251
252			SHGetMalloc(&destruct);
253			destruct->Free(id);
254			destruct->Release();
255
256			if (scanDir == "")
257			{
258			switch (MessageBox(parent, "Scan Directory needs to be selected.",
259			programName.c_str(), MB_ABORTRETRYIGNORE \| MB_ICONERROR))
260			{
261			case IDABORT:
262			exit(1);
263			break;
264			case IDRETRY:
265			break;
266			case IDIGNORE:
267			Beep(2200, 250);
268			Beep(1100, 500);
269			Beep(3300, 250);
270			exit(2);
271			break;
272			}
273			}
274			}
275			while (scanDir == "");
276	douglas	273
277			if (debug) cerr << "scanDir = " << scanDir << "\n";
278	douglas	269	}
279
280			void ScanUtility::setSaveDir(HWND parent)
281			{
282	douglas	271	BROWSEINFO info;
283	douglas	269
284	douglas	271	info.hwndOwner = parent;
285			info.pidlRoot = NULL;
286			info.pszDisplayName = NULL;
287			info.lpszTitle = "Select the Save Directory";
288			info.ulFlags = BIF_RETURNONLYFSDIRS \| BIF_STATUSTEXT;
289			info.lpfn = browse;
290			info.lParam = MAKELPARAM(number, false);
291			info.iImage = 0;
292
293			do
294			{
295			LPITEMIDLIST id = SHBrowseForFolder(&info);
296
297			if (id != NULL)
298			{
299			char folder[MAX_PATH];
300
301			if (SHGetPathFromIDList(id, folder))
302			{
303			saveDir = folder;
304			}
305			}
306
307			LPMALLOC destruct;
308
309			SHGetMalloc(&destruct);
310			destruct->Free(id);
311			destruct->Release();
312
313			if (saveDir == "")
314			{
315			switch (MessageBox(parent, "Scan Directory needs to be selected.",
316			programName.c_str(), MB_ABORTRETRYIGNORE \| MB_ICONERROR))
317			{
318			case IDABORT:
319			exit(1);
320			break;
321			case IDRETRY:
322			break;
323			case IDIGNORE:
324			Beep(2200, 250);
325			Beep(1100, 500);
326			Beep(3300, 250);
327			exit(2);
328			break;
329			}
330			}
331			}
332			while (saveDir == "");
333	douglas	273
334			if (debug) cerr << "saveDir = " << saveDir << "\n";
335	douglas	269	}
336
337	douglas	273	void ScanUtility::populate(HWND parent)
338			{
339			set<string> scans;
340
341			do
342			{
343			string scan = scanDir + "\\SCAN????_000." +
344			IndividualClient::getExtension();
345			WIN32_FIND_DATA found;
346			HANDLE finder = FindFirstFile(scan.c_str(), &found);
347
348			if (finder != INVALID_HANDLE_VALUE)
349			{
350			do
351			{
352			scans.insert(found.cFileName);
353			}
354			while (FindNextFile(finder, &found));
355
356			FindClose(finder);
357			}
358
359			if (scans.empty())
360			{
361			if (MessageBox(parent, "No scanned documents found.",
362			programName.c_str(), MB_RETRYCANCEL \| MB_ICONQUESTION) ==
363			IDCANCEL) break;
364			}
365			}
366			while (scans.empty());
367
368			if (scans.empty())
369			{
370			PropSheet_PressButton(GetParent(parent), PSBTN_BACK);
371			}
372			else
373			{
374			SHFILEINFO info;
375			HIMAGELIST icons = HIMAGELIST(SHGetFileInfo((*scans.begin()).c_str(),
376			0, &info, sizeof(info), SHGFI_SMALLICON \| SHGFI_SYSICONINDEX));
377
378			ListView_SetImageList(GetDlgItem(parent, IDC_SELECT_SCANS), icons,
379			LVSIL_SMALL);
380
381			int index = 0;
382
383			if (debug) cerr << "scans = {\n";
384
385			for (set<string>::iterator itor = scans.begin(); itor != scans.end();
386			itor++)
387			{
388			if (debug) cerr << " " << *itor << "\n";
389
390			char scan[MAX_PATH];
391
392			sprintf(scan, "%s", (*itor).c_str());
393
394			LVITEM item;
395
396			item.mask = LVIF_IMAGE \| LVIF_TEXT;
397			item.iItem = index++;
398			item.iSubItem = 0;
399			item.state = LVIS_SELECTED;
400			item.stateMask = LVIS_SELECTED;
401			item.pszText = scan;
402			item.iImage = info.iIcon;
403
404			ListView_InsertItem(GetDlgItem(parent, IDC_SELECT_SCANS), &item);
405			}
406
407			if (debug) cerr << "}\n";
408			}
409			}
410
411	douglas	271	int ScanUtility::browse(HWND dialog, UINT msg, LPARAM l, LPARAM d)
412			{
413			map<unsigned, ScanUtility*>::iterator itor = utilities.find(LOWORD(d));
414			ScanUtility* data = itor->second;
415
416			switch (msg)
417			{
418			case BFFM_INITIALIZED:
419			center(dialog);
420			SendMessage(dialog, BFFM_SETOKTEXT, 0,
421			LPARAM(toWide("&Select").c_str()));
422			SendMessage(dialog, BFFM_SETEXPANDED, FALSE, CSIDL_DRIVES);
423	douglas	273	SendMessage(dialog, BFFM_SETSELECTION, TRUE, LPARAM(HIWORD(d) ?
424			data->scanDir.c_str() : data->saveDir.c_str()));
425	douglas	271	break;
426			case BFFM_SELCHANGED:
427			{
428			IShellFolder* object;
429
430			SHGetDesktopFolder(&object);
431
432			STRRET thing;
433			char* folder;
434
435			object->GetDisplayNameOf(LPCITEMIDLIST(l), SHGDN_FORPARSING,
436			&thing);
437			StrRetToStr(&thing, LPCITEMIDLIST(l), &folder);
438			SendMessage(dialog, BFFM_SETSTATUSTEXT, 0, LPARAM(folder));
439
440			if (PathIsUNCServer(folder))
441			{
442			SendMessage(dialog, BFFM_ENABLEOK, 0, 0);
443			}
444
445			CoTaskMemFree(folder);
446			object->Release();
447			}
448			break;
449			}
450
451			return 0;
452			}
453
454	douglas	268	INT_PTR ScanUtility::start(HWND dialog, UINT msg, WPARAM w, LPARAM l)
455			{
456			map<HWND, ScanUtility*>::iterator itor = windows.find(dialog);
457			ScanUtility* data = itor->second;
458
459			switch (msg)
460	douglas	265	{
461	douglas	268	case WM_INITDIALOG:
462	douglas	269	center(GetParent(dialog));
463	douglas	268	{
464	douglas	271	LPPROPSHEETPAGE page = LPPROPSHEETPAGE(l);
465			map<unsigned, ScanUtility*>::iterator itor =
466			utilities.find(page->lParam);
467	douglas	265
468	douglas	268	windows.insert(pair<HWND, ScanUtility*>(dialog, itor->second));
469			}
470	douglas	273	{
471			ostringstream instructions;
472
473			instructions << "1.\tIf you need instructions, you should not be r"
474			<< "unning this program\n\tin Scan Utility mode.\n"
475			<< "2.\tOtherwise, go forth and scan.\n"
476			<< "3.\tThen come back and click Next.\n";
477
478			SetDlgItemText(dialog, IDC_START_INSTRUCTIONS,
479			instructions.str().c_str());
480			}
481	douglas	268	break;
482	douglas	269	case WM_NOTIFY:
483			{
484	douglas	273	LPNMHDR nm = LPNMHDR(l);
485	douglas	269
486			switch (nm->code)
487			{
488			case PSN_SETACTIVE:
489			PropSheet_SetWizButtons(GetParent(dialog), PSWIZB_NEXT);
490	douglas	271	{
491			char folder[44];
492
493			PathCompactPathEx(folder, data->scanDir.c_str(), 44, 0);
494			SetDlgItemText(dialog, IDC_START_SCAN_TEXT, folder);
495			PathCompactPathEx(folder, data->saveDir.c_str(), 44, 0);
496			SetDlgItemText(dialog, IDC_START_SAVE_TEXT, folder);
497			}
498	douglas	269	break;
499	douglas	273	case PSN_WIZNEXT:
500			SetCurrentDirectory(data->scanDir.c_str());
501			break;
502	douglas	269	}
503			}
504			break;
505	douglas	271	case WM_COMMAND:
506			switch (LOWORD(w))
507			{
508			case IDC_START_SCAN_BROWSE:
509			data->setScanDir(dialog);
510			{
511			char folder[44];
512
513			PathCompactPathEx(folder, data->scanDir.c_str(), 44, 0);
514			SetDlgItemText(dialog, IDC_START_SCAN_TEXT, folder);
515			}
516			break;
517			case IDC_START_SAVE_BROWSE:
518			data->setSaveDir(dialog);
519			{
520			char folder[44];
521
522			PathCompactPathEx(folder, data->saveDir.c_str(), 44, 0);
523			SetDlgItemText(dialog, IDC_START_SAVE_TEXT, folder);
524			}
525			break;
526			}
527			break;
528	douglas	268	}
529	douglas	265
530	douglas	268	return FALSE;
531	douglas	265	}
532	douglas	273
533			INT_PTR ScanUtility::select(HWND dialog, UINT msg, WPARAM w, LPARAM l)
534			{
535			map<HWND, ScanUtility*>::iterator itor = windows.find(dialog);
536			ScanUtility* data = itor->second;
537
538			switch (msg)
539			{
540			case WM_INITDIALOG:
541			{
542			LPPROPSHEETPAGE page = LPPROPSHEETPAGE(l);
543			map<unsigned, ScanUtility*>::iterator itor =
544			utilities.find(page->lParam);
545
546			windows.insert(pair<HWND, ScanUtility*>(dialog, itor->second));
547			}
548			{
549			LVCOLUMN column;
550
551			column.mask = LVCF_FMT \| LVCF_TEXT \| LVCF_WIDTH;
552			column.fmt = LVCFMT_IMAGE;
553			column.cx = 120;
554			column.pszText = "Scanned Documents";
555
556			ListView_InsertColumn(GetDlgItem(dialog, IDC_SELECT_SCANS), 0,
557			&column);
558			}
559			break;
560			case WM_NOTIFY:
561			if (w == IDC_SELECT_SCANS)
562			{
563			switch (ListView_GetSelectedCount(GetDlgItem(dialog,
564			IDC_SELECT_SCANS)))
565			{
566			case 1:
567			PropSheet_SetWizButtons(GetParent(dialog), PSWIZB_BACK \|
568			PSWIZB_NEXT);
569			break;
570			default:
571			PropSheet_SetWizButtons(GetParent(dialog), PSWIZB_BACK);
572			break;
573			}
574			}
575			else
576			{
577			LPNMHDR nm = LPNMHDR(l);
578
579			switch (nm->code)
580			{
581			case PSN_SETACTIVE:
582			PropSheet_SetWizButtons(GetParent(dialog), PSWIZB_BACK);
583			data->populate(dialog);
584			break;
585			case PSN_WIZBACK:
586			ListView_DeleteAllItems(GetDlgItem(dialog, IDC_SELECT_SCANS));
587			break;
588			case PSN_WIZNEXT:
589			//
590			ListView_DeleteAllItems(GetDlgItem(dialog, IDC_SELECT_SCANS));
591			break;
592			}
593			}
594			break;
595			case WM_COMMAND:
596			break;
597			}
598
599			return FALSE;
600			}