TOOLS.C

Go to the documentation of this file.

/* file  WTOOLS.C   Animator tools for Windows */

#define MODULE_TOOLS 1

#include "animate.h"

static short PanTo(long *, long *, long);
static void get_stage_actor_position(node *Np, long *x, long *y, long *z,
    long *xx, long *yy, long *zz);
static void get_stage_actor_rotation(node *Np, double *theta,
       double *phi, double *alpha);
static void get_stage_actor_expansion(node *Np, double *sx,
       double *sy, double *sz);

static double lpa,lpp,lpt;
static long lpx,lpy,lpz,lpxx,lpyy,lpzz;

long GrabonX,GrabonY,GrabonZ,GrabDx,GrabDy,GrabDz;

void ExecuteActorsMenu(HWND hWnd){
  long idata[12]={IDBM_MENU1_MO,
                  IDBM_MENU1_MF,
                  IDBM_MENU1_CA,
                  IDBM_MENU1_TA,
                  IDBM_MENU1_LI,
                  IDBM_MENU1_PA,
                  IDBM_MENU1_SK,
                  IDBM_MENU1_GR,
                  IDBM_MENU1_RO,
                  IDBM_MENU1_CS,
                  IDBM_MENU1_XI,
                  IDBM_MENU1_DR};
  long icommand[12]={
    IDM_ACTOR_QADD_MOD,
    IDM_ACTOR_QADD_MORPH,
    IDM_ACTOR_QADD_CAMERA,
    IDM_ACTOR_QADD_TARGET,
    IDM_ACTOR_QADD_LIGHT,
    IDM_ACTOR_QADD_PATH,
    IDM_ACTOR_QADD_SKY,
    IDM_ACTOR_QADD_GROUND,
    IDM_ACTOR_QADD_ROBOT,
    IDM_ACTOR_QADD_CSG,
    IDM_ACTOR_QADD_XIP,
    IDM_ACTOR_QADD_DIRECTOR};
  int i;
  POINT pt;
  HMENU hMenu=CreatePopupMenu();
  HBITMAP hBitmap[12];
  RECT rc;
  UINT align=TPM_LEFTALIGN;
  GetWindowRect(GetDlgItem(ghwndTools,7),&rc);
  if(bToolpannelLeft){pt.x=rc.right; align=TPM_LEFTALIGN; }
  else               {pt.x=rc.left;  align=TPM_RIGHTALIGN;}
  pt.y=rc.top; //  GetCursorPos(&pt);
  for(i=0;i<12;i++){
    hBitmap[i]=LoadBitmap(ghinst_main,MAKEINTRESOURCE(idata[i]));
    AppendMenu(hMenu,MF_ENABLED|MF_BITMAP,icommand[i],(LPCSTR)hBitmap[i]);
    if(i == 1 || i == 5 || i == 9)
      AppendMenu(hMenu,MF_SEPARATOR,0,NULL);
  }
  TrackPopupMenu(hMenu,align | TPM_LEFTBUTTON,
                        pt.x,pt.y,0,hWnd,NULL);
  DestroyMenu(hMenu);
  for(i=0;i<12;i++){
    if(hBitmap[i] != NULL)DeleteObject(hBitmap);
  }
  InvalidateRect(ghwndTools,NULL,FALSE);
}

void EngageTool(int newtool){
 int oldtool;
 oldtool=tool;
 if(tool != NOTOOL){
    DisengageTool();
 }
 TOOLCHANGED:
 if(newtool == NODETOOL){
   if(SelectedNode != NULL){
     if(SelectedNode->type == PATH){
       newtool=PATHEDITOR; goto TOOLCHANGED;
     }
     else if(SelectedNode->type == ROBOT){
       newtool=SKELETOR; goto TOOLCHANGED;
     }
   }
   if(tool == NOTOOL){
     tool=NODETOOL;
     SendPrgmMessage(IDS_NODESELECTOR1,1);
   }
 }
 else if(newtool == GRABBER){
   Save_UndoA();
   SendPrgmMessage(IDS_GRABBERTOOL,1);
   StageGrabOn();
   AugmentToolPannel(TRUE);
 }
 else if(newtool == ROTATOR){
   Save_UndoA();
   SendPrgmMessage(IDS_ROTATORTOOL,1);
   StageRotateOn();
   AugmentToolPannel(TRUE);
 }
 else if(newtool == SIZER){
   Save_UndoA();
   SendPrgmMessage(IDS_SIZERTOOL,1);
   StageSizeOn();
   AugmentToolPannel(TRUE);
 }
 else if(newtool == TRACKER){
   Save_UndoA();
   SendPrgmMessage(IDS_TRACKER,1);
   ShifterOn();
   if(tool == TRACKER)SetCursor(ghcurTracker);
 }
 else if(newtool == PATHEDITOR){
   Save_UndoA();
   SendPrgmMessage(IDS_PATHEDITORTOOL,1);
   EditPathOn();
   if(tool == PATHEDITOR)SetCursor(ghcurPathed);
 }
 else if(newtool == SKELETOR){
   Save_UndoA();
   SendPrgmMessage(IDS_SKELETORTOOL,1);
   SkeletorOn();
   if(tool == SKELETOR)SetCursor(ghcurSkeletor);
 }
 else if(newtool == PAN){
   SendPrgmMessage(IDS_PANTOOL,1);
   tool=newtool;
 }
 else if(newtool == INZOOM){
   SendPrgmMessage(IDS_INZOOMTOOL,1);
   tool=newtool;
 }
 if(newtool >= NTOOLS)newtool=NODETOOL;
 else if(tool != NOTOOL)SetCursor(ghcurTools[newtool]);
 InvalidateRect(ghwndTools,NULL,FALSE);
}

void DisengageTool(void){
 int otool;
 otool=tool;
 if(tool == GRABBER || tool == ROTATOR ||     // To switch out of internal
    tool == SIZER)AugmentToolPannel(FALSE);   // undo
 if     (tool == GRABBER)StageGrabOff(1);
 else if(tool == ROTATOR)RotateOff(1);
 else if(tool == SIZER)SizeOff(1);
 else if(tool == PAN || tool == INZOOM)tool=NOTOOL;
 else if(tool == TRACKER && subtool == SHIFTER)ShifterOff(1);
 else if(tool == TRACKER && subtool == ANGLER)AnglerOff(1);
 else if(tool == PATHEDITOR)EditPathOff(1);
 else if(tool == SKELETOR)SkeletorOff(1);
 else if(tool == NODETOOL)tool=NOTOOL;
 if(otool >= NTOOLS)otool=NODETOOL;
 InvalidateRect(ghwndTools,NULL,FALSE);
 SendPrgmMessage(IDS_SELECTTOOL,1);
 SetCursor(ghcurArrow);
}

object *PickNode(short type1, short type2){
 node *Np;
 object *Op;
 point  p,tp;
 short im,hx,vy;
 double dmin,phi,theta,alpha,sx,sy,sz,ima;
 Op=NULL;
 if((Np=FirstNp) == NULL)return NULL;
 else if(tool == PATHEDITOR && type1 != PATH){
    SendPrgmQuery(IDQ_INPATH,0);
    return NULL;
 }
 else if(tool == TRACKER && subtool == SHIFTER){
    SendPrgmQuery(IDQ_INSHIFTER,0);
    return NULL;
 }
 else if(tool == TRACKER && subtool == ANGLER){
    SendPrgmQuery(IDQ_INANGLER,0);
    return NULL;
 }
 if(SelectedNode == NULL)while(Np != NULL){
   if((Op=Np->fobj) != NULL)while(Op != NULL){
     if( CurrentFrame >= Op->firstframe && CurrentFrame <= Op->lastframe
         && (type1 == Op->type || type2 == Op->type))goto GOTIT;
     Op=Op->next;
   }
   Np=Np->next;
 }
 else{
  if((Np=SelectedNode->next) == NULL)Np=FirstNp;
  while(Np != SelectedNode){
    if((Op=Np->fobj) != NULL)while(Op != NULL){
      if( CurrentFrame >= Op->firstframe && CurrentFrame <= Op->lastframe
          && (type1 == Op->type || type2 == Op->type))goto GOTIT;
      Op=Op->next;
    }
    Np=Np->next;
    if(Np == NULL)Np=FirstNp;
  }
 }
 return NULL;
GOTIT:
 if(Op != NULL && !(GetAsyncKeyState(VK_CONTROL) & 0x80000)){/* ctrl -  don't ON */
   GetTransform(0,CurrentFrame,1.0,
                Np,Op,p,tp,&phi,&theta,&alpha,&sx,&sy,&sz,&im,&ima);
   if( ! in_stage_triview(p)){
     TVpointX = p[0]-TVsizeX/2;
     TVpointY = p[1]-TVsizeY/2;
     TVpointZ = p[2]-TVsizeZ/2;
   }
   GrabonX=NpointerX=p[0]; GrabDx=0;
   GrabonY=NpointerY=p[1]; GrabDy=0;
   GrabonZ=NpointerZ=p[2]; GrabDz=0;
   UpdateRuler(0);
 }
 SelectedNode=Np;
 if(tool == GRABBER)get_stage_actor_position(SelectedNode,
                    &lpx,&lpy,&lpz,&lpxx,&lpyy,&lpzz);
 if(tool == ROTATOR)get_stage_actor_rotation(SelectedNode,
                    &lpt,&lpp,&lpa);
 if(tool == SIZER)get_stage_actor_expansion(SelectedNode,
                    &lpt,&lpp,&lpa);
 if(tool == PATHEDITOR){
  SelectedPath=NULL; SelectedPathPoint=NULL;
 }
 UpdateSelectedActor(TRUE);
 if(tool == NODETOOL){
   EngageTool(NODETOOL);
   if(tool == NODETOOL)ReDrawStageDisplay(TRUE);
 }
 else
   ReDrawStageDisplay(TRUE);
 return Op;
}

int CheckClosestObject(int w,double *dmin,point vp,int hx,int vy,int r){
 int sho,svo;
 double d;
 GetWindowCoords(w,vp[0],vp[1],vp[2],&sho,&svo);
 if( (sho > hx-r) && (sho < hx+r)
  && (svo > vy-r) && (svo < vy+r)){
   d=(double)(vp[0]-NpointerX)*(double)(vp[0]-NpointerX)
    +(double)(vp[1]-NpointerY)*(double)(vp[1]-NpointerY)
    +(double)(vp[2]-NpointerZ)*(double)(vp[2]-NpointerZ);
   if(d < *dmin){
     *dmin=d;
     return 1;
   }
 }
 return 0;
}

BOOL PickClosestNode(int wid, int hx, int vy, BOOL pick_only){
 node *Np,*node_found=NULL;
 pathpoint *Pp;
 object *Op;
 point  ObjectOffset,vp,tp;
 short im;
 double dmin,dmin1,phi,theta,alpha,sx,sy,sz,ima;
 int type;
 dmin=(double)TVsizeX*(double)TVsizeX*(double)TVsizeZ;
 if((Np=FirstNp) == NULL)return FALSE;
 while(Np != NULL){
   if((Op=Np->fobj) != NULL)while(Op != NULL){
     if( CurrentFrame >= Op->firstframe && CurrentFrame <= Op->lastframe){
       GetTransform(0,CurrentFrame,1.0,
                    Np,Op,ObjectOffset,tp,&phi,&theta,&alpha,
                    &sx,&sy,&sz,&im,&ima);
       if(Op->type == PATH){
         Pp=Op->firstpathpoint; while(Pp != NULL){
           AddPoints(Pp->p,ObjectOffset,vp);
           dmin1=dmin;
           if(CheckClosestObject(wid,&dmin,vp,hx,vy,5) == 1){
             node_found=Np;
             if(node_found == SelectedNode)dmin=dmin1;
             break;
           }
           Pp=Pp->next;
         }
       }
       else if(Op->type == CAMERA){
         CopyPoint(ObjectOffset,vp);
         dmin1=dmin;
         if(CheckClosestObject(wid,&dmin,vp,hx,vy+8,12) == 1){
           node_found=Np;
           if(node_found == SelectedNode)dmin=dmin1;
         }
       }
       else if(Op->type == LIGHT){
         CopyPoint(ObjectOffset,vp);
         dmin1=dmin;
         if(CheckClosestObject(wid,&dmin,vp,hx-2,vy+8,10) == 1){
           node_found=Np;
           if(node_found == SelectedNode)dmin=dmin1;
         }
       }
       else if(Op->type == NORMAL || Op->type == ANIMOBJ){
         if(DrawStatus == 0 || Op->quick_only == 1)type=0;
         else if(DrawStatus == 3 || (DrawStatus == 2 && Np != SelectedNode)
                 || (DrawStatus == 1 && Np == SelectedNode))type=1;
         else type=0;
         dmin1=dmin;
         if(CheckBoundingObject(type,wid,hx,vy,Op,ObjectOffset,
            phi,theta,alpha,im,ima,sx,sy,sz,&dmin) == 1){
           node_found=Np;
           if(node_found == SelectedNode)dmin=dmin1;
         }
       }
       else if(Op->type == PARTICLE){
         dmin1=dmin;
         if(CheckBoundingObject(0,wid,hx,vy,Op,ObjectOffset,
            phi,theta,alpha,im,ima,sx,sy,sz,&dmin) == 1){
           node_found=Np;
           if(node_found == SelectedNode)dmin=dmin1;
         }
       }
       else{
         CopyPoint(ObjectOffset,vp);
         dmin1=dmin;
         if(CheckClosestObject(wid,&dmin,vp,hx,vy,5) == 1){
           node_found=Np;
           if(node_found == SelectedNode)dmin=dmin1;
         }
       }
     }
     Op=Op->next;
   }
   Np=Np->next;
 }
 if(node_found == NULL)return FALSE;
 if(node_found == SelectedNode)return TRUE;
 SelectedNode=node_found;
 UpdateSelectedActor(TRUE);
 if(tool == NODETOOL || tool == PATHEDITOR || tool == SKELETOR ||
    tool == TRACKER){
   if(tool == TRACKER)EngageTool(TRACKER);
   else               EngageTool(NODETOOL);
   if(tool == NODETOOL)ReDrawStageDisplay(TRUE);
   else if(pick_only)return TRUE;
   else              return FALSE;
 }
 else
   ReDrawStageDisplay(TRUE);
 return TRUE;
}

