Blog de Gilles Vasseur - Pascal et compagnie

Après avoir appris à rendre plus plus vivantes vos interfaces grâce aux interpolations, avec la série de billets que je vous propose, vous doterez Lazarus de classes spécifiques aux fonctions d'easing. Votre EDI préféré saura alors imiter certaines animations présentes dans d'autres langages de programmation ou frameworks.

Les travaux réalisés dans les billets précédents vont fournir la matière à la hiérarchie de classes que nous allons mettre en place.
Nous allons tout d'abord définir une classe de base pour nos interpolations. Cette classe est essentielle : comme elle sera l'ancêtre de nos classes de travail, partout où cette classe de base sera attendue, nous pourrons lui substituer une classe enfant, d'où une grande souplesse.

Si vous avez besoin d'un rafraîchissement de mémoire à propos de la notion de polymorphisme, vous pouvez consulter le tutoriel se rapportant aux principes fondamentaux de la Programmation Orientée Objet.

De cette classe initiale, nous dériverons des classes de plus en plus spécialisées : une première classe introduira les fonctionnalités propres aux interpolations de type easing que deux autres classes filles (ou plutôt petites-filles) spécialiseront, l'une pour les nombres flottants, l’autre pour les entiers. Dans une prochaine série, une solution alternative à base de courbes de Bézier cubiques viendra compléter cette famille avec une classe dédiée.

Dans un souci de clarté, nous construirons deux unités :

• interpolationstypes pour regrouper les constantes, les types et les fonctions outils qui accompagneront les classes ;
• interpolations qui contiendra les classes proprement dites (déclarations et implémentations).

Seule la première sera décrite ici.

De manière classique, l'unité interpolationstypes définit le type essentiel utilisé pour nos interpolations et des outils gravitant autour. En particulier, nous souhaiterons peut-être transformer des chaînes de caractères en éléments de l'énumération TGVInterpolationType.

Voici le code source de cette unité :

Code delphi :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
 unit interpolationstypes;
 
{$mode objfpc}{$H+}
 
interface
 
uses
  Classes, SysUtils;
 
type
  TGVInterpolationType = (intLinear,
    intEaseInQuad, intEaseOutQuad, intEaseInOutQuad, intEaseOutInQuad,
    intEaseInCubic, intEaseOutCubic, intEaseInOutCubic, intEaseOutInCubic,
    intEaseInQuart, intEaseOutQuart, intEaseInOutQuart, intEaseOutInQuart,
    intEaseInQuint, intEaseOutQuint, intEaseInOutQuint, intEaseOutInQuint,
    intEaseInSine, intEaseOutSine, intEaseInOutSine, intEaseOutInSine,
    intEaseInExpo, intEaseOutExpo, intEaseInOutExpo, intEaseOutInExpo,
    intEaseInCirc, intEaseOutCirc, intEaseInOutCirc, intEaseOutInCirc,
    intEaseInElastic, intEaseOutElastic, intEaseInOutElastic, intEaseOutInElastic,
    intEaseInBack, intEaseOutBack, intEaseInOutBack, intEaseOutInBack,
    intEaseInBounce, intEaseOutBounce, intEaseInOutBounce, intEaseOutInBounce
    );
 
const
  C_InterpolationToStr: array[TGVInterpolationType] of string =
    ('Linear',
    'EaseInQuad', 'EaseOutQuad', 'EaseInOutQuad', 'EaseOutInQuad',
    'EaseInCubic', 'EaseOutCubic', 'EaseInOutCubic', 'EaseOutInCubic',
    'EaseInQuart', 'EaseOutQuart', 'EaseInOutQuart', 'EaseOutInQuart',
    'EaseInQuint', 'EaseOutQuint', 'EaseInOutQuint', 'EaseOutInQuint',
    'EaseInSine', 'EaseOutSine', 'EaseInOutSine', 'EaseOutInSine',
    'EaseInExpo', 'EaseOutExpo', 'EaseInOutExpo', 'EaseOutInExpo',
    'EaseInCirc', 'EaseOutCirc', 'EaseInOutCirc', 'EaseOutInCirc',
    'EaseInElastic', 'EaseOutElastic', 'EaseInOutElastic', 'EaseOutInElastic',
    'EaseInBack', 'EaseOutBack', 'EaseInOutBack', 'EaseOutInBack',
    'EaseInBounce', 'EaseOutBounce', 'EaseInOutBounce', 'EaseOutInBounce');
 
  C_DefaultDuration = 100;
  C_DefaultInterpolation = intLinear;
 
  // chaîne en interpolation
 function StrToInterpolation(St: string): TGVInterpolationType;
 
implementation
 
function StrToInterpolation(const St: string): TGVInterpolationType;
// *** chaîne en interpolation ***
var
  LInt: TGVInterpolationType;
begin
  Result := intLinear;
  for LInt := low(TGVInterpolationType) to high(TGVInterpolationType) do
    if CompareText(St, C_InterpolationToStr[LInt]) = 0 then
    begin
      Result := LInt;
      Exit;
    end;
end;
 
end.

À chaque élément de l'énumération correspond une chaîne du tableau de constantes chaînes C_InterpolationGVInterpolationStr.
La traduction d'une chaîne en élément de l'énumération est réalisée par la fonction StrToInterpolation qui parcourt la liste de cette énumération jusqu'à identifier l'élément visé. La fonction de comparaison est CompareText qui ne tient pas compte de la casse. Par défaut, l'interpolation retournée par la fonction est intLinear, ce qui correspond au déroulement habituel d'une animation linéaire.

Cette unité sera à compléter avec la définition de nouvelles classes lorsque nous aborderons les courbes de Bézier cubiques.

Rendez-vous d'ici peu pour la classe de base...