# Language fr-FR translations for PACKAGE package.
# Automatically generated, 2008.
#
msgid ""
msgstr ""
"Project-Id-Version: PACKAGE VERSION\n"
"Report-Msgid-Bugs-To: http://bugs.kde.org\n"
"POT-Creation-Date: 2008-10-14 11:38+0000\n"
"PO-Revision-Date: 2009-08-10 23:21+0100\n"
"Last-Translator: P.J <essaidetest@yahoo.fr>\n"
"Language-Team: none\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"

#. Tag: title
#: Groovy.xml:5
#, no-c-format
msgid "Groovy integration"
msgstr "L'intégration avec Groovy"

#. Tag: para
#: Groovy.xml:7
#, no-c-format
msgid "One aspect of JBoss Seam is its RAD (Rapid Application Development) capability. While not synonymous with RAD, one interesting tool in this space is dynamic languages. Until recently, choosing a dynamic language was required choosing a completely different development platform (a development platform with a set of APIs and a runtime so great that you would no longer want to use you old legacy Java [sic] APIs anymore, which would be lucky because you would be forced to use those proprietary APIs anyway). Dynamic languages built on top of the Java Virtual Machine, and <ulink url=\"http://groovy.codehaus.org\">Groovy</ulink> in particular broke this approach in silos."
msgstr "Un des aspects de JBoss Seam est dans sa capacité RAD (Rapid Application Development, NdT Développement d'Application Rapide). Sans synonimie avec RAD, l'outil intéréssant dans ce cas est dans les langages dynamiques. Jusqu'à présent, choisir un langage dynamique était un choix qui été requis par une plateforme de développement complètement différente (une plateforme de développement avec un groupe d'APIs et un runtime si génial que vous ne devriez plus vouloir utiliser vos bonnes vieille APIs Java [sic] après, ce qui est une chance car vous ne devriez plus être forcé d'utiliser ces APIs propriétaire maintenant). Les langages dynamiques sont construis au dessus de la Machine Virtuelle Java et <ulink url=\"http://groovy.codehaus.org\">Groovy</ulink> en particulier brise cette approche en silos."

#. Tag: para
#: Groovy.xml:15
#, no-c-format
msgid "JBoss Seam now unites the dynamic language world with the Java EE world by seamlessly integrating both static and dynamic languages. JBoss Seam lets the application developer use the best tool for the task, without context switching. Writing dynamic Seam components is exactly like writing regular Seam components. You use the same annotations, the same APIs, the same everything."
msgstr "JBoss Seam unifie maintenant le monde des langages dynamiques avec le monde Java EE en intégrant sans couture les deux langages statique et dynamique. JBoss Seam permet au développer d'application d'utiliser le meilleur outil pour la tâche, sans basculer de contexte. Ecrire les composants dynamiques de Seam est exactement comme écrire des composants classiques de Seam. Vous utilisez les même annotations, les même APIs, les mêmes tout."

#. Tag: title
#: Groovy.xml:21
#, no-c-format
msgid "Groovy introduction"
msgstr "Introduction à Groovy"

#. Tag: para
#: Groovy.xml:23
#, no-c-format
msgid "Groovy is an agile dynamic language based on the Java language but with additional features inspired by Python, Ruby and Smalltalk. The strengths of Groovy are twofold:"
msgstr "Groovy est un langage dynamique agile basé sur le langage Java avec des fonctionnalité additionnelles inspirée par Python, Ruby et Smalltalk. La force de Groovy est dans deux points:"

#. Tag: para
#: Groovy.xml:28
#, no-c-format
msgid "Java syntax is supported in Groovy: Java code is Groovy code, making the learning curve very smooth"
msgstr "La syntaxe Java est supportée dans  Groovy: le code Java est le code Groovy, ce qui rend la courbe d'apprentissage très douce"

#. Tag: para
#: Groovy.xml:33
#, no-c-format
msgid "Groovy objects are Java objects, and Groovy classes are Java classes: Groovy integrates smoothly with existing Java libraries and frameworks."
msgstr "Les objets Groovy sont des objets Java, et les classes Groovy sont des classes Java: Groovy s'intègre facilement avec les bibliothèques Java et les serveurs d'applications."

#. Tag: para
#: Groovy.xml:38
#, no-c-format
msgid "TODO: write a quick overview of the Groovy syntax add-on"
msgstr "A FAIRE: ecrire un rapide apperçu de l'ajout de syntaxe Groovy"

#. Tag: title
#: Groovy.xml:42
#, no-c-format
msgid "Writing Seam applications in Groovy"
msgstr "L'écriture d'applications Seam en Groovy"

#. Tag: para
#: Groovy.xml:44
#, no-c-format
msgid "There is not much to say about it. Since a Groovy object is a Java object, you can virtually write any Seam component, or any class for what it worth, in Groovy and deploy it. You can also mix Groovy classes and Java classes in the same application."
msgstr "Il n'y a pas grand chose à dire à propos de cela. Si un objet Groovy est un objet Java, vous pouvez virtuellement écrire tout composant Seam, ou toute classe pour ce qui est prévu, en Groovy et la déployer. Vous pouvez aussi mélanger les classes Groovy et Java dans la même application."

#. Tag: title
#: Groovy.xml:49
#, no-c-format
msgid "Writing Groovy components"
msgstr "Ecriture de composants en Groovy"

#. Tag: para
#: Groovy.xml:51
#, no-c-format
msgid "As you should have noticed by now, Seam uses annotations heavily. Be sure to use Groovy 1.1 or above for annotation support. Here are some example of groovy code used in a Seam application."
msgstr "Comme vous devriez avoir noté maintenant, Seam utilise lourdement les annotations. Soyez sûr d'utiliser Groovy 1.1 ou supérieur pour le support des annotations. Voici un exemple de code en groovy utilisé dans une application Seam."

#. Tag: title
#: Groovy.xml:55
#, no-c-format
msgid "Entity"
msgstr "Entité"

#. Tag: programlisting
#: Groovy.xml:57
#, no-c-format
msgid ""
"@Entity\n"
"    @Name(\"hotel\")\n"
"    class Hotel implements Serializable\n"
"    {\n"
"        @Id @GeneratedValue\n"
"        Long id\n"
"\n"
"        @Length(max=50) @NotNull\n"
"        String name\n"
"\n"
"        @Length(max=100) @NotNull\n"
"        String address\n"
"\n"
"        @Length(max=40) @NotNull\n"
"        String city\n"
"\n"
"        @Length(min=2, max=10) @NotNull\n"
"        String state\n"
"\n"
"        @Length(min=4, max=6) @NotNull\n"
"        String zip\n"
"\n"
"        @Length(min=2, max=40) @NotNull\n"
"        String country\n"
"\n"
"        @Column(precision=6, scale=2)\n"
"        BigDecimal price\n"
"\n"
"        @Override\n"
"        String toString()\n"
"        {\n"
"            return \"Hotel(${name},${address},${city},${zip})\"\n"
"        }\n"
"    }"
msgstr ""
"@Entity\n"
"    @Name(\"hotel\")\n"
"    class Hotel implements Serializable\n"
"    {\n"
"        @Id @GeneratedValue\n"
"        Long id\n"
"\n"
"        @Length(max=50) @NotNull\n"
"        String name\n"
"\n"
"        @Length(max=100) @NotNull\n"
"        String address\n"
"\n"
"        @Length(max=40) @NotNull\n"
"        String city\n"
"\n"
"        @Length(min=2, max=10) @NotNull\n"
"        String state\n"
"\n"
"        @Length(min=4, max=6) @NotNull\n"
"        String zip\n"
"\n"
"        @Length(min=2, max=40) @NotNull\n"
"        String country\n"
"\n"
"        @Column(precision=6, scale=2)\n"
"        BigDecimal price\n"
"\n"
"        @Override\n"
"        String toString()\n"
"        {\n"
"            return \"Hotel(${name},${address},${city},${zip})\"\n"
"        }\n"
"    }"

#. Tag: para
#: Groovy.xml:59
#, no-c-format
msgid "Groovy natively support the notion of properties (getter/setter), so there is no need to explicitly write verbose getters and setters: in the previous example, the hotel class can be accessed from Java as <code>hotel.getCity()</code>, the getters and setters being generated by the Groovy compiler. This type of syntactic sugar makes the entity code very concise."
msgstr "Groovy supporte nativement la notion de propriété (asseseurs), donc il n'y a pas besoin d'écrire de verbeux assesseurs: dans l'exemple précédent, la classe hotel peut être accédé depuis Java comme  <code>hotel.getCity()</code>, les asseseurs peuvent être générés par le compilateur Groovy. Le type de la syntaxe pur sucre rends le code de l'entité très concise."

#. Tag: title
#: Groovy.xml:67
#, no-c-format
msgid "Seam component"
msgstr "Le composant Seam"

#. Tag: para
#: Groovy.xml:69
#, no-c-format
msgid "Writing Seam components in Groovy is in no way different than in Java: annotations are used to mark the class as a Seam component."
msgstr "Ecrire les composants Seam en Groovy n'est pas vraiment différent qu'en Java: les annotations sont utilisées pour marquer la classe comme un composant de Seam."

#. Tag: programlisting
#: Groovy.xml:72
#, no-c-format
msgid ""
"@Scope(ScopeType.SESSION)\n"
"@Name(\"bookingList\")\n"
"class BookingListAction implements Serializable\n"
"{\n"
"    @In EntityManager em\n"
"    @In User user\n"
"    @DataModel List&lt;Booking&gt; bookings\n"
"    @DataModelSelection Booking booking\n"
"    @Logger Log log\n"
"\n"
"    @Factory public void getBookings()\n"
"    {\n"
"        bookings = em.createQuery('''\n"
"                select b from Booking b\n"
"                where b.user.username = :username\n"
"                order by b.checkinDate''')\n"
"            .setParameter(\"username\", user.username)\n"
"            .getResultList()\n"
"    }\n"
"    \n"
"    public void cancel()\n"
"    {\n"
"        log.info(\"Cancel booking: #{bookingList.booking.id} for #{user.username}\")\n"
"        Booking cancelled = em.find(Booking.class, booking.id)\n"
"        if (cancelled != null) em.remove( cancelled )\n"
"        getBookings()\n"
"        FacesMessages.instance().add(\"Booking cancelled for confirmation number #{bookingList.booking.id}\", new Object[0])\n"
"    }\n"
"}"
msgstr ""
"@Scope(ScopeType.SESSION)\n"
"@Name(\"bookingList\")\n"
"class BookingListAction implements Serializable\n"
"{\n"
"    @In EntityManager em\n"
"    @In User user\n"
"    @DataModel List&lt;Booking&gt; bookings\n"
"    @DataModelSelection Booking booking\n"
"    @Logger Log log\n"
"\n"
"    @Factory public void getBookings()\n"
"    {\n"
"        bookings = em.createQuery('''\n"
"                select b from Booking b\n"
"                where b.user.username = :username\n"
"                order by b.checkinDate''')\n"
"            .setParameter(\"username\", user.username)\n"
"            .getResultList()\n"
"    }\n"
"    \n"
"    public void cancel()\n"
"    {\n"
"        log.info(\"Cancel booking: #{bookingList.booking.id} for #{user.username}\")\n"
"        Booking cancelled = em.find(Booking.class, booking.id)\n"
"        if (cancelled != null) em.remove( cancelled )\n"
"        getBookings()\n"
"        FacesMessages.instance().add(\"Booking cancelled for confirmation number #{bookingList.booking.id}\", new Object[0])\n"
"    }\n"
"}"

#. Tag: title
#: Groovy.xml:79
#: Groovy.xml:146
#, no-c-format
msgid "seam-gen"
msgstr "seam-gen"

#. Tag: para
#: Groovy.xml:81
#, no-c-format
msgid "Seam gen has a transparent integration with Groovy. You can write Groovy code in seam-gen backed projects without any additional infrastructure requirement. When writing a Groovy entity, simply place your <filename>.groovy</filename> files in <filename>src/main</filename>. Unsurprisingly, when writing an action, simply place your <filename>.groovy</filename> files in <filename>src/hot</filename>."
msgstr "Seam-gen as une intégration transparente avec Groovy. Vous pouvez écrire le code Groovy dans un projet géré par seam-gen sans aucun prérequis d'infrastructure additionnel. Quand à écrire une entité Groovy, placez simplement vos fichiers <filename>.groovy</filename> dans <filename>src/main</filename>. Sans surprise, avec l'écriture d'une action, placez simplement vos fichiers <filename>.groovy</filename> dans  <filename>src/hot</filename>."

#. Tag: title
#: Groovy.xml:90
#, no-c-format
msgid "Deployment"
msgstr "Le déploiement"

#. Tag: para
#: Groovy.xml:92
#, no-c-format
msgid "Deploying Groovy classes is very much like deploying Java classes (surprisingly, no need to write nor comply with a 3-letter composite specification to support a multi-language component framework)."
msgstr "Le déploiement des classes Groovy est assez proche du déploiement des classes Java (sans surprise, pas besoin d'écrire ni de se conformer avec la spécification composite en 3 lettres pour supportert un serveur d'application multi langage)."

#. Tag: para
#: Groovy.xml:95
#, no-c-format
msgid "Beyond standard deployments, JBoss Seam has the ability, at development time, to redeploy JavaBeans Seam component classes without having to restart the application, saving a lot of time in the development / test cycle. The same support is provided for GroovyBeans Seam components when the <filename>.groovy</filename> files are deployed."
msgstr "Au delà des déploiement standard, JBoss Seam a la capacité ,au moment du développement, de redéployer les classes de composants Seam JavaBeans sans avoir à redémarrer l'application, préservant beaucoup de temps de développement dans le cycle développement/test. Le même support est fourni par les composants de Seam de GroovyBeans quand les fichiers <filename>.groovy</filename> sont déployés."

#. Tag: title
#: Groovy.xml:101
#, no-c-format
msgid "Deploying Groovy code"
msgstr "Le déploiement de code Groovy"

#. Tag: para
#: Groovy.xml:103
#, no-c-format
msgid "A Groovy class <emphasis>is</emphasis> a Java class, with a bytecode representation just like a Java class. To deploy, a Groovy entity, a Groovy Session bean or a Groovy Seam component, a compilation step is necessary. A common approach is to use the <literal>groovyc</literal> ant task. Once compiles, a Groovy class is in no way different than a Java class and the application server will treat them equally. Note that this allow a seamless mix of Groovy and Java code."
msgstr "Une classe Groovy <emphasis>est</emphasis> une classe Java avec une représentation en bytecode tout comme une classe Java. Pour déployer une entité Groovy, un bean de session Groovy ou un composant Seam Groovy, une étape de compilation est nécéssaire. Une approche commune est d'utiliser la tache ant <literal>groovyc</literal>. Une fois compilé, une classe Groovy n'est en acune manière différente d'une classe Java et le serveur d'application la traitera à équalité. Notez que cela autorise un mélange intégré de Groovy et de code Java."

#. Tag: title
#: Groovy.xml:111
#, no-c-format
msgid "Native .groovy file deployment at development time"
msgstr "Le déploiement de fichier .groovy natif au moment du déploiement"

#. Tag: para
#: Groovy.xml:113
#, no-c-format
msgid "JBoss Seam natively supports the deployment of <literal>.groovy</literal> files (ie without compilation) in incremental hotdeployment mode (development only). This enables a very fast edit/test cycle. To set up .groovy deployments, follow the configuration at <xref linkend=\"gettingstarted-hotdeployment\"/> and deploy your Groovy code (<filename>.groovy</filename> files) into the <filename>WEB-INF/dev</filename> directory. The GroovyBean components will be picked up incrementally with no need to restart the application (and obviously not the application server either)."
msgstr "JBoss Seam supporte nativement le déploiement de fichier <literal>.groovy</literal> f (autrement dit sans compilation) dans le mode de redéploiement à chaud incrémental (seulement au développement). Cela rend possible un cycle edition/test très rapide. Pour configurer le déploiement de .groovy, suivez la configuration de la  <xref linkend=\"gettingstarted-hotdeployment\"/>  et deploiyez votre code Groovy (les fichiers  <filename>.groovy</filename>) dans le dossier <filename>WEB-INF/dev</filename>. Les composants GroovyBean vont être pris  incrémentallement sans avoir besoin de redémarrer l'application (ni heureusement le serveur d'application)."

#. Tag: para
#: Groovy.xml:120
#, no-c-format
msgid "Be aware that the native .groovy file deployment suffers the same limitations as the regular Seam hotdeployment:"
msgstr "Soyez informé que le déploiement de fichier .groovy natif souffre des limitations identique du redéploiement à chaud classique de Seam:"

#. Tag: para
#: Groovy.xml:125
#, no-c-format
msgid "The components must be JavaBeans or GroovyBeans. They cannot be EJB3 bean"
msgstr "Les composants doivent être des JavaBeans ou des GroovyBeans. Ils ne peuvent pas être des beans EJB3 "

#. Tag: para
#: Groovy.xml:129
#, no-c-format
msgid "Entities cannot be hotdeployed"
msgstr "Les entités ne peuvent pas redéployées à chaud"

#. Tag: para
#: Groovy.xml:133
#, no-c-format
msgid "The hot-deployable components will not be visible to any classes deployed outside of <literal>WEB-INF/dev</literal>"
msgstr "Le déploiement à chaud des composants ne sera pas visible pour toute classes deployé à l'extérieur de  <literal>WEB-INF/dev</literal>"

#. Tag: para
#: Groovy.xml:138
#, no-c-format
msgid "Seam debug mode must be enabled"
msgstr "Le mode debug de Seam doit être activé"

#. Tag: para
#: Groovy.xml:148
#, no-c-format
msgid "Seam-gen transparently supports Groovy files deployment and compilation. This includes the native <filename>.groovy</filename> file deployment in development mode (compilation-less). If you create a seam-gen project of type WAR, Java and Groovy classes in <filename>src/hot</filename> will automatically be candidate for the incremental hot deployment. If you are in production mode, the Groovy files will simply be compiled before deployment."
msgstr "Seam-gen supporte de manière transparent le déploiement et la compilation de fichiers Groovy. Cela inclus le déploiement de fichier  <filename>.groovy</filename> natif dans le mode développement (sans compilation). Si vous créez un projet seam-gen de type WAR, les classes Java et   Groovy dans <filename>src/hot</filename> vont être automatiquement candidate pour le déploiement à chaud incrémental. Si vous êtes en mode de production, les fichiers Groovy vont être simplement compilés avant le déploiement."

#. Tag: para
#: Groovy.xml:154
#, no-c-format
msgid "You will find a live example of the Booking demo written completely in Groovy and supporting incremental hot deployment in <filename>examples/groovybooking</filename>."
msgstr "Vous trouverez un exemple en ligne de la démonstration de la Réservation d'Hotel écrit totalement en Groovy et supportant le déploiement incrémental à chaud dans <filename>examples/groovybooking</filename>."

