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

#include "Undo.h"
#include "MainImage.h"
#include "PenManager.h"
//#include "MainMenu.h"        //lhskys
//---------------------------------------------------------------------------
#pragma package(smart_init)
TUndo *Undo;
//---------------------------------------------------------------------------
__fastcall TUndo::TUndo()
{
  Number = 0;
  //DestroyedIndex=StartingIndexOfPenUndo=CurrentHistoryPenIndex=CurrentHistoryIndex= -1;
  StartingIndexOfPenUndo=CurrentHistoryPenIndex=CurrentHistoryIndex= -1;
//  CurrentLayerOrder=ubitmap->getLayerOrder();
	HistoryOfUndoMethod=new TList;			//by linuxjun

  StartPenUndoBitmap = false;
  StartPenUndoMask = false;
}
//---------------------------------------------------------------------------
__fastcall TUndo::~TUndo()
{
	THistoryData *HisData;

 	while (HistoryOfUndoMethod->Count) {
    HisData = (THistoryData *)HistoryOfUndoMethod->First();
  	HistoryOfUndoMethod->Remove(HisData);
 	  delete HisData;
 	}
  delete HistoryOfUndoMethod;
}
//---------------------------------------------------------------------------
// Private Function
//---------------------------------------------------------------------------
int __fastcall TUndo::GetCount() {
//  return CurrentHistoryIndex;
	int count = 0;
  THistoryData *data;
	for (int i = HistoryOfUndoMethod->Count - 1; i >= 0; i--) {
  	data = (THistoryData *)HistoryOfUndoMethod->Items[i];
    if (data->Equal(Image->uBitmap->getLayerOrder())) count++;    //by linuxjun Undo_Method
  }
	return count;
}
//---------------------------------------------------------------------------
/*THistoryData *__fastcall TUndo::GetLast()
{
  THistoryData *data;
	for (int i = HistoryOfUndoMethod->Count - 1; i >= 0; i--) {
  	data = (THistoryData *)HistoryOfUndoMethod->Items[i];
    if (data->Equal(Image->uBitmap->getLayerOrder())) {         //by linuxjun Undo_Method
    	return data;
    }
  }
  if(HistoryOfUndoMethod->Count>0)return (THistoryData *)HistoryOfUndoMethod->Last();
fail:
	return NULL;
}*/
//---------------------------------------------------------------------------
THistoryData *__fastcall TUndo::GetLast()
{
  THistoryData *data;
	for (int i = HistoryOfUndoMethod->Count - 1; i >= 0; i--) {
  	data = (THistoryData *)HistoryOfUndoMethod->Items[i];
    if (data->Equal(Image->uBitmap->getLayerOrder()) && (data->getUndoKind()&UK_PATTERN||data->getUndoKind()&UK_MASK) ) {         //by linuxjun Undo_Method
    	return data;
    }
  }
  if(HistoryOfUndoMethod->Count>0)return (THistoryData *)HistoryOfUndoMethod->Last();
fail:
	return NULL;
}
//---------------------------------------------------------------------------
/*THistoryData *__fastcall TUndo::GetLastPatternUd()
{
  THistoryData *data;
	for (int i = HistoryOfUndoMethod->Count - 1; i >= 0; i--) {
  	data = (THistoryData *)HistoryOfUndoMethod->Items[i];
    if (data->Equal(Image->uBitmap->getLayerOrder()) && data->getUndoKind()&UK_PATTERN) {         //by linuxjun Undo_Method
    	return data;
    }
  }
  if(HistoryOfUndoMethod->Count>0)return (THistoryData *)HistoryOfUndoMethod->Last();
fail:
	return NULL;
}*/
//---------------------------------------------------------------------------
// Public Function
//---------------------------------------------------------------------------
void __fastcall TUndo::InitPenUndo()
{
	StartingIndexOfPenUndo=CurrentHistoryPenIndex=CurrentHistoryIndex;
  THistoryData * historyData;
  PenUndoData=NULL;
  for(int i=CurrentHistoryPenIndex;i>=0;i--)
  {
    historyData=(THistoryData *)HistoryOfUndoMethod->Items[i];
    switch(historyData->getFromKind())
    {
   		case UK_ALL:
   		case UK_REPEAT:
      case UK_MASK:
////			historyData->Mask->PartialUndo->StartPenUndo();
 			  if (historyData->getFromKind()==UK_MASK)
  		  {
          historyData->Mask->PartialUndo->StartPenUndo();
          StartPenUndoMask = true;
//   		  	Image->LayerMask->PartialUndo->StartPenUndo();
          i=0;
			    break;
		    }
   		case UK_PATTERN:
// 		  	historyData->uBitmap->PartialUndo->StartPenUndo();
        historyData->uBitmap->PartialUndo->StartPenUndo();
        StartPenUndoBitmap = true;
 		  	//Image->uBitmap->PartialUndo->StartPenUndo();
//        if(Image->LayerMask){
        if(historyData->LayerMask){
   		  	//Image->LayerMask->PartialUndo->StartPenUndo();
          historyData->LayerMask->PartialUndo->StartPenUndo();
        }
        i=0;
		    break;
 		  case UK_WORKAREA:
    	case UK_COLOR:
   			break;
   	}
  }
}

void __fastcall TUndo::ExitPenUndo()
{
//	StartingIndexOfPenUndo=CurrentHistoryPenIndex=-1;
//	StartingIndexOfPenUndo=CurrentHistoryPenIndex=DestroyedIndex;
	StartingIndexOfPenUndo=CurrentHistoryPenIndex=-1;
  if(PenUndoData){
    try{
      switch(PenUndoData->getFromKind())
      {
 		    case UK_ALL:
   		  case UK_REPEAT:
        case UK_MASK:
////		  	historyData->Mask->PartialUndo->EndPenUndo();
    		  if (PenUndoData->getFromKind()==UK_MASK){
            Image->Mask->PartialUndo->EndPenUndo();
            break;
          }
 	    	case UK_PATTERN:
// 	    	PenUndoData->uBitmap->PartialUndo->EndPenUndo();
   	    	Image->uBitmap->PartialUndo->EndPenUndo();
	        break;
   	    case UK_WORKAREA:
     	  case UK_COLOR:
  		  	break;
      }
    }catch( ... ){}        //for µÎ°³ÀÇ
  }
  PenUndoData=NULL;
  StartPenUndoBitmap = false;
  StartPenUndoMask = false;

}

void __fastcall TUndo::Set(TPItemImage *image, TPalette *palette, TPWorkArea *workarea)
{
  Image = image;
  CurrentLayerOrder = Image->uBitmap->getLayerOrder();
  Palette = palette;
  WorkArea = workarea;
//  Arrange();
}
//---------------------------------------------------------------------------
bool __fastcall TUndo::UndoSave(int kind, RECT rect)
{
  //DWORD startTick = GetTickCount();
  //DWORD endTick = 0;

  RGBQUAD rgb[256];
	BITMAPHANDLE *tempBitmapHandle;
  TPLayer *lay;

	//THistoryData * historyData= new THistoryData(kind , rect, Image->uBitmap, Image->LayerMask, Image->Mask);
	THistoryData * historyData= new THistoryData(kind , rect, Image->uBitmap);
  historyData->setFromLayerOrder(CurrentLayerOrder);    //just for Layer Switching
  CurrentLayerOrder=historyData->getCurrentLayerOrder();

	CurrentHistoryIndex++;
  int tempIndex;

 tempIndex=CurrentHistoryIndex;
//  while(HistoryOfUndoMethod->Count>CurrentHistoryIndex){
  while(HistoryOfUndoMethod->Count>tempIndex){
    RemoveLast();
  }
  CurrentHistoryIndex=tempIndex;


	HistoryOfUndoMethod->Add(historyData);

//	LayerMask=layerMask;
//  Mask=mask;


	switch(kind)
	{
    case UK_REARRANGE:
			if(Image->uBitmap->BitsPerPixel==8)
			{
				int layerCount = Image->LayerList->Count;
				for(int i = 0; i < layerCount; i++) {
					lay = (TPLayer *)Image->LayerList->Items[i];
					lay->LBitmap->PartialUndo->AddUndo();
					lay->LBitmap->PartialUndo->SetMaximumUndoNum(GetMaxUndoNum());
					lay->LBitmap->PartialUndo->RectSaveUndo(Rect(0, 0, Image->uBitmap->Width, Image->uBitmap->Height));
					if(lay->LMask){
						lay->LMask->PartialUndo->AddUndo();
						lay->LMask->PartialUndo->SetMaximumUndoNum(GetMaxUndoNum());
						lay->LMask->PartialUndo->RectSaveUndo(Rect(0, 0, Image->uBitmap->Width, Image->uBitmap->Height));
					}
				}

				if (Palette) Palette->ToRGBQUAD(historyData->FromRgb, 256);
				else Image->uBitmap->GetColors(0, 256, historyData->FromRgb);

				if (Palette) {
					if (historyData->FromPalette == NULL){
						if ((historyData->FromPalette = new TPalette)==NULL) goto fail;
					}
					historyData->FromPalette->SetPalette(Palette);
				}


				break;
			}

		case UK_ALL:			//all kind
		case UK_REPEAT:		//pattern + workarea + mask
		case UK_PATTERN:
			historyData->uBitmap = Image->uBitmap;

			Image->uBitmap->PartialUndo->AddUndo();
			Image->uBitmap->PartialUndo->SetMaximumUndoNum(GetMaxUndoNum());


			if(Image->LayerMask){
				historyData->LayerMask = Image->LayerMask;

				Image->LayerMask->PartialUndo->AddUndo();
				Image->LayerMask->PartialUndo->SetMaximumUndoNum(GetMaxUndoNum());
			}
			if (rect.left!=rect.right&&rect.top!=rect.bottom)
			{
				Image->uBitmap->PartialUndo->RectSaveUndo(rect);
				if(Image->LayerMask) Image->LayerMask->PartialUndo->RectSaveUndo(rect);
			}
			//need to correction !!!! must correct

			//<-----for Pen-Undo Save Palette Data---->//
			if (Image->uBitmap->BitsPerPixel==8) {
//				historyData->FromRgb=new RGBQUAD[256]; 		//by linuxjun
				if (Palette) Palette->ToRGBQUAD(historyData->FromRgb, 256);
				else Image->uBitmap->GetColors(0, 256, historyData->FromRgb);

				// Ææ »ö´Ü°è ±â´É »ç¿ë½Ã ¾ðµÎ¸¦ Çصµ »ö´Ü°è°¡ À¯ÁöµÇµµ·Ï Çϱâ À§ÇØ
				if (PenManagerForm && PenManagerForm->aspread)
				{
					historyData->PenSpreadStartIdx = PenManagerForm->SpreadStart;
					historyData->PenSpreadEndIdx = PenManagerForm->SpreadEnd;
				}
			}
			if (Palette) {
				if (historyData->FromPalette == NULL){
					if ((historyData->FromPalette = new TPalette)==NULL) goto fail;
				}
				historyData->FromPalette->SetPalette(Palette);
	    }
			//<--------------------------------------->//
			if(kind==UK_PATTERN)break;

		case UK_WORKAREA:
	   	tempBitmapHandle = Image->uBitmap->RgnBitmap->Handle;
	   	if (tempBitmapHandle) {
	   		if (L_BitmapHasRgn(tempBitmapHandle)) {
  				RGNXFORM XForm;
			  	XForm.uViewPerspective = TOP_LEFT;
	 				XForm.nXScalarNum = 1;
		  		XForm.nXScalarDen = 1;
	  			XForm.nYScalarNum = 1;
		  		XForm.nYScalarDen = 1;
	 				XForm.nXOffset = 0;
			  	XForm.nYOffset = 0;
		  		L_GetBitmapRgnHandle(tempBitmapHandle, &XForm, &(historyData->FromRegion));
	   	  }
	    }
			if(kind==UK_WORKAREA)break;

		case UK_MASK:
			if (Image->Mask)
			{
				historyData->Mask = Image->Mask;

				Image->Mask->PartialUndo->AddUndo();
				Image->Mask->PartialUndo->SetMaximumUndoNum(GetMaxUndoNum());
				if (rect.left!=rect.right&&rect.top!=rect.bottom)
				{
					Image->Mask->PartialUndo->RectSaveUndo(rect);
				}
			}
			if(kind==UK_MASK||kind==UK_REPEAT)break;

		case UK_COLOR:
    	if (Image->uBitmap->BitsPerPixel==8) {
//				historyData->FromRgb=new RGBQUAD[256]; 		//by linuxjun
    	  if (Palette) Palette->ToRGBQUAD(historyData->FromRgb, 256);
    	  else Image->uBitmap->GetColors(0, 256, historyData->FromRgb);
			}
			if (Palette) {
				if (historyData->FromPalette == NULL){
					if ((historyData->FromPalette = new TPalette)==NULL) goto fail;
				}
				historyData->FromPalette->SetPalette(Palette);
			}
			break;
 	}
	////////////////////MaxMum°ªÀÌ ³ÑÀ» °æ¿ì ¿¹Àü Undo Data¸¦ Áö¿ì±âÀ§ÇÑ ÄÚµå
	if(StartingIndexOfPenUndo <= -1){
		while(HistoryOfUndoMethod->Count > GetMaxUndoNum()){
			RemoveFirst();
		}
	}

  //endTick = GetTickCount();
  //RecordTickTime("UndoSave", endTick - startTick);

  return true;
fail:
	if (historyData) delete historyData;
  return false;
}
//---------------------------------------------------------------------------
bool __fastcall TUndo::UndoSave(int kind)
{
  return UndoSave(kind, Rect(0, 0, Image->uBitmap->Width, Image->uBitmap->Height));
}
//---------------------------------------------------------------------------
bool __fastcall TUndo::RedoSave(int kind)
{                 // »õ·Î¿î Undo ¹æ½Ä (MainImageµî¿¡¼­) By GreenFish


  RGBQUAD rgb[256];
	BITMAPHANDLE *tempBitmapHandle = NULL;
//  TPLayer *lay = NULL;

  // Index out of bound °ü·Ã ¿¹¿Üó¸®: aidobb 2009. 12. 07.
  if(CurrentHistoryIndex == -1) return false;

	THistoryData * historyData=(THistoryData *)HistoryOfUndoMethod->Items[CurrentHistoryIndex];
  historyData->setToLayerOrder(CurrentLayerOrder);    //just for Layer Switching
  historyData->setToKind(kind);

//	switch(CurrentKind)
	switch(kind)
	{
    case UK_REARRANGE:
      if(Image->uBitmap->BitsPerPixel==8)
      {
//        int layerCount = Image->LayerList->Count;
//        for(int i = 0; i < layerCount; i++) {
//          lay = (TPLayer *)Image->LayerList->Items[i];
//          lay->LBitmap->PartialUndo->AddUndo();
//          lay->LBitmap->PartialUndo->SetMaximumUndoNum(GetMaxUndoNum());
//          if(lay->LMask){
//            lay->LMask->PartialUndo->AddUndo();
//            lay->LMask->PartialUndo->SetMaximumUndoNum(GetMaxUndoNum());
//          }
//        }
      	if (Palette) Palette->ToRGBQUAD(historyData->ToRgb, 256);
      	else historyData->uBitmap->GetColors(0, 256, historyData->ToRgb);

    		if (Palette) {
		  		if (!historyData->ToPalette)
			  	{
		  	  	if ((historyData->ToPalette = new TPalette)==NULL) goto fail;
	    		  historyData->ToPalette->SetPalette(Palette);
  				}
	      }
        break;
      }

 		case UK_ALL:

 		case UK_REPEAT:

		case UK_PATTERN:
			//need to correction !!!! must correct

			//<-----for Pen-Undo Save Palette Data---->//
    	if (historyData->uBitmap->BitsPerPixel==8) {
    	  if (Palette) Palette->ToRGBQUAD(historyData->ToRgb, 256);
    	  else historyData->uBitmap->GetColors(0, 256, historyData->ToRgb);

        // Ææ »ö´Ü°è ±â´É »ç¿ë½Ã ¾ðµÎ¸¦ Çصµ »ö´Ü°è°¡ À¯ÁöµÇµµ·Ï Çϱâ À§ÇØ
        if (PenManagerForm && PenManagerForm->aspread)
        {
          historyData->PenSpreadStartIdx = PenManagerForm->SpreadStart;
          historyData->PenSpreadEndIdx = PenManagerForm->SpreadEnd;
        }
    	}
	 		if (Palette) {
				if (!historyData->ToPalette)
				{
		  		if ((historyData->ToPalette = new TPalette)==NULL) goto fail;
	    		historyData->ToPalette->SetPalette(Palette);
				}
	    }
			//<-------------------------------------->//
			if(kind==UK_PATTERN)break;

		case UK_WORKAREA:
	   	tempBitmapHandle = historyData->Bitmap->RgnBitmap->Handle;

	   	if (tempBitmapHandle) {
	   		if (L_BitmapHasRgn(tempBitmapHandle)) {

  				RGNXFORM XForm;
			  	XForm.uViewPerspective = TOP_LEFT;
	 				XForm.nXScalarNum = 1;
		  		XForm.nXScalarDen = 1;
	  			XForm.nYScalarNum = 1;
		  		XForm.nYScalarDen = 1;
	 				XForm.nXOffset = 0;
			  	XForm.nYOffset = 0;
		  		L_GetBitmapRgnHandle(tempBitmapHandle, &XForm, &(historyData->ToRegion));
	   	  }
	    }

			if(kind==UK_WORKAREA)break;

		case UK_MASK:

//			if(Image->Mask)Image->Mask->PartialUndo->LoadUndo();

			if(kind==UK_MASK||kind==UK_REPEAT)break;

		case UK_COLOR:
    	if (historyData->Bitmap->BitsPerPixel==8) {
    	  if (Palette) Palette->ToRGBQUAD(historyData->ToRgb, 256);
    	  else historyData->Bitmap->GetColors(0, 256, historyData->ToRgb);

    	}
	 		if (Palette) {
				if (!historyData->ToPalette)
				{
		  		if ((historyData->ToPalette = new TPalette)==NULL) goto fail;
	    		historyData->ToPalette->SetPalette(Palette);
				}
	    }
			break;

 	}
  return true;
fail:
	if (historyData) delete historyData;
  return false;
}
//---------------------------------------------------------------------------
void __fastcall TUndo::LayerChange(int from, int to)
{

//	if(from==to){
//		return;
//	}
	TPLayer *lay;
	int row;
	for(row=0;row<MainImageForm->iMainImage->LayerList->Count;row++){
		lay = (TPLayer *) MainImageForm->iMainImage->LayerList->Items[row];
		if(to==lay->GetLayerOrder())break;
  }
	if(row<MainImageForm->iMainImage->LayerList->Count){
    MainImageForm->LayerCNT = row+1;
    MainImageForm->iMainImage->Index = row;
		MainImageForm->BackGroundSettingForChangeLayer();
		::RepaintImage();
//    if (row > 0) {                          //by k3dogs(20001107)µå·¡±×·Î ·¡ÀÌ¾î ¿Å±â±â.
//          LayerGrid->BeginDrag(false,false);    //
//          ExchangeRow = row+1;                    //ExchangeRow = ±³È¯µÉ ·¹À̾î
//    }                                       //

	}



}
bool __fastcall TUndo::IsThereThisLayerUnionBitmap(TUnionBitmap * Bitmap){
	TPLayer *lay;
	int cnt=Image->LayerList->Count;

	for(int i=0;i<cnt;i++)
	{
    lay = (TPLayer *) MainImageForm->iMainImage->LayerList->Items[i];
		if(lay->LBitmap == Bitmap || lay->ARLBitmap == Bitmap){
			return true;
		}
	}
	return false;


}

bool __fastcall TUndo::IsThereThisLayerMaskBitmap(TUnionBitmap * Bitmap){
	TPLayer *lay;
	int cnt=Image->LayerList->Count;
	for(int i=0;i<cnt;i++)
	{
    lay = (TPLayer *) MainImageForm->iMainImage->LayerList->Items[i];
		if(lay->LMask == Bitmap || lay->ARLMask == Bitmap){
			return true;
		}
	}
	return false;


}
bool __fastcall TUndo::IsThereThisBitmap(int LayerOrder)
{
	TPLayer *lay;
	int cnt=Image->LayerList->Count;

//	for(int i=0;i<Image->LayerList->Count;i++)
	for(int i=0;i<cnt;i++)
	{
    lay = (TPLayer *) MainImageForm->iMainImage->LayerList->Items[i];
		if(lay->LBitmap->getLayerOrder()==LayerOrder){
			return true;
		}
	}
	return false;
}

//---------------------------------------------------------------------------
//void __fastcall TUndo::UndoRead(bool bDelete)
bool __fastcall TUndo::UndoRead(bool bDelete)
{                 // »õ·Î¿î Undo ¹æ½Ä (MainImageµî¿¡¼­) By GreenFish

//	HistoryOfUndoMethod->Add(historyData);
//  if(CurrentHistoryIndex>StartingIndexOfPenUndo){
//  if(CurrentHistoryIndex>StartingIndexOfPenUndo && CurrentHistoryIndex>DestroyedIndex){
  bool result;
  TPLayer *lay;

	if(CurrentHistoryIndex>StartingIndexOfPenUndo){
		RGBQUAD rgb[256];
		THistoryData * historyData=(THistoryData *)HistoryOfUndoMethod->Items[CurrentHistoryIndex];

		int kind;
		CurrentLayerOrder=historyData->getCurrentLayerOrder();
		if(IsThereThisBitmap(CurrentLayerOrder))
		{
			//when there exist current Bitmap by Removing Layer
			RedoSave(kind=historyData->getFromKind());			//caution!! getToKInd();
//			LayerChange(historyData->getToLayerOrder(),historyData->getCurrentLayerOrder()); //by linuxjun
			LayerChange(Image->uBitmap->getLayerOrder(),historyData->getCurrentLayerOrder()); //by linuxjun
			switch(kind)
			{
				case UK_REARRANGE:
          if(Image->uBitmap->BitsPerPixel==8)
          {
						if(historyData->FromPalette) Palette->SetPalette(historyData->FromPalette);
						else historyData->uBitmap->PutColors(0, 256, historyData->FromRgb);
            Image->RearrangeColors(historyData->FromRgb);
            int layerCount = Image->LayerList->Count;
            for(int i = 0; i < layerCount; i++) {
							lay = (TPLayer *)Image->LayerList->Items[i];
              lay->LBitmap->PartialUndo->LoadUndo();
              if(lay->LMask){
                lay->LMask->PartialUndo->LoadUndo();
              }
            }
            Image->MakeBeforeBitmap();
            break;
					}
				case UK_ALL:
				case UK_REPEAT:
          if(kind==UK_REPEAT && MainImageForm->AutoRepeat){
  			    MainImageForm->AutoRepeat = false;
      			MainImageForm->sbAutoRepView->Enabled = false;
      			MainImageForm->ARViewExitForm();

            RemoveAutoRepeatUndo();
            MainImageForm->iMainImage->ReplaceAutoBitmap(MainImageForm->ARLayerCnt-1);
            MainImageForm->iMainImage->EndAutoRepeat();
            MainImageForm->EnlargeCanvasInAutoRepeat();

      			MainImageForm->AutoRepUpdateMenu(true);
       			MainImageForm->iMainImage->OnPaintRange = NULL;
            //            break;
          }
					/*

  				AutoRepeatViewEnd();
    			MainImageForm->iMainImage->OnPaintRange = NULL;
          */

				case UK_PATTERN:
					if(historyData->uBitmap)historyData->uBitmap->PartialUndo->LoadUndo();
					if(historyData->LayerMask) historyData->LayerMask->PartialUndo->LoadUndo();
					if (historyData->uBitmap->BitsPerPixel==8) {
            Byte prevUseColorCnt = Palette->UseColor;

						if(historyData->FromPalette) Palette->SetPalette(historyData->FromPalette);
						else historyData->uBitmap->PutColors(0, 256, historyData->FromRgb);
            Image->RearrangeColors(historyData->FromRgb);

            // Ææ »ö´Ü°è ±â´É »ç¿ë½Ã ¾ðµÎ¸¦ Çصµ »ö´Ü°è°¡ À¯ÁöµÇµµ·Ï Çϱâ À§ÇØ
            if (PenManagerForm && PenManagerForm->aspread)
              PenManagerForm->AddPenSpreadColorForUndo(historyData->PenSpreadStartIdx, historyData->PenSpreadEndIdx, prevUseColorCnt);
					}
					if(kind==UK_PATTERN)break;


				case UK_WORKAREA:

					if (historyData->FromRegion) {
						RGNXFORM XForm;
						XForm.uViewPerspective = TOP_LEFT;
						XForm.nXScalarNum = 1;
						XForm.nXScalarDen = 1;
						XForm.nYScalarNum = 1;
						XForm.nYScalarDen = 1;
						XForm.nXOffset = 0;
						XForm.nYOffset = 0;
						L_SetBitmapRgnHandle(historyData->Bitmap->RgnBitmap->Handle, &XForm, historyData->FromRegion, L_RGN_SET);
							WorkArea->SetMask(historyData->FromRegion);
					} else {
						WorkArea->Reset();
					}
					if(kind==UK_WORKAREA)break;

				case UK_MASK:
					if(historyData->Mask)	historyData->Mask->PartialUndo->LoadUndo();
					if(kind==UK_MASK||kind==UK_REPEAT)break;

				case UK_COLOR:
					if (historyData->Bitmap->BitsPerPixel==8) {
		//				if(historyData->FromPalette) Palette->SetPalette(historyData->FromRgb);
						if(historyData->FromPalette) Palette->SetPalette(historyData->FromPalette);
						else historyData->Bitmap->PutColors(0, 256, historyData->FromRgb);
            Image->RearrangeColors(historyData->FromRgb);
					}
					if (Palette) {
						if (!historyData->FromPalette)
						{
							Palette->SetPalette(historyData->FromPalette);
						}
					}
					break;
			}
	  	CurrentHistoryIndex--;
      if(bDelete){RemoveLast();}    //by linuxjun for ¸Þ´º½ÇÇàÁß À߸øµÇ¾î UndoµÉ¶§ À߸øµÈ dataÀÇ »èÁ¦¸¦ À§ÇÔ.
      if(bDelete&&CurrentHistoryIndex>StartingIndexOfPenUndo){
      //bDelete°¡ falseÀÌ¸é ¸Þ´º¿¡¼­ »ç¿ëÇÏ´Â UndoÀ̹ǷΠUK_COLOR³ª UK_WORKAREAÀ̸é Áö¿ì°í Çѹø´õ ºÎ¸¥´Ù.
        if(kind==UK_COLOR||kind==UK_WORKAREA){
          return UndoRead(bDelete);
        }
      }

    	return true;
		}else{
			//when there is not current Bitmap by Removing Layer
//			LayerChange(Image->uBitmap->getLayerOrder(),historyData->getCurrentLayerOrder()); //by linuxjun
			switch(kind)
			{

        case UK_REARRANGE:
          if(Image->uBitmap->BitsPerPixel==8)
          {
						if(historyData->FromPalette) Palette->SetPalette(historyData->FromPalette);
						else Image->uBitmap->PutColors(0, 256, historyData->FromRgb);     //À§ÀÇ ºÎºÐÀ̶û history¿¡¼­ Image·Î¹Ù²ïºÎºÐÀÌ ´Ù¸¥ºÎºÐÀÓ
            Image->RearrangeColors(historyData->FromRgb);
            int layerCount = Image->LayerList->Count;
            for(int i = 0; i < layerCount; i++) {
              lay = (TPLayer *)Image->LayerList->Items[i];
              lay->LBitmap->PartialUndo->LoadUndo();
              if(lay->LMask){
                lay->LMask->PartialUndo->LoadUndo();
              }
            }

            break;
					}


				case UK_ALL:
				case UK_REPEAT:
          /*if(kind==UK_REPEAT && MainImageForm->AutoRepeat){
  			    MainImageForm->AutoRepeat = false;
      			MainImageForm->sbAutoRepView->Enabled = false;
      			MainImageForm->ARViewExitForm();

            RemoveAutoRepeatUndo();
            MainImageForm->iMainImage->ReplaceAutoBitmap(MainImageForm->ARLayerCnt-1);
            MainImageForm->iMainImage->EndAutoRepeat();
            MainImageForm->EnlargeCanvasInAutoRepeat();

      			MainImageForm->AutoRepUpdateMenu(true);
       			MainImageForm->iMainImage->OnPaintRange = NULL;
            //            break;
          }*/

				case UK_PATTERN:
					if (historyData->uBitmap->BitsPerPixel==8) {
						if(historyData->FromPalette) Palette->SetPalette(historyData->FromPalette);
					}
					if(kind==UK_PATTERN)break;
				case UK_WORKAREA:
					if(kind==UK_WORKAREA)break;

				case UK_MASK:
					if(kind==UK_MASK||kind==UK_REPEAT)break;

				case UK_COLOR:
					if (historyData->Bitmap->BitsPerPixel==8) {
						if(historyData->FromPalette) Palette->SetPalette(historyData->FromPalette);
					}
					if (Palette) {
						if (!historyData->FromPalette)
						{
							Palette->SetPalette(historyData->FromPalette);
						}
					}
					break;
			}
	  	CurrentHistoryIndex--;
/*      result=UndoRead(true);
      if(!bDelete&&CurrentHistoryIndex>StartingIndexOfPenUndo){
      //bDelete°¡ falseÀÌ¸é ¸Þ´º¿¡¼­ »ç¿ëÇÏ´Â UndoÀ̹ǷΠUK_COLOR³ª UK_WORKAREAÀ̸é Áö¿ì°í Çѹø´õ ºÎ¸¥´Ù.
        if(kind==UK_COLOR||kind==UK_WORKAREA){

          result=UndoRead();
//          return UndoRead();
        }
      }
      return result;*/
      if(bDelete){RemoveLast();}    //by linuxjun for ¸Þ´º½ÇÇàÁß À߸øµÇ¾î UndoµÉ¶§ À߸øµÈ dataÀÇ »èÁ¦¸¦ À§ÇÔ.
    	return UndoRead(bDelete);
		}
fail:
  	if (historyData) delete historyData;
    return false;
  }else{
    return false;   //added for removing warning
  }
}

//---------------------------------------------------------------------------
//void __fastcall TUndo::UndoRead(bool bDelete)
bool __fastcall TUndo::PenUndoRead()
{                 // »õ·Î¿î Undo ¹æ½Ä (MainImageµî¿¡¼­) By GreenFish


  RGBQUAD rgb[256];
	BITMAPHANDLE *tempBitmapHandle;
  bool CanHavePenUndoData=true;

  if(CurrentHistoryPenIndex>=HistoryOfUndoMethod->Count){
    CurrentHistoryPenIndex=HistoryOfUndoMethod->Count-1;
  }
  if(CurrentHistoryPenIndex<0)
  {
    CurrentHistoryPenIndex=0;
    CanHavePenUndoData=false;
  }


	THistoryData * historyData=(THistoryData *)HistoryOfUndoMethod->Items[CurrentHistoryPenIndex];



	int kind=historyData->getFromKind();

  if(kind!=UK_WORKAREA&&kind!=UK_COLOR){
    if(Image->uBitmap->getLayerOrder()!=historyData->getCurrentLayerOrder())
    return false;
    /*
    CurrentLayerOrder=historyData->getCurrentLayerOrder();
    LayerChange(historyData->getToLayerOrder(),historyData->getCurrentLayerOrder()); //by linuxjun
    */
  }else if(kind == UK_REARRANGE){
    return false;
  }
  if(kind==UK_REPEAT && MainImageForm->AutoRepeat){
    return false;
  }


  if(CanHavePenUndoData){
  	switch(kind)
	  {
 		  case UK_ALL:
   		case UK_REPEAT:
	  	case UK_MASK:
		  	if(historyData->Mask){
          if (StartPenUndoMask == false){
            historyData->Mask->PartialUndo->StartPenUndo();
            StartPenUndoMask = true;
          }
          historyData->Mask->PartialUndo->LoadPenUndo(historyData->FromRgb);
        }
    	  PenUndoData=historyData;			//by linuxjun
  			if (kind==UK_MASK)
	  		{
		  		CurrentHistoryPenIndex--;
			  	break;
  			}
	  	case UK_PATTERN:
       	PenUndoData=historyData;			//by linuxjun
  			if(historyData->uBitmap){
          if (StartPenUndoBitmap == false){
            historyData->Bitmap->PartialUndo->StartPenUndo();
            StartPenUndoBitmap = true;
          }
          historyData->uBitmap->PartialUndo->LoadPenUndo(historyData->FromRgb);
        }
   			if(historyData->LayerMask)historyData->LayerMask->PartialUndo->LoadPenUndo(historyData->FromRgb);

		  	CurrentHistoryPenIndex--;

			  break;


  		case UK_WORKAREA:
	  	case UK_COLOR:

			  CurrentHistoryPenIndex--;
        if(CurrentHistoryPenIndex>=0){
//          PenUndoData=NULL;         //caution!!
    			return PenUndoRead();
        }else{
//          PenUndoData=NULL;         //caution!!
          return false;
        }
   	}
  }else{
//    PenUndoData=NULL;                //caution!!
    CurrentHistoryPenIndex--;
  }
  return true;
fail:
	if (historyData) delete historyData;
  return false;
}


//---------------------------------------------------------------------------
bool __fastcall TUndo::RedoRead()
{                       
  RGBQUAD rgb[256];
	BITMAPHANDLE *tempBitmapHandle;
  TPLayer *lay;  


  if(CurrentHistoryIndex < HistoryOfUndoMethod->Count-1){
	  CurrentHistoryIndex++;
  }

	if (CurrentHistoryIndex < 0 || CurrentHistoryIndex >= HistoryOfUndoMethod->Count) {
		return false;
	}
	
	THistoryData * historyData=(THistoryData *)HistoryOfUndoMethod->Items[CurrentHistoryIndex];
	if( IsThereThisBitmap( historyData->getCurrentLayerOrder() ) ){
		LayerChange(historyData->getFromLayerOrder(),historyData->getCurrentLayerOrder()); //by linuxjun
		int kind;
		switch(kind=historyData->getToKind())
		{
			case UK_REARRANGE:
        if(Image->uBitmap->BitsPerPixel==8)
        {
  				if(historyData->FromPalette) Palette->SetPalette(historyData->ToPalette);
					else historyData->uBitmap->PutColors(0, 256, historyData->ToRgb);
          Image->RearrangeColors(historyData->ToRgb);
          int layerCount = Image->LayerList->Count;
          for(int i = 0; i < layerCount; i++) {
            lay = (TPLayer *)Image->LayerList->Items[i];
            lay->LBitmap->PartialUndo->LoadRedo();
            if(lay->LMask){
              lay->LMask->PartialUndo->LoadRedo();
            }
          }
          Image->MakeBeforeBitmap();
          break;
	  		}

			case UK_ALL:
			case UK_REPEAT:
			case UK_PATTERN:
				historyData->uBitmap->PartialUndo->LoadRedo();
				if(historyData->LayerMask) historyData->LayerMask->PartialUndo->LoadRedo();

				if (historyData->uBitmap->BitsPerPixel==8) {
          Byte prevUseColorCnt = Palette->UseColor;

					if(historyData->ToPalette) Palette->SetPalette(historyData->ToPalette);
					else historyData->uBitmap->PutColors(0, 256, historyData->ToRgb);
          Image->RearrangeColors(historyData->ToRgb);

          // Ææ »ö´Ü°è ±â´É »ç¿ë½Ã ¾ðµÎ¸¦ Çصµ »ö´Ü°è°¡ À¯ÁöµÇµµ·Ï Çϱâ À§ÇØ
          if (PenManagerForm && PenManagerForm->aspread)
            PenManagerForm->AddPenSpreadColorForUndo(historyData->PenSpreadStartIdx, historyData->PenSpreadEndIdx, prevUseColorCnt);
				}

			 /*	if (Palette) {
					if (!historyData->ToPalette)
					{
						Palette->SetPalette(historyData->ToPalette);
					}
				}*/
				if(kind==UK_PATTERN)break;


			case UK_WORKAREA:
				if (historyData->ToRegion) {
					RGNXFORM XForm;
					XForm.uViewPerspective = TOP_LEFT;
					XForm.nXScalarNum = 1;
					XForm.nXScalarDen = 1;
					XForm.nYScalarNum = 1;
					XForm.nYScalarDen = 1;
					XForm.nXOffset = 0;
					XForm.nYOffset = 0;
					L_SetBitmapRgnHandle(historyData->Bitmap->RgnBitmap->Handle, &XForm, historyData->ToRegion, L_RGN_SET);
					WorkArea->SetMask(historyData->ToRegion);
	//		  	 	WorkArea->SetMask(XForm);
				} else {
					WorkArea->Reset();
				}
				if(kind==UK_WORKAREA)break;

			case UK_MASK:
				if(historyData->Mask)	historyData->Mask->PartialUndo->LoadRedo();
				if(kind==UK_MASK||kind==UK_REPEAT)break;

			case UK_COLOR:
				if (historyData->Bitmap->BitsPerPixel==8) {
	//				if(Palette) Palette->SetPalette(historyData->ToRgb);
					if(historyData->ToPalette) Palette->SetPalette(historyData->ToPalette);
					else historyData->Bitmap->PutColors(0, 256, historyData->ToRgb);
          Image->RearrangeColors(historyData->FromRgb);          
				}
				if (Palette) {
					if (!historyData->ToPalette)
					{
						Palette->SetPalette(historyData->ToPalette);
					}
				}
				break; 
		}
		return true;
	}else{
//		LayerChange(historyData->getFromLayerOrder(),historyData->getCurrentLayerOrder()); //by linuxjun
		int kind;
		switch(kind=historyData->getToKind())
		{
			case UK_ALL: 
			case UK_REPEAT: 
			case UK_PATTERN:

				if (historyData->uBitmap->BitsPerPixel==8) {
					if(historyData->ToPalette) Palette->SetPalette(historyData->ToPalette);
				}

			 /*	if (Palette) {
					if (!historyData->ToPalette)
					{
						Palette->SetPalette(historyData->ToPalette);
					}
				}*/
				if(kind==UK_PATTERN)break;


			case UK_WORKAREA:
			if(kind==UK_WORKAREA)break;

			case UK_MASK:
				if(kind==UK_MASK||kind==UK_REPEAT)break;

			case UK_COLOR:
				if (historyData->Bitmap->BitsPerPixel==8) {
	//				if(Palette) Palette->SetPalette(historyData->ToRgb);
					if(historyData->ToPalette) Palette->SetPalette(historyData->ToPalette);
				}
				if (Palette) {
					if (!historyData->ToPalette)
					{
						Palette->SetPalette(historyData->ToPalette);
					}
				}
				break; 
		}
   	return RedoRead();

	}
fail:
	if (historyData) delete historyData;
  return false;

}
//---------------------------------------------------------------------------
int __fastcall TUndo::GetListCount()
{
/*
  switch(Do){
   case 'Undo':
     return CurrentHistoryIndex;
   case 'MaxUndoNum':
     return HistoryOfUndoMethod->Count;
  }*/
  /*
	int temp;
	temp = GetMaxUndoNum();
	if(temp > CurrentHistoryIndex){
		temp = CurrentHistoryIndex;
	}*/
	int temp;
	temp = CurrentHistoryIndex;

  if(StartingIndexOfPenUndo > -1){
    temp = CurrentHistoryPenIndex+1;
  }
	//return CurrentHistoryIndex;
	return temp;
//  return HistoryOfUndoMethod->Count;
}
//---------------------------------------------------------------------------
void __fastcall TUndo::RemoveLast()
{

//	for (int i = HistoryOfUndoMethod->Count - 1; i >= 0; i--) {
  if(HistoryOfUndoMethod->Count)
  {
  	  THistoryData *historyData = (THistoryData *)HistoryOfUndoMethod->Last();
  	  HistoryOfUndoMethod->Remove(historyData);
      delete historyData;
      if(HistoryOfUndoMethod->Count<=CurrentHistoryIndex)CurrentHistoryIndex=HistoryOfUndoMethod->Count-1;
//      break;
  }

  /*
	for (int i = HistoryOfUndoMethod->Count - 1; i >= 0; i--) {
  	THistoryData *historyData = (THistoryData *)HistoryOfUndoMethod->Items[i];
    if (historyData->Equal(CurrentLayerOrder)) {

  	  HistoryOfUndoMethod->Remove(historyData);


      delete historyData;
      if(HistoryOfUndoMethod->Count<=CurrentHistoryIndex)CurrentHistoryIndex=HistoryOfUndoMethod->Count-1;
      break;
    }
  }

  */
}
//---------------------------------------------------------------------------
void __fastcall TUndo::RemoveFirst()
{
	//for (int i = HistoryOfUndoMethod->Count - 1; i >= 0; i--) {
	THistoryData *HisData;
	if(HistoryOfUndoMethod->Count > GetMaxUndoNum() && StartingIndexOfPenUndo <= -1){
		if(HistoryOfUndoMethod->Count > 0){
			HisData = (THistoryData *)HistoryOfUndoMethod->First();

			HistoryOfUndoMethod->Remove(HisData);

	    if(HisData->uBitmap && IsThereThisLayerUnionBitmap(HisData->uBitmap)){
        HisData->uBitmap->PartialUndo->RemoveFirst();
      }
    	if(HisData->LayerMask && IsThereThisLayerMaskBitmap(HisData->uBitmap)){
        HisData->LayerMask->PartialUndo->RemoveFirst();
      }
    	if(HisData->Mask) HisData->Mask->PartialUndo->RemoveFirst();

			delete HisData;
			CurrentHistoryIndex--;
		}
	}
}
//---------------------------------------------------------------------------
void __fastcall TUndo::RemoveOneLayerInfo(int layerOrder)
{
  THistoryData *hisdata;
	for (int i = 0; i < HistoryOfUndoMethod->Count;) {
  	hisdata = (THistoryData *)HistoryOfUndoMethod->Items[i];
    if (hisdata->Equal(layerOrder)) {
  	  HistoryOfUndoMethod->Remove(hisdata);
			delete hisdata;
    }
    else i++;
  }
  if(HistoryOfUndoMethod->Count<=CurrentHistoryIndex)CurrentHistoryIndex=HistoryOfUndoMethod->Count-1;
}
//---------------------------------------------------------------------------
void __fastcall TUndo::RemoveAutoRepeatUndo()
{
  int nAutoRepeatNum = -1;
  int i = -1;
  THistoryData *hisdata = NULL;
	for (i = HistoryOfUndoMethod->Count-1; i >=0 ; i--) {
  	hisdata = (THistoryData *)HistoryOfUndoMethod->Items[i];
    if (hisdata->getFromKind()==UK_REPEAT) {
      nAutoRepeatNum = i;
      break;
    }
  }
  if( nAutoRepeatNum >= 0 ){
    while(HistoryOfUndoMethod->Count-1 > nAutoRepeatNum) {
      RemoveLast();
    }
  }
  else {      // AutoRepeat»óÅ¿¡¼­ undosaveµÈ °ÍÀÌ max°ªÀ» ³Ñ´Â °æ¿ì°¡ ÀÖÀ½
    while(HistoryOfUndoMethod->Count > 0){
      RemoveLast();
    }
  }
}
//---------------------------------------------------------------------------
void __fastcall TUndo::RemoveAll()
{
	for (int i = 0; i < HistoryOfUndoMethod->Count;) {
  	THistoryData *hisdata = (THistoryData *)HistoryOfUndoMethod->Items[i];
    if (hisdata->Equal(CurrentLayerOrder)) {
  	  HistoryOfUndoMethod->Remove(hisdata);

	    if(hisdata->uBitmap) hisdata->uBitmap->PartialUndo->RemoveFirst();
    	if(hisdata->LayerMask) hisdata->LayerMask->PartialUndo->RemoveFirst();
    	if(hisdata->Mask) hisdata->Mask->PartialUndo->RemoveFirst();
 			delete hisdata;
    }
    else i++;
  }
  if(HistoryOfUndoMethod->Count<=CurrentHistoryIndex)CurrentHistoryIndex=HistoryOfUndoMethod->Count-1;
}
//---------------------------------------------------------------------------
int __fastcall TUndo::GetMaxUndoNum(){
  if(Maximum>1){
    return Maximum;
  }else{
    return 1;
  }
}
//---------------------------------------------------------------------------
void __fastcall TUndo::SetMaxUndoNum(int maxnum){ Maximum=maxnum; }
//---------------------------------------------------------------------------
bool __fastcall TUndo::CanPenUndoNow()
{
	THistoryData * historyData;
	bool bResult=false;
	int kind;
	int i;
	if(CurrentHistoryPenIndex >= 0){
		bResult= true;
	  if(CurrentHistoryPenIndex>=HistoryOfUndoMethod->Count) CurrentHistoryPenIndex=HistoryOfUndoMethod->Count-1;
		for(int i=CurrentHistoryPenIndex ; i>=0 ; i--)
		{
			historyData=(THistoryData *)HistoryOfUndoMethod->Items[i];

			kind=historyData->getFromKind();
			if(kind!=UK_WORKAREA&&kind!=UK_COLOR){
				if(Image->uBitmap->getLayerOrder()==historyData->getCurrentLayerOrder()){
					bResult=true;
				}else{
					bResult=false;
				}
				break;
			}
		}
		if(i==-1){
			bResult=false;
		}
	}
	return bResult;
} 
//---------------------------------------------------------------------------