FMX.UIOverlayLoader.pas

unit FMX.UIOverlayLoader;

{
  * ===========================================================================
  * MEStackCodes - 2025
  * FMX.UIOverlayLoader - Displaying a OverlayLoader for Delphi/FMX
  * https://github.com/MEStackCodes
  * ---------------------------------------------------------------------------
  * Distributed under the MIT software license.
  * ===========================================================================
}

interface

uses
  System.SysUtils,
  System.Classes,
  System.UITypes,
  System.Skia,
  System.Types,
  FMX.Types,
  FMX.Objects,
  FMX.Layouts,
  FMX.Graphics,
  FMX.Controls,
  FMX.Controls.Presentation,
  FMX.Skia,
  FMX.Ani;

type

  TSpinnerType = (stModel1, stModel2, stCustom);
  TSpinnerMotion = (Linear, Quadratic, Cubic, Quartic, Quintic, Sinusoidal, Exponential, Circular, Elastic, Back, Bounce);
  TSpinnerSize = (ssSmall = 48, ssMedium = 64, ssBig = 128, ssCustom = 0);

  TUIOverlayLoader = class(TComponent)
  private
    FBackgroundOpacity: Single;
    FBackgroundColor: TAlphaColor;
    FSpinnerColor: TAlphaColor;
    FSpinnerStrokeColor: TAlphaColor;
    FSpinnerOpacity: Single;
    FSpinnerVelocity: Single;
    FSpinnerType: TSpinnerType;
    FSpinnerSize: TSpinnerSize;
    FSpinnerBackgroundColor: TAlphaColor;
    FSpinnerBackgroundRadius: Single;
    FSpinnerBackgroundOpacity: Single;
    FPrimaryContainer: TLayout;
    FOverlayContainer: TPresentedControl;
    FOverlayBackground: TRectangle;
    FSpinnerContainer: TLayout;
    FSpinnerBackground: TRectangle;
    FSpinner: TSkSvg;
    FSpinnerAnimator: TFloatAnimation;
    FControlType: TControlType;
    FSpinnerHeight: Single;
    FSpinnerWidth: Single;
    FSpinnerMotion: TSpinnerMotion;
    FIsShowing: Boolean;
    FParentOverloading: TFMXObject;
    procedure SetControlType(const Value: TControlType);
    procedure SetBackgroundOpacity(const Value: Single);
    procedure SetBackgroundColor(const Value: TAlphaColor);
    procedure SetSpinnerColor(const Value: TAlphaColor);
    procedure SetSpinnerStrokeColor(const Value: TAlphaColor);
    procedure SetSpinnerOpacity(const Value: Single);
    procedure SetSpinnerType(const Value: TSpinnerType);
    procedure SetSpinnerSize(const Value: TSpinnerSize);
    procedure SetSpinnerBackgroundColor(const Value: TAlphaColor);
    procedure SetSpinnerBackgroundRadius(const Value: Single);
    procedure SetSpinnerBackgroundOpacity(const Value: Single);
    procedure SetSpinnerHeight(const Value: Single);
    procedure SetSpinnerWidth(const Value: Single);
    procedure SetSpinnerMotion(const Value: TSpinnerMotion);
    procedure SetSpinnerVelocity(const Value: Single);
  public
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;
    function IsShowing: Boolean;
    procedure Hide;
    procedure SetOverloadingForm(const AParent: TFMXObject);
    procedure Show;
    procedure LoadFromFile(const AFileSVGName: string);
    property SpinnerHeight: Single read FSpinnerHeight write SetSpinnerHeight;
    property SpinnerWidth: Single read FSpinnerWidth write SetSpinnerWidth;
    property SpinnerVelocity: Single read FSpinnerVelocity write SetSpinnerVelocity;
    property SpinnerMotion: TSpinnerMotion read FSpinnerMotion write SetSpinnerMotion;
    property ControlType: TControlType read FControlType write SetControlType;
    property BackgroundOpacity: Single read FBackgroundOpacity write SetBackgroundOpacity;
    property BackgroundColor: TAlphaColor read FBackgroundColor write SetBackgroundColor;
    property SpinnerColor: TAlphaColor read FSpinnerColor write SetSpinnerColor;
    property SpinnerStrokeColor: TAlphaColor read FSpinnerStrokeColor write SetSpinnerStrokeColor;
    property SpinnerOpacity: Single read FSpinnerOpacity write SetSpinnerOpacity;
    property SpinnerType: TSpinnerType read FSpinnerType write SetSpinnerType;
    property SpinnerSize: TSpinnerSize read FSpinnerSize write SetSpinnerSize;
    property SpinnerBackgroundColor: TAlphaColor read FSpinnerBackgroundColor write SetSpinnerBackgroundColor;
    property SpinnerBackgroundRadius: Single read FSpinnerBackgroundRadius write SetSpinnerBackgroundRadius;
    property SpinnerBackgroundOpacity: Single read FSpinnerBackgroundOpacity write SetSpinnerBackgroundOpacity;
  end;

  TSVGColorParser = class
  public
    class function ReplaceFillColor(const TextSVG: string; ReplaceColor: TAlphaColor): string; static;
    class function ReplaceStrokeColor(const TextSVG: string; ReplaceColor: TAlphaColor): string; static;
  end;

implementation

uses System.RegularExpressions;

const
  OLXmlHeader = '<?xml version="1.0" encoding="utf-8"?>';
  OLSvgHeader1 = '<svg width="24" height="24" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">';
  OLSvgHeader2 = '<svg width="25" height="25" viewBox="0 0 25 25" fill="none" xmlns="http://www.w3.org/2000/svg">';
  OLSvgFooter = '</svg>';
  OPath1 = '<path opacity="0.2" fill-rule="evenodd" clip-rule="evenodd" d="M12 19C15.866 19 19 15.866 19 12C19 8.13401 15.866 5 12 5C8.13401 5 5 8.13401 5 12C5 15.866 8.13401 19 12 19ZM12 22C17.5228 22 22 17.5228 22 12C22 6.47715 17.5228 2 12 2C6.47715 2 2 6.47715 2 12C2 17.5228 6.47715 22 12 22Z" fill="#000000"/><path d="M2 12C2 6.47715 6.47715 2 12 2V5C8.13401 5 5 8.13401 5 12H2Z" fill="#6750A4"/>';
  OPath2 = '<path d="M4.5 12.5C4.5 16.9183 8.08172 20.5 12.5 20.5C16.9183 20.5 20.5 16.9183 20.5 12.5C20.5 8.08172 16.9183 4.5 12.5 4.5" stroke="#6750A4" stroke-width="1.2"/>';

  // SVG Spinner Built-in Model
  SpinnerModel1 = OLXmlHeader + OLSvgHeader1 + OPath1 + OLSvgFooter;
  SpinnerModel2 = OLXmlHeader + OLSvgHeader2 + OPath2 + OLSvgFooter;

procedure TUIOverlayLoader.SetBackgroundOpacity(const Value: Single);
begin
  FBackgroundOpacity := Value;
  FOverlayBackground.Opacity := FBackgroundOpacity;
end;

procedure TUIOverlayLoader.SetControlType(const Value: TControlType);
begin
  FControlType := Value;
  FOverlayContainer.ControlType := FControlType;

  if (FControlType = TControlType.Platform) then
  begin
    FOverlayContainer.Opacity := 0.85;
  end
  else
  begin
    FOverlayContainer.Opacity := 1;
  end;
end;

procedure TUIOverlayLoader.SetBackgroundColor(const Value: TAlphaColor);
begin
  FBackgroundColor := Value;
  FOverlayBackground.Fill.Color := FBackgroundColor;
end;

procedure TUIOverlayLoader.SetSpinnerColor(const Value: TAlphaColor);
begin
  FSpinnerColor := Value;
  FSpinner.Svg.Source := TSVGColorParser.ReplaceFillColor(FSpinner.Svg.Source, FSpinnerColor);
end;

procedure TUIOverlayLoader.SetSpinnerStrokeColor(const Value: TAlphaColor);
begin
  FSpinnerStrokeColor := Value;
  FSpinner.Svg.Source := TSVGColorParser.ReplaceStrokeColor(FSpinner.Svg.Source, FSpinnerStrokeColor);
end;

procedure TUIOverlayLoader.SetSpinnerOpacity(const Value: Single);
begin
  FSpinnerOpacity := Value;
  FSpinner.Opacity := FSpinnerOpacity;
end;

procedure TUIOverlayLoader.SetSpinnerType(const Value: TSpinnerType);
begin
  FSpinnerType := Value;

  case FSpinnerType of
    stModel1:
      begin
        FSpinner.Svg.Source := SpinnerModel1;
        FSpinnerAnimator.Interpolation := TInterpolationType.Linear;
      end;
    stModel2:
      begin
        FSpinner.Svg.Source := SpinnerModel2;
        FSpinnerAnimator.Interpolation := TInterpolationType.Circular;
      end;
    stCustom:
      begin
        FSpinner.Svg.Source := String.Empty;
      end;
  end;
