Context Navigation

source: trunk/dll/avl.c@ 312

Visit:

Last change on this file since 312 was 312, checked in by root, 19 years ago
load_archivers: remember where comments are
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 32.1 KB

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

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

Download in other formats: