/******************************************************************************

   Module Name: crane
   Description: 3D Origami Crane Animator
   Version:     v1.00
   Authors:     Mike Robert
   Date:        3/30/90

   For Jennifer Lee.

   Revision History:

   Bugs:

   Enhancements:

******************************************************************************/

/* INCLUDE FILES
*/

#define  NOCOMM

#include <Windows.h>
#include <math.h>
#include <process.h>
#include "WinUnDoc.h"
#include "crane.h"
#include "dialogs.h"

/* SYMBOLIC CONSTANTS
*/

/*  Miscellaneous.  */

#define  PI                   3.14159265     /* The value of ã */

#define  CNT_ANIMATE          4              /* Animate count */

#define  MAX_MOVE             100.           /* Maximum movement */

#define  MAX_POINTS            56            /* Maximum points */

#define  MAX_SHAPES            11            /* Maximum shapes */

/*  Crane Point Flags.  */

#define  CPF_NORMAL           0x0000         /* Normal point */
#define  CPF_START            0x0001         /* New line sequence start */
#define  CPF_MOVE             0x0002         /* Movement point */
#define  CPF_EOL              0x8000         /* End of point list */

/*  ROTation.  */

#define  ROT_INC              ( PI / 18. )   /* Rotation degree increment */
#define  ROT_MIN              ( 0. )         /* Rotation minimum */
#define  ROT_MAX              ( PI * 2. )    /* Rotation maximum */

/*  Z-SiZing.  */

#define  ZSZ_ATMINSIZ         -5000.
#define  ZSZ_ATMAXSIZ         5000.

#define  ZSZ_WINORG           -1500
#define  ZSZ_WINEXT           3000

/* MACROS
*/

#define  WITHIN(a,b,c)        ( (a) >= (b) && (a) <= (c) )

/* TYPEDEFS
*/

typedef struct _POINT3D
{
   double         x, y, z;                   /* XYZ coordinates (floating) */
}
   POINT3D;                                  /* 3-dimensional point */

typedef POINT3D FAR *LPPOINT3D;

typedef struct _ANIMATEPT
{
   WORD           unPtIndex;                 /* Point index */
   double         dfMinRot,                  /* Minimum rotation */
                  dfMaxRot,                  /* Maximum rotation */
                  dfCurRot,                  /* Current rotation */
                  dfIncRot,                  /* Rotation increment */
                  dfDst;                     /* Distance */
}
   ANIMATEPT;                                /* Animate point structure */

typedef ANIMATEPT FAR *LPANIMATEPT;

typedef struct _SHAPE
{
   WORD           unIndex,                   /* Index */
                  unCnt;                     /* Point count */
}
   SHAPE;                                    /* Shape structure */

typedef SHAPE FAR *LPSHAPE;

typedef struct _CRANEPT
{
   WORD           unFlags;                   /* Flags */
   POINT3D        pt3dOrg,                   /* Original point */
                  pt3dNew;                   /* New point */
}
   CRANEPT;                                  /* Crane point structure */

typedef CRANEPT FAR *LPCRANEPT;

/* GLOBAL VARIABLES
*/

static   HANDLE         hModule;             /* Module instance handle */

static   HWND           hClientWnd;          /* Client window handle */
static   HDC            hClientDC;           /* Client display context handle */

static   FARPROC        lpfnXYZDataDlgProc;  /* XYZ data dialog function pointer */
static   HWND           hXYZDataDlg = NULL;  /* Data dialog window handle */

static   BOOL           bAnimate = FALSE;    /* Animation flag */

static   BOOL           bRecording = FALSE;  /* Recording flag */
static   WORD           unRecordCnt = 0;     /* Record count */
static   int            fhRecordFile;        /* Record file handle */

static   RECT           rErase,              /* Erase rectangle */
                        rOldErase,           /* Old erase rectangle */
                        rUpdate;             /* Update rectangle */

static   POINT          aptList[ MAX_POINTS ];
                                             /* Point list */

static   POINT3D        pt3dRot;             /* Rotation amounts */

static   POINT3D        pt3dLoc;             /* Current location */

static   CRANEPT        cptMove =            /* Movement crane point */
                        {
                           CPF_MOVE,
                           { 0., 0., MAX_MOVE },
                           { 0., 0., 0. }
                        };

static   ANIMATEPT      aaptList[ CNT_ANIMATE ] =
                                             /* Animate point list */
                        {
                           {
                              33,
                              PI * 3. / 4. + PI / 40.,
                              PI * 5. / 4. - PI / 40.,
                              PI,
                              -PI / 20.,
                              1050.
                           },
                           {
                              37,
                              PI * 3. / 4. + PI / 40.,
                              PI * 5. / 4. - PI / 40.,
                              PI,
                              -PI / 20.,
                              1050.
                           },
                           {
                              41,
                              -PI / 4. + PI / 40.,
                              PI / 4. - PI / 40.,
                              0.,
                              PI / 20.,
                              1050.
                           },
                           {
                              45,
                              -PI / 4. + PI / 40.,
                              PI / 4. - PI / 40.,
                              0.,
                              PI / 20.,
                              1050.
                           }
                        };

static   POINT3D        pt3dMin =            /* Coordinate minimums */
                        { -1050., -405., -810. },
                        pt3dMax =            /* Coordinate maximums */
                        { 1050., 405., 810. };

static   SHAPE          ashpList[ ] =        /* Shape list */
                        {
                           { 0, 4 },
                           { 4, 7 },
                           { 11, 5 },
                           { 16, 5 },
                           { 21, 5 },
                           { 26, 5 },
                           { 31, 4 },
                           { 35, 4 },
                           { 39, 4 },
                           { 43, 4 },
                           { 47, 9 }
                        };

static   CRANEPT        acptList[ ] =        /* Crane points */
                        {
                           {                 /* 0 */
                              CPF_START,
                              { 0., -405., -810. },
                              { 0., 0., 0. }
                           },
                           {                 /* 1 */
                              CPF_NORMAL,
                              { 0., 405., -180. },
                              { 0., 0., 0. }
                           },
                           {                 /* 2 */
                              CPF_NORMAL,
                              { 0., 255., 60. },
                              { 0., 0., 0. }
                           },
                           {                 /* 3 */
                              CPF_NORMAL,
                              { 0., -405., -810. },
                              { 0., 0., 0. }
                           },
                           {                 /* 4 */
                              CPF_START,
                              { 0., 255., 60. },
                              { 0., 0., 0. }
                           },
                           {                 /* 5 */
                              CPF_NORMAL,
                              { 0., 405., 300. },
                              { 0., 0., 0. }
                           },
                           {                 /* 6 */
                              CPF_NORMAL,
                              { 0., -135., 720. },
                              { 0., 0., 0. }
                           },
                           {                 /* 7 */
                              CPF_NORMAL,
                              { 0., 135., 810. },
                              { 0., 0., 0. }
                           },
                           {                 /* 8 */
                              CPF_NORMAL,
                              { 0., -195., 780. },
                              { 0., 0., 0. }
                           },
                           {                 /* 9 */
                              CPF_NORMAL,
                              { 0., -225., 690. },
                              { 0., 0., 0. }
                           },
                           {                 /* 10 */
                              CPF_NORMAL,
                              { 0., 255., 60. },
                              { 0., 0., 0. }
                           },
                           {                 /* 11 */
                              CPF_START,
                              { 0., 255., 60. },
                              { 0., 0., 0. }
                           },
                           {                 /* 12 */
                              CPF_NORMAL,
                              { 0., 405., -180. },
                              { 0., 0., 0. }
                           },
                           {                 /* 13 */
                              CPF_NORMAL,
                              { -450., 75., -270. },
                              { 0., 0., 0. }
                           },
                           {                 /* 14 */
                              CPF_NORMAL,
                              { -90., 195., 60. },
                              { 0., 0., 0. }
                           },
                           {                 /* 15 */
                              CPF_NORMAL,
                              { 0., 255., 60. },
                              { 0., 0., 0. }
                           },
                           {                 /* 16 */
                              CPF_START,
                              { 0., 255., 60. },
                              { 0., 0., 0. }
                           },
                           {                 /* 17 */
                              CPF_NORMAL,
                              { 0., 405., 300. },
                              { 0., 0., 0. }
                           },
                           {                 /* 18 */
                              CPF_NORMAL,
                              { -450., 75., 390. },
                              { 0., 0., 0. }
                           },
                           {                 /* 19 */
                              CPF_NORMAL,
                              { -90., 195., 60. },
                              { 0., 0., 0. }
                           },
                           {                 /* 20 */
                              CPF_NORMAL,
                              { 0., 255., 60. },
                              { 0., 0., 0. }
                           },
                           {                 /* 21 */
                              CPF_START,
                              { 450., 75., -270. },
                              { 0., 0., 0. }
                           },
                           {                 /* 22 */
                              CPF_NORMAL,
                              { 90., 195., 60. },
                              { 0., 0., 0. }
                           },
                           {                 /* 23 */
                              CPF_NORMAL,
                              { 0., 255., 60. },
                              { 0., 0., 0. }
                           },
                           {                 /* 24 */
                              CPF_NORMAL,
                              { 0., 405., -180. },
                              { 0., 0., 0. }
                           },
                           {                 /* 25 */
                              CPF_NORMAL,
                              { 450., 75., -270. },
                              { 0., 0., 0. }
                           },
                           {                 /* 26 */
                              CPF_START,
                              { 90., 195., 60. },
                              { 0., 0., 0. }
                           },
                           {                 /* 27 */
                              CPF_NORMAL,
                              { 450., 75., 390. },
                              { 0., 0., 0. }
                           },
                           {                 /* 28 */
                              CPF_NORMAL,
                              { 0., 405., 300. },
                              { 0., 0., 0. }
                           },
                           {                 /* 29 */
                              CPF_NORMAL,
                              { 0., 255., 60. },
                              { 0., 0., 0. }
                           },
                           {                 /* 30 */
                              CPF_NORMAL,
                              { 90., 195., 60. },
                              { 0., 0., 0. }
                           },
                           {                 /* 31 */
                              CPF_START,
                              { -90., 195., 60. },
                              { 0., 0., 0. }
                           },
                           {                 /* 32 */
                              CPF_NORMAL,
                              { -450., 75., -270. },
                              { 0., 0., 0. }
                           },
                           {                 /* 33 */
                              CPF_NORMAL,
                              { -1050., 0., 60. },
                              { 0., 0., 0. }
                           },
                           {                 /* 34 */
                              CPF_NORMAL,
                              { -90., 195., 60. },
                              { 0., 0., 0. }
                           },
                           {                 /* 35 */
                              CPF_START,
                              { -90., 195., 60. },
                              { 0., 0., 0. }
                           },
                           {                 /* 36 */
                              CPF_NORMAL,
                              { -450., 75., 390. },
                              { 0., 0., 0. }
                           },
                           {                 /* 37 */
                              CPF_NORMAL,
                              { -1050., 0., 60. },
                              { 0., 0., 0. }
                           },
                           {                 /* 38 */
                              CPF_NORMAL,
                              { -90., 195., 60. },
                              { 0., 0., 0. }
                           },
                           {                 /* 39 */
                              CPF_START,
                              { 90., 195., 60. },
                              { 0., 0., 0. }
                           },
                           {                 /* 40 */
                              CPF_NORMAL,
                              { 450., 75., -270. },
                              { 0., 0., 0. }
                           },
                           {                 /* 41 */
                              CPF_NORMAL,
                              { 1050., 0., 60. },
                              { 0., 0., 0. }
                           },
                           {                 /* 42 */
                              CPF_NORMAL,
                              { 90., 195., 60. },
                              { 0., 0., 0. }
                           },
                           {                 /* 43 */
                              CPF_START,
                              { 90., 195., 60. },
                              { 0., 0., 0. }
                           },
                           {                 /* 44 */
                              CPF_NORMAL,
                              { 450., 75., 390. },
                              { 0., 0., 0. }
                           },
                           {                 /* 45 */
                              CPF_NORMAL,
                              { 1050., 0., 60. },
                              { 0., 0., 0. }
                           },
                           {                 /* 46 */
                              CPF_NORMAL,
                              { 90., 195., 60. },
                              { 0., 0., 0. }
                           },
                           {                 /* 47 */
                              CPF_START,
                              { -270., 135., 390. },
                              { 0., 0., 0. }
                           },
                           {                 /* 48 */
                              CPF_NORMAL,
                              { 0., -15., 330. },
                              { 0., 0., 0. }
                           },
                           {                 /* 49 */
                              CPF_NORMAL,
                              { 270., 135., 390. },
                              { 0., 0., 0. }
                           },
                           {                 /* 50 */
                              CPF_NORMAL,
                              { 270., 45., 60. },
                              { 0., 0., 0. }
                           },
                           {                 /* 51 */
                              CPF_NORMAL,
                              { 270., 135., -270. },
                              { 0., 0., 0. }
                           },
                           {                 /* 52 */
                              CPF_NORMAL,
                              { 0., -45., -210. },
                              { 0., 0., 0. }
                           },
                           {                 /* 53 */
                              CPF_NORMAL,
                              { -270., 135., -270. },
                              { 0., 0., 0. }
                           },
                           {                 /* 54 */
                              CPF_NORMAL,
                              { -270., 45., 60. },
                              { 0., 0., 0. }
                           },
                           {                 /* 55 */
                              CPF_NORMAL,
                              { -270., 135., 390. },
                              { 0., 0., 0. }
                           },
                           {                 /* 56 */
                              CPF_EOL,
                              { 0., 0., 0. },
                              { 0., 0., 0. }
                           }
                        };

#define  MAX_POINTS            56            /* Maximum points */

#define  MAX_SHAPES            11            /* Maximum shapes */

/* FUNCTION PROTOYPES
*/

void PASCAL WinMain(

   HANDLE hInstance,    /* Instance handle.
                        */
      
   HANDLE hPrevInstance,
                        /* Previous instance handle.
                        */
      
   LPSTR lpszCmdLine,   /* Command line string pointer.
                        */
      
   int nCmdShow         /* Show command parameter.
                        */
      
   );

long FAR PASCAL WindowProc( 

   HWND hWnd,           /* Window handle.
                        */

   unsigned nMsg,       /* Message type.
                        */

   WORD wParam,         /* 16-bit parameter.
                        */

   LONG lParam          /* 32-bit parameter.
                        */

   );

BOOL NEAR PASCAL Init( 

   HANDLE hInstance,    /* Instance handle.
                        */
      
   HANDLE hPrevInstance,
                        /* Previous instance handle.
                        */
      
   LPSTR lpszCmdLine,   /* Command line string pointer.
                        */
      
   int nCmdShow         /* Show command parameter.
                        */
      
   );

void NEAR PASCAL Menu( 

   HWND hWnd,           /* Window handle.
                        */

   WORD wID             /* Command ID.
                        */

   );

void NEAR PASCAL InitMenu(

   HWND hWnd,           /* Window handle.
                        */

   HMENU hMenu          /* Menu handle.
                        */

   );

BOOL FAR PASCAL XYZDataDlgProc( 

   HWND hDlg,           /* Dialog window handle.
                        */

   unsigned nMsg,       /* Message to dialog.
                        */

   WORD wParam,         /* Word parameter.
                        */

   LONG lParam          /* Long parameter.
                        */

   );

void NEAR PASCAL UpdateXYZDataDlg( void );

BOOL FAR PASCAL AboutDlgProc( 

   HWND hDlg,           /* Dialog window handle.
                        */

   unsigned nMsg,       /* Message type.
                        */

   WORD wParam,         /* 16-bit parameter.
                        */

   LONG lParam          /* 32-bit parameter.
                        */

   );

void NEAR PASCAL AnimateCranePts(

   HWND hWnd            /* Window handle.
                        */

   );

void NEAR PASCAL RecordPlayback( 

   HWND hWnd            /* Window handle.
                        */

   );
      
void NEAR PASCAL RecordRead( void );

void NEAR PASCAL RecordWrite( void );

void NEAR PASCAL Key( 

   HWND hWnd,           /* Window handle.
                        */

   WORD wId             /* Key ID.
                        */

   );
      
void NEAR PASCAL CalcNewCranePts( void );

void NEAR PASCAL CalcNewPt(

   LPCRANEPT lpcpt      /* Crane point pointer.
                        */

   );

void NEAR PASCAL Size(

   HWND hWnd,           /* Window handle.
                        */

   LONG lParam          /* 32-bit parameter.
                        */

   );

void NEAR PASCAL Paint( 

   HWND hWnd            /* Window handle.
                        */

   );

void NEAR PASCAL ResetCranePts( void );

void NEAR PASCAL myYield( void );

/******************************************************************************

   Function Name: WinMain

   Description:

      Top level procedure called by windows on application startup.

   Control Flow:

   Return Values:

      None.

   Notes:

******************************************************************************/

void PASCAL WinMain(

   HANDLE hInstance,    /* Instance handle.
                        */
      
   HANDLE hPrevInstance,
                        /* Previous instance handle.
                        */
      
   LPSTR lpszCmdLine,   /* Command line string pointer.
                        */
      
   int nCmdShow         /* Show command parameter.
                        */
      
   )

