开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 查看源码
JULIA.C
资源名称：MSDN_VC98.zip　[点击查看]
上传用户：bangxh
上传日期：2007-01-31
资源大小：42235k
文件大小：146k
源码类别：

Windows编程

开发平台：

Visual C++

JULIA.C：源码内容
  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. *
  9. * Copyright (C) 1993-1997 Microsoft Corporation
  10. *
  11. * The Mandelbrot Dream serves to demonstrate the GDI and USER
  12. * functionalities in the setting of fractals.
  13. *
  14. * The Mandelbrot Dream provides the following functions:
  15. *       1.  Drawing the Mandelbrot set and the corresponding julia set
  16. *       2.  Zooming into any of the set
  17. *       3.  MDI fractal drawing windows
  18. *       4.  Floating Point Math/Fix Point Math
  19. *       5.  Shifting color table entries
  20. *       6.  Changing palette entries and animating palatte aka color cycling
  21. *       7.  Loading/Saving bitmap created with special effect
  22. *       8.  Changing bitmap color with flood fill
  23. *       9.  Boundary tracing and creating a clip region out of it for
  24. *           creating special effect
  25. *      10.  Enumerate printers for printing
  26. *      11.  Load RLE (or convert .bmp files to RLE) for playing in viewer
  27. *      12.  Save the RLE in memory to disk.
  28. *
  29. * Note: Users can now draw and saves the julia sets on disk as bmps in
  30. *       the Julia windows.  These bitmaps can then be read into the memory
  31. *       (and converted to RLE format) one by one for displaying in sequence
  32. *       in the viewer window.  Eg Load the julia.rle in the viewer window
  33. *       and select the play or play continuously menu item.     02-Jan-1993
  34. *
  35. * Note2: The fix point math in this sample makes use of the LargeInteger
  36. *        64 bit math library.
  37. *
  38. * Dependencies:
  39. *
  40. *       none
  41. *
  42. **************************************************************************/
  43. #include <windows.h>
  44. #include <stdlib.h>
  45. #include <commdlg.h>
  46. #include <stdarg.h>
  47. #include <math.h>
  48. #include <stdio.h>
  49. #include <shellapi.h>
  50. #include "julia.h"
  52. //
  53. // For T1 to create all pens in advance.  This is not a good approach
  54. // because pens are per thread basis.  The drawing threads won't be able
  55. // to use them if they are not created in their threads.    18-Sep-1992
  56. //
  57. //#define THRDONE
  59. #define CYCLETHRD
  61. #define PRTTHRD
  62. #define NEWPRTAPI
  64. #ifndef DEBUG
  65.    #undef OutputDebugString
  66.    #define OutputDebugString(LPCSTR)
  67. #endif
  69. //
  70. // Forward declarations.
  71. //
  72. BOOL InitializeApp            (INT*);
  73. LONG APIENTRY MainWndProc     (HWND, UINT, DWORD, LONG);
  74. LONG APIENTRY ChildWndProc    (HWND, UINT, DWORD, LONG);
  75. BOOL CALLBACK About           (HWND, UINT, DWORD, LONG);
  76. LONG APIENTRY TextWndProc     (HWND, UINT, DWORD, LONG);
  77. LONG APIENTRY JuliaWndProc    (HWND, UINT, DWORD, LONG);
  78. LONG APIENTRY ViewerWndProc   (HWND, UINT, DWORD, LONG);
  79. LONG APIENTRY ViewSurfWndProc (HWND, UINT, DWORD, LONG);
  80. BOOL APIENTRY SuspendDrawThrd (HWND, LONG);
  81. BOOL APIENTRY ResumeDrawThrd  (HWND, LONG);
  82. BOOL StartDraw       (PINFO);
  83. BOOL StartDrawFix    (PINFO);
  84. BOOL StartDraw2      (PINFO);
  85. BOOL StartMandelbrot (PINFO);
  86. BOOL StartMandelbrotFix (PINFO);
  87. HBITMAP SaveBitmap   (HWND, HPALETTE);
  88. void DrawBitmap      (HDC, PINFO, int, int, int, int);
  89. BOOL bDrawDIB        (HDC, PINFO, int, int, int, int);
  90. LONG lMul(LONG, LONG);
  91. LONG lDiv(LONG, LONG);
  92. PINFO pGetInfoData(HWND);
  93. BOOL bReleaseInfoData(HWND);
  94. BOOL bCheckMutexMenuItem(PINFO, HMENU, UINT);
  95. VOID vChkMenuItem(PINFO, HMENU, UINT);
  96. BOOL bInitInfo(PINFO);
  97. BOOL bResetGlobal(VOID);
  98. HBRUSH hBrCreateBrush(HDC, DWORD);
  99. BOOL bPrintBmp(PPRTDATA);
  100. BOOL bStoreRleFile(HDC, PINFO, PSTR);
  101. BOOL bFreeRleFile(PINFO);
  102. BOOL bPlayRle(PINFO);
  103. BOOL bSaveRleFile(HDC, PINFO, PSTR);
  104. BOOL bPlayRleCont2(PINFO);
  105. BOOL bSelectDIBPal(HDC, PINFO, LPBITMAPINFO, BOOL);
  106. HBITMAP DIBfromDDB(HDC, HBITMAP, PINFO);
  109. //
  110. // Global variable declarations.
  111. //
  113. HPEN   hpnRed;
  114. HPEN   hpnBlack;
  115. HPEN   hpnGreen;
  116. INT    giPen = 0;
  118. HANDLE ghModule;
  119. HWND   ghwndMain = NULL;
  120. HWND   ghwndClient = NULL;
  121. HANDLE ghAccel;
  123. HMENU  hMenu, hChildMenu, hViewMenu;
  124. HMENU  hViewSubOne, hSubMenuOne, hSubMenuThree;
  125. HMENU  hPrinterMenu;
  127. CHAR   gszFile[20];
  128. CHAR   gszMapName[20];
  129. char   gtext[256];
  131. BOOL   gFloat = TRUE;
  132. LONG   gStep = 1;
  133. LONG   gIteration = 500;
  134. BOOL   gbStretch = TRUE;
  135. INT    giStretchMode = COLORONCOLOR;
  136. INT    giDmOrient = DMORIENT_PORTRAIT;
  137. INT    giNPrinters = 0;
  139. HPALETTE        ghPal, ghPalOld;
  141. double xFrom, xTo, yFrom, yTo, c1, c2;
  142. LONG   lxFrom, lxTo, lyFrom, lyTo, lc1, lc2;
  147. /******************************Public*Routine******************************
  148. *
  149. * WinMain
  150. *
  151. **************************************************************************/
  153. int WINAPI WinMain(
  154.     HINSTANCE hInstance,
  155.     HINSTANCE hPrevInstance,
  156.     LPSTR lpCmdLine,
  157.     int nShowCmd)
  158. {
  159.     MSG    msg;
  161.     ghModule = GetModuleHandle(NULL);
  162.     if (!InitializeApp(&giPen)) 
  163. {
  164. OutputDebugString("memory: InitializeApp failure!");
  165. return 0;
  166.     }
  168.     if (!(ghAccel = LoadAccelerators (ghModule, MAKEINTRESOURCE(ACCEL_ID))))
  169. OutputDebugString("memory: Load Accel failure!");
  172.     while (GetMessage(&msg, NULL, 0, 0)) 
  173. {
  174. if (!TranslateAccelerator( ghwndMain, ghAccel, &msg) &&
  175.     !TranslateMDISysAccel( ghwndClient, &msg)) 
  176. {
  177. TranslateMessage(&msg);
  178. DispatchMessage(&msg);
  179. }
  180.     }
  183.     DeleteObject(ghPal);
  185.     return 1;
  187.     UNREFERENCED_PARAMETER(lpCmdLine);
  188.     UNREFERENCED_PARAMETER(nShowCmd);
  189.     UNREFERENCED_PARAMETER(hInstance);
  190.     UNREFERENCED_PARAMETER(hPrevInstance);
  191. }
  194. /***************************************************************************
  195. * InitializeApp
  196. *
  197. ***************************************************************************/
  199. BOOL InitializeApp(INT *piPen)
  200. {
  201.     WNDCLASS wc;
  202.     HDC      hDC;
  204. #ifdef THRDONE
  205.     INT      iNumClr;
  206. #endif
  208.     wc.style            = CS_OWNDC;
  209.     wc.lpfnWndProc      = (WNDPROC)MainWndProc;
  210.     wc.cbClsExtra       = 0;
  211.     wc.cbWndExtra       = sizeof(LONG);
  212.     wc.hInstance        = ghModule;
  213.     wc.hIcon            = LoadIcon(ghModule, MAKEINTRESOURCE(APPICON));
  214.     wc.hCursor          = LoadCursor(NULL, IDC_ARROW);
  215.     wc.hbrBackground    = (HBRUSH)(COLOR_APPWORKSPACE);
  216.     wc.lpszMenuName     = "MainMenu";
  217.     wc.lpszClassName    = "MandelClass";
  219.     if (!RegisterClass(&wc))
  220. return FALSE;
  222.     wc.lpfnWndProc      = (WNDPROC)ChildWndProc;
  223.     wc.hIcon            = LoadIcon(ghModule, MAKEINTRESOURCE(APPICON));
  224.     wc.lpszMenuName     = NULL;
  225.     wc.lpszClassName    = "ChildClass";
  227.     if (!RegisterClass(&wc))
  228. return FALSE;
  230.     wc.lpfnWndProc      = (WNDPROC)ViewerWndProc;
  231.     wc.hIcon            = LoadIcon(ghModule, MAKEINTRESOURCE(VIEWICON));
  232.     wc.lpszMenuName     = NULL;
  233.     wc.lpszClassName    = "ViewerClass";
  235.     if (!RegisterClass(&wc))
  236. return FALSE;
  238.     wc.style            = CS_OWNDC | CS_HREDRAW | CS_VREDRAW;
  239.     wc.lpfnWndProc      = (WNDPROC)TextWndProc;
  240.     wc.hIcon            = NULL;
  241.     wc.hCursor          = LoadCursor(NULL, IDC_ARROW);
  242.     wc.hbrBackground    = (HBRUSH)(COLOR_BTNSHADOW);
  243.     wc.lpszMenuName     = NULL;
  244.     wc.lpszClassName    = "Text";
  246.     if (!RegisterClass(&wc))
  247.     return FALSE;
  249.     wc.style            = CS_OWNDC | CS_HREDRAW | CS_VREDRAW;
  250.     wc.lpfnWndProc      = (WNDPROC)JuliaWndProc;
  251.     wc.hIcon            = NULL;
  253.     //
  254.     // Nope.  Can't have this, screw up my Paint Can cursor
  255.     //
  256.     //wc.hCursor          = LoadCursor(NULL, IDC_ARROW);
  258.     wc.hCursor          = NULL;
  259.     wc.hbrBackground    = (HBRUSH)(COLOR_BACKGROUND);
  260.     wc.lpszMenuName     = NULL;
  261.     wc.lpszClassName    = "Julia";
  263.     if (!RegisterClass(&wc))
  264.     return FALSE;
  266.     wc.style            = CS_OWNDC | CS_HREDRAW | CS_VREDRAW;
  267.     wc.lpfnWndProc      = (WNDPROC)ViewSurfWndProc;
  268.     wc.hIcon            = NULL;
  269.     wc.hCursor          = LoadCursor(NULL, IDC_ARROW);
  270.     wc.hbrBackground    = (HBRUSH)(COLOR_BACKGROUND);
  271.     wc.lpszMenuName     = NULL;
  272.     wc.lpszClassName    = "View";
  274.     if (!RegisterClass(&wc))
  275.     return FALSE;
  278.     //
  279.     // Notice, submenu is zero-based
  280.     //
  281.     hMenu       = LoadMenu(ghModule, "MainMenu");
  282.     hChildMenu  = LoadMenu(ghModule, "ChildMenu");
  283.     hViewMenu   = LoadMenu(ghModule, "ViewMenu");
  284.     hViewSubOne = GetSubMenu(hViewMenu, 1);
  285.     hSubMenuOne = GetSubMenu(hMenu, 1);
  286.     hSubMenuThree = GetSubMenu(hChildMenu, 8);
  287.     hPrinterMenu = GetSubMenu(hChildMenu, 7);
  289.     //
  290.     // Disable color-cycling for display devices that does not support
  291.     // palette like the VGA.  As as 29-May-1992, the MIPS display driver
  292.     // is the only one that supports palette
  293.     //
  294.     hDC = GetDC(NULL);
  295.     if (!((GetDeviceCaps(hDC, RASTERCAPS)) & RC_PALETTE)) {
  296. EnableMenuItem(hChildMenu, MM_CYCLE, MF_GRAYED);
  297.     }
  299. #ifdef THRDONE
  301.     if ((iNumClr = iCreatePenFrPal(hDC, NULL, 0, &ghPal)) != 0) 
  302. {
  303. sprintf( gtext,"iNumClr = %dn", iNumClr);
  304. OutputDebugString( gtext);
  306. if ((pInfo->prghPen = (PVOID*) GlobalAlloc(GMEM_FIXED | GMEM_ZEROINIT, sizeof(HPEN)*iNumClr)) == NULL) 
  307.     OutputDebugString ("Failed in Memory Allocation for pInfo->prghPen!");
  308. else 
  309. if ((*piPen = iCreatePenFrPal(hDC, pInfo->prghPen, 0, &ghPal)) == 0)
  310. OutputDebugString("Failed in creating pen!");
  311.     }
  313. #endif
  314.     ReleaseDC(NULL, hDC);
  316.     ghwndMain = CreateWindowEx(0L, "MandelClass", 
  317.    GetStringRes (IDS_MANDEL_DREAM),
  319.     WS_OVERLAPPED   | WS_CAPTION     | WS_BORDER       |
  320.     WS_THICKFRAME   | WS_MAXIMIZEBOX | WS_MINIMIZEBOX  |
  321.     WS_CLIPCHILDREN | WS_VISIBLE     | WS_SYSMENU,
  322.     80, 70, 550, 400 /* 550 */,
  323.     NULL, hMenu, ghModule, NULL);
  325.     if (ghwndMain == NULL)
  326. return FALSE;
  328.     bInitPrinter(ghwndMain);
  330.     SetWindowLong(ghwndMain, GWL_USERDATA, 0L);
  332.     SetFocus(ghwndMain);    /* set initial focus */
  334.     PostMessage(ghwndMain, WM_COMMAND, MM_MANDEL, 0L);
  335.     PostMessage(ghwndMain, WM_COMMAND, MM_CREATE_MANDEL_THREAD, 0L);
  337.     return TRUE;
  338. }
  341. /******************************Public*Routine******************************
  342. *
  343. * MainWndProc
  344. *
  345. **************************************************************************/
  347. long APIENTRY MainWndProc(
  348.     HWND hwnd,
  349.     UINT message,
  350.     DWORD wParam,
  351.     LONG lParam)
  352. {
  353.     static int         iJuliaCount=1;
  354.     static int         iMandelCount=1;
  355.     static int         iViewerCount=1;
  356.     CLIENTCREATESTRUCT clientcreate;
  357.     HWND               hwndChildWindow;
  358.     static FARPROC     lpfnSuspendThrd, lpfnResumeThrd;
  361.     switch (message) {
  363.       case WM_CREATE:
  364. SetWindowLong(hwnd, 0, (LONG)NULL);
  366. clientcreate.hWindowMenu  = hSubMenuOne;
  367. clientcreate.idFirstChild = 1;
  369. ghwndClient = CreateWindow("MDICLIENT", NULL,
  370.     WS_CHILD | WS_CLIPCHILDREN | WS_VISIBLE,
  371.     0,0,0,0,
  372.     hwnd, NULL, ghModule, (LPVOID)&clientcreate);
  373. lpfnSuspendThrd = (FARPROC)MakeProcInstance (SuspendDrawThrd, ghModule);
  374. lpfnResumeThrd  = (FARPROC)MakeProcInstance (ResumeDrawThrd, ghModule);
  376. return 0L;
  378.       case WM_DESTROY: {
  379. bCleanupPrinter();
  380. PostQuitMessage(0);
  381. return 0L;
  382.       }
  384.       //
  385.       // Wait! User is going to zero out our app's visible region.  This
  386.       // is going to mess up our drawing (we are not keeping any shadow
  387.       // bitmap in this version yet.) So, let's suspend our drawing thread
  388.       // first before user does that.  We will resume after user is done.
  389.       //
  390.       case WM_SYSCOMMAND: {
  391. LONG        lResult;
  393. //
  394. // We'll enumerate our children and suspend their drawing thread.
  395. //
  396. EnumChildWindows(ghwndClient, (WNDENUMPROC)lpfnSuspendThrd, lParam);
  398. //
  399. // Now, let user does it supposed to do
  400. //
  401. lResult = DefFrameProc(hwnd,  ghwndClient, message, wParam, lParam);
  403. //
  404. // User's done, we'll resume the suspended threads in our children
  405. //
  406. EnumChildWindows(ghwndClient, (WNDENUMPROC)lpfnResumeThrd, lParam);
  408. return lResult;
  409. break;
  410.       }
  411. #if 0
  412.       //
  413.       // Our window's size is going to change, we'll make sure the new
  414.       // window is a square.
  415.       //
  416.       case WM_WINDOWPOSCHANGING: {
  417.     PWINDOWPOS pWndPos;
  418.     RECT       rect;
  419.     LONG       lcx, lcy;
  421.     GetWindowRect(hwnd, &rect);
  422.     lcx = rect.right-rect.left;
  423.     lcy = rect.bottom-rect.top;
  424.     pWndPos = (PWINDOWPOS)lParam;
  425.     if ((pWndPos->cy > lcy) || (pWndPos->cx > lcx))
  426. pWndPos->cx =  pWndPos->cy =
  427.    ((pWndPos->cx > pWndPos->cy) ? pWndPos->cy : pWndPos->cx);
  428.     else if ((pWndPos->cy < lcy) || (pWndPos->cx < lcx))
  429.      pWndPos->cx =  pWndPos->cy =
  430. ((pWndPos->cx > pWndPos->cy) ? pWndPos->cy : pWndPos->cx);
  431.     break;
  432.       }
  433. #endif
  435.       case WM_COMMAND:
  437. switch (LOWORD(wParam)) {
  438.     case IDM_TILE:
  439. SendMessage(ghwndClient, WM_MDITILE, 0L, 0L);
  440. return 0L;
  441.     case IDM_CASCADE:
  442. SendMessage(ghwndClient, WM_MDICASCADE, 0L, 0L);
  443. return 0L;
  444.     case IDM_ARRANGE:
  445. SendMessage(ghwndClient, WM_MDIICONARRANGE, 0L, 0L);
  446. return 0L;
  448.     //
  449.     // Create Julia or Mandelbrot set
  450.     //
  451.     case MM_JULIA:
  452.     case MM_MANDEL: {
  453. HANDLE hInfo;
  454. PINFO  pInfo;
  455. MDICREATESTRUCT mdicreate;
  457. hInfo = LocalAlloc(LHND, (WORD) sizeof(INFO));
  458. if (hInfo == NULL) 
  459. {
  460.     OutputDebugString("Failed to Allocate Info!");
  461.     return 0L;
  462. }
  463. if ((pInfo = (PINFO)LocalLock(hInfo)) == NULL) 
  464. {
  465.     OutputDebugString("Failed in LocalLock, hInfo");
  466.     return 0L;
  467. }
  469. bInitInfo(pInfo);
  470. wsprintf((LPSTR) &(pInfo->CaptionBarText),
  471.  (LOWORD(wParam) == MM_JULIA) ? 
  472.  GetStringRes (IDS_JULIA): 
  473.  GetStringRes (IDS_MANDELBROT),
  474.  (LOWORD(wParam) == MM_JULIA) ? iJuliaCount : iMandelCount);
  475. if (LOWORD(wParam) == MM_JULIA) {
  476.     c1 = 0.360284;
  477.     c2 = 0.100376;
  478.     lc1 = 738;          //.3603515
  479.     lc2 = 206;          //.1005859
  480.     pInfo->bMandel = FALSE;
  481. } else {
  482.     pInfo->bMandel = TRUE;
  483. }
  485. //
  486. // Fill in the MDICREATE structure for MDI child creation
  487. //
  488. mdicreate.szClass = "ChildClass";
  489. mdicreate.szTitle = (LPTSTR)&(pInfo->CaptionBarText);
  490. mdicreate.hOwner  = ghModule;
  491. mdicreate.x       =
  492. mdicreate.y       = CW_USEDEFAULT;
  493. mdicreate.cx      = 300;
  494. mdicreate.cy      = 300;
  495. mdicreate.style   = 0L;
  496. mdicreate.lParam  = (LONG) hInfo;
  498. /*Create Child Window*/
  499. hwndChildWindow =
  500.     (HANDLE) SendMessage(ghwndClient, WM_MDICREATE,
  501. 0L,
  502. (LONG)(LPMDICREATESTRUCT)&mdicreate);
  504. if (hwndChildWindow == NULL) 
  505. {
  506.     OutputDebugString ("Failed in Creating Child Window");
  507.     return 0L;
  508. }
  510. (LOWORD(wParam) == MM_JULIA) ? iJuliaCount++ : iMandelCount++ ;
  511. LocalUnlock(hInfo);
  512. return ((LONG)hwndChildWindow);
  513.     }
  515.     case MM_RLEVIEWER: {
  516. HANDLE hInfo;
  517. PINFO  pInfo;
  518. MDICREATESTRUCT mdicreate;
  520. hInfo = LocalAlloc(LHND, (WORD) sizeof(INFO));
  521. if (hInfo == NULL) 
  522. {
  523.     OutputDebugString ("Failed to Allocate Info!");
  524.     return 0L;
  525. }
  526. if ((pInfo = (PINFO)LocalLock(hInfo)) == NULL) 
  527. {
  528.     OutputDebugString ("Failed in LocalLock, hInfo");
  529.     return 0L;
  530. }
  532. bInitInfo(pInfo);
  533. wsprintf((LPSTR) &(pInfo->CaptionBarText), GetStringRes (IDS_VIEWER), iViewerCount );
  535. //
  536. // Fill in the MDICREATE structure for MDI child creation
  537. //
  538. mdicreate.szClass = "ViewerClass";
  539. mdicreate.szTitle = (LPTSTR)&(pInfo->CaptionBarText);
  540. mdicreate.hOwner  = ghModule;
  541. mdicreate.x       =
  542. mdicreate.y       = CW_USEDEFAULT;
  543. mdicreate.cx      = 300;
  544. mdicreate.cy      = 300;
  545. mdicreate.style   = 0L;
  546. mdicreate.lParam  = (LONG) hInfo;
  548. /*Create Child Window*/
  549. hwndChildWindow =
  550.     (HANDLE) SendMessage(ghwndClient, WM_MDICREATE,
  551. 0L,
  552. (LONG)(LPMDICREATESTRUCT)&mdicreate);
  554. if (hwndChildWindow == NULL) 
  555. {
  556.     OutputDebugString ("Failed in Creating Child Window");
  557.     return 0L;
  558. }
  560. iViewerCount++ ;
  561. LocalUnlock(hInfo);
  562. return ((LONG)hwndChildWindow);
  564.     }
  566.     case MM_ABOUT:
  567. if (DialogBox(ghModule, "AboutBox", ghwndMain, (DLGPROC)About) == -1)
  568.    OutputDebugString ("DEMO: About Dialog Creation Error!");
  569. return 0L;
  571.     //
  572.     // Only my children know how to deal with these messages, so
  573.     // pass these to children for processing
  574.     //
  575.     case MM_CREATE_JULIA_THREAD:
  576.     case MM_SET_XFORM_ATTR:
  577.     case MM_CREATE_MANDEL_THREAD:
  578.     case MM_OPT_4:              // currently not used
  579.     case MM_DRAW_SET:
  580.     case MM_SETDIB2DEVICE:
  581.     case MM_BW:
  582.     case MM_SHIFT:
  583.     case MM_CUSTOM:
  584.     case MM_CYCLE:
  585.     case MM_TP_IDLE:
  586.     case MM_TP_LOW:
  587.     case MM_TP_BELOW_NORMAL:
  588.     case MM_TP_NORMAL:
  589.     case MM_TP_ABOVE_NORMAL:
  590.     case MM_TP_HIGH:
  591.     case MM_TP_TIME_CRITICAL:
  592.     case MM_FLOAT:
  593.     case MM_FIX:
  594.     case MM_ITERATION_100:
  595.     case MM_ITERATION_500:
  596.     case MM_ITERATION_1000:
  597.     case MM_ITERATION_5000:
  598.     case MM_ITERATION_DOUBLE:
  599.     case MM_STEP_ONE:
  600.     case MM_STEP_TWO:
  601.     case MM_STEP_THREE:
  602.     case MM_SAVE:
  603.     case MM_SAVE_MONO:
  604.     case MM_LOAD:
  605.     case MM_STRETCHBLT:
  606.     case MM_BITBLT:
  607.     case MM_BLACKONWHITE:
  608.     case MM_COLORONCOLOR:
  609.     case MM_WHITEONBLACK:
  610.     case MM_HALFTONE:
  611.     case MM_CLIP:
  612.     case MM_RM_CLIP:
  613.     case MM_SELCLIPRGN:
  614.     case MM_ERASE:
  615.     case MM_PORTRAIT:
  616.     case MM_LANDSCAPE:
  617.     case MM_PRINTER:
  618.     case MM_PRINTER + 1:
  619.     case MM_PRINTER + 2:
  620.     case MM_PRINTER + 3:
  621.     case MM_PRINTER + 4:
  622.     case MM_PRINTER + 5:
  623.     case MM_PRINTER + 6:
  624.     case MM_PRINTER + 7:
  625.     case MM_PRINTER + 8:
  626.     case MM_PRINTER + 9:
  627.     case MM_RLELOAD_DEMO:
  628.     case MM_RLEPLAYCONT:
  629.     case MM_RLELOAD:
  630.     case MM_RLESAVE:
  631.     case MM_CLEAR:
  632.     case MM_RLEPLAY:
  633.     {
  634. HWND hActiveChild;
  636. hActiveChild = (HANDLE) SendMessage(ghwndClient, WM_MDIGETACTIVE, 0L, 0L);
  637. if (hActiveChild)
  638.     SendMessage(hActiveChild, WM_COMMAND, wParam, lParam);
  639. return 0L;
  640.     }
  642.     default:
  643. return DefFrameProc(hwnd,  ghwndClient, message, wParam, lParam);
  644. }
  645.     default:
  647. return DefFrameProc(hwnd,  ghwndClient, message, wParam, lParam);
  648.     }
  649. }
  651. /***************************************************************************
  652. * ChildWndProc
  653. *
  654. ***************************************************************************/
  656. long APIENTRY ChildWndProc(
  657.     HWND hwnd,
  658.     UINT message,
  659.     DWORD wParam,
  660.     LONG lParam)
  661. {
  662.     static FARPROC     lpfnSuspendThrd, lpfnResumeThrd;
  663.     static BOOL        bDIB2Device = FALSE;
  665.     sprintf( gtext,"message = %lxn", message);
  666.     OutputDebugString( gtext);
  668.     switch (message) {
  669. case WM_COMMAND: {
  670.   PINFO       pInfo;
  671.   HWND        hTextWnd;
  673.   switch (LOWORD(wParam)) {
  674.     //
  675.     // Create a Julia drawing thread
  676.     //
  677.     case MM_CREATE_JULIA_THREAD: {
  678. if ((pInfo = pGetInfoData(hwnd)) == NULL) {
  679.     return 0L;
  680. }
  682. hTextWnd = pInfo->hTextWnd;
  683. sprintf( gtext,"(%g, %g) <-> (%g, %g)", pInfo->xFrom, pInfo->yFrom, pInfo->xTo, pInfo->yTo);
  684. SetWindowText(hTextWnd, gtext);
  685. sprintf( gtext,"(c1 = %g, c2 = %g)nn", pInfo->c1, pInfo->c2);
  686. OutputDebugString( gtext );
  688. if (pInfo->hThrd)
  689.     CloseHandle(pInfo->hThrd);
  691. pInfo->hThrd = CreateThread(NULL, 0,
  692.  (gFloat ? (LPTHREAD_START_ROUTINE)StartDraw : (LPTHREAD_START_ROUTINE)StartDrawFix),
  693.  pInfo,
  694.  STANDARD_RIGHTS_REQUIRED,
  695.  &pInfo->dwThreadId );
  697.        if (pInfo->hThrd && pInfo->bDrawing) 
  698.    {
  699.     if (!SetThreadPriority(pInfo->hThrd, pInfo->iPriority))
  700.      OutputDebugString ("Can't set Priority!");
  701.        }
  703.        bReleaseInfoData(hwnd);
  704.        return 0L;
  705.     }
  707.     //
  708.     // Reset pInfo reflecting new transformation
  709.     //
  710.     case MM_SET_XFORM_ATTR: {
  711. if ((pInfo = pGetInfoData(hwnd)) == NULL) {
  712.     return 0L;
  713. }
  715. hTextWnd = pInfo->hTextWnd;
  716. SetWindowText(hTextWnd, GetStringRes (IDS_CLICK_HERE_VIEW));
  718. pInfo->xFrom      = xFrom;
  719. pInfo->xTo        = xTo;
  720. pInfo->yFrom      = yFrom;
  721. pInfo->yTo        = yTo;
  722. pInfo->c1         = c1;
  723. pInfo->c2         = c2;
  724. pInfo->lxFrom      = lxFrom;
  725. pInfo->lxTo        = lxTo;
  726. pInfo->lyFrom      = lyFrom;
  727. pInfo->lyTo        = lyTo;
  728. pInfo->lc1         = lc1;
  729. pInfo->lc2         = lc2;
  731.        bReleaseInfoData(hwnd);
  732.        return 0L;
  733.     }
  735.     //
  736.     // Create a Mandelbrot drawing thread
  737.     //
  738.     case MM_CREATE_MANDEL_THREAD: {
  739. if ((pInfo = pGetInfoData(hwnd)) == NULL) {
  740.     return 0L;
  741. }
  743. hTextWnd = pInfo->hTextWnd;
  744. sprintf( gtext,"(%g, %g) <-> (%g, %g)", pInfo->xFrom, pInfo->yFrom, pInfo->xTo, pInfo->yTo);
  745. SetWindowText(hTextWnd, gtext);
  746. sprintf( gtext,"(c1 = %g, c2 = %g)nn", pInfo->c1, pInfo->c2);
  747. OutputDebugString( gtext );
  749. if (pInfo->hThrd)
  750.     CloseHandle(pInfo->hThrd);
  752. pInfo->hThrd = CreateThread(NULL, 0,
  753.  (gFloat ? (LPTHREAD_START_ROUTINE)StartMandelbrot : (LPTHREAD_START_ROUTINE)StartMandelbrotFix),
  754.  pInfo,
  755.  STANDARD_RIGHTS_REQUIRED,
  756.  &pInfo->dwThreadId );
  758.        if (pInfo->hThrd && pInfo->bDrawing) 
  759.    {
  760.   if (!SetThreadPriority(pInfo->hThrd, pInfo->iPriority))
  761.      OutputDebugString ("Can't set Priority!");
  762.        }
  765.        bReleaseInfoData(hwnd);
  766.        return 0L;
  767.     }
  769.     //
  770.     // Create a Julia drawing thread using algorithm StartDraw2
  771.     // Currently not used
  772.     //
  773.     case MM_OPT_4: {
  774. if ((pInfo = pGetInfoData(hwnd)) == NULL) {
  775.     return 0L;
  776. }
  778. hTextWnd = pInfo->hTextWnd;
  779. SetWindowText(hTextWnd, "MM_OPT_4");
  781. sprintf( gtext,"xFrom = %g, xTo = %g, yFrom = %g, yTo = %gn", pInfo->xFrom, pInfo->xTo, pInfo->yFrom, pInfo->yTo);
  782. OutputDebugString( gtext );
  784. if (pInfo->hThrd)
  785.     CloseHandle(pInfo->hThrd);
  787. pInfo->hThrd = CreateThread(NULL, 0,
  788.  (LPTHREAD_START_ROUTINE)StartDraw2,
  789.  pInfo,
  790.  STANDARD_RIGHTS_REQUIRED,
  791.  &pInfo->dwThreadId );
  793.        if (pInfo->hThrd && pInfo->bDrawing) 
  794.    {
  795.       if (!SetThreadPriority(pInfo->hThrd, pInfo->iPriority))
  796.      OutputDebugString ("Can't set Priority!");
  797.        }
  799.        bReleaseInfoData(hwnd);
  800.        return 0L;
  801.     }
  803.     case MM_DRAW_SET: {
  804. if ((pInfo = pGetInfoData(hwnd)) == NULL) {
  805.     return 0L;
  806. }
  808. PostMessage(hwnd, WM_COMMAND,
  809.     pInfo->bMandel ? (DWORD)((WORD)MM_CREATE_MANDEL_THREAD) : (DWORD)((WORD)MM_CREATE_JULIA_THREAD),
  810.     (LONG)0L);
  812.        bReleaseInfoData(hwnd);
  813.        return 0L;
  814.     }
  816.     {
  817.     int     iPriority;
  819. case MM_TP_IDLE:
  820.     if ((pInfo = pGetInfoData(hwnd)) == NULL) {
  821. return 0L;
  822.     }
  824.     iPriority = THREAD_PRIORITY_IDLE;
  825.     bCheckMutexMenuItem(pInfo, hChildMenu, MM_TP_IDLE);
  826.     DrawMenuBar(GetParent(GetParent(hwnd))) ;
  827.     goto CWP_SET_PRIORITY;
  829. case MM_TP_LOW:
  830.     if ((pInfo = pGetInfoData(hwnd)) == NULL) {
  831. return 0L;
  832.     }
  834.     iPriority = THREAD_PRIORITY_LOWEST;
  835.     bCheckMutexMenuItem(pInfo, hChildMenu, MM_TP_LOW);
  836.     DrawMenuBar(GetParent(GetParent(hwnd))) ;
  837.     goto CWP_SET_PRIORITY;
  839. case MM_TP_BELOW_NORMAL:
  840.     if ((pInfo = pGetInfoData(hwnd)) == NULL) {
  841. return 0L;
  842.     }
  844.     iPriority = THREAD_PRIORITY_BELOW_NORMAL;
  845.     bCheckMutexMenuItem(pInfo, hChildMenu, MM_TP_BELOW_NORMAL);
  846.     DrawMenuBar(GetParent(GetParent(hwnd))) ;
  847.     goto CWP_SET_PRIORITY;
  849. case MM_TP_NORMAL:
  850.     if ((pInfo = pGetInfoData(hwnd)) == NULL) {
  851. return 0L;
  852.     }
  854.     iPriority = THREAD_PRIORITY_NORMAL;
  855.     bCheckMutexMenuItem(pInfo, hChildMenu, MM_TP_NORMAL);
  856.     DrawMenuBar(GetParent(GetParent(hwnd))) ;
  857.     goto CWP_SET_PRIORITY;
  859. case MM_TP_ABOVE_NORMAL:
  860.     if ((pInfo = pGetInfoData(hwnd)) == NULL) {
  861. return 0L;
  862.     }
  864.     iPriority = THREAD_PRIORITY_ABOVE_NORMAL;
  865.     bCheckMutexMenuItem(pInfo, hChildMenu, MM_TP_ABOVE_NORMAL);
  866.     DrawMenuBar(GetParent(GetParent(hwnd))) ;
  867.     goto CWP_SET_PRIORITY;
  869. case MM_TP_HIGH:
  870.     if ((pInfo = pGetInfoData(hwnd)) == NULL) {
  871. return 0L;
  872.     }
  874.     iPriority = THREAD_PRIORITY_HIGHEST;
  875.     bCheckMutexMenuItem(pInfo, hChildMenu, MM_TP_HIGH);
  876.     DrawMenuBar(GetParent(GetParent(hwnd))) ;
  877.     goto CWP_SET_PRIORITY;
  879. case MM_TP_TIME_CRITICAL:
  880.     if ((pInfo = pGetInfoData(hwnd)) == NULL) {
  881. return 0L;
  882.     }
  884.     iPriority = THREAD_PRIORITY_TIME_CRITICAL;
  885.     bCheckMutexMenuItem(pInfo, hChildMenu, MM_TP_TIME_CRITICAL);
  886.     DrawMenuBar(GetParent(GetParent(hwnd))) ;
  888. CWP_SET_PRIORITY:
  889.     {
  890.        HANDLE       hThrd;
  892.        hThrd = pInfo->hThrd;
  893.        pInfo->iPriority = iPriority;
  895.        if (hThrd && pInfo->bDrawing) 
  896.    {
  897.       if (!SetThreadPriority(hThrd, iPriority))
  898.      OutputDebugString ("Can't set Priority!");
  899.        }
  901.     }
  902.     bReleaseInfoData(hwnd);
  903.     return 0L;
  905.     }
  907.     case MM_FLOAT: {
  908. if ((pInfo = pGetInfoData(hwnd)) == NULL) {
  909.     return 0L;
  910. }
  911. bCheckMutexMenuItem(pInfo, hChildMenu, MM_FLOAT);
  912. DrawMenuBar(GetParent(GetParent(hwnd))) ;
  913. gFloat = TRUE;
  914. bReleaseInfoData(hwnd);
  915. return 0L;
  916.     }
  917.     case MM_FIX: {
  918. if ((pInfo = pGetInfoData(hwnd)) == NULL) {
  919.     return 0L;
  920. }
  921. bCheckMutexMenuItem(pInfo, hChildMenu, MM_FIX);
  922. DrawMenuBar(GetParent(GetParent(hwnd))) ;
  923. gFloat = FALSE;
  924. bReleaseInfoData(hwnd);
  925. return 0L;
  926.     }
  927.     case MM_ITERATION_100: {
  928. if ((pInfo = pGetInfoData(hwnd)) == NULL) {
  929.     return 0L;
  930. }
  931. bCheckMutexMenuItem(pInfo, hChildMenu, MM_ITERATION_100);
  932. DrawMenuBar(GetParent(GetParent(hwnd))) ;
  933. gIteration = 100;
  934. pInfo->iIteration = 100;
  935. SetWindowText(pInfo->hTextWnd, GetStringRes (IDS_ITER_100));
  936. bReleaseInfoData(hwnd);
  937. return 0L;
  938.     }
  939.     case MM_ITERATION_500: {
  940. if ((pInfo = pGetInfoData(hwnd)) == NULL){
  941.     return 0L;
  942. }
  943. bCheckMutexMenuItem(pInfo, hChildMenu, MM_ITERATION_500);
  944. DrawMenuBar(GetParent(GetParent(hwnd))) ;
  945. gIteration = 500;
  947. pInfo->iIteration = 500;
  948. SetWindowText(pInfo->hTextWnd, GetStringRes (IDS_ITER_500));
  949. bReleaseInfoData(hwnd);
  950. return 0L;
  951.     }
  952.     case MM_ITERATION_1000: {
  953. if ((pInfo = pGetInfoData(hwnd)) == NULL) {
  954.     return 0L;
  955. }
  956. bCheckMutexMenuItem(pInfo, hChildMenu, MM_ITERATION_1000);
  957. DrawMenuBar(GetParent(GetParent(hwnd))) ;
  958. gIteration = 1000;
  959. pInfo->iIteration = 1000;
  960. SetWindowText(pInfo->hTextWnd, GetStringRes (IDS_ITER_1000));
  961. bReleaseInfoData(hwnd);
  962. return 0L;
  963.     }
  964.     case MM_ITERATION_5000: {
  965. if ((pInfo = pGetInfoData(hwnd)) == NULL) {
  966.     return 0L;
  967. }
  968. bCheckMutexMenuItem(pInfo, hChildMenu, MM_ITERATION_5000);
  969. DrawMenuBar(GetParent(GetParent(hwnd))) ;
  970. gIteration = 5000;
  971. pInfo->iIteration = 5000;
  972. SetWindowText(pInfo->hTextWnd, GetStringRes (IDS_ITER_5000));
  973. bReleaseInfoData(hwnd);
  974. return 0L;
  975.     }
  976.     case MM_ITERATION_DOUBLE: {
  977. if ((pInfo = pGetInfoData(hwnd)) == NULL) {
  978.     return 0L;
  979. }
  980. bCheckMutexMenuItem(pInfo, hChildMenu, MM_ITERATION_DOUBLE);
  981. DrawMenuBar(GetParent(GetParent(hwnd))) ;
  982. gIteration *= 2;
  983. pInfo->iIteration = gIteration;
  984. sprintf( gtext, GetStringRes (IDS_ITERATION), pInfo->iIteration);
  985. SetWindowText(pInfo->hTextWnd, gtext);
  986. bReleaseInfoData(hwnd);
  987. return 0L;
  988.     }
  989.     case MM_STEP_ONE: {
  990. if ((pInfo = pGetInfoData(hwnd)) == NULL) {
  991.     return 0L;
  992. }
  993. bCheckMutexMenuItem(pInfo, hChildMenu, MM_STEP_ONE);
  994. DrawMenuBar(GetParent(GetParent(hwnd))) ;
  995. gStep = 1;
  996. pInfo->iStep = 1;
  998. bReleaseInfoData(hwnd);
  999. return 0L;
  1000.     }
  1001.     case MM_STEP_TWO:  {
  1002. if ((pInfo = pGetInfoData(hwnd)) == NULL){
  1003.     return 0L;
  1004. }
  1005. bCheckMutexMenuItem(pInfo, hChildMenu, MM_STEP_TWO);
  1006. DrawMenuBar(GetParent(GetParent(hwnd))) ;
  1007. gStep = 2;
  1008. pInfo->iStep = 2;
  1010. bReleaseInfoData(hwnd);
  1011. return 0L;
  1012.     }
  1013.     case MM_STEP_THREE: {
  1014. if ((pInfo = pGetInfoData(hwnd)) == NULL) {
  1015.     return 0L;
  1016. }
  1017. bCheckMutexMenuItem(pInfo, hChildMenu, MM_STEP_THREE);
  1018. DrawMenuBar(GetParent(GetParent(hwnd))) ;
  1019. gStep = 3;
  1020. pInfo->iStep = 3;
  1022. bReleaseInfoData(hwnd);
  1023. return 0L;
  1024.     }
  1026.     case MM_LOAD: {
  1027. HDC hDC;
  1028. OPENFILENAME ofn;
  1029. char szDirName[256];
  1030. char szFile[256], szFileTitle[256];
  1031. static char *szFilter;
  1032. RECT    rc;
  1034. if ((pInfo = pGetInfoData(hwnd)) == NULL){
  1035.     return 0L;
  1036. }
  1038. szFilter = GetStringRes (IDS_FILE_LIST1);
  1040. GetSystemDirectory((LPSTR) szDirName, 256);
  1041. strcpy(szFile, "*.bmp");
  1042. ofn.lStructSize = sizeof(OPENFILENAME);
  1043. ofn.hwndOwner = pInfo->hwnd;
  1044. ofn.lpstrFilter = szFilter;
  1045. ofn.lpstrCustomFilter = (LPSTR) NULL;
  1046. ofn.nMaxCustFilter = 0L;
  1047. ofn.nFilterIndex = 1;
  1048. ofn.lpstrFile = szFile;
  1049. ofn.nMaxFile = sizeof(szFile);
  1050. ofn.lpstrFileTitle = szFileTitle;
  1051. ofn.nMaxFileTitle = sizeof(szFileTitle);
  1052. ofn.lpstrInitialDir = szDirName;
  1053. ofn.lpstrTitle = (LPSTR) NULL;
  1054. ofn.Flags = 0L;
  1055. ofn.nFileOffset = 0;
  1056. ofn.nFileExtension = 0;
  1057. ofn.lpstrDefExt = "BMP";
  1059. if (!GetOpenFileName(&ofn))
  1060.     return 0L;
  1062. GetClientRect(pInfo->hwnd, &rc);
  1063. hDC = GetDC(pInfo->hwnd);
  1064. if (LoadBitmapFile(hDC, pInfo, szFile))
  1065.   bDrawDIB(hDC, pInfo, 0, 0, rc.right, rc.bottom);
  1066. ReleaseDC(hwnd, hDC);
  1068. bReleaseInfoData(hwnd);
  1070. return 0L;
  1071.     }
  1073.     case MM_SAVE: {
  1074. HDC hDC;
  1075. OPENFILENAME ofn;
  1076. char szDirName[256];
  1077. char szFile[256], szFileTitle[256];
  1078. static char *szFilter;
  1080. szFilter = GetStringRes (IDS_FILE_LIST2);
  1082. if ((pInfo = pGetInfoData(hwnd)) == NULL) {
  1083.     return 0L;
  1084. }
  1085. hDC = GetDC(pInfo->hwnd);
  1086. #if 0
  1087. {
  1088. HPALETTE hPalTmp;
  1090. hPalTmp = CopyPalette(pInfo->hPal);
  1091. DeleteObject(pInfo->hPal);
  1092. pInfo->hPal = hPalTmp;
  1093. }
  1094. #endif
  1095. //
  1096. // saving special effects user might have created in window
  1097. //
  1098. if (pInfo->hBmpSaved)
  1099.     DeleteObject(pInfo->hBmpSaved);
  1100. pInfo->hBmpSaved = SaveBitmap(pInfo->hwnd, pInfo->hPal);
  1101. pInfo->bUseDIB = FALSE;
  1103. GetSystemDirectory((LPSTR) szDirName, 256);
  1104. strcpy(szFile, "*.bmp");
  1105. ofn.lStructSize = sizeof(OPENFILENAME);
  1106. ofn.hwndOwner = pInfo->hwnd;
  1107. ofn.lpstrFilter = szFilter;
  1108. ofn.lpstrCustomFilter = (LPSTR) NULL;
  1109. ofn.nMaxCustFilter = 0L;
  1110. ofn.nFilterIndex = 0L;
  1111. ofn.lpstrFile = szFile;
  1112. ofn.nMaxFile = sizeof(szFile);
  1113. ofn.lpstrFileTitle = szFileTitle;
  1114. ofn.nMaxFileTitle = sizeof(szFileTitle);
  1115. ofn.lpstrInitialDir = szDirName;
  1116. ofn.lpstrTitle = (LPSTR) NULL;
  1117. ofn.Flags = OFN_SHOWHELP | OFN_OVERWRITEPROMPT;
  1118. ofn.nFileOffset = 0;
  1119. ofn.nFileExtension = 0;
  1120. ofn.lpstrDefExt = (LPSTR)NULL;
  1122. if (!GetSaveFileName(&ofn)) {
  1123.     ReleaseDC(pInfo->hwnd, hDC);
  1124.     bReleaseInfoData(hwnd);
  1125.     return 0L;
  1126. }
  1128. SelectPalette(hDC,
  1129.    ((pInfo->iStretchMode == HALFTONE) ? pInfo->hHTPal : pInfo->hPal),
  1130.    FALSE);
  1131. RealizePalette(hDC);
  1132. UpdateColors(hDC);
  1134. //
  1135. // test
  1136. //
  1137. ghPal = pInfo->hPal;
  1139. SaveBitmapFile(hDC, pInfo->hBmpSaved, szFile);
  1141. ReleaseDC(pInfo->hwnd, hDC);
  1143. bReleaseInfoData(hwnd);
  1144. return 0L;
  1145.     }
  1146.     case MM_SAVE_MONO: {
  1147. HDC hDC;
  1148. OPENFILENAME ofn;
  1149. char szDirName[256];
  1150. char szFile[256], szFileTitle[256];
  1151. static char *szFilter;
  1153. if ((pInfo = pGetInfoData(hwnd)) == NULL){
  1154.     return 0L;
  1155. }
  1157. szFilter = GetStringRes (IDS_FILE_LIST2);
  1159. GetSystemDirectory((LPSTR) szDirName, 256);
  1160. strcpy(szFile, "*.bmp");
  1161. ofn.lStructSize = sizeof(OPENFILENAME);
  1162. ofn.hwndOwner = pInfo->hwnd;
  1163. ofn.lpstrFilter = szFilter;
  1164. ofn.lpstrCustomFilter = (LPSTR) NULL;
  1165. ofn.nMaxCustFilter = 0L;
  1166. ofn.nFilterIndex = 0L;
  1167. ofn.lpstrFile = szFile;
  1168. ofn.nMaxFile = sizeof(szFile);
  1169. ofn.lpstrFileTitle = szFileTitle;
  1170. ofn.nMaxFileTitle = sizeof(szFileTitle);
  1171. ofn.lpstrInitialDir = szDirName;
  1172. ofn.lpstrTitle = GetStringRes (IDS_SAVING_MONO_BITMAP);
  1173. ofn.Flags = OFN_SHOWHELP | OFN_OVERWRITEPROMPT;
  1174. ofn.nFileOffset = 0;
  1175. ofn.nFileExtension = 0;
  1176. ofn.lpstrDefExt = (LPSTR)NULL;
  1178. if (!GetSaveFileName(&ofn))
  1179.     return 0L;
  1181. hDC = GetDC(pInfo->hwnd);
  1183. SaveBitmapFile(hDC, pInfo->hBmpMono, szFile);
  1184. ReleaseDC(pInfo->hwnd, hDC);
  1186. bReleaseInfoData(hwnd);
  1187. return 0L;
  1188.     }
  1189.     case MM_STRETCHBLT: {
  1190. if ((pInfo = pGetInfoData(hwnd)) == NULL){
  1191.     return 0L;
  1192. }
  1193. gbStretch = TRUE;
  1194. bCheckMutexMenuItem(pInfo, hChildMenu, MM_STRETCHBLT);
  1195. DrawMenuBar(GetParent(GetParent(hwnd))) ;
  1196. pInfo->bStretch = gbStretch;
  1197. InvalidateRect(pInfo->hwnd, NULL, FALSE);
  1199. bReleaseInfoData(hwnd);
  1200. return 0L;
  1202.     }
  1203.     case MM_BITBLT: {
  1204. if ((pInfo = pGetInfoData(hwnd)) == NULL) {
  1205.     return 0L;
  1206. }
  1207. gbStretch = FALSE;
  1208. bCheckMutexMenuItem(pInfo, hChildMenu, MM_BITBLT);
  1209. DrawMenuBar(GetParent(GetParent(hwnd))) ;
  1210. pInfo->bStretch = gbStretch;
  1211. InvalidateRect(pInfo->hwnd, NULL, FALSE);
  1213. bReleaseInfoData(hwnd);
  1214. return 0L;
  1216.     }
  1217.     case MM_BLACKONWHITE: {
  1218. if ((pInfo = pGetInfoData(hwnd)) == NULL) {
  1219.     return 0L;
  1220. }
  1221. giStretchMode = BLACKONWHITE;
  1222. bCheckMutexMenuItem(pInfo, hChildMenu, MM_BLACKONWHITE);
  1223. DrawMenuBar(GetParent(GetParent(hwnd))) ;
  1224. pInfo->iStretchMode = giStretchMode;
  1225. InvalidateRect(pInfo->hwnd, NULL, FALSE);
  1227. bReleaseInfoData(hwnd);
  1228. return 0L;
  1230.     }
  1231.     case MM_COLORONCOLOR: {
  1232. if ((pInfo = pGetInfoData(hwnd)) == NULL) {
  1233.     return 0L;
  1234. }
  1235. giStretchMode = COLORONCOLOR;
  1236. bCheckMutexMenuItem(pInfo, hChildMenu, MM_COLORONCOLOR);
  1237. DrawMenuBar(GetParent(GetParent(hwnd))) ;
  1238. pInfo->iStretchMode = giStretchMode;
  1239. InvalidateRect(pInfo->hwnd, NULL, FALSE);
  1241. bReleaseInfoData(hwnd);
  1242. return 0L;
  1244.     }
  1245.     case MM_WHITEONBLACK: {
  1246. if ((pInfo = pGetInfoData(hwnd)) == NULL) {
  1247.     return 0L;
  1248. }
  1249. giStretchMode = WHITEONBLACK;
  1250. bCheckMutexMenuItem(pInfo, hChildMenu, MM_WHITEONBLACK);
  1251. DrawMenuBar(GetParent(GetParent(hwnd))) ;
  1252. pInfo->iStretchMode = giStretchMode;
  1253. InvalidateRect(pInfo->hwnd, NULL, FALSE);
  1255. bReleaseInfoData(hwnd);
  1256. return 0L;
  1258.     }
  1259.     case MM_HALFTONE: {
  1260. if ((pInfo = pGetInfoData(hwnd)) == NULL) {
  1261.     return 0L;
  1262. }
  1263. giStretchMode = HALFTONE;
  1264. bCheckMutexMenuItem(pInfo, hChildMenu, MM_HALFTONE);
  1265. DrawMenuBar(GetParent(GetParent(hwnd))) ;
  1266. pInfo->iStretchMode = giStretchMode;
  1267. InvalidateRect(pInfo->hwnd, NULL, FALSE);
  1269. bReleaseInfoData(hwnd);
  1270. return 0L;
  1271.     }
  1272.     case MM_SETDIB2DEVICE: {
  1273. if ((pInfo = pGetInfoData(hwnd)) == NULL) {
  1274.     return 0L;
  1275. }
  1276. bDIB2Device = (bDIB2Device ? FALSE : TRUE);
  1277. pInfo->bSetDIBsToDevice = bDIB2Device;
  1278. CheckMenuItem(hChildMenu, MM_SETDIB2DEVICE, (bDIB2Device ? MF_CHECKED : MF_UNCHECKED));
  1279. bReleaseInfoData(hwnd);
  1280. return 0L;
  1281.     }
  1282.     case MM_BW: {
  1283. HDC hDC;
  1285. if ((pInfo = pGetInfoData(hwnd)) == NULL) {
  1286.     return 0L;
  1287. }
  1288. hDC = GetDC(pInfo->hwnd);
  1289. bChangeDIBColor(hDC, pInfo, MM_BW);
  1290. ReleaseDC(hwnd, hDC);
  1291. bReleaseInfoData(hwnd);
  1292. return 0L;
  1293.     }
  1294.     case MM_SHIFT: {
  1295. HDC hDC;
  1297. if ((pInfo = pGetInfoData(hwnd)) == NULL) {
  1298.     return 0L;
  1299. }
  1300. hDC = GetDC(pInfo->hwnd);
  1301. bChangeDIBColor(hDC, pInfo, MM_SHIFT);
  1302. ReleaseDC(hwnd, hDC);
  1303. bReleaseInfoData(hwnd);
  1304. return 0L;
  1305.     }
  1306.     case MM_CUSTOM: {
  1307. static DWORD argbCust[16] = {
  1308.     RGB(255, 255, 255), RGB(255, 255, 255),
  1309.     RGB(255, 255, 255), RGB(255, 255, 255),
  1310.     RGB(255, 255, 255), RGB(255, 255, 255),
  1311.     RGB(255, 255, 255), RGB(255, 255, 255),
  1312.     RGB(255, 255, 255), RGB(255, 255, 255),
  1313.     RGB(255, 255, 255), RGB(255, 255, 255),
  1314.     RGB(255, 255, 255), RGB(255, 255, 255),
  1315.     RGB(255, 255, 255), RGB(255, 255, 255)
  1316. };
  1317. CHOOSECOLOR cc;
  1318. BOOL bResult;
  1319. DWORD rgbOld;
  1320. HBRUSH hBrush;
  1321. HDC hDC;
  1323. rgbOld = RGB(255, 255, 255);
  1324. cc.lStructSize = sizeof(CHOOSECOLOR);
  1325. cc.hwndOwner = ghwndMain;
  1326. cc.hInstance = ghModule;
  1327. cc.rgbResult = rgbOld;
  1328. cc.lpCustColors = argbCust;
  1329. cc.Flags = CC_RGBINIT | CC_SHOWHELP;
  1330. cc.lCustData = 0;
  1331. cc.lpfnHook = NULL;
  1332. cc.lpTemplateName = NULL;
  1334. bResult = ChooseColor(&cc);
  1335. if ((pInfo = pGetInfoData(hwnd)) == NULL) {
  1336.     return 0L;
  1337. }
  1338. if (bResult) {
  1339.     hDC = GetDC(pInfo->hwnd);
  1340.     hBrush = hBrCreateBrush(hDC, cc.rgbResult);
  1341.     ReleaseDC(pInfo->hwnd, hDC);
  1342.     if (pInfo->hBrush)
  1343. DeleteObject(pInfo->hBrush);
  1344.     pInfo->hBrush = hBrush;
  1345.     pInfo->bFill = TRUE;
  1346. }
  1347. bReleaseInfoData(hwnd);
  1348. return 0L;
  1349. }
  1351. #ifndef CYCLETHRD
  1352.     case MM_CYCLE: {
  1353. HDC hDC;
  1355. if ((pInfo = pGetInfoData(hwnd)) == NULL) {
  1356.     return 0L;
  1357. }
  1358. hDC = GetDC(pInfo->hwnd);
  1360. if (pInfo->bClrCycle) {
  1361.     CheckMenuItem(hChildMenu, MM_CYCLE, MF_UNCHECKED);
  1362.     pInfo->bClrCycle = FALSE;
  1363. } else {
  1364.     CheckMenuItem(hChildMenu, MM_CYCLE, MF_CHECKED);
  1365.     pInfo->bClrCycle = TRUE;
  1366.     bChangeDIBColor(hDC, pInfo, MM_CYCLE);
  1367. }
  1369. ReleaseDC(hwnd, hDC);
  1370. bReleaseInfoData(hwnd);
  1371. return 0L;
  1372.     }
  1373. #else
  1375.     case MM_CYCLE: {
  1376. if ((pInfo = pGetInfoData(hwnd)) == NULL) {
  1377.     return 0L;
  1378. }
  1380. if (pInfo->bFirstTime) 
  1381. {
  1382.     if (!SetEvent(pInfo->hQuitEvent)) 
  1383. {
  1384. OutputDebugString ("Can't set Quit Event!");
  1385. return 0L;
  1386.     }
  1388.     if (pInfo->hCycleThrd)
  1389. CloseHandle(pInfo->hCycleThrd);
  1391.     pInfo->hCycleThrd = CreateThread(NULL, 0,
  1392.      (LPTHREAD_START_ROUTINE)bCycle,
  1393.      (LPVOID)hwnd,
  1394.      STANDARD_RIGHTS_REQUIRED,
  1395.      &pInfo->dwCycleThrdID );
  1396.     pInfo->bClrCycle = TRUE;
  1397.     pInfo->bFirstTime = FALSE;
  1398.     CheckMenuItem(hChildMenu, MM_CYCLE, MF_CHECKED);
  1399. } else {
  1400.     if (pInfo->bClrCycle) {
  1401. CheckMenuItem(hChildMenu, MM_CYCLE, MF_UNCHECKED);
  1402. pInfo->bClrCycle = FALSE;
  1403. pInfo->dwSuspend = SuspendThread(pInfo->hCycleThrd);
  1404.     } else {
  1405. CheckMenuItem(hChildMenu, MM_CYCLE, MF_CHECKED);
  1406. pInfo->bClrCycle = TRUE;
  1407. pInfo->dwSuspend = ResumeThread(pInfo->hCycleThrd);
  1408.     }
  1409.     if (pInfo->dwSuspend == -1) {
  1410. (pInfo->bClrCycle ?
  1411.  sprintf( gtext,"Error in resuming threadn") :
  1412.  sprintf( gtext,"Error in suspending threadn")  );
  1413. OutputDebugString( gtext );
  1414.     }
  1415. }
  1417. bReleaseInfoData(hwnd);
  1418. return 0L;
  1419.     }
  1420. #endif
  1421.     case MM_CLIP: {
  1422. if ((pInfo = pGetInfoData(hwnd)) == NULL) {
  1423.     return 0L;
  1424. }
  1426. hTextWnd = pInfo->hTextWnd;
  1427. sprintf( gtext,"(%g, %g) <-> (%g, %g)", pInfo->xFrom, pInfo->yFrom, pInfo->xTo, pInfo->yTo);
  1428. SetWindowText(hTextWnd, gtext);
  1429. sprintf( gtext,"(c1 = %g, c2 = %g)nn", pInfo->c1, pInfo->c2);
  1430. OutputDebugString( gtext );
  1431. if (!pInfo->bMandel) 
  1432. {
  1433.     MessageBox(ghwndMain, 
  1434.    GetStringRes (IDS_BOUNDARY),
  1435.    NULL, MB_OK);
  1436.     return 0L;
  1437. }
  1439. if (pInfo->hThrd)
  1440.     CloseHandle(pInfo->hThrd);
  1442. pInfo->hThrd = CreateThread(NULL, 0,
  1443.  (gFloat ? (LPTHREAD_START_ROUTINE)bBoundaryScanFix : (LPTHREAD_START_ROUTINE)bBoundaryScanFix),
  1444.  pInfo,
  1445.  STANDARD_RIGHTS_REQUIRED,
  1446.  &pInfo->dwThreadId );
  1448.        bReleaseInfoData(hwnd);
  1449.        return 0L;
  1450.     }
  1451.     case MM_RM_CLIP: {
  1452. HDC     hDC;
  1454. if ((pInfo = pGetInfoData(hwnd)) == NULL) {
  1455.     return 0L;
  1456. }
  1458. hDC = GetDC(pInfo->hwnd);
  1459. SelectClipRgn(hDC, (HRGN) NULL);
  1460. ReleaseDC(pInfo->hwnd, hDC);
  1461. bReleaseInfoData(hwnd);
  1462. InvalidateRect(pInfo->hwnd, NULL, FALSE);
  1463. return 0L;
  1465.     }
  1466.     case MM_SELCLIPRGN: {
  1467. HDC     hDC;
  1469. if ((pInfo = pGetInfoData(hwnd)) == NULL) {
  1470.     return 0L;
  1471. }
  1472. hDC = GetDC(pInfo->hwnd);
  1474. if (pInfo->hRgnPath != (HRGN) NULL) {
  1475.     SelectClipRgn(hDC, pInfo->hRgnPath);
  1476. }
  1478. ReleaseDC(pInfo->hwnd, hDC);
  1479. bReleaseInfoData(hwnd);
  1480. return 0L;
  1481.     }
  1482.     case MM_ERASE: {
  1483. HDC     hDC;
  1484. RECT    rc;
  1486. if ((pInfo = pGetInfoData(hwnd)) == NULL) {
  1487.     return 0L;
  1488. }
  1489. hDC = GetDC(pInfo->hwnd);
  1490. if (pInfo->hRgnPath != (HRGN) NULL) {
  1491.     SelectClipRgn(hDC, pInfo->hRgnPath);
  1492. }
  1493. SelectObject(hDC, GetStockObject(WHITE_BRUSH));
  1494. GetClientRect(pInfo->hwnd, &rc);
  1495. PatBlt(hDC, 0, 0, rc.right, rc.bottom, PATCOPY);
  1496. ReleaseDC(pInfo->hwnd, hDC);
  1497. bReleaseInfoData(hwnd);
  1498. return 0L;
  1499.     }
  1500.     case MM_PORTRAIT: {
  1501. if ((pInfo = pGetInfoData(hwnd)) == NULL) {
  1502.     return 0L;
  1503. }
  1505. giDmOrient = DMORIENT_PORTRAIT;
  1506. bCheckMutexMenuItem(pInfo, hChildMenu, MM_PORTRAIT);
  1507. DrawMenuBar(GetParent(GetParent(hwnd))) ;
  1508. bReleaseInfoData(hwnd);
  1509. return 0L;
  1510.     }
  1511.     case MM_LANDSCAPE: {
  1512. if ((pInfo = pGetInfoData(hwnd)) == NULL) {
  1513.     return 0L;
  1514. }
  1516. giDmOrient = DMORIENT_LANDSCAPE;
  1517. bCheckMutexMenuItem(pInfo, hChildMenu, MM_LANDSCAPE);
  1518. DrawMenuBar(GetParent(GetParent(hwnd))) ;
  1519. bReleaseInfoData(hwnd);
  1520. return 0L;
  1521.     }
  1522.     case MM_PRINTER:
  1523.     case MM_PRINTER + 1:
  1524.     case MM_PRINTER + 2:
  1525.     case MM_PRINTER + 3:
  1526.     case MM_PRINTER + 4:
  1527.     case MM_PRINTER + 5:
  1528.     case MM_PRINTER + 6:
  1529.     case MM_PRINTER + 7:
  1530.     case MM_PRINTER + 8:
  1532. #ifdef PRTTHRD
  1533.     case MM_PRINTER + 9: {
  1534. PINFO       pInfo;
  1535. PRTDATA     PrtData, *pPrtData;
  1536. ULONG       sizINFO;
  1537. PBYTE       pjTmpInfo, pjTmp;
  1539. if ((pInfo = pGetInfoData(hwnd)) == NULL) {
  1540.     return 0L;
  1541. }
  1543. if (pInfo->hBmpSaved == NULL) 
  1544. {
  1545.     MessageBox(ghwndMain, 
  1546.        GetStringRes (IDS_NO_SAVED_BITMAP),
  1547.    NULL, MB_OK);
  1548.     return 0L;
  1549. }
  1551. //
  1552. // Copy the info structure to PrtData
  1553. //
  1554. pPrtData = &PrtData;
  1555. pjTmp    = (PBYTE)&(pPrtData->info);
  1556. pjTmpInfo = (PBYTE)pInfo;
  1557. sizINFO = sizeof(INFO);
  1559. while(sizINFO--)
  1560. {
  1561.     *(((PBYTE)pjTmp)++) = *((pjTmpInfo)++);
  1562. }
  1564. PrtData.index = LOWORD(wParam) - MM_PRINTER;
  1566. if (giDmOrient == DMORIENT_PORTRAIT) {
  1567.     PrtData.bUseDefault = TRUE;
  1568. } else {
  1569.     PrtData.bUseDefault = FALSE;
  1570.     PrtData.DevMode.dmSize = sizeof(DEVMODE);
  1571.     PrtData.DevMode.dmDriverExtra = 0;
  1572.     PrtData.DevMode.dmOrientation = DMORIENT_LANDSCAPE;
  1573.     PrtData.DevMode.dmFields = DM_ORIENTATION;
  1574. }
  1576. if (pInfo->hPrtThrd)
  1577.     CloseHandle(pInfo->hPrtThrd);
  1579. pInfo->hPrtThrd = CreateThread(NULL, 0,
  1580.  (LPTHREAD_START_ROUTINE)bPrintBmp,
  1581.  &PrtData,
  1582.  STANDARD_RIGHTS_REQUIRED,
  1583.  &pInfo->dwPrtThrdID );
  1585. bReleaseInfoData(hwnd);
  1586. return 0L;
  1587.     }
  1589. #else
  1590.     case MM_PRINTER + 9: {
  1591. HDC         hdcPrinter, hDC;
  1592. int         index;
  1593. DEVMODE     devmode;
  1594. DEVMODE     *pdevmode;
  1595. PINFO       pInfo;
  1596. int         iWidth, iHeight;
  1599. index = LOWORD(wParam) - MM_PRINTER;
  1601. if (giDmOrient == DMORIENT_PORTRAIT)
  1602.     pdevmode = NULL;
  1603. else {
  1604.     pdevmode = &devmode;
  1605.     devmode.dmSize = sizeof(DEVMODE);
  1606.     devmode.dmDriverExtra = 0;
  1607.     devmode.dmOrientation = DMORIENT_LANDSCAPE;
  1608.     devmode.dmFields = DM_ORIENTATION;
  1609. }
  1611. if (!(hdcPrinter = CreateDC( "", gpszPrinterNames[index],
  1612.      "", pdevmode)))
  1613. {
  1614.     return(0L);
  1615. }
  1617. if ((pInfo = pGetInfoData(hwnd)) == NULL) {
  1618.     return 0L;
  1619. }
  1621. iWidth = GetDeviceCaps(hdcPrinter, HORZRES);
  1622. iHeight = GetDeviceCaps(hdcPrinter, VERTRES);
  1624. // !!! Why is it necessary to save the image over again?  May not want to
  1625. //     do this because user may want to print the nice HT bitmap. So,
  1626. //     use the DIB src.
  1627. #if 0
  1628. if (pInfo->hBmpSaved)
  1629.     DeleteObject(pInfo->hBmpSaved);
  1631. pInfo->hBmpSaved = SaveBitmap(pInfo->hwnd, pInfo->hPal);
  1632. #endif
  1633. Escape(hdcPrinter, STARTDOC, 20, "Mandelbrot", NULL);
  1634. bDrawDIB(hdcPrinter, pInfo, 0, 0, iWidth, iHeight);
  1635. Escape(hdcPrinter, NEWFRAME, 0, NULL, NULL);
  1636. Escape(hdcPrinter, ENDDOC, 0, NULL, NULL);
  1637. ReleaseDC(pInfo->hwnd, hDC);
  1638. bReleaseInfoData(hwnd);
  1639. DeleteDC(hdcPrinter);
  1640. return 0L;
  1641.     }
  1642. #endif
  1643.     default:
  1644.        return 0L;
  1646.   }
  1648. }
  1649. case WM_SETFOCUS:
  1650.     break;
  1652. case WM_MDIACTIVATE: {
  1653.     PINFO       pInfo;
  1655.     if ((pInfo = pGetInfoData(hwnd)) == NULL) {
  1656. return 0L;
  1657.     }
  1659.     if ((HWND) lParam == hwnd) {                // being activated
  1660. SendMessage(GetParent(hwnd), WM_MDISETMENU,
  1661.     (DWORD)  hChildMenu,
  1662.     (LONG)   hSubMenuThree) ;
  1664. (pInfo->bClrCycle ?
  1665.     CheckMenuItem(hChildMenu, MM_CYCLE, MF_CHECKED) :
  1666.     CheckMenuItem(hChildMenu, MM_CYCLE, MF_UNCHECKED) );
  1668. vChkMenuItem(pInfo, hChildMenu, MF_CHECKED);
  1669. DrawMenuBar(GetParent(GetParent(hwnd))) ;
  1670. goto MDI_ACT_EXIT;
  1671.     }
  1673.     if ((HWND) wParam == hwnd) {                // being deactivated
  1675. vChkMenuItem(pInfo, hChildMenu, MF_UNCHECKED);
  1676. DrawMenuBar(GetParent(GetParent(hwnd))) ;
  1677.     }
  1678. MDI_ACT_EXIT:
  1679.     bReleaseInfoData(hwnd);
  1680.     return 0L;
  1681. }
  1683. case WM_QUERYNEWPALETTE:
  1684. case WM_PALETTECHANGED: {
  1685.     PINFO       pInfo;
  1687.     if ((pInfo = pGetInfoData(hwnd)) == NULL) {
  1688. return 0L;
  1689.     }
  1691.     SendMessage(pInfo->hwnd, message, wParam, lParam);
  1692.     bReleaseInfoData(hwnd);
  1693.     return 0L;
  1694. }
  1696. #if 0
  1697. case WM_WINDOWPOSCHANGING: {
  1698.     PWINDOWPOS  pWndPos;
  1699.     PINFO       pInfo;
  1700.     HWND        hTextWnd;
  1701.     int         iCyText, iCxBorder, iCyBorder, iCyCaption;
  1702.     RECT        rect, rcl;
  1703.     LONG        lcx, lcy;
  1705.     if ((pInfo = pGetInfoData(hwnd)) == NULL) {
  1706. break;
  1707.     }
  1709.     hTextWnd = pInfo->hTextWnd;
  1711.     bReleaseInfoData(hwnd);
  1713.     iCyText = GetWindowLong(hTextWnd, GWL_USERDATA);
  1714.     iCxBorder = GetSystemMetrics(SM_CXBORDER);
  1715.     iCyBorder = GetSystemMetrics(SM_CYBORDER);
  1716.     iCyCaption = GetSystemMetrics(SM_CYCAPTION) - iCyBorder;
  1717.     GetClientRect(GetParent(hwnd), &rcl);
  1718.     GetWindowRect(hwnd, &rect);
  1719.     lcx = rect.right-rect.left;
  1720.     lcy = rect.bottom-rect.top;
  1721.     pWndPos = (PWINDOWPOS)lParam;
  1722.     if ((pWndPos->cy > lcy) || (pWndPos->cx > lcx)) {
  1723. pWndPos->cx =
  1724.    ((pWndPos->cx > pWndPos->cy) ? pWndPos->cy-iCyText : pWndPos->cx);
  1725. pWndPos->cy = pWndPos->cx + iCyText;
  1726.     } else { if ((pWndPos->cy < lcy) || (pWndPos->cx < lcx)) {
  1727.      pWndPos->cx =
  1728. ((pWndPos->cx > pWndPos->cy) ? pWndPos->cy-iCyText : pWndPos->cx);
  1729.      pWndPos->cy = pWndPos->cx + iCyText;
  1730.    }
  1731.     }
  1732.     break;
  1733. }
  1734. #endif
  1735. case WM_SIZE: {
  1736.     HANDLE      hThrd;
  1737.     PINFO       pInfo;
  1738.     HWND        hTextWnd, hJulia;
  1739.     BOOL        bMandel;
  1740.     WORD        wCx;
  1741.     int         iCyText;
  1743.     if ((pInfo = pGetInfoData(hwnd)) == NULL) {
  1744. break;
  1745.     }
  1747.     hTextWnd = pInfo->hTextWnd;
  1748.     hJulia   = pInfo->hwnd;
  1749.     hThrd    = pInfo->hThrd;
  1750.     bMandel  = pInfo->bMandel;
  1751.     bReleaseInfoData(hwnd);
  1752.     iCyText = GetWindowLong(hTextWnd, GWL_USERDATA);
  1753.     wCx = (WORD) (HIWORD(lParam) - iCyText);
  1755.     MoveWindow(hJulia, 0, 0,
  1756.    LOWORD(lParam),
  1757.    wCx,
  1758.    TRUE);
  1760.     MoveWindow(hTextWnd,
  1761.        0,
  1762.        wCx,
  1763.        LOWORD(lParam),
  1764.        iCyText,
  1765.        TRUE);
  1767.     if (hThrd) {
  1768. TerminateThread(hThrd, (DWORD)0L);
  1769. /*
  1770. PostMessage(hwnd, WM_COMMAND,
  1771.     bMandel ? (DWORD)((WORD)MM_CREATE_MANDEL_THREAD) : (DWORD)((WORD)MM_CREATE_JULIA_THREAD),
  1772.     (LONG)0L);
  1773.   */
  1774.     }
  1776.     break;
  1777. }
  1779. //
  1780. // display info in the status window
  1781. //
  1782. case WM_USER+0xa: {
  1783.     PINFO       pInfo;
  1784.     static ULONG ulClick = 0;
  1785.     HWND        hTextWnd;
  1787.     ulClick++;
  1788.     if ((pInfo = pGetInfoData(hwnd)) == NULL) {
  1789. return 0L;
  1790.     }
  1792.     hTextWnd = pInfo->hTextWnd;
  1793.     switch (ulClick % 6) {
  1794. case 0: sprintf( gtext,"%g <= x <= %g, %g <= y <= %g", pInfo->xFrom, pInfo->xTo, pInfo->yTo, pInfo->yFrom);
  1795. break;
  1796. case 1: sprintf( gtext,"c1 = %g, c2 = %g", pInfo->c1, pInfo->c2);
  1797. break;
  1798. case 2: sprintf( gtext,
  1799.      GetStringRes (IDS_ELAPSED_TIME),
  1800.  (ULONG) pInfo->dwElapsed);
  1801. break;
  1802. case 3: sprintf( gtext,
  1803.      GetStringRes (IDS_ITERATION),
  1804.  pInfo->iIteration);
  1805. break;
  1806. case 4: sprintf( gtext,
  1807.  GetStringRes (IDS_STEP),
  1808.  pInfo->iStep);
  1809. break;
  1810. case 5: 
  1811. (gFloat ? sprintf( gtext, GetStringRes (IDS_FLOATING_PT))
  1812.         : sprintf( gtext, GetStringRes (IDS_FIXED_PT))) ;
  1813. break;
  1815. default: break;
  1816.     }
  1817.     SetWindowText(hTextWnd, gtext);
  1818.     bReleaseInfoData(hwnd);
  1819.     return 0L;
  1820. }
  1822. case WM_SYSCOMMAND: {
  1823.     LONG        lResult;
  1825.     EnumChildWindows(ghwndClient, (WNDENUMPROC)lpfnSuspendThrd, lParam);
  1827.     lResult = DefMDIChildProc(hwnd, message, wParam, lParam);
  1829.     EnumChildWindows(ghwndClient, (WNDENUMPROC)lpfnResumeThrd, lParam);
  1831.     return lResult;
  1832.     break;
  1833. }
  1835. case WM_CREATE: {
  1836.     PINFO           pInfo;
  1837.     HANDLE          hInfo;
  1838.     HWND            hTextWnd, hJulia;
  1839.     RECT            rcl;
  1841.     //
  1842.     // CR! MakeProcInstance is noop!
  1843.     //
  1844.     lpfnSuspendThrd = (FARPROC)MakeProcInstance (SuspendDrawThrd, ghModule);
  1845.     lpfnResumeThrd  = (FARPROC)MakeProcInstance (ResumeDrawThrd, ghModule);
  1847.     hTextWnd = CreateWindow("Text", NULL,
  1848.     WS_BORDER | SS_LEFT | WS_CHILD | WS_VISIBLE,
  1849.     0, 0, 0, 0,
  1850.     hwnd,
  1851.     (HMENU) 2,
  1852.     ghModule,
  1853.     NULL);
  1855.     GetClientRect(hwnd, &rcl);
  1856.     hJulia = CreateWindow("Julia", (LPSTR) NULL,
  1857.   WS_CHILD      | WS_VISIBLE     |
  1858.   WS_BORDER,
  1859.   0,0, rcl.right-rcl.left,
  1860.   rcl.bottom-rcl.top-GetWindowLong(hTextWnd, GWL_USERDATA),
  1861.   hwnd, (HMENU)1, ghModule, (LPVOID)NULL);
  1863.     SetWindowText(hTextWnd, GetStringRes (IDS_SELECT_DRAW_SET));
  1865.     hInfo = (HANDLE) ((LPMDICREATESTRUCT) ((LPCREATESTRUCT) lParam)->lpCreateParams)->lParam ;
  1866.     if (hInfo) {
  1867. if ((pInfo = (PINFO)LocalLock(hInfo)) == NULL) 
  1868. {
  1869.     OutputDebugString ("Failed in LocalLock, hNode");
  1870.     break;
  1871. } 
  1872. else 
  1873. {
  1874.     HDC hDC;
  1876.     if (!GetClientRect(hwnd, &pInfo->rcClient))
  1877. OutputDebugString ("Failed in GetClientRect!");
  1879.     pInfo->hTextWnd = hTextWnd;
  1880.     pInfo->hwnd = hJulia;
  1881.     hDC = GetDC(hJulia);
  1882.     pInfo->hHTPal = CreateHalftonePalette(hDC);
  1883.     ReleaseDC(hJulia, hDC);
  1884. #ifdef CYCLETHRD
  1885.     //
  1886.     // Creating a signal quit color cycling event
  1887.     //
  1888.     if ((pInfo->hQuitEvent = CreateEvent(NULL, TRUE, TRUE, NULL)) == NULL)
  1889. OutputDebugString ("Failed in creating Quit Event!");
  1890. #endif
  1891.     SetWindowLong(hwnd, 0, (LONG) hInfo);
  1892.     LocalUnlock(hInfo);
  1893. }
  1894.     } 
  1895. else 
  1896. {
  1897. OutputDebugString ("Can't allocate hInfo!");
  1898.     }
  1900. #if 0
  1901.     //
  1902.     // Initialize printers here will detect printers availiability
  1903.     // more often, but kind of overkill.
  1904.     //
  1905.     bInitPrinter(hwnd);
  1906. #endif
  1907.     break;
  1908. }
  1910. case WM_CLOSE: {
  1911.     SendMessage(GetParent(hwnd), WM_MDISETMENU,
  1912.     (DWORD) hMenu,
  1913.     (LONG)  hSubMenuOne) ;
  1914.     DrawMenuBar(GetParent(GetParent(hwnd))) ;
  1915.     break;
  1916. }
  1918. case WM_DESTROY: {
  1919.     PINFO            pInfo;
  1920.     if ((pInfo = pGetInfoData(hwnd)) == NULL) {
  1921. break;
  1922.     }
  1924.     if (pInfo->hThrd) {
  1925. TerminateThread(pInfo->hThrd, (DWORD)0L);
  1926. CloseHandle(pInfo->hThrd);
  1927.     }
  1928.     if (pInfo->hPrtThrd) {
  1929. TerminateThread(pInfo->hPrtThrd, (DWORD)0L);
  1930. CloseHandle(pInfo->hPrtThrd);
  1931.     }
  1932.     if (pInfo->hCycleThrd) {
  1933. TerminateThread(pInfo->hCycleThrd, (DWORD)0L);
  1934. CloseHandle(pInfo->hCycleThrd);
  1935.     }
  1938. #ifdef CYCLETHRD
  1939.     //
  1940.     // Cleanup color cycling
  1941.     //
  1942.     if (!ResetEvent(pInfo->hQuitEvent))
  1943. OutputDebugString ("Failed in reseting quit event!");
  1944. #endif
  1945.     if (pInfo->hBmpMono)
  1946. DeleteObject(pInfo->hBmpMono);
  1948.     if (pInfo->hBmpSaved)
  1949. DeleteObject(pInfo->hBmpSaved);
  1951.     if (pInfo->hBrush)
  1952. DeleteObject(pInfo->hBrush);
  1954.     bReleaseInfoData(hwnd);
  1955.     LocalFree((HANDLE) GetWindowLong(hwnd, 0));
  1956.     break;
  1957. }
  1959. default:
  1960.     return DefMDIChildProc(hwnd, message, wParam, lParam);
  1962.     } //switch
  1963.     return DefMDIChildProc(hwnd, message, wParam, lParam);
  1964. }
  1966. /******************************Public*Routine******************************
  1967. *
  1968. * ViewerWndProc
  1969. *
  1970. * Effects:
  1971. *
  1972. * Warnings:
  1973. *
  1974. **************************************************************************/
  1976. LONG APIENTRY ViewerWndProc(
  1977.     HWND hwnd,
  1978.     UINT message,
  1979.     DWORD wParam,
  1980.     LONG lParam)
  1981. {
  1982.     static FARPROC     lpfnSuspendThrd, lpfnResumeThrd;
  1984.     switch (message) {
  1985. case WM_COMMAND: {
  1986.   PINFO       pInfo;
  1987.   HWND        hTextWnd;
  1989.   switch (LOWORD(wParam)) {
  1990.     case MM_RLELOAD_DEMO: {
  1991. HDC             hDC;
  1992. char            szDirName[256];
  1993. char            szFile[400];
  1994. HWND            hViewSurf;
  1996. GetCurrentDirectory(256, (LPTSTR) szDirName);
  1998. if ((pInfo = pGetInfoData(hwnd)) == NULL) {
  1999.     return 0L;
  2000. }
  2002. if ((hViewSurf = pInfo->hwnd) == NULL)
  2003.     return 0L;
  2005. hTextWnd = pInfo->hTextWnd;
  2006. sprintf( gtext,"Loading bitmap(s) into memory");
  2007. SetWindowText(hTextWnd, gtext);
  2009. hDC = GetDC(hViewSurf);
  2010. strcpy(szFile, szDirName);
  2011. strcat(szFile, "\rsc\julia.rle");
  2013. if (bStoreRleFile(hDC, pInfo, szFile)) {
  2014.     pInfo->RleData.ulFiles++;
  2015.     PostMessage(ghwndMain, WM_COMMAND, MM_RLEPLAYCONT, 0L);
  2016. }
  2018. ReleaseDC(hViewSurf, hDC);
  2020. bReleaseInfoData(hwnd);
  2021. return 0L;
  2023.     }
  2026.     case MM_RLELOAD: {
  2027. HDC             hDC;
  2028. OPENFILENAME    ofn;
  2029. char            szDirName[256];
  2030. char            szFile[256], szFileTitle[256];
  2031. static char     *szFilter;
  2032. RECT            rc;
  2033. HWND            hViewSurf;
  2035. szFilter = GetStringRes (IDS_FILE_LIST1);
  2037. GetSystemDirectory((LPSTR) szDirName, 256);
  2038. strcpy(szFile, "*.bmp");
  2039. ofn.lStructSize = sizeof(OPENFILENAME);
  2040. ofn.hwndOwner = hwnd;
  2041. ofn.lpstrFilter = szFilter;
  2042. ofn.lpstrCustomFilter = (LPSTR) NULL;
  2043. ofn.nMaxCustFilter = 0L;
  2044. ofn.nFilterIndex = 1;
  2045. ofn.lpstrFile = szFile;
  2046. ofn.nMaxFile = sizeof(szFile);
  2047. ofn.lpstrFileTitle = szFileTitle;
  2048. ofn.nMaxFileTitle = sizeof(szFileTitle);
  2049. ofn.lpstrInitialDir = szDirName;
  2050. ofn.lpstrTitle = (LPSTR) NULL;
  2051. ofn.Flags = 0L;
  2052. ofn.nFileOffset = 0;
  2053. ofn.nFileExtension = 0;
  2054. ofn.lpstrDefExt = "BMP";
  2056. if (!GetOpenFileName(&ofn))
  2057.     return 0L;
  2059. if ((pInfo = pGetInfoData(hwnd)) == NULL) {
  2060.     return 0L;
  2061. }
  2063. if ((hViewSurf = pInfo->hwnd) == NULL)
  2064.     return 0L;
  2066. hTextWnd = pInfo->hTextWnd;
  2067. sprintf( gtext, GetStringRes (IDS_LOADING_BITMAPS));
  2068. SetWindowText(hTextWnd, gtext);
  2070. GetClientRect(hwnd, &rc);
  2071. hDC = GetDC(hViewSurf);
  2072. if (bStoreRleFile(hDC, pInfo, szFile))
  2073.     pInfo->RleData.ulFiles++;
  2074. ReleaseDC(hViewSurf, hDC);
  2076. bReleaseInfoData(hwnd);
  2077. return 0L;
  2079.     }
  2081.     case MM_RLESAVE: {
  2082. HDC             hDC;
  2083. OPENFILENAME    ofn;
  2084. char            szDirName[256];
  2085. char            szFile[256], szFileTitle[256];
  2086. static char     *szFilter;
  2087. HWND            hViewSurf;
  2089. szFilter = GetStringRes (IDS_FILE_LIST3);
  2091. GetSystemDirectory((LPSTR) szDirName, 256);
  2092. strcpy(szFile, "*.rle");
  2093. ofn.lStructSize = sizeof(OPENFILENAME);
  2094. ofn.hwndOwner = hwnd;
  2095. ofn.lpstrFilter = szFilter;
  2096. ofn.lpstrCustomFilter = (LPSTR) NULL;
  2097. ofn.nMaxCustFilter = 0L;
  2098. ofn.nFilterIndex = 0L;
  2099. ofn.lpstrFile = szFile;
  2100. ofn.nMaxFile = sizeof(szFile);
  2101. ofn.lpstrFileTitle = szFileTitle;
  2102. ofn.nMaxFileTitle = sizeof(szFileTitle);
  2103. ofn.lpstrInitialDir = szDirName;
  2104. ofn.lpstrTitle = GetStringRes(IDS_SAVING_MEMORY_RLE); 
  2105. ofn.Flags = OFN_SHOWHELP | OFN_OVERWRITEPROMPT;
  2106. ofn.nFileOffset = 0;
  2107. ofn.nFileExtension = 0;
  2108. ofn.lpstrDefExt = (LPSTR)NULL;
  2110. if (!GetSaveFileName(&ofn))
  2111.     return 0L;
  2113. if ((pInfo = pGetInfoData(hwnd)) == NULL) {
  2114.     return 0L;
  2115. }
  2117. if ((hViewSurf = pInfo->hwnd) == NULL)
  2118.     return 0L;
  2120. hTextWnd = pInfo->hTextWnd;
  2121. sprintf( gtext, GetStringRes (IDS_SAVING_LOADED_BMP)); 
  2122. SetWindowText(hTextWnd, gtext);
  2124. hDC = GetDC(hViewSurf);
  2125. bSaveRleFile(hDC, pInfo, szFile);
  2126. ReleaseDC(hViewSurf, hDC);
  2128. bReleaseInfoData(hwnd);
  2129. return 0L;
  2130.     }
  2132.     case MM_CLEAR: {
  2133. if ((pInfo = pGetInfoData(hwnd)) == NULL) {
  2134.     return 0L;
  2135. }
  2137. hTextWnd = pInfo->hTextWnd;
  2138. sprintf( gtext,GetStringRes (IDS_DISCARD_LOADED_BMP));
  2139. SetWindowText(hTextWnd, gtext);
  2141. bFreeRleFile(pInfo);
  2143. bReleaseInfoData(hwnd);
  2144. return 0L;
  2145.     }
  2147.     case MM_RLEPLAY: {
  2148. HDC     hDC;
  2149. HWND    hViewSurf;
  2151. if ((pInfo = pGetInfoData(hwnd)) == NULL) {
  2152.     return 0L;
  2153. }
  2155. if ((hViewSurf = pInfo->hwnd) == NULL)
  2156.     return 0L;
  2158. hTextWnd = pInfo->hTextWnd;
  2159. sprintf( gtext, GetStringRes (IDS_PLAY_LOADED_BMP)); 
  2160. SetWindowText(hTextWnd, gtext);
  2162. hDC = GetDC(hViewSurf);
  2163. EnableMenuItem(hViewSubOne, MM_CLEAR, MF_GRAYED);
  2165. if (pInfo->hThrd0)
  2166.     CloseHandle(pInfo->hThrd0);
  2168. pInfo->hThrd0 = CreateThread(NULL, 0,
  2169.      (LPTHREAD_START_ROUTINE)bPlayRle,
  2170.      pInfo,
  2171.      STANDARD_RIGHTS_REQUIRED,
  2172.      &pInfo->dwThreadId );
  2174. if (pInfo->hThrd0) 
  2175. {
  2176.     if (!SetThreadPriority(pInfo->hThrd0, THREAD_PRIORITY_BELOW_NORMAL))
  2177.    OutputDebugString ("Can't set Priority!");
  2178. }
  2180. //bPlayRle(hDC, pInfo);
  2181. EnableMenuItem(hViewSubOne, MM_CLEAR, MF_ENABLED);
  2182. ReleaseDC(hViewSurf, hDC);
  2184. bReleaseInfoData(hwnd);
  2185. return 0L;
  2186.     }
  2188.     case MM_RLEPLAYCONT: {
  2189. HWND    hViewSurf;
  2191. if ((pInfo = pGetInfoData(hwnd)) == NULL) {
  2192.     return 0L;
  2193. }
  2195. if ((hViewSurf = pInfo->hwnd) == NULL)
  2196.     return 0L;
  2198. hTextWnd = pInfo->hTextWnd;
  2199. sprintf( gtext, GetStringRes (IDS_PLAY_BMP_CONT));
  2200. SetWindowText(hTextWnd, gtext);
  2202. if (pInfo->bFirstTime) 
  2203. {
  2204.     if (!SetEvent(pInfo->hQuitEvent)) 
  2205. {
  2206. OutputDebugString ("Can't set Quit Event!");
  2207.     return 0L;
  2208.     }
  2210.     EnableMenuItem(hViewSubOne, MM_CLEAR, MF_GRAYED);
  2212.     if (pInfo->hThrd)
  2213. CloseHandle(pInfo->hThrd);
  2215.     pInfo->hThrd = CreateThread(NULL, 0,
  2216.  (LPTHREAD_START_ROUTINE)bPlayRleCont2,
  2217.  pInfo,
  2218.  STANDARD_RIGHTS_REQUIRED,
  2219.  &pInfo->dwThreadId );
  2221.     if (pInfo->hThrd) {
  2222. if (!SetThreadPriority(pInfo->hThrd, THREAD_PRIORITY_BELOW_NORMAL))
  2223.      OutputDebugString ("Can't set Priority!");
  2224.     }
  2226.     pInfo->bPlayRleCont = TRUE;
  2227.     pInfo->bFirstTime = FALSE;
  2228.     CheckMenuItem(hViewMenu, MM_RLEPLAYCONT, MF_CHECKED);
  2229. } 
  2230. else 
  2231. {
  2232.     if (pInfo->bPlayRleCont) {
  2233. EnableMenuItem(hViewSubOne, MM_CLEAR, MF_ENABLED);
  2234. CheckMenuItem(hViewMenu, MM_RLEPLAYCONT, MF_UNCHECKED);
  2235. pInfo->bPlayRleCont = FALSE;
  2236. pInfo->dwSuspend = SuspendThread(pInfo->hThrd);
  2237.     } else {
  2238. EnableMenuItem(hViewSubOne, MM_CLEAR, MF_GRAYED);
  2239. CheckMenuItem(hViewMenu, MM_RLEPLAYCONT, MF_CHECKED);
  2240. pInfo->bPlayRleCont = TRUE;
  2241. pInfo->dwSuspend = ResumeThread(pInfo->hThrd);
  2242.     }
  2243.     if (pInfo->dwSuspend == -1) {
  2244. (pInfo->bPlayRleCont ?
  2245.  sprintf( gtext,"Error in resuming threadn") :
  2246.  sprintf( gtext,"Error in suspending threadn")  );
  2247. OutputDebugString( gtext );
  2248.     }
  2249. }
  2251. bReleaseInfoData(hwnd);
  2252. return 0L;
  2253.     }
  2255.     default:
  2256.        return 0L;
  2258.   } //switch
  2260. } // WM_COMMAND
  2261. case WM_SETFOCUS:
  2262.     break;
  2264. case WM_MDIACTIVATE: {
  2265.     PINFO       pInfo;
  2267.     if ((pInfo = pGetInfoData(hwnd)) == NULL) {
  2268. return 0L;
  2269.     }
  2271.     if ((HWND) lParam == hwnd) {
  2272. SendMessage(GetParent(hwnd), WM_MDISETMENU,
  2273.     (WPARAM)  hViewMenu,
  2274.     (LPARAM)  NULL) ;
  2275. DrawMenuBar(GetParent(GetParent(hwnd))) ;
  2276.     }
  2278.     bReleaseInfoData(hwnd);
  2279.     return 0L;
  2280. }
  2281. case WM_QUERYNEWPALETTE:
  2282. case WM_PALETTECHANGED: {
  2283.     PINFO       pInfo;
  2285.     if ((pInfo = pGetInfoData(hwnd)) == NULL) {
  2286. return 0L;
  2287.     }
  2289.     SendMessage(pInfo->hwnd, message, wParam, lParam);
  2290.     bReleaseInfoData(hwnd);
  2291.     return 0L;
  2292. }
  2294. case WM_SIZE: {
  2295.     PINFO       pInfo;
  2296.     HWND        hTextWnd, hView;
  2297.     WORD        wCx;
  2298.     int         iCyText;
  2300.     if ((pInfo = pGetInfoData(hwnd)) == NULL) {
  2301. break;
  2302.     }
  2304.     hTextWnd = pInfo->hTextWnd;
  2305.     hView    = pInfo->hwnd;
  2306.     bReleaseInfoData(hwnd);
  2307.     iCyText = GetWindowLong(hTextWnd, GWL_USERDATA);
  2308.     wCx = (WORD) (HIWORD(lParam) - iCyText);
  2310.     MoveWindow(hView, 0, 0,
  2311.    LOWORD(lParam),
  2312.    wCx,
  2313.    TRUE);
  2315.     MoveWindow(hTextWnd,
  2316.        0,
  2317.        wCx,
  2318.        LOWORD(lParam),
  2319.        iCyText,
  2320.        TRUE);
  2322.     break;
  2323. }
  2325. //
  2326. // display info in the status window
  2327. //
  2328. case WM_USER+0xa: {
  2329.     PINFO       pInfo;
  2330.     static ULONG ulClick = 0;
  2331.     HWND        hTextWnd;
  2333.     ulClick++;
  2334.     if ((pInfo = pGetInfoData(hwnd)) == NULL) {
  2335. return 0L;
  2336.     }
  2338.     hTextWnd = pInfo->hTextWnd;
  2339.     switch (ulClick % 4) {
  2340. case 0: 
  2341. sprintf( gtext, GetStringRes (IDS_FRAMES)); 
  2342. break;
  2343. case 1: 
  2344. sprintf( gtext, GetStringRes (IDS_FRAMES));
  2345. break;
  2346. case 2: sprintf( gtext, (pInfo->bPlayRleCont ? 
  2347.                GetStringRes (IDS_CONT_PLAY) :
  2348.                        GetStringRes (IDS_SINGLE_PLAY)));
  2349. break;
  2350. case 3: sprintf( gtext,"");
  2351. break;
  2352. default: break;
  2353.     }
  2354.     SetWindowText(hTextWnd, gtext);
  2355.     bReleaseInfoData(hwnd);
  2356.     return 0L;
  2357. }
  2359. case WM_SYSCOMMAND: {
  2360.     LONG        lResult;
  2362.     EnumChildWindows(ghwndClient, (WNDENUMPROC)lpfnSuspendThrd, lParam);
  2364.     lResult = DefMDIChildProc(hwnd, message, wParam, lParam);
  2366.     EnumChildWindows(ghwndClient, (WNDENUMPROC)lpfnResumeThrd, lParam);
  2368.     return lResult;
  2369.     break;
  2370. }
  2372. case WM_CREATE: {
  2373.     PINFO           pInfo;
  2374.     HANDLE          hInfo;
  2375.     HWND            hTextWnd, hView;
  2376.     RECT            rcl;
  2378.     //
  2379.     // CR! MakeProcInstance is noop!
  2380.     //
  2381.     lpfnSuspendThrd = (FARPROC)MakeProcInstance (SuspendDrawThrd, ghModule);
  2382.     lpfnResumeThrd  = (FARPROC)MakeProcInstance (ResumeDrawThrd, ghModule);
  2384.     hTextWnd = CreateWindow("Text", NULL,
  2385.     WS_BORDER | SS_LEFT | WS_CHILD | WS_VISIBLE,
  2386.     0, 0, 0, 0,
  2387.     hwnd,
  2388.     (HMENU) 2,
  2389.     ghModule,
  2390.     NULL);
  2392.     GetClientRect(hwnd, &rcl);
  2393.     hView = CreateWindow("View", (LPSTR) NULL,
  2394.   WS_CHILD      | WS_VISIBLE     |
  2395.   WS_BORDER,
  2396.   0,0, rcl.right-rcl.left,
  2397.   rcl.bottom-rcl.top-GetWindowLong(hTextWnd, GWL_USERDATA),
  2398.   hwnd, (HMENU)1, ghModule, (LPVOID)NULL);
  2400.     SetWindowText(hTextWnd, GetStringRes (IDS_SELECT_DRAW_SET));
  2401.     hInfo = (HANDLE) ((LPMDICREATESTRUCT) ((LPCREATESTRUCT) lParam)->lpCreateParams)->lParam ;
  2402.     if (hInfo) {
  2403. if ((pInfo = (PINFO)LocalLock(hInfo)) == NULL) 
  2404. {
  2405.     OutputDebugString ("Failed in LocalLock, hNode");
  2406.     break;
  2407. } 
  2408. else 
  2409. {
  2410.     HDC hDC;
  2412.     if (!GetClientRect(hwnd, &pInfo->rcClient))
  2413. OutputDebugString ("Failed in GetClientRect!");
  2415.     pInfo->hTextWnd = hTextWnd;
  2416.     pInfo->hwnd = hView;
  2418.     hDC = GetDC(hView);
  2419.     pInfo->hHTPal = CreateHalftonePalette(hDC);
  2420.     ReleaseDC(hView, hDC);
  2422.     //
  2423.     // Creating a signal quit play continuous event
  2424.     //
  2425.     if ((pInfo->hQuitEvent = CreateEvent(NULL, TRUE, TRUE, NULL)) == NULL)
  2426. OutputDebugString ("Failed in creating Quit Event!");
  2428.     SetWindowLong(hwnd, 0, (LONG) hInfo);
  2429.     LocalUnlock(hInfo);
  2430. }
  2431.     } 
  2432. else 
  2433. {
  2434. OutputDebugString ("Can't allocate hInfo!");
  2435.     }
  2437.     break;
  2438. }
  2440. case WM_CLOSE: {
  2441.     SendMessage(GetParent(hwnd), WM_MDISETMENU,
  2442.     (DWORD) hMenu,
  2443.     (LONG)  hSubMenuOne) ;
  2444.     DrawMenuBar(GetParent(GetParent(hwnd))) ;
  2445.     break;
  2446. }
  2448. case WM_DESTROY: {
  2449.     PINFO            pInfo;
  2450.     if ((pInfo = pGetInfoData(hwnd)) == NULL) {
  2451. break;
  2452.     }
  2454.     TerminateThread(pInfo->hThrd, (DWORD)0L);
  2455.     CloseHandle(pInfo->hThrd);
  2457.     //
  2458.     // Cleanup continuous play
  2459.     //
  2460.     if (!ResetEvent(pInfo->hQuitEvent))
  2461. OutputDebugString ("Failed in reseting quit event!");
  2463.     bFreeRleFile(pInfo);
  2464.     bReleaseInfoData(hwnd);
  2465.     LocalFree((HANDLE) GetWindowLong(hwnd, 0));
  2466.     break;
  2467. }
  2469. default:
  2470.     return DefMDIChildProc(hwnd, message, wParam, lParam);
  2472.     } //switch
  2473.     return DefMDIChildProc(hwnd, message, wParam, lParam);
  2474. }
  2476. /******************************Public*Routine******************************
  2477. *
  2478. * ViewSurfWndProc
  2479. *
  2480. * Effects:
  2481. *
  2482. * Warnings:
  2483. *
  2484. **************************************************************************/
  2486. LONG APIENTRY ViewSurfWndProc (HWND hwnd, UINT message, DWORD wParam, LONG lParam)
  2487. {
  2488.     switch (message)
  2489.     {
  2490.        case WM_CREATE: {
  2491.     break;
  2492.        }
  2494.        case WM_DESTROY: {
  2495.     break;
  2496.        }
  2498.        case WM_QUERYNEWPALETTE: {
  2499.      HWND        hParent;
  2500.      PINFO       pInfo;
  2501.      HDC         hDC;
  2502.      UINT        i;
  2503.      HPALETTE    hOldPal;
  2505.      if ((hParent=GetParent(hwnd)) == NULL) 
  2506.  {
  2507. OutputDebugString ("Can't get hParent!");
  2508. return 0L;
  2509.      }
  2510.      if ((pInfo = pGetInfoData(hParent)) == NULL) {
  2511.   return 0L;
  2512.      }
  2514.      // If palette realization causes a palette change,
  2515.      // we need to do a full redraw.
  2517.      hDC = GetDC (hwnd);
  2519.      hOldPal = SelectPalette (hDC,
  2520.        pInfo->RleData.hPal,
  2521.        0);
  2523.      i = RealizePalette(hDC);
  2525.      SelectPalette (hDC, hOldPal, 0);
  2526.      ReleaseDC (hwnd, hDC);
  2527.      bReleaseInfoData(hParent);
  2529.      if (i) {
  2530.  InvalidateRect (hwnd, (LPRECT) (NULL), TRUE);
  2531.  return TRUE;
  2532.      } else
  2533.  return FALSE;
  2535.        }
  2536.        case WM_PALETTECHANGED: {
  2537.      HWND        hParent;
  2538.      PINFO       pInfo;
  2539.      HDC         hDC;
  2540.      UINT        i;
  2541.      HPALETTE    hOldPal;
  2543.      if ((hParent=GetParent(hwnd)) == NULL) {
  2544.  MessageBox(ghwndMain, "Can't get hParent!", "Error", MB_OK);
  2545.  return 0L;
  2546.      }
  2547.      if ((pInfo = pGetInfoData(hParent)) == NULL) {
  2548.   return 0L;
  2549.      }
  2551.      // if we were not responsible for palette change and if
  2552.      // palette realization causes a palette change, do a redraw.
  2554.      if ((HWND)wParam != hwnd){
  2555. hDC = GetDC (hwnd);
  2557. hOldPal = SelectPalette (hDC,
  2558. pInfo->RleData.hPal,
  2559. 0);
  2561. i = RealizePalette (hDC);
  2563. if (i){
  2564.     UpdateColors (hDC);
  2565. }
  2566. SelectPalette (hDC, hOldPal, 0);
  2567. ReleaseDC (hwnd, hDC);
  2568.     }
  2569.     bReleaseInfoData(hParent);
  2570.     break;
  2571.        }
  2573.        case WM_PAINT:
  2574.  {
  2575.      PAINTSTRUCT ps;
  2576.      HDC         hDC;
  2577.      RECT        rc;
  2579.      GetClientRect(hwnd,&rc);
  2580.      hDC = BeginPaint(hwnd, &ps);
  2581.      EndPaint(hwnd, &ps);
  2582.      return 0L;
  2583.  }
  2585.     } // switch
  2586.     return DefWindowProc(hwnd, message, wParam, lParam);
  2587. }
  2589. /***************************************************************************
  2590. * About
  2591. *
  2592. * About dialog proc.
  2593. *
  2594. ***************************************************************************/
  2596. BOOL CALLBACK About(
  2597.     HWND hDlg,
  2598.     UINT message,
  2599.     DWORD wParam,
  2600.     LONG lParam)
  2601. {
  2602.     switch (message) {
  2603.     case WM_INITDIALOG:
  2604. return TRUE;
  2606.     case WM_COMMAND:
  2607. if (wParam == IDOK)
  2608.     EndDialog(hDlg, wParam);
  2609. break;
  2610.     }
  2612.     return FALSE;
  2614.     UNREFERENCED_PARAMETER(lParam);
  2615.     UNREFERENCED_PARAMETER(hDlg);
  2616. }
  2618. /*************************************************************************
  2619. *
  2620. * TextWndProc
  2621. *
  2622. * Text Window proc.
  2623. *
  2624. ***************************************************************************/
  2626. LONG APIENTRY TextWndProc (HWND hwnd, UINT message, DWORD wParam, LONG lParam)
  2627. {
  2628.     static HFONT hFont = (HFONT) NULL;
  2630.     switch (message)
  2631.     {
  2632.     case WM_CREATE:
  2633. {
  2634.     LOGFONT    lf;
  2635.     HDC        hDC;
  2636.     HFONT      hOldFont;
  2637.     TEXTMETRIC tm;
  2638.     RECT       rect;
  2639.     LONG       lHeight;
  2641.     SystemParametersInfo(SPI_GETICONTITLELOGFONT, sizeof(lf), (PVOID) &lf, FALSE);
  2643.     hDC = GetDC(hwnd);
  2644.     // this is the height for 8 point size font in pixels
  2645.     lf.lfHeight = 8 * GetDeviceCaps(hDC, LOGPIXELSY) / 72;
  2647.     hFont = CreateFontIndirect(&lf);
  2648.     hOldFont = SelectObject(hDC, hFont);
  2649.     GetTextMetrics(hDC, &tm);
  2650.     GetClientRect(GetParent(hwnd), &rect);
  2652.     // base the height of the window on size of text
  2653.     lHeight = tm.tmHeight+6*GetSystemMetrics(SM_CYBORDER)+2;
  2654.     // saved the height for later reference
  2655.     SetWindowLong(hwnd, GWL_USERDATA, lHeight);
  2656.     SetWindowPos(hwnd, NULL,
  2657.     0,
  2658.     rect.bottom-lHeight,
  2659.     rect.right-rect.left,
  2660.     lHeight,
  2661.     SWP_NOZORDER | SWP_NOMOVE);
  2663.     ReleaseDC(hwnd, hDC);
  2664.     break;
  2665. }
  2667.     case WM_LBUTTONDOWN: {
  2668. PostMessage(GetParent(hwnd), WM_USER+0xa, (DWORD)0L, (LONG)0L);
  2669. break;
  2670.     }
  2672.     case WM_DESTROY:
  2673.     if (hFont)
  2674. DeleteObject(hFont);
  2675.     break;
  2677.     case WM_SETTEXT:
  2678.     DefWindowProc(hwnd, message, wParam, lParam);
  2679.     InvalidateRect(hwnd,NULL,TRUE);
  2680.     UpdateWindow(hwnd);
  2681.     return 0L;
  2683.     case WM_PAINT:
  2684. {
  2685.     PAINTSTRUCT ps;
  2686.     RECT   rc;
  2687.     char   ach[128];
  2688.     int    len, nxBorder, nyBorder;
  2689.     HFONT  hOldFont = NULL;
  2691.     BeginPaint(hwnd, &ps);
  2693.     GetClientRect(hwnd,&rc);
  2695.     nxBorder = GetSystemMetrics(SM_CXBORDER);
  2696.     rc.left  += 9*nxBorder;
  2697.     rc.right -= 9*nxBorder;
  2699.     nyBorder = GetSystemMetrics(SM_CYBORDER);
  2700.     rc.top    += 3*nyBorder;
  2701.     rc.bottom -= 3*nyBorder;
  2703.     // 3D Text
  2704.     len = GetWindowText(hwnd, ach, sizeof(ach));
  2705.     SetBkColor(ps.hdc, GetSysColor(COLOR_BTNFACE));
  2707.     SetBkMode(ps.hdc, TRANSPARENT);
  2708.     SetTextColor(ps.hdc, RGB(64,96,96));
  2709.     if (hFont)
  2710. hOldFont = SelectObject(ps.hdc, hFont);
  2711.     ExtTextOut(ps.hdc, rc.left+2*nxBorder+2, rc.top+2, ETO_OPAQUE | ETO_CLIPPED,
  2712. &rc, ach, len, NULL);
  2714.     SetTextColor(ps.hdc, RGB(128,128,128));
  2715.     if (hFont)
  2716. hOldFont = SelectObject(ps.hdc, hFont);
  2717.     ExtTextOut(ps.hdc, rc.left+2*nxBorder+1, rc.top+1, ETO_CLIPPED,
  2718. &rc, ach, len, NULL);
  2720.     SetTextColor(ps.hdc, RGB(255,255,255));
  2721.     if (hFont)
  2722. hOldFont = SelectObject(ps.hdc, hFont);
  2723.     ExtTextOut(ps.hdc, rc.left+2*nxBorder, rc.top, ETO_CLIPPED,
  2724. &rc, ach, len, NULL);
  2726.     SetBkMode(ps.hdc, OPAQUE);
  2728.     if (hOldFont)
  2729. SelectObject(ps.hdc, hOldFont);
  2731.     EndPaint(hwnd, &ps);
  2732.     return 0L;
  2733. }
  2734.     }
  2735.     return DefWindowProc(hwnd, message, wParam, lParam);
  2736. }
  2739. /**************************************************************************
  2740. *
  2741. * JuliaWndProc
  2742. *
  2743. **************************************************************************/
  2745. LONG APIENTRY JuliaWndProc (HWND hwnd, UINT message, DWORD wParam, LONG lParam)
  2746. {
  2747.     //
  2748.     // These statics are shared by all the Julia windows.  But, this is
  2749.     // fine because only one Julia window is tracking at any one time.
  2750.     // Ideally, we should place this in the per-window INFO data structure.
  2751.     // But, this is not necessary.
  2752.     //
  2753.     static BOOL    bTrack = FALSE;
  2754.     static int     OrgX, OrgY;
  2755.     static int     PrevX, PrevY;
  2756.     static HDC     hDC;
  2757.     static HCURSOR hCurArrow, hCurPaintCan;
  2759.     switch (message)
  2760.     {
  2761.        case WM_CREATE: {
  2763.     hpnRed     = CreatePen(PS_SOLID, 0, RGB(0xFF, 0,    0));
  2764.     hpnGreen   = CreatePen(PS_SOLID, 0, RGB(0,    0xFF, 0));
  2765.     hpnBlack   = CreatePen(PS_SOLID, 0, RGB(0,    0,    0));
  2767.     hCurPaintCan = LoadCursor(ghModule, MAKEINTRESOURCE(PAINTCURSOR));
  2768.     hCurArrow = LoadCursor(NULL, IDC_ARROW);
  2769.     break;
  2770.        }
  2772.        case WM_DESTROY: {
  2773.     HWND        hParent;
  2774.     PINFO       pInfo;
  2776.     DeleteObject(hpnRed);
  2777.     DeleteObject(hpnGreen);
  2778.     DeleteObject(hpnBlack);
  2780.     if ((hParent=GetParent(hwnd)) == NULL) 
  2781. {
  2782. OutputDebugString ("Can't get hParent!");
  2783. break;
  2784.     }
  2785.     if ((pInfo = pGetInfoData(hParent)) == NULL) {
  2786. break;
  2787.     }
  2789.     // we might have open resource if we ever load bitmap in this wnd.
  2790.     bFreeRleFile(pInfo);
  2791.     bReleaseInfoData(hParent);
  2792.     break;
  2793.        }
  2795.        case WM_QUERYNEWPALETTE: {
  2796.      HWND        hParent;
  2797.      PINFO       pInfo;
  2798.      HDC         hDC;
  2799.      UINT        i;
  2800.      HPALETTE    hOldPal;
  2802.      if ((hParent=GetParent(hwnd)) == NULL) 
  2803.  {
  2804. OutputDebugString ("Can't get hParent!");
  2805. return 0L;
  2806.      }
  2807.      if ((pInfo = pGetInfoData(hParent)) == NULL) {
  2808.   return 0L;
  2809.      }
  2811.      // If palette realization causes a palette change,
  2812.      // we need to do a full redraw.
  2814.      hDC = GetDC (hwnd);
  2816.      hOldPal = SelectPalette (hDC,
  2817.        ((pInfo->iStretchMode == HALFTONE) ? pInfo->hHTPal : pInfo->hPal),
  2818.        0);
  2820.      i = RealizePalette(hDC);
  2821.      SelectPalette (hDC, hOldPal, 0);
  2822.      ReleaseDC (hwnd, hDC);
  2823.      bReleaseInfoData(hParent);
  2825.      if (i) {
  2826.  InvalidateRect (hwnd, (LPRECT) (NULL), TRUE);
  2827.  return TRUE;
  2828.      } else
  2829.  return FALSE;
  2831.        }
  2832.        case WM_PALETTECHANGED: {
  2833.      HWND        hParent;
  2834.      PINFO       pInfo;
  2835.      HDC         hDC;
  2836.      UINT        i;
  2837.      HPALETTE    hOldPal;
  2839.      if ((hParent=GetParent(hwnd)) == NULL) {
  2840. OutputDebugString ("Can't get hParent!");
  2841. return 0L;
  2842.      }
  2843.      if ((pInfo = pGetInfoData(hParent)) == NULL) {
  2844.   return 0L;
  2845.      }
  2847.      // if we were not responsible for palette change and if
  2848.      // palette realization causes a palette change, do a redraw.
  2850.      if ((HWND)wParam != hwnd){
  2851. hDC = GetDC (hwnd);
  2853. hOldPal = SelectPalette (hDC,
  2854.        ((pInfo->iStretchMode == HALFTONE) ? pInfo->hHTPal : pInfo->hPal),
  2855. 0);
  2857. i = RealizePalette (hDC);
  2859. if (i){
  2860.     UpdateColors (hDC);
  2861. }
  2862. SelectPalette (hDC, hOldPal, 0);
  2863. ReleaseDC (hwnd, hDC);
  2864.     }
  2865.     bReleaseInfoData(hParent);
  2866.     break;
  2867.        }
  2869.        case WM_PAINT: