lina-components/Source/uFrmCtrls.pas

unit uFrmCtrls;

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

interface

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

type
  { Hilfsklassen }
  TSplashScreenMode = (ssmDefault,ssmModal);
  TSplashScreenAnimation = (ssaNone,ssaShallow);
  TProgressBarManagerMode = (pmmNone,pmmBattery,pmmDownload);
  TListBoxManagerMode = (lmmNone,lmmEdit,lmmComboBox);
  TParamReferenceType = (prtAutomatic,prtChar,prtString,prtInteger,prtFloat);

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;

type
  { Hauptklassen }

  { TSplash... }
  TSplashForm = class
  private
    { Private-Deklarationen }
    FBorderStyle: TFormBorderStyle;
    FBorderIcons: TBorderIcons;
    FLeft: Integer;
    FTop: Integer;
    FWidth: Integer;
    FHeight: Integer;
    FAlign: TAlign;
    FAlphaBlend: Boolean;
    FAlphaBlendValue: Byte;
    FCaption: TCaption;
    FColor: TColor;
    FEnabled: Boolean;
    FWindowState: TWindowState;
    FPosition: TPosition;
    FCursor: TCursor;
  public
    { Public-Deklarationen }
    constructor Create;
    destructor Destroy; override;
  published
    { Published-Deklarationen }
    property BorderStyle: TFormBorderStyle read FBorderStyle write FBorderStyle default bsNone;
    property BorderIcons: TBorderIcons read FBorderIcons write FBorderIcons default [];
    property Left: Integer read FLeft write FLeft default 0;
    property Top: Integer read FTop write FTop default 0;
    property Width: Integer read FWidth write FWidth default 600;
    property Height: Integer read FHeight write FHeight default 400;
    property Align: TAlign read FAlign write FAlign default alNone;
    property AlphaBlend: Boolean read FAlphaBlend write FAlphaBlend default False;
    property AlphaBlendValue: Byte read FAlphaBlendValue write FAlphaBlendValue default 255;
    property Caption: TCaption read FCaption write FCaption;
    property Color: TColor read FColor write FColor default clBtnFace;
    property Enabled: Boolean read FEnabled write FEnabled default True;
    property WindowState: TWindowState read FWindowState write FWindowState default wsNormal;
    property Position: TPosition read FPosition write FPosition default poScreenCenter;
    property Cursor: TCursor read FCursor write FCursor default crHourGlass;
  end;

  TSplashProgressBar = class
  private
    { Private-Deklarationen }
    FLeft: Integer;
    FTop: Integer;
    FWidth: Integer;
    FHeight: Integer;
    FVisible: Boolean;
    FPosition: Integer;
    FMin: Integer;
    FMax: Integer;
    FAlign: TAlign;
    FBackgroundColor: TColor;
    FBarColor: TColor;
    FState: TProgressBarState;
    FStyle: TProgressBarStyle;
    FSmooth: Boolean;
    FSmoothReverse: Boolean;
    FMarqueeInterval: Integer;
    FStep: Integer;
  public
    { Public-Deklarationen }
    constructor Create;
    destructor Destroy; override;
  published
    { Published-Deklarationen }
    property Left: Integer read FLeft write FLeft default 250;
    property Top: Integer read FTop write FTop default 250;
    property Width: Integer read FWidth write FWidth default 100;
    property Height: Integer read FHeight write FHeight default 50;
    property Visible: Boolean read FVisible write FVisible default True;
    property Position: Integer read FPosition write FPosition default 0;
    property Max: Integer read FMax write FMax default 100;
    property Min: Integer read FMin write FMin default 0;
    property Align: TAlign read FAlign write FAlign default alNone;
    property BackgroundColor: TColor read FBackgroundColor write FBackgroundColor default clDefault;
    property BarColor: TColor read FBarColor write FBarColor default clDefault;
    property State: TProgressBarState read FState write FState default pbsNormal;
    property Style: TProgressBarStyle read FStyle write FStyle default pbstNormal;
    property Smooth: Boolean read FSmooth write FSmooth default False;
    property SmoothReverse: Boolean read FSmoothReverse write FSmoothReverse default False;
    property MarqueeInterval: Integer read FMarqueeInterval write FMarqueeInterval default 10;
    property Step: Integer read FStep write FStep default 10;
  end;

  TSplashImage = class
  private
    { Private-Deklarationen }
    FVisible: Boolean;
    FTransparent: Boolean;
    FPicture: TPicture;
  public
    { Public-Deklarationen }
    constructor Create;
    destructor Destroy; override;
  published
    { Published-Deklarationen }
    property Visible: Boolean read FVisible write FVisible default True;
    property Transparent: Boolean read FTransparent write FTransparent default False;
    property Picture: TPicture read FPicture write FPicture;
  end;

  TSplashTimer = class
  private
    { Private-Deklarationen }
    FEnabled: Boolean;
    FInterval: Cardinal;
  public
    { Public-Deklarationen }
    constructor Create;
    destructor Destroy;
  published
    { Published-Deklarationen }
    property Enabled: Boolean read FEnabled write FEnabled default False;
    property Interval: Cardinal read FInterval write FInterval default 1000;
  end;

  TSplashScreen = class(TComponent)
  private
    { Private-Deklarationen }
    FormObject: TForm;
    ProgressBarObject: TProgressBar;
    ImageObject: TImage;
    TimerObject: TTimer;
    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 FormObjectShow(Sender: TObject);
    procedure FormObjectHide(Sender: TObject);
    procedure TimerObjectTimer(Sender: TObject);
    procedure AnimationTimerShowTimer(Sender: TObject);
    procedure AnimationTimerHideTimer(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 FSplashForm;
    property SplashProgressBar: TSplashProgressBar read FSplashProgressBar write FSplashProgressBar;
    property SplashImage: TSplashImage read FSplashImage write FSplashImage;
    property SplashTimer: TSplashTimer read FSplashTimer write FSplashTimer;
    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;
  published
    { Published-Deklarationen }
    { Ereignisse }
    property OnUpdate: TComponentManagerUpdateEvent read FUpdateEvent write FUpdateEvent;
    { Eigenschaften }
    property About: TComponentAbout read FAbout;
  end;

  TProgressBarManager = class(TComponentManager)
  private
    { Private-Deklarationen }
    FAbout: TComponentAbout;
    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;
  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;
    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
  private
    { Private-Deklarationen }
    FPrefix: String;
    FSuffix: String;
    FSeperator: String;
  public
    { Public-Deklarationen }
    constructor Create;
    destructor Destroy; override;
  published
    { Published-Deklarationen }
    property Prefix: String read FPrefix write FPrefix;
    property Suffix: String read FSuffix write FSuffix;
    property Seperator: String read FSeperator write FSeperator;
  end;

  TParamReference = class
  private
    { Private-Deklarationen }
    FParamType: TParamReferenceType;
    FDefaultValue: Variant;
    FConnector: Pointer;
    FFormat: TParamFormat;
  public
    { Public-Deklarationen }
    constructor Create;
    destructor Destroy; override;
  published
    { Published-Deklarationen }
    property ParamType: TParamReferenceType read FParamType write FParamType default prtAutomatic;
    property DefaultValue: Variant read FDefaultValue write FDefaultValue;
  //  property Connector: Pointer read FConnector write FConnector;
    property Format: TParamFormat read FFormat write FFormat;
  end;

  TParamDefiner = class(TComponent)
  private
    { Private-Deklarationen }
    FAbout: TComponentAbout;
 //   FReferences: TObjectList;
  public
    { Public-Deklarationen }
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;
 //   property References [Index]: TParamReference read FReferences write FReferences;
  published
    { Published-Deklarationen }
    property About: TComponentAbout read FAbout;
  end;

  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]);