{
   /*  Variable definition.  */

   MSG            stMsg;                     /* Message structure */

   /*  Initialize ourselves.  */

   if ( !Init( hInstance, hPrevInstance, lpszCmdLine, nCmdShow ) )
      exit( 1 );

   /*  Process messages until exit.  */

   while ( GetMessage( &stMsg, NULL, 0, 0 ) )
   {
      /*  Translate and dispatch the message.  */

      TranslateMessage( &stMsg );
      DispatchMessage( &stMsg );

   }

   exit( stMsg.wParam );

}

/******************************************************************************

   Function Name: Init

   Description:

      Provides initialization for the first instance and every following
      instance.

   Control Flow:

   Return Values:

      Failure: FALSE
      Success: TRUE

   Notes:

******************************************************************************/

BOOL NEAR PASCAL Init( 

   HANDLE hInstance,    /* Instance handle.
                        */
      
   HANDLE hPrevInstance,
                        /* Previous instance handle.
                        */
      
   LPSTR lpszCmdLine,   /* Command line string pointer.
                        */
      
   int nCmdShow         /* Show command parameter.
                        */
      
   )
      
{
   /*  Variable definition.  */

   WNDCLASS       wcClass;                   /* Class information storage */

   OFSTRUCT       ofRecord;                  /* Record open file structure */

   /*  Perform the appropiate initialization.  */

   if ( !hPrevInstance )
   {
      wcClass.lpszClassName    = "Crane";
      wcClass.hInstance        = hInstance;
      wcClass.lpfnWndProc      = WindowProc;
      wcClass.hCursor          = LoadCursor( NULL, IDC_ARROW );
      wcClass.hIcon            = LoadIcon( hInstance, "CraneIcon" );
      wcClass.lpszMenuName     = "CraneMenu";
      wcClass.hbrBackground    = GetStockObject( WHITE_BRUSH );
      wcClass.style            = CS_OWNDC;
      wcClass.cbClsExtra       = 0;
      wcClass.cbWndExtra       = 0;

      RegisterClass( &wcClass );

   }

   /*  Store this instance so window procedures can use it.  */

   hModule = hInstance;

   /*  Create the window.  */

   hClientWnd = CreateWindow( "Crane",
                              " Crane ",
                              WS_OVERLAPPEDWINDOW,
                              CW_USEDEFAULT,
                              SW_SHOWNORMAL,
                              CW_USEDEFAULT,
                              0,
                              NULL,
                              NULL,
                              hInstance,
                              NULL
                            );

   /*  Get our display context and initialize it.  */

   hClientDC = GetDC( hClientWnd );

   SetMapMode( hClientDC, MM_ANISOTROPIC );
   SetWindowOrg( hClientDC, ZSZ_WINORG, ZSZ_WINORG );
   SetWindowExt( hClientDC, ZSZ_WINEXT, ZSZ_WINEXT );

   SelectObject( hClientDC, GetStockObject( BLACK_PEN ) );

   /*  Initialize the crane data.  */

   ResetCranePts( );

   /*  Create the dialog procedure pointer.  */

   lpfnXYZDataDlgProc = MakeProcInstance( XYZDataDlgProc, hModule );

   /*  Open the record file.  */

   fhRecordFile = OpenFile( "RECORD.DAT", &ofRecord, OF_CREATE | OF_READWRITE );
   if ( !fhRecordFile )
      MessageBox( hClientWnd,
                  "Unable to open record file",
                  "Error",
                  MB_ICONEXCLAMATION | MB_OK
                );

   unRecordCnt = 0;

   /*  Display this window on the screen.  */

   ShowWindow( hClientWnd, nCmdShow );

   /*  Force immediate paint of the client area.  */

   UpdateWindow( hClientWnd );

   return ( TRUE );

}

/******************************************************************************

   Function Name: WindowProc

   Description:

      Processes the messages for the Crane window.

   Control Flow:

   Return Values:

      DefWindowProc specific return values if message not processed
      else 0L signalling message was processed.

   Notes:

******************************************************************************/

long FAR PASCAL WindowProc( 

   HWND hWnd,           /* Window handle.
                        */

   unsigned nMsg,       /* Message type.
                        */

   WORD wParam,         /* 16-bit parameter.
                        */

   LONG lParam          /* 32-bit parameter.
                        */

   )

{
   /*  Process the message.  */

   switch ( nMsg )
   {
      case WM_INITMENU:
         InitMenu( hWnd, wParam );
         break;

      case WM_COMMAND:
         Menu( hWnd, wParam );
         break;

      case WM_KEYUP:
         Key( hWnd, wParam );
         break;

      case WM_SIZE:
         Size( hWnd, lParam );
         break;

      case WM_PAINT:
         Paint( hWnd );
         break;

      case WM_CLOSE:

         if ( bAnimate )
         {
            bAnimate = FALSE;
            PostMessage( hWnd, nMsg, wParam, lParam );
            break;
         }

         DestroyWindow( hWnd );
         break;

      case WM_DESTROY:

         _lclose( fhRecordFile );

         FreeProcInstance( lpfnXYZDataDlgProc );

         ReleaseDC( hWnd, hClientDC );

         PostQuitMessage( 0 );
         break;

      default:
         return ( DefWindowProc( hWnd, nMsg, wParam, lParam ) );
         break;

   }

   return ( 0L );

}

/******************************************************************************

   Function Name: Menu

   Description:

      Provides processing for menu commands.

   Control Flow:

   Return Values:

      None.

   Notes:

******************************************************************************/

void NEAR PASCAL Menu( 

   HWND hWnd,           /* Window handle.
                        */

   WORD wId             /* Command ID.
                        */

   )
      
