TOOLS1.C

Go to the documentation of this file.

/* --
OpenFX - Modelling, Animation and Rendering Package
-- */


/* file TOOLS1.C  first designer tools file */

#define MODULE_TOOLS1 1

#include "design.h"

#define TIME_DELAY 30

typedef struct XTRAEDGE {
 int  ep;
 int  nc;
} xtraedge;

typedef struct VERTEXVERTEXEDGE {
 int  vs,vd;
} vertexvertexedge;

long PrimitiveType = 0;

long LastToolVertex = -1;  /* used in mlibs.c */

static void PullMagnet(void);
static void Edge3d(void);
static void Plot3d(void);
static void Grab(void);
static void Shape(void);
static void ShapeShape(int id);
static void FormerDown(void);
static void FormerUp(void);
static void FormerMove(void);
static void ShearerDown(void);
static void ShearerUp(void);
static void ShearerMove(int x, int y);
static void Ixpand(void);
static void Irotate(void);
static void Casteljau(point p, long *Vc, long i, long j, double mu);
static int GetGrabberBoundingBox(int flag);
static void DrawIrotateBoundBox(int i, double theta);
static void RotatePointAbout(long x, long y, long X, long Y, long *tx,
                             long *ty, double ctheta, double stheta);

static int  x_down,y_down;
static BOOL PrimitiveActive=FALSE,Mxpand=FALSE,IxpandFlag=FALSE,
            JxpandFlag=FALSE,bFlagNotool=FALSE,bFlagMoved=FALSE,
            bFlagNurbs=FALSE;
static long VertexCount1[50],VertexCount2[50];
static long GrabonX,GrabonY,GrabonZ,GrabDx,GrabDy,GrabDz,
            grab_xmin,grab_ymin,grab_zmin,
            grab_xmax,grab_ymax,grab_zmax;
static double RotatorTheta=0.0;
static double shaper_angle_phi=0.0,shaper_angle_theta=0.0,shaper_size=6;
static point *shaper_list=NULL;
static BOOL  bShaperMoved=FALSE;
static unsigned char PrimitiveFaceColour[3]={164,164,164};

static void Casteljau(point p, long *Vc, long i, long j, double mu){
  vertex *va,*va1;
  point p1,p2;
  if(j == 1){
    va=(MainVp+(*(Vc+i))); va1=(MainVp+(*(Vc+i+1)));
    p[0] = (long)((1.0 - mu)*(double)(va->xyz[0])
                 + mu*(double)(va1->xyz[0]));
    p[1] = (long)((1.0 - mu)*(double)(va->xyz[1])
                 + mu*(double)(va1->xyz[1]));
    p[2] = (long)((1.0 - mu)*(double)(va->xyz[2])
                 + mu*(double)(va1->xyz[2]));
  }
  else{
    Casteljau(p1,Vc,i,j-1,mu);
    Casteljau(p2,Vc,i+1,j-1,mu);
    p[0]=(long)((1.0 - mu)*(double)p1[0] + mu*(double)p2[0]);
    p[1]=(long)((1.0 - mu)*(double)p1[1] + mu*(double)p2[1]);
    p[2]=(long)((1.0 - mu)*(double)p1[2] + mu*(double)p2[2]);
  }
}

void RecalibrateBezier(int id){
 long i,N,Npath;
 double mu;
 point p;
 N=Bcurves[id].Np-1;
 Npath=Bcurves[id].Nc;
 for(i=1;i<N;i++){
   mu=(double)i/(double)N;
   Casteljau(p,Bcurves[id].Vc,0,Npath-1,mu);
   (MainVp+Bcurves[id].Vp[i])->xyz[0]=p[0];
   (MainVp+Bcurves[id].Vp[i])->xyz[1]=p[1];
   (MainVp+Bcurves[id].Vp[i])->xyz[2]=p[2];
 }
}

void RecalibrateAllBezier(void){
 int i;
 if(N_Bcurves == 0)return;
 for(i=0;i<N_Bcurves;i++)RecalibrateBezier(i);
}

void MakeBezierCurve(void){
 HCURSOR hSave;
 vertex *Vp;
 long vp,vf,*va;
 long Npath,i,N;
 double mu;
 point p;
 bezier_curve *bc;
 if(NvertSelect<4)return;
 if((vf=get_closest_vertex()) < 0)return;
 N=RequestNumEntry(10,3,100,"No. of Edges"," Edges");
 if(N < 4)return;
 hSave=SetCursor(ghcurWait);
 /* found first vertex of path */
 /* find path connected to vf and store in array va[] */
 if((va=(long *)X__Malloc(NvertSelect*sizeof(long))) == NULL){
   SetCursor(hSave);
   SendPrgmQuery(IDQ_NOMEM2,0);
   return;
 }
 Save_Undo(0);
 Npath=0; va[0]=vf; (MainVp+va[0])->id=1;  i=NvertSelect-1;
 vp=0; while(vp < Nvert){
   Vp=(MainVp+vp);
   if(Vp->status == SELECTED && Vp->id == 0 && connected(va[Npath],vp)){
     Npath++;    /* add the point to the path list */
     va[Npath]=vp;
     Vp->id=1;   /* flag so not used again also indicates in path */
     i--;
     vp=0;  /* go back and look for the next connected vertex */
   }
   else vp++;
 }
 Npath++;       /* to make up to number of points */
 if(i != 0 || Npath > 9){
   SendPrgmQuery(IDQ_NOTSUITABLECURVE,0);
   goto EXIT;
 }
 if(Npath > 3){ /* at least 4 points needed */
   if(N_Bcurves == 0)bc=(bezier_curve *)X__Malloc(sizeof(bezier_curve));
   else bc=(bezier_curve *)X__Realloc(Bcurves,sizeof(bezier_curve)*(N_Bcurves+1));
   if(bc == NULL){
     SendPrgmQuery(IDQ_NOMEM2,0);
     goto EXIT;
   }
   Bcurves=bc; bc = &Bcurves[N_Bcurves];
   sprintf(bc->name,"C-%ld",N_Bcurves);
   if((bc->Vc = (long *)X__Malloc(Npath*sizeof(long))) == NULL){
     SendPrgmQuery(IDQ_NOMEM2,0);
     goto EXIT;
   }
   if((bc->Vp = (long *)X__Malloc((N+1)*sizeof(long))) == NULL){
     X__Free(bc->Vc);
     SendPrgmQuery(IDQ_NOMEM2,0);
     goto EXIT;
   }
   N_Bcurves++; bc->Nc=Npath; bc->Np=N+1;
   for(i=0;i<Npath;i++)bc->Vc[i] = va[i];
   if(!UpdateVertexHeap(Nvert+N-1)){
     SendPrgmQuery(IDQ_NOMEM2,0);
     goto EXIT;
   }
   if(!UpdateEdgeHeap(Nedge+N+1)){
     SendPrgmQuery(IDQ_NOMEM2,0);
     goto EXIT;
   }
   for(i=1;i<N;i++){
     mu=(double)i/(double)N;
     Casteljau(p,va,0,Npath-1,mu);
     CreateVertex();
     bc->Vp[i]=Nvert-1;
     if(i == 1)CreateEdge(va[0],Nvert-1);
     else      CreateEdge(Nvert-1,Nvert-2);
     Vp=(MainVp+Nvert-1);
     Vp->xyz[0]=p[0]; Vp->xyz[1]=p[1]; Vp->xyz[2]=p[2];
   }
   CreateEdge(Nvert-1,va[Npath-1]);
   bc->Vp[0]=va[0];
   bc->Vp[N]=va[Npath-1];
   RequestCharString(6,bc->name,"Curve ID",ghwnd_main);
 }
 EXIT:
 SetCursor(hSave);
 X__Free(va);
 DrawModel(); UpdateCounters();
 return;
}

int AddFace(void){
 vertex  *vp;
 long Nvs,vps0,vps1,vpn[3];     /* VertexCount max = 50 ?? */
 edge    *ep;
 int i,count1,count2,j,k,l,c;
 if( (NvertSelect < 2) || (NvertSelect > 3))return 0;
 Nvs=Nvert;
 vp=MainVp; i=0;
 for(vp=MainVp,c=0;c<Nvert;c++,vp++){
   if(vp->status == SELECTED){
     vpn[i++]=(long)c;
     if( i > NvertSelect)break;
   }
 }
 if(i == 2)i=1;  /* only one edge to add if 2 vertices only */
 else      i=3;  /* up to 3 edges to add if 3 vertices      */
 for(l=0;l<i;l++){
   if     (l == 0){vps0=vpn[0]; vps1=vpn[1];}
   else if(l == 1){vps0=vpn[1]; vps1=vpn[2];}
   else if(l == 2){vps0=vpn[2]; vps1=vpn[0];}
   ep=MainEp; count1=0; count2=0;
   for(c=0;c<Nedge;c++){
     if(ep->V[0] == vps0){VertexCount1[count1]=ep->V[1];count1++;}
     if(ep->V[1] == vps0){VertexCount1[count1]=ep->V[0];count1++;}
     if(ep->V[0] == vps1){VertexCount2[count2]=ep->V[1];count2++;}
     if(ep->V[1] == vps1){VertexCount2[count2]=ep->V[0];count2++;}
     ep++;
   }
   if((count1 > 0) && (count2 > 0)){
     for(j=0;j<count1;j++)for(k=0;k<count2;k++){
       if(VertexCount1[j] == VertexCount2[k]){
         if(!CheckFaceExists(vps0,vps1,VertexCount1[j],0)){
           UpdateFaceHeap(Nface+1);
           CreateFace(vps0,vps1,VertexCount1[j]);
         }
       }
     }
   }
   if(!CheckEdgeExists(vps0,vps1,0)){
     UpdateEdgeHeap(Nedge+1);
     CreateEdge(vps0,vps1);
     DrawOneEdgeOnly((MainVp+vps0),(MainVp+vps1));
   }
 }
 return 1;
}

void ToolDown(HWND hwnd, int av, int x, int y){
 bFlagMoved=FALSE;
 x_down=x; y_down=y;
 if(tool == NOTOOL || tool == NODETOOL){
   long Vid;
   if(SelectedBrush >= 0)GrabBrushPoint(x,y);
   else if(SelectedShader >= 0)GrabMaterialAxisPoint(x,y);
   else if(tool == NOTOOL){
     if(GetAsyncKeyState(VK_CONTROL) & 0x8000){;} /* do not select */
     else if((Vid=PickVertex()) >= 0){
       SelectConnectedTo(Vid);
       Empty_Undo();
     }
     else SelectNurbsPatch(av,x,y);
   }
   else if(tool == NODETOOL){
     bFlagNotool=FALSE;
     bFlagNurbs=FALSE;
     if((LastToolVertex=PickVertex()) >= 0){
       Empty_Undo();
       if((MainVp+LastToolVertex)->status == SELECTED)bFlagNotool=TRUE;
     }
     else if(GetAsyncKeyState(VK_LBUTTON) & 0x8000){
       if(SelectNurbsControlPoint(av,x,y)){
         bFlagNurbs=TRUE;
         bFlagNotool=TRUE;
         MoveNurbsControlPoint(av,x,y,1);
       }
       else if(GetAsyncKeyState(VK_LBUTTON) & 0x8000){
         if(GetAsyncKeyState(VK_MENU) & 0x8000)tool=DESELECTOR;
         else                                  tool=SELECTOR;
         bFlagNotool=TRUE;
         SelectorDown(hwnd,av,x,y);
       }
     }
   }
 }
 else if(tool == SELECTOR || tool == DESELECTOR){
   SelectorDown(hwnd,av,x,y);
 }
 else if(tool == GRABBER){
   GrabOn();
   DrawRubberBoundBox(grab_xmin,grab_ymin,grab_zmin,
                      grab_xmax,grab_ymax,grab_zmax);
   MoveNurbsSurface(av,x,y,1);
 }
 else if(tool == EXPANDER || tool == ROTATOR){
   IxpandFlag=FALSE;
 }
 else if(tool == PLOT3D || tool == BUILDER){
   point p;
   if(LastToolVertex >= 0){
     p[0]=GrabDx=NpointerX; p[1]=GrabDy=NpointerY; p[2]=GrabDz=NpointerZ;
     DrawRubber3dLine((MainVp+LastToolVertex)->xyz,p);
   }
 }
 else if(tool == PLOTTER){
   point p;
   if(GetAsyncKeyState(VK_MENU) & 0x8000){LastToolVertex = -1;}
   if(LastToolVertex >= 0){
     p[0]=GrabDx=NpointerX; p[1]=GrabDy=NpointerY; p[2]=GrabDz=NpointerZ;
     DrawRubber3dLine((MainVp+LastToolVertex)->xyz,p);
   }
   else if(!(GetAsyncKeyState(VK_CONTROL) & 0x8000))ToolAction(x,y);
 }
 else if(tool == SHAPER){
   GrabonX=NpointerX; GrabonY=NpointerY; GrabonZ=NpointerZ;
   DrawShaperSphere(GrabonX,GrabonY,GrabonZ,
                    shaper_angle_theta,shaper_angle_phi,shaper_size);
   FormerDown();
 }
 else if(tool == MAGNETTO){
   GrabonX=NpointerX; GrabonY=NpointerY; GrabonZ=NpointerZ;
   ShearerDown();
 }
 else if(tool == PRIMS){
   GrabDx=grab_xmin=grab_xmax=NpointerX;
   GrabDy=grab_ymin=grab_ymax=NpointerY;
   GrabDz=grab_zmin=grab_zmax=NpointerZ;
   SendMessage(ghwndDlgPrimitives,WM_INTERROGATE,0,0);
   PrimitiveActive=FALSE;
 }
 else if(sktool == YES)SkToolDown(x,y);
}

void ToolUp(HWND hwnd, int av, int x, int y){
 if(tool == NOTOOL || tool == NODETOOL){
   if(SelectedBrush >= 0)UnGrabBrushPoint();
   else if(SelectedShader >= 0)UnGrabMaterialAxisPoint();
   else if(tool == NODETOOL && bFlagNurbs){
     bFlagNotool=FALSE; bFlagNurbs=FALSE;
     MoveNurbsControlPoint(av,x,y,-1);
     DrawModel();
   }
   else if(tool == NODETOOL && LastToolVertex >= 0){
     if(bFlagNotool && bFlagMoved){
       DrawRubberLines(hwnd,av,-2,x,y);
       DrawModel();
     }
     else { /* change select status */
       vertex *vf;
       vf=(MainVp+LastToolVertex);
       if(vf->status==SELECTED){
         NvertSelect--; NvertDeselect++; vf->status=DESELECTED;
       }
       else{
         NvertSelect++; NvertDeselect--; vf->status=SELECTED;
       }
       DrawVerticesOnly(vf); UpdateCounters();
     }
     bFlagNotool=FALSE; LastToolVertex= -1;
   }
 }
 else if(tool == SELECTOR || tool == DESELECTOR){
   SelectorUp(hwnd,av,x,y,bFlagMoved,bFlagNotool);
   if(bFlagNotool){
     tool=NODETOOL; bFlagNotool=FALSE;
   }
 }
 else if(tool == GRABBER){
   MoveNurbsSurface(av,x,y,-1);
   Grab();
 }
 else if(tool == PLOT3D || tool == BUILDER){
   point p;
   if(LastToolVertex >= 0){
     p[0]=GrabDx=NpointerX; p[1]=GrabDy=NpointerY; p[2]=GrabDz=NpointerZ;
     DrawRubber3dLine((MainVp+LastToolVertex)->xyz,p);
   }
 }
 else if(tool == PLOTTER){
   point p;
   if(LastToolVertex >= 0){
     vertex *vf;
     int ix,jy;
     vf=(MainVp+LastToolVertex);
     p[0]=GrabDx=NpointerX; p[1]=GrabDy=NpointerY; p[2]=GrabDz=NpointerZ;
     DrawRubber3dLine(vf->xyz,p);
     GetWindowCoords(ActiveView,vf->xyz[0],vf->xyz[1],vf->xyz[2],&ix,&jy);
     if(GetAsyncKeyState(VK_CONTROL) & 0x8000){;}
     else if(abs(x-ix) >2 || abs(y-jy) > 2)ToolAction(x,y);
   }
 }
 else if(tool == PRIMS){
   if(PrimitiveActive){
     PrimitiveActive=FALSE;
     DrawRubberBoundBox(grab_xmin,grab_ymin,grab_zmin,
                        grab_xmax,grab_ymax,grab_zmax);
     UpdatePrimitiveStructure(PrimitiveType,ActiveView,
                              grab_xmin,grab_ymin,grab_zmin,
                              grab_xmax,grab_ymax,grab_zmax,
                              GrabDx,GrabDy,GrabDz);
     if(IsWindow(ghwndDlgPrimitives)){
       SendMessage(ghwndDlgPrimitives,WM_UPDATEPDIALOG,0,0);
       if(PrimStruct.auto_interactive)
         SendMessage(ghwndDlgPrimitives,WM_COMMAND,(WPARAM)IDOK,0);
     }
   }
 }
 else if(tool == EXPANDER || tool == ROTATOR){
   IxpandFlag=FALSE;
 }
 else if(tool == SHAPER){
   DrawShaperSphere(GrabonX,GrabonY,GrabonZ,
                    shaper_angle_theta,shaper_angle_phi,shaper_size);
   FormerUp();
 }
 else if(tool == MAGNETTO){
   ShearerUp();
 }
 else if(sktool == YES)SkToolUp(x,y);
 if(tool == EXPANDER || tool == ROTATOR || tool == GRABBER ||
    tool == NODETOOL){
   if(ghwndOpenGLview == NULL)Draw3dView(0,0);
   else PostMessage(ghwndOpenGLview,(WM_USER+2),0,0); // update
 }
 return;
}

void ToolMove(HWND hwnd, int av, int x, int y){
 point p;
 int flag=0;
 POINT pt;
 if(!bFlagMoved && abs(x-x_down) < 2 && abs(y-y_down) < 2)return;
 if(tool == NOTOOL || tool == NODETOOL){
   if(SelectedBrush >= 0)PullBrushPoint(x,y);
   else if(SelectedShader >= 0)PullShaderPoint(x,y);
   else if(tool == NODETOOL && bFlagNurbs){
     MoveNurbsControlPoint(av,x,y,0);
   }
   else if(tool == NODETOOL && LastToolVertex >= 0 && bFlagNotool){
     if(bFlagMoved)DrawRubberLines(hwnd,av,-1,x,y);
     else DrawRubberLines(hwnd,av,LastToolVertex,x,y);
   }
 }
 else if(tool == SELECTOR || tool == DESELECTOR){
   SelectorMove(hwnd,av,x,y);
 }
 else if(tool == GRABBER){
   DrawRubberBoundBox(grab_xmin,grab_ymin,grab_zmin,grab_xmax,grab_ymax,grab_zmax);
   grab_xmin += (NpointerX-GrabDx); grab_xmax += (NpointerX-GrabDx);
   grab_ymin += (NpointerY-GrabDy); grab_ymax += (NpointerY-GrabDy);
   grab_zmin += (NpointerZ-GrabDz); grab_zmax += (NpointerZ-GrabDz);
   GrabDx=NpointerX; GrabDy=NpointerY; GrabDz=NpointerZ;
   DrawRubberBoundBox(grab_xmin,grab_ymin,grab_zmin,grab_xmax,grab_ymax,grab_zmax);
   MoveNurbsSurface(av,x,y,0);
 }
 else if(tool == PLOTTER){
   Move3dCursor(0,x,y);
   if     (x > WindowSizeX[ActiveView] - 4){
     flag=1; SendMessage(ghwnd_main,WM_COMMAND,IDM_PAN_RIGHT1,ActiveView);
   }
   else if(x < 4){
     flag=1; SendMessage(ghwnd_main,WM_COMMAND,IDM_PAN_LEFT1,ActiveView);
   }
   else if(y < 4){
     flag=1; SendMessage(ghwnd_main,WM_COMMAND,IDM_PAN_UP1,ActiveView);
   }
   else if(y > WindowSizeY[ActiveView] - 4){
     flag=1; SendMessage(ghwnd_main,WM_COMMAND,IDM_PAN_DOWN1,ActiveView);
   }
   if(flag){
     GetWindowCoords(ActiveView,NpointerX,NpointerY,NpointerZ,&x,&y);
     pt.x=x; pt.y=y;
     ClientToScreen(ghwnd_current,&pt);
     SetCursorPos(pt.x,pt.y);
   }
   if(LastToolVertex >= 0){
     if(!flag){
       p[0]=GrabDx; p[1]=GrabDy; p[2]=GrabDz;
       DrawRubber3dLine((MainVp+LastToolVertex)->xyz,p);
     }
     p[0]=GrabDx=NpointerX; p[1]=GrabDy=NpointerY; p[2]=GrabDz=NpointerZ;
     DrawRubber3dLine((MainVp+LastToolVertex)->xyz,p);
   }
 }
 else if(tool == PLOT3D || tool == BUILDER){
   if(LastToolVertex >= 0){
     p[0]=GrabDx; p[1]=GrabDy; p[2]=GrabDz;
     DrawRubber3dLine((MainVp+LastToolVertex)->xyz,p);
     p[0]=GrabDx=NpointerX; p[1]=GrabDy=NpointerY; p[2]=GrabDz=NpointerZ;
     DrawRubber3dLine((MainVp+LastToolVertex)->xyz,p);
   }
 }
 else if(tool == PRIMS){
   long d,dx,dy,dz;
   if(PrimitiveActive){
     DrawRubberBoundBox(grab_xmin,grab_ymin,grab_zmin,
                        grab_xmax,grab_ymax,grab_zmax);
   }
   else PrimitiveActive=TRUE;
   if(ActiveView == TRITOP)
     d=max(labs(GrabDx-NpointerX),labs(GrabDy-NpointerY));
   if(ActiveView == TRIFRONT)
     d=max(labs(GrabDx-NpointerX),labs(GrabDz-NpointerZ));
   if(ActiveView == TRIRIGHT)
     d=max(labs(GrabDy-NpointerY),labs(GrabDz-NpointerZ));
   if(PrimitiveType == 0){
     if     (ActiveView == TRITOP){
       dx=NpointerX-GrabDx; dy=NpointerY-GrabDy; dz=0;
     }
     else if(ActiveView == TRIFRONT){
       dx=NpointerX-GrabDx; dy=0; dz=NpointerZ-GrabDz;
     }
     else{
       dx=0; dy=NpointerY-GrabDy; dz=NpointerZ-GrabDz;
     }
     grab_xmin=GrabDx; grab_xmax=GrabDx+dx;
     grab_ymin=GrabDy; grab_ymax=GrabDy+dy;
     grab_zmin=GrabDz; grab_zmax=GrabDz+dz;
   }
   else{
     dx=dy=dz=d;
     if(PrimitiveType == 2 || PrimitiveType == 4){
       if     (ActiveView == TRITOP)dz=0;
       else if(ActiveView == TRIFRONT)dy=0;
       else dx=0;
     }
     else if(PrimitiveType != 7 && PrimitiveType != 8 && PrimitiveType != 9){
       if(GetAsyncKeyState(VK_CONTROL) & 0x8000){
         if     (ActiveView == TRITOP)dz=GrabDz-grab_zmin;
         else if(ActiveView == TRIFRONT)dy=GrabDy-grab_ymin;
         else dx=GrabDx-grab_xmin;
       }
     }
     grab_xmin=GrabDx-dx; grab_xmax=GrabDx+dx;
     grab_ymin=GrabDy-dy; grab_ymax=GrabDy+dy;
     grab_zmin=GrabDz-dz; grab_zmax=GrabDz+dz;
   }
   DrawRubberBoundBox(grab_xmin,grab_ymin,grab_zmin,
                      grab_xmax,grab_ymax,grab_zmax);
 }
 else if(tool == EXPANDER || tool == ROTATOR){
   RotatorTheta=0.0;
   if(!IxpandFlag){
     IxpandFlag=TRUE;
     if(GetGrabberBoundingBox(0) == 0){
       grab_xmin=grab_xmax=NpointerX;
       grab_ymin=grab_ymax=NpointerY;
       grab_zmin=grab_zmax=NpointerZ;
     }
     if(tool == ROTATOR){
       DrawIrotateBoundBox(ActiveView,RotatorTheta);
       RotateNurbsSurface(av,1,0.0);
     }
     else{
       DrawRubberBoundBox(grab_xmin,grab_ymin,grab_zmin,
                          grab_xmax,grab_ymax,grab_zmax);
       XpandNurbsSurface(av,1,0.0,0.0,0.0);
     }
     if(tool == EXPANDER)Ixpand();
     else                Irotate();
   }
 }
 else if(tool == SHAPER){
   if     (GetAsyncKeyState(VK_CONTROL) & 0x8000)ShapeShape(0);
//   else if(GetAsyncKeyState(VK_SHIFT)   & 0x8000)ShapeShape(1);  // SHAPER
//   else if(GetAsyncKeyState(VK_MENU)    & 0x8000)ShapeShape(2);  // SHAPER
   else{
     Move3dCursor(0,x,y);
     DrawShaperSphere(GrabonX,GrabonY,GrabonZ,
                      shaper_angle_theta,shaper_angle_phi,shaper_size);
//     GrabonX=NpointerX; GrabonY=NpointerY; GrabonZ=NpointerZ;    // SHAPER
     FormerMove();
     DrawShaperSphere(GrabonX,GrabonY,GrabonZ,
                    shaper_angle_theta,shaper_angle_phi,shaper_size);
   }
 }
 else if(tool == MAGNETTO){
   ShearerMove(x,y);
 }
 else if(sktool == YES)SkToolMove(x,y);
 bFlagMoved=TRUE;
 return;
}

void ToolAction(int x, int y){
 if     (tool == PLOT3D)Plot3d();
 else if(tool == PLOTTER)Plot3d();
 else if(tool == BUILDER)Edge3d();
// else if(tool == MAGNETTO)PullMagnet();
// else if(tool == SHAPER)Shape();
 else if(sktool == YES){;} //SkToolAction(x,y);
 return;
}

static int GetGrabberBoundingBox(int flag){
 int i;
 vertex *vp;
 grab_xmin=grab_ymin=grab_zmin =  MAXUNIT;
 grab_xmax=grab_ymax=grab_zmax = -MAXUNIT;
 if((vp=MainVp) != NULL)for(i=0;i<Nvert;i++){
   if(vp->status == SELECTED){
     if(vp->xyz[0] > grab_xmax)grab_xmax=vp->xyz[0];
     if(vp->xyz[0] < grab_xmin)grab_xmin=vp->xyz[0];
     if(vp->xyz[1] > grab_ymax)grab_ymax=vp->xyz[1];
     if(vp->xyz[1] < grab_ymin)grab_ymin=vp->xyz[1];
     if(vp->xyz[2] > grab_zmax)grab_zmax=vp->xyz[2];
     if(vp->xyz[2] < grab_zmin)grab_zmin=vp->xyz[2];
     flag=1;
   }
   vp++;
 }
 return flag;
}

void GrabOn(void){
 int flag=0;
 GrabonX=NpointerX; GrabonY=NpointerY; GrabonZ=NpointerZ;
 GrabDx=NpointerX;  GrabDy=NpointerY;  GrabDz=NpointerZ;
 flag=GetGrabberBoundingBox(flag);
 if(flag == 0){
   grab_xmin=grab_xmax=NpointerX;
   grab_ymin=grab_ymax=NpointerY;
   grab_zmin=grab_zmax=NpointerZ;
 }
}

static void Grab(void){
 vertex *vp;
 long i,dx,dy,dz;
 dx=NpointerX-GrabonX; dy=NpointerY-GrabonY; dz=NpointerZ-GrabonZ;
 vp=MainVp; for(i=0;i<Nvert;i++){
   if(vp->status == SELECTED){
     vp->xyz[0] += dx;
     vp->xyz[1] += dy;
     vp->xyz[2] += dz;
   }
   vp++;
 }
 GrabDx=GrabonX=NpointerX;
 GrabDy=GrabonY=NpointerY;
 GrabDz=GrabonZ=NpointerZ;
 RecalibrateAllBezier(); RecalibrateMapLocks();
 do_NOT_abort=TRUE;
 DrawModel();
 if(ghwndOpenGLview != NULL)PostMessage(ghwndOpenGLview,(WM_USER+2),0,0);
 do_NOT_abort=FALSE;
}