end;

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

constructor TSplashForm.Create;
begin
  //...
end;

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

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

constructor TSplashProgressBar.Create;
begin
  //...
end;

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

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

constructor TSplashImage.Create;
begin
  FPicture := TPicture.Create;
end;

destructor TSplashImage.Destroy;
begin
  FPicture.Free;
  inherited;
end;

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

constructor TSplashTimer.Create;
begin
  //...
end;

destructor TSplashTimer.Destroy;
begin
  //...
  inherited;
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;
  FSplashProgressBar := TSplashProgressBar.Create;
  FSplashImage := TSplashImage.Create;
  FSplashTimer := TSplashTimer.Create;

  FormObject := TForm.Create(Self);
  FormObject.OnShow := FormObjectShow;
  FormObject.OnHide := FormObjectHide;
  FormObject.Visible := False;
  ProgressBarObject := TProgressBar.Create(Self);
  ProgressBarObject.Parent := FormObject;
  ImageObject := TImage.Create(Self);
  ImageObject.Parent := FormObject;
  TimerObject := TTimer.Create(Self);
  TimerObject.OnTimer := TimerObjectTimer;
  TimerObject.Enabled := False;

  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;
  FSplashForm.Free;
  FSplashProgressBar.Free;
  FSplashImage.Free;
  FSplashTimer.Free;
  FormObject.Close;
  FormObject.Free;
  //ProgressBarObject.Free;      _
  //ImageObject.Free;             |
  //TimerObject.Free;             |____\  Automatisch
  //AnimationTimerShow.Free;      |    /  freigegeben
  //AnimationTimerHide.Free;     _|
  inherited;
end;

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

procedure TSplashScreen.Hide;
begin
  TimerObject.Enabled := False;
  if Animation = ssaNone then
  begin
    FormObject.Hide;
  end else
  begin
    if Animation = ssaShallow then
    begin
      FormObject.AlphaBlend := True;
      AnimationTimerShow.Enabled := False;
      AnimationTimerHide.Enabled := True;
    end;
  end;
  FVisible := False;
  if Assigned(OnHide) then
  begin
    OnHide(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 }
  FormObject.BorderStyle := SplashForm.BorderStyle;
  FormObject.BorderIcons := SplashForm.BorderIcons;
  FormObject.Left := SplashForm.Left;
  FormObject.Top := SplashForm.Top;
  FormObject.Width := SplashForm.Width;
  FormObject.Height := SplashForm.Height;
  FormObject.Align := SplashForm.Align;
  FormObject.AlphaBlend := SplashForm.AlphaBlend;
  FormObject.AlphaBlendValue := SplashForm.AlphaBlendValue;
  FormObject.Caption := SplashForm.Caption;
  FormObject.Color := SplashForm.Color;
  FormObject.Enabled := SplashForm.Enabled;
  FormObject.WindowState := SplashForm.WindowState;
  FormObject.Position := SplashForm.Position;
  FormObject.Cursor := SplashForm.Cursor;
  { TSplashProgressBar -> TProgressBar }
  ProgressBarObject.Left := SplashProgressBar.Left;
  ProgressBarObject.Top := SplashProgressBar.Top;
  ProgressBarObject.Width := SplashProgressBar.Width;
  ProgressBarObject.Height := SplashProgressBar.Height;
  ProgressBarObject.Visible := SplashProgressBar.Visible;
  ProgressBarObject.Position := SplashProgressBar.Position;
  ProgressBarObject.Max := SplashProgressBar.Max;
  ProgressBarObject.Min := SplashProgressBar.Min;
  ProgressBarObject.Cursor := FormObject.Cursor;
  ProgressBarObject.Align := SplashProgressBar.Align;
  ProgressBarObject.BackgroundColor := SplashProgressBar.BackgroundColor;
  ProgressBarObject.BarColor := SplashProgressBar.BarColor;
  ProgressBarObject.State := SplashProgressBar.State;
  ProgressBarObject.Style := SplashProgressBar.Style;
  ProgressBarObject.Smooth := SplashProgressBar.Smooth;
  ProgressBarObject.SmoothReverse := SplashProgressBar.SmoothReverse;
  ProgressBarObject.MarqueeInterval := SplashProgressBar.MarqueeInterval;
  ProgressBarObject.Step := SplashProgressBar.Step;
  { TSplashImage -> TImage }
  ImageObject.Visible := SplashImage.Visible;
  ImageObject.Transparent := SplashImage.Transparent;
  ImageObject.Picture := SplashImage.Picture;
  { TSplashTimer -> TTimer }
  TimerObject.Enabled := SplashTimer.Enabled;
  TimerObject.Interval := SplashTimer.Interval;
  if Assigned(OnChange) then
  begin
    OnChange(Self);
  end;
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
    Show;
  end else
  begin
    Hide;
  end;
end;

procedure TSplashScreen.FormObjectShow(Sender: TObject);
begin
  //...
end;

procedure TSplashScreen.FormObjectHide(Sender: TObject);
begin
  //...
end;

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

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

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

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

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

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

procedure TComponentManager.Update;
begin
  //...
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
  inherited;
  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;
  if Assigned(OnUpdate) then
  begin
    OnUpdate(Self);
  end;
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
  inherited;
  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);
  if Assigned(OnUpdate) then
  begin
    OnUpdate(Self);
  end;
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
  //...
end;

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

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

constructor TParamReference.Create;
begin
  FFormat := TParamFormat.Create;
end;

destructor TParamReference.Destroy;
begin
  FFormat.Free;
  inherited;
end;

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

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

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

end.