Context Navigation

source: trunk/dll/filldir.c@ 51

Visit:

Last change on this file since 51 was 51, checked in by root, 23 years ago
Standardize EA match
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 49.1 KB

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

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

Download in other formats: