//{ ------------------------------------------------------------------------------ }
//{ Authorization : F. A Electronics                                               }
//{ Date          : 1997. 6.                                                       }
//{ Compiler      : Delphi 3.0                                                     }
//{ ------------------------------------------------------------------------------ }
//{ Class Name : TDIB256Palette                                                    }
//{ Description: ÀÌÈ­ÀÏÀº ¼¼°¡Áö ±â´ÉÀ» °¡Áø´Ù.                                    }
//{                                                                                }
//{    ù¹ø°´Â Palette ±â´ÉÀÌ´Ù.                                                  }
//{    µÎ¹ø°´Â Color Change ±â´ÉÀÌ´Ù.                                             }
//{    ¼¼¹ø°´Â Palette ÀÔÃâ·Â±â´ÉÀÌ´Ù.                                            }
//{                                                                                }
//{ ------------------------------------------------------------------------------ }
//  (DIB256s.pas)

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

#include "DIB256s.h"

//---------------------------------------------------------------------------
#pragma package(smart_init)
//---------------------------------------------------------------------------
static inline void ValidCtrCheck(TDIB256Palette *)
{
	new TDIB256Palette((TComponent*)NULL);
}
//---------------------------------------------------------------------------
__fastcall TDIB256Palette::TDIB256Palette(TComponent *Owner)
: TCustomControl(Owner)
{
  ControlStyle = ControlStyle << csOpaque;
	FNumXSquares = 8;
	FNumYSquares = 6;
  FTab = 2;
  FStart = 2;
	FChoiceIndex = 1; //2;
	FCursorIndex = 1; //2;
	Canvas->Pen->Color = clBlack;
	FDiagonalColor = (TColor)0x00EAEAEA;
  FDiagonalBorderColor = (TColor)0x00DCDCDC;
	FSelectionColor = clRed;
	SetBounds(0, 0, 100, 100);
	FScroll = new TScrollBar(this);
	FScroll->Parent = this;
  FScroll->Kind = sbVertical;
  FScroll->OnScroll = SBScroll;
	UpdateScrollBar(false);
	FSelectionWidth = 1;
}
//---------------------------------------------------------------------------
__fastcall TDIB256Palette::~TDIB256Palette()
{
  delete FScroll;
}
//---------------------------------------------------------------------------
void __fastcall TDIB256Palette::CreateWnd()
{
  TCustomControl::CreateWnd();
  SetWindowLong(Handle, GWL_STYLE, GetWindowLong(Handle, GWL_STYLE) | WS_CLIPSIBLINGS);
}
//---------------------------------------------------------------------------
void __fastcall TDIB256Palette::DrawSquare(int Which)
{
	int WinTop, WinLeft, i;
	TRect CellRect;

	if ((Which >= 0) && (Which < FNumXSquares*FNumYSquares) && (Palette != NULL)){
		i = Which + FStart;
    WinTop = (Which/FNumXSquares)*FCellYSize+2;
		WinLeft = (Which%FNumXSquares)*FCellXSize+2;
		CellRect = Bounds(WinLeft+FTab, WinTop+FTab, FCellXSize-(FTab*2), FCellYSize-(FTab*2));
		if (i < 252){
			if (ComponentState.Contains(csDesigning)){
  	    Canvas->Brush->Color = clGray;
				Canvas->Pen->Color = clGray;
        Canvas->Pen->Width = 1;
        Canvas->Rectangle(CellRect.Left, CellRect.Top, CellRect.Right+1, CellRect.Bottom+1);
      } else {
				if (Palette->ColorCount > i){
          try {
						Canvas->Brush->Color = Palette->Color[i];
						if (FChoiceIndex==i){
							if (FUseSelectionColor) Canvas->Pen->Color = FSelectionColor;
							else {
								if (Canvas->Brush->Color != clWhite){
									Canvas->Pen->Color = Palette->Color[i];
								}
								else {
									Canvas->Pen->Color = FDiagonalBorderColor;
								}
							}
							Canvas->Pen->Width = FSelectionWidth;
							Canvas->Rectangle(CellRect.Left-FSelectionWidth, CellRect.Top-FSelectionWidth, CellRect.Right+1+FTab, CellRect.Bottom+1+FTab);
						} else {
							if (Canvas->Brush->Color != clWhite){
								Canvas->Pen->Color = Palette->Color[i];
							}
							else {
								Canvas->Pen->Color = FDiagonalBorderColor;
							}

							Canvas->Pen->Width = 1;
              Canvas->Rectangle(CellRect.Left, CellRect.Top, CellRect.Right+1, CellRect.Bottom+1);
            }
          } catch(EAccessViolation &exception){
            Canvas->Brush->Color = clWhite;
						Canvas->Pen->Color = clWhite;
            Canvas->Pen->Width = 1;
            Canvas->Rectangle(CellRect.Left, CellRect.Top, CellRect.Right+1, CellRect.Bottom+1);
          }

        } else {
					Canvas->Brush->Color = FDiagonalColor;
          Canvas->Brush->Style = bsFDiagonal;
					Canvas->Pen->Color = FDiagonalBorderColor;
          Canvas->Pen->Width = 1;
          Canvas->Rectangle(CellRect.Left, CellRect.Top, CellRect.Right+1, CellRect.Bottom+1);
        }
      }
      Canvas->Pen->Style = psSolid;
    } else {
			Canvas->Brush->Color = clWhite;
      Canvas->Pen->Style = psClear;
      Canvas->Pen->Width = 1;
      Canvas->Rectangle(CellRect.Left, CellRect.Top, CellRect.Right+1, CellRect.Bottom+1);
    }
	}

//		if (i < 252){
//			if (ComponentState.Contains(csDesigning)){
//				Canvas->Brush->Color = clWhite;
//				Canvas->Pen->Color = clBlack;
//			}
//			else {
//				try {
//					Canvas->Brush->Color = Palette->Color[i];
//					if (FChoiceIndex==i){
//						Canvas->Pen->Color = Palette->Color[i];
//					}
//					else {
//						Canvas->Pen->Color = clBlack;
//					}
//				}
//				catch(EAccessViolation &exception){
//					Canvas->Brush->Color = clWhite;
//					Canvas->Pen->Color = clBlack;
//				}
//			}
//			Canvas->Pen->Style = psSolid;
//			Canvas->Pen->Width = 3;
//		} else {
//			Canvas->Brush->Color = clBlack;
//			Canvas->Pen->Style = psClear;
//		}
//
//		//Canvas->Rectangle(CellRect.Left, CellRect.Top, CellRect.Right+1, CellRect.Bottom+1);
//		Canvas->Rectangle(CellRect.Left, CellRect.Top, CellRect.Right, CellRect.Bottom);
//		Canvas->Pen->Color = clGray;
//		Canvas->Pen->Width = 1;
//		Canvas->MoveTo(CellRect.Right, CellRect.Top+1);
//		Canvas->LineTo(CellRect.Right, CellRect.Bottom-1);
//		Canvas->LineTo(CellRect.Left+1, CellRect.Bottom-1);
//	}
}
 //---------------------------------------------------------------------------
