SKELETON.C

Go to the documentation of this file.

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


/* file SKELETON.C  skeleton file for the designer */

// Handle all skeleton functions

#define MODULE_SKELETON 1

#include "design.h"

#define NODE_AXIS    0
#define RED_AXIS     1
#define GREEN_AXIS   2
#define YELLOW_AXIS  3
#define TIME_DELAY  30

static skel *PickSkeleton(int H, int V, int view);
static void DefaultOrientAxes(skel *sp);
static void SelectBySk(skel *sp,int op, int children);
static void SkTwist(void);
static void SkPivot(void);
static void SkRotateRubberBones(void);
static void DrawSkeletonAxes(skel *sp,int view,int sh1,int sv1, HDC hDC);
static void DrawTrSkeletonAxes(skel *sp,int view,int sh1,int sv1, HDC hDC);
static void DuplicateSkeletonChildren(skel *, skel *, skel *, long );
static BOOL CALLBACK SkToolBarDlgProc(HWND, UINT, WPARAM, LPARAM);
static double GetBoneRelativeDistance(point v, point s, point sp, vector d, double len, double *l, vector r);

static BOOL SkMovedFlag=FALSE;
static BOOL SkSelectFlag=FALSE;
static BOOL SkRubberBonesRotate=FALSE;
static int ep1[12]={0,1,2,3,4,5,6,7,0,1,2,3};
static int ep2[12]={1,2,3,0,5,6,7,4,4,5,6,7};
static int SelectedSkeletonAxis=0;
static point LastSkeletonPoint;
static skel *LastSkeletonVertex=NULL,*SkAssNode=NULL,
            *SkSelectedNode1=NULL,*SkSelectedNode2=NULL;

static skel *PickSkeleton(int H, int V, int view){
 skel *sp,*sf;
 double d,dmin,dth;
 int sho,svo;
 sp=MainSp;
 sf=NULL;
 dmin=(double)TVsizeX*(double)TVsizeX;
 dth=dmin/32/32;
 while(sp != NULL){
   GetWindowCoords(view,sp->xyz[0],sp->xyz[1],sp->xyz[2],&sho,&svo);
   if( (sho > H-4) && (sho < H+4) && (svo > V-4) && (svo < V+4)){
     d=(double)(sp->xyz[0]-NpointerX)*(double)(sp->xyz[0]-NpointerX)
      +(double)(sp->xyz[1]-NpointerY)*(double)(sp->xyz[1]-NpointerY)
      +(double)(sp->xyz[2]-NpointerZ)*(double)(sp->xyz[2]-NpointerZ);
     if(d < dmin){
       dmin=d;
       sf=sp;
     }
   }
   sp=sp->last;
 }
 return sf;
}

void ZeroSkeletonBoundingBox(skel *sp){
 int i,j;
 for(i=0;i<8;i++)for(j=0;j<3;j++)sp->bx[i][j] = sp->xyz[j];
 if(sp->at != NULL){
   for(j=0;j<3;j++)sp->bx[2][j]=sp->at->xyz[j];
   for(j=0;j<3;j++)sp->bx[3][j]=sp->at->xyz[j];
   for(j=0;j<3;j++)sp->bx[6][j]=sp->at->xyz[j];
   for(j=0;j<3;j++)sp->bx[7][j]=sp->at->xyz[j];
 }
}

static void DefaultOrientAxes(skel *sp){
 vector x={1.0,0.0,0.0},y={0.0,1.0,0.0},z={0.0,0.0,1.0};
 if(sp->at == NULL)return;
 VECSUB((double)sp->at->xyz,(double)sp->xyz,sp->v); O_normalize(sp->v);
 if     (fabs(sp->v[2]) < 0.9)CROSS(sp->v,z,sp->u)
 else if(fabs(sp->v[1]) < 0.9)CROSS(y,sp->v,sp->u)
 else                         CROSS(x,sp->v,sp->u)
 O_normalize(sp->u);
 CROSS(sp->u,sp->v,sp->w);
 O_normalize(sp->w);
}

void GetSkeletonBoundBox(skel *sp, int ass){
 long l;
 int i,j,flag=0;
 vector p,box[8];
 vertex *vp;
 double a,b,c,amin,amax,bmin,bmax,cmin,cmax;
 amin=bmin=cmin=   FARAWAY;
 amax=bmax=cmax=  -FARAWAY;
 ZeroSkeletonBoundingBox(sp);
 if((vp=MainVp) != NULL)for(l=0;l<Nvert;l++){
   if(ass && vp->status == SELECTED)vp->sp=sp;
   if(vp->sp == sp){
     flag=1;
     VECSUB((double)vp->xyz,(double)sp->xyz,p)
     a=DOT(p,sp->u); amin=min(a,amin); amax=max(a,amax);
     b=DOT(p,sp->v); bmin=min(b,bmin); bmax=max(b,bmax);
     c=DOT(p,sp->w); cmin=min(c,cmin); cmax=max(c,cmax);
   }
   vp++;
 }
 if(flag){ /* assign bounding box */
   box[0][0]=amin; box[0][1]=bmin; box[0][2]=cmax;
   box[1][0]=amax; box[1][1]=bmin; box[1][2]=cmax;
   box[2][0]=amax; box[2][1]=bmax; box[2][2]=cmax;
   box[3][0]=amin; box[3][1]=bmax; box[3][2]=cmax;
   box[4][0]=amin; box[4][1]=bmin; box[4][2]=cmin;
   box[5][0]=amax; box[5][1]=bmin; box[5][2]=cmin;
   box[6][0]=amax; box[6][1]=bmax; box[6][2]=cmin;
   box[7][0]=amin; box[7][1]=bmax; box[7][2]=cmin;
   for(i=0;i<8;i++)for(j=0;j<3;j++){
     sp->bx[i][j] = sp->xyz[j] + (long)(box[i][0]*sp->u[j] +
                                        box[i][1]*sp->v[j] +
                                        box[i][2]*sp->w[j]);
   }
 }
}

void SelectByHierarchy(skel *sp, int op){
  vertex *vp;
  skel *sp1,*sp2;
  int drawval=0;
  long i;
  if(sp != NULL){
    if((sp1=MainSp) != NULL)while(sp1 != NULL){
      sp1->id=0; sp1=sp1->last;
    }
    if((sp1=MainSp) != NULL)while(sp1 != NULL){
      sp2=sp1;
      while(sp2 != NULL){
        if(sp2 == sp)sp1->id=1;
        sp2=sp2->at;
      }
      sp1=sp1->last;
    }
    if(op == DLG_SKEL_SELECT){
      if((vp=MainVp) != NULL)for(i=0;i<Nvert;i++,vp++){
        if((sp1=vp->sp) != NULL && sp1->id == 1 && vp->status != SELECTED){
          if(drawval == 0)drawval=1;
          if(vp->status == HIDDEN)drawval=2;
          vp->status=SELECTED;
          NvertSelect++; NvertDeselect--;
        }
      }
    }
    else if(op == DLG_SKEL_DESELECT){
      if((vp=MainVp) != NULL)for(i=0;i<Nvert;i++,vp++){
        if((sp1=vp->sp) != NULL && sp1->id == 1 && vp->status != DESELECTED){
          if(vp->status == HIDDEN){
            vp->status=DESELECTED;
            drawval=2;
          }
          else{
            if(drawval == 0)drawval=1;
            vp->status=DESELECTED;
            NvertSelect--; NvertDeselect++;
          }
        }
      }
    }
    else if(op == DLG_SKEL_HIDE){
      if((vp=MainVp) != NULL)for(i=0;i<Nvert;i++,vp++){
        if((sp1=vp->sp) != NULL && sp1->id == 1 && vp->status != HIDDEN){
          drawval=2;
          if(vp->status == SELECTED){NvertSelect--; NvertDeselect++;}
          vp->status=HIDDEN;
        }
      }
    }
    else if(op == 1){ /* select TV */
      if((vp=MainVp) != NULL)for(i=0;i<Nvert;i++,vp++){
        if(vp->status == DESELECTED && (sp1=vp->sp) != NULL &&
          ((!SkSelectFlag && sp1 == sp) || (SkSelectFlag && sp1->id == 1)) ){
          if(drawval == 0)drawval=1;
          vp->status=SELECTED;
          NvertSelect++; NvertDeselect--;
        }
      }
    }
    else if(op == 2){ /* deselect TV */
      if((vp=MainVp) != NULL)for(i=0;i<Nvert;i++,vp++){
        if(vp->status == SELECTED && (sp1=vp->sp) != NULL &&
          ((!SkSelectFlag && sp1 == sp) || (SkSelectFlag && sp1->id == 1)) ){
          if(drawval == 0)drawval=1;
          vp->status=DESELECTED;
          NvertSelect--; NvertDeselect++;
        }
      }
    }
    else if(op == 3){ /* hide TV */
      if((vp=MainVp) != NULL)for(i=0;i<Nvert;i++,vp++){
        if((sp1=vp->sp) != NULL &&
          ((!SkSelectFlag && sp1 == sp) || (SkSelectFlag && sp1->id == 1)) ){
          drawval=2;
          if(vp->status == SELECTED){NvertSelect--; NvertDeselect++;}
          vp->status=HIDDEN;
        }
      }
    }
    else if(op == 4){ /* reveal TV */
      if((vp=MainVp) != NULL)for(i=0;i<Nvert;i++,vp++){
        if(vp->status == HIDDEN && (sp1=vp->sp) != NULL &&
          ((!SkSelectFlag && sp1 == sp) || (SkSelectFlag && sp1->id == 1)) ){
          drawval=2;
          vp->status=DESELECTED;
        }
      }
    }
    if(drawval == 2)DrawModel();
    else if(drawval == 1)DrawVerticesOnly(NULL);
    UpdateCounters();
  }
}

static void SelectBySk(skel *sp,int op, int children){
  vertex *vp;
  skel *sp1,*sp2;
  int drawval=0;
  long i;
  if(sp != NULL){
    if((sp1=MainSp) != NULL)while(sp1 != NULL){
      sp1->id=0; sp1=sp1->last;
    }
    if(children == 1){ /* plus all selected */
      if((sp1=MainSp) != NULL)while(sp1 != NULL){
        sp2=sp1;
        while(sp2 != NULL){
          if(sp2 == sp)sp1->id=1;
          sp2=sp2->at;
        }
        sp1=sp1->last;
      }
    }
    else{ /* just as attached */
      if((sp1=MainSp) != NULL)while(sp1 != NULL){
        if(sp1 == sp)sp1->id=1;
        sp1=sp1->last;
      }
    }
    if(op == SELECTED){
      if((vp=MainVp) != NULL)for(i=0;i<Nvert;i++,vp++){
        if((sp1=vp->sp) != NULL && sp1->id == 1 && vp->status == DESELECTED){
          if(drawval == 0)drawval=1;
          vp->status=SELECTED;
          NvertSelect++; NvertDeselect--;
        }
      }
    }
    else if(op == DESELECTED){
      if((vp=MainVp) != NULL)for(i=0;i<Nvert;i++,vp++){
        if((sp1=vp->sp) != NULL && sp1->id == 1 && vp->status == SELECTED){
          if(drawval == 0)drawval=1;
          vp->status=DESELECTED;
          NvertSelect--; NvertDeselect++;
        }
      }
    }
    if(drawval == 1){
      DrawVerticesOnly(NULL); /* WM_PAINT will redraw the skeleton */
      UpdateCounters();
    }
  }
}