BOOL PickClosestPathPoint(int wid, int hx, int vy){
 node *Np,*node_found=NULL;
 pathpoint *Pp,*point_found=NULL;
 object *Op,*path_found=NULL;
 point  ObjectOffset,vp,tp;
 short im;
 double dmin,phi,theta,alpha,sx,sy,sz,ima;
 int type;
 dmin=(double)TVsizeX*(double)TVsizeX*(double)TVsizeZ;
 GrabonX=NpointerX; GrabonY=NpointerY; GrabonZ=NpointerZ;
 Np=FirstNp; while(Np != NULL){
   if((Op=Np->fobj) != NULL)while(Op != NULL){
     if(Op->type == PATH){
       if( CurrentFrame >= Op->firstframe && CurrentFrame <= Op->lastframe){
            GetTransform(0,CurrentFrame,1.0,
                         Np,Op,ObjectOffset,tp,&phi,&theta,&alpha,
                         &sx,&sy,&sz,&im,&ima);
         Pp=Op->firstpathpoint; while(Pp != NULL){
           AddPoints(Pp->p,ObjectOffset,vp);
           if(CheckClosestObject(wid,&dmin,vp,hx,vy,3) == 1){
             node_found=Np;
             path_found=Op;
             point_found=Pp;
           }
           Pp=Pp->next;
         }
       }
     }
     Op=Op->next;
   }
   Np=Np->next;
 }
 if(node_found == NULL){
   if(SelectedNode == NULL){
     SelectedPath=NULL;  SelectedPathPoint=NULL;
   }
   return FALSE;
 }
 if(node_found  == SelectedNode &&
    path_found  == SelectedPath &&
    point_found == SelectedPathPoint)return TRUE;
 if(node_found == SelectedNode){
   DrawInvertNode(ghdc_triview_Bitmap,SelectedNode,EDITING);
   SelectedPath=path_found;
   SelectedPathPoint=point_found;
   DrawInvertNode(ghdc_triview_Bitmap,SelectedNode,EDITING);
   return TRUE;
 }
 SelectedNode=node_found;
 SelectedPath=path_found;
 SelectedPathPoint=point_found;
 UpdateSelectedActor(TRUE);
 ReDrawStageDisplay(TRUE);
 return TRUE;
}

void SnapTo(short option){
 object *Op;
 pathpoint *Pp;
 point p,po;
 double zero=0.0,one=1.0,length_on_path;
 p[0]=po[0]=0; p[1]=po[1]=0; p[2]=po[2]=0;
 if(SelectedNode == NULL)return;
 GetOffsetPosition(SelectedNode,NULL,CurrentFrame,1.0,p);
 if(option > 0){ /* start/end of path */
   if(SelectedNode->type != PATH){
     SendPrgmQuery(IDQ_NOPATH,0);
     return;
   }
   if     (option == 1){
     Op=GetObjectAtFrame(SelectedNode,CurrentFrame);
     if(Op == NULL)return;
     if((Pp=Op->firstpathpoint) == NULL)return;
     CopyPoint(Pp->p,po);
   }
   else if(option == 2){
     Op=GetObjectAtFrame(SelectedNode,CurrentFrame);
     if(Op == NULL)return;
     if((Pp=Op->firstpathpoint) == NULL)return;
     while(Pp->next != NULL)Pp=Pp->next;
     CopyPoint(Pp->p,po);
   }
   else if(option == 3){
     if(tool != PATHEDITOR || SelectedPathPoint == NULL){
       SendPrgmQuery(IDQ_NOPATH,0);
       return;
     }
     if(SelectedPathPoint != NULL)CopyPoint(SelectedPathPoint->p,po);
   }
   AddPoints(p,po,p);
 }
 if( (p[0] > TVpointX && p[0] < TVpointX+TVsizeX)
  && (p[1] > TVpointY && p[1] < TVpointY+TVsizeY)
  && (p[2] > TVpointZ && p[2] < TVpointZ+TVsizeZ)){
    Draw3dCursor();
    NpointerX=p[0];
    NpointerY=p[1];
    NpointerZ=p[2];
    Draw3dCursor();
 }
 else{
   NpointerX=p[0];
   NpointerY=p[1];
   NpointerZ=p[2];
   TVpointX=NpointerX - TVsizeX/2;
   TVpointY=NpointerY - TVsizeY/2;
   TVpointZ=NpointerZ - TVsizeZ/2;
   ReDrawStageDisplay(TRUE);
  if(ghwndOpenGLview == NULL)PerspectiveView(0,1);
  else UpdateGLview(TRUE);
 }
 if(coords_visible)UpdateRuler(0);
}

#define TIME_DELAY 30

// move tool code

static position *GrabIdentity;

void EnterGrabMode(void){
 int i,ifd,ild;
 do_NOT_abort=YES;
 DrawInvertNode(ghdc_triview_Bitmap,SelectedNode,SELECTED);
 /* now draw directly onto screen */
 if(View == TRIVIEW){ifd=0;ild=3;}
 else               {ifd=ActiveView; ild=ifd+1;}
 for(i=ifd;i<ild;i++)UpdateWindow(ghwnd_triview[i]);
 Draw3dCursor();
 DrawInvertNode(NULL,SelectedNode,SELECTED);
 Draw3dCursor();
 do_NOT_abort=NO;
}

void LeaveGrabMode(void){
 do_NOT_abort=YES;
 DrawInvertNode(ghdc_triview_Bitmap,SelectedNode,SELECTED);
 do_NOT_abort=NO;
 if(ghwndOpenGLview != NULL)UpdateGLview(TRUE);
 else PerspectiveView(0,1);
}

position *IsValidPosition(void){
 position *Pp;
 if(SelectedNode == NULL)return NULL;
 Pp=SelectedNode->fpos; while(Pp != NULL){
   if(CurrentFrame >= Pp->firstframe && CurrentFrame <= Pp->lastframe){
     if(CurrentFrame == Pp->lastframe ||
        (Pp->type != TWEEN && Pp->type != SPLINE && Pp->type != FOLLOWAT)){
       return Pp;
     }
     return NULL;
   }
   Pp=Pp->next;
 }
 return NULL;
}

int StageGrabIdentify(void){ /* Button down */
 position *Pp;
 int id;
 GrabIdentity=NULL;
 if(SelectedNode == NULL)return 0;
 Pp=SelectedNode->fpos; while(Pp != NULL){
   if(CurrentFrame >= Pp->firstframe && CurrentFrame <= Pp->lastframe){
     if(CurrentFrame == Pp->lastframe ||
        (Pp->type != TWEEN && Pp->type != SPLINE && Pp->type != FOLLOWAT)){
       GrabIdentity=Pp;
       GrabonX=NpointerX; GrabonY=NpointerY; GrabonZ=NpointerZ;
       return 1;
     }
     if((id=SelectKeyMaker()) > 0){
       if     (id == 1)NextKey('N');
       else if(id == 2)MakeKey('P',CurrentFrame,SelectedNode);
       get_stage_actor_position(SelectedNode,&lpx,&lpy,&lpz,&lpxx,&lpyy,&lpzz);
     }
     return 0;
   }
   Pp=Pp->next;
 }
 MakeControl(SelectedNode,'P',ghwnd_main);
 return 0;
}

void SetNewPosition(long pX, long pY, long pZ, short abrel){
 position *Pp;
 if((Pp=GrabIdentity) != NULL){
   if(Pp->type == TWEEN  || Pp->type == SPLINE || Pp->type == FOLLOWAT){
     if(abrel){Pp->finish[0] =pX;   Pp->finish[1] =pY;  Pp->finish[2] =pZ; }
     else     {Pp->finish[0]+=pX;   Pp->finish[1]+=pY;  Pp->finish[2]+=pZ; }
   }
 }
 return;
}

void StageGrabOn(void){
 EDIT_ACTION=YES;
 tool=GRABBER;
 if(SelectedNode != NULL)get_stage_actor_position(SelectedNode,
   &lpx,&lpy,&lpz,&lpxx,&lpyy,&lpzz);
 ReDrawStageDisplay(TRUE);
}

void StageGrabOff(short redraw){
  tool=NOTOOL;
  if(redraw)ReDrawStageDisplay(TRUE);
}

void StageGrab(short where, short which){
  short id;
  int i,ifd,ild;
  if(View == TRIVIEW){ifd=0;ild=3;}
  else               {ifd=ActiveView; ild=ifd+1;}
  if(SelectedNode == NULL)return;
  if((GrabonX != NpointerX)||(GrabonY != NpointerY)||(GrabonZ != NpointerZ)
                           || (where == 1)){
    GrabDx=NpointerX-GrabonX;
    GrabDy=NpointerY-GrabonY;
    GrabDz=NpointerZ-GrabonZ;
    if(which)DrawInvertNode(ghdc_triview_Bitmap,SelectedNode,SELECTED);
    else{
      Draw3dCursor();
      DrawInvertNode(NULL,SelectedNode,SELECTED);
    }
    if((where%2) == 1)SetNewPosition(NpointerX,NpointerY,NpointerZ,1);
    else              SetNewPosition(GrabDx,GrabDy,GrabDz,0); /* rel */

    if(where < 2){int flag=0,x,y;
      POINT pt;
      GetCursorPos(&pt);
      ScreenToClient(ghwnd_current,&pt);
      x=pt.x; y=pt.y;
      if     (x > WindowSizeX[ActiveView] - 4){
        flag=1;
        if(ActiveView == TRITOP  )Zoom(PANRIGHT,0);
        if(ActiveView == TRIFRONT)Zoom(PANRIGHT,0);
        if(ActiveView == TRIRIGHT)Zoom(PANFORWARD,0);
      }
      else if(x < 4){
        flag=1;
        if(ActiveView == TRITOP  )Zoom(PANLEFT,0);
        if(ActiveView == TRIFRONT)Zoom(PANLEFT,0);
        if(ActiveView == TRIRIGHT)Zoom(PANBACK,0);
      }
      else if(y < 4){
        flag=1;
        if(ActiveView == TRITOP  )Zoom(PANFORWARD,0);
        if(ActiveView == TRIFRONT)Zoom(PANUP,0);
        if(ActiveView == TRIRIGHT)Zoom(PANUP,0);
      }
      else if(y > WindowSizeY[ActiveView] - 4){
        flag=1;
        if(ActiveView == TRITOP  )Zoom(PANBACK,0);
        if(ActiveView == TRIFRONT)Zoom(PANDOWN,0);
        if(ActiveView == TRIRIGHT)Zoom(PANDOWN,0);
      }
      if(flag){
        GetWindowCoords(ActiveView,NpointerX,NpointerY,NpointerZ,&x,&y);
        pt.x=x; pt.y=y;
        ClientToScreen(ghwnd_current,&pt);
        SetCursorPos(pt.x,pt.y);
        ReDrawStageDisplay(FALSE);
        for(i=ifd;i<ild;i++)UpdateWindow(ghwnd_triview[i]);
        Draw3dCursor();
      }
    }

    if(which)DrawInvertNode(ghdc_triview_Bitmap,SelectedNode,SELECTED);
    else{
      DrawInvertNode(NULL,SelectedNode,SELECTED);
      Draw3dCursor();
    }
    if(which)for(i=ifd;i<ild;i++)UpdateWindow(ghwnd_triview[i]);
    if(ghwndOpenGLview == NULL){
      PerspectiveView(View,0);
      UpdateWindow(ghwnd_view);
    }
    else UpdateGLview(FALSE);
    GrabonX=NpointerX;
    GrabonY=NpointerY;
    GrabonZ=NpointerZ;
  }
}

static void get_stage_actor_position(node *Np, long *x, long *y, long *z,
    long *xx, long *yy, long *zz){
 position *Pp;
 *x = *xx = NpointerX; *y = *yy = NpointerY; *z = *zz = NpointerZ;
 if((Pp=Np->fpos) != NULL){
   while(Pp != NULL){
     if(CurrentFrame == Pp->lastframe){
       *x=Pp->finish[0]; *y=Pp->finish[1]; *z=Pp->finish[2];
       return;
     }
     Pp=Pp->next;
   }
 }
 return;
}

void InstantStageGrab(void){
 node *Np;
 short id;
 position *Pp;
 double x,y,z;
 if((Np=SelectedNode) != NULL){
   if((Pp=Np->fpos) != NULL){
     while(Pp != NULL){
       if(CurrentFrame == Pp->lastframe){
         if(Pp->type == TWEEN  || Pp->type == SPLINE){
           x=(double)(Pp->finish[0]-lrulerx)/ruler;
           y=(double)(Pp->finish[1]-lrulery)/ruler;
           z=(double)(Pp->finish[2]-lrulerz)/ruler;
           if(fabs(x) > 999999 || fabs(y) > 999999 || fabs(z) > 999999){
             SendPrgmQuery(IDQ_COORDTOOBIG,0);
             return;
           }
           LoadString(ghinst_main,IDX_MISC_MOVETO,res_str,256);
           if(Read3Reals(res_str,&x,&y,&z,0) == OK){
             Pp->finish[0]=(long)(x*ruler)+lrulerx;
             Pp->finish[1]=(long)(y*ruler)+lrulery;
             Pp->finish[2]=(long)(z*ruler)+lrulerz;
             ReDrawStageDisplay(TRUE);
             if(ghwndOpenGLview == NULL)PerspectiveView(0,1);
             else UpdateGLview(TRUE);
           }
         }
         else SendPrgmQuery(IDQ_ONLYTWEEN,0);
         return;
       }
       Pp=Pp->next;
     }
   }
   SendPrgmQuery(IDQ_ONLYKEYFRAME,0);
 }
 else SendPrgmQuery(IDQ_NOACTORSELECTED,0);
 return;
}

static short SetupActorTrack(node *Np);
static short GetActorTrack(position *fp, position *lp, long nstart);
static void FreeActorTrack(void);

static int key_action_tool;

typedef struct tagTRACKPOINT {
 struct Animator_POSITION *pp;
 point p;
 long  type;
} TRACKPOINT;

static TRACKPOINT *trackpoints=NULL;
static long Ntrackpoints;

void ShifterOn(void){
 node *Np;
 short id;
 position *Pp;
 double x,y,z;
 if(SelectedNode == NULL){
   SendPrgmQuery(IDQ_NOACTORSELECTED,0);
   return;
 }
 if(Nframes == 1){
   SendPrgmQuery(IDQ_MUSTEXCEED1FRAME,0);
   return;
 }
 key_action_tool=gToolFlags.flagT;
 if(!SetupActorTrack(SelectedNode))return;
 EDIT_ACTION=YES;
 tool=TRACKER;  subtool=SHIFTER;
 if(!IsWindow(ghwndDlgTools)){
   ghwndDlgTools=CreateDialog(ghinst_main,MAKEINTRESOURCE(DLG_TRACK_DIRECT),
                                 ghwnd_main,(DLGPROC)SplineTweenDlgProc);
   if(IsWindow(ghwndDlgTools))ShowWindow(ghwndDlgTools,SW_SHOW);
   SetFocus(ghwnd_main);
 }
 ReDrawStageDisplay(TRUE);
}

void ShifterOff(short redraw){
 FreeActorTrack();
 if(IsWindow(ghwndDlgTools)){
   DestroyWindow(ghwndDlgTools);
   ghwndDlgTools=NULL;
 }
 tool=NOTOOL;
 if(redraw)ReDrawStageDisplay(TRUE);
}

static int shiftkeyframe_id = -1;

void ShiftKeyFrameDeactivate(void){
 shiftkeyframe_id = -1;
}

void ShiftKeyFrame(int x, int y){
 position *pp;
 int i,k,oldROP[3];
 long j,id,type;
 int sho,svo,ifd,ild;
 if((id = (long)shiftkeyframe_id) < 0)return;
 if(View == TRIVIEW){ifd=0;ild=3;}
 else               {ifd=ActiveView; ild=ifd+1;}
 for(k=ifd;k<ild;k++)oldROP[k]=SetROP2(ghdc_triview_Bitmap[k],R2_XORPEN);
 DrawActorTrack(ghdc_triview_Bitmap,0);
 DrawNode(ghdc_triview_Bitmap,SelectedNode,SELECTED);
 if(trackpoints[id].pp != NULL){
   if(ActiveView == 0 || ActiveView == 1)trackpoints[id].pp->finish[0]=NpointerX;
   if(ActiveView == 0 || ActiveView == 2)trackpoints[id].pp->finish[1]=NpointerY;
   if(ActiveView == 1 || ActiveView == 2)trackpoints[id].pp->finish[2]=NpointerZ;
 }
 if(!GetActorTrack(SelectedNode->fpos,NULL,0))goto TOOL_ERROR;
 DrawNode(ghdc_triview_Bitmap,SelectedNode,SELECTED);
 DrawActorTrack(ghdc_triview_Bitmap,0);
 for(k=ifd;k<ild;k++)oldROP[k]=SetROP2(ghdc_triview_Bitmap[k],oldROP[k]);
 {int flag=0;
  if     (x > WindowSizeX[ActiveView] - 4){
    flag=1; SendMessage(ghwnd_main,WM_COMMAND,IDM_PAN_RIGHT,ActiveView);
  }
  else if(x < 4){
    flag=1; SendMessage(ghwnd_main,WM_COMMAND,IDM_PAN_LEFT,ActiveView);
  }
  else if(y < 4){
    flag=1; SendMessage(ghwnd_main,WM_COMMAND,IDM_PAN_UP,ActiveView);
  }
  else if(y > WindowSizeY[ActiveView] - 4){
    flag=1; SendMessage(ghwnd_main,WM_COMMAND,IDM_PAN_DOWN,ActiveView);
  }
  if(flag){
    POINT pt;
    GetWindowCoords(ActiveView,NpointerX,NpointerY,NpointerZ,&x,&y);
    pt.x=x; pt.y=y;
    ClientToScreen(ghwnd_current,&pt);
    SetCursorPos(pt.x,pt.y);
  }
 }
 for(k=ifd;k<ild;k++){
   InvalidateRect(ghwnd_triview[k],NULL,FALSE);
   UpdateWindow(ghwnd_triview[k]);
 }
 if(ghwndOpenGLview == NULL)PerspectiveView(0,0);
 else UpdateGLview(FALSE);
 return;
 TOOL_ERROR:
 ShifterOff(1);
 return;
}

int ShiftKeyFrameActivate(int x, int y){
 position *pp;
 int xo,i,k,space_exit=0,oldROP[3];
 long j,id,type;
 double d,dmin,drange;
 int sho,svo,ifd,ild;
 POINT pt;
 HCURSOR hSaveCursor;
 long evTime;
 if(trackpoints == NULL || SelectedNode == NULL)return 0;
 if(View == TRIVIEW){ifd=0;ild=3;}
 else               {ifd=ActiveView; ild=ifd+1;}
 id = -1; type=1;  shiftkeyframe_id = (int)id;
 LOOP:
 dmin=(double)TVsizeX*(double)TVsizeX;
 drange=dmin/32/32;
 for(j=0;j<Ntrackpoints;j++){
   if(trackpoints[j].type == type && in_stage_triview(trackpoints[j].p)){
     GetWindowCoords(ActiveView,trackpoints[j].p[0],
       trackpoints[j].p[1],trackpoints[j].p[2],&sho,&svo);
     if( (sho > x-4) && (sho < x+4) && (svo > y-4) && (svo < y+4)){
       d=(double)(trackpoints[j].p[0]-NpointerX)
        *(double)(trackpoints[j].p[0]-NpointerX)
        +(double)(trackpoints[j].p[1]-NpointerY)
        *(double)(trackpoints[j].p[1]-NpointerY)
        +(double)(trackpoints[j].p[2]-NpointerZ)
        *(double)(trackpoints[j].p[2]-NpointerZ);
       if(d < dmin){
         dmin=d;
         id=j;
       }
     }
   }
 }
 if(id < 0){
   if(type == 1)type=0;
   else  return 0;
   goto LOOP;
 }
 key_action_tool=gToolFlags.flagT;
 if(trackpoints[id].type == 0){ /* make a key frame */
   char ttt[64];
   LoadString(ghinst_main,IDX_MISC_CREATEKEY,res_str,256);
   LoadString(ghinst_main,IDX_MISC_CONFIRM,ttt,64);
   if(MessageBox(NULL,res_str,ttt,
      MB_YESNO|MB_ICONQUESTION|MB_TASKMODAL) != IDYES)return -1;
   for(k=ifd;k<ild;k++)oldROP[k]=SetROP2(ghdc_triview_Bitmap[k],R2_XORPEN);
   DrawActorTrack(ghdc_triview_Bitmap,0);
   DrawNode(ghdc_triview_Bitmap,SelectedNode,SELECTED);
   trackpoints[id].pp->firstframe=id+2; /* because id starts at 0 */
   if(trackpoints[id].pp->last == NULL)j=id+1;
   else j=trackpoints[id].pp->last->lastframe+1;
   if((pp=CreatePosition(SelectedNode,j,id+1)) == NULL)goto TOOL_ERROR;
   UPDATETIMELINES(IDC_TIMEL_UPDATE)
   CopyPoint(trackpoints[id].p,pp->finish);
   pp->type=trackpoints[id].pp->type;
   if(!GetActorTrack(SelectedNode->fpos,NULL,0))goto TOOL_ERROR;
   DrawNode(ghdc_triview_Bitmap,SelectedNode,SELECTED);
   DrawActorTrack(ghdc_triview_Bitmap,0);
   for(k=ifd;k<ild;k++){
     oldROP[k]=SetROP2(ghdc_triview_Bitmap[k],oldROP[k]);
     InvalidateRect(ghwnd_triview[k],NULL,FALSE);
     UpdateWindow(ghwnd_triview[k]);
   }
   return -1;
 }
 else if(key_action_tool > 0){
   i=key_action_tool;
   pp=trackpoints[id].pp;
   while (GetAsyncKeyState(VK_LBUTTON) & 0x8000){;}
   if(i == 1){ /* time shift */
     GetCursorPos(&pt); xo=pt.x;
     evTime=GetTickCount()+TIME_DELAY;
     do {
       if(evTime > GetTickCount())continue;
       if(GetAsyncKeyState(VK_LBUTTON) & 0x8000)break;
       GetCursorPos(&pt); y=pt.x;
       x = y-xo; xo=y;
       if(x != 0){
         if(x > 0)y=max( 1,min( 45,x));
         else     y=min(-1,max(-45,x));
/*         BKIN: */
         if(abs(y) > 5){
           for(k=ifd;k<ild;k++)oldROP[k]=SetROP2(ghdc_triview_Bitmap[k],R2_XORPEN);
           DrawActorTrack(ghdc_triview_Bitmap,0);
           DrawNode(ghdc_triview_Bitmap,SelectedNode,SELECTED);
           if(pp->next != NULL){
             if(y < 0 && pp->lastframe > pp->firstframe){
               pp->lastframe--;
               pp->next->firstframe--;
             }
             else if(y > 0 && pp->next->firstframe < pp->next->lastframe){
               pp->lastframe++;
               pp->next->firstframe++;
             }
           }
           if(!GetActorTrack(SelectedNode->fpos,NULL,0))goto TOOL_ERROR;
           DrawNode(ghdc_triview_Bitmap,SelectedNode,SELECTED);
           DrawActorTrack(ghdc_triview_Bitmap,0);
           for(k=ifd;k<ild;k++){
             oldROP[k]=SetROP2(ghdc_triview_Bitmap[k],oldROP[k]);
             InvalidateRect(ghwnd_triview[k],NULL,FALSE);
             UpdateWindow(ghwnd_triview[k]);
           }
         }
         if(abs(y) < 50){ /* mouse in use do - pause */
           evTime=GetTickCount()+TIME_DELAY;
           while(GetTickCount() < TIME_DELAY){;}
           GetCursorPos(&pt); xo=pt.x;
         }
       }
//       Get_Key(&key,&ekey);
//       if(key == 0 && ekey == RIGHTARROW){y = -50; goto BKIN;}
//       if(key == 0 && ekey == LEFTARROW) {y =  50; goto BKIN;}
//       if(key == RETURN || key == SPACE)break;
       evTime=GetTickCount()+TIME_DELAY;
     }
     while(1);
   }
   else if(i == 2){ /* delete */
     if(pp->last == NULL || pp->next == NULL){
       SendPrgmQuery(IDQ_NOENDCHANGE,0);
       return -1;
     }
     for(k=ifd;k<ild;k++)oldROP[k]=SetROP2(ghdc_triview_Bitmap[k],R2_XORPEN);
     DrawActorTrack(ghdc_triview_Bitmap,0);
     DrawNode(ghdc_triview_Bitmap,SelectedNode,SELECTED);
     i=pp->firstframe;
     pp=pp->next;
     DeletePosition(SelectedNode,i);
     UPDATETIMELINES(IDC_TIMEL_UPDATE)
     pp->firstframe=i;
     if(!GetActorTrack(SelectedNode->fpos,NULL,0))goto TOOL_ERROR;
     DrawNode(ghdc_triview_Bitmap,SelectedNode,SELECTED);
     DrawActorTrack(ghdc_triview_Bitmap,0);
     for(k=ifd;k<ild;k++){
       oldROP[k]=SetROP2(ghdc_triview_Bitmap[k],oldROP[k]);
       InvalidateRect(ghwnd_triview[k],NULL,FALSE);
       UpdateWindow(ghwnd_triview[k]);
     }
   }
   else if(i == 3){ /* change tension */
     GetCursorPos(&pt); xo=pt.x;
     evTime=GetTickCount()+TIME_DELAY;
     do {
       if(evTime > GetTickCount())continue;
       if(GetAsyncKeyState(VK_LBUTTON) & 0x8000)break;
       GetCursorPos(&pt); y=pt.x;
       x = y-xo; xo=y;
       if(x != 0){
         if(x > 0)y=max( 1,min( 50,x));
         else     y=min(-1,max(-50,x));
         d=1.0+(double)y/95.0;
         for(k=ifd;k<ild;k++)oldROP[k]=SetROP2(ghdc_triview_Bitmap[k],R2_XORPEN);
         DrawActorTrack(ghdc_triview_Bitmap,0);
         DrawNode(ghdc_triview_Bitmap,SelectedNode,SELECTED);
         if((dmin=pp->tension_e * d) > 0.01 && dmin < 0.95)pp->tension_e=dmin;
         if(pp->next != NULL){
           if((dmin=pp->next->tension_s * d) > 0.01 && dmin < 0.95)
             pp->next->tension_s=dmin;
         }
         if(!GetActorTrack(SelectedNode->fpos,NULL,0))goto TOOL_ERROR;
         DrawNode(ghdc_triview_Bitmap,SelectedNode,SELECTED);
         DrawActorTrack(ghdc_triview_Bitmap,0);
         for(k=ifd;k<ild;k++){
           oldROP[k]=SetROP2(ghdc_triview_Bitmap[k],oldROP[k]);
           InvalidateRect(ghwnd_triview[k],NULL,FALSE);
           UpdateWindow(ghwnd_triview[k]);
         }
       }
//       if(key == RETURN || key == SPACE)break;
       evTime=GetTickCount()+TIME_DELAY;
     }
     while(1);
   }
//   SetCursor(hSaveCursor);
   while (GetAsyncKeyState(VK_LBUTTON) & 0x8000){;}
   if(ghwndOpenGLview == NULL)PerspectiveView(0,1);
   else UpdateGLview(TRUE);
   return 0;
 }
 shiftkeyframe_id = (int)id;
 return 1;
 TOOL_ERROR:
 ShifterOff(1);
 return 0;
}

static short SetupActorTrack(node *Np){
 position *pp;
 if(Np == NULL)return 0;
 else if(Np->fpos == NULL){ /* create the time lines */
   if(CreatePosition(Np,1,1) == NULL)return 0;
   if(CreatePosition(Np,2,Nframes) == NULL)return 0;
   Np->fpos->type=SPLINE;
   Np->fpos->next->type=SPLINE;
   UPDATETIMELINES(IDC_TIMEL_UPDATE)
 }
 pp=Np->fpos;
 while(pp != NULL){
   if(!(pp->type == TWEEN || pp->type == SPLINE)){
     SendPrgmQuery(IDQ_ONLYTWEEN,0);
     return 0;
   }
   pp=pp->next;
 }
 if((trackpoints=(TRACKPOINT *)X__Malloc(Nframes*sizeof(TRACKPOINT))) == NULL){
   SendPrgmQuery(IDQ_NOMEM2,0);
   return 0;
 }
 if(!GetActorTrack(Np->fpos,NULL,0)){
   FreeActorTrack();
   return 0;
 }
 return 1;
}

static short GetActorTrack(position *fp, position *lp, long nstart){
 long i;
 double ratio,dr,kx[4],ky[4],kz[4],gs,ge;
 point dp,spl,spn;
 Ntrackpoints=nstart;
 while(fp != lp){
   dr=1.0/(double)(fp->lastframe+1 - fp->firstframe);
   for(i=fp->firstframe;i<=fp->lastframe;i++){
     if(fp->type == TWEEN){
       if((fp->last == NULL) || (fp->firstframe == fp->lastframe))
         CopyPoint(fp->finish,trackpoints[Ntrackpoints].p);
       else{
         ratio=(double)(i+1 - fp->firstframe)*dr;
         SubPoints(fp->finish,fp->last->finish,dp);
         ScalePoint(ratio,ratio,ratio,dp,dp);
         AddPoints(fp->last->finish,dp,trackpoints[Ntrackpoints].p);
         if(fp->last->lastframe != fp->firstframe-1){
           SendPrgmQuery(IDQ_NOGAPINTIMELINE,0);
           return 0;
         }
       }
     }
     else if(fp->type == SPLINE){
       if((fp->last == NULL) || (fp->firstframe == fp->lastframe))
         CopyPoint(fp->finish,trackpoints[Ntrackpoints].p);
       else{
         ratio=(double)(i+1 - fp->firstframe)*dr;
         if(fp->last->last != NULL){
           CopyPoint(fp->last->last->finish,spl);
         }
         else{
           SubPoints(fp->finish,fp->last->finish,dp);
           SubPoints(fp->last->finish,dp,spl);
         }
         if(fp->next != NULL){
           CopyPoint(fp->next->finish,spn);
         }
         else{
           SubPoints(fp->finish,fp->last->finish,dp);
           AddPoints(fp->finish,dp,spn);
         }
         gs=(double)(fp->finish[0]-spl[0])*fp->tension_s;
         ge=(double)(spn[0]-fp->last->finish[0])*fp->tension_e;
         SplinesG(kx,fp->last->finish[0],fp->finish[0],gs,ge);

         gs=(double)(fp->finish[1]-spl[1])*fp->tension_s;
         ge=(double)(spn[1]-fp->last->finish[1])*fp->tension_e;
         SplinesG(ky,fp->last->finish[1],fp->finish[1],gs,ge);

         gs=(double)(fp->finish[2]-spl[2])*fp->tension_s;
         ge=(double)(spn[2]-fp->last->finish[2])*fp->tension_e;
         SplinesG(kz,fp->last->finish[2],fp->finish[2],gs,ge);

         trackpoints[Ntrackpoints].p[0] = SplinesP(kx,ratio);
         trackpoints[Ntrackpoints].p[1] = SplinesP(ky,ratio);
         trackpoints[Ntrackpoints].p[2] = SplinesP(kz,ratio);
         /* extra bit here if needed in future */
       }
     }
     trackpoints[Ntrackpoints].pp=fp;
     if(i==fp->lastframe)trackpoints[Ntrackpoints].type=1;
     else                trackpoints[Ntrackpoints].type=0;
     Ntrackpoints++;
   }
   fp=fp->next;
 }
 return 1;
}

void DrawActorTrack(HDC hdc[],short mode){
 int i,sh,sv,shi[3],svi[3];
 long j;
 int ifd,ild;
 LOGPEN lopn;
 HPEN hOldPen[3];
 GetObject(ghSelectedPen,sizeof(LOGPEN),&lopn);
 if(View == TRIVIEW){ifd=0;ild=3;}
 else               {ifd=ActiveView; ild=ifd+1;}
 if(trackpoints == NULL)return;
 for(j=0;j<Ntrackpoints;j++){
   for(i=ifd;i<ild;i++){
     hOldPen[i]=SelectObject(hdc[i],ghInvertPen);
     if(j > 0){
       MoveToEx(hdc[i],shi[i],svi[i],NULL);
     }
     GetWindowCoords(i,
                     trackpoints[j].p[0],
                     trackpoints[j].p[1],
                     trackpoints[j].p[2],&shi[i],&svi[i]);
     if(j > 0){
       LineTo(hdc[i],shi[i],svi[i]);
     }
     if(!mode && trackpoints[j].type){
       SelectObject(hdc[i],ghSelectedPen);
       Rectangle(hdc[i],(int)shi[i]-2,(int)svi[i]-2,
                        (int)shi[i]+3,(int)svi[i]+3);
     }
     else if(shi[i] >= 0 && shi[i] < WindowSizeX[i] &&
             svi[i] >= 0 &&  svi[i] < WindowSizeY[i]){
       Rectangle(hdc[i],(int)shi[i]-1,(int)svi[i]-1,
                        (int)shi[i]+2,(int)svi[i]+2);
//       X__SetPixel(hdc[i],shi[i],svi[i],lopn.lopnColor);
     }
     SelectObject(hdc[i],hOldPen[i]);
   }
 }
}

static void FreeActorTrack(void){
  if(trackpoints != NULL)X__Free(trackpoints);
  trackpoints=NULL;
}
// end move tool code

// expand tool code

void StageSizeOn(void){
 node *Np;
 size *Xp;
 double x,y,z;
 WORD res;
 EDIT_ACTION=YES;
 tool=SIZER;
 if(SelectedNode != NULL){
   get_stage_actor_expansion(SelectedNode,&lpt,&lpp,&lpa);
   if(!IsWindow(ghwndDlgTools)){
     if(SelectedNode->type != CAMERA){
       if(SelectedNode->type == LIGHT){
         gToolFlags.flagX=TRUE;
         gToolFlags.flagY=FALSE;
         gToolFlags.flagZ=TRUE;
         res=DLG_SIZERL;
       }
       else res=DLG_SIZER;
       ghwndDlgTools=CreateDialog(ghinst_main,MAKEINTRESOURCE(res),
                                  ghwnd_main,(DLGPROC)SizerToolDlgProc);
       if(IsWindow(ghwndDlgTools))ShowWindow(ghwndDlgTools,SW_SHOW);
       SetFocus(ghwnd_main);
     }
     else{
       gToolFlags.flagX=TRUE;
       gToolFlags.flagY=TRUE;
       gToolFlags.flagZ=FALSE;
     }
   }
 }
 ReDrawStageDisplay(TRUE);
}

void SizeOff(short redraw){
 tool=NOTOOL;
 if(IsWindow(ghwndDlgTools)){
   DestroyWindow(ghwndDlgTools);
   ghwndDlgTools=NULL;
 }
 if(redraw)ReDrawStageDisplay(TRUE);
}

static void ScalePath(short sor){
 object *Op;
 pathpoint *Ppp;
 int x,xo,MickeyX,I;
 POINT pt;
 long evTime;
 double scale_value,Sx,Sy,Sz,tro[4][4];
 if((Op=SelectedNode->fobj) != NULL)while(Op != NULL){
  if(CurrentFrame >= Op->firstframe || CurrentFrame <= Op->lastframe){
    GetCursorPos(&pt); xo=pt.x;
    evTime=GetTickCount()+TIME_DELAY;
    do {
     if(evTime > GetTickCount())continue;
     GetCursorPos(&pt); x=pt.x;
     MickeyX = x-xo; xo=x;
     if(MickeyX != 0){
      if(MickeyX > 0)I=max( 1,min( 50,MickeyX));
      else           I=min(-1,max(-50,MickeyX));
      DrawInvertNode(ghdc_triview_Bitmap,SelectedNode,SELECTED);
      if(sor == 0){ /* change of scale */
        scale_value = 1.0 + (double)(I)/55.0; Sx=Sy=Sz=1.0;
        if(gToolFlags.flagX)Sx=scale_value;
        if(gToolFlags.flagY)Sy=scale_value;
        if(gToolFlags.flagZ)Sz=scale_value;
      }
      else{ /* a rotation about the origin */
        if     (gToolFlags.flagA == 2)roty(tro,-I*PIo180);
        else if(gToolFlags.flagA == 1)rotx(tro, I*PIo180);
        else  rotz(tro,I*PIo180);
      }
      if((Ppp=Op->firstpathpoint) != NULL){
        while(Ppp != NULL){
          if(sor == 0){
            Ppp->p[0] *= Sx; Ppp->p[1] *= Sy; Ppp->p[2] *= Sz;
          }
          else{
            m4by1(tro,(double)Ppp->p[0],(double)Ppp->p[1],(double)Ppp->p[2],
                  &Sx,&Sy,&Sz);
            Ppp->p[0] = (long)Sx; Ppp->p[1] = (long)Sy; Ppp->p[2] = (long)Sz;
          }
          Ppp=Ppp->next;
        }
      }
      DrawInvertNode(ghdc_triview_Bitmap,SelectedNode,SELECTED);
      if(ghwndOpenGLview == NULL){
        PerspectiveView(View,0);
        UpdateWindow(ghwnd_view);
      }
      else UpdateGLview(FALSE);
      if(View == TRIVIEW){
        for(I=0;I<3;I++)UpdateWindow(ghwnd_triview[I]);
      }
      else UpdateWindow(ghwnd_current);
     }
     evTime=GetTickCount()+TIME_DELAY;
     {MSG msg;
       if(PeekMessage(&msg, 0, 0, 0, PM_REMOVE)){
         TranslateMessage(&msg);
         DispatchMessage(&msg);
       }
      }
    }
    while (GetAsyncKeyState(VK_LBUTTON) & 0x8000);
    Op->pathlength=PathLength(Op->firstpathpoint /* re-calculate the length */
                             ,Op->pathtype,Op->npathpoints);
    if(ghwndOpenGLview != NULL)UpdateGLview(TRUE);
    else PerspectiveView(0,1);
    return;
  }
  Op=Op->next;
 }
 return;
}

void Resize(void){
 size *Xp;
 int x,xo,MickeyX,I,id;
 double scale_value;
 POINT pt;
 long evTime;
 if(SelectedNode == NULL)return;
 if( !(SelectedNode->type == NORMAL || SelectedNode->type == GROUND   ||
       SelectedNode->type == PATH   || SelectedNode->type == ANIMOBJ  ||
       SelectedNode->type == CAMERA || SelectedNode->type == PARTICLE ||
       SelectedNode->type == ROBOT  || SelectedNode->type == LIGHT)){
    SendPrgmQuery(IDQ_NORESIZE,0);
    return;
 }
 if(SelectedNode->type == PATH){ScalePath(0); return;}
 else if((Xp=SelectedNode->fsiz) != NULL){
   while(Xp != NULL){
     if(CurrentFrame == Xp->lastframe){
       GetCursorPos(&pt); xo=pt.x;
       evTime=GetTickCount()+TIME_DELAY;
       do {
         if(evTime > GetTickCount())continue;
         GetCursorPos(&pt); x=pt.x;
         MickeyX = x-xo; xo=x;
         if(MickeyX != 0){
           if(MickeyX > 0)I=max( 1,min( 50,MickeyX));
           else           I=min(-1,max(-50,MickeyX));
           DrawInvertNode(ghdc_triview_Bitmap,SelectedNode,SELECTED);
           scale_value = 1.0 + (double)(I)/55.0;
           if(gToolFlags.flagX)Xp->Sx *= scale_value;
           if(gToolFlags.flagY)Xp->Sy *= scale_value;
           if(SelectedNode->type == CAMERA){
             Xp->Sx = min(Xp->Sx,20);
             Xp->Sx = max(Xp->Sx,0.1);
             Xp->Sy = min(Xp->Sy,20);
             Xp->Sy = max(Xp->Sy,0.1);
           }
           else if(SelectedNode->type == LIGHT){
             Xp->Sx = min(Xp->Sx,150);
             Xp->Sx = max(Xp->Sx,1);
             if(gToolFlags.flagZ)Xp->Sz *= scale_value;
//             Xp->Sy = min(Xp->Sy,150);
//             Xp->Sy = max(Xp->Sy,1);
           }
           else{
             if(gToolFlags.flagZ)Xp->Sz *= scale_value;
           }
           DrawInvertNode(ghdc_triview_Bitmap,SelectedNode,SELECTED);
           if(ghwndOpenGLview == NULL){
             PerspectiveView(View,0);
             UpdateWindow(ghwnd_view);
           }
           else UpdateGLview(FALSE);
           if(View == TRIVIEW){
             for(I=0;I<3;I++)UpdateWindow(ghwnd_triview[I]);
           }
           else UpdateWindow(ghwnd_current);
         }
         evTime=GetTickCount()+TIME_DELAY;
         {MSG msg;
          if(PeekMessage(&msg, 0, 0, 0, PM_REMOVE)){
            TranslateMessage(&msg);
            DispatchMessage(&msg);
          }
         }
       }
       while (GetAsyncKeyState(VK_LBUTTON) & 0x8000);
      if(ghwndOpenGLview != NULL)UpdateGLview(TRUE);
      else PerspectiveView(0,1);
      return;
     }
     Xp=Xp->next;
   }
   /* try to make key */
   Xp=SelectedNode->fsiz; while(Xp != NULL){
     if(CurrentFrame >= Xp->firstframe && CurrentFrame <= Xp->lastframe){
       if(CurrentFrame == Xp->lastframe)return;
       if((id=SelectKeyMaker()) > 0){
         if(id == 1){
           NextKey('N');
         }
         else if(id == 2){
           DrawInvertNode(ghdc_triview_Bitmap,SelectedNode,SELECTED);    /* in case it doesn't come */
           MakeKey('Z',CurrentFrame,SelectedNode);                       /* back at the same place  */
           DrawInvertNode(ghdc_triview_Bitmap,SelectedNode,SELECTED);
         }
       }
       return;
     }
     Xp=Xp->next;
   }
 }
 MakeControl(SelectedNode,'Z',ghwnd_main);
 return;
}

static void get_stage_actor_expansion(node *Np, double *sx,
       double *sy, double *sz){
 size *Xp;
 *sx=1.0; *sy=1.0; *sz=1.0;
 if((Xp=Np->fsiz) != NULL){
   while(Xp != NULL){
     if(CurrentFrame == Xp->lastframe){
       *sx=Xp->Sx; *sy=Xp->Sy; *sz=Xp->Sz;
       return;
     }
     Xp=Xp->next;
   }
 }
 return;
}

void InstantStageXpnd(void){
 node *Np;
 size *Xp;
 short id;
 double x,y,z;
 if((Np=SelectedNode) != NULL){
   if((Xp=Np->fsiz) != NULL){
     while(Xp != NULL){
       if(CurrentFrame == Xp->lastframe){
         x=Xp->Sx; y=Xp->Sy; z=Xp->Sz;
         LoadString(ghinst_main,IDX_MISC_SETSCALE,res_str,256);
         if(Read3Reals(res_str,&x,&y,&z,0) == OK){
           Xp->Sx=x; Xp->Sy=y; Xp->Sz=z;
           ReDrawStageDisplay(TRUE);
           if(ghwndOpenGLview == NULL)PerspectiveView(0,1);
           else UpdateGLview(TRUE);
         }
         else SendPrgmQuery(IDQ_ONLYTWEEN,0);
         return;
       }
       Xp=Xp->next;
     }
   }
   SendPrgmQuery(IDQ_ONLYKEYFRAME,0);
 }
 else SendPrgmQuery(IDQ_NOACTORSELECTED,0);
 return;
}
// end expand tool code

// rotate tool code

void StageRotateOn(void){
 EDIT_ACTION=YES;
 tool=ROTATOR;
 if(SelectedNode != NULL)get_stage_actor_rotation(SelectedNode,
   &lpt,&lpp,&lpa);
// if(!IsWindow(ghwndDlgTools)){
//   ghwndDlgTools=CreateDialog(ghinst_main,MAKEINTRESOURCE(DLG_ROTATOR),
//                                 ghwnd_main,(DLGPROC)RotatorToolDlgProc);
//   if(IsWindow(ghwndDlgTools))ShowWindow(ghwndDlgTools,SW_SHOW);
//   SetFocus(ghwnd_main);
// }
 ReDrawStageDisplay(TRUE);
}

void RotateOff(long redraw){
 tool=NOTOOL;
 if(IsWindow(ghwndDlgTools)){
   DestroyWindow(ghwndDlgTools);
   ghwndDlgTools=NULL;
 }
 if(redraw)ReDrawStageDisplay(TRUE);
}

static void get_stage_actor_rotation(node *Np, double *theta,
       double *phi, double *alpha){
 align *Ap;
 *theta=0.0; *alpha=0.0; *phi=0.0;
 if((Ap=Np->fali) != NULL){
   while(Ap != NULL){
     if(CurrentFrame == Ap->lastframe){
       *alpha=Ap->alpha; *phi=Ap->phi; *theta=Ap->theta;
       return;
     }
     Ap=Ap->next;
   }
 }
 return;
}