{
   /*  Variable definition.  */

   FARPROC        lpfnProc;                  /* Procedure pointer */

   /*  Check for a Control command.  */

   if ( WITHIN( wId, MI_CONTROL_MIN, MI_CONTROL_MAX ) )
   {
      switch ( wId )
      {
         /*  Check for the Reset command.  */

         case MI_CONTROL_RESET:

            ResetCranePts( );

            InvalidateRect( hWnd, NULL, TRUE );

            break;

         /*  Check for the About... command.  */

         case MI_CONTROL_DATA:

            hXYZDataDlg = CreateDialog( hModule,
                                        "DATABOX",
                                        hWnd,
                                        lpfnXYZDataDlgProc
                                      );

            break;

         /*  Check for the About... command.  */

         case MI_CONTROL_ABOUT:

            lpfnProc = MakeProcInstance( AboutDlgProc, hModule );
            DialogBox( hModule, "ABOUTBOX", hWnd, lpfnProc );
            FreeProcInstance( lpfnProc );

            break;

      }

   }

   /*  Check for an Animate command.  */

   else if ( WITHIN( wId, MI_ANIMATE_MIN, MI_ANIMATE_MAX ) )
   {
      switch ( wId )
      {
         /*  Check for the Start command.  */

         case MI_ANIMATE_START:

            bAnimate = TRUE;

            rOldErase.left   = ZSZ_WINORG;
            rOldErase.top    = ZSZ_WINORG;
            rOldErase.right  = ZSZ_WINORG + ZSZ_WINEXT + 1;
            rOldErase.bottom = ZSZ_WINORG + ZSZ_WINEXT + 1;

            AnimateCranePts( hWnd );

            break;

         /*  Check for the Stop command.  */

         case MI_ANIMATE_STOP:

            bAnimate = FALSE;

            break;

      }

   }

   /*  Check for a Record command.  */

   else if ( WITHIN( wId, MI_RECORD_MIN, MI_RECORD_MAX ) )
   {
      switch ( wId )
      {
         /*  Check for the Start command.  */

         case MI_RECORD_START:

            bRecording = TRUE;

            break;

         /*  Check for the Stop command.  */

         case MI_RECORD_STOP:

            bRecording = FALSE;

            break;

         /*  Check for the Playback command.  */

         case MI_RECORD_PLAYBACK:

            RecordPlayback( hWnd );

            break;

         /*  Check for the Reset command.  */

         case MI_RECORD_RESET:

            unRecordCnt = 0;

            _llseek( fhRecordFile, 0L, 0 );

            break;

      }

   }

   return;

}

/******************************************************************************

   Function Name: InitMenu

   Description:

      Changes the status of any of the menuitems that require moment to
      moment changes.

   Control Flow:

   Return Values:

      None.

   Notes:

******************************************************************************/

void NEAR PASCAL InitMenu(

   HWND hWnd,           /* Window handle.
                        */

   HMENU hMenu          /* Menu handle.
                        */

   )

{
   /*  Update the apropiate menu items.  */

   if ( !hXYZDataDlg )
      EnableMenuItem( hMenu, MI_CONTROL_DATA, MF_ENABLED );
   else
      EnableMenuItem( hMenu, MI_CONTROL_DATA, MF_DISABLED | MF_GRAYED );

   if ( !bAnimate )
   {
      EnableMenuItem( hMenu, MI_ANIMATE_START, MF_ENABLED );
      EnableMenuItem( hMenu, MI_ANIMATE_STOP, MF_DISABLED | MF_GRAYED );
   }
   else
   {
      EnableMenuItem( hMenu, MI_ANIMATE_START, MF_DISABLED | MF_GRAYED );
      EnableMenuItem( hMenu, MI_ANIMATE_STOP, MF_ENABLED );
   }

   if ( !bRecording )
      EnableMenuItem( hMenu, MI_RECORD_START, MF_ENABLED );
   else
      EnableMenuItem( hMenu, MI_RECORD_START, MF_DISABLED | MF_GRAYED );

   if ( bRecording )
      EnableMenuItem( hMenu, MI_RECORD_STOP, MF_ENABLED );
   else
      EnableMenuItem( hMenu, MI_RECORD_STOP, MF_DISABLED | MF_GRAYED );

   if ( !bRecording && !bAnimate && unRecordCnt != 0 )
      EnableMenuItem( hMenu, MI_RECORD_PLAYBACK, MF_ENABLED );
   else
      EnableMenuItem( hMenu, MI_RECORD_PLAYBACK, MF_DISABLED | MF_GRAYED );

   return;

}

/******************************************************************************

   Function Name: XYZDataDlgProc

   Description:

      This routine will process the XYZ data dialog box.

   Control Flow:

   Return Values:

      Success: TRUE
      Failure: FALSE

   Notes:

******************************************************************************/

BOOL FAR PASCAL XYZDataDlgProc( 

   HWND hDlg,           /* Dialog window handle.
                        */

   unsigned nMsg,       /* Message to dialog.
                        */

   WORD wParam,         /* Word parameter.
                        */

   LONG lParam          /* Long parameter.
                        */

   )

{
   /*  Process the message.  */

   switch ( nMsg )
   {
      /*  Process the init dialog message.  */

      case WM_INITDIALOG:

         /*  Update the data fields.  */

         UpdateXYZDataDlg( );

         SetFocus( GetDlgItem( hDlg, IDOK ) );

         return ( FALSE );

         break;

      /*  Process the command message.  */

      case WM_COMMAND:

         /*  Parse the control ID.  */

         switch ( wParam )
         {
            /*  Process the Ok button. */

            case IDOK:

               DestroyWindow( hDlg );
               break;

            /*  Default processing.  */

            default:
               return ( FALSE );
               break;

         }

         break;

      /*  Process the destroy message.  */

      case WM_DESTROY:

         hXYZDataDlg = NULL;

         break;

      /*  Default processing.  */

      default:

         return ( FALSE );
         break;

   }

   return ( TRUE );

}

/******************************************************************************

   Function Name: UpdateXYZDataDlg

   Description:

      Updates the controls in the XYZ data dialog.

   Control Flow:

   Return Values:

      None.

   Notes:

******************************************************************************/

