//---------------------------------------------------------------------------
#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 link "RzTabs"
#pragma link "RzPanel"
#pragma link "RzButton"
#pragma link "RzEdit"
#pragma link "RzRadChk"
#pragma link "RzLine"
#pragma link "RzCmboBx"
#pragma link "RzRadGrp"
#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]
#define IDS_NO_TENSION        StringTable[23]
#define IDS_SHOW_RUNIN        StringTable[24]
#define IDS_EMIT_RATIO        StringTable[25]
#define IDS_OPTIMIZATION      StringTable[26]
#define IDS_DIRECTINPUT       StringTable[27]
#define IDS_EXCUTE            StringTable[28]
#define IDS_REPEAT            StringTable[29]   // 2018.11.07 Ãß°¡ -han
#define IDS_REPEAT_NUM        StringTable[30]   // 2018.11.14 Ãß°¡ -han

//---------------------------------------------------------------------------
TGuideBar_F *GuideBar_F;
//---------------------------------------------------------------------------
__fastcall TGuideBar_F::TGuideBar_F(TComponent* Owner)
  : TForm(Owner)
{
	osinfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
	GetVersionEx(&osinfo);

  if ((osinfo.dwMajorVersion == 6) && (osinfo.dwMinorVersion >= 0)) {//Vista ÀÌ»ó
    this->Constraints->MaxWidth = 660;
    this->Constraints->MinWidth = 660;
  }
  else {
    this->Constraints->MaxWidth = 650;
    this->Constraints->MinWidth = 650;
  }
  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;

  int a[MAX_LAYER_COUNT] = {0,0,0,0,0,0,0};//ÀåÁø¸¸ ÃÖ¼Ò °ø¹è¼ö ±¸ÇÏ´Â ±¸¹® - °°Àº ±¸¹®ÀÌ ¿©·¯±ºµ¥ ÀÖ´Ù
  for(int j2=0;j2<Main->texlayer->TexList->Count;j2++){
    Tex *tex = ((Tex *)Main->texlayer->TexList->Items[j2]);
    for(int i2=0;i2<tex->Wales->Count;i2++) a[j2]+= ((WaleState *)(tex->Wales->Items[i2]))->cnt;
  }
  int lcn = GetLCN(a[0],a[1],a[2],a[3],a[4],a[5],a[6]);
  rbCompleteNeedle1->Caption=IDS_OPTIMIZATION;
  lbCompleteNeedleCnt->Caption=lcn;
  rbCompleteNeedle2->Caption=IDS_DIRECTINPUT;
  sbViewYarnList->Caption=IDS_YARN_LIST;
  pmAdd->Caption=IDS_ADD;
  pmDelete->Caption=IDS_DELETE;
  pmRepeat->Caption=IDS_REPEAT;
  lbInOutDescription->Caption=IDS_DESCRIPTION;
  sbDefault->Caption=IDS_DEFAULT;
  sbSetDefaultWithOptimization->Caption=IDS_SET_WITH_OPTIMIZE;
  sbSetDefaultWithFormula->Caption=IDS_SET_WITH_FORMULA;
  cbNoTension->Caption=IDS_NO_TENSION;
  cbShowRunin->Caption=IDS_SHOW_RUNIN;


  cbbData->Items->Clear();//gabriel
  cbbData->Items->Add("mm/Rack");
  cbbData->Items->Add(IDS_EMIT_RATIO);
  cbbData->Items->Add(IDS_OVERLAP);
  cbbData->Items->Add(IDS_FORCE);
  cbbData->ItemIndex=0;

  btnRun->Caption = IDS_EXCUTE;

  sgThreading->DoubleBuffered = true;
  sgCourse->DoubleBuffered = true;
}
//---------------------------------------------------------------------------

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];
  if(Main->texlayer->default_complete_needle == true){
    rbCompleteNeedle1->Checked = true;
    edCompleteNeedle->Enabled = false;
  }
  else{
    rbCompleteNeedle2->Checked = true;
    edCompleteNeedle->Enabled = true;
  }

  int a[MAX_LAYER_COUNT] = {0,0,0,0,0,0,0}; //ÀåÁø¸¸ ÃÖ¼Ò °ø¹è¼ö ±¸ÇÏ´Â ±¸¹® - °°Àº ±¸¹®ÀÌ ¿©·¯±ºµ¥ ÀÖ´Ù
  for(int j2=0;j2<Main->texlayer->TexList->Count;j2++){
    Tex *tex = ((Tex *)Main->texlayer->TexList->Items[j2]);
    for(int i2=0;i2<tex->Wales->Count;i2++) a[j2]+= ((WaleState *)(tex->Wales->Items[i2]))->cnt;
  }
  int lcn = GetLCN(a[0],a[1],a[2],a[3],a[4],a[5],a[6]);
  rbCompleteNeedle1->Caption=IDS_OPTIMIZATION;
  lbCompleteNeedleCnt->Caption=IntToStr(lcn);
}
//---------------------------------------------------------------------------
void __fastcall TGuideBar_F::UpdateGuideBar(void){
  UpdateEdit();
  ShowData();
}
//---------------------------------------------------------------------------
void __fastcall TGuideBar_F::FormPaint(TObject *Sender)
{
  Tex *tex = (Tex *)Main->texlayer->TexList->Items[Main->LayerNum];
  if (Main->LayerMode) {//Bar ó¸® ³»¿ë
    int barCount = Main->maindata.bar;
    lblLayer->Caption="GB "+IntToStr(barCount - Main->LayerNum);
    if(!GuideBar_F->Visible)
      cbLayerSelect->ItemIndex = barCount - Main->LayerNum - 1;
  }
  else {
    lblLayer->Caption="Layer "+IntToStr(Main->LayerNum+1);
    if(!GuideBar_F->Visible)
      cbLayerSelect->ItemIndex = Main->LayerNum;
  }

  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();

  sgThreading->Row = tex->Wales->Count+1;
}
//---------------------------------------------------------------------------
void __fastcall TGuideBar_F::FormActivate(TObject *Sender)
{

  if (Main->LayerMode) {
    int barCount = Main->maindata.bar;
    lblLayer->Caption="GB "+IntToStr(barCount - Main->LayerNum);
  } else {
    lblLayer->Caption="Layer "+IntToStr(Main->LayerNum+1);
  }

  cbLayerSelect->ClearItemsValues();
  if(Main->LayerMode){
    for(int i=1; i<=Main->maindata.bar; i++){
      cbLayerSelect->AddItemValue("GB" + IntToStr(i), IntToStr(i));
    }
    cbLayerSelect->ItemIndex = 0;
  }
  else{
    for(int i=1; i<=Main->maindata.bar; i++){
      cbLayerSelect->AddItemValue("Layer" + IntToStr(Main->maindata.bar-i+1), IntToStr(Main->maindata.bar-i+1));
    }
    cbLayerSelect->ItemIndex = Main->maindata.bar-1;
  }
  lblLayer->Left=pnlComm->Width-lblLayer->Width-10;
  ShowData();
  UpdateGuideBar();
  cbLayerSelectChange(NULL);
}
//---------------------------------------------------------------------------
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(false);  //070822
    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] = 60;
  sgThreading->ColWidths[1] = 130;
  sgThreading->ColWidths[2] = 130;
  sgThreading->ColWidths[3] = 130;
  sgThreading->ColWidths[4] = 130;
  sgThreading->FixedCols=2;
  sgCourse->ColCount = 6;
  sgCourse->RowCount = 20;
  sgCourse->DefaultRowHeight = 25;
  sgCourse->ColWidths[0] = 59;
  sgCourse->ColWidths[1] = 120;
  sgCourse->ColWidths[2] = 120;
  sgCourse->ColWidths[3] = 100;
  sgCourse->ColWidths[4] = 90;
  sgCourse->ColWidths[5] = 90;
  sgCourse->FixedCols=1;

  cbLayerSelect->ItemIndex = 0;
  //lblLayer->Left=pnlComm->Width-lblLayer->Width-10;
  ShowData();
  UpdateGuideBar();
}
//---------------------------------------------------------------------------
void __fastcall TGuideBar_F::ShowData(){
  rgFormula->ItemIndex=gd.formula[Main->LayerNum];
  cbNoTension->Checked=gd.NoTension[Main->LayerNum];
  cbShowRunin->Checked=gd.ShowRunin[Main->LayerNum];
}
//---------------------------------------------------------------------------
void __fastcall TGuideBar_F::SetFont(){
  SetSmallFont(Font);
  SetSmallFont(lblLayer->Font);
  SetSmallFont(lbStart->Font);
  SetSmallFont(lbCompleteNeedle->Font);
  SetSmallFont(lbInOutDescription->Font);
  SetSmallFont(Label3->Font);
  SetSmallFont(lbCompleteNeedleCnt->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);
        sgThreading->Canvas->Font->Color = clWhite;
      }
      break;
    }
    case 1:
    {
      if(ARow==0){
        str = IDS_THREADING;
        sgThreading->Canvas->Font->Color = clWhite;
      } else {
        str="";
        if(ARow-1<tex->Wales->Count){
          sgThreading->Canvas->Font->Color = clWhite;
          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 = clWhite;
      } 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 = clWhite;
      } 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 = clWhite;
      } 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 = clWhite;
      } else {
        str="";
        if(ARow-1<tex->Curve->Count){
          sgCourse->Canvas->Font->Color = clWhite;
          str=IntToStr(ARow);
        }
      }
      break;
    }
    case 1:
    {
      if(ARow==0){
        str = "mm/RACK";
        sgCourse->Canvas->Font->Color = clWhite;
      } else {
        if(ARow-1<tex->Curve->Count){
          str=IntToStr(((CourseState2 *)(tex->Courses->Items[ARow-1]))->emit);
        }
      }
      break;
    }
    case 2:
    {
      if(ARow==0){
        str = IDS_DEFAULT;
        sgCourse->Canvas->Font->Color = clWhite;
      } else {
        if(ARow-1<tex->Curve->Count){
          if(tex->Curve->Count!=tex->Courses->Count) str="-";
          else str=IntToStr(((CourseState2 *)tex->Courses->Items[ARow-1])->emit_ref);
        }
      }
      break;
    }
    case 3:
    {
      if(ARow==0){
        str = IDS_EMIT_RATIO;
        sgCourse->Canvas->Font->Color = clWhite;
      } else {
        if(ARow-1<tex->Curve->Count){
          if(tex->Curve->Count!=tex->Courses->Count) str="-";
          else str=IntToStr(((CourseState2 *)tex->Courses->Items[ARow-1])->ratio)+"%";
        }
      }
      break;
    }
    case 4:
    {
      if(ARow==0){
        str = IDS_OVERLAP;
        sgCourse->Canvas->Font->Color = clWhite;
      } else {
        if(ARow-1<tex->Curve->Count){
          if(*(bool *)(tex->Raise->Items[ARow-1])){
            str="O";
          } else {
            str="X";
          }
        }
      }
      break;
    }
    case 5:
    {
      if(ARow==0){
        str = IDS_FORCE;
        sgCourse->Canvas->Font->Color = clWhite;
      } 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)
{
  AnsiString inputData;

  if(edThreadingInput->Focused()) fgEdit=2;
  if(fgEdit == 1){
   inputData = edThreadingCell->Text;
  }
  else{
   inputData = edThreadingInput->Text;
  }

  Tex *tex = (Tex *)Main->texlayer->TexList->Items[Main->LayerNum];
  TexLayer *texlayer = Main->texlayer;
  if(Key==VK_RETURN){
    switch(sgThreading->Col){
      case 0:
        break;
      case 2:
      {
        if(inputData=="")return;
        int i;
        if(i<0)i=0;
        i=StrToInt(inputData);

        int at[MAX_LAYER_COUNT] = {0,0,0,0,0,0,0};//ÀåÁø¸¸ ÃÖ¼Ò °ø¹è¼ö ±¸ÇÏ´Â ±¸¹® - °°Àº ±¸¹®ÀÌ ¿©·¯±ºµ¥ ÀÖ´Ù
        for(int j2=0;j2<Main->texlayer->TexList->Count;j2++){
          Tex *texT = ((Tex *)Main->texlayer->TexList->Items[j2]);
          for(int i2=0;i2<texT->Wales->Count;i2++) at[j2]+= ((WaleState *)(texT->Wales->Items[i2]))->cnt;
        }
        at[Main->LayerNum] += i;
        int lcnT = GetLCN(at[0],at[1],at[2],at[3],at[4],at[5],at[6]);

        if( lcnT >10066325 || lcnT < 0){
          ShowMessage("Data Out Of Bound!");
        }
        else{
          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);
            }
          }
          //sgThreading->Row = sgThreading->Selection.Bottom;
          //sgThreading->Row = tex->Wales->Count+1;
          if( sgThreading->Row == sgThreading->RowCount - 1 ){
            FormPaint(NULL);
          }
          else{
            sgThreading->Row++;
          }
        }
        edThreadingInput->Text="";
        sgThreading->Repaint();
//      DesignForm->DrawChart(false); //070822
        break;
      }
      case 3:
      {
        if(inputData=="")return;
        int i;
        if(i<0)i=0;
        char c=*(char *)(inputData.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();
        sgThreading->Row++;
        break;
//        DesignForm->DrawChart(false); //070822
      }
      case 4:
      {
        if(inputData == "") return;
        bool v = true;
        if(inputData=="0" || inputData == "O" || inputData == "o"){
          v = true;
        }
        else{
          v = false;
        }
        for(int j=sgThreading->Selection.Top; j<=sgThreading->Selection.Bottom; j++){
          if(j-1 < tex->Wales->Count){
            ((WaleState *)(tex->Wales->Items[j-1]))->isTransParent = v;
          }
        }
        edThreadingInput->Text = "";
        sgThreading->Repaint();
        sgThreading->Row++;
        break;
      }
      default:
        break;
    }
    TRect rect = sgThreading->CellRect(sgThreading->Col, sgThreading->Row);
    edThreadingCell->Left = rect.left + sgThreading->Left;
    edThreadingCell->Top = rect.top + sgThreading->Top;
    edThreadingCell->Width = rect.Width();
    edThreadingCell->Height = rect.Height();
    if(fgEdit == 1){
      edThreadingCell->Visible = true;
      edThreadingCell->SetFocus();
    }

    int a[MAX_LAYER_COUNT] = {0,0,0,0,0,0,0};//ÀåÁø¸¸ ÃÖ¼Ò °ø¹è¼ö ±¸ÇÏ´Â ±¸¹® - °°Àº ±¸¹®ÀÌ ¿©·¯±ºµ¥ ÀÖ´Ù
    for(int j2=0;j2<texlayer->TexList->Count;j2++){
      Tex *tex = ((Tex *)texlayer->TexList->Items[j2]);
      for(int i2=0;i2<tex->Wales->Count;i2++) a[j2]+= ((WaleState *)(tex->Wales->Items[i2]))->cnt;
    }
    int lcn = GetLCN(a[0],a[1],a[2],a[3],a[4],a[5],a[6]);
    rbCompleteNeedle1->Caption=IDS_OPTIMIZATION;
    lbCompleteNeedleCnt->Caption=IntToStr(lcn);
  }
  if(YarnCompositionData_F&&YarnCompositionData_F->Visible)YarnCompositionData_F->Repaint();

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