void StageRotate(long window_id){
 align *Ap;
 int x,xo,MickeyX,I,id;
 POINT pt;
 long evTime;
 if(ActiveView == TRITOP  )gToolFlags.flagA = 0;
 if(ActiveView == TRIRIGHT)gToolFlags.flagA = 1;
 if(ActiveView == TRIFRONT)gToolFlags.flagA = 2;
 if(SelectedNode == NULL)return;
 if(SelectedNode->type == PATH){ScalePath(1); return;}
 else if((Ap=SelectedNode->fali) != NULL){
  while(Ap != NULL){
   if(CurrentFrame == Ap->lastframe){
    GetCursorPos(&pt); xo=pt.x;
    evTime=GetTickCount()+TIME_DELAY;
    do {
     if(evTime > GetTickCount())continue;
     GetCursorPos(&pt); x=pt.x;
     MickeyX = x-xo; xo=x;
     if(MickeyX != 0){
      if(MickeyX > 0)I=max( 1,min( 90,MickeyX));
      else           I=min(-1,max(-90,MickeyX));
      if((GetAsyncKeyState(VK_SHIFT) & 0x8000) == 0x8000){
        /* constrain 45 degrees */
        if(abs(I) < 22)I=0;
        else{
          if(I < 0)I = -45;
          else     I =  45;
        }
      }
      DrawInvertNode(ghdc_triview_Bitmap,SelectedNode,SELECTED);
      if(gToolFlags.flagA == 2){ /* bank */
        Ap->theta -= I;if(Ap->theta> 180.0)Ap->theta= -360+Ap->theta;
      }
      else if(gToolFlags.flagA == 1 ||
             (GetAsyncKeyState(VK_CONTROL) & 0x8000)){ /* up/down */
        if(Ap->type == TWEEN || Ap->type == SPLINEA){
          Ap->alpha += I;if(Ap->alpha> 180.0)Ap->alpha= -360+Ap->alpha;
        }
      }
      else{   /* around and about rotation */
        if(Ap->type == TWEEN || Ap->type == SPLINEA){ /* not used for track, align, rotate */
          Ap->phi += I;if(Ap->phi> 180.0)Ap->phi= -360+Ap->phi;
        }
      }
      DrawInvertNode(ghdc_triview_Bitmap,SelectedNode,SELECTED);
      if(ghwndOpenGLview == NULL){
        PerspectiveView(View,0);
        UpdateWindow(ghwnd_view);
      }
      else UpdateGLview(FALSE);
      if(View == ONEVIEW)UpdateWindow(ghwnd_current);
      else{
        for(I=0;I<3;I++)UpdateWindow(ghwnd_triview[I]);
      }
     }
     evTime=GetTickCount()+TIME_DELAY;
      {MSG msg;
       if(PeekMessage(&msg, 0, 0, 0, PM_REMOVE)){
         TranslateMessage(&msg);
         DispatchMessage(&msg);
       }
      }
    }
    while (GetAsyncKeyState(VK_LBUTTON) & 0x8000);
    if(ghwndOpenGLview != NULL)UpdateGLview(TRUE);
    else PerspectiveView(0,1);
    return;
   }
   Ap=Ap->next;
  }
  /* try to make key */
  Ap=SelectedNode->fali; while(Ap != NULL){
    if(CurrentFrame >= Ap->firstframe && CurrentFrame <= Ap->lastframe){
      if(CurrentFrame == Ap->lastframe)return;
      if((id=SelectKeyMaker()) > 0){
        if(id == 1){
          NextKey('N');
        }
        else if(id == 2){
          DrawInvertNode(ghdc_triview_Bitmap,SelectedNode,SELECTED);    /* in case it doesn't come */
          MakeKey('A',CurrentFrame,SelectedNode);                       /* back at the same place  */
          DrawInvertNode(ghdc_triview_Bitmap,SelectedNode,SELECTED);
        }
      }
      return;
    }
    Ap=Ap->next;
  }
 }
 MakeControl(SelectedNode,'A',ghwnd_main);
 return;
}

void StageStepRotate(int command){
 align *Ap;
 long axis,I;
 int id;
 axis=0;
 if(GetAsyncKeyState(VK_SHIFT) & 0x8000)I=5;
 else I=1;
 if(command == IDM_PAN_RIGHT){I =  I; axis=0;}
 if(command == IDM_PAN_LEFT) {I = -I; axis=0;}
 if(command == IDM_PAN_UP)   {I =  I; axis=1;}
 if(command == IDM_PAN_DOWN) {I = -I; axis=1;}
 if(command == IDM_ZOOM_IN)  {I =  I; axis=2;}   /* bank */
 if(command == IDM_ZOOM_OUT) {I = -I; axis=2;}   /* bank */
 if(SelectedNode == NULL)return;
 if(SelectedNode->type == PATH){return;}
 else if((Ap=SelectedNode->fali) != NULL){
  while(Ap != NULL){
   if(CurrentFrame == Ap->lastframe){
     DrawInvertNode(ghdc_triview_Bitmap,SelectedNode,SELECTED);
     if(axis == 2){/* bank */
       Ap->theta -= I;if(Ap->theta> 180.0)Ap->theta= -360+Ap->theta;
     }
     else if(axis == 1){
       if(Ap->type == TWEEN || Ap->type == SPLINEA){
         Ap->alpha += I;if(Ap->alpha> 180.0)Ap->alpha= -360+Ap->alpha;
       }
     }
     else{   /* around and about rotation */
       if(Ap->type == TWEEN || Ap->type == SPLINEA){ /* not used for track, align, rotate */
         Ap->phi += I;if(Ap->phi> 180.0)Ap->phi= -360+Ap->phi;
       }
     }
     DrawInvertNode(ghdc_triview_Bitmap,SelectedNode,SELECTED);
     if(ghwndOpenGLview == NULL)PerspectiveView(0,0);
     else UpdateGLview(FALSE);
     return;
   }
   Ap=Ap->next;
  }
  /* try to make key */
  Ap=SelectedNode->fali; while(Ap != NULL){
    if(CurrentFrame >= Ap->firstframe && CurrentFrame <= Ap->lastframe){
      if(CurrentFrame == Ap->lastframe)return;
      if((id=SelectKeyMaker()) > 0){
        if(id == 1){
          NextKey('N');
        }
        else if(id == 2){
          DrawInvertNode(ghdc_triview_Bitmap,SelectedNode,SELECTED);    /* in case it doesn't come */
          MakeKey('A',CurrentFrame,SelectedNode);                       /* back at the same place  */
          DrawInvertNode(ghdc_triview_Bitmap,SelectedNode,SELECTED);
        }
      }
      return;
    }
    Ap=Ap->next;
  }
 }
 MakeControl(SelectedNode,'A',ghwnd_main);
}

void InstantStageRotate(void){
 node *Np;
 align *Ap;
 short id;
 double x,y,z;
 if((Np=SelectedNode) != NULL){
   if((Ap=Np->fali) != NULL){
     while(Ap != NULL){
       if(CurrentFrame == Ap->lastframe){
         if(Ap->type == TWEEN || Ap->type == SPLINEA){
           x=Ap->phi; y=Ap->alpha; z=Ap->theta;
           LoadString(ghinst_main,IDX_MISC_SETROTATION,res_str,256);
           if(Read3Reals(res_str,&x,&y,&z,1) == OK){
             Ap->phi=x; Ap->alpha=y; Ap->theta=z;
             ReDrawStageDisplay(TRUE);
             if(ghwndOpenGLview == NULL)PerspectiveView(0,1);
             else UpdateGLview(TRUE);
           }
         }
         else SendPrgmQuery(IDQ_ONLYTWEEN,0);
         return;
       }
       Ap=Ap->next;
     }
   }
   SendPrgmQuery(IDQ_ONLYKEYFRAME,0);
 }
 else SendPrgmQuery(IDQ_NOACTORSELECTED,0);
 return;
}

static short SetupActorAngles(node *Np);
static short GetActorAngles(align *fa, align *la, long nstart);
static void FreeActorAngles(void);

typedef struct Animator_TRACKANGLE {
 struct Animator_ALIGN *ap;
 double alpha,theta,phi;
 long  type;
} TRACKANGLE;

static TRACKANGLE *trackangles=NULL;
static long Ntrackangles;
static align *SelectedActorRotation=NULL;

static short SetupActorAngles(node *Np){
 align *ap;
 if(Np == NULL)return 0;
 else if(Np->fali == NULL){ /* create the time lines */
   if(CreateAlign(Np,1,1) == NULL)return 0;
   if(CreateAlign(Np,2,Nframes) == NULL)return 0;
   Np->fali->type=TWEEN;
   Np->fali->next->type=TWEEN;
   UPDATETIMELINES(IDC_TIMEL_UPDATE)
 }
 ap=Np->fali;
 while(ap != NULL){
   if(!(ap->type == TWEEN || ap->type == SPLINEA)){
     SendPrgmQuery(IDQ_ONLYTWEEN,0);
     return 0;
   }
   ap=ap->next;
 }
 if((trackangles=(TRACKANGLE *)X__Malloc(Nframes*sizeof(TRACKANGLE))) == NULL){
   SendPrgmQuery(IDQ_NOMEM2,0);
   return 0;
 }
 if(!GetActorAngles(Np->fali,NULL,0)){
   FreeActorAngles();
   return 0;
 }
 return 1;
}

static void FreeActorAngles(void){
  if(trackangles != NULL)X__Free(trackangles);
  trackangles=NULL;
}

static short GetActorAngles(align *fa, align *la, long nstart){
 long i,ddt;
 double ratio,dr,dp,kx[4],ky[4],kz[4],dpl,dpn;
 Ntrackangles=nstart;
 while(fa != la){
   dr=1.0/(double)(fa->lastframe+1 - fa->firstframe);
   for(i=fa->firstframe;i<=fa->lastframe;i++){
     if(fa->type == TWEEN){
       if((fa->last == NULL) || (fa->firstframe == fa->lastframe)){
          trackangles[Ntrackangles].phi=fa->phi;
          trackangles[Ntrackangles].theta=fa->theta;
          trackangles[Ntrackangles].alpha=fa->alpha;
       }
       else{
         ratio=(double)(i+1 - fa->firstframe)*dr;
         dp = fa->phi - fa->last->phi;
         if(dp < -180.0)dp += 360.0;
         if(dp >  180.0)dp -= 360.0;
         dp *= ratio;
         dp += fa->last->phi;
         if(dp < -180.0)dp += 360.0;
         if(dp >  180.0)dp -= 360.0;
         trackangles[Ntrackangles].phi = dp;
         dp = fa->theta - fa->last->theta;
         if(dp < -180.0)dp += 360.0;
         if(dp >  180.0)dp -= 360.0;
         dp *= ratio;
         dp += fa->last->theta;
         if(dp < -180.0)dp += 360.0;
         if(dp >  180.0)dp -= 360.0;
         trackangles[Ntrackangles].theta = dp;
         dp = fa->alpha - fa->last->alpha;
         if(dp < -180.0)dp += 360.0;
         if(dp >  180.0)dp -= 360.0;
         dp *= ratio;
         dp += fa->last->alpha;
         if(dp < -180.0)dp += 360.0;
         if(dp >  180.0)dp -= 360.0;
         trackangles[Ntrackangles].alpha = dp;
         if(fa->last->lastframe != fa->firstframe-1){
           SendPrgmQuery(IDQ_NOGAPINTIMELINE,0);
           return 0;
         }
       }
     }
     else if(fa->type == SPLINEA){
       if((fa->last == NULL) || (fa->firstframe == fa->lastframe)){
          trackangles[Ntrackangles].phi=fa->phi;
          trackangles[Ntrackangles].theta=fa->theta;
          trackangles[Ntrackangles].alpha=fa->alpha;
       }
       else{
         ratio=(double)(i+1 - fa->firstframe)*dr;
         dp = fa->phi - fa->last->phi;
         if(dp < -180.0)dp += 360.0;
         if(dp >  180.0)dp -= 360.0;
         if(fa->last->last == NULL)dpl=0.0;
         else{
           dpl = fa->last->phi - fa->last->last->phi;
           if(dpl < -180.0)dpl += 360.0;
           if(dpl >  180.0)dpl -= 360.0;
           ddt = fa->last->lastframe - fa->last->firstframe;
           if(ddt == 0)dpl=0.0; /* single frame  zero gradient */
         }
         if(fa->next == NULL)dpn=0.0;
         else{
           dpn = fa->next->phi - fa->phi;
           if(dpn < -180.0)dpn += 360.0;
           if(dpn >  180.0)dpn -= 360.0;
           ddt = fa->next->lastframe - fa->next->firstframe;
           if(ddt == 0)dpn=0.0;
         }
         dpl *= fa->tension_s; dpn *= fa->tension_e;
         SplinesG(kx,fa->last->phi,fa->last->phi+dp,dpl,dpn);
         dp=SplinesR(kx,ratio);
         if(dp < -180.0)dp += 360.0;
         if(dp >  180.0)dp -= 360.0;
         trackangles[Ntrackangles].phi = dp;
         dp = fa->theta - fa->last->theta;
         if(dp < -180.0)dp += 360.0;
         if(dp >  180.0)dp -= 360.0;
         if(fa->last->last == NULL)dpl=0.0;
         else{
           dpl = fa->last->theta - fa->last->last->theta;
           if(dpl < -180.0)dpl += 360.0;
           if(dpl >  180.0)dpl -= 360.0;
           ddt = fa->last->lastframe - fa->last->firstframe;
           if(ddt == 0)dpl=0.0;
         }
         if(fa->next == NULL)dpn=0.0;
         else{
           dpn = fa->next->theta - fa->theta;
           if(dpn < -180.0)dpn += 360.0;
           if(dpn >  180.0)dpn -= 360.0;
           ddt = fa->next->lastframe - fa->next->firstframe;
           if(ddt == 0)dpn=0.0;
         }
         dpl *= fa->tension_s; dpn *= fa->tension_e;
         SplinesG(kx,fa->last->theta,fa->last->theta+dp,dpl,dpn);
         dp=SplinesR(kx,ratio);
         if(dp < -180.0)dp += 360.0;
         if(dp >  180.0)dp -= 360.0;
         trackangles[Ntrackangles].theta = dp;
         dp = fa->alpha - fa->last->alpha;
         if(dp < -180.0)dp += 360.0;
         if(dp >  180.0)dp -= 360.0;
         if(fa->last->last == NULL)dpl=0.0;
         else{
           dpl = fa->last->alpha - fa->last->last->alpha;
           if(dpl < -180.0)dpl += 360.0;
           if(dpl >  180.0)dpl -= 360.0;
           ddt = fa->last->lastframe - fa->last->firstframe;
           if(ddt == 0)dpl=0.0;
         }
         if(fa->next == NULL)dpn=0.0;
         else{
           dpn = fa->next->alpha - fa->alpha;
           if(dpn < -180.0)dpn += 360.0;
           if(dpn >  180.0)dpn -= 360.0;
           ddt = fa->next->lastframe - fa->next->firstframe;
           if(ddt == 0)dpn=0.0;
         }
         dpl *= fa->tension_s; dpn *= fa->tension_e;
         SplinesG(kx,fa->last->alpha,fa->last->alpha+dp,dpl,dpn);
         dp=SplinesR(kx,ratio);
         if(dp < -180.0)dp += 360.0;
         if(dp >  180.0)dp -= 360.0;
         trackangles[Ntrackangles].alpha = dp;
       }
     }
     trackangles[Ntrackangles].ap=fa;
     if(i==fa->lastframe)trackangles[Ntrackangles].type=1;
     else                trackangles[Ntrackangles].type=0;
     Ntrackangles++;
   }
   fa=fa->next;
 }
 return 1;
}

