source: trunk/dll/datamin.c@ 1178

Last change on this file since 1178 was 1178, checked in by John Small, 17 years ago

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