######################################################################
# 
#      ManyPage : Moteur de Publication de site Web
#      ManyPage : Web site Management tools
#
#
# Auteur/Author       		: Pierre Cordani
# Collaborateur/Contributor	: Pascal Vuylsteker, MediaPort team
#
# Documentation : http://www.vrarchitect.net/ManyPage
# Question      : manypage@vuylsteker.net
#
# Creation      : 1/1/00
# Modification  : 1/12/00
# Version       : 0.9
# SoftVersion   : Perl 5
######################################################################
#
# This file contain row documentation in french on how to use ManyPage
# Please consult the manual at 
#     http://www.vrarchitect.net/ManyPage/index.en.html
# 
# Ce fichier est principalement un memo sur la manire d'utiliser ManyPage
# Pour une aide plus dtaille, voir
#     http://www.vrarchitect.net/ManyPage/index.fr.html
#
######################################################################
#
#  Copyright (C) 2000 Pierre Cordani - Pascal Vuylsteker
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# Ce programme est un logiciel libre ; vous pouvez le redistribuer et/ou le modifier conformment
# aux dispositions de la Licence Publique Gnrale GNU, telle que publie par la Free Software
# Foundation ; version 2 de la licence, ou encore ( votre choix) toute version ultrieure.
#
###################

Commentaires concernant le script d'habillage ManyPage

* Utilisation
 
        Ce script permet d'habiller des fichiers HTML d'une facon modulaire,
en utilisant un squelette, une arborescence virtuelle et ce que l'on va
appeler des objets SGML.
        Le squelette de l'habillage sera contenu dans le fichier .dress, ce sera
le modele utilise pour la creation des clones. Ce clones etant le resultat
de l'habillage.
        Une notion de programmation objet a ete introduite pour permettre un
plus grand controle de l'habillage avec un minimum de code grace a la
notion
d'heritage. Cette programmation sera effectue grace a des objets SGML qui
seront decrits dans le fichier .obj.
        L'arborescence virtuelle est utilisee pour proposer a l'utilisateur une
navigation plus conventionnelle, tel un livre, et elle sera decrite dans le
fichier .link.
 
* Fonctionnement
 
	 	Le script d'habillage est entierement ecrit en Perl.
		Plusieurs informations sont necessaires a son bon fonctionnement.
 
		Pour commencer, il lui faut un fichier decrivant la structure du serveur:

			-Partie source (fichiers non habilles)
			-Partie destination (fichiers habilles)
		
		Le fichier comportant cette description est nomme "config", et il doit etre
place dans le meme repertoire que les fichiers perls.

		En voici la syntaxe:
		
		<Source>
		/usr1/people/cordani/WWW_Test/Src
		</Source>

		<Destination>
		/usr1/people/cordani/WWW_Test/Docs
		</Destination>

        Pour continuer il lui faut un fichier source ecrit en HTML, tout autre
fichier ne correspondant pas a la syntaxe HTML sera automatiquement ecarte
du traitement.
 
	ex du format:
 
	<HTML>
        <HEAD>
        </HEAD>

        <BODY>
        </BODY>
	</HTML>
 
        La troisieme information capitale est l'existence d'un fichier
dont le nom doit etre ".dress" qui est le modele qui permetera au script de creer les
differentes pages habillees. Sans ce fichier, le resultat de l'habillage
est une page vide (Une nouvelle fonctionalite serait de creer une copie
conforme de la page HTML dans le cas ou le fichier .dress serait
inexistant).
        Le fichier .dress devra etre ecrit en HTML avec la contrainte suivante:
        Deux objet particuliers seront utilises pour la creation des clones:
 
        <PM.HEAD> : information concernant la partie HEAD du fichier HTML source
        <PM.BODY>  : le corps du fichier HTML source
 
        Ces deux objets pourront bien evidement etre places n'importe ou dans le fichier
.dress, laissant ainsi la possibilite d'habiller la page comme on le souhaite.
 
	 ex classique d'un fichier .dress:
 
	<HTML>
         <HEAD>
			<PM.HEAD>
         </HEAD>
 
         <BODY>
            <PM.BODY>
         </BODY>
	</HTML>
 
        L'objet <PM.BODY.NONE> peut etre utilise dans le tag BODY pour permettre
