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

#include "YarnTable_F.h"
#include "MainImage.h"
#include "Palette.h"
#include "YarnArrange_F.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma link "PColorGrid"
#pragma link "PHLS"
#pragma resource "*.dfm"
//---------------------------------------------------------------------------
#define IDS_YARNARRANGE  StringTable[0]
#define IDS_YARNDYE      StringTable[1]
#define IDS_TABLEVIEW    StringTable[2]
#define IDS_INSERT       StringTable[3]
#define IDS_NEW          StringTable[4]
#define IDS_MESSAGE      StringTable[5]
TYarnArrangeForm *YarnArrangeForm;
//---------------------------------------------------------------------------
__fastcall TYarnArrangeForm::TYarnArrangeForm(TComponent* Owner)
	: TForm(Owner)
{
}
//---------------------------------------------------------------------------

void __fastcall TYarnArrangeForm::FormCreate(TObject *Sender)
{
//=====================================================
  StringTable.Create(DirectoryItem, Language, "YarnArrange");
  SetSmallFont(Font);
  SetSmallFont(StaticText1->Font);
  SetSmallFont(StaticText2->Font);

  Caption                           = IDS_YARNARRANGE;
  StaticText1->Caption              = IDS_YARNDYE;
  sbDyeNew->Caption                 = IDS_NEW;
  sbDyeDelete->Caption              = IDS_COMMON_DELETE;
  sbTableView->Caption              = IDS_TABLEVIEW;
  StaticText2->Caption              = IDS_YARNARRANGE;
  sbArrayNew->Caption               = IDS_NEW;
  sbArrayInsert->Caption            = IDS_INSERT;
  sbArrayDelete->Caption            = IDS_COMMON_DELETE;
//=====================================================

  TIniFile *IniFile = new TIniFile(AppDataItem + "\\Main.ini");
  if (IniFile) {
    Left = IniFile->ReadInteger("YarnArray", "FormLeft", (Screen->Width-Width)>>1);
    Top = IniFile->ReadInteger("YarnArray", "FormTop", (Screen->Height-Height)>>1);
    delete IniFile;
  }
  MainImageForm->OnYarnColorChange = YarnColorChange;
  YarnTableForm->OnYarnChange = YarnChange;
  YarnTableForm->OnCloseForm = CloseTableForm;
  PalIndex = 2;
  for(int i=0; i<4; i++) {
    if (MainImageForm->Plan->Yarn->Choice[i].Data)
      ScrollEnable(i);
  }
  InitDyePanel();
  if(MainImageForm->Plan->Yarn->ArrayCount) {
    sbArrayNew->Enabled = true;
    sbArrayInsert->Enabled = true;
    sbArrayDelete->Enabled = true;
  }
}
//---------------------------------------------------------------------------
void __fastcall TYarnArrangeForm::InitDyePanel()
{
	TPColorGrid *colorgrid;
  TPanel *panel;
  TYarnData *yd;
  int cnt;
	for (int i = 0; i < 4; i++) {
    yd = MainImageForm->Plan->Yarn->Choice[i].Data;
  	if (yd) {
      InitChoiceButton(1);
      cnt = yd->Colors;
      for (int j = 0; j < 8; j++) {
        colorgrid = (TPColorGrid *) FindComponent("ColorGrid" + AnsiString(i*8+j+1));
        colorgrid->ColorCount = cnt;
        if (MainImageForm->Plan->Yarn->Choice[i].Color[j]) {
          colorgrid->IsFill = true;
          for (int k = 0; k < cnt; k++) {
            colorgrid->ReDrawCell(k, (MainImageForm->Plan->Yarn->Choice[i].Color[j][k]->GetColor(0))->Color);
          }
        }
      }
    }
  }
}
//---------------------------------------------------------------------------

