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

#include "WorkArea.h"
#include "MainImage.h"
#include "Main.h"
#include "Window.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
//---------------------------------------------------------------------------
// Private Function
//---------------------------------------------------------------------------
void __fastcall TPWorkArea::ResetMask()
{
	if (Mask) { delete Mask; Mask = NULL; }
}
//---------------------------------------------------------------------------
void __fastcall TPWorkArea::RemoveUndo()
{
	HRGN *rgn;

	while (Undo->Count) {
  	rgn = (HRGN *)Undo->Last();
    DeleteObject(*rgn);
    Undo->Remove(rgn);
	  HeapFree(GetProcessHeap(), 0, rgn);
  }
}
//---------------------------------------------------------------------------
// Public Function
//---------------------------------------------------------------------------
__fastcall TPWorkArea::TPWorkArea(TTexpiaBitmap **tb)
	: TObject()
{
	Bitmap = tb;
  Undo = new TList;
  Mask = NULL;
}
//---------------------------------------------------------------------------
__fastcall TPWorkArea::~TPWorkArea()
{
  ResetMask();
  RemoveUndo();
  delete Undo;
}
//---------------------------------------------------------------------------
void __fastcall TPWorkArea::SaveToFile(pBITMAPHANDLE bh, AnsiString s){
  RGNXFORM XForm;
  HRGN hrgnSrc;
  XForm.uViewPerspective = TOP_LEFT;
  XForm.nXScalarNum = 1;
  XForm.nXScalarDen = 1;
  XForm.nYScalarNum = 1;
  XForm.nYScalarDen = 1;
  XForm.nXOffset = 0;
  XForm.nYOffset = 0;

  L_GetBitmapRgnHandle(bh, &XForm, &hrgnSrc);
  DWORD dwWrite;
  DWORD dwBytes = GetRegionData(hrgnSrc, 0, NULL);
  LPVOID buf = VirtualAlloc(NULL, dwBytes, MEM_COMMIT, PAGE_READWRITE);
  GetRegionData(hrgnSrc, dwBytes, (RGNDATA *)buf);

  HANDLE hFile = CreateFile(s.c_str(), GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
  WriteFile(hFile, &dwBytes, sizeof(int), &dwWrite, NULL);
  WriteFile(hFile, buf, dwBytes, &dwWrite, NULL);
  CloseHandle(hFile);

  VirtualFree(buf ,dwBytes ,MEM_DECOMMIT);
  DeleteObject(hrgnSrc);
}
//---------------------------------------------------------------------------
void __fastcall TPWorkArea::LoadFromFile(pBITMAPHANDLE bh, AnsiString s, bool offset)
{
  XFORM xForm;
	xForm.eM11 = 1.0F;
	xForm.eM12 = 0.0F;
	xForm.eM21 = 0.0F;
	xForm.eM22 = 1.0F;
	xForm.eDx = 0.0F;
	xForm.eDy = 0.0F;
  HRGN hrgnSrc;
  DWORD dwRead;
  DWORD dwBytes;

#ifdef TEXTILE
  if(!MainForm->WReopenMove || !WindowForm->rbAddition->Checked){
    if (L_BitmapHasRgn(bh)) L_FreeBitmapRgn(bh);
  }
#else
  if (L_BitmapHasRgn(bh)) L_FreeBitmapRgn(bh);
#endif
  HANDLE hFile = CreateFile(s.c_str(), GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
  ReadFile(hFile, &dwBytes, sizeof(int), &dwRead, NULL);
  LPVOID buf = VirtualAlloc(NULL, dwBytes, MEM_COMMIT, PAGE_READWRITE);
  ReadFile(hFile, buf, dwBytes, &dwRead, NULL);
  hrgnSrc = ExtCreateRegion(&xForm, dwBytes, (RGNDATA *)buf);
  if(offset==false) {
    RECT r;
    GetRgnBox(hrgnSrc,&r);
    OffsetRgn(hrgnSrc,-r.left,-r.top);
  }
  SetRegion(bh, hrgnSrc);
  DeleteObject(hrgnSrc);
  VirtualFree(buf ,dwBytes ,MEM_DECOMMIT);
  CloseHandle(hFile);

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

bool __fastcall TPWorkArea::SetMask(HRGN Region)
{
	HRGN rgn = NULL;
	RGBQUAD rgb[256];
  RECT r;
  HDC dc = NULL;

  ResetMask();
  if (Region) {
    bComplex = GetRegionData(Region, 0, NULL) > 4000;
		GetRgnBox(Region, &Range);
  	if ((rgn = CreateRectRgn(0, 0, 1, 1))==NULL) goto fail;
	  CombineRgn(rgn, Region, (HRGN)0, RGN_COPY);
  	OffsetRgn(rgn, -Range.left, -Range.top);
	  if ((Mask = new TTexpiaBitmap)==NULL) goto fail;
    if ((*Bitmap)->BitsPerPixel==8) {
	    for (int i=0; i<256; i++) {
  	    rgb[i].rgbReserved = 0;
			  rgb[i].rgbRed = rgb[i].rgbGreen = rgb[i].rgbBlue = i;
  	  }
  		if (!Mask->Create(Range.right-Range.left, Range.bottom-Range.top, 8, rgb)) goto fail;
    } else {
  		if (!Mask->Create(Range.right-Range.left, Range.bottom-Range.top, 1)) goto fail;
    }
		if ((dc = Mask->CreateDC())==NULL) goto fail;
	 	r = Rect(0, 0, Mask->Width, Mask->Height);
 		FillRect(dc, &r, GetStockObject(BLACK_BRUSH));
  	SelectObject(dc, GetStockObject(WHITE_BRUSH));
  	SelectObject(dc, GetStockObject(WHITE_PEN));
	  PaintRgn(dc, rgn);
    Mask->DeleteDC(dc);
  	DeleteObject(rgn);
	}
  return true;
fail:
	if (rgn) {
  	::doDestroy(Mask);
  	DeleteObject(rgn);
  }
	return false;
}
//---------------------------------------------------------------------------
bool __fastcall TPWorkArea::GetMask(TTexpiaBitmap *mask, int bpp)
{
	HRGN rgn;
	RGBQUAD rgb[256];
  RECT r;
  HDC dc;

  rgn = (*Bitmap)->GetRegion();
  if (rgn) {
		OffsetRgn(rgn, -Range.left, -Range.top);
	  if (bpp==8) {
  	  for (int i=0; i<256; i++) {
 	  	  rgb[i].rgbReserved = 0;
		  	rgb[i].rgbRed = rgb[i].rgbGreen = rgb[i].rgbBlue = i;
	 	  }
 			if (!mask->Create(Range.right-Range.left, Range.bottom-Range.top, 8, rgb)) goto fail;
	  } else {
 			if (!mask->Create(Range.right-Range.left, Range.bottom-Range.top, 1)) goto fail;
	  }
		if ((dc = mask->CreateDC())==NULL) goto fail;
	 	r = Rect(0, 0, mask->Width, mask->Height);
		FillRect(dc, &r, GetStockObject(BLACK_BRUSH));
	  SelectObject(dc, GetStockObject(WHITE_BRUSH));
		SelectObject(dc, GetStockObject(WHITE_PEN));
	  PaintRgn(dc, rgn);
		DeleteObject(rgn);
	  mask->DeleteDC(dc);
  }
  return true;
fail:
  return false;
}
//---------------------------------------------------------------------------
void __fastcall TPWorkArea::Reset(bool bUndo)
{
	BITMAPHANDLE *bh;

	bh = (*Bitmap)->Handle;
	if (bh) {
  	if (L_BitmapHasRgn(bh)) L_FreeBitmapRgn(bh);
  }
  SetMask(NULL);
  if (bUndo) RemoveUndo();
}
//---------------------------------------------------------------------------
void __fastcall TPWorkArea::SetRectangle(RECT rc)
{
	BITMAPHANDLE *bh;
  HRGN rgn;
  RGNXFORM XForm;

	bh = (*Bitmap)->Handle;
	if (bh) {
  	if (L_BitmapHasRgn(bh)) L_FreeBitmapRgn(bh);
  	XForm.uViewPerspective = TOP_LEFT;
		XForm.nXScalarNum = 1;
		XForm.nXScalarDen = 1;
		XForm.nYScalarNum = 1;
		XForm.nYScalarDen = 1;
		XForm.nXOffset = 0;
	 	XForm.nYOffset = 0;
	  L_SetBitmapRgnRect(bh, &XForm, &rc, L_RGN_SET);
    L_GetBitmapRgnHandle(bh, &XForm, &rgn);
	  SetMask(rgn);
    DeleteObject(rgn);
  } else {
	  SetMask(NULL);
  }
}
//---------------------------------------------------------------------------
void __fastcall TPWorkArea::Move(int X, int Y)
{
	BITMAPHANDLE *bh;

 	bh = (*Bitmap)->Handle;
	if (bh) {
  	L_OffsetBitmapRgn(bh, Y, X);
    Range.left += X;
    Range.top += Y;
    Range.right += X;
    Range.bottom += Y;
  }
}
//---------------------------------------------------------------------------
void __fastcall TPWorkArea::Transform(RECT r)
{
	BITMAPHANDLE *bh;
  HRGN rgn;
  RGNXFORM XForm;
  RECT rcRegion;

	bh = (*Bitmap)->Handle;
	if (bh) {
  	XForm.uViewPerspective = TOP_LEFT;
  	XForm.nXScalarNum = 1;
  	XForm.nXScalarDen = 1;
  	XForm.nYScalarNum = 1;
  	XForm.nYScalarDen = 1;
  	XForm.nXOffset = 0;
  	XForm.nYOffset = 0;
  	L_GetBitmapRgnBounds(bh, &XForm, &rcRegion);
  	XForm.nXOffset = -rcRegion.left;
  	XForm.nYOffset = -rcRegion.top;
  	L_GetBitmapRgnHandle(bh, &XForm, &rgn);
  	L_FreeBitmapRgn(bh);

  	XForm.nXScalarNum = r.right - r.left;
  	XForm.nXScalarDen = rcRegion.right - rcRegion.left;
  	XForm.nYScalarNum = r.bottom - r.top;
  	XForm.nYScalarDen = rcRegion.bottom - rcRegion.top;
  	XForm.nXOffset = 0;
  	XForm.nYOffset = 0;
  	L_SetBitmapRgnHandle(bh, &XForm, rgn, L_RGN_SET);
    DeleteObject(rgn);

  	XForm.nXScalarNum = 1;
  	XForm.nXScalarDen = 1;
  	XForm.nYScalarNum = 1;
  	XForm.nYScalarDen = 1;
  	L_GetBitmapRgnHandle(bh, &XForm, &rgn);
  	SetMask(rgn);
    DeleteObject(rgn);
    Move(r.left, r.top);
  }
}
//---------------------------------------------------------------------------
bool __fastcall TPWorkArea::PushUndo()
{
	BITMAPHANDLE *bh;
  HRGN *rgn = NULL;
  RGNXFORM XForm;

 	bh = (*Bitmap)->Handle;
 	if (bh) {
 		if (L_BitmapHasRgn(bh)) {
		  if ((rgn = (HRGN *)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
      	sizeof(HRGN)))==NULL) goto fail;
	  	XForm.uViewPerspective = TOP_LEFT;
  		XForm.nXScalarNum = 1;
  		XForm.nXScalarDen = 1;
	  	XForm.nYScalarNum = 1;
  		XForm.nYScalarDen = 1;
  		XForm.nXOffset = 0;
	  	XForm.nYOffset = 0;
  		L_GetBitmapRgnHandle(bh, &XForm, rgn);
		  Undo->Add(rgn);
      if (Undo->Count > undoMax) {
        rgn = (HRGN *)Undo->First();
        Undo->Remove(rgn);
        DeleteObject(*rgn);
        HeapFree(GetProcessHeap(), 0, rgn);
      }
 	  }
  }
  return true;
fail:
	if (rgn) HeapFree(GetProcessHeap(), 0, rgn);
  return false;
}
//---------------------------------------------------------------------------
void __fastcall TPWorkArea::PopUndo()
{
	BITMAPHANDLE *bh;
  HRGN *rgn;
  RGNXFORM XForm;

  if (Undo->Count>0) {
  	bh = (*Bitmap)->Handle;
  	if (bh) {
		  rgn = (HRGN *)Undo->Last();
	  	XForm.uViewPerspective = TOP_LEFT;
  		XForm.nXScalarNum = 1;
  		XForm.nXScalarDen = 1;
	  	XForm.nYScalarNum = 1;
  		XForm.nYScalarDen = 1;
  		XForm.nXOffset = 0;
	  	XForm.nYOffset = 0;
			L_SetBitmapRgnHandle(bh, &XForm, *rgn, L_RGN_SET);
		 	SetMask(*rgn);
  	  DeleteObject(*rgn);
	    Undo->Remove(rgn);
		  HeapFree(GetProcessHeap(), 0, rgn);
  	}
  }
}
//---------------------------------------------------------------------------
bool __fastcall TPWorkArea::StatusUndo()
{
	return Undo->Count>0;
}
//---------------------------------------------------------------------------
void __fastcall TPWorkArea::DrawShape(TPItemImage *Image, POINT First, POINT Second, bool bEllipse)
{
/*
  HDC formDC;
  HBRUSH hOldBrush;
  HPEN hOldPen;
  int nDrawMode; */
  POINT f, s;
  RECT rr;

/*  formDC = Image->Canvas->Handle;
  hOldBrush = SelectObject(formDC, GetStockObject(NULL_BRUSH));
  hOldPen = SelectObject(formDC, GetStockObject(WHITE_PEN));
  nDrawMode = GetROP2(formDC);
  SetROP2(formDC, R2_NOT); */
 	if (First.x>Second.x) {
   	f.x = Second.x;
   	s.x = First.x+1;
  } else {
   	f.x = First.x;
   	s.x = Second.x+1;
  }
 	if (First.y>Second.y) {
   	f.y = Second.y;
   	s.y = First.y+1;
  } else {
   	f.y = First.y;
   	s.y = Second.y+1;
  }
/*
  rr.left = Image->BitmapToCanvasX(f.x);
  rr.right = Image->BitmapToCanvasX(s.x);
  if (Image->Bitmap->CoordinateSystem==csTopLeft) {
		rr.top = Image->BitmapToCanvasY(f.y);
		rr.bottom = Image->BitmapToCanvasY(s.y);
  } else {
		rr.top = Image->BitmapToCanvasY(f.y)+1;
		rr.bottom = Image->BitmapToCanvasY(s.y)+1;
  }
  if (bEllipse) {
	  Ellipse(formDC, rr.left, rr.top, rr.right, rr.bottom);
  } else {
	  Rectangle(formDC, rr.left, rr.top, rr.right, rr.bottom);
  }*/

  if (Image->Bitmap->CoordinateSystem!=csTopLeft) {
    f.y++;
    s.y++;
  }
#ifndef dogtest
  if (bEllipse) {
	  MainImageForm->DrawEllipseLocate(Rect(f.x,f.y-1,s.x-1,s.y));
  } else {
	  MainImageForm->DrawRectangleLocate(Rect(f.x,f.y-1,s.x-1,s.y));
  }
#endif
/*
  SetROP2(formDC, nDrawMode);
  SelectObject(formDC, hOldBrush);
  SelectObject(formDC, hOldPen);*/
}
//---------------------------------------------------------------------------
void __fastcall TPWorkArea::SetShapeRegion(TPItemImage *Image, POINT First, POINT Second, bool bEllipse)
{
    pBITMAPHANDLE bh;
  RGNXFORM XForm;
  HRGN rgnDst;
  RECT rc;

	bh = Image->Bitmap->Handle;
  XForm.uViewPerspective = TOP_LEFT;
  XForm.nXScalarNum = 1;
  XForm.nXScalarDen = 1;
  XForm.nYScalarNum = 1;
  XForm.nYScalarDen = 1;
  XForm.nXOffset = 0;
  XForm.nYOffset = 0;
 	if (First.x>Second.x) {
   	rc.left = Second.x;
   	rc.right = First.x+1;
  } else {
   	rc.left = First.x;
   	rc.right = Second.x+1;
  }
 	if (First.y>Second.y) {
   	rc.top = Second.y;
   	rc.bottom = First.y+1;
  } else {
   	rc.top = First.y;
   	rc.bottom = Second.y+1;
  }
  if (bEllipse) {
		L_SetBitmapRgnEllipse(bh, &XForm, &rc, L_RGN_SET);
  } else {
	  L_SetBitmapRgnRect(bh, &XForm, &rc, L_RGN_SET);
  }
  L_GetBitmapRgnHandle(bh, &XForm, &rgnDst);
	SetMask(rgnDst);
	DeleteObject(rgnDst);
}
//---------------------------------------------------------------------------
void __fastcall TPWorkArea::SetShapeRegion(TTexpiaBitmap *Bmp, POINT First, POINT Second)
{
	pBITMAPHANDLE bh;
  RGNXFORM XForm;
  HRGN rgnDst;
  RECT rc;

	bh = Bmp->Handle;
  XForm.uViewPerspective = TOP_LEFT;
  XForm.nXScalarNum = 1;
  XForm.nXScalarDen = 1;
  XForm.nYScalarNum = 1;
  XForm.nYScalarDen = 1;
  XForm.nXOffset = 0;
  XForm.nYOffset = 0;
 	if (First.x>Second.x) {
   	rc.left = Second.x;
   	rc.right = First.x+1;
  } else {
   	rc.left = First.x;
   	rc.right = Second.x+1;
  }
 	if (First.y>Second.y) {
   	rc.top = Second.y;
   	rc.bottom = First.y+1;
  } else {
   	rc.top = First.y;
   	rc.bottom = Second.y+1;
  }
	L_SetBitmapRgnRect(bh, &XForm, &rc, L_RGN_SET);
  L_GetBitmapRgnHandle(bh, &XForm, &rgnDst);
	SetMask(rgnDst);
	DeleteObject(rgnDst);
}
//---------------------------------------------------------------------------
void __fastcall TPWorkArea::SetRegion(HRGN rgn)
{
  RGNXFORM XForm;

 	XForm.uViewPerspective = TOP_LEFT;
	XForm.nXScalarNum = 1;
  XForm.nXScalarDen = 1;
	XForm.nYScalarNum = 1;
	XForm.nYScalarDen = 1;
  XForm.nXOffset = 0;
	XForm.nYOffset = 0;
	L_SetBitmapRgnHandle((*Bitmap)->Handle, &XForm, rgn, L_RGN_SET);
 	SetMask(rgn);
}
//---------------------------------------------------------------------------
void __fastcall TPWorkArea::SetRegion(pBITMAPHANDLE bh, HRGN rgn)
{
  RGNXFORM XForm;

 	XForm.uViewPerspective = TOP_LEFT;
	XForm.nXScalarNum = 1;
  XForm.nXScalarDen = 1;
	XForm.nYScalarNum = 1;
	XForm.nYScalarDen = 1;
  XForm.nXOffset = 0;
	XForm.nYOffset = 0;
#ifdef TEXTILE
  if(MainImageForm->WATEMP){
  	L_SetBitmapRgnHandle(bh, &XForm, rgn, L_RGN_OR);
  }else{
	  L_SetBitmapRgnHandle(bh, &XForm, rgn, L_RGN_SET);
  }
#else
	L_SetBitmapRgnHandle(bh, &XForm, rgn, L_RGN_SET);
#endif
  if(bh == (*Bitmap)->Handle) SetMask(rgn);
}
//---------------------------------------------------------------------------
void __fastcall TPWorkArea::ResetRegion(TPItemImage *Image, HRGN *rgn)
{
	pBITMAPHANDLE bh;
  RGNXFORM XForm;
  RECT rc;

	bh = (*Bitmap)->Handle;
	if (L_BitmapHasRgn(bh)) {
    XForm.uViewPerspective = TOP_LEFT;
    XForm.nXScalarNum = 1;
    XForm.nXScalarDen = 1;
    XForm.nYScalarNum = 1;
    XForm.nYScalarDen = 1;
    XForm.nXOffset = 0;
    XForm.nYOffset = 0;
    if (rgn) L_GetBitmapRgnHandle(bh, &XForm, rgn);
    L_GetBitmapRgnBounds(bh, &XForm, &rc);
    L_FreeBitmapRgn(bh);
    SetMask(NULL);
    InvalidateRect(Image->Parent->Handle, &rc, false);
  }
}
//---------------------------------------------------------------------------
int __fastcall TPWorkArea::IsRect(TTexpiaBitmap *tb)
{
	BITMAPHANDLE *bh;
  HRGN rgn, rgn1 = NULL;
  RGNXFORM XForm;
  int v = -1;
  bool rectSw;

	bh = tb->Handle;
 	if (bh) {
  	if (L_BitmapHasRgn(bh)) {
  	  XForm.uViewPerspective = TOP_LEFT;
		  XForm.nXScalarNum = 1;
		  XForm.nXScalarDen = 1;
		  XForm.nYScalarNum = 1;
		  XForm.nYScalarDen = 1;
		  XForm.nXOffset = 0;
	 	  XForm.nYOffset = 0;
      L_GetBitmapRgnHandle(bh, &XForm, &rgn);
      rgn1 = CreateRectRgn(Range.left, Range.top, Range.right, Range.bottom);
      if (rgn1) {
        rectSw = EqualRgn(rgn, rgn1);
        v = rectSw ? 1 : 0;
        DeleteObject(rgn1);
      }
      DeleteObject(rgn);
    }
  }
  return v;
}
//---------------------------------------------------------------------------

void __fastcall TPWorkArea::SwapUndo()
{
	BITMAPHANDLE *bh;
  HRGN *rgn = NULL, *rgn1 = NULL;
  RGNXFORM XForm;

 	bh = (*Bitmap)->Handle;
 	if (bh) {
 		if (L_BitmapHasRgn(bh)) {
		  if ((rgn = (HRGN *)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
      	sizeof(HRGN)))==NULL) goto fail;
	  	XForm.uViewPerspective = TOP_LEFT;
  		XForm.nXScalarNum = 1;
  		XForm.nXScalarDen = 1;
	  	XForm.nYScalarNum = 1;
  		XForm.nYScalarDen = 1;
  		XForm.nXOffset = 0;
	  	XForm.nYOffset = 0;
  		L_GetBitmapRgnHandle(bh, &XForm, rgn);
//---------------------------------------------------------------------------
      if (Undo->Count>0) {
        rgn1 = (HRGN *)Undo->Last();
			  L_SetBitmapRgnHandle(bh, &XForm, *rgn1, L_RGN_SET);
		    SetMask(*rgn1);
        DeleteObject(*rgn1);
        Undo->Remove(rgn1);
        HeapFree(GetProcessHeap(), 0, rgn1);
      }
//---------------------------------------------------------------------------
		  Undo->Add(rgn);
 	  }
  }
  return;
fail:
	if (rgn) HeapFree(GetProcessHeap(), 0, rgn);
}
//---------------------------------------------------------------------------

void __fastcall TPWorkArea::CopyRGN(TTexpiaBitmap *srcBmp, TTexpiaBitmap *dstBmp, int k)
{
  BITMAPHANDLE *srcbh, *dstbh;
  HRGN rgn;
  RGNXFORM ToXForm, FromXForm;

  srcbh = srcBmp->Handle;
  dstbh = dstBmp->Handle;
  if (srcbh && dstbh) {
    if (L_BitmapHasRgn(dstbh)) L_FreeBitmapRgn(dstbh);
    if (L_BitmapHasRgn(srcbh)) {
      FromXForm.uViewPerspective = TOP_LEFT;
      FromXForm.nXScalarNum = 1;
      FromXForm.nXScalarDen = 1;
      FromXForm.nYScalarNum = 1;
      FromXForm.nYScalarDen = 1;
      FromXForm.nXOffset = 0;
  	  FromXForm.nYOffset = 0;

      ToXForm.uViewPerspective = TOP_LEFT;
      ToXForm.nXScalarNum = 1;
      ToXForm.nXScalarDen = 1;
      ToXForm.nYScalarNum = 1;
      ToXForm.nYScalarDen = 1;
      ToXForm.nXOffset = k * Range.left;
  	  ToXForm.nYOffset = k * Range.top;
      k = L_GetBitmapRgnHandle(srcbh, &FromXForm, &rgn);
      k = L_SetBitmapRgnHandle(dstbh, &ToXForm, rgn, L_RGN_SET);
      DeleteObject(rgn);
    }
  }
}
//---------------------------------------------------------------------------

void __fastcall TPWorkArea::TransformRGN(int x, int y, int kind)
{
  HRGN rgn;
  TTexpiaBitmap *temp;

  temp = new TTexpiaBitmap;
  temp->Create(Range.right - Range.left, Range.bottom - Range.top, 1);
  CopyRGN((*Bitmap), temp, -1);
  switch (kind) {
    case 1: L_FlipBitmap(temp->Handle); break;
    case 2: L_ReverseBitmap(temp->Handle); break;
    case 3:
      L_ReverseBitmap(temp->Handle);
      L_FlipBitmap(temp->Handle);
  }
  CopyRGN(temp, (*Bitmap), 1);
  delete temp;

  rgn = (*Bitmap)->GetRegion();
  SetMask(rgn);
  DeleteObject(rgn);
  Move(x, y);
}
//---------------------------------------------------------------------------

void __fastcall TPWorkArea::InvertRegion()
{
	BITMAPHANDLE *bh;
  HRGN rgn;
  RGNXFORM XForm;

	bh = (*Bitmap)->Handle;
	if (bh) {
    rgn = (*Bitmap)->GetRegion();
  	if (L_BitmapHasRgn(bh)) L_FreeBitmapRgn(bh);
  	XForm.uViewPerspective = TOP_LEFT;
		XForm.nXScalarNum = 1;
		XForm.nXScalarDen = 1;
		XForm.nYScalarNum = 1;
		XForm.nYScalarDen = 1;
		XForm.nXOffset = 0;
	 	XForm.nYOffset = 0;
  	L_SetBitmapRgnHandle(bh, &XForm, rgn, L_RGN_SETNOT);
    DeleteObject(rgn);
    L_GetBitmapRgnHandle(bh, &XForm, &rgn);
	  SetMask(rgn);
    DeleteObject(rgn);
  }
}
//---------------------------------------------------------------------------
bool __fastcall MergeRegion(HRGN &hRgn, int left, int top, int right, int bottom)
{
  HRGN hTempRgn = NULL;

  if (hRgn) {
    if ((hTempRgn = CreateRectRgn(left, top, right, bottom)) == NULL) goto fail;
    if (CombineRgn(hRgn, hRgn, hTempRgn, RGN_OR) == ERROR) goto fail;
    DeleteObject(hTempRgn); hTempRgn = NULL;
  } else {
    if ((hRgn = CreateRectRgn(left, top, right, bottom)) == NULL) goto fail;
  }
  return true;
fail:
  if (hTempRgn) DeleteObject(hTempRgn);
  return false;
}
//---------------------------------------------------------------------------

void __fastcall TPWorkArea::IrregularRegion (TTexpiaBitmap *SubMask, RECT rc)
{
  Byte *wam, *tma, *ssl, mm, nn;        // ±×¸²ÀÇ ÇüÅ¿¡ µû¶ó ÀÛ¾÷±¸¿ªÀÌ »ý±âµµ·Ï
  TTexpiaBitmap *TempMask;              // ¸¸µé¾îÁÖ´Â ºÎºÐÀÔ´Ï´Ù  - By GreenFish
  RGBQUAD Maskrgb[256];
  RGNXFORM XForm;
  HRGN rgnSrc, rgnDst;
  TPItemImage *Image = MainImageForm->iMainImage;
  int x, y;
  HRGN rgn;

  XForm.uViewPerspective = TOP_LEFT;
  XForm.nXScalarNum = 1;
  XForm.nXScalarDen = 1;
  XForm.nYScalarNum = 1;
  XForm.nYScalarDen = 1;
  XForm.nXOffset = 0;
  XForm.nYOffset = 0;

  if (Image->SubBitmap->BitsPerPixel==8) {
    TempMask = new TTexpiaBitmap;
    Image->Bitmap->GetColors(0, 256, Maskrgb);
    TempMask->Create(Image->Bitmap->Width, Image->Bitmap->Height, 8, Maskrgb);

    Image->SubMask->StartScanLine();
    TempMask->StartScanLine();
//    WorkArea->Mask->StartScanLine();

		for (y = rc.top ; y < rc.bottom; y++) {
      ssl = Image->SubMask->GetScanLine(y-rc.top);
      tma = TempMask->GetScanLine(y);
//      wam = WorkArea->Mask->GetScanLine(y-rc.top);

  	  for (x = rc.left; x < rc.right; x++, ssl++){
      //, wam++) {
        if (*ssl) {  *(tma+x) = 0;// *wam = 0;
        }
        else { *(tma+x) = 0xFF; //*wam = 0xFF;
        }
      }
      TempMask->PutScanLine(y);
//      WorkArea->Mask->PutScanLine(y-rc.top);
    }

    Image->SubMask->StopScanLine();
    TempMask->StopScanLine();
//    WorkArea->Mask->StopScanLine();

  }else {          // Full Color
    TempMask = new TTexpiaBitmap;
    TempMask->Create(Image->Bitmap->Width, Image->Bitmap->Height, 1);

    Image->SubMask->StartScanLine();
    TempMask->StartScanLine();
//    WorkArea->Mask->StartScanLine();

		for (y = rc.top ; y < rc.bottom; y++) {
      ssl = Image->SubMask->GetScanLine(y-rc.top);
      tma = TempMask->GetScanLine(y);
//      wam = WorkArea->Mask->GetScanLine(y-rc.top);

      mm = nn = 0x80;
      tma += rc.left / 8;
      nn >>= rc.left % 8;

  	  for (x = 0; x < rc.right-rc.left; x++//, wam++
      ) {
    	  if ((ssl[x >> 3] & (0x80 >> (x & 7))) == 0) {
//          *wam |= mm;
          *tma |= nn;

        }else {
        }

//        if (mm == 1) { wam++; *wam = 0; mm = 0x80; } else mm >>= 1;
        if (nn == 1) { tma++; *tma = 0; nn = 0x80; } else nn >>= 1;
      }
      TempMask->PutScanLine(y);
//      WorkArea->Mask->PutScanLine(y-rc.top);
    }
    Image->SubMask->StopScanLine();
    TempMask->StopScanLine();
//    WorkArea->Mask->StopScanLine();
  }
#ifdef TEXTILE
  if(MainForm->WReopenMove && WindowForm->rbAddition->Checked){
    L_SetBitmapRgnFromMask (Image->Bitmap->Handle, &XForm, TempMask->Handle, L_RGN_OR);
  }else{
    L_SetBitmapRgnFromMask (Image->Bitmap->Handle, &XForm, TempMask->Handle, L_RGN_SET);
  }
#else
  L_SetBitmapRgnFromMask (Image->Bitmap->Handle, &XForm, TempMask->Handle, L_RGN_SET);
#endif
  L_GetBitmapRgnHandle (Image->Bitmap->Handle, &XForm, &rgn);
	SetMask(rgn);
	DeleteObject(rgn);
  delete TempMask;
}
//---------------------------------------------------------------------------
void __fastcall TPWorkArea::ChangeBitmap(TTexpiaBitmap **Bm)
{
#ifdef KNIT
  Bitmap = Bm;
#endif
}
//---------------------------------------------------------------------------