l'utilisation des options du tag <BODY> de la page source.
 
	ex:
 
	<HTML>
         <HEAD>
			<PM.HEAD>
         </HEAD>
 
         <BODY <PM.BODY.ATTRIBUT>>
            <PM.BODY>
         </BODY>
	</HTML>
 
        D'autres objets predefinis existent egalement:
 
         <PM.KEYWD.FILENAME>         : nom du fichier source sans suffixe
         <PM.KEYWD.BACK>             : lien BACK     (url)
         <PM.KEYWD.UP>               : lien UP       (url)
         <PM.KEYWD.NEXT>             : lien NEXT     (url)
         <PM.KEYWD.TITLEBACK>        : Champ titre de la page BACK
         <PM.KEYWD.TITLEUP>          : Champ titre de la page UP
         <PM.KEYWD.TITLENEXT>        : Champ titre de la page NEXT
         <PM.KEYWD.LANG>             : langue du fichier html en train d'etre ecrit
         <PM.KEYWD.DATE.MODIF>       : date de modification du fichier                                                                       -->
         <PM.KEYWD.DATE.HAB>         : date d'habillage du fichier                                                                   -->
         <PM.KEYWD.DATE>			 : date courante au format jour/mois/annee  ex: 18/05/1998                                                                   -->
		<PM.TITLE>  : seul le titre du header
 
	Remarque: Tout objet commencant par PM, est un objet particulier au programme

     *Objets simples.
 
         Maintenant, on va s'interesser a la conception des objets SGML. Ces objets seront
 les ensembles plus ou moins elementaires qui nous permetteront de concevoir l'habillage
 des nos pages HTML.
         Tout objet doit avoir la syntaxe suivante :
 
         <MP.nom_objet>
                 description de l'objet
         </MP.nom_objet>
 
         Et doit se trouver dans un fichier appele ".obj". Ce fichier
 contiendra la description de tous les objets utilises pour
l'habillage.
         La description d'un objet simple contient du texte HTML, du Javascript, ...
 
         Disons qu'on veut creer un objet representant une boule de couleur rouge,
 dont le fichier au format gif se trouve a la racine (/rouge.gif), et qu'on appellera
 BOULE.ROUGE.
         Voici la syntaxe a utiliser:
 
         <MP.BOULE.ROUGE>
                 <IMG SRC="/rouge.gif">
         </MP.BOULE.ROUGE>
 
         Ces objets peuvent etre utilises aussi bien dans le fichier .dress que dans le
 fichier HTML source.
 
         ex du fichier HTML source:
 
         <HTML>
                 <HEAD>
                         <TITLE>exemple 1</TITLE>
                 </HEAD>
 
                 <BODY>
                         <MP.BOULE.ROUGE>a<BR>
                         <MP.BOULE.ROUGE>b<BR>
                 </BODY>
         </HTML>
 
         Une fois le fichier habille, on obtiendra ceci:
 
         <HTML>
                 <HEAD>
                         <TITLE>exemple 1</TITLE>
                 </HEAD>
 
                 <BODY>
                         <IMG SRC="/rouge.gif">a<BR>
                         <IMG SRC="/rouge.gif">b<BR>
                 </BODY>
         </HTML>
 
 
         *Objets complexes
 
         Un objet complexe est definit par un ensemble des sous-objets (simples ou complexes).
         On essayera d'eviter d'incorporer du HTML dans un objet complexe, de facon a rendre
 cet objet aussi modulable que possible.
         Exemple de definition d'un objet complexe:
 
         Objets simples:
 
         <MP.IMG1>
                 <IMG SRC="/img1.gif">
         </MP.IMG1>
 
         <MP.HR>
                 <HR>
         </MP.HR>
 
         <MP.IMG2>
                 <IMG SRC="/img2.gif">
         </MP.IMG2>
 
         Objets complexes:
 
         <MP.SEP>
                 <MP.BOULE.ROUGE>
                 <MP.HR>
                 <MP.BOULE.ROUGE>
         </MP.SEP>
 
         <MP.MENU>
                 <MP.IMG1>
                 <MP.SEP>
                 <MP.IMG2>
         </MP.MEUN>
 
         *Notion d'heritage
 
         Bon, c'est la que la chose se complique un peu. Pour pouvoir garder une
 modularite importante, le script utilise des objets qui ont une notion d'heritage.
         Disons par exemple que nous avons cree un objet <MP.MENU> utilisant 10 sous-menus
 (<MP.MENU1>, <MP.MENU2>, ...), et que dans chaque sous menu, on utilise l'objet
 <MP.BOULE.COULEUR> etant defini de la facon suivante:
 
         <MP.BOULE.ROUGE>
                 <IMG SRC="/rouge.gif">
         </MP.BOULE.ROUGE>
 
         <MP.BOULE.BLEUE>
                 <IMG SRC="/bleu.gif">
         </MP.BOULE.BLEUE>
 
         <MP.BOULE.COULEUR>
                 <MP.BOULE.ROUGE>
         </MP.BOULE.COULEUR>
 
         Donc, chaque instance de l'objet <MP.BOULE.COULEUR> sera remplace par une
 boule rouge.
         Nous avons un fichier .dress:
 
         <HTML>
                 <HEAD>
                         <PM.TITLE>
                 </HEAD>
 
                 <BODY>
                 <MP.MENU><BR>
                         <PM.BODY>
                 </BODY>
         </HTML>
 
         Et nous avons 30 fichiers a habiller.
         Nous aurons comme resultat, 30 fichiers avec chacun un menu
contenant des boules
 rouges.
         Disons que nous voulons maintenant differencier l'un de ces 30 fichiers en
 utilisant des boules bleues dans son menu. Comment faire?
         La procedure la plus simple est de ne pas utiliser l'objet <MP.MENU> dans le
 fichier .dress, mais dans chaque fichier source, de facon a creer un deuxieme menu
 dans le fichier .obj et l'utiliser dans le fichier source souhaite. Mais cela nous
 oblige a editer 30 fichiers a la main. Et en plus, on a du recreer un objet menu de
 toutes pieces pour simplement modifier la couleur des boules (Nous avons donc deux
 objets identique a une couleur pres).
         On va donc reflechir autrement. On sait que la seule chose qui nous pose
 probleme est l'objet <MP.BOULE.COULEUR>. Dans ce cas, nous n'avons rien d'autre a
 faire que proposer au script de changer sa valeur pour le fichier souhaite. Pour
 cela, on va creer un fichier objet dont le nom sera le meme que celui
 du fichier source a modifier (ex: index.html -> index.obj), et dans ce fichier on
 redefinira l'objet <MP.BOULE.COULEUR>.
 
         ex pour index.obj:
 
         <MP.BOULE.COULEUR>
                 <MP.BOULE.BLEUE>
         </MP.BOULE.COULEUR>
 
         Nous avons donc, en trois lignes, cree un objet particulier au fichier source.
         L'objet <MP.MENU> va heriter l'objet <MP.BOULE.COULEUR> du fichier index.obj, et de
 ce fait, va remplacer l'ancien <MP.BOULE.COULEUR> lui etant associe.
         Il est possible de creer autant de fichiers particuliers que de fichiers sources.
         La meme chose peut etre effectue pour le fichier .dress, a la difference que
 celui-ci remplacera la totalite du .dress precedant.
 
         Passons maintenant au cas de l'habillage d'une arborescence.
         Nous pouvons utiliser un seul .dress et un seul .obj pour l'ensemble de
 l'arborescence. Bien evidement, tout les fichier auront le meme look.
Par contre, si
 nous desirons donner un look different a chaque branche de l'arborescence, il ne nous
 reste plus qu'a creer un fichier .dress et un fichier .obj par branche, sachant que
 tout fichier .obj heritera des objets du niveau superieur.
 
         C'est la que rentre en jeu la notion d'objet simple ou
complexe. Le but du jeu
 etant de creer des objets aussi elementaires que possible pour ne devoir modifier que le
 stricte necessaire. Prennons par exemple le cas d'un menu qui doit se retrouver sur
 toutes les pages du serveur, dont l'une des icones doit referencer une page differente
 selon le repertoire dans lequel on se trouve. On devrait pouvoir
simplement modifier
 la reference vers cette page dans le .obj de chaque repertoire, sans devoir toucher
 au reste.
 
         Exemple (.obj principal):
 
         <MP.CONTACT.HREF>
                 /equipe.+
         </MP.CONTACT.HREF>
 
         <MP.IMAGE.MENU.CONTACT>
                 /Icon/Menu/MP/contact.gif
         </MP.IMAGE.MENU.CONTACT>
 
         <MP.MENU.CONTACT>
                 <A HREF="<MP.CONTACT.HREF>"><IMG SRC="<MP.IMAGE.MENU.CONTACT>"></A>
         </MP.MENU.CONTACT>
 
         Dans le .obj suivant (sous-repertoire):
 
         <MP.CONTACT.HREF>
                 /nom_rep/equipe.+
         </MP.CONTACT.HREF>
 
 
         Remarque: Il est recommande de definir tout les objets en commun, en une seule fois,
 et dans le fichier .obj qui se trouve a la racine de l'arborescence a habiller.
 
     *Notion d'attribut
 
         Disons que maintenant, je voudrai creer l'objet <MP.ENCADRE.ROUGE> qui prend
 en parametre un texte, et place une boule rouge au debut et une autre a la fin.
 Je parle donc d'un objet <MP.ENCADRE> utilisant deux fois l'objet <MP.BOULE.ROUGE>.
 Pour cela rien de plus simple. Dans le fichier .obj je definis
l'objet <MP.ENCADRE>
 de la facon suivante:
 
         <MP.ENCADRE>
                 <MP.BOULE.ROUGE>
                 <MP.BOULE.ROUGE>
         </MP.ENCADRE>
 
         Bien entendu, l'objet <MP.BOULE.ROUGE> doit exister, sans quoi, l'objet <MP.ENCADRE>
 serait vide. (L'utilisateur a la possibilite de definir l'objet
<MP.BOULE.ROUGE>
 n'importe ou dans le fichier .obj sans que cela pose un probleme a la traduction).
         Le probleme qui reste a resoudre est le suivant; comment utiliser cet objet pour
 afficher un texte qu'il ne connait pas encore entre les deux boules rouges?
         #Rien de plus simple#, il suffit d'utiliser la notion d'attribut.
         Dans le langage HTML classique, il existe des tags qui
utilisent des attributs, comme par
 exemple le tag IMG, avec les attributs SRC, WIDTH, HEIGHT, ...
         Le jeu consiste donc, a pouvoir creer des objets avec un nombre voulu
 d'attributs qui lui seront associes. La syntaxe a employer est la suivante:
 
         Pour les attributs:
 
         PM.ATTRIBUT.nom_attribut1
         PM.ATTRIBUT.nom_attribut2
         ...
 
         Pour l'objet:
 
         <MP.ENCADRE>
                 <MP.BOULE.ROUGE>
                 PM.ATTRIBUT.TEXT
                 <MP.BOULE.ROUGE>
         </MP.ENCADRE>
 
         Maintenant, si on veux le mot "salut" encadre de deux boules rouges, il suffira d'utiliser
 l'objet <MP.ENCADRE> de la maniere suivante:
 
         <MP.nom_objet nom_attribut1="..." nom_attribut2="..." ...>
 
         ex du fichier HTML source:
 
         <HTML>
                 <HEAD>
                         <TITLE>exemple 2</TITLE>
                 </HEAD>
 
                 <BODY>
                         <MP.ENCADRE TEXT="salut">
                 </BODY>
         </HTML>
 
         Une fois le fichier habille, on obtiendra ceci:
 
         <HTML>
                 <HEAD>
                         <TITLE>exemple 2</TITLE>
                 </HEAD>
 
                 <BODY>
                         <IMG SRC="/rouge.gif">
                         salut
                         <IMG SRC="/rouge.gif">
                 </BODY>
         </HTML>
 
 
         On peut egalement definir une valeur par default pour un attribut donne.
         Supposons que nous avons l'objet <MP.HR> definit de la maniere suivante:
 
         <MP.HR>
                 <CENTER><IMG SRC="/Icon/Serveur/MP/hr.jpg" WIDTH=500 HEIGHT=3></CENTER>
         </MP.HR>
 
         Cet objet permet d'afficher une ligne de separation de taille fixe.
         Supposons maintenant, que nous voulons laisser le choix de la taille a l'utilisateur,
 pour cela, on va utiliser les attributs:
 
         <MP.HR>
                 <CENTER><IMG SRC="/Icon/Serveur/MP/hr.jpg" WIDTH=PM.ATTRIBUT.WIDTH HEIGHT=PM.ATTRIBUT.HEIGHT></CENTER>
         </MP.HR>
 
         On peut maintenant donner la taille voulue a l'objet, en utilisant les attributs de la
 maniere suivante:
 
         <MP.HR WIDTH="500" HEIGHT="3">
         <MP.HR WIDTH="70%" HEIGHT="10">
 
         Or, il y a un petit probleme. Quelle est la taille de l'objet si l'utilisateur
 n'utilise pas les attributs WIDTH et HEIGHT ?
         Pour les objets comme <MP.ENCADRE>, l'utilisation de l'attribut n'est pas obligatoire,
 car a default d'une valeur pour l'attribut TEXT, l'objet sera traduit
par deux boules
 de couleur rouge. Par contre, pour l'objet <MP.HR>, la non initialisation des attributs
 WIDTH et HEIGHT, se traduira par un objet dont la syntaxe HTML sera incorrecte:
 
         <MP.HR> -> <CENTER><IMG SRC="/Icon/Serveur/MP/hr.jpg" WIDTH= HEIGHT=></CENTER>
 
         C'est la que rentre la notion de valeur par default pour les attributs de l'objet en
 question. Disons que nous voulons que la taille par default soit la suivante: WIDTH="500"
 et HEIGHT="3". Pour cela la syntaxe suivante doit etre employe:
 
         <MP.HR WIDTH="500" HEIGHT="3">
                 <CENTER><IMG SRC="/Icon/Serveur/MP/hr.jpg" WIDTH=PM.ATTRIBUT.WIDTH HEIGHT=PM.ATTRIBUT.HEIGHT></CENTER>
         </MP.HR>
 
         <MP.HR> -> <CENTER><IMG SRC="/Icon/Serveur/MP/hr.jpg" WIDTH=500 HEIGHT=3></CENTER>
 
 
         *Test d'existance

		Il arrive parfois qu'un objet ne doit pas etre constamment affiche. Prenons par 
exemple le cas d'un menu qui se retrouve dans chaque page, dans lequel, des 
fleches sont utilisees pour permettre une navigation transversale entre les pages 
d'un mme niveau (NEXT et BACK). Or, il se peut que pour une page donnee, la 
page precedante, ou la page suivante soit inexistante. Il serait donc illogique de se 
retrouver avec une fleche dont la reference n'existe pas.
	L'habillage fournit un objet special pour ce type de situation, cet objet est:

	PM.IF
	
	Sa syntaxe est la suivante:
	
	<PM.IF EXIST=`a` THEN=`c` ELSE=`d`> --> existence de a
	<PM.IF NOEXIST=`a` THEN=`c` ELSE=`d`> --> non existence de a
	<PM.IF TEST=`a PM.EQ b` THEN=`c` ELSE=`d`> --> egalite de a et b
	<PM.IF TEST=`a PM.NE b` THEN=`c` ELSE=`d`> --> non egalite de a et b
	<PM.IF TEST=`a PM.LT b` THEN=`c` ELSE=`d`> --> a plus petit que b
	<PM.IF TEST=`a PM.GT b` THEN=`c` ELSE=`d`> --> a plus grand que b
	<PM.IF TEST=`a PM.CT b` THEN=`c` ELSE=`d`> --> a contient b
	<PM.IF TEST=`a PM.NC b` THEN=`c` ELSE=`d`> --> a ne contient pas b

	L'attribut ELSE etant facultatif.
	Nous avons vu que pour connaitre le nom du fichier suivant, il existait le mot cle 
<PM.KEYWD.NEXT>. Il ne reste plus qu'a tester si ce fichier existe pour savoir si 
notre fleche doit etre affichee ou pas.

	Ex:  (On suppose l'existence de l'objet <MP.FLECHE.NEXT>)

	<MP.MENU.LINK.FLECHE> 
		<PM.IF EXIST=`<PM.KEYWD.NEXT>` THEN=`<MP.FLECHE.NEXT>`> 
	</MP.MENU.LINK.FLECHE>

	Un autre exemple peut etre le fait de vouloir afficher le titre de la page 
suivante dans le cas ou celleci existe. Pour ce faire, on va utiliser le mot cle 
<PM.KEYWD.TITLENEXT>.

	Si le titre existe on affichera la phrase: Next : titre_page_suivante
	Si le titre n'existe pas, on affichera: page Suivante
 
	Ex:


	<MP.MENU.LINK.NEXTTXT> 
		<PM.IF EXIST=`<PM.KEYWD.TITLENEXT>` THEN=`Next : 
<PM.KEYWD.TITLENEXT>` ELSE=`Page Suivante`> 
	</MP.MENU.LINK.NEXTTXT>


         -Notion de la langue	

	Le script d'habillage peut gerer une bdd multilangue, mais pour cela, il 
faudra lui specifier quelles sont les langues utilisees dans le fichier .obj
	L'objet permettant de definir la bdd langue dans le fichier .obj est :

		<PM.LANGAGE>

	Sa syntaxe est la suivante :

	<PM.LANGAGE>
		<PM.LANG TYPE=suffixe de la langue>nom de la langue</PM.LANG>
	</PM.LANGAGE>


	Ex d'utilisation:

	<PM.LANGAGE>
		<PM.LANG TYPE=fr>Fran&ccedil;ais</PM.LANG>
		<PM.LANG TYPE=en>English</PM.LANG>
	</PM.LANGAGE>

	De cette facon, nous avons defini une bdd bilingue francaise-anglaise.

	La consequence directe de cette definition, est que tout les objet dont le nom 
se termine par un suffixe appartenant a la bdd des langues, ne sera utilise que 
dans la page de la meme langue.

	Ex:

	<MP.MENU.FR> ne sera utilise que dans une page .fr.html
	<MP.MENU.EN> ne sera utilise que dans une page .en.html

		 *Habillages paralleles
		 
		Il arrive parfois que le pages soient trop charges en graphisme, et que
malheureusement, toutes les version des navigateurs ne suivent pas, ou simplement
que les gens trouvent ca beau, mais lourd pour pouvoir acceder au contenu. 
		Dans ce cas, on peut prevoir, pour un meme fichier source, plusieurs habillages
differents.
		Pour ce faire, il suffira de definir un habillage parallele avec des nouveaux objets.
		La syntaxe des fichiers d'habillage sera la suivante:

		.obj_nom_d_un_autre_habillage
		.dress_nom_d_un_autre_habillage
	
		nom_d_un_autre_habillage prendra la valeur de votre choix
		Ex:
			.obj_leger
			.dress_leger

		le .link reste le meme

		Il faudra apres specifier quelle est la partie concernee par cet nouvel habillage.
(Il se peut que simplement une sous-partie du site ait besoin d'un double habillage)

		il faudra pour ce faire, editer le fichier dont le nom est :

			autre_habillage

		Et utiliser la syntaxe suivante :

			<Autre_habillage>
				<NOM>nom_d_un_autre_habillage</NOM>
				<PARTIE>partie_concernee</PARTIE>
				<PARTIE>partie_concernee2</PARTIE>
				<NOT_PARTIE>partie_non_concernee</NOT_PARTIE>
				<NOT_PARTIE>partie_non_concernee2</NOT_PARTIE>
			</Autre_habillage>

		Et ceci pour chaque habillage suplementaire.
		
		Ex pour un seul habillage parallele pour la partie /NEWS:

			<Autre_habillage>
				<NOM>leger</NOM>
				<PARTIE>/NEWS</PARTIE>
			</Autre_habillage>

		Ex pour un seul habillage parallele pour la partie /NEWS,
			sauf la partie /NEWS/Spring:

			<Autre_habillage>
				<NOM>leger</NOM>
				<PARTIE>/NEWS</PARTIE>
				<NOT_PARTIE>/NEWS/Spring</NOT_PARTIE>
			</Autre_habillage>

		si le fichier source est nomme index.fr.html, le fichier destination prendra comme
nom index.leger.fr.html, et toutes les references a l'interieur du fichier seront modifies por
rester dans l'habillage parallele. La seule facon de proteger une reference du changement est
de l'encadrer entre les commentaires suivants:

		<!---PARALLELE--->
		<!---/PARALLELE--->

		Autrement, tout les liens a l'exterieur de la partie concernee , ou 
dans la partie protegee, ne seront pas modifies.

		Il faut lancer le script d'habillage avec l'option "p" pour que le double habillage
soit prit en compte.
 
         *Creation de la navigation interne
 
         Si on desire creer une navigation interne, connaitre ainsi
les pages precedente,
 suivante et pere, il faut s'y prendre en deux etapes.
         D'abord l'utilisation des objets <PM.KEYWD.BACK>, <PM.KEYWD.UP> et
 <PM.KEYWD.NEXT> pour connaitre le nom de ces pages.
 
         ex: creation d'un objet pour le lien vers la page suivante:
 
         <MP.IMAGE.MENU.LINK.NEXT>
                 <IMG SRC="/next.gif">
         </MP.IMAGE.MENU.LINK.NEXT>
 
         <MP.MENU.LINK.NEXT>
                 <A HREF="<PM.KEYWD.NEXT>">
                 <MP.IMAGE.MENU.LINK.NEXT>
         </A>
     </MP.MENU.LINK.NEXT>
 
         Ensuite la creation du fichier .link contenant l'arborescence virtuelle des pages.
         Ce fichier .link est propre au repertoire dans lequel il se trouve.
         Sa syntaxe est la suivante (les espaces sont des tabulations):
 
         fichier1.html   <UP>../pere.html</UP>
         fichier2.html
                 :fichier2_1.html
                 :fichier2_2.html
                 :       :fichier2_2_1.html
                 :fichier2_3.html
         fichier3.html
 
     resultat:
 
                                       pere.html
                                         / | \
                               _________/  |  \________
                              /            |           \
                 fichier1.html         fichier2.html     fichier3.html
                                         / | \
                              __________/  |  \__________
                             /             |             \
              fichier2_1.html        fichier2_2.html      fichier2_3.html
                                                                  |
                                                                  |
                                                          fichier2_2_1.html
 

	On peut egalement creer des clones pour certains fichiers. Disons par exemple que nous
avons un fichier nomme welcome.fr.html et qu'on veux aussi avoir un fichier nomme index.fr.html
avec le meme contenu (idem pour la version anglaise). Dans ce cas, plutot que copier dans la partie
source le contenu de welcome dans index, on definit dans le fichier .link que le fichier welcome
va etre duplique.

	Ex de fichier .link:
	
	welcome.+	<TWIN>index.+</TWIN>
	
	le .+ implique que le fichier welcome.fr.html sera copie en index.fr.html et que le fichier 
welcome.en.html sera copie en index.en.html. (le .+ est un joker pour toutes les langues de la 
bdd langues decrite dans le fichier .obj)


Execution du Programme

	Pour lancer un habillage simple sur des pages html, il suffira d'utiliser le script
"main.pl". Autrement, si un habillage parallele veut etre effectue, utiliser le script
"habille.pl" qui va prendre en compte la description du fichier "autre_habillage".
	Le lancement du programme sans aucune option donne la liste complete des options
disponibles



