Académique Documents
Professionnel Documents
Culture Documents
Installation Éditions
Application et
modules
applicatifs
Page XV.1
Construction d'une application
Plusieurs dispositifs peuvent être mis en œuvre, à commencer par la simple écriture de
ces informations dans un fichier externe. Mais deux sont prévus explicitement par les standards
de programmation Windows :
- L'utilisation de fichiers d'initialisation ( d'extension '.ini' ).
- L'inscription de ces informations dans la base de registres du système.
Windows 3.11 a généralisé l'utilisation de fichiers "texte" d'extension ".ini" qui sont des
fichiers de configuration faciles à manipuler.
Le fait qu'un fichier ".ini" soit au format texte facilite sa modification. Il est en
effet possible de l'éditer à l'aide de n'importe quel éditeur de texte afin de
modifier manuellement un paramétrage malencontreux qui empêche le bon
fonctionnement de l'application.
Un fichier ".ini" est composé de sections débutant par un mot clé marqué entre crochet.
Au sein d'une section, chaque ligne ( clé ) correspond à une initialisation.
Page XV.2
Construction d'une application
parametre=valeur d'initialisation
// il n'y a pas d'espace au niveau du '='
Une ligne commençant par un ' ;' est une ligne de commentaire. Elle
n'est donc pas prise en compte par l'application.
Exemple :
[Gallery]
BaseDir=I:\DELPHI\GALLERY
GalleryProjects=1
GalleryForms=1
[Experts]
ExptDemo=I:\DELPHI\BIN\EXPTDEMO.DLL
Il est possible d'accéder aux différents fichiers ".ini" via un ensemble de fonctions du
SDK de Windows. Mais ces fonctions ne sont pas particulièrement aisées à manipuler et
nécessitent la mises en place de tampons et l'utilisation de variables de type pointeur.
Bien entendu, comme on l'a déjà fait en d'autres circonstances, cet objet
n'est pas accessible via l'inspecteur d'objet et tout accès ne peut être réalisé
que par programmation.
Page XV.3
Construction d'une application
Principales méthodes :
Exemple :
if ( ! FileExists( FichierIni ) )
{
Desc = FileCreate( FichierIni );
// Création du fichier
if ( Desc < 0 )
ShowMessage ( "Création du fichier Essai.ini
impossible" ) ;
else // Le fichier est créé : on l'initialise
{
Page XV.4
Construction d'une application
La base de registres existait déjà sous Windows 3.1 mais n'était utilisée que par les
programme OLE.
Les informations de la base de registre sont stockées dans deux fichiers du répertoire
Windows ( System.dat et User.dat ).
Page XV.5
Construction d'une application
Chaque clé prend alors une valeur d'initialisation. Cette valeur peut être de type chaîne
de caractères, entier, booléen, réel, date ou "binaire" ( succession de 0 et de 1 n'ayant de
sens que pour l'application qui a généré cette valeur ).
Ces clés, très nombreuses, sont stockées sous forme d'une arborescence, les clés étant de
plus en plus précise au fur et à mesure que l'on "descend" dans l'arborescence.
Section Utilisation
HKEY_CLASSES_ROOT
HKEY_LOCAL_MACHINE Windows y stocke les informations sur la
configuration matérielle.
HKEY_CURRENTS_CONFIG
HKEY_CURRENT_USER Stocke les informations sur les programmes
installés sur la machine.
Cette section est elle-même divisée en
plusieurs sections dont l'une s'appelle
software.
Microsoft recommande de diviser cette section
en plusieurs sous-sections de la manière
suivante :
Software\Compagnie\Logiciel\Version
HKEY_USERS
HKEY_DYN_DATA
A partir de là il faut utiliser une des méthodes de la classe TRegistry en fonction de ses
besoins :
Openkey ( ) Ouvre une clé dans la section définie dans la propriété RootKey.
Si la clé n'existe pas elle est créée.
CreateKey ( ) Crée une nouvelle clé.
CloseKey ( ) Met fin à l'accès à la clé courante. La base est alors remise à
jour.
KayExists ( ) Détermine si une clé existe.
GetKeyInfo ( ) Retourne diverses infos sur la clé courante.
GetKeyNames ( ) Copie toutes les sous-clés de la clé courante.
GetDataType ( ) Retourne le type de la variable ValueName
Read ... ( ) Lisent le contenu d'une variable du type spécifié.
Write ... ( ) Écrivent dans la base de registre, une valeur du type spécifié.
Page XV.6
Construction d'une application
Exemple :
bool Res ;
AnsiString EditorFont ;
int FontSize ;
TRegistry *MonReg = new TRegistry ( ) ;
Il peut aussi y avoir d'autres produits ( tels des assistants ou des présentations
plus ou moins dynamiques du produit , mais cela est beaucoup plus complexe à
réaliser et n'est pas encore une "recommandation" incontournable ).
Ils doivent apporter une aide dans toutes les phases d'utilisation de l'application :
- Installation, configuration et désinstallation de l'application ;
- Utilisation courante ;
- Administration de l'application.
Page XV.7
Construction d'une application
Pour arriver à cela, il faut que le programmeur réalise des liens entre les différents
modules de son application et les rubriques de l'aide lorsqu'il met au point le code.
Le format 'rtf' permet en outre de créer des liens "hypertexte" permettant la navigation
non structurée entre diverses partie du texte : le fait de définir un mot clé comme étant
un "point chaud" ( = activable ) fait que, lorsque l'utilisateur place la souris sur ce mot,
la forme du curseur change : le fait de cliquer provoque l'affichage d'un autre texte
(contenu d'une autre rubrique ).
Un texte "point chaud" est souligné. Une image, ou une partie d'image,
peut aussi être un point chaud.
Page XV.8
Construction d'une application
L'ensemble des fichiers '.rtf' constituant un fichier d'aide est regroupé au sein d'un
projet. Un fichier 'projet, d'extension '.prj', est alors constitué : c'est un fichier texte à la
structure particulière permettant de fédérer les divers fichiers '.rtf', d'indiquer les images
à incorporer, les liens à établir avec une application , etc.
Aujourd'hui les choses sont beaucoup plus simples car il existe de nombreux utilitaires
permettant la création directe de fichiers au format '.rtf' tout en créant automatiquement
le fichier 'projet' adéquat. Dans ce domaine les produits les plus onéreux ne sont pas
toujours les plus efficaces et les plus simples d'emploi et on trouve en shareware
français des produits très faciles d'emploi ( écrits en Visual Basic .... ou en Delphi ).
Une fois le projet réalisé, il faut le compiler afin de créer le fichier '.hlp' souhaité. Il
faut pour cela utiliser un compilateur spécial fourni gratuitement par Microsoft : le
compilateur HC ( Help Compilator ) et ses successeurs ( HC31 ou mieux HCP ).
La compilation se fait en mode DOS est peut être très longue si le projet est
important.
HCP utilise la mémoire étendue. De ce fait il est adapté aux projets ambitieux.
1. Indiquer à l'application, le lieu où le fichier est stocké. Cela se fait grâce au menu
'Options de Projet' onglet Application. Il suffit de renseigner la zone de saisie
'Fichier d'aide :'.
Pour cela :
Page XV.9
Construction d'une application
Pour réaliser une telle aide il faut alors utiliser la méthode HelpContext ( ) ou la
méthode HelpJump ( ).
Dans les deux cas il faut que le créateur du fichier d'aide fournisse les
renseignements adéquats ( noms et / ou numéros des rubriques du
fichier ) pour pouvoir constituer une aide contextuelle efficace.
Page XV.10
Construction d'une application
- Soit utiliser le navigateur Internet présent sur la machine. Mais il faut alors savoir
quel est le navigateur installé ( ou alors il faut fournir lors de l'installation le
navigateur que l'on souhaite faire utiliser ).
Le fait que le navigateur soit un programme "externe" à l'application fait que son
lancement et son rafraîchissement ( affichage des diverses pages de l'aide ) se révèle
assez délicat et nécessite l'utilisation de primitives de l'API Windows proches du
système.
Page XV.11
Construction d'une application
}
}
Il est cependant possible de construire une fois pour toute une fiche
autonome qui réalisera ces fonctions et qui pourra ensuite être utilisée dans
les différents projets qui le souhaitent.
15.3 : Impressions
15.31 : Généralités
Page XV.12
Construction d'une application
Ce système permet de réaliser des impressions quelle que soit l'imprimante utilisée pour
l'impression ( c'est GDI qui se charge de réaliser les adaptations nécessaires ). GDI se
comporte donc comme une imprimante virtuelle générique.
Quelle que soit la manière dont on réalise les impressions, il est nécessaire, avant
d'entamer celles-ci, de donner quelques indications à GDI :
- Quelle est l'imprimante utilisée pour l'impression ;
- Type d'impression ( toutes les pages, certains pages, une ou plusieurs copies, etc. ).
- Etc...
Page XV.13
Construction d'une application
Comme tous les composants "dialogues", ces deux composants sont en fait des
interfaces avec des bibliothèques de dialogues standards de Windows ( stockées dans
COMMDLG.DLL ). Autrement dit, quel que soit l'environnement de développement, la
boite de dialogue qui s'affiche en cours d'exécution est identique.
Comme tous les composants de l'onglet "Dialogues", ceux-ci sont des composants
invisibles qui s'activent, en programmation grâce à la méthode Execute ( ).
Cette méthode réalise d'une manière transparente ( c'est à dire via un dialogue avec GDI
entièrement géré par la méthode ) la copie "écran" de la fenêtre qui l'a invoquée.
Si cette possibilité est de loin la plus simple à mettre en œuvre elle est aussi la plus
limitée : les cas où l'on a besoin de réaliser une copie de la fenêtre active sont relativement
rares.
Page XV.14
Construction d'une application
Les nouvelles versions de C++ Builder font que la méthode Print ( ) tient
compte de la résolution de l'imprimante. On obtient donc une impression de taille acceptable
même si l'imprimante utilisée a une résolution élevée. Dans les premières versions des
environnements Borland, l'impression d'une feuille de 600 x 480 pixels se traduisait par
l'impression d'une "vignette" de moins de 2 cm de coté ( pour une imprimante de résolution
720 ppi ).
En fait cela est possible en initialisant la propriété PrintScale de l'objet Form
concerné.
Comme tout objet qui se respecte, Printer dispose d'un ensemble de propriétés et de
méthodes accessibles en programmation. Depuis quelques versions la classe TPrinter est
documentée dans l'aide en ligne ( ce qui n'était pas vrai à l'origine ) même si la lecture des
rubriques révèle quelques surprises. On peut donc manipuler l'objet Printer sans trop de
problèmes et il donne alors satisfaction dans de nombreux cas.
En fait l'objet Printer encapsule l'accès aux primitives de GDI nécessaires pour
réaliser une impression. Il faut savoir que des utilitaires comme Quick Report
invoquent, en s'appuyant sur les scripts générés en phase de conception, un
objet de type Printer pour assurer le dialogue avec GDI. La génération de script
facilite ce dialogue ( une partie des ordres sont générés "à la souris" ) mais cela
se traduit par une plus grande lenteur d'exécution et une plus grande
consommation de ressources systèmes. Invoquer directement Printer se révèle
certes plus fastidieux mais est plus efficace en termes de performances.
PPrinter = Printer ( ) ;
Propriétés de TCanvas :
Brush Permet de définir les modes de remplissage des objets.
Pen Permet de définir les types et épaisseurs des traits.
Page XV.15
Construction d'une application
Il est évident que cela devient rapidement fastidieux si l'impression à réaliser est
importante. Néanmoins, en utilisant quelques méthodes bien choisies on arrive
rapidement à obtenir des résultats très corrects : impressions de cadres de tous types,
utilisation des fontes diverses avec enrichissements variés, impressions de graphiques
et d'images, etc.
Surtout, les impressions sont réalisées très rapidement, car le nombre d'intermédiaire est
très réduit : on s'adresse directement à GDI.
Méthodes :
BeginDoc Lance le travail d'impression
EndDoc Met fin au travail d'impression.
En fait EndDoc achève le travail en mémoire de l'objet Printer.
L'impression du document commence à ce moment.
NewPage Force Printer à changer de page.
L'impression via l'objet Printer se révèle à l'usage ( par utilisation massive de copier /
coller ) assez rapide à maîtriser. Il est vrai que de nombreux essais sont nécessaires pour
positionner correctement les différents objets en utilisant des coordonnées exprimées en
twips.
L'exemple précédent imprimait un rectangle occupant à peu près la surface d'une page
A4. Une telle page à donc une largeur approximative de 5800 twips pour une hauteur de
7800 twips..... pour une résolution imprimante de 720 ppi. Car c'est là que le problème
apparaît : l'affichage dépend de la résolution de l'imprimante. Il sera d'une taille deux
fois plus importante si la résolution courante de l'imprimante utilisée est de 360 ppi.
3. Pondérer toutes les coordonnées utilisées dans les différentes méthodes par les
coefficients ainsi déterminés.
Si l'on souhaite imprimer une image ou une partie de l'écran ( ce qui permet
d'outrepasser les limites de la méthode Print ( ) ), il faut utiliser les propriétés Draw ( )
et StretchDraw ( ) de la propriété Canvas.
{
Graphics::TBitmap *ImageForm ;
/* Le :: est utilisé pour ôter l'ambiguïté avec la classe
Bitmap de l'API Windows */
MonPrinter = Printer ( ) ;
RectDest . Left = 0 ;
RectDest . Top = 0 ;
RectDest . Right = .... ;
RectDest . Bottom = .... ;
ImageForm = GetFormImage ( ) ;
// Capture d'une image de la dimension de la feuille active
}
delete MonPrinter ;
Page XV.18
Construction d'une application
15.431 / Présentation :
Depuis quelques versions, les produits Borland ( Delphi et C++Builder ) sont fournis
avec un ensemble de composants permettant de réaliser des impressions élaborées :
rapport d'entreprises avec en têtes, compteurs de page, logos, connexions à des bases de
données, états de différents types, etc.
QuickReport est un utilitaire conçu au départ par une société tierce. Il semble qu'il ait
été racheté depuis par Borland car seule cette société continue à le proposer. Il est
explicitement destiné à être utilisé dans des applications ayant de gros besoins
d'impressions ( applications orientées "données" en particulier ) et est très utile dans ces
cas par sa capacité à gérer aisément les résultats de requêtes SQL.
QuickReport fonctionne via des scripts qui sont générés automatiquement lors de la
phase de conception des états d'impression. Il y a un script par type d'état à générer.
Tout atelier de développement qui se respecte doit savoir manipuler de tels utilitaires.
Mais cette solution se révèle lourde à mettre en œuvre et à diffuser lorsque les besoins
en impressions sont relativement limités.
Tous ces composants seront conçus dans des bandeaux qu'il suffira de positionner sur la
feuille "modèle" et qui seront appelés à chaque fois que l'on en aura besoin en cours
d'impression. Un bandeau est donc un modèle d'une partie de page à imprimer. Ils sera
éditer avec les données "courantes" correspondantes.
Page XV.19
Construction d'une application
Ce composant maître comporte un grand nombre de propriétés dont les principales sont:
Chaque bande est un objet TQRBand. L'ordre de conception / création de ces bandes n'a
aucune importance. L'impression se fera en fonction du type de la bande.
Par exemple pour créer un état comportant un titre, un en-tête et un pied de page,
des libellés de colonnes et des données sous forme d'enregistrement il faut 5
composants QRBand de types différents ( types : rbTitle, rbPageHeader,
rbPageFooter rbColumnHeader, rbDetail ).
Page XV.20
Construction d'une application
3- Déposer, sur chaque type de bande les composants permettant de constituer les
modèles d'objets. Le cas échéant connecter les composants aux champs des tables ou requêtes à
afficher ( en initialisant les propriétés DataSet et DataField ).
Page XV.21
Construction d'une application
Il suffit de lier les deux tables, comme cela a été fait précédemment ( voir chapitre
"tables liées" ), pour que, à l'impression, on ait un état comportant des ensembles
successifs de bandes suivantes :
- Une bande contenant les informations de l'enregistrement courant provenant de la
table maître.
- Une bande contenant les informations issues de la table liée, fonction des valeurs
courantes de la table maître.
On constate que :
- Il y a autant d'ensemble de bandes que d'enregistrement contenus dans la table
maître.
- Chaque bande maître est suivie d'un nombre variable de bandes "filles" pour une
bande "maître" ( fonction du lien 1 n existant entre les deux tables ).
Seule une version allégée d'Install Shield, appelée Install Shield Express, est
fournie avec l'environnement de développement. Une version professionnelle, plus puissante,
peut être acquise en sus.
Les versions du produit évoluent rapidement et sont de plus en plus faciles à
utiliser.
On utilise Install Shield une fois que le produit est achevé, avec génération d'un
exécutable stable ainsi que les différents types de fichiers qu'il est susceptible d'avoir à utiliser :
- bibliothèques DLL;
- exécutables annexes ( BDE et/ou générateur d'états par exemple ) ;
- fichiers de données ;
- fichiers d'aide ;
- fichiers d'initialisation ;
- etc.
Une fois les choix initiaux réalisés ( nouveau projet ou ouverture d'un projet existant, et
détermination éventuelle d'un répertoire de stockage ), le projet se présente sous la forme d'une
check-list qu'il s'agit de renseigner en fonction de vos besoins :
Page XV.22
Construction d'une application
- Inclusion de différents modules annexes ( BDE, pilotes SQL ou ODBC, VCL, etc.).
Une attention particulière doit être apportée à cette phase car il faut déterminer les
types de composants qu'il faudra inclure au produit ( y compris les composants
Quick Report, Internet, etc. le cas échéant ).
- Génération des images des disquettes d'installation ( ou CD ).
- Test de la procédure d'installation.
- Génération des médias d'installation.
Page XV.23