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


#pragma hdrstop

#include "VectorRepeat.h"
//---------------------------------------------------------------------------

#pragma package(smart_init)

#define CM_PER_INCH 2.54

// Constructor
__fastcall TVectorRepeat::TVectorRepeat() {	
	mMainImage = NULL;
	mSrcBitmap = NULL;
	mSrcMask = NULL;
	mPreviewBitmap = NULL;
	mPreviewMask = NULL;
	mPreviewMaskOrg = NULL;

	mSrcDataList = NULL;
	mDstBufferDataList = NULL;
	mDstDataList = NULL;

	mSrcRect = Rect(0, 0, 0, 0);

	mIsInitialized = false;
	mMode = REPEAT_NORMAL;
	mIsCutObject = false;
	mGapX = 0;
	mGapY = 0;
	mIsUsedCount = false;
	mCountX = 1;
	mCountY = 1;
	mHalfDropMaxLength = 0;
	mHalfDropLength = 0;
}
//---------------------------------------------------------------------------

// Destructor
__fastcall TVectorRepeat::~TVectorRepeat() {
	if (mSrcDataList != NULL) {
		mSrcDataList->Clear();
		delete mSrcDataList;
		mSrcDataList = NULL;
	}
	if (mDstBufferDataList != NULL) {
		mDstBufferDataList->Clear();
		delete mDstBufferDataList;
		mDstBufferDataList = NULL;
	}
	if (mSrcBitmap != NULL) {
		delete mSrcBitmap;
		mSrcBitmap = NULL;
	}
	if (mSrcMask != NULL) {
		delete mSrcMask;
		mSrcMask = NULL;
	}
	if (mPreviewMaskOrg != NULL) {
		delete mPreviewMaskOrg;
		mPreviewMaskOrg = NULL;
	}

	mMainImage->SubVisible = false;
	mMainImage->SubEnabled = false;
	mMainImage->SubMethod = false;
}
//---------------------------------------------------------------------------

// Initialize
bool __fastcall TVectorRepeat::Initialize(TMainImageForm *mif) {
	BEGIN_LOG("");

	mMainImage = mif->iMainImage;
	mDpi = mif->CanvasInfor.DotsPerInch;

	// Set Preview Enabled
	mMainImage->SubVisible = true;
	mMainImage->SubEnabled = true;
	mMainImage->SubMethod = true;

	mSrcDataList = new TList();
	mDstBufferDataList = new TList();
	mDstDataList = mif->V_DATA;

	// Set List & Region of Source Vector Data
	mSrcRect = TRect(MaxInt, MaxInt, 0, 0);
	TList *dataList = mif->V_DATA;
	for (int idx = 0; idx < dataList->Count; idx++) {
		TVecData *obj = static_cast<TVecData*>(dataList->Items[idx]);
		if (obj->bSelected == true) {
			TRect objRect = TRect(obj->First.x - obj->PenThick / 2, obj->First.y - obj->PenThick / 2,
				obj->Second.x + obj->PenThick / 2, obj->Second.y + obj->PenThick / 2);
			
			// Set Source Rect
			mSrcRect.Left = min(mSrcRect.Left, objRect.Left);
			mSrcRect.Top = min(mSrcRect.Top, objRect.Top);
			mSrcRect.Right = max(mSrcRect.Right, objRect.Right);
			mSrcRect.Bottom = max(mSrcRect.Bottom, objRect.Bottom);

			// Add to DataList
			mSrcDataList->Add(obj);
		}
	}
	// Apply Gap to Source Region
	mSrcRect.Right += mGapX;
	mSrcRect.Bottom += mGapY;

	// If there is No Source Data, Fail in Initialization.
	if (mSrcDataList->Count == 0) {
		END_LOG;
		return false;
  }

	// Create Source & Preview Bitmap / Mask
	mSrcBitmap = new TTexpiaBitmap();
	mSrcMask = new TTexpiaBitmap();
	mPreviewBitmap = mMainImage->SubBitmap;
	mPreviewMask = mMainImage->SubMask;
	mPreviewMaskOrg = new TUnionBitmap();
	int previewWidth = mMainImage->uBitmap->Width;
	int previewHeight = mMainImage->uBitmap->Height;	
	
	if (mMainImage->uBitmap->BitsPerPixel == 8) {
		RGBQUAD rgb[256];
		mif->Palette->ToRGBQUAD(rgb, 256);
		mSrcBitmap->Create(mSrcRect.Width() - mGapX, mSrcRect.Height() - mGapY, 8, rgb);
		mSrcMask->Create(mSrcRect.Width() - mGapX, mSrcRect.Height() - mGapY, 8, rgb);
		mSrcMask->FillRect(Rect(0, 0, mSrcBitmap->Width, mSrcBitmap->Height), PALETTEINDEX(0xFF));

		mPreviewBitmap->Create(previewWidth, previewHeight, 8, rgb);
		mPreviewMask->Create(previewWidth, previewHeight, 8, rgb);
		mPreviewMaskOrg->Create(previewWidth, previewHeight, 8, rgb);		
	}
	else {
		mSrcBitmap->Create(mSrcRect.Width() - mGapX, mSrcRect.Height() - mGapY, 24);
		mSrcMask->Create(mSrcRect.Width() - mGapX, mSrcRect.Height() - mGapY, 1);
		mSrcMask->FillRect(Rect(0, 0, mSrcBitmap->Width, mSrcBitmap->Height), clWhite);
		
		mPreviewBitmap->Create(previewWidth, previewHeight, 24);
		mPreviewMask->Create(previewWidth, previewHeight, 24);
		mPreviewMaskOrg->Create(previewWidth, previewHeight, 24);
	}

	// Paint Source Vector Data to Bitmap & Mask For Using Preview Step
	HDC dcSrcBmp = mSrcBitmap->CreateDC();
	HDC dcSrcBmpMask = mSrcMask->CreateDC();
	bool orgbCancelAntialiasing = VecDraw->NVector->bCancelAntialiasing;
	VecDraw->NVector->bCancelAntialiasing = true;
	VecDraw->ConvertToBitmap(dcSrcBmp, mSrcDataList, mif, mSrcRect.Left, mSrcRect.Top, false, false);
	VecDraw->ConvertToBitmapMask(dcSrcBmpMask, mSrcDataList, mif, mSrcRect.Left, mSrcRect.Top);
	VecDraw->NVector->bCancelAntialiasing = orgbCancelAntialiasing;
	if (dcSrcBmp)
		mSrcBitmap->DeleteDC(dcSrcBmp);
	if (dcSrcBmpMask)
		mSrcMask->DeleteDC(dcSrcBmpMask);

	// Initialize Preview Region
	mMainImage->SubRange.left = 0;
	mMainImage->SubRange.top = 0;
	mMainImage->SubRange.right = 0;
	mMainImage->SubRange.bottom = 0;
	
  // Initialization Completed
	mIsInitialized = true;

	// Set Preview Bitmap
	SetPreviewBitmap();
	
	END_LOG;
	return true;
}
//---------------------------------------------------------------------------

void __fastcall TVectorRepeat::SetMode(EVecRepeatMode mode) {
	if (mMode != mode) {
		mMode = mode;
		if (mMode == REPEAT_HDHOR) {
			mHalfDropMaxLength = mSrcRect.Width();
			mHalfDropLength = mHalfDropMaxLength / 2;
		}
		else if (mMode == REPEAT_HDVER) {
			mHalfDropMaxLength = mSrcRect.Height();
			mHalfDropLength = mHalfDropMaxLength / 2;
		}
		SetPreviewBitmap();
	}
}
//---------------------------------------------------------------------------

void __fastcall TVectorRepeat::SetIsCutObject(bool isCutObj) {
	if (mIsCutObject != isCutObj) {
		mIsCutObject = isCutObj;
	}
}
//---------------------------------------------------------------------------

void __fastcall TVectorRepeat::SetGapUnit(TUnit unit) {
	mGapUnit = unit;
}
//---------------------------------------------------------------------------

void __fastcall TVectorRepeat::SetGapX(float value) {
	int gap = 0;
	switch (mGapUnit) {
		case uDot:
			gap = value;
			break;
		case uInch:
			gap = value * mDpi + 0.5;
			break;
		case uCm:
			gap = value * mDpi / CM_PER_INCH + 0.5;
			break;
	}

	if (mGapX != gap) {
		mSrcRect.Right -= mGapX;
		mGapX = gap;
		mSrcRect.Right += mGapX;
		SetPreviewBitmap();
	}
}
//---------------------------------------------------------------------------

void __fastcall TVectorRepeat::SetGapY(float value) {
	int gap = 0;
	switch (mGapUnit) {
		case uDot:
			gap = value;
			break;
		case uInch:
			gap = value * mDpi + 0.5;
			break;
		case uCm:
			gap = value * mDpi / CM_PER_INCH + 0.5;
			break;
	}

	if (mGapY != gap) {
		mSrcRect.Bottom -= mGapY;
		mGapY = gap;
		mSrcRect.Bottom += mGapY;
		SetPreviewBitmap();
	}
}
//---------------------------------------------------------------------------

float __fastcall TVectorRepeat::GetGapX() {
	switch (mGapUnit) {
		case uDot:
			return mGapX;
		case uInch:
			return (float)mGapX / (float)mDpi;
		case uCm:
			return CM_PER_INCH * (float)mGapX / (float)mDpi;
	}
}
//---------------------------------------------------------------------------

float __fastcall TVectorRepeat::GetGapY() {
	switch (mGapUnit) {
		case uDot:
			return mGapY;
		case uInch:
			return (float)mGapY / (float)mDpi;
		case uCm:
			return CM_PER_INCH * (float)mGapY / (float)mDpi;
	}
}
//---------------------------------------------------------------------------

void __fastcall TVectorRepeat::SetIsUsedCount(bool isUsedCnt) {
	if (mIsUsedCount != isUsedCnt) {
		mIsUsedCount = isUsedCnt;
		SetPreviewBitmap();
	}
}
//---------------------------------------------------------------------------

void __fastcall TVectorRepeat::SetFixedCountX(int cnt) {
	if (mFixedCountX != cnt) {
		mFixedCountX = cnt;
	}
}
//---------------------------------------------------------------------------

void __fastcall TVectorRepeat::SetFixedCountY(int cnt) {
	if (mFixedCountY != cnt) {
		mFixedCountY = cnt;
	}
}
//---------------------------------------------------------------------------

void __fastcall TVectorRepeat::SetHalfDropLength(int length) {
	if (mHalfDropLength != length) {
		mHalfDropLength = length;
		SetPreviewBitmap();
  }
}
//---------------------------------------------------------------------------

// Set Preview Bitmap
void __fastcall TVectorRepeat::SetPreviewBitmap() {
	BEGIN_LOG("");

	// Set Preview Bitmap Only If Initialization is completed.
	if (mIsInitialized == false) {
		END_LOG;
		return;
  }

	TCursor orgCursor = Screen->Cursor;
	Screen->Cursor = crHourGlass;

	// Initialize Preview Bitmap & Mask
	if (mMainImage->uBitmap->BitsPerPixel == 8)		
		mPreviewMaskOrg->FillRect(Rect(0, 0, mPreviewMaskOrg->Width, mPreviewMaskOrg->Height), PALETTEINDEX(0xFF));
	else
		mPreviewMaskOrg->FillRect(Rect(0, 0, mPreviewMaskOrg->Width, mPreviewMaskOrg->Height), clWhite);

	HDC dcSrcBmp = mSrcBitmap->CreateDC();
	HDC dcSrcBmpMask = mSrcMask->CreateDC();

	int x, y, p;
	switch (mMode) {
		case REPEAT_NORMAL:
			y = mSrcRect.Top % mSrcRect.Height();
			if (y > 0)
				y -= mSrcRect.Height();
			for (; y < mPreviewBitmap->Height; y += mSrcRect.Height()) {
				x = mSrcRect.Left % mSrcRect.Width();
				if (x > 0)
					x -= mSrcRect.Width();
				for (; x < mPreviewBitmap->Width; x += mSrcRect.Width()) {
					mPreviewBitmap->UnionBitBlt(dcSrcBmp, x, y, mSrcBitmap->Width, mSrcBitmap->Height, 0, 0, SRCCOPY, true);
					mPreviewMaskOrg->UnionBitBlt(dcSrcBmpMask, x, y, mSrcMask->Width, mSrcMask->Height, 0, 0, SRCCOPY, true);
				}
			}
			break;

		case REPEAT_HDHOR:
			y = mSrcRect.Top % mSrcRect.Height();
			if (y > 0)
				y -= mSrcRect.Height();

			p = mSrcRect.Left - mHalfDropLength * (mSrcRect.Top - y) / mSrcRect.Height();
			for (; y < mPreviewBitmap->Height; y += mSrcRect.Height(), p += mHalfDropLength) {
				x = p % mSrcRect.Width();
				if (x > 0)
					x -= mSrcRect.Width();
				for (; x < mPreviewBitmap->Width; x += mSrcRect.Width()) {
					mPreviewBitmap->UnionBitBlt(dcSrcBmp, x, y, mSrcBitmap->Width, mSrcBitmap->Height, 0, 0, SRCCOPY, true);
					mPreviewMaskOrg->UnionBitBlt(dcSrcBmpMask, x, y, mSrcMask->Width, mSrcMask->Height, 0, 0, SRCCOPY, true);
				}
			}
			break;

		case REPEAT_HDVER:
			x = mSrcRect.Left % mSrcRect.Width();
			if (x > 0)
				x -= mSrcRect.Width();

			p = mSrcRect.Top - mHalfDropLength * (mSrcRect.Left - x) / mSrcRect.Width();
			for (; x < mPreviewBitmap->Width; x += mSrcRect.Width(), p += mHalfDropLength) {
				y = p % mSrcRect.Height();
				if (y > 0)
					y -= mSrcRect.Height();
				for (; y < mPreviewBitmap->Height; y += mSrcRect.Height()) {
					mPreviewBitmap->UnionBitBlt(dcSrcBmp, x, y, mSrcBitmap->Width, mSrcBitmap->Height, 0, 0, SRCCOPY, true);
					mPreviewMaskOrg->UnionBitBlt(dcSrcBmpMask, x, y, mSrcMask->Width, mSrcMask->Height, 0, 0, SRCCOPY, true);
				}
			}
			break;
	}
	
	if (dcSrcBmp)
		mSrcBitmap->DeleteDC(dcSrcBmp);
	if (dcSrcBmpMask)
		mSrcMask->DeleteDC(dcSrcBmpMask);

	Screen->Cursor = orgCursor;

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

// Set Preview Mask
void __fastcall TVectorRepeat::SetPreviewMask(RECT previewRect) {
	BEGIN_LOG("");

	// Copy From Original Mask For Preview Region
	mPreviewMask->CopyUsingBitBlt(previewRect.left, previewRect.top,
		previewRect.right - previewRect.left, previewRect.bottom - previewRect.top, mPreviewMaskOrg, SRCCOPY);

	// If Mode is Half Drop Mode, FixedCount Isn't Used and Doesn't cut Vector Object,
	// Region of Mask
	// Half Drop ModeÀÏ ¶§ ¹Ýº¹ °³¼ö¸¦ »ç¿ëÇÏÁö ¾Ê°í Vector Oject¸¦ ÀÚ¸£Áö ¾Ê´Â °æ¿ì 
	// Mask 󸮸¦ ÅëÇØ ¹Ì¸®º¸±â¿¡¼­ º¸ÀÌÁö ¾Ê¾Æ¾ß ÇÒ Oject¸¦ °¡¸°´Ù
	if (mIsUsedCount == true || mIsCutObject == false) {
		int x, y, p;
		if (mMode == REPEAT_HDHOR) {
			y = previewRect.top + (mSrcRect.Top - previewRect.top) % mSrcRect.Height();
			if (y > previewRect.top)
				y -= mSrcRect.Height();

			p = - mHalfDropLength * (mSrcRect.Top - y) / mSrcRect.Height();
			while (y < previewRect.bottom) {
				x = previewRect.left + p % mSrcRect.Width();
				if (x > previewRect.left)
					x -= mSrcRect.Width();
				if (mMainImage->uBitmap->BitsPerPixel == 8)
					mPreviewMask->FillRect(Rect(previewRect.left, y, x + mSrcRect.Width(), y + mSrcMask->Height), PALETTEINDEX(0xFF));
				else
					mPreviewMask->FillRect(Rect(previewRect.left, y, x + mSrcRect.Width(), y + mSrcMask->Height), clWhite);	

				x += (previewRect.right - previewRect.left);
				if (x >= previewRect.right)
					x -= mSrcRect.Width();
				if (mMainImage->uBitmap->BitsPerPixel == 8)
					mPreviewMask->FillRect(Rect(x, y, previewRect.right, y + mSrcMask->Height), PALETTEINDEX(0xFF));
				else
					mPreviewMask->FillRect(Rect(x, y, previewRect.right, y + mSrcMask->Height), clWhite);
				
				y += mSrcRect.Height();
				p += mHalfDropLength;
			}
		}
		else if (mMode == REPEAT_HDVER) {
			x = previewRect.left + (mSrcRect.Left - previewRect.left) % mSrcRect.Width();
			if (x > previewRect.left)
				x -= mSrcRect.Width();

			p = - mHalfDropLength * (mSrcRect.Left - x) / mSrcRect.Width();
			while (x < previewRect.right) {
				y = previewRect.top + p % mSrcRect.Height();
				if (y > previewRect.top)
					y -= mSrcRect.Height();

				if (mMainImage->uBitmap->BitsPerPixel == 8)
					mPreviewMask->FillRect(Rect(x, previewRect.top, x + mSrcRect.Width(), y + mSrcRect.Height()), PALETTEINDEX(0xFF));
				else
					mPreviewMask->FillRect(Rect(x, previewRect.top, x + mSrcRect.Width(), y + mSrcRect.Height()), clWhite);
					
				y += (previewRect.bottom - previewRect.top);
				if (y >= previewRect.bottom)
					y -= mSrcRect.Height();

				if (mMainImage->uBitmap->BitsPerPixel == 8)
					mPreviewMask->FillRect(Rect(x, y, x + mSrcRect.Width(), previewRect.bottom), PALETTEINDEX(0xFF));
				else
					mPreviewMask->FillRect(Rect(x, y, x + mSrcRect.Width(), previewRect.bottom), clWhite);

				x += mSrcRect.Width();
				p += mHalfDropLength;
			}
		}
	}

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

// Mouse Move Event : Set Preview Range & Preview Mask
void __fastcall TVectorRepeat::OnMouseMove(int X, int Y) {
	RECT newSubRange;
	// When Using Fixed Repetition Count
	if (mIsUsedCount == true) {
		mCountX = mFixedCountX;
		mCountY = mFixedCountY;
		int bound;

		// X Direction
		if (X < (mSrcRect.Left + mSrcRect.Right) / 2) {
			bound = mSrcRect.Right - mCountX * mSrcRect.Width();
			if (bound < 0)
				bound = 0;
			newSubRange.left = bound;
			newSubRange.right = mSrcRect.Right;
		}
		else {
			bound = mSrcRect.Left + mCountX * mSrcRect.Width();
			if (bound > mPreviewBitmap->Width)
				bound = mPreviewBitmap->Width;
			newSubRange.left = mSrcRect.Left;
			newSubRange.right = bound;
		}

		// Y Direction
		if (Y < (mSrcRect.Top + mSrcRect.Bottom) / 2) {
			bound = mSrcRect.Bottom - mCountY * mSrcRect.Height();
			if (bound < 0)
				bound = 0;
			newSubRange.top = bound;
			newSubRange.bottom = mSrcRect.Bottom;
		}
		else {
			bound = mSrcRect.Top + mCountY * mSrcRect.Height();
			if (bound > mPreviewBitmap->Height)
				bound = mPreviewBitmap->Height;
			newSubRange.top = mSrcRect.Top;
			newSubRange.bottom = bound;
		}

		// If Mode is Half Drop Mode, Expand Each Side of Region
		if (mMode == REPEAT_HDHOR) {
			newSubRange.left = newSubRange.left - mSrcRect.Width();
			newSubRange.right = newSubRange.right + mSrcRect.Width();
		}
		else if (mMode == REPEAT_HDVER) {
			newSubRange.top = newSubRange.top - mSrcRect.Height();
			newSubRange.bottom = newSubRange.bottom + mSrcRect.Height();
		}
	}
	// When Using Mouse Directly
	else {        	
		// X Direction
		mCountX = 0;
		if (X < mSrcRect.Left) {
			if ((mSrcRect.Left - X) % mSrcRect.Width() == 0)
				mCountX = (mSrcRect.Left - X) / mSrcRect.Width();
			else
				mCountX = (mSrcRect.Left - X) / mSrcRect.Width() + 1;
			mCountX++;				

			if (mIsCutObject == true) {
				newSubRange.left = X;
				newSubRange.right = mSrcRect.Right;
			}
			else {
				newSubRange.left = mSrcRect.Right - mCountX * mSrcRect.Width();
				newSubRange.right = mSrcRect.Right;
			}
		}
		else {
			if (X < mSrcRect.Right)
				mCountX = 1;
			else if ((X - mSrcRect.Left) % mSrcRect.Width() == 0)
				mCountX = (X - mSrcRect.Left) / mSrcRect.Width();
			else
				mCountX = (X - mSrcRect.Left) / mSrcRect.Width() + 1;

			if (mIsCutObject == true) {
				newSubRange.left = mSrcRect.Left;
				newSubRange.right = X + 1;
			}
			else {
				newSubRange.left = mSrcRect.Left;
				newSubRange.right = mSrcRect.Left + mCountX * mSrcRect.Width();
			}
		}

		// Y Direction
		mCountY = 0;
		if (Y < mSrcRect.Top) {
			if ((mSrcRect.Top - Y) % mSrcRect.Height() == 0)
				mCountY = (mSrcRect.Top - Y) / mSrcRect.Height();
			else
				mCountY = (mSrcRect.Top - Y) / mSrcRect.Height() + 1;
			mCountY++;

			if (mIsCutObject == true) {
				newSubRange.top = Y;
				newSubRange.bottom = mSrcRect.Bottom;
			}
			else {
				newSubRange.top = mSrcRect.Bottom - mCountY * mSrcRect.Height();
				newSubRange.bottom = mSrcRect.Bottom;
			}
		}
		else {
			if (Y < mSrcRect.Bottom)
				mCountY = 1;
			else if ((Y - mSrcRect.Top) % mSrcRect.Height() == 0)
				mCountY = (Y - mSrcRect.Top) / mSrcRect.Height();
			else
				mCountY = (Y - mSrcRect.Top) / mSrcRect.Height() + 1;

			if (mIsCutObject == true) {
				newSubRange.top = mSrcRect.Top;
				newSubRange.bottom = Y + 1;
			}
			else {
				newSubRange.top = mSrcRect.Top;
				newSubRange.bottom = mSrcRect.Top + mCountY * mSrcRect.Height();
			}				
		}

		if (mIsCutObject == false) {
			// If Mode is Half Drop Mode, Expand Each Side of Region
			if (mMode == REPEAT_HDHOR) {
				newSubRange.left = newSubRange.left - mSrcRect.Width();
				newSubRange.right = newSubRange.right + mSrcRect.Width();
			}
			else if (mMode == REPEAT_HDVER) {
				newSubRange.top = newSubRange.top - mSrcRect.Height();
				newSubRange.bottom = newSubRange.bottom + mSrcRect.Height();
			}
		}
	}

	// Set Preview Mask for newSubRange
	SetPreviewMask(newSubRange);

	RECT paintRect;
	paintRect.left = min(newSubRange.left, mMainImage->SubRange.left);
	paintRect.top = min(newSubRange.top, mMainImage->SubRange.top);
	paintRect.right = max(newSubRange.right, mMainImage->SubRange.right);
	paintRect.bottom = max(newSubRange.bottom, mMainImage->SubRange.bottom);

	mMainImage->SubRange = newSubRange;
	if (paintRect.right >= mMainImage->CanvasWidth - 2) {
		mMainImage->Repaint();
	}
	else
		mMainImage->RectPaint(paintRect);

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

// Mouse Down Event : Run Repetition
void __fastcall TVectorRepeat::OnMouseDown(int X, int Y) {
	Run();
}
//---------------------------------------------------------------------------

// Run Repetetion
void __fastcall TVectorRepeat::Run() {
	BEGIN_LOG("");

	TCursor orgCursor = Screen->Cursor;
	Screen->Cursor = crHourGlass;

	// Initialize Destination Buffer List
	if (mDstBufferDataList->Count > 0)
		mDstBufferDataList->Clear();

	int disX, disY, diff;
	TRect dstRect, boundRect, interRect;
	switch (mMode) {
		case REPEAT_NORMAL:
			for (int yIdx = 0; yIdx < mCountY; yIdx++) {
				if (mSrcRect.Top > mMainImage->SubRange.top)
					disY = - yIdx * mSrcRect.Height();
				else
					disY = yIdx * mSrcRect.Height();

				for (int xIdx = 0; xIdx < mCountX; xIdx++) {
					if (mSrcRect.Left > mMainImage->SubRange.left)
						disX = - xIdx * mSrcRect.Width();
					else
						disX = xIdx * mSrcRect.Width();

					dstRect = Rect(mSrcRect.Left + disX, mSrcRect.Top + disY, mSrcRect.Right + disX, mSrcRect.Bottom + disY);
					if (mIsCutObject == true)
						boundRect = mMainImage->SubRange;
					else
						boundRect = Rect(0, 0, mMainImage->uBitmap->Width, mMainImage->uBitmap->Height);

					if (IntersectRect(interRect, dstRect, boundRect) == true)
						RepeatObjects(disX, disY, boundRect);
				}
			}
			break;

		case REPEAT_HDHOR:
			for (int yIdx = 0; yIdx < mCountY; yIdx++) {
				if (mSrcRect.Top > mMainImage->SubRange.top) {
					disY = - (mCountY - 1 - yIdx) * mSrcRect.Height();
					diff = (mHalfDropLength * (mCountY - 1 - yIdx)) % mSrcRect.Width() -  mSrcRect.Width();
				}
				else {
					disY = yIdx * mSrcRect.Height();
					diff = (int)(mHalfDropLength * yIdx) % mSrcRect.Width() - mSrcRect.Width();
				}

				for (int xIdx = 0; xIdx < mCountX + 1; xIdx++) {
					if (mSrcRect.Left > mMainImage->SubRange.left + mSrcRect.Width())
						disX = -(mCountX - 1 - xIdx) * mSrcRect.Width() + diff;
					else
						disX = xIdx * mSrcRect.Width() + diff;

					dstRect = Rect(mSrcRect.Left + disX, mSrcRect.Top + disY, mSrcRect.Right + disX, mSrcRect.Bottom + disY);

					if (mIsCutObject == true) {
						boundRect = mMainImage->SubRange;
					}
					else {
						boundRect.Left = mMainImage->SubRange.left + mSrcRect.Width();
						boundRect.Right = mMainImage->SubRange.right - mSrcRect.Width();
						boundRect.Left = max(boundRect.Left, 0);
						boundRect.Right = min(boundRect.Right, mMainImage->uBitmap->Width);
						boundRect.Top = 0;
						boundRect.Bottom = mMainImage->uBitmap->Height;
					}

					if (IntersectRect(interRect, dstRect, boundRect) == true)
						RepeatObjects(disX, disY, boundRect);
				}
			}
			break;

		case REPEAT_HDVER:
			for (int xIdx = 0; xIdx < mCountX; xIdx++) {
				if (mSrcRect.Left > mMainImage->SubRange.left) {
					disX = - (mCountX - 1 - xIdx) * mSrcRect.Width();
					diff = (mHalfDropLength * (mCountX - 1 - xIdx)) % mSrcRect.Height() - mSrcRect.Height();
				}
				else {
					disX = xIdx * mSrcRect.Width();
					diff = (int)(mHalfDropLength * xIdx) % mSrcRect.Height() - mSrcRect.Height();
				}

				for (int yIdx = 0; yIdx < mCountY + 1; yIdx++) {
					if (mSrcRect.Top > mMainImage->SubRange.top + mSrcRect.Height())
						disY = -(mCountY - 1 - yIdx) * mSrcRect.Height() + diff;
					else
						disY = yIdx * mSrcRect.Height() + diff;

					dstRect = Rect(mSrcRect.Left + disX, mSrcRect.Top + disY, mSrcRect.Right + disX, mSrcRect.Bottom + disY);

					if (mIsCutObject == true) {
						boundRect = mMainImage->SubRange;
					}
					else {
						boundRect.Top = mMainImage->SubRange.top + mSrcRect.Height();
						boundRect.Bottom = mMainImage->SubRange.bottom - mSrcRect.Height();
						boundRect.Top = max(boundRect.Top, 0);
						boundRect.Bottom = min(boundRect.Bottom, mMainImage->uBitmap->Height);
						boundRect.Left = 0;
						boundRect.Right = mMainImage->uBitmap->Width;
					}

					if (IntersectRect(interRect, dstRect, boundRect) == true)
						RepeatObjects(disX, disY, boundRect);
				}
			}
			break;
	}

	// Object¸¦ ÀÚ¸£´Â °æ¿ì PreviewRect¸¦ ±âÁØÀ¸·Î Object ¸¦ ÀÚ¸§
	if (mIsUsedCount == false && mIsCutObject == true) {
		// Create boundRect
		TVecData *boundRect = new TVecData(MainImageForm->Number);
		boundRect->Kind = V_CURVE;
		boundRect->First.x = mMainImage->SubRange.left;
		boundRect->First.y = mMainImage->SubRange.top;
		boundRect->Second.x = mMainImage->SubRange.right;
		boundRect->Second.y = mMainImage->SubRange.bottom;
		boundRect->nCount = 4;
		boundRect->pList = (DPOINT*)HeapAlloc(GetProcessHeap(), 0,
			sizeof(DPOINT) * (boundRect->nCount * 3 + 1));
		boundRect->pMask = (BYTE*)HeapAlloc(GetProcessHeap(), 0,
			(boundRect->nCount * 3 + 1) % 8 == 0 ? (boundRect->nCount * 3 + 1) / 8 :
			(boundRect->nCount * 3 + 1) / 8 + 1);
		boundRect->pList[12].DPoint(boundRect->First.x, boundRect->First.y);
		boundRect->pList[11].DPoint(boundRect->First.x, boundRect->First.y);
		boundRect->pList[10].DPoint(boundRect->First.x, boundRect->Second.y);
		boundRect->pList[9].DPoint(boundRect->First.x, boundRect->Second.y);
		boundRect->pList[8].DPoint(boundRect->First.x, boundRect->Second.y);
		boundRect->pList[7].DPoint(boundRect->Second.x, boundRect->Second.y);
		boundRect->pList[6].DPoint(boundRect->Second.x, boundRect->Second.y);
		boundRect->pList[5].DPoint(boundRect->Second.x, boundRect->Second.y);
		boundRect->pList[4].DPoint(boundRect->Second.x, boundRect->First.y);
		boundRect->pList[3].DPoint(boundRect->Second.x, boundRect->First.y);
		boundRect->pList[2].DPoint(boundRect->Second.x, boundRect->First.y);
		boundRect->pList[1].DPoint(boundRect->First.x, boundRect->First.y);
		boundRect->pList[0].DPoint(boundRect->First.x, boundRect->First.y);
		boundRect->bClosed = true;
		boundRect->bSelected = true;

		// Insert boundRect temporarily
		mDstBufferDataList->Insert(0, boundRect);
		// Cut Ojects by boundRect
		VecDraw->ManualRepeatCuttingObjects(mDstBufferDataList);

		// Delete boundRect
		mDstBufferDataList->Remove(boundRect);
		delete boundRect;
	}

	/// Add to Destination List(MainImageForm->V_DATA)
	bool bAddUndoStep = true;	// Add Undo Step Or Not
	RECT rtCur, rtUnion, rect;
	for (int itmIdx = 0; itmIdx < mDstBufferDataList->Count; itmIdx++) {
		TVecData *obj = static_cast<TVecData*>(mDstBufferDataList->Items[itmIdx]);
		if (obj != NULL) {			
			obj->bSelected = true;
			if(obj->ParentTextBox){
				VecDraw->MakeTextBoxPointList(obj->ParentTextBox);
				VecDraw->GetRectForMouseMove(obj->ParentTextBox, rect);
				UnionRect(&rtUnion, &rtUnion, &rect);

				mDstDataList->Add(obj);
				mDstDataList->Add(obj->ParentTextBox);
				VecDraw->UndoSave(VU_TEXTCREATE, mDstDataList->Count - 1, bAddUndoStep);
			}
			else{
				rtCur = Rect(obj->First.x - obj->PenThick / 2, obj->First.y - obj->PenThick / 2,
				obj->Second.x + obj->PenThick / 2, obj->Second.y + obj->PenThick / 2);
				UnionRect(&rtUnion, &rtUnion, &rtCur);

				mDstDataList->Add(obj);
				VecDraw->UndoSave(VU_CREATE, mDstDataList->Count - 1, bAddUndoStep);
			}
			bAddUndoStep = false;
		}
	}
	MainImageForm->iMainImage->RectPaint(rtUnion);

	Screen->Cursor = orgCursor;

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

// Copy & Paste Objects Moved by (disX, disY)
void __fastcall TVectorRepeat::RepeatObjects(int disX, int disY, TRect boundRect) {
	BEGIN_LOG("");

	if (disX == 0 && disY == 0) {
		END_LOG;
		return;
	}

	for (int itmIdx = 0; itmIdx < mSrcDataList->Count; itmIdx++) {
		TVecData *srcObj = static_cast<TVecData*>(mSrcDataList->Items[itmIdx]);
		TVecData *newObj = new TVecData(srcObj->GetInstNum());
		if(srcObj->ParentTextBox)
		{
			newObj->Copy(srcObj->ParentTextBox);
			newObj = newObj->ListOfAllLine->CurveData;
		}else
		{
			newObj->Copy(srcObj);
		}
		newObj->MoveBy(disX, disY);

		if (!mIsCutObject || (mIsCutObject &&(IsVecDataInRect(newObj, boundRect) == true))) {
			newObj->bSelected = true;
			mDstBufferDataList->Add(newObj);
		}
		else {
			delete newObj;
		}

//		// Do Not Add Vector Objects that are located outside boundary
//		if (IsVecDataInRect(newObj, boundRect) == true) {
//			newObj->bSelected = true;
//			mDstBufferDataList->Add(newObj);
//		}
//		else {
//			delete newObj;
//		}
	}

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

// Check Vector Object Is In boundRect
bool __fastcall TVectorRepeat::IsVecDataInRect(TVecData *obj, TRect boundRect) {
	TRect objRect = Rect(obj->First.x - obj->PenThick / 2, obj->First.y - obj->PenThick / 2,
				obj->Second.x + obj->PenThick / 2, obj->Second.y + obj->PenThick / 2);
	TRect interRect;
	bool isInRect = false;

	if (IntersectRect(interRect, objRect, boundRect) == true) {
		if (interRect != objRect) {
			DPOINT pt1, pt2;
			for (int lineIdx = 0; lineIdx < 4; lineIdx++) {
				switch (lineIdx) {
					case 0:
						pt1.DPoint(boundRect.Left, boundRect.Top);
						pt2.DPoint(boundRect.Right, boundRect.Top);
						break;
					case 1:
						pt1.DPoint(boundRect.Right, boundRect.Top);
						pt2.DPoint(boundRect.Right, boundRect.Bottom);
						break;
					case 2:
						pt1.DPoint(boundRect.Right, boundRect.Bottom);
						pt2.DPoint(boundRect.Left, boundRect.Bottom);
						break;
					case 3:
						pt1.DPoint(boundRect.Left, boundRect.Bottom);
						pt2.DPoint(boundRect.Left, boundRect.Top);
						break;
				}

				if (VecDraw->isVecDataCrossedWithLine(pt1, pt2, obj) == true) {
					isInRect = true;
					break;
				}
			}

			if (isInRect == false) {
				if (obj->pList != NULL && obj->nCount > 0) {
					if (obj->pList[0].x >= boundRect.Left && obj->pList[0].x < boundRect.Right &&
						obj->pList[0].y >= boundRect.Top && obj->pList[0].y < boundRect.Bottom)
					{
						isInRect = true;
					}
				}
			}
		}
		else {
			isInRect = true;
		}
	}

	return isInRect;
}
// ---------------------------------------------------------------------------