IntraWeb FR

Traduit de Anglais vers Français - www.onlinedoctranslator.
com
Manuel IntraWeb
Logiciel Atozed Copyright

IntraWeb
Une approche révolutionnaire du développement d'applications Web
"Rend le développement d'applications Web aussi simple que tomber

sur une bûche..."
Magazine PC Plus, juin 2002

IntraWeb
Tous les droits sont réservés. Aucune partie de ce travail ne peut être reproduite sous quelque forme ou par quelque moyen que ce soit - graphique, électronique ou
mécanique, y compris la photocopie, l'enregistrement, l'enregistrement ou les systèmes de stockage et de récupération d'informations - sans l'autorisation écrite de
l'éditeur.
Les produits auxquels il est fait référence dans ce document peuvent être des marques commerciales et/ou des marques déposées de leurs
propriétaires respectifs. L'éditeur et l'auteur ne revendiquent pas ces marques.
Bien que toutes les précautions aient été prises dans la préparation de ce document, l'éditeur et l'auteur n'assument aucune responsabilité
pour les erreurs ou omissions, ou pour les dommages résultant de l'utilisation des informations contenues dans ce document ou de l'utilisation
de programmes et de code source qui peuvent l'accompagner. En aucun cas, l'éditeur et l'auteur ne pourront être tenus responsables d'une
quelconque perte de profit ou de tout autre dommage commercial causé ou prétendu avoir été causé directement ou indirectement par ce
document.
je Manuel IntraWeb
Table des matières

Avant-propos 1
Partie I Bienvenue 3
1 autre document..n . . ta
. . . tio.n.................................................. .................................................................. ...................... 3
2 Comment IntraWeb...W. . . o..rk..s............................................... .................................................................. ....................... 3
3 Limites de..l.e...E . . . . Version................................... .................................................................. ....... 3

. . . évaluation
4 Sup. Technique. . . o..r..t.................................................. .................................................................. .............................. 4

5 Licence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
6 crédits, Ackno . . . .w. LED . . . e..n

. . . gemme . . . o..p..y..r..ig.h..ts.................................. .............................................. 5
. . t..s...a..n..d...C
7 Exigences.................................................................. .................................................................. ................................. 6

Aperçu ..........................................................................................................................................................6
Sourcils pris en charge..er.s. ..... .... ..... .... ..... .... ..... .... ..... .... ..... .... ..... .... ..... ..... .... ..... .... ..... .... ..... .... ..... .... ..... .... ..... .... ..... .... ..... ... 7
Développement Env..ir..o..n..m
. . . .e . . n.m. .ts.. .... ..... .... ..... .... ..... .... ..... .... ..... . ... ..... ..... .... ..... .... ..... .... ..... .... ..... . ... ..... .... ..... .... ..... .... ..... ... 8
Partie II Quoi de neuf dix

1. Vue d'ensemble . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . dix
2 Support PDA.................................................. .................................................................. ................................... 11
Partie III Guide de migration 13

1 6,0 à 7,0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2 5.1 à 6.0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
3 5,0 à 5,1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
Partie IV Installation 18
1 Installation de..f..L..ic.e..n..s..e...K. . . e..y..s.................................................. .................................................................. ............. 18
2 Visual Studio....N . . . et.................................................. .................................................................. ....................... 18

3 Delphi / C++.B . . . u..ild.e..r ........................................ .................................................................. ............................ 18
4 Kylix. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
5 Mise à niveau vers...a...n..e..w. . . . v..e..rs.io

..m. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
Utilisateurs Delphi 7 .... .... ..... .... ..... .... ..... .... ..... .... ... .. .... ..... .... ..... .... ..... ..... .... ..... .... ... .. .... ..... .... ..... .... ..... .... ..... .... ..... ... . ..... . 19
Partie V Démos 21
1 Démarrage rapide ............................................... .................................................................. ................................... 21
2 Bâtiment A De.m. . . o...S . . . y...S..te.p

. . t..e..p...B . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
3 Caractéristiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
4 Devinez. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
5 DevinerWB ................................................. .................................................................. ................................. 32

6 Devinez Multi ................................................. .................................................................. ................................. 32
7 FishFact . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32

Contenu II
8 FishFactDM .................................................. .................................................................. ................................. 32
9 Phénitique Cu.s..to . . ..m. . e..r...P..ro.f..il..e..r.................................. .................................................................. ....................... 32

10 AutonomeS..S..L. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
11 WebSnapSur..ve . . . y.................................................. .................................................................. ....................... 32
12 Stand personnalisé.d. . UNE . . . e.................................................. .................................................................. .................... 32
. . . lo.n
13 Bouton Retour............................................... .................................................................. ................................... 33
Formulaires de 14 pages ................................................. .................................................................. ................................... 33
15 Marché aux poissons ................................................. .................................................................. ................................. 33
16 Meurs, vole ! Mourir..!.............................................. .................................................................. ................................. 33
17 WebMail32 .................................................. .................................................................. ................................. 34
Débogage de la partie VI 36
1 Mise en route.e..d............................................... .................................................................. .................................... 36
2 Sortie de débogage..t.................................................. .................................................................. ................................... 36
3 Détection d'Er.ro.r..s...o..n...S..t..ar.tu.p................... .................................................................. ....................................... 36
4 Commande Li.n..e...P. . . le matin . . . rs.................................................. .................................................................. ....... 36

. . ..e. te
Partie VII Développement 39

1 Repenser e . . UE
. . . s..e..r..In.t..er.fa.c. . e.................................................. .................................................................. ..... 39
2 Écrire vos..F..irs ...

. . . étain tr.aW . . ti.o..n............................................................... ....................................... 39
. . . p..p..lic.a
. . . . e..b...A
3 images et G . . .p. . h..ic.s............................................... .................................................................. ....................... 41

. . . ra
4 Extension In.tra.W
. . . . e..b.................................................. .................................................................. ....................... 42
5 Travailler avec...C. . . O...M

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
6 Travailler avec...C. . . mentir . . . a..ta.S

. . . n..tD . . .m
. . e..t...C..o . . . ts.................................................. ................................ 43
..m
. . . p..o.n..e
7 Travailler avec...P..D. . . UNE

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
8 Divers.................................................. .................................................................. ................................... 44
Partie VIII Gestion des formulaires 47

1 Travailler avec...F..o. . r..m
. . . s.................................................. .................................................................. .................... 47
2 Mode de mise à jour.................................................. .................................................................. .................................. 47
3 IntraWeb Fra.m. . . . e.................................................. .................................................................. .............................. 48

. . . o..n..tr.o..l...................................... .................................................................. .............................. 49
4 Utilisation Intraweb..r..C
5 Forme visuelle .In.h..e..r..ita.n..c..e.......................... .................................................................. ..................................... 49
6 Gestion de la for..rm. . . s.................................................. .................................................................. ....................... 49
7 Liste des formulaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
8 Affichage du formulaire. . . . s.................................................. .................................................................. .............................. 50
9 Cacher les formulaires.................................................. .................................................................. ................................... 51
dix Détruire Fo ..
. . r..m . s.................................................. .................................................................. ....................... 51
. . .e. . e..n...F..o
11 Transmission de données...B . . . et.w ..
. . r..m . s.................................................. .................................................................. .... 51
12 Remarque pour C++..B . . . u..ild.e..r..u ..

. . . se . rs.................................................. .................................................................. ........ 57

III Manuel IntraWeb
Partie IX Gestion de l'état 59

1 État inhérent.e.................................................. .................................................................. ................................... 59
2 Restrictions............................................................... .................................................................. ................................ 59
3 Stockage en toute sécurité............................................... .................................................................. ................................... 59
4 Complexe État.a..n..d. . . . le.e...B . . . n.................................................................. .............................................. 62

. . . u..tto
. . . a..c..k...B
Utilisation du OnBa.c..k. .B. . . ut.à . . . v..e..n..t..... .... ..... .... ..... .... ..... .... .... . .... ..... ..... .... ..... .... ..... .... ..... .... .... . .... ..... .... ..... .... ..... .... ..... . 64
. . n...E
Partie X Gestion des sessions 66

1 WebApplicat.io.n. . . ..O. .b. . je.c..t.................................................. .................................................................. ................... 66
2 Référencement.e. . . e...S..e..s..s..io
..m. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
3 Durée de vie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
4 Mise en œuvre. . m
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
5 Stockage Addi.tio.n . . une . . à........................................... .................................................................. .................... 67

. . . l..D
6 Session Rela..te.d...E . . .v. . .fr. . ts.................................................. .................................................................. ............. 67

7 Mémoire Cons..u..m. . . . p..tio.n............................................................... .................................................................. ...................... 68
8 Composant R . . . e..fe.re
..m. . . ce
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
9 Comment Se..ss. . . io.n....M

. . un . . . o..r..k..?................................................. .............................................. 68
. . . e..n..t...W
. . . une gemme
URL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
Biscuits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
Champs cachés .... .... ..... .... ..... .... ..... .... ..... .... .... . .... ..... .... ..... .... ..... ..... .... ..... .... .... . .... ..... .... ..... .... ..... .... ..... .... ..... .... ..... . 69
Gestionnaires et modèles de mise en page de la partie XI 71

. . . a..n..a..g..e..r..?.................................. .................................................................. ....................... 71
1 Qu'est-ce qu'un laïc. . .o. . u..t..M
2 Mise en page du formulaire............................................... .................................................................. ................................... 71
3 Modèles HTML .................................................. .................................................................. ................................... 71
..
4 Température du système. . la . te.s.................................................. .................................................................. ....................... 73
Contrôleur de serveur Partie XII 75

. . ll.er.?.............................................. .................................................................. ....... 75
1 Qu'est-ce que le S..e..rv.e..r...C . . .o. . n..tro
2 Propriétés ................................................. .................................................................. ................................. 75
Partie XIII Écrire des composants personnalisés 77

1. Vue d'ensemble . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
2 Sous Const.ru . . . ct.io.n............................................... .................................................................. ....................... 77

3 Code source............................................................... .................................................................. ................................... 77
Serveur 4 cœurs ........................................................ .................................................................. ................................... 77
5 Tiers Pr.o..g..r..a..m . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
Partie XIV Javascript 79

1. Vue d'ensemble . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
2 Domaines d'Imp.le.m
. . . .e..nt.a..tio.n....................................... .................................................................. ....................... 79

Contenu IV
3 Utilisation de Script.E..v..e..n..ts. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
Écriture de JavaScr.ip.t..e..v..e..n. . ts
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
Plus de script Eve.n..ts... ..... .... ..... .... ..... .... ..... .... ... .. .... ..... .... ..... .... ..... ..... .... ..... .... ... .. .... ..... .... ..... .... ..... .... ..... .... ..... ... . ..... . 84
4 Javascript Fu . . m
. . . ct.io.n..s.................................................. .................................................................. ....................... 85
Fonctions communes. . .s. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
Partie XV Mode page 88

1 Introduction.à. . . . P..a..g..e...M. . .. o. ré. . . e.................................................. .................................................................. ......... 88
2 Travailler avec...P..a. . .g. . e...M
. . . ode........................................... .................................................................. .................. 88
3 IntraWeb et...W. . . e...b..s..n..a..p.................................. .................................................................. .............................. 92

Création de la démo
. . . . o.... ..... .... ..... .... ..... .... ..... .... ..... .... ..... .... ..... .... ..... ..... .... ..... .... ..... .... ..... .... ..... .... ..... .... ..... .... ..... .... ..... . 93
Exécution de la démo
. . . . o.... ..... .... ..... .... ..... .... ..... .... ..... .... ..... .... ..... .... ..... ..... .... ..... .... ..... .... ..... .... ..... .... ..... .... ..... .... ..... .... ..... . 99
4 IntraWeb Pa..g. . e..s . . .. P

. . . (..IW . ) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
Introduction à. .IW
. . ..P. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
Création du Pr.o. . . je .c..t. ..... .... ..... .... ..... .... ..... .... ..... .... ..... .... ..... .... ..... ..... .... ..... .... ..... .... ..... .... ..... .... ..... .... ..... .... ..... .... .... 103
La préparation de l'art. .e..r..ve.r. ..... .... ..... .... ..... .... ..... .... ..... .... ..... .... ..... .... ..... ..... .... ..... .... ..... .... ..... .... ..... .... ..... .... ..... .... ..... .... .... 103
Création d'un IW.P...p..a..g . . e..... .... ..... .... ..... .... ..... .... ..... .... .... . .... ..... .... ..... ..... .... ..... .... ..... .... .... . .... ..... .... ..... .... ..... .... ..... .... .... 105
Création d'un IW.P...fo. . r..m

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
Déploiement du .fi.l..e..s.... ..... .... ..... .... ..... .... ..... .. .. ..... .... ..... .... ..... .... ..... ..... .... ..... .. .. ..... .... ..... .... ..... .... ..... .... ..... .... ... .. .... .... 106
Partie XVI Mécanisme de mise en cache IntraWeb 109

..
1 fichier de mise en cache . s.................................................. .................................................................. .............................. 109
Déploiement de la partie XVII 111

1 Montage............................................................. .................................................................. ................................. 111
Aperçu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
Fichiers externes. ..... .... ..... .... ..... .... ..... .... ..... .... ..... .... ..... .... ..... .... ..... ..... .... ..... .... ..... .... ..... .... ..... .... ..... .... ..... .... ..... .... . ... 111
Autorisations. ..... .... ..... .... ..... .... ..... .... ..... .... ..... .... ..... .... ..... .... ..... ..... .... ..... .... ..... .... ..... .... ..... .... ..... .... ..... .... ..... .... . ... 111
ISAPI. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
Déploiement dans..IIS.. ..... .... ..... .... ..... .... ..... .... ..... .. .. ..... .... ..... .... ..... ..... .... ..... .... ..... .. .. ..... .... ..... .... ..... .... ..... .... ..... .... ... 112
ISAPI Utiliti.e..s.. .... ..... .... ..... .... ..... .... ..... .... . .... .... ..... .... ..... .... ..... ..... .... ..... .... . .... .... ..... .... ..... .... ..... .... ..... .... ..... . ... .... 115
ISAPI Host.in.g. .... ..... .... ..... .... ..... .... ..... .... ..... .... . .... .... ..... .... ..... ..... .... ..... .... ..... .... . .... .... ..... .... ..... .... ..... .... ..... .... .... 115
Commun IS..A . . . s..... .... ..... .... ..... .... ..... .... ..... .... .... . .... ..... ..... .... ..... .... ..... .... ..... .... .... . .... ..... .... ..... .... ..... .... .... 116
. . . P..I..Is.s..ue
ISAP utile . . . I..li.n...ks... .... ..... .... ..... .... ..... .... ..... . ... ..... .... ..... .... ..... ..... .... ..... .... ..... . ... ..... .... ..... .... ..... .... ..... .... ..... .... .. .. 117
2 Méthodes ....................................................... .................................................................. ................................. 117

Remarques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
Tenez-vous seul. ..... .... ..... .... ..... .... ..... .... ..... .... ..... .... ..... .... ..... .... ..... ..... .... ..... .... ..... .... ..... .... ..... .... ..... .... ..... .... ..... .... . ... 117
ISAPI / NSAPI /. .A..p. . une

. . . ch . . ..O
. . . e.. .D..S . . /...C. ..G
. . Je. ./..W . . - . .. C..g
. . . dans . . JE.. .... ..... .... ..... .... ..... ..... .... ..... .... .. ... .... ..... .... ..... .... ..... .... ..... .... ..... .. .. .... 118
Windows Servi.c..e... .... ..... .... ..... .... ..... .... ..... .... ..... .... ..... .... ..... .... ..... ..... .... ..... .... ..... .... ..... .... ..... .... ..... .... ..... .... ..... .... .... 119
3 URL de lancement..s. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
Lien vers Intra.W. . . . e. .b...Un. . . p..p..lic.a..tio. . . n..s... .... ..... .... ..... .... ..... .... ..... .... ... .. ..... .... ..... .... ..... .... ..... .... ..... .... ... .. .... ..... .... ..... .... .... 119
Séances. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
Passage de Param.e..t..e. .rs. ..... .... ..... .... ..... .... ..... .... ..... .... ..... .... ..... .... ..... ..... .... ..... .... ..... .... ..... .... ..... .... ..... .... ..... .... ..... .... .... 120
4 Conversion..P..ro.je. . . ct..T..y..p..e..s.................................. .................................................................. ........................ 121

Conversion de . . . . . Supporter
. . . alo
..m. . . e.. .à. .EST
. . . A..P . . .h. . je. ..... .... ..... .... ..... ..... .... ..... .... ..... .... ..... .... ..... .... ..... .... ..... .... ..... .... .... 121
. . Je...dans ..D..e..lp
Conversion de . . . . . Supporter
. . . A..lo
. . n...e. .à
. . . . EST UN . . ..C. .B
. . . P. .I..dans . . .e.
. . mal
. . vous . r.. .... ..... .... ..... ..... .... ..... .... ..... .... .. ... .... ..... .... ..... .... ..... .... ..... .... .... 122
Conversion de . . . . . EST UN
. . .P. . I..à..S . .e. . lp .h..i. ..... .... ..... .... ..... ..... .... ..... .... ..... .... ..... .... ..... .... ..... .... ..... .... ..... .... .... 123
. . . ta .n..d . . . lo.n..e...dans. . . .ré . . UNE
5 L..in.u supplémentaires. . . x...Dans . . . a..tio.n............................................................... .................................................................. ......... 124

. . former
Aperçu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124

V Manuel IntraWeb
6 Application..p..o..r..t.................................. .................................................................. ................................... 124
Partie XVIII Évaluations des performances 126

1 Conseils . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126
Partie XIX Mise à l'échelle des applications IntraWeb 128

..
1 Mise à l'échelle Met.h. . .o. ré . s.................................................. .................................................................. ....................... 128
2 Distribuer...l'In.tr.a..W. . . e..b . . .p. . l.ic

. . . . A..p . . . a..tio.n
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
Partie XX HTTP sécurisé / SSL 131

1. Introduction................................................ .................................................................. ................................. 131
2 Activation SS..L. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131
3 Conversion..C..e..rt.if..ic.a..te.s... en . . ..P. . E..M ..

. . . . . Former . . à................................................. ................................... 131
4 Exemple ................................................. .................................................................. ................................ 132
Indice 133

1
"En un mot, IntraWeb fait les choses à la manière de Delphi. ..... Suis-je
donc impressionné ? Oui, tout à fait. ..... Comme j'ai examiné WebSnap
et comparé à IntraWeb, il est clair pour moi qu'IntraWeb est le
genre de technologie que je m'attendrais à voir de Borland
mais ne l'a pas fait."
Delphi Magazine, mars 2002

Section
je
Bienvenue 3
1 Bienvenue
IntaWeb est une nouvelle façon révolutionnaire de créer des applications Web. Construit sur Web Solution Builder et les
versions antérieures d'IntaWeb, il étend la technologie de ces deux éléments, fournissant un excellent outil pour créer
des applications Internet, Intranet et Extranet d'une manière rapide et facile à entretenir.
De nombreux outils de développement Web exigent que l'utilisateur connaisse les scripts CGI,
le suivi et les configurations clients complexes. IntaWeb élimine tous ces tracas et frais généraux. En créant
simplement l'application à l'aide de la suite de composants dans Delphi ou Visual Studio, puis en l'enregistrant
sur le serveur, les clients peuvent accéder à l'application à l'aide de n'importe quel navigateur conforme à la
version HTML 4. Ceux-ci incluent les dernières versions de Netscape et Internet Explorer. Ces deux
ont été entièrement testés avec IntaWeb et sont 100% compatibles. Aucun codage HTML, CGI ou JavaScript n'est requis ;
tout le codage est fait en utilisant Delphi ou C# et VB.NET pour Visual Studio. Pour plus de flexibilité, l'application peut
également être exécutée en tant qu'exécutable autonome comme toute autre application de bureau, offrant des
capacités de débogage.
1.1 Autre documentation
N'oubliez pas de consulter la FAQ IntaWeb (disponible sur le Site Web d'Atozed Software) ainsi que les informations
disponibles sur le site lui-même. Beaucoup de documentation y est contenue qui ne se trouve pas dans le manuel ou
le fichier d'aide et pour qu'elle reste précise et à jour, nous ne l'avons pas dupliquée.
Ce document est conçu comme un manuel et non comme un guide de référence. Le fichier d'aide IntaWeb
Component Reference doit être consulté lorsqu'une référence pour les propriétés, les événements, les méthodes et
les composants est nécessaire.
1.2 Comment fonctionne IntraWeb
IntaWeb fonctionne un peu comme une application exécutable normale, à l'exception du fait que l'interface utilisateur est un
navigateur Web au lieu d'une fenêtre. Après avoir placé l'application sur un serveur Web, un utilisateur peut exécuter une
instance de l'application en utilisant une URL pour démarrer une session. Les informations de l'utilisateur seront suivies par
l'instance de l'application en cours d'utilisation, évitant ainsi la perte d'informations ou leur confusion avec d'autres
informations utilisateur. Pour chaque utilisateur, de nouvelles informations de session sont créées et suivies automatiquement
et de manière transparente pour le développeur. La surcharge est faible et la capacité d'une application IntaWeb est similaire à
celle d'autres solutions Web telles que ISAPI, CGI ou ASP.
IntaWeb est conçu pour créer tout type d'application Web, qu'il s'agisse d'un simple formulaire de saisie de données, d'un
sondage ou d'une application complexe où les clients doivent être « connectés » pendant une période prolongée.
1.3 Limites de la version d'évaluation

Les limitations de l'édition d'évaluation ont été conçues de manière à ce que vous puissiez pleinement évaluer
votre application sans limite de temps ni restriction de développement. Les seules restrictions dans le
édition d'évaluation existent pour entraver le déploiement.
Numéros de port uniques

Lorsque vous utilisez la version d'évaluation d'IntaWeb, les numéros de port que votre application IntaWeb écoute seront
uniques à chaque exécution. Tous les paramètres de port que vous pouvez spécifier seront ignorés. Le test est facilité en mode
d'évaluation par l'utilisation de l'élément de menu d'exécution car il ajuste automatiquement son URL pour le port changeant.
Restriction IP
Dans la version d'évaluation, les applications IntaWeb n'écoutent que sur l'IP 127.0.0.1. Aucune demande provenant d'autres
adresses IP ne sera répondue.

4 Manuel IntraWeb
Aucun service
Les applications IntaWeb ne peuvent pas être installées ou exécutées en tant que services dans la version d'évaluation. Tenter de le
faire entraînera des erreurs.
Pas de SSL
SSL est désactivé dans la version d'évaluation.
Aucune licence de déploiement

Vous ne pouvez pas déployer d'applications créées avec la version d'évaluation.
1.4 Soutien technique

Des informations d'assistance à jour sont disponibles sur http://www.atozed.com/ .
1.5 Licence
Contrat de licence utilisateur unique
Il s'agit d'un accord juridique entre vous, l'utilisateur final, et Atozed Software (ci-après dénommé
simplement Atozed). En utilisant ce progiciel, vous acceptez d'être lié par les termes de cet accord. Si
vous n'êtes pas d'accord avec les termes de cet accord, désinstallez rapidement ce logiciel.
Octroi de licence - Atozed vous accorde le droit d'utiliser une copie du logiciel ci-joint pendant une
les développeurs uniques utilisent. Cela inclut la possibilité d'installer sur plusieurs ordinateurs tant que le
l'installation n'est utilisée que par le même développeur. En clair, cela signifie que vous pouvez installer ce logiciel
sur votre ordinateur de bureau et votre ordinateur portable tant que vous êtes le seul à utiliser le logiciel. Vous ne
pouvez pas installer sur plusieurs ordinateurs pour que plusieurs développeurs puissent l'utiliser. De plus, vous ne
pouvez pas installer sur un ordinateur pour que plusieurs développeurs l'utilisent en dehors de
à des fins de débogage normales et d'examen par les pairs.
Vous pouvez faire une copie du logiciel à des fins de sauvegarde pour une utilisation sur votre propre ordinateur. Le
logiciel d'origine doit être sauvegardé sous une forme non modifiée.
Vous ne pouvez pas mettre le logiciel en réseau ou l'utiliser sur plus d'un seul ordinateur ou ordinateur
terminal à tout moment, sauf si une copie est achetée pour chaque développeur du réseau qui utilisera
le logiciel. Vous ne pouvez pas louer ou louer le logiciel, mais vous pouvez transférer le logiciel et le
matériel écrit qui l'accompagne et cette licence à une autre personne de manière permanente à
condition que vous ne conserviez aucune copie et que l'autre personne accepte les termes et conditions
de cet accord.
CE LOGICIEL NE PEUT PAS ÊTRE DISTRIBUÉ, SOUS FORME MODIFIÉE OU NON MODIFIÉE, DANS LE
CADRE DE TOUT PROGRAMME D'APPLICATION AUTRE LOGICIEL QUI EST UN PRODUIT DE TYPE
BIBLIOTHÈQUE, UN OUTIL DE DÉVELOPPEMENT OU UN SYSTÈME D'EXPLOITATION, OU QUI PEUT
ÊTRE CONCURRENTIEL AVEC OU UTILISÉ À LA LIEU DU PRODUIT DU PROGRAMME,
SANS L'AUTORISATION ÉCRITE EXPRESSE D'Atozed.
Cette licence inclut le droit de distribuer des applications à l'aide du logiciel joint à condition que
les conditions ci-dessus soient remplies.
Terme - Cet accord est en vigueur jusqu'à ce que vous le résiliez en détruisant le logiciel, toutes les copies et
sauvegardes. Il prendra également fin si vous ne respectez pas cet accord. Vous acceptez lors de la résiliation
de détruire le logiciel, ainsi que toutes ses copies, y compris les sauvegardes.
droits d'auteur - Le logiciel appartient à Atozed et est protégé par les lois et traités internationaux.
Par conséquent, vous devez traiter le logiciel comme tout autre matériel protégé par le droit d'auteur.
Clause de garantie
Garantie limitée - Atozed garantit que le logiciel fonctionnera essentiellement conformément

avec les documents écrits qui l'accompagnent. Atozed ne garantit pas que les fonctions contenues

Bienvenue 5
dans le logiciel répondra à vos exigences, ou toute opération du logiciel sera

ininterrompue ou exempte d'erreurs.
Exclusion de garanties - Atozed décline toute autre garantie, expresse ou implicite,

y compris, mais sans s'y limiter, les garanties implicites de qualité marchande d'aptitude de particuliers
but, en ce qui concerne le logiciel et les documents écrits qui l'accompagnent. Atozed n'aura aucun dommage
indirect. En aucun cas, Atozed ou ses fournisseurs ne pourront être tenus responsables des dommages quels qu'ils
soient (y compris, mais sans s'y limiter, les dommages pour perte de bénéfices commerciaux, interruption d'activité,
perte d'informations commerciales ou toute perte pécuniaire), résultant de l'utilisation ou de l'incapacité de ce
produit, même si Atozed a été informé de la possibilité de tels dommages.
Seul recours - Atozed n'est pas responsable des recours.
Droits restreints du gouvernement américain - Ce logiciel et sa documentation sont fournis avec des droits
restrictifs. L'utilisation, la duplication ou la divulgation par le gouvernement est soumise à des restrictions
énoncé à la section c(1)(ii) de la clause Droits et données techniques sur les logiciels informatiques à l'adresse
52.227-7013.
1.6 Crédits, remerciements et droits d'auteur

Tous les efforts ont été faits pour fournir du crédit aux sources appropriées. Cependant, dans de nombreux cas, plusieurs
sources n'ont été utilisées qu'à des fins de consultation. Dans d'autres cas, les auteurs originaux ne sont pas connus,
ou aucune information sur la licence n'a été fournie.
IntaWeb
IntaWeb est un produit commercial et entièrement protégé par les lois et traités internationaux sur le droit d'auteur.
Aide et manuel
Aide et manuel est utilisé pour produire ce fichier et d'autres fichiers d'aide et de la documentation.
http://www.ec-software.com/
Configuration Inno
L'installation d'IntaWeb s'effectue à l'aide Configuration Inno qui est Copyright © 1998-2001 Jordan
Russell avec des parties de Martijn Laan.
La A-Team et TeamZed
Merci à A-Team et TeamZed pour leur soutien continu à IntaWeb.
Inde
IntaWeb utilise Indy pour fournir une grande partie de ses fonctionnalités. Indy exige que son droit d'auteur soit inclus. Veuillez
noter que ce droit d'auteur ne s'applique qu'au code Indy lui-même. Plus d'informations sur la licence de
Indy peut être trouvé à http://www.nevrona.com/indy/license.html.
droits d'auteur
Certaines parties de ce logiciel sont protégées par copyright (c) 1993 - 2001, Chad Z. Hower (Kudzu) et Indy Pit Crew
- http://www.nevrona.com/Indy/
Licence
La redistribution et l'utilisation sous forme source et binaire, avec ou sans modification, sont autorisées à condition que les
conditions suivantes soient remplies :
Les redistributions du code source doivent conserver l'avis de droit d'auteur ci-dessus, cette liste de conditions et la clause de non-
responsabilité suivante.
Les redistributions sous forme binaire doivent reproduire l'avis de droit d'auteur ci-dessus, cette liste de conditions et les

6 Manuel IntraWeb
suivant l'avis de non-responsabilité dans la documentation, sur la boîte et/ou d'autres matériaux fournis avec la
distribution.
Aucun nom personnel ou nom d'organisation associé au projet Indy ne peut être utilisé pour approuver
ou promouvoir des produits dérivés de ce logiciel sans l'autorisation écrite préalable de l'individu ou de
l'organisation spécifique.
CE LOGICIEL EST FOURNI PAR Chad Z. Hower (Kudzu) et l'équipe Indy Pit "EN L'ÉTAT" ET
TOUTE GARANTIE EXPRESSE OU IMPLICITE, Y COMPRIS, MAIS SANS S'Y LIMITER, LES GARANTIES
IMPLICITES DE QUALITÉ MARCHANDE ET D'ADAPTATION À UN USAGE PARTICULIER SONT EXCLUES.
EN AUCUN CAS, LES REGENTS OU CONTRIBUTEURS NE SERONT RESPONSABLES DE TOUT
DOMMAGE DIRECT, INDIRECT, ACCESSOIRE, SPÉCIAL, EXEMPLAIRE OU CONSÉCUTIF (Y COMPRIS,
MAIS SANS S'Y LIMITER, L'ACHAT DE BIENS OU DE SERVICES DE REMPLACEMENT ;
PERTE D'UTILISATION, DE DONNÉES, OU DE BÉNÉFICES ; OU INTERRUPTION DES ACTIVITÉS) TOUTEFOIS CAUSÉ ET SUR
TOUTE THÉORIE DE RESPONSABILITÉ, QU'ELLE SOIT DANS UN CONTRAT, UNE RESPONSABILITÉ STRICTE OU
DÉLICTUELLE (Y COMPRIS LA NÉGLIGENCE OU AUTRE) DÉCOULANT DE QUELQUE MANIÈRE QUE CE SOIT DE
L'UTILISATION DE CE LOGICIEL, MÊME SI AVISÉ DE LA POSSIBILITÉ D'UNE TELLE POSSIBILITÉ.
Auteur original de TIWMenu

Merci à la personne qui est à l'origine de ce composant. Cependant, ils ont oublié de marquer leur nom
dans le fichier .pas. :)
Jason Southwell
Pour apport de plusieurs composants et composants de
démarrage. Apport de TIWDataModulePool dans IntaWeb 6
Thomas Brattli
http://www.dhtmlcentral.com
Pour eXperience DHTML Cool Menus qui sont la base de TIWMainMenu.
Motty Adler
Pour la contribution de l'idée et de la source sur laquelle TIWTimer est basé.
L. Relihan & P. Kerl

Auteurs de l'applet Java PacText utilisé dans la démo des fonctionnalités.
Paul Stockton et Anthony Lowery

Pour leur contribution au code du calendrier.
Autres
Merci à toutes les autres parties qui ont aidé avec des contributions petites et grandes que nous avons peut-
être négligées.
Jorrit B. Jongma
Contribution des routines et classes de compression pour la compression HTTP dans IntaWeb 6
1.7 Conditions
1.7.1 Aperçu
La seule exigence est que les utilisateurs d'applications développées par IntaWeb aient des navigateurs compatibles
avec HTML 4 *, car une utilisation intensive de HTML 4 et de JavaScript est faite. IntaWeb a été
largement testé avec Netscape et Internet Explorer et est pris en charge avec Mozilla, Netscape 6 et
supérieur et Internet Explorer 4.0 et supérieur.
REMARQUE : si vous souhaitez prendre en charge Netscape 4, vous devez utiliser IntaWeb version 4.

Bienvenue 7
maintenir et soutenir. Depuis la version 5.1, IntaWeb prend en charge HTML 3.2 en version PDA. Par conséquent, Netscape 4 est
pris en charge dans une certaine mesure (c'est-à-dire, aucune utilisation de CSS ou JavaScript).
HTML4
IntaWeb utilise HTML 4 et des feuilles de style pour réaliser le placement des coordonnées des éléments et d'autres
fonctionnalités. L'utilisation de modèles ou de mode page peut éliminer le besoin de feuilles de style.
JavaScript
JavaScript est utilisé pour permettre de nombreuses fonctionnalités client avancées. JavaScript permet également à IntaWeb
de contrôler le navigateur et les pages rendues. JavaScript n'est requis que pour le mode Application.
Prise en charge des PDA (HTML 3.2)

Intraweb 5.1 introduit la prise en charge des PDA. Basé sur HTML 3.2, le mode 3.2 vous permet de développer des
applications compatibles avec la plupart des appareils PDA. Le mode 3.2 ne nécessite PAS de JavaScript ou
CSS, ce qui le rend entièrement compatible avec tout appareil prenant en charge HTML 3.2. Veuillez noter que pour utiliser
3.2 vous êtes limité aux contrôles 3.2 qui apparaissent sur la palette. La plupart de ces contrôles sont les mêmes que
les contrôles IW standard, mais en raison des restrictions HTML 3.2 et du manque de JavaScript, ils offrent dans
certains cas moins de fonctionnalités que leur équivalent standard.
1.7.2 Navigateurs pris en charge
Même avec les normes HTML et JavaScript en place, les navigateurs diffèrent dans de nombreux domaines. IntaWeb
ajuste automatiquement ces différences. IntaWeb génère le code HTML et JavaScript approprié pour le navigateur.
IntaWeb connaît même certains bogues dans des versions spécifiques de chaque navigateur et les contourne de
manière dynamique. Dans d'autres cas, la sortie de chaque navigateur est optimisée. Voir la section sur les
implémentations du navigateur pour plus d'informations.
Implémentations du navigateur
Même avec les normes HTML et JavaScript en place, les navigateurs diffèrent dans de nombreux domaines. Cela est dû en grande partie au fait que
les navigateurs créent souvent des extensions avant que ces fonctionnalités ne soient adoptées en tant que normes. Souvent, différents
navigateurs implémentent des fonctionnalités similaires de manière incompatible.
IntaWeb s'adapte automatiquement à ces différences. IntaWeb génère le code HTML approprié et
Code JavaScript pour le navigateur. IntaWeb connaît même certains bogues dans des versions spécifiques de chaque
navigateur et les contourne de manière dynamique. Dans d'autres cas, la sortie de chaque navigateur est optimisée.
IntaWeb exécute tout cela de manière transparente pour vous et sans utiliser Java, ActiveX ou aucun plug-in.
Internet Explorer
Internet Explorer versions 5 et 6 sont pris en charge.
Internet Explorer 4 n'est plus officiellement pris en charge. Cependant, toute application HTML 3.2 doit s'exécuter
sans aucun problème sur Internet Explorer 4.
Netscape
Netscape 7 est pris en charge.
Netscape 6 n'est pas pris en charge. La version 6 de Netscape a de sérieux problèmes avec le rendu HTML et
l'implémentation de JavaScript. Une meilleure version est disponible en téléchargement sur le site Netscape.
Bien que Netscape 6 ne soit pas officiellement pris en charge, la plupart des applications créées avec IntaWeb s'exécuteront
correctement dessus. Il existe des problèmes connus avec Netscape 6 lors de l'utilisation de mises à jour partielles, lors de l'utilisation de
régions, lors de la mise en cache des fichiers et lors de la tentative d'utilisation du contrôle TIWMenu. Il pourrait cependant y avoir plus
de problèmes. Lors du développement pour Netscape 6, assurez-vous de tester votre application avec une version plus récente
version de Netscape (7 ou supérieure) avant de rechercher des bogues.

8 Manuel IntraWeb
Mozilla
Mozilla est pris en charge. Veuillez vous assurer que vous utilisez la dernière mise à jour de Mozilla.
Opéra
Opera 7 est entièrement pris en charge.
En raison du nombre de restrictions imposées par Opera 6 avec la prise en charge de JavaScript, certaines caractéristiques ne sont
actuellement pas prises en charge dans Opera. Beaucoup d'entre eux ont à voir avec les ancrages et l'alignement. Le positionnement à
gauche et en haut est pris en charge avec les ancres, cependant, actuellement, à droite et en bas ne le sont pas. Autre fonctionnalité
est pris en charge dans Opera.
D'autres navigateurs
Tout navigateur prenant en charge le rendu HTML 3.2 est pris en charge. Cependant, HTML 3.2 est limité à bien des égards,
le plus notable étant le manque de prise en charge de Javascript.
1.7.3 Environnements de développement
Lors de l'achat d'IntaWeb Enterprise Edition (ne s'applique pas aux offres spéciales), une assistance est fournie pour les
environnements de développement suivants :
· Delphi 5 (Pro et Entreprise)

· Delphi 6 (Pro et Entreprise)
· Delphi 7 (Professionnel, Entreprise et Architecte)
· Générateur C++ 5
· Générateur C++ 6
· Kylix 2
· Kylix 3
· Visual Studio .NET 2003
Il existe également une édition Java qui prend en charge JBuilder, qui est vendu comme un produit séparé

Section
II
dix Manuel IntraWeb
2 Quoi de neuf
2.1 Aperçu
IntaWeb 7 introduit de nombreuses nouvelles fonctionnalités, notamment :
Conseils améliorés
Dans IW 7, il n'est plus nécessaire d'ajouter un caractère ESCAPE lors de l'utilisation du caractère guillemet simple (')
dans le texte de l'astuce.
Texte brut
Les contrôles TIWURL, TIWURL32, TIWLink, TIWHyperLink32 ont désormais la propriété RawText. Cette propriété fait
référence à la façon dont la légende de ces contrôles est rendue au format HMTL. Pour plus d'informations sur la
propriété RawText, veuillez consulter le guide de référence.
Contrôle TIWtreeView amélioré

La propriété Font du contrôle TIWTreeView contient maintenant un membre CSSStyle, qui peut être modifié
chez le concepteur.
Détection de navigateur inconnu

Dans IntaWeb 7, les fonctions de détection de navigateur inconnu au niveau du formulaire ainsi qu'au niveau du serveur. Cette
signifie que, lorsqu'un navigateur inconnu ou non pris en charge est détecté au niveau du formulaire, l'application
redirigera vers l'URL spécifiée dans le contrôleur de serveur's propriété UnknownBrowser.
Délai d'expiration de la session individuelle
Dans IntaWeb 7, lorsqu'une session est démarrée, son délai d'expiration est par défaut celui du global, défini dans le
contrôleur de serveur. (Pour plus d'informations sur le délai d'expiration de la session dans le contrôleur de serveur, reportez-
vous à TIWServerControllerBase.SessionTimeout dans le Guide de référence.) Plus tard, le délai d'expiration de la session peut
être défini individuellement.
Propriété DeviceNotSupported dans le contrôleur de serveur

Lorsqu'un périphérique non pris en charge est accédé (comme un PDA avec un périphérique WML), l'application
redirige vers l'emplacement spécifié par cette propriété, et si la propriété est laissée vide, une exception avec
le message "Périphérique non pris en charge" s'affiche.
Petits changements:
· La propriété ConvertSpaces de TIWCustomText et TIWCustomText32 est définie par défaut sur false.
La propriété ConvertSpaces indique si les espaces contenus dans le texte du contrôle doivent être
rendus comme ' ' ou ignorés.
Fonctionnalités introduites dans 6 :
· Mise à jour partielle/progressive de la page

· Régions défilantes
· Simulation de connexion lente
· Redimensionnement côté serveur
· Traitement des fichiers IWP
· Modèles/sous-modèles avec TIWRegion et TFrame
· SSL à la demande
· . NET Common Code Base
· Compression HTTP
· Améliorations pour aligner/ancrer
· Taille de la police mesurée en pixels, au lieu de points

Quoi de neuf 11
· Entrée RVB dans l'éditeur de propriétés de couleur
2.2 Prise en charge des PDA
Intraweb 5.1 introduit la prise en charge des appareils portables (appelés désormais PDA). En utilisant HTML 3.2 et
aucun JavaScript ou CSS supplémentaire, IntaWeb vous permet de développer des applications robustes et efficaces
pour tout appareil PDA compatible HTML 3.2.
Les composants HTML 3.2 suivants sont désormais disponibles :

· TIWLabel32 - contrôle des étiquettes
· TIWEdit32 - boîte d'édition
· TIWBouton32 - bouton poussoir

· TIWList32 - Liste HTML
· TIWHRrègle32 - Règle horizontale HTML
· TIWListBox32 - contrôle des listbox
· TIWComboBox32 - contrôle combobox
· TIWRadioGroup32 - contrôle de groupe radio
· TIWImage32 - contrôle des images
· TIWImageFile32 - contrôle des fichiers images
· TIWURL32 - contrôle des liens
· TIWGrid32 - contrôle du réseau
· TIWMemo32 - contrôle mémo (zone de texte HTML)

· TIWText32 - contrôle de texte
· TIWRectangle32 - contrôle rectangle

· TIWCheckBox32 - contrôle des cases à cocher
· TIWHyperLink32 - contrôle des liens
· TIWDBEdit32 - boîte d'édition sensible aux données
· TIWDBCheckBox32 - case à cocher sensible aux données
· TIWDBCboBox32 - combobox sensible aux données
· TIWDBLabel32 - contrôle d'étiquette sensible aux données
· TIWDBListBox32 - contrôle de listbox sensible aux données
· TIWDBLookupComboBox32 - combobox sensible aux données utilisée pour les recherches sur le terrain
· TIWDBLookupListBox32 - listbox sensible aux données utilisée pour les recherches sur le terrain
· TIWDBMemo32 - contrôle de mémo sensible aux données (zone de texte HTML)
· TIWDBText32 - contrôle de texte sensible aux données
· TIWDBImage32 - contrôle d'image sensible aux données
· TIWDBRadioGroup32 - contrôle de groupe radio sensible aux données
· TIWTemplateProcessorHTML32 - processeur de modèles pour les modèles HTML

· TIWPageProducer32 - producteur de pages utilisé pour travailler avec WebSnap en mode page
· TIWLayoutMgrHTML32 - gestionnaire de mise en page

Section
III
Guide de migration 13
3 Guide de migration
Les guides de migration IntraWeb sont conservés à des fins historiques. Si vous effectuez une mise à niveau à partir d'anciennes
versions, vous devez lire chaque ensemble de notes pour chaque version.
Sauvegardez toujours vos projets avant de tenter des conversions. Prévoyez également toujours suffisamment de temps pour les
conversions.
3.1 6,0 à 7,0

La mise à niveau vers IntraWeb 7.0 à partir de la version 6.0 prend moins de 5 minutes pour la plupart des projets. Chargez simplement le
contrôleur de serveur au moment de la conception et cliquez sur « Ignorer ». Maintenant, enregistrez et recompilez. À moins que vous n'utilisiez
la propriété TimeOutURL, aucune autre couverture n'est requise.
La propriété TimeOutURL devient SessionTimeOutURL

La propriété TimeOutURL du contrôleur de serveur change son nom en SessionTimeOutURL et n'est plus
de type chaîne, mais TIWFileReference.
Session utilisateur visuelle

IntaWeb 7 introduit l'objet de session utilisateur visuel. L'objet session utilisateur est créé par l'assistant de projet
IntaWeb et il s'agit en fait d'un module de données. Certains des avantages de cette approche sont :
· les composants nécessaires à la session utilisateur peuvent être ajoutés directement en les déposant sur le formulaire.
· il peut être utilisé comme module de données, et toute la gestion de session est effectuée par l'application
· de nouvelles méthodes et membres peuvent être ajoutés à la session utilisateur, comme auparavant.
Les objets de session utilisateur précédents sont toujours compatibles avec IntaWeb 7, il n'est donc pas nécessaire de mettre à jour la
session utilisateur vers le nouveau type, sauf si vous souhaitez tirer parti des nouvelles fonctionnalités.
Noter: Bien que la nouvelle session utilisateur puisse fonctionner comme un module de données, lors de l'utilisation du pool de modules de données, un
module de données est toujours créé.
3.2 5.1 à 6.0

Modifications requises lors de la mise à niveau de 5.1 à 6.0 :
La propriété BGColor
Pour une utilisation plus facile et intuitive, les propriétés BackgroundColor du formulaire (TIWForm) et des
cellules de la grille dynamique (TIWDynGrid) ont été renommées en BGColor. Le nom BGColor a été choisi car il
est utilisé pour les couleurs d'arrière-plan dans tous les composants d'IntaWeb.
Lors du chargement des formulaires, le contenu de l'ancienne propriété BackgroundColor sera perdu et vous devrez à nouveau définir
la couleur souhaitée dans la propriété BGColor. La même chose s'applique lors du chargement de formulaires contenant des contrôles
TIWDynGrid.
Projets ISAPI
Ce changement a été introduit dans les dernières étapes de 5.1. Pour les nouvelles applications, l'assistant
créer automatiquement le bon DPR automatiquement. Cependant, pour les projets existants, vous devez
ajouter le code suivant à votre fichier DPR (surligné en gras) :
ISAPIApp,
IWINitISAPI,
Contrôleur de serveur dans 'ServerController.pas' {IWServerController : TIWServerController}, Unité 1 dans '
Unité1.pas' {IWForm1 : TIWFormModuleBase};
{$R *.RES}

14 Manuel IntraWeb
exportations
Obtenir la version d'extension,
HttpExtensionProc,
TerminerExtension ;
Cadres
Vous devez convertir les formulaires TFrame existants en cadres IntaWeb. Pour ce faire, créez un nouveau cadre
IntaWeb à l'aide de l'assistant de projet puis coupez et collez vos composants sur le nouveau cadre. Vous trouverez
plus d'informations sur la création d'un cadre IntaWeb dans leCadre IntaWeb chapitre de ce manuel.
3.3 5,0 à 5,1

Modifications requises lors de la mise à niveau de 5.0 à 5.1 :
Dans la mesure du possible, les interfaces sont restées les mêmes. Cependant, dans certaines situations, il a été jugé
préférable de changer d'interface pour une extension future.
Pour la plupart, la migration d'une application 5.0 vers 5.1 est simple et cette section est conçue pour vous
aider dans cette migration.
URLBase
Pour utiliser URLBase, vous devez y accéder viaWebApplication.AppURLBase
TIWImage
La propriété UseBorder a été dépréciée. La nouvelle propriété BorderOptions doit être utilisée à la
place.
RWebApplication
RWebApplication est maintenant simplement WebApplication. La portée détermine si cette version de threadvar ou la
version de propriété est accessible.
Fichiers de projet
Les fichiers de projet ont un nouveau format et les exécutables de débogage autonomes sont désormais des projets
distincts des exécutables de service autonomes. Des exemples de chacun peuvent être vus en regardant le Guess
démo.
Un nouveau fichier de projet autonome devrait ressembler à ceci :
programme Deviner;
les usages
Formes,
IWMain,
Principale dans 'Pas.principale' {formMain : TIWFormModuleBase}, contrôleur de serveur dans '
ServerController.pas' {IWServerController : TDataModule};
{$R *.res}
commencer
Application.Initialiser;
Application.CréerFormulaire(TFormIWMain, formIWMain);
Application.Exécuter ;
finir.
Lors de la conversion des applications de service, vous devez ajouter IWINitService à la les usages clause du DPR et
remplacer le code existant par :
programme GuessService;

Guide de migration 15
les usages
IWINitService,
{$R *.res}
commencer
IWRun;
finir.
Les projets ISAPI et DSO ont la disposition suivante (fichier DPR) :
ISAPI
une bibliothèque DevinezDLL;
les usages
IWINitISAPI,
{$R *.RES}
commencer
IWRun;
finir.
GRD
une bibliothèque DevinezDSO;
les usages
ApacheApp,
IWINitApache,
Contrôleur de serveur dans 'ServerController.pas' {IWServerController :
TIWServerControllerBase},
Principale dans 'Pas.principale' {formMain : TIWFormModuleBase};
{$R *.res}
exportations
apache_module Nom 'DevinezDSO_module';
commencer
IWRun;
finir.
Lors de la compilation pour Apache 2, vous devez vous assurer que vous incluez IWInitApacheTwo dans la clause uses
par opposition à IWInitApache. Si vous créez une application Apache 2 à l'aide de l'assistant, cela est automatique.
REMARQUE: Vous devez apporter les modifications appropriées à la VCL Delphi 7 avant que vos modules ne fonctionnent avec Apache 2.
Ces informations peuvent être obtenues sur le site Web de Dr. Bob à l'adresse
http://www.drbob42.com/Delphi7/Apache2040.htm
Paramétrage du formulaire principal et du contrôleur de serveur

Pour tous types de projets (Standalone, ISAPI, DSO, Service), deux initialisation des sections doivent être ajoutées.
Le premier doit être dans la forme principale du projet et indique quelle forme est la forme principale
former. Par exemple, pour le projet Guess, ce serait :
initialisation
TformMain.SetAsMainForm;
SetAsMainForm est une procédure de classe d'un TIWForm. Lorsque vous travaillez sur des projets qui prennent en charge
à la fois HTML 4.0 et PDA (HTML 3.2), il est TRÈS IMPORTANT que le formulaire principal pour la version 4.0 et la version 3.2
aient chacun une section d'initialisation indiquant qu'il s'agit du formulaire principal (voir

16 Manuel IntraWeb
GuessMulti pour des exemples).
L'autre section d'initialisation concerne le contrôleur de serveur. Cela doit être défini dans le
ServerController lui-même et il est présent pour les nouveaux projets :
initialisation
TIWServerController.SetServerControllerClass;
Ici SetServerControllerClass est à nouveau une procédure de classe de IWServerControllerBase.
SurNouvelleSession
Le gestionnaire d'événements OnNewSession a un changement dans la signature. La nouvelle signature est :
OnNewSession(ASession : TIWApplication ; var VMainForm : TIWBaseForm);
Assurez-vous d'inclure IWBaseForm et IWBaseControl dans le les usages clause de la Contrôleur de serveur en cas de conversion
à partir d'une version précédente.
Propriétaires de session et de module de données

Dans les versions précédentes (antérieures à 5.1), le propriétaire de la session était Une session puis le propriétaire du
DataModule (le cas échéant) serait APropriétaire. Dans 5.1, ceux-ci ont changé ennéant pour le premier et Soi pour le dernier.
Propriétés obsolètes sur les formulaires

Il est recommandé que lorsque vous ouvrez un projet déjà réalisé dans des versions antérieures à 5.1, vous
à travers tous les
formulaires et ignorez les propriétés inexistantes avant de compiler votre application.
Propriété TemplateProcessor
Cette propriété a été renommée en LayoutMgr. Attribuez tous les composants TemplateProcessor de votre formulaire
à ce
nouvelle propriété
Chemin d'application
Dans les versions précédentes d'IW, vous deviez utiliser gsAppPath pour obtenir le chemin de l'application. A partir de 5.1 vous
peut utiliser WebApplication.ApplicationPath pour l'obtenir.
TIWFichier
Pour obtenir la taille d'un fichier, vous ne pouvez plus accéder à la propriété Size du flux de fichiers. A la place tu
devra l'obtenir en utilisant la méthode suivante:
THTTPFiles(WebApplication.FileList).GetSize(IWFile1.Name)
Où IWFile1 est le contrôle TIWFile utilisé pour transférer le fichier.

Section
IV
18 Manuel IntraWeb
4 Installation
4.1 Installation des clés de licence
Le téléchargement pour les utilisateurs enregistrés avec des clés de licence est le même que l'édition d'évaluation. Si vous avez
déjà installé l'édition d'évaluation, il vous suffit d'entrer votre clé de licence à l'aide de l'utilitaire d'enregistrement. L'utilitaire
d'enregistrement peut être exécuté à partir de son icône dans le groupe de programmes IntaWeb.
4.2 Visual Studio.Net

Le programme d'installation intègre automatiquement IntaWeb dans l'environnement Visual Studio. Ce qui suit
des onglets sont ajoutés à la boîte à outils : "Contrôles Intraweb", "Contrôles BD Intraweb", "Composants Intraweb",
"My IW User Controls". L'onglet "Intraweb Controls" contient les contrôles IntaWeb standard, l'onglet "Intraweb DB
Controls" contient les contrôles Intraweb orientés données, l'onglet "Intraweb Components" contient les composants
des gestionnaires de mise en page et l'onglet "My IW User Controls" contient les contrôles définis par l'utilisateur .
Les applications Intraweb doivent être créées à l'aide de l'assistant d'application Intraweb accessible depuis la fenêtre
Nouveaux projets de Visual Studio .NET.
Pour les deux environnements, le programme d'installation crée également des groupes de programmes, auxquels vous pouvez accéder via le
menu Démarrer. La documentation est placée dans ce groupe de programmes.
4.3 Générateur Delphi/C++
L'installation intégrera automatiquement IntaWeb dans Delphi. Six nouveaux onglets seront créés sur la palette de
composants contenant les composants IntaWeb. L'un d'eux contient les composants non liés à la base de données (IW
Standard), un autre contient les composants orientés données (IWData), le troisième contient les composants de contrôle (IW
Control), le quatrième onglet est destiné aux contrôles côté client (IWClient Side), le cinquième onglet est pour les composants
HTML 3.2 non-base de données (IW standard 3.2) et le sixième est pour les données HTML 3.2-
composants conscients (IWData 3.2). Un nouvel onglet sera également créé dans le référentiel Delphi. Toutes les
applications IntaWeb doivent être créées à l'aide des modèles contenus dans le référentiel sous l'onglet IntaWeb.
Le processus d'installation copie les fichiers appropriés dans le répertoire Windows\System et dans les sous-
dossiers de tous les environnements Delphi sélectionnés.
4.4 Kylix
Veuillez consulter les instructions d'installation de Linux qui sont liées à la page de téléchargement IntaWeb.
4.5 Mise à niveau vers une nouvelle version
Avant de passer à une nouvelle version :
Pour Delphes :
1. Désinstallez les versions précédentes d'IntaWeb

2. Assurez-vous que vous n'avez pas de fichiers restants sur votre système. Vérifier:
· Intra*.bpl
· Intra*.dcp
· IW*.*
3. Supprimez tous les fichiers trouvés à l'étape 2. Assurez-vous de vérifier l'ensemble de votre système.
4. Installez la nouvelle version d'IntaWeb

Installation 19
Pour Visual Studio .NET :
1. Désinstallez la version précédente d'Intraweb pour .NET.
4.5.1 Utilisateurs de Delphi 7
Si vous utilisez la version d'IntaWeb incluse dans Delphi 7 et que vous avez droit à une mise à niveau (de la
version incluse à la version 5.1), vous devez effectuer les étapes suivantes pour installer IntaWeb :
1. Désinstallez la version incluse dans Delphi 7

2. Générez une nouvelle demande de clé en utilisant l'application de demande de clé disponible sur le site
Web d'Atozed (www.atozedsoftware.com).
3. Installez la nouvelle version et entrez la clé obtenue à l'étape 2.

Section
V
Démos 21
5 Démos
5.1 Démarrage rapide
Jusqu'à ce que vous soyez prêt à déployer, vous devez utiliser les versions autonomes pour le développement et les
tests. À des fins d'évaluation, vous devriez commencer par la démo la plus simple, « Devinez ». Guess est une démo
très simpliste (Notre version de "Hello World"), mais vous présentera IntaWeb avec une application simple. Après
que vous pouvez ensuite regarder les autres démos pour voir les fonctionnalités plus avancées d'IntaWeb.
La plupart des démos d'Intraweb pour Delphi ont plusieurs fichiers de projet tels que Features / FeaturesDLL /
FeaturesDSO. Features est la version autonome, FeaturesDLL est la version ISAPI et FeaturesDSO est la version
Apache. Ce sont des fichiers de projet différents mais partagent les mêmes unités et
mis à part le fichier projet, le code source est identique. Enfin, vous pouvez terminer avec la démo "Fonctionnalités" qui
n'est pas une application "fonctionnelle" en soi mais une démo qui démontre de nombreuses fonctionnalités d'IntaWeb
simplement pour les démontrer.
Il existe également des sources et des démos supplémentaires fournies par les utilisateurs disponibles sur la page de
téléchargement IntaWeb sur le site Web d'Atozed.
5.2 Construire une démo étape par étape
Ce chapitre suivra pas à pas le développement d'une démo simple pour Intraweb. La démo s'appelle FormData et
montre commentFormulaires IntaWeb peuvent interagir les uns avec les autres lors d'un session.
La description
FormsDemo est une application simple qui a deux écrans : le premier affiche une modification et un bouton. Cliquer sur
le bouton ouvrira le deuxième écran qui montre toutes les données saisies dans le champ d'édition du premier
formulaire et le nombre de fois que l'utilisateur a visité le deuxième écran. Il s'agit d'une application autonome
développée avec IntaWeb.
Comment fonctionne l'application autonome ?
Une application autonome est un exécutable qui écoute sur le port défini par l'utilisateur et renvoie les
pages HTML.
IntaWeb peut créer ce type d'applications. Les formulaires IntaWeb ajoutés au projet et les contrôles qu'il contient
seront rendus sous forme de contenu HTML et servis au navigateur.
Création d'une application FormData dans Delphi
Dans le menu Delphi, choisissez Fichier|Nouveau|Autre... .Dans la fenêtre Nouveaux éléments, choisissez l'onglet IntaWeb.
Pour créer une nouvelle application, sélectionnez l'icône IntaWeb Application Wizard puis cliquez sur OK :

22 Manuel IntraWeb
Vous serez invité avec une fenêtre qui permet la sélection de différents types d'applications. Choisissez
l'application autonome :
Après avoir terminé ces étapes, la nouvelle application aura la configuration par défaut : un fichier de
projet nommé Project1 et Unit1.pas et IWUnit.dfm, un formulaire vide.
Remplacez le nom du projet par FormData et le nom du formulaire par formMain. Maintenant, sur ce
form, ajoutez à partir de la palette IW Standard, un TIWEdit, un TIWLabel, un TIWButton et un TIWLink. Au moment de
l'exécution, ces contrôles seront rendus sous forme de balises HTML standard, afin qu'ils puissent être interprétés par le
navigateur comme n'importe quel fichier HTML. Le composant TIWEdit sera rendu comme une balise INPUT avec type='text',

Démos 23
le composant TIWLabel sera rendu comme une balise SPAN, le composant TIWButton sera un INPUT avec
type='button' et le composant TIWLink sera rendu comme une balise d'ancrage.
Finalement, le formulaire doit ressembler à ceci :
Ensuite, ajoutez un nouveau formulaire au projet depuis le menu Delphi. Sélectionnez Fichier|Nouveau|Autre... . Dans la fenêtre Nouveaux
éléments, sélectionnez l'icône Nouveau formulaire. L'assistant de création de formulaire apparaîtra :
Sélectionnez le bouton radio Formulaire de demande, puis appuyez sur ok. Nommez le formulaire nouvellement
créé formDialog et ajoutez-y les composants suivants : un TIWMemo, un TIWLabel et un TIWLink. Nommez le
composant TIWLabel lblCount et le TIWLink lnkReturn.
Modifiez les propriétés Caption du TIWLabel et du contrôle TIWLink, de sorte que le formulaire ressemble à ceci :

24 Manuel IntraWeb
Au moment de l'exécution, les contrôles seront rendus sous forme de balises HTML, comme expliqué précédemment. Le
composant TIWMemo devient une balise TEXTAREA.
Maintenant, ajoutez un membre public à la classe TformMain de type TFormDialog :
FDialogForm : TformDialog ;
Et un membre public de la classe TformDialog :
FCount : nombre entier ;
L'étape suivante consiste à ajouter un gestionnaire d'événements pour le composant TIWButton. Pour ajouter un gestionnaire d'événements à un
Composant IntaWeb, procédez comme pour tout composant Delphi : ouvrez la fenêtre de l'inspecteur d'objets et
choisissez l'onglet Evénements. La classe TIWButton a deux événements publiés :
· Sur clic événement : déclenché lorsque l'utilisateur clique sur le bouton dans la fenêtre du navigateur
· OnHTMLTag événement : déclenché lorsque IntaWeb crée la balise sous laquelle le contrôle est rendu. Cet événement
est utilisé pour ajouter des attributs facultatifs à la balise rendue.
Dans cette démo, écrira seulement le Sur clic gestionnaire d'événements. Il affichera le FDialogForm, le
formulaire qui affichera le nombre de fois qu'il a été affiché et le texte saisi dans le composant TIWEdit de
la forme principale.
Voici le code qui accomplit ceci :
procédure TformMain.butnOkClick(Sender: TObject); var
s : chaîne ;
commencer
s := Trim(editText.Text);
editText.Text := '';
si s = '' alors commencer
{ accédez au deuxième formulaire uniquement si du texte a été saisi }
WebApplication.ShowMessage('Veuillez entrer du texte.'); fin sinon
commencer

Démos 25
avec FDialogForm, commencez

{ ajouter du texte modifié au mémo }
IWMemo1.Lines.Add(s);
{ augmenter le nombre de fois où le formulaire a été affiché }
Inc(FCount);
{ afficher le formulaire }
Spectacle;
finir;
finir;
finir;
Notez qu'avant d'appeler la procédure butnOnClick, le FDialogForm doit être initialisé. Cela se fait dans
l'événement OnCreate du formulaire principal :
procédure TformMain.IWAppFormCreate(Sender: TObject);

commencer
FDialogForm := TformDialog.Create(WebApplication);
finir;
Jusqu'à présent, la navigation entre le TformMain et le TformDialog a été développée, et nous devons
écrire le code qui affiche le nombre de fois que l'utilisateur a visité le deuxième écran et le code qui
redirigera l'utilisateur vers le formulaire principal.
Tout d'abord, ajoutez le gestionnaire d'événements OnRender pour TformDialog. L'événement OnRender est utilisé lorsque
les utilisateurs souhaitent interagir avec le processus de rendu. Le processus de rendu est celui qui génère le HTML, à partir
du formulaire IntaWeb et des contrôles qui s'y trouvent. Utilisez les mêmes étapes pour ajouter ce gestionnaire
d'événements que pour le composant TIWButton.
procédure TformDialog.IWAppFormRender(Sender: TObject); commencer
lablCount.Caption := 'Ce formulaire a été affiché ' + IntToStr(FCount) + ' fois.'; finir;
Ce code modifie la légende de lablCount. Ajoutez ensuite le

code pour l'événement OnClick de lnkReturn.
procedure TformDialog.linkReturnClick(Sender: TObject);

commencer
Cacher;
finir;
Pourquoi ce code fonctionne-t-il ? Lorsque vous souhaitez afficher un formulaire, vous devez appeler sa méthode Show. Pour
masquant un formulaire, appelez sa méthode Hide. Que se passe-t-il avec les formes en mémoire ? Ils sont
conservés dans une pile, en fonction du moment où ils ont été créés. Lorsque vous masquez le formulaire du haut
de la pile, celui créé avant est affiché.
Tester l'application
Vous pouvez tester votre application comme n'importe quelle autre application Delphi. Vous verrez une boîte de dialogue semblable à celle-ci :

26 Manuel IntraWeb
Appuyez sur F9 pour commencer à tester votre application.

Vous pouvez activer la sortie de débogage en appuyant sur le bouton lunettes de la barre d'outils. Ensuite, dans la partie gauche de la
fenêtre, vous verrez les identifiants de session, les appels aux fonctions JavaScript, etc.
Déploiement de l'application
L'application sera un exécutable autonome et la seule chose côté serveur dont vous aurez besoin pour
exécuter votre application. Vous n'avez même pas besoin d'un serveur Web d'aucune sorte, car autonome
les applications intègrent un serveur Web.
Création d'une application FormData dans Visual Studio .NET
Dans le menu Visual Studio, choisissez Fichier|Nouveau|Projet... .Dans la fenêtre Nouveau projet, choisissez
Projets Visual C# et Application autonome Intraweb.

Démos 27
Choisissez un nom pour le nouveau projet et cliquez sur OK. Sur le formulaire principal créé, ajoutez à partir de l'élément de la boîte
à outils Intraweb Controls une édition, une étiquette de texte, un bouton et un lien. A l'exécution, ces contrôles seront
rendus sous forme de balises HTML standard, afin qu'ils puissent être interprétés par le navigateur comme
n'importe quel fichier HTML. Le composant Edit sera rendu comme une balise INPUT avec type='text', le composant
TextLabel sera rendu comme une balise SPAN, le composant Button sera une INPUT avec type='button' et le
composant Link sera rendu comme un balise d'ancrage.
Finalement, le formulaire doit ressembler à ceci :
Ensuite, ajoutez un nouveau formulaire au projet à partir du menu Visual Studio .NET. Sélectionnez Fichier|Ajouter un nouvel élément... . Dans la
fenêtre Ajouter un nouvel élément, sélectionnez Formulaire Intraweb.

28 Manuel IntraWeb
L'assistant de création de formulaire apparaîtra :
Sélectionnez le bouton radio HTML 4.0, puis appuyez sur le bouton intitulé Créer. Nommez le formulaire
nouvellement créé FormDialog et ajoutez-y les composants suivants : un Memo, un TextLabel et un Link. Nom
le composant TextLabel lblCount et le Link lnkReturn.
Modifiez les propriétés Caption du contrôle Label et Link, de sorte que le formulaire ressemble à ceci :

Démos 29
Au moment de l'exécution, les contrôles seront rendus sous forme de balises HTML, comme expliqué précédemment. Le composant
Memo devient une balise TEXTAREA.
Maintenant, ajoutez un membre public à la classe FormMain de type FormDialog :
privé FormDialog formDialog = Nouveau FormDialog();
Et un membre public de la classe TformDialog :
Publique Nombre Int32 = 0 ;
L'étape suivante consiste à ajouter un gestionnaire d'événements pour le composant Button : dans l'onglet Propriétés du contrôle
Button, sélectionnez Events.
Il y aura deux éléments pour l'onglet Événements :
· Sur clic événement : déclenché lorsque l'utilisateur clique sur le bouton dans la fenêtre du navigateur
· OnHTMLTag événement : déclenché lorsque IntaWeb crée la balise sous laquelle le contrôle est rendu. Cet événement
est utilisé pour ajouter des attributs facultatifs à la balise rendue.
Dans cette démo, écrira seulement le Sur clic gestionnaire d'événements. Il affichera le FDialogForm, le
formulaire qui affichera le nombre de fois qu'il a été affiché et le texte saisi dans le composant Edit du
forme principale.
Voici le code qui accomplit ceci :
void privé btnOk_OnClick (expéditeur d'objet, System.EventArgs e) {
chaîne s = "";
if (editText.Text != null) {
s = editText.Text.Trim();
}
si ("" == s) {
WebApplication.ShowMessage("Veuillez saisir du texte.");
}
autre {
formDialog.GetMemoControl().Lines.Add(s);

30 Manuel IntraWeb
formDialog.Count += 1;
formDialog.Show();
}
}
Jusqu'à présent, la navigation entre le FormMain et le FormDialog a été développée, et nous devons
écrire le code qui affiche le nombre de fois que l'utilisateur a visité le deuxième écran et
le code qui redirigera l'utilisateur vers le formulaire principal.
Tout d'abord, ajoutez le gestionnaire d'événements OnRender pour FormDialog. L'événement OnRender est utilisé lorsque les
utilisateurs souhaitent interagir avec le processus de rendu. Le processus de rendu est celui qui génère le HTML affiché dans le
navigateur, à partir du formulaire IntaWeb et des contrôles qui s'y trouvent. Utilisez les mêmes étapes pour
en ajoutant ce gestionnaire d'événement comme pour le composant Button.
vide privé FormDialog_OnRender(objet Expéditeur) {
lblCount.Caption = String.Format("Ce formulaire a été affiché {0} fois", Count);

}
Ce code modifie la légende de lablCount. Ajoutez ensuite le

code pour l'événement OnClick de lnkReturn.
void privé lnkReturn_OnClick (expéditeur d'objet, System.EventArgs e) {
Cacher();
}
Pourquoi ce code fonctionne-t-il ? Lorsque vous souhaitez afficher un formulaire, vous devez appeler sa méthode Show.
Pour masquer un formulaire, appelez sa méthode Hide. Que se passe-t-il avec les formes en mémoire ? Ils sont conservés
dans une pile, en fonction du moment où ils ont été créés. Lorsque vous masquez le formulaire du haut de la pile, celui créé
avant est affiché.
Tester l'application
Vous pouvez tester votre application comme n'importe quelle autre application Visual Studio .NET. Vous verrez une boîte de dialogue
semblable à celle-ci :

Démos 31
Appuyez sur F9 pour commencer à tester votre application.

Vous pouvez activer la sortie de débogage en appuyant sur le bouton lunettes de la barre d'outils. Ensuite, dans la partie gauche de la
fenêtre, vous verrez les identifiants de session, les appels aux fonctions JavaScript, etc.
Déploiement de l'application
L'application sera un exécutable autonome, qui nécessite le framework NET 1.1.
5.3 Caractéristiques
Cette démo est disponible uniquement pour Intraweb pour Delphi.
La démo des fonctionnalités n'est pas conçue comme une application fonctionnelle. Il est conçu comme une démo pour montrer les
fonctionnalités spécifiques d'IntaWeb. Utilisez cette démo pour voir comment utiliser des fonctionnalités spécifiques dans IntaWeb, mais aussi
pour voir certaines des choses qu'IntaWeb peut faire.
5.4 Deviner
Guess est une application très simple et ne contient qu'un seul formulaire. C'est cependant la démo de démarrage idéale pour
comprendre le fonctionnement d'IntaWeb. La démo sert de simple deviner le jeu de nombres.

32 Manuel IntraWeb
5.5 DevinerWB
Cette démo est disponible uniquement pour Intraweb pour Delphi. DevinezWB est leDeviner application
implémentée en mode page au lieu du mode application.
5.6 DevinezMulti
GuessMulti est une démo qui prend en charge simultanément les navigateurs normaux ainsi que les PDA dans un seul
exécutable.
5.7 PoissonFait
FishFact est un port IntaWeb du populaire Delphi Demo FishFact. Cette démo nécessite DBDemos.
5.8 FishFactDM
FishFactDM est identique à la démo FishFact, mais montre comment utiliser les Datamodules avec IntaWeb.
FishFactDM montre également comment présenter une grille paginée. Cette démo nécessite DBDemos.
5.9 Profileur de clients Phenitics

Phonetics Customer Profiler est un exemple d'application qu'une entreprise de téléphonie mobile peut utiliser pour créer
des propositions personnalisées pour des clients potentiels et les aider à choisir le plan d'appel qui leur convient le mieux. La
démo n'utilise pas de base de données, mais elle montre comment suivre les informations, utiliser plusieurs formulaires et
modèles.
5.10 AutonomeSSL
StandAloneSSL montre l'utilisation du mode autonome avec une connexion SSL à l'aide d'exemples de
certificats.
5.11 WebSnapSurvey
L'enquête WebSnap montre comment utiliser le mode page IntaWeb avec WebSnap. Cette démo ne fonctionne que dans Delphi
6 Enterprise et supérieur car WebSnap est nouveau dans Delphi 6 et uniquement inclus dans Delphi Enterprise.
5.12 Autonome personnalisé
La démonstration autonome personnalisée montre comment implémenter un serveur autonome avec une interface
personnalisée à l'aide du composant IWStandAlone.

Traduit de Anglais vers Français - www.onlinedoctranslator.com
32 Manuel IntraWeb
5.5 DevinerWB
Cette démo est disponible uniquement pour Intraweb pour Delphi. DevinezWB est leDeviner application
implémentée en mode page au lieu du mode application.
5.6 DevinezMulti
GuessMulti est une démo qui prend en charge simultanément les navigateurs normaux ainsi que les PDA dans un seul
exécutable.
5.7 PoissonFait
FishFact est un port IntaWeb du populaire Delphi Demo FishFact. Cette démo nécessite DBDemos.
5.8 FishFactDM
FishFactDM est identique à la démo FishFact, mais montre comment utiliser les Datamodules avec IntaWeb.
FishFactDM montre également comment présenter une grille paginée. Cette démo nécessite DBDemos.
5.9 Profileur de clients Phenitics

Phonetics Customer Profiler est un exemple d'application qu'une entreprise de téléphonie mobile peut utiliser pour créer
des propositions personnalisées pour des clients potentiels et les aider à choisir le plan d'appel qui leur convient le mieux. La
démo n'utilise pas de base de données, mais elle montre comment suivre les informations, utiliser plusieurs formulaires et
modèles.
5.10 AutonomeSSL
StandAloneSSL montre l'utilisation du mode autonome avec une connexion SSL à l'aide d'exemples de
certificats.
5.11 WebSnapSurvey
L'enquête WebSnap montre comment utiliser le mode page IntaWeb avec WebSnap. Cette démo ne fonctionne que dans Delphi
6 Enterprise et supérieur car WebSnap est nouveau dans Delphi 6 et uniquement inclus dans Delphi Enterprise.
5.12 Autonome personnalisé
La démonstration autonome personnalisée montre comment implémenter un serveur autonome avec une interface
personnalisée à l'aide du composant IWStandAlone.

Démos 33
5.13 Bouton Retour
La démonstration Back Button montre comment utiliser l'événement OnBackButton du IWServerController pour activer la
fonctionnalité de bouton de retour dans le navigateur.
5.14 Formulaires de pages
PageForms est une démo simple qui vous montre comment implémenter l'application PageMode à l'aide de
WebBroker. Pour plus d'informations, voir la section PageMode dans le manuel
5.15 Marché aux poissons
FishMarket montre comment utiliser la commande Re-Entry en combinaison avec le suivi des cookies pour vous permettre de
quitter et de réentrer une application IW en transmettant des paramètres sur l'URL.
5.16 Meurs, vole ! Mourir !
Meurs, vole ! Mourir ! est une démo complexe qui démontre à la fois les techniques de base et avancées à utiliser avec
IntaWeb.
La démo est une boutique virtuelle, où les utilisateurs peuvent acheter divers produits anti-mouches, allant d'une tapette à mouches
à une bombe nucléaire.
Cette démo est une réplique de la démo ASPX bien connue IBuySpy de Microsoft, et elle montre à quel point des tâches
complexes peuvent être facilement effectuées avec IntaWeb, sans écrire une seule ligne de code HTML ou JavaScript.
La démo fait un usage intensif des bases de données, et à cette fin, le moteur DBISAM d'Elevate Software a été
choisi pour l'implémentation Delphi et MSDE pour la version .NET. Afin de compiler et d'exécuter la démo Delphi,
vous aurez besoin d'obtenir une copie de DBISAM. Une version d'évaluation ainsi que la version complète
peuvent être obtenues sur leur site Web à l'adressehttp://www.elevatesoftware.com. Obtenir
les meilleurs résultats, assurez-vous de télécharger la dernière version du moteur. Pour exécuter la démo
Visual Studio .NET 2003, vous devez installer le MSDE sur votre machine et restaurer la base de données à
partir du fichier de sauvegarde fourni avec la démo.
Pourquoi DBISAM ?
De longues discussions ont eu lieu avant de choisir ce moteur. Le choix est basé sur ces faits :
· c'est rapide
· il a un faible encombrement
· il se compile dans l'exécutable ou la dll et ne nécessite pas de composants supplémentaires
· est entièrement conforme à SQL 99
· l'installation prend très peu de temps
Code source
Code source de Die, Fly ! Mourir ! a été écrit dans le but de servir de tutoriel de programmation pour les utilisateurs d'IntaWeb.
En parcourant le code, vous pouvez découvrir comment utiliser les cadres, comment utiliser le
OnHTMLTag, comment programmer un panier, comment stocker des images dans une base de données et les récupérer

34 Manuel IntraWeb
à un formulaire et à d'autres trucs et astuces que les utilisateurs ont demandés au fil du temps.
5.17 WebMail32
WebMail32 est une démonstration puissante qui montre à quel point il est facile d'obtenir une application PDA complexe en utilisant IntaWeb.
Cette démo simule un expéditeur Web simpliste qui rend sa sortie au format HTML 3.2.
WebMail32 montre l'utilisation de plusieurs contrôles HTML 3.2, ainsi que l'utilisation de modèles statiques et
dynamiques avec IntaWeb et la création de composants dynamiques.
Inde
WebMail32 utilise le composant TIdPOP3, qui fait partie de la bibliothèque de composants Indy. Indy est une
bibliothèque de composants open source pour les protocoles et connexions Internet et est fournie avec Delphi 6 et
Delphi 7.
Vous pouvez également obtenir gratuitement la dernière version d'Indy sur http://www.indyproject.org.

Section
VI
36 Manuel IntraWeb
6 Débogage
6.1 Commencer
Lorsque vous utilisez le débogage en mode autonome, c'est le même que pour toute autre application Delphi ou Visual
Studio .NET. Réglez simplement vos points de rupture, vos montres, etc. et courez.
6.2 Sortie de débogage
Lors de l'exécution en mode autonome, vous pouvez activer la sortie de débogage pour voir les sessions créées, détruites et les
requêtes HTTP. Vous pouvez activer la sortie de débogage, vous pouvez sélectionner "Afficher les informations de débogage" à partir de
le menu fichier, ou appuyez sur le bouton de la barre d'outils qui a une icône des lunettes.
Voici une capture d'écran avec le bouton de la barre d'outils de débogage enfoncé et les informations de sortie de débogage d'une
session utilisateur :
6.3 Détection des erreurs au démarrage
Si des erreurs se produisent lors du démarrage d'une application, IntaWeb fermera l'application et enregistrera l'erreur dans
un fichier .err. Le nom de fichier de l'application avec une extension .err sera utilisé. Si vous rencontrez des difficultés pour
démarrer une application, recherchez un fichier .err associé. Le fichier .err est un fichier texte et peut être consulté
avec bloc-notes, ou edln.
Les erreurs qui se produisent en dehors du bloc de programme, telles que des packages requis manquants ou des DLL liées de manière statique,
ne peuvent pas être détectées et ne seront pas enregistrées dans le fichier .err.
6.4 Paramètres de ligne de commande
Lancement automatique du navigateur
Pour accélérer davantage le développement, vous pouvez ajouter "/LaunchBrowser" aux paramètres de l'application pour que le
programme lance automatiquement le navigateur à chaque exécution. Pour ce faire dans Delphi, sélectionnez l'élément de
menu Paramètres dans le menu Exécuter. Saisissez ensuite "/LaunchBrowser" dans le champ Paramètres. Les
la prochaine fois que vous exécuterez votre application, le navigateur sera automatiquement lancé. La même chose peut être
obtenue dans Visual Studio .NET en entrant "/LaunchBrowser" pour les arguments de ligne de commande

Débogage 37
dans les pages de propriétés du projet, section Propriétés de configuration/Débogage.
Réduire automatiquement
L'écran de débogage peut être dit pour démarrer minimisé en passant /minimize sur la ligne de commande. Ceci est utile
pendant le développement s'il est combiné avec /LaunchBrowser

Section
VII
Développement 39
7 Développement
7.1 Repenser l'interface utilisateur
De nombreuses personnes essaient de concevoir leurs applications Web exactement comme des applications normales. Si
vous essayez ceci, vous créerez des interfaces qui ne fonctionnent pas bien. Imaginez qu'une application Windows se
comporte comme une application DOS (WordPerfect l'a fait avec son port Windows initial). Ce serait une interface maladroite
n'est-ce pas ? Non seulement vous devez penser différemment à votre interface utilisateur pour le Web, mais vous devez
également réaliser que le Web a des limites et la conception qui les entoure.
Un exemple de ceci est DBGrids. Dans une application Delphi normale, il peut être considéré comme normal d'afficher
des centaines ou des milliers d'enregistrements dans une grille. Faire cela sur le Web créera de très gros
Documents HTML et temps de chargement très lents pour l'utilisateur.
Une fois que les développeurs s'en rendent compte, ils demandent souvent les boutons "Suivant" et "Précédent" et que le
DBGrid soit étendu pour permettre un affichage partiel. Bien que cela puisse être mis en œuvre, il faudrait
implémenté soit pour consommer de grandes quantités de mémoire sur le serveur, soit en exigeant en permanence la
base de données qui consommerait moins de mémoire mais serait lente. Au lieu de l'aborder comme une application
Delphi normale, repensez votre interface pour le Web.
Ce n'est certainement pas la seule possibilité, mais la technique suivante est courante. Au lieu de présenter
vos utilisateurs avec des milliers d'enregistrements au départ, présentez-leur une grille vierge et un champ de recherche. Exigez de vos
utilisateurs qu'ils présentent certains critères de base pour localiser les enregistrements dont ils ont besoin. En utilisant les critères de
recherche, vous pouvez ensuite renvoyer des dizaines, voire quelques centaines de lignes. Non seulement c'est bon pour la bande
passante, mais c'est une bonne interface utilisateur et cela réduira la charge sur votre base de données.
Permettre aux utilisateurs d'entrer des critères de recherche permet toujours la possibilité que les résultats se comptent
encore par milliers et causent le même problème que vous essayiez d'éviter. Pour vous aider, TIWDBGrid a une propriété
RowLimit. La valeur par défaut est 0, ce qui signifie qu'elle est désactivée. Vous pouvez le régler sur un
valeur maximale, et peu importe le nombre de lignes renvoyées par la requête, pas plus que le nombre dans
RowLimit ne sera renvoyé à l'utilisateur.
Si vous pensez à cela, vous avez probablement vu cette technique ailleurs. De nombreux moteurs de recherche limitent le nombre de
lignes renvoyées. Ce n'est pas seulement pour des raisons de bande passante. Dans la plupart des cas, les données
devient de moins en moins utile après un certain nombre. Dans les cas où ce n'est pas vrai, trop de données sont simplement
données à l'utilisateur en même temps et il les filtrera probablement de toute façon.
Si vous décidez toujours que vous voulez une "grille paginée" composée de petits ensembles de données avec suivant/précédent
options, vous pouvez y parvenir en définissant la propriété StartFirst de TIWDBGrid sur false et en définissant la propriété
RowLimit sur le nombre de lignes que vous souhaitez afficher à un moment donné. Ensuite, en positionnant le jeu de données
avant affichage, vous pouvez passer au suivant/précédent.
7.2 Rédiger votre première application IntraWeb
Utilisation de Delphi
Toutes les applications IntaWeb doivent être créées à l'aide de l'assistant d'application IntaWeb dans l'onglet IntaWeb du
référentiel. Cliquez sur Fichier -> Nouveau -> Autre puis choisissez l'onglet IntaWeb. Sélectionnez l'assistant d'application
IntaWeb. Cliquez enfin sur OK.
Cela crée un cadre pour une nouvelle application autonome IntaWeb. Bien que le projet puisse être
compilé et exécuté à ce stade, il ne fait rien. Le formulaire de débogage standard apparaît et affiche des
informations sur IW et des éléments de menu pour déboguer l'application. Sélection de l'exécution
(ou en appuyant sur la touche F9) l'élément de menu lancera le navigateur avec une page vierge. C'est parce que le principal

40 Manuel IntraWeb
Le formulaire ne contient pas encore de composants ou de fonctionnalités.
programme Projet 1;
les usages
Formes,
IWMain,
Contrôleur de serveur dans 'ServerController.pas' {IWServerController : TIWServerController}, Unité 1 dans '
Unité1.pas' {IWForm1 : TIWFormModuleBase};
{$R *.res}
commencer
finir.
Le code de la figure ci-dessus affiche le contenu du fichier de projet. Vous pouvez voir que c'est la même chose
qu'une application Delphi standard. Cela est vrai pour les applications autonomes.
Comme mentionné précédemment, le nouveau projet est le bloc de construction de base pour toute application IntaWeb.
Comme tout autre projet Delphi, un formulaire IntaWeb principal est créé et peut être utilisé comme formulaire principal de
l'application. Pour démontrer la puissance et la facilité des applications IW, ci-dessous, un petit exemple est montré.
1. Ouvrez l'IWForm par défaut (IWUnit1.pas) qui a été créé.

2. Déposez un TIWButton, TIWEdit et TIWLabel sur le formulaire sans ordre particulier.
3. Attribuez le code suivant à l'événement OnClick du bouton :
procédure TIWFormModule.IWButton1Click(Sender: TObject); commencer
IWLabel1.Caption := IWEdit1.Text; finir;
Une fois les étapes terminées, compilez et exécutez l'application. Pour le tester, appuyez sur la touche F9. Le navigateur
par défaut doit être lancé et afficher le formulaire principal. Entrez du texte dans la zone de texte et cliquez sur
le bouton. La sortie est affichée dans l'étiquette.
Utilisation de Visual Studio .NET
Pour créer une application IntraWeb.NET, choisissez Application autonome IntaWeb ou Application
IntaWeb ISAPI dans la fenêtre Nouveau projet de Visual Studio .NET. Sélectionnez les options par défaut
dans l'assistant et vérifiez le code généré par l'assistant pour le point d'entrée de l'application :
[STATfil]
vide statique Principale()
{
IWServerController.SetServerControllerClass( Type de(IWServerController));
FormMain.SetAsMainForm(Type de(FormMain));
Application.Exécuter(Nouveau Principale());
}
Si vous cliquez sur Démarrer à ce stade et lancez un navigateur à partir de la fenêtre de débogage, la page affichée dans le
navigateur sera vide, car aucun contrôle n'a encore été placé sur le formulaire et aucun code supplémentaire n'a été écrit.
Essayez cet exemple simple :
1) Sur le formMain, déposez un Button, un TextLabel et un champ Edit.

2) Affectez l'événement OnClick du bouton à cette fonction
vide privé button1_OnClick(objet expéditeur, System.EventArgs e)

Développement 41
{
textLabel1.Caption = edit1.Text;
}
Maintenant, compilez et exécutez l'application. Cliquez sur Démarrer et appuyez sur F9 dans la fenêtre de débogage. Le
navigateur par défaut sera lancé. Entrez du texte dans l'édition et cliquez sur le bouton.
Certes, ce que nous avons montré dans ces exemples n'est pas sorcier. Mais, il a été créé en utilisant le code
Delphi/C# standard et sans aucun HTML. L'exemple présenté a été choisi en raison de sa simplicité. Le but est
de démontrer que la programmation d'applications IntaWeb est très similaire au développement de n'importe
quelle autre application Windows. Les mêmes méthodes, propriétés, événements, etc.
peut être utilisé de la même manière. Cependant, IntaWeb est beaucoup plus puissant et peut être utilisé pour créer des applications
de base de données entièrement activées et plus encore.
Pour une introduction plus détaillée à la création de nouvelles applications et des didacticiels détaillés, veuillez consulter les
didacticiels sur le site Web d'Atozed à l'adresse http://www.atozed.com.
7.3 Images et graphiques

IntaWeb prend en charge les graphiques via l'utilisation de modèles, de composants TIWImage, TIWDBImage et
TIWImageFile Delphi ou des contrôles WebImage, ImageFile et DBImage équivalents dans Visual Studio
. RAPPORTER. Il existe de nombreuses façons d'utiliser des graphiques dans IntaWeb, mais ce sont les principales méthodes.
Modèles
L'utilisation de graphiques dans les modèles se fait en insérant les graphiques directement dans le code HTML. Les graphiques
peuvent être servis à l'aide du répertoire Files ou d'un serveur Web standard.
TIWImage et WebImage
TIWImage (WebImage dans Intraweb pour Visual Studio .NET) est utilisé pour les images dynamiques. Chaque fois qu'une
image est demandée, l'image est convertie en JPG. Cela peut être assez gourmand en ressources et ne doit donc être utilisé
que pour les images qui seront modifiées dans le cadre de la fonction d'une application.
Pour un exemple de ceci, veuillez consulter la démonstration Dynamic Interactive Image dans la démo des
fonctionnalités.
Pour les images statiques qui ne sont pas générées à chaque fois, utilisez TIWImageFile.
TIWDBImage et DBImage
TIWDBImage (DBImage dans Intraweb pour Visual Studio .NET) convertit automatiquement les images d'un champ de
base de données en JPG. Il est utilisé comme un TDBImage normal, il effectue tout le travail nécessaire pour afficher
l'image du champ de la base de données dans le navigateur.
Pour un exemple de TIWDBImage, consultez l'une des démos FishFact.
TIWImageFile et ImageFile
TIWImageFile (ImageFile dans Intraweb pour Visual Studio .NET) sert un fichier directement à partir d'un fichier sur le disque.
Parce qu'il ne convertit pas l'image, TIWImageFile est un moyen extrêmement efficace de servir des images et
est beaucoup plus efficace que TIWImage. Si vous utilisez des images complètement statiques, vous devez
toujours utiliser TIWImageFile.
TIWImageFile fournit également une prise en charge au moment de la conception en affichant l'image au moment de la conception.
Cependant, l'image est simplement affichée, les données d'image ne sont pas stockées avec le formulaire. Chaque fois qu'elle est
affichée au moment de la conception, l'image est chargée à partir du fichier sur le disque.
Le nom de fichier spécifie un chemin complet et un nom de fichier vers le fichier image à afficher au moment de la conception.
Au moment de l'exécution, le chemin est ignoré et seul le nom de fichier est utilisé. Au moment de l'exécution, l'image devrait être

42 Manuel IntraWeb
dans le répertoire des fichiers.
Prise en charge des GIF
IntaWeb pour Delphi peut prendre en charge les fichiers GIF, mais l'installation n'installe pas le support GIF. Veuillez consulter la
FAQ IntaWeb pour plus de détails sur l'utilisation des fichiers GIF avec IntaWeb. IntaWeb pour Visual Studio .NET a
Prise en charge des GIF.
7.4 Extension d'IntraWeb
Composants personnalisés
Tous les composants IntaWeb sont écrits à l'aide d'une API ouverte qui vous permet facilement d'écrire les vôtres
composants et ajoutez-les à IntaWeb comme vous le pouvez avec Delphi. Pour faciliter davantage l'écriture des
composants, le code source de tous les composants IntaWeb est inclus, même dans l'édition d'évaluation
d'IntaWeb.
Pour plus d'informations sur la création de composants personnalisés, veuillez consulter la section "Écrire des composants
personnalisés" dans ce manuel.
Intégration de HTML brut

Vous pouvez également intégrer votre propre code HTML dans votre application IntaWeb sans écrire de composant en
utilisant le composant TIWText. Déposez simplement un composant TIWText sur votre formulaire. Définissez la
propriété RawText sur True et WantReturns sur False. Enfin, placez le HTML dans la propriété Lines et votre
HTML personnalisé sera généré dans le cadre de votre formulaire.
Modèles HTML
Les modèles HTML (simplement appelés modèles ailleurs) peuvent être utilisés pour ajouter du HTML avancé dans votre
application et personnaliser l'apparence de votre application. Veuillez consulter la section sur les gestionnaires de mise en page
pour plus de détails.
7.5 Travailler avec COM
Initialisation de COM
IntaWeb peut effectuer automatiquement les appels nécessaires pour initialiser COM. Ceci est très utile lorsque vous travaillez
avec des composants tels que ADO pour accéder aux données. Pour utiliser cette fonctionnalité, définissez la propriété
ComInitialization dans ServerController. Il peut prendre l'une des trois valeurs possibles :
· ciAucun: aucune initialisation COM n'est appelée. C'est la valeur par défaut.
· ciNormal: COM est initialisé. C'est la méthode utilisée lors du déploiement d'applications autonomes construites
avec IntaWeb. Il spécifie le modèle de concurrence en tant qu'appartement à thread unique. En interne, IntaWeb
appelez CoInitialize(nil).
· ciMultiThread: utilisez ce paramètre lorsque vous avez besoin d'une initialisation COM et lors du
déploiement en tant que DLL ISAPI. Cela initialisera COM pour la concurrence d'objets multithread. En
interne, IntaWeb appellera CoInitializeEx(nil, COINIT_MULTITHREADED).
La désinitialisation est également prise en charge automatiquement lorsque la propriété est définie sur autre chose que
ciNone.
Fils et COM
La plupart des objets COM ne peuvent pas être transmis entre les threads. Les applications IntaWeb sont des HTTP multi-threads
serveurs qui réutilisent les threads, vous ne pouvez donc pas stocker de références à des objets COM entre deux
accès à la même session ou entre sessions. En fonction de votre problème spécifique, vous pouvez

Développement 43
utilisez un objet COM en une seule opération (pas sur toute la session, mais à un accès à la fois), puis
supprimez-le, ou rassemblez les interfaces COM dont vous avez besoin.
7.6 Utilisation des composants ClientDataSet
Ce chapitre se réfère uniquement à IntaWeb pour Delphi.
Si vous utilisez un composant ClientDataSet et que vous obtenez une violation d'accès lorsque vous quittez
l'application, vous devez ajouter le DBClient unité dans la clause uses de l'application avant IWMain.
La raison de la violation d'accès est que si DBClient n'est pas inclus dans la clause uses du fichier de projet, ses
interfaces internes sont libérées avant la fermeture de toutes les sessions et lorsque IW ferme ses sessions, il
essaie de libérer le composant ClientDataSet et vous obtenez la violation d'accès.
Lorsque DBClient est placé avant IWMain IWwill sessions gratuites avant DBClient les interfaces sont
libérées.
7.7 Travailler avec un PDA
IntaWeb 5.1 introduit la prise en charge des PDA. Ceci est accompli en restreignant la sortie générée par
l'application IW à l'aide de HTML 3.2 pur sans JavaScript ou feuilles de style en cascade supplémentaires. Bien
qu'à première vue, il semble que le développement d'applications soit limité, il est important de comprendre
que les limitations sont principalement imposées par les appareils plutôt que par IW. Étant donné que HTML 3.2 est une norme prise
en charge par presque tous les appareils du marché, il s'agit d'une bonne option pour développer des applications Web axées sur les
PDA.
Développement d'applications 3.2

Développer dans Delphi
Lors du développement d'applications PDA, vous devez utiliser des formulaires d'applications (ou des formulaires de page)
qui sont de la classe TIWAppForm32 (TIWPageForm32). Cela peut être accompli soit en utilisant l'assistant pour créer
une nouvelle application et en sélectionnant "Main Form 3.2" ou en ajoutant un formulaire 3.2 à une application
existante.
Développement dans Visual Studio .NET
Utilisez l'assistant pour créer une nouvelle application et assurez-vous que tous les formulaires ajoutés à l'application
être conforme à HTML 3.2 (hérité de la classe AppForm32).
Utilisation des contrôles 3.2
Les applications PDA sont limitées aux commandes de la classe 3.2. Cependant, en raison des restrictions
imposées par HTML 3.2, ces contrôles homologues n'ont parfois pas toutes les fonctionnalités que le
4.0 (ou normal) les contrôles IW ont. Vous pouvez UNIQUEMENT utiliser les commandes 3.2 pour les applications PDA.
Utilisation des contrôles Intraweb pour Delphi 3.2
Il y a deux onglets sur la palette de composants qui ont le composant de version 3.2 correspondant de
les composants IW standard.
Utilisation des contrôles Intraweb pour .NET 3.2
Visual Studio .NET affiche automatiquement uniquement les composants 3.2 dans la boîte à outils lorsqu'un formulaire 3.2 est
actif.
Rendu et mise en page

44 Manuel IntraWeb
Par défaut, lorsque vous placez des contrôles 3.2 sur un formulaire, ceux-ci sont affichés verticalement dans l'ordre de tabulation.
C'est idéal pour tester votre application avant de finaliser les aspects de l'interface utilisateur. La raison du placement vertical est due
au fait que les PDA ne prennent pas en charge CSS et que le positionnement ne peut donc pas être
accompli directement. Pour permettre un positionnement correct, vous avez deux alternatives. La première consiste à utiliser un
composant TIWLayoutMgrHTML32 et à concevoir votre éditeur de forme. La deuxième option consiste à utiliser un
TIWTemplateProcessor32 (TemplateProcessor32 dans Intraweb pour Visual Studio .NET) et à utiliser des modèles pour concevoir
l'apparence de l'application. Cependant, il est important de se rappeler que lors de l'utilisation
un éditeur externe pour concevoir des formulaires 3.2, vous devez restreindre les éléments HTML au standard 3.2. La plupart des
éditeurs HTML vous permettent de définir cette option avant l'édition.
Remarque : Dans Intraweb pour Visual Studio .NET, l'éditeur LayoutMgrHTML32 ne peut pas être utilisé pour la conception du
formulaire.
Paramétrage du formulaire principal
Comme pour les applications IW normales, les versions PDA doivent avoir une forme principale définie. Pour ce faire dans Intraweb pour
Delphi, utilisez la méthode SetAsMainForm dans la section d'initialisation du formulaire dont vous avez besoin pour être le formulaire
principal. Dans Intraweb pour Visual Studio .NET, déclarez la méthode Main sous la forme souhaitée
comme forme principale.
Exécuter l'application
Pendant le développement, il est beaucoup plus facile de tester les applications PDA en utilisant l'ordinateur sur lequel vous développez. IW
vous permet de le faire en lançant votre navigateur normal et en testant la version PDA. Pour ce faire, vous
avez deux alternatives :
1. A l'aide de l'application Standalone, cliquez sur l'icône PDA avant de lancer le navigateur avec le
Bouton de lancement du navigateur.
2. Tapez directement l'URL dans le navigateur en ajoutant 32 à la fin, par exemple http://127.0.0.1:8888/32
Cela vous permettra de voir les résultats de votre application IW PDA sur le navigateur.
Lorsque vous utilisez l'application directement à partir d'un appareil PDA, IW détecte le navigateur utilisé par l'appareil
PDA et lance automatiquement l'application PDA.
Noter: Le message d'erreur "aucun formulaire principal n'est défini" se produit lorsque vous essayez d'accéder à une
application qui n'a pas de formulaires HTML 3.2 avec un navigateur qui ne peut pas afficher HTML 4.0. Cela peut se produire
avec Netscape 4, car Netscape 4 ne prend pas entièrement en charge HTML 4.0 et JavaScript.
7.8 Divers
Fichiers externes
Les fichiers tels que les images et les téléchargements sont accessibles à l'aide de chemins relatifs situés sous le
dossier de candidature. Créez un dossier nommé files et placez tous les objets HTML référencés à l'intérieur. Dans la page
HTML, vous pouvez référencer les images en utilisant :
img src="../files/image.jpg"
Assurez-vous d'utiliser / et non \. Internet Explorer corrigera pour \, mais d'autres navigateurs afficheront des images
cassées. De plus, cette fonctionnalité n'est pas limitée aux images et peut être utilisée pour tout type de fichier.
Les fichiers accessibles avec l'URL des fichiers sont mis en cache par le navigateur. Si vous souhaitez créer des fichiers dynamiques qui
ne doivent pas être mis en cache, utilisez ../filesnc/<filename> au lieu de ../files/<filename>. Les fichiers seront toujours récupérés au
même endroit dans le sous-répertoire des fichiers, mais le navigateur sera invité à ne pas les mettre en cache.
Autres propriétés de formulaire

Assurez-vous également de regarder les propriétés sur le formulaire. Il existe des propriétés qui permettent la personnalisation de

Développement 45
les sorties qui sont souvent négligées. Ces propriétés permettent de contrôler la sortie HTML, et plus encore.
Contrôleur de serveur
Chaque application a une unité ServerController. Le ServerController contient des propriétés qui affectent la façon dont
l'application agit et se comporte à l'échelle mondiale. Il contient également des événements qui peuvent être définis. Pour
plus d'informations, consultez le Contrôleur de serveur chapitre.
Modules de données
Si vous utilisez des modules de données, veuillez consulter la démo FishfactDM. Une chose à noter, si vous liez vos propriétés de source
de données à un module de données au moment de la conception comme le fait FishFactDM, vos modules de données DOIVENT
appartenir à l'application Web de l'utilisateur. Cela se fait dans FishFactDM en définissant le propriétaire du module de données sur le
propriétaire des données de session, qui est la variable WebApplication. Si cela n'est pas fait, les formulaires
ne sera pas lu correctement et tous les formulaires seront liés au premier et même module de données.
Remarque : Les Datamodules se réfèrent uniquement à Intraweb pour Delphi.

Section
VIII
Gestion des formulaires 47
8 Gestion des formulaires
8.1 Travailler avec des formulaires
Tous les formulaires utilisés par une application IntaWeb doivent être un formulaire spécifique à IntaWeb. L'utilisation de
formulaires IntaWeb diffère un peu de l'utilisation de formulaires Delphi standard ou de formulaires Windows dans Visual Studio.
. RAPPORTER. Par exemple, tout formulaire affiché doit être effectué à l'aide de la méthode Show du formulaire. Dans
en d'autres termes, l'exposition modale n'est pas autorisée ou prise en charge.
Dans Intraweb pour Delphi

Le référentiel contient une autre icône, qui est le formulaire IntaWeb. Tous les nouveaux formulaires IntaWeb doivent être créés à
l'aide de Fichier | Nouveau et en choisissant le formulaire IntaWeb. Les formulaires Delphi standard ne sont pas compatibles
avec IntaWeb. Une nouvelle unité et un nouveau formulaire seront créés et affichés à l'écran.
Dans Intraweb pour Visual Studio .NET

Tous les nouveaux formulaires Intraweb doivent être créés en sélectionnant le formulaire IntaWeb dans la boîte de dialogue Ajouter un élément dans Visual
Studio IDE.
8.2 Mode de mise à jour
À partir de la version 6, IntaWeb utilise un modèle de mise à jour révolutionnaire qui améliorera considérablement les performances de
votre application. C'est ce qu'on appelle des mises à jour partielles.
Les formulaires de demande ont maintenant une nouvelle propriété, appelée UpdateMode. Définir cette propriété sureuhTous
forcera IntaWeb à utiliser le mode de mise à jour standard, le mode traditionnel lorsque tout le formulaire est
rafraîchi. Définir cette propriété surumPartiel entraînera l'actualisation du formulaire sur tous les contrôles qui ont besoin
d'être actualisés, ce qui améliore considérablement la vitesse de votre application, en particulier sur les connexions plus
lentes.
La mise à jour partielle est la technologie la plus innovante en matière de développement Web. Cependant, en raison de l'utilisation intensive des
technologies de script, ce mode de mise à jour n'est disponible que sur les derniers navigateurs et uniquement en mode HTML 4.0.
Limitations des mises à jour partielles
Lors de l'utilisation de mises à jour partielles, plusieurs éléments doivent être pris en considération. Voici une liste
des situations dans lesquelles les mises à jour partielles ne fonctionneront pas correctement :
· TerminateAndRedirect(AURL, AMsg) ne fonctionnera pas correctement si UpdateMode est umPartial

· La création de composant dynamique ne fonctionnera pas si UpdateMode est umPartial. Pour utiliser la création dynamique de
composants, vous devrez utiliser le mode de mise à jour umAll
· La modification de la taille des contrôles au moment de l'exécution ne fonctionne pas actuellement lorsque UpdateMode est
umPartial. Il s'agit d'un problème connu qui sera corrigé dans une future version, mais pour le moment, la définition de la taille
d'un contrôle (largeur, hauteur, etc.) au moment de l'exécution ne fonctionne pas.
· Le contrôle Treeview ne fonctionnera pas avec le mode de mise à jour umPartial
· l'affectation à l'exécution des gestionnaires d'événements ne fonctionnera pas dans umPartial
Toutes ces situations se produisent en raison de l'utilisation complexe des mises à jour partielles du codage
JavaScript. Certains de ces problèmes seront résolus dans les futures versions du produit.

48 Manuel IntraWeb
8.3 Cadre IntraWeb

Pour utiliser les cadres Delphi dans votre projet IntaWeb, vous devez utiliser l'assistant de cadre qui créera un
cadre IntaWeb, hérité du TFrame de Delphi.
Tout d'abord, dans le menu principal de Delphi, sélectionnez Fichier | Nouveau | Autre... .
Dans la fenêtre Nouveaux éléments, choisissez l'onglet IntaWeb et sélectionnez Nouveau cadre :
Cette opération va créer un contrôle hérité de TFrame, avec un contrôle TIWRegion placé dessus. Tous les
composants ajoutés à ce cadre doivent être placés sur ce composant TIWRegion.
Pour ajouter le cadre nouvellement créé sur l'une de vos fiches, accédez à l'onglet Standard de la palette de
composants de Delphi et choisissez Cadres :
A partir de maintenant, vous pouvez utiliser ce cadre comme n'importe quel TFrame de Delphi.
Un exemple d'utilisation des cadres avec IntaWeb peut être vu dans le Caractéristiques démo.

8.4 Contrôle des utilisateurs intraweb
L'équivalent pour Visual Studio .NET pour les cadres Delphi Intraweb sont les contrôles utilisateur. Ce type de champs fait
office de conteneur pour d'autres champs Intraweb et peut être placé sur différents formulaires. Utilisateur
les contrôles peuvent être construits dans Visual Studio .NET à l'aide de l'assistant : sélectionnez Fichier|Ajouter de nouveaux éléments dans le
menu de l'IDE et choisissez dans la section Intraweb Contrôle utilisateur Intraweb :
Le contrôle nouvellement créé sera automatiquement placé sur l'onglet "My IW User Controls" dans la boîte à outils.
A noter que lorsqu'une modification intervient dans un champ utilisateur, il faut construire le projet pour que les
modifications soient prises en compte par les formulaires hébergeant le champ.
8.5 Héritage de forme visuelle
L'héritage de formulaire visuel n'est pas pris en charge, mais l'héritage de code l'est. L'héritage de forme visuelle est problématique
dans les applications Delphi normales et nécessite une prise en charge supplémentaire du streaming. De plus, Visuel
L'héritage de formulaire ne fonctionne pas correctement avec les formulaires personnalisés utilisés par IntaWeb. Pour ces
raisons, aucun support de streaming supplémentaire n'a été inclus dans le code d'IntraWeb.
Vous pouvez cependant utiliser l'héritage de code. L'héritage de code permet l'héritage de méthodes, de membres et de propriétés.
Vous pouvez également créer des contrôles dynamiquement.
8.6 Gestion des formulaires
La gestion des formulaires dans une application IntaWeb est très similaire à celle d'une application Windows normale mais
avec quelques restrictions :
1. Un seul formulaire peut être visible à la fois. C'est parce que le formulaire est en fait affiché dans le

50 Manuel IntraWeb
navigateur.
2. Les formulaires modaux ne peuvent pas être utilisés, mais comme un seul formulaire à la fois peut être visible, pratiquement tous les
formulaires sont modaux.
3. Dans Intraweb pour Delphi, les formulaires doivent appartenir à WebApplication.
8.7 Liste des formulaires
IntaWeb conserve une liste de formulaires dans le cadre de la session des utilisateurs. Il est conservé dans une pile comme une mode avec des
formes nouvellement affichées ajoutées au sommet. Lorsque les formulaires sont masqués ou libérés, cette liste est utilisée pour déterminer le
formulaire qui doit être activé s'il n'est pas explicitement demandé d'afficher un autre formulaire via un appel au .Show
méthode d'un formulaire.
Normalement, l'utilisateur n'interagit jamais directement avec la liste de formulaires, mais les méthodes des formulaires sont appelées à
la place. Cependant, il existe des cas où une interaction directe avec la liste de formulaires peut être nécessaire. Pour
ces cas TIWApplication (IWApplication dans Intraweb pour Visual Studio .NET) contient plusieurs méthodes pour
interagir avec la liste de formulaires et sont documentées dans le fichier d'aide.
8.8 Affichage des formulaires
Les formulaires intraweb sont affichés en appelant la méthode Showmethod. Une chose qui diffère cependant d'une
application normale est que le formulaire n'est pas affiché immédiatement lorsque le .Showmethod est appelé. Avec
une application IntaWeb, l'appel à la méthode .Show définit simplement le formulaire comme le prochain formulaire
actif à afficher après la sortie de l'événement et le retour à IntaWeb. Ce n'est qu'après l'exécution de l'événement que le
formulaire s'affichera.
Une instance donnée d'un formulaire peut être affichée plusieurs fois pour l'amener au sommet. Dans ce cas,
l'instance du formulaire sera dans la liste des formulaires à plusieurs endroits.
Affichage des formulaires dans IntaWeb pour Delphi
Le format général pour afficher un formulaire est le suivant :
TFormType.Create(WebApplication).Show;
Cela peut être déroutant au début, mais ce n'est qu'un raccourci pour :
avec TFormType.Create (WebApplication) commence

Spectacle;
finir;
Cela devrait vous être familier car c'est la même chose que dans une application standard, sauf que le
propriétaire ici est WebApplication.
Affichage des formulaires dans Intraweb pour Visual studio .NET
La forme générale est :
(nouveau FormType()).Show();

8,9 Masquer les formulaires
Dans une application normale, un formulaire peut être masqué sans détruire le formulaire en appelant la
méthode .Hide.
La même fonctionnalité peut être implémentée dans IntaWeb en appelant simplement la
méthode .Hide. La méthode .Hide masquera le formulaire sans le détruire comme le fait .Release.
. Masquer supprime toutes les références dans la liste de formulaires comme le fait .Release mais ne détruit pas le
formulaire. De ce fait, vous devez conserver une référence au formulaire si vous souhaitez le réafficher
ultérieurement, sinon le formulaire deviendra orphelin.
8.10 Détruire les formes
Dans une application Delphi normale, lorsqu'un formulaire n'est plus nécessaire, il peut être détruit en utilisant le
. Free ou les méthodes .Destroy.
Dans une application IntaWeb, c'est similaire, cependant vous ne devez pas appeler directement les méthodes .Free
ou .Destroy. Au lieu de cela, vous devez appeler la méthode .Release. La méthode .Release ne détruit pas réellement
le formulaire lorsqu'il est appelé. Le formulaire ne sera pas détruit jusqu'à ce que l'événement se termine et redonne
le contrôle à IntaWeb. C'est parce que .Release est généralement appelé de l'intérieur et événement du formulaire
lui-même, bien que ce ne soit pas toujours le cas.
Après l'appel de la libération, tout comme dans une application normale, le formulaire actif devient celui qui était actif
avant que le formulaire détruit ne devienne actif. Si vous ne souhaitez pas renvoyer l'utilisateur au formulaire
précédent, vous devez appeler la méthode .Show pour un formulaire différent.
Le .Showmethod peut être appelé avant ou après le .Release car ni l'un ni l'autre ne prend effet jusqu'à
ce que le contrôle soit rendu à IntaWeb.
Lorsqu'un formulaire est publié, toutes les références à celui-ci dans la liste des formulaires sont supprimées. Cela provoque
une modification de l'ordre des formulaires qui seront affichés lorsque les formulaires sont masqués ou libérés sans appels
explicites de .Showmethod.
Dans Visual Studio .NET, les formulaires ne sont pas explicitement supprimés à cause du ramasse-miettes. L'appel
de .Release est cependant nécessaire, le formulaire est donc supprimé de la liste des formulaires.
8.11 Passer des données entre les formulaires
Les données peuvent être transmises entre les formulaires comme dans n'importe quelle application normale. Étant donné que les formulaires
sont persistants, les informations peuvent être stockées dans les variables membres des classes de formulaires.
À des fins de démonstration, nous allons créer une démo simple avec deux formulaires. Le formulaire principal
contiendra un bouton et une zone d'édition. L'autre formulaire contient un champ mémo et une étiquette.
Lorsque l'utilisateur appuie sur le bouton du formulaire principal, le texte de la zone d'édition sera ajouté au
mémo sur le deuxième formulaire et le formulaire sera affiché. Le second formulaire affichera également
combien de fois il a été affiché et permettra à l'utilisateur de revenir au formulaire principal.
Démo complète
Pour voir le projet en action, veuillez consulter le projet FormData.dpr dans le répertoire Demos
d'IntaWeb pour Delphi, ou le FormData.sln dans le répertoire Demos d'Intraweb pour Visual
Studio .NET. Pour la version Visual Studio .NET, la démo est disponible à la fois en C# et

52 Manuel IntraWeb
Langages VB.NET.
exemple Delphi
Voici à quoi ressemble le formulaire principal au moment de la conception :
Formulaire principal - Temps de conception
Formulaire principal – Code source
unité Principale;
{PUBDIST}
interface
les usages
IWAppForm, IWApplication, IWTypes, IWCompButton, IWCompEdit,

Des classes,
Contrôles, IWControl, IWCompLabel, boîte de dialogue, IWHTMLControls ;
taper
TformMain = classe (TIWAppForm)
IWLabel1 : TIWLabel ;
editText: TIWEdit;
ButnOk : TIWButton ;
IWLink1 : TIWLink ;
procedure butnOkClick(Sender: TObject);
procedure IWAppFormCreate(Sender: TObject);
procédure IWLink1Click(Expéditeur : TObject);
Publique
FDialogForm : TformDialog ; finir;
la mise en oeuvre
{$R *.dfm}
les usages
SysUtils ;
procédure TformMain.butnOkClick(Sender: TObject); var
s : chaîne ;
commencer

s := Trim(editText.Text);
editText.Text := '';
si s = '' alors commencer
WebApplication.ShowMessage('Veuillez entrer du texte.'); fin sinon
commencer
avec FDialogForm, commencez
IWMemo1.Lines.Add(s);
Inc(FCount);
Spectacle;
finir;
finir;
finir;
procédure TformMain.IWAppFormCreate(Sender: TObject); commencer
FDialogForm := TformDialog.Create(WebApplication); finir;
procédure TformMain.IWLink1Click(Sender: TObject); commencer
WebApplication.Terminate('Au revoir !'); finir;
finir.
IWLink1 OnClick
Cet événement est lié au lien avec la légende « Quitter » et met simplement fin à la session utilisateur
lorsque l'utilisateur clique sur le lien.
SurCréer
L'événement OnCreate est appelé lors de la création du formulaire. Dans ce cas, un autre formulaire est créé et la référence à
celui-ci est stockée en tant que variable membre de ce formulaire afin de pouvoir y accéder à nouveau ultérieurement.
butnOk.OnClick
Dans l'événement OnClick, la case d'édition est cochée pour les données. Si aucune donnée n'existe,
WebApplication.ShowMessage est appelé pour afficher un message à l'utilisateur. Une fois le message rejeté, le
formulaire principal s'affiche à nouveau.
Si l'utilisateur a saisi des données, l'utilisation de FDialogForm (qui a été créé dans OnCreate de ce formulaire) est utilisée. Les
données sont ajoutées au mémo et une variable membre de TFormDialog est mise à jour. Il est ensuite affiché à l'aide de la
méthode .Show. Comme vous pouvez le voir, les données sont très faciles à transmettre entre les formulaires et sont
identiques à celles d'une application Delphi normale.
Exemple de Visual Studio .NET
Les formulaires sont appelés : FormMain et FormDialog
FormMain - Temps de conception

54 Manuel IntraWeb
FormMain - Code source C# :
à l'aide de Système;
à l'aide de System.Collections;
à l'aide de System.ComponentModel;
à l'aide de Système.dessin ;
à l'aide de System.Windows.Forms;
à l'aide de System.Data;
à l'aide de Atozed.Intraweb.NETMain;
à l'aide de Atozed.Intraweb.AppFormUnit ;
espace de noms Données de formulaire
classe publique FormMain : AppForm {
privé Atozed.Intraweb.CompLabel.TextLabel tiwLabel1;

privé Atozed.Intraweb.CompEdit.Edit editText;
privé Atozed.Intraweb.CompButton.Button btnOk;
privé Atozed.Intraweb.HTMLControls.Link lnkQuit;
privé Composants System.ComponentModel.Container = nul;
privé FormDialog formDialog = Nouveau FormDialog();
Publique FormulaireMain()
{
// Cet appel est requis par le Concepteur de formulaire Windows.
InitializeComponent();
// TODO : ajouter toute initialisation après l'appel InitializeComponent

}
/// <résumé>
/// Nettoyer toutes les ressources utilisées.
/// </summary>
annulation protégée Disposer(bool élimination) {
si (disposer)
{
si (composants != nul) {
composants.Dispose();

}
}
base.Éliminer (élimination);
}
# Région Code généré par le concepteur

/// <résumé>
/// Méthode requise pour la prise en charge de Designer - ne pas modifier
/// le contenu de cette méthode avec l'éditeur de code.
/// </summary>
vide privé InitializeComponent() {
}
# région de fin
# Région Point d'entrée de l'application

/// <résumé>
/// Le point d'entrée principal de l'application.
/// </summary>
[STATfil]
vide statique Principale()
{
IWServerController.SetServerControllerClass( Type de(IWServerController));
Nouveau IWLicenseKey();
FormMain.SetAsMainForm(Type de(FormMain));
Application.Exécuter(Nouveau Principale());
}
# région de fin
vide privé btnOk_OnClick(objet expéditeur, System.EventArgs e) {
chaîne de caractères s = "" ;
si (modifierTexte.Texte != nul) {
s = editText.Text.Trim();
}
si ("" == s) {
WebApplication.ShowMessage("Veuillez saisir du texte.");
}
autre {
formDialog.GetMemoControl().Lines.Add(s);
formDialog.Count += 1;
formDialog.Show();
}
}
vide privé lnkQuit_OnClick(objet expéditeur, System.EventArgs e) {
WebApplication.Terminate("Au revoir !");
}
}
}
FormMain - code source VB.NET
Importations Système

56 Manuel IntraWeb
Importations Système.Collections
Importations System.ComponentModel
Importations Dessin.Système
Importations System.Windows.Forms
Importations System.Data
Importations Atozed.Intraweb.NETMain
Importations Atozed.Intraweb.AppFormUnit
Classe publique FormulairePrincipal

hérite Formulaire d'application
Privé AvecÉvénements TiwLabel1 Comme Atozed.Intraweb.CompLabel.TextLabel

Privé AvecÉvénements éditer le texte Comme Atozed.Intraweb.CompEdit.Edit
Privé Composants Comme System.ComponentModel.Container = Rien de privé
frmDialog Comme FormDialog = Nouveau Formulaire de dialogue
Sous-marin public Nouveau()
' Cet appel est requis par le Concepteur de formulaires Windows.

InitialiserComposant()
' A FAIRE : ajouter toute initialisation après l'appel InitializeComponent

Fin du sous-marin
' <résumé>
' Nettoyer toutes les ressources utilisées.
' </résumé>
Substitution des surcharges protégées Disposer(ParVal disposer En tant que booléen)
Si disposer Puis
Si non Composants n'est rien alors
composants.Dispose()
Fin si
Fin si
MaBase.Éliminer (éliminer)
Fin du sous-marin
#Région "Code généré par le concepteur"

' <résumé>
' Méthode requise pour la prise en charge de Designer - ne pas modifier
' le contenu de cette méthode avec l'éditeur de code. '
</résumé>
Privé AvecÉvénements btnOk Comme Atozed.Intraweb.CompButton.Button
Privé AvecÉvénements lnkQuitter Comme Atozed.Intraweb.HTMLControls.Link
Sous-marin privé InitialiserComposant()
Fin du sous-marin
#Région de fin
#Région "Point d'entrée de l'application"

'/// <résumé>
'/// Le point d'entrée principal de l'application.
'/// </summary>
<STAThread()> _
Sous-marin partagé Principale()
Faible LLicence Comme IWLicenseKey = Nouveau IWLicenseKey()

IWServerController.SetServerControllerClass(System.Type.GetType("FormData.IWS
erverController"))
FormMain.SetAsMainForm(System.Type.GetType("FormData.FormMain"))

Application.Exécuter(Nouveau Principale())
Fin du sous-marin
#Région de fin
Sous-marin privé lnkQuit_OnClick(ParVal expéditeur Comme System.Object, ParVal e Comme System.EventArgs)

Poignées lnkQuit.OnClick
WebApplication.Terminate("Au revoir !")
Fin du sous-marin
Sous-marin privé btnOk_OnClick(ParVal expéditeur Comme System.Object, ParVal e Comme System.EventArgs)

Poignées btnOk.OnClick
Faible s En tant que chaîne = ""
Si (modifierTexte.Texte <> Rien) Puis

s = editText.Text.Trim()
Fin si
Si ("" = s) Puis
WebApplication.ShowMessage("Veuillez saisir du texte.")
Autre
frmDialog.GetMemoControl().Lines.Add(s)
frmDialog.Count = frmDialog.Count + 1
frmDialog.Show()
Fin si
Fin du sous-marin
Classe de fin
Formez cet exemple, le code généré par le concepteur de formulaires dans la méthode InitializeComponent a été
supprimé.
btnOk_OnClick
Dans ce cas, la case d'édition est cochée pour les données. Si des données existent, elles sont ajoutées au champ mémo dans la
deuxième forme et le compteur gardant le nombre de fois où la deuxième forme a été affichée est augmenté et la
deuxième forme est affichée.
lnkQuit_OnClick
Cet événement met fin à la session.
8.12 Remarque pour les utilisateurs de C++ Builder
En raison de la façon dont les formulaires fonctionnent dans C++ Builder, le meilleur endroit pour initialiser toutes les instances de classe automatique est à
l'intérieur du constructeur de formulaire plutôt que dans le gestionnaire d'événements OnCreate.
Cela évitera le problème des instances créées deux fois, problème qui se pose à cause de la
ordre de création des éléments formels dans C++ Builder. Dans C++ Builder, le gestionnaire d'événement OnCreate est appelé
avant le constructeur de formulaire et le gestionnaire d'événement OnDestroy est appelé après le destructeur de formulaire.
Pour éviter de tels problèmes, veuillez déplacer toutes les initialisations automatiques des instances de classe dans le constructeur de
formulaire et ne conserver dans le gestionnaire d'événements OnCreate que les instances allouées dynamiquement.

Section
IX
Gestion de l'État 59
9 Gestion de l'État
9.1 État inhérent

Les outils de développement Web standard ont une gestion automatique des sessions, mais cela signifie simplement
qu'ils suivent les informations de session pour vous. Vous devez toujours gérer les informations d'état entre les pages,
ou les informations de proxy dans et hors d'un objet d'état. Les objets d'état sont également généralement limités aux
chaînes et les données doivent être marshalées dans et hors des chaînes, ce qui n'est pas possible pour les types de
données complexes. IntaWeb a quelque chose de mieux, et c'est la gestion d'état inhérente. Qu'est-ce que vous dites?
Un nouveau mot à la mode ? Non. Posez-vous la question suivante : comment gérez-vous l'état dans une application
Delphi ou Windows normale ? Quoi? Tu n'as pas à? EXACTEMENT! C'est ainsi que vous gérez l'état dans IntaWeb.
9.2 Restrictions
Variables globales
Les variables globales en général ne doivent pas être utilisées. Si vous souhaitez utiliser une variable globale
"globale" mais spécifique à chaque session utilisateur, vous devez utiliser des variables liées à la session
utilisateur, comme décrit plus loin.
Si toutefois vous voulez une variable globale parmi toutes les sessions utilisateur, vous pouvez et devez en fait utiliser
une variable globale. Cependant, comme IntaWeb est un environnement threadé, vous devez prendre les mesures
appropriées pour protéger la variable des accès concurrents.
ThreadVars
ThreadVars ne doit jamais être utilisé dans une application IntaWeb, sauf comme stockage temporaire dans des
circonstances contrôlées. IntaWeb est basé sur HTTP qui est sans état. Cela signifie essentiellement que les
threads ne sont pas attribués à un utilisateur spécifique et qu'un utilisateur est déplacé entre les threads entre
les requêtes HTTP.
9.3 Stockage sûr
Stockage sécurisé dans IntaWeb pour Delphi
Formulaire / Datamodule Membres

Cette section fait référence à IntaWeb pour Delphi uniquement : comme les formulaires et les modules de données
IntaWeb sont persistants comme dans une application Delphi normale, vous pouvez stocker des informations en tant que
variables membres et propriétés. De tels membres doivent être utilisés lorsque le formulaire lui-même a besoin de stocker
des données sur son instance ou de recevoir des entrées d'un autre formulaire.
Session utilisateur
La session utilisateur (couverte plus en détail dans la section Gestion de session de ce manuel) contient une
propriété .Data qui peut contenir une référence à un objet. Lorsque vous devez stocker des informations
spécifiques à l'utilisateur, vous pouvez les stocker dans la propriété .Data de la session. Les données accepte
une instance de TObject et détruisent automatiquement le TObject lorsque la session est détruite. Le moyen le
plus simple est de créer un objet et d'ajouter les champs que vous souhaitez, puis de créer votre

60 Manuel IntraWeb
objet et stockez-le dans la propriété Data de la session lorsque la session est créée. La démo de
Phonetics en montre un exemple étendu.
Lorsqu'un nouveau projet IntaWeb est créé, un objet de session utilisateur shell est créé pour vous dans le
ServerController. Le ServerController par défaut ressemble à ceci :
unité ServerController;
{PUBDIST}
interface
les usages
SysUtils, Classes, IWServerControllerBase,

IWApplication, IWAppForm;
taper
TIWServerController = classe(TIWServerControllerBase)
procédure IWServerControllerBaseNewSession(ASession:
TIWApplication;
var VMainForm: TIWAppForm); privé
Publique
finir;
TUserSession = classe
Publique
finir;
// Procédures
fonction UserSession : TUserSession ;
la mise en oeuvre
{$R *.dfm}
les usages
IWINit;
fonction UserSession : TUserSession ;

commencer
Résultat := TUserSession(RWebApplication.Data); finir;
procédure TIWServerController.IWServerControllerBaseNewSession(
ASession : TIWApplication ; var VMainForm: TIWAppForm); commencer
ASession.Data := TUserSession.Create; finir;
finir.
TUserSession est un objet de session vide auquel vous pouvez ajouter des membres, des propriétés et des méthodes.
Le code pour créer la TUserSession pour chaque session est également créé dans l'événement OnNewSession.
Une fonction nommée UserSession existe également pour un accès facile à l'objet. Donc, si vous avez
modifié la déclaration TUserSession comme suit :

TUserSession = classe
Publique
Nom d'utilisateur : chaîne ;
Mot de passe : chaîne ;
finir;
Vous pouvez accéder à ces propriétés ailleurs dans votre code simplement comme indiqué ici :
UserSession.Username := 'Joe'; LPassword :=

UserSession.Password;
Si vous n'avez pas besoin d'une session utilisateur, vous pouvez choisir de l'éliminer du code. Ce n'est pas
nécessaire et fait partie du modèle par défaut simplement pour plus de commodité.
Le type de classe de TUserSession peut être de n'importe quel type. Pour les projets générés avec un module de
données, la TUserSession est un descendant de TComponent et non de TObject comme indiqué ici. TComponent permet
à la session de posséder des composants tels que le module de données et permet un nettoyage plus facile.
Stockage sécurisé dans IntaWeb pour Visual Studio .NET
Session utilisateur
Lorsqu'une nouvelle solution IntaWeb est créée, un objet de session utilisateur shell est créé pour vous dans
le fichier UserSession.
UserSession est un objet de session vide auquel vous pouvez ajouter des membres, des propriétés et des
méthodes. Le code pour créer la UserSession pour chaque session est également créé dans l'événement
OnNewSession du ServerController.
en utilisant le système ;
en utilisant Atozed.Intraweb.UserSessionBaseUnit ; en
utilisant Atozed.Intraweb.Init ;
espace de noms FormData

{
classe publique IWUserSession : UserSessionBase
{
composants privés System.ComponentModel.Container = null;
private void InitializeComponent() {
composants = new System.ComponentModel.Container();

}
IWUserSession publique()
{
InitializeComponent();
}
IWUserSession publique statique UserSession()

62 Manuel IntraWeb
{
revenir
(IWUserSession)Atozed.Intraweb.Init.Unit.WebApplication.Data ;
}
}
}
La méthode statique appelée UserSession existe pour un accès facile à l'objet. Donc, si vous ajoutez les
lignes suivantes à la UserSession :
chaîne publique Nom d'utilisateur ;

chaîne publique Mot de passe ;
Vous pouvez accéder à ces propriétés ailleurs dans votre code simplement comme indiqué ici :
IWUserSession.UserSession().Nom d'utilisateur = 'Joe'; LPassword

= IWUserSession.UserSession().Password;
Si vous n'avez pas besoin d'une session utilisateur, vous pouvez choisir de l'éliminer du code. Ce n'est pas
nécessaire et fait partie du modèle par défaut simplement pour plus de commodité.
9.4 État complexe et le bouton Retour
De nombreuses personnes découvrent rapidement que lors de la création d'une application IntaWeb, le bouton de
retour du navigateur ne fonctionne pas. Par défaut, IntaWeb désactive le bouton de retour et l'appuyer n'a aucun effet.
Veuillez noter tout d'abord que cela ne s'applique qu'au mode application. En mode page, le bouton de retour est
entièrement fonctionnel. Cette limitation est due à la façon dont IntaWeb autorise et utilise l'état complexe.
Scénario – Application normale

Imaginez une application normale conçue pour s'exécuter sur l'ordinateur local de l'utilisateur. Il a cinq formulaires différents, et
pour certains des formulaires, plusieurs instances de ce formulaire peuvent être créées avec des données différentes (telles
qu'une boîte de dialogue de propriétés affichant les propriétés de différents objets). Imaginez maintenant qu'à tout moment,
sans avertissement ni préavis à vous le programmeur, l'utilisateur peut accéder à n'importe quel formulaire dans l'application.
Mais non seulement ils peuvent accéder à n'importe quelle forme, mais ils peuvent accéder à n'importe quelle forme, dans
n'importe quel état antérieur, même à des versions des formes qui ont depuis été retirées de la mémoire. Une fois qu'ils sont
passés à cette forme, ils peuvent même interagir avec elle. Comment une telle application pourrait-elle gérer cela?
En voici quelques-uns, mais certainement pas tous les problèmes :

•Les formulaires peuvent s'appuyer sur des données dans des bases de données qui n'existent plus parce que l'utilisateur les a supprimées.
•Les formulaires peuvent s'appuyer sur des données qui ont changé depuis, et l'utilisateur publierait des données anciennes et invalides.
•Les objets qui étaient en mémoire ont changé ou n'existent plus.

Boutons de retour dans les systèmes non IntaWeb

Les systèmes non intégrés à IntaWeb prennent généralement en charge les boutons de retour. Cependant, c'est parce qu'ils entrent dans
l'une de ces catégories :
•Apatride – Ils sont complètement sans état et reconstruisent l'état entre chaque page. Ceci est généralement très
inefficace du côté du serveur pour les weblications et met considérablement la charge supplémentaire sur les bases
de données car les données sont lues et écrites inutilement.
•Diffusion d'état – Ces types diffusent l'état dans et hors de chaque page Web. Cela consomme de la bande passante et
ralentit les accès aux pages. Ils ne peuvent pas non plus utiliser de données complexes, ou l'utilisation de données
complexes provoque les mêmes problèmes que ceux décrits précédemment.
Même les applications qui prennent en charge le bouton de retour, de tels problèmes sont toujours rencontrés. Cependant,
parce qu'ils autorisent la publication d'anciennes données, ils doivent vérifier les données pour voir si les opérations
demandées peuvent être effectuées. Cela augmente considérablement la quantité de code utilisateur, sauf dans les systèmes
les plus simples. De tels systèmes ne sont généralement pas des weblications, mais des pages dynamiques individuelles.
IntaWeb n'est pas seul

Si vous essayez de nombreuses applications bancaires ou systèmes de commande en ligne, beaucoup d'entre eux ont les
mêmes restrictions, mais ne se comportent pas aussi bien. La plupart d'entre eux vous permettent de revenir en arrière, mais
vous diront que vous avez demandé du contenu expiré. C'est certainement très peu convivial et déroutant pour les personnes
non techniques.
Bouton Retour à des fins historiques

Dans des circonstances limitées, le bouton de retour peut être pris en charge en mode application. Il peut être
activé à des fins historiques. Cela signifie que le bouton de retour sera activé et que l'utilisateur pourra revenir
en arrière. Cependant, s'ils essaient d'interagir avec les données d'une page qu'ils ont atteinte à l'aide du
bouton de retour, ils échoueront. Si l'utilisateur essaie d'interagir avec une telle page, un avertissement
s'affichera :
Vous avez tenté de publier ou d'actualiser des données à partir d'une page qui
dépend d'informations qui ne sont plus disponibles pour l'application serveur.
Vos tentatives de modifications seront ignorées. Vous allez maintenant

être resynchronisé à l'emplacement actuel dans l'application.
Une fois cet avertissement affiché, l'utilisateur verra le formulaire actuel tel qu'il était avant d'utiliser
le bouton Précédent.
Cette fonctionnalité peut être activée en définissant la propriété .HistoryEnabled sur true dans le
contrôleur de serveur.
Cette boîte de dialogue d'avertissement peut également être désactivée. Pour ce faire, définissez la
propriété .ShowResyncWarning sur false dans le contrôleur de serveur. Si false, au lieu de voir la boîte de dialogue
d'avertissement, l'utilisateur sera simplement resynchronisé avec le formulaire actuel.

64 Manuel IntraWeb
9.4.1 Utilisation de l'événement OnBackButton
IntaWeb 5.1 introduit un nouvel événement appelé OnBackButton. Cependant, malgré son nom, il ne se déclenche
PAS lorsque le bouton de retour est enfoncé dans le navigateur. Cela est dû à la nature du protocole HTTP et, par
conséquent, le navigateur ne peut pas envoyer d'événement au serveur pour indiquer que cela s'est produit. Au
en revanche, ce qui peut être détecté, c'est lorsqu'un formulaire qui a déjà été envoyé au serveur est renvoyé.
C'est là que cet événement entre en jeu.
OnBackButton est déclenché lorsqu'un formulaire est soumis à nouveau au serveur. L'événement peut donc être utilisé pour
détecter quelle opération doit avoir lieu si d'anciennes données sont renvoyées. L'affectation de l'événement affecte deux propriétés :
HistoriqueActivé et Afficher l'avertissement de resynchronisation. Lorsqu'un événement a été affecté, la première propriété est
automatiquement définie sur True tandis que la dernière est définie sur False.
IntaWeb fonctionne par séquences. Chaque formulaire soumis comporte un numéro de séquence. Lorsque l'application est démarrée
pour la première fois, la séquence (ou l'ID de piste) est définie sur 0. Chaque fois qu'un formulaire est soumis, cet ID de piste est
incrémenté de 1. Les séquences jouent un rôle important dans les événements de bouton de retour.
La signature de l'événement est :
ASubmittedSequence, ACurrentSequence : Entier ; ANomFormulaire : chaîne ; var VHandled,

VExecute : booléen
· ASubmittedSequence: Représente la séquence qui a été soumise. Ce sera toujours

INFÉRIEUR auACurrentSequence qui représente la séquence courante.
· ACurrentSequence: Représente l'ID de piste actuel.
· ANomFormulaire: Travailler avec des numéros de séquence, bien que puissant, peut devenir encombrant. Vous
pouvez également utiliser le paramètre AFormName pour voir QUEL formulaire a été soumis à nouveau.
· VHandled: Lors du contrôle d'un formulaire soumis à nouveau, vous devez définir la propriété VHandled sur
True, sinon IntaWeb comprendra que l'événement n'a pas été géré et affichera l'action par défaut qui
consiste à afficher le message Re-sync.
· VExécuter: Lorsqu'un formulaire est recréé dans l'événement OnBackButton, vous pouvez choisir si vous
voulez l'exécuter ou le générer. Par défaut, VExecute est FALSE, ce qui signifie que le formulaire sera
généré.
Pour plus d'informations et un exemple Delphi d'utilisation du OnBackButton jetez un oeil à la

Bouton Retour démo située dans le dossier de l'application.

Section
X
66 Manuel IntraWeb
dix Gestion des sessions
10.1 Objet d'application Web
TIWApplication est à une application IntaWeb, ce que TApplication est à une application Delphi standard. Comme ce
dernier, TIWApplication n'est pas un composant visuel. Il n'apparaît pas dans le panneau des propriétés et n'a donc pas
de propriétés publiées. Cependant, il possède un certain nombre de propriétés publiques et
méthodes accessibles via le code dans l'application IW. Pour chaque session utilisateur, un objet
TIWApplication est créé. Il représente "l'application" ou la session de l'utilisateur. Dans Intraweb pour
Visual Studio .NET, la classe d'application est IWApplication et a exactement le même rôle que
TIWApplication dans Intraweb pour Delphi.
10.2 Référencement de la session
L'application des utilisateurs est accessible de plusieurs manières.
Propriété WebApplication du formulaire

Dans tous les cas ou méthodes de vos formulaires, vous pouvez simplement utiliser WebApplication qui référencera la
propriété WebApplication du formulaire. Cela répondra aux exigences dans presque tous les cas. Cependant, certaines
exceptions notables où cette propriété n'est pas accessible sont les procédures globales, les TFrames,
modules de données et classes non IntaWeb.
Propriété WebApplication d'un contrôle

Le contrôle IntaWeb de base contient également une propriété WebApplication qui peut être utilisée lors de l'écriture de contrôles
personnalisés.
WebApplication ThreadVar
Dans le code qui n'est pas contenu dans un formulaire ou un composant IntaWeb, la version threadvar est accessible. Ceci
est particulièrement utile dans les procédures globales ou dans le code TFrame dans Delphi Intraweb
applications ou le code de contrôle utilisateur dans les applications Intraweb pour Visual Studio .NET.
10.3 Durée de vie
Une session utilisateur est gérée automatiquement par IntaWeb. Lorsqu'une nouvelle session démarre, IntaWeb
créer une nouvelle instance d'une TIWApplication (ou IWApplication dans Visual Studio .NET) pour l'utilisateur et la suivre
automatiquement. Il peut ensuite être utilisé pour acquérir des informations sur l'utilisateur, contrôler la session des
utilisateurs ou stocker des informations supplémentaires. Aucune gestion de la part des développeurs n'est requise pour
implémenter la gestion de session, ou pour suivre l'utilisateur.
Une session existe jusqu'à ce qu'elle soit terminée manuellement en appelant l'une des méthodes de terminaison de
TIWApplication ou qu'un délai d'attente se produise. Si un utilisateur n'accède pas à l'application dans un délai donné, la
session de l'utilisateur sera détruite. Le délai d'expiration par défaut est de 10 minutes, mais peut être ajusté en modifiant la
propriété SessionTimeout dans les applications ServerController.
Noter: Pour stocker les variables liées à la session, créez des membres de la classe TUserSession (UserSession dans
Intraweb pour Visual Studio .ENT).
Remarque pour les utilisateurs de Delphi : Ne pas travailler avec des variables déclarées dans le var section, car elles sont globales pour tous les
threads et ne refléteront pas correctement les données de session.

Gestion des sessions 67
10.4 Mise en œuvre

Les sessions sont gérées automatiquement par IntaWeb. Les sessions sont stockées en mémoire sur le serveur et sont donc
protégées des utilisateurs qui pourraient tenter de modifier les données de session.
Chaque session se voit attribuer un ID de session unique qui est utilisé pour identifier la session. L'ID de session est
construit de manière sécurisée afin que les ID de session ne soient pas prévisibles et donc sujets au piratage. De plus,
chaque session est liée au navigateur de l'utilisateur et si un autre navigateur est détecté tentant d'utiliser
la même session une erreur sera retournée.
Pour plus de sécurité, utilisez la propriété RestrictIPs de ServerController. Cela vérifiera l'adresse IP de l'utilisateur
par rapport à la session et renverra une erreur si l'adresse IP change. Cette option est fausse par
par défaut et ne doit être défini sur true que dans les intranets ou les extranets avec des clients contrôlés. Cela est dû au fait
que certains serveurs proxy tels que le serveur proxy Microsoft ISA modifient les adresses IP entre les requêtes HTTP pour un
utilisateur donné et entraîneront la visualisation de plusieurs adresses IP par le serveur IntaWeb.
Par défaut, l'ID de session est intégré dans chaque page HTML et suivi avec chaque requête HTTP. Cette
permet à un seul utilisateur d'avoir plusieurs sessions par application. L'inconvénient est qu'une fois que l'utilisateur est à
l'intérieur de l'application, il ne peut pas quitter l'application et y revenir. Pour cette raison, lors de l'utilisation de cette
méthode de suivi des ID de session, toutes les pages Web non applicatives doivent être ouvertes dans de nouvelles fenêtres, à
moins que ce ne soit en réponse à la fermeture de l'application.
Le suivi de session peut être configuré pour utiliser des cookies au lieu d'être incorporés dans la page HTML en définissant la
propriété SessionTrackingMethod du ServerController sur tmCookie. Cela indiquera à IntaWeb d'utiliser des cookies pour
suivre la session de l'utilisateur à la place. L'avantage est que l'utilisateur peut facilement entrer et sortir de l'application vers
d'autres pages Web. L'inconvénient est que de nombreux utilisateurs désactivent les cookies et
aussi que l'utilisateur ne peut avoir qu'une seule session par application.
10.5 Stockage de données supplémentaires
Des données supplémentaires peuvent être stockées dans la propriété .Data et sont traitées dans la section Gestion de l'état de
ce manuel.
10.6 Événements liés à la session
Le contrôleur de serveur a des événements liés à la gestion de session qui sont déclenchés pour la création et la
destruction de session.
SurNouvelleSession
OnNewSession est déclenché à chaque fois qu'une nouvelle session utilisateur est créée. Il passe deux
arguments, ASession et VMainForm.
ASession est une référence à la session nouvellement créée et peut être utilisée pour interroger des informations sur
l'utilisateur ou modifiée avec des informations personnalisées telles que la création d'un objet à stocker dans la
propriété .Data.
VMainForm est passé en tant que paramètre var. Il est initialisé à nil et s'il n'est pas défini, le formulaire principal par
défaut tel que spécifié dans le fichier de projet (dpr) sera utilisé. VMainForm peut cependant être modifié en fonction
des paramètres passés sur l'URL de démarrage, ou en fonction d'autres critères pour spécifier un formulaire principal
pour l'utilisateur. Pour spécifier une autre forme principale, créez-la simplement et renvoyez son instance dans
l'argument VMainForm. Dans Visual Studio .NET, VMainForm est initialisé à null et passé par référence et il a
exactement les mêmes fonctionnalités que dans Intraweb pour Delphi.

68 Manuel IntraWeb
OnFerme Session
OnCloseSession est appelé lorsqu'une session utilisateur est sur le point de se terminer. Cela se produit soit
lorsque l'une des formes de WebApplication.Terminate est appelée, soit lorsque la session a expiré.
10.7 Consommation de mémoire
La consommation de mémoire de base par session est assez faible et, dans la plupart des cas, n'est pas une considération
majeure. La taille réelle peut varier d'une session à l'autre, mais la consommation de mémoire de base à l'exclusion des
données utilisateur dans la propriété .Data doit généralement être au maximum de 1024 octets.
Noter: C'est le réglage typique. Si vous disposez de suffisamment de RAM, vous pouvez stocker en toute sécurité autant d'octets que vous le
souhaitez.
10.8 Référence des composants
Plus d'informations sur les méthodes et les propriétés de la classe TIWApplication sont disponibles dans le fichier
d'aide IntaWeb. La classe IWApplication est décrite dans le fichier d'aide Intraweb pour Visual Studio .NET.
10.9 Comment fonctionne la gestion de session ?
Lorsque vous utilisez ApplicationMode dans IntaWeb, le suivi de session est effectué automatiquement.
Cela permet à l'utilisateur de se concentrer sur l'application et d'oublier la gestion des sessions. Même si
tout cela est automatisé, il est bon de comprendre comment IntaWeb y parvient et de voir comment il
peut l'étendre pour stocker certaines informations.
IntaWeb permet à l'utilisateur de spécifier comment la gestion des sessions est suivie. Cela offre de la flexibilité
puisque certaines situations restreignent l'utilisateur à un certain type de suivi. Par exemple, lorsque l'application
est déployée dans une grande entreprise, qui a certaines restrictions de navigateur telles que l'interdiction des
cookies, une autre forme de suivi de session peut être utilisée. Pour offrir cette flexibilité, le suivi de session peut
être obtenu en utilisant l'une des options suivantes : Champs cachés, URL et Cookies.
Les développeurs habitués à mettre en œuvre le suivi de session à l'aide de technologies telles que
WebBroker les connaissent bien, car il s'agit du 3 moyen le plus courant (sinon le seul) de mettre en
œuvre une telle fonctionnalité. La méthode utilisée est définie comme une propriété dans le
ServerController (Suivi de session).
10.9.1 URL
Le suivi de session URL est la méthode par défaut. Lorsque vous utilisez cette méthode, les informations
apparaissent à tout moment dans l'URL. Lors du premier appel de l'application, l'URL est de la forme :
http://xxx.xxx.xxx.xxx:xxxx/{start_command}
Après le premier appel, les informations de session appropriées seront ajoutées à l'URL, qui
sera :
http://xxx.xxx.xxx.xxx:xxxx/exec_command/Z/YYYYYYYYYYYYYYY

Gestion des sessions 69
Il y a deux valeurs importantes ici à comprendre, Z représente l'ID de la piste tandis que
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAlé représente l'ID de
session. L'ID de piste représente "l'état" dans lequel se trouve l'application. Lorsqu'une application IW démarre, l'ID de piste est mis à 0. Chaque
fois qu'une nouvelle demande est faite au serveur, l'ID de piste est incrémenté de 1. Chaque nouvelle demande a une valeur plus élevée que la
précédente. Cela permet à IW de savoir exactement dans quel état il se trouve.
L'ID de session est une valeur aléatoire générée à partir de valeurs uniques afin qu'elle soit différente
pour chaque utilisateur qui accède à l'application. Cela rend pratiquement impossible le mélange de
sessions entre deux utilisateurs.
L'un des inconvénients de l'utilisation de l'URL comme suivi de session est que l'utilisateur verra toujours l'URL
dans ce format. Toute modification de l'ID de session entraînera un message de session invalide.
10.9.2 Cookies
Les cookies sont une bonne alternative lorsque les utilisateurs ont activé les cookies dans leur navigateur et n'ont
aucun problème à les utiliser. Les cookies offrent également l'avantage de ne pas avoir une URL longue et également
des options de réentrée. En autorisant la réentrée, l'application peut créer un lien vers un site Web externe et à partir
de ce site Web externe, un lien vers l'application. Pour plus d'informations à ce sujet, consultez l'événement OnReEntry
dans ServerController.
En ce qui concerne les informations stockées, les mêmes entrées (identifiant de session et identifiant de piste) qu'avec tmURL
stockées dans le cookie.
10.9.3 Champs cachés
Introduits dans Intraweb 5.1, les champs masqués peuvent désormais être utilisés pour implémenter le suivi de
session. Chaque fois qu'une nouvelle demande est faite, deux champs supplémentaires sont rendus à l'intérieur du
FORMtag lorsque la page est affichée. En utilisant cette méthode de suivi de session, l'URL peut également rester
"simple" sans qu'il soit nécessaire d'afficher l'ID de piste et l'ID de session à chaque demande.
Que sont les champs cachés ?
Les champs masqués sont des champs de formulaire HTML standard qui ne sont pas visuels. C'est-à-dire que l'utilisateur régulier ne les voit
jamais.
Les champs cachés sont rendus au format HTML en tant que <INPUT TYPE="hidden" NAME="my name" VALUE="my
value"> tag, où "my name" est le nom du champ masqué et "my value" est la valeur réelle que contient
le champ masqué.
Les champs cachés sont contenus dans les formulaires HTML, mais ils n'ont pas d'apparence visuelle. Ils sont très utiles
pour le suivi de session, ainsi que pour transmettre des données entre les formulaires.
Noter: Lorsque cette méthode de suivi de session est utilisée, la chaîne ExecCmd apparaîtra dans la barre d'URL si le
redimensionnement côté serveur est actif. Ce comportement est inhérent à la conception et ne peut être évité.

Section
XI
Gestionnaires de mise en page et modèles 71
11 Gestionnaires de mise en page et modèles
11.1 Qu'est-ce qu'un gestionnaire de disposition ?
Un gestionnaire de mise en page assemble les éléments HTML de chaque composant en une page HTML complète pour la sortie vers le
navigateur. IntaWeb dispose d'un gestionnaire de mise en page de base dont on peut descendre pour créer de nouveaux gestionnaires
de mise en page. Actuellement, IntaWeb a deux gestionnaires de mise en page et à l'avenir, il y aura d'autres
gestionnaires de mise en page pour prendre en charge XML et plus encore. Dans Intraweb pour Delphi, le gestionnaire de
disposition de base s'appelle TIWLayoutMgr et a deux descendants : TIWLayoutMgrForm et TIWTemplateProcessorHTML.
Intraweb pour Visual Studio .NET possède le gestionnaire de disposition de base ContainerLayout et les deux descendants :
TemplateProcessorHMTL et LayoutMgrHTML.
11.2 Disposition du formulaire
Il s'agit du gestionnaire de mise en page par défaut. Si aucun gestionnaire de mise en page n'est spécifié, un gestionnaire de mise en
page implicite sera créé et utilisé. Il crée des pages HTML qui ont la même mise en page et la même apparence que le formulaire
conçu. Dans Intraweb pour Delphi, ce gestionnaire de mise en page est de type TIWLayoutMgrForm et dans Intraweb pour Visual
Studio .NET est de type LayoutMgrForm.
11.3 Modèles HTML
Modèles HTML
Les modèles permettent un formatage et une mise en page avancés de conteneurs individuels (formulaires, cadres
IntaWeb ou contrôles utilisateur, régions). Les modèles permettent également à un concepteur Web de concevoir la
mise en page des conteneurs sans utiliser l'IDE. En bref, les modèles permettent de séparer la présentation et la mise
en œuvre. Les modèles sont simplement des fichiers HTML spéciaux.
L'utilisation de modèles nécessite toujours que le navigateur prenne en charge HTML et JavaScript.
Tous les contrôles encadrés seront rendus sans cadres lorsque des modèles sont utilisés. Si vous souhaitez avoir
des cadres dans le modèle, vous devez les encadrer en utilisant IFrame ou une autre méthode dans votre
modèle.
Pour utiliser des modèles, créez un sous-répertoire "Modèles" dans votre répertoire d'application et créez un fichier
<NomFormulaire>.html. Ensuite, pour le formulaire auquel vous souhaitez appliquer le modèle :
1. Ajoutez un processeur de modèle HTML sur votre formulaire. Dans Intraweb pour Delphi, ce type
de processeur est appelé composant TIWTemplateProcessorHTML et est placé sur l'onglet
IntaWeb Control de la palette. Dans Intraweb pour Visual Studio .NET, ce processeur est
TemplateProcessorHTML et est placé sur l'élément de boîte à outils des composants Intraweb.
2. Définissez LayoutMgr du formulaire sur le nouveau contrôle de processeur de modèle HTML.
La plupart des fonctionnalités du modèle devraient être explicites en examinant les exemples. Pour voir
les modèles en action, consultez la démo Phonetics Customer Profiler.
Pour chaque composant, le modèle doit contenir une balise de la forme

{%Component.HTMLName%}.
Noter: Cette règle ne s'applique pas aux contrôles non visuels.

72 Manuel IntraWeb
HTMLName dans la plupart des cas est le même que le nom. Lorsque le formulaire est généré, les balises seront
remplacées par la sortie du composant. L'utilisation de {%%} au lieu de <> permet une édition plus facile dans les
éditeurs WSIWYGHTML et est compatible avec tous les éditeurs HTML. Les caractères de balise {%%} ne sont pas
non plus considérés comme des caractères spéciaux et ne sont donc pas convertis en balises spéciales. Par
défaut, une balise FORM principale entourera le corps pour assurer le bon fonctionnement de tous les contrôles
et boutons d'entrée. Cependant, dans certains cas, cela peut interférer avec le code HTML. Pour de tels cas,
consultez la rubrique d'aide pour TIWTemplateProcessorHTML.MasterFormTag.
Il existe un cas particulier lors de la création de modèles HTML pour des formulaires contenant des régions ou des cadres
IntaWeb dans du code Delphi ou des contrôles utilisateur dans Visual Studio .NET.
Pour les contrôles sur les régions, les situations suivantes peuvent se produire :
- les contrôles sont placés sur une région qui a son propre sous-modèle. Dans ce cas, vous n'avez pas besoin de
spécifier de balises pour les contrôles de la région, faites simplement référence à la région via une balise. Au
moment de l'exécution, les contrôles de cette région seront rendus en fonction du sous-modèle. Pour un exemple
Delphi sur les sous-modèles, voir la démo des fonctionnalités.
- les contrôles sont placés sur une région qui n'a pas de sous-modèle associé. Dans ce cas se
référer aux contrôles avec :
{%RegionName.ControlHTMLName%}. Si vous souhaitez que la région soit rendue comme au moment de la
conception, dans le modèle HTML, écrivez uniquement la balise de la région : {%RegionHTMLName%}. Notez que dans
les sous-modèles pour les régions, les contrôles doivent être référencés uniquement avec le nom HTML :
{%Control.HTMLName%}. S'il vous plaît, vérifiez leNote récapitulative à la fin de cette section pour un exemple sur la
façon de référencer des contrôles sur des régions avec des sous-modèles attribués.
Les contrôles placés sur les cadres/contrôles utilisateurs IntaWeb peuvent être référencés par :
- {%FrameNameRegionName.ControlHTMLName%} si le cadre IntaWeb parent n'est pas
rendu via un sous-modèle. RegionName est le nom de la région placée sur le cadre IntaWeb.
- {%FrameName%} : dans ce cas, le cadre IntaWeb est rendu selon un sous-modèle attribué ou, si aucun
sous-modèle n'est attribué, la mise en page et l'apparence seront établies au moment de la conception. Si
vous choisissez cette approche, vous n'avez pas besoin de référencer via des balises aucun des contrôles
du cadre IntaWeb.
Si vous souhaitez utiliser les balises de style Borland <#TagName#> au lieu des balises de style IntaWeb, vous pouvez
définir la propriété TagType sur ttBorland. Les balises de type IntaWeb sont plus faciles à utiliser avec les éditeurs HTML
WSYWIG.
Modèles et Mozilla : Il n'est pas recommandé d'utiliser IWRegions dans les structures <table>, en raison de
certains problèmes de positionnement dans le navigateur Mozilla. Par exemple, cela ne sera pas correctement
positionné dans Mozilla :
<html><body>
<tableau>
<tr>
<td>tester</td>
<td>{%IWRegion1%}</td>
</tr>
</table>

72 Manuel IntraWeb
HTMLName dans la plupart des cas est le même que le nom. Lorsque le formulaire est généré, les balises seront
remplacées par la sortie du composant. L'utilisation de {%%} au lieu de <> permet une édition plus facile dans les
éditeurs WSIWYGHTML et est compatible avec tous les éditeurs HTML. Les caractères de balise {%%} ne sont pas
non plus considérés comme des caractères spéciaux et ne sont donc pas convertis en balises spéciales. Par
défaut, une balise FORM principale entourera le corps pour assurer le bon fonctionnement de tous les contrôles
et boutons d'entrée. Cependant, dans certains cas, cela peut interférer avec le code HTML. Pour de tels cas,
consultez la rubrique d'aide pour TIWTemplateProcessorHTML.MasterFormTag.
Il existe un cas particulier lors de la création de modèles HTML pour des formulaires contenant des régions ou des cadres
IntaWeb dans du code Delphi ou des contrôles utilisateur dans Visual Studio .NET.
Pour les contrôles sur les régions, les situations suivantes peuvent se produire :
- les contrôles sont placés sur une région qui a son propre sous-modèle. Dans ce cas, vous n'avez pas besoin de
spécifier de balises pour les contrôles de la région, faites simplement référence à la région via une balise. Au
moment de l'exécution, les contrôles de cette région seront rendus en fonction du sous-modèle. Pour un exemple
Delphi sur les sous-modèles, voir la démo des fonctionnalités.
- les contrôles sont placés sur une région qui n'a pas de sous-modèle associé. Dans ce cas se
référer aux contrôles avec :
{%RegionName.ControlHTMLName%}. Si vous souhaitez que la région soit rendue comme au moment de la
conception, dans le modèle HTML, écrivez uniquement la balise de la région : {%RegionHTMLName%}. Notez que dans
les sous-modèles pour les régions, les contrôles doivent être référencés uniquement avec le nom HTML :
{%Control.HTMLName%}. S'il vous plaît, vérifiez leNote récapitulative à la fin de cette section pour un exemple sur la
façon de référencer des contrôles sur des régions avec des sous-modèles attribués.
Les contrôles placés sur les cadres/contrôles utilisateurs IntaWeb peuvent être référencés par :
- {%FrameNameRegionName.ControlHTMLName%} si le cadre IntaWeb parent n'est pas
rendu via un sous-modèle. RegionName est le nom de la région placée sur le cadre IntaWeb.
- {%FrameName%} : dans ce cas, le cadre IntaWeb est rendu selon un sous-modèle attribué ou, si aucun
sous-modèle n'est attribué, la mise en page et l'apparence seront établies au moment de la conception. Si
vous choisissez cette approche, vous n'avez pas besoin de référencer via des balises aucun des contrôles
du cadre IntaWeb.
Si vous souhaitez utiliser les balises de style Borland <#TagName#> au lieu des balises de style IntaWeb, vous pouvez
définir la propriété TagType sur ttBorland. Les balises de type IntaWeb sont plus faciles à utiliser avec les éditeurs HTML
WSYWIG.
Modèles et Mozilla : Il n'est pas recommandé d'utiliser IWRegions dans les structures <table>, en raison de
certains problèmes de positionnement dans le navigateur Mozilla. Par exemple, cela ne sera pas correctement
positionné dans Mozilla :
<html><body>
<tableau>
<tr>
<td>tester</td>
<td>{%IWRegion1%}</td>
</tr>
</table>

Gestionnaires de mise en page et modèles 73
</body></html>
Plus de détails sur ce bogue peuvent être trouvés sur http://bugzilla.mozilla.org/show_bug.cgi?id=63895

et http://bugzilla.mozilla.org/attachment.cgi?id=76045&action=view.
Remarque récapitulative : Les contrôles sur les régions ou les cadres qui ont leurs propres modèles doivent être spécifiés
individuellement. Supposons que vous ayez un formulaire (IWForm1) et que vous mettiez une région sur le formulaire
(IWRegion1), une zone d'édition sur le formulaire (IWEdit1) et une étiquette sur la région (IWLabel1). Si vous affectez des
modèles à la fois au formulaire et à la région, vous devez inclure les contrôles du formulaire dans le modèle du formulaire
(IWRegion1 et IWEdit1 dans notre exemple), et inclure les contrôles de la région dans le modèle pour
la région (IWLabel1 dans notre exemple). Un exemple avec des régions et des sous-modèles peut être vu dans la démo des
fonctionnalités.
11.4 Modèles système

Les modèles système peuvent être utilisés pour modifier l'apparence et la présentation des messages système et des boîtes de
dialogue générés par IntaWeb.
Boîtes de dialogue système
Il existe deux fichiers modèles spécifiques appelés IWShowMessage.html et IWException.html. Ceux-ci sont utilisés
pour fournir une mise en forme supplémentaire à la méthode ShowMessage et pour l'affichage des exceptions non
interceptées. Les balises suivantes doivent être présentes :
{%message texte%}
{%butnOk%}
Notez que le modèle pour ShowMessage n'a aucun effet lorsque smAlert ou smNewWindow est
transmis à ShowMessage.
Messages système
Les modèles système prennent en charge deux balises : {%Content%} et {%AppName%} qui peuvent être
utilisées pour afficher le message d'erreur. {%AppName%} est tel que spécifié dans ServerController.AppName.
La balise {%AppID%}. IT fait référence à l'ID de l'application.
IWError.html
Les erreurs système sont des erreurs qui se produisent en dehors de votre application et dans la partie serveur
d'IntaWeb. Ces erreurs sont rares et consistent généralement en des éléments tels que l'utilisateur entrant des
demandes non valides via des URL ou essayant d'accéder à des sessions expirées. Ces erreurs peuvent être gérées en
créant un modèle nommé IWError.html.
Noter: Ce chapitre s'adresse uniquement aux utilisateurs d'Intraweb pour Delphi.

Section
XII
Contrôleur de serveur 75
12 Contrôleur de serveur
12.1 Qu'est-ce que le contrôleur de serveur ?
Chaque fois que vous créez une nouvelle application IntaWeb*, l'assistant de projet crée un formulaire appelé
IWServerController. Tous les projets d'applications IntaWeb EXIGENT ce formulaire.
Bien qu'au début, cela puisse ne pas sembler trop important, et lorsque vous créez votre première application IW, vous
pouvez même ne pas ouvrir le formulaire ; le ServerController joue un rôle très important dans une application IW. À partir
de là, vous pouvez contrôler des propriétés telles que le port, les paramètres SSL et bien plus encore. Ce chapitre explique
les concepts du ServerController.
* Le formulaire est UNIQUEMENT créé lorsque vous travaillez en mode APPLICATION avec IntaWeb pour Delphi. Lors de
l'utilisation de PageMode, le ModuleController crée un contrôleur de serveur en interne.
12.2 Propriétés
La plupart des propriétés pertinentes du ServerController sont publiées et donc accessibles via
l'inspecteur d'objets dans Delphi ou l'onglet Propriétés dans Visual Studio .NET.
Pour plus d'informations sur les propriétés du ServerController, veuillez consulter le fichier d'aide de référence des
composants IntaWeb.

Section
XIII
Écriture de composants personnalisés 77
13 Écriture de composants personnalisés
13.1 Aperçu
Tous les composants IntaWeb sont écrits à l'aide d'une API ouverte qui vous permet facilement d'écrire vos propres
composants et de les ajouter à IntaWeb comme vous le pouvez avec Delphi ou Visual Studio .NET. Dans Intraweb pour Delphi,
pour faciliter davantage l'écriture des composants, le code source de tous les composants dans
inclus, même dans l'édition d'évaluation.
13.2 En construction
Ce chapitre est encore en construction et sera développé à l'avenir. N'hésitez pas à utiliser nos groupes de discussion pour
poser toutes les questions relatives à l'écriture de composants personnalisés.
13.3 Code source

Le code source est inclus pour la plupart des composants IntaWeb pour Delphi. Le code source se trouve dans le sous-
répertoire source du répertoire IntaWeb. L'API est très similaire à Delphi et pour la plupart des gens assez explicative.
13.4 Serveur principal
Dans chaque application IntaWeb, il y a un serveur principal qui est responsable de servir le HTTP réel
demandes. Ce serveur est de type basé TIWServer et est accessible en utilisant la variable globale GIWServer dans
l'unité IWServer dans la version Delphi ou l'espace de noms Atozed.Intraweb.Server dans la version Visual Studio .NET.
Le serveur principal possède des méthodes utiles aux rédacteurs de composants et est documenté dans les fichiers
d'aide en tant que TIWServer.
13,5 Programme tiers

Si vous créez des composants à distribuer, gratuitement ou contre rémunération, vous devriez envisager
rejoindre le programme tiers IntaWeb. Des informations sur ce programme sont disponibles sur le site Web
d'IntaWeb. Le programme IntaWeb Third Party peut vous aider dans le développement de vos composants, ainsi
que dans la distribution et la promotion de vos composants.

Section
XIV
Javascript 79
14 Javascript
14.1 Aperçu
IntaWeb utilise fortement Javascript pour implémenter ses fonctionnalités. Cependant, certains utilisateurs qui sont
à l'aise avec Javascript ou souhaitez ajouter des fonctionnalités personnalisées peuvent ajouter leur propre Javascript sans
avoir à contourner complètement IntaWeb. IntaWeb contient de nombreuses bibliothèques et fonctions qui peuvent être
utile.
Cette section ne décrira pas chaque bibliothèque ou fonction car beaucoup sont spécifiques à un composant ou peu utiles au
développeur. Au lieu de cela, un aperçu et une introduction seront présentés pour une intégration facile dans les
bibliothèques Javascript IntaWeb.
14.2 Domaines de mise en œuvre
Il existe une infinité d'endroits pour ajouter Javascript à une application IntaWeb, mais les plus courants sont :
1. Utilisation des méthodes et propriétés des formulaires : Javascript, AddToInitProc, AddValidation, ScriptFiles
3. A partir d'un champ personnalisé.
4. Dans un modèle.
5. Utilisation de ScriptEvents
14.3 Utilisation de ScriptEvents
De nombreux contrôles visuels IntaWeb sont associés à des événements tels que l'événement OnClick du bouton. Cela vous
permet de programmer les événements comme une application standard. Cependant, certains événements JavaScript
spécifiques ne sont pas disponibles. Bien que des événements tels que OnBlur, OnFocus, etc. ne soient pas
disponibles directement, vous pouvez toujours les utiliser via la propriété ScriptEvents du contrôle.
Accès à la propriété ScriptEvents dans Delphi
En double-cliquant sur cette propriété, l'éditeur ScriptEvents s'affiche.

80 Manuel IntraWeb
Une fois chargé, il existe une liste d'événements associés à ce contrôle. Ces événements correspondent à des
événements JavaScript, par conséquent, tout code entré doit être du code JavaScript et non du code Delphi ou C++.
Accès à la propriété ScriptEvents dans Visual Studio .NET

Javascript 81
Ouvrez la fenêtre ScriptEvents à partir des propriétés du contrôle :
et ajoutez le code pour l'événement JavaScript souhaité :

82 Manuel IntraWeb
Pour voir comment associer un événement à l'un d'entre eux, consultez les deux sections suivantes.
Écriture d'événements JavaScript
(Remarque : Étant donné que les contrôles IW 3.2 reposent EXCLUSIVEMENT sur HTML et n'utilisent ni JavaScript ni
CSS, ScriptEvents n'est pas disponible pour ces contrôles)
14.3.1 Écriture d'événements JavaScript
La première étape consiste à choisir l'événement auquel vous souhaitez associer du code Javascript. Dans ce cas,
nous allons faire une fonction qui affiche une simple alerte lorsque le champ obtient le focus.
La première étape consiste à déposer un TIWEdit sur le formulaire et à double-cliquer sur la propriété ScriptEvents. Une
fois l'éditeur affiché, cliquez sur l'événement OnFocus puis saisissez le texte suivant dans la zone d'édition :
Maintenant, lorsque vous exécutez ceci :

Javascript 83
et entrez la case IWEdit1, l'alerte s'affichera dans le navigateur.
L'étape suivante consiste à interagir avec la valeur saisie dans la zone d'édition. Dans ce cas, nous allons effectuer une
vérification de la valeur saisie pour voir si elle est d'au moins six caractères. La première chose à faire est de définir la
fonction qui vérifie si la longueur du texte est correcte :
function CheckLength(ASender) {
if (ASender.value.length < 6) {
alert("Au moins 6 caractères requis");

}
}
Une fois cette fonction définie, nous devons pouvoir l'utiliser. Pour ce faire, nous pouvons l'ajouter à la propriété
JavaScript du formulaire :

84 Manuel IntraWeb
La dernière étape consiste à appeler la fonction à partir de l'événement OnBlur du contrôle IWEdit. Pour cela,
choisissez OnBlur dans les ScriptEvents du champ et saisissez le code suivant :
Vérifier la longueur (ceci)
Où « this » représente le contrôle réel en JavaScript.
Tout ce qui a été fait précédemment, pourrait également être fait à l'exécution en utilisant la méthode des
contrôles "HookEvents". Pour plus d'informations sur HookEvents, consultez le répertoire source.
14.3.2 Plus d'événements de script
Dans la section précédente (Écriture d'événements JavaScript), nous avons vu comment écrire des événements associés à un
champ et comment interagir avec l'objet. Dans cette section, nous examinerons quelques autres exemples d'événements
d'écriture.
Voyons un exemple de la façon de changer dynamiquement la couleur d'un bouton lorsque le pointeur de la souris
se déplace dessus. Évidemment, les événements associés à cela sont OnMouseOver, OnMouseOut. Dans le
OnMouseOver, nous plaçons le code suivant :
this.style.color='blanc';
this.style.backgroundColor='rouge';
Comme vous pouvez le voir, cette fois le code a été entré directement dans l'événement au lieu d'appeler une
fonction (pas nécessaire dans ce cas non plus). Vous pouvez également envisager que plus d'une instruction puisse
être saisie. Dans le OnMouseOut, nous plaçons le code suivant :
this.style.color='blanc';
this.style.backgroundColor='vert';
Maintenant, lorsque vous déplacez la souris sur le bouton, l'arrière-plan devient rouge et le texte blanc. Lorsque
le pointeur de la souris quitte le bouton, la couleur d'arrière-plan passe au vert.

Javascript 85
Jusqu'à présent, nous avons vu comment associer des événements à un contrôle particulier et comment interagir avec les
valeurs/propriétés du contrôle. L'étape suivante consiste à voir comment interagir avec d'autres objets sur la page.
Les contrôles IW sont rendus sous forme d'objet nommé avec le format suivant :
COMPONENT_NAME{IWCL}
Par exemple, si nous avons déposé un bouton sur le formulaire nommé IWButton1, l'élément HTML
correspondant serait :
IWBUTTON1IWCL
De cette façon, il est facile de se référer à d'autres contrôles. Par exemple, nous pouvons saisir la valeur suivante dans
l'événement OnChange d'un IWEdit :
IWBUTTON1IWCL.style.color='marron';
De cette façon, lorsque la valeur d'un IWEdit change, la couleur du bouton passe automatiquement au marron.
14.4 Fonctions Javascript

14.4.1 Fonctions communes
IntaWeb comprend plusieurs fichiers de script avec des fonctions JavaScript qui sont utilisées en interne. Certaines de ces
fonctions peuvent également être appelées par le développeur pour effectuer certaines actions. Voici une liste des plus
courantes :
FindElem
FindElem prend en paramètre un nom d'objet et renvoie l'objet s'il est trouvé. Vous pouvez utiliser cette fonction
pour trouver l'instance d'un certain élément sur le formulaire.
SoumettreCliquerConfirmer
SubmitClickConfirm est très souvent utilisé dans IntaWeb. Il faut quatre paramètres :
fonction SubmitClickConfirm (AObjectName, AParam, ADoValidation, AConfirmation)
Le premier est le nom de l'objet, le second est un paramètre passé à l'action du formulaire. Le troisième
indique si la validation est requise ou non et le quatrième indique la chaîne de confirmation. Cette fonction est
utilisé chaque fois qu'une chaîne de confirmation est entrée dans un contrôle prenant en charge la propriété. Ce
qui se passe est le suivant :
Lors de la saisie d'une valeur dans la propriété confirmation d'un TIWButton par exemple, le code suivant est appelé :
SubmitClickConfirm("IWBUTTON1", "", True, "Vouliez-vous vraiment cliquer sur ce bouton ?")
Ce qui se passe alors, c'est que SubmitClickConfirm appelle une boîte de validation avec le texte passé en
paramètre. Si la boîte de confirmation renvoie True, le formulaire sera soumis. Sinon, il ne sera pas soumis.

86 Manuel IntraWeb
Lorsque vous ajoutez du code avant un SubmitClickConfirm, assurez-vous que le code que vous ajoutez renvoie un True ou
False afin que le formulaire soit soumis en conséquence.

Section
XV
88 Manuel IntraWeb
15 Mode pages
Le mode page n'est disponible que dans Delphi 5-7 et C++ Builder. Dans Delphi 8 et Visual Studio.Net, ASP.net
peut être utilisé à la place du mode page.
15.1 Introduction au mode page
IntaWeb peut être utilisé en mode application ou en mode page. Ce dernier utilise d'autres technologies telles
que WebBroker ou WebSnap, permettant au développeur de combiner les connaissances existantes
avec la technologie RAD. Bien que dans la plupart des cas, le mode application soit la voie à suivre, le mode page offre
une approche intéressante du développement Web. Pour comprendre la différence entre les deux, voyons un scénario
dans lequel chacun s'intégrerait de manière appropriée.
Si vous développez une application (ou une weblication) où la gestion de l'état est requise et chaque étape est
imbriqué avec le précédent, tel qu'un système de gestion relationnelle des contacts, le mode candidature serait le
plus approprié. C'est parce que l'ensemble de l'application s'intègre parfaitement dans un scénario d'automates.
Par exemple, dans les systèmes CRM normaux, un utilisateur se connecte et se voit présenter un menu à partir
duquel il peut accéder à différents utilitaires tels que la gestion des contacts, les factures des clients, etc.
Ceux-ci sont tous liés au même utilisateur, où M. Smith a certains contacts et Miss Jones en a d'autres. La gestion
de session joue ici un rôle important et le suivi de l'ensemble de la "session" est très important.
D'autre part, s'il existe un site Web où se trouvent diverses sections indépendantes, telles que News,
Cotations boursières et livre d'or, aucun de ceux-ci n'est vraiment lié entre eux. Une personne peut vouloir voir les nouvelles
alors qu'une autre personne aimerait laisser sa signature. Il n'y a pas de "suivi de session" en tant que tel, pas besoin de se
rappeler si l'utilisateur qui a demandé des nouvelles a également demandé des cotations boursières. C'est là que le mode Page
s'intègre parfaitement.
La principale différence lorsque l'on travaille avec le mode Page par opposition au mode Application, est que le
premier n'offre aucun type de gestion d'état ou de session. Tout cela doit être pris en charge par le développeur en
utilisant la technologie existante telle que WebBroker (ou WebSnap). Encore une fois, dans la plupart des cas, la
gestion de session n'est pas requise dans ces cas. Il est très important de réfléchir à ce qu'est exactement
est le but de l'application Web avant de décider d'utiliser le mode page ou le mode application, c'est-à-dire qu'il s'agit d'une application à
part entière en cours de développement ou d'un site dynamique.
Lors du développement de sites dynamiques avec le mode Page, la technologie sous-jacente (comme mentionné
précédemment) doit être WebBroker ou WebSnap. IW permet d'ajouter à cette épine dorsale en fournissant des "pages" à
interfaces de conception. Considérez le mode Page comme des pages où chaque page peut être conçue à l'aide de la
technologie RAD avec un glisser-déposer de contrôles visuels IW. Par conséquent, la première étape consiste à décider
si WebBroker ou WebSnap va être utilisé.
15.2 Travailler avec le mode page
La chose la plus importante à retenir lorsque vous travaillez avec PageMode, c'est qu'il s'agit essentiellement d'un complément
à d'autres technologies telles que WebBroker ou WebSnap. Par conséquent, il est essentiel que vous connaissiez et compreniez
l'une ou l'autre de ces technologies pour développer avec succès des applications à l'aide de PageMode. Sur le site Web
d'Atozed, il existe un tutoriel sur WebBroker pour les débutants.
WebBroker est une interface de bas niveau. Le problème est qu'il est souvent présenté comme étant de haut niveau. PageMode
peut être considéré comme des "plugins" qui reposent sur WebBroker (ou WebSnap), ce qui signifie que vous ne créez pas
réellement une application IW mais plutôt une application WebBroker dont certaines parties sont générées à l'aide d'IW.
Considérez IW dans PageMode comme un module complémentaire "tiers" à WebBroker.
La première étape consiste à créer une nouvelle application WebBroker. Dans ce cas, une DLL ISAPI sera créée. Pour

Mode pages 89
pour plus d'informations sur WebBroker, consultez l'aide en ligne Delphi ou les didacticiels sur le site Web d'Atozed.
Une fois l'application WebBroker créée, un nouveau formulaire IW sera ajouté au projet. À faire
cela, utilisez la page de l'assistant IntaWeb dans le référentiel d'objets. Selon que l'application va
être conçue pour les appareils PDA, PageForm 3.2 doit être choisi par opposition à PageForm.
Après avoir cliqué sur le bouton Ok, un nouveau formulaire IW s'affichera. Ce formulaire est très similaire aux
formulaires IW utilisés en mode application, mais il possède certaines propriétés spécifiques liées au mode page. En
particulier, il y a trois propriétés qui sont importantes :
- Traitement automatique
- FormulaireAction
- PostToSelf
Ce qu'AutoProcess indique, c'est si les paramètres seront automatiquement lus et mis en correspondance avec les composants du
formulaire. Dans la plupart des cas, cela doit être défini sur True. Étant donné que ce formulaire représente un véritable "formulaire
HTML", une propriété importante de tout formulaire HTML est l'action de formulaire. Cette propriété peut être définie à l'aide de
FormAction. Cependant, dans la plupart des cas, la FormAction consisterait à appeler le sous-jacent
IWPageForm lui-même, donc en définissant la propriété PostToSelf sur True, cela sera pris en charge et
FormAction peut être laissé vide. Si, d'un autre côté, la publication doit être gérée par une WebAction
définie dans le WebModule, PostToSelf devrait être défini sur False et FormAction devrait contenir l'action
appropriée.
Dans le cas de cet exemple (voir PageForms dans le répertoire Demo), PostToSelf est défini sur True et FormAction est
laissé vide. L'étape suivante consiste à supprimer certains contrôles sur le formulaire.

90 Manuel IntraWeb
Dans ce cas, un IWLabel et une IWURL sont placés sur le formulaire. L'étape suivante consiste à créer un deuxième formulaire IW. Encore une fois,
en utilisantFichier -> Nouveau -> IntaWeb -> Nouveau formulaire un nouveau formulaire de page est créé. Avant de placer un code sous l'une ou
l'autre forme, certaines étapes préalables sont nécessaires.
Noter: Certaines unités peuvent ne pas être incluses automatiquement dans le nouveau formulaire de page. Si le compilateur se plaint
de symboles non déclarés, vérifiez d'abord s'ils ne figurent pas dans ces unités : IWApplication,
IWTemplateProcessorHTML, IWLayoutMgr et/ou IWHTMLControls.
Lors de l'utilisation de PageMode, la technologie sous-jacente se charge d'afficher les formulaires. En mode Application, un
formulaire serait affiché en utilisant quelque chose comme :
TIWForm.Create(WebApplication).Show;
Dans le cas de PageMode, c'est légèrement différent.
Pour afficher le premier formulaire, définissez une WebAction dans le WebModule comme /main :

Mode pages 91
Définissez la valeur par défaut sur True et définissez PathInfo et Name (comme indiqué dans la figure ci-dessus). Comme
pour toute application WebBroker normale, il existe deux manières de renvoyer une réponse. L'un utilise le
biens Producteur et l'autre est en le définissant dans le code. Dans ce cas, la même chose peut être faite pour
afficher le formulaire IW. Cependant, deux étapes préalables sont requises. La première est unique par
application et consiste à utiliser un IWModuleController. Il s'agit d'un composant qui crée automatiquement un
IWServerController. Il suffit de déposer UN de ces composants sur le WebModule :
Il n'y a pas de propriétés ou d'événements supplémentaires qui doivent être attribués. Il suffit d'en
placer un sur le WebModule.
L'étape suivante requise pour afficher un formulaire IW consiste à utiliser un composant IWPageProducer. UN est requis PAR
formulaire (ou affectez-le dynamiquement au moment de l'exécution). Ce composant n'a qu'un seul événement qui est
les OnGetForm. Cet événement renvoie le contenu du formulaire IW au courtier :

92 Manuel IntraWeb
procédure TWebModule1.prodMainGetForm(ASender: TIWPageProducer;

AApplication Web : Application TIW ; var VForm : TIWPageForm);
commencer
VForm := TformMain.Create(AWebApplication);
finir;
Ceci est similaire à ce qui est utilisé en mode Application, sauf qu'ici, au lieu de faire un Show, le résultat de la création
du formulaire est affecté au paramètre VForm. L'étape suivante consiste à affecter le producteur à l'action Web à l'aide
de l'inspecteur d'objets. Puisqu'il existe un deuxième formulaire dans cette application, les mêmes étapes sont
effectuées pour le deuxième formulaire. Comme le montre l'événement, le propriétaire du
form est également passé en paramètre (AWebApplication). Une seconde WebAction doit être définie pour afficher le
second formulaire. Cela se fait à nouveau d'une manière similaire à la première WebAction.
Remarque : lors de l'ajout d'un IWPageProducer et de l'affectation de l'événement dans le WebModule, deux unités
doivent être ajoutées à la clause uses, IWApplication et IWPageForm (IWPageForm32).
Il ne reste plus qu'à afficher le deuxième formulaire du premier à l'aide d'une IWURL. Pour ce faire, il suffit
d'appeler la WebAction qui produit le deuxième formulaire. L'URL peut être attribuée à l'IWURL dans
l'événement OnCreate du formulaire :
procédure TformMain.IWPageFormCreate(Expéditeur : TObject);

commencer
IWURL1.URL := WebApplication.URLBase + '/seconde';

finir;
Le deuxième formulaire demande un nom et affiche une étiquette. Celui-ci est programmé exactement de la même manière qu'en mode
application.
Par conséquent, vous pouvez voir que travailler avec PageMode vous donne la flexibilité RAD d'IW et vous permet
travailler avec les technologies existantes. Une grande partie de la façon dont les choses sont faites coïncide avec le mode d'application,
à l'exception de quelques différences mineures qui ont été mentionnées dans cet exemple.
15.3 IntraWeb et Websnap

Cette section fournit une brève introduction sur la façon dont IntaWeb peut être intégré à WebSnap. Une démo
sera construite qui utilise WebSnap pour fournir le cadre, la connexion et la gestion de session. IntaWeb sera
utilisé pour fournir l'interface utilisateur. Dans ce mode d'intégration, les produits sont assez
gratuit.
La démo est une démo simple qui prend en compte deux questions qui sont d'une importance vitale pour la
communauté de programmation. Les deux questions sont :
1. Quel a été le MEILLEUR film de Star Trek ?

2. Quel a été le PIRE film Star Trek ?
Il recueillera ensuite votre vote et le compilera avec les autres électeurs. Pour voir cela, exécutez simplement la démo
dans le navigateur plusieurs fois. Après avoir compilé les votes, il générera un petit graphique affichant les résultats. Le
code source complet de la démo est inclus dans le répertoire demos. Nous l'avons conçu pour qu'il soit le plus simple
possible afin de le rendre facile à suivre. Il démontre ce qui suit :
1. Intégration d'IntaWeb avec WebSnap.

2. Utilisation du mode page IntaWeb.
3. Utilisation de la gestion de session WebSnap avec IntaWeb.

Mode pages 93
4. Utilisation de WebSnap pour le contrôle de l'authentification.

5. Utilisation d'IntaWeb pour fournir l'interface Web principale.
15.3.1 Création de la démo

Il est supposé que vous connaissez WebSnap et nous allons donc simplement montrer les parties spécifiques à IntaWeb lors de la
création de cette démo. Nous avons commencé avec une application WebSnap standard qui contenait la prise en charge de la connexion
à l'aide d'un TWebUserList et d'un TLoginFormAdapter.
La première chose à faire pour utiliser IntaWeb avec WebSnap est d'ajouter un TIWModuleController. Pour simplifier la distribution et ne
pas exiger la distribution de fichiers externes, IntaWeb sert des fichiers "internes" à partir de ses bibliothèques. IntaWeb a plusieurs
fichiers internes et en tant qu'utilisateur, vous pouvez en ajouter d'autres en utilisant l'API d'IntraWeb.
TIWModuleController se connecte au mécanisme de répartition de WebSnap et fournit cette fonctionnalité ainsi que
d'autres exigences fondamentales d'IntaWeb. Ce composant peut également être utilisé pour utiliser IntaWeb avec
WebBroker et est illustré dans la démo GuessWB fournie avec IntaWeb.
Pour que TIWModuleController soit efficace, le module d'application a également besoin d'un TWebDispatcher.
Si votre application n'a pas encore de TWebDispatcher, ouvrez simplement le module d'application et ajoutez un
TWebDispatcher (depuis l'onglet Internet) puis un TIWModuleController (depuis l'onglet IntaWeb Control).
Aucune autre modification n'est requise, IntaWeb et WebSnap feront le reste.
Votre module d'application devrait maintenant ressembler à ceci :
Ensuite, nous avons créé un nouveau module de page WebSnap. Pour ce faire, nous avons sélectionnéFichier : Nouveau : Autre : Onglet WebSnap :
Module de page WebSnap. La boîte de dialogue est affichée ici :

94 Manuel IntraWeb
Après avoir cliqué sur OK, Delphi affichera la boîte de dialogue Nouveau module de page WebSnap comme illustré ici :

Mode pages 95
Faites en sorte que les paramètres correspondent aux paramètres comme indiqué dans la figure ci-dessus et sélectionnez OK. Delphi va
maintenant créer un nouveau module de page WebSnap. Ça devrait ressembler à ça:
Supprimez le TPageProducer et créez un TIWPageProducer (à partir de l'onglet IntaWeb Control). Le module de page devrait
maintenant ressembler à ceci :
Enregistrez le module de page et nommez-le Page1Module.pas. Nous devons maintenant créer un formulaire de page IntaWeb.
Sélectionner Fichier : Nouveau : Autre : IntaWeb : Nouveau Formulaire. Sélectionnez le bouton radio Formulaire de page, puis cliquez sur
OK. Enregistrez le formulaire sous Page1Form.pas. Revenons maintenant en arrière et lions Page1Module à Page1Form. Pour ce faire,
créez un événement OnGetForm pour le TIWPageProducer. L'événement doit ressembler à ceci :
procédure TPage1.IWPageProducer1GetForm(ASender: TIWPageProducer;

AApplication Web : Application TIW ; var VForm : TIWPageForm);
commencer
VForm := TformPage1.Create(AWebApplication);
finir;
Cela crée une instance de TformPage1 à la demande. Pour que l'unité compile IWApplication et IWPageForm
doivent également être ajoutés à la clause uses.
Revenons maintenant à Page1Form et créons nos questions d'enquête. Nous avons créé deux TIWLabel
composants, deux TIWComboboxes, un TIWButton et un TIWText. Pour les zones de liste déroulante, nous avons également
défini RequireInput = False. Notre Page1Form ressemble maintenant à ceci :

96 Manuel IntraWeb
Ensuite, nous ajouterons le code de l'événement OnCreate du formulaire. Double-cliquez sur le formulaire et entrez ce code. Le code
charge simplement le texte et les numéros d'identification dans les zones de liste déroulante.
procedure TformPage1.IWPageFormCreate(Sender: TObject);

var
i : TSTMovie ;
commencer
pour i := Low(i) to High(i) commence

cmboBest.Items.AddObject(GMovies[i], TObject(i));
finir;
(cmboBest.Items);
finir;
Nous allons maintenant ajouter un événement OnClick pour le bouton. Double-cliquez sur le bouton et ajoutez ce code :
procedure TformPage1.butnVoteClick(Sender: Tobject); var
Meilleur : TSTMovie ;
Le pire : TSTMovie ;
commencer
LBest := miMotionPicture;
LWorst := miMotionPicture;
if cmboBest.ItemIndex = -1 then begin
textMsg.Lines.Text :=
'Veuillez sélectionner un choix pour le meilleur film Star
Trek.'; end else if cmboWorst.ItemIndex = -1 then begin
textMsg.Lines.Text :=
'Veuillez sélectionner un choix pour le pire film de Star Trek.'; fin
sinon commencer
LBest := TSTMovie([cmboBest.ItemIndex]);
LWorst := TSTMovie([cmboWorst.ItemIndex]); si
LBest = LWorst alors commencer
textMsg.Lines.Text := 'Désolé - mais vous ne pouvez pas choisir le même film pour
le meilleur et le pire.';
fin sinon commencer
if WebContext.Session.Values['Confirm'] <> 'Y' then begin if
LBest = miFinalFrontier then begin
textMsg.Lines.Text := 'Ugh. The Final Frontier était vraiment horrible.
Êtes-vous sûr que c'est
+ 'votre choix pour le meilleur ?';

Mode pages 97
butnVote.Caption := 'Votez avec mon choix discutable de toute façon';

WebContext.Session.Values['Confirm'] := 'Y'; end
else si LBest = miVoyageHome alors commencer
textMsg.Lines.Text := 'Bon choix ! La maison Voyage était bonne
n'est-ce pas ?';
butnVote.Caption := 'Enregistrer mon vote !';
WebContext.Session.Values['Confirm'] := 'Y';
finir;
finir;
finir;
finir;
textMsg.Visible := textMsg.Lines.Count > 0;
sinon textMsg.Visible alors commencez RecordVote(LBest, Lworst);
ProduceResponse := False; DispatchPageName('PageResults',
WebContext.Response, []);
finir;
finir;
Maintenant, nous pourrions passer beaucoup de temps à expliquer le code ci-dessus. Mais avez-vous remarqué quelque chose ? C'est tout le
code Delphi standard ! Nous allons donc juste expliquer quelques lignes d'intérêt.
Le code vérifie si l'utilisateur a sélectionné des informations et s'assure également qu'il ne sélectionne pas le
même film pour les deux choix. Il entre également dans son opinion personnelle sur certains choix et
affiche des messages à l'utilisateur en rendant le composant TIWText visible. Si le composant TIWText n'est pas rendu
visible, aucun message ne s'affiche et tout va bien. Dans ce cas, le code appelle RecordVote qui est une procédure dans
Global.pas qui fait partie de la démo. Il définit ensuite ProduceResponse sur False. Cela indique à IntaWeb de ne pas
rendre cette page car nous la rendrons manuellement ou donnerons à WebSnap
instructions pour le faire. Enfin, nous donnons des instructions à WebSnap pour afficher un module de page différent afin
d'afficher les résultats.
Il y a quelques propriétés sur le formulaire lui-même que nous devons également définir.
1.Réglez PostToSelf sur true. Cela indique au formulaire de générer des liens qui renverront les données à ce
même forme. FormAction peut être défini si vous souhaitez que les données soient soumises à un autre
formulaire. FormAction et PostToSelf (lorsque vrai) s'excluent mutuellement.
2.Réglez AutoProcess sur true. Cela indique au formulaire d'analyser automatiquement les variables HTTP et de définir les
états des composants en conséquence. Si vous souhaitez contrôler ce processus manuellement, vous laisseriez
AutoProcess à false.
Ensuite, nous allons créer un autre module de page et un autre formulaire de page. Les étapes sont à peu près comme la précédente,
nous ne perdrons donc pas de place là-dessus. Au lieu de cela, nous commencerons par un formulaire de page bancaire,
PageResultsForm.pas. Nous avons ajouté une TIWImage et chargé un bitmap dedans. Cela ressemble à ceci :

98 Manuel IntraWeb
Pour ce formulaire, nous avons créé un seul événement. Nous avons mis du code de dessin dans l'événement OnRender.
L'événement OnRender se produit chaque fois qu'IntaWeb rend un formulaire, avant qu'il ne soit réellement
rendu. Voici le code de l'OnRender :
procedure TformResults.IWPageFormRender(Sender: Tobject); var
i : TSTMovie ;
LMaxBest : Entier ;
LMaxWorst : nombre entier ;
LMaxWidth : entier ;
LVotesBest : Tlist ;
LVotesPire : Tlist ;
commencer
LMaxMeilleur := 0;
LMaxWorst := 0;
LMaxWidth := 0;
LVotesBest := TList.Create; essayez
LVotesWorst := TList.Create; essayez
GetVotes(LVotesBest, LvotesWorst);
avec imagResults.Picture.Bitmap.Canvas, commencez
Brush.Style := bsClear;
Font.Color := clBlue;
Font.Name := 'Script';

Mode pages 99
Taille.Font := 18;
for i := Low(i) to High(i) commence
TextOut(85, 98 + 24 * Ord(i), Gmovies[i]);
LMaxWidth := Max(LMaxWidth, TextWidth(GMovies[i]));
LMaxBest := Max(LMaxBest, Integer(LVotesBest[Ord(i)]));
LMaxWorst := Max(LMaxWorst, Integer(LVotesWorst[Ord(i)]));
finir;
TextOut (330, 74, 'Meilleur');
TextOut(480, 74, 'Pire'); //
Brush.Style := bsSolid;
pour i := Low(i) to High(i) commence
Brush.Color := Gcolors[i];
RemplirRect(Rect(310, 98 + 24 * Ord(i)
, 310 + Trunc((Entier(LVotesBest[Ord(i)]) / LMaxBest) * 150)
, 98 + 24 * Ord(i) + 20));
Brush.Color := GColors[TSTMovie(Ord(High(i)) – Ord(i))];
RemplirRect(Rect(480, 98 + 24 * Ord(i)
, 480 + Trunc((Entier(LVotesWorst[Ord(i)]) / LMaxWorst) * 150)
, 98 + 24 * Ord(i) + 20));
finir;
finir;
enfin FreeAndNil(LVotesWorst); finir;
enfin FreeAndNil(LVotesBest); finir; finir;
15.3.2 Exécuter la démo

Nous avons maintenant couvert les parties importantes de la démo elle-même. Voyons à quoi cela ressemble lorsque nous
l'exécutons. Compilez et exécutez d'abord la démo, puis exécutez le débogueur d'application Web à partir du menu Outils.
Dans le débogueur d'application Web, cliquez sur le lien URL, puis sélectionnez WebSnapSurvey.Survey dans le
navigateur. Cela lancera notre application de démonstration. Ça devrait ressembler à ça:

100 Manuel IntraWeb
Cet écran est produit par l'adaptateur de connexion WebSnaps. Entrez test pour le nom d'utilisateur et test pour le mot de
passe et cliquez sur Connexion. Cet écran apparaît maintenant :

Mode pages 101
Maintenant, sélectionnez vos choix et cliquez sur voter. Maintenant, il affichera l'écran de résultat :

102 Manuel IntraWeb
15.4 Pages IntraWeb (IWP)

15.4.1 Introduction à IWP
IntaWeb version 6 introduit les IWP (IntaWeb Pages). Vous pouvez considérer les IWP comme des pages côté
serveur qui sont traitées automatiquement par une application ISAPI/DSO. Ils sont similaires à la même philosophie
queaspic pages.
Le concept derrière IWP est que vous pouvez créer des pages HTML statiques et dynamiques avec n'importe quelle
extension que vous voulez (par défaut, IWP est utilisé bien que vous n'ayez pas besoin de le spécifier n'importe où dans
votre application) et le serveur Web traite les pages et renvoie soit contenu dynamique ou statique
selon la nature de la page. Considérez-le comme un processus inverse de ce qu'est PageMode. Pour
développer un peu plus cela, voyons d'abord comment fonctionne PageMode.
ModePage
La première chose que vous devez faire lors du développement d'applications PageMode est de créer votre

Mode pages 103
WebBroker/WebSnap et ajoutez des formulaires IWPageForm (alternativement pour 3.2, vous utiliseriez
IWPageForm32) à votre projet. Vous concevriez ensuite le formulaire et y ajouteriez la fonctionnalité
dynamique. Une fois terminé, vous utiliseriez un TIWPageProducer pour renvoyer le contenu au
client (navigateur). Vous pouvez éventuellement utiliser un modèle pour personnaliser le formulaire.
IWP fonctionne sur le même principe, sauf que dans ce cas, votre première étape consiste à créer votre modèle HTML puis
votre formulaire. Bien que vous puissiez le faire dans l'ordre inverse, cela a plus de sens de cette façon puisque
IWP tirer le contenu du modèle. Autrement dit, dans le traitement de modèle normal, le descendant
IWForm recherche un modèle et remplace les contrôles par ceux du formulaire. Dans les IWP, le
TEMPLATE recherche les contrôles et ils sont remplacés au moment de l'exécution. Le modèle extrait les
informations du formulaire.
IWP n'est pas seulement limité au précédent, mais il rend également la tâche de développer des sites Web
dynamiques encore plus simple qu'elle ne l'utilise maintenant avec PageMode. Voyons unpas à pas approche sur la
façon de créer un site Web IWP.
15.4.2 Création du projet

Les pages IWP fonctionnent avec tout type de framework Internet Delphi (CBuilder ou Kylix) que vous souhaitez utiliser (comme toutes les
applications PageMode). Vous pouvez utiliser WebSnap ou WebBroker par exemple.
La première étape consiste à créer une nouvelle application Web Server. Une fois que vous avez le WebModule, vous devez
déposer 2 composants sur le formulaire. Le premier, comme toutes les applications PageMode avec IW est le
IWModuleController. Le second est soit unTIWPageController ou un TIWPageController32
selon que vous créez un projet 4.0 ou 3.2. Évidemment, vous pouvez combiner les deux types
d'applications dans un même projet en supprimant l'un de chaque composant.
Les TIWPageController est un composant simple mais puissant. Il n'y a pas d'événements et seulement 2 importants
Propriétés. Comme nous le verrons plus loin, ce composant gère les tâches nécessaires pour trouver la page IWP
correspondante, analyser le contenu, générer le formulaire et renvoyer le résultat au navigateur. Il n'y a pas besoin d'un
TIWTemplateProcessor ou un TIWPageProducer. Ceux-ci sont à la fois inhérents au composant et utilisés de manière
transparente. Les seules propriétés requises sont reflétées dans la figure ci-dessous :
Les Type de balise La propriété indique le type de balise que vous utiliserez dans vos pages IWP. Par défaut c'est le
ttIntraWeb tag (qui est représenté en encadrant les noms de contrôle dans {%....%}). Vous pouvez également définir
ceci aux balises de style Borland. L'autre propriété pertinente est laURL de l'application qui spécifie le chemin de
l'URL virtuelle vers votre application. Ainsi, par exemple, si votre répertoire de scripts sur votre serveur Web est/
scripts et ton projet s'appelle projet1.dll, alors cette propriété prendrait la valeur /scripts/projet1.dll/ (notez le
préfixe et le suffixe du caractère /).
C'est tout ce que vous devez faire avec ces propriétés. L'étape suivante consiste à enregistrer le projet et éventuellement
définir le chemin de sortie sur celui de votrescripts emplacement du répertoire.
Une fois cela fait, nous pouvons passer à configuration du serveur pour travailler avec IWP et ensuite continuer avec la
conception de nos pages.
15.4.3 Préparation du serveur

L'une des étapes requises lorsque vous travaillez avec des IWP consiste à configurer votre serveur Web pour identifier ces fichiers en
tant que fichier "spécial" nécessitant un traitement côté serveur.

104 Manuel IntraWeb
Vous trouverez ci-dessous les instructions sur la façon d'accomplir cela avec Omni HTTP et IIS.
Configuration d'Internet Information Server

Ouvrez Internet Information Services Manager et choisissez le site Web sur lequel vous souhaitez déployer les IWP.
Faites un clic droit et choisissezPropriétés.
Clique sur le Accueil Répertoire onglet et cliquez sur le Configuration bouton. S'il est désactivé, vous devez d'abord créer un
domaine d'application. Une fois la boîte de dialogue de configuration ouverte, choisissez leMappages onglet et
clique sur le Ajouter bouton. Cela présentera la boîte de dialogue pour ajouter le mappage d'application IWP.
Dans la zone Exécutable, nous devons entrer le chemin d'accès à notre projet. Dans notre cas, nous pouvons entrer
c:\inetpub\scripts\project1.dll . L'étape suivante consiste à définir l'extension que nous allons utiliser. Par défaut, vous pouvez
utiliser.iwp, cependant, cela peut être tout ce que vous voulez. Une fois terminé, cliquez sur OK dans toutes les cases.
L'étape facultative suivante consiste à ajouter l'index aux propriétés par défaut du document. C'est ainsi que si vous
placez le fichier dans un dossier portant le nomindex.iwp par exemple, IIS identifiera cela comme une demande
valide et vous renverra la page SI l'URL ne contient PAS le nom du fichier (par exemple, http://
www.mondomaine.com).
Important : Vous ne pourrez valider l'entrée que si l'exécutable existe.
Configuration d'Omni HTTPD

La configuration d'OmniHTTPD est fondamentalement la même que celle d'IIS. La première étape consiste à ajouter
l'application de projet qui gérera les pages IWP. Lancez Omni et cliquez surPropriétés. Cliquez ensuite surParamètres
généraux du serveur Web.
Clique sur le Externe onglet et entrez l'extension dans le Virtuel zone d'édition. Dans leRéel , entrez
l'emplacement du projet qui va gérer les pages IWP. Une fois terminé, cliquez sur leAjouter bouton
et cliquez ensuite sur d'accord. L'étape suivante consiste à ajouter l'entrée IWP auMIME Les paramètres. Pour cela, cliquez sur leMIME
onglet et comme avant, entrez les paramètres comme ci-dessous :
Cliquez sur Ajouter puis D'ACCORD. C'est ça. Omni est maintenant configuré pour gérer les pages IWP. N'oubliez pas que si vous
choisissez une extension différente, vous devez entrer une valeur différente dans les zones d'extension correspondantes.

Mode pages 105
15.4.4 Création d'une page IWP
Les pages IWP sont comme des pages HTML normales, en fait ce sont des pages HTML normales. La seule différence est qu'ils
incluent éventuellement une section d'en-tête spéciale et des balises pour représenter les contrôles. Ceci est facultatif car,
comme mentionné précédemment, IWP peut être dynamique ou statique. Dans ce dernier cas, il n'est pas nécessaire d'ajouter
autre chose que votre code HTML normal.
Voici un exemple de source HTML pour une page IWP statique :
<html>
<corps>
Ceci est ma première page statique IWP
</body>
</html>
Comme on peut le voir, il n'y a rien de spécial à propos de la page précédente. Cette page est renvoyée telle quelle par l'application
IWP puisqu'elle est identifiée comme statique.
Cependant, la véritable puissance des pages IWP réside dans le fait qu'elles renvoient un contenu dynamique qui interagit avec le
application PageMode côté serveur. Lorsque vous fournissez du contenu dynamique, vous devez ajouter une section
d'en-tête spéciale à la page IWP. Cette section est jointe à<intraweb:en-tête> tags et a actuellement deux paramètres :
Nom de forme et Gestionnaire. Un exemple de ceci serait :
<intraweb:en-tête>
NomFormulaire=IWForm1
Gestionnaire=AutrePage
</intraweb:header>
Les Nom de forme et Gestionnaire ne sont pas tous les deux requis. Avant d'expliquer ce que chacun fait,
voyons comment fonctionnent les pages IWP. LesIWPageController qui a été déposé sur leWebModule lors de la
création du projet est le moteur derrière IWP. Il s'occupe d'enregistrer tous les formulaires du projet, de
rechercher le formulaire correct lorsqu'une demande arrive et de renvoyer le contenu, entre autres tâches.
Cependant, tout cela ne se fait pas par magie ! Ce que ce composant a besoin de savoir pour chaque requête
envoyée au serveur, c'est quel est le nom de formulaire ou le gestionnaire correspondant pour cela
page.
Si la Nom de forme est spécifié dans la section d'en-tête, le IWPageController recherchera le projet
correspondant IWPageForm avec le même nom et l'utiliser pour les
En traitement. Si laNom de forme n'est pas spécifié, il recherchera alors un Gestionnaire. Qu'est-ce qu'unGestionnaire? C'est un
WebAction.
Définition des WebActions

Bien que cela ne soit pas nécessaire, IWP vous permet de définir une action Web pour gérer un formulaire (page). Comme les
applications PageMode normales, vous pouvez définir une WebAction qui utilise unTIWPageProducer pour retourner le contenu du
formulaire et effectuer en même temps d'autres actions supplémentaires. Cependant, cela n'est pas obligatoire et ajoute en quelque
sorte une surcharge (en ce qui concerne le temps de développement) lors de l'utilisation d'IWP).
Vous pouvez le faire si vous en avez spécifiquement besoin, sinon, en spécifiant simplement le Nom de forme dans la section d'en-
tête, vous pouvez laisser IWP s'occuper de tout le traitement pour vous.
Par conséquent, pour chaque contenu de page dynamique que vous souhaitez ajouter à votre site Web, celui-ci a un
IWPageForm (32), ajouter le <intraweb:en-tête> section avec le Nom de forme paramètre. Cette balise est
transparente au HTML et lorsque la page a été traitée et renvoyée au navigateur, cette section est
supprimée.
Création d'une page IWP dynamique

La page ci-dessous est un exemple simple d'une page dynamique IWP, mais est idéale pour la démonstration

106 Manuel IntraWeb
fins. Fondamentalement, il se compose d'une page Web statique avec une étiquette dynamique qui renvoie la date et l'heure actuelles.
Vous pouvez utiliser n'importe quel outil de développement de page Web pour le créer.
<html>
<tête>
<intraweb:section>
NomFormulaire=IWForm1
</intraweb:section>
</head>
<corps>
Ceci est ma première page IWP dynamique. Si vous regardez ci-dessous, vous verrez le
courant
date et l'heure.
<BR>
<BR>
Date et heure actuelles : {%IWLabel1%}
Au revoir!
</body>
</html>
Les L'étape suivante est de créer le correspondant IWPageForm pour cela dans notre projet
15.4.5 Création d'un formulaire IWP
Comme mentionné précédemment, les sites Web IWP peuvent avoir un contenu à la fois statique et dynamique. Les formulaires sont
UNIQUEMENT requis lorsque la page IWP renvoie un contenu dynamique.
Dans Création d'une page IWP nous avons vu comment créer la page HTML pour notre page IWP dynamique. Ici,
nous allons voir comment fournir le contenu dynamique.
La première étape consiste à ajouter un nouveau IWPageForm à notre projet de serveur Web. Encore une fois, si vous
concevez des applications 3.2, vous devrez créer unIWPageForm32 former.
Créer un nouveau IWPageForm en cliquant sur Fichier -> Nouveau et en choisissant IntaWeb languette. Clique sur leFormer
assistant et choisissez un Formulaire de page. Une fois que vous avez le formulaire dans le concepteur, déposez unTIWLabel dessus.
Assurez-vous que le formulaire est nommé IWForm1 (qui correspond à la Nom de forme paramètre dans la page IWP).
Dans leOnRender événement, écrivez le code suivant :
procédure TIWForm1.IWPageFormRender(Sender: TObject);

commencer
IWLabel1.Caption := FormatDateTime('jjj, jj de mmm, aaaa. hh:nn', maintenant);

finir;
Il ne reste plus qu'à enregistrer le projet et à le compiler. Une fois l'exécutable prêt, cliquez sur
Déploiement des fichiers
15.4.6 Déploiement des fichiers
Le déploiement d'IWP est une tâche très simple. Outre la configuration du serveur Web pour traiter les pages IWP, la seule autre
tâche consiste à copier les fichiers au bon emplacement.

Mode pages 107
Indépendamment du serveur Web que vous utilisez, il y a deux choses qui doivent être déployées : les pages
statiques et dynamiques sont la première, et l'application Web réelle est la seconde. Les pages (indépendamment du
fait qu'elles soient statiques ou dynamiques) doivent être placées dans le dossier où votre site Web
le serveur héberge des pages Web. Dans IIS, c'est normalementwwwroot par défaut. Dans Omni, c'esthtdocs.
L'application doit être déployée sur le chemin physique vers lequel pointe votre dossier de scripts virtuels.
Cela doit coïncider avec leURL de l'application valeur saisie dans le IWPageController.
Appeler les pages IWP

Une fois tous les fichiers déployés, il ne vous reste plus qu'à appeler la page en question. Par exemple, si votre site
s'appelle www.mondomaine.com et que votre page IWP s'appelle first.iwp, ouvrez simplement le navigateur et
tapez http://www.mondomaine.com/first.iwp.
Le serveur web (via l'association que nous avons faite en Préparation du serveur) sait automatiquement que lorsqu'une
extension IWP (ou toute autre extension que vous mettez) est demandée, elle lancera le web correspondant
application (dans notre cas projet1.dll).
Comme vous pouvez le voir, IWP présente un moyen très simple mais puissant de créer des sites Web dynamiques. Il
n'y a pratiquement pas de code à écrire côté serveur pour gérer le traitement réel des pages, autre que les formulaires
avec lesquels vous souhaitez serveur des pages dynamiques.

Section
XVIe
Mécanisme de mise en cache IntraWeb 109
16 Mécanisme de mise en cache IntraWeb
16.1 Mise en cache des fichiers
Afin d'améliorer les performances, IntaWeb conserve les fichiers pouvant être mis en cache (fichiers du Des dossiers répertoire,
etc.) dans un répertoire nommé Cacher. Par défaut, ce répertoire est créé la première fois que l'application enregistre un fichier
mis en cache dans le dossier racine de l'application. L'utilisateur peut modifier le nom et l'emplacement par défaut
du répertoire de cache, mais dans ce chapitre nous supposerons pour la facilité d'explication qu'il est nommé
Cacher.
Plusieurs règles s'appliquent à la Cacher annuaire:

· l'application ne doit pas enregistrer de fichiers pour une utilisation ultérieure dans le Cacher répertoire, puisque le répertoire
est vidé de temps en temps. Les fichiers de ce répertoire sont des fichiers temporaires.
· lors du déploiement d'une application IntaWeb, assurez-vous toujours qu'elle a accès total (lire écrire,
modifier, etc.) au Cacher répertoire, sinon l'application s'exécutera avec des résultats imprévisibles
(violations d'accès, erreurs internes, etc.).

Section
XVIIe
Déploiement 111
17 Déploiement
17.1 Installation
17.1.1 Aperçu
Intraweb pour Delphi
Les applications créées avec Intraweb pour Delphi sont entièrement autonomes. Cela signifie que vous n'avez
qu'à copier la sortie compilée (.exe, .so, .dll, etc.) sur le serveur. Vous n'avez pas besoin de copier externe
fichiers à moins que vous n'ayez créé des fichiers externes.
Les démos telles que la démo Guess ne reposent sur aucun fichier externe et donc la simple copie de la sortie binaire
compilée sur le serveur est suffisante.
Intraweb pour Visual Studio .NET
Les applications créées avec Intraweb pour Visual Studio .NET doivent être déployées sur des machines qui ont
les 1.1 Cadre .NET. Les fichiers externes que l'application peut contenir doivent également être copiés sur
la machine de déploiement.
déploiement
17.1.2 Fichiers externes
Il est possible qu'au cours du développement l'application ait créé des dépendances sur des fichiers externes. Dans
ce cas, vous devrez également copier ces fichiers.
Des dossiers
Si vous avez des fichiers dans le répertoire files ou ses sous-répertoires, vous devrez peut-être également les copier sur le serveur. Si tel
est le cas, ils doivent résider dans undes dossiers sous-répertoire qui est placé dans le même répertoire que le binaire
exécutable.
Modèles
Si vous avez utilisé des modèles, vous devrez également les copier sur le serveur. Ils doivent résider dans un
modèles sous-répertoire placé dans le même répertoire que l'exécutable binaire.
17.1.3 Autorisations
Par défaut, une application IntaWeb a besoin de très peu d'autorisations pour s'exécuter. Voici les exigences
minimales :
1. Accès en lecture au Des dossiers si le sous-répertoire files est utilisé.

2. Accès en lecture au Modèles sous-répertoire si des modèles sont utilisés.
3. Accès complet à la Cacher sous-répertoire. Par défaut si ce répertoire n'existe pas, IntaWeb le créera et disposera
ainsi des autorisations adéquates. Dans ce cas, il doit d'abord disposer des autorisations pour créer des répertoires
dans le répertoire dans lequel il se trouve. Vous obtiendrez des erreurs imprévisibles, des violations d'accès les plus
probables et des erreurs de serveur internes si l'accès à ce sous-répertoire est refusé ou
limité.
De plus, si vous vous connectez à une base de données, vous devrez vous assurer que l'application dispose des autorisations appropriées. Cela
est particulièrement vrai pour les bases de données locales qui accèdent directement aux fichiers de base de données.
Si vous utilisez le BDE, vous devez faire particulièrement attention à ce que le BDE puisse créer ses répertoires de travail ainsi qu'accéder
aux fichiers de données.

112 Manuel IntraWeb
17.1.4 ISAPI
17.1.4.1 Déploiement dans IIS
Bien qu'une application IW ISAPI soit identique à une application ISAPI standard, les étapes de déploiement d'une IW
ISAPI seront expliquées étape par étape. Cependant, en raison du nombre de serveurs existants qui prennent en
charge les ISAPI, cette section est limitée au déploiement sur Internet Information Server de Microsoft. C'est l'un des
serveurs les plus courants sur lesquels déployer des ISAPI.
Avant de déployer l'application, la première étape consiste à configurer IIS pour autoriser l'exécution des ISAPI. Dans IIS
5.0, la version incluse dans Windows 2000 et Windows XP, la première étape consiste à créer le site Web et, sous celui-ci,
à créer un dossier virtuel doté des autorisations d'exécution pour exécuter les applications ISAPI.
IMPORTANT : veuillez consulter la note à la fin de la page concernant IIS version 6.
Une fois le site créé (ou sur un site existant), faites un clic droit avec le bouton de la souris et choisissez
Nouveau -> Répertoire virtuel
Cliquez sur Prochain sur l'écran d'introduction de l'assistant. L'étape suivante consiste à sélectionner un alias pour ce répertoire virtuel.
Normalement, la norme est d'utiliser des "scripts", mais n'importe quel alias souhaité peut être utilisé. Cette
définit comment l'application sera appelée via l'URL :
http://xxx.xxxx.xxx.xxx/{alias}/xxxxxxxxxx
L'étape suivante consiste à choisir le répertoire physique réel où les fichiers vont résider et où le alias défini à
l'étape précédente pointera vers. Encore une fois, par défaut, ce serait quelque chose comme

112 Manuel IntraWeb
17.1.4 ISAPI
17.1.4.1 Déploiement dans IIS
Bien qu'une application IW ISAPI soit identique à une application ISAPI standard, les étapes de déploiement d'une IW
ISAPI seront expliquées étape par étape. Cependant, en raison du nombre de serveurs existants qui prennent en
charge les ISAPI, cette section est limitée au déploiement sur Internet Information Server de Microsoft. C'est l'un des
serveurs les plus courants sur lesquels déployer des ISAPI.
Avant de déployer l'application, la première étape consiste à configurer IIS pour autoriser l'exécution des ISAPI. Dans IIS
5.0, la version incluse dans Windows 2000 et Windows XP, la première étape consiste à créer le site Web et, sous celui-ci,
à créer un dossier virtuel doté des autorisations d'exécution pour exécuter les applications ISAPI.
IMPORTANT : veuillez consulter la note à la fin de la page concernant IIS version 6.
Une fois le site créé (ou sur un site existant), faites un clic droit avec le bouton de la souris et choisissez
Nouveau -> Répertoire virtuel
Cliquez sur Prochain sur l'écran d'introduction de l'assistant. L'étape suivante consiste à sélectionner un alias pour ce répertoire virtuel.
Normalement, la norme est d'utiliser des "scripts", mais n'importe quel alias souhaité peut être utilisé. Cette
définit comment l'application sera appelée via l'URL :
http://xxx.xxxx.xxx.xxx/{alias}/xxxxxxxxxx
L'étape suivante consiste à choisir le répertoire physique réel où les fichiers vont résider et où le alias défini à
l'étape précédente pointera vers. Encore une fois, par défaut, ce serait quelque chose comme

Déploiement 113
c:\inetpub\scripts. Cela dépend bien sûr de l'endroit où IIS a été installé et de l'emplacement du
répertoire du site Web actuel.
La dernière étape consiste à choisir les autorisations que le répertoire virtuel va avoir. Normalement, ce n'est pas une bonne idée de
mélanger des répertoires contenant des exécutables avec des répertoires contenant des fichiers auxquels accéder.
lecture écriture. En fait, il n'est pas recommandé d'avoir des répertoires avec accès en écriture via IIS. Dans ce cas, la
meilleure option est de supprimer toutes les autorisations à l'exception de laExécuter (comme les applications ISAPI ou
CGI).
Ce sont les étapes requises pour configurer IIS pour exécuter les ISAPI. Cependant, avant de pouvoir exécuter
l'application, quelques problèmes supplémentaires sont nécessaires. Si le système utilise NTFS, il est nécessaire de
s'assurer que le répertoire physique entré à l'étape 2 de l'assistant et vers lequel pointe l'alias virtuel dispose des
autorisations d'exécution. Les autorisations pour IIS sont basées sur deux facteurs, ceux attribués dans
IIS lui-même et ceux du système de fichiers sous-jacent, prévalant ce dernier sur le premier. Bien sûr, si vous exécutez FAT
(fortement recommandé), il n'y a pas d'autorisations au niveau des fichiers.
La dernière étape restante consiste à copier l'ISAPI dans le répertoire physique approprié qui a été configuré,
assurez-vous que l'ISAPI dispose des autorisations d'exécution et copiez tous les fichiers nécessaires (tels que Des dossiers et
Modèles dossiers) sous le répertoire physique.
Une fois toutes ces étapes accomplies, l'application peut être appelée à l'aide de l'URL :
http://xxx.xxx.xxx.xxx/{alias}/{application_name.dll}/{start_command}
Facultativement, si un port différent du port par défaut 80 a été configuré dans IIS, cette valeur devra
être ajoutée à l'URL.
Exemple:
Si l'application s'exécute sur le port par défaut d'IIS, l'URL ressemblera à ceci :

114 Manuel IntraWeb
http://votreserveurweb/répertoirevirtuel/VotreNomDLL/start
Si vous avez configuré votre application pour utiliser un port, l'URL ressemblerait à :
http://yourwebserver:port/virtualdirectory/YourDLLName/start
Il y a un problème important à retenir lors du déploiement d'ISAPI sous IIS (ou d'ailleurs sous tout autre serveur
compatible ISAPI), et c'est que l'ISAPI s'exécute sous certaines restrictions de sécurité. En particulier, il s'exécute
dans le contexte d'un utilisateur spécifique, qui dans le cas d'IIS est
IUSR_MACHINENAME, où MACHINENAME est remplacé par le nom du serveur. Cet utilisateur
a des autorisations de sécurité très restrictives et cela doit être pris en considération lorsque certains appels nécessitent un
niveau de sécurité plus élevé (comme la communication avec des objets COM, la connexion à certaines bases de données
nécessitant un accès aux fichiers, etc.).
Comme pour toute autre application ISAPI, les IW ISAPI sont des DLL et restent donc en mémoire après le premier appel. IIS
permet de les décharger en configurant une « zone » applicative. Pour ce faire, cliquez avec le bouton droit sur le répertoire
virtuel nouvellement créé (dans la figure ci-dessous, il est nomméscripts) et cliquez sur propriétés.
Une fois l'écran des propriétés affiché, cliquez sur le bouton Répertoire virtuel onglet pour accéder au Paramètres de
l'application.

Déploiement 115
Saisissez une valeur pour le Nom de l'application (tel que Scénarios ou Applications IW) et cliquez sur le Créer
bouton. Met leNiveau d'application à l'isolement requis. NormalementMoyenne (mise en commun) est suffisant. Pour
Pour plus d'informations sur les niveaux d'isolement, consultez l'aide en ligne d'IIS. Lors de l'accès à
l'application, leDécharger sera activé et en accédant aux propriétés et en cliquant sur le Décharger bouton,
TOUS les ISAPI situés sous le répertoire virtuel seront supprimés de la mémoire. Par conséquent, cela ne doit
être fait qu'UNE SEULE FOIS par répertoire virtuel.
REMARQUE:
IIS 6 a augmenté la sécurité par défaut. Pour permettre à ISAPI de s'exécuter, vous devez cliquer sur la nouvelle
entrée "Web Service Extensions" dans MMC et sur "All Unknown ISAPI extensions" changer le statut de
"Interdit".
17.1.4.2 Utilitaires ISAPI
Ces utilitaires de gestion ISAPI peuvent vous aider à gérer vos DLL ISAPI.
· Web de données - http://www.turbodb.de/en/support/isapi.html

· EggCentric - http://www.eggcentric.com/
17.1.4.3 Hébergement ISAPI
Une liste des services d'hébergement prenant en charge ISAPI est disponible sur notre site Web à l'adresse :
http://www.atozedsoftware.com/IntraWeb/FAQ/Hosts.iwp

116 Manuel IntraWeb
17.1.4.4 Problèmes ISAPI courants
ISAPI et regroupement de threads
La section ISAPI et regroupement de threads se réfère uniquement aux applications Intraweb pour Delphi.
À partir d'IntaWeb 5.1, la clause d'exportation suivante doit être ajoutée dans le fichier de projet (.dpr) :
exportations

HttpExtensionProc,
TerminerExtension ;
Cela est nécessaire en raison des dernières modifications ISAPI et de regroupement de threads dans IntaWeb.
Les extensions ISAPI restent en mémoire
Pour les personnes qui n'ont pas l'habitude de travailler avec ISAPI, un problème courant est "Mon ISAPI est chargé, et il ne se
déchargera pas, est-ce normal ?"
Oui c'est le cas. Le serveur seul peut décider à quel moment décharger les extensions de la mémoire. Le
déchargement ne peut pas se faire depuis l'extension elle-même.
Cette conception est destinée à donner un coup de pouce aux performances - contrairement au protocole CGI, où l'application
est chargée à chaque fois qu'elle est exécutée. Les modules ISAPI restent en mémoire, ce qui réduit le temps de chargement.
Ce système offre également d'autres avantages, comme une sécurité améliorée et une mémoire partagée.
Les extensions ISAPI doivent être déchargées pour être remplacées
Vous découvrirez peut-être que, lors du développement, l'exécutable (bibliothèque) ne peut pas être produit. C'est un
situation courante lorsque vous travaillez avec ISAPI et est causée par le serveur Web, qui a chargé l'extension ISAPI et ne l'a
toujours pas déchargée. Pour continuer votre développement, vous devrez soit décharger l'ISAPI manuellement, soit
renommer le fichier de sortie. Pour obtenir des instructions sur la façon de supprimer manuellement les ISAPI, veuillez
consulter la documentation du serveur Web que vous utilisez.
Gestionnaire ISAPI
Une solution pour éviter la situation décrite précédemment est d'utiliser une DLL intermédiaire, qui charge et
décharge votre application ISAPI selon les besoins. Nous vous recommandons d'utiliser ISAPI Manager, qui peut être
téléchargé à partir dehttp://www.dataweb.de. D'autres outils qui effectuent la même tâche sont disponibles.
Comment décharger d'IIS
Outre l'arrêt et le redémarrage du serveur Web, IIS fournit d'autres moyens de décharger les ISAPI. Cela se
fera automatiquement si vous procédez comme suit :
Pour IIS 3 ou inférieur :
Pour désactiver la mise en cache ISAPI, vous devrez remplacer l'entrée de registre suivante par 0 :
HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\W3SVC\Parameters\CacheExte nsions
Après avoir modifié cette entrée, redémarrez le serveur Web et les ISAPI ne seront plus mises en cache.
Pour réactiver l'option de cache, définissez simplement la même valeur sur 1 et redémarrez le serveur Web.
Pour IIS 4 ou supérieur :
Faites un clic droit sur le répertoire des scripts de votre site Web, puis sélectionnez "Propriétés" et dans l'onglet
"Répertoire virtuel" choisissez le bouton "Configuration...". Désélectionnez le "Cache des applications ISAPI"
case à cocher et cliquez deux fois sur "OK" pour enregistrer les paramètres.

Déploiement 117
Que signifie la case à cocher Utiliser ISAPIThreadPool ?
Lors de la création d'une nouvelle application ISAPI, l'assistant affiche l'option "Utiliser
ISAPIThreadPool". Si cochée, l'unité ISAPIThreadPool sera incluse dans le projet.
Selon Borland, pour les applications ISAPI, l'unité ISAPIThreadPool augmente l'évolutivité en utilisant des threads de mise en
commun et en gérant beaucoup plus d'utilisateurs et de demandes simultanées.
Cette option doit être utilisée uniquement lorsque les applications s'exécutent sous IIS.
17.1.4.5 Liens ISAPI utiles
Pour configurer correctement IIS :

www.microsoft.com/directory/article.asp?ID=kb;en-us;Q300991&SD=MSDN
Pour créer votre premier ISAPI Delphi :

http://www.matlus.com/scripts/website.dll/Tutorials?DelphiISAPI&FirstISAPI&3
Pour déboguer les ISAPI Delphi :

http://www.msdelphi.com http://codecentral.borland.com/codecentral/
ccweb.exe/listing?id=15348
http://community.borland.com/article/0,1410,23024,00.html
17.2 Méthodes
17.2.1 Remarques
Les applications développées avec IntaWeb pour Delphi peuvent être déployées en tant que service Windows /
démon Linux, exécutable autonome, application ISAPI ou Apache DSO. En utilisant le mode page, les
applications IntaWeb peuvent également être déployées par d'autres méthodes.
Les applications développées avec Intraweb pour Visual Studio .NET peuvent être déployées en tant qu'exécutables
autonomes ou en tant que dll ISAPI.
17.2.2 Autonome
Lors de l'écriture de votre application en Delphi, vous utiliserez probablement le mode autonome pour déboguer votre
application. Lorsqu'il est exécuté en tant qu'application, un écran de débogage apparaît avec des statistiques de base. Cet écran
contient également une option Exécuter (Exécuter | Exécuter ou F9), qui peut être utilisée pour tester l'exécution de l'application
dans le navigateur. En cliquant dessus, le navigateur par défaut sera lancé avec l'URL correspondante pour tester l'application.
Le formulaire de débogage StandAlone
La fenêtre par défaut en mode StandAlone vous permet d'effectuer des opérations de débogage très basiques.

118 Manuel IntraWeb
L'étiquette marquée (2) dans l'image affiche le nombre de connexions actives à l'application en
cours.
La zone marquée d'un (1) dans l'image représente la zone de débogage.
Pour activer la journalisation dans la zone de débogage, sélectionnez "Options | Afficher les informations de débogage" dans le menu.
Écrire des messages personnalisés dans la zone de débogage
Pour écrire vos messages personnalisés dans la zone de débogage, vous pouvez utiliser la méthode "Log" de la
fenêtre StandAlone. Dans Intraweb pour Delphi, la fenêtre StandAlone par défaut est de type TFormIWMain et est
déclarée dans l'unité IWMain. Dans Intraweb pour Visual Studio .NET, la fenêtre StandAlone par défaut est de type
Main déclarée dans l'espace de noms Atozed.Intraweb.NETMain.
La méthode "Log" prend un paramètre AMsg de type chaîne, qui représente le message à écrire dans la
zone de débogage.
Rédaction d'un formulaire StandAlone personnalisé
Pour une démonstration de l'écriture de votre propre fenêtre StandAlone personnalisée dans Delphi, veuillez
consulter la démo Custom StandAlone.
17.2.3 ISAPI / NSAPI / Apache DSO / CGI / Win-CGI

Intraweb pour Delphi
Les applications développées en mode page peuvent être déployées en tant qu'ISAPI, Apache DSO, NSAPI, CGI ou Win-CGI.
Les exécutables en mode application ne peuvent être déployés qu'en tant qu'ISAPI, NSAPI ou Apache DSO.
Intraweb pour Visual Studio . RAPPORTER
Ce type d'applications ne peut être déployé que sous forme de DLL ISAPI.

Déploiement 119
17.2.4 Service Windows

L'exécution d'applications IntaWeb en tant que service a ses avantages et ses inconvénients. Les inconvénients sont qu'il
n'y a pas d'écran de débogage ou d'élément de menu d'exécution. Le principal avantage est qu'il n'y a pas besoin de se
connecter à la machine pour exécuter l'application (comme tout autre service Windows). Quelques étapes doivent être
suivies avant d'exécuter l'application en tant que service. En particulier, il a
être installé en tant que tel. Pour ce faire, à l'aide de l'invite de commande Windows, accédez au répertoire où
réside l'application et tapez :
Nom_application –installer
Cela l'installera et l'application apparaîtra dans l'applet des services. À partir de là, il peut être configuré pour
s'exécuter automatiquement ou manuellement. Il n'est pas nécessaire d'activer le "Interagir avec le bureau"
sous les propriétés du service, et cela n'aura aucun effet.
De la même manière, si le besoin s'en fait sentir de désinstaller l'application, cela peut être fait en tapant :
Nom_application –désinstaller
Avant d'exécuter cette commande, assurez-vous d'arrêter votre service.
Remarques
1. Seuls les services de prise en charge de Windows NT, Windows 2000 et Windows XP. Windows 95, Windows 98
et Windows ME ne prennent pas en charge les services.
2. Les services ne fonctionnent pas en mode évaluation. Tenter de le faire entraînera des erreurs.
17.3 URL de lancement
17.3.1 Liaison aux applications IntraWeb

Étant donné que toute l'interface utilisateur est basée sur un navigateur Web, l'appel de l'application se fait à l'aide d'une
URL. L'URL a un format très simple.
Utilisation autonome
Syntaxe : http://<serveur>:<port>
Exemple : http://www.atozedsoftware.com:4000
Utilisation d'ISAPI
Syntaxe : http://<serveur>/<chemin du script>/<dll>
Exemple : http://www.atozedsoftware.com/iw/guess.dll
Utilisation d'Apache DSO

Syntaxe : http://<serveur>/<emplacement>
Exemple : http://www.atozedsoftware.com/myapp
Lancer l'option d'URL

Les URL sont formées en spécifiant l'hôte et en ajoutant le numéro de port (s'il est différent du 80 par défaut). Vous pouvez
éventuellement spécifier un texte de début sur l'URL en définissant la propriété StartCmd dans le
ServerController puis en ajoutant la valeur de l'URL Par exemple : http://
www.atozedsoftware.com:4000/launch
17.3.2 Séances
Chaque fois que cette URL est saisie dans le navigateur et qu'une nouvelle session est créée, l'utilisateur est
automatiquement suivi pendant toute la durée de la session. En option, les paramètres peuvent également être

120 Manuel IntraWeb
spécifié lors de l'appel d'une nouvelle instance en les passant à l'aide de POST ou GET.
17.3.3 Passage de paramètres
Les paramètres sont transmis à l'application à l'aide du signe d'interrogation (?) après l'URL de démarrage. Chaque
paramètre se compose d'un "nom de paramètre" et d'une "valeur de paramètre". Les paramètres sont séparés les uns
des autres par le signe esperluette (&). Les exemples suivants montrent comment passer deux paramètres nommés
"param1" et "param2" avec les valeurs "value1" et "value" respectivement (l'exemple est pour standalone) :
http://www.atozedsoftware.com:4000?param1=value1¶m2=value2
Ces paramètres sont disponibles dans votre application en accédant à la propriété RunParams de
l'objet TIWApplication.
De plus, des modifications préalables au lancement peuvent être effectuées dans l'événement ServerController.OnNewSession. Une
telle utilisation peut être de lire les paramètres qui ont été transmis dans une offre différents utilisateurs différents
formes de départ.
NOTE IMPORTANTE:
Certains navigateurs sur Macintosh nécessitent que le paramètre start ait un / avant le ?. Par exemple, les
éléments suivants :
http://<serveur>:8888?param1=valeur1
peut ne pas fonctionner correctement sur certains navigateurs Macintosh et doit être remplacé par :
http://<serveur>:8888/?param1=valeur1
Puisque presque tous les navigateurs acceptent /?, il ne devrait pas y avoir d'effets secondaires d'ajouter / avant le ? dans tous les appels.

Déploiement 121
17.4 Conversion des types de projets
17.4.1 Conversion de Standalone en ISAPI dans Delphi

Prenons l'exemple de la démo Guess :
programme Devinez;
les usages
Formes,
IWMain,
Main dans 'Main.pas' {formMain: TIWFormModuleBase},
ServerController dans 'ServerController.pas' {IWServerController: TDataModule} ;
{$R *.res}
commencer
finir.
1. Modifiez le programme clause à une bibliothèque.

2. Retirez l'IWMain et les formulaires du les usages clause.
3. Ajoutez IWINitISAPI au les usages clause.
4. Supprimez tout entre BEGIN..END.
5. Ajoutez IWRun entre BEGIN..END.
6. Ajoutez GetExtensionVersion, HttpExtensionProc, TerminateExtension au exportations clause.
Votre programme devrait maintenant ressembler à ceci :
bibliothèque GuessDLL;
les usages
ISAPIApp,
IWINitISAPI,
Main dans 'Main.pas' {formMain : TIWFormModuleBase}, ServerController dans
'ServerController.pas' {IWServerController :
TDataModule} ;
{$R *.RES}
exportations
HttpExtensionProc,
TerminerExtension ;
commencer
IWRun;
finir.

122 Manuel IntraWeb
17.4.2 Conversion de StandAlone en ISAPI dans CBuilder

Ouvrez votre fichier bpr dans un éditeur de texte tel que NotePad.
1. Changez l'EXE en DLL

2. Repérez la ligne qui dit -tW -tWM"/> et ajoutez "D" après le premier W
3. Remplacez c0w32.obj par c0d32.obj
4. Enregistrez les modifications et ouvrez le fichier de projet mis à jour dans C++ Builder
5. Supprimer IWMain et Forms de la clause uses
6. Ajoutez IWINitISAPI à la clause uses.
7. Construire le projet
--------------------------------------------------------------------------------

Déploiement 123
17.4.3 Conversion d'ISAPI en StandAlone dans Delphi

Prenons l'exemple de la démo GuessDLL :
bibliothèque GuessDLL;
les usages
IWINitISAPI,
Main dans 'Main.pas' {formMain : TIWFormModuleBase}, ServerController dans
'ServerController.pas' {IWServerController :
TDataModule} ;
{$R *.RES}
exportations
HttpExtensionProc,
TerminerExtension ;
commencer
IWRun;
finir.
1. Modifiez le une bibliothèque clause à programme.

2. Supprimez l'IWINitISAPI du les usages clause.
3. Ajoutez IWMain et Forms au les usages clause.
4. Supprimez tout entre BEGIN..END
5. Ajoutez les lignes ci-dessous entre BEGIN..END
6. Retirez le exportations clause.
Votre programme devrait maintenant ressembler à ceci :
programme Devinez;
les usages
Formes,
IWMain,
Main dans 'Main.pas' {formMain: TIWFormModuleBase},
ServerController dans 'ServerController.pas' {IWServerController: TDataModule} ;
{$R *.res}
commencer
finir.

124 Manuel IntraWeb
17.5 Informations supplémentaires sur Linux
17.5.1 Aperçu
Les applications IntaWeb qui utilisent TImage ou TFrame auront besoin du support de XWindows. Les applications qui
n'utilisent pas ces deux composants ne nécessitent pas la prise en charge de XWindow.
L'installation d'un serveur X complet sur une machine serveur Linux n'est pas souhaitable ni même possible dans de
nombreux cas. Au lieu de cela, vous pouvez exécuter un serveur X spécial conçu pour les serveurs Web appelé X Virtual
Frambe Buffer, ou Xvfb en abrégé. Xvfb est utilisé par des milliers de DSO CGI et Apache.
Xvfb est inclus dans de nombreuses distributions telles que SUSE. Si vous n'avez pas Xvfb, vous pouvez l'obtenir à partir de
l'une des URL suivantes :
· http://www.xfree86.org/4.0.1/Xvfb.1.html
· http://chartworks.com/support/server/XvfbonUnix.html
· http://www.slac.stanford.edu/grp/cd/soft/unix/xvfb.html
Une fois installé, vous pouvez l'utiliser en émettant :
Xvfb :99 &
Aucune configuration n'est requise.
Ensuite, avant de lancer votre problème d'application IW :
export DISPLAY=localhost:99.0
17.6 Ports d'application
Lors du déploiement de l'application, le port de l'application doit être choisi avec soin.
Les numéros de port inférieurs à 1024 sont toujours réservés. Linux ne vous laissera même pas les appliquer sans
autorisations.
Sous Windows, le système d'exploitation laissera l'application s'exécuter sur n'importe quel port, et c'est le travail de
l'application de sélectionner un port inutilisé.
C'est en général une bonne idée de sélectionner un port supérieur à 1024 pour votre application. Un port généralement
ouvert par les pare-feu et configuré dans les proxys est le 8080.
Quel que soit le port que vous avez choisi, vérifiez avant qu'aucune autre application ne l'utilise.

Section
XVIIIe
126 Manuel IntraWeb
18 Évaluations des performances
18.1 Des astuces
Vous voudrez probablement tester les performances de votre application. De nombreux utilisateurs testent les performances de
manière incorrecte et reçoivent ainsi des résultats trompeurs. Lors des tests, tenez compte des éléments suivants qui peuvent avoir un
impact négatif sur vos tests.
1. Lorsque vous utilisez Internet Explorer, la première page s'affichera rapidement. Cependant, lorsque vous cliquez sur un
bouton ou un lien de la première page, Internet Explorer chargera alors des bibliothèques supplémentaires et
provoquera un retard. Ce délai est causé par Internet Explorer et non par l'application IntaWeb. Au fur et à mesure
que vous passez aux pages successives, vous remarquerez que ce délai n'existe plus.
2. Lors de l'utilisation d'un navigateur sur la même machine que le serveur, le réseau est obligé d'utiliser le
adresse de "bouclage". L'adresse de bouclage offre généralement de bonnes performances, mais
introduit parfois des retards dans le transfert des données.
3. Lorsque vous utilisez un navigateur sur la même machine que le serveur, le navigateur, le réseau et
l'application rivalise toutes pour le processeur, le disque et la mémoire en même temps. La plupart des navigateurs sont très
gourmands en CPU et en mémoire, et ont donc un impact négatif sur le serveur et vos résultats.
4. Lorsque vous utilisez Netscape et exécutez votre application à partir de Delphi, le débogueur Delphi se connecte
et le conflit Netscape. Souvent, vous devrez passer du navigateur à l'application pour
"décoller" le réseau local.
5. Chaque fois que vous exécutez votre serveur depuis Delphi ou Visual Studio .NET, leurs débogueurs sont
actif. Le débogueur consomme non seulement de la mémoire et du processeur, mais peut également
ralentir l'exécution de votre application. Dans des circonstances normales, cela est parfaitement
acceptable, mais gardez cela à l'esprit si vous testez les performances.
6. La première fois que vous exécutez une application basée sur ISAPI, le serveur Web doit charger la DLL, ce
qui entraînera un retard.
Pour tester correctement les performances, vous devez exécuter votre application et votre navigateur sur des machines distinctes.

Section
XIXème
128 Manuel IntraWeb
19 Mise à l'échelle des applications intraWeb
19.1 Méthodes de mise à l'échelle
Que se passe-t-il si mon application devient trop volumineuse pour être gérée par un seul serveur ? IntaWeb peut-il évoluer ? Bien sûr que oui.
IntaWeb peut être mis à l'échelle à l'aide de diverses méthodes. Tout d'abord, considérez également que dans de nombreuses applications, vous
pouvez gérer plus avec moins de CPU, car le mode App est avec état. Sans état, les applications passent souvent
beaucoup d'état de streaming CPU vers une base de données, l'état de reconstruction ou la réexécution inutile de requêtes sur une
base de données. Cela étant dit, il y a encore des moments où vous devez évoluer.
Ajouter un autre niveau

Utilisez MTS, COM, SOAP, ASTA, Midas, peu importe et divisez cette pièce en plusieurs machines. Cela
retirera le traitement de l'application IntaWeb et lui permettra d'être distribué.
Renforcez votre serveur de base de données

Ajoutez plus de puissance CPU ou de mémoire au serveur de base de données. Dans de nombreux systèmes, la base de
données est le goulot d'étranglement et l'application Web passe la majorité de son temps à attendre la base de données.
Ajouter plus de mémoire au serveur d'applications

Vérifiez votre utilisation de la mémoire et assurez-vous que votre serveur d'applications dispose de la quantité appropriée de
Mémoire. La mémoire virtuelle sera utilisée si la mémoire physique disponible est insuffisante, mais cela ralentira le
temps de réponse et consommera des cycles CPU. L'élimination de l'utilisation de la mémoire virtuelle augmentera
l'efficacité et la capacité.
Utiliser un serveur multiprocesseur

Les serveurs IntaWeb sont entièrement threadés. Ainsi, les serveurs IntaWeb tireront parti de plusieurs processeurs s'ils sont
présents.
Distribuer l'application IntaWeb elle-même

Si vous avez atteint un niveau vous obligeant à mettre à l'échelle l'application IntaWeb réelle, cela peut être
accompli aussi. S'il te plait regardeDistribution de l'application IntaWeb.
19.2 Distribution de l'application IntraWeb
Ce qui sera présenté ici n'est pas le seul moyen de distribuer une application IntaWeb, mais c'est le plus courant.
C'est très simple, et efficace. Cette méthode peut également être utilisée en conjonction avec les méthodes
décrites précédemment.
Étape 1 - Installer plusieurs serveurs d'applications

Chaque serveur aura besoin de sa propre adresse IP. Pour cet exemple, nous les appellerons simplement .1, .2 et
. 3.
Étape 2 - Créer un nouvel enregistrement DNS

Créez une nouvelle entrée DNS pour identifier l'application. Pour cet exemple, nous utiliserons
iwapp.atozedsoftware.com.
Étape 3 - Ajouter plusieurs IP pour l'enregistrement DNS

Le DNS permet d'attribuer plusieurs IP à un enregistrement donné. Dans notre exemple, nous attribuerions .1, .2, .3 à
iwapp.atozedsoftware.com. Lorsque plusieurs adresses IP sont attribuées à un seul enregistrement, le serveur DNS
effectuera une rotation DNS, parfois également appelée round robin. Cela signifie que la première demande pour
iwapp.atozedsoftware.com renverra .1, la seconde renverra .2, la troisième renverra .3, la quatrième renverra .1, et
ainsi de suite.
Cela répartira la charge sur les serveurs. Cette méthode n'effectue pas un véritable équilibrage de charge, car elle ne mesure
pas la charge, elle la distribue simplement. Dans la plupart des applications, la loi des moyennes s'applique et il

Mise à l'échelle des applications intraWeb 129
est assez efficace. Si votre application est telle qu'elle crée des déséquilibres importants, vous devrez plutôt utiliser un
serveur DNS d'équilibrage de charge.
Étape 4 - Créer une entrée de redirection

Sur chaque serveur d'applications, créez une entrée de redirection à l'aide de la configuration du serveur Web principal ou d'une page qui
effectue une redirection vers l'adresse IP réelle de ce serveur. Lorsque la page ou l'entrée virtuelle est demandée, le
navigateur ne saura pas qu'il a été redirigé vers une adresse IP par le serveur DNS, car cela fait partie de son
fonctionnement normal. Cependant, nous devons nous assurer que les demandes suivantes sont acheminées vers le
même serveur d'applications, car IntaWeb est avec état. Notez que cela ne s'applique qu'au mode Application, et non au
mode Page. Cette étape peut être ignorée pour le mode Page.
L'entrée virtuelle ou la page Web redirige simplement le navigateur Web vers une URL contenant son adresse IP
individuelle au lieu de iwapp.atozedsoftware.com. Par exemple, si notre URL est http://iwapp.atozedsoftware.com, cette
entrée peut rediriger le navigateur vers . Cette URL illustre une application IntaWeb autonome, mais elle peut être
ajustée pour rediriger vers une page statique, une version ISAPI ou une version DSO. L'important est
que le navigateur est redirigé vers le serveur d'applications physique afin que chaque requête suivante retourne
à ce serveur.

Section
XX
HTTP/SSL sécurisé 131
20 HTTP/SSL sécurisé
20.1 introduction
Si votre application est déployée en tant que DLL ISAPI ou DSO Apache, vous devez utiliser les capacités SSL du
serveur Web d'hébergement car il gère le protocole HTTP.
En mode autonome, SSL est également pris en charge. La première étape est que vous devez obtenir des certificats SSL.
20.2 Activer SSL

IntaWeb exige que vos certificats soient au format .pem. Pour activer la prise en charge SSL, procédez comme suit :
1. Téléchargez et installez les DLL SSL. Des informations sur la façon d'obtenir les DLL sont disponibles sur
http://www.nevrona.com/indy/ssl.html . Les DLL sont gratuites.
2. Définissez le SSLPort dans le ServerController sur une valeur autre que 0. La valeur par défaut pour la prise en charge SSL est
443. Si vous exécutez un serveur Web standard sur la même machine et qu'il prend en charge SSL,
il utilisera déjà 443 et vous devrez utiliser un autre port.
3. Définissez le SSLCertificatePassword dans le ServerController si vous avez attribué un mot de passe à vos
certificats.
4. Placez vos certificats dans le même répertoire que l'application. Les certificats doivent être nommés :
· Cert.pem
· Racine.pem
· Clé.pem
Si vos certificats ne sont pas au format .pem, veuillez consulter la section sur conversion au format PEM.
20.3 Conversion de certificats au format PEM
Conversion de certificats au format PEM

Il est probable que vos certificats ne vous aient pas été livrés au format .pem. S'ils ne sont pas en .pem, vous
doit les convertir pour une utilisation avec IntaWeb.
Cette procédure suppose que vous avez déjà reçu votre paire clé et certificat d'une autorité de
certification (comme Verisign ou Thawte) et que vous les avez installés dans Microsoft Internet
Explorer dans le magasin de certificats personnels.
Certificat d'exportation
Sélectionnez le certificat et exportez-le sous forme de fichier .pfx (format d'échange personnel). Vous pouvez éventuellement le
protéger avec un mot de passe.
Convertir .pfx en .pem

Dans le cadre du téléchargement SSL, un utilitaire nommé openssl.exe a été inclus. Cet utilitaire sera utilisé pour convertir
votre fichier .pfx.
Pour utiliser openssl.exe, utilisez le format suivant :
openssl.exe pkcs12 –in <votre fichier>.pfx –out <votre fichier>.pem
Openssl.exe vous demandera un mot de passe. Entrez-le si vous en avez utilisé un, ou laissez-le vide si vous n'en avez pas
spécifié. Il vous demandera également un nouveau mot de passe pour le fichier .pem. Ceci est facultatif, mais si vous le
protégez avec un mot de passe, assurez-vous de renseigner la propriété ServerController.SSLCertificatePassword dans
votre application.
Fractionnement du fichier .pem

Si vous examinez le nouveau fichier .pem avec un bloc-notes, vous remarquerez qu'il se compose de deux parties. Les deux
parties se composent de la clé privée et de la partie certificat (clé publique). Des informations supplémentaires sont
également incluses. IntaWeb exige que ces informations soient séparées dans des fichiers séparés.

132 Manuel IntraWeb
Clé.pem
Créez key.pem avec le bloc-notes et collez tout ce qui se trouve entre et y compris ces deux instructions :
- - - - - COMMENCER CLÉ PRIVÉE RSA -----
- - - - - FIN CLÉ PRIVÉE RSA -----
Cert.pem
Créez cert.pem avec le bloc-notes et collez tout ce qui se trouve entre et y compris ces deux instructions :
- - - - - COMMENCER LE CERTIFICAT -----
- - - - - CERTIFICAT DE FIN -----
Racine.pem
Le fichier final requis par IntaWeb est le fichier de certificat de l'autorité de certification. Vous pouvez l'obtenir auprès de
Internet Explorer dans la boîte de dialogue Autorité de certification racine de confiance. Sélectionnez l'Autorité qui a émis votre
certificat et exportez-le au format Base64 (cer). Ce format est également le même que le format PEM, donc après l'exportation,
renommez simplement le fichier en root.pem.
20.4 Exemple
Un exemple Intraweb pour Delphi avec un certificat de test est inclus et peut être vu en examinant le
AutonomeSSL démo.

Indice 133
Indice
-S-
pas à pas 102

134 Manuel IntraWeb

IntraWeb FR

Transféré par

Droits d'auteur :

Formats disponibles

IntraWeb FR

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

IntraWeb FR

Transféré par

Droits d'auteur :

Formats disponibles

Traduit de Anglais vers Français - www.onlinedoctranslator.

Logiciel Atozed Copyright

"Rend le développement d'applications Web aussi simple que tomber

Magazine PC Plus, juin 2002

Table des matières

2 Comment IntraWeb...W. . . o..rk..s............................................... .................................................................. ....................... 3

3 Limites de..l.e...E . . . . Version................................... .................................................................. ....... 3

4 Sup. Technique. . . o..r..t.................................................. .................................................................. .............................. 4

6 crédits, Ackno . . . .w. LED . . . e..n

7 Exigences.................................................................. .................................................................. ................................. 6

Partie II Quoi de neuf dix

2 Support PDA.................................................. .................................................................. ................................... 11

Partie III Guide de migration 13

2 Visual Studio....N . . . et.................................................. .................................................................. ....................... 18

5 Mise à niveau vers...a...n..e..w. . . . v..e..rs.io

2 Bâtiment A De.m. . . o...S . . . y...S..te.p

5 DevinerWB ................................................. .................................................................. ................................. 32

Logiciel Atozed Copyright

8 FishFactDM .................................................. .................................................................. ................................. 32

9 Phénitique Cu.s..to . . ..m. . e..r...P..ro.f..il..e..r.................................. .................................................................. ....................... 32

13 Bouton Retour............................................... .................................................................. ................................... 33

Formulaires de 14 pages ................................................. .................................................................. ................................... 33

15 Marché aux poissons ................................................. .................................................................. ................................. 33

16 Meurs, vole ! Mourir..!.............................................. .................................................................. ................................. 33

17 WebMail32 .................................................. .................................................................. ................................. 34

2 Sortie de débogage..t.................................................. .................................................................. ................................... 36

3 Détection d'Er.ro.r..s...o..n...S..t..ar.tu.p................... .................................................................. ....................................... 36

4 Commande Li.n..e...P. . . le matin . . . rs.................................................. .................................................................. ....... 36

Partie VII Développement 39

2 Écrire vos..F..irs ...

3 images et G . . .p. . h..ic.s............................................... .................................................................. ....................... 41

5 Travailler avec...C. . . O...M

6 Travailler avec...C. . . mentir . . . a..ta.S

7 Travailler avec...P..D. . . UNE

8 Divers.................................................. .................................................................. ................................... 44

Partie VIII Gestion des formulaires 47

2 Mode de mise à jour.................................................. .................................................................. .................................. 47

3 IntraWeb Fra.m. . . . e.................................................. .................................................................. .............................. 48

5 Forme visuelle .In.h..e..r..ita.n..c..e.......................... .................................................................. ..................................... 49

6 Gestion de la for..rm. . . s.................................................. .................................................................. ....................... 49

7 Liste des formulaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50

8 Affichage du formulaire. . . . s.................................................. .................................................................. .............................. 50

9 Cacher les formulaires.................................................. .................................................................. ................................... 51

12 Remarque pour C++..B . . . u..ild.e..r..u ..

Logiciel Atozed Copyright

Partie IX Gestion de l'état 59

2 Restrictions............................................................... .................................................................. ................................ 59

3 Stockage en toute sécurité............................................... .................................................................. ................................... 59

4 Complexe État.a..n..d. . . . le.e...B . . . n.................................................................. .............................................. 62

Partie X Gestion des sessions 66

5 Stockage Addi.tio.n . . une . . à........................................... .................................................................. .................... 67

6 Session Rela..te.d...E . . .v. . .fr. . ts.................................................. .................................................................. ............. 67

9 Comment Se..ss. . . io.n....M

Gestionnaires et modèles de mise en page de la partie XI 71

2 Mise en page du formulaire............................................... .................................................................. ................................... 71

3 Modèles HTML .................................................. .................................................................. ................................... 71

Contrôleur de serveur Partie XII 75

2 Propriétés ................................................. .................................................................. ................................. 75

Partie XIII Écrire des composants personnalisés 77

2 Sous Const.ru . . . ct.io.n............................................... .................................................................. ....................... 77