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

#include "ComboForm.h"
#include "Combo_F.h"
#include "MainImage.h"
#include "Palette.h"
#include "Main.h"
#include "MainMenu.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma link "TPStretchImage"
#pragma link "RzEdit"
#pragma resource "*.dfm"
//---------------------------------------------------------------------------
#define IDS_COMBOFORM    StringTable[0]
#define IDS_COMBOMSGBOX1 StringTable[1]  // "Do you want to close Combo Menu?"

#define CIMAGE_WIDTH 486
#define CIMAGE_HEIGHT 368
#define SELECTOR_WIDTH 450
#define SELECTOR_HEIGHT 40
#define BACK_SHAPE_W 493
#define BACK_SHAPE_H 375
#define SHAPE_W 25        //(BACKSHAPE_W - BUTTON_W) / 18
#define SHAPE_H 20        //(BUTTON_H) / 2

TComboForms *ComboForms;
/////////ComboShape////////////
//---------------------------------------------------------------------------
__fastcall TComboShape::TComboShape(TComponent *AOwner): TShape(AOwner)
{
 	Width  = SHAPE_W;
 	Height = SHAPE_H;
 	Brush->Style = bsSolid;
  
}

/////////ComboSelector/

//---------------------------------------------------------------------------
void __fastcall TComboSelector::Paint()
{
  for (int wEntryIndex=0; wEntryIndex<=35; wEntryIndex++)
    DrawShape(wEntryIndex);
}
//---------------------------------------------------------------------------
void __fastcall TComboSelector::DrawShape(int Which)
{
  if ((FChoiceColor) && (Which < FChoiceColor->Count)) {
		ComboShape[Which]->Brush->Color =
 			FPalette->ColorData[FChoiceColor->Code[Which]]->Color;
  } else {
		ComboShape[Which]->Brush->Color = clWhite;
  }
}
//---------------------------------------------------------------------------
void __fastcall TComboSelector::ShapeMouseDown(TObject *Sender, TMouseButton Button,
  TShiftState Shift, int X, int Y)
{
	TComboShape *s = (TComboShape *) Sender;
  if (s->Count <= FChoiceColor->Count) {
  	if (s->Selected == false) {
  		s->Pen->Color = clWhite;
    	s->Selected = true;
      FCount++;
  	} else if ((s->Selected) == true) {
  		s->Pen->Color = clBlack;
    	s->Selected = false;
      FCount--;
  	}
    if (FOnShapeDown) FOnShapeDown(this, s);
  }
}
//---------------------------------------------------------------------------
void __fastcall TComboSelector::ShapeMouseMove(TObject *Sender, TShiftState Shift,
  int X, int Y)
{
	TComboShape *s = (TComboShape *) Sender;

  if (s->Count <= FChoiceColor->Count) 
    if (FOnShapeMove) FOnShapeMove(this, s);

}
//---------------------------------------------------------------------------
__fastcall TComboSelector::TComboSelector(TComponent *AOwner):
  TCustomControl(AOwner)
{
  ControlStyle = ControlStyle << csOpaque;
  Color = clWhite;
  SetBounds(0, 0, SELECTOR_WIDTH, SELECTOR_HEIGHT);
  FPalette = new TPalette;
	for (int j=0; j<=35; j++)  {
		ComboShape[j] = new TComboShape(this);
		ComboShape[j]->Count  =  j + 1;
		ComboShape[j]->Parent = this;
		ComboShape[j]->Left   = (j % 18) * SHAPE_W;
		ComboShape[j]->Top    = (j / 18) * SHAPE_H;
		ComboShape[j]->OnMouseDown = ShapeMouseDown;
		ComboShape[j]->OnMouseMove = ShapeMouseMove;
  }
  FCount = 0;
}
//---------------------------------------------------------------------------
__fastcall TComboSelector::~TComboSelector(void)
{
  for (int j=0; j<=35; j++)
  	delete ComboShape[j];
  delete FPalette;
}
//---------------------------------------------------------------------------
void __fastcall TComboSelector::ShapeDown(int Index)
{
 	if (ComboShape[Index - 1]->Selected == false) {
 		ComboShape[Index - 1]->Pen->Color = clWhite;
   	ComboShape[Index - 1]->Selected = true;
    FCount++;
 	} else if (ComboShape[Index - 1]->Selected == true) {
 		ComboShape[Index - 1]->Pen->Color = clBlack;
   	ComboShape[Index - 1]->Selected = false;
    FCount--;
 	}
}
//---------------------------------------------------------------------------

/////////ComboForms////////////

