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

#include "YarnArrange.h"
#include "MainImage.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
//---------------------------------------------------------------------------
// TYarnChoice
//---------------------------------------------------------------------------
__fastcall TYarnChoice::TYarnChoice()
{
	Data = NULL;
  for (int j = 0; j < 8; j++) {      //Error ¹ß»ý--óÀ½¿¡ ½Ç µðÀÚÀÎÀ§ÇØ ÆûÀ» ¶ç¿ï¶§  \\\Á¤¼ö°¡
   	Color[j] = NULL;
  }
}
//---------------------------------------------------------------------------
__fastcall TYarnChoice::~TYarnChoice()
{
  if (Data) {
    for (int j = 0; j < 8; j++) {
    	if (Color[j]) {
      	for (int k=0; k<Data->Colors; k++) delete Color[j][k];
    	  delete[] Color[j];
      }
    }
  	delete Data;
  }
}
//---------------------------------------------------------------------------
TPException __fastcall TYarnChoice::LoadFromFile(HANDLE fh, Word dpi)
{
  DWORD dwRead;
	int i, j, k, index;
  BYTE c;
  TColorData *cd = NULL;
  TPException ec = EC_NONE;

 	if ((Data = new TYarnData) == NULL) { ec = EC_MEMORY_LACK; goto fail; }
 	if ((ec = Data->LoadFromFile(fh, true)) != EC_NONE) goto fail;
	if (!ReadFile(fh, &c, sizeof(BYTE), &dwRead, NULL)) goto fail;
  if ((cd = new TColorData) == NULL) { ec = EC_MEMORY_LACK; goto fail; }
  for (i=0, k=1; i<8; i++, k<<=1) {
   	if (c&k) {
    	if ((Color[i] = new TGradeColor *[Data->Colors]) == NULL) { ec = EC_MEMORY_LACK; goto fail; }
    	for (j=0; j<Data->Colors; j++) {
				if (!ReadFile(fh, &index, sizeof(int), &dwRead, NULL)) goto fail;
      	cd->LoadFromFile((int)fh, 1);
	    	if ((Color[i][j] = new TGradeColor) == NULL) { ec = EC_MEMORY_LACK; goto fail; }
      	Color[i][j]->SetColor(cd, index);
      }
    }
  }
  delete cd;
  ypi = (double)dpi/Data->Thick;    // Data->Thick == 0 ???
  return EC_NONE;
fail :
  if (cd) delete cd;
  if (Data) {
    for (i=0; i<8; i++) {
      if (Color[i]) {
      	for (j=0; j<Data->Colors; j++) delete Color[i][j];
        delete[] Color[i]; Color[i] = NULL;
      }
    }
    delete Data; Data = NULL;
  }
  if (ec == EC_NONE) ec = EC_FILE_NOT_READ;
  return ec;
}
//---------------------------------------------------------------------------
TPException __fastcall TYarnChoice::SaveToFile(HANDLE fh)
{
  DWORD dwWrite;
	int i, j;
  BYTE c;
  TPException ec = EC_NONE;

 	if (!Data->SaveToFile(fh, true)) goto fail;
  c = 0;
  for (i=0, j=1; i<8; i++, j<<=1) {
	 	if (Color[i]) c |= j;
  }
	if (!WriteFile(fh, &c, sizeof(BYTE), &dwWrite, NULL)) goto fail;
  for (i=0; i<8; i++) {
   	if (Color[i]) {
    	for (j=0; j<Data->Colors; j++) {
				if (!WriteFile(fh, &Color[i][j]->Index, sizeof(int), &dwWrite, NULL)) goto fail;
      	Color[i][j]->GetColor(0)->SaveToFile((int)fh);
      }
    }
  }
  return EC_NONE;
fail:
  if (ec == EC_NONE) ec = EC_FILE_NOT_WRITE;
  return ec;
}
//---------------------------------------------------------------------------
// TYarnArrange
//---------------------------------------------------------------------------
__fastcall TYarnArrange::TYarnArrange()
{
  ChoiceCount = 0;
  bFinish = false;
  ArrayCount = 0;
  for (int i = 0; i < 6; i++) {
    memset(Array[i].code, 0, 100);
  }
}
//---------------------------------------------------------------------------
void __fastcall TYarnArrange::AddChoiceData(AnsiString fn, int i, int dpi)
{
#ifdef TPDEBUG
	if (Choice[i].Data) {
  	SHOWDEBUG;
  }
#endif
	if ((Choice[i].Data = new TYarnData) == NULL) goto fail;
  if (Choice[i].Data->LoadFromFile(fn) != EC_NONE) goto fail;
  Choice[i].ypi = (double) dpi / Choice[i].Data->Thick;
  AddColor(i, 0);
  ChoiceCount++;
  return;
fail :
  EXCEPTION_MESSAGE_OK(EC_MEMORY_LACK);
}
//---------------------------------------------------------------------------
void __fastcall TYarnArrange::ChangeChoiceData(AnsiString fn, int i, int dpi)
{
#ifdef TPDEBUG
	if (Choice[i].Data) {
  	SHOWDEBUG;
  }
#endif
	if ((Choice[i].Data = new TYarnData) == NULL) goto fail;
  if (Choice[i].Data->LoadFromFile(fn) != EC_NONE) goto fail;
  Choice[i].ypi = (double) dpi / Choice[i].Data->Thick;
  ChoiceCount++;
  return;
fail :
  EXCEPTION_MESSAGE_OK(EC_MEMORY_LACK);
}
//---------------------------------------------------------------------------

void __fastcall TYarnArrange::AddColor(int i, int j)
{
  int k;
#ifdef TPDEBUG
	if (Choice[i].Color[j]) {
  	SHOWDEBUG;
  }
#endif
	Choice[i].Color[j] = new TGradeColor*[Choice[i].Data->Colors];
  if (!Choice[i].Color[j]) goto fail;
  for (k=0; k < Choice[i].Data->Colors; k++) {
  	Choice[i].Color[j][k] = new TGradeColor;
    if (!Choice[i].Color[j][k]) goto fail;
  }
  return;
fail :
  if (Choice[i].Color[j]) delete Choice[i].Color[j];
  return;
}
//---------------------------------------------------------------------------
void __fastcall TYarnArrange::RemoveColor(int i, int j)
{
#ifdef TPDEBUG
	if (Choice[i].Color[j]) {
  	SHOWDEBUG;
  }
#endif
	if (Choice[i].Color[j]) {
  	for (int k=0; k < Choice[i].Data->Colors; k++) {
     	delete Choice[i].Color[j][k];
   	}
   	delete[] Choice[i].Color[j];
    Choice[i].Color[j] = NULL;
  }
}
//---------------------------------------------------------------------------
void __fastcall TYarnArrange::RemoveChoiceData(int i)
{
  TColorData *cd;

  for (int j = 0; j < 8; j++) RemoveColor(i, j);
	if(Choice[i].Data) {
  	delete Choice[i].Data;
    Choice[i].Data = NULL;
  	ChoiceCount--;
  }
}
//---------------------------------------------------------------------------
void __fastcall TYarnArrange::ClearAllChoiceData()
{
	for (int i = 0; i < 4; i++) {
  	RemoveChoiceData(i);
  }
  ChoiceCount = 0;
}
// -----------------------------------------------------------------------
TPException __fastcall TYarnArrange::LoadFromFile(HANDLE fh, TEXPIAFILEHEADER &tpfh)
{
  DWORD dwRead;
	BYTE c, *sp, *dp, bc, color[8][16], *yp;
  TYarnArray *ya;
  short count;
  int i, j, k, l, m, n, s, size;
  double r;
	Ddye dye[4];
  Ydata *yd;
  Yinfor *yi;
  AnsiString str;
  TPException ec = EC_NONE;

  if (tpfh.Version.Texpia=='P') {
    if (tpfh.Version.Method=='T' && tpfh.Version.Number>=200) {		// Windows Version
			if (!ReadFile(fh, &ChoiceCount, sizeof(int), &dwRead, NULL)) goto fail;
		  for (i = 0; i < ChoiceCount; i++) {
       	if ((ec = Choice[i].LoadFromFile(fh, tpfh.CanvasInfor.DotsPerInch)) != EC_NONE) goto fail;
		  }
    } else {																						 					// DOS Version
	    if ((tpfh.Version.Method=='V' || tpfh.Version.Method=='C') && tpfh.Version.Number<315) {
			  for (i=0; i<4; i++) {
          yi = &dye[i].infor;
          if (!ReadFile(fh, &dye[i].type, 1, &dwRead, NULL)) goto fail;
          if (!ReadFile(fh, color[0], 128, &dwRead, NULL)) goto fail;
          if (!ReadFile(fh, &dye[i].dycp, 1, &dwRead, NULL)) goto fail;
          if (SetFilePointer(fh, 2, NULL, FILE_CURRENT) == 0xFFFFFFFF) goto fail;
          if (!ReadFile(fh, dye[i].fname, 13, &dwRead, NULL)) goto fail;
          if (SetFilePointer(fh, 3, NULL, FILE_CURRENT) == 0xFFFFFFFF) goto fail;
          if (!ReadFile(fh, &yi->length, 2, &dwRead, NULL)) goto fail;
          if (!ReadFile(fh, &yi->width, 2, &dwRead, NULL)) goto fail;
          if (!ReadFile(fh, &yi->thick, 2, &dwRead, NULL)) goto fail;
          if (!ReadFile(fh, &bc, 1, &dwRead, NULL)) goto fail;
          yi->state.sz = bc;
          if (!ReadFile(fh, &bc, 1, &dwRead, NULL)) goto fail;
          yi->state.nty = bc;
          if (!ReadFile(fh, &bc, 1, &dwRead, NULL)) goto fail;
          yi->colors = bc;
          if (SetFilePointer(fh, 3, NULL, FILE_CURRENT) == 0xFFFFFFFF) goto fail;
          if (!ReadFile(fh, &yi->tpi, 8, &dwRead, NULL)) goto fail;
          if (SetFilePointer(fh, 4, NULL, FILE_CURRENT) == 0xFFFFFFFF) goto fail;
          if (!ReadFile(fh, &bc, 1, &dwRead, NULL)) goto fail;
          yi->state.system = bc;
          if (!ReadFile(fh, &bc, 1, &dwRead, NULL)) goto fail;
          yi->state.unit = bc;
          if (SetFilePointer(fh, 2, NULL, FILE_CURRENT) == 0xFFFFFFFF) goto fail;
          if (!ReadFile(fh, &dye[i].ypi, 8, &dwRead, NULL)) goto fail;
          yi->ratio = 2.0/3.0;
					yi->count = Dot2Count(160, TYarnUnit(yi->state.system, yi->state.unit),
          	yi->thick, yi->ratio);
          if (dye[i].type) {
		        ChoiceCount++;
            yi->state.hair = (yi->thick==yi->width) ? 0 : 1;
            s = yi->length*yi->width;
            if ((dye[i].map = new BYTE[s]) == NULL) { ec = EC_MEMORY_LACK; goto fail; }
            if (!ReadFile(fh, dye[i].map, s, &dwRead, NULL)) goto fail;
            if (yi->state.nty==yi->colors) {  // Normal
              yi->type = 0;
              for (k=0; k<yi->state.nty; k++) {
                yd = &dye[i].data[k];
                yd->cnum = k;
                yd->colors = 1;
                for (j=0; j<8; j++) {
                  dye[i].color[j][k<<3] = color[j][k];
                }
              }
              yp = dye[i].map;
              for (j=0; j<s; j++, yp++) {
                if (*yp!=0xFF) *yp = ((*yp&0xF0)<<2)+(*yp&0x0F)+1;
                else *yp = 0;
              }
            } else if (yi->state.nty==1) {           // Rainbow
              yi->type = 2;
              yd = &dye[i].data[0];
              yd->cnum = 0;
              yd->colors = yi->colors;
              for (j=0; j<8; j++) {
                for (k=0; k<yd->colors; k++) {
                  dye[i].color[j][k] = color[j][k];
                }
              }
              yp = dye[i].map;
              for (j=0; j<s; j++, yp++) {
                if (*yp!=0xFF) *yp = ((*yp&0xF0)>>1)+(*yp&0x0F)+1;
                else *yp = 0;
              }
            } else {                                        // Melange
              yi->type = 0;
              size = (yi->colors+yi->state.nty-1) / yi->state.nty;
              for (k=m=0; k<yi->state.nty; k++) {
                n = yi->colors-k*size;
                if (n>size) n = size;
                yi->type |= 1<<(k<<1);
                yd = &dye[i].data[k];
                yd->cnum = m;
                yd->colors = n;
                for (j=0; j<8; j++) {
                  for (l=0; l<n; l++, m++) {
                    dye[i].color[j][(k<<3)+l] = color[j][m];
                  }
                }
              }
              yp = dye[i].map;
              for (j=0; j<s; j++, yp++) {
                if (*yp!=0xFF) {
                  k = (*yp&0xF0)>>4;
                  *yp = ((k/size)<<6)+((k%size)<<3)+(*yp&0x0F)+1;
                } else *yp = 0;
              }
            }
            for (j=0; j<yi->state.nty; j++) {
              yd = &dye[i].data[j];
              yd->color = NULL;
              yd->methods = 0; yd->method = NULL;
            }
          }
        }
      } else if ((tpfh.Version.Method=='V' || tpfh.Version.Method=='C') && tpfh.Version.Number<320) {
        ChoiceCount = 0;
			  for (i=0; i<4; i++) {
          if (!ReadFile(fh, dye[i].fname, 14, &dwRead, NULL)) goto fail;
          if (!ReadFile(fh, &dye[i].dycp, 1, &dwRead, NULL)) goto fail;
          if (!ReadFile(fh, &dye[i].type, 1, &dwRead, NULL)) goto fail;
          if (!ReadFile(fh, dye[i].color[0], 256, &dwRead, NULL)) goto fail;
          if (!ReadFile(fh, &dye[i].ypi, 8, &dwRead, NULL)) goto fail;
          if (!ReadFile(fh, &dye[i].infor, sizeof(Yinfor), &dwRead, NULL)) goto fail;
          for (j=0; j<4; j++) {
            if (!ReadFile(fh, &dye[i].data[j].count, 2, &dwRead, NULL)) goto fail;
            if (!ReadFile(fh, &dye[i].data[j].cnum, 1, &dwRead, NULL)) goto fail;
            if (!ReadFile(fh, &dye[i].data[j].colors, 1, &dwRead, NULL)) goto fail;
            if (SetFilePointer(fh, 4, NULL, FILE_CURRENT) == 0xFFFFFFFF) goto fail;
          }
          if (SetFilePointer(fh, 4, NULL, FILE_CURRENT) == 0xFFFFFFFF) goto fail;
          if (dye[i].type) {
		        ChoiceCount++;
            for (j=0; j<dye[i].infor.state.nty; j++) {
              yd = &dye[i].data[j];
              if ((yd->color = new TTexColor[yd->colors]) == NULL) { ec = EC_MEMORY_LACK; goto fail; }
              if (!ReadFile(fh, yd->color, yd->colors*sizeof(TTexColor), &dwRead, NULL)) goto fail;
              yd->methods = 0;
              yd->method = NULL;
            }
            s = dye[i].infor.length*dye[i].infor.width;
            if ((dye[i].map = new BYTE[s]) == NULL) { ec = EC_MEMORY_LACK; goto fail; }
            if (!ReadFile(fh, dye[i].map, s, &dwRead, NULL)) goto fail;
          }
        }
      } else {
        ChoiceCount = 0;
			  for (i=0; i<4; i++) {
					if (!ReadFile(fh, &dye[i], sizeof(Ddye), &dwRead, NULL)) goto fail;
          if (dye[i].type) {
		        ChoiceCount++;
            for (j=0; j<dye[i].infor.state.nty; j++) {
              yd = &dye[i].data[j];
              if (yd->colors) {
                if ((yd->color = new TTexColor[yd->colors]) == NULL) { ec = EC_MEMORY_LACK; goto fail; }
                if (!ReadFile(fh, yd->color, yd->colors*sizeof(TTexColor), &dwRead, NULL)) goto fail;
              } else yd->color = NULL;
              if (yd->methods) {
                if ((yd->method = new Ymethod[yd->methods])==NULL) { ec = EC_MEMORY_LACK; goto fail; }
                if (!ReadFile(fh, yd->method, yd->methods*sizeof(Ymethod), &dwRead, NULL)) goto fail;
              } else yd->method = NULL;
            }
            s = dye[i].infor.length*dye[i].infor.width;
            if ((dye[i].map = new BYTE[s]) == NULL) { ec = EC_MEMORY_LACK; goto fail; }
            if (!ReadFile(fh, dye[i].map, s, &dwRead, NULL)) goto fail;
          }
        }
      }
      for (i=0; i<4; i++) {
        if (dye[i].type) {
        	if ((Choice[i].Data = new TYarnData) == NULL) { ec = EC_MEMORY_LACK; goto fail; }
          TYarnData *data = Choice[i].Data;
          data->FileName = dye[i].fname;
          data->DPI = 160;
          data->Length = dye[i].infor.length;
          data->Width = dye[i].infor.width;
          data->Thick = dye[i].infor.thick;
          data->Ratio = dye[i].infor.ratio;
          data->Dyed = false;
	        TYarnInfor *infor = &data->Infor;
          infor->Detail.Count = dye[i].infor.count;
          data->Unit.System = dye[i].infor.state.unit;
          data->Unit.Method = dye[i].infor.state.system;
          infor->Detail.TYC = dye[i].infor.state.nty;
          infor->Detail.SZ = dye[i].infor.state.sz;
          infor->Detail.Hair = dye[i].infor.state.hair;
          infor->Detail.TPI = dye[i].infor.tpi;
					if (infor->Detail.TYC>1) {
	          infor->Detail.Type = 0;
	          infor->Colors = 0;
	          infor->Color = NULL;
           	if ((infor->Infor = new TYarnInfor[infor->Detail.TYC]) == NULL) {
              ec = EC_MEMORY_LACK; goto fail;
            }
						for (k=0; k<infor->Detail.TYC; k++) {
              infor->Infor[k].Detail.Count = dye[i].data[k].count;
	            infor->Infor[k].Detail.Type = (dye[i].infor.type>>(2*k))&3;
              infor->Infor[k].Detail.TYC = 1;
              infor->Infor[k].Detail.SZ = infor->Detail.SZ;
              infor->Infor[k].Detail.Hair = infor->Detail.Hair;
              infor->Infor[k].Detail.TPI = infor->Detail.TPI;
	            infor->Infor[k].Colors = dye[i].data[k].colors;
	            if ((infor->Infor[k].Color = new TColorData *[dye[i].data[k].colors]) == NULL) {
                ec = EC_MEMORY_LACK; goto fail;
              }
  	          for (j=0; j<infor->Infor[k].Colors; j++) {
	  	          if ((infor->Infor[k].Color[j] = new TColorData) == NULL) {
                  ec = EC_MEMORY_LACK; goto fail;
                }
      	      }
        	    if (dye[i].data[k].colors>0 && dye[i].data[k].color) {
	        	    for (j=0; j<dye[i].data[k].colors; j++) {
		        	    infor->Infor[k].Color[j]->SetTexColor(dye[i].data[k].color[j]);
								}
	            }
	 	          if (infor->Infor[k].Detail.Type>0) {
	  	          infor->Infor[k].Methods = dye[i].data[k].methods;
	    	        if ((infor->Infor[k].Method = new TYarnMethod[dye[i].data[k].methods]) == NULL) {
                  ec = EC_MEMORY_LACK; goto fail;
                }
  	    	      if (dye[i].data[k].methods>0) {
	  	    	      for (j=0; j<dye[i].data[k].methods; j++) {
		  	      	    memcpy(&infor->Infor[k].Method[j], &dye[i].data[k].method[j], 4);
									}
	             	}
	            }
            }
          } else {
	          infor->Detail.Type = dye[i].infor.type;
	          infor->Colors = dye[i].infor.colors;
	          if ((infor->Color = new TColorData *[dye[i].infor.colors]) == NULL) {
              ec = EC_MEMORY_LACK; goto fail;
            }
            for (j=0; j<infor->Colors; j++) {
	            if ((infor->Color[j] = new TColorData) == NULL) { ec = EC_MEMORY_LACK; goto fail; }
            }
            if (dye[i].data[0].colors>0 && dye[i].data[0].color) {
	            for (j=0; j<dye[i].data[0].colors; j++) {
		            infor->Color[j]->SetTexColor(dye[i].data[0].color[j]);
							}
            }
	          if (infor->Detail.Type>0) {
	            infor->Methods = dye[i].data[0].methods;
	            if ((infor->Method = new TYarnMethod[dye[i].data[0].methods]) == NULL) {
                ec = EC_MEMORY_LACK; goto fail;
              }
  	          if (dye[i].data[0].methods>0) {
	  	          for (j=0; j<dye[i].data[0].methods; j++) {
		  	          memcpy(&infor->Method[j], &dye[i].data[0].method[j], 4);
								}
            	}
            }
          }
	  	  	data->Rearrange();
    			sp = dye[i].map;
          if ((data->Map = new BYTE[data->Length*data->Width]) == NULL) {
            ec = EC_MEMORY_LACK; goto fail;
          }
	  		  dp = (BYTE *)data->Map;
					if (infor->Detail.TYC>1) {
			  	  for (j=0; j<data->Length*data->Width; j++, sp++, dp++) {
      				if (*sp) {
								*dp = ((infor->Infor[(*sp>>6)&3].FirstColor+((*sp>>3)&7))<<3)+(*sp&7);
	  	  	    } else *dp = 0;
  			    }
	  	  	} else {
		    		for (j=0; j<data->Length*data->Width; j++, sp++, dp++) {
      				if (*sp) {
								*dp = ((infor->FirstColor+((*sp>>3)&7))<<3)+(*sp&7);
	  		      } else *dp = 0;
  			    }
		    	}
          for (j = 0; j < 8; j++) {
		        if (dye[i].type&(1<<j)) {
		          if ((Choice[i].Color[j] = new TGradeColor *[Choice[i].Data->Colors]) == NULL) {
                ec = EC_MEMORY_LACK; goto fail;
              }
              for (l = k = 0; l < dye[i].infor.state.nty; l++) {
	              for (m = 0; m < dye[i].data[l].colors; m++, k++) {
				          if ((Choice[i].Color[j][k] = new TGradeColor) == NULL) {
                    ec = EC_MEMORY_LACK; goto fail;
                  }
									n = dye[i].color[j][(l<<3) + m] + 1;
	                Choice[i].Color[j][k]->SetColor(MainImageForm->Palette->ColorData[n], n);
                }
              }
            }
          }
				  Choice[i].ypi = (double)tpfh.CanvasInfor.DotsPerInch/data->Thick;
        }
        if (dye[i].type) {
	        for (j=0; j<dye[i].infor.state.nty; j++) {
		        yd = &dye[i].data[j];
		        if (yd->color) delete[] yd->color;
  		      if (yd->method) delete[] yd->method;
          }
	        if (dye[i].map) delete[] dye[i].map;
        }
      }
    }
// Array data load from file
    if (!ReadFile(fh, &ArrayCount, sizeof(char), &dwRead, NULL)) goto fail;
    for (i=0; i < ArrayCount ; i++) {
      if (!ReadFile(fh, &Array[i].count, sizeof(Byte), &dwRead, NULL)) goto fail;
      if (!ReadFile(fh, Array[i].code, Array[i].count, &dwRead, NULL)) goto fail;
    }
  }
  return EC_NONE;
fail:
  for(i=0 ; i<4; i++) {
    if (dye[i].map) delete[] dye[i].map;
  }
  if (ec == EC_NONE) ec = EC_FILE_NOT_READ;
  return ec;
}
//---------------------------------------------------------------------------
TPException __fastcall TYarnArrange::SaveToFile(HANDLE fh)
{
  DWORD dwWrite;
	int i;
  TPException ec = EC_NONE;

	if (!WriteFile(fh, &ChoiceCount, sizeof(int), &dwWrite, NULL)) goto fail;
  for (i = 0; i < ChoiceCount; i++) {
  	if (Choice[i].Data) {
      if ((ec = Choice[i].SaveToFile(fh)) != EC_NONE) goto fail;
    }
  }

// Array data save to file
  if (!WriteFile(fh, &ArrayCount, sizeof(char), &dwWrite, NULL)) goto fail;
  for (i = 0; i < ArrayCount; i++) {
    if (!WriteFile(fh, &Array[i].count, sizeof(Byte), &dwWrite, NULL)) goto fail;
    if (!WriteFile(fh, Array[i].code, Array[i].count, &dwWrite, NULL)) goto fail;
  }
  return EC_NONE;
fail :
  if (ec == EC_NONE) ec = EC_FILE_NOT_WRITE;
  return ec;
}
//---------------------------------------------------------------------------
void __fastcall TYarnArrange::AddTextureData(int r, int c, int data)
{

  if(!MainImageForm->Plan->Yarn->Array[c].count) MainImageForm->Plan->Yarn->ArrayCount++;
  if(r == MainImageForm->Plan->Yarn->Array[c].count) MainImageForm->Plan->Yarn->Array[c].count++;
  MainImageForm->Plan->Yarn->Array[c].code[r] = data;

}
//---------------------------------------------------------------------------

void __fastcall TYarnArrange::ClearTextureData(int c, int cnt)
{

  for (int i=0;i<cnt;i++) {
    if(MainImageForm->Plan->Yarn->Array[c].code[i]<0)
      MainImageForm->Plan->Yarn->Array[c].code[i] = 0;
  }
  MainImageForm->Plan->Yarn->Array[c].count = 0;
  MainImageForm->Plan->Yarn->ArrayCount--;
}
//---------------------------------------------------------------------------