HotLog.pas (v1.2) gère entièrement un fichier de log. THotLog est "multi-threadé" et le fichier de log est accédé via un tampon mémoire afin d'assurer une écriture correcte des données sur le disque, quoiqu'il arrive à votre application.

HotLog.pas et THotLog : Fonctionnalités.

» THotLog est "multi-threadé", orienté objet, et "buffered safe". Le fichier de log sera correctement écrit
sur le disque, même si votre application se termine sur une erreur. Le travail de "parsing" / mise en
forme de chaîne de caractères / écriture du fichier, et de retour visuel (optionnel, dans un TMemo) ne
consomme presque rien dans votre thread principal. Vous pouvez utiliser autant d'instances de l'objet
THotLog que vous le souhaitez.

» Gestion du fichier de log :
   o Chemin, nom, extention (y compris (éventuellement) les noms à base de generations
      (".001", ".002" etc.)),
   o Accès au fichier (ouverture, ecriture, fermeture ; historisation des versions précédentes
      si un système de générations est utlisé)
   o Toutes les valeurs et comportements par défaut peuvent évidement être modifiés..
   o Depuis la version 2.0, capacité à surveiller la taille du fichier de log, et à le fermer pour en ouvrir un
      nouveau quand une certaine limite est atteinte

» Entièrement automatisé : L'instance de l'objet assurant le processus de logging est crée
automatiquement au démarrage de votre application, et vous pouvez l'utiliser directement si vous
choisissez de ne changer aucune de ses valeurs par défaut. De même, il sera libéré en fin de traitement.

» Procure des moyens de récupérer aisément des informations diverses à propos de l'environnement
dans lequel votre programme est
en train de s'éxécuter, afin de faciliter un éventuel debogage en cas de besoin. Ces informations
comprennent des faits et chiffres
à propos du système d'exploitation, de la mémoire, des capacity de "timing" du PC, et bien d'autres ;

» Dispose de capacités de formattage de chaînes de caractères étendues et faciles à utiliser,
permettant de présenter un log clairement ;

» Est capable de sortir des informations détaillées en cas d'exception/erreurs. Etant en mesure
de gérer les  "variant open array parameter" (grâce aux explications de Rudy V.), il peut prendre en
compte n'importe quel type de données, sans que vous ayez à vous préocuper de quoi que ce soit :
Passez lui simplement des variables telles qu'elles sont, (comme par exemple la liste des paramètres
reçus par une fonction, et/ou les variables en cours de manipulation) sans chercher à les transtyper, ou
à savoir si un pointeur est valide ou non, etc. : THotLog s'en charge.

» Peut aussi afficher les lignes du log dans un TMemo (dont vous lui aurez simplement passé le handle),
si vous vous souhaitez que votre utilisateur dispose d'un feedback visuel.

» Dispose d'une capacité puissante de mesure de temps de calcul, permettant de chronometrer des
portions de code. Selon l'environnement dans lequel votre programme s'éxécute (système et matériel),
la meilleur résolution peut descendre jusqu'à quelques dixièmes de nanosecondes (milliardièmes de
secondes), et les mesure peuvent être effectuées dans l'unité (native ou temporelle) de votre choix
(depuis les heures jusqu'aux nanosecondes pour les unités de temps, et depuis les "ticks" jusqu'aux
cycles CPU pour les unités natives.

» Un grand nombre de paramètres optionnels permet de changer le comportement par défaut de
THotLog ;

» Etc., etc.

QTimers.pas / TQTimer : Fonctionnalités .

................................................

(MailTo:Qnno_AT_Noos.fr)

.........................

Tous les fichiers sur cette page sont gratuits, quel que soit leur emploi. Cependant, ils restent ma propriété intelectuelle pour mes parties du code, et celle de leurs auteurs originaux pour leurs parties du code.

Ces unités peuvent être utilisées librement dans n'importe quel type d'application (Freeware, shareware ou programme commercial). Toutefois, j'apprecierai que vous m'envoyiez un mail, si vous décidez de les utiliser.

Bien sûr, vous les utiliserez sous votre propre responsabilité. Ni moi, ni aucun des contributeur ne saurions être tenus pour responsable de quelque problème qui pourrait résulter de leur utilisation. ;-)

QTimer.pas contient TQTimer, un outil de chronométrage du code, qui a la faculté de convertir des mesures dans l'unité de temps de votre choix (y compris dans la "plus lisible possible", si demandé).

» TQTimer est un outils de mesure de la vitesse de portions de code. Il propose quatre
compteurs différents, et dispose d'une précision pouvant aller (en fonction du système sur
lequel il est éxécuté) jusqu'à quelques dixièmes de nanosecondes.
Il peut retourner les mesures effectuées dans l'unité de votre choix, (unité native du compteur,
ou unité de temps)

» TQTimer étant la definition d'un objet, vous pouvez en utiliser autant d'instances que vous le
souhaitez, ce qui peut être utile pour, par éxemple, avoir une instance de timer par portion de
code à chronometrer, ou encore, une instance par timer utilisé (GetTickCount, RDTSC, etc.)

» TQTimer dispose en plus de la capacité de déterminer de lui-même quelle est l'unité de temps
à utiliser pour restituer un écart entre deux mesures, de telle sorte que le résultat soit le plus
"lisible" possible.

Note : HotLog.pas contient déjà la définition de TQTimer (pour que tout soit dans une seule unité).
En conséquence, si votre projet utilise déjà l'unité HotLog.pas, vous n'avez pas besoin de l'unité Qtimer.pas.

Remarque à destination des utilisateurs francophones : Les commentaires et les fichiers d'aides des unités ci-dessous sont exclusivement rédigés en anglais. Je n'ai pas eu pour le moment le temps d'en faire plusieurs versions, et l'anglais est devenu l'"esperanto" du web.

» TQProgressBar  est un composant visuel capable d'apporter un look 'Xp' à vos
application, même en dehors de Xp. Chaque barre peut :

  . Etre plate ou en forme de cylindre ;

  . Etre verticale ou horizontale ;

  . Afficher ou non les positions "inactives" (les positions non envore atteintes ;

  . Avoir un cadre, un arrière-plan, ou aucuns ;

  . Etre monocolore, ou afficher un gradient ;

  . Chaque couleur peut être changée (cadre, fond, la barre elle-même, positions
    inactives) ;

  . Apparaître sous la forme d'une barre continue, ou sous la forme de blocs
    consécutifs. Dans ce cas, les blocs peuvent être dessinés peu à peu, ou bloc par
    bloc.

Ce composant est gratuit, et fourni avec son source complet.
Il a été développé sous D6PE, peut être installé sur l'une des palettes de l'IDE, et être
utilisé comme n'importe quel autre composant visuel.
Le fichier zip contient une liste des propriéts disponibles, ainsi qu'une demo et son
source.

................................................

TQProgressBar (v1.1) est un composant qui permet - entre autres - d'utiliser une progressBar au look 'Xp', même en dehors de XP...

................................................

TQSpiderGraph, un composant graphique de type "radar" ou "toile d'araignée".

................................................

» TQSpiderGraph est un composant graphique.

Il affiche des graphs de type "radar", avec un nombre d'axes et de lignes limité uniquement
par la lisibilité...

Il dispose de nombreuses fonctionnalités s'appliquant notament :

  . aux axes (nombre, couleurs, max et min individuels)
  . son arrière plan (transparent, mono-color, ou avec gradient)
  . le nombre des lignes, leurs couleurs, l'affichage de leur nom, leur épaisseur, etc.
  . Il traque les mouvements de la souris, peut afficher les valeurs d'une ligne dans une boite
    à coté du pointeur, et / ou signaler à votre programme l'entrée et la sortie de la souris sur
    une ligne
  . Il peut copier son image dans un TBitmap, ou l'enregistrer dans un fichier, au format .bmp
    (32bits) ou .jpg.

Les "radar graphs" sont particulièrement utiles pour permettre à votre utilisateur de comparer
visuellement les valeurs de différents ensembles de données. TQSpiderGraph dispose de
moyen facilitant encore cette comparaison visuelle :

   Ses fonction de "mise en avant" de lignes permettent de mettre en évidence :
   -> la(les) ligne(s) dont l'aire est la plus importante ou la moins importante ;
   -> Celle(s) ayant la valeur la plus élevée (ou la moins élevée) pour tel ou tel axe ;
   -> ou tout simplement celle(s) de votre choix, en utilisant son(leur) index.

   La "mise en évidence" se fait en utilisant l'un des (ou une combinaison de) modes suivants :
   -> Changer la couleur de la(des) ligne(s) concernée(s) ;
   -> Changer son(leur) épaisseur ;
   -> Afficher les points de cette(s) ligne(s) uniquement ;
   -> Et pourquoi pas, faire clignoter temporairement cette(ces) ligne(s).

TQSpiderGraph a de nombreuses autre fonctionalités. Sa capacité (optionelle) à dimensioner
de lui même ses axes pour les adapter aux valeurs que vous envoyez en est un exemple.

Il a été développé et testé sous D6PE, est gratuit, et fourni avec son source.

Le fichier zip contient le code source du composant, une démo compilée (et son source), ainsi
qu'un fichier d'aide (sommaire, et en anglais...) au format html.

La dernière version est la 2.2

(Depuis la version 2.0, THotLog peut fermer le fichier de log une fois qu'il atteint une certaine limite, puis d'en ouvrir un nouveau).

(La version 2.1 ajoute à la 2.0 le support de D5)

(La versioàn 2.2 améliore la gestion du retour visuel (memo), et corrige une AV potentielle à la création du fichier)

Composants avec source :

Using MethodAddress(); to access a published method of a class by its name used as string.

Cet article (en anglais) montre :
- Comment accéder à une "method" (procedure ou fonction) dans un programme, en utilisant son nom (comme "String"), et comment lire ce qu'elle renvoie (dans le cas des fonctions) ;
- Accessoirement : Quelques usages possibles des Variants, y compris comment stocker un pointeur dans un varaint, (et le manipuler ensuite).