UTILS.C

Go to the documentation of this file.

/* file UTILS.C */

#define MODULE_UTILS 1

#include "animate.h"

void Nudge(int command){
 int sx,sy,step=1,grabbed=0;
 if(tool == GRABBER || tool == NOTOOL){
   GetWindowCoords(ActiveView,NpointerX,NpointerY,NpointerZ,&sx,&sy);
   if(tool == GRABBER)grabbed=StageGrabIdentify();
   if(GetAsyncKeyState(VK_SHIFT  ) & 0x8000)step=5;
   if(command == IDM_PAN_LEFT) sx -= step; /* use PAN commands as ID's */
   if(command == IDM_PAN_RIGHT)sx += step;
   if(command == IDM_PAN_UP)   sy -= step;
   if(command == IDM_PAN_DOWN) sy += step;
   Draw3dCursor();
   GetWorldCoords(ActiveView,&NpointerX,&NpointerY,&NpointerZ,sx,sy);
   Draw3dCursor();
   if(coords_visible)UpdateRuler(0);
   if(tool == GRABBER && grabbed == 1)StageGrab(2,1); /* do it in the bitmap */
 }
 if(tool == ROTATOR){
   BOOL do_it=FALSE;
   if(command == IDM_PAN_LEFT){
     do_it=TRUE;
     if     (ActiveView == TRIRIGHT)command=IDM_PAN_UP;
     else if(ActiveView == TRIFRONT)command=IDM_ZOOM_OUT;
     else                           command=IDM_PAN_RIGHT;
   }
   else if(command == IDM_PAN_RIGHT){
     do_it=TRUE;
     if     (ActiveView == TRIRIGHT)command=IDM_PAN_DOWN;
     else if(ActiveView == TRIFRONT)command=IDM_ZOOM_IN;
     else                           command=IDM_PAN_LEFT;
   }
   if(do_it)StageStepRotate(command);
 }
}

void ReleaseNurbs(nurbs *n){
 long i;
 if(n->kvU != NULL)X__Free(n->kvU);
 n->kvU = NULL;
 if(n->kvV != NULL)X__Free(n->kvV);
 n->kvV = NULL;
 if(n->points == NULL)return;
 for(i=0;i < n->numV;i++)X__Free(n->points[i]);
 X__Free(n->points);
 n->points=NULL;
 return;
}

BOOL AllocNurbs(nurbs *n, double *ukv, double *vkv){
 long i;
 if(ukv == NULL){
 if((n->kvU = (double *)X__Malloc((n->numU + n->orderU) * sizeof(double)))
   == NULL)return FALSE;
 }
 else n->kvU = ukv;
 if(vkv == NULL){
 if((n->kvV = (double *)X__Malloc((n->numV + n->orderV) * sizeof(double)))
   == NULL)return FALSE;
 }
 else n->kvV = vkv;
 if((n->points = (vector4 **)X__Malloc((long)n->numV
       * (long)sizeof(vector4 *))) == NULL)return FALSE;
 for (i = 0; i < n->numV; i++){
   if((n->points[i] = (vector4 *)X__Malloc((long)n->numU
       * (long)sizeof(vector4))) == NULL)return FALSE;
 }
 return TRUE;
}

void FreeNurbs(long n, nurbs *Np){
 long i;
 if(n == 0 || Np == NULL)return;
 for(i=0;i<n;i++){
   ReleaseNurbs((Np+i));
 }
 X__Free(Np);
 return;
}

pathpoint *AppendPathPoint(pathpoint *Ppp){
/* only used to load path from script or path file and during copy
   no need to ammend the number of pathpoints */
 pathpoint *tp;
 EDIT_ACTION=YES;
 if((tp = (pathpoint *)X__Malloc(sizeof(pathpoint))) == NULL){
   SendPrgmQuery(IDQ_NOMEM1,0);
   return NULL;
 }
 if(Ppp != NULL)Ppp->next=tp;
 tp->last=Ppp;
 tp->next=NULL;
 return tp;
}

PATHEDITCONTROL *CreatePathEditControlPoint(int *nPec,
                 PATHEDITCONTROL **Pec,
                 PATHEDITCONTROL *last,
                 PATHEDITCONTROL *next,
                 int frame, double distance){
 PATHEDITCONTROL *temp,*pe,*pe1;
 if((temp=(PATHEDITCONTROL *)X__Malloc(sizeof(PATHEDITCONTROL))) == NULL){
   if((*Pec) != NULL){ /* free up all path */
     if((pe = *Pec) != NULL)while(pe != NULL){
       pe1=pe; pe=pe->next; X__Free(pe1);
     }
   }
   *nPec=0;
   *Pec=NULL;
   return NULL;
 }
 if(*Pec == NULL)*Pec=temp;  /* The first in the sequence */
 temp->last=last; if(last != NULL)last->next=temp;
 temp->next=next; if(next != NULL)next->last=temp;
 temp->frame=frame;
 temp->distance=distance;
 temp->x=0; temp->y=0;
 *nPec = (*nPec)+1;
 return temp;
}

void DeletePathEditControlPoint(int *nPec,
                 PATHEDITCONTROL **Pec,
                 PATHEDITCONTROL *here){
 if(here->last != NULL)here->last->next=here->next;
 if(here->next != NULL)here->next->last=here->last;
 if(here == *Pec){
   *Pec=here->next;  /* which may be NULL */
 }
 X__Free(here);
 *nPec = (*nPec)-1;
 return;
}

void CreatePathPoint(void){
 int j;
 pathpoint *sp,*tp;
 EDIT_ACTION=YES;
 if(SelectedNode == NULL){
   SendPrgmQuery(IDQ_NOPATH,0);
   return;
 }
 if(SelectedPath == NULL || (sp=SelectedPathPoint) == NULL){
   ; //SendPrgmQuery(IDQ_PATH3,0);
   return;
 }
 DrawInvertNode(ghdc_triview_Bitmap,SelectedNode,EDITING);
 if(sp->next == NULL){
   SendPrgmQuery(IDQ_PATH4,0);
 }
 else if((tp = (pathpoint *)X__Malloc(sizeof(pathpoint))) == NULL){
   SendPrgmQuery(IDQ_NOMEM1,0);
 }
 else{
   tp->last=sp;
   tp->next=sp->next;
   sp->next->last=tp;
   sp->next=tp;
   for(j=0;j<3;j++){
     tp->p[j]=(sp->p[j] + tp->next->p[j])/2;
   }
   tp->ptheta = (sp->ptheta + tp->next->ptheta)/2.0;
   tp->pfi    = (sp->pfi    + tp->next->pfi   )/2.0;
   tp->distance=sp->distance+1.0;
   tp->tension_n=sp->tension_p;
   tp->tension_p=sp->tension_n;
   tp->status=sp->status;
   SelectedPath->npathpoints++;
 }
 SelectedPathPoint=NULL;
 DrawInvertNode(ghdc_triview_Bitmap,SelectedNode,EDITING);
}

void DeletePathPoint(void){
 pathpoint *tp;
 EDIT_ACTION=YES;
 if(SelectedNode == NULL){
   SendPrgmQuery(IDQ_NOPATH,0);
   return;
 }
 else if(SelectedPath == NULL)return;
 DrawInvertNode(ghdc_triview_Bitmap,SelectedNode,EDITING);
 if(SelectedPath->pathtype == CLOSED && SelectedPath->npathpoints < 4){
   SendPrgmQuery(IDQ_PATH5,0);
 }
 else if((tp=SelectedPathPoint) == NULL){
  ; // SendPrgmQuery(IDQ_PATH3,0);
 }
 else if(tp->next == NULL || tp->last == NULL){
   SendPrgmQuery(IDQ_PATH6,0);
 }
 else{
   tp->next->last = tp->last;
   tp->last->next = tp->next;
   X__Free(tp);
   SelectedPath->npathpoints--;
 }
 SelectedPathPoint=NULL;
 DrawInvertNode(ghdc_triview_Bitmap,SelectedNode,EDITING);
}

pathpoint *CreateIPointPath(short type, node *Np, short firstframe,
                            short *pathtype, short *npathpoints){
 pathpoint *temp1,*temp2,*temp3,*tp,*sp;
 object *Op;
 long lpx,lpy,lpz,fpx,fpy,fpz;
 HWND hwnd;
 EDIT_ACTION=YES;
 if((hwnd=GetFocus()) != ghwnd_main)hwnd=ghwndTimeline;
 if     (type == LOADED){
   return LoadPath(pathtype,npathpoints,hwnd);
 }
 else if(type == COPIED)
   return CopyPath(pathtype,npathpoints,Np,firstframe,hwnd);
 *pathtype=type;
 if((temp1 = (pathpoint *)X__Malloc(sizeof(pathpoint))) == NULL){
   SendPrgmQuery(IDQ_NOMEM1,0);
   return NULL;
 }
 if((temp2 = (pathpoint *)X__Malloc(sizeof(pathpoint))) == NULL){
   SendPrgmQuery(IDQ_NOMEM1,0);
   X__Free(temp1); return NULL;
 }
 if(type == CLOSED){
   if((temp3 = (pathpoint *)X__Malloc(sizeof(pathpoint))) == NULL){
     SendPrgmQuery(IDQ_NOMEM1,0);
     X__Free(temp1); X__Free(temp2); return NULL;
   }
 }
 fpx=NpointerX; fpy=NpointerY;        fpz=NpointerZ;
 lpx=NpointerX; lpy=NpointerY+TVsizeY; lpz=NpointerZ;
 if((Op=Np->fobj) != NULL)while(Op != NULL){ /* if not the first path for */
   if(Op->lastframe >= firstframe){          /* this object then put first*/
     if(Op->last != NULL){                   /* point at end of last and  */
       if(Op->last->pathtype == CLOSED)sp=Op->last->firstpathpoint;
       else{                                 /* last at cursor. Unless    */
         sp=NULL;                            /* closed then start at first*/
         if((tp=Op->last->firstpathpoint) != NULL)while(tp!=NULL){
           sp=tp;                            /* if first path then start  */
           tp=tp->next;                      /* at cursor                 */
         }
       }
       if(sp!=NULL){
         fpx=sp->p[0];  fpy=sp->p[1];  fpz=sp->p[2];
         lpx=NpointerX; lpy=NpointerY; lpz=NpointerZ;
       }
     }
     break;   /* break out of while loop */
   }
   Op=Op->next;
 }
 if(type == OPEN){
  temp1->last=NULL;
  temp1->next=temp2;
  temp2->last=temp1;
  temp2->next=NULL;
  temp1->ptheta=0; temp1->pfi=0;
  temp2->ptheta=0; temp2->pfi=0;
  temp1->p[0]=fpx; temp1->p[1]=fpy; temp1->p[2]=fpz;
  temp2->p[0]=lpx; temp2->p[1]=lpy; temp2->p[2]=lpz;
  temp1->distance=0.0; /* set by calculating path length */
  temp2->distance=0.0;
  temp1->status=temp2->status=0;
  temp1->tension_n=temp2->tension_n=0.5;
  temp1->tension_p=temp2->tension_p=0.5;
  *npathpoints=2;
 }
 else if(type ==CLOSED){
  temp1->last=NULL;
  temp1->next=temp2;
  temp2->last=temp1;
  temp2->next=temp3;
  temp3->last=temp2;
  temp3->next=NULL;
  temp1->ptheta=0; temp1->pfi=0;
  temp2->ptheta=0; temp2->pfi=0;
  temp3->ptheta=0; temp3->pfi=0;
  temp1->p[0]=fpx;        temp1->p[1]=fpy;         temp1->p[2]=fpz;
  temp2->p[0]=fpx+TVsizeX; temp2->p[1]=fpy+TVsizeY;  temp2->p[2]=fpz;
  temp3->p[0]=fpx-TVsizeX; temp3->p[1]=fpy+TVsizeY;  temp3->p[2]=fpz;
  temp1->distance=0.0;temp2->distance=0.0; temp3->distance=0.0;
  temp1->tension_n=temp2->tension_n=temp3->tension_n=0.5;
  temp1->tension_p=temp2->tension_p=temp3->tension_p=0.5;
  temp1->status=temp2->status=temp3->status=0;
  *npathpoints=3;
 }
 return temp1;
}

void DeleteCostume(node *Np, long frame){
 object *temp;
 pathpoint *pp,*pp1;
 PATHEDITCONTROL *pe,*pe1;
 temp=Np->fobj;
 while(temp != NULL){
  if((temp->firstframe <= frame) && (temp->lastframe >= frame)){
    EDIT_ACTION=YES;
    if(temp->fileID >= 0)DeleteRamFile(temp->fileID, temp);
    if((pp=temp->firstpathpoint) != NULL){
      if(SelectedPath == temp){
        SelectedPath=NULL;
        SelectedPathPoint=NULL;
      }
      while(pp != NULL){
        pp1=pp; pp=pp->next; X__Free(pp1);
      }
    }
    if(temp->v != NULL)X__Free(temp->v);   /* for paths this is velocity */
    if((pe=temp->pec) != NULL)while(pe != NULL){
        pe1=pe; pe=pe->next; X__Free(pe1);}
    DeleteEffect(temp);
    if(temp->xip == NULL)X__Free(temp->xip);  temp->xip=NULL;
    UnloadRamImage(&(temp->image));
    if(temp->next != NULL)temp->next->last = temp->last;
    if(temp->last != NULL)temp->last->next = temp->next;
    else Np->fobj=temp->next;
    X__Free(temp);
    return;
  }
 temp=temp->next;}
}

object *CreateCostume(node *Np, long firstframe, long lastframe){
 object *temp,*p,*q;
 short ff,lf;
 int i;
 EDIT_ACTION=YES;
 ff=min(firstframe,lastframe);
 lf=max(firstframe,lastframe);
 if((temp = (object *)X__Malloc(sizeof(object))) == NULL){
   SendPrgmQuery(IDQ_NOMEM1,0);
   fail_op=YES; return NULL;
 }
 p=Np->fobj; q=NULL;
 LOOP:
 if(p != NULL){
   if(((lf >= p->firstframe) && (lf <= p->lastframe))
    ||((ff >= p->firstframe) && (ff <= p->lastframe))
    ||((ff <= p->firstframe) && (lf >= p->lastframe))){
      if((ff < p->firstframe) && (lf > p->lastframe))fail_op=YES;
      X__Free(temp); return NULL;}
   else if(lf < p->firstframe){/* item is before p */
      temp->next=p;
      if(p->last == NULL)Np->fobj = temp; /* before first item */
      else p->last->next=temp;
      temp->last = p->last;
      p->last=temp;
      goto END;
   }
   q=p; p=p->next;
   goto LOOP;
 }
 else{/* item is either only one or is last */
  if(q == NULL)Np->fobj=temp; /* item is only one */
  else q->next=temp;
  temp->last=q;
  temp->next=NULL;
  goto END;
 }
 goto LOOP;
END:
 temp->name[0]='\0';
 temp->firstframe = ff;
 temp->lastframe = lf;
 temp->type = Np->type;
 temp->quick_only=0;
 temp->fileID = -1;
 temp->npathpoints=0;
 temp->origin[0]=0; temp->origin[1]=0; temp->origin[2]=0;
 temp->offset[0]=0; temp->offset[1]=0; temp->offset[2]=0;
 temp->colour[0]=0;
 temp->colour[1]=255;
 temp->colour[2]=0;
 temp->acolour[0]=0;
 temp->acolour[1]=128;
 temp->acolour[2]=0;
 temp->morph=NO;
 temp->morphNo=0;
 temp->xip=NULL;
 temp->effect=NULL;
 temp->edges=NULL;
 temp->points=NULL;
 temp->skeleton=NULL;
 temp->w_frame.Np=temp->w_frame.Ne=0;
 temp->w_frame.e=NULL; temp->w_frame.p=NULL;
 temp->skid=NULL;
 temp->npoints=0;
 temp->nskeleton=0;
 temp->nedges=0;
 temp->in_ram=0;
 temp->bWireframe=0;
 temp->pathtype = -1;
 temp->groundtype=0;
 temp->lighttype =0;
 temp->light_intensity=1.0;
 temp->depth_cue=0;
 temp->depth_cue_c=1.0;
 temp->depth_cue_l=1.0;
 temp->depth_cue_q=0.0;
 temp->self_shadow=1;
 temp->cast_shadow=1;
 temp->show_shadow=1;
 temp->firstpathpoint = NULL;
 temp->pec=NULL;
 temp->npec=0;
 temp->v=NULL;
 temp->pathlength=0.0;
 temp->gspec=temp->gtran=temp->grefl=temp->gbump=0.0;
 temp->hEffect=NULL;
 temp->effectname[0]=0;
 temp->Nurbs=NULL;
 temp->nNurbs=0;
 temp->bIKchain=FALSE;
 InitialiseRamImage(&(temp->image));
 memset(&(temp->particles),0,sizeof(ParticleSystem));
 InitialiseParticleSystem(&(temp->particles));
 temp->groundTemperature=0.0;
 for(i=0;i<8;i++)temp->other_params[i]=0.0;
 return temp;
}

void DeleteSize(node *Np, long frame){
 size *temp;
 EDIT_ACTION=YES;
 temp=Np->fsiz;
 while(temp != NULL){
  if((temp->firstframe <= frame) && (temp->lastframe >= frame)){
    if(temp->next != NULL)temp->next->last = temp->last;
    if(temp->last != NULL)temp->last->next = temp->next;
    else Np->fsiz=temp->next;
    X__Free(temp);
    return;
  }
  temp=temp->next;
 }
}

static void SetDefaultCameraParams(cameraparam *c){
  c->f_number = 4;
  c->focal_length = 10;
  c->focus_distance = 10;
  c->polarn_angle = 0;
  c->polar_type  = 0;
  c->stereo_separation = 0.1;
  c->parallax_distance = 100.0;
}

size *CreateSize(node *Np, long firstframe, long lastframe){
 size *temp,*p,*q;
 short ff,lf;
 EDIT_ACTION=YES;
 ff=min(firstframe,lastframe);
 lf=max(firstframe,lastframe);
 if((temp = (size *)X__Malloc(sizeof(size))) == NULL){
   SendPrgmQuery(IDQ_NOMEM1,0);
   fail_op=YES; return NULL;
 }
 p=Np->fsiz; q=NULL;
 LOOP:
 if(p != NULL){
   if(((lf >= p->firstframe) && (lf <= p->lastframe))
    ||((ff >= p->firstframe) && (ff <= p->lastframe))
    ||((ff <= p->firstframe) && (lf >= p->lastframe))){
      if((ff < p->firstframe) && (lf > p->lastframe))fail_op=YES;
      X__Free(temp); return NULL;}
   else if(lf < p->firstframe){/* item is before p */
      temp->next=p;
      if(p->last == NULL)Np->fsiz = temp; /* before first item */
      else p->last->next=temp;
      temp->last = p->last;
      p->last=temp;
      goto END;
   }
   q=p; p=p->next;
   goto LOOP;
 }
 else{/* item is either only one or is last */
  if(q == NULL)Np->fsiz=temp; /* item is only one */
  else q->next=temp;
  temp->last=q;
  temp->next=NULL;
  goto END;
 }
 goto LOOP;
END:
 temp->firstframe=ff;
 temp->lastframe=lf;
 temp->tweentype=0;
 temp->tension_s=0.5;
 temp->tension_e=0.5;
 temp->easin=1.0;
 temp->easout=1.0;
 if(temp->last == NULL){
   if(Np->type == LIGHT){
     temp->Sx=15; temp->Sy=5; temp->Sz=1; /* light cone angles sz not used */
   }
   else{
     temp->Sx=1;  temp->Sy=1; temp->Sz=1;
   }
   if(Np->type == CAMERA)SetDefaultCameraParams(&(temp->camera_params));
 }
 else{
   temp->Sx=temp->last->Sx;
   temp->Sy=temp->last->Sy;
   temp->Sz=temp->last->Sz;
   if(Np->type == CAMERA)memcpy(&(temp->camera_params),&(temp->last->camera_params),sizeof(cameraparam));
 }
 return temp;
}

