uColorPickerControls.pas

{ uColorPickerControls.pas
  Custom Color Picker Controls v1.9
  ------------------------------------------------------------------------------
  Contains the custom controls used by the Color Picker:
    • TBufferedControl  - Flicker-reduced base control
    • TSVSquare         - Interactive color selection surface
    • THueBar           - Hue / Saturation / Lightness control bar
    • TColorSwatch      - Color preview control
  Includes gradient caching, smooth selector animation and mouse interaction.

  Developer : Shohanur Rahman
  Publisher : SR Studio 24 - BD
  Copyright : © 2026 SR Studio 24 - BD
  Website   : https://srstudio24.blogspot.com/

  IMPORTANT:
  Mode mapping, gradient generation, cache, animation and mouse handling
  are core logic. Do not modify without checking uCustomColorDlg.pas.

  Internal project code.
  Unauthorized modification or redistribution is not permitted.
}
unit uColorPickerControls;

interface

uses
  Winapi.Windows, Winapi.Messages, Winapi.MMSystem, System.SysUtils, System.Classes, Vcl.ExtCtrls,
  System.Types, System.Math, Vcl.Graphics, Vcl.Controls, Vcl.Forms;

type
  TBufferedControl = class(TCustomControl)
  private
    FOnPaint: TNotifyEvent;
  protected
    procedure Paint; override;
    procedure WMEraseBkgnd(var Message: TWMEraseBkgnd); message WM_ERASEBKGND;
    procedure CMFontChanged(var Message: TMessage); message CM_FONTCHANGED;
    procedure CMColorChanged(var Message: TMessage); message CM_COLORCHANGED;
  public
    constructor Create(AOwner: TComponent); override;
    property Canvas;
    property OnPaint: TNotifyEvent read FOnPaint write FOnPaint;
  end;

  TSVSquareMode = (ssmSatBri, ssmHueBri, ssmHueSat);

  TSVSquare = class(TBufferedControl)
  private
    FHue, FSat, FBri: Integer;
    FMode: TSVSquareMode;
    FCache: TBitmap;
    FDisplayBmp: TBitmap;
    FCacheKey: string;
    FOnChange: TNotifyEvent;
    FDragging: Boolean;
    FDisplaySat, FDisplayBri, FTargetSat, FTargetBri: Double;
    FAnimationSpeed: Double;
    FUpdateTimer: TTimer;
    FLastAnimationTick: UInt64;
    procedure SetHue(Value: Integer);
    procedure SetSat(Value: Integer);
    procedure SetBri(Value: Integer);
    procedure SetMode(Value: TSVSquareMode);
    procedure RebuildCache;
    procedure RestretchDisplay;
    procedure UpdateTimerTick(Sender: TObject);
    procedure UpdateAnimation;
    procedure DoChange;
    function GetCacheKey: string;
  protected
    procedure Paint; override;
    procedure Resize; override;
    procedure MouseDown(Button: TMouseButton; Shift: TShiftState; X, Y: Integer); override;
    procedure MouseMove(Shift: TShiftState; X, Y: Integer); override;
    procedure MouseUp(Button: TMouseButton; Shift: TShiftState; X, Y: Integer); override;
    procedure CMCancelMode(var Message: TMessage); message CM_CANCELMODE;
  public
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;
    property Hue: Integer read FHue write SetHue;
    property Sat: Integer read FSat write SetSat;
    property Bri: Integer read FBri write SetBri;
    property Mode: TSVSquareMode read FMode write SetMode;
    property OnChange: TNotifyEvent read FOnChange write FOnChange;
    procedure ForceRebuild;
  end;

  THueBarMode = (hbmHue, hbmSat, hbmLight);

  THueBar = class(TBufferedControl)
  private
    FHue, FSat, FBri: Integer;
    FMode: THueBarMode;
    FCache: TBitmap;
    FOnChange: TNotifyEvent;
    FDragging: Boolean;
    procedure SetHue(Value: Integer);
    procedure SetSat(Value: Integer);
    procedure SetBri(Value: Integer);
    procedure SetMode(Value: THueBarMode);
    procedure RebuildCache;
    procedure DoChange;
  protected
    procedure Paint; override;
    procedure MouseDown(Button: TMouseButton; Shift: TShiftState; X, Y: Integer); override;
    procedure MouseMove(Shift: TShiftState; X, Y: Integer); override;
    procedure MouseUp(Button: TMouseButton; Shift: TShiftState; X, Y: Integer); override;
    procedure CMCancelMode(var Message: TMessage); message CM_CANCELMODE;
  public
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;
    property Hue: Integer read FHue write SetHue;
    property Sat: Integer read FSat write SetSat;
    property Bri: Integer read FBri write SetBri;
    property Mode: THueBarMode read FMode write SetMode;
    property OnChange: TNotifyEvent read FOnChange write FOnChange;
    property IsDragging: Boolean read FDragging;
  end;

  TColorSwatch = class(TBufferedControl)
  private
    FColor: TColor;
    FShowBorder: Boolean;
    procedure SetColor(Value: TColor);
    procedure SetShowBorder(Value: Boolean);
  protected
    procedure Paint; override;
  public
    constructor Create(AOwner: TComponent); override;
    property Color: TColor read FColor write SetColor;
    property ShowBorder: Boolean read FShowBorder write SetShowBorder;
    property OnClick;
  end;

implementation

uses
  uColorUtils;

// Delphi XE2 .. 10.3 compatibility (GetTickCount64 added later in Winapi.Windows)
function GetTickCount64: UInt64; stdcall; external kernel32 name 'GetTickCount64';

{ TBufferedControl }

constructor TBufferedControl.Create(AOwner: TComponent);
begin
  inherited Create(AOwner);
  ControlStyle := ControlStyle + [csOpaque, csCaptureMouse, csClickEvents, csReplicatable];
  DoubleBuffered := True;
  ParentBackground := False;
  TabStop := False;
end;

procedure TBufferedControl.Paint;
begin
  if Assigned(FOnPaint) then FOnPaint(Self);
end;

procedure TBufferedControl.WMEraseBkgnd(var Message: TWMEraseBkgnd);
begin
  Message.Result := 1;
end;

procedure TBufferedControl.CMFontChanged(var Message: TMessage);
begin
  inherited; Invalidate;
end;

procedure TBufferedControl.CMColorChanged(var Message: TMessage);
begin
  inherited; Invalidate;
end;

{ TSVSquare }

constructor TSVSquare.Create(AOwner: TComponent);
begin
  inherited Create(AOwner);
  FCache := TBitmap.Create;
  FCache.PixelFormat := pf24bit;
  FCache.SetSize(512, 512);
  FDisplayBmp := TBitmap.Create;
  FDisplayBmp.PixelFormat := pf24bit;
  FDisplayBmp.SetSize(256, 256);
  FCacheKey := '';
  FHue := 0; FSat := 100; FBri := 100;
  FMode := ssmSatBri;
  FDragging := False;
  FDisplaySat := 100; FDisplayBri := 100;
  FTargetSat := 100; FTargetBri := 100;
  FAnimationSpeed := 22.0;
  FLastAnimationTick := 0;
  Width := 256; Height := 256;
  FUpdateTimer := TTimer.Create(Self);
  FUpdateTimer.Interval := 4;
  FUpdateTimer.Enabled := False;
  FUpdateTimer.OnTimer := UpdateTimerTick;
end;

destructor TSVSquare.Destroy;
begin
  if FDragging then
  begin
    FDragging := False;
    timeEndPeriod(1);
    if GetCapture = Handle then ReleaseCapture;
  end;
  FUpdateTimer.Free;
  FDisplayBmp.Free;
  FCache.Free;
  inherited;
end;

procedure TSVSquare.CMCancelMode(var Message: TMessage);
begin
  inherited;
  if FDragging then
  begin
    FDragging := False;
    timeEndPeriod(1);
    FUpdateTimer.Enabled := False;
    if GetCapture = Handle then ReleaseCapture;
  end;
end;

function TSVSquare.GetCacheKey: string;
begin
  case FMode of
    ssmSatBri: Result := Format('SV_%d', [FHue]);
    ssmHueBri: Result := Format('HV_%d', [FHue]); // fixed Bri এখন FHue-তে
    ssmHueSat: Result := Format('HS_%d', [FBri]);
  end;
end;

procedure TSVSquare.SetMode(Value: TSVSquareMode);
begin
  if FMode <> Value then
  begin
    FMode := Value;
    FCacheKey := '';
    RebuildCache;
    Invalidate;
  end;
end;

procedure TSVSquare.SetHue(Value: Integer);
begin
  Value := ((Value mod 360) + 360) mod 360;
  if FHue <> Value then
  begin
    FHue := Value;
    FCacheKey := '';
    RebuildCache;
    Invalidate;
  end;
end;

procedure TSVSquare.SetSat(Value: Integer);
begin
  Value := EnsureRange(Value, 0, 100);
  if FSat <> Value then
  begin
    FSat := Value;
    FDisplaySat := Value;
    FTargetSat := Value;
    Invalidate;
  end;
end;

procedure TSVSquare.SetBri(Value: Integer);
begin
  Value := EnsureRange(Value, 0, 100);
  if FBri <> Value then
  begin
    FBri := Value;
    FDisplayBri := Value;
    FTargetBri := Value;
    if FMode = ssmHueSat then
    begin
      FCacheKey := '';
      RebuildCache;
    end;
    Invalidate;
  end;
end;

procedure TSVSquare.RebuildCache;
var
  x, y: Integer;
  R, G, B: Byte;
  P: PByteArray;
  Hf, Sf, Vf, C, Xv, M, Rf, Gf, Bf: Double;
  Hi: Integer;
  Key: string;
begin
  Key := GetCacheKey;
  if Key = FCacheKey then Exit;
  FCacheKey := Key;
  for y := 0 to 511 do
  begin
    P := FCache.ScanLine[y];
    for x := 0 to 511 do
    begin
      case FMode of
        ssmSatBri:
          begin
            Sf := x / 511.0;
            Vf := (511 - y) / 511.0;
            Hf := FHue / 60.0;
            C := Vf * Sf;
            Xv := C * (1.0 - Abs(Frac(Hf * 0.5) * 2.0 - 1.0));
            M := Vf - C;
            Hi := Trunc(Hf) mod 6;
            case Hi of
              0: begin Rf := C; Gf := Xv; Bf := 0; end;
              1: begin Rf := Xv; Gf := C; Bf := 0; end;
              2: begin Rf := 0; Gf := C; Bf := Xv; end;
              3: begin Rf := 0; Gf := Xv; Bf := C; end;
              4: begin Rf := Xv; Gf := 0; Bf := C; end;
            else begin Rf := C; Gf := 0; Bf := Xv; end;
            end;
            R := EnsureRange(Round((Rf + M) * 255.0), 0, 255);
            G := EnsureRange(Round((Gf + M) * 255.0), 0, 255);
            B := EnsureRange(Round((Bf + M) * 255.0), 0, 255);
          end;
        ssmHueBri:
          begin
            // S mode নতুন অর্থ: X = Hue, Y = Sat, fixed = Bri (FHue)
            Hf := (x / 511.0) * 6.0;
            Sf := (511 - y) / 511.0; // Y = Saturation
            Vf := FHue / 100.0; // fixed Brightness
            C := Vf * Sf;
            Xv := C * (1.0 - Abs(Frac(Hf * 0.5) * 2.0 - 1.0));
            M := Vf - C;
            Hi := Trunc(Hf) mod 6;
            case Hi of
              0: begin Rf := C; Gf := Xv; Bf := 0; end;
              1: begin Rf := Xv; Gf := C; Bf := 0; end;
              2: begin Rf := 0; Gf := C; Bf := Xv; end;
              3: begin Rf := 0; Gf := Xv; Bf := C; end;
              4: begin Rf := Xv; Gf := 0; Bf := C; end;
            else begin Rf := C; Gf := 0; Bf := Xv; end;
            end;
            R := EnsureRange(Round((Rf + M) * 255.0), 0, 255);
            G := EnsureRange(Round((Gf + M) * 255.0), 0, 255);
            B := EnsureRange(Round((Bf + M) * 255.0), 0, 255);
          end;
        ssmHueSat:
          begin
            HSLtoRGBValues(
              Round((x / 511.0) * 359.0),
              Round(((511 - y) / 511.0) * 100.0),
              FHue, // fixed Lightness
              R, G, B);
          end;
      end;
      P[x * 3 + 0] := B;
      P[x * 3 + 1] := G;
      P[x * 3 + 2] := R;
    end;
  end;
  // Expensive HALFTONE resample now happens ONCE here (only when the
  // gradient content actually changed), instead of on every Paint().
  RestretchDisplay;
end;

procedure TSVSquare.RestretchDisplay;
var
  OldMode: Integer;
