DRAFT0.C

Go to the documentation of this file.

/* --
OpenFX version 1.0 - Modelling, Animation and Rendering Package
Copyright (C) 2000 OpenFX Development Team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

You may contact the OpenFX development team via elecronic mail
at core@openfx.org, or visit our website at http://openfx.org for
further information and support details.
-- */

/* file DRAFT0.C included in DRAFT.C */

static void DeleteAllPath(void){
 if(Np > 0 && pathlist != NULL){
   int i,n;
   PATHPOINT *pp;
   for(i=0;i<Np;i++){
     if((n=pathlist[i].n) > 0 && (pp=pathlist[i].pts) != NULL){
       X__Free(pp);
     }
   }
   X__Free(pathlist);
   Np=0; pathlist=NULL;
   Lp= -1; Lpp= -1;
 }
}

static void DeleteOnePath(int id){
 int i,n;
 PATHPOINT *pp;
 if(Np < 2){
   DeleteAllPath();
   return;
 }
 if((n=pathlist[id].n) > 0 && (pp=pathlist[id].pts) != NULL){
   X__Free(pp);
 }
 if(Lp < Np-1){
  for(i=Lp;i<Np-1;i++){
    memcpy((pathlist + i),(pathlist + i+1),sizeof(PTH));
  }
 }
 Np--;
 pathlist=(PTH *)X__Realloc(pathlist,sizeof(PTH)*Np);
 if(pathlist == NULL){
   Np=0; MessageBeep(MB_OK);
 }
 Lp= -1; Lpp= -1;
 return;
}

static void DeletePathVertex(void){
 int i;
 PTH *pth;
 PATHPOINT *temp;
 pth=(pathlist + Lp);
 if(pth->n == 1){
   DeleteOnePath(Lp);
   return;
 }
 if(Lpp == 0 || Lpp == pth->n - 1)pth->closed=0;
 if(Lpp < pth->n - 1){
  for(i=Lpp;i<pth->n - 1;i++){
    memcpy((pth->pts + i),(pth->pts + i+1),sizeof(PATHPOINT));
  }
 }
 (pth->n)--;
 pth->pts=(PATHPOINT *)X__Realloc(pth->pts,sizeof(PATHPOINT)*pth->n);
 if(pth->pts == NULL){
   pth->n=0; MessageBeep(MB_OK);
 }
 Lp= -1; Lpp= -1;
}

static int CreatePath(void){
 PTH *temp;
 if(pathlist == NULL){
   if((pathlist=(PTH *)X__Malloc(sizeof(PTH))) == NULL)return -1;
 }
 else{
   if((temp=(PTH *)X__Realloc(pathlist,sizeof(PTH)*(Np+1))) == NULL)
     return Np-1;
   pathlist=temp;
 }
 pathlist[Np].pts=NULL;
 pathlist[Np].n=0;
 pathlist[Np].closed=0;
 Np++;
 return Np-1;
}

static int CreatePathPoint(int pa,int x, int y){
 PATHPOINT *temp;
 if(pa < 0)return -1;
 if(pathlist[pa].pts == NULL){
   if((pathlist[pa].pts=(PATHPOINT *)X__Malloc(sizeof(PATHPOINT))) == NULL)
     return -1;
 }
 else{
   if((temp=(PATHPOINT *)X__Realloc(pathlist[pa].pts,
       sizeof(PATHPOINT)*(pathlist[pa].n+1))) == NULL)return pathlist[pa].n;
   pathlist[pa].pts=temp;
 }
 pathlist[pa].pts[pathlist[pa].n].p.x=x;
 pathlist[pa].pts[pathlist[pa].n].p.y=y;
 pathlist[pa].pts[pathlist[pa].n].type=0;
 pathlist[pa].pts[pathlist[pa].n].hand=0;
 pathlist[pa].pts[pathlist[pa].n].bent=0;
 pathlist[pa].n++;
 return pathlist[pa].n - 1;
}

static void GetXtraPoints(int w, PATHPOINT *pp, PATHPOINT *pp1,
                          long *xr, long *yr){
 double x0,x1,x2,x3,b,c,cc,bb;
 if(w == 1){
   x0=(double)(pp->p.x);   x1=(double)(pp->p1.x);
   x2=(double)(pp1->p2.x); x3=(double)(pp1->p.x);
 }
 else{
   x0=(double)(pp->p.x);   x1=(double)(pp->p2.x);
   x2=(double)(pp1->p1.x); x3=(double)(pp1->p.x);
 }
 c=3.0*(x1-x0);
 b=3.0*(x2-2.0*x1+x0);
 bb=b/4.0;
 cc=c*0.5; x1=x0+cc/3.0;
 *xr = (long)(bb/3.0+2.0*x1-x0);
 if(w == 1){
   x0=(double)(pp->p.y);   x1=(double)(pp->p1.y);
   x2=(double)(pp1->p2.y); x3=(double)(pp1->p.y);
 }
 else{
   x0=(double)(pp->p.y);   x1=(double)(pp->p2.y);
   x2=(double)(pp1->p1.y); x3=(double)(pp1->p.y);
 }
 c=3.0*(x1-x0);
 b=3.0*(x2-2.0*x1+x0);
 bb=b/4.0;
 cc=c*0.5; x1=x0+cc/3.0;
 *yr = (long)(bb/3.0+2.0*x1-x0);
}

static void InsertVertex(void){
 BOOL bInsert;
 int i,bCurve=0;
 PTH *pth;
 PATHPOINT *pp,*pp1;
 long x,y,x1,y1,x2,y2;
 pth=(pathlist + Lp);
 if(Lpp < pth->n - 1)bInsert=TRUE; else bInsert=FALSE;
 if(CreatePathPoint(Lp,0,0) < 0)return;
 pth=(pathlist + Lp);
 if(bInsert){
   pp1=(pth->pts + Lpp+1); pp=(pth->pts + Lpp);
   if(pp1->type == 1 || pp->type == 1){
     GetBezierPoint(0.5,pp,pp1,&x,&y);
     if(pp->type == 0){
       int dx,dy;
       dx=pp1->p2.x - pp->p.x;
       dy=pp1->p2.y - pp->p.y;
       pp->p1.x=(double)pp->p.x + 0.05*dx;
       pp->p1.y=(double)pp->p.y + 0.05*dy;
     }
     if(pp1->type == 0){
       int dx,dy;
       dx=pp->p1.x - pp1->p.x;
       dy=pp->p1.y - pp1->p.y;
       pp1->p2.x=(double)pp1->p.x + 0.05*dx;
       pp1->p2.y=(double)pp1->p.y + 0.05*dy;
     }
     GetXtraPoints(1,pp,pp1,&x1,&y1);
     GetXtraPoints(2,pp1,pp,&x2,&y2);
     pp1->p2.x = pp1->p.x + (pp1->p2.x - pp1->p.x)/2;
     pp1->p2.y = pp1->p.y + (pp1->p2.y - pp1->p.y)/2;
     pp->p1.x = pp->p.x + (pp->p1.x - pp->p.x)/2;
     pp->p1.y = pp->p.y + (pp->p1.y - pp->p.y)/2;
     bCurve=1;
   }
   else{
     x=(pp1->p.x + pp->p.x)/2;
     y=(pp1->p.y + pp->p.y)/2;
   }
   for(i=pth->n - 1;i > Lpp; i--){
     memcpy((pth->pts + i),(pth->pts + i-1),sizeof(PATHPOINT));
   }
 }
 else{
   pp1=(pth->pts); pp=(pth->pts + Lpp);
   if(pp1->type == 1 || pp->type == 1){
     GetBezierPoint(0.5,pp,pp1,&x,&y);
     if(pp->type == 0){
       int dx,dy;
       dx=pp1->p2.x - pp->p.x;
       dy=pp1->p2.y - pp->p.y;
       pp->p1.x=(double)pp->p.x + 0.05*dx;
       pp->p1.y=(double)pp->p.y + 0.05*dy;
     }
     if(pp1->type == 0){
       int dx,dy;
       dx=pp->p1.x - pp1->p.x;
       dy=pp->p1.y - pp1->p.y;
       pp1->p2.x=(double)pp1->p.x + 0.05*dx;
       pp1->p2.y=(double)pp1->p.y + 0.05*dy;
     }
     GetXtraPoints(1,pp,pp1,&x1,&y1);
     GetXtraPoints(2,pp1,pp,&x2,&y2);
     pp1->p2.x = pp1->p.x + (pp1->p2.x - pp1->p.x)/2;
     pp1->p2.y = pp1->p.y + (pp1->p2.y - pp1->p.y)/2;
     pp->p1.x = pp->p.x + (pp->p1.x - pp->p.x)/2;
     pp->p1.y = pp->p.y + (pp->p1.y - pp->p.y)/2;
     bCurve=1;
   }
   else {
     x=(pp1->p.x + pp->p.x)/2;
     y=(pp1->p.y + pp->p.y)/2;
   }
 }
 ((pth->pts)+Lpp+1)->p.x=x;
 ((pth->pts)+Lpp+1)->p.y=y;
 ((pth->pts)+Lpp+1)->type=bCurve;
 if(bCurve){
   ((pth->pts)+Lpp+1)->p2.x=x1;
   ((pth->pts)+Lpp+1)->p2.y=y1;
   ((pth->pts)+Lpp+1)->p1.x=x2;
   ((pth->pts)+Lpp+1)->p1.y=y2;
 }
 ((pth->pts)+Lpp+1)->hand=0;
 ((pth->pts)+Lpp+1)->bent=0;
}

static double Cubic(double t, double x0, double x1, double x2, double x3){
 double a,b,c;
 c=3.0*(x1-x0);
 b=3.0*(x2-2.0*x1+x0);
 a=3.0*(x1-x2)+x3-x0;
 return x0+t*(t*(t*a+b)+c);
}

static void DrawBezierCurve(HDC hDC, PATHPOINT *pl, PATHPOINT *p){
 double t,dt,x,y,x0,x1,x2,x3,y0,y1,y2,y3,dx,dy;
 x0=pl->p.x; y0=pl->p.y;
 if(pl->type == 0){
  dx=p->p2.x - pl->p.x;
  dy=p->p2.y - pl->p.y;
  x1=(double)pl->p.x + 0.05*dx;
  y1=(double)pl->p.y + 0.05*dy;
 }
 else{x1=pl->p1.x; y1=pl->p1.y;}
 if(p->type == 0){
   dx=p->p.x - pl->p1.x;
   dy=p->p.y - pl->p1.y;
   x2=(double)p->p.x - 0.05*dx;
   y2=(double)p->p.y - 0.05*dy;
 }
 else{x2=p->p2.x;  y2=p->p2.y;}
 x3=p->p.x; y3=p->p.y;
 dt=0.05;
 MoveToEx(hDC,(int)x0-WoffX,(int)y0-WoffY,NULL);
 for(t=dt;t<1.0+dt;t+=dt){
   x=Cubic(t,x0,x1,x2,x3);
   y=Cubic(t,y0,y1,y2,y3);
   LineTo(hDC,(int)x-WoffX,(int)y-WoffY);
 }
}

static void GetBezierPoint(double t, PATHPOINT *pl, PATHPOINT *p,
                           long *xp, long *yp){
 double x,y,x0,x1,x2,x3,y0,y1,y2,y3,dx,dy;
 x0=pl->p.x; y0=pl->p.y;
 if(pl->type == 0){
  dx=p->p2.x - pl->p.x;
  dy=p->p2.y - pl->p.y;
  x1=(double)pl->p.x + 0.05*dx;
  y1=(double)pl->p.y + 0.05*dy;
 }
 else{x1=pl->p1.x; y1=pl->p1.y;}
 if(p->type == 0){
   dx=p->p.x - pl->p1.x;
   dy=p->p.y - pl->p1.y;
   x2=(double)p->p.x - 0.05*dx;
   y2=(double)p->p.y - 0.05*dy;
 }
 else{x2=p->p2.x;  y2=p->p2.y;}
 x3=p->p.x; y3=p->p.y;
 *xp=(long)Cubic(t,x0,x1,x2,x3);
 *yp=(long)Cubic(t,y0,y1,y2,y3);
}

