Context Navigation

source: trunk/dll/datamin.c@ 1627

Visit:

Last change on this file since 1627 was 1627, checked in by Gregg Young, 14 years ago
Add a low mem version of xDosAlloc* wrappers; move error checking into all the xDosAlloc* wrappers. Ticket 471
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 30.0 KB

Line
1
2	/***********************************************************************
3
4	$Id: datamin.c 1627 2011-08-26 21:48:06Z gyoung $
5
6	Minimized data bar
7
8	Copyright (c) 1993-98 M. Kimes
9	Copyright (c) 2001, 2010 Steven H. Levine
10
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
14	23 May 05 SHL Avoid delays for inaccessible drives
15	25 May 05 SHL Use ULONGLONG and CommaFmtULL
16	06 Jun 05 SHL Drop unused code
17	22 Jul 06 SHL Check more run time errors
18	02 Jan 07 GKY Changed drive information string formating to accomodate 6 char FS names
19	07 Jan 07 GKY Move error strings etc. to string file
20	30 Mar 07 GKY Remove GetPString for window class names
21	20 Aug 07 GKY Move #pragma alloc_text to end for OpenWatcom compat
22	02 Sep 07 GKY Replaced DosQProcStatus with DosQuerySysState to fix trap in thunk code
23	10 Dec 08 SHL Integrate exception handler support
24	03 Jan 09 GKY Check for system that is protectonly to gray out Dos/Win command lines and prevent
25	Dos/Win programs from being inserted into the execute dialog with message why.
26	11 Jan 09 GKY Replace font names in the string file with global set at compile in init.c
27	07 Feb 09 GKY Eliminate Win_Error2 by moving function names to PCSZs used in Win_Error
28	07 Feb 09 GKY Add *DateFormat functions to format dates based on locale
29	08 Mar 09 GKY Renamed commafmt.h i18nutil.h
30	12 Jul 09 GKY Add xDosQueryAppType and xDosAlloc... to allow FM/2 to load in high memory
31	13 Dec 09 GKY Fixed separate paramenters. Please note that appname should be used in
32	profile calls for user settings that work and are setable in more than one
33	miniapp; FM3Str should be used for setting only relavent to FM/2 or that
34	aren't user settable; realappname should be used for setting applicable to
35	one or more miniapp but not to FM/2
36	17 JAN 10 GKY Changes to get working with Watcom 1.9 Beta (1/16/10). Mostly cast CHAR CONSTANT * as CHAR *.
37	26 Aug 11 GKY Add a low mem version of xDosAlloc* wrappers; move error checking into all the
38	xDosAlloc* wrappers.
39
40	***********************************************************************/
41
42	#include <string.h>
43	#include <ctype.h>
44	#include <limits.h>
45	// #include <process.h> // _beginthread
46
47	#define INCL_DOS
48	#define INCL_DOSERRORS
49	#define INCL_WIN
50	#define INCL_GPI
51	#define INCL_LONGLONG
52
53	#include "fm3dll.h"
54	#include "fm3dll2.h" // #define's for UM_*, control id's, etc.
55	#include "info.h" // Data declaration(s)
56	#include "notebook.h" // Data declaration(s)
57	#include "inis.h" // Data declaration(s)
58	#include "init.h" // Data declaration(s)
59	#include "defview.h" // Data declaration(s)
60	#include "fm3dlg.h"
61	#include "fm3str.h"
62	#include "procstat.h"
63	#include "datamin.h"
64	#include "errutil.h" // Dos_Error...
65	#include "strutil.h" // GetPString
66	#include "i18nutil.h" // CommaFmtUL
67	#include "killproc.h" // KillDlgProc
68	#include "sysinfo.h" // SysInfoDlgProc
69	#include "mainwnd.h" // TopWindowName
70	#include "common.h" // OpenDirCnr
71	#include "shadow.h" // OpenObject
72	#include "chklist.h" // PopupMenu
73	#include "presparm.h" // SetPresParams
74	#include "undel.h" // UndeleteDlgProc
75	#include "misc.h" // GetCmdSpec
76	#include "wrappers.h" // xDosFindFirst
77	#include "systemf.h" // runemf2
78	#include "fortify.h"
79	#include "excputil.h" // 06 May 08 SHL added
80
81	APIRET16 APIENTRY16 Dos16MemAvail(PULONG pulAvailMem);
82
83	static volatile HEV G_hevDataMin = NULLHANDLE;
84	static volatile HWND G_hwndSingle = NULLHANDLE;
85
86	static VOID dataminThread(VOID * pv);
87
88	// Data definitions
89	#pragma data_seg(GLOBAL1)
90	HWND DataHwnd;
91	BOOL fDataInclRemote;
92	BOOL fDataShowDrives;
93	BOOL fDataToFore;
94	BOOL fDullMin;
95
96	#pragma data_seg(DATA2)
97
98	static PSZ pszSrcFile = __FILE__;
99
100	long MINI_X = 208, MINI_Y = 16;
101
102	//=== MiniTimeProc - time, swap and drive status mini windows procedure ===
103
104	MRESULT EXPENTRY MiniTimeProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
105	{
106	APIRET rc;
107
108	switch (msg) {
109	case WM_CREATE:
110	{
111	PVOID pv = xmalloc(sizeof(tDataMin), pszSrcFile, __LINE__);
112	if (pv)
113	WinSetWindowPtr(hwnd, QWL_DATAMIN_PTR, pv);
114	}
115	break;
116
117	case WM_BUTTON1CLICK:
118	{
119	USHORT id = WinQueryWindowUShort(hwnd, QWS_ID);
120
121	if (id >= MINI_DRIVEA) {
122	if (G_hevDataMin != NULLHANDLE) {
123	G_hwndSingle = hwnd;
124	rc = DosPostEventSem(G_hevDataMin);
125	if (rc) {
126	Dos_Error(MB_ENTER, rc, HWND_DESKTOP, pszSrcFile, __LINE__,
127	GetPString(IDS_POSTSEMFAILED));
128	}
129	}
130	}
131	else if (id == MINI_TIME)
132	PostMsg(WinQueryWindow(hwnd, QW_PARENT), UM_SETUP6, // Up time
133	MPVOID, MPVOID);
134	else if (id == MINI_PROC)
135	WinSendMsg(WinQueryWindow(hwnd, QW_PARENT),
136	WM_SYSCOMMAND, MPFROM2SHORT(SC_TASKMANAGER, 0), MPVOID);
137	}
138	break;
139
140	case WM_BUTTON1DBLCLK:
141	{
142	USHORT id = WinQueryWindowUShort(hwnd, QWS_ID);
143
144	if (id >= MINI_DRIVEA && !hwndMain) {
145	CHAR s[] = " :\\";
146
147	*s = (CHAR) (id - MINI_DRIVEA) + 'A';
148	OpenDirCnr((HWND) 0, HWND_DESKTOP, (HWND) 0, FALSE, s);
149	return MRFROMLONG(1L);
150	}
151	else if (id == MINI_TIME) {
152	OpenObject("<WP_CLOCK>",
153	(SHORT2FROMMP(mp2) & KC_SHIFT) ? Default : Settings, hwnd);
154	return MRFROMLONG(1L);
155	}
156
157	#ifdef NEVER
158	else if (id == MINI_MEM) {
159	WinDlgBox(HWND_DESKTOP,
160	HWND_DESKTOP,
161	SysInfoDlgProc, FM3ModHandle, SYS_FRAME, NULL);
162	return MRFROMLONG(1L);
163	}
164	#endif
165
166	else if (id == MINI_PROC \|\| id == MINI_MEM) {
167	WinDlgBox(HWND_DESKTOP,
168	hwnd, KillDlgProc, FM3ModHandle, KILL_FRAME, NULL);
169	return MRFROMLONG(1L);
170	}
171	else if (id == MINI_SWAP && *SwapperDat) {
172
173	char s[5];
174
175	strncpy(s, SwapperDat, 4);
176	s[3] = 0;
177	WinDlgBox(HWND_DESKTOP,
178	hwndMain,
179	UndeleteDlgProc, FM3ModHandle, UNDEL_FRAME, MPFROMP(s));
180	return MRFROMLONG(1L);
181	}
182	}
183	break;
184
185	case WM_BUTTON1MOTIONSTART:
186	PostMsg(WinQueryWindow(hwnd, QW_PARENT),
187	UM_BUTTON1MOTIONSTART, MPVOID, MPVOID);
188	break;
189
190	case WM_CONTEXTMENU:
191	PostMsg(WinQueryWindow(hwnd, QW_PARENT), UM_CONTEXTMENU, MPVOID, MPVOID);
192	break;
193
194	case WM_PAINT:
195	{
196	MRESULT mr = 0;
197	USHORT id;
198
199	id = WinQueryWindowUShort(hwnd, QWS_ID);
200	if (id >= MINI_DRIVEA) {
201	HPS hps = WinBeginPaint(hwnd, (HPS) 0, NULL);
202
203	if (hps) {
204	mr = WinSendMsg(WinQueryWindow(hwnd, QW_PARENT),
205	UM_PAINT, MPFROM2SHORT(id, 0), MPFROMLONG(hps));
206	WinEndPaint(hps);
207	return mr; // Bypass default paint
208	}
209	}
210	}
211	break;
212
213	case WM_DESTROY:
214	{
215	PVOID pv = WinQueryWindowPtr(hwnd, QWL_DATAMIN_PTR);
216
217	xfree(pv, pszSrcFile, __LINE__);
218	}
219	break;
220	}
221	return PFNWPStatic(hwnd, msg, mp1, mp2);
222
223	} // MiniTimeProc
224
225	//=== DataProc - databar client window procedure ===
226
227	MRESULT EXPENTRY DataProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
228	{
229	APIRET rc;
230
231	static ULONG counter;
232	static BOOL NoFloat, noqproc = FALSE, Positioned;
233	static HWND hwndMenu = (HWND) 0;
234
235	switch (msg) {
236	case WM_CREATE:
237	if (DataHwnd) {
238	WinSetWindowPos(DataHwnd, HWND_TOP, 0, 0, 0, 0, SWP_ZORDER \| SWP_SHOW);
239	return MRFROMLONG(1L);
240	}
241	DataHwnd = WinQueryWindow(hwnd, QW_PARENT);
242	NoFloat = FALSE;
243	Positioned = FALSE;
244	//fixme to allow user to change presparams 1-10-09 GKY
245	SetPresParams(hwnd,
246	&RGBGREY, &RGBBLACK, &RGBBLACK, FNT_8HELVETICA);
247	{
248	int c;
249	long x = 3;
250	USHORT ids[] = { MINI_TIME, MINI_MEM, MINI_SWAP, MINI_PROC, 0 };
251	POINTL aptl[TXTBOX_COUNT];
252	HPS hps;
253
254	hps = WinGetPS(hwnd);
255	if (hps) {
256	GpiQueryTextBox(hps,
257	34,
258	" -=03:08:22 SMW 1998/08/02=- ",
259	TXTBOX_COUNT, aptl);
260	WinReleasePS(hps);
261	MINI_X = aptl[TXTBOX_TOPRIGHT].x + 6;
262	MINI_Y = aptl[TXTBOX_TOPRIGHT].y + 6;
263	}
264	for (c = 0; ids[c]; c++) {
265	if (!WinCreateWindow(hwnd,
266	(CHAR *) WC_MINITIME,
267	NullStr,
268	SS_TEXT \| DT_CENTER \| DT_VCENTER \| WS_VISIBLE,
269	x,
270	3,
271	MINI_X,
272	MINI_Y, hwnd, HWND_TOP, ids[c], NULL, NULL)) {
273	Win_Error(hwnd, hwnd, pszSrcFile, __LINE__,
274	PCSZ_WINCREATEWINDOW);
275	}
276	x += (MINI_X + 4);
277	}
278	}
279	if (!hwndMain) {
280	SWCNTRL swctl;
281
282	memset(&swctl, 0, sizeof(swctl));
283	swctl.hwnd = WinQueryWindow(hwnd, QW_PARENT);
284	swctl.uchVisibility = SWL_VISIBLE;
285	swctl.fbJump = (fDataToFore) ? SWL_NOTJUMPABLE : SWL_JUMPABLE;
286	swctl.bProgType = PROG_PM;
287	strcpy(swctl.szSwtitle, GetPString(IDS_DATABARTITLETEXT));
288	WinCreateSwitchEntry(WinQueryAnchorBlock(hwnd), &swctl);
289	}
290	PostMsg(hwnd, UM_SETUP, MPVOID, MPVOID);
291	return 0;
292
293	case WM_MENUEND:
294	NoFloat = FALSE;
295	if (hwndMenu == (HWND) mp2) {
296	WinDestroyWindow(hwndMenu);
297	hwndMenu = (HWND) 0;
298	}
299	break;
300
301	case UM_RESTORE:
302	WinSetWindowPtr(hwnd, QWL_USER, mp1);
303	return 0;
304
305	case UM_SETUP:
306	{
307	long x, y;
308	SWP swp, swpD;
309	int c;
310	ULONG size = sizeof(SWP);
311	ULONG numdrives = 0;
312	ULONG drivestyle = (DRIVE_REMOVABLE \| DRIVE_INVALID \|
313	DRIVE_IGNORE \| DRIVE_ZIPSTREAM \| DRIVE_NOSTATS);
314	ULONG ulDriveNum, ulDriveMap;
315
316	if (!fDataInclRemote)
317	drivestyle \|= DRIVE_REMOTE \|\| DRIVE_VIRTUAL \|\| DRIVE_RAMDISK;
318	if (fDataShowDrives) {
319	DosError(FERR_DISABLEHARDERR);
320	DosQCurDisk(&ulDriveNum, &ulDriveMap);
321	x = 3;
322	y = MINI_Y + 4;
323	// Drive status windows
324	for (c = 2; c < 26; c++) {
325	if ((ulDriveMap & (1L << c)) && !(driveflags[c] & drivestyle)) {
326	if (!WinCreateWindow(hwnd,
327	(CHAR *) WC_MINITIME,
328	NullStr,
329	SS_TEXT \| DT_CENTER \| DT_VCENTER \|
330	WS_VISIBLE, x, y, MINI_X, MINI_Y, hwnd,
331	HWND_TOP, MINI_DRIVEA + c, NULL, NULL)) {
332	Win_Error(hwnd, hwnd, pszSrcFile, __LINE__,
333	PCSZ_WINCREATEWINDOW);
334	}
335	numdrives++;
336	x += (MINI_X + 4);
337	if ((numdrives % 4) == 0) {
338	y += (MINI_Y + 4);
339	x = 3;
340	}
341	}
342	}
343	}
344	x = (MINI_X * 4) + 18;
345	y = (MINI_Y + 4) + ((numdrives / 4) * (MINI_Y + 4)) +
346	(((numdrives % 4) != 0) * (MINI_Y + 4));
347	if (!Positioned) {
348	if (PrfQueryProfileData(fmprof, appname, "DataMinPos", &swp, &size)) {
349	WinQueryWindowPos(HWND_DESKTOP, &swpD);
350	if (swp.x > swpD.cx - 16)
351	swp.x = swpD.cx - 16;
352	if (swp.y > swpD.cy - 16)
353	swp.y = swpD.cy - 16;
354	WinSetWindowPos(WinQueryWindow(hwnd, QW_PARENT),
355	HWND_TOP,
356	swp.x,
357	swp.y,
358	x, y, SWP_SIZE \| SWP_MOVE \| SWP_SHOW \| SWP_ZORDER);
359	}
360	else
361	WinSetWindowPos(WinQueryWindow(hwnd, QW_PARENT),
362	HWND_TOP,
363	0,
364	0,
365	x, y, SWP_SHOW \| SWP_SIZE \| SWP_MOVE \| SWP_ZORDER);
366	Positioned = TRUE;
367	}
368	else
369	WinSetWindowPos(WinQueryWindow(hwnd, QW_PARENT),
370	HWND_TOP,
371	0, 0, x, y, SWP_SHOW \| SWP_SIZE \| SWP_ZORDER);
372	WinShowWindow(WinQueryWindow(hwnd, QW_PARENT), TRUE);
373	if (numdrives) {
374	if (xbeginthread(dataminThread,
375	32768,
376	(PVOID)hwnd,
377	pszSrcFile,
378	__LINE__) == -1)
379	{
380	PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
381	}
382	}
383	counter = 0;
384	PostMsg(hwnd, UM_TIMER, MPVOID, MPVOID);
385	}
386	return 0; // UM_SETUP
387
388	case WM_BUTTON1DBLCLK:
389	if (hwndMain)
390	PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
391	break;
392
393	case UM_CONTEXTMENU:
394	case WM_CONTEXTMENU:
395	if (!hwndMenu)
396	hwndMenu = WinLoadMenu(HWND_DESKTOP, FM3ModHandle, MINI_FRAME);
397	if (hwndMenu) {
398	WinCheckMenuItem(hwndMenu, MINI_FLOAT, fDataToFore);
399	WinCheckMenuItem(hwndMenu, MINI_SHOW, fDataShowDrives);
400	WinCheckMenuItem(hwndMenu, MINI_BORING, fDullMin);
401	WinCheckMenuItem(hwndMenu, MINI_INCLREMOTE, fDataInclRemote);
402	if (fProtectOnly) {
403	WinEnableMenuItem(hwndMenu, IDM_DOSCOMMANDLINE, FALSE);
404	WinEnableMenuItem(hwndMenu, IDM_WINFULLSCREEN, FALSE);
405	}
406	NoFloat = TRUE;
407	if (!PopupMenu(hwnd, hwnd, hwndMenu))
408	NoFloat = FALSE;
409	}
410	if (msg == UM_CONTEXTMENU)
411	return 0;
412	break;
413
414	case WM_BUTTON2DBLCLK:
415	if (!(SHORT2FROMMP(mp2) & KC_SHIFT)) {
416	PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(MINI_FLOAT, 0), MPVOID);
417	break;
418	}
419	/* else intentional fallthru */
420	case WM_CHORD:
421	case WM_BUTTON3DBLCLK:
422	PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(MINI_SHOW, 0), MPVOID);
423	break;
424
425	case UM_BUTTON1MOTIONSTART:
426	case WM_BUTTON1MOTIONSTART:
427	{
428	TRACKINFO TrackInfo;
429	SWP Position;
430
431	memset(&TrackInfo, 0, sizeof(TrackInfo));
432	TrackInfo.cxBorder = 1;
433	TrackInfo.cyBorder = 1;
434	TrackInfo.cxGrid = 1;
435	TrackInfo.cyGrid = 1;
436	TrackInfo.cxKeyboard = 8;
437	TrackInfo.cyKeyboard = 8;
438	WinQueryWindowPos(WinQueryWindow(hwnd, QW_PARENT), &Position);
439	TrackInfo.rclTrack.xLeft = Position.x;
440	TrackInfo.rclTrack.xRight = Position.x + Position.cx;
441	TrackInfo.rclTrack.yBottom = Position.y;
442	TrackInfo.rclTrack.yTop = Position.y + Position.cy;
443	WinQueryWindowPos(HWND_DESKTOP, &Position);
444	TrackInfo.rclBoundary.xLeft = Position.x;
445	TrackInfo.rclBoundary.xRight = Position.x + Position.cx;
446	TrackInfo.rclBoundary.yBottom = Position.y;
447	TrackInfo.rclBoundary.yTop = Position.y + Position.cy;
448	TrackInfo.ptlMinTrackSize.x = 0;
449	TrackInfo.ptlMinTrackSize.y = 0;
450	TrackInfo.ptlMaxTrackSize.x = Position.cx;
451	TrackInfo.ptlMaxTrackSize.y = Position.cy;
452	TrackInfo.fs = TF_MOVE \| TF_STANDARD \| TF_ALLINBOUNDARY;
453	if (WinTrackRect(HWND_DESKTOP, (HPS) 0, &TrackInfo)) {
454	WinSetWindowPos(WinQueryWindow(hwnd, QW_PARENT),
455	HWND_TOP, TrackInfo.rclTrack.xLeft,
456	TrackInfo.rclTrack.yBottom, 0, 0, SWP_MOVE);
457	WinSendMsg(hwnd, WM_SAVEAPPLICATION, MPVOID, MPVOID);
458	}
459	}
460	break;
461
462	case WM_HELP:
463	PostMsg(hwnd, WM_COMMAND, MPFROM2SHORT(IDM_HELP, 0), MPVOID);
464	break;
465
466	case WM_COMMAND:
467	switch (SHORT1FROMMP(mp1)) {
468	case IDM_COMMANDLINE:
469	case IDM_DOSCOMMANDLINE:
470	case IDM_WINFULLSCREEN:
471	{
472	CHAR *env = GetCmdSpec(FALSE), path[CCHMAXPATH];
473	INT type = SEPARATE \| WINDOWED;
474
475	*path = 0;
476	TopWindowName(hwnd, (HWND) 0, path);
477	if (SHORT1FROMMP(mp1) == IDM_DOSCOMMANDLINE)
478	env = GetCmdSpec(TRUE);
479	else if (SHORT1FROMMP(mp1) != IDM_COMMANDLINE) {
480	env = "WINOS2.COM";
481	type = SEPARATE \| FULLSCREEN;
482	}
483	runemf2(type, hwnd, pszSrcFile, __LINE__,
484	path, NULL, "%s", env);
485	}
486	break;
487
488	case IDM_HELP:
489	if (hwndHelp)
490	WinSendMsg(hwndHelp,
491	HM_DISPLAY_HELP,
492	MPFROM2SHORT(HELP_DATABAR, 0), MPFROMSHORT(HM_RESOURCEID));
493	break;
494
495	case MINI_CLOSE:
496	PostMsg(hwnd, WM_CLOSE, MPVOID, MPVOID);
497	break;
498
499	case MINI_BORING:
500	fDullMin = (fDullMin) ? FALSE : TRUE;
501	PrfWriteProfileData(fmprof, appname, "DullDatabar", &fDullMin, sizeof(BOOL));
502	if (G_hevDataMin != NULLHANDLE) {
503	rc = DosPostEventSem(G_hevDataMin);
504	if (rc) {
505	Dos_Error(MB_ENTER, rc, HWND_DESKTOP, pszSrcFile, __LINE__,
506	GetPString(IDS_POSTSEMFAILED));
507	}
508	}
509
510	break;
511
512	case MINI_INCLREMOTE:
513	case MINI_SHOW:
514	if (SHORT1FROMMP(mp1) == MINI_SHOW) {
515	fDataShowDrives = (fDataShowDrives) ? FALSE : TRUE;
516	PrfWriteProfileData(fmprof, appname, "DataShowDrives",
517	&fDataShowDrives, sizeof(BOOL));
518	}
519	else {
520	fDataInclRemote = (fDataInclRemote) ? FALSE : TRUE;
521	PrfWriteProfileData(fmprof, appname, "DataInclRemote",
522	&fDataInclRemote, sizeof(BOOL));
523	}
524	{
525	HENUM henum;
526	HWND hwndChild;
527	USHORT id;
528
529	henum = WinBeginEnumWindows(hwnd);
530	while ((hwndChild = WinGetNextWindow(henum)) != NULLHANDLE) {
531	id = WinQueryWindowUShort(hwndChild, QWS_ID);
532	if (id >= MINI_DRIVEA)
533	WinDestroyWindow(hwndChild);
534	}
535	WinEndEnumWindows(henum);
536	}
537	PostMsg(hwnd, UM_SETUP, MPVOID, MPVOID);
538	break;
539
540	case MINI_FLOAT:
541	fDataToFore = (fDataToFore) ? FALSE : TRUE;
542	PrfWriteProfileData(fmprof, appname, "DataToFore", &fDataToFore, sizeof(BOOL));
543	if (!hwndMain) {
544
545	SWCNTRL swcntrl;
546	HSWITCH hswitch;
547
548	hswitch = (HSWITCH) WinQuerySwitchHandle(hwnd, (PID) 0);
549	if (hswitch) {
550	memset(&swcntrl, 0, sizeof(SWCNTRL));
551	if (!WinQuerySwitchEntry(hswitch, &swcntrl)) {
552	swcntrl.fbJump = (fDataToFore) ? SWL_NOTJUMPABLE : SWL_JUMPABLE;
553	WinChangeSwitchEntry(hswitch, &swcntrl);
554	}
555	}
556	}
557	break;
558	}
559	return 0;
560
561	case WM_SIZE:
562	WinSetWindowPos(hwnd,
563	HWND_TOP,
564	0,
565	0,
566	SHORT1FROMMP(mp2),
567	SHORT2FROMMP(mp2), SWP_MOVE \| SWP_SIZE);
568	break;
569
570	case WM_PAINT:
571	{
572	HPS hps;
573	POINTL ptl;
574	SWP swp;
575	RECTL rcl;
576
577	hps = WinBeginPaint(hwnd, (HPS) 0, &rcl);
578	if (hps) {
579	WinFillRect(hps, (PRECTL) & rcl, CLR_PALEGRAY);
580	GpiSetMix(hps, FM_OVERPAINT);
581	GpiSetColor(hps, CLR_WHITE);
582	WinQueryWindowPos(hwnd, &swp);
583	ptl.x = 0;
584	ptl.y = 0;
585	GpiMove(hps, &ptl);
586	ptl.y = swp.cy - 1;
587	GpiLine(hps, &ptl);
588	ptl.x = swp.cx - 1;
589	GpiLine(hps, &ptl);
590	GpiSetColor(hps, CLR_DARKGRAY);
591	ptl.y = 0;
592	GpiLine(hps, &ptl);
593	ptl.x = 0;
594	GpiLine(hps, &ptl);
595	{
596	HENUM henum;
597	HWND hwndTemp;
598
599	henum = WinBeginEnumWindows(hwnd);
600	while ((hwndTemp = WinGetNextWindow(henum)) != NULLHANDLE) {
601	PaintRecessedWindow(hwndTemp,
602	hps, (WinQueryWindowUShort(hwndTemp, QWS_ID)
603	!= MINI_TIME), FALSE);
604	}
605	WinEndEnumWindows(henum);
606	}
607	WinEndPaint(hps);
608	}
609	}
610	return 0;
611
612	case UM_PAINT:
613	{
614	CHAR s[90];
615	CHAR szFreeQty[38];
616	CHAR szDrvLtr[] = " :";
617	CHAR *pszFSystem;
618	ULONGLONG ullFreeQty;
619	ULONG ulPercentFree;
620	ULONG wasx;
621	HPS hps = (HPS) mp2;
622	HWND hwndChild;
623	USHORT id;
624	SWP swp;
625	POINTL ptl;
626	tDataMin *pDM;
627
628	id = SHORT1FROMMP(mp1);
629	if (id >= MINI_DRIVEA) {
630	hwndChild = WinWindowFromID(hwnd, id);
631	if (!hwndChild)
632	return 0;
633	if (!WinQueryWindowPos(hwndChild, &swp))
634	return 0;
635	pDM = WinQueryWindowPtr(hwndChild, QWL_DATAMIN_PTR);
636	if (!pDM \|\| pDM->qfsi_rc) {
637	ullFreeQty = 0;
638	ulPercentFree = 0;
639	}
640	else {
641	ullFreeQty = (ULONGLONG) pDM->fsa.cUnitAvail *
642	(pDM->fsa.cSectorUnit * pDM->fsa.cbSector);
643
644	ulPercentFree = (pDM->fsa.cUnit && pDM->fsa.cUnitAvail) ?
645	(pDM->fsa.cUnitAvail * 100) / pDM->fsa.cUnit : 0;
646	}
647
648	CommaFmtULL(szFreeQty, sizeof(szFreeQty), ullFreeQty, ' ');
649	*szDrvLtr = (CHAR) (id - MINI_DRIVEA) + 'A';
650
651	if (!pDM \|\| pDM->qfsi_rc \|\| pDM->qfsa_rc)
652	pszFSystem = "N/A";
653	else {
654	pszFSystem = (PCHAR)(pDM->fsqb2.szName) + pDM->fsqb2.cbName + 1;
655	pszFSystem[15] = 0;
656	}
657	sprintf(s,
658	"%s %13s %lu%%-%s %6s ",
659	szDrvLtr,
660	szFreeQty,
661	ulPercentFree, GetPString(IDS_FREETEXT), pszFSystem);
662	if (!hps)
663	hps = WinGetPS(hwndChild);
664	if (hps) {
665	if (!fDullMin) {
666	ptl.x = 0;
667	ptl.y = 0;
668	GpiMove(hps, &ptl);
669	GpiSetColor(hps, CLR_BLACK);
670	ptl.x = swp.cx - 1;
671	ptl.y = swp.cy - 1;
672	GpiBox(hps, DRO_OUTLINE, &ptl, 0, 0);
673	ptl.x = 1;
674	ptl.y = 1;
675	if (ulPercentFree) {
676	GpiMove(hps, &ptl);
677	GpiSetColor(hps,
678	(ulPercentFree < 11) ? CLR_DARKRED :
679	(ulPercentFree < 26) ? CLR_DARKBLUE :
680	CLR_DARKGREEN);
681	ptl.y = swp.cy - 2;
682	ptl.x = ((swp.cx - 2) * ulPercentFree) / 100;
683	wasx = ptl.x;
684	GpiBox(hps, DRO_OUTLINEFILL, &ptl, 0, 0);
685	GpiSetColor(hps,
686	(ulPercentFree < 11) ? CLR_RED :
687	(ulPercentFree < 26) ? CLR_BLUE : CLR_GREEN);
688	ptl.x = wasx;
689	ptl.y = swp.cy - 2;
690	GpiMove(hps, &ptl);
691	ptl.x = 1;
692	GpiLine(hps, &ptl);
693	ptl.y = 2;
694	ptl.x = 1;
695	GpiLine(hps, &ptl);
696	ptl.x = wasx;
697	}
698	if (ulPercentFree < 99) {
699	GpiSetColor(hps, CLR_DARKGRAY);
700	wasx = ptl.x;
701	ptl.y = 2;
702	GpiMove(hps, &ptl);
703	ptl.y = swp.cy - 2;
704	ptl.x = swp.cx - 2;
705	GpiBox(hps, DRO_OUTLINEFILL, &ptl, 0, 0);
706	ptl.x = wasx;
707	GpiMove(hps, &ptl);
708	GpiSetColor(hps, CLR_PALEGRAY);
709	ptl.x = swp.cx - 3;
710	GpiLine(hps, &ptl);
711	ptl.x = wasx;
712	ptl.y = 1;
713	GpiMove(hps, &ptl);
714	GpiSetColor(hps, CLR_BLACK);
715	ptl.x = swp.cx - 2;
716	GpiLine(hps, &ptl);
717	ptl.y = swp.cy - 3;
718	GpiLine(hps, &ptl);
719	}
720	GpiSetColor(hps, CLR_WHITE);
721	}
722	else {
723	GpiSetColor(hps, CLR_PALEGRAY);
724	ptl.x = 0;
725	ptl.y = 0;
726	GpiMove(hps, &ptl);
727	ptl.x = swp.cx - 1;
728	ptl.y = swp.cy - 1;
729	GpiBox(hps, DRO_OUTLINEFILL, &ptl, 0, 0);
730	GpiSetColor(hps,
731	(ulPercentFree < 11) ? CLR_DARKRED : CLR_DARKBLUE);
732	}
733	GpiSetBackMix(hps, BM_LEAVEALONE);
734	GpiSetMix(hps, FM_OVERPAINT);
735	{
736	POINTL aptl[TXTBOX_COUNT];
737
738	GpiQueryTextBox(hps, strlen(s), s, TXTBOX_COUNT, aptl);
739	ptl.y = ((swp.cy / 2) -
740	((aptl[TXTBOX_TOPRIGHT].y +
741	aptl[TXTBOX_BOTTOMLEFT].y) / 2));
742	ptl.y++;
743	ptl.x = (swp.cx / 2) - (aptl[TXTBOX_TOPRIGHT].x / 2);
744	if (ptl.x < 2)
745	ptl.x = 2;
746	GpiCharStringAt(hps, &ptl, strlen(s), s);
747	}
748	if (!mp2)
749	WinReleasePS(hps);
750	}
751	} // if drive window
752	}
753	return 0;
754
755	case UM_TIMER:
756	{
757	CHAR s[134], szDate[DATE_BUF_BYTES];
758	DATETIME dt;
759
760	if (fDataToFore && !NoFloat)
761	WinSetWindowPos(WinQueryWindow(hwnd, QW_PARENT),
762	HWND_TOP, 0, 0, 0, 0, SWP_ZORDER);
763	if (counter && (counter % 19) && (counter % 20)) {
764	if (!DosGetDateTime(&dt)) {
765	DTDateFormat(szDate, dt);
766	sprintf(s,
767	" %02hu%s%02hu%s%02hu %s %s",
768	dt.hours, TimeSeparator,
769	dt.minutes, TimeSeparator,
770	dt.seconds,
771	GetPString(IDS_SUNDAY + dt.weekday),
772	szDate);
773	WinSetDlgItemText(hwnd, MINI_TIME, s);
774	}
775	}
776	else if (!counter \|\| !(counter % 19))
777	PostMsg(hwnd, UM_SETUP6, MPVOID, MPVOID); // Uptime
778	if (!(counter % 4)) {
779	PostMsg(hwnd, UM_SETUP3, MPVOID, MPVOID); // Memory utilization
780	if (!(counter % 10)) {
781	PostMsg(hwnd, UM_SETUP5, MPVOID, MPVOID); // Process status
782	if (!(counter % 20)) {
783	PostMsg(hwnd, UM_SETUP2, MPVOID, MPVOID); // Swapper
784	}
785	}
786	}
787	}
788	counter++;
789	return 0;
790
791	case UM_SETUP2:
792	{
793	CHAR s[134], szFileQty[38], szFreeQty[38];
794	FILEFINDBUF3L ffb;
795	ULONG nm = 1;
796	ULONGLONG ullFreeQty;
797	HDIR hdir = HDIR_CREATE;
798	FSALLOCATE fsa;
799
800	if (*SwapperDat) {
801	DosError(FERR_DISABLEHARDERR);
802	if (!xDosFindFirst(SwapperDat, &hdir, FILE_NORMAL \| FILE_HIDDEN \|
803	FILE_SYSTEM \| FILE_ARCHIVED \| FILE_READONLY,
804	&ffb, sizeof(ffb), &nm, FIL_STANDARDL)) {
805	priority_bumped();
806	DosFindClose(hdir);
807	DosError(FERR_DISABLEHARDERR);
808	if (!DosQueryFSInfo(toupper(*SwapperDat) - '@', FSIL_ALLOC,
809	&fsa, sizeof(FSALLOCATE))) {
810	ullFreeQty =
811	(ULONGLONG) fsa.cUnitAvail * (fsa.cSectorUnit * fsa.cbSector);
812	CommaFmtULL(szFreeQty, sizeof(szFreeQty), ullFreeQty, ' ');
813	}
814	else
815	*szFreeQty = 0;
816
817	CommaFmtULL(szFileQty, sizeof(szFileQty), ffb.cbFile, ' ');
818	sprintf(s, " %s %s%s%s",
819	GetPString(IDS_SWAPTITLETEXT),
820	szFileQty, *szFreeQty ? "/" : NullStr, szFreeQty);
821	WinSetDlgItemText(hwnd, MINI_SWAP, s);
822	}
823	}
824	}
825	return 0;
826
827	case UM_SETUP3: // Memory utilization
828	{
829	CHAR s[134], tm[38], szQty[38];
830	ULONG amem = 0;
831
832	if (!DosQuerySysInfo(QSV_TOTAVAILMEM, QSV_TOTAVAILMEM,
833	(PVOID) & amem, (ULONG) sizeof(amem))) {
834	CommaFmtUL(tm, sizeof(tm), amem, 'M');
835	if (!Dos16MemAvail(&amem))
836	CommaFmtUL(szQty, sizeof(szQty), amem, 'M');
837	else
838	*szQty = 0;
839	sprintf(s, " %s%s%s%s",
840	GetPString(IDS_MEMTITLETEXT),
841	szQty, (*szQty) ? "/" : NullStr, tm);
842	WinSetDlgItemText(hwnd, MINI_MEM, s);
843	}
844	}
845	return 0;
846
847	case UM_SETUP5: // Process status
848	{
849	CHAR s[134], tm[38], szQty[38];
850
851	if (fUseQProcStat && !noqproc) {
852
853	PROCESSINFO *ppi;
854	BUFFHEADER *pbh = NULL;
855	MODINFO *pmi;
856	ULONG numprocs = 0, numthreads = 0;
857
858	if (!xDosAllocMem((PVOID)&pbh, USHRT_MAX + 4096,
859	PAG_COMMIT \| PAG_READ \| PAG_WRITE,
860	pszSrcFile, __LINE__)) {
861	if (DosQProcStatus((ULONG *)pbh, USHRT_MAX))
862	noqproc = TRUE;
863	else {
864	ppi = pbh->ppi;
865	while (ppi->ulEndIndicator != PROCESS_END_INDICATOR) {
866	pmi = pbh->pmi;
867	while (pmi && ppi->hModRef != pmi->hMod)
868	pmi = pmi->pNext;
869	if (pmi) {
870	numprocs++;
871	numthreads += ppi->usThreadCount;
872	}
873	ppi = (PPROCESSINFO) (ppi->ptiFirst + ppi->usThreadCount);
874	}
875	commafmt(szQty, sizeof(szQty), numprocs);
876	commafmt(tm, sizeof(tm), numthreads);
877	sprintf(s,
878	" %s%s %s%s",
879	GetPString(IDS_PROCSTITLETEXT),
880	szQty, GetPString(IDS_THRDSTITLETEXT), tm);
881	WinSetDlgItemText(hwnd, MINI_PROC, s);
882	}
883	DosFreeMem(pbh);
884	}
885	}
886	else if (fUseQSysState && !noqproc) {
887
888	QSPREC *ppi;
889	QSPTRREC *pbh = NULL;
890	QSLREC *pmi;
891	ULONG numprocs = 0, numthreads = 0;
892
893	if (!xDosAllocMem((PVOID) & pbh, USHRT_MAX + 4096,
894	PAG_COMMIT \| PAG_READ \| PAG_WRITE,
895	pszSrcFile, __LINE__)) {
896	//2 Sep 07 GKY 0x05 = process & Mod data only
897	if (DosQuerySysState(QS_PROCESS \| QS_MTE, 0, 0, 0, pbh, USHRT_MAX))
898	noqproc = TRUE;
899	else {
900	ppi = pbh->pProcRec;
901	while (ppi->RecType == 1) {
902	pmi = pbh->pLibRec;
903	while (pmi && ppi->hMte != pmi->hmte)
904	pmi = pmi->pNextRec;
905	if (pmi) {
906	numprocs++;
907	numthreads += ppi->cTCB;
908	}
909	ppi = (QSPREC *) (ppi->pThrdRec + ppi->cTCB);
910	}
911	commafmt(szQty, sizeof(szQty), numprocs);
912	commafmt(tm, sizeof(tm), numthreads);
913	sprintf(s,
914	" %s%s %s%s",
915	GetPString(IDS_PROCSTITLETEXT),
916	szQty, GetPString(IDS_THRDSTITLETEXT), tm);
917	WinSetDlgItemText(hwnd, MINI_PROC, s);
918	}
919	DosFreeMem(pbh);
920	}
921	}
922	else {
923	commafmt(szQty, sizeof(szQty),
924	WinQuerySwitchList(WinQueryAnchorBlock(hwnd), (PSWBLOCK) 0,
925	0));
926	sprintf(s, " %s%s", GetPString(IDS_TASKSTITLETEXT), szQty);
927	WinSetDlgItemText(hwnd, MINI_PROC, s);
928	}
929	}
930	return 0;
931
932	case UM_SETUP6: // Uptime
933	{
934	ULONG val = 0, numdays, nummins;
935	CHAR s[128];
936
937	if (!DosQuerySysInfo(QSV_MS_COUNT,
938	QSV_MS_COUNT,
939	(PVOID) & val, (ULONG) sizeof(val))) {
940	val /= 60000L;
941	numdays = val / (60L * 24L);
942	strcpy(s, GetPString(IDS_ELAPSEDTITLETEXT));
943	if (numdays)
944	sprintf(s + strlen(s),
945	" %lu %s%s, ",
946	numdays, GetPString(IDS_DAYTEXT), &"s"[numdays == 1L]);
947	nummins = val % (60L * 24L);
948	sprintf(s + strlen(s), " %lu%s%02lu", nummins / 60, TimeSeparator, nummins % 60);
949	WinSetDlgItemText(hwnd, MINI_TIME, s);
950	}
951	}
952	return 0;
953
954	case WM_SAVEAPPLICATION:
955	{
956	SWP swp;
957
958	WinQueryWindowPos(WinQueryWindow(hwnd, QW_PARENT), &swp);
959	PrfWriteProfileData(fmprof, appname, "DataMinPos", &swp, sizeof(SWP));
960	}
961	break;
962
963	case WM_CLOSE:
964	WinSendMsg(hwnd, WM_SAVEAPPLICATION, MPVOID, MPVOID);
965	WinDestroyWindow(WinQueryWindow(hwnd, QW_PARENT));
966	return 0;
967
968	case WM_DESTROY:
969	if (DataHwnd == WinQueryWindow(hwnd, QW_PARENT)) {
970	DataHwnd = (HWND) 0;
971	if (hwndMenu)
972	WinDestroyWindow(hwndMenu);
973	hwndMenu = (HWND) 0;
974	}
975	if (hwndMain) {
976
977	SWP swp;
978	ULONG fl = SWP_SHOW \| SWP_ZORDER \| SWP_ACTIVATE, ofl;
979
980	ofl = WinQueryWindowULong(hwnd, QWL_USER);
981	WinQueryWindowPos(WinQueryWindow(hwndMain, QW_PARENT), &swp);
982	if (swp.fl & SWP_MINIMIZE)
983	fl \|= ((ofl & SWP_MAXIMIZE) ? SWP_MAXIMIZE : SWP_RESTORE);
984	WinSetWindowPos(WinQueryWindow(hwndMain, QW_PARENT),
985	HWND_TOP, 0, 0, 0, 0, fl);
986	}
987	else if (!PostMsg((HWND) 0, WM_QUIT, MPVOID, MPVOID))
988	WinSendMsg((HWND) 0, WM_QUIT, MPVOID, MPVOID);
989	break;
990	}
991	return WinDefWindowProc(hwnd, msg, mp1, mp2);
992
993	} // DataProc
994
995	//=== CreateDataBar - create databar windows ===
996
997	HWND CreateDataBar(HWND hwndParent, ULONG fl)
998	{
999	HWND hwndClient = (HWND) 0;
1000	ULONG FrameFlags = 0;
1001
1002	if (WinCreateStdWindow(hwndParent,
1003	WS_VISIBLE,
1004	&FrameFlags,
1005	(CHAR *) WC_DATABAR,
1006	NULL, WS_VISIBLE, 0, MINI_FRAME, &hwndClient)) {
1007	WinSendMsg(hwndClient, UM_RESTORE, MPFROMLONG(fl), MPVOID);
1008	}
1009	return hwndClient;
1010
1011	} // CreateDataBar
1012
1013	//=== dataminThread - drive status thread ===
1014
1015	static VOID dataminThread(VOID * pv)
1016	{
1017	HAB hab = NULLHANDLE;
1018	HMQ hmq = NULLHANDLE;
1019	HWND hwndParent = (HWND) pv;
1020	HWND hwnd;
1021	HENUM henum;
1022	BOOL busy = TRUE;
1023	APIRET rc;
1024	USHORT id;
1025
1026	# ifdef FORTIFY
1027	Fortify_EnterScope();
1028	# endif
1029	if (G_hevDataMin == NULLHANDLE) {
1030	// Create just once for any thread that might use it
1031	// Kernel will clean up on exit
1032	rc = DosCreateEventSem(NULL, (PHEV) & G_hevDataMin, 0L, FALSE);
1033	if (rc) {
1034	Dos_Error(MB_ENTER, rc, HWND_DESKTOP, pszSrcFile, __LINE__,
1035	GetPString(IDS_CREATESEMFAILED));
1036	busy = FALSE;
1037	}
1038	}
1039
1040	// fixme to report errors
1041	hab = WinInitialize(0);
1042	if (hab == NULLHANDLE)
1043	busy = FALSE;
1044	else {
1045	hmq = WinCreateMsgQueue(hab, 0);
1046	if (hmq == NULLHANDLE)
1047	busy = FALSE;
1048	else
1049	WinCancelShutdown(hmq, TRUE);
1050	}
1051
1052	while (busy) {
1053	HWND hwndSingle = G_hwndSingle;
1054
1055	G_hwndSingle = NULLHANDLE;
1056
1057	busy = FALSE;
1058
1059	if (!WinIsWindow(hab, hwndParent))
1060	break;
1061
1062	henum = WinBeginEnumWindows(hwndParent);
1063	while (henum && (hwnd = WinGetNextWindow(henum)) != NULLHANDLE) {
1064	if (!WinIsWindow(hab, hwnd))
1065	continue;
1066	if (hwndSingle && hwndSingle != hwnd)
1067	continue;
1068	id = WinQueryWindowUShort(hwnd, QWS_ID);
1069	if (id > MINI_DRIVEA) {
1070	ULONG dskNum = id - MINI_DRIVEA + 1;
1071	tDataMin *pDM = WinQueryWindowPtr(hwnd, QWL_DATAMIN_PTR);
1072	SWP swp;
1073	CHAR szPath[] = " :";
1074
1075	if (!pDM)
1076	continue;
1077	busy = TRUE;
1078	if (!WinQueryWindowPos(hwnd, &swp))
1079	continue;
1080
1081	DosError(FERR_DISABLEHARDERR);
1082	pDM->qfsi_rc = DosQueryFSInfo(dskNum,
1083	FSIL_ALLOC,
1084	&pDM->fsa, sizeof(FSALLOCATE));
1085
1086	if (!pDM->qfsi_rc) {
1087	*szPath = (CHAR) dskNum + 'A' - 1;
1088	pDM->qfsa_cb = sizeof(FSQBUFFER2) + 256; // se tDataMin
1089	DosError(FERR_DISABLEHARDERR);
1090	pDM->qfsa_rc = DosQueryFSAttach(szPath, 0, /* Ordinal */
1091	FSAIL_QUERYNAME,
1092	&pDM->fsqb2, &pDM->qfsa_cb);
1093	}
1094	WinInvalidateRect(hwnd, NULL, FALSE);
1095	} // if drive window
1096	} // while henum
1097	WinEndEnumWindows(henum);
1098
1099	if (busy) {
1100	ULONG clPosted;
1101
1102	rc = DosWaitEventSem(G_hevDataMin, 20000L);
1103	if (rc && rc != ERROR_TIMEOUT) {
1104	Dos_Error(MB_ENTER, rc, HWND_DESKTOP, pszSrcFile, __LINE__,
1105	GetPString(IDS_POSTSEMFAILED));
1106	}
1107
1108	rc = DosResetEventSem(G_hevDataMin, &clPosted);
1109	if (rc && rc != ERROR_ALREADY_RESET) {
1110	Dos_Error(MB_ENTER, rc, HWND_DESKTOP, pszSrcFile, __LINE__,
1111	GetPString(IDS_POSTSEMFAILED));
1112	}
1113	}
1114
1115	} // while
1116
1117	if (hmq != NULLHANDLE)
1118	WinDestroyMsgQueue(hmq);
1119
1120	if (hab != NULLHANDLE)
1121	WinTerminate(hab);
1122	# ifdef FORTIFY
1123	Fortify_LeaveScope();
1124	# endif
1125	} // dataminThread
1126
1127	#pragma alloc_text(DATAMIN,DataDlgProc,MiniTimeProc)

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

Download in other formats: