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

#include "TPDocument.h"
#pragma package(smart_init)
//---------------------------------------------------------------------------
//
// TPDocument
//
//---------------------------------------------------------------------------
// ValidCtrCheck is used to assure that the components created do not have
// any pure virtual functions.
//

static inline void ValidCtrCheck(TPDocument *)
{
  new TPDocument(NULL);
}
//---------------------------------------------------------------------------
__fastcall TPDocument::TPDocument(TComponent* Owner)
  : TGraphicControl(Owner)
{
  ControlStyle = ControlStyle << csReplicatable << csOpaque;
  Height = 105;
  Width = 105;
  FSheet = NULL;
  FDesign = true;
  FRGridSpace = 1;
  FDGridSpace = 8;
  SelectElement = NULL;
  dcm = dcmNone;
  lang = 0;   //dog
  MDS = NULL;
                  
  // È­¸é¿¡ N1, F1À» º¸¿©ÁÙ °ÍÀÎÁöÀÇ ¿©ºÎ (2007. 08. 09 Annualring)
  paintID = true;

  FFormulaMode = false; //formula
  FSetDateMode = false;
  ArrowSelectMouseDown = false;
}
//---------------------------------------------------------------------------
__fastcall TPDocument::~TPDocument()
{
}
//---------------------------------------------------------------------------
// Private Function
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
void __fastcall TPDocument::WMKeyDown(TMessage &msg)
{
//  if (FOnKeyDown) FOnKeyDown(this, &Key, Sfhift);
//  if (FOnKeyDown) FOnKeyDown(this);
}
//---------------------------------------------------------------------------
void __fastcall TPDocument::WMKeyUp(TMessage &msg)
{
//  if (FOnKeyUp) FOnKeyUp(this, &Key, Shift);
//  if (FOnKeyUp) FOnKeyUp(this);
}
//---------------------------------------------------------------------------
void __fastcall TPDocument::WMKeyPress(TMessage &msg)
{
//  if (FOnKeyPress) FOnKeyPress(this, &Key, Shift);
//  if (FOnKeyPress) FOnKeyPress(this);
}
//---------------------------------------------------------------------------
void __fastcall TPDocument::SetDesign(bool Value)
{
  if (FDesign != Value) {
    FDesign = Value;
    Refresh();
  }
}
//---------------------------------------------------------------------------
void __fastcall TPDocument::SetRGridSpace(int Value)
{
  if (FRGridSpace != Value) {
    FRGridSpace = Value;
    if (FRGridSpace) {
      ViewStatus.Position.x -= ViewStatus.Position.x % FRGridSpace;
      ViewStatus.Position.y -= ViewStatus.Position.y % FRGridSpace;
    }
    Refresh();
  }
}
//---------------------------------------------------------------------------
void __fastcall TPDocument::SetDGridSpace(int Value)
{
  if (FDGridSpace != Value) {
    FDGridSpace = Value;
    if (FDGridSpace) {
      ViewStatus.Position.x -= ViewStatus.Position.x % FDGridSpace;
      ViewStatus.Position.y -= ViewStatus.Position.y % FDGridSpace;
    }
    Refresh();
  }
}
//---------------------------------------------------------------------------
void __fastcall TPDocument::SetSheet(TPDocSheet *Value)
{
  if (FSheet != Value) {
    FSheet = Value;
    Refresh();
  }
}
//---------------------------------------------------------------------------
void __fastcall TPDocument::SetPosX(LONG Value)
{
  int grid;
  if (FDesign) grid = FDGridSpace;
  else         grid = FRGridSpace;
  if (ViewStatus.Position.x != Value) {
    ViewStatus.Position.x = Value - (Value % grid);
    if (ViewStatus.Position.x < 0) ViewStatus.Position.x = 0;     //added by k3dogs(2000/10/25)0º¸´Ù ÀÛÀ¸¸é access violation error°¡ ³­´Ù.
    Refresh();
  }
}
//---------------------------------------------------------------------------
void __fastcall TPDocument::SetPosY(LONG Value)
{
  int grid;
  if (FDesign) grid = FDGridSpace;
  else         grid = FRGridSpace;
  if (ViewStatus.Position.y != Value) {
    ViewStatus.Position.y = Value - (Value % grid);
    if (ViewStatus.Position.y < 0) ViewStatus.Position.y = 0;
    Refresh();
  }
}
//---------------------------------------------------------------------------
// Protected Function
//---------------------------------------------------------------------------
void __fastcall TPDocument::Paint()
{
  TPDocElement *dp;
  RECT r, rt, ddr;
  HDC dcSrc = NULL, dcMemV = NULL;
  HBITMAP bmMemV = NULL;
  int x, y, w, h, zi, zo;

  TPDocArrow* docArrow;
  RECT arrowRect, arrowTextRect;

  if (ComponentState.Contains(csDesigning)) {
    TGraphicControl::Canvas->Pen->Style = psDash;
    TGraphicControl::Canvas->Brush->Style = bsClear;
    TGraphicControl::Canvas->Rectangle(0, 0, Width, Height);
  } else {
   	if (Width<=0 || Height<=0) return;
    dcSrc = TGraphicControl::Canvas->Handle;
    try {
      zi = ViewStatus.ZoomIn;
      zo = ViewStatus.ZoomOut;
      w = Width;
      h = Height;
      bmMemV = CreateCompatibleBitmap(dcSrc, w, h);
      dcMemV = CreateCompatibleDC(dcSrc);
      SelectObject(dcMemV, bmMemV);
      r = Rect(0, 0, w, h);
      FillRect(dcMemV, &r, (HBRUSH)GetStockObject(WHITE_BRUSH));
      if (FDesign) {
        if (FSheet) {
          if (FDGridSpace * zi / zo  > 4) {
            for (y = (4 - ViewStatus.Position.y%4) % 4 * zi/zo; y < h; y += FDGridSpace * zi/zo) {
              for (x = (4 - ViewStatus.Position.x*4) %4 * zi/zo; x < w; x += FDGridSpace *zi/zo) {
                SetPixel(dcMemV, x, y, clBlack);
              }
            }
          }
          for (int i = 0; i < FSheet->Element->Count; i++) {
            dp = (TPDocElement *)FSheet->Element->Items[i];
            if (dp == NULL) continue;
            rt = dp->ConvertRange(&ViewStatus);
            if (IntersectRect(&ddr, &r, &rt)) {
//              if(dp->HasValue()){
//                dp->PaintReport(FSheet, dcMemV, ViewStatus, false, dp == SelectElement, lang);  // 0-->Korean..
//                dp->PaintDesign(dcMemV, ViewStatus, dp == SelectElement);
//
//              }else{

                // HasValueÀÏ ¶§µµ paintIDÀÌ trueÀÌ¸é º¸¿©ÁÖ±â (2007. 08. 09 Annualring)
               dp->PaintDesign(FSheet, dcMemV, ViewStatus, false, dp == SelectElement, lang, paintID);
//              }
            }
          }
        }
        //if (FOnEditPaint) FOnEditPaint(this, dcMemV);
        if (FOnPaintGuideLine) FOnPaintGuideLine(dcMemV, Rect(0,0,0,0));   // By minw428
        BitBlt(dcSrc, 0, 0, w, h, dcMemV, 0, 0, SRCCOPY);
      } else {
        if (FSheet) {
          for (int i = 0; i < FSheet->Element->Count; i++) {
            dp = (TPDocElement *)FSheet->Element->Items[i];
            if (dp == NULL) continue;
            rt = dp->ConvertRange(&ViewStatus);
            if (IntersectRect(&ddr , &r, &rt)) {
              dp->PaintForm(dcMemV, &ViewStatus);
              #ifdef ELLITE_BASIC
              if (dp->Type == detArrow || dp->Type == detSheafLabel) {
              #else
              if (dp->Type == detArrow || dp->Type == detSheafLabel || dp->Type == detSheafLine) {
              #endif              
                continue;
              }
              else if (dp->Type == detSheafImage)
                dp->PaintReport(FSheet, dcMemV, ViewStatus, false, ((TPDocSheafImage *)dp)->bSelected, lang);  // 0-->Korean.. //for linuxjun
              else
                dp->PaintReport(FSheet, dcMemV, ViewStatus, false, dp == SelectElement, lang);  // 0-->Korean..
            }
          }
        }
        //if (FOnEditPaint) FOnEditPaint(this, dcMemV);
        if (FOnPaintVector) FOnPaintVector(dcMemV, Rect(0,0,0,0));   // By GreenFish
        //*Ellite Basic ¿ä±¸»çÇ×À¸·Î È­»ìÇ¥ ±×¸®´Â ³ôÀÌ ³ô¿©ÁÖ´Â ºÎºÐ by linuxjun
        if (FSheet) {
          for (int i = 0; i < FSheet->Element->Count; i++) {
            dp = (TPDocElement *)FSheet->Element->Items[i];
            if (dp == NULL) continue;
            rt = dp->ConvertRange(&ViewStatus);

            if (dp->Type == detArrow) {

              // ±âÁ¸ ¿¡·¯ ¼öÁ¤À» À§ÇØ ¿©±âµµ RectPaint¿Í ¶È°°ÀÌ ¼öÁ¤ (2007. 11. 21 Annualring)
              arrowRect = dp->ConvertRange(&ViewStatus); // &dp->Range;
              docArrow = (TPDocArrow*)dp;
              // ¿©±â¼­  (2007. 11. 01 Annualring)
              arrowTextRect = docArrow->ConvertTextRange(&ViewStatus);// TextRange;

//              arrowRect = ComposeRect(arrowRect, arrowTextRect);
              if (IntersectRect(&ddr, &arrowRect, &r) || IntersectRect(&ddr, &arrowTextRect, &r)) {
//              if (IntersectRect(&ddr , &r, &rt)) {
                dp->PaintForm(dcMemV, &ViewStatus);
                dp->PaintReport(FSheet, dcMemV, ViewStatus, false, ((TPDocArrow *)dp)->bSelected, lang);  // 0-->Korean..
              }
            }
            #ifdef ELLITE_BASIC
            else if (dp->Type == detSheafLabel) {
            #else
            else if (dp->Type == detSheafLabel || dp->Type == detSheafLine) {
            #endif
              dp->PaintReport(FSheet, dcMemV, ViewStatus, false, dp == SelectElement, lang);
            }
          }
        }
        //*/

        if (FOnPaintGuideLine) FOnPaintGuideLine(dcMemV, Rect(0,0,0,0));   // By minw428
        BitBlt(dcSrc, 0, 0, w, h, dcMemV, 0, 0, SRCCOPY);
        if (FOnPaintDirectly)  FOnPaintDirectly(dcSrc, 0, 0, w, h);
      }
    }
    __finally {
      if (dcMemV) DeleteDC(dcMemV);
      if (bmMemV) DeleteObject(bmMemV);
    }
  }
}
                    

//---------------------------------------------------------------------------
void __fastcall TPDocument::PaintElement(TPDocElement *elementToPaint)
{
  TPDocElement *dp;
  RECT r, rt, ddr;
  HDC dcSrc = NULL, dcMemV = NULL;
  HBITMAP bmMemV = NULL;
  int x, y, w, h, zi, zo;

  if (ComponentState.Contains(csDesigning)) {
    TGraphicControl::Canvas->Pen->Style = psDash;
    TGraphicControl::Canvas->Brush->Style = bsClear;
    TGraphicControl::Canvas->Rectangle(0, 0, Width, Height);
  } else {
   	if (Width<=0 || Height<=0) return;
    dcSrc = TGraphicControl::Canvas->Handle;
    try {
      zi = ViewStatus.ZoomIn;
      zo = ViewStatus.ZoomOut;
      w = Width;
      h = Height;
      bmMemV = CreateCompatibleBitmap(dcSrc, w, h);
      dcMemV = CreateCompatibleDC(dcSrc);
      SelectObject(dcMemV, bmMemV);

      r = Rect(0, 0, w, h);
 //     FillRect(dcMemV, &r, (HBRUSH)GetStockObject(WHITE_BRUSH));

      if (!FDesign) {

        if (FSheet) {
          for (int i = 0; i < FSheet->Element->Count; i++)
          {
            dp = (TPDocElement *)FSheet->Element->Items[i];
            if (dp == NULL) continue;
            rt = dp->ConvertRange(&ViewStatus);

            if (dp->Type == detArrow && dp == elementToPaint){
              if (IntersectRect(&ddr , &r, &rt)) {
                dp->PaintForm(dcMemV, &ViewStatus);
                dp->PaintForm(dcMemV, &ViewStatus);
                dp->PaintReport(FSheet, dcMemV, ViewStatus, false, ((TPDocArrow *)dp)->bSelected, lang);
                BitBlt(dcSrc, 0, 0, w, h, dcMemV, 0, 0, SRCCOPY);
              }
            }

          }
        }
//        BitBlt(dcSrc, 0, 0, w, h, dcMemV, 0, 0, SRCCOPY);
      }
    }
    __finally {
      if (dcMemV) DeleteDC(dcMemV);
      if (bmMemV) DeleteObject(bmMemV);
    }
  }
}

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

void __fastcall TPDocument::RectPaint(RECT Src)
{
  TPDocElement *dp, *ep;
  RECT r, rc;
	RECT tempRc;
  HDC dcSrc = NULL, dcMemV = NULL, dcForm = NULL;
  HBITMAP bmMemV = NULL;
  int x, y, w, h, zi, zo;
  TPDocViewStatus vs;
  TPDocViewStatus imageVs;
  POINT sp;
  RECT VectorRect;

  TPDocArrow* docArrow;
  RECT arrowRect, arrowTextRect;

  if (ComponentState.Contains(csDesigning)) {
    TGraphicControl::Canvas->Pen->Style = psDash;
    TGraphicControl::Canvas->Brush->Style = bsClear;
    TGraphicControl::Canvas->Rectangle(0, 0, Width, Height);
  } else {
   	if (Width<=0 || Height<=0) return;
    dcSrc = TGraphicControl::Canvas->Handle;
		tempRc.left = Src.left;
		tempRc.right = Src.right;
		tempRc.top = Src.top;
		tempRc.bottom = Src.bottom;

    try {
      zi = ViewStatus.ZoomIn;
      zo = ViewStatus.ZoomOut;

          /*
			tempRc.left -= ViewStatus.Position.x;
			tempRc.top -= ViewStatus.Position.y;
			tempRc.right -= ViewStatus.Position.x;
			tempRc.bottom -= ViewStatus.Position.y;

			/*
			if (zo>1 && zi == 1) {
				tempRc.left -= tempRc.left%zo;
				tempRc.top -= tempRc.top%zo;
				tempRc.right -= tempRc.right%zo;
				tempRc.bottom -= tempRc.bottom%zo;
			}
			if (zi>1 && zo != 1) {
				tempRc.left -= tempRc.left%zo;
				tempRc.top -= tempRc.top%zo;
				tempRc.right += tempRc.right%zo;
				tempRc.bottom += tempRc.bottom%zo;
			}
			*/
      /*

			if(zi==2){
				tempRc.left -= tempRc.left%(zo/zi);
				tempRc.top -= tempRc.top%(zo/zi);
				tempRc.right -= tempRc.right%(zo/zi);
				tempRc.bottom -= tempRc.bottom%(zo/zi);
			}

 			if(zi==3){
				tempRc.left -= tempRc.left%(zo/zi);
				tempRc.top -= tempRc.top%(zo/zi);
				tempRc.right += tempRc.right%(zo/zi);
				tempRc.bottom += tempRc.bottom%(zo/zi);
			}

 			if(zi==5){
				tempRc.left -= tempRc.left%(zo);
				tempRc.top -= tempRc.top%(zo);
				tempRc.right += tempRc.right%(zo);
				tempRc.bottom += tempRc.bottom%(zo);
			}
 			if(zi==6){
				tempRc.left -= tempRc.left%(zo);
				tempRc.top -= tempRc.top%(zo);
				tempRc.right += tempRc.right%(zo);
				tempRc.bottom += tempRc.bottom%(zo);
			}

			if(zi==7){
				tempRc.left -= tempRc.left%(zo);
				tempRc.top -= tempRc.top%(zo);
				tempRc.right += tempRc.right%(zo);
				tempRc.bottom += tempRc.bottom%(zo);
			}

      w = (tempRc.right - tempRc.left) * zi / zo;
      h = (tempRc.bottom - tempRc.top) * zi / zo;
        */
      /*
 			if(zi==4){
				Src.left -= (Src.left+ViewStatus.Position.x)%2;
				Src.top -= Src.top%2;
				Src.right += (Src.right+ViewStatus.Position.x)%2;
				Src.bottom += Src.bottom%2;
			}
 			if(zi==6){
				Src.left -= (Src.left+ViewStatus.Position.x)%2;
				Src.top -= (Src.top+ViewStatus.Position.y)%2;
				Src.right += (Src.right+ViewStatus.Position.x)%2;
				Src.bottom += (Src.bottom+ViewStatus.Position.y)%2;
			}
        */
  		Src.left -= (Src.left-ViewStatus.Position.x)%4;
			Src.top -= (Src.top-ViewStatus.Position.y)%4;
			Src.right += 4-(Src.right-ViewStatus.Position.x)%4;
			Src.bottom += 4-(Src.bottom-ViewStatus.Position.y)%4;

      w = (Src.right - Src.left) * zi / zo;
      h = (Src.bottom - Src.top) * zi / zo;

      vs.Position.x = Src.left;  vs.Position.y = Src.top;
      //vs.Position.x = tempRc.left;  vs.Position.y = tempRc.top;
      vs.ZoomIn = zi; vs.ZoomOut = zo;
      //sp.x = ViewStatus.Pattern2RectViewX(Src.left);
      //sp.y = ViewStatus.Pattern2RectViewY(Src.top);
      sp.x = ViewStatus.Pattern2ViewX(Src.left);
      sp.y = ViewStatus.Pattern2ViewY(Src.top);
//      sp.x = (Src.left-ViewStatus.Position.x)*zi/zo;
//      sp.y = (Src.top-ViewStatus.Position.x)*zi/zo;
      bmMemV = CreateCompatibleBitmap(dcSrc, w, h);
      dcMemV = CreateCompatibleDC(dcSrc);
      SelectObject(dcMemV, bmMemV);
      r = Rect(0, 0, w, h);
      FillRect(dcMemV, &r, (HBRUSH)GetStockObject(WHITE_BRUSH));

      if (FDesign) {
        if (FSheet) {
          if (FDGridSpace * zi / zo  > 4) {
            for (y = (4 - Src.top%4) % 4 * zi/zo; y < h; y += FDGridSpace * zi/zo) {
              for (x = (4 - Src.left*4) %4 * zi/zo; x < w; x += FDGridSpace *zi/zo) {
                SetPixel(dcMemV, x, y, clBlack);
              }
            }
          }
          for (int i = 0; i < FSheet->Element->Count; i++) {
            dp = (TPDocElement *)FSheet->Element->Items[i];
            if (dp == NULL) continue;
            if (IntersectRect(&r, &dp->Range, &Src)) {

//              if(dp->HasValue()){
//                dp->PaintDesign(dcMemV, ViewStatus, dp == SelectElement);
//                dp->PaintReport(FSheet, dcMemV, ViewStatus, false, dp == SelectElement, lang);  // 0-->Korean..
//              }else{     
              // HasValueÀÏ ¶§µµ paintIDÀÌ trueÀÌ¸é º¸¿©ÁÖ±â (2007. 08. 09 Annualring)
              dp->PaintDesign(FSheet, dcMemV, vs, false, dp == SelectElement, lang, paintID);
//              }

//              dp->PaintDesign(dcMemV, vs, dp == SelectElement);
            }
          }
        }
        //if (FOnEditPaint) FOnEditPaint(this, dcMemV);
        BitBlt(dcSrc, sp.x, sp.y, w, h, dcMemV, 0, 0, SRCCOPY);
      } else {
        if (FSheet) {
          for (int i = 0; i < FSheet->Element->Count; i++) {
            dp = (TPDocElement *)FSheet->Element->Items[i];
            if (dp == NULL) continue;
            if (IntersectRect(&r, &dp->Range, &Src)) {
              if (dp->Type == detChart) {
                for (int n = 0; n < ((TPDocChart *)dp)->Cell->Count; n++) {
                  ep = (TPDocElement *)((TPDocChart *)dp)->Cell->Items[n];
                  rc = ep->ConvertRange();
                  if (IntersectRect(&r, &rc, &Src)){
                      ep->PaintForm(dcMemV, &vs);
                      if(ep->bVisible == true)
                        ep->PaintReport(FSheet, dcMemV, vs, false, dp == SelectElement, lang);
                      else
                        ep->PaintReportHidden(FSheet, dcMemV, vs, false, dp == SelectElement, lang);
                  }
                }
              } else{
                dp->PaintForm(dcMemV, &vs);

                ///* for linuxjun RectPaintÀ϶§µµ ArrowÀÇ °æ¿ì ¼±Åà ¿©ºÎ¸¦ µû·Î ó¸®ÇؾßÇÒ°Å °°À¸³ª ¾ÆÁ÷ ÀÌ»óÀÌ º¸°íµÇÁö ¾ÊÀ½...³Ö¾î¾ßÇÒÁö ¸»¾Æ¾ßÇÒÁö...¸ð¸£°ÚÀ½.
                #ifdef ELLITE_BASIC
                if (dp->Type == detArrow || dp->Type == detSheafLabel) {
                #else
                if (dp->Type == detArrow || dp->Type == detSheafLabel || dp->Type == detSheafLine) {
                #endif                
                  continue;
                }
                else if (dp->Type == detSheafImage) {
                  // ImageÀÇ RectPaint½Ã¿¡ À̹ÌÁö À§Ä¡°¡ ¾à°£¾¿ ±úÁö´Â ¹®Á¦ 󸮸¦ À§ÇÏ¿© º¸Á¤
                  // (2007. 11. 21 Annualring)
/*
                  imageVs = vs;
                  if (imageVs.Position.x > dp->Range.left) {
                    imageVs.Position.x = imageVs.Position.x + 1;
                  }
                  if (imageVs.Position.y > dp->Range.top) {
                    imageVs.Position.y = imageVs.Position.y + 1;
                  }
*/
                  dp->PaintReport(FSheet, dcMemV, vs, false, ((TPDocSheafImage *)dp)->bSelected, lang);  // 0-->Korean.. //for linuxjun
                  //dp->PaintReport(FSheet, dcMemV, ViewStatus, false, dp == SelectElement, lang);  // 0-->Korean.. //by linuxjun
                }
                else
                  dp->PaintReport(FSheet, dcMemV, vs, false, dp == SelectElement, lang);  // 0-->Korean..
              }
            }
          }
        }
        //if (FOnEditPaint) FOnEditPaint(this, dcMemV);



        //if (FOnPaintVector) FOnPaintVector(dcMemV, Src);   // By GreenFish
        // TexProó·³ (X - PositionX) * ZoomIn/ZoomOut - px ÇüÅ·Πº¯°æ - by monkman (2007.10.02)
        VectorRect = Src;
        VectorRect.left = (VectorRect.left - ViewStatus.Position.x) *ViewStatus.ZoomIn/ViewStatus.ZoomOut;
        VectorRect.top = (VectorRect.top - ViewStatus.Position.y) *ViewStatus.ZoomIn/ViewStatus.ZoomOut;
        if (FOnPaintVector) FOnPaintVector(dcMemV, VectorRect);   // By GreenFish



        //*Ellite Basic ¿ä±¸»çÇ×À¸·Î È­»ìÇ¥ ±×¸®´Â ³ôÀÌ ³ô¿©ÁÖ´Â ºÎºÐ by linuxjun
        if (FSheet) {
          for (int i = 0; i < FSheet->Element->Count; i++) {
            dp = (TPDocElement *)FSheet->Element->Items[i];
            if (dp == NULL) continue;
            // °Ë»çÇÏ´Â ¼ø¼­¸¦ ¹Ù²Þ. (2007. 10. 31 Annualring)
            if (dp->Type == detArrow){
              arrowRect = dp->Range;// &dp->Range;

              docArrow = (TPDocArrow*)dp;
              // ¿©±â¼­  (2007. 11. 01 Annualring)
              arrowTextRect = docArrow->TextRange;

//              arrowRect = ComposeRect(arrowRect, arrowTextRect);
              if (IntersectRect(&r, &arrowRect, &Src) || IntersectRect(&r, &arrowTextRect, &Src)) {
//              dp->PaintForm(dcMemV, &vs);
                dp->PaintForm(dcMemV, &vs);

                dp->PaintReport(FSheet, dcMemV, vs, false, ((TPDocArrow *)dp)->bSelected, lang);  // 0-->Korean..
              }
            }
            #ifdef ELLITE_BASIC
            else if (dp->Type == detSheafLabel) {
            #else
            else if (dp->Type == detSheafLabel || dp->Type == detSheafLine) {
            #endif
              dp->PaintReport(FSheet, dcMemV, vs, false, dp == SelectElement, lang);  // 0-->Korean..
            }
          }
        }
        //*/


        if (FOnPaintGuideLine) FOnPaintGuideLine(dcMemV, Src);   // By minw428
        BitBlt(dcSrc, sp.x, sp.y, w, h, dcMemV, 0, 0, SRCCOPY);
        //RectPaint¿¡ Repaint°¡ ÀÖÀ¸¸é ÀÖÀ» ÇÊ¿ä°¡ ¾ø´Â °ÍÀÌ´Ù. ÁÖ¼® ó¸®  by david 090312
        //Repaint(); // ¼¿ ¼û±â±â¿¡¼­ ÀϺΠ±ôºý°Å¸² ¹× ¼±Åà ÀÌ»ó ¿¡·¯ ¼öÁ¤ by kj0821 090107
      }
    }
    __finally {
      if (dcForm) FSheet->Bitmap->DeleteDC(dcForm);
      if (dcMemV) DeleteDC(dcMemV);
      if (bmMemV) DeleteObject(bmMemV);
    }
  }
}
//---------------------------------------------------------------------------
void __fastcall TPDocument::MouseDown(TMouseButton Button, TShiftState Shift, int X, int Y)
{
  TPDocElement *dp;
  int grid;
  if (FDesign) grid = FDGridSpace;
  else         grid = FRGridSpace;

  // 2005 Vector Upgrade =-= [ Begin ] =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  // Point ¼±Åà °³¼±, Æ÷ÀÎÆ®ÀÇ ½Ç¼ö ÁÂÇ¥°¡ µé¾î°£´Ù - by monkman (2005.01.25)
  FRealPosX = ViewStatus.Position.x + (double(X*ViewStatus.ZoomOut)/ViewStatus.ZoomIn);
  FRealPosY = ViewStatus.Position.y + (double(Y*ViewStatus.ZoomOut)/ViewStatus.ZoomIn);
  // =-=-=-=-=-=-=-=-=-=-=-= [  End  ] =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-

  X = ViewStatus.View2PatternX(X);
  Y = ViewStatus.View2PatternY(Y);
  if (grid) {
    X -= X % grid;
    Y -= Y % grid;
  }

//=========================================================
  if (Shift.Contains(ssDouble) && FSheet && FSheet->Editable) {
    // Vector¿¡¼­ °î¼±±×¸®±â½Ã ´õºíŬ¸¯Çϸé Á÷¼±ÀÌ µÇ¾î¾ßÇϴµ¥ À̺κР¶§¹®¿¡ ¸·ÇôÀÖÀ½
    // ´õºí Ŭ¸¯ÀÌ µÇµµ·Ï ¼öÁ¤ - by monkman (2007.09.21)
    TControl::MouseDown(Button, Shift, X, Y);
    return;
  }

  // µå·¡±×¸¦ ÀÌ¿ëÇÑ È­¸é À̵¿, ȤÀº °¡À̵å¶órmsep ÀÎ À̵¿½Ã¸¦ À§Çؼ­ TControl::MouseDown() È£Ãâ by altang 07.05.17
  // Cursor°¡ crHandPointÀÌ°í È­»ìÇ¥³ª ½¬ÇÁ¶óÀÎÀÏ ¶§¿¡´Â ÀÌ ¾ÈÀ¸·Î µé¾î°¡¸é
  // È­»ìÇ¥ ¸ð¾ç º¯°æ¿¡¼­ ¿¡·¯°¡ ³­´Ù. µû¶ó¼­ ¾Æ·¡¿Í °°ÀÌ ¼öÁ¤ÇÏ¿´´Ù.
  // (2007. 07. 13 Annualring)
  // ´Ù½Ã ¼öÁ¤ (2007. 07. 18 Annualring)
  // Cell ´ÙÁß ¼±ÅÃÀ» À§ÇØ Ctrl, Shift°¡ °°ÀÌ ´­·¯Á® ÀÖ´Â °æ¿ì Á¦¿Ü ½ÃÅ°µµ·Ï ¼öÁ¤
  if (Shift.Contains(ssCtrl) && Button == mbLeft && !Shift.Contains(ssShift) ||
   (Cursor == crHandPoint && ( (SelectElement == NULL) || (SelectElement->Type != detArrow && SelectElement->Type != detSheafLine) ) )){

   TControl::MouseDown(Button, Shift, X, Y);
   return;
  }


  // Editability Check (2007. 01. 29 Annualring)
  if (FSheet && !FSheet->Editable)
  {
    return;
  }

  if (Button == mbLeft) {
    if (SelectElement) {
      if (dcm != dcmNone) {
        if (SelectElement->Type == detArrow) {
          if (Shift.Contains(ssShift)) {
            dcm = dcmNone;
          }
          else {
            RECT ArrowRange = Rect(FSheet->Range.right, FSheet->Range.bottom, 0, 0);
            for (int i = 0; i < FSheet->Element->Count; i++) {
              dp = (TPDocElement *)FSheet->Element->Items[i];
              if (dp == NULL) continue;
              if (dp->Type != detArrow) continue;
              if (((TPDocArrow *)dp)->bSelected == false) continue;

              dp->ControlMode = dcm;
              dp->ControlModeMouseDown(Shift, X, Y);
              ArrowSelectMouseDown = true;
              GetSelectedArrowRange((TPDocArrow *)dp, ArrowRange);
            }
            if (ArrowSelectMouseDown){
              ArrowRangeSpace.left = X - ArrowRange.left;
              ArrowRangeSpace.top = Y - ArrowRange.top;
              ArrowRangeSpace.right = ArrowRange.right - X;
              ArrowRangeSpace.bottom = ArrowRange.bottom - Y;
            }
          }
        }
        /*  for linuxjun    ÇÊ¿ä¾ø´Â ºÎºÐÀÓÀ» È®ÀÎÇßÀ½ ±×·¯¹Ç·Î ÁÖ¼®À» Ç®¸é ¾ÈµÊ.
        else if (SelectElement->Type == detSheafImage) {
          if (Shift.Contains(ssShift)) dcm = dcmNone;
          else {
            for (int i = 0; i < FSheet->Element->Count; i++) {
              dp = (TPDocElement *)FSheet->Element->Items[i];
              if (dp->Type != detSheafImage) continue;
              if (((TPDocSheafImage *)dp)->bSelected == false) continue;

              dp->ControlMode = dcm;
              dp->ControlModeMouseDown(Shift, X, Y);
            }
          }
        }//*/
		else if ((SelectElement->Type == detSheafLabel) && Shift.Contains(ssShift)) {
		  dcm = dcmNone;
		}
        else {
          SelectElement->ControlMode = dcm;
          SelectElement->ControlModeMouseDown(Shift, X, Y);
          dcm = dcmNone;
        }
        Refresh();
      }
    } else dcm = dcmNone;
  } else if (Button == mbRight) {
     if (SelectElement) {
       if (dcm == dcmSelect && SelectElement->Type == detChart && FFormulaMode == false && FSetDateMode == false) {
          ((TPDocChart *)SelectElement)->ConsiderRightButton(TGraphicControl::Canvas->Handle, ViewStatus, X, Y);
       } else if (SelectElement->Type == detArrow) return;
     } else dcm = dcmNone;
  }
  if (SelectElement && SelectElement->Type == detArrow && Shift.Contains(ssShift))
  	TControl::MouseDown(Button, Shift, X, Y);
  /* for linuxjun     ÇÊ¿ä¾ø´Â ºÎºÐÀÓÀ» È®ÀÎÇßÀ½ ±×·¯¹Ç·Î ÁÖ¼®À» Ç®¸é ¾ÈµÊ.
  else if (SelectElement && SelectElement->Type == detSheafImage && Shift.Contains(ssShift))
  	TControl::MouseDown(Button, Shift, X, Y);
  //*/
  else if (SelectElement && SelectElement->ControlMode != dcmNone) {
    if(SelectElement->Type == detChart) {
      ((TPDocChart *)SelectElement)->SetSheet(FSheet);    //For Undo
    }

  	TControl::MouseDown(Button, Shift, X, Y);
    if(FFormulaMode == false && FSetDateMode == false)
    {//¼ö½ÄÀÔ·ÂÀ» ÇÏ°í ÀÖÁö ¾ÊÀ»¶§¸¸ ½ÇÇà
      if(Shift.Contains(ssCtrl) && Shift.Contains(ssShift))
        ((TPDocChart *)SelectElement)->MultiSelect(TGraphicControl::Canvas->Handle, ViewStatus, X, Y);
      else
        SelectElement->ControlModeMouseMove(TGraphicControl::Canvas->Handle, ViewStatus, X, Y);
    }

  } else {
//    FSheet->SelectUndoSave();
  	TControl::MouseDown(Button, Shift, X, Y);
  }
/*
  if (Button == mbLeft && !Shift.Contains(ssDouble)) {
    if (dcm != dcmNone) {
      SelectElement->ControlMode = dcm;
      SelectElement->ControlModeMouseDown(X, Y);
      dcm = dcmNone;
      Refresh();
    }
  }
  if (SelectElement && SelectElement->ControlMode != dcmNone) {
    SelectElement->ControlModeMouseMove(TGraphicControl::Canvas->Handle, ViewStatus, X, Y);
  } else {
  	TControl::MouseDown(Button, Shift, X, Y);
  }
*/
//=========================================================
}
//---------------------------------------------------------------------
void __fastcall TPDocument::MouseMove(TShiftState Shift, int X, int Y)
{
  TPDocElement *dp;
	int px, py;
  RECT rc;
  int grid;
  if (FDesign) grid = FDGridSpace;
  else         grid = FRGridSpace;

  // 2005 Vector Upgrade =-= [ Begin ] =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  // Point ¼±Åà °³¼±, Æ÷ÀÎÆ®ÀÇ ½Ç¼ö ÁÂÇ¥°¡ µé¾î°£´Ù - by monkman (2005.01.25)
  FRealPosX = ViewStatus.Position.x + (double(X*ViewStatus.ZoomOut)/ViewStatus.ZoomIn);
  FRealPosY = ViewStatus.Position.y + (double(Y*ViewStatus.ZoomOut)/ViewStatus.ZoomIn);
  // =-=-=-=-=-=-=-=-=-=-=-= [  End  ] =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-

  X = ViewStatus.View2PatternX(X);
  Y = ViewStatus.View2PatternY(Y);

//==================================================================== maybe be modified....
  if (FDesign) {       // Design Tool
    if (SelectElement && SelectElement->ControlMode == dcmNone && FFormulaMode == false) {
      dcm = SelectElement->GetControlMode(X, Y);
      Cursor = GetCursor(dcm);
    } else {
      dcm = dcmNone;
      Cursor = GetCursor(dcmNone);
    }
  } else {             // Report Tool
//====================================================================
    if (SelectElement) {
      if (SelectElement->Type == detSheafImage || SelectElement->Type == detSheafLabel
      || SelectElement->Type == detSheafLine) {
        if (SelectElement && SelectElement->ControlMode == dcmNone) {
          dcm = SelectElement->GetControlMode(X, Y);
          Cursor = GetCursor(dcm);
        }
      }
      else if (SelectElement->Type == detArrow) {
        for (int i = 0; i < FSheet->Element->Count; i++) {
          dp = (TPDocElement *)FSheet->Element->Items[i];
          if (dp == NULL) continue;
          if (dp->Type != detArrow) continue;
          if (((TPDocArrow *)dp)->bSelected == false) continue;

          dcm = dp->GetControlMode(X, Y);
          if (dcm == dcmMove) break;
        }
        Cursor = GetCursor(dcm);
      }
    } else {
      dcm = dcmNone;
      Cursor = GetCursor(dcmNone);
    }
  }
//====================================================================
  if (grid) {
    X -= X % grid;
    Y -= Y % grid;
  }
  if (SelectElement && SelectElement->ControlMode != dcmNone) {
    if (SelectElement->Type == detArrow) {
      int nowX = X;
      int nowY = Y;
      if (ArrowSelectMouseDown){
        if (X < ArrowRangeSpace.left) nowX = ArrowRangeSpace.left;
        if (X + ArrowRangeSpace.right > FSheet->Range.right) nowX = FSheet->Range.right - ArrowRangeSpace.right;
        if (Y < ArrowRangeSpace.top) nowY = ArrowRangeSpace.top;
        if (Y + ArrowRangeSpace.bottom > FSheet->Range.bottom) nowY = FSheet->Range.bottom - ArrowRangeSpace.bottom;
        for (int i = 0; i < FSheet->Element->Count; i++) {
          dp = (TPDocElement *)FSheet->Element->Items[i];
          if (dp == NULL) continue;
          if (dp->Type != detArrow) continue;
          if (dp->ControlMode == dcmNone) continue;
          if (((TPDocArrow *)dp)->bSelected == false) continue;
          FSheet->ElementMoveUndoSave();
          FSheet->UndoSave(dp);   //For Undo
          dp->ControlModeMouseMove(TGraphicControl::Canvas->Handle, ViewStatus, nowX, nowY);
        }
      }
    } else {
      if (!FDesign) {
        FSheet->ElementMoveUndoSave();
        FSheet->UndoSave(SelectElement);   //For Undo
      }
      if(FFormulaMode == false && FSetDateMode == false)
      {//¼ö½ÄÀÔ·ÂÀ» ÇÏ°í ÀÖÁö ¾ÊÀ»¶§¸¸ ½ÇÇà
        if(Shift.Contains(ssCtrl) == false || Shift.Contains(ssShift) == false)
          SelectElement->ControlModeMouseMove(TGraphicControl::Canvas->Handle, ViewStatus, X, Y);
      }
    }
  } else {
    TControl::MouseMove(Shift, X, Y);
  }
}
//---------------------------------------------------------------------
void __fastcall TPDocument::MouseUp(TMouseButton Button, TShiftState Shift, int X, int Y)
{
  TPDocElement *dp;
	int px, py;
  RECT rc;
  int grid;
  if (FDesign) grid = FDGridSpace;
  else         grid = FRGridSpace;

  // 2005 Vector Upgrade =-= [ Begin ] =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
  // Point ¼±Åà °³¼±, Æ÷ÀÎÆ®ÀÇ ½Ç¼ö ÁÂÇ¥°¡ µé¾î°£´Ù - by monkman (2005.01.25)
  FRealPosX = ViewStatus.Position.x + (double(X*ViewStatus.ZoomOut)/ViewStatus.ZoomIn);
  FRealPosY = ViewStatus.Position.y + (double(Y*ViewStatus.ZoomOut)/ViewStatus.ZoomIn);
  // =-=-=-=-=-=-=-=-=-=-=-= [  End  ] =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-

  X = ViewStatus.View2PatternX(X);
  Y = ViewStatus.View2PatternY(Y);
  if (grid) {
    X -= X % grid;
    Y -= Y % grid;
  }
  int nowX = X;
  int nowY = Y;

  if (SelectElement && SelectElement->ControlMode != dcmNone) {
    if (SelectElement->Type == detArrow) {
      int nowX = X;
      int nowY = Y;
      if (ArrowSelectMouseDown){
        if (X < ArrowRangeSpace.left) nowX = ArrowRangeSpace.left;
        if (X + ArrowRangeSpace.right > FSheet->Range.right) nowX = FSheet->Range.right - ArrowRangeSpace.right;
        if (Y < ArrowRangeSpace.top) nowY = ArrowRangeSpace.top;
        if (Y + ArrowRangeSpace.bottom > FSheet->Range.bottom) nowY = FSheet->Range.bottom - ArrowRangeSpace.bottom;

        for (int i = 0; i < FSheet->Element->Count; i++) {
          dp = (TPDocElement *)FSheet->Element->Items[i];
          if (dp == NULL) continue;
          if (dp->Type != detArrow) continue;
          if (dp->ControlMode == dcmNone) continue;
          if (((TPDocArrow *)dp)->bSelected == false) continue;
            dp->GetNewRange(nowX, nowY);
            dp->ControlModeMouseUp();
            dp->ControlMode = dcmNone;
        }
        ArrowSelectMouseDown = false;
      }
    } else {
      SelectElement->GetNewRange(X, Y);
      SelectElement->ControlModeMouseUp();
      SelectElement->ControlMode = dcmNone;
      //Refresh();
    }
    Refresh();
  } else {
    TControl::MouseUp(Button, Shift, X, Y);
  }
}
//---------------------------------------------------------------------
void __fastcall TPDocument::KeyDown(int Key)
{
}
//---------------------------------------------------------------------
// Public Function
//---------------------------------------------------------------------------
void __fastcall TPDocument::RemoveData()
{
  SelectElement = NULL;
  FSheet->RemoveData();
  dcm = dcmNone;
  Refresh();
}
//---------------------------------------------------------------------------
void __fastcall TPDocument::RemoveSelect()
{
  TPDocElement *dp;
  if (SelectElement->Type == detArrow||SelectElement->Type == detSheafImage) {
    for (int i = 0; i < FSheet->Element->Count; i++) {
      dp = (TPDocElement *)FSheet->Element->Items[i];
      if (dp == NULL) continue;
      switch(dp->Type){
        case detArrow:
          if (((TPDocArrow *)dp)->bSelected){
            FSheet->RemoveData(dp);
            i--;
            dp = NULL;
          }
          break;
        case detSheafImage:
          if (((TPDocSheafImage *)dp)->bSelected){
            FSheet->RemoveData(dp);
            i--;
            dp = NULL;
          }
          break;
        default:
          break;
      }
    }

  } else
  {
    if(SelectElement->Type == detChart){
      for(int i = 0; i < ((TPDocChart*)SelectElement)->Cell->Count; i++){
        TPDocElement* sep = ((TPDocChart*)SelectElement)->getCell(i);
        if (sep == NULL) continue;
        if(sep->NowSelect)
        {
          continue;
        }
        else
        {
          // erase cell
          ((TPDocChart*)SelectElement)->RemoveSelectedCell();
          SelectElement = NULL;
          dcm = dcmNone;
          Refresh();
          return;
        }
      }
    }

    Sheet->RemoveData(SelectElement);
  }


  //
  /*    //for  Qe
  if (SelectElement->Type == detArrow) {
    for (int i = 0; i < FSheet->Element->Count; i++) {
      dp = (TPDocElement *)FSheet->Element->Items[i];
      if (dp->Type != detArrow) continue;
      if (((TPDocArrow *)dp)->bSelected == false) continue;

      FSheet->RemoveData(dp);
      i--;
      dp = NULL;
    }
  } else if(SelectElement->Type == detSheafImage) {
    for (int i = 0; i < FSheet->Element->Count; i++) {
      dp = (TPDocElement *)FSheet->Element->Items[i];
      if (dp->Type != detSheafImage) continue;
      if (((TPDocSheafImage *)dp)->bSelected == false) continue;

      FSheet->RemoveData(dp);
      i--;
      dp = NULL;
    }

  } else FSheet->RemoveData(SelectElement);
  */
  SelectElement = NULL;
  dcm = dcmNone;
  Refresh();
}
//---------------------------------------------------------------------------
int __fastcall TPDocument::GetSelectedArrowNum()
{
  TPDocElement *dp;
  int nResult=0;
  if (SelectElement->Type == detArrow) {
    for (int i = 0; i < FSheet->Element->Count; i++) {
      dp = (TPDocElement *)FSheet->Element->Items[i];
      if (dp == NULL) continue;
      if (dp->Type != detArrow) continue;
      if (((TPDocArrow *)dp)->bSelected == false) continue;
      nResult++;
    }
  }
  Refresh();
  return nResult;
}
//---------------------------------------------------------------------------
int __fastcall TPDocument::GetSelectedEltNum()         //for  Qe
{
  TPDocElement *dp;
  int nResult=0;
  for (int i = 0; i < FSheet->Element->Count; i++) {
    dp = (TPDocElement *)FSheet->Element->Items[i];
    if (dp == NULL) continue;    
    switch(dp->Type){
      case detArrow:
        if (((TPDocArrow *)dp)->bSelected){
          nResult++;
        }
        break;
      case detSheafImage:
        if (((TPDocSheafImage *)dp)->bSelected){
          nResult++;
        }
        break;
      default:
        break;
    }
  }
  Refresh();
  return nResult;
}
//---------------------------------------------------------------------------
bool __fastcall TPDocument::Select(POINT pt, bool paint, bool bShift)
{
  SelectElement = FSheet->Select(pt, FDesign, bShift);
  if (paint)
    Refresh();
  return SelectElement != NULL;
}
                         
//---------------------------------------------------------------------------
// ¿ø·¡ÀÇ SelectÇÔ¼ö¿¡ ¼±ÅÃÇÒ Element¸¦ ÀǹÌÇÏ´Â ¸Å°³º¯¼ö targetElement¸¦ Ãß°¡
// ¸í½ÃÀûÀ¸·Î Element¸¦ ¼±ÅÃÇÒ ¼ö ÀÖ°Ô ¸¸µë. (2007. 04. 16 Annualring)
bool __fastcall TPDocument::ElementSelect(POINT pt, bool paint, bool bShift, TPDocElement *targetElement)
{
  SelectElement = FSheet->ElementSelect(pt, FDesign, bShift, targetElement);
  if (paint)
    Refresh();
  return SelectElement != NULL;
}
//---------------------------------------------------------------------------
void __fastcall TPDocument::SetPosition(int x, int y)
{
  ViewStatus.Position.x = x; ViewStatus.Position.y = y;
  Refresh();
}
//---------------------------------------------------------------------------
HDC __fastcall TPDocument::GetHandle()
{
  return TGraphicControl::Canvas->Handle;
}
//---------------------------------------------------------------------------
TCanvas *__fastcall TPDocument::GetCanvas()
{
  return TGraphicControl::Canvas;
}
//---------------------------------------------------------------------------
void __fastcall TPDocument::SetZoom(int zi, int zo)
{
  if (ViewStatus.ZoomIn != zi || ViewStatus.ZoomOut != zo) {
    ViewStatus.ZoomIn = zi;
    ViewStatus.ZoomOut = zo;
    Refresh();
  }
}
//---------------------------------------------------------------------------
TPDocElement * __fastcall TPDocument::GetSelectElement(bool subelement)
{
  // CodeGuard Error ¼öÁ¤ NULLÀε¥ NULL·Î Ç¥½Ã°¡ ¾È µÈ »óÅ·Π¸®ÅϵǴ °æ¿ì ¹æÁö
  // (2007. 11. 13 Annualring)
  TPDocElement *sp = NULL;
  try{
    if (subelement) {
       if (SelectElement->Type == detInput) {
        sp = ((TPDocInput *)SelectElement)->IPElement;
      } else if (SelectElement->Type == detChart) {
        sp = ((TPDocChart *)SelectElement)->GetSelectElement();
      }
    } else {
      SelectElement->Type;
      sp = SelectElement;
    }
    return sp;
  }
  catch(Exception &e){
    return NULL;
  }
}                                                                               
//---------------------------------------------------------------------------
TPDocElement * __fastcall TPDocument::GetCellValue(int index)
{
  TPDocElement *sp;
  sp = ((TPDocChart *)SelectElement)->getCell(index);
  return sp;
}
//---------------------------------------------------------------------------
void __fastcall TPDocument::GetSelectedArrowRange(TPDocArrow *arrow, RECT &range)
{
  int arrowLeft, arrowTop, arrowRight, arrowBottom;

  if (arrow->FOldArrow[0].x < arrow->FOldArrow[1].x){
    if (arrow->AType == dat3Point){
      if (arrow->FOldArrow[0].x < arrow->FOldArrow[2].x){
        arrowLeft = arrow->FOldArrow[0].x;
        if (arrow->FOldArrow[1].x < arrow->FOldArrow[2].x){
          arrowRight = arrow->FOldArrow[2].x;
        }
        else {
          arrowRight = arrow->FOldArrow[1].x;
        }
      }
      else {
        arrowLeft = arrow->FOldArrow[2].x;
        if (arrow->FOldArrow[0].x < arrow->FOldArrow[1].x){
          arrowRight = arrow->FOldArrow[1].x;
        }
        else {
          arrowRight = arrow->FOldArrow[0].x;
        }
      }
    }
    else {
      arrowLeft = arrow->FOldArrow[0].x;
      arrowRight = arrow->FOldArrow[1].x;
    }
  }
  else {
    if (arrow->AType == dat3Point){
      if (arrow->FOldArrow[1].x < arrow->FOldArrow[2].x){
        arrowLeft = arrow->FOldArrow[1].x;
        if (arrow->FOldArrow[0].x < arrow->FOldArrow[2].x){
          arrowRight = arrow->FOldArrow[2].x;
        }
        else {
          arrowRight = arrow->FOldArrow[0].x;
        }
      }
      else {
        arrowLeft = arrow->FOldArrow[2].x;
        if (arrow->FOldArrow[0].x < arrow->FOldArrow[1].x){
          arrowRight = arrow->FOldArrow[1].x;
        }
        else {
          arrowRight = arrow->FOldArrow[0].x;
        }
      }
    }
    else {
      arrowLeft = arrow->FOldArrow[1].x;
      arrowRight = arrow->FOldArrow[0].x;
    }
  }
  if (arrow->FOldArrow[0].y < arrow->FOldArrow[1].y){
    if (arrow->AType == dat3Point){
      if (arrow->FOldArrow[0].y < arrow->FOldArrow[2].y){
        arrowTop = arrow->FOldArrow[0].y;
        if (arrow->FOldArrow[1].y < arrow->FOldArrow[2].y){
          arrowBottom = arrow->FOldArrow[2].y;
        }
        else {
          arrowBottom = arrow->FOldArrow[1].y;
        }
      }
      else {
        arrowTop = arrow->FOldArrow[2].y;
        if (arrow->FOldArrow[0].y < arrow->FOldArrow[1].y){
          arrowBottom = arrow->FOldArrow[1].y;
        }
        else {
          arrowBottom = arrow->FOldArrow[0].y;
        }
      }
    }
    else {
      arrowTop = arrow->FOldArrow[0].y;
      arrowBottom = arrow->FOldArrow[1].y;
    }
  }
  else {
    if (arrow->AType == dat3Point){
      if (arrow->FOldArrow[1].y < arrow->FOldArrow[2].y){
        arrowTop = arrow->FOldArrow[1].y;
        if (arrow->FOldArrow[0].y < arrow->FOldArrow[2].y){
          arrowBottom = arrow->FOldArrow[2].y;
        }
        else {
          arrowBottom = arrow->FOldArrow[0].y;
        }
      }
      else {
        arrowTop = arrow->FOldArrow[2].y;
        if (arrow->FOldArrow[0].y < arrow->FOldArrow[1].y){
          arrowBottom = arrow->FOldArrow[1].y;
        }
        else {
          arrowBottom = arrow->FOldArrow[0].y;
        }
      }
    }
    else {
      arrowTop = arrow->FOldArrow[1].y;
      arrowBottom = arrow->FOldArrow[0].y;
    }
  }

  if (range.left > arrowLeft) range.left = arrowLeft;
  if (range.top > arrowTop) range.top = arrowTop;
  if (range.right < arrowRight) range.right = arrowRight;
  if (range.bottom < arrowBottom) range.bottom = arrowBottom;
}
//---------------------------------------------------------------------------
void __fastcall TPDocument::ResetSelectElement()
{
  if (SelectElement) {
//    FSheet->SelectUndoSave();
    SelectElement = NULL;
    dcm = dcmNone;
  }
}
//---------------------------------------------------------------------------
RECT __fastcall TPDocument::ChangeRect(RECT rc)
{

  rc.left = ViewStatus.Pattern2ViewX(rc.left);
  rc.top = ViewStatus.Pattern2ViewY(rc.top);
  rc.right = ViewStatus.Pattern2ViewX(rc.right);
  rc.bottom = ViewStatus.Pattern2ViewY(rc.bottom);
  return rc;
}
//---------------------------------------------------------------------------
POINT __fastcall TPDocument::ChangePoint(POINT tp)
{
  tp.x = ViewStatus.Pattern2ViewX(tp.x);
  tp.y= ViewStatus.Pattern2ViewY(tp.y);
  return tp;
}
//---------------------------------------------------------------------------
TPDocViewStatus __fastcall TPDocument::GetViewStatus()
{
  return ViewStatus;
}
//---------------------------------------------------------------------------
int __fastcall TPDocument::GetSheetID()
{
  return FSheet->ID;
}
//---------------------------------------------------------------------------
namespace Tpdocument
{
  void __fastcall PACKAGE Register()
  {
    TComponentClass classes[1] = {__classid(TPDocument)};
    RegisterComponents("Texpia", classes, 0);
  }
}
//---------------------------------------------------------------------------