void NEAR PASCAL UpdateXYZDataDlg( void )

{
   /*  Update the controls.  */

   SetDlgItemInt( hXYZDataDlg, ID_XROT, (int) ( pt3dRot.x / PI * 180. ), TRUE );
   SetDlgItemInt( hXYZDataDlg, ID_YROT, (int) ( pt3dRot.y / PI * 180. ), TRUE );
   SetDlgItemInt( hXYZDataDlg, ID_ZROT, (int) ( pt3dRot.z / PI * 180. ), TRUE );

   SetDlgItemInt( hXYZDataDlg, ID_XLOC, (int) ( pt3dLoc.x ), TRUE );
   SetDlgItemInt( hXYZDataDlg, ID_YLOC, (int) ( pt3dLoc.y ), TRUE );
   SetDlgItemInt( hXYZDataDlg, ID_ZLOC, (int) ( pt3dLoc.z ), TRUE );

   SetDlgItemInt( hXYZDataDlg, ID_XMOV, (int) ( cptMove.pt3dNew.x ), TRUE );
   SetDlgItemInt( hXYZDataDlg, ID_YMOV, (int) ( cptMove.pt3dNew.y ), TRUE );
   SetDlgItemInt( hXYZDataDlg, ID_ZMOV, (int) ( cptMove.pt3dNew.z ), TRUE );

   return;

}

/******************************************************************************

   Function Name: AboutDlgProc

   Description:

      Processes the messages for the About dialog window.

   Control Flow:

   Return Values:

      Dialog function dependent.

   Notes:

******************************************************************************/

BOOL FAR PASCAL AboutDlgProc( 

   HWND hDlg,           /* Dialog window handle.
                        */

   unsigned nMsg,       /* Message type.
                        */

   WORD wParam,         /* 16-bit parameter.
                        */

   LONG lParam          /* 32-bit parameter.
                        */

   )

{
   /*  Process the message.  */

   switch ( nMsg )
   {
      /*  Process the command message.  */

      case WM_COMMAND:

         /*  Parse the control ID.  */

         switch ( wParam )
         {
            /*  Process the OK button.  */

            case IDOK:
               EndDialog( hDlg, TRUE );
               break;

            /*  Default processing.  */

            default:
               return ( FALSE );
               break;

         }

         break;

      /*  Default processing.  */

      default:
         return ( FALSE );
         break;

   }

   return ( TRUE );

}

/******************************************************************************

   Function Name: AnimateCranePts

   Description:

      Performs animation on the specific crane points.

   Control Flow:

   Return Values:

      None.

   Notes:

******************************************************************************/

void NEAR PASCAL AnimateCranePts(

   HWND hWnd            /* Window handle.
                        */

   )

{
   /*  Variable definition.  */

   WORD           unI,                       /* Indexing variable */
                  unIndex;                   /* Index */

   /*  Animate the points while animation is requested.  */

   while ( bAnimate )
   {
      /*  Initialize the erase rectangle.  */

      rErase.left   = 32767;
      rErase.top    = 32767;
      rErase.right  = -32767;
      rErase.bottom = -32767;

      /*  Loop and animate the points.  */

      for ( unI = 0; unI < CNT_ANIMATE; ++unI )
      {
         aaptList[ unI ].dfCurRot += aaptList[ unI ].dfIncRot;

         if ( aaptList[ unI ].dfCurRot <= aaptList[ unI ].dfMinRot ||
              aaptList[ unI ].dfCurRot >= aaptList[ unI ].dfMaxRot
            )
            aaptList[ unI ].dfIncRot = -aaptList[ unI ].dfIncRot;

         unIndex = aaptList[ unI ].unPtIndex;

         acptList[ unIndex ].pt3dOrg.x = cos( aaptList[ unI ].dfCurRot ) *
                                          aaptList[ unI ].dfDst;
         acptList[ unIndex ].pt3dOrg.y = sin( aaptList[ unI ].dfCurRot ) *
                                          aaptList[ unI ].dfDst;

      }

      /*  Compute the location offset.  */

      CalcNewPt( &cptMove );

      pt3dLoc.x += cptMove.pt3dNew.x;
      pt3dLoc.y += cptMove.pt3dNew.y;
      pt3dLoc.z += cptMove.pt3dNew.z;

      /*  Calculate the new points.  */

      CalcNewCranePts( );

      /*  Compute and erase the update rectangle.  */

      UnionRect( &rUpdate, &rErase, &rOldErase );

      rOldErase = rErase;

      /*  Convert the update rectangle to device units.  */

      LPtoDP( hClientDC, (LPPOINT) &rUpdate, 2 );

      rUpdate.left   -= 2;
      rUpdate.top    -= 2;
      rUpdate.right  += 2;
      rUpdate.bottom += 2;

      InvalidateRect( hWnd, &rUpdate, TRUE );

      /*  Convert back to logical units.  */

      DPtoLP( hClientDC, (LPPOINT) &rUpdate, 2 );

      /*  If recording then write the data.  */

      if ( bRecording )
         RecordWrite( );

      /*  Update the dialog.  */

      if ( hXYZDataDlg )
         UpdateXYZDataDlg( );

      /*  Yield.  */

      myYield( );

   }

   return;

}

/******************************************************************************

   Function Name: CalcNewCranePts

   Description:

      Calculate the new crane points.

   Control Flow:

   Return Values:

      None.

   Notes:

******************************************************************************/

void NEAR PASCAL CalcNewCranePts( void )