void __fastcall TYarnArrangeForm::FormDestroy(TObject *Sender)
{
  int i;

  TIniFile *IniFile = new TIniFile(AppDataItem + "\\Main.ini");
  if (IniFile) {
		if (Left<0) Left = 10; if (Top<0) Top = 10;
		IniFile->WriteInteger("YarnArray", "FormLeft", Left);
		IniFile->WriteInteger("YarnArray", "FormTop", Top);
	  delete IniFile;
  } else { goto fail; }
  for (i = 0; i < 4; i++) {
    if (cmap[i]) delete[] cmap[i];
  }
  if (MainImageForm->Plan->Yarn->ArrayCount == MainImageForm->Plan->Texture->Count)
    MainImageForm->Plan->Yarn->bFinish = true;
  else
    MainImageForm->Plan->Yarn->bFinish = false;
  MainImageForm->OnYarnColorChange = NULL;
  return;
fail :
  EXCEPTION_MESSAGE_OK(EC_MEMORY_LACK);
  return;
}
//---------------------------------------------------------------------------
//// Choice Published Method
//---------------------------------------------------------------------------

void __fastcall TYarnArrangeForm::DyeGridDrawCell(TObject *Sender, int Col,
      int Row, TRect &rect, TGridDrawState State)
{
	TYarnData *yd = MainImageForm->Plan->Yarn->Choice[Col].Data;
  if (yd) {
	  int x, y;
  	TPoint sp;
  	TSize vs = { 126, 76 };
    sp.x = rect.Left+2;
    sp.y = rect.Top+2+((vs.cy-yd->Width)>>1);
    yd->Draw(DyeGrid->Canvas, sp, vs);

    TRect TextRect = Rect(rect.Left, rect.Top + (vs.cy + 4), rect.Right, rect.Bottom);
    x = ((vs.cx + 4) - DyeGrid->Canvas->TextWidth(yd->FileName)) / 2;
    DyeGrid->Canvas->TextRect(TextRect, TextRect.Left + x, 	TextRect.Top+5,
    	yd->FileName);
  }
}
//---------------------------------------------------------------------------

void __fastcall TYarnArrangeForm::sbDyeNewClick(TObject *Sender)
{
	TPColorGrid *colorgrid;
  int i;
	MainImageForm->Plan->Yarn->ClearAllChoiceData();
  ArrayGrid->EditorMode = false;
  for (i = 0; i < 4; i++) {
    if (cmap[i]) { delete[] cmap[i]; cmap[i] = NULL; }
  }
  for (i = 1; i <= 32; i++) {
   	colorgrid = (TPColorGrid *) FindComponent("ColorGrid" + AnsiString(i));
    colorgrid->ColorCount = 0;
    colorgrid->IsFill = false;
  }
  InitChoiceButton(0);
  InitArrayButton(0);
  clearArrayGrid();
  DyeGrid->Repaint();
}
//---------------------------------------------------------------------------

void __fastcall TYarnArrangeForm::sbTableViewClick(TObject *Sender)
{
	YarnTableForm->Visible = sbTableView->Down;
}
//---------------------------------------------------------------------------

void __fastcall TYarnArrangeForm::DyeGridClick(TObject *Sender)
{
	int i = DyeGrid->Col;
  int k, m, n, precnt;
  TPColorGrid *colorgrid;
  TPanel *panel;
  TYarnArray *ya;
	if (sbDyeDelete->Down) {
  	if (MainImageForm->Plan->Yarn->Choice[i].Data) {
      if (MainImageForm->Plan->Yarn->Choice[i].Data->Dyed) {
        panel = (TPanel *) FindComponent("Panel" + AnsiString(i+1) + "16");
        panel->SendToBack();
        if (cmap[i]) { delete[] cmap[i]; cmap[i] = NULL; }
      }
    	MainImageForm->Plan->Yarn->RemoveChoiceData(i);
      for (int j = 1; j <= 8; j++) {
        k = i*8 + j;
        // colorgrid clear
      	colorgrid = (TPColorGrid *) FindComponent("ColorGrid" + AnsiString(k));
        colorgrid->ColorCount = 0;
        colorgrid->IsFill = false;
      }
      if (!MainImageForm->Plan->Yarn->ChoiceCount) InitChoiceButton(0);
    	DyeGrid->Repaint();
      ArrayGrid->Repaint();
    }
    sbDyeDelete->Down = false;
  }
}
//---------------------------------------------------------------------------

