source: trunk/dll/datamin.c@ 136

Last change on this file since 136 was 136, checked in by root, 20 years ago

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