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

#include "MoveCopy_F.h"
#include "FullView.h"
#include "MainImage.h"
#include "Palette.h"
#include "Rotation.h"
#include "StatusProgress.h"
#include "Undo.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma link "RXCtrls"
#pragma resource "*.dfm"
//---------------------------------------------------------------------------
#define IDS_ROTATE           StringTable[0]
#define IDS_BEND             StringTable[1]
#define IDS_BEFOREDEGREE     StringTable[2]
//---------------------------------------------------------------------------
TMoveCopyForm *MoveCopyForm;
//---------------------------------------------------------------------------
__fastcall TMoveCopyForm::TMoveCopyForm(TComponent* Owner)
	: TForm(Owner)
{
	hWnd = ((TWinControl *)Owner)->Handle;
//==============================================================
  StringTable.Create(DirectoryBin, Language, "MoveCopy");
  SetSmallFont(Font);
  SetSmallFont(Label1->Font);
	sbCopy->Caption       = IDS_COMMON_COPY;
	sbMove->Caption       = IDS_COMMON_MOVE;
	sbNormal->Caption     = IDS_COMMON_NORMAL;
	sbUDMirror->Caption   = IDS_COMMON_UPDOWNMIRROR;
	sbUpDown->Caption     = IDS_COMMON_UPDOWN;
	sbRotate->Caption     = IDS_ROTATE;
	sbMirror->Caption     = IDS_COMMON_MIRROR;
	sbBend->Caption       = IDS_BEND;
	Label1->Caption       = IDS_COMMON_ANGLE;
	btnRotateRun->Caption = IDS_COMMON_RUN;
  sbBeforeDeg->Hint     = IDS_BEFOREDEGREE;
//==============================================================
}
//---------------------------------------------------------------------------
void __fastcall TMoveCopyForm::FormCreate(TObject *Sender)
{
  MousePointPlace = 5;
  window.Bitmap = window.Mask = window.Back = NULL;
}
//---------------------------------------------------------------------------
void __fastcall TMoveCopyForm::TypeClick(TObject *Sender)
{
  TSpeedButton *s = 0;

  if (IsDraw) {
   	if (MCItem == TMC_ROTATE) {
   		Rotate_Rect();
   	} else if (MCItem == TMC_BEND) {
   		bend_locate();
   	}
  }
  mpPanel->Visible = true;
  s = (TSpeedButton *)Sender;
  if (s == sbNormal) {
  	ClientHeight = 215;
  	Parent->Height = ParentHeight + ClientHeight;
 		MCItem = TMC_NONE;
  } else if (s == sbUpDown) {
 		ClientHeight = 215;
  	Parent->Height = ParentHeight+ClientHeight;
	  MCItem = TMC_UPDOWN;
  } else if (s == sbMirror) {
 		ClientHeight = 215;
  	Parent->Height = ParentHeight+ClientHeight;
 		MCItem = TMC_MIRROR;
  } else if (s == sbUDMirror) {
 		ClientHeight = 215;
  	Parent->Height = ParentHeight+ClientHeight;
	  MCItem = TMC_UDMIRROR;
  } else if (s == sbRotate) {
 		ClientHeight = 152;
  	Parent->Height = ParentHeight+ClientHeight;
	  MCItem = TMC_ROTATE;
    rgBendType->Visible  = false;
    mpPanel->Visible = false;
    RotatePanel->Visible = true;
    tate = 0;
    sw = false;
  } else if (s == sbBend) {
 		ClientHeight = 152;
  	Parent->Height = ParentHeight+ClientHeight;
    RotatePanel->Visible = false;
    mpPanel->Visible = false;
    rgBendType->Visible  = true;
 		MCItem = TMC_BEND;
  	Csx = window.s.x + window.size.x / 2.0;
    Csy = window.s.y + window.size.y / 2.0;
    Dsx = Csx; Dsy = Csy;
	  tR = 0; Sign = 0; Theta = 0;
    step = 0;
  }
  SetMoveCopyImage();
}
//---------------------------------------------------------------------------
void __fastcall TMoveCopyForm::FunctionClick(TObject *Sender)
{
	TSpeedButton *s = 0;
  if (IsDraw) {
   	if (MCItem == TMC_ROTATE) {
   		Rotate_Rect();
   	} else if (MCItem == TMC_BEND) {
   		bend_locate();
   	}
  }
  IsDraw = true;
	s = (TSpeedButton *)Sender;
  if (s == sbCopy) {
  	MCState = TMC_COPY;
  } else if (s == sbMove) {
  	MCState = TMC_MOVE;
  }
  if (MCItem == TMC_ROTATE) {
    tate = 0;
  } else if (MCItem == TMC_BEND) {
  	Csx = window.s.x + window.size.x / 2.0;
    Csy = window.s.y + window.size.y / 2.0;
    Dsx = Csx; Dsy = Csy;
	  tR = 0; Sign = 0; Theta = 0;
    step = 0;
  }
  SetMoveCopyImage();
}
//---------------------------------------------------------------------------
void __fastcall TMoveCopyForm::rgBendTypeClick(TObject *Sender)
{
  TPItemImage *Image = MainImageForm->iMainImage;

  Image->Repaint();
 	Csx = window.s.x + window.size.x / 2.0;
  Csy = window.s.y + window.size.y / 2.0;
  Dsx = Csx; Dsy = Csy;
  tR = 0; Sign = 0; Theta = 0;
  step = 0;
  IsDraw = true;
  SetMoveCopyImage();
}
//---------------------------------------------------------------------------
void __fastcall TMoveCopyForm::btnRotateRunClick(TObject *Sender)
{
  TCursor OldCursor;

  OldCursor = Screen->Cursor;
  Screen->Cursor = crHourGlass;
  if ((0 <= StrToInt(cbRotate->Text)) && (360 > StrToInt(cbRotate->Text))) {
    tate = 0;
    RunData();
	  IsDraw = false;
  	tate  = 1;
  }
  Screen->Cursor = OldCursor;
}
//---------------------------------------------------------------------------
void __fastcall TMoveCopyForm::RunData()
{
  TRotation *Trans = NULL;
  TPoint Cen;

  Cen.x = window.s.x + window.size.x / 2;
  Cen.y = window.s.y + window.size.y / 2;
  if ((Trans = new TRotation) == NULL) {EXCEPTION_MESSAGE_OK(EC_MEMORY_LACK); return;}
  Theta = DegToRad((Extended)StrToInt(cbRotate->Text));
  Trans->translation(-Cen.x, -Cen.y);
  Trans->rotation(-Theta);
  Trans->convert(window.s.x, window.s.y, sx[0], sy[0]);
  sx[0] = sx[0] + Cen.x;
  sy[0] = sy[0] + Cen.y;
  Trans->convert(window.s.x, window.e.y, sx[1], sy[1]);
  sx[1] = sx[1] + Cen.x;
  sy[1] = sy[1] + Cen.y;
  Trans->convert(window.e.x, window.s.y, sx[2], sy[2]);
  sx[2] = sx[2] + Cen.x;
  sy[2] = sy[2] + Cen.y;
  Trans->convert(window.e.x, window.e.y, sx[3], sy[3]);
  sx[3] = sx[3] + Cen.x;
  sy[3] = sy[3] + Cen.y;
  max_x = sx[0]; min_x = max_x;
  max_y = sy[0]; min_y = max_y;
  delete Trans; Trans = 0;

  for (int i = 0; i <= 3; i++) {
    if (min_x >= sx[i]) min_x = sx[i];
    else if (max_x <= sx[i]) max_x = sx[i];
    if (min_y >= sy[i]) min_y = sy[i];
    else if (max_y <= sy[i]) max_y = sy[i];
  }
  RotateArea = Point(max_x-min_x+1, max_y-min_y+1);
  BeforeDeg = StrToInt(cbRotate->Text);
  MakeRotateImage();
}
//---------------------------------------------------------------------------
void __fastcall TMoveCopyForm::cbRotateDblClick(TObject *Sender)
{
	TComboBox *s = (TComboBox *)Sender;
	s->SetFocus();
 	s->SelectAll();
}
//---------------------------------------------------------------------------
void __fastcall TMoveCopyForm::cbRotateKeyPress(TObject *Sender, char &Key)
{
	TComboBox *s = (TComboBox *)Sender;
	if (Key == 13) {
  	if ((0 <= StrToInt(s->Text)) && (360 > StrToInt(s->Text))) {
    	SelectNext((TWinControl *)Sender, true, true);
      Key = 0;
    }
  }
}
//---------------------------------------------------------------------------
void __fastcall TMoveCopyForm::sbBeforeDegClick(TObject *Sender)
{
	cbRotate->Text = BeforeDeg;
  btnRotateRunClick(btnRotateRun);
}
//---------------------------------------------------------------------------
// Private Function
//---------------------------------------------------------------------------
void __fastcall TMoveCopyForm::EraseWorkAreaIn()
{
  int i, j;
  Byte *IP, *WP, wm;
  COLORREF color;
  TPItemImage *Image = MainImageForm->iMainImage;

	if (!Image->Bitmap->StartScanLine()) goto fail;
	if (!MainImageForm->WorkArea->Mask->StartScanLine()) goto fail;
  if (Image->Bitmap->BitsPerPixel==8) {
		color = PaletteForm->DIB256Palette->GetBGCOLORREF(8);
 		for (i=0; i<window.size.y; i++) {
  		IP = Image->Bitmap->GetScanLine(window.s.y+i)+window.s.x;
  		WP = MainImageForm->WorkArea->Mask->GetScanLine(i);
			for (j=0; j<window.size.x; j++, IP++, WP++) {
  	 		if (*WP) {
        	*IP = color;
        }
  		}
  		Image->Bitmap->PutScanLine(window.s.y+i);
		}
  } else {
		color = PaletteForm->DIB256Palette->GetBGCOLORREF(24);
		for (i=0; i<window.size.y; i++) {
  		IP = Image->Bitmap->GetScanLine(window.s.y+i)+3*window.s.x;
  		WP = MainImageForm->WorkArea->Mask->GetScanLine(i);
      wm = 0x80;
			for (j=0; j<window.size.x; j++, IP+=3) {
  	 		if (*WP&wm) {
 					SetPixel24(IP, color);
    		}
        if (wm==1) { WP++; wm = 0x80; } else wm >>= 1;
  		}
  		Image->Bitmap->PutScanLine(window.s.y+i);
		}
  }
	MainImageForm->WorkArea->Mask->StopScanLine();
	Image->Bitmap->StopScanLine();
  return;
fail:
	MainImageForm->WorkArea->Mask->StopScanLine();
	Image->Bitmap->StopScanLine();
  EXCEPTION_MESSAGE_OK(EC_MEMORY_LACK);
}
//---------------------------------------------------------------------------
/*
void __fastcall TMoveCopyForm::Symmerty(int X, int Y)
{
  int ww, hh, l;
  TPItemImage *Image = MainImageForm->iMainImage;
  TPSelectImage *MoveCopyImage = MainImageForm->iSelectImage;

	l = min(MainImageForm->Panel->Width, Image->Bitmap->Width*MoveCopyImage->ZoomIn/MoveCopyImage->ZoomOut);
	if (MoveCopyImage->Width==l) {
  	l = Image->PositionX-X;
  	if (l<0) {
	 		MoveCopyImage->Left = -l*MoveCopyImage->ZoomIn/MoveCopyImage->ZoomOut;
 			MoveCopyImage->PositionX = 0;
    } else {
			MoveCopyImage->Left = 0;
      MoveCopyImage->PositionX = l;
    }
	} else {
    if (X>=Image->Bitmap->Width-MoveCopyImage->Bitmap->Width)
    	X = Image->Bitmap->Width-MoveCopyImage->Bitmap->Width;
		MoveCopyImage->Left = Image->BitmapToCanvasX(X);
   	MoveCopyImage->PositionX = 0;
	}

	l = min(MainImageForm->Panel->Height, Image->Bitmap->Height*MoveCopyImage->ZoomIn/MoveCopyImage->ZoomOut);
	if (MoveCopyImage->Height==l) {
  	l = Image->PositionY-Y;
  	if (l<0) {
	 		MoveCopyImage->Top = -l*MoveCopyImage->ZoomIn/MoveCopyImage->ZoomOut;
 			MoveCopyImage->PositionY = 0;
    } else {
	 		MoveCopyImage->Top = 0;
 			MoveCopyImage->PositionY = l;
    }
	} else {
    if (Y>=Image->Bitmap->Height-MoveCopyImage->Bitmap->Height)
    	Y = Image->Bitmap->Height-MoveCopyImage->Bitmap->Height;
 		MoveCopyImage->Top = Image->BitmapToCanvasY(Y);
    MoveCopyImage->PositionY = 0;
	}

	if (MoveCopyImage->Width==MainImageForm->Panel->Width) {
 		MoveCopyRect.s.x = Image->PositionX-MoveCopyImage->PositionX;
	} else {
 		MoveCopyRect.s.x = Image->CanvasToBitmapX(MoveCopyImage->Left);
	}
	if (MoveCopyImage->Height==MainImageForm->Panel->Height) {
 		MoveCopyRect.s.y = Image->PositionY-MoveCopyImage->PositionY;
	} else {
 		MoveCopyRect.s.y = Image->CanvasToBitmapY(MoveCopyImage->Top);
	}
 	MoveCopyRect.e.x = MoveCopyRect.s.x+MoveCopyRect.size.x;
 	MoveCopyRect.e.y = MoveCopyRect.s.y+MoveCopyRect.size.y;

	if (MoveCopyImage->Bitmap->Width>MainImageForm->Panel->Width*MoveCopyImage->ZoomOut/MoveCopyImage->ZoomIn) {
   	MoveCopyImage->Width = MainImageForm->Panel->Width;
	} else {
    ww = Image->Bitmap->Width*MoveCopyImage->ZoomIn/MoveCopyImage->ZoomOut;
    if (MoveCopyImage->Bitmap->Width > Image->Bitmap->Width) {
   	  MoveCopyImage->Width = ww - MoveCopyImage->Left;
    } else {
   	  MoveCopyImage->Width = MoveCopyImage->Bitmap->Width*MoveCopyImage->ZoomIn/MoveCopyImage->ZoomOut;
    }
	}

	if (MoveCopyImage->Bitmap->Height>MainImageForm->Panel->Height*MoveCopyImage->ZoomOut/MoveCopyImage->ZoomIn) {
    MoveCopyImage->Height = MainImageForm->Panel->Height;
  } else {
    if (MoveCopyImage->Bitmap->Height > Image->Bitmap->Height) {
      hh = Image->Bitmap->Height*MoveCopyImage->ZoomIn/MoveCopyImage->ZoomOut;
      MoveCopyImage->Height = hh - MoveCopyImage->Top;
    } else {
      MoveCopyImage->Height = MoveCopyImage->Bitmap->Height*MoveCopyImage->ZoomIn/MoveCopyImage->ZoomOut;
    }
  }
}
*/
void __fastcall TMoveCopyForm::Symmerty(int X, int Y)
{
  int iw, sw, ih, sh;
  TPItemImage *Image = MainImageForm->iMainImage;
  TPSelectImage *MoveCopyImage = MainImageForm->iSelectImage;

  iw = Image->Bitmap->Width * Image->ZoomIn / Image->ZoomOut;
  sw = MoveCopyImage->Bitmap->Width * MoveCopyImage->ZoomIn / MoveCopyImage->ZoomOut;
	MoveCopyImage->Left = Image->BitmapToCanvasX(X);
  MoveCopyImage->PositionX = 0;
	MoveCopyRect.s.x = Image->CanvasToBitmapX(MoveCopyImage->Left);
 	MoveCopyRect.e.x = MoveCopyRect.s.x+MoveCopyRect.size.x;
  if (iw < MainImageForm->Panel->Width) {
    if (MoveCopyImage->Left + sw > iw) {
		  MoveCopyImage->Width = iw - MoveCopyImage->Left;
    } else {
		  MoveCopyImage->Width = sw;
    }
  } else {
	  MoveCopyImage->Width = sw;
  }

  ih = Image->Bitmap->Height * Image->ZoomIn / Image->ZoomOut;
  sh = MoveCopyImage->Bitmap->Height * MoveCopyImage->ZoomIn / MoveCopyImage->ZoomOut;
	MoveCopyImage->Top = Image->BitmapToCanvasY(Y);
  MoveCopyImage->PositionY = 0;
	MoveCopyRect.s.y = Image->CanvasToBitmapY(MoveCopyImage->Top);
 	MoveCopyRect.e.y = MoveCopyRect.s.y+MoveCopyRect.size.y;
#ifdef KNIT
	if (MoveCopyImage->Top <= MainImageForm->Panel->Height - ih) {
	  MoveCopyImage->Height = sh - (MainImageForm->Panel->Height - ih - MoveCopyImage->Top);
		MoveCopyImage->Top = MainImageForm->Panel->Height - ih;
  } else {
	  MoveCopyImage->Height = sh;
  }
#else
  if (ih < MainImageForm->Panel->Height) {
    if (MoveCopyImage->Top + sh > ih) {
		  MoveCopyImage->Height = ih - MoveCopyImage->Top;
    } else {
		  MoveCopyImage->Height = sh;
    }
  } else {
	  MoveCopyImage->Height = sh;
  }
#endif
}
//---------------------------------------------------------------------------
bool __fastcall TMoveCopyForm::SymmertyMouseDown(int X, int Y)
{
  TCursor OldCursor;
  int i, j, ww, hh;
  Byte *IP, *WP, *MP, *WMP, mm;
  bool undoSw = false;
  COLORREF color, IC, WC, bgc, c;
  RECT temp, temp1;
  TPItemImage *Image = MainImageForm->iMainImage;
  TPSelectImage *MoveCopyImage = MainImageForm->iSelectImage;

  Symmerty(X, Y);
	if (MCState==TMC_MOVE) {
      SetRect(&temp, MoveCopyRect.s.x, MoveCopyRect.s.y, MoveCopyRect.e.x, MoveCopyRect.e.y);
      UnionRect(&temp1, &temp, &MainImageForm->WorkArea->Range);
  	  undoSw = MainImageForm->UndoSave(UK_ALL,
        Rect(temp1.left, temp1.top, temp1.right, temp1.bottom), true);
      if (undoSw == false) goto fail;
	} else if (MCState==TMC_COPY) {
  	  undoSw = MainImageForm->UndoSave(UK_PATTERN,
        Rect(MoveCopyRect.s.x, MoveCopyRect.s.y, MoveCopyRect.e.x, MoveCopyRect.e.y), true);
      if (undoSw == false) goto fail;
  }
	if (MCState == TMC_MOVE) { EraseWorkAreaIn();  SymmertyMouseMove(X, Y); }

  if (FullViewForm->Super==sOverlap) {
    FullViewForm->ReadyToOverlapChange(MoveCopyImage->Bitmap, Rect(MoveCopyRect.s.x,
      MoveCopyRect.s.y, MoveCopyRect.e.x, MoveCopyRect.e.y), MainImageForm->Palette->UseColor);
  }

  ww = Image->Bitmap->Width;
  hh = Image->Bitmap->Height;

  if (MainImageForm->MaskArea) {
	  if (Image->Bitmap->BitsPerPixel==8) {
			if (MainImageForm->Protect) {
  			if (!Image->Bitmap->StartScanLine()) goto fail;
  			if (!Image->Mask->StartScanLine()) goto fail;
	 			if (!MoveCopyImage->Bitmap->StartScanLine()) goto fail;
        if (!window.Mask->StartScanLine()) goto fail;
				if (FullViewForm->Super==sOverlap) {
  	     	MainImageForm->InitOverlap();
					for (i=0; i<MoveCopyRect.size.y; i++) {
            if (MoveCopyRect.s.y+i < 0 ||  MoveCopyRect.s.y+i >= hh) continue;
 						IP = Image->Bitmap->GetScanLine(MoveCopyRect.s.y+i)+MoveCopyRect.s.x;
 						MP = Image->Mask->GetScanLine(MoveCopyRect.s.y+i)+MoveCopyRect.s.x;
 						WP = MoveCopyImage->Bitmap->GetScanLine(i);
            WMP = window.Mask->GetScanLine(i);
						for (j=0; j<MoveCopyRect.size.x; j++, IP++, WP++, MP++, WMP++) {
              if (MoveCopyRect.s.x+j < 0 || MoveCopyRect.s.x+j >= ww) continue;
     				  if (MainImageForm->Palette->ColorData[*IP]->Protect==0 && *MP == 0 && *WMP == 0) {
                if (*IP > 1) {
 	         	    color = MainImageForm->Overlap(*IP, *WP);
	   	      	    if (color==0xFF) {
	     		          MainImageForm->ExitOverlap();
								    Image->Bitmap->StopScanLine();
									  Image->Mask->StopScanLine();
									  MoveCopyImage->Bitmap->StopScanLine();
                    window.Mask->StopScanLine();
									  Undo->Read();
									  ::RepaintColor();
				            EXCEPTION_MESSAGE_OK(EC_COLOR_OVERFLOW);
            	   	  return false;
                  } else {
									  *IP = color;
	 	           	  }
                } else *IP = *WP;
              }
						}
 						Image->Bitmap->PutScanLine(MoveCopyRect.s.y+i);
					}
	     		MainImageForm->ExitOverlap();
  	    } else {
					for (i=0; i<MoveCopyRect.size.y; i++) {
            if (MoveCopyRect.s.y+i < 0 || MoveCopyRect.s.y+i >= hh) continue;
 						IP = Image->Bitmap->GetScanLine(MoveCopyRect.s.y+i)+MoveCopyRect.s.x;
 						MP = Image->Mask->GetScanLine(MoveCopyRect.s.y+i)+MoveCopyRect.s.x;
 						WP = MoveCopyImage->Bitmap->GetScanLine(i);
            WMP = window.Mask->GetScanLine(i);
						for (j=0; j<MoveCopyRect.size.x; j++, IP++, WP++, MP++, WMP++) {
              if (MoveCopyRect.s.x+j < 0 || MoveCopyRect.s.x+j >= ww) continue;
   						if (MainImageForm->Palette->ColorData[*IP]->Protect==0 && *MP == 0 && *WMP == 0) {
								*IP = *WP;
	    				}
						}
  					Image->Bitmap->PutScanLine(MoveCopyRect.s.y+i);
					}
	   		}
        window.Mask->StopScanLine();
  			Image->Bitmap->StopScanLine();
  			Image->Mask->StopScanLine();
  			MoveCopyImage->Bitmap->StopScanLine();
			} else {
				if (!Image->Bitmap->StartScanLine()) goto fail;
				if (!Image->Mask->StartScanLine()) goto fail;
				if (!MoveCopyImage->Bitmap->StartScanLine()) goto fail;
        if (!window.Mask->StartScanLine()) goto fail;
				if (FullViewForm->Super==sOverlap) {
      		MainImageForm->InitOverlap();
					for (i=0; i<MoveCopyRect.size.y; i++) {
            if (MoveCopyRect.s.y+i < 0 || MoveCopyRect.s.y+i >= hh) continue;
  					IP = Image->Bitmap->GetScanLine(MoveCopyRect.s.y+i)+MoveCopyRect.s.x;
  					MP = Image->Mask->GetScanLine(MoveCopyRect.s.y+i)+MoveCopyRect.s.x;
	 					WP = MoveCopyImage->Bitmap->GetScanLine(i);
            WMP = window.Mask->GetScanLine(i);
						for (j=0; j<MoveCopyRect.size.x; j++, IP++, WP++, MP++, WMP++) {
              if (MoveCopyRect.s.x+j < 0 || MoveCopyRect.s.x+j >= ww) continue;
     					if (*MP == 0 && *WMP == 0) {
                if (*IP > 1) {
	    	  	   	  color = MainImageForm->Overlap(*IP, *WP);
  	    	  	 	  if (color==0xFF) {
	     		          MainImageForm->ExitOverlap();
									  Image->Bitmap->StopScanLine();
									  Image->Mask->StopScanLine();
									  MoveCopyImage->Bitmap->StopScanLine();
                    window.Mask->StopScanLine();
									  Undo->Read();
									  ::RepaintColor();
				            EXCEPTION_MESSAGE_OK(EC_COLOR_OVERFLOW);
            	   	  return false;
	  	    	   	  } else {
									  *IP = color;
  	    	   		  }
                } else *IP = *WP;
              }
						}
  					Image->Bitmap->PutScanLine(MoveCopyRect.s.y+i);
					}
      		MainImageForm->ExitOverlap();
  	    } else {
					for (i=0; i<MoveCopyRect.size.y; i++) {
            if (MoveCopyRect.s.y+i < 0 || MoveCopyRect.s.y+i >= hh) continue;
 						IP = Image->Bitmap->GetScanLine(MoveCopyRect.s.y+i)+MoveCopyRect.s.x;
 						MP = Image->Mask->GetScanLine(MoveCopyRect.s.y+i)+MoveCopyRect.s.x;
 						WP = MoveCopyImage->Bitmap->GetScanLine(i);
            WMP = window.Mask->GetScanLine(i);
						for (j=0; j<MoveCopyRect.size.x; j++, IP++, WP++, MP++, WMP++) {
              if (MoveCopyRect.s.x+j < 0 || MoveCopyRect.s.x+j >= ww) continue;
   						if (*MP == 0 && *WMP == 0) {
								*IP = *WP;
	    				}
						}
  					Image->Bitmap->PutScanLine(MoveCopyRect.s.y+i);
					}
		   	}
        window.Mask->StopScanLine();
				Image->Bitmap->StopScanLine();
				Image->Mask->StopScanLine();
				MoveCopyImage->Bitmap->StopScanLine();
 			}
	  } else {
  	  bgc = PaletteForm->DIB256Palette->GetBGCOLORREF(24);
			if (!Image->Bitmap->StartScanLine()) goto fail;
			if (!Image->Mask->StartScanLine()) goto fail;
			if (!MoveCopyImage->Bitmap->StartScanLine()) goto fail;
			if (!window.Mask->StartScanLine()) goto fail;
			if (FullViewForm->Super==sOverlap) {
	    	MainImageForm->InitOverlap();
				for (i=0; i<MoveCopyRect.size.y; i++) {
          if (MoveCopyRect.s.y+i < 0 || MoveCopyRect.s.y+i >= hh) continue;
					IP = Image->Bitmap->GetScanLine(MoveCopyRect.s.y+i)+3*MoveCopyRect.s.x;
					MP = Image->Mask->GetScanLine(MoveCopyRect.s.y+i);
					WP = MoveCopyImage->Bitmap->GetScanLine(i);
			    WMP = window.Mask->GetScanLine(i);
          mm = 0x80;
					for (j=0; j<MoveCopyRect.size.x; j++, IP+=3, WP+=3) {
            if (MoveCopyRect.s.x+j < 0 || MoveCopyRect.s.x+j >= ww) continue;
            GetPixel24(IP, c);
            if (((MP[(MoveCopyRect.s.x + j) >> 3] & (0x80 >> ((MoveCopyRect.s.x + j) & 7))) == 0)
              && ((*WMP&mm) == 0)) {
              if (c != bgc) {
        			  GetPixel24(IP, IC);
	        		  GetPixel24(WP, WC);
  		     		  color = MainImageForm->Overlap(IC, WC);
							  SetPixel24(IP, color);
              } else CopyPixel24(IP, WP);
            }
            if (mm == 1) { mm = 0x80; WMP++; } else mm >>= 1;
					}
					Image->Bitmap->PutScanLine(MoveCopyRect.s.y+i);
				}
  	  	MainImageForm->ExitOverlap();
	    } else {
				for (i=0; i<MoveCopyRect.size.y; i++) {
          if (MoveCopyRect.s.y+i < 0 || MoveCopyRect.s.y+i >= hh) continue;
					IP = Image->Bitmap->GetScanLine(MoveCopyRect.s.y+i)+3*MoveCopyRect.s.x;
					MP = Image->Mask->GetScanLine(MoveCopyRect.s.y+i);
					WP = MoveCopyImage->Bitmap->GetScanLine(i);
			    WMP = window.Mask->GetScanLine(i);
          mm = 0x80;
					for (j=0; j<MoveCopyRect.size.x; j++, IP+=3, WP+=3) {
            if (MoveCopyRect.s.x+j < 0 || MoveCopyRect.s.x+j >= ww) continue;
            GetPixel24(IP, c);
            if (((MP[(MoveCopyRect.s.x + j) >> 3] & (0x80 >> ((MoveCopyRect.s.x + j) & 7))) == 0)
              && ((*WMP&mm) == 0)) {
              CopyPixel24(IP, WP);
            }
            if (mm == 1) { mm = 0x80; WMP++; } else mm >>= 1;
					}
					Image->Bitmap->PutScanLine(MoveCopyRect.s.y+i);
				}
	  	}
			Image->Bitmap->StopScanLine();
			Image->Mask->StopScanLine();
			MoveCopyImage->Bitmap->StopScanLine();
      window.Mask->StopScanLine();
  	}
  } else {
	  if (Image->Bitmap->BitsPerPixel==8) {
			if (MainImageForm->Protect) {
  			if (!Image->Bitmap->StartScanLine()) goto fail;
	 			if (!MoveCopyImage->Bitmap->StartScanLine()) goto fail;
        if (!window.Mask->StartScanLine()) goto fail;
				if (FullViewForm->Super==sOverlap) {
  	     	MainImageForm->InitOverlap();
					for (i=0; i<MoveCopyRect.size.y; i++) {
            if (MoveCopyRect.s.y+i < 0 || MoveCopyRect.s.y+i >= hh) continue;
 						IP = Image->Bitmap->GetScanLine(MoveCopyRect.s.y+i)+MoveCopyRect.s.x;
 						WP = MoveCopyImage->Bitmap->GetScanLine(i);
            WMP = window.Mask->GetScanLine(i);
						for (j=0; j<MoveCopyRect.size.x; j++, IP++, WP++, WMP++) {
              if (MoveCopyRect.s.x+j < 0 || MoveCopyRect.s.x+j >= ww) continue;
     					if (MainImageForm->Palette->ColorData[*IP]->Protect==0 && *WMP == 0) {
                if (*IP > 1) {
 	         			  color = MainImageForm->Overlap(*IP, *WP);
	   	       		  if (color==0xFF) {
					          MainImageForm->ExitOverlap();
          				  Image->Bitmap->StopScanLine();
									  MoveCopyImage->Bitmap->StopScanLine();
                    window.Mask->StopScanLine();
									  Undo->Read();
									  ::RepaintColor();
				            EXCEPTION_MESSAGE_OK(EC_COLOR_OVERFLOW);
            	   	  return false;
           			  } else {
									  *IP = color;
	 	           	  }
                } else *IP = *WP;
  	 	       	}
						}
 						Image->Bitmap->PutScanLine(MoveCopyRect.s.y+i);
					}
	     		MainImageForm->ExitOverlap();
  	    } else {
					for (i=0; i<MoveCopyRect.size.y; i++) {
            if (MoveCopyRect.s.y+i < 0 || MoveCopyRect.s.y+i >= hh) continue;
 						IP = Image->Bitmap->GetScanLine(MoveCopyRect.s.y+i)+MoveCopyRect.s.x;
 						WP = MoveCopyImage->Bitmap->GetScanLine(i);
            WMP = window.Mask->GetScanLine(i);
						for (j=0; j<MoveCopyRect.size.x; j++, IP++, WP++, WMP++) {
              if (MoveCopyRect.s.x+j < 0 || MoveCopyRect.s.x+j >= ww) continue;
   						if (MainImageForm->Palette->ColorData[*IP]->Protect==0 && *WMP == 0) {
								*IP = *WP;
	    				}
						}
  					Image->Bitmap->PutScanLine(MoveCopyRect.s.y+i);
					}
	   		}
  			Image->Bitmap->StopScanLine();
  			MoveCopyImage->Bitmap->StopScanLine();
        window.Mask->StopScanLine();
			} else {
        if (!Image->Bitmap->StartScanLine()) goto fail;
				if (!MoveCopyImage->Bitmap->StartScanLine()) goto fail;
				if (!window.Mask->StartScanLine()) goto fail;
				if (FullViewForm->Super==sOverlap) {
      		MainImageForm->InitOverlap();
					for (i=0; i<MoveCopyRect.size.y; i++) {
            if (MoveCopyRect.s.y+i < 0 || MoveCopyRect.s.y+i >= hh) continue;
  					IP = Image->Bitmap->GetScanLine(MoveCopyRect.s.y+i)+MoveCopyRect.s.x;
	 					WP = MoveCopyImage->Bitmap->GetScanLine(i);
            WMP = window.Mask->GetScanLine(i);
						for (j=0; j<MoveCopyRect.size.x; j++, IP++, WP++, WMP++) {
              if (MoveCopyRect.s.x+j < 0 || MoveCopyRect.s.x+j >= ww) continue;
              if (*WMP == 0) {
                if (*IP > 1) {
    	  	   	    color = MainImageForm->Overlap(*IP, *WP);
      	  	 	    if (color==0xFF) {
	     		          MainImageForm->ExitOverlap();
							      Image->Bitmap->StopScanLine();
							      MoveCopyImage->Bitmap->StopScanLine();
                    window.Mask->StopScanLine();
							      Undo->Read();
							      ::RepaintColor();
			              EXCEPTION_MESSAGE_OK(EC_COLOR_OVERFLOW);
           	        return false;
  	    	   	    } else {
							      *IP = color;
      	   		    }
                } else *IP = *WP;
              }
						}
  					Image->Bitmap->PutScanLine(MoveCopyRect.s.y+i);
					}
      		MainImageForm->ExitOverlap();
  	    } else {
					for (i=0; i<MoveCopyRect.size.y; i++) {
            if (MoveCopyRect.s.y+i < 0 || MoveCopyRect.s.y+i >= hh) continue;
  					IP = Image->Bitmap->GetScanLine(MoveCopyRect.s.y+i)+MoveCopyRect.s.x;
	 					WP = MoveCopyImage->Bitmap->GetScanLine(i);
            WMP = window.Mask->GetScanLine(i);
						for (j=0; j<MoveCopyRect.size.x; j++, IP++, WP++, WMP++) {
              if (MoveCopyRect.s.x+j < 0 || MoveCopyRect.s.x+j >= ww) continue;
              if (*WMP == 0) *IP = *WP;
						}
  					Image->Bitmap->PutScanLine(MoveCopyRect.s.y+i);
					}
		   	}
				Image->Bitmap->StopScanLine();
				MoveCopyImage->Bitmap->StopScanLine();
				window.Mask->StopScanLine();
 			}
	  } else {
  	  bgc = PaletteForm->DIB256Palette->GetBGCOLORREF(24);
			if (!Image->Bitmap->StartScanLine()) goto fail;
  		if (!MoveCopyImage->Bitmap->StartScanLine()) goto fail;
			if (!window.Mask->StartScanLine()) goto fail;
			if (FullViewForm->Super==sOverlap) {
	    	MainImageForm->InitOverlap();
				for (i=0; i<MoveCopyRect.size.y; i++) {
          if (MoveCopyRect.s.y+i < 0 || MoveCopyRect.s.y+i >= hh) continue;
					IP = Image->Bitmap->GetScanLine(MoveCopyRect.s.y+i)+3*MoveCopyRect.s.x;
					WP = MoveCopyImage->Bitmap->GetScanLine(i);
          WMP = window.Mask->GetScanLine(i);
          mm = 0x80;
					for (j=0; j<MoveCopyRect.size.x; j++, IP+=3, WP+=3) {
            if (MoveCopyRect.s.x+j < 0 || MoveCopyRect.s.x+j >= ww) continue;
            if ((*WMP&mm) == 0) {
        		  GetPixel24(IP, IC);
              if (IC != bgc) {
	        	    GetPixel24(WP, WC);
  		     	    color = MainImageForm->Overlap(IC, WC);
						    SetPixel24(IP, color);
              } else  CopyPixel24(IP, WP);
            }
            if (mm == 1) { mm = 0x80; WMP++; } else mm >>= 1;
					}
					Image->Bitmap->PutScanLine(MoveCopyRect.s.y+i);
				}
  	  	MainImageForm->ExitOverlap();
	    } else {
				for (i=0; i<MoveCopyRect.size.y; i++) {
          if (MoveCopyRect.s.y+i < 0 || MoveCopyRect.s.y+i >= hh) continue;
					IP = Image->Bitmap->GetScanLine(MoveCopyRect.s.y+i)+3*MoveCopyRect.s.x;
					WP = MoveCopyImage->Bitmap->GetScanLine(i);
          WMP = window.Mask->GetScanLine(i);
          mm = 0x80;
					for (j=0; j<MoveCopyRect.size.x; j++, IP+=3, WP+=3) {
            if (MoveCopyRect.s.x+j < 0 || MoveCopyRect.s.x+j >= ww) continue;
            if ((*WMP&mm) == 0) CopyPixel24(IP, WP);
            if (mm == 1) { mm = 0x80; WMP++; } else mm >>= 1;
					}
					Image->Bitmap->PutScanLine(MoveCopyRect.s.y+i);
				}
	  	}
  		Image->Bitmap->StopScanLine();
			MoveCopyImage->Bitmap->StopScanLine();
			window.Mask->StopScanLine();
  	}
  }

  if (FullViewForm->Super==sOverlap && MCState==TMC_COPY) {
    if (Image->Bitmap->BitsPerPixel == 8) {
      Image->Bitmap->GetColors(0, 256, rgb);
      rgb[252].rgbRed   = 192;   //-----clBtnFace
      rgb[252].rgbGreen = 192;
      rgb[252].rgbBlue  = 192;
      MoveCopyImage->Bitmap->PutColors(0, 256, rgb);
      window.Bitmap->PutColors(0, 256, rgb);
    }
  }
	::RepaintImage();
  return true;
fail:
	Image->Mask->StopScanLine();
	window.Mask->StopScanLine();
	MoveCopyImage->Bitmap->StopScanLine();
  Image->Bitmap->StopScanLine();
  if (undoSw == true) Undo->RemoveLast();
  EXCEPTION_MESSAGE_OK(EC_MEMORY_LACK);
  return false;
}
//---------------------------------------------------------------------------
void __fastcall TMoveCopyForm::SymmertyMouseMove(int X, int Y)
{
  Byte *PP, *MP, *MBP, *DP, *IP, mm;
  int x, y, ww, hh;
  COLORREF bgc, c;
  TPItemImage *Image = MainImageForm->iMainImage;
  TPSelectImage *MoveCopyImage = MainImageForm->iSelectImage;

  Symmerty(X, Y);

  ww = Image->Bitmap->Width;
  hh = Image->Bitmap->Height;

  if (Image->Bitmap->BitsPerPixel == 8) {
    if (!MoveCopyImage->Bitmap->StartScanLine()) goto fail;
    if (!window.Bitmap->StartScanLine()) goto fail;
    if (!window.Mask->StartScanLine()) goto fail;
    if (!Image->Bitmap->StartScanLine()) goto fail;
    if (MainImageForm->MaskArea) {
      if (!Image->Mask->StartScanLine()) goto fail;
      if (MainImageForm->Protect) {
        if (FullViewForm->Super == sGauze) {
          for (y = 0; y < MoveCopyRect.size.y; y++) {
            if (MoveCopyRect.s.y + y < 0 || MoveCopyRect.s.y + y >= hh) continue;
            MBP = Image->Mask->GetScanLine(MoveCopyRect.s.y + y) + MoveCopyRect.s.x;
            IP = Image->Bitmap->GetScanLine(MoveCopyRect.s.y + y) + MoveCopyRect.s.x;
            DP = MoveCopyImage->Bitmap->GetScanLine(y);
            PP = window.Bitmap->GetScanLine(y);
            MP = window.Mask->GetScanLine(y);
            for (x = 0; x < MoveCopyRect.size.x; x++, MBP++, IP++, DP++, PP++, MP++) {
              if (MoveCopyRect.s.x + x < 0 || MoveCopyRect.s.x + x >= ww) continue;
              if (MainImageForm->Palette->ColorData[*IP]->Protect == 0 && *MBP == 0) {
                if (*MP) {
                  *DP = *IP;
                } else {
                  if (*IP > 1){
                    if ((y+x)&1) *DP = *PP; else *DP = *IP;
                  } else *DP = *PP;
                }
              } else {
                *DP = *IP;
              }
            }
            MoveCopyImage->Bitmap->PutScanLine(y);
          }
        } else {
          for (y = 0; y < MoveCopyRect.size.y; y++) {
            if (MoveCopyRect.s.y + y < 0 || MoveCopyRect.s.y + y >= hh) continue;
            MBP = Image->Mask->GetScanLine(MoveCopyRect.s.y + y) + MoveCopyRect.s.x;
            IP = Image->Bitmap->GetScanLine(MoveCopyRect.s.y + y) + MoveCopyRect.s.x;
            DP = MoveCopyImage->Bitmap->GetScanLine(y);
            PP = window.Bitmap->GetScanLine(y);
            MP = window.Mask->GetScanLine(y);
            for (x = 0; x < MoveCopyRect.size.x; x++, MBP++, IP++, DP++, PP++, MP++) {
              if (MoveCopyRect.s.x + x < 0 || MoveCopyRect.s.x + x >= ww) continue;
              if (MainImageForm->Palette->ColorData[*IP]->Protect == 0 && *MBP == 0) {
                if (*MP) *DP = *IP; else *DP = *PP;
              } else {
                *DP = *IP;
              }
            }
            MoveCopyImage->Bitmap->PutScanLine(y);
          }
        }
      } else {
        if (FullViewForm->Super == sGauze) {
          for (y = 0; y < MoveCopyRect.size.y; y++) {
            if (MoveCopyRect.s.y + y < 0 || MoveCopyRect.s.y + y >= hh) continue;
            MBP = Image->Mask->GetScanLine(MoveCopyRect.s.y + y) + MoveCopyRect.s.x;
            IP = Image->Bitmap->GetScanLine(MoveCopyRect.s.y + y) + MoveCopyRect.s.x;
            DP = MoveCopyImage->Bitmap->GetScanLine(y);
            PP = window.Bitmap->GetScanLine(y);
            MP = window.Mask->GetScanLine(y);
            for (x = 0; x < MoveCopyRect.size.x; x++, MBP++, IP++, DP++, PP++, MP++) {
              if (MoveCopyRect.s.x + x < 0 || MoveCopyRect.s.x + x >= ww) continue;
              if (*MBP == 0) {
                if (*MP) {
                  *DP = *IP;
                } else {
                  if (*IP > 1){
                    if ((y+x)&1) *DP = *PP; else *DP = *IP;
                  } else *DP = *PP;
                }
              } else {
                *DP = *IP;
              }
            }
            MoveCopyImage->Bitmap->PutScanLine(y);
          }
        } else {
          for (y = 0; y < MoveCopyRect.size.y; y++) {
            if (MoveCopyRect.s.y + y < 0 || MoveCopyRect.s.y + y >= hh) continue;
            MBP = Image->Mask->GetScanLine(MoveCopyRect.s.y + y) + MoveCopyRect.s.x;
            IP = Image->Bitmap->GetScanLine(MoveCopyRect.s.y + y) + MoveCopyRect.s.x;
            DP = MoveCopyImage->Bitmap->GetScanLine(y);
            PP = window.Bitmap->GetScanLine(y);
            MP = window.Mask->GetScanLine(y);
            for (x = 0; x < MoveCopyRect.size.x; x++, MBP++, IP++, DP++, PP++, MP++) {
              if (MoveCopyRect.s.x + x < 0 || MoveCopyRect.s.x + x >= ww) continue;
              if (*MBP == 0) {
                if (*MP) *DP = *IP; else *DP = *PP;
              } else {
                *DP = *IP;
              }
            }
            MoveCopyImage->Bitmap->PutScanLine(y);
          }
        }
      }
      Image->Mask->StopScanLine();
    } else {
      if (MainImageForm->Protect) {
        if (FullViewForm->Super == sGauze) {
          for (y = 0; y < MoveCopyRect.size.y; y++) {
            if (MoveCopyRect.s.y + y < 0 || MoveCopyRect.s.y + y >= hh) continue;
            IP = Image->Bitmap->GetScanLine(MoveCopyRect.s.y + y) + MoveCopyRect.s.x;
            DP = MoveCopyImage->Bitmap->GetScanLine(y);
            PP = window.Bitmap->GetScanLine(y);
            MP = window.Mask->GetScanLine(y);
            for (x = 0; x < MoveCopyRect.size.x; x++, IP++, DP++, PP++, MP++) {
              if (MoveCopyRect.s.x + x < 0 || MoveCopyRect.s.x + x >= ww) continue;
              if (MainImageForm->Palette->ColorData[*IP]->Protect == 0) {
                if (*MP) {
                  *DP = *IP;
                } else {
                  if (*IP > 1){
                    if ((y+x)&1) *DP = *PP; else *DP = *IP;
                  } else *DP = *PP;
                }
              } else {
                *DP = *IP;
              }
            }
            MoveCopyImage->Bitmap->PutScanLine(y);
          }
        } else {
          for (y = 0; y < MoveCopyRect.size.y; y++) {
            if (MoveCopyRect.s.y + y < 0 || MoveCopyRect.s.y + y >= hh) continue;
            IP = Image->Bitmap->GetScanLine(MoveCopyRect.s.y + y) + MoveCopyRect.s.x;
            DP = MoveCopyImage->Bitmap->GetScanLine(y);
            PP = window.Bitmap->GetScanLine(y);
            MP = window.Mask->GetScanLine(y);
            for (x = 0; x < MoveCopyRect.size.x; x++, IP++, DP++, PP++, MP++) {
              if (MoveCopyRect.s.x + x < 0 || MoveCopyRect.s.x + x >= ww) continue;
              if (MainImageForm->Palette->ColorData[*IP]->Protect == 0) {
                if (*MP) *DP = *IP; else *DP = *PP;
              } else {
                *DP = *IP;
              }
            }
            MoveCopyImage->Bitmap->PutScanLine(y);
          }
        }
      } else {
        if (FullViewForm->Super == sGauze) {
          for (y = 0; y < MoveCopyRect.size.y; y++) {
            if (MoveCopyRect.s.y + y < 0 || MoveCopyRect.s.y + y >= hh) continue;
            IP = Image->Bitmap->GetScanLine(MoveCopyRect.s.y + y) + MoveCopyRect.s.x;
            DP = MoveCopyImage->Bitmap->GetScanLine(y);
            PP = window.Bitmap->GetScanLine(y);
            MP = window.Mask->GetScanLine(y);
            for (x = 0; x < MoveCopyRect.size.x; x++, IP++, DP++, PP++, MP++) {
              if (MoveCopyRect.s.x + x < 0 || MoveCopyRect.s.x + x >= ww) continue;
              if (*MP) {
                *DP = *IP;
              } else {
                if (*IP > 1){
                  if ((y+x)&1) *DP = *PP; else *DP = *IP;
                } else *DP = *PP;
              }
            }
            MoveCopyImage->Bitmap->PutScanLine(y);
          }
        } else {
          for (y = 0; y < MoveCopyRect.size.y; y++) {
            if (MoveCopyRect.s.y + y < 0 || MoveCopyRect.s.y + y >= hh) continue;
            IP = Image->Bitmap->GetScanLine(MoveCopyRect.s.y + y) + MoveCopyRect.s.x;
            DP = MoveCopyImage->Bitmap->GetScanLine(y);
            PP = window.Bitmap->GetScanLine(y);
            MP = window.Mask->GetScanLine(y);
            for (x = 0; x < MoveCopyRect.size.x; x++, IP++, DP++, PP++, MP++) {
              if (MoveCopyRect.s.x + x < 0 || MoveCopyRect.s.x + x >= ww) continue;
              if (*MP) *DP = *IP; else *DP = *PP;
            }
            MoveCopyImage->Bitmap->PutScanLine(y);
          }
        }
      }
    }
    Image->Bitmap->StopScanLine();
    window.Mask->StopScanLine();
    window.Bitmap->StopScanLine();
    MoveCopyImage->Bitmap->StopScanLine();
  } else {
  	bgc = PaletteForm->DIB256Palette->GetBGCOLORREF(24);
    if (!MoveCopyImage->Bitmap->StartScanLine()) goto fail;
    if (!window.Bitmap->StartScanLine()) goto fail;
    if (!window.Mask->StartScanLine()) goto fail;
    if (!Image->Bitmap->StartScanLine()) goto fail;
    if (MainImageForm->MaskArea) {
      if (!Image->Mask->StartScanLine()) goto fail;
      if (FullViewForm->Super == sGauze) {
        for (y = 0; y < MoveCopyRect.size.y; y++) {
          if (MoveCopyRect.s.y + y < 0 || MoveCopyRect.s.y + y >= hh) continue;
          IP = Image->Bitmap->GetScanLine(MoveCopyRect.s.y + y) + 3*MoveCopyRect.s.x;
          MBP = Image->Mask->GetScanLine(MoveCopyRect.s.y + y);
          DP = MoveCopyImage->Bitmap->GetScanLine(y);
          PP = window.Bitmap->GetScanLine(y);
          MP = window.Mask->GetScanLine(y);
          mm = 0x80;
          for (x = 0; x < MoveCopyRect.size.x; x++, IP+=3, DP+=3, PP+=3) {
            if (MoveCopyRect.s.x + x < 0 || MoveCopyRect.s.x + x >= ww) continue;
            if ((MBP[(MoveCopyRect.s.x + x) >> 3] & (0x80 >> ((MoveCopyRect.s.x + x) & 7))) == 0) {
              if (*MP & mm) {
                CopyPixel24(DP, IP);
              } else {
                GetPixel24(IP, c);
                if (c!=bgc) {
                  if ((y+x)&1) {
                    CopyPixel24(DP, PP);
                  } else {
                    CopyPixel24(DP, IP);
                  }
                } else CopyPixel24(DP, PP);
              }
					  } else CopyPixel24(DP, IP);
            if (mm == 1) { MP++; mm = 0x80; } else mm >>= 1;
          }
          MoveCopyImage->Bitmap->PutScanLine(y);
        }
      } else {
        for (y = 0; y < MoveCopyRect.size.y; y++) {
          if (MoveCopyRect.s.y + y < 0 || MoveCopyRect.s.y + y >= hh) continue;
          IP = Image->Bitmap->GetScanLine(MoveCopyRect.s.y + y) + 3*MoveCopyRect.s.x;
          MBP = Image->Mask->GetScanLine(MoveCopyRect.s.y + y);
          DP = MoveCopyImage->Bitmap->GetScanLine(y);
          PP = window.Bitmap->GetScanLine(y);
          MP = window.Mask->GetScanLine(y);
          mm = 0x80;
          for (x = 0; x < MoveCopyRect.size.x; x++, IP+=3, DP+=3, PP+=3) {
            if (MoveCopyRect.s.x + x < 0 || MoveCopyRect.s.x + x >= ww) continue;
            if ((MBP[(MoveCopyRect.s.x + x) >> 3] & (0x80 >> ((MoveCopyRect.s.x + x) & 7))) == 0) {
              if (*MP & mm) { CopyPixel24(DP, IP); } else { CopyPixel24(DP, PP); }
					  } else CopyPixel24(DP, IP);
            if (mm == 1) { MP++; mm = 0x80; } else mm >>= 1;
          }
          MoveCopyImage->Bitmap->PutScanLine(y);
        }
      }
      Image->Mask->StopScanLine();
    } else {
      if (FullViewForm->Super == sGauze) {
        for (y = 0; y < MoveCopyRect.size.y; y++) {
          if (MoveCopyRect.s.y + y < 0 || MoveCopyRect.s.y + y >= hh) continue;
          IP = Image->Bitmap->GetScanLine(MoveCopyRect.s.y + y) + 3*MoveCopyRect.s.x;
          DP = MoveCopyImage->Bitmap->GetScanLine(y);
          PP = window.Bitmap->GetScanLine(y);
          MP = window.Mask->GetScanLine(y);
          mm = 0x80;
          for (x = 0; x < MoveCopyRect.size.x; x++, IP+=3, DP+=3, PP+=3) {
            if (MoveCopyRect.s.x + x < 0 || MoveCopyRect.s.x + x >= ww) continue;
            if (*MP & mm) {
              CopyPixel24(DP, IP);
            } else {
              GetPixel24(IP, c);
              if (c!=bgc) {
                if ((y+x)&1) {
                  CopyPixel24(DP, PP);
                } else {
                  CopyPixel24(DP, IP);
                }
              } else CopyPixel24(DP, PP);
            }
            if (mm == 1) { MP++; mm = 0x80; } else mm >>= 1;
          }
          MoveCopyImage->Bitmap->PutScanLine(y);
        }
      } else {
        for (y = 0; y < MoveCopyRect.size.y; y++) {
          if (MoveCopyRect.s.y + y < 0 || MoveCopyRect.s.y + y >= hh) continue;
          IP = Image->Bitmap->GetScanLine(MoveCopyRect.s.y + y) + 3*MoveCopyRect.s.x;
          DP = MoveCopyImage->Bitmap->GetScanLine(y);
          PP = window.Bitmap->GetScanLine(y);
          MP = window.Mask->GetScanLine(y);
          mm = 0x80;
          for (x = 0; x < MoveCopyRect.size.x; x++, IP+=3, DP+=3, PP+=3) {
            if (MoveCopyRect.s.x + x < 0 || MoveCopyRect.s.x + x >= ww) continue;
            if (*MP & mm) { CopyPixel24(DP, IP); } else { CopyPixel24(DP, PP); }
            if (mm == 1) { MP++; mm = 0x80; } else mm >>= 1;
          }
          MoveCopyImage->Bitmap->PutScanLine(y);
        }
      }
    }
    Image->Bitmap->StopScanLine();
    window.Mask->StopScanLine();
    window.Bitmap->StopScanLine();
    MoveCopyImage->Bitmap->StopScanLine();
  }
  MoveCopyImage->Visible = true;
#ifdef KNIT
  MoveCopyImage->SetPosition(0, 0);
#endif
  MainImageForm->iMainImage->Update();
  MoveCopyImage->Update();
  return;
fail:
  if (Image->Mask) Image->Mask->StopScanLine();
  Image->Bitmap->StopScanLine();
  window.Mask->StopScanLine();
  window.Bitmap->StopScanLine();
  MoveCopyImage->Bitmap->StopScanLine();
  EXCEPTION_MESSAGE_OK(EC_MEMORY_LACK);
}
//---------------------------------------------------------------------------
void __fastcall TMoveCopyForm::Rotate_Rect(void)
{
 	MainImageForm->DrawLineLocate(Point(sx[0], sy[0]), Point(sx[2], sy[2]),8);
 	MainImageForm->DrawLineLocate(Point(sx[2], sy[2]), Point(sx[3], sy[3]),8);
 	MainImageForm->DrawLineLocate(Point(sx[3], sy[3]), Point(sx[1], sy[1]),8);
 	MainImageForm->DrawLineLocate(Point(sx[1], sy[1]), Point(sx[0], sy[0]),8);
  MainImageForm->DrawLineLocate(Point(ArrowX[0], ArrowY[0]), Point(ArrowX[1], ArrowY[1]),8);
  MainImageForm->DrawLineLocate(Point(ArrowX[1], ArrowY[1]), Point(ArrowX[2], ArrowY[2]),8);
  MainImageForm->DrawLineLocate(Point(ArrowX[2], ArrowY[2]), Point(ArrowX[0], ArrowY[0]),8);
  MainImageForm->DrawLineLocate(Point(ArrowX[3], ArrowY[3]), Point(ArrowX[4], ArrowY[4]),8);
}
//---------------------------------------------------------------------------
void __fastcall TMoveCopyForm::Convert_CLTheta(int X, int Y)
{
  int tx, ty, cltheta;

  tx = window.s.x - X;
  ty = window.s.y - Y;

  if (ty == 0) {
    if (tx >= 0) Theta = M_PI / 2.0;
    else Theta = 1.5 * M_PI;
  } else {
    Theta = atan((Extended)tx / ty);
    if (ty < 0) Theta += M_PI; else if (tx < 0) Theta += 2.0 * M_PI;
  }
}
//---------------------------------------------------------------------------
void __fastcall TMoveCopyForm::Trans_Data(int X, int Y)
{
  TRotation *Trans = NULL;
  TPoint Cen;

  Cen.x = window.s.x + window.size.x / 2;
  Cen.y = window.s.y + window.size.y / 2;
  if ((Trans = new TRotation) == NULL) {EXCEPTION_MESSAGE_OK(EC_MEMORY_LACK); return;}
  Convert_CLTheta(X, Y);
  Trans->translation(-Cen.x, -Cen.y);
  Trans->rotation(-Theta);
  Trans->convert(window.s.x, window.s.y, sx[0], sy[0]);
  sx[0] = sx[0] + Cen.x;
  sy[0] = sy[0] + Cen.y;
  Trans->convert(window.s.x, window.e.y, sx[1], sy[1]);
  sx[1] = sx[1] + Cen.x;
  sy[1] = sy[1] + Cen.y;
  Trans->convert(window.e.x, window.s.y, sx[2], sy[2]);
  sx[2] = sx[2] + Cen.x;
  sy[2] = sy[2] + Cen.y;
  Trans->convert(window.e.x, window.e.y, sx[3], sy[3]);
  sx[3] = sx[3] + Cen.x;
  sy[3] = sy[3] + Cen.y;
  Trans->convert(ArrowX[0], ArrowY[0]);
  ArrowX[0] = ArrowX[0] + Cen.x;
  ArrowY[0] = ArrowY[0] + Cen.y;
  Trans->convert(ArrowX[1], ArrowY[1]);
  ArrowX[1] = ArrowX[1] + Cen.x;
  ArrowY[1] = ArrowY[1] + Cen.y;
  Trans->convert(ArrowX[2], ArrowY[2]);
  ArrowX[2] = ArrowX[2] + Cen.x;
  ArrowY[2] = ArrowY[2] + Cen.y;
  Trans->convert(ArrowX[3], ArrowY[3]);
  ArrowX[3] = ArrowX[3] + Cen.x;
  ArrowY[3] = ArrowY[3] + Cen.y;
  max_x = sx[0]; min_x = max_x;
  max_y = sy[0]; min_y = max_y;
  delete Trans; Trans = 0;
}
//---------------------------------------------------------------------------
#define PixelCenter(v)                         \
  IP2 = IP+3;                             \
  IP3 = IP1+3;                            \
  IPMinX = *IP+diff1*(*IP2-*IP);          \
  IPMaxX = *IP1+diff1*(*IP3-*IP1);        \
  v = (Byte)floor(IPMinX+diff*(IPMaxX-IPMinX));

void __fastcall TMoveCopyForm::MakeRotateImage()
{
  TRotation *Trans = NULL;
  Extended dx, dy, px, py;
  TPoint Cen;
  int LX, LY, xx, yy, i, j;
  Byte *IP,*IP1,*IP2,*IP3, *MP, mm, *WBP, *WMP, wmm;
  COLORREF bgc, c;
  Byte v;
  double diff,diff1,IPMinX,IPMaxX;
  bool mbc = false, wbc = false, wmc = false;
  TPItemImage *Image = MainImageForm->iMainImage;
  TPSelectImage *MoveCopyImage = MainImageForm->iSelectImage;

  if ((Trans = new TRotation) == NULL)  goto fail;
  LX         = window.size.x / 2;
  LY         = window.size.y / 2;
  Cen.x      = window.s.x + LX;
  Cen.y      = window.s.y + LY;
  Trans->translation(-Cen.x, -Cen.y);
  Trans->rotation(Theta);
  MoveCopyImage->Visible = false;
  if (min_x >= Image->Bitmap->Width - MoveCopyImage->Bitmap->Width) {
	  MoveCopyImage->Left = Image->BitmapToCanvasX(Image->Bitmap->Width - MoveCopyImage->Bitmap->Width);
  } else {
	  MoveCopyImage->Left = Image->BitmapToCanvasX(min_x);
  }
  if (min_y >= Image->Bitmap->Height - MoveCopyImage->Bitmap->Height) {
		MoveCopyImage->Top = Image->BitmapToCanvasY(Image->Bitmap->Height - MoveCopyImage->Bitmap->Height);
  } else {
		MoveCopyImage->Top = Image->BitmapToCanvasY(min_y);
  }
  MoveCopyImage->Width  = RotateArea.x * MoveCopyImage->ZoomIn / MoveCopyImage->ZoomOut;
  MoveCopyImage->Height = RotateArea.y * MoveCopyImage->ZoomIn / MoveCopyImage->ZoomOut;
  MoveCopyRect.size = RotateArea;
  if (Image->Bitmap->BitsPerPixel==8) {
	  mbc = MoveCopyImage->Bitmap->Create(RotateArea.x, RotateArea.y, 8, rgb);
    if (mbc == false) goto fail;
		wbc = window.Bitmap->Create(RotateArea.x, RotateArea.y, 8, rgb);
    if (wbc == false) goto fail;
		wmc = window.Mask->Create(RotateArea.x, RotateArea.y, 8, rgb);
    if (wmc == false) goto fail;

		if (!Image->Bitmap->StartScanLine()) goto fail;
 		if (!MainImageForm->WorkArea->Mask->StartScanLine()) goto fail;
		if (!window.Bitmap->StartScanLine()) goto fail;
	  if (!window.Mask->StartScanLine()) goto fail;
		switch (FullViewForm->Super) {
  		case sOff:
  	   	StatusProgress->Maximum = max_y-min_y;
				for (i=0; i<=max_y-min_y; i++) {
      		StatusProgress->Position = i;
	       	WBP = window.Bitmap->GetScanLine(i);
  	      WMP = window.Mask->GetScanLine(i);
	 				for (j=0; j<=max_x-min_x; j++, WBP++, WMP++) {
  					Trans->convert(j+min_x, i+min_y, dx, dy);
 						py = dy+LY;
  					yy = floor(py);
    				if (yy>=0 && yy<window.size.y) {
    	 				px = dx+LX;
     					xx = floor(px);
          		IP = Image->Bitmap->GetScanLine(window.s.y+yy)+window.s.x+xx;
  	        	MP = MainImageForm->WorkArea->Mask->GetScanLine(yy)+xx;
     					if (xx>=0 && xx<window.size.x && *MP) {
     						*WBP = *IP;
 								*WMP = 0;
	     				} else {
								*WBP = 0;
								*WMP = 0xFF;
     					}
   					} else {
							*WBP = 0;
							*WMP = 0xFF;
    				}
	 				}
    	    window.Bitmap->PutScanLine(i);
      	  window.Mask->PutScanLine(i);
 				}
      	StatusProgress->End();
	     	break;
	 	  case sOverlap: case sNormal:  case sGauze:
      	StatusProgress->Maximum = max_y-min_y;
 				for (i=0; i<=max_y-min_y; i++) {
       		StatusProgress->Position = i;
	        WBP = window.Bitmap->GetScanLine(i);
  	      WMP = window.Mask->GetScanLine(i);
 					for (j=0; j<=max_x-min_x; j++, WBP++, WMP++) {
  					Trans->convert(j+min_x, i+min_y, dx, dy);
 						py = dy+LY;
    				yy = floor(py);
  	 				if (yy>=0 && yy<window.size.y) {
     					px = dx+LX;
     					xx = floor(px);
   	      		IP = Image->Bitmap->GetScanLine(window.s.y+yy)+window.s.x+xx;
     	      	MP = MainImageForm->WorkArea->Mask->GetScanLine(yy)+xx;
      				if (xx>=0 && xx<window.size.x && *MP && *IP>1) {
    	   				*WBP = *IP;
								*WMP = 0;
     					} else {
								*WBP = 0;
								*WMP = 0xFF;
      				}
	   				} else {
							*WBP = 0;
							*WMP = 0xFF;
   					}
 					}
	        window.Bitmap->PutScanLine(i);
  	      window.Mask->PutScanLine(i);
				}
        StatusProgress->End();
      	break;
 		}
  	window.Bitmap->StopScanLine();
		window.Mask->StopScanLine();
		MainImageForm->WorkArea->Mask->StopScanLine();
  	Image->Bitmap->StopScanLine();
  } else {
	  mbc = MoveCopyImage->Bitmap->Create(RotateArea.x, RotateArea.y, 24);
    if (mbc == false) goto fail;
		wbc = window.Bitmap->Create(RotateArea.x, RotateArea.y, 24);
    if (wbc == false) goto fail;
		wmc = window.Mask->Create(RotateArea.x, RotateArea.y, 1);
    if (wmc == false) goto fail;

	  if (!Image->Bitmap->StartScanLineN(2)) goto fail;
 		if (!MainImageForm->WorkArea->Mask->StartScanLine()) goto fail;
	  if (!window.Bitmap->StartScanLine()) goto fail;
  	if (!window.Mask->StartScanLine()) goto fail;
  	bgc = PaletteForm->DIB256Palette->GetBGCOLORREF(24);
		switch (FullViewForm->Super) {
	   	case sOff:
      	StatusProgress->Maximum = max_y-min_y;
 				for (i=0; i<=max_y-min_y; i++) {
       	StatusProgress->Position = i;
        	WBP = window.Bitmap->GetScanLine(i);
  	      WMP = window.Mask->GetScanLine(i);
          *WMP = 0;	wmm = 0x80;
	 				for (j=0; j<=max_x-min_x; j++, WBP+=3) {
  					Trans->convert(j+min_x, i+min_y, dx, dy);
 						py = dy+LY;
  					yy = floor(py);
            diff=py-yy;
    				if (yy>=0 && yy<window.size.y) {
    	 				px = dx+LX;
     					xx = floor(px);
              diff1=px-xx;

          		IP = Image->Bitmap->GetScanLine(window.s.y+yy)+3*(window.s.x+xx);
              IP1 = Image->Bitmap->GetScanLineN(window.s.y+yy+1,1)+3*(window.s.x+xx);
              PixelCenter(v);
              c = v<<16;

              IP++;
              IP1++;
              PixelCenter(v);
              c |= v<<8;

              IP++;
              IP1++;
              PixelCenter(v);
              c |= v;

  	        	MP = MainImageForm->WorkArea->Mask->GetScanLine(yy)+(xx>>3);
              mm = 0x80>>(xx&7);
     					if (xx>=0 && xx<window.size.x && (*MP&mm)) {
     						SetPixel24(WBP, c);
	     				} else {
								SetPixel24(WBP, 0);
								*WMP |= wmm;
     					}
   					} else {
							SetPixel24(WBP, 0);
							*WMP |= wmm;
    				}
            if (wmm==1) { WMP++; *WMP = 0; wmm = 0x80; } else wmm >>= 1;
	 				}
    	    window.Bitmap->PutScanLine(i);
      	  window.Mask->PutScanLine(i);
 				}
      	StatusProgress->End();
	     	break;
  	  case sOverlap: case sNormal: case sGauze:
      	StatusProgress->Maximum = max_y-min_y;
 				for (i=0; i<=max_y-min_y; i++) {
       		StatusProgress->Position = i;
	        WBP = window.Bitmap->GetScanLine(i);
  	      WMP = window.Mask->GetScanLine(i);
          *WMP = 0;	wmm = 0x80;
 					for (j=0; j<=max_x-min_x; j++, WBP+=3) {
  					Trans->convert(j+min_x, i+min_y, dx, dy);
 						py = dy+LY;
    				yy = floor(py);
            diff=py-yy;
    				if (yy>=0 && yy<window.size.y) {
    	 				px = dx+LX;
     					xx = floor(px);
              diff1=px-xx;

          		IP = Image->Bitmap->GetScanLine(window.s.y+yy)+3*(window.s.x+xx);
              IP1 = Image->Bitmap->GetScanLineN(window.s.y+yy+1,1)+3*(window.s.x+xx);
              PixelCenter(v);
              c = v<<16;

              IP++;
              IP1++;
              PixelCenter(v);
              c |= v<<8;

              IP++;
              IP1++;
              PixelCenter(v);
              c |= v;

     	      	MP = MainImageForm->WorkArea->Mask->GetScanLine(yy)+(xx>>3);
              mm = 0x80>>(xx&7);
      				if (xx>=0 && xx<window.size.x && (*MP&mm) && c!=bgc) {
     						SetPixel24(WBP, c);
     					} else {
								SetPixel24(WBP, 0);
								*WMP |= wmm;
      				}
	   				} else {
							SetPixel24(WBP, 0);
							*WMP |= wmm;
   					}
            if (wmm==1) { WMP++; *WMP = 0; wmm = 0x80; } else wmm >>= 1;
 					}
	        window.Bitmap->PutScanLine(i);
  	      window.Mask->PutScanLine(i);
				}
      	StatusProgress->End();
      	break;
 		}
   	window.Bitmap->StopScanLine();
	  window.Mask->StopScanLine();
	 	MainImageForm->WorkArea->Mask->StopScanLine();
   	Image->Bitmap->StopScanLine();
  }
  delete Trans;
  return;
fail:
	window.Bitmap->StopScanLine();
	window.Mask->StopScanLine();
	MainImageForm->WorkArea->Mask->StopScanLine();
 	Image->Bitmap->StopScanLine();
  if (wmc) window.Mask->Destroy();
  if (wbc) window.Bitmap->Destroy();
  if (mbc) MoveCopyImage->Bitmap->Destroy();
  if (Trans) delete Trans;
  EXCEPTION_MESSAGE_OK(EC_MEMORY_LACK);
}
//---------------------------------------------------------------------------
void __fastcall TMoveCopyForm::RotateMouseDown(int X, int Y)
{
  int degree;
  TPSelectImage *MoveCopyImage = MainImageForm->iSelectImage;

  if (tate == 0) {
 	  if (IsDraw) Rotate_Rect();   // µ¹¾Æ°¡´Â »ç°¢ÇüÀ» ±×¸®´Â ÇÁ·Î½ÃÀú
    RotateArea = Point(max_x-min_x+1, max_y-min_y+1);
    degree = StrToInt(cbRotate->Text);
    if (sw) Theta = degree * M_PI / 180.0;
    else Convert_CLTheta(X, Y);
    BeforeDeg = degree;
    MakeRotateImage();
    IsDraw = false;
  }
//  MoveCopyImage->Visible = true;
  tate  = 1;
}
//---------------------------------------------------------------------------
void __fastcall TMoveCopyForm::RotateMouseMove(int X, int Y)
{
  int ArrowXX, ArrowYY, LX, LY, i;
  TPoint Cen;

  if (tate==0) {
    if (IsDraw) Rotate_Rect();   // µ¹¾Æ°¡´Â »ç°¢ÇüÀ» ±×¸®´Â ÇÁ·Î½ÃÀú..
 		LX = window.size.x / 2;
   	LY = window.size.y / 2;
   	Cen.x = window.s.x + LX;
   	Cen.y = window.s.y + LY;
   	ArrowXX  = window.size.x / 6;
   	ArrowYY  = window.size.y / 6;
    ArrowX[0] = Cen.x;
    ArrowX[1] = Cen.x - ArrowXX * 2;
    ArrowX[2] = Cen.x + ArrowXX * 2;
    ArrowX[3] = Cen.x;
    ArrowX[4] = Cen.x;
    ArrowY[0] = Cen.y - ArrowYY * 2;
    ArrowY[1] = Cen.y;
    ArrowY[2] = Cen.y;
    ArrowY[3] = Cen.y + ArrowYY * 2;
    ArrowY[4] = Cen.y;
    Trans_Data(X, Y);
    for (i = 0; i <= 3; i++) {
      if (min_x >= sx[i]) min_x = sx[i];
      else if (max_x <= sx[i]) max_x = sx[i];
      if (min_y >= sy[i]) min_y = sy[i];
      else if (max_y <= sy[i]) max_y = sy[i];
    }
	  Rotate_Rect();   // µ¹¾Æ°¡´Â »ç°¢ÇüÀ» ±×¸®´Â ÇÁ·Î½ÃÀú..
    IsDraw = true;
    cbRotate->Text = Format("%3.0f", OPENARRAY(TVarRec, (RadToDeg(Theta))));
  } else if (tate==1) {
		SymmertyMouseMove(X, Y);
  }
}
//---------------------------------------------------------------------------
bool __fastcall TMoveCopyForm::new_mc_buf(TWindowData w)
{
  bool mbc = false, wbc = false, wmc = false;
  MoveCopyRect.s    = w.s;
  MoveCopyRect.e    = w.e;
  MoveCopyRect.size = w.size;
  TPItemImage *Image = MainImageForm->iMainImage;
  TPSelectImage *MoveCopyImage = MainImageForm->iSelectImage;

  if (Image->Bitmap->BitsPerPixel==8) {
	  mbc = MoveCopyImage->Bitmap->Create(w.size.x, w.size.y, 8, rgb);
    if (mbc == false) goto fail;
 		MoveCopyImage->SetPosition(0, 0);
		wbc = window.Bitmap->Create(w.size.x, w.size.y, 8, rgb);
    if (wbc == false) goto fail;
		wmc = window.Mask->Create(w.size.x, w.size.y, 8, rgb);
    if (wmc == false) goto fail;
	  window.Bitmap->FillRect(Rect(0, 0, w.size.x, w.size.y), PALETTEINDEX(0x00));
	  window.Mask->FillRect(Rect(0, 0, w.size.x, w.size.y), PALETTEINDEX(0xFF));
  } else {
	  mbc = MoveCopyImage->Bitmap->Create(w.size.x, w.size.y, 24);
    if (mbc == false) goto fail;
 		MoveCopyImage->SetPosition(0, 0);
		wbc = window.Bitmap->Create(w.size.x, w.size.y, 24);
    if (wbc == false) goto fail;
		wmc = window.Mask->Create(w.size.x, w.size.y, 24);
    if (wmc == false) goto fail;
	  window.Bitmap->FillRect(Rect(0, 0, w.size.x, w.size.y), 0);
	  window.Mask->FillRect(Rect(0, 0, w.size.x, w.size.y), 0xFFFFFF);
  }
  return true;
fail:
  if (wmc) window.Mask->Destroy();
  if (wbc) window.Bitmap->Destroy();
  if (mbc) MoveCopyImage->Bitmap->Destroy();
  return false;
}
//---------------------------------------------------------------------------
void __fastcall TMoveCopyForm::bending_fan(void)
{
  int i,j, x, y, cx1, cy1, xx, yy, min_x, min_y, max_x, max_y;
  double radius, th, lr, sr, Y, X, diff, diff1, IPMinX, IPMaxX, diff_x, diff_y,
         diff_ave, ave;
  Byte *IP, *IP1, *IP2, *IP3, *WBP,*WBP1, mm, *MP1, mm1, *WMP, wm, wmm,
        wm1, v, *MP, *WP, c1, c2, c3;
  COLORREF c, bgc;
  TPItemImage *Image = MainImageForm->iMainImage;
  TPSelectImage *MoveCopyImage = MainImageForm->iSelectImage;

  if (Dsy>Dsx) {
    if (tR>=window.size.y/2.0) {
      sr = tR-window.size.y/2.0;
      lr = tR+window.size.y/2.0;
    } else {
      Theta = 2*(double)window.size.x/window.size.y;
      sr = 0; lr = window.size.y;
    }
    if(Dsy1<0){
       cx1 = Csx;
       cy1 = window.s.y+lr;
       min_x = cx1-lr*sin(Theta/2);
       min_y = cy1-lr;
       max_x = cx1+lr*sin(Theta/2)+1;
       max_y = cy1-sr*cos(Theta/2);
       if(Theta>M_PI){
         min_x = cx1-lr;
         max_x = cx1+lr+1;
         max_y = cy1+lr*sin((Theta-M_PI)/2);
       }
    } else {
       cx1 = Csx;
       cy1 = window.e.y-lr;
       min_x = cx1-lr*sin(Theta/2);
       min_y = cy1+sr*cos(Theta/2);
       max_x = cx1+lr*sin(Theta/2)+1;
       max_y = cy1+lr;
       if(Theta>M_PI){
         min_x = cx1-lr;
         max_x = cx1+lr+1;
         min_y = cy1-lr*sin((Theta-M_PI)/2);
       }
    }
    bendwindow.size.x = max_x - min_x;
    bendwindow.size.y = max_y - min_y;
    if (new_mc_buf(bendwindow) == false) return;
    if (!Image->Bitmap->StartScanLineN(2))                goto fail;
    if (!window.Bitmap->StartScanLine())                 goto fail;
    if (!window.Mask->StartScanLine())                   goto fail;
    if (!MainImageForm->WorkArea->Mask->StartScanLine()) goto fail;
    if (Image->Bitmap->BitsPerPixel==8) {
      switch (FullViewForm->Super) {
        case sOff:
        	StatusProgress->Maximum = max_y-min_y;
      		for(j = min_y; j < max_y; j++){
            StatusProgress->Position = j-min_y;
            WMP = window.Mask->GetScanLine(j-min_y);
            WBP = window.Bitmap->GetScanLine(j-min_y);
        		for (i = min_x; i < max_x; i++,WBP++, WMP++) {
              radius = sqrt((cx1-i)*(cx1-i)+(cy1-j)*(cy1-j));
              if(radius == 0){
                th = 0;
                Y = abs(window.s.y-cy1);
              } else {
                if(Dsy1<0){
                  th = acos((cy1-j)/radius);
                  Y = lr-radius;
                } else {
                  th = acos((j-cy1)/radius);
                  Y = radius-sr;
                }
              }
              Y = Y+0.5;
              yy = floor(Y);
              if(yy >= 0 && yy < window.size.y){
                if((i-min_x)>=(max_x-min_x)/2) X = window.size.x/2*(1+th / (Theta/2));
                else X = window.size.x/2*(1-th/(Theta/2));
                X = X+0.5;
                xx = floor(X);
                if(xx >= 0 && xx < window.size.x){
                  IP = Image->Bitmap->GetScanLine(window.s.y+yy) + (window.s.x+xx);
                  c1 = *IP;
                  MP = MainImageForm->WorkArea->Mask->GetScanLine(yy)+xx;
                  if (*MP) {
                    *WBP = c1;
                    *WMP = 0;
                  } else {
                    *WBP = 0;
                    *WMP = 0xFF;
                  }
                } else {
                  *WBP = 0;
                  *WMP = 0xFF;
                }
              } else {
                *WBP = 0;
                *WMP = 0xff;
              }
            }
            window.Bitmap->PutScanLine(j-min_y);
            window.Mask->PutScanLine(j-min_y);
          }
      	  StatusProgress->End();
          break;
    	  case sOverlap: case sNormal: case sGauze:
        	StatusProgress->Maximum = max_y-min_y;
      		for(j = min_y; j < max_y; j++){
            StatusProgress->Position = j-min_y;
            WMP = window.Mask->GetScanLine(j-min_y);
            WBP = window.Bitmap->GetScanLine(j-min_y);
        		for (i = min_x; i < max_x; i++, WBP++, WMP++) {
              radius = sqrt((cx1-i)*(cx1-i)+(cy1-j)*(cy1-j));
              if(radius == 0){
                th = 0;
                Y = abs(window.s.y-cy1);
              } else {
                if(Dsy1<0){
                  th = acos((cy1-j)/radius);
                  Y = lr-radius;
                } else {
                  th = acos((j-cy1)/radius);
                  Y = radius-sr;
                }
              }
              Y = Y+0.5;
              yy = floor(Y);
              if(yy >= 0 && yy < window.size.y){
                if((i-min_x)>=(max_x-min_x)/2) X = window.size.x/2*(1+th / (Theta/2));
                else X = window.size.x/2*(1-th/(Theta/2));
                X = X+0.5;
                xx = floor(X);
                if(xx >= 0 && xx < window.size.x){
                  IP = Image->Bitmap->GetScanLine(window.s.y+yy) + (window.s.x+xx);
                  c1 = *IP;
                  MP = MainImageForm->WorkArea->Mask->GetScanLine(yy)+xx;
                  if (*MP && *IP!=1) {
                    *WBP = c1;
                    *WMP = 0;
                  } else {
                    *WBP = 0;
                    *WMP = 0xFF;
                  }
                } else {
                  *WBP = 0;
                  *WMP = 0xFF;
                }
              } else {
                *WBP = 0;
                *WMP = 0xff;
              }
            }
            window.Bitmap->PutScanLine(j-min_y);
            window.Mask->PutScanLine(j-min_y);
          }
          StatusProgress->End();
          break;
      }
    } else {
     	bgc = PaletteForm->DIB256Palette->GetBGCOLORREF(24);
      switch (FullViewForm->Super) {
        case sOff:
          StatusProgress->Maximum = max_y-min_y;
          for(j = min_y; j < max_y; j++){
            StatusProgress->Position = j-min_y;
            WMP = window.Mask->GetScanLine(j-min_y);
            WBP = window.Bitmap->GetScanLine(j-min_y);
            *WMP = 0;	wmm = 0x80;
            for (i=min_x; i < max_x; i++, WBP+=3) {
              radius = sqrt((cx1-i)*(cx1-i)+(cy1-j)*(cy1-j));
              if(radius == 0){
                th = 0;
                Y = abs(window.s.y-cy1);
              } else {
                if(Dsy1<0){
                  th = acos((cy1-j)/radius);
                  Y = lr-radius;
                } else {
                  th = acos((j-cy1)/radius);
                  Y = radius-sr;
                }
              }
              yy = floor(Y);
              diff = Y-yy;
              if(yy >= 0 && yy < window.size.y){
                if((i-min_x)>=(max_x-min_x)/2) X = window.size.x/2*(1+th / (Theta/2));
                else X = window.size.x/2*(1-th/(Theta/2));
                xx = floor(X);
                diff1 = X-xx;
                if(xx >= 0 && xx < window.size.x){
                  IP = Image->Bitmap->GetScanLine(window.s.y+yy) + 3*(window.s.x+xx);
                  IP1 = Image->Bitmap->GetScanLineN(window.s.y+yy+1,1) + 3*(window.s.x+xx);
                  PixelCenter(v);
                  c = v<<16;
                  IP++;
                  IP1++;
                  PixelCenter(v);
                  c |= v<<8;
                  IP++;
                  IP1++;
                  PixelCenter(v);
                  c |= v;
                  MP = MainImageForm->WorkArea->Mask->GetScanLine(yy)+(xx>>3);
                  mm = 0x80>>(xx&7);
                  if (*MP&mm) {
                    SetPixel24(WBP, c);
                  } else {
                    SetPixel24(WBP, 0);
                    *WMP |= wmm;
                  }
                } else {
                  SetPixel24(WBP, 0);
                  *WMP |= wmm;
                }
              } else {
                SetPixel24(WBP, 0);
                *WMP |= wmm;
              }
              if (wmm==1) { WMP++; *WMP = 0; wmm = 0x80; } else wmm >>= 1;
            }
            window.Bitmap->PutScanLine(j-min_y);
            window.Mask->PutScanLine(j-min_y);
          }
          StatusProgress->End();
          break;
        case sOverlap: case sNormal:  case sGauze:
          StatusProgress->Maximum = max_y-min_y;
          for(j = min_y; j < max_y; j++){
            StatusProgress->Position = j-min_y;
            WMP = window.Mask->GetScanLine(j-min_y);
            WBP = window.Bitmap->GetScanLine(j-min_y);
            *WMP = 0;	wmm = 0x80;
            for (i=min_x; i < max_x; i++, WBP+=3) {
              radius = sqrt((cx1-i)*(cx1-i)+(cy1-j)*(cy1-j));
              if(radius == 0){
                th = 0;
                Y = abs(window.s.y-cy1);
              } else {
                if(Dsy1<0){
                  th = acos((cy1-j)/radius);
                  Y = lr-radius;
                } else {
                  th = acos((j-cy1)/radius);
                  Y = radius-sr;
                }
              }
              yy = floor(Y);
              diff = Y-yy;
              if(yy >= 0 && yy < window.size.y){
                if((i-min_x)>=(max_x-min_x)/2) X = window.size.x/2*(1+th / (Theta/2));
                else X = window.size.x/2*(1-th/(Theta/2));
                xx = floor(X);
                diff1 = X-xx;
                if(xx >= 0 && xx < window.size.x){
                  IP = Image->Bitmap->GetScanLine(window.s.y+yy) + 3*(window.s.x+xx);
                  IP1 = Image->Bitmap->GetScanLineN(window.s.y+yy+1,1) + 3*(window.s.x+xx);
                  PixelCenter(v);
                  c = v<<16;
                  IP++;
                  IP1++;
                  PixelCenter(v);
                  c |= v<<8;
                  IP++;
                  IP1++;
                  PixelCenter(v);
                  c |= v;
                  MP = MainImageForm->WorkArea->Mask->GetScanLine(yy)+(xx>>3);
                  mm = 0x80>>(xx&7);
                  if ((*MP&mm) && c!=bgc) {
                    SetPixel24(WBP, c);
                  } else {
                    SetPixel24(WBP, 0);
                    *WMP |= wmm;
                  }
                } else {
                  SetPixel24(WBP, 0);
                  *WMP |= wmm;
                }
              } else {
                SetPixel24(WBP,0);
                *WMP |= wmm;
              }
              if (wmm==1) { WMP++; *WMP = 0; wmm = 0x80; } else wmm >>= 1;
            }
            window.Bitmap->PutScanLine(j-min_y);
            window.Mask->PutScanLine(j-min_y);
          }
          StatusProgress->End();
          break;
      }
    }
		Image->Bitmap->StopScanLine();
		window.Bitmap->StopScanLine();
		window.Mask->StopScanLine();
 		MainImageForm->WorkArea->Mask->StopScanLine();
  } else {
    if (tR>=window.size.x/2.0) {
      sr = tR-window.size.x/2.0;
      lr = tR+window.size.x/2.0;
    } else {
      Theta = 2*(double)window.size.y/window.size.x;
      sr = 0; lr = window.size.x;
    }
    if(Dsx1<0){
      cx1 = window.s.x+lr;
      cy1 = Csy;
      min_x = cx1-lr;
      min_y = cy1-lr*sin(Theta/2);
      max_x = cx1-sr*cos(Theta/2);
      max_y = cy1+lr*sin(Theta/2)+1;
      if(Theta>M_PI){
        min_y = cy1-lr ;
        max_y = cy1+lr;
        max_x = cx1+lr*sin((Theta-M_PI)/2)+1;
      }
    } else {
      cx1 = window.e.x-lr;
      cy1 = Csy;
      min_x = cx1+sr*cos(Theta/2);
      min_y = cy1-lr*sin(Theta/2);
      max_x = cx1+lr;
      max_y = cy1+lr*sin(Theta/2)+1;
      if(Theta>M_PI){
        min_y = cy1-lr;
        max_y = cy1+lr+1;
        min_x = cx1-lr*sin((Theta-M_PI)/2);
      }
    }
    bendwindow.size.x = max_x - min_x;
    bendwindow.size.y = max_y - min_y;
    if (new_mc_buf(bendwindow) == false) return;
    if (!MoveCopyImage->Bitmap->StartScanLine())          goto fail;
    if (!Image->Bitmap->StartScanLineN(2))                 goto fail;
    if (!window.Bitmap->StartScanLine())                  goto fail;
    if (!window.Mask->StartScanLine())                    goto fail;
    if (!MainImageForm->WorkArea->Mask->StartScanLine())  goto fail;
    if (Image->Bitmap->BitsPerPixel==8) {
  		switch (FullViewForm->Super) {
     		case sOff:
          StatusProgress->Maximum = max_y-min_y;
          for(j = min_y; j < max_y; j++){
            StatusProgress->Position = j-min_y;
            WMP = window.Mask->GetScanLine(j-min_y);
            WBP = window.Bitmap->GetScanLine(j-min_y);
            for (i=min_x; i < max_x; i++, WBP++, WMP++) {
              radius = sqrt((cx1-i)*(cx1-i)+(cy1-j)*(cy1-j));
              if(radius == 0){
                th = 0;
                X = abs(window.s.x-cx1);
              } else {
                if(Dsx1<0){
                  th = acos((cx1-i)/radius);
                  X = lr-radius;
                } else {
                  th = acos((i-cx1)/radius);
                  X = radius-sr;
                }
              }
              X = X+0.5;
              xx = floor(X);
              if(xx >= 0 && xx < window.size.x){
                if((j-min_y)>=(max_y-min_y)/2) Y = window.size.y/2*(1+th / (Theta/2));
                else Y = window.size.y/2*(1-th/(Theta/2));
                Y = Y+0.5;
                yy = floor(Y);
                if(yy >= 0 && yy < window.size.y){
                  IP = Image->Bitmap->GetScanLine(window.s.y+yy) + (window.s.x+xx);
                  c1 = *IP;
                  MP = MainImageForm->WorkArea->Mask->GetScanLine(yy)+xx;
                  if (*MP) {
                    *WBP = c1;
                    *WMP = 0;
                  } else goto next;
                } else goto next;
              } else {
next:
                *WBP = 0;
                *WMP = 0xFF;
              }
            }
            window.Bitmap->PutScanLine(j-min_y);
            window.Mask->PutScanLine(j-min_y);
          }
          StatusProgress->End();
          break;
        case sOverlap: case sNormal: case sGauze:
          StatusProgress->Maximum = max_y-min_y;
          for(j = min_y; j < max_y; j++){
            StatusProgress->Position = j-min_y;
            WMP = window.Mask->GetScanLine(j-min_y);
            WBP = window.Bitmap->GetScanLine(j-min_y);
            for (i=min_x; i < max_x; i++, WBP++, WMP++) {
              radius = sqrt((cx1-i)*(cx1-i)+(cy1-j)*(cy1-j));
              if(radius == 0){
                th = 0;
                X = abs(window.s.x-cx1);
              } else {
                if(Dsx1<0){
                  th = acos((cx1-i)/radius);
                  X = lr-radius;
                } else {
                  th = acos((i-cx1)/radius);
                  X = radius-sr;
                }
              }
              X = X+0.5;
              xx = floor(X);
              if(xx >= 0 && xx < window.size.x){
                if((j-min_y)>=(max_y-min_y)/2) Y = window.size.y/2*(1+th / (Theta/2));
                else Y = window.size.y/2*(1-th/(Theta/2));
                Y = Y+0.5;
                yy = floor(Y);
                if(yy >= 0 && yy < window.size.y){
                  IP = Image->Bitmap->GetScanLine(window.s.y+yy) + (window.s.x+xx);
                  c1 = *IP;
                  MP = MainImageForm->WorkArea->Mask->GetScanLine(yy)+xx;
                  if (*MP && *IP!=1) {
                    *WBP = c1;
                    *WMP = 0;
                  } else {
                    *WBP = 0;
                    *WMP = 0xFF;
                  }
                } else {
                  *WBP = 0;
                  *WMP = 0xFF;
                }
              } else {
                *WBP = 0;
                *WMP = 0xff;
              }
            }
            window.Bitmap->PutScanLine(j-min_y);
            window.Mask->PutScanLine(j-min_y);
          }
          StatusProgress->End();
          break;
      }
    } else {
      bgc = PaletteForm->DIB256Palette->GetBGCOLORREF(24);
      switch (FullViewForm->Super) {
        case sOff:
        	StatusProgress->Maximum = max_y-min_y;
      		for(j = min_y; j < max_y; j++){
            StatusProgress->Position = j-min_y;
            WMP = window.Mask->GetScanLine(j-min_y);
            WBP = window.Bitmap->GetScanLine(j-min_y);
            *WMP = 0;	wmm = 0x80;
        		for (i=min_x; i < max_x; i++, WBP+=3) {
              radius = sqrt((cx1-i)*(cx1-i)+(cy1-j)*(cy1-j));
              if(radius == 0){
                th = 0;
                X = abs(window.s.x-cx1);
              } else {
                if(Dsx1<0){
                  th = acos((cx1-i)/radius);
                  X = lr-radius;
                } else {
                  th = acos((i-cx1)/radius);
                  X = radius-sr;
                }
              }
              xx = floor(X);
              diff1 = X-xx;
              if(xx >= 0 && xx < window.size.x){
                if((j-min_y)>=(max_y-min_y)/2) Y = window.size.y/2*(1+th / (Theta/2));
                else Y = window.size.y/2*(1-th/(Theta/2));
                yy = floor(Y);
                diff = Y-yy;
                if(yy >= 0 && yy < window.size.y){
                  IP = Image->Bitmap->GetScanLine(window.s.y+yy) + 3*(window.s.x+xx);
                  IP1 = Image->Bitmap->GetScanLineN(window.s.y+yy+1,1) + 3*(window.s.x+xx);
                  PixelCenter(v);
                  c = v<<16;
                  IP++;
                  IP1++;
                  PixelCenter(v);
                  c |= v<<8;
                  IP++;
                  IP1++;
                  PixelCenter(v);
                  c |= v;
                  MP = MainImageForm->WorkArea->Mask->GetScanLine(yy)+(xx>>3);
                  mm = 0x80>>(xx&7);
                  if (*MP&mm) {
                    SetPixel24(WBP, c);
                  } else {
                    SetPixel24(WBP, 0);
                    *WMP |= wmm;
                  }
                } else {
                  SetPixel24(WBP, 0);
                  *WMP |= wmm;
                }
              } else {
                SetPixel24(WBP,0);
                *WMP |= wmm;
              }
              if (wmm==1) { WMP++; *WMP = 0; wmm = 0x80; } else wmm >>= 1;
            }
            window.Bitmap->PutScanLine(j-min_y);
            window.Mask->PutScanLine(j-min_y);
          }
          StatusProgress->End();
          break;
        case sOverlap: case sNormal: case sGauze:
        	StatusProgress->Maximum = max_y-min_y;
      		for(j = min_y; j < max_y; j++){
            StatusProgress->Position = j-min_y;
            WMP = window.Mask->GetScanLine(j-min_y);
            WBP = window.Bitmap->GetScanLine(j-min_y);
            *WMP = 0;	wmm = 0x80;
        		for (i=min_x; i < max_x; i++, WBP+=3) {
              radius = sqrt((cx1-i)*(cx1-i)+(cy1-j)*(cy1-j));
              if(radius == 0){
                th = 0;
                X = abs(window.s.x-cx1);
              } else {
                if(Dsx1<0){
                  th = acos((cx1-i)/radius);
                  X = lr-radius;
                } else {
                  th = acos((i-cx1)/radius);
                  X = radius-sr;
                }
              }
              xx = floor(X);
              diff1 = X-xx;
              if(xx >= 0 && xx < window.size.x){
                if((j-min_y)>=(max_y-min_y)/2) Y = window.size.y/2*(1+th / (Theta/2));
                else Y = window.size.y/2*(1-th/(Theta/2));
                yy = floor(Y);
                diff = Y-yy;
                if(yy >= 0 && yy < window.size.y){
                  IP = Image->Bitmap->GetScanLine(window.s.y+yy) + 3*(window.s.x+xx);
                  IP1 = Image->Bitmap->GetScanLineN(window.s.y+yy+1,1) + 3*(window.s.x+xx);
                  PixelCenter(v);
                  c = v<<16;
                  IP++;
                  IP1++;
                  PixelCenter(v);
                  c |= v<<8;
                  IP++;
                  IP1++;
                  PixelCenter(v);
                  c |= v;
                  MP = MainImageForm->WorkArea->Mask->GetScanLine(yy)+(xx>>3);
                  mm = 0x80>>(xx&7);
          				if ((*MP&mm) && c!=bgc) {
                    SetPixel24(WBP, c);
                  } else {
                    SetPixel24(WBP, 0);
                    *WMP |= wmm;
                  }
                } else {
                  SetPixel24(WBP, 0);
                  *WMP |= wmm;
                }
              } else {
                SetPixel24(WBP,0);
                *WMP |= wmm;
              }
              if (wmm==1) { WMP++; *WMP = 0; wmm = 0x80; } else wmm >>= 1;
            }
            window.Bitmap->PutScanLine(j-min_y);
            window.Mask->PutScanLine(j-min_y);
          }
          StatusProgress->End();
          break;
      }
    }
		window.Bitmap->StopScanLine();
		window.Mask->StopScanLine();
 		MainImageForm->WorkArea->Mask->StopScanLine();
		Image->Bitmap->StopScanLine();
  }
  return;
fail:
	window.Mask->StopScanLine();
	window.Bitmap->StopScanLine();
	MainImageForm->WorkArea->Mask->StopScanLine();
	Image->Bitmap->StopScanLine();
  window.Mask->Destroy();
  window.Bitmap->Destroy();
  MoveCopyImage->Bitmap->Destroy();
  EXCEPTION_MESSAGE_OK(EC_MEMORY_LACK);
}
//---------------------------------------------------------------------------
void __fastcall TMoveCopyForm::bending_tube(void)
{

  int i, j, n, temp, cx, cy, err, diff_Y, diff_X;
  Byte *PP, *PP1, *DP, *DP1, *WBP, *WBP1, *MP, mm, *MP1, mm1, *WP, wm, *WP1,
       wm1, *WMP, *IP, *IP1, *IP2, *IP3, v, wmm;
  COLORREF c, bgc;
  double y, x, radius, yy, xx, diff_YY, diff_XX, diff, diff1, IPMaxX, IPMinX;
  TPItemImage *Image = MainImageForm->iMainImage;
  bool sw = false;

  if ((Theta <= 0) || (Theta >= M_PI)) {
    if (Theta <= 0) Theta = M_PI*0.05;
    else Theta = M_PI*0.95;
  }
  if (Dsy>Dsx) {
    cx = window.s.x+window.size.x/2.0;
    if(Dsy1>0){
      cy = window.s.y-window.size.x/(4*tan((M_PI-Theta)/2));
      if (cy < window.s.y) {
        y = window.s.y-(cx-window.s.x)*(cx-window.s.x)/(cy-window.s.y);
        radius = sqrt((cx-window.s.x)*(cx-window.s.x)+(y-window.s.y)*(y-window.s.y));
        bendwindow.size.y=window.e.y-(y-radius);
        sw = true;
      }
    } else {
      cy = window.e.y+window.size.x/(4*tan((M_PI-Theta)/2));
      if (cy > window.e.y) {
        y = window.e.y-(cx-window.e.x)*(cx-window.e.x)/(cy-window.e.y);
        radius = sqrt((cx-window.e.x)*(cx-window.e.x)+(y-window.e.y)*(y-window.e.y));
        bendwindow.size.y=y+radius-window.s.y;
        sw = true;
      }
    }
    bendwindow.size.x = window.size.x;
    if (new_mc_buf(bendwindow) == false) return;
		if (!Image->Bitmap->StartScanLineN(2)) goto fail;
		if (!window.Bitmap->StartScanLine()) goto fail;
		if (!window.Mask->StartScanLine()) goto fail;
 		if (!MainImageForm->WorkArea->Mask->StartScanLine()) goto fail;
    if (Image->Bitmap->BitsPerPixel==8) {
      if (sw) {
          switch (FullViewForm->Super) {
  	 		    case sOff:
              StatusProgress->Maximum = bendwindow.size.y;
              for (j=0; j < bendwindow.size.y; j++) {
	        	    StatusProgress->Position = j;
                WMP = window.Mask->GetScanLine(j);
                WBP = window.Bitmap->GetScanLine(j);
          		  for (i=0; i < window.size.x; i++, WBP++, WMP++) {
                  if (Dsy1>0){
                    yy=y-sqrt(fabs(radius*radius-(i+window.s.x-cx)*(i+window.s.x-cx)));
                    if(radius<window.size.x/2){
                      yy=window.s.y-sqrt(fabs(window.size.x*window.size.x/4-(i+window.s.x-cx)*(i+window.s.x-cx)));
                    }
                    yy = floor(yy+0.5);
                    diff_Y = (y-radius+j)-yy;
                  } else {
                    yy=y+sqrt(fabs(radius*radius-(i+window.s.x-cx)*(i+window.s.x-cx)));
                    if(radius<window.size.x/2){
                      yy=window.e.y+sqrt(fabs(window.size.x*window.size.x/4-(i+window.s.x-cx)*(i+window.s.x-cx)));
                    }
                    yy = floor(yy+0.5);
                    diff_Y = yy-(window.s.y+j);
                    diff_Y = window.size.y-diff_Y;
                  }
                  if(diff_Y>=0 && diff_Y < window.size.y){
                    MP = MainImageForm->WorkArea->Mask->GetScanLine(diff_Y)+i;
                    IP = Image->Bitmap->GetScanLine(window.s.y+diff_Y) + (window.s.x+i);
                    if(*MP){
                      *WBP = *IP;
                      *WMP = 0;
                    } else {
                      *WBP = 0;
                      *WMP = 0xff;
                    }
                  } else {
                    *WBP = 0;
                    *WMP = 0xff;
                  }
                }
                window.Bitmap->PutScanLine(j);
                window.Mask->PutScanLine(j);
              }
              StatusProgress->End();
       	      break;
    	      case sOverlap: case sNormal: case sGauze:
          	  StatusProgress->Maximum = bendwindow.size.y;
              for (j=0;j<bendwindow.size.y;j++) {
	        	    StatusProgress->Position = j;
                WMP = window.Mask->GetScanLine(j);
                WBP = window.Bitmap->GetScanLine(j);
          		  for (i=0; i < window.size.x; i++, WBP++, WMP++) {
                  if (Dsy1>0){
                    yy=y-sqrt(fabs(radius*radius-(i+window.s.x-cx)*(i+window.s.x-cx)));
                    if(radius<window.size.x/2){
                      yy=window.s.y-sqrt(fabs(window.size.x*window.size.x/4-(i+window.s.x-cx)*(i+window.s.x-cx)));
                    }
                    yy = floor(yy+0.5);
                    diff_Y = (y-radius+j)-yy;
                  } else {
                    yy=y+sqrt(fabs(radius*radius-(i+window.s.x-cx)*(i+window.s.x-cx)));
                    if(radius<window.size.x/2){
                      yy=window.e.y+sqrt(fabs(window.size.x*window.size.x/4-(i+window.s.x-cx)*(i+window.s.x-cx)));
                    }
                    yy = floor(yy+0.5);
                    diff_Y = yy-(window.s.y+j);
                    diff_Y = window.size.y-diff_Y;
                  }
                  if (diff_Y>=0 && diff_Y < window.size.y){
                    MP = MainImageForm->WorkArea->Mask->GetScanLine(diff_Y)+i;
                    IP = Image->Bitmap->GetScanLine(window.s.y+diff_Y) + (window.s.x+i);
                    if (*MP && *IP!=1) {
                      *WBP = *IP;
                      *WMP = 0;
                    } else {
                      *WBP = 0;
                      *WMP = 0xff;
                    }
                  } else {
                    *WBP = 0;
                    *WMP = 0xff;
                  }
                }
                window.Bitmap->PutScanLine(j);
                window.Mask->PutScanLine(j);
              }
              StatusProgress->End();
              break;
          }
        } else {
          switch (FullViewForm->Super) {
  	 		    case sOff:
              StatusProgress->Maximum = window.size.y;
              for (j=0; j < window.size.y; j++) {
	        	    StatusProgress->Position = j;
                WBP = window.Bitmap->GetScanLine(j);
          		  for (i=0; i < window.size.x; i++, WBP++) {
                  IP = Image->Bitmap->GetScanLine(window.s.y+j) + (window.s.x+i);
                  *WBP = *IP;
                }
                window.Bitmap->PutScanLine(j);
                window.Mask->PutScanLine(j);
              }
              StatusProgress->End();
       	      break;
    	      case sOverlap: case sNormal: case sGauze:
          	  StatusProgress->Maximum = window.size.y;
              for (j=0;j<window.size.y;j++) {
	        	    StatusProgress->Position = j;
                WMP = window.Mask->GetScanLine(j);
                WBP = window.Bitmap->GetScanLine(j);
          		  for (i=0; i < window.size.x; i++, WBP++, WMP++) {
                  MP = MainImageForm->WorkArea->Mask->GetScanLine(j)+i;
                  IP = Image->Bitmap->GetScanLine(window.s.y+j) + (window.s.x+i);
                  if (*MP && *IP!=1) {
                    *WBP = *IP;
                    *WMP = 0;
                  } else {
                    *WBP = 0;
                    *WMP = 0xff;
                  }
                }
                window.Bitmap->PutScanLine(j);
                window.Mask->PutScanLine(j);
              }
              StatusProgress->End();
              break;
          }
        }
    } else {
     	bgc = PaletteForm->DIB256Palette->GetBGCOLORREF(24);
      diff1=0;
      if (sw) {
        switch (FullViewForm->Super) {
    	 		case sOff:
            StatusProgress->Maximum = bendwindow.size.y;
    	  		for (j=0;j<bendwindow.size.y;j++) {
              StatusProgress->Position = j;
              WMP = window.Mask->GetScanLine(j);
              WBP = window.Bitmap->GetScanLine(j);
              *WMP = 0;	wmm = 0x80;
              for (i=0; i < window.size.x; i++, WBP+=3) {
                if(Dsy1>0){
                  yy=y-sqrt(fabs(radius*radius-(i+window.s.x-cx)*(i+window.s.x-cx)));
                  if(radius<window.size.x/2){
                    yy=window.s.y-sqrt(fabs(window.size.x*window.size.x/4-(i+window.s.x-cx)*(i+window.s.x-cx)));
                  }
                  diff_YY = y-radius+j-yy;
                  diff_Y = floor(diff_YY);
                } else {
                  yy=y+sqrt(fabs(radius*radius-(i+window.s.x-cx)*(i+window.s.x-cx)));
                  if(radius<window.size.x/2){
                    yy = window.e.y+sqrt(fabs(window.size.x*window.size.x/4-(i+window.s.x-cx)*(i+window.s.x-cx)));
                  }
                  diff_YY =window.size.y-(yy-window.s.y-j);
                  diff_Y = floor(diff_YY);
                }
                diff = diff_YY-diff_Y;
                if(diff_Y>=0 && diff_Y < window.size.y){
                  MP = MainImageForm->WorkArea->Mask->GetScanLine(diff_Y)+(i>>3);
                  mm = 0x80>>(i&7);
                  IP = Image->Bitmap->GetScanLine(window.s.y+diff_Y) + 3*(window.s.x+i);
                  IP1 = Image->Bitmap->GetScanLine(window.s.y+diff_Y+1) + 3*(window.s.x+i);
                  PixelCenter(v);
                  c = v<<16;
                  IP++;
                  IP1++;
                  PixelCenter(v);
                  c |= v<<8;
                  IP++;
                  IP1++;
                  PixelCenter(v);
                  c |= v;
                  if (*MP&mm) {
                    SetPixel24(WBP, c);
                  } else {
                    SetPixel24(WBP, 0);
                    *WMP |= wmm;
                  }
                } else {
                  SetPixel24(WBP, 0);
                  *WMP |= wmm;
                }
                if (wmm==1) { WMP++; *WMP = 0; wmm = 0x80; } else wmm >>= 1;
              }
              window.Bitmap->PutScanLine(j);
              window.Mask->PutScanLine(j);
            }
            StatusProgress->End();
            break;
          case sOverlap: case sNormal: case sGauze:
            StatusProgress->Maximum = bendwindow.size.y;
    	  		for (j=0;j<bendwindow.size.y;j++) {
              StatusProgress->Position = j;
              WMP = window.Mask->GetScanLine(j);
              WBP = window.Bitmap->GetScanLine(j);
              *WMP = 0;	wmm = 0x80;
              for (i=0; i < window.size.x; i++, WBP+=3) {
                if(Dsy1>0){
                  yy=y-sqrt(fabs(radius*radius-(i+window.s.x-cx)*(i+window.s.x-cx)));
                  if(radius<window.size.x/2){
                    yy=window.s.y-sqrt(fabs(window.size.x*window.size.x/4-(i+window.s.x-cx)*(i+window.s.x-cx)));
                  }
                  diff_YY = y-radius+j-yy;
                  diff_Y = floor(diff_YY);
                } else {
                  yy=y+sqrt(fabs(radius*radius-(i+window.s.x-cx)*(i+window.s.x-cx)));
                  if(radius<window.size.x/2){
                    yy = window.e.y+sqrt(fabs(window.size.x*window.size.x/4-(i+window.s.x-cx)*(i+window.s.x-cx)));
                  }
                  diff_YY =window.size.y-(yy-window.s.y-j);
                  diff_Y = floor(diff_YY);
                }
                diff = diff_YY-diff_Y;
                if(diff_Y >= 0 && diff_Y < window.size.y){
                  MP = MainImageForm->WorkArea->Mask->GetScanLine(diff_Y)+(i>>3);
                  mm = 0x80>>(i&7);
                  IP = Image->Bitmap->GetScanLine(window.s.y+diff_Y) + 3*(window.s.x+i);
                  IP1 = Image->Bitmap->GetScanLine(window.s.y+diff_Y+1) + 3*(window.s.x+i);
                  PixelCenter(v);
                  c = v<<16;
                  IP++;
                  IP1++;
                  PixelCenter(v);
                  c |= v<<8;
                  IP++;
                  IP1++;
                  PixelCenter(v);
                  c |= v;
                  if ((*MP&mm) && c!=bgc) {
                    SetPixel24(WBP, c);
                  } else {
                    SetPixel24(WBP, 0);
                    *WMP |= wmm;
                  }
                } else {
                  SetPixel24(WBP, 0);
                  *WMP |= wmm;
                }
                if (wmm==1) { WMP++; *WMP = 0; wmm = 0x80; } else wmm >>= 1;
              }
              window.Bitmap->PutScanLine(j);
              window.Mask->PutScanLine(j);
            }
            StatusProgress->End();
            break;
        }
      } else {
        switch (FullViewForm->Super) {
    	 		case sOff:
            StatusProgress->Maximum = window.size.y;
    	  		for (j=0;j<window.size.y;j++) {
              StatusProgress->Position = j;
              WMP = window.Mask->GetScanLine(j);
              WBP = window.Bitmap->GetScanLine(j);
              *WMP = 0;	wmm = 0x80;
              for (i=0; i < window.size.x; i++, WBP+=3) {
                MP = MainImageForm->WorkArea->Mask->GetScanLine(j)+(i>>3);
                mm = 0x80>>(i&7);
                IP = Image->Bitmap->GetScanLine(window.s.y+j) + 3*(window.s.x+i);
                c = *IP<<16;
                IP++;
                c |= *IP<<8;
                IP++;
                c |= *IP;
                if (*MP&mm) {
                  SetPixel24(WBP, c);
                } else {
                  SetPixel24(WBP, 0);
                  *WMP |= wmm;
                }
                if (wmm==1) { WMP++; *WMP = 0; wmm = 0x80; } else wmm >>= 1;
              }
              window.Bitmap->PutScanLine(j);
              window.Mask->PutScanLine(j);
            }
            StatusProgress->End();
            break;
          case sOverlap: case sNormal: case sGauze:
            StatusProgress->Maximum = window.size.y;
    	  		for (j=0;j<window.size.y;j++) {
              StatusProgress->Position = j;
              WMP = window.Mask->GetScanLine(j);
              WBP = window.Bitmap->GetScanLine(j);
              *WMP = 0;	wmm = 0x80;
              for (i=0; i < window.size.x; i++, WBP+=3) {
                MP = MainImageForm->WorkArea->Mask->GetScanLine(j)+(i>>3);
                mm = 0x80>>(i&7);
                IP = Image->Bitmap->GetScanLine(window.s.y+j) + 3*(window.s.x+i);
                c = *IP<<16;
                IP++;
                c |= *IP<<8;
                IP++;
                c |= *IP;
                if ((*MP&mm) && c!=bgc) {
                  SetPixel24(WBP, c);
                } else {
                  SetPixel24(WBP, 0);
                  *WMP |= wmm;
                }
                if (wmm==1) { WMP++; *WMP = 0; wmm = 0x80; } else wmm >>= 1;
              }
              window.Bitmap->PutScanLine(j);
              window.Mask->PutScanLine(j);
            }
            StatusProgress->End();
            break;
        }
      }
    }
		Image->Bitmap->StopScanLine();
		window.Bitmap->StopScanLine();
		window.Mask->StopScanLine();
 		MainImageForm->WorkArea->Mask->StopScanLine();
  } else {
    cy = window.s.y+window.size.y/2.0;
    if(Dsx1>0){
      cx = window.s.x-window.size.y/(4*tan((M_PI-Theta)/2));
      if (cx < window.s.x) {
        x = window.s.x-(cy-window.s.y)*(cy-window.s.y)/(cx-window.s.x);
        radius = sqrt((cy-window.s.y)*(cy-window.s.y)+(x-window.s.x)*(x-window.s.x));
        bendwindow.size.x=window.e.x-(x-radius);
        sw = true;
      }
    } else {
      cx = window.e.x+window.size.y/(4*tan((M_PI-Theta)/2));
      if (cx > window.e.x) {
        x = window.e.x-(cy-window.e.y)*(cy-window.e.y)/(cx-window.e.x);
        radius = sqrt((cy-window.e.y)*(cy-window.e.y)+(x-window.e.x)*(x-window.e.x));
        bendwindow.size.x=x+radius-window.s.x;
        sw = true;
      }
    }
    bendwindow.size.y = window.size.y+1;
    if (new_mc_buf(bendwindow) == false) return;
		if (!Image->Bitmap->StartScanLineN(2)) goto fail;
		if (!window.Bitmap->StartScanLine()) goto fail;
		if (!window.Mask->StartScanLine())  goto fail;
 		if (!MainImageForm->WorkArea->Mask->StartScanLine()) goto fail;
    if (Image->Bitmap->BitsPerPixel==8) {
      if (sw) {
			  switch (FullViewForm->Super) {
  	 		  case sOff:
        	  StatusProgress->Maximum = bendwindow.size.y;
      			for (j=0; j < bendwindow.size.y; j++) {
	          	StatusProgress->Position = j;
  	          WMP = window.Mask->GetScanLine(j);
              WBP = window.Bitmap->GetScanLine(j);
          		for (i=0; i < bendwindow.size.x; i++, WBP++, WMP++) {
                if(Dsx1>0){
                  xx=x-sqrt(fabs(radius*radius-(j+window.s.y-cy)*(j+window.s.y-cy)));
                  if(radius<window.size.y/2){
                     xx=window.s.x-sqrt(fabs(window.size.y*window.size.y/4-(j+window.s.y-cy)*(j+window.s.y-cy)));
                  }
                  xx = floor(xx+0.5);
                  diff_X=(x-radius+i)-xx;
                } else {
                  xx=x+sqrt(fabs(radius*radius-(j+window.s.y-cy)*(j+window.s.y-cy)));
                  if(radius<window.size.y/2){
                     xx=window.e.y+sqrt(fabs(window.size.y*window.size.y/4-(j+window.s.y-cy)*(j+window.s.y-cy)));
                  }
                  xx = floor(xx+0.5);
                  diff_X = xx-(window.s.x+i);
                  diff_X = window.size.x-diff_X;
                }
                if(diff_X>=0 && diff_X < window.size.x){
                  MP = MainImageForm->WorkArea->Mask->GetScanLine(j)+diff_X;
                  IP = Image->Bitmap->GetScanLine(window.s.y+j) + (window.s.x+diff_X);
                  if(*MP){
                    *WBP = *IP;
                    *WMP = 0;
                  } else {
                    *WBP = 0;
                    *WMP = 0xff;
                  }
                } else {
                   *WBP = 0;
                   *WMP = 0xff;
                }
              }
	            window.Bitmap->PutScanLine(j);
  	          window.Mask->PutScanLine(j);
            }
      	    StatusProgress->End();
     	      break;
          case sOverlap: case sNormal: case sGauze:
          	StatusProgress->Maximum = bendwindow.size.y;
      			for (j=0;j<bendwindow.size.y;j++) {
	          	StatusProgress->Position = j;
  	          WMP = window.Mask->GetScanLine(j);
              WBP = window.Bitmap->GetScanLine(j);
        		  for (i=0; i < bendwindow.size.x; i++, WBP++, WMP++) {
                if(Dsx1>0){
                  xx=x-sqrt(fabs(radius*radius-(j+window.s.y-cy)*(j+window.s.y-cy)));
                  if(radius<window.size.y/2){
                     xx=window.s.x-sqrt(fabs(window.size.y*window.size.y/4-(j+window.s.y-cy)*(j+window.s.y-cy)));
                  }
                  xx = floor(xx+0.5);
                  diff_X=(x-radius+i)-xx;
                } else {
                  xx=x+sqrt(fabs(radius*radius-(j+window.s.y-cy)*(j+window.s.y-cy)));
                  if(radius<window.size.y/2){
                     xx=window.e.y+sqrt(fabs(window.size.y*window.size.y/4-(j+window.s.y-cy)*(j+window.s.y-cy)));
                  }
                  xx = floor(xx+0.5);
                  diff_X = xx-(window.s.x+i);
                  diff_X = window.size.x-diff_X;
                }
                if(diff_X >= 0 && diff_X < window.size.x){
                  MP = MainImageForm->WorkArea->Mask->GetScanLine(j)+diff_X;
                  IP = Image->Bitmap->GetScanLine(window.s.y+j) + (window.s.x+diff_X);
                  if (*MP && *IP!=1) {
                    *WBP = *IP;
                    *WMP = 0;
                  } else {
                    *WBP = 0;
                    *WMP = 0xff;
                  }
                } else {
                   *WBP = 0;
                   *WMP = 0xff;
                }
              }
  	          window.Bitmap->PutScanLine(j);
    	        window.Mask->PutScanLine(j);
            }
        	  StatusProgress->End();
  	        break;
        }
      } else {
			  switch (FullViewForm->Super) {
  	 		  case sOff:
        	  StatusProgress->Maximum = window.size.y;
      			for (j=0; j < window.size.y; j++) {
	          	StatusProgress->Position = j;
              WBP = window.Bitmap->GetScanLine(j);
          		for (i=0; i < window.size.x; i++, WBP++) {
                IP = Image->Bitmap->GetScanLine(window.s.y+j) + (window.s.x+i);
                *WBP = *IP;
              }
	            window.Bitmap->PutScanLine(j);
  	          window.Mask->PutScanLine(j);
            }
      	    StatusProgress->End();
     	      break;
          case sOverlap: case sNormal: case sGauze:
          	StatusProgress->Maximum = window.size.y;
      			for (j=0;j<window.size.y;j++) {
	          	StatusProgress->Position = j;
  	          WMP = window.Mask->GetScanLine(j);
              WBP = window.Bitmap->GetScanLine(j);
        		  for (i=0; i < window.size.x; i++, WBP++, WMP++) {
                MP = MainImageForm->WorkArea->Mask->GetScanLine(j)+i;
                IP = Image->Bitmap->GetScanLine(window.s.y+j) + (window.s.x+i);
                if (*MP && *IP!=1) {
                  *WBP = *IP;
                  *WMP = 0;
                } else {
                  *WBP = 0;
                  *WMP = 0xff;
                }
              }
  	          window.Bitmap->PutScanLine(j);
    	        window.Mask->PutScanLine(j);
            }
        	  StatusProgress->End();
  	        break;
        }
      }
    } else {
     	bgc = PaletteForm->DIB256Palette->GetBGCOLORREF(24);
      diff=0;
      if (sw) {
  			switch (FullViewForm->Super) {
    	 		case sOff:
          	StatusProgress->Maximum = bendwindow.size.y;
    	  		for (j=0;j<bendwindow.size.y;j++) {
	          	StatusProgress->Position = j;
  	          WMP = window.Mask->GetScanLine(j);
              WBP = window.Bitmap->GetScanLine(j);
              *WMP = 0;	wmm = 0x80;
          		for (i=0; i < bendwindow.size.x; i++, WBP+=3) {
                if(Dsx1>0){
                  xx=x-sqrt(fabs(radius*radius-(j+window.s.y-cy)*(j+window.s.y-cy)));
                  if(radius<window.size.y/2){
                     xx=window.s.x-sqrt(fabs(window.size.y*window.size.y/4-(j+window.s.y-cy)*(j+window.s.y-cy)));
                  }
                  diff_XX = x-radius+i-xx;
                  diff_X = floor(diff_XX);
                } else {
                  xx=x+sqrt(fabs(radius*radius-(j+window.s.y-cy)*(j+window.s.y-cy)));
                  if(radius<window.size.y/2){
                     xx = window.e.x+sqrt(fabs(window.size.y*window.size.y/4-(j+window.s.y-cy)*(j+window.s.y-cy)));
                  }
                  diff_XX =window.size.x-(xx-window.s.x-i);
                  diff_X = floor(diff_XX);
                }
                diff1 = diff_XX-diff_X;
                if(diff_X>=0 && diff_X<window.size.x){
                  MP = MainImageForm->WorkArea->Mask->GetScanLine(j)+(diff_X>>3);
                  mm = 0x80>>(diff_X&7);
                  IP = Image->Bitmap->GetScanLine(window.s.y+j) + 3*(window.s.x+diff_X);
                  IP1 = Image->Bitmap->GetScanLine(window.s.y+j+1) + 3*(window.s.x+diff_X);
                  PixelCenter(v);
                  c = v<<16;
                  IP++;
                  IP1++;
                  PixelCenter(v);
                  c |= v<<8;
                  IP++;
                  IP1++;
                  PixelCenter(v);
                  c |= v;

       	    	    if (*MP&mm) {
           	 	      SetPixel24(WBP, c);
                  } else {
                    SetPixel24(WBP, 0);
                    *WMP |= wmm;
                  }
                } else {
						      SetPixel24(WBP, 0);
							    *WMP |= wmm;
     					  }
                if (wmm==1) { WMP++; *WMP = 0; wmm = 0x80; } else wmm >>= 1;
              }
	            window.Bitmap->PutScanLine(j);
  	          window.Mask->PutScanLine(j);
            }
        	  StatusProgress->End();
        	  break;
      	  case sOverlap: case sNormal: case sGauze:
          	StatusProgress->Maximum = bendwindow.size.y;
    		  	for (j=0;j<bendwindow.size.y;j++) {
	          	StatusProgress->Position = j;
  	          WMP = window.Mask->GetScanLine(j);
              WBP = window.Bitmap->GetScanLine(j);
              *WMP = 0;	wmm = 0x80;
          		for (i=0; i < bendwindow.size.x; i++, WBP+=3) {
                if(Dsx1>0){
                  xx=x-sqrt(fabs(radius*radius-(j+window.s.y-cy)*(j+window.s.y-cy)));
                  if(radius<window.size.y/2){
                     xx=window.s.x-sqrt(fabs(window.size.y*window.size.y/4-(j+window.s.y-cy)*(j+window.s.y-cy)));
                  }
                  diff_XX = x-radius+i-xx;
                  diff_X = floor(diff_XX);
                } else {
                  xx=x+sqrt(fabs(radius*radius-(j+window.s.y-cy)*(j+window.s.y-cy)));
                  if(radius<window.size.y/2){
                     xx = window.e.x+sqrt(fabs(window.size.y*window.size.y/4-(j+window.s.y-cy)*(j+window.s.y-cy)));
                  }
                  diff_XX =window.size.x-(xx-window.s.x-i);
                  diff_X = floor(diff_XX);
                }
                diff1 = diff_XX-diff_X;
                if(diff_X >= 0 && diff_X < window.size.x){
                  MP = MainImageForm->WorkArea->Mask->GetScanLine(j)+(diff_X>>3);
                  mm = 0x80>>(diff_X&7);
                  IP = Image->Bitmap->GetScanLine(window.s.y+j) + 3*(window.s.x+diff_X);
                  IP1 = Image->Bitmap->GetScanLine(window.s.y+j+1) + 3*(window.s.x+diff_X);
                  PixelCenter(v);
                  c = v<<16;
                  IP++;
                  IP1++;
                  PixelCenter(v);
                  c |= v<<8;
                  IP++;
                  IP1++;
                  PixelCenter(v);
                  c |= v;

        				  if ((*MP&mm) && c!=bgc) {
         	 	        SetPixel24(WBP, c);
                  } else {
                    SetPixel24(WBP, 0);
                    *WMP |= wmm;
                  }
                } else {
					  	    SetPixel24(WBP, 0);
						  	  *WMP |= wmm;
   					    }
                if (wmm==1) { WMP++; *WMP = 0; wmm = 0x80; } else wmm >>= 1;
              }
	            window.Bitmap->PutScanLine(j);
  	          window.Mask->PutScanLine(j);
            }
      	    StatusProgress->End();
    	      break;
	      }
      } else {
  			switch (FullViewForm->Super) {
    	 		case sOff:
          	StatusProgress->Maximum = window.size.y;
    	  		for (j=0;j<window.size.y;j++) {
	          	StatusProgress->Position = j;
  	          WMP = window.Mask->GetScanLine(j);
              WBP = window.Bitmap->GetScanLine(j);
              *WMP = 0;	wmm = 0x80;
          		for (i=0; i < window.size.x; i++, WBP+=3) {
                MP = MainImageForm->WorkArea->Mask->GetScanLine(j)+(i>>3);
                mm = 0x80>>(i&7);
                IP = Image->Bitmap->GetScanLine(window.s.y+j) + 3*(window.s.x+i);
                c = *IP<<16;
                IP++;
                c |= *IP<<8;
                IP++;
                c |= *IP;

                if (*MP&mm) {
                  SetPixel24(WBP, c);
                } else {
                  SetPixel24(WBP, 0);
                  *WMP |= wmm;
                }
                if (wmm==1) { WMP++; *WMP = 0; wmm = 0x80; } else wmm >>= 1;
              }
	            window.Bitmap->PutScanLine(j);
  	          window.Mask->PutScanLine(j);
            }
        	  StatusProgress->End();
        	  break;
      	  case sOverlap: case sNormal: case sGauze:
          	StatusProgress->Maximum = window.size.y;
    		  	for (j=0;j<window.size.y;j++) {
	          	StatusProgress->Position = j;
  	          WMP = window.Mask->GetScanLine(j);
              WBP = window.Bitmap->GetScanLine(j);
              *WMP = 0;	wmm = 0x80;
          		for (i=0; i < window.size.x; i++, WBP+=3) {
                MP = MainImageForm->WorkArea->Mask->GetScanLine(j)+(i>>3);
                mm = 0x80>>(i&7);
                IP = Image->Bitmap->GetScanLine(window.s.y+j) + 3*(window.s.x+i);
                c = *IP<<16;
                IP++;
                c |= *IP<<8;
                IP++;
                c |= *IP;

                if ((*MP&mm) && c!=bgc) {
                  SetPixel24(WBP, c);
                } else {
                  SetPixel24(WBP, 0);
                  *WMP |= wmm;
                }
                if (wmm==1) { WMP++; *WMP = 0; wmm = 0x80; } else wmm >>= 1;
              }
	            window.Bitmap->PutScanLine(j);
  	          window.Mask->PutScanLine(j);
            }
      	    StatusProgress->End();
    	      break;
	      }
      }
    }
		Image->Bitmap->StopScanLine();
		window.Bitmap->StopScanLine();
		window.Mask->StopScanLine();
 		MainImageForm->WorkArea->Mask->StopScanLine();
  }
  return;
fail:
	window.Bitmap->StopScanLine();
	window.Mask->StopScanLine();
 	MainImageForm->WorkArea->Mask->StopScanLine();
	Image->Bitmap->StopScanLine();
  window.Mask->Destroy();
  window.Bitmap->Destroy();
  EXCEPTION_MESSAGE_OK(EC_MEMORY_LACK);
}
//---------------------------------------------------------------------------
void __fastcall TMoveCopyForm::bend_locate()
{
  int center, ax, ay, bx, by, cx, cy, dx, dy, e;
  double x, y, tx1, ty1, tx2, ty2, sr, lr, ct, st, part, angle, cltheta;

  if (Dsx == Dsy) {
    tx1 = window.s.x;
    ty1 = window.s.y;
    tx2 = window.e.x;  ty2 = window.e.y;
    Lsx = tx1; Lsy = ty1;
    Lex = tx2; Ley = ty1;
    MainImageForm->DrawLineLocate(Point(Lsx, Lsy), Point(Lex, Ley));
    Lex = tx1; Ley = ty2;
    MainImageForm->DrawLineLocate(Point(Lsx, Lsy), Point(Lex, Ley));
    Lsx = tx2; Lsy = ty2;
    Lex = tx2; Ley = ty1;
    MainImageForm->DrawLineLocate(Point(Lsx, Lsy), Point(Lex, Ley));
    Lex = tx1; Ley = ty2;
    MainImageForm->DrawLineLocate(Point(Lsx, Lsy), Point(Lex, Ley));
  } else if (rgBendType->ItemIndex == 0) {
    if (Dsy > Dsx) {
      if (tR >= window.size.y / 2.0) {
        sr = tR - window.size.y / 2.0;
        lr = tR + window.size.y / 2.0;
        e  = 1;
      } else {
        Theta = 2 * (double)window.size.x / window.size.y;
        sr    = 0;
        lr    = window.size.y;
        e     = 0;
      }
      if (Sign == 1) center = Csy - window.size.y / 2.0 + lr + e;
      else center = Csy - window.size.y / 2.0 - sr + e;

      part = Theta / window.size.x / 2.0;
      tx2  = Csx; ty2 = center - lr * Sign;
      tx1  = tx2; ty1 = ty2;
      angle = 0;
      while (angle <= Theta / 2.0) {
        st  = sin(angle); ct  = cos(angle);
        x   = lr * st;    y   = center - lr * ct * Sign;
        Lsx = tx1;        Lsy = ty1;
        tx1 = Csx + x;    Lex = tx1;
        ty1 = y;          Ley = ty1;
		    MainImageForm->DrawLineLocate(Point(Lsx, Lsy), Point(Lex, Ley));
        Lsx = tx2;        Lsy = ty2;
        tx2 = Csx - x;    Lex = tx2;
        ty2 = y;          Ley = ty2;
		    MainImageForm->DrawLineLocate(Point(Lsx, Lsy), Point(Lex, Ley));
        angle = angle + part;
      }
      ax = tx1; bx = tx2; ay = ty1; by = ty2;
      if (window.size.x < sr * 3) part = Theta / window.size.x / 2.0;
      else part = Theta / (sr * 3 + 1) / 2.0;
      tx2 = Csx; ty2 = center - sr * Sign;
      tx1 = tx2; ty1 = ty2;
      angle = 0;
      while (angle <= Theta / 2.0) {
        st  = sin(angle); ct  = cos(angle);
        x   = sr * st;    y   = center - sr * ct * Sign;
        Lsx = tx1;        Lsy = ty1;
        tx1 = Csx + x;    Lex = tx1;
        ty1 = y;          Ley = ty1;
		    MainImageForm->DrawLineLocate(Point(Lsx, Lsy), Point(Lex, Ley));
        Lsx = tx2;        Lsy = ty2;
        tx2 = Csx - x;    Lex = tx2;
        ty2 = y;          Ley = ty2;
		    MainImageForm->DrawLineLocate(Point(Lsx, Lsy), Point(Lex, Ley));
      	angle = angle + part;
      }
      cx = tx1; dx = tx2; cy = ty1; dy = ty2;
      Lsx = ax;  Lsy = ay;  Lex = cx;  Ley = cy;
	    MainImageForm->DrawLineLocate(Point(Lsx, Lsy), Point(Lex, Ley));
      Lsx = bx;  Lsy = by;  Lex = dx;  Ley = dy;
	    MainImageForm->DrawLineLocate(Point(Lsx, Lsy), Point(Lex, Ley));
    } else {
      if (tR >= window.size.x / 2.0) {
        sr = tR - window.size.x / 2.0;
        lr = tR + window.size.x / 2.0;
        e     = 0;
        e  = 1;
      } else {
        Theta = 2 * (double)window.size.y / window.size.x;
        sr    = 0;
        lr    = window.size.x;
        e     = 0;
      }
      if (Sign == 1) center = Csx - window.size.x / 2.0 + lr + e;
      else center = Csx - window.size.x / 2.0 - sr + e;

      part = Theta / window.size.y / 2.0;
      ty2  = Csy ; tx2 = center - lr * Sign;
      ty1  = ty2; tx1 = tx2;
      angle = 0;
      while (angle <= Theta / 2.0) {
        st  = sin(angle);              ct  = cos(angle);
        x   = center - lr * ct * Sign; y   = lr * st;
        Lsx = tx1;                     Lsy = ty1;
        tx1 = x;                       Lex = tx1;
        ty1 = Csy + y;                 Ley = ty1;
	      MainImageForm->DrawLineLocate(Point(Lsx, Lsy), Point(Lex, Ley));
        Lsx = tx2;                     Lsy = ty2;
        tx2 = x;                       Lex = tx2;
        ty2 = Csy - y;                 Ley = ty2;
		    MainImageForm->DrawLineLocate(Point(Lsx, Lsy), Point(Lex, Ley));
      	angle = angle + part;
      }
      ax = tx1; bx = tx2; ay = ty1; by = ty2;
      if (window.size.y < sr * 3) part = Theta / window.size.y / 2.0;
      else part = Theta / (sr * 3 + 1) / 2;
      ty2 = Csy; tx2 = center - sr * Sign;
      ty1 = ty2; tx1 = tx2;
      angle = 0;
      while (angle <= Theta / 2.0) {
        st = sin(angle);  ct = cos(angle);
        x = center - sr * ct * Sign; y = sr * st;
        Lsx = tx1;                   Lsy = ty1;
        tx1 = x;                     Lex = tx1;
        ty1 = Csy + y;               Ley = ty1;
		    MainImageForm->DrawLineLocate(Point(Lsx, Lsy), Point(Lex, Ley));
        Lsx = tx2;                   Lsy = ty2;
        tx2 = x;                     Lex = tx2;
        ty2 = Csy - y;               Ley = ty2;
		    MainImageForm->DrawLineLocate(Point(Lsx, Lsy), Point(Lex, Ley));
      	angle = angle + part;
      }
      cx = tx1; dx = tx2; cy = ty1; dy = ty2;
      Lsx = ax;  Lsy = ay;  Lex = cx;  Ley = cy;
	    MainImageForm->DrawLineLocate(Point(Lsx, Lsy), Point(Lex, Ley));
      Lsx = bx;  Lsy = by;  Lex = dx;  Ley = dy;
	    MainImageForm->DrawLineLocate(Point(Lsx, Lsy), Point(Lex, Ley));
    }
  } else {
    if (Dsy > Dsx) {
      if (fabs(tR) > window.size.x/2) {
        center = Csy - window.size.y / 2.0 - sqrt(fabs(tR * tR - window.size.x * window.size.x / 4.0)) * Sign + 1;
        tx2 = window.s.x;
        tx1 = tx2; ty1 = window.s.y;
        x = 0;
        while (x <= window.size.x) {
          y   = sqrt(fabs(tR * tR - (window.size.x/2-x) * (window.size.x/2-x))) * Sign + center;
          Lsx = tx1;        Lsy = ty1;
          tx1 = window.s.x + x;    Lex = tx1;
          ty1 = y;          Ley = ty1;
          if (x == 0) ty2 = y;
		      MainImageForm->DrawLineLocate(Point(Lsx, Lsy), Point(Lex, Ley));
          x = x + 1;
        }
        Lsx = tx1; Lsy = ty1; Lex = window.e.x;
        Ley = window.s.y;
	      MainImageForm->DrawLineLocate(Point(Lsx, Lsy), Point(Lex, Ley));

        center = center + window.size.y;
        tx2 = window.s.x;
        tx1 = tx2; ty1 = window.e.y;
        x = 0;
        while (x <= window.size.x) {
          y   = sqrt(fabs(tR * tR - (window.size.x/2-x) * (window.size.x/2-x))) * Sign + center;
          Lsx = tx1;        Lsy = ty1;
          tx1 = window.s.x + x;    Lex = tx1;
          ty1 = y;          Ley = ty1;
          if (x == 0) ty2 = y;
		      MainImageForm->DrawLineLocate(Point(Lsx, Lsy), Point(Lex, Ley));
          x = x + 1;
        }
        Lsx = tx1; Lsy = ty1; Lex = window.e.x;
        Ley = window.e.y;
	      MainImageForm->DrawLineLocate(Point(Lsx, Lsy), Point(Lex, Ley));

        Lsx = window.s.x; Lsy = window.s.y;
        Lex = Lsx; Ley = window.e.y;
  	    MainImageForm->DrawLineLocate(Point(Lsx, Lsy), Point(Lex, Ley));
        Lsx = window.e.x; Lsy = window.s.y;
        Lex = Lsx; Ley = window.e.y;
	      MainImageForm->DrawLineLocate(Point(Lsx, Lsy), Point(Lex, Ley));
      } else {
        center = Csy - window.size.y / 2.0 ;
        if (window.size.y%2 == 1) center = center + 1;
        tx2 = window.s.x;
        tx1 = tx2; ty1 = window.s.y;
        x = 0;
        while (x <= window.size.x) {
          y   = sqrt(fabs((window.size.x * window.size.x)/4 - (window.size.x/2-x) * (window.size.x/2-x))) * Sign + center;
          Lsx = tx1;        Lsy = ty1;
          tx1 = window.s.x + x;    Lex = tx1;
          ty1 = y;          Ley = ty1;
          if (x == 0) ty2 = y;
  		    MainImageForm->DrawLineLocate(Point(Lsx, Lsy), Point(Lex, Ley));
          x = x + 1;
        }
        Lsx = tx1; Lsy = ty1; Lex = window.e.x;
        Ley = window.s.y;
  	    MainImageForm->DrawLineLocate(Point(Lsx, Lsy), Point(Lex, Ley));

        center = center + window.size.y;
        tx2 = window.s.x;
        tx1 = tx2; ty1 = window.e.y;
        x = 0;
        while (x <= window.size.x) {
          y   = sqrt(fabs((window.size.x * window.size.x)/4 - (window.size.x/2-x) * (window.size.x/2-x))) * Sign + center;
          Lsx = tx1;        Lsy = ty1;
          tx1 = window.s.x + x;    Lex = tx1;
          ty1 = y;          Ley = ty1;
          if (x == 0) ty2 = y;
		      MainImageForm->DrawLineLocate(Point(Lsx, Lsy), Point(Lex, Ley));
          x = x + 1;
        }
        Lsx = tx1; Lsy = ty1; Lex = window.e.x;
        Ley = window.e.y;
  	    MainImageForm->DrawLineLocate(Point(Lsx, Lsy), Point(Lex, Ley));

        Lsx = window.s.x; Lsy = window.s.y;
        Lex = Lsx; Ley = window.e.y;
	      MainImageForm->DrawLineLocate(Point(Lsx, Lsy), Point(Lex, Ley));
        Lsx = window.e.x; Lsy = window.s.y;
        Lex = Lsx; Ley = window.e.y;
	      MainImageForm->DrawLineLocate(Point(Lsx, Lsy), Point(Lex, Ley));
      }
    } else {
      if (fabs(tR) > window.size.y/2) {
        center = Csx - window.size.x / 2.0 - sqrt(fabs(tR * tR - window.size.y * window.size.y / 4.0)) * Sign + 1;
        ty2 = window.s.y;
        tx1 = window.s.x;                ty1 = ty2;
        y = 0;
        while (y <= window.size.y) {
          x   = sqrt(fabs(tR * tR - (window.size.y/2-y) * (window.size.y/2-y))) * Sign + center;
          Lsx = tx1;        Lsy = ty1;
          tx1 = x;          Lex = tx1;
          ty1 = window.s.y + y;    Ley = ty1;
          if (y == 0) tx2 = x;
		      MainImageForm->DrawLineLocate(Point(Lsx, Lsy), Point(Lex, Ley));
          y = y + 1;
        }
        Lsx = tx1; Lex = window.s.x;
        Lsy = ty1; Ley = window.e.y;
	      MainImageForm->DrawLineLocate(Point(Lsx, Lsy), Point(Lex, Ley));

        center = center + window.size.x;
        ty2 = window.s.y;
        tx1 = window.e.x;                ty1 = ty2;
        y = 0;
        while (y <= window.size.y) {
          x   = sqrt(fabs(tR * tR - (window.size.y/2-y) * (window.size.y/2-y))) * Sign + center;
          Lsx = tx1;        Lsy = ty1;
          tx1 = x;          Lex = tx1;
          ty1 = window.s.y + y;    Ley = ty1;
          if (y == 0) tx2 = x;
		      MainImageForm->DrawLineLocate(Point(Lsx, Lsy), Point(Lex, Ley));
          y = y + 1;
        }
        Lsx = tx1; Lsy = ty1; Lex = window.e.x;
        Ley = window.e.y;
	      MainImageForm->DrawLineLocate(Point(Lsx, Lsy), Point(Lex, Ley));

        Lsx = window.s.x; Lsy = window.s.y;
        Lex = window.e.x; Ley = Lsy;
	      MainImageForm->DrawLineLocate(Point(Lsx, Lsy), Point(Lex, Ley));
        Lsx = window.s.x; Lsy = window.e.y;
        Lex = window.e.x; Ley = Lsy;
	      MainImageForm->DrawLineLocate(Point(Lsx, Lsy), Point(Lex, Ley));
      } else {
        center = Csx - window.size.x / 2.0;
        if (window.size.x%2 == 1) center = center + 1;
        ty2 = window.s.y;
        tx1 = window.s.x;                ty1 = ty2;
        y = 0;
        while (y <= window.size.y) {
          x   = sqrt(fabs((window.size.y * window.size.y)/4- (window.size.y/2-y) * (window.size.y/2-y))) * Sign + center;
          Lsx = tx1;        Lsy = ty1;
          tx1 = x;          Lex = tx1;
          ty1 = window.s.y + y;    Ley = ty1;
          if (y == 0) tx2 = x;
		      MainImageForm->DrawLineLocate(Point(Lsx, Lsy), Point(Lex, Ley));
          y = y + 1;
        }
        Lsx = tx1; Lex = window.s.x;
        Lsy = ty1; Ley = window.e.y;
	      MainImageForm->DrawLineLocate(Point(Lsx, Lsy), Point(Lex, Ley));

        center = center + window.size.x;
        ty2 = window.s.y;
        tx1 = window.e.x;                ty1 = ty2;
        y = 0;
        while (y <= window.size.y) {
          x   = sqrt(fabs((window.size.y * window.size.y)/4 - (window.size.y/2-y) * (window.size.y/2-y))) * Sign + center;
          Lsx = tx1;        Lsy = ty1;
          tx1 = x;          Lex = tx1;
          ty1 = window.s.y + y;    Ley = ty1;
          if (y == 0) tx2 = x;
	  	    MainImageForm->DrawLineLocate(Point(Lsx, Lsy), Point(Lex, Ley));
          y = y + 1;
        }
        Lsx = tx1; Lsy = ty1; Lex = window.e.x;
        Ley = window.e.y;
	      MainImageForm->DrawLineLocate(Point(Lsx, Lsy), Point(Lex, Ley));

        Lsx = window.s.x; Lsy = window.s.y;
        Lex = window.e.x; Ley = Lsy;
	      MainImageForm->DrawLineLocate(Point(Lsx, Lsy), Point(Lex, Ley));
        Lsx = window.s.x; Lsy = window.e.y;
        Lex = window.e.x; Ley = Lsy;
	      MainImageForm->DrawLineLocate(Point(Lsx, Lsy), Point(Lex, Ley));
      }
    }
  }
}
//---------------------------------------------------------------------------
void __fastcall TMoveCopyForm::MakeBendImage()
{
  TCursor OldCursor;
  TPSelectImage *MoveCopyImage = MainImageForm->iSelectImage;

  OldCursor = Screen->Cursor;
 	Screen->Cursor = crHourGlass;
  bendwindow.s      = window.s;
 	bendwindow.e      = window.e;
  bendwindow.size   = window.size;
 	bendwindow.Bitmap = 0;
  bendwindow.Mask   = 0;
 	bendwindow.Back   = 0;
  MoveCopyImage->Visible = false;
  if (Dsx == Dsy) {
    SetMoveCopyImage();
  } else if (rgBendType->ItemIndex == 0) {
		bending_fan();
  } else {
		bending_tube();
  }
 	Screen->Cursor = OldCursor;
}
//---------------------------------------------------------------------------
void __fastcall TMoveCopyForm::BendMouseDown(int X, int Y)
{
  TCursor OldCursor;
  TPSelectImage *MoveCopyImage = MainImageForm->iSelectImage;

	if (step==0) {
    step = 1;
  	bend_locate();
		MakeBendImage();
//    MoveCopyImage->Visible = true;
    IsDraw = false;
  } else if (step==1) {
  	step = 2;
  }
}
//---------------------------------------------------------------------------
void __fastcall TMoveCopyForm::BendMouseMove(int X, int Y)
{
  TPItemImage *Image = MainImageForm->iMainImage;

  if (step==0) {
  	if (IsDraw) bend_locate();
    Dsx1 = Csx-X;
    Dsy1 = Csy-Y;
  	Dsx = abs(Dsx1);
  	Dsy = abs(Dsy1);
  	if (Dsy > Dsx) {
    	if (Csy < Y) {
      	Theta = fabs(M_PI * (Y - Csy) / (Image->Height - (Csy - Image->PositionY)));
#if defined(KNIT)
      	Theta = fabs(M_PI * (Y - Csy) / (Csy - Image->PositionY));
#endif
        if(Theta > M_PI) Theta = M_PI;
      	Sign  = 1;
    	} else {
      	Theta = fabs(M_PI * (Csy - Y) / (Csy - Image->PositionY));
      	Sign  = -1;
    	}
    	if (Theta) tR = M_PI * window.size.x / (2.0 * Theta);
      else tR = 0;
  	} else {
    	if (Csx < X) {
      	Theta = fabs(M_PI * (X - Csx) / (Image->Width - (Csx - Image->PositionX)));
#if defined (KNIT)
      	Theta = fabs(M_PI * (X - Csx) / (Csx - Image->PositionX));
#endif
        if(Theta > M_PI) Theta = M_PI;
      	Sign  = 1;
    	} else {
      	Theta = fabs((M_PI * (Csx - X) / (Csx - Image->PositionX)));
      	Sign  = -1;
    	}
      if (Theta) tR = M_PI * window.size.y / (2.0 * Theta);
      else tR = 0;
  	}
  	if (rgBendType->ItemIndex == 0) {
  		Theta = Theta * 2.0;
    	tR = tR / M_PI;
  	}
  	bend_locate();
    IsDraw = true;
  } else if (step==1) {
		SymmertyMouseMove(X, Y);
  }
/*  TPItemImage *Image = MainImageForm->iMainImage;

  if (step==0) {
  	if (IsDraw) bend_locate();
    Dsx1 = Csx-X;
    Dsy1 = Csy-Y;
  	Dsx = abs(Dsx1);
  	Dsy = abs(Dsy1);
  	if (Dsy > Dsx) {
    	if (Csy < Y) {
      	Theta = M_PI * (Y - Csy) / (Image->Height - Csy);
        if(Theta > M_PI) Theta = M_PI;
      	Sign  = 1;
    	} else {
      	Theta = M_PI * (Csy - Y) / Csy;
      	Sign  = -1;
    	}
    	if (Theta) tR = M_PI * window.size.x / (2.0 * Theta);
      else tR = 0;
  	} else {
    	if (Csx < X) {
      	Theta = M_PI * (X - Csx) / (Image->Width - Csx);
        if(Theta > M_PI) Theta = M_PI;
      	Sign  = 1;
    	} else {
      	Theta = M_PI * (Csx - X) / Csx;
      	Sign  = -1;
    	}
      if (Theta) tR = M_PI * window.size.y / (2.0 * Theta);
      else tR = 0;
  	}
  	if (rgBendType->ItemIndex == 0) {
  		Theta = Theta * 2.0;
    	tR = tR / M_PI;
  	}
  	bend_locate();
    IsDraw = true;
  } else if (step==1) {
		SymmertyMouseMove(X, Y);
  }
*/
}
//---------------------------------------------------------------------------
// Public Function
//---------------------------------------------------------------------------
void __fastcall TMoveCopyForm::InitForm()
{
  TCursor OldCursor;
  TPItemImage *Image = MainImageForm->iMainImage;
  TPSelectImage *MoveCopyImage = MainImageForm->iSelectImage;


  ParentHeight = Parent->Height+20;
 	ClientHeight = 215;
  Parent->Height = ParentHeight+ClientHeight;
  OldCursor      = Screen->Cursor;
  Screen->Cursor = crHourGlass;
	if ((window.Bitmap = new TTexpiaBitmap) == NULL) goto fail;
	if ((window.Mask = new TTexpiaBitmap) == NULL) goto fail;

  window.s.x     = MainImageForm->WorkArea->Range.left;
  window.s.y     = MainImageForm->WorkArea->Range.top;
  window.e.x     = MainImageForm->WorkArea->Range.right;
  window.e.y     = MainImageForm->WorkArea->Range.bottom;
  window.size.x = window.e.x - window.s.x;
  window.size.y = window.e.y - window.s.y;
  MoveCopyRect.s     = window.s;
  MoveCopyRect.e     = window.e;
  MoveCopyRect.size  = window.size;
  MoveCopyRect.Bitmap = 0;
  MoveCopyRect.Mask   = 0;
  MoveCopyRect.Back   = 0;
  MoveCopyImage->Left = window.s.x;
  MoveCopyImage->Top  = window.s.y;
  MoveCopyImage->Width  = 0;
  MoveCopyImage->Height = 0;
  if (Image->Bitmap->BitsPerPixel==8) {
		MainImageForm->Palette->ToRGBQUAD(rgb, 256);
    rgb[252].rgbRed = 192;      //---|
    rgb[252].rgbGreen = 192;    //   |  ----  clbtnface
    rgb[252].rgbBlue = 192;     //---|
    if (!MoveCopyImage->Bitmap->Create(window.size.x, window.size.y, 8, rgb)) goto fail;
	 	if (!window.Bitmap->Create(window.size.x, window.size.y, 8, rgb)) goto fail;
		if (!window.Mask->Create(window.size.x, window.size.y, 8, rgb)) goto fail;
  } else {
	  if (!MoveCopyImage->Bitmap->Create(window.size.x, window.size.y, 24)) goto fail;
	 	if (!window.Bitmap->Create(window.size.x, window.size.y, 24)) goto fail;
		if (!window.Mask->Create(window.size.x, window.size.y, 1)) goto fail;
  }
 	MoveCopyImage->SetPosition(0, 0);
  ReadIni();
  SetMoveCopyImage();
	rgBendType->ItemIndex = 0;
  IsDraw = false;
  Screen->Cursor = OldCursor;
  DrawMousePoint(MousePointPlace);
  return;
fail:
  Screen->Cursor = OldCursor;
  EXCEPTION_MESSAGE_OK(EC_MEMORY_LACK);
  PostMessage(hWnd, TPM_EXITFUNCTION, 0, 0);
}
//---------------------------------------------------------------------------
void __fastcall TMoveCopyForm::ExitForm(void)
{
  TPSelectImage *MoveCopyImage = MainImageForm->iSelectImage;

  WriteIni();
  if (IsDraw) {
  	if (MCItem == TMC_ROTATE) {
 			Rotate_Rect();
  	} else if (MCItem == TMC_BEND) {
 			bend_locate();
  	}
  }
  IsDraw = false;
  if (window.Bitmap) { delete window.Bitmap; window.Bitmap = 0; }
  if (window.Mask) { delete window.Mask; window.Mask = 0; }
  MoveCopyImage->Bitmap->Destroy();
  MoveCopyImage->Visible = false;
}
//---------------------------------------------------------------------------
void __fastcall TMoveCopyForm::ReadIni()
{
  int type, state;
  TIniFile *MoveCopyIni = NULL;
	MoveCopyIni = new TIniFile(DirectoryItem + "\\MoveCopy.ini");
  if (MoveCopyIni) {
  	state = MoveCopyIni->ReadInteger("MoveCopy", "State", 0);
  	if (state) {
  		MCState = TMC_MOVE;
    	sbMove->Down = true;
  	} else {
  		MCState = TMC_COPY;
    	sbCopy->Down = true;
  	}
  	type  = MoveCopyIni->ReadInteger("MoveCopy", "Type", 0);
  	if (type == 0) {
	  	MCItem  = TMC_NONE;
    	sbNormal->Down = true;
  	} else if (type == 1) {
	  	MCItem  = TMC_UPDOWN;
    	sbUpDown->Down = true;
  	} else if (type == 2) {
	  	MCItem  = TMC_MIRROR;
    	sbMirror->Down = true;
  	} else if (type == 3) {
	  	MCItem  = TMC_UDMIRROR;
    	sbUDMirror->Down = true;
  	}
  	BeforeDeg = MoveCopyIni->ReadInteger("Rotate", "BeforeDeg", 0);
  	delete MoveCopyIni;
  }
}
//---------------------------------------------------------------------------
void __fastcall TMoveCopyForm::WriteIni()
{
  int state, type;
  TIniFile *MoveCopyIni = NULL;
  if (MCState == TMC_COPY) state = 0; else state = 1;
  if (MCItem == TMC_UPDOWN)        type = 1;
  else if (MCItem == TMC_MIRROR)   type = 2;
  else if (MCItem == TMC_UDMIRROR) type = 3;
  else type = 0;
	MoveCopyIni = new TIniFile(DirectoryItem + "\\MoveCopy.ini");
  if (MoveCopyIni) {
  	MoveCopyIni->WriteInteger("MoveCopy", "State", state);
  	MoveCopyIni->WriteInteger("MoveCopy", "Type", type);
  	MoveCopyIni->WriteInteger("Rotate", "BeforeDeg", BeforeDeg);
  	delete MoveCopyIni;
  }
}
//---------------------------------------------------------------------------
void __fastcall TMoveCopyForm::SetMoveCopyImage(bool sw)
{
  int i, j;
  TCursor OldCursor;
  Byte *WP, *WBP, *MP, *PP, mm, wm;
  COLORREF bgc, c;
  bool mbc = false, wbc = false, wmc = false;
  TPItemImage *Image = MainImageForm->iMainImage;
  TPSelectImage *MoveCopyImage = MainImageForm->iSelectImage;

  OldCursor = Screen->Cursor;
  Screen->Cursor = crHourGlass;
  MoveCopyImage->Visible = false;
 	MoveCopyImage->Width  = 0;
	MoveCopyImage->Height = 0;
	if (MCItem == TMC_ROTATE) {
  	if (IsDraw) Rotate_Rect();
    if (sw) MakeRotateImage();
  } else if (MCItem == TMC_BEND) {
 	 	if (IsDraw) bend_locate();
    if (sw) MakeBendImage();
	} else {
    MoveCopyRect.s    = window.s;
    MoveCopyRect.e    = window.e;
    MoveCopyRect.size = window.size;
    if (Image->Bitmap->BitsPerPixel==8) {
	   	mbc = MoveCopyImage->Bitmap->Create(window.size.x, window.size.y, 8, rgb);
      if (mbc == false) goto fail;
  	 	MoveCopyImage->SetPosition(0, 0);
  		wbc = window.Bitmap->Create(window.size.x, window.size.y, 8, rgb);
      if (wbc == false) goto fail;
	  	wmc = window.Mask->Create(window.size.x, window.size.y, 8, rgb);
      if (wmc == false) goto fail;
    	if (!window.Bitmap->StartScanLine()) goto fail;
  	  if (!window.Mask->StartScanLine()) goto fail;
    	if (!Image->Bitmap->StartScanLine()) goto fail;
  	  if (!MainImageForm->WorkArea->Mask->StartScanLine()) goto fail;
  	  if (MCItem==TMC_NONE) {
  			switch (FullViewForm->Super) {
      		case sOff:
          	StatusProgress->Maximum = window.size.y;
   					for (i=0; i<window.size.y; i++) {
  	        	StatusProgress->Position = i;
  	          WBP = window.Bitmap->GetScanLine(i);
    	        MP = window.Mask->GetScanLine(i);
      	      PP = Image->Bitmap->GetScanLine(window.s.y + i)+window.s.x;
        	    WP = MainImageForm->WorkArea->Mask->GetScanLine(i);
   						for (j=0; j<window.size.x; j++, WBP++, MP++, PP++, WP++) {
          			if (*WP) {
                	*WBP = *PP;  *MP = 0x00;
    	      		} else {
      	          *WBP = 0x00; *MP = 0xFF;
          			}
   						}
    	        window.Bitmap->PutScanLine(i);
      	      window.Mask->PutScanLine(i);
   					}
          	StatusProgress->End();
            break;
        	case sOverlap: case sNormal: case sGauze:
          	StatusProgress->Maximum = window.size.y;
   					for (i=0; i<window.size.y; i++) {
  	        	StatusProgress->Position = i;
  	          WBP = window.Bitmap->GetScanLine(i);
    	        MP = window.Mask->GetScanLine(i);
      	      PP = Image->Bitmap->GetScanLine(window.s.y + i)+window.s.x;
        	    WP = MainImageForm->WorkArea->Mask->GetScanLine(i);
   						for (j=0; j<window.size.x; j++, WBP++, MP++, PP++, WP++) {
          			if (*WP && *PP > 1) {
                	*WBP = *PP;  *MP = 0x00;
    	      		} else {
      	          *WBP = 0x00; *MP = 0xFF;
          			}
   						}
    	        window.Bitmap->PutScanLine(i);
      	      window.Mask->PutScanLine(i);
   					}
          	StatusProgress->End();
        		break;
    	  }
  	  } else if (MCItem==TMC_UPDOWN) {
  			switch (FullViewForm->Super) {
    	    case sOff:
          	StatusProgress->Maximum = window.size.y;
  					for (i=0; i<window.size.y; i++) {
  	        	StatusProgress->Position = i;
            	WBP = window.Bitmap->GetScanLine(i);
  	          MP = window.Mask->GetScanLine(i);
    	        PP = Image->Bitmap->GetScanLine(window.e.y-1-i)+window.s.x;
      	      WP = MainImageForm->WorkArea->Mask->GetScanLine(window.size.y-1-i);
  						for (j=0; j<window.size.x; j++,WBP++, MP++, PP++, WP++) {
     						if (*WP) {
              	  *WBP = *PP;
                	*MP = 0x00;
  	   					} else {
    	            *WBP = 0x00;
      	          *MP = 0xFF;
     						}
  						}
  	          window.Bitmap->PutScanLine(i);
    	        window.Mask->PutScanLine(i);
  					}
          	StatusProgress->End();
        		break;
      	  case sOverlap: case sNormal: case sGauze:
          	StatusProgress->Maximum = window.size.y;
  					for (i=0; i<window.size.y; i++) {
  	        	StatusProgress->Position = i;
            	WBP = window.Bitmap->GetScanLine(i);
  	          MP = window.Mask->GetScanLine(i);
    	        PP = Image->Bitmap->GetScanLine(window.e.y-1-i)+window.s.x;
      	      WP = MainImageForm->WorkArea->Mask->GetScanLine(window.size.y-1-i);
  						for (j=0; j<window.size.x; j++, WBP++, MP++, PP++, WP++) {
     						if (*WP  && *PP > 1) {
              	  *WBP = *PP;
                	*MP = 0x00;
  	   					} else {
    	            *WBP = 0x00;
      	          *MP = 0xFF;
     						}
  						}
  	          window.Bitmap->PutScanLine(i);
    	        window.Mask->PutScanLine(i);
  					}
          	StatusProgress->End();
        		break;
    		}
  	  } else if (MCItem==TMC_MIRROR) {
  			switch (FullViewForm->Super) {
      	  case sOff:
          	StatusProgress->Maximum = window.size.y;
   					for (i=0; i<window.size.y; i++) {
  	        	StatusProgress->Position = i;
  	          WBP = window.Bitmap->GetScanLine(i);
    	        MP = window.Mask->GetScanLine(i);
      	      PP = Image->Bitmap->GetScanLine(window.s.y+i)+window.e.x-1;
        	    WP = MainImageForm->WorkArea->Mask->GetScanLine(i)+window.size.x-1;
   						for (j=0; j<window.size.x; j++, WBP++, MP++, PP--, WP--) {
          			if (*WP) {
                	*WBP = *PP;
  	              *MP = 0x00;
    	      		} else {
      	          *WBP = 0x00;
        	        *MP = 0xFF;
          			}
   						}
    	        window.Bitmap->PutScanLine(i);
      	      window.Mask->PutScanLine(i);
   					}
          	StatusProgress->End();
  					break;
        	case sOverlap: case sNormal: case sGauze:
          	StatusProgress->Maximum = window.size.y;
   					for (i=0; i<window.size.y; i++) {
  	        	StatusProgress->Position = i;
  	          WBP = window.Bitmap->GetScanLine(i);
    	        MP = window.Mask->GetScanLine(i);
      	      PP = Image->Bitmap->GetScanLine(window.s.y+i)+window.e.x-1;
        	    WP = MainImageForm->WorkArea->Mask->GetScanLine(i)+window.size.x-1;
   						for (j=0; j<window.size.x; j++, WBP++, MP++, PP--, WP--) {
          			if (*WP && *PP > 1) {
                	*WBP = *PP;
  	              *MP = 0x00;
    	      		} else {
      	          *WBP = 0x00;
        	        *MP = 0xFF;
          			}
   						}
    	        window.Bitmap->PutScanLine(i);
      	      window.Mask->PutScanLine(i);
   					}
          	StatusProgress->End();
  					break;
    		}
  	  } else if (MCItem==TMC_UDMIRROR) {
  			switch (FullViewForm->Super) {
      	  case sOff:
          	StatusProgress->Maximum = window.size.y;
  					for (i=0; i<window.size.y; i++) {
  	        	StatusProgress->Position = i;
  	          WBP = window.Bitmap->GetScanLine(i);
    	        MP = window.Mask->GetScanLine(i);
      	      PP = Image->Bitmap->GetScanLine(window.e.y-1-i)+window.e.x-1;
        	    WP = MainImageForm->WorkArea->Mask->GetScanLine(window.size.y-1-i)+window.size.x-1;
  						for (j=0; j<window.size.x; j++, WBP++, MP++, PP--, WP--) {
     						if (*WP) {
                	*WBP = *PP;
  	              *MP = 0x00;
    	 					} else {
      	          *WBP = 0x00;
        	        *MP = 0xFF;
     						}
  						}
    	        window.Bitmap->PutScanLine(i);
      	      window.Mask->PutScanLine(i);
  					}
          	StatusProgress->End();
       			break;
        	case sOverlap: case sNormal: case sGauze:
          	StatusProgress->Maximum = window.size.y;
  					for (i=0; i<window.size.y; i++) {
  	        	StatusProgress->Position = i;
  	          WBP = window.Bitmap->GetScanLine(i);
    	        MP = window.Mask->GetScanLine(i);
      	      PP = Image->Bitmap->GetScanLine(window.e.y-1-i)+window.e.x-1;
        	    WP = MainImageForm->WorkArea->Mask->GetScanLine(window.size.y-1-i)+window.size.x-1;
  						for (j=0; j<window.size.x; j++, WBP++, MP++, PP--, WP--) {
     						if (*WP && *PP > 1) {
                	*WBP = *PP;
  	              *MP = 0x00;
    	 					} else {
      	          *WBP = 0x00;
        	        *MP = 0xFF;
     						}
  						}
    	        window.Bitmap->PutScanLine(i);
      	      window.Mask->PutScanLine(i);
  					}
          	StatusProgress->End();
       			break;
  	  	}
  	  }
    	window.Bitmap->StopScanLine();
  	  window.Mask->StopScanLine();
    	Image->Bitmap->StopScanLine();
  	  MainImageForm->WorkArea->Mask->StopScanLine();
    } else {
	   	mbc = MoveCopyImage->Bitmap->Create(window.size.x, window.size.y, 24);
      if (mbc == false) goto fail;
  	 	MoveCopyImage->SetPosition(0, 0);
  		wbc = window.Bitmap->Create(window.size.x, window.size.y, 24);
      if (wbc == false) goto fail;
	  	wmc = window.Mask->Create(window.size.x, window.size.y, 1);
      if (wmc == false) goto fail;
  		bgc = PaletteForm->DIB256Palette->GetBGCOLORREF(24);
    	if (!window.Bitmap->StartScanLine()) goto fail;
  	  if (!window.Mask->StartScanLine()) goto fail;
    	if (!Image->Bitmap->StartScanLine()) goto fail;
  	  if (!MainImageForm->WorkArea->Mask->StartScanLine()) goto fail;
  	  if (MCItem==TMC_NONE) {
  			switch (FullViewForm->Super) {
      		case sOff:
          	StatusProgress->Maximum = window.size.y;
   					for (i=0; i<window.size.y; i++) {
  	        	StatusProgress->Position = i;
  	          WBP = window.Bitmap->GetScanLine(i);
    	        MP = window.Mask->GetScanLine(i);
      	      PP = Image->Bitmap->GetScanLine(window.s.y+i)+3*window.s.x;
        	    WP = MainImageForm->WorkArea->Mask->GetScanLine(i);
              *MP = 0; mm = 0x80;
   						for (j=0; j<window.size.x; j++, WBP+=3, PP+=3) {
          			if (*WP&mm) {
                	CopyPixel24(WBP, PP);
    	      		} else {
      	          SetPixel24(WBP, 0);
        	        *MP |= mm;
          			}
                if (mm==1) { MP++; WP++; *MP = 0; mm = 0x80; } else mm >>= 1;
   						}
    	        window.Bitmap->PutScanLine(i);
      	      window.Mask->PutScanLine(i);
   					}
          	StatusProgress->End();
        		break;
        	case sOverlap: case sNormal: case sGauze:
          	StatusProgress->Maximum = window.size.y;
   					for (i=0; i<window.size.y; i++) {
  	        	StatusProgress->Position = i;
  	          WBP = window.Bitmap->GetScanLine(i);
    	        MP = window.Mask->GetScanLine(i);
      	      PP = Image->Bitmap->GetScanLine(window.s.y+i)+3*window.s.x;
        	    WP = MainImageForm->WorkArea->Mask->GetScanLine(i);
              *MP = 0; mm = 0x80;
   						for (j=0; j<window.size.x; j++, WBP+=3, PP+=3) {
              	GetPixel24(PP, c);
          			if (*WP&mm && (c!=bgc)) {
                	CopyPixel24(WBP, PP);
    	      		} else {
      	          SetPixel24(WBP, 0);
        	        *MP |= mm;
          			}
                if (mm==1) { MP++; WP++; *MP = 0; mm = 0x80; } else mm >>= 1;
   						}
    	        window.Bitmap->PutScanLine(i);
      	      window.Mask->PutScanLine(i);
   					}
          	StatusProgress->End();
        		break;
    	  }
  	  } else if (MCItem==TMC_UPDOWN) {
  			switch (FullViewForm->Super) {
    	    case sOff:
          	StatusProgress->Maximum = window.size.y;
  					for (i=0; i<window.size.y; i++) {
  	        	StatusProgress->Position = i;
            	WBP = window.Bitmap->GetScanLine(i);
  	          MP = window.Mask->GetScanLine(i);
    	        PP = Image->Bitmap->GetScanLine(window.e.y-1-i)+3*window.s.x;
      	      WP = MainImageForm->WorkArea->Mask->GetScanLine(window.size.y-1-i);
              *MP = 0; mm = 0x80;
  						for (j=0; j<window.size.x; j++, WBP+=3, PP+=3) {
     						if (*WP&mm) {
              	  CopyPixel24(WBP, PP);
  	   					} else {
    	            SetPixel24(WBP, 0);
      	          *MP |= mm;
     						}
                if (mm==1) { MP++; WP++; *MP = 0; mm = 0x80; } else mm >>= 1;
  						}
  	          window.Bitmap->PutScanLine(i);
    	        window.Mask->PutScanLine(i);
  					}
          	StatusProgress->End();
        		break;
        	case sOverlap: case sNormal: case sGauze:
          	StatusProgress->Maximum = window.size.y;
  					for (i=0; i<window.size.y; i++) {
  	        	StatusProgress->Position = i;
            	WBP = window.Bitmap->GetScanLine(i);
  	          MP = window.Mask->GetScanLine(i);
    	        PP = Image->Bitmap->GetScanLine(window.e.y-1-i)+3*window.s.x;
      	      WP = MainImageForm->WorkArea->Mask->GetScanLine(window.size.y-1-i);
              *MP = 0; mm = 0x80;
  						for (j=0; j<window.size.x; j++, WBP+=3, PP+=3) {
                GetPixel24(PP, c);
     						if (*WP&mm && (c!=bgc)) {
              	  CopyPixel24(WBP, PP);
  	   					} else {
    	            SetPixel24(WBP, 0);
      	          *MP |= mm;
     						}
                if (mm==1) { MP++; WP++; *MP = 0; mm = 0x80; } else mm >>= 1;
  						}
  	          window.Bitmap->PutScanLine(i);
    	        window.Mask->PutScanLine(i);
  					}
          	StatusProgress->End();
        		break;
    		}
  	  } else if (MCItem==TMC_MIRROR) {
  			switch (FullViewForm->Super) {
      	  case sOff:
          	StatusProgress->Maximum = window.size.y;
   					for (i=0; i<window.size.y; i++) {
  	        	StatusProgress->Position = i;
  	          WBP = window.Bitmap->GetScanLine(i);
    	        MP = window.Mask->GetScanLine(i);
              *MP = 0; mm = 0x80;
      	      PP = Image->Bitmap->GetScanLine(window.s.y+i)+3*(window.e.x-1);
        	    WP = MainImageForm->WorkArea->Mask->GetScanLine(i)+((window.size.x-1)>>3);
              wm = 0x80>>((window.size.x-1)&7);
   						for (j=0; j<window.size.x; j++, WBP+=3, PP-=3) {
          			if (*WP&wm) {
                	CopyPixel24(WBP, PP);
    	      		} else {
      	          SetPixel24(WBP, 0);
        	        *MP |= mm;
          			}
                if (mm==1) { MP++; *MP = 0; mm = 0x80; } else mm >>= 1;
                if (wm==0x80) { WP--; wm = 1; } else wm <<= 1;
   						}
    	        window.Bitmap->PutScanLine(i);
      	      window.Mask->PutScanLine(i);
   					}
          	StatusProgress->End();
  					break;
        	case sOverlap: case sNormal: case sGauze:
          	StatusProgress->Maximum = window.size.y;
   					for (i=0; i<window.size.y; i++) {
  	        	StatusProgress->Position = i;
  	          WBP = window.Bitmap->GetScanLine(i);
    	        MP = window.Mask->GetScanLine(i);
              *MP = 0; mm = 0x80;
      	      PP = Image->Bitmap->GetScanLine(window.s.y+i)+3*(window.e.x-1);
        	    WP = MainImageForm->WorkArea->Mask->GetScanLine(i)+((window.size.x-1)>>3);
              wm = 0x80>>((window.size.x-1)&7);
   						for (j=0; j<window.size.x; j++, WBP+=3, PP-=3) {
                GetPixel24(PP, c);
          			if (*WP&wm && (c!=bgc)) {
                	CopyPixel24(WBP, PP);
    	      		} else {
      	          SetPixel24(WBP, 0);
        	        *MP |= mm;
          			}
                if (mm==1) { MP++; *MP = 0; mm = 0x80; } else mm >>= 1;
                if (wm==0x80) { WP--; wm = 1; } else wm <<= 1;
   						}
    	        window.Bitmap->PutScanLine(i);
      	      window.Mask->PutScanLine(i);
   					}
          	StatusProgress->End();
  					break;
    		}
  	  } else if (MCItem==TMC_UDMIRROR) {
  			switch (FullViewForm->Super) {
      	  case sOff:
          	StatusProgress->Maximum = window.size.y;
  					for (i=0; i<window.size.y; i++) {
  	        	StatusProgress->Position = i;
  	          WBP = window.Bitmap->GetScanLine(i);
    	        MP = window.Mask->GetScanLine(i);
              *MP = 0; mm = 0x80;
      	      PP = Image->Bitmap->GetScanLine(window.e.y-1-i)+3*(window.e.x-1);
        	    WP = MainImageForm->WorkArea->Mask->GetScanLine(window.size.y-1-i)+((window.size.x-1)>>3);
              wm = 0x80>>((window.size.x-1)&7);
  						for (j=0; j<window.size.x; j++, WBP+=3, PP-=3) {
     						if (*WP&wm) {
                	CopyPixel24(WBP, PP);
    	 					} else {
      	          SetPixel24(WBP, 0);
        	        *MP |= mm;
     						}
                if (mm==1) { MP++; *MP = 0; mm = 0x80; } else mm >>= 1;
                if (wm==0x80) { WP--; wm = 1; } else wm <<= 1;
  						}
    	        window.Bitmap->PutScanLine(i);
      	      window.Mask->PutScanLine(i);
  					}
          	StatusProgress->End();
       			break;
        	case sOverlap: case sNormal: case sGauze:
          	StatusProgress->Maximum = window.size.y;
  					for (i=0; i<window.size.y; i++) {
  	        	StatusProgress->Position = i;
  	          WBP = window.Bitmap->GetScanLine(i);
    	        MP = window.Mask->GetScanLine(i);
              *MP = 0; mm = 0x80;
      	      PP = Image->Bitmap->GetScanLine(window.e.y-1-i)+3*(window.e.x-1);
        	    WP = MainImageForm->WorkArea->Mask->GetScanLine(window.size.y-1-i)+((window.size.x-1)>>3);
              wm = 0x80>>((window.size.x-1)&7);
  						for (j=0; j<window.size.x; j++, WBP+=3, PP-=3) {
                GetPixel24(PP, c);
     						if (*WP&wm && (c!=bgc)) {
                	CopyPixel24(WBP, PP);
    	 					} else {
      	          SetPixel24(WBP, 0);
        	        *MP |= mm;
     						}
                if (mm==1) { MP++; *MP = 0; mm = 0x80; } else mm >>= 1;
                if (wm==0x80) { WP--; wm = 1; } else wm <<= 1;
  						}
    	        window.Bitmap->PutScanLine(i);
      	      window.Mask->PutScanLine(i);
  					}
          	StatusProgress->End();
       			break;
  	  	}
  	  }
    	window.Bitmap->StopScanLine();
  	  window.Mask->StopScanLine();
    	Image->Bitmap->StopScanLine();
  	  MainImageForm->WorkArea->Mask->StopScanLine();
    }
  }
  Screen->Cursor = OldCursor;
  return;
fail:
  Screen->Cursor = OldCursor;
 	window.Bitmap->StopScanLine();
  window.Mask->StopScanLine();
  MainImageForm->WorkArea->Mask->StopScanLine();
 	Image->Bitmap->StopScanLine();
  if (wmc) window.Mask->Destroy();
  if (wbc) window.Bitmap->Destroy();
  if (mbc) MoveCopyImage->Bitmap->Destroy();
  EXCEPTION_MESSAGE_OK(EC_MEMORY_LACK);
}
//---------------------------------------------------------------------------
void __fastcall TMoveCopyForm::MoveCopyMouseDown(int X, int Y)
{
  TCursor OldCursor;
  TPItemImage *Image = MainImageForm->iMainImage;
  TPSelectImage *MoveCopyImage = MainImageForm->iSelectImage;

 	OldCursor = Screen->Cursor;
 	Screen->Cursor = crHourGlass;
  if(MCItem == TMC_ROTATE || MCItem == TMC_BEND) {
   	X = X-MoveCopyImage->Bitmap->Width/2.0;
	  Y = Y-MoveCopyImage->Bitmap->Height/2.0;
  } else {
    if (MousePointPlace == 2) {
      X = X-MoveCopyImage->Bitmap->Width;
    } else if (MousePointPlace == 3) {
	    Y = Y-MoveCopyImage->Bitmap->Height;
    } else if (MousePointPlace == 4) {
      X = X-MoveCopyImage->Bitmap->Width;
	    Y = Y-MoveCopyImage->Bitmap->Height;
    } else if (MousePointPlace == 5) {
      X = X-MoveCopyImage->Bitmap->Width/2.0;
      Y = Y-MoveCopyImage->Bitmap->Height/2.0;
    }
  }
  
	if (X<0) X = 0;
	else if (X>Image->Bitmap->Width-MoveCopyImage->Bitmap->Width)
 		X = Image->Bitmap->Width-MoveCopyImage->Bitmap->Width;
	if (Y<0) Y = 0;
	else if (Y>Image->Bitmap->Height-MoveCopyImage->Bitmap->Height)
 		Y = Image->Bitmap->Height-MoveCopyImage->Bitmap->Height;

 	switch (MCItem) {
   	case TMC_ROTATE: RotateMouseDown(X, Y); break;
   	case TMC_BEND: BendMouseDown(X, Y); break;
 		default:
			if (SymmertyMouseDown(X, Y) && MCState==TMC_MOVE) {
        if (MainImageForm->WorkArea->IsRect(Image->Bitmap) == 1) {
		   	  MainImageForm->WorkArea->Move(MoveCopyRect.s.x - MainImageForm->WorkArea->Range.left,
   				  MoveCopyRect.s.y - MainImageForm->WorkArea->Range.top);
        } else {
          MainImageForm->WorkArea->Reset();
        }
        MainImageForm->WorkAreaChange();
				PostMessage(hWnd, TPM_EXITFUNCTION, 0, 0);
			}
 	}
 	Screen->Cursor = OldCursor;
}
//---------------------------------------------------------------------------
void __fastcall TMoveCopyForm::MoveCopyMouseMove(int X, int Y)
{
  TPItemImage *Image = MainImageForm->iMainImage;
  TPSelectImage *MoveCopyImage = MainImageForm->iSelectImage;

  if(MCItem == TMC_ROTATE || MCItem == TMC_BEND) {
   	X = X-MoveCopyImage->Bitmap->Width/2.0;
	  Y = Y-MoveCopyImage->Bitmap->Height/2.0;
  } else {
    if (MousePointPlace == 2) {
      X = X-MoveCopyImage->Bitmap->Width;
    } else if (MousePointPlace == 3) {
	    Y = Y-MoveCopyImage->Bitmap->Height;
    } else if (MousePointPlace == 4) {
      X = X-MoveCopyImage->Bitmap->Width;
	    Y = Y-MoveCopyImage->Bitmap->Height;
    } else if (MousePointPlace == 5) {
      X = X-MoveCopyImage->Bitmap->Width/2.0;
      Y = Y-MoveCopyImage->Bitmap->Height/2.0;
    }
  }
  if (Image->Bitmap->Width>=MoveCopyImage->Bitmap->Width) {
 	  if (X<0) X = 0;
    else if (X>Image->Bitmap->Width-MoveCopyImage->Bitmap->Width)
      X = Image->Bitmap->Width-MoveCopyImage->Bitmap->Width;
  }
  if (Image->Bitmap->Height>=MoveCopyImage->Bitmap->Height) {
 	  if (Y<0) Y = 0;
    if (Y>Image->Bitmap->Height-MoveCopyImage->Bitmap->Height)
      Y = Image->Bitmap->Height-MoveCopyImage->Bitmap->Height;
  }
  switch (MCItem) {
    case TMC_ROTATE: RotateMouseMove(X, Y); break;
    case TMC_BEND: BendMouseMove(X+MoveCopyImage->Bitmap->Width/2.0,
    	Y+MoveCopyImage->Bitmap->Height/2.0); break;
    default: SymmertyMouseMove(X, Y); break;
  }
}
//---------------------------------------------------------------------------
void __fastcall TMoveCopyForm::MoveCopyImageMouseDown(int X, int Y)
{
  TCursor OldCursor;
  TPItemImage *Image = MainImageForm->iMainImage;
  TPSelectImage *MoveCopyImage = MainImageForm->iSelectImage;

 	OldCursor = Screen->Cursor;
 	Screen->Cursor = crHourGlass;
  if(MCItem == TMC_ROTATE || MCItem == TMC_BEND) {
   	X = Image->CanvasToBitmapX(MoveCopyImage->Left+X)-MoveCopyImage->Bitmap->Width/2.0;
  	Y = Image->CanvasToBitmapY(MoveCopyImage->Top+Y)-MoveCopyImage->Bitmap->Height/2.0;
  } else {
    switch(MousePointPlace) {
      case 1:                                                  //Left-Top
       	X = Image->CanvasToBitmapX(MoveCopyImage->Left+X);
      	Y = Image->CanvasToBitmapY(MoveCopyImage->Top+Y);
        break;
      case 2:                                                  //Right-Top
       	X = Image->CanvasToBitmapX(MoveCopyImage->Left+X)-MoveCopyImage->Bitmap->Width;
      	Y = Image->CanvasToBitmapY(MoveCopyImage->Top+Y);
        break;
      case 3:                                                  //Left_Bottom
       	X = Image->CanvasToBitmapX(MoveCopyImage->Left+X);
      	Y = Image->CanvasToBitmapY(MoveCopyImage->Top+Y)-MoveCopyImage->Bitmap->Height;
        break;
      case 4:                                                  //Right-Bottom
       	X = Image->CanvasToBitmapX(MoveCopyImage->Left+X)-MoveCopyImage->Bitmap->Width;
      	Y = Image->CanvasToBitmapY(MoveCopyImage->Top+Y)-MoveCopyImage->Bitmap->Height;
        break;
      default:                                                 //Center
       	X = Image->CanvasToBitmapX(MoveCopyImage->Left+X)-MoveCopyImage->Bitmap->Width/2.0;
      	Y = Image->CanvasToBitmapY(MoveCopyImage->Top+Y)-MoveCopyImage->Bitmap->Height/2.0;
        break;
    }
  }
  if (Image->Bitmap->Width>=MoveCopyImage->Bitmap->Width) {
 	  if (X<0) X = 0;
	  else if (X>Image->Bitmap->Width-MoveCopyImage->Bitmap->Width)
 		  X = Image->Bitmap->Width-MoveCopyImage->Bitmap->Width;
  }
  if (Image->Bitmap->Height>=MoveCopyImage->Bitmap->Height) {
  	if (Y<0) Y = 0;
	  else if (Y>Image->Bitmap->Height-MoveCopyImage->Bitmap->Height)
 		  Y = Image->Bitmap->Height-MoveCopyImage->Bitmap->Height;
  }
 	switch (MCItem) {
   	case TMC_ROTATE:
		  if (tate==1) {
		    if (SymmertyMouseDown(X, Y) && MCState==TMC_MOVE) {
          MainImageForm->WorkAreaReset();
				  PostMessage(hWnd, TPM_EXITFUNCTION, 0, 0);
		    }
		  }
      break;
   	case TMC_BEND:
		  if (step==1) {
		    if (SymmertyMouseDown(X, Y) && MCState==TMC_MOVE) {
          MainImageForm->WorkAreaReset();
				  PostMessage(hWnd, TPM_EXITFUNCTION, 0, 0);
		    }
		  }
      break;
 		default:
			if (SymmertyMouseDown(X, Y) && MCState==TMC_MOVE) {
        if (MainImageForm->WorkArea->IsRect(Image->Bitmap) == 1) {
		   	  MainImageForm->WorkArea->Move(MoveCopyRect.s.x - MainImageForm->WorkArea->Range.left,
   				  MoveCopyRect.s.y - MainImageForm->WorkArea->Range.top);
        } else {
          MainImageForm->WorkArea->Reset();
        }
        MainImageForm->WorkAreaChange();
			  PostMessage(hWnd, TPM_EXITFUNCTION, 0, 0);
			}
      break;
 	}
 	Screen->Cursor = OldCursor;
}
//---------------------------------------------------------------------------
void __fastcall TMoveCopyForm::MoveCopyImageMouseMove(int X, int Y)
{
  TPItemImage *Image = MainImageForm->iMainImage;
  TPSelectImage *MoveCopyImage = MainImageForm->iSelectImage;

  if(MCItem == TMC_ROTATE || MCItem == TMC_BEND) {
   	X = Image->CanvasToBitmapX(MoveCopyImage->Left+X)-MoveCopyImage->Bitmap->Width/2.0;
  	Y = Image->CanvasToBitmapY(MoveCopyImage->Top+Y)-MoveCopyImage->Bitmap->Height/2.0;
  } else {
    switch(MousePointPlace) {
      case 1:                                                  //Left-Top
       	X = Image->CanvasToBitmapX(MoveCopyImage->Left+X);
      	Y = Image->CanvasToBitmapY(MoveCopyImage->Top+Y);
        break;
      case 2:                                                  //Right-Top
       	X = Image->CanvasToBitmapX(MoveCopyImage->Left+X)-MoveCopyImage->Bitmap->Width;
      	Y = Image->CanvasToBitmapY(MoveCopyImage->Top+Y);
        break;
      case 3:                                                  //Left_Bottom
       	X = Image->CanvasToBitmapX(MoveCopyImage->Left+X);
      	Y = Image->CanvasToBitmapY(MoveCopyImage->Top+Y)-MoveCopyImage->Bitmap->Height;
        break;
      case 4:                                                  //Right-Bottom
       	X = Image->CanvasToBitmapX(MoveCopyImage->Left+X)-MoveCopyImage->Bitmap->Width;
      	Y = Image->CanvasToBitmapY(MoveCopyImage->Top+Y)-MoveCopyImage->Bitmap->Height;
        break;
      default:                                                 //Center
       	X = Image->CanvasToBitmapX(MoveCopyImage->Left+X)-MoveCopyImage->Bitmap->Width/2.0;
      	Y = Image->CanvasToBitmapY(MoveCopyImage->Top+Y)-MoveCopyImage->Bitmap->Height/2.0;
        break;
    }
  }
  if (Image->Bitmap->Width>=MoveCopyImage->Bitmap->Width) {
 	  if (X<0) X = 0;
    else if (X>Image->Bitmap->Width-MoveCopyImage->Bitmap->Width)
      X = Image->Bitmap->Width-MoveCopyImage->Bitmap->Width;
  }
  if (Image->Bitmap->Height>=MoveCopyImage->Bitmap->Height) {
 	  if (Y<0) Y = 0;
    if (Y>Image->Bitmap->Height-MoveCopyImage->Bitmap->Height)
      Y = Image->Bitmap->Height-MoveCopyImage->Bitmap->Height;
  }
  switch (MCItem) {
    case TMC_ROTATE:
		  if (tate==1) SymmertyMouseMove(X, Y);
      break;
    case TMC_BEND:
		  if (step==1) SymmertyMouseMove(X, Y);
      break;
  	default: SymmertyMouseMove(X, Y); break;
  }
}
//---------------------------------------------------------------------------
void __fastcall TMoveCopyForm::iMainImageChange(void)
{
  TPSelectImage *MoveCopyImage = MainImageForm->iSelectImage;

  MoveCopyImage->Width  = 0;
  MoveCopyImage->Height = 0;
	if (IsDraw) IsDraw = false;
}
//---------------------------------------------------------------------------
void __fastcall TMoveCopyForm::mpImageMouseDown(TObject *Sender,
      TMouseButton Button, TShiftState Shift, int X, int Y)
{
  int w, h;
  w = mpImage->Width;
  h = mpImage->Height;

  if ((MCItem != TMC_ROTATE) && (MCItem != TMC_BEND)) {
    if((X>w/4 && X<=3*w/4) && (Y>h/4 && Y<= 3*h/4)) {              //Center
      MousePointPlace = 5;
    } else if((X>=0 && X<=w/2) && (Y>=0 && Y<=h/2)) {              //Left-Top
      MousePointPlace = 1;
    } else if((X>=w/2 && X<=w) && (Y>=0 && Y<=h/2)) {              //Right-Top
      MousePointPlace = 2;
    } else if((X>=0 && X<=w/2) && (Y>h/2 && Y<= h)) {              //Left-Bottom
      MousePointPlace = 3;
    } else if((X>w/2 && X<=w) && (Y>h/2 && Y<=h)) {                //Right-Bottom
      MousePointPlace = 4;
    }
    DrawMousePoint(MousePointPlace);
  }
}
//---------------------------------------------------------------------------
void __fastcall TMoveCopyForm::DrawMousePoint(int mousepoint)
{
  int width, height;
  TRect canvas;
  width = mpImage->Width;
  height = mpImage->Height;

  canvas = Rect(0,0,width,height);
  mpImage->Canvas->Brush->Color = clWhite;
  mpImage->Canvas->FillRect(canvas);
                                                            //Create New MouseMark
  mpImage->Canvas->Pen->Color = clBlack;
  mpImage->Canvas->Pen->Width = 3;
  mpImage->Canvas->Brush->Color = clWhite;
  switch(mousepoint) {
    case 1:
      mpImage->Canvas->Rectangle(3, 3, 13, 13);
      break;
    case 2:
      mpImage->Canvas->Rectangle(width-13, 3, width-3, 13);
      break;
    case 3:
      mpImage->Canvas->Rectangle(3, height-13, 13, height-3);
      break;
    case 4:
      mpImage->Canvas->Rectangle(width-13, height-13, width-3, height-3);
      break;
    default:
      mpImage->Canvas->Rectangle(width/2-5, height/2-5, width/2+5, height/2+5);
      break;
  }
}
//---------------------------------------------------------------------------