void DeleteAlign(node *Np, long frame){
 align *temp;
 EDIT_ACTION=YES;
 temp=Np->fali;
 while(temp != NULL){
  if((temp->firstframe <= frame) && (temp->lastframe >= frame)){
    if(temp->next != NULL)temp->next->last = temp->last;
    if(temp->last != NULL)temp->last->next = temp->next;
    else Np->fali=temp->next;
    X__Free(temp);
    return;
  }
 temp=temp->next;}
}

align *CreateAlign(node *Np, long firstframe, long lastframe){
 align *temp,*p,*q;
 short ff,lf;
 EDIT_ACTION=YES;
 ff=min(firstframe,lastframe);
 lf=max(firstframe,lastframe);
 if((temp = (align *)X__Malloc(sizeof(align))) == NULL){
   SendPrgmQuery(IDQ_NOMEM1,0);
   fail_op=YES; return NULL;
 }
 p=Np->fali; q=NULL;
 LOOP:
 if(p != NULL){
   if(((lf >= p->firstframe) && (lf <= p->lastframe))
    ||((ff >= p->firstframe) && (ff <= p->lastframe))
    ||((ff <= p->firstframe) && (lf >= p->lastframe))){
      if((ff < p->firstframe) && (lf > p->lastframe))fail_op=YES;
      X__Free(temp); return NULL;}
   else if(lf < p->firstframe){/* item is before p */
      temp->next=p;
      if(p->last == NULL)Np->fali = temp; /* before first item */
      else p->last->next=temp;
      temp->last = p->last;
      p->last=temp;
      goto END;
   }
   q=p; p=p->next;
   goto LOOP;
 }
 else{/* item is either only one or is last */
  if(q == NULL)Np->fali=temp; /* item is only one */
  else q->next=temp;
  temp->last=q;
  temp->next=NULL;
  goto END;
 }
 goto LOOP;
END:
 temp->type=TWEEN;
 temp->firstframe=ff;
 temp->lastframe=lf;
 temp->topath=NULL;
 temp->tension_s=0.5;
 temp->tension_e=0.5;
 temp->easin=1.0;
 temp->easout=1.0;
 if(temp->last == NULL){
  temp->theta=0;
  temp->phi=0;
  temp->alpha=0;
  temp->im=0;
  temp->ima= -1.0;
 }
 else{
  temp->theta=temp->last->theta;
  temp->phi=temp->last->phi;
  temp->alpha=temp->last->alpha;
  temp->im=temp->last->im;
  temp->ima=temp->last->ima;
 }
 return temp;
}

void DeletePosition(node *Np, long frame){
 position *temp;
 EDIT_ACTION=YES;
 temp=Np->fpos;
 while(temp != NULL){
  if((temp->firstframe <= frame) && (temp->lastframe >= frame)){
    if(temp->next != NULL)temp->next->last = temp->last;
    if(temp->last != NULL)temp->last->next = temp->next;
    else Np->fpos=temp->next;
    X__Free(temp);
    return;
  }
 temp=temp->next;}
}

void DeletePositionIn(node *Np, long first_frame, long last_frame){ // all positions!
  int i;
  for(i=first_frame;i<=last_frame;i++)DeletePosition(Np,i);
}

position *CreatePosition(node *Np, long firstframe, long lastframe){
 position *temp,*p,*q;
 short ff,lf;
 EDIT_ACTION=YES;
 ff=min(firstframe,lastframe);
 lf=max(firstframe,lastframe);
 if((temp = (position *)X__Malloc(sizeof(position))) == NULL){
   SendPrgmQuery(IDQ_NOMEM1,0);
   fail_op=YES; return NULL;
 }
 p=Np->fpos; q=NULL;
 LOOP:
 if(p != NULL){
   if(((lf >= p->firstframe) && (lf <= p->lastframe))
    ||((ff >= p->firstframe) && (ff <= p->lastframe))
    ||((ff <= p->firstframe) && (lf >= p->lastframe))){
      if((ff < p->firstframe) && (lf > p->lastframe))fail_op=YES;
      X__Free(temp); return NULL;}
   else if(lf < p->firstframe){/* item is before p */
      temp->next=p;
      if(p->last == NULL)Np->fpos = temp; /* before first item */
      else p->last->next=temp;
      temp->last = p->last;
      p->last=temp;
      goto END;
   }
   q=p; p=p->next;
   goto LOOP;
 }
 else{/* item is either only one or is last */
  if(q == NULL)Np->fpos=temp; /* item is only one */
  else q->next=temp;
  temp->last=q;
  temp->next=NULL;
  goto END;
 }
 goto LOOP;
END:
 temp->type=TWEEN;
 temp->firstframe=ff;
 temp->lastframe=lf;
 temp->onpath=NULL;
 temp->tension_s=0.5;
 temp->tension_e=0.5;
 temp->easin=1.0;
 temp->easout=1.0;
 temp->fx=0; temp->fy=0; temp->fz=0;
 if(Np->type == TARGET){   /* if target add at the current cursor position*/
   temp->finish[0]=NpointerX;
   temp->finish[1]=NpointerY;
   temp->finish[2]=NpointerZ;
 }
 else if(temp->last == NULL){
   temp->finish[0]=0;
   temp->finish[1]=0;
   temp->finish[2]=0;
 }
 else{  /* put at same place as last */
   temp->finish[0]=temp->last->finish[0];
   temp->finish[1]=temp->last->finish[1];
   temp->finish[2]=temp->last->finish[2];
 }
 return temp;
}