int skintriview(point p){
 if( ((p[0] > TVpointX) && (p[0] < TVpointX+TVsizeX))
  && ((p[1] > TVpointY) && (p[1] < TVpointY+TVsizeY))
  && ((p[2] > TVpointZ) && (p[2] < TVpointZ+TVsizeZ))
   )return 1;
 return 0;
}

void SkDelete(skel *sp){
 vertex *vp;
 long i;
 EraseSkeleton(sp);
 if((vp=MainVp) != NULL)for(i=0;i<Nvert;i++){ /* remove vertex point to sk */
   if(vp->sp == sp)vp->sp=NULL;
   vp++;
 }
 ClearNurbsSkeleton(sp);
}

void ResetSkeletonWeights(void){
 double w=1.0,r=1.0,z=0.1;
 skel *sp; 
 if(Read3Reals("Reset All Bones",&w,&r,&z,2) == OK){
   sp=MainSp; while(sp != NULL){
     sp->weight=w;
     sp->wrange=r;
     sp->wzone=z;
     sp=sp->last;
   }
 }
}

void AutoVerticesToSkeleton(void){
 int i;
 vertex *vp;
 skel *sp,*nearest_sp;
 double d,l,dmin;
 vector r;
 i=MessageBox(ghwnd_main,"Confirm ?","Auto Assign",MB_YESNO);
 if(i != IDYES)return;
 sp=MainSp; while(sp != NULL){ 
   VECCOPY(sp->xyz,sp->xyz_last);
   sp=sp->last;
 }
 sp=MainSp; while(sp != NULL){ 
   if(sp->at != NULL){ // Calcuate lengths and bone directions
     VECSUB((double)sp->at->xyz_last,(double)sp->xyz_last,sp->d_last)
     sp->len_last=sqrt(DOT(sp->d_last,sp->d_last));
     VECSCALE(1.0/sp->len_last,sp->d_last,sp->d_last);     
     VECSUB((double)sp->at->xyz,(double)sp->xyz,sp->d)
     sp->len=sqrt(DOT(sp->d,sp->d));
     VECSCALE(1.0/sp->len,sp->d,sp->d);     
   }
   sp=sp->last;
 }
 vp=MainVp; if(MainVp != NULL && Nvert > 0)for(i=0;i<Nvert;i++){
   if(vp->status == SELECTED){ 
     dmin=(double)MAXUNIT; nearest_sp=NULL;
     sp=MainSp; while(sp != NULL){ 
       if(sp->at != NULL && sp->weight > 0.0){ // go through each bone and calculate its distance from the vertex
        d=GetBoneRelativeDistance(vp->xyz,sp->xyz_last,sp->at->xyz_last,sp->d_last,sp->len_last,&l,r);
         d=d/fabs(sp->weight); // to allow for weights to influence 
         if(d < dmin){
           if(l < sp->wrange+sp->wzone){  // inside range
             dmin=d;
             nearest_sp=sp;
           }
         }
       }
       sp=sp->last;
     }
     if(nearest_sp != NULL){
       vp->sp=nearest_sp;
     }
   }
   vp++;
 }
 sp=MainSp; while(sp != NULL){ 
   GetSkeletonBoundBox(sp,0);
   sp=sp->last;
 }
}

static void SkTwist(void){
 int x,xo,MickeyX;
 POINT pt;
 long xp,yp,evTime;
 double I,ltr[4][4];
 skel *sp;
 if(SkSelectedNode1 == NULL)return;
 GetCursorPos(&pt); xo=pt.x;
 sp=SkSelectedNode1;
 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=(double)max( 1,min( 45,MickeyX));
     else           I=(double)min(-1,max(-45,MickeyX));
     DrawSkeleton();
     rotate_round_vector(I,sp->v,ltr);
     mv4by1(ltr,sp->u,sp->u);
     mv4by1(ltr,sp->w,sp->w);
     DrawSkeleton();
   }
   evTime=GetTickCount()+TIME_DELAY;
 }
 while (GetAsyncKeyState(VK_LBUTTON) & 0x8000);
 return;
}

static double GetBoneRelativeDistance(point v, point s, point sp, vector d, double len, double *l, vector r){
 vector dp,q;
 double ll;
 VECSUB((double)v,(double)s,dp)
 ll=DOT(dp,d);
 if(ll < 0.0){ // closest point is behind start
   *l=0.0;     // fraction of bone to offset vector
   VECSUB((double)v,(double)s,r)
 }
 else if(ll > len){ // closest point is beyond end
   *l=1.0;   
   VECSUB((double)v,(double)sp,r)
 } 
 else{
   *l=ll/len;
   VECSUM((double)s,ll*d,q)
   VECSUB((double)v,q,r)
 }  
 return sqrt(DOT(r,r));  // closest distance of v to bone from (s to sp) 
}

static void GetNewVertexPositionForBone(skel *sp, vector p){
 double l;
 vector pb;
 l=sp->len * sp->l; // this is relative position along new bone of start point of vector to P
 VECSUM((double)sp->xyz,l*sp->d,pb)
 VECSUM(pb,sp->r,p) // this is the position of the vertex relative to the new bone's position
}

static void GetNewVertexPositionForRotatedBone(skel *sp, point v, vector p){
 m4by1(sp->tr,(double)v[0],(double)v[1],(double)v[2],&p[0],&p[1],&p[2]);
}


static void RubberBonesDeformConstant(void){ // Perform rubber Bones Action constant scaling - constant effect inside range
 int i;  
 vertex *vp;
 skel *sp,*spsel;
 double l,f,x,ff,wsum;
 vector r,p,nv;
 // setup 
 sp=MainSp; while(sp != NULL){ 
   if(sp->at != NULL){ // Calcuate lengths and bone directions
     VECSUB((double)sp->at->xyz_last,(double)sp->xyz_last,sp->d_last)
     sp->len_last=sqrt(DOT(sp->d_last,sp->d_last));
     VECSCALE(1.0/sp->len_last,sp->d_last,sp->d_last);     
     VECSUB((double)sp->at->xyz,(double)sp->xyz,sp->d)
     sp->len=sqrt(DOT(sp->d,sp->d));
     VECSCALE(1.0/sp->len,sp->d,sp->d);     
   }
   sp=sp->last;
 }
 // now move each selected vertex
 vp=MainVp; if(MainVp != NULL && Nvert > 0)for(i=0;i<Nvert;i++){
   if(vp->status == SELECTED){   
     wsum=0.0;
     sp=MainSp; while(sp != NULL){ 
       sp->r_scale=0.0; 
       if(sp->at != NULL){ // go through each bone and calculate its distance from the vertex
         sp->r_dist=GetBoneRelativeDistance(vp->xyz,sp->xyz_last,sp->at->xyz_last,
                          sp->d_last,sp->len_last,&l,r);
         sp->l=l;  // relative position along bone to which vertex is closest
         VECCOPY(r,sp->r) // vector from (point l to vertex) 
         if(sp->r_dist < sp->wrange*ruler){  // bone is in range
           f=(sp->wrange-sp->wzone)*ruler;
           sp->r_scale=sp->weight;
           if(l < 1.e-3 || l > 1-1.e-3){  // at end of bone
             ff=sqrt(1.0 - sp->r_dist/(sp->wrange*ruler));  // fall off for all vertices
             sp->r_scale *= ff;
           }
           else if((x=sp->r_dist - f) > 0){ // in the transition zone
             sp->r_scale *= (1.0-x/f);
           }  
           wsum += sp->r_scale;
         }
       }
       sp=sp->last;
     }
     if(wsum > 0.0){ // there are some changes to this vertex, otherwise no change to this vertex
       nv[0]=nv[1]=nv[2]=0.0; 
       sp=MainSp; while(sp != NULL){ // scale weights
         if(sp->at != NULL){ // go through each bone and calculate the new position based on any bone move
           if(SkRubberBonesRotate)GetNewVertexPositionForRotatedBone(sp,vp->xyz,p);
           else                   GetNewVertexPositionForBone(sp,p);
           VECSUM(nv,(sp->r_scale/wsum)*p,nv)  // weight the new point
         }
         sp=sp->last;
       }
       // assign new vertex position based on bone weight
       VECCOPY((long)nv,vp->xyz)
     }
   }
   vp++;
 }
}

static void RubberBonesDeformVariable(void){ // Perform rubber Bones Action  with variable scaling - strength proportionate to distance from bone - no matter how close
 int i;
 vertex *vp;
 skel *sp;
 double l,dmin,dthresh=32,wsum;
 vector r,p,nv;
 // setup 
 sp=MainSp; while(sp != NULL){ 
   if(sp->at != NULL){ // Calcuate lengths and bone directions
     VECSUB((double)sp->at->xyz_last,(double)sp->xyz_last,sp->d_last)
     sp->len_last=sqrt(DOT(sp->d_last,sp->d_last));
     VECSCALE(1.0/sp->len_last,sp->d_last,sp->d_last);     
     VECSUB((double)sp->at->xyz,(double)sp->xyz,sp->d)
     sp->len=sqrt(DOT(sp->d,sp->d));
     VECSCALE(1.0/sp->len,sp->d,sp->d);     
   }
   sp=sp->last;
 }
 // now move each selected vertex
 vp=MainVp; if(MainVp != NULL && Nvert > 0)for(i=0;i<Nvert;i++){
   if(vp->status == SELECTED){   
     dmin=(double)MAXUNIT;
     sp=MainSp; while(sp != NULL){ 
       if(sp->at != NULL){ // go through each bone and calculate its distance from the vertex
         sp->r_scale=max(dthresh,(sp->r_dist=GetBoneRelativeDistance(vp->xyz,sp->xyz_last,sp->at->xyz_last,
                          sp->d_last,sp->len_last,&l,r)));
         sp->l=l;  // relative position along bone to which vertex is closest
         VECCOPY(r,sp->r) // vector from (point l to vertex) 
         if(sp->r_scale < dmin)dmin=sp->r_scale;
       }
       sp=sp->last;
     }
     wsum=0.0;
     sp=MainSp; while(sp != NULL){ // calculate bone influence
       if(sp->at != NULL){ // go through each bone and calculate its distance from the vertex
         sp->r_scale = (dmin/(sp->r_scale))*(dmin/(sp->r_scale))*sp->weight;
         if(sp->r_dist > (sp->wrange-sp->wzone)*ruler){  // bone is out of range
           if(sp->r_dist > sp->wrange*ruler)sp->r_scale=0.0;
           else{
             double s = (sp->r_dist - (sp->wrange-sp->wzone)*ruler)/(sp->wzone*ruler);
             sp->r_scale *= (1.0-s); 
           }
         } 
         wsum += sp->r_scale;   
       }
       sp=sp->last;
     }
     if(wsum > 1.e-4){ // there are some changes to this vertex, otherwise no change to this vertex
       sp=MainSp; while(sp != NULL){ // scale influences so all influences sum to 1.0 (unless bones are out of range
         if(sp->at != NULL){
           sp->r_scale /= wsum;
         }
         sp=sp->last;
       }
       // now each bone contains the weight influence to move the bone based on its last position
       // find the vertex position based on the new bone positions
       nv[0]=nv[1]=nv[2]=0.0; 
       sp=MainSp; while(sp != NULL){ // scale weights
         if(sp->at != NULL){ // go through each bone and calculate the new position based on any bone move
           if(SkRubberBonesRotate)GetNewVertexPositionForRotatedBone(sp,vp->xyz,p);
           else                   GetNewVertexPositionForBone(sp,p);
           VECSUM(nv,(sp->r_scale)*p,nv)  // weight the new point
         }
         sp=sp->last;
       }
       // assign new vertex position based on bone weight
       VECCOPY((long)nv,vp->xyz)
     }
   }
   vp++;
 }
}

static void RubberBonesDeform(void){ // call the appropriate model
 if(rubberbone_model == 0)RubberBonesDeformVariable();
 else                     RubberBonesDeformConstant();
}

static void SkRotateRubberBones(void){ 
 int x,xo,MickeyX;
 POINT pt;
 long xp,yp,evTime;
 double I,ltr[4][4],sst[4][4],xr,yr,zr;
 skel *sp,*ls,*ssp;
 point p2;
 vector v;
 if((ls=LastSkeletonVertex) == NULL)return;
 GetCursorPos(&pt); xo=pt.x;
 ClipCursor(NULL);
 evTime=GetTickCount()+TIME_DELAY;
 do {
   if(evTime > GetTickCount())continue;
   GetCursorPos(&pt); x=pt.x;
   MickeyX = x-xo; xo=x;
   if(MickeyX != 0){
     DrawSkeleton();
     if(MickeyX > 0)I=(double)max( 1,min( 45,MickeyX));
     else           I=(double)min(-1,max(-45,MickeyX));
     if     (ActiveView == 0){v[0] =  0.0; v[1] = 0.0; v[2] = 1.0;} // perpendicular to active window
     else if(ActiveView == 1){v[0] =  0.0; v[1] = 1.0; v[2] = 0.0;}
     else if(ActiveView == 2){v[0] = -1.0; v[1] = 0.0; v[2] = 0.0;}
     if(ls->at == NULL){  /* main node */
       VECSCALE(1000.0*(double)UNIT2,v,v)
       VECSUM((double)ls->xyz,v,v)
       mv4by1(ls->t,v,v);
       VECCOPY((long)v,p2)
       arbitrary_rotate(I,ls->tp,p2,ltr);
     }
     else{
       VECSCALE(1000.0*(double)UNIT2,v,v)
       VECSUM((double)ls->at->xyz,v,v)
       mv4by1(ls->at->t,v,v);
       VECCOPY((long)v,p2)
       arbitrary_rotate(I,ls->at->tp,p2,ltr);
     }
     ssp=MainSp; while(ssp != NULL){  // work out transformation matrices
       sp=ssp; while(sp != NULL){
         if(sp == LastSkeletonVertex){
           m4by4(ltr,ssp->t,sst);
           c4to4(sst,ssp->t);
           break;
         }
         sp=sp->at;
       }
       ssp=ssp->last;
     }
     sp=MainSp; while(sp != NULL){ // apply transformation matrices 
        m4by4(sp->t,sp->tr,sst); c4to4(sst,sp->tr);  // tr is the total transform
        m4by1(sp->t,(double)(sp->xyz[0]),(double)(sp->xyz[1])
              ,(double)(sp->xyz[2]),&xr,&yr,&zr);
        sp->xyz[0]=(long)xr; sp->xyz[1]=(long)yr; sp->xyz[2]=(long)zr;
        null_transform(sp->t);  // must reset as Skeleton has been moved
        sp=sp->last;
     }
     DrawSkeleton();
   }
   evTime=GetTickCount()+TIME_DELAY;
 }
 while (GetAsyncKeyState(VK_LBUTTON) & 0x8000);
 return;
}

static void SkPivot(void){  // SKANIMATE tool - manipulate skeleton pose interactively
 int x,xo,MickeyX;          // display shows only skeleton and bounding box
 POINT pt;
 long xp,yp,evTime;
 double I,ltr[4][4],sst[4][4];
 skel *sp,*ls,*ssp;
 point p2;
 vector v;
 if((ls=LastSkeletonVertex) == NULL)return;
 GetCursorPos(&pt); xo=pt.x;
 sp=SkSelectedNode1;
 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=(double)max( 1,min( 45,MickeyX));
     else           I=(double)min(-1,max(-45,MickeyX));
     if(1){ /* ctrl */
       if(ls->at == NULL){  /* main node */
         if     (SelectedSkeletonAxis == RED_AXIS  )VECCOPY(ls->u,v)
         else if(SelectedSkeletonAxis == GREEN_AXIS)VECCOPY(ls->v,v)
         else                                       VECCOPY(ls->w,v)
         VECSCALE(1000.0*(double)UNIT2,v,v)
         VECSUM((double)ls->xyz,v,v)
         mv4by1(ls->t,v,v);
         VECCOPY((long)v,p2)
         arbitrary_rotate(I,ls->tp,p2,ltr);
       }
       else{
         if(SelectedSkeletonAxis == NODE_AXIS){
           arbitrary_rotate(I,ls->tp,ls->at->tp,ltr);
         }
         else{
           if     (SelectedSkeletonAxis == RED_AXIS   )VECCOPY(ls->at->u,v)
           else if(SelectedSkeletonAxis == GREEN_AXIS )VECCOPY(ls->at->v,v)
           else if(SelectedSkeletonAxis == YELLOW_AXIS)VECCOPY(ls->at->w,v)
           VECSCALE(1000.0*(double)UNIT2,v,v)
           VECSUM((double)ls->at->xyz,v,v)
           mv4by1(ls->at->t,v,v);
           VECCOPY((long)v,p2)
           arbitrary_rotate(I,ls->at->tp,p2,ltr);
         }
       }
     }
     else{
       null_transform(ltr);   /* do nothing */
     }
     ssp=MainSp; while(ssp != NULL){
       sp=ssp; while(sp != NULL){
         if(sp == LastSkeletonVertex){
           m4by4(ltr,ssp->t,sst);
           c4to4(sst,ssp->t);
           break;
         }
         sp=sp->at;
       }
       ssp=ssp->last;
     }
     DrawModel();
     if(ghwndOpenGLview == NULL)Draw3dView(0,0);
     UpdateWindow(ghwnd_view);
   }
   evTime=GetTickCount()+TIME_DELAY;
 }
 while (GetAsyncKeyState(VK_LBUTTON) & 0x8000);
 return;
}

static void DrawTrSkeletonAxes(skel *sp,int view,int sh1,int sv1, HDC hDC){
 HPEN holdPen=NULL;
 int i,j,draw,draw_red,draw_green,draw_yellow;
 vector vpu,vpv,vpw;
 point pu,pv,pw;
 double s,x,y,z;
 long ix,iy,iz;
 int sh2,sv2,sh[8],sv[8];
 draw_red=NO; draw_green=NO; draw_yellow=NO;
 if(sp == SkSelectedNode1){
   if(SelectedSkeletonAxis == RED_AXIS   )draw_red=YES;
   if(SelectedSkeletonAxis == GREEN_AXIS )draw_green=YES;
   if(SelectedSkeletonAxis == YELLOW_AXIS)draw_yellow=YES;
   s=(double)TVsizeX/10;
   draw=YES;
   holdPen=SelectObject(hDC,ghSelectedPen);
 }
 else if(sp == SkSelectedNode2){
   if(SelectedSkeletonAxis == NODE_AXIS){
     holdPen=SelectObject(hDC,ghSelectedPen);
     draw_green=YES;
   }
   s=(double)TVsizeX/15;
   draw=YES;
 }
 else{
   s=(double)TVsizeX/15;
   draw=NO;
 }
 if(draw){
   for(i=0;i<3;i++){
     vpu[i]=(s * sp->u[i]) + (double)sp->xyz[i];
     vpv[i]=(s * sp->v[i]) + (double)sp->xyz[i];
     vpw[i]=(s * sp->w[i]) + (double)sp->xyz[i];
   }
   m4by1(sp->t,vpu[0],vpu[1],vpu[2],&x,&y,&z);
   pu[0]=(long)x; pu[1]=(long)y; pu[2]=(long)z;
   m4by1(sp->t,vpv[0],vpv[1],vpv[2],&x,&y,&z);
   pv[0]=(long)x; pv[1]=(long)y; pv[2]=(long)z;
   m4by1(sp->t,vpw[0],vpw[1],vpw[2],&x,&y,&z);
   pw[0]=(long)x; pw[1]=(long)y; pw[2]=(long)z;
   GetWindowCoords(view,pu[0],pu[1],pu[2],&sh2,&sv2);
   if(draw_red == YES){
     MoveToEx(hDC,sh2,sv2,NULL); LineTo(hDC,sh1,sv1);
     Ellipse(hDC,sh2-2,sv2-2,sh2+3,sv2+3);
   }
   GetWindowCoords(view,pv[0],pv[1],pv[2],&sh2,&sv2);
   if(draw_green == YES){
     MoveToEx(hDC,sh2,sv2,NULL); LineTo(hDC,sh1,sv1);
     Ellipse(hDC,sh2-2,sv2-2,sh2+3,sv2+3);
   }
   GetWindowCoords(view,pw[0],pw[1],pw[2],&sh2,&sv2);
   if(draw_yellow == YES){
     MoveToEx(hDC,sh2,sv2,NULL); LineTo(hDC,sh1,sv1);
     Ellipse(hDC,sh2-2,sv2-2,sh2+3,sv2+3);
   }
 }
 if(holdPen != NULL)SelectObject(hDC,holdPen);
 for(i=0;i<8;i++){
   m4by1(sp->t,(double)(sp->bx[i][0]),
               (double)(sp->bx[i][1]),
               (double)(sp->bx[i][2]),&x,&y,&z);
   GetWindowCoords(view,(long)x,(long)y,(long)z,&sh[i],&sv[i]);
 }
 if(sh[0] == sh1 &&    /* if box is zero size quit */
    sv[0] == sv1 &&
    sh[1] == sh1 &&
    sv[1] == sv1 &&
    sh[4] == sh1 &&
    sv[4] == sv1)return;
 for(i=0;i<12;i++){
   MoveToEx(hDC,sh[ep1[i]],sv[ep1[i]],NULL);
   LineTo(hDC,sh[ep2[i]],sv[ep2[i]]);
 }
 return;
}

void DrawTrSkeletonInOne(HDC hDC, int view){
 HBRUSH holdBrush;
 HPEN   holdPen,holdPen1;
 int sh1,sv1,sh2,sv2,i;
 double x,y,z;
 skel *sp;
 if(Nskel == 0 || MainSp == NULL)return;
 holdPen=SelectObject(hDC,ghEdgePen);
 holdBrush=SelectObject(hDC,GetStockObject(HOLLOW_BRUSH));
 SelectPalette(hDC,ghpaletteScreen,FALSE);
 RealizePalette(hDC);
 sp=MainSp;
 while(sp != NULL){
   m4by1(sp->t,(double)(sp->xyz[0]),(double)(sp->xyz[1])
              ,(double)(sp->xyz[2]),&x,&y,&z);
   sp->tp[0]=(long)x; sp->tp[1]=(long)y; sp->tp[2]=(long)z;
   sp=sp->last;
 }
 sp=MainSp;
 while(sp != NULL){
  if(skintriview(sp->tp) || (sp->at != NULL && skintriview(sp->at->tp))){
    GetWindowCoords(view,sp->tp[0],sp->tp[1],sp->tp[2],&sh1,&sv1);
    if(sp->at != NULL){
      GetWindowCoords(view,sp->at->tp[0],
                      sp->at->tp[1],sp->at->tp[2],&sh2,&sv2);
      MoveToEx(hDC,sh1,sv1,NULL); LineTo(hDC,sh2,sv2);
    }
    if(sp == LastSkeletonVertex)holdPen1=SelectObject(hDC,ghInvertPen);
    if(sp == FirstSp)Rectangle(hDC,sh1-4,sv1-4,sh1+5,sv1+5);
    else Ellipse(hDC,sh1-3,sv1-3,sh1+4,sv1+4);
    if(sp == LastSkeletonVertex)SelectObject(hDC,holdPen1);
    DrawTrSkeletonAxes(sp,view,sh1,sv1,hDC);
  }
  sp=sp->last;
 }
 SelectObject(hDC,holdPen);
 SelectObject(hDC,holdBrush);
}

static void DrawSkeletonAxes(skel *sp,int view,int sh1,int sv1, HDC hDC){
 HPEN holdPen;
 point pu,pv,pw;
 double s;
 int i,sh2,sv2;
 if(sp == SkSelectedNode1)s=(double)TVsizeX/5;
 else                     s=(double)TVsizeX/20;
 for(i=0;i<3;i++){
   pu[i]=(long)(s * sp->u[i]) + sp->xyz[i];
   pv[i]=(long)(s * sp->v[i]) + sp->xyz[i];
   pw[i]=(long)(s * sp->w[i]) + sp->xyz[i];
 }
 holdPen=SelectObject(hDC,ghSelectorPen);
 GetWindowCoords(view,pu[0],pu[1],pu[2],&sh2,&sv2);
 MoveToEx(hDC,sh1,sv1,NULL); LineTo(hDC,sh2,sv2);
 SelectObject(hDC,ghDeselectorPen);
 GetWindowCoords(view,pw[0],pw[1],pw[2],&sh2,&sv2);
 MoveToEx(hDC,sh1,sv1,NULL); LineTo(hDC,sh2,sv2);
 SelectObject(hDC,holdPen);
}

static void DrawSkeletonRubberBone(skel *sp1, int view, HDC hDC){
 HPEN holdPen;
 int sh1,sv1,sh2,sv2,dx,dy;
 skel *sp;
 sp=sp1;
 holdPen=SelectObject(hDC,ghDeselectorPen);
 GetWindowCoords(view,sp->xyz[0],sp->xyz[1],sp->xyz[2],&sh1,&sv1);
 if(view == TRITOP)       GetWindowCoords(view,sp->xyz[0]+(long)(sp->wrange*ruler),sp->xyz[1],sp->xyz[2],&sh2,&sv2);
 else if(view == TRIFRONT)GetWindowCoords(view,sp->xyz[0]+(long)(sp->wrange*ruler),sp->xyz[1],sp->xyz[2],&sh2,&sv2);
 else if(view == TRIRIGHT)GetWindowCoords(view,sp->xyz[0],sp->xyz[1]+(long)(sp->wrange*ruler),sp->xyz[2],&sh2,&sv2);
 dy=dx=sh2-sh1; 
 Ellipse(hDC,sh1-dx,sv1-dy,sh1+dx,sv1+dy);
 if((sp=sp1->at) != NULL && fabs(sp->wrange-sp1->wrange) > 0.1){
   GetWindowCoords(view,sp->xyz[0],sp->xyz[1],sp->xyz[2],&sh1,&sv1);
   if(view == TRITOP)       GetWindowCoords(view,sp->xyz[0]+(long)(sp1->wrange*ruler),sp->xyz[1],sp->xyz[2],&sh2,&sv2);
   else if(view == TRIFRONT)GetWindowCoords(view,sp->xyz[0]+(long)(sp1->wrange*ruler),sp->xyz[1],sp->xyz[2],&sh2,&sv2);
   else if(view == TRIRIGHT)GetWindowCoords(view,sp->xyz[0],sp->xyz[1]+(long)(sp->wrange*ruler),sp->xyz[2],&sh2,&sv2);
   dy=dx=sh2-sh1; 
   Ellipse(hDC,sh1-dx,sv1-dy,sh1+dx,sv1+dy);
 }
 // Edges??
 SelectObject(hDC,holdPen);
}

void DrawSkeletonInOne(HDC hDC, int view){
 HBRUSH holdBrush;
 HPEN   holdPen;
 int    oldROP;
 int sh1,sv1,sh2,sv2,i;
 skel *sp;
 holdPen=SelectObject(hDC,ghInvertPen);
 holdBrush=SelectObject(hDC,GetStockObject(HOLLOW_BRUSH));
 oldROP=SetROP2(hDC,R2_XORPEN);
 SelectPalette(hDC,ghpaletteScreen,FALSE);
 RealizePalette(hDC);
 DrawOne3dCursor(hDC,view);
 sp=MainSp;
 while(sp != NULL){
  if(skintriview(sp->xyz) || (sp->at != NULL && skintriview(sp->at->xyz))){
    GetWindowCoords(view,sp->xyz[0],sp->xyz[1],sp->xyz[2],&sh1,&sv1);
    if(sp->at != NULL){
      GetWindowCoords(view,sp->at->xyz[0],
                      sp->at->xyz[1],sp->at->xyz[2],&sh2,&sv2);
      MoveToEx(hDC,sh1,sv1,NULL); LineTo(hDC,sh2,sv2);
    }
    if(sp == FirstSp)Rectangle(hDC,sh1-4,sv1-4,sh1+5,sv1+5);
    else             Ellipse(hDC,sh1-3,sv1-3,sh1+4,sv1+4);
    DrawSkeletonAxes(sp,view,sh1,sv1,hDC);
    DrawSkeletonRubberBone(sp,view,hDC);
  }
  sp=sp->last;
 }
 DrawOne3dCursor(hDC,view);
 SelectObject(hDC,holdPen);
 SelectObject(hDC,holdBrush);
 SetROP2(hDC,oldROP);
}

void TidyUpOldSkeltonType(void){
 skel *sp;
 if((sp=FirstSp) != NULL)while(sp != NULL){
   DefaultOrientAxes(sp);
   GetSkeletonBoundBox(sp,0); /* do NOT assign */
   sp=sp->next;
 }
}

void TabSkeletonAxis(void){
  SelectedSkeletonAxis++;
  if(SelectedSkeletonAxis > 3)SelectedSkeletonAxis=0;
  DrawModel();
}

void SkToolOn(void){
 LastSkeletonVertex=NULL;
 SkSelectedNode1=NULL; SkSelectedNode2=NULL;
 if(tool == SKANIMATE){
   short i;
   skel *sp;
   if((sp=MainSp) != NULL)while(sp != NULL){
     null_transform(sp->t);
     for(i=0;i<3;i++)sp->tp[i]=sp->xyz[i];
     sp=sp->last;
   }
   Save_Undo(1);
 }
 else if(tool == SKRUBBERBONES)Save_Undo(1);
}

void SkToolOff(void){
 LastSkeletonVertex=NULL;
 SkSelectedNode1=NULL; SkSelectedNode2=NULL;
 if(tool == SKANIMATE){
   int i;
   double x,y,z;
   vector p;
   skel *sp;
   vertex *vp;
   if((sp=MainSp) != NULL)while(sp != NULL){
     for(i=0;i<3;i++)sp->xyz[i]=sp->tp[i];
     sp=sp->last;
   }
   if((vp=MainVp) != NULL && Nvert > 0)for(i=0;i<Nvert;i++){ /* move vertices */
     if(vp->sp != NULL){
       m4by1(vp->sp->t,(double)vp->xyz[0],(double)vp->xyz[1]
                      ,(double)vp->xyz[2],&x,&y,&z);
       vp->xyz[0]=(long)x; vp->xyz[1]=(long)y; vp->xyz[2]=(long)z;
     }
     vp++;
   }
   if((sp=MainSp) != NULL)while(sp != NULL){ /* move axes and bounding box */
     for(i=0;i<8;i++){
       m4by1(sp->t,(double)sp->bx[i][0],(double)sp->bx[i][1]
                  ,(double)sp->bx[i][2],&x,&y,&z);
       sp->bx[i][0]=(long)x; sp->bx[i][1]=(long)y; sp->bx[i][2]=(long)z;
     }
     VECSCALE((double)UNIT2*1000.0,sp->u,p) VECSUM(p,(double)sp->xyz,p)
     m4by1(sp->t,p[0],p[1],p[2],&(sp->u[0]),&(sp->u[1]),&(sp->u[2]));
     VECSUB(sp->u,(double)sp->xyz,sp->u) O_normalize(sp->u);
     VECSCALE((double)UNIT2*1000.0,sp->v,p) VECSUM(p,(double)sp->xyz,p)
     m4by1(sp->t,p[0],p[1],p[2],&(sp->v[0]),&(sp->v[1]),&(sp->v[2]));
     VECSUB(sp->v,(double)sp->xyz,sp->v) O_normalize(sp->v);
     VECSCALE((double)UNIT2*1000.0,sp->w,p) VECSUM(p,(double)sp->xyz,p)
     m4by1(sp->t,p[0],p[1],p[2],&(sp->w[0]),&(sp->w[1]),&(sp->w[2]));
     VECSUB(sp->w,(double)sp->xyz,sp->w) O_normalize(sp->w);
     sp=sp->last;
   }
 }
}

void SkToolDown(int x, int y){
 SkMovedFlag=FALSE;
 if(tool == SKADD){
   SkAssNode=NULL;
   if(LastSkeletonVertex != NULL){
     LastSkeletonPoint[0]=NpointerX;
     LastSkeletonPoint[1]=NpointerY;
     LastSkeletonPoint[2]=NpointerZ;
     DrawRubber3dLine(LastSkeletonPoint,LastSkeletonVertex->xyz);
   }
   else{  // if not selected
     LastSkeletonVertex=PickSkeleton(x,y,ActiveView);
     if(LastSkeletonVertex != NULL){
       LastSkeletonPoint[0]=NpointerX;
       LastSkeletonPoint[1]=NpointerY;
       LastSkeletonPoint[2]=NpointerZ;
       DrawRubber3dLine(LastSkeletonPoint,LastSkeletonVertex->xyz);
     }
   }
 }
 else if(tool == SKGRAB){
   LastSkeletonVertex=NULL;
   if(!(GetAsyncKeyState(VK_CONTROL) & 0x8000))
     LastSkeletonVertex=PickSkeleton(x,y,ActiveView);
 }
 else if(tool == SKRENAME){
   LastSkeletonVertex=NULL;
   if(!(GetAsyncKeyState(VK_CONTROL) & 0x8000))
     LastSkeletonVertex=PickSkeleton(x,y,ActiveView);
 }
 else if(tool == SKRUBBERBONES){
   skel *sp;
   int i; 
   LastSkeletonVertex=NULL;
   if(GetKeyState(VK_MENU) & 0x8000)SkRubberBonesRotate=TRUE;
   LastSkeletonVertex=PickSkeleton(x,y,ActiveView);
   sp=MainSp;
   while(sp != NULL){
     VECCOPY(sp->xyz,sp->xyz_last);
     null_transform(sp->t);
     null_transform(sp->tr);  // cumulated transform for moving rubber bones
     for(i=0;i<3;i++)sp->tp[i]=sp->xyz[i];
     sp=sp->last;
   }
 }
 else if(tool == SKTWIST){
   LastSkeletonVertex=NULL;
   if(!(GetAsyncKeyState(VK_CONTROL) & 0x8000))
     LastSkeletonVertex=PickSkeleton(x,y,ActiveView);
   if(LastSkeletonVertex != NULL){
     DrawSkeleton(); SkSelectedNode1=LastSkeletonVertex; DrawSkeleton();
   }
 }
 else if(tool == SKDUPLICATE || tool == SKSELECT){
   LastSkeletonVertex=NULL;
   if(!(GetAsyncKeyState(VK_CONTROL) & 0x8000))SkToolAction(x,y); 
 }
 else if(tool == SKDELETE || tool == SKSUBDIV || tool == SKASSIGN){
   LastSkeletonVertex=NULL;
   if(!(GetAsyncKeyState(VK_CONTROL) & 0x8000))SkToolAction(x,y);
 }
 else if(tool == SKANIMATE){
   long x1,y1,z1;
   skel *sp,*sf;
   double d,dmin,dth;
   int sho,svo;
   sp=MainSp;  sf=NULL;
   dmin=(double)TVsizeX*(double)TVsizeX;
   dth=dmin/32/32;
   while(sp != NULL){
     GetWindowCoords(ActiveView,sp->tp[0],sp->tp[1],sp->tp[2],&sho,&svo);
     if( (sho > x-4) && (sho < x+4) && (svo > y-4) && (svo < y+4)){
       d=(double)(sp->tp[0]-NpointerX)*(double)(sp->tp[0]-NpointerX)
        +(double)(sp->tp[1]-NpointerY)*(double)(sp->tp[1]-NpointerY)
        +(double)(sp->tp[2]-NpointerZ)*(double)(sp->tp[2]-NpointerZ);
       if(d < dmin){
         dmin=d;
         sf=sp;
       }
     }
     sp=sp->last;
   }
   if(sf != NULL){
     LastSkeletonVertex=sf;
     if(sf->at != NULL){
       SkSelectedNode1=sf->at;
       SkSelectedNode2=sf;
     }
     else{
       SkSelectedNode1=sf;
       SkSelectedNode2=NULL;
     }
     DrawModel();
   }
 }
}

void SkToolUp(int x, int y){
 if(tool == SKADD){
   if(LastSkeletonVertex != NULL){
     LastSkeletonPoint[0]=NpointerX;  // Draw it away
     LastSkeletonPoint[1]=NpointerY;
     LastSkeletonPoint[2]=NpointerZ;
     DrawRubber3dLine(LastSkeletonPoint,LastSkeletonVertex->xyz);
     if(SkMovedFlag && !(GetAsyncKeyState(VK_CONTROL) & 0x8000)){
                       //     DrawRubber3dLine(LastSkeletonPoint,LastSkeletonVertex->xyz);
       SkToolAction(x,y); // make the node!!
     }
   }
   if(SkAssNode != NULL){
     DrawSkeleton();
     Read1String3Real("Bone Properties","Name","Weight","Range(Ruler)","Zone(Ruler)",SkAssNode->name,
                      &(SkAssNode->weight),&(SkAssNode->wrange),&(SkAssNode->wzone),ghwnd_main);
     DrawSkeleton();
     SkAssNode=NULL;
   }
 }
 else if(tool == SKRENAME){
   if(LastSkeletonVertex != NULL){
     DrawSkeleton();
     Read1String3Real("Bone Properties","Name","Weight","Range (Ruler)","Zone(Ruler)",LastSkeletonVertex->name,
                      &(LastSkeletonVertex->weight),&(LastSkeletonVertex->wrange),&(LastSkeletonVertex->wzone),ghwnd_main);
     DrawSkeleton();
   }
   LastSkeletonVertex=NULL;
 }
 else if(tool == SKGRAB){
   LastSkeletonVertex=NULL;
 }
 else if(tool == SKRUBBERBONES){ // Apply the deformation 
   LastSkeletonVertex=NULL;
   if(SkRubberBonesRotate)RubberBonesDeform(); 
   else                   RubberBonesDeform();
   SkRubberBonesRotate=FALSE;
   DrawModel();
   if(ghwndOpenGLview == NULL)Draw3dView(0,0);
   else PostMessage(ghwndOpenGLview,(WM_USER+2),0,0);
 }
 else if(tool == SKTWIST){
   LastSkeletonVertex=NULL;
   if(SkSelectedNode1 != NULL){
     DrawSkeleton(); SkSelectedNode1=NULL; DrawSkeleton();
   }
   SkSelectedNode1=NULL;
 }
 else if(tool == SKDUPLICATE && LastSkeletonVertex != NULL){
   LastSkeletonVertex=NULL;
 }
 else if(tool == SKSELECT && LastSkeletonVertex != NULL){
   int op1,op2;
   if(GetAsyncKeyState(VK_SHIFT) & 0x8000)op1=DESELECTED;
   else                                   op1=SELECTED;
   if(GetAsyncKeyState(VK_CONTROL) & 0x8000)op2=1;
   else                                     op2=0;
   SelectBySk(LastSkeletonVertex,op1,op2);
   LastSkeletonVertex=NULL;
 }
}

void SkToolMove(int x, int y){
 SkMovedFlag=TRUE;
 if(tool != SKTWIST && tool != SKANIMATE)Move3dCursor(0,x,y);
 if(tool == SKADD){
   if(LastSkeletonVertex != NULL){
     DrawRubber3dLine(LastSkeletonPoint,LastSkeletonVertex->xyz);
     LastSkeletonPoint[0]=NpointerX;
     LastSkeletonPoint[1]=NpointerY;
     LastSkeletonPoint[2]=NpointerZ;
     DrawRubber3dLine(LastSkeletonPoint,LastSkeletonVertex->xyz);
   }
 }
 else if(tool == SKGRAB){
   if(LastSkeletonVertex != NULL){
     skel *sp,*ssp,*fp;
     long x1,y1,z1,dx,dy,dz;
     DrawSkeleton();
     GetWorldCoords(ActiveView,&x1,&y1,&z1,x,y);
     sp=LastSkeletonVertex;
     if     (ActiveView == TRITOP  )z1=sp->xyz[2];
     else if(ActiveView == TRIFRONT)y1=sp->xyz[1];
     else if(ActiveView == TRIRIGHT)x1=sp->xyz[0];
     dx=x1-sp->xyz[0]; dy=y1-sp->xyz[1]; dz=z1-sp->xyz[2];
     if(GetAsyncKeyState(VK_SHIFT) & 0x8000){ /* drag all attached */
       ssp=MainSp; while(ssp != NULL){
         fp=ssp; while(fp != NULL){
           if(fp == sp){
             ssp->xyz[0] += dx; ssp->xyz[1] += dy; ssp->xyz[2] += dz;
             break;
           }
           fp=fp->at;
         }
         ssp=ssp->last;
       }
       DefaultOrientAxes(sp);
       GetSkeletonBoundBox(sp,0);
     }
     else{
       sp->xyz[0]=x1; sp->xyz[1]=y1; sp->xyz[2]=z1;
       ssp=MainSp; while(ssp != NULL){
         fp=ssp; while(fp != NULL){
           if(fp == sp){
             DefaultOrientAxes(ssp);
             GetSkeletonBoundBox(sp,0);
             break;
           }
           fp=fp->at;
         }
         ssp=ssp->last;
       }
     }
     DrawSkeleton();
   }
 }
 else if(tool == SKRUBBERBONES){ 
   if(SkRubberBonesRotate){   // Rotate this bone about parent in this window
     SkRotateRubberBones();
   }
   else if(LastSkeletonVertex != NULL){
     skel *sp,*ssp,*fp;
     long x1,y1,z1,dx,dy,dz;
     DrawSkeleton();
     GetWorldCoords(ActiveView,&x1,&y1,&z1,x,y);
     sp=LastSkeletonVertex;
     if     (ActiveView == TRITOP  )z1=sp->xyz[2];
     else if(ActiveView == TRIFRONT)y1=sp->xyz[1];
     else if(ActiveView == TRIRIGHT)x1=sp->xyz[0];
     dx=x1-sp->xyz[0]; dy=y1-sp->xyz[1]; dz=z1-sp->xyz[2];
     if(GetAsyncKeyState(VK_SHIFT) & 0x8000){ /* drag all attached */
       ssp=MainSp; while(ssp != NULL){
         fp=ssp; while(fp != NULL){
           if(fp == sp){
             ssp->xyz[0] += dx; ssp->xyz[1] += dy; ssp->xyz[2] += dz;
             break;
           }
           fp=fp->at;
         }
         ssp=ssp->last;
       }
       DefaultOrientAxes(sp); // may need changed if rotation
       GetSkeletonBoundBox(sp,0);
     }
     else if(GetAsyncKeyState(VK_CONTROL) & 0x8000){ /* move bone and parent */
       sp->xyz[0]=x1; sp->xyz[1]=y1; sp->xyz[2]=z1;
       if((ssp=sp->at) !=NULL){ ssp->xyz[0] += dx; ssp->xyz[1] += dy; ssp->xyz[2] += dz;}
       ssp=MainSp; while(ssp != NULL){
         fp=ssp; while(fp != NULL){
           if(fp == sp){
             DefaultOrientAxes(ssp);
             GetSkeletonBoundBox(sp,0);
             break;
           }
           fp=fp->at;
         }
         ssp=ssp->last;
       }
     }
     else{
       sp->xyz[0]=x1; sp->xyz[1]=y1; sp->xyz[2]=z1;
       ssp=MainSp; while(ssp != NULL){
         fp=ssp; while(fp != NULL){
           if(fp == sp){
             DefaultOrientAxes(ssp);
             GetSkeletonBoundBox(sp,0);
             break;
           }
           fp=fp->at;
         }
         ssp=ssp->last;
       }
     }
     DrawSkeleton();
   }
 }
 else if(tool == SKTWIST){
   if(LastSkeletonVertex != NULL)SkTwist();
   else Move3dCursor(0,x,y);
 }
 else if(tool == SKANIMATE){
   if(LastSkeletonVertex != NULL)SkPivot();
   else Move3dCursor(0,x,y);
 }
}

void SkToolAction(int x, int y){
 if(tool == SKADD){
   if(LastSkeletonVertex != NULL){
//     DrawRubber3dLine(LastSkeletonPoint,LastSkeletonVertex->xyz);
     DrawSkeleton();
     if(IsWindow(ghwndSkEdit)){
       MessageBeep(MB_OK);
       LastSkeletonVertex=NULL;
       SkAssNode=MainSp;
     }
     else{
       CreateSkeleton(LastSkeletonVertex);
       LastSkeletonVertex=NULL;
       DefaultOrientAxes(MainSp);
       GetSkeletonBoundBox(MainSp,0);
       SkAssNode=MainSp;
     }
     DrawSkeleton();
     while(GetAsyncKeyState(VK_LBUTTON) & 0x8000 ||
           GetAsyncKeyState(VK_RBUTTON) & 0x8000){;}
   }
   else{
//     LastSkeletonVertex=PickSkeleton(x,y,ActiveView);
   }
//   if(LastSkeletonVertex != NULL){
//     LastSkeletonPoint[0]=NpointerX;
//     LastSkeletonPoint[1]=NpointerY;
//     LastSkeletonPoint[2]=NpointerZ;
//     DrawRubber3dLine(LastSkeletonPoint,LastSkeletonVertex->xyz);
//   }
 }
 else if(tool == SKGRAB){
//   if(LastSkeletonVertex == NULL){
//     LastSkeletonVertex=PickSkeleton(x,y,ActiveView);
//   }
 }
 else if(tool == SKTWIST){
//   if(LastSkeletonVertex == NULL){
//     LastSkeletonVertex=PickSkeleton(x,y,ActiveView);
//     if(LastSkeletonVertex != NULL){
//       DrawSkeleton(); SkSelectedNode1=LastSkeletonVertex; DrawSkeleton();
//     }
//   }
 }
 else if(tool == SKDELETE){
   if(IsWindow(ghwndSkEdit))MessageBeep(MB_OK);
   else{
     LastSkeletonVertex=PickSkeleton(x,y,ActiveView);
     if(LastSkeletonVertex != NULL && LastSkeletonVertex != FirstSp){
       DrawSkeleton();
       SkDelete(LastSkeletonVertex);
       DrawSkeleton();
     }
     LastSkeletonVertex=NULL;
   }
 }
 else if(tool == SKSUBDIV){
   long l,nx,ny,nz;
   skel *sp,*tsp,*ssp;
   vertex *vp;
   if(IsWindow(ghwndSkEdit))MessageBeep(MB_OK);
   else{
     if((sp=PickSkeleton(x,y,ActiveView)) != NULL){
       DrawSkeleton();
       if(sp == FirstSp){  // we have picked the root so add a node at the root
         tsp=MainSp;
         CreateSkeleton(FirstSp); // Create a new Skeleton point pointing at the root
         VECCOPY(FirstSp->xyz,MainSp->xyz)
         ssp=tsp; while(ssp != NULL){
           if(ssp->at == FirstSp)ssp->at=MainSp; // re-vector to new intermediate point
           ssp=ssp->last;
         }
         if((vp=MainVp) != NULL)for(l=0;l<Nvert;l++,vp++){
           if(vp->sp == FirstSp)vp->sp=MainSp;  // re-assing any vertices pointing at Main
         }
       }
       else{
         nx=(sp->xyz[0]+sp->at->xyz[0])/2;
         ny=(sp->xyz[1]+sp->at->xyz[1])/2;
         nz=(sp->xyz[2]+sp->at->xyz[2])/2;
         CreateSkeleton(sp->at); /* new node point at what sp used to point to */
         sp->at = MainSp;        /* point at new node */
         MainSp->xyz[0]=nx;
         MainSp->xyz[1]=ny;
         MainSp->xyz[2]=nz;
         DefaultOrientAxes(MainSp);
         ZeroSkeletonBoundingBox(MainSp);
       }
       DrawSkeleton();
     }
   }
 }
 else if(tool == SKASSIGN){
   skel   *sp;
   if((sp=PickSkeleton(x,y,ActiveView)) != NULL){
      GetSkeletonBoundBox(sp,1);
      FlashWindow(ghwnd_main,TRUE);
      SendPrgmMessage(IDS_OK,1);
   }
 }
 else if(tool == SKSELECT){
   LastSkeletonVertex=NULL;
   if((LastSkeletonVertex=PickSkeleton(x,y,ActiveView)) != NULL)
      FlashWindow(ghwnd_main,TRUE);
 }
 else if(tool == SKDUPLICATE){
   long delta;
   skel *sp;
   BOOL bContinue;
   LastSkeletonVertex=NULL;
   if((sp=PickSkeleton(x,y,ActiveView)) != NULL){
     if(sp == FirstSp)FlashWindow(ghwnd_main,TRUE);  // can't duplicate root
     else {
       DrawSkeleton();
       delta=TVsizeX / 10.0;
       CreateSkeleton(sp->at); 
       MainSp->xyz[0]=sp->xyz[0]+delta;
       MainSp->xyz[1]=sp->xyz[1];
       MainSp->xyz[2]=sp->xyz[2];
       strcpy(MainSp->name,sp->name); strcat(MainSp->name,"_c");
       DefaultOrientAxes(MainSp);
       ZeroSkeletonBoundingBox(MainSp);
       DuplicateSkeletonChildren(sp,MainSp,MainSp,delta); 
       DrawSkeleton();
     }
   }
 }
}

static void DuplicateSkeletonChildren(skel *from, skel *to, skel *OldMainSp, long delta){
 skel *sp;
 sp=FirstSp->next; while(sp != OldMainSp){
   if(sp->at == from){
     CreateSkeleton(to); 
     MainSp->xyz[0]=sp->xyz[0]+delta;
     MainSp->xyz[1]=sp->xyz[1];
     MainSp->xyz[2]=sp->xyz[2];
     strcpy(MainSp->name,sp->name); strcat(MainSp->name,"_c");
     DefaultOrientAxes(MainSp);
     DuplicateSkeletonChildren(sp,MainSp,OldMainSp,delta);    
   }
   sp=sp->next;
 }
}


// Skeleton TREEVIEW code ////////////////////////////////////////////////////////////////

#define ptrNMHDR       ((LPNMHDR)lparam)
#define ptrNM_TREEVIEW ((NM_TREEVIEW *)lparam)
#define ptrTV_DISPINFO ((TV_DISPINFO *)lparam)

#define IDM_SKTB_ADD          100
#define IDM_SKTB_INSERT       101
#define IDM_SKTB_DELETE       102
#define IDM_SKTB_SELECT       103
#define IDM_SKTB_DESELECT     104
#define IDM_SKTB_HIDE         105
#define IDM_SKTB_UNHIDE       106
#define IDM_SKTB_ASSIGN       107
#define IDM_SKTB_DEASSIGN     108

static PSTR        lpszSkTreeViewClass="SkTreeViewClass";
static HWND        hWndTreeView=NULL;
static HWND        hTBWnd=NULL;
static HIMAGELIST  hCoasterImageList=NULL;

#define NTOOLBARBUTTONS 13

static TBBUTTON tbb[NTOOLBARBUTTONS] = {
          {3,IDM_SKTB_SELECT,       TBSTATE_ENABLED,TBSTYLE_BUTTON,0,0 },
          {4,IDM_SKTB_DESELECT,     TBSTATE_ENABLED,TBSTYLE_BUTTON,0,0 },
          {0,0,                     TBSTATE_ENABLED,TBSTYLE_SEP,   0,0 },
          {2,IDM_SKTB_INSERT,       TBSTATE_ENABLED,TBSTYLE_BUTTON|
                                               TBSTYLE_CHECK, 0,0 },
          {0,0,                     TBSTATE_ENABLED,TBSTYLE_SEP,   0,0 },
          {5,IDM_SKTB_HIDE,         TBSTATE_ENABLED,TBSTYLE_BUTTON,0,0 },
          {6,IDM_SKTB_UNHIDE,       TBSTATE_ENABLED,TBSTYLE_BUTTON,0,0 },
          {0,0,                     TBSTATE_ENABLED,TBSTYLE_SEP,   0,0 },
          {7,IDM_SKTB_ASSIGN,       TBSTATE_ENABLED,TBSTYLE_BUTTON,0,0 },
          {8,IDM_SKTB_DEASSIGN,     TBSTATE_ENABLED,TBSTYLE_BUTTON,0,0 },
          {0,0,                     TBSTATE_ENABLED,TBSTYLE_SEP,   0,0 },
          {0,IDM_SKTB_ADD,          TBSTATE_ENABLED,TBSTYLE_BUTTON,0,0 },
          {1,IDM_SKTB_DELETE,       TBSTATE_ENABLED,TBSTYLE_BUTTON,0,0 }
                         };

static HTREEITEM AddTreeViewItem (HWND        hWndTV,
                                  HTREEITEM   hParent,
                                  HTREEITEM   hInsertAfter,
                                  int         iImage,
                                  int         iSelectedImage,
                                  LPSTR       szText,
                                 LPARAM      lParam){
 TV_INSERTSTRUCT       tvIns;
 tvIns.item.mask           = TVIF_TEXT  | TVIF_IMAGE |
                         TVIF_SELECTEDIMAGE | TVIF_PARAM;
 tvIns.item.pszText        = szText;
 tvIns.item.cchTextMax     = sizeof(szText);
 tvIns.item.iImage         = iImage;
 tvIns.item.iSelectedImage = iSelectedImage;
 tvIns.item.lParam         = lParam;
 tvIns.hParent             = hParent;
 tvIns.hInsertAfter        = hInsertAfter;
 return TreeView_InsertItem(hWndTV,&tvIns);
}

static void AddTwigsTo(skel *parent, HWND hWndTV){
 skel *sp;
 HTREEITEM hParent;
 sp=FirstSp;
 while(sp != NULL){
   if(sp->at == parent){
     hParent=(HTREEITEM)(sp->at->lParam);
     sp->lParam=(LPARAM)AddTreeViewItem(hWndTV,hParent,(HTREEITEM)TVI_FIRST,
                                      0,1,
                                      (LPSTR)sp->name,
                                      (LPARAM)sp);
     AddTwigsTo(sp,hWndTV);
   }
   sp=sp->next;
 }
}

static BOOL TreeViewRecursive(skel *spTarget, skel *spDrag){
 skel *sp;
 while(spTarget != NULL){
   if(spTarget == spDrag)return TRUE;
   spTarget=spTarget->at;
 }
 return FALSE;
}

static BOOL TreeviewMenuCommand(HWND hWnd, WORD id){
 long i;
 BOOL bFound;
 vertex *vp;
 skel *sp,*spp;
 HTREEITEM hTarget;
 TV_ITEM  tvi;
 if(id == IDM_SKTB_INSERT){
   SkSelectFlag ^= 1;
   return TRUE;
 }
 if(sktool == YES){MessageBeep(MB_OK); return FALSE;}
 if((hTarget=TreeView_GetSelection(hWndTreeView)) == NULL)return FALSE;
 tvi.mask  = TVIF_PARAM;
 tvi.hItem = hTarget;
 TreeView_GetItem(hWndTreeView,&tvi);
 if((sp=(skel *)tvi.lParam) == NULL)return FALSE;
 switch (id) {
   case IDM_SKTB_ADD:
     CreateSkeleton(sp);
     MainSp->lParam=(LPARAM)AddTreeViewItem(hWndTreeView,hTarget,
                                      (HTREEITEM)TVI_FIRST,
                                      0,1,
                                      (LPSTR)MainSp->name,
                                      (LPARAM)MainSp);
     TreeView_EnsureVisible(hWndTreeView,(HTREEITEM)MainSp->lParam);
     TreeView_SelectItem(hWndTreeView,(HTREEITEM)MainSp->lParam);
     break;
   case IDM_SKTB_DELETE:
     if(sp == FirstSp)break;
     TreeView_DeleteItem(hWndTreeView,hTarget);
     while(1){
       bFound=FALSE;
       spp=FirstSp; while(spp != NULL){
         if(spp != sp && TreeViewRecursive(spp,sp)){
           SkDelete(spp);
           bFound=TRUE;
           goto BKOUT;
         }
         spp=spp->next;
       }
       BKOUT:
       if(!bFound)break;
     }
     SkDelete(sp);
     break;
   case IDM_SKTB_SELECT:
     SelectByHierarchy(sp,1);
     break;
   case IDM_SKTB_DESELECT:
     SelectByHierarchy(sp,2);
     break;
   case IDM_SKTB_HIDE:
     SelectByHierarchy(sp,3);
     break;
   case IDM_SKTB_UNHIDE:
     SelectByHierarchy(sp,4);
     break;
   case IDM_SKTB_ASSIGN:
     GetSkeletonBoundBox(sp,1);
     break;
   case IDM_SKTB_DEASSIGN:
     if((vp=MainVp) != NULL)for(i=0;i<Nvert;i++,vp++){
       if(vp->sp == sp)vp->sp=NULL;
     }
     break;
   default:
     break;
 }
 return TRUE;
}

static BOOL CALLBACK SkTreeViewWndProc(HWND hwnd, UINT msg, WPARAM wparam,
                                    LPARAM lparam ){
 static HIMAGELIST hDragImage=NULL;
 static HTREEITEM  hDragItem=NULL;
 static BOOL       bDragging=FALSE;
 static int ToolbarHeight;
 RECT rc,rc1;
 int dx,dy,x,y,xp,yp,xl,yl;
 DWORD dwStyle;
 skel *sp;
 switch( msg ){
   case WM_PAINT:
     PaintDialogBackground(hwnd,ghinst_main);
     break;
   case WM_INITDIALOG:
     SetClassLong(hwnd,GCL_HICON,
                 (LONG)LoadIcon(ghinst_main,"MODELERICON"));
     xp=GetPrivateProfileInt(IniSection,"SKPOSX",-1,IniFilename);
     yp=GetPrivateProfileInt(IniSection,"SKPOSY",-1,IniFilename);
     xl=GetPrivateProfileInt(IniSection,"SKSIZX",-1,IniFilename);
     yl=GetPrivateProfileInt(IniSection,"SKSIZY",-1,IniFilename);
     if(xp < 0 || yp < 0 || xl < 0 || yl < 0){
       x=200; y=40; dx=248; dy=250;
     }
     else{
       x=xp; y=yp; dx=xl; dy=yl;
     }
     SetWindowPos(hwnd,NULL,x,y,dx,dy,SWP_NOZORDER);
     //RSF   case WM_CREATE:
     dwStyle=WS_CHILD | WS_VISIBLE | WS_BORDER;
     if(Preferences.tooltips)dwStyle = dwStyle | TBSTYLE_TOOLTIPS;
     hTBWnd = CreateToolbarEx(hwnd,dwStyle,
        0,      // control identifier for the toolbar
        9,      // bitmaps images
        ghinst_main,
        IDBM_SKTOOLBAR,
        tbb,
        NTOOLBARBUTTONS,
        16,15,  // size of buttons
        16,15,  // size of bitmap
        sizeof(TBBUTTON)
       );
     if(0){dx=32; dy=32;} else {dx=16; dy=16;}
     hCoasterImageList=ImageList_Create(
                         dx,dy,
                         TRUE,
                         2,
                         5
                         );
     ImageList_AddIcon(hCoasterImageList,
                              LoadIcon(ghinst_main,"TREEVIEWICON0"));
     ImageList_AddIcon(hCoasterImageList,
                              LoadIcon(ghinst_main,"TREEVIEWICON1"));
     GetClientRect(hTBWnd,&rc1); ToolbarHeight=rc1.bottom+1;
     GetClientRect(hwnd,&rc);

     hWndTreeView=GetDlgItem(hwnd,DLG_SKELETON_TREEVIEW);
     SetWindowPos(hWndTreeView,NULL,0,ToolbarHeight,
                  rc.right,rc.bottom-ToolbarHeight,SWP_NOZORDER);
     if(hWndTreeView != NULL){
       TreeView_SetImageList(hWndTreeView,hCoasterImageList,0);
       ImageList_SetBkColor(hCoasterImageList,GetSysColor(COLOR_WINDOW));
       UpdateSkTreeView();
       sp=MainSp; while(sp != NULL){
        if(sp->at == FirstSp){
          TreeView_EnsureVisible(hWndTreeView,(HTREEITEM)(sp->lParam));
          TreeView_Expand(hWndTreeView,(HTREEITEM)(sp->lParam),TVE_EXPAND);
        }
        sp=sp->last;
       }
     }
     return TRUE; //RSF     break;
   case WM_DESTROY:{
       char str[32];
       GetWindowRect(hwnd,&rc);
       sprintf(str,"%ld",rc.left);
       WritePrivateProfileString(IniSection,"SKPOSX",str,IniFilename);
       sprintf(str,"%ld",rc.top);
       WritePrivateProfileString(IniSection,"SKPOSY",str,IniFilename);
       sprintf(str,"%ld",rc.right-rc.left);
       WritePrivateProfileString(IniSection,"SKSIZX",str,IniFilename);
       sprintf(str,"%ld",rc.bottom-rc.top);
       WritePrivateProfileString(IniSection,"SKSIZY",str,IniFilename);
       if(hCoasterImageList != NULL)ImageList_Destroy(hCoasterImageList);
       hCoasterImageList=NULL;
       hWndTreeView=NULL;
       DestroyWindow(hTBWnd);
       hTBWnd=NULL;
     }
     break;
   case WM_SYSCOMMAND:
     switch(LOWORD(wparam & 0xfff0)){
       case SC_CLOSE:
         PostMessage(ghwnd_main,WM_COMMAND,IDM_HIERARCHY_NAME,0);
         break;
       default:
         return FALSE;//RSF         return(DefWindowProc(hwnd,msg,wparam,lparam));
      }
      break;
   case WM_NOTIFY:
     switch (ptrNMHDR->code){
       case TTN_NEEDTEXT:{
           int idButton;
           LPTOOLTIPTEXT lpttt;
           lpttt=(LPTOOLTIPTEXT)lparam;
           lpttt->hinst=ghinst_main;
           idButton=lpttt->hdr.idFrom;
           switch(idButton){
             case IDM_SKTB_ADD:
               lpttt->lpszText=MAKEINTRESOURCE(IDI_TIP_K_1); break;
             case IDM_SKTB_DELETE:
               lpttt->lpszText=MAKEINTRESOURCE(IDI_TIP_K_2); break;
             case IDM_SKTB_INSERT:
               lpttt->lpszText=MAKEINTRESOURCE(IDI_TIP_K_3); break;
             case IDM_SKTB_SELECT:
               lpttt->lpszText=MAKEINTRESOURCE(IDI_TIP_K_4); break;
             case IDM_SKTB_DESELECT:
               lpttt->lpszText=MAKEINTRESOURCE(IDI_TIP_K_5); break;
             case IDM_SKTB_HIDE:
               lpttt->lpszText=MAKEINTRESOURCE(IDI_TIP_K_6); break;
             case IDM_SKTB_UNHIDE:
               lpttt->lpszText=MAKEINTRESOURCE(IDI_TIP_K_7); break;
             case IDM_SKTB_ASSIGN:
               lpttt->lpszText=MAKEINTRESOURCE(IDI_TIP_K_8); break;
             case IDM_SKTB_DEASSIGN:
               lpttt->lpszText=MAKEINTRESOURCE(IDI_TIP_K_9); break;
           }
         }
         break;
       case TVN_BEGINLABELEDIT:
         if ((skel *)ptrTV_DISPINFO->item.lParam == FirstSp)return 1;
         else return 0;  // Allow Editing
       case TVN_ENDLABELEDIT:
         if(ptrTV_DISPINFO->item.pszText != NULL){
           ptrTV_DISPINFO->item.mask = TVIF_TEXT;
           sp=(skel *)ptrTV_DISPINFO->item.lParam;
           strcpy(sp->name,ptrTV_DISPINFO->item.pszText);
           TreeView_SetItem(
                   ptrNMHDR->hwndFrom,      // Handle of TreeView
                   &(ptrTV_DISPINFO->item)  // TV_ITEM structure w/changes
                           );
           return TRUE;
         }
         break;
       case TVN_BEGINDRAG:
         if((skel *)ptrNM_TREEVIEW->itemNew.lParam != FirstSp){
            hDragImage = TreeView_CreateDragImage(
                        ptrNMHDR->hwndFrom,ptrNM_TREEVIEW->itemNew.hItem);
           TreeView_GetItemRect(
                 ptrNMHDR->hwndFrom,            // Handle of TreeView
                 ptrNM_TREEVIEW->itemNew.hItem, // Item in TreeView
                 &rc,                           // RECT to store result
                 FALSE
                 );
           hDragItem = ptrNM_TREEVIEW->itemNew.hItem;
           ImageList_SetDragCursorImage(hDragImage,0,0,0);
           ImageList_BeginDrag(hDragImage,0,0,0);
           ImageList_DragEnter(
                 hWndTreeView,
                 ptrNM_TREEVIEW->ptDrag.x,
                 ptrNM_TREEVIEW->ptDrag.y
                 );
           ImageList_DragShowNolock(TRUE);
           SetCapture(hwnd);
           bDragging=TRUE;
           return 0L;
         }
         break;
       default: break;
     }
     return FALSE; //RSF     return (DefWindowProc(hwnd,msg,wparam,lparam));
   case WM_MOUSEMOVE:
     if(bDragging){
       HTREEITEM       hTarget;
       TV_HITTESTINFO  tvht;
       y=HIWORD(lparam)-ToolbarHeight;
       ImageList_DragMove(LOWORD(lparam),y);
       tvht.pt.x = LOWORD(lparam);
       tvht.pt.y = y;
       if((hTarget = TreeView_HitTest(hWndTreeView,&tvht)) != NULL){
         TV_ITEM  tvi;
         tvi.mask  = TVIF_PARAM;
         tvi.hItem = hTarget;
         TreeView_GetItem(hWndTreeView,&tvi);
         if(hTarget != TreeView_GetDropHilight(hWndTreeView)){
           ImageList_DragShowNolock(FALSE);
           TreeView_SelectDropTarget(hWndTreeView,hTarget);
           ImageList_DragShowNolock(TRUE);
         }
         return 0L;
       }
       if(hTarget != TreeView_GetDropHilight(hWndTreeView)){
         ImageList_DragShowNolock(FALSE);
         TreeView_SelectDropTarget(hWndTreeView,NULL);
         ImageList_DragShowNolock(TRUE);
       }
     }
     break;
   case WM_LBUTTONUP:
     if(bDragging){
       HTREEITEM hTarget;       // Item under mouse
       TV_ITEM   tvi;           // Temporary Item
       skel      *spTarget,*spDrag;
       ImageList_DragLeave(hWndTreeView);
       ImageList_EndDrag();
       ReleaseCapture();
       bDragging = FALSE;
       ImageList_Destroy(hDragImage);
       hDragImage = NULL;
       if((hTarget = TreeView_GetDropHilight(hWndTreeView)) != NULL){
         if(hTarget != hDragItem){
         tvi.mask       = TVIF_PARAM;
         tvi.hItem      = hDragItem;
         TreeView_GetItem(hWndTreeView,&tvi);
         spDrag=(skel *)tvi.lParam;
         tvi.hItem      = hTarget;
         TreeView_GetItem(hWndTreeView,&tvi);
         spTarget=(skel *)tvi.lParam;
         if(sktool == NO && !TreeViewRecursive(spTarget,spDrag)){
           spDrag->at=spTarget;
           TreeView_DeleteItem(hWndTreeView,hDragItem);
           spDrag->lParam=(LPARAM)AddTreeViewItem(hWndTreeView,
                                      (HTREEITEM)spTarget->lParam,
                                      (HTREEITEM)TVI_FIRST,
                                      0,1,
                                      (LPSTR)spDrag->name,
                                      (LPARAM)spDrag);
           AddTwigsTo(spDrag,hWndTreeView);
         }
         else MessageBeep(MB_OK);
         }
       }
       TreeView_SelectDropTarget(hWndTreeView,NULL);
     }
     break;
   case WM_COMMAND:
     //RSF     return  on next line+1
     if(LOWORD(wparam) == IDOK){;}
     else     TreeviewMenuCommand(hwnd,LOWORD(wparam));
     break;
   case WM_SIZE:
     if(hTBWnd != NULL)SendMessage(hTBWnd,msg,wparam,lparam);
     if(hWndTreeView != NULL){
       SetWindowPos(hWndTreeView,NULL,
                    0,ToolbarHeight,
                    LOWORD(lparam),HIWORD(lparam)-ToolbarHeight,
                    SWP_NOZORDER);
     }
   default:
     break; //RSF    return(DefWindowProc(hwnd,msg,wparam,lparam));
 }
 return FALSE; //RSF  return ( 0L );
}

void SkeletonTreeView(HWND hWndParent){
 WNDCLASS   wc;
 HDC        hdc,hdcMem;
 RECT       rc;
 HBITMAP    hbm,hbmold=NULL;
 char       str[32];
 MSG        msg;
 int x,y,dx,dy;
 if(ghwndSkEdit != NULL){
   DestroyWindow(ghwndSkEdit);
   ghwndSkEdit=NULL;
   return;
 }
 ghwndSkEdit=CreateDialog(ghinst_main,MAKEINTRESOURCE(DLG_SKELETON),
                         hWndParent,(DLGPROC)SkTreeViewWndProc);
 UpdateWindow(ghwndSkEdit);
 if(ghwndSkEdit == NULL){
   return;
 }
 SendMessage(hTBWnd,TB_CHECKBUTTON,IDM_SKTB_INSERT,
            (LPARAM)MAKELONG(SkSelectFlag,0));
 return;
}

void UpdateSkTreeView(void){
 if(!IsWindow(hWndTreeView))return;
 TreeView_DeleteItem(hWndTreeView,TVI_ROOT);
 FirstSp->lParam=(LPARAM)AddTreeViewItem(hWndTreeView,
                                         TVI_ROOT,
                                         (HTREEITEM)TVI_FIRST,
                                         0,1,
                                         (LPSTR)FirstSp->name,
                                         (LPARAM)FirstSp);
 AddTwigsTo(FirstSp,hWndTreeView);
}



void SetSkToolbarState(BOOL state){
 int i;
 if(!IsWindow(ghwndSkEdit))return;
 for(i=0;i<NTOOLBARBUTTONS;i++)SendMessage(hTBWnd,
   TB_ENABLEBUTTON,(WPARAM)tbb[i].idCommand,(LPARAM)MAKELONG(state,0));
}

void SkeletonToolBar(HWND hWndParent){
 WNDCLASS   wc;
 HDC        hdc,hdcMem;
 RECT       rc;
 HBITMAP    hbm,hbmold=NULL;
 char       str[32];
 MSG        msg;
 int x,y,dx,dy;
 if(ghwndSkToolbar != NULL){
   DestroyWindow(ghwndSkToolbar);
   ghwndSkToolbar=NULL;
   return;
 }
 ghwndSkToolbar=CreateDialog(ghinst_main,MAKEINTRESOURCE(DLG_SKTOOLBAR),
                         hWndParent,(DLGPROC)SkToolBarDlgProc);
 UpdateWindow(ghwndSkToolbar);
 if(ghwndSkToolbar == NULL){
   return;
 }
 return;
}

static BOOL CALLBACK SkToolBarDlgProc(HWND hwnd, UINT msg, WPARAM wparam,
                                    LPARAM lparam ){
 static TBBUTTON tbtns[10] = {
          {0,DLG_SKTOOLBAR_BUILD,TBSTATE_ENABLED,TBSTYLE_BUTTON|
                                               TBSTYLE_CHECKGROUP, 0,0 },
          {1,DLG_SKTOOLBAR_REPOSITION,TBSTATE_ENABLED,TBSTYLE_BUTTON|
                                               TBSTYLE_CHECKGROUP, 0,0 },
          {2,DLG_SKTOOLBAR_ROTATION,TBSTATE_ENABLED,TBSTYLE_BUTTON|
                                               TBSTYLE_CHECKGROUP, 0,0 },
          {3,DLG_SKTOOLBAR_REMOVE,TBSTATE_ENABLED,TBSTYLE_BUTTON|
                                               TBSTYLE_CHECKGROUP, 0,0 },
          {4,DLG_SKTOOLBAR_INSERT,TBSTATE_ENABLED,TBSTYLE_BUTTON|
                                               TBSTYLE_CHECKGROUP, 0,0 },
          {5,DLG_SKTOOLBAR_ATTACH,TBSTATE_ENABLED,TBSTYLE_BUTTON|
                                               TBSTYLE_CHECKGROUP, 0,0 },
          {6,DLG_SKTOOLBAR_SELECT,TBSTATE_ENABLED,TBSTYLE_BUTTON|
                                               TBSTYLE_CHECKGROUP, 0,0 },
          {7,DLG_SKTOOLBAR_DUPLICATE,TBSTATE_ENABLED,TBSTYLE_BUTTON|
                                               TBSTYLE_CHECKGROUP, 0,0 },
          {8,DLG_SKTOOLBAR_RUBBERBONES,TBSTATE_ENABLED,TBSTYLE_BUTTON|
                                               TBSTYLE_CHECKGROUP, 0,0 },
          {9,DLG_SKTOOLBAR_RENAME,TBSTATE_ENABLED,TBSTYLE_BUTTON|
                                               TBSTYLE_CHECKGROUP, 0,0 }
                         };
 static HWND hWndTools=NULL;
 DWORD dwStyle;
 RECT rc;
 int x,y,xp,yp,id;
 switch( msg ){
   case WM_INITDIALOG:
     xp=GetPrivateProfileInt(IniSection,"SKTOOLBOXPOSX",-1,IniFilename);
     yp=GetPrivateProfileInt(IniSection,"SKTOOLBOXPOSY",-1,IniFilename);
     if(xp < 0 || yp < 0){
       x=200; y=40;
     }
     else{
       x=xp; y=yp;
     }
     dwStyle=WS_CHILD | WS_VISIBLE | WS_BORDER;
     if(Preferences.tooltips)dwStyle = dwStyle | TBSTYLE_TOOLTIPS;
     hWndTools = CreateToolbarEx(hwnd,dwStyle,
        0,      // control identifier for the toolbar
        10,      // bitmaps images
        ghinst_main,
        IDBM_SKTOOLBAR1,
        tbtns,
        10,      // no of buttons
        16,15,  // size of buttons
        16,15,  // size of bitmap
        sizeof(TBBUTTON)
       );
     id=DLG_SKTOOLBAR_BUILD;
     if     (tool == SKGRAB  )       id=DLG_SKTOOLBAR_REPOSITION;
     else if(tool == SKTWIST )       id=DLG_SKTOOLBAR_ROTATION;
     else if(tool == SKDELETE)       id=DLG_SKTOOLBAR_REMOVE;
     else if(tool == SKSUBDIV)       id=DLG_SKTOOLBAR_INSERT;
     else if(tool == SKASSIGN)       id=DLG_SKTOOLBAR_ATTACH;
     else if(tool == SKSELECT)       id=DLG_SKTOOLBAR_SELECT;
     else if(tool == SKDUPLICATE)    id=DLG_SKTOOLBAR_DUPLICATE;
     else if(tool == SKRUBBERBONES ) id=DLG_SKTOOLBAR_RUBBERBONES;
     else if(tool == SKRENAME )      id=DLG_SKTOOLBAR_RENAME;
     SendMessage(hWndTools,TB_CHECKBUTTON,id,MAKELONG(TRUE,0));
     SetWindowPos(hwnd,NULL,x,y,0,0,SWP_NOZORDER|SWP_NOSIZE);
     return TRUE;
   case WM_DESTROY:{
       char str[32];
       GetWindowRect(hwnd,&rc);
       sprintf(str,"%ld",rc.left);
       WritePrivateProfileString(IniSection,"SKTOOLBOXPOSX",str,IniFilename);
       sprintf(str,"%ld",rc.top);
       WritePrivateProfileString(IniSection,"SKTOOLBOXPOSY",str,IniFilename);
       if(hWndTools != NULL)DestroyWindow(hWndTools);
       hWndTools=NULL;
     }
     break;
   case WM_SYSCOMMAND:
     switch(LOWORD(wparam & 0xfff0)){
       case SC_CLOSE:
         PostMessage(ghwnd_main,WM_COMMAND,IDM_STOP,0);
         break;
       default:
         return FALSE;
      }
      break;
   case WM_NOTIFY:
     switch (ptrNMHDR->code){
       case TTN_NEEDTEXT:{
           int idButton;
           LPTOOLTIPTEXT lpttt;
           lpttt=(LPTOOLTIPTEXT)lparam;
           lpttt->hinst=ghinst_main;
           idButton=lpttt->hdr.idFrom;
           switch(idButton){
             case DLG_SKTOOLBAR_BUILD:
               lpttt->lpszText=MAKEINTRESOURCE(IDI_TIP_KT_1); break;
             case DLG_SKTOOLBAR_REPOSITION:
               lpttt->lpszText=MAKEINTRESOURCE(IDI_TIP_KT_2); break;
             case DLG_SKTOOLBAR_ROTATION:
               lpttt->lpszText=MAKEINTRESOURCE(IDI_TIP_KT_3); break;
             case DLG_SKTOOLBAR_REMOVE:
               lpttt->lpszText=MAKEINTRESOURCE(IDI_TIP_KT_4); break;
             case DLG_SKTOOLBAR_INSERT:
               lpttt->lpszText=MAKEINTRESOURCE(IDI_TIP_KT_5); break;
             case DLG_SKTOOLBAR_ATTACH:
               lpttt->lpszText=MAKEINTRESOURCE(IDI_TIP_KT_6); break;
             case DLG_SKTOOLBAR_SELECT:
               lpttt->lpszText=MAKEINTRESOURCE(IDI_TIP_KT_7); break;
             case DLG_SKTOOLBAR_DUPLICATE:
               lpttt->lpszText=MAKEINTRESOURCE(IDI_TIP_KT_8); break;
             case DLG_SKTOOLBAR_RUBBERBONES:
               lpttt->lpszText=MAKEINTRESOURCE(IDI_TIP_KT_9); break;
             case DLG_SKTOOLBAR_RENAME:
               lpttt->lpszText=MAKEINTRESOURCE(IDI_TIP_KT_10); break;
           }
         }
         break;
       default: break;
     }
     return FALSE;
   case WM_COMMAND:
     if(LOWORD(wparam) == IDOK){;}
     else if(LOWORD(wparam) == DLG_SKTOOLBAR_BUILD){
       PostMessage(ghwnd_main,WM_COMMAND,IDM_HIERARCHY_BUILD,0);
     }
     else if(LOWORD(wparam) == DLG_SKTOOLBAR_REPOSITION){
       PostMessage(ghwnd_main,WM_COMMAND,IDM_HIERARCHY_STRETCH,0);
     }
     else if(LOWORD(wparam) == DLG_SKTOOLBAR_ROTATION){
       PostMessage(ghwnd_main,WM_COMMAND,IDM_HIERARCHY_TWIST,0);
     }
     else if(LOWORD(wparam) == DLG_SKTOOLBAR_REMOVE){
       PostMessage(ghwnd_main,WM_COMMAND,IDM_HIERARCHY_REMOVE,0);
     }
     else if(LOWORD(wparam) == DLG_SKTOOLBAR_INSERT){
       PostMessage(ghwnd_main,WM_COMMAND,IDM_HIERARCHY_INSERT,0);
     }
     else if(LOWORD(wparam) == DLG_SKTOOLBAR_ATTACH){
       PostMessage(ghwnd_main,WM_COMMAND,IDM_HIERARCHY_ATTACH,0);
     }
     else if(LOWORD(wparam) == DLG_SKTOOLBAR_SELECT){
       PostMessage(ghwnd_main,WM_COMMAND,IDM_HIERARCHY_SELECT,0);
     }
     else if(LOWORD(wparam) == DLG_SKTOOLBAR_DUPLICATE){
       PostMessage(ghwnd_main,WM_COMMAND,IDM_HIERARCHY_DUPLICATE,0);
     }
     else if(LOWORD(wparam) == DLG_SKTOOLBAR_RUBBERBONES){
       PostMessage(ghwnd_main,WM_COMMAND,IDM_HIERARCHY_RUBBERBONES,0);
     }
     else if(LOWORD(wparam) == DLG_SKTOOLBAR_RENAME){
       PostMessage(ghwnd_main,WM_COMMAND,IDM_HIERARCHY_RENAME,0);
     }
     break;
   default:
     break;
 }
 return FALSE;
}