//---------------------------------------------------------------------------
#include <vcl.h>
#include <math.h>
#pragma hdrstop

#include "Plan.h"
#include "Progress_F.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
//---------------------------------------------------------------------------
static struct {
  char sht[5][3][3];
  char nml[5][5][5];
  char lng[5][7][7];
} Hair = {
  {
    { { 1, 0, 0 }, { 0, 1, 0 }, { 0, 0, 1 } },
    { { 1, 1, 0 }, { 0, 0, 1 }, { 0, 1, 0 } },
    { { 0, 0, 1 }, { 0, 0, 1 }, { 1, 1, 0 } },
    { { 0, 0, 1 }, { 0, 1, 0 }, { 1, 0, 0 } },
    { { 1, 0, 0 }, { 1, 0, 1 }, { 0, 1, 0 } }
  }, {
    {
      { 1, 0, 0, 0, 0 }, { 0, 1, 0, 0, 0 }, { 0, 1, 0, 0, 0 },
      { 0, 0, 1, 1, 0 }, { 0, 0, 0, 0, 1 }
    }, {
      { 1, 1, 1, 0, 0 }, { 0, 0, 0, 1, 0 }, { 0, 0, 1, 0, 0 },
      { 0, 0, 1, 0, 0 }, { 0, 1, 0, 0, 0 }
    }, {
      { 0, 0, 0, 0, 1 }, { 0, 0, 0, 0, 1 }, { 0, 1, 1, 1, 0 },
      { 0, 1, 0, 0, 0 }, { 1, 1, 0, 0, 0 }
    }, {
      { 0, 0, 1, 1, 0 }, { 1, 1, 0, 0, 1 }, { 0, 0, 0, 0, 1 },
      { 0, 0, 0, 1, 0 }, { 0, 0, 0, 1, 0 }
    }, {
      { 1, 1, 1, 0, 0 }, { 0, 0, 0, 1, 0 }, { 0, 0, 0, 0, 1 },
      { 0, 0, 0, 0, 1 }, { 0, 0, 0, 1, 0 }
    }
  }, {
    {
      { 1, 0, 0, 0, 0, 0, 0 }, { 0, 1, 0, 0, 0, 0, 0 },
      { 0, 1, 0, 0, 0, 0, 0 }, { 0, 1, 0, 0, 0, 0, 0 },
      { 0, 0, 1, 1, 0, 0, 0 }, { 0, 0, 0, 1, 0, 0, 1 },
      { 0, 0, 0, 0, 1, 1, 0 }
    }, {
      { 1, 1, 1, 0, 0, 0, 0 }, { 0, 0, 0, 1, 0, 0, 0 },
      { 0, 0, 1, 0, 0, 0, 0 }, { 0, 1, 0, 0, 0, 0, 0 },
      { 0, 0, 1, 0, 0, 0, 1 }, { 0, 0, 1, 0, 0, 1, 0 },
      { 0, 0, 0, 1, 1, 0, 0 }
    }, {
      { 0, 0, 0, 0, 1, 1, 0 }, { 0, 0, 0, 0, 1, 0, 1 },
      { 0, 1, 1, 1, 0, 0, 0 }, { 0, 1, 0, 0, 0, 0, 0 },
      { 0, 1, 0, 0, 0, 0, 0 }, { 0, 0, 1, 0, 0, 0, 0 },
      { 1, 1, 0, 0, 0, 0, 0 }
    }, {
      { 0, 0, 1, 1, 0, 0, 0 }, { 1, 1, 0, 0, 1, 0, 0 },
      { 0, 0, 0, 0, 1, 0, 0 }, { 0, 0, 1, 1, 0, 0, 0 },
      { 0, 1, 0, 0, 0, 0, 0 }, { 0, 0, 1, 0, 0, 0, 0 },
      { 0, 0, 1, 1, 1, 0, 0 }
    }, {
      { 1, 0, 0, 0, 0, 0, 0 }, { 1, 0, 0, 0, 0, 0, 0 },
      { 0, 1, 1, 0, 0, 0, 0 }, { 0, 0, 1, 0, 0, 0, 0 },
      { 0, 0, 0, 1, 1, 1, 0 }, { 0, 0, 0, 0, 0, 1, 0 },
      { 0, 0, 0, 0, 0, 0, 1 }
    }
  }
};
//---------------------------------------------------------------------------
// TKnapsack
//---------------------------------------------------------------------------
int __fastcall TKnapsack::Recursion(int t, int i)
{
  if (t==min) return 1;
  else if (t<min || i==dn) return 0;
  else if (Recursion(t-data[i], i+1)) {
    result[rn++] = i; return 1;
  } else return Recursion(t, i+1);
}
//---------------------------------------------------------------------------
void __fastcall TKnapsack::Process(int t)
{
  min = 0;
  while (abs(min)<t) {
    Recursion(t, 0);
    if (rn) break;
    min = -min;
    if (min<=0) min--;
  }
}
//---------------------------------------------------------------------------
// TPlan
//---------------------------------------------------------------------------
__fastcall TPlan::TPlan()
{
  Yarn = new TYarnArrange;
  Texture = new TTextureArrange;
  xwp = ywt = NULL;
  bmFront = bmBack = NULL;
}
//---------------------------------------------------------------------------
__fastcall TPlan::~TPlan()
{
  if (Yarn) delete Yarn;
  if (Texture) delete Texture;
	if (xwp) delete xwp;
	if (ywt) delete ywt;
  if (bmFront) delete bmFront;
  if (bmBack) delete bmBack;
}
//---------------------------------------------------------------------------
// Private Methods
//---------------------------------------------------------------------------
void __fastcall TPlan::InitYarnDot(int i)
{
  int j, k;
  double l1, l2, gap;
  TYarnArray *yad;

  if (Yarn->Array[i]->Count) {
    data[i] = new Data[Yarn->Array[i]->Count];
    memset(data[i], 0, sizeof(Data));
    cnt[i] = 0;
    l1 = l2 = 0.0;
    for (j=0; j<Yarn->Array[i]->Count; j++) {
	    yad = (TYarnArray *)Yarn->Array[i]->Items[j];
      for (k=0; k<cnt[i]; k++) {
        if (yad->code==data[i][k].code && yad->yarns==data[i][k].yarns) {
          data[i][j].num = k;
          if (yad->method==W_REVERSE) {
            data[i][k].max += 2*yad->repeat;
          } else {
            data[i][k].max += yad->repeat;
          }
          break;
        }
      }
      if (k>=cnt[i]) {
        data[i][k].code = yad->code;
        data[i][k].yarns = yad->yarns;
        data[i][k].dot = yad->yarns*160/yad->density;
        if (yad->method==W_REVERSE) {
          data[i][k].max = 2*yad->repeat;
        } else {
          data[i][k].max = yad->repeat;
        }
        data[i][j].num = cnt[i]++;
      }
      if (yad->method==W_REVERSE) {
        l1 += 2*yad->yarns*yad->repeat/yad->density;
        l2 += 2*yad->repeat*data[i][k].dot/160.0;
      } else {
        l1 += yad->yarns*yad->repeat/yad->density;
        l2 += yad->repeat*data[i][k].dot/160.0;
      }
    }
    gap = (l1-l2)*160.0+0.5;
    TKnapsack *ks = new TKnapsack(cnt[i]);
    for (j=0; j<cnt[i]; j++) ks->Input(j, data[i][j].max);
    ks->Process(gap);
    for (j=0; j<ks->rn; j++) data[i][ks->result[j]].dot++;
    delete ks;
  }
}
//---------------------------------------------------------------------------
void __fastcall TPlan::ExitYarnDot(int i)
{
  if (data[i]) { delete data[i]; data[i] = NULL; }
}
//---------------------------------------------------------------------------
int __fastcall TPlan::Change(int i, int &n, int &o, int &r, int &repeat)
{
	TList *Array = Yarn->Array[i];

  if (((TYarnArray *)Array->Items[n])->method==W_CENTER) {
    if (o>0) {
      o--;
      while (o>=0 && ((TYarnArray *)Array->Items[o])->code==0) o--;
      if (((TYarnArray *)Array->Items[o])->method!=W_REVERSE) {
        if (repeat>1) {
          repeat--;
          o = r;
        } else {
          n++;
          while (n<Array->Count && ((TYarnArray *)Array->Items[n])->code==0) n++;
          if (n>=Array->Count) {
            if (Yarn->bFinish[i]) {
              n = 0;
              repeat = ((TYarnArray *)Array->Items[n])->repeat;
              r = n;
            } else return 1;
          }
          o = n;
        }
      } else {
        if (((TYarnArray *)Array->Items[o])->repeat!=((TYarnArray *)Array->Items[r])->repeat) {
          if (repeat>1) {
            repeat--;
            o = r;
          } else {
            repeat = ((TYarnArray *)Array->Items[o])->repeat;
            r = o;
          }
        }
      }
    } else {
      if (repeat>1) {
        repeat--;
        o = r;
      } else {
        n++;
        while (n<Array->Count && ((TYarnArray *)Array->Items[n])->code==0) n++;
        if (n>=Array->Count) {
          if (Yarn->bFinish[i]) {
            n = 0;
            repeat = ((TYarnArray *)Array->Items[n])->repeat;
            r = n;
          } else return 1;
        }
        o = n;
      }
    }
  } else {
    n++;
    while (n<Array->Count && ((TYarnArray *)Array->Items[n])->code==0) n++;
    if (n<Array->Count) {
	    if (((TYarnArray *)Array->Items[n])->repeat!=((TYarnArray *)Array->Items[r])->repeat) {
  	    if (repeat>1) {
    	    repeat--;
      	  n = r;
	      } else {
  	      repeat = ((TYarnArray *)Array->Items[n])->repeat;
    	    r = n;
      	}
	    }
    } else {
   	  if (Yarn->bFinish[i]) {
     	  n = 0;
       	repeat = ((TYarnArray *)Array->Items[n])->repeat;
        r = n;
 	    } else return 1;
    }
    o = n;
  }
  return 0;
}
//---------------------------------------------------------------------------
void __fastcall TPlan::InitWeaveData(TWeaveData &wd, int i, int o)
{
	TYarnArray *ya = (TYarnArray *)Yarn->Array[i]->Items[o];
  if (ya->yarns>0) {
	  wd.cv = (ya->code-1)>>3;
  	wd.cr = (ya->code-1)&0x07;
	  wd.l = Yarn->Choice[wd.cv].Data->Length;
  	wd.s = Yarn->Choice[wd.cv].Data->Width;
	  wd.w = Yarn->Choice[wd.cv].Data->Thick;
  	wd.hl = (wd.s-wd.w)>>1;
	  wd.dpy = (double)data[i][data[i][o].num].dot/ya->yarns;
  	wd.gap = wd.dpy-wd.w;
	  if (wd.gap>0) {
  	  wd.gap *= wd.w/wd.gap;
    	if (wd.gap>wd.w) wd.gap = wd.w;
	  } else wd.w = ceil(wd.dpy);
  	wd.t = (wd.s-wd.w)>>1;
	  wd.ydc = Yarn->Choice[wd.cv].Color[wd.cr];
  	wd.ydm = Yarn->Choice[wd.cv].Data->Map;
    wd.ycn = (wd.cv<<11)+(wd.cr<<8);
  } else {
	  wd.dpy = 0;
  }
}
//---------------------------------------------------------------------------
void __fastcall TPlan::WarpBar(TTexpiaBitmap *Bitmap, TWeaveData &wd, int y)
{
	BYTE *yp, c, *pp;
  int x, vx;
  COLORREF rgb;

  yp = (BYTE *)wd.ydm+(*(xwp+wd.tc)+y)%wd.l;
  pp = Bitmap->GetScanLine(y)+3*wd.v;
  for (x=0; x<wd.w; x++, pp+=3) {
    vx = wd.v+x;
    if (vx<Bitmap->Width) {
      c = *(yp+(x+wd.t)*wd.l);
      if (c) {
      	if (WeaveCondition.WovenEffect==WESolid) {
	      	rgb = RGBQUAD2COLORREF(wd.ydc[c>>3]->GetColor(0)->RGB);
        } else {
	      	rgb = RGBQUAD2COLORREF(wd.ydc[c>>3]->GetColor((c&7)-4)->RGB);
        }
	    	SetPixel24(pp, rgb);
      }
    }
  }
  Bitmap->PutScanLine(y);
}
//---------------------------------------------------------------------------
void __fastcall TPlan::WeftBar(TTexpiaBitmap *Bitmap, TWeaveData &wd, int x)
{
	BYTE *yp, c, *pp;
  int y, vy;
  COLORREF rgb;

  yp = (BYTE *)wd.ydm+(*(ywt+wd.tc)+x)%wd.l;
  for (y=0; y<wd.w; y++) {
    vy = wd.v+y;
    if (vy<Bitmap->Height) {
		  pp = Bitmap->GetScanLine(vy)+3*x;
      c = *(yp+(y+wd.t)*wd.l);
      if (c) {
      	if (WeaveCondition.WovenEffect==WESolid) {
	      	rgb = RGBQUAD2COLORREF(wd.ydc[c>>3]->GetColor(0)->RGB);
        } else {
	      	rgb = RGBQUAD2COLORREF(wd.ydc[c>>3]->GetColor((c&7)-4)->RGB);
        }
	    	SetPixel24(pp, rgb);
      }
		  Bitmap->PutScanLine(vy);
    }
  }
}
//---------------------------------------------------------------------------
void __fastcall TPlan::Warp(TWeaveData &wd, WORD *pp)
{
  BYTE *yp1;
  WORD *pp1;
  int x;

  yp1 = (BYTE *)wd.ydm+*(xwp+wd.tc)+wd.t*wd.l;
  pp1 = pp+wd.v;
  if (wd.v+wd.w<bmWarp->size.x) {
    for (x=0; x<wd.w; x++, yp1+=wd.l, pp1++) {
      if (*yp1) *pp1 = wd.ycn+*yp1;
    }
  } else {
    for (x=0; x<wd.w; x++, yp1+=wd.l, pp1++) {
      if (wd.v+x<bmWarp->size.x && *yp1) *pp1 = wd.ycn+*yp1;
    }
  }
  if (++*(xwp+wd.tc)>=wd.l) *(xwp+wd.tc) = 0;
}
//---------------------------------------------------------------------------
void __fastcall TPlan::WarpHair(TWeaveData &wd, WORD *pp, WORD *hp)
{
  BYTE *yp1;
  WORD *pp1, *hp1;
  int x;

  yp1 = (BYTE *)wd.ydm+*(xwp+wd.tc)+wd.t*wd.l;
  pp1 = pp+wd.v;
  if (wd.v+wd.w<bmWarp->size.x) {
    for (x=0; x<wd.w; x++, yp1+=wd.l, pp1++) {
      if (*yp1) *pp1 = wd.ycn+*yp1;
    }
  } else {
    for (x=0; x<wd.w; x++, yp1+=wd.l, pp1++) {
      if (wd.v+x<bmWarp->size.x && *yp1) *pp1 = wd.ycn+*yp1;
    }
  }
  yp1 = (BYTE *)wd.ydm+*(xwp+wd.tc);
  hp1 = hp+wd.v-wd.hl;
  if (wd.v-wd.hl>=0 && wd.v<bmHair->size.x) {
    for (x=-wd.hl; x<0; x++, yp1+=wd.l, hp1++) {
      if (*yp1) *hp1 = wd.ycn+*yp1;
    }
  } else {
    for (x=-wd.hl; x<0; x++, yp1+=wd.l, hp1++) {
      if (wd.v+x>=0 && wd.v+x<bmHair->size.x && *yp1) *hp1 = wd.ycn+*yp1;
    }
  }
  yp1 = (BYTE *)wd.ydm+*(xwp+wd.tc)+(wd.s-wd.hl)*wd.l;
  hp1 = hp+wd.v+wd.w;
  if (wd.v+wd.w+wd.hl<bmHair->size.x) {
    for (x=wd.w; x<wd.w+wd.hl; x++, yp1+=wd.l, hp1++) {
      if (*yp1) *hp1 = wd.ycn+*yp1;
    }
  } else {
    for (x=wd.w; x<wd.w+wd.hl; x++, yp1+=wd.l, hp1++) {
      if (wd.v+x<bmHair->size.x && *yp1) *hp1 = wd.ycn+*yp1;
    }
  }
  if (++*(xwp+wd.tc)>=wd.l) *(xwp+wd.tc) = 0;
}
//---------------------------------------------------------------------------
void __fastcall TPlan::calc_warp()
{
	TList *Array = Yarn->Array[WARP];
  TWeaveData wd;
  WORD *pp, *hp;
  int x, y, n, o, ic, r, repeat, tl;
  double al, gs, gt;

	memset(bmWarp->pointer(), 0, 2*bmWarp->size.x*bmWarp->size.y);
  TProgressForm *Form = new TProgressForm(NULL);
  Form->Title = "Weave - Warp";
  Form->Show();
  tl = 0; al = tl;
  wd.tc = ic = 0;
  n = o = 0;
  repeat = ((TYarnArray *)Array->Items[n])->repeat;
  r = n;
  InitWeaveData(wd, WARP, o);
  if (WeaveCondition.HairEffect==HEActual) {
		memset(bmHair->pointer(), 0, 2*bmHair->size.x*bmHair->size.y);
    while (al+wd.dpy<bmWarp->size.x) {
      Form->Ratio = al/bmWarp->size.x;
      if (wd.gap>0.0) {
        gs = (rand()%int(wd.gap*100))/100.0;
        gt = wd.gap/(16+rand()%10);
        pp = bmWarp->pointer();
        hp = bmHair->pointer();
        for (y=0; y<bmWarp->size.y; y++) {
          wd.v = al+gs;
          if (gt>=0) {
            if (gs+gt>=wd.gap) gt = -gt;
          } else {
            if (gs+gt<0) gt = -gt;
          }
          gs += gt;
          WarpHair(wd, pp, hp);
          pp += bmWarp->size.x;
          hp += bmHair->size.x;
        }
      } else {
        wd.v = al;
        pp = bmWarp->pointer();
        hp = bmHair->pointer();
        for (y=0; y<bmWarp->size.y; y++) {
          WarpHair(wd, pp, hp);
          pp += bmWarp->size.x;
          hp += bmHair->size.x;
        }
      }
      wd.tc++; ic++;
      al += wd.dpy;
      if (ic>=((TYarnArray *)Array->Items[o])->yarns) {
        ic = 0;
        tl += data[WARP][data[WARP][o].num].dot; al = tl;
        Change(WARP, n, o, r, repeat); InitWeaveData(wd, WARP, o);
      }
    }
  } else {
    while (al+wd.dpy<bmWarp->size.x) {
      Form->Ratio = al/bmWarp->size.x;
      if (wd.gap>0.0) {
        gs = (rand()%int(wd.gap*100))/100.0;
        gt = wd.gap/(16+rand()%10);
        pp = bmWarp->pointer();
        for (y=0; y<bmWarp->size.y; y++) {
          wd.v = al+gs;
          if (gt>=0) {
            if (gs+gt>=wd.gap) gt = -gt;
          } else {
            if (gs+gt<0) gt = -gt;
          }
          gs += gt;
          Warp(wd, pp);
          pp += bmWarp->size.x;
        }
      } else {
        wd.v = al;
        pp = bmWarp->pointer();
        for (y=0; y<bmWarp->size.y; y++) {
          Warp(wd, pp);
          pp += bmWarp->size.x;
        }
      }
      wd.tc++; ic++;
      al += wd.dpy;
      if (ic>=((TYarnArray *)Array->Items[o])->yarns) {
        ic = 0;
        tl += data[WARP][data[WARP][o].num].dot; al = tl;
        Change(WARP, n, o, r, repeat); InitWeaveData(wd, WARP, o);
      }
    }
  }
  delete Form;
}
//---------------------------------------------------------------------------
void __fastcall TPlan::Weft(TWeaveData &wd, WORD *pp)
{
  BYTE *yp1;
  WORD *pp1;
  int y;

  yp1 = (BYTE *)wd.ydm+*(ywt+wd.tc)+wd.t*wd.l;
  pp1 = pp+wd.v*bmWeft->size.x;
  if (wd.v+wd.w<bmWeft->size.y) {
    for (y=0; y<wd.w; y++, yp1+=wd.l, pp1+=bmWeft->size.x) {
      if (*yp1) *pp1 = wd.ycn+*yp1;
    }
  } else {
    for (y=0; y<wd.w; y++, yp1+=wd.l, pp1+=bmWeft->size.x) {
      if (wd.v+y<bmWeft->size.y && *yp1) *pp1 = wd.ycn+*yp1;
    }
  }
  if (++*(ywt+wd.tc)>=wd.l) *(ywt+wd.tc) = 0;
}
//---------------------------------------------------------------------------
void __fastcall TPlan::WeftHair(TWeaveData &wd, WORD *pp, WORD *hp)
{
  BYTE *yp1;
  WORD *pp1, *hp1;
  int y;

  yp1 = (BYTE *)wd.ydm+*(ywt+wd.tc)+wd.t*wd.l;
  pp1 = pp+wd.v*bmWeft->size.x;
  if (wd.v+wd.w<bmWeft->size.y) {
    for (y=0; y<wd.w; y++, yp1+=wd.l, pp1+=bmWeft->size.x) {
      if (*yp1) *pp1 = wd.ycn+*yp1;
    }
  } else {
    for (y=0; y<wd.w; y++, yp1+=wd.l, pp1+=bmWeft->size.x) {
      if (wd.v+y<bmWeft->size.y && *yp1) *pp1 = wd.ycn+*yp1;
    }
  }
  yp1 = (BYTE *)wd.ydm+*(ywt+wd.tc);
  hp1 = hp+(wd.v-wd.hl)*bmHair->size.x;
  if (wd.v-wd.hl>=0 && wd.v<bmHair->size.y) {
    for (y=-wd.hl; y<0; y++, yp1+=wd.l, hp1+=bmHair->size.x) {
      if (*yp1) {
        if (*hp1==0 || wd.h==0) {
          *hp1 = wd.ycn+*yp1;
          wd.h ^= 0xFF;
        }
      }
    }
  } else {
    for (y=-wd.hl; y<0; y++, yp1+=wd.l, hp1+=bmHair->size.x) {
      if (wd.v+y>=0 && wd.v+y<bmHair->size.y && *yp1) {
        if (*hp1==0 || wd.h==0) {
          *hp1 = wd.ycn+*yp1;
          wd.h ^= 0xFF;
        }
      }
    }
  }
  yp1 = (BYTE *)wd.ydm+*(ywt+wd.tc)+(wd.s-wd.hl)*wd.l;
  hp1 = hp+(wd.v+wd.w)*bmHair->size.x;
  if (wd.v+wd.w+wd.hl<bmHair->size.y) {
    for (y=wd.w; y<wd.w+wd.hl; y++, yp1+=wd.l, hp1+=bmHair->size.x) {
      if (*yp1) {
        if (*hp1==0 || wd.h==0) {
          *hp1 = wd.ycn+*yp1;
          wd.h ^= 0xFF;
        }
      }
    }
  } else {
    for (y=wd.w; y<wd.w+wd.hl; y++, yp1+=wd.l, hp1+=bmHair->size.x) {
      if (wd.v+y<bmHair->size.y && *yp1) {
        if (*hp1==0 || wd.h==0) {
          *hp1 = wd.ycn+*yp1;
          wd.h ^= 0xFF;
        }
      }
    }
  }
  if (++*(ywt+wd.tc)>=wd.l) *(ywt+wd.tc) = 0;
}
//---------------------------------------------------------------------------
void __fastcall TPlan::calc_weft()
{
	TList *Array = Yarn->Array[WEFT];
  TWeaveData wd;
  WORD *pp, *hp;
  int x, y, n, o, ic, r, repeat, tl;
  double al, gs, gt;

	memset(bmWeft->pointer(), 0, 2*bmWeft->size.x*bmWeft->size.y);
  TProgressForm *Form = new TProgressForm(NULL);
  Form->Title = "Weave - Weft";
  Form->Show();
  tl = 0; al = tl;
  wd.tc = ic = 0;
  n = o = 0;
  repeat = ((TYarnArray *)Array->Items[n])->repeat;
  r = n;
  wd.h = 0;
  InitWeaveData(wd, WEFT, o);
  if (WeaveCondition.HairEffect==HEActual) {
    while (al+wd.dpy<bmWeft->size.y) {
      Form->Ratio = al/bmWeft->size.y;
      if (wd.gap>0.0) {
        gs = (rand()%int(wd.gap*100))/100.0;
        gt = wd.gap/(16+rand()%10);
        pp = bmWeft->pointer();
        hp = bmHair->pointer();
        for (x=0; x<bmWeft->size.x; x++, pp++, hp++) {
          wd.v = al+gs;
          if (gt>=0) {
            if (gs+gt>=wd.gap) gt = -gt;
          } else {
            if (gs+gt<0) gt = -gt;
          }
          gs += gt;
          WeftHair(wd, pp, hp);
        }
      } else {
        wd.v = al;
        pp = bmWeft->pointer();
        hp = bmHair->pointer();
        for (x=0; x<bmWeft->size.x; x++, pp++, hp++) WeftHair(wd, pp, hp);
      }
      wd.tc++; ic++;
      al += wd.dpy;
      if (ic>=((TYarnArray *)Array->Items[o])->yarns) {
        ic = 0;
        tl += data[WEFT][data[WEFT][o].num].dot; al = tl;
        Change(WEFT, n, o, r, repeat); InitWeaveData(wd, WEFT, o);
      }
    }
  } else {
    while (al+wd.dpy<bmWeft->size.y) {
      Form->Ratio = al/bmWeft->size.y;
      if (wd.gap>0.0) {
        gs = (rand()%int(wd.gap*100))/100.0;
        gt = wd.gap/(16+rand()%10);
        pp = bmWeft->pointer();
        for (x=0; x<bmWeft->size.x; x++, pp++) {
          wd.v = al+gs;
          if (gt>=0) {
            if (gs+gt>=wd.gap) gt = -gt;
          } else {
            if (gs+gt<0) gt = -gt;
          }
          gs += gt;
          Weft(wd, pp);
        }
      } else {
        wd.v = al;
        pp = bmWeft->pointer();
        for (x=0; x<bmWeft->size.x; x++, pp++) Weft(wd, pp);
      }
      wd.tc++; ic++;
      al += wd.dpy;
      if (ic>=((TYarnArray *)Array->Items[o])->yarns) {
        ic = 0;
        tl += data[WEFT][data[WEFT][o].num].dot; al = tl;
        Change(WEFT, n, o, r, repeat); InitWeaveData(wd, WEFT, o);
      }
    }
  }
  delete Form;
}
//---------------------------------------------------------------------------
void __fastcall TPlan::texture_warp(TMemoryArea<WORD> *bm)
{
  WORD *bp, *wp, *wpp;
  int p, x, y;

  wp = bmWarp->pointer(v[WARP], v[WEFT]);
  if (v[WEFT]+dpy[WEFT]<bm->size.y) {
    for (y=0; y<dpy[WEFT]; y++) {
      bp = bm->pointer(v[WARP], v[WEFT]+y); wpp = wp;
      if (v[WARP]+dpy[WARP]<bm->size.x) {
        for (x=0; x<dpy[WARP]; x++, bp++, wpp++) {
          if (*wpp) *bp = *wpp;
        }
      } else {
        for (x=0; x<dpy[WARP]; x++, bp++, wpp++) {
          if (v[WARP]+x<bm->size.x) {
            if (*wpp) *bp = *wpp;
          }
        }
      }
      wp += bmWarp->size.x;
    }
  } else {
    for (y=0; y<dpy[WEFT]; y++) {
      if (v[WEFT]+y<bm->size.y) {
        bp = bm->pointer(v[WARP], v[WEFT]+y); wpp = wp;
        if (v[WARP]+dpy[WARP]<bm->size.x) {
          for (x=0; x<dpy[WARP]; x++, bp++, wpp++) {
            if (*wpp) *bp = *wpp;
          }
        } else {
          for (x=0; x<dpy[WARP]; x++, bp++, wpp++) {
            if (v[WARP]+x<bm->size.x) {
              if (*wpp) *bp = *wpp;
            }
          }
        }
      }
      wp += bmWarp->size.x;
    }
  }
}
//---------------------------------------------------------------------------
void __fastcall TPlan::texture_weft(TMemoryArea<WORD> *bm)
{
  WORD *bp, *wp, *wpp;
  int p, x, y;

  wp = bmWeft->pointer(v[WARP], v[WEFT]);
  if (v[WARP]+dpy[WARP]<bm->size.x) {
    for (x=0; x<dpy[WARP]; x++, wp++) {
      bp = bm->pointer(v[WARP]+x, v[WEFT]); wpp = wp;
      if (v[WEFT]+dpy[WEFT]<bm->size.y) {
        for (y=0; y<dpy[WEFT]; y++) {
          if (*wpp) *bp = *wpp;
          bp += bm->size.x;
          wpp += bmWeft->size.x;
        }
      } else {
        for (y=0; y<dpy[WEFT]; y++) {
          if (v[WEFT]+y<bm->size.y && *wpp) *bp = *wpp;
          bp += bm->size.x;
          wpp += bmWeft->size.x;
        }
      }
    }
  } else {
    for (x=0; x<dpy[WARP]; x++, wp++) {
      if (v[WARP]+x<bm->size.x) {
        bp = bm->pointer(v[WARP]+x, v[WEFT]); wpp = wp;
        if (v[WEFT]+dpy[WEFT]<bm->size.y) {
          for (y=0; y<dpy[WEFT]; y++) {
            if (*wpp) *bp = *wpp;
	          bp += bm->size.x;
            wpp += bmWeft->size.x;
          }
        } else {
          for (y=0; y<dpy[WEFT]; y++) {
            if (v[WEFT]+y<bm->size.y && *wpp) *bp = *wpp;
	          bp += bm->size.x;
            wpp += bmWeft->size.x;
          }
        }
      }
    }
  }
}
//---------------------------------------------------------------------------
void __fastcall TPlan::calc_hair()
{
	WORD *fp, *bp, *hp, fc, bc;
  int x, y, ix, iy, hmp;

  if (WeaveCondition.HairEffect==HEActual) {
    TProgressForm *Form = new TProgressForm(NULL);
    Form->Title = "Weave - Hair";
    Form->Show();
    if (WeaveCondition.BackSide) {
      for (y=0; y<bmFront->size.y; y++) {
        Form->Ratio = (double)y/bmFront->size.y;
        fp = bmFront->pointer(0, y);
        bp = bmBack->pointer(0, y);
        hp = bmHair->pointer(0, y);
        for (x=0; x<bmFront->size.x; x++) {
          switch (WeaveCondition.HairRatio) {
            case 1:
              if (*hp && rand()%5) { *fp = *hp; *bp = *hp; }
              break;
            case 2:
              if (*hp && rand()%4) { *fp = *hp; *bp = *hp; }
              break;
            case 3:
              if (*hp && rand()%3) { *fp = *hp; *bp = *hp; }
              break;
            case 4:
              if (*hp && rand()%2) { *fp = *hp; *bp = *hp; }
              break;
            case 5:
              if (*hp && rand()%3==0) { *fp = *hp; *bp = *hp; }
              break;
            case 6:
              if (*hp && rand()%4==0) { *fp = *hp; *bp = *hp; }
              break;
            case 7:
              if (*hp && rand()%5==0) { *fp = *hp; *bp = *hp; }
              break;
            default:
              if (*hp) { *fp = *hp; *bp = *hp; }
          }
          fp++; bp++; hp++;
        }
      }
    } else {
      for (y=0; y<bmFront->size.y; y++) {
        Form->Ratio = (double)y/bmFront->size.y;
        fp = (WORD *)bmFront->pointer(0, y);
        hp = (WORD *)bmHair->pointer(0, y);
        for (x=0; x<bmFront->size.x; x++) {
          switch (WeaveCondition.HairRatio) {
            case 1: if (*hp && rand()%5) *fp = *hp; break;
            case 2: if (*hp && rand()%4) *fp = *hp; break;
            case 3: if (*hp && rand()%3) *fp = *hp; break;
            case 4: if (*hp && rand()%2) *fp = *hp; break;
            case 5: if (*hp && rand()%3==0) *fp = *hp; break;
            case 6: if (*hp && rand()%4==0) *fp = *hp; break;
            case 7: if (*hp && rand()%5==0) *fp = *hp; break;
            default: if (*hp) *fp = *hp;
          }
          fp++; hp++;
        }
      }
    }
    delete Form;
  } else if (WeaveCondition.HairEffect==HEShort) {
    TProgressForm *Form = new TProgressForm(NULL);
    Form->Title = "Weave - Hair";
    Form->Show();
    for (iy=0; iy<bmFront->size.y-5; iy+=5) {
      Form->Ratio = (double)iy/(bmFront->size.y-5);
      for (ix=0; ix<bmFront->size.x-5; ix+=5) {
        fp = (WORD *)bmFront->pointer(ix+rand()%2, iy+rand()%2);
        fc = *(fp+(rand()%3)*bmFront->size.x+rand()%3);
        if (fc) {
          hmp = rand()%5;
          for (y=0; y<3; y++) {
            for (x=0; x<3; x++) {
              if (Hair.lng[hmp][y][x]) *(fp+x) = fc;
            }
            fp += bmFront->size.x;
          }
        }
        if (WeaveCondition.BackSide) {
          bp = bmBack->pointer(ix+rand()%2, iy+rand()%2);
          bc = *(bp+(rand()%3)*bmBack->size.x+rand()%3);
          if (bc) {
            hmp = rand()%5;
            for (y=0; y<3; y++) {
              for (x=0; x<3; x++) {
                if (Hair.lng[hmp][y][x]) *(bp+x) = bc;
              }
              bp += bmBack->size.x;
            }
          }
        }
      }
    }
    delete Form;
  } else if (WeaveCondition.HairEffect==HELong) {
    TProgressForm *Form = new TProgressForm(NULL);
    Form->Title = "Weave - Hair";
    Form->Show();
    for (iy=0; iy<bmFront->size.y-9; iy+=9) {
      Form->Ratio = (double)iy/(bmFront->size.y-9);
      for (ix=0; ix<bmFront->size.x-9; ix+=9) {
        fp = (WORD *)bmFront->pointer(ix+rand()%2, iy+rand()%2);
        fc = *(fp+(rand()%7)*bmFront->size.x+rand()%7);
        if (fc) {
          hmp = rand()%5;
          for (y=0; y<7; y++) {
            for (x=0; x<7; x++) {
              if (Hair.nml[hmp][y][x]) *(fp+x) = fc;
            }
            fp += bmFront->size.x;
          }
        }
        if (WeaveCondition.BackSide) {
          bp = bmBack->pointer(ix+rand()%2, iy+rand()%2);
          bc = *(bp+(rand()%7)*bmBack->size.x+rand()%7);
          if (bc) {
            hmp = rand()%5;
            for (y=0; y<7; y++) {
              for (x=0; x<7; x++) {
                if (Hair.nml[hmp][y][x]) *(bp+x) = bc;
              }
              bp += bmBack->size.x;
            }
          }
        }
      }
    }
    delete Form;
  } else if (WeaveCondition.HairEffect==HENormal) {
    TProgressForm *Form = new TProgressForm(NULL);
    Form->Title = "Weave - Hair";
    Form->Show();
    for (iy=0; iy<bmFront->size.y-7; iy+=7) {
    Form->Ratio = (double)iy/(bmFront->size.y-7);
      for (ix=0; ix<bmFront->size.x-7; ix+=7) {
        fp = (WORD *)bmFront->pointer(ix+rand()%2, iy+rand()%2);
        fc = *(fp+(rand()%5)*bmFront->size.x+rand()%5);
        if (fc) {
          hmp = rand()%5;
          for (y=0; y<5; y++) {
            for (x=0; x<5; x++) {
              if (Hair.sht[hmp][y][x]) *(fp+x) = fc;
            }
            fp += bmFront->size.x;
          }
        }
        if (WeaveCondition.BackSide) {
          bp = bmBack->pointer(ix+rand()%2, iy+rand()%2);
          bc = *(bp+(rand()%5)*bmBack->size.x+rand()%5);
          if (bc) {
            hmp = rand()%5;
            for (y=0; y<5; y++) {
              for (x=0; x<5; x++) {
                if (Hair.sht[hmp][y][x]) *(bp+x) = bc;
              }
              bp += bmBack->size.x;
            }
          }
        }
      }
    }
    delete Form;
  }
}
//---------------------------------------------------------------------------
void __fastcall TPlan::Draw(TMemoryArea<WORD> *Source, TTexpiaBitmap *Target)
{
	WORD *sp;
  BYTE *dp;
  COLORREF rgb;
  TGradeColor **ydc;

  Target->StartScanLine();
  for (int y=0; y<Source->size.y; y++) {
	  sp = Source->pointer(0, y);
	 	dp = Target->GetScanLine(y);
	  for (int x=0; x<Source->size.x; x++, sp++, dp+=3) {
    	if (*sp) {
			  ydc = Yarn->Choice[*sp>>11].Color[(*sp>>8)&7];
     		if (WeaveCondition.WovenEffect==WESolid) {
      		rgb = RGBQUAD2COLORREF(ydc[(*sp>>3)&0x1F]->GetColor(0)->RGB);
	      } else if (WeaveCondition.WovenEffect==WETypeA) {
  	    	rgb = RGBQUAD2COLORREF(ydc[(*sp>>3)&0x1F]->GetColor((*sp&7)-4)->RGB);
    	  } else {
      		rgb = RGBQUAD2COLORREF(ydc[(*sp>>3)&0x1F]->GetColor(-((*sp&7)>>1))->RGB);
	      }
  	  	SetPixel24(dp, rgb);
  		}
    }
  	Target->PutScanLine(y);
  }
  Target->StopScanLine();
}
//---------------------------------------------------------------------------
// Public Methods
//---------------------------------------------------------------------------
void __fastcall TPlan::Init(int x, int y)
{
	if (xwp) delete xwp;
  xwp = new int[x];
	if (ywt) delete ywt;
  ywt = new int[y];
}
//---------------------------------------------------------------------------
void __fastcall TPlan::DrawWarpBar(TTexpiaBitmap *Bitmap)
{
	TList *Array = Yarn->Array[WARP];
  char c;
  int i, x, y, vx, vy, n, o, r, ic, repeat, tl;
  double al, gs, gt;
  TWeaveData wd;

  if (Array->Count==0) return;
  Bitmap->FillRect(Rect(0, 0, Bitmap->Width, Bitmap->Height), clBlack);
  InitYarnDot(WARP);
  tl = 0; al = tl;
  wd.tc = ic = 0;
  n = 0;
  while (((TYarnArray *)Array->Items[n])->code==0) n++;
  o = n;
  repeat = ((TYarnArray *)Array->Items[n])->repeat;
  r = n;
  InitWeaveData(wd, WARP, o);
  Bitmap->StartScanLine();
  while (al+wd.dpy<Bitmap->Width) {
  	if (wd.dpy>0) {
	    if (*(xwp+wd.tc)<=0 || *(xwp+wd.tc)>=wd.l) {
  	    *(xwp+wd.tc) = rand()%wd.l;
    	}
	    if (wd.gap>0.0) {
  	    gs = (rand()%int(wd.gap*100))/100.0;
    	  gt = wd.gap/(16+rand()%10);
      	for (y=0; y<Bitmap->Height; y++) {
        	wd.v = al+gs;
	        if (gt>=0) {
  	        if (gs+gt>=wd.gap) gt = -gt;
    	    } else {
      	    if (gs+gt<0) gt = -gt;
        	}
	        gs += gt;
  	      WarpBar(Bitmap, wd, y);
    	  }
	    } else {
  	    wd.v = al;
    	  for (y=0; y<Bitmap->Height; y++) {
      	  WarpBar(Bitmap, wd, y);
	      }
  	  }
    	wd.tc++; ic++;
	    al += wd.dpy;
  	  if (ic>=((TYarnArray *)Array->Items[o])->yarns) {
    	  ic = 0;
      	tl += data[WARP][data[WARP][o].num].dot; al = tl;
	      if (Change(WARP, n, o, r, repeat)) break; else InitWeaveData(wd, WARP, o);
  	  }
    } else {
   	  ic = 0;
     	tl += data[WARP][data[WARP][o].num].dot; al = tl;
      if (Change(WARP, n, o, r, repeat)) break; else InitWeaveData(wd, WARP, o);
    }
  }
  Bitmap->StopScanLine();
  ExitYarnDot(WARP);
}
//---------------------------------------------------------------------------
void __fastcall TPlan::DrawWeftBar(TTexpiaBitmap *Bitmap)
{
	TList *Array = Yarn->Array[WEFT];
  char c;
  int i, x, y, vx, vy, n, o, r, ic, repeat, tl;
  double al, gs, gt;
  TWeaveData wd;

  if (Array->Count==0) return;
  Bitmap->FillRect(Rect(0, 0, Bitmap->Width, Bitmap->Height), clBlack);
  InitYarnDot(WEFT);
  tl = 0; al = tl;
  wd.tc = ic = 0;
  n = 0;
  while (((TYarnArray *)Array->Items[n])->code==0) n++;
  o = n;
  repeat = ((TYarnArray *)Array->Items[n])->repeat;
  r = n;
  InitWeaveData(wd, WEFT, o);
  Bitmap->StartScanLine();
  while (al+wd.dpy<Bitmap->Height) {
  	if (wd.dpy>0) {
	    if (*(ywt+wd.tc)<=0 || *(ywt+wd.tc)>=wd.l) {
  	    *(ywt+wd.tc) = rand()%wd.l;
    	}
	    if (wd.gap>0.0) {
  	    gs = (rand()%int(wd.gap*100))/100.0;
    	  gt = wd.gap/(16+rand()%10);
      	for (x=0; x<Bitmap->Width; x++) {
        	wd.v = al+gs;
	        if (gt>=0) {
  	        if (gs+gt>=wd.gap) gt = -gt;
    	    } else {
      	    if (gs+gt<0) gt = -gt;
        	}
	        gs += gt;
  	      WeftBar(Bitmap, wd, x);
    	  }
	    } else {
  	    wd.v = al;
    	  for (x=0; x<Bitmap->Width; x++) {
      	  WeftBar(Bitmap, wd, x);
	      }
  	  }
    	wd.tc++; ic++;
	    al += wd.dpy;
  	  if (ic>=((TYarnArray *)Array->Items[o])->yarns) {
    	  ic = 0;
      	tl += data[WEFT][data[WEFT][o].num].dot; al = tl;
	      if (Change(WEFT, n, o, r, repeat)) break; else InitWeaveData(wd, WEFT, o);
      }
    } else {
   	  ic = 0;
     	tl += data[WEFT][data[WEFT][o].num].dot; al = tl;
      if (Change(WEFT, n, o, r, repeat)) break; else InitWeaveData(wd, WEFT, o);
    }
  }
  Bitmap->StopScanLine();
  ExitYarnDot(WEFT);
}
//---------------------------------------------------------------------------
int __fastcall TPlan::calc_weave(TTexpiaBitmap *Bitmap)
{
  char *tp;
  int x, y, lx, ly, code, ti;
  int n[2], o[2], r[2], ic[2], tc[2], repeat[2], tl[2];
  double al[2];

  WORD *pFront, *pWeft;
	TList *ArrayWarp = Yarn->Array[WARP];
	TList *ArrayWeft = Yarn->Array[WEFT];

  TCursor OldCursor = Screen->Cursor;
  Screen->Cursor = crHourGlass;
  bmWarp = new TMemoryArea<WORD>(Bitmap->Width, Bitmap->Height);
  bmWeft = new TMemoryArea<WORD>(Bitmap->Width, Bitmap->Height);
  bmHair = new TMemoryArea<WORD>(Bitmap->Width, Bitmap->Height);
  InitYarnDot(WARP);
  InitYarnDot(WEFT);
  calc_warp();
  calc_weft();
  if (bmFront==NULL) {
	  bmFront = new TMemoryArea<WORD>(Bitmap->Width, Bitmap->Height);
  }
  *bmFront = *bmWarp;
  pFront = bmFront->pointer();
  pWeft = bmWeft->pointer();
  for (int i=0; i<bmFront->size.y; i++) {
    for (int j=0; j<bmFront->size.x; j++, pFront++, pWeft++) {
      if (*pWeft!=0 && *pFront==0) *pFront = *pWeft;
    }
  }
  if (WeaveCondition.BackSide) {
	  if (bmBack==NULL) {
		  bmBack = new TMemoryArea<WORD>(Bitmap->Width, Bitmap->Height);
	  }
    *bmBack = *bmFront;
  }
  TProgressForm *Form = new TProgressForm(NULL);
  Form->Title = "Weave - Unite";
  Form->Show();
  tl[WEFT] = tl[WARP] = 0;
  al[WEFT] = al[WARP] = 0.0;
  ic[WEFT] = ic[WARP] = 0;
  n[WEFT] = n[WARP] = 0;
  o[WEFT] = o[WARP] = 0;
  r[WEFT] = r[WARP] = 0;
  repeat[WARP] = ((TYarnArray *)ArrayWarp->Items[n[WARP]])->repeat;
  repeat[WEFT] = ((TYarnArray *)ArrayWeft->Items[n[WEFT]])->repeat;
  dpy[WARP] = (double)data[WARP][data[WARP][o[WARP]].num].dot/
    ((TYarnArray *)ArrayWarp->Items[o[WARP]])->yarns;
  dpy[WEFT] = (double)data[WEFT][data[WEFT][o[WEFT]].num].dot/
    ((TYarnArray *)ArrayWeft->Items[o[WEFT]])->yarns;
  tc[WEFT] = tc[WARP] = 0;
  ti = 0;
  code = ((TTextureArray *)Texture->Array->Items[ti])->code-1;
  lx = Texture->Choice[code].width;
  ly = Texture->Choice[code].height;
  tp = Texture->Choice[code].data;
  while (1) {
    if (al[WARP] == 0.0) Form->Ratio = al[WEFT]/bmFront->size.y;
    v[WARP] = al[WARP]; v[WEFT] = al[WEFT];
    if (WeaveCondition.BackSide) {
      if (*(tp+tc[WARP]%lx)) {
        texture_warp(bmFront);
        texture_weft(bmBack);
      } else {
        texture_weft(bmFront);
        texture_warp(bmBack);
      }
    } else {
	    if (*(tp+tc[WARP]%lx)) {
  	    texture_warp(bmFront);
    	} else {
      	texture_weft(bmFront);
	    }
    }
    tc[WARP]++;
    if (Texture->Array->Count>1) {
      if (tc[WARP]>=((TTextureArray *)Texture->Array->Items[ti])->size) {
        ti++; if (ti>=Texture->Array->Count) ti = 0;
        code = ((TTextureArray *)Texture->Array->Items[ti])->code-1;
        lx = Texture->Choice[code].width;
        ly = Texture->Choice[code].height;
        tp = Texture->Choice[code].data+(tc[WEFT]%ly)*lx;
        tc[WARP] = 0;
      }
    }
    ic[WARP]++;
    al[WARP] += dpy[WARP];
    if (al[WARP]<bmFront->size.x) {
      if (ic[WARP]>=((TYarnArray *)ArrayWarp->Items[o[WARP]])->yarns) {
        ic[WARP] = 0;
        tl[WARP] += data[WARP][data[WARP][o[WARP]].num].dot;
        al[WARP] = tl[WARP];
        Change(WARP, n[WARP], o[WARP], r[WARP], repeat[WARP]);
        dpy[WARP] = (double)data[WARP][data[WARP][o[WARP]].num].dot/
          ((TYarnArray *)ArrayWarp->Items[o[WARP]])->yarns;
      }
    } else {
      tl[WARP] = 0; al[WARP] = 0.0;
      n[WARP] = o[WARP] = r[WARP] = 0;
      repeat[WARP] = ((TYarnArray *)ArrayWarp->Items[n[WARP]])->repeat;
      dpy[WARP] = (double)data[WARP][data[WARP][o[WARP]].num].dot/
        ((TYarnArray *)ArrayWarp->Items[o[WARP]])->yarns;
      ic[WARP] = 0;
      tc[WARP] = 0; tc[WEFT]++;
      if (Texture->Array->Count>1) {
        ti = 0;
        code = ((TTextureArray *)Texture->Array->Items[ti])->code-1;
        lx = Texture->Choice[code].width;
        ly = Texture->Choice[code].height;
      }
      tp = Texture->Choice[code].data+(tc[WEFT]%ly)*lx;
      ic[WEFT]++;
      al[WEFT] += dpy[WEFT];
      if (al[WEFT]<bmFront->size.y) {
        if (ic[WEFT]>=((TYarnArray *)ArrayWeft->Items[o[WEFT]])->yarns) {
          ic[WEFT] = 0;
          tl[WEFT] += data[WEFT][data[WEFT][o[WEFT]].num].dot;
          al[WEFT] = tl[WEFT];
          Change(WEFT, n[WEFT], o[WEFT], r[WEFT], repeat[WEFT]);
          dpy[WEFT] = (double)data[WEFT][data[WEFT][o[WEFT]].num].dot/
            ((TYarnArray *)ArrayWeft->Items[o[WEFT]])->yarns;
        }
      } else break;
    }
  }
  delete Form;
  ExitYarnDot(WARP);
  ExitYarnDot(WEFT);
  delete bmWarp;
  delete bmWeft;
  calc_hair();
  delete bmHair;
  Screen->Cursor = OldCursor;
  return 0;
}
//---------------------------------------------------------------------------
void __fastcall TPlan::DrawFront(TTexpiaBitmap *Bitmap)
{
	if (bmFront) Draw(bmFront, Bitmap);
  else Bitmap->FillRect(Rect(0, 0, Bitmap->Width, Bitmap->Height), clBlack);
}
//---------------------------------------------------------------------------
void __fastcall TPlan::DrawBack(TTexpiaBitmap *Bitmap)
{
	if (bmBack) Draw(bmBack, Bitmap);
  else Bitmap->FillRect(Rect(0, 0, Bitmap->Width, Bitmap->Height), clBlack);
}
//---------------------------------------------------------------------------
bool __fastcall TPlan::LoadFromFile(int fh, TTexVersion &v)
{
	FileRead(fh, &WeaveCondition, sizeof(TWeaveCondition));
	Yarn->LoadFromFile(fh, v);
	Texture->LoadFromFile(fh, v);
  bmFront = new TMemoryArea<WORD>;
	bmFront->LoadFromFile(fh);
  if (WeaveCondition.BackSide) {
	  bmBack = new TMemoryArea<WORD>;
  	bmBack->LoadFromFile(fh);                             
  }
}
//---------------------------------------------------------------------------
bool __fastcall TPlan::SaveToFile(int fh)
{
	FileWrite(fh, &WeaveCondition, sizeof(TWeaveCondition));
	Yarn->SaveToFile(fh);
	Texture->SaveToFile(fh);
	bmFront->SaveToFile(fh);
  if (WeaveCondition.BackSide) {
  	bmBack->SaveToFile(fh);
  }
}
//---------------------------------------------------------------------------