__fastcall TComboForms::TComboForms(TComponent* Owner)
  : TForm(Owner)
{
  StringTable.Create(DirectoryItem, Language, "ComboForm");
  SetSmallFont(Font);
  SetSmallFont(SpeedButton1->Font);
  SetSmallFont(SpeedButton2->Font);
  SetSmallFont(SpeedButton3->Font);
  SetSmallFont(SpeedButton4->Font);
  SetSmallFont(Edit1->Font);
  SetSmallFont(Edit2->Font);
  SetSmallFont(Edit3->Font);
  SetSmallFont(Edit4->Font);
  Caption = IDS_COMBOFORM;

}
//---------------------------------------------------------------------------
void __fastcall TComboForms::FormCreate(TObject *Sender)
{
	ChoiceColor = NULL;

	// ÄÄÆ÷³ÍÆ®ÀÇ À§Ä¡¿Í Å©±â¸¦ Çػ󵵿¡ ¸Âµµ·Ï º¯°æ - by monkman (2010.08.16)
	HDC hDC = NULL;

	// Monitor
	hDC = GetDC(NULL);
	//nOriginalScreenWidth = GetDeviceCaps(hDC, HORZRES);
	//nOriginalScreenHeight = GetDeviceCaps(hDC, VERTRES);
	nOriginalScreenWidth = 1280;
	nOriginalScreenHeight = 1024;
	ReleaseDC(NULL, hDC);

	// Çػ󵵰¡ º¯°æµÉ ¶§ ÄÁÆ®·ÑµéÀÇ À§Ä¡¿Í »çÀÌÁ ÀúÀåÇϱâ À§ÇØ - by monkman (2010.08.16)
	CompPosSizeList = new TList;
}
//---------------------------------------------------------------------------
void __fastcall TComboForms::FormDestroy(TObject *Sender)
{
	// Çػ󵵰¡ º¯°æµÉ ¶§ ÄÁÆ®·ÑµéÀÇ À§Ä¡¿Í »çÀÌÁ º¯°æÇϱâ À§ÇØ - by monkman (2010.08.16)
	TCompPosSize *CompPosSize = NULL;
	if (CompPosSizeList) {
		for (int i = 0; i < CompPosSizeList->Count; i++) {
			CompPosSize = (TCompPosSize *)CompPosSizeList->Items[i];
			if (CompPosSize) delete CompPosSize;
		}

		CompPosSizeList->Clear();
		delete CompPosSizeList;
	}
	CompPosSizeList = NULL;

  delete ChoiceColor;
  ChoiceColor = NULL;
  for (int j=0; j<=3; j++)
  	delete Selector[j];
}
//---------------------------------------------------------------------------

void __fastcall TComboForms::FixClick(TObject *Sender)
{
	TSpeedButton *s = (TSpeedButton *) Sender;
  if (rotate.fix[s->Tag] == 0) {
  	rotate.fix[s->Tag] = 1;
    s->Font->Color = clBlue;
    s->Caption = "FIX";
    s->Down = true;
    rotate.fix_cnt++;
  } else {
  	rotate.fix[s->Tag] = 0;
    s->Font->Color = clBlack;
    s->Caption = s->Tag + 1;
    s->Down = false;
    rotate.fix_cnt--;
  }
  SetData();
}
//---------------------------------------------------------------------------

void __fastcall TComboForms::OutMouseDown(TObject *Sender,
      TMouseButton Button, TShiftState Shift, int X, int Y)
{
  TShape *s = (TShape *) Sender;
  page = s->Tag;
  if (page == 0) {
  	Shape1->Pen->Color = clFuchsia;
  	Shape2->Pen->Color = clBlue;
  	Shape3->Pen->Color = clBlue;
  	Shape4->Pen->Color = clBlue;
  } else if (page == 1) {
  	Shape1->Pen->Color = clBlue;
  	Shape2->Pen->Color = clFuchsia;
  	Shape3->Pen->Color = clBlue;
  	Shape4->Pen->Color = clBlue;
  } else if (page == 2) {
  	Shape1->Pen->Color = clBlue;
  	Shape2->Pen->Color = clBlue;
  	Shape3->Pen->Color = clFuchsia;
  	Shape4->Pen->Color = clBlue;
  } else if (page == 3) {
  	Shape1->Pen->Color = clBlue;
  	Shape2->Pen->Color = clBlue;
  	Shape3->Pen->Color = clBlue;
  	Shape4->Pen->Color = clFuchsia;
  }
  SetData();
}
//---------------------------------------------------------------------------
void __fastcall TComboForms::DrawRectangle(TObject *Sender, RECT rc)
{
  HDC formDC;
  HBRUSH hOldBrush;
  HPEN hOldPen;
  int nDrawMode;
  TPStretchImage *s = (TPStretchImage *) Sender;

  formDC = s->Canvas->Handle;
  hOldBrush = (HBRUSH)SelectObject(formDC, GetStockObject(NULL_BRUSH));
  hOldPen = (HPEN)SelectObject(formDC, GetStockObject(WHITE_PEN));
  nDrawMode = GetROP2(formDC);
  SetROP2(formDC, R2_NOT);
  Rectangle(formDC, min(rc.left, rc.right), min(rc.top, rc.bottom),
	  max(rc.left, rc.right), max(rc.top, rc.bottom));
  SetROP2(formDC, nDrawMode);
  SelectObject(formDC, hOldBrush);
  SelectObject(formDC, hOldPen);
}
//--------------------------------------------------------------------------
void __fastcall TComboForms::FromSelector2ComboSelector()
{
  int cnt = WSelector->Count;

  for (int m=0; m<=3; m++) {
    for (int k=0; k<36; k++) {
      if(Selector[m]->ComboShape[k]->Selected)
        Selector[m]->ShapeDown(k+1);
    }
  }

  for (int i=0; i<cnt; i++) {
    for (int j=0; j<36; j++) {
      if (WSelector->ChoiceColor->Code[i] == ChoiceColor->Code[j]) {
        if (ComboMenu->sbComboDelete->Down) {
          for (int k=0; k<=3; k++) Selector[k]->ShapeDown(j+1);
        } else {
          if (!Selector[0]->ComboShape[j]->Selected) {
            for (int k=0; k<=3; k++) Selector[k]->ShapeDown(j+1);
            break;
          }
        }
      }
    }
  }
  SetData();
}
//---------------------------------------------------------------------------
void __fastcall TComboForms::CImageMouseDown(TObject *Sender,
      TMouseButton Button, TShiftState Shift, int X, int Y)
{
	TRect r;
  int ix, iy;

  TPStretchImage *s = (TPStretchImage *) Sender;
	if (Button==mbMiddle || (Shift.Contains(ssShift) && Button==mbLeft)) {
    double rx = (double) CImage[0]->Width / window.size.x;
    double ry = (double) CImage[0]->Height / window.size.y;
  	if (rx > ry) {
   		ix = X / ry;
   		iy = Y / ry;
  	} else {
   		ix = X / rx;
   		iy = Y / rx;
  	}
		if (ComboMenu->sbComboBlock->Down) {
    	if (ComboMenu->sbComboDelete->Down) {
			  WSelector->DeleteColor(s->Bitmap->GetPixelColor(ix, iy));
   	  } else {
        if (WSelector->Count<13)
			    WSelector->AddColor(s->Bitmap->GetPixelColor(ix, iy));
      }
      FromSelector2ComboSelector();
    } else {
      if (step == 0) {
	      Temp.left = X;
			  Temp.top  = Y;
        Temp.right = Temp.left;
			  Temp.bottom = Temp.top;
 			  DrawRectangle(Sender, Temp);
        IsDraw = true;
        Img_tag = s->Tag;
		    step   = 1;
	    } else if (step == 1) {
	  	  Temp.right  = X;
		  	Temp.bottom = Y;
				DrawRectangle(Sender, Temp);
      	if (rx > ry) {
     		  Temp.left = Temp.left / ry;
     		  Temp.right = Temp.right / ry;
     		  Temp.top = Temp.top / ry;
     		  Temp.bottom = Temp.bottom / ry;
  	    } else {
     		  Temp.left = Temp.left / rx;
     		  Temp.right = Temp.right / rx;
     		  Temp.top = Temp.top / rx;
     		  Temp.bottom = Temp.bottom / rx;
  	    }
		    if (Temp.left > Temp.right) {
			    r.Left  = Temp.right;
  				r.Right = Temp.left;
	  	  } else {
		  	  r.Left  = Temp.left;
					r.Right = Temp.right;
	    	}
			  if (Temp.top > Temp.bottom) {
  				r.Top    = Temp.bottom;
 	  			r.Bottom = Temp.top;
		  	} else {
	  			r.Top    = Temp.top;
 				  r.Bottom = Temp.bottom;
			  }
        if (ComboMenu->sbComboDelete->Down) {
		    	for (iy=r.Top; iy<r.Bottom; iy++) {
            for (ix=r.Left; ix<r.Right; ix++) {
	  		  		WSelector->DeleteColor(s->Bitmap->GetPixelColor(ix, iy));
	      	  }
	  		  }
        } else {
		    	for (iy=r.Top; iy<r.Bottom; iy++) {
   		  		for (ix=r.Left; ix<r.Right; ix++) {
              if (WSelector->Count<13)
                WSelector->AddColor(s->Bitmap->GetPixelColor(ix, iy));
              else goto next;
	      	  }
	  		  }
        }
next:
			  IsDraw = false;	MainImageForm->iMainImage->OnPaintLocate = NULL;/////////////////by jeegeo
        Img_tag = 10;
        step = 0;
        FromSelector2ComboSelector();
      }
	  }
	} else if (Button == mbLeft) {
    page = s->Tag;
    if (page == 0) {
  	  Shape1->Pen->Color = clFuchsia;
  	  Shape2->Pen->Color = clBlue;
  	  Shape3->Pen->Color = clBlue;
  	  Shape4->Pen->Color = clBlue;
    } else if (page == 1) {
  	  Shape1->Pen->Color = clBlue;
  	  Shape2->Pen->Color = clFuchsia;
  	  Shape3->Pen->Color = clBlue;
  	  Shape4->Pen->Color = clBlue;
    } else if (page == 2) {
  	  Shape1->Pen->Color = clBlue;
  	  Shape2->Pen->Color = clBlue;
  	  Shape3->Pen->Color = clFuchsia;
  	  Shape4->Pen->Color = clBlue;
    } else if (page == 3) {
  	  Shape1->Pen->Color = clBlue;
  	  Shape2->Pen->Color = clBlue;
  	  Shape3->Pen->Color = clBlue;
  	  Shape4->Pen->Color = clFuchsia;
    }
    SetData();
  }
}
//---------------------------------------------------------------------------

void __fastcall TComboForms::CImageMouseMove(TObject *Sender,
      TShiftState Shift, int X, int Y)
{

  double rx, ry;
  COLORREF color;
  TPStretchImage* s = (TPStretchImage *) Sender;

  if (s->Tag == Img_tag) {
    if (step == 1) {
	    if (IsDraw) DrawRectangle(Sender, Temp);
	    Temp.right  = X;
		  Temp.bottom = Y;
	    DrawRectangle(Sender, Temp);
      IsDraw = true;
	  }
  }
  rx = (double) CImage[0]->Width / (double)window.size.x;
  ry = (double) CImage[0]->Height / (double)window.size.y;
	if (rx > ry) {
 		X = X / ry;
 		Y = Y / ry;
	} else {
 		X = X / rx;
 		Y = Y / rx;
	}
  if (X >= 0 && X < s->Bitmap->Width && Y >= 0 && Y < s->Bitmap->Height)
  {
    color =	s->Bitmap->GetPixelColor(X, Y);
    PaletteForm->DIB256Palette->CursorIndex
    	= 252 - (4 - s->Tag)*ChoiceColor->Count + ChoiceColor->Number[color];
  }
}
//---------------------------------------------------------------------------
int __fastcall TComboForms::Factorial(int n)
{
  int m = 1;
	for (int i=1; i<=n; i++) {
    m = m * i;
  }
  return m;
}
//---------------------------------------------------------------------------
int __fastcall TComboForms::Fermutation(int a, int b)
{
  int m = 1;
	for (int i=a; i>a-b; i--) {
    m = m * i;
  }
  return m;
}
//---------------------------------------------------------------------------
void __fastcall TComboForms::ComboSelectorShapeDown(TObject *Sender,
  TComboShape *Shape)
{
	int k;
	TComboSelector *cs = (TComboSelector *) Sender;
	if (Shape->Selected) {
    WSelector->AddColor(ChoiceColor->Code[Shape->Count-1]);
  } else {
    WSelector->DeleteColor(ChoiceColor->Code[Shape->Count-1]);
  }
  for (int i=0; i<=3; i++) {
  	if (cs!=Selector[i])  Selector[i]->ShapeDown(Shape->Count);
    else k = i;
  }

  //Selector¸¦ ´©¸£¸é ÇØ´çÇÏ´Â image°¡ ¼±Åõǵµ·Ï OutMouseDown¸¦ call
  TShape* aShape = (TShape*)FindComponent("Shape" + IntToStr(k + 1));
  OutMouseDown(aShape, mbLeft, TShiftState(), 0, 0);

  PaletteForm->DIB256Palette->ChoiceIndex
  	= ((252 - (4 * ChoiceColor->Count)) + k * ChoiceColor->Count ) + Shape->Count - 1;
  SetData();
}
//---------------------------------------------------------------------------
void __fastcall TComboForms::ComboSelectorShapeMove(TObject *Sender,
  TComboShape *Shape)
{
	int i, k;
	TComboSelector *cs = (TComboSelector *) Sender;

  for (i=0; i<=3; i++) {
  	if (cs == Selector[i])  k = i;
  }
  PaletteForm->DIB256Palette->CursorIndex
  	= 252 - (4 - k)*ChoiceColor->Count + Shape->Count - 1;
}
//---------------------------------------------------------------------------
bool __fastcall TComboForms::InitForm()
{
  ChoiceColor = new TChoiceColor;
  if (MainImageForm->WorkArea->Mask) {
	MainImageForm->SearchWorkAreaColor(ChoiceColor);
  } else {
	MainImageForm->SearchWholeColor(ChoiceColor);
  }

  if (ChoiceColor->Count > 12) {
    EXCEPTION_MESSAGE_OK(EC_COLOR_OVER12);
		//Application->MessageBox("over 12 color error","error box",MB_OK);
    return false;
    }

  int i;

  Left = 2;
  Top = 25;
 	Visible = true;

  WSelector = ComboMenu->Selector;
  rotate.reverse = &(ComboMenu->PlayBar->Direction);
  rotate.fix_cnt = 0;
  for (i=0; i<4; i++) rotate.fix[i] = 0;

  if (MainImageForm->WorkArea->Mask) {
  	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;
  } else {
	window.s = Point(0, 0);
  	window.e = Point(MainImageForm->iMainImage->uBitmap->Width
      , MainImageForm->iMainImage->uBitmap->Height);
  }
 	window.size.x = window.e.x - window.s.x;
 	window.size.y = window.e.y - window.s.y;
 	window.Bitmap = 0;
 	window.Mask   = 0;
 	window.Back   = 0;
//
//    MainImageForm->iMainImage->Repaint();
    Shape1->Pen->Color = clFuchsia;
 	Shape2->Pen->Color = clBlue;
 	Shape3->Pen->Color = clBlue;
 	Shape4->Pen->Color = clBlue;

    CImage[0] = PImage1;
    CImage[1] = PImage2;
    CImage[2] = PImage3;
    CImage[3] = PImage4;

    for (i=0; i<=3; i++) {
			Selector[i] = new TComboSelector(this);
	    Selector[i]->Parent = this;
			Selector[i]->Left =  (BACK_SHAPE_W+5) * (i % 2);
	    Selector[i]->Top =  (BACK_SHAPE_H+5) + (BACK_SHAPE_H+SELECTOR_HEIGHT+10) * (i / 2);
      Selector[i]->Selector = WSelector;
  	  Selector[i]->Palette->SetPalette(MainImageForm->Palette);
		  Selector[i]->ChoiceColor = ChoiceColor;
  	  Selector[i]->Invalidate();

  	  Selector[i]->OnShapeDown = ComboSelectorShapeDown;
  	  Selector[i]->OnShapeMove = ComboSelectorShapeMove;
    }

    page = 0;
    Img_tag = 10;
    SetComboImage();
		::RepaintColor();

		// Çػ󵵰¡ º¯°æµÉ ¶§ ÄÁÆ®·ÑµéÀÇ À§Ä¡¿Í »çÀÌÁ º¯°æÇϱâ À§ÇØ - by monkman (2010.08.16)
		SaveComponentPosSize();
		ResizeComponentByResolution();

    return true;
//
}
//---------------------------------------------------------------------------

