Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Normal
Revision Log

source: trunk/dll/filldir.c@ 2

Visit:

Last change on this file since 2 was 2, checked in by root, 23 years ago
Initial revision
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 47.4 KB

Rev	Line
[2]	1	#define INCL_DOS
	2	#define INCL_WIN
	3
	4	#include <os2.h>
	5	#include <stdarg.h>
	6	#include <stdio.h>
	7	#include <stdlib.h>
	8	#include <string.h>
	9	#include <ctype.h>
	10	#include <time.h>
	11	#include "fm3dll.h"
	12	#include "fm3str.h"
	13
	14	#pragma alloc_text(FILLDIR,FillInRecordFromFFB,FillInRecordFromFSA,IDFile)
	15	#pragma alloc_text(FILLDIR1,ProcessDirectory,FillDirCnr,FillTreeCnr)
	16
	17
	18	HPOINTER IDFile (ULONG cmp) {
	19
	20	HPOINTER hptr;
	21
	22	hptr = (HPOINTER)0;
	23	if(cmp == (ULONG )".EXE" \|\| cmp == (ULONG )".CMD" \|\|
	24	cmp == (ULONG )".BAT" \|\| cmp == (ULONG )".COM")
	25	hptr = hptrApp;
	26	else if(cmp == (ULONG )".ZIP" \|\| cmp == (ULONG )".LZH" \|\|
	27	cmp == (ULONG )".ARJ" \|\| cmp == (ULONG )".ARC" \|\|
	28	cmp == (ULONG )".ZOO" \|\| cmp == (ULONG )".RAR")
	29	hptr = hptrArc;
	30	else if(cmp == (ULONG )".BMP" \|\| cmp == (ULONG )".ICO" \|\|
	31	cmp == (ULONG )".PTR" \|\| cmp == (ULONG )".GIF" \|\|
	32	cmp == (ULONG )".TIF" \|\| cmp == (ULONG )".PCX" \|\|
	33	cmp == (ULONG )".TGA" \|\| cmp == (ULONG )".XBM")
	34	hptr = hptrArt;
	35	return hptr;
	36	}
	37
	38
	39	ULONG FillInRecordFromFFB (HWND hwndCnr,PCNRITEM pci, const PSZ pszDirectory,
	40	const PFILEFINDBUF4 pffb,const BOOL partial,
	41	DIRCNRDATA *dcd) {
	42
	43	/* fill in a container record from a FILEFINDBUF4 structure */
	44
	45	CHAR attrstring[] = "RHS\0DA",cmps[] = ".xxx";
	46	register CHAR *p;
	47	HPOINTER hptr;
	48	register INT x,y;
	49	INT t;
	50	ULONG cmp;
	51
	52	pci->hwndCnr = hwndCnr;
	53	t = strlen(pszDirectory);
	54	memcpy(pci->szFileName,pszDirectory,t + 1);
	55	/* note! we cheat below, and accept the full pathname in pszDirectory
	56	if !*pffb->achName. speeds up and simplifies processing elsewhere
	57	(like in update.c) */
	58	if(*pffb->achName) {
	59	p = pci->szFileName + (t - 1);
	60	if(*p != '\\') {
	61	p++;
	62	*p = '\\';
	63	}
	64	p++;
	65	memcpy(p,pffb->achName,pffb->cchName + 1);
	66	}
	67	/* load the object's Subject, if required */
	68	if(pffb->cbList > 4L && dcd && fLoadSubject &&
	69	(isalpha(*pci->szFileName) &&
	70	!(driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_NOLOADSUBJS))) {
	71
	72	APIRET rc;
	73	EAOP2 eaop;
	74	PGEA2LIST pgealist;
	75	PFEA2LIST pfealist;
	76	PGEA2 pgea;
	77	PFEA2 pfea;
	78	CHAR *value;
	79
	80	pgealist = malloc(sizeof(GEA2LIST) + 32);
	81	if(pgealist) {
	82	memset(pgealist,0,sizeof(GEA2LIST) + 32);
	83	pgea = &pgealist->list[0];
	84	strcpy(pgea->szName,SUBJECT);
	85	pgea->cbName = strlen(pgea->szName);
	86	pgea->oNextEntryOffset = 0L;
	87	pgealist->cbList = (sizeof(GEA2LIST) + pgea->cbName);
	88	pfealist = malloc(1532);
	89	if(pfealist) {
	90	memset(pfealist,0,1532);
	91	pfealist->cbList = 1024;
	92	eaop.fpGEA2List = pgealist;
	93	eaop.fpFEA2List = pfealist;
	94	eaop.oError = 0L;
	95	rc = DosQueryPathInfo(pci->szFileName,FIL_QUERYEASFROMLIST,
	96	(PVOID)&eaop,(ULONG)sizeof(EAOP2));
	97	if(!rc) {
	98	pfea = &eaop.fpFEA2List->list[0];
	99	value = pfea->szName + pfea->cbName + 1;
	100	value[pfea->cbValue] = 0;
	101	if((USHORT )value == EAT_ASCII)
	102	strncpy(pci->subject,value + (sizeof(USHORT) * 2),39);
	103	pci->subject[39] = 0;
	104	}
	105	free(pfealist);
	106	}
	107	free(pgealist);
	108	}
	109	}
	110	pci->pszSubject = pci->subject;
	111	/* load the object's longname */
	112	*pci->Longname = 0;
	113	if(pffb->cbList > 4L && dcd && fLoadLongnames &&
	114	(isalpha(*pci->szFileName) &&
	115	(driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_NOLONGNAMES) &&
	116	!(driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_NOLOADLONGS))) {
	117
	118	APIRET rc;
	119	EAOP2 eaop;
	120	PGEA2LIST pgealist;
	121	PFEA2LIST pfealist;
	122	PGEA2 pgea;
	123	PFEA2 pfea;
	124	CHAR *value;
	125
	126	pgealist = malloc(sizeof(GEA2LIST) + 32);
	127	if(pgealist) {
	128	memset(pgealist,0,sizeof(GEA2LIST) + 32);
	129	pgea = &pgealist->list[0];
	130	strcpy(pgea->szName,LONGNAME);
	131	pgea->cbName = strlen(pgea->szName);
	132	pgea->oNextEntryOffset = 0L;
	133	pgealist->cbList = (sizeof(GEA2LIST) + pgea->cbName);
	134	pfealist = malloc(1532);
	135	if(pfealist) {
	136	memset(pfealist,0,1532);
	137	pfealist->cbList = 1024;
	138	eaop.fpGEA2List = pgealist;
	139	eaop.fpFEA2List = pfealist;
	140	eaop.oError = 0L;
	141	rc = DosQueryPathInfo(pci->szFileName,FIL_QUERYEASFROMLIST,
	142	(PVOID)&eaop,(ULONG)sizeof(EAOP2));
	143	if(!rc) {
	144	pfea = &eaop.fpFEA2List->list[0];
	145	value = pfea->szName + pfea->cbName + 1;
	146	value[pfea->cbValue] = 0;
	147	if((USHORT )value == EAT_ASCII)
	148	strncpy(pci->Longname,value + (sizeof(USHORT) * 2),CCHMAXPATHCOMP);
	149	pci->Longname[CCHMAXPATHCOMP - 1] = 0;
	150	}
	151	free(pfealist);
	152	}
	153	free(pgealist);
	154	}
	155	}
	156	pci->pszLongname = pci->Longname;
	157
	158	/* do anything required to case of filename */
	159	if(fForceUpper)
	160	strupr(pci->szFileName);
	161	else if(fForceLower)
	162	strlwr(pci->szFileName);
	163
	164	/* get an icon to use with it */
	165	if(pffb->attrFile & FILE_DIRECTORY) {
	166	if(!fNoIconsDirs && (!isalpha(*pci->szFileName) \|\|
	167	!(driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_NOLOADICONS)))
	168	hptr = WinLoadFileIcon(pci->szFileName, FALSE);
	169	else
	170	hptr = (HPOINTER)0;
	171	}
	172	else {
	173	if(!fNoIconsFiles && (!isalpha(*pci->szFileName) \|\|
	174	!(driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_NOLOADICONS)))
	175	hptr = WinLoadFileIcon(pci->szFileName, FALSE);
	176	else {
	177	p = strrchr(pci->szFileName,'.');
	178	if(p && !p[4]) {
	179	cmps[1] = toupper(p[1]);
	180	cmps[2] = toupper(p[2]);
	181	cmps[3] = toupper(p[3]);
	182	cmp = (ULONG )cmps;
	183	hptr = IDFile(cmp);
	184	}
	185	else
	186	hptr = (HPOINTER)0;
	187	}
	188	}
	189	if(!hptr)
	190	hptr = ((pffb->attrFile & FILE_DIRECTORY) != 0) ? hptrDir :
	191	((pffb->attrFile & FILE_SYSTEM) != 0) ? hptrSystem :
	192	((pffb->attrFile & FILE_HIDDEN) != 0) ? hptrHidden :
	193	((pffb->attrFile & FILE_READONLY) != 0) ? hptrReadonly :
	194	hptrFile;
	195
	196	/* decide where to point for the container's title text */
	197	if(partial) {
	198	p = strrchr(pci->szFileName,'\\');
	199	if(!p) {
	200	p = strrchr(pci->szFileName,':');
	201	if(!p)
	202	p = pci->szFileName;
	203	else
	204	p++;
	205	}
	206	else if((dcd && dcd->type == TREE_FRAME) \|\|
	207	(!(pffb->attrFile & FILE_DIRECTORY) \|\| !*(p + 1)))
	208	p++;
	209	if(!*p)
	210	p = pci->szFileName;
	211	}
	212	else
	213	p = pci->szFileName;
	214	/* now fill the darned thing in... */
	215	pci->pszFileName = p;
	216	pci->date.day = pffb->fdateLastWrite.day;
	217	pci->date.month = pffb->fdateLastWrite.month;
	218	pci->date.year = pffb->fdateLastWrite.year + 1980;
	219	pci->time.seconds = pffb->ftimeLastWrite.twosecs * 2;
	220	pci->time.minutes = pffb->ftimeLastWrite.minutes;
	221	pci->time.hours = pffb->ftimeLastWrite.hours;
	222	pci->ladate.day = pffb->fdateLastAccess.day;
	223	pci->ladate.month = pffb->fdateLastAccess.month;
	224	pci->ladate.year = pffb->fdateLastAccess.year + 1980;
	225	pci->latime.seconds = pffb->ftimeLastAccess.twosecs * 2;
	226	pci->latime.minutes = pffb->ftimeLastAccess.minutes;
	227	pci->latime.hours = pffb->ftimeLastAccess.hours;
	228	pci->crdate.day = pffb->fdateCreation.day;
	229	pci->crdate.month = pffb->fdateCreation.month;
	230	pci->crdate.year = pffb->fdateCreation.year + 1980;
	231	pci->crtime.seconds = pffb->ftimeCreation.twosecs * 2;
	232	pci->crtime.minutes = pffb->ftimeCreation.minutes;
	233	pci->crtime.hours = pffb->ftimeCreation.hours;
	234	pci->easize = (pffb->cbList > 4L) ? (pffb->cbList / 2) : 0L;
	235	pci->cbFile = pffb->cbFile;
	236	pci->attrFile = pffb->attrFile;
	237	/* build attribute string for display */
	238	y = 0;
	239	for(x = 0;x < 6;x++)
	240	if(attrstring[x])
	241	pci->szDispAttr[y++] = (CHAR)((pci->attrFile & (1 << x)) ?
	242	attrstring[x] : '-');
	243	pci->szDispAttr[5] = 0;
	244	pci->pszDispAttr = pci->szDispAttr;
	245	pci->rc.pszIcon = pci->pszFileName;
	246	pci->rc.hptrIcon = hptr;
	247
	248	/* check to see if record should be visible */
	249	if(dcd && (*dcd->mask.szMask \|\| dcd->mask.antiattr \|\|
	250	((dcd->mask.attrFile &
	251	(FILE_HIDDEN \| FILE_SYSTEM \| FILE_READONLY \| FILE_ARCHIVED)) !=
	252	(FILE_HIDDEN \| FILE_SYSTEM \| FILE_READONLY \| FILE_ARCHIVED)))) {
	253	if(*dcd->mask.szMask \|\| dcd->mask.antiattr) {
	254	if(!Filter((PMINIRECORDCORE)pci,(PVOID)&dcd->mask))
	255	pci->rc.flRecordAttr \|= CRA_FILTERED;
	256	}
	257	else if((!(dcd->mask.attrFile & FILE_HIDDEN) &&
	258	(pci->attrFile & FILE_HIDDEN)) \|\|
	259	(!(dcd->mask.attrFile & FILE_SYSTEM) &&
	260	(pci->attrFile & FILE_SYSTEM)) \|\|
	261	(!(dcd->mask.attrFile & FILE_READONLY) &&
	262	(pci->attrFile & FILE_READONLY)) \|\|
	263	(!(dcd->mask.attrFile & FILE_ARCHIVED) &&
	264	(pci->attrFile & FILE_ARCHIVED)))
	265	pci->rc.flRecordAttr \|= CRA_FILTERED;
	266	}
	267
	268	return pffb->cbFile + pci->easize;
	269	}
	270
	271
	272	ULONG FillInRecordFromFSA (HWND hwndCnr,PCNRITEM pci,const PSZ pszFileName,
	273	const PFILESTATUS4 pfsa4,
	274	const BOOL partial,
	275	DIRCNRDATA *dcd) {
	276
	277	HPOINTER hptr;
	278	CHAR attrstring[] = "RHS\0DA",cmps[] = ".xxx";
	279	register CHAR *p;
	280	register INT x,y;
	281	ULONG cmp;
	282
	283	/* fill in a container record from a FILESTATUS4 structure */
	284
	285	pci->hwndCnr = hwndCnr;
	286	strcpy(pci->szFileName,pszFileName);
	287	/* load the object's Subject, if required */
	288	if(pfsa4->cbList > 4L && dcd && fLoadSubject &&
	289	(!isalpha(*pci->szFileName) \|\|
	290	!(driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_NOLOADSUBJS))) {
	291
	292	APIRET rc;
	293	EAOP2 eaop;
	294	PGEA2LIST pgealist;
	295	PFEA2LIST pfealist;
	296	PGEA2 pgea;
	297	PFEA2 pfea;
	298	CHAR *value;
	299
	300	pgealist = malloc(sizeof(GEA2LIST) + 32);
	301	if(pgealist) {
	302	memset(pgealist,0,sizeof(GEA2LIST) + 32);
	303	pgea = &pgealist->list[0];
	304	strcpy(pgea->szName,SUBJECT);
	305	pgea->cbName = strlen(pgea->szName);
	306	pgea->oNextEntryOffset = 0L;
	307	pgealist->cbList = (sizeof(GEA2LIST) + pgea->cbName);
	308	pfealist = malloc(1532);
	309	if(pfealist) {
	310	memset(pfealist,0,1532);
	311	pfealist->cbList = 1024;
	312	eaop.fpGEA2List = pgealist;
	313	eaop.fpFEA2List = pfealist;
	314	eaop.oError = 0L;
	315	rc = DosQueryPathInfo(pci->szFileName,FIL_QUERYEASFROMLIST,
	316	(PVOID)&eaop,
	317	(ULONG)sizeof(EAOP2));
	318	if(!rc) {
	319	pfea = &eaop.fpFEA2List->list[0];
	320	value = pfea->szName + pfea->cbName + 1;
	321	value[pfea->cbValue] = 0;
	322	if((USHORT )value == EAT_ASCII)
	323	strncpy(pci->subject,value + (sizeof(USHORT) * 2),39);
	324	pci->subject[39] = 0;
	325	}
	326	free(pfealist);
	327	}
	328	free(pgealist);
	329	}
	330	}
	331	pci->pszSubject = pci->subject;
	332	*pci->Longname = 0;
	333	if(pfsa4->cbList > 4L && dcd && fLoadLongnames &&
	334	(!isalpha(*pci->szFileName) \|\|
	335	((driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_NOLONGNAMES) &&
	336	!(driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_NOLOADLONGS)))) {
	337
	338	APIRET rc;
	339	EAOP2 eaop;
	340	PGEA2LIST pgealist;
	341	PFEA2LIST pfealist;
	342	PGEA2 pgea;
	343	PFEA2 pfea;
	344	CHAR *value;
	345
	346	pgealist = malloc(sizeof(GEA2LIST) + 32);
	347	if(pgealist) {
	348	memset(pgealist,0,sizeof(GEA2LIST) + 32);
	349	pgea = &pgealist->list[0];
	350	strcpy(pgea->szName,LONGNAME);
	351	pgea->cbName = strlen(pgea->szName);
	352	pgea->oNextEntryOffset = 0L;
	353	pgealist->cbList = (sizeof(GEA2LIST) + pgea->cbName);
	354	pfealist = malloc(1532);
	355	if(pfealist) {
	356	memset(pfealist,0,1532);
	357	pfealist->cbList = 1024;
	358	eaop.fpGEA2List = pgealist;
	359	eaop.fpFEA2List = pfealist;
	360	eaop.oError = 0L;
	361	rc = DosQueryPathInfo(pci->szFileName,FIL_QUERYEASFROMLIST,
	362	(PVOID)&eaop,(ULONG)sizeof(EAOP2));
	363	if(!rc) {
	364	pfea = &eaop.fpFEA2List->list[0];
	365	value = pfea->szName + pfea->cbName + 1;
	366	value[pfea->cbValue] = 0;
	367	if((USHORT )value == EAT_ASCII)
	368	strncpy(pci->Longname,value + (sizeof(USHORT) * 2),CCHMAXPATHCOMP);
	369	pci->Longname[CCHMAXPATHCOMP - 1] = 0;
	370	}
	371	free(pfealist);
	372	}
	373	free(pgealist);
	374	}
	375	}
	376	pci->pszLongname = pci->Longname;
	377	if(fForceUpper)
	378	strupr(pci->szFileName);
	379	else if(fForceLower)
	380	strlwr(pci->szFileName);
	381
	382	if(pfsa4->attrFile & FILE_DIRECTORY) {
	383	if(!fNoIconsDirs && (!isalpha(*pci->szFileName) \|\|
	384	!(driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_NOLOADICONS)))
	385	hptr = WinLoadFileIcon(pci->szFileName, FALSE);
	386	else
	387	hptr = (HPOINTER)0;
	388	}
	389	else {
	390	if(!fNoIconsFiles && (!isalpha(*pci->szFileName) \|\|
	391	!(driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_NOLOADICONS)))
	392	hptr = WinLoadFileIcon(pci->szFileName, FALSE);
	393	else {
	394	p = strrchr(pci->szFileName,'.');
	395	if(p && !p[4]) {
	396	cmps[1] = toupper(p[1]);
	397	cmps[2] = toupper(p[2]);
	398	cmps[3] = toupper(p[3]);
	399	cmp = (ULONG )cmps;
	400	hptr = IDFile(cmp);
	401	}
	402	else
	403	hptr = (HPOINTER)0;
	404	}
	405	}
	406	if(!hptr)
	407	hptr = ((pfsa4->attrFile & FILE_DIRECTORY) != 0) ? hptrDir :
	408	((pfsa4->attrFile & FILE_SYSTEM) != 0) ? hptrSystem :
	409	((pfsa4->attrFile & FILE_HIDDEN) != 0) ? hptrHidden :
	410	((pfsa4->attrFile & FILE_READONLY) != 0) ? hptrReadonly :
	411	hptrFile;
	412
	413	if(partial) {
	414	p = strrchr(pci->szFileName,'\\');
	415	if(!p) {
	416	p = strrchr(pci->szFileName,':');
	417	if(!p)
	418	p = pci->szFileName;
	419	else
	420	p++;
	421	}
	422	else if((dcd && dcd->type == TREE_FRAME) \|\|
	423	(!(pfsa4->attrFile & FILE_DIRECTORY) \|\| !*(p + 1)))
	424	p++;
	425	if(!*p)
	426	p = pci->szFileName;
	427	}
	428	else
	429	p = pci->szFileName;
	430	pci->pszFileName = p;
	431	pci->date.day = pfsa4->fdateLastWrite.day;
	432	pci->date.month = pfsa4->fdateLastWrite.month;
	433	pci->date.year = pfsa4->fdateLastWrite.year + 1980;
	434	pci->time.seconds = pfsa4->ftimeLastWrite.twosecs * 2;
	435	pci->time.minutes = pfsa4->ftimeLastWrite.minutes;
	436	pci->time.hours = pfsa4->ftimeLastWrite.hours;
	437	pci->ladate.day = pfsa4->fdateLastAccess.day;
	438	pci->ladate.month = pfsa4->fdateLastAccess.month;
	439	pci->ladate.year = pfsa4->fdateLastAccess.year + 1980;
	440	pci->latime.seconds = pfsa4->ftimeLastAccess.twosecs * 2;
	441	pci->latime.minutes = pfsa4->ftimeLastAccess.minutes;
	442	pci->latime.hours = pfsa4->ftimeLastAccess.hours;
	443	pci->crdate.day = pfsa4->fdateCreation.day;
	444	pci->crdate.month = pfsa4->fdateCreation.month;
	445	pci->crdate.year = pfsa4->fdateCreation.year + 1980;
	446	pci->crtime.seconds = pfsa4->ftimeCreation.twosecs * 2;
	447	pci->crtime.minutes = pfsa4->ftimeCreation.minutes;
	448	pci->crtime.hours = pfsa4->ftimeCreation.hours;
	449	pci->easize = (pfsa4->cbList > 4L) ? (pfsa4->cbList / 2) : 0L;
	450	pci->cbFile = pfsa4->cbFile;
	451	pci->attrFile = pfsa4->attrFile;
	452	y = 0;
	453	for(x = 0;x < 6;x++)
	454	if(attrstring[x])
	455	pci->szDispAttr[y++] = (CHAR)((pci->attrFile & (1 << x)) ?
	456	attrstring[x] : '-');
	457	pci->szDispAttr[5] = 0;
	458	pci->pszDispAttr = pci->szDispAttr;
	459	pci->rc.pszIcon = pci->pszFileName;
	460	pci->rc.hptrIcon = hptr;
	461
	462	if(dcd && (*dcd->mask.szMask \|\| dcd->mask.antiattr \|\|
	463	((dcd->mask.attrFile &
	464	(FILE_HIDDEN \| FILE_SYSTEM \| FILE_READONLY \| FILE_ARCHIVED)) !=
	465	(FILE_HIDDEN \| FILE_SYSTEM \| FILE_READONLY \| FILE_ARCHIVED)))) {
	466	if(*dcd->mask.szMask \|\| dcd->mask.antiattr) {
	467	if(!Filter((PMINIRECORDCORE)pci,(PVOID)&dcd->mask))
	468	pci->rc.flRecordAttr \|= CRA_FILTERED;
	469	}
	470	else if((!(dcd->mask.attrFile & FILE_HIDDEN) &&
	471	(pci->attrFile & FILE_HIDDEN)) \|\|
	472	(!(dcd->mask.attrFile & FILE_SYSTEM) &&
	473	(pci->attrFile & FILE_SYSTEM)) \|\|
	474	(!(dcd->mask.attrFile & FILE_READONLY) &&
	475	(pci->attrFile & FILE_READONLY)) \|\|
	476	(!(dcd->mask.attrFile & FILE_ARCHIVED) &&
	477	(pci->attrFile & FILE_ARCHIVED)))
	478	pci->rc.flRecordAttr \|= CRA_FILTERED;
	479	}
	480
	481	return pfsa4->cbFile + pci->easize;
	482	}
	483
	484
	485	ULONG ProcessDirectory (const HWND hwndCnr, const PCNRITEM pciParent,
	486	const CHAR *szDirBase, const BOOL filestoo,
	487	const BOOL recurse,const BOOL partial,
	488	CHAR stopflag,DIRCNRDATA dcd,ULONG *foundany) {
	489
	490	/* put all the directories (and files if filestoo is TRUE) from a
	491	* directory into the container. recurse through subdirectories if
	492	* recurse is TRUE.
	493	*/
	494
	495	PSZ szFileSpec;
	496	INT t;
	497	PFILEFINDBUF4 pffb,*ppffb,pffbFile,pfTotal = NULL,pfTemp;
	498	HDIR hdir = HDIR_CREATE;
	499	ULONG ulMaxFiles,ulExtraBytes,ulM = 1L,ulTotal = 0L;
	500	LONG numbytes,totalbytes,returnbytes = 0L;
	501	PCH pchEndPath;
	502	APIRET rc;
	503	PCNRITEM pci,pciFirst,pcit;
	504	RECORDINSERT ri;
	505	register PBYTE fb,tb;
	506
	507	if(foundany)
	508	(*foundany) = 0L;
	509	if(isalpha(*szDirBase) && szDirBase[1] == ':' && szDirBase[2] == '\\') {
	510	// if(!(driveflags[toupper(*szDirBase) - 'A'] & DRIVE_NOLONGNAMES))
	511	ulExtraBytes = EXTRA_RECORD_BYTES;
	512	// else
	513	// ulExtraBytes = EXTRA_RECORD_BYTES2;
	514	if((driveflags[toupper(*szDirBase) - 'A'] & DRIVE_REMOTE) && fRemoteBug)
	515	ulM = 1L; /* file system gets confused */
	516	else if(driveflags[toupper(*szDirBase) - 'A'] & DRIVE_ZIPSTREAM)
	517	ulM = min(FilesToGet,225); /* anything more is wasted */
	518	else
	519	ulM = FilesToGet; /* full-out */
	520	}
	521	else {
	522	ulExtraBytes = EXTRA_RECORD_BYTES;
	523	ulM = FilesToGet;
	524	}
	525	if(OS2ver[0] == 20 && OS2ver[1] < 30)
	526	ulM = min(ulM,(65535 / sizeof(FILEFINDBUF4)));
	527
	528	ulMaxFiles = ulM;
	529	szFileSpec = malloc(CCHMAXPATH + 2);
	530	pffb = malloc((ulM + 1L) * sizeof(FILEFINDBUF4));
	531	ppffb = malloc((ulM + 1L) * sizeof(PFILEFINDBUF4));
	532	if(pffb && ppffb && szFileSpec) {
	533	t = strlen(szDirBase);
	534	memcpy(szFileSpec,szDirBase,t + 1);
	535	pchEndPath = szFileSpec + t;
	536	if(*(pchEndPath - 1) != '\\') {
	537	memcpy(pchEndPath,"\\",2);
	538	pchEndPath++;
	539	}
	540	memcpy(pchEndPath,"*",2);
	541	DosError(FERR_DISABLEHARDERR);
	542	rc = DosFindFirst(szFileSpec, &hdir,
	543	FILE_NORMAL \| ((filestoo) ? FILE_DIRECTORY :
	544	MUST_HAVE_DIRECTORY) \| FILE_READONLY \|
	545	FILE_ARCHIVED \| FILE_SYSTEM \| FILE_HIDDEN,
	546	pffb, ulM * sizeof(FILEFINDBUF4),
	547	&ulMaxFiles, FIL_QUERYEASIZE);
	548	priority_normal();
	549	*pchEndPath = 0;
	550	if(!rc) {
	551	while(!rc) {
	552	/*
	553	* remove . and .. from list if present
	554	* also counter file system bugs that sometimes
	555	* allows normal files to slip through when
	556	* only directories should appear (only a few
	557	* network file systems exhibit such a problem).
	558	*/
	559	{
	560	register ULONG x;
	561
	562	if(stopflag && *stopflag)
	563	goto Abort;
	564	fb = (PBYTE)pffb;
	565	x = 0L;
	566	while(x < ulMaxFiles) {
	567	pffbFile = (PFILEFINDBUF4)fb;
	568	if(!*pffbFile->achName \|\|
	569	(!filestoo && !(pffbFile->attrFile & FILE_DIRECTORY)) \|\|
	570	(((pffbFile->attrFile & FILE_DIRECTORY) &&
	571	pffbFile->achName[0] == '.') &&
	572	(!pffbFile->achName[1] \|\| (pffbFile->achName[1] == '.' &&
	573	!pffbFile->achName[2]))))
	574	ulMaxFiles--;
	575	else
	576	ppffb[x++] = pffbFile;
	577	if(!pffbFile->oNextEntryOffset) {
	578	ulMaxFiles = x;
	579	break;
	580	}
	581	fb += pffbFile->oNextEntryOffset;
	582	}
	583	if(ulMaxFiles) {
	584	if(stopflag && *stopflag)
	585	goto Abort;
	586	if(fSyncUpdates) {
	587	pciFirst = WinSendMsg(hwndCnr, CM_ALLOCRECORD,
	588	MPFROMLONG(ulExtraBytes),
	589	MPFROMLONG(ulMaxFiles));
	590	if(pciFirst) {
	591
	592	register INT i;
	593
	594	pci = pciFirst;
	595	totalbytes = 0L;
	596	for(i = 0; i < ulMaxFiles; i++) {
	597	pffbFile = ppffb[i];
	598	numbytes = FillInRecordFromFFB(hwndCnr,pci,szFileSpec,
	599	pffbFile,partial,dcd);
	600	if(numbytes > -1L) {
	601	pci = (PCNRITEM)pci->rc.preccNextRecord;
	602	totalbytes += numbytes;
	603	}
	604	else {
	605	General_Error(WinQueryAnchorBlock(hwndCnr),HWND_DESKTOP,
	606	__FILE__,__LINE__,
	607	GetPString(IDS_FILLDIRERR1TEXT),
	608	hwndCnr);
	609	ulMaxFiles--;
	610	}
	611	}
	612	if(ulMaxFiles) {
	613	memset(&ri,0,sizeof(RECORDINSERT));
	614	ri.cb = sizeof(RECORDINSERT);
	615	ri.pRecordOrder = (PRECORDCORE) CMA_END;
	616	ri.pRecordParent = (PRECORDCORE) pciParent;
	617	ri.zOrder = (ULONG) CMA_TOP;
	618	ri.cRecordsInsert = ulMaxFiles;
	619	ri.fInvalidateRecord = (!fSyncUpdates && dcd &&
	620	dcd->type == DIR_FRAME) ?
	621	FALSE : TRUE;
	622	if(!WinSendMsg(hwndCnr,
	623	CM_INSERTRECORD,
	624	MPFROMP(pciFirst),
	625	MPFROMP(&ri))) {
	626	DosSleep(100L);
	627	WinSetFocus(HWND_DESKTOP,hwndCnr);
	628	if(!WinSendMsg(hwndCnr,
	629	CM_INSERTRECORD,
	630	MPFROMP(pciFirst),
	631	MPFROMP(&ri))) {
	632	General_Error(WinQueryAnchorBlock(hwndCnr),
	633	HWND_DESKTOP,
	634	__FILE__,
	635	__LINE__,
	636	GetPString(IDS_FILLDIRERR2TEXT));
	637	totalbytes = -1L;
	638	if(WinIsWindow((HAB)0,hwndCnr)) {
	639	pci = pciFirst;
	640	while(pci) {
	641	pcit = (PCNRITEM)pci->rc.preccNextRecord;
	642	WinSendMsg(hwndCnr,
	643	CM_FREERECORD,
	644	MPFROMP(&pci),
	645	MPFROMSHORT(1));
	646	pci = pcit;
	647	}
	648	}
	649	}
	650	}
	651	}
	652	}
	653	else {
	654	General_Error(WinQueryAnchorBlock(hwndCnr),
	655	HWND_DESKTOP,
	656	__FILE__,
	657	__LINE__,
	658	GetPString(IDS_FILLDIRERR3TEXT));
	659	totalbytes = -1L;
	660	}
	661	if(totalbytes > -1L) {
	662	returnbytes += totalbytes;
	663	if(foundany)
	664	(*foundany) += ulMaxFiles;
	665	}
	666	}
	667	else {
	668	pfTemp = realloc(pfTotal,sizeof(FILEFINDBUF4) *
	669	(ulMaxFiles + ulTotal));
	670	if(pfTemp) {
	671	pfTotal = pfTemp;
	672	for(x = 0;x < ulMaxFiles;x++)
	673	pfTotal[x + ulTotal] = *ppffb[x];
	674	ulTotal += ulMaxFiles;
	675	}
	676	else {
	677	saymsg(MB_ENTER,
	678	HWND_DESKTOP,
	679	GetPString(IDS_ERRORTEXT),
	680	GetPString(IDS_OUTOFMEMORY));
	681	break;
	682	}
	683	}
	684	}
	685	}
	686	if(stopflag && *stopflag)
	687	goto Abort;
	688	ulMaxFiles = ulM;
	689	DosError(FERR_DISABLEHARDERR);
	690	rc = DosFindNext(hdir, pffb, ulM * sizeof(FILEFINDBUF4),
	691	&ulMaxFiles);
	692	priority_normal();
	693	if(rc)
	694	DosError(FERR_DISABLEHARDERR);
	695	}
	696	DosFindClose(hdir);
	697
	698	if(pffb \|\| ppffb) {
	699	if(pffb)
	700	free(pffb);
	701	if(ppffb)
	702	free(ppffb);
	703	ppffb = NULL;
	704	pffb = NULL;
	705	}
	706
	707	if(ulTotal && pfTotal) {
	708	if(stopflag && *stopflag)
	709	goto Abort;
	710	pciFirst = WinSendMsg(hwndCnr, CM_ALLOCRECORD,
	711	MPFROMLONG(ulExtraBytes),
	712	MPFROMLONG(ulTotal));
	713	if(pciFirst) {
	714
	715	register INT i;
	716
	717	pci = pciFirst;
	718	totalbytes = 0L;
	719	tb = (PBYTE)pfTotal;
	720	for(i = 0; i < ulTotal; i++) {
	721	pffbFile = (PFILEFINDBUF4)tb;
	722	numbytes = FillInRecordFromFFB(hwndCnr,pci,szFileSpec,
	723	pffbFile,partial,dcd);
	724	if(numbytes > -1L) {
	725	pci = (PCNRITEM)pci->rc.preccNextRecord;
	726	totalbytes += numbytes;
	727	}
	728	else {
	729	General_Error(WinQueryAnchorBlock(hwndCnr),
	730	HWND_DESKTOP,
	731	__FILE__,
	732	__LINE__,
	733	GetPString(IDS_FILLDIRERR4TEXT),
	734	hwndCnr);
	735	ulTotal--;
	736	}
	737	tb += sizeof(FILEFINDBUF4);
	738	}
	739	if(ulTotal) {
	740	memset(&ri,0,sizeof(RECORDINSERT));
	741	ri.cb = sizeof(RECORDINSERT);
	742	ri.pRecordOrder = (PRECORDCORE) CMA_END;
	743	ri.pRecordParent = (PRECORDCORE) pciParent;
	744	ri.zOrder = (ULONG) CMA_TOP;
	745	ri.cRecordsInsert = ulTotal;
	746	ri.fInvalidateRecord = (!fSyncUpdates && dcd &&
	747	dcd->type == DIR_FRAME) ?
	748	FALSE : TRUE;
	749	if(!WinSendMsg(hwndCnr,CM_INSERTRECORD,
	750	MPFROMP(pciFirst),MPFROMP(&ri))) {
	751	DosSleep(100L);
	752	WinSetFocus(HWND_DESKTOP,hwndCnr);
	753	if(!WinSendMsg(hwndCnr,CM_INSERTRECORD,
	754	MPFROMP(pciFirst),MPFROMP(&ri))) {
	755	General_Error(WinQueryAnchorBlock(hwndCnr),
	756	HWND_DESKTOP,
	757	__FILE__,
	758	__LINE__,
	759	GetPString(IDS_FILLDIRERR5TEXT));
	760	totalbytes = -1L;
	761	if(WinIsWindow((HAB)0,hwndCnr)) {
	762	pci = pciFirst;
	763	while(pci) {
	764	pcit = (PCNRITEM)pci->rc.preccNextRecord;
	765	WinSendMsg(hwndCnr,CM_FREERECORD,
	766	MPFROMP(&pci),MPFROMSHORT(1));
	767	pci = pcit;
	768	}
	769	}
	770	}
	771	}
	772	}
	773	}
	774	else {
	775	General_Error(WinQueryAnchorBlock(hwndCnr),
	776	HWND_DESKTOP,
	777	__FILE__,
	778	__LINE__,
	779	GetPString(IDS_FILLDIRERR3TEXT));
	780	totalbytes = -1L;
	781	}
	782	if(totalbytes > -1L) {
	783	returnbytes += totalbytes;
	784	if(foundany)
	785	(*foundany) += ulMaxFiles;
	786	}
	787	}
	788	}
	789
	790	if(!fSyncUpdates && dcd && dcd->type == DIR_FRAME)
	791	WinSendMsg(hwndCnr,CM_INVALIDATERECORD,MPVOID,
	792	MPFROM2SHORT(0,CMA_ERASE));
	793	}
	794	Abort:
	795	if(pfTotal \|\| ppffb \|\| pffb \|\| szFileSpec) {
	796	if(pfTotal)
	797	free(pfTotal);
	798	if(szFileSpec)
	799	free(szFileSpec);
	800	if(pffb)
	801	free(pffb);
	802	if(ppffb)
	803	free(ppffb);
	804	}
	805	if(recurse) {
	806	pci = WinSendMsg(hwndCnr, CM_QUERYRECORD, MPFROMP(pciParent),
	807	MPFROM2SHORT(CMA_FIRSTCHILD, CMA_ITEMORDER));
	808	while(pci && (INT)pci != -1) {
	809	if(pci->attrFile & FILE_DIRECTORY)
	810	Stubby(hwndCnr,pci);
	811	pci = WinSendMsg(hwndCnr, CM_QUERYRECORD, MPFROMP(pci),
	812	MPFROM2SHORT(CMA_NEXT, CMA_ITEMORDER));
	813	}
	814	}
	815
	816	return returnbytes;
	817	}
	818
	819
	820	ULONG FillDirCnr (HWND hwndCnr,CHAR directory,DIRCNRDATA dcd) {
	821
	822	ULONG ret;
	823
	824	ret = ProcessDirectory(hwndCnr,(PCNRITEM)NULL,directory,TRUE,FALSE,TRUE,
	825	(dcd) ? &dcd->stopflag : NULL,dcd,NULL);
	826	DosPostEventSem(CompactSem);
	827	return ret;
	828	}
	829
	830
	831	ULONG FillTreeCnr (HWND hwndCnr,HWND hwndParent) {
	832
	833	ULONG ulDriveNum,ulDriveMap,numtoinsert = 0L,drvtype;
	834	PCNRITEM pci,pciFirst = NULL,pciNext,pciParent = NULL;
	835	INT x,removable;
	836	CHAR szDrive[] = " :\\",FileSystem[CCHMAXPATH],suggest[32];
	837	FILESTATUS4 fsa4;
	838	APIRET rc;
	839	BOOL drivesbuilt = FALSE;
	840	static BOOL didonce = FALSE;
	841
	842	fDummy = TRUE;
	843	*suggest = 0;
	844	for(x = 0;x < 26;x++)
	845	driveflags[x] &= (DRIVE_IGNORE \| DRIVE_NOPRESCAN \| DRIVE_NOLOADICONS \|
	846	DRIVE_NOLOADSUBJS \| DRIVE_NOLOADLONGS \|
	847	DRIVE_INCLUDEFILES \| DRIVE_SLOW);
	848	memset(driveserial,-1,sizeof(driveserial));
	849	{
	850	ULONG startdrive = 3L;
	851
	852	DosError(FERR_DISABLEHARDERR);
	853	if(!DosQuerySysInfo(QSV_BOOT_DRIVE,
	854	QSV_BOOT_DRIVE,
	855	(PVOID)&startdrive,
	856	(ULONG)sizeof(ULONG)) &&
	857	startdrive)
	858	driveflags[startdrive - 1] \|= DRIVE_BOOT;
	859	}
	860	DosError(FERR_DISABLEHARDERR);
	861	rc = DosQCurDisk(&ulDriveNum,
	862	&ulDriveMap);
	863	if(rc) {
	864	Dos_Error(MB_CANCEL,
	865	rc,
	866	HWND_DESKTOP,
	867	__FILE__,
	868	__LINE__,
	869	GetPString(IDS_FILLDIRERR6TEXT));
	870	exit(0);
	871	}
	872	for(x = 0;x < 26;x++)
	873	if((ulDriveMap & (1L << x)) && !(driveflags[x] & DRIVE_IGNORE))
	874	numtoinsert++;
	875	if(numtoinsert)
	876	pciFirst = WinSendMsg(hwndCnr,
	877	CM_ALLOCRECORD,
	878	MPFROMLONG(EXTRA_RECORD_BYTES2),
	879	MPFROMLONG((ULONG)numtoinsert));
	880	if(pciFirst) {
	881	pci = pciFirst;
	882	for(x = 0;x < 26;x++) {
	883	if((ulDriveMap & (1L << x)) && !(driveflags[x] & DRIVE_IGNORE)) {
	884	*szDrive = (CHAR)x + 'A';
	885
	886	{
	887	CHAR s[80];
	888	ULONG flags = 0,size = sizeof(ULONG);
	889
	890	sprintf(s,"%c.DriveFlags",toupper(*szDrive));
	891	if(PrfQueryProfileData(fmprof,appname,s,&flags,&size) &&
	892	size == sizeof(ULONG))
	893	driveflags[toupper(*szDrive) - 'A'] \|= flags;
	894	}
	895
	896	if(x > 1) {
	897	if(!(driveflags[x] & DRIVE_NOPRESCAN)) {
	898	*FileSystem = 0;
	899	drvtype = 0;
	900	removable = CheckDrive(*szDrive,FileSystem,&drvtype);
	901	driveserial[x] = -1;
	902	if(removable != -1) {
	903
	904	struct {
	905	ULONG serial;
	906	CHAR volumelength;
	907	CHAR volumelabel[CCHMAXPATH];
	908	} volser;
	909
	910	DosError(FERR_DISABLEHARDERR);
	911	if(!DosQueryFSInfo((ULONG)x,
	912	FSIL_VOLSER,
	913	&volser,
	914	sizeof(volser)))
	915	driveserial[x] = volser.serial;
	916	}
	917	else
	918	driveflags[x] \|= DRIVE_INVALID;
	919	memset(&fsa4,0,sizeof(FILESTATUS4));
	920	driveflags[x] \|= ((removable == -1 \|\| removable == 1) ?
	921	DRIVE_REMOVABLE : 0);
	922	if(drvtype & DRIVE_REMOTE)
	923	driveflags[x] \|= DRIVE_REMOTE;
	924	if(strcmp(FileSystem,HPFS) &&
	925	strcmp(FileSystem,HPFS386) &&
	926	strcmp(FileSystem,CDFS))
	927	driveflags[x] \|= DRIVE_NOLONGNAMES;
	928	if(!strcmp(FileSystem,CDFS)) {
	929	removable = 1;
	930	driveflags[x] \|= (DRIVE_REMOVABLE \| DRIVE_NOTWRITEABLE \|
	931	DRIVE_CDROM);
	932	}
	933	else if(!stricmp(FileSystem,CBSIFS)) {
	934	driveflags[x] \|= DRIVE_ZIPSTREAM;
	935	driveflags[x] &= (~DRIVE_REMOTE);
	936	if(drvtype & DRIVE_REMOVABLE)
	937	driveflags[x] \|= DRIVE_REMOVABLE;
	938	if(!(drvtype & DRIVE_NOLONGNAMES))
	939	driveflags[x] &= (~DRIVE_NOLONGNAMES);
	940	}
	941
	942	pci->rc.flRecordAttr \|= CRA_RECORDREADONLY;
	943	if((ULONG)(toupper(*pci->szFileName) - '@') == ulDriveNum)
	944	pci->rc.flRecordAttr \|= (CRA_CURSORED \| CRA_SELECTED);
	945
	946	if(removable == 0) {
	947	pci->attrFile \|= FILE_DIRECTORY;
	948	DosError(FERR_DISABLEHARDERR);
	949	rc = DosQueryPathInfo(szDrive,
	950	FIL_QUERYEASIZE,
	951	&fsa4,
	952	(ULONG)sizeof(FILESTATUS4));
	953	if(rc == 58) {
	954	DosError(FERR_DISABLEHARDERR);
	955	rc = DosQueryPathInfo(szDrive,
	956	FIL_STANDARD,
	957	&fsa4,
	958	(ULONG)sizeof(FILESTATUS3));
	959	fsa4.cbList = 0;
	960	}
	961	if(rc && !didonce) {
	962	if(!*suggest) {
	963	*suggest = '/';
	964	suggest[1] = 0;
	965	}
	966	sprintf(suggest + strlen(suggest),
	967	"%c",
	968	toupper(*szDrive));
	969	strcpy(pci->szFileName,szDrive);
	970	pci->pszFileName = pci->szFileName;
	971	pci->rc.pszIcon = pci->pszFileName;
	972	pci->attrFile = FILE_DIRECTORY;
	973	strcpy(pci->szDispAttr,"----D-");
	974	pci->pszDispAttr = pci->szDispAttr;
	975	driveserial[x] = -1;
	976	}
	977	else
	978	FillInRecordFromFSA(hwndCnr,
	979	pci,
	980	szDrive,
	981	&fsa4,
	982	TRUE,
	983	NULL);
	984	}
	985	else {
	986	strcpy(pci->szFileName,szDrive);
	987	pci->pszFileName = pci->szFileName;
	988	pci->rc.pszIcon = pci->pszFileName;
	989	pci->attrFile = FILE_DIRECTORY;
	990	strcpy(pci->szDispAttr,"----D-");
	991	pci->pszDispAttr = pci->szDispAttr;
	992	}
	993	pci->szFileName = toupper(pci->szFileName);
	994	if(driveflags[x] & DRIVE_CDROM)
	995	pci->rc.hptrIcon = hptrCDROM;
	996	else
	997	pci->rc.hptrIcon = (driveflags[x] & DRIVE_REMOVABLE) ?
	998	hptrRemovable :
	999	(driveflags[x] & DRIVE_REMOTE) ?
	1000	hptrRemote :
	1001	(driveflags[x] & DRIVE_ZIPSTREAM) ?
	1002	hptrZipstrm : hptrDrive;
	1003	}
	1004	else {
	1005	pci->rc.hptrIcon = hptrDunno;
	1006	strcpy(pci->szFileName,szDrive);
	1007	pci->pszFileName = pci->szFileName;
	1008	pci->rc.pszIcon = pci->pszFileName;
	1009	pci->attrFile = FILE_DIRECTORY;
	1010	strcpy(pci->szDispAttr,"----D-");
	1011	pci->pszDispAttr = pci->szDispAttr;
	1012	driveserial[x] = -1;
	1013	}
	1014	}
	1015	else {
	1016	pci->rc.hptrIcon = hptrFloppy;
	1017	strcpy(pci->szFileName,szDrive);
	1018	pci->pszFileName = pci->szFileName;
	1019	pci->rc.pszIcon = pci->pszFileName;
	1020	pci->attrFile = FILE_DIRECTORY;
	1021	strcpy(pci->szDispAttr,"----D-");
	1022	pci->pszDispAttr = pci->szDispAttr;
	1023	driveflags[x] \|= (DRIVE_REMOVABLE \| DRIVE_NOLONGNAMES);
	1024	driveserial[x] = -1;
	1025	}
	1026	pci->rc.flRecordAttr \|= CRA_RECORDREADONLY;
	1027	pci = (PCNRITEM)pci->rc.preccNextRecord; /* next rec */
	1028	}
	1029	else if(!(ulDriveMap & (1L << x)))
	1030	driveflags[x] \|= DRIVE_INVALID;
	1031	}
	1032	PostMsg(hwndMain,
	1033	UM_BUILDDRIVES,
	1034	MPVOID,
	1035	MPVOID);
	1036	drivesbuilt = TRUE;
	1037	/* insert the drives */
	1038	if(numtoinsert && pciFirst) {
	1039
	1040	RECORDINSERT ri;
	1041
	1042	memset(&ri,0,sizeof(RECORDINSERT));
	1043	ri.cb = sizeof(RECORDINSERT);
	1044	ri.pRecordOrder = (PRECORDCORE)CMA_END;
	1045	ri.pRecordParent = (PRECORDCORE)NULL;
	1046	ri.zOrder = (ULONG)CMA_TOP;
	1047	ri.cRecordsInsert = numtoinsert;
	1048	ri.fInvalidateRecord = FALSE;
	1049	if(!WinSendMsg(hwndCnr,
	1050	CM_INSERTRECORD,
	1051	MPFROMP(pciFirst),
	1052	MPFROMP(&ri)))
	1053	General_Error(WinQueryAnchorBlock(hwndCnr),
	1054	hwndCnr,
	1055	__FILE__,
	1056	__LINE__,
	1057	GetPString(IDS_FILLDIRERR5TEXT));
	1058	}
	1059	/* move cursor onto the default drive rather than the first drive */
	1060	if(!fSwitchTree) {
	1061	pci = (PCNRITEM)WinSendMsg(hwndCnr,
	1062	CM_QUERYRECORD,
	1063	MPVOID,
	1064	MPFROM2SHORT(CMA_FIRST,CMA_ITEMORDER));
	1065	while(pci && (INT)pci != -1) {
	1066	if((ULONG)(toupper(*pci->szFileName) - '@') == ulDriveNum) {
	1067	WinSendMsg(hwndCnr,
	1068	CM_SETRECORDEMPHASIS,
	1069	MPFROMP(pci),
	1070	MPFROM2SHORT(TRUE,CRA_CURSORED));
	1071	break;
	1072	}
	1073	pci = (PCNRITEM)WinSendMsg(hwndCnr,
	1074	CM_QUERYRECORD,
	1075	MPFROMP(pci),
	1076	MPFROM2SHORT(CMA_NEXT,CMA_ITEMORDER));
	1077	}
	1078	}
	1079
	1080	if(hwndParent)
	1081	WinSendMsg(WinWindowFromID(WinQueryWindow(hwndParent,QW_PARENT),
	1082	MAIN_DRIVELIST),
	1083	LM_DELETEALL,
	1084	MPVOID,
	1085	MPVOID);
	1086
	1087	if(fShowEnv) {
	1088
	1089	RECORDINSERT ri;
	1090
	1091	pciParent = WinSendMsg(hwndCnr,
	1092	CM_ALLOCRECORD,
	1093	MPFROMLONG(EXTRA_RECORD_BYTES2),
	1094	MPFROMLONG(1));
	1095	if(pciParent) {
	1096	pciParent->flags \|= RECFLAGS_ENV;
	1097	strcpy(pciParent->szFileName,GetPString(IDS_ENVVARSTEXT));
	1098	pciParent->pszFileName = pciParent->szFileName;
	1099	pciParent->rc.hptrIcon = hptrEnv;
	1100	pciParent->rc.pszIcon = pciParent->pszFileName;
	1101	strcpy(pciParent->szDispAttr,"------");
	1102	pciParent->pszDispAttr = pciParent->szDispAttr;
	1103	memset(&ri,0,sizeof(RECORDINSERT));
	1104	ri.cb = sizeof(RECORDINSERT);
	1105	ri.pRecordOrder = (PRECORDCORE)CMA_END;
	1106	ri.pRecordParent = (PRECORDCORE)NULL;
	1107	ri.zOrder = (ULONG)CMA_TOP;
	1108	ri.cRecordsInsert = 1;
	1109	ri.fInvalidateRecord = FALSE;
	1110	if(WinSendMsg(hwndCnr,
	1111	CM_INSERTRECORD,
	1112	MPFROMP(pciParent),
	1113	MPFROMP(&ri))) {
	1114
	1115	char p,pp;
	1116
	1117	p = GetPString(IDS_ENVVARNAMES);
	1118	while(*p == ' ')
	1119	p++;
	1120	while(*p) {
	1121	*FileSystem = 0;
	1122	pp = FileSystem;
	1123	while(p && p != ' ')
	1124	pp++ = p++;
	1125	*pp = 0;
	1126	while(*p == ' ')
	1127	p++;
	1128	if(*FileSystem &&
	1129	(!stricmp(FileSystem,"LIBPATH") \|\|
	1130	getenv(FileSystem))) {
	1131	pci = WinSendMsg(hwndCnr,
	1132	CM_ALLOCRECORD,
	1133	MPFROMLONG(EXTRA_RECORD_BYTES2),
	1134	MPFROMLONG(1));
	1135	if(pci) {
	1136	pci->flags \|= RECFLAGS_ENV;
	1137	sprintf(pci->szFileName,
	1138	"%%%s%%",
	1139	FileSystem);
	1140	pci->pszFileName = pci->szFileName;
	1141	pci->rc.hptrIcon = hptrEnv;
	1142	pci->rc.pszIcon = pci->pszFileName;
	1143	strcpy(pci->szDispAttr,"------");
	1144	pci->pszDispAttr = pci->szDispAttr;
	1145	memset(&ri,0,sizeof(RECORDINSERT));
	1146	ri.cb = sizeof(RECORDINSERT);
	1147	ri.pRecordOrder = (PRECORDCORE)CMA_END;
	1148	ri.pRecordParent = (PRECORDCORE)pciParent;
	1149	ri.zOrder = (ULONG)CMA_TOP;
	1150	ri.cRecordsInsert = 1;
	1151	ri.fInvalidateRecord = FALSE;
	1152	if(!WinSendMsg(hwndCnr,
	1153	CM_INSERTRECORD,
	1154	MPFROMP(pci),
	1155	MPFROMP(&ri))) {
	1156	General_Error(WinQueryAnchorBlock(hwndCnr),
	1157	hwndCnr,
	1158	__FILE__,
	1159	__LINE__,
	1160	GetPString(IDS_FILLDIRERR5TEXT));
	1161	WinSendMsg(hwndCnr,
	1162	CM_FREERECORD,
	1163	MPFROMP(&pci),
	1164	MPFROMSHORT(1));
	1165	}
	1166	}
	1167	}
	1168	}
	1169	WinSendMsg(hwndCnr,
	1170	CM_INVALIDATERECORD,
	1171	MPFROMP(&pciParent),
	1172	MPFROM2SHORT(1,CMA_ERASE \| CMA_REPOSITION));
	1173	}
	1174	else
	1175	WinSendMsg(hwndCnr,
	1176	CM_FREERECORD,
	1177	MPFROMP(&pciParent),
	1178	MPFROMSHORT(1));
	1179	}
	1180	}
	1181
	1182	x = 0;
	1183	pci = (PCNRITEM)WinSendMsg(hwndCnr,
	1184	CM_QUERYRECORD,
	1185	MPVOID,
	1186	MPFROM2SHORT(CMA_FIRST,
	1187	CMA_ITEMORDER));
	1188	while(pci && (INT)pci != -1) {
	1189	pciNext = (PCNRITEM)WinSendMsg(hwndCnr,
	1190	CM_QUERYRECORD,
	1191	MPFROMP(pci),
	1192	MPFROM2SHORT(CMA_NEXT,
	1193	CMA_ITEMORDER));
	1194	if(!(pci->flags & RECFLAGS_ENV)) {
	1195	if((ULONG)(toupper(*pci->szFileName) - '@') == ulDriveNum \|\|
	1196	toupper(*pci->szFileName) > 'B') {
	1197	if(!(driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_INVALID) &&
	1198	!(driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_NOPRESCAN) &&
	1199	(!fNoRemovableScan \|\|
	1200	!(driveflags[toupper(*pci->szFileName) - 'A'] & DRIVE_REMOVABLE))) {
	1201	if(!Stubby(hwndCnr,pci)) {
	1202	WinSendMsg(hwndCnr,
	1203	CM_INVALIDATERECORD,
	1204	MPFROMP(&pci),
	1205	MPFROM2SHORT(1,CMA_ERASE \| CMA_REPOSITION));
	1206	goto SkipBadRec;
	1207	}
	1208	}
	1209	}
	1210	else
	1211	WinSendMsg(hwndCnr,
	1212	CM_INVALIDATERECORD,
	1213	MPFROMP(&pci),
	1214	MPFROM2SHORT(1,CMA_ERASE \| CMA_REPOSITION));
	1215	WinSendMsg(WinWindowFromID(WinQueryWindow(hwndParent,QW_PARENT),
	1216	MAIN_DRIVELIST),
	1217	LM_INSERTITEM,
	1218	MPFROM2SHORT(LIT_SORTASCENDING,0),
	1219	MPFROMP(pci->szFileName));
	1220	}
	1221	SkipBadRec:
	1222	x++;
	1223	pci = pciNext;
	1224	}
	1225	if(hwndParent)
	1226	WinSendMsg(WinWindowFromID(WinQueryWindow(hwndParent,QW_PARENT),
	1227	MAIN_DRIVELIST),LM_SELECTITEM,MPFROM2SHORT(0,0),
	1228	MPFROMLONG(TRUE));
	1229
	1230	pci = (PCNRITEM)WinSendMsg(hwndCnr,
	1231	CM_QUERYRECORD,
	1232	MPVOID,
	1233	MPFROM2SHORT(CMA_FIRST,
	1234	CMA_ITEMORDER));
	1235	while(pci && (INT)pci != -1) {
	1236	pciNext = (PCNRITEM)WinSendMsg(hwndCnr,
	1237	CM_QUERYRECORD,
	1238	MPFROMP(pci),
	1239	MPFROM2SHORT(CMA_NEXT,
	1240	CMA_ITEMORDER));
	1241	if(pci->flags & RECFLAGS_ENV) {
	1242	pci = (PCNRITEM)WinSendMsg(hwndCnr,
	1243	CM_QUERYRECORD,
	1244	MPFROMP(pci),
	1245	MPFROM2SHORT(CMA_FIRSTCHILD,
	1246	CMA_ITEMORDER));
	1247	while(pci && (INT)pci != -1) {
	1248	if(pci->flags & RECFLAGS_ENV)
	1249	FleshEnv(hwndCnr,pci);
	1250	pci = (PCNRITEM)WinSendMsg(hwndCnr,
	1251	CM_QUERYRECORD,
	1252	MPFROMP(pci),
	1253	MPFROM2SHORT(CMA_NEXT,
	1254	CMA_ITEMORDER));
	1255	}
	1256	break;
	1257	}
	1258	pci = (PCNRITEM)WinSendMsg(hwndCnr,
	1259	CM_QUERYRECORD,
	1260	MPFROMP(pci),
	1261	MPFROM2SHORT(CMA_NEXT,
	1262	CMA_ITEMORDER));
	1263	}
	1264
	1265	}
	1266	else {
	1267	General_Error(WinQueryAnchorBlock(hwndCnr),
	1268	hwndCnr,
	1269	__FILE__,
	1270	__LINE__,
	1271	GetPString(IDS_FILLDIRERR7TEXT));
	1272	exit(0);
	1273	}
	1274	if(!drivesbuilt && hwndMain)
	1275	PostMsg(hwndMain,
	1276	UM_BUILDDRIVES,
	1277	MPVOID,
	1278	MPVOID);
	1279	DosSleep(33L);
	1280	fDummy = FALSE;
	1281	DosPostEventSem(CompactSem);
	1282	{
	1283	BYTE info;
	1284	BOOL includesyours = FALSE;
	1285
	1286	if(*suggest \|\|
	1287	(!(driveflags[1] & DRIVE_IGNORE) &&
	1288	fFirstTime)) {
	1289	if(!DosDevConfig(&info,
	1290	DEVINFO_FLOPPY) &&
	1291	info == 1) {
	1292	if(!*suggest) {
	1293	*suggest = '/';
	1294	suggest[1] = 0;
	1295	}
	1296	else
	1297	memmove(suggest + 2,suggest + 1,strlen(suggest));
	1298	suggest[1] = 'B';
	1299	}
	1300	}
	1301	if(*suggest) {
	1302	for(x = 2;x < 26;x++) {
	1303	if(driveflags[x] & DRIVE_IGNORE) {
	1304	includesyours = TRUE;
	1305	sprintf(suggest + strlen(suggest),
	1306	"%c",
	1307	(char)(x + 'A'));
	1308	}
	1309	}
	1310	strcat(suggest," %*");
	1311	if(saymsg(MB_YESNO \| MB_ICONEXCLAMATION,
	1312	(hwndParent) ? hwndParent : hwndCnr,
	1313	GetPString(IDS_SUGGESTTITLETEXT),
	1314	GetPString(IDS_SUGGEST1TEXT),
	1315	(includesyours) ?
	1316	GetPString(IDS_SUGGEST2TEXT) :
	1317	NullStr,
	1318	suggest) == MBID_YES) {
	1319
	1320	char s[64];
	1321
	1322	sprintf(s,
	1323	"PARAMETERS=%s",
	1324	suggest);
	1325	WinCreateObject(WPProgram,
	1326	"FM/2",
	1327	s,
	1328	FM3Folder,
	1329	CO_UPDATEIFEXISTS);
	1330	WinCreateObject(WPProgram,
	1331	"FM/2 Lite",
	1332	s,
	1333	FM3Folder,
	1334	CO_UPDATEIFEXISTS);
	1335	WinCreateObject(WPProgram,
	1336	"Archive Viewer/2",
	1337	s,
	1338	FM3Tools,
	1339	CO_UPDATEIFEXISTS);
	1340	WinCreateObject(WPProgram,
	1341	"Dir Sizes",
	1342	s,
	1343	FM3Tools,
	1344	CO_UPDATEIFEXISTS);
	1345	WinCreateObject(WPProgram,
	1346	"Visual Tree",
	1347	s,
	1348	FM3Tools,
	1349	CO_UPDATEIFEXISTS);
	1350	WinCreateObject(WPProgram,
	1351	"Visual Directory",
	1352	s,
	1353	FM3Tools,
	1354	CO_UPDATEIFEXISTS);
	1355	WinCreateObject(WPProgram,
	1356	"Global File Viewer",
	1357	s,
	1358	FM3Tools,
	1359	CO_UPDATEIFEXISTS);
	1360	WinCreateObject(WPProgram,
	1361	"Databar",
	1362	s,
	1363	FM3Tools,
	1364	CO_UPDATEIFEXISTS);
	1365	}
	1366	}
	1367	}
	1368	didonce = TRUE;
	1369	return 0L;
	1370	}
	1371

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

Download in other formats: