Elian Lacroix

Positionner le Débogueur sur le poste de développement à partir de conditions de production.

2010-09-14T16:05:00.001+02:00

Lorsque le mécanisme de sécurité Wlangage est déclenché en production, il n'est pas toujours évident de parvenir à reproduire le même cas sur le poste de développement afin d'apporter les corrections nécessaires. Avant d'entreprendre un débogage à distance nécessitant une connexion au poste de l'utilisateur final, et d'être disponible au moment où l'erreur survient, il est possible d'utiliser un "Dump de débogage".

Rien de plus simple, grâce au lien "Enregistrer les informations pour le fournisseur de l'application (dump de débogage)" :

En effet, le lien permet d'obtenir un fichier d'extension wdump, qu'il suffit de récupérer sur le poste de développement. Une fois le fichier récupéré, un simple drag & drop au dessus du projet concerné permet de se retrouver dans le débogueur, au moment ou le mécanisme de sécurité a été déclenché, afin de mieux cerner le cas en consultant les variables, paramètres...

Il est également possible d'obtenir un dump par programmation, par exemple dans le cas où les déclenchements du mécanisme de sécurité sont traités par l'application :
http://doc.pcsoft.fr/fr-FR/?1000018834

Je profite de ce billet pour m'excuser auprès de ceux qui m'écrivent "ce blog est-il mort ?" ! Rassurez-vous il n'est pas mort. Mais comme tout le monde les "temps modernes" ne me laissent que très peu de temps pour partager, et prendre le temps pour des activités qui sortent d'un contexte purement professionnel.

Obtenir la liste de toutes les DLL utilisées par une application

2010-05-12T10:57:00.001+02:00

Le code suivant peut être utile pour localiser toutes les DLL utilisés par une application, durant son exécution. Affichée à partir d'une fenêtre "à propos" ou de configuration avancée, cette liste peut permettre :
- de vérifier l'emplacement des modules réellement chargés,
- de vérifier les versions,
- de connaître les dépendances nécessaires.

sListeDLL est une chaîne
POUR TOUTE CHAINE sUneAppli DE ExeListeProcessus(exePID, exeNomCourt) SEPAREE PAR RC

SI ExtraitChaîne(sUneAppli, 2, TAB) ~= fExtraitChemin(ExeInfo(exeNom), fFichier+fExtension) ALORS
sListeDLL = ExeListeDLL(ExtraitChaîne(sUneAppli, 1, TAB))
FIN

FIN
Saisie1 = sListeDLL

Supprimer les signes cabalistiques dans le sujet des emails envoyés avec WINDEV.

2010-04-30T15:55:00.000+02:00

Suivant la messagerie utilisée pour la lecture d'un email envoyé avec WINDEV, Outlook notamment, le sujet des emails peut ne pas avoir les bons caractères (accents remplacés...).

C'est le cas lorsque le message est envoyé avec l'appel suivant :

EmailEnvoieMessage("SessionSMTP")

Pour que le mail envoyé soit correctement lu dans ce cas, il faut modifier le code d'envoi, en donnant l'option EmailOptionEncodeEntête :

EmailEnvoieMessage("SessionSMTP", EmailOptionEncodeEntête)

Sans cette option, si le sujet du message est "c'est l'été", le message envoyé contient :

From:...
Subject: c'est l'été
To:...

Alors qu'avec l'option, il est codé différemment, et est mieux interprété par certaines messageries :

From:...
Subject: =?ISO-8859-1?Q?c'est_l'=E9t=E9=00?=
To:...

Déploiement en réseau des applications, comment modifier le lien entre chaque poste utilisateur et le serveur ?

2010-03-17T14:24:00.001+01:00

Le déploiement avec mise à jour en réseau est extrêmement pratique, puisqu'il permet :
- d'avoir l'application en local sur chaque poste pour de meilleures performances,
- de ne mettre à jour que le serveur lors des modifications de l'application, afin qu'elle se propage automatiquement sur tous les postes.
Cette solution offre donc les avantages, sans les inconvénients d'autres possibilités de déploiement.

Le seul point délicat de cette solution, concerne le changement de serveur. En effet toutes les installations locales de l'application "pointent" vers le serveur en ayant son nom stocké dans un fichier de paramètres. De ce fait, si le serveur doit changer de nom, ou de ressource partagée, il est nécessaire d'intervenir sur le paramétrage de chaque poste afin de rétablir la possibilité de mise à jour automatique.

Voici les solutions possibles, de la plus avantageuse à la plus contraignante :

- réinstallation complète de l'application en "push"
Sur le serveur le programme WDADMINEXE.EXE permet de déployer l'application sur les postes utilisateurs. Donc si le réseau le permet, une première possibilité consiste à déployer à nouveau l'application sur tous les postes. De cette manière sur chaque poste le lien vers le nouveau serveur sera mis à jour.

- réinstallation complète de l'application sur chaque poste :
Cette seconde solution vise à obtenir le même résultat que précédemment, en installant à nouveau l'application sur chaque poste. Le fichier de paramètre est ainsi remis à jour, par contre cette solution impose de repasser sur tous les postes pour relancer l'installation du serveur.

- modification du fichier de paramètre de chaque poste :
Le fichier de paramètre utilisé par se mécanisme ne nomme WDUPDATE.NET, il est placé dans le répertoire de l'exécutable sur chaque poste. C'est un fichier de type ".INI", il est donc possible de le modifier depuis l'application elle-même à l'aide de la fonction "AppliChangeParamètre" (ou "INIEcrit"). Il est donc envisageable avant le changement de serveur de faire une dernière mise à jour de l'application, qui sera capable via le code du projet de corriger le WDUPDATE.NET. Une fois la mise à jour prise par chaque poste, il sera possible de changer le serveur, puisque la version locale de l'application aura maintenant l'emplacement du nouveau serveur.

Applet Java et exécutable Win32 générés depuis un même projet, comment supprimer les erreurs de compilation "La fonction n'a pas d'équivalent dans le framework WL/Java" ?

2010-03-10T13:00:00.010+01:00

Lorsqu'un projet contient deux configurations, l'une permettant de créer un exécutable Windows, l'autre permettant de créer une applet Java, tous les codes sont compilés en permanence, quelque soit la configuration en cours. Ainsi même si la configuration de projet chargée et celle de l'exécutable Windows, les erreurs de compilation de la forme suivante peuvent remonter :

La fonction n'a pas d'équivalent dans le framework WL/Java

L'utilisation de la fonction "EnModeTest" ne permet pas d'éviter la compilation. La solution pour éviter cette compilation systématique : le "code-cible conditionnel". Il suffit dans le code utilisant une fonction non disponible en Java, de dérouler le menu "Code / code-cible conditionnel". L'interface propose alors de sélectionner les codes à ajouter, et divise le code en sections. Il est ainsi possible d'avoir un code compilé dépendant de chaque plateforme cible. Illustration avec un bouton faisant appel à un état :

Où paramétrer l'utilisation d'un serveur proxy pour utiliser les fonctions FTPEnvoie, FTPRécupère ?

2010-03-09T13:00:00.001+01:00

Les fonctions FTP* du WLangage reposent directement sur le API FTP de Internet Explorer. Si un proxy doit être utilisé, il faut donc le configurer directement dans les options de Internet Explorer, et non pas avec la fonction Proxy du WLangage.

Voici en image l'emplacement du réglage dans Internet Explorer :

Exception pour confirmer la règle, il y en a toujours une, la fonction "FTPCommande", contrairement à "FTPRécupère" ou "FTPEnvoie", permet d'adresser directement le serveur FTP, sans passer par les API de Interner Explorer. Elle est obligatoire si le serveur FTP n'est pas accessible au travers de Internet Explorer.

Exporter les données d'un champ table vers Excel sans limitation sur le nombre de lignes.

2010-03-08T13:50:00.000+01:00

Lors de l'utilisation de l'option automatique "Exporter vers Excel" d'un champ table, ou de la fonction "TableVersExcel", l'extension "XLS" est proposée par défaut. Le fichier Excel créé a donc le format des versions de Excel antérieures à la version 2007. Ces versions sont limitées à 65 536 lignes dans une feuille.

Pour exporter les données sans aucune limitation, il faut que format du fichier Excel créé soit en version 2007. Il faut pour cela préciser lors de l'exportation une extension "XLSX", au lieu de "XLS".

Précision dans les champs de saisie des IHM

2009-05-12T09:49:00.003+02:00

Ce billet complète le précédent concernant la précision des calculs faits par programmation. En effet, tout comme l'utilisation de "0n" pour l'affectation d'un numérique, l'option "Numérique haute précision" des champs permet d'obtenir une précision maximale pour les valeurs saisies :

La coche n'est pas active par défaut, il faut donc bien penser à l'activer à partir du moment ou le domaine de l'application nécessite une précision importante.

Résultat erroné dans un calcul sur des numériques

2009-05-12T09:32:00.003+02:00

L'expression courante "on en apprend tous les jours" est sans doute la plus vraie qui soit !

Hier encore je pensais que le type "numérique" était juste comme le type "monétaire". Ce n'est pas tout à fait exact, son affectation directe se faisant via un réel, on peut avoir des valeurs ou arrondis inattendus inhérents au codage des réels de Windows (IEEE).

Mais aujourd'hui après une consultation de l'aide sur le type numérique, j'ai appris une syntaxe permettant de forcer une affectation pour qu'elle soit juste. Je pense qu'il est bon de garder cette information à l'esprit dès lors qu'un traitement nécessite une importante précision de calcul.

Ainsi l'écriture traditionnelle :

nValeur est un numérique
nValeur = 1234567890123456789.01
Trace(nValeur)

Sera avantageusement remplacée par :

nValeur est un numérique
nValeur = 0n1234567890123456789.01
Trace(nValeur)

Attention le "0n" qui précède la valeur est un "zéro" combiné avec la lettre "n". Il ne s'agit pas des lettres "o" et "n".

Ignorer un paramètre sur index full-text dans une requête

2009-01-15T17:34:00.006+01:00

Lorsqu'une requête contient un paramètre portant sur un index full-text, par défaut la pertinence relative à l'index full-text fait partie du résultat. La requête est donc de la forme suivante :

SELECT
MATCH(XX, YY, ZZ) AGAINST({ParamFullText}) AS PertinenceFullText
FROM
TABLE
WHERE

AND PertinenceFullText > 0
ORDER BY
PertinenceFullText DESC

Tant que cette pertinence figure dans le résultat, le paramètre de la requête s'y rapportant est obligatoire. La syntaxe suivante :

Requête.ParamFullText = Null
HExécuteRequête(Requête)

conduira à l'erreur :

Erreur dans le code SQL de la requête . Initialisation de la requête impossible. Le paramètre doit être renseigné.

Pour pouvoir rendre le paramètre optionnel, il suffit de ne pas le faire figurer dans le résultat de la requête. Dans l'éditeur de requêtes il faut pour cela sélectionner "ne pas afficher" en cliquant sur l'oeil correspondant à la condition sur l'index full-text. La requête obtenue sera de la forme suivante :

SELECT
*
FROM
TABLE
WHERE

AND MATCH(XXX, YYY, ZZZ) AGAINST({ParamFullText}) > 0

Comme toujours, c'est très simple ... une fois que l'on sait.

Pallier au message "L'état ?? est déjà en cours d'impression"

2008-11-18T18:04:00.004+01:00

J'ai constaté avec surprise, suite aux plaintes d'utilisateurs, que le double-clic sur un bouton lançant un état provoquait une erreur de l'application :

L'état ?? est déjà en cours d'impression
Dump de l'erreur du module <12.00Bw>.
- Niveau : erreur fatale (EL_FATAL)
- Code erreur : 210055
- Infos de debug : Fonction (21,0)

Le défaut m'a été confirmé par le support. En palliatif immédiat, puriste s'abstenir, j'ai utilisé le code suivant qui évite de relancer l'état en cas de double clic.

// Code de clic sur le bouton d'impression
SI ChaîneOccurrence(dbgInfo(dbgPile), "Clic sur "+MoiMême..Nom) > 1 ALORS RETOUR

iAperçu(i100)
iImprimeEtat(Etat1)

J'espère que cette astuce pourra resservir, même s'appuyer sur la pile n'est pas de plus "propre", cela permet de facilement régler le problème.

Wlangage dans les requêtes SQL : "Vous n'êtes pas autorisé à exécuter la fonction WLangage XX dans une requête"

2008-09-25T15:13:00.002+02:00

Les requêtes sur une base Hyper File peuvent inclure des instructions WLangage (cf billet fonction du WLangage dans une requête SQL). Par contre une erreur peut se produire lors de l'exécution, mentionnant le nom de la fonction WLangage appelée dans le code SQL :

Vous n'êtes pas autorisé à exécuter la fonction WLangage XX dans une requête

Où est le piège ... dans les droits définis sur le serveur !

Il faut donner le droit "Droit d'exécuter des procédures stockées" à l'utilisateur connecté. Sans ce droit spécifique, l'exécution d'une requête se solde par ce retour.

Requête DECODE pour moins de code...

2008-09-17T18:33:00.001+02:00

Je ne découvre seulement qu'aujourd'hui l'instruction SQL DECODE. C'est un intérêt du développement on en apprend tous les jours !

L'instruction SQL DECODE est très pratique, elle permet de formater une information directement dans le résultat d'une requête SQL, afin d'éviter de la programmation lors de la lecture de la requête pour présenter les données. Exemple typique d'une civilité stockée avec 1, 2 ou 3 dans une base de données, on pourra grâce à DECODE obtenir directement dans le résultat de la requête "M.", "Mme" ou "Mlle". Exemple :

SELECT
DECODE(CLIENT.Civilité ,1,'M. ',2,'Mme. ',3,'Melle ','') +' '+
CLIENT.NomClient +' '+CLIENT.PrénomClient AS NomComplet
FROM
CLIENT

Système 32 ou 64 bits pour héberger un moteur Hyper File Client/Serveur (ou exécuter les applications) ?

2008-09-16T15:07:00.005+02:00

"Qui peut le plus peut le moins" on peut donc être tenté de systématiquement partir sur du 64 bits ! Il n'y a cependant aucune obligation. La seule restriction incontournable d'un système 32 bits et de ne pas permettre à un processus d'allouer plus de 2 Go de RAM (indépendamment de la RAM totale). Donc ... système 64 bits obligatoire si le moteur Hyper File Client/serveur a besoin à un moment donné de plus de 2 Go de RAM pour répondre aux applications clientes qui le sollicitent. Dans tout autre cas un système 32 bits est suffisant.

Par contre attention de ne pas sous évaluer les besoins, car d'après mes constations lorsque les 2 Go disponibles en 32 bits sont alloués, il n'est pas rare que les postes clients ne reçoivent plus de réponse (ou seulement après une attente trop importante).

Ajuster l'espace alloué pour le cache du moteur Hyper File Client/Serveur

2008-09-12T11:12:00.012+02:00

Le centre de contrôle Hyper File permet d'indiquer la taille mémoire maximale à utiliser pour les caches.

Afin d'accélérer les accès pour de meilleures performances, on peut être tenté d'augmenter à outrance cet espace, . Mais il faut bien garder à l'esprit que l'espace donné pour le cache, limite d'autant l'espace disponible pour les autres besoins du serveur (requêtes, traitements...).

Il est donc nécessaire d'étudier en production ce qu'il se passe sur le serveur, en fonction des actions faites par les applications. En effet, en fonction des accès effectués par les applications, les caches devront être privilégiés, ou au contraire, il faudra un maximum d'espace mémoire libre pour satisfaire au plus vite les applications.

Pour cela il faut activer dans la configuration du serveur les statistiques d'activités, puis les consulter sur une période de mise en production la plus représentative possible de l'utilisation courante.

Leur visualisation sous forme de graphe permet de voir les accès (en nombre ou en octets) fait en directs sur le disque, ou dans les caches. L'opération doit être renouvelée à plusieurs reprises, en augmentant à chaque fois sensiblement l'espace des caches. Dès que l'augmentation du cache alloué ne permet plus de faire évoluer le nombre d'accès en cache de façon significative, il ne faut plus augmenter l'espace alloué au cache sous peine de limiter l'espace mémoire inutilement.

Pour une mesure précise, il faut à chaque essai de réglage de l'espace du cache consulter les statistiques d'activité sur une même période d'utilisation (même nombre d'utilisateurs, avec une même activité). Pour encore plus de précision l'observation des statistiques peut se faire sur une période ou l'application n'est exécutée que par des tests automatiques, qui permettraient d'avoir une activité constante. Personnellement, je ne suis jamais allé jusque là, la simple consultation des statistiques durant la production ayant toujours été suffisante pour se faire une bonne idée.

Créer une copie locale pour test d'un fichier Hyper File Client/Serveur

2008-09-09T11:40:00.004+02:00

Il n'est pas rare d'avoir besoin pour test d'une copie locale d'un fichier de données Client/Serveur en cours d'exploitation. Dans ce cas, la fonction "HCopieFichier" ne peut pas être utilisée, car elle aurait une incidence sur les blocages et accès en cours.

Le code suivant peut avantageusement être utilisé, son exécution sera transparente pour les utilisateurs.

ConnexionHFCS est une Connexion
sNomFicherHFCS est une chaîne = "PRODUITS.FIC"
sdFichierHFCS est une Source de Données
sdFichierLocal est une Source de Données
sRepLocal est une chaîne = "C:\TEMP"
sNomLocal est une chaîne = "PRODUITS"

ConnexionHFCS..Provider = hAccèsHFClientServeur
ConnexionHFCS..Utilisateur = "admin"
ConnexionHFCS..MotDePasse = ""
ConnexionHFCS..Serveur = "SRV_Data:4912"
ConnexionHFCS..BaseDeDonnées = "FACT"

HOuvreConnexion(ConnexionHFCS)
HDéclareExterne(sNomFicherHFCS,sdFichierHFCS,ConnexionHFCS)

HAlias(sdFichierHFCS, sdFichierLocal)
HChangeRep(sdFichierLocal, sRepLocal)
HChangeNom(sdFichierLocal, sNomLocal)
HCréationSiInexistant(sdFichierLocal)

POUR TOUT sdFichierHFCS

HCopieEnreg(sdFichierLocal, sdFichierHFCS, hCopieIdAuto)
HAjoute(sdFichierLocal,hForceIdAuto)

FIN

Note : en fonction des actions faites sur le fichier Client/Serveur en production, il faut compléter le traitement afin de traiter les cas d'erreur.

Comparer deux enregistrements d'une table décrite dans l'analyse ...

2008-09-08T15:44:00.003+02:00

Le WLangage n'a pas de fonction permettant de savoir si deux enregistrements d'un même fichier, ou de deux fichiers différents mais de même structure, sont identiques. Pour effectuer une telle comparaison, sans tester l'égalité entre toutes les rubriques, il est possible d'utiliser une fonction spécifique :

HRécupèreEnregistrement(...)

Cette dernière permet en effet d'avoir le contenu complet d'un enregistrement dans une variable chaîne de caractères. Il suffit donc de l'utiliser sur les enregistrements à comparer, puis de comparer les chaînes obtenues.

Comment récupérer le séparateur décimal de windows ?

2008-05-30T14:53:00.004+02:00

La fonction WLangage "NumériqueVersChaine" peut retourner sous la forme d'une chaine une valeur réelle, tout en utilisant le séparateur décimal de Windows. Elle peut donc servir à récupérer si besoin ce séparateur :

SeparateurDecimal est un caractère
SeparateurDecimal = NumériqueVersChaîne(1.1,"3,1f")[[2]]
Info(SeparateurDecimal)

Encoder un mot de passe pour un serveur LDAP

2008-03-12T13:46:00.000+01:00

Si l'écriture dans un serveur LDAP est simple avec les fonctions LDAP* du Wlangage, il n'en est pas de même dans le cas bien particulier ou l'on souhaite écrire un mot de passe !

Voici le code nécessaire à l'encodage du mot de passe pour qu'il soit "conforme" LDAP :

sMotDePasse est une chaîne = "secret"
sSel est une chaîne = "graindesel"
sHash est une chaîne = HashChaîne(HA_SHA_160, sMotDePasse+sSel)
sAttrib est une chaîne = "{SSHA}"+Crypte(sHash+sSel, "", crypteAucun, encodeBASE64)

Placer en fond d'un état les pages d'un formulaire PDF

2008-02-22T12:16:00.004+01:00

Suite à une demande sur le forum, et intéressé par la fonctionnalité, j'ai recherché comment placer en fond d'un état les différentes pages d'un document PDF.

La méthode n'a rien d'immédiate, je pense que sa publication sera appréciée !

Si un état contient plusieurs pages, et qu'il a en fond un PDF contenant également plusieurs pages, les différentes pages de l'état ne peuvent pas prendre les différentes pages du PDF, mais une seule (et c'est vraiment dommage) :

Il faut donc jongler et créer plusieurs états qui vont être imbriqués les uns dans les autres :
- un premier état est associé à la page 1 du formulaire PDF,
- un deuxième état est associé à la page 2 du formulaire PDF,
- un troisième état est associé à la page 3 du formulaire PDF ....

L'application fera ainsi un iImprimeEtat() du premier état. Ce premier état fera dans son code après impression un iImprimeEtat() du deuxième état, qui appellera à son tour le troisième état...

J'ai testé la solution d'états internes, mais je n'ai pas eu de bons résultats. De façon générale il me semble que les états imbriqués sont à préférer aux états internes.

Gageons que PC SOFT saura faire évoluer la fonctionnalité pour plus de simplicité. Car cette solution s'applique si les pages de l'état sont différentes, mais pas dans le cas ou c'est le bloc corps d'un état qui va se dérouler sur différentes pages ...

Utilisateur courant dans la barre de message, sans programmation comme la date ou l'heure...

2008-02-20T18:13:00.004+01:00

Sans aucune programmation il est possible d'insérer des informations dans la barre de messages des applications : date, heure, depuis peu l'utilisateur en cours dans le cas ou l'application utilise le Groupware utilisateur !

Ce principe du "Zéro code" se développe, avec les actions prédéfinies et les FAA notamment, et c'est une bonne chose pour accélérer les développements, limiter les risques d'erreur, ajouter des fonctionnalités !

Ndlr : terminant une longue intervention sur site, je devrais retrouver avec plaisir un peu de temps pour le blog et le forum dans les semaines qui viennent !

Aide à la saisie obligatoire !!!

2007-12-20T15:15:00.001+01:00

Voici une fonctionnalité de la version 12 qu'il faudrait rendre obligatoire, par respect pour les utilisateurs des applications !

Un jour ou l'autre on se retrouve devant un champ, sans savoir où trouver l'information attendue. Dans le meilleur des cas une bulle d'aide est proposée, ou un bouton d'aide dans la fenêtre, mais il n'est pas rare de ne pas être assisté.

Alors que toute saisie respectueuse de l'utilisateur, devrait permettre instantanément de savoir de quoi il s'agit. Voici un exemple de mise en oeuvre de l'aide à la saisie avec WINDEV 12 (c'est également disponible pour les pages WEB des sites WEBDEV) :

Dès que le curseur est placé dans le champ, l'information d'aide s'efface progressivement avec un effet de fondu pour laisser place à la saisie.

Aucune programmation n'est requise, il suffit de fournir l'information qui guidera l'utilisateur dans la description du champ :

WINDEV 12 non documenté !

2007-12-13T17:46:00.000+01:00

Deux fonctionnalités non documentées de WINDEV 12 découvertes après quelques minutes d'utilisation, certes avec l'aide du support, mais cela vaut un petit billet pour faire circuler l'information en attendant que la documentation rattrape la productivité des développeurs !

1. Recherche dans les styles et les options d'édition des champs, information sur le Blog du support. A vos claviers pour tester le Ctrl+F, il y en a peut être d'autres du même type à découvrir !

2. Afficher un PDF dans une image est enfantin :

IMG_TEST_PDF = fRepExe()+["\"]+"AideDépart.PDF"

Le positionner sur une page précise est ... tout aussi simple, à condition d'avoir trouvé la bonne propriété (ce que l'aide ne donne pas par défaut pour le moment) :

IMG_TEST_PDF..NuméroPage = 4

Au passage le support m'informe qu'à terme le champ image lorsqu'il est affecté avec un PDF, aura une gestion d'ascenseurs, de zoom. Le tout basé sur la technologie "Zéro code" chère à PC SOFT !

Compléter les appels aux navigateurs par un message d'information

2007-11-29T18:21:00.000+01:00

Il n'est pas rare de lancer depuis une application le navigateur Web par défaut sur un site. Le traitement est de la forme :

LanceAppliAssociée("http://elianlacroix.blogspot.com")

Mais les configurations de plus en plus sécurisées peuvent bloquer cette ouverture du navigateur. L'action pourrait en effet être commandée par un programme malveillant...

Il est donc bon lorsque cette ouverture est ponctuelle de donner au passage un message d'information indiquant l'action, et la conduite à tenir en cas de difficulté. Ceci est d'autant plus vrai dans le cas d'une application dite "grand public".

Voici une illustration de ce mécanisme mis en place dans l'application Tomtom Home lorsque l'on tente de consulter la documentation d'un GPS fraîchement déballé :

Ainsi même si l'ouverture est impossible, l'utilisateur final n'est pas dérouté par un bouton sans aucun effet. L'ajout d'une minuterie sur le bouton peut être un plus, ainsi que d'une coche "ne plus afficher ce message".

Accélérer les traitements d'importation de données

2007-10-11T10:23:00.000+02:00

Les temps de traitement pour des importations de données peuvent générer une attente importante si se cumulent des volumes importants, et des index nombreux. En effet, chaque ajout va nécessiter de mettre à jour les différents index correspondant aux données.

Une alternative permettant des traitements d'importations plus rapides, consiste à différer la mise à jour des index en s'appuyant sur le mécanisme de réindexation.

La phase d'importation se fait en utilisant la fonction "HEcrit" en lieu et place de "HAjoute". Elle permettra d'insérer les données à importer, sans aucune mise à jour des index. Cela permet un gain de temps, très significatif dans le cas d'un fichier ayant de nombreux index.

Une fois les données importées, il suffit d'utiliser la fonction "HRéindexe" qui va mettre à jour les index avec les nouvelles données. Dans bien des cas, cette méthode en deux temps est plus rapide qu'une importation traditionnelle avec la fonction "HAjoute".

Sur le même sujet :
Synthèse pour aller plus vite !
Accélérer le lancement des applications

Accélérer le lancement des applications

2007-10-05T10:06:00.000+02:00

Par facilité on place régulièrement la fonction "HCréationSiInexistant" au début des applications pour s'assurer de la création systématique de tous les fichiers de données. Le piège, la base grandissante, est d'avoir une attente importante lors de cet appel, car il provoque une ouverture de tous les fichiers de données. Et l'ouverture initiale des fichiers fait partie des opérations les plus coûteuses en temps.

Il y a une solution, presque miracle, c'est l'option "hOuvertureDifférée" de la fonction :

HCréationSiInexistant("*", hOuvertureDifférée)

En effet, le but escompté est atteint, car tous les fichiers restent créés automatiquement. Mais pour les fichiers existants, l'ouverture ne sera pas faite immédiatement. Elle sera différée à la première utilisation effective du fichier. On comprend aisément le gain de temps très appréciable puisque :
- le temps d'ouverture des fichiers est réparti au fil de l'application,
- seuls les fichiers réellement utilisés seront ouverts.

Sur le même sujet :
Synthèse pour aller plus vite !
Accélérer les traitements d'importation de données

Contrôle lors du changement de volet d'un onglet

2007-10-02T09:35:00.000+02:00

Le champ onglet est pourvu d'un code de modification, appelé lorsque l'utilisateur change de volet. Ce code permet d'exécuter des traitements concernant le volet qui vient d'être affiché. Il s'exécute lorsque le changement de volet est déjà fait.

Pour toutes sortes de raisons, il peut être utile d'exécuter un traitement lorsque l'utilisateur clic sur un nouveau volet, mais avant même que le nouveau volet ne soit affiché. Il faudrait pour cela un code de modification sur l'onglet, mais avant changement !

Ce code n'étant pas proposé par défaut, il est possible d'utiliser en lieu et place le code optionnel "Bouton gauche enfoncé" du champ onglet. En effet ce code est bien appelé avant même que le changement de volet ne soit effectif. Il permet donc par exemple de faire un contrôle de saisie sur le volet sélectionné avant le clic, pour si besoin interdire le changement de volet en inhibant l'événement.

Imprimer une image en gardant le choix de l'imprimante dans l'aperçu...

2007-09-25T13:37:00.000+02:00

En créant un aperçu d'une image avec les fonctions "iAperçu", "iImprimeImage" et "iFinImprime", la fenêtre d'aperçu obtenue ne permet pas la sélection de l'imprimante. C'est pourtant bien utile notamment pour les applications qui s'exécutent depuis des postes portables qui changent régulièrement d'imprimante.

Une astuce permettant d'obtenir une impression d'image avec le choix de l'imprimante, consiste à utiliser un état créé par l'éditeur d'états, plutôt qu'une impression programmée.
Il suffit ensuite de lancer l'aperçu avec la fonction "iImprimeEtat", et l'aperçu sera pourvu du choix de l'imprimante. L'état sera on ne peut plus simple, avec un champ image affecté par un paramètre de l'état, paramètre recevant le nom de de l'image à afficher à l'ouverture de l'état.

Eviter les oublis avec les règles

2007-09-17T13:13:00.000+02:00

Les projets ont toujours des traitements, ou des champs, qui doivent se comporter de façon uniforme, ou provoquer d'autres actions obligatoires au domaine d'application.

Dans la précipitation quotidienne, il n'est pas rare de faire un oubli, préjudiciable en temps par la suite puisqu'il faut revenir sur le traitement ou l'interface, dans le pire des cas après un signalement de l'utilisateur final.

Il y a une fonctionnalité que j'avais initialement sous-estimée, baptisée "règle métier" qui limite grandement les risques d'oublis. En effet, elles permettent d'indiquer pour des champs ou fenêtres, des actions obligatoires, qui seront automatiquement rappelées pendant les phases de développement qui suivront.

Une illustration en image maintenant que l'information circule en vidéo :

Toujours plus d'informations !

2007-09-17T08:00:00.000+02:00

Le site de PC SOFT propose de nouvelles sources d'informations à ne pas négliger pour ne pas passer à côté de fonctionnalités précieuses (cf. prochain billet sur les règles métiers).

Tout d'abord un nouveau blog "Technologies et Marchés" de l'équipe commerciale, mais contenant surtout de l'information technique (tous les blogs).

D'autre part des vidéos en grande quantité pour présenter bon nombre de fonctionnalités. Sans rentrer dans le détail, elles permettent de découvrir de nombreux principes, qu'il est ensuite facile de mettre en œuvre grâce à la simplicité des éditeurs. On retrouve même ces vidéos sur Youtube !

Synthèse pour aller plus vite !

2007-07-30T12:28:00.000+02:00

Voyant apparaître sur les forums des demandes de conseils pour optimiser les accès aux données, j'ai regroupé ici les principaux éléments de réponse, et méthodes à employer. L'optimisation des accès est primordiale, surtout lorsqu'ils sont faits au travers d'Internet qui n'offre pas les débits d'un réseau local.

Privilégier les sélections par des requêtes :
Il est préférable d'effectuer les sélections de données au travers de requêtes. En effet, par opposition à des accès enregistrement par enregistrement, elles vont permettre de "ramener" sur le poste client les données sélectionnées, par "paquets" réseau bien remplis. Des lectures enregistrement par enregistrement vont au contraire générer du trafic avec à chaque fois peu de données. De plus la lecture d'un enregistrement impose de récupérer toutes ces rubriques, alors que la sélection d'une requête peut être affinée en ne prenant que les rubriques utiles à un moment donné. Ceci est d'autant plus vrai si la connexion se fait par Internet.

Optimisation des requêtes :
Le menu "Requête / Optimiser la requête" accessible en édition d'une requête doit finaliser la phase de création d'une interrogation. Il permet d'ajouter si besoin les clés dont la requête aura besoin pour un maximum de rapidité.

Statistiques des index à jour :
Les clés dans le fichier sont importantes, à condition que les statistiques des index soient régulièrement mis à jour (surtout après des ajouts en grand nombre).

Rester raisonnable :
La facilité avec laquelle on programme et accède aux données, le tout généralement dans l'urgence, provoque parfois une négligence de l'évaluation de ce que l'on demande. Chaque enregistrement à une taille bien précise, chaque interrogation va ramener un ensemble d'enregistrements, donc un volume précis. Il faut tenir compte, surtout en accès via Internet, de ce volume, afin d'évaluer avec le débit minimal si l'application ne demande pas trop par rapport à ce qu'elle peut recevoir.

Client/Serveur :
Privilégier un accès aux données au travers du moteur Hyper File Client/Serveur, il va permettre de soulager grandement le travail de chaque poste client, et donc de gagner en performances. Les procédures stockées vont offrir également des gains. Typiquement, un long calcul statistiques pourra être fait en "différé" de l'application, permettant à un utilisateur d'avoir un résultat immédiat en remplacement d'une attente.
Son mécanisme de "Log" pourra également permettre un suivi très fin des interrogations en vue de rechercher notamment des abus d'une station, ou d'un traitement.

Analyseur de performances :
Lorsque l'on a encore des attentes, il faut exécuter l'analyseur de performances qui va permettre de les localiser très précisément. Une fois que l'on sait où passe le temps, il devient possible de voir comment l'influencer (dans un programme uniquement à mon grand regret).
Cas particulier pour l'attente du matin, il faut garder dans un coin de tête le possible trouble que peut engendrer la restauration du système.

Ce billet n'a rien d'exhaustif le sujet étant si vaste, je tenterai de le compléter régulièrement. Mais pas trop vite tout de même, car il est temps pour moi de prendre quelques jours de repos en cette période estivale !

Sur le même sujet :
Accélérer le lancement des applications.
Accélérer les traitements d'importation de données

Attente au matin lors de la mise à jour d'un fichier ...

2007-07-18T18:14:00.000+02:00

Description surprenante d'un utilisateur final :

Tous les matins le premier enregistrement d'une commande prend du temps, les suivants sont immédiats !?

Surprenante, car c'est plutôt au fur et à mesure que l'on "charge" la machine tout au long de la journée qu'elle ralentit, plutôt qu'à son démarrage. Et pourtant, cela peut se produire avec les postes XP configurés par défaut et utilisant une base Hyper File.

Le fautif : la restauration du système de Windows car elle pense que les fichiers NDX (index Hyper File) sont des fichiers systèmes à sauvegarder. De ce fait, après chaque démarrage du poste, si une modification est demandée sur un fichier Hyper File ("HModifie", "HAjoute", "HSupprime"...), une sauvegarde du fichier est faite et peut donc être coûteuse en temps suivant sa taille. Plus généralement, sont concernées toutes les actions qui provoquent une modification de l'index. En revanche la simple consultation n'a pas d'incidence sur la restauration du système.

La solution consiste à indiquer au mécanisme de restauration du système qu'il doit ignorer les fichiers d'index de votre application. Pour cela une clé de registre est mise à disposition par Microsoft. Il suffit donc d'aller insérer une valeur dans cette clé avec la fonction "RegistreEcrit".

La clé de registre est la suivante : HKEY_LOCAL_MACHINE\SYSTEM\ControlSet001\Control\BackupRestore\FilesNotToBackup
Il faut insérer une valeur texte dont le nom est une chaîne quelconque, par exemple le nom de votre application, et la donnée le chemin à exclure.

La copie d'écran ci-contre donne une illustration, et ce lien donne une page de détail sur un site Microsoft.

Echec de visualisation des pages d'une aide CHM

2007-07-16T18:17:00.000+02:00

Surprise après le déploiement d'une application déployée sur un serveur (aucun fichier sur les postes des utilisateurs à part un raccourci) : les aides au format CHM présentaient une erreur de "Navigation vers la page Web annulée".

Renseignement pris auprès du support, rien de plus normal avec un Windows XP à jour : ce n'est pas autorisé !!! Sécurité Microsoft oblige, les .CHM doivent être en local pour une visualisation directe. Il est cependant possible de passer outre cette "sécurité", en suivant les recommandations de cet article :
http://support.microsoft.com/default.aspx?scid=kb;fr;902225

Mon état est devenu fou, il ne voit pas mon paramètre !

2007-07-11T09:34:00.000+02:00

"Tranche de vie", avec un long moment perdu à ne pas réussir à passer un paramètre à un état. Malgré un iImprimeEtat(NomEtat, Paramètre), j'avais systématiquement le message "on attendait 1 paramètres, on en a reçu 0".

Après de longues minutes à chercher, j'ai finalement trouvé mon erreur dans la description de l'état, ou par mégarde les bornes "min" et "max" étaient cochées je ne sais plus pour quelle raison. Le bon code d'appel de l'état avec des bornes et un paramètre aurait du être iImprimeEtat(NomEtat, ValeurBorneMin, ValeurBorneMax, Paramètre).

J'espère que ce billet pourra dépanner quelqu'un, un jour, ce qui me permettra de me sentir moins seul sur pareil bêtise !

Identifier les emails entrants qui sont des réponses aux précédents emails sortants

2007-07-10T11:03:00.000+02:00

Il est de plus en plus fréquent de devoir implémenter un suivi des emails dans les systèmes d'information, par exemple pour qu'une réponse soit directement dirigée vers le bon collaborateur.

L'exemple WD Suivi Email de la LST 68 donne le principe de base, en utilisant la variable Email.Référence. Mais j'ai eu besoin d'aller plus loin pour le cas ou l'on souhaite récupérer directement l'identifiant du dernier message que l'on a envoyé. En effet, le champ Email.Référence empile les identifiants des différents messages, il peut donc être utilise de faire un parcours en sens inverse de son contenu pour trouver l'identifiant du dernier message envoyé. D'autre part dans la structure des emails on peut trouver directement l'identifiant du dernier message, dans une section "In-Reply-To".

Voici donc deux fonctions permettant de parvenir au résultat attendu, n'hésitez pas à les réutiliser si elles répondent à vos attentes !

FONCTION ChercheRéférence(_SourceEmail)

// Recherche dans le code source d'un email reçu en paramètre
// s'il s'agit d'une réponse à un message envoyé précédemment
// On recherche d'abord la balise In-Reply-To, puis dans les
// références (en partant de la fin)
// MESSAGEID_DOMAINE est une constante du projet contenant
// le domaine donné lors de l'envoi des messages (partie droite du @)

sReference est une chaîne
sListeRéférence est une chaîne

sReference = :InReplyTo(_SourceEmail)

SI Position(sReference, MESSAGEID_DOMAINE, 1, SansCasse) ALORS
// Une référence a été trouvée, elle est renvoyée.
RENVOYER sReference
SINON
// Pas de "InReplyTo" dans ce message, on va regarder les références de l'email en partant de la fin.
SI Email.Référence <> "" ALORS
// On supprime les espaces entre les références pour les parcourir
sListeRéférence = Remplace(Email.Référence, " ", "")
POUR TOUT CHAINE sReference DE sListeRéférence SEPAREE PAR "><" DEPUISFIN
// On teste si la référence en cours nous appartient
// Si oui, on a retoure car c'est la plus récente et donc celle que l'on veut.
SI Position(sReference, MESSAGEID_DOMAINE, 1, SansCasse) ALORS
RENVOYER SansEspace(Remplace(Remplace(sReference, ">", ""), "<", ""))
FIN
FIN
// Pas de référence trouvée si on arrive jusque là
RENVOYER ""
SINON
// Par de référence non plus (nouveau message ou réception d'un Webmail qui ne les fait pas suivre)
RENVOYER ""
FIN
FIN

FONCTION InReplyTo(_SourceEmail)

// Retourne le In-Reply-To d'un email dont on reçoit
// le source complet en paramètre (par exemple Email.Source)
// Le In-Reply-To trouvé correspond à l'identifiant d'un email
// envoyé précédemment

sInReplyToBalise est une chaîne = RC+"In-REPLY-TO:"
sInReplyTo est une chaîne
nPosInReplyTo est un entier

nPosInReplyTo = Position(_SourceEmail, sInReplyToBalise, 1, SansCasse)

SI nPosInReplyTo > 0 ALORS
sInReplyTo = ExtraitChaîne(_SourceEmail[[(nPosInReplyTo+Taille(sInReplyToBalise)+1) A ]], 1, RC)
RENVOYER SansEspace(Remplace(Remplace(sInReplyTo, ">", ""), "<", ""))
SINON
// L'info n'est pas trouvée
RENVOYER ""
FIN

Si vous faites un copier/coller du code dans votre éditeur, utilisez ensuite le menu "Code ... Réindentation automatique" afin d'avoir le code correctement affiché.

Pourquoi le code de modification d'un champ s'exécute à l'ouverture d'une fenêtre ?

2007-07-09T13:27:00.000+02:00

Dans l'ordre normal des choses, l'ouverture d'une fenêtre provoque l'enchaînement des traitements suivants :
- code de déclaration des globales de la fenêtres,
- code d'initialisation successives des différents champs,
- et enfin le code d'initialisation de la fenêtre.

Alors qu'elle peut être l'option qui provoque l'exécution du code de modification d'un des champs, avant le code d'initialisation de la fenêtre ?

C'est l'option "Mémoriser la valeur" du détail de la description des champs. En effet, j'ai bataillé un moment pour trouver pourquoi j'avais un onglet dont le code était appelé de la sorte. C'est comme tout, une fois qu'on le sait, cela devient simple et évident. En effet, comme le système restaure un choix de l'utilisateur de l'application, il exécute également le code qui avait été provoqué par ce choix.

Installation MSI ou CAB ? Localisation Framework ?

2007-07-03T22:51:00.000+02:00

Les combinaisons d'installations d'une application WINDEV MOBILE sur un périphérique mobile sont nombreuses, il n'est pas évident de s'y retrouver au départ :
- Utiliser le Framework PC SOFT non renommé,
- Utiliser un jeu de DLL renommées,
- Utiliser un Framework commun renommé.
Le tout à combiner avec le type d'installation retenue : via un fichier MSI ou un fichier .CAB.

Pour faire un bon choix, il faut avoir les réponses aux questions suivantes qui vont dépendre du domaine d'activité, du matériel (...) :
- l'installation sera-t-elle faite sur un mobile directement, sans connexion à un PC ?
- le mobile dispose-t-il d'un espace de stockage important (carte mémoire additionnelle) ?
- plusieurs applications devront-elle être installées ?

Avec ces réponses, il est facile de s'orienter vers le choix le plus adapté, sachant qu'il s'agit de toute façon de compromis :

- installation sur mobile sans connexion à un PC ?
Dans ce cas il faut générer une installation en .CAB qui sera copiée sur le mobile (et automatiquement supprimée après exécution). Dans le cas contraire, un MSI sera préférable car exécuté au travers d'un installeur Microsoft avec lequel l'utilisateur est généralement familiarisé.

- le mobile dispose d'espace avec une carte additionnelle ?
Dans ce cas il est préférable d'utiliser un jeu de DLL renommées, unique pour l'application. De cette manière un .CAB unique sera créé facilitant l'installation. Dans le cas contraire, il faut limiter l'espace occupé en ayant un unique Framework sur le mobile. Si une seule application doit être installée, on garde un jeu de DLL renommées, unique pour l'application. Par contre s'il faut installer plusieurs applications, on retient le choix :
-- utiliser le Framework PC SOFT non renommé pour placer le Framework directement dans le mobile,
-- ou utiliser un Framework commun renommé pour placer le Framework directement sur une carte mémoire.
Dans ces deux cas, 2 fichiers .CAB sont générés : un pour l'application, l'autre pour le Framework.

J'espère que ce résumé pourra donner quelques orientations...

"Mobilité" en nouveau sujet

2007-07-02T23:24:00.000+02:00

Quelques jours passés en Suisse le mois dernier, de nouveaux matériels répondants maintenant à des attentes réelles des utilisateurs, et une bonne promo à "1 euro de plus" comme PC SOFT en a le secret, ont eu raison de moi : me voilà tout fraîchement équipé d'un Smartphone (QTEK) HTC S710.

L'occasion donc d'ajouter une nouvelle catégorie dans le Blog : la mobilité ! J'espère prochainement vous faire partager mes premières astuces et conseils, mais il va falloir que je découvre auparavant ce "nouveau monde" ou l'ergonomie doit être sans cesse la priorité du Développeur !

Il ne faut pas se fier aux idées reçues, ces petits concentrés de technologies ne sont plus des gadgets !

Ndlr : ne vous méprenez pas en ce qui concerne la Suisse, j'ai simplement pu y observer une utilisation bien plus fréquente de ce type d'équipement qu'en France. Rien à voir avec ce qui pourrait fâcher un douanier !

Obtenir une représentation hexadécimale d'une chaîne de caractères alphanumérique

2007-06-27T09:34:00.000+02:00

Petite astuce lorsque l'on doit donner une forme hexadécimale à une chaine : utiliser la fonction "NumériqueVersChaine" qui permet la conversion simple d'une valeur décimale en hexadécimale. Exemple :

sChaine est une chaîne = "Bonjour, 27 juin 2007"
sChaineHexa est une chaîne

POUR i = 1 A Taille(sChaine)
sChaineHexa += NumériqueVersChaîne(Asc(sChaine[[i]]), "2X")
FIN

Info(sChaineHexa)

Une application directe, visualiser le Hash d'un fichier par exemple, car sans conversion de ce type la valeur contient des signes cabalistiques peu lisibles.

Pourquoi le fond d'une fenêtre ne change pas avec la propriété ..ImageFond ?

2007-06-25T12:03:00.000+02:00

Pour le déploiement des applications, il faut garder dans un coin de tête que les éléments (fenêtres, états, images ...) de la bibliothèque sont prioritaires à ceux localisés sur disque.

Exemple type, dans une application on propose à l'utilisateur de changer l'image de fond de sa fenêtre principale. Pour cela, on a dans le code de déclaration des globales de la fenêtre :

MaFenêtre..ImageFond = ComplèteRep(fRepExe())+"ImageFond.jpg"

Il suffit de changer l'image "ImageFond.jpg" du répertoire de l'exécutable pour personnaliser l'image de fond de la fenêtre. Mais attention, cela ne fonctionne que si dans l'application aucune image "ImageFond.jpg" n'est utilisée par ailleurs. Dans le cas contraire, l'image utilisée par l'application est incluse dans la bibliothèque, elle est prioritaire, et une nouvelle image "ImageFond.jpg" dans le répertoire de l'exécutable est tout simplement ignorée.

Colonne combo d'une table, syntaxe de récupération de la valeur donnée par "gLien" au chargement

2007-05-10T12:30:00.000+02:00

Lorsqu'une colonne combo d'une table est chargée par programmation avec "ListeAjoute", et que chaque élément a un identifiant donné avec "gLien", la récupération de cet identifiant n'est pas immédiate.

D'abord il ne faut pas cocher l'option "retourner la valeur spécifiée avec la fonction gLien" dans le détail de la description de la colonne combo.

Ensuite il faut utiliser dans le code la syntaxe suivante :

Info(NomTable.NomColonneCombo[NuméroLigne][NomTable.NomColonneCombo[NuméroLigne]])

Sans cette syntaxe, la récupération de l'information donnée au chargement avec "gLien" n'est que partielle.

Ndlr : ne pensez pas que j'ai trouvé cette syntaxe par moi-même, il s'agit d'une information obtenue du support !

Comment stopper un sablier récalcitrant ?

2007-04-25T21:47:00.000+02:00

Pour faire patienter un utilisateur, l'utilisation d'un sablier est parfaitement adaptée. Mais dans la "vie" d'une application, un traitement simple au départ s'enrichie au fil du temps, fait appel à des composants, dialogues avec d'autres applications ... bref au final, il y a quelque part un Sablier(Vrai) qui persiste et ne veut plus s'enlever même avec un Sablier(Faux) dans le traitement.

Voici une méthode de contournement permettant de s'assurer de la disparition définitive d'un sablier laissé par un traitement.

Il faut créer une procédure globale "StopSablier", qui contiendra uniquement un appel de Sablier(Faux). Les automatismes de procédure feront le reste, comme le montre la copie d'écran du billet. Pour résumer, avec un seul appel de la procédure dans le code, on va appeler 3 fois Sablier(Faux), on est ainsi certain de reprendre le curseur de souris standard !

Pas forcément élégant, mais radicalement efficace !

Définir l'instruction suivante pour déboguer 10 fois plus vite !

2007-04-20T09:13:00.000+02:00

Pendant longtemps le passage au Débogueur d'un code permettait :
- de suivre l'exécution en pas à pas (F7),
- de repérer le traitement à corriger,
- faire la correction,
- relancer un test pour s'assurer du résultat en ayant donc à refaire tout le processus permettant d'arriver au traitement...

Mais maintenant il y a le bouton que je surnomme le "bouton magique du Débogueur", qui permet de définir l'instruction suivante, tout en débogant. Il facilite en effet considérablement la mise au point et permet :
- de suivre l'exécution en pas à pas (F7),
- de repérer le traitement à corriger,
- faire la correction, et immédiatement rexécuter le code juste avant cette modification !!! Il n'est plus nécessaire de relancer le test et donc de refaire tout le processus permettant d'arriver au traitement.

Il est même possible de changer une fenêtre sous l'éditeur, et de réexécuter son ouverture. Mais là les cas d'usage sont moins fréquents.

Migrer une analyse vers une autre base de données...

2007-04-16T14:27:00.001+02:00

Les forums contiennent souvent des sujets de la forme "comment migrer mon analyse" en Oracle, en SQL SERVER, MYSQL...

J'avais évoqué ce sujet dans un précédent billet, il n'y a aucune migration à faire au niveau des descriptions de fichiers pour utiliser une base de données ou une autre ! Si dans l'analyse un fichier est décrit en Oracle, sa description peut être appliquée en Hyper File, SQL SERVER ou tout autre base pour laquelle on dispose d'un provider OLE DB ou d'un accès natif.

La clé du mécanisme : les fonctions "HOuvreConnexion" et "HChangeConnexion".

Peu importe le type indiqué dans l'analyse, à tout moment le programme peut :
- appeler "HOuvreConnexion" pour ouvrir une connexion vers une base de données,
- puis appeler "HChangeConnexion" pour associer les tables de l'analyse, à cette nouvelle connexion.

C'est donc un mécanisme à garder dans un coin de tête, bien plus rapide que de se lancer dans des modifications de l'analyse, générations ...

Jauge en lieu et place du sablier lors de l'exécution d'une requête, la "soluce" !?

2007-04-14T23:33:00.000+02:00

Les utilisateurs ne supportent pas les écrans figés avec un sablier, pourtant imposés lorsqu'une requête importante doit être exécutée.

Afin d'afficher une jauge durant le traitement d'une requête, il faut bien récupérer en premier lieu le nombre d'enregistrements à traiter avec la fonction "HNbEnr", et cette dernière fige l'application avec le sablier tant que toute la requête n'est pas exécutée dans sa totalité.

Et bien cela n'est plus vrai, après consultation des dernières nouveautés !!!

La fonction "HNbEnr" a été dotée d'une option "hNonBloquant". Elle permet de connaître immédiatement après l'appel de la requête, le nombre d'enregistrements déjà récupérés. Il est donc possible de débuter le traitement de la requête par son parcours, tout en affichant une jauge certes approximative, mais une jauge. Au fur et à mesure du parcours, si la propriété "..ExécutionTerminée" retourne faux, il est possible de réajuster la jauge avec le nombre d'enregistrements récupérés en rappelant "HNbEnr".

Tous ceux qui aiment observer les utilisateurs de nos applications, savent déjà que le traitement sera jugé plus rapide, du moment qu'une progression est visible !

Extraire sur disque des fichiers contenus dans une bibliothèque ?

2007-04-13T16:58:00.000+02:00

J'ai longtemps pensé que cela n'était pas possible, et pourtant ... astuce découverte sur le forum WIN DEV, elle mérite d'être connue j'espère pouvoir la relayer par ce billet !

Je remercie son auteur que je cite (presque) directement :

- Faire un fichier Hyper File avec une rubrique mémo binaire,
- Ajouter les fichiers que l'on veut pouvoir extraire dans le mémo binaire,
- Inclure ce fichier (.fic, .ndx, .mmo) dans l'exécutable,
- dans le code indiquer que pour ce fichier il faut le rechercher dans la bibliothèque :
HChangeLocalisation(Fichier, hWDL)

Et voila.

Il suffit de rechercher dans le fichier Hyper File l'enregistrement qui contient le fichier que l'on souhaite extraire, puis de l'extraire avec :
HExtraitMémo(Fichier,MemoFichier,"C:\chemin...\FichierDestination")

Message d'origine.

Ajout de descriptions de tables MYSQL dans une analyse provoque une erreur MSVCRT.DLL ou WDHF

2007-04-13T16:15:00.000+02:00

Rien de pire qu'une action que l'on utilise couramment, et qui sur un poste ne daigne pas s'exécuter. J'ai rencontré ce cas avec l'importation d'une table MYSQL dans une analyse. Après le listage des tables de la base MYSQL, un des messages suivants était affiché :

Une erreur système inattendue est survenue.
Si cet incident se produit de manière systématique
Module MSVCRT.DLL...

Ou :

Erreur interne à la DLL WDHF

L'origine de la panne ? Une version de LIBMYSQL.DLL qui ne convenait pas à WINDEV.
Le problème a donc disparu en installant un MYSQL et en récupérant sa LIBMYSQL.DLL standard. Précédemment il s'agissait d'un MYSQL installé avec par EasyPHP.

Pourquoi la taille d'un fichier Hyper File n'est pas réduite après un lot de suppressions ?

2007-04-13T15:59:00.000+02:00

L'appel en série de la fonction "HSupprime()" ne provoque pas la diminution de la taille du fichier. Ceci est valable pour le fichier de données (.FIC) et pour son mémo (.MMO).

Déroutant au premier abord, mais normal en creusant un peu. En effet, pour le système de fichiers (FAT32, NTFS...) l'allocation d'un espace ou sa restitution est coûteuse en temps. Il n'y a qu'à voir la différence de temps entre un copier/coller par l'explorateur, et un couper/coller du même volume. De ce fait en cas de suppression, la taille initiale est conservée, il y a simplement un "marquage" des enregistrements laissés libres par les suppressions. Les ajouts ultérieurs viendront réutiliser ces espaces vides.

Si après une suppression importante on souhaite récupérer l'espace disque correspondant, il est possible d'exécuter la fonction "HRéindexe" avec compression : là tout l'espace est restitué.

A noter que par un parcours séquentiel du fichier sur les numéros d'enregistrements, on peut passer sur les enregistrement marqués à réutiliser (cf. fonction "HEtat").

A noter d'autre part que ce mécanisme met clairement en évidence le fait qu'il ne faut jamais baser un traitement, encore moins une liaison, sur un numéro d'enregistrement puisqu'il n'est pas fixe.

Récupération d'un variant provenant d'une DLL ActiveX...

2007-03-27T09:42:00.000+02:00

Lorsqu'une procédure WLangage est appelée par une DLL en passant un variant en paramètre, une "gymnastique" est nécessaire pour récupérer l'information renvoyée par la DLL. Cela vaut bien un billet, pour gagner un peu de temps, car en tout premier lieu on aurait tendance à écrire l'entête de la procédure avec :

PROCEDURE AppeléeParDLL(RecupValeur est un variant)

Pourtant avec cette déclaration le message suivant sera obtenu lors de l'exécution :

"Un élément de type ne peut pas être converti vers le type variant"

La bonne déclaration, puis syntaxe de récupération du paramètre est la suivante :

PROCEDURE AppeléeParDLL(RecupValeur)

varRecupVariant est un Variant = RecupValeur
VariantConvertit(varRecupVariant, wlChaîne)
Info(varRecupVariant)

A noter que l'appel de la procédure "AppeléeParDLL" en réponse à la DLL ActiveX est initialisé avec la fonction "AutomationEvénement".

Le numéro d'enregistrement des fichiers et des requêtes.

2007-03-08T00:40:00.000+01:00

Lors du parcours d'un fichier, on peut connaître la position physique de l'enregistrement dans le fichier avec la fonction HNumEnr(). A partir de ce numéro, il est possible par la suite d'effectuer un accès direct à l'enregistrement avec la fonction "HLit", ou une modification avec "HMofifie(,)".

Par contre lors du parcours du résultat d'une requête, cette même fonction "HNumEnr" donne un numéro d'enregistrement dans la requête, mais pas celui de l'enregistrement d'origine dans le fichier. Pour avoir le numéro de l'enregistrement du fichier, il est possible d'utiliser la variable d'état "H.NumEnr" après une lecture dans la requête. On peut ainsi envisager après une lecture d'un enregistrement du résultat d'une requête, de modifier directement l'enregistrement correspondant dans le fichier avec "HMofifie(,)".

Attention par contre à l'utilisation du numéro d'enregistrement pour accéder aux données. Cette technique convient à un instant donné dans l'application. Par contre il ne faut pas utiliser ce numéro d'enregistrement par exemple pour lier des enregistrements. En effet, la position physique d'un enregistrement dans un fichier est modifiée lors d'opérations de maintenance. Pour les liaisons, l'utilisation de l'identifiant automatique est la meilleure solution.

Copier un menu contextuel d'une fenêtre à une autre ?

2007-03-07T15:05:00.000+01:00

Les menus contextuels n'étant pas proposés dans le volet de l'éditeur ou la zone Kouglof, il faut donc "ruser" pour récupérer un menu contextuel d'une fenêtre vers une autre. L'astuce est la suivante :
- dans la fenêtre contenant le menu contextuel, créer un bouton,
- associer ce bouton au menu contextuel,
- copier/coller ce bouton vers la fenêtre qui doit recevoir ce menu ...
et c'est fait ! La fenêtre dans laquelle le bouton a été copié contient maintenant le menu. Le bouton peut être supprimé.

Plus qu'une ligne de code : One-liner

2007-03-02T12:54:00.000+01:00

En clin d'oeil au billet "Pour quelques lignes de code en moins", je pousse le bouchon un peu plus loin avec un programme WIN DEV qui n'a plus qu'une ligne de code, ou "one-liner". Il s'agit de remplacer dans un fichier le caractère de code ascii 10 par un traditionnel "retour-chariot" ou RC. Les adeptes auront reconnus un fichier provenant de Linux devant être transformé pour faciliter son utilisation sous Windows !

fSauveTexte(Remplace(LigneCommande(), fExtraitChemin... (LigneCommande(), fExtension), ...
"New"+fExtraitChemin(LigneCommande(), fExtension)),...
Remplace(fChargeTexte(LigneCommande()), Caract(10),RC))

Le code se trouve dans le code du projet, aucune interface n'est requise pour ce "convertisseur". Une copie du fichier dont le nom est reçu en ligne de commande est créée, avec remplacement du "Caract(10)" par un "retour-chariot". La copie garde le nom et l'emplacement d'origine, seul un "New" est ajouté au nom, juste avant l'extension.

Pour quelques sourires de plus : améliorer l'accessibilité de la Loupe.

2007-02-28T22:39:00.000+01:00

Au petit matin dans les bouchons, il y a deux attitudes. Coller le pare choc de son prédécesseur en se jurant, une main crispée sur le volant et l'autre sur le klaxon, que personne ne vous volera une place. Ce mode de conduite permet de s'assurer un gain de temps pouvant aller jusqu'à 3 secondes, pour l'arrivée au feu suivant 75 mètres plus loin. A l'inverse, il est possible de toujours laisser une distance de sécurité raisonnable avec son prédécesseur, afin de permettre aux autres usagers de prendre leur place dans le trafic. Cette attitude permet de récolter le sourire d'autres conducteurs, soulagés d'enfin trouver une âme charitable tolérant un changement de file, l'accès ou la sortie d'une place de parking... J'opte personnellement pour cette seconde attitude. Pour une journée efficace, la récolte quotidienne de 3 s/km (1) me semble une bonne moyenne.

Un bonus de sourires (2) peut être obtenu en ajoutant un "plus" à une application existante, avec un coût de programmation quasiment nul.

Cas typique, une table fichier permet de rechercher un enregistrement via la loupe. La plupart des recherches se font via une même colonne de la table (numéro de commande, de téléphone, adresse email de plus en plus souvent ...). L'opérateur arrive sur sa fenêtre de recherche, vient cliquer sur la Loupe pour entamer une nouvelle recherche. C'est le genre d'opération que l'utilisateur final peut faire 50 fois dans la journée dans bien des applications.

Pour le "bonus sourires", ajoutez un tri automatique sur la colonne qui est la plus utilisée, et forcer dès l'ouverture de la fenêtre le "focus" sur la table en question. Il suffit d'insérer les appels des fonctions "TableTrie" et "EcranPremier" dans le code d'initialisation de la fenêtre. Le résultat : l'utilisateur dès l'ouverture de sa fenêtre de recherche peut immédiatement entamer la saisie d'une valeur, le passage en saisie dans la loupe de la colonne triée devenant ainsi automatique.

Un détail diront certains. Oui, mais je peux vous assurer qu'une personne ayant pendant des mois eu à faire cette recherche en allant cliquer sur cette loupe, va gagner un grand confort d'utilisation et vous faire de grands sourires le jour ou vous lui permettrez d'éviter ce clic en plus !

(1) s/km : sourires obtenus par kilomètre parcouru à moins de 10 km/h.
(2) rassurez-vous, si vous vous êtes reconnus dans la première attitude au volant, il en faut pour que les garagistes aient encore à changer des embrayages ;-), cela n'empêche pas d'aimer les sourires des Utilisateurs de vos applications !

64 Bits, mais à tous les étages

2007-02-25T21:21:00.000+01:00

La création d'applications 64 bits peut être nécessaire pour répondre à certaines exigences de mise en exploitation.

Le passage d'une application existante en 64 bits, se fait simplement via la coche d'une option dans la description du projet. Mais attention tout de même, si c'est très simple dans une application constituée d'une unique bibliothèque, s'il y a au contraire de nombreux composants la tâche est plus importante. En effet, si l'application est compilée avec la compatibilité 64 bits activée, les composants qu'elle utilise devront également être générés avec la compatibilité 64 bits. Il faut donc penser à cocher l'option de compatibilité 64 bits dans les composants.

Rassurez-vous, l'éditeur vous indique par un message d'information la présence d'un composant qui ne serait pas à jour (ci-contre).

L'activation de la compatibilité 64 bits n'a que très peu d'effets sur les traitements. Les modifications à effectuer vont concerner les types des variables du WLangage, notamment dans les appels de fonctions des API Windows. En effet, une déclaration "est un entier système" doit être faite en lieu et place de déclarations avec "est un entier sur x octets". Là également c'est l'éditeur de code qui indique après une compilation les changements à faire, il n'est pas nécessaire de "fouiller" son code.

Il peut également être nécessaire d'ajouter des variables intermédiaires, car les fonctions du WLangage ne retournent pas des "entier système". C'est par exemple le cas de la fonction "Dimension" qui ne peut donc pas être donnée directement à la fonction "API" si la compatibilité 64 bits est active. Sur ce dernier point, PC SOFT proposera sans doute des évolutions, car cet ajout pourrait être évité.

Pour la phase finale de création de l'exécutable, il est bien d'avoir recours à une nouvelle configuration de projet. Elle permettra via un unique projet de générer un exécutable 32 bits et un exécutable 64 bits. Elle permettra également si besoin la création de composants, de Web services, le tout en une seule opération par le menu "Atelier / Génération multiple".

A savoir avant de déployer sous Windows Vista...

2007-02-20T09:43:00.000+01:00

Après, au fil des bêtas, les incertitudes sur les fonctionnalités qui seraient actives ou non par défaut, Windows VISTA est devenu une réalité. Le voile est levé, plus aucun incertitude ne subsiste l'UAC est active par défaut.

L'UAC, ou pour les initiés User Account Control, est une des fonctionnalités majeure de Windows VISTA. Elle doit permettre de redonner au système la sécurité qui faisait défaut aux précédentes versions.
Lorsqu'elle est active, et que le programmeur ne tient pas compte de ses spécificités, un panneau d'information avec l'icône ci-contre sera fréquemment donné à l'utilisateur final qui risque d'être dérouté. En effet par défaut les privilèges sont restreints, il faut jusqu'à 7 clics par exemple pour supprimer un raccourci sur le bureau.

Ainsi par défaut un message relatif à l'élévation des privilèges peut être affiché régulièrement. N'ayant qu'une expertise limitée sur le sujet, je n'aurai pas la prétention de vous décrire les méandres de ce mécanisme. En revanche un article Microsoft détaille ce qu'il faut absolument connaître de l'UAC avant d'aborder Windows VISTA. Je vous encourage donc vivement à le consulter.

Si besoin dans un tout premier temps, notamment pour le Développement, il est possible de désactiver l'UAC. Plus généralement, les fonctionnalités de VISTA peuvent être activées ou désactivées via ce mode opératoire.

Bon à savoir, exemples revus à profusion...

2007-01-30T12:04:00.000+01:00

Le DVD de la LST 66 contient en plus des exemples de la LST elle-même, une série d'exemples des précédentes versions ou LST, revus et améliorés.

En voici la liste un peu "brute", mais un Ctrl+F permet de rechercher un sujet qui vous intéresse :

WD Arbres en saisie, WD Calcul statistiques Hyper File, WD DerniersDocuments, WD Ecran Tactile, WD Fenêtres furtives, WD FileImpression, WD GANTT, WD Glossaire, WD JournalEvenement, WD ListeGraphique, WD ModeleImpression, WD PartageMemoire, WD Pays du Monde, WD photocopieur, WD Saisie assistée de répertoire, WD Saisie Email, WD Scanner, WD Select RTF, WD Table Etendue, WD Active Directory DotNet, WD JaugeFTP, WD Lecteur RSS, WD MotDePasse, WD ProxyPOP3, WD Threads FTP, WD VisuTIF, WD WMI DOTNET, WD APISystemes, WD Appels JAVA, WD Arbre Doublons, WD ContrôleADistance, WD ExtractionMIME, WD GroupwareCS, WD Impression de Tree View, WD Licence, WD ListeChaînée, WD Masque de saisie avancé, WD Onglets glissants, WD Paramètres Impressions, WD Persistance, WD Serveur RMI, WD Trace Socket, WW_DiagrammeGANTT, WW_ImagePass, WW_VitrineAWP, WW_ChangementCSS, WW_FlashParametrable, WW_Fraimes, WW_MapArea, WW_MiseEnEvidence, WW_ReassortXML, Pocket GANTT, Pocket Clavier Virtuel, Pocket ExtractionMIME, Pocket MotDePasse, Pocket Persistance, Socket Unicode.

Ndlr : je fais ce billet car je n'avais pas vu ce contenu lors de l'installation de cette LST, je me dis du coup pour me rassurer que je ne dois pas être le seul !

Accélérer les applications sur les configurations limitées, ou en TSE

2007-01-17T00:11:00.000+01:00

Si les applications sont toujours plus agréables de part leur aspect et leur richesse fonctionnelle, elles sont forcément plus gourmandes en ressources.

Il arrive donc que des configurations ne suivent plus, soit en raison des caratéristiques d'une station, soit en raison d'une limitation des ressources dans un contexte TSE.

Une astuce à connaître dans pareil situation, consiste à "jouer" de la propriété "..AffichageActif". Pendant toute la durée d'un traitement important (remplissage de champs, calculs...), il sera possible de "débrayer" l'affichage qui est généralement le plus couteux en temps.

Si cela n'est pas suffisant, la création d'un rapport "WPF" avec les fonctions "AnalyseurDébut" puis "AnalyseurFin" permet généralement de repérer le(s) traitement(s) à optimiser avec l'analyseur de performances (appelé également Profiler).

Une interface personnalisée en quelques clics avec l'opacité des champs...

2007-01-16T23:18:00.000+01:00

S'il y a bien un domaine dans lequel il est difficile de progresser lorsque l’on n’a pas la science infuse, c'est bien celui des interfaces !

Heureusement, les gabarits font une grosse partie du travail, en permettant d’avoir d’emblée une interface agréable, comme le montre l’image ci-contre avec une fenêtre au look Vista exécutée sur mon poste XP.

Mais avec quelques clics en plus, il y a moyen de se différencier du gabarit standard. En effet, l’opacité des champs permet d’apporter une touche esthétique supplémentaire. Il suffit de placer sous les champs une image piochée dans le catalogue. Une image en rapport avec le contenu de la fenêtre est vivement recommandée, ou une image type "splash screen" également proposée dans le catalogue.

Une fois l’image en place, il suffit de jouer sur son opacité, ainsi que sur celle des champs par-dessus pour obtenir un effet tout a fait convenable, et surtout sans passer par un outil de retouche d’image qui aurait nécessité de jouer de la transparence avec différents calques !

Voici un exemple de résultat, certes de piètre qualité car en cherchant une image d’une taille plus adaptée il aurait été possible de faire bien mieux, toujours en quelques clics.

A noter en astuce que le modifieur est très utile dans ce type de manœuvre pour par exemple changer l’opacité de plusieurs champs à la fois. D’interface austère, il est cependant parfaitement adapté à la manipulation des propriétés des champs de l’interface.

Pour quelques lignes de code en moins...

2007-01-02T23:35:00.000+01:00

Je profite de ce premier billet de l'année 2007 pour souhaiter une excellente année à ceux qui me lisent, régulièrement ou non !

Il n'est pas rare d'empiler des SI ... SINON ... FIN pour des affectations de variables, de paramètres... Il en résulte un "code à rallonge", qui même avec l'enroulé de l'éditeur code reste long à manipuler. Typiquement, l'affectation des paramètres d'une requête, lorsque certains ne doivent pas être pris en compte, exemple :

SI ChampNom <> "" ALORS
Req.ParamNom = ChampNom
SINON
Req.ParamNom = NULL
FIN

SI ChampDNaissance <> "" ALORS
Req.ParamDNais = ChampDNais
SINON
Req.ParamDNais = NULL
FIN

..

HExecuteRequete(Req)
FichierVersTableMémoire(Req, TableSélection)

L'alternative se nomme "instruction conditionnelle monoligne" (cf entrée d'aide "Condition, Instruction ?"). Beaucoup de vocabulaire pour un principe tout simple : affecter une variable par une valeur, ou par une autre, en fonction d'une condition. L'écriture ci-dessus est ainsi simplifiée à l'extrême tout en restant lisible, une fois l'habitude acquise :

Req.ParamNom = ChampNom <> "" ? ChampNom SINON NULL
Req.ParamDNais = ChampDNais <> "" ? ChampDNais SINON NULL
..
HExecuteRequete(Req)
FichierVersTableMémoire(Req, TableSélection)

Fonctions WLangage dans le code SQL, mais également procédures stockées...

2006-12-22T21:25:00.000+01:00

L'appel d'une fonction du WLangage dans une requête SQL est permis, mais bien évidement il est possible d'appeler une procédure stockée sur le serveur avec la même méthode.

La méthode est on ne peut plus simple :
- dans l'analyse, créer une collection de procédures, puis une fonction par le clic droit dans le volet,
- dans un traitement, appeler la fonction "HMiseAJourCollection" qui permet de copier la collection de procédures, sur le serveur.

A ce stade, il est possible d'insérer l'appel des procédures de la collection, dans les requetes SQL lancées. Exemple avec le même modèle de traitement que dans le précédent billet :

sNomFichierTXT est une chaîne = "c:\temp\commande.txt"
sListeCommande est une chaîne
sCodeSQL est une chaîne
sdReq est une Source de Données

sCodeSQL = [
SELECT ProcServeur(DateCommande) as DateCommandeformatée,
NumCommande,
TotalHT
FROM COMMANDE
]

HExécuteRequêteSQL(sdReq, sCodeSQL)

POUR TOUT sdReq
sListeCommande += [RC]+HRécupèreEnregistrement(sdReq,TAB)
FIN

fSauveTexte(sNomFichierTXT, sListeCommande)
LanceAppliAssociée(sNomFichierTXT)

La procédure "ProcServeur" aura un code WLangage qui pourra traiter la date reçue en paramètre, pour la formater différemment par exemple, ou pour la modifier en fonction de données, requêtes de la base.

Attention, dans la version en cours de WINDEV 11 je n'ai pu appeler la procédure que par la fonction "HExecuteRequeteSQL". Sauf mauvaise manipulation de ma part, l'éditeur de requêtes n'a pas encore l'air adapté à l'appel des procédures stockées.

Fonctions Wlangage dans les requêtes Hyper File avec l'opérateur "WL." (WINDEV 11)

2006-12-20T15:42:00.000+01:00

Le moteur Hyper File Client/Serveur propose les procédures stockées, et de ce fait permet l'appel de fonctions du Wlangage, directement dans le code SQL des requêtes !

J'ai fait quelques tests de procédures stockées, et au passage j'ai utilisé cette possibilité. Cela va simplifier bien des traitements nécessitant le formatage du résultat d'une requête, en vue d'une exportation par exemple.

Un cas typique, je dois générer un fichier texte contenant des dates / numéros / montants de commandes. La date doit être lisible, et non pas au format "AAAAMMJJ" utilisé pour le stockage et l'affectation des champs ou colonnes de type date des interfaces.

Le résultat peut être obtenu immédiatement dans la requête, ce qui évite un traitement des données lors du parcours qui suit la requête.

Voici un exemple utilisant cette possibilité (il s'agit du code de l'image de ce billet) :

sNomFichierTXT est une chaîne = "c:\temp\commande.txt"
sListeCommande est une chaîne
sCodeSQL est une chaîne
sdReq est une Source de Données

sCodeSQL = [
SELECT WL.DateVersChaine(DateCommande) as DateCommandeformatée,
NumCommande,
TotalHT
FROM COMMANDE
]

HExécuteRequêteSQL(sdReq, sCodeSQL)

POUR TOUT sdReq
sListeCommande += [RC]+HRécupèreEnregistrement(sdReq,TAB)
FIN

fSauveTexte(sNomFichierTXT, sListeCommande)
LanceAppliAssociée(sNomFichierTXT)

A noter qu'il est possible de donner un formatage spécifique à la date avec le code SQL suivant :

sCodeSQL = [
SELECT WL.DateVersChaine(DateCommande,'JJJ JJ MMM AAAA') as DateCommandeformatée,
NumCommande,
TotalHT
FROM COMMANDE
]

Le fichier généré aura les dates dans un format "Ven. 28 Jan. 2000" par exemple.

Ndlr : la requête est volontairement simpliste pour l'illustration, elle permet dans un cas réel une sélection de données. Ce qui est très intéressant, c'est le code d'exportation qui est simplifié à l'extrême, et qui dit code simple, dit code plus rapide avec un risque d'erreur de programmation moindre !

Nouveau site WINDEV : Ed4u

2006-12-19T23:36:00.000+01:00

Apparition d'un nouveau site de ressources WINDEV : Ed4u. Peu d'informations dans l'immédiat, le site basé sur un CMS vient d'être publié ces derniers jours c'est donc un peu tôt. Les auteurs semblent cependant très motivés, je leur souhaite de réussir dans leur projet !

Exécuter une action lors du tri d'une colonne de table

2006-12-15T18:32:00.000+01:00

Il est fréquent de devoir effectuer une action lorsque l'utilisateur trie les données d'une table. Une capture d'événement était requise jusqu'à la version 10, ce sujet a été fréquement abordé sur le forum. Le code nécessaire se trouve ci-dessous.

Il est cependant rendu obsolète, puisque WINDEV 11 permet d'ajouter aux colonnes un code "à chaque tri" !

//1. Code d'initialisation de la table :
Evenement("TRISPECIAL","TABLE1", 1529)

//2. Procédure TRISPECIAL
Procédure TRISPECIAL()
// _eve.wParam contient le numéro de la colonne
Trace("On a cliqué sur l'entête de la colonne n° "+_eve.wParam )
SI _eve.wParam = 2 ALORS
//On veut que la procédure TRISPECIAL permet d'obtenir un tri sur
//la colonne COL2 puis sur la colonne COL1:

// Annuler le tri automatique
_eve.retour = 0
tabletri("COL2"+TAB+"COL1")
FIN

Ndlr : ce code a pour origine un message du support.

Concaténation optionnelle avec WINDEV 11

2006-12-15T01:33:00.000+01:00

Combien de bogues ont été générés par un caractère en trop en début ou fin de chaîne ? Ou un "\" manquant dans un chemin d'accès, ou un "/" dans une URL ?

Le cas de figure est très fréquent, on doit fournir une liste construire dans une itération, avec un séparateur bien déterminé. Le code à la forme suivante :

POUR TOUT Client AVEC CodePostal="26110"
sListeClient += Client.Nom+", "
FIN

Et il faut ensuite supprimer le ", " en trop en fin de chaîne s'il y a eu au moins un client. Ou alors faire une condition dans la boucle pour gérer le séparateur ... Bref plusieurs méthodes que l'on panache, ce qui augmente encore le risque d'erreur.

Du coup la fonctionnalité "concaténation optionnelle" avait attiré mon attention dans la brochure, je l'ai mise en ouvre et immédiatement adoptée !
Voici un exemple (j'en proposerai un plus parlant prochainement en situation) :

POUR TOUT Client AVEC CodePostal="26110"
sListeClient += [", "] + Client.Nom
FIN

Composant, partage par le GDS

2006-12-15T01:13:00.000+01:00

Essai suivant sur la version 11 de WINDEV, l’intégration des composants dans le GDS.

Je ne pense pas qu'il soit nécessaire de rappeler l'intérêt des composants, salutaires dans les projets pour partager des fonctionnalités entre les différents modules, et surtout pour sécuriser les accès au système d'information.

De la même manière, le GDS est également devenu totalement incontournable pour gérer les modifications des projets, et leur partage entre les développeurs.

Mais la gestion des composants n’étant pas intégrée au GDS en version 10, des gymnastiques étaient souvent nécessaires pour assurer la mise à jour des composants d’un projet, et il ne fallait pas non plus oublier de les transmettre d’un développeur à l’autre, ou d’un site à un autre suivant le cas. Ayant plusieurs fois mentionné ces difficultés à PC SOFT, j’ai prioritairement regardé les possibilités du GDS en matière de gestion des composants. Nouvelle bonne surprise, puisque le GDS a inclus le nécessaire.

La création d’un composant tout d’abord permet dans son assistant de placer le composant dans l’arborescence du GDS, en plus du centre de réutiliabilité (ce dernier n’était pas facilement partageable entre sites distants comme l’est le GDS).

Ensuite l’intégration d’un composant dans le projet propose également la récupération d’un composant, depuis le GDS. La mise en place des ressources partagées va être facilitée. Par contre je ne crois pas avoir vu d’option permettant d’inclure les composants utilitaires fournis par PC SOFT dans le GDS. Il me semble que l’installation de WINDEV pourrait proposer d’ajouter ses composants dans la base GDS, la réutilisation sera encore accrue. Peut être ma première suggestion pour WINDEV 11 !

Le plus bel effet, sans compétence infographique, c'est WINDEV 11

2006-12-15T00:35:00.000+01:00

Malgré la "suractivité" qu’entraîne la période de fin d'année, je débute la découverte de WINDEV 11 installé il y a quelques minutes sur mon portable. Je manque cruellement de temps ces jours-ci, mais je ne peux pas résister à quelques essais !

Le premier lancement est une surprise visuelle, l'interface est profondément améliorée en terme d'esthétisme : effets de transparence, animation des boutons, halos, alors que mon poste est équipé de Windows XP SP2 et non pas de Vista !

Comme je suis d'un naturel envieux, je me suis en priorité demandé s'il serait aisé de reproduire ces effets dans des modules existants.

Pour test, j'ai utilisé un programme permettant aux enfants de réviser leur vocabulaire, en répondant aux interrogations de l'agent Microsoft !

Et bien plus que jamais, le savoir faire PC SOFT est bien présent dans cette version, puisque avec mes piètres compétences graphiques, sans programmation, "Appliquer un gabarit" et quelques clics m'ont permis d'obtenir une interface "Vista" telle que la propose WINDEV 11, toujours sur mon système XP !

IE7 et le volet "Quick tab" ou "Aperçu mosaique"

2006-12-14T09:39:00.000+01:00

La nouvelle version du navigateur Internet Explorer propose une fonctionnalité bien intéressante, avec l'ouverture des sites dans des volets. Cette possibilité n'a rien de révolutionnaire, Firefox la propose depuis longtemps, et la navigation par des volets dans une application est chose commune. Par contre, dès qu'au moins deux volets sont ouverts, un volet "Quick tab", ou "Aperçu mosaïque" est ajouté. Là c'est une révolution dans la présentation des données pour l'utilisateur, en un coup d'œil il repère le volet sur lequel il souhaite retourner. Et à tout moment le raccourci Ctrl+Q permet de revenir à la mosaïque.

Au quotidien, cette méthode de présentation peut faire gagner un temps précieux en Alt+tab, "non c'est pas celui là", Alt+tab, "non c'est pas celui là" ...

Pour les applications, cette possibilité sera peut être proposée par WINDEV pour les champs onglets ou boite à outils ! C'est en tout cas une suggestion que je vais m'empresser de faire à PC SOFT !

La copie d'écran ci-dessus montre IE7 en position de recherche d'informations WINDEV. Mais j'en ai également un ouvert avec des volets remplis de cadeaux, Noël oblige !

Un bémol tout de même dans la fonctionnalité, elle est gourmande en mémoire. 100 Mo de RAM sont rapidement nécessaires pour ouvrir plusieurs volets.

Fonctionnalités d'exportation (RTF, XLS, RTF ...) depuis l'aperçu pour les impressions programmées

2006-12-05T13:30:00.000+01:00

L'aperçu des états imprimés créés avec l'éditeur d'états propose par défaut des sorties dans différents formats : RTF pour Word, XLS pour EXCEL, PDF, XML, ou envoi par email.

Cette même possibilité n'est pas disponible pour les impressions programmées par les fonctions "iImprime", "iImprimeMot", "iImprimeZone", "iImprimeImage"... alors qu'elle est bien utile !

Il existe un moyen de combiner ces deux "méthodes" d'impression pour avoir une impression programmée, imprimée au travers d'un état. Ainsi l'impression programmée bénéficie des possibilités d'exportation dans l'aperçu.

Le moyen pour y parvenir est très facile à mettre en œuvre, il suffit de :
- créer un état ne parcourant aucune donnée, sans aucune champ,
- placer le code de l'impression programmée dans traitement de fermeture de l'état.
Le lancement de cet état "spécial" avec la commande "iImprimeEtat" permettra d'avoir un aperçu contenant une impression programmée, et les possibilités d'exportation.

Pacte écologique / Etre un bon citoyen sans faire de politque...

2006-12-04T21:00:00.000+01:00

Je ne profite d'aucune ressource de façon abusive (chômage, RMI, allocations...). Tous mes revenus sont déclarés, et j'estime mérités, car je ne profite pas de l'argent d'autres contribuables.

C'est ma façon d'être un "bon citoyen".

Je ne fais pas de politique : gauche ou droite au pouvoir ne change rien à mon quotidien. L'un comme l'autre au travers de leurs représentants n'ont qu'un objectif, la présidence en 2007, le reste n'a que peu d'importance. Même armé de très bonnes intentions le meilleur des candidats ne pourra pas mettre les fainéants au travail, soigner les malades imaginaires ou mettre au pas ceux qui n'ont aucune règle.

Cela ne m'empêche pas d'être optimiste pour l'avenir, car je ne suis pas le seul à rester animé des saines valeurs héritées du travail des générations précédentes. Aussi, j'ai signé le "Pacte écologique", qui j'en suis sûr rencontrera un vif succès, et permettra de montrer que finalement, tout le monde ne se fout pas de tout.

Vous pouvez signer le "Pacte écologique", et peut être plus encore, ajouter quelques gestes quotidiens supplémentaires en faveur de l'environnement. Par exemple si vous faites plus de 20 minutes de bouchon le matin, demandez-vous si le vélo n'est pas plus rapide au final (tout en permettant au passage de profiter pleinement des friandises de noël sans crainte pour votre ligne).

Inhiber une action standard sur un événement (clavier, souris...)

2006-11-28T00:20:00.000+01:00

Windows apporte pour tous les champs des comportements standard pour lesquels aucune programation n'est requise, et c'est tant mieux par ce que je ne programmerai pas tout ça tous les jours !

Mais comme il est toujours bon d'en vouloir plus, on peut dans certain cas ne pas vouloir du comportement standard sur une action bien précise.

Par exemple, on pourrait décider qu'un champ ascenseur ne doit pas réagir à la roulette de la souris. Il suffit pour y parvenir d'ajouter le traitement optionnel "roulette souris", puis de faire renvoyer la valeur "0" à l'événement Windows correspondant (cf. montage écran).

En effet, le traitement optionnel est appelé lorsque Windows fait l'envoi de l'événement au champ, et avant même que Windows n'ait effectué son action standard. De ce fait on peut très bien exécuter un code avant l'action standard de Windows, et aller jusqu'à l'inhiber comme dans ces exemples.

Cela est également valable avec la fonction "Evénement" du WLangage qui fonctionne suivant le même principe.

Imprimer directement depuis un aperçu...

2006-11-27T12:30:00.000+01:00

La fenêtre d'aperçu propose lors de l'impression de choisir le nombre de pages à imprimer, ainsi que le nombre de copies. D'un point de vue ergonomique, cela peut ne pas convenir à certains usages, voici la méthode pour ne pas avoir de confirmation et imprimer directement :

Aperçu personnalisé :
Il faut tout d'abord copier dans le répertoire du projet la fenêtre de l'aperçu, c'est une fenêtre WINDEV dans le répertoire des exemples. Ouvrir ensuite cette fenêtre dans le projet, afin de l'enregistrer dans les éléments du projet. Par le menu "Projet / Description du projet" et le volet "Style", il faut donner cette fenêtre comme fenêtre d'aperçu. A ce stade, il est possible de personnaliser la fenêtre utilisée lors de l'aperçu depuis l'application.

Modification de l'aperçu :
Ouvrir la description du bouton "Imprimer", et simplement changer son nom en "ImprimerTout". Au prochaine aperçu, ce bouton lancera directement l'impression !

Big Brother dans les applications ...

2006-11-23T22:30:00.000+01:00

Dans un site en exploitation avec des données en perpétuelle mouvements, il n'est pas rare de rencontrer deux utilisateurs se disputant la propriété ... d'une erreur de manipulation.

- C'est toi il y a une semaine qui m'a dit de rentrer la nouvelle adresse.
- Oui mais ensuite je l'ai changée à nouveau, tu n'aurais pas du l'écraser !
- Non je ne l'ai pas changée à nouveau, c'est toi qui a oublié de la changer ...

Au final le conflit est stoppé en se tournant vers l'informaticien en charge du programme :

- [en coeur] : on vient te voir car l'application a encore perdu une adresse.

Ca sent le vécu pour beaucoup j'en suis certain. Un remède très efficace existe, c'est la journalisation. Cerise sur le gâteau, son activation se fait par une case à cocher dans la description des fichiers de l'analyse, aucune programmation n'est requise. La journalisation des écritures est suffisante pour régler tout litige tel que décrit ci-dessus.

Lorsque la journalisation est active, le menu contextuel des champs reliés aux rubriques de fichiers dispose d'une option "Historique..." qui permet de connaître toutes les valeurs successivement prises par la rubrique avec :
- la date de l'heure de modification,
- la valeur,
- le poste depuis lequel le changement a été fait,
- le login de l'utilisateur qui a fait le changement.

Toutes ces informations peuvent également être proposées par une interface spécifique de l'application, avec la fonction "HHistoriqueModification" qui retourne, entre autre, toutes ces informations sur les modifications.

Plus de doute sur qui a fait quoi !

Autre intérêt, la journalisation permet après une restauration de données de rajouter à la sauvegarde les dernières modifications.

Deux recommandations pour l'utilisation de la journalisation :
- utiliser dans le programme la fonction "HPoste" pour renseigner le journal précisément sur l'auteur des changements,
- placer les journaux sur un autre disque que celui contenant les données, avec la fonction "HChangeRepJNL".

Mémorisation de la position des colonnes de table inopérante ?

2006-11-22T22:45:00.000+01:00

Option à ne pas oublier dans la description des tables : mémoriser la position des colonnes. Elle permet sans ajouter de code, de proposer à l'utilisateur final de toujours retrouver les colonnes comme il les a lui-même positionnées.

Seulement il peut arriver que cette mémorisation soit inefficace sur une table donnée, sans raison apparente. Il y a bien sûr une explication : la propriété "..MenuContextuel". En effet, l'affectation de la propriété "..MenuContextuel" d'une table, inhibe la restauration de ses paramètres mémorisés. Ceci dans le but de ne pas avoir de colonne invisible, qui ne pourrait pas être restaurée. Mais encore faut-il le savoir, je n'ai pas trouvé l'information dans la documentation. Je l'ai obtenue du support après avoir cherché un long moment pourquoi dans une même fenêtre une première table avait ses colonnes bien remises en place, mais pas une seconde.

Peut-être qu'une prochaine version de WINDEV pourra afficher des informations aux développeurs pour les informer lors de l'utilisation d'une propriété de ce type des effets engendrés sur d'autres fonctions.

Fichier en cours d'utilisation ... mais par qui ?

2006-11-17T12:15:00.000+01:00

Un fichier de données reste parfois ouvert, alors que l'on est persuadé qu'il n'est plus utilisé, et que tous les programmes l'utilisant sont arrêtés...

Fichier en cours d'utilisation sur un autre poste ...
Le fichier est utilisé par un autre processus ...

Un utilitaire pouvant se substituer au gestionnaire de tâches est très commode, car il permet de connaître les processus qui utilisent un fichier. Il s'agit de Process Explorer, à toujours garder dans ses outils de travail. Anecdote, l'éditeur d'origine est Sysinternal, mais il semble qu'il y ait eu récemment une absorption de Microsoft. En effet, l'adresse http://www.sysinternals.com est directement redirigée sur un site Microsoft !

Bref, le menu "Find / Find handle or DLL" permet de donner le chemin d'accès au fichier de données en cours d'utilisation ... qui ne devrait pas l'être. La recherche vous donne ensuite la liste de tous les processus utilisant ce fichier.

Au passage, deux "pièges" pouvant aboutit à laisser un fichier de données ouvert ...
- fichier Hyper File, appeler la fonction "HFerme", mais oublier les "HAnnuleDéclaration" sur les requêtes exécutées sur ce même fichier,
- fichier externe : appeler "fCrée" et "fOuvre", et ne faire qu'un seul "fFerme". Pour éviter tout risque d'erreur, préférer "fOuvre" seule, mais avec le paramètre "foCréation".

Une image (celle du site Microsoft) de l'utilitaire complet, tel qu'il apparaît si vous le substituez au gestionnaire de tâches :

Importer un fichier texte dans un fichier Hyper File en formatant des dates

2006-11-15T19:45:00.000+01:00

L'importation d'un fichier texte dans un fichier Hyper File est facilitée par la commande "HImporteTexte". Dans le cas favorable, l'importation est donc extrêmement simple grâce à cette fonction. Bien évidemment, suivant l'origine des données à importer, on se trouve en dehors du "cas favorable", il suffit par exemple qu'une date n'ait pas le format "AAAAMMJJ" attendu.

Dans ce cas, il faut avoir recours à une bonne vieille moulinette, facilitée par l'instruction POUR TOUT.

L'exemple ci-dessous utilise une demande du forum, ce sujet revenant assez régulièrement d'ou l'idée de ce billet. Il faut souligner qu'il s'applique aux dates, mais également à tout ce qui peut nécessiter une conversion avant la mise en base.

Soit un fichier texte à importer avec le contenu suivant (une tabulation sépare les colonnes, un retour chariot sépare les lignes ) :

15/03/2002 abc imo 560,33
19/04/2003 klo hap 561,00
12/06/2001 dol pme 7840,00

Si la date dans le fichier texte avait été codée sous la forme "20020315" la fonction "HImporteTexte" aurait fait l'affaire. Mais avec ce codage de date, il faut mouliner (une fois de plus ?). Voici un exemple de code pouvant être utilisé :

sEnregistrementsAImporter est une chaîne
sNouvelEnreg est une chaîne
sDateNonformatée est une chaîne

sEnregistrementsAImporter = fChargeTexte("C:\MonFichier.txt")

POUR TOUTE CHAINE sNouvelEnreg DE sEnregistrementsAImporter SEPAREE PAR RC

sDateNonformatée = ExtraitChaîne(sNouvelEnreg, 1, TAB)
Fichier.Date = ChaîneVersDate(sDateNonformatée, "JJ/MM/AAAA")
Fichier.Personne = ExtraitChaîne(sNouvelEnreg, 2, TAB)
Fichier.Libellé = ExtraitChaîne(sNouvelEnreg, 3, TAB)
Fichier.Montant = ExtraitChaîne(sNouvelEnreg, 4, TAB)

HAjoute(Fichier)
FIN

Une bonne évolution de la fonction "HImporteTexte", serait de pouvoir donner dans les délimiteurs un format de date comme le prend la fonction "ChaîneVersDate". Le champ d'action de "HImporteTexte" serait grandement étendu. J'en ai fait la suggestion au support.

Une option de menu contextuel en gras

2006-11-14T12:26:00.000+01:00

Une astuce permet de passer une unique option d'un menu contextuel, ayant le look XP, en gras.

Il suffit d'intervenir sur le libellé, et de l'encadrer avec les balises HTML de mise en gras, l'image ci-contre met en évidence ce procédé.

Cela permet par exemple de mettre en évidence l'option la plus couramment utilisée, un "petit plus" dans une interface !

Bêta Blogger avant WINDEV 11, pour une leçon d'ergonomie !

2006-11-10T23:55:00.000+01:00

En attendant de pouvoir m'initier aux nouveautés de WINDEV 11, je découvre la bêta version des Blogs façon Google. Un sacré chamboulement puisqu'en terme de fonctionnalités, visibles tout autour de ce billet, il est maintenant possible :
- d'ajouter des flux RSS,
- de regrouper les billets par sujets,
- d'avoir une arborescence des archives ...

Mais surtout, et là chapeau, surtout il est possible d'obtenir tout cela sans aucune programmation Web, dans un environnement totalement dynamique. Un simple glisser/déplacer d'un élémement dans la page permet de disposer les différentes zones du blog. Un modèle d'ergonomie.

J'encourage tous ceux qui le peuvent à prendre quelques minutes pour créer un blog de test, juste pour découvrir la simplicité avec laquelle toutes les possibilités du blog sont proposées. Les développeurs se sont réellement creusés pour parvenir à un tel résultat, c'est un très bel exemple de respect de l'utlisateur.

Stockage des images, optimisation de l'espace en changeant le format...

2006-11-10T17:00:00.000+01:00

Une rubrique mémo image est généralement affectée par une commande de la forme Fichier.RubriqueImage = ChampImage, ou "EcranVersFichier".

Cette affectation copie fidèlement l'image contenue dans le champ, au format BMP.

En fonction du contenu de l'image, un enregistrement en JPEG est souvent suffisant en qualité, et permet de diviser la taille de l'image par un facture important. Il suffit pour cela d'affecter la rubrique avec un appel de la fonction "dSauveimageJPEG" :

Fichier.RubriqueImage = dSauveImageJPEG(ChampImage, enMémoire)

Petite astuce bien utile s'il faut gagner un peu de place, surtout si l'application doit à un moment donné transférer ces images.

Présentation par défaut de l'interface d'une application déployée

2006-11-09T00:21:00.000+01:00

L'utilisateur final d'une application peut configurer la présentation de son application :
- position et taille des fenêtres,
- largeur des colonnes des tables,
- mémorisation de valeurs pour les champs...

Comme il est courant pour tout le monde de changer d'avis, il est souhaitable de lui proposer une option de l'application permettant de revenir à l'état initial pour toutes les informations mémorisées. Il peut s'agit d'un menu "Paramètres / Rétablir l'affichage par défaut". Cette option devra simplement faire la suppression dans la base de registres de la clé retournée par la fonction "ProjetInfo(piRegistre)".

Pour aller plus loin sur ce mécanisme, il est également possible de remplacer la sauvegarde faite dans la base de registres, par une sauvegarde dans un fichier XML. Cette possibilité est donnée par la fonction "InitParamètre". L'avantage est alors de pouvoir facilement "transporter" les paramètres sauvegardés d'un poste à un autre. Il est même envisageable de conserver le fichier XML dans un fichier de la base de données, afin de le restituer automatiquement au lancement de l'application en fonction de l'utilisateur qui se connecte !

Loupe de recherche des colonnes des tables

2006-11-08T13:28:00.000+01:00

Voici une "checklist" à appliquer lorsque la loupe d'une colonne de table fichier n'apparaît pas lors de l'exécution.

- la coche "Avec recherche (loupe)" doit être active dans la description de la colonne, tout comme la coche "Triable" (volet "Général"),

- la rubrique du fichier associé à la colonne (volet "Liaison") doit être une clé dans le fichier (unique ou doublon peut importe),

- le remplissage de la table doit se faire sans programmation. Il s'agit du sélecteur "Parcours automatique" dans la description de la table (volet "Contenu"),

- l'option "Ascenseur proportionnel" doit également être cochée toujours dans la description de la table (volet "Détail").

Toutes ces conditions doivent être réunies dans le cas d'une table directement reliée à un fichier. Si la table est reliée à une requête, la nécessité de clé dans le fichier de données disparaît.

Accélérateur de traitement ...

2006-11-03T13:15:00.000+01:00

Avec son nom tout à fait anodin, la propriété "..AffichageActif" peut accélérer de façon considérables des traitements. En effet, vous pouvez l'observer avec l'analyseur de performances, les accès à l'interface sont coûteux temps. Par exemple un parcours de données avec des "TableAjoute" dans une table mémoire (champ d'affichage) sera plus long qu'un même parcours chargeant une variable tableau (fonction "TableauAjoute"). Là peut intervenir avantageusement la propriété, en inhibant provisoirement l'affichage. Exemple :

NomFenêtre..AffichageActif = Faux
TraitementXYZ()
NomFenêtre..AffichageActif = Vrai

Simple, mais redoutable d'efficacité dans bien des cas de figure !

Etat imprimé à tout faire (zone répétée, variable tableau...)

2006-11-02T13:26:00.000+01:00

Par défaut l'assistant de création des états permet de sélectionner des données dans les fichiers de l'analyse, une requête, un champ table...

Il existe une méthode d'impression "passe partout" car elle permet d'imprimer tout aussi facilement tout et n'importe quoi. L'idée de ce billet m'est venue en voyant le forum, pour l'impression des données d'une zone répétée.

Il suffit dans l'assistant de création d'état d'indiquer "Je programme la lecture de ma source de données", puis de créer dans l'état des champs avec les types et masques désirés. C'est le code de l'état et du bloc corps que se chargeront du parcours des données, la programmation est minime :

// code d'ouverture de l'état
// Déclaration d'une globale pour parcourir les répétitions
// ou pourquoi pas les éléments d'une variable tableau...
gnIndice est un entier = 1

// Code de lecture des données de l'état
// Termine l'impression si toutes les répétitions ont été vues
SI gnIndice > ZoneRépétéeOccurrence(FEN_FenetreAppelante.ZR_ZoneRépétée1) ALORS
RENVOYER Faux
SINON
RENVOYER Vrai
FIN

// Code avant impression du bloc corps
// Affectation des champs de l'état avec les attributs
// de la zone qui permettent d'avoir les valeurs
RUB_RUBRIQUE1 = FEN_FenetreAppelant.ZR_ZoneRépétée1.ATT_Attribut1[gnIndice]
RUB_RUBRIQUE2 = FEN_FenetreAppelant.ZR_ZoneRépétée1.ATT_Attribut2[gnIndice]
RUB_RUBRIQUE3 = FEN_FenetreAppelant.ZR_ZoneRépétée1.ATT_Attribut3[gnIndice]
...
// Incrémentation du compteur pour passer à la prochaine répétition.
gnIndice++

Cette méthode peut être étendue à tout ce qui peut se parcourir, dans l'exemple on lit les répétitions d'une zone répétée, mais il peut s'agit d'un tableau, d'une zone mémoire, un fichier texte...

Représentation binaire d'une valeur.

2006-11-02T12:09:00.000+01:00

A toute fin utile, voici un traitement proposé en réponse sur le forum pour obtenir la représentation binaire d'une valeur. La fonction de conversion inverse est donnée également.

FONCTION VersBinaire(nValeurDecimal)

sBinaire est une chaîne = ""
nb est un entier = nValeurDecimal

TANTQUE nb > 0
SI modulo(nb,2) ALORS
sBinaire = "1" + sBinaire
SINON
sBinaire = "0" + sBinaire
FIN
nb = nb/2
FIN
RENVOYER sBinaire

Et la récupération d'une valeur exprimée en décimal, à partir de sa représentation binaire :

FONCTION DepuisBinaire(schaineBinaire)

sBinaire est une chaîne = schaineBinaire
i est un entier
j est un entier
nDecimal est un entier
nCalcul est un entier

POUR i = Taille (sBinaire) A 1 PAS -1
nCalcul = 2*Val (sBinaire[[i A i]])
SI nCalcul ALORS
nDecimal += Puissance (nCalcul,j)
FIN
j++
FIN

RENVOYER nDecimal

Comment suis-je devenu définitivement accro des outils PC SOFT (partie 1) ?

2006-10-25T00:15:00.000+02:00

J'ai découvert le savoir faire PC SOFT en 1994 avec le trio Hyper Screen, Hyper File et Hyper Screen. Travaillant sur la réalisation d'un tableau de bord(1) pour une chaîne de grande distribution, fraîchement diplômé de l'université de Grenoble, je n'avais jamais fait autre chose que des programmes noirs, avec des interfaces en mode texte. Et là, je faisais des programmes en couleurs, gérant la souris, le défilement de données avec des ascenseurs, l'ouverture de fenêtres les unes par-dessus les autres ... le tout depuis un QBasic sous DOS 6.2 et sa compilation en ligne de commande. Le principe(2) était des plus simple, les 3 produits PC SOFT ajoutaient en quelque sorte des commandes au QBasic, commandes pour gérer l'interface, les données et les éditions. Le résultat était sidérant, avec très peu de commandes le programme était d'une efficacité redoutable, aussi conviviale qu'une application sous Windows 3.1 de l'époque, les problèmes de pilotes en moins !

Sorti de la tristesse des interfaces texte du DOS grâce à Hyper Screen, je me suis tout naturellement mis à la programmation sous Windows. J'ai compulsé de nombreuses heures le Petzold, et, je ne pouvais pas choisir mes outils à cette époque, j'ai fait mes premières fenêtres sous Visual C++ 1.5. Avec la première mouture des MFC (Microsof Foundation Classes), je pensais que la gestion de l'interface et des données serait aussi simple qu'avec Hyper Screen et Hyper File sous DOS. C'était une erreur, je me suis retrouvé avec des compilations infernales et interminables, des classes dans tous les sens, loin très loin de la simplicité de mes précédents développements. Heureusement, mon employeur a changé son fusil d'épaule avec l'arrivée de WINDEV 1.5, et depuis, avec des contextes professionnels différents, je travaille avec les outils PC SOFT. Ca fait donc plus de 12 ans !

Avec WINDEV 1.5 j'ai pu faire mes premières applications Windows en quelques clics, comme on peut le faire aujourd'hui. Le principe est en effet resté le même, on dessine la fenêtre en y plaçant les champs et boutons. On clic sur Go pour tester, sur l'engrenage pour créer l'exécutable à diffuser. J'ai ainsi enchaîné mes créations avec la version 1.5, puis les versions 2, 4 et enfin 5.5 qui a permis le passage en 32 bits. Passage douloureux pour bon nombre de mes collègues qui devaient se soucier de la portée de leurs pointeurs, de la taille de leurs variables entières (...), aisé pour moi qui devait uniquement cocher un sélecteur à la création de l'exécutable (juste les appels des API à adapter). PC SOFT avait tout prévu, comme sous Hyper Screen, et Hyper File qui restait le même avec déjà son système de modification automatique des fichiers de données.

La suite au prochain épisode ...

(1) Tableau de bord : vous comprenez mon billet relatif au tableau de bord des versions 11, j'ai fréquemment travaillé de tout temps sur la présentation des données, et l'aperçu du tableau de bord de suivi des projets est de très bonne augure pour WINDEV 11 !

(2) Cette technique de programmation reste disponible en version 10, elle est illustrée pas des exemples du dossier \Langages Externes\. En C, C#, Basic, Cobol, Fortran on ajoute des "includes" qui donnent accès à Hyper File, Wlangage et aux éléments d'une bibliothèque (.WDL).

Section critique à la bonne place, avec le bon nom...

2006-10-20T12:38:00.000+02:00

Dans un programme utilisant plusieurs thread (messagerie instantanée avec Socket, traitements batch...), il peut arriver après un certain temps d'utilisation un blocage (pas de réponse...), ou une disparition pure et simple de la liste des processus, ou un message du mécanisme de sécurité WLangage :

Une erreur système inattendue est survenue.
Module : WD100VM.DLL
Erreur système : Access violation (GPF)
EIP = 12345678

C'est une difficulté sérieuse, car il n'y a en général aucune reproduction systématique, et le traitement donné dans la pile de l'erreur change d'une exécution à l'autre. La piste de recherche à privilégier dans pareil cas, se nomme "section critique". En effet, dès que plusieurs threads s'exécutent en parallèle, ils vont nécessairement à un moment ou à un autre accéder à des éléments partagés. Typiquement, une variable globale du projet, un membre de classe utilisé dans une méthode exécutée par un thread secondaire, et une autre partie de la classe sollicitée dans le thread principal ... les combinaisons sont infinies.

Il faut donc en tout premier lieu en cas d'instabilité vérifier que tous les éléments (variables, membres...) qui sont utilisés par deux thread distincts sont dans une section critique. Sans cela, l'erreur ou le blocage "aléatoire" est quasiment garanti à un moment ou à un autre dans le déroulement de l'application, et le plus souvent après un important nombre d'heures d'utilisation.

A titre d'exemple, si une variable globale du projet est affectée dans un thread secondaire, le code devra être de la forme suivante :

Et bien sûr, la consultation de cette variable dans le thread principal devra se faire avec la même section critique (attention à ne pas faire une faute de frappe dans le nom de la section) :

Ce billet est motivé par plusieurs instabilités aléatoires résolues en ajoutant les bonnes sections critiques. La dernière en date, hier, provenait d'une faute de frappe avec un nom de section critique erroné lors de l'affectation d'un membre !

Demander de l'aide au Framework DotNet ...

2006-10-17T23:38:00.000+02:00

Dans le meilleur des mondes, le développeur aurait dans son environnement de développement toutes les fonctions possibles et imaginables créées depuis l'origine de la micro-informatique. Le temps passé à "réinventer la roue" serait enfin réduit à un minimum acceptable. Bien évidemment, ce meilleur des mondes n'est qu'utopie, et c'est tant mieux car le quotidien du développeur deviendrait bien monotone s'il n'était plus nécessaire de se creuser la tête de temps à autre !

Dans la pratique donc, il n'est donc pas rare d'avoir une fonction manquante, nécessitant dans le pire des cas un recodage. Mais c'est un cas extrême avec WINDEV car deux Framework sont à la disposition du développeur.

On pense immédiatement au Framework PC SOFT inclus avec toutes les applications. Il contient à lui seul des centaines de fonctions, des propriétés, l'accès moteur Hyper File, aux bases de données via OLE DB ...

Mais il ne faut pas omettre le Framework .NET directement accessible également. Il apporte de nombreuses possibilités supplémentaires.

Une illustration, obtenir du système un identifiant unique, plus communément appelé GUID (cf. ci-contre). La fonction "iDonneIdentifiant" du WLangage ne convient pas si l'on désire un identifiant unique au niveau du poste, elle ne convient que pour une instance de l'application.

La classe GUID de MSCORLIB inclus en standard dans .NET donne l'information. Il devient alors très facile d'avoir l'information en quelques clics. Le menu "Atelier" donne la possibilité d'ajouter dans le projet les classes de MSCORLIB. Il suffit ensuite de déclarer un objet "GUID" pour obtenir l'information attendue.

L'éditeur de code propose une complétion automatique pour les classes .NET intégrées, cela facile leur utilisation.

Notez qu'en utilisant le Framework .NET dans votre application sa présence sur l'installation cliente sera indispensable. Il faut donc vérifier avant tout le déploiement du Framework .NET sur les postes cibles. Normalement il est fait du moment que Windows update est actif.

Synthèse de l'information, par Google et WINDEV 11 !

2006-10-13T12:15:00.000+02:00

C'est chose faite, la version 11 de WINDEV est annoncée. En même temps Google propose une nouvelle version de Blogger. Moi qui adore les découvertes, je suis comblé !

Je suis régulièrement amené ces derniers temps à travailler sur la présentation des données dans des applications existantes. Les tableaux statistiques d'époque ou autre ne conviennent plus à l'utilisateur final, qui veut en un clin d'oeil avoir accès à toute l'information. C'est par exemple une des clés du succès des portails Web qui savent proposer un accueil regroupant les éléments dont a besoin l'Internaute.

Cette "tendance" ressort des nouveautés, puisque Google, et WINDEV 11 propose une notion de "tableau de bord" (dashboard en anglais dans le texte). L'interface du futur Windows Vista est également orientée vers une présentation réellement pensée pour l'utilisateur, et non plus pour le "bidouilleur", ou le connaisseur.

Gageons qu'avec de telles sources d'inspiration, les applications vont prendre un sacré "coup de jeune" en terme d'interface, et d'ergonomie. Alors synthèse de l'information dans nous outils de travail, mais également dans nos productions pour rendre l'outil informatique plus accessible en pensant toujours à ce dont à réellement besoin l'utilisateur final !

On en apprend tous les jours ...

2006-10-12T19:35:00.000+02:00

Le développement est un domaine si vaste, qu'il ne se passe pas une journée sans faire de découverte. Ma nouveauté du jour, est la fonction "ChaineRécupère" ! J'ai de tout temps utilisé la fonction "Transfert" qui n'est plus nécessaire maintenant. J'étais passé à côté de cette fonction, je ne sais pas dire dans quelle version de WINDEV elle est apparue.

Un fil du forum décrit l'aspect technique de cette commande.

Moralité, n'oubliez pas de relire régulièrement les documentations diverses, on ne sait jamais tout. Et puis il vient un stade ou l'on en apprend tous les jours, mais on en oublie également.

Poser la bonne question !

2006-10-11T22:18:00.000+02:00

Le dialogue instauré entre une application et ses utilisateurs est primordiale. Même avec des modes opératoires parfaitement définis, si l'application propose un choix ambigu l'utilisateur risque une fausse manipulation. Il aura de plus un ressenti négatif envers l'application, la trouvant difficile à utiliser.

Il paraît donc évident que toutes les applications devraient avoir des dialogues peaufinés. Cependant la réalité est différente, car historiquement le développeur disposait pour solliciter l'utilisateur de la fameuse "MessageBox" Windows, accessible en Wlangage au travers des fonctions "OuiNon", "Confirmez" avec les traditionnels boutons Oui, Non, Annuler. Difficile de proposer un dialogue efficace à partir de ce jeu d'instructions, sans passer un temps important dans la création de fenêtres spécifiques.

Pour trouver un juste équilibre entre des messages conviviaux à la réponse facile, sans rallonge de planning, le Wlangage propose une fonction "Dialogue", dotée d'un assistant de mise en œuvre, que je recommande de rendre obligatoire dans toutes vos règles ou chartes de programmation !

En effet, cette fonction permet de trouver le juste équilibre pour que le développeur en un minimum de temps puisse créer une interface de dialogue agréable, et surtout complète.

Voici une illustration, avec une action courante, l'envoi d'un email. Dans le cas ou l'utilisateur final ne renseigne pas le sujet de son message, on va l'en informer. La méthode originale "OuiNon" pouvait donner le type de message ci-contre. Oui, il est un peu caricatural, mais je vous assure l'avoir trouvé dans des applications.

L'utilisation de la fonction "Dialogue" permet d'éviter pareil "désagrément", car elle va permettre au développeur de bien poser la question, tout en proposant des boutons de réponses en texte clair. Notez que l'internationalisation est prise en charge par la fonction "Dialogue". Cette vue de l'assistant se passe quasiment de commentaire. Au centre le message, à droite on gère la présence des boutons, en bas leurs caractéristiques, à gauche l'icone système à afficher...

L'assistant va plus loin, le code de traitement du choix de l'utilisateur est immédiatement généré. Il ne reste plus qu'à insérer l'appel de vos procédures.

Un principe similaire pour un dialogue de saisie est proposé grâce à la fonction "Saisie". Ci-dessous, son illustration extraite de l'aide de WINDEV.

Astuce, n'oubliez pas les minuteries. Il est rare de bloquer une application sur un dialogue, il peut être utile de forcer sa validation sans réponse de l'utilisateur après un certain laps de temps. C'est la fonction "DélaiAvantFermeture" qui appelée avant "Dialogue" vous permet d'ajouter une minuterie sur le bouton qui valide le dialogue.

Piloter la sauvegarde d'une base de données Hyper File Client/Serveur

2006-10-10T13:31:00.000+02:00

Voici un code prêt à l'emploi qui m'a donné du fil à retordre, car l'aide en ligne de la commande était erronée ! En effet, il y avait une coquille sur le paramètre permettant de donner le mot de passe. Le bon paramètre est /MDP_DB et non pas /MDP_BD.

Vous pouvez copier directement le code sur le fil correspondant dans le forum

Hyper File, Hyper File Client/Serveur, MYSQL, Oracle, SQL SERVER...

2006-10-09T08:33:00.000+02:00

Une demande très courante des développeurs, et de pouvoir changer ou alterner la base de données utilisée par l'application. Utiliser une base Hyper File en mode partage (dit "classique"), ou en mode Client/Serveur suivant le site, ou une base MYSQL...

La solution est très simple, mais de part notre naturel à toujours chercher compliqué, les méthodes employées sont souvent les moins efficaces. Pourtant, avec seulement deux commandes, le W-Langage permet de facilement jongler d'une base de données à l'autre, sans intervenir sur la description des tables dans l'analyse. En effet, le type de base de données indiqué dans l'analyse est indicatif, il est utilisé uniquement par défaut sans mention contraire dans vos traitements. Ainsi dans votre code vous pouvez à tout moment appeler :
- "HOuvreConnexion" : elle permet d'ouvrir une connexion vers une base quelconque, du moment que vous avez une accès natif, ou un provider OLE DB.
- "HChangeConnexion" : elle permet d'associer une ou plusieurs tables de l'analyse, à une connexion qui vient d'être ouverte.
Ainsi une application simplement en redéfinissant la connexion peut changer la base utilisée. Un extrait de code est proposé dans une FAQ PC SOFT.

Attention, il s'agit là du principe de connexion. Bien entendu, le simple faire de changer de base peut ne pas suffire, car chaque base a ses propres spécificités d'utilisation. Si la base Hyper File est en mode Client/Serveur, il faudra privilégier les requêtes pour en tirer les meilleures performances. Mais cela dans un but d'optimisation. Dans tous les cas ou le volume de données traité reste raisonnable, il n'est pas indispensable d'avoir un travail d'optimisation intensif, il est ainsi possible de jongler facilement d'une base à une autre juste avec les commandes "HOuvreConnexion"et "HChangeConnexion".

Ce principe de connexion peut également être utilisé pour effectuer un transfert de données lorqu'il s'agit de bases de données différentes. La notion d'alias vient en renfort, et va permettre d'avoir un unique fichier de l'analyse, accessible en deux exemplaires dans deux connexions différentes. Le traitement peut alors être de la forme suivante :
- "HOuvreConnexion" pour vous connecter à une base quelconque,
- "HAlias" pour avoir une copie du fichier,
- "HChangeConnexion" pour que l'alias travail sur la base sur laquelle la
connexion a été ouverte,
- "POUR TOUT" pour parcourir les enregistrements du fichier source,
- "HCopieEnreg" et "HAjoute" pour copier les enregistrements.
Il est même envisageable de traiter une analyse complète, et plaçant le tout
dans parcours de la liste des fichiers (fonction "HListeFichier").
Il existe également des outils permettant d'effectuer des transferts de données.

Echanger des sources et techniques avec Google ?

2006-10-06T00:36:00.000+02:00

L'actualité Google est toujours chargée ces dernières années, elle concerne aujourd'hui tous les développeurs adeptes du partage de sources, et qui ne souhaitent plus réinventer en permanence la roue !

Un nouveau portail "codesearch" a donc vu le jour, et permet d'effectuer des recherches dans les codes sources recensés par Google. Et en matière de recensement, Google sait y faire !

Limiter les ressources sollicitées par les impressions.

2006-10-05T12:34:00.000+02:00

Je l'ai évoqué dans un précédent billet, s'il y a bien un domaine dans lequel il faut s'appliquer à ne pas trop solliciter le système, c'est bien celui de l'impression. En effet, si pour l'utilisateur le fait d'imprimer une action anodine, pour le système ce n'est pas rien, il va abondamment solliciter les pilotes de périphériques, les ressources graphiques...

Voici quelques astuces qui vous permettront je l'espère d'augmenter la réussite de vos impressions, essentiellement sur les configurations les plus faiblement dotées (hard et soft).

1. réinitialiser le mécanisme d'impression avant chaque nouvelle impression, avec un appel de la fonction "iRAZ".

2. éviter les images volumineuses en fond de page par exemple en utilisant une image enregistrée pour le Web.

3. sélectionner dans la confi- guration des états, l'option d'impres- sion à chaque page.

4. ralentir l'impression avec la fonction "Multitache" dans le code après impression du bas de page. L'attente doit varier en fonction de la configuration, elle peut être mémorisée dans la base de registres. Un menu "Configuration" de l'application pourra permettre son réglage d'un poste à un autre.

Créer une fenêtre, à partir d'une application existante

2006-10-03T23:19:00.000+02:00

Il peut arriver de trouver une fenêtre dans une application existante, avec une interface novatrice ou non, mais en tout cas interessante. Pour réaliser la même dans votre application, une première alternative consiste à recréer champs par champs les éléments de la fenêtre qui aide votre inspiration (notez que je ne parle jamais de copie...).

Mais il y a bien mieux, dans l'assistant de création d'une nouvelle fenêtre. Le volet "Import" vous liste les applications lancées, et vous permet d'en choisir une. A la validation, vous obtiendrez sous WINDEV une fenêtre dont vous pourrez coder les traitements, reprenant tout ou partie de l'interface de l'application existante.

Mise en forme RTF programmée

2006-10-03T12:35:00.000+02:00

Voici une méthode que j'utilise couramment pour mettre en forme un texte RTF. Elle permet de créer un "modèle" en RTF, puis de l'utiliser dans un traitement pour une mise en base, ou un affichage.

Première étape, sous Wordpad, préparer le texte avec la mise en forme. Dans le texte, placer des %1, %2 en lieu et place des données effectives, en effectuant toute la mise en forme désirée.

Seconde étape, récupérer à l'aide du bloc note le code RTF avec sa mise en forme, afin de le placer dans une constante du projet. Dans le cas ou la mise en forme doit évoluer régulièrement, il peut être avantageux de récupérer la mise en forme au lancement de l'application, avec la fonction "fChargeTexte".

La technique est en place, pour obtenir l'information avec sa mise en forme dans l'application, il suffira d'affecter un champ RTF, un libellé RTF, ou une rubrique de fichier avec la fonction "ChaineConstruit". Exemple :
LIB_RTF = ChaineConstruit(RTF_RAPPORT, RéseauUtilisateur(), DateVersChaine(DateSys()), sRapport)

Ce texte mise en forme peut également compléter un texte existant, en utilisant la fonction "RTFInsére".

Les possibilités d'un service Web ... sans Web service

2006-10-02T21:34:00.000+02:00

L'utilisation d'un Web service peut être commode dans bien des situations pour interroger depuis une application un système distant qui va vous retourner une information : une clé pour l'installation de l'application, l'état d'un processus distant ...

Vous pouvez avec WINDEV créer un Web service, qui sera configuré sur le serveur Web avec l'extension standard SOAP. Cela reviendra à accéder à une bibliothèque (.WDL) regroupant vos traitements, en "traversant" le serveur Web. Vous pouvez obtenir le détail de ce principe, et de sa configuration, dans l'aide de WINDEV, le schéma de principe ci-contre en est issu. Le site "Soapuser.com" montre les principes de communication qui régissent les services Web. Vous pourrez constater que cela n'est pas simple, pour finalement peu de chose : récupérer le résultat d'un traitement exécuté sur un serveur Web.

Le but de ce billet, est de présenter une alternative à la mise en place d'un Web Service, donnant le même résultat, mais évitant la configuration de l'extension SOAP du serveur Web, et le déploiement des modules WINDEV spécifiques (WD100SIIS.DLL, WD100SAPA.DLL ou WD100SAPA2.DLL). Cette alternative peut être mise en œuvre, à partir du moment ou vous disposez d'une application WEBDEV déployée. Cette application, en un minimum de programmation peut devenir un "Web service". Le principe est le suivant :

Côté site WEBDEV, le code du projet sera piloté via sa ligne de commande. Exemple :

ValeurReçueEnParamètre est une chaine
ValeurReçueEnParamètre = PageParamètre("AFAIRE")

SELON ValeurReçueEnParamètre
CAS : "XYZ"
// On a reçu la tâche XYZ à faire
// comme retourner une clé d'installation
// On appelle une procédure qui retourne le résultat
ChaineAffiche(FonctionXYZ())
// On termine le site la session est terminée
FinProgramme()

AUTRES CAS :
// Aucune action spécifique à faire
// lancement normal du site sur sa page
PageAffiche(<1ière>)
FIN

Côté WINDEV, le code n'est pas plus complexe pour interroger le "Web service" grâce à la fonction "HTTPRequete". Voici un exemple :

HTTPRequete("http://serveur/WD100AWP/WD100AWP.EXE/CONNECT/MONSITE?AFAIRE=XYZ")
Info(HTTPDonneRésultat())

La fonction "HTTPDonneRésultat" va retourner l'information renvoyée par la fonction "FonctionXYZ" du site WEBDEV, par l'intermédiaire de la fonction WLangage "ChaineAffiche". En utilisant différentes valeurs pour le paramètre "AFAIRE" il est possible d'utiliser un même site WEBDEV pour effectuer toutes sortes d'actions, en quelque sorte donc de sous-traiter des traitements. Mais appelé sans paramètre, le site WEBDEV garde sa vocation première.

Voilà comment en 5 fonctions WLangage ajouter des fonctionnalité délocalisées à une application WINDEV, en limitant les étapes de configuration. Il est toujours préférable d'utiliser ce que l'on a déjà, plutôt que d'ajouter une couche de technologie supplémentaire.

Configurations de projet

2006-10-02T12:25:00.000+02:00

Une possibilité de WINDEV peu connue des développeurs, les "configurations de projet". Il s'agit pourtant de la possibilité de préparer à partir d'un unique projet, plusieurs exécutables avec des contenus différenciés. Les configurations de projet permettent également la création de composants (.WDK), de bibliothèques (.WDL), de Web Service ou d'assemblage .NET.

La mise en pratique des configurations de projet est capitale, dès qu'un projet va être diffusé à plusieurs sites ayant des spécificités. Si une partie du projet est commune à tous les sites, mais que certaines fenêtres et états auront des particularités, ou ne servent que sur un site donné, les configurations de projet évitent de créer les exécutables les uns à la suite des autres.
C'est à la création des configurations que le contenu de chaque exécutable est déterminé en fonction des éléments déjà présents dans le projet. Ensuite le menu "Atelier ... Génération multiple" permet en une seule opération de recréer tous les exécutables. J'ai déjà vu des développeurs crées un exécutable en cochant certains éléments du projet à inclure, puis créer un deuxième exécutable avec d'autres éléments, puis créer un troisième exécutable avec encore de nouveaux éléments pour un autre site ...

Les configurations n'étant pas limitées aux exécutables, elles permettent d'aller bien plus loin en générant par exemple :
- l'exécutable de l'application,
- un composant avec des fenêtres internes qui permettront d'intégrer des parties de l'application dans un autre projet,
- un Web service regroupant des procédures de l'application pour les exploiter via des requêtes http...

Une fois les configurations décrites avec tous leurs éléments, elles sont transparentes pour la suite du développement. Il faut simplement lors de l'ajout d'un nouvel élément (état, classe, fenêtre...) préciser la configuration dans laquelle il doit être placé.

Si un traitement ne doit être exécuté que dans le cas d'une configuration précise, il est possible d'utiliser la commande "ProjetInfo" avec le paramètre "piConfiguration". Il est dommage sur cet aspect que le "code cible conditionnel" ne propose pas les configurations, et qu'il soit nécessaire d'utiliser un traditionnel SELON ProjetInfo(iConfiguration) ...

Filigrane / image en fond d'un état

2006-09-28T22:49:00.001+02:00

J'ai vu de nombreux développeurs, et encore un fil de discussion récent sur le forum, batailler pour ajouter dans le fond d'un état une image. Typiquement, une mention "duplicata" en diagonale dans le fond d'un état. Le piège consiste à partir sur la fonctionnalité de "formulaire" que propose l'éditeur d'état, elle est très spécifique. Il faut utiliser la solution "Image de fond" donnée dans la description de l'état (cf image du billet). Cette solution consiste à appeler dans le code avant impression du bloc de haut de page, la commande suivante :
iImprimeImage("Image.jpg", 0, 0, iLargeurPage(), iHauteurPage())

Il n'y a rien d'autre à faire !

Astuce : pensez à optimiser la taille de cette image, car elle sera envoyée au pilote de l'imprimante. Et s'il y a bien un domaine dans lequel il faut éviter d'être trop gourmand en ressources, c'est bien celui de l'impression.

Quiz - connaissez-vous la fonction "HStatCalcule" ?

2006-09-28T16:10:00.000+02:00

Il s'agit probablement d'une des fonctions WLangage les plus méconnue du moteur Hyper File, et pourtant elle est primordiale ! Dernier exemple en date, une requête récupère 350 enregistrements, dans une table en comportant 400 000. Les 350 enregistrements sont rapidement récupérés (fonction "ConstruitTableFichier" pour leur visualisation), pourtant la requête ne rend pas la main et la table reste bloquée avec le sablier. Renseignement pris sur l'application et son activité, il s'avère que d'importants mouvements ont été faits sur ce fichier.

Solution dans pareil cas : appeler la fonction "HStatCalcule", pour obtenir un chargement immédiat et complet des données de la requête.

Voici la description de la fonction donnée dans l'aide :

Ces statistiques sont utilisées lors de la pose d'un filtre, la création d'une requête ou encore la création d'une vue sur le fichier. Le moteur Hyper File analyse la condition de sélection et s'appuie ensuite sur ces statistiques pour déterminer les rubriques les plus discriminantes qui permettront d'optimiser les parcours des fichiers.
Les statistiques permettent d'avoir des informations sur le contenu du fichier au moment de leur calcul. Aussi, plus il y a de modifications du fichier après ce calcul et moins ces statistiques sont fidèles au contenu du fichier. Plus le fichier contient d'enregistrements et moins la modification d'un enregistrement a d'impact sur le reflet du fichier que les statistiques renvoient.

Un autre point important sur le sujet "performances", concerne la densité des index. Un fichier de stockage peut être utilisé pour de l'insertion permanente de données, mais peut avoir peu de consultations. A l'inverse, un fichier peut être consulté en permanence, tout en étant que rarement complété. Et bien en fonction de l'usage du fichier, il peut être bon d'ajuster le "taux de densité" de l'index, afin de favoriser les insertions, ou les consultations. Le taux de densité est modifiable lors de la réindexation des fichiers (WDOptimiseur, ou fonction "HRéindexe").

Exécutables WINDEV et Framework

2006-09-22T22:47:00.000+02:00

Un billet de remerciement pour le support technique PC SOFT, qui a publié de l'information sur la méthode de téléchargement du Framework par les exécutables. La documentation ne va pas aussi loin, et la compréhension d'un mécanisme de ce type permet une bien meilleure utilisation.

En complément, il est bon de préciser que la sélection d'un Framework commun lors de la création d'un exécutable est une possibilité, mais pas une obligation pour l'exécutable. Je reformule, si vous créez un exécutable en demandant l'utilisation d'un Framework commun, cet exécutable utilisera bien le Framework commun mais à la condition qu'il ne trouve pas un Framework dans son propre répertoire.