void __fastcall TComboForms::ComboColorChange(TObject *Sender)
{
  int fg, k, i, j, m;
  RGBQUAD rgb[256];

  fg = PaletteForm->DIB256Palette->ChoiceIndex;
	if (ChoiceColor) {
    if (ChoiceColor->Count > 36) return;
	  k = 252 - 4*ChoiceColor->Count;
//    if (MainImageForm->Palette->UseColor >= k) return;     // 99/06/07
  	if (fg >= k) {
    	m = fg - k;
			i = m / ChoiceColor->Count;
    	j = m % ChoiceColor->Count;
      if(i != page) { // ÇöÀç ¼±ÅÃµÈ color°¡ »ç¿ëµÇ´Â Selector¸¦ ¼±ÅÃÇϵµ·Ï ÇÔ
        TShape* aShape = (TShape*)FindComponent("Shape" + IntToStr(i + 1));
        OutMouseDown(aShape, mbLeft, TShiftState(), 0, 0);
      }
 		  Selector[i]->Palette->ColorData[Selector[i]->ChoiceColor->Code[j]]
   		  = MainImageForm->Palette->ColorData[fg];
 	    Selector[i]->Palette->ToRGBQUAD(rgb, 256);
 		  CImage[i]->Bitmap->PutColors(0, 256, rgb);
      CImage[i]->Repaint();
 		  Selector[i]->Invalidate();
    } else {
      for(i = 0; i < 4; i++)
      {
        Selector[i]->Palette->ColorData[fg]
          = MainImageForm->Palette->ColorData[fg];
        Selector[i]->Palette->ToRGBQUAD(rgb, 256);
        CImage[i]->Bitmap->PutColors(0, 256, rgb);
        CImage[i]->Repaint();
        Selector[i]->Invalidate();
      }
    }
    //ComboForm¿¡¼­ ¼±ÅÃµÈ Selector°¡ ComboMenuÀÇ Selector¿¡ ¹Ý¿µµÇµµ·Ï palette µ¿±âÈ­
    WSelector->SetPalette(Selector[page]->Palette);
    WSelector->Invalidate();
  }
}
//---------------------------------------------------------------------------

void __fastcall TComboForms::PaletteColorChange(int i)
{
  int fg, k, j, m;

  k = 252 - 4*ChoiceColor->Count;
  for (j = 0; j < ChoiceColor->Count; j++) {
    fg = k + (i * ChoiceColor->Count + j);
    MainImageForm->Palette->ColorData[fg]
      = Selector[i]->Palette->ColorData[Selector[i]->ChoiceColor->Code[j]];
  }
}
//---------------------------------------------------------------------------

