![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fatpel.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [OS/2 SDKs] / os232sdk / toolkt20 / c / samples / fatpel|
Return to fatpel.c CVS log | Up to [OS/2 SDKs] / os232sdk / toolkt20 / c / samples / fatpel |
1.1 root 1: /************************************************************************
2: *
3: * fatpel.c -- The Diamond Metric, Theory vs. Practice
4: *
5: * Created by Microsoft, IBM Corporation, 1990
6: *
7: * DISCLAIMER OF WARRANTIES. The following [enclosed] code is
8: * sample code created by Microsoft Corporation and/or IBM
9: * Corporation. This sample code is not part of any standard
10: * Microsoft or IBM product and is provided to you solely for
11: * the purpose of assisting you in the development of your
12: * applications. The code is provided "AS IS", without
13: * warranty of any kind. Neither Microsoft nor IBM shall be
14: * liable for any damages arising out of your use of the sample
15: * code, even if they have been advised of the possibility of
16: * such damages.
17: *
18: ************************************************************************/
19:
20: #define INCL_WINFRAMEMGR
21: #define INCL_WINWINDOWMGR
22: #define INCL_WINMESSAGEMGR
23: #define INCL_WINPOINTERS
24: #define INCL_WINSWITCHLIST
25: #define INCL_WINTRACKRECT
26: #define INCL_WINDIALOGS
27: #define INCL_WINBUTTONS
28: #define INCL_GPILOGCOLORTABLE
29: #define INCL_GPIBITMAPS
30: #define INCL_GPITRANSFORMS
31: #define INCL_DOSMEMMGR
32: #define INCL_DOSFILEMGR
33: #define INCL_BITMAPFILEFORMAT
34: #define INCL_GPIPRIMITIVES
35: #define INCL_WINMENUS
36: #define INCL_GPIREGIONS
37: #define INCL_WINPOINTERS
38: #define INCL_WININPUT
39: #include <os2.h>
40:
41: #include <stdio.h>
42: #include <stdlib.h>
43: #include <string.h>
44:
45: #include "..\opendlg\opendlg.h"
46: #include "fatpel.h"
47:
48:
49:
50:
51: /************************************************************************
52: *
53: * Function declarations
54: *
55: ************************************************************************/
56:
57: /* Private functions */
58:
59: VOID cdecl main(VOID);
60: BOOL FAR InitGlobals(VOID);
61: BOOL FAR InitApp(VOID);
62: VOID Close(HWND);
63: VOID Command(HWND, USHORT);
64: VOID Paint(HPS, USHORT);
65: VOID EraseBackground(HPS);
66: VOID DrawGrid(HPS);
67: VOID DisplayRenderedPels(HPS, USHORT);
68: VOID DisplayControlPoints(HPS, LONG, PPOINTL, USHORT);
69: VOID DisplayMathematicalObject(HPS, USHORT);
70: VOID DrawFatPels(HPS);
71: VOID DrawOneFatPel(HPS, PPOINTL, COLOR);
72: VOID GetFatPelFromPt(PPOINTL, PPOINTL);
73: VOID SetFatPel(PPOINTL, COLOR);
74: VOID RoundControlPoints(HPS, LONG, PPOINTL, PPOINTL, LONG, LONG);
75: VOID ComputeTransform(PRECTL, PRECTL);
76: VOID DrawPrimitive(HPS, LONG, PPOINTL);
77: VOID UpdateSurfaceDims(VOID);
78: VOID MySetWindowLong (HWND, USHORT, LONG);
79: VOID MySetWindowLongHex(HWND, USHORT, LONG);
80: LONG MyGetWindowLong (HWND, USHORT);
81: VOID MouseMove(HWND, MPARAM);
82: VOID ButtonUp(HWND, USHORT);
83: VOID ButtonDown(HWND, USHORT, MPARAM);
84: VOID DragPelSize(HWND, POINTS);
85: VOID WriteFile(HWND, HPS);
86: BOOL WriteBMP(HFILE, HPS, PBITMAPINFOHEADER2);
87: VOID MyMessageBox(HWND, PSZ);
88: VOID SaveWindowToFile(HWND);
89: SHORT IsPtInList(PPOINTL);
90: SHORT AddPtToList(PPOINTL);
91: BOOL IsPtCloseToLine(PPOINTL, PPOINTL, PPOINTL);
92: VOID SwapLong(PLONG, PLONG);
93:
94:
95: /* Exported functions */
96:
97: MRESULT EXPENTRY WndProc (HWND, USHORT, MPARAM, MPARAM);
98: MRESULT EXPENTRY AboutDlg (HWND, USHORT, MPARAM, MPARAM);
99: MRESULT EXPENTRY ColorsDlg (HWND, USHORT, MPARAM, MPARAM);
100: MRESULT EXPENTRY PelSizeDlg(HWND, USHORT, MPARAM, MPARAM);
101:
102:
103:
104:
105: /************************************************************************
106: *
107: * Global Variables
108: *
109: ************************************************************************/
110:
111: /* compute absolute value for arbitrary (in my case, LONG) number */
112: /* this is to avoid compiler warnings about data conversion */
113: #define L_ABS(x) (((x) > 0) ? (x) : (-(x)))
114:
115: typedef struct
116: {
117: HAB hab;
118: HMQ hMsgQ;
119: HWND hwndFrame;
120: HWND hwnd;
121:
122: BOOL fFirstTime; /* TRUE --> first time initialization of rcl */
123: RECTL rcl; /* dimensions of client rectangle */
124:
125: HPS hpsFat;
126: HDC hdcFat;
127: HBITMAP hbmFat;
128: HPS hpsFatShadow;
129: HDC hdcFatShadow;
130: HBITMAP hbmFatShadow;
131:
132: RECTL rclFatBM; /* dimensions of fatbits bitmap */
133: RECTL rclFat; /* dimensions of active fat bits grid */
134: LONG cxFatPel; /* width of fat pel */
135: LONG cyFatPel; /* height of fat pel */
136: LONG cxHalfFatPel;
137: LONG cyHalfFatPel;
138: USHORT usPelShape;
139:
140: MATRIXLF matlf; /* goes from window coords to fatpel coords */
141:
142: BOOL fRGB; /* TRUE --> color mode is RGB */
143: COLOR clrMathObj;
144: COLOR clrRenderedObj;
145: COLOR clrField;
146: COLOR clrCrossHair;
147: COLOR clrInterstice;
148: COLOR clrControlPoints;
149:
150: COLOR clrBlackIndex;
151: COLOR clrEditPel;
152:
153: USHORT usControlPointSymbol;
154:
155: BOOL fDisplayRenderedObj;
156: BOOL fDisplayMathObj;
157: BOOL fDisplayControlPoints;
158: BOOL fDisplayCrossHairs;
159: BOOL fDisplayPelBorder;
160: BOOL fRoundControlPoints;
161: BOOL fAutoRedraw;
162: USHORT usCurPrim;
163: USHORT usMix;
164:
165: LONG cptl;
166: PPOINTL pptl;
167: PPOINTL pptlTmp;
168:
169: BOOL fDraggingPelSize;
170: HPOINTER hptrDragSize;
171:
172: BOOL fDraggingPelColor;
173: HPOINTER hptrDragColor;
174:
175: SHORT sPtGrabbed;
176: BOOL fDraggingControlPoint;
177: LONG lHitPrecision;
178:
179: BOOL fEditPelColors;
180:
181: } GLOBALDATA;
182: GLOBALDATA global;
183:
184:
185:
186:
187: /************************************************************************
188: *
189: * main
190: *
191: * WinInitialize resizes our ring 2 stack, among other things, so
192: * we won't GP fault trying to do graphics. WinCreateMsgQueue defines
193: * us as a REAL PM app. (WINDOWAPI in .DEF file does also).
194: * Call a sub to register our window class and create a window.
195: * Loop over messages. Exit cleanly.
196: *
197: ************************************************************************/
198:
199: VOID cdecl
200: main()
201: {
202: QMSG qMsg;
203: int iRet = 0;
204:
205:
206: global.hab = WinInitialize(NULL);
207: global.hMsgQ = WinCreateMsgQueue(global.hab, 0);
208:
209: if (InitApp())
210: while (WinGetMsg( global.hab, (PQMSG)&qMsg, (HWND)NULL, 0, 0 ))
211: WinDispatchMsg( global.hab, (PQMSG)&qMsg );
212: else
213: iRet = -1;
214:
215: WinDestroyWindow( global.hwndFrame );
216: WinDestroyMsgQueue( global.hMsgQ );
217: WinTerminate( global.hab );
218: DosExit(EXIT_PROCESS, iRet);
219: }
220:
221:
222:
223:
224: /****************************************************************************
225: *
226: * InitGlobals
227: *
228: * Initialize global variables.
229: *
230: ****************************************************************************/
231:
232: BOOL FAR
233: InitGlobals()
234: {
235: global.fFirstTime = TRUE;
236:
237: global.rcl.xLeft = 0L;
238: global.rcl.yBottom = 0L;
239: global.rcl.xRight = 0L;
240: global.rcl.yTop = 0L;
241:
242: global.hpsFat = NULL;
243: global.hdcFat = NULL;
244: global.hbmFat = NULL;
245: global.hpsFatShadow = NULL;
246: global.hdcFatShadow = NULL;
247: global.hbmFatShadow = NULL;
248: global.rclFatBM.xLeft = 0L;
249: global.rclFatBM.yBottom = 0L;
250: global.rclFatBM.xRight = 0L;
251: global.rclFatBM.yTop = 0L;
252:
253: global.cxFatPel = 32L;
254: global.cyFatPel = 32L;
255: global.cxHalfFatPel = global.cxFatPel / 2L;
256: global.cyHalfFatPel = global.cyFatPel / 2L;
257: global.usPelShape = IDC_CIRCLE;
258:
259: global.fRGB = FALSE;
260: global.clrMathObj = CLR_BLUE;
261: global.clrRenderedObj = CLR_NEUTRAL;
262: global.clrField = CLR_CYAN;
263: global.clrCrossHair = CLR_DARKCYAN;
264: global.clrInterstice = CLR_BACKGROUND;
265: global.clrControlPoints = CLR_YELLOW;
266:
267: global.clrBlackIndex = CLR_ERROR;
268: global.clrEditPel = CLR_ERROR;
269:
270: global.usControlPointSymbol = MARKSYM_SOLIDDIAMOND;
271:
272: global.fDisplayRenderedObj = TRUE;
273: global.fDisplayMathObj = TRUE;
274: global.fDisplayControlPoints = TRUE;
275: global.fDisplayCrossHairs = TRUE;
276: global.fDisplayPelBorder = TRUE;
277: global.fRoundControlPoints = FALSE;
278: global.fAutoRedraw = TRUE;
279: global.usCurPrim = IDM_POLYLINE;
280: global.usMix = FM_OVERPAINT;
281:
282: global.fDraggingPelSize = FALSE;
283: global.fDraggingPelColor = FALSE;
284: global.fDraggingControlPoint = FALSE;
285: global.sPtGrabbed = NO_POINT;
286: global.lHitPrecision = 0L;
287:
288: global.fEditPelColors = FALSE;
289:
290: global.cptl = 0L;
291: global.pptl = global.pptlTmp = NULL;
292: if (DosAllocMem(&global.pptl, CPTLMAX * sizeof(POINTL), fPERM|PAG_COMMIT))
293: return FALSE;
294: if (DosAllocMem(&global.pptlTmp, CPTLMAX * sizeof(POINTL), fPERM|PAG_COMMIT))
295: return FALSE;
296:
297: return TRUE;
298: }
299:
300:
301:
302:
303: /****************************************************************************
304: *
305: * InitApp
306: *
307: * Register application window class and creates standard window.
308: *
309: ****************************************************************************/
310:
311: #define INIT_MENU_ITEM(val, var) \
312: TOGGLE_MENU_ITEM(global.hwndFrame, (val), (var))
313:
314: BOOL FAR
315: InitApp()
316: {
317: char szTitle[24];
318: ULONG ctldata;
319: PID pid;
320: TID tid;
321: HSWITCH hsw;
322: static SWCNTRL swctl = { 0, 0, 0, 0, 0, SWL_VISIBLE,
323: SWL_JUMPABLE, "FatPels", 0 };
324:
325: if (!InitGlobals())
326: return FALSE;
327:
328:
329: /* Register Application Window Class */
330:
331: WinLoadString( global.hab, NULL, IDS_TITLE, sizeof(szTitle), (PCH)szTitle );
332: if ( !WinRegisterClass( global.hab, (PCH)szTitle, (PFNWP)WndProc,
333: CS_SIZEREDRAW, 0 ))
334: return FALSE;
335:
336:
337: /* Load the pointer to use when dragging pel size. */
338: if (!(global.hptrDragSize = WinLoadPointer( HWND_DESKTOP, NULL, IDR_DRAGSIZEPTR )))
339: return FALSE;
340:
341: /* Load the pointer to use when dragging pel color. */
342: if (!(global.hptrDragColor = WinLoadPointer( HWND_DESKTOP, NULL, IDR_DRAGCOLORPTR )))
343: return FALSE;
344:
345:
346: /* Create a window instance of class "FatPel" */
347:
348: ctldata = FCF_STANDARD &
349: ~(ULONG)(FCF_ACCELTABLE | FCF_TASKLIST);
350:
351: if (global.hwndFrame = WinCreateStdWindow(
352: HWND_DESKTOP, /* specify desktop as parent window */
353: WS_VISIBLE, /* window styles */
354: &ctldata, /* frame creation flags */
355: (PCH)szTitle, /* window class name */
356: (PCH)szTitle, /* name appearing in window caption */
357: 0L, /* */
358: (HMODULE)NULL, /* use current executable module id */
359: IDW_FATPEL, /* menu id */
360: (HWND FAR *)&global.hwnd /* window handle */
361: ))
362: {
363: INIT_MENU_ITEM(IDM_RENDEREDOBJ, global.fDisplayRenderedObj);
364: INIT_MENU_ITEM(IDM_MATHOBJ, global.fDisplayMathObj);
365: INIT_MENU_ITEM(IDM_CTLPOINTS, global.fDisplayControlPoints);
366: INIT_MENU_ITEM(IDM_CROSSHAIRS, global.fDisplayCrossHairs);
367: INIT_MENU_ITEM(IDM_PELBORDER, global.fDisplayPelBorder);
368: INIT_MENU_ITEM(IDM_ROUNDPOINTS, global.fRoundControlPoints);
369: INIT_MENU_ITEM(IDM_AUTOREDRAW, global.fAutoRedraw);
370: INIT_MENU_ITEM(IDM_EDITPELCOLORS, global.fEditPelColors);
371:
372: CHECK_MENU_ITEM(global.hwndFrame, global.usCurPrim);
373:
374:
375: /* Add ourselves to the switch list. */
376:
377: WinQueryWindowProcess(global.hwndFrame, &pid, &tid);
378: swctl.hwnd = global.hwndFrame;
379: swctl.idProcess = pid;
380: hsw = WinAddSwitchEntry(&swctl);
381:
382: return TRUE;
383: }
384: return FALSE;
385: }
386:
387:
388:
389:
390: /*************************************************************************
391: *
392: * WndProc
393: *
394: * Process messages for the window class.
395: *
396: ************************************************************************/
397:
398: MRESULT EXPENTRY
399: WndProc( hwnd, usMsg, mp1, mp2 )
400: HWND hwnd;
401: USHORT usMsg;
402: MPARAM mp1;
403: MPARAM mp2;
404: {
405: switch (usMsg)
406: {
407: case WM_CLOSE:
408: Close(hwnd);
409: break;
410:
411: case WM_COMMAND:
412: Command(hwnd, LOUSHORT(mp1));
413: break;
414:
415: case WM_PAINT:
416: {
417: HPS hps;
418:
419: if (global.fFirstTime)
420: {
421: SIZEF sizfx;
422:
423: hps = WinGetPS(hwnd);
424: GpiQueryMarkerBox(hps, &sizfx);
425: global.lHitPrecision = sizfx.cx / 0x20000L + 1L;
426: WinReleasePS(hps);
427:
428: UpdateSurfaceDims();
429: global.fFirstTime = FALSE;
430: }
431:
432: /* The small bitmap may have been resized since we last
433: * painted, in which case it will have been initialized to
434: * the field color. Therefore, we will render the mathematical
435: * object to make sure the right fatpels are there.
436: */
437: global.usMix = FM_OVERPAINT;
438: hps = WinBeginPaint(global.hwnd, NULL, NULL);
439: Paint(hps, CLEAR_BACKGROUND|RENDER_MATH_OBJ);
440: WinEndPaint(hps);
441: }
442: break;
443:
444: case WM_BUTTON1DOWN:
445: case WM_BUTTON2DOWN:
446: ButtonDown(hwnd, usMsg, mp1);
447: break;
448:
449: case WM_BUTTON1UP:
450: case WM_BUTTON2UP:
451: ButtonUp(hwnd, usMsg);
452: break;
453:
454: case WM_MOUSEMOVE:
455: MouseMove(hwnd, mp1);
456: break;
457:
458: case WM_SIZE:
459: UpdateSurfaceDims();
460: return( (MRESULT)WinDefWindowProc(hwnd, usMsg, mp1, mp2));
461: break;
462:
463: default:
464: return( (MRESULT)WinDefWindowProc(hwnd, usMsg, mp1, mp2));
465: break;
466: }
467:
468: return FALSE;
469: }
470:
471:
472:
473:
474: /************************************************************************
475: *
476: * MouseMove
477: *
478: ************************************************************************/
479:
480: VOID
481: MouseMove(hwnd, mp1)
482: HWND hwnd;
483: MPARAM mp1;
484: {
485: POINTL ptl;
486: HPS hps;
487:
488:
489: /* make sure we still have our pointer */
490: /* notice the hierarchy of pointer modes */
491:
492: if (global.fDraggingPelSize)
493: {
494: if (global.hptrDragSize)
495: WinSetPointer(HWND_DESKTOP,global.hptrDragSize);
496: }
497: else if (global.fEditPelColors)
498: {
499: if (global.hptrDragColor)
500: WinSetPointer(HWND_DESKTOP,global.hptrDragColor);
501: }
502: else
503: WinSetPointer(HWND_DESKTOP,
504: WinQuerySysPointer(HWND_DESKTOP,SPTR_ARROW,FALSE));
505:
506:
507: if (global.fDraggingPelColor)
508: {
509: POINTL ptl, ptlFat;
510: HPS hps;
511:
512:
513: ptl.x = (LONG) LOUSHORT(mp1);
514: ptl.y = (LONG) HIUSHORT(mp1);
515:
516: /* letting the point go negative causes overflow errors */
517: if (ptl.x < 0)
518: ptl.x = 0;
519: if (ptl.y < 0)
520: ptl.y = 0;
521:
522: GetFatPelFromPt(&ptl, &ptlFat);
523: SetFatPel(&ptlFat, global.clrEditPel);
524:
525: hps = WinGetPS(hwnd);
526: Paint(hps, OVERRIDE_RENDERED_OBJ);
527: Paint(hps, IGNORED); /* this call just copies fatpels to the screen */
528: WinReleasePS(hps);
529: }
530: else if (global.fDraggingControlPoint)
531: {
532: ptl.x = (LONG) LOUSHORT(mp1);
533: ptl.y = (LONG) HIUSHORT(mp1);
534:
535: /* letting the point go negative causes overflow errors */
536: if (ptl.x < 0)
537: ptl.x = 0;
538: if (ptl.y < 0)
539: ptl.y = 0;
540:
541: if (global.sPtGrabbed != NO_POINT)
542: {
543: hps = WinGetPS(hwnd);
544: Paint(hps, OVERRIDE_RENDERED_OBJ);
545:
546: global.pptl[global.sPtGrabbed] = ptl;
547:
548: Paint(hps, CLEAR_FAT_BITMAP|RENDER_MATH_OBJ);
549: WinReleasePS(hps);
550: }
551: }
552: }
553:
554:
555:
556:
557: /************************************************************************
558: *
559: * ButtonUp
560: *
561: ************************************************************************/
562:
563: VOID
564: ButtonUp(hwnd, usMsg)
565: HWND hwnd;
566: USHORT usMsg;
567: {
568: SHORT i;
569: HPS hps;
570:
571:
572: if (global.fDraggingPelColor)
573: {
574: global.fDraggingPelColor = FALSE;
575: WinSetCapture(HWND_DESKTOP, NULL);
576: }
577: else if (global.fDraggingControlPoint)
578: {
579: global.fDraggingControlPoint = FALSE;
580: WinSetCapture(HWND_DESKTOP, NULL);
581: if (global.sPtGrabbed != NO_POINT)
582: {
583: if (usMsg == WM_BUTTON2UP) /* remove point? */
584: {
585: hps = WinGetPS(hwnd);
586: Paint(hps, OVERRIDE_RENDERED_OBJ);
587:
588: /* squeeze out selected point */
589: if ((i = global.sPtGrabbed) < (SHORT)(global.cptl-1))
590: while (i < (SHORT)(global.cptl-1))
591: {
592: global.pptl[i] = global.pptl[i+1];
593: ++i;
594: }
595:
596: --global.cptl;
597: global.sPtGrabbed = NO_POINT;
598:
599: Paint(hps, CLEAR_FAT_BITMAP|RENDER_MATH_OBJ);
600: WinReleasePS(hps);
601: }
602: else /* WM_BUTTON1UP */
603: global.sPtGrabbed = NO_POINT;
604: }
605: }
606: }
607:
608:
609:
610:
611: /************************************************************************
612: *
613: * ButtonDown
614: *
615: ************************************************************************/
616:
617: VOID
618: ButtonDown(hwnd, usMsg, mp1)
619: HWND hwnd;
620: USHORT usMsg;
621: MPARAM mp1;
622: {
623: if (global.fDraggingPelSize)
624: {
625: POINTS pt;
626: HPS hps;
627:
628: pt.x = LOUSHORT(mp1);
629: pt.y = HIUSHORT(mp1);
630: DragPelSize(hwnd, pt);
631: global.fDraggingPelSize = FALSE;
632:
633: WinSetPointer(HWND_DESKTOP,
634: WinQuerySysPointer(HWND_DESKTOP,SPTR_ARROW,FALSE));
635:
636: hps = WinGetPS(hwnd);
637: global.usMix = FM_OVERPAINT;
638: Paint(hps, CLEAR_BACKGROUND|CLEAR_FAT_BITMAP|RENDER_MATH_OBJ);
639: WinReleasePS(hps);
640: }
641: else if (global.fEditPelColors)
642: {
643: POINTL ptl, ptlFat;
644: HPS hps;
645:
646: global.fDraggingPelColor = TRUE;
647: WinSetCapture(HWND_DESKTOP, hwnd);
648:
649: ptl.x = (LONG) LOUSHORT(mp1);
650: ptl.y = (LONG) HIUSHORT(mp1);
651:
652: if (global.usMix != FM_XOR)
653: {
654: hps = WinGetPS(hwnd);
655: global.usMix = FM_XOR;
656: Paint(hps, CLEAR_BACKGROUND);
657: WinReleasePS(hps);
658: }
659:
660: if (usMsg == WM_BUTTON1DOWN)
661: global.clrEditPel = global.clrRenderedObj;
662: else
663: global.clrEditPel = global.clrField;
664:
665: GetFatPelFromPt(&ptl, &ptlFat);
666: SetFatPel(&ptlFat, global.clrEditPel);
667:
668: hps = WinGetPS(hwnd);
669: Paint(hps, OVERRIDE_RENDERED_OBJ);
670: Paint(hps, IGNORED); /* this call just copies fatpels to the screen */
671: WinReleasePS(hps);
672: }
673: else if (!global.fDraggingControlPoint)
674: {
675: POINTL ptl;
676: SHORT sNewPtGrabbed;
677: HPS hps;
678:
679: global.fDraggingControlPoint = TRUE;
680: WinSetCapture(HWND_DESKTOP, hwnd);
681:
682: ptl.x = (LONG) LOUSHORT(mp1);
683: ptl.y = (LONG) HIUSHORT(mp1);
684:
685: sNewPtGrabbed = IsPtInList(&ptl);
686:
687: if (global.usMix != FM_XOR)
688: {
689: hps = WinGetPS(hwnd);
690: global.usMix = FM_XOR;
691: Paint(hps, CLEAR_BACKGROUND);
692: WinReleasePS(hps);
693: }
694:
695: if (usMsg == WM_BUTTON1DOWN) /* add/move point? */
696: {
697: hps = WinGetPS(hwnd);
698:
699: if (sNewPtGrabbed != NO_POINT)
700: global.sPtGrabbed = sNewPtGrabbed;
701: Paint(hps, OVERRIDE_RENDERED_OBJ);
702:
703: if (sNewPtGrabbed == NO_POINT)
704: global.sPtGrabbed = AddPtToList(&ptl);
705: else
706: global.sPtGrabbed = sNewPtGrabbed;
707:
708: Paint(hps, CLEAR_FAT_BITMAP|RENDER_MATH_OBJ);
709: WinReleasePS(hps);
710:
711: if (global.sPtGrabbed == NO_POINT)
712: MyMessageBox(global.hwnd, "Cannot add any more points.");
713: }
714: else if (sNewPtGrabbed != NO_POINT)
715: global.sPtGrabbed = sNewPtGrabbed;
716: }
717: }
718:
719:
720:
721:
722: /************************************************************************
723: *
724: * GetFatPelFromPt
725: *
726: ************************************************************************/
727:
728: VOID
729: GetFatPelFromPt(pptl, pptlFat)
730: PPOINTL pptl;
731: PPOINTL pptlFat;
732: {
733: pptlFat->x = pptl->x / global.cxFatPel;
734: pptlFat->y = pptl->y / global.cyFatPel;
735: }
736:
737:
738:
739:
740: /************************************************************************
741: *
742: * SetFatPel
743: *
744: ************************************************************************/
745:
746: VOID
747: SetFatPel(pptl, clr)
748: PPOINTL pptl;
749: COLOR clr;
750: {
751: LINEBUNDLE lb;
752:
753: if (global.hpsFat)
754: {
755: lb.lColor = clr;
756: GpiSetAttrs(global.hpsFat, PRIM_LINE, LBB_COLOR, 0L, &lb);
757: GpiSetPel(global.hpsFat, pptl);
758: }
759: }
760:
761:
762:
763:
764: /************************************************************************
765: *
766: * IsPtInList
767: *
768: ************************************************************************/
769:
770: SHORT
771: IsPtInList(pptl)
772: PPOINTL pptl;
773: {
774: SHORT i;
775:
776:
777: /* try to find pptl in the points we already have */
778: for (i = 0; i < (SHORT)global.cptl; ++i)
779: if (((L_ABS(pptl->x - global.pptl[i].x)) <= global.lHitPrecision) &&
780: ((L_ABS(pptl->y - global.pptl[i].y)) <= global.lHitPrecision))
781: return i;
782:
783: /* couldn't find it */
784: return NO_POINT;
785: }
786:
787:
788:
789:
790: /************************************************************************
791: *
792: * AddPtToList
793: *
794: ************************************************************************/
795:
796: SHORT
797: AddPtToList(pptl)
798: PPOINTL pptl;
799: {
800: SHORT i, j;
801:
802: if (global.cptl < CPTLMAX)
803: {
804: /* check for new points lying on a line segment */
805: for (i = 0; i < (SHORT)(global.cptl-1L); ++i)
806: if (IsPtCloseToLine(&global.pptl[i], &global.pptl[i+1], pptl))
807: {
808: /* insert point between endpoints of nearest line segment */
809: for (j = (SHORT)global.cptl; j > i+1; --j)
810: global.pptl[j] = global.pptl[j - 1];
811: global.pptl[i+1] = *pptl;
812: ++global.cptl;
813: return i+1;
814: }
815:
816: /* append the point */
817:
818: i = (SHORT) global.cptl;
819: global.pptl[i] = *pptl;
820: ++global.cptl;
821: return i;
822: }
823:
824: return NO_POINT;
825: }
826:
827:
828:
829:
830: /************************************************************************
831: *
832: * IsPtCloseToLine
833: *
834: ************************************************************************/
835:
836: BOOL
837: IsPtCloseToLine(pptl1, pptl2, pptlTest)
838: PPOINTL pptl1;
839: PPOINTL pptl2;
840: PPOINTL pptlTest;
841: {
842: POINTL ptlLL, ptlUR;
843: LONG dx, dy, yIntercept, error;
844: LONG lBoxAdjustment;
845:
846:
847: /* find the bounding box of the line segment */
848:
849: ptlLL = *pptl1; /* assume line goes lower left to upper right */
850: ptlUR = *pptl2;
851: if (pptl1->x > pptl2->x)
852: SwapLong(&ptlLL.x, &ptlUR.x);
853: if (pptl1->y > pptl2->y)
854: SwapLong(&ptlLL.y, &ptlUR.y);
855:
856:
857: /* adjust the bounding box if it's too narrow */
858:
859: lBoxAdjustment = global.lHitPrecision/2L;
860:
861: dx = pptl2->x - pptl1->x;
862: if (L_ABS(dx) <= global.lHitPrecision)
863: {
864: ptlLL.x -= lBoxAdjustment;
865: ptlUR.x += lBoxAdjustment;
866: }
867: dy = pptl2->y - pptl1->y;
868: if (L_ABS(dy) <= global.lHitPrecision)
869: {
870: ptlLL.y -= lBoxAdjustment;
871: ptlUR.y += lBoxAdjustment;
872: }
873:
874:
875: /* see if the test point is in the bounding box of the line segment */
876:
877: if ((pptlTest->x >= ptlLL.x) &&
878: (pptlTest->x <= ptlUR.x) &&
879: (pptlTest->y >= ptlLL.y) &&
880: (pptlTest->y <= ptlUR.y))
881: {
882: /* test for special cases */
883:
884: if (dx == 0) /* vertical line */
885: {
886: return (L_ABS(pptlTest->x - pptl1->x) <= global.lHitPrecision);
887: }
888:
889: if (dy == 0) /* horizontal line */
890: {
891: return (L_ABS(pptlTest->y - pptl1->y) <= global.lHitPrecision);
892: }
893:
894:
895: /* test for general case */
896:
897: yIntercept = pptl1->y - (pptl1->x * dy) / dx;
898:
899: error = pptlTest->y - (pptlTest->x * dy / dx) - yIntercept;
900: if (L_ABS(error) <= global.lHitPrecision)
901: return TRUE;
902: }
903:
904: return FALSE;
905: }
906:
907:
908:
909:
910: /************************************************************************
911: *
912: * SwapLong
913: *
914: ************************************************************************/
915:
916: VOID
917: SwapLong(pl1, pl2)
918: PLONG pl1, pl2;
919: {
920: LONG lTmp;
921:
922: lTmp = *pl1;
923: *pl1 = *pl2;
924: *pl2 = lTmp;
925: }
926:
927:
928:
929:
930: /************************************************************************
931: *
932: * DragPelSize
933: *
934: * Set the dimensions of a fat pel by dragging a rectangle
935: * on the screen.
936: *
937: ************************************************************************/
938:
939: VOID
940: DragPelSize(hwnd, pt)
941: HWND hwnd;
942: POINTS pt;
943: {
944: TRACKINFO ti;
945:
946: WinSendMsg(global.hwndFrame, WM_QUERYTRACKINFO, (MPARAM)TF_MOVE, (MPARAM)&ti);
947:
948: ti.cxBorder = 1;
949: ti.cyBorder = 1;
950: ti.rclTrack.xLeft = (LONG)pt.x;
951: ti.rclTrack.yBottom = (LONG)pt.y;
952: ti.rclTrack.xRight = (LONG)pt.x;
953: ti.rclTrack.yTop = (LONG)pt.y;
954: ti.fs = TF_RIGHT | TF_TOP;
955: ti.ptlMinTrackSize.x = 1L;
956: ti.ptlMinTrackSize.y = 1L;
957:
958: if (WinTrackRect(hwnd, NULL, &ti))
959: {
960: global.cxFatPel = (ti.rclTrack.xRight - ti.rclTrack.xLeft) ;
961: global.cyFatPel = (ti.rclTrack.yTop - ti.rclTrack.yBottom);
962:
963: if (global.cxFatPel < 1L)
964: global.cxFatPel = 1L;
965:
966: if (global.cyFatPel < 1L)
967: global.cyFatPel = 1L;
968:
969: global.cxHalfFatPel = global.cxFatPel / 2L;
970: global.cyHalfFatPel = global.cyFatPel / 2L;
971:
972: UpdateSurfaceDims();
973: }
974: }
975:
976:
977:
978:
979: /************************************************************************
980: *
981: * Close
982: *
983: ************************************************************************/
984:
985: VOID
986: Close(hwnd)
987: HWND hwnd;
988: {
989: if (global.hptrDragSize)
990: WinDestroyPointer(global.hptrDragSize);
991: WinPostMsg(hwnd, WM_QUIT, 0L, 0L);
992: }
993:
994:
995:
996:
997: /************************************************************************
998: *
999: * Command
1000: *
1001: * Dispatches menu commands to the proper handlers.
1002: *
1003: ************************************************************************/
1004:
1005: #define UPDATE_MENU_BOOL(var, val) \
1006: { \
1007: TOGGLE_BOOL((var)); \
1008: TOGGLE_MENU_ITEM(global.hwndFrame, (val), (var)); \
1009: }
1010:
1011: #define UPDATE_MENU_LIST(var, val) \
1012: { \
1013: UNCHECK_MENU_ITEM(global.hwndFrame, (var)); \
1014: (var) = (val); \
1015: CHECK_MENU_ITEM(global.hwndFrame, (var)); \
1016: }
1017:
1018: VOID
1019: Command(hwnd, id)
1020: HWND hwnd;
1021: USHORT id;
1022: {
1023: BOOL fRedraw = FALSE;
1024: USHORT fsCmd = IGNORED;
1025:
1026:
1027: switch (id)
1028: {
1029: case IDM_SAVE:
1030: SaveWindowToFile(hwnd);
1031: break;
1032:
1033: case IDM_ABOUT:
1034: WinDlgBox( HWND_DESKTOP, hwnd, (PFNWP)AboutDlg, NULL,
1035: IDD_ABOUTDLG, NULL );
1036: break;
1037:
1038: case IDM_REDRAW:
1039: fsCmd = CLEAR_BACKGROUND|CLEAR_FAT_BITMAP|RENDER_MATH_OBJ;
1040: break;
1041:
1042: case IDM_SETPELSIZE:
1043: {
1044: LONG cxFatPel, cyFatPel;
1045:
1046: cxFatPel = global.cxFatPel;
1047: cyFatPel = global.cyFatPel;
1048:
1049: if (WinDlgBox( HWND_DESKTOP, hwnd, (PFNWP)PelSizeDlg, NULL,
1050: IDD_PELSIZEDLG, NULL ))
1051: {
1052: if ((cxFatPel == global.cxFatPel) &&
1053: (cyFatPel == global.cyFatPel))
1054: fsCmd = CLEAR_BACKGROUND;
1055: else
1056: fsCmd = CLEAR_BACKGROUND|CLEAR_FAT_BITMAP|RENDER_MATH_OBJ;
1057: fRedraw = TRUE;
1058: }
1059: }
1060: break;
1061:
1062: case IDM_DRAGPELSIZE:
1063: global.fDraggingPelSize = TRUE;
1064: break;
1065:
1066: case IDM_RENDEREDOBJ:
1067: UPDATE_MENU_BOOL(global.fDisplayRenderedObj, IDM_RENDEREDOBJ);
1068: fsCmd = CLEAR_BACKGROUND|CLEAR_FAT_BITMAP|RENDER_MATH_OBJ;
1069: fRedraw = TRUE;
1070: break;
1071:
1072: case IDM_MATHOBJ:
1073: UPDATE_MENU_BOOL(global.fDisplayMathObj, IDM_MATHOBJ);
1074: fsCmd = CLEAR_BACKGROUND;
1075: fRedraw = TRUE;
1076: break;
1077:
1078: case IDM_CTLPOINTS:
1079: UPDATE_MENU_BOOL(global.fDisplayControlPoints, IDM_CTLPOINTS);
1080: fsCmd = CLEAR_BACKGROUND;
1081: fRedraw = TRUE;
1082: break;
1083:
1084: case IDM_CROSSHAIRS:
1085: UPDATE_MENU_BOOL(global.fDisplayCrossHairs, IDM_CROSSHAIRS);
1086: fsCmd = CLEAR_BACKGROUND;
1087: fRedraw = TRUE;
1088: break;
1089:
1090: case IDM_PELBORDER:
1091: UPDATE_MENU_BOOL(global.fDisplayPelBorder, IDM_PELBORDER);
1092: fsCmd = CLEAR_BACKGROUND;
1093: fRedraw = TRUE;
1094: break;
1095:
1096: case IDM_ROUNDPOINTS:
1097: UPDATE_MENU_BOOL(global.fRoundControlPoints, IDM_ROUNDPOINTS);
1098: fsCmd = CLEAR_BACKGROUND;
1099: fRedraw = TRUE;
1100: break;
1101:
1102: case IDM_AUTOREDRAW:
1103: UPDATE_MENU_BOOL(global.fAutoRedraw, IDM_AUTOREDRAW);
1104: break;
1105:
1106: case IDM_NOPRIM:
1107: case IDM_POLYLINE:
1108: case IDM_POLYFILLET:
1109: case IDM_POLYSPLINE:
1110: case IDM_POINTARC:
1111: UPDATE_MENU_LIST(global.usCurPrim, id);
1112: fsCmd = CLEAR_BACKGROUND|CLEAR_FAT_BITMAP|RENDER_MATH_OBJ;
1113: fRedraw = TRUE;
1114: break;
1115:
1116: case IDM_SETCOLORS:
1117: if (WinDlgBox( HWND_DESKTOP, hwnd, (PFNWP)ColorsDlg, NULL,
1118: IDD_COLORSDLG, NULL ))
1119: {
1120: fsCmd = CLEAR_BACKGROUND|RENDER_MATH_OBJ;
1121: fRedraw = TRUE;
1122: }
1123: break;
1124:
1125: case IDM_EDITPELCOLORS:
1126: UPDATE_MENU_BOOL(global.fEditPelColors, IDM_EDITPELCOLORS);
1127: break;
1128:
1129: case IDM_CLEARALL:
1130: global.cptl = 0L;
1131: fsCmd = CLEAR_BACKGROUND|CLEAR_FAT_BITMAP|RENDER_MATH_OBJ;
1132: fRedraw = TRUE;
1133: break;
1134: }
1135:
1136: if ((global.fAutoRedraw && fRedraw) || (id == IDM_REDRAW))
1137: {
1138: HPS hps;
1139:
1140: hps = WinGetPS(hwnd);
1141: global.usMix = FM_OVERPAINT;
1142: Paint(hps, fsCmd);
1143: WinReleasePS(hps);
1144: }
1145: }
1146:
1147:
1148:
1149:
1150: /************************************************************************
1151: *
1152: * Paint
1153: *
1154: ************************************************************************/
1155:
1156: VOID
1157: Paint(hps, fsCmd)
1158: HPS hps;
1159: USHORT fsCmd;
1160: {
1161: HRGN hrgn, hrgnClipOld, hrgnT;
1162:
1163:
1164: /* Clear the unused part of the client rectangle to a hatch pattern. */
1165: if (fsCmd & CLEAR_BACKGROUND)
1166: EraseBackground(hps);
1167:
1168:
1169: /* Set up the color mode as the user has requested */
1170:
1171: if (global.fRGB)
1172: {
1173: GpiCreateLogColorTable(hps, LCOL_RESET, LCOLF_RGB, 0L, 0L, NULL);
1174: if (global.hpsFat)
1175: {
1176: GpiCreateLogColorTable(global.hpsFat, LCOL_RESET, LCOLF_RGB, 0L, 0L, NULL);
1177: GpiCreateLogColorTable(global.hpsFatShadow, LCOL_RESET, LCOLF_RGB, 0L, 0L, NULL);
1178: }
1179: }
1180: else
1181: if (global.hpsFat)
1182: {
1183: GpiCreateLogColorTable(global.hpsFat, LCOL_RESET, LCOLF_INDRGB, 0L, 0L, NULL);
1184: GpiCreateLogColorTable(global.hpsFatShadow, LCOL_RESET, LCOLF_INDRGB, 0L, 0L, NULL);
1185: global.clrBlackIndex = GpiQueryColorIndex(hps, 0L, 0x000000L);
1186: }
1187:
1188:
1189: if (global.usPelShape == IDC_CIRCLE)
1190: {
1191: ARCPARAMS arcp;
1192:
1193: arcp.lP = global.cxFatPel / 2L;
1194: arcp.lQ = global.cyFatPel / 2L;
1195: arcp.lR = 0L;
1196: arcp.lS = 0L;
1197:
1198: GpiSetArcParams(hps, &arcp);
1199: }
1200:
1201:
1202: /* set clipping rectangle to the fatbit surface */
1203:
1204: if ((hrgn = GpiCreateRegion(hps, 1L, &global.rcl)) != HRGN_ERROR)
1205: GpiSetClipRegion(hps, hrgn, &hrgnClipOld);
1206:
1207:
1208: if (fsCmd & CLEAR_BACKGROUND)
1209: {
1210: DrawGrid(hps);
1211:
1212: if (global.hpsFatShadow)
1213: {
1214: AREABUNDLE ab;
1215:
1216: /* clear shadow fatpel surface to background color */
1217: ab.lColor = global.clrField;
1218: GpiSetAttrs(global.hpsFatShadow, PRIM_AREA, ABB_COLOR, 0L, &ab);
1219: GpiBitBlt(global.hpsFatShadow, NULL, 2L, (PPOINTL)&global.rclFat, ROP_PATCOPY, NULL);
1220: }
1221: }
1222:
1223: if (global.fDisplayRenderedObj && !(fsCmd & OVERRIDE_RENDERED_OBJ))
1224: DisplayRenderedPels(hps, fsCmd);
1225:
1226: if (global.fDisplayControlPoints)
1227: {
1228: /* when rubberbanding with the rendered obj, newly drawn fatpels
1229: * can wipe out stationary control point markers, so we have to
1230: * redraw them all each time
1231: */
1232:
1233: if (global.fDisplayRenderedObj || (fsCmd & CLEAR_BACKGROUND))
1234: DisplayControlPoints(hps, global.cptl, global.pptl, global.usMix);
1235: else if (global.sPtGrabbed != NO_POINT)
1236: /* draw just the control point that moved */
1237: DisplayControlPoints(hps, 1L, global.pptl+global.sPtGrabbed, global.usMix);
1238: }
1239:
1240: if (global.fDisplayMathObj)
1241: DisplayMathematicalObject(hps, global.usMix);
1242:
1243: /* delete the clip region we set up */
1244:
1245: if (hrgnClipOld != HRGN_ERROR)
1246: GpiSetClipRegion(hps, hrgnClipOld, &hrgnT);
1247: if (hrgn != HRGN_ERROR)
1248: GpiDestroyRegion(hps, hrgn);
1249: }
1250:
1251:
1252:
1253:
1254: /************************************************************************
1255: *
1256: * DisplayMathematicalObject
1257: *
1258: ************************************************************************/
1259:
1260: VOID
1261: DisplayMathematicalObject(hps, usMix)
1262: HPS hps;
1263: USHORT usMix;
1264: {
1265: PPOINTL pptl;
1266: LINEBUNDLE lb;
1267:
1268: if (global.cptl > 0)
1269: {
1270: if (global.fRoundControlPoints)
1271: {
1272: RoundControlPoints(hps, global.cptl, global.pptl, global.pptlTmp,
1273: global.cxFatPel, global.cyFatPel);
1274: pptl = global.pptlTmp;
1275: }
1276: else
1277: pptl = global.pptl;
1278:
1279: /* draw line */
1280: lb.lColor = global.clrMathObj;
1281: lb.usMixMode = usMix;
1282: GpiSetAttrs(hps, PRIM_LINE, LBB_COLOR|LBB_MIX_MODE, 0L, &lb);
1283: DrawPrimitive(hps, global.cptl, pptl);
1284: }
1285: }
1286:
1287:
1288:
1289:
1290: /************************************************************************
1291: *
1292: * DisplayControlPoints
1293: *
1294: ************************************************************************/
1295:
1296: VOID
1297: DisplayControlPoints(hps, cptl, pptl, usMix)
1298: HPS hps;
1299: LONG cptl;
1300: PPOINTL pptl;
1301: USHORT usMix;
1302: {
1303: PPOINTL pptlT;
1304: MARKERBUNDLE mb;
1305:
1306: if (cptl > 0)
1307: {
1308: if (global.fRoundControlPoints)
1309: {
1310: RoundControlPoints(hps, cptl, pptl, global.pptlTmp,
1311: global.cxFatPel, global.cyFatPel);
1312: pptlT = global.pptlTmp;
1313: }
1314: else
1315: pptlT = pptl;
1316:
1317:
1318: mb.lColor = global.clrControlPoints;
1319: mb.usMixMode = usMix;
1320: mb.usSymbol = global.usControlPointSymbol;
1321: GpiSetAttrs(hps, PRIM_MARKER, MBB_COLOR|MBB_MIX_MODE|MBB_SYMBOL, 0L, &mb);
1322:
1323: GpiPolyMarker(hps, cptl, pptlT);
1324: }
1325: }
1326:
1327:
1328:
1329:
1330: /************************************************************************
1331: *
1332: * EraseBackground
1333: *
1334: * Erase the unused part of the window to a hatch pattern.
1335: *
1336: ************************************************************************/
1337:
1338: VOID
1339: EraseBackground(hps)
1340: HPS hps;
1341: {
1342: RECTL rclClient, rclT;
1343: AREABUNDLE ab;
1344:
1345:
1346: WinQueryWindowRect(global.hwnd, &rclClient);
1347:
1348: ab.lColor = CLR_BLACK;
1349: ab.lBackColor = CLR_WHITE;
1350: ab.usSymbol = PATSYM_DIAG1;
1351: GpiSetAttrs(hps, PRIM_AREA, ABB_COLOR|ABB_BACK_COLOR|ABB_SYMBOL,
1352: 0L, (PBUNDLE)&ab);
1353:
1354: if (global.rcl.yTop < rclClient.yTop)
1355: {
1356: rclT.xLeft = rclClient.xLeft;
1357: rclT.yBottom = global.rcl.yBottom;
1358: rclT.xRight = rclClient.xRight;
1359: rclT.yTop = rclClient.yTop;
1360: GpiBitBlt(hps, NULL, 2L, (PPOINTL)&rclT, ROP_PATCOPY, NULL);
1361: }
1362:
1363: if (global.rcl.xRight < rclClient.xRight)
1364: {
1365: rclT.xLeft = global.rcl.xRight;
1366: rclT.yBottom = rclClient.yBottom;
1367: rclT.xRight = rclClient.xRight;
1368: rclT.yTop = global.rcl.yTop;
1369: GpiBitBlt(hps, NULL, 2L, (PPOINTL)&rclT, ROP_PATCOPY, NULL);
1370: }
1371:
1372: ab.usSymbol = PATSYM_SOLID;
1373: GpiSetAttrs(hps, PRIM_AREA, ABB_SYMBOL, 0L, (PBUNDLE)&ab);
1374: }
1375:
1376:
1377:
1378:
1379: /************************************************************************
1380: *
1381: * DrawGrid
1382: *
1383: ************************************************************************/
1384:
1385: VOID
1386: DrawGrid(hps)
1387: HPS hps;
1388: {
1389: AREABUNDLE ab;
1390: POINTL ptl;
1391: POINTL aptl[3];
1392:
1393:
1394: /* clear fatpel surface to background color */
1395: ab.lColor = global.clrInterstice;
1396: GpiSetAttrs(hps, PRIM_AREA, ABB_COLOR, 0L, &ab);
1397: GpiBitBlt(hps, NULL, 2L, (PPOINTL)&global.rcl, ROP_PATCOPY, NULL);
1398:
1399:
1400: /* draw one pel in lower left corner */
1401:
1402: ptl.x = global.cxFatPel / 2L;
1403: ptl.y = global.cyFatPel / 2L;
1404: DrawOneFatPel(hps, &ptl, global.clrField);
1405:
1406:
1407: /* blt up first column then across -- we don't have to worry
1408: * about the edges because a clip region has been setup to do that.
1409: */
1410:
1411: aptl[0].x = 0L;
1412: aptl[0].y = global.cyFatPel;
1413: aptl[1].x = global.cxFatPel;
1414: aptl[2].x = 0L;
1415: aptl[2].y = 0L;
1416:
1417: while (aptl[0].y <= global.rcl.yTop)
1418: {
1419: aptl[1].y = aptl[0].y + aptl[0].y;
1420: GpiBitBlt(hps, hps, 3L, aptl, ROP_SRCCOPY, (LONG)NULL);
1421: aptl[0].y += aptl[1].y - aptl[0].y;
1422: }
1423:
1424: aptl[0].x = global.cxFatPel;
1425: aptl[0].y = 0L;
1426: aptl[1].y = global.rcl.yTop;
1427: aptl[2].x = 0L;
1428: aptl[2].y = 0L;
1429:
1430: while (aptl[0].x <= global.rcl.xRight)
1431: {
1432: aptl[1].x = aptl[0].x + aptl[0].x;
1433: GpiBitBlt(hps, hps, 3L, aptl, ROP_SRCCOPY, (LONG)NULL);
1434: aptl[0].x += aptl[1].x - aptl[0].x;
1435: }
1436: }
1437:
1438:
1439:
1440:
1441: /************************************************************************
1442: *
1443: * DisplayRenderedPels
1444: *
1445: ************************************************************************/
1446:
1447: VOID
1448: DisplayRenderedPels(hps, fsCmd)
1449: HPS hps;
1450: USHORT fsCmd;
1451: {
1452: LINEBUNDLE lb;
1453: AREABUNDLE ab;
1454: POINTL aptl[3];
1455:
1456: /* Call GPI to draw the current primitive into the small bitmap,
1457: * then fatbit it to the display.
1458: */
1459:
1460: if (global.hbmFat)
1461: {
1462: if (fsCmd & CLEAR_FAT_BITMAP)
1463: {
1464: /* clear fatpel surface to background color */
1465: ab.lColor = global.clrField;
1466: GpiSetAttrs(global.hpsFat, PRIM_AREA, ABB_COLOR, 0L, &ab);
1467: GpiBitBlt(global.hpsFat, NULL, 2L, (PPOINTL)&global.rclFat, ROP_PATCOPY, NULL);
1468: }
1469:
1470: if (fsCmd & RENDER_MATH_OBJ)
1471: {
1472: if (global.cptl > 0)
1473: {
1474: /* draw line */
1475: lb.lColor = global.clrRenderedObj;
1476: GpiSetAttrs(global.hpsFat, PRIM_LINE, LBB_COLOR, 0L, &lb);
1477: GpiSetModelTransformMatrix(global.hpsFat, 9L,
1478: &global.matlf, TRANSFORM_REPLACE);
1479: DrawPrimitive(global.hpsFat, global.cptl, global.pptl);
1480: GpiSetModelTransformMatrix(global.hpsFat, 0L, NULL, TRANSFORM_REPLACE);
1481: }
1482: }
1483:
1484: /* xor the new rendered bitmap into the shadow bitmap */
1485: *((PRECTL)&aptl[0]) = global.rclFat;
1486: aptl[2].x = 0L;
1487: aptl[2].y = 0L;
1488: GpiBitBlt(global.hpsFatShadow, global.hpsFat, 3L, aptl, ROP_SRCINVERT, NULL);
1489:
1490: /* fatbit object to the display */
1491: DrawFatPels(hps);
1492:
1493: /* get the new shadow bitmap */
1494: GpiBitBlt(global.hpsFatShadow, global.hpsFat, 3L, aptl, ROP_SRCCOPY, NULL);
1495: }
1496: }
1497:
1498:
1499:
1500:
1501: /************************************************************************
1502: *
1503: * DrawFatPels
1504: *
1505: ************************************************************************/
1506:
1507: VOID
1508: DrawFatPels(hps)
1509: HPS hps;
1510: {
1511: POINTL ptl, ptlCenter;
1512: LONG i, j;
1513: COLOR clr;
1514:
1515:
1516: /* if the pel size is 1,1, then just blt the small bitmap to the
1517: * display.
1518: */
1519:
1520: if ((global.cxFatPel == 1L) && (global.cyFatPel == 1L))
1521: {
1522: POINTL aptl[3];
1523:
1524: *((PRECTL)&aptl[0]) = global.rcl;
1525: aptl[2].x = 0L;
1526: aptl[2].y = 0L;
1527: GpiBitBlt(hps, global.hpsFat, 3L, aptl, ROP_SRCCOPY, 0L);
1528:
1529: return;
1530: }
1531:
1532: for (i = 0; i < global.rclFat.xRight; ++i)
1533: for (j = 0; j < global.rclFat.yTop; ++j)
1534: {
1535: ptl.x = i;
1536: ptl.y = j;
1537:
1538: clr = GpiQueryPel(global.hpsFatShadow, &ptl);
1539: if ((global.fRGB && (clr != 0x000000L)) ||
1540: (!global.fRGB && (clr != global.clrBlackIndex)))
1541: {
1542: clr = GpiQueryPel(global.hpsFat, &ptl);
1543: ptlCenter.x = (i * global.cxFatPel) + global.cxHalfFatPel;
1544: ptlCenter.y = (j * global.cyFatPel) + global.cyHalfFatPel;
1545: DrawOneFatPel(hps, &ptlCenter, clr);
1546: }
1547: }
1548: }
1549:
1550:
1551:
1552:
1553: /************************************************************************
1554: *
1555: * DrawOneFatPel
1556: *
1557: ************************************************************************/
1558:
1559: VOID
1560: DrawOneFatPel(hps, pptl, clr)
1561: HPS hps;
1562: PPOINTL pptl;
1563: COLOR clr;
1564: {
1565: POINTL ptl;
1566: LINEBUNDLE lb;
1567: AREABUNDLE ab;
1568:
1569:
1570: if (global.fDisplayPelBorder || global.fDisplayCrossHairs)
1571: {
1572: lb.lColor = global.clrCrossHair;
1573: GpiSetAttrs(hps, PRIM_LINE, LBB_COLOR, 0L, &lb);
1574: }
1575:
1576: ab.lColor = clr;
1577: GpiSetAttrs(hps, PRIM_AREA, ABB_COLOR, 0L, &ab);
1578:
1579:
1580: switch (global.usPelShape)
1581: {
1582: case IDC_SQUARE:
1583: {
1584: POINTL ptlT;
1585: ULONG flCmd;
1586:
1587: if (global.fDisplayPelBorder)
1588: flCmd = DRO_OUTLINEFILL;
1589: else
1590: flCmd = DRO_FILL;
1591:
1592: ptlT.x = pptl->x - global.cxHalfFatPel;
1593: ptlT.y = pptl->y - global.cyHalfFatPel;
1594: GpiSetCurrentPosition(hps, &ptlT);
1595: ptlT.x = pptl->x + global.cxHalfFatPel;
1596: ptlT.y = pptl->y + global.cyHalfFatPel;
1597: GpiBox(hps, flCmd, &ptlT, 0L, 0L);
1598: }
1599: break;
1600:
1601: case IDC_DIAMOND:
1602: {
1603: POINTL aptlT[4];
1604: ULONG flCmd;
1605:
1606: if (global.fDisplayPelBorder)
1607: flCmd = BA_BOUNDARY;
1608: else
1609: flCmd = 0L;
1610:
1611: aptlT[0].x = pptl->x;
1612: aptlT[0].y = pptl->y - global.cyHalfFatPel;
1613: aptlT[1].x = pptl->x - global.cxHalfFatPel;
1614: aptlT[1].y = pptl->y;
1615: aptlT[2].x = pptl->x;
1616: aptlT[2].y = pptl->y + global.cyHalfFatPel;
1617: aptlT[3].x = pptl->x + global.cxHalfFatPel;
1618: aptlT[3].y = pptl->y;
1619:
1620: GpiSetCurrentPosition(hps, &aptlT[3]);
1621: GpiBeginArea(hps, flCmd);
1622: GpiPolyLine(hps, 4L, aptlT);
1623: GpiEndArea(hps);
1624: }
1625:
1626: break;
1627:
1628: case IDC_CIRCLE:
1629: {
1630: ULONG flCmd;
1631:
1632: if (global.fDisplayPelBorder)
1633: flCmd = DRO_OUTLINEFILL;
1634: else
1635: flCmd = DRO_FILL;
1636:
1637: GpiSetCurrentPosition(hps, pptl);
1638: GpiFullArc(hps, flCmd, 0x10000L);
1639: }
1640: break;
1641: }
1642:
1643:
1644: if (global.fDisplayCrossHairs)
1645: {
1646: /* draw cross in center of pel */
1647:
1648: ptl.x = pptl->x - global.cxHalfFatPel;
1649: ptl.y = pptl->y;
1650: GpiSetCurrentPosition(hps, &ptl);
1651: ptl.x = pptl->x + global.cxHalfFatPel;
1652: GpiPolyLine(hps, 1L, &ptl);
1653:
1654: ptl.x = pptl->x;
1655: ptl.y = pptl->y - global.cyHalfFatPel;
1656: GpiSetCurrentPosition(hps, &ptl);
1657: ptl.y = pptl->y + global.cyHalfFatPel;
1658: GpiPolyLine(hps, 1L, &ptl);
1659: }
1660: }
1661:
1662:
1663:
1664:
1665: /************************************************************************
1666: *
1667: * RoundControlPoints
1668: *
1669: ************************************************************************/
1670:
1671: VOID
1672: RoundControlPoints(hps, cptl, pptl1, pptl2, cx, cy)
1673: HPS hps;
1674: LONG cptl;
1675: PPOINTL pptl1;
1676: PPOINTL pptl2;
1677: LONG cx;
1678: LONG cy;
1679: {
1680: LONG cx2, cy2;
1681: LONG i;
1682: MATRIXLF matlf;
1683:
1684:
1685: /* copy the input buffer to the output/scratch buffer */
1686: for (i = 0; i < cptl; ++i)
1687: pptl2[i] = pptl1[i];
1688:
1689:
1690: /* set the transform, transform the points to device space (i.e. to
1691: * hpsFat dimensions), then restore the original transform
1692: */
1693: GpiQueryModelTransformMatrix(hps, 9L, &matlf);
1694: GpiSetModelTransformMatrix(hps, 9L, &global.matlf, TRANSFORM_REPLACE);
1695: GpiConvert(hps, CVTC_WORLD, CVTC_DEVICE, cptl, pptl2);
1696: GpiSetModelTransformMatrix(hps, 9L, &matlf, TRANSFORM_REPLACE);
1697:
1698:
1699: /* position each point in the center of its fatpel */
1700:
1701: cx2 = cx / 2L;
1702: cy2 = cy / 2L;
1703:
1704: for (i = 0; i < cptl; ++i, ++pptl2)
1705: {
1706: pptl2->x = pptl2->x * cx + cx2;
1707: pptl2->y = pptl2->y * cy + cy2;
1708: }
1709: }
1710:
1711:
1712:
1713:
1714: /************************************************************************
1715: *
1716: * ComputeTransform
1717: *
1718: ************************************************************************/
1719:
1720: VOID
1721: ComputeTransform(prcl1, prcl2)
1722: PRECTL prcl1;
1723: PRECTL prcl2;
1724: {
1725: LONG xExt1, yExt1;
1726: LONG xExt2, yExt2;
1727: FIXED xScale, yScale;
1728:
1729:
1730: xExt1 = prcl1->xRight - prcl1->xLeft;
1731: yExt1 = prcl1->yTop - prcl1->yBottom;
1732: xExt2 = prcl2->xRight - prcl2->xLeft;
1733: yExt2 = prcl2->yTop - prcl2->yBottom;
1734:
1735:
1736: /* If the rectangles are of exactly the same dimensions, then
1737: * set the unity transform. If not, compute the x and y scale
1738: * factors. Note that in world coordinates rectangles are
1739: * inclusive-inclusive, whereas in device coordinates they are
1740: * inclusive-exclusive. The extents of the destination are
1741: * therefore one pel too large as computed, so we subtract one
1742: * in the scale factor computation.
1743: */
1744:
1745: if (xExt1 == xExt2)
1746: xScale = 0x10000L;
1747: else
1748: xScale = ((xExt2-1L) * 0x10000L) / xExt1;
1749:
1750: if (yExt1 == yExt2)
1751: yScale = 0x10000L;
1752: else
1753: yScale = ((yExt2-1L) * 0x10000L) / yExt1;
1754:
1755:
1756: /* store the transform matrix for easy access */
1757:
1758: global.matlf.fxM11 = xScale;
1759: global.matlf.fxM12 = 0L;
1760: global.matlf. lM13 = 0L;
1761: global.matlf.fxM21 = 0L;
1762: global.matlf.fxM22 = yScale;
1763: global.matlf. lM23 = 0L;
1764: global.matlf. lM31 = 0L;
1765: global.matlf. lM32 = 0L;
1766: global.matlf. lM33 = 1L;
1767: }
1768:
1769:
1770:
1771:
1772: /************************************************************************
1773: *
1774: * DrawPrimitive
1775: *
1776: ************************************************************************/
1777:
1778: VOID
1779: DrawPrimitive(hps, cptl, pptl)
1780: HPS hps;
1781: LONG cptl;
1782: PPOINTL pptl;
1783: {
1784: switch (global.usCurPrim)
1785: {
1786: case IDM_NOPRIM:
1787: break;
1788:
1789: case IDM_POLYLINE:
1790: GpiSetCurrentPosition(hps, pptl);
1791: GpiPolyLine(hps, cptl-1L, pptl + 1);
1792: break;
1793:
1794: case IDM_POLYFILLET:
1795: if (cptl >= 3L)
1796: {
1797: GpiSetCurrentPosition(hps, pptl);
1798: GpiPolyFillet(hps, cptl-1L, pptl + 1);
1799: }
1800: break;
1801:
1802: case IDM_POLYSPLINE:
1803: if (cptl >= 4L)
1804: {
1805: LONG cptSlack; /* # points in pptl not usable by PolySpline */
1806:
1807: cptSlack = ((cptl-1L) % 3) + 1;
1808: GpiSetCurrentPosition( hps, pptl );
1809: GpiPolySpline( hps, cptl-cptSlack, pptl+1 );
1810: }
1811: break;
1812:
1813: case IDM_POINTARC:
1814: if (cptl >= 3L)
1815: {
1816: GpiSetCurrentPosition( hps, pptl );
1817: GpiPointArc( hps, pptl+1 );
1818: }
1819: break;
1820: }
1821: }
1822:
1823:
1824:
1825:
1826: /************************************************************************
1827: *
1828: * UpdateSurfaceDims
1829: *
1830: ************************************************************************/
1831:
1832: VOID
1833: UpdateSurfaceDims()
1834: {
1835: SIZEL size;
1836: static BITMAPINFOHEADER2 bminfo;
1837: AREABUNDLE ab;
1838:
1839:
1840: WinQueryWindowRect(global.hwnd, &global.rcl);
1841:
1842: /* compute size of small surface */
1843: global.rclFat.xLeft = 0L;
1844: global.rclFat.yBottom = 0L;
1845: global.rclFat.xRight = global.rcl.xRight / global.cxFatPel;
1846: global.rclFat.yTop = global.rcl.yTop / global.cyFatPel;
1847:
1848: /* compute size of fatpel version of small surface */
1849: global.rcl.xLeft = 0L;
1850: global.rcl.yBottom = 0L;
1851: global.rcl.xRight = global.rclFat.xRight * global.cxFatPel;
1852: global.rcl.yTop = global.rclFat.yTop * global.cyFatPel;
1853:
1854: ComputeTransform(&global.rcl, &global.rclFat);
1855:
1856: if ((global.rclFat.xRight <= global.rclFatBM.xRight) &&
1857: (global.rclFat.yTop <= global.rclFatBM.yTop))
1858: return;
1859:
1860:
1861:
1862: /* The new fatbits surface doesn't fit in the bitmap, so we
1863: * have to make a new one. If we don't have a DC or PS, make
1864: * those before making the bitmap. If we do have a bitmap,
1865: * delete it before making the new one.
1866: */
1867:
1868: global.rclFatBM = global.rclFat;
1869:
1870: if (global.hbmFat)
1871: {
1872: GpiSetBitmap(global.hpsFat, NULL);
1873: GpiDeleteBitmap(global.hbmFat);
1874: GpiSetBitmap(global.hpsFatShadow, NULL);
1875: GpiDeleteBitmap(global.hbmFatShadow);
1876: }
1877:
1878: if (!global.hdcFat)
1879: {
1880: global.hdcFat = DevOpenDC(global.hab, OD_MEMORY, "*", 0L, NULL, NULL);
1881: if (!global.hdcFat)
1882: goto usd_error;
1883:
1884: global.hdcFatShadow = DevOpenDC(global.hab, OD_MEMORY, "*", 0L, NULL, NULL);
1885: if (!global.hdcFatShadow)
1886: goto usd_error;
1887: }
1888:
1889: if (!global.hpsFat)
1890: {
1891: size.cx = 0L;
1892: size.cy = 0L;
1893: global.hpsFat = GpiCreatePS(global.hab, global.hdcFat, &size,
1894: PU_PELS|GPIT_MICRO|GPIA_ASSOC);
1895: if (!global.hpsFat)
1896: goto usd_error;
1897:
1898: global.hpsFatShadow = GpiCreatePS(global.hab, global.hdcFatShadow, &size,
1899: PU_PELS|GPIT_MICRO|GPIA_ASSOC);
1900: if (!global.hpsFatShadow)
1901: goto usd_error;
1902: }
1903:
1904: /* create bitmap with maximum color resolution (24-bit color) */
1905: bminfo.cbFix = sizeof(BITMAPINFOHEADER2);
1906: bminfo.cx = (USHORT) (global.rclFatBM.xRight - global.rclFatBM.xLeft);
1907: bminfo.cy = (USHORT) (global.rclFatBM.yTop - global.rclFatBM.yBottom);
1908: bminfo.cPlanes = 1L;
1909: bminfo.cBitCount = 24L;
1910: global.hbmFat = GpiCreateBitmap(global.hpsFat, &bminfo, 0L, 0L, 0L);
1911: if (!global.hbmFat)
1912: goto usd_error;
1913: GpiSetBitmap(global.hpsFat, global.hbmFat);
1914:
1915: /* create a shadow bitmap of the one we just created */
1916: bminfo.cbFix = sizeof(BITMAPINFOHEADER2);
1917: bminfo.cx = (USHORT) (global.rclFatBM.xRight - global.rclFatBM.xLeft);
1918: bminfo.cy = (USHORT) (global.rclFatBM.yTop - global.rclFatBM.yBottom);
1919: bminfo.cPlanes = 1L;
1920: bminfo.cBitCount = 24L;
1921: global.hbmFatShadow = GpiCreateBitmap(global.hpsFatShadow, &bminfo, 0L, 0L, 0L);
1922: if (!global.hbmFat)
1923: goto usd_error;
1924: GpiSetBitmap(global.hpsFatShadow, global.hbmFatShadow);
1925:
1926: /* clear bitmap surface to field color */
1927: ab.lColor = global.clrField;
1928: GpiSetAttrs(global.hpsFat, PRIM_AREA, ABB_COLOR, 0L, &ab);
1929: GpiBitBlt(global.hpsFat, NULL, 2L, (PPOINTL)&global.rclFat, ROP_PATCOPY, NULL);
1930:
1931: return;
1932:
1933:
1934: /* error exit point */
1935:
1936: usd_error:
1937: if (global.hpsFat)
1938: GpiDestroyPS(global.hpsFat);
1939: if (global.hpsFatShadow)
1940: GpiDestroyPS(global.hpsFatShadow);
1941: if (global.hdcFat)
1942: DevCloseDC(global.hdcFat);
1943: if (global.hdcFatShadow)
1944: DevCloseDC(global.hdcFatShadow);
1945:
1946: global.hpsFat = NULL;
1947: global.hdcFat = NULL;
1948: global.hpsFatShadow = NULL;
1949: global.hdcFatShadow = NULL;
1950: }
1951:
1952:
1953:
1954:
1955: /************************************************************************
1956: *
1957: * AboutDlg
1958: *
1959: * Process messages for the About box.
1960: *
1961: ************************************************************************/
1962:
1963: MRESULT EXPENTRY
1964: AboutDlg(hwnd, usMsg, mp1, mp2)
1965: HWND hwnd;
1966: USHORT usMsg;
1967: MPARAM mp1;
1968: MPARAM mp2;
1969: {
1970: switch (usMsg)
1971: {
1972: case WM_COMMAND:
1973: if (SHORT1FROMMP(mp1) == DID_OK)
1974: WinDismissDlg(hwnd, TRUE);
1975: else
1976: return FALSE;
1977: break;
1978:
1979: default:
1980: return (MRESULT)WinDefDlgProc(hwnd, usMsg, mp1, mp2);
1981: }
1982: return FALSE;
1983: }
1984:
1985:
1986:
1987:
1988: /************************************************************************
1989: *
1990: * PelSizeDlg
1991: *
1992: * Process messages for the Pel Size dialog box.
1993: *
1994: ************************************************************************/
1995:
1996: MRESULT EXPENTRY
1997: PelSizeDlg(hwnd, usMsg, mp1, mp2)
1998: HWND hwnd;
1999: USHORT usMsg;
2000: MPARAM mp1;
2001: MPARAM mp2;
2002: {
2003: BOOL fRet = FALSE;
2004:
2005: switch (usMsg)
2006: {
2007: case WM_INITDLG:
2008: MySetWindowLong(hwnd, IDC_PELWIDTH, global.cxFatPel);
2009: MySetWindowLong(hwnd, IDC_PELHEIGHT, global.cyFatPel);
2010: WinSendDlgItemMsg(hwnd, global.usPelShape,
2011: BM_SETCHECK, (MPARAM)TRUE, 0L);
2012: return FALSE;
2013: break;
2014:
2015: case WM_COMMAND:
2016: switch (SHORT1FROMMP(mp1))
2017: {
2018: case DID_OK:
2019: global.cxFatPel = MyGetWindowLong(hwnd, IDC_PELWIDTH);
2020: global.cyFatPel = MyGetWindowLong(hwnd, IDC_PELHEIGHT);
2021:
2022: if (global.cxFatPel < 1L)
2023: global.cxFatPel = 1L;
2024:
2025: if (global.cyFatPel < 1L)
2026: global.cyFatPel = 1L;
2027:
2028: global.cxHalfFatPel = global.cxFatPel / 2L;
2029: global.cyHalfFatPel = global.cyFatPel / 2L;
2030:
2031: global.usPelShape = (USHORT) WinSendDlgItemMsg(hwnd, IDC_SQUARE,
2032: BM_QUERYCHECKINDEX, 0L, 0L) + IDC_SQUARE;
2033:
2034:
2035: UpdateSurfaceDims();
2036:
2037: fRet = TRUE;
2038:
2039: /* fall through to some common code */
2040:
2041: case DID_CANCEL:
2042: WinDismissDlg(hwnd, fRet);
2043: break;
2044:
2045: default:
2046: return FALSE;
2047: }
2048: break;
2049:
2050: default:
2051: return (MRESULT)WinDefDlgProc(hwnd, usMsg, mp1, mp2);
2052: }
2053: return FALSE;
2054: }
2055:
2056:
2057:
2058:
2059: /************************************************************************
2060: *
2061: * ColorsDlg
2062: *
2063: * Process messages for the Set Colors dialog box.
2064: *
2065: ************************************************************************/
2066:
2067: MRESULT EXPENTRY
2068: ColorsDlg(hwnd, usMsg, mp1, mp2)
2069: HWND hwnd;
2070: USHORT usMsg;
2071: MPARAM mp1;
2072: MPARAM mp2;
2073: {
2074: BOOL fRet = FALSE;
2075: BOOL fRGB;
2076: COLOR clrMathObj;
2077: COLOR clrRenderedObj;
2078: COLOR clrField;
2079: COLOR clrCrossHair;
2080: COLOR clrInterstice;
2081: COLOR clrControlPoints;
2082:
2083: switch (usMsg)
2084: {
2085: case WM_INITDLG:
2086: if (global.fRGB)
2087: {
2088: MySetWindowLongHex(hwnd, IDC_MATHOBJ, global.clrMathObj);
2089: MySetWindowLongHex(hwnd, IDC_RENDEREDOBJ, global.clrRenderedObj);
2090: MySetWindowLongHex(hwnd, IDC_FIELD, global.clrField);
2091: MySetWindowLongHex(hwnd, IDC_CROSSHAIRS, global.clrCrossHair);
2092: MySetWindowLongHex(hwnd, IDC_INTERSTICE, global.clrInterstice);
2093: MySetWindowLongHex(hwnd, IDC_CTLPOINTS, global.clrControlPoints);
2094: }
2095: else
2096: {
2097: MySetWindowLong (hwnd, IDC_MATHOBJ, global.clrMathObj);
2098: MySetWindowLong (hwnd, IDC_RENDEREDOBJ, global.clrRenderedObj);
2099: MySetWindowLong (hwnd, IDC_FIELD, global.clrField);
2100: MySetWindowLong (hwnd, IDC_CROSSHAIRS, global.clrCrossHair);
2101: MySetWindowLong (hwnd, IDC_INTERSTICE, global.clrInterstice);
2102: MySetWindowLong (hwnd, IDC_CTLPOINTS, global.clrControlPoints);
2103: }
2104: WinSendDlgItemMsg(hwnd, IDC_RGB, BM_SETCHECK, MPFROM2SHORT(global.fRGB,0), 0L);
2105: return FALSE;
2106: break;
2107:
2108: case WM_CONTROL:
2109: if ((SHORT1FROMMP(mp1) == IDC_RGB) && (SHORT2FROMMP(mp1)== BN_CLICKED))
2110: {
2111: fRGB = !(SHORT)WinSendDlgItemMsg(hwnd, IDC_RGB, BM_QUERYCHECK, 0L, 0L);
2112: WinSendDlgItemMsg(hwnd, IDC_RGB, BM_SETCHECK, MPFROM2SHORT(fRGB,0), 0L);
2113:
2114: clrMathObj = MyGetWindowLong(hwnd, IDC_MATHOBJ);
2115: clrRenderedObj = MyGetWindowLong(hwnd, IDC_RENDEREDOBJ);
2116: clrField = MyGetWindowLong(hwnd, IDC_FIELD);
2117: clrCrossHair = MyGetWindowLong(hwnd, IDC_CROSSHAIRS);
2118: clrInterstice = MyGetWindowLong(hwnd, IDC_INTERSTICE);
2119: clrControlPoints = MyGetWindowLong(hwnd, IDC_CTLPOINTS);
2120:
2121: if (fRGB)
2122: {
2123: HPS hps;
2124:
2125: /* for each color, get rgb value from index */
2126:
2127: hps = WinGetPS(hwnd);
2128:
2129: clrMathObj = GpiQueryRGBColor(hps, 0L, clrMathObj);
2130: clrRenderedObj = GpiQueryRGBColor(hps, 0L, clrRenderedObj);
2131: clrField = GpiQueryRGBColor(hps, 0L, clrField);
2132: clrCrossHair = GpiQueryRGBColor(hps, 0L, clrCrossHair);
2133: clrInterstice = GpiQueryRGBColor(hps, 0L, clrInterstice);
2134: clrControlPoints = GpiQueryRGBColor(hps, 0L, clrControlPoints);
2135:
2136: WinReleasePS(hps);
2137:
2138: MySetWindowLongHex(hwnd, IDC_MATHOBJ, clrMathObj);
2139: MySetWindowLongHex(hwnd, IDC_RENDEREDOBJ, clrRenderedObj);
2140: MySetWindowLongHex(hwnd, IDC_FIELD, clrField);
2141: MySetWindowLongHex(hwnd, IDC_CROSSHAIRS, clrCrossHair);
2142: MySetWindowLongHex(hwnd, IDC_INTERSTICE, clrInterstice);
2143: MySetWindowLongHex(hwnd, IDC_CTLPOINTS, clrControlPoints);
2144: }
2145: else
2146: {
2147: HPS hps;
2148:
2149: /* for each color, get nearest index value from rgb */
2150:
2151: hps = WinGetPS(hwnd);
2152:
2153: clrMathObj = GpiQueryColorIndex(hps, 0L, clrMathObj);
2154: clrRenderedObj = GpiQueryColorIndex(hps, 0L, clrRenderedObj);
2155: clrField = GpiQueryColorIndex(hps, 0L, clrField);
2156: clrCrossHair = GpiQueryColorIndex(hps, 0L, clrCrossHair);
2157: clrInterstice = GpiQueryColorIndex(hps, 0L, clrInterstice);
2158: clrControlPoints = GpiQueryColorIndex(hps, 0L, clrControlPoints);
2159:
2160: WinReleasePS(hps);
2161:
2162: MySetWindowLong (hwnd, IDC_MATHOBJ, clrMathObj);
2163: MySetWindowLong (hwnd, IDC_RENDEREDOBJ, clrRenderedObj);
2164: MySetWindowLong (hwnd, IDC_FIELD, clrField);
2165: MySetWindowLong (hwnd, IDC_CROSSHAIRS, clrCrossHair);
2166: MySetWindowLong (hwnd, IDC_INTERSTICE, clrInterstice);
2167: MySetWindowLong (hwnd, IDC_CTLPOINTS, clrControlPoints);
2168: }
2169: }
2170: return (MRESULT)WinDefDlgProc(hwnd, usMsg, mp1, mp2);
2171: break;
2172:
2173: case WM_COMMAND:
2174: switch (SHORT1FROMMP(mp1))
2175: {
2176: case DID_OK:
2177: global.clrMathObj = MyGetWindowLong(hwnd, IDC_MATHOBJ);
2178: global.clrRenderedObj = MyGetWindowLong(hwnd, IDC_RENDEREDOBJ);
2179: global.clrField = MyGetWindowLong(hwnd, IDC_FIELD);
2180: global.clrCrossHair = MyGetWindowLong(hwnd, IDC_CROSSHAIRS);
2181: global.clrInterstice = MyGetWindowLong(hwnd, IDC_INTERSTICE);
2182: global.clrControlPoints = MyGetWindowLong(hwnd, IDC_CTLPOINTS);
2183:
2184: global.fRGB = (SHORT)WinSendDlgItemMsg(hwnd, IDC_RGB, BM_QUERYCHECK, 0L, 0L);
2185:
2186: fRet = TRUE;
2187:
2188: /* fall through to some common code */
2189:
2190: case DID_CANCEL:
2191: WinDismissDlg(hwnd, fRet);
2192: break;
2193:
2194: default:
2195: return FALSE;
2196: }
2197: break;
2198:
2199: default:
2200: return (MRESULT)WinDefDlgProc(hwnd, usMsg, mp1, mp2);
2201: }
2202: return FALSE;
2203: }
2204:
2205:
2206:
2207:
2208: /************************************************************************
2209: *
2210: * MySetWindowLong
2211: *
2212: * Sets the given control id to the value specified.
2213: *
2214: ************************************************************************/
2215:
2216: VOID
2217: MySetWindowLong(hWnd, id, num)
2218: HWND hWnd;
2219: USHORT id;
2220: LONG num;
2221: {
2222: char szStr[CCHSTR];
2223:
2224: sprintf((NPCH)szStr, "%ld", num);
2225: WinSetWindowText(WinWindowFromID(hWnd, id), (PCH)szStr);
2226: }
2227:
2228:
2229:
2230:
2231: /************************************************************************
2232: *
2233: * MySetWindowLongHex
2234: *
2235: * Sets the given control id to the value specified, in hexadecimal
2236: * notation.
2237: *
2238: ************************************************************************/
2239:
2240: VOID
2241: MySetWindowLongHex(hWnd, id, num)
2242: HWND hWnd;
2243: USHORT id;
2244: LONG num;
2245: {
2246: char szStr[CCHSTR];
2247:
2248: sprintf((NPCH)szStr, "0x%06lX", num);
2249: WinSetWindowText(WinWindowFromID(hWnd, id), (PCH)szStr);
2250: }
2251:
2252:
2253:
2254:
2255: /************************************************************************
2256: *
2257: * MyGetWindowLong
2258: *
2259: * Returns the value from the given control id.
2260: *
2261: ************************************************************************/
2262:
2263: LONG
2264: MyGetWindowLong(hWnd, id)
2265: HWND hWnd;
2266: USHORT id;
2267: {
2268: char szStr[CCHSTR];
2269: LONG num;
2270:
2271: WinQueryWindowText(WinWindowFromID(hWnd, id), CCHSTR, (PCH)szStr);
2272:
2273: if (strchr(szStr, 'x'))
2274: sscanf((NPCH)szStr, "0x%lx", &num);
2275: else if (strchr(szStr, 'X'))
2276: sscanf((NPCH)szStr, "0X%lx", &num);
2277: else
2278: sscanf((NPCH)szStr, "%ld", &num);
2279:
2280: return num;
2281: }
2282:
2283:
2284:
2285:
2286: /************************************************************************
2287: *
2288: * SaveWindowToFile
2289: *
2290: * Copy the bits from the client rectangle (actually, just the fatpel
2291: * area) into a bitmap, then save that bitmap.
2292: *
2293: ************************************************************************/
2294:
2295: VOID
2296: SaveWindowToFile(hwnd)
2297: HWND hwnd;
2298: {
2299: static BITMAPINFOHEADER2 bminfo;
2300: HBITMAP hbm;
2301: HPS hps;
2302: POINTL aptl[3];
2303:
2304: /* create bitmap in display's favorite format */
2305: bminfo.cbFix = sizeof(BITMAPINFOHEADER2);
2306: bminfo.cx = (USHORT) (global.rcl.xRight - global.rcl.xLeft);
2307: bminfo.cy = (USHORT) (global.rcl.yTop - global.rcl.yBottom);
2308: bminfo.cPlanes = 0L;
2309: bminfo.cBitCount = 0L;
2310: if (hbm = GpiCreateBitmap(global.hpsFat, &bminfo, 0L, 0L, 0L))
2311: {
2312: /* select it into the small bitmap's PS */
2313: GpiSetBitmap(global.hpsFat, hbm);
2314:
2315: /* GpiBitBlt from the window to the bitmap */
2316: hps = WinGetPS(hwnd);
2317:
2318: *((PRECTL)&aptl[0]) = global.rcl;
2319: aptl[2].x = 0L;
2320: aptl[2].y = 0L;
2321: GpiBitBlt(global.hpsFat, hps, 3L, aptl, ROP_SRCCOPY, 0L);
2322:
2323: WinReleasePS(hps);
2324:
2325: /* save the bitmap */
2326: WriteFile(hwnd, global.hpsFat);
2327: }
2328:
2329: /* deselect the bitmap and delete it */
2330: GpiSetBitmap(global.hpsFat, global.hbmFat);
2331: if (hbm)
2332: GpiDeleteBitmap(hbm);
2333: }
2334:
2335:
2336:
2337:
2338: /************************************************************************
2339: *
2340: * WriteFile
2341: *
2342: * Calls the OpenDlg's DlgFile function to ask the user what file name to
2343: * save under.
2344: *
2345: ************************************************************************/
2346:
2347: VOID
2348: WriteFile(hwnd, hps)
2349: HWND hwnd;
2350: HPS hps;
2351: {
2352: HFILE hfile;
2353: DLF dlf;
2354: BITMAPINFOHEADER2 bmih;
2355:
2356: dlf.rgbAction = DLG_SAVEDLG;
2357: dlf.rgbFlags = 0;
2358: dlf.phFile = &hfile;
2359: dlf.pszExt = "";
2360: dlf.pszAppName = "FatPel";
2361: dlf.pszInstructions = NULL;
2362: dlf.szFileName[0] = '\0';
2363: dlf.szOpenFile[0] = '\0';
2364: dlf.pszTitle = "Save Bitmap";
2365:
2366:
2367: switch (DlgFile(hwnd,&dlf))
2368: {
2369: case TDF_ERRMEM:
2370: case TDF_INVALID:
2371: MyMessageBox(hwnd, "Error opening file.");
2372: break;
2373:
2374: case TDF_NOSAVE:
2375: break;
2376:
2377: default:
2378: bmih.cbFix = sizeof(BITMAPINFOHEADER2);
2379: bmih.cx = (USHORT) global.rcl.xRight;
2380: bmih.cy = (USHORT) global.rcl.yTop;
2381: bmih.cPlanes = 0L;
2382: bmih.cBitCount = 0L;
2383:
2384: if (!WriteBMP(hfile, hps, &bmih))
2385: MyMessageBox(hwnd, "Error writing file.");
2386: }
2387: }
2388:
2389:
2390:
2391:
2392: /************************************************************************
2393: *
2394: * WriteBMP
2395: *
2396: * Write the bitmap out to a BMP format file. Write the file
2397: * header first, then the bitmap bits. Space for the header
2398: * and the bits is allocated. The file
2399: * will have been opened by the time this function is called,
2400: * and the file handle will be in the *pdlf structure.
2401: *
2402: ************************************************************************/
2403:
2404: BOOL
2405: WriteBMP(hfile, hps, pbmih)
2406: HFILE hfile;
2407: HPS hps; /* hps from which to get bitmap bits. */
2408: PBITMAPINFOHEADER2 pbmih; /* Bitmap information. */
2409: {
2410: ULONG cScans;
2411: ULONG ulSize; /* Number of bytes occupied by bitmap bits. */
2412: ULONG cbBMHdr; /* Size of bitmap header. */
2413: PBITMAPFILEHEADER2 pbfh; /* Pointer to private copy of bitmap info data. */
2414: ULONG cbWritten; /* Number of bytes written by DosWrite. */
2415: BOOL fRet = FALSE; /* Function return code. */
2416: PVOID pBits;
2417: int i; /* Generic loop index. */
2418: struct
2419: {
2420: LONG cPlanes;
2421: LONG cBitCount;
2422: } bmFmt;
2423:
2424:
2425: /*******************************************************************
2426: * If the bitmap was created with either 0 planes or 0 bits per
2427: * pixel, then query the format to write with. By asking for just
2428: * one format (two LONGs, or one instance of structure of bmFmt),
2429: * we'll get the device's favored format.
2430: *******************************************************************/
2431:
2432: if ((pbmih->cPlanes == 0) || (pbmih->cBitCount == 0))
2433: {
2434: if (!GpiQueryDeviceBitmapFormats(hps, 2L, (PLONG)&bmFmt))
2435: goto lfwrite_error_close_file;
2436: }
2437: else
2438: {
2439: bmFmt.cPlanes = pbmih->cPlanes;
2440: bmFmt.cBitCount = pbmih->cBitCount;
2441: }
2442:
2443:
2444: /*******************************************************************
2445: * Determine size of bitmap header. The header consists of a
2446: * a fixed-size part and a variable-length color table. The
2447: * latter has 2^cBitCount entries, each of which is sizeof(RGB)
2448: * bytes long. The exception is when cBitCount is 24, in which
2449: * case the color table is omitted because the pixels are direct
2450: * rgb values.
2451: *******************************************************************/
2452:
2453: i = (int) bmFmt.cBitCount;
2454: if (i == 24)
2455: cbBMHdr = 0;
2456: else
2457: for (cbBMHdr = sizeof(RGB); i > 0; --i)
2458: cbBMHdr *= 2;
2459: cbBMHdr += sizeof(BITMAPFILEHEADER);
2460:
2461:
2462: /*******************************************************************
2463: * Copy structure from input to work buffer. The call to
2464: * GpiQueryBitmapBits will have write-access to this, so we won't
2465: * let it have the user's data.
2466: *******************************************************************/
2467:
2468: pbfh = NULL;
2469: if (DosAllocMem((PPVOID)&pbfh, cbBMHdr, fPERM|PAG_COMMIT))
2470: goto lfwrite_error_close_file;
2471: pbfh->bmp2 = *pbmih;
2472: if ((pbmih->cPlanes == 0) || (pbmih->cBitCount))
2473: {
2474: pbfh->bmp2.cPlanes = (USHORT) bmFmt.cPlanes;
2475: pbfh->bmp2.cBitCount = (USHORT) bmFmt.cBitCount;
2476: }
2477:
2478:
2479: /*******************************************************************
2480: * Allocate space for the bitmap bits -- all of them at once.
2481: * The extra ULONG casts are there to force all the arithmetic
2482: * to be done in 32 bits.
2483: *******************************************************************/
2484:
2485: ulSize = (
2486: (
2487: (
2488: (ULONG)pbfh->bmp2.cBitCount
2489: * (ULONG)pbfh->bmp2.cx
2490: + 31L
2491: ) / 32L
2492: ) * (ULONG)pbfh->bmp2.cPlanes * 4L
2493: ) * (ULONG)pbfh->bmp2.cy;
2494:
2495: if (DosAllocMem((PPVOID)&pBits, ulSize, fPERM|PAG_COMMIT))
2496: goto lfwrite_error_free_header;
2497:
2498:
2499: /*******************************************************************
2500: * Tell GPI to give us the bits. The function returns the number
2501: * of scan lines of the bitmap that were copied. We want all of
2502: * them at once.
2503: *******************************************************************/
2504:
2505: cScans = GpiQueryBitmapBits( hps
2506: , 0L
2507: , (ULONG)pbfh->bmp2.cy
2508: , (PBYTE)pBits
2509: , (PBITMAPINFO2)&pbfh->bmp2);
2510: if (cScans != pbfh->bmp2.cy) /* compare with original number of scans */
2511: goto lfwrite_error_free_bits;
2512:
2513:
2514: /*******************************************************************
2515: * Fill in the extra header fields and write the header out to
2516: * the file.
2517: *******************************************************************/
2518:
2519: pbfh->usType = BFT_BMAP;
2520: pbfh->cbSize = ulSize + cbBMHdr;
2521: pbfh->xHotspot = pbfh->bmp2.cx / 2;
2522: pbfh->yHotspot = pbfh->bmp2.cy / 2;
2523: pbfh->offBits = cbBMHdr;
2524:
2525: if (DosWrite( hfile, (PVOID)pbfh, cbBMHdr, &cbWritten))
2526: goto lfwrite_error_free_bits;
2527: if (cbWritten != cbBMHdr)
2528: goto lfwrite_error_free_bits;
2529:
2530:
2531: /*******************************************************************
2532: * Write the bits out to the file.
2533: *******************************************************************/
2534:
2535: if (DosWrite( hfile, (PVOID)pBits, ulSize, &cbWritten))
2536: goto lfwrite_error_free_bits;
2537: if (cbWritten != ulSize)
2538: goto lfwrite_error_free_bits;
2539:
2540: fRet = TRUE; /* The bits are on the disk. */
2541:
2542:
2543: /*******************************************************************
2544: * Close the file, free the buffer space and leave. This is a
2545: * common exit point from the function. Since the same cleanup
2546: * operations need to be performed for such a large number of
2547: * possible error conditions, this is concise way to do the right
2548: * thing.
2549: *******************************************************************/
2550:
2551: lfwrite_error_free_bits:
2552: DosFreeMem(pBits);
2553: lfwrite_error_free_header:
2554: DosFreeMem(&pbfh);
2555: lfwrite_error_close_file:
2556: DosClose(hfile);
2557: return fRet;
2558: }
2559:
2560:
2561:
2562:
2563: /************************************************************************
2564: *
2565: * MyMessageBox
2566: *
2567: * Displays a message box with the given string. To simplify matters,
2568: * the box will always have the same title ("FatPel"), will always
2569: * have a single button ("Ok"), will always have an exclamation point
2570: * icon, and will always be application modal.
2571: *
2572: ************************************************************************/
2573:
2574: VOID
2575: MyMessageBox(hWnd, sz)
2576: HWND hWnd;
2577: PSZ sz;
2578: {
2579: static char *szTitle = "FatPel Application";
2580:
2581: WinMessageBox(HWND_DESKTOP, hWnd, sz, szTitle, NULL,
2582: MB_OK|MB_ICONEXCLAMATION|MB_APPLMODAL);
2583: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.