Différences

Ci-dessous, les différences entre deux révisions de la page.

--- prog:lazarus:classes:tcontrols:tcontrols2 [13/08/2024 17:50]
thierry [Enfants du Control]
+++ prog:lazarus:classes:tcontrols:tcontrols2 [29/08/2024 19:07] (Version actuelle)
thierry [Savoir quelle partie (TRect) du Control est affiché]
@@ Ligne 1: / Ligne 1: @@
-====== TControl, TWinControl ======
-===== Dessin des Controls =====
+====== Dessin des Controls ======
-==== Bloquer l'affichage du control  lors d'un Update ====
+===== Méthode PAINT =====
+==== Quand est appelée PAINT ? ====
+La méthode ''Paint'' d'un ''TControl'' est appelée dans plusieurs circonstances liées à la nécessité de redessiner l'interface utilisateur. Voici les principaux moments où cette méthode est appelée :
+. **Lors de la création du contrôle :** Quand un contrôle est créé pour la première fois, la méthode `Paint` est appelée pour dessiner l'apparence initiale du contrôle.
+. **Lors d'un rafraîchissement ou d'une invalidation :** Si le contrôle est explicitement invalidé en appelant la méthode `Invalidate` ou `Repaint`, le système de rendu de Windows planifie un message de peinture, et la méthode `Paint` sera appelée pour redessiner le contrôle.
+. **Lorsqu'une partie du contrôle est recouverte puis découverte :** Par exemple, si une autre fenêtre recouvre partiellement le contrôle, puis est déplacée, la méthode `Paint` sera appelée pour redessiner la partie découverte.
+. **Lors de la redimensionnement du contrôle :** Si les dimensions du contrôle changent (par exemple, si l'utilisateur redimensionne la fenêtre contenant le contrôle), la méthode `Paint` est appelée pour ajuster et redessiner le contenu en fonction des nouvelles dimensions.
+. **Lors du défilement (scrolling) :** Si le contrôle est dans une zone défilable et que le contenu est déplacé par défilement, `Paint` peut être appelée pour dessiner les nouvelles parties du contrôle qui deviennent visibles.
+. **Lors du changement de style ou de propriétés visuelles :** Si certaines propriétés visuelles du contrôle changent (comme la couleur, le style de police, etc.), la méthode `Paint` est appelée pour redessiner le contrôle avec les nouvelles propriétés.
+La méthode `Paint` fait partie du cycle de peinture des contrôles dans l'API Windows. C'est une méthode clé pour assurer que les contrôles graphiques sont correctement affichés à l'écran, réagissant aux changements de l'état visuel ou de la disposition du formulaire.
+===== Bloquer l'affichage du control  lors d'un Update =====
 Il est possible que l'on ai besoin de "figer" le contrôle, lorsque l'on met a jour ses enfants par exemple, pour éviter le scintillement de celui-ci.
@@ Ligne 41: / Ligne 59: @@
   Canvas.Frame(vRect);
 </code>
+===== TControlBorderSpacing =====
+''TControlBorderSpacing'' est une classe utilisée pour gérer l'espacement autour d'un contrôle.\\
+Elle est particulièrement utile pour définir les marges (espace vide) entre un contrôle et les autres contrôles environnants, ou entre un contrôle et les bords de son conteneur parent.
-===== Position et dimensions des Controls =====
+=== Rôle de TControlBorderSpacing ===
-==== Constraints ====
+Le rôle principal de **TControlBorderSpacing** est de fournir une manière standard et flexible de gérer les marges d'un contrôle. Cela permet de s'assurer qu'un contrôle n'est pas collé directement à d'autres contrôles ou aux bords de son conteneur, améliorant ainsi l'apparence visuelle et l'organisation de l'interface utilisateur.
-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.
+=== Propriétés principales de TControlBorderSpacing ===
+Voici les propriétés les plus courantes de **TControlBorderSpacing** :
-<code delphi>
+  * **Around** : Définit l'espace autour du contrôle, c'est-à-dire une marge uniforme de tous les côtés (haut, bas, gauche, droite).
-published
+  * **Top** : Spécifie la marge au-dessus du contrôle.
-  property OnChange: TNotifyEvent;  // [rw] Event handler for a change in the constraints.
+  * **Bottom** : Spécifie la marge en dessous du contrôle.
-  property MaxHeight: TConstraintSize; // [rw] The maximum height.
+  * **Left** : Spécifie la marge à gauche du contrôle.
-  property MaxWidth: TConstraintSize; // [rw]  The maximum width.
+  * **Right** : Spécifie la marge à droite du contrôle.
-  property MinHeight: TConstraintSize; // [rw]  The minimum height.
+  * **InnerBorder** : Détermine l'espace intérieur autour du contrôle lui-même, souvent utilisé dans des conteneurs pour créer un padding (remplissage interne).
-  property MinWidth: TConstraintSize; // [rw] The minimum width.
+  * **OuterBorder** : Contrôle l'espace extérieur autour du contrôle.
-end;
+=== Exemple d'utilisation ===
+Supposons que vous ayez un **TButton** placé dans un **TPanel**, et que vous souhaitiez ajouter un espace de 10 pixels autour du bouton pour qu'il ne touche pas directement les bords du panneau. Vous pourriez configurer **TControlBorderSpacing** comme suit :
+<code pascal>
+Button1.BorderSpacing.Around := 10;
 </code>
-Un exemple d'utilisation est donné ci-dessous dans la section ''AdjustClientRect''
+Ou, pour spécifier des marges différentes pour chaque côté :
+<code pascal>
+Button1.BorderSpacing.Left := 5;
+Button1.BorderSpacing.Top := 10;
+Button1.BorderSpacing.Right := 5;
+Button1.BorderSpacing.Bottom := 10;
+</code>
+En utilisant ''TControlBorderSpacing'', vous pouvez contrôler précisément l'espacement des contrôles dans une interface utilisateur, ce qui est particulièrement utile lorsque vous travaillez avec des layouts dynamiques ou des interfaces utilisateur complexes.
-==== GetLogicalClientRect ====
+===== Savoir quelle partie (TRect) du Control est affiché =====
-Source : [[https://lazarus-ccr.sourceforge.io/docs/lcl/controls/tcontrol.getlogicalclientrect.html]]
+La fonction ''TMyControl.GetVisibleRect'' ci-dessous __calcule la partie visible d'un contrôle__ personnalisé sous forme d'un ''TRect'', en tenant compte des limites imposées par ses parents dans la hiérarchie visuelle.\\
+Elle traverse tous les parents du contrôle, réduisant progressivement le rectangle visible à l'intersection avec chaque parent. Le résultat est le rectangle visible final en coordonnées locales, retourné par la fonction.
+<code pascal>
+function TMyControl.GetVisibleRect: TRect;
+var
+  vParent: TWinControl;
+  vRect, vParentRect: TRect;
+  vP:      TPoint;
+begin
+  assert(assigned(Parent));
-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.
+  vRect := BoundsRect; // Le TControl en entier, pas juste ClientRect
+  if assigned(Parent) then
+  begin
+    vParent := Parent;
+    vP      := ControlOrigin;
+    vRect.Offset(vP);
-Rôle de GetLogicalClientRect :
+    { On scan tous les Parents }
-  * 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.
+    while assigned(vParent) and not (vRect.IsEmpty) do
-  * 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.
+    begin
-==== AdjustClientRect ====
+      vParentRect := vParent.ClientToScreen(vParent.ClientRect);
-Source : [[https://lazarus-ccr.sourceforge.io/docs/lcl/controls/twincontrol.adjustclientrect.html]]
+      vRect       := vRect.Intersect(vRect, vParentRect);
+      vParent     := vParent.Parent;
+    end;
-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 :
+    if not vRect.IsEmpty then vRect.Offset(-vP.X, -vP.y);
-  * 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
-<code delphi>
-type
-  TMyControl = class(TWinControl)
-  protected
-    procedure AdjustClientRect(var Rect: TRect); override; //surcharge de la méthode
   end;
-procedure TMyControl.AdjustClientRect(var ARect: TRect);
+  Result := vRect;
-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;
-</code>
-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.
-<code delphi \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;
 </code>
+** Utilité de la fonction TMyControl.GetVisibleRect **
-===== Accessibilité (pour utilisateur ayant un handicap) =====
+La fonction `TMyControl.GetVisibleRect` permet de déterminer quelle partie d'un contrôle est réellement visible à l'écran, en tenant compte des limitations imposées par ses parents dans la hiérarchie des contrôles.
-Chaque TControl a un membre de Type ''TLazAccessibleObject'' récupérable avec ''GetAccessibleObject''
-Plus d'infos ici :
-  * [[https://lazarus-ccr.sourceforge.io/docs/lcl/controls/tlazaccessibleobject.html]]
-  * [[https://wiki.lazarus.freepascal.org/LCL_Accessibility]]
+** Contexte d'utilisation **
+  * **Rendu graphique** : Identifie quelles portions du contrôle doivent être redessinées en fonction de leur visibilité.
+  * **Détection de clics** : Vérifie si une interaction utilisateur, comme un clic, se produit dans une zone visible du contrôle.
+  * **Optimisation** : Aide à concentrer les ressources sur la partie visible du contrôle pour améliorer les performances.
+** Autres applications **
+  * **Défilement automatique** : Lorsqu'un contrôle est contenu dans un `ScrollBox`, la fonction aide à gérer le défilement en ajustant dynamiquement la partie visible.
+  * **Animations ou effets visuels** : Pour des effets qui doivent se limiter aux zones visibles, cette fonction garantit que seules les parties pertinentes du contrôle sont affectées.
+  * **Validation et gestion des collisions** : Dans des applications comme les jeux ou les simulations, elle peut servir à déterminer les parties visibles d'un objet pour des vérifications ou interactions précises.