void __fastcall TDIB256Palette::WMGetDlgCode(Messages::TWMNoParams &Message)
{
  Message.Result = DLGC_WANTARROWS + DLGC_WANTCHARS;
}
//---------------------------------------------------------------------------
void __fastcall TDIB256Palette::WMSize(Messages::TWMSize &Message)
{
  TCustomControl::Dispatch(&Message);
  UpdateCellSizes(false);
  UpdateScrollBar(false);
}
//---------------------------------------------------------------------------
void __fastcall TDIB256Palette::CMCtl3DChanged(Messages::TMessage &Message)
{
  TCustomControl::Dispatch(&Message);
  Invalidate();
}
//---------------------------------------------------------------------------
void __fastcall TDIB256Palette::MouseDown(TMouseButton Button, TShiftState Shift,
  int X, int Y)
{
	if (Button == mbLeft) SetChoiceIndex(MouseCoord(X, Y));
  if (TabStop) SetFocus();
  Invalidate();
  TCustomControl::MouseDown(Button, Shift, X, Y);
}
//---------------------------------------------------------------------------
void __fastcall TDIB256Palette::MouseMove(TShiftState Shift, int X, int Y)
{
	FCursorIndex = MouseCoord(X, Y);
	if (FOnCursorIndexChange) FOnCursorIndexChange(this);
  TCustomControl::MouseMove(Shift, X, Y);
}
//---------------------------------------------------------------------------
void __fastcall TDIB256Palette::Paint()
{
	int Row, Col, wEntryIndex;

	Canvas->Brush->Style = bsSolid;
	Canvas->Brush->Color = clWhite;//clBlack;
	Canvas->FillRect(ClientRect);
	Canvas->Font = Font;
	Canvas->Pen->Color = clSilver;
	Canvas->Pen->Width = 1;
	Canvas->MoveTo(Width-2, 0);
	Canvas->LineTo(Width-2, Height-1);
	Canvas->LineTo(0, Height-1);
	Canvas->LineTo(0, 0);
	Canvas->LineTo(Width-2, 0);

	for (Row = 0; Row < FNumYSquares; Row++){
		for (Col = 0; Col < FNumXSquares; Col++){
			wEntryIndex = Row * FNumXSquares + Col;
			DrawSquare(wEntryIndex);
		}
	}

// TRect rtRectPaint;
//
//	Canvas->Brush->Color = clBlack;
//	rtRectPaint = TRect(ClientRect);
//	rtRectPaint.right = rtRectPaint.right - FScroll->Width;
//	Canvas->FillRect(rtRectPaint);
//	Canvas->Font = Font;
//
//	for (Row = 0; Row < FNumYSquares; Row++){
//		for (Col = 0; Col < FNumXSquares; Col++){
//			wEntryIndex = Row * FNumXSquares + Col;
//			DrawSquare(wEntryIndex);
//		}
//	}
}
//---------------------------------------------------------------------------
void __fastcall TDIB256Palette::SBScroll(TObject* Sender, TScrollCode ScrollCode,
  int &ScrollPos)
{
  FStart = 2+ScrollPos*FNumXSquares;
  Repaint();
}
//---------------------------------------------------------------------------
void __fastcall TDIB256Palette::UpdateCellSizes(bool DoRepaint)
{
  BoundsRect = Bounds(Left, Top, Width , Height);
  FCellXSize = (Width - 16)/FNumXSquares;
	FCellYSize = (Height - 4)/FNumYSquares;
//	FCellXSize = (Width - 16)/FNumXSquares;
//	FCellYSize = Height/FNumYSquares;
	if (DoRepaint) Invalidate();
}
//---------------------------------------------------------------------------
void __fastcall TDIB256Palette::UpdateScrollBar(bool Setting)
{
  FScroll->Width = 15;
  FScroll->Height = Height;
  FScroll->Visible = true;
  FScroll->Left = Width - 15;
  FScroll->Min = 0;
  if (Setting){
    if ((250/FNumXSquares)*FNumXSquares != 250){
      FScroll->Max = (250/FNumXSquares)+1-FNumYSquares;
    } else {
      FScroll->Max = (250/FNumXSquares)-FNumYSquares;
    }
    FScroll->LargeChange = FNumYSquares;
    FScroll->SmallChange = 1;
  } else {
    FScroll->Max = 0;
  }
}
//---------------------------------------------------------------------------
void __fastcall TDIB256Palette::ColorChange()
{
  Changed();
  if (FOnColorChange) FOnColorChange(this);
  Invalidate();
}
//---------------------------------------------------------------------------
//{ Get }
//---------------------------------------------------------------------------
WORD __fastcall TDIB256Palette::GetUseColor()
{
	return Palette->UseColor;
}
//---------------------------------------------------------------------------
WORD __fastcall TDIB256Palette::GetColorCount()
{
	return Palette->ColorCount;
}
//---------------------------------------------------------------------------
TColor __fastcall TDIB256Palette::GetFGColor()
{
  return Palette->Color[FChoiceIndex];
}
//---------------------------------------------------------------------------
TColor __fastcall TDIB256Palette::GetBGColor()
{
  return Palette->Color[BackgroundIndex];
}
//---------------------------------------------------------------------------
TColor __fastcall TDIB256Palette::GetCursorColor()
{
  return Palette->Color[FCursorIndex];
}
//---------------------------------------------------------------------------
tagRGBQUAD __fastcall TDIB256Palette::GetForegroundRgb()
{
  return Palette->ColorData[FChoiceIndex]->RGB;
}
//---------------------------------------------------------------------------
tagRGBQUAD __fastcall TDIB256Palette::GetBackgroundRgb()
{
  return Palette->ColorData[BackgroundIndex]->RGB;
}
//---------------------------------------------------------------------------
//{ Set }
//---------------------------------------------------------------------------
void __fastcall TDIB256Palette::SetChoiceIndex(BYTE Value)
{
  int i;
	if (Palette != NULL){
		if (FChoiceIndex != Value){
			FOldColor = FChoiceIndex;
			//FChoiceIndex = Value;
			if (Value >= Palette->ColorCount){
				Palette->ColorCount = Value + 1;
				FChoiceIndex = Value;
				//FChoiceIndex = Palette->ColorCount - 1;
			} else {
				FChoiceIndex = Value;
			}
			if ((FChoiceIndex < FStart) || (FChoiceIndex>=FStart+FNumXSquares*FNumYSquares)){
				i = ((FChoiceIndex-1)/FNumXSquares)-(FNumYSquares/2);
				if (i<0) i = 0;
				else if (i > FScroll->Max) i = FScroll->Max;
				FStart = 2+i*FNumXSquares;
				FScroll->Position = i;
			}
			if (Palette->UseColor < Value) Palette->UseColor = Value;
			DrawSquare(FChoiceIndex);
		  if (FOnChoiceIndexChange) FOnChoiceIndexChange(this);
			Invalidate();
		}
	}
}
//---------------------------------------------------------------------------
void __fastcall TDIB256Palette::SetCursorIndex(BYTE Value)
{
  if (FCursorIndex != Value){
    FCursorIndex = Value;
		if (FOnCursorIndexChange) FOnCursorIndexChange(this);
  }
}
//---------------------------------------------------------------------------
void __fastcall TDIB256Palette::SetNumXSquares(int Value)
{
  if ((Value>0) && (Value<=16) && (FNumXSquares != Value)){
    FNumXSquares = Value;
		UpdateCellSizes(true);
    UpdateScrollBar(true);
  }
}
//---------------------------------------------------------------------------
void __fastcall TDIB256Palette::SetNumYSquares(int Value)
{
	if ((Value>0) && (Value<=16) && (FNumYSquares != Value)){
    FNumYSquares = Value;
    UpdateCellSizes(true);
    UpdateScrollBar(true);
  }
}
//---------------------------------------------------------------------------
void __fastcall TDIB256Palette::SetTab(int Value)
{
  if ((Value>=1) && (Value<=6) && (FTab != Value)){
    FTab = Value;
    Invalidate();
  }
}
//---------------------------------------------------------------------------
void __fastcall TDIB256Palette::SetUseColor(WORD Value)
{
  if (Palette->UseColor != 0){
    Palette->UseColor = Value;
	  if (FOnUseColorChange) FOnUseColorChange(this);
  }
}
//---------------------------------------------------------------------------
//{ System }
//---------------------------------------------------------------------------
int __fastcall TDIB256Palette::MouseCoord(int X, int Y)
{
  int result = 0;

  if (X > Width - 1) X = Width - 16;
  else if (X < 0) X = 0;
  if (Y > Height - 1) Y = Height - 1;
  else if (Y < 0) Y = 0;
  result = ((Y/FCellYSize) * FNumXSquares + (X/FCellXSize)) + FStart;
  if (result >= 251) result = 251;

  return result;
}
//---------------------------------------------------------------------------
COLORREF __fastcall TDIB256Palette::GetFGCOLORREF(int bpp)
{
  unsigned result;
	if (bpp == 8){
  	result = PALETTEINDEX(FChoiceIndex);
  } else {
		result = Palette->Color[FChoiceIndex];
  }
  return result;
}
//---------------------------------------------------------------------------
COLORREF __fastcall TDIB256Palette::GetBGCOLORREF(int bpp)
{
  unsigned result;
	if (bpp == 8){
  	result = PALETTEINDEX(BackgroundIndex);
  } else {
  	result = Palette->Color[BackgroundIndex];
  }
  return result;
}
//---------------------------------------------------------------------------
void __fastcall TDIB256Palette::LoadFromFile(Char *FileName)
{
	Palette->LoadFromFile(FileName);
  UpdateCellSizes(true);
  UpdateScrollBar(true);
  ColorChange();
  if (FOnCursorIndexChange) FOnCursorIndexChange(this);
  if (FOnUseColorChange) FOnUseColorChange(this);
}
//---------------------------------------------------------------------------
void __fastcall TDIB256Palette::SaveToFile(Char *FileName)
{
  Palette->SaveToFile(FileName);
}
//---------------------------------------------------------------------------
void __fastcall TDIB256Palette::SetPalette(TPalette *p)
{
	Palette = p;
	if (Palette){
		int colorcount = p->ColorCount;
		for (int i = colorcount; i < 255; i++){
			Palette->SetNormal(i, 255, 255, 255);
			//Palette->SetNormal(i, 0, 0, 0);
		}
		Palette->SetNormal(255, 255, 255, 255);
		Palette->ColorCount = colorcount;
	}

	UpdateCellSizes(true);
  UpdateScrollBar(true);
  if (Palette != NULL){
    ColorChange();
		if (FOnCursorIndexChange) FOnCursorIndexChange(this);
    if (FOnUseColorChange) FOnUseColorChange(this);
  }
}
//---------------------------------------------------------------------------
void __fastcall TDIB256Palette::Copy(int i, TColorData *cm)
{
	Palette->Copy(i, cm);
	ColorChange();
	if (Palette->ColorCount <= i) Palette->ColorCount = i + 1;
}
//---------------------------------------------------------------------------
void __fastcall TDIB256Palette::SetNormal(int i, BYTE r, BYTE g, BYTE b)
{
	Palette->SetNormal(i, r, g, b);
	ColorChange();
	if (Palette->ColorCount <= i) Palette->ColorCount++;
}
//---------------------------------------------------------------------------
void __fastcall TDIB256Palette::SetPrinterColor(int i, WORD p, BYTE n, BYTE r, BYTE g, BYTE b)
{
	Palette->SetPrinterColor(i, p, n, r, g, b);
	ColorChange();
	if (Palette->ColorCount <= i) Palette->ColorCount++;
}
//---------------------------------------------------------------------------
void __fastcall TDIB256Palette::SetPantone1000(int i, WORD p, BYTE n, BYTE r, BYTE g, BYTE b)
{
	Palette->SetPantone1000(i, p, n, r, g, b);
	ColorChange();
	if (Palette->ColorCount <= i) Palette->ColorCount++;
}
//---------------------------------------------------------------------------
void __fastcall TDIB256Palette::SetPantoneTextile(int i, WORD p, BYTE n, BYTE r, BYTE g, BYTE b)
{
	Palette->SetPantoneTextile(i, p, n, r, g, b);
	ColorChange();
	if (Palette->ColorCount <= i) Palette->ColorCount++;
}
//---------------------------------------------------------------------------
void __fastcall TDIB256Palette::SetTPStandardColor(int i, WORD p, BYTE n, BYTE r, BYTE g, BYTE b)
{
	Palette->SetTPStandardColor(i, p, n, r, g, b);
	ColorChange();
	if (Palette->ColorCount <= i) Palette->ColorCount++;
}
//---------------------------------------------------------------------------
void __fastcall TDIB256Palette::SetTPTextileColor(int i, WORD p, BYTE n, BYTE r, BYTE g, BYTE b)
{
	Palette->SetTPTextileColor(i, p, n, r, g, b);
	ColorChange();
	if (Palette->ColorCount <= i) Palette->ColorCount++;
}
//---------------------------------------------------------------------------
void __fastcall TDIB256Palette::SetUserColor(int i, WORD k, WORD p,
	BYTE n, BYTE r, BYTE g, BYTE b, Char *fn, Char *cn, Char *pc, Char *pf)
{
	Palette->SetUserColor(i, k, p, n, r, g, b, fn, cn, pc, pf);
	ColorChange();
	if (Palette->ColorCount <= i) Palette->ColorCount++;
}
//---------------------------------------------------------------------------
void __fastcall TDIB256Palette::SetPantoneColor(int i, WORD p, BYTE n, BYTE r, BYTE g, BYTE b)
{
  Palette->SetPantoneColor(i, p, n, r, g, b);
	ColorChange();
	if (Palette->ColorCount <= i) Palette->ColorCount++;
}
//---------------------------------------------------------------------------
void __fastcall TDIB256Palette::SetUserColor(int i, void *data)
{
  Palette->SetUserColor(i, data);
	ColorChange();
	if (Palette->ColorCount <= i) Palette->ColorCount++;
}
//---------------------------------------------------------------------------
///PANTONE Color Ãß°¡·Î »ý±â°Ô µÊ. ¼Ó¼º¹øÈ£´Â 6 ¹øÀ» ºÎ¿©ÇÔ by smallpotato(2008.03.07)
void __fastcall TDIB256Palette::SetPantoneColor2(int i, void *data)
{
	Palette->SetPantoneColor2(i, data);
	ColorChange();
	if (Palette->ColorCount <= i) Palette->ColorCount++;
}
//---------------------------------------------------------------------------
void __fastcall TDIB256Palette::SetDiagonalColor(TColor Value)
{
  FDiagonalColor = Value;
}
//---------------------------------------------------------------------------
void __fastcall TDIB256Palette::SetDiagonalBorderColor(TColor Value)
{
  FDiagonalBorderColor = Value;
}
//---------------------------------------------------------------------------
void __fastcall TDIB256Palette::SetSelectionColor(TColor Value)
{
	FSelectionColor = Value;
}
//---------------------------------------------------------------------------
void __fastcall TDIB256Palette::SetColor(int pos)
{
	SetNormal(pos, 100, 0, 0);
  //FColorCount++;
}
//---------------------------------------------------------------------------
void __fastcall TDIB256Palette::SetSelectionWidth(int Value)
{
	FSelectionWidth = Value;
}
//---------------------------------------------------------------------------
void __fastcall TDIB256Palette::SetPosition(int Value)
{
	FScroll->Position += Value;
  if (FScroll->Position < 0) FScroll->Position = 0;
	if (FScroll->Position > FScroll->Max) FScroll->Position = FScroll->Max;
  FStart = 2 + FScroll->Position*FNumXSquares;
	Repaint();
}
//---------------------------------------------------------------------------
void __fastcall TDIB256Palette::LeaveUseColorOnly()
{
	int colorcount = Palette->UseColor + 1;
	for (int i = colorcount; i < 256; i++){
		SetNormal(i, 255, 255, 255); //SetNormal(i, 0, 0, 0);    //shin palette add ColorCount
	}
	Palette->ColorCount = Palette->UseColor + 1;  //shin palette add ColorCount
	Repaint();
}
//---------------------------------------------------------------------------
void __fastcall TDIB256Palette::ClearAll()
{
	for (int i = 0; i < 256; i++){
		SetNormal(i, 255, 255, 255); //SetNormal(i, 0, 0, 0);    //shin palette add ColorCount
	}
	Repaint();
}

namespace Dib256s
{
  void __fastcall PACKAGE Register()
  {
    TComponentClass classes[1] = {__classid(TDIB256Palette)};
    RegisterComponents("Texpia", classes, 0);
  }
}
//---------------------------------------------------------------------------