Position et Dimensions des TControls

Sources :

• https://lazarus-ccr.sourceforge.io/docs/lcl/controls/tsizeconstraints.html
• https://lazarus-ccr.sourceforge.io/docs/lcl/controls/tcontrol.constraints.html

TControl.Constraints peut être utiliser pour définir les dimensions max et min d'un Control.

published
  property OnChange: TNotifyEvent;  // [rw] Event handler for a change in the constraints.
  property MaxHeight: TConstraintSize; // [rw] The maximum height.
  property MaxWidth: TConstraintSize; // [rw]  The maximum width.
  property MinHeight: TConstraintSize; // [rw]  The minimum height.
  property MinWidth: TConstraintSize; // [rw] The minimum width.
end;

Un exemple d'utilisation est donné ci-dessous dans la section AdjustClientRect

Source : https://lazarus-ccr.sourceforge.io/docs/lcl/controls/tcontrol.getlogicalclientrect.html

La fonction TControl.GetLogicalClientRect a pour rôle d'obtenir les dimensions de la zone cliente d'un contrôle en tenant compte des coordonnées logiques. Cela signifie qu'elle retourne la zone disponible pour les composants enfants, excluant les bordures et autres éléments non-clients, en tenant compte des transformations ou des échelles logiques appliquées au contrôle.

Rôle de GetLogicalClientRect :

• Récupération des dimensions réelles : La méthode renvoie un rectangle (TRect) représentant les dimensions de la zone cliente en coordonnées logiques.
• Gestion des transformations : Elle prend en compte les transformations éventuelles, telles que l'échelle, les rotations ou les autres modifications logiques appliquées au contrôle.

Source : https://lazarus-ccr.sourceforge.io/docs/lcl/controls/twincontrol.adjustclientrect.html

TWinControl.AdjustClientRect est une méthode appelée pour ajuster la zone cliente d'un contrôle fenêtré, c'est-à-dire l'espace disponible pour ses composants enfants. Elle permet de :

• Redéfinir la zone cliente en tenant compte des bordures, marges, ou autres éléments spécifiques au contrôle.
• Personnaliser la zone disponible pour les composants enfants en fonction des besoins du contrôle.

Les classes descendants peuvent redéfinir cette méthode pour modifier Rect, représentant la zone cliente, afin de gérer précisément l'espace intérieur du contrôle.

Exemple d'utilisation : Utiliser les Constraints pour definir une largeur et hauteur minimale

type
  TMyControl = class(TWinControl)
  protected
    procedure AdjustClientRect(var Rect: TRect); override; //surcharge de la méthode
  end;
 
procedure TMyControl.AdjustClientRect(var ARect: TRect);
begin
  inherited AdjustClientRect(ARect); // Appeler la méthode héritée pour ajustements de base
  ARect.Height:=max(Constraints.MinHeight,ARect.Height); // Empêche la hauteur d'etre inferieur à la hauteur minimale contenue dans Contraints
  ARect.Width:=max(Constraints.MinWidth,ARect.Width); // Pareil pour la largeur
end;

Comme indiqué dans le code, la méthode AdjustClientRect est appelée fréquemment, donc n'y mettez pas de code coûteux, ou mettez en cache le résultat.

\lcl\include\wincontrol.inc

{------------------------------------------------------------------------------
  TWinControl AdjustClientRect
------------------------------------------------------------------------------}
procedure TWinControl.AdjustClientRect(var ARect: TRect);
begin
  // Can be overriden.
  // It's called often, so don't put expensive code here, or cache the result
end;

Avec cette méthode on rajoute un Handler au Parent qui appel notre procédure OnParentResizeHandler a chaque redimensionnement du Parent.

On surcharge la procedure SetParent afin de prevenir tout changement de Parent et de maintenir le bon Handler sur le bon Parent.

  TMyControl = class(TCustomControl)
  private
    procedure OnParentResizeHandler(Sender: TObject);
  protected
    procedure SetParent(NewParent: TWinControl); override;
  public ...
  end;
 
 
procedure TMyControl.OnParentResizeHandler(Sender: TObject);
begin
  Debugln('%s.OnParentResizeHandler PWith[%d]', [Name, Parent.ClientWidth]);
end;
 
procedure TMyControl.SetParent(NewParent: TWinControl);
var
  vOldParent: TWinControl;
begin
  vOldParent := Parent;
  inherited SetParent(NewParent);
  if Parent <> vOldParent then
  begin
    if assigned(vOldParent) then
      vOldParent.RemoveHandlerOnResize(@OnParentResizeHandler);
    if assigned(Parent) then
      Parent.AddHandlerOnResize(@OnParentResizeHandler, False);
  end;
end;