Context Navigation

source: trunk/dll/avl.c@ 1556

Visit:

Last change on this file since 1556 was 1556, checked in by Gregg Young, 15 years ago
Check if archiver.bb2 has been changed on disk before editing (ticket 441)
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 35.9 KB

Line
1
2	/***********************************************************************
3
4	$Id: avl.c 1556 2010-11-21 23:17:01Z gyoung $
5
6	archiver.bb2 search, load, save and date parse
7
8	Copyright (c) 1993, 1998 M. Kimes
9	Copyright (c) 2004, 2008 Steven H.Levine
10
11	01 Aug 04 SHL Rework lstrip/rstrip usage
12	13 Aug 05 SHL Beautify with indent
13	13 Aug 05 SHL find_type: correct no sig exists bypass logic
14	13 Aug 05 SHL SBoxDlgProc: avoid dereferencing NULL signature
15	18 Aug 05 SHL Comments
16	31 Dec 05 SHL indent -i2
17	08 Dec 05 SHL load_archivers: allow empty startlist
18	30 Dec 05 SHL load_archivers: use get_archiver_line?(), clean nits
19	29 May 06 SHL SBoxDlgProc: support move, add, delete
20	30 May 06 SHL load_archivers: add reload support
21	16 Jun 06 SHL load_archivers: support signatures containing 0s
22	26 Jun 06 SHL load_archivers: remember where comments are
23	14 Jul 06 SHL Use Runtime_Error
24	29 Jul 06 SHL Use xfgets, xfgets_bstripcr
25	15 Aug 06 SHL Use Runtime_Error more
26	01 Nov 06 SHL Turn off leftover debug code
27	06 Apr 07 GKY Work around PM DragInfo and DrgFreeDISH limit
28	19 Apr 07 SHL Use FreeDragInfoData
29	19 Apr 07 SHL Add more drag/drop error checking
30	20 Aug 07 GKY Move #pragma alloc_text to end for OpenWatcom compat
31	25 Aug 07 SHL load_archivers: add missing close on error path
32	29 Feb 08 GKY Use xfree where appropriate
33	22 Jun 08 GKY Added free_archivers for fortify checking
34	19 Jul 08 GKY ifdef Fortify free_archivers
35	29 Nov 08 GKY Add ini entry for LastArchiver so the previous archiver is selected in the
36	Select archive dialog if no default is provided.
37	29 Nov 08 GKY Remove or replace with a mutex semaphore DosEnterCriSec where appropriate.
38	11 Jan 08 GKY Replace "ARCHIVER.BB2" in string file with global set at compile in init.c
39	08 Mar 09 GKY Additional strings move to PCSZs in init.c
40	23 Oct 10 GKY Changes to populate and utilize a HELPTABLE for context specific help
41
42	***********************************************************************/
43
44	#include <stdlib.h>
45	#include <string.h>
46	#include <ctype.h>
47	#include <share.h>
48	#include <sys/stat.h>
49
50	#define INCL_DOS
51	#define INCL_WIN
52	#define INCL_WINSTDDRAG
53	#define INCL_LONGLONG
54
55	#include "fm3dll.h"
56	#include "fm3dll2.h" // #define's for UM_*, control id's, etc.
57	#include "notebook.h" // Data declaration(s)
58	#include "init.h" // Data declaration(s)
59	#include "valid.h" // Data declaration(s)
60	#include "mainwnd.h" // Data declaration(s)
61	#include "fm3dlg.h"
62	#include "fm3str.h"
63	#include "avl.h"
64	#include "strutil.h" // GetPString
65	#include "errutil.h" // Runtime_Error
66	#include "avv.h" // ArcReviewDlgProc, rewrite_archiverbb2
67	#include "droplist.h" // DropHelp, FullDrgName
68	#include "misc.h" // DrawTargetEmphasis
69	#include "draglist.h" // FreeDragInfoData
70	#include "chklist.h" // PosOverOkay
71	#include "literal.h" // literal
72	#include "wrappers.h" // xfgets
73	#include "strips.h" // bstrip
74	#include "srchpath.h" // searchpath
75	#include "stristr.h" // stristr
76	#include "delims.h" // to_delim
77	#include "fortify.h"
78
79	// Data definitions
80	static PSZ pszSrcFile = __FILE__;
81	static void fill_listbox(HWND hwnd, BOOL fShowAll, SHORT sOldSelect);
82
83	#pragma data_seg(GLOBAL1)
84	ARC_TYPE *arcsighead;
85	UINT arcsigs_header_lines; // Header comments line count in archiver.bb2
86	UINT arcsigs_trailer_line_num; // Trailer comments start line number (1..n)
87	BOOL arcsigsloaded;
88	BOOL arcsigsmodified;
89	static struct stat Archiverbb2Stats;
90
91	#define ARCHIVER_LINE_BYTES 256
92
93	//=== quick_find_type() ===
94	ARC_TYPE quick_find_type(CHAR filespec, ARC_TYPE * topsig)
95	{
96	ARC_TYPE info, found = NULL;
97	CHAR *p;
98
99	if (!arcsigsloaded)
100	load_archivers();
101	p = strrchr(filespec, '.');
102	if (p) {
103	p++;
104	info = (topsig) ? topsig : arcsighead;
105	while (info) {
106	if (info->ext && *(info->ext) && !stricmp(p, info->ext)) {
107	found = find_type(filespec, topsig);
108	break;
109	}
110	info = info->next;
111	}
112	}
113	return found;
114	}
115
116	//=== fill_listbox() fill or refill listbox from current archiver definitions ===
117
118	static VOID fill_listbox(HWND hwnd, BOOL fShowAll, SHORT sOldSelect)
119	{
120	ARC_TYPE *pat;
121	BOOL found = FALSE;
122	SHORT sSelect;
123
124	WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_DELETEALL, MPVOID, MPVOID);
125
126	for (pat = arcsighead; pat; pat = pat->next) {
127	/*
128	* this inner loop tests for a dup signature entry and assures
129	* that only the entry at the top of the list gets used for
130	* conversion; editing any is okay
131	*/
132	if (!fShowAll) {
133	ARC_TYPE *pat2;
134	BOOL isDup = FALSE;
135
136	for (pat2 = arcsighead;
137	pat2 && pat->siglen && pat2 != pat && !isDup; pat2 = pat2->next) {
138	isDup = pat2->siglen == pat->siglen &&
139	!memcmp(pat2->signature, pat->signature, pat->siglen);
140	} // for
141	if (isDup)
142	continue;
143	}
144
145	// If caller is editing archivers or entry useful to caller, show in listbox
146	if (fShowAll \|\| (pat->id && pat->extract && pat->create)) {
147	sSelect = (SHORT) WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_INSERTITEM,
148	MPFROM2SHORT(LIT_END, 0),
149	MPFROMP(pat->id ? pat->id : "?"));
150	if (!found && *szDefArc && pat->id && !strcmp(szDefArc, pat->id)) {
151	// Highlight default
152	WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_SELECTITEM,
153	MPFROMSHORT(sSelect), MPFROMSHORT(TRUE));
154	found = TRUE;
155	}
156	}
157	else {
158	// Complain about odd entry
159	if (!pat->id \|\| !*pat->id) {
160	WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_INSERTITEM,
161	MPFROM2SHORT(LIT_END, 0),
162	MPFROMP(GetPString(IDS_UNKNOWNUNUSABLETEXT)));
163	}
164	else {
165	CHAR s[81];
166
167	sprintf(s, "%0.12s %s", pat->id, GetPString(IDS_UNUSABLETEXT));
168	WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_INSERTITEM,
169	MPFROM2SHORT(LIT_END, 0), MPFROMP(s));
170	}
171	}
172	} // while scanning
173
174	// Try to reselect last selection unless user wants default selection
175	if (sOldSelect == LIT_NONE) {
176	ULONG size = sizeof(SHORT);
177
178	PrfQueryProfileData(fmprof, appname, "LastArchiver", &sOldSelect, &size);
179	}
180	if (sOldSelect != LIT_NONE && !found) {
181	SHORT sItemCount =
182	(SHORT) WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_QUERYITEMCOUNT,
183	MPVOID, MPVOID);
184
185	if (sOldSelect >= sItemCount)
186	sOldSelect = sItemCount - 1;
187	if (sOldSelect >= 0) {
188	WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_SELECTITEM,
189	MPFROMSHORT(sOldSelect), MPFROMSHORT(TRUE));
190	}
191	}
192
193	if (found)
194	PosOverOkay(hwnd);
195	}
196
197	ARC_TYPE find_type(CHAR filespec, ARC_TYPE * topsig)
198	{
199	HFILE handle;
200	ULONG action;
201	ULONG len;
202	ULONG l;
203	ARC_TYPE *info;
204	CHAR *p;
205	CHAR buffer[4096]; // 06 Oct 07 SHL Protect against NTFS defect
206
207	if (!arcsigsloaded)
208	load_archivers();
209	if (!topsig)
210	topsig = arcsighead;
211	DosError(FERR_DISABLEHARDERR);
212	if (DosOpen(filespec,
213	&handle,
214	&action,
215	0,
216	0,
217	OPEN_ACTION_FAIL_IF_NEW \|
218	OPEN_ACTION_OPEN_IF_EXISTS,
219	OPEN_FLAGS_FAIL_ON_ERROR \|
220	OPEN_FLAGS_NOINHERIT \|
221	OPEN_FLAGS_RANDOMSEQUENTIAL \|
222	OPEN_SHARE_DENYNONE \| OPEN_ACCESS_READONLY, 0))
223	return NULL;
224	// Scan signatures
225	for (info = topsig; info; info = info->next) {
226	if (info->siglen == 0) {
227	// No signature -- check extension
228	p = strrchr(filespec, '.');
229	if (p) {
230	p++;
231	if (info->ext && *(info->ext) && !stricmp(p, info->ext))
232	break; // Matched
233
234	}
235	continue; // Next sig
236
237	}
238	// Try signature match
239	l = info->siglen;
240	l = min(l, 79);
241	if (!DosChgFilePtr(handle,
242	abs(info->file_offset),
243	(info->file_offset >= 0) ?
244	FILE_BEGIN : FILE_END, &len)) {
245	if (!DosRead(handle, buffer, l, &len) && len == l) {
246	if (!memcmp(info->signature, buffer, l))
247	break; // Matched
248
249	}
250	}
251	} // for
252
253	DosClose(handle); /* Either way, we're done for now */
254	return info; /* Return signature, if any */
255	}
256
257	# ifdef FORTIFY
258
259	VOID free_archivers(VOID)
260	{
261	ARC_TYPE pat, next;
262
263	pat = arcsighead;
264	while (pat) {
265	next = pat->next;
266	xfree(pat->id, pszSrcFile, __LINE__);
267	xfree(pat->ext, pszSrcFile, __LINE__);
268	xfree(pat->list, pszSrcFile, __LINE__);
269	xfree(pat->extract, pszSrcFile, __LINE__);
270	xfree(pat->create, pszSrcFile, __LINE__);
271	xfree(pat->move, pszSrcFile, __LINE__);
272	xfree(pat->delete, pszSrcFile, __LINE__);
273	xfree(pat->signature, pszSrcFile, __LINE__);
274	xfree(pat->startlist, pszSrcFile, __LINE__);
275	xfree(pat->endlist, pszSrcFile, __LINE__);
276	xfree(pat->exwdirs, pszSrcFile, __LINE__);
277	xfree(pat->test, pszSrcFile, __LINE__);
278	xfree(pat->createrecurse, pszSrcFile, __LINE__);
279	xfree(pat->createwdirs, pszSrcFile, __LINE__);
280	xfree(pat->movewdirs, pszSrcFile, __LINE__);
281	xfree(pat, pszSrcFile, __LINE__);
282	pat = next;
283	}
284	arcsighead = NULL;
285	}
286
287	//=== free_arc_type() free allocated ARC_TYPE ===
288
289	# endif
290
291	VOID free_arc_type(ARC_TYPE * pat)
292	{
293	if (pat) {
294	xfree(pat->id, pszSrcFile, __LINE__);
295	xfree(pat->ext, pszSrcFile, __LINE__);
296	xfree(pat->list, pszSrcFile, __LINE__);
297	xfree(pat->extract, pszSrcFile, __LINE__);
298	xfree(pat->create, pszSrcFile, __LINE__);
299	xfree(pat->move, pszSrcFile, __LINE__);
300	xfree(pat->delete, pszSrcFile, __LINE__);
301	xfree(pat->signature, pszSrcFile, __LINE__);
302	xfree(pat->startlist, pszSrcFile, __LINE__);
303	xfree(pat->endlist, pszSrcFile, __LINE__);
304	xfree(pat->exwdirs, pszSrcFile, __LINE__);
305	xfree(pat->test, pszSrcFile, __LINE__);
306	xfree(pat->createrecurse, pszSrcFile, __LINE__);
307	xfree(pat->createwdirs, pszSrcFile, __LINE__);
308	xfree(pat->movewdirs, pszSrcFile, __LINE__);
309	free(pat);
310	}
311	}
312
313	static UINT cur_line_num; // Input file line counter
314
315	//=== get_line_strip_comments() read line, strip comments and whitespace ===
316
317	static PSZ get_line_strip_comments(PSZ pszIn, FILE * fp)
318	{
319	PSZ psz = xfgets(pszIn, ARCHIVER_LINE_BYTES, fp, pszSrcFile, __LINE__);
320	PSZ psz2;
321
322	if (psz) {
323	cur_line_num++;
324	psz2 = strchr(pszIn, ';');
325	if (psz2)
326	*psz2 = 0; // Chop comment
327	bstripcr(pszIn); // Strip leading white and trailing white and CR/LF
328
329	}
330	return psz;
331	}
332
333	//=== get_line_strip_white() read line, strip whitespace ===
334
335	static PSZ get_line_strip_white(PSZ pszIn, FILE * fp)
336	{
337	PSZ psz =
338	xfgets_bstripcr(pszIn, ARCHIVER_LINE_BYTES, fp, pszSrcFile, __LINE__);
339
340	if (psz)
341	cur_line_num++;
342
343	return psz;
344	}
345
346	//=== load_archivers() load or reload archive definitions from archiver.bb2 ===
347
348	INT load_archivers(VOID)
349	{
350	FILE *fp;
351	CHAR sz[ARCHIVER_LINE_BYTES + 1];
352	CHAR *psz;
353	ARC_TYPE *pat = NULL;
354	ARC_TYPE *patLast = NULL;
355	UINT lines_per_arcsig = LINES_PER_ARCSIG;
356	UINT per_sig_comment_line_num = 0;
357	INT i;
358	CHAR *moder = "r";
359
360	// Free current signatures
361	if (arcsighead) {
362	for (pat = arcsighead; pat;) {
363	patLast = pat;
364	pat = pat->next;
365	free_arc_type(patLast);
366	}
367	arcsighead = NULL;
368	}
369
370	arcsigsmodified = FALSE;
371	arcsigs_header_lines = 0;
372	arcsigs_trailer_line_num = 0;
373
374	//DosEnterCritSec(); //GKY 11-29-08
375	DosRequestMutexSem(hmtxFM2Globals, SEM_INDEFINITE_WAIT);
376	psz = searchpath(PCSZ_ARCHIVERBB2);
377	if (!psz \|\| !*psz) {
378	DosReleaseMutexSem(hmtxFM2Globals);
379	//DosExitCritSec();
380	return -1;
381	}
382	stat(psz, &Archiverbb2Stats);
383	fp = xfsopen(psz, moder, SH_DENYWR, pszSrcFile, __LINE__, TRUE);
384	DosReleaseMutexSem(hmtxFM2Globals);
385	//DosExitCritSec();
386	if (!fp)
387	return -2;
388	strcpy(archiverbb2, psz); // Remember full path
389
390	cur_line_num = 0;
391
392	// Line 1 must contain number of lines per signature definition
393	if (!get_line_strip_comments(sz, fp)) {
394	fclose(fp);
395	return -3;
396	}
397	if (*sz)
398	lines_per_arcsig = atoi(sz);
399	if (!*sz \|\| lines_per_arcsig < LINES_PER_ARCSIG) {
400	fclose(fp); // 25 Aug 07 SHL
401	return -3;
402	}
403
404	// Parse rest of file
405	// 1st non-blank line starts definition
406	// Need to determine header size and start of trailer
407
408	while (!feof(fp)) {
409	// If reading header
410	if (!arcsigs_header_lines) {
411	// Reading header - find header size and start of signtures
412	if (!get_line_strip_white(sz, fp))
413	break; // Unexpected EOF
414	if (stristr(sz, "-- Current Archivers --")) {
415	arcsigs_header_lines = cur_line_num;
416	continue;
417	}
418	if (!sz \|\| sz == ';')
419	continue; // Header comment or blank line
420	else {
421	// Not a comment, must be start of signatures
422	PSZ psz2 = strchr(sz, ';');
423
424	if (psz2) {
425	*psz2 = 0; // Chop trailing comment
426	bstripcr(sz); // Strip leading white and trailing white and CR/LF
427	}
428	arcsigs_header_lines = cur_line_num - 1;
429	}
430	}
431	else {
432	// Reading defintiions
433	if (!get_line_strip_comments(sz, fp))
434	break; // EOF
435	}
436
437	// fixme to avoid allocating empty fields
438
439	// Remember start of per sig comments for next definition
440	if (per_sig_comment_line_num == 0)
441	per_sig_comment_line_num = cur_line_num;
442
443	if (*sz) {
444	// At start of defintion
445
446	pat = xmallocz(sizeof(ARC_TYPE), pszSrcFile, __LINE__);
447	if (!pat)
448	break;
449	pat->id = xstrdup(sz, pszSrcFile, __LINE__);
450
451	pat->comment_line_num = per_sig_comment_line_num;
452	pat->defn_line_num = cur_line_num;
453
454	if (!get_line_strip_comments(sz, fp)) // line 2 - extension
455	break;
456	if (*sz)
457	pat->ext = xstrdup(sz, pszSrcFile, __LINE__);
458	else
459	pat->ext = NULL;
460	if (!get_line_strip_comments(sz, fp)) // line 3 - offset to signature
461	break;
462	pat->file_offset = atol(sz);
463	if (!get_line_strip_comments(sz, fp)) // line 4 - list command
464	break;
465	if (*sz)
466	pat->list = xstrdup(sz, pszSrcFile, __LINE__);
467	else
468	pat->list = NULL;
469	if (!pat->list)
470	break; // Must have list command - fixme to complain
471	if (!get_line_strip_comments(sz, fp)) // line 5
472	break;
473	if (*sz)
474	pat->extract = xstrdup(sz, pszSrcFile, __LINE__);
475	else
476	pat->extract = NULL;
477	if (!get_line_strip_comments(sz, fp)) // line 6
478	break;
479	if (*sz)
480	pat->exwdirs = xstrdup(sz, pszSrcFile, __LINE__);
481	else
482	pat->exwdirs = NULL;
483	if (!get_line_strip_comments(sz, fp)) // line 7
484	break;
485	if (*sz)
486	pat->test = xstrdup(sz, pszSrcFile, __LINE__);
487	else
488	pat->test = NULL;
489	if (!get_line_strip_comments(sz, fp)) // line 8
490	break;
491	if (*sz)
492	pat->create = xstrdup(sz, pszSrcFile, __LINE__);
493	else
494	pat->create = NULL;
495	if (!get_line_strip_comments(sz, fp)) // line 9
496	break;
497	if (*sz)
498	pat->createwdirs = xstrdup(sz, pszSrcFile, __LINE__);
499	else
500	pat->createwdirs = NULL;
501	if (!get_line_strip_comments(sz, fp)) // line 10
502	break;
503	if (*sz)
504	pat->createrecurse = xstrdup(sz, pszSrcFile, __LINE__);
505	else
506	pat->createrecurse = NULL;
507	if (!get_line_strip_comments(sz, fp)) // line 11
508	break;
509	if (*sz)
510	pat->move = xstrdup(sz, pszSrcFile, __LINE__);
511	else
512	pat->move = NULL;
513	if (!get_line_strip_comments(sz, fp)) // line 12
514	break;
515	if (*sz)
516	pat->movewdirs = xstrdup(sz, pszSrcFile, __LINE__);
517	else
518	pat->movewdirs = NULL;
519	if (!get_line_strip_comments(sz, fp)) // line 13
520	break;
521	if (*sz)
522	pat->delete = xstrdup(sz, pszSrcFile, __LINE__);
523	else
524	pat->delete = NULL;
525	if (!get_line_strip_white(sz, fp)) // line 14
526	break;
527	i = literal(sz); // Translate \ escapes
528	if (i) {
529	pat->siglen = i;
530	pat->signature = xmalloc(i, pszSrcFile, __LINE__);
531	if (!pat->signature)
532	break;
533	memcpy(pat->signature, sz, i); // signature may not be a string
534	}
535	else {
536	pat->siglen = 0;
537	pat->signature = NULL;
538	}
539	if (!get_line_strip_white(sz, fp)) // line 15
540	break;
541	if (*sz)
542	pat->startlist = xstrdup(sz, pszSrcFile, __LINE__);
543	else
544	pat->startlist = NULL;
545	if (!get_line_strip_white(sz, fp)) // line 16
546	break;
547	if (*sz)
548	pat->endlist = xstrdup(sz, pszSrcFile, __LINE__);
549	else
550	pat->endlist = NULL;
551	if (!get_line_strip_comments(sz, fp)) // line 17
552	break;
553	pat->osizepos = atoi(sz);
554	if (!get_line_strip_comments(sz, fp)) // line 18
555	break;
556	pat->nsizepos = atoi(sz);
557	if (!get_line_strip_comments(sz, fp)) // line 19
558	break;
559	pat->fdpos = atoi(sz);
560	psz = strchr(sz, ',');
561	if (psz) {
562	psz++;
563	pat->datetype = atoi(psz);
564	}
565	if (!get_line_strip_comments(sz, fp)) // line 20
566	break;
567	pat->fdflds = atoi(sz);
568	if (!get_line_strip_comments(sz, fp)) // line 21
569	break;
570	pat->fnpos = atoi(sz);
571	psz = strchr(sz, ',');
572	if (psz) {
573	psz++;
574	pat->nameislast = (BOOL) (*psz && atol(psz) == 0) ? FALSE : TRUE;
575	psz = strchr(psz, ',');
576	if (psz) {
577	psz++;
578	pat->nameisnext = (BOOL) (*psz && atol(psz) == 0) ? FALSE : TRUE;
579	psz = strchr(psz, ',');
580	if (psz) {
581	psz++;
582	pat->nameisfirst = (BOOL) (*psz && atol(psz) == 0) ? FALSE : TRUE;
583	}
584	}
585	}
586	// Ignore unknown lines - must be newer file format
587	for (i = LINES_PER_ARCSIG; i < lines_per_arcsig; i++) {
588	if (!get_line_strip_comments(sz, fp))
589	break; // Unexpected EOF - fixme to complain
590	}
591
592	// Add to list, assume next and prev already NULL
593	if (!arcsighead)
594	arcsighead = patLast = pat;
595	else {
596	patLast->next = pat;
597	pat->prev = patLast;
598	patLast = pat;
599	}
600	pat = NULL; // Done with this defintion
601
602	arcsigs_trailer_line_num = cur_line_num + 1; // In case this is last defintion
603	per_sig_comment_line_num = 0;
604	} // if got definition
605
606	} // while more lines
607
608	fclose(fp);
609
610	free_arc_type(pat); // In case partial definition in progress
611
612	if (!arcsighead)
613	return -4;
614
615	arcsigsloaded = TRUE;
616
617	return 0;
618	}
619
620	#define TEST_DRAG 0 // fixme to be gone or to work
621
622	static MRESULT EXPENTRY SDlgListboxSubclassProc(HWND hwnd, ULONG msg,
623	MPARAM mp1, MPARAM mp2)
624	{
625	PFNWP pfnOldProc = (PFNWP) WinQueryWindowPtr(hwnd, QWL_USER);
626
627	PDRAGITEM pDItem;
628	PDRAGINFO pDInfo;
629	BOOL ok;
630
631	static BOOL emphasized = FALSE;
632	static PSZ DRMDRF_LBOX = "<DRM_LBOX,DRF_UNKNOWN>";
633	static PSZ DRM_LBOX = "DRM_LBOX";
634
635	switch (msg) {
636	case WM_BEGINDRAG:
637	{
638	LONG cur_ndx;
639	DRAGITEM ditem;
640	DRAGIMAGE dimage;
641	HWND hwndDrop;
642
643	// fprintf(stderr, "SDlgListboxSubclassProc: BEGINDRAG\n");
644	cur_ndx = WinQueryLboxSelectedItem(hwnd);
645
646	if (cur_ndx != LIT_NONE) {
647	pDInfo = DrgAllocDraginfo(1);
648	if (pDInfo) {
649	pDInfo->usOperation = DO_DEFAULT;
650	pDInfo->hwndSource = hwnd;
651
652	memset(&ditem, 0, sizeof(DRAGITEM));
653	ditem.hwndItem = hwnd;
654	ditem.ulItemID = 1;
655	ditem.hstrType = DrgAddStrHandle(DRT_UNKNOWN);
656	ditem.hstrRMF = DrgAddStrHandle(DRMDRF_LBOX);
657	ditem.hstrContainerName = DrgAddStrHandle(NullStr);
658	ditem.hstrSourceName = DrgAddStrHandle(NullStr);
659	ditem.hstrTargetName = DrgAddStrHandle(NullStr);
660	// ditem.fsControl = 0;
661	ditem.fsSupportedOps = DO_MOVEABLE;
662
663	memset(&dimage, 0, sizeof(DRAGIMAGE));
664	dimage.cb = sizeof(DRAGIMAGE);
665	dimage.hImage = hptrFile;
666	dimage.cptl = 0;
667	dimage.fl = DRG_ICON;
668	dimage.sizlStretch.cx = 32;
669	dimage.sizlStretch.cy = 32;
670	dimage.cxOffset = -16;
671	dimage.cyOffset = 0;
672	DrgSetDragitem(pDInfo, &ditem, sizeof(DRAGITEM), 0); /* Index of DRAGITEM */
673	hwndDrop = DrgDrag(hwnd, pDInfo, &dimage, 1, /* One DRAGIMAGE */
674	VK_ENDDRAG, NULL);
675	if (!hwndDrop)
676	Win_Error(hwnd, hwnd, pszSrcFile, __LINE__, "DrgDrag");
677
678	DrgFreeDraginfo(pDInfo);
679	// WinSetWindowPos(hwnd,HWND_TOP,0,0,0,0,SWP_ACTIVATE);
680	}
681	}
682	break;
683	}
684
685	case DM_DRAGOVER:
686	ok = FALSE;
687	if (!emphasized) {
688	POINTL ptl;
689	POINTL ptl2;
690
691	emphasized = TRUE;
692	ptl.x = SHORT1FROMMP(mp2);
693	ptl.y = SHORT2FROMMP(mp2);
694	ptl2 = ptl;
695	WinMapWindowPoints(HWND_DESKTOP, hwnd, &ptl2, 1);
696	// fprintf(stderr, "DRAGOVER mapped x y %d %d to %d %d\n", ptl.x, ptl.y, ptl2.x, ptl2.y);
697	WinPostMsg(hwnd, WM_BUTTON1CLICK,
698	MPFROM2SHORT((SHORT) ptl2.x, (SHORT) ptl2.y),
699	MPFROM2SHORT(HT_NORMAL, KC_NONE));
700	// fprintf(stderr, "DRAGOVER posted 0x%x WM_BUTTON1CLICK x y %d %d\n", hwnd, ptl2.x, ptl2.y);
701	}
702	pDInfo = (PDRAGINFO) mp1; /* Get DRAGINFO pointer */
703	if (pDInfo) {
704	if (!DrgAccessDraginfo(pDInfo)) {
705	Win_Error(HWND_DESKTOP, HWND_DESKTOP, pszSrcFile, __LINE__,
706	PCSZ_DRGACCESSDRAGINFO);
707	}
708	else {
709	pDItem = DrgQueryDragitemPtr(pDInfo, 0);
710	/* Check valid rendering mechanisms and data format */
711	ok = DrgVerifyRMF(pDItem, DRM_LBOX, NULL);
712	DrgFreeDraginfo(pDInfo);
713	}
714	}
715	return ok ? MRFROM2SHORT(DOR_DROP, DO_MOVE) :
716	MRFROM2SHORT(DOR_NEVERDROP, 0);
717
718	case DM_DRAGLEAVE:
719	if (emphasized) {
720	emphasized = FALSE;
721	// fixme to draw listbox item emphasized
722	// DrawTargetEmphasis(hwnd, emphasized);
723	// fprintf(stderr, "DRAGLEAVE\n");
724	fflush(stderr);
725	}
726	return 0;
727
728	case DM_DROPHELP:
729	DropHelp(mp1, mp2, hwnd, "fixme to give some help");
730	return 0;
731
732	case DM_DROP:
733	ok = FALSE;
734	if (emphasized) {
735	emphasized = FALSE;
736	// DrawTargetEmphasis(hwnd, emphasized);
737	}
738	pDInfo = (PDRAGINFO) mp1; /* Get DRAGINFO pointer */
739	if (pDInfo) {
740	if (!DrgAccessDraginfo(pDInfo)) {
741	Win_Error(HWND_DESKTOP, HWND_DESKTOP, pszSrcFile, __LINE__,
742	PCSZ_DRGACCESSDRAGINFO);
743	}
744	else {
745	pDItem = DrgQueryDragitemPtr(pDInfo, 0);
746	if (!pDItem)
747	Win_Error(hwnd, hwnd, pszSrcFile, __LINE__, "DM_DROP");
748	/* Check valid rendering mechanisms and data */
749	ok = DrgVerifyRMF(pDItem, DRM_LBOX, NULL)
750	&& ~pDItem->fsControl & DC_PREPARE;
751	if (ok) {
752	// ret = FullDrgName(pDItem,buffer,buflen);
753	/* note: targetfail is returned to source for all items */
754	DrgSendTransferMsg(pDInfo->hwndSource, DM_ENDCONVERSATION,
755	MPFROMLONG(pDItem->ulItemID),
756	MPFROMLONG(DMFL_TARGETSUCCESSFUL));
757	}
758	FreeDragInfoData(hwnd, pDInfo);
759	}
760	}
761	return 0;
762	} // switch
763	return pfnOldProc ? pfnOldProc(hwnd, msg, mp1, mp2) :
764	WinDefWindowProc(hwnd, msg, mp1, mp2);
765	}
766
767	//=== SBoxDlgProc() Select archiver to use or edit, supports list reorder too ===
768
769	static PSZ pszCantFindMsg = "Can't find item %d";
770
771	MRESULT EXPENTRY SBoxDlgProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
772	{
773	ARC_TYPE **ppatReturn; // Where to return selected archiver
774	ARC_TYPE *pat;
775	SHORT sSelect;
776	SHORT sItemCount;
777	CHAR szItemText[256];
778	CHAR szPCItemText[256]; // Parent or child item text
779	SHORT i;
780	BOOL fShowAll;
781
782	static SHORT sLastSelect = LIT_NONE;
783
784	switch (msg) {
785	case WM_INITDLG:
786	if (!arcsigsloaded)
787	load_archivers();
788	else {
789	struct stat Buffer;
790
791	stat(searchpath(PCSZ_ARCHIVERBB2), &Buffer);
792	if (Archiverbb2Stats.st_size != Buffer.st_size \|\|
793	Archiverbb2Stats.st_mtime != Buffer.st_mtime)
794	if (saymsg(MB_YESNO,
795	hwnd,
796	GetPString(IDS_ADCHANGESONDISKTEXT),
797	GetPString(IDS_ADRELOADMEMTEXT)) == MBID_YES)
798	load_archivers();
799	}
800	if (!(ARC_TYPE **) mp2) {
801	Runtime_Error(pszSrcFile, __LINE__, NULL);
802	WinDismissDlg(hwnd, 0);
803	break;
804	}
805	/* Passed arg points to where to return selected archiver definition
806	* On input arg value controls selection list content
807	* If non-NULL, dup names are suppressed
808	* If NULL, all definitions are shown
809	*/
810	ppatReturn = (ARC_TYPE **) mp2;
811	fShowAll = *ppatReturn == NULL;
812	if (*ppatReturn)
813	*ppatReturn = arcsighead; // Preset to first
814	WinSetWindowPtr(hwnd, QWL_USER, (PVOID) ppatReturn);
815	fill_listbox(hwnd, fShowAll, sLastSelect);
816
817	#ifdef TEST_DRAG // fixme
818	{
819	HWND hwnd2 = WinWindowFromID(hwnd, ASEL_LISTBOX);
820	PFNWP pfn = WinSubclassWindow(hwnd2,
821	SDlgListboxSubclassProc);
822
823	WinSetWindowPtr(hwnd2, QWL_USER, (PVOID) pfn);
824	}
825	#endif // TEST_DRAG fixme
826
827	break;
828
829	case WM_HELP:
830	if (hwndHelp)
831	WinSendMsg(hwndHelp,
832	HM_DISPLAY_HELP,
833	MPFROMSHORT(1), MPFROMSHORT(HM_RESOURCEID));
834	break;
835
836	case WM_COMMAND:
837	ppatReturn = (ARC_TYPE **) WinQueryWindowPtr(hwnd, QWL_USER);
838	switch (SHORT1FROMMP(mp1)) {
839	case DID_OK:
840	sSelect = (SHORT) WinSendDlgItemMsg(hwnd,
841	ASEL_LISTBOX,
842	LM_QUERYSELECTION,
843	MPFROMSHORT(LIT_FIRST), MPVOID);
844	if (sSelect == LIT_NONE) {
845	Runtime_Error(pszSrcFile, __LINE__, "list empty");
846	return 0;
847	}
848	pat = arcsighead;
849	if (*ppatReturn) {
850	// If dups hidden, find archiver with matching id
851	*szItemText = 0;
852	WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_QUERYITEMTEXT,
853	MPFROM2SHORT(sSelect, 255), MPFROMP(szItemText));
854	if (!*szItemText)
855	pat = NULL;
856	else {
857	for (; pat; pat = pat->next) {
858	if (pat->id && !strcmp(szItemText, pat->id))
859	break; // Found it
860	}
861	}
862	}
863	else {
864	// If dups not hidden, lookup by count
865	for (i = 0; pat && i < sSelect; i++, pat = pat->next) ; // Scan
866	}
867	if (pat && (!*ppatReturn \|\| (pat->id && pat->extract && pat->create))) {
868	*ppatReturn = pat;
869	}
870	else {
871	Runtime_Error(pszSrcFile, __LINE__, "no match");
872	// Refuse to select
873	WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_SELECTITEM,
874	MPFROMSHORT(LIT_NONE), FALSE);
875	return 0;
876	}
877	PrfWriteProfileData(fmprof, appname, "LastArchiver", &sSelect, sizeof(SHORT));
878	sLastSelect = sSelect;
879	WinDismissDlg(hwnd, TRUE);
880	return 0;
881
882	case DID_CANCEL:
883	if (arcsigsmodified) {
884	if (saymsg(MB_YESNO,
885	hwnd,
886	GetPString(IDS_ADCHANGESINMEMTEXT),
887	GetPString(IDS_ADREWRITETEXT), NullStr) == MBID_YES) {
888	PSZ ab2 = searchpath(PCSZ_ARCHIVERBB2); // Rewrite without prompting
889
890	rewrite_archiverbb2(ab2);
891	}
892	}
893	sSelect = (SHORT) WinSendDlgItemMsg(hwnd,
894	ASEL_LISTBOX,
895	LM_QUERYSELECTION,
896	MPFROMSHORT(LIT_FIRST), MPVOID);
897	if (sSelect != LIT_NONE) {
898	sLastSelect = sSelect;
899	PrfWriteProfileData(fmprof, appname, "LastArchiver", &sSelect, sizeof(SHORT));
900	}
901	*ppatReturn = NULL;
902	PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID); // fixme to understand why needed
903	return 0;
904
905	case ASEL_PB_ADD:
906	sSelect = (SHORT) WinSendDlgItemMsg(hwnd,
907	ASEL_LISTBOX,
908	LM_QUERYSELECTION,
909	MPFROMSHORT(LIT_FIRST), MPVOID);
910	if (sSelect != LIT_NONE) {
911	ARCDUMP ad;
912
913	memset(&ad, 0, sizeof(ARCDUMP));
914	ad.info = xmallocz(sizeof(ARC_TYPE), pszSrcFile, __LINE__);
915	if (ad.info) {
916	if (!WinDlgBox(HWND_DESKTOP,
917	hwnd,
918	ArcReviewDlgProc,
919	FM3ModHandle, AD_FRAME, MPFROMP(&ad))) {
920	free(ad.info);
921	}
922	else {
923	// Find self - assume all archivers listed since we are editing
924	for (i = 0, pat = arcsighead; pat && i < sSelect; pat = pat->next, i++) ; // Find self
925
926	if (!pat) {
927	if (arcsighead)
928	Runtime_Error(pszSrcFile, __LINE__, pszCantFindMsg, sSelect);
929	else
930	arcsighead = ad.info;
931	}
932	else {
933	// Insert before
934	if (pat->prev) {
935	ad.info->next = pat;
936	ad.info->prev = pat->prev;
937	pat->prev->next = ad.info;
938	pat->prev = ad.info;
939	}
940	else {
941	arcsighead = ad.info;
942	ad.info->next = pat;
943	pat->prev = ad.info;
944	}
945	}
946	WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_INSERTITEM,
947	MPFROM2SHORT(sSelect, 0),
948	MPFROMP(ad.info->id ? ad.info->id : "?"));
949	WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_SELECTITEM,
950	MPFROMSHORT(sSelect - 1), MPFROMSHORT(TRUE));
951	arcsigsmodified = TRUE;
952	}
953	}
954	}
955	return 0;
956	case ASEL_PB_DELETE:
957	sSelect = (SHORT) WinSendDlgItemMsg(hwnd,
958	ASEL_LISTBOX,
959	LM_QUERYSELECTION,
960	MPFROMSHORT(LIT_FIRST), MPVOID);
961	if (sSelect != LIT_NONE) {
962	// Find self - assume all archivers listed since we are editing
963	for (i = 0, pat = arcsighead; pat && i < sSelect; pat = pat->next, i++) ; // Find self
964
965	if (!pat)
966	Runtime_Error(pszSrcFile, __LINE__, pszCantFindMsg, sSelect);
967	else {
968	// Delete current
969	if (pat->prev) {
970	pat->prev->next = pat->next;
971	if (pat->next)
972	pat->next->prev = pat->prev;
973	}
974	else {
975	arcsighead = pat->next;
976	if (pat->next)
977	pat->next->prev = pat->prev;
978	}
979	}
980	free_arc_type(pat);
981	arcsigsmodified = TRUE;
982	WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_DELETEITEM,
983	MPFROM2SHORT(sSelect, 0), MPVOID);
984	sItemCount =
985	(SHORT) WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_QUERYITEMCOUNT,
986	MPVOID, MPVOID);
987	if (sSelect >= sItemCount)
988	sSelect--;
989	if (sSelect >= 0) {
990	WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_SELECTITEM,
991	MPFROMSHORT(sSelect), MPFROMSHORT(TRUE));
992	}
993	}
994	return 0;
995	case ASEL_PB_UP:
996	sSelect = (SHORT) WinSendDlgItemMsg(hwnd,
997	ASEL_LISTBOX,
998	LM_QUERYSELECTION,
999	MPFROMSHORT(LIT_FIRST), MPVOID);
1000	if (sSelect != LIT_NONE && sSelect > 0) {
1001	// Find self - assume all archivers listed since we are editing
1002	for (i = 0, pat = arcsighead; pat && i < sSelect; pat = pat->next, i++) ; // Find self
1003	if (!pat \|\| !pat->prev)
1004	Runtime_Error(pszSrcFile, __LINE__, pszCantFindMsg, sSelect);
1005	else {
1006	ARC_TYPE *patGDad;
1007	ARC_TYPE *patDad;
1008	ARC_TYPE *patChild;
1009
1010	patChild = pat->next;
1011	patDad = pat->prev;
1012	patGDad = patDad->prev;
1013	patDad->next = patChild;
1014	if (patChild)
1015	patChild->prev = patDad;
1016	patDad->prev = pat;
1017	pat->next = patDad;
1018	if (patGDad) {
1019	patGDad->next = pat;
1020	pat->prev = patGDad;
1021	}
1022	else {
1023	arcsighead = pat;
1024	pat->prev = NULL;
1025	}
1026
1027	WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_QUERYITEMTEXT,
1028	MPFROM2SHORT(sSelect, 255), MPFROMP(szItemText));
1029	WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_QUERYITEMTEXT,
1030	MPFROM2SHORT(sSelect - 1, 255),
1031	MPFROMP(szPCItemText));
1032	WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_SETITEMTEXT,
1033	MPFROMSHORT(sSelect), MPFROMP(szPCItemText));
1034	WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_SETITEMTEXT,
1035	MPFROMSHORT(sSelect - 1), MPFROMP(szItemText));
1036	WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_SELECTITEM,
1037	MPFROMSHORT(sSelect - 1), MPFROMSHORT(TRUE));
1038	arcsigsmodified = TRUE;
1039	}
1040	}
1041	return 0;
1042	case ASEL_PB_DOWN:
1043	sSelect =
1044	(SHORT) WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_QUERYSELECTION,
1045	MPFROMSHORT(LIT_FIRST), MPVOID);
1046	sItemCount =
1047	(SHORT) WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_QUERYITEMCOUNT,
1048	MPVOID, MPVOID);
1049	if (sSelect != LIT_NONE && sSelect < sItemCount - 1) {
1050	// Find self - assume all archivers listed since we are editing
1051	for (i = 0, pat = arcsighead; pat && i < sSelect; pat = pat->next, i++) ; // Find self
1052	if (!pat \|\| !pat->next)
1053	Runtime_Error(pszSrcFile, __LINE__, "Can't find item %d of %d",
1054	sSelect, sItemCount);
1055	else {
1056	ARC_TYPE *patDad;
1057	ARC_TYPE *patChild;
1058
1059	patDad = pat->prev;
1060	patChild = pat->next;
1061	pat->next = patChild->next;
1062	patChild->next = pat;
1063	pat->prev = patChild;
1064	patChild->prev = patDad;
1065	if (patDad) {
1066	patDad->next = patChild;
1067	patChild->prev = patDad;
1068	}
1069	else {
1070	arcsighead = patChild;
1071	patChild->prev = NULL;
1072	}
1073
1074	WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_QUERYITEMTEXT,
1075	MPFROM2SHORT(sSelect, 255), MPFROMP(szItemText));
1076	WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_QUERYITEMTEXT,
1077	MPFROM2SHORT(sSelect + 1, 255),
1078	MPFROMP(szPCItemText));
1079	WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_SETITEMTEXT,
1080	MPFROMSHORT(sSelect), MPFROMP(szPCItemText));
1081	WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_SETITEMTEXT,
1082	MPFROMSHORT(sSelect + 1), MPFROMP(szItemText));
1083	WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_SELECTITEM,
1084	MPFROMSHORT(sSelect + 1), MPFROMSHORT(TRUE));
1085	arcsigsmodified = TRUE;
1086	}
1087	}
1088	return 0;
1089
1090	case ASEL_PB_REVERT:
1091	// Reload without checking in case changed outside
1092	sSelect =
1093	(SHORT) WinSendDlgItemMsg(hwnd, ASEL_LISTBOX, LM_QUERYSELECTION,
1094	MPFROMSHORT(LIT_FIRST), MPVOID);
1095	load_archivers();
1096	fill_listbox(hwnd, TRUE, sSelect);
1097	return 0;
1098
1099	case IDM_HELP:
1100	if (hwndHelp) {
1101	WinSendMsg(hwndHelp, HM_DISPLAY_HELP, MPFROM2SHORT(HELP_EDITARC, 0), // fixme to be HELP_SELARC
1102	MPFROMSHORT(HM_RESOURCEID));
1103	}
1104	}
1105	return 0; // WM_COMMAND
1106
1107	case WM_CONTROL:
1108	if (SHORT1FROMMP(mp1) == ASEL_LISTBOX && SHORT2FROMMP(mp1) == LN_ENTER)
1109	PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(DID_OK, 0), MPVOID);
1110	return 0;
1111
1112	case WM_CLOSE:
1113	WinDismissDlg(hwnd, FALSE);
1114	return 0;
1115
1116	default:
1117	break;
1118	}
1119	return WinDefDlgProc(hwnd, msg, mp1, mp2);
1120	}
1121
1122	/*
1123	see archiver.tmp
1124	02-08-96 23:55 1
1125	8 Feb 96 23:55:32 2
1126	8 Feb 96 11:55p 3
1127	96-02-08 23:55:32 4
1128	31-02-98 23:55 5
1129	*/
1130
1131	BOOL ArcDateTime(CHAR * dt, INT type, CDATE * cdate, CTIME * ctime)
1132	{
1133	INT x;
1134	BOOL ret = FALSE;
1135	CHAR p, pp, *pd;
1136
1137	if (dt && cdate && ctime) {
1138	memset(cdate, 0, sizeof(CDATE));
1139	memset(ctime, 0, sizeof(CTIME));
1140	if (type) {
1141	p = dt;
1142	while (p && p == ' ')
1143	p++;
1144	pd = dt;
1145	switch (type) {
1146	case 1:
1147	cdate->month = atoi(pd);
1148	p = to_delim(pd, "-/.");
1149	if (p) {
1150	p++;
1151	cdate->day = atoi(p);
1152	pd = p;
1153	p = to_delim(pd, "-/.");
1154	if (p) {
1155	p++;
1156	cdate->year = atoi(p);
1157	if (cdate->year > 80 && cdate->year < 1900)
1158	cdate->year += 1900;
1159	else if (cdate->year < 1900)
1160	cdate->year += 2000;
1161	ret = TRUE;
1162	p = strchr(p, ' ');
1163	if (p) {
1164	while (p && p == ' ')
1165	p++;
1166	ctime->hours = atoi(p);
1167	p = to_delim(pd, ":.");
1168	if (p) {
1169	p++;
1170	ctime->minutes = atoi(p);
1171	p = to_delim(pd, ":.");
1172	if (p) {
1173	p++;
1174	ctime->seconds = atoi(p);
1175	}
1176	}
1177	}
1178	}
1179	}
1180	break;
1181
1182	case 2:
1183	cdate->day = atoi(p);
1184	p = strchr(p, ' ');
1185	if (p) {
1186	p++;
1187	for (x = 0; x < 12; x++) {
1188	if (!strnicmp(p, GetPString(IDS_JANUARY + x), 3))
1189	break;
1190	}
1191	if (x < 12) {
1192	cdate->month = x;
1193	p = strchr(p, ' ');
1194	if (p) {
1195	p++;
1196	cdate->year = atoi(p);
1197	if (cdate->year > 80 && cdate->year < 1900)
1198	cdate->year += 1900;
1199	else if (cdate->year < 1900)
1200	cdate->year += 2000;
1201	ret = TRUE;
1202	p = strchr(p, ' ');
1203	if (p) {
1204	while (p && p == ' ')
1205	p++;
1206	ctime->hours = atoi(p);
1207	p = to_delim(pd, ":.");
1208	if (p) {
1209	p++;
1210	ctime->minutes = atoi(p);
1211	p = to_delim(pd, ":.");
1212	if (p) {
1213	p++;
1214	ctime->seconds = atoi(p);
1215	}
1216	}
1217	}
1218	}
1219	}
1220	}
1221	break;
1222
1223	case 3:
1224	cdate->day = atoi(p);
1225	p = strchr(p, ' ');
1226	if (p) {
1227	p++;
1228	for (x = 0; x < 12; x++) {
1229	if (!strnicmp(p, GetPString(IDS_JANUARY + x), 3))
1230	break;
1231	}
1232	if (x < 12) {
1233	cdate->month = x;
1234	p = strchr(p, ' ');
1235	if (p) {
1236	p++;
1237	cdate->year = atoi(p);
1238	if (cdate->year > 80 && cdate->year < 1900)
1239	cdate->year += 1900;
1240	else if (cdate->year < 1900)
1241	cdate->year += 2000;
1242	ret = TRUE;
1243	p = strchr(p, ' ');
1244	if (p) {
1245	while (p && p == ' ')
1246	p++;
1247	ctime->hours = atoi(p);
1248	p = to_delim(pd, ":.");
1249	if (p) {
1250	p++;
1251	pp = p;
1252	ctime->minutes = atoi(p);
1253	p = to_delim(pd, ":.");
1254	if (p) {
1255	p++;
1256	ctime->seconds = atoi(p);
1257	p += 2;
1258	if (toupper(*p) == 'P')
1259	ctime->hours += 12;
1260	}
1261	else {
1262	p = pp;
1263	p += 2;
1264	if (toupper(*p) == 'P')
1265	ctime->hours += 12;
1266	}
1267	}
1268	}
1269	}
1270	}
1271	}
1272	break;
1273
1274	case 4:
1275	cdate->year = atoi(p);
1276	if (cdate->year > 80 && cdate->year < 1900)
1277	cdate->year += 1900;
1278	else if (cdate->year < 1900)
1279	cdate->year += 2000;
1280	p = to_delim(pd, "-/.");
1281	if (p) {
1282	p++;
1283	cdate->month = atoi(p);
1284	pd = p;
1285	p = to_delim(pd, "-/.");
1286	if (p) {
1287	p++;
1288	cdate->day = atoi(p);
1289	ret = TRUE;
1290	p = strchr(p, ' ');
1291	if (p) {
1292	while (p && p == ' ')
1293	p++;
1294	ctime->hours = atoi(p);
1295	p = to_delim(pd, ":.");
1296	if (p) {
1297	p++;
1298	ctime->minutes = atoi(p);
1299	p = to_delim(pd, ":.");
1300	if (p) {
1301	p++;
1302	ctime->seconds = atoi(p);
1303	}
1304	}
1305	}
1306	}
1307	}
1308	break;
1309
1310	case 5:
1311	cdate->day = atoi(pd);
1312	p = to_delim(pd, "-/.");
1313	if (p) {
1314	p++;
1315	cdate->month = atoi(p);
1316	pd = p;
1317	p = to_delim(pd, "-/.");
1318	if (p) {
1319	p++;
1320	cdate->year = atoi(p);
1321	if (cdate->year > 80 && cdate->year < 1900)
1322	cdate->year += 1900;
1323	else if (cdate->year < 1900)
1324	cdate->year += 2000;
1325	ret = TRUE;
1326	p = strchr(p, ' ');
1327	if (p) {
1328	while (p && p == ' ')
1329	p++;
1330	ctime->hours = atoi(p);
1331	p = to_delim(pd, ":.");
1332	if (p) {
1333	p++;
1334	ctime->minutes = atoi(p);
1335	p = to_delim(pd, ":.");
1336	if (p) {
1337	p++;
1338	ctime->seconds = atoi(p);
1339	}
1340	}
1341	}
1342	}
1343	}
1344	break;
1345
1346	default:
1347	break;
1348	}
1349	}
1350	}
1351	return ret;
1352	}
1353
1354	#pragma alloc_text(MISC9,quick_find_type,find_type)
1355	#pragma alloc_text(AVL,load_archivers, get_line_strip_comments, get_line_strip_white, free_archivers)
1356	#pragma alloc_text(FMARCHIVE,SBoxDlgProc,SDlgListboxSubclassProc)
1357	#pragma alloc_text(ARCCNRS,ArcDateTime)

Note: See TracBrowser for help on using the repository browser.

Download in other formats: