Context Navigation

source: trunk/dll/datamin.c@ 396

Visit:

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

Rev	Line
[30]	1
	2	/***********************************************************************
	3
	4	$Id: datamin.c 396 2006-07-28 18:42:35Z root $
	5
	6	Minimized data bar
	7
	8	Copyright (c) 1993-98 M. Kimes
[346]	9	Copyright (c) 2001, 2006 Steven H. Levine
[30]	10
[130]	11	14 Sep 02 SHL Handle large partitions
	12	16 Oct 02 SHL Handle large partitions better
	13	23 May 05 SHL Use QWL_USER
[136]	14	23 May 05 SHL Avoid delays for inaccessible drives
[162]	15	25 May 05 SHL Use ULONGLONG and CommaFmtULL
[204]	16	06 Jun 05 SHL Drop unused code
[346]	17	22 Jul 06 SHL Check more run time errors
[30]	18
	19	***********************************************************************/
	20
[2]	21	#define INCL_DOS
[136]	22	#define INCL_DOSERRORS
[2]	23	#define INCL_WIN
	24	#define INCL_GPI
[162]	25	#define INCL_LONGLONG
	26	#include <os2.h>
[2]	27
	28	#include <stdio.h>
	29	#include <stdlib.h>
	30	#include <string.h>
	31	#include <ctype.h>
	32	#include <limits.h>
[136]	33
[2]	34	#include "fm3dll.h"
	35	#include "fm3dlg.h"
	36	#include "fm3str.h"
	37	#include "procstat.h"
[136]	38	#include "datamin.h"
[2]	39
	40	#pragma data_seg(DATA2)
[346]	41
	42	static PSZ pszSrcFile = __FILE__;
	43
[2]	44	#pragma alloc_text(DATAMIN,DataDlgProc,MiniTimeProc)
	45
[136]	46	APIRET16 APIENTRY16 Dos16MemAvail(PULONG pulAvailMem);
[2]	47
[136]	48	static volatile HEV G_hevDataMin = NULLHANDLE;
	49	static volatile HWND G_hwndSingle = NULLHANDLE;
[2]	50
[136]	51	static VOID dataminThread (VOID *pv);
[2]	52
[136]	53	long MINI_X = 208, MINI_Y = 16;
[2]	54
[136]	55	//=== MiniTimeProc - time, swap and drive status mini windows procedure ===
[2]	56
[136]	57	MRESULT EXPENTRY MiniTimeProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
	58	{
	59	APIRET rc;
	60	switch (msg)
	61	{
	62	case WM_CREATE:
	63	{
[346]	64	PVOID pv = xmalloc(sizeof(tDataMin),pszSrcFile,__LINE__);
[136]	65	WinSetWindowPtr(hwnd, QWL_DATAMIN_PTR, pv);
	66	}
	67	break;
[2]	68
[136]	69	case WM_BUTTON1CLICK:
	70	{
	71	USHORT id = WinQueryWindowUShort(hwnd, QWS_ID);
	72
	73	if (id >= MINI_DRIVEA)
[2]	74	{
[136]	75	if (G_hevDataMin != NULLHANDLE)
	76	{
	77	G_hwndSingle = hwnd;
	78	rc = DosPostEventSem(G_hevDataMin);
	79	if (rc)
	80	{
	81	Dos_Error(MB_ENTER,
	82	rc,
	83	HWND_DESKTOP,
[346]	84	pszSrcFile,
[136]	85	__LINE__,
	86	"Post Semaphore failed" // GetPString(IDS_POSTSEMFAILED)
	87	);
	88	}
	89	}
	90	}
	91	else if (id == MINI_TIME)
	92	PostMsg(WinQueryWindow(hwnd, QW_PARENT),
	93	UM_SETUP6, // Up time
	94	MPVOID,
	95	MPVOID);
	96	else if (id == MINI_PROC)
	97	WinSendMsg(WinQueryWindow(hwnd, QW_PARENT),
	98	WM_SYSCOMMAND,
	99	MPFROM2SHORT(SC_TASKMANAGER, 0),
	100	MPVOID);
	101	}
	102	break;
[2]	103
[136]	104	case WM_BUTTON1DBLCLK:
	105	{
	106	USHORT id = WinQueryWindowUShort(hwnd, QWS_ID);
[2]	107
[136]	108	if (id >= MINI_DRIVEA && !hwndMain)
	109	{
	110	CHAR s[] = " :\\";
[2]	111
[136]	112	*s = (CHAR) (id - MINI_DRIVEA) + 'A';
[396]	113	OpenDirCnr((HWND)0,
[136]	114	HWND_DESKTOP,
[396]	115	(HWND)0,
[136]	116	FALSE,
	117	s);
	118	return MRFROMLONG(1L);
	119	}
	120	else if (id == MINI_TIME)
	121	{
	122	OpenObject("<WP_CLOCK>",
	123	(SHORT2FROMMP(mp2) & KC_SHIFT) ?
	124	Default : Settings,
	125	hwnd);
	126	return MRFROMLONG(1L);
	127	}
[2]	128
	129	#ifdef NEVER
[136]	130	else if (id == MINI_MEM)
	131	{
	132	WinDlgBox(HWND_DESKTOP,
	133	HWND_DESKTOP,
	134	SysInfoDlgProc,
	135	FM3ModHandle,
	136	SYS_FRAME,
	137	NULL);
	138	return MRFROMLONG(1L);
	139	}
[2]	140	#endif
	141
[136]	142	else if (id == MINI_PROC \|\| id == MINI_MEM)
	143	{
	144	WinDlgBox(HWND_DESKTOP,
	145	hwnd,
	146	KillDlgProc,
	147	FM3ModHandle,
	148	KILL_FRAME,
	149	NULL);
	150	return MRFROMLONG(1L);
	151	}
	152	else if (id == MINI_SWAP && *SwapperDat)
	153	{
[2]	154
[136]	155	char s[5];
[2]	156
[136]	157	strncpy(s, SwapperDat, 4);
	158	s[3] = 0;
	159	WinDlgBox(HWND_DESKTOP,
	160	hwndMain,
	161	UndeleteDlgProc,
	162	FM3ModHandle,
	163	UNDEL_FRAME,
	164	MPFROMP(s));
	165	return MRFROMLONG(1L);
[2]	166	}
[136]	167	}
	168	break;
[2]	169
[136]	170	case WM_BUTTON1MOTIONSTART:
	171	PostMsg(WinQueryWindow(hwnd, QW_PARENT),
	172	UM_BUTTON1MOTIONSTART,
	173	MPVOID,
	174	MPVOID);
	175	break;
[2]	176
[136]	177	case WM_CONTEXTMENU:
	178	PostMsg(WinQueryWindow(hwnd, QW_PARENT),
	179	UM_CONTEXTMENU,
	180	MPVOID,
	181	MPVOID);
	182	break;
[2]	183
[136]	184	case WM_PAINT:
	185	{
	186	MRESULT mr = 0;
	187	USHORT id;
	188
	189	id = WinQueryWindowUShort(hwnd, QWS_ID);
	190	if (id >= MINI_DRIVEA)
[2]	191	{
[136]	192	HPS hps = WinBeginPaint(hwnd, (HPS) 0, NULL);
	193	if (hps)
	194	{
	195	mr = WinSendMsg(WinQueryWindow(hwnd, QW_PARENT),
	196	UM_PAINT,
	197	MPFROM2SHORT(id, 0),
	198	MPFROMLONG(hps));
	199	WinEndPaint(hps);
	200	return mr; // Bypass default paint
	201	}
	202	}
	203	}
	204	break;
[2]	205
[136]	206	case WM_DESTROY:
	207	{
	208	PVOID pv = WinQueryWindowPtr(hwnd, QWL_DATAMIN_PTR);
[346]	209	xfree(pv);
[2]	210	}
[136]	211	break;
[2]	212	}
[136]	213	return PFNWPStatic(hwnd, msg, mp1, mp2);
[2]	214
[136]	215	} // MiniTimeProc
[2]	216
[136]	217	//=== DataProc - databar client window procedure ===
[2]	218
[136]	219	MRESULT EXPENTRY DataProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
	220	{
	221	APIRET rc;
	222
[2]	223	static ULONG counter;
[136]	224	static BOOL NoFloat, noqproc = FALSE, Positioned;
[396]	225	static HWND hwndMenu = (HWND)0;
[2]	226
[136]	227	switch (msg)
	228	{
	229	case WM_CREATE:
[377]	230	if (DataHwnd) {
[136]	231	WinSetWindowPos(DataHwnd,
	232	HWND_TOP,
	233	0,
	234	0,
	235	0,
	236	0,
	237	SWP_ZORDER \| SWP_SHOW);
	238	return MRFROMLONG(1L);
	239	}
	240	DataHwnd = WinQueryWindow(hwnd, QW_PARENT);
	241	NoFloat = FALSE;
	242	Positioned = FALSE;
	243	SetPresParams(hwnd,
	244	&RGBGREY,
	245	&RGBBLACK,
	246	&RGBBLACK,
	247	GetPString(IDS_8HELVTEXT));
	248	{
	249	int c;
	250	long x = 3;
	251	USHORT ids[] = {MINI_TIME, MINI_MEM, MINI_SWAP, MINI_PROC, 0};
	252	POINTL aptl[TXTBOX_COUNT];
	253	HPS hps;
	254
	255	hps = WinGetPS(hwnd);
	256	if (hps)
	257	{
	258	GpiQueryTextBox(hps,
	259	34,
	260	" -=03:08:22 SMW 1998/08/02=- ",
	261	TXTBOX_COUNT,
	262	aptl);
	263	WinReleasePS(hps);
	264	MINI_X = aptl[TXTBOX_TOPRIGHT].x + 6;
	265	MINI_Y = aptl[TXTBOX_TOPRIGHT].y + 6;
[2]	266	}
[136]	267	for (c = 0; ids[c]; c++)
[2]	268	{
[377]	269	if (!WinCreateWindow(hwnd,
[136]	270	GetPString(IDS_WCMINITIME),
	271	NullStr,
	272	SS_TEXT \| DT_CENTER \| DT_VCENTER \| WS_VISIBLE,
	273	x,
	274	3,
	275	MINI_X,
	276	MINI_Y,
	277	hwnd,
	278	HWND_TOP,
	279	ids[c],
	280	NULL,
[377]	281	NULL))
	282	{
	283	Win_Error2(hwnd,hwnd,pszSrcFile,__LINE__,IDS_WINCREATEWINDOW);
	284	}
[136]	285	x += (MINI_X + 4);
[2]	286	}
[136]	287	}
	288	if (!hwndMain)
	289	{
	290	SWCNTRL swctl;
[2]	291
[136]	292	memset(&swctl, 0, sizeof(swctl));
	293	swctl.hwnd = WinQueryWindow(hwnd, QW_PARENT);
	294	swctl.uchVisibility = SWL_VISIBLE;
	295	swctl.fbJump = (fDataToFore) ? SWL_NOTJUMPABLE : SWL_JUMPABLE;
	296	swctl.bProgType = PROG_PM;
	297	strcpy(swctl.szSwtitle,
	298	GetPString(IDS_DATABARTITLETEXT));
	299	WinCreateSwitchEntry(WinQueryAnchorBlock(hwnd),
	300	&swctl);
	301	}
	302	PostMsg(hwnd,
	303	UM_SETUP,
	304	MPVOID,
	305	MPVOID);
	306	return 0;
[2]	307
[136]	308	case WM_MENUEND:
	309	NoFloat = FALSE;
[396]	310	if (hwndMenu == (HWND)mp2)
[136]	311	{
	312	WinDestroyWindow(hwndMenu);
[396]	313	hwndMenu = (HWND)0;
[136]	314	}
	315	break;
	316
	317	case UM_RESTORE:
	318	WinSetWindowPtr(hwnd, QWL_USER, mp1);
	319	return 0;
	320
	321	case UM_SETUP:
	322	{
	323	long x, y;
	324	SWP swp, swpD;
	325	int c;
	326	ULONG size = sizeof(SWP);
	327	ULONG numdrives = 0;
	328	ULONG drivestyle = (DRIVE_REMOVABLE \| DRIVE_INVALID \|
	329	DRIVE_IGNORE \| DRIVE_ZIPSTREAM);
	330	ULONG ulDriveNum, ulDriveMap;
	331
	332	if (!fDataInclRemote)
	333	drivestyle \|= DRIVE_REMOTE;
	334	if (fDataShowDrives)
	335	{
	336	DosError(FERR_DISABLEHARDERR);
	337	DosQCurDisk(&ulDriveNum, &ulDriveMap);
	338	x = 3;
	339	y = MINI_Y + 4;
	340	// Drive status windows
	341	for (c = 2; c < 26; c++)
	342	{
	343	if ((ulDriveMap & (1L << c)) && !(driveflags[c] & drivestyle))
	344	{
[377]	345	if (!WinCreateWindow(hwnd,
[136]	346	GetPString(IDS_WCMINITIME),
	347	NullStr,
	348	SS_TEXT \| DT_CENTER \| DT_VCENTER \| WS_VISIBLE,
	349	x,
	350	y,
	351	MINI_X,
	352	MINI_Y,
	353	hwnd,
	354	HWND_TOP,
	355	MINI_DRIVEA + c,
	356	NULL,
[377]	357	NULL))
	358	{
	359	Win_Error2(hwnd,hwnd,pszSrcFile,__LINE__,IDS_WINCREATEWINDOW);
	360	}
[136]	361	numdrives++;
	362	x += (MINI_X + 4);
	363	if ((numdrives % 4) == 0)
	364	{
	365	y += (MINI_Y + 4);
	366	x = 3;
	367	}
	368	}
	369	}
[2]	370	}
[136]	371	x = (MINI_X * 4) + 18;
	372	y = (MINI_Y + 4) + ((numdrives / 4) * (MINI_Y + 4)) +
	373	(((numdrives % 4) != 0) * (MINI_Y + 4));
	374	if (!Positioned)
	375	{
	376	if (PrfQueryProfileData(fmprof,
	377	appname,
	378	"DataMinPos",
	379	&swp,
	380	&size))
	381	{
	382	WinQueryWindowPos(HWND_DESKTOP, &swpD);
	383	if (swp.x > swpD.cx - 16)
	384	swp.x = swpD.cx - 16;
	385	if (swp.y > swpD.cy - 16)
	386	swp.y = swpD.cy - 16;
	387	WinSetWindowPos(WinQueryWindow(hwnd, QW_PARENT),
	388	HWND_TOP,
	389	swp.x,
	390	swp.y,
	391	x,
	392	y,
	393	SWP_SIZE \| SWP_MOVE \| SWP_SHOW \| SWP_ZORDER);
	394	}
	395	else
	396	WinSetWindowPos(WinQueryWindow(hwnd, QW_PARENT),
	397	HWND_TOP,
	398	0,
	399	0,
	400	x,
	401	y,
	402	SWP_SHOW \| SWP_SIZE \| SWP_MOVE \| SWP_ZORDER);
	403	Positioned = TRUE;
	404	}
	405	else
	406	WinSetWindowPos(WinQueryWindow(hwnd, QW_PARENT),
	407	HWND_TOP,
	408	0,
	409	0,
	410	x,
	411	y,
	412	SWP_SHOW \| SWP_SIZE \| SWP_ZORDER);
	413	WinShowWindow(WinQueryWindow(hwnd, QW_PARENT),
	414	TRUE);
	415	if (numdrives) {
[346]	416	if (_beginthread(dataminThread,NULL,32768,(PVOID)hwnd) == -1) {
	417	Runtime_Error(pszSrcFile, __LINE__, GetPString(IDS_COULDNTSTARTTHREADTEXT));
	418	PostMsg(hwnd,WM_CLOSE,MPVOID,MPVOID);
[136]	419	}
	420	}
	421	counter = 0;
[2]	422	PostMsg(hwnd,
[136]	423	UM_TIMER,
	424	MPVOID,
	425	MPVOID);
	426	}
	427	return 0; // UM_SETUP
	428
	429	case WM_BUTTON1DBLCLK:
	430	if (hwndMain)
	431	PostMsg(hwnd,
	432	WM_CLOSE,
	433	MPVOID,
	434	MPVOID);
	435	break;
	436
	437	case UM_CONTEXTMENU:
	438	case WM_CONTEXTMENU:
	439	if (!hwndMenu)
	440	hwndMenu = WinLoadMenu(HWND_DESKTOP,
	441	FM3ModHandle,
	442	MINI_FRAME);
	443	if (hwndMenu)
	444	{
	445	WinCheckMenuItem(hwndMenu,
	446	MINI_FLOAT,
	447	fDataToFore);
	448	WinCheckMenuItem(hwndMenu,
	449	MINI_SHOW,
	450	fDataShowDrives);
	451	WinCheckMenuItem(hwndMenu,
	452	MINI_BORING,
	453	fDullMin);
	454	WinCheckMenuItem(hwndMenu,
	455	MINI_INCLREMOTE,
	456	fDataInclRemote);
	457	NoFloat = TRUE;
	458	if (!PopupMenu(hwnd,
	459	hwnd,
	460	hwndMenu))
	461	NoFloat = FALSE;
	462	}
	463	if (msg == UM_CONTEXTMENU)
[2]	464	return 0;
[136]	465	break;
[2]	466
[136]	467	case WM_BUTTON2DBLCLK:
	468	if (!(SHORT2FROMMP(mp2) & KC_SHIFT))
	469	{
	470	PostMsg(hwnd,
	471	WM_COMMAND,
	472	MPFROM2SHORT(MINI_FLOAT, 0),
	473	MPVOID);
[2]	474	break;
[136]	475	}
	476	/* else intentional fallthru */
	477	case WM_CHORD:
	478	case WM_BUTTON3DBLCLK:
	479	PostMsg(hwnd,
	480	WM_COMMAND,
	481	MPFROM2SHORT(MINI_SHOW, 0),
	482	MPVOID);
	483	break;
[2]	484
[136]	485	case UM_BUTTON1MOTIONSTART:
	486	case WM_BUTTON1MOTIONSTART:
	487	{
	488	TRACKINFO TrackInfo;
	489	SWP Position;
[2]	490
[136]	491	memset(&TrackInfo, 0, sizeof(TrackInfo));
	492	TrackInfo.cxBorder = 1;
	493	TrackInfo.cyBorder = 1;
	494	TrackInfo.cxGrid = 1;
	495	TrackInfo.cyGrid = 1;
	496	TrackInfo.cxKeyboard = 8;
	497	TrackInfo.cyKeyboard = 8;
	498	WinQueryWindowPos(WinQueryWindow(hwnd, QW_PARENT), &Position);
	499	TrackInfo.rclTrack.xLeft = Position.x;
	500	TrackInfo.rclTrack.xRight = Position.x + Position.cx;
	501	TrackInfo.rclTrack.yBottom = Position.y;
	502	TrackInfo.rclTrack.yTop = Position.y + Position.cy;
	503	WinQueryWindowPos(HWND_DESKTOP, &Position);
	504	TrackInfo.rclBoundary.xLeft = Position.x;
	505	TrackInfo.rclBoundary.xRight = Position.x + Position.cx;
	506	TrackInfo.rclBoundary.yBottom = Position.y;
	507	TrackInfo.rclBoundary.yTop = Position.y + Position.cy;
	508	TrackInfo.ptlMinTrackSize.x = 0;
	509	TrackInfo.ptlMinTrackSize.y = 0;
	510	TrackInfo.ptlMaxTrackSize.x = Position.cx;
	511	TrackInfo.ptlMaxTrackSize.y = Position.cy;
	512	TrackInfo.fs = TF_MOVE \| TF_STANDARD \| TF_ALLINBOUNDARY;
	513	if (WinTrackRect(HWND_DESKTOP, (HPS) 0, &TrackInfo))
[2]	514	{
[136]	515	WinSetWindowPos(WinQueryWindow(hwnd, QW_PARENT),
	516	HWND_TOP, TrackInfo.rclTrack.xLeft,
	517	TrackInfo.rclTrack.yBottom, 0, 0, SWP_MOVE);
	518	WinSendMsg(hwnd, WM_SAVEAPPLICATION, MPVOID, MPVOID);
	519	}
	520	}
	521	break;
[2]	522
[136]	523	case WM_HELP:
	524	PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(IDM_HELP, 0), MPVOID);
	525	break;
	526
	527	case WM_COMMAND:
	528	switch (SHORT1FROMMP(mp1))
	529	{
	530	case IDM_COMMANDLINE:
	531	case IDM_DOSCOMMANDLINE:
	532	case IDM_WINFULLSCREEN:
	533	{
	534	CHAR *env = GetCmdSpec(FALSE), path[CCHMAXPATH];
	535	INT type = SEPARATE \| WINDOWED;
	536
	537	*path = 0;
	538	TopWindowName(hwnd,
[396]	539	(HWND)0,
[136]	540	path);
	541	if (SHORT1FROMMP(mp1) == IDM_DOSCOMMANDLINE)
	542	env = GetCmdSpec(TRUE);
	543	else if (SHORT1FROMMP(mp1) != IDM_COMMANDLINE)
	544	{
	545	env = "WINOS2.COM";
	546	type = SEPARATE \| FULLSCREEN;
	547	}
	548	runemf2(type,
	549	hwnd,
	550	path,
	551	NULL,
	552	"%s",
	553	env);
[2]	554	}
[136]	555	break;
[2]	556
[136]	557	case IDM_HELP:
	558	if (hwndHelp)
	559	WinSendMsg(hwndHelp,
	560	HM_DISPLAY_HELP,
	561	MPFROM2SHORT(HELP_DATABAR, 0),
	562	MPFROMSHORT(HM_RESOURCEID));
[2]	563	break;
	564
[136]	565	case MINI_CLOSE:
	566	PostMsg(hwnd,
	567	WM_CLOSE,
	568	MPVOID,
	569	MPVOID);
[2]	570	break;
	571
[136]	572	case MINI_BORING:
	573	fDullMin = (fDullMin) ? FALSE : TRUE;
	574	PrfWriteProfileData(fmprof,
	575	FM3Str,
	576	"DullDatabar",
	577	&fDullMin,
	578	sizeof(BOOL));
	579	if (G_hevDataMin != NULLHANDLE)
	580	{
	581	rc = DosPostEventSem(G_hevDataMin);
	582	if (rc) {
	583	Dos_Error(MB_ENTER,
	584	rc,
	585	HWND_DESKTOP,
[346]	586	pszSrcFile,
[136]	587	__LINE__,
	588	"Post Semaphore failed" // GetPString(IDS_POSTSEMFAILED)
	589	);
	590	}
[2]	591	}
[136]	592
[2]	593	break;
	594
[136]	595	case MINI_INCLREMOTE:
	596	case MINI_SHOW:
	597	if (SHORT1FROMMP(mp1) == MINI_SHOW)
[2]	598	{
[136]	599	fDataShowDrives = (fDataShowDrives) ? FALSE : TRUE;
	600	PrfWriteProfileData(fmprof,
	601	appname,
	602	"DataShowDrives",
	603	&fDataShowDrives,
	604	sizeof(BOOL));
	605	}
	606	else
	607	{
	608	fDataInclRemote = (fDataInclRemote) ? FALSE : TRUE;
	609	PrfWriteProfileData(fmprof,
	610	appname,
	611	"DataInclRemote",
	612	&fDataInclRemote,
	613	sizeof(BOOL));
	614	}
	615	{
	616	HENUM henum;
	617	HWND hwndChild;
	618	USHORT id;
[2]	619
[136]	620	henum = WinBeginEnumWindows(hwnd);
	621	while ((hwndChild = WinGetNextWindow(henum)) != NULLHANDLE)
	622	{
	623	id = WinQueryWindowUShort(hwndChild, QWS_ID);
	624	if (id >= MINI_DRIVEA)
	625	WinDestroyWindow(hwndChild);
	626	}
	627	WinEndEnumWindows(henum);
[2]	628	}
[136]	629	PostMsg(hwnd, UM_SETUP, MPVOID, MPVOID);
[2]	630	break;
	631
[136]	632	case MINI_FLOAT:
	633	fDataToFore = (fDataToFore) ? FALSE : TRUE;
	634	PrfWriteProfileData(fmprof,
	635	appname,
	636	"DataToFore",
	637	&fDataToFore,
	638	sizeof(BOOL));
	639	if (!hwndMain)
	640	{
	641
	642	SWCNTRL swcntrl;
	643	HSWITCH hswitch;
	644
	645	hswitch = (HSWITCH) WinQuerySwitchHandle(hwnd, (PID) 0);
	646	if (hswitch)
	647	{
	648	memset(&swcntrl, 0, sizeof(SWCNTRL));
	649	if (!WinQuerySwitchEntry(hswitch, &swcntrl))
	650	{
	651	swcntrl.fbJump = (fDataToFore) ? SWL_NOTJUMPABLE : SWL_JUMPABLE;
	652	WinChangeSwitchEntry(hswitch,
	653	&swcntrl);
	654	}
	655	}
	656	}
[2]	657	break;
[136]	658	}
	659	return 0;
[2]	660
[136]	661	case WM_SIZE:
	662	WinSetWindowPos(hwnd,
	663	HWND_TOP,
	664	0,
	665	0,
	666	SHORT1FROMMP(mp2),
	667	SHORT2FROMMP(mp2),
	668	SWP_MOVE \| SWP_SIZE);
	669	break;
[2]	670
[136]	671	case WM_PAINT:
	672	{
	673	HPS hps;
	674	POINTL ptl;
	675	SWP swp;
	676	RECTL rcl;
[2]	677
[136]	678	hps = WinBeginPaint(hwnd,
	679	(HPS) 0,
	680	&rcl);
	681	if (hps)
	682	{
	683	WinFillRect(hps,
	684	(PRECTL) & rcl,
	685	CLR_PALEGRAY);
	686	GpiSetMix(hps, FM_OVERPAINT);
	687	GpiSetColor(hps, CLR_WHITE);
	688	WinQueryWindowPos(hwnd, &swp);
	689	ptl.x = 0;
	690	ptl.y = 0;
	691	GpiMove(hps, &ptl);
	692	ptl.y = swp.cy - 1;
	693	GpiLine(hps, &ptl);
	694	ptl.x = swp.cx - 1;
	695	GpiLine(hps, &ptl);
	696	GpiSetColor(hps, CLR_DARKGRAY);
	697	ptl.y = 0;
	698	GpiLine(hps, &ptl);
	699	ptl.x = 0;
	700	GpiLine(hps, &ptl);
	701	{
	702	HENUM henum;
	703	HWND hwndTemp;
[2]	704
[136]	705	henum = WinBeginEnumWindows(hwnd);
	706	while ((hwndTemp = WinGetNextWindow(henum)) != NULLHANDLE)
	707	{
	708	PaintRecessedWindow(hwndTemp,
	709	hps,
	710	(WinQueryWindowUShort(hwndTemp, QWS_ID)
	711	!= MINI_TIME),
	712	FALSE);
	713	}
	714	WinEndEnumWindows(henum);
	715	}
	716	WinEndPaint(hps);
	717	}
	718	}
	719	return 0;
[2]	720
[136]	721	case UM_PAINT:
	722	{
	723	CHAR s[90];
	724	CHAR szFreeQty[38];
	725	CHAR szDrvLtr[] = " :";
	726	CHAR *pszFSystem;
[162]	727	ULONGLONG ullFreeQty;
[136]	728	ULONG ulPercentFree;
	729	ULONG wasx;
	730	HPS hps = (HPS) mp2;
	731	HWND hwndChild;
	732	USHORT id;
	733	SWP swp;
	734	POINTL ptl;
	735	tDataMin *pDM;
[2]	736
[136]	737	id = SHORT1FROMMP(mp1);
	738	if (id >= MINI_DRIVEA)
	739	{
	740	hwndChild = WinWindowFromID(hwnd, id);
	741	if (!hwndChild)
	742	return 0;
	743	if (!WinQueryWindowPos(hwndChild, &swp))
	744	return 0;
	745	pDM = WinQueryWindowPtr(hwndChild, QWL_DATAMIN_PTR);
	746	if (!pDM \|\| pDM -> qfsi_rc)
	747	{
[162]	748	ullFreeQty = 0;
[136]	749	ulPercentFree = 0;
	750	}
	751	else
	752	{
[162]	753	ullFreeQty = (ULONGLONG)pDM -> fsa.cUnitAvail *
[136]	754	(pDM -> fsa.cSectorUnit * pDM -> fsa.cbSector);
[2]	755
[136]	756	ulPercentFree = (pDM -> fsa.cUnit && pDM -> fsa.cUnitAvail) ?
	757	(pDM -> fsa.cUnitAvail * 100) / pDM -> fsa.cUnit :
	758	0;
	759	}
[2]	760
[162]	761	CommaFmtULL(szFreeQty, sizeof(szFreeQty), ullFreeQty,' ');
[136]	762	*szDrvLtr = (CHAR)(id - MINI_DRIVEA) + 'A';
[2]	763
[136]	764	if (!pDM \|\| pDM -> qfsi_rc \|\| pDM -> qfsa_rc)
	765	pszFSystem = "N/A";
	766	else
	767	{
	768	pszFSystem = pDM -> fsqb2.szName +
	769	pDM -> fsqb2.cbName + 1;
	770	pszFSystem[15] = 0;
	771	}
	772	sprintf(s,
[162]	773	" %s %s (%lu%%) %s [%s]",
[136]	774	szDrvLtr,
	775	szFreeQty,
	776	ulPercentFree,
	777	GetPString(IDS_FREETEXT),
	778	pszFSystem);
	779	if (!hps)
	780	hps = WinGetPS(hwndChild);
	781	if (hps)
	782	{
	783	if (!fDullMin)
	784	{
	785	ptl.x = 0;
	786	ptl.y = 0;
	787	GpiMove(hps,
	788	&ptl);
	789	GpiSetColor(hps,
	790	CLR_BLACK);
	791	ptl.x = swp.cx - 1;
	792	ptl.y = swp.cy - 1;
	793	GpiBox(hps,
	794	DRO_OUTLINE,
	795	&ptl,
	796	0,
	797	0);
	798	ptl.x = 1;
	799	ptl.y = 1;
	800	if (ulPercentFree)
	801	{
	802	GpiMove(hps, &ptl);
	803	GpiSetColor(hps,
	804	(ulPercentFree < 11) ? CLR_DARKRED :
	805	(ulPercentFree < 26) ? CLR_DARKBLUE :
	806	CLR_DARKGREEN);
	807	ptl.y = swp.cy - 2;
	808	ptl.x = ((swp.cx - 2) * ulPercentFree) / 100;
	809	wasx = ptl.x;
	810	GpiBox(hps,
	811	DRO_OUTLINEFILL,
	812	&ptl,
	813	0,
	814	0);
	815	GpiSetColor(hps,
	816	(ulPercentFree < 11) ? CLR_RED :
	817	(ulPercentFree < 26) ? CLR_BLUE : CLR_GREEN);
	818	ptl.x = wasx;
	819	ptl.y = swp.cy - 2;
	820	GpiMove(hps,
	821	&ptl);
	822	ptl.x = 1;
	823	GpiLine(hps,
	824	&ptl);
	825	ptl.y = 2;
	826	ptl.x = 1;
	827	GpiLine(hps,
	828	&ptl);
	829	ptl.x = wasx;
	830	}
	831	if (ulPercentFree < 99)
	832	{
	833	GpiSetColor(hps,
	834	CLR_DARKGRAY);
	835	wasx = ptl.x;
	836	ptl.y = 2;
	837	GpiMove(hps, &ptl);
	838	ptl.y = swp.cy - 2;
	839	ptl.x = swp.cx - 2;
	840	GpiBox(hps,
	841	DRO_OUTLINEFILL,
	842	&ptl,
	843	0,
	844	0);
	845	ptl.x = wasx;
	846	GpiMove(hps,
	847	&ptl);
	848	GpiSetColor(hps,
	849	CLR_PALEGRAY);
	850	ptl.x = swp.cx - 3;
	851	GpiLine(hps, &ptl);
	852	ptl.x = wasx;
	853	ptl.y = 1;
	854	GpiMove(hps, &ptl);
	855	GpiSetColor(hps,
	856	CLR_BLACK);
	857	ptl.x = swp.cx - 2;
	858	GpiLine(hps, &ptl);
	859	ptl.y = swp.cy - 3;
	860	GpiLine(hps, &ptl);
	861	}
	862	GpiSetColor(hps,
	863	CLR_WHITE);
	864	}
	865	else
	866	{
	867	GpiSetColor(hps,
	868	CLR_PALEGRAY);
	869	ptl.x = 0;
	870	ptl.y = 0;
	871	GpiMove(hps,
	872	&ptl);
	873	ptl.x = swp.cx - 1;
	874	ptl.y = swp.cy - 1;
	875	GpiBox(hps,
	876	DRO_OUTLINEFILL,
	877	&ptl,
	878	0,
	879	0);
	880	GpiSetColor(hps,
	881	(ulPercentFree < 11) ? CLR_DARKRED :
	882	CLR_DARKBLUE);
	883	}
	884	GpiSetBackMix(hps,
	885	BM_LEAVEALONE);
	886	GpiSetMix(hps,
	887	FM_OVERPAINT);
	888	{
	889	POINTL aptl[TXTBOX_COUNT];
[2]	890
[136]	891	GpiQueryTextBox(hps,
	892	strlen(s),
	893	s,
	894	TXTBOX_COUNT,
	895	aptl);
	896	ptl.y = ((swp.cy / 2) -
	897	((aptl[TXTBOX_TOPRIGHT].y +
	898	aptl[TXTBOX_BOTTOMLEFT].y) / 2));
	899	ptl.y++;
	900	ptl.x = (swp.cx / 2) - (aptl[TXTBOX_TOPRIGHT].x / 2);
	901	if (ptl.x < 2)
	902	ptl.x = 2;
	903	GpiCharStringAt(hps,
	904	&ptl,
	905	strlen(s),
	906	s);
	907	}
	908	if (!mp2)
	909	WinReleasePS(hps);
	910	}
	911	} // if drive window
	912	}
	913	return 0;
	914
	915	case UM_TIMER:
	916	{
	917	CHAR s[134];
	918	DATETIME dt;
	919
	920	if (fDataToFore && !NoFloat)
	921	WinSetWindowPos(WinQueryWindow(hwnd, QW_PARENT),
	922	HWND_TOP, 0, 0, 0, 0, SWP_ZORDER);
	923	if (counter && (counter % 19) && (counter % 20))
	924	{
	925	if (!DosGetDateTime(&dt))
	926	{
	927	sprintf(s,
	928	" %02hu:%02hu:%02hu %s %04u/%02u/%02u",
	929	dt.hours,
	930	dt.minutes,
	931	dt.seconds,
	932	GetPString(IDS_SUNDAY + dt.weekday),
	933	dt.year,
	934	dt.month,
	935	dt.day);
	936	WinSetDlgItemText(hwnd,
	937	MINI_TIME,
	938	s);
	939	}
[2]	940	}
[136]	941	else if (!counter \|\| !(counter % 19))
	942	PostMsg(hwnd, UM_SETUP6, MPVOID, MPVOID); // Uptime
	943	if (!(counter % 4))
	944	{
	945	PostMsg(hwnd, UM_SETUP3, MPVOID, MPVOID); // Memory utilization
	946	if (!(counter % 10))
	947	{
	948	PostMsg(hwnd, UM_SETUP5, MPVOID, MPVOID); // Process status
	949	if (!(counter % 20))
	950	{
	951	PostMsg(hwnd, UM_SETUP2, MPVOID, MPVOID); // Swapper
	952	}
	953	}
	954	}
	955	}
	956	counter++;
	957	return 0;
[2]	958
[136]	959	case UM_SETUP2:
	960	{
[204]	961	CHAR s[134], szFileQty[38], szFreeQty[38];
[136]	962	FILEFINDBUF3 ffb;
	963	ULONG nm = 1L;
[162]	964	ULONGLONG ullFreeQty;
[136]	965	HDIR hdir = HDIR_CREATE;
	966	FSALLOCATE fsa;
[2]	967
[136]	968	if (*SwapperDat)
[2]	969	{
[136]	970	DosError(FERR_DISABLEHARDERR);
	971	if (!DosFindFirst(SwapperDat, &hdir, FILE_NORMAL \| FILE_HIDDEN \|
	972	FILE_SYSTEM \| FILE_ARCHIVED \| FILE_READONLY,
	973	&ffb, sizeof(ffb), &nm, FIL_STANDARD))
	974	{
	975	priority_bumped();
	976	DosFindClose(hdir);
	977	DosError(FERR_DISABLEHARDERR);
	978	if (!DosQueryFSInfo(toupper(*SwapperDat) - '@', FSIL_ALLOC,
	979	&fsa, sizeof(FSALLOCATE)))
	980	{
[162]	981	ullFreeQty = (ULONGLONG)fsa.cUnitAvail * (fsa.cSectorUnit * fsa.cbSector);
	982	CommaFmtULL(szFreeQty, sizeof(szFreeQty), ullFreeQty,' ');
[136]	983	}
	984	else
[162]	985	*szFreeQty = 0;
	986
	987	CommaFmtULL(szFileQty, sizeof(szFileQty), ffb.cbFile,' ');
	988	sprintf(s, " %s %s%s%s",
[136]	989	GetPString(IDS_SWAPTITLETEXT),
	990	szFileQty,
[162]	991	*szFreeQty ? "/" : NullStr,
	992	szFreeQty);
	993	WinSetDlgItemText(hwnd,MINI_SWAP,s);
[136]	994	}
	995	}
	996	}
	997	return 0;
[2]	998
[136]	999	case UM_SETUP3: // Memory utilization
	1000	{
[162]	1001	CHAR s[134], tm[38], szQty[38];
[136]	1002	ULONG amem = 0;
[2]	1003
[136]	1004	if (!DosQuerySysInfo(QSV_TOTAVAILMEM, QSV_TOTAVAILMEM,
	1005	(PVOID) & amem, (ULONG) sizeof(amem)))
	1006	{
[162]	1007	CommaFmtUL(tm, sizeof(tm), amem,'M');
	1008	if (!Dos16MemAvail(&amem))
	1009	CommaFmtUL(szQty, sizeof(szQty), amem,'M');
[136]	1010	else
[162]	1011	*szQty = 0;
	1012	sprintf(s, " %s%s%s%s",
[136]	1013	GetPString(IDS_MEMTITLETEXT),
	1014	szQty,
	1015	(*szQty) ? "/" : NullStr,
[162]	1016	tm);
[136]	1017	WinSetDlgItemText(hwnd,
	1018	MINI_MEM,
	1019	s);
[2]	1020	}
[136]	1021	}
	1022	return 0;
[2]	1023
[136]	1024	case UM_SETUP5: // Process status
	1025	{
	1026	CHAR s[134], tm[38], szQty[38];
	1027
	1028	if (fUseQProcStat && !noqproc)
[2]	1029	{
	1030
[136]	1031	PROCESSINFO *ppi;
	1032	BUFFHEADER *pbh = NULL;
	1033	MODINFO *pmi;
	1034	ULONG numprocs = 0, numthreads = 0;
[346]	1035	APIRET rc;
[136]	1036
[346]	1037	rc = DosAllocMem((PVOID) & pbh, USHRT_MAX + 4096,
	1038	PAG_COMMIT \| OBJ_TILE \| PAG_READ \| PAG_WRITE);
	1039	if (rc)
	1040	Dos_Error(MB_CANCEL,rc,hwnd,pszSrcFile,__LINE__,GetPString(IDS_OUTOFMEMORY));
	1041	else
[136]	1042	{
[346]	1043	if (DosQProcStatus(pbh, USHRT_MAX))
	1044	noqproc = TRUE;
	1045	else {
[136]	1046	ppi = pbh -> ppi;
	1047	while (ppi -> ulEndIndicator != PROCESS_END_INDICATOR)
[36]	1048	{
[136]	1049	pmi = pbh -> pmi;
	1050	while (pmi && ppi -> hModRef != pmi -> hMod)
	1051	pmi = pmi -> pNext;
	1052	if (pmi)
	1053	{
	1054	numprocs++;
	1055	numthreads += ppi -> usThreadCount;
	1056	}
	1057	ppi = (PPROCESSINFO) (ppi -> ptiFirst + ppi -> usThreadCount);
[36]	1058	}
[136]	1059	commafmt(szQty, sizeof(szQty), numprocs);
	1060	commafmt(tm, sizeof(tm), numthreads);
	1061	sprintf(s,
	1062	" %s%s %s%s",
	1063	GetPString(IDS_PROCSTITLETEXT),
	1064	szQty,
	1065	GetPString(IDS_THRDSTITLETEXT),
	1066	tm);
	1067	WinSetDlgItemText(hwnd,
	1068	MINI_PROC,
	1069	s);
	1070	}
	1071	DosFreeMem(pbh);
	1072	}
[2]	1073	}
[136]	1074	else
[2]	1075	{
[136]	1076	commafmt(szQty, sizeof(szQty),
	1077	WinQuerySwitchList(WinQueryAnchorBlock(hwnd), (PSWBLOCK) 0, 0));
	1078	sprintf(s,
	1079	" %s%s",
	1080	GetPString(IDS_TASKSTITLETEXT),
	1081	szQty);
	1082	WinSetDlgItemText(hwnd,
	1083	MINI_PROC,
	1084	s);
[2]	1085	}
[136]	1086	}
	1087	return 0;
[2]	1088
[136]	1089	case UM_SETUP6: // Uptime
	1090	{
	1091	ULONG val = 0, numdays, nummins;
	1092	CHAR s[128];
	1093
	1094	if (!DosQuerySysInfo(QSV_MS_COUNT,
	1095	QSV_MS_COUNT,
	1096	(PVOID) & val,
	1097	(ULONG) sizeof(val)))
[2]	1098	{
[136]	1099	val /= 60000L;
	1100	numdays = val / (60L * 24L);
	1101	strcpy(s, GetPString(IDS_ELAPSEDTITLETEXT));
	1102	if (numdays)
	1103	sprintf(s + strlen(s),
	1104	" %lu %s%s, ",
	1105	numdays,
	1106	GetPString(IDS_DAYTEXT),
	1107	&"s"[numdays == 1L]);
	1108	nummins = val % (60L * 24L);
	1109	sprintf(s + strlen(s),
	1110	" %lu:%02lu",
	1111	nummins / 60,
	1112	nummins % 60);
	1113	WinSetDlgItemText(hwnd,
	1114	MINI_TIME,
	1115	s);
[2]	1116	}
[136]	1117	}
	1118	return 0;
[2]	1119
[136]	1120	case WM_SAVEAPPLICATION:
	1121	{
	1122	SWP swp;
[2]	1123
[136]	1124	WinQueryWindowPos(WinQueryWindow(hwnd, QW_PARENT), &swp);
	1125	PrfWriteProfileData(fmprof,
	1126	appname,
	1127	"DataMinPos",
	1128	&swp,
	1129	sizeof(SWP));
	1130	}
	1131	break;
[2]	1132
[136]	1133	case WM_CLOSE:
	1134	WinSendMsg(hwnd,
	1135	WM_SAVEAPPLICATION,
	1136	MPVOID,
	1137	MPVOID);
	1138	WinDestroyWindow(WinQueryWindow(hwnd, QW_PARENT));
	1139	return 0;
[2]	1140
[136]	1141	case WM_DESTROY:
	1142	if (DataHwnd == WinQueryWindow(hwnd, QW_PARENT))
	1143	{
	1144	DataHwnd = (HWND)0;
	1145	if (hwndMenu)
	1146	WinDestroyWindow(hwndMenu);
	1147	hwndMenu = (HWND)0;
	1148	}
	1149	if (hwndMain)
	1150	{
[2]	1151
[136]	1152	SWP swp;
	1153	ULONG fl = SWP_SHOW \| SWP_ZORDER \| SWP_ACTIVATE, ofl;
[2]	1154
[136]	1155	ofl = WinQueryWindowULong(hwnd, QWL_USER);
	1156	WinQueryWindowPos(WinQueryWindow(hwndMain, QW_PARENT), &swp);
	1157	if (swp.fl & SWP_MINIMIZE)
	1158	fl \|= ((ofl & SWP_MAXIMIZE) ? SWP_MAXIMIZE : SWP_RESTORE);
	1159	WinSetWindowPos(WinQueryWindow(hwndMain, QW_PARENT),
	1160	HWND_TOP,
	1161	0,
	1162	0,
	1163	0,
	1164	0,
	1165	fl);
	1166	}
	1167	else if (!PostMsg((HWND)0,
	1168	WM_QUIT,
	1169	MPVOID,
	1170	MPVOID))
	1171	WinSendMsg((HWND)0,
	1172	WM_QUIT,
	1173	MPVOID,
	1174	MPVOID);
	1175	break;
	1176	}
	1177	return WinDefWindowProc(hwnd, msg, mp1, mp2);