begin
  if (FDisplayBmp = nil) or (FDisplayBmp.Width <= 0) or (FDisplayBmp.Height <= 0) then Exit;
  OldMode := SetStretchBltMode(FDisplayBmp.Canvas.Handle, HALFTONE);
  SetBrushOrgEx(FDisplayBmp.Canvas.Handle, 0, 0, nil);
  FDisplayBmp.Canvas.StretchDraw(Rect(0, 0, FDisplayBmp.Width, FDisplayBmp.Height), FCache);
  SetStretchBltMode(FDisplayBmp.Canvas.Handle, OldMode);
end;

procedure TSVSquare.Resize;
begin
  inherited;
  if (FDisplayBmp <> nil) and (Width > 0) and (Height > 0) then
  begin
    FDisplayBmp.SetSize(Width, Height);
    RestretchDisplay;
  end;
end;

procedure TSVSquare.Paint;
var
  cx, cy: Integer;
begin
  RebuildCache;
  // Safety net: keep display bitmap in sync even if a Resize message was
  // ever missed (e.g. programmatic size change) - identical output,
  // negligible cost (two integer compares) on the common path.
  if (FDisplayBmp.Width <> Width) or (FDisplayBmp.Height <> Height) then
  begin
    FDisplayBmp.SetSize(Width, Height);
    RestretchDisplay;
  end;
  Canvas.Draw(0, 0, FDisplayBmp);
  cx := Round(FDisplaySat * 255 / 100);
  cy := Round((100 - FDisplayBri) * 255 / 100);
  Canvas.Brush.Style := bsClear;
  Canvas.Pen.Color := clWhite;
  Canvas.Pen.Width := 2;
  Canvas.Ellipse(cx - 6, cy - 6, cx + 7, cy + 7);
  Canvas.Pen.Color := clBlack;
  Canvas.Pen.Width := 1;
  Canvas.Ellipse(cx - 5, cy - 5, cx + 6, cy + 6);
end;

procedure TSVSquare.UpdateTimerTick(Sender: TObject);
begin
  UpdateAnimation;
end;

procedure TSVSquare.UpdateAnimation;
var
  NowTick: UInt64;
  DeltaMS, Alpha: Double;
  OldSat, OldBri: Double;
begin
  if not FDragging then
  begin
    FUpdateTimer.Enabled := False;
    Exit;
  end;
  NowTick := GetTickCount64;
  if FLastAnimationTick = 0 then FLastAnimationTick := NowTick;
  DeltaMS := NowTick - FLastAnimationTick;
  FLastAnimationTick := NowTick;
  if DeltaMS > 50 then DeltaMS := 50;
  OldSat := FDisplaySat; OldBri := FDisplayBri;
  Alpha := 1.0 - Exp(-FAnimationSpeed * DeltaMS / 1000.0);
  FDisplaySat := FDisplaySat + (FTargetSat - FDisplaySat) * Alpha;
  FDisplayBri := FDisplayBri + (FTargetBri - FDisplayBri) * Alpha;
  if Abs(FDisplaySat - FTargetSat) < 0.02 then FDisplaySat := FTargetSat;
  if Abs(FDisplayBri - FTargetBri) < 0.02 then FDisplayBri := FTargetBri;
  if (Abs(FDisplaySat - OldSat) > 0.001) or (Abs(FDisplayBri - OldBri) > 0.001) then
    Invalidate;
  if (Abs(FDisplaySat - FTargetSat) < 0.01) and (Abs(FDisplayBri - FTargetBri) < 0.01) then
  begin
    FDisplaySat := FTargetSat;
    FDisplayBri := FTargetBri;
  end;
end;

procedure TSVSquare.DoChange;
begin
  if Assigned(FOnChange) then FOnChange(Self);
end;

procedure TSVSquare.ForceRebuild;
begin
  FCacheKey := '';
  RebuildCache;
  Invalidate;
end;