void __fastcall TYarnArrangeForm::ScrollBarScroll(TObject *Sender,
      TScrollCode ScrollCode, int &ScrollPos)
{
	TScrollBar *sb = (TScrollBar *) Sender;
  TPColorGrid *colorgrid;
  int index = sb->Tag;
  for (int i = 1; i <= 8; i++) {
  	colorgrid = (TPColorGrid *) FindComponent("ColorGrid" + AnsiString(i+index*8));
    colorgrid->Pos = ScrollPos;
  }
}
//---------------------------------------------------------------------------
void __fastcall TYarnArrangeForm::ColorGridMouseDown(TObject *Sender,
      TMouseButton Button, TShiftState Shift, int X, int Y)
{
	TPColorGrid *colorgrid = (TPColorGrid *) Sender;
  TColorData *cd = NULL;
  int i, j, index;
  i = (colorgrid->Tag-1) / 8;     // 0, 1, 2, 3
  j = (colorgrid->Tag-1) % 8;     // 0  - 7
 	if (colorgrid->IsFill) {
    if (Button== mbMiddle || (Shift.Contains(ssShift) && Button==mbLeft)) {
   		index = colorgrid->GetColorIndex(X, Y);
      if (index >= 0) {
        PaletteForm->DIB256Palette->ChoiceIndex
			    = MainImageForm->Plan->Yarn->Choice[i].Color[j][index]->Index;
      }
    	return;
		} else if (Button == mbLeft) {
	  	if (sbDyeDelete->Down) {
      	MainImageForm->Plan->Yarn->RemoveColor(i, j);
      	colorgrid->DrawNullSquare();
      	colorgrid->IsFill = false;
    		sbDyeDelete->Down = false;
  		} else {
    		index = colorgrid->GetColorIndex(X, Y);
      	if (index >= 0) {
        	ChangeChoiceColor(i, j, index);
			 		cd = (TColorData *) MainImageForm->Plan->Yarn->Choice[i].Color[j][index]->GetColor(0);
        	colorgrid->ReDrawCell(index, cd->Color);
      	}
  		}
		}
 	} else {
    if (MainImageForm->Plan->Yarn->Choice[i].Data) {
      MainImageForm->Plan->Yarn->AddColor(i, j);
    	AddChoiceColor(i, j);
    	DrawColorGrid(colorgrid->Tag-1);
  		colorgrid->IsFill = true;
    }
 	}
  DyeGrid->Repaint();
}
//---------------------------------------------------------------------------
void __fastcall TYarnArrangeForm::ColorGridMouseMove(TObject *Sender,
      TShiftState Shift, int X, int Y)
{
	TPColorGrid *colorgrid = (TPColorGrid *) Sender;
  int i, j, index;
  i = (colorgrid->Tag-1) / 8;     // 0, 1, 2, 3
  j = (colorgrid->Tag-1) % 8;     // 0  - 7
 	if (colorgrid->IsFill) {
    index = colorgrid->GetColorIndex(X, Y);
    if (index>=0) {
      PaletteForm->DIB256Palette->CursorIndex
        = MainImageForm->Plan->Yarn->Choice[i].Color[j][index]->Index;
    }
  }
}
//---------------------------------------------------------------------------
//// Array Published Method
//---------------------------------------------------------------------------
void __fastcall TYarnArrangeForm::ArrayGridDrawCell(TObject *Sender,
      int Col, int Row, TRect &Rect, TGridDrawState State)
{
	AnsiString str = "";
  int x, y, wid, temp, cnt, j;
  TSize size;
  TYarnArray *yarnarray;

	size.cx = Rect.Right-Rect.Left;
	size.cy = Rect.Bottom-Rect.Top;

	if (Col == 0) {
    if (Row == 0) str = "No.";
  	else str = Row;
  } else {
  	if (Row == 0) {
      switch (Col) {
      	case 1: str = "T1";        break;
      	case 2: str = "T2";        break;
      	case 3: str = "T3";        break;
      	case 4: str = "T4";        break;
      	case 5: str = "T5";        break;
      	case 6: str = "T6";        break;
      }
    } else {
      cnt = MainImageForm->Plan->Yarn->Array[Col-1].count;
      if (Row > cnt) return;
      cnt = MainImageForm->Plan->Texture->Count;
      if (Col > cnt) return;
//      if (MainImageForm->Plan->Yarn->Array[Col-1].code[Row-1] < 0
//           || MainImageForm->Plan->Yarn->Array[Col-1].code[Row-1] > 33) str = "";
//      else
      str = IntToStr(MainImageForm->Plan->Yarn->Array[Col-1].code[Row-1]);
 		}
  }
	x = (size.cx-ArrayGrid->Canvas->TextWidth(str)) / 2;
	if (x<0) x = 0;
  y = (size.cy-ArrayGrid->Canvas->TextHeight(str)) / 2;
	if (y<0) y = 0;
	ArrayGrid->Canvas->TextRect(Rect, Rect.Left+x, Rect.Top+y, str);
}
//---------------------------------------------------------------------------