{
   /*  Variable definition.  */

   WORD           unI;                       /* Indexing variable */

   /*  Recalculate the points.  */

   for ( unI = 0; acptList[ unI ].unFlags != CPF_EOL; ++unI )
   {
      CalcNewPt( &acptList[ unI ] );

      aptList[ unI ].x = (int) acptList[ unI ].pt3dNew.x;
      aptList[ unI ].y = (int) acptList[ unI ].pt3dNew.y;

      if ( aptList[ unI ].x < rErase.left )
         rErase.left = aptList[ unI ].x;

      if ( aptList[ unI ].y < rErase.top )
         rErase.top = aptList[ unI ].y;

      if ( aptList[ unI ].x > rErase.right )
         rErase.right = aptList[ unI ].x;

      if ( aptList[ unI ].y > rErase.bottom )
         rErase.bottom = aptList[ unI ].y;

   }

   return;

}

/******************************************************************************

   Function Name: CalcNewPt

   Description:

      Calculates the new point.

   Control Flow:

   Return Values:

      None.

   Notes:

******************************************************************************/

void NEAR PASCAL CalcNewPt(

   LPCRANEPT lpcpt      /* Crane point pointer.
                        */

   )

{
   /*  Variable definition.  */

   double         dfRot,                     /* Rotation */
                  dfDst;                     /* Distance */

   /*  Reset the point.  */

   lpcpt->pt3dNew = lpcpt->pt3dOrg;

   /*  Perform Z rotation.  */

   if ( lpcpt->pt3dNew.x != 0. || lpcpt->pt3dNew.y != 0. )
   {
      dfRot = atan2( lpcpt->pt3dNew.y, lpcpt->pt3dNew.x ) + pt3dRot.z;

      dfDst = sqrt( lpcpt->pt3dNew.x * lpcpt->pt3dNew.x +
                    lpcpt->pt3dNew.y * lpcpt->pt3dNew.y
                  );

      lpcpt->pt3dNew.x = ( cos( dfRot ) * dfDst );
      lpcpt->pt3dNew.y = ( sin( dfRot ) * dfDst );

   }

   /*  Perform X rotation.  */

   if ( lpcpt->pt3dNew.z != 0. || lpcpt->pt3dNew.y != 0. )
   {
      dfRot = atan2( lpcpt->pt3dNew.y, lpcpt->pt3dNew.z ) + pt3dRot.x;

      dfDst = sqrt( lpcpt->pt3dNew.z * lpcpt->pt3dNew.z +
                    lpcpt->pt3dNew.y * lpcpt->pt3dNew.y
                  );

      lpcpt->pt3dNew.z = ( cos( dfRot ) * dfDst );
      lpcpt->pt3dNew.y = ( sin( dfRot ) * dfDst );

   }

   /*  Perform Y rotation.  */

   if ( lpcpt->pt3dNew.x != 0. || lpcpt->pt3dNew.z != 0. )
   {
      dfRot = atan2( lpcpt->pt3dNew.z, lpcpt->pt3dNew.x ) + pt3dRot.y;

      dfDst = sqrt( lpcpt->pt3dNew.x * lpcpt->pt3dNew.x +
                    lpcpt->pt3dNew.z * lpcpt->pt3dNew.z
                  );

      lpcpt->pt3dNew.x = ( cos( dfRot ) * dfDst );
      lpcpt->pt3dNew.z = ( sin( dfRot ) * dfDst );

   }

   /*  Exit if move point.  */

   if ( lpcpt->unFlags == CPF_MOVE )
      return;

   /*  Adjust relative location and size in space.  */

   lpcpt->pt3dNew.x += pt3dLoc.x;
   lpcpt->pt3dNew.y += pt3dLoc.y;
   lpcpt->pt3dNew.z += pt3dLoc.z;

   if ( lpcpt->pt3dNew.x != 0. || lpcpt->pt3dNew.y != 0. )
   {
      dfRot = atan2( lpcpt->pt3dNew.y, lpcpt->pt3dNew.x );

      dfDst = sqrt( lpcpt->pt3dNew.x * lpcpt->pt3dNew.x +
                    lpcpt->pt3dNew.y * lpcpt->pt3dNew.y
                  );

      dfDst *= ( lpcpt->pt3dNew.z - ZSZ_ATMINSIZ ) / ZSZ_ATMAXSIZ;

      if ( dfDst < 0. )
         dfDst = 0.;

      lpcpt->pt3dNew.x = ( cos( dfRot ) * dfDst );
      lpcpt->pt3dNew.y = ( sin( dfRot ) * dfDst );

   }

   return;

}

/******************************************************************************

   Function Name: RecordPlayback

   Description:

      Plays back the recording.

   Control Flow:

   Return Values:

      None.

   Notes:

******************************************************************************/

void NEAR PASCAL RecordPlayback( 

   HWND hWnd            /* Window handle.
                        */

   )
      
{
   /*  Variable definition.  */

   RECT           rClient;                   /* Client rectangle */

   HBRUSH         hEraseBrush;               /* Brush handle */

   WORD           unC,                       /* Counting variable */
                  unI;                       /* Indexing variable */

   /*  Erase the background.  */

   hEraseBrush = GetStockObject( WHITE_BRUSH );

   GetClientRect( hWnd, &rClient );

   DPtoLP( hClientDC, (LPPOINT) &rClient, 2 );

   FillRect( hClientDC, &rClient, hEraseBrush );

   /*  Playback the records.  */

   _llseek( fhRecordFile, 0L, 0 );

   for ( unC = 0; unC < unRecordCnt; ++unC )
   {
      /*  Read the next set of points.  */

      RecordRead( );

      /*  Perform our painting.  */

      FillRect( hClientDC, &rUpdate, hEraseBrush );

      for ( unI = 0; unI < MAX_SHAPES; ++unI )
         Polyline( hClientDC,
                   &aptList[ ashpList[ unI ].unIndex ],
                   ashpList[ unI ].unCnt
                 );

   }

   return;

}

/******************************************************************************

   Function Name: RecordRead

   Description:

      Reads one set of points from the file.

   Control Flow:

   Return Values:

      None.

   Notes:

******************************************************************************/

void NEAR PASCAL RecordRead( void )

