unit uFrmCtrls;

//////////////////////////////////////
///  Lina Form Controls Unit       ///
///  ****************************  ///
///  (c) 2014 Dennis Göhlert a.o.  ///
//////////////////////////////////////

interface

uses
  { Standard-Units }
  SysUtils, Classes, Controls, Windows, Forms, StdCtrls, ComCtrls, ExtCtrls,
  Graphics,
  { Andere Package-Units }
  uBase, uSysTools, uSysCtrls, uWebCtrls;

type
  { Fehlermeldungen }
  EInvalidParamChar = class(Exception);
  EParamNotFound = class(Exception);
  EInvalidParamIdentifier = class(Exception);
  EInvalidParamFormat = class(Exception);

type
  { Hilfsklassen }
  TSplashScreenMode = (ssmDefault,ssmModal);
  TSplashScreenAnimation = (ssaNone,ssaShallow);
  TProgressBarManagerMode = (pmmNone,pmmBattery,pmmDownload);
  TListBoxManagerMode = (lmmNone,lmmEdit,lmmComboBox);

type
  { Ereignisse }
  TSplashCreateEvent = procedure(Sender: TObject) of object;
  TSplashDestroyEvent = procedure(Sender: TObject) of object;
  TSplashShowEvent = procedure(Sender: TObject) of object;
  TSplashHideEvent = procedure(Sender: TObject) of object;
  TSplashChangeEvent = procedure(Sender: TObject) of object;
  TSplashTimerEvent = procedure(Sender: TObject) of object;
  TComponentManagerUpdateEvent = procedure(Sender: TObject) of object;
  TParamDefinerUpdateEvent = procedure(Sender: TObject) of object;