void DeleteSky(node *Np, long frame){
 sky *temp;
 EDIT_ACTION=YES;
 temp=Np->fsky;
 while(temp != NULL){
  if((temp->firstframe <= frame) && (temp->lastframe >= frame)){
    if(temp->next != NULL)temp->next->last = temp->last;
    if(temp->last != NULL)temp->last->next = temp->next;
    else Np->fsky=temp->next;
    UnloadRamImage(&(temp->image));
    X__Free(temp);
    return;
  }
 temp=temp->next;}
}

sky *CreateSky(node *Np, long firstframe, long lastframe){
 int i;
 sky *temp,*p,*q;
 short ff,lf;
 EDIT_ACTION=YES;
 ff=min(firstframe,lastframe);
 lf=max(firstframe,lastframe);
 if((temp = (sky *)X__Malloc(sizeof(sky))) == NULL){
   SendPrgmQuery(IDQ_NOMEM1,0);
   fail_op=YES; return NULL;
 }
 p=Np->fsky; q=NULL;
 LOOP:
 if(p != NULL){
   if(((lf >= p->firstframe) && (lf <= p->lastframe))
    ||((ff >= p->firstframe) && (ff <= p->lastframe))
    ||((ff <= p->firstframe) && (lf >= p->lastframe))){
      if((ff < p->firstframe) && (lf > p->lastframe))fail_op=YES;
      X__Free(temp); return NULL;}
   else if(lf < p->firstframe){/* item is before p */
      temp->next=p;
      if(p->last == NULL)Np->fsky = temp; /* before first item */
      else p->last->next=temp;
      temp->last = p->last;
      p->last=temp;
      goto END;
   }
   q=p; p=p->next;
   goto LOOP;
 }
 else{/* item is either only one or is last */
  if(q == NULL)Np->fsky=temp; /* item is only one */
  else q->next=temp;
  temp->last=q;
  temp->next=NULL;
  goto END;
 }
 goto LOOP;
END:
 temp->firstframe=ff;
 temp->lastframe=lf;
 temp->colour[0]=128;
 temp->colour[1]=60;
 temp->colour[2]=60;
 temp->zcolour[0]=0;
 temp->zcolour[1]=128;
 temp->zcolour[2]=255;
 temp->type=0;
 temp->gamb=0.08; temp->oamb=0.1;
 temp->gamb_colour[0]=temp->gamb_colour[1]=temp->gamb_colour[2]=0.08;
 temp->oamb_colour[0]=temp->oamb_colour[1]=temp->oamb_colour[2]=0.08;
 temp->aff=1; temp->alf=9999; temp->ast=1;
 for(i=0;i<32;i++)temp->sky_params[i]=0.0;
 temp->sky_params[0]=15.0;
 temp->sky_params[1]=50.0;
 strcpy(temp->sky_params_file,"<none>");
 InitialiseRamImage(&(temp->image));
 return temp;
}

void DeleteDirector(node *Np, long frame){
 director *temp;
 EDIT_ACTION=YES;
 temp=Np->fdirector;
 while(temp != NULL){
  if((temp->firstframe <= frame) && (temp->lastframe >= frame)){
    if(temp->next != NULL)temp->next->last = temp->last;
    if(temp->last != NULL)temp->last->next = temp->next;
    else Np->fdirector=temp->next;
    X__Free(temp);
    return;
  }
 temp=temp->next;}
}

director *CreateDirector(node *Np, long firstframe, long lastframe){
 director *temp,*p,*q;
 short ff,lf;
 EDIT_ACTION=YES;
 ff=min(firstframe,lastframe);
 lf=max(firstframe,lastframe);
 if((temp = (director *)X__Malloc(sizeof(sky))) == NULL){
   SendPrgmQuery(IDQ_NOMEM1,0);
   fail_op=YES; return NULL;
 }
 p=Np->fdirector; q=NULL;
 LOOP:
 if(p != NULL){
   if(((lf >= p->firstframe) && (lf <= p->lastframe))
    ||((ff >= p->firstframe) && (ff <= p->lastframe))
    ||((ff <= p->firstframe) && (lf >= p->lastframe))){
      if((ff < p->firstframe) && (lf > p->lastframe))fail_op=YES;
      X__Free(temp); return NULL;}
   else if(lf < p->firstframe){/* item is before p */
      temp->next=p;
      if(p->last == NULL)Np->fdirector = temp; /* before first item */
      else p->last->next=temp;
      temp->last = p->last;
      p->last=temp;
      goto END;
   }
   q=p; p=p->next;
   goto LOOP;
 }
 else{/* item is either only one or is last */
  if(q == NULL)Np->fdirector=temp; /* item is only one */
  else q->next=temp;
  temp->last=q;
  temp->next=NULL;
  goto END;
 }
 goto LOOP;
END:
 temp->firstframe=ff;
 temp->lastframe=lf;
 temp->type=0;
 temp->ActiveCamera=FirstNp;
 return temp;
}

void DeleteNode(node *Np){
 sky       *Sp,*tSp;
 object    *Op,*tOp;
 position  *Pp,*tPp;
 director  *Dp,*tDp;
 align     *Ap,*tAp;
 size      *Zp,*tZp;
 node      *oldNp;
 if(Np == NULL)return;
 EDIT_ACTION=YES;
 oldNp=Np;
 if((Sp = Np->fsky) != NULL)while(Sp != NULL){
   DeleteSky(Np,Sp->lastframe);
   Sp=Np->fsky;
 //   tSp=Sp->next; X__Free(Sp); Sp=tSp;
 }
 if((Dp = Np->fdirector) != NULL)while(Dp != NULL){
    tDp=Dp->next; X__Free(Dp); Dp=tDp;}
 if((Op = Np->fobj) != NULL)while(Op != NULL){
   DeleteCostume(Np,Op->lastframe);
   Op=Np->fobj;
 }
 if((Pp = Np->fpos) != NULL)while(Pp != NULL){
   tPp=Pp->next; X__Free(Pp); Pp=tPp;}
 if((Ap = Np->fali) != NULL)while(Ap != NULL){
   tAp=Ap->next; X__Free(Ap); Ap=tAp;}
 if((Zp = Np->fsiz) != NULL)while(Zp != NULL){
   tZp=Zp->next; X__Free(Zp); Zp=tZp;}
 if(Np->last != NULL)Np->last->next=Np->next;
 if(Np->next != NULL)Np->next->last=Np->last;
 if(Np == MainNp )MainNp  = Np->last;
 if(Np == FirstNp)FirstNp = Np->next;
 Nnodes--;
 X__Free(Np);
 /* now look at all dependencies remaining to see if they depend on this
    node, if they do then remove the dependencies by conversion to
    the simplest type
 */
 if((Np=FirstNp) != NULL)while(Np != NULL){
   if((Pp=Np->fpos) != NULL)while(Pp != NULL){
     if(Pp->onpath == oldNp){Pp->onpath=NULL; Pp->type = TWEEN;}
     Pp=Pp->next;
   }
   if((Ap=Np->fali) != NULL)while(Ap != NULL){
     if(Ap->topath == oldNp){Ap->topath=NULL; Ap->type = TWEEN;}
     Ap=Ap->next;
   }
   /* if it's a director then check to see if it was pointing at a
      camera that has been deleted, if so point to first camera */
   if(Np->type == DIRECTOR){
     if((Dp=Np->fdirector) != NULL)while(Dp != NULL){
       if(Dp->ActiveCamera == oldNp)Dp->ActiveCamera=FirstNp;
       Dp=Dp->next;
     }
   }
   Np=Np->next;
 }
}