{
   /*  Read the points in.  */

   _lread( fhRecordFile, (LPSTR) &rUpdate, sizeof ( RECT ) );
   _lread( fhRecordFile, (LPSTR) aptList, sizeof ( POINT ) * MAX_POINTS );

   return;

}

/******************************************************************************

   Function Name: RecordWrite

   Description:

      Writes one set of points to the file.

   Control Flow:

   Return Values:

      None.

   Notes:

******************************************************************************/

void NEAR PASCAL RecordWrite( void )

{
   /*  Read the points in.  */

   _lwrite( fhRecordFile, (LPSTR) &rUpdate, sizeof ( RECT ) );
   _lwrite( fhRecordFile, (LPSTR) aptList, sizeof ( POINT ) * MAX_POINTS );

   ++unRecordCnt;

   return;

}

/******************************************************************************

   Function Name: Key

   Description:

      Provides processing for key events.

   Control Flow:

   Return Values:

      None.

   Notes:

******************************************************************************/

void NEAR PASCAL Key( 

   HWND hWnd,           /* Window handle.
                        */

   WORD wId             /* Key ID.
                        */

   )
      
{
   /*  Parse the key pressed and adjust the appropiate rotation amount.  */

   switch ( wId )
   {
      case VK_NUMPAD2:

         pt3dRot.x -= ROT_INC;

         if ( pt3dRot.x <= ROT_MIN )
            pt3dRot.x = ROT_MAX;

         break;

      case VK_NUMPAD8:

         pt3dRot.x += ROT_INC;

         if ( pt3dRot.x >= ROT_MAX )
            pt3dRot.x = ROT_MIN;

         break;

      case VK_NUMPAD4:

         pt3dRot.y -= ROT_INC;

         if ( pt3dRot.y <= ROT_MIN )
            pt3dRot.y = ROT_MAX;

         break;

      case VK_NUMPAD6:

         pt3dRot.y += ROT_INC;

         if ( pt3dRot.y >= ROT_MAX )
            pt3dRot.y = ROT_MIN;

         break;

      case VK_NUMPAD1:

         pt3dRot.z -= ROT_INC;

         if ( pt3dRot.z <= ROT_MIN )
            pt3dRot.z = ROT_MAX;

         break;

      case VK_NUMPAD9:

         pt3dRot.z += ROT_INC;

         if ( pt3dRot.z >= ROT_MAX )
            pt3dRot.z = ROT_MIN;

         break;

      default:

         return;
         break;

   }

   /*  If not animating then calculate the new points and paint them.  */

   if ( !bAnimate )
   {
      CalcNewCranePts( );
      InvalidateRect( hWnd, NULL, TRUE );
   }

   return;

}

/******************************************************************************

   Function Name: Size

   Description:

      Performs processing for re-sizing of the client window.

   Control Flow:

   Return Values:

      None.

   Notes:

******************************************************************************/

void NEAR PASCAL Size(

   HWND hWnd,           /* Window handle.
                        */

   LONG lParam          /* 32-bit parameter.
                        */

   )

{
   /*  Variable definition.  */

   POINT          ptExt,                     /* Extents */
                  ptOrg;                     /* Origin */

   /*  Get the new size and update the mapping.  */

   ptExt = MAKEPOINT( lParam );

   if ( ptExt.x < ptExt.y )
   {
      ptOrg.x = 0;
      ptOrg.y = ( ptExt.y - ptExt.x ) / 2;
      ptExt.y = ptExt.x;
   }
   else
   {
      ptOrg.x = ( ptExt.x - ptExt.y ) / 2;
      ptOrg.y = 0;
      ptExt.x = ptExt.y;
   }

   SetViewportOrg( hClientDC, ptOrg.x, ptOrg.y );
   SetViewportExt( hClientDC, ptExt.x, ptExt.y );

   InvalidateRect( hWnd, NULL, TRUE );

   return;

}

/******************************************************************************

   Function Name: Paint

   Description:

      Performs updates on the client area as requested by window messages.

   Control Flow:

   Return Values:

      None.

   Notes:

******************************************************************************/

void NEAR PASCAL Paint( 

   HWND hWnd            /* Window handle.
                        */

   )

{
   /*  Variable definition.  */

   PAINTSTRUCT    stPS;                      /* Painting structure */

   WORD           unI;                       /* Indexing variable */

   /*  Prepare the client area for painting.  */

   BeginPaint( hWnd, &stPS );

   /*  Perform our painting.  */

   for ( unI = 0; unI < MAX_SHAPES; ++unI )
      Polyline( hClientDC,
                &aptList[ ashpList[ unI ].unIndex ],
                ashpList[ unI ].unCnt
              );

   /*  We're done so exit.  */

   EndPaint( hWnd, &stPS );

   return;

}

/******************************************************************************

   Function Name: ResetCranePts

   Description:

      Resets the crane points back to the origin.

   Control Flow:

   Return Values:

      None.

   Notes:

******************************************************************************/

void NEAR PASCAL ResetCranePts( void )
      
{
   /*  Reset the points.  */

   pt3dRot.x = 0.;
   pt3dRot.y = 0.;
   pt3dRot.z = 0.;

   pt3dLoc.x = 0.;
   pt3dLoc.y = 0.;
   pt3dLoc.z = 0.;

   CalcNewCranePts( );

   return;

}

/******************************************************************************

   Function Name: myYield

   Description:

      Uses PeekMessage to yield control.

   Control Flow:

   Return Values:

      None.

   Notes:

******************************************************************************/

void NEAR PASCAL myYield( void )

{
   /*  Variable definition.  */

   MSG            stMsg;                     /* Buffer to hold message */

   /*  Process messages until exit.  */

   while ( PeekMessage( &stMsg, NULL, 0, 0, PM_REMOVE ) )
   {
      TranslateMessage( &stMsg );
      DispatchMessage( &stMsg );
   }

   return;

}