void __fastcall TYarnArrangeForm::ArrayGridClick(TObject *Sender)
{
	TYarnArray *yarnarray, *preya;
  int i, j, cnt, data, arraycnt, code;
  AnsiString str;

  ArrayGrid->EditorMode = false;
  ArrayGrid->Options>>goEditing;
  cnt = MainImageForm->Plan->Yarn->Array[ArrayGrid->Col-1].count;
  if (MainImageForm->Plan->Yarn->ChoiceCount == 0) return;
  if (ArrayGrid->Row) {
    if (sbArrayInsert->Down || sbArrayDelete->Down) {
      if (ArrayGrid->Row <= MainImageForm->Plan->Yarn->Array[ArrayGrid->Col-1].count) {
     			if (sbArrayInsert->Down) {
         		for (i=cnt; i>=ArrayGrid->Row; i--) {
         			ArrayGrid->Cells[ArrayGrid->Col][i+1] = ArrayGrid->Cells[ArrayGrid->Col][i];
              MainImageForm->Plan->Yarn->Array[ArrayGrid->Col-1].code[i] = MainImageForm->Plan->Yarn->Array[ArrayGrid->Col-1].code[i-1];
          	}
            MainImageForm->Plan->Yarn->Array[ArrayGrid->Col-1].code[ArrayGrid->Row-1] = 0;
            ArrayGrid->Cells[ArrayGrid->Col][ArrayGrid->Row] = "0";
            MainImageForm->Plan->Yarn->Array[ArrayGrid->Col-1].count++;
          } else if (sbArrayDelete->Down) {
              for (i=ArrayGrid->Row; i<cnt; i++) {
                ArrayGrid->Cells[ArrayGrid->Col][i] = ArrayGrid->Cells[ArrayGrid->Col][i+1];
                MainImageForm->Plan->Yarn->Array[ArrayGrid->Col-1].code[i-1] = MainImageForm->Plan->Yarn->Array[ArrayGrid->Col-1].code[i];
              }
              i = cnt;
              ArrayGrid->Cells[ArrayGrid->Col][i] = "";
              MainImageForm->Plan->Yarn->Array[ArrayGrid->Col-1].code[i-1] = 0;
              MainImageForm->Plan->Yarn->Array[ArrayGrid->Col-1].count--;

              if(!MainImageForm->Plan->Yarn->Array[ArrayGrid->Col-1].count) {
                MainImageForm->Plan->Yarn->ClearTextureData(ArrayGrid->Col-1,cnt);
                if(!MainImageForm->Plan->Yarn->ArrayCount) InitArrayButton(0);
              }
          }
      }
      sbArrayInsert->Down = false;
      sbArrayDelete->Down = false;
    } else if (ArrayGrid->Col) {
      if ( ArrayGrid->Col <= MainImageForm->Plan->Texture->Count) {
        if ((ArrayGrid->Row-1) <= MainImageForm->Plan->Yarn->Array[ArrayGrid->Col-1].count)
          ArrayGrid->EditorMode = true;
          ArrayGrid->Options<<goEditing;
      }
/*
	    	switch (ArrayGrid->Col) {
      		case 1:
      			if ((ArrayGrid->Row-1)<=MainImageForm->Plan->Yarn->Array[0].count)
          		ArrayGrid->EditorMode = true;
        		break;
      		case 2:
      			if ((ArrayGrid->Row-1)<=MainImageForm->Plan->Yarn->Array[1].count)
          		ArrayGrid->EditorMode = true;
        		break;
      		case 3:
      			if ((ArrayGrid->Row-1)<=MainImageForm->Plan->Yarn->Array[2].count)
          		ArrayGrid->EditorMode = true;
        		break;
      		case 4:
      			if ((ArrayGrid->Row-1)<=MainImageForm->Plan->Yarn->Array[3].count)
          		ArrayGrid->EditorMode = true;
        		break;
      		case 5:
      			if ((ArrayGrid->Row-1)<=MainImageForm->Plan->Yarn->Array[4].count)
          		ArrayGrid->EditorMode = true;
        		break;
      		case 6:
      			if ((ArrayGrid->Row-1)<=MainImageForm->Plan->Yarn->Array[5].count)
          		ArrayGrid->EditorMode = true;
        		break;
        }
*/
    }
  }
	ArrayGrid->Repaint();
}
//---------------------------------------------------------------------------
bool __fastcall TYarnArrangeForm::ProperInput(AnsiString str)
{
  if (str == "") return false;
  int k;

  TPColorGrid *colorgrid;
	try {
    k = StrToInt(str);
    if (k < 33) {
      if (k == 0) return true;
      colorgrid = (TPColorGrid *) FindComponent("ColorGrid" + IntToStr(k));
      if (colorgrid->IsFill) return true;
    }
    return false;
  } catch (EConvertError *error) {
  	return false;
  }
}
//---------------------------------------------------------------------------