procedure TSVSquare.MouseDown(Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
begin
  inherited;
  if Button <> mbLeft then Exit;
  FDragging := True;
  timeBeginPeriod(1); // raise Windows timer resolution for smooth per-frame animation while dragging
  FTargetSat := FSat; FTargetBri := FBri;
  FLastAnimationTick := GetTickCount64;
  SetCapture(Handle);
  FUpdateTimer.Enabled := True;
  MouseMove(Shift, X, Y);
end;

procedure TSVSquare.MouseMove(Shift: TShiftState; X, Y: Integer);
var
  NewS, NewB: Integer;
begin
  inherited;
  if not FDragging then Exit;
  X := EnsureRange(X, 0, Width - 1);
  Y := EnsureRange(Y, 0, Height - 1);
  if Width > 1 then NewS := Round(X * 100 / (Width - 1)) else NewS := 0;
  if Height > 1 then NewB := 100 - Round(Y * 100 / (Height - 1)) else NewB := 100;
  NewS := EnsureRange(NewS, 0, 100);
  NewB := EnsureRange(NewB, 0, 100);
  if (NewS <> FSat) or (NewB <> FBri) then
  begin
    FSat := NewS; FBri := NewB;
    FTargetSat := NewS; FTargetBri := NewB;
    DoChange;
  end;
  if not FUpdateTimer.Enabled then
  begin
    FLastAnimationTick := GetTickCount64;
    FUpdateTimer.Enabled := True;
  end;
end;

procedure TSVSquare.MouseUp(Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
begin
  inherited;
  if not FDragging then Exit;
  FDragging := False;
  timeEndPeriod(1);
  FDisplaySat := FTargetSat; FDisplayBri := FTargetBri;
  Invalidate;
  FUpdateTimer.Enabled := False;
  if GetCapture = Handle then ReleaseCapture;
end;

{ THueBar }

constructor THueBar.Create(AOwner: TComponent);
begin
  inherited Create(AOwner);
  FCache := TBitmap.Create;
  FCache.PixelFormat := pf24bit;
  FCache.SetSize(22, 256);
  FHue := 0; FSat := 100; FBri := 100;
  FMode := hbmHue;
  FDragging := False;
  Width := 22; Height := 256;
  RebuildCache;
end;

destructor THueBar.Destroy;
begin
  if FDragging then
  begin
    FDragging := False;
    if GetCapture = Handle then ReleaseCapture;
  end;
  FCache.Free;
  inherited;
end;

procedure THueBar.CMCancelMode(var Message: TMessage);
begin
  inherited;
  if FDragging then
  begin
    FDragging := False;
    if GetCapture = Handle then ReleaseCapture;
  end;
end;

procedure THueBar.SetHue(Value: Integer);
begin
  Value := ((Value mod 360) + 360) mod 360;
  if FHue <> Value then
  begin
    FHue := Value;
    // Hue feeds the fixed-color term in BOTH hbmSat and hbmLight gradients,
    // so both modes must rebuild - unchanged from original behavior.
    if FMode <> hbmHue then RebuildCache;
    Invalidate;
  end;
end;

procedure THueBar.SetSat(Value: Integer);
begin
  Value := EnsureRange(Value, 0, 100);
  if FSat <> Value then
  begin
    FSat := Value;
    // hbmSat-এ এখন Sat fixed → rebuild লাগে
    if (FMode = hbmLight) or (FMode = hbmSat) then RebuildCache;
    Invalidate;
  end;
end;

procedure THueBar.SetBri(Value: Integer);
begin
  Value := EnsureRange(Value, 0, 100);
  if FBri <> Value then
  begin
    FBri := Value;
    // hbmSat-এ Bri এখন axis → gradient rebuild লাগে না
    if FMode = hbmLight then RebuildCache;
    Invalidate;
  end;
end;

procedure THueBar.SetMode(Value: THueBarMode);
begin
  if FMode <> Value then
  begin
    FMode := Value;
    RebuildCache;
    Invalidate;
  end;
end;

procedure THueBar.RebuildCache;
var
  y, x: Integer;
  Hval, Lval, BriVal: Integer;   // <-- BriVal এখানে যোগ করা হয়েছে (inline var সরানো হয়েছে)
  R, G, B: Byte;
  P: PByteArray;
begin
  for y := 0 to 255 do
  begin
    case FMode of
      hbmHue:
        begin
          Hval := 359 - (y * 359 div 255);
          HSBtoRGBValues(Hval, 100, 100, R, G, B);
        end;
      hbmSat:
        begin
          // S mode: Bri ভ্যারি করে (fixed Hue + fixed Sat)। টপ = পিওর কালার
          BriVal := 100 - (y * 100 div 255);
          HSBtoRGBValues(FHue, FSat, BriVal, R, G, B);
        end;
      hbmLight:
        begin
          Lval := 100 - (y * 100 div 255);
          HSLtoRGBValues(FHue, FSat, Lval, R, G, B);
        end;
    end;
    P := FCache.ScanLine[y];
    for x := 0 to 21 do
    begin
      P[x * 3 + 0] := B;
      P[x * 3 + 1] := G;
      P[x * 3 + 2] := R;
    end;
  end;
end;

procedure THueBar.Paint;
var
  cy: Integer;
  CurVal: Integer;
begin
  Canvas.Draw(0, 0, FCache);
  // Marker is drawn straight from the live value - no lerp/animation
  // buffer - so it always sits exactly where the mouse (or an external
  // Hue/Sat/Bri assignment) put it, with zero lag.
  case FMode of
    hbmHue: CurVal := FHue;
    hbmSat: CurVal := FBri; // <-- আগে FSat ছিল, এখন FBri
    hbmLight: CurVal := FBri;
  else
    CurVal := 0;
  end;
  case FMode of
    hbmHue: cy := Round((359 - CurVal) * 255 / 359);
    hbmSat: cy := Round((100 - CurVal) * 255 / 100);
    hbmLight: cy := Round((100 - CurVal) * 255 / 100);
  else
    cy := 0;
  end;
  Canvas.Brush.Style := bsClear;
  Canvas.Pen.Color := clWhite;
  Canvas.Pen.Width := 2;
  Canvas.Rectangle(1, cy - 3, 21, cy + 4);
  Canvas.Pen.Color := clBlack;
  Canvas.Pen.Width := 1;
  Canvas.Rectangle(2, cy - 2, 20, cy + 3);
end;

procedure THueBar.DoChange;
begin
  if Assigned(FOnChange) then FOnChange(Self);
end;

procedure THueBar.MouseDown(Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
begin
  inherited;
  if Button <> mbLeft then Exit;
  FDragging := True;
  SetCapture(Handle);
  MouseMove(Shift, X, Y);
end;

procedure THueBar.MouseMove(Shift: TShiftState; X, Y: Integer);
var
  NewVal: Integer;
begin
  inherited;
  if not FDragging then Exit;
  Y := EnsureRange(Y, 0, Height - 1);
  case FMode of
    hbmHue:
      begin
        if Height > 1 then NewVal := 359 - Round(Y * 359 / (Height - 1)) else NewVal := 359;
        NewVal := EnsureRange(NewVal, 0, 359);
        if NewVal <> FHue then
        begin
          FHue := NewVal;
          DoChange;
        end;
      end;
    hbmSat:
      begin
        if Height > 1 then NewVal := 100 - Round(Y * 100 / (Height - 1)) else NewVal := 100;
        NewVal := EnsureRange(NewVal, 0, 100);
        if NewVal <> FBri then // <-- আগে FSat ছিল
        begin
          FBri := NewVal;
          DoChange;
        end;
      end;
    hbmLight:
      begin
        if Height > 1 then NewVal := 100 - Round(Y * 100 / (Height - 1)) else NewVal := 100;
        NewVal := EnsureRange(NewVal, 0, 100);
        if NewVal <> FBri then
        begin
          FBri := NewVal;
          DoChange;
        end;
      end;
  end;
  // Force a SYNCHRONOUS repaint right now (not just an async Invalidate
  // request). Without this, Windows can keep delivering a burst of
  // WM_MOUSEMOVE messages before it ever gets around to the lower-priority
  // WM_PAINT - the value updates internally every message, but the screen
  // only catches up once at the end of the burst, which is exactly what
  // reads as "jumping" instead of a smooth 1:1 drag. Repaint forces the
  // paint to happen immediately, every single mouse move.
  Repaint;
end;

procedure THueBar.MouseUp(Button: TMouseButton; Shift: TShiftState; X, Y: Integer);
begin
  inherited;
  if not FDragging then Exit;
  FDragging := False;
  if GetCapture = Handle then ReleaseCapture;
end;

{ TColorSwatch }

constructor TColorSwatch.Create(AOwner: TComponent);
begin
  inherited Create(AOwner);
  FColor := clBlack;
  FShowBorder := True;
  Width := 60; Height := 60;
end;

procedure TColorSwatch.SetColor(Value: TColor);
begin
  if FColor <> Value then
  begin
    FColor := Value;
    Invalidate;
  end;
end;

procedure TColorSwatch.SetShowBorder(Value: Boolean);
begin
  if FShowBorder <> Value then
  begin
    FShowBorder := Value;
    Invalidate;
  end;
end;

procedure TColorSwatch.Paint;
begin
  Canvas.Brush.Color := FColor;
  Canvas.FillRect(ClientRect);
  if FShowBorder then
  begin
    Canvas.Brush.Style := bsClear;
    Canvas.Pen.Color := clWindowFrame;
    Canvas.Rectangle(0, 0, Width, Height);
  end;
end;

end.