void __fastcall TComboForms::SetData()
{
  if (ComboMenu->sbChange->Down) {
    if (WSelector->Count > 12) {
			EXCEPTION_MESSAGE_OK(EC_COLOR_OVERFLOW);
			ComboMenu->rzbitbtnExit->Enabled = false;
			ComboMenu->rzbitbtnRun->Enabled = true;
      ComboMenu->PlayBar->SetInit();
	  	ComboMenu->PlayPanel->Visible = false;
  	  ComboMenu->SelectorPanel->Visible = true;
    } else {
  	  WSelector->SetPalette(Selector[page]->Palette);
  	  WSelector->Invalid();
  	  rotate.page  = 0;
  	  rotate.count = Selector[page]->Count;
      if (rotate.count == 0) {
				ComboMenu->rzbitbtnExit->Enabled = false;
				ComboMenu->rzbitbtnRun->Enabled = true;
	      ComboMenu->sbHue->Enabled = true;
  	    ComboMenu->PlayBar->SetInit();
	      ComboMenu->PlayPanel->Visible = false;
  	    ComboMenu->SelectorPanel->Visible = true;
      } else {
  	    color_count  = WSelector->Count;
  	    color_point  = 225 - 4 * color_count;
//  		  rotate.total = Factorial(WSelector->Count);
  		  rotate.total = Fermutation(WSelector->Count, rotate.count);
        ComboMenu->Progress->Frequency = 4 - rotate.fix_cnt;
        if (WSelector->Count>8)
          ComboMenu->Progress->Max = rotate.total/1000;
        else
          ComboMenu->Progress->Max = rotate.total - 1;
      }
    }
  } else if (ComboMenu->sbHue->Down) {
	  WSelector->SetPalette(Selector[page]->Palette);
	  WSelector->Invalid();
 	  rotate.page  = 0;
 	  rotate.count = Selector[page]->Count;
    if (ComboMenu->HuePanel->Visible && WSelector->Count)
    	ComboMenu->SetSelectorPalette();
  }
}
//---------------------------------------------------------------------------
void __fastcall TComboForms::SetComboImage()
{
  int i, j, x, y, k;
  Byte *src, *dst;
	long double rx, ry;
  RGBQUAD rgb[256];
  TPItemImage *Image = MainImageForm->iMainImage;
  TPException ec = EC_NONE;

  if (page == 0) {
  	Shape1->Pen->Color = clFuchsia;
  	Shape2->Pen->Color = clBlue;
  	Shape3->Pen->Color = clBlue;
  	Shape4->Pen->Color = clBlue;
  } else if (page == 1) {
  	Shape1->Pen->Color = clBlue;
  	Shape2->Pen->Color = clFuchsia;
  	Shape3->Pen->Color = clBlue;
  	Shape4->Pen->Color = clBlue;
  } else if (page == 2) {
  	Shape1->Pen->Color = clBlue;
  	Shape2->Pen->Color = clBlue;
  	Shape3->Pen->Color = clFuchsia;
  	Shape4->Pen->Color = clBlue;
  } else if (page == 3) {
  	Shape1->Pen->Color = clBlue;
  	Shape2->Pen->Color = clBlue;
  	Shape3->Pen->Color = clBlue;
  	Shape4->Pen->Color = clFuchsia;
  }
	if (MainImageForm->WorkArea->Mask) {
  	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;
  } else {
   	window.s = Point(0, 0);
  	window.e = Point(Image->uBitmap->Width, Image->uBitmap->Height);
  }
  window.size.x = window.e.x-window.s.x;
  window.size.y = window.e.y-window.s.y;

  //// ColorBook ¿¡ ÀÇÇÑ  colorchange¸¦ À§ÇÑ ÀÛ¾÷..

 	k = 252 - 4*ChoiceColor->Count;

  for (i=0; i<=3; i++)  {
    for (j=0; j<ChoiceColor->Count; j++) {
    	MainImageForm->Palette->ColorData[k]
       	= Selector[i]->Palette->ColorData[Selector[i]->ChoiceColor->Code[j]];
     	k++;
  	}
  }
  //////////////

  if (!Image->uBitmap->StartScanLine()) { ec = EC_MEMORY_LACK; SAVE_EXCEPTION(ec); goto fail; }
  for (i=0; i<=3; i++)  {
  	Selector[i]->Palette->ToRGBQUAD(rgb, 256);
  	if (CImage[i]->Bitmap->Create(window.size.x, window.size.y, 8, rgb) == false) { ec = EC_MEMORY_LACK; SAVE_EXCEPTION(ec); goto fail; }
    if (!CImage[i]->Bitmap->StartScanLine()) { ec = EC_MEMORY_LACK; SAVE_EXCEPTION(ec); goto fail; }
    for (y=0; y<window.size.y; y++) {
    	src = Image->uBitmap->GetScanLine(window.s.y + y);
    	dst = CImage[i]->Bitmap->GetScanLine(y);
	    for (x=0; x<window.size.x; x++) {
      	*(dst+x) = *(src+(window.s.x + x));
      }
      CImage[i]->Bitmap->PutScanLine(y);
    }
    CImage[i]->Bitmap->StopScanLine();
  	rx = (double) CIMAGE_WIDTH / window.size.x;
  	ry = (double) CIMAGE_HEIGHT / window.size.y;
  	if (rx > ry) {
   		CImage[i]->Width  = window.size.x * ry;
   		CImage[i]->Height = window.size.y * ry;
  	} else {
   		CImage[i]->Width  = window.size.x * rx;
   		CImage[i]->Height = window.size.y * rx;
  	}
  }
  Image->uBitmap->StopScanLine();
  CanVisible(0);
  return;
fail:
  for (i = 0; i <= 3; i++) {
    CImage[i]->Bitmap->StopScanLine();
    CImage[i]->Bitmap->Destroy();
  }
  Image->uBitmap->StopScanLine();
  EXCEPTION_MESSAGE_OK(ec);
}
//---------------------------------------------------------------------------
void __fastcall TComboForms::Combination(Byte *pmt, int n, int r, int p)
{
	Byte *buf = 0;
	HGLOBAL hBuf = NULL;
  int k, l, ft;
  Byte i, j;

	hBuf = GlobalAlloc(GMEM_MOVEABLE, n * sizeof(Byte));
  if (hBuf) {
	  buf = (Byte *)GlobalLock(hBuf);
    if (buf) {
      for (i=0; i<n; i++)  *(buf+i) = '0';
      ft = Factorial(n);
      if ((n - r)!=0)  p = p * Factorial(n - r);
      for (i=0; i<r; i++) {
  	    ft = ft / (n - i);
        l = p / ft;
        k = 0;
        for (j=0; j<n; j++) {
          if (*(buf+j) == '0') {
            if (k == l) {
              *(pmt+i) = j;
              *(buf+j) = '1';
              break;
            }
            k++;
          }
        }
        p = p % ft;
      }
	    GlobalUnlock(hBuf);
    }
	  GlobalFree(hBuf);
  }
}
//---------------------------------------------------------------------------
void __fastcall TComboForms::ComChange(TObject *Sender)
{
	int i, j, m, fn;
  RGBQUAD rgb[256];

  m = 0;
  if (WSelector->Count < rotate.count) {
  } else if ((WSelector->Count > 12) || (WSelector->Count == 0)) {
  } else if (rotate.fix_cnt < 4) {
  	j = (rotate.total - 1) / (4 - rotate.fix_cnt);
    if (rotate.page < 0) rotate.page = j;
    else if (rotate.page > j) rotate.page = 0;
    for (i=0; i<=3; i++) {
    	if (rotate.fix[i] == 0) {
      	j = (rotate.page * (4 - rotate.fix_cnt) + i) % rotate.total;
        switch (i) {
					case 0: Edit1->Text = String(j+1);  break;
					case 1: Edit2->Text = String(j+1);  break;
					case 2: Edit3->Text = String(j+1);  break;
          case 3: Edit4->Text = String(j+1);  break;
        }
        Combination(rotate.fact, WSelector->Count, rotate.count, j);
        fn = 0;
        for (j=0; j < ChoiceColor->Count; j++)  {
        	if (Selector[i]->ComboShape[j]->Selected == true) {
            Selector[i]->Palette->ColorData[Selector[i]->ChoiceColor->Code[j]]->Copy(
            	WSelector->GetColorMap(rotate.fact[fn]));
            fn++;
          }
        }
				Selector[i]->Palette->ToRGBQUAD(rgb, 256);
				CImage[i]->Bitmap->PutColors(0, 256, rgb);
        CImage[i]->Repaint();
        Selector[i]->Invalidate();
        rotate.number = rotate.page * (4 - rotate.fix_cnt) + 1 + m;
        m++;
      }
    }
    if (*(rotate.reverse) == 2) rotate.page++;
    else if (*(rotate.reverse) == 1) rotate.page--;
  }
}
//---------------------------------------------------------------------------