void __fastcall TYarnArrangeForm::YPICalculate(int col, int row)
{
}
//---------------------------------------------------------------------------

void __fastcall TYarnArrangeForm::ArrayGridKeyDown(TObject *Sender,
      WORD &Key, TShiftState Shift)
{
	TYarnArray *yarnarray;
  AnsiString str;

	if (Key==VK_RETURN ) {
    TStringGrid *grid = (TStringGrid *) Sender;
 		if (grid->EditorMode) {
      str = ArrayGrid->Cells[grid->Col][grid->Row];
     	if (((grid->Row-1) <= MainImageForm->Plan->Yarn->Array[grid->Col-1].count)
           && (MainImageForm->Plan->Texture->Array[grid->Col - 1].number > 0)) {   // NO Texture No Yarn
        if (ProperInput(str)) {
          MainImageForm->Plan->Yarn->AddTextureData(grid->Row-1,grid->Col-1,StrToInt(str));
          grid->Row = grid->Row + 1;
          InitArrayButton(1);
        } else {
          ArrayGrid->Cells[grid->Col][grid->Row] = "";
        }
     	} else {
        ArrayGrid->Cells[grid->Col][grid->Row] = "";
      }
    	grid->EditorMode = false;
    	ArrayGrid->Repaint();
		}
	}
}
//---------------------------------------------------------------------------
void __fastcall TYarnArrangeForm::AllDensity(double d)
{
}
//---------------------------------------------------------------------------

void __fastcall TYarnArrangeForm::sbArrayNewClick(TObject *Sender)
{
  clearArrayGrid();
}
//---------------------------------------------------------------------------
void __fastcall TYarnArrangeForm::clearArrayGrid()
{
  int i,j,cntArray,cnt;

  ArrayGrid->EditorMode = false;
  for (i=0 ; i<6 ; i++) {
    cnt = MainImageForm->Plan->Yarn->Array[i].count;
    for (j=0 ; j<cnt ; j++) {
      ArrayGrid->Cells[i+1][j+1] = "";
      MainImageForm->Plan->Yarn->Array[i].code[j] = 0;
    }
    MainImageForm->Plan->Yarn->Array[i].count = 0;
  }
  MainImageForm->Plan->Yarn->ArrayCount = 0;
  InitArrayButton(0);
  ArrayGrid->Repaint();
}
//---------------------------------------------------------------------------

//// Private Method
//---------------------------------------------------------------------------
void __fastcall TYarnArrangeForm::InitChoiceButton(int i)
{
	sbDyeDelete->Down = false;
	sbDyeNew->Enabled = i;
  sbDyeDelete->Enabled = i;
}

