![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to lfdraw.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [OS/2 SDKs] / pmsdk / samples / linefrac|
Return to lfdraw.c CVS log | Up to [OS/2 SDKs] / pmsdk / samples / linefrac |
1.1 root 1:
2: /************************************************************************
3: *
4: * lfdraw.c
5: *
6: * Created by Microsoft Corp., 1988
7: *
8: * This file contains the functions that handle drawing of a "line
9: * fractal".
10: *
11: * The fractal always starts out showing one application of the
12: * similarity transform to the unit interval, centered in the window.
13: * Clicking on the left mouse button causes the fractal to recurse
14: * deeper; on the right button, shallower.
15: *
16: * Ideas for the future:
17: * ---------------------
18: *
19: * 1) Add a help screen to explain how to use it.
20: * 2) Allow the user to create or edit a similarity transform.
21: * 3) Allow setting of line attributes per segment of transform.
22: * 4) Save transform to disk and read back, so user can remember the
23: * good ones (and justify the program!).
24: * 5) Display the level of recursion in a corner of the window.
25: *
26: *
27: *
28: * Background fractal drawing scheme:
29: *
30: * To enable the user to interact with the system during
31: * the drawing of a complicated fractal, the fractal is
32: * drawn into a bitmap by a background thread. This thread
33: * is started at the first WM_PAINT message received by the
34: * application, and never terminates.
35: *
36: * The thread's execution is controlled by a semaphore,
37: * lSemAccumulateFractal. The thread is initially blocked
38: * by its semaphore. When something changes in the environ-
39: * ment such that the fractal is to be redrawn, or drawn for
40: * the first time, the semaphore is cleared and the thread
41: * is off and running. Note that the environment must be
42: * set up BEFORE the semaphore is cleared, otherwise the
43: * fractal may be partially drawn with old parameters.
44: * The thread automatically resets the semaphore, so that
45: * as soon as it's done drawing, it has to wait for the signal
46: * to start again.
47: *
48: * The fractal is drawn in batches of 500 points per polyline.
49: * After each polyline is drawn, the background thread invalidates
50: * the main client rectangle to force a WM_PAINT message to be sent.
51: * All the paint procedure does is copy the bitmap, whatever
52: * it's current state, to the screen. The user therefore
53: * sees bursts of 500 points at a time as his fractal is drawn.
54: *
55: * The semaphore is controlled, in greater detail, as follows:
56: *
57: * Disable background drawing (set semaphore):
58: *
59: * LineFracInit
60: * Don't let second thread start working until a
61: * transform has been defined.
62: *
63: * AccumulateLineFractal
64: * Don't start the next one until the user asks for it.
65: *
66: * Enable background drawing (clear semaphore):
67: *
68: * WM_BUTTON1UP
69: * WM_BUTTON2UP
70: * WM_SIZE & fAutoScale
71: * The level of recursion or dimensions of bitmap have
72: * changed, so redraw the fractal.
73: *
74: * Change of transform
75: * The similarity transform has changed, so draw the
76: * new fractal with the current environment.
77: *
78: *
79: * Event AccumulateLineFractal
80: * ----- ---------------------
81: *
82: * WM_BUTTON1UP --------<--------
83: * WM_BUTTON2UP / \
84: * WM_SIZE & fAutoScale | |
85: * Change of transform | |
86: * | | |
87: * | V |
88: * +---------clear--------------> +----------------------+ |
89: * | lSemAccumulateFracal | |
90: * +----------set---------------> +----------------------+ |
91: * | | |
92: * | if semaphore is clear ^
93: * initialization | |
94: * done with current fractal V |
95: * +----------------------+ |
96: * | Draw fractal | |
97: * WM_PAINT <---- | into bitmap | |
98: * +----------------------+ |
99: * | |
100: * | |
101: * \ /
102: * -------->--------
103: *
104: ************************************************************************/
105:
106: #define INCL_WIN
107: #define INCL_GPI
108: #define INCL_DOSSEMAPHORES
109:
110: #include <os2.h>
111: #include <math.h>
112: #include "linefrac.h"
113:
114:
115:
116:
117: /************************************************************************
118: *
119: * Function prototypes.
120: *
121: * These add some error checking to function calls, and prevent
122: * forward references to functions of undefined return type.
123: *
124: ************************************************************************/
125:
126: VOID LineFractal(int, double, double, BOOL, PLINEFRAC);
127: VOID AddFractalPoint(double, double);
128: VOID LineFracDraw(void);
129:
130:
131:
132:
133: /************************************************************************
134: *
135: * Global Data
136: *
137: *
138: * These variables reduce the number of parameters passed to
139: * the recursive fractal drawing function, or to the various
140: * functions called by the window procedure.
141: *
142: *
143: * hwndLineFrac Window handle for the client area.
144: * LineFracRc The dimensions of the bitmap (drawing surface).
145: * LineFracPS The Presentation Space for drawing fractal.
146: * LineFracXform Points to currently selected similarity transform.
147: * usRecursion Number of levels of recursion in drawing.
148: * usPolygonSides Number of sides to the polygonal frame of "unit
149: * intervals". The fractal transformation is
150: * applied to each line segment of the frame.
151: *
152: * ptPolyLine Array for accumulating points for PolyLine.
153: * cptPoly The number of points in ptPolyLine.
154: * x, y Current position, i.e. the endpoint of the
155: * last line segment drawn/accumulated.
156: * lSemAccumulateFractal
157: * Semaphore controlling the background thread which
158: * accumulates points of fractal. Clear it to
159: * start new fractal.
160: * fInterrupted Indicates drawing should be aborted.
161: * fClearBetween Indicates that the drawing surface should be
162: * cleared to the background color before starting.
163: *
164: * xscale These transform each point accumulated, so
165: * yscale that the drawing fits into the window,
166: * xoff with the original unit interval at the center.
167: * yoff
168: *
169: * lColorBack Background color for the drawing.
170: * lColor Line foreground color.
171: * usStyle Line style.
172: * usMixMode Line foreground mix mode.
173: *
174: ************************************************************************/
175:
176: extern HWND hwndLineFrac;
177: extern RECTL LineFracRc;
178: extern HPS LineFracPS;
179: extern PLINEFRAC LineFracXform;
180: extern USHORT usRecursion;
181: extern USHORT usPolygonSides;
182:
183: POINTL ptPolyLine[MAX_POINT_COUNT];
184: ULONG cptPoly = 0L;
185: extern USHORT cptMax;
186: double x, y;
187:
188: extern LONG lSemAccumulateFractal;
189: extern BOOL fInterrupted;
190: extern BOOL fClearBetween;
191:
192: extern double xscale;
193: extern double yscale;
194: extern double xoff;
195: extern double yoff;
196:
197: extern LONG lColorBack;
198: extern LONG lColor;
199: extern USHORT usStyle;
200: extern USHORT usMixMode;
201:
202:
203:
204:
205: /************************************************************************
206: *
207: * AccumulateLineFractal
208: *
209: * Organize the drawing of the fractal. Runs in an independent
210: * thread to accumulate the points of the fractal, then calls
211: * GpiPolyLine to draw into a bitmap. Each time a line is drawn
212: * (in batches of some appropriate number of points) the client
213: * rectangle of the application window is invalidated to cause a
214: * WM_PAINT message. When the paint message is processed, the
215: * bitmap will be copied to the display.
216: *
217: * This thread never terminates. It is blocked by the semaphore
218: * lSemAccumulateFractal when there is no work to be done.
219: *
220: ************************************************************************/
221:
222: VOID FAR PASCAL
223: AccumulateLineFractal()
224: {
225: double initlength;
226: double initangle;
227: double angledecr;
228: int i;
229:
230:
231: WinInitialize(NULL); /* initialize ring 2 stack for thread */
232:
233: while (1)
234: {
235: DosSemRequest(&lSemAccumulateFractal, -1L);
236:
237:
238: /* Initialize the fractal to the unit interval, with nothing
239: * in the point accumulation buffer.
240: */
241:
242: fInterrupted = FALSE;
243:
244: x = 0.0;
245: y = 0.0;
246:
247: if (usPolygonSides == 1)
248: {
249: initlength = 1.0;
250: initangle = 0.0;
251: angledecr = 0.0;
252: }
253: else
254: {
255: initlength = sin(PI / usPolygonSides);
256: initangle = (PI * (usPolygonSides - 2)) / (2 * usPolygonSides);
257: angledecr = 2 * PI / usPolygonSides;
258: }
259:
260:
261: /* Clear the client rectangle to background color. */
262: if (fClearBetween)
263: WinFillRect(LineFracPS, &LineFracRc, lColorBack);
264:
265:
266: for (i = 0; i < usPolygonSides; ++i)
267: {
268:
269: /* Anchor the fractal at the left endpoint of the unit interval,
270: * then draw it to the specified depth of recursion. If the point
271: * buffer is not empty afterwards, draw the last PolyLine.
272: */
273:
274: cptPoly = 0L;
275: AddFractalPoint(x, y);
276: LineFractal(usRecursion, initlength, initangle, FALSE, LineFracXform);
277:
278: if (fInterrupted)
279: break;
280:
281: if (cptPoly > 1)
282: LineFracDraw();
283:
284: initangle -= angledecr;
285: }
286: }
287: }
288:
289:
290:
291:
292: /************************************************************************
293: *
294: * LineFractal
295: *
296: * Draw fractal with the given similarity transform.
297: *
298: * The general idea is to define a transformation to apply to the
299: * unit line segment, to get a new polyline. This same transformation
300: * is then applied to each line segment of the new polyline. The number
301: * of successive applications of the similarity transform is set by the
302: * user. It's known as the level of recursion of the fractal.
303: *
304: * Since this is where the point accumulation process will usually
305: * be, it recognizes the flag fInterrupted to allow the current
306: * work to be abandoned.
307: *
308: ************************************************************************/
309:
310: VOID
311: LineFractal(depth, len, ang, flip, xform)
312: int depth;
313: double len;
314: double ang;
315: BOOL flip;
316: PLINEFRAC xform;
317: {
318: double newlen;
319: PLINEFRAC newseg;
320:
321:
322: if (fInterrupted)
323: return;
324:
325: if (depth)
326: {
327: /*
328: * We have not reached the maximum depth of recursion yet,
329: * so apply the similarity transform to the current line
330: * segment.
331: */
332:
333: --depth;
334: newseg = xform;
335: do
336: {
337: newlen = len * newseg->length;
338: ang += newseg->angle * (flip ? -1 : 1);
339: LineFractal(depth, newlen, ang, flip ^ newseg->flip, xform);
340: } while ((newseg = newseg->next) != EOLIST);
341: }
342: else
343: {
344: /*
345: * We have reached the maximum depth of recursion, so
346: * draw a line segment.
347: */
348:
349: x += len * cos(ang);
350: y += len * sin(ang);
351: AddFractalPoint(x, y);
352:
353: if (cptPoly >= (ULONG)cptMax)
354: {
355: LineFracDraw();
356: ptPolyLine[0] = ptPolyLine[cptPoly-1];
357: cptPoly = 1L;
358: }
359: }
360: }
361:
362:
363:
364:
365: /************************************************************************
366: *
367: * AddFractalPoint
368: *
369: * Applies the global coordinate transform to the point (x, y), then
370: * stuffs it into the global PolyLine point array, and increments the
371: * counts of points in the array.
372: *
373: ************************************************************************/
374:
375: void
376: AddFractalPoint(x, y)
377: double x,y;
378: {
379: ptPolyLine[cptPoly].x = (int)(x * xscale + xoff + 0.5);
380: ptPolyLine[cptPoly].y = (int)(y * yscale + yoff + 0.5);
381: ++cptPoly;
382: }
383:
384:
385:
386:
387: /************************************************************************
388: *
389: * LineFracDraw
390: *
391: * Set line attributes and draw a batch of lines. Invalidate the client
392: * rectangle of the main window to cause our latest bitmap to be
393: * copied there.
394: *
395: ************************************************************************/
396:
397: VOID
398: LineFracDraw()
399: {
400: LINEBUNDLE lb;
401:
402: lb.lColor = lColor;
403: lb.usMixMode = usMixMode;
404: lb.usType = usStyle;
405: GpiSetAttrs(LineFracPS, PRIM_LINE, LBB_COLOR|LBB_MIX_MODE|LBB_TYPE,
406: 0L, (PBUNDLE)&lb);
407: GpiSetCurrentPosition( LineFracPS, (PPOINTL)ptPolyLine );
408: GpiPolyLine( LineFracPS, cptPoly-1, (PPOINTL)&ptPolyLine[1] );
409: WinInvalidateRect(hwndLineFrac, &LineFracRc, FALSE);
410: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.