![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mandel.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / samples / rpc / mandel|
Return to mandel.c CVS log | Up to [WindowsNT SDKs] / mstools / samples / rpc / mandel |
1.1 root 1: /****************************************************************************
2:
3: MANDEL.C --
4:
5: Main code for the Windows Mandelbrot Set distributed drawing program.
6:
7: Copyright (C) 1990 Microsoft Corporation.
8:
9: This code sample is provided for demonstration purposes only.
10: Microsoft makes no warranty, either express or implied,
11: as to its usability in any given situation.
12:
13: ****************************************************************************/
14:
15: #include <sys\types.h>
16: #include <sys\stat.h>
17: #include <direct.h>
18: #include <dos.h>
19: #include <string.h>
20: #include <ctype.h>
21: #include <malloc.h> // malloc, free
22: #include <stdio.h>
23: #include <stdlib.h>
24: #include <time.h>
25:
26: #ifdef RPC
27: #include <rpc.h>
28: #include "mdlrpc.h"
29: #endif
30:
31: #include <windows.h> /* Required for all Windows applications */
32: #include "mandel.h" /* Specific to this program */
33:
34: #define MENUNAME "MandelMenu"
35: #define CLASSNAME "MandelClass"
36: #define ABOUTBOX "AboutBox"
37: #define SAVEBOX "SAVEBOX"
38:
39:
40: #define POLL_TIME 100
41: #define LINES 4
42:
43: #ifdef RPC
44: char szTitle[] = "Mandelbrot RPC";
45: #else
46: char szTitle[] = "Mandelbrot Standalone";
47: #endif
48:
49: char szBitmap[] = "Mandel";
50:
51: CPOINT cptUL = { (double) -2.05, (double) 1.4 };
52: double dPrec = (double) .01;
53:
54: void PaintLine( HWND, svr_table *, HDC, int);
55: COLORREF MapColor( DWORD, DWORD );
56: void DrawRect( HWND, PRECT, BOOL, HDC);
57: long get_drivemap(void);
58: void set_dlgitems(HWND, char *, long);
59: BOOL update_curdir(HWND, char *, long);
60: char * getdcwd( int, char *, unsigned);
61: void set_filename( HWND );
62: BOOL munge_path( char *);
63:
64: HANDLE hInst; /* current instance */
65:
66: int iLines = LINES;
67: svr_table SvrTable[20];
68: int SvrTableSz = 0;
69:
70: #define NCOLORS 11
71: int fContinueZoom = TRUE;
72: int fZoomIn = TRUE;
73: int Histogram[4][4][NCOLORS+1] = {0}; /* split current picture into 16 regions */
74: /* zoom on most complex region; region with most colors represented */
75: int ColorCount[4][4] = {0};
76: int Max[4][4] = { 0 };
77: int iHistMaxI = 2;
78: int iHistMaxJ = 3;
79: RECT rcZoom;
80: BOOL fRectDefined = FALSE;
81:
82:
83: /*
84: *
85: * FUNCTION: WinMain(HANDLE, HANDLE, LPSTR, int)
86: *
87: * PURPOSE: Calls initialization function, processes message loop
88: *
89: * COMMENTS:
90: *
91: * Windows recognizes this function by name as the initial entry point
92: * for the program. This function calls the application initialization
93: * routine, if no other instance of the program is running, and always
94: * calls the instance initialization routine. It then executes a message
95: * retrieval and dispatch loop that is the top-level control structure
96: * for the remainder of execution. The loop is terminated when a WM_QUIT
97: * message is received, at which time this function exits the application
98: * instance by returning the value passed by PostQuitMessage().
99: *
100: * If this function must abort before entering the message loop, it
101: * returns the conventional value NULL.
102: *
103: */
104:
105: int APIENTRY WinMain(hInstance, hPrevInstance, lpCmdLine, nCmdShow)
106: HANDLE hInstance; /* current instance */
107: HANDLE hPrevInstance; /* previous instance */
108: LPSTR lpCmdLine; /* command line */
109: int nCmdShow; /* show-window type (open/icon) */
110: {
111: MSG msg; /* message */
112:
113: UNREFERENCED_PARAMETER(lpCmdLine);
114:
115: // add a runtime exception handler for RPC version
116: // see below for additional exception handling code
117: #ifdef RPC
118: RpcTryExcept {
119: #endif
120:
121: if (!hPrevInstance) /* Other instances of app running? */
122: if (!InitApplication(hInstance)) /* Initialize shared things */
123: return (FALSE); /* Exits if unable to initialize */
124:
125: /* Perform initializations that apply to a specific instance */
126:
127: if (!InitInstance(hInstance, nCmdShow))
128: return (FALSE);
129:
130: /* Acquire and dispatch messages until a WM_QUIT message is received. */
131:
132:
133: while (GetMessage(&msg, /* message structure */
134: NULL, /* handle of window receiving the message */
135: 0, /* lowest message to examine */
136: 0)) /* highest message to examine */
137: {
138: TranslateMessage(&msg); /* Translates virtual key codes */
139: DispatchMessage(&msg); /* Dispatches message to window */
140: }
141:
142: return (msg.wParam); /* Returns the value from PostQuitMessage */
143:
144: // add a runtime exception handler for RPC version
145: // see above for additional exception handling code
146: #ifdef RPC
147: } // end of RpcTryExcept statements
148: RpcExcept(1) {
149: sprintf(pszFail, "Please start the server application.");
150: MessageBox(msg.hwnd, pszFail, "Mandel Server Not Started",
151: MB_ICONHAND | MB_SYSTEMMODAL);
152: }
153: RpcEndExcept
154: #endif
155:
156: } // end WinMain
157:
158:
159:
160:
161: /*
162: * FUNCTION: InitApplication(HANDLE)
163: *
164: * PURPOSE: Initializes window data and registers window class
165: *
166: * COMMENTS:
167: *
168: * This function is called at initialization time only if no other
169: * instances of the application are running. This function performs
170: * initialization tasks that can be done once for any number of running
171: * instances.
172: *
173: * In this case, we initialize a window class by filling out a data
174: * structure of type WNDCLASS and calling the Windows RegisterClass()
175: * function. Since all instances of this application use the same window
176: * class, we only need to do this when the first instance is initialized.
177: */
178:
179: BOOL InitApplication(hInstance)
180: HANDLE hInstance; /* current instance */
181: {
182: WNDCLASS wc;
183:
184: /* Fill in window class structure with parameters that describe the */
185: /* main window. */
186:
187: wc.style = 0; /* Class style(s). */
188: wc.lpfnWndProc = (WNDPROC)MainWndProc; /* Function to retrieve messages for */
189: /* windows of this class. */
190: wc.cbClsExtra = 0; /* No per-class extra data. */
191: wc.cbWndExtra = 0; /* No per-window extra data. */
192: wc.hInstance = hInstance; /* Application that owns the class. */
193: wc.hIcon = LoadIcon(hInstance, "RPC_ICON");
194: wc.hCursor = LoadCursor(NULL, IDC_ARROW);
195: wc.hbrBackground = GetStockObject(WHITE_BRUSH);
196: wc.lpszMenuName = MENUNAME; /* Name of menu resource in .RC file. */
197: wc.lpszClassName = CLASSNAME; /* Name used in call to CreateWindow. */
198:
199: /* Register the window class and return success/failure code. */
200:
201: return (RegisterClass(&wc));
202:
203: }
204:
205:
206:
207: /*
208: * FUNCTION: InitInstance(HANDLE, int)
209: *
210: * PURPOSE: Saves instance handle and creates main window.
211: *
212: * COMMENTS:
213: *
214: * This function is called at initialization time for every instance of
215: * this application. This function performs initialization tasks that
216: * cannot be shared by multiple instances.
217: *
218: * In this case, we save the instance handle in a static variable and
219: * create and display the main program window.
220: */
221:
222: BOOL InitInstance(hInstance, nCmdShow)
223: HANDLE hInstance; /* Current instance identifier. */
224: int nCmdShow; /* Param for first ShowWindow() call. */
225: {
226: HWND hWnd; /* Main window handle. */
227: RECT rc;
228:
229: /* Save the instance handle in static variable, which will be used in */
230: /* many subsequence calls from this application to Windows. */
231:
232: hInst = hInstance;
233:
234: /* Create a main window for this application instance. */
235:
236: hWnd = CreateWindow(
237: CLASSNAME, /* See RegisterClass() call. */
238: szTitle, /* Text for window title bar. */
239: WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_BORDER | WS_MINIMIZEBOX,
240: CW_USEDEFAULT, /* Default horizontal position. */
241: CW_USEDEFAULT, /* Default vertical position. */
242: WIDTH, /* Default width. */
243: HEIGHT, /* Default height. */
244: NULL, /* Overlapped windows have no parent. */
245: NULL, /* Use the window class menu. */
246: hInstance, /* This instance owns this window. */
247: NULL /* Pointer not needed. */
248: );
249:
250: /* If window could not be created, return "failure" */
251:
252: if (!hWnd)
253: return (FALSE);
254:
255: /* Make the window visible; update its client area; and return "success" */
256:
257: ShowWindow(hWnd, nCmdShow); /* Show the window */
258: UpdateWindow(hWnd); /* Sends WM_PAINT message */
259:
260: rc.top = rc.left = 0;
261: rc.bottom = HEIGHT-1;
262: rc.right = WIDTH-1;
263:
264: SetNewCalc(cptUL, dPrec, rc);
265:
266: return (TRUE); /* Returns the value from PostQuitMessage */
267: }
268:
269:
270:
271: /*
272: * FUNCTION: MainWndProc(HWND, unsigned, WORD, LONG)
273: *
274: * PURPOSE: Processes messages
275: *
276: * MESSAGES:
277: *
278: * WM_COMMAND - application menu (About dialog box)
279: * WM_DESTROY - destroy window
280: *
281: * COMMENTS:
282: *
283: * To process the IDM_ABOUT message, call MakeProcInstance() to get
284: * the current instance address of the About() function, then call
285: * DialogBox to create the box according to the information in the
286: * MANDEL.RC file and turn control over to the About() function.
287: * When it returns, free the intance address.
288: */
289:
290: LONG APIENTRY MainWndProc(
291: HWND hWnd, /* window handle */
292: UINT message, /* type of message */
293: UINT wParam, /* additional information */
294: LONG lParam) /* additional information */
295: {
296: FARPROC lpProcAbout; /* pointer to the "About" function */
297: PAINTSTRUCT ps;
298: HDC hdc;
299: static HDC hdcMem;
300: static HBITMAP hbmMem;
301: static int width;
302: static int height;
303: RECT rc;
304: static BOOL fButtonDown = FALSE;
305: static POINT pSelected;
306: POINT pMove;
307: int iWidthNew;
308: int iHeightNew;
309: static int miOldLines;
310: double scaling;
311:
312: switch (message)
313: {
314:
315: case WM_CREATE:
316: if (!InitRemote(hWnd))
317: return FALSE;
318:
319: InitHistogram();
320:
321: hdc = GetDC(hWnd);
322: hdcMem = CreateCompatibleDC(hdc);
323: GetWindowRect(hWnd, &rc);
324: width = rc.right - rc.left;
325: height = rc.bottom - rc.top;
326: hbmMem = CreateCompatibleBitmap(hdc, width, height);
327: SelectObject(hdcMem, hbmMem);
328:
329: ReleaseDC(hWnd,hdc);
330:
331: rc.left = rc.top = 0;
332: rc.right = width+1;
333: rc.bottom = height + 1;
334: FillRect(hdcMem, &rc, GetStockObject(WHITE_BRUSH));
335:
336: SetTimer(hWnd, 1, POLL_TIME, NULL); // set timer for polls
337:
338: CheckMenuItem(GetMenu(hWnd), IDM_4LINES, MF_CHECKED);
339: CheckMenuItem(GetMenu(hWnd), IDM_CONTINUOUS, MF_CHECKED);
340: miOldLines = IDM_4LINES; // save to uncheck
341:
342: break;
343:
344: case WM_PAINT:
345: hdc = BeginPaint(hWnd, &ps);
346: BitBlt(hdc, ps.rcPaint.left,
347: ps.rcPaint.top,
348: ps.rcPaint.right - ps.rcPaint.left,
349: ps.rcPaint.bottom - ps.rcPaint.top,
350: hdcMem, ps.rcPaint.left, ps.rcPaint.top, SRCCOPY);
351: EndPaint(hWnd, &ps);
352: break;
353:
354: case WM_COMMAND: /* message: command from application menu */
355: switch(wParam)
356: {
357:
358: case IDM_ABOUT:
359: lpProcAbout = MakeProcInstance((FARPROC)About, hInst);
360:
361: DialogBox(hInst, /* current instance */
362: ABOUTBOX, /* resource to use */
363: hWnd, /* parent handle */
364: (WNDPROC)lpProcAbout); /* About() instance address */
365:
366: FreeProcInstance(lpProcAbout);
367: break;
368:
369: case IDM_ZOOMOUT:
370: if (dPrec > (double)MAXPREC) // don't allow the zoom out
371: break;
372: rcZoom.left = WIDTH/4 + (WIDTH/8); // center square
373: rcZoom.top = HEIGHT/4 + (HEIGHT/8);
374: rcZoom.right = rcZoom.left + (WIDTH/4);
375: rcZoom.bottom = rcZoom.top + (HEIGHT/4);
376:
377: cptUL.real -= (rcZoom.left * dPrec); // inverse of zoom in
378: cptUL.imag += (rcZoom.top * dPrec);
379: iWidthNew = (rcZoom.right - rcZoom.left + 1);
380: iHeightNew = (rcZoom.bottom - rcZoom.top + 1);
381: scaling =
382: ( (double) ((iWidthNew > iHeightNew) ? iWidthNew : iHeightNew)
383: / (double)width);
384: dPrec /= scaling;
385:
386: rc.left = rc.top = 0;
387: rc.bottom = height - 1;
388: rc.right = width - 1;
389:
390: SetNewCalc(cptUL, dPrec, rc);
391: fRectDefined = FALSE;
392: DoSomeWork(hWnd, FALSE);
393: break;
394:
395: case IDM_ZOOMIN: // zoom in on selected rectangle
396: // if no rectangle, don't zoom in
397: if (!fRectDefined)
398: break;
399: if (dPrec < (double)MINPREC) // don't allow zoom in
400: break;
401: DrawRect(hWnd, &rcZoom, TRUE, hdcMem); // draw new rect
402:
403: // calculate new upper-left
404: cptUL.real += (rcZoom.left * dPrec);
405: cptUL.imag -= (rcZoom.top * dPrec);
406:
407: iWidthNew = (rcZoom.right - rcZoom.left + 1);
408: iHeightNew = (rcZoom.bottom - rcZoom.top + 1);
409: scaling =
410: ( (double) ((iWidthNew > iHeightNew) ? iWidthNew : iHeightNew)
411: / (double)width);
412:
413: dPrec *= scaling;
414:
415: rc.left = rc.top = 0;
416: rc.bottom = height - 1;
417: rc.right = width - 1;
418:
419: SetNewCalc( cptUL, dPrec, rc);
420: IncPictureID();
421:
422: fRectDefined = FALSE;
423: DoSomeWork(hWnd, FALSE);
424: break;
425:
426: case IDM_CONTINUOUS: // continuous zoom in
427: if (fContinueZoom == TRUE) {
428: CheckMenuItem(GetMenu(hWnd), IDM_CONTINUOUS, MF_UNCHECKED);
429: fContinueZoom = FALSE;
430: }
431: else {
432: CheckMenuItem(GetMenu(hWnd), IDM_CONTINUOUS, MF_CHECKED);
433: fContinueZoom = TRUE;
434: }
435: break;
436:
437: case IDM_REDRAW:
438: if (fContinueZoom == TRUE)
439: InitHistogram();
440: rc.left = rc.top = 0;
441: rc.right = width+1;
442: rc.bottom = height + 1;
443: FillRect(hdcMem, &rc, GetStockObject(WHITE_BRUSH));
444: InvalidateRect(hWnd, NULL, TRUE);
445:
446: rc.left = rc.top = 0;
447: rc.bottom = height - 1;
448: rc.right = width - 1;
449: SetNewCalc( cptUL, dPrec, rc);
450:
451: fRectDefined = FALSE;
452: DoSomeWork(hWnd, FALSE);
453: break;
454:
455: case IDM_EXIT:
456: DestroyWindow(hWnd);
457: break;
458:
459: case IDM_TOP:
460: cptUL.real = (double) -2.05;
461: cptUL.imag = (double) 1.4;
462: dPrec = .01;
463:
464: rc.left = rc.top = 0;
465: rc.bottom = height - 1;
466: rc.right = width - 1;
467: SetNewCalc( cptUL, dPrec, rc);
468: cPictureID = 0; // incremented past original
469:
470: fRectDefined = FALSE;
471: DoSomeWork(hWnd, FALSE);
472: break;
473:
474: case IDM_1LINE:
475: case IDM_2LINES:
476: case IDM_4LINES:
477: case IDM_8LINES:
478: case IDM_16LINES:
479: case IDM_32LINES:
480:
481: CheckMenuItem(GetMenu(hWnd), miOldLines, MF_UNCHECKED);
482: miOldLines = wParam;
483: switch(wParam)
484: {
485: case IDM_1LINE:
486: iLines = 1;
487: break;
488: case IDM_2LINES:
489: iLines = 2;
490: break;
491: case IDM_4LINES:
492: iLines = 4;
493: break;
494: case IDM_8LINES:
495: iLines = 8;
496: break;
497: case IDM_16LINES:
498: iLines = 16;
499: break;
500: case IDM_32LINES:
501: iLines = 32;
502: }
503:
504: CheckMenuItem(GetMenu(hWnd), miOldLines, MF_CHECKED);
505: break;
506:
507:
508: default: /* Lets Windows process it */
509: return (DefWindowProc(hWnd, message, wParam, lParam));
510: }
511: break;
512:
513: case WM_DESTROY: /* message: window being destroyed */
514: PostQuitMessage(0);
515: DeleteDC(hdcMem);
516: DeleteObject(hbmMem);
517: break;
518:
519: case WM_DOSOMEWORK:
520: // do another slice of calculation work
521: DoSomeWork(hWnd, FALSE);
522: break;
523:
524: case WM_PAINTLINE:
525: // The shared buffer contains a line of data; draw it
526: PaintLine(hWnd,
527: (svr_table *)&SvrTable[(signed int)wParam],
528: hdcMem,
529: height);
530: break;
531:
532: case WM_TIMER:
533: // timer means we should do another slice of work
534: DoSomeWork(hWnd, TRUE);
535: break;
536:
537: case WM_LBUTTONDOWN:
538: // left button down; start to define a zoom rectangle
539:
540: if (fRectDefined)
541: DrawRect(hWnd, &rcZoom, FALSE, hdcMem); // undraw old rectangle
542:
543: // initialize rectangle
544: rcZoom.left = rcZoom.right = pSelected.x = LOWORD(lParam);
545: rcZoom.top = rcZoom.bottom = pSelected.y = HIWORD(lParam);
546:
547: // draw the new rectangle
548: DrawRect(hWnd, &rcZoom, TRUE, hdcMem);
549:
550: fRectDefined = TRUE;
551: fButtonDown = TRUE;
552: SetCapture(hWnd); // capture all mouse events
553: break;
554:
555: case WM_MOUSEMOVE:
556:
557: // mouse move -- if the button is down, change the rect
558: if (!fButtonDown)
559: break;
560:
561: DrawRect(hWnd, &rcZoom, FALSE, hdcMem); // undraw old rect
562:
563: pMove.x = LOWORD(lParam);
564: pMove.y = HIWORD(lParam);
565:
566: // update the selection rectangle
567: if (pMove.x <= pSelected.x)
568: rcZoom.left = pMove.x;
569: if (pMove.x >= pSelected.x)
570: rcZoom.right = pMove.x;
571: if (pMove.y <= pSelected.y)
572: rcZoom.top = pMove.y;
573: if (pMove.y >= pSelected.y)
574: rcZoom.bottom = pMove.y;
575:
576: DrawRect(hWnd, &rcZoom, TRUE, hdcMem); // draw new rect
577: break;
578:
579: case WM_LBUTTONUP:
580: // button up; end selection
581: fButtonDown = FALSE;
582: ReleaseCapture();
583: break;
584:
585: default: /* Passes it on if unproccessed */
586: return (DefWindowProc(hWnd, message, wParam, lParam));
587: }
588: return (0L);
589: }
590:
591:
592:
593: /*
594: * FUNCTION: About(HWND, unsigned, WORD, LONG)
595: *
596: * PURPOSE: Processes messages for "About" dialog box
597: *
598: * MESSAGES:
599: *
600: * WM_INITDIALOG - initialize dialog box
601: * WM_COMMAND - Input received
602: *
603: * COMMENTS:
604: *
605: * No initialization is needed for this particular dialog box, but TRUE
606: * must be returned to Windows.
607: *
608: * Wait for user to click on "Ok" button, then close the dialog box.
609: */
610:
611: BOOL APIENTRY About(
612: HWND hDlg, /* window handle of the dialog box */
613: UINT message, /* type of message */
614: UINT wParam, /* message-specific information */
615: LONG lParam)
616: {
617: UNREFERENCED_PARAMETER(lParam);
618:
619: switch (message)
620: {
621: case WM_INITDIALOG: /* message: initialize dialog box */
622:
623: return (TRUE);
624:
625: case WM_COMMAND: /* message: received a command */
626: if (wParam == IDOK /* "OK" box selected? */
627: || wParam == IDCANCEL) /* System menu close command? */
628: {
629: EndDialog(hDlg, TRUE); /* Exits the dialog box */
630: return (TRUE);
631: }
632: break;
633: }
634: return (FALSE); /* Didn't process a message */
635: }
636:
637:
638:
639:
640: /*
641: * DoSomeWork --
642: *
643: * This function does our work for us. It does it in little pieces, and
644: * will schedule itself as it sees fit.
645: */
646:
647: void
648: DoSomeWork( HWND hwnd,
649: BOOL fTimer)
650: {
651:
652: static WORD wIteration = 0;
653:
654: if (fTimer) {
655: wIteration++;
656:
657: // on every nth tick, we send out a poll
658: if (wIteration == 120) { // tune this?
659: wIteration = 0;
660: return;
661: }
662:
663: // on the half-poll, we check for responses
664: if ((wIteration == 2) || (wIteration == 10)) {
665: return;
666: }
667:
668: }
669:
670: if (CheckDrawStatus(hwnd))
671: SendMessage(hwnd, WM_DOSOMEWORK, 0, 0L);
672:
673: return;
674: }
675:
676:
677:
678: /*
679: * DrawRect --
680: *
681: * This function draws (or undraws) the zoom rectangle.
682: */
683:
684: void
685: DrawRect( HWND hwnd,
686: PRECT prc,
687: BOOL fDrawIt,
688: HDC hdcBM)
689: {
690:
691: HDC hdc;
692: DWORD dwRop;
693:
694: hdc = GetDC(hwnd);
695:
696: if (fDrawIt)
697: dwRop = NOTSRCCOPY;
698: else
699: dwRop = SRCCOPY;
700:
701:
702: // top side
703: BitBlt(hdc, prc->left, prc->top, (prc->right - prc->left) + 1,
704: 1, hdcBM, prc->left, prc->top, dwRop);
705:
706: // bottom side
707: BitBlt(hdc, prc->left, prc->bottom, (prc->right - prc->left) + 1,
708: 1, hdcBM, prc->left, prc->bottom, dwRop);
709:
710: // left side
711: BitBlt(hdc,prc->left, prc->top, 1, (prc->bottom - prc->top) + 1,
712: hdcBM, prc->left, prc->top, dwRop);
713:
714: // right side
715: BitBlt(hdc,prc->right, prc->top, 1, (prc->bottom - prc->top) + 1,
716: hdcBM, prc->right, prc->top, dwRop);
717:
718: ReleaseDC(hwnd, hdc);
719: }
720:
721:
722:
723: /*
724: * PaintLine --
725: *
726: * This function paints a buffer of data into the bitmap.
727: */
728:
729: void
730: PaintLine( HWND hwnd,
731: svr_table * pst,
732: HDC hdcBM,
733: int cHeight)
734: {
735:
736: PWORD pwDrawData;
737: int y;
738: int x;
739: DWORD dwThreshold;
740: RECT rc;
741: WORD lines;
742:
743: lines = (WORD) pst->cLines;
744:
745: // picture ID had better match, or else we skip it
746: if (CheckDrawingID(pst->cPicture))
747: {
748: // figure out our threshold
749: dwThreshold = QueryThreshold();
750:
751: // get a pointer to the draw buffer
752: pwDrawData = (PWORD)GetDrawBuffer();
753: if (pwDrawData == NULL) {
754: ReturnDrawBuffer();
755: return;
756: }
757:
758: // starting x coordinate
759: x = (int) pst->dwLine;
760:
761: // now loop through the rectangle
762: while (lines-- > 0)
763: {
764: // bottom to top, since that's the order of the data in the buffer
765: y = (int) cHeight-1;
766:
767:
768: while (y >= 0) {
769: // draw a pixel
770: SetPixel(hdcBM, x,y, MapColor((DWORD)*pwDrawData, dwThreshold));
771: if (fContinueZoom == TRUE)
772: CalcHistogram(x, y, (DWORD)*pwDrawData, dwThreshold);
773: // now increment buffer pointer and y coord
774: y--;
775: pwDrawData++;
776: }
777: x++; // increment X coordinate
778: }
779:
780: // figure out the rectangle to invalidate
781: rc.top = 0;
782: rc.bottom = cHeight;
783: rc.left = (int)(pst->dwLine);
784: rc.right = (int)(pst->dwLine) + pst->cLines;
785:
786: FreeDrawBuffer();
787:
788: // and invalidate it on the screen so we redraw it
789: InvalidateRect(hwnd, &rc, FALSE);
790: }
791:
792: // free this for someone else to use
793: ReturnDrawBuffer();
794:
795: // and change the pipe state, if necessary
796: if (pst->iStatus == SS_PAINTING)
797: pst->iStatus = SS_IDLE;
798:
799: }
800:
801:
802: #define CLR_BLACK RGB(0,0,0)
803: #define CLR_DARKBLUE RGB(0,0,127)
804: #define CLR_BLUE RGB(0,0,255)
805: #define CLR_CYAN RGB(0,255,255)
806: #define CLR_DARKGREEN RGB(0,127,0)
807: #define CLR_GREEN RGB(0,255,0)
808: #define CLR_YELLOW RGB(255,255,0)
809: #define CLR_RED RGB(255,0,0)
810: #define CLR_DARKRED RGB(127,0,0)
811: #define CLR_WHITE RGB(255,255,255)
812: #define CLR_PALEGRAY RGB(194,194,194)
813: #define CLR_DARKGRAY RGB(127,127,127)
814:
815:
816: static COLORREF ColorMapTable[] = { // size = NCOLORS
817: CLR_DARKBLUE,
818: CLR_BLUE,
819: CLR_CYAN,
820: CLR_DARKGREEN,
821: CLR_GREEN,
822: CLR_YELLOW,
823: CLR_RED,
824: CLR_DARKRED,
825: CLR_WHITE,
826: CLR_PALEGRAY,
827: CLR_DARKGRAY};
828:
829:
830: /*
831: * MapColor --
832: *
833: * This function maps an iteration count into a corresponding RGB color.
834: */
835:
836: COLORREF
837: MapColor(DWORD dwIter,
838: DWORD dwThreshold)
839: {
840:
841: // if it's beyond the threshold, call it black
842: if (dwIter >= dwThreshold) {
843: return CLR_BLACK;
844: }
845:
846: // get a modulus based on the number of colors
847: dwIter = (dwIter / 3) % NCOLORS; // 11;
848:
849: // and return the appropriate color
850: return ColorMapTable[dwIter];
851:
852: }
853: /* CalcHistogram
854: * This function is used to select the region that is the
855: * most complex and will be used to zoom in for the next picture;
856: * it contains the most colors. The number of colors are counted.
857: */
858:
859: void
860: CalcHistogram(int x,
861: int y,
862: DWORD dwIter,
863: DWORD dwThreshold)
864: {
865:
866: // if it's beyond the threshold, call it black
867: if (dwIter >= dwThreshold) {
868: Histogram[x/(WIDTH/4)][y/(HEIGHT/4)][NCOLORS]++;
869: return;
870: }
871: // get a modulus based on the number of colors
872: dwIter = (dwIter / 3) % NCOLORS; // 11;
873:
874: // and bump the count for the appropriate color
875: Histogram[x/(WIDTH/4)][y/(HEIGHT/4)][dwIter]++; // region of map
876:
877: return;
878:
879: }
880:
881:
882: /* InitHistogram
883: * This function initializes the histogram data structures.
884: */
885:
886: void InitHistogram(void)
887: {
888: int i, j, k;
889:
890: for (i = 0; i < 4; i++)
891: for (j = 0; j < 4; j++)
892: for (k = 0; k <= NCOLORS; k++)
893: Histogram[i][j][k] = 0; /* count of colors */
894: }
895:
896: /* CountHistogram
897: * This function determines the number of colors represented
898: * within a region. The region with the most colors is
899: * selected using the maxi and maxj values. X and Y coordinates
900: * corresponding to these regions are stored in the HistRegion
901: * table and are used for the next picture.
902: */
903:
904: void CountHistogram(void)
905: {
906: int i, j, k;
907: /* count the number of colors in each region */
908: /* find the color that dominates each region */
909: for (i = 0; i < 4; i++) {
910: for (j = 0; j < 4; j++) {
911: ColorCount[i][j] = 0;
912: Max[i][j] = 0;
913: for (k = 0; k <= NCOLORS; k++) {
914: if (Histogram[i][j][k] > Max[i][j])
915: Max[i][j] = Histogram[i][j][k];
916: if (Histogram[i][j][k] != 0) /* count of colors */
917: ColorCount[i][j]++;
918: }
919:
920: }
921: }
922: iHistMaxI = 0;
923: iHistMaxJ = 0;
924: /* if several regions have the same number of colors, */
925: /* select the region with the most variety: the smallest max */
926: for (i = 0; i < 4; i++) {
927: for (j = 0; j < 4; j++) {
928: if ( (ColorCount[i][j] >= ColorCount[iHistMaxI][iHistMaxJ])
929: && (Max[i][j] < Max[iHistMaxI][iHistMaxJ]) ) {
930: iHistMaxI = i;
931: iHistMaxJ = j;
932: }
933: }
934: }
935: InitHistogram(); /* initialize for next time */
936:
937: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.