sous vista et XP cela fonctionne, par contre, sous Seven ou les versions serveur, je ne sais pas trop.

il faudrait que je regarde si il y a des changements sur cette DLL selon les versions de Windows.

parce que le code est copié de TCustomForm ... d'ou le dynamic restant.

pour les conventions, on respecte celle de Borland ... sinon tout le monde fait n'importe quoi et personne ne comprend plus rien.

"f" pour les variables privées
"p" pour les pointeurs
"set" et "get" pour les fonctions de propriétés

"_" et "__" s'utilise plutot pour les déclarations d'implémentation privée (variables, constantes et objets globaux).

voilou ...

bon code.

ouch un peu sur les conventions de code :




type
  TFrame = class(Forms.TFrame)
  private
    fOnShow  : TNotifyEvent;
    fOnHide  : TNotifyEvent;
    procedure CMShowingChanged(var M: TMessage); message CM_SHOWINGCHANGED;
  protected
    procedure DoHide; dynamic;
    procedure DoShow; dynamic;
  published
    property OnShow : TNotifyEvent read fOnShow write fOnShow;
    property OnHide : TNotifyEvent read fOnHide write fOnHide;
  end;

{ TFrame }

procedure TFrame.CMShowingChanged(var M: TMessage);
begin
  if Showing then
    DoShow
  else
    DoHide;
end;

procedure TFrame.DoHide;
begin
  if Assigned(fOnHide) then
    fOnHide(Self);
end;

procedure TFrame.DoShow;
begin
  if Assigned(fOnShow) then
    fOnShow(Self);
end;

comme ça quoi :


function affichageTemps(temps : LongWord):string;
var Z, S, M, H : LongWord;
begin
  Z := Temps mod 1000;
  S := (Temps div 1000) mod 60;
  M := (Temps div 60000) mod 60;
  H := (Temps div 3600000);
  result := format('%.d:%.2d:%.2d.%.3d',[H,M,S,Z]);
end;

conclusions :

au final, dans la méthode Paint, seul reste, à part la convertion du temps en degré que l'on aurait également pus mettre en cache aussi (puisque ce sont des valeurs connues d'avance dans un interval connus lui aussi), les positions sont reduite à de simple additions!
au final on à supprimer de nombreux appels a Sinus et Cosinus et de nombreuses multiplications qui ralentissent les boucles et les méthodes.

tout a fait, un exemple :


unit UDrawTime;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, ExtCtrls;

type
  TForm31 = class(TForm)
    Timer1: TTimer;
    PaintBox1: TPaintBox;
    procedure Timer1Timer(Sender: TObject);
    procedure PaintBox1Paint(Sender: TObject);
    procedure FormCreate(Sender: TObject);
  private
    { Déclarations privées }
  public
    { Déclarations publiques }
  end;

var
  Form31: TForm31;

implementation

{$R *.dfm}

const
  DTR = PI/180; // Degre to radian
  iSin = 0; // sin index
  iCos = 1; // cos index

var
  // Sin cos cache ( 2 880 octets)
  SinCos        : array[iSin..iCos, 0..359] of single;

  // Positions cache (4 * 2 880 octets (11 520 octets))
  PointsOfRayBig,                                 // Aiguille secondes
  PointsOfRayBigIv,                               // Aiguille secondes (arrière)
  PointsOfRayMedium,                              // Aiguille minutes
  PointsOfRaySmall   : array[0..359] of TPoint;   // Aiguille heures

  // les caches prennent un peu de mémoire, cela est necessaire pour gagner les
  // cycles dans l'animation. au total 14.4Ko seront necessaire (ridicule) pour
  // un gains de performance non négligeable.

// pré-calculs
procedure Precalculus;
var A : integer;
begin
  // les Sinus et cosinus, on pourrait aussi utiliser la fonction
  // Math.SinCos qui est un chouille plus rapide, mais comme il s'agit
  // ici de pré-calculs éfféctués au démarrage de l'application,
  // le gains des quelques cycles n'est pas trés important.
  for A := 0 to 359 do
  begin
    SinCos[iSin, A] := Sin(DTR * (A-90)); // A-90 pour corriger l'angle de
    SinCos[iCos, A] := Cos(DTR * (A-90)); // départ des aiguilles.
  end;

  // Les points, on calcul les positions avec nos rayons
  // prédéfinit. Dans un objet, on mettrait à jours ces
  // calculs uniquement quand l'utilisateur/développeur
  // modifierai un des rayons, bien entendus, il faudrait
  // 3 méthode (PCBig, PCMedium, PCSmall) en changeant
  // réspectivement les rayons Heure, Minute, Seconde,
  // et également la taille (Resize) du composant.
  // ici les rayons pourrait être un % de la taille :
  // round(Width * 0.48 * SinCos[...]) = rayon de 48% de
  // la taille du composant.
  for A := 0 to 359 do
  begin
    PointsOfRayBig[A].X    := round(80 * SinCos[iCos, A]);
    PointsOfRayBig[A].Y    := round(80 * SinCos[iSin, A]);

    // -180° = position inverse, mod 360 pour ne pas dépasser l'interval
    // 0..359.
    PointsOfRayBigIv[(A - 180) mod 360].X := round(10 * SinCos[iCos, A]);
    PointsOfRayBigIv[(A - 180) mod 360].Y := round(10 * SinCos[iSin, A]);

    PointsOfRayMedium[A].X := round(60 * SinCos[iCos, A]);
    PointsOfRayMedium[A].Y := round(60 * SinCos[iSin, A]);

    PointsOfRaySmall[A].X  := round(40 * SinCos[iCos, A]);
    PointsOfRaySmall[A].Y  := round(40 * SinCos[iSin, A]);

  end;
end;


{ Procedure de dessin de l'horloge

  parametres :
    Canvas  : le canvas de destination pour le dessin de l'horloge
    H, M, S : heure (0..11 ou 0..23), minute et seconde (0..59) de l'heure à afficher.
    CX, CY  : position centrale X et Y de l'horloge sur le canvas
}
procedure DrawTime(Canvas: TCanvas; const H, M, S: byte; const CX, CY: integer);
var
  vH, vM, vS : integer;
  vBuffer : TBitmap;
begin
  // on transforme le Temps en Degrés! BWAHAHAHA!
  vH := trunc(360 * (((H mod 12)*60+M)/720)); // on transforme les heures en minutes
  vM := trunc(360 * (M/60));
  vS := trunc(360 * (S/60));

  // back buffer ...
  // what that bidule ?
  // le back buffer permet de dessiner "hors affichage", ce qui est plus performant
  // avec la GDI. on transmet le back buffer uniquement à la fin, on parlera ici de
  // rendu software, ce que la carte graphique fait en hardware de façon naturelle.
  // mais la GDI n'etant pas supportée en hardware, appliquer ce principe en mode
  // software permet de grapiller encore de la fluidité.
  vBuffer := TBitmap.Create;
  try
    vBuffer.Width := 160;
    vBuffer.Height:= 160;
    vBuffer.PixelFormat := pf32bit;

    vBuffer.Canvas.Brush.Color := clBtnFace;
    vBuffer.Canvas.FillRect(vBuffer.Canvas.ClipRect);

    // le cadre
    vBuffer.Canvas.Pen.Color := clBlack;
    vBuffer.Canvas.Ellipse(0, 0, 159, 159);

    // les minutes
    vBuffer.Canvas.Pen.Width := 3;
    vBuffer.Canvas.MoveTo(80, 80);
    vBuffer.Canvas.LineTo(80+PointsOfRayMedium[vM].X, 80+PointsOfRayMedium[vM].Y);

    // les heures
    vBuffer.Canvas.Pen.Width := 2;
    vBuffer.Canvas.MoveTo(80, 80);
    vBuffer.Canvas.LineTo(80+PointsOfRaySmall[vH].X, 80+PointsOfRaySmall[vH].Y);

    // les secondes
    vBuffer.Canvas.Pen.Width := 1;
    vBuffer.Canvas.Pen.Color := clRed;
    vBuffer.Canvas.MoveTo(80, 80);
    vBuffer.Canvas.LineTo(80+PointsOfRayBig[vS].X, 80+PointsOfRayBig[vS].Y);
    vBuffer.Canvas.MoveTo(80, 80);
    vBuffer.Canvas.LineTo(80+PointsOfRayBigIv[vS].X, 80+PointsOfRayBigIv[vS].Y);

    // dessin sur le canvas transmit
    Canvas.Draw(CX-80, CY-80, vBuffer);
  finally
    vBuffer.Free;
  end;
end;


procedure TForm31.FormCreate(Sender: TObject);
begin
  // 250ms, largement suffisant ici
  Timer1.Interval := 250;
end;

procedure TForm31.PaintBox1Paint(Sender: TObject);
var H, M, S, Z: word;
begin
  // on decode l'heure courrante
  DecodeTime(Now, H, M, S, Z);
  // on appel la methode de dessin
  DrawTime(PaintBox1.Canvas, H, M, S, PaintBox1.Width div 2, PaintBox1.Height div 2);
end;

procedure TForm31.Timer1Timer(Sender: TObject);
begin
  // timer 1 sert uniquement à rafraichir le dessin
  PaintBox1.Invalidate;
end;


// éxécuté au l'initialisation de l'unité
initialization
  // les précalculs.
  Precalculus;

end.

pas mal, on vas pouvoir passer à l'optimisation :

précalcul et Sin et Cos en cache, amélioration des conventions de code, et d'autres trucs par ci par la.

voila, mise a jours effectuée.

oublis du dfm ... lol ...

je corrige ça et intégre une dcv pour les D < 2009.

La demo est éfféctivement pour D2009, il faudra placer les methodes dans un objet pour en tirer partis.

au niveau mémoire, en D2009 cela prend un chouilla de place avec la liste des fonctions chargée, rien de bien méchant si on à pas un wrapper conséquent (pas comme l'api windows complète par exemple), mais pratique pour un wrapper d'une centaines de fonctions.

au niveau charge, il est certains que les calls en plus pour appeler GetProcAddress et les vérification d'erreur ralentissent un peu le tout, mais la encore, rien de bien méchant.