//---------------------------------------------------------------------------
void __fastcall TYarnArrangeForm::AddChoiceColor(int i, int j)
{
  TColorData *cd;

  int cnt = MainImageForm->Plan->Yarn->Choice[i].Data->Colors;
  if (cnt > 0) {
	  for (int k = 0; k < cnt; k++) {
      cd = MainImageForm->Palette->ColorData[PalIndex];
		  MainImageForm->Plan->Yarn->Choice[i].Color[j][k]->SetColor(cd, PalIndex);
      MainImageForm->Plan->Yarn->Choice[i].Data->Color[k]->SetColor(cd);
  	  PalIndex++;
      if (PalIndex > 251) PalIndex = 2;
    }
  }
}
//---------------------------------------------------------------------------
void __fastcall TYarnArrangeForm::ChangeChoiceColor(int i, int j, int k)
{
  int ind = PaletteForm->DIB256Palette->ChoiceIndex;
  if (ind == 1) {
  	ShowMessage(IDS_MESSAGE);
    PaletteForm->DIB256Palette->ChoiceIndex = 2;
    ind = 2;
  }
	TColorData *src = MainImageForm->Palette->ColorData[ind];
 	MainImageForm->Plan->Yarn->Choice[i].Color[j][k]->SetColor(src, ind);
  for (int n = 0; n < MainImageForm->Plan->Yarn->Choice[i].Data->Colors; n++) {
  	src = (TColorData *) MainImageForm->Plan->Yarn->Choice[i].Color[j][n]->GetColor(0);
  	MainImageForm->Plan->Yarn->Choice[i].Data->Color[n]->SetColor(src);
  }
}
//---------------------------------------------------------------------------
void __fastcall TYarnArrangeForm::DrawColorGrid(int i)
{
	TPColorGrid *colorgrid  = (TPColorGrid *) FindComponent("ColorGrid"+ AnsiString(i+1));
  TColorData *cd;
  int k = i / 8;
  if (colorgrid->ColorCount > 0) {
    for (int j = 0; j < colorgrid->ColorCount; j++) {
      cd = (TColorData *) MainImageForm->Plan->Yarn->Choice[k].Color[i%8][j]->GetColor(0);
  	  colorgrid->ReDrawCell(j, cd->Color);
    }
  }
}
//---------------------------------------------------------------------------
void __fastcall TYarnArrangeForm::ScrollEnable(int i)
{
  TScrollBar *sb = (TScrollBar *) FindComponent("ScrollBar" + AnsiString(i+1));
  int cnt = MainImageForm->Plan->Yarn->Choice[i].Data->Colors;
	if (cnt < 7)
  	sb->Enabled = false;
  else {
  	sb->Enabled = true;
  	sb->Max = cnt - 6;
  }
}
//---------------------------------------------------------------------------
int __fastcall TYarnArrangeForm::FindChoiceIndex()
{
	for (int i = 0; i < 4; i++) {
  	if (!MainImageForm->Plan->Yarn->Choice[i].Data) return i;
  }
  return -1;
}
//---------------------------------------------------------------------------
//// Array Private Method
//---------------------------------------------------------------------------
void __fastcall TYarnArrangeForm::InitArrayButton(int i)
{
	sbArrayInsert->Down = false;
	sbArrayDelete->Down = false;
	sbArrayNew->Enabled = i;
  sbArrayInsert->Enabled = i;
  sbArrayDelete->Enabled = i;
}
//---------------------------------------------------------------------------
void __fastcall TYarnArrangeForm::ChangeTotalSize()
{
}
//---------------------------------------------------------------------------

void __fastcall TYarnArrangeForm::DeleteArrayData(int cnt, int i, int ww, bool ex)
{
}
//---------------------------------------------------------------------------

void __fastcall TYarnArrangeForm::RearrangeGrid(int precnt, int ww)
{
}
//---------------------------------------------------------------------------

void __fastcall TYarnArrangeForm::CloseTableForm()
{
  sbTableView->Down = false;
}
//---------------------------------------------------------------------------

void __fastcall TYarnArrangeForm::CloseAccountForm()
{
}
//---------------------------------------------------------------------------
//// Public Method
//---------------------------------------------------------------------------
void __fastcall TYarnArrangeForm::YarnChange(AnsiString fn)
{
  int i = FindChoiceIndex();
	if (i >= 0) {
    AcceptData(fn, i);
  } else {
		MainImageForm->Plan->Yarn->ChoiceCount = 4;
    Sysutils::Beep();
    ShowMessage(IDS_MESSAGE_DATAFULL);
  }
}
//---------------------------------------------------------------------------
void __fastcall TYarnArrangeForm::AcceptData(AnsiString fn, int i)
{
  TPColorGrid *colorgrid;
  if (IsScanYarn(fn)) {
    ShowMessage(IDS_MESSAGE_SCANYARN);
    return;
  }
  i = FindChoiceIndex();
	if (i >= 0) {
		MainImageForm->Plan->Yarn->AddChoiceData(fn, i, MainImageForm->CanvasInfor.DotsPerInch);
    AddChoiceColor(i, 0);
    for (int j = 1; j <= 8; j++) {
      colorgrid = (TPColorGrid *) FindComponent("ColorGrid"+ IntToStr(i*8+j));
      colorgrid->ColorCount = MainImageForm->Plan->Yarn->Choice[i].Data->Colors;
    }
    ScrollEnable(i);
    DrawColorGrid(i*8);
  	colorgrid = (TPColorGrid *) FindComponent("ColorGrid"+ IntToStr(i*8+1));
    colorgrid->IsFill = true;
    InitChoiceButton(1);
  	DyeGrid->Repaint();
  } else {
		MainImageForm->Plan->Yarn->ChoiceCount = 4;
    ShowMessage(IDS_MESSAGE_DATAFULL);
  }
}
//---------------------------------------------------------------------------
bool __fastcall TYarnArrangeForm::IsScanYarn(AnsiString fn)
{
  TYarnData yd;
  yd.LoadFromFile(fn);
  return yd.Dyed;
}
//---------------------------------------------------------------------------

