![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to status.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / samples / sdktools / windiff|
Return to status.c CVS log | Up to [WindowsNT SDKs] / mstools / samples / sdktools / windiff |
1.1 root 1:
2: /******************************************************************************\
3: * This is a part of the Microsoft Source Code Samples.
4: * Copyright (C) 1993 Microsoft Corporation.
5: * All rights reserved.
6: * This source code is only intended as a supplement to
7: * Microsoft Development Tools and/or WinHelp documentation.
8: * See these sources for detailed information regarding the
9: * Microsoft samples programs.
10: \******************************************************************************/
11:
12: /****************************** Module Header *******************************
13: * Module Name: STATUS.C
14: *
15: * Status line handler.
16: *
17: * Functions:
18: *
19: * StatusInit()
20: * StatusCreate()
21: * StatusHeight()
22: * StatusAlloc()
23: * StatusAddItem()
24: * StatusCreateTools()
25: * StatusDeleteTools()
26: * StatusWndProc()
27: * StatusResize()
28: * StatusCalcHeight()
29: * StatusCalcWidth()
30: * StatusGetItem()
31: * LowerRect()
32: * RaiseRect()
33: * StatusPaint()
34: * BottomRight()
35: * TopLeft()
36: * StatusButtonDown()
37: * StatusButtonUp()
38: * InitDC()
39: *
40: * Comments:
41: *
42: ****************************************************************************/
43:
44: #include <windows.h>
45: #include <string.h>
46:
47: #include "gutils.h"
48:
49:
50: /* --- data structures ------------------------------------------------- */
51: #define SF_MAXLABEL 80 /* no more than 80 in an item within the bar */
52: /* Is this adequate for long pathnames on a
53: hi-res screen?
54: */
55:
56: typedef struct statel {
57: int type; /* SF_BUTTON or SF_STATIC */
58: int flags; /* SF_VAR => variable width
59: SF_LEFT=> left aligned (else right)
60: SF_RAISE=> paint as 'raised' 3d rect
61: SF_LOWER=> paint as lowered 3D rect
62: SF_SZMIN=>together with SF_VAR
63: allows minimum size for
64: var sized item
65: SF_SZMAX=>see SZMIN and use nouse
66: */
67: int id; /* control id */
68: int width; /* width of control in chars */
69: char text[SF_MAXLABEL+1]; /* null-term string for label */
70:
71: RECT rc; /* used by status.c */
72: } STATEL, FAR * PSTATEL;
73:
74: typedef struct itemlist {
75: int nitems;
76: PSTATEL statels;
77:
78: int selitem; /* used by status.c */
79: BOOL isselected; /* used by status.c */
80: } ILIST, FAR * PILIST;
81:
82: /* prototypes of routines in this module */
83:
84: void StatusCreateTools(void);
85: void StatusDeleteTools(void);
86: long APIENTRY StatusWndProc(HWND, UINT, UINT, LONG);
87: void StatusResize(HWND hWnd, PILIST pilist);
88: int StatusCalcHeight(HWND hWnd, PSTATEL ip);
89: int StatusCalcWidth(HWND hWnd, PSTATEL ip);
90: PSTATEL StatusGetItem(PILIST plist, int id);
91: void LowerRect(HDC hDC, LPRECT rcp);
92: void RaiseRect(HDC hDC, LPRECT rcp);
93: void StatusPaint(HWND hWnd, PILIST iplistp);
94: void BottomRight(HDC hDC, LPRECT rcp, HPEN hpen, BOOL bCorners);
95: void TopLeft(HDC hDC, LPRECT rcp, HPEN hpen, BOOL bCorners);
96: void StatusButtonDown(HDC hDC, PSTATEL ip);
97: void StatusButtonUp(HDC hDC, PSTATEL ip);
98: void InitDC(HDC hdc);
99:
100:
101: /*--global data---------------------------------------------------------*/
102:
103: HPEN hpenHilight, hpenLowlight;
104: HPEN hpenBlack, hpenNeutral;
105: HBRUSH hbrBackground; /* pieces and board */
106: HFONT hFont;
107: int status_charheight, status_charwidth;
108:
109: /* default pt size for font (tenths of a pt) */
110: #define DEF_PTSIZE 80
111:
112: /***************************************************************************
113: * Function: StatusInit
114: *
115: * Purpose:
116: *
117: * Create window class
118: */
119: BOOL
120: StatusInit(HANDLE hInstance)
121: {
122: WNDCLASS wc;
123: BOOL resp;
124: TEXTMETRIC tm;
125: HDC hDC;
126:
127:
128: StatusCreateTools();
129:
130: wc.style = CS_HREDRAW|CS_VREDRAW|CS_GLOBALCLASS;
131: wc.lpfnWndProc = (WNDPROC) StatusWndProc;
132: wc.cbClsExtra = 0;
133: wc.cbWndExtra = sizeof(HANDLE);
134: wc.hInstance = hInstance;
135: wc.hIcon = NULL;
136: wc.hCursor = LoadCursor(NULL, IDC_ARROW);
137: wc.hbrBackground = hbrBackground;
138: wc.lpszClassName = (LPSTR) "gdstatusclass";
139: wc.lpszMenuName = NULL;
140:
141: resp = RegisterClass(&wc);
142:
143: hDC = GetDC(NULL);
144: InitDC(hDC);
145: GetTextMetrics(hDC, &tm);
146: status_charheight = (int)(tm.tmHeight + tm.tmExternalLeading);
147: status_charwidth = (int)tm.tmAveCharWidth;
148: ReleaseDC(NULL, hDC);
149:
150: return(resp);
151: }
152:
153: /*
154: /***************************************************************************
155: * Function: StatusCreate
156: *
157: * Purpose:
158: *
159: * Create and show the window
160: */
161: HWND APIENTRY
162: StatusCreate(HANDLE hInst, HWND hParent, int id, LPRECT rcp, HANDLE hmem)
163: {
164:
165: HWND hWnd;
166:
167: /* create a child window of status class */
168:
169:
170: hWnd = CreateWindow("gdstatusclass",
171: NULL,
172: WS_CHILD | WS_VISIBLE,
173: rcp->left,
174: rcp->top,
175: (rcp->right - rcp->left),
176: (rcp->bottom - rcp->top),
177: hParent,
178: (HANDLE) id,
179: hInst,
180: (LPVOID) hmem);
181:
182: return(hWnd);
183: }
184:
185: /***************************************************************************
186: * Function: StatusHeight
187: *
188: * Purpose:
189: *
190: * Return default height of this window
191: */
192: int APIENTRY
193: StatusHeight(HANDLE hmem)
194: /* The window has a number of items which are arranged horizontally,
195: so the window height is the maximum of the individual heights
196: */
197: {
198: PILIST plist;
199: int i;
200: int sz;
201: int maxsize = 0;
202:
203: plist = (PILIST) GlobalLock(hmem);
204: if (plist != NULL) {
205: for (i = 0; i<plist->nitems; i++) {
206: sz = StatusCalcHeight(NULL, &plist->statels[i]);
207: maxsize = max(sz, maxsize);
208: }
209: }
210: GlobalUnlock(hmem);
211: if (maxsize > 0) {
212: return(maxsize + 4);
213: } else {
214: return(status_charheight + 4);
215: }
216: }
217:
218: /***************************************************************************
219: * Function: StatusAlloc
220: *
221: * Purpose:
222: *
223: * Alloc the plist struct and return handle to caller
224: */
225: HANDLE FAR PASCAL
226: StatusAlloc(int nitems)
227: {
228: HANDLE hmem;
229: PILIST pilist;
230: LPSTR chp;
231:
232: hmem = GlobalAlloc(GMEM_MOVEABLE|GMEM_ZEROINIT,
233: sizeof(ILIST) + (sizeof(STATEL) * nitems));
234: chp = GlobalLock(hmem);
235: if (chp == NULL) {
236: return(NULL);
237: }
238:
239: pilist = (PILIST) chp;
240: pilist->nitems = nitems;
241: pilist->statels = (PSTATEL) &chp[sizeof(ILIST)];
242: GlobalUnlock(hmem);
243:
244: return(hmem);
245: }
246:
247:
248: /***************************************************************************
249: * Function: StatusAddItem
250: *
251: * Purpose:
252: *
253: * Insert an item into the plist
254: */
255: BOOL FAR PASCAL
256: StatusAddItem(HANDLE hmem, int itemnr, int type, int flags, int id,
257: int width, LPSTR text)
258: {
259: PILIST pilist;
260: PSTATEL pel;
261:
262: pilist = (PILIST) GlobalLock(hmem);
263: if ((pilist == NULL) || (itemnr >= pilist->nitems)) {
264: GlobalUnlock(hmem);
265: return(FALSE);
266: }
267: pel = &pilist->statels[itemnr];
268: pel->type = type;
269: pel->flags = flags;
270: pel->id = id;
271: pel->width = width;
272: if (text == NULL) {
273: pel->text[0] = '\0';
274: } else {
275: lstrcpy(pel->text, text);
276: }
277:
278:
279: GlobalUnlock(hmem);
280: return(TRUE);
281: }
282:
283: /***************************************************************************
284: * Function: InitDC
285: *
286: * Purpose:
287: *
288: * Initialize colors and font
289: */
290: void
291: InitDC(HDC hdc)
292: {
293: SetBkColor(hdc, RGB(192,192,192));
294: SelectObject(hdc, hbrBackground);
295: SelectObject(hdc, hFont);
296: }
297:
298:
299: /***************************************************************************
300: * Function: StatusCreateTools
301: *
302: * Purpose:
303: *
304: * Create Pens and brushes
305: */
306: void
307: StatusCreateTools()
308: {
309: LOGFONT lf;
310: HDC hdc;
311: int scale;
312:
313: hbrBackground = CreateSolidBrush(RGB(192,192,192));
314: hpenHilight = CreatePen(0, 1, RGB(255, 255, 255));
315: hpenLowlight = CreatePen(0, 1, RGB(128, 128, 128));
316: hpenNeutral = CreatePen(0, 1, RGB(192, 192, 192));
317: hpenBlack = CreatePen(0, 1, RGB(0, 0, 0));
318:
319: hdc = GetDC(NULL);
320: scale = GetDeviceCaps(hdc, LOGPIXELSY);
321: ReleaseDC(NULL, hdc);
322:
323: lf.lfHeight = -MulDiv(DEF_PTSIZE, scale, 720);
324: lf.lfWidth = 0;
325: lf.lfEscapement = 0;
326: lf.lfOrientation = 0;
327: lf.lfWeight = FW_REGULAR;
328: lf.lfItalic = 0;
329: lf.lfUnderline = 0;
330: lf.lfStrikeOut = 0;
331: lf.lfCharSet = ANSI_CHARSET;
332: lf.lfOutPrecision = OUT_DEFAULT_PRECIS;
333: lf.lfClipPrecision = CLIP_DEFAULT_PRECIS;
334: lf.lfQuality = PROOF_QUALITY;
335: lf.lfPitchAndFamily = VARIABLE_PITCH | FF_SWISS;
336: lf.lfFaceName[0] = '\0';
337: #ifdef COMPLEX
338: hFont = CreateFontIndirect(&lf);
339: #else
340: hFont = GetStockObject(SYSTEM_FONT);
341: #endif
342:
343:
344:
345: }
346:
347: /***************************************************************************
348: * Function: StatusDeleteTools
349: *
350: * Purpose:
351: *
352: * Delete brushes and pens
353: */
354: void
355: StatusDeleteTools()
356: {
357: DeleteObject(hbrBackground);
358: DeleteObject(hpenHilight);
359: DeleteObject(hpenLowlight);
360: DeleteObject(hpenBlack);
361: DeleteObject(hpenNeutral);
362:
363: #ifdef COMPLEX
364: DeleteObject(hFont);
365: #endif
366: }
367:
368: /***************************************************************************
369: * Function: StatusWndProc
370: *
371: * Purpose:
372: *
373: * Main winproc for status windows
374: *
375: * handles create/destroy and paint requests
376: */
377:
378: long FAR PASCAL
379: StatusWndProc(HWND hWnd, UINT message, UINT wParam, LONG lParam)
380: {
381: HANDLE hitems;
382: PSTATEL ip;
383: PILIST plist;
384: CREATESTRUCT FAR * cp;
385: int i;
386: HDC hDC;
387: RECT rc;
388: POINT pt;
389:
390: switch(message) {
391:
392: case WM_CREATE:
393: cp = (CREATESTRUCT FAR *) lParam;
394: hitems = (HANDLE) (LONG) cp->lpCreateParams;
395: SetWindowLong(hWnd, 0, (LONG)hitems);
396: plist = (PILIST) GlobalLock(hitems);
397: if (plist != NULL) {
398: plist->selitem = -1;
399: GlobalUnlock(hitems);
400: }
401: break;
402:
403: case WM_SIZE:
404: hitems = (HANDLE) GetWindowLong(hWnd, 0);
405: plist = (PILIST) GlobalLock(hitems);
406: if (plist != NULL) {
407: StatusResize(hWnd, plist);
408: GlobalUnlock(hitems);
409: }
410: break;
411:
412: case WM_PAINT:
413: hitems = (HANDLE) GetWindowLong(hWnd, 0);
414: plist = (PILIST) GlobalLock(hitems);
415: StatusPaint(hWnd, plist);
416: GlobalUnlock(hitems);
417:
418: break;
419:
420: case WM_LBUTTONUP:
421: hitems = (HANDLE) GetWindowLong(hWnd, 0);
422: plist = (PILIST) GlobalLock(hitems);
423: pt.x = LOWORD(lParam);
424: pt.y = HIWORD(lParam);
425:
426: if (plist == NULL) {
427: break;
428: }
429: if (plist->selitem != -1) {
430: ip = &plist->statels[plist->selitem];
431: if (plist->isselected) {
432: hDC = GetDC(hWnd);
433: InitDC(hDC);
434: StatusButtonUp(hDC, ip);
435: ReleaseDC(hWnd, hDC);
436: }
437: plist->selitem = -1;
438: ReleaseCapture();
439: if (PtInRect(&ip->rc, pt)) {
440: SendMessage(GetParent(hWnd), WM_COMMAND,
441: MAKELONG(ip->id, WM_LBUTTONUP), (LONG)hWnd);
442: }
443: }
444: GlobalUnlock(hitems);
445: break;
446:
447: case WM_LBUTTONDOWN:
448: hitems = (HANDLE) GetWindowLong(hWnd, 0);
449: plist = (PILIST) GlobalLock(hitems);
450: if (plist == NULL) {
451: break;
452: }
453: pt.x = LOWORD(lParam);
454: pt.y = HIWORD(lParam);
455: if (plist->selitem == -1) {
456: for (i = 0; i< plist->nitems; i++) {
457: ip = &plist->statels[i];
458: if (PtInRect(&ip->rc, pt)) {
459: if (ip->type != SF_BUTTON) {
460: break;
461: }
462: plist->selitem = i;
463: SetCapture(hWnd);
464:
465: plist->isselected = TRUE;
466: hDC = GetDC(hWnd);
467: InitDC(hDC);
468: StatusButtonDown(hDC, ip);
469: ReleaseDC(hWnd, hDC);
470: break;
471: }
472: }
473: }
474: GlobalUnlock(hitems);
475: break;
476:
477: case WM_MOUSEMOVE:
478: hitems = (HANDLE) GetWindowLong(hWnd, 0);
479: plist = (PILIST) GlobalLock(hitems);
480: if (plist == NULL) {
481: break;
482: }
483: pt.x = LOWORD(lParam);
484: pt.y = HIWORD(lParam);
485: if (plist->selitem != -1) {
486: ip = &plist->statels[plist->selitem];
487: if (PtInRect(&ip->rc, pt)) {
488: if (!plist->isselected) {
489: hDC = GetDC(hWnd);
490: InitDC(hDC);
491: StatusButtonDown(hDC, ip);
492: ReleaseDC(hWnd, hDC);
493: plist->isselected = TRUE;
494: }
495: } else {
496: if(plist->isselected) {
497: hDC = GetDC(hWnd);
498: InitDC(hDC);
499: StatusButtonUp(hDC, ip);
500: ReleaseDC(hWnd, hDC);
501: plist->isselected = FALSE;
502: }
503: }
504: }
505: GlobalUnlock(hitems);
506: break;
507:
508:
509: case WM_DESTROY:
510:
511: hitems = (HANDLE) GetWindowLong(hWnd, 0);
512: GlobalUnlock(hitems);
513: GlobalFree(hitems);
514:
515: SetWindowLong(hWnd, 0, 0L);
516: break;
517:
518: case SM_NEW:
519: hitems = (HANDLE) GetWindowLong(hWnd, 0);
520: if (hitems != NULL) {
521: GlobalFree(hitems);
522: }
523: hitems = (HANDLE) wParam;
524: if (hitems == NULL) {
525: SetWindowLong(hWnd, 0, 0L);
526: InvalidateRect(hWnd, NULL, TRUE);
527: break;
528: }
529: plist = (PILIST) GlobalLock(hitems);
530: if (plist == NULL) {
531: SetWindowLong(hWnd, 0, 0L);
532: InvalidateRect(hWnd, NULL, TRUE);
533: break;
534: }
535: plist->selitem = -1;
536: StatusResize(hWnd, plist);
537: GlobalUnlock(hitems);
538: SetWindowLong(hWnd, 0, (LONG)hitems);
539: InvalidateRect(hWnd, NULL, TRUE);
540: break;
541:
542: case SM_SETTEXT:
543: hitems = (HANDLE) GetWindowLong(hWnd, 0);
544: if (hitems == NULL) {
545: break;
546: }
547: plist = (PILIST) GlobalLock(hitems);
548: ip = StatusGetItem(plist, wParam);
549: if (ip != NULL) {
550: if (lParam == 0) {
551: ip->text[0] = '\0';
552: } else {
553: strncpy(ip->text, (LPSTR) lParam, SF_MAXLABEL);
554: ip->text[SF_MAXLABEL] = '\0';
555: }
556:
557: /* if this is a variable width field, we need to redo
558: * all size calcs in case the field width has changed.
559: * in that case, we need to repaint the entire window
560: * and not just this field - so set rc to indicate the
561: * area to be redrawn.
562: */
563: if (ip->flags & SF_VAR) {
564: StatusResize(hWnd, plist);
565: GetClientRect(hWnd, &rc);
566: RedrawWindow(hWnd, &rc, NULL,
567: RDW_INVALIDATE|RDW_ERASE|RDW_UPDATENOW);
568: } else {
569: /* instead of just invalidating the window, we can
570: * force the window to be repainted now. This is
571: * essential for status updates during a busy
572: * loop when no messages are being processed,
573: * but we should still update the user on what's
574: * happening.
575: */
576: RedrawWindow(hWnd, &ip->rc, NULL,
577: RDW_INVALIDATE|RDW_NOERASE|RDW_UPDATENOW);
578: }
579:
580: }
581: GlobalUnlock(hitems);
582: break;
583:
584: default:
585: return(DefWindowProc(hWnd, message, wParam, lParam));
586: }
587: return 0;
588: }
589:
590: /***************************************************************************
591: * Function: StatusResize
592: *
593: * Purpose:
594: *
595: * Position the labels and buttons within the status window
596: */
597: void
598: StatusResize(HWND hWnd, PILIST iplistp)
599: {
600: RECT rc;
601: int curpos_right, curpos_left;
602: int height, width;
603: int i;
604: PSTATEL ip;
605:
606:
607: if (iplistp == NULL) {
608: return;
609: }
610: GetClientRect(hWnd, &rc);
611: curpos_left = rc.left + status_charwidth / 2;
612: curpos_right = rc.right - (status_charwidth / 2);
613:
614: /* loop through all items setting their position rects.
615: * items are flagged as being left or right. We place them
616: * in order starting at the left and the right, with a single
617: * char's width between each item
618: */
619: for (i = 0; i < iplistp->nitems; i++) {
620: ip = &iplistp->statels[i];
621:
622: width = StatusCalcWidth(hWnd, ip);
623: height = StatusCalcHeight(hWnd, ip);
624: ip->rc.top = (rc.bottom - height) / 2;
625: ip->rc.bottom = ip->rc.top + height;
626:
627: /* see if this item fits. Items that partially fit
628: * are placed reduced in size.
629: */
630: if (ip->flags & SF_LEFT) {
631:
632: if (curpos_left+width >= curpos_right) {
633: /* doesn't completely fit-does it partly? */
634: if ((curpos_left + 1) >= curpos_right){
635:
636: /* no - this item does not fit */
637: ip->rc.left = 0;
638: ip->rc.right = 0;
639: } else {
640: /* partial fit */
641: ip->rc.left = curpos_left;
642: ip->rc.right = curpos_right - 1;
643: curpos_left = curpos_right;
644: }
645: } else {
646: /* complete fit */
647: ip->rc.left = curpos_left;
648: ip->rc.right = curpos_left + width;
649: curpos_left += width + 1;
650: }
651: } else {
652:
653: /* same size check for right-aligned items */
654: if (curpos_right-width <= curpos_left) {
655:
656: /* partial fit ? */
657: if (curpos_right <= curpos_left+1) {
658: ip->rc.left = 0;
659: ip->rc.right = 0;
660: } else {
661: /* yes - partial fit */
662: ip->rc.left = curpos_left + 1;
663: ip->rc.right = curpos_right;
664: curpos_right = curpos_left;
665: }
666: } else {
667: /* complete fit */
668: ip->rc.right = curpos_right;
669: ip->rc.left = curpos_right - width;
670: curpos_right -= (width + 1);
671: }
672: }
673: }
674: }
675:
676:
677: /***************************************************************************
678: * Function: StatusPaint
679: *
680: * Purpose:
681: *
682: * Paint the status window
683: */
684: void
685: StatusPaint(HWND hWnd, PILIST iplistp)
686: {
687: RECT rc;
688: HDC hDC;
689: PAINTSTRUCT ps;
690: int i;
691: PSTATEL ip;
692: HPEN hpenOld;
693:
694: GetClientRect(hWnd, &rc);
695: hDC = BeginPaint(hWnd, &ps);
696: InitDC(hDC);
697:
698: RaiseRect(hDC, &rc);
699: if (iplistp == NULL) {
700: EndPaint(hWnd, &ps);
701: return;
702: }
703: for (i =0; i < iplistp->nitems; i++) {
704: ip = &iplistp->statels[i];
705:
706: if (ip->rc.left == ip->rc.right) {
707: continue;
708: }
709: if (ip->type == SF_STATIC) {
710: if (ip->flags & SF_RAISE) {
711: RaiseRect(hDC, &ip->rc);
712: } else if (ip->flags & SF_LOWER) {
713: LowerRect(hDC, &ip->rc);
714: }
715: rc = ip->rc;
716: rc.left += (status_charwidth / 2);
717: rc.right--;
718: rc.top++;
719: rc.bottom--;
720: hpenOld = SelectObject(hDC, hpenNeutral);
721: Rectangle(hDC, rc.left, rc.top, rc.right, rc.bottom);
722: SelectObject(hDC, hpenOld);
723: DrawText(hDC, ip->text, lstrlen(ip->text), &rc,
724: DT_LEFT | DT_VCENTER);
725: } else {
726: StatusButtonUp(hDC, ip);
727: }
728: }
729:
730: EndPaint(hWnd, &ps);
731: }
732:
733: /***************************************************************************
734: * Function: RaiseRect
735: *
736: * Purpose:
737: *
738: */
739: void
740: RaiseRect(HDC hDC, LPRECT rcp)
741: {
742: TopLeft(hDC, rcp, hpenHilight, FALSE);
743: BottomRight(hDC, rcp, hpenLowlight, FALSE);
744: }
745:
746: /***************************************************************************
747: * Function: LowerRect
748: *
749: * Purpose:
750: *
751: */
752: void
753: LowerRect(HDC hDC, LPRECT rcp)
754: {
755: TopLeft(hDC, rcp, hpenLowlight, FALSE);
756: BottomRight(hDC, rcp, hpenHilight, FALSE);
757: }
758:
759: /***************************************************************************
760: * Function: StatusButtonUp
761: *
762: * Purpose:
763: *
764: */
765: void
766: StatusButtonUp(HDC hDC, PSTATEL ip)
767: {
768: RECT rc;
769: HPEN hpenOld;
770:
771: rc = ip->rc;
772: TopLeft(hDC, &rc, hpenBlack, TRUE);
773: BottomRight(hDC, &rc, hpenBlack, FALSE);
774:
775: rc.top++;
776: rc.bottom--;
777: rc.left++;
778: rc.right--;
779: TopLeft(hDC, &rc, hpenHilight, FALSE);
780: BottomRight(hDC, &rc, hpenLowlight, TRUE);
781:
782: rc.top++;
783: rc.bottom--;
784: rc.left++;
785: rc.right--;
786: BottomRight(hDC, &rc, hpenLowlight, TRUE);
787: rc.bottom--;
788: rc.right--;
789: hpenOld = SelectObject(hDC, hpenNeutral);
790: Rectangle(hDC, rc.left, rc.top, rc.right, rc.bottom);
791: SelectObject(hDC, hpenOld);
792: DrawText(hDC, ip->text, lstrlen(ip->text), &rc, DT_CENTER | DT_VCENTER);
793: }
794:
795: /***************************************************************************
796: * Function: StatusButtonDown
797: *
798: * Purpose:
799: *
800: */
801: void
802: StatusButtonDown(HDC hDC, PSTATEL ip)
803: {
804: RECT rc;
805: HPEN hpenOld;
806:
807: rc = ip->rc;
808: TopLeft(hDC, &rc, hpenBlack, TRUE);
809: BottomRight(hDC, &rc, hpenBlack, FALSE);
810:
811: rc.top++;
812: rc.bottom--;
813: rc.left++;
814: rc.right--;
815: TopLeft(hDC, &rc, hpenLowlight, TRUE);
816: rc.top++;
817: rc.left++;
818: TopLeft(hDC, &rc, hpenNeutral, TRUE);
819: rc.top++;
820: rc.left++;
821: TopLeft(hDC, &rc, hpenNeutral, TRUE);
822: rc.top++;
823: rc.left++;
824: hpenOld = SelectObject(hDC, hpenNeutral);
825: Rectangle(hDC, rc.left, rc.top, rc.right, rc.bottom);
826: SelectObject(hDC, hpenOld);
827: DrawText(hDC, ip->text, lstrlen(ip->text), &rc, DT_CENTER | DT_VCENTER);
828: }
829:
830: /***************************************************************************
831: * Function: TopLeft
832: *
833: * Purpose:
834: *
835: */
836: void
837: TopLeft(HDC hDC, LPRECT rcp, HPEN hpen, BOOL bCorners)
838: {
839: HPEN hpenOld;
840: int x, y;
841:
842: hpenOld = SelectObject(hDC, hpen);
843: x = rcp->right - 1;
844: y = rcp->bottom;
845: if (!bCorners) {
846: x--;
847: y--;
848: }
849: MoveToEx(hDC, x, rcp->top, NULL);
850: LineTo(hDC, rcp->left, rcp->top);
851: LineTo(hDC, rcp->left, y);
852: SelectObject(hDC, hpenOld);
853: }
854:
855: /***************************************************************************
856: * Function: BottomRight
857: *
858: * Purpose:
859: *
860: */
861: void
862: BottomRight(HDC hDC, LPRECT rcp, HPEN hpen, BOOL bCorners)
863: {
864: HPEN hpenOld;
865: int x, y;
866:
867: hpenOld = SelectObject(hDC, hpen);
868: x = rcp->left - 1;
869: y = rcp->top;
870: if (!bCorners) {
871: x++;
872: y++;
873: }
874: MoveToEx(hDC, rcp->right-1, y, NULL);
875: LineTo(hDC, rcp->right-1, rcp->bottom-1);
876: LineTo(hDC, x, rcp->bottom-1);
877: SelectObject(hDC, hpenOld);
878: }
879:
880: /***************************************************************************
881: * Function: StatusGetItem
882: *
883: * Purpose:
884: *
885: */
886: PSTATEL
887: StatusGetItem(PILIST plist, int id)
888: {
889: int i;
890:
891: if (plist == NULL) {
892: return(NULL);
893: }
894: for (i = 0; i < plist->nitems; i++) {
895: if (plist->statels[i].id == id) {
896: return(&plist->statels[i]);
897: }
898: }
899: return(NULL);
900: }
901:
902: /***************************************************************************
903: * Function: StatusCalcWidth
904: *
905: * Purpose:
906: *
907: * Calculate the width of a given field. This is the width in characters
908: * multiplied by the average character width, plus a few units for
909: * borders.
910: *
911: * If SF_VAR is set, this field size varies depending on the text, so
912: * we use GetTextExtent for the field size. If SF_VAR is selected, the caller
913: * can specify that the size is not to exceed the (width * avecharwidth)
914: * size (using SF_SZMAX) or that it is not be less than it (SF_SZMIN).
915: */
916: int
917: StatusCalcWidth(HWND hWnd, PSTATEL ip)
918: {
919: int ch_size, t_size;
920: SIZE sz;
921: HDC hDC;
922:
923: ch_size = ip->width * status_charwidth;
924: if (ip->flags & SF_VAR) {
925: hDC = GetDC(hWnd);
926: InitDC(hDC);
927: GetTextExtentPoint(hDC, ip->text, lstrlen(ip->text), &sz);
928: ReleaseDC(hWnd, hDC);
929: t_size = sz.cx;
930:
931: /*
932: * check this size against min/max size if
933: * requested
934: */
935:
936: if (ip->flags & SF_SZMIN) {
937: if (ch_size > t_size) {
938: t_size = ch_size;
939: }
940: }
941: if (ip->flags & SF_SZMAX) {
942: if (ch_size < t_size) {
943: t_size = ch_size;
944: }
945: }
946: ch_size = t_size;
947: }
948:
949: if (ch_size != 0) {
950: if (ip->type == SF_BUTTON) {
951: return(ch_size+6);
952: } else {
953: return(ch_size+4);
954: }
955: } else {
956: return(0);
957: }
958: }
959:
960: /***************************************************************************
961: * Function: StatusCalcHeight
962: *
963: * Purpose:
964: *
965: * Calculate the height of a given field
966: */
967: int
968: StatusCalcHeight(HWND hWnd, PSTATEL ip)
969: {
970: int size;
971:
972: size = status_charheight;
973: if (ip->type == SF_BUTTON) {
974: return(size + 6);
975: } else {
976: return(size + 2);
977: }
978: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.