source: trunk/dll/datamin.c@ 153

Last change on this file since 153 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
RevLine 
[30]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
[130]9 Copyright (c) 2001, 2005 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
[30]15
16***********************************************************************/
17
[2]18#define INCL_DOS
[136]19#define INCL_DOSERRORS
[2]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>
[136]29
[2]30#include "fm3dll.h"
31#include "fm3dlg.h"
32#include "fm3str.h"
33#include "procstat.h"
[136]34#include "datamin.h"
[2]35
36#pragma data_seg(DATA2)
37#pragma alloc_text(DATAMIN,DataDlgProc,MiniTimeProc)
38
[136]39APIRET16 APIENTRY16 Dos16MemAvail(PULONG pulAvailMem);
[2]40
[136]41static volatile HEV G_hevDataMin = NULLHANDLE;
42static volatile HWND G_hwndSingle = NULLHANDLE;
[2]43
[136]44static VOID dataminThread (VOID *pv);
[2]45
[136]46long MINI_X = 208, MINI_Y = 16;
[2]47
[136]48//=== MiniTimeProc - time, swap and drive status mini windows procedure ===
[2]49
[136]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;
[2]61
[136]62 case WM_BUTTON1CLICK:
63 {
64 USHORT id = WinQueryWindowUShort(hwnd, QWS_ID);
65
66 if (id >= MINI_DRIVEA)
[2]67 {
[136]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;
[2]96
[136]97 case WM_BUTTON1DBLCLK:
98 {
99 USHORT id = WinQueryWindowUShort(hwnd, QWS_ID);
[2]100
[136]101 if (id >= MINI_DRIVEA && !hwndMain)
102 {
103 CHAR s[] = " :\\";
[2]104
[136]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 }
[2]121
122#ifdef NEVER
[136]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 }
[2]133#endif
134
[136]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 {
[2]147
[136]148 char s[5];
[2]149
[136]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);
[2]159 }
[136]160 }
161 break;
[2]162
[136]163 case WM_BUTTON1MOTIONSTART:
164 PostMsg(WinQueryWindow(hwnd, QW_PARENT),
165 UM_BUTTON1MOTIONSTART,
166 MPVOID,
167 MPVOID);
168 break;
[2]169
[136]170 case WM_CONTEXTMENU:
171 PostMsg(WinQueryWindow(hwnd, QW_PARENT),
172 UM_CONTEXTMENU,
173 MPVOID,
174 MPVOID);
175 break;
[2]176
[136]177 case WM_PAINT:
178 {
179 MRESULT mr = 0;
180 USHORT id;
181
182 id = WinQueryWindowUShort(hwnd, QWS_ID);
183 if (id >= MINI_DRIVEA)
[2]184 {
[136]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;
[2]198
[136]199 case WM_DESTROY:
200 {
201 PVOID pv = WinQueryWindowPtr(hwnd, QWL_DATAMIN_PTR);
202 if (pv)
203 free(pv);
[2]204 }
[136]205 break;
[2]206 }
[136]207 return PFNWPStatic(hwnd, msg, mp1, mp2);
[2]208
[136]209} // MiniTimeProc
[2]210
[136]211//=== DataProc - databar client window procedure ===
[2]212
[136]213MRESULT EXPENTRY DataProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
214{
215 APIRET rc;
216
[2]217 static ULONG counter;
[136]218 static BOOL NoFloat, noqproc = FALSE, Positioned;
219 static HWND hwndMenu = (HWND) 0;
[2]220
[136]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;
[2]261 }
[136]262 for (c = 0; ids[c]; c++)
[2]263 {
[136]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);
[2]278 }
[136]279 }
280 if (!hwndMain)
281 {
282 SWCNTRL swctl;
[2]283
[136]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;
[2]299
[136]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 }
[2]359 }
[136]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;
[2]423 PostMsg(hwnd,
[136]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)
[2]465 return 0;
[136]466 break;
[2]467
[136]468 case WM_BUTTON2DBLCLK:
469 if (!(SHORT2FROMMP(mp2) & KC_SHIFT))
470 {
471 PostMsg(hwnd,
472 WM_COMMAND,
473 MPFROM2SHORT(MINI_FLOAT, 0),
474 MPVOID);
[2]475 break;
[136]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;
[2]485
[136]486 case UM_BUTTON1MOTIONSTART:
487 case WM_BUTTON1MOTIONSTART:
488 {
489 TRACKINFO TrackInfo;
490 SWP Position;
[2]491
[136]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))
[2]515 {
[136]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;
[2]523
[136]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);
[2]555 }
[136]556 break;
[2]557
[136]558 case IDM_HELP:
559 if (hwndHelp)
560 WinSendMsg(hwndHelp,
561 HM_DISPLAY_HELP,
562 MPFROM2SHORT(HELP_DATABAR, 0),
563 MPFROMSHORT(HM_RESOURCEID));
[2]564 break;
565
[136]566 case MINI_CLOSE:
567 PostMsg(hwnd,
568 WM_CLOSE,
569 MPVOID,
570 MPVOID);
[2]571 break;
572
[136]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 }
[2]592 }
[136]593
[2]594 break;
595
[136]596 case MINI_INCLREMOTE:
597 case MINI_SHOW:
598 if (SHORT1FROMMP(mp1) == MINI_SHOW)
[2]599 {
[136]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;
[2]620
[136]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);
[2]629 }
[136]630 PostMsg(hwnd, UM_SETUP, MPVOID, MPVOID);
[2]631 break;
632
[136]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 }
[2]658 break;
[136]659 }
660 return 0;
[2]661
[136]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;
[2]671
[136]672 case WM_PAINT:
673 {
674 HPS hps;
675 POINTL ptl;
676 SWP swp;
677 RECTL rcl;
[2]678
[136]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;
[2]705
[136]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;
[2]721
[136]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;
[2]738
[136]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";
[2]770
[136]771 ulPercentFree = (pDM -> fsa.cUnit && pDM -> fsa.cUnitAvail) ?
772 (pDM -> fsa.cUnitAvail * 100) / pDM -> fsa.cUnit :
773 0;
774 }
[2]775
[136]776 commafmt(szFreeQty, sizeof(szFreeQty), (ULONG)fltFreeQty);
777 *szDrvLtr = (CHAR)(id - MINI_DRIVEA) + 'A';
[2]778
[136]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];
[2]906
[136]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 }
[2]956 }
[136]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;
[2]974
[136]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;
[2]983
[136]984 if (*SwapperDat)
[2]985 {
[136]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;
[2]1044
[136]1045 case UM_SETUP3: // Memory utilization
1046 {
1047 CHAR s[134], tm[38], szQty[38], *pszUM, *tmk;
1048 ULONG amem = 0;
[2]1049
[136]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);
[2]1097 }
[136]1098 }
1099 return 0;
[2]1100
[136]1101 case UM_SETUP5: // Process status
1102 {
1103 CHAR s[134], tm[38], szQty[38];
1104
1105 if (fUseQProcStat && !noqproc)
[2]1106 {
1107
[136]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)
[36]1120 {
[136]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);
[36]1130 }
[136]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 }
[2]1148 }
[136]1149 else
[2]1150 {
[136]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);
[2]1161 }
[136]1162 }
1163 return 0;
[2]1164
[136]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)))
[2]1174 {
[136]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);
[2]1192 }
[136]1193 }
1194 return 0;
[2]1195
[136]1196 case WM_SAVEAPPLICATION:
1197 {
1198 SWP swp;
[2]1199
[136]1200 WinQueryWindowPos(WinQueryWindow(hwnd, QW_PARENT), &swp);
1201 PrfWriteProfileData(fmprof,
1202 appname,
1203 "DataMinPos",
1204 &swp,
1205 sizeof(SWP));
1206 }
1207 break;
[2]1208
[136]1209 case WM_CLOSE:
1210 WinSendMsg(hwnd,
1211 WM_SAVEAPPLICATION,
1212 MPVOID,
1213 MPVOID);
1214 WinDestroyWindow(WinQueryWindow(hwnd, QW_PARENT));
1215 return 0;
[2]1216
[136]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 {
[2]1227
[136]1228 SWP swp;
1229 ULONG fl = SWP_SHOW | SWP_ZORDER | SWP_ACTIVATE, ofl;
[2]1230
[136]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);
[2]1254
[136]1255} // DataProc
[2]1256
[136]1257//=== CreateDataBar - create databar windows ===
[2]1258
[136]1259HWND CreateDataBar(HWND hwndParent, ULONG fl)
1260{
1261 HWND hwndClient = (HWND) 0;
1262 ULONG FrameFlags = 0;
[2]1263
[136]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;
[2]1280
[136]1281} // CreateDataBar
[2]1282
[136]1283//=== dataminThread - drive status thread ===
[2]1284
[136]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))
[2]1334 break;
1335
[136]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;
[2]1355
[136]1356 DosError(FERR_DISABLEHARDERR);
1357 pDM -> qfsi_rc = DosQueryFSInfo(dskNum,
1358 FSIL_ALLOC,
1359 &pDM -> fsa,
1360 sizeof(FSALLOCATE));
[2]1361
[136]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);
[2]1377
[136]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 );
[2]1391 }
1392
[136]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 }
[2]1405
[136]1406 } // while
[2]1407
[136]1408 if (hmq != NULLHANDLE)
1409 WinDestroyMsgQueue(hmq);
[2]1410
[136]1411 if (hab != NULLHANDLE)
1412 WinTerminate(hab);
1413
1414} // dataminThread
Note: See TracBrowser for help on using the repository browser.