type
  { Hauptklassen }

  { TSplash... }
  TSplashObject = class(TPersistent)
  private
    { Private-Deklarationen }
    SplashScreenVisible: Boolean;
  public
    { Public-Deklarationen }
    constructor Create;
    destructor Destroy; override;
  end;

  TSplashForm = class(TSplashObject)
  private
    { Private-Deklarationen }
    FormObject: TForm;
    { Methoden }
    function GetBorderStyle: TFormBorderStyle;
    procedure SetBorderStyle(Value: TFormBorderStyle);
    function GetBorderIcons: TBorderIcons;
    procedure SetBorderIcons(Value: TBorderIcons);
    function GetLeft: Integer;
    procedure SetLeft(Value: Integer);
    function GetTop: Integer;
    procedure SetTop(Value: Integer);
    function GetWidth: Integer;
    procedure SetWidth(Value: Integer);
    function GetHeight: Integer;
    procedure SetHeight(Value: Integer);
    function GetAlign: TAlign;
    procedure SetAlign(Value: TAlign);
    function GetAlphaBlend: Boolean;
    procedure SetAlphaBlend(Value: Boolean);
    function GetAlphaBlendValue: Byte;
    procedure SetAlphaBlendValue(Value: Byte);
    function GetCaption: TCaption;
    procedure SetCaption(Value: TCaption);
    function GetColor: TColor;
    procedure SetColor(Value: TColor);
    function GetEnabled: Boolean;
    procedure SetEnabled(Value: Boolean);
    function GetWindowState: TWindowState;
    procedure SetWindowState(Value: TWindowState);
    function GetPosition: TPosition;
    procedure SetPosition(Value: TPosition);
    function GetCursor: TCursor;
    procedure SetCursor(Value: TCursor);
  public
    { Public-Deklarationen }
    constructor Create;
    destructor Destroy; override;
  published
    { Published-Deklarationen }
    property BorderStyle: TFormBorderStyle read GetBorderStyle write SetBorderStyle default bsNone;
    property BorderIcons: TBorderIcons read GetBorderIcons write SetBorderIcons default [];
    property Left: Integer read GetLeft write SetLeft default 0;
    property Top: Integer read GetTop write SetTop default 0;
    property Width: Integer read GetWidth write SetWidth default 600;
    property Height: Integer read GetHeight write SetHeight default 400;
    property Align: TAlign read GetAlign write SetAlign default alNone;
    property AlphaBlend: Boolean read GetAlphaBlend write SetAlphaBlend default False;
    property AlphaBlendValue: Byte read GetAlphaBlendValue write SetAlphaBlendValue default 255;
    property Caption: TCaption read GetCaption write SetCaption;
    property Color: TColor read GetColor write SetColor default clBtnFace;
    property Enabled: Boolean read GetEnabled write SetEnabled default True;
    property WindowState: TWindowState read GetWindowState write SetWindowState default wsNormal;
    property Position: TPosition read GetPosition write SetPosition default poScreenCenter;
    property Cursor: TCursor read GetCursor write SetCursor default crHourGlass;
  end;

  TSplashProgressBar = class(TSplashObject)
  private
    { Private-Deklarationen }
    ProgressBarObject: TProgressBar;
    { Methoden }
    function GetLeft: Integer;
    procedure SetLeft(Value: Integer);
    function GetTop: Integer;
    procedure SetTop(Value: Integer);
    function GetWidth: Integer;
    procedure SetWidth(Value: Integer);
    function GetHeight: Integer;
    procedure SetHeight(Value: Integer);
    function GetVisible: Boolean;
    procedure SetVisible(Value: Boolean);
    function GetPosition: Integer;
    procedure SetPosition(Value: Integer);
    function GetMax: Integer;
    procedure SetMax(Value: Integer);
    function GetMin: Integer;
    procedure SetMin(Value: Integer);
    function GetAlign: TAlign;
    procedure SetAlign(Value: TAlign);
    function GetBackgroundColor: TColor;
    procedure SetBackgroundColor(Value: TColor);
    function GetBarColor: TColor;
    procedure SetBarColor(Value: TColor);
    function GetState: TProgressBarState;
    procedure SetState(Value: TProgressBarState);
    function GetStyle: TProgressBarStyle;
    procedure SetStyle(Value: TProgressBarStyle);
    function GetSmooth: Boolean;
    procedure SetSmooth(Value: Boolean);
    function GetSmoothReverse: Boolean;
    procedure SetSmoothReverse(Value: Boolean);
    function GetMarqueeInterval: Integer;
    procedure SetMarqueeInterval(Value: Integer);
    function GetStep: Integer;
    procedure SetStep(Value: Integer);
  public
    { Public-Deklarationen }
    constructor Create;
    destructor Destroy; override;
  published
    { Published-Deklarationen }
    property Left: Integer read GetLeft write SetLeft default 250;
    property Top: Integer read GetTop write SetTop default 250;
    property Width: Integer read GetWidth write SetWidth default 100;
    property Height: Integer read GetHeight write SetHeight default 50;
    property Visible: Boolean read GetVisible write SetVisible default True;
    property Position: Integer read GetPosition write SetPosition default 0;
    property Max: Integer read GetMax write SetMax default 100;
    property Min: Integer read GetMin write SetMin default 0;
    property Align: TAlign read GetAlign write SetAlign default alNone;
    property BackgroundColor: TColor read GetBackgroundColor write SetBackgroundColor default clDefault;
    property BarColor: TColor read GetBarColor write SetBarColor default clDefault;
    property State: TProgressBarState read GetState write SetState default pbsNormal;
    property Style: TProgressBarStyle read GetStyle write SetStyle default pbstNormal;
    property Smooth: Boolean read GetSmooth write SetSmooth default False;
    property SmoothReverse: Boolean read GetSmoothReverse write SetSmoothReverse default False;
    property MarqueeInterval: Integer read GetMarqueeInterval write SetMarqueeInterval default 10;
    property Step: Integer read GetStep write SetStep default 10;
  end;

  TSplashImage = class(TSplashObject)
  private
    { Private-Deklarationen }
    ImageObject: TImage;
    { Methoden }
    function GetVisible: Boolean;
    procedure SetVisible(Value: Boolean);
    function GetTransparent: Boolean;
    procedure SetTransparent(Value: Boolean);
    function GetPicture: TPicture;
    procedure SetPicture(Value: TPicture);
  public
    { Public-Deklarationen }
    constructor Create;
    destructor Destroy; override;
  published
    { Published-Deklarationen }
    property Visible: Boolean read GetVisible write SetVisible default True;
    property Transparent: Boolean read GetTransparent write SetTransparent default False;
    property Picture: TPicture read GetPicture write SetPicture;
  end;

  TSplashTimer = class(TSplashObject)
  private
    { Private-Deklarationen }
    TimerObject: TTimer;
    FEnabled: Boolean;
    { Methoden }
    procedure SetEnabled(Value: Boolean);
    function GetInterval: Cardinal;
    procedure SetInterval(Value: Cardinal);
  public
    { Public-Deklarationen }
    constructor Create;
    destructor Destroy; override;
  published
    { Published-Deklarationen }
    property Enabled: Boolean read FEnabled write SetEnabled default False;
    property Interval: Cardinal read GetInterval write SetInterval default 1000;
  end;

  TSplashScreen = class(TComponent)
  private
    { Private-Deklarationen }
    AnimationTimerShow: TTimer;
    AnimationTimerHide: TTimer;
    FAbout: TComponentAbout;
    FSplashForm: TSplashForm;
    FSplashProgressBar: TSplashProgressBar;
    FSplashImage: TSplashImage;
    FSplashTimer: TSplashTimer;
    FDisplayTime: Cardinal;
    FAutoShow: Boolean;
    FMode: TSplashScreenMode;
    FAnimation: TSplashScreenAnimation;
    FAnimationSpeed: Byte;
    FVisible: Boolean;
    { Ereignisse }
    FCreateEvent: TSplashCreateEvent;
    FDestroyEvent: TSplashDestroyEvent;
    FShowEvent: TSplashShowEvent;
    FHideEvent: TSplashHideEvent;
    FChangeEvent: TSplashChangeEvent;
    FTimerEvent: TSplashTimerEvent;
    { Methoden }
    procedure SetVisible(Value: Boolean);
    procedure SetSplashForm(Value: TSplashForm);
    procedure SetSplashProgressBar(Value: TSplashProgressBar);
    procedure SetSplashImage(Value: TSplashImage);
    procedure SetSplashTimer(Value: TSplashTimer);
    procedure AnimationTimerShowTimer(Sender: TObject);
    procedure AnimationTimerHideTimer(Sender: TObject);
    procedure FormObjectShow(Sender: TObject);
    procedure FormObjectHide(Sender: TObject);
    procedure TimerObjectTimer(Sender: TObject);
  protected
    { Protected-Deklarationen }
    procedure Refresh;                 //Vorberaitung (benutzerdefinierte Werte)
    procedure Reset;                   //Vorbereitung (standardmäßige Werte)
  public
    { Public-Deklarationen }
    property Visible: Boolean read FVisible write SetVisible;
    constructor Create(AOwnder: TComponent); override;
    destructor Destroy; override;
    procedure ApplyChanges;            //Änderungen übernehmen
    procedure Show;                    //Anzeigen
    procedure Hide;                    //Verstecken (schließen)
  published
    { Published-Deklarationen }
    { Ereignisse }
    property OnCreate: TSplashCreateEvent read FCreateEvent write FCreateEvent;
    property OnDestroy: TSplashDestroyEvent read FDestroyEvent write FDestroyEvent;
    property OnShow: TSplashShowEvent read FShowEvent write FShowEvent;
    property OnHide: TSplashHideEvent read FHideEvent write FHideEvent;
    property OnChange: TSplashChangeEvent read FChangeEvent write FChangeEvent;
    property OnTimer: TSplashTimerEvent read FTimerEvent write FTimerEvent;
    { Eigenschaften }
    property About: TComponentAbout read FAbout;
    property SplashForm: TSplashForm read FSplashForm write SetSplashForm;
    property SplashProgressBar: TSplashProgressBar read FSplashProgressBar write SetSplashProgressBar;
    property SplashImage: TSplashImage read FSplashImage write SetSplashImage;
    property SplashTimer: TSplashTimer read FSplashTimer write SetSplashTimer;
    property DisplayTime: Cardinal read FDisplayTime write FDisplayTime default 2000;
    property AutoShow: Boolean read FAutoShow write FAutoShow default False;
    property Mode: TSplashScreenMode read FMode write FMode default ssmDefault;
    property Animation: TSplashScreenAnimation read FAnimation write FAnimation default ssaNone;
    property AnimationSpeed: Byte read FAnimationSpeed write FAnimationSpeed default 10;
  end;

  { T...Manager }

  TComponentManager = class(TComponent)
  private
    { Private-Deklarationen }
    FAbout: TComponentAbout;
    { Ereignisse }
    FUpdateEvent: TComponentManagerUpdateEvent;
  public
    { Public-Deklarationen }
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;
    procedure Update; virtual;
  published
    { Published-Deklarationen }
    { Ereignisse }
    property OnUpdate: TComponentManagerUpdateEvent read FUpdateEvent write FUpdateEvent;
    { Eigenschaften }
    property About: TComponentAbout read FAbout;
  end;

  TProgressBarManager = class(TComponentManager)
  private
    { Private-Deklarationen }
    FTarget: TProgressBar;
    FSourceBattery: TBattery;
    FSourceDownload: TDownload;
    FMode: TProgressBarManagerMode;
    { Methoden }
    procedure SetTarget(Value: TProgressBar);
    procedure SetSourceBattery(Value: TBattery);
    procedure SetSourceDownload(Value: TDownload);
    procedure SetMode(Value: TProgressBarManagerMode);
  public
    { Public-Deklarationen }
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;
    procedure Update; override;
  published
    { Published-Deklarationen }
    property Target: TProgressBar read FTarget write SetTarget;
    property SourceBattery: TBattery read FSourceBattery write SetSourceBattery;
    property SourceDownload: TDownload read FSourceDownload write SetSourceDownload;
    property Mode: TProgressBarManagerMode read FMode write SetMode default pmmNone;
  end;

  TListBoxManager = class(TComponentManager)
  private
    { Private-Deklarationen }
    FilteredList: TFilteredStringList;
    FTarget: TListBox;
    FSourceEdit: TEdit;
    FSourceComboBox: TComboBox;
    FMode: TListBoxManagerMode;
    FFilterOptions: TStringFilterOptions;
    { Methoden }
    procedure SetTarget(Value: TListBox);
    procedure SetSourceEdit(Value: TEdit);
    procedure SetSourceComboBox(Value: TComboBox);
    procedure SetMode(Value: TListBoxManagerMode);
    procedure SetFilterOptions(Value: TStringFilterOptions);
  public
    { Public-Deklarationen }
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;
    procedure Update; override;
    procedure LoadList;
  published
    { Published-Deklarationen }
    property Target: TListBox read FTarget write SetTarget;
    property SourceEdit: TEdit read FSourceEdit write SetSourceEdit;
    property SourceComboBox: TComboBox read FSourceComboBox write SetSourceComboBox;
    property Mode: TListBoxManagerMode read FMode write SetMode default lmmNone;
    property FilterOptions: TStringFilterOptions read FFilterOptions write SetFilterOptions default [sfoCaseSensitive,sfoForceTrim,sfoDefaultVisible];
  end;

  { TParam... }
  TParamFormat = class(TPersistent)
  private
    { Private-Deklarationen }
    FPrefix: String;
    FSuffix: String;
    FSeparator: String;
    { Methoden }
    procedure SetPrefix(Value: String);
    procedure SetSuffix(Value: String);
    procedure SetSeparator(Value: String);
  public
    { Public-Deklarationen }
    constructor Create; overload;
    constructor Create(APrefix,ASeparator,ASuffix: String); overload;
    destructor Destroy; override;
  published
    { Published-Deklarationen }
    property Prefix: String read FPrefix write SetPrefix;
    property Suffix: String read FSuffix write SetSuffix;
    property Separator: String read FSeparator write SetSeparator;
  end;

  TParamReference = class(TCollectionItem)
  private
    { Private-Deklarationen }
    FDefaultValue: String;
    FIdentifier: String;
    FConnector: PString;
    FFormat: TParamFormat;
    { Methoden }
    procedure SetIdentifier(Value: String);
    function GetFormat: TParamFormat;
    procedure SetFormat(Value: TParamFormat);
  public
    { Public-Deklarationen }
    constructor Create(Collection: TCollection); override;
    destructor Destroy; override;
    procedure Update;
    function AsText(UseDefVal: Boolean = False): String;
    { Eigenschaften }
    property Connector: PString read FConnector write FConnector;
  published
    { Published-Deklarationen }
    property DefaultValue: String read FDefaultValue write FDefaultValue;
    property Identifier: String read FIdentifier write SetIdentifier;
    property Format: TParamFormat read FFormat write SetFormat;
  end;

  TParamReferences = class(TCollection);

  TParamDefiner = class(TComponent)
  private
    { Private-Deklarationen }
    FAbout: TComponentAbout;
    FReferences: TParamReferences;
    { Ereignisse }
    FUpdateEvent: TParamDefinerUpdateEvent;
    { Methoden }
    procedure SetReferences(Value: TParamReferences);
  public
    { Public-Deklarationen }
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;
    procedure Update;
  published
    { Published-Deklarationen }
    { Ereignisse }
    property OnUpdate: TParamDefinerUpdateEvent read FUpdateEvent write FUpdateEvent;
    { Eigenschaften }
    property About: TComponentAbout read FAbout;
    property References: TParamReferences read FReferences write SetReferences;
  end;

  procedure SetTaskBarVisibe(const Value: Boolean);
  procedure ListParams(var OutList: TStrings);
  function StringFromParam(Ident,Value: String; Format: TParamFormat): String;
  function StringFromParamRef(ParamRef: TParamReference; UseDefVal: Boolean = True): String;
  function StringFromParams(Idents,Values: TStrings; Format: TParamFormat): String;

  procedure Register;

