Delphi-PRAXiS - Numerische Eingabe in Stinggrid validieren

Die einzige zuverlässige Art ist die Verwendung eines

Memento und einer Prüfung, ob der aktuelle Wert den Anforderungen entspricht.

Wenn ja, dann wird der aktuelle Wert in das Memento übernommen, wenn nein, dann wird der Wert aus dem Memento wiederhergestellt.

Delphi-Quellcode:

			unit EditGuardian;

interface

uses

  System.Generics.Collections,

  System.Classes, System.SysUtils,

  Vcl.StdCtrls;

type

  TEditMemento = class( TPersistent )

  private

    FSelStart: Integer;

    FSelLength: Integer;

    FText: string;

    procedure AssignFromCustomEdit( ASource: TCustomEdit );

    procedure AssignToCustomEdit( ADest: TCustomEdit );

    procedure AssignToEditMemento( ADest: TEditMemento );

  protected

    procedure AssignTo( Dest: TPersistent ); override;

  public

    procedure Assign( Source: TPersistent ); override;

  end;

  TEditGuardian = class

  private

    FEdit: TCustomEdit;

    FMemento: TEditMemento;

    FValidator: TPredicate<string>;

  public

    constructor Create( AEdit: TCustomEdit; AValidator: TPredicate<string> );

    destructor Destroy; override;

    procedure Validate;

  end;

implementation

{ TEditMemento }

procedure TEditMemento.Assign( Source: TPersistent );

begin

  if Source is TCustomEdit

  then

    AssignFromCustomEdit( Source as TCustomEdit )

  else

    inherited;

end;

procedure TEditMemento.AssignFromCustomEdit( ASource: TCustomEdit );

begin

  Self.FText := ASource.Text;

  Self.FSelStart := ASource.SelStart;

  Self.FSelLength := ASource.SelLength;

end;

procedure TEditMemento.AssignTo( Dest: TPersistent );

begin

  if Dest is TCustomEdit

  then

    AssignToCustomEdit( Dest as TCustomEdit )

  else if Dest is TEditMemento

  then

    AssignToEditMemento( Dest as TEditMemento )

  else

    inherited;

end;

procedure TEditMemento.AssignToCustomEdit( ADest: TCustomEdit );

begin

  ADest.Text := Self.FText;

  ADest.SelStart := Self.FSelStart;

  ADest.SelLength := Self.FSelLength;

end;

procedure TEditMemento.AssignToEditMemento( ADest: TEditMemento );

begin

  ADest.FText := Self.FText;

  ADest.FSelStart := Self.FSelStart;

  ADest.FSelLength := Self.FSelLength;

end;

{ TEditGuardian }

constructor TEditGuardian.Create( AEdit: TCustomEdit; AValidator: TPredicate<string> );

begin

  inherited Create;

  if not Assigned( AEdit )

  then

    raise EArgumentNilException.Create( 'AEdit' );

  if not Assigned( AValidator )

  then

    raise EArgumentNilException.Create( 'AValidator' );

  FEdit := AEdit;

  FMemento := TEditMemento.Create;

  FValidator := AValidator;

  Validate;

end;

destructor TEditGuardian.Destroy;

begin

  FMemento.Free;

  inherited;

end;

procedure TEditGuardian.Validate;

begin

  if ( FEdit.Text = '' ) or FValidator( FEdit.Text )

  then

    FMemento.Assign( FEdit )

  else

    FEdit.Assign( FMemento );

end;

end.

Und hier ein kleines Beispiel mit 3 Edits (Integer, Float, Frei)

Delphi-Quellcode:

			unit FormMain;

interface

uses

  Winapi.Windows, Winapi.Messages,

  System.SysUtils, System.Variants, System.Classes, System.Generics.Collections,

  Vcl.Graphics, Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls, Vcl.AppEvnts,

  EditGuardian;

type

  TMainForm = class( TForm )

    Edit1: TEdit;

    Edit2: TEdit;

    Edit3: TEdit;

    ApplicationEvents1: TApplicationEvents;

    procedure ApplicationEvents1Idle( Sender: TObject; var Done: Boolean );

  private

    FGuardians: TList<TEditGuardian>;

    procedure CheckGuardians;

  public

    procedure AfterConstruction; override;

    procedure BeforeDestruction; override;

  end;

var

  MainForm: TMainForm;

implementation

{$R *.dfm}

procedure TMainForm.AfterConstruction;

begin

  inherited;

  FGuardians := TObjectList<TEditGuardian>.Create;

  // Integer Edit

  FGuardians.Add( TEditGuardian.Create( Edit1,

        function( AValue: string ): Boolean

    var

      LValue: Integer;

    begin

      Result := TryStrToInt( AValue, LValue );

    end ) );

  // FloatEdit

  FGuardians.Add( TEditGuardian.Create( Edit2,

    function( AValue: string ): Boolean

    var

      LValue: Extended;

    begin

      Result := TryStrToFloat( AValue, LValue );

    end ) );

end;

procedure TMainForm.ApplicationEvents1Idle( Sender: TObject; var Done: Boolean );

begin

  CheckGuardians;

end;

procedure TMainForm.BeforeDestruction;

begin

  inherited;

  FGuardians.Free;

end;

procedure TMainForm.CheckGuardians;

var

  LGuardian: TEditGuardian;

begin

  for LGuardian in FGuardians do

    LGuardian.Validate;

end;

end.

Und wie man sieht ist es völlig unerheblich welche Taste auch immer gedrückt wurde, oder auf welchem Weg der Wert es in das Edit-Control geschafft haben könnte. Passt der Wert nicht, wird einfach der alte Zustand wiederhergestellt.

Drops gelutscht :mrgreen:

PS Wer jetzt anmerken möchte, dass man dort keine negativen Zahlen eingeben kann, weil ein einfaches

Delphi-Quellcode:

einfach geschluckt wird, der passt entweder den Validator an, oder viel besser erstellt sich eine eigene

Delphi-Quellcode:

TryStrToMyValue

und berücksichtigt dort diese Eingabe und nimmt diese in den Validator mit auf. Denn irgendwann will man den Wert aus dem Edit wieder auslesen und dann benutzt man einfach diesen

Delphi-Quellcode:

TryStrToMyValue