source: trunk/dll/datamin.c@ 346

Last change on this file since 346 was 346, checked in by root, 19 years ago

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