//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

#include "Kasuri_F.h"
#include "Main.h"
#include "PenManager.h"
#include "Palette.h"
#include "Rotation.h"
#include "MainMenu.h"
#include "LogData.h"
//---------------------------------------------------------------------------
#define IDS_POINT           StringTable[0]
#define IDS_BRANCH          StringTable[1]
#define IDS_TWIGS           StringTable[2]
#define IDS_DISTANCE        StringTable[3]
#define IDS_APPLYPEN        StringTable[4]
#define IDS_CRAYON          StringTable[5]
#define IDS_DENSITY         StringTable[6]
#define IDS_OK              StringTable[7]
#define IDS_CANCEL          StringTable[8]
#define IDS_Option          StringTable[9]
#define IDS_Caption         StringTable[10]

//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma link "TPStretchImage"
#pragma link "RzButton"
#pragma link "RzRadChk"
#pragma link "RzEdit"
#pragma link "RzSpnEdt"
#pragma link "RzPanel"
#pragma link "RzTrkBar"
#pragma link "RzButton"
#pragma link "TNumEdit"
#pragma link "RzBckgnd"
#pragma resource "*.dfm"

TKasuriForm *KasuriForm;
//---------------------------------------------------------------------------
__fastcall TKasuriForm::TKasuriForm(TComponent* Owner)
  : TForm(Owner)
{
  BEGIN_LOG("");

	StringTable.Create(DirectoryItem, Language, "Kasuri");

	SetSmallFont(Font);

  Caption                 = IDS_Caption;
  lbPointCount->Caption   = IDS_POINT;
  lbBranchCount->Caption  = IDS_BRANCH;
  lbTwigCount->Caption    = IDS_TWIGS;
  lbDistance->Caption     = IDS_DISTANCE;
  rzbtApplyPen->Caption   = IDS_APPLYPEN;
  rzcbCrayon->Caption     = IDS_CRAYON;
  lbDensity->Caption      = IDS_DENSITY;
  rzbtOK->Caption         = IDS_OK;
  rzbtCancel->Caption     = IDS_CANCEL;
  RzGroupBox1->Caption    = IDS_Option;

  MImageForm = MainImageForm;

  sbPreview->Down = false;

  //060914
  MImageForm->iMainImage->OnPaintLowerVector = PaintLowerVector;
  MImageForm->iMainImage->OnPaintUpperVector = PaintUpperVector;

  oldCursor = MImageForm->iMainImage->Cursor;
  MImageForm->iMainImage->Cursor = crDefault;

  crayonPenBitmap = NULL;

  if(KasuriSubForm) {
    delete KasuriSubForm;
    KasuriSubForm = NULL;
  }
	KasuriSubForm = new TKasuriSubForm(MainForm);   //060914 shin kasuri
	KasuriSubForm->Parent = MainForm;
  KasuriSubForm->Visible = false;
  KasuriSubForm->Left = PenManagerForm->Left - KasuriSubForm->Width;
  KasuriSubForm->Top = this->Top + 60;//+KasuriSubForm->Height ;

  END_LOG;
}
//---------------------------------------------------------------------------
__fastcall TKasuriForm::~TKasuriForm()
{
  BEGIN_LOG("");

  ExitForm();

  END_LOG;
}
//---------------------------------------------------------------------------
void __fastcall TKasuriForm::InitForm(int point, int branch)  //shin 061024
{
  BEGIN_LOG("");

  UpdateMenuItems(false);
  hasKasuri = false;
  selectPenPoint = false;
  selectPenPointNum = 0;

  kasuri = NULL;
  IsNormalPen = true; //shin 061024 À§·Î ¿Ã¸²
  InitPenPoints();
  SetCount(point, branch, 6); //shin 061024
  rzsePointCount->Value = point;     //shin 061024
  rzseBranchCount->Value = branch;   //shin 061024
  OptionEnabled(false);

  nDensity = 1;
  bendDistance = 2;
  tbrCrayon->Position = 0;
  //DrawCreyonToPaintBox();
  CrayonOptionEnabled(false);
  DrawPen();
  IsPenShapeChange = false;

  MImageForm->iMainImage->Cursor = crDefault;
	if (PenManagerForm)PenManagerForm->rzcbPressure->Enabled = false;

  END_LOG;
}
//---------------------------------------------------------------------------
void __fastcall TKasuriForm::ExitForm()
{
  BEGIN_LOG("");

	PenManagerForm->kasuriPointCount = pointCount;    //shin 061024
  PenManagerForm->kasuriBranchCount = branchCount;  //shin 061024

  if (hasKasuri){
    delete kasuri;
    kasuri = NULL;
    hasKasuri = false;
  }
    //060914
  if (MainForm->MDIChildCount > 0){
    if (MImageForm && MImageForm->iMainImage){
      MImageForm->iMainImage->OnPaintLowerVector = NULL;
      MImageForm->iMainImage->OnPaintUpperVector = NULL;
      MImageForm->iMainImage->Cursor = oldCursor;
      MImageForm->iMainImage->Repaint();
    }
  }
  if (PenManagerForm){
    //PenManagerForm->Type = PT_NORMAL;
    PenManagerForm->rzcbPressure->Enabled = true;
  }

  if (crayonPenBitmap) delete crayonPenBitmap;
  crayonPenBitmap = NULL;

  UpdateMenuItems(true);

  END_LOG;
}
//---------------------------------------------------------------------------
void __fastcall TKasuriForm::SetCount(int nPointCount, int nBranchCount, int nTwigCount)
{
  BEGIN_LOG("");

  pointCount = nPointCount;
  branchCount = nBranchCount;
  twigCount = nTwigCount;
  AllBranchCount = branchCount + twigCount*(branchCount-1);
  nowCount = 0;

  if (kasuri){
    delete kasuri;
    kasuri = NULL;
  }
  kasuri = new TKasuri;
  kasuri->PointCount = pointCount;
  kasuri->BranchCount = branchCount;
  kasuri->TwigCount = twigCount;
  kasuri->AllBranchCount = AllBranchCount;
  hasKasuri = true;
  bEdit = true;
  SetPenPoints();
  SetPenColor();

  //chun
  bPathDrawingMode = true;
  bPathDrawMovingMode = false;
  bPathDrawEnd = false;

  if (PathPointList){
    while(PathPointList->Count > 0){
      TPoint *point = (TPoint *)PathPointList->Last();
      PathPointList->Remove(point);
      delete point;
    }
  } else {
    PathPointList = new TList;
  }

  END_LOG;
}
//---------------------------------------------------------------------------
bool __fastcall TKasuriForm::isPointEnd()
{
  if (nowCount == branchCount*pointCount) return true;
  else return false;
}
//---------------------------------------------------------------------------
void __fastcall TKasuriForm::AddPoints()
{
  BEGIN_LOG("");

  int pCount = CurvePoint->Count;
  while(CurvePoint->Count > 0){
    TPoint *point = (TPoint *)CurvePoint->First();
    CurvePoint->Remove(point);
    kasuri->KPointList->Add(point);
  }
  delete CurvePoint;

  nowCount += pCount;
  if (nowCount == pointCount*branchCount){
    ChangeKasuriPoints(true);

    if (branchCount > 1){
      int maxtwigs = kasuri->CalMaxTwigs();

      tbrTwigs->Max = maxtwigs;

      if (maxtwigs < twigCount){
        tbrTwigs->Position = tbrTwigs->Max;
        edTwigCount->Text = IntToStr(tbrTwigs->Position);
      }
      else {
        tbrTwigs->Position = twigCount;
      }
    }
  }

  END_LOG;
}
//---------------------------------------------------------------------------


bool __fastcall TKasuriForm::CheckCount()
{
  if (pointCount >=3 && branchCount >= 1 && twigCount > 0){
    return true;
  } else return false;
}
//---------------------------------------------------------------------------
void __fastcall TKasuriForm::FindPoint(int nX, int nY)
{
  BEGIN_LOG("");

  TPoint *point;
  if (isPointEnd()){
	  for(int i = 0; i < kasuri->KPointList->Count; i++)
	  {
	    point = (TPoint *)kasuri->KPointList->Items[i];
	    if((point->x - 3 <= nX && nX <= point->x + 3) && (point->y - 3 <= nY && nY <= point->y + 3))
	    {
	      bKasuriEditMode = true;
	      nMovePointIndex = i;
	      break;
	    } else {
	      bKasuriEditMode = false;
	    }
	  }
	 }

  END_LOG;
}
//---------------------------------------------------------------------------
void __fastcall TKasuriForm::PaintLowerVector(HDC dcDst, int px, int py, int vw, int vh)
{
  BEGIN_LOG("");

  if (hasKasuri && isPointEnd()){
    //CheckPen();
    if (!IsNormalPen){
      if (kasuri->IsNormalPen){
        MakeCrayonBitmap();
        kasuri->IsNormalPen = false;
      }
    }
    kasuri->DrawKasuri(dcDst,
      MImageForm->iMainImage->ZoomIn,
      MImageForm->iMainImage->ZoomOut,
      MImageForm->sbHorz->Position,
      MImageForm->sbVert->Position,
      px, py, MImageForm->iMainImage->uBitmap->BitsPerPixel);
    //kasuri->DrawTest(dcDst);  // spline¾È¿¡¼­ÀÇ Á¡ÀÇ À§Ä¡
  }

  END_LOG;
}
//---------------------------------------------------------------------------
void __fastcall TKasuriForm::PaintUpperVector(HDC dcDst, int px, int py, int vw, int vh)
{
  BEGIN_LOG("");

  if (hasKasuri){
    if (bEdit){
      kasuri->DrawEditLine(dcDst,
        MImageForm->iMainImage->ZoomIn,
        MImageForm->iMainImage->ZoomOut,
        MImageForm->sbHorz->Position,
        MImageForm->sbVert->Position,
        px, py);
    }
  }

  END_LOG;
}
//---------------------------------------------------------------------------
void __fastcall TKasuriForm::MovePoint(int moveX, int moveY, bool bUp)
{
  BEGIN_LOG("");

  if (hasKasuri){
    TPoint *point;
    point = (TPoint *)kasuri->KPointList->Items[nMovePointIndex];
    point->x = moveX;
    point->y = moveY;

    //ChangeKasuriPoints(bUp);
    MoveKasuriPoint(nMovePointIndex, bUp);
    if (bUp){
      kasuri->bMove = false;
    }
  }

  END_LOG;
}
//---------------------------------------------------------------------------
void __fastcall TKasuriForm::edTwigCountMouseDown(TObject *Sender,
      TMouseButton Button, TShiftState Shift, int X, int Y)
{
  edTwigCount->SetFocus();
}
//---------------------------------------------------------------------------
void __fastcall TKasuriForm::DrawPen()
{
  BEGIN_LOG("");

  if (penImage->Bitmap->Width == 0 || penImage->Bitmap->Height == 0){
    penImage->Bitmap->Create(penImage->Width, penImage->Height, 24);
  }
  penImage->Bitmap->FillRect(Rect(0, 0, penImage->Width, penImage->Height), clWhite);

  HDC penDC = penImage->Bitmap->CreateDC();
  gdp::Graphics graphics(penDC);
  gdp::Point pPoints[10], pPoints2[10];
  gdp::Color penColor(0, 0, 0);
  gdp::Color penColorRed(255, 0, 0);
  gdp::Pen pen(penColor, 1);
  gdp::Pen penRed(penColorRed, 1);

  gdp::SolidBrush penBrush(penColor);
  gdp::GraphicsPath penPath;
  penPath.SetFillMode(gdp::FillModeWinding);

  if (IsNormalPen){
    for (int i = 0; i < 4; i++){
      pPoints[i].X = penPoints[i].x;
      pPoints[i].Y = penPoints[i].y;
      if (i == 0){
        pPoints2[3].X = pPoints[0].X;
        pPoints2[3].Y = pPoints[0].Y;
      } else {
        pPoints2[3-i].X = pPoints[i].X;
        pPoints2[3-i].Y = pPoints2[3].Y + (pPoints2[3].Y - pPoints[i].Y);
      }
    }

    penPath.AddCurve(pPoints, 4);
    penPath.AddCurve(pPoints2, 4);
    graphics.DrawPath(&pen, &penPath);

   } else {
    TTexpiaBitmap *maskBitmap = NULL;
    maskBitmap = new TTexpiaBitmap;
    maskBitmap->Create(penImage->Bitmap->Width, penImage->Bitmap->Height, 24);
    maskBitmap->FillRect(Rect(0, 0, penImage->Width, penImage->Height), clWhite);

    HDC maskDC = maskBitmap->CreateDC();

    gdp::Graphics graphics_mask(maskDC);

    for (int i = 0; i < 4; i++){
      pPoints[i].X = penPoints[i].x;
      pPoints[i].Y = penPoints[i].y;
      if (i == 0){
        pPoints2[3].X = pPoints[0].X;
        pPoints2[3].Y = pPoints[0].Y;
      } else {
        pPoints2[3-i].X = pPoints[i].X;
        pPoints2[3-i].Y = pPoints2[3].Y + (pPoints2[3].Y - pPoints[i].Y);
      }
    }

    penPath.AddCurve(pPoints, 4);
    penPath.AddCurve(pPoints2, 4);
    graphics_mask.FillPath(&penBrush, &penPath);
    maskBitmap->DeleteDC(maskDC);

    Byte *msk, *cyn;
    maskBitmap->StartScanLine();
    crayonPenBitmap->StartScanLine();
    for (int h = 0; h < maskBitmap->Height; h++){
      msk = maskBitmap->GetScanLine(h);
      cyn = crayonPenBitmap->GetScanLine(h);
      for (int w = 0; w < maskBitmap->Width*3; w+=3){
        if ((msk[w]!= 255) || (msk[w+1]!= 255) || (msk[w+2]!= 255)){
          msk[w] = cyn[w];
          msk[w+1] = cyn[w+1];
          msk[w+2] = cyn[w+2];
        }
      }
      maskBitmap->PutScanLine(h);
    }
    maskBitmap->StopScanLine();
    crayonPenBitmap->StopScanLine();

    penImage->Bitmap->Copy(maskBitmap, SRCCOPY);
    graphics.DrawPath(&pen, &penPath);
    if (maskBitmap) delete maskBitmap;

  }

  for (int i = 0; i < 4; i++){
    if (selectPenPointNum == 0 || selectPenPointNum != i){
      graphics.DrawRectangle(&pen, pPoints[i].X - 3, pPoints[i].Y - 3, 6, 6);
    } else {
      graphics.DrawRectangle(&penRed, pPoints[i].X - 3, pPoints[i].Y - 3, 6, 6);
    }
  }

  penImage->Bitmap->DeleteDC(penDC);
  penImage->Repaint();

  END_LOG;
}
//---------------------------------------------------------------------------
void __fastcall TKasuriForm::InitPenPoints()
{
  if (penPoints){
    delete[] penPoints;
  }
  penPoints = new TPoint[4];
  penPoints[0].x = 0;
  penPoints[0].y = penImage->Height/2;
  penPoints[1].x = penImage->Width/2;
  penPoints[1].y = penImage->Height/5 ;
  penPoints[2].x = penImage->Width*9/10;
  penPoints[2].y = 0;
  penPoints[3].x = penImage->Width;
  penPoints[3].y = penImage->Height/2;
}
//---------------------------------------------------------------------------
void __fastcall TKasuriForm::penImageMouseMove(TObject *Sender,
      TShiftState Shift, int X, int Y)
{
  BEGIN_LOG("");

  if (X > 0 && X < KasuriSubForm->penImage->Width && Y > 0 && Y < KasuriSubForm->penImage->Height/2){
    if (selectPenPoint && selectPenPointNum != 0 && selectPenPointNum != 3){
      if (selectPenPointNum == 2 && X > penImage->Width - penImage->Width*0.1){
        penPoints[selectPenPointNum].x = penImage->Width - penImage->Width*0.1;
      } else if (selectPenPointNum == 1 && X < penImage->Width*0.1){
        penPoints[selectPenPointNum].x = penImage->Width*0.1;
      } else {
        penPoints[selectPenPointNum].x = X;
      }
      penPoints[selectPenPointNum].y = Y;
      penImage->Repaint();
      DrawPen();
    }
  }

  END_LOG;
}
//---------------------------------------------------------------------------

