![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to lfmsg.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 lfmsg.c CVS log | Up to [OS/2 SDKs] / pmsdk / samples / linefrac |
1.1 root 1: /************************************************************************
2: *
3: * lfmsg.c
4: *
5: * Message handling subroutines for the LineFractal window class.
6: *
7: * Created by Microsoft Corp., 1988
8: ************************************************************************/
9:
10: #define INCL_WIN
11: #define INCL_GPI
12: #define INCL_DOSPROCESS
13: #define INCL_DOSSEMAPHORES
14: #include <os2.h>
15:
16: #include <stdio.h>
17: #include <stdlib.h>
18: #include <math.h>
19: #include "linefrac.h"
20:
21:
22:
23:
24: /************************************************************************
25: *
26: * Function prototypes.
27: *
28: * These add some error checking to function calls, and prevent
29: * forward references to functions of undefined return type.
30: *
31: ************************************************************************/
32:
33: VOID MySetWindowUShort(HWND, USHORT, USHORT);
34: VOID MySetWindowLong(HWND, USHORT, LONG);
35: USHORT MyGetWindowUShort(HWND, USHORT);
36: LONG MyGetWindowLong(HWND, USHORT);
37:
38:
39:
40:
41: /************************************************************************
42: *
43: * Global Variables
44: *
45: *
46: * hAB Anchor block handle. Needed only for some obscure mainframe
47: * compatability issue.
48: * hwndLineFrac
49: * Our main window handle.
50: * hwndLineFracFrame
51: * The handle to our window frame (to get at menus, etc.).
52: *
53: * LineFracPS Presentation Space for the background accumulation thread.
54: * LineFracRc Holds the dimensions of the bitmap we draw into.
55: * LineFracBM Handle to our bitmap. Needed only during creation and
56: * destruction.
57: * LineFracDC Handle to the DC we've selected our bitmap into. Needed
58: * only during creation and destruction.
59: * fHaveBitmap TRUE ==> a bitmap was successfully created for the second
60: * thread to draw into.
61: * fHaveAccumThread
62: * TRUE ==> the point accumulation thread was successfully
63: * created.
64: *
65: * tidAccumFrac
66: * Thread ID for the point accumulation thread.
67: * abAccumStack
68: * Stack for the ...
69: *
70: * usCurrentXform
71: * The menu command id of the currently selected transform.
72: * LineFracXform
73: * The current similarity transform used when drawing.
74: * usRecursion The currently selected depth of recursion.
75: * usPolygonSides
76: * Number of sides to the polygonal frame of "unit
77: * intervals". The fractal transformation is
78: * applied to each line segment of the frame.
79: *
80: * lSemAccumulateFractal
81: * Semaphore controlling the point accumulation thread.
82: * Clear it to start another fractal.
83: * fInterrupted
84: * TRUE ==> abort current fractal.
85: * fClearBetween
86: * TRUE ==> clear drawing surface (bitmap) between fractals.
87: * fAutoScale TRUE ==> resize our bitmap to match the client rectangle.
88: *
89: * xscale These transform each point accumulated, so
90: * yscale that the drawing fits into the window,
91: * xoff with the original unit interval at the center.
92: * yoff
93: *
94: * lColorBack Background color for fractal.
95: * lColor Line foreground color.
96: * usStyle Line style.
97: * usMixMode Line foreground mix mode.
98: *
99: * XformFuncs Array of built-in transform-defining functions.
100: *
101: ************************************************************************/
102:
103: #define CCHSTR 12 /* work buffer size for MyGetWindowLong, etc */
104:
105: HAB hAB;
106: HWND hwndLineFrac;
107: HWND hwndLineFracFrame;
108:
109: HPS LineFracPS = NULL;
110: RECTL LineFracRc = { 0L, 0L, 0L, 0L };
111: HBITMAP LineFracBM = NULL;
112: HDC LineFracDC = NULL;
113: BOOL fHaveBitmap = FALSE;
114: BOOL fHaveAccumThread = FALSE;
115:
116: #define SIZE_ACCUM_STACK 2048
117: TID tidAccumFrac;
118: CHAR abAccumStack[SIZE_ACCUM_STACK];
119:
120: USHORT usCurrentXform = IDMSAWTOOTH;
121: PLINEFRAC LineFracXform = NULL;
122: USHORT usRecursion = 1;
123: USHORT usPolygonSides = 3;
124: USHORT cptMax = MAX_POINT_COUNT;
125:
126: LONG lSemAccumulateFractal = NULL;
127: BOOL fInterrupted = FALSE;
128: BOOL fClearBetween = TRUE;
129: BOOL fAutoScale = TRUE;
130:
131: double xscale = 250.0;
132: double yscale = 220.0;
133: double xoff = 30.0;
134: double yoff = 30.0;
135:
136: LONG lColorBack = CLR_BLACK;
137: LONG lColor = CLR_BLUE;
138: USHORT usStyle = LINETYPE_SOLID;
139: USHORT usMixMode = FM_OVERPAINT;
140:
141: typedef PLINEFRAC (* PFPLF)(); /* "ptr to func returning ptr to LINEFRAC" */
142: PFPLF XformFuncs[] =
143: {
144: DefineSharkTooth,
145: DefineSawTooth,
146: DefineKochIsland,
147: DefineStovePipe,
148: DefineEsses
149: };
150:
151:
152:
153:
154: /************************************************************************
155: *
156: * LineFracInit
157: *
158: * Set up a bitmap for the second thread to draw into. Then set
159: * up the second thread itself. Set the flag so we don't do this
160: * twice. Lower the priority of the background thread to IDLETIME,
161: * so that it won't slow down user-interface response.
162: *
163: * Initialize the current transform. Post a message to cause the
164: * transform to actually be defined.
165: *
166: ************************************************************************/
167:
168: VOID
169: LineFracInit(hWnd)
170: HWND hWnd;
171: {
172: if (fHaveBitmap = ResizeBitmap(hWnd))
173: {
174: DosSemSet( &lSemAccumulateFractal );
175: if (fHaveAccumThread = !DosCreateThread( AccumulateLineFractal,
176: &tidAccumFrac,
177: abAccumStack + sizeof(abAccumStack)));
178: DosSetPrty(PRTYS_THREAD, PRTYC_IDLETIME, 0, tidAccumFrac);
179: WinPostMsg(hWnd, WM_COMMAND, (MPARAM)usCurrentXform, (MPARAM)0L);
180: }
181: }
182:
183:
184:
185:
186: /************************************************************************
187: *
188: * LineFracExit
189: *
190: * If we have a bitmap lying around, delete it.
191: *
192: ************************************************************************/
193:
194: VOID
195: LineFracExit()
196: {
197: if (fHaveBitmap)
198: {
199: GpiSetBitmap(LineFracPS, NULL);
200: GpiDeleteBitmap(LineFracBM);
201: GpiDestroyPS(LineFracPS);
202: DevCloseDC(LineFracDC);
203: }
204: }
205:
206:
207:
208:
209: /************************************************************************
210: *
211: * ResizeBitmap
212: *
213: * Destroy the current bitmap and create a new one the size of the
214: * current client rectangle.
215: *
216: ************************************************************************/
217:
218: BOOL
219: ResizeBitmap(hWnd)
220: HWND hWnd;
221: {
222: SIZEL size;
223: BITMAPINFOHEADER bminfo;
224:
225:
226: if (fHaveBitmap)
227: {
228: GpiSetBitmap(LineFracPS, NULL);
229: GpiDeleteBitmap(LineFracBM);
230: GpiDestroyPS(LineFracPS);
231: DevCloseDC(LineFracDC);
232: }
233:
234: LineFracDC = DevOpenDC(hAB, OD_MEMORY, "*", 0L, NULL, NULL);
235: if (!LineFracDC)
236: return FALSE;
237:
238: size.cx = 0L;
239: size.cy = 0L;
240: LineFracPS = GpiCreatePS(hAB, LineFracDC, &size,
241: PU_PELS|GPIT_MICRO|GPIA_ASSOC);
242: if (!LineFracPS)
243: {
244: DevCloseDC(LineFracDC);
245: return FALSE;
246: }
247:
248:
249: bminfo.cbFix = sizeof(BITMAPINFOHEADER);
250: WinQueryWindowRect(hWnd, &LineFracRc);
251: bminfo.cx = (USHORT) (LineFracRc.xRight - LineFracRc.xLeft);
252: bminfo.cy = (USHORT) (LineFracRc.yTop - LineFracRc.yBottom);
253: bminfo.cPlanes = 1;
254: bminfo.cBitCount = 4;
255: LineFracBM = GpiCreateBitmap(LineFracPS, &bminfo, 0L, 0L, 0L);
256: if (!LineFracBM)
257: {
258: GpiDestroyPS(LineFracPS);
259: DevCloseDC(LineFracDC);
260: return FALSE;
261: }
262:
263: GpiSetBitmap(LineFracPS, LineFracBM);
264: WinFillRect(LineFracPS, &LineFracRc, lColorBack);
265:
266:
267: /* Compute the scale and translation parameters from the
268: * current client rectangle.
269: */
270:
271: xoff = (LineFracRc.xRight - LineFracRc.xLeft) * 0.125;
272: yoff = (LineFracRc.yTop - LineFracRc.yBottom) * 0.5;
273: xscale = xoff * 6.0;
274: yscale = (LineFracRc.yTop - LineFracRc.yBottom) * 0.75;
275:
276: return TRUE;
277: }
278:
279:
280:
281:
282: /************************************************************************
283: *
284: * LineFracCommand
285: *
286: * Process menu commands related to line fractals.
287: *
288: ************************************************************************/
289:
290: VOID
291: LineFracCommand(hWnd, id)
292: HWND hWnd;
293: USHORT id;
294: {
295: switch (id)
296: {
297: case IDMABOUT:
298: WinDlgBox( HWND_DESKTOP, hWnd, (PFNWP)AboutDlg, NULL,
299: IDD_ABOUT, NULL );
300: break;
301:
302: case IDMFRACATTRS:
303: WinDlgBox( HWND_DESKTOP, hWnd, (PFNWP)LineFracDlg, NULL,
304: IDD_LINEFRAC, NULL );
305: break;
306:
307: case IDMCLEARBITMAP:
308: if (fHaveBitmap)
309: {
310: WinFillRect(LineFracPS, &LineFracRc, lColorBack);
311: WinInvalidateRect(hwndLineFrac, &LineFracRc, FALSE);
312: }
313: break;
314:
315: case IDMAUTOSCALE:
316: fAutoScale = !fAutoScale;
317: WinSendDlgItemMsg( hwndLineFracFrame, FID_MENU,
318: MM_SETITEMATTR, MPFROM2SHORT(IDMAUTOSCALE, TRUE),
319: MPFROM2SHORT(MIA_CHECKED, fAutoScale ? MIA_CHECKED : NULL));
320: break;
321:
322: case IDMSHARKTOOTH:
323: case IDMSAWTOOTH:
324: case IDMKOCH:
325: case IDMSTOVE:
326: case IDMESSES:
327: LineFracXform = (*(XformFuncs[id - IDMSHARKTOOTH]))();
328: WinSendDlgItemMsg( hwndLineFracFrame, FID_MENU,
329: MM_SETITEMATTR, MPFROM2SHORT(usCurrentXform, TRUE),
330: MPFROM2SHORT(MIA_CHECKED, NULL));
331: usCurrentXform = id;
332: WinSendDlgItemMsg( hwndLineFracFrame, FID_MENU,
333: MM_SETITEMATTR, MPFROM2SHORT(usCurrentXform, TRUE),
334: MPFROM2SHORT(MIA_CHECKED, MIA_CHECKED));
335:
336: case IDMREDRAW:
337: DosSemClear(&lSemAccumulateFractal);
338:
339: case IDMABORT:
340: fInterrupted = TRUE; /* suicide flag for pt accumulation */
341: break;
342: }
343: }
344:
345:
346:
347:
348: /************************************************************************
349: *
350: * LineFracPaint
351: *
352: * If we have a bitmap, blit it to the screen, no matter what state
353: * it's in.
354: *
355: ************************************************************************/
356:
357: VOID
358: LineFracPaint(hPS)
359: HPS hPS;
360: {
361: POINTL bbp[4];
362:
363: if (fHaveBitmap)
364: {
365: bbp[0].x = 0L; bbp[0].y = 0L;
366: bbp[1].x = LineFracRc.xRight; bbp[1].y = LineFracRc.yTop;
367: bbp[2].x = 0L; bbp[2].y = 0L;
368:
369: GpiBitBlt(hPS, LineFracPS, 3L, bbp, ROP_SRCCOPY, (LONG)NULL);
370: }
371: }
372:
373:
374:
375:
376: /************************************************************************
377: *
378: * DefineSharkTooth
379: *
380: * Set up the similarity transform for the following linefractal,
381: * which looks roughly like:
382: *
383: *
384: * *
385: * ===> * *
386: * * *
387: * *************** * *
388: *
389: ************************************************************************/
390:
391: PLINEFRAC
392: DefineSharkTooth()
393: {
394: double ang;
395: double len;
396: static LINEFRAC shark[3];
397:
398: ang = PI / 6.0;
399: len = 1.0 / sqrt(3.0);
400:
401:
402: shark[0].angle = ang;
403: shark[0].length = len;
404: shark[0].flip = FALSE;
405: shark[0].next = &(shark[1]);
406:
407: shark[1].angle = -ang * 2.0;
408: shark[1].length = len;
409: shark[1].flip = FALSE;
410: shark[1].next = EOLIST;
411:
412: return &(shark[0]);
413: }
414:
415:
416:
417:
418: /************************************************************************
419: *
420: * DefineSawTooth
421: *
422: * Set up the similarity transform for the following linefractal,
423: * which looks roughly like:
424: *
425: *
426: *
427: * ===> *
428: * * *
429: * *************** * * *
430: * * *
431: * *
432: *
433: ************************************************************************/
434:
435: PLINEFRAC
436: DefineSawTooth()
437: {
438: double ang;
439: double len;
440: static LINEFRAC saw[3];
441:
442: ang = PI / 4.0;
443: len = 1.0 / sqrt(2.0);
444:
445:
446: saw[0].angle = ang;
447: saw[0].length = len / 2.0;
448: saw[0].flip = FALSE;
449: saw[0].next = &(saw[1]);
450:
451: saw[1].angle = -ang * 2.0;
452: saw[1].length = len;
453: saw[1].flip = FALSE;
454: saw[1].next = &(saw[2]);
455:
456: saw[2].angle = ang * 2.0;
457: saw[2].length = len / 2.0;
458: saw[2].flip = FALSE;
459: saw[2].next = EOLIST;
460:
461: return &(saw[0]);
462: }
463:
464:
465:
466:
467: /************************************************************************
468: *
469: * DefineKochIsland
470: *
471: * Set up the similarity transform for the following linefractal,
472: * which looks roughly like:
473: *
474: * This is known as the Koch, or snowflake, transform.
475: *
476: *
477: * *
478: * ===> * *
479: * * *
480: * *************** ***** *****
481: *
482: ************************************************************************/
483:
484: PLINEFRAC
485: DefineKochIsland()
486: {
487: double ang;
488: double len;
489: static LINEFRAC koch[4];
490:
491: ang = PI / 3.0;
492: len = 1.0 / 3.0;
493:
494:
495: koch[0].angle = 0.0;
496: koch[0].length = len;
497: koch[0].flip = FALSE;
498: koch[0].next = &(koch[1]);
499:
500: koch[1].angle = ang;
501: koch[1].length = len;
502: koch[1].flip = FALSE;
503: koch[1].next = &(koch[2]);
504:
505: koch[2].angle = -2.0 * ang;
506: koch[2].length = len;
507: koch[2].flip = FALSE;
508: koch[2].next = &(koch[3]);
509:
510: koch[3].angle = ang;
511: koch[3].length = len;
512: koch[3].flip = FALSE;
513: koch[3].next = EOLIST;
514:
515: return &(koch[0]);
516: }
517:
518:
519:
520:
521: /************************************************************************
522: *
523: * DefineStovePipe
524: *
525: * Set up the similarity transform for the following linefractal,
526: * which looks roughly like:
527: *
528: * This is sometimes known as the stovepipe transform.
529: *
530: *
531: * ******
532: * * *
533: * ===> * *
534: * * *
535: * ************** ***** *****
536: *
537: ************************************************************************/
538:
539: PLINEFRAC
540: DefineStovePipe()
541: {
542: double ang;
543: double len;
544: static LINEFRAC Stove[5];
545:
546:
547: ang = PI / 2.0;
548: len = 1.0 / 3.0;
549:
550:
551: Stove[0].angle = 0.0;
552: Stove[0].length = len;
553: Stove[0].flip = FALSE;
554: Stove[0].next = &(Stove[1]);
555:
556: Stove[1].angle = ang;
557: Stove[1].length = len;
558: Stove[1].flip = FALSE;
559: Stove[1].next = &(Stove[2]);
560:
561: Stove[2].angle = -ang;
562: Stove[2].length = len;
563: Stove[2].flip = FALSE;
564: Stove[2].next = &(Stove[3]);
565:
566: Stove[3].angle = -ang;
567: Stove[3].length = len;
568: Stove[3].flip = FALSE;
569: Stove[3].next = &(Stove[4]);
570:
571: Stove[4].angle = ang;
572: Stove[4].length = len;
573: Stove[4].flip = FALSE;
574: Stove[4].next = EOLIST;
575:
576: return &(Stove[0]);
577: }
578:
579:
580:
581:
582:
583: /************************************************************************
584: *
585: * DefineEsses
586: *
587: * Set up the similarity transform for the following linefractal,
588: * which looks roughly like:
589: *
590: *
591: * ******
592: * * *
593: * ************** ===> * * *
594: * * *
595: * ******
596: *
597: ************************************************************************/
598:
599: PLINEFRAC
600: DefineEsses()
601: {
602: double ang;
603: static LINEFRAC Esses[5];
604:
605:
606: ang = PI / 2.0;
607:
608:
609: Esses[0].angle = ang;
610: Esses[0].length = 0.25;
611: Esses[0].flip = FALSE;
612: Esses[0].next = &(Esses[1]);
613:
614: Esses[1].angle = -ang;
615: Esses[1].length = 0.5;
616: Esses[1].flip = FALSE;
617: Esses[1].next = &(Esses[2]);
618:
619: Esses[2].angle = -ang;
620: Esses[2].length = 0.5;
621: Esses[2].flip = FALSE;
622: Esses[2].next = &(Esses[3]);
623:
624: Esses[3].angle = ang;
625: Esses[3].length = 0.5;
626: Esses[3].flip = FALSE;
627: Esses[3].next = &(Esses[4]);
628:
629: Esses[4].angle = ang;
630: Esses[4].length = 0.25;
631: Esses[4].flip = FALSE;
632: Esses[4].next = EOLIST;
633:
634: return &(Esses[0]);
635: }
636:
637:
638:
639:
640: /************************************************************************
641: *
642: * LineFracDlg
643: *
644: * Process messages for the fractal attributes dialog box.
645: *
646: ************************************************************************/
647:
648: ULONG FAR PASCAL
649: LineFracDlg( hWndDlg, message, mp1, mp2 )
650: HWND hWndDlg;
651: USHORT message;
652: MPARAM mp1;
653: MPARAM mp2;
654: {
655: switch (message)
656: {
657: case WM_INITDLG:
658: MySetWindowLong (hWndDlg, IDDCOLORBK, lColorBack);
659: MySetWindowLong (hWndDlg, IDDCOLOR, lColor);
660: MySetWindowUShort(hWndDlg, IDDSTYLE, usStyle);
661: MySetWindowUShort(hWndDlg, IDDMIX, usMixMode);
662: MySetWindowUShort(hWndDlg, IDDNUMSIDES, usPolygonSides);
663: MySetWindowUShort(hWndDlg, IDDCPTMAX, cptMax);
664: MySetWindowUShort(hWndDlg, IDDRECURSION, usRecursion);
665:
666: WinSendDlgItemMsg( hWndDlg, IDDCLEARBETWEEN, BM_SETCHECK,
667: MPFROM2SHORT(fClearBetween, 0), 0L );
668: return FALSE;
669:
670: case WM_COMMAND:
671: switch (SHORT1FROMMP(mp1))
672: {
673: case IDDOK:
674: lColorBack = MyGetWindowLong (hWndDlg, IDDCOLORBK);
675: lColor = MyGetWindowLong (hWndDlg, IDDCOLOR);
676: usStyle = MyGetWindowUShort(hWndDlg, IDDSTYLE);
677: usMixMode = MyGetWindowUShort(hWndDlg, IDDMIX);
678: usPolygonSides = MyGetWindowUShort(hWndDlg, IDDNUMSIDES);
679: cptMax = MyGetWindowUShort(hWndDlg, IDDCPTMAX);
680: usRecursion = MyGetWindowUShort(hWndDlg, IDDRECURSION);
681:
682: fClearBetween = (SHORT)WinSendDlgItemMsg( hWndDlg, IDDCLEARBETWEEN,
683: BM_QUERYCHECK, 0L, 0L );
684:
685: if (usPolygonSides == 0)
686: usPolygonSides = 2;
687:
688: if (cptMax == 0)
689: cptMax = 1;
690: else if (cptMax > MAX_POINT_COUNT)
691: cptMax = MAX_POINT_COUNT;
692:
693:
694: WinDismissDlg( hWndDlg, TRUE );
695: break;
696:
697: case IDDCANCEL:
698: WinDismissDlg( hWndDlg, TRUE );
699: break;
700:
701: default:
702: return FALSE;
703: }
704: break;
705:
706: default:
707: return (ULONG) WinDefDlgProc( hWndDlg, message, mp1, mp2 );
708: }
709: return FALSE;
710: }
711:
712:
713:
714:
715: /************************************************************************
716: *
717: * AboutDlg
718: *
719: * Process messages for the About box.
720: *
721: ************************************************************************/
722:
723: ULONG FAR PASCAL
724: AboutDlg( hWndDlg, message, mp1, mp2 )
725: HWND hWndDlg;
726: USHORT message;
727: MPARAM mp1;
728: MPARAM mp2;
729: {
730: switch (message)
731: {
732: case WM_COMMAND: /* the user has pressed a button */
733: switch (SHORT1FROMMP(mp1)) /* which button? */
734: {
735: case DID_OK:
736: case DID_CANCEL:
737: WinDismissDlg( hWndDlg, TRUE );
738: break;
739:
740: default:
741: return FALSE;
742: }
743: break;
744:
745: default:
746: return (ULONG) WinDefDlgProc( hWndDlg, message, mp1, mp2 );
747: }
748: return FALSE;
749: }
750:
751:
752:
753:
754: /************************************************************************
755: *
756: * MySetWindowUShort
757: *
758: * Sets the given control id to the value specified.
759: *
760: * Be careful! The call to sprintf only works because our
761: * stack segment is the same as our data segment.
762: *
763: ************************************************************************/
764:
765: VOID
766: MySetWindowUShort(hWnd, id, num)
767: HWND hWnd;
768: USHORT id;
769: USHORT num;
770: {
771: char szStr[CCHSTR];
772:
773: sprintf((NPCH)szStr, "%u", num);
774: WinSetWindowText(WinWindowFromID(hWnd, id), (PCH)szStr);
775: }
776:
777:
778:
779:
780: /************************************************************************
781: *
782: * MySetWindowLong
783: *
784: * Sets the given control id to the value specified.
785: *
786: * Be careful! The call to sprintf only works because our
787: * stack segment is the same as our data segment.
788: *
789: ************************************************************************/
790:
791: VOID
792: MySetWindowLong(hWnd, id, num)
793: HWND hWnd;
794: USHORT id;
795: LONG num;
796: {
797: char szStr[CCHSTR];
798:
799: sprintf((NPCH)szStr, "%ld", num);
800: WinSetWindowText(WinWindowFromID(hWnd, id), (PCH)szStr);
801: }
802:
803:
804:
805:
806: /************************************************************************
807: *
808: * MyGetWindowUShort
809: *
810: * Returns the value from the given control id.
811: *
812: * Be careful! The call to atoi only works because our
813: * stack segment is the same as our data segment.
814: *
815: ************************************************************************/
816:
817: USHORT
818: MyGetWindowUShort(hWnd, id)
819: HWND hWnd;
820: USHORT id;
821: {
822: char szStr[CCHSTR];
823:
824: WinQueryWindowText(WinWindowFromID(hWnd, id), CCHSTR, (PCH)szStr);
825: return atoi(szStr);
826: }
827:
828:
829:
830:
831: /************************************************************************
832: *
833: * MyGetWindowLong
834: *
835: * Returns the value from the given control id.
836: *
837: * Be careful! The call to atol only works because our
838: * stack segment is the same as our data segment.
839: *
840: ************************************************************************/
841:
842: LONG
843: MyGetWindowLong(hWnd, id)
844: HWND hWnd;
845: USHORT id;
846: {
847: char szStr[CCHSTR];
848:
849: WinQueryWindowText(WinWindowFromID(hWnd, id), CCHSTR, (PCH)szStr);
850: return atol(szStr);
851: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.