BOOL PrimitiveOn(void){
 int i;
 PrimitiveActive=FALSE;
 PrimStruct.auto_interactive=TRUE;
 PrimStruct.nsides=12;
 PrimStruct.nsteps=1;
 PrimStruct.smooth=1;
 PrimStruct.faces=320;
 PrimStruct.nvert=9;
 PrimStruct.nhorz=16;
 PrimStruct.torus_ratio=0.5;
 for(i=0;i<3;i++)PrimStruct.fc[i]=PrimitiveFaceColour[i];
 PrimitiveType=0;
 UpdatePrimitiveStructure(0,ActiveView,
                          TVcentreX-TVsizeX/2,
                          TVcentreY-TVsizeY/2,
                          TVcentreZ-TVsizeZ/2,
                          TVcentreX+TVsizeX/2,
                          TVcentreY+TVsizeY/2,
                          TVcentreZ+TVsizeZ/2,
                          TVcentreX,TVcentreY,TVcentreZ);
 ghwndDlgPrimitives=CreateDialog(ghinst_main,MAKEINTRESOURCE(DLG_TAB_PRIMES),
                                 ghwnd_main,(DLGPROC)PrimitivesDlgProc);
 return TRUE;
}

void PrimitiveOff(void){
 int i;
 PrimitiveActive=FALSE;
 for(i=0;i<3;i++)PrimitiveFaceColour[i]=PrimStruct.fc[i];
 if(IsWindow(ghwndDlgPrimitives))DestroyWindow(ghwndDlgPrimitives);
 ghwndDlgPrimitives=NULL;
}

void Plot3dOn(void){ /* for PLOT3D and BUILDER */
 LastToolVertex = -1;
}

void Plot3dOff(void){  /* for PLOT3D AND PLOTTER and BUILDER */
  LastToolVertex = -1;
}

void IxpandOn(void){
  Mxpand=FALSE;
  IxpandFlag=FALSE;
  GrabonX=NpointerX; GrabonY=NpointerY; GrabonZ=NpointerZ;
}

void IrotateOn(void){
  Mxpand=FALSE;
  IxpandFlag=FALSE;
  RotatorTheta=0.0;
  GrabonX=NpointerX; GrabonY=NpointerY; GrabonZ=NpointerZ;
}

static void Plot3d(void){ /* just make curve if ctrl key down */
 int vp,vps[3];
 edge *Ep;
 int ep;
 int count1,count2,j,k;
 point p;
 p[0]=GrabDx; p[1]=GrabDy; p[2]=GrabDz;
 if(LastToolVertex >= 0)DrawRubber3dLine((MainVp+LastToolVertex)->xyz,p);
 if( !(GetAsyncKeyState(VK_CONTROL) & 0x8000) && (vp=PickVertex()) >= 0
    && (MainVp+vp)->status == SELECTED){
   if(LastToolVertex >= 0 && LastToolVertex != vp){
     vps[0]=vp;
     vps[1]=LastToolVertex;
     count1=0; count2=0;
     ep=0; while(ep < Nedge){
       Ep=(MainEp+ep);
       if(Ep->V[0] == vps[0]){VertexCount1[count1]=Ep->V[1]; count1++;}
       if(Ep->V[1] == vps[0]){VertexCount1[count1]=Ep->V[0]; count1++;}
       if(Ep->V[0] == vps[1]){VertexCount2[count2]=Ep->V[1]; count2++;}
       if(Ep->V[1] == vps[1]){VertexCount2[count2]=Ep->V[0]; count2++;}
       ep++;
     }
     if((count1 > 0) && (count2 > 0)){
       for(j=0;j<count1;j++)for(k=0;k<count2;k++){
          if(VertexCount1[j] == VertexCount2[k]){
            if(!CheckFaceExists(vps[0],vps[1],VertexCount1[j],0)){
               UpdateFaceHeap(Nface+1);
               CreateFace(vps[0],vps[1],VertexCount1[j]);
            }
          }
       }
     }
     if(!CheckEdgeExists(vps[0],vps[1],0)){
       UpdateEdgeHeap(Nedge+1);
       CreateEdge(vps[0],vps[1]);
       DrawOneEdgeOnly((MainVp+vps[0]),(MainVp+vps[1]));
     }
     LastToolVertex=-1;
   }
   else LastToolVertex=vp;
 }
 else{
   UpdateVertexHeap(Nvert+1);
   CreateVertex();
   if(LastToolVertex >= 0){
     UpdateEdgeHeap(Nedge+1);
     CreateEdge(LastToolVertex,Nvert-1);
     DrawOneEdgeOnly((MainVp+LastToolVertex),(MainVp+Nvert-1));
   }
   else DrawVerticesOnly((MainVp+Nvert-1));
   LastToolVertex=Nvert-1;
 }
 p[0]=GrabDx=NpointerX; p[1]=GrabDy=NpointerY; p[2]=GrabDz=NpointerZ;
 if(LastToolVertex >= 0)DrawRubber3dLine((MainVp+LastToolVertex)->xyz,p);
 UpdateCounters();
}

static void Edge3d(void){
 int vp,vps[3];
 edge *Ep;
 int ep;
 int count1,count2,j,k;
 point p;
 p[0]=GrabDx; p[1]=GrabDy; p[2]=GrabDz;
 if(LastToolVertex >= 0)DrawRubber3dLine((MainVp+LastToolVertex)->xyz,p);
 if((vp=PickVertex()) >= 0){
   if(LastToolVertex >= 0 && LastToolVertex != vp){
     vps[0]=vp;
     vps[1]=LastToolVertex;
     count1=0; count2=0;
     ep=0; while(ep < Nedge){
       Ep=(MainEp+ep);
       if(Ep->V[0] == vps[0]){VertexCount1[count1]=Ep->V[1]; count1++;}
       if(Ep->V[1] == vps[0]){VertexCount1[count1]=Ep->V[0]; count1++;}
       if(Ep->V[0] == vps[1]){VertexCount2[count2]=Ep->V[1]; count2++;}
       if(Ep->V[1] == vps[1]){VertexCount2[count2]=Ep->V[0]; count2++;}
       ep++;
     }
     if((count1 > 0) && (count2 > 0)){
       for(j=0;j<count1;j++)for(k=0;k<count2;k++){
          if(VertexCount1[j] == VertexCount2[k]){
            if(!CheckFaceExists(vps[0],vps[1],VertexCount1[j],0)){
              UpdateFaceHeap(Nface+1);
              CreateFace(vps[0],vps[1],VertexCount1[j]);
            }
          }
       }
     }
     if(!CheckEdgeExists(vps[0],vps[1],0)){
       UpdateEdgeHeap(Nedge+1);
       CreateEdge(vps[0],vps[1]);
       DrawOneEdgeOnly((MainVp+vps[0]),(MainVp+vps[1]));
     }
     LastToolVertex=-1;
   }
   else LastToolVertex=vp;
 }
 p[0]=GrabDx=NpointerX; p[1]=GrabDy=NpointerY; p[2]=GrabDz=NpointerZ;
 if(LastToolVertex >= 0)DrawRubber3dLine((MainVp+LastToolVertex)->xyz,p);
 UpdateCounters();
}

static void PullMagnet(void){
 long i;
 vertex *vp;
 double dmin,dmax,d,mu;
 dmin=(double)MAXUNIT * (double)MAXUNIT;
 dmax=0.0;
 if((vp=MainVp) != NULL)for(i=0;i<Nvert;i++){
   if(vp->status == SELECTED){
     d  = (double)(vp->xyz[0] - NpointerX)*(double)(vp->xyz[0] - NpointerX)
        + (double)(vp->xyz[1] - NpointerY)*(double)(vp->xyz[1] - NpointerY)
        + (double)(vp->xyz[2] - NpointerZ)*(double)(vp->xyz[2] - NpointerZ);
     d=sqrt(d);
     if(d < dmin)dmin=d;
     if(d > dmax)dmax=d;
   }
   vp++;
 }
 if(dmin <1.e-5)return;
 if((vp=MainVp) != NULL)for(i=0;i<Nvert;i++){
   if(vp->status == SELECTED){
     d  = (double)(vp->xyz[0] - NpointerX)*(double)(vp->xyz[0] - NpointerX)
        + (double)(vp->xyz[1] - NpointerY)*(double)(vp->xyz[1] - NpointerY)
        + (double)(vp->xyz[2] - NpointerZ)*(double)(vp->xyz[2] - NpointerZ);
     d=sqrt(d);
     mu=1.0-(d-dmin)/(dmax-dmin);
     mu = mu*mu*mu;
     mu=mu/2;
     if(GetAsyncKeyState(VK_MENU) & 0x8000)mu *= -1.0; /* repel */
     vp->xyz[0]=(long)((double)vp->xyz[0]+(double)(NpointerX-vp->xyz[0])*mu);
     vp->xyz[1]=(long)((double)vp->xyz[1]+(double)(NpointerY-vp->xyz[1])*mu);
     vp->xyz[2]=(long)((double)vp->xyz[2]+(double)(NpointerZ-vp->xyz[2])*mu);
   }
   vp++;
 }
 DrawModel();
}

BOOL AddCopy(int wait){
 HCURSOR hSave;
 vertex *vp,*V0,*V1,*V2,*Vp;
 edge   *ep;
 face   *fp;
 long   i,Nvert1,Nedge1,Nface1;
 long x,y,z;
 if(NvertSelect == 0)return FALSE;
 if(NvertSelect > 32000){
   SendPrgmQuery(IDQ_WIRETOOBIG,0);
   return FALSE;
 }
 if(wait)hSave=SetCursor(ghcurWait);
 if(!UpdateVertexHeap(Nvert+NvertSelect))return FALSE;
 for(Nedge1=0,ep=MainEp,i=0;i<Nedge;i++){
   V0=(MainVp+ep->V[0]); V1=(MainVp+ep->V[1]);
   if(V0->status == SELECTED && V1->status == SELECTED)Nedge1++;
   ep++;
 }
 if(!UpdateEdgeHeap(Nedge+Nedge1))return FALSE;
 for(Nface1=0,fp=MainFp,i=0;i<Nface;i++){
   V0=(MainVp+fp->V[0]); V1=(MainVp+fp->V[1]); V2=(MainVp+fp->V[2]);
   if(V0->status == SELECTED &&
      V1->status == SELECTED &&
      V2->status == SELECTED)Nface1++;
   fp++;
 }
 if(!UpdateFaceHeap(Nface+Nface1))return FALSE;
 Nvert1=Nvert; Nedge1=Nedge; Nface1=Nface;
 vp=MainVp; for(i=0;i<Nvert1;i++){
   if(vp->status == SELECTED){
     CreateVertex();
     Vp=(MainVp+Nvert-1);
     Vp->xyz[0]=vp->xyz[0];
     Vp->xyz[1]=vp->xyz[1];
     Vp->xyz[2]=vp->xyz[2];
     Vp->gp=vp->gp;
     if(Vp->gp == 1){
       Vp->x=vp->x;
       Vp->y=vp->y;
     }
     Vp->status=DESELECTED;
     vp->id=Nvert-1;
     NvertSelect--; NvertDeselect++;
   }
   else{
     vp->id = -1;  /* needed by copy+flip+weld */
   }
   vp++;
 }
 if(Nedge > 0)for(ep=MainEp,i=0;i<Nedge1;i++){
   V0=(MainVp+ep->V[0]); V1=(MainVp+ep->V[1]);
   if(V0->status == SELECTED &&
      V1->status == SELECTED){
      CreateEdge(V0->id,V1->id);
   }
   ep++;
 }
 if(Nface > 0)for(fp=MainFp,i=0;i<Nface1;i++){
   V0=(MainVp+fp->V[0]); V1=(MainVp+fp->V[1]); V2=(MainVp+fp->V[2]);
   if(V0->status == SELECTED &&
      V1->status == SELECTED &&
      V2->status == SELECTED) {
     CreateFace(V0->id,V1->id,V2->id);
     CopyFaceProp(fp,(MainFp+Nface-1));
   }
   fp++;
 }
 vp=MainVp; for(i=0;i<Nvert1;i++){
   if(vp->status == SELECTED){
    vp->status=DESELECTED;
    (MainVp+vp->id)->status=SELECTED;
   }
   vp++;
 }
 if(wait) {
   SetCursor(hSave);
//   if((dos_key_shift() & 0x04) == 0x04){ /* ctrl */
//     if(Read3Reals("Offset by",&dx_copy,&dy_copy,&dz_copy,0,0) == 0)return FALSE;
//     x=(long)(dx_copy*ruler);
//     y=(long)(dy_copy*ruler);
//     z=(long)(dz_copy*ruler);
//     vp=MainVp; while (vp != NULL){
//       if(vp->status == SELECTED){
//         vp->xyz[0] += x; vp->xyz[1] += y; vp->xyz[2] += z;
//       }
//       vp=vp->last;
//     }
//     ReDrawDisplay();
//     return FALSE;
//   }
 }
 return TRUE;
}

BOOL CreateAttachedCopy(int open){
 /* open = 1 for Selected edges and faces; open = 2 for all attached faces */
 vertex *Vp,*vp,*vl,*vr,*v0,*v1,*v2;
 edge   *ep;
 face   *fp;
 int    ne,addit;
 long   i,j,uuecount=0,k,Nvert1=0,Nedge1=0,Nface1=0;
 xtraedge *xp;
 vertexvertexedge *vve=NULL;
 if(NvertSelect > 32000 || Nvert < 1){ return FALSE; }
 ne=0; if(Nedge > 0)for(j=0,ep=MainEp;j<Nedge;j++,ep++){
   v0=(MainVp+ep->V[0]); v1=(MainVp+ep->V[1]);
   if(v0->status == SELECTED && v1->status == SELECTED)ne++;
 }
 Nvert1=NvertSelect;
 Nedge1=ne;
 if(ne > 0){
   xp=(xtraedge *)
   X__Malloc(ne*sizeof(xtraedge));
   if(xp == NULL){
     SendPrgmQuery(IDQ_NOMEM2,0);
     return FALSE;
   }
   i=0; ep=MainEp; for(j=0;j<Nedge;j++,ep++){  /* selected edge */
     v0=(MainVp+ep->V[0]); v1=(MainVp+ep->V[1]);
     if(v0->status == SELECTED && v1->status == SELECTED){
       xp[i].ep = j; xp[i].nc=0; i++;
     }
   }
   if(i != ne){
     SendPrgmQuery(IDQ_EDGEINCONSISTANT,0);
     X__Free(xp);
     return FALSE;
   }
   for(i=0;i<ne;i++){
     vl=(MainVp+(MainEp+xp[i].ep)->V[0]);
     vr=(MainVp+(MainEp+xp[i].ep)->V[1]);
     fp=MainFp; if(Nface > 0)for(j=0;j<Nface;j++,fp++){
       v0=(MainVp+fp->V[0]); v1=(MainVp+fp->V[1]); v2=(MainVp+fp->V[2]);
       if(v0->status == SELECTED &&
          v1->status == SELECTED &&
          v2->status == SELECTED){
         if((vl == v0 && vr == v1) || (vl == v1 && vr == v0))xp[i].nc++;
         if((vl == v1 && vr == v2) || (vl == v2 && vr == v1))xp[i].nc++;
         if((vl == v2 && vr == v0) || (vl == v0 && vr == v2))xp[i].nc++;
       }
     }
   }
 }
 fp=MainFp; if(Nface > 0)for(i=0;i<Nface;i++,fp++){
   v0=(MainVp+fp->V[0]); v1=(MainVp+fp->V[1]); v2=(MainVp+fp->V[2]);
   if(v0->status == SELECTED &&
      v1->status == SELECTED &&
      v2->status == SELECTED)Nface1++;
 }
 if(open == 2 && Nedge > 0){ /* make a list of the vertices that are joined */
   uuecount=0;
   for(i=0,ep=MainEp;i<Nedge;i++){
     v0=(MainVp+ep->V[0]); v1=(MainVp+ep->V[1]);
     if((v0->status == DESELECTED && v1->status == SELECTED) ||
        (v1->status == DESELECTED && v0->status == SELECTED))
       uuecount++;
     ep++;
   }
   if((vve=(vertexvertexedge *)X__Malloc(uuecount*sizeof(vertexvertexedge)))
      == NULL){
     open=1; uuecount=0;
   }
   else{
     uuecount=0;
     for(i=0,ep=MainEp;i<Nedge;i++){
       v0=(MainVp+ep->V[0]); v1=(MainVp+ep->V[1]);
       if((v0->status == DESELECTED && v1->status == SELECTED) ||
          (v1->status == DESELECTED && v0->status == SELECTED)){
         if(v0->status == SELECTED){
           vve[uuecount].vs=ep->V[0];
           vve[uuecount].vd=ep->V[1];
         }
         else{
           vve[uuecount].vs=ep->V[1];
           vve[uuecount].vd=ep->V[0];
         }
         uuecount++;
       }
       ep++;
     }
   }
 }
 if(!UpdateVertexHeap(Nvert+Nvert1))return FALSE;
 if(!UpdateEdgeHeap(Nedge+Nvert1+Nedge1*2+uuecount))return FALSE;
 if(!UpdateFaceHeap(Nface+Nface1+Nedge1*2+uuecount))return FALSE;
 Nvert1=Nvert; Nedge1=Nedge; Nface1=Nface;
 vp=MainVp; for(j=0;j<Nvert1;j++){
   if(vp->status == SELECTED) {
     addit=0;
     if(ne > 0)for(i=0;i<ne;i++){
       if((
           (MainEp+xp[i].ep)->V[0] == j || (MainEp+xp[i].ep)->V[1] == j)
        && (xp[i].nc < 2))addit=1;
     }
     else addit=1;
     CreateVertex();
     Vp=(MainVp+Nvert-1);
     Vp->xyz[0]=vp->xyz[0];
     Vp->xyz[1]=vp->xyz[1];
     Vp->xyz[2]=vp->xyz[2];
     Vp->gp=vp->gp;
     if(Vp->gp == 1){
       Vp->x=vp->x;
       Vp->y=vp->y;
     }
     if(addit)CreateEdge(j,Nvert-1);
     Vp->status=DESELECTED;
     vp->id=Nvert-1;
     NvertSelect--;NvertDeselect++;
  }
  vp++;
 }
 i=0; if(Nedge > 0)for(ep=MainEp,j=0;j<Nedge1;j++){
   v0=(MainVp+ep->V[0]); v1=(MainVp+ep->V[1]);
   if(v0->status == SELECTED &&
      v1->status == SELECTED){
      CreateEdge(v0->id,v1->id);
      if(xp[i].nc < 2){
        CreateEdge(v0->id,ep->V[1]);
        CreateFace(v0->id,v1->id,ep->V[1]);
        CreateFace(v0->id,ep->V[1],ep->V[0]);
      }
      i++;
   }
   ep++;
 }
 if(Nface1 > 0)for(fp=MainFp,j=0;j<Nface1;j++){ /* put in faces that are copies */
   v0=(MainVp+fp->V[0]); v1=(MainVp+fp->V[1]); v2=(MainVp+fp->V[2]);
   if(v0->status == SELECTED &&
      v1->status == SELECTED &&
      v2->status == SELECTED) {
     CreateFace(v0->id,v1->id,v2->id);
     CopyFaceProp(fp,(MainFp+Nface-1));
   }
   fp++;
 }
 if(open == 2 && uuecount > 0){ /* add the connection edge and face */
   for(i=0;i<uuecount;i++){
     k=(MainVp+vve[i].vs)->id;
     CreateEdge(vve[i].vd,k);
     CreateFace(vve[i].vd,vve[i].vs,k);
   }
   X__Free(vve);
 }
 vp=MainVp; for(j=0;j<Nvert1;j++){
   if(vp->status == SELECTED){
     vp->status=DESELECTED;
     (MainVp+vp->id)->status=SELECTED;
   }
   vp++;
 }
 UpdateFaceHeap(Nface);    /* release any storage that was given as  */
 UpdateEdgeHeap(Nedge);    /* an over estimate when it was allocated */
 if(ne > 0)X__Free(xp);
 return TRUE;
}