void __fastcall TKasuriForm::penImageMouseDown(TObject *Sender,
      TMouseButton Button, TShiftState Shift, int X, int Y)
{
  BEGIN_LOG("");

  for (int i = 1; i < 4; i++){
    if (penPoints[i].x > X - 3 && penPoints[i].x < X + 3
    && penPoints[i].y > Y - 3 && penPoints[i].y < Y + 3){
      selectPenPointNum = i;
      selectPenPoint = true;
      penImage->Repaint();
      DrawPen();
      break;
    }
  }

  END_LOG;
}
//---------------------------------------------------------------------------

void __fastcall TKasuriForm::penImageMouseUp(TObject *Sender,
      TMouseButton Button, TShiftState Shift, int X, int Y)
{
  BEGIN_LOG("");

  if (selectPenPoint && selectPenPointNum != 0 && selectPenPointNum != 3){
    if (X > 0 && X < penImage->Width && Y > 0 && Y < penImage->Height/2){
      if (selectPenPointNum == 2 && X > penImage->Width - penImage->Width*0.1){
        penPoints[selectPenPointNum].x = penImage->Width - penImage->Width*0.1;
      } else if (selectPenPointNum == 1 && X < penImage->Width*0.1){
        penPoints[selectPenPointNum].x = penImage->Width*0.1;
      } else {
        penPoints[selectPenPointNum].x = X;
      }
      penPoints[selectPenPointNum].y = Y;
      penImage->Repaint();
    }
    selectPenPoint = false;
    selectPenPointNum = 0;
    DrawPen();
    IsPenShapeChange = true;
  }

  END_LOG;
}
//---------------------------------------------------------------------------
void __fastcall TKasuriForm::edTwigCountKeyDown(TObject *Sender, WORD &Key,
      TShiftState Shift)
{
  BEGIN_LOG("");

  if (Key == VK_RETURN){
    if (edTwigCount->Value > 0)
    {
      int nTwig = edTwigCount->Value;
      if (CheckCount()){
        if (hasKasuri && isPointEnd()){
          if (nTwig > tbrTwigs->Max){
            tbrTwigs->Position = tbrTwigs->Max;
          } else {
            tbrTwigs->Position = nTwig;
          }
          TwigsChange();
        }
      }
      rzbtOK->SetFocus();
    }
    edTwigCount->Value = tbrTwigs->Position;
  }

  END_LOG;
}
//---------------------------------------------------------------------------
void __fastcall TKasuriForm::SetPenPoints()
{
  BEGIN_LOG("");

  if (hasKasuri){
    penThick = PenManagerForm->Pen->Thick;
    kasuri->SetPenPoints(penPoints, 4, penThick);
  }

  END_LOG;
}
//---------------------------------------------------------------------------

void __fastcall TKasuriForm::PathDrawMouseDownSet(int X,int Y, int xPoz, int yPoz,
  int zoomIn, int zoomOut)   //by bomchun(06.08.12)
{
  TPoint *tempPoint;
  tempPoint = new TPoint;
  tempPoint->x = X;
  tempPoint->y = Y;
  PathPointList->Add(tempPoint);

  bPathDrawMovingMode = true;
  //bPathDrawEnd = false;

  MoveToEx(MImageForm->iMainImage->Canvas->Handle,
          (X - xPoz)*zoomIn/zoomOut,
          (Y - yPoz)*zoomIn/zoomOut, NULL);
}
//---------------------------------------------------------------------------
void __fastcall TKasuriForm::PathDrawMouseMoveSet(int X,int Y, int xPoz, int yPoz,
  int zoomIn, int zoomOut)   //by bomchun(06.08.12)
{
  TPoint *tempPoint;
  tempPoint = new TPoint;
  tempPoint->x = X;
  tempPoint->y = Y;
  PathPointList->Add(tempPoint);

  //LineTo(MImageForm->iMainImage->Canvas->Handle,X,Y);
  //MoveToEx(MImageForm->iMainImage->Canvas->Handle,X,Y,NULL);

  LineTo(MImageForm->iMainImage->Canvas->Handle,
      (X - xPoz)*zoomIn/zoomOut,
      (Y - yPoz)*zoomIn/zoomOut);
  MoveToEx(MImageForm->iMainImage->Canvas->Handle,
      (X - xPoz)*zoomIn/zoomOut,
      (Y - yPoz)*zoomIn/zoomOut, NULL);

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

void __fastcall TKasuriForm::PathDrawMouseUpSet(int X,int Y, int xPoz, int yPoz,
  int zoomIn, int zoomOut)
{
  BEGIN_LOG("");

  TPoint *tempPoint;
  tempPoint = new TPoint;
  tempPoint->x = X;
  tempPoint->y = Y;
  PathPointList->Add(tempPoint);

  bool cal = KasuriPathPointCalculate(pointCount-2);
  if (cal){
    LineTo(MImageForm->iMainImage->Canvas->Handle,
        (X - xPoz)*zoomIn/zoomOut,
        (Y - yPoz)*zoomIn/zoomOut);

    AddPoints();

    bPathDrawingMode = true;
    bPathDrawMovingMode = false;

    if (isPointEnd()){
      bPathDrawEnd = true;
      bPathDrawingMode = false;
      if (branchCount > 1) OptionEnabled(true);
    } else {
      bPathDrawEnd = false;
      OptionEnabled(false);
    }
  } else {
    bPathDrawingMode = true;
    bPathDrawMovingMode = false;
    bPathDrawEnd = false;
  }

  END_LOG;
}
//---------------------------------------------------------------------------
bool __fastcall TKasuriForm::KasuriPathPointCalculate(int nPointCount)   //by bomchun kasuro path drawing point get (06.08.12)
{
  BEGIN_LOG("");

    //±×¸° °î¼±ÀÇ ±æÀÌ¿¡ µû¶ó Æ÷ÀÎÆ® °³¼ö´ë·Î ³ª´®
  int nDistance = 0;
  int nTempDistance =0;
  int nBeforeTemp,nNowTemp;
  TPoint *TempPoint, *TempPoint1, *TempPoint2;
  TPoint *CorrectPoint;
  TPoint *pBeforePoint = new TPoint;
  TPoint *pNowPoint = new TPoint;

  if (PathPointList->Count < 10){
    while(PathPointList->Count > 0){
      TPoint *point = (TPoint *)PathPointList->Last();
      PathPointList->Remove(point);
      delete point;
    }
    if (pBeforePoint) delete pBeforePoint;
    if (pNowPoint) delete pNowPoint;
    END_LOG;
    return false;
  }

  CurvePoint = new TList;

  TempPoint1 = (TPoint *)PathPointList->Items[0];
  TPoint *first = new TPoint;
  first->x = TempPoint1->x;
  first->y = TempPoint1->y;
  CurvePoint->Add(first);  //¸Ç ù Á¡À» ³Ö¾îÁØ´Ù

  TempPoint2 = (TPoint *)PathPointList->Items[1];
  pNowPoint->x = TempPoint2->x;
  pNowPoint->y = TempPoint2->y;

  for(int i = 2; i < PathPointList->Count - 1; i++)
  {
    TempPoint = (TPoint *)PathPointList->Items[i];
    pBeforePoint->x = pNowPoint->x;
    pBeforePoint->y = pNowPoint->y;
    pNowPoint->x = TempPoint->x;
    pNowPoint->y = TempPoint->y;
    nDistance += sqrt((pNowPoint->x - pBeforePoint->x) * (pNowPoint->x - pBeforePoint->x) + (pNowPoint->y - pBeforePoint->y) * (pNowPoint->y - pBeforePoint->y));
  }

  for(int k = 0; k < nPointCount; k++ )
  {
    CorrectPoint = new TPoint;
    nTempDistance = 0;
    TempPoint = (TPoint *)PathPointList->Items[1];
    pNowPoint->x = TempPoint->x;
    pNowPoint->y = TempPoint->y;

    nNowTemp = ((k+1) * (nDistance/(nPointCount+1)));

    for(int i = 2; i < PathPointList->Count - 1; i++)
    {
      TempPoint = (TPoint *)PathPointList->Items[i];
      pBeforePoint->x = pNowPoint->x;
      pBeforePoint->y = pNowPoint->y;
      pNowPoint->x = TempPoint->x;
      pNowPoint->y = TempPoint->y;
      nTempDistance += sqrt((pNowPoint->x - pBeforePoint->x) * (pNowPoint->x - pBeforePoint->x) + (pNowPoint->y - pBeforePoint->y) * (pNowPoint->y - pBeforePoint->y));
      nBeforeTemp = nNowTemp;
      nNowTemp = abs(((k+1) * (nDistance/(nPointCount+1))) - nTempDistance);
      if(nNowTemp < nBeforeTemp)
      {
        CorrectPoint->x = pNowPoint->x;
        CorrectPoint->y = pNowPoint->y;
      }
    }
    CurvePoint->Add(CorrectPoint);
  }

  TempPoint = (TPoint *)PathPointList->Items[PathPointList->Count - 1];
  TPoint *last = new TPoint;
  last->x = TempPoint->x;
  last->y = TempPoint->y;
  CurvePoint->Add(last);  //¸Ç ¸¶Áö¸· Á¡À» ³Ö¾îÁØ´Ù


  while(PathPointList->Count > 0){
    TPoint *point = (TPoint *)PathPointList->Last();
    PathPointList->Remove(point);
    delete point;
  }

  if (pBeforePoint) delete pBeforePoint;
  if (pNowPoint) delete pNowPoint;

  END_LOG;
  return true;
}

//----------------------------------------------------------------------------
void __fastcall TKasuriForm::tbrCrayonChange(TObject *Sender)
{
  BEGIN_LOG("");

	if (BarPosition != tbrCrayon->Position){      //shin 061024

	  BarPosition = tbrCrayon->Position;
	
	  if (!IsNormalPen){
	    MakeCrayonBitmap();
	    ChangeCrayonPen();
	  }
	
	  //DrawCreyonToPaintBox();
	  MImageForm->iMainImage->Repaint();
  }

  END_LOG;
}
//---------------------------------------------------------------------------

bool __fastcall TKasuriForm::MakeRandom(int nXpos, int nRandArange)
{
  Randomize();   //by bomchun ¼öÁ¤µÇ¾úÀ½ (06.08.17)  nRandArange,nXpos
  int temp;
  temp = random(nRandArange);
  //if(nXpos + n <= 0) n = 1 - nXpos;
  if(temp <= nXpos)
  {
    return true;
  }
  else
  {
    return false;
  }
}
//---------------------------------------------------------------------------

void __fastcall TKasuriForm::rzseDensityChange(TObject *Sender)
{
  BEGIN_LOG("");

  int nText = rzseDensity->Value;
  if (nText > rzseDensity->Max){
    nDensity = rzseDensity->Max;
  } else {
    nDensity = nText;
  }
  if (!IsNormalPen){
    MakeCrayonBitmap();
    ChangeCrayonPen();
  }
  MImageForm->iMainImage->Repaint();
  rzbtOK->SetFocus();

  KasuriSubForm->rzseDensity->OnChange = NULL;
  KasuriSubForm->rzseDensity->Value = rzseDensity->Value;
  KasuriSubForm->rzseDensity->OnChange = KasuriSubForm->rzseDensityChange;

  END_LOG;
}
//---------------------------------------------------------------------------

void __fastcall TKasuriForm::sbApplyPenClick(TObject *Sender)
{
  BEGIN_LOG("");

  SetPenPoints();
  SetPenColor();
  if (!IsNormalPen){
    MakeCrayonBitmap();
  }
  MImageForm->iMainImage->Repaint();

  END_LOG;
}
//---------------------------------------------------------------------------
void __fastcall TKasuriForm::CheckPen()
{
  BEGIN_LOG("");

  bool penchange = false;
  TColor tPenColor = PenManagerForm->PenShape->Pen->Color;
  int red = tPenColor;
  int green = tPenColor >> 8;
  int blue = tPenColor >> 16;
  if (rgbPenColor.rgbBlue != blue || rgbPenColor.rgbGreen != green
  ||  rgbPenColor.rgbRed != red){
    SetPenColor();
    penchange = true;
  }

  if (IsPenShapeChange){
    SetPenPoints();
    IsPenShapeChange = false;
    penchange = true;
  }

  if (penchange) MImageForm->iMainImage->Repaint();

  END_LOG;
}
//---------------------------------------------------------------------------
void __fastcall TKasuriForm::SetPenColor()
{
  BEGIN_LOG("");

  if (hasKasuri){
    TColor tPenColor = PenManagerForm->PenShape->Pen->Color;
    int red = tPenColor;
    int green = tPenColor >> 8;
    int blue = tPenColor >> 16;

    rgbPenColor.rgbBlue = blue;
    rgbPenColor.rgbGreen = green;
    rgbPenColor.rgbRed = red;

    penIndex = PaletteForm->DIB256Palette->ChoiceIndex;
    kasuri->SetPenColor(rgbPenColor, penIndex);
    
    if (!IsNormalPen){      //shin 061024
      MakeCrayonBitmap();
      ChangeCrayonPen();
    }
  }

  END_LOG;
}
//---------------------------------------------------------------------------

void __fastcall TKasuriForm::rzbtOKClick(TObject *Sender)
{
  BEGIN_LOG("");

  Run();

  END_LOG;
}
//---------------------------------------------------------------------------
void __fastcall TKasuriForm::rzcbCrayonClick(TObject *Sender)
{
  BEGIN_LOG("");

  if (rzcbCrayon->Checked){
    IsNormalPen = false;
    CrayonOptionEnabled(true);
    if (hasKasuri){
      MakeCrayonBitmap();
      kasuri->IsNormalPen = false;
    }
    tbrCrayon->Position = tbrCrayon->Max/3;
    //DrawCreyonToPaintBox();
  } else {
    IsNormalPen = true;
    CrayonOptionEnabled(false);
    if (hasKasuri) kasuri->IsNormalPen = true;
  }
  DrawPen();
  MImageForm->iMainImage->Repaint();

  KasuriSubForm->rzcbCrayon->OnClick = NULL;
  KasuriSubForm->rzcbCrayon->Checked = rzcbCrayon->Checked;
  KasuriSubForm->rzcbCrayon->OnClick = KasuriSubForm->rzcbCrayonClick;

  END_LOG;
}
//---------------------------------------------------------------------------
void __fastcall TKasuriForm::CrayonOptionEnabled(bool bEnabled)
{
  BEGIN_LOG("");

  lbDensity->Enabled = bEnabled;
	rzseDensity->Enabled = bEnabled;
	tbrCrayon->Enabled = bEnabled;

  END_LOG;
}
//---------------------------------------------------------------------------
void __fastcall TKasuriForm::MakeCrayonBitmap()
{
  BEGIN_LOG("");

  if (hasKasuri && kasuri->KPointList->Count > 0){
    //ÇöÀç Á¡µéÀÇ Rect±¸Çϱâ
    int minx = 100000;
    int miny = 100000;
    int maxx = 0;
    int maxy = 0;
    int startx = 0, starty = 0;
    for (int i = 0; i < kasuri->KPointList->Count; i++){
      TPoint *point = (TPoint *)kasuri->KPointList->Items[i];
      if (point->x < minx) minx = point->x;
      if (point->y < miny) miny = point->y;
      if (point->x > maxx) maxx = point->x;
      if (point->y > maxy) maxy = point->y;
      if ((i % pointCount) == 0){
        startx += point->x;
        starty += point->y;
      }
    }

    if (branchCount > 1){
      startx = startx/branchCount;
      starty = starty/branchCount;
    }

    int width = maxx - minx + penThick*2;
    int height = maxy - miny + penThick*2;
    int largewidth = sqrt(width*width + height*height);
    int largeheight = largewidth;

    TTexpiaBitmap *CrayonBitmap = new TTexpiaBitmap;
    CrayonBitmap->Create(width, height, MImageForm->iMainImage->uBitmap->BitsPerPixel,
    MImageForm->iMainImage->uBitmap->RGB);
    if (MImageForm->iMainImage->uBitmap->BitsPerPixel == 24){
      CrayonBitmap->FillRect(Rect(0, 0, width, height), MImageForm->iMainImage->uBitmap->BackgroundColor);
      MakeDefaultCrayonBitmap(CrayonBitmap, startx - minx + penThick, starty - miny + penThick);
      kasuri->SetCrayonBitmap(CrayonBitmap, MImageForm->iMainImage->uBitmap->BackgroundColor, MImageForm->iMainImage->ZoomIn, MImageForm->iMainImage->ZoomOut);
    } else {
      if (rgbPenColor.rgbRed + rgbPenColor.rgbGreen + rgbPenColor.rgbBlue < 100){
        CrayonBitmap->StartScanLine();
        BYTE *Dst;
        for (int y = 0; y < CrayonBitmap->Height; y++){
          Dst = CrayonBitmap->GetScanLine(y);
          memset(Dst, 0xFF, CrayonBitmap->Width);
          CrayonBitmap->PutScanLine(y);
        }
        CrayonBitmap->StopScanLine();

        //CrayonBitmap->FillRect(Rect(0, 0, width, height), 255);
        MakeDefaultCrayonBitmap(CrayonBitmap, startx - minx + penThick, starty - miny + penThick);
        kasuri->SetCrayonBitmap(CrayonBitmap, 255, MImageForm->iMainImage->ZoomIn, MImageForm->iMainImage->ZoomOut);
      } else {
        CrayonBitmap->FillRect(Rect(0, 0, width, height), 0);
        MakeDefaultCrayonBitmap(CrayonBitmap, startx - minx + penThick, starty - miny + penThick);
        kasuri->SetCrayonBitmap(CrayonBitmap, 0, MImageForm->iMainImage->ZoomIn, MImageForm->iMainImage->ZoomOut);
      }
    }
    delete CrayonBitmap;
  }

  END_LOG;
}
//---------------------------------------------------------------------------
void __fastcall TKasuriForm::MakeDefaultCrayonBitmap(TTexpiaBitmap *Bitmap, int startx, int starty)
{
  BEGIN_LOG("");

  int n;
  int r = 0, g = 0, b = 0;
  r = rgbPenColor.rgbRed;
  g = rgbPenColor.rgbGreen;
  b = rgbPenColor.rgbBlue;

  HDC dcDst = Bitmap->CreateDC();
  gdp::Graphics graphics(dcDst);
  gdp::Color penColor(r, g, b);
  gdp::Pen pen(penColor, nDensity);// 1);
  gdp::SolidBrush penBrush(penColor);
  pen.SetStartCap(gdp::LineCapRound);
  pen.SetEndCap(gdp::LineCapRound);

  if (dcDst){
    int l, d, m, k;
    int temp = 0;
    if (Bitmap->Height > Bitmap->Width) temp = Bitmap->Height;
    else temp = Bitmap->Width;

    n = (temp/3 + (/*tbrCrayon->Max*/100 - BarPosition) *(temp/100));

    for(int x = -startx + random(2*nDensity); x < Bitmap->Width - startx; x+= 1 + random(nDensity)){
      for(int y = -starty + random(nDensity); y < Bitmap->Height - starty; y+= 1 + random(nDensity)){
        l = sqrt(x*x+y*y);

        if (random(n) > l){
          graphics.DrawLine(&pen, (x + startx), (y + starty), (x + startx + 1), (y + starty + 1));
        }
      }
    }

    /*
    n = (temp/2 + (tbrCrayon->Max - BarPosition) *(temp/100));
    for(int x = -startx; x < Bitmap->Width - startx; x+= nDensity){
      for(int y = -starty; y < Bitmap->Height - starty; y++){
        l = sqrt(x*x+y*y);

        if (rand() % n > l){
          if (nDensity == 1){
            graphics.DrawEllipse(&pen, x + startx, y + starty, 1, 1);
          } else {
            graphics.DrawEllipse(&pen, x + startx, y + starty, nDensity, nDensity);
            graphics.FillEllipse(&penBrush, x+ startx, y+ starty, nDensity, nDensity);
          }
        }
      }
    }
    */
    Bitmap->DeleteDC(dcDst);
  }

  END_LOG;
}
//---------------------------------------------------------------------------

void __fastcall TKasuriForm::DrawCreyonToPaintBox()
{
  BEGIN_LOG("");

  Graphics::TBitmap *tbPaintBox;
  tbPaintBox = new Graphics::TBitmap();  //by bomchun Å©·¹¿ë ÆäÀÎÆ®¹Ú½º¿¡ ±×¸®´Â ºÎºÐ
  tbPaintBox->Width = pbCreyonView->Width;
  tbPaintBox->Height = pbCreyonView->Height;
  tbPaintBox->Handle = CreateCompatibleBitmap(pbCreyonView->Canvas->Handle,pbCreyonView->Width,pbCreyonView->Height);

  int n;
  n = (tbPaintBox->Width/2 + BarPosition *(tbPaintBox->Width/100)); //by bomchun ÀüüÀûÀ¸·Î ¼öÁ¤µÇ¾úÀ½

  tbPaintBox->Canvas->FillRect(Rect(0,0,tbPaintBox->Width,tbPaintBox->Height));
  tbPaintBox->Canvas->Pen->Width = nDensity;
  tbPaintBox->Canvas->Pen->Color = clBlack;

  for(int k = 1; k < tbPaintBox->Height+1; k += nDensity)
  {
    for(int i = 1; i < tbPaintBox->Width+1; i++)
    {
      if(MakeRandom(i,n))
      {
        tbPaintBox->Canvas->Ellipse(i,k,i+2,k+2);
      }
    }
  }

  BitBlt(pbCreyonView->Canvas->Handle, 0, 0, tbPaintBox->Width, tbPaintBox->Height,tbPaintBox->Canvas->Handle , 0, 0, SRCCOPY);
  delete  tbPaintBox;

  END_LOG;
}
//---------------------------------------------------------------------------
void __fastcall TKasuriForm::rzbtCancelClick(TObject *Sender)
{
  BEGIN_LOG("");

  hasKasuri = false;
  MImageForm->iMainImage->Repaint();
  if (CheckCount()) SetCount(pointCount, branchCount, twigCount);
  OptionEnabled(false);
  rzbtOK->SetFocus();

  END_LOG;
}
//---------------------------------------------------------------------------
void __fastcall TKasuriForm::Run()
{
  BEGIN_LOG("");

  if (!isPointEnd()){
    if (kasuri){
      delete kasuri;
      kasuri = NULL;
    }
    hasKasuri = false;
  } else {
    if (hasKasuri){
      RECT rt;
      bool undoSw = false;

      bEdit = false;
      hasKasuri = false;

      int minx = 100000;
      int miny = 100000;
      int maxx = 0;
      int maxy = 0;
      int startx = 0, starty = 0;
      for (int i = 0; i < kasuri->KPointList->Count; i++){
        TPoint *point = (TPoint *)kasuri->KPointList->Items[i];
        if (point->x < minx) minx = point->x;
        if (point->y < miny) miny = point->y;
        if (point->x > maxx) maxx = point->x;
        if (point->y > maxy) maxy = point->y;
      }
      rt.left = minx - penThick;
      rt.top = miny - penThick;
      rt.right = maxx + penThick;
      rt.bottom = maxy + penThick;

      if ((undoSw = MImageForm->UndoSave(UK_ALL, rt)) == false) { END_LOG; return; }
/*
      kasuri->Apply(MImageForm->iMainImage->uBitmap);
      if (MImageForm->iMainImage->LayerMask){
        kasuri->Apply(MImageForm->iMainImage->LayerMask, true);
      }*/

      kasuri->Apply(MImageForm->iMainImage->uBitmap,
        MImageForm->iMainImage->BackGround, MImageForm->Protect, false,
        MImageForm->iMainImage->Mask, MImageForm->MaskArea);

      if (MImageForm->iMainImage->LayerMask){
        kasuri->Apply(MImageForm->iMainImage->LayerMask,
          MImageForm->iMainImage->BackGround, MImageForm->Protect, true,
          MImageForm->iMainImage->Mask, MImageForm->MaskArea);
      }
      
      MImageForm->iMainImage->RectPaint(rt);
    }
  }
  //´Ù½Ã ¼ÂÆÃÇØÁØ´Ù
  SetCount(pointCount, branchCount, twigCount);
  OptionEnabled(false);

  END_LOG;
}
//---------------------------------------------------------------------------
void __fastcall TKasuriForm::iMainImageKeyDown(WORD Key, TShiftState Shift)
{
  BEGIN_LOG("");

  if (!edTwigCount->Focused() && !edDistance->Focused()
    && !rzsePointCount->Focused() && !rzseBranchCount->Focused()){
    if (Key == VK_RETURN){
      Run();
    }
  }

  END_LOG;
}
//---------------------------------------------------------------------------
void __fastcall TKasuriForm::iMainImageMouseLeave(TObject *Sender)
{
//  bPathDrawingMode = true;
//  bPathDrawMovingMode = false;
//  bPathDrawEnd = false;
}
//---------------------------------------------------------------------------
void __fastcall TKasuriForm::ChangeKasuriPoints(bool IsCrayonChange)
{
  BEGIN_LOG("");

  if (IsCrayonChange){
    if (!IsNormalPen){
      MakeCrayonBitmap();
      kasuri->IsNormalPen = false;
    }
  }
  kasuri->bMove = !IsCrayonChange;  //shin 061024
  kasuri->CalculatePoints();

  END_LOG;
}
//---------------------------------------------------------------------------
void __fastcall TKasuriForm::MoveKasuriPoint(int nIndex, bool IsCrayonChange)
{
  BEGIN_LOG("");

  if (!IsNormalPen || branchCount > 1){
    kasuri->bMove = !IsCrayonChange;  //shin 061024
    if (IsNormalPen || branchCount > 1) kasuri->ChangePoint(nIndex);

    if (IsCrayonChange){
      if (!IsNormalPen){
        MakeCrayonBitmap();
        kasuri->IsNormalPen = false;
      }
    }
  }

  END_LOG;
}
//---------------------------------------------------------------------------
void __fastcall TKasuriForm::rzsePointCountMouseDown(TObject *Sender,
      TMouseButton Button, TShiftState Shift, int X, int Y)
{
  rzsePointCount->SetFocus();
}
//---------------------------------------------------------------------------

void __fastcall TKasuriForm::rzseBranchCountMouseDown(TObject *Sender,
      TMouseButton Button, TShiftState Shift, int X, int Y)
{
  rzseBranchCount->SetFocus();
}
//---------------------------------------------------------------------------

void __fastcall TKasuriForm::rzsePointCountChange(TObject *Sender)
{
  BEGIN_LOG("");

  if (rzsePointCount->Value > 0){
    int nPoint = rzsePointCount->Value;
    if (nPoint > rzsePointCount->Max){
      pointCount = rzsePointCount->Max;
    } else {
      if (nPoint == pointCount+1 || nPoint == pointCount-1) rzbtOK->SetFocus();
      pointCount = nPoint;
    }
    hasKasuri = false;
    MImageForm->iMainImage->Repaint();
    if (CheckCount()) SetCount(pointCount, branchCount, twigCount);
  }

  END_LOG;
}
//---------------------------------------------------------------------------

void __fastcall TKasuriForm::rzseBranchCountChange(TObject *Sender)
{
  BEGIN_LOG("");

  int nBranch = rzseBranchCount->Value;
  if (nBranch > rzseBranchCount->Max){
    branchCount = rzseBranchCount->Max;
  } else {
    if (nBranch == branchCount+1 || nBranch == branchCount-1) rzbtOK->SetFocus();
    branchCount = nBranch;
  }
  if (branchCount > 1){
    //OptionEnabled(true);
  } else {
    OptionEnabled(false);
    tbrTwigs->Position = 1;
    trbDistance->Position = 1;
  }
  hasKasuri = false;
  MImageForm->iMainImage->Repaint();
  if (CheckCount()) SetCount(pointCount, branchCount, twigCount);

  END_LOG;
}
//---------------------------------------------------------------------------

void __fastcall TKasuriForm::rzsePointCountKeyDown(TObject *Sender,
      WORD &Key, TShiftState Shift)
{
  BEGIN_LOG("");

  if (Key == VK_RETURN){
    if (rzsePointCount->Value > 0){
      int nPoint = rzsePointCount->Value;

      hasKasuri = false;
      if (nPoint > rzsePointCount->Max){
        pointCount = rzsePointCount->Max;
      } else {
        pointCount = nPoint;
      }
      MImageForm->iMainImage->Repaint();
      if (CheckCount()) SetCount(pointCount, branchCount, twigCount);
      rzbtOK->SetFocus();
    }
  }

  END_LOG;
}
//---------------------------------------------------------------------------

void __fastcall TKasuriForm::rzseBranchCountKeyDown(TObject *Sender,
      WORD &Key, TShiftState Shift)
{
  BEGIN_LOG("");

  if (Key == VK_RETURN){

    if (rzseBranchCount->Value > 0)
    {
      int nBranch = rzseBranchCount->Value;

      hasKasuri = false;
      if (nBranch > rzseBranchCount->Max){
        branchCount = rzseBranchCount->Max;
      } else {
        branchCount = nBranch;
      }
      MImageForm->iMainImage->Repaint();
      if (CheckCount()) SetCount(pointCount, branchCount, twigCount);

      rzbtOK->SetFocus();
    }
  }

  END_LOG;
}
//---------------------------------------------------------------------------


void __fastcall TKasuriForm::rzbtApplyPenClick(TObject *Sender)
{
  BEGIN_LOG("");

  SetPenPoints();
  //SetPenColor();
  if (!IsNormalPen){
    MakeCrayonBitmap();
    ChangeCrayonPen();
  }
  MImageForm->iMainImage->Repaint();
  rzbtOK->SetFocus();

  END_LOG;
}
//---------------------------------------------------------------------------
void __fastcall TKasuriForm::UpdateMenuItems(bool bEnable)
{
  if (!MainMenuForm) return;
  MainMenuForm->sbDraw->Enabled = bEnable;
  MainMenuForm->sbPatternRepeat->Enabled = bEnable;
  MainMenuForm->sbText->Enabled = bEnable;
}
//---------------------------------------------------------------------------
void __fastcall TKasuriForm::ChangeCrayonPen()
{
  BEGIN_LOG("");

  if (!crayonPenBitmap){
    crayonPenBitmap = new TTexpiaBitmap;
    crayonPenBitmap->Create(penImage->Bitmap->Width, penImage->Bitmap->Height, 24);
  }
  crayonPenBitmap->FillRect(Rect(0, 0, penImage->Width, penImage->Height), clWhite);
  MakeDefaultCrayonBitmap(crayonPenBitmap, penImage->Bitmap->Width, penImage->Bitmap->Height/2);
  DrawPen();

  END_LOG;
}
//---------------------------------------------------------------------------

void __fastcall TKasuriForm::edDistanceMouseDown(TObject *Sender,
      TMouseButton Button, TShiftState Shift, int X, int Y)
{
  edDistance->SetFocus();
}
//---------------------------------------------------------------------------

void __fastcall TKasuriForm::edDistanceKeyDown(TObject *Sender, WORD &Key,
      TShiftState Shift)
{
  BEGIN_LOG("");

  if (Key == VK_RETURN){

    if (edTwigCount->Value > 0)
    {
      int nDistance = edDistance->Value;

      if (hasKasuri && isPointEnd()){
        if (nDistance > trbDistance->Max){
          trbDistance->Position = trbDistance->Max;
        } else {
          trbDistance->Position = nDistance;
        }
        DistanceChange();
      }
    }
    edDistance->Value = bendDistance;
    rzbtOK->SetFocus();
  }

  END_LOG;
}
//---------------------------------------------------------------------------
void __fastcall TKasuriForm::rzseDensityMouseDown(TObject *Sender,
      TMouseButton Button, TShiftState Shift, int X, int Y)
{
  rzseDensity->SetFocus();
}
//---------------------------------------------------------------------------
void __fastcall TKasuriForm::OptionEnabled(bool bEnable)
{
  BEGIN_LOG("");

  lbTwigCount->Enabled = bEnable;
  lbDistance->Enabled = bEnable;
	edTwigCount->Enabled = bEnable;
	edDistance->Enabled = bEnable;
	tbrTwigs->Enabled = bEnable;
	trbDistance->Enabled = bEnable;

  if (bEnable){
    edTwigCount->Value = twigCount;
    edDistance->Value = bendDistance;
  }

  END_LOG;
}
//---------------------------------------------------------------------------
void __fastcall TKasuriForm::sbPreviewClick(TObject *Sender)
{
  KasuriSubForm->Visible = !KasuriSubForm->Visible;
  KasuriSubForm->Repaint();
}
//---------------------------------------------------------------------------
void __fastcall TKasuriForm::TwigsChange()
{
  BEGIN_LOG("");

  twigCount = tbrTwigs->Position;
  edTwigCount->Value = twigCount;

  if (CheckCount()){
    if (hasKasuri && isPointEnd()){
      AllBranchCount = branchCount + twigCount*(branchCount-1);
      kasuri->TwigCount = twigCount;
      kasuri->AllBranchCount = AllBranchCount;
      ChangeKasuriPoints();
      if (kasuri->bMove) kasuri->bMove = false;   //shin 061024
      MImageForm->iMainImage->Repaint();
    }
  }

  END_LOG;
}
//---------------------------------------------------------------------------
void __fastcall TKasuriForm::DistanceChange()
{
  BEGIN_LOG("");

  if (hasKasuri && isPointEnd()){
    bendDistance = trbDistance->Position;
    kasuri->Distance = bendDistance;
    ChangeKasuriPoints();
    if (kasuri->bMove) kasuri->bMove = false;   //shin 061024
    MImageForm->iMainImage->Repaint();
  }
  edDistance->Value = bendDistance;

  END_LOG;
}
//---------------------------------------------------------------------------
void __fastcall TKasuriForm::EditorSelectAll(TObject *Sender)
{
	SetFocusAndSelectAll(Sender);
}
//---------------------------------------------------------------------------

void __fastcall TKasuriForm::trbDistanceChange(TObject *Sender)
{
	BEGIN_LOG("");

	DistanceChange();

	END_LOG;
}
//---------------------------------------------------------------------------

void __fastcall TKasuriForm::tbrTwigsChange(TObject *Sender)
{
	BEGIN_LOG("");

	TwigsChange();

	END_LOG;
}
//---------------------------------------------------------------------------