![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to wmchar.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [OS/2 SDKs] / pmsdk / samples / wmchar|
Return to wmchar.c CVS log | Up to [OS/2 SDKs] / pmsdk / samples / wmchar |
1.1 root 1: /***************************************************************************\
2: * wmchar.c -- Displays WM_CHAR messages
3: *
4: * Created by Microsoft Corporation, 1989
5: \***************************************************************************/
6:
7:
8: #define INCL_WIN
9: #define INCL_GPILCIDS
10: #include <os2.h>
11: #include <string.h>
12: #include <stdio.h>
13: #include "wmchar.h"
14:
15:
16: #define max2(a, b) ((a) > (b) ? (a) : (b))
17: #define min2(a, b) ((a) < (b) ? (a) : (b))
18:
19:
20: /* display dependent values */
21: SHORT gcyChar;
22: SHORT gcxAveChar;
23: SHORT gcxMaxChar;
24: SHORT gcxMargin;
25:
26: /* program globals */
27: USHORT gcMessages = 0; /* also the "number" of the most recent message */
28: CHAR gszNull[] = " --"; /* denotes an empty field */
29: BOOL gfKeyUps = FALSE;
30:
31:
32: /* char messages are stored in a circular buffer */
33: typedef struct _CHMSG { /* cm */
34: USHORT usKC;
35: UCHAR uchRep;
36: UCHAR uchScan;
37: USHORT ch;
38: USHORT usVK;
39: } CHMSG;
40:
41: #define CBUFFERELTS 20
42:
43: CHMSG gacm[CBUFFERELTS];
44: SHORT gicmStart = 0;
45:
46:
47: /* display field attributes are stored in an array */
48: typedef struct _MSGFIELD { /* mf */
49: BOOL fDisplay; /* TRUE if field is currently being displayed */
50: SHORT cxWidth; /* field width, initially chars, then pixels */
51: CHAR *szHeading; /* field heading */
52: } MSGFIELD;
53:
54: #define INUMBER 0
55: #define IVIRTUALKEY 1
56: #define ICHAR 2
57: #define ISCANCODE 3
58: #define IREPEAT 4
59: #define IFLAGS 5
60:
61: MSGFIELD gamf[CDISPLAYFIELDS] = {
62: TRUE, 7, " #",
63: TRUE, 15, "VK_ Value",
64: TRUE, 14, "Char",
65: FALSE, 10, "Scan",
66: FALSE, 8, "Rep",
67: TRUE, 0, "KC_ Flags" /* variable width, so it's last */
68: };
69:
70: SHORT gcxMargin = 3;
71:
72:
73: /* char flag strings */
74: CHAR *gachFlags[] = {
75: "char",
76: "virtualkey",
77: "scancode",
78: "shift",
79: "ctrl",
80: "alt",
81: "keyup",
82: "prevdown",
83: "lonekey",
84: "deadkey",
85: "composite",
86: "invalidcomp",
87: "toggle",
88: "invalidchar",
89: "dbcsrsrvd1",
90: "dbcsrsrvd2"
91: };
92:
93: /* virtual key strings */
94: CHAR *gachVK[] = {
95: gszNull,
96: "button1",
97: "button2",
98: "button3",
99: "break",
100: "backspace",
101: "tab",
102: "backtab",
103: "newline",
104: "shift",
105: "ctrl",
106: "alt",
107: "altgraf",
108: "pause",
109: "capslock",
110: "esc",
111: "space",
112: "pageup",
113: "pagedown",
114: "end",
115: "home",
116: "left",
117: "up",
118: "right",
119: "down",
120: "printscrn",
121: "insert",
122: "delete",
123: "scrllock",
124: "numlock",
125: "enter",
126: "sysrq",
127: "f1",
128: "f2",
129: "f3",
130: "f4",
131: "f5",
132: "f6",
133: "f7",
134: "f8",
135: "f9",
136: "f10",
137: "f11",
138: "f12",
139: "f13",
140: "f14",
141: "f15",
142: "f16",
143: "f17",
144: "f18",
145: "f19",
146: "f20",
147: "f21",
148: "f22",
149: "f23",
150: "f24"
151: };
152:
153:
154:
155: /***************************************************************************\
156: * DrawText
157: *
158: * This function displays a text string.
159: *
160: * Parameters:
161: * hps: presentation space
162: * cx, cy: point to begin drawing
163: * sz: string to draw
164: * iColor: text color
165: * fExtent: whether to calc extent or not
166: *
167: * Returns:
168: * x position of end of painted string if fExtent == TRUE
169: \***************************************************************************/
170:
171: SHORT DrawText(
172: HPS hps,
173: SHORT cx,
174: SHORT cy,
175: CHAR *sz,
176: LONG iColor,
177: BOOL fExtent)
178: {
179: RECTL rcl;
180: SHORT cch;
181:
182: cch = strlen(sz);
183:
184: rcl.xLeft = cx;
185: rcl.xRight = cx + cch * gcxMaxChar; /* hack */
186: rcl.yBottom = cy;
187: rcl.yTop = cy + gcyChar;
188:
189: WinDrawText(hps, cch, (PCH)sz, (PRECTL)&rcl, iColor, SYSCLR_WINDOW, 0);
190:
191: if (fExtent) {
192: WinDrawText(hps, cch, (PCH)sz, (PRECTL)&rcl, iColor,
193: SYSCLR_WINDOW, DT_QUERYEXTENT);
194: return (SHORT)rcl.xRight;
195: }
196:
197: return 0;
198: }
199:
200:
201:
202: /***************************************************************************\
203: * FormatHexChar
204: *
205: * This function formats an unsigned hex number into a string. It is needed
206: * to get around shortcomings of sprintf().
207: *
208: * Parameters:
209: * uch: number to format
210: * sz: string to get number
211: \***************************************************************************/
212:
213: VOID FormatHexChar(
214: USHORT uch,
215: CHAR *sz)
216: {
217: sprintf(sz, "0x%2x", uch);
218:
219: /* patch up hex byte display */
220: if (strlen(sz) > 4) {
221: /* remove sign extension of byte */
222: sz[2] = sz[4];
223: sz[3] = sz[5];
224: sz[4] = 0;
225: } else if (sz[2] == ' ') {
226: /* fill in blank with 0 */
227: sz[2] = '0';
228: }
229: }
230:
231:
232:
233: /***************************************************************************\
234: * DrawMessage
235: *
236: * This function draws a single message line.
237: *
238: * Parameters:
239: * hps: presentation space
240: * iMessage: message number to display
241: * pcm: pointer to message structure
242: * cy: y position of message
243: \***************************************************************************/
244:
245: VOID DrawMessage(
246: HPS hps,
247: SHORT iMessage,
248: CHMSG *pcm,
249: SHORT cy)
250: {
251: CHAR sz[16];
252: USHORT fsFlags;
253: SHORT i;
254: SHORT cx;
255:
256: cx = gcxMargin;
257:
258: if (gamf[INUMBER].fDisplay) {
259: /* draw message number */
260: sprintf(sz, "%u.", iMessage);
261: DrawText(hps, cx, cy, sz, SYSCLR_WINDOWTEXT, FALSE);
262: cx += gamf[INUMBER].cxWidth;
263: }
264:
265: if (gamf[IVIRTUALKEY].fDisplay) {
266: /* draw virtual key code */
267: DrawText(hps, cx, cy, gachVK[pcm->usVK], SYSCLR_WINDOWTEXT,
268: FALSE);
269: cx += gamf[IVIRTUALKEY].cxWidth;
270: }
271:
272: if (gamf[ICHAR].fDisplay) {
273: /* draw character */
274: if ((CHAR)pcm->ch) {
275: FormatHexChar(pcm->ch, sz);
276: DrawText(hps, cx, cy, sz, SYSCLR_WINDOWTEXT, FALSE);
277: sprintf(sz, "'%c'", (CHAR)pcm->ch);
278: DrawText(hps, cx + 7 * gcxAveChar, cy, sz, SYSCLR_WINDOWTEXT,
279: FALSE);
280: } else {
281: DrawText(hps, cx, cy, gszNull, SYSCLR_WINDOWTEXT, FALSE);
282: }
283: cx += gamf[ICHAR].cxWidth;
284: }
285:
286: if (gamf[ISCANCODE].fDisplay) {
287: if (pcm->uchScan) {
288: FormatHexChar(pcm->uchScan, sz);
289: DrawText(hps, cx, cy, sz, SYSCLR_WINDOWTEXT, FALSE);
290: } else {
291: DrawText(hps, cx, cy, gszNull, SYSCLR_WINDOWTEXT, FALSE);
292: }
293: cx += gamf[ISCANCODE].cxWidth;
294: }
295:
296: if (gamf[IREPEAT].fDisplay) {
297: sprintf(sz, "%u", pcm->uchRep);
298: DrawText(hps, cx, cy, sz, SYSCLR_WINDOWTEXT, FALSE);
299: cx += gamf[IREPEAT].cxWidth;
300: }
301:
302: if (gamf[IFLAGS].fDisplay) {
303: /* draw KC_ flags */
304: fsFlags = pcm->usKC;
305: for (i = 0; i < 16; i++) {
306: if (fsFlags & 1) {
307: switch (i) {
308: case 0:
309: if (gamf[ICHAR].fDisplay)
310: goto DF_PRINTIT;
311: break;
312: case 1:
313: if (gamf[IVIRTUALKEY].fDisplay)
314: goto DF_PRINTIT;
315: break;
316: case 2:
317: if (gamf[ISCANCODE].fDisplay)
318: goto DF_PRINTIT;
319: break;
320: default:
321: DF_PRINTIT:
322: cx = DrawText(hps, cx, cy, gachFlags[i], SYSCLR_WINDOWTEXT, TRUE);
323: cx += gcxAveChar;
324: }
325: }
326: fsFlags >>= 1;
327: }
328: cx += gamf[IFLAGS].cxWidth;
329: }
330: }
331:
332:
333:
334: /***************************************************************************\
335: * PaintClient
336: *
337: * This function paints a client window.
338: *
339: * Parameters:
340: * hwnd: window handle
341: \***************************************************************************/
342:
343: VOID PaintClient(
344: HWND hwnd)
345: {
346: HPS hps;
347: RECTL rcl;
348: SHORT iMessage;
349: SHORT yBottom;
350: SHORT cx;
351: SHORT i;
352:
353: hps = WinBeginPaint(hwnd, (HPS)NULL, (PRECTL)&rcl);
354:
355: /* clear invalidated region */
356: WinFillRect(hps, (PRECTL)&rcl, SYSCLR_WINDOW);
357:
358: /* get y position to start drawing */
359: WinQueryWindowRect(hwnd, (PRECTL)&rcl);
360: yBottom = (SHORT)(rcl.yTop - gcyChar - gcyChar / 2);
361:
362: /* draw headings */
363: cx = gcxMargin;
364: for (i = 0; i < CDISPLAYFIELDS; i++) {
365: if (gamf[i].fDisplay) {
366: DrawText(hps, cx, yBottom, gamf[i].szHeading,
367: SYSCLR_WINDOWSTATICTEXT, FALSE);
368: cx += gamf[i].cxWidth;
369: }
370: }
371:
372: /* draw each entry */
373: i = gicmStart;
374: iMessage = gcMessages;
375: yBottom -= (gcyChar + gcyChar / 2);
376: do {
377: if (!iMessage || yBottom < -gcyChar)
378: break;
379:
380: DrawMessage(hps, iMessage, &gacm[i], yBottom);
381:
382: i = (i + 1) % CBUFFERELTS;
383: iMessage--;
384: yBottom -= gcyChar;
385:
386: } while (i != gicmStart);
387:
388: WinEndPaint(hps);
389: }
390:
391:
392:
393: /***************************************************************************\
394: * NewMessage
395: *
396: * This function adds a new WM_CHAR message to the list.
397: *
398: * Parameters:
399: * hwnd: window handle
400: * mp1, mp2:
401: * usKC: key flags
402: * usVK: virtual key code
403: * ch: char;
404: \***************************************************************************/
405:
406: VOID NewMessage(
407: HWND hwnd,
408: MPARAM mp1,
409: MPARAM mp2)
410: {
411: RECTL rclScroll, rclUpdate;
412: HPS hps;
413:
414: /* overwrite oldest entry */
415: if (gicmStart)
416: gicmStart--;
417: else
418: gicmStart = CBUFFERELTS - 1;
419:
420: gacm[gicmStart].usKC = SHORT1FROMMP(mp1);
421: gacm[gicmStart].uchRep = CHAR3FROMMP(mp1);
422: gacm[gicmStart].uchScan = CHAR4FROMMP(mp1);
423: gacm[gicmStart].ch = SHORT1FROMMP(mp2);
424: gacm[gicmStart].usVK = SHORT2FROMMP(mp2);
425:
426: gcMessages++;
427:
428: /* scroll and update intelligently */
429: WinQueryWindowRect(hwnd, (PRECTL)&rclScroll);
430: rclScroll.yTop -= 2 * gcyChar;
431: rclScroll.yBottom = max2(0L, rclScroll.yTop - (LONG)(CBUFFERELTS * gcyChar));
432:
433: WinScrollWindow(hwnd, 0, -gcyChar, (PRECTL)&rclScroll, (PRECTL)&rclScroll,
434: NULL, &rclUpdate, 0);
435:
436: hps = WinGetPS(hwnd);
437: WinFillRect(hps, (PRECTL)&rclUpdate, SYSCLR_WINDOW);
438: DrawMessage( hps
439: , gcMessages
440: , &gacm[gicmStart]
441: , (SHORT)rclScroll.yTop - gcyChar );
442: WinReleasePS(hps);
443: }
444:
445:
446:
447: /***************************************************************************\
448: * CheckMenuItem
449: *
450: * This function sets the check state of a menu item.
451: *
452: * Parameters:
453: * hwnd: frame window
454: * id: menu id
455: * fCheck: check state
456: \***************************************************************************/
457:
458: VOID CheckMenuItem(
459: HWND hwndFrame,
460: SHORT id,
461: BOOL fCheck)
462: {
463: HWND hwndMenu;
464:
465: /* toggle menu checkmark */
466: hwndMenu = WinWindowFromID(hwndFrame, FID_MENU);
467: WinSendMsg(hwndMenu, MM_SETITEMATTR, MPFROM2SHORT(id, TRUE),
468: MPFROM2SHORT(MIA_CHECKED, fCheck ? MIA_CHECKED : 0));
469: }
470:
471:
472:
473: /***************************************************************************\
474: * MenuCommand
475: *
476: * This function processes WM_COMMAND messages.
477: *
478: * Parameters:
479: * hwnd: client window handle
480: * id: command identifier
481: \***************************************************************************/
482:
483: VOID MenuCommand(
484: HWND hwnd,
485: SHORT id)
486: {
487: BOOL *pfDisplay;
488: HWND hwndFrame;
489:
490: if (id == IDM_CLEAR) {
491:
492: /* clear current messages */
493: gcMessages = 0;
494: WinInvalidateRect(hwnd, NULL, FALSE);
495:
496: } else if (id == IDM_KEYUPS) {
497:
498: /* toggle logging keyups */
499: gfKeyUps = !gfKeyUps;
500: hwndFrame = WinQueryWindow(hwnd, QW_PARENT, FALSE);
501: CheckMenuItem(hwndFrame, IDM_KEYUPS, gfKeyUps);
502:
503: } else if (id >= IDM_DISPLAYFIRST && id <= IDM_DISPLAYLAST) {
504:
505: /* toggle display field */
506: pfDisplay = &(gamf[id - IDM_DISPLAYFIRST].fDisplay);
507: *pfDisplay = !*pfDisplay;
508: hwndFrame = WinQueryWindow(hwnd, QW_PARENT, FALSE);
509: CheckMenuItem(hwndFrame, id, *pfDisplay);
510:
511: /* repaint in new format */
512: WinInvalidateRect(hwnd, NULL, FALSE);
513: }
514: }
515:
516:
517:
518: /***************************************************************************\
519: * MainWndProc
520: *
521: * This is the window procedure for the main client window.
522: \***************************************************************************/
523:
524: MRESULT CALLBACK MainWndProc(
525: HWND hwnd,
526: USHORT msg,
527: MPARAM mp1,
528: MPARAM mp2)
529: {
530: switch (msg) {
531:
532: case WM_PAINT:
533: PaintClient(hwnd);
534: break;
535:
536: case WM_COMMAND:
537: MenuCommand(hwnd, SHORT1FROMMP(mp1));
538: break;
539:
540: case WM_CHAR:
541: if (gfKeyUps || !(KC_KEYUP & SHORT1FROMMP(mp1))) {
542:
543: /* add new message to list */
544: NewMessage(hwnd, mp1, mp2);
545: }
546: break;
547:
548: default:
549: return WinDefWindowProc(hwnd, msg, mp1, mp2);
550: }
551:
552: return (MRESULT)0;
553: }
554:
555:
556:
557: /***************************************************************************\
558: * CheckMenus
559: *
560: * This function sets menu check marks according to their current internal
561: * state.
562: *
563: * Parameters:
564: * hwndFrame: main app window handle
565: \***************************************************************************/
566:
567: VOID CheckMenus(
568: HWND hwndFrame)
569: {
570: SHORT id;
571:
572: CheckMenuItem(hwndFrame, IDM_KEYUPS, gfKeyUps);
573:
574: for (id = IDM_DISPLAYFIRST; id <= IDM_DISPLAYLAST; id++) {
575: CheckMenuItem(hwndFrame, id, gamf[id - IDM_DISPLAYFIRST].fDisplay);
576: }
577: }
578:
579:
580:
581: /***************************************************************************\
582: * RegisterSwitchEntry
583: *
584: * This function registers the app with the switch list.
585: *
586: * Parameters:
587: * hwndFrame: main app window handle
588: \***************************************************************************/
589:
590: VOID RegisterSwitchEntry(
591: HWND hwndFrame)
592: {
593: PID pid;
594: TID tid;
595: SWCNTRL swc;
596:
597: WinQueryWindowProcess(hwndFrame, (PPID)&pid, (PTID)&tid);
598: WinQueryWindowText(hwndFrame, MAXNAMEL, (PSZ)swc.szSwtitle);
599: swc.hwnd = hwndFrame;
600: swc.hwndIcon = (ULONG)NULL;
601: swc.hprog = (HPROGRAM)NULL;
602: swc.idProcess = pid;
603: swc.idSession = NULL;
604: swc.uchVisibility = SWL_VISIBLE;
605: swc.fbJump = SWL_JUMPABLE;
606: WinAddSwitchEntry((PSWCNTRL)&swc);
607: }
608:
609:
610:
611: /***************************************************************************\
612: * GetDisplayValues
613: *
614: * This function sets display dependent global variables.
615: \***************************************************************************/
616:
617: VOID GetDisplayValues(VOID)
618: {
619: HPS hps;
620: FONTMETRICS fm;
621: SHORT i;
622:
623: hps = WinGetPS(HWND_DESKTOP);
624: GpiQueryFontMetrics(hps, (ULONG)sizeof(FONTMETRICS), (PFONTMETRICS)&fm);
625: WinReleasePS(hps);
626:
627: gcyChar = (SHORT)(fm.lMaxBaselineExt + fm.lExternalLeading);
628: gcxAveChar = (SHORT)fm.lAveCharWidth;
629: gcxMaxChar = (SHORT)fm.lMaxCharInc;
630:
631: /* adjust display widths for this font */
632: gcxMargin *= gcxAveChar;
633: for (i = 0; i < CDISPLAYFIELDS; i++) {
634: gamf[i].cxWidth *= gcxAveChar;
635: }
636: }
637:
638:
639:
640: /***************************************************************************\
641: * main
642: *
643: * This is the main procedure for the app.
644: \***************************************************************************/
645:
646: VOID cdecl main(VOID)
647: {
648: HAB hab;
649: HMQ hmq;
650: QMSG qmsg;
651: ULONG ulCreate;
652: HWND hwndFrame;
653: HWND hwndClient;
654: static CHAR szApp[] = "Char Messages";
655:
656: /* init app */
657: hab = WinInitialize(NULL);
658: hmq = WinCreateMsgQueue(hab, 0);
659: GetDisplayValues();
660:
661: /* create main window */
662: WinRegisterClass(hab, szApp, MainWndProc, 0L, 0);
663: ulCreate = FCF_TITLEBAR | FCF_SYSMENU | FCF_MINMAX | FCF_SIZEBORDER |
664: FCF_MENU | FCF_SHELLPOSITION;
665: hwndFrame = WinCreateStdWindow(HWND_DESKTOP, WS_VISIBLE, &ulCreate,
666: szApp, szApp, 0L, NULL, ID_RESOURCES,
667: &hwndClient);
668:
669: /* register with switch list */
670: RegisterSwitchEntry(hwndFrame);
671:
672: /* initialize menu */
673: CheckMenus(hwndFrame);
674:
675: /* message loop */
676: while (WinGetMsg(hab, &qmsg, NULL, 0, 0))
677: WinDispatchMsg(hab, &qmsg);
678:
679: /* clean up */
680: WinDestroyWindow(hwndFrame);
681: WinDestroyMsgQueue(hmq);
682: WinTerminate(hab);
683: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.