BOOL Extrude(int command){
 HCURSOR hSave;
 static double dx_extrude=0.0,dy_extrude=0.0,dz_extrude=0.0;
 long Vstart,i,com,loop_count=1;
 double dmap=1.0;
 vertex *vp;
 long x,y,z;
 if(NvertSelect < 1)return FALSE;
 if(NvertSelect > 32000){
   SendPrgmQuery(IDQ_WIRETOOBIG,0);
   return FALSE;
 }
 Vstart=Nvert;
// if((dos_key_shift() & 0x04) == 0x04){
//   command=1; loop_count=1;
//   if((loop_count=Read3Reals("Extrude by",&dx_extrude,&dy_extrude,
//      &dz_extrude,0,2)) == 0)return FALSE;
//   dmap=1.0/(double)loop_count;
// }
 hSave=SetCursor(ghcurWait);
// if((dos_key_shift() & 0x08) == 0x08)com=2; /* left ALT key */
// else                                com=1;
 com=1;
 NEXT_LOOP:
 if(!CreateAttachedCopy(com)){ /* it failed */
   SetCursor(hSave);
   return FALSE;
 }
 if(command == 0){
   if(Nvert > Vstart){
     for(i=Vstart,vp=(MainVp+Vstart);i<Nvert;i++,vp++){
       if(vp->status == SELECTED && vp->gp == 1){
          vp->y += 1.0; /* to increment the applied map */
       }
     }
   }
   return TRUE;
 }
 x=(long)(dx_extrude*ruler)+lrulerx;
 y=(long)(dy_extrude*ruler)+lrulery;
 z=(long)(dz_extrude*ruler)+lrulerz;
 if(Nvert > Vstart)for(i=Vstart,vp=(MainVp+Vstart);i<Nvert;i++,vp++){
   if(vp->status == SELECTED){
     vp->xyz[0] += x; vp->xyz[1] += y; vp->xyz[2] += z;
     if(vp->gp == 1){
       vp->y += dmap; /* to increment the applied map */
     }
   }
 }
 loop_count--; if(loop_count > 0)goto NEXT_LOOP;
 SetCursor(hSave);
 do_NOT_abort=TRUE;
 DrawModel();
 do_NOT_abort=FALSE;
 return FALSE;
}

static void Ixpand(void){
 double s,sx,sy,sz,sxx,syy,szz;
 int x,xo,MickeyX,I,flag=0;
 POINT pt;
 long evTime;
 GetCursorPos(&pt); xo=pt.x;
 sxx=syy=szz=1.0;
 ClipCursor(NULL);
 if(!Mxpand){
   GrabonX=NpointerX; GrabonY=NpointerY; GrabonZ=NpointerZ;
 }
 evTime=GetTickCount()+TIME_DELAY;
 do {
   if(evTime > GetTickCount())continue;
   GetCursorPos(&pt); x=pt.x;
   MickeyX = x-xo; xo=x;
   if(MickeyX != 0){
     flag=1;
     if(MickeyX > 0)I=max( 1,min( 50,MickeyX));
     else           I=min(-1,max(-50,MickeyX));
     DrawRubberBoundBox(grab_xmin,grab_ymin,grab_zmin,
                        grab_xmax,grab_ymax,grab_zmax);
     sx=sy=sz=1.0; s=(double)(I)/55.0;
     if     (GetAsyncKeyState(VK_SHIFT)   & 0x8000)sy += s;
     else if(GetAsyncKeyState(VK_CONTROL) & 0x8000)sz += s;
     else if(GetAsyncKeyState(VK_MENU)    & 0x8000)sx += s;
     else {sx += s; sy += s; sz += s;}
     grab_xmin = (long)((double)(grab_xmin-GrabonX)*sx)+GrabonX;
     grab_xmax = (long)((double)(grab_xmax-GrabonX)*sx)+GrabonX;
     grab_ymin = (long)((double)(grab_ymin-GrabonY)*sy)+GrabonY;
     grab_ymax = (long)((double)(grab_ymax-GrabonY)*sy)+GrabonY;
     grab_zmin = (long)((double)(grab_zmin-GrabonZ)*sz)+GrabonZ;
     grab_zmax = (long)((double)(grab_zmax-GrabonZ)*sz)+GrabonZ;
     sxx *= sx; syy *= sy; szz *= sz;
     DrawRubberBoundBox(grab_xmin,grab_ymin,grab_zmin,
                        grab_xmax,grab_ymax,grab_zmax);
     XpandNurbsSurface(ActiveView,0,sx,sy,sz);
   }
   evTime=GetTickCount()+TIME_DELAY;
 }
 while (GetAsyncKeyState(VK_LBUTTON) & 0x8000);
 if(flag && !(GetAsyncKeyState(VK_RBUTTON) & 0x8000)){
   int i;
   vertex *vp;
   flag=0;
   grab_xmin=grab_ymin=grab_zmin =  MAXUNIT;
   grab_xmax=grab_ymax=grab_zmax = -MAXUNIT;
   if((vp=MainVp) != NULL)for(i=0;i<Nvert;i++){
     if(vp->status == SELECTED){
       vp->xyz[0]=(long)((double)(vp->xyz[0]-GrabonX)*sxx)+GrabonX;
       vp->xyz[1]=(long)((double)(vp->xyz[1]-GrabonY)*syy)+GrabonY;
       vp->xyz[2]=(long)((double)(vp->xyz[2]-GrabonZ)*szz)+GrabonZ;
       if(vp->xyz[0] > grab_xmax)grab_xmax=vp->xyz[0];
       if(vp->xyz[0] < grab_xmin)grab_xmin=vp->xyz[0];
       if(vp->xyz[1] > grab_ymax)grab_ymax=vp->xyz[1];
       if(vp->xyz[1] < grab_ymin)grab_ymin=vp->xyz[1];
       if(vp->xyz[2] > grab_zmax)grab_zmax=vp->xyz[2];
       if(vp->xyz[2] < grab_zmin)grab_zmin=vp->xyz[2];
     }
     vp++;
   }
   RecalibrateAllBezier(); RecalibrateMapLocks();
   do_NOT_abort=1;
   DrawModel();
   do_NOT_abort=0;
   sxx=syy=szz=1.0;
 }
 else{
   DrawRubberBoundBox(grab_xmin,grab_ymin,grab_zmin,
                      grab_xmax,grab_ymax,grab_zmax);
   XpandNurbsSurface(ActiveView,-1,0.0,0.0,0.0);
 }
 return;
}

static void Irotate(void){
 double beta=0.0,ctheta=0.0,stheta=0.0;
 int angle=0,bngle=0,x,xo,MickeyX,I,flag=0;
 POINT pt;
 long xp,yp,evTime;
 GetCursorPos(&pt); xo=pt.x;
 RotatorTheta=0.0;
 ClipCursor(NULL);
 if(!Mxpand){
   GrabonX=NpointerX; GrabonY=NpointerY; GrabonZ=NpointerZ;
 }
 evTime=GetTickCount()+TIME_DELAY;
 do {
   if(evTime > GetTickCount())continue;
   GetCursorPos(&pt); x=pt.x;
   MickeyX = x-xo; xo=x;
   if(MickeyX != 0){
     flag=1;
     if(MickeyX > 0)I=max( 1,min( 45,MickeyX));
     else           I=min(-1,max(-45,MickeyX));
     if((GetAsyncKeyState(VK_SHIFT) & 0x8000) == 0x8000){
       /* constrain 45 degrees if SHIFT key */
       if(abs(I) < 22)I=0;
       else{
         if(I < 0)I = -45;
         else     I =  45;
       }
     }
     DrawIrotateBoundBox(ActiveView,RotatorTheta);
     angle -= I;
     if     (angle >  180)angle -= 360;
     else if(angle < -180)angle += 360;
     RotatorTheta = angle*PI/180.0;
     bngle -= I;
     if     (bngle >  180)bngle -= 360;
     else if(bngle < -180)bngle += 360;
     DrawIrotateBoundBox(ActiveView,RotatorTheta);
     RotateNurbsSurface(ActiveView,0,RotatorTheta);
   }
   evTime=GetTickCount()+TIME_DELAY;
 }
 while (GetAsyncKeyState(VK_LBUTTON) & 0x8000);
 if(flag && !(GetAsyncKeyState(VK_RBUTTON) & 0x8000)){
   int i;
   vertex *vp;
   flag=0;
   beta = bngle*PI/180.0; bngle=0;
   ctheta=cos(beta); stheta=sin(beta);
   if((vp=MainVp) != NULL)for(i=0;i<Nvert;i++){
     if(vp->status == SELECTED){
       if(ActiveView == TRITOP){
         RotatePointAbout(vp->xyz[0],vp->xyz[1],GrabonX,GrabonY,
                          &xp,&yp,ctheta,stheta);
         vp->xyz[0]=xp; vp->xyz[1]=yp;
       }
       else if(ActiveView == TRIFRONT){
         RotatePointAbout(vp->xyz[0],vp->xyz[2],GrabonX,GrabonZ,
                          &xp,&yp,ctheta,stheta);
         vp->xyz[0]=xp; vp->xyz[2]=yp;
       }
       else if(ActiveView == TRIRIGHT){
         RotatePointAbout(vp->xyz[1],vp->xyz[2],GrabonY,GrabonZ,
                          &xp,&yp,ctheta,stheta);
         vp->xyz[1]=xp; vp->xyz[2]=yp;
       }
     }
     vp++;
   }
   RecalibrateAllBezier(); RecalibrateMapLocks();
   do_NOT_abort=1;
   DrawModel();
   do_NOT_abort=0;
 }
 else {
   DrawIrotateBoundBox(ActiveView,RotatorTheta);
   RotateNurbsSurface(ActiveView,-1,0.0);
 }
 return;
}