void __fastcall TYarnArrangeForm::DyeGridDragDrop(TObject *Sender,
      TObject *Source, int X, int Y)
{
  int si, ti, i, cnt, precnt;
  TPColorGrid *cg;
  TPanel *panel;
  TStringGrid *sg = (TStringGrid *) Source;
  AnsiString fn, dn;

  si = sg->Col  + (sg->Row * sg->ColCount);
  if (si >= YarnTableForm->FileListBox->Items->Count) return;
  YarnTableForm->FileListBox->ItemIndex = si;
  fn = ExtractFileName(YarnTableForm->FileListBox->FileName);
  dn = ExtractFileDir(YarnTableForm->FileListBox->FileName);
  chdir(dn.c_str());
  ti = (DyeGrid->MouseCoord(X, Y)).X;
  if (ti < 0) return;
  if (MainImageForm->Plan->Yarn->Choice[ti].Data) {
    if (IsScanYarn(fn)) {
      ShowMessage(IDS_MESSAGE_SCANYARN);
      return;
    }
    MainImageForm->Plan->Yarn->RemoveChoiceData(ti);
    cnt = 0;

    for (i = 0; i < 8; i++) {
      cg = (TPColorGrid *) FindComponent("ColorGrid" + AnsiString(ti*8+i+1));
      if (cg->IsFill) cnt++;
      cg->ColorCount = 0; cg->IsFill = false;
    }

    MainImageForm->Plan->Yarn->ChangeChoiceData(fn, ti, MainImageForm->CanvasInfor.DotsPerInch);
    for (i = 0; i < 8; i++) {
      cg = (TPColorGrid *) FindComponent("ColorGrid" + AnsiString(ti*8+i+1));
      cg->ColorCount = MainImageForm->Plan->Yarn->Choice[ti].Data->Colors;
      if (i < cnt) {
        MainImageForm->Plan->Yarn->AddColor(ti, i);
        AddChoiceColor(ti, i);
        DrawColorGrid(cg->Tag-1);
        cg->IsFill = true;
      }
      ScrollEnable(ti);
    }
    DyeGrid->Repaint();
    MainImageForm->bChoiceExchange = true;
  } else {
    YarnChange(fn);
  }
}
//---------------------------------------------------------------------------

void __fastcall TYarnArrangeForm::UnitChange()
{
}
//---------------------------------------------------------------------------
void __fastcall TYarnArrangeForm::InitSetHLS(int i)
{
}
//---------------------------------------------------------------------------


void __fastcall TYarnArrangeForm::DyeGridDragOver(TObject *Sender,
      TObject *Source, int X, int Y, TDragState State, bool &Accept)
{
  if (Source == YarnTableForm->YarnTableGrid) Accept = true; else Accept = false;
}
//---------------------------------------------------------------------------

void __fastcall TYarnArrangeForm::YarnColorChange(int k, int m, int n, int i)
{
  TPColorGrid *colorgrid = NULL;
  int index = k*8 + (m+1);
  TColorData *cd = MainImageForm->Palette->ColorData[i];
  colorgrid = (TPColorGrid *) FindComponent("ColorGrid" + AnsiString(index));
  colorgrid->ReDrawCell(n, cd->Color);
  DyeGrid->Invalidate();
}
//---------------------------------------------------------------------------