![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mdisplit.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [OS/2 SDKs] / pmsdk / samples / mdi|
Return to mdisplit.c CVS log | Up to [OS/2 SDKs] / pmsdk / samples / mdi |
1.1 root 1: /***************************************************************************\
2: * split.c - Code for window splitting
3: *
4: * Created by Microsoft Corporation, 1989
5: \***************************************************************************/
6:
7: #define INCL_WINSYS
8: #define INCL_WINCOMMON
9: #define INCL_WINMESSAGEMGR
10: #define INCL_WINPOINTERS
11: #define INCL_WINMENUS
12: #define INCL_WININPUT
13: #define INCL_WINHEAP
14: #define INCL_WINSCROLLBARS
15: #define INCL_WINFRAMEMGR
16: #define INCL_WINWINDOWMGR
17: #define INCL_WINRECTANGLES
18: #define INCL_GPIBITMAPS
19: #define INCL_GPIPRIMITIVES
20:
21: #include <os2.h>
22: #include "app.h"
23: #include "appdata.h"
24: #include "mdi.h"
25: #include "mdidata.h"
26:
27: VOID InvertRect(HPS, PRECTL);
28: VOID TrackSplitbars(HWND, USHORT, SHORT, SHORT);
29: VOID FillSplitbarInteriors(USHORT, HWND, HWND);
30: HWND QueryBotLeftClient(HWND hwndFrame, NPDOC npdoc);
31: VOID DrawTrackRects(HPS, PRECTL, SHORT, SHORT, USHORT);
32: VOID MoveTrackRects(HPS, PRECTL, USHORT, SHORT, SHORT, SHORT, SHORT);
33: VOID CalcTrackRect(PRECTL, PRECTL, SHORT, USHORT);
34: VOID SetSplitbarPos(HWND, PRECTL, SHORT, SHORT, USHORT);
35: HWND QueryBotLeftClient(HWND hwndFrame, NPDOC npdoc);
36:
37: MRESULT CALLBACK SplitbarWndProc(HWND hwnd, USHORT msg, MPARAM mp1, MPARAM mp2)
38: {
39: HPS hps;
40: POINTL ptl;
41: RECTL rclPaint;
42: HWND hwndClient, hwndFrame, hwndOrigin;
43: BOOL fControl;
44: register NPDOC npdoc;
45:
46: switch (msg) {
47:
48: case WM_PAINT:
49: hwndFrame = WinQueryWindow(hwnd, QW_PARENT, FALSE);
50: hwndClient = WinWindowFromID(hwndFrame, FID_CLIENT);
51:
52: npdoc = NPDOCFROMCLIENT(hwndClient);
53:
54: hps = WinBeginPaint(hwnd, NULL, NULL);
55:
56: WinQueryWindowRect(hwnd, &rclPaint);
57:
58: if (WinQueryWindowUShort(hwnd, QWS_ID) == ID_VERTSPLITBAR) {
59: if (npdoc->fs & DF_SPLITVERT) {
60: WinDrawBorder(hps, &rclPaint, 1, 0, SYSCLR_WINDOWFRAME,
61: SYSCLR_WINDOW, DB_STANDARD);
62: /*
63: * Make the interiors of the splitbars
64: * visually correct.
65: */
66: FillSplitbarInteriors(npdoc->fs, hwnd,
67: WinWindowFromID(hwndFrame, ID_HORZSPLITBAR));
68: } else {
69: WinFillRect(hps, &rclPaint, SYSCLR_WINDOWFRAME);
70: }
71: } else {
72: if (npdoc->fs & DF_SPLITHORZ) {
73: WinDrawBorder(hps, &rclPaint, 0, 1, SYSCLR_WINDOWFRAME,
74: SYSCLR_WINDOW, DB_STANDARD | DB_INTERIOR);
75: } else {
76: WinFillRect(hps, &rclPaint, SYSCLR_WINDOWFRAME);
77: }
78: }
79:
80: WinEndPaint(hps);
81: break;
82:
83: case WM_MOUSEMOVE:
84: hwndFrame = WinQueryWindow(hwnd, QW_PARENT, FALSE);
85: hwndClient = WinWindowFromID(hwndFrame, FID_CLIENT);
86:
87: npdoc = NPDOCFROMCLIENT(hwndClient);
88:
89: ptl.x = SHORT1FROMMP(mp1);
90: ptl.y = SHORT2FROMMP(mp1);
91:
92: hwndOrigin = QueryBotLeftClient(hwndFrame, npdoc);
93: WinMapWindowPoints(hwnd, hwndOrigin, (PPOINTL)&ptl, 1);
94:
95: if (WinQueryWindowUShort(hwnd, QWS_ID) == ID_VERTSPLITBAR) {
96:
97: if ((npdoc->fs & DF_SPLITHORZ) &&
98: ((SHORT)ptl.y > (npdoc->cyHorzSplitPos - (cyHorzSplitbar))) &&
99: ((SHORT)ptl.y <= (npdoc->cyHorzSplitPos + (cyHorzSplitbar * 2)))) {
100: WinSetPointer(HWND_DESKTOP, hptrHVSplit);
101: } else {
102: WinSetPointer(HWND_DESKTOP, hptrVertSplit);
103: }
104: } else {
105: if ((npdoc->fs & DF_SPLITVERT) &&
106: ((SHORT)ptl.x > (npdoc->cxVertSplitPos - (cxVertSplitbar))) &&
107: ((SHORT)ptl.x <= (npdoc->cxVertSplitPos + (cxVertSplitbar * 2)))) {
108: WinSetPointer(HWND_DESKTOP, hptrHVSplit);
109: } else {
110: WinSetPointer(HWND_DESKTOP, hptrHorzSplit);
111: }
112: }
113: break;
114:
115: case WM_BUTTON1DOWN:
116: case WM_BUTTON1DBLCLK:
117: /*
118: * Get the control key state here so the user doesn't
119: * have to hold it down the whole time to get the
120: * desired effect.
121: */
122: fControl = (WinGetKeyState(HWND_DESKTOP, VK_CTRL) & 0x8000);
123:
124: hwndFrame = WinQueryWindow(hwnd, QW_PARENT, FALSE);
125: hwndClient = WinWindowFromID(hwndFrame, FID_CLIENT);
126:
127: /*
128: * Update the entire window before we start
129: * tracking with the splitter bars.
130: */
131: WinUpdateWindow(hwndFrame);
132:
133: npdoc = NPDOCFROMCLIENT(hwndClient);
134:
135: ptl.x = SHORT1FROMMP(mp1);
136: ptl.y = SHORT2FROMMP(mp1);
137:
138: hwndOrigin = QueryBotLeftClient(hwndFrame, npdoc);
139: WinMapWindowPoints(hwnd, hwndOrigin, (PPOINTL)&ptl, 1);
140:
141: if (WinQueryWindowUShort(hwnd, QWS_ID) == ID_VERTSPLITBAR) {
142: if ((npdoc->fs & DF_SPLITHORZ) &&
143: ((SHORT)ptl.y > (npdoc->cyHorzSplitPos - (cyHorzSplitbar))) &&
144: ((SHORT)ptl.y <= (npdoc->cyHorzSplitPos + (cyHorzSplitbar * 2)))) {
145: TrackSplitbars(hwndClient, SPS_VERT | SPS_HORZ, (SHORT)ptl.x,
146: (SHORT)ptl.y);
147: } else {
148: TrackSplitbars(hwndClient, SPS_VERT, (SHORT)ptl.x,
149: (SHORT)ptl.y);
150: }
151: } else {
152: if ((npdoc->fs & DF_SPLITVERT) &&
153: ((SHORT)ptl.x > (npdoc->cxVertSplitPos - (cxVertSplitbar))) &&
154: ((SHORT)ptl.x <= (npdoc->cxVertSplitPos + (cxVertSplitbar * 2)))) {
155: TrackSplitbars(hwndClient, SPS_VERT | SPS_HORZ, (SHORT)ptl.x,
156: (SHORT)ptl.y);
157: } else {
158: TrackSplitbars(hwndClient, SPS_HORZ, (SHORT)ptl.x,
159: (SHORT)ptl.y);
160: }
161: }
162:
163: /*
164: * If the control key is down, we leave
165: * the focus where it is.
166: */
167: if (fControl == FALSE)
168: WinSetFocus(HWND_DESKTOP, hwndClient);
169:
170: break;
171:
172: case WM_MOVE:
173: case WM_SIZE:
174: WinInvalidateRect(hwnd, NULL, FALSE);
175: break;
176:
177: default:
178: return(WinDefWindowProc(hwnd, msg, mp1, mp2));
179: break;
180: }
181:
182: return (0L);
183: }
184:
185:
186: VOID FillSplitbarInteriors(USHORT fs, HWND hwndVert, HWND hwndHorz)
187: {
188: HPS hps;
189: RECTL rclVertSplitbar, rclHorzSplitbar;
190:
191: if (fs & DF_SPLITVERT) {
192: hps = WinGetPS(hwndVert);
193: WinQueryWindowRect(hwndVert, &rclVertSplitbar);
194: WinInflateRect(NULL, &rclVertSplitbar, -cxBorder, 0);
195: WinFillRect(hps, &rclVertSplitbar, SYSCLR_WINDOW);
196: WinReleasePS(hps);
197: }
198:
199: if (fs & DF_SPLITHORZ) {
200: hps = WinGetPS(hwndHorz);
201: WinQueryWindowRect(hwndHorz, &rclHorzSplitbar);
202: WinInflateRect(NULL, &rclHorzSplitbar, 0, -cyBorder);
203: WinFillRect(hps, &rclHorzSplitbar, SYSCLR_WINDOW);
204: WinReleasePS(hps);
205: }
206: }
207:
208:
209: BOOL CreateSplitbarWindows(HWND hwndFrame, NPDOC npdoc)
210: {
211: USHORT fsStyle;
212: register NPVIEW npview, npviewNew;
213: HWND hwndNewClient;
214:
215: fsStyle = npdoc->fsStyle;
216: npview = npdoc->npviewFirst;
217:
218: if (fsStyle & DS_VERTSPLITBAR) {
219: if (WinCreateWindow(hwndFrame, WC_SCROLLBAR, "",
220: SBS_HORZ, 0, 0, 0, 0, hwndFrame,
221: WinWindowFromID(hwndFrame, FID_HORZSCROLL),
222: ID_HORZSCROLL2, NULL, NULL) == NULL)
223: return (FALSE);
224:
225: if (WinCreateWindow(hwndFrame, szSplitbarClass, "",
226: (ULONG)SPS_VERT, 0, 0, 0, 0, hwndFrame,
227: WinWindowFromID(hwndFrame, FID_MINMAX),
228: ID_VERTSPLITBAR, NULL, NULL) == NULL)
229: return (FALSE);
230:
231: hwndNewClient = WinCreateWindow(hwndFrame, szDocClass, "",
232: 0L, 0, 0, 0, 0, hwndFrame,
233: WinWindowFromID(hwndFrame, FID_CLIENT),
234: ID_CLIENT2, NULL, NULL);
235: if (hwndNewClient == NULL)
236: return (FALSE);
237:
238: /*
239: * Link ID_CLIENT2 into npdoc's view list.
240: */
241: npviewNew = NPVIEWFROMCLIENT(hwndNewClient);
242: npview->npviewNext = npviewNew;
243: npview = npviewNew;
244: }
245:
246: if (fsStyle & DS_HORZSPLITBAR) {
247: if (WinCreateWindow(hwndFrame, WC_SCROLLBAR, "",
248: SBS_VERT, 0, 0, 0, 0, hwndFrame,
249: WinWindowFromID(hwndFrame, FID_VERTSCROLL),
250: ID_VERTSCROLL2, NULL, NULL) == NULL)
251: return (FALSE);
252:
253: if (WinCreateWindow(hwndFrame, szSplitbarClass, "",
254: (ULONG)SPS_HORZ, 0, 0, 0, 0, hwndFrame,
255: WinWindowFromID(hwndFrame, FID_MINMAX),
256: ID_HORZSPLITBAR, NULL, NULL) == NULL)
257: return (FALSE);
258:
259: /*
260: * If we're split vertically as well, then we want to
261: * insert ID_CLIENT3 behind ID_CLIENT2 and create
262: * ID_CLIENT4 behind CLIENT3, otherwise we just create
263: * ID_CLIENT3 behind FID_CLIENT.
264: */
265: if (fsStyle & DS_VERTSPLITBAR) {
266: hwndNewClient = WinCreateWindow(hwndFrame, szDocClass, "",
267: 0L, 0, 0, 0, 0, hwndFrame,
268: WinWindowFromID(hwndFrame, ID_CLIENT2),
269: ID_CLIENT3, NULL, NULL);
270: if (hwndNewClient == NULL)
271: return (FALSE);
272:
273: /*
274: * Link ID_CLIENT3 into npdoc's view list.
275: */
276: npviewNew = NPVIEWFROMCLIENT(hwndNewClient);
277: npview->npviewNext = npviewNew;
278: npview = npviewNew;
279:
280: hwndNewClient = WinCreateWindow(hwndFrame, szDocClass, "",
281: 0L, 0, 0, 0, 0, hwndFrame,
282: WinWindowFromID(hwndFrame, ID_CLIENT3),
283: ID_CLIENT4, NULL, NULL);
284: if (hwndNewClient == NULL)
285: return (FALSE);
286:
287: /*
288: * Link ID_CLIENT4 into npdoc's view list.
289: */
290: npviewNew = NPVIEWFROMCLIENT(hwndNewClient);
291: npview->npviewNext = npviewNew;
292: npview = npviewNew;
293:
294: } else {
295: hwndNewClient = WinCreateWindow(hwndFrame, szDocClass, "",
296: 0L, 0, 0, 0, 0, hwndFrame,
297: WinWindowFromID(hwndFrame, FID_CLIENT),
298: ID_CLIENT3, NULL, NULL);
299: if (hwndNewClient == NULL)
300: return (FALSE);
301:
302: /*
303: * Link ID_CLIENT3 into npdoc's view list.
304: */
305: npviewNew = NPVIEWFROMCLIENT(hwndNewClient);
306: npview->npviewNext = npviewNew;
307: npview = npviewNew;
308: }
309: }
310:
311: return (TRUE);
312: }
313:
314:
315: HWND QueryBotLeftClient(HWND hwndFrame, NPDOC npdoc)
316: {
317: if (npdoc->fs & DF_SPLITHORZ) {
318: /*
319: * If there isn't enough room to split
320: * then only the main client will be
321: * visible so we'll use it.
322: */
323: if (WinIsWindowVisible(WinWindowFromID(hwndFrame, ID_HORZSPLITBAR)))
324: return (WinWindowFromID(hwndFrame, ID_CLIENT3));
325: else
326: return (WinWindowFromID(hwndFrame, FID_CLIENT));
327:
328: } else {
329: return (WinWindowFromID(hwndFrame, FID_CLIENT));
330: }
331: }
332:
333:
334:
335: VOID TrackSplitbars(HWND hwndClient, register USHORT fsTrack, SHORT xMouse,
336: SHORT yMouse)
337: {
338: SHORT x, y;
339: SHORT xNew, yNew;
340: HPS hps;
341: RECTL rclClient, rclClientScreen;
342: QMSG qmsg;
343: AREABUNDLE abnd;
344: HWND hwndFrame, hwndOrigin;
345: register NPDOC npdoc;
346: POINTL ptlPointer;
347:
348: hwndFrame = WinQueryWindow(hwndClient, QW_PARENT, FALSE);
349:
350: WinLockWindowUpdate(HWND_DESKTOP, hwndFrame);
351:
352: /*
353: * If we're split horizontally then we want the
354: * origin to be a ID_CLIENT3's origin, otherwise
355: * we want FID_CLIENT's origin.
356: */
357: npdoc = NPDOCFROMCLIENT(hwndClient);
358: hwndOrigin = QueryBotLeftClient(hwndFrame, npdoc);
359:
360: /*
361: * We use WinCalcFrameRect() to get the client rectangle
362: * rather than WinQueryWindowRect() because the window
363: * might already be split, so hwndClient's rectangle wouldn't
364: * necessarily include the area we want.
365: */
366: WinQueryWindowRect(hwndFrame, &rclClient);
367:
368: /*
369: * Map rectangle to screen coordinates because
370: * WinCalcFrameRect() will byte-align the client.
371: */
372: WinMapWindowPoints(hwndFrame, HWND_DESKTOP, (PPOINTL)&rclClient, 2);
373: WinCalcFrameRect(hwndFrame, &rclClient, TRUE);
374:
375: WinCopyRect(NULL, &rclClientScreen, &rclClient);
376: WinMapWindowPoints(HWND_DESKTOP, hwndOrigin, (PPOINTL)&rclClient, 2);
377:
378: WinSetCapture(HWND_DESKTOP, hwndOrigin);
379:
380: /*
381: * We get a PSF_PARENTCLIP PS so we can draw the
382: * splitbars through the other client windows,
383: * but still get the PS origin we want.
384: */
385: hps = WinGetClipPS(hwndOrigin, NULL,
386: PSF_PARENTCLIP | PSF_LOCKWINDOWUPDATE);
387:
388: abnd.usSymbol = PATSYM_HALFTONE;
389: abnd.lColor = CLR_TRUE;
390: abnd.lBackColor = CLR_FALSE;
391: GpiSetAttrs(hps, PRIM_AREA, ABB_SYMBOL | ABB_COLOR | ABB_BACK_COLOR, 0L,
392: (PBUNDLE)&abnd);
393:
394: if (fsTrack & SPS_HORZ) {
395: if (npdoc->fs & DF_SPLITHORZ) {
396: y = npdoc->cyHorzSplitPos + (cyHorzSplitbar / 2);
397: } else if (npdoc->fs & DF_HSPLITOVERFLOW) {
398: y = 0;
399: /*
400: * Clear the overflow flag since the
401: * user can't track to an overflown
402: * position.
403: */
404: npdoc->fs &= ~DF_HSPLITOVERFLOW;
405: } else {
406: y = (SHORT)rclClient.yTop - (cyHorzSplitbar / 2);
407: }
408: }
409:
410: if (fsTrack & SPS_VERT) {
411: if (npdoc->fs & DF_SPLITVERT) {
412: x = npdoc->cxVertSplitPos + (cxVertSplitbar / 2);
413: } else if (npdoc->fs & DF_VSPLITOVERFLOW) {
414: x = (SHORT)rclClient.xRight - cxVertSplitbar;
415: /*
416: * Clear the overflow flag since the
417: * user can't track to an overflown
418: * position.
419: */
420: npdoc->fs &= ~DF_VSPLITOVERFLOW;
421: } else {
422: x = (cxVertSplitbar / 2);
423: }
424: }
425:
426: /*
427: * If xMouse is -1, then we want to set the pointer
428: * position to the position of the splitbars.
429: */
430: if (xMouse == -1) {
431: xMouse = x;
432: yMouse = y;
433: ptlPointer.x = x;
434: ptlPointer.y = y;
435: WinMapWindowPoints(hwndOrigin, HWND_DESKTOP, (PPOINTL)&ptlPointer, 1);
436: WinSetPointerPos(HWND_DESKTOP, (SHORT)ptlPointer.x, (SHORT)ptlPointer.y);
437: }
438:
439: DrawTrackRects(hps, &rclClient, x, y, fsTrack);
440:
441: while (WinGetMsg(NULL, (PQMSG)&qmsg, NULL, NULL, NULL)) {
442: switch (qmsg.msg) {
443:
444: case WM_BUTTON1UP:
445: DrawTrackRects(hps, &rclClient, x, y, fsTrack);
446: WinLockWindowUpdate(HWND_DESKTOP, NULL);
447: SetSplitbarPos(hwndClient, &rclClient, x, y, fsTrack);
448: goto exit_no_unlock;
449:
450: case WM_CHAR:
451: if ((((USHORT)qmsg.mp1 &
452: (KC_KEYUP | KC_DEADKEY | KC_COMPOSITE | KC_INVALIDCOMP))
453: == 0) && ((USHORT)qmsg.mp1 & KC_VIRTUALKEY)) {
454:
455: WinQueryPointerPos(HWND_DESKTOP, (PPOINTL)&ptlPointer);
456: switch (SHORT2FROMMP(qmsg.mp2)) {
457:
458: case VK_UP:
459: ptlPointer.y += (cyHorzSplitbar * 2);
460: break;
461:
462: case VK_DOWN:
463: ptlPointer.y -= (cyHorzSplitbar * 2);
464: break;
465:
466: case VK_RIGHT:
467: ptlPointer.x += (cxVertSplitbar * 2);
468: break;
469:
470: case VK_LEFT:
471: ptlPointer.x -= (cxVertSplitbar * 2);
472: break;
473:
474: case VK_ENTER:
475: case VK_NEWLINE:
476: DrawTrackRects(hps, &rclClient, x, y, SPS_HORZ | SPS_VERT);
477: WinLockWindowUpdate(HWND_DESKTOP, NULL);
478: SetSplitbarPos(hwndClient, &rclClient, x, y,
479: SPS_HORZ | SPS_VERT);
480: goto exit_no_unlock;
481:
482: case VK_ESC:
483: DrawTrackRects(hps, &rclClient, x, y, SPS_HORZ | SPS_VERT);
484: goto exit;
485: }
486: if ((SHORT)ptlPointer.x < (SHORT)rclClientScreen.xLeft)
487: ptlPointer.x = rclClientScreen.xLeft;
488: else if ((SHORT)ptlPointer.x > (SHORT)rclClientScreen.xRight)
489: ptlPointer.x = rclClientScreen.xRight;
490:
491: if ((SHORT)ptlPointer.y < (SHORT)rclClientScreen.yBottom)
492: ptlPointer.y = rclClientScreen.yBottom;
493: else if ((SHORT)ptlPointer.y > (SHORT)rclClientScreen.yTop)
494: ptlPointer.y = rclClientScreen.yTop;
495:
496: WinSetPointerPos(HWND_DESKTOP, (SHORT)ptlPointer.x,
497: (SHORT)ptlPointer.y);
498: }
499: break;
500:
501: case WM_MOUSEMOVE:
502: xNew = x + (SHORT1FROMMP(qmsg.mp1) - xMouse);
503: xMouse = SHORT1FROMMP(qmsg.mp1);
504: yNew = y + (SHORT2FROMMP(qmsg.mp1) - yMouse);
505: yMouse = SHORT2FROMMP(qmsg.mp1);
506:
507: MoveTrackRects(hps, &rclClient, fsTrack, x, y, xNew, yNew);
508: x = xNew;
509: y = yNew;
510: break;
511:
512: default:
513: WinDispatchMsg(NULL, (PQMSG)&qmsg);
514: break;
515: }
516: }
517:
518: exit:
519: WinLockWindowUpdate(HWND_DESKTOP, NULL);
520: exit_no_unlock:
521: WinReleasePS(hps);
522: WinSetCapture(HWND_DESKTOP, NULL);
523: }
524:
525:
526: VOID SetSplitbarPos(HWND hwndClient, PRECTL prclClient, SHORT x, SHORT y,
527: USHORT fsTrack)
528: {
529: register NPDOC npdoc;
530: register NPVIEW npview1, npview2, npview3, npview4;
531: HWND hwndFrame;
532: RECTL rclTrack;
533:
534: npview1 = (NPVIEW)WinQueryWindowUShort(hwndClient, QWS_USER);
535: npdoc = npview1->npdoc;
536: hwndFrame = WinQueryWindow(hwndClient, QW_PARENT, FALSE);
537:
538: if (npdoc->fsStyle & DS_VERTSPLITBAR) {
539: npview2 = (NPVIEW)WinQueryWindowUShort(
540: WinWindowFromID(hwndFrame, ID_CLIENT2), QWS_USER);
541: }
542:
543: if (npdoc->fsStyle & DS_HORZSPLITBAR) {
544: npview3 = (NPVIEW)WinQueryWindowUShort(
545: WinWindowFromID(hwndFrame, ID_CLIENT3), QWS_USER);
546: }
547:
548: if (npdoc->fsStyle & (DS_HORZSPLITBAR | DS_VERTSPLITBAR)) {
549: npview4 = (NPVIEW)WinQueryWindowUShort(
550: WinWindowFromID(hwndFrame, ID_CLIENT4), QWS_USER);
551: }
552:
553: if (fsTrack & SPS_VERT) {
554: CalcTrackRect(prclClient, &rclTrack, x, SPS_VERT);
555: npdoc->cxVertSplitPos = (SHORT)rclTrack.xLeft;
556: if ((npdoc->cxVertSplitPos < cxVertSplitbar) ||
557: (npdoc->cxVertSplitPos >
558: ((SHORT)prclClient->xRight - (cxVertSplitbar * 2)))) {
559: npdoc->fs &= ~DF_SPLITVERT;
560: } else {
561: npdoc->fs |= DF_SPLITVERT;
562:
563: /*
564: * Setup ID_CLIENT2 with the same yOrigin
565: * as FID_CLIENT.
566: */
567: npview2->yOrigin = npview1->yOrigin;
568:
569: /*
570: * If we were horizontally split already, then
571: * set ID_CLIENT4 to the same yOrigin
572: * as ID_CLIENT3.
573: */
574: if (npdoc->fs & DF_SPLITHORZ)
575: npview4->yOrigin = npview3->yOrigin;
576: }
577: }
578:
579: if (fsTrack & SPS_HORZ) {
580: CalcTrackRect(prclClient, &rclTrack, y, SPS_HORZ);
581: npdoc->cyHorzSplitPos = (SHORT)rclTrack.yBottom;
582: if ((npdoc->cyHorzSplitPos >
583: ((SHORT)prclClient->yTop - (cyHorzSplitbar * 2))) ||
584: (npdoc->cyHorzSplitPos < cyHorzSplitbar)) {
585: npdoc->fs &= ~DF_SPLITHORZ;
586: } else {
587: npdoc->fs |= DF_SPLITHORZ;
588:
589: /*
590: * Setup ID_CLIENT3 with the same xOrigin
591: * as FID_CLIENT.
592: */
593: npview3->xOrigin = npview1->xOrigin;
594:
595: /*
596: * If we were vertically split already, then
597: * set ID_CLIENT4 to the same xOrigin
598: * as ID_CLIENT2.
599: */
600: if (npdoc->fs & DF_SPLITHORZ)
601: npview4->xOrigin = npview2->xOrigin;
602: }
603: }
604:
605: WinSendMsg(hwndFrame, WM_UPDATEFRAME, 0L, 0L);
606: }
607:
608:
609: VOID CalcTrackRect(PRECTL prclClient, PRECTL prcl, SHORT coord, USHORT fsTrack)
610: {
611: if (fsTrack & SPS_VERT) {
612: WinSetRect(NULL, prcl, coord - (cxVertSplitbar / 2), 0,
613: coord + (cxVertSplitbar - (cxVertSplitbar / 2)),
614: (SHORT)prclClient->yTop);
615:
616: if ((SHORT)prcl->xLeft < 0)
617: WinOffsetRect(NULL, prcl, (SHORT)-(prcl->xLeft), 0);
618: else if ((SHORT)prcl->xRight > (SHORT)prclClient->xRight)
619: WinOffsetRect(NULL, prcl,
620: -((SHORT)prcl->xRight - (SHORT)prclClient->xRight), 0);
621: } else if (fsTrack & SPS_HORZ) {
622: WinSetRect(NULL, prcl, 0, coord - (cyHorzSplitbar / 2),
623: (SHORT)prclClient->xRight,
624: coord + (cyHorzSplitbar - (cyHorzSplitbar / 2)));
625:
626: if ((SHORT)prcl->yBottom < 0)
627: WinOffsetRect(NULL, prcl, 0, (SHORT)-(prcl->yBottom));
628: else if ((SHORT)prcl->yTop > (SHORT)prclClient->yTop)
629: WinOffsetRect(NULL, prcl,
630: 0, -((SHORT)prcl->yTop - (SHORT)prclClient->yTop));
631: }
632: }
633:
634:
635: VOID DrawTrackRects(HPS hps, PRECTL prclClient, SHORT x, SHORT y,
636: USHORT fsTrack)
637: {
638: RECTL rclFill;
639:
640: VOID CalcTrackRect(PRECTL, PRECTL, SHORT, USHORT);
641:
642: if (fsTrack & SPS_VERT) {
643: CalcTrackRect(prclClient, (PRECTL)&rclFill, x, SPS_VERT);
644:
645: InvertRect(hps, (PRECTL)&rclFill);
646: }
647:
648: if (fsTrack & SPS_HORZ) {
649: CalcTrackRect(prclClient, (PRECTL)&rclFill, y, SPS_HORZ);
650:
651: InvertRect(hps, (PRECTL)&rclFill);
652: }
653: }
654:
655:
656: VOID MoveTrackRects(HPS hps, PRECTL prclClient, USHORT fsTrack, SHORT xOld,
657: SHORT yOld, SHORT xNew, SHORT yNew)
658: {
659: RECTL rclOld, rclNew, rclScratch;
660: VOID CalcTrackRect(PRECTL, PRECTL, SHORT, USHORT);
661:
662: if (fsTrack & SPS_VERT) {
663: CalcTrackRect(prclClient, (PRECTL)&rclOld, xOld, SPS_VERT);
664: CalcTrackRect(prclClient, (PRECTL)&rclNew, xNew, SPS_VERT);
665:
666: if (WinSubtractRect(NULL, &rclScratch, &rclOld, &rclNew))
667: InvertRect(hps, (PRECTL)&rclScratch);
668: if (WinSubtractRect(NULL, &rclScratch, &rclNew, &rclOld))
669: InvertRect(hps, (PRECTL)&rclScratch);
670: }
671:
672: if (fsTrack & SPS_HORZ) {
673: CalcTrackRect(prclClient, (PRECTL)&rclOld, yOld, SPS_HORZ);
674: CalcTrackRect(prclClient, (PRECTL)&rclNew, yNew, SPS_HORZ);
675:
676: if (WinSubtractRect(NULL, &rclScratch, &rclOld, &rclNew))
677: InvertRect(hps, (PRECTL)&rclScratch);
678: if (WinSubtractRect(NULL, &rclScratch, &rclNew, &rclOld))
679: InvertRect(hps, (PRECTL)&rclScratch);
680: }
681: }
682:
683:
684: VOID InvertRect(HPS hps, PRECTL prcl)
685: {
686: RECTL rclParm[2];
687:
688: WinCopyRect(NULL, (PRECTL)&rclParm[0], (PRECTL)prcl);
689: rclParm[1].xLeft = 0;
690: rclParm[1].yBottom = 0;
691: GpiBitBlt(hps, (HPS)NULL, 3L, (PPOINTL)rclParm, ROP_PATINVERT, 0L);
692: }
693:
694:
695: VOID FindSwp(PSWP aswp, register USHORT cswp, USHORT id, PSWP FAR *ppswp)
696: {
697: register i;
698:
699: for (i = 0; i < cswp; i++) {
700: if (WinQueryWindowUShort(aswp[i].hwnd, QWS_ID) == id) {
701: *ppswp = &aswp[i];
702: return;
703: }
704: }
705: }
706:
707:
708: /*
709: * Set the SWP structure to the passed in parameters.
710: *
711: * This routine is dependent on the order of elements
712: * in the SWP structure.
713: */
714: VOID SetSwpPos(PSWP pswp, HWND hwnd, HWND hwndInsertBehind, SHORT x, SHORT y,
715: SHORT cx, SHORT cy, USHORT fs)
716: {
717: /*
718: *pswp = *((PSWP)&fs);
719: */
720: pswp->hwnd = hwnd;
721: pswp->hwndInsertBehind = hwndInsertBehind;
722: pswp->x = x;
723: pswp->y = y;
724: pswp->cx = cx;
725: pswp->cy = cy;
726: pswp->fs = fs;
727: }
728:
729:
730: VOID HideSwp(PSWP pswp, HWND hwnd, USHORT *piswp)
731: {
732: if (WinIsWindowVisible(hwnd)) {
733: SetSwpPos(pswp, hwnd, NULL, 0, 0, 0, 0, SWP_HIDE);
734: (*piswp)++;
735: }
736: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.