[2]	1178
[136]	1179	} // DataProc
[2]	1180
[136]	1181	//=== CreateDataBar - create databar windows ===
[2]	1182
[136]	1183	HWND CreateDataBar(HWND hwndParent, ULONG fl)
	1184	{
[396]	1185	HWND hwndClient = (HWND)0;
[136]	1186	ULONG FrameFlags = 0;
[2]	1187
[136]	1188	if (WinCreateStdWindow(hwndParent,
	1189	WS_VISIBLE,
	1190	&FrameFlags,
	1191	GetPString(IDS_WCDATABAR),
	1192	NULL,
	1193	WS_VISIBLE,
	1194	0,
	1195	MINI_FRAME,
	1196	&hwndClient))
	1197	{
	1198	WinSendMsg(hwndClient,
	1199	UM_RESTORE,
	1200	MPFROMLONG(fl),
	1201	MPVOID);
	1202	}
	1203	return hwndClient;
[2]	1204
[136]	1205	} // CreateDataBar
[2]	1206
[136]	1207	//=== dataminThread - drive status thread ===
[2]	1208
[136]	1209	static VOID dataminThread (VOID *pv)
	1210	{
	1211	HAB hab = NULLHANDLE;
	1212	HMQ hmq = NULLHANDLE;
	1213	HWND hwndParent = (HWND)pv;
	1214	HWND hwnd;
	1215	HENUM henum;
	1216	BOOL busy = TRUE;
	1217	APIRET rc;
	1218	USHORT id;
	1219
	1220	if (G_hevDataMin == NULLHANDLE)
	1221	{
	1222	// Create just once for any thread that might use it
	1223	// Kernel will clean up on exit
	1224	rc = DosCreateEventSem(NULL,(PHEV)&G_hevDataMin,0L,FALSE);
	1225	if (rc) {
	1226	Dos_Error(MB_ENTER,
	1227	rc,
	1228	HWND_DESKTOP,
[346]	1229	pszSrcFile,
[136]	1230	__LINE__,
	1231	"Create Semaphore failed" // GetPString(IDS_CREATESEMFAILED)
	1232	);
	1233	busy = FALSE;
	1234	}
	1235	}
	1236
[179]	1237	// fixme to report errors
[136]	1238	hab = WinInitialize(0);
	1239	if (hab == NULLHANDLE)
	1240	busy = FALSE;
	1241	else
	1242	{
	1243	hmq = WinCreateMsgQueue(hab,0);
	1244	if (hmq == NULLHANDLE)
	1245	busy = FALSE;
	1246	else
	1247	WinCancelShutdown(hmq,TRUE);
	1248	}
	1249
	1250	while (busy)
	1251	{
	1252	HWND hwndSingle = G_hwndSingle;
	1253	G_hwndSingle = NULLHANDLE;
	1254
	1255	busy = FALSE;
	1256
	1257	if (!WinIsWindow(hab,hwndParent))
[2]	1258	break;
	1259
[136]	1260	henum = WinBeginEnumWindows(hwndParent);
	1261	while(henum && (hwnd = WinGetNextWindow(henum)) != NULLHANDLE)
	1262	{
	1263	if (!WinIsWindow(hab,hwnd))
	1264	continue;
	1265	if (hwndSingle && hwndSingle != hwnd)
	1266	continue;
	1267	id = WinQueryWindowUShort(hwnd,QWS_ID);
	1268	if (id > MINI_DRIVEA )
	1269	{
	1270	ULONG dskNum = id - MINI_DRIVEA + 1;
	1271	tDataMin *pDM = WinQueryWindowPtr(hwnd, QWL_DATAMIN_PTR);
	1272	SWP swp;
	1273	CHAR szPath[] = " :";
	1274	if (!pDM)
	1275	continue;
	1276	busy = TRUE;
	1277	if (!WinQueryWindowPos(hwnd, &swp))
	1278	continue;
[2]	1279
[136]	1280	DosError(FERR_DISABLEHARDERR);
	1281	pDM -> qfsi_rc = DosQueryFSInfo(dskNum,
	1282	FSIL_ALLOC,
	1283	&pDM -> fsa,
	1284	sizeof(FSALLOCATE));
[2]	1285
[136]	1286	if (!pDM -> qfsi_rc)
	1287	{
	1288	*szPath = (CHAR) dskNum + 'A' - 1;
	1289	pDM -> qfsa_cb = sizeof(FSQBUFFER2) + 256; // se tDataMin
	1290	DosError(FERR_DISABLEHARDERR);
	1291	pDM -> qfsa_rc = DosQueryFSAttach(szPath,
	1292	0, /* Ordinal */
	1293	FSAIL_QUERYNAME,
	1294	&pDM -> fsqb2,
	1295	&pDM -> qfsa_cb);
	1296	}
	1297	WinInvalidateRect(hwnd, NULL, FALSE);
	1298	} // if drive window
	1299	} // while henum
	1300	WinEndEnumWindows(henum);
[2]	1301
[136]	1302	if (busy)
	1303	{
	1304	ULONG clPosted;
	1305	rc = DosWaitEventSem(G_hevDataMin,20000L);
	1306	if (rc && rc != ERROR_TIMEOUT)
	1307	{
	1308	Dos_Error(MB_ENTER,
	1309	rc,
	1310	HWND_DESKTOP,
[346]	1311	pszSrcFile,
[136]	1312	__LINE__,
	1313	"Wait Semaphore failed" // GetPString(IDS_POSTSEMFAILED)
	1314	);
[2]	1315	}
	1316
[136]	1317	rc = DosResetEventSem(G_hevDataMin,&clPosted);
	1318	if (rc && rc != ERROR_ALREADY_RESET)
	1319	{
	1320	Dos_Error(MB_ENTER,
	1321	rc,
	1322	HWND_DESKTOP,
[346]	1323	pszSrcFile,
[136]	1324	__LINE__,
	1325	"Reset Semaphore failed" // GetPString(IDS_POSTSEMFAILED)
	1326	);
	1327	}
	1328	}
[2]	1329
[136]	1330	} // while
[2]	1331
[136]	1332	if (hmq != NULLHANDLE)
	1333	WinDestroyMsgQueue(hmq);
[2]	1334
[136]	1335	if (hab != NULLHANDLE)
	1336	WinTerminate(hab);
	1337
	1338	} // dataminThread

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

Download in other formats: