![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to avio.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [OS/2 SDKs] / pmsdk / samples / browse / avbrowse|
Return to avio.c CVS log | Up to [OS/2 SDKs] / pmsdk / samples / browse / avbrowse |
1.1 root 1: /*
2: avio.c -- AVIO action routines
3:
4: Implements scrollbars, sets up an AVIO Presentation Space
5: */
6: #define INCL_AVIO
7: #define INCL_DEV
8: #define INCL_VIO
9: #define INCL_WINWINDOWMGR
10: #define INCL_WINSYS
11: #define INCL_WINMESSAGEMGR
12: #define INCL_WINTRACKRECT
13: #define INCL_WINFRAMEMGR
14: #define INCL_WINSCROLLBARS
15: #include <os2.h>
16: #include <string.h> /* One strlen() call in the Blast() macro */
17: #include "avio.h" /* Get Avio-prefixed routine prototypes */
18: /*
19: Constants
20: */
21: char Blank[2] = { 0x20, 0x07 }; /* <Space> + EGA white attribute */
22: /*
23: Macros to make the code more readable
24: */
25: /* Upper and Lower Bound Calculations */
26: #define Abs(a) (((a) > 0) ? (a) : (-(a)))
27: #define Min(a,b) (((a) < (b)) ? (a) : (b))
28: #define Max(a,b) (((a) > (b)) ? (a) : (b))
29: #define LowerBound(pos, disp, lbound) Max(pos - disp, lbound)
30: #define UpperBound(pos, disp, ubound) Min(pos + disp, ubound)
31:
32: /* Scroll Bar Abbreviations */
33: #define DisableSB(hSB) WinSetParent(hSB, HWND_OBJECT, TRUE)
34: #define EnableSB(hSB) WinSetParent(hSB, hWndFrame, TRUE)
35: #define SetScroll(h, pos, max) \
36: WinSendMsg(h, SBM_SETSCROLLBAR, MPFROM2SHORT(pos, 0), MPFROM2SHORT(0, max))
37:
38: /* Scrollbar redraw macros */
39: #define UpdateOn(c, hsb) if (!(++c)) WinEnableWindowUpdate(hsb, TRUE)
40: #define UpdateOff(c, hsb) if (!(c--)) WinEnableWindowUpdate(hsb, FALSE)
41: #define UpdateFrame(sb) \
42: WinSendMsg(hWndFrame, WM_UPDATEFRAME, MPFROMLONG(sb), 0L)
43:
44: /* Scrolling Macros */
45: #define ClearScreen() ScrollUp(-1) /* Scroll up an "infinite" # lines */
46: #define ScrollDown(n) VioScrollDn(0, 0, -1, -1, n, Blank, hVPS)
47: #define ScrollUp(n) VioScrollUp(0, 0, -1, -1, n, Blank, hVPS)
48:
49: /* RectL -> SWP conversion macros */
50: #define lcx(r) ((r.xRight - r.xLeft) + 1)
51: #define lcy(r) ((r.yTop - r.yBottom) + 1)
52:
53: /* Miscellaneous macros */
54: #define Blast(l, x, y) VioWrtCharStr(l, Min(strlen(l), cxChScreen), x, y, hVPS)
55: #define CalcChars(sPg, sCh) \
56: ((sCh) ? (Max(((sPg) / (sCh)), 0)) : 0)
57: #define SetCellSize(h,w) VioSetDeviceCellSize(h, w, hVPS)
58: #define Value(value) WinQuerySysValue(HWND_DESKTOP, value)
59: /*
60: File-Local Variables
61: */
62: HDC hDC; /* Device Context */
63: HVPS hVPS; /* Virtual PS */
64: int iTopLine; /* PS Line of window corner */
65: int iCurCol; /* Current column of window corner */
66: int cxChPage; /* Width and height of our window, in characters */
67: int cyChPage;
68: int iMaxHorz; /* Scroll bar upper bounds */
69: int iMaxVert;
70: BOOL fNeedHorz; /* Do we need the scroll bars or not? */
71: BOOL fNeedVert;
72: HWND hWndHorzSB; /* Window handles of ScrollBar windows */
73: HWND hWndVertSB;
74: extern HWND hWndFrame; /* Client, frame windows */
75: extern HWND hWndClient;
76: PFNWP pfnOldClient; /* Old Client Window Procedure pointer */
77: PFNWP pfnOldFrame; /* Old Frame Window Procedure pointer */
78: SHORT cyChPS; /* Number of rows in AVIO PS */
79: SHORT cxChPS; /* Number of cols in AVIO PS */
80: SHORT cyChScreen; /* Number of rows in display space */
81: SHORT cxChScreen; /* Number of cols in display space */
82: PFNQL pfnQueryLine;
83: /*
84: Measurements used to help make the window look nice
85: */
86: LONG cxConstant, cyConstant; /* Miscellaneous frame lens */
87: int cxMaxFrame, cyMaxFrame; /* Maximum frame widths */
88: LONG lChWidth, lChHeight;
89: SHORT cxMaxClient, cyMaxClient; /* Client area bounds */
90: BOOL fCreatedPS; /* AVIO PS created */
91: int cHUpdate = -1; /* Keep track of updates */
92: int cVUpdate = -1;
93: /*
94: Local prototypes
95: */
96: void FixScroll(BOOL, BOOL, HWND, ULONG, int *, int, int *);
97: void UpdateScrollBars(RECTL);
98: void Refresh(void);
99: void Update(USHORT, USHORT, USHORT);
100: /*
101: The actual routines
102: */
103: void AvioInit(PLBINFO plbi) {
104: /*
105: Initialize Presentation Space, Device Context, Scroll Bars
106: */
107: VIOCURSORINFO vci;
108: /*
109: Initialize the line buffer info
110: */
111: cyChScreen = plbi->sRows;
112: cxChScreen = plbi->sCols;
113: cyChPS = plbi->sPSrows;
114: cxChPS = plbi->sPScols;
115: pfnQueryLine = plbi->pfnQL;
116: /*
117: One Time Initializations...
118: */
119: if (!fCreatedPS) {
120: /*
121: Create the AVIO Presentation Space, with one attribute byte
122: */
123: hDC = WinOpenWindowDC(hWndClient); /* Open the device context */
124: VioCreatePS(&hVPS, cyChPS, cxChPS + 1, 0, 1, 0);
125: VioAssociate(hDC, hVPS); /* Link the PS with the DC */
126: /*
127: Turn off the cursor (set invisible attribute)
128: */
129: VioGetCurType(&vci, hVPS);
130: vci.attr = -1;
131: VioSetCurType(&vci, hVPS);
132: /*
133: Measure the frame components
134: */
135: cxConstant = 0;
136: cyConstant = Value(SV_CYTITLEBAR) + Value(SV_CYMENU);
137: /*
138: Snag scroll bar info
139: */
140: hWndHorzSB = WinWindowFromID(hWndFrame, FID_HORZSCROLL);
141: hWndVertSB = WinWindowFromID(hWndFrame, FID_VERTSCROLL);
142: fNeedHorz = fNeedVert = TRUE;
143: /*
144: Setup the Client and Frame routines
145: */
146: pfnOldFrame = WinSubclassWindow(hWndFrame, AvioFrameWndProc);
147: pfnOldClient = WinSubclassWindow(hWndClient, AvioClientWndProc);
148: fCreatedPS = TRUE;
149: }
150: /*
151: Repaint the screen
152: */
153: iTopLine = iCurCol = 0;
154: AvioStartup(plbi->fLargeFont);
155: }
156:
157: void AvioStartup(BOOL fLargeFont) {
158: /*
159: Clear the screen, set the font, redraw the area
160: */
161: RECTL rclFrame;
162:
163: ClearScreen();
164: AvioLargeFont(fLargeFont);
165: WinQueryWindowRect(hWndFrame, &rclFrame);
166: UpdateScrollBars(rclFrame);
167: Update(0, cyChPS, 0);
168: }
169:
170: void AvioScroll(USHORT SB_Command, USHORT Position, BOOL Horizontal) {
171: /*
172: Process the scroll bar messages
173:
174: These routines are symmetric; in fact, SB_LINELEFT = SB_LINEUP, etc...
175: so one might note that this could be condensed. It's left expanded for
176: speed and clarity. The scrollbar values are bounded to stay inside
177: the Presentation Space.
178: */
179: if (Horizontal) { /* Horizontal Scroll Bar */
180: switch (SB_Command) {
181: case SB_LINELEFT:
182: iCurCol = LowerBound(iCurCol, 1, 0); break;
183: case SB_LINERIGHT:
184: iCurCol = UpperBound(iCurCol, 1, iMaxHorz); break;
185: case SB_PAGELEFT:
186: iCurCol = LowerBound(iCurCol, cxChPage, 0); break;
187: case SB_PAGERIGHT:
188: iCurCol = UpperBound(iCurCol, cxChPage, iMaxHorz); break;
189: case SB_SLIDERTRACK:
190: iCurCol = (SHORT) Position;
191: default: break;
192: }
193: if (SB_Command != SB_SLIDERTRACK)
194: SetScroll(hWndHorzSB, iCurCol, iMaxHorz);
195:
196: } else { /* Vertical Scroll Bar */
197: switch (SB_Command) {
198: case SB_LINEUP:
199: iTopLine = LowerBound(iTopLine, 1, 0); break;
200: case SB_LINEDOWN:
201: iTopLine = UpperBound(iTopLine, 1, iMaxVert); break;
202: case SB_PAGEUP:
203: iTopLine = LowerBound(iTopLine, cyChPage, 0); break;
204: case SB_PAGEDOWN:
205: iTopLine = UpperBound(iTopLine, cyChPage, iMaxVert);break;
206: case SB_SLIDERTRACK:
207: iTopLine = (SHORT) Position;
208: default: break;
209: }
210: if (SB_Command != SB_SLIDERTRACK)
211: SetScroll(hWndVertSB, iTopLine, iMaxVert);
212: }
213: Refresh();
214: }
215:
216: MRESULT AvioSize(HWND hWnd, USHORT msg, MPARAM mp1, MPARAM mp2) {
217: /*
218: Do the default AVIO sizing, and kyfe a few values
219: */
220: RECTL rclFrame;
221:
222: if (!fCreatedPS) return 0L;
223: /*
224: Update the scroll bars, and the screen
225: */
226: WinQueryWindowRect(hWndFrame, &rclFrame);
227: UpdateScrollBars(rclFrame);
228: /*
229: Now, do the normal AVIO processing
230: */
231: return WinDefAVioWindowProc(hWnd, msg, mp1, mp2);
232: }
233:
234: void Update(USHORT usLineNum, USHORT usHowMany, USHORT usStartLine) {
235: /*
236: Updates N lines starting from START line on screen.
237: Starts at saved line LINENUM.
238: */
239: USHORT i; /* Loop index variable */
240: USHORT usWhichLine = usLineNum; /* Line number to be queried */
241: char *szLine;
242:
243: for (i = usStartLine; i < (usStartLine + usHowMany); i++) {
244: szLine = (*pfnQueryLine)(usWhichLine++); /* Get the line */
245: if (szLine) Blast(szLine, i, 0); /* Print it out */
246: }
247: }
248:
249: void Refresh(void) {
250: /*
251: Do the origin shifting and screen updating
252: */
253: SHORT Delta;
254: int static iOldTopLine = 0;
255:
256: VioSetOrg(0, iCurCol, hVPS); /* Get the free AVIO horizontal shift */
257: Delta = iTopLine - iOldTopLine; /* Compute vertical shift */
258: if (Abs(Delta) < cyChPS) {
259: if (Delta < 0) { /* Scroll Up -- make Delta positive*/
260: ScrollDown(-Delta);
261: Update(iTopLine, -Delta, 0);
262: } else { /* Scroll Down by Delta */
263: ScrollUp(Delta);
264: Update(iTopLine + cyChPS - Delta, Delta, cyChPS - Delta);
265: }
266: } else AvioRedraw(); /* Redo the entire screen */
267: iOldTopLine = iTopLine;
268: }
269:
270: void AvioClose(void) {
271: /*
272: Termination routines
273: */
274: /*
275: Destroy the Presentation Space
276: */
277: VioAssociate(NULL, hVPS);
278: VioDestroyPS(hVPS);
279: fCreatedPS = FALSE;
280: }
281:
282: void AvioPaint(HWND hWnd) {
283: /*
284: Paint the AVIO presentation space by telling it to show itself.
285: A possible optimization here is to repaint only the update region.
286: */
287: static HPS hPS;
288: static RECTL RectL;
289:
290: hPS = WinBeginPaint(hWnd, (HPS) NULL, &RectL);
291: VioShowPS(cyChPS, cxChPS, 0, hVPS);
292: WinEndPaint(hPS);
293: }
294:
295: MRESULT AvioMinMax(PSWP pSWP) {
296: /*
297: Handle WM_MINMAX messages, to make sure frame doesn't get too big
298: */
299: if (pSWP->fs & (SWP_MAXIMIZE | SWP_RESTORE)) {
300: if (pSWP->fs & SWP_MAXIMIZE) {
301: /*
302: Save cx, cy values for later origin displacement
303: */
304: int Oldcx = pSWP->cx;
305: int Oldcy = pSWP->cy;
306: /*
307: Displace, and change to maximum size
308: */
309: pSWP->x += (Oldcx -
310: (pSWP->cx = cxMaxFrame + (int) (Value(SV_CXSIZEBORDER) << 1)));
311: pSWP->y += (Oldcy -
312: (pSWP->cy = cyMaxFrame + (int) (Value(SV_CYSIZEBORDER) << 1)));
313: }
314: /*
315: Now, fix the scroll bars
316: */
317: AvioAdjustFramePos(pSWP);
318: return TRUE;
319: }
320: return FALSE;
321: }
322:
323: void AvioClear(void) { ClearScreen(); }
324:
325: void AvioAdjustFramePos(PSWP pSWP) {
326: /*
327: Trap WM_ADJUSTWINDOWPOS messages to the frame with this routine.
328: Keep the window sized right, and control scrollbar visibility.
329: */
330: RECTL rclFrame;
331:
332: if (!(pSWP->cx && pSWP->cy)) return; /* Null area... */
333: if (pSWP->fs & SWP_MINIMIZE) return; /* Iconic... */
334: /*
335: Make sure the dimensions are in range
336: */
337: pSWP->cx = Min(pSWP->cx, (cxMaxFrame + (SHORT)(Value(SV_CXSIZEBORDER)<<1)));
338: pSWP->cy = Min(pSWP->cy, (cyMaxFrame + (SHORT)(Value(SV_CYSIZEBORDER)<<1)));
339: /*
340: Update the scroll bars
341: */
342: rclFrame.xLeft = (LONG) pSWP->x;
343: rclFrame.xRight = (LONG) (pSWP->x + pSWP->cx - 1);
344: rclFrame.yBottom = (LONG) pSWP->y;
345: rclFrame.yTop = (LONG) (pSWP->y + pSWP->cy - 1);
346: UpdateScrollBars(rclFrame);
347:
348: return;
349: }
350:
351: void AvioTrackFrame(HWND hWnd, MPARAM mpTrackFlags) {
352: /*
353: Takes action on WM_TRACKFRAME message
354: */
355: static TRACKINFO tiTrackInfo;
356: /*
357: Get the tracking information in the TrackInfo structure
358: */
359: WinSendMsg(hWnd, WM_QUERYTRACKINFO, mpTrackFlags, &tiTrackInfo);
360: WinTrackRect(hWnd, NULL, &tiTrackInfo);
361: }
362:
363: void AvioQueryTrackInfo(PTRACKINFO pTI) {
364: /*
365: Routine which processes WM_QUERYTRACKINFO messages to the frame.
366: Call this routine after the default one to change various parameters.
367:
368: Note: In reality, since we have a menu bar, we should make the
369: minimum width of the window something such that it does not "fold."
370: */
371: BOOL fMove;
372: /*
373: Get the grid set up for byte alignment (unless moving)
374:
375: cxGrid is set to half character width so that arrow keys
376: will function when sizing (they try to size by half a
377: character)
378: */
379: fMove = ((pTI->fs & TF_MOVE) == TF_MOVE);
380: pTI->fs |= TF_GRID;
381: pTI->cxGrid = (fMove) ? 1 : ((SHORT) (lChWidth >> 1));
382: pTI->cyGrid = (fMove) ? 1 : ((SHORT) lChHeight);
383: /*
384: Bound the frame.
385: Maximum: Sizing Border, Scrollbars, Title, Menus, client region
386: */
387: pTI->ptlMaxTrackSize.x = (LONG) (pTI->cxBorder << 1) + (LONG) cxMaxFrame;
388: pTI->ptlMaxTrackSize.y = (LONG) (pTI->cyBorder << 1) + (LONG) cyMaxFrame;
389: }
390:
391: void AvioRedraw(void) {
392: /*
393: Clear, then redraw the entire Presentation Space
394: */
395: ClearScreen();
396: Update(iTopLine, cyChPS, 0);
397: }
398:
399: MRESULT CALLBACK AvioClientWndProc
400: (HWND hWnd, USHORT msg, MPARAM mp1, MPARAM mp2) {
401: /*
402: Window Procedure which traps messages to the Client area
403: */
404: switch (msg) {
405: case WM_PAINT: /* Paint the AVIO way! */
406: AvioPaint(hWnd);
407: break;
408:
409: case WM_SIZE: /* Size the AVIO way! */
410: return AvioSize(hWnd, msg, mp1, mp2);
411: break;
412:
413: case WM_HSCROLL:
414: AvioScroll(HIUSHORT(mp2), LOUSHORT(mp2), TRUE);
415: break;
416:
417: case WM_VSCROLL:
418: AvioScroll(HIUSHORT(mp2), LOUSHORT(mp2), FALSE);
419: break;
420:
421: case WM_ERASEBACKGROUND:
422: break;
423:
424: case WM_TRACKFRAME:
425: AvioTrackFrame(hWnd, mp1);
426: break;
427:
428: case WM_MINMAXFRAME: /* Limit Maximized window size */
429: AvioMinMax((PSWP) mp1);
430:
431: /* fall through */
432:
433: default: return (*pfnOldClient)(hWnd, msg, mp1, mp2);
434: }
435: return 0;
436: }
437:
438: MRESULT CALLBACK AvioFrameWndProc(HWND hWnd, USHORT msg, MPARAM mp1, MPARAM mp2)
439: /*
440: Force the frame to stay small enough (no larger than the PS)
441: */
442: {
443: BOOL rc; /* Return code from WM_QUERYTRACKINFO */
444:
445: switch(msg) {
446: case WM_ADJUSTWINDOWPOS: /* Calculate scroll bar adjustments */
447: AvioAdjustFramePos(mp1);
448: break;
449:
450: case WM_QUERYTRACKINFO: /* Get default, then process message */
451: rc = (BOOL) (*pfnOldFrame)(hWnd, msg, mp1, mp2);
452: AvioQueryTrackInfo((PTRACKINFO) mp2);
453: return rc;
454:
455: default: break;
456: }
457: return (*pfnOldFrame)(hWnd, msg, mp1, mp2);
458: }
459:
460: void UpdateScrollBars(RECTL rclClient) {
461: /*
462: This routine fixes up the scroll bars when the window is resized, or
463: when the font size is changed.
464:
465: Parameters: The dimensions of the frame window
466: Result: Updates the scrollbars, enabling/disabling as needed
467: */
468: BOOL fNeededHorz = fNeedHorz; /* Did we need the scrollbars then? */
469: BOOL fNeededVert = fNeedVert;
470: /*
471: Compute the client rectangle, without the scrollbars
472: */
473: WinCalcFrameRect(hWndFrame, &rclClient, TRUE);
474: /*
475: Compute page width -- do we need the horizontal scroll bar?
476: */
477: cxChPage = (int) CalcChars(lcx(rclClient), lChWidth);
478: fNeedHorz = ((iMaxHorz = Max(cxChScreen - cxChPage, 0)) > 0);
479: /*
480: Compute page height -- do we need the vertical scroll bar?
481: */
482: cyChPage = (int) CalcChars(lcy(rclClient), lChHeight);
483: fNeedVert = ((iMaxVert = Max(cyChScreen - cyChPage, 0)) > 0);
484: /*
485: Maintain scrollbar integrity
486: */
487: iCurCol = Min(iCurCol, iMaxHorz);
488: iTopLine = Min(iTopLine, iMaxVert);
489: /*
490: Now, update the scrollbars as necessary
491: */
492: FixScroll(fNeededHorz, fNeedHorz, hWndHorzSB,
493: FCF_HORZSCROLL, &iCurCol, iMaxHorz, &cHUpdate);
494:
495: FixScroll(fNeededVert, fNeedVert, hWndVertSB,
496: FCF_VERTSCROLL, &iTopLine, iMaxVert, &cVUpdate);
497: /*
498: Now, update the screen to be visually consistent
499: */
500: Refresh();
501: }
502:
503: void FixScroll(fNeeded, fNeed, hWnd, flScroll, piPos, iMax, pc)
504: /*
505: This routine makes the necessary scrollbar adjustments, and
506: also enables/disables them.
507: */
508: BOOL fNeeded; /* Whether we used to need the scrollbar */
509: BOOL fNeed; /* Whether we need the scrollbar now */
510: HWND hWnd; /* Handle to the scrollbar window */
511: ULONG flScroll; /* FCF_xxxxSCROLL flag (for the scrollbar) */
512: int *piPos; /* Current location of scrollbar thumb */
513: int iMax; /* New maximum for the scrollbar */
514: int *pc; /* Counter for WinEnableWindowUpdate recursion */
515: {
516: if (fNeed) { /* Enable the scroll bar -- we didn't need it before */
517: if (!fNeeded) {
518: EnableSB(hWnd);
519: UpdateOff((*pc), hWnd);
520: UpdateFrame(flScroll);
521: UpdateOn((*pc), hWnd);
522: }
523: SetScroll(hWnd, (*piPos) = Min((*piPos), iMax), iMax);
524: } else { /* Disable the scroll bar, we no longer need it */
525: if (fNeeded) {
526: DisableSB(hWnd);
527: UpdateOff((*pc), hWnd);
528: UpdateFrame(flScroll);
529: UpdateOn((*pc), hWnd);
530: }
531: }
532: }
533:
534: void AvioLargeFont(BOOL fLargeFont) {
535: static BOOL fFirst = TRUE; // Need to init?
536: static LONG lSmallHt, lSmallWd, lLargeHt, lLargeWd; // Font sizes
537: SWP swp;
538:
539: if (fFirst) {
540: /*
541: The first time through, get the small and large font sizes
542: */
543: DevQueryCaps(hDC, CAPS_CHAR_HEIGHT, 1L, &lLargeHt);
544: DevQueryCaps(hDC, CAPS_CHAR_WIDTH, 1L, &lLargeWd);
545: DevQueryCaps(hDC, CAPS_SMALL_CHAR_HEIGHT, 1L, &lSmallHt);
546: DevQueryCaps(hDC, CAPS_SMALL_CHAR_WIDTH, 1L, &lSmallWd);
547: fFirst = FALSE;
548: }
549: /*
550: Set the character size with VioSetDeviceCellSize
551: */
552: SetCellSize( (SHORT) (lChHeight = ((fLargeFont) ? lLargeHt : lSmallHt)),
553: (SHORT) (lChWidth = ((fLargeFont) ? lLargeWd : lSmallWd)) );
554: /*
555: Compute maximum size of client area
556: */
557: cxMaxClient = (cxChPS * (SHORT) lChWidth);
558: cxMaxFrame = cxMaxClient + (SHORT) cxConstant;
559: cyMaxClient = (cyChPS * (SHORT) lChHeight);
560: cyMaxFrame = cyMaxClient + (SHORT) cyConstant;
561: /*
562: Send a WM_ADJUSTFRAMEPOS message
563: */
564: WinQueryWindowPos(hWndFrame, &swp);
565: if (swp.fs & SWP_MAXIMIZE) {
566: AvioMinMax(&swp);
567: WinSetMultWindowPos(hWndFrame, &swp, 1);
568: } else {
569: swp.fs = SWP_ACTIVATE | SWP_MOVE | SWP_SHOW | SWP_SIZE;
570: WinSetWindowPos(hWndFrame, NULL, swp.x, swp.y,
571: Min(cxMaxFrame, swp.cx), Min(cyMaxFrame, swp.cy), swp.fs);
572: }
573: AvioAdjustFramePos(&swp); /* Fix up the frame, scroll bars */
574: AvioPaint(hWndClient); /* Repaint with new characters */
575: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.