Tutoriel : Création de composants activés LiveBindings

Remonter à Tutoriels Bases de données et LiveBindings

Ce tutoriel montre comment créer des composants pouvant être utilisés avec LiveBindings. Dans ce tutoriel, vous activerez un composant TTrackBar personnalisé pouvant être utilisé avec LiveBindings.

Notez que chaque fois que vous déposez un composant TTrackBar sur une fiche, le Concepteur LiveBindings l'affiche sans propriété recensée, comme sur la figure ci-dessous.

C'est parce que TTrackBar n'a pas été activé pour une utilisation avec LiveBindings. Pour pouvoir activer un composant pour une utilisation avec LiveBindings, les deux exigences suivantes doivent être remplies :

• Le contrôle doit implémenter le support des observateurs, car LiveBindings dépend des observateurs pour l'abonnement aux notifications de contrôles.
• Vous devez recenser le nom de la valeur du contrôle (par exemple : Position pour TTrackBar). Le nom de la valeur du contrôle est utilisé par les composants LiveBindings pour générer des expressions qui obtiennent et définissent la valeur du contrôle.

Un composant TTrackBar ne peut pas être modifié directement pour ce comportement. Le support de l'observateur doit donc être implémenté dans une classe descendante que vous allez créer en suivant les étapes de ce tutoriel.

Création du nouveau composant TTrackBar observable

Nous allons nommer la classe qui implémentera la barre de suivi observable TObservableTrackbar, et l'unité quant à elle sera appelée VCL.Sample.ObservableTrackbar.

Voici la section interface du composant 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;

Voici la section implementation :

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.

Recensement du nouveau composant TTrackBar observable

Pour que TObservableTrackBar soit entièrement activé pour le Concepteur LiveBindings, vous devez le recenser. La propriété du nom de valeur du contrôle doit être recensée en utilisant la méthode RegisterObservableMember(). Ce code peut être utilisé dans la même unité qui recense le composant.

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 est identifiée comme le nom de valeur du contrôle à deux endroits :

• dans VCL.Sample.ObservableTrackbar.pas avec l'attribut ObservableMember ;
• dans VCL.Sample.ObservableTrackbarReg.pas en appelant RegisterObservableMember().

L'attribut ObservableMember sera utilisé par les composants LiveBindings pour générer des expressions. RegisterObserverableMember() sera utilisé en conception pour informer le Concepteur LiveBindings.

Utilisation du nouveau composant TTrackBar observable

Après avoir installé un package qui contient VCL.Sample.ObservableTrackbar.pas et VCL.Sample.ObservableTrackbarReg.pas, TObservableTrackbar peut être sélectionné dans la palette des composants. TObservableTrackbar est représenté dans le Concepteur LiveBindings comme dans la figure ci-dessous :

Vous pouvez maintenant connecter ObservableTracker1.Position à un champ (ou à une autre propriété d'objet) en utilisant le Concepteur LiveBindings.

Conclusion

En suivant ce prototype, vous pouvez concevoir vos propres composants activés LiveBindings dans RAD Studio en procédant simplement comme suit :

• implémentation du support de l'observateur ;
• recensement du nom de la valeur du contrôle.

Voir aussi

• LiveBindings dans RAD Studio
• Concepteur LiveBindings
• Tutoriels RAD Studio
• TObserverMapping