void AnglerOn(void){
 node *Np;
 short id;
 position *Pp;
 double x,y,z;
 MessageBeep(MB_OK);
 return;
#if 0
 SelectedActorRotation=NULL;
 if(SelectedNode == NULL){
   SendPrgmQuery(IDQ_NOACTORSELECTED,0);
   return;
 }
 if(Nframes == 1){
   SendPrgmQuery(IDQ_MUSTEXCEED1FRAME,0);
   return;
 }
 key_action_tool=gToolFlags.flagR;
 if(!SetupActorTrack(SelectedNode))return;
 if(!SetupActorAngles(SelectedNode)){
  FreeActorAngles(); return;
 }
 EDIT_ACTION=YES;
 tool=TRACKER; subtool=ANGLER;
 if(!IsWindow(ghwndDlgTools)){
   ghwndDlgTools=CreateDialog(ghinst_main,MAKEINTRESOURCE(DLG_DIRECT),
                                 ghwnd_main,(DLGPROC)DirectorToolDlgProc);
   if(IsWindow(ghwndDlgTools))ShowWindow(ghwndDlgTools,SW_SHOW);
   SetFocus(ghwnd_main);
 }
 ReDrawStageDisplay(TRUE);
#endif
}

void AnglerOff(short redraw){
  SelectedActorRotation=NULL;
  FreeActorAngles();
  FreeActorTrack();
  if(IsWindow(ghwndDlgTools)){
    DestroyWindow(ghwndDlgTools);
    ghwndDlgTools=NULL;
  }
  tool=NOTOOL;
  if(redraw)ReDrawStageDisplay(TRUE);
}

void AngleKeyFrame(int x, int y){
 position *pp;
 align    *ap;
 int i,k,xo,oldROP[3];
 long j,id,type;
 double d,dmin,drange;
 int sho,svo,ifd,ild;
 POINT pt;
 HCURSOR hSaveCursor;
 long evTime;
 if(trackpoints == NULL || trackangles == NULL || SelectedNode == NULL)return;
 if(View == TRIVIEW){ifd=0;ild=3;}
 else               {ifd=ActiveView; ild=ifd+1;}
 if(grid_on){
   GetWindowCoords(ActiveView,NpointerX,NpointerY,NpointerZ,&x,&y);
 }
 id = -1; type=1;
 LOOP:
 dmin=(double)TVsizeX*(double)TVsizeX;
 drange=dmin/32/32;
 for(j=0;j<Ntrackpoints;j++){
   if(trackpoints[j].type == type && in_stage_triview(trackpoints[j].p)){
     GetWindowCoords(ActiveView,trackpoints[j].p[0],
       trackpoints[j].p[1],trackpoints[j].p[2],&sho,&svo);
     if( (sho > x-4) && (sho < x+4) && (svo > y-4) && (svo < y+4)){
       d=(double)(trackpoints[j].p[0]-NpointerX)
        *(double)(trackpoints[j].p[0]-NpointerX)
        +(double)(trackpoints[j].p[1]-NpointerY)
        *(double)(trackpoints[j].p[1]-NpointerY)
        +(double)(trackpoints[j].p[2]-NpointerZ)
        *(double)(trackpoints[j].p[2]-NpointerZ);
       if(d < dmin){
         dmin=d;
         id=j;
       }
     }
   }
 }
 if(id < 0){
   if(type == 1)type=0;
   else return;
   goto LOOP;
 }
 if(id >= Ntrackangles)return;
 key_action_tool=gToolFlags.flagR;
 if(trackangles[id].type == 0){ /* make a key frame */
   char ttt[64];
   LoadString(ghinst_main,IDX_MISC_CREATEKEY,res_str,256);
   LoadString(ghinst_main,IDX_MISC_CONFIRM,ttt,64);
   if(MessageBox(NULL,res_str,ttt,
      MB_YESNO|MB_ICONQUESTION|MB_TASKMODAL) != IDYES)return;
   for(k=ifd;k<ild;k++)oldROP[k]=SetROP2(ghdc_triview_Bitmap[k],R2_XORPEN);
   DrawActorRotations(ghdc_triview_Bitmap,0);
   DrawNode(ghdc_triview_Bitmap,SelectedNode,SELECTED);
   trackangles[id].ap->firstframe=id+2; /* because id starts at 0 */
   if(trackangles[id].ap->last == NULL)j=id+1;
   else j=trackangles[id].ap->last->lastframe+1;
   if((ap=CreateAlign(SelectedNode,j,id+1)) == NULL)goto TOOL_ERROR;
   ap->alpha=trackangles[id].alpha;
   ap->theta=trackangles[id].theta;
   ap->phi  =trackangles[id].phi;
   ap->type=trackangles[id].ap->type;
   UPDATETIMELINES(IDC_TIMEL_UPDATE)
   if(!GetActorAngles(SelectedNode->fali,NULL,0))goto TOOL_ERROR;
   DrawNode(ghdc_triview_Bitmap,SelectedNode,SELECTED);
   DrawActorRotations(ghdc_triview_Bitmap,0);
   for(k=ifd;k<ild;k++){
     oldROP[k]=SetROP2(ghdc_triview_Bitmap[k],oldROP[k]);
     InvalidateRect(ghwnd_triview[k],NULL,FALSE);
     UpdateWindow(ghwnd_triview[k]);
   }
   if(ghwndOpenGLview == NULL)PerspectiveView(0,1);
   else UpdateGLview(TRUE);
   return;
 }
 else if(key_action_tool > 0){
   i=key_action_tool;
   ap=trackangles[id].ap;
   while (GetAsyncKeyState(VK_LBUTTON) & 0x8000){;}
   if(i == 1){ /* time shift */
     GetCursorPos(&pt); xo=pt.x;
     evTime=GetTickCount()+TIME_DELAY;
     do {
       if(evTime > GetTickCount())continue;
       if(GetAsyncKeyState(VK_LBUTTON) & 0x8000)break;
       GetCursorPos(&pt); y=pt.x;
       x = y-xo; xo=y;
       if(x != 0){
         if(x > 0)y=max( 1,min( 45,x));
         else     y=min(-1,max(-45,x));
/*         BKIN:  */
         if(abs(y) > 5){
           for(k=ifd;k<ild;k++)oldROP[k]=SetROP2(ghdc_triview_Bitmap[k],R2_XORPEN);
           DrawActorRotations(ghdc_triview_Bitmap,0);
           DrawNode(ghdc_triview_Bitmap,SelectedNode,SELECTED);
           if(ap->next != NULL){
             if(y < 0 && ap->lastframe > ap->firstframe){
               ap->lastframe--;
               ap->next->firstframe--;
             }
             else if(y > 0 && ap->next->firstframe < ap->next->lastframe){
               ap->lastframe++;
               ap->next->firstframe++;
             }
           }
           if(!GetActorAngles(SelectedNode->fali,NULL,0))goto TOOL_ERROR;
           DrawNode(ghdc_triview_Bitmap,SelectedNode,SELECTED);
           DrawActorRotations(ghdc_triview_Bitmap,0);
           for(k=ifd;k<ild;k++){
             oldROP[k]=SetROP2(ghdc_triview_Bitmap[k],oldROP[k]);
             InvalidateRect(ghwnd_triview[k],NULL,FALSE);
             UpdateWindow(ghwnd_triview[k]);
           }
         }
         if(abs(y) < 50){ /* mouse in use do - pause */
           evTime=GetTickCount()+TIME_DELAY;
           while(GetTickCount() < TIME_DELAY){;}
           GetCursorPos(&pt); xo=pt.x;
         }
       }
       evTime=GetTickCount()+TIME_DELAY;
     }
     while(1);
   }
   else if(i == 2){ /* delete */
     if(ap->last == NULL || ap->next == NULL){
       SendPrgmQuery(IDQ_NOENDCHANGE,0);
       return;
     }
     for(k=ifd;k<ild;k++)oldROP[k]=SetROP2(ghdc_triview_Bitmap[k],R2_XORPEN);
     DrawActorRotations(ghdc_triview_Bitmap,0);
     DrawNode(ghdc_triview_Bitmap,SelectedNode,SELECTED);
     i=ap->firstframe;
     ap=ap->next;
     DeleteAlign(SelectedNode,i);
     UPDATETIMELINES(IDC_TIMEL_UPDATE)
     ap->firstframe=i;
     if(!GetActorAngles(SelectedNode->fali,NULL,0))goto TOOL_ERROR;
     DrawNode(ghdc_triview_Bitmap,SelectedNode,SELECTED);
     DrawActorRotations(ghdc_triview_Bitmap,0);
     for(k=ifd;k<ild;k++){
       oldROP[k]=SetROP2(ghdc_triview_Bitmap[k],oldROP[k]);
       InvalidateRect(ghwnd_triview[k],NULL,FALSE);
       UpdateWindow(ghwnd_triview[k]);
     }
   }
   else if(i == 3){ /* change tension */
     for(k=ifd;k<ild;k++)oldROP[k]=SetROP2(ghdc_triview_Bitmap[k],R2_XORPEN);
     DrawActorRotations(ghdc_triview_Bitmap,0);
     SelectedActorRotation=ap;
     DrawActorRotations(ghdc_triview_Bitmap,0);
     for(k=ifd;k<ild;k++){
       oldROP[k]=SetROP2(ghdc_triview_Bitmap[k],oldROP[k]);
       InvalidateRect(ghwnd_triview[k],NULL,FALSE);
       UpdateWindow(ghwnd_triview[k]);
     }
     GetCursorPos(&pt); xo=pt.x;
     evTime=GetTickCount()+TIME_DELAY;
     do {
       if(evTime > GetTickCount())continue;
       if(GetAsyncKeyState(VK_LBUTTON) & 0x8000)break;
       GetCursorPos(&pt); y=pt.x;
       x = y-xo; xo=y;
       if(x != 0){
         if(x > 0)y=max( 1,min( 50,x));
         else     y=min(-1,max(-50,x));
         d=1.0+(double)y/95.0;
         for(k=ifd;k<ild;k++)oldROP[k]=SetROP2(ghdc_triview_Bitmap[k],R2_XORPEN);
         DrawActorRotations(ghdc_triview_Bitmap,0);
         DrawNode(ghdc_triview_Bitmap,SelectedNode,SELECTED);
         if((dmin=ap->tension_e * d) > 0.01 && dmin < 1.95)ap->tension_e=dmin;
         if(ap->next != NULL){
           if((dmin=ap->next->tension_s * d) > 0.01 && dmin < 1.95)
             ap->next->tension_s=dmin;
         }
         if(!GetActorAngles(SelectedNode->fali,NULL,0))goto TOOL_ERROR;
         DrawNode(ghdc_triview_Bitmap,SelectedNode,SELECTED);
         DrawActorRotations(ghdc_triview_Bitmap,0);
         for(k=ifd;k<ild;k++){
           oldROP[k]=SetROP2(ghdc_triview_Bitmap[k],oldROP[k]);
           InvalidateRect(ghwnd_triview[k],NULL,FALSE);
           UpdateWindow(ghwnd_triview[k]);
         }
       }
//       if(key == RETURN || key == SPACE)break;
       evTime=GetTickCount()+TIME_DELAY;
     }
     while(1);
     for(k=ifd;k<ild;k++)oldROP[k]=SetROP2(ghdc_triview_Bitmap[k],R2_XORPEN);
     DrawActorRotations(ghdc_triview_Bitmap,0);
     SelectedActorRotation=NULL;
     DrawActorRotations(ghdc_triview_Bitmap,0);
     for(k=ifd;k<ild;k++){
       oldROP[k]=SetROP2(ghdc_triview_Bitmap[k],oldROP[k]);
       InvalidateRect(ghwnd_triview[k],NULL,FALSE);
       UpdateWindow(ghwnd_triview[k]);
     }
   }
   while (GetAsyncKeyState(VK_LBUTTON) & 0x8000){;}
   if(ghwndOpenGLview == NULL)PerspectiveView(0,1);
   else UpdateGLview(TRUE);
   return;
 }
 ap=trackangles[id].ap;  /* change angles of keyframes */
 for(k=ifd;k<ild;k++)oldROP[k]=SetROP2(ghdc_triview_Bitmap[k],R2_XORPEN);
 DrawActorRotations(ghdc_triview_Bitmap,0);
 SelectedActorRotation=ap;
 DrawActorRotations(ghdc_triview_Bitmap,0);
 for(k=ifd;k<ild;k++){
   oldROP[k]=SetROP2(ghdc_triview_Bitmap[k],oldROP[k]);
   InvalidateRect(ghwnd_triview[k],NULL,FALSE);
   UpdateWindow(ghwnd_triview[k]);
 }
 while (GetAsyncKeyState(VK_LBUTTON) & 0x8000){;}
 GetCursorPos(&pt); xo=pt.x;
 evTime=GetTickCount()+TIME_DELAY;
 do {
   if(evTime > GetTickCount())continue;
   if(GetAsyncKeyState(VK_LBUTTON) & 0x8000)break;
   GetCursorPos(&pt); y=pt.x;
   x = y-xo; xo=y;
   if(x != 0){
     if(x > 0)y=max( 1,min( 45,x));
     else     y=min(-1,max(-45,x));
     for(k=ifd;k<ild;k++)oldROP[k]=SetROP2(ghdc_triview_Bitmap[k],R2_XORPEN);
     DrawActorRotations(ghdc_triview_Bitmap,0);
     DrawNode(ghdc_triview_Bitmap,SelectedNode,SELECTED);
     if(gToolFlags.flagA == 2 ||
        (GetAsyncKeyState(VK_SHIFT   ) & 0x8000)){ /* bank */
       ap->theta -= y;if(ap->theta > 180.0)ap->theta= -360+ap->theta;
     }
     else if(gToolFlags.flagA == 1 ||
             (GetAsyncKeyState(VK_CONTROL) & 0x8000)){ /* up/down */
       ap->alpha += y;if(ap->alpha > 180.0)ap->alpha= -360+ap->alpha;
     }
     else{   /* around and about rotation */
       ap->phi   += y;if(ap->phi > 180.0)ap->phi= -360+ap->phi;
     }
     if(!GetActorAngles(SelectedNode->fali,NULL,0))goto TOOL_ERROR;
     DrawNode(ghdc_triview_Bitmap,SelectedNode,SELECTED);
     DrawActorRotations(ghdc_triview_Bitmap,0);
     for(k=ifd;k<ild;k++){
       oldROP[k]=SetROP2(ghdc_triview_Bitmap[k],oldROP[k]);
       InvalidateRect(ghwnd_triview[k],NULL,FALSE);
       UpdateWindow(ghwnd_triview[k]);
     }
   }
   evTime=GetTickCount()+TIME_DELAY;
 }
 while(1);
 for(k=ifd;k<ild;k++)oldROP[k]=SetROP2(ghdc_triview_Bitmap[k],R2_XORPEN);
 DrawActorRotations(ghdc_triview_Bitmap,0);
 SelectedActorRotation=NULL;
 DrawActorRotations(ghdc_triview_Bitmap,0);
 for(k=ifd;k<ild;k++){
   oldROP[k]=SetROP2(ghdc_triview_Bitmap[k],oldROP[k]);
   InvalidateRect(ghwnd_triview[k],NULL,FALSE);
   UpdateWindow(ghwnd_triview[k]);
 }
 if(ghwndOpenGLview == NULL)PerspectiveView(0,1);
 else UpdateGLview(TRUE);
 return;
 TOOL_ERROR:
 AnglerOff(1);
 return;
}

void DrawActorRotations(HDC hdc[], short mode){
 long j;
 DrawActorTrack(hdc,1);
 if(trackangles == NULL || trackpoints == NULL || Ntrackpoints != Ntrackangles)return;
 for(j=0;j<Ntrackangles;j++){
   if(trackangles[j].type)DrawArrow(hdc,trackpoints[j].p,
      trackangles[j].phi,
      trackangles[j].theta,
      trackangles[j].alpha,
      0,0.0,TVsizeX/24);
   else if(trackangles[j].ap == SelectedActorRotation ||
     (trackangles[j].ap->last != NULL &&
      trackangles[j].ap->last == SelectedActorRotation))
     DrawDirectionLine(hdc,trackpoints[j].p,
      trackangles[j].phi,
      trackangles[j].theta,
      trackangles[j].alpha,
      0,0.0,TVsizeX/36);
 }
}

void SwitchTrackerType(void){
 /* assume either in SHIFTER or ANGLER */
 int oldROP[3],k,ifd,ild;
 if(SelectedNode == NULL)return;
 if(View == TRIVIEW){ifd=0;ild=3;}
 else               {ifd=ActiveView; ild=ifd+1;}
 for(k=ifd;k<ild;k++)oldROP[k]=SetROP2(ghdc_triview_Bitmap[k],R2_XORPEN);
 if(subtool == SHIFTER){
   DrawActorTrack(ghdc_triview_Bitmap,0);
   DrawNode(ghdc_triview_Bitmap,SelectedNode,SELECTED);
   FreeActorTrack();
   subtool=ANGLER;
   SelectedActorRotation=NULL;
   key_action_tool=gToolFlags.flagR;
   SetupActorTrack(SelectedNode);
   SetupActorAngles(SelectedNode);
   DrawNode(ghdc_triview_Bitmap,SelectedNode,SELECTED);
   DrawActorRotations(ghdc_triview_Bitmap,0);
 }
 else if(subtool == ANGLER){
   DrawActorRotations(ghdc_triview_Bitmap,0);
   DrawNode(ghdc_triview_Bitmap,SelectedNode,SELECTED);
   SelectedActorRotation=NULL;
   FreeActorAngles();
   FreeActorTrack();
   subtool=SHIFTER;
   key_action_tool=gToolFlags.flagT;
   SetupActorTrack(SelectedNode);
   DrawNode(ghdc_triview_Bitmap,SelectedNode,SELECTED);
   DrawActorTrack(ghdc_triview_Bitmap,0);
 }
 for(k=ifd;k<ild;k++){
   oldROP[k]=SetROP2(ghdc_triview_Bitmap[k],oldROP[k]);
   InvalidateRect(ghwnd_triview[k],NULL,FALSE);
   UpdateWindow(ghwnd_triview[k]);
 }
}
// end rotate tool code

void EditPathOn(void){
 object *Op;
 short im;
 double sx,sy,sz,ima,x,y,z;
 point tp;
 if(SelectedNode == NULL){
   SendPrgmQuery(IDQ_NOACTORSELECTED,0);
   return;
 }
 if(SelectedNode->type != PATH){
   SendPrgmQuery(IDQ_NOPATH,0);
   return;
 }
 EDIT_ACTION=YES;
 tool=PATHEDITOR;
 SelectedPath=NULL;
 SelectedPathPoint=NULL;
 ReDrawStageDisplay(TRUE);
 if(!IsWindow(ghwndDlgTools)){
   ghwndDlgTools=CreateDialog(ghinst_main,MAKEINTRESOURCE(DLG_PATHTOOL),
                              ghwnd_main,(DLGPROC)PathToolDlgProc);
   if(IsWindow(ghwndDlgTools))ShowWindow(ghwndDlgTools,SW_SHOW);
 }
}

void EditPathOff(short redraw){
 tool=NOTOOL;
 if(IsWindow(ghwndDlgTools)){
   DestroyWindow(ghwndDlgTools);
   ghwndDlgTools=NULL;
 }
 gToolFlags.flagP=0;
 if(SelectedPath != NULL)
    SelectedPath->pathlength=PathLength(
    SelectedPath->firstpathpoint,
    SelectedPath->pathtype,
    SelectedPath->npathpoints);
 SelectedPath=NULL;
 SelectedPathPoint=NULL;
 if(redraw)ReDrawStageDisplay(TRUE);
}


void AdjustPathTension(long window_id){
 pathpoint *pp;
 int x,y,xo,MickeyX,i,id;
 double d,dmin;
 POINT pt;
 long evTime;
 if(SelectedNode == NULL || SelectedPath == NULL ||
    (pp=SelectedPathPoint) == NULL)return;
 GetCursorPos(&pt); xo=pt.x;
 evTime=GetTickCount()+TIME_DELAY;
 do {
   if(evTime > GetTickCount())continue;
   GetCursorPos(&pt); y=pt.x;
   x = y-xo; xo=y;
   if(x != 0){
     if(x > 0)y=max( 1,min( 50,x));
     else     y=min(-1,max(-50,x));
     d=1.0+(double)y/95.0;
     DrawInvertNode(ghdc_triview_Bitmap,SelectedNode,EDITING);
     if((dmin=pp->tension_p * d) > 0.01 && dmin < 0.95)pp->tension_p=dmin;
     if((dmin=pp->tension_n * d) > 0.01 && dmin < 0.95)pp->tension_n=dmin;
     DrawInvertNode(ghdc_triview_Bitmap,SelectedNode,EDITING);
     if(View == ONEVIEW)UpdateWindow(ghwnd_current);
     else{
       for(i=0;i<3;i++)UpdateWindow(ghwnd_triview[i]);
     }
   }
   evTime=GetTickCount()+TIME_DELAY;
 }
 while(GetAsyncKeyState(VK_LBUTTON) & 0x8000);
 if(ghwndOpenGLview == NULL)PerspectiveView(View,1);
 else UpdateGLview(TRUE);
 return;
}

void EditPath(void){
 int i;
 if(gToolFlags.flagP == 3)return; /* tension    */
 if(gToolFlags.flagP != 0){       /* add/delete */
   DrawInvertNode(ghdc_triview_Bitmap,SelectedNode,EDITING);
   SelectedPath=NULL; SelectedPathPoint=NULL;
   DrawInvertNode(ghdc_triview_Bitmap,SelectedNode,EDITING);
   return;
 }
 if(SelectedNode == NULL || SelectedPath == NULL ||
    SelectedPathPoint == NULL)return;
 if((GrabonX != NpointerX)||(GrabonY != NpointerY)||(GrabonZ != NpointerZ)){
   DrawInvertNode(ghdc_triview_Bitmap,SelectedNode,EDITING);
   SelectedPathPoint->p[0] += NpointerX-GrabonX;
   SelectedPathPoint->p[1] += NpointerY-GrabonY;
   SelectedPathPoint->p[2] += NpointerZ-GrabonZ;
   DrawInvertNode(ghdc_triview_Bitmap,SelectedNode,EDITING);
   GrabonX=NpointerX;
   GrabonY=NpointerY;
   GrabonZ=NpointerZ;
   if(View == ONEVIEW)UpdateWindow(ghwnd_current);
   else{
     for(i=0;i<3;i++)UpdateWindow(ghwnd_triview[i]);
   }
 }
}

void AnimatorUndo(void){
 int id;
 if(tool == GRABBER && SelectedNode != NULL){
   DrawInvertNode(ghdc_triview_Bitmap,SelectedNode,SELECTED);
   NpointerX=lpxx;
   NpointerY=lpyy;
   NpointerZ=lpzz;
   GrabonX=NpointerX; GrabonY=NpointerY;  GrabonZ=NpointerZ;
   SetNewPosition(lpx,lpy,lpz,1);
   DrawInvertNode(ghdc_triview_Bitmap,SelectedNode,SELECTED);
   if(ghwndOpenGLview == NULL)PerspectiveView(0,1);
   else UpdateGLview(TRUE);
 }
 else if(tool == ROTATOR && SelectedNode != NULL){
   align *Ap;
   if((Ap=SelectedNode->fali) != NULL){
     while(Ap != NULL){
       if(CurrentFrame == Ap->lastframe){
         DrawInvertNode(ghdc_triview_Bitmap,SelectedNode,SELECTED);
         Ap->phi=lpp; Ap->theta=lpt; Ap->alpha=lpa;
         DrawInvertNode(ghdc_triview_Bitmap,SelectedNode,SELECTED);
         if(ghwndOpenGLview == NULL)PerspectiveView(0,1);
         else UpdateGLview(TRUE);
         break;
       }
       Ap=Ap->next;
     }
   }
 }
 else if(tool == SIZER && SelectedNode != NULL){
   size *Xp;
   if((Xp=SelectedNode->fsiz) != NULL){
     while(Xp != NULL){
       if(CurrentFrame == Xp->lastframe){
         DrawInvertNode(ghdc_triview_Bitmap,SelectedNode,SELECTED);
         Xp->Sx=lpt; Xp->Sy=lpp; Xp->Sz=lpa;
         DrawInvertNode(ghdc_triview_Bitmap,SelectedNode,SELECTED);
         if(ghwndOpenGLview == NULL)PerspectiveView(0,1);
         else UpdateGLview(TRUE);
         break;
       }
       Xp=Xp->next;
     }
   }
 }
}

static int PanX,PanY,ZoomX,ZoomY,ZoomRX,ZoomRY;
static BOOL ZoomInFlag=FALSE,PanMoveFlag=FALSE;
static HDC hDCzoom;

void PanToolUp(int x, int y, BOOL ctrl, BOOL shift, HWND hwnd){
 double zf=2.0;
 long a,b,c,d,e,f,stor;
 tool_down_flag=FALSE;
 tool_move_flag=FALSE;
 if(ZoomInFlag){
   Rectangle(hDCzoom,ZoomX,ZoomY,ZoomRX,ZoomRY);
   ReleaseDC(hwnd,hDCzoom);
   ZoomInFlag=FALSE;
   if(!ctrl)return;
   if(TVsizeX <= MINUNIT || TVsizeY <= MINUNIT || TVsizeZ <= MINUNIT){
     SendPrgmMessage(IDS_NOZOOMIN,1);
     MessageBeep(MB_OK);
     return;
   }
   if(ActiveView == TRITOP){
     stor=NpointerZ; NpointerZ=(TVpointZ+TVsizeZ/2);
   }
   else if(ActiveView == TRIFRONT){
     stor=NpointerY; NpointerY=(TVpointY+TVsizeY/2);
   }
   else{
     stor=NpointerX; NpointerX=(TVpointX+TVsizeX/2);
   }
   GetWorldCoords(ActiveView,&a,&b,&c,(ZoomX+ZoomRX)/2,(ZoomY+ZoomRY)/2);
   zf=(double)max(abs(ZoomX-ZoomRX),abs(ZoomY-ZoomRY))/
      (double)(max(WindowSizeX[ActiveView],WindowSizeY[ActiveView]));
   TVsizeX=(long)((double)TVsizeX*zf);
   TVsizeY=(long)((double)TVsizeY*zf);
   TVsizeZ=(long)((double)TVsizeZ*zf);
   WindowPixelSize=(double)TVsizeZ/(double)WindowSizeY[1];
   TVpointX=a-TVsizeX/2; TVcentreX=a;
   TVpointY=b-TVsizeY/2; TVcentreY=b;
   TVpointZ=c-TVsizeZ/2; TVcentreZ=c;
   if(ActiveView == TRITOP)NpointerZ=stor;
   else if(ActiveView == TRIFRONT)NpointerY=stor;
   else NpointerX=stor;
 }
 else if(ctrl){
   if(TVsizeX <= MINUNIT || TVsizeY <= MINUNIT || TVsizeZ <= MINUNIT){
     SendPrgmMessage(IDS_NOZOOMIN,1);
     MessageBeep(MB_OK);
   }
   else{
     if(ActiveView == TRITOP){
       stor=NpointerZ; NpointerZ=(TVpointZ+TVsizeZ/2);
     }
     else if(ActiveView == TRIFRONT){
       stor=NpointerY; NpointerY=(TVpointY+TVsizeY/2);
     }
     else{
       stor=NpointerX; NpointerX=(TVpointX+TVsizeX/2);
     }
     GetWorldCoords(ActiveView,&a,&b,&c,x,y);
     TVsizeX=(long)((double)TVsizeX/zf);
     TVsizeY=(long)((double)TVsizeY/zf);
     TVsizeZ=(long)((double)TVsizeZ/zf);
     WindowPixelSize=(double)TVsizeZ/(double)WindowSizeY[1];
     TVpointX=a-TVsizeX/2; TVcentreX=a;
     TVpointY=b-TVsizeY/2; TVcentreY=b;
     TVpointZ=c-TVsizeZ/2; TVcentreZ=c;
     if(ActiveView == TRITOP)NpointerZ=stor;
     else if(ActiveView == TRIFRONT)NpointerY=stor;
     else NpointerX=stor;
   }
 }
 else if(shift){
   if(TVsizeX >= MAXUNIT || TVsizeY >= MAXUNIT || TVsizeZ >= MAXUNIT){
     SendPrgmMessage(IDS_NOZOOMOUT,1);
     MessageBeep(MB_OK);
   }
   else{
     if(ActiveView == TRITOP){
       stor=NpointerZ; NpointerZ=(TVpointZ+TVsizeZ/2);
     }
     else if(ActiveView == TRIFRONT){
       stor=NpointerY; NpointerY=(TVpointY+TVsizeY/2);
     }
     else{
       stor=NpointerX; NpointerX=(TVpointX+TVsizeX/2);
     }
     GetWorldCoords(ActiveView,&a,&b,&c,x,y);
     TVsizeX=(long)((double)TVsizeX*zf);
     TVsizeY=(long)((double)TVsizeY*zf);
     TVsizeZ=(long)((double)TVsizeZ*zf);
     WindowPixelSize=(double)TVsizeZ/(double)WindowSizeY[1];
     TVpointX=a-TVsizeX/2; TVcentreX=a;
     TVpointY=b-TVsizeY/2; TVcentreY=b;
     TVpointZ=c-TVsizeZ/2; TVcentreZ=c;
     if(ActiveView == TRITOP)NpointerZ=stor;
     else if(ActiveView == TRIFRONT)NpointerY=stor;
     else NpointerX=stor;
   }
 }
 if(NpointerX < TVpointX)NpointerX=TVpointX+TVsizeX/2;
 if(NpointerX > TVpointX+TVsizeX)NpointerX=TVpointX+TVsizeX/2;
 if(NpointerY < TVpointY)NpointerY=TVpointY+TVsizeY/2;
 if(NpointerY > TVpointY+TVsizeY)NpointerY=TVpointY+TVsizeY/2;
 if(NpointerZ < TVpointZ)NpointerZ=TVpointZ+TVsizeZ/2;
 if(NpointerZ > TVpointZ+TVsizeZ)NpointerZ=TVpointZ+TVsizeZ/2;
 ReDrawStageDisplay(TRUE);
}

BOOL PanToolDown(int x, int y, BOOL ctrl, BOOL shift, HWND hwnd){
 PanX=x; PanY=y;
 ZoomInFlag=FALSE; PanMoveFlag=FALSE;
 ZoomX=x; ZoomY=y;
// if(shift) Patblt
 tool_down_flag=TRUE;
 tool_move_flag=FALSE;
 return TRUE;
}

void PanToolMove(int x, int y, BOOL ctrl, BOOL shift,HWND hwnd){
 unsigned int SaveDrawStatus;
 long a,b,c,d,e,f,gqd;
 tool_down_flag=TRUE;
 tool_move_flag=TRUE;
 if(ctrl || ZoomInFlag){
   if(!ZoomInFlag && (abs(x-ZoomX) > 2 || abs(y-ZoomY) > 2)){
     ZoomInFlag=TRUE;
     hDCzoom=GetDC(hwnd);
     SelectObject(hDCzoom,GetStockObject(NULL_BRUSH));
     SelectObject(hDCzoom,ghSelectedPen);
     SetROP2(hDCzoom,R2_XORPEN);
//     SelectPalette(hDCzoom,ghpaletteScreen,FALSE);
//     RealizePalette(hDCzoom);
     Rectangle(hDCzoom,ZoomX,ZoomY,ZoomRX,ZoomRY);
   }
   if(ZoomInFlag){
     Rectangle(hDCzoom,ZoomX,ZoomY,ZoomRX,ZoomRY);
     ZoomRX=x; ZoomRY=y;
     Rectangle(hDCzoom,ZoomX,ZoomY,ZoomRX,ZoomRY);
   }
   return;
 }
 else if(shift)return;
 PanMoveFlag=TRUE;
 GetWorldCoords(ActiveView,&a,&b,&c,PanX,PanY);
 GetWorldCoords(ActiveView,&d,&e,&f,x,y);
 TVpointX += (a-d);
 TVpointY += (b-e);
 TVpointZ += (c-f);
 TVcentreX += (a-d);
 TVcentreY += (b-e);
 TVcentreZ += (c-f);
 PanX=x; PanY=y;
 SaveDrawStatus=DrawStatus;
 gqd=global_quickdraw;
 global_quickdraw=1;
 if(DrawStatus == 0)ReDrawStageDisplay(TRUE);
 else               ReDrawQuickDisplay(TRUE);
 UpdateWindow(ghwnd_current);
 global_quickdraw=gqd;
 DrawStatus=SaveDrawStatus;
}

void ZoomView(int x, int y){
 BOOL bRedraw=FALSE;
 unsigned int SaveDrawStatus;
 int xo;
 POINT pt;
 long gqd,evTime;
 double zf,dx,dy,dz;
 tool_down_flag=TRUE;
 tool_move_flag=TRUE;
 GetCursorPos(&pt); xo=pt.x;
 evTime=GetTickCount()+TIME_DELAY;
 do {
   if(evTime > GetTickCount())continue;
   if(!(GetAsyncKeyState(VK_LBUTTON) & 0x8000))break;
   GetCursorPos(&pt); y=pt.x;
   if(y < 1){
    x= 0; SetCursorPos(pt.x+20,pt.y); xo=pt.x+20;
   }
   else if(y > Xres-2){
    x= 0; SetCursorPos(pt.x-20,pt.y); xo=pt.x-20;
   }
   else{
     x = y-xo; xo=y;
   }
   if(x != 0){
     dx=(double)(NpointerX-TVpointX)/(double)TVsizeX;
     dy=(double)(NpointerY-TVpointY)/(double)TVsizeY;
     dz=(double)(NpointerZ-TVpointZ)/(double)TVsizeZ;
     if(x > 0){
       zf = 1.2+(x-20.0)*(5.0-1.2)/(400-20);
       zf = max(zf,1.2);
       zf = min(zf,5.0);
     }
     else{
       x = -x;
       zf = 0.888-(x-20)*(0.888-0.2)/(400-20);
       zf = min(zf,0.83333);
       zf = max(zf,0.2);
     }
     if(zf < 1.0 &&
        (TVsizeX >= MAXUNIT || TVsizeY >= MAXUNIT || TVsizeZ >= MAXUNIT)){
       MessageBeep(MB_OK);
     }
     else{
       TVsizeX=(long)((double)TVsizeX/zf);
       TVsizeY=(long)((double)TVsizeY/zf);
       TVsizeZ=(long)((double)TVsizeZ/zf);
       WindowPixelSize=(double)TVsizeZ/(double)WindowSizeY[1];
       TVpointX=NpointerX-(long)(dx*(double)TVsizeX); TVcentreX=TVpointX+TVsizeX/2;
       TVpointY=NpointerY-(long)(dy*(double)TVsizeY); TVcentreY=TVpointY+TVsizeY/2;
       TVpointZ=NpointerZ-(long)(dz*(double)TVsizeZ); TVcentreZ=TVpointZ+TVsizeZ/2;
       SaveDrawStatus=DrawStatus;
       gqd=global_quickdraw;
       global_quickdraw=1;
       if(DrawStatus == 0)ReDrawStageDisplay(TRUE);
       else               ReDrawQuickDisplay(TRUE);
       UpdateWindow(ghwnd_current);
       global_quickdraw=gqd;
       DrawStatus=SaveDrawStatus;
       bRedraw=TRUE;
     }
   }
   evTime=GetTickCount()+TIME_DELAY;
   {MSG msg;
    if(PeekMessage(&msg, 0, 0, 0, PM_REMOVE)){
      TranslateMessage(&msg);
      DispatchMessage(&msg);
    }
   }
 }
 while(1);
 tool_down_flag=FALSE;
 tool_move_flag=FALSE;
 if(bRedraw)ReDrawStageDisplay(TRUE);
 return;
}

static short PanTo(long *start, long *centre, long increment){
 long newpoint;
 newpoint = *start + increment;
 if(newpoint > MAXUNIT || newpoint < -MAXUNIT){
   SendPrgmQuery(IDQ_PANTOOFAR,0);
   return 0;
 }
 *start = newpoint;
 *centre = *centre + increment;
 return 1;
}

void Zoom2(double fraction){
 long what_shift,cx,cy,cz;
 double zf;
 short f;
 zf= (1.0+(double)fraction / 5.0);
 if(TVsizeX <= MINUNIT || TVsizeY <= MINUNIT || TVsizeZ <= MINUNIT){
    SendPrgmQuery(IDQ_NOZOOMIN,0);
    return;
 }
  if(TVsizeX >= MAXUNIT || TVsizeY >= MAXUNIT || TVsizeZ >= MAXUNIT){
    SendPrgmQuery(IDQ_NOZOOMOUT,0);
    return;
 }
 cx=TVpointX+TVsizeX/2; cy=TVpointY+TVsizeY/2; cz=TVpointZ+TVsizeZ/2;
 TVsizeX=(long)((double)TVsizeX/zf);
 TVsizeY=(long)((double)TVsizeY/zf);
 TVsizeZ=(long)((double)TVsizeZ/zf);
 WindowPixelSize=(double)TVsizeZ/(double)WindowSizeY[1];
 TVpointX=cx-TVsizeX/2;
 TVpointY=cy-TVsizeY/2;
 TVpointZ=cz-TVsizeZ/2;
 if(NpointerX < TVpointX)        NpointerX=TVpointX;
 if(NpointerX > TVpointX+TVsizeX)NpointerX=TVpointX+TVsizeX;
 if(NpointerY < TVpointY)        NpointerY=TVpointY;
 if(NpointerY > TVpointY+TVsizeY)NpointerY=TVpointY+TVsizeY;
 if(NpointerZ < TVpointZ)        NpointerZ=TVpointZ;
 if(NpointerZ > TVpointZ+TVsizeZ)NpointerZ=TVpointZ+TVsizeZ;
 ReDrawStageDisplay(TRUE);
}

void Zoom(int command, int redraw){
 long what_shift,cx,cy,cz;
 double zf;
 short f;
 if(command == ZOOMIN || command == ZOOMOUT){
   zf=1.2;
   if(GetAsyncKeyState(VK_SHIFT  ) & 0x8000)zf=1.5;
   if(GetAsyncKeyState(VK_CONTROL) & 0x8000)zf=2.0;
   if(GetAsyncKeyState(VK_MENU   ) & 0x8000)zf=4.0;
 }
 else{
   what_shift=TVsizeX/16;
   if(GetAsyncKeyState(VK_SHIFT  ) & 0x8000)what_shift=TVsizeX/2;
   if(GetAsyncKeyState(VK_CONTROL) & 0x8000)what_shift=TVsizeX;
   if(GetAsyncKeyState(VK_MENU   ) & 0x8000)what_shift=TVsizeX*1.5;
 }
 if(command == ZOOMIN){
  if(TVsizeX <= MINUNIT || TVsizeY <= MINUNIT || TVsizeZ <= MINUNIT){
    SendPrgmQuery(IDQ_NOZOOMIN,0);
    goto EXIT;
  }
  cx=TVpointX+TVsizeX/2; cy=TVpointY+TVsizeY/2; cz=TVpointZ+TVsizeZ/2;
  TVsizeX=(long)((double)TVsizeX/zf);
  TVsizeY=(long)((double)TVsizeY/zf);
  TVsizeZ=(long)((double)TVsizeZ/zf);
  WindowPixelSize=(double)TVsizeZ/(double)WindowSizeY[1];
  TVpointX=cx-TVsizeX/2;
  TVpointY=cy-TVsizeY/2;
  TVpointZ=cz-TVsizeZ/2;
 }
 else if(command == ZOOMOUT){
  if(TVsizeX >= MAXUNIT || TVsizeY >= MAXUNIT || TVsizeZ >= MAXUNIT){
    SendPrgmQuery(IDQ_NOZOOMOUT,0);
    goto EXIT;
  }
  cx=TVpointX+TVsizeX/2; cy=TVpointY+TVsizeY/2; cz=TVpointZ+TVsizeZ/2;
  TVsizeX=(long)((double)TVsizeX*zf);
  TVsizeY=(long)((double)TVsizeY*zf);
  TVsizeZ=(long)((double)TVsizeZ*zf);
  WindowPixelSize=(double)TVsizeZ/(double)WindowSizeY[1];
  TVpointX=cx-TVsizeX/2;
  TVpointY=cy-TVsizeY/2;
  TVpointZ=cz-TVsizeZ/2;
 }
 else if(command == RECENTRE){
  if(TVsizeX >= MAXUNIT || TVsizeY >= MAXUNIT || TVsizeZ >= MAXUNIT){
    goto EXIT;
  }
  TVpointX=NpointerX-TVsizeX/2; TVcentreX=NpointerX;
  TVpointY=NpointerY-TVsizeY/2; TVcentreY=NpointerY;
  TVpointZ=NpointerZ-TVsizeZ/2; TVcentreZ=NpointerZ;
 }
 else if(command == CENTREWORLD){
   point TVC,TVP,TVclipMin,TVclipMax;
   get_centre_stage(TVC,TVP,TVclipMin,TVclipMax);
   TVsizeX = 2*(TVC[0]-TVP[0]);
   TVsizeY = 2*(TVC[1]-TVP[1]);
   TVsizeZ = 2*(TVC[2]-TVP[2]);
   TVpointX=TVP[0]-TVsizeX/10;
   TVpointY=TVP[1]-TVsizeY/10;
   TVpointZ=TVP[2]-TVsizeZ/10;
   TVsizeX += TVsizeX/5; TVsizeY += TVsizeY/5; TVsizeZ += TVsizeZ/5;
   TVcentreX=NpointerX=TVC[0];
   TVcentreY=NpointerY=TVC[1];
   TVcentreZ=NpointerZ=TVC[2];
   GetTriview(FALSE);
 }
 else { /* pan commands */
   if(WindowBox_view == 1){
    if(command == PANFORWARD ||
       command == PANBACK    ||
       command == PANRIGHT   ||
       command == PANLEFT)what_shift *= -1.0;
   }
   if(command == PANFORWARD){if(!PanTo(&TVpointY,&TVcentreY,+what_shift))goto EXIT;} /* forward   */
   if(command == PANBACK   ){if(!PanTo(&TVpointY,&TVcentreY,-what_shift))goto EXIT;} /* backwards */
   if(command == PANRIGHT  ){if(!PanTo(&TVpointX,&TVcentreX,+what_shift))goto EXIT;} /* right     */
   if(command == PANLEFT   ){if(!PanTo(&TVpointX,&TVcentreX,-what_shift))goto EXIT;} /* left      */
   if(command == PANUP     ){if(!PanTo(&TVpointZ,&TVcentreZ,+what_shift))goto EXIT;} /* up        */
   if(command == PANDOWN   ){if(!PanTo(&TVpointZ,&TVcentreZ,-what_shift))goto EXIT;} /* down      */
 }
 if(NpointerX < TVpointX)        NpointerX=TVpointX;
 if(NpointerX > TVpointX+TVsizeX)NpointerX=TVpointX+TVsizeX;
 if(NpointerY < TVpointY)        NpointerY=TVpointY;
 if(NpointerY > TVpointY+TVsizeY)NpointerY=TVpointY+TVsizeY;
 if(NpointerZ < TVpointZ)        NpointerZ=TVpointZ;
 if(NpointerZ > TVpointZ+TVsizeZ)NpointerZ=TVpointZ+TVsizeZ;
 if(redraw)ReDrawStageDisplay(TRUE);
 EXIT:;
}