void __fastcall TComboForms::PageEditClick(TObject *Sender)
{
  TRzNumericEdit* edit = (TRzNumericEdit *) Sender;
  edit->SetFocus();
  edit->SelectAll();
}
//---------------------------------------------------------------------------

void __fastcall TComboForms::PageEditKeyDown(TObject *Sender, WORD &Key,
      TShiftState Shift)
{
  int tg, s_page, j, fn;
  RGBQUAD rgb[256];
  TRzNumericEdit* et = (TRzNumericEdit *) Sender;
  if(Key==VK_RETURN) {
    tg = et->Tag;
    if (rotate.fix[tg] == 0) {
      s_page = et->IntValue;
      if ((s_page<=0)||(s_page>rotate.total)) {
        s_page = 1;
        et->Value = 1; //et->Text = "1";
      }
      j = s_page-1;
      Combination(rotate.fact, WSelector->Count, rotate.count, j);
      fn = 0;
      for (j=0; j<color_count; j++) {
        if (Selector[tg]->ComboShape[j]->Selected == true) {
          Selector[tg]->Palette->ColorData[Selector[tg]->ChoiceColor->Code[j]]->Copy(
          	WSelector->GetColorMap(rotate.fact[fn]));
          fn++;
        }
      }
  		Selector[tg]->Palette->ToRGBQUAD(rgb, 256);
	  	CImage[tg]->Bitmap->PutColors(0, 256, rgb);
      CImage[tg]->Repaint();
      Selector[tg]->Invalidate();
    }
  }
}
//---------------------------------------------------------------------------
void __fastcall TComboForms::CanVisible(int i)
{
  if (i == 0) {
    Edit1->Visible = false;
    Edit2->Visible = false;
    Edit3->Visible = false;
    Edit4->Visible = false;
  } else {
    Edit1->Visible = true;
    Edit2->Visible = true;
    Edit3->Visible = true;
    Edit4->Visible = true;
  }
}

//---------------------------------------------------------------------------
void __fastcall TComboForms::FormCloseQuery(TObject *Sender,
      bool &CanClose)
{
	if (Application->MessageBox(IDS_COMBOMSGBOX1.c_str(), L"Information", MB_OKCANCEL) == 1)
    CanClose = true;
  else CanClose = false;
}
//---------------------------------------------------------------------------

void __fastcall TComboForms::FormClose(TObject *Sender,
      TCloseAction &Action)
{
  if (Action) {
    ComboMenu->ExitForm(true);
		ComboMenu->rzbitbtnOld->AllowAllUp = true;
		ComboMenu->rzbitbtnOld->Down = false;
    ComboMenu->rzbitbtnOld->AllowAllUp = false;
		ComboMenu->InitForm(true);
    ComboMenu->useCombo = false;
  }
}
//---------------------------------------------------------------------------

void __fastcall TComboForms::PImagePaintEnd(TObject *Sender)
{
#ifdef TRIAL
  TPStretchImage *pi = (TPStretchImage *)Sender;
  PaintWaterMark(pi->Canvas->Handle, 0, 0, pi->Width, pi->Height, 1, 3);
#endif
}
//---------------------------------------------------------------------------
void __fastcall TComboForms::SaveComponentPosSize()
{
	// ÄÄÆ÷³ÍÆ®ÀÇ À§Ä¡¿Í Å©±â¸¦ ÀúÀå - by monkman (2010.08.16)
	TCompPosSize *CompPosSize = NULL;
	TWinControl *winCtrl = NULL;

	for (int i = 0; i < ComponentCount; i++) {
		winCtrl = (TWinControl *)(Components[i]);
		if (winCtrl) {
			CompPosSize = new TCompPosSize;
			CompPosSize->Comp = Components[i];
			CompPosSize->Left = winCtrl->Left;
			CompPosSize->Top = winCtrl->Top;
			CompPosSize->Width = winCtrl->Width;
			CompPosSize->Height = winCtrl->Height;
			CompPosSizeList->Add(CompPosSize);
		}
	}
}
//---------------------------------------------------------------------------
void __fastcall TComboForms::ResizeComponentByResolution()
{
	// ÄÄÆ÷³ÍÆ®ÀÇ À§Ä¡¿Í Å©±â¸¦ Çػ󵵿¡ ¸Âµµ·Ï º¯°æ - by monkman (2010.08.16)
	HDC hDC = NULL;
	int nScreenWidth = 0, nScreenHeight = 0;
	double dHorzZoom = 0.0, dVertZoom = 0.0, dRatio = 0.0;
	TCompPosSize *CompPosSize = NULL;
	TWinControl *winCtrl = NULL;
	TComboSelector *comboSel = NULL;

	// Monitor
	hDC = GetDC(NULL);
	nScreenWidth = GetDeviceCaps(hDC, HORZRES);
	nScreenHeight = GetDeviceCaps(hDC, VERTRES);
	ReleaseDC(NULL, hDC);

	dHorzZoom = (double)nScreenWidth / nOriginalScreenWidth;
	dVertZoom = (double)nScreenHeight / nOriginalScreenHeight;
	dRatio = dHorzZoom < dVertZoom ? dHorzZoom : dVertZoom;

	// Form
	if (0 < CompPosSizeList->Count) {
		CompPosSize = (TCompPosSize *)CompPosSizeList->Items[0];

		Left = 0;
		Top = 0;
		// ĵ¹ö½º Å©±â ¸¸Å­
		if (MainMenuForm) {
			Width = MainForm->ClientWidth - MainMenuForm->Width - 4;
			Height = MainForm->ClientHeight - MainForm->StatusBar->Height - 4;
		}

		for (int i = 0; i < CompPosSizeList->Count; i++) {
			CompPosSize = (TCompPosSize *)CompPosSizeList->Items[i];
			winCtrl = (TWinControl *)(CompPosSize->Comp);
			if (CompPosSize) {
				winCtrl->Left = CompPosSize->Left * dRatio;
				winCtrl->Top = CompPosSize->Top * dRatio;
				winCtrl->Width = CompPosSize->Width * dRatio;
				winCtrl->Height = CompPosSize->Height * dRatio;
			}
			comboSel = dynamic_cast<TComboSelector *>(CompPosSize->Comp);
			if (comboSel) {
				for (int j=0; j<=35; j++)  {
					comboSel->ComboShape[j]->Left   = (j % 18) * SHAPE_W * dRatio;
					comboSel->ComboShape[j]->Top    = (j / 18) * SHAPE_H * dRatio;
				}
			}
		}
	}
}
//---------------------------------------------------------------------------