static void DrawFromPathPoint(BOOL closed, int p,int pp, POINT *pt,
                              HWND hwnd, HDC hdc){
 HPEN hOldPen;
 HBRUSH hOldBrush;
 int oldROP;
 HDC hDClocal;
 PATHPOINT *ppt,Pp,*lpPp;
 if(p < 0 || pp < 0)return;
 ppt=(pathlist[p].pts + pp);
 if(hdc == NULL)hDClocal=GetDC(hwnd);
 else           hDClocal=hdc;
 hOldPen=SelectObject(hDClocal,GetStockObject(WHITE_PEN));
 hOldBrush=SelectObject(hDClocal,GetStockObject(WHITE_BRUSH));
 oldROP=SetROP2(hDClocal,R2_XORPEN);
 if(ppt->type == 1 || (closed && pathlist[p].pts->type == 1)){
   lpPp=&Pp;
   if(closed){
     lpPp->type=pathlist[p].pts->type;
     lpPp->p1.x=pathlist[p].pts->p1.x;
     lpPp->p1.y=pathlist[p].pts->p1.y;
     lpPp->p2.x=pathlist[p].pts->p2.x;
     lpPp->p2.y=pathlist[p].pts->p2.y;
     lpPp->p.x=pathlist[p].pts->p.x;
     lpPp->p.y=pathlist[p].pts->p.y;
   }
   else{
     lpPp->type=0;
     lpPp->p.x=pt->x; lpPp->p.y=pt->y;
   }
   DrawBezierCurve(hDClocal,ppt,lpPp);
 }
 else{
   MoveToEx(hDClocal,ppt->p.x-WoffX,ppt->p.y-WoffY,NULL);
   if(closed)LineTo(hDClocal,pathlist[p].pts->p.x-WoffX,
                             pathlist[p].pts->p.y-WoffY);
   else      LineTo(hDClocal,pt->x-WoffX,pt->y-WoffY);
 }
 if(!closed)Rectangle(hDClocal,pt->x-2-WoffX,pt->y-2-WoffY,
                               pt->x+3-WoffX,pt->y+3-WoffY);
 SetROP2(hDClocal,oldROP);
 SelectObject(hDClocal,hOldPen);
 SelectObject(hDClocal,hOldBrush);
 if(hdc == NULL)ReleaseDC(hwnd,hDClocal);
}

static void DrawPathPoint(int p, int pp, HWND hwnd, HDC hdc){
 HPEN hOldPen;
 HBRUSH hOldBrush;
 int oldROP;
 HDC hDClocal;
 PATHPOINT *ppt,*ppt1;
 int x1,y1,x2,y2,n;
 if(p < 0 || pp < 0)return;
 n=pathlist[p].n;
 if(pp > n)return;
 if(pp == n){
   if(pathlist[p].closed == 0)return;
   pp=0;
 }
 ppt=(pathlist[p].pts + pp);
 x2=ppt->p.x; y2=ppt->p.y;
 if(pp > 0){
   ppt1=(ppt-1);
   x1=ppt1->p.x; y1=ppt1->p.y;
 }
 else{
   if(pathlist[p].closed){
     ppt1=(ppt+(n-1));
     x1=ppt1->p.x; y1=ppt1->p.y;
   }
   else{
     ppt1=NULL;
     x1=x2; y1=y2;
   }
 }
 if(hdc == NULL)hDClocal=GetDC(hwnd);
 else           hDClocal=hdc;
 hOldPen=SelectObject(hDClocal,GetStockObject(WHITE_PEN));
 hOldBrush=SelectObject(hDClocal,GetStockObject(BLACK_BRUSH));
 oldROP=SetROP2(hDClocal,R2_XORPEN);
 if(ppt1 != NULL && (ppt->type == 1 || ppt1->type == 1))
   DrawBezierCurve(hDClocal,ppt1,ppt);
 else{
   MoveToEx(hDClocal,x1-WoffX,y1-WoffY,NULL);
   LineTo(hDClocal,x2-WoffX,y2-WoffY);
 }
 Rectangle(hDClocal,x2-2-WoffX,y2-2-WoffY,
                    x2+3-WoffX,y2+3-WoffY);
 if(ppt->hand == 1 && ppt->type == 1){
   int n;
   if(pp < pathlist[p].n - 1 || pathlist[p].closed || tracetool == 1){
     MoveToEx(hDClocal,ppt->p1.x-WoffX,ppt->p1.y-WoffY,NULL);
     Rectangle(hDClocal,ppt->p1.x-1-WoffX,ppt->p1.y-1-WoffY,
                        ppt->p1.x+2-WoffX,ppt->p1.y+2-WoffY);
     LineTo(hDClocal,x2-WoffX,y2-WoffY);
   }
   if(pp > 0 || pathlist[p].closed){
     MoveToEx(hDClocal,x2-WoffX,y2-WoffY,NULL);
     LineTo(hDClocal,ppt->p2.x-WoffX,ppt->p2.y-WoffY);
     Rectangle(hDClocal,ppt->p2.x-1-WoffX,ppt->p2.y-1-WoffY,
                        ppt->p2.x+2-WoffX,ppt->p2.y+2-WoffY);
   }
 }
 SetROP2(hDClocal,oldROP);
 SelectObject(hDClocal,hOldPen);
 SelectObject(hDClocal,hOldBrush);
 if(hdc == NULL)ReleaseDC(hwnd,hDClocal);
}

static void MoveWholePath(int x, int y, HWND hWnd){
 PATHPOINT *pp;
 int j,n,dx,dy;
 if(Lp < 0 || Lpp < 0)return;
 pp=((pathlist + Lp)->pts + Lpp);
 n=(pathlist + Lp)->n;
 dx = x - pp->p.x; dy = y - pp->p.y;
 for(j=0;j<n;j++)DrawPathPoint(Lp,j,hWnd,NULL);
 pp=(pathlist + Lp)->pts;
 for(j=0;j<n;j++){
   pp->p.x += dx; pp->p1.x += dx; pp->p2.x += dx;
   pp->p.y += dy; pp->p1.y += dy; pp->p2.y += dy;
   pp++;
 }
 for(j=0;j<n;j++)DrawPathPoint(Lp,j,hWnd,NULL);
}

static void BuildBezierCurve(PATHPOINT *pl, PATHPOINT *p,
                             long Scale, BOOL fv){
 int flag=0;
 long i,n;
 double t,dt,dts,x,y,x0,x1,x2,x3,y0,y1,y2,y3,dx,dy;
 x0=pl->p.x; y0=pl->p.y;
 if(pl->type == 0){
  dx=p->p2.x - pl->p.x;
  dy=p->p2.y - pl->p.y;
  x1=(double)pl->p.x + 0.05*dx;
  y1=(double)pl->p.y + 0.05*dy;
  flag=1;
 }
 else{x1=pl->p1.x; y1=pl->p1.y;}
 if(p->type == 0){
   dx=p->p.x - pl->p1.x;
   dy=p->p.y - pl->p1.y;
   x2=(double)p->p.x - 0.05*dx;
   y2=(double)p->p.y - 0.05*dy;
   flag=2;
 }
 else{x2=p->p2.x;  y2=p->p2.y;}
 x3=p->p.x; y3=p->p.y;
 n=10;
 dt=1.0/(double)n;
 if(flag == 1){
   dts=2*dt;
   dt=(1.0-dts)/(double)(n-1);
 }
 else if(flag == 2){
   dt=(1.0-2.0*dt)/(double)(n-1);
   dts=dt;
 }
 else dts=dt;
 if(fv)n--; /* don't go right to end if closing curve */
 UpdateVertexHeap(Nvert+n);
 UpdateEdgeHeap(Nedge+n);
 for(i=0,t=dts;i<n;i++,t+=dt){
   if(!fv && i == n-1)t=1.0;
   x=Cubic(t,x0,x1,x2,x3);
   y=Cubic(t,y0,y1,y2,y3);
   CreateVertex();
   (MainVp+Nvert-1)->xyz[0]=(x-PAGESIZE/2)*Scale;
   (MainVp+Nvert-1)->xyz[1]=NpointerY;
   (MainVp+Nvert-1)->xyz[2]=(PAGESIZE/2-y)*Scale;
   CreateEdge(Nvert-1,Nvert-2);
 }
}

static void BuildFromTrace(HWND hWnd){
 RECT rc;
 PATHPOINT *ppt,*ppt1;
 int x1,y1,x2,y2;
 int i,j,n;
 PATHPOINT *pp;
 long Scale,first_vertex;
 if(Np == 0 || pathlist == NULL)return;
 GetClientRect(hWnd,&rc);
 Scale=100;
 for(i=0;i<Np;i++){
   pp=pathlist[i].pts;
   if(pp != NULL){
     ppt=(pathlist[i].pts);
     n=pathlist[i].n;
     x1=ppt->p.x; y1=ppt->p.y;
     UpdateVertexHeap(Nvert+1);
     CreateVertex();
     first_vertex=Nvert-1;
     (MainVp+Nvert-1)->xyz[0]=(x1-PAGESIZE/2)*Scale;
     (MainVp+Nvert-1)->xyz[1]=NpointerY;
     (MainVp+Nvert-1)->xyz[2]=(PAGESIZE/2-y1)*Scale;
     if(n > 1)for(j=1;j<n;j++){
       ppt=(pathlist[i].pts + j);
       x2=ppt->p.x; y2=ppt->p.y;
       ppt1=(ppt-1);
       if(ppt->type == 1 || ppt1->type == 1)
         BuildBezierCurve(ppt1,ppt,Scale,FALSE);
       else{
         UpdateVertexHeap(Nvert+1);
         CreateVertex();
         (MainVp+Nvert-1)->xyz[0]=(x2-PAGESIZE/2)*Scale;
         (MainVp+Nvert-1)->xyz[1]=NpointerY;
         (MainVp+Nvert-1)->xyz[2]=(PAGESIZE/2-y2)*Scale;
         UpdateEdgeHeap(Nedge+1);
         CreateEdge(Nvert-1,Nvert-2);
       }
     }
     if(pathlist[i].closed){
       ppt=pathlist[i].pts; ppt1=(ppt + n-1);
       if(ppt->type == 1 || ppt1->type == 1)
         BuildBezierCurve(ppt1,ppt,Scale,TRUE);
       UpdateEdgeHeap(Nedge+1);
       CreateEdge(Nvert-1,first_vertex);
     }
   }
 }
}

