![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to box.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [OS/2 SDKs] / os2sdk / demos / apps / lqh|
Return to box.c CVS log | Up to [OS/2 SDKs] / os2sdk / demos / apps / lqh |
1.1 root 1: /****************************************************************************
2:
3: PROGRAM: Box.c
4:
5: PURPOSE: Dynamic Link Library for drawing boxes on the screen
6:
7: FUNCTIONS:
8: BoxSave() - Saves a rectangular area of the screen
9: BoxRestore() - Restores a rectangular area of the screen
10: BoxDraw() - Draws a box on the screen
11: BoxMessage() - Displays a message within a temporary box
12: BoxGetString() - Displays a box with a prompt, retrieves a string
13: BoxScroll() - Displays a vertical scroll bar
14:
15: COMMENTS:
16: This group of functions provides an easy method for saving and
17: restoring a rectangular area of the screen. An application calls
18: BoxSave() to save the requested portion of the screen along with
19: the current cursor position and cursor type. It calls BoxDraw() to
20: create a border around the area that is saved and to clear the
21: interior and optionally change the attributes of the interior.
22: When that application completes display to the box, it calls
23: BoxRestore() to restore the screen, cursor position, and cursor
24: type. These functions may be called as many times as there is
25: memory to store the screen.
26:
27: ****************************************************************************/
28: #define INCL_BASE /* Includes all of the OS/2 base */
29:
30: #include <os2.h> /* OS/2 include file */
31: #include "lqhdll.h"
32:
33: INT _acrtused = 0; /* no C startup */
34:
35: /****************************************************************************
36:
37: FUNCTION: BoxSave(QHBOX FAR *);
38:
39: PURPOSE: Saves a rectangular box on the screen
40:
41: COMMENTS:
42:
43: This function allocates enough memory to save the specified
44: rectangle of screen memory, the current cursor position, and the
45: currrent cursor type. It returns the selector to that memory, or
46: zero if it was unable to allocate the memory. The screen memory,
47: cursor position, and cursor type may be restored with a call to
48: BoxRestore().
49:
50: ****************************************************************************/
51:
52: SEL FAR PASCAL BoxSave(qhbBox)
53: QHBOX FAR *qhbBox;
54: {
55: PCH pchBoxSave; /* pointer to memory */
56: SEL selBoxSave; /* selector to memory */
57: USHORT usRow; /* current row */
58: USHORT usLen; /* length of each row */
59:
60: if (DosAllocSeg((((qhbBox->bottom + 1) - qhbBox->top) *
61: ((qhbBox->right + 1) - qhbBox->left)) * 2 + 12,
62: (PSEL) &selBoxSave, 0))
63: return (0L);
64: pchBoxSave = MAKEP(selBoxSave, 0);
65:
66: /* Save the current cursor position and cursor type */
67:
68: VioGetCurType((PVIOCURSORINFO) pchBoxSave, 0);
69: VioGetCurPos(MAKEP(selBoxSave, 8), MAKEP(selBoxSave, 10), 0);
70: pchBoxSave += 12;
71:
72: /* Save the screen by copying the screen cells into memory */
73:
74: usLen = ((qhbBox->right + 1) - qhbBox->left) * 2;
75: for (usRow = qhbBox->top; usRow <= qhbBox->bottom; usRow++) {
76: VioReadCellStr(pchBoxSave, /* address of the buffer */
77: &usLen, /* length of the buffer */
78: usRow, /* starting row */
79: qhbBox->left, /* starting column */
80: 0); /* Vio handle */
81: pchBoxSave += usLen;
82: }
83: return (selBoxSave); /* Returns selector to the saved screen data */
84: }
85:
86: /****************************************************************************
87:
88: FUNCTION: BoxRestore(QHBOX FAR *, SEL);
89:
90: PURPOSE: Restores a rectangular area of the screen
91:
92: COMMENTS:
93:
94: This function restores the cursor position, the cursor typye, and
95: the area of the screen that was previously saved with a call to the
96: BoxSave() function. After the data is restored, it frees the
97: allocated memory.
98:
99: ****************************************************************************/
100:
101: BOOL FAR PASCAL BoxRestore(qhbBox, selBoxSave)
102: QHBOX far *qhbBox;
103: SEL selBoxSave;
104: {
105: PCH pchBoxSave; /* pointer to memory */
106: USHORT usRow; /* current row */
107: USHORT usLen; /* length of each row */
108: PUSHORT pusCur;
109:
110: pchBoxSave = MAKEP(selBoxSave, 0);
111: pusCur = MAKEP(selBoxSave, 8);
112:
113: /* Restore the current cursor position and cursor type */
114:
115: VioSetCurType((PVIOCURSORINFO) pchBoxSave, 0);
116: VioSetCurPos(*pusCur, *(pusCur + 1), 0);
117: pchBoxSave += 12;
118:
119: /* Restore the screen */
120:
121: usLen = ((qhbBox->right + 1) - qhbBox->left) * 2;
122: for (usRow = qhbBox->top; usRow <= qhbBox->bottom; usRow++) {
123: VioWrtCellStr(pchBoxSave, /* address of the buffer */
124: usLen, /* length of the buffer */
125: usRow, /* starting row */
126: qhbBox->left, /* starting column */
127: 0); /* Vio handle */
128: pchBoxSave += usLen;
129: }
130: DosFreeSeg(selBoxSave); /* free the memory */
131: }
132:
133: /****************************************************************************
134:
135: FUNCTION: BoxDraw(QHBOX FAR *);
136:
137: PURPOSE: Draws a rectangular box on the screen
138:
139: COMMENTS:
140:
141: This function is used to draw a box on the screen. All the
142: information that is needed to draw the box is placed in a QHBOX
143: structure, and the pointer to that structure is passed as the
144: parameter to this function. The QHBOX structure is defined as:
145:
146: typedef struct _QHBOX {
147: USHORT top;
148: USHORT left;
149: USHORT bottom;
150: USHORT right;
151: INT FillAtt;
152: BYTE BorderAtt;
153: BYTE BoxType;
154: } QHBOX;
155:
156: The qhbBox.FillAtt contains an attribute that will be combined with
157: a space to clear the interior of the box. If the attribute is -1,
158: the interior of the box is not cleared.
159:
160: The attributes of the border are set by using the qhbBox.BorderAtt
161: parameter.
162:
163: The type of border is specified in the qhbBox.BoxType parameter.
164: The value is in the range between 0 to 2.
165:
166: 0 - no border
167: 1 - thin border
168: 2 - thick border
169:
170: Before calling BoxDraw(), an application should call BoxSave() if
171: it intends to restore the screen written to by the BoxDraw()
172: function.
173:
174: ****************************************************************************/
175:
176: VOID FAR PASCAL BoxDraw(qhbBox)
177: QHBOX FAR *qhbBox; /* box dimensions */
178: {
179: INT i;
180: CHAR chCell[2], chBox[6];
181: switch(qhbBox->BoxType) {
182: case 1: /* thin border */
183: chBox[0] = 218; /* upper-left corner */
184: chBox[1] = 192; /* lower-left corner */
185: chBox[2] = 217; /* lower-right corner */
186: chBox[3] = 191; /* upper-right corner */
187: chBox[4] = 196; /* horizontal line */
188: chBox[5] = 179; /* vertical line */
189: break;
190:
191: case 2: /* thick border */
192: chBox[0] = 201;
193: chBox[1] = 200;
194: chBox[2] = 188;
195: chBox[3] = 187;
196: chBox[4] = 205;
197: chBox[5] = 186;
198: break;
199:
200: default: /* no border */
201: chBox[0] = chBox[1] = chBox[2] = chBox[3] =
202: chBox[4] = chBox[5] = ' ';
203: break;
204: }
205:
206: chCell[1] = qhbBox->BorderAtt; /* Sets the border attribute */
207: chCell[0] = chBox[0]; /* Upper-left corner character */
208:
209: /* display the four corners of the box */
210:
211: VioWrtNCell(chCell, /* address of the cell */
212: 1, /* number of times to write the cell */
213: qhbBox->top, /* starting row */
214: qhbBox->left, /* starting column */
215: 0); /* Vio handle */
216: chCell[0] = chBox[1]; /* lower-left corner character */
217: VioWrtNCell(chCell, 1, qhbBox->bottom, qhbBox->left, 0);
218: chCell[0] = chBox[2]; /* lower-right corner character */
219: VioWrtNCell(chCell, 1, qhbBox->bottom, qhbBox->right, 0);
220: chCell[0] = chBox[3]; /* upper-right corner character */
221: VioWrtNCell(chCell, 1, qhbBox->top, qhbBox->right, 0);
222:
223: /* display the horizontal and vertical sides of the box */
224:
225: chCell[0] = chBox[4]; /* horizontal-line character */
226: VioWrtNCell(chCell, (qhbBox->right - qhbBox->left) - 1, qhbBox->top,
227: qhbBox->left + 1, 0);
228: VioWrtNCell(chCell, (qhbBox->right - qhbBox->left) - 1, qhbBox->bottom,
229: qhbBox->left + 1, 0);
230: chCell[0] = chBox[5]; /* vertical-line character */
231: for (i = qhbBox->top + 1; i < qhbBox->bottom; i++) {
232: VioWrtNCell(chCell, 1, i, qhbBox->left, 0);
233: VioWrtNCell(chCell, 1, i, qhbBox->right, 0);
234: }
235:
236: /* Clear the inside of the box by using spaces combined with the
237: * specified attribute.
238: */
239:
240: if (qhbBox->FillAtt != -1) { /* Does not clear if minus one */
241: chCell[1] = qhbBox->FillAtt;
242: chCell[0] = ' ';
243: VioScrollUp(qhbBox->top + 1, /* top row */
244: qhbBox->left + 1, /* left column */
245: qhbBox->bottom - 1, /* bottom row */
246: qhbBox->right - 1, /* right column */
247: (qhbBox->bottom - qhbBox->top) - 1, /* number of lines */
248: chCell, /* character-attribute cell */
249: 0); /* Vio handle */
250: }
251: }
252:
253:
254: /****************************************************************************
255:
256: FUNCTION: BoxMessage(PSZ, BYTE, BYTE, HMOU, BOOL);
257:
258: PURPOSE: Displays an alert box with the PSZ message inside
259:
260: COMMENTS:
261: This automatically saves the area of the screen that will be used
262: for the message box, creates the message box in the center of the
263: screen (with the message centered within the box), optionally
264: beeps, and waits for a key or mouse button to be pressed, and then
265: restores the portion of the screen used for the box.
266:
267: A zero may be passed instead of the handle to the mouse device.
268:
269: ****************************************************************************/
270:
271: VOID FAR PASCAL BoxMessage(pszMessage, bBorder, bType, hmou, bBell)
272: PSZ pszMessage; /* message to display */
273: BYTE bBorder; /* border and interior attribute */
274: BYTE bType; /* box line type */
275: HMOU hmou; /* handle to the current mouse */
276: BOOL bBell; /* TRUE to sound a warning tone */
277: {
278: KBDKEYINFO KbdKeyInfo; /* structure for key data */
279: MOUEVENTINFO MouInfo; /* mouse event packet structure */
280: QHBOX qhbBox; /* box dimensions */
281: SEL selBoxSave; /* selector to memory for screen save */
282: USHORT usMouNoWait = 0; /* Do not wait for mouse event */
283:
284: if (Dstrlen(pszMessage) > 77)
285: pszMessage[77] = 0;
286:
287: /* Set up the qhbBox structure */
288:
289: qhbBox.top = 11;
290: qhbBox.bottom = 13;
291: qhbBox.left = (79 - Dstrlen(pszMessage)) / 2;
292: qhbBox.right = (79 - qhbBox.left) + 1;
293: qhbBox.BorderAtt = bBorder;
294: qhbBox.FillAtt = (int) bBorder;
295: qhbBox.BoxType = bType;
296:
297: if (!(selBoxSave = BoxSave(&qhbBox))) /* Saves the screen */
298: return;
299: BoxDraw(&qhbBox); /* Draws the box */
300: VioWrtCharStr(pszMessage, Dstrlen(pszMessage), qhbBox.top + 1,
301: qhbBox.left + 1, 0); /* Writes the message */
302: if (bBell)
303: DosBeep(800, 200); /* Generates a beep */
304: do {
305: KbdCharIn(&KbdKeyInfo, /* buffer for data */
306: 1, /* Does not wait */
307: 0); /* keyboard handle */
308: if (hmou) {
309: MouReadEventQue(&MouInfo, &usMouNoWait, hmou);
310: if (MouInfo.fs < 1 && MouInfo.Time) /* button release */
311: break;
312: }
313: }
314: while (!KbdKeyInfo.fbStatus);
315: BoxRestore(&qhbBox, selBoxSave); /* Restores the screen */
316: }
317:
318: /****************************************************************************
319:
320: FUNCTION: BoxGetString(PSZ, PSZ, USHORT, BYTE);
321:
322: PURPOSE: Retrieves a string from the user
323:
324: COMMENTS:
325:
326: This function is used to retrieve a string from the user. It
327: displays a box wide enough to contain the prompt string and the
328: maximum size of the string buffer to retrieve. If the total exceeds
329: 78 characters, then the interior of the box will contain two lines.
330: The first line contains the prompt string, and the second line is
331: used for the input string.
332:
333: ****************************************************************************/
334:
335: BOOL FAR PASCAL BoxGetString(pszPrompt, pszDest, usMax, bAttrib, hmou)
336: PSZ pszPrompt; /* prompt string */
337: PSZ pszDest; /* destination buffer */
338: USHORT usMax; /* maximum string to retrieve */
339: BYTE bAttrib; /* box's attribute */
340: HMOU hmou; /* mouse handle */
341: {
342: KBDKEYINFO KbdKeyInfo; /* structure for key data */
343: MOUEVENTINFO MouInfo; /* mouse event packet structure */
344: VIOCURSORINFO CData; /* cursor data */
345: SEL selBoxSave;
346: QHBOX qhbBox; /* box dimensions */
347: USHORT usLine, usCol, usRow, usPos;
348: BOOL fLoop;
349: USHORT cbTotal, cbOutside, cbPrompt;
350: USHORT usMouNoWait = 0; /* Do not wait for mouse event */
351:
352: cbPrompt = Dstrlen(pszPrompt);
353: cbTotal = cbPrompt + usMax;
354: cbOutside = (cbTotal < 78) ? (79 - (cbTotal + 2)) / 2 : 0;
355: usRow = (cbTotal < 78) ? 1 : 2;
356: if (usMax > 78)
357: usMax = 78;
358:
359: qhbBox.top = 11;
360: qhbBox.bottom = qhbBox.top + usRow + 1;
361: qhbBox.left = cbOutside;
362: qhbBox.right = 79 - cbOutside;
363: qhbBox.BorderAtt = bAttrib;
364: qhbBox.FillAtt = bAttrib;
365: qhbBox.BoxType = 1;
366:
367: if (!(selBoxSave = BoxSave(&qhbBox)))
368: return 0L;
369: BoxDraw(&qhbBox);
370: VioGetCurType(&CData, 0); /* Gets current cursor data */
371: CData.attr = 0x00; /* Sets attribute to normal */
372: VioSetCurType(&CData, 0);
373: VioWrtCharStr(pszPrompt, cbPrompt, qhbBox.top + 1,
374: qhbBox.left + 1, 0);
375: usCol = (usRow > 1) ? 0 : qhbBox.left + cbPrompt + 1;
376: usPos = 0;
377:
378: for (fLoop = TRUE; fLoop;) {
379: VioSetCurPos(qhbBox.top + usRow, usCol + usPos + 1, 0);
380: do {
381: KbdCharIn(&KbdKeyInfo, /* address of buffer for keystroke */
382: IO_NOWAIT, /* wait/no-wait flag */
383: 0); /* logical keyboard handle */
384: if (hmou) {
385: MouReadEventQue(&MouInfo, &usMouNoWait, hmou);
386: if (MouInfo.fs < 1 && MouInfo.Time) {
387: KbdKeyInfo.chChar = 27;
388: break;
389: }
390: }
391: }
392: while (!KbdKeyInfo.fbStatus);
393:
394: switch(KbdKeyInfo.chChar) {
395: case 27: /* ESCAPE key */
396: BoxRestore(&qhbBox, selBoxSave);
397: return FALSE;
398:
399: case '\r': /* ENTER key */
400: fLoop = FALSE;
401: pszDest[usPos] = 0;
402: if (!usPos) { /* nothing entered */
403: BoxRestore(&qhbBox, selBoxSave);
404: return FALSE;
405: }
406: break;
407:
408: case 8: /* BACKSPACE key */
409: if (usPos) {
410: VioWrtNChar(" ", /* character */
411: 1, /* number of characters */
412: qhbBox.top + usRow, /* row */
413: usCol + usPos, /* column */
414: 0); /* Vio handle */
415: --usPos;
416: }
417: break;
418:
419: default:
420: if (usPos >= usMax)
421: DosBeep(800, 200);
422: else {
423: pszDest[usPos++] = KbdKeyInfo.chChar;
424: VioWrtNChar(&KbdKeyInfo.chChar, 1, qhbBox.top + usRow,
425: usCol + usPos, 0);
426: }
427: break;
428: }
429: }
430:
431: BoxRestore(&qhbBox, selBoxSave); /* Restores the screen */
432: return TRUE;
433: }
434:
435: /****************************************************************************
436:
437: FUNCTION: BoxScroll(QHBOX FAR *, USHORT, USHORT, BYTE);
438:
439: PURPOSE: Displays scroll bar and current position
440:
441: COMMENTS:
442:
443: This function draws a scroll bar on the right side of the box
444: displayed by the BoxDraw() function. It places a marker within the
445: scroll bar to indicate the relative position of the text within the
446: box.
447:
448: ****************************************************************************/
449:
450: VOID FAR PASCAL BoxScroll(qhbBox, usTotalLines, usCurLine, bAttib)
451: QHBOX FAR *qhbBox;
452: USHORT usTotalLines, usCurLine;
453: BYTE bAttib;
454: {
455: INT i;
456: USHORT usCount;
457: CHAR chCell[2];
458: USHORT cbBar;
459:
460: chCell[1] = bAttib;
461: chCell[0] = 176; /* side-scroll character */
462:
463: /* draw the side scroll bar */
464:
465: for (i = qhbBox->top + 2; i < qhbBox->bottom - 1; i++) {
466: VioWrtNCell(chCell, 1, i, qhbBox->right, 0);
467: }
468:
469: /* place arrows at the top and bottom */
470:
471: chCell[0] = 24; /* upward arrow */
472: VioWrtNCell(chCell, 1, qhbBox->top + 1, qhbBox->right, 0);
473: chCell[0] = 25; /* downward arrow */
474: VioWrtNCell(chCell, 1, qhbBox->bottom - 1, qhbBox->right, 0);
475:
476: /* Position the marker that indicates where the current line is
477: * relative to the total number of lines of text.
478: */
479:
480: chCell[0] = 178;
481: if (usCurLine > (usTotalLines - (qhbBox->bottom - qhbBox->top)) ||
482: usTotalLines < qhbBox->bottom)
483: usCount = qhbBox->bottom - 2;
484: else if (usCurLine == 1)
485: usCount = qhbBox->top + 2;
486: else {
487: cbBar = (qhbBox->bottom - qhbBox->top) - 3;
488: usCount = qhbBox->top + 2 +
489: ((usCurLine * cbBar) / (usTotalLines - cbBar));
490: }
491:
492: VioWrtNCell(chCell, 1, usCount, qhbBox->right, 0);
493: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.