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
RevLine 
[30]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
[346]9 Copyright (c) 2001, 2006 Steven H. Levine
[30]10
[130]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
[136]14 23 May 05 SHL Avoid delays for inaccessible drives
[162]15 25 May 05 SHL Use ULONGLONG and CommaFmtULL
[204]16 06 Jun 05 SHL Drop unused code
[346]17 22 Jul 06 SHL Check more run time errors
[30]18
19***********************************************************************/
20
[2]21#define INCL_DOS
[136]22#define INCL_DOSERRORS
[2]23#define INCL_WIN
24#define INCL_GPI
[162]25#define INCL_LONGLONG
26#include <os2.h>
[2]27
28#include <stdio.h>
29#include <stdlib.h>
30#include <string.h>
31#include <ctype.h>
32#include <limits.h>
[136]33
[2]34#include "fm3dll.h"
35#include "fm3dlg.h"
36#include "fm3str.h"
37#include "procstat.h"
[136]38#include "datamin.h"
[2]39
40#pragma data_seg(DATA2)
[346]41
42static PSZ pszSrcFile = __FILE__;
43
[2]44#pragma alloc_text(DATAMIN,DataDlgProc,MiniTimeProc)
45
[136]46APIRET16 APIENTRY16 Dos16MemAvail(PULONG pulAvailMem);
[2]47
[136]48static volatile HEV G_hevDataMin = NULLHANDLE;
49static volatile HWND G_hwndSingle = NULLHANDLE;
[2]50
[136]51static VOID dataminThread (VOID *pv);
[2]52
[136]53long MINI_X = 208, MINI_Y = 16;
[2]54
[136]55//=== MiniTimeProc - time, swap and drive status mini windows procedure ===
[2]56
[136]57MRESULT EXPENTRY MiniTimeProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
58{
59 APIRET rc;
60 switch (msg)
61 {
62 case WM_CREATE:
63 {
[346]64 PVOID pv = xmalloc(sizeof(tDataMin),pszSrcFile,__LINE__);
[136]65 WinSetWindowPtr(hwnd, QWL_DATAMIN_PTR, pv);
66 }
67 break;
[2]68
[136]69 case WM_BUTTON1CLICK:
70 {
71 USHORT id = WinQueryWindowUShort(hwnd, QWS_ID);
72
73 if (id >= MINI_DRIVEA)
[2]74 {
[136]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,
[346]84 pszSrcFile,
[136]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;
[2]103
[136]104 case WM_BUTTON1DBLCLK:
105 {
106 USHORT id = WinQueryWindowUShort(hwnd, QWS_ID);
[2]107
[136]108 if (id >= MINI_DRIVEA && !hwndMain)
109 {
110 CHAR s[] = " :\\";
[2]111
[136]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 }
[2]128
129#ifdef NEVER
[136]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 }
[2]140#endif
141
[136]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 {
[2]154
[136]155 char s[5];
[2]156
[136]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);
[2]166 }
[136]167 }
168 break;
[2]169
[136]170 case WM_BUTTON1MOTIONSTART:
171 PostMsg(WinQueryWindow(hwnd, QW_PARENT),
172 UM_BUTTON1MOTIONSTART,
173 MPVOID,
174 MPVOID);
175 break;
[2]176
[136]177 case WM_CONTEXTMENU:
178 PostMsg(WinQueryWindow(hwnd, QW_PARENT),
179 UM_CONTEXTMENU,
180 MPVOID,
181 MPVOID);
182 break;
[2]183
[136]184 case WM_PAINT:
185 {
186 MRESULT mr = 0;
187 USHORT id;
188
189 id = WinQueryWindowUShort(hwnd, QWS_ID);
190 if (id >= MINI_DRIVEA)
[2]191 {
[136]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;
[2]205
[136]206 case WM_DESTROY:
207 {
208 PVOID pv = WinQueryWindowPtr(hwnd, QWL_DATAMIN_PTR);
[346]209 xfree(pv);
[2]210 }
[136]211 break;
[2]212 }
[136]213 return PFNWPStatic(hwnd, msg, mp1, mp2);
[2]214
[136]215} // MiniTimeProc
[2]216
[136]217//=== DataProc - databar client window procedure ===
[2]218
[136]219MRESULT EXPENTRY DataProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
220{
221 APIRET rc;
222
[2]223 static ULONG counter;
[136]224 static BOOL NoFloat, noqproc = FALSE, Positioned;
225 static HWND hwndMenu = (HWND) 0;
[2]226
[136]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;
[2]267 }
[136]268 for (c = 0; ids[c]; c++)
[2]269 {
[136]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);
[2]284 }
[136]285 }
286 if (!hwndMain)
287 {
288 SWCNTRL swctl;
[2]289
[136]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;
[2]305
[136]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 }
[2]365 }
[136]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) {
[346]411 if (_beginthread(dataminThread,NULL,32768,(PVOID)hwnd) == -1) {
412 Runtime_Error(pszSrcFile, __LINE__, GetPString(IDS_COULDNTSTARTTHREADTEXT));
413 PostMsg(hwnd,WM_CLOSE,MPVOID,MPVOID);
[136]414 }
415 }
416 counter = 0;
[2]417 PostMsg(hwnd,
[136]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)
[2]459 return 0;
[136]460 break;
[2]461
[136]462 case WM_BUTTON2DBLCLK:
463 if (!(SHORT2FROMMP(mp2) & KC_SHIFT))
464 {
465 PostMsg(hwnd,
466 WM_COMMAND,
467 MPFROM2SHORT(MINI_FLOAT, 0),
468 MPVOID);
[2]469 break;
[136]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;
[2]479
[136]480 case UM_BUTTON1MOTIONSTART:
481 case WM_BUTTON1MOTIONSTART:
482 {
483 TRACKINFO TrackInfo;
484 SWP Position;
[2]485
[136]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))
[2]509 {
[136]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;
[2]517
[136]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);
[2]549 }
[136]550 break;
[2]551
[136]552 case IDM_HELP:
553 if (hwndHelp)
554 WinSendMsg(hwndHelp,
555 HM_DISPLAY_HELP,
556 MPFROM2SHORT(HELP_DATABAR, 0),
557 MPFROMSHORT(HM_RESOURCEID));
[2]558 break;
559
[136]560 case MINI_CLOSE:
561 PostMsg(hwnd,
562 WM_CLOSE,
563 MPVOID,
564 MPVOID);
[2]565 break;
566
[136]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,
[346]581 pszSrcFile,
[136]582 __LINE__,
583 "Post Semaphore failed" // GetPString(IDS_POSTSEMFAILED)
584 );
585 }
[2]586 }
[136]587
[2]588 break;
589
[136]590 case MINI_INCLREMOTE:
591 case MINI_SHOW:
592 if (SHORT1FROMMP(mp1) == MINI_SHOW)
[2]593 {
[136]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;
[2]614
[136]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);
[2]623 }
[136]624 PostMsg(hwnd, UM_SETUP, MPVOID, MPVOID);
[2]625 break;
626
[136]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 }
[2]652 break;
[136]653 }
654 return 0;
[2]655
[136]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;
[2]665
[136]666 case WM_PAINT:
667 {
668 HPS hps;
669 POINTL ptl;
670 SWP swp;
671 RECTL rcl;
[2]672
[136]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;
[2]699
[136]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;
[2]715
[136]716 case UM_PAINT:
717 {
718 CHAR s[90];
719 CHAR szFreeQty[38];
720 CHAR szDrvLtr[] = " :";
721 CHAR *pszFSystem;
[162]722 ULONGLONG ullFreeQty;
[136]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;
[2]731
[136]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 {
[162]743 ullFreeQty = 0;
[136]744 ulPercentFree = 0;
745 }
746 else
747 {
[162]748 ullFreeQty = (ULONGLONG)pDM -> fsa.cUnitAvail *
[136]749 (pDM -> fsa.cSectorUnit * pDM -> fsa.cbSector);
[2]750
[136]751 ulPercentFree = (pDM -> fsa.cUnit && pDM -> fsa.cUnitAvail) ?
752 (pDM -> fsa.cUnitAvail * 100) / pDM -> fsa.cUnit :
753 0;
754 }
[2]755
[162]756 CommaFmtULL(szFreeQty, sizeof(szFreeQty), ullFreeQty,' ');
[136]757 *szDrvLtr = (CHAR)(id - MINI_DRIVEA) + 'A';
[2]758
[136]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,
[162]768 " %s %s (%lu%%) %s [%s]",
[136]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];
[2]885
[136]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 }
[2]935 }
[136]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;
[2]953
[136]954 case UM_SETUP2:
955 {
[204]956 CHAR s[134], szFileQty[38], szFreeQty[38];
[136]957 FILEFINDBUF3 ffb;
958 ULONG nm = 1L;
[162]959 ULONGLONG ullFreeQty;
[136]960 HDIR hdir = HDIR_CREATE;
961 FSALLOCATE fsa;
[2]962
[136]963 if (*SwapperDat)
[2]964 {
[136]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 {
[162]976 ullFreeQty = (ULONGLONG)fsa.cUnitAvail * (fsa.cSectorUnit * fsa.cbSector);
977 CommaFmtULL(szFreeQty, sizeof(szFreeQty), ullFreeQty,' ');
[136]978 }
979 else
[162]980 *szFreeQty = 0;
981
982 CommaFmtULL(szFileQty, sizeof(szFileQty), ffb.cbFile,' ');
983 sprintf(s, " %s %s%s%s",
[136]984 GetPString(IDS_SWAPTITLETEXT),
985 szFileQty,
[162]986 *szFreeQty ? "/" : NullStr,
987 szFreeQty);
988 WinSetDlgItemText(hwnd,MINI_SWAP,s);
[136]989 }
990 }
991 }
992 return 0;
[2]993
[136]994 case UM_SETUP3: // Memory utilization
995 {
[162]996 CHAR s[134], tm[38], szQty[38];
[136]997 ULONG amem = 0;
[2]998
[136]999 if (!DosQuerySysInfo(QSV_TOTAVAILMEM, QSV_TOTAVAILMEM,
1000 (PVOID) & amem, (ULONG) sizeof(amem)))
1001 {
[162]1002 CommaFmtUL(tm, sizeof(tm), amem,'M');
1003 if (!Dos16MemAvail(&amem))
1004 CommaFmtUL(szQty, sizeof(szQty), amem,'M');
[136]1005 else
[162]1006 *szQty = 0;
1007 sprintf(s, " %s%s%s%s",
[136]1008 GetPString(IDS_MEMTITLETEXT),
1009 szQty,
1010 (*szQty) ? "/" : NullStr,
[162]1011 tm);
[136]1012 WinSetDlgItemText(hwnd,
1013 MINI_MEM,
1014 s);
[2]1015 }
[136]1016 }
1017 return 0;
[2]1018
[136]1019 case UM_SETUP5: // Process status
1020 {
1021 CHAR s[134], tm[38], szQty[38];
1022
1023 if (fUseQProcStat && !noqproc)
[2]1024 {
1025
[136]1026 PROCESSINFO *ppi;
1027 BUFFHEADER *pbh = NULL;
1028 MODINFO *pmi;
1029 ULONG numprocs = 0, numthreads = 0;
[346]1030 APIRET rc;
[136]1031
[346]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
[136]1037 {
[346]1038 if (DosQProcStatus(pbh, USHRT_MAX))
1039 noqproc = TRUE;
1040 else {
[136]1041 ppi = pbh -> ppi;
1042 while (ppi -> ulEndIndicator != PROCESS_END_INDICATOR)
[36]1043 {
[136]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);
[36]1053 }
[136]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 }
[2]1068 }
[136]1069 else
[2]1070 {
[136]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);
[2]1080 }
[136]1081 }
1082 return 0;
[2]1083
[136]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)))
[2]1093 {
[136]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);
[2]1111 }
[136]1112 }
1113 return 0;
[2]1114
[136]1115 case WM_SAVEAPPLICATION:
1116 {
1117 SWP swp;
[2]1118
[136]1119 WinQueryWindowPos(WinQueryWindow(hwnd, QW_PARENT), &swp);
1120 PrfWriteProfileData(fmprof,
1121 appname,
1122 "DataMinPos",
1123 &swp,
1124 sizeof(SWP));
1125 }
1126 break;
[2]1127
[136]1128 case WM_CLOSE:
1129 WinSendMsg(hwnd,
1130 WM_SAVEAPPLICATION,
1131 MPVOID,
1132 MPVOID);
1133 WinDestroyWindow(WinQueryWindow(hwnd, QW_PARENT));
1134 return 0;
[2]1135
[136]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 {
[2]1146
[136]1147 SWP swp;
1148 ULONG fl = SWP_SHOW | SWP_ZORDER | SWP_ACTIVATE, ofl;
[2]1149
[136]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);
[2]1173
[136]1174} // DataProc
[2]1175
[136]1176//=== CreateDataBar - create databar windows ===
[2]1177
[136]1178HWND CreateDataBar(HWND hwndParent, ULONG fl)
1179{
1180 HWND hwndClient = (HWND) 0;
1181 ULONG FrameFlags = 0;
[2]1182
[136]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;
[2]1199
[136]1200} // CreateDataBar
[2]1201
[136]1202//=== dataminThread - drive status thread ===
[2]1203
[136]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,
[346]1224 pszSrcFile,
[136]1225 __LINE__,
1226 "Create Semaphore failed" // GetPString(IDS_CREATESEMFAILED)
1227 );
1228 busy = FALSE;
1229 }
1230 }
1231
[179]1232 // fixme to report errors
[136]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))
[2]1253 break;
1254
[136]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;
[2]1274
[136]1275 DosError(FERR_DISABLEHARDERR);
1276 pDM -> qfsi_rc = DosQueryFSInfo(dskNum,
1277 FSIL_ALLOC,
1278 &pDM -> fsa,
1279 sizeof(FSALLOCATE));
[2]1280
[136]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);
[2]1296
[136]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,
[346]1306 pszSrcFile,
[136]1307 __LINE__,
1308 "Wait Semaphore failed" // GetPString(IDS_POSTSEMFAILED)
1309 );
[2]1310 }
1311
[136]1312 rc = DosResetEventSem(G_hevDataMin,&clPosted);
1313 if (rc && rc != ERROR_ALREADY_RESET)
1314 {
1315 Dos_Error(MB_ENTER,
1316 rc,
1317 HWND_DESKTOP,
[346]1318 pszSrcFile,
[136]1319 __LINE__,
1320 "Reset Semaphore failed" // GetPString(IDS_POSTSEMFAILED)
1321 );
1322 }
1323 }
[2]1324
[136]1325 } // while
[2]1326
[136]1327 if (hmq != NULLHANDLE)
1328 WinDestroyMsgQueue(hmq);
[2]1329
[136]1330 if (hab != NULLHANDLE)
1331 WinTerminate(hab);
1332
1333} // dataminThread
Note: See TracBrowser for help on using the repository browser.