static void WritePaths(void){
 FILE *fp;
 PTH  *p;
 PATHPOINT *pp;
 char signon[]="EBPH";
 int i,j;
 if((fp=fopen(gszFile,"wb")) == NULL){
   MessageBox(GetFocus(),"Failed to open file","Bezier Module",MB_OK);
   return;
 }
 fwrite(signon,1,4,fp);
 fwrite(&Np,sizeof(int),1,fp);
 p=pathlist;
 for(i=0;i<Np;i++){
   fwrite(&(p->n),sizeof(int),1,fp);
   fwrite(&(p->closed),sizeof(int),1,fp);
   pp=p->pts;
   if(p->n > 0)for(j=0;j<p->n;j++){
     fwrite(&(pp->type),sizeof(int),1,fp);
     fwrite(&(pp->bent),sizeof(int),1,fp);
     fwrite(&(pp->p),sizeof(POINT),1,fp);
     fwrite(&(pp->p1),sizeof(POINT),1,fp);
     fwrite(&(pp->p2),sizeof(POINT),1,fp);
     pp++;
   }
   p++;
 }
 fclose(fp);
}

static void ReadPaths(void){
 FILE *fp;
 POINT p,p1,p2;
 PATHPOINT *pp;
 char signon[5];
 int Np1,n,closed,type,bent;
 int i,j,k;
 if((fp=fopen(gszFile,"rb")) == NULL){
   MessageBox(GetFocus(),"Failed to open file","Bezier Module",MB_OK);
   return;
 }
 DeleteAllPath();
 fread(signon,1,4,fp); signon[4]=0;
 fread(&Np1,sizeof(int),1,fp);
//{char tempstr[255]; sprintf(tempstr,"N Paths=%d",Np1);
//MessageBox(GetFocus(),tempstr,"debug",MB_OK);}
 if(Np1 > 0)for(i=0;i<Np1;i++){
//{char tempstr[255]; sprintf(tempstr,"reading %d",i);
//MessageBox(GetFocus(),tempstr,"debug",MB_OK);}
   fread(&n,sizeof(int),1,fp);
//{char tempstr[255]; sprintf(tempstr,"npoints %d",n);
//MessageBox(GetFocus(),tempstr,"debug",MB_OK);}
   fread(&closed,sizeof(int),1,fp);
//{char tempstr[255]; sprintf(tempstr,"closed=%d ",closed);
//MessageBox(GetFocus(),tempstr,"debug",MB_OK);}
   if(CreatePath() < 0)goto XERR;
   pathlist[Np-1].closed=closed;
   if(n > 0)for(j=0;j<n;j++){
     fread(&type,sizeof(int),1,fp);
     fread(&bent,sizeof(int),1,fp);
     fread(&p,sizeof(POINT),1,fp);
     fread(&p1,sizeof(POINT),1,fp);
     fread(&p2,sizeof(POINT),1,fp);
     if((k=CreatePathPoint(Np-1,(int)p.x,(int)p.y)) < 0)goto XERR;
     pp=((pathlist + Np-1)->pts + k);
     pp->type=type; pp->bent=bent;
     pp->p1.x=p1.x; pp->p1.y=p1.y;
     pp->p2.x=p2.x; pp->p2.y=p2.y;
   }
 }
 fclose(fp);
 return;
 XERR:
 MessageBox(GetFocus(),"Memory error","Bezier Module",MB_OK);
 DeleteAllPath();
 fclose(fp);
 return;
}