const
  { Meta-Daten }
  SplashScreenComponent_Name = 'SplashScreen';
  SplashScreenComponent_Version = 1.0;
  SplashScreenComponent_Copyright = 'Copyright © 2014';
  SplashScreenComponent_Author = 'Dennis Göhlert a.o.';

  ProgressBarManagerComponent_Name = 'ProgressBarManager';
  ProgressBarManagerComponent_Version = 1.0;
  ProgressBarManagerComponent_Copyright = 'Copyright © 2014';
  ProgressBarManagerComponent_Author = 'Dennis Göhlert a.o.';

  ListBoxManagerComponent_Name = 'ListBoxManager';
  ListBoxManagerComponent_Version = 1.0;
  ListBoxManagerComponent_Copyright = 'Copyright © 2014';
  ListBoxManagerComponent_Author = 'Dennis Göhlert a.o.';

  ParamDefinerComponent_Name = 'ParamDefiner';
  ParamDefinerComponent_Version = 1.0;
  ParamDefinerComponent_Copyright = 'Copyright © 2014';
  ParamDefinerComponent_Author = 'Dennis Göhlert a.o.';

implementation

procedure Register;
begin
  RegisterComponents(ComponentsPage,[TSplashScreen,TProgressBarManager,TListBoxManager,TParamDefiner]);
end;

procedure SetTaskBarVisibe(const Value: Boolean);
begin
  if Value = True then
  begin
    ShowWindow(Application.Handle,SW_HIDE);
    SetWindowLong(Application.Handle,GWL_EXSTYLE,GetWindowLong(Application.Handle,GWL_EXSTYLE) and not WS_EX_TOOLWINDOW or WS_EX_APPWINDOW);
    ShowWindow(Application.Handle,SW_SHOW);
  end else
  begin
    ShowWindow(Application.Handle,SW_SHOW);
    SetWindowLong(Application.Handle,GWL_EXSTYLE,GetWindowLong(Application.Handle,GWL_EXSTYLE) and not WS_EX_TOOLWINDOW or WS_EX_APPWINDOW);
    ShowWindow(Application.Handle,SW_HIDE);
  end;
end;

procedure ListParams(var OutList: TStrings);
var
  Index: Integer;
begin
  OutList.Clear;
  for Index := 0 to ParamCount do
  begin
    OutList.Add(ParamStr(Index));
  end;
end;

function StringFromParam(Ident,Value: String; Format: TParamFormat): String;
var
  TmpStr: String;
  Index: Integer;
  RequireQuotes: Boolean;
