Context Navigation

source: trunk/dll/avl.c@ 439

Visit:

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