Tutorial: Erstellen von LiveBindings-fähigen Komponenten

Nach oben zu Tutorials zu Datenbanken und LiveBindings

Dieses Tutorial zeigt das Erstellen von Komponenten, die mit LiveBindings eingesetzt werden können. In diesem Tutorial wird eine benutzerdefinierte TTrackBar-Komponente eingerichtet, die mit LiveBindings eingesetzt werden kann.

Wenn Sie eine TTrackBar-Komponente auf einem Formular ablegen, zeigt der LiveBindings-Designer die Komponente ohne registrierte Eigenschaften an (siehe die folgende Abbildung).

Der Grund dafür ist, dass TTrackBar nicht für die Verwendung mit LiveBindings aktiviert ist. Damit eine Komponente mit LiveBindings eingesetzt werden kann, müssen zwei Voraussetzungen erfüllt sein:

• Das Steuerelement muss die Observer-Unterstützung implementieren, weil LiveBindings-Komponenten zum Abonnieren von Steuerelementbenachrichtigungen auf Observer angewiesen sind.
• Der Name des Steuerwertes (z. B.: Position für TTrackBar) muss registriert werden. Mit diesem Steuerwertnamen können LiveBindings-Komponenten Ausdrücke zum Abrufen und Setzen des Wertes des Steuerelements erzeugen.

Eine TTrackBar-Komponente kann für dieses Verhalten nicht direkt geändert werden, daher muss die Observer-Unterstützung in einer abgeleiteten Klasse implementiert werden. Diese Klasse wird in diesem Tutorial erstellt.

Erstellen der neuen beobachtbaren TTrackBar-Komponente

Die Klasse, die den beobachtbaren Schieberegler implementiert, wird in diesem Tutorial TObservableTrackbar und die Unit VCL.Sample.ObservableTrackbar genannt.

Im Folgenden finden Sie den interface-Abschnitt der Komponente TObservableTrackbar.

unit VCL.Sample.ObservableTrackbar;

interface

uses
  Vcl.ComCtrls, System.Classes, WinApi.Messages, WinApi.CommCtrl, Vcl.Controls;

type
  [ObservableMember('Position')]                            { identifies the control value name for TObservableTrackbar }
  TObservableTrackBar = class(TTrackBar)
  private
    procedure CNHScroll(var Message: TWMHScroll); message CN_HSCROLL;
    procedure CNVScroll(var Message: TWMVScroll); message CN_VSCROLL;
    procedure ObserverToggle(const AObserver: IObserver; const Value: Boolean);
  protected
    function CanObserve(const ID: Integer): Boolean; override;                       { declaration is in System.Classes }
    procedure ObserverAdded(const ID: Integer; const Observer: IObserver); override; { declaration is in System.Classes }
  end;

implementation-Abschnitt:

implementation

uses
  System.SysUtils;

{ TObservableTrackBar }

function TObservableTrackBar.CanObserve(const ID: Integer): Boolean;
{ Controls which implement observers always override TComponent.CanObserve(const ID: Integer). }
{ This method identifies the type of observers supported by TObservableTrackbar. }
begin
  case ID of
    TObserverMapping.EditLinkID,      { EditLinkID is the observer that is used for control-to-field links }
    TObserverMapping.ControlValueID:
      Result := True;
  else
    Result := False;
  end;
end;

{ The overrides for CNHscroll and CNVScroll are where TObservableTrackBar calls the
  observable interfaces to notify LiveBindings components when the user moves the thumb.
  These two overrides are sufficient to monitor user input to TObservableTrackbar.
  TLinkObservers.ControlChanged is a utility method that does most of the work. You can
  find the implementation in System.Classes. }
procedure TObservableTrackBar.CNHScroll(var Message: TWMHScroll);
var
  LPosition: Integer;
begin
  LPosition := Position;

  inherited;

  if LPosition <> Position then
    TLinkObservers.ControlChanged(Self);
end;

procedure TObservableTrackBar.CNVScroll(var Message: TWMVScroll);
var
  LPosition: Integer;

begin
  Message.Result := 0;
  LPosition := Position;

  inherited;

  if LPosition <> Position then
    TLinkObservers.ControlChanged(Self);
end;

{ The following methods prevent the user from moving the thumb when TObservableTrackBar
  is linked to a read-only field. }
procedure TObservableTrackBar.ObserverAdded(const ID: Integer; const Observer: IObserver);
begin
  if ID = TObserverMapping.EditLinkID then
    Observer.OnObserverToggle := ObserverToggle;
end;

{ All controls that support the EditLink observer should prevent the user from changing the
  control value. Disabling the control is one way to do it. Some observer implementations ignore
  certain types of input to prevent the user from changing the control value. }
procedure TObservableTrackBar.ObserverToggle(const AObserver: IObserver; const Value: Boolean);
var
  LEditLinkObserver: IEditLinkObserver;

begin
  if Value then
  begin
    if Supports(AObserver, IEditLinkObserver, LEditLinkObserver) then
      { disable the trackbar if the associated field does not support editing }
      Enabled := not LEditLinkObserver.IsReadOnly;
  end else
    Enabled := True;
end;

end.

Registrieren der neuen beobachtbaren TTrackBar-Komponente

Um die TObservableTrackBar-Komponente im LiveBindings-Designer vollständig zu aktivieren, müssen Sie sie registrieren. Die Eigenschaft für den Steuerwertnamen muss mit der Methode RegisterObservableMember() registriert werden. Dieser Code kann in die Unit aufgenommen werden, in der auch die Komponente registriert wird.

unit VCL.Sample.ObservableTrackbarReg;

interface

procedure Register;

implementation

uses
  System.Classes, VCL.Sample.ObservableTrackbar, Data.Bind.Components;

procedure Register;
begin
  RegisterComponents('LiveBindings Samples', [TObservableTrackBar]);
end;

initialization
  Data.Bind.Components.RegisterObservableMember(TArray<TClass>.Create(TObservableTrackBar), 'Position', 'DFM');

finalization
  Data.Bind.Components.UnregisterObservableMember(TArray<TClass>.Create(TObservableTrackBar));

end.

Position wird an zwei Stellen als Steuerwertname definiert:

• In VCL.Sample.ObservableTrackbar.pas mit dem Attribut ObservableMember
• In VCL.Sample.ObservableTrackbarReg.pas durch Aufruf von RegisterObservableMember()

Mit dem Attribut ObservableMember erzeugen LiveBindings-Komponenten Ausdrücke. Mit RegisterObserverableMember() wird beim Entwurf der LiveBindings-Designer informiert.

Verwenden der neuen beobachtbaren TTrackBar-Komponente

Nach der Installation eines Package, das VCL.Sample.ObservableTrackbar.pas und VCL.Sample.ObservableTrackbarReg.pas enthält, kann TObservableTrackbar in der Komponentenpalette ausgewählt werden. TObservableTrackbar wird im LiveBindings-Designer wie in der folgenden Abbildung dargestellt:

Jetzt können Sie im LiveBindings-Designer ObservableTracker1.Position mit einem Feld (oder mit einer anderen Objekteigenschaft) verbinden.

Schlussfolgerung

Anhand dieses Prototyps können Sie in RAD Studio eigene Komponenten für LiveBindings folgendermaßen erstellen:

• Implementieren der Observer-Unterstützung
• Registrieren des Steuerwertnamens

Siehe auch

• LiveBindings in RAD Studio
• LiveBindings-Designer
• RAD Studio – Tutorials
• TObserverMapping