node *CreateNode(void){
 node *temp;
 if((temp = (node *)X__Malloc(sizeof(node))) == NULL){
   SendPrgmQuery(IDQ_NOMEM1,0);
   return NULL;
 }
 EDIT_ACTION=YES;
 if(MainNp == NULL)FirstNp=temp;
 else              MainNp->next=temp;
 temp->last=MainNp;
 temp->next=NULL;
 temp->fsky=NULL;
 temp->fdirector=NULL;
 temp->fobj=NULL;
 temp->fpos=NULL;
 temp->fali=NULL;
 temp->fsiz=NULL;
 temp->type=-1;
 temp->ID=MaxNodeID++;
 MainNp = temp;
 Nnodes++;
 return temp;
}

pathpoint *CopyPath(short *pathtype, short *npathpoints, node *Nc,
                    short firstframe, HWND parent){
 pathpoint *Ppp=NULL,*Fpp=NULL,*Lpp=NULL,*Cpp=NULL;
 char tempname[32];
 node *Np;
 object *Op;
 long i;
 if((Np=SelectNode(tempname,NO,parent)) == NULL || Np->type != PATH)return NULL;
 if((Op=Np->fobj) != NULL)while(Op != NULL){
   if(firstframe >= Op->firstframe && firstframe <= Op->lastframe){
     if(Op->npathpoints > 0 && (Cpp=Op->firstpathpoint) != NULL){
       for(i=0;i<Op->npathpoints;i++){
         if((Ppp=AppendPathPoint(Ppp)) == NULL)goto MEMFAIL;
         CopyPoint(Cpp->p,Ppp->p);
         Ppp->tension_n=Cpp->tension_n;
         Ppp->tension_p=Cpp->tension_p;
         Ppp->ptheta=0;Ppp->pfi=0;
         Ppp->distance=0.0; /* set by path length calculation */
         Lpp=Ppp;
         if(i == 0)Fpp=Ppp;
         Cpp=Cpp->next;
       }
       *npathpoints = Op->npathpoints;
       *pathtype = Op->pathtype;
       return Fpp;
     }
   }
   Op=Op->next;
 }
 return NULL;
 MEMFAIL:
 if(Lpp != NULL)while(Lpp!=NULL){Ppp=Lpp->last; X__Free(Lpp); Lpp=Ppp;}
 return NULL;
}

void CheckRecursiveFollow(node *Np, short ff, short lf){
 position *Pp;
 align    *Ap;
 char mess[256];
 object   *Op;
 double   alpha,theta,phi,sx,sy,sz,ima;
 short    im;
 point    Offset,TrackedOffset;
 long     tframe;
 tframe=CurrentFrame;
 AGAIN:
 if(setjmp(r_buf) != 0){
   SendPrgmQuery(IDQ_SELFFOLLOW1,0);
   sprintf(mess,"Actor %s reset to TWEEN", Np->actorname);
   MessageBox (NULL,mess,"NOTE",
    MB_OK | MB_ICONINFORMATION | MB_TASKMODAL);
   if((Pp=Np->fpos) != NULL)while(Pp != NULL){
     if((CurrentFrame >= Pp->firstframe) && (CurrentFrame <= Pp->lastframe)){
       Pp->type=TWEEN;  Pp->onpath=NULL; Pp->pnodename[0]='\0';
     }
     Pp=Pp->next;
   }
   if((Ap=Np->fali) != NULL)while(Ap != NULL){
     if((CurrentFrame >= Ap->firstframe) && (CurrentFrame <= Ap->lastframe)){
       Ap->type=TWEEN;  Ap->topath=NULL; Ap->anodename[0]='\0';
     }
     Ap=Ap->next;
   }
   goto AGAIN;
 }
 for(CurrentFrame=ff; CurrentFrame <= lf; CurrentFrame++){
   if((Op=Np->fobj) != NULL)while(Op != NULL){
     if(CurrentFrame >= Op->firstframe && CurrentFrame <= Op->lastframe){
       GetTransform(0,CurrentFrame,1.0,Np,Op,Offset,TrackedOffset,
                    &phi,&theta,&alpha,&sx,&sy,&sz,&im,&ima);
     }
     Op=Op->next;
   }
 }
 CurrentFrame=tframe;
}

void ScrapEverything(void){
 XIP  *Ip,*tIp;
 node *Np,*tNp;
 long i;
 char WorkfileName[64];
 if((Np=MainNp) != NULL)while(Np != NULL){
   tNp=Np->last;
   DeleteNode(Np);
   Np=tNp;
 }
 MainNp=NULL;
 FirstNp=NULL;
 SelectedNode=NULL;
 SelectedPath=NULL;
 SelectedPathPoint=NULL;
 SelectedCamera=NULL;
 Ncameras=0;
 Nnodes=0;
 Nground=0;
 Nrobots=0;
 Nskys=0;
 Ndirectors=0;
 MaxNodeID=0;
 if((Ip=MainIp) != NULL)while(Ip != NULL){
   tIp=Ip->last;
   DeleteImageProcess(Ip);
   Ip=tIp;
 }
 MainIp=NULL;
 FirstIp=NULL;
 NimageProcesses=0;
 fileID=0;
 Nframes=1;
 EnableMenuItem(GetMenu(ghwnd_main),IDM_FRAME_RENDERNOW,MF_GRAYED);
 CurrentFrame=1;
 FirstTimeRender=1;
 SelectedPathPhi=0.0;
 SelectedPathTheta=0.0;
 SelectedPathAlpha=0.0;
 SelectedPathOffset[0]=0;
 SelectedPathOffset[1]=0;
 SelectedPathOffset[2]=0;
 sprintf(WorkfileName,"%sW_$.SCR",TempPath);
 remove(WorkfileName);
 sprintf(WorkfileName,"%sX_$.SCR",TempPath);
 remove(WorkfileName);
 sprintf(WorkfileName,"%sY_$.SCR",TempPath);
 remove(WorkfileName);
 sprintf(WorkfileName,"%sW_$001.GIF",TempPath);
 remove(WorkfileName);
 sprintf(WorkfileName,"%sWIRE_$$$.APF",TempPath);
 remove(WorkfileName);
 FreePreview();
 EraseTempImageFiles();
 EDIT_ACTION=NO;
}

long SelectNodeID(HWND parent){
 node *Np;
 char temp[256];
 temp[0]=0;
 if((Np=SelectNode(temp,NO,parent)) == NULL)return -1;
 return (long)(Np->ID);
}

node *GetSelectedCamera(long cf, node *Sc){
 director *dp;
 node     *np;
 if(Ndirectors < 1 || use_director == 0)return Sc;
 np=FirstNp; while (np != NULL){
   if(np->type == DIRECTOR){
     dp=np->fdirector;
     while(dp != NULL){
       if(cf >= dp->firstframe && cf <= dp->lastframe){
         Sc=dp->ActiveCamera;
         return Sc;
       }
       dp=dp->next;
     }
     return Sc;
   }
   np=np->next;
 }
 return Sc;
}

typedef struct tagSELECTDLGLIST {
  int n;
  int maxlen;
  char *title;
  char **list;
  node **NpList;
} SELECTDLGLIST;

static BOOL CALLBACK ActorListDlgProc(HWND hwnd, UINT msg,
                                      WPARAM wparam, LPARAM lparam ){
 static SELECTDLGLIST *dp;
 static HBITMAP hbmpPicture,hbmpOld;
 static HBITMAP hbmpImages[N_OBJECTTYPELIST];
 HWND hctl;
 TCHAR tchBuf[MAX_PATH];
 TEXTMETRIC tm;
 int i,y,nItem;
 int tc;
 HDC hdcMem;
 LPMEASUREITEMSTRUCT lpmis;
 LPDRAWITEMSTRUCT lpdis;
 RECT rcBitmap;
 switch( msg ) {
   case WM_INITDIALOG:{
       dp=(SELECTDLGLIST *)lparam;
       for(i=0;i<N_OBJECTTYPELIST;i++){
         hbmpImages[i]=LoadBitmap(ghinst_main,
           MAKEINTRESOURCE(ObjectSmallBitmapIdList[i]));
       }
       hctl=GetDlgItem(hwnd,DLG_SELECT_LIST);
       for(i=0;i<dp->n;i++){
         nItem=SendMessage(hctl,LB_ADDSTRING,0,(LPARAM)dp->list[i]);
         if(dp->NpList != NULL){
           node *Np;
           Np=dp->NpList[i];
           if(Np != NULL){
             hbmpPicture=hbmpImages[0];
             if(Np->type == PATH)hbmpPicture=hbmpImages[1];
             if(Np->type == TARGET)hbmpPicture=hbmpImages[2];
             if(Np->type == GROUND)hbmpPicture=hbmpImages[3];
             if(Np->type == LIGHT)hbmpPicture=hbmpImages[4];
             if(Np->type == ANIMOBJ)hbmpPicture=hbmpImages[5];
             if(Np->type == PARTICLE)hbmpPicture=hbmpImages[6];
             if(Np->type == SKY)hbmpPicture=hbmpImages[7];
             if(Np->type == ROBOT)hbmpPicture=hbmpImages[8];
             if(Np->type == CAMERA)hbmpPicture=hbmpImages[9];
             if(Np->type == IMAGEP)hbmpPicture=hbmpImages[10];
             if(Np->type == DIRECTOR)hbmpPicture=hbmpImages[11];
             SendMessage(hctl,LB_SETITEMDATA,nItem,(LPARAM)hbmpPicture);
           }
         }
       }
       SendMessage(hctl,LB_SETCURSEL,0,0);
       SendMessage(hctl,LB_SETCOLUMNWIDTH,(WPARAM)(dp->maxlen+1)*6+22,0);
       SendMessage(hwnd,WM_SETTEXT,0,(LPARAM)dp->title);
       CentreDialogOnScreen(hwnd);
     }
     return (TRUE);
   case WM_MEASUREITEM:
     lpmis=(LPMEASUREITEMSTRUCT)lparam;
     lpmis->itemHeight=16;
     return TRUE;
   case WM_DRAWITEM:
     lpdis=(LPDRAWITEMSTRUCT)lparam;
     if(lpdis->itemID == -1)break;
     switch(lpdis->itemAction){
       case ODA_SELECT:
       case ODA_DRAWENTIRE:
         hbmpPicture=(HBITMAP)SendMessage(lpdis->hwndItem,LB_GETITEMDATA,
          lpdis->itemID,(LPARAM)0);
         hdcMem=CreateCompatibleDC(lpdis->hDC);
         hbmpOld=SelectObject(hdcMem,hbmpPicture);
         SendMessage(lpdis->hwndItem,LB_GETTEXT,lpdis->itemID,(LPARAM)tchBuf);
         GetTextMetrics(lpdis->hDC,&tm);
         y=(lpdis->rcItem.bottom+lpdis->rcItem.top-tm.tmHeight)/2;
         ExtTextOut(lpdis->hDC,
                    lpdis->rcItem.left+16+6,y,
                    ETO_OPAQUE | ETO_CLIPPED,
                    &lpdis->rcItem,
                    tchBuf,strlen(tchBuf),
                    NULL);
         BitBlt(lpdis->hDC,lpdis->rcItem.left,lpdis->rcItem.top,
                lpdis->rcItem.right-lpdis->rcItem.left,
                lpdis->rcItem.bottom-lpdis->rcItem.top,
                hdcMem,0,0,SRCCOPY);
         SelectObject(hdcMem,hbmpOld);
         DeleteDC(hdcMem);
         if(lpdis->itemState & ODS_SELECTED){
           rcBitmap.left=lpdis->rcItem.left;
           rcBitmap.top=lpdis->rcItem.top;
           rcBitmap.right=lpdis->rcItem.left+
                          16+6+strlen(tchBuf)*tm.tmAveCharWidth;
           rcBitmap.bottom=lpdis->rcItem.top+16;
//           InvertRect(lpdis->hDC,&rcBitmap);
           InvertRect(lpdis->hDC,&lpdis->rcItem);
         }
         break;
       case ODA_FOCUS:
         break;
     }
     return TRUE;
   case WM_COMMAND:
      switch(LOWORD(wparam)){
        case DLG_SELECT_LIST:
          switch(HIWORD(wparam)){
            case LBN_SELCHANGE:
              hctl=GetDlgItem(hwnd,DLG_SELECT_LIST);
              i=SendMessage(hctl,LB_GETCURSEL,0,0);
              if(dp->NpList != NULL){
                node *Np;
                Np=dp->NpList[i];
                if(Np != NULL){
                  if(Np->type == NORMAL ||
                     Np->type == ROBOT  ||
                     Np->type == ANIMOBJ){
                    object *Op;
                    Op=GetObjectAtFrame(Np,CurrentFrame);
                    if(Op == NULL)
                      SetDlgItemText(hwnd,DLG_SELECT_INFO,Np->actorname);
                    else
                      SetDlgItemText(hwnd,DLG_SELECT_INFO,Op->name);
                  }
                  else
                    SetDlgItemText(hwnd,DLG_SELECT_INFO," ");
                }

              }
              break;
            case LBN_DBLCLK:
            SendMessage(hwnd,WM_COMMAND,MAKEWPARAM(IDOK,0),0);
              break;
            default:
              break;
          }
          break;
        case IDCANCEL:
          EndDialog(hwnd, -1);
          return (TRUE);
        case IDOK:
          hctl=GetDlgItem(hwnd,DLG_SELECT_LIST);
          i=SendMessage(hctl,LB_GETCURSEL,0,0);
          EndDialog(hwnd,i);
          return(TRUE);
        default:
          break;
      }
      break;
   case WM_DESTROY:
     for(i=0;i<N_OBJECTTYPELIST;i++)DeleteObject(hbmpImages[i]);
     return TRUE;
 }
 return(FALSE);
}

node *SelectNode(char *NodeName, short with_sky, HWND parent){
 SELECTDLGLIST SelectDlgList;
 node *Np,**NpList;
 int maxlen=0;
 short id,i,j;
 char **ItemList;
 char title[256];
 if((ItemList = (char **)X__Malloc(sizeof(char *)*Nnodes)) == NULL)
     return NULL;
 for(i=0;i<Nnodes;i++){
   if((ItemList[i] = (char *)X__Malloc(128)) == NULL){
     if(i > 0)for(j=0;j<i;j++)X__Free(ItemList[j]);
     X__Free(ItemList);
     return NULL;
   }
 }
 if((NpList = (node **)X__Malloc(sizeof(node *)*Nnodes)) == NULL){
   for(i=0;i<Nnodes;i++)X__Free(ItemList[i]);
   X__Free(ItemList);
   return NULL;
 }
 i=0; Np=FirstNp; while(Np != NULL){ /* get list of node names */
   strcpy(ItemList[i]," ");
   strcat(ItemList[i],Np->actorname);
   NpList[i]=Np;
   maxlen=max(maxlen,strlen(ItemList[i]));
   i++; Np=Np->next;
 }
 TRYAGAIN:
 LoadString(ghinst_main,IDX_MISC_ACTOR,title,63);
 SelectDlgList.n=Nnodes;
 SelectDlgList.list=ItemList;
 SelectDlgList.title=title;
 SelectDlgList.maxlen=maxlen;
 SelectDlgList.NpList=NpList;
 id=DialogBoxParam(ghinst_main,MAKEINTRESOURCE(DLG_SELECT),parent,
                   (DLGPROC)ActorListDlgProc,(LPARAM)&SelectDlgList);
// id=SelectScrolledItemList(Nnodes,ItemList,title,FALSE,parent);
 if(id != FAIL && with_sky == NO && NpList[id]->type == SKY){
   MessageBeep(MB_OK);
   goto TRYAGAIN;
 }
 if(id == FAIL || (with_sky == NO && NpList[id]->type == SKY)){
   for(i=0;i<Nnodes;i++)X__Free(ItemList[i]);
   X__Free(ItemList);
   X__Free(NpList);
   return NULL;
 }
 strcpy(NodeName,ItemList[id]);
 Np=NpList[id];
 for(i=0;i<Nnodes;i++)X__Free(ItemList[i]);
 X__Free(ItemList);
 X__Free(NpList);
 return Np;
}

void CentreDialogOnCursor(HWND hwnd){
 RECT rcDlg;
 POINT p;
 GetCursorPos(&p);
 GetWindowRect(hwnd,&rcDlg);
 OffsetRect(&rcDlg,-rcDlg.left,-rcDlg.top);
 OffsetRect(&rcDlg,p.x-rcDlg.right/2,p.y-rcDlg.bottom/2);
 if(rcDlg.left < 0)OffsetRect(&rcDlg,-rcDlg.left,0);
 if(rcDlg.top  < 0)OffsetRect(&rcDlg,0,-rcDlg.top);
 if(rcDlg.right  > Xres)OffsetRect(&rcDlg,Xres-rcDlg.right,0);
 if(rcDlg.bottom > Yres)OffsetRect(&rcDlg,0,Yres-rcDlg.bottom);
 SetWindowPos(hwnd,HWND_TOP,rcDlg.left,rcDlg.top,0,0,SWP_NOSIZE);
 return;
}

void CentreDialogOnScreen(HWND hWnd){
 RECT rc;
 GetWindowRect(hWnd, &rc);
 SetWindowPos(hWnd, NULL,
    (GetSystemMetrics(SM_CXSCREEN) - (rc.right - rc.left)) / 2,
    (GetSystemMetrics(SM_CYSCREEN) - (rc.bottom - rc.top)) / 2,
    0, 0, SWP_NOSIZE | SWP_NOZORDER);
}

void AppendFileExtension(char *filename, char *ext){
 if(strrchr(filename,'.') == NULL){
   strcat(filename,ext);
 }
}

char *short_form(char *filename){
 char *sps,*spc;
 sps=spc=filename;
 while((spc=strchr(spc,'\\')) != NULL){spc++; sps=spc;}
 return sps;
}

char *truncate_path(char *name, int n){
 static char compressed_path[256],newname[256];
 char *lp;
 int i,l;
 strcpy(newname,name);
 *short_form(newname) = '\0';
 if((l=strlen(newname)) == 0)return newname;
 if(strlen(newname) > n){
   strnset(compressed_path,'\0',255);
   strncpy(compressed_path,newname,3);
   strcat(compressed_path,"...");
   lp=strrchr(newname,'\\');
   if(lp != NULL)strcat(compressed_path,lp);
 }
 else strcpy(compressed_path,newname);
 AnsiLower(compressed_path);
 return compressed_path;
}