Context Navigation

source: trunk/dll/avl.c@ 537

Visit:

Last change on this file since 537 was 537, checked in by root, 19 years ago
Turn off leftover debug code
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 32.3 KB

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

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

Download in other formats: