home *** CD-ROM | disk | FTP | other *** search
/ Mega A/V / mega_av.zip / mega_av / GRAPHUTL / WINS1651.ZIP / MATHTOOL.C < prev    next >
C/C++ Source or Header  |  1991-11-06  |  15KB  |  545 lines
  1. /* MathTools.c was written by:
  2.  
  3.       Mark C. Peterson
  4.       The Yankee Programmer
  5.       405-C Queen Street, Suite #181
  6.       Southington, CT 06489
  7.       (203) 276-9721
  8.  
  9.    If you make any changes to this file, please comment out the older
  10.    code with your name, date, and a short description of the change.
  11.  
  12.    Thanks!
  13.  
  14.                                  -Mark
  15.  
  16. */
  17.  
  18. #include <windows.h>
  19. #include "winfract.h"
  20. #include "mathtool.h"
  21. #include <math.h>
  22. #include <stdlib.h>
  23. #include "profile.h"
  24.  
  25. static char MTClassName[] =     "FFWMathTools";
  26. static char MTWindowTitle[] =   "Math Tools";
  27. HWND hFractalWnd, hMathToolsWnd, hCoordBox, hZoomDlg, hZoomBar;
  28. HANDLE hThisInst, hZoomBrush, hZoomPen;
  29. long FAR PASCAL MTWndProc();
  30. int MTWindowOpen = 0, CoordBoxOpen = 0, KillCoordBox = 0;
  31. int ZoomBarOpen = 0, KillZoomBar = 0, Zooming = 0, TrackingZoom = 0;
  32. POINT ZoomClick, ZoomCenter;
  33. int ZoomBarMax = 100, ZoomBarMin = -100;
  34. int Sizing = 1, ReSizing = 0;
  35.  
  36. static double Pi =  3.14159265359;
  37. FARPROC DefZoomProc;
  38.  
  39. RECT ZoomRect;
  40.  
  41. WORD CoordFormat = IDM_RECT;
  42. WORD AngleFormat = IDM_DEGREES;
  43.  
  44. extern unsigned xdots, ydots;
  45. extern double xxmin, yymin, xxmax, yymax, delxx, delyy;
  46. extern int ytop, ybottom, xleft, xright;
  47. extern BOOL zoomflag;
  48. extern int time_to_restart, time_to_cycle, time_to_reinit, calc_status;
  49. extern int win_xoffset, win_yoffset;
  50.  
  51. void XorZoomBox(void);
  52.  
  53. extern int win_xoffset, win_yoffset;   /* BDT 11/6/91 */
  54.  
  55.  
  56. /* Global Maintenance */
  57.  
  58. void CheckMathTools(void) {
  59.    if(KillCoordBox) {
  60.       KillCoordBox = 0;
  61.       SaveParamSwitch(CoordBoxStr, FALSE);
  62.       CheckMenuItem(GetMenu(hFractalWnd), IDM_COORD, MF_UNCHECKED);
  63.       DestroyWindow(hCoordBox);
  64.    }
  65.    if(KillZoomBar) {
  66.       XorZoomBox();
  67.       Zooming = 0;
  68.       KillZoomBar = 0;
  69.       SaveParamSwitch(ZoomBoxStr, FALSE);
  70.       CheckMenuItem(GetMenu(hFractalWnd), IDM_ZOOM, MF_UNCHECKED);
  71.       DestroyWindow(hZoomDlg);
  72.    }
  73. }
  74.  
  75. BOOL RegisterMathWindows(HANDLE hInstance) {
  76.     WNDCLASS  wc;
  77.  
  78.     SetToolsPath();
  79.     hThisInst = hInstance;
  80.  
  81.     wc.style = CS_OWNDC;
  82.     wc.lpfnWndProc = MTWndProc;
  83.     wc.cbClsExtra = 0;
  84.     wc.cbWndExtra = 0;
  85.     wc.hInstance = hInstance;
  86.     wc.hIcon = LoadIcon(hInstance, "MathToolIcon");
  87.     wc.hCursor = LoadCursor(NULL, IDC_ARROW);
  88.     wc.hbrBackground = GetStockObject(BLACK_BRUSH);
  89.     wc.lpszMenuName =  "MathToolsMenu";
  90.     wc.lpszClassName = MTClassName;
  91.  
  92.     return (RegisterClass(&wc));
  93. }
  94.  
  95.  
  96. /* Window Sizing */
  97.  
  98. void SizeWindow(HWND hWnd) {
  99.    if(Sizing) {
  100.       POINT w;
  101.  
  102.       w.x = xdots + (GetSystemMetrics(SM_CXFRAME) * 2);
  103.       w.y = ydots + (GetSystemMetrics(SM_CYFRAME) * 2) +
  104.                      GetSystemMetrics(SM_CYCAPTION) +
  105.                      GetSystemMetrics(SM_CYMENU);
  106.       ReSizing = 1;
  107.       ShowScrollBar(hWnd, SB_BOTH, FALSE);
  108.       SetWindowPos(hWnd, GetNextWindow(hWnd, GW_HWNDPREV), 0, 0,
  109.                    w.x, w.y, SWP_NOMOVE);
  110.       ReSizing = 0;
  111.    }
  112. }
  113.  
  114. void ReSizeWindow(HWND hWnd) {
  115.    if(Sizing) {
  116.       SizeWindow(hWnd);
  117.       ShowWindow(hWnd, SW_SHOWNA);
  118.    }
  119. }
  120.  
  121. void WindowSizing(HWND hWnd) {
  122.    if(Sizing) {
  123.       CheckMenuItem(GetMenu(hWnd), IDM_SIZING, MF_UNCHECKED);
  124.       Sizing = 0;
  125.       ShowScrollBar(hWnd, SB_BOTH, TRUE);
  126.    }
  127.    else {
  128.       CheckMenuItem(GetMenu(hWnd), IDM_SIZING, MF_CHECKED);
  129.       Sizing = 1;
  130.       ReSizeWindow(hWnd);
  131.    }
  132.    ProgStr = Winfract;
  133.    SaveParamSwitch(WindowSizingStr, Sizing);
  134. }
  135.  
  136.  
  137.  
  138. /* Zoom Box */
  139.  
  140. void XorZoomBox(void) {
  141.    HDC hDC;
  142.    HANDLE hOldBrush, hOldPen;
  143.    int OldMode;
  144.  
  145.    if(Zooming) {
  146.       hDC = GetDC(hFractalWnd);
  147.  
  148.       hOldBrush = SelectObject(hDC, hZoomBrush);
  149.       hOldPen = SelectObject(hDC, hZoomPen);
  150.       OldMode = SetROP2(hDC, R2_XORPEN);
  151.  
  152.       Rectangle(hDC, ZoomRect.left, ZoomRect.top, ZoomRect.right,
  153.                 ZoomRect.bottom);
  154.  
  155.       SelectObject(hDC, hOldBrush);
  156.       SelectObject(hDC, hOldPen);
  157.       SetROP2(hDC, OldMode);
  158.  
  159.       ReleaseDC(hFractalWnd, hDC);
  160.    }
  161. }
  162.  
  163. void PositionZoomBar(void) {
  164.    char Temp[15];
  165.  
  166.    SetScrollPos(hZoomBar, SB_CTL, Zooming, TRUE);
  167.    sprintf(Temp, "%d%%", Zooming);
  168.    SetDlgItemText(hZoomDlg, ID_PERCENT, Temp);
  169. }
  170.  
  171. void CalcZoomRect(void) {
  172.    unsigned Midx, Midy;
  173.    double z;
  174.  
  175.    if(Zooming) {
  176.       Midx = xdots >> 1;
  177.       Midy = ydots >> 1;
  178.       z = 1.0 - (fabs((double)Zooming / 100) * .99);
  179.       ZoomRect.left = ZoomCenter.x - (unsigned)(z * Midx) - 1;
  180.       ZoomRect.right = ZoomCenter.x + (unsigned)(z * Midx) + 1;
  181.       ZoomRect.top = ZoomCenter.y - (unsigned)(z * Midy) - 1;
  182.       ZoomRect.bottom = ZoomCenter.y + (unsigned)(z * Midy) + 1;
  183.    }
  184. }
  185.  
  186. void CenterZoom(void) {
  187.    ZoomCenter.x = xdots >> 1;
  188.    ZoomCenter.y = ydots >> 1;
  189. }
  190.  
  191. void StartZoomTracking(DWORD lp) {
  192.    HRGN hRgn;
  193.  
  194.    ZoomClick = MAKEPOINT(lp);
  195.    if(hRgn = CreateRectRgn(ZoomClick.x-1, ZoomClick.y-1, ZoomClick.x+1,
  196.                ZoomClick.y+1)) {
  197.       if(RectInRegion(hRgn, &ZoomRect))
  198.          TrackingZoom = TRUE;
  199.       DeleteObject(hRgn);
  200.    }
  201. }
  202.  
  203. void TrackZoom(DWORD lp) {
  204.    POINT NewPoint;
  205.  
  206.    XorZoomBox();
  207.  
  208.    NewPoint = MAKEPOINT(lp);
  209.    ZoomCenter.x += NewPoint.x - ZoomClick.x;
  210.    ZoomCenter.y += NewPoint.y - ZoomClick.y;
  211.    ZoomClick = NewPoint;
  212.  
  213.    CalcZoomRect();
  214.    XorZoomBox();
  215. }
  216.  
  217. void EndZoom(DWORD lp) {
  218.    TrackZoom(lp);
  219.    TrackingZoom = FALSE;
  220. }
  221.  
  222. void PaintMathTools(void) {
  223.    XorZoomBox();
  224. }
  225.  
  226. void CancelZoom(void) {
  227.    XorZoomBox();
  228.    CenterZoom();
  229.    TrackingZoom = Zooming = FALSE;
  230.    PositionZoomBar();
  231. }
  232.  
  233. void ExecuteZoom(void) {
  234.    double xd, yd, z;
  235.  
  236.    xd = xxmin + (delxx * (ZoomCenter.x + win_xoffset));  /* BDT 11/6/91 */
  237.    yd = yymax - (delyy * (ZoomCenter.y + win_yoffset));  /* BDT 11/6/91 */
  238.  
  239.    z = 1.0 - fabs((double)Zooming / 100 * .99);
  240.    if(Zooming > 0)
  241.       z = 1.0 / z;
  242.  
  243.    xxmin = xd - (delxx * z * (xdots / 2));
  244.    xxmax = xd + (delxx * z * (xdots / 2));
  245.    yymin = yd - (delyy * z * (ydots / 2));
  246.    yymax = yd + (delyy * z * (ydots / 2));
  247.  
  248.    time_to_reinit = 1;
  249.    time_to_cycle = 0;
  250.    calc_status = 0;
  251. }
  252.  
  253. BOOL FAR PASCAL ZoomBarProc(HWND hWnd, WORD Message, WORD wp, DWORD dp) {
  254.    switch(Message) {
  255.       case WM_KEYDOWN:
  256.          switch(wp) {
  257.             case VK_RETURN:
  258.                if(TrackingZoom)
  259.                   ExecuteZoom();
  260.                break;
  261.             case VK_ESCAPE:
  262.                CancelZoom();
  263.                break;
  264.             default:
  265.                break;
  266.          }
  267.          break;
  268.    }
  269.    return(CallWindowProc(DefZoomProc, hWnd, Message, wp, dp));
  270. }
  271.  
  272. BOOL FAR PASCAL ZoomBarDlg(HWND hDlg, WORD Message, WORD wp, DWORD dp) {
  273.    FARPROC lpFnct;
  274.  
  275.    switch(Message) {
  276.       case WM_INITDIALOG:
  277.          ZoomBarOpen = TRUE;
  278.          ProgStr = Winfract;
  279.          SaveParamSwitch(ZoomBoxStr, TRUE);
  280.          CenterZoom();
  281.          CheckMenuItem(GetMenu(hFractalWnd), IDM_ZOOM, MF_CHECKED);
  282.          PositionWindow(hDlg, ZoomBoxPosStr);
  283.          hZoomDlg = hDlg;
  284.          hZoomBrush = GetStockObject(BLACK_BRUSH);
  285.          hZoomPen = GetStockObject(WHITE_PEN);
  286.          if(!(lpFnct = MakeProcInstance(ZoomBarProc, hThisInst)))
  287.             return(FALSE);
  288.          if(!(hZoomBar = CreateWindow("scrollbar", NULL, WS_CHILD |
  289.                            WS_TABSTOP | SBS_VERT,
  290.                            38, 28, 18, 248, hDlg, NULL, hThisInst, NULL)))
  291.             return(FALSE);
  292.  
  293.          SetScrollRange(hZoomBar, SB_CTL, ZoomBarMin, ZoomBarMax, FALSE);
  294.          SetScrollPos(hZoomBar, SB_CTL, 0, FALSE);
  295.          ShowScrollBar(hZoomBar, SB_CTL, TRUE);
  296.          Zooming = 0;
  297.  
  298.          /* Create a Window Subclass */
  299.          DefZoomProc = (FARPROC)GetWindowLong(hZoomBar, GWL_WNDPROC);
  300.          SetWindowLong(hZoomBar, GWL_WNDPROC, (LONG)lpFnct);
  301.          return(TRUE);
  302.       case WM_MOVE:
  303.          SaveWindowPosition(hDlg, ZoomBoxPosStr);
  304.          break;
  305.       case WM_CLOSE:
  306.          KillZoomBar = 1;
  307.          ProgStr = Winfract;
  308.          break;
  309.       case WM_DESTROY:
  310.          ZoomBarOpen = 0;
  311.          break;
  312.       case WM_VSCROLL:
  313.          if(Zooming)
  314.             XorZoomBox();
  315.          switch(wp) {
  316.             case SB_PAGEDOWN:
  317.                Zooming += 20;
  318.             case SB_LINEDOWN:
  319.                Zooming = min(ZoomBarMax, Zooming + 1);
  320.                break;
  321.             case SB_PAGEUP:
  322.                Zooming -= 20;
  323.             case SB_LINEUP:
  324.                Zooming = max(ZoomBarMin, Zooming - 1);
  325.                break;
  326.             case SB_TOP:
  327.                Zooming = ZoomBarMin;
  328.                break;
  329.             case SB_BOTTOM:
  330.                Zooming = ZoomBarMax;
  331.                break;
  332.             case SB_THUMBPOSITION:
  333.             case SB_THUMBTRACK:
  334.                Zooming = LOWORD(dp);
  335.                break;
  336.          }
  337.          PositionZoomBar();
  338.          CalcZoomRect();
  339.          XorZoomBox();
  340.          break;
  341.       default:
  342.          break;
  343.    }
  344.    return(FALSE);
  345. }
  346.  
  347. void ZoomBar(HWND hWnd) {
  348.    FARPROC lpFnct;
  349.  
  350.    hFractalWnd = hWnd;
  351.    if(ZoomBarOpen)
  352.       KillZoomBar = TRUE;
  353.    else {
  354.       if(lpFnct = MakeProcInstance(ZoomBarDlg, hThisInst)) {
  355.          if(CreateDialog(hThisInst, "ZoomBar", hWnd, lpFnct))
  356.             return;
  357.       }
  358.       MessageBox(hWnd, "Error Opening Zoom Bar",
  359.                  NULL, MB_ICONEXCLAMATION | MB_OK);
  360.    }
  361. }
  362.  
  363.  
  364. /* Coordinate Box */
  365.  
  366. BOOL FAR PASCAL CoordBoxDlg(HWND hDlg, WORD Message, WORD wp, DWORD dp) {
  367.    HMENU hDlgMenu;
  368.  
  369.    hDlgMenu = GetMenu(hDlg);
  370.    switch(Message) {
  371.       case WM_INITDIALOG:
  372.          CoordBoxOpen = 1;
  373.          ProgStr = Winfract;
  374.          SaveParamSwitch(CoordBoxStr, TRUE);
  375.          CheckMenuItem(GetMenu(hFractalWnd), IDM_COORD, MF_CHECKED);
  376.          hCoordBox = hDlg;
  377.          PositionWindow(hDlg, CoordBoxPosStr);
  378.          return(TRUE);
  379.       case WM_MOVE:
  380.          SaveWindowPosition(hDlg, CoordBoxPosStr);
  381.          break;
  382.       case WM_CLOSE:
  383.          KillCoordBox = 1;
  384.          ProgStr = Winfract;
  385.          break;
  386.       case WM_DESTROY:
  387.          CoordBoxOpen = 0;
  388.          break;
  389.       case WM_COMMAND:
  390.          CheckMenuItem(hDlgMenu, AngleFormat, MF_UNCHECKED);
  391.          CheckMenuItem(hDlgMenu, CoordFormat, MF_UNCHECKED);
  392.          switch(wp) {
  393.             case IDM_RADIANS:
  394.             case IDM_GRAD:
  395.             case IDM_DEGREES:
  396.                AngleFormat = wp;
  397.                break;
  398.             case IDM_POLAR:
  399.             case IDM_RECT:
  400.             case IDM_PIXEL:
  401.                CoordFormat = wp;
  402.                break;
  403.          }
  404.          CheckMenuItem(hDlgMenu, AngleFormat, MF_CHECKED);
  405.          CheckMenuItem(hDlgMenu, CoordFormat, MF_CHECKED);
  406.          if(CoordFormat == IDM_POLAR) {
  407.             SetDlgItemText(hDlg, ID_X_NAME, "|z|");
  408.             SetDlgItemText(hDlg, ID_Y_NAME, "\xD8");
  409.             EnableMenuItem(hDlgMenu, IDM_DEGREES, MF_ENABLED);
  410.             EnableMenuItem(hDlgMenu, IDM_RADIANS, MF_ENABLED);
  411.             EnableMenuItem(hDlgMenu, IDM_GRAD, MF_ENABLED);
  412.          }
  413.          else {
  414.             SetDlgItemText(hDlg, ID_X_NAME, "x");
  415.             SetDlgItemText(hDlg, ID_Y_NAME, "y");
  416.             EnableMenuItem(hDlgMenu, IDM_DEGREES, MF_DISABLED | MF_GRAYED);
  417.             EnableMenuItem(hDlgMenu, IDM_RADIANS, MF_DISABLED | MF_GRAYED);
  418.             EnableMenuItem(hDlgMenu, IDM_GRAD, MF_DISABLED | MF_GRAYED);
  419.          }
  420.    }
  421.    return(FALSE);
  422. }
  423.  
  424. void UpdateCoordBox(DWORD dw) {
  425.    unsigned xPixel, yPixel;
  426.    double xd, yd, Angle, Modulus;
  427.    char xStr[40], yStr[40];
  428.  
  429.    xPixel = (unsigned)dw         + win_xoffset;  /* BDT 11/6/91 */
  430.    yPixel = (unsigned)(dw >> 16) + win_yoffset;  /* BDT 11/6/91 */
  431.    xd = xxmin + (delxx * xPixel);
  432.    yd = yymax - (delyy * yPixel);
  433.    switch(CoordFormat) {
  434.       case IDM_PIXEL:
  435.          sprintf(xStr, "%d", xPixel);
  436.          sprintf(yStr, "%d", yPixel);
  437.          break;
  438.       case IDM_RECT:
  439.          sprintf(xStr, "%+.8g", xd);
  440.          sprintf(yStr, "%+.8g", yd);
  441.          break;
  442.       case IDM_POLAR:
  443.          Modulus = (xd*xd) + (yd*yd);
  444.          if(Modulus > 1E-20) {
  445.             Modulus = sqrt(Modulus);
  446.             Angle = atan2(yd, xd);
  447.             switch(AngleFormat) {
  448.                case IDM_DEGREES:
  449.                   Angle = (Angle / Pi) * 180;
  450.                   break;
  451.                case IDM_GRAD:
  452.                   Angle = (Angle / Pi) * 200;
  453.                case IDM_RADIANS:
  454.                   break;
  455.             }
  456.          }
  457.          else {
  458.             Modulus = 0.0;
  459.             Angle = 0.0;
  460.          }
  461.          sprintf(xStr, "%+.8g", Modulus);
  462.          sprintf(yStr, "%+.8g", Angle);
  463.          break;
  464.    }
  465.    SetDlgItemText(hCoordBox, ID_X_COORD, xStr);
  466.    SetDlgItemText(hCoordBox, ID_Y_COORD, yStr);
  467. }
  468.  
  469. void CoordinateBox(HWND hWnd) {
  470.    FARPROC lpCoordBox;
  471.  
  472.    hFractalWnd = hWnd;
  473.    if(CoordBoxOpen)
  474.       KillCoordBox = TRUE;
  475.    else {
  476.       if(lpCoordBox = MakeProcInstance(CoordBoxDlg, hThisInst)) {
  477.          if(CreateDialog(hThisInst, "CoordBox", hWnd, lpCoordBox))
  478.             return;
  479.       }
  480.       MessageBox(hWnd, "Error Opening Coordinate Box",
  481.                  NULL, MB_ICONEXCLAMATION | MB_OK);
  482.    }
  483.    ProgStr = Winfract;
  484. }
  485.  
  486.  
  487.  
  488. /* Math Tools Window - Not Implemented Yet */
  489.  
  490. BOOL OpenMTWnd(void) {
  491.     hMathToolsWnd = CreateWindow(
  492.         MTClassName,
  493.         MTWindowTitle,
  494.         WS_OVERLAPPEDWINDOW | WS_HSCROLL | WS_VSCROLL,
  495.         CW_USEDEFAULT, CW_USEDEFAULT,
  496.         xdots, ydots,
  497.         hFractalWnd,
  498.         NULL,
  499.         hThisInst,
  500.         NULL
  501.     );
  502.     if(!hMathToolsWnd)
  503.         return(FALSE);
  504.  
  505.     ShowWindow(hMathToolsWnd, SW_SHOWNORMAL);
  506.     UpdateWindow(hMathToolsWnd);
  507.  
  508.     return(TRUE);
  509. }
  510.  
  511. void MathToolBox(HWND hWnd) {
  512.     hFractalWnd = hWnd;
  513.     if(MTWindowOpen)
  514.        DestroyWindow(hMathToolsWnd);
  515.     else {
  516.       if(!OpenMTWnd())
  517.          MessageBox(hWnd, "Error Opening Math Tools Window", NULL,
  518.                     MB_ICONEXCLAMATION | MB_OK);
  519.     }
  520. }
  521.  
  522.  
  523. long FAR PASCAL MTWndProc(HWND hWnd, unsigned Message, WORD wParam, DWORD lParam) {
  524.    switch (Message) {
  525.       case WM_CREATE:
  526.          CheckMenuItem(GetMenu(hFractalWnd), IDM_MATH_TOOLS, MF_CHECKED);
  527.          MTWindowOpen = 1;
  528.          break;
  529.       case WM_COMMAND:
  530.          switch(wParam) {
  531.             case IDM_EXIT:
  532.                DestroyWindow(hWnd);
  533.                break;
  534.          }
  535.          break;
  536.       case WM_DESTROY:
  537.          CheckMenuItem(GetMenu(hFractalWnd), IDM_MATH_TOOLS, MF_UNCHECKED);
  538.          MTWindowOpen = 0;
  539.          break;
  540.       default:
  541.          return(DefWindowProc(hWnd, Message, wParam, lParam));
  542.     }
  543.     return(0L);
  544. }
  545.