Index: trunk/workshop-routing-foss4g/chapters/geoext_client.rst
===================================================================
--- trunk/workshop-routing-foss4g/chapters/geoext_client.rst	(revision 63)
+++ trunk/workshop-routing-foss4g/chapters/geoext_client.rst	(revision 74)
@@ -1,43 +1,32 @@
 ==============================================================================================================
-GeoExt Browser Client
+Client en GeoExt
 ==============================================================================================================
 
-`GeoExt <http://www.geoext.org/>`_ is a *JavaScript Toolkit for Rich Web Mapping Applications*. GeoExt
-brings together the geospatial know how of `OpenLayers <http://www.openlayers.org>`_ with
-the user interface savvy of `Ext JS <http://www.sencha.com>`_ to help you build powerful desktop
-style GIS apps on the web with JavaScript.
-
-Let's start with a simple GeoExt example and extend it with routing functionality then:
+`GeoExt <http://www.geoext.org/>`_ est une librairie JavaScript pour le dÃ©veloppement d'applications internet avancÃ©es. GeoExt rassemble les capacitÃ©s d'`OpenLayers <http://www.openlayers.org>`_ avec l'interface utilsiateur savvy de `Ext JS <http://www.sencha.com>`_ pour aider au dÃ©veloppement d'applications similaires Ã  des applications bureautiques.
+
+CommenÃ§ons avec un exemple simple d'utilisation de GeoExt et ajoutons-y les fonctionalitÃ©s de routage :
 
 .. literalinclude:: ../../web/routing-0.html
 	:language: html
 
-In the header we include all the javascript and css needed for the application,
-we also define a function to be run when the page is loaded (Ext.onReady).
-
-This function creates a `GeoExt.MapPanel
-<http://www.geoext.org/lib/GeoExt/widgets/MapPanel.html>`_ with an
-OpenStreetMap layer centered to Denver. In this code, no OpenLayers.Map is
-explicitly created; the GeoExt.MapPanel do this under the hood: it takes the map options, the
-center and the zoom and create a map instance accordingly.
-
-To allow our users to get directions, we need to provide:
- * a way to select the routing algorithm (Shortest path Dijkstra, A* or Shooting*),
- * a way to select the start and final destination.
-
-.. note:: This chapter only show code snippets, the full source code of the
- page can be found in ``pgrouting-workshop/web/routing-final.html`` that should
- be on your desktop. The full listing can also be found at the end of this chapter.
-
--------------------------------------------------------------------------------------------------------------
-Routing method selection
--------------------------------------------------------------------------------------------------------------
-
-To select the routing method, we will use an `Ext.form.ComboBox
-<http://www.sencha.com/deploy/dev/docs/?class=Ext.form.ComboBox>`_: it
-behaves just like a normal html select but we can more easily control it.
-
-Just like the GeoExt.MapPanel, we need an html element to place our control,
-let's create a new div in the body (with 'method' as id):
+Dans l'entÃªte nous chargeons l'ensemble des fichiers javascript et css requis pour l'application. Nous dÃ©finissons aussi une fonction qui sera exÃ©cutÃ©e Ã  la fin du chargement de la page (Ext.onReady).
+
+Cette fonction cÃ©e une instance de`GeoExt.MapPanel
+<http://www.geoext.org/lib/GeoExt/widgets/MapPanel.html>`_ avec une couche de fond OpenStreetMap centrÃ©e sur Denver. Dans ce code, aucun objet OpenLayers.Map est explicitemet crÃ©Ã©; le GeoExt.MapPanel le fait de faÃ§on camouflÃ© : il rÃ©cupÃšre les options de la carte, le centre, le seuil de zoom et crÃ©e une instance de maniÃšre appropriÃ©e.
+
+Pour permettre Ã  nos utilisateurs de trouver leur direction, nous devons fournir :
+ * un moyen de sÃ©lectionner un algorithme de routage  (Dijkstra, A* ou Shooting*),
+ * un moyen de sÃ©lectionner la position de dÃ©part et d'arrivÃ©e.
+
+.. note:: Ce chapitre prÃ©sente uniquement des extraits de codes, le code source complet de la page peut Ãªtre rÃ©cupÃ©rÃ©e depuis ``pgrouting-workshop/web/routing-final.html`` qui devrait Ãªtre sur votre bureau. Le fichier complet se trouve Ã  la fin de ce chapitre.
+
+-------------------------------------------------------------------------------------------------------------
+Outil de sÃ©lection de la mÃ©thode de routage
+-------------------------------------------------------------------------------------------------------------
+
+Pour sÃ©lectionner une mÃ©thode de routage, nous utiliserons un `Ext.form.ComboBox
+<http://www.sencha.com/deploy/dev/docs/?class=Ext.form.ComboBox>`_: il se comporte simplement comme un select html mais est plus simple Ã  controler.
+
+Comme pour le GeoExt.MapPanel, nous avons besoin d'un Ã©lÃ©ments html pour placer notre control, crÃ©ons un div dans le body (ayant 'method' comme identifiant) :
 
  .. code-block:: html
@@ -48,5 +37,5 @@
    </body>
 
-Then we create the combo itself:
+CrÃ©ons ensuite le combo :
  .. code-block:: js
 
@@ -63,53 +52,37 @@
    });
 
-In the ``store`` option, we set all the possible values for the routing method;
-the format is an array of options where an option is in the form ``[key, name]``.
-The ``key`` will be send to the server (the php script in our case) and the
-``value`` displayed in the combo.
-
-The ``renderTo`` specify where the combo must be rendered, we use our new div here.
-
-And finally, a default value is selected:
+Dans l'option ``store``, nous avons dÃ©fini toutes les valeurs pour les mÃ©thodes de routages; les formats sont dans un tableau d'options ou une option est de la forme ``[clef,valeur]``. La ``clef`` sera envoyÃ©e au serveur (the script php dans note cas) et la ``valeur`` affichÃ©e dans la liste dÃ©roulante.
+
+L'option ``renderTo`` dÃ©fini oÃ¹ la liste dÃ©roulante doit Ãªtre affichÃ©e , nous utilisons ici notre Ã©lÃ©ment div.
+
+Et pour finir, une valeur par dÃ©faut est dÃ©finie :
  .. code-block:: js
 
     method.setValue("SPD");
 
-This part only uses ExtJS component: no OpenLayers or GeoExt code here.
-
--------------------------------------------------------------------------------------------------------------
-Select the start and final destination
--------------------------------------------------------------------------------------------------------------
-
-We want to allow the users to draw and move the start and final destination
-points. This is more or less the behavior of google maps and others: the user
-selects the points via a search box (address search) or by clicking the
-map. The system query the server and display the route on the map. The user
-can later move the start or final point and the route is updated.
-
-In this workshop, we will only implement the input via the map (draw points and
-drag-and-drop) but it's possible to implement the search box feature by using a
-web service like `GeoNames <http://www.geonames.org/>`_ or any other `geocoding
-<http://en.wikipedia.org/wiki/Geocoding>`_ service.
-
-To do this we will need a tool to draw points (we will use the
+Cette partie utilise le composant ExtJS : ni code OpenLayers ni GeoExt.
+
+-------------------------------------------------------------------------------------------------------------
+SÃ©lectionner un point de dÃ©part et d'arrivÃ©e
+-------------------------------------------------------------------------------------------------------------
+
+Nous souhaitons permettre Ã  nos utilisateurs de dÃ©ssiner et dÃ©placer un point de dÃ©part et d'arrivÃ©e. C'est plus ou moins le comportement des applications comme google map et les autres : l'utilsateur choisi un point de dÃ©part Ã  l'aide d'un moteur de recherche ou en cliquant sur la carte. L'applicationinterroge ensuite le serveur afin d'afficher le chemin sur la carte. L'utilisateur peut ensuite modifier son opint de dÃ©part et d'arrivÃ©e afin que le chemin soit mis Ã  jour automatiquement.
+
+Dans ces travaux pratiques, nous implÃ©menterons seulement la saisie de point sur la carte (dessiner des points et les dÃ©placer) mais il est parfaitement possible d'implÃ©menter un moteur de recherche en utilisant un service web dÃ©diÃ© tel que `GeoNames <http://www.geonames.org/>`_ ou tout autre service de `geocodage
+<http://fr.wikipedia.org/wiki/Geocodage>`_.
+
+Pour faire ceci nous aurons besoin d'un outil permettant de dessiner des points (nous utiliserons le control
 `OpenLayers.Control.DrawFeatures
-<http://openlayers.org/dev/examples/draw-feature.html>`_ control) and a tool to
-move points (`OpenLayers.Control.DragFeatures
-<http://openlayers.org/dev/examples/drag-feature.html>`_ will be perfect for
-this job). As their name suggests these controls comes from OpenLayers.
-
-These two controls will need a place to draw and manipulate the points; we
-will also need an `OpenLayers.Layer.Vector
-<http://dev.openlayers.org/releases/OpenLayers-2.10/doc/apidocs/files/OpenLayers/Layer/Vector-js.html>`_
-layer. In OpenLayers, a vector layer in a place where features (a geometry and
-attributes) can be drawn programmatically (in contrast, the OSM layer is a
-raster layer).
-
-Because vector layers are cheap, we will use a second one to draw the route
-returned by the web service. The layers initialization is:
-
- .. code-block:: js
-
-    // create the layer where the route will be drawn
+<http://openlayers.org/dev/examples/draw-feature.html>`_) et un outil pour dÃ©placer les points (`OpenLayers.Control.DragFeatures
+<http://openlayers.org/dev/examples/drag-feature.html>`_ sera parfait pour ce travail). Comme leur noms le suppose ces controls sont disponibles dans OpenLayers.
+
+Ces deux controls auront besoin d'un emplacement pour afficher et manipuler les points; nous aurons besoin d'une couche `OpenLayers.Layer.Vector
+<http://dev.openlayers.org/releases/OpenLayers-2.10/doc/apidocs/files/OpenLayers/Layer/Vector-js.html>`_. Dans OpenLayers, une couche vecteur est un endroit oÃ¹ des Ã©lements (une geomÃ©trie et des attributs) peuvent Ãªtre afffichÃ©e (contrairement Ã  la couche OSM qui est une couche raster).
+
+Comme les couches vecteurs sont lÃ©gÃšres, nous en utiliserons une seconde pour afficher la route retourner par le service web. L'initialisation de la couche se fait de la maniÃšre suivante :
+
+ .. code-block:: js
+
+    // CrÃ©ation de la couche oÃ¹ le chemin sera affichÃ©
     var route_layer = new OpenLayers.Layer.Vector("route", {
         styleMap: new OpenLayers.StyleMap(new OpenLayers.Style({
@@ -119,91 +92,76 @@
     });
 
-``"route"`` is the layer name, any string can be used.
-``styleMap`` gives the layer a bit of visual style with a custom stroke color and
-width (in pixel).
-
-The second layer initialization is simply:
-
- .. code-block:: js
-
-    // create the layer where the start and final points will be drawn
+``"route"`` est  le nom de la couche, n'importe qu'elle chaÃ®ne de caractÃšres peut Ãªtre utilisÃ©e.
+``styleMap`` fournis Ã  la couche un mimum de style avec une couleur de contour particuliÃšre et un largeur (en pixel).
+
+La seconde couche est simplement initialiser comme suit :
+
+ .. code-block:: js
+
+    // CrÃ©ation de la couche ou seront affichÃ© les points de dÃ©part et d'arrivÃ©e
     var points_layer = new OpenLayers.Layer.Vector("points");
 
-The two layers are added to the OpenLayers.Map object with:
-
- .. code-block:: js
-
-    // add the layers to the map
+Les deux couches sont ajoutÃ©e Ã  l'objet OpenLayers.Map avec :
+
+ .. code-block:: js
+
+    // Ajouter la cocuhe Ã  la carte
     map.addLayers([points_layer, route_layer]);
 
-Let's look at the control to draw the points: because this component has
-special behavior it's more easy to create a new class based on the standard
-OpenLayers.Control.DrawFeatures control. This new control (named DrawPoints) is
-saved in a separated javascript file (``web/DrawPoints.js``):
+Regardons le control pour afficher les points : puisque ce composant Ã  un comportement particulier il est plus simple de crÃ©er une nouvelle classe basÃ©e sur le control standard
+OpenLayers.Control.DrawFeatures. Ce control (nommÃ© DrawPoints) est enregistrÃ© dans un fichier javascript Ã  part (``web/DrawPoints.js``):
 
 .. literalinclude:: ../../web/DrawPoints.js
 	:language: js
 
-In the ``initialize`` function (that's the class constructor) we set that
-this control can only draw points (handler variable is OpenLayers.Handler.Point).
-
-The special behavior is implemented in the ``drawFeature`` function: because we
-only need the start and final points the control deactivates itself when two
-points are drawn by counting how many features has the vector
-layer. Control deactivation is ``this.deactivate()``.
-
-Our control is then created with:
-
- .. code-block:: js
-
-    // create the control to draw the points (see the DrawPoints.js file)
+Dans la fonction ``initialize`` (qui est le constructeur de la classe) nous spÃ©cifions que ce control peut seulement dessiner des point (la variable handler est OpenLayers.Handler.Point).
+
+Le comportement spÃ©cifique est implÃ©mentÃ© dans la fonction ``drawFeature`` : puisque nous avons seulement  besoin des points de dÃ©part et d'arrivÃ©e, le control se desactive automatiquemnt lorsque deux points ont Ã©tÃ© saisie. La dÃ©sactivation se fait via ``this.deactivate()``.
+
+Notre control est ensuite crÃ©Ã© avec :
+
+ .. code-block:: js
+
+    // CrÃ©ation du control pour dessiner les points (voir le fichier DrawPoints.js)
     var draw_points = new DrawPoints(points_layer);
 
-``points_layer`` is the vector layer created earlier.
-
-And now for the DragFeature control:
-
- .. code-block:: js
-
-    // create the control to move the points
+``points_layer`` est la couche vecteur crÃ©Ã©e prÃ©cÃ©demment.
+
+Et maintenant pour le control DragFeature :
+
+ .. code-block:: js
+
+    // CrÃ©ation du control pour dÃ©placer les points 
     var drag_points = new OpenLayers.Control.DragFeature(points_layer, {
         autoActivate: true
     });
 
-Again, ``points_layer`` is the vector layer, ``autoActivate: true`` tells
-OpenLayers that we want this control to be automatically activated.
-
- .. code-block:: js
-
-    // add the controls to the map
+Encore une fois, la couche ``points_layer``est de type vecteur, ``autoActivate: true`` dit Ã  OpenLayers que nous voulons que ce control soit automatiquement activÃ©.
+
+ .. code-block:: js
+
+    // Ajouter le control Ã  la carte
     map.addControls([draw_points, drag_points]);
 
-Adds the controls to the map.
-
--------------------------------------------------------------------------------------------------------------
-Call and receive data from web service
--------------------------------------------------------------------------------------------------------------
-
-The basic workflow to get a route from the web server is:
-
-#. transform our points coordinates from EPSG:900913 to EPSG:4326
-#. call the web service with the correct arguments (method name and two points coordinates)
-#. parse the web service response: transform GeoJSON to OpenLayers.Feature.Vector
-#. transform all the coordinates from EPSG:4326 to EPSG:900913
-#. add this result to a vector layer
-
-The first item is something new: our map uses the EPSG:900913 projection
-(because we use an OSM layer) but the web service expects coordinates in
-EPSG:4326: we have to re-project the data before sending them. This is not a
-big deal: we will simply use the `Proj4js <http://trac.osgeo.org/proj4js/>`_
-javascript library.
-
-(The second item *call the web service* is covered in the next chapter.)
-
-The routing web service in pgrouting.php returns a `GeoJSON
-<http://geojson.org/>`_ FeatureCollection object. A FeatureCollection is simply
-an array of features: one feature for each route segment. This is very convenient because
-OpenLayers and GeoExt have all what we need to handle this format. To make our
-live even easier, we are going to use the GeoExt.data.FeatureStore:
+Ajouter le control Ã  la carte.
+
+-------------------------------------------------------------------------------------------------------------
+Envoyer et recevoire des donnÃ©es du service web
+-------------------------------------------------------------------------------------------------------------
+
+Le cheminement de base pour obtenir un chemin depuis le service web est le suivant :
+
+#. transformer nos points en coordonnÃ©es de EPSG:900913 en EPSG:4326
+#. appeler le service web avec les arguments correctes (nom de la mÃ©thode et deux points)
+#. lire le rÃ©sultat retournÃ© par le service web : transformer le GeoJSON en OpenLayers.Feature.Vector
+#. transformer toutes les coordonnÃ©es de EPSG:4326 Ã  EPSG:900913
+#. ajouter le rÃ©sultat Ã  la couche vecteur
+
+La premiÃšre Ã©tape est quelque chose de nouveau : notre carte utilise le systÃšme de projection EPSG:900913 
+(parce que nous utilisons une couche OSM) mais le service web attends des coordonnÃ©es en EPSG:4326 : nous devons re-projeter les donnÃ©es avant de les envoyer. Ce n'est pas bien difficile : nous aurons simplement besoin de la ` librairie javascript Proj4js <http://trac.osgeo.org/proj4js/>`_.
+
+(La deuxiÃšme Ã©tape *appeler le service web* est Ã©tudiÃ© au chapitre suivant.)
+
+Le service web de routage dans pgrouting.php renvoit un objet  FeatureCollection au format `GeoJSON <http://geojson.org/>`_. Un objet FeatureCollection est simplement un tableau d'Ã©lÃ©ment : un Ã©lÃ©ments pour chaque tronÃ§on de route. Ceci est trÃšs pratique carOpenLayers et GeoExt ont tout ce dont nous avons besoin pour gÃ©rer ce format. Pour nous rendre la tÃ¢che encore plus simple, nous utiliserons le GeoExt.data.FeatureStore suivant :
 
  .. code-block:: js
@@ -225,43 +183,29 @@
     });
 
-A store is simply a container to store informations: we can push data into and
-get it back.
-
-Let's explain all the options:
-
-``layer``: the argument is a vector layer: by specifying a layer, the
-FeatureStore will automatically draw the data received into this
-layer. This is exactly what we need for the last item (*add this result to a
-vector layer*) in the list above.
-
-``fields``: lists all the attributes returned along with the geometry: pgrouting.php
-returns the segment length so we set it here. Note that this information is not
-used in this workshop.
-
-``proxy``: the proxy item specify where the data should be taken: in our case
-from a HTTP server. The proxy type is GeoExt.data.ProtocolProxy: this class
-connects the ExtJS world (the store) and the OpenLayers world (the protocol
-object).
-
-``protocol``: this OpenLayers component is able to make HTTP requests to an ``url``
-(our php script) and to parse the response (``format`` option). By adding the
-``internalProjection`` and ``externalProjection`` option, the coordinates
-re-projection in made by the format.
-
-We now have all what we need to handle the data returned by the web service: the next
-chapter will explain how and when to call the service.
-
--------------------------------------------------------------------------------------------------------------
-Trigger the web service call
--------------------------------------------------------------------------------------------------------------
-
-We need to call the web service when:
- * the two points are drawn
- * one of the point is moved
- * the routing method has changed
-
-Our vector layer generates an event (called ``featureadded``) when a
-new feature is added, we can listen to this event and call to pgrouting
-function (this function will be presented shortly):
+Un Store est simplement un conteneur qui stocke des informations : nous pouvons y ajouter des Ã©lÃ©ments et les rÃ©cupÃ©rer.
+
+Expliquons les options :
+
+``layer``: le paramÃštre est une couche vecteur : en spÃ©cifiant une couche, le
+FeatureStore affichera automatiquement les donnÃ©es qu'elle contient. C'est exactement ce dont nous avons besoin pour la derniÃšre Ã©tape (*ajouter le rÃ©sultat Ã  la couche vecteur*) dans la liste ci-dessus.
+
+``fields``: liste tout les attributs renvoyÃ©s avec la gÃ©omÃ©trie : pgrouting.php renvoit la longueurdu segment donc nous le spÃ©cifions ici. Notez que cette information n'est pas utilisÃ©e dans ces travaux pratiques.
+
+``proxy``: le paramÃštre proxy specifie oÃ¹ nous devons rÃ©cupÃ©rer les donnÃ©es : dans notre cas depuis le serveur HTTP. Le type de proxy est GeoExt.data.ProtocolProxy : cette classe connecte le monde ExtJS (le Store) et le monde OpenLayers (l'objet protocol).
+
+``protocol``: ce composant OpenLayers est capable d'exÃ©cuter des requÃªtes Ã  un``url`` (notre script php) et de lire la rÃ©ponse (option ``format``). En ajoutant les options ``internalProjection`` et ``externalProjection``, les coordonnÃ©es sont reprojetÃ©es par l'objet format.
+
+Nous avons maintenant tout ce qu'il nous faut pour gÃ©rer les donnÃ©es renvoyÃ©es par le service web : le prochain chapitre expliquera comment et quand l'appeler.
+
+-------------------------------------------------------------------------------------------------------------
+DÃ©clancher l'appel au service web
+-------------------------------------------------------------------------------------------------------------
+
+Nous devons appeler le service web lorsque :
+ * les deux points sont dessinÃ©s
+ * un point Ã  Ã©tÃ© dÃ©placÃ©
+ * la mÃ©thode Ã  utiliser a changÃ© 
+
+Notre couche vecteur gÃ©nÃšre une Ã©vÃ©nement (appelÃ© ``featureadded``) lorsqu'un nouvel Ã©lÃ©ment est ajoutÃ©, nous pouvons utiliser cet Ã©vÃ©nement pour appeler la fonction pgrouting (cette fonction sera prÃ©sentÃ© dans peu de temps) :
 
  .. code-block:: js
@@ -273,12 +217,7 @@
     });
 
-.. note:: Before we continue some words about events: an event in OpenLayers
-  (the same apply for ExtJS and other frameworks), is a system to allow a
-  function to be called when *something* happened. For instance when a layer is
-  added to the map or when the mouse is over a feature. Multiple functions can
-  be connected to the same event.
-
-No event is generated when a point is moved, hopefully we can give a
-function to the DragFeature control to be called we the point is moved:
+.. note:: Avant de continuer quelque mots sur les Ã©vÃ©nements : un Ã©vÃ©nement dans OpenLayers (la mÃªme chose s'applique pour ExtJS et les autres frameworks), est un systÃšme qui permet Ã  une fonction d'Ãªtre appelÃ©e lorsque *quelquechose* se passe. Par exemple lorsqu'une couche est ajoutÃ©e Ã  la carte ou quand la souris se trouve au dessus d'un objet de la carte. Plusieurs fonctions peuvent Ãªtre liÃ©es Ã  un mÃªme Ã©vÃ©nement.
+
+Aucune Ã©vÃ©nemenet n'est gÃ©nÃ©rÃ© lorsqu'un point est dÃ©placÃ©, heureusement nous pouvons dÃ©finir une fonction Ã  notre control DragFeature Ã  appeler lorsqu'un point est dÃ©placÃ© :
 
  .. code-block:: js
@@ -288,6 +227,5 @@
     };
 
-For the *method* combo, we can add a listeners options to the constructor with
-a `select` argument (that's the event triggered when the user changes the value):
+Pour la liste dÃ©roulante *method*, nous pouvons ajouter une option `select` au contructeur  (c'est l'Ã©vÃ©nement dÃ©clencher lorsqu'un utilisateur change sa sÃ©lection) :
 
  .. code-block:: js
@@ -309,6 +247,5 @@
     });
 
-
-It's now time to present the pgrouting function:
+Il est maintenant temps de prÃ©senter la fonction pgrouting :
 
  .. code-block:: js
@@ -340,27 +277,22 @@
     }
 
-The pgrouting function calls the web service through the store argument.
-
-At first, the function checks if two points are passed in
-argument. Then, ``store.removeAll()`` is called to erase a previous result
-from the layer (remember that the store and the vector layer are binded).
-The two points coordinates are then projected using OpenLayers.Projection
-instances.
-
-Finally, ``store.load()`` is called with a ``params`` representing the
-pgrouting.php arguments (they are passed to the HTTP GET call).
-
--------------------------------------------------------------------------------------------------------------
-What's next ?
--------------------------------------------------------------------------------------------------------------
-
-Possible enhancements:
- * use a geocoding service to get start/final point
- * way point support
- * nice icons for the start and final points
- * driving directions (road map): we already have the segment length
-
--------------------------------------------------------------------------------------------------------------
-Full source code
+La fonction pgrouting appÃšle me service web Ã  travers l'argument store.
+
+Au dÃ©but, la fonction vÃ©rifie si deux points sont prÃ©sent dans les paramÃštres. Ensuite, `select` est appelÃ©e pour Ã©ffacer le rÃ©sultat prÃ©cÃ©dent de la couche (souvenez-vous que le Store et la couche vecteur sont liÃ©). Les deux points sont projetÃ©s en utilisant une instance de OpenLayers.Projection.
+
+Pour finir, ``store.load()`` est appelÃ©e avec un argument ``params`` (ils sont passÃ©s via un appÃšle HTTP utilisant la mÃ©thode GET).
+
+-------------------------------------------------------------------------------------------------------------
+Que faire maintenant ?
+-------------------------------------------------------------------------------------------------------------
+
+Possibles amÃ©liorations :
+ * Utiliser un service de gÃ©ocodage pour rÃ©cupÃ©rer le point de dÃ©part / d'arrivÃ©e
+ * Support de plusieurs points 
+ * De jolies icÃŽnes pour le point de dÃ©part et celui d'arrivÃ©e
+ * Direction du parcour (carte de voyage) : nous avons dÃ©jÃ  la distance
+
+-------------------------------------------------------------------------------------------------------------
+Code source complet
 -------------------------------------------------------------------------------------------------------------
 