end;

procedure TUIOverlayLoader.SetSpinnerSize(const Value: TSpinnerSize);
begin
  FSpinnerSize := Value;
  FSpinnerContainer.Height := Ord(Value);
  FSpinnerContainer.Width := Ord(Value);
end;

procedure TUIOverlayLoader.SetSpinnerHeight(const Value: Single);
begin
  FSpinnerHeight := Value;

  if (FSpinnerSize = TSpinnerSize.ssCustom) then
  begin
    FSpinnerContainer.Height := FSpinnerHeight;
  end;
end;

procedure TUIOverlayLoader.SetSpinnerWidth(const Value: Single);
begin
  FSpinnerWidth := Value;

  if (FSpinnerSize = TSpinnerSize.ssCustom) then
  begin
    FSpinnerContainer.Width := FSpinnerWidth;
  end;
end;

procedure TUIOverlayLoader.SetSpinnerMotion(const Value: TSpinnerMotion);
begin
  FSpinnerMotion := Value;
  FSpinnerAnimator.Interpolation := TInterpolationType(FSpinnerMotion);
end;

procedure TUIOverlayLoader.SetSpinnerVelocity(const Value: Single);
begin
  FSpinnerVelocity := Value;
  FSpinnerAnimator.Duration := FSpinnerVelocity;
end;

procedure TUIOverlayLoader.SetSpinnerBackgroundColor(const Value: TAlphaColor);
begin
  FSpinnerBackgroundColor := Value;
  FSpinnerBackground.Fill.Color := FSpinnerBackgroundColor;
end;

procedure TUIOverlayLoader.SetSpinnerBackgroundRadius(const Value: Single);
begin
  FSpinnerBackgroundRadius := Value;
  FSpinnerBackground.XRadius := FSpinnerBackgroundRadius;
  FSpinnerBackground.YRadius := FSpinnerBackgroundRadius;
end;

procedure TUIOverlayLoader.SetSpinnerBackgroundOpacity(const Value: Single);
begin
  FSpinnerBackgroundOpacity := Value;
  FSpinnerBackground.Opacity := FSpinnerBackgroundOpacity;
end;

constructor TUIOverlayLoader.Create(AOwner: TComponent);
begin
  inherited Create(AOwner);

  FBackgroundOpacity := 0.4;
  FBackgroundColor := TAlphaColors.Black;
  FSpinnerColor := TAlphaColors.White;
  FControlType := TControlType.Styled;
  FSpinnerOpacity := 1.0;
  FSpinnerType := TSpinnerType.stModel1;
  FSpinnerSize := TSpinnerSize.ssSmall;
  FSpinnerBackgroundColor := TAlphaColors.Null;
  FSpinnerBackgroundRadius := 8.0;
  FSpinnerBackgroundOpacity := 1.0;
  FSpinnerHeight := 0;
  FSpinnerWidth := 0;
  FSpinnerMotion := TSpinnerMotion.Linear;
  FSpinnerVelocity := 0.9;

  FPrimaryContainer := TLayout.Create(Self);
  FPrimaryContainer.Visible := False;

  FOverlayContainer := TPresentedControl.Create(FPrimaryContainer);
  FOverlayContainer.Parent := FPrimaryContainer;
  FOverlayContainer.HitTest := True;
  FOverlayContainer.Align := TAlignLayout.Contents;
  FOverlayContainer.ControlType := FControlType;

  FOverlayBackground := TRectangle.Create(FOverlayContainer);
  FOverlayBackground.Parent := FOverlayContainer;
  FOverlayBackground.Stroke.Kind := TBrushKind.None;
  FOverlayBackground.HitTest := False;
  FOverlayBackground.Align := TAlignLayout.Contents;
  FOverlayBackground.Fill.Color := FBackgroundColor;
  FOverlayBackground.Opacity := FBackgroundOpacity;

  FSpinnerContainer := TLayout.Create(FOverlayContainer);
  FSpinnerContainer.Parent := FOverlayContainer;
  FSpinnerContainer.Align := TAlignLayout.Center;
  FSpinnerContainer.HitTest := False;
  FSpinnerContainer.Height := Ord(FSpinnerSize);
  FSpinnerContainer.Width := Ord(FSpinnerSize);

  FSpinnerBackground := TRectangle.Create(FSpinnerContainer);
  FSpinnerBackground.Parent := FSpinnerContainer;
  FSpinnerBackground.Stroke.Kind := TBrushKind.None;
  FSpinnerBackground.Fill.Color := FSpinnerBackgroundColor;
  FSpinnerBackground.HitTest := False;
  FSpinnerBackground.Align := TAlignLayout.Contents;
  FSpinnerBackground.XRadius := FSpinnerBackgroundRadius;
  FSpinnerBackground.YRadius := FSpinnerBackgroundRadius;
  FSpinnerBackground.Opacity := FSpinnerBackgroundOpacity;

  FSpinner := TSkSvg.Create(FSpinnerContainer);
  FSpinner.Parent := FSpinnerContainer;
  FSpinner.Align := TAlignLayout.Client;
  FSpinner.Padding := TBounds.Create(RectF(5, 5, 5, 5));
  FSpinner.Svg.WrapMode := TSkSvgWrapMode.Fit;
  FSpinner.HitTest := False;
  FSpinner.Visible := True;
  FSpinner.Svg.Source := SpinnerModel1;

  FSpinnerAnimator := TFloatAnimation.Create(FSpinner);
  FSpinnerAnimator.Parent := FSpinner;
  FSpinnerAnimator.Enabled := False;
  FSpinnerAnimator.AnimationType := TAnimationType.InOut;
  FSpinnerAnimator.Interpolation := TInterpolationType(FSpinnerMotion);
  FSpinnerAnimator.Duration := FSpinnerVelocity;
  FSpinnerAnimator.Loop := True;
  FSpinnerAnimator.PropertyName := 'rotationAngle';
  FSpinnerAnimator.StartValue := 0;
  FSpinnerAnimator.StopValue := 360;

