![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to julia.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / samples / mandel|
Return to julia.c CVS log | Up to [WindowsNT SDKs] / mstools / samples / mandel |
1.1 ! root 1: /******************************Module*Header*******************************\ ! 2: * Module Name: julia.c ! 3: * ! 4: * Main module for the Mandelbrot Dream ! 5: * contains almost everything; windows procedure + misc stuff ! 6: * ! 7: * Created: 24-Oct-1991 18:34:08 ! 8: * Author: Petrus Wong ! 9: * ! 10: * Copyright (c) 1990 Microsoft Corporation ! 11: * ! 12: * The Mandelbrot Dream serves to demonstrate the GDI and USER ! 13: * functionalities in the setting of fractals. ! 14: * ! 15: * The Mandelbrot Dream provides the following functions: ! 16: * 1. Drawing the Mandelbrot set and the corresponding julia set ! 17: * 2. Zooming into any of the set ! 18: * 3. MDI fractal drawing windows ! 19: * 4. Floating Point Math/Fix Point Math ! 20: * 5. Shifting color table entries ! 21: * 6. Changing palette entries and animating palatte aka color cycling ! 22: * 7. Loading/Saving bitmap created with special effect ! 23: * 8. Changing bitmap color with flood fill ! 24: * 9. Boundary tracing and creating a clip region out of it for ! 25: * creating special effect ! 26: * 10. Enumerate printers for printing ! 27: * ! 28: * Dependencies: ! 29: * ! 30: * none ! 31: * ! 32: \**************************************************************************/ ! 33: #include <windows.h> ! 34: #include <stdlib.h> ! 35: #include <commdlg.h> ! 36: #include <stdarg.h> ! 37: #include <math.h> ! 38: #include <stdio.h> ! 39: #include "julia.h" ! 40: ! 41: //#define CYCLETHRD ! 42: #define PRTTHRD ! 43: #define NEWPRTAPI ! 44: ! 45: //#define DEBUG ! 46: ! 47: #ifndef DEBUG ! 48: #undef OutputDebugString ! 49: #define OutputDebugString(LPCSTR) ! 50: #endif ! 51: ! 52: ! 53: ! 54: // ! 55: // Forward declarations. ! 56: // ! 57: BOOL InitializeApp (INT*); ! 58: LONG MainWndProc (HWND, UINT, DWORD, LONG); ! 59: LONG ChildWndProc (HWND, UINT, DWORD, LONG); ! 60: LONG About (HWND, UINT, DWORD, LONG); ! 61: LONG TextWndProc (HWND, UINT, DWORD, LONG); ! 62: LONG JuliaWndProc (HWND, UINT, DWORD, LONG); ! 63: LONG DrawWndProc (HWND, UINT, DWORD, LONG); ! 64: BOOL APIENTRY SuspendDrawThrd (HWND, LONG); ! 65: BOOL APIENTRY ResumeDrawThrd (HWND, LONG); ! 66: BOOL StartDraw (PINFO); ! 67: BOOL StartDrawFix (PINFO); ! 68: BOOL StartDraw2 (PINFO); ! 69: BOOL StartMandelbrot (PINFO); ! 70: BOOL StartMandelbrotFix (PINFO); ! 71: HBITMAP SaveBitmap (HWND); ! 72: void DrawBitmap (HDC, PINFO, int, int, int, int); ! 73: LONG lMul(LONG, LONG); ! 74: LONG lDiv(LONG, LONG); ! 75: PINFO pGetInfoData(HWND); ! 76: BOOL bReleaseInfoData(HWND); ! 77: BOOL bCheckMutexMenuItem(HMENU, UINT); ! 78: BOOL bInitInfo(PINFO); ! 79: BOOL bResetGlobal(VOID); ! 80: HBRUSH hBrCreateBrush(HDC, DWORD); ! 81: BOOL bPrintBmp(PPRTDATA); ! 82: extern BOOL bCycle(HWND); ! 83: extern BOOL bCleanupPrinter(VOID); ! 84: extern INT iCreatePenFrPal(HDC, PVOID *); ! 85: ! 86: /******************************Public*Routine******************************\ ! 87: * ! 88: * WinMain ! 89: * ! 90: * History: ! 91: * 13-Jun-1992 -by- Petrus Wong Creates an array of pens ! 92: * 17-Apr-1991 -by- Petrus Wong ! 93: * Wrote it. ! 94: \**************************************************************************/ ! 95: ! 96: int APIENTRY WinMain( ! 97: HINSTANCE hInstance, ! 98: HINSTANCE hPrevInstance, ! 99: LPSTR lpCmdLine, ! 100: int nShowCmd) ! 101: { ! 102: MSG msg; ! 103: INT i; ! 104: ! 105: ghModule = GetModuleHandle(NULL); ! 106: if (!InitializeApp(&giPen)) { ! 107: MessageBox(ghwndMain, "memory: InitializeApp failure!", "Error", MB_OK); ! 108: return 0; ! 109: } ! 110: ! 111: if (!(ghAccel = LoadAccelerators (ghModule, MAKEINTRESOURCE(ACCEL_ID)))) ! 112: MessageBox(ghwndMain, "memory: Load Accel failure!", "Error", MB_OK); ! 113: ! 114: ! 115: while (GetMessage(&msg, NULL, 0, 0)) { ! 116: if (!TranslateAccelerator( ghwndMain, ghAccel, &msg) && ! 117: !TranslateMDISysAccel( ghwndClient, &msg) ) { ! 118: TranslateMessage(&msg); ! 119: DispatchMessage(&msg); ! 120: } ! 121: } ! 122: ! 123: // ! 124: // Delete all the pens created and free the array of hPens; ! 125: // The pens and the array of hPens was created and allocated respectively ! 126: // in InitializeApp ! 127: // ! 128: if (gprghPen != NULL) { ! 129: for (i = 0; i <= giPen; i++) { ! 130: DeleteObject((HPEN) gprghPen[i]); ! 131: } ! 132: GlobalFree(gprghPen); ! 133: } ! 134: ! 135: ! 136: return 1; ! 137: ! 138: UNREFERENCED_PARAMETER(lpCmdLine); ! 139: UNREFERENCED_PARAMETER(nShowCmd); ! 140: UNREFERENCED_PARAMETER(hInstance); ! 141: UNREFERENCED_PARAMETER(hPrevInstance); ! 142: } ! 143: ! 144: ! 145: /***************************************************************************\ ! 146: * InitializeApp ! 147: * ! 148: * History: ! 149: * 13-Jun-1992 Petrus Wong creates pens ! 150: * 29-May-1992 Petrus Wong check if device supports palette for cycling ! 151: * 09-09-91 Petrus Wong Created. ! 152: \***************************************************************************/ ! 153: ! 154: BOOL InitializeApp(INT *piPen) ! 155: { ! 156: WNDCLASS wc; ! 157: HDC hDC; ! 158: INT iNumClr; ! 159: ! 160: wc.style = CS_OWNDC; ! 161: wc.lpfnWndProc = (WNDPROC)MainWndProc; ! 162: wc.cbClsExtra = 0; ! 163: wc.cbWndExtra = sizeof(LONG); ! 164: wc.hInstance = ghModule; ! 165: wc.hIcon = LoadIcon(ghModule, MAKEINTRESOURCE(APPICON)); ! 166: wc.hCursor = LoadCursor(NULL, IDC_ARROW); ! 167: wc.hbrBackground = (HBRUSH)(COLOR_APPWORKSPACE); ! 168: wc.lpszMenuName = "MainMenu"; ! 169: wc.lpszClassName = "MandelClass"; ! 170: ! 171: if (!RegisterClass(&wc)) ! 172: return FALSE; ! 173: ! 174: wc.lpfnWndProc = (WNDPROC)ChildWndProc; ! 175: wc.hIcon = LoadIcon(ghModule, MAKEINTRESOURCE(APPICON)); ! 176: wc.lpszMenuName = NULL; ! 177: wc.lpszClassName = "ChildClass"; ! 178: ! 179: if (!RegisterClass(&wc)) ! 180: return FALSE; ! 181: ! 182: wc.style = CS_OWNDC | CS_HREDRAW | CS_VREDRAW; ! 183: wc.lpfnWndProc = (WNDPROC)TextWndProc; ! 184: wc.hIcon = NULL; ! 185: wc.hCursor = LoadCursor(NULL, IDC_ARROW); ! 186: wc.hbrBackground = (HBRUSH)(COLOR_BTNSHADOW); ! 187: wc.lpszMenuName = NULL; ! 188: wc.lpszClassName = "Text"; ! 189: ! 190: if (!RegisterClass(&wc)) ! 191: return FALSE; ! 192: ! 193: wc.style = CS_OWNDC | CS_HREDRAW | CS_VREDRAW; ! 194: wc.lpfnWndProc = (WNDPROC)JuliaWndProc; ! 195: wc.hIcon = NULL; ! 196: ! 197: // ! 198: // Nope. Can't have this, screw up my Paint Can cursor ! 199: // ! 200: //wc.hCursor = LoadCursor(NULL, IDC_ARROW); ! 201: ! 202: wc.hCursor = NULL; ! 203: wc.hbrBackground = (HBRUSH)(COLOR_BACKGROUND); ! 204: wc.lpszMenuName = NULL; ! 205: wc.lpszClassName = "Julia"; ! 206: ! 207: if (!RegisterClass(&wc)) ! 208: return FALSE; ! 209: ! 210: ! 211: // ! 212: // Notice, submenu is zero-based ! 213: // ! 214: hMenu = LoadMenu(ghModule, "MainMenu"); ! 215: hChildMenu = LoadMenu(ghModule, "ChildMenu"); ! 216: hSubMenuOne = GetSubMenu(hMenu, 1); ! 217: hSubMenuThree = GetSubMenu(hChildMenu, 8); ! 218: hPrinterMenu = GetSubMenu(hChildMenu, 7); ! 219: ! 220: // ! 221: // Disable color-cycling for display devices that does not support ! 222: // palette like the VGA. As as 29-May-1992, the MIPS display driver ! 223: // is the only one that supports palette ! 224: // ! 225: hDC = GetDC(NULL); ! 226: if (!((GetDeviceCaps(hDC, RASTERCAPS)) & RC_PALETTE)) { ! 227: EnableMenuItem(hChildMenu, MM_CYCLE, MF_GRAYED); ! 228: } ! 229: ! 230: if ((iNumClr = iCreatePenFrPal(hDC, NULL)) != 0) { ! 231: sprintf( gtext,"iNumClr = %d\n", iNumClr); ! 232: OutputDebugString( gtext); ! 233: ! 234: if ((gprghPen = (PVOID*) GlobalAlloc(GMEM_FIXED | GMEM_ZEROINIT, sizeof(HPEN)*iNumClr)) == NULL) { ! 235: MessageBox(ghwndMain, "Failed in Memory Allocation for gprghPen!", "Error", MB_OK); ! 236: } else { ! 237: if ((*piPen = iCreatePenFrPal(hDC, gprghPen)) == 0) ! 238: MessageBox(ghwndMain, "Failed in creating pen!", "Error", MB_OK); ! 239: } ! 240: } ! 241: ! 242: ReleaseDC(NULL, hDC); ! 243: ! 244: ghwndMain = CreateWindowEx(0L, "MandelClass", "Mandelbrot Dream", ! 245: WS_OVERLAPPED | WS_CAPTION | WS_BORDER | ! 246: WS_THICKFRAME | WS_MAXIMIZEBOX | WS_MINIMIZEBOX | ! 247: WS_CLIPCHILDREN | WS_VISIBLE | WS_SYSMENU, ! 248: 80, 70, 550, 550, ! 249: NULL, hMenu, ghModule, NULL); ! 250: ! 251: if (ghwndMain == NULL) ! 252: return FALSE; ! 253: ! 254: bInitPrinter(ghwndMain); ! 255: ! 256: SetWindowLong(ghwndMain, GWL_USERDATA, 0L); ! 257: ! 258: SetFocus(ghwndMain); /* set initial focus */ ! 259: ! 260: return TRUE; ! 261: } ! 262: ! 263: ! 264: /******************************Public*Routine******************************\ ! 265: * ! 266: * MainWndProc ! 267: * ! 268: * History: ! 269: * 09-Sept-1991 -by- Petrus Wong ! 270: * Wrote it. ! 271: \**************************************************************************/ ! 272: ! 273: long MainWndProc( ! 274: HWND hwnd, ! 275: UINT message, ! 276: DWORD wParam, ! 277: LONG lParam) ! 278: { ! 279: static int iJuliaCount=1; ! 280: static int iMandelCount=1; ! 281: CLIENTCREATESTRUCT clientcreate; ! 282: HWND hwndChildWindow; ! 283: static FARPROC lpfnSuspendThrd, lpfnResumeThrd; ! 284: ! 285: ! 286: switch (message) { ! 287: ! 288: case WM_CREATE: ! 289: SetWindowLong(hwnd, 0, (LONG)NULL); ! 290: ! 291: clientcreate.hWindowMenu = hSubMenuOne; ! 292: clientcreate.idFirstChild = 1; ! 293: ! 294: ghwndClient = CreateWindow("MDICLIENT", NULL, ! 295: WS_CHILD | WS_CLIPCHILDREN | WS_VISIBLE, ! 296: 0,0,0,0, ! 297: hwnd, NULL, ghModule, (LPVOID)&clientcreate); ! 298: lpfnSuspendThrd = (FARPROC)MakeProcInstance (SuspendDrawThrd, ghModule); ! 299: lpfnResumeThrd = (FARPROC)MakeProcInstance (ResumeDrawThrd, ghModule); ! 300: return 0L; ! 301: ! 302: case WM_DESTROY: { ! 303: bCleanupPrinter(); ! 304: PostQuitMessage(0); ! 305: return 0L; ! 306: } ! 307: ! 308: // ! 309: // Wait! User is going to zero out our app's visible region. This ! 310: // is going to mess up our drawing (we are not keeping any shadow ! 311: // bitmap in this version yet.) So, let's suspend our drawing thread ! 312: // first before user does that. We will resume after user is done. ! 313: // ! 314: case WM_SYSCOMMAND: { ! 315: LONG lResult; ! 316: ! 317: // ! 318: // We'll enumerate our children and suspend their drawing thread. ! 319: // ! 320: EnumChildWindows(ghwndClient, (WNDENUMPROC)lpfnSuspendThrd, lParam); ! 321: ! 322: // ! 323: // Now, let user does it supposed to do ! 324: // ! 325: lResult = DefFrameProc(hwnd, ghwndClient, message, wParam, lParam); ! 326: ! 327: // ! 328: // User's done, we'll resume the suspended threads in our children ! 329: // ! 330: EnumChildWindows(ghwndClient, (WNDENUMPROC)lpfnResumeThrd, lParam); ! 331: ! 332: return lResult; ! 333: break; ! 334: } ! 335: #if 0 ! 336: // ! 337: // Our window's size is going to change, we'll make sure the new ! 338: // window is a square. ! 339: // ! 340: case WM_WINDOWPOSCHANGING: { ! 341: PWINDOWPOS pWndPos; ! 342: RECT rect; ! 343: LONG lcx, lcy; ! 344: ! 345: GetWindowRect(hwnd, &rect); ! 346: lcx = rect.right-rect.left; ! 347: lcy = rect.bottom-rect.top; ! 348: pWndPos = (PWINDOWPOS)lParam; ! 349: if ((pWndPos->cy > lcy) || (pWndPos->cx > lcx)) ! 350: pWndPos->cx = pWndPos->cy = ! 351: ((pWndPos->cx > pWndPos->cy) ? pWndPos->cy : pWndPos->cx); ! 352: else if ((pWndPos->cy < lcy) || (pWndPos->cx < lcx)) ! 353: pWndPos->cx = pWndPos->cy = ! 354: ((pWndPos->cx > pWndPos->cy) ? pWndPos->cy : pWndPos->cx); ! 355: break; ! 356: } ! 357: #endif ! 358: case WM_COMMAND: ! 359: ! 360: switch (LOWORD(wParam)) { ! 361: case IDM_TILE: ! 362: SendMessage(ghwndClient, WM_MDITILE, 0L, 0L); ! 363: return 0L; ! 364: case IDM_CASCADE: ! 365: SendMessage(ghwndClient, WM_MDICASCADE, 0L, 0L); ! 366: return 0L; ! 367: case IDM_ARRANGE: ! 368: SendMessage(ghwndClient, WM_MDIICONARRANGE, 0L, 0L); ! 369: return 0L; ! 370: ! 371: // ! 372: // Create Julia or Mandelbrot set ! 373: // ! 374: case MM_JULIA: ! 375: case MM_MANDEL: { ! 376: HANDLE hInfo; ! 377: PINFO pInfo; ! 378: MDICREATESTRUCT mdicreate; ! 379: ! 380: hInfo = LocalAlloc(LHND, (WORD) sizeof(INFO)); ! 381: if (hInfo == NULL) { ! 382: MessageBox(ghwndMain, "Failed to Allocate Info!", "Error", MB_OK); ! 383: return 0L; ! 384: } ! 385: if ((pInfo = (PINFO)LocalLock(hInfo)) == NULL) { ! 386: MessageBox(ghwndMain, "Failed in LocalLock, hInfo", "Error", MB_OK); ! 387: return 0L; ! 388: } ! 389: ! 390: bInitInfo(pInfo); ! 391: wsprintf((LPSTR) &(pInfo->CaptionBarText), ! 392: (LOWORD(wParam) == MM_JULIA) ? "Julia %d" : "Mandelbrot %d", ! 393: (LOWORD(wParam) == MM_JULIA) ? iJuliaCount : iMandelCount ); ! 394: if (LOWORD(wParam) == MM_JULIA) { ! 395: c1 = 0.360284; ! 396: c2 = 0.100376; ! 397: lc1 = 738; //.3603515 ! 398: lc2 = 206; //.1005859 ! 399: pInfo->bMandel = FALSE; ! 400: } else { ! 401: pInfo->bMandel = TRUE; ! 402: } ! 403: ! 404: // ! 405: // Fill in the MDICREATE structure for MDI child creation ! 406: // ! 407: mdicreate.szClass = "ChildClass"; ! 408: mdicreate.szTitle = (LPTSTR)&(pInfo->CaptionBarText); ! 409: mdicreate.hOwner = ghModule; ! 410: mdicreate.x = ! 411: mdicreate.y = CW_USEDEFAULT; ! 412: mdicreate.cx = 300; ! 413: mdicreate.cy = 300; ! 414: mdicreate.style = 0L; ! 415: mdicreate.lParam = (LONG) hInfo; ! 416: ! 417: /*Create Child Window*/ ! 418: hwndChildWindow = ! 419: (HANDLE) SendMessage(ghwndClient, WM_MDICREATE, ! 420: 0L, ! 421: (LONG)(LPMDICREATESTRUCT)&mdicreate); ! 422: ! 423: if (hwndChildWindow == NULL) { ! 424: MessageBox(ghwndMain, "Failed in Creating Child Window", "Error", MB_OK); ! 425: return 0L; ! 426: } ! 427: ! 428: (LOWORD(wParam) == MM_JULIA) ? iJuliaCount++ : iMandelCount++ ; ! 429: LocalUnlock(hInfo); ! 430: return ((LONG)hwndChildWindow); ! 431: } ! 432: ! 433: case MM_ABOUT: ! 434: if (DialogBox(ghModule, "AboutBox", ghwndMain, (DLGPROC)About) == -1) ! 435: MessageBox(ghwndMain, "DEMO: About Dialog Creation Error!", "Error", MB_OK); ! 436: return 0L; ! 437: ! 438: // ! 439: // Only my children know how to deal with these messages, so ! 440: // pass these to children for processing ! 441: // ! 442: case MM_CREATE_JULIA_THREAD: ! 443: case MM_SET_XFORM_ATTR: ! 444: case MM_CREATE_MANDEL_THREAD: ! 445: case MM_OPT_4: // currently not used ! 446: case MM_DRAW_SET: ! 447: case MM_SETDIB2DEVICE: ! 448: case MM_BW: ! 449: case MM_SHIFT: ! 450: case MM_CUSTOM: ! 451: case MM_CYCLE: ! 452: case MM_FLOAT: ! 453: case MM_FIX: ! 454: case MM_ITERATION_TEN: ! 455: case MM_ITERATION_TWENTY: ! 456: case MM_ITERATION_THIRTY: ! 457: case MM_ITERATION_FIFTY: ! 458: case MM_ITERATION_DOUBLE: ! 459: case MM_STEP_ONE: ! 460: case MM_STEP_TWO: ! 461: case MM_STEP_THREE: ! 462: case MM_SAVE: ! 463: case MM_SAVE_MONO: ! 464: case MM_LOAD: ! 465: case MM_STRETCHBLT: ! 466: case MM_BITBLT: ! 467: case MM_BLACKONWHITE: ! 468: case MM_COLORONCOLOR: ! 469: case MM_WHITEONBLACK: ! 470: case MM_HALFTONE: ! 471: case MM_CLIP: ! 472: case MM_RM_CLIP: ! 473: case MM_ERASE: ! 474: case MM_PORTRAIT: ! 475: case MM_LANDSCAPE: ! 476: case MM_PRINTER: ! 477: case MM_PRINTER + 1: ! 478: case MM_PRINTER + 2: ! 479: case MM_PRINTER + 3: ! 480: case MM_PRINTER + 4: ! 481: case MM_PRINTER + 5: ! 482: case MM_PRINTER + 6: ! 483: case MM_PRINTER + 7: ! 484: case MM_PRINTER + 8: ! 485: case MM_PRINTER + 9: ! 486: { ! 487: HWND hActiveChild; ! 488: ! 489: hActiveChild = (HANDLE) SendMessage(ghwndClient, WM_MDIGETACTIVE, 0L, 0L); ! 490: if (hActiveChild) ! 491: SendMessage(hActiveChild, WM_COMMAND, wParam, lParam); ! 492: return 0L; ! 493: } ! 494: ! 495: default: ! 496: return DefFrameProc(hwnd, ghwndClient, message, wParam, lParam); ! 497: } ! 498: default: ! 499: ! 500: return DefFrameProc(hwnd, ghwndClient, message, wParam, lParam); ! 501: } ! 502: } ! 503: ! 504: /***************************************************************************\ ! 505: * ChildWndProc ! 506: * ! 507: * History: ! 508: * 04-17-91 ???? Created. ! 509: * 09-09-91 Petrus Wong Rewrote. ! 510: \***************************************************************************/ ! 511: ! 512: long ChildWndProc( ! 513: HWND hwnd, ! 514: UINT message, ! 515: DWORD wParam, ! 516: LONG lParam) ! 517: { ! 518: static FARPROC lpfnSuspendThrd, lpfnResumeThrd; ! 519: static BOOL bDIB2Device = FALSE; ! 520: ! 521: sprintf( gtext,"message = %lx\n", message); ! 522: OutputDebugString( gtext); ! 523: ! 524: switch (message) { ! 525: ! 526: case WM_COMMAND: { ! 527: PINFO pInfo; ! 528: HWND hTextWnd; ! 529: ! 530: switch (LOWORD(wParam)) { ! 531: // ! 532: // Create a Julia drawing thread ! 533: // ! 534: case MM_CREATE_JULIA_THREAD: { ! 535: if ((pInfo = pGetInfoData(hwnd)) == NULL) { ! 536: return 0L; ! 537: } ! 538: ! 539: hTextWnd = pInfo->hTextWnd; ! 540: sprintf( gtext,"(%g, %g) <-> (%g, %g)", pInfo->xFrom, pInfo->yFrom, pInfo->xTo, pInfo->yTo); ! 541: SetWindowText(hTextWnd, gtext); ! 542: sprintf( gtext,"(c1 = %g, c2 = %g)\n\n", pInfo->c1, pInfo->c2); ! 543: OutputDebugString( gtext ); ! 544: ! 545: pInfo->hThrd = CreateThread(NULL, 0, ! 546: (gFloat ? (LPTHREAD_START_ROUTINE)StartDraw : (LPTHREAD_START_ROUTINE)StartDrawFix), ! 547: pInfo, ! 548: STANDARD_RIGHTS_REQUIRED, ! 549: &pInfo->dwThreadId ); ! 550: ! 551: bReleaseInfoData(hwnd); ! 552: return 0L; ! 553: } ! 554: ! 555: // ! 556: // Reset pInfo reflecting new transformation ! 557: // ! 558: case MM_SET_XFORM_ATTR: { ! 559: if ((pInfo = pGetInfoData(hwnd)) == NULL) { ! 560: return 0L; ! 561: } ! 562: ! 563: hTextWnd = pInfo->hTextWnd; ! 564: SetWindowText(hTextWnd, "Click here for viewing info"); ! 565: ! 566: pInfo->xFrom = xFrom; ! 567: pInfo->xTo = xTo; ! 568: pInfo->yFrom = yFrom; ! 569: pInfo->yTo = yTo; ! 570: pInfo->c1 = c1; ! 571: pInfo->c2 = c2; ! 572: pInfo->lxFrom = lxFrom; ! 573: pInfo->lxTo = lxTo; ! 574: pInfo->lyFrom = lyFrom; ! 575: pInfo->lyTo = lyTo; ! 576: pInfo->lc1 = lc1; ! 577: pInfo->lc2 = lc2; ! 578: ! 579: bReleaseInfoData(hwnd); ! 580: return 0L; ! 581: } ! 582: ! 583: // ! 584: // Create a Mandelbrot drawing thread ! 585: // ! 586: case MM_CREATE_MANDEL_THREAD: { ! 587: if ((pInfo = pGetInfoData(hwnd)) == NULL) { ! 588: return 0L; ! 589: } ! 590: ! 591: hTextWnd = pInfo->hTextWnd; ! 592: sprintf( gtext,"(%g, %g) <-> (%g, %g)", pInfo->xFrom, pInfo->yFrom, pInfo->xTo, pInfo->yTo); ! 593: SetWindowText(hTextWnd, gtext); ! 594: sprintf( gtext,"(c1 = %g, c2 = %g)\n\n", pInfo->c1, pInfo->c2); ! 595: OutputDebugString( gtext ); ! 596: ! 597: pInfo->hThrd = CreateThread(NULL, 0, ! 598: (gFloat ? (LPTHREAD_START_ROUTINE)StartMandelbrot : (LPTHREAD_START_ROUTINE)StartMandelbrotFix), ! 599: pInfo, ! 600: STANDARD_RIGHTS_REQUIRED, ! 601: &pInfo->dwThreadId ); ! 602: bReleaseInfoData(hwnd); ! 603: return 0L; ! 604: } ! 605: ! 606: // ! 607: // Create a Julia drawing thread using algorithm StartDraw2 ! 608: // Currently not used ! 609: // ! 610: case MM_OPT_4: { ! 611: if ((pInfo = pGetInfoData(hwnd)) == NULL) { ! 612: return 0L; ! 613: } ! 614: ! 615: hTextWnd = pInfo->hTextWnd; ! 616: SetWindowText(hTextWnd, "MM_OPT_4"); ! 617: ! 618: sprintf( gtext,"xFrom = %g, xTo = %g, yFrom = %g, yTo = %g\n", pInfo->xFrom, pInfo->xTo, pInfo->yFrom, pInfo->yTo); ! 619: OutputDebugString( gtext ); ! 620: ! 621: pInfo->hThrd = CreateThread(NULL, 0, ! 622: (LPTHREAD_START_ROUTINE)StartDraw2, ! 623: pInfo, ! 624: STANDARD_RIGHTS_REQUIRED, ! 625: &pInfo->dwThreadId ); ! 626: ! 627: bReleaseInfoData(hwnd); ! 628: return 0L; ! 629: } ! 630: ! 631: case MM_DRAW_SET: { ! 632: if ((pInfo = pGetInfoData(hwnd)) == NULL) { ! 633: return 0L; ! 634: } ! 635: ! 636: PostMessage(hwnd, WM_COMMAND, ! 637: pInfo->bMandel ? (DWORD)((WORD)MM_CREATE_MANDEL_THREAD) : (DWORD)((WORD)MM_CREATE_JULIA_THREAD), ! 638: (LONG)0L); ! 639: ! 640: bReleaseInfoData(hwnd); ! 641: return 0L; ! 642: } ! 643: ! 644: case MM_FLOAT: { ! 645: bCheckMutexMenuItem(hChildMenu, MM_FLOAT); ! 646: DrawMenuBar(GetParent(GetParent(hwnd))) ; ! 647: gFloat = TRUE; ! 648: return 0L; ! 649: } ! 650: case MM_FIX: { ! 651: bCheckMutexMenuItem(hChildMenu, MM_FIX); ! 652: DrawMenuBar(GetParent(GetParent(hwnd))) ; ! 653: gFloat = FALSE; ! 654: return 0L; ! 655: } ! 656: case MM_ITERATION_TEN: { ! 657: bCheckMutexMenuItem(hChildMenu, MM_ITERATION_TEN); ! 658: DrawMenuBar(GetParent(GetParent(hwnd))) ; ! 659: gIteration = 10; ! 660: if ((pInfo = pGetInfoData(hwnd)) == NULL) { ! 661: return 0L; ! 662: } ! 663: pInfo->iIteration = 10; ! 664: ! 665: bReleaseInfoData(hwnd); ! 666: return 0L; ! 667: } ! 668: case MM_ITERATION_TWENTY: { ! 669: bCheckMutexMenuItem(hChildMenu, MM_ITERATION_TWENTY); ! 670: DrawMenuBar(GetParent(GetParent(hwnd))) ; ! 671: gIteration = 20; ! 672: if ((pInfo = pGetInfoData(hwnd)) == NULL){ ! 673: return 0L; ! 674: } ! 675: ! 676: pInfo->iIteration = 20; ! 677: ! 678: bReleaseInfoData(hwnd); ! 679: return 0L; ! 680: } ! 681: case MM_ITERATION_THIRTY: { ! 682: bCheckMutexMenuItem(hChildMenu, MM_ITERATION_THIRTY); ! 683: DrawMenuBar(GetParent(GetParent(hwnd))) ; ! 684: gIteration = 30; ! 685: if ((pInfo = pGetInfoData(hwnd)) == NULL) { ! 686: return 0L; ! 687: } ! 688: pInfo->iIteration = 30; ! 689: ! 690: bReleaseInfoData(hwnd); ! 691: return 0L; ! 692: } ! 693: case MM_ITERATION_FIFTY: { ! 694: bCheckMutexMenuItem(hChildMenu, MM_ITERATION_FIFTY); ! 695: DrawMenuBar(GetParent(GetParent(hwnd))) ; ! 696: gIteration = 50; ! 697: if ((pInfo = pGetInfoData(hwnd)) == NULL) { ! 698: return 0L; ! 699: } ! 700: pInfo->iIteration = 50; ! 701: ! 702: bReleaseInfoData(hwnd); ! 703: return 0L; ! 704: } ! 705: case MM_ITERATION_DOUBLE: { ! 706: bCheckMutexMenuItem(hChildMenu, MM_ITERATION_DOUBLE); ! 707: DrawMenuBar(GetParent(GetParent(hwnd))) ; ! 708: gIteration *= 2; ! 709: if ((pInfo = pGetInfoData(hwnd)) == NULL) { ! 710: return 0L; ! 711: } ! 712: pInfo->iIteration = gIteration; ! 713: ! 714: bReleaseInfoData(hwnd); ! 715: return 0L; ! 716: } ! 717: case MM_STEP_ONE: { ! 718: bCheckMutexMenuItem(hChildMenu, MM_STEP_ONE); ! 719: DrawMenuBar(GetParent(GetParent(hwnd))) ; ! 720: gStep = 1; ! 721: if ((pInfo = pGetInfoData(hwnd)) == NULL) { ! 722: return 0L; ! 723: } ! 724: pInfo->iStep = 1; ! 725: ! 726: bReleaseInfoData(hwnd); ! 727: return 0L; ! 728: } ! 729: case MM_STEP_TWO: { ! 730: bCheckMutexMenuItem(hChildMenu, MM_STEP_TWO); ! 731: DrawMenuBar(GetParent(GetParent(hwnd))) ; ! 732: gStep = 2; ! 733: if ((pInfo = pGetInfoData(hwnd)) == NULL){ ! 734: return 0L; ! 735: } ! 736: pInfo->iStep = 2; ! 737: ! 738: bReleaseInfoData(hwnd); ! 739: return 0L; ! 740: } ! 741: case MM_STEP_THREE: { ! 742: bCheckMutexMenuItem(hChildMenu, MM_STEP_THREE); ! 743: DrawMenuBar(GetParent(GetParent(hwnd))) ; ! 744: gStep = 3; ! 745: if ((pInfo = pGetInfoData(hwnd)) == NULL) { ! 746: return 0L; ! 747: } ! 748: pInfo->iStep = 3; ! 749: ! 750: bReleaseInfoData(hwnd); ! 751: return 0L; ! 752: } ! 753: ! 754: case MM_LOAD: { ! 755: HDC hDC; ! 756: OPENFILENAME ofn; ! 757: char szDirName[256]; ! 758: char szFile[256], szFileTitle[256]; ! 759: static char *szFilter; ! 760: RECT rc; ! 761: ! 762: szFilter = ! 763: "DIB files (*.bmp)\0*.bmp\0RLE files (*.rle)\0*.rle\0\0"; ! 764: ! 765: GetSystemDirectory((LPSTR) szDirName, 256); ! 766: strcpy(szFile, "*.bmp\0"); ! 767: ofn.lStructSize = sizeof(OPENFILENAME); ! 768: ofn.hwndOwner = hwnd; ! 769: ofn.lpstrFilter = szFilter; ! 770: ofn.lpstrCustomFilter = (LPSTR) NULL; ! 771: ofn.nMaxCustFilter = 0L; ! 772: ofn.nFilterIndex = 1; ! 773: ofn.lpstrFile = szFile; ! 774: ofn.nMaxFile = sizeof(szFile); ! 775: ofn.lpstrFileTitle = szFileTitle; ! 776: ofn.nMaxFileTitle = sizeof(szFileTitle); ! 777: ofn.lpstrInitialDir = szDirName; ! 778: ofn.lpstrTitle = (LPSTR) NULL; ! 779: ofn.Flags = 0L; ! 780: ofn.nFileOffset = 0; ! 781: ofn.nFileExtension = 0; ! 782: ofn.lpstrDefExt = "BMP"; ! 783: ! 784: if (!GetOpenFileName(&ofn)) ! 785: return 0L; ! 786: if ((pInfo = pGetInfoData(hwnd)) == NULL){ ! 787: return 0L; ! 788: } ! 789: GetClientRect(pInfo->hwnd, &rc); ! 790: hDC = GetDC(pInfo->hwnd); ! 791: if (LoadBitmapFile(hDC, pInfo, szFile)) ! 792: DrawBitmap(hDC, pInfo, 0, 0, rc.right, rc.bottom); ! 793: ReleaseDC(hwnd, hDC); ! 794: ! 795: bReleaseInfoData(hwnd); ! 796: ! 797: return 0L; ! 798: } ! 799: ! 800: case MM_SAVE: { ! 801: HDC hDC; ! 802: OPENFILENAME ofn; ! 803: char szDirName[256]; ! 804: char szFile[256], szFileTitle[256]; ! 805: static char *szFilter; ! 806: szFilter = "DIB files (*.bmp)\0\0"; ! 807: ! 808: if ((pInfo = pGetInfoData(hwnd)) == NULL) { ! 809: return 0L; ! 810: } ! 811: hDC = GetDC(pInfo->hwnd); ! 812: ! 813: // ! 814: // saving special effects user might have created in window ! 815: // ! 816: if (pInfo->hBmpSaved) ! 817: DeleteObject(pInfo->hBmpSaved); ! 818: pInfo->hBmpSaved = SaveBitmap(pInfo->hwnd); ! 819: ! 820: GetSystemDirectory((LPSTR) szDirName, 256); ! 821: strcpy(szFile, "*.bmp\0"); ! 822: ofn.lStructSize = sizeof(OPENFILENAME); ! 823: ofn.hwndOwner = hwnd; ! 824: ofn.lpstrFilter = szFilter; ! 825: ofn.lpstrCustomFilter = (LPSTR) NULL; ! 826: ofn.nMaxCustFilter = 0L; ! 827: ofn.nFilterIndex = 0L; ! 828: ofn.lpstrFile = szFile; ! 829: ofn.nMaxFile = sizeof(szFile); ! 830: ofn.lpstrFileTitle = szFileTitle; ! 831: ofn.nMaxFileTitle = sizeof(szFileTitle); ! 832: ofn.lpstrInitialDir = szDirName; ! 833: ofn.lpstrTitle = (LPSTR) NULL; ! 834: ofn.Flags = OFN_SHOWHELP | OFN_OVERWRITEPROMPT; ! 835: ofn.nFileOffset = 0; ! 836: ofn.nFileExtension = 0; ! 837: ofn.lpstrDefExt = (LPSTR)NULL; ! 838: ! 839: if (!GetSaveFileName(&ofn)) { ! 840: ReleaseDC(pInfo->hwnd, hDC); ! 841: bReleaseInfoData(hwnd); ! 842: return 0L; ! 843: } ! 844: ! 845: SaveBitmapFile(hDC, pInfo->hBmpSaved, szFile); ! 846: ReleaseDC(pInfo->hwnd, hDC); ! 847: ! 848: bReleaseInfoData(hwnd); ! 849: return 0L; ! 850: } ! 851: case MM_SAVE_MONO: { ! 852: HDC hDC; ! 853: OPENFILENAME ofn; ! 854: char szDirName[256]; ! 855: char szFile[256], szFileTitle[256]; ! 856: static char *szFilter; ! 857: szFilter = "DIB files (*.bmp)\0\0"; ! 858: ! 859: GetSystemDirectory((LPSTR) szDirName, 256); ! 860: strcpy(szFile, "*.bmp\0"); ! 861: ofn.lStructSize = sizeof(OPENFILENAME); ! 862: ofn.hwndOwner = hwnd; ! 863: ofn.lpstrFilter = szFilter; ! 864: ofn.lpstrCustomFilter = (LPSTR) NULL; ! 865: ofn.nMaxCustFilter = 0L; ! 866: ofn.nFilterIndex = 0L; ! 867: ofn.lpstrFile = szFile; ! 868: ofn.nMaxFile = sizeof(szFile); ! 869: ofn.lpstrFileTitle = szFileTitle; ! 870: ofn.nMaxFileTitle = sizeof(szFileTitle); ! 871: ofn.lpstrInitialDir = szDirName; ! 872: ofn.lpstrTitle = "Saving Monochrome Bitmap"; ! 873: ofn.Flags = OFN_SHOWHELP | OFN_OVERWRITEPROMPT; ! 874: ofn.nFileOffset = 0; ! 875: ofn.nFileExtension = 0; ! 876: ofn.lpstrDefExt = (LPSTR)NULL; ! 877: ! 878: if (!GetSaveFileName(&ofn)) ! 879: return 0L; ! 880: if ((pInfo = pGetInfoData(hwnd)) == NULL) { ! 881: return 0L; ! 882: } ! 883: hDC = GetDC(pInfo->hwnd); ! 884: ! 885: SaveBitmapFile(hDC, pInfo->hBmpMono, szFile); ! 886: ReleaseDC(pInfo->hwnd, hDC); ! 887: ! 888: bReleaseInfoData(hwnd); ! 889: return 0L; ! 890: } ! 891: case MM_STRETCHBLT: { ! 892: gbStretch = TRUE; ! 893: bCheckMutexMenuItem(hChildMenu, MM_STRETCHBLT); ! 894: DrawMenuBar(GetParent(GetParent(hwnd))) ; ! 895: if ((pInfo = pGetInfoData(hwnd)) == NULL){ ! 896: return 0L; ! 897: } ! 898: pInfo->bStretch = gbStretch; ! 899: InvalidateRect(pInfo->hwnd, NULL, FALSE); ! 900: ! 901: bReleaseInfoData(hwnd); ! 902: return 0L; ! 903: ! 904: } ! 905: case MM_BITBLT: { ! 906: gbStretch = FALSE; ! 907: bCheckMutexMenuItem(hChildMenu, MM_BITBLT); ! 908: DrawMenuBar(GetParent(GetParent(hwnd))) ; ! 909: if ((pInfo = pGetInfoData(hwnd)) == NULL) { ! 910: return 0L; ! 911: } ! 912: pInfo->bStretch = gbStretch; ! 913: InvalidateRect(pInfo->hwnd, NULL, FALSE); ! 914: ! 915: bReleaseInfoData(hwnd); ! 916: return 0L; ! 917: ! 918: } ! 919: case MM_BLACKONWHITE: { ! 920: giStretchMode = BLACKONWHITE; ! 921: bCheckMutexMenuItem(hChildMenu, MM_BLACKONWHITE); ! 922: DrawMenuBar(GetParent(GetParent(hwnd))) ; ! 923: if ((pInfo = pGetInfoData(hwnd)) == NULL) { ! 924: return 0L; ! 925: } ! 926: pInfo->iStretchMode = giStretchMode; ! 927: InvalidateRect(pInfo->hwnd, NULL, FALSE); ! 928: ! 929: bReleaseInfoData(hwnd); ! 930: return 0L; ! 931: ! 932: } ! 933: case MM_COLORONCOLOR: { ! 934: giStretchMode = COLORONCOLOR; ! 935: bCheckMutexMenuItem(hChildMenu, MM_COLORONCOLOR); ! 936: DrawMenuBar(GetParent(GetParent(hwnd))) ; ! 937: if ((pInfo = pGetInfoData(hwnd)) == NULL) { ! 938: return 0L; ! 939: } ! 940: pInfo->iStretchMode = giStretchMode; ! 941: InvalidateRect(pInfo->hwnd, NULL, FALSE); ! 942: ! 943: bReleaseInfoData(hwnd); ! 944: return 0L; ! 945: ! 946: } ! 947: case MM_WHITEONBLACK: { ! 948: giStretchMode = WHITEONBLACK; ! 949: bCheckMutexMenuItem(hChildMenu, MM_WHITEONBLACK); ! 950: DrawMenuBar(GetParent(GetParent(hwnd))) ; ! 951: if ((pInfo = pGetInfoData(hwnd)) == NULL) { ! 952: return 0L; ! 953: } ! 954: pInfo->iStretchMode = giStretchMode; ! 955: InvalidateRect(pInfo->hwnd, NULL, FALSE); ! 956: ! 957: bReleaseInfoData(hwnd); ! 958: return 0L; ! 959: ! 960: } ! 961: case MM_HALFTONE: { ! 962: giStretchMode = HALFTONE; ! 963: bCheckMutexMenuItem(hChildMenu, MM_HALFTONE); ! 964: DrawMenuBar(GetParent(GetParent(hwnd))) ; ! 965: if ((pInfo = pGetInfoData(hwnd)) == NULL) { ! 966: return 0L; ! 967: } ! 968: pInfo->iStretchMode = giStretchMode; ! 969: InvalidateRect(pInfo->hwnd, NULL, FALSE); ! 970: ! 971: bReleaseInfoData(hwnd); ! 972: return 0L; ! 973: } ! 974: case MM_SETDIB2DEVICE: { ! 975: if ((pInfo = pGetInfoData(hwnd)) == NULL) { ! 976: return 0L; ! 977: } ! 978: bDIB2Device = (bDIB2Device ? FALSE : TRUE); ! 979: pInfo->bSetDIBsToDevice = bDIB2Device; ! 980: CheckMenuItem(hChildMenu, MM_SETDIB2DEVICE, (bDIB2Device ? MF_CHECKED : MF_UNCHECKED)); ! 981: bReleaseInfoData(hwnd); ! 982: return 0L; ! 983: } ! 984: case MM_BW: { ! 985: HDC hDC; ! 986: ! 987: if ((pInfo = pGetInfoData(hwnd)) == NULL) { ! 988: return 0L; ! 989: } ! 990: hDC = GetDC(pInfo->hwnd); ! 991: bChangeDIBColor(hDC, pInfo, MM_BW); ! 992: ReleaseDC(hwnd, hDC); ! 993: bReleaseInfoData(hwnd); ! 994: return 0L; ! 995: } ! 996: case MM_SHIFT: { ! 997: HDC hDC; ! 998: ! 999: if ((pInfo = pGetInfoData(hwnd)) == NULL) { ! 1000: return 0L; ! 1001: } ! 1002: hDC = GetDC(pInfo->hwnd); ! 1003: bChangeDIBColor(hDC, pInfo, MM_SHIFT); ! 1004: ReleaseDC(hwnd, hDC); ! 1005: bReleaseInfoData(hwnd); ! 1006: return 0L; ! 1007: } ! 1008: case MM_CUSTOM: { ! 1009: static DWORD argbCust[16] = { ! 1010: RGB(255, 255, 255), RGB(255, 255, 255), ! 1011: RGB(255, 255, 255), RGB(255, 255, 255), ! 1012: RGB(255, 255, 255), RGB(255, 255, 255), ! 1013: RGB(255, 255, 255), RGB(255, 255, 255), ! 1014: RGB(255, 255, 255), RGB(255, 255, 255), ! 1015: RGB(255, 255, 255), RGB(255, 255, 255), ! 1016: RGB(255, 255, 255), RGB(255, 255, 255), ! 1017: RGB(255, 255, 255), RGB(255, 255, 255) ! 1018: }; ! 1019: CHOOSECOLOR cc; ! 1020: BOOL bResult; ! 1021: DWORD rgbOld; ! 1022: HBRUSH hBrush; ! 1023: HDC hDC; ! 1024: ! 1025: rgbOld = RGB(255, 255, 255); ! 1026: cc.lStructSize = sizeof(CHOOSECOLOR); ! 1027: cc.hwndOwner = ghwndMain; ! 1028: cc.hInstance = ghModule; ! 1029: cc.rgbResult = rgbOld; ! 1030: cc.lpCustColors = argbCust; ! 1031: cc.Flags = CC_RGBINIT | CC_SHOWHELP; ! 1032: cc.lCustData = 0; ! 1033: cc.lpfnHook = NULL; ! 1034: cc.lpTemplateName = NULL; ! 1035: ! 1036: bResult = ChooseColor(&cc); ! 1037: if ((pInfo = pGetInfoData(hwnd)) == NULL) { ! 1038: return 0L; ! 1039: } ! 1040: if (bResult) { ! 1041: hDC = GetDC(pInfo->hwnd); ! 1042: hBrush = hBrCreateBrush(hDC, cc.rgbResult); ! 1043: ReleaseDC(pInfo->hwnd, hDC); ! 1044: if (pInfo->hBrush) ! 1045: DeleteObject(pInfo->hBrush); ! 1046: pInfo->hBrush = hBrush; ! 1047: pInfo->bFill = TRUE; ! 1048: } ! 1049: bReleaseInfoData(hwnd); ! 1050: return 0L; ! 1051: } ! 1052: ! 1053: #ifndef CYCLETHRD ! 1054: case MM_CYCLE: { ! 1055: HDC hDC; ! 1056: ! 1057: if ((pInfo = pGetInfoData(hwnd)) == NULL) { ! 1058: return 0L; ! 1059: } ! 1060: hDC = GetDC(pInfo->hwnd); ! 1061: ! 1062: if (pInfo->bClrCycle) { ! 1063: CheckMenuItem(hChildMenu, MM_CYCLE, MF_UNCHECKED); ! 1064: pInfo->bClrCycle = FALSE; ! 1065: } else { ! 1066: CheckMenuItem(hChildMenu, MM_CYCLE, MF_CHECKED); ! 1067: pInfo->bClrCycle = TRUE; ! 1068: bChangeDIBColor(hDC, pInfo, MM_CYCLE); ! 1069: } ! 1070: ! 1071: ReleaseDC(hwnd, hDC); ! 1072: bReleaseInfoData(hwnd); ! 1073: return 0L; ! 1074: } ! 1075: #else ! 1076: ! 1077: case MM_CYCLE: { ! 1078: if ((pInfo = pGetInfoData(hwnd)) == NULL) { ! 1079: return 0L; ! 1080: } ! 1081: ! 1082: if (pInfo->bFirstTime) { ! 1083: if (!SetEvent(pInfo->hQuitEvent)) { ! 1084: MessageBox(ghwndMain, "Can't set Quit Event!", ! 1085: "Error", MB_OK); ! 1086: return 0L; ! 1087: } ! 1088: ! 1089: pInfo->hCycleThrd = CreateThread(NULL, 0, ! 1090: (LPTHREAD_START_ROUTINE)bCycle, ! 1091: hwnd, ! 1092: STANDARD_RIGHTS_REQUIRED, ! 1093: &pInfo->dwCycleThrdID ); ! 1094: pInfo->bClrCycle = TRUE; ! 1095: pInfo->bFirstTime = FALSE; ! 1096: CheckMenuItem(hChildMenu, MM_CYCLE, MF_CHECKED); ! 1097: } else { ! 1098: if (pInfo->bClrCycle) { ! 1099: CheckMenuItem(hChildMenu, MM_CYCLE, MF_UNCHECKED); ! 1100: pInfo->bClrCycle = FALSE; ! 1101: pInfo->dwSuspend = SuspendThread(pInfo->hCycleThrd); ! 1102: } else { ! 1103: CheckMenuItem(hChildMenu, MM_CYCLE, MF_CHECKED); ! 1104: pInfo->bClrCycle = TRUE; ! 1105: pInfo->dwSuspend = ResumeThread(pInfo->hCycleThrd); ! 1106: } ! 1107: if (pInfo->dwSuspend == -1) { ! 1108: (pInfo->bClrCycle ? ! 1109: sprintf( gtext,"Error in resuming thread\n") : ! 1110: sprintf( gtext,"Error in suspending thread\n") ); ! 1111: OutputDebugString( gtext ); ! 1112: } ! 1113: } ! 1114: ! 1115: bReleaseInfoData(hwnd); ! 1116: return 0L; ! 1117: } ! 1118: #endif ! 1119: case MM_CLIP: { ! 1120: if ((pInfo = pGetInfoData(hwnd)) == NULL) { ! 1121: return 0L; ! 1122: } ! 1123: ! 1124: hTextWnd = pInfo->hTextWnd; ! 1125: sprintf( gtext,"(%g, %g) <-> (%g, %g)", pInfo->xFrom, pInfo->yFrom, pInfo->xTo, pInfo->yTo); ! 1126: SetWindowText(hTextWnd, gtext); ! 1127: sprintf( gtext,"(c1 = %g, c2 = %g)\n\n", pInfo->c1, pInfo->c2); ! 1128: OutputDebugString( gtext ); ! 1129: if (!pInfo->bMandel) { ! 1130: MessageBox(ghwndMain, "Boundary Tracing and Setting clip region to the boundary points only works for Mandelbrot Set.", "Error", MB_OK); ! 1131: return 0L; ! 1132: } ! 1133: pInfo->hThrd = CreateThread(NULL, 0, ! 1134: (gFloat ? (LPTHREAD_START_ROUTINE)bBoundaryScanFix : (LPTHREAD_START_ROUTINE)bBoundaryScanFix), ! 1135: pInfo, ! 1136: STANDARD_RIGHTS_REQUIRED, ! 1137: &pInfo->dwThreadId ); ! 1138: ! 1139: bReleaseInfoData(hwnd); ! 1140: return 0L; ! 1141: } ! 1142: case MM_RM_CLIP: { ! 1143: HDC hDC; ! 1144: ! 1145: if ((pInfo = pGetInfoData(hwnd)) == NULL) { ! 1146: return 0L; ! 1147: } ! 1148: ! 1149: hDC = GetDC(pInfo->hwnd); ! 1150: SelectClipRgn(hDC, (HRGN) NULL); ! 1151: ReleaseDC(pInfo->hwnd, hDC); ! 1152: bReleaseInfoData(hwnd); ! 1153: InvalidateRect(pInfo->hwnd, NULL, FALSE); ! 1154: return 0L; ! 1155: ! 1156: } ! 1157: case MM_ERASE: { ! 1158: HDC hDC; ! 1159: RECT rc; ! 1160: ! 1161: if ((pInfo = pGetInfoData(hwnd)) == NULL) { ! 1162: return 0L; ! 1163: } ! 1164: hDC = GetDC(pInfo->hwnd); ! 1165: if (pInfo->hRgnPath != (HRGN) NULL) { ! 1166: SelectClipRgn(hDC, pInfo->hRgnPath); ! 1167: } ! 1168: SelectObject(hDC, GetStockObject(WHITE_BRUSH)); ! 1169: GetClientRect(pInfo->hwnd, &rc); ! 1170: PatBlt(hDC, 0, 0, rc.right, rc.bottom, PATCOPY); ! 1171: ReleaseDC(pInfo->hwnd, hDC); ! 1172: bReleaseInfoData(hwnd); ! 1173: return 0L; ! 1174: } ! 1175: case MM_PORTRAIT: { ! 1176: giDmOrient = DMORIENT_PORTRAIT; ! 1177: bCheckMutexMenuItem(hChildMenu, MM_PORTRAIT); ! 1178: DrawMenuBar(GetParent(GetParent(hwnd))) ; ! 1179: return 0L; ! 1180: } ! 1181: case MM_LANDSCAPE: { ! 1182: giDmOrient = DMORIENT_LANDSCAPE; ! 1183: bCheckMutexMenuItem(hChildMenu, MM_LANDSCAPE); ! 1184: DrawMenuBar(GetParent(GetParent(hwnd))) ; ! 1185: return 0L; ! 1186: } ! 1187: case MM_PRINTER: ! 1188: case MM_PRINTER + 1: ! 1189: case MM_PRINTER + 2: ! 1190: case MM_PRINTER + 3: ! 1191: case MM_PRINTER + 4: ! 1192: case MM_PRINTER + 5: ! 1193: case MM_PRINTER + 6: ! 1194: case MM_PRINTER + 7: ! 1195: case MM_PRINTER + 8: ! 1196: ! 1197: #ifdef PRTTHRD ! 1198: case MM_PRINTER + 9: { ! 1199: PINFO pInfo; ! 1200: PRTDATA PrtData, *pPrtData; ! 1201: ULONG sizINFO; ! 1202: PBYTE pjTmpInfo, pjTmp; ! 1203: ! 1204: if ((pInfo = pGetInfoData(hwnd)) == NULL) { ! 1205: return 0L; ! 1206: } ! 1207: ! 1208: if (pInfo->hBmpSaved == NULL) { ! 1209: MessageBox(ghwndMain, "No Saved bitmap to print", "Error", MB_OK); ! 1210: return 0L; ! 1211: } ! 1212: ! 1213: // ! 1214: // Copy the info structure to PrtData ! 1215: // ! 1216: pPrtData = &PrtData; ! 1217: pjTmp = (PBYTE)&(pPrtData->info); ! 1218: pjTmpInfo = (PBYTE)pInfo; ! 1219: sizINFO = sizeof(INFO); ! 1220: ! 1221: while(sizINFO--) ! 1222: { ! 1223: *(((PBYTE)pjTmp)++) = *((pjTmpInfo)++); ! 1224: } ! 1225: ! 1226: PrtData.index = LOWORD(wParam) - MM_PRINTER; ! 1227: ! 1228: if (giDmOrient == DMORIENT_PORTRAIT) { ! 1229: PrtData.bUseDefault = TRUE; ! 1230: } else { ! 1231: PrtData.bUseDefault = FALSE; ! 1232: PrtData.DevMode.dmSize = sizeof(DEVMODE); ! 1233: PrtData.DevMode.dmDriverExtra = 0; ! 1234: PrtData.DevMode.dmOrientation = DMORIENT_LANDSCAPE; ! 1235: PrtData.DevMode.dmFields = DM_ORIENTATION; ! 1236: } ! 1237: ! 1238: pInfo->hPrtThrd = CreateThread(NULL, 0, ! 1239: (LPTHREAD_START_ROUTINE)bPrintBmp, ! 1240: &PrtData, ! 1241: STANDARD_RIGHTS_REQUIRED, ! 1242: &pInfo->dwPrtThrdID ); ! 1243: ! 1244: bReleaseInfoData(hwnd); ! 1245: return 0L; ! 1246: } ! 1247: ! 1248: #else ! 1249: case MM_PRINTER + 9: { ! 1250: HDC hdcPrinter, hDC; ! 1251: int index; ! 1252: DEVMODE devmode; ! 1253: DEVMODE *pdevmode; ! 1254: PINFO pInfo; ! 1255: int iWidth, iHeight; ! 1256: ! 1257: ! 1258: index = LOWORD(wParam) - MM_PRINTER; ! 1259: ! 1260: if (giDmOrient == DMORIENT_PORTRAIT) ! 1261: pdevmode = NULL; ! 1262: else { ! 1263: pdevmode = &devmode; ! 1264: devmode.dmSize = sizeof(DEVMODE); ! 1265: devmode.dmDriverExtra = 0; ! 1266: devmode.dmOrientation = DMORIENT_LANDSCAPE; ! 1267: devmode.dmFields = DM_ORIENTATION; ! 1268: } ! 1269: ! 1270: if (!(hdcPrinter = CreateDC( "", gpszPrinterNames[index], ! 1271: "", pdevmode))) ! 1272: { ! 1273: return(0L); ! 1274: } ! 1275: ! 1276: if ((pInfo = pGetInfoData(hwnd)) == NULL) { ! 1277: return 0L; ! 1278: } ! 1279: ! 1280: iWidth = GetDeviceCaps(hdcPrinter, HORZRES); ! 1281: iHeight = GetDeviceCaps(hdcPrinter, VERTRES); ! 1282: ! 1283: if (pInfo->hBmpSaved) ! 1284: DeleteObject(pInfo->hBmpSaved); ! 1285: ! 1286: pInfo->hBmpSaved = SaveBitmap(pInfo->hwnd); ! 1287: ! 1288: Escape(hdcPrinter, STARTDOC, 20, "Mandelbrot", NULL); ! 1289: DrawBitmap(hdcPrinter, pInfo, 0, 0, iWidth, iHeight); ! 1290: Escape(hdcPrinter, NEWFRAME, NULL, NULL, NULL); ! 1291: Escape(hdcPrinter, ENDDOC, NULL, NULL, NULL); ! 1292: ReleaseDC(pInfo->hwnd, hDC); ! 1293: bReleaseInfoData(hwnd); ! 1294: DeleteDC(hdcPrinter); ! 1295: return 0L; ! 1296: } ! 1297: #endif ! 1298: default: ! 1299: return 0L; ! 1300: ! 1301: } ! 1302: ! 1303: } ! 1304: case WM_SETFOCUS: ! 1305: break; ! 1306: ! 1307: case WM_MDIACTIVATE: { ! 1308: PINFO pInfo; ! 1309: ! 1310: if ((pInfo = pGetInfoData(hwnd)) == NULL) { ! 1311: return 0L; ! 1312: } ! 1313: ! 1314: if ((HWND) lParam == hwnd) { ! 1315: SendMessage(GetParent(hwnd), WM_MDISETMENU, ! 1316: (DWORD) hChildMenu, ! 1317: (LONG) hSubMenuThree) ; ! 1318: DrawMenuBar(GetParent(GetParent(hwnd))) ; ! 1319: ! 1320: (pInfo->bClrCycle ? ! 1321: CheckMenuItem(hChildMenu, MM_CYCLE, MF_CHECKED) : ! 1322: CheckMenuItem(hChildMenu, MM_CYCLE, MF_UNCHECKED) ); ! 1323: } ! 1324: ! 1325: bReleaseInfoData(hwnd); ! 1326: return 0L; ! 1327: } ! 1328: #if 0 ! 1329: case WM_WINDOWPOSCHANGING: { ! 1330: PWINDOWPOS pWndPos; ! 1331: PINFO pInfo; ! 1332: HWND hTextWnd; ! 1333: int iCyText, iCxBorder, iCyBorder, iCyCaption; ! 1334: RECT rect, rcl; ! 1335: LONG lcx, lcy; ! 1336: ! 1337: if ((pInfo = pGetInfoData(hwnd)) == NULL) { ! 1338: break; ! 1339: } ! 1340: ! 1341: hTextWnd = pInfo->hTextWnd; ! 1342: ! 1343: bReleaseInfoData(hwnd); ! 1344: ! 1345: iCyText = GetWindowLong(hTextWnd, GWL_USERDATA); ! 1346: iCxBorder = GetSystemMetrics(SM_CXBORDER); ! 1347: iCyBorder = GetSystemMetrics(SM_CYBORDER); ! 1348: iCyCaption = GetSystemMetrics(SM_CYCAPTION) - iCyBorder; ! 1349: GetClientRect(GetParent(hwnd), &rcl); ! 1350: GetWindowRect(hwnd, &rect); ! 1351: lcx = rect.right-rect.left; ! 1352: lcy = rect.bottom-rect.top; ! 1353: pWndPos = (PWINDOWPOS)lParam; ! 1354: if ((pWndPos->cy > lcy) || (pWndPos->cx > lcx)) { ! 1355: pWndPos->cx = ! 1356: ((pWndPos->cx > pWndPos->cy) ? pWndPos->cy-iCyText : pWndPos->cx); ! 1357: pWndPos->cy = pWndPos->cx + iCyText; ! 1358: } else { if ((pWndPos->cy < lcy) || (pWndPos->cx < lcx)) { ! 1359: pWndPos->cx = ! 1360: ((pWndPos->cx > pWndPos->cy) ? pWndPos->cy-iCyText : pWndPos->cx); ! 1361: pWndPos->cy = pWndPos->cx + iCyText; ! 1362: } ! 1363: } ! 1364: break; ! 1365: } ! 1366: #endif ! 1367: case WM_SIZE: { ! 1368: HANDLE hThrd; ! 1369: PINFO pInfo; ! 1370: HWND hTextWnd, hJulia; ! 1371: BOOL bMandel; ! 1372: WORD wCx; ! 1373: int iCyText; ! 1374: ! 1375: if ((pInfo = pGetInfoData(hwnd)) == NULL) { ! 1376: break; ! 1377: } ! 1378: ! 1379: hTextWnd = pInfo->hTextWnd; ! 1380: hJulia = pInfo->hwnd; ! 1381: hThrd = pInfo->hThrd; ! 1382: bMandel = pInfo->bMandel; ! 1383: bReleaseInfoData(hwnd); ! 1384: iCyText = GetWindowLong(hTextWnd, GWL_USERDATA); ! 1385: wCx = (WORD) (HIWORD(lParam) - iCyText); ! 1386: ! 1387: MoveWindow(hJulia, 0, 0, ! 1388: LOWORD(lParam), ! 1389: wCx, ! 1390: TRUE); ! 1391: ! 1392: MoveWindow(hTextWnd, ! 1393: 0, ! 1394: wCx, ! 1395: LOWORD(lParam), ! 1396: iCyText, ! 1397: TRUE); ! 1398: ! 1399: if (hThrd) { ! 1400: TerminateThread(hThrd, (DWORD)0L); ! 1401: /* ! 1402: PostMessage(hwnd, WM_COMMAND, ! 1403: bMandel ? (DWORD)((WORD)MM_CREATE_MANDEL_THREAD) : (DWORD)((WORD)MM_CREATE_JULIA_THREAD), ! 1404: (LONG)0L); ! 1405: */ ! 1406: } ! 1407: ! 1408: break; ! 1409: } ! 1410: ! 1411: // ! 1412: // display info in the status window ! 1413: // ! 1414: case WM_USER+0xa: { ! 1415: PINFO pInfo; ! 1416: static ULONG ulClick = 0; ! 1417: HWND hTextWnd; ! 1418: ! 1419: ulClick++; ! 1420: if ((pInfo = pGetInfoData(hwnd)) == NULL) { ! 1421: return 0L; ! 1422: } ! 1423: ! 1424: hTextWnd = pInfo->hTextWnd; ! 1425: switch (ulClick % 6) { ! 1426: case 0: sprintf( gtext,"%g <= x <= %g, %g <= y <= %g", pInfo->xFrom, pInfo->xTo, pInfo->yTo, pInfo->yFrom); ! 1427: break; ! 1428: case 1: sprintf( gtext,"c1 = %g, c2 = %g", pInfo->c1, pInfo->c2); ! 1429: break; ! 1430: case 2: sprintf( gtext,"Elapsed Time = %ld", (ULONG) pInfo->dwElapsed); ! 1431: break; ! 1432: case 3: sprintf( gtext,"Iteration = %d", pInfo->iIteration); ! 1433: break; ! 1434: case 4: sprintf( gtext,"Step = %d", pInfo->iStep); ! 1435: break; ! 1436: case 5: (gFloat ? sprintf( gtext,"Floating point math") ! 1437: : sprintf( gtext,"Fix point math")) ; ! 1438: break; ! 1439: ! 1440: default: break; ! 1441: } ! 1442: SetWindowText(hTextWnd, gtext); ! 1443: bReleaseInfoData(hwnd); ! 1444: return 0L; ! 1445: } ! 1446: ! 1447: case WM_SYSCOMMAND: { ! 1448: LONG lResult; ! 1449: ! 1450: EnumChildWindows(ghwndClient, (WNDENUMPROC)lpfnSuspendThrd, lParam); ! 1451: ! 1452: lResult = DefMDIChildProc(hwnd, message, wParam, lParam); ! 1453: ! 1454: EnumChildWindows(ghwndClient, (WNDENUMPROC)lpfnResumeThrd, lParam); ! 1455: ! 1456: return lResult; ! 1457: break; ! 1458: } ! 1459: ! 1460: case WM_CREATE: { ! 1461: PINFO pInfo; ! 1462: HANDLE hInfo; ! 1463: HWND hTextWnd, hJulia; ! 1464: RECT rcl; ! 1465: ! 1466: // ! 1467: // CR! MakeProcInstance is noop! ! 1468: // ! 1469: lpfnSuspendThrd = (FARPROC)MakeProcInstance (SuspendDrawThrd, ghModule); ! 1470: lpfnResumeThrd = (FARPROC)MakeProcInstance (ResumeDrawThrd, ghModule); ! 1471: ! 1472: hTextWnd = CreateWindow("Text", NULL, ! 1473: WS_BORDER | SS_LEFT | WS_CHILD | WS_VISIBLE, ! 1474: 0, 0, 0, 0, ! 1475: hwnd, ! 1476: (HMENU) 2, ! 1477: ghModule, ! 1478: NULL); ! 1479: ! 1480: GetClientRect(hwnd, &rcl); ! 1481: hJulia = CreateWindow("Julia", (LPSTR) NULL, ! 1482: WS_CHILD | WS_VISIBLE | ! 1483: WS_BORDER, ! 1484: 0,0, rcl.right-rcl.left, ! 1485: rcl.bottom-rcl.top-GetWindowLong(hTextWnd, GWL_USERDATA), ! 1486: hwnd, (HMENU)1, ghModule, (LPVOID)NULL); ! 1487: ! 1488: SetWindowText(hTextWnd, "Select the 'Draw Set' menu item to start drawing."); ! 1489: hInfo = (HANDLE) ((LPMDICREATESTRUCT) ((LPCREATESTRUCT) lParam)->lpCreateParams)->lParam ; ! 1490: if (hInfo) { ! 1491: if ((pInfo = (PINFO)LocalLock(hInfo)) == NULL) { ! 1492: MessageBox(ghwndMain, "Failed in LocalLock, hNode", "Error", MB_OK); ! 1493: break; ! 1494: } else { ! 1495: if (!GetClientRect(hwnd, &pInfo->rcClient)) ! 1496: MessageBox(ghwndMain, "Failed in GetClientRect!", "Error", MB_OK); ! 1497: ! 1498: pInfo->hTextWnd = hTextWnd; ! 1499: pInfo->hwnd = hJulia; ! 1500: #ifdef CYCLETHRD ! 1501: // ! 1502: // Creating a signal quit color cycling event ! 1503: // ! 1504: if ((pInfo->hQuitEvent = CreateEvent(NULL, TRUE, TRUE, NULL)) == NULL) ! 1505: MessageBox(ghwndMain, "Failed in creating Quit Event!", "Error", MB_OK); ! 1506: #endif ! 1507: SetWindowLong(hwnd, 0, (LONG) hInfo); ! 1508: LocalUnlock(hInfo); ! 1509: } ! 1510: } else { ! 1511: MessageBox(ghwndMain, "Can't allocate hInfo!", "Error", MB_OK); ! 1512: } ! 1513: ! 1514: #if 0 ! 1515: // ! 1516: // Initialize printers here will detect printers availiability ! 1517: // more often, but kind of overkill. ! 1518: // ! 1519: bInitPrinter(hwnd); ! 1520: #endif ! 1521: break; ! 1522: } ! 1523: ! 1524: case WM_CLOSE: { ! 1525: SendMessage(GetParent(hwnd), WM_MDISETMENU, ! 1526: (DWORD) hMenu, ! 1527: (LONG) hSubMenuOne) ; ! 1528: DrawMenuBar(GetParent(GetParent(hwnd))) ; ! 1529: break; ! 1530: } ! 1531: ! 1532: case WM_DESTROY: { ! 1533: PINFO pInfo; ! 1534: if ((pInfo = pGetInfoData(hwnd)) == NULL) { ! 1535: break; ! 1536: } ! 1537: ! 1538: TerminateThread(pInfo->hThrd, (DWORD)0L); ! 1539: TerminateThread(pInfo->hPrtThrd, (DWORD)0L); ! 1540: ! 1541: #ifdef CYCLETHRD ! 1542: // ! 1543: // Cleanup color cycling ! 1544: // ! 1545: if (!ResetEvent(pInfo->hQuitEvent)) ! 1546: MessageBox(ghwndMain, "Failed in reseting quit event!", "Error", MB_OK); ! 1547: #endif ! 1548: if (pInfo->hBmpMono) ! 1549: DeleteObject(pInfo->hBmpMono); ! 1550: ! 1551: if (pInfo->hBmpSaved) ! 1552: DeleteObject(pInfo->hBmpSaved); ! 1553: ! 1554: if (pInfo->hBrush) ! 1555: DeleteObject(pInfo->hBrush); ! 1556: ! 1557: bReleaseInfoData(hwnd); ! 1558: LocalFree((HANDLE) GetWindowLong(hwnd, 0)); ! 1559: break; ! 1560: } ! 1561: ! 1562: default: ! 1563: return DefMDIChildProc(hwnd, message, wParam, lParam); ! 1564: ! 1565: } //switch ! 1566: return DefMDIChildProc(hwnd, message, wParam, lParam); ! 1567: } ! 1568: ! 1569: /***************************************************************************\ ! 1570: * About ! 1571: * ! 1572: * About dialog proc. ! 1573: * ! 1574: * History: ! 1575: * 04-13-91 ???? Created. ! 1576: * 09-09-91 Petrus Wong Rewrote. ! 1577: \***************************************************************************/ ! 1578: ! 1579: long About( ! 1580: HWND hDlg, ! 1581: UINT message, ! 1582: DWORD wParam, ! 1583: LONG lParam) ! 1584: { ! 1585: switch (message) { ! 1586: case WM_INITDIALOG: ! 1587: return TRUE; ! 1588: ! 1589: case WM_COMMAND: ! 1590: if (wParam == IDOK) ! 1591: EndDialog(hDlg, wParam); ! 1592: break; ! 1593: } ! 1594: ! 1595: return FALSE; ! 1596: ! 1597: UNREFERENCED_PARAMETER(lParam); ! 1598: UNREFERENCED_PARAMETER(hDlg); ! 1599: } ! 1600: ! 1601: /************************************************************************* ! 1602: * ! 1603: * TextWndProc ! 1604: * ! 1605: * Text Window proc. ! 1606: * ! 1607: * History: ! 1608: * 10-07-91 Petrus Wong Created. ! 1609: * ! 1610: \***************************************************************************/ ! 1611: ! 1612: LONG TextWndProc (HWND hwnd, UINT message, DWORD wParam, LONG lParam) ! 1613: { ! 1614: static HFONT hFont = (HFONT) NULL; ! 1615: ! 1616: switch (message) ! 1617: { ! 1618: case WM_CREATE: ! 1619: { ! 1620: LOGFONT lf; ! 1621: HDC hDC; ! 1622: HFONT hOldFont; ! 1623: TEXTMETRIC tm; ! 1624: RECT rect; ! 1625: LONG lHeight; ! 1626: ! 1627: SystemParametersInfo(SPI_GETICONTITLELOGFONT, sizeof(lf), (PVOID) &lf, FALSE); ! 1628: ! 1629: hDC = GetDC(hwnd); ! 1630: // this is the height for 8 point size font in pixels ! 1631: lf.lfHeight = 8 * GetDeviceCaps(hDC, LOGPIXELSY) / 72; ! 1632: ! 1633: hFont = CreateFontIndirect(&lf); ! 1634: hOldFont = SelectObject(hDC, hFont); ! 1635: GetTextMetrics(hDC, &tm); ! 1636: GetClientRect(GetParent(hwnd), &rect); ! 1637: ! 1638: // base the height of the window on size of text ! 1639: lHeight = tm.tmHeight+6*GetSystemMetrics(SM_CYBORDER)+2; ! 1640: // saved the height for later reference ! 1641: SetWindowLong(hwnd, GWL_USERDATA, lHeight); ! 1642: SetWindowPos(hwnd, NULL, ! 1643: 0, ! 1644: rect.bottom-lHeight, ! 1645: rect.right-rect.left, ! 1646: lHeight, ! 1647: SWP_NOZORDER | SWP_NOMOVE); ! 1648: ! 1649: ReleaseDC(hwnd, hDC); ! 1650: break; ! 1651: } ! 1652: ! 1653: case WM_LBUTTONDOWN: { ! 1654: PostMessage(GetParent(hwnd), WM_USER+0xa, (DWORD)0L, (LONG)0L); ! 1655: break; ! 1656: } ! 1657: ! 1658: case WM_DESTROY: ! 1659: if (hFont) ! 1660: DeleteObject(hFont); ! 1661: break; ! 1662: ! 1663: case WM_SETTEXT: ! 1664: DefWindowProc(hwnd, message, wParam, lParam); ! 1665: InvalidateRect(hwnd,NULL,TRUE); ! 1666: UpdateWindow(hwnd); ! 1667: return 0L; ! 1668: ! 1669: case WM_PAINT: ! 1670: { ! 1671: PAINTSTRUCT ps; ! 1672: RECT rc; ! 1673: char ach[128]; ! 1674: int len, nxBorder, nyBorder; ! 1675: HFONT hOldFont = NULL; ! 1676: ! 1677: BeginPaint(hwnd, &ps); ! 1678: ! 1679: GetClientRect(hwnd,&rc); ! 1680: ! 1681: nxBorder = GetSystemMetrics(SM_CXBORDER); ! 1682: rc.left += 9*nxBorder; ! 1683: rc.right -= 9*nxBorder; ! 1684: ! 1685: nyBorder = GetSystemMetrics(SM_CYBORDER); ! 1686: rc.top += 3*nyBorder; ! 1687: rc.bottom -= 3*nyBorder; ! 1688: ! 1689: // 3D Text ! 1690: len = GetWindowText(hwnd, ach, sizeof(ach)); ! 1691: SetBkColor(ps.hdc, GetSysColor(COLOR_BTNFACE)); ! 1692: ! 1693: SetBkMode(ps.hdc, TRANSPARENT); ! 1694: SetTextColor(ps.hdc, RGB(64,96,96)); ! 1695: if (hFont) ! 1696: hOldFont = SelectObject(ps.hdc, hFont); ! 1697: ExtTextOut(ps.hdc, rc.left+2*nxBorder+2, rc.top+2, ETO_OPAQUE | ETO_CLIPPED, ! 1698: &rc, ach, len, NULL); ! 1699: ! 1700: SetTextColor(ps.hdc, RGB(128,128,128)); ! 1701: if (hFont) ! 1702: hOldFont = SelectObject(ps.hdc, hFont); ! 1703: ExtTextOut(ps.hdc, rc.left+2*nxBorder+1, rc.top+1, ETO_CLIPPED, ! 1704: &rc, ach, len, NULL); ! 1705: ! 1706: SetTextColor(ps.hdc, RGB(255,255,255)); ! 1707: if (hFont) ! 1708: hOldFont = SelectObject(ps.hdc, hFont); ! 1709: ExtTextOut(ps.hdc, rc.left+2*nxBorder, rc.top, ETO_CLIPPED, ! 1710: &rc, ach, len, NULL); ! 1711: ! 1712: SetBkMode(ps.hdc, OPAQUE); ! 1713: ! 1714: if (hOldFont) ! 1715: SelectObject(ps.hdc, hOldFont); ! 1716: ! 1717: EndPaint(hwnd, &ps); ! 1718: return 0L; ! 1719: } ! 1720: } ! 1721: return DefWindowProc(hwnd, message, wParam, lParam); ! 1722: } ! 1723: ! 1724: ! 1725: /**************************************************************************\ ! 1726: * ! 1727: * JuliaWndProc ! 1728: * ! 1729: * History: ! 1730: * 14-Jun-1992 -by- Petrus Wong removed pens except red & black ! 1731: * 22-Nov-1991 -by- Petrus Wong ! 1732: * Wrote it. ! 1733: \**************************************************************************/ ! 1734: ! 1735: LONG JuliaWndProc (HWND hwnd, UINT message, DWORD wParam, LONG lParam) ! 1736: { ! 1737: // ! 1738: // These statics are shared by all the Julia windows. But, this is ! 1739: // fine because only one Julia window is tracking at any one time. ! 1740: // Ideally, we should place this in the per-window INFO data structure. ! 1741: // But, this is not necessary. ! 1742: // ! 1743: static BOOL bTrack = FALSE; ! 1744: static int OrgX, OrgY; ! 1745: static int PrevX, PrevY; ! 1746: static HDC hDC; ! 1747: static HCURSOR hCurArrow, hCurPaintCan; ! 1748: ! 1749: switch (message) ! 1750: { ! 1751: case WM_CREATE: { ! 1752: ! 1753: hpnRed = CreatePen(PS_SOLID, 0, RGB(0xFF, 0, 0)); ! 1754: hpnGreen = CreatePen(PS_SOLID, 0, RGB(0, 0xFF, 0)); ! 1755: hpnBlack = CreatePen(PS_SOLID, 0, RGB(0, 0, 0)); ! 1756: ! 1757: hCurPaintCan = LoadCursor(ghModule, MAKEINTRESOURCE(PAINTCURSOR)); ! 1758: hCurArrow = LoadCursor(NULL, IDC_ARROW); ! 1759: break; ! 1760: } ! 1761: ! 1762: case WM_DESTROY: { ! 1763: ! 1764: DeleteObject(hpnRed); ! 1765: DeleteObject(hpnGreen); ! 1766: DeleteObject(hpnBlack); ! 1767: break; ! 1768: } ! 1769: case WM_PAINT: ! 1770: { ! 1771: PAINTSTRUCT ps; ! 1772: HWND hParent; ! 1773: PINFO pInfo; ! 1774: HDC hDC; ! 1775: RECT rc; ! 1776: ! 1777: GetClientRect(hwnd,&rc); ! 1778: hDC = BeginPaint(hwnd, &ps); ! 1779: EndPaint(hwnd, &ps); ! 1780: if ((hParent=GetParent(hwnd)) == NULL) { ! 1781: MessageBox(ghwndMain, "Can't get hParent!", "Error", MB_OK); ! 1782: return 0L; ! 1783: } ! 1784: if ((pInfo = pGetInfoData(hParent)) == NULL) { ! 1785: return 0L; ! 1786: } ! 1787: ! 1788: if (pInfo->hBmpSaved) { ! 1789: hDC = GetDC(hwnd); ! 1790: DrawBitmap(hDC, pInfo, 0, 0, rc.right, rc.bottom); ! 1791: ReleaseDC(hwnd, hDC); ! 1792: } ! 1793: bReleaseInfoData(hParent); ! 1794: ! 1795: //EndPaint(hwnd, &ps); ! 1796: return 0L; ! 1797: } ! 1798: ! 1799: case WM_RBUTTONDOWN: { ! 1800: RECT rc; ! 1801: HANDLE hParent; ! 1802: PINFO pInfo; ! 1803: int x, y; ! 1804: HWND hJulia; ! 1805: HANDLE hTextWnd; ! 1806: ! 1807: x = (int) LOWORD(lParam); ! 1808: y = (int) HIWORD(lParam); ! 1809: if ((hParent=GetParent(hwnd)) == NULL) { ! 1810: MessageBox(ghwndMain, "Can't get hParent!", "Error", MB_OK); ! 1811: break; ! 1812: } ! 1813: ! 1814: if ((pInfo = pGetInfoData(hParent)) == NULL) { ! 1815: break; ! 1816: } ! 1817: ! 1818: hTextWnd = pInfo->hTextWnd; ! 1819: ! 1820: if (GetWindowLong(GetParent(hwnd), GWL_STYLE) & WS_MAXIMIZE) { ! 1821: GetClientRect(ghwndMain, &rc); ! 1822: rc.bottom -= GetWindowLong(hTextWnd,GWL_USERDATA); ! 1823: } else { ! 1824: GetClientRect(hwnd, &rc); ! 1825: } ! 1826: ! 1827: if (pInfo->bMandel) { ! 1828: ! 1829: hJulia = (HWND) SendMessage(ghwndMain, WM_COMMAND, ! 1830: (DWORD)((WORD)MM_JULIA), 0L); ! 1831: if (hJulia) { ! 1832: //GetClientRect(hwnd, &rc); ! 1833: // ! 1834: // calculate the c value corresponding to the point ! 1835: // ! 1836: c1 = Xform((double) x, 0.0, (double) rc.right, pInfo->xFrom, pInfo->xTo); ! 1837: c2 = Xform((double) y, 0.0, (double) rc.bottom, pInfo->yFrom, pInfo->yTo); ! 1838: lc1 = XformFix(x, 0, rc.right, pInfo->lxFrom, pInfo->lxTo); ! 1839: lc2 = XformFix(y, 0, rc.bottom, pInfo->lyFrom, pInfo->lyTo); ! 1840: ! 1841: sprintf( gtext,"(c1 = %g, c2 = %g)\n", c1, c2); ! 1842: OutputDebugString( gtext ); ! 1843: ! 1844: // ! 1845: // Reset globals to default values for creating Julia set ! 1846: // (Entire set, not zoom in) ! 1847: // ! 1848: bResetGlobal(); ! 1849: PostMessage(hJulia, WM_COMMAND, (DWORD)((WORD) MM_SET_XFORM_ATTR), 0L); ! 1850: } else { ! 1851: MessageBox(ghwndMain, "Can't create hJulia!", "Error", MB_OK); ! 1852: } ! 1853: } ! 1854: bReleaseInfoData(hParent); ! 1855: break; ! 1856: } ! 1857: case WM_LBUTTONDOWN: { ! 1858: HANDLE hParent; ! 1859: PINFO pInfo; ! 1860: int x, y; ! 1861: DWORD dwRGB; ! 1862: HBRUSH hBrOld; ! 1863: ! 1864: x = (int) LOWORD(lParam); ! 1865: y = (int) HIWORD(lParam); ! 1866: if ((hParent=GetParent(hwnd)) == NULL) { ! 1867: MessageBox(ghwndMain, "Can't get hParent!", "Error", MB_OK); ! 1868: break; ! 1869: } ! 1870: ! 1871: if ((pInfo = pGetInfoData(hParent)) == NULL) { ! 1872: break; ! 1873: } ! 1874: ! 1875: if (pInfo->bFill) { ! 1876: hDC = GetDC(hwnd); ! 1877: hBrOld = SelectObject(hDC, pInfo->hBrush); ! 1878: dwRGB = GetPixel(hDC, x, y); ! 1879: ExtFloodFill(hDC, x, y, (COLORREF)dwRGB, FLOODFILLSURFACE); ! 1880: SelectObject(hDC, hBrOld); ! 1881: ReleaseDC(hwnd, hDC); ! 1882: pInfo->bFill = FALSE; ! 1883: ! 1884: if (pInfo->hBmpSaved) ! 1885: DeleteObject(pInfo->hBmpSaved); ! 1886: ! 1887: pInfo->hBmpSaved = SaveBitmap(hwnd); ! 1888: SetCursor(hCurArrow); ! 1889: } else { ! 1890: bTrack = TRUE; ! 1891: OrgX = PrevX = x = LOWORD(lParam); ! 1892: OrgY = PrevY = y = HIWORD(lParam); ! 1893: ! 1894: hDC = GetDC(hwnd); ! 1895: SetCapture(hwnd); ! 1896: } ! 1897: bReleaseInfoData(hParent); ! 1898: break; ! 1899: } ! 1900: case WM_MOUSEMOVE: { ! 1901: RECT rectClient; ! 1902: int NextX; ! 1903: int NextY; ! 1904: HANDLE hParent; ! 1905: PINFO pInfo; ! 1906: ! 1907: if ((hParent=GetParent(hwnd)) == NULL) { ! 1908: MessageBox(ghwndMain, "Can't get hParent!", "Error", MB_OK); ! 1909: break; ! 1910: } ! 1911: ! 1912: if ((pInfo = pGetInfoData(hParent)) == NULL) { ! 1913: break; ! 1914: } ! 1915: ! 1916: if (pInfo->bFill) { ! 1917: SetCursor(hCurPaintCan); ! 1918: } else { ! 1919: SetCursor(hCurArrow); ! 1920: } ! 1921: ! 1922: bReleaseInfoData(hParent); ! 1923: ! 1924: // Update the selection region ! 1925: if (bTrack) { ! 1926: NextX = (SHORT) LOWORD(lParam); ! 1927: NextY = (SHORT) HIWORD(lParam); ! 1928: ! 1929: // Do not draw outside the window's client area ! 1930: ! 1931: GetClientRect (hwnd, &rectClient); ! 1932: if (NextX < rectClient.left) { ! 1933: NextX = rectClient.left; ! 1934: } else if (NextX >= rectClient.right) { ! 1935: NextX = rectClient.right - 1; ! 1936: } ! 1937: if (NextY < rectClient.top) { ! 1938: NextY = rectClient.top; ! 1939: } else if (NextY >= rectClient.bottom) { ! 1940: NextY = rectClient.bottom - 1; ! 1941: } ! 1942: if ((NextX != PrevX) || (NextY != PrevY)) { ! 1943: SetROP2(hDC, R2_NOT); // Erases the previous box ! 1944: ! 1945: MoveToEx(hDC, OrgX, OrgY, NULL); ! 1946: LineTo(hDC, OrgX, PrevY); ! 1947: LineTo(hDC, PrevX, PrevY); ! 1948: LineTo(hDC, PrevX, OrgY); ! 1949: LineTo(hDC, OrgX, OrgY); ! 1950: // Get the current mouse position ! 1951: ! 1952: PrevX = NextX; ! 1953: PrevY = NextY; ! 1954: MoveToEx(hDC, OrgX, OrgY, NULL); // Draws the new box ! 1955: LineTo(hDC, OrgX, PrevY); ! 1956: LineTo(hDC, PrevX, PrevY); ! 1957: LineTo(hDC, PrevX, OrgY); ! 1958: LineTo(hDC, OrgX, OrgY); ! 1959: } ! 1960: } ! 1961: break; ! 1962: ! 1963: } ! 1964: ! 1965: case WM_LBUTTONUP: { ! 1966: RECT rc; ! 1967: HANDLE hParent; ! 1968: PINFO pInfo; ! 1969: int NextX; ! 1970: int NextY; ! 1971: int iDistX, iDistY, iAbsDstX, iAbsDstY; ! 1972: HWND hZoom; ! 1973: HANDLE hTextWnd; ! 1974: ! 1975: if (!bTrack) ! 1976: break; ! 1977: ! 1978: // End the selection ! 1979: ReleaseCapture(); ! 1980: bTrack = FALSE; ! 1981: ! 1982: MoveToEx(hDC, OrgX, OrgY, NULL); // Erases the box ! 1983: LineTo(hDC, OrgX, PrevY); ! 1984: LineTo(hDC, PrevX, PrevY); ! 1985: LineTo(hDC, PrevX, OrgY); ! 1986: LineTo(hDC, OrgX, OrgY); ! 1987: ! 1988: NextX = LOWORD(lParam); ! 1989: NextY = HIWORD(lParam); ! 1990: ! 1991: iDistX = NextX - OrgX; ! 1992: iDistY = NextY - OrgY; ! 1993: iAbsDstX = (iDistX > 0 ? iDistX : -iDistX); ! 1994: iAbsDstY = (iDistY > 0 ? iDistY : -iDistY); ! 1995: if (iAbsDstX > iAbsDstY) { ! 1996: NextY = OrgY + (iDistY > 0 ? iAbsDstX : -iAbsDstX); ! 1997: } else if (iAbsDstX < iAbsDstY) { ! 1998: NextX = OrgX + (iDistX > 0 ? iAbsDstY : -iAbsDstY); ! 1999: } ! 2000: ! 2001: MoveToEx(hDC, OrgX, OrgY, NULL); // Draws the new box ! 2002: LineTo(hDC, OrgX, NextY); ! 2003: LineTo(hDC, NextX, NextY); ! 2004: LineTo(hDC, NextX, OrgY); ! 2005: LineTo(hDC, OrgX, OrgY); ! 2006: ! 2007: SetROP2(hDC, R2_COPYPEN); ! 2008: ! 2009: ReleaseDC(hwnd, hDC); ! 2010: if ((hParent=GetParent(hwnd)) == NULL) { ! 2011: MessageBox(ghwndMain, "Can't get hParent!", "Error", MB_OK); ! 2012: break; ! 2013: } ! 2014: ! 2015: if ((pInfo = pGetInfoData(hParent)) == NULL) { ! 2016: break; ! 2017: } ! 2018: ! 2019: hTextWnd = pInfo->hTextWnd; ! 2020: sprintf(gtext, "Mouse (%d, %d), (%d, %d)\n", OrgX, OrgY, NextX, NextY); ! 2021: //SetWindowText(hTextWnd, gtext); ! 2022: OutputDebugString(gtext); ! 2023: ! 2024: ! 2025: if (GetWindowLong(GetParent(hwnd), GWL_STYLE) & WS_MAXIMIZE) { ! 2026: ! 2027: GetClientRect(ghwndMain, &rc); ! 2028: rc.bottom -= GetWindowLong(hTextWnd,GWL_USERDATA); ! 2029: sprintf(gtext, "(%d, %d), (%d, %d)\n", rc.left, rc.top, rc.right, rc.bottom); ! 2030: //SetWindowText(hTextWnd, gtext); ! 2031: OutputDebugString(gtext); ! 2032: ! 2033: } else { ! 2034: GetClientRect(hwnd, &rc); ! 2035: } ! 2036: ! 2037: if ((OrgX == NextX) && (OrgY == NextY)) { ! 2038: bReleaseInfoData(hParent); ! 2039: break; ! 2040: } ! 2041: ! 2042: hZoom = (HWND) SendMessage(ghwndMain, WM_COMMAND, ! 2043: pInfo->bMandel ? (DWORD)((WORD)MM_MANDEL) : (DWORD)((WORD)MM_JULIA), ! 2044: 0L); ! 2045: if (hZoom) { ! 2046: //GetClientRect(hwnd, &rc); ! 2047: xFrom = Xform((double) OrgX, 0.0, (double) rc.right, pInfo->xFrom, pInfo->xTo); ! 2048: xTo = Xform((double) NextX, 0.0, (double) rc.right, pInfo->xFrom, pInfo->xTo); ! 2049: yFrom = Xform((double) OrgY, 0.0, (double) rc.bottom, pInfo->yFrom, pInfo->yTo); ! 2050: yTo = Xform((double) NextY, 0.0, (double) rc.bottom, pInfo->yFrom, pInfo->yTo); ! 2051: lxFrom = XformFix(OrgX, 0, rc.right, pInfo->lxFrom, pInfo->lxTo); ! 2052: lxTo = XformFix(NextX, 0, rc.right, pInfo->lxFrom, pInfo->lxTo); ! 2053: lyFrom = XformFix(OrgY, 0, rc.bottom, pInfo->lyFrom, pInfo->lyTo); ! 2054: lyTo = XformFix(NextY, 0, rc.bottom, pInfo->lyFrom, pInfo->lyTo); ! 2055: if (!pInfo->bMandel) { ! 2056: c1 = pInfo->c1; ! 2057: c2 = pInfo->c2; ! 2058: lc1 = pInfo->lc1; ! 2059: lc2 = pInfo->lc2; ! 2060: } ! 2061: PostMessage(hZoom, WM_COMMAND, (DWORD)((WORD) MM_SET_XFORM_ATTR), 0L); ! 2062: } else { ! 2063: MessageBox(ghwndMain, "Can't create hZoom!", "Error", MB_OK); ! 2064: } ! 2065: bReleaseInfoData(hParent); ! 2066: break; ! 2067: } // case WM_LBUTTONUP ! 2068: } // switch ! 2069: return DefWindowProc(hwnd, message, wParam, lParam); ! 2070: } ! 2071: ! 2072: ! 2073: /******************************Public*Routine******************************\ ! 2074: * ! 2075: * SuspendDrawThrd ! 2076: * ! 2077: * Effects: Enumerates all the MDI children. Suspending the drawing thread ! 2078: * in those windows, if any. ! 2079: * ! 2080: * Warnings: assumes the MDI children has class name "ChildClass." ! 2081: * ! 2082: * History: ! 2083: * 09-Dec-1991 -by- Petrus Wong ! 2084: * Wrote it. ! 2085: \**************************************************************************/ ! 2086: ! 2087: ! 2088: BOOL APIENTRY SuspendDrawThrd (HWND hwnd, LONG lParam) { ! 2089: HANDLE hThrd; ! 2090: PINFO pInfo; ! 2091: DWORD dwSuspend; ! 2092: BOOL bDrawing; ! 2093: char sz[30]; ! 2094: ! 2095: GetClassName(hwnd, sz, 15); ! 2096: if (strcmp(sz, "ChildClass") != 0) ! 2097: return 1L; ! 2098: if ((pInfo = pGetInfoData(hwnd)) == NULL) { ! 2099: return 1L; ! 2100: } ! 2101: ! 2102: bDrawing = pInfo->bDrawing; ! 2103: hThrd = pInfo->hThrd; ! 2104: bReleaseInfoData(hwnd); ! 2105: ! 2106: if (hThrd && bDrawing) { ! 2107: dwSuspend = SuspendThread(hThrd); ! 2108: sprintf( gtext,"\nSuspend: dwSuspend = %d, dwSuspend = %g\n", dwSuspend, dwSuspend); ! 2109: OutputDebugString( gtext ); ! 2110: ! 2111: if (dwSuspend == -1) { ! 2112: sprintf( gtext,"Error in suspending thread\n"); ! 2113: OutputDebugString( gtext ); ! 2114: } ! 2115: } ! 2116: return 1L; ! 2117: UNREFERENCED_PARAMETER(lParam); ! 2118: } ! 2119: ! 2120: ! 2121: /******************************Public*Routine******************************\ ! 2122: * ! 2123: * ResumeDrawThrd ! 2124: * ! 2125: * Effects: Enumerates all the MDI children. Resuming the drawing thread ! 2126: * in those windows, if any. ! 2127: * ! 2128: * Warnings: Assumes the MDI children has class name "ChildClass." Also, ! 2129: * assumes the drawing has been suspended by SuspendDrawThrd. ! 2130: * ! 2131: * History: ! 2132: * 09-Dec-1991 -by- Petrus Wong ! 2133: * Wrote it. ! 2134: \**************************************************************************/ ! 2135: ! 2136: ! 2137: BOOL APIENTRY ResumeDrawThrd (HWND hwnd, LONG lParam) { ! 2138: HANDLE hThrd; ! 2139: PINFO pInfo; ! 2140: DWORD dwSuspend; ! 2141: BOOL bDrawing; ! 2142: char sz[30]; ! 2143: ! 2144: GetClassName(hwnd, sz, 15); ! 2145: if (strcmp(sz, "ChildClass") != 0) ! 2146: return 1L; ! 2147: if ((pInfo = pGetInfoData(hwnd)) == NULL) { ! 2148: return 1L; ! 2149: } ! 2150: ! 2151: bDrawing = pInfo->bDrawing; ! 2152: hThrd = pInfo->hThrd; ! 2153: bReleaseInfoData(hwnd); ! 2154: ! 2155: if (hThrd && bDrawing) { ! 2156: dwSuspend = ResumeThread(hThrd); ! 2157: sprintf( gtext,"Resume: dwSuspend = %d, dwSuspend = %g\n", dwSuspend, dwSuspend); ! 2158: OutputDebugString( gtext ); ! 2159: ! 2160: if (dwSuspend == -1) { ! 2161: sprintf( gtext,"Error in resuming thread\n"); ! 2162: OutputDebugString( gtext ); ! 2163: } ! 2164: } ! 2165: return 1L; ! 2166: UNREFERENCED_PARAMETER(lParam); ! 2167: } ! 2168: ! 2169: ! 2170: /******************************Public*Routine******************************\ ! 2171: * ! 2172: * lMul ! 2173: * ! 2174: * Effects: Fix point multiplication ! 2175: * ! 2176: * Warnings: 20.11 fix point representation used. This is only good for ! 2177: * multiplication in a limited range. Will overflow. ! 2178: * CR! Will be implemented as macros in the future ! 2179: * ! 2180: * History: ! 2181: * 20-Nov-1991 -by- Petrus Wong ! 2182: * Wrote it. ! 2183: \**************************************************************************/ ! 2184: ! 2185: LONG lMul(LONG l1, LONG l2) ! 2186: { ! 2187: return( (l1 * l2) >> 11); ! 2188: } ! 2189: ! 2190: /******************************Public*Routine******************************\ ! 2191: * ! 2192: * lDiv ! 2193: * ! 2194: * Effects: fix point division ! 2195: * ! 2196: * Warnings: 20.11 fix point representation used. This is only good for ! 2197: * division in a limited range. Will overflow. ! 2198: * CR! Will be implemented as macros in the future ! 2199: * ! 2200: * History: ! 2201: * 20-Nov-1991 -by- Petrus Wong ! 2202: * Wrote it. ! 2203: \**************************************************************************/ ! 2204: ! 2205: LONG lDiv(long l1, long l2) ! 2206: { ! 2207: return( (l1 << 11) / l2); ! 2208: } ! 2209: ! 2210: ! 2211: /**************************************************************************\ ! 2212: * ! 2213: * StartDrawFix ! 2214: * 2 ! 2215: * Effects: Draw'g the Julia Set for Q (z) = z + c, where z, c are complex ! 2216: * c ! 2217: * Fact: |Q (0)| = |c| > 2, the orbit of 0 escapes immediately ! 2218: * c ! 2219: * claim: |z| >= |c| = 2 + l, l > 0 escapes under Q ! 2220: * c ! 2221: * The Julia Set: Basin Boundaries algorithm. ! 2222: * ! 2223: * Warnings: ! 2224: * ! 2225: * History: ! 2226: * 14-Jun-1992 -by- Petrus Wong Modified to use the pen array ! 2227: * 20-Nov-1991 -by- Petrus Wong ! 2228: * Wrote it. ! 2229: \**************************************************************************/ ! 2230: BOOL StartDrawFix(PINFO pInfo) ! 2231: { ! 2232: DWORD dwTick1; ! 2233: HDC hDC; ! 2234: RECT rc; ! 2235: ! 2236: int m, n, i, iPrev; ! 2237: int xCurr, yCurr; ! 2238: int iPen; ! 2239: ! 2240: LONG c1, c2; ! 2241: LONG x0, y0, x1, y1, x, y, z; ! 2242: ! 2243: iPen = giPen + 1; ! 2244: iPrev = FIRST_PIXEL; // a big value to signal the first pixel ! 2245: //iPrev = pInfo->iIteration + FIRST_PIXEL; ! 2246: c1 = pInfo->lc1; ! 2247: c2 = pInfo->lc2; ! 2248: ! 2249: pInfo->bMandel = FALSE; ! 2250: pInfo->bDrawing = TRUE; ! 2251: hDC = GetDC(pInfo->hwnd); ! 2252: ! 2253: GetClientRect(pInfo->hwnd, &rc); ! 2254: yCurr = rc.top; ! 2255: ! 2256: dwTick1 = GetTickCount(); ! 2257: ! 2258: for (n=rc.top; n<=rc.bottom; n+=pInfo->iStep, yCurr+=pInfo->iStep, iPrev = FIRST_PIXEL) { ! 2259: xCurr = rc.left; // since LineTo excludes last point ! 2260: MoveToEx(hDC, 0, yCurr, NULL); ! 2261: y0 = XformFix(n, rc.top, rc.bottom, pInfo->lyFrom, pInfo->lyTo); ! 2262: ! 2263: for (m=rc.left; m<=rc.right; m++, xCurr++) { ! 2264: x0 = XformFix(m, rc.left, rc.right, pInfo->lxFrom, pInfo->lxTo); ! 2265: x = x0; ! 2266: y = y0; ! 2267: ! 2268: for (i=1; i<=pInfo->iIteration; i++) { ! 2269: x1 = lMul(x - y, x + y) + c1; // Z = x1 + i x2 ! 2270: ! 2271: y1 = (lMul(x, y) * 2) + c2; ! 2272: x = x1; ! 2273: y = y1; // 2 2 2 1/2 2 ! 2274: z = lMul(x, x) + lMul(y, y); // |Z| = ((x1 + x2 ) ) > 2 ! 2275: ! 2276: if (z > 8192) ! 2277: break; ! 2278: } ! 2279: ! 2280: if (i != iPrev) ! 2281: { ! 2282: if (iPrev != FIRST_PIXEL) ! 2283: { ! 2284: switch(iPrev) ! 2285: { ! 2286: case 1: SelectObject(hDC, hpnRed); break; ! 2287: default: ! 2288: ! 2289: if (iPrev >= pInfo->iIteration) { ! 2290: SelectObject(hDC, hpnBlack); ! 2291: break; ! 2292: } ! 2293: SelectObject(hDC, (HPEN)gprghPen[iPrev % iPen]); ! 2294: break; ! 2295: } ! 2296: iPrev = i; ! 2297: LineTo(hDC,xCurr,yCurr); ! 2298: } ! 2299: else ! 2300: iPrev = i; // remember the color for the first pixel ! 2301: } ! 2302: } ! 2303: switch(i) ! 2304: { ! 2305: case 1: SelectObject(hDC, hpnRed); break; ! 2306: default: ! 2307: if (iPrev >= pInfo->iIteration) { ! 2308: SelectObject(hDC, hpnBlack); ! 2309: break; ! 2310: } ! 2311: SelectObject(hDC, (HPEN)gprghPen[i % iPen]); ! 2312: break; ! 2313: } ! 2314: ! 2315: LineTo(hDC,xCurr,yCurr); ! 2316: } ! 2317: ReleaseDC(pInfo->hwnd, hDC); ! 2318: ! 2319: pInfo->dwElapsed = GetTickCount() - dwTick1; ! 2320: ! 2321: if (pInfo->hBmpSaved) ! 2322: DeleteObject(pInfo->hBmpSaved); ! 2323: ! 2324: pInfo->hBmpSaved = SaveBitmap(pInfo->hwnd); ! 2325: pInfo->bDrawing = FALSE; ! 2326: ! 2327: ExitThread(0); ! 2328: if (!CloseHandle(pInfo->hThrd)) ! 2329: MessageBox(ghwndMain, "Failed in CloseHandle!", "Error", MB_OK); ! 2330: ! 2331: return TRUE; ! 2332: } ! 2333: ! 2334: /**************************************************************************\ ! 2335: * ! 2336: * StartDraw ! 2337: * 2 ! 2338: * Effects: Draw'g the Julia Set for Q (z) = z + c, where z, c are complex ! 2339: * c ! 2340: * Fact: |Q (0)| = |c| > 2, the orbit of 0 escapes immediately ! 2341: * c ! 2342: * claim: |z| >= |c| = 2 + l, l > 0 escapes under Q ! 2343: * c ! 2344: * The Julia Set: Basin Boundaries algorithm. ! 2345: * ! 2346: * Warnings: ! 2347: * ! 2348: * History: ! 2349: * 14-Jun-1992 -by- Petrus Wong Modified to use the pen array and LineTo ! 2350: * 20-Nov-1991 -by- Petrus Wong ! 2351: * Wrote it. ! 2352: \**************************************************************************/ ! 2353: BOOL StartDraw(PINFO pInfo) ! 2354: { ! 2355: DWORD dwTick1; ! 2356: HDC hDC; ! 2357: RECT rc; ! 2358: ! 2359: int m, n, i, iPrev; ! 2360: int xCurr, yCurr; ! 2361: int iPen; ! 2362: ! 2363: double c1, c2; ! 2364: double x0, y0, x1, y1, x, y, z; ! 2365: ! 2366: ! 2367: iPen = giPen + 1; ! 2368: iPrev = FIRST_PIXEL; // a big value to signal the first pixel ! 2369: //iPrev = pInfo->iIteration + FIRST_PIXEL; ! 2370: c1 = pInfo->c1; ! 2371: c2 = pInfo->c2; ! 2372: ! 2373: pInfo->bMandel = FALSE; ! 2374: pInfo->bDrawing = TRUE; ! 2375: hDC = GetDC(pInfo->hwnd); ! 2376: ! 2377: GetClientRect(pInfo->hwnd, &rc); ! 2378: yCurr = rc.top; ! 2379: ! 2380: dwTick1 = GetTickCount(); ! 2381: ! 2382: for (n=rc.top; n<=rc.bottom; n+=pInfo->iStep, yCurr+=pInfo->iStep, iPrev = FIRST_PIXEL) { ! 2383: xCurr = rc.left; // since LineTo excludes last point ! 2384: MoveToEx(hDC, 0, yCurr, NULL); ! 2385: y0 = Xform((double) n, 0.0, (double) rc.bottom, pInfo->yFrom, pInfo->yTo); ! 2386: ! 2387: for (m=rc.left; m<=rc.right; m++, xCurr++) { ! 2388: x0 = Xform((double) m, 0.0, (double) rc.right, pInfo->xFrom, pInfo->xTo); ! 2389: x = x0; ! 2390: y = y0; ! 2391: ! 2392: for (i=1; i<=pInfo->iIteration; i++) { ! 2393: x1 = (x - y) * (x + y) + c1; // Z = x1 + i x2 ! 2394: ! 2395: y1 = 2 * x * y + c2; ! 2396: x = x1; ! 2397: y = y1; // 2 2 2 1/2 2 ! 2398: z = x * x + y * y; // |Z| = ((x1 + x2 ) ) > 2 ! 2399: ! 2400: if (z > 4.0) ! 2401: break; ! 2402: } ! 2403: ! 2404: if (i != iPrev) ! 2405: { ! 2406: if (iPrev != FIRST_PIXEL) ! 2407: { ! 2408: switch(iPrev) ! 2409: { ! 2410: case 1: SelectObject(hDC, hpnRed); break; ! 2411: default: ! 2412: ! 2413: if (iPrev >= pInfo->iIteration) { ! 2414: SelectObject(hDC, hpnBlack); ! 2415: break; ! 2416: } ! 2417: SelectObject(hDC, (HPEN)gprghPen[iPrev % iPen]); ! 2418: break; ! 2419: } ! 2420: iPrev = i; ! 2421: LineTo(hDC,xCurr,yCurr); ! 2422: } ! 2423: else ! 2424: iPrev = i; // remember the color for the first pixel ! 2425: } ! 2426: } ! 2427: switch(i) ! 2428: { ! 2429: case 1: SelectObject(hDC, hpnRed); break; ! 2430: default: ! 2431: if (iPrev >= pInfo->iIteration) { ! 2432: SelectObject(hDC, hpnBlack); ! 2433: break; ! 2434: } ! 2435: SelectObject(hDC, (HPEN)gprghPen[i % iPen]); ! 2436: break; ! 2437: } ! 2438: ! 2439: LineTo(hDC,xCurr,yCurr); ! 2440: } ! 2441: ReleaseDC(pInfo->hwnd, hDC); ! 2442: ! 2443: pInfo->dwElapsed = GetTickCount() - dwTick1; ! 2444: ! 2445: if (pInfo->hBmpSaved) ! 2446: DeleteObject(pInfo->hBmpSaved); ! 2447: ! 2448: pInfo->hBmpSaved = SaveBitmap(pInfo->hwnd); ! 2449: pInfo->bDrawing = FALSE; ! 2450: ! 2451: ExitThread(0); ! 2452: if (!CloseHandle(pInfo->hThrd)) ! 2453: MessageBox(ghwndMain, "Failed in CloseHandle!", "Error", MB_OK); ! 2454: ! 2455: return TRUE; ! 2456: } ! 2457: ! 2458: /**************************************************************************\ ! 2459: * ! 2460: * StartDraw2 ! 2461: * 2 ! 2462: * Effects: Draw'g the Julia Set for Q (z) = z + c, where z, c are complex ! 2463: * ! 2464: * The Julia Set: Backward iteration algorithm. ! 2465: * ! 2466: * Warnings: ! 2467: * ! 2468: * History: ! 2469: * 20-Nov-1991 -by- Petrus Wong ! 2470: * Wrote it. ! 2471: \**************************************************************************/ ! 2472: ! 2473: BOOL StartDraw2(PINFO pInfo) ! 2474: { ! 2475: HDC hDC; ! 2476: RECT rc; ! 2477: int m, n, i; ! 2478: double c1, c2; ! 2479: double x0, y0, w0, w1, pi, theta, r; ! 2480: ! 2481: pi = 22.0/7.0; ! 2482: c1 = 0.360284; ! 2483: c2 = 0.100376; ! 2484: x0 = 1.5; ! 2485: y0 = 1.5; ! 2486: ! 2487: hDC = GetDC(pInfo->hwnd); ! 2488: ! 2489: GetClientRect(pInfo->hwnd, &rc); ! 2490: for (i=0; i<=15000; i++) { ! 2491: w0 = x0 - c1; ! 2492: w1 = y0 - c2; ! 2493: sprintf( gtext,"w(%g, %g) xy(%g, %g)\n", w0, w1, x0, y0); ! 2494: OutputDebugString( gtext ); ! 2495: ! 2496: if (w0 == 0.0) { ! 2497: theta = pi/2; ! 2498: sprintf( gtext,"(w0 == 0.0) theta = %g\n\n", theta); ! 2499: OutputDebugString( gtext ); ! 2500: ! 2501: } else { ! 2502: if (w0 > 0.0) { ! 2503: theta = atan(w1/w0); ! 2504: sprintf( gtext,"(w0 > 0.0) theta = %g\n\n", theta); ! 2505: OutputDebugString( gtext ); ! 2506: ! 2507: } else { // w0 < 0.0 ! 2508: theta = pi + atan(w1/w0); ! 2509: sprintf( gtext,"(w0 < 0.0) theta = %g\n\n", theta); ! 2510: OutputDebugString( gtext ); ! 2511: } ! 2512: } ! 2513: r = sqrt(w0 * w0 + w1 + w1); ! 2514: theta = theta/2.0 + ((int) ((2.0*rand()/(RAND_MAX+1.0)))*pi); ! 2515: r = sqrt(r); ! 2516: x0 = r*cos(theta); ! 2517: y0 = r*sin(theta); ! 2518: if (i > 50) { ! 2519: m = Xform2(x0, pInfo->xFrom, pInfo->xTo, 0.0, (double) rc.right); ! 2520: n = Xform2(y0, pInfo->yFrom, pInfo->yTo, 0.0, (double) rc.bottom); ! 2521: SetPixel(hDC, m, n, 0x000000ff); ! 2522: } ! 2523: } ! 2524: ! 2525: ReleaseDC(pInfo->hwnd, hDC); ! 2526: ! 2527: ExitThread(0); ! 2528: if (!CloseHandle(pInfo->hThrd)) ! 2529: MessageBox(ghwndMain, "Failed in CloseHandle!", "Error", MB_OK); ! 2530: ! 2531: return TRUE; ! 2532: } ! 2533: ! 2534: /**************************************************************************\ ! 2535: * ! 2536: * StartMandelbrotFix ! 2537: * 2 ! 2538: * Effects: Draw'g the Mandelbrot Set for Q (z) = z + c, where z, c complex ! 2539: * ! 2540: * Warnings: ! 2541: * ! 2542: * History: ! 2543: * 14-Jun-1992 -by- Petrus Wong Modified to use the pen array ! 2544: * 20-Nov-1991 -by- Petrus Wong ! 2545: * Wrote it. ! 2546: \**************************************************************************/ ! 2547: BOOL StartMandelbrotFix(PINFO pInfo) ! 2548: { ! 2549: DWORD dwTick1; ! 2550: HDC hDC; ! 2551: RECT rc; ! 2552: int m, n, i, iPrev; ! 2553: int xCurr, yCurr; ! 2554: int iPen; ! 2555: ! 2556: LONG c1, c2; ! 2557: LONG x1, y1, x, y, r; ! 2558: ! 2559: iPen = giPen + 1; ! 2560: pInfo->bMandel = TRUE; ! 2561: pInfo->bDrawing = TRUE; ! 2562: hDC = GetDC(pInfo->hwnd); ! 2563: ! 2564: GetClientRect(pInfo->hwnd, &rc); ! 2565: ! 2566: dwTick1 = GetTickCount(); ! 2567: yCurr = rc.top; ! 2568: for (n=rc.top; n<=rc.bottom; n+=pInfo->iStep, yCurr+=pInfo->iStep, iPrev = FIRST_PIXEL) { ! 2569: xCurr = rc.left; // since LineTo excludes last point ! 2570: MoveToEx(hDC, 0, yCurr, NULL); ! 2571: c2 = XformFix(n, rc.top, rc.bottom, pInfo->lyFrom, pInfo->lyTo); ! 2572: ! 2573: for (m=rc.left; m<=rc.right; m++, xCurr++) { ! 2574: c1 = XformFix(m, rc.left, rc.right, pInfo->lxFrom, pInfo->lxTo); ! 2575: x = c1; ! 2576: y = c2; ! 2577: ! 2578: for (i=1; i<=pInfo->iIteration; i++) { ! 2579: x1 = lMul(x - y, x + y) + c1; ! 2580: y1 = (lMul(x, y) * 2) + c2; ! 2581: r = lMul(x1, x1) + lMul(y1, y1); ! 2582: x = x1; ! 2583: y = y1; ! 2584: if (r > 8192) { ! 2585: break; ! 2586: } ! 2587: } ! 2588: ! 2589: if (i != iPrev) { ! 2590: if (iPrev != FIRST_PIXEL) { ! 2591: switch(iPrev) { ! 2592: case 1: SelectObject(hDC, hpnRed); break; ! 2593: default: ! 2594: if (iPrev >= pInfo->iIteration) { ! 2595: SelectObject(hDC, hpnBlack); ! 2596: break; ! 2597: } ! 2598: SelectObject(hDC, (HPEN)gprghPen[iPrev % iPen]); ! 2599: break; ! 2600: } ! 2601: iPrev = i; ! 2602: LineTo(hDC, xCurr, yCurr); ! 2603: } ! 2604: else ! 2605: iPrev = i; // remember the color for the first pixel ! 2606: } ! 2607: } ! 2608: ! 2609: switch(i) ! 2610: { ! 2611: case 1: SelectObject(hDC, hpnRed); break; ! 2612: default: ! 2613: if (i >= pInfo->iIteration) { ! 2614: SelectObject(hDC, hpnBlack); ! 2615: break; ! 2616: } ! 2617: SelectObject(hDC, (HPEN)gprghPen[i % iPen]); ! 2618: break; ! 2619: } ! 2620: ! 2621: LineTo(hDC,xCurr,yCurr); ! 2622: ! 2623: } ! 2624: ReleaseDC(pInfo->hwnd, hDC); ! 2625: ! 2626: pInfo->dwElapsed = GetTickCount() - dwTick1; ! 2627: ! 2628: if (pInfo->hBmpSaved) ! 2629: DeleteObject(pInfo->hBmpSaved); ! 2630: ! 2631: pInfo->hBmpSaved = SaveBitmap(pInfo->hwnd); ! 2632: pInfo->bDrawing = FALSE; ! 2633: ! 2634: ExitThread(0); ! 2635: if (!CloseHandle(pInfo->hThrd)) ! 2636: MessageBox(ghwndMain, "Failed in CloseHandle!", "Error", MB_OK); ! 2637: ! 2638: return TRUE; ! 2639: } ! 2640: ! 2641: /**************************************************************************\ ! 2642: * ! 2643: * StartMandelbrot ! 2644: * 2 ! 2645: * Effects: Draw'g the Mandelbrot Set for Q (z) = z + c, where z, c complex ! 2646: * ! 2647: * Warnings: ! 2648: * ! 2649: * History: ! 2650: * 14-Jun-1992 -by- Petrus Wong Modified to use the pen array and LineTo ! 2651: * 20-Nov-1991 -by- Petrus Wong ! 2652: * Wrote it. ! 2653: \**************************************************************************/ ! 2654: BOOL StartMandelbrot(PINFO pInfo) ! 2655: { ! 2656: DWORD dwTick1; ! 2657: HDC hDC; ! 2658: RECT rc; ! 2659: int m, n, i, iPrev; ! 2660: int xCurr, yCurr; ! 2661: int iPen; ! 2662: ! 2663: double c1, c2; ! 2664: double x1, y1, x, y, r; ! 2665: ! 2666: iPen = giPen + 1; ! 2667: pInfo->bMandel = TRUE; ! 2668: pInfo->bDrawing = TRUE; ! 2669: hDC = GetDC(pInfo->hwnd); ! 2670: ! 2671: GetClientRect(pInfo->hwnd, &rc); ! 2672: ! 2673: dwTick1 = GetTickCount(); ! 2674: yCurr = rc.top; ! 2675: for (n=rc.top; n<=rc.bottom; n+=pInfo->iStep, yCurr+=pInfo->iStep, iPrev = FIRST_PIXEL) { ! 2676: xCurr = rc.left; // since LineTo excludes last point ! 2677: MoveToEx(hDC, 0, yCurr, NULL); ! 2678: c2 = Xform((double) n, 0.0, (double) rc.bottom, pInfo->yFrom, pInfo->yTo); ! 2679: ! 2680: for (m=rc.left; m<=rc.right; m++, xCurr++) { ! 2681: c1 = Xform((double) m, 0.0, (double) rc.right, pInfo->xFrom, pInfo->xTo); ! 2682: x = c1; ! 2683: y = c2; ! 2684: ! 2685: for (i=1; i<=pInfo->iIteration; i++) { ! 2686: x1 = (x - y) * (x + y) + c1; ! 2687: y1 = 2 * x * y + c2; ! 2688: r = x1 * x1 + y1 * y1; ! 2689: x = x1; ! 2690: y = y1; ! 2691: if (r > 4.0) { ! 2692: break; ! 2693: } ! 2694: } ! 2695: ! 2696: if (i != iPrev) { ! 2697: if (iPrev != FIRST_PIXEL) { ! 2698: switch(iPrev) { ! 2699: case 1: SelectObject(hDC, hpnRed); break; ! 2700: default: ! 2701: if (iPrev >= pInfo->iIteration) { ! 2702: SelectObject(hDC, hpnBlack); ! 2703: break; ! 2704: } ! 2705: SelectObject(hDC, (HPEN)gprghPen[iPrev % iPen]); ! 2706: break; ! 2707: } ! 2708: iPrev = i; ! 2709: LineTo(hDC, xCurr, yCurr); ! 2710: } ! 2711: else ! 2712: iPrev = i; // remember the color for the first pixel ! 2713: } ! 2714: } ! 2715: ! 2716: switch(i) ! 2717: { ! 2718: case 1: SelectObject(hDC, hpnRed); break; ! 2719: default: ! 2720: if (i >= pInfo->iIteration) { ! 2721: SelectObject(hDC, hpnBlack); ! 2722: break; ! 2723: } ! 2724: SelectObject(hDC, (HPEN)gprghPen[i % iPen]); ! 2725: break; ! 2726: } ! 2727: ! 2728: LineTo(hDC,xCurr,yCurr); ! 2729: ! 2730: } ! 2731: ReleaseDC(pInfo->hwnd, hDC); ! 2732: ! 2733: pInfo->dwElapsed = GetTickCount() - dwTick1; ! 2734: ! 2735: if (pInfo->hBmpSaved) ! 2736: DeleteObject(pInfo->hBmpSaved); ! 2737: ! 2738: pInfo->hBmpSaved = SaveBitmap(pInfo->hwnd); ! 2739: pInfo->bDrawing = FALSE; ! 2740: ! 2741: ExitThread(0); ! 2742: if (!CloseHandle(pInfo->hThrd)) ! 2743: MessageBox(ghwndMain, "Failed in CloseHandle!", "Error", MB_OK); ! 2744: ! 2745: return TRUE; ! 2746: } ! 2747: ! 2748: ! 2749: /******************************Public*Routine******************************\ ! 2750: * ! 2751: * Xform ! 2752: * ! 2753: * Effects: Given m, find x. ! 2754: * ! 2755: * Xform(Pt) : Src |--> Dest ! 2756: * eg. ! 2757: * Src |----|--------| |--> Dest |----|--------| ! 2758: * -2 x 2 0 m 320 ! 2759: * ! 2760: * x = (m - 0)/(320 - 0) * (2 - -2) + -2 ! 2761: * ! 2762: * Warnings: 1. This will become a macro in the future for speed. For now, ! 2763: * it is here for debugging purposes. ! 2764: * ! 2765: * History: ! 2766: * 25-Nov-1991 -by- Petrus Wong ! 2767: * Wrote it. ! 2768: \**************************************************************************/ ! 2769: #if 0 ! 2770: double Xform( ! 2771: double Pt, ! 2772: double SrcFrom, ! 2773: double SrcTo, ! 2774: double DestFrom, ! 2775: double DestTo) ! 2776: { ! 2777: //sprintf( gtext,"%g = Xform(%g, %g, %g, %g, %g)\n", ((Pt-SrcFrom)/(SrcTo-SrcFrom)*(DestTo-DestFrom))+DestFrom, Pt, SrcFrom, SrcTo, DestFrom, DestTo); ! 2778: //OutputDebugString( gtext ); ! 2779: return(((Pt-SrcFrom)/(SrcTo-SrcFrom)*(DestTo-DestFrom))+DestFrom); ! 2780: } ! 2781: #endif ! 2782: ! 2783: /******************************Public*Routine******************************\ ! 2784: * ! 2785: * Xform2 ! 2786: * ! 2787: * Effects: Given x, find m. ! 2788: * ! 2789: * Xform(Pt) : Src |--> Dest ! 2790: * eg. ! 2791: * Src |----|--------| |--> Dest |----|--------| ! 2792: * -2 x 2 0 m 320 ! 2793: * ! 2794: * m = (x - -2)/(2 - -2) * 320 ! 2795: * ! 2796: * Warnings: 1. This will become a macro in the future for speed. For now, ! 2797: * it is here for debugging purposes. ! 2798: * ! 2799: * History: ! 2800: * 25-Nov-1991 -by- Petrus Wong ! 2801: * Wrote it. ! 2802: \**************************************************************************/ ! 2803: #if 0 ! 2804: int Xform2( ! 2805: double Pt, ! 2806: double SrcFrom, ! 2807: double SrcTo, ! 2808: double DestFrom, ! 2809: double DestTo) ! 2810: { ! 2811: //sprintf( gtext,"%g = Xform(%g, %g, %g, %g, %g)\n", ((Pt-SrcFrom)/(SrcTo-SrcFrom)*(DestTo-DestFrom))+DestFrom, Pt, SrcFrom, SrcTo, DestFrom, DestTo); ! 2812: //OutputDebugString( gtext ); ! 2813: return((int) ((Pt-SrcFrom)/(SrcTo-SrcFrom)*(DestTo-DestFrom)+DestFrom)); ! 2814: } ! 2815: #endif ! 2816: ! 2817: /******************************Public*Routine******************************\ ! 2818: * ! 2819: * SaveBitmap ! 2820: * ! 2821: * Effects: Returns the handle of a bitmap corresponding to the window. ! 2822: * using utilizing BitBlt. ! 2823: * ! 2824: * Warnings: ! 2825: * ! 2826: * History: ! 2827: * 03-Dec-1991 -by- Petrus Wong ! 2828: * Wrote it. ! 2829: \**************************************************************************/ ! 2830: ! 2831: HBITMAP SaveBitmap(HWND hWnd) { ! 2832: HDC hdcMem, hDC; ! 2833: HBITMAP hBitmap, hOldBitmap; ! 2834: RECT rc; ! 2835: ! 2836: hDC = GetDC(hWnd); ! 2837: GetClientRect(hWnd, &rc); ! 2838: ! 2839: hdcMem = CreateCompatibleDC(hDC); ! 2840: ! 2841: hBitmap = CreateCompatibleBitmap(hDC, (int)rc.right-rc.left, (int)rc.bottom-rc.top); ! 2842: ! 2843: hOldBitmap = SelectObject(hdcMem, hBitmap); ! 2844: BitBlt(hdcMem, 0, 0, (int)rc.right-rc.left, (int)rc.bottom-rc.top, hDC, 0, 0, SRCCOPY); ! 2845: hBitmap = SelectObject(hdcMem, hOldBitmap); ! 2846: ! 2847: DeleteDC(hdcMem); ! 2848: ReleaseDC(hWnd, hDC); ! 2849: ! 2850: return(hBitmap); ! 2851: ! 2852: } ! 2853: ! 2854: /******************************Public*Routine******************************\ ! 2855: * ! 2856: * DrawBitmap ! 2857: * ! 2858: * Effects: ! 2859: * ! 2860: * Warnings: ! 2861: * ! 2862: * History: ! 2863: * 03-Dec-1991 -by- Petrus Wong ! 2864: * Wrote it. ! 2865: \**************************************************************************/ ! 2866: ! 2867: void DrawBitmap(HDC hdc, PINFO pInfo, int xStart, int yStart, int cx, int cy) { ! 2868: BITMAP bm; ! 2869: HDC hdcMem; ! 2870: POINT ptSize, ptOrg; ! 2871: ! 2872: hdcMem = CreateCompatibleDC(hdc); ! 2873: SelectObject(hdcMem, (pInfo->bUseMono ? pInfo->hBmpMono : pInfo->hBmpSaved)); ! 2874: SetMapMode(hdcMem, GetMapMode(hdc)); ! 2875: ! 2876: GetObject((pInfo->bUseMono ? pInfo->hBmpMono : pInfo->hBmpSaved), sizeof(BITMAP), (LPSTR)&bm); ! 2877: ptSize.x = bm.bmWidth; ! 2878: ptSize.y = bm.bmHeight; ! 2879: DPtoLP(hdc, &ptSize, 1); ! 2880: ! 2881: ptOrg.x = 0; ! 2882: ptOrg.y = 0; ! 2883: DPtoLP(hdcMem, &ptOrg, 1); ! 2884: ! 2885: if (pInfo->bStretch) { ! 2886: SetStretchBltMode(hdc, pInfo->iStretchMode); ! 2887: // cx+1 and cy+1: temporary work around for a bug! ! 2888: StretchBlt(hdc, xStart, yStart, cx+1, cy+1, ! 2889: hdcMem, ptOrg.x, ptOrg.y, ptSize.x, ptSize.y,SRCCOPY); ! 2890: } else { ! 2891: BitBlt(hdc, xStart, yStart, ptSize.x, ptSize.y, ! 2892: hdcMem, xStart, yStart, SRCCOPY); ! 2893: } ! 2894: ! 2895: if (pInfo->bUseMono) ! 2896: pInfo->bUseMono = FALSE; ! 2897: ! 2898: DeleteDC(hdcMem); ! 2899: UNREFERENCED_PARAMETER(cx); ! 2900: UNREFERENCED_PARAMETER(cy); ! 2901: } ! 2902: ! 2903: /******************************Public*Routine******************************\ ! 2904: * ! 2905: * pGetInfoData(HWND hwnd) ! 2906: * ! 2907: * Effects: calls LocalLock, returning pointer to Info structure. ! 2908: * assumes hwnd contains handle to Info structure at index 0. ! 2909: * should call bReleaseInfoData when done. ! 2910: * Global alert: ghwndMain used. ! 2911: * ! 2912: * Warnings: ! 2913: * ! 2914: * History: ! 2915: * 27-Jan-1992 -by- Petrus Wong ! 2916: * Wrote it. ! 2917: \**************************************************************************/ ! 2918: ! 2919: PINFO pGetInfoData(HWND hwnd) ! 2920: { ! 2921: HANDLE hInfo; ! 2922: PINFO pInfo; ! 2923: ! 2924: hInfo = (HANDLE) GetWindowLong(hwnd, 0); ! 2925: if (hInfo == NULL) { ! 2926: MessageBox(ghwndMain, "Null Info handle retrieved - GetInfo", "Error", MB_OK); ! 2927: return NULL; ! 2928: } ! 2929: ! 2930: if ((pInfo = (PINFO)LocalLock(hInfo)) == NULL) { ! 2931: return NULL; ! 2932: } ! 2933: ! 2934: return pInfo; ! 2935: } ! 2936: ! 2937: /******************************Public*Routine******************************\ ! 2938: * ! 2939: * bReleaseInfoData(HWND hwnd) ! 2940: * ! 2941: * Effects: calls LocalUnlock. Returns whatever LocalUnlock returns. ! 2942: * ! 2943: * Warnings: assumes LocalLock was called previously. ! 2944: * assumes hwnd contains handle to Info structure at index 0. ! 2945: * Global alert: ghwndMain used. ! 2946: * ! 2947: * History: ! 2948: * 27-Jan-1992 -by- Petrus Wong ! 2949: * Wrote it. ! 2950: \**************************************************************************/ ! 2951: ! 2952: BOOL bReleaseInfoData(HWND hwnd) ! 2953: { ! 2954: HANDLE hInfo; ! 2955: ! 2956: hInfo = (HANDLE) GetWindowLong(hwnd, 0); ! 2957: if (hInfo == NULL) { ! 2958: MessageBox(ghwndMain, "Null Info handle retrieved - ReleaseInfo", "Error", MB_OK); ! 2959: return FALSE; ! 2960: } ! 2961: ! 2962: return (LocalUnlock(hInfo)); ! 2963: } ! 2964: ! 2965: ! 2966: /******************************Public*Routine******************************\ ! 2967: * ! 2968: * bCheckMutexMenuItem ! 2969: * ! 2970: * Effects: Put a check mark on uiCheckItem in the hMenu. Remove previous ! 2971: * check mark, if any, on items in the same group. Returns TRUE ! 2972: * if successful, FALSE otherwise (item not exists). ! 2973: * ! 2974: * Warnings: ! 2975: * ! 2976: * History: ! 2977: * 28-Jan-1992 -by- Petrus Wong ! 2978: * Wrote it. ! 2979: \**************************************************************************/ ! 2980: ! 2981: BOOL bCheckMutexMenuItem(HMENU hMenu, UINT uiCheckItem) ! 2982: { ! 2983: switch(uiCheckItem) { ! 2984: case MM_FLOAT: ! 2985: case MM_FIX: ! 2986: CheckMenuItem(hMenu, MM_FLOAT, MF_UNCHECKED); ! 2987: CheckMenuItem(hMenu, MM_FIX, MF_UNCHECKED); ! 2988: break; ! 2989: case MM_ITERATION_TEN: ! 2990: case MM_ITERATION_TWENTY: ! 2991: case MM_ITERATION_THIRTY: ! 2992: case MM_ITERATION_FIFTY: ! 2993: case MM_ITERATION_DOUBLE: ! 2994: CheckMenuItem(hMenu, MM_ITERATION_TEN, MF_UNCHECKED); ! 2995: CheckMenuItem(hMenu, MM_ITERATION_TWENTY, MF_UNCHECKED); ! 2996: CheckMenuItem(hMenu, MM_ITERATION_THIRTY, MF_UNCHECKED); ! 2997: CheckMenuItem(hMenu, MM_ITERATION_FIFTY, MF_UNCHECKED); ! 2998: CheckMenuItem(hMenu, MM_ITERATION_DOUBLE, MF_UNCHECKED); ! 2999: break; ! 3000: case MM_STEP_ONE: ! 3001: case MM_STEP_TWO: ! 3002: case MM_STEP_THREE: ! 3003: CheckMenuItem(hMenu, MM_STEP_ONE, MF_UNCHECKED); ! 3004: CheckMenuItem(hMenu, MM_STEP_TWO, MF_UNCHECKED); ! 3005: CheckMenuItem(hMenu, MM_STEP_THREE, MF_UNCHECKED); ! 3006: break; ! 3007: case MM_STRETCHBLT: ! 3008: case MM_BITBLT: ! 3009: CheckMenuItem(hMenu, MM_STRETCHBLT, MF_UNCHECKED); ! 3010: CheckMenuItem(hMenu, MM_BITBLT, MF_UNCHECKED); ! 3011: break; ! 3012: case MM_BLACKONWHITE: ! 3013: case MM_COLORONCOLOR: ! 3014: case MM_WHITEONBLACK: ! 3015: case MM_HALFTONE: ! 3016: CheckMenuItem(hMenu, MM_BLACKONWHITE, MF_UNCHECKED); ! 3017: CheckMenuItem(hMenu, MM_COLORONCOLOR, MF_UNCHECKED); ! 3018: CheckMenuItem(hMenu, MM_WHITEONBLACK, MF_UNCHECKED); ! 3019: CheckMenuItem(hMenu, MM_HALFTONE, MF_UNCHECKED); ! 3020: break; ! 3021: case MM_PORTRAIT: ! 3022: case MM_LANDSCAPE: ! 3023: CheckMenuItem(hMenu, MM_PORTRAIT, MF_UNCHECKED); ! 3024: CheckMenuItem(hMenu, MM_LANDSCAPE, MF_UNCHECKED); ! 3025: break; ! 3026: default: ! 3027: return FALSE; ! 3028: } ! 3029: CheckMenuItem(hMenu, uiCheckItem, MF_CHECKED); ! 3030: return TRUE; ! 3031: } ! 3032: ! 3033: /******************************Public*Routine******************************\ ! 3034: * ! 3035: * bInitInfo ! 3036: * ! 3037: * Effects: Initialize the Info data structure ! 3038: * ! 3039: * Warnings: ! 3040: * ! 3041: * History: ! 3042: * 28-Jan-1992 -by- Petrus Wong ! 3043: * Wrote it. ! 3044: \**************************************************************************/ ! 3045: ! 3046: BOOL bInitInfo(PINFO pInfo) ! 3047: { ! 3048: pInfo->hParent = ghwndClient; ! 3049: pInfo->xFrom = -2.0; ! 3050: pInfo->xTo = 2.0; ! 3051: pInfo->yFrom = 2.0; ! 3052: pInfo->yTo = -2.0; ! 3053: pInfo->lxFrom = -4096; // 20.11 fix point ! 3054: pInfo->lxTo = 4096; // representation of ! 3055: pInfo->lyFrom = 4096; // -2, 2, 2, and -2 ! 3056: pInfo->lyTo = -4096; // ! 3057: pInfo->iIteration = gIteration; ! 3058: pInfo->iStep = gStep; ! 3059: pInfo->bStretch = gbStretch; ! 3060: pInfo->iStretchMode = giStretchMode; ! 3061: wsprintf((LPSTR) &(pInfo->CaptionBarText), ""); ! 3062: pInfo->hwnd = NULL; ! 3063: pInfo->hTextWnd = NULL; ! 3064: pInfo->rcClient.top = 0; ! 3065: pInfo->rcClient.left = 0; ! 3066: pInfo->rcClient.bottom = 0; ! 3067: pInfo->rcClient.right = 0; ! 3068: pInfo->hdcClient = NULL; ! 3069: pInfo->hRgnPath = NULL; ! 3070: pInfo->hThrd = NULL; ! 3071: pInfo->bDrawing = FALSE; ! 3072: pInfo->dwThreadId = 0; ! 3073: pInfo->dwElapsed = 0L; ! 3074: pInfo->c1 = 0.0; ! 3075: pInfo->c2 = 0.0; ! 3076: pInfo->lc1 = 0L; ! 3077: pInfo->lc2 = 0L; ! 3078: pInfo->hBmpSaved = NULL; ! 3079: pInfo->bSizeChng = FALSE; ! 3080: pInfo->bMandel = TRUE; ! 3081: pInfo->bSetDIBsToDevice = FALSE; ! 3082: pInfo->bFill = FALSE; ! 3083: pInfo->hBrush = NULL; ! 3084: pInfo->hQuitEvent = NULL; ! 3085: pInfo->hCycleThrd = NULL; ! 3086: pInfo->dwCycleThrdID = 0; ! 3087: pInfo->bClrCycle = FALSE; ! 3088: pInfo->bFirstTime = TRUE; ! 3089: pInfo->dwSuspend = 0; ! 3090: pInfo->hBmpMono = NULL; ! 3091: pInfo->bUseMono = FALSE; ! 3092: pInfo->hPrtThrd = NULL; ! 3093: pInfo->dwPrtThrdID = 0; ! 3094: return TRUE; ! 3095: } ! 3096: ! 3097: /******************************Public*Routine******************************\ ! 3098: * ! 3099: * bResetGlobal ! 3100: * ! 3101: * Effects: Set (l) x/y From/To to their default values ! 3102: * ! 3103: * Warnings: ! 3104: * ! 3105: * History: ! 3106: * 28-Jan-1992 -by- Petrus Wong ! 3107: * Wrote it. ! 3108: \**************************************************************************/ ! 3109: ! 3110: BOOL bResetGlobal(VOID) ! 3111: { ! 3112: xFrom = -2.0; ! 3113: xTo = 2.0; ! 3114: yFrom = 2.0; ! 3115: yTo = -2.0; ! 3116: lxFrom = -4096; ! 3117: lxTo = 4096; ! 3118: lyFrom = 4096; ! 3119: lyTo = -4096; ! 3120: return TRUE; ! 3121: } ! 3122: ! 3123: /******************************Public*Routine******************************\ ! 3124: * ! 3125: * hBrCreateBrush ! 3126: * ! 3127: * Effects: Creates a brush with the specified RGB ! 3128: * ! 3129: * Warnings: ! 3130: * ! 3131: * History: ! 3132: * 04-Mar-1992 -by- Petrus Wong ! 3133: * Wrote it. ! 3134: \**************************************************************************/ ! 3135: ! 3136: HBRUSH hBrCreateBrush(HDC hDC, DWORD dwRGB) ! 3137: { ! 3138: HDC hdcMem; ! 3139: HBRUSH hbr; ! 3140: HBRUSH hbrOld; ! 3141: HBITMAP hbmPat; ! 3142: HBITMAP hbmOld; ! 3143: ! 3144: hbr = CreateSolidBrush(dwRGB); ! 3145: hdcMem = CreateCompatibleDC(hDC); ! 3146: ! 3147: // ! 3148: // Minimum size for a bitmap to be used in a fill pattern is 8x8 ! 3149: // ! 3150: hbmPat = CreateCompatibleBitmap(hDC, 8, 8); ! 3151: ! 3152: hbmOld = SelectObject(hdcMem, hbmPat); ! 3153: hbrOld = SelectObject(hdcMem, hbr); ! 3154: PatBlt(hdcMem, 0, 0, 8, 8, PATCOPY); ! 3155: ! 3156: // ! 3157: // Deselect hbmPat and hbr ! 3158: // ! 3159: SelectObject(hdcMem, hbmOld); ! 3160: SelectObject(hdcMem, hbrOld); ! 3161: ! 3162: DeleteDC(hdcMem); ! 3163: DeleteObject(hbr); ! 3164: ! 3165: hbr = CreatePatternBrush(hbmPat); ! 3166: ! 3167: DeleteObject(hbmPat); ! 3168: ! 3169: return hbr; ! 3170: } ! 3171: ! 3172: ! 3173: /******************************Public*Routine******************************\ ! 3174: * ! 3175: * bPrintBmp ! 3176: * ! 3177: * Effects: A Thread routine for printing bitmap ! 3178: * ! 3179: * Warnings: ! 3180: * ! 3181: * History: ! 3182: * 31-May-1992 -by- Petrus Wong ! 3183: * Wrote it. ! 3184: \**************************************************************************/ ! 3185: ! 3186: BOOL bPrintBmp(PPRTDATA pPrtData) { ! 3187: HDC hdcPrinter; ! 3188: int iWidth, iHeight; ! 3189: ! 3190: #ifdef NEWPRTAPI ! 3191: DOCINFO DocInfo; ! 3192: #endif ! 3193: ! 3194: if (pPrtData->bUseDefault) { ! 3195: hdcPrinter = CreateDC( "", gpszPrinterNames[pPrtData->index], ! 3196: "", NULL); ! 3197: } else { ! 3198: hdcPrinter = CreateDC( "", gpszPrinterNames[pPrtData->index], ! 3199: "", &(pPrtData->DevMode)); ! 3200: } ! 3201: ! 3202: if (!hdcPrinter) ! 3203: { ! 3204: ExitThread(0); ! 3205: return(FALSE); ! 3206: } ! 3207: ! 3208: iWidth = GetDeviceCaps(hdcPrinter, HORZRES); ! 3209: iHeight = GetDeviceCaps(hdcPrinter, VERTRES); ! 3210: ! 3211: #ifdef NEWPRTAPI ! 3212: ! 3213: DocInfo.cbSize = sizeof(DOCINFO); ! 3214: DocInfo.lpszDocName = pPrtData->info.CaptionBarText; ! 3215: DocInfo.lpszOutput = NULL; ! 3216: StartDoc(hdcPrinter, &DocInfo); ! 3217: StartPage(hdcPrinter); ! 3218: DrawBitmap(hdcPrinter, &(pPrtData->info), 0, 0, iWidth, iHeight); ! 3219: EndPage(hdcPrinter); ! 3220: EndDoc(hdcPrinter); ! 3221: ! 3222: #else ! 3223: ! 3224: Escape(hdcPrinter, STARTDOC, 20, "Mandelbrot", NULL); ! 3225: DrawBitmap(hdcPrinter, &(pPrtData->info), 0, 0, iWidth, iHeight); ! 3226: Escape(hdcPrinter, NEWFRAME, NULL, NULL, NULL); ! 3227: Escape(hdcPrinter, ENDDOC, NULL, NULL, NULL); ! 3228: ! 3229: #endif ! 3230: ! 3231: DeleteDC(hdcPrinter); ! 3232: ExitThread(0); ! 3233: return(TRUE); ! 3234: ! 3235: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.