void __fastcall TGuideBar_F::edCourseInputKeyPress(TObject *Sender,
      char &Key)
{
  AnsiString inputData;

  if(edCourseInput->Focused()) fgEdit=2;
  if(fgEdit == 1){
   inputData = edCourseCell->Text;
  }
  else{
   inputData = edCourseInput->Text;
  }

  Tex *tex = (Tex *)Main->texlayer->TexList->Items[Main->LayerNum];

  //gabriel 2006.04.26 <<---------
  if(Key==VK_RETURN){


    if (edCourseStart->Text.Length()>0 && edCourseEnd->Text.Length()>0) {
      int courseStart = StrToInt(edCourseStart->Text);
      int courseEnd = StrToInt(edCourseEnd->Text);
      if (courseStart<0) courseStart=0;
      if (courseEnd<0) courseEnd=0;
      if (courseStart>Main->maindata.course) courseStart=Main->maindata.course;
      if (courseEnd>Main->maindata.course) courseEnd=Main->maindata.course;


        switch(cbbData->ItemIndex) {//2006.04.27
          case 0:
          {
            // case of sgCourse->Col = 1
            if(inputData=="")return;
            int i;
            i=StrToInt(inputData);
            if(i<0)i=0;
            for(int j=courseStart;j<=courseEnd;j++){
              if(j-1<tex->Curve->Count){//Row´Â 1ºÎÅÍ ½ÃÀÛ//Curve´Â 0ºÎÅͽÃÀÛ//Row-1==Curve
                ((CourseState2 *)tex->Courses->Items[j-1])->emit=i;
              }
            }
            edCourseInput->Text="";
            sgCourse->Repaint();
//            DesignForm->DrawChart(false); //070822
            break;
          }
          case 1:
          {
            if(inputData=="")return;
            int i;
            i=StrToInt(inputData);
            if(i<0)i=0;
            for(int j=courseStart;j<=courseEnd;j++){
              if(j-1<tex->Curve->Count){//Row´Â 1ºÎÅÍ ½ÃÀÛ//Curve´Â 0ºÎÅͽÃÀÛ//Row-1==Curve
                ((CourseState2 *)tex->Courses->Items[j-1])->ratio=i;
              }
            }
            edCourseInput->Text="";
            sgCourse->Repaint();
//            DesignForm->DrawChart(false); //070822
            //sgCourse->Row++;
            break;

          }
          case 2:
          {
            if(inputData=="")return;
            bool v=true;
            if(inputData=="0"||inputData=="O"||inputData=="o"){
              v=true;
            } else {
              v=false;
            }
            for(int j=courseStart;j<=courseEnd;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(false); //070822
            //sgCourse->Row++;
            break;
          }
          case 3:
          {
            if(inputData=="")return;
            bool v=true;
            if(inputData=="0"||inputData=="O"||inputData=="o"){
              v=true;
            } else {
              v=false;
            }
            for(int j=courseStart;j<=courseEnd;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(false); //070822
            //sgCourse->Row++;
            break;
          }
        }

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

      edCourseStart->Text="";//clear
      edCourseEnd->Text="";

      return;
    }
  }
  //gabriel 2006.04.26 --------->>


  

  if(Key==VK_RETURN){
    switch(sgCourse->Col){
      case 0:
        break;
      case 1:
      {
        if(inputData=="")return;
        int i;
        i=StrToInt(inputData);
        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
            ((CourseState2 *)tex->Courses->Items[j-1])->emit=i;
          }
        }
        edCourseInput->Text="";
        sgCourse->Repaint();
//        DesignForm->DrawChart(false); //070822
        sgCourse->Row++;
        break;

      }
      case 3:
      {
        if(inputData=="")return;
        int i;
        i=StrToInt(inputData);
        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
            ((CourseState2 *)tex->Courses->Items[j-1])->ratio=i;
          }
        }
        edCourseInput->Text="";
        sgCourse->Repaint();
//        DesignForm->DrawChart(false); //070822
        sgCourse->Row++;
        break;

      }
      case 4:
      {
        if(inputData=="")return;
        bool v=true;
        if(inputData=="0"||inputData=="O"||inputData=="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(false); //070822
        sgCourse->Row++;
        break;
      }
      case 5:
      {
        if(inputData=="")return;
        bool v=true;
        if(inputData=="0"||inputData=="O"||inputData=="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(false); //070822
        sgCourse->Row++;
        break;
      }

      default:
        break;
    }
    TRect rect = sgCourse->CellRect(sgCourse->Col, sgCourse->Row);
    edCourseCell->Left = rect.left + sgCourse->Left;
    edCourseCell->Top = rect.top + sgCourse->Top;
    edCourseCell->Width = rect.Width();
    edCourseCell->Height = rect.Height();
    if(fgEdit == 1){
      edCourseCell->Visible = true;
      edCourseCell->SetFocus();
    }
  }
  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(false); //070822

  int a[MAX_LAYER_COUNT] = {0,0,0,0,0,0,0};//ÀåÁø¸¸ ÃÖ¼Ò °ø¹è¼ö ±¸ÇÏ´Â ±¸¹® - °°Àº ±¸¹®ÀÌ ¿©·¯±ºµ¥ ÀÖ´Ù
  for(int j2=0;j2<Main->texlayer->TexList->Count;j2++){
    Tex *tex = ((Tex *)Main->texlayer->TexList->Items[j2]);
    for(int i2=0;i2<tex->Wales->Count;i2++) a[j2]+= ((WaleState *)(tex->Wales->Items[i2]))->cnt;
  }
  int lcn = GetLCN(a[0],a[1],a[2],a[3],a[4],a[5],a[6]);
  rbCompleteNeedle1->Caption=IDS_OPTIMIZATION;
  lbCompleteNeedleCnt->Caption=IntToStr(lcn);
}
//---------------------------------------------------------------------------

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

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

  int a[MAX_LAYER_COUNT] = {0,0,0,0,0,0,0};//ÀåÁø¸¸ ÃÖ¼Ò °ø¹è¼ö ±¸ÇÏ´Â ±¸¹® - °°Àº ±¸¹®ÀÌ ¿©·¯±ºµ¥ ÀÖ´Ù
  for(int j2=0;j2<Main->texlayer->TexList->Count;j2++){
    Tex *tex = ((Tex *)Main->texlayer->TexList->Items[j2]);
    for(int i2=0;i2<tex->Wales->Count;i2++) a[j2]+= ((WaleState *)(tex->Wales->Items[i2]))->cnt;
  }
  int lcn = GetLCN(a[0],a[1],a[2],a[3],a[4],a[5],a[6]);
  rbCompleteNeedle1->Caption=IDS_OPTIMIZATION;
  lbCompleteNeedleCnt->Caption=IntToStr(lcn);
}
//---------------------------------------------------------------------------

void __fastcall TGuideBar_F::pmRepeatClick(TObject *Sender)
{
  Tex *tex = (Tex *)Main->texlayer->TexList->Items[Main->LayerNum];
  int selectedTopIndex = sgThreading->Selection.Top;
  int selectedBottomIndex = sgThreading->Selection.Bottom;
  int repeatNum;
  int oneRepeatSum = 0;
  AnsiString strRepeatNum;
  AnsiString strIDSRepeatNum;
  strIDSRepeatNum = IDS_REPEAT_NUM;

  strRepeatNum = InputBox("Repeat", strIDSRepeatNum + "\t" ,"");
  repeatNum = strRepeatNum.ToInt();

  for(int idx = selectedTopIndex ; idx <= selectedBottomIndex ; idx++){
    WaleState *ws = (WaleState *)tex->Wales->Items[idx-1];
    oneRepeatSum +=  ws->cnt;
  }
  if(repeatNum > 0){

    int at[MAX_LAYER_COUNT] = {0,0,0,0,0,0,0};//ÀåÁø¸¸ ÃÖ¼Ò °ø¹è¼ö ±¸ÇÏ´Â ±¸¹® - °°Àº ±¸¹®ÀÌ ¿©·¯±ºµ¥ ÀÖ´Ù
    for(int j2=0;j2<Main->texlayer->TexList->Count;j2++){
      Tex *texT = ((Tex *)Main->texlayer->TexList->Items[j2]);
      for(int i2=0;i2<texT->Wales->Count;i2++) at[j2]+= ((WaleState *)(texT->Wales->Items[i2]))->cnt;
    }
    at[Main->LayerNum] += (repeatNum-1)*oneRepeatSum;
    int lcnT = GetLCN(at[0],at[1],at[2],at[3],at[4],at[5],at[6]);
    if( lcnT >10066325 || lcnT < 0){
        ShowMessage("Data Out Of Bound!");
    }

    for(int i = 0 ; i < repeatNum - 1 ; i++){
      for(int j = selectedTopIndex; j <= selectedBottomIndex ; j++){
        if(j-1<0||j-1>=tex->Wales->Count){
          return;
        }
        WaleState *ws = new WaleState;
        WaleState *wsTarget = (WaleState *)tex->Wales->Items[j-1];

        ws->yarnIndex = wsTarget->yarnIndex;
        ws->cnt = wsTarget->cnt;
        ws->in = wsTarget->in;
        ws->isTransParent = wsTarget->isTransParent;
        tex->Wales->Add(ws);

        if( sgThreading->Row == sgThreading->RowCount - 1 ){
          FormPaint(NULL);
        }
        else{
          sgThreading->Row++;
        }


      }
    }

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

    rbCompleteNeedle1->Caption=IDS_OPTIMIZATION;
    lbCompleteNeedleCnt->Caption=IntToStr(lcnT);
  }else{
    ShowMessage("0 ÀÌ»óÀÇ ¹Ýº¹ ¼ö¸¦ Àû¾îÁÖ¼¼¿ä.");
    return;
  }
}
//---------------------------------------------------------------------------

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(false); //070822

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

void __fastcall TGuideBar_F::sbDefaultClick(TObject *Sender)
{
  Tex *tex = (Tex *)Main->texlayer->TexList->Items[Main->LayerNum];
  for(int i=0;i<tex->Courses->Count;i++){
    ((CourseState2 *)tex->Courses->Items[i])->emit=((CourseState2 *)tex->Courses->Items[i])->emit_ref;
  }
  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::pcGuideBarChange(TObject *Sender)
{
  /*
  if(pcGuideBar->ActivePage==tsThreading){
    edThreadingInput->SetFocus();
    this->VertScrollBar->Position = 0;
  } else if(pcGuideBar->ActivePage==tsCourse){
    edCourseInput->SetFocus();
    this->VertScrollBar->Position = 0;
  }
  */
}
//---------------------------------------------------------------------------

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

void __fastcall TGuideBar_F::rgFormulaClick(TObject *Sender)
{
  gd.formula[Main->LayerNum]=rgFormula->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 4:
    {
      if(!Shift.Contains(ssLeft))break;
      if(ARow==0){
        bool exist=false;
        for(int i=0;i<tex->Raise->Count;i++){
          if(*((bool *)tex->Raise->Items[i])){
            exist=true;
            break;
          }
        }
        if(exist){
          for(int i=0;i<tex->Raise->Count;i++){
            *((bool *)tex->Raise->Items[i]) = false;
          }
        } else {
          for(int i=0;i<tex->Curve->Count;i++){
            KO *ko=(KO *)tex->Curve->Items[i];
            if(ko->in==ko->via){
              *((bool *)tex->Raise->Items[i]) = true;
            }
          }
        }
      } else if(ARow!=0&&ARow-1<tex->Raise->Count){
        *((bool *)tex->Raise->Items[ARow-1]) =! *((bool *)tex->Raise->Items[ARow-1]);
      }
      break;
    }
    case 5: 
    {
      if(!Shift.Contains(ssLeft))break;
      if(ARow==0){
        bool exist=false;
        for(int i=0;i<tex->Force->Count;i++){
          if(*((bool *)tex->Force->Items[i])){
            exist=true;
            break;
          }
        }
        if(exist){
          for(int i=0;i<tex->Force->Count;i++){
            *((bool *)tex->Force->Items[i]) = false;
          }
        } else {
          for(int i=0;i<tex->Curve->Count;i++){
            KO *ko=(KO *)tex->Curve->Items[i];
            if(ko->in==ko->via){
              *((bool *)tex->Force->Items[i]) = true;
            }
          }
        }
      } else 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();

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


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

  int h=Main->maindata.course;
  int layer=Main->LayerNum;

  Tex *tex = (Tex *)Main->texlayer->TexList->Items[layer];
  double denier=0,filament=0;
  int cnt=0;
  for(int i=0;i<tex->Wales->Count;i++){
    WaleState *ws=(WaleState *)tex->Wales->Items[i];
    Yarn *yarn=(Yarn *)Main->texlayer->YarnList->Items[ws->yarnIndex];
    if(ws->in){
      cnt++;
      denier+=yarn->denier;
      filament+=yarn->filament;
    }
  }
  if(cnt){
    denier/=cnt;
    filament/=cnt;
  } else {
    denier=DEFAULT_YARN_DENIER;
    filament=DEFAULT_YARN_MULTI;
  }
  for(int j=0;j<h;j++){
    int DefaultLength = tex->DefaultLength(j, denier, filament,
          Main->maindata.cpc, Main->maindata.gauge, gd.formula[layer])*480.0;
     ((CourseState2 *)tex->Courses->Items[j])->emit_ref=DefaultLength;
  }
  sgCourse->Repaint();

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

void __fastcall TGuideBar_F::sbSetDefaultWithOptimizationClick(
      TObject *Sender)
{
  int h=Main->maindata.course;
  int layer=Main->LayerNum;
  Tex *tex = (Tex *)Main->texlayer->TexList->Items[layer];

  int width = Main->texlayer->complete_needle;
    if(Main->texlayer->default_complete_needle == true){   //ÀåÁø¸¸ : ÃÖ¼Ò°ø¹è¼ö¸¦ À§ÇØ
      int a[MAX_LAYER_COUNT] = {0,0,0,0,0,0,0};
      TList *TexList = Main->texlayer->TexList;
      for(int j2=0;j2<TexList->Count;j2++){
        Tex *tex = ((Tex *)TexList->Items[j2]);
        for(int i2=0;i2<tex->Wales->Count;i2++) a[j2]+= ((WaleState *)(tex->Wales->Items[i2]))->cnt;
      }
      width = GetLCN(a[0],a[1],a[2],a[3],a[4],a[5],a[5]);
    }
  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, gd.ShowRunin, NULL);
  tricot->Optimize(true/*¾ðÁ¦³ª ÃÖÀûÈ­*/, 0/*½ºÆÇ È¿°ú ¾øÀ½*/, gd.NoTension, 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++){
    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, layer, gd.formula[layer]);//gabriel
      if(leni) {
        cnt++;
        len+=leni;
      }
    }
    if(cnt==0) ((CourseState2 *)tex->Courses->Items[j])->emit_ref=0;
    else ((CourseState2 *)tex->Courses->Items[j])->emit_ref=(len/cnt);
  }

  delete tricot;

  //under lapÀº default·êÀ» µû¸£ÀÚ
  double denier=0,filament=0;
  int cnt=0;
  for(int i=0;i<tex->Wales->Count;i++){
    WaleState *ws=(WaleState *)tex->Wales->Items[i];
    Yarn *yarn=(Yarn *)Main->texlayer->YarnList->Items[ws->yarnIndex];
    if(ws->in){
      cnt++;
      denier+=yarn->denier;
      filament+=yarn->filament;
    }
  }
  if(cnt){
    denier/=cnt;
    filament/=cnt;
  } else {
    denier=DEFAULT_YARN_DENIER;
    filament=DEFAULT_YARN_MULTI;
  }
  for(int j=0;j<h;j++){
    KO *ko2 = (KO *)tex->Curve->Items[(j+1)%tex->Curve->Count];
    KO *ko = (KO *)tex->Curve->Items[j];
    if(ko->in==ko->via||ko2->in==ko2->via) {
    int DefaultLength = tex->DefaultLength(j, denier, filament,
          Main->maindata.cpc, Main->maindata.gauge, gd.formula[layer])*480.0;
     ((CourseState2 *)tex->Courses->Items[j])->emit_ref=DefaultLength;
    }
  }

  sgCourse->Repaint();

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

void __fastcall TGuideBar_F::FormResize(TObject *Sender)
{
  //Width=648;
  //if(Height<638)Height=638;

  //# sjpark - form size fix
  /*
  int tHeight = 638;
  if ((osinfo.dwMajorVersion == 6) && (osinfo.dwMinorVersion >= 0)) {//Vista ÀÌ»ó
    tHeight = 650;
  }
  pcGuideBar->Height=607+Height-tHeight;
  CoursePanel->Height=330+Height-tHeight;
  sgCourse->Height=255+Height-tHeight;
  pnLength->Top=376+Height-tHeight;
  WalePanel->Height=527+Height-tHeight;
  sgThreading->Height=415+Height-tHeight;
  lbInOutDescription->Top=496+Height-tHeight;
  edInOutDescription->Top=496+Height-tHeight;
  */
}
//---------------------------------------------------------------------------

void __fastcall TGuideBar_F::sgCourseMouseMove(TObject *Sender,
      TShiftState Shift, int X, int Y)
{
  int ACol,ARow;
  sgCourse->MouseToCell(X, Y, ACol, ARow);
  Tex *tex = (Tex *)Main->texlayer->TexList->Items[Main->LayerNum];
  switch(ACol){
    case 1:
    {
      int len=0;
      for(int i=0;i<tex->Courses->Count;i++){
        len+=((CourseState2 *)tex->Courses->Items[i])->emit;
      }
      if(tex->Courses->Count){
        len/=tex->Courses->Count;
      }
      sgCourse->Hint=len;
      break;
    }
    case 2:
    {
      int len=0;
      for(int i=0;i<tex->Courses->Count;i++){
        len+=((CourseState2 *)tex->Courses->Items[i])->emit_ref;
      }
      if(tex->Courses->Count){
        len/=tex->Courses->Count;
      }
      sgCourse->Hint=len;
      break;
    }
    default:
      sgCourse->Hint="";
      break;
  }
}
//---------------------------------------------------------------------------

void __fastcall TGuideBar_F::cbNoTensionClick(TObject *Sender)
{
  gd.NoTension[Main->LayerNum]=cbNoTension->Checked;
}
//---------------------------------------------------------------------------

void __fastcall TGuideBar_F::cbShowRuninClick(TObject *Sender)
{
  gd.ShowRunin[Main->LayerNum]=cbShowRunin->Checked;
}
//---------------------------------------------------------------------------

void __fastcall TGuideBar_F::rbCompleteNeedle1Click(TObject *Sender)
{
  Main->texlayer->default_complete_needle = true;
  edCompleteNeedle->Enabled = false;
}
//---------------------------------------------------------------------------

void __fastcall TGuideBar_F::rbCompleteNeedle2Click(TObject *Sender)
{
  Main->texlayer->default_complete_needle = false;
  edCompleteNeedle->Enabled = true;
}
//---------------------------------------------------------------------------

void __fastcall TGuideBar_F::btnRunClick(TObject *Sender)
{
  TCursor cursor;
  cursor = Screen->Cursor;
  Screen->Cursor = crHourGlass;
  DesignForm->DrawChart(false);  //070822
  Screen->Cursor = cursor;
}
//---------------------------------------------------------------------------

  


void __fastcall TGuideBar_F::sgThreadingDblClick(TObject *Sender)
{
   if((col == 2 || col == 3)&&row!=0){
      fgEdit = 1;
      TRect a = sgThreading->CellRect(col,row);
      edThreadingCell->Left = a.left + sgThreading->Left;
      edThreadingCell->Top = a.top + sgThreading->Top;
      edThreadingCell->Width = a.Width();
      edThreadingCell->Height = a.Height();
      edThreadingCell->Text = "";
      edThreadingCell->Visible = true;
      edThreadingCell->SetFocus();
   }
}
//---------------------------------------------------------------------------
void __fastcall TGuideBar_F::sgCourseDblClick(TObject *Sender)
{
   if((col == 1 || col == 3)&&row!=0){
      fgEdit = 1;
      TRect a = sgCourse->CellRect(col,row);
      edCourseCell->Left = a.left + sgCourse->Left;
      edCourseCell->Top = a.top + sgCourse->Top;
      edCourseCell->Width = a.Width();
      edCourseCell->Height = a.Height();
      edCourseCell->Text = "";
      edCourseCell->Visible = true;
      edCourseCell->SetFocus();
   }
}
//---------------------------------------------------------------------------


void __fastcall TGuideBar_F::edThreadingCellExit(TObject *Sender)
{
  edThreadingCell->Visible = false;
}
//---------------------------------------------------------------------------



void __fastcall TGuideBar_F::edCourseCellExit(TObject *Sender)
{
  edCourseCell->Visible = false;  
}
//---------------------------------------------------------------------------



void __fastcall TGuideBar_F::cbLayerSelectChange(TObject *Sender)
{
  int layerNum = StrToInt(cbLayerSelect->Value);
  switch(layerNum){
    case 1:
      if(Main->LayerMode) Main->cbB1Click(NULL);
      else Main->sbL1Click(NULL);
      break;
    case 2:
      if(Main->LayerMode) Main->cbB2Click(NULL);
      else Main->sbL2Click(NULL);
      break;
    case 3:
      if(Main->LayerMode) Main->cbB3Click(NULL);
      else Main->sbL3Click(NULL);
      break;
    case 4:
      if(Main->LayerMode) Main->cbB4Click(NULL);
      else Main->sbL4Click(NULL);
      break;
    case 5:
      if(Main->LayerMode) Main->cbB5Click(NULL);
      else Main->sbL5Click(NULL);
      break;
    case 6:
      if(Main->LayerMode) Main->cbB6Click(NULL);
      else Main->sbL6Click(NULL);
      break;
    case 7:
      if(Main->LayerMode) Main->cbB7Click(NULL);
      else Main->sbL7Click(NULL);
      break;
    default:
      break;
  }
}
//---------------------------------------------------------------------------