end;

destructor TUIOverlayLoader.Destroy;
begin
  inherited Destroy;
end;

procedure TUIOverlayLoader.SetOverloadingForm(const AParent: TFMXObject);
begin
  FParentOverloading := AParent;
end;

procedure TUIOverlayLoader.Show;
begin

  if ((not Assigned(FParentOverloading)) or FIsShowing) then
    exit;

  FPrimaryContainer.Parent := FParentOverloading;
  FPrimaryContainer.Visible := True;
  FPrimaryContainer.Align := TAlignLayout.Contents;
  FSpinnerAnimator.Enabled := True;
  FPrimaryContainer.BringToFront;
  FIsShowing := True;
end;

procedure TUIOverlayLoader.Hide;
begin
  FSpinnerAnimator.Enabled := False;
  FPrimaryContainer.Visible := False;
  FIsShowing := False;
end;

procedure TUIOverlayLoader.LoadFromFile(const AFileSVGName: string);
var
  VectorFile: TStringList;
begin
  if (FileExists(AFileSVGName)) then
  begin
    VectorFile := TStringList.Create;
    try
      VectorFile.LoadFromFile(AFileSVGName);
      FSpinner.Svg.Source := VectorFile.Text;
      FSpinnerType := TSpinnerType.stCustom;
    finally
      VectorFile.Free;
    end;
  end;
end;

function TUIOverlayLoader.IsShowing: Boolean;
begin
  Result := FIsShowing;
end;

class function TSVGColorParser.ReplaceFillColor(const TextSVG: string; ReplaceColor: TAlphaColor): string;
var
  Regex: TRegEx;
  ReplaceHex: string;
begin
  ReplaceHex := Format('#%2.2x%2.2x%2.2x', [TAlphaColorRec(ReplaceColor).R, TAlphaColorRec(ReplaceColor).G, TAlphaColorRec(ReplaceColor).B]);
  Regex := TRegEx.Create('fill\s*=\s*"#([0-9a-fA-F]{6})"', [roIgnoreCase]);
  Result := Regex.Replace(TextSVG, 'fill="' + ReplaceHex + '"');
end;

class function TSVGColorParser.ReplaceStrokeColor(const TextSVG: string; ReplaceColor: TAlphaColor): string;
var
  Regex: TRegEx;
  ReplaceHex: string;
begin
  ReplaceHex := Format('#%2.2x%2.2x%2.2x', [TAlphaColorRec(ReplaceColor).R, TAlphaColorRec(ReplaceColor).G, TAlphaColorRec(ReplaceColor).B]);
  Regex := TRegEx.Create('stroke\s*=\s*"#([0-9a-fA-F]{6})"', [roIgnoreCase]);
  Result := Regex.Replace(TextSVG, 'stroke="' + ReplaceHex + '"');
end;

end.