Context Navigation

source: trunk/dll/avl.c@ 418

Visit:

Last change on this file since 418 was 418, checked in by root, 19 years ago
Use more wrappers
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 32.2 KB

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

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

Download in other formats: