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

#include "Shadow_F.h"
#include "MainImage.h"
#include "Palette.h"
#include "Undo.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
//---------------------------------------------------------------------------
#define IDS_SHADOWCOLOR   StringTable[0]
#define IDS_ANGLE         StringTable[1]
#define IDS_DISTANCE      StringTable[2]
#define IDS_APPLYSHADOW   StringTable[3]

TShadowForm *ShadowForm;
//---------------------------------------------------------------------------
__fastcall TShadowForm::TShadowForm(TComponent* Owner)
  : TForm(Owner)
{
	hWnd = ((TWinControl *)Owner)->Handle;

  StringTable.Create(DirectoryItem, Language, "Shadow_F");
  SetSmallFont(Font);

  lbColor->Caption   = IDS_SHADOWCOLOR;
  ImgAngle->Hint     = IDS_ANGLE;
  ImgDistance->Hint  = IDS_DISTANCE;
  sbApply->Caption   = IDS_APPLYSHADOW;

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

void __fastcall TShadowForm::FormCreate(TObject *Sender)
{
  //
}
//---------------------------------------------------------------------------
void __fastcall TShadowForm::sbAngleScroll(TObject *Sender,
      TScrollCode ScrollCode, int &ScrollPos)
{
  lbAngle->Caption = IntToStr(ScrollPos);
  ShowShadow();
}
//---------------------------------------------------------------------------

void __fastcall TShadowForm::sbDistanceScroll(TObject *Sender,
      TScrollCode ScrollCode, int &ScrollPos)
{
  lbDistance->Caption = IntToStr(ScrollPos);
  ShowShadow();
}
//---------------------------------------------------------------------------

void __fastcall TShadowForm::sbApplyClick(TObject *Sender)
{
  THistoryData *ud = MainImageForm->Undo->GetLast();
  RECT undorange = ud->getRectRange();

  undosave = true;
  MainImageForm->UndoSave(UK_PATTERN, undorange);
  PostMessage(hWnd, TPM_EXITFUNCTION, 0, 0);
}
//---------------------------------------------------------------------------
//Private Method
//---------------------------------------------------------------------------

void __fastcall TShadowForm::MakeShadow()
{
//*
  Byte *LP, *MP, *PP, mm;
  int x, y;
  COLORREF bgcolor, shadowcolor;
//  THistoryData *ud = MainImageForm->Undo->GetLastPatternUd();
  THistoryData *ud = MainImageForm->Undo->GetLast();

//  RECT r = ud->Range;
  RECT rect = ud->getRectRange();

  shadowcolor = color;

//  if (ud->LayerMask->StartScanLine() == false) goto fail;

	if (!ud->LayerMask)return;

  ud->LayerMask->PartialUndo->LoadLast(ud->FromRgb);
  if (ud->LayerMask->StartUndoScanLine() == false) goto fail;

  if (TempBitmap->StartScanLine() == false) goto fail;
  if (TempMask->StartScanLine() == false) goto fail;
  if (TempBitmap->BitsPerPixel == 8) {
    bgcolor = PaletteForm->DIB256Palette->GetBGCOLORREF(8);
    for (y = range.top; y < range.bottom; y++) {
      //LP = ud->LayerMask->GetScanLine(y - r.top);
//      ud->LayerMask->UndoCheckActivePart(y, range.left, range.right-range.left);   // by linuxjun
      LP = ud->LayerMask->GetUndoScanLine(y, range.left, range.right-range.left);
      PP = TempBitmap->GetScanLine(y - range.top);
      MP = TempMask->GetScanLine(y - range.top);
      for (x = range.left; x < range.right; x++, PP++, MP++) {
        //if (LP[x - r.left]) {
        if (LP[x]) {
          *PP = 0; *MP = 0xFF;
        } else {
          *PP = shadowcolor; *MP = 0;
        }
      }
      TempMask->PutScanLine(y - range.top);
      TempBitmap->PutScanLine(y - range.top);
    }
  } else {
//    bgcolor = PaletteForm->DIB256Palette->GetBGCOLORREF(24);
    bgcolor = 0;
    for (y = range.top; y < range.bottom; y++) {
      //LP = ud->LayerMask->GetScanLine(y - r.top);
//      ud->LayerMask->UndoCheckActivePart(y, range.left, range.right-range.left);   // by linuxjun
      LP = ud->LayerMask->GetUndoScanLine(y, rect.left, rect.right-rect.left);
      PP = TempBitmap->GetScanLine(y - range.top);
      MP = TempMask->GetScanLine(y - range.top);
      *MP = 0; mm = 0x80;
      x = range.left;
      while(1) {
        //if (LP[(x - r.left) >> 3] & (0x80 >> ((x - r.left) & 7))) {
        if (LP[(x) >> 3]  &  (0x80 >> ((x) & 7))) {
          SetPixel24(PP, bgcolor);
          *MP |= mm;
        } else {
          SetPixel24(PP, shadowcolor);
        }
        x++;
        if (x >= range.right) break;
        PP += 3;
        if (mm == 1) { MP++; *MP = 0; mm = 0x80; } else mm >>= 1;
      }
       TempMask->PutScanLine(y - range.top);
      TempBitmap->PutScanLine(y - range.top);
    }
  }
  TempBitmap->StopScanLine();
  TempMask->StopScanLine();
  ud->LayerMask->StopUndoScanLine();
  return;
fail:
  TempBitmap->StopScanLine();
  TempMask->StopScanLine();
  ud->LayerMask->StopUndoScanLine();
  EXCEPTION_MESSAGE_OK(EC_MEMORY_LACK);

 // */
/*      //BeConverted by linuxjun Don't Forget!!   Undo_Method
  Byte *LP, *MP, *PP, mm;
  int x, y;
  COLORREF bgcolor, shadowcolor;
  THistoryData *ud = MainImageForm->Undo->GetLast();
  RECT r = ud->Range;

  shadowcolor = color;

  if (ud->LayerMask->StartScanLine() == false) goto fail;
  if (TempBitmap->StartScanLine() == false) goto fail;
  if (TempMask->StartScanLine() == false) goto fail;
  if (TempBitmap->BitsPerPixel == 8) {
    bgcolor = PaletteForm->DIB256Palette->GetBGCOLORREF(8);
    for (y = range.top; y < range.bottom; y++) {
      LP = ud->LayerMask->GetScanLine(y - r.top);
      PP = TempBitmap->GetScanLine(y - range.top);
      MP = TempMask->GetScanLine(y - range.top);
      for (x = range.left; x < range.right; x++, PP++, MP++) {
        if (LP[x - r.left]) {
          *PP = 0; *MP = 0xFF;
        } else {
          *PP = shadowcolor; *MP = 0;
        }
      }
      TempMask->PutScanLine(y - range.top);
      TempBitmap->PutScanLine(y - range.top);
    }
  } else {
//    bgcolor = PaletteForm->DIB256Palette->GetBGCOLORREF(24);
    bgcolor = 0;
    for (y = range.top; y < range.bottom; y++) {
      LP = ud->LayerMask->GetScanLine(y - r.top);
      PP = TempBitmap->GetScanLine(y - range.top);
      MP = TempMask->GetScanLine(y - range.top);
      *MP = 0; mm = 0x80;
      x = range.left;
      while(1) {
        if (LP[(x - r.left) >> 3] & (0x80 >> ((x - r.left) & 7))) {
          SetPixel24(PP, bgcolor);
          *MP |= mm;
        } else {
          SetPixel24(PP, shadowcolor);
        }
        x++;
        if (x >= range.right) break;
        PP += 3;
        if (mm == 1) { MP++; *MP = 0; mm = 0x80; } else mm >>= 1;
      }
      TempMask->PutScanLine(y - range.top);
      TempBitmap->PutScanLine(y - range.top);
    }
  }
  TempBitmap->StopScanLine();
  TempMask->StopScanLine();
  ud->LayerMask->StopScanLine();
  return;
fail:
  TempBitmap->StopScanLine();
  TempMask->StopScanLine();
  ud->LayerMask->StopScanLine();
  EXCEPTION_MESSAGE_OK(EC_MEMORY_LACK);
  */
}
//---------------------------------------------------------------------------

void __fastcall TShadowForm::CalculatePosition()
{
  double rad =  DegToRad((Extended) (360 - sbAngle->Position));
  int distance = sbDistance->Position;

  pos.x = range.left + distance * cos(rad);
  pos.y = range.top + distance * sin(rad);

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

void __fastcall TShadowForm::ShowShadow()
{

//  THistoryData *ud = MainImageForm->Undo->GetLastPatternUd();        //BeConverted Undo_Method
  THistoryData *ud = MainImageForm->Undo->GetLast();        //BeConverted Undo_Method
  HDC /*dcBmp = NULL, dcLayer = NULL, dcTempUB = NULL, dcTempUM = NULL,*/
    /*dcTempB = NULL,*/ dcTempM = NULL/*, dcTemp = NULL*/;    // convert by celberus
//*
  RECT rect = ud->getRectRange();
  RGNXFORM XForm;
  HRGN Region = NULL;
  RGBQUAD rgb[256];



  BITMAPHANDLE *regionHandle = Image->uBitmap->RgnBitmap->Handle;   // convert by celberus
  CalculatePosition();

  XForm.uViewPerspective = TOP_LEFT;
 	XForm.nXScalarNum = 1;
 	XForm.nXScalarDen = 1;
  XForm.nYScalarNum = 1;
 	XForm.nYScalarDen = 1;
 	XForm.nXOffset = 0;
  XForm.nYOffset = 0;
  L_GetBitmapRgnHandle(regionHandle, &XForm, &Region);    // convert by celberus
 	L_FreeBitmapRgn(regionHandle);    // convert by celberus

  Image->uBitmap->PartialUndo->LoadUndoWithOutIndexChange();
  Image->LayerMask->PartialUndo->LoadUndoWithOutIndexChange();
  //----³»ÀÏ ´Ù½Ã º¸Àð...-_-;;;--------
	//if (Image->uBitmap!=ud->uBitmap)
	//{
  //	Image->uBitmap->Copy(rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, ud->uBitmap, rect.left, rect.top, SRCCOPY);    // convert by celberus
  //	Image->LayerMask->Copy(rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, ud->LayerMask, rect.left, rect.top, SRCCOPY);
  //	}
  //-----------------------------------

  if(Image->uBitmap->BitsPerPixel == 8) {
    TempBitmap->GetColors(0, 256, rgb);
    Image->uBitmap->PutColors(0, 256, rgb);
    Image->LayerMask->PutColors(0, 256, rgb);
  }

  if ((dcTempM = TempMask->CreateDC()) == NULL) goto fail;

  Image->LayerMask->UnionBitBlt(dcTempM, pos.x, pos.y, TempMask->Width, TempMask->Height, 0, 0, SRCAND, true);   //BitBlt
  Image->uBitmap->UnionBitBlt(dcTempM, pos.x, pos.y, TempMask->Width, TempMask->Height, 0, 0, SRCAND, true);    // convert by celberus
  Image->uBitmap->Copy(pos.x, pos.y, TempBitmap->Width, TempBitmap->Height, TempBitmap, 0, 0, SRCPAINT);  // convert by celberus
  Image->uBitmap->UnionBitBlt(dcTempM, range.left, range.top, TempMask->Width, TempMask->Height, 0, 0, SRCAND, true);     // convert by celberus
  Image->uBitmap->Copy(range.left, range.top, Temp->Width, Temp->Height, Temp, 0, 0, SRCPAINT);  // convert by celberus

  TempMask->DeleteDC(dcTempM);

	L_SetBitmapRgnHandle(regionHandle, &XForm, Region, L_RGN_SET);
  DeleteObject(Region);
  Image->Repaint();
  return;
fail:
  if (dcTempM) TempMask->DeleteDC(dcTempM);
  if (Region) DeleteObject(Region);


  /*      //BeConverted by linuxjun Don't Forget!!   Undo_Method
  RECT r = ud->Range;
  RGNXFORM XForm;
  HRGN Region = NULL;
//  BITMAPHANDLE *bh = Image->uBitmap->Handle;
  BITMAPHANDLE *regionHandle = Image->uBitmap->RgnBitmap->Handle;   // convert by celberus
  CalculatePosition();

  XForm.uViewPerspective = TOP_LEFT;
 	XForm.nXScalarNum = 1;
 	XForm.nXScalarDen = 1;
  XForm.nYScalarNum = 1;
 	XForm.nYScalarDen = 1;
 	XForm.nXOffset = 0;
  XForm.nYOffset = 0;
  L_GetBitmapRgnHandle(regionHandle, &XForm, &Region);    // convert by celberus
 	L_FreeBitmapRgn(regionHandle);    // convert by celberus

//  if ((dcBmp   = Image->uBitmap->CreateDC()) == NULL) goto fail;    convert by celberus
//  if ((dcLayer = Image->LayerMask->CreateDC()) == NULL) goto fail;

//  if ((dcTempUB = ud->Bitmap->CreateDC()) == NULL) goto fail;     convert by celberus
//  if ((dcTempUM = ud->LayerMask->CreateDC()) == NULL) goto fail;
//  BitBlt(dcBmp, r.left, r.top, r.right - r.left, r.bottom - r.top, dcTempUB, 0, 0, SRCCOPY);
  Image->uBitmap->Copy(r.left, r.top, r.right - r.left, r.bottom - r.top, ud->Bitmap, 0, 0, SRCCOPY);    // convert by celberus
//  BitBlt(dcLayer, r.left, r.top, r.right - r.left, r.bottom - r.top, dcTempUM, 0, 0, SRCCOPY);
  Image->LayerMask->Copy(r.left, r.top, r.right - r.left, r.bottom - r.top, ud->LayerMask, 0, 0, SRCCOPY);
//  ud->Bitmap->DeleteDC(dcTempUB);     convert by celberus
//  ud->LayerMask->DeleteDC(dcTempUM);

//  if ((dcTempB = TempBitmap->CreateDC()) == NULL) goto fail;    convert by celberus
  if ((dcTempM = TempMask->CreateDC()) == NULL) goto fail;
//  if ((dcTemp  = Temp->CreateDC()) == NULL) goto fail;    convert by celberus

//  BitBlt(dcLayer, pos.x, pos.y, TempMask->Width, TempMask->Height, dcTempM, 0, 0, SRCAND);
  Image->LayerMask->UnionBitBlt(dcTempM, pos.x, pos.y, TempMask->Width, TempMask->Height, 0, 0, SRCAND, true);
//  BitBlt(dcBmp, pos.x, pos.y, TempMask->Width, TempMask->Height, dcTempM, 0, 0, SRCAND);
  Image->uBitmap->UnionBitBlt(dcTempM, pos.x, pos.y, TempMask->Width, TempMask->Height, 0, 0, SRCAND, true);    // convert by celberus
//  BitBlt(dcBmp, pos.x, pos.y, TempBitmap->Width, TempBitmap->Height, dcTempB, 0, 0, SRCPAINT);
  Image->uBitmap->Copy(pos.x, pos.y, TempBitmap->Width, TempBitmap->Height, TempBitmap, 0, 0, SRCPAINT);  // convert by celberus
//  BitBlt(dcBmp, range.left, range.top, TempMask->Width, TempMask->Height, dcTempM, 0, 0, SRCAND);
  Image->uBitmap->UnionBitBlt(dcTempM, range.left, range.top, TempMask->Width, TempMask->Height, 0, 0, SRCAND, true);     // convert by celberus
//  BitBlt(dcBmp, range.left, range.top, Temp->Width, Temp->Height, dcTemp, 0, 0, SRCPAINT);
  Image->uBitmap->Copy(range.left, range.top, Temp->Width, Temp->Height, Temp, 0, 0, SRCPAINT);  // convert by celberus

//  TempBitmap->DeleteDC(dcTempB);    convert by celberus
  TempMask->DeleteDC(dcTempM);
//  Temp->DeleteDC(dcTemp);     convert by celberus
//  Image->uBitmap->DeleteDC(dcBmp);    convert by celberus
//  Image->LayerMask->DeleteDC(dcLayer);

	L_SetBitmapRgnHandle(regionHandle, &XForm, Region, L_RGN_SET);
  DeleteObject(Region);
  Image->Repaint();
  return;
fail:
//  if (dcBmp) Image->uBitmap->DeleteDC(dcBmp);   convert by celberus
//  if (dcLayer) Image->LayerMask->DeleteDC(dcLayer);
//  if (dcTempUB) ud->Bitmap->DeleteDC(dcTempUB);   convert by celberus
//  if (dcTempUM) ud->LayerMask->DeleteDC(dcTempUM);
//  if (dcTempB) TempBitmap->DeleteDC(dcTempB);   convert by celberus
  if (dcTempM) TempMask->DeleteDC(dcTempM);
//  if (dcTemp) Temp->DeleteDC(dcTemp);   convert by celberus
  if (Region) DeleteObject(Region);
  */
}
//---------------------------------------------------------------------------
//Public Method
//---------------------------------------------------------------------------

void __fastcall TShadowForm::InitForm()
{
  RGBQUAD rgb[256];
  SIZE size;
  RECT undorange;

  ClientHeight = 159;
  Parent->Height = Parent->Height+20+ClientHeight;

  range = MainImageForm->WorkArea->Range;
  pos.x = range.left; pos.y = range.top;

  size.cx = range.right  - range.left;
  size.cy = range.bottom - range.top;
  Image = MainImageForm->iMainImage;
  undosave = false;

  bIsEnded=false;
  undorange.left   =  range.left - 100;
  if (undorange.left < 0) undorange.left = 0;
  undorange.right  =  range.right + 100;
  if (undorange.right > Image->uBitmap->Width) undorange.right = Image->uBitmap->Width;
  undorange.top    =  range.top - 100;
  if (undorange.top < 0) undorange.top = 0;
  undorange.bottom  =  range.bottom + 100;
  if (undorange.bottom > Image->uBitmap->Height) undorange.bottom = Image->uBitmap->Height;

  MainImageForm->UndoSave(UK_PATTERN, undorange);

  if ((TempBitmap = new TUnionBitmap) == NULL) goto fail;   // convert by celberus
  if ((TempMask = new TTexpiaBitmap) == NULL) goto fail;
  if ((Temp = new TUnionBitmap) == NULL) goto fail;   // convert by celberus
  if (Image->uBitmap->BitsPerPixel == 8) {
    Image->uBitmap->GetColors(0, 256, rgb);
    if (TempBitmap->Create(size.cx, size.cy, 8, rgb) == false) goto fail;
    if (Temp->Create(size.cx, size.cy, 8, rgb) == false) goto fail;
    if (TempMask->Create(size.cx, size.cy, 8, rgb) == false) goto fail;
  } else {
    if (TempBitmap->Create(size.cx, size.cy, 24) == false) goto fail;
    if (Temp->Create(size.cx, size.cy, 24) == false) goto fail;
    if (TempMask->Create(size.cx, size.cy, 1) == false) goto fail;
  }
  Temp->CopyFromRect(Image->LayerMask, range.left, range.top, NOTSRCCOPY);
  Temp->CopyFromRect(Image->uBitmap, range.left, range.top, SRCAND);
  FGChange(PaletteForm->DIB256Palette->ChoiceIndex);
//  MakeShadow();
//  ShowShadow();
  return;
fail:
  EXCEPTION_MESSAGE_OK(EC_MEMORY_LACK);
  PostMessage(hWnd, TPM_EXITFUNCTION, 0, 0);
}
//---------------------------------------------------------------------------

void __fastcall TShadowForm::ExitForm()
{
  if (undosave == false) {
//    Undo->Read();       //BeConverted by linuxjun Don't Forget!!   Undo_Method
    MainImageForm->Undo->UndoRead();       //BeConverted by linuxjun Don't Forget!!   Undo_Method
    if (PaletteForm->DIB256Palette->ChoiceIndex > MainImageForm->Palette->UseColor)
    PaletteForm->DIB256Palette->ChoiceIndex = MainImageForm->Palette->UseColor;
    bIsEnded=true;
    ::RepaintColor();
  }
  doDestroy(TempBitmap)
  doDestroy(Temp)
  doDestroy(TempMask)
}
//---------------------------------------------------------------------------

void __fastcall TShadowForm::FGChange(int Value)
{
  if (Image->uBitmap->BitsPerPixel == 8) {
    color = Value;
    shColor->Brush->Color
      = PaletteForm->DIB256Palette->Palette->ColorData[Value]->Color;
  } else {
    color = PaletteForm->DIB256Palette->Palette->ColorData[Value]->Color;
    shColor->Brush->Color = color;
  }
  MakeShadow();
  ShowShadow();
}
//---------------------------------------------------------------------------
void __fastcall TShadowForm::PaletteColorChange(int Value)    // by celberus
{
  RGBQUAD rgb[256];
  if (Image->uBitmap->BitsPerPixel == 8) {
    color = Value;
    shColor->Brush->Color
      = PaletteForm->DIB256Palette->Palette->ColorData[Value]->Color;
    Image->uBitmap->GetColors(0, 256, rgb);
    TempBitmap->PutColors(0, 256, rgb);
    TempMask->PutColors(0, 256, rgb);
  } else {
    color = PaletteForm->DIB256Palette->Palette->ColorData[Value]->Color;
    shColor->Brush->Color = color;
  }
  if(!bIsEnded){
    MakeShadow();
    ShowShadow();
  }
}
//---------------------------------------------------------------------------