static void RotatePointAbout(long x, long y, long X, long Y, long *tx,
                             long *ty, double ctheta, double stheta){
 double dx,dy;
 dx=(double)(x-X);
 dy=(double)(y-Y);
 *tx = X+(long)(ctheta*dx-stheta*dy);
 *ty = Y+(long)(stheta*dx+ctheta*dy);
}

static void DrawIrotateBoundBox(int i, double theta){
 int  xs1,xs2,xs3,xs4,ys1,ys2,ys3,ys4;
 long xp,yp;
 double c,s;
 RECT rc;
 HDC hDC;
 hDC=GetDC(ghwnd_triview[i]);
 SelectObject(hDC,ghInvertPen);
 SetROP2(hDC,R2_XORPEN);
 SelectPalette(hDC,ghpaletteScreen,FALSE);
 RealizePalette(hDC);
 c=cos(theta); s=sin(theta);
 if(i == TRITOP){
   RotatePointAbout(grab_xmin,grab_ymin,GrabonX,GrabonY,&xp,&yp,c,s);
   GetWindowCoords(i,xp,yp,GrabonZ,&xs1,&ys1);
   RotatePointAbout(grab_xmax,grab_ymin,GrabonX,GrabonY,&xp,&yp,c,s);
   GetWindowCoords(i,xp,yp,GrabonZ,&xs2,&ys2);
   RotatePointAbout(grab_xmax,grab_ymax,GrabonX,GrabonY,&xp,&yp,c,s);
   GetWindowCoords(i,xp,yp,GrabonZ,&xs3,&ys3);
   RotatePointAbout(grab_xmin,grab_ymax,GrabonX,GrabonY,&xp,&yp,c,s);
   GetWindowCoords(i,xp,yp,GrabonZ,&xs4,&ys4);
 }
 else if(i == TRIFRONT){
   RotatePointAbout(grab_xmin,grab_zmin,GrabonX,GrabonZ,&xp,&yp,c,s);
   GetWindowCoords(i,xp,GrabonY,yp,&xs1,&ys1);
   RotatePointAbout(grab_xmax,grab_zmin,GrabonX,GrabonZ,&xp,&yp,c,s);
   GetWindowCoords(i,xp,GrabonY,yp,&xs2,&ys2);
   RotatePointAbout(grab_xmax,grab_zmax,GrabonX,GrabonZ,&xp,&yp,c,s);
   GetWindowCoords(i,xp,GrabonY,yp,&xs3,&ys3);
   RotatePointAbout(grab_xmin,grab_zmax,GrabonX,GrabonZ,&xp,&yp,c,s);
   GetWindowCoords(i,xp,GrabonY,yp,&xs4,&ys4);
 }
 else if(i == TRIRIGHT){
   RotatePointAbout(grab_ymin,grab_zmin,GrabonY,GrabonZ,&xp,&yp,c,s);
   GetWindowCoords(i,GrabonY,xp,yp,&xs1,&ys1);
   RotatePointAbout(grab_ymax,grab_zmin,GrabonY,GrabonZ,&xp,&yp,c,s);
   GetWindowCoords(i,GrabonY,xp,yp,&xs2,&ys2);
   RotatePointAbout(grab_ymax,grab_zmax,GrabonY,GrabonZ,&xp,&yp,c,s);
   GetWindowCoords(i,GrabonY,xp,yp,&xs3,&ys3);
   RotatePointAbout(grab_ymin,grab_zmax,GrabonY,GrabonZ,&xp,&yp,c,s);
   GetWindowCoords(i,GrabonY,xp,yp,&xs4,&ys4);
 }
 DrawOne3dCursor(hDC,i);
 MoveToEx(hDC,xs1,ys1,NULL);
 LineTo(hDC,xs2,ys2); LineTo(hDC,xs3,ys3);
 LineTo(hDC,xs4,ys4); LineTo(hDC,xs1,ys1);
 DrawOne3dCursor(hDC,i);
 ReleaseDC(ghwnd_triview[i],hDC);
}

static void ShapeShape(int id){
 int x,xo,MickeyX,I;
 POINT pt;
 long xp,yp,evTime;
 double c;
 GetCursorPos(&pt); xo=pt.x;
 RotatorTheta=0.0;
 ClipCursor(NULL);
 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));
     DrawShaperSphere(GrabonX,GrabonY,GrabonZ,
                    shaper_angle_theta,shaper_angle_phi,shaper_size);
     c=(1.0-(double)I/50.0); c=min(c,1.2); c=max(c,0.8);
     if(id == 0){     /* ctrl */
       shaper_size *= c;
       if(shaper_size < 0.3)shaper_size=0.3;
       if(shaper_size > 50.)shaper_size=50.;
     }
     else if(id == 1){ /* shift = longditude */
       shaper_angle_phi += I*PI/180;
       if(shaper_angle_phi >  PI)shaper_angle_phi -= PI*2;
       if(shaper_angle_phi < -PI)shaper_angle_phi += PI*2;
     }
     else if(id == 2){ /* alt  = latitide */
       shaper_angle_theta += I*PI/180;;
       if(shaper_angle_theta >  PI)shaper_angle_theta -= PI*2;
       if(shaper_angle_theta < -PI)shaper_angle_theta += PI*2;
     }
     DrawShaperSphere(GrabonX,GrabonY,GrabonZ,
                    shaper_angle_theta,shaper_angle_phi,shaper_size);
   }
   evTime=GetTickCount()+TIME_DELAY;
 }
 while (GetAsyncKeyState(VK_LBUTTON) & 0x8000);
 return;
}

static void Shape(void){
 long i;
 vector shaper_direction={0.0,0.0,1.0};
 vertex *vp;
 double mu1,mu2,r2,sx,sy,sz,b,c,rt;
 vector vnc;
 shaper_direction[2]=cos(shaper_angle_theta);
 shaper_direction[0]=cos(shaper_angle_phi)*sin(shaper_angle_theta);
 shaper_direction[1]=sin(shaper_angle_phi)*sin(shaper_angle_theta);
 r2=((double)TVsizeX/shaper_size)*((double)TVsizeX/shaper_size);
 vp=MainVp; if(MainVp != NULL && Nvert > 0)for(i=0;i<Nvert;i++){
   if(vp->status != SELECTED)continue;
   vnc[0]=(double)(vp->xyz[0]-GrabonX);
   vnc[1]=(double)(vp->xyz[1]-GrabonY);
   vnc[2]=(double)(vp->xyz[2]-GrabonZ);
   b=2*DOT(vnc,shaper_direction);
   c=DOT(vnc,vnc)-r2;
   rt=(b*b-4.0*c);
   if(rt > 0.0){ /* the vector intersects the sphere */
     rt=sqrt(rt);
     mu1 = (-b+rt)*0.5;
     mu2 = (-b-rt)*0.5;
     if(mu1 > mu2){  /* order the intersections */
       c=mu1; mu1=mu2; mu2=c;
     }
     if(mu1 < 0.0 && mu2 > 0.0){/* vertex is inside the sphere */
       vp->xyz[0] += (long)(mu2*shaper_direction[0]);
       vp->xyz[1] += (long)(mu2*shaper_direction[1]);
       vp->xyz[2] += (long)(mu2*shaper_direction[2]);
     }
   }
   vp++;
 }
 RecalibrateAllBezier(); RecalibrateMapLocks();
 do_NOT_abort=TRUE;
 DrawModel();
 do_NOT_abort=FALSE;
 DrawShaperSphere(GrabonX,GrabonY,GrabonZ,
                  shaper_angle_theta,shaper_angle_phi,shaper_size);
}

static void FormerDown(void){
 long i,j;
 vertex *vp;
 shaper_list=NULL;
 bShaperMoved=FALSE;
 if(NvertSelect < 1)return;
 if((shaper_list=X__Malloc(NvertSelect*sizeof(point))) != NULL){
   for(i=0,j=0,vp=MainVp;i<Nvert;i++,vp++){
     if(vp->status != SELECTED)continue;
     VECCOPY(vp->xyz,shaper_list[j])
     j++;
   }
 }
 return;
}

static void FormerUp(void){
 if(shaper_list !=NULL)X__Free(shaper_list);
 shaper_list=NULL;
 if(!bShaperMoved)return;
 RecalibrateAllBezier(); RecalibrateMapLocks();
 if(ghwndOpenGLview != NULL)PostMessage(ghwndOpenGLview,(WM_USER+2),0,0);
 do_NOT_abort=TRUE;
 DrawModel();
 do_NOT_abort=FALSE;
}

