source: trunk/dll/datamin.c@ 443

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

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