begin
  Result := '';
  TmpStr := Format.Prefix + Ident + Format.Separator + Value + Format.Suffix;
  RequireQuotes := False;
  for Index := 1 to Length(TmpStr) do
  begin
    if TmpStr[Index] in Spaces then
    begin
      RequireQuotes := True;
    end;
    if TmpStr[Index] in ['''','"'] then
    begin
      raise EInvalidParamChar.Create('Invalid character at position: ' + IntToStr(Index));
    end;
  end;
  if RequireQuotes = True then
  begin
    Result := '"' + TmpStr + '"';
  end else
  begin
    Result := TmpStr;
  end;
end;

function StringFromParamRef(ParamRef: TParamReference; UseDefVal: Boolean = True): String;
var
  Value: String;
begin
  if UseDefVal = True then
  begin
    Value := ParamRef.DefaultValue;
  end else
  begin
    Value := ParamRef.Connector^;
  end;
  Result := StringFromParam(ParamRef.Identifier,Value,ParamRef.Format);
end;

function StringFromParams(Idents,Values: TStrings; Format: TParamFormat): String;
var
  TmpStr: String;
  Index: Integer;
begin
  Result := '';
  for Index := 0 to Idents.Count do
  begin
    if Index > 0 then
    begin
      TmpStr := TmpStr + ' ';
    end;
    TmpStr := TmpStr + StringFromParam(Idents.Strings[Index],Values[Index],Format);
  end;
  Result := TmpStr;
end;

{ ----------------------------------------------------------------------------
  TSplashObject
  ---------------------------------------------------------------------------- }

constructor TSplashObject.Create;
begin
  inherited;
  SplashScreenVisible := False;
end;

destructor TSplashObject.Destroy;
begin
  //...
  inherited;
end;

{ ----------------------------------------------------------------------------
  TSplashForm
  ---------------------------------------------------------------------------- }

constructor TSplashForm.Create;
begin
  FormObject := TForm.Create(nil);
  FormObject.Visible := False;
end;

destructor TSplashForm.Destroy;
begin
  FormObject.Close;
  FormObject.Free;
  inherited;
end;

function TSplashForm.GetBorderStyle: TFormBorderStyle;
begin
  Result := FormObject.BorderStyle;
end;

procedure TSplashForm.SetBorderStyle(Value: TFormBorderStyle);
begin
  FormObject.BorderStyle := Value;
end;

function TSplashForm.GetBorderIcons: TBorderIcons;
begin
  Result := FormObject.BorderIcons;
end;

procedure TSplashForm.SetBorderIcons(Value: TBorderIcons);
begin
  FormObject.BorderIcons := Value;
end;

function TSplashForm.GetLeft: Integer;
begin
  Result := FormObject.Left;
end;

procedure TSplashForm.SetLeft(Value: Integer);
begin
  FormObject.Left := Value;
end;

function TSplashForm.GetTop: Integer;
begin
  Result := FormObject.Top;
end;

procedure TSplashForm.SetTop(Value: Integer);
begin
  FormObject.Top := Value;
end;

function TSplashForm.GetWidth: Integer;
begin
  Result := FormObject.Width;
end;

procedure TSplashForm.SetWidth(Value: Integer);
begin
  FormObject.Width := Value;
end;

function TSplashForm.GetHeight: Integer;
begin
  Result := FormObject.Height;
end;

procedure TSplashForm.SetHeight(Value: Integer);
begin
  FormObject.Height := Value;
end;

function TSplashForm.GetAlign: TAlign;
begin
  Result := FormObject.Align;
end;

procedure TSplashForm.SetAlign(Value: TAlign);
begin
  FormObject.Align := Value;
end;

function TSplashForm.GetAlphaBlend: Boolean;
begin
  Result := FormObject.AlphaBlend;
end;

procedure TSplashForm.SetAlphaBlend(Value: Boolean);
begin
  FormObject.AlphaBlend := Value;
end;

function TSplashForm.GetAlphaBlendValue: Byte;
begin
  Result := FormObject.AlphaBlendValue;
end;

procedure TSplashForm.SetAlphaBlendValue(Value: Byte);
begin
  FormObject.AlphaBlendValue := Value;
end;

function TSplashForm.GetCaption: TCaption;
begin
  Result := FormObject.Caption;
end;

procedure TSplashForm.SetCaption(Value: TCaption);
begin
  FormObject.Caption := Value;
end;

function TSplashForm.GetColor: TColor;
begin
  Result := FormObject.Color;
end;

procedure TSplashForm.SetColor(Value: TColor);
begin
  FormObject.Color := Value;
end;

function TSplashForm.GetEnabled: Boolean;
begin
  Result := FormObject.Enabled;
end;

procedure TSplashForm.SetEnabled(Value: Boolean);
begin
  FormObject.Enabled := Value;
end;

function TSplashForm.GetWindowState: TWindowState;
begin
  Result := FormObject.WindowState;
end;

procedure TSplashForm.SetWindowState(Value: TWindowState);
begin
  FormObject.WindowState := Value;
end;

function TSplashForm.GetPosition: TPosition;
begin
  Result := FormObject.Position;
end;

procedure TSplashForm.SetPosition(Value: TPosition);
begin
  FormObject.Position := Value;
end;

function TSplashForm.GetCursor: TCursor;
begin
  Result := FormObject.Cursor;
end;

procedure TSplashForm.SetCursor(Value: TCursor);
begin
  FormObject.Cursor := Value;
end;

{ ----------------------------------------------------------------------------
  TSplashProgressBar
  ---------------------------------------------------------------------------- }

constructor TSplashProgressBar.Create;
begin
  ProgressBarObject := TProgressBar.Create(nil);
end;

destructor TSplashProgressBar.Destroy;
begin
  ProgressBarObject.Free;
  inherited;
end;

function TSplashProgressBar.GetLeft: Integer;
begin
  Result := ProgressBarObject.Left;
end;

procedure TSplashProgressBar.SetLeft(Value: Integer);
begin
  ProgressBarObject.Left := Value;
end;

function TSplashProgressBar.GetTop: Integer;
begin
  Result := ProgressBarObject.Top;
end;

procedure TSplashProgressBar.SetTop(Value: Integer);
begin
  ProgressBarObject.Top := Value;
end;

function TSplashProgressBar.GetWidth: Integer;
begin
  Result := ProgressBarObject.Width;
end;

procedure TSplashProgressBar.SetWidth(Value: Integer);
begin
  ProgressBarObject.Width := Value;
end;

function TSplashProgressBar.GetHeight: Integer;
begin
  Result := ProgressBarObject.Height;
end;

procedure TSplashProgressBar.SetHeight(Value: Integer);
begin
  ProgressBarObject.Height := Value;
end;

function TSplashProgressBar.GetVisible: Boolean;
begin
  Result := ProgressBarObject.Visible;
end;

procedure TSplashProgressBar.SetVisible(Value: Boolean);
begin
  ProgressBarObject.Visible := Value;
end;

function TSplashProgressBar.GetPosition: Integer;
begin
  Result := ProgressBarObject.Position;
end;

procedure TSplashProgressBar.SetPosition(Value: Integer);
begin
  ProgressBarObject.Position := Value;
end;

function TSplashProgressBar.GetMax: Integer;
begin
  Result := ProgressBarObject.Max;
end;

procedure TSplashProgressBar.SetMax(Value: Integer);
begin
  ProgressBarObject.Max := Value;
end;

function TSplashProgressBar.GetMin: Integer;
begin
  Result := ProgressBarObject.Min;
end;

procedure TSplashProgressBar.SetMin(Value: Integer);
begin
  ProgressBarObject.Min := Value;
end;

function TSplashProgressBar.GetAlign: TAlign;
begin
  Result := ProgressBarObject.Align;
end;

procedure TSplashProgressBar.SetAlign(Value: TAlign);
begin
  ProgressBarObject.Align := Value;
end;

function TSplashProgressBar.GetBackgroundColor: TColor;
begin
  Result := ProgressBarObject.BackgroundColor;
end;

procedure TSplashProgressBar.SetBackgroundColor(Value: TColor);
begin
  ProgressBarObject.BackgroundColor := Value;
end;

function TSplashProgressBar.GetBarColor: TColor;
begin
  Result := ProgressBarObject.BarColor;
end;

procedure TSplashProgressBar.SetBarColor(Value: TColor);
begin
  ProgressBarObject.BarColor := Value;
end;

function TSplashProgressBar.GetState: TProgressBarState;
begin
  Result := ProgressBarObject.State;
end;

procedure TSplashProgressBar.SetState(Value: TProgressBarState);
begin
  ProgressBarObject.State := Value;
end;

function TSplashProgressBar.GetStyle: TProgressBarStyle;
begin
  Result := ProgressBarObject.Style;
end;

procedure TSplashProgressBar.SetStyle(Value: TProgressBarStyle);
begin
  ProgressBarObject.Style := Value;
end;

function TSplashProgressBar.GetSmooth: Boolean;
begin
  Result := ProgressBarObject.Smooth;
end;

procedure TSplashProgressBar.SetSmooth(Value: Boolean);
begin
  ProgressBarObject.Smooth := Value;
end;

function TSplashProgressBar.GetSmoothReverse: Boolean;
begin
  Result := ProgressBarObject.SmoothReverse;
end;

procedure TSplashProgressBar.SetSmoothReverse(Value: Boolean);
begin
  ProgressBarObject.SmoothReverse := Value;
end;

function TSplashProgressBar.GetMarqueeInterval: Integer;
begin
  Result := ProgressBarObject.MarqueeInterval;
end;

procedure TSplashProgressBar.SetMarqueeInterval(Value: Integer);
begin
  ProgressBarObject.MarqueeInterval := Value;
end;

function TSplashProgressBar.GetStep: Integer;
begin
  Result := ProgressBarObject.Step;
end;

procedure TSplashProgressBar.SetStep(Value: Integer);
begin
  ProgressBarObject.Step := Value;
end;


{ ----------------------------------------------------------------------------
  TSplashImage
  ---------------------------------------------------------------------------- }

constructor TSplashImage.Create;
begin
  ImageObject := TImage.Create(nil);
  Picture := TPicture.Create;
  ImageObject.Align := alClient;
  ImageObject.Stretch := True;
end;

destructor TSplashImage.Destroy;
begin
  //Picture.Free;  Keine Ahrnung, wieso das hier automatisch wieder freigegeben wird (??)
  ImageObject.Free;
  inherited;
end;

function TSplashImage.GetVisible: Boolean;
begin
  Result := ImageObject.Visible;
end;

procedure TSplashImage.SetVisible(Value: Boolean);
begin
  ImageObject.Visible := Value;
end;

function TSplashImage.GetTransparent: Boolean;
begin
  Result := ImageObject.Transparent;
end;

procedure TSplashImage.SetTransparent(Value: Boolean);
begin
  ImageObject.Transparent := Value;
end;

function TSplashImage.GetPicture: TPicture;
begin
  Result := ImageObject.Picture;
end;

procedure TSplashImage.SetPicture(Value: TPicture);
begin
  ImageObject.Picture.Assign(Value);
end;

{ ----------------------------------------------------------------------------
  TSplashTimer
  ---------------------------------------------------------------------------- }

constructor TSplashTimer.Create;
begin
  TimerObject := TTimer.Create(nil);
  TimerObject.Enabled := False;
end;

destructor TSplashTimer.Destroy;
begin
  TimerObject.Enabled := False;
  TimerObject.Free;
  inherited;
end;

procedure TSplashTimer.SetEnabled(Value: Boolean);
begin
  FEnabled := Value;
  if SplashScreenVisible = True then
  begin
    TimerObject.Enabled := Value;
  end;
end;

function TSplashTimer.GetInterval: Cardinal;
begin
  Result := TimerObject.Interval;
end;

procedure TSplashTimer.SetInterval(Value: Cardinal);
begin
  TimerObject.Interval := Value;
end;

{ ----------------------------------------------------------------------------
  TSplashScreen
  ---------------------------------------------------------------------------- }

constructor TSplashScreen.Create(AOwnder: TComponent);
begin
  inherited;
  FDisplayTime := 2000;
  FAutoShow := False;
  FMode := ssmDefault;
  FAnimation := ssaNone;
  FAnimationSpeed := 10;
  FVisible := False;

  FAbout := TComponentAbout.Create(SplashScreenComponent_Name,SplashScreenComponent_Version,SplashScreenComponent_Copyright,SplashScreenComponent_Author);
  FSplashForm := TSplashForm.Create;
  FSplashForm.FormObject.OnShow := FormObjectShow;
  FSplashForm.FormObject.OnHide := FormObjectHide;
  FSplashTimer := TSplashTimer.Create;
  FSplashTimer.TimerObject.OnTimer := TimerObjectTimer;
  FSplashProgressBar := TSplashProgressBar.Create;
  FSplashImage := TSplashImage.Create;
  FSplashTimer := TSplashTimer.Create;
  { Parents richtig setzen }
  SplashProgressBar.ProgressBarObject.Parent := SplashForm.FormObject;
  SplashImage.ImageObject.Parent := SplashForm.FormObject;
  { AnimationTimer... }
  AnimationTimerShow := TTimer.Create(Self);
  AnimationTimerShow.OnTimer := AnimationTimerShowTimer;
  AnimationTimerShow.Enabled := False;
  AnimationTimerShow.Interval := 50;
  AnimationTimerHide := TTimer.Create(Self);
  AnimationTimerHide.OnTimer := AnimationTimerHideTimer;
  AnimationTimerHide.Enabled := False;
  AnimationTimerHide.Interval := 50;
  Reset;
  if Assigned(OnCreate) then
  begin
    OnCreate(Self);
  end;
  { Erst NACHDEM fertig erstellt wurde und OnCreate-Event ausgeführt wurde... }
  if AutoShow = True then
  begin
    Show;
  end;
end;

destructor TSplashScreen.Destroy;
begin
  if Assigned(OnDestroy) then
  begin
    OnDestroy(Self);
  end;
  FAbout.Free;
  FSplashProgressBar.Free;
  FSplashImage.Free;
  FSplashTimer.Free;
  FSplashForm.Free;
  //ProgressBarObject.Free;      _
  //ImageObject.Free;             |
  //TimerObject.Free;             |____\  Automatisch
  //AnimationTimerShow.Free;      |    /  freigegeben
  //AnimationTimerHide.Free;     _|
  inherited;
end;

procedure TSplashScreen.Show;
begin
  SplashTimer.TimerObject.Enabled := SplashTimer.FEnabled;
  if Mode = ssmModal then
  begin
    SplashForm.FormObject.ShowModal;
  end else
  begin
    SplashForm.FormObject.Show;
  end;
  if Animation = ssaShallow then
  begin
    SplashForm.FormObject.AlphaBlend := True;
    SplashForm.FormObject.AlphaBlendValue := 0;
    AnimationTimerHide.Enabled := False;
    AnimationTimerShow.Enabled := True;
  end;
  FVisible := True;
  SplashForm.FormObject.BringToFront;
  SplashForm.SplashScreenVisible := True;
  SplashProgressBar.SplashScreenVisible := True;
  SplashImage.SplashScreenVisible := True;
  SplashTimer.SplashScreenVisible := True;
  if Assigned(OnShow) then
  begin
    OnShow(Self);
  end;
end;

procedure TSplashScreen.Hide;
begin
  SplashTimer.TimerObject.Enabled := False;
  if Animation = ssaNone then
  begin
    SplashForm.FormObject.Hide;
  end else
  begin
    if Animation = ssaShallow then
    begin
      SplashForm.FormObject.AlphaBlend := True;
      AnimationTimerShow.Enabled := False;
      AnimationTimerHide.Enabled := True;
    end;
  end;
  FVisible := False;
  SplashForm.SplashScreenVisible := False;
  SplashProgressBar.SplashScreenVisible := False;
  SplashImage.SplashScreenVisible := False;
  SplashTimer.SplashScreenVisible := False;
  if Assigned(OnHide) then
  begin
    OnHide(Self);
  end;
end;

procedure TSplashScreen.FormObjectShow(Sender: TObject);
begin
  Visible := True;
end;

procedure TSplashScreen.FormObjectHide(Sender: TObject);
begin
  Visible := False;
end;

procedure TSplashScreen.TimerObjectTimer(Sender: TObject);
begin
  if Assigned(OnTimer) then
  begin
    OnTimer(Self);
  end;
end;

procedure TSplashScreen.ApplyChanges;
begin
  { "Refresh;" ist nicht public, deswegen hier eine Referenz.
    Falls beim übernehmen der Änderungen noch sonstige Dinge getan werden
    müssen, können diese hier definiert werden. }
  Refresh;
end;

procedure TSplashScreen.Refresh;
begin
  { TSplashForm -> TForm }
  SplashForm.FormObject.BorderStyle := SplashForm.BorderStyle;
  SplashForm.FormObject.BorderIcons := SplashForm.BorderIcons;
  SplashForm.FormObject.Left := SplashForm.Left;
  SplashForm.FormObject.Top := SplashForm.Top;
  SplashForm.FormObject.Width := SplashForm.Width;
  SplashForm.FormObject.Height := SplashForm.Height;
  SplashForm.FormObject.Align := SplashForm.Align;
  SplashForm.FormObject.AlphaBlend := SplashForm.AlphaBlend;
  SplashForm.FormObject.AlphaBlendValue := SplashForm.AlphaBlendValue;
  SplashForm.FormObject.Caption := SplashForm.Caption;
  SplashForm.FormObject.Color := SplashForm.Color;
  SplashForm.FormObject.Enabled := SplashForm.Enabled;
  SplashForm.FormObject.WindowState := SplashForm.WindowState;
  SplashForm.FormObject.Position := SplashForm.Position;
  SplashForm.FormObject.Cursor := SplashForm.Cursor;
  { TSplashProgressBar -> TProgressBar }
  SplashProgressBar.ProgressBarObject.Left := SplashProgressBar.Left;
  SplashProgressBar.ProgressBarObject.Top := SplashProgressBar.Top;
  SplashProgressBar.ProgressBarObject.Width := SplashProgressBar.Width;
  SplashProgressBar.ProgressBarObject.Height := SplashProgressBar.Height;
  SplashProgressBar.ProgressBarObject.Visible := SplashProgressBar.Visible;
  SplashProgressBar.ProgressBarObject.Position := SplashProgressBar.Position;
  SplashProgressBar.ProgressBarObject.Max := SplashProgressBar.Max;
  SplashProgressBar.ProgressBarObject.Min := SplashProgressBar.Min;
  SplashProgressBar.ProgressBarObject.Cursor := SplashForm.FormObject.Cursor;
  SplashProgressBar.ProgressBarObject.Align := SplashProgressBar.Align;
  SplashProgressBar.ProgressBarObject.BackgroundColor := SplashProgressBar.BackgroundColor;
  SplashProgressBar.ProgressBarObject.BarColor := SplashProgressBar.BarColor;
  SplashProgressBar.ProgressBarObject.State := SplashProgressBar.State;
  SplashProgressBar.ProgressBarObject.Style := SplashProgressBar.Style;
  SplashProgressBar.ProgressBarObject.Smooth := SplashProgressBar.Smooth;
  SplashProgressBar.ProgressBarObject.SmoothReverse := SplashProgressBar.SmoothReverse;
  SplashProgressBar.ProgressBarObject.MarqueeInterval := SplashProgressBar.MarqueeInterval;
  SplashProgressBar.ProgressBarObject.Step := SplashProgressBar.Step;
  { TSplashImage -> TImage }
  SplashImage.ImageObject.Visible := SplashImage.Visible;
  SplashImage.ImageObject.Transparent := SplashImage.Transparent;
  SplashImage.ImageObject.Picture := SplashImage.Picture;
  { TSplashTimer -> TTimer }
  SplashTimer.TimerObject.Enabled := SplashTimer.Enabled;
  SplashTimer.TimerObject.Interval := SplashTimer.Interval;
end;

procedure TSplashScreen.Reset;
begin
  { TSplashForm }
  SplashForm.BorderStyle := bsNone;
  SplashForm.BorderIcons := [];
  SplashForm.Left := 0;
  SplashForm.Top := 0;
  SplashForm.Width := 600;
  SplashForm.Height := 400;
  SplashForm.Align := alNone;
  SplashForm.AlphaBlend := False;
  SplashForm.AlphaBlendValue := 255;
  SplashForm.Color := clBtnFace;
  SplashForm.Enabled := True;
  SplashForm.WindowState := wsNormal;
  SplashForm.Position := poScreenCenter;
  SplashForm.Cursor := crHourGlass;
  { TSplashProgressBar }
  SplashProgressBar.Left := 250;
  SplashProgressBar.Top := 250;
  SplashProgressBar.Width := 100;
  SplashProgressBar.Height := 50;
  SplashProgressBar.Visible := True;
  SplashProgressBar.Position := 0;
  SplashProgressBar.Max := 100;
  SplashProgressBar.Min := 0;
  SplashProgressBar.Align := alNone;
  SplashProgressBar.BackgroundColor := clDefault;
  SplashProgressBar.BarColor := clDefault;
  SplashProgressBar.State := pbsNormal;
  SplashProgressBar.Style := pbstNormal;
  SplashProgressBar.Smooth := False;
  SplashProgressBar.SmoothReverse := False;
  SplashProgressBar.MarqueeInterval := 10;
  SplashProgressBar.Step := 10;
  { TSplashImage }
  SplashImage.Visible := True;
  SplashImage.Transparent := False;
  { TSplashTimer }
  SplashTimer.Enabled := False;
  SplashTimer.Interval := 1000;
  if Assigned(OnChange) then
  begin
    OnChange(Self);
  end;
end;

procedure TSplashScreen.SetVisible(Value: Boolean);
begin
  if Value = True then
  begin
    if SplashForm.FormObject.Visible = False then
    begin
      Show;
    end;
  end else
  begin
    if SplashForm.FormObject.Visible = True then
    begin
      Hide;
    end;
  end;
end;

procedure TSplashScreen.SetSplashForm(Value: TSplashForm);
begin
  FSplashForm.Assign(Value);
  if Assigned(OnChange) then
  begin
    OnChange(Self);
  end;
end;

procedure TSplashScreen.SetSplashProgressBar(Value: TSplashProgressBar);
begin
  FSplashProgressBar.Assign(Value);
  if Assigned(OnChange) then
  begin
    OnChange(Self);
  end;
end;

procedure TSplashScreen.SetSplashImage(Value: TSplashImage);
begin
  FSplashImage.Assign(Value);
  if Assigned(OnChange) then
  begin
    OnChange(Self);
  end;
end;

procedure TSplashScreen.SetSplashTimer(Value: TSplashTimer);
begin
  FSplashTimer.Assign(Value);
  if Assigned(OnChange) then
  begin
    OnChange(Self);
  end;
end;

procedure TSplashScreen.AnimationTimerShowTimer(Sender: TObject);
begin
  if Animation = ssaShallow then
  begin
    if SplashForm.FormObject.AlphaBlendValue < SplashForm.AlphaBlendValue then
    begin
      if SplashForm.AlphaBlendValue - SplashForm.FormObject.AlphaBlendValue < AnimationSpeed then
      begin
        SplashForm.FormObject.AlphaBlendValue := SplashForm.FormObject.AlphaBlendValue + (SplashForm.AlphaBlendValue - SplashForm.FormObject.AlphaBlendValue);
      end else
      begin
        SplashForm.FormObject.AlphaBlendValue := SplashForm.FormObject.AlphaBlendValue + AnimationSpeed;
      end;
    end else
    begin
      AnimationTimerShow.Enabled := False;
      SplashForm.FormObject.AlphaBlend := SplashForm.AlphaBlend;
    end;
  end;
end;

procedure TSplashScreen.AnimationTimerHideTimer(Sender: TObject);
begin
  if Animation = ssaShallow then
  begin
    if SplashForm.FormObject.AlphaBlendValue > 0 then
    begin
      if SplashForm.FormObject.AlphaBlendValue < AnimationSpeed then
      begin
        SplashForm.FormObject.AlphaBlendValue := SplashForm.FormObject.AlphaBlendValue - SplashForm.FormObject.AlphaBlendValue;
      end else
      begin
        SplashForm.FormObject.AlphaBlendValue := SplashForm.FormObject.AlphaBlendValue - AnimationSpeed;
      end;
    end else
    begin
      AnimationTimerHide.Enabled := False;
      SplashForm.FormObject.AlphaBlend := SplashForm.AlphaBlend;
      SplashForm.FormObject.Hide;
    end;
  end;
end;

{ ----------------------------------------------------------------------------
  TComponentManager
  ---------------------------------------------------------------------------- }

constructor TComponentManager.Create(AOwner: TComponent);
begin
  inherited;
  //...
end;

destructor TComponentManager.Destroy;
begin
  //...
  inherited;
end;

procedure TComponentManager.Update;
begin
  if Assigned(OnUpdate) then
  begin
    OnUpdate(Self);
  end;
end;

{ ----------------------------------------------------------------------------
  TProgressBarManager
  ---------------------------------------------------------------------------- }

constructor TProgressBarManager.Create(AOwner: TComponent);
begin
  inherited;
  FAbout := TComponentAbout.Create(ProgressBarManagerComponent_Name,ProgressBarManagerComponent_Version,ProgressBarManagerComponent_Copyright,ProgressBarManagerComponent_Author);
  FMode := pmmNone;

  Update;
end;

destructor TProgressBarManager.Destroy;
begin
  FAbout.Free;
  inherited;
end;

procedure TProgressBarManager.Update;
begin
  if Assigned(Target) = False then
  begin
    Exit;
  end;
  if Mode <> pmmNone then
  begin
    if (Mode = pmmBattery) and (Assigned(SourceBattery) = False)
    or (Mode = pmmDownload) and (Assigned(SourceDownload) = False) then
    begin
      Exit;
    end;
  end;
  if Mode = pmmBattery then
  begin
    Target.Position := (Target.Max div 100) * SourceBattery.GetBatteryPercent;
  end;
  if Mode = pmmDownload then
  begin
    Target.Position := (Target.Max div 100) * SourceDownload.GetProgressPercent;
  end;
  inherited;
end;

procedure TProgressBarManager.SetTarget(Value: TProgressBar);
begin
  FTarget := Value;
  Update;
end;

procedure TProgressBarManager.SetSourceBattery(Value: TBattery);
begin
  FSourceBattery := Value;
  if Mode = pmmBattery then
  begin
    Update;
  end;
end;

procedure TProgressBarManager.SetSourceDownload(Value: TDownload);
begin
  FSourceDownload := Value;
  if Mode = pmmDownload then
  begin
    Update;
  end;
end;

procedure TProgressBarManager.SetMode(Value: TProgressBarManagerMode);
begin
  FMode := Value;
  Update;
end;

{ ----------------------------------------------------------------------------
  TListBoxManager
  ---------------------------------------------------------------------------- }

constructor TListBoxManager.Create(AOwner: TComponent);
begin
  inherited;
  FAbout := TComponentAbout.Create(ListBoxManagerComponent_Name,ListBoxManagerComponent_Version,ListBoxManagerComponent_Copyright,ListBoxManagerComponent_Author);
  FMode := lmmNone;
  FFilterOptions := [sfoCaseSensitive,sfoForceTrim,sfoDefaultVisible];
  FilteredList := TFilteredStringList.Create;
  Update;
end;

destructor TListBoxManager.Destroy;
begin
  FAbout.Free;
  FilteredList.Free;
  inherited;
end;

procedure TListBoxManager.Update;
begin
  if Assigned(Target) = False then
  begin
    Exit;
  end;
  if Mode <> lmmNone then
  begin
    if (Mode = lmmEdit) and (Assigned(SourceEdit) = False)
    or (Mode = lmmComboBox) and (Assigned(SourceComboBox) = False) then
    begin
      Exit;
    end;
  end;
  if Mode = lmmEdit then
  begin
    FilteredList.Filter := SourceEdit.Text;
  end;
  if Mode = lmmComboBox then
  begin
    FilteredList.Filter := SourceComboBox.Text;
  end;
  Target.Items.Assign(FilteredList.FilteredStrings);
  inherited;
end;

procedure TListBoxManager.LoadList;
begin
  if Assigned(Target) then
  begin
    FilteredList.Assign(Target.Items);
  end;
end;

procedure TListBoxManager.SetTarget(Value: TListBox);
begin
  FTarget := Value;
  LoadList;
  Update;
end;

procedure TListBoxManager.SetSourceEdit(Value: TEdit);
begin
  FSourceEdit := Value;
  if Mode = lmmEdit then
  begin
    Update;
  end;
end;

procedure TListBoxManager.SetSourceComboBox(Value: TComboBox);
begin
  FSourceComboBox := Value;
  if Mode = lmmComboBox then
  begin
    Update;
  end;
end;

procedure TListBoxManager.SetMode(Value: TListBoxManagerMode);
begin
  FMode := Value;
  Update;
end;

procedure TListBoxManager.SetFilterOptions(Value: TStringFilterOptions);
begin
  FilteredList.FilterOptions := Value;
  FFilterOptions := Value;
  Update;
end;

{ ----------------------------------------------------------------------------
  TParamFormat
  ---------------------------------------------------------------------------- }

constructor TParamFormat.Create;
begin
  inherited;
  //...
end;

constructor TParamFormat.Create(APrefix,ASeparator,ASuffix: String);
begin
  Create;
  Prefix := APrefix;
  Separator := ASeparator;
  Suffix := ASuffix;
end;

destructor TParamFormat.Destroy;
begin
  //...
  inherited;
end;

procedure TParamFormat.SetPrefix(Value: String);
var
  Index: Integer;
begin
  for Index := 1 to Length(Value) do
  begin
    if Value[Index] in [#34,#39] then
    begin
      raise EInvalidParamFormat.Create('Invalid param format for property: "Prefix"');
    end;
  end;
  FPrefix := Value;
end;

procedure TParamFormat.SetSuffix(Value: String);
var
  Index: Integer;
begin
  for Index := 1 to Length(Value) do
  begin
    if Value[Index] in [#34,#39] then
    begin
      raise EInvalidParamFormat.Create('Invalid param format for property: "Suffix"');
    end;
  end;
  FSuffix := Value;
end;

procedure TParamFormat.SetSeparator(Value: String);
var
  Index: Integer;
begin
  for Index := 1 to Length(Value) do
  begin
    if Value[Index] in [#34,#39] then
    begin
      raise EInvalidParamFormat.Create('Invalid param format for property: "Seperator"');
    end;
  end;
  FSeparator := Value;
end;

{ ----------------------------------------------------------------------------
  TParamReference
  ---------------------------------------------------------------------------- }

constructor TParamReference.Create(Collection: TCollection);
begin
  inherited;
  FFormat := TParamFormat.Create;
  FIdentifier := ClassName + IntToStr(ID);
end;

destructor TParamReference.Destroy;
begin
  FConnector := nil;
  FFormat.Free;
  inherited;
end;

function TParamReference.GetFormat: TParamFormat;
begin
  Result := FFormat;
end;

procedure TParamReference.SetFormat(Value: TParamFormat);
begin
  FFormat := Value;
end;

procedure TParamReference.SetIdentifier(Value: String);
var
  Index: Integer;
begin
  if Length(Value) > 0 then
  begin
    for Index := 1 to Length(Value) do
    begin
      if (Value[Index] in Spaces) or (Value[Index] in [#34,#39]) then
      begin
        raise EInvalidParamIdentifier.Create('"' + Value + '" is not a valid identifier value');
      end;
    end;
  end else
  begin
    raise EInvalidParamIdentifier.Create('"' + Value + '" is not a valid identifier value');
  end;
  FIdentifier := Value;
end;

procedure TParamReference.Update;
var
  Value: String;
  ParamIndex: Integer;
  ParamItem: String;
  CharIndex: Integer;
  InPrefix: Boolean;
  InSep: Boolean;
  InDef: Boolean;
  InSuffix: Boolean;
begin
  Connector^ := DefaultValue;
  Value := '';
  for ParamIndex := 1 to ParamCount do
  begin
    InPrefix := True;
    InSuffix := False;
    InSep := False;
    InDef := False;
    ParamItem := ParamStr(ParamIndex);
    CharIndex := 1;
    while CharIndex <= Length(ParamItem) do
    begin
      //[X----]
      if InPrefix = True then
      begin
        if Length(Format.Prefix) = 0 then
        begin
          InPrefix := False;
          Continue;
        end;
        if ParamItem[CharIndex] = Format.Prefix[CharIndex] then
        begin
          if CharIndex = Length(Format.Prefix) then
          begin
            InPrefix := False;
          end;
        end else
        begin
          Break;
        end;
      end else
      begin
        //[----X]
        if InSuffix = True then
        begin
          if (ParamItem[CharIndex] = Format.Suffix[CharIndex - Length(Format.Prefix + Identifier + Format.Separator + Value)]) then
          begin
            if CharIndex = Length(ParamItem) then
            begin
              //--> EXIT <--
              Connector^ := Value;
              Exit;
            end;
          end else
          begin
            Break;
          end;
        end else
        //Identifier [ InIdent := not (InPrefix or InSuffix) ]
        begin
          //[--X--]
          if InSep = True then
          begin
            if Length(Format.Separator) = 0 then
            begin
              InSep := False;
              InDef := True;
              Continue;
            end;
            if ParamItem[CharIndex] = Format.Separator[CharIndex - Length(Format.Prefix + Identifier)] then
            begin
              if CharIndex = Length(Format.Prefix + Identifier + Format.Separator) then
              begin
                InSep := False;
                InDef := True;
              end;
            end else
            begin
              Break;
            end;
          end else
          begin
            //[---X-]
            if InDef = True then
            begin
              Value := Value + ParamItem[CharIndex];
              if CharIndex = Length(ParamItem) - Length(Format.Suffix) then
              begin
                InDef := False;
                InSuffix := True;
                if Length(Format.Suffix) = 0 then
                begin
                  //--> EXIT <--
                  Connector^ := Value;
                  Exit;
                end;
              end;
            end else
            begin
              //[-X---]
              if ParamItem[CharIndex] = Identifier[CharIndex - Length(Format.Prefix)] then
              begin
                if CharIndex = Length(Identifier + Format.Prefix) then
                begin
                  InSep := True;
                end;
              end else
              begin
                Break;
              end;
            end;
          end;
        end;
      end;
      Inc(CharIndex);
    //While (CharIndex)
    end;
  //For (ParamIndex)
  end;
  raise EParamNotFound.Create('Parameter "' + Identifier + '" not found');
end;

function TParamReference.AsText(UseDefVal: Boolean = False): String;
begin
  Result := StringFromParamRef(Self,UseDefVal);
end;

{ ----------------------------------------------------------------------------
  TParamDefiner
  ---------------------------------------------------------------------------- }

constructor TParamDefiner.Create;
begin
  inherited;
  FAbout := TComponentAbout.Create(ParamDefinerComponent_Name,ParamDefinerComponent_Version,ParamDefinerComponent_Copyright,ParamDefinerComponent_Author);
  FReferences := TParamReferences.Create(TParamReference);
end;

destructor TParamDefiner.Destroy;
begin
  FAbout.Free;
  FReferences.Free;
  inherited;
end;

procedure TParamDefiner.SetReferences(Value: TParamReferences);
begin
  FReferences := Value;
end;

procedure TParamDefiner.Update;
var
  Index: Integer;
begin
  if References.Count > 0 then
  begin
    try
      for Index := 0 to References.Count - 1 do
      begin
        (References.Items[Index] as TParamReference).Update;
      end;
    finally
      if Assigned(OnUpdate) = True then
      begin
        OnUpdate(Self);
      end;
    end;
  end;
end;

end.
