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

#include "GuideBar.h"
#include "YarnCompositionData.h"
#include "TexLayer.h"
#include "Tex.h"
#include "tricot.h"
#include "Main_F.h"
#include "Design.h"
#include "ColorLibrary_F.h"
#include "Palette.h"
#include "MetaData_F.h"
#include "YarnList_F.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
//---------------------------------------------------------------------------
#define IDS_WALE_SET          StringTable[0]
#define IDS_COURSE_SET        StringTable[1]
#define IDS_THREADING         StringTable[2]
#define IDS_START             StringTable[3]
#define IDS_COUNT             StringTable[4]
#define IDS_COURSE            StringTable[5]
#define IDS_LENGTH            StringTable[6]
#define IDS_ADD               StringTable[7]
#define IDS_DELETE            StringTable[8]
#define IDS_GUIDE_BAR         StringTable[9]
#define IDS_TRANSPARENT       StringTable[10]
#define IDS_TOO_BIG_WIDTH     StringTable[11]
#define IDS_COMPLETE_NEEDLE   StringTable[12]
#define IDS_YARN_LIST         StringTable[13]
#define IDS_YARN_NUM          StringTable[14]
#define IDS_DEFAULT_DENIER    StringTable[15]
#define IDS_DEFAULT_FILAMENT  StringTable[16]
#define IDS_OVERLAP           StringTable[17]
#define IDS_DESCRIPTION       StringTable[18]
#define IDS_FORCE             StringTable[19]
#define IDS_DEFAULT           StringTable[20]
#define IDS_SET_WITH_OPTIMIZE StringTable[21]
#define IDS_SET_WITH_FORMULA  StringTable[22]

//---------------------------------------------------------------------------
TGuideBar_F *GuideBar_F;
//---------------------------------------------------------------------------
__fastcall TGuideBar_F::TGuideBar_F(TComponent* Owner)
  : TForm(Owner)
{
  for(int i=0;i<4;i++) ListOfDefault[i] = new TList;

  StringTable.Create(BaseDir, Language, "Guide Bar");
  Caption=IDS_GUIDE_BAR;
  tsCourse->Caption=IDS_COURSE_SET;
  tsThreading->Caption=IDS_THREADING;
  lbStart->Caption=IDS_START;
  lbCompleteNeedle->Caption=IDS_COMPLETE_NEEDLE;
  lbFilament->Caption=IDS_DEFAULT_FILAMENT;
  lbDenier->Caption=IDS_DEFAULT_DENIER;
  sbViewYarnList->Caption=IDS_YARN_LIST;
  pmAdd->Caption=IDS_ADD;
  pmDelete->Caption=IDS_DELETE;
  lbInOutDescription->Caption=IDS_DESCRIPTION;
  sbDefault->Caption=IDS_DEFAULT;
  sbSetDefaultWithOptimization->Caption=IDS_SET_WITH_OPTIMIZE;
  sbSetDefaultWithFormula->Caption=IDS_SET_WITH_FORMULA;

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

void __fastcall TGuideBar_F::UpdateEdit(void){
  Tex *tex = (Tex *)Main->texlayer->TexList->Items[Main->LayerNum];
  edShift->Text = IntToStr(tex->leftShift);
  edCompleteNeedle->Text = IntToStr(Main->texlayer->complete_needle);
  edInOutDescription->Text = gd.iodescription[Main->LayerNum];  
}
//---------------------------------------------------------------------------
void __fastcall TGuideBar_F::UpdateGuideBar(void){
  UpdateEdit();
}
//---------------------------------------------------------------------------
void __fastcall TGuideBar_F::FormPaint(TObject *Sender)
{
  Tex *tex = (Tex *)Main->texlayer->TexList->Items[Main->LayerNum];
  lbLayer->Caption="Layer "+IntToStr(Main->LayerNum+1);

  sgThreading->RowCount = tex->Wales->Count>20 ? tex->Wales->Count+10 : 30;
  sgCourse->RowCount = tex->Curve->Count>20 ? tex->Curve->Count+10 : 30;

  sgThreading->Repaint();
  sgCourse->Repaint();

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

void __fastcall TGuideBar_F::FormActivate(TObject *Sender)
{
  lbLayer->Caption="Layer "+IntToStr(Main->LayerNum+1);
  ShowData();
  UpdateGuideBar();
}
//---------------------------------------------------------------------------

void __fastcall TGuideBar_F::edShiftKeyPress(TObject *Sender, char &Key)
{
  Tex *tex = (Tex *)Main->texlayer->TexList->Items[Main->LayerNum];
  if(Key==VK_RETURN){
    if(edShift->Text=="")return;
    if(StrToInt(edShift->Text)<0) edShift->Text = "0";
    tex->leftShift=StrToInt(edShift->Text);
    UpdateGuideBar();
    DesignForm->DrawChart();
    DesignForm->UpdateEdit();
  }
}
//---------------------------------------------------------------------------

void __fastcall TGuideBar_F::FormCreate(TObject *Sender)
{

  SetFont();

  pcGuideBar->ActivePage=tsThreading;
  
  sgThreading->ColCount = 5;
  sgThreading->RowCount = 20;
  sgThreading->DefaultRowHeight = 25;
  sgThreading->ColWidths[0] = 53;
  sgThreading->ColWidths[1] = 90;
  sgThreading->ColWidths[2] = 100;
  sgThreading->ColWidths[3] = 90;
  sgThreading->ColWidths[4] = 100;
  sgThreading->FixedCols=2;
  sgCourse->ColCount = 5;
  sgCourse->RowCount = 20;
  sgCourse->DefaultRowHeight = 25;
  sgCourse->ColWidths[0] = 63;
  sgCourse->ColWidths[1] = 105;
  sgCourse->ColWidths[2] = 105;
  sgCourse->ColWidths[3] = 80;
  sgCourse->ColWidths[4] = 80;
  sgCourse->FixedCols=1;

}
//---------------------------------------------------------------------------
void __fastcall TGuideBar_F::ShowData(){
  edDenier->Text=MyFloatToStr(gd.default_denier,2);
  edFilament->Text=IntToStr(gd.default_filament);

  rgFormula1->ItemIndex=gd.formula[0];
  rgFormula2->ItemIndex=gd.formula[1];
  rgFormula3->ItemIndex=gd.formula[2];
  rgFormula4->ItemIndex=gd.formula[3];

}
//---------------------------------------------------------------------------
void __fastcall TGuideBar_F::SetFont(){
  SetSmallFont(Font);
  SetSmallFont(lbLayer->Font);
}
//---------------------------------------------------------------------------
void __fastcall TGuideBar_F::sgThreadingDrawCell(TObject *Sender,
      int ACol, int ARow, TRect &Rect, TGridDrawState State)
{
  Tex *tex = (Tex *)Main->texlayer->TexList->Items[Main->LayerNum];
  AnsiString str;
  sgThreading->Canvas->Font->Size=10;

  switch(ACol){
    case 0:
    {
      if(ARow){
        str=IntToStr(ARow);
      }
      break;
    }
    case 1:
    {
      if(ARow==0){
        str = IDS_THREADING;
        sgThreading->Canvas->Font->Color = clMaroon;
      } else {
        str="";
        if(ARow-1<tex->Wales->Count){
          if(((WaleState *)(tex->Wales->Items[ARow-1]))->in){
            str="In";
          } else {
            str="Out";
          }
        }
      }

      break;
    }
    case 2:
    {
      if(ARow==0){
        str = IDS_COUNT;
        sgThreading->Canvas->Font->Color = clMaroon;
      } else {
        str="";
        if(ARow-1<tex->Wales->Count)
          str=IntToStr(((WaleState *)(tex->Wales->Items[ARow-1]))->cnt);
      }

      break;
    }

    case 3:
      if(ARow==0){
        str = IDS_YARN_NUM;
        sgThreading->Canvas->Font->Color = clMaroon;
      } else {
        str="";
        if(ARow-1<tex->Wales->Count)
          str=AnsiString((char)('A'+((WaleState *)(tex->Wales->Items[ARow-1]))->yarnIndex));
      }
      break;

    case 4:
      if(ARow==0){
        str = IDS_TRANSPARENT;
        sgThreading->Canvas->Font->Color = clMaroon;
      } else {
        if(ARow-1<tex->Wales->Count&&((WaleState *)(tex->Wales->Items[ARow-1]))->in){
          bool isTransParent=((WaleState *)(tex->Wales->Items[ARow-1]))->isTransParent;
          if(isTransParent)str="O";
          else str="X";
        }
      }
      break;
    default:
      break;
  }
  if(sgThreading->Cells[ACol][ARow]!="")sgThreading->Cells[ACol][ARow]="";
  int x = ((Rect.right-Rect.left) - sgThreading->Canvas->TextWidth(str)) / 2;
  int y = ((Rect.bottom-Rect.top) - sgThreading->Canvas->TextHeight(str)) / 2;
  sgThreading->Canvas->TextOut(Rect.Left + x, Rect.Top + y, str);

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

void __fastcall TGuideBar_F::sgCourseDrawCell(TObject *Sender, int ACol,
      int ARow, TRect &Rect, TGridDrawState State)
{

  Tex *tex = (Tex *)Main->texlayer->TexList->Items[Main->LayerNum];
  AnsiString str;
  sgCourse->Canvas->Font->Size=10;

  switch(ACol){
    case 0:
    {
      if(ARow==0){
        str = IDS_COURSE;
        sgCourse->Canvas->Font->Color = clMaroon;
      } else {
        str="";
        if(ARow-1<tex->Curve->Count){
          str=IntToStr(ARow);
        }
      }
      break;
    }
    case 1:
    {
      if(ARow==0){
        str = "mm/RACK";
        sgCourse->Canvas->Font->Color = clMaroon;
      } else {
        if(ARow-1<tex->Curve->Count){
          str=IntToStr(((CourseState *)(tex->Courses->Items[ARow-1]))->emit);
        }
      }
      break;
    }
    case 2:
    {
      if(ARow==0){
        str = IDS_DEFAULT;
        sgCourse->Canvas->Font->Color = clMaroon;
      } else {
        if(ARow-1<tex->Curve->Count){
          if(tex->Curve->Count!=ListOfDefault[Main->LayerNum]->Count) str="-";
          else str=IntToStr(*(int *)ListOfDefault[Main->LayerNum]->Items[ARow-1]);
        }
      }
      break;
    }
    case 3:
    {
      if(ARow==0){
        str = IDS_OVERLAP;
        sgCourse->Canvas->Font->Color = clMaroon;
      } else {
        if(ARow-1<tex->Curve->Count){
          if(*(bool *)(tex->Raise->Items[ARow-1])){
            str="O";
          } else {
            str="X";
          }
        }
      }
      break;
    }
    case 4:
    {
      if(ARow==0){
        str = IDS_FORCE;
        sgCourse->Canvas->Font->Color = clMaroon;
      } else {
        if(ARow-1<tex->Curve->Count){
          if(*(bool *)(tex->Force->Items[ARow-1])){
            str="O";
          } else {
            str="X";
          }
        }
      }
      break;
    }

    default:
      break;
  }
  if(sgCourse->Cells[ACol][ARow]!="")sgCourse->Cells[ACol][ARow]="";
  int x = ((Rect.right-Rect.left) - sgCourse->Canvas->TextWidth(str)) / 2;
  int y = ((Rect.bottom-Rect.top) - sgCourse->Canvas->TextHeight(str)) / 2;
  sgCourse->Canvas->TextOut(Rect.Left + x, Rect.Top + y, str);

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

void __fastcall TGuideBar_F::edThreadingInputKeyPress(TObject *Sender, char &Key)
{
  Tex *tex = (Tex *)Main->texlayer->TexList->Items[Main->LayerNum];
  TexLayer *texlayer = Main->texlayer;
  switch(sgThreading->Col){
    case 0:
      break;
    case 2:
    {
      if(Key==VK_RETURN){
        if(edThreadingInput->Text=="")return;
        int i;
        if(i<0)i=0;
        i=StrToInt(edThreadingInput->Text);
        for(int j=sgThreading->Selection.Top;j<=sgThreading->Selection.Bottom;j++){
          if(j-1<tex->Wales->Count){//Row´Â 1ºÎÅÍ ½ÃÀÛ//Wales´Â 0ºÎÅͽÃÀÛ//Row-1==Wales
            ((WaleState *)tex->Wales->Items[j-1])->cnt=i;
          } else {
            WaleState *ws = new WaleState;
            ws->cnt=i;
            tex->Wales->Add(ws);
          }
        }

        edThreadingInput->Text="";
        sgThreading->Repaint();
        DesignForm->DrawChart();
        sgThreading->Row++;
      }
      break;
    }
    case 3:
    {
      if(Key==VK_RETURN){
        if(edThreadingInput->Text=="")return;
        int i;
        if(i<0)i=0;
        char c=*(char *)(edThreadingInput->Text.c_str());
        if(c>='A'&&c<='Z'){
          c-='A';
        } else {
          c-='a';
        }
        i=c;
        if(i>=texlayer->YarnList->Count){
          i=texlayer->YarnList->Count-1;
        }
        if(i<0){
          i=0;
        }
        for(int j=sgThreading->Selection.Top;j<=sgThreading->Selection.Bottom;j++){
          if(j-1<tex->Wales->Count){//Row´Â 1ºÎÅÍ ½ÃÀÛ//Wales´Â 0ºÎÅͽÃÀÛ//Row-1==Wales
            ((WaleState *)tex->Wales->Items[j-1])->yarnIndex=i;
          } else {
            WaleState *ws = new WaleState;
            ws->yarnIndex=i;
            tex->Wales->Add(ws);
          }
        }

        edThreadingInput->Text="";
        sgThreading->Repaint();
        DesignForm->DrawChart();
        sgThreading->Row++;
      }
      break;
    }
    default:
      break;
  }

  if(YarnCompositionData_F&&YarnCompositionData_F->Visible)YarnCompositionData_F->Repaint();

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

void __fastcall TGuideBar_F::edCourseInputKeyPress(TObject *Sender,
      char &Key)
{
  Tex *tex = (Tex *)Main->texlayer->TexList->Items[Main->LayerNum];

  switch(sgCourse->Col){
    case 0:
      break;
    case 1:
    {
      if(Key==VK_RETURN){
        if(edCourseInput->Text=="")return;
        int i;
        i=StrToInt(edCourseInput->Text);
        if(i<0)i=0;
        for(int j=sgCourse->Selection.Top;j<=sgCourse->Selection.Bottom;j++){
          if(j-1<tex->Curve->Count){//Row´Â 1ºÎÅÍ ½ÃÀÛ//Curve´Â 0ºÎÅͽÃÀÛ//Row-1==Curve
            ((CourseState *)tex->Courses->Items[j-1])->emit=i;
          }
        }
        edCourseInput->Text="";
        sgCourse->Repaint();
        DesignForm->DrawChart();
        //sgCourse->Row++;
      }
      break;

    }
    case 3:
    {
      if(Key==VK_RETURN){
        if(edCourseInput->Text=="")return;
        bool v=true;
        if(edCourseInput->Text=="0"||edCourseInput->Text=="O"||edCourseInput->Text=="o"){
          v=true;
        } else {
          v=false;
        }
        for(int j=sgCourse->Selection.Top;j<=sgCourse->Selection.Bottom;j++){
          if(j-1<tex->Raise->Count){//Row´Â 1ºÎÅÍ ½ÃÀÛ//Curve´Â 0ºÎÅͽÃÀÛ//Row-1==Curve
            *((bool *)tex->Raise->Items[j-1])=v;
          }
        }
        edCourseInput->Text="";
        sgCourse->Repaint();
        DesignForm->DrawChart();
        //sgCourse->Row++;
      }
      break;
    }
    case 4:
    {
      if(Key==VK_RETURN){
        if(edCourseInput->Text=="")return;
        bool v=true;
        if(edCourseInput->Text=="0"||edCourseInput->Text=="O"||edCourseInput->Text=="o"){
          v=true;
        } else {
          v=false;
        }
        for(int j=sgCourse->Selection.Top;j<=sgCourse->Selection.Bottom;j++){
          if(j-1<tex->Force->Count){//Row´Â 1ºÎÅÍ ½ÃÀÛ//Curve´Â 0ºÎÅͽÃÀÛ//Row-1==Curve
            *((bool *)tex->Force->Items[j-1])=v;
          }
        }
        edCourseInput->Text="";
        sgCourse->Repaint();
        DesignForm->DrawChart();
        //sgCourse->Row++;
      }
      break;
    }

    default:
      break;
  }

  if(YarnCompositionData_F&&YarnCompositionData_F->Visible)YarnCompositionData_F->Repaint();

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

void __fastcall TGuideBar_F::sgThreadingClick(TObject *Sender)
{
  edThreadingInput->SetFocus();
}
//---------------------------------------------------------------------------
void __fastcall TGuideBar_F::sgCourseClick(TObject *Sender)
{
  edCourseInput->SetFocus();
}
//---------------------------------------------------------------------------

void __fastcall TGuideBar_F::edThreadingInputKeyDown(TObject *Sender, WORD &Key,
      TShiftState Shift)
{
  switch(Key){
    case VK_LEFT:
    {
      if(sgThreading->Col>sgThreading->FixedCols) sgThreading->Col--;
      break;
    }
    case VK_RIGHT:
    {
      if(sgThreading->Col<sgThreading->ColCount-1)
        sgThreading->Col++;
      break;
    }
    case VK_UP:
    {
      if(sgThreading->Row>sgThreading->FixedRows)
        sgThreading->Row--;
      break;
    }
    case VK_DOWN:
    {
      if(sgThreading->Row<sgThreading->RowCount-1)
        sgThreading->Row++;
      break;
    }
  }
}
//---------------------------------------------------------------------------
void __fastcall TGuideBar_F::edCourseInputKeyDown(TObject *Sender,
      WORD &Key, TShiftState Shift)
{
  switch(Key){
    case VK_LEFT:
    {
      if(sgCourse->Col>sgCourse->FixedCols) sgCourse->Col--;
      break;
    }
    case VK_RIGHT:
    {
      if(sgCourse->Col<sgCourse->ColCount-1)
        sgCourse->Col++;
      break;
    }
    case VK_UP:
    {
      if(sgCourse->Row>sgCourse->FixedRows)
        sgCourse->Row--;
      break;
    }
    case VK_DOWN:
    {
      if(sgCourse->Row<sgCourse->RowCount-1)
        sgCourse->Row++;
      break;
    }
  }

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

void __fastcall TGuideBar_F::FormShow(TObject *Sender)
{
  if(pcGuideBar->ActivePage==tsThreading){
    edThreadingInput->SetFocus();
  } else if(pcGuideBar->ActivePage==tsCourse){
    edCourseInput->SetFocus();
  }
}
//---------------------------------------------------------------------------

void __fastcall TGuideBar_F::pmAddClick(TObject *Sender)
{
  Tex *tex = (Tex *)Main->texlayer->TexList->Items[Main->LayerNum];

  if(row-1<0||row-1>tex->Wales->Count){
    return;
  }
  WaleState *ws = new WaleState;
  tex->Wales->Insert(row-1,ws);

  if(YarnCompositionData_F&&YarnCompositionData_F->Visible)YarnCompositionData_F->Repaint();
  sgThreading->Repaint();
  DesignForm->DrawChart();

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

void __fastcall TGuideBar_F::pmDeleteClick(TObject *Sender)
{
  Tex *tex = (Tex *)Main->texlayer->TexList->Items[Main->LayerNum];
  if(row-1<0||row-1>=tex->Wales->Count){
    return;
  }
  WaleState *ws = (WaleState *)tex->Wales->Items[row-1];
  delete ws;
  tex->Wales->Delete(row-1);

  if(YarnCompositionData_F&&YarnCompositionData_F->Visible)YarnCompositionData_F->Repaint();
  sgThreading->Repaint();
  DesignForm->DrawChart();

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

void __fastcall TGuideBar_F::sgThreadingMouseDown(TObject *Sender,
      TMouseButton Button, TShiftState Shift, int X, int Y)
{
  int ACol,ARow;
  sgThreading->MouseToCell(X, Y, ACol, ARow);
  col=ACol;
  row=ARow;
  //sgThreading->Col=ACol<1 ? 1 : ACol;
  //sgThreading->Row=ARow<1 ? 1 : ARow;
  Tex *tex = (Tex *)Main->texlayer->TexList->Items[Main->LayerNum];
  switch(ACol){
    case 1:
    {
      if(ARow!=0&&ARow-1<tex->Wales->Count){
        if(!Shift.Contains(ssLeft))break;
        ((WaleState *)tex->Wales->Items[ARow-1])->in
          = !((WaleState *)tex->Wales->Items[ARow-1])->in;
      }
      break;
    }
    case 4:
    {
      if(!Shift.Contains(ssLeft))break;
      if(ARow-1==tex->Wales->Count){
        WaleState *ws = new WaleState;
        ws->isTransParent=false;
        tex->Wales->Add(ws);
      } else if(ARow!=0&&ARow-1<tex->Wales->Count){
        ((WaleState *)tex->Wales->Items[ARow-1])->isTransParent =! ((WaleState *)tex->Wales->Items[ARow-1])->isTransParent;
      }
      //sgThreading->Col=1;
      break;
    }
    default:
      break;
  }

  if(YarnCompositionData_F&&YarnCompositionData_F->Visible)YarnCompositionData_F->Repaint();
  sgThreading->Repaint();
  DesignForm->DrawChart();

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

void __fastcall TGuideBar_F::sbDefaultClick(TObject *Sender)
{
  Tex *tex = (Tex *)Main->texlayer->TexList->Items[Main->LayerNum];
  if(tex->Courses->Count!=ListOfDefault[Main->LayerNum]->Count) return;
  for(int i=0;i<tex->Courses->Count;i++){
    ((CourseState *)tex->Courses->Items[i])->emit=*(int *)ListOfDefault[Main->LayerNum]->Items[i];
  }
  sgCourse->Repaint();
}
//---------------------------------------------------------------------------


void __fastcall TGuideBar_F::edCompleteNeedleKeyPress(TObject *Sender,
      char &Key)
{
  if(Key==VK_RETURN){
    int i=StrToInt(edCompleteNeedle->Text);
    if(i<1) i=1;
    if(i>TEX_MAX_WIDTH)i=TEX_MAX_WIDTH;
    Main->texlayer->complete_needle=i;
    edCompleteNeedle->Text=IntToStr(i);
  }
}
//---------------------------------------------------------------------------

void __fastcall TGuideBar_F::edFilamentKeyPress(TObject *Sender, char &Key)
{
  if(Key==VK_RETURN){
    int i=StrToInt(edFilament->Text);
    if(i<1) i=1;
    gd.default_filament=i;
    edFilament->Text=IntToStr(i);
    sgCourse->Repaint();
  }
}
//---------------------------------------------------------------------------

void __fastcall TGuideBar_F::edDenierKeyPress(TObject *Sender, char &Key)
{
  if(Key==VK_RETURN){
    double i=StrToFloat(edDenier->Text);
    if(i<0) i=0;
    gd.default_denier=i;
    edDenier->Text=MyFloatToStr(i,2);
    sgCourse->Repaint();
  }
}
//---------------------------------------------------------------------------
void __fastcall TGuideBar_F::pcGuideBarChange(TObject *Sender)
{
  if(pcGuideBar->ActivePage==tsThreading){
    edThreadingInput->SetFocus();
  } else if(pcGuideBar->ActivePage==tsCourse){
    edCourseInput->SetFocus();
  }
}
//---------------------------------------------------------------------------

void __fastcall TGuideBar_F::sbViewYarnListClick(TObject *Sender)
{
  if(YarnListForm->WindowState==wsMinimized){
    YarnListForm->WindowState=wsNormal;
    return;
  }
  if(YarnListForm->Visible)YarnListForm->Visible=false;
  else YarnListForm->Visible=true;
}
//---------------------------------------------------------------------------

void __fastcall TGuideBar_F::rgFormula1Click(TObject *Sender)
{
  gd.formula[0]=rgFormula1->ItemIndex;
  sgCourse->Repaint();
}
//---------------------------------------------------------------------------

void __fastcall TGuideBar_F::rgFormula2Click(TObject *Sender)
{
  gd.formula[1]=rgFormula2->ItemIndex;
  sgCourse->Repaint();
}
//---------------------------------------------------------------------------

void __fastcall TGuideBar_F::rgFormula3Click(TObject *Sender)
{
  gd.formula[2]=rgFormula3->ItemIndex;
  sgCourse->Repaint();
}
//---------------------------------------------------------------------------

void __fastcall TGuideBar_F::rgFormula4Click(TObject *Sender)
{
  gd.formula[3]=rgFormula4->ItemIndex;
  sgCourse->Repaint();  
}
//---------------------------------------------------------------------------

void __fastcall TGuideBar_F::edInOutDescriptionKeyPress(TObject *Sender,
      char &Key)
{
  if(Key==VK_RETURN){
    gd.iodescription[Main->LayerNum]=edInOutDescription->Text;
  }
}
//---------------------------------------------------------------------------

void __fastcall TGuideBar_F::sgCourseMouseDown(TObject *Sender,
      TMouseButton Button, TShiftState Shift, int X, int Y)
{
  int ACol,ARow;
  sgCourse->MouseToCell(X, Y, ACol, ARow);
  col=ACol;
  row=ARow;
  //sgCourse->Col=ACol<1 ? 1 : ACol;
  //sgCourse->Row=ARow<1 ? 1 : ARow;
  Tex *tex = (Tex *)Main->texlayer->TexList->Items[Main->LayerNum];
  switch(ACol){
    case 3:
    {
      if(!Shift.Contains(ssLeft))break;
      if(ARow!=0&&ARow-1<tex->Raise->Count){
        *((bool *)tex->Raise->Items[ARow-1]) =! *((bool *)tex->Raise->Items[ARow-1]);
      }
      break;
    }
    case 4:
    {
      if(!Shift.Contains(ssLeft))break;
      if(ARow!=0&&ARow-1<tex->Force->Count){
        *((bool *)tex->Force->Items[ARow-1]) =! *((bool *)tex->Force->Items[ARow-1]);
      }
      break;
    }
    default:
      break;
  }

  if(YarnCompositionData_F&&YarnCompositionData_F->Visible)YarnCompositionData_F->Repaint();
  sgCourse->Repaint();
  //DesignForm->DrawChart();

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

void __fastcall TGuideBar_F::FormDestroy(TObject *Sender)
{
  for(int i=0;i<4;i++){
    while(ListOfDefault[i]->Count){
      delete (int *)ListOfDefault[i]->Last();
      ListOfDefault[i]->Remove(ListOfDefault[i]->Last());
    }
    delete ListOfDefault[i];
  }
}
//---------------------------------------------------------------------------

void __fastcall TGuideBar_F::sbSetDefaultWithFormulaClick(TObject *Sender)
{

  Tex *tex0 = (Tex *)Main->texlayer->TexList->Items[0];
  int h=tex0->Courses->Count;
  for(int i=0;i<4;i++){
    if(ListOfDefault[i]->Count>h){
      while(ListOfDefault[i]->Count>h){
        delete (int *)ListOfDefault[i]->Last();
        ListOfDefault[i]->Remove(ListOfDefault[i]->Last());
      }
    } else {
      while(ListOfDefault[i]->Count<h){
        int *p = new int;
        *p = DEFAULT_YARN_EMIT;
        ListOfDefault[i]->Add(p);
      }
    }
  }

  for(int i=0;i<Main->maindata.bar;i++){
    Tex *tex = (Tex *)Main->texlayer->TexList->Items[i];
    for(int j=0;j<h;j++){
      int DefaultLength = tex->DefaultLength(j, gd.default_denier, gd.default_filament,
            Main->maindata.cpc, Main->maindata.gauge, gd.formula[i])*480.0;

      *(int *)ListOfDefault[i]->Items[j]=DefaultLength;
    }
  }
  sgCourse->Repaint();

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

void __fastcall TGuideBar_F::sbSetDefaultWithOptimizationClick(
      TObject *Sender)
{
  int h=Main->maindata.course;
  for(int i=0;i<4;i++){
    if(ListOfDefault[i]->Count>h){
      while(ListOfDefault[i]->Count>h){
        delete (int *)ListOfDefault[i]->Last();
        ListOfDefault[i]->Remove(ListOfDefault[i]->Last());
      }
    } else {
      while(ListOfDefault[i]->Count<h){
        int *p = new int;
        *p = DEFAULT_YARN_EMIT;
        ListOfDefault[i]->Add(p);
      }
    }
  }

  int width = Main->texlayer->complete_needle;
  int height = Main->maindata.course;
  Tricot *tricot = new Tricot(width, height, 25.4/Main->maindata.gauge, 10.0/Main->maindata.cpc);
  tricot->InitTricot(Main->texlayer, NULL);
  tricot->Optimize(true/*¾ðÁ¦³ª ÃÖÀûÈ­*/, 0/*½ºÆÇ È¿°ú ¾øÀ½*/, NULL);
    //ÈÄ°¡°ø ¾øÀ½//»þ¸µ½Ã¿¡µµ ÃÖÀûÈ­ÇÑ »óÅ·Π°è»ê

  for(int i=0;i<tricot->Width;i++){
    for(int j=0;j<tricot->Height;j++){
      Octopus *octo = tricot->GetOctopus(i,j);
      Octopus *octo2 = tricot->GetOctopus(i,j-1);
      if(octo->used!=true)continue;
      double x = tricot->FindRealPosX(octo,i,j);
      double y = tricot->FindRealPosY(octo,i,j);
      octo->plusX=0;
      octo->plusY=0;
      if(octo2->used!=true)continue;
      double sx = tricot->FindRealPosX(octo2,i,j-1);
      double sy = tricot->FindRealPosY(octo2,i,j-1);
      double rx,ry;
      FindR90VectorDouble(sx,sy,x,y,rx,ry);
      octo->plusX=rx*(0.05+0.2*octo2->head_wideness);
      octo->plusY=ry*(0.05+0.2*octo2->head_wideness);
    }
  }

  for(int j=0;j<tricot->Height;j++){
    for(int l=0;l<4;l++){
      int cnt=0;
      int len=0;
      for(int i=0;i<tricot->Width;i++){
        Octopus *octo = tricot->GetOctopus(i,j);
        if(octo->used!=true)continue;
        int leni = tricot->GetLength(octo, i, j, l, gd.formula[i]);
        if(leni) {
          cnt++;
          len+=leni;
        }
      }
      if(cnt==0) *(int *)ListOfDefault[l]->Items[j]=0;
      else *(int *)ListOfDefault[l]->Items[j]=(len/cnt);
    }
  }

  delete tricot;

  sgCourse->Repaint();

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