static void FormerMove(void){
 long i,j;
 double z,zmax,scale;
 vertex *vp;
 vector po,dx,gon;
 bShaperMoved=TRUE;
 if(shaper_list == NULL)return;
 zmax=((double)TVsizeX/shaper_size);
 zmax=zmax*zmax;
 dx[0]=NpointerX-(gon[0]=GrabonX);
 dx[1]=NpointerY-(gon[1]=GrabonY);
 dx[2]=NpointerZ-(gon[2]=GrabonZ);
 for(i=0,j=0,vp=MainVp;i<Nvert;i++,vp++){
   if(vp->status != SELECTED)continue;
   VECCOPY((double)shaper_list[j],po)
   z=(po[0]-gon[0])*(po[0]-gon[0])+
     (po[1]-gon[1])*(po[1]-gon[1])+
     (po[2]-gon[2])*(po[2]-gon[2]);
   if(z < zmax){
     scale=(1.0-z/zmax);
     if(GetAsyncKeyState(VK_SHIFT) & 0x8000){scale = scale*scale*scale*scale;}
     else  scale *= scale;  // different models
     VECSUM(po,scale*dx,vp->xyz)
   }
   j++;
 }
 DrawQuickModel();
}

static void ShearerDown(void){
 long i,j,id,c,cc;
 vertex *vp;
 shaper_list=NULL;
 bShaperMoved=FALSE;
 if(NvertSelect < 1)return;
 if     (ActiveView == TRITOP)  {id=2; c=NpointerZ;}
 else if(ActiveView == TRIFRONT){id=1; c=NpointerY;}
 else if(ActiveView == TRIRIGHT){id=0; c=NpointerX;}
 GrabDx=0;
 if((shaper_list=X__Malloc(NvertSelect*sizeof(point))) != NULL){
   for(i=0,j=0,vp=MainVp;i<Nvert;i++,vp++){
     if(vp->status != SELECTED)continue;
     if((cc=labs(vp->xyz[id]-c)) > GrabDx)GrabDx=cc;
     VECCOPY(vp->xyz,shaper_list[j])
     j++;
   }
 }
 return;
}

static void ShearerUp(void){
 if(shaper_list !=NULL)X__Free(shaper_list);
 shaper_list=NULL;
 if(!bShaperMoved)return;
 RecalibrateAllBezier(); RecalibrateMapLocks();
 if(ghwndOpenGLview != NULL)PostMessage(ghwndOpenGLview,(WM_USER+2),0,0);
 do_NOT_abort=TRUE;
 DrawModel();
 do_NOT_abort=FALSE;
}

static void ShearerMove(int x, int y){
 long i,j,id,type;
 vertex *vp;
 vector po,dx,gon;
 double z,l;
 bShaperMoved=TRUE;
 if(shaper_list == NULL)return;

 if((GetAsyncKeyState(VK_MENU) & 0x8000) &&
    (GetAsyncKeyState(VK_CONTROL) & 0x8000)){ // curl
   long id1,id2,c1,c2,cc;
   l=(double)(x-x_down);
   if(l > 0.0)l=min(360.0,l*1.5);
   else       l=max(-360.0,l*1.5);
   if     (ActiveView == TRITOP)  {id1=1; c1=GrabonY;}
   else if(ActiveView == TRIFRONT){id1=2; c1=GrabonZ;}
   else if(ActiveView == TRIRIGHT){id1=2; c1=GrabonZ;}
   GrabDx=0;
   for(i=0,j=0,vp=MainVp;i<Nvert;i++,vp++){
     if(vp->status != SELECTED)continue;
     if((cc=labs((long)shaper_list[j][id1]-c1)) > GrabDx)GrabDx=cc;
     j++;
   }
   gon[0]=GrabonX;
   gon[1]=GrabonY;
   gon[2]=GrabonZ;
   for(i=0,j=0,vp=MainVp;i<Nvert;i++,vp++){
     if(vp->status != SELECTED)continue;
     VECCOPY((double)shaper_list[j],po)
     z=fabs(po[id1]-gon[id1]);
     if(GrabDx > 1.0){
       long xp,yp;
       double beta,ctheta,stheta;
       if(GetAsyncKeyState(VK_SHIFT) & 0x8000)z=(1.0 - z/(double)GrabDx);
       else                                   z=z/(double)GrabDx;
       beta = l*z*PI/180.0;
       ctheta=cos(beta); stheta=sin(beta);
       if(ActiveView == TRITOP){
         RotatePointAbout((long)po[0],(long)po[1],GrabonX,GrabonY,
                          &xp,&yp,ctheta,stheta);
         vp->xyz[0]=xp; vp->xyz[1]=yp;
       }
       else if(ActiveView == TRIFRONT){
         RotatePointAbout((long)po[0],(long)po[2],GrabonX,GrabonZ,
                          &xp,&yp,ctheta,stheta);
         vp->xyz[0]=xp; vp->xyz[2]=yp;
       }
       else if(ActiveView == TRIRIGHT){
         RotatePointAbout((long)po[1],(long)po[2],GrabonY,GrabonZ,
                          &xp,&yp,ctheta,stheta);
         vp->xyz[1]=xp; vp->xyz[2]=yp;
                }
     }
     j++;
   }
   DrawQuickModel();
   return;
 }


 dx[0]=NpointerX-(gon[0]=GrabonX);
 dx[1]=NpointerY-(gon[1]=GrabonY);
 dx[2]=NpointerZ-(gon[2]=GrabonZ);
 if     (ActiveView == TRITOP)  {dx[2]=0; id=2;}
 else if(ActiveView == TRIFRONT){dx[1]=0; id=1;}
 else if(ActiveView == TRIRIGHT){dx[0]=0; id=0;}
 if(GetAsyncKeyState(VK_MENU) & 0x8000){  // taper
   l=(double)(x-x_down);
   if(l < 0.0)l =  min(1.0,fabs(l)/100.0);
   else       l = -min(1.0,l/100.0);
   type=1;
 }
 else if(GetAsyncKeyState(VK_CONTROL) & 0x8000){ // twist
   l=(double)(x-x_down);
   if(l > 0.0)l=min(360.0,l*1.5);
   else       l=max(-360.0,l*1.5);
   type=2;
 }
 else{
   type=0;
 }
 for(i=0,j=0,vp=MainVp;i<Nvert;i++,vp++){
   if(vp->status != SELECTED)continue;
   VECCOPY((double)shaper_list[j],po)
   z=fabs(po[id]-gon[id]);
   if(GrabDx > 1.0){
     z=(1.0 - z/(double)GrabDx);
     if(GetAsyncKeyState(VK_SHIFT) & 0x8000)z=z*z;
     if(type == 1){ // taper
       vector d;
       VECSUB(gon,po,d)
       if     (ActiveView == TRITOP)  d[2]=0;
       else if(ActiveView == TRIFRONT)d[1]=0;
       else if(ActiveView == TRIRIGHT)d[0]=0;
       VECSUM(po,l*z*d,vp->xyz)
     }
     else if(type == 2){  // twist
       long xp,yp;
       double beta,ctheta,stheta;
       beta = l*z*PI/180.0;
       ctheta=cos(beta); stheta=sin(beta);
       if(ActiveView == TRITOP){
         RotatePointAbout((long)po[0],(long)po[1],GrabonX,GrabonY,
                          &xp,&yp,ctheta,stheta);
         vp->xyz[0]=xp; vp->xyz[1]=yp;
       }
       else if(ActiveView == TRIFRONT){
         RotatePointAbout((long)po[0],(long)po[2],GrabonX,GrabonZ,
                          &xp,&yp,ctheta,stheta);
         vp->xyz[0]=xp; vp->xyz[2]=yp;
       }
       else if(ActiveView == TRIRIGHT){
         RotatePointAbout((long)po[1],(long)po[2],GrabonY,GrabonZ,
                          &xp,&yp,ctheta,stheta);
         vp->xyz[1]=xp; vp->xyz[2]=yp;
       }
     }
     else{ // shear
       VECSUM(po,z*dx,vp->xyz)
     }
   }
   j++;
 }
 DrawQuickModel();
}

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;
 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);   /* like a zoom */
     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;
 if(ghwndOpenGLview != NULL)PostMessage(ghwndOpenGLview,(WM_USER+2),0,0);
 do_NOT_abort=TRUE;
 DrawModel();
 do_NOT_abort=FALSE;
 UpdateCounters();
}

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

void PanToolMove(int x, int y, BOOL ctrl, BOOL shift,HWND hwnd){
 long a,b,c,d,e,f,gqd;
 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;
 DrawQuickModel();
}

void ZoomView(int x, int y){
 BOOL bRedraw=FALSE,bUpdate=FALSE;
 unsigned int SaveDrawStatus;
 int xo;
 POINT pt;
 long gqd,evTime;
 double zf,dx,dy,dz;
 GetCursorPos(&pt); xo=pt.x;
// evTime=GetTickCount()+TIME_DELAY;
 do {
   Sleep(10);
 //  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.1;
     }
     else{
       zf=0.9090909;
     }
     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;
       DrawQuickModel();
       bRedraw=TRUE;
       bUpdate=TRUE;
     }
   }
//   evTime=GetTickCount()+TIME_DELAY;
   {MSG msg;
    if(PeekMessage(&msg, 0, 0, 0, PM_REMOVE)){
      TranslateMessage(&msg);
      DispatchMessage(&msg);
    }
   }
   if(bUpdate){
     DrawQuickModel();
     bUpdate=FALSE;
   }
 }
 while(1);
 if(bRedraw){
   if(ghwndOpenGLview != NULL)PostMessage(ghwndOpenGLview,(WM_USER+2),0,0);
   do_NOT_abort=TRUE;
   DrawModel();
   do_NOT_abort=FALSE;
   UpdateCounters();
 }
 return;
}