[seam-commits] Seam SVN: r10388 - in trunk/doc/Seam_Reference_Guide: bn-IN and 23 other directories.

Sun Apr 12 01:22:12 EDT 2009

Author: dan.j.allen
Date: 2009-04-12 01:22:10 -0400 (Sun, 12 Apr 2009)
New Revision: 10388

Added:
   trunk/doc/Seam_Reference_Guide/as-IN/Guice.po
   trunk/doc/Seam_Reference_Guide/bn-IN/Guice.po
   trunk/doc/Seam_Reference_Guide/de-DE/Guice.po
   trunk/doc/Seam_Reference_Guide/es-ES/Guice.po
   trunk/doc/Seam_Reference_Guide/es-MX/Guice.po
   trunk/doc/Seam_Reference_Guide/fr-FR/Guice.po
   trunk/doc/Seam_Reference_Guide/gu-IN/Guice.po
   trunk/doc/Seam_Reference_Guide/hi-IN/Guice.po
   trunk/doc/Seam_Reference_Guide/it-IT/Guice.po
   trunk/doc/Seam_Reference_Guide/ja-JP/Guice.po
   trunk/doc/Seam_Reference_Guide/kn-IN/Guice.po
   trunk/doc/Seam_Reference_Guide/ko-KR/Guice.po
   trunk/doc/Seam_Reference_Guide/ml-IN/Guice.po
   trunk/doc/Seam_Reference_Guide/mr-IN/Guice.po
   trunk/doc/Seam_Reference_Guide/or-IN/Guice.po
   trunk/doc/Seam_Reference_Guide/pa-IN/Guice.po
   trunk/doc/Seam_Reference_Guide/pot/Guice.pot
   trunk/doc/Seam_Reference_Guide/pt-BR/Guice.po
   trunk/doc/Seam_Reference_Guide/ru-RU/Guice.po
   trunk/doc/Seam_Reference_Guide/si-LK/Guice.po
   trunk/doc/Seam_Reference_Guide/sl-SL/Guice.po
   trunk/doc/Seam_Reference_Guide/ta-IN/Guice.po
   trunk/doc/Seam_Reference_Guide/te-IN/Guice.po
   trunk/doc/Seam_Reference_Guide/zh-CN/Guice.po
   trunk/doc/Seam_Reference_Guide/zh-TW/Guice.po
Log:
commit PO for Guice chapter


Added: trunk/doc/Seam_Reference_Guide/as-IN/Guice.po
===================================================================

--- trunk/doc/Seam_Reference_Guide/as-IN/Guice.po	                        (rev 0)
+++ trunk/doc/Seam_Reference_Guide/as-IN/Guice.po	2009-04-12 05:22:10 UTC (rev 10388)
@@ -0,0 +1,96 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"POT-Creation-Date: 2009-04-12 01:20-0400\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Language-Team: LANGUAGE <LL at li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:6(title) 
+msgid "Guice integration"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:8(para) 
+msgid "Google Guice is a library that provides lightweight dependency injection through type-safe resolution. The Guice integration (part of the Seam IoC module) allows use of Guice injection for all Seam components annotated with the <literal>@Guice</literal> annotation. In addition to the regular bijection that Seam performs (which becomes optional), Seam also delegates to known Guice injectors to satisify the dependencies of the component. Guice may be useful to tie non-Seam parts of large or legacy applications together with Seam."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:17(note) 
+msgid "The Guice integration is bundled in the jboss-seam-ioc library. This dependency is required for all integration techniques covered in this chapter. You will also need the Guice JAR file on the classpath."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:24(title) 
+msgid "Creating a hybrid Seam-Guice component"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:26(para) 
+msgid "The goal is to create a hybrid Seam-Guice component. The rule for how to do this is very simple. If you want to use Guice injection in your Seam component, annotate it with the <literal>@Guice</literal> annotation (after importing the type <literal>org.jboss.seam.ioc.guice.Guice</literal>)."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:33(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuicyComponent\")\n at Guice public class MyGuicyComponent\n{\n   @Inject MyObject myObject;\n   @Inject @Special MyObject mySpecialObject;\n   ...\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:41(para) 
+msgid "This Guice injection will happen on every method call, just like with bijection. Guice injects based on type and binding. To satisify the dependencies in the previous example, you might have bound the following implementations in a Guice module, where <literal>@Special</literal> is an annotation you define in your application."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:48(programlisting) 
+#, no-wrap
+msgid "public class MyGuicyModule implements Module\n{\n   public void configure(Binder binder)\n   {\n      binder.bind(MyObject.class)\n         .toInstance(new MyObject(\"regular\"));\n\n      binder.bind(MyObject.class).annotatedWith(Special.class)\n         .toInstance(new MyObject(\"special\"));\n   }\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:60(para) 
+msgid "Great, but which Guice injector will be used to inject the dependencies? Well, you need to perform some setup first."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:69(title) 
+msgid "Configuring an injector"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:71(para) 
+msgid "You tell Seam which Guice injector to use by hooking it into the injection property of the Guice initization component in the Seam component descriptor (components.xml):"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:89(para) 
+msgid "<literal>myGuiceInjector</literal> must resolve to a Seam component that implements the Guice <literal>Injector</literal> interface."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:94(para) 
+msgid "Having to create an injector is boiler-plate code, though. What you really want to be able to do is simply hook up Seam to your Guice modules. Fortunately, there is a built-in Seam component that implements the <literal>Injector</literal> interface to do exactly that. You can configure it in the Seam component descriptor with this additional stanza."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:108(para) 
+msgid "Of course you can also use an injector that is already used in other, possibly non-Seam part of you application. That's one of the main motivations for creating this integration. Since the injector is defined with EL expression, you can obtain it in whatever way you like. For instance, you may use the Seam factory component pattern to provide injector."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:115(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuiceInjectorFactory\")\npublic InjectorFactory\n{\n   @Factory(name = \"myGuiceInjector\", scope = APPLICATION, create = true)\n   public Injector getInjector()\n   {\n      // Your code that returns injector    \n   }\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:128(title) 
+msgid "Using multiple injectors"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:130(para) 
+msgid "By default, an injector configured in the Seam component descriptor is used. If you really need to use multiple injectors (AFAIK, you should use multiple modules instead), you can specify different injector for every Seam component in the <literal>@Guice</literal> annotation."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:137(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuicyComponent\")\n at Guice(\"myGuiceInjector\")\npublic class MyGuicyComponent\n{\n   @Inject MyObject myObject;\n   ...\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:147(para) 
+msgid "That's all there is to it! Check out the guice example in the Seam distribution to see the Seam Guice integration in action!"
+msgstr ""
+
+#. Put one translator per line, in the form of NAME <EMAIL>, YEAR1, YEAR2.
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:0(None) 
+msgid "translator-credits"
+msgstr ""
+

Added: trunk/doc/Seam_Reference_Guide/bn-IN/Guice.po
===================================================================
--- trunk/doc/Seam_Reference_Guide/bn-IN/Guice.po	                        (rev 0)
+++ trunk/doc/Seam_Reference_Guide/bn-IN/Guice.po	2009-04-12 05:22:10 UTC (rev 10388)
@@ -0,0 +1,96 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"POT-Creation-Date: 2009-04-12 01:20-0400\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Language-Team: LANGUAGE <LL at li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:6(title) 
+msgid "Guice integration"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:8(para) 
+msgid "Google Guice is a library that provides lightweight dependency injection through type-safe resolution. The Guice integration (part of the Seam IoC module) allows use of Guice injection for all Seam components annotated with the <literal>@Guice</literal> annotation. In addition to the regular bijection that Seam performs (which becomes optional), Seam also delegates to known Guice injectors to satisify the dependencies of the component. Guice may be useful to tie non-Seam parts of large or legacy applications together with Seam."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:17(note) 
+msgid "The Guice integration is bundled in the jboss-seam-ioc library. This dependency is required for all integration techniques covered in this chapter. You will also need the Guice JAR file on the classpath."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:24(title) 
+msgid "Creating a hybrid Seam-Guice component"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:26(para) 
+msgid "The goal is to create a hybrid Seam-Guice component. The rule for how to do this is very simple. If you want to use Guice injection in your Seam component, annotate it with the <literal>@Guice</literal> annotation (after importing the type <literal>org.jboss.seam.ioc.guice.Guice</literal>)."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:33(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuicyComponent\")\n at Guice public class MyGuicyComponent\n{\n   @Inject MyObject myObject;\n   @Inject @Special MyObject mySpecialObject;\n   ...\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:41(para) 
+msgid "This Guice injection will happen on every method call, just like with bijection. Guice injects based on type and binding. To satisify the dependencies in the previous example, you might have bound the following implementations in a Guice module, where <literal>@Special</literal> is an annotation you define in your application."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:48(programlisting) 
+#, no-wrap
+msgid "public class MyGuicyModule implements Module\n{\n   public void configure(Binder binder)\n   {\n      binder.bind(MyObject.class)\n         .toInstance(new MyObject(\"regular\"));\n\n      binder.bind(MyObject.class).annotatedWith(Special.class)\n         .toInstance(new MyObject(\"special\"));\n   }\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:60(para) 
+msgid "Great, but which Guice injector will be used to inject the dependencies? Well, you need to perform some setup first."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:69(title) 
+msgid "Configuring an injector"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:71(para) 
+msgid "You tell Seam which Guice injector to use by hooking it into the injection property of the Guice initization component in the Seam component descriptor (components.xml):"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:89(para) 
+msgid "<literal>myGuiceInjector</literal> must resolve to a Seam component that implements the Guice <literal>Injector</literal> interface."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:94(para) 
+msgid "Having to create an injector is boiler-plate code, though. What you really want to be able to do is simply hook up Seam to your Guice modules. Fortunately, there is a built-in Seam component that implements the <literal>Injector</literal> interface to do exactly that. You can configure it in the Seam component descriptor with this additional stanza."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:108(para) 
+msgid "Of course you can also use an injector that is already used in other, possibly non-Seam part of you application. That's one of the main motivations for creating this integration. Since the injector is defined with EL expression, you can obtain it in whatever way you like. For instance, you may use the Seam factory component pattern to provide injector."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:115(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuiceInjectorFactory\")\npublic InjectorFactory\n{\n   @Factory(name = \"myGuiceInjector\", scope = APPLICATION, create = true)\n   public Injector getInjector()\n   {\n      // Your code that returns injector    \n   }\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:128(title) 
+msgid "Using multiple injectors"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:130(para) 
+msgid "By default, an injector configured in the Seam component descriptor is used. If you really need to use multiple injectors (AFAIK, you should use multiple modules instead), you can specify different injector for every Seam component in the <literal>@Guice</literal> annotation."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:137(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuicyComponent\")\n at Guice(\"myGuiceInjector\")\npublic class MyGuicyComponent\n{\n   @Inject MyObject myObject;\n   ...\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:147(para) 
+msgid "That's all there is to it! Check out the guice example in the Seam distribution to see the Seam Guice integration in action!"
+msgstr ""
+
+#. Put one translator per line, in the form of NAME <EMAIL>, YEAR1, YEAR2.
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:0(None) 
+msgid "translator-credits"
+msgstr ""
+

Added: trunk/doc/Seam_Reference_Guide/de-DE/Guice.po
===================================================================
--- trunk/doc/Seam_Reference_Guide/de-DE/Guice.po	                        (rev 0)
+++ trunk/doc/Seam_Reference_Guide/de-DE/Guice.po	2009-04-12 05:22:10 UTC (rev 10388)
@@ -0,0 +1,96 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"POT-Creation-Date: 2009-04-12 01:20-0400\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Language-Team: LANGUAGE <LL at li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:6(title) 
+msgid "Guice integration"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:8(para) 
+msgid "Google Guice is a library that provides lightweight dependency injection through type-safe resolution. The Guice integration (part of the Seam IoC module) allows use of Guice injection for all Seam components annotated with the <literal>@Guice</literal> annotation. In addition to the regular bijection that Seam performs (which becomes optional), Seam also delegates to known Guice injectors to satisify the dependencies of the component. Guice may be useful to tie non-Seam parts of large or legacy applications together with Seam."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:17(note) 
+msgid "The Guice integration is bundled in the jboss-seam-ioc library. This dependency is required for all integration techniques covered in this chapter. You will also need the Guice JAR file on the classpath."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:24(title) 
+msgid "Creating a hybrid Seam-Guice component"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:26(para) 
+msgid "The goal is to create a hybrid Seam-Guice component. The rule for how to do this is very simple. If you want to use Guice injection in your Seam component, annotate it with the <literal>@Guice</literal> annotation (after importing the type <literal>org.jboss.seam.ioc.guice.Guice</literal>)."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:33(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuicyComponent\")\n at Guice public class MyGuicyComponent\n{\n   @Inject MyObject myObject;\n   @Inject @Special MyObject mySpecialObject;\n   ...\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:41(para) 
+msgid "This Guice injection will happen on every method call, just like with bijection. Guice injects based on type and binding. To satisify the dependencies in the previous example, you might have bound the following implementations in a Guice module, where <literal>@Special</literal> is an annotation you define in your application."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:48(programlisting) 
+#, no-wrap
+msgid "public class MyGuicyModule implements Module\n{\n   public void configure(Binder binder)\n   {\n      binder.bind(MyObject.class)\n         .toInstance(new MyObject(\"regular\"));\n\n      binder.bind(MyObject.class).annotatedWith(Special.class)\n         .toInstance(new MyObject(\"special\"));\n   }\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:60(para) 
+msgid "Great, but which Guice injector will be used to inject the dependencies? Well, you need to perform some setup first."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:69(title) 
+msgid "Configuring an injector"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:71(para) 
+msgid "You tell Seam which Guice injector to use by hooking it into the injection property of the Guice initization component in the Seam component descriptor (components.xml):"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:89(para) 
+msgid "<literal>myGuiceInjector</literal> must resolve to a Seam component that implements the Guice <literal>Injector</literal> interface."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:94(para) 
+msgid "Having to create an injector is boiler-plate code, though. What you really want to be able to do is simply hook up Seam to your Guice modules. Fortunately, there is a built-in Seam component that implements the <literal>Injector</literal> interface to do exactly that. You can configure it in the Seam component descriptor with this additional stanza."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:108(para) 
+msgid "Of course you can also use an injector that is already used in other, possibly non-Seam part of you application. That's one of the main motivations for creating this integration. Since the injector is defined with EL expression, you can obtain it in whatever way you like. For instance, you may use the Seam factory component pattern to provide injector."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:115(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuiceInjectorFactory\")\npublic InjectorFactory\n{\n   @Factory(name = \"myGuiceInjector\", scope = APPLICATION, create = true)\n   public Injector getInjector()\n   {\n      // Your code that returns injector    \n   }\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:128(title) 
+msgid "Using multiple injectors"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:130(para) 
+msgid "By default, an injector configured in the Seam component descriptor is used. If you really need to use multiple injectors (AFAIK, you should use multiple modules instead), you can specify different injector for every Seam component in the <literal>@Guice</literal> annotation."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:137(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuicyComponent\")\n at Guice(\"myGuiceInjector\")\npublic class MyGuicyComponent\n{\n   @Inject MyObject myObject;\n   ...\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:147(para) 
+msgid "That's all there is to it! Check out the guice example in the Seam distribution to see the Seam Guice integration in action!"
+msgstr ""
+
+#. Put one translator per line, in the form of NAME <EMAIL>, YEAR1, YEAR2.
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:0(None) 
+msgid "translator-credits"
+msgstr ""
+

Added: trunk/doc/Seam_Reference_Guide/es-ES/Guice.po
===================================================================
--- trunk/doc/Seam_Reference_Guide/es-ES/Guice.po	                        (rev 0)
+++ trunk/doc/Seam_Reference_Guide/es-ES/Guice.po	2009-04-12 05:22:10 UTC (rev 10388)
@@ -0,0 +1,96 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"POT-Creation-Date: 2009-04-12 01:20-0400\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Language-Team: LANGUAGE <LL at li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:6(title) 
+msgid "Guice integration"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:8(para) 
+msgid "Google Guice is a library that provides lightweight dependency injection through type-safe resolution. The Guice integration (part of the Seam IoC module) allows use of Guice injection for all Seam components annotated with the <literal>@Guice</literal> annotation. In addition to the regular bijection that Seam performs (which becomes optional), Seam also delegates to known Guice injectors to satisify the dependencies of the component. Guice may be useful to tie non-Seam parts of large or legacy applications together with Seam."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:17(note) 
+msgid "The Guice integration is bundled in the jboss-seam-ioc library. This dependency is required for all integration techniques covered in this chapter. You will also need the Guice JAR file on the classpath."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:24(title) 
+msgid "Creating a hybrid Seam-Guice component"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:26(para) 
+msgid "The goal is to create a hybrid Seam-Guice component. The rule for how to do this is very simple. If you want to use Guice injection in your Seam component, annotate it with the <literal>@Guice</literal> annotation (after importing the type <literal>org.jboss.seam.ioc.guice.Guice</literal>)."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:33(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuicyComponent\")\n at Guice public class MyGuicyComponent\n{\n   @Inject MyObject myObject;\n   @Inject @Special MyObject mySpecialObject;\n   ...\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:41(para) 
+msgid "This Guice injection will happen on every method call, just like with bijection. Guice injects based on type and binding. To satisify the dependencies in the previous example, you might have bound the following implementations in a Guice module, where <literal>@Special</literal> is an annotation you define in your application."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:48(programlisting) 
+#, no-wrap
+msgid "public class MyGuicyModule implements Module\n{\n   public void configure(Binder binder)\n   {\n      binder.bind(MyObject.class)\n         .toInstance(new MyObject(\"regular\"));\n\n      binder.bind(MyObject.class).annotatedWith(Special.class)\n         .toInstance(new MyObject(\"special\"));\n   }\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:60(para) 
+msgid "Great, but which Guice injector will be used to inject the dependencies? Well, you need to perform some setup first."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:69(title) 
+msgid "Configuring an injector"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:71(para) 
+msgid "You tell Seam which Guice injector to use by hooking it into the injection property of the Guice initization component in the Seam component descriptor (components.xml):"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:89(para) 
+msgid "<literal>myGuiceInjector</literal> must resolve to a Seam component that implements the Guice <literal>Injector</literal> interface."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:94(para) 
+msgid "Having to create an injector is boiler-plate code, though. What you really want to be able to do is simply hook up Seam to your Guice modules. Fortunately, there is a built-in Seam component that implements the <literal>Injector</literal> interface to do exactly that. You can configure it in the Seam component descriptor with this additional stanza."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:108(para) 
+msgid "Of course you can also use an injector that is already used in other, possibly non-Seam part of you application. That's one of the main motivations for creating this integration. Since the injector is defined with EL expression, you can obtain it in whatever way you like. For instance, you may use the Seam factory component pattern to provide injector."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:115(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuiceInjectorFactory\")\npublic InjectorFactory\n{\n   @Factory(name = \"myGuiceInjector\", scope = APPLICATION, create = true)\n   public Injector getInjector()\n   {\n      // Your code that returns injector    \n   }\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:128(title) 
+msgid "Using multiple injectors"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:130(para) 
+msgid "By default, an injector configured in the Seam component descriptor is used. If you really need to use multiple injectors (AFAIK, you should use multiple modules instead), you can specify different injector for every Seam component in the <literal>@Guice</literal> annotation."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:137(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuicyComponent\")\n at Guice(\"myGuiceInjector\")\npublic class MyGuicyComponent\n{\n   @Inject MyObject myObject;\n   ...\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:147(para) 
+msgid "That's all there is to it! Check out the guice example in the Seam distribution to see the Seam Guice integration in action!"
+msgstr ""
+
+#. Put one translator per line, in the form of NAME <EMAIL>, YEAR1, YEAR2.
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:0(None) 
+msgid "translator-credits"
+msgstr ""
+

Added: trunk/doc/Seam_Reference_Guide/es-MX/Guice.po
===================================================================
--- trunk/doc/Seam_Reference_Guide/es-MX/Guice.po	                        (rev 0)
+++ trunk/doc/Seam_Reference_Guide/es-MX/Guice.po	2009-04-12 05:22:10 UTC (rev 10388)
@@ -0,0 +1,96 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"POT-Creation-Date: 2009-04-12 01:20-0400\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Language-Team: LANGUAGE <LL at li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:6(title) 
+msgid "Guice integration"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:8(para) 
+msgid "Google Guice is a library that provides lightweight dependency injection through type-safe resolution. The Guice integration (part of the Seam IoC module) allows use of Guice injection for all Seam components annotated with the <literal>@Guice</literal> annotation. In addition to the regular bijection that Seam performs (which becomes optional), Seam also delegates to known Guice injectors to satisify the dependencies of the component. Guice may be useful to tie non-Seam parts of large or legacy applications together with Seam."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:17(note) 
+msgid "The Guice integration is bundled in the jboss-seam-ioc library. This dependency is required for all integration techniques covered in this chapter. You will also need the Guice JAR file on the classpath."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:24(title) 
+msgid "Creating a hybrid Seam-Guice component"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:26(para) 
+msgid "The goal is to create a hybrid Seam-Guice component. The rule for how to do this is very simple. If you want to use Guice injection in your Seam component, annotate it with the <literal>@Guice</literal> annotation (after importing the type <literal>org.jboss.seam.ioc.guice.Guice</literal>)."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:33(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuicyComponent\")\n at Guice public class MyGuicyComponent\n{\n   @Inject MyObject myObject;\n   @Inject @Special MyObject mySpecialObject;\n   ...\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:41(para) 
+msgid "This Guice injection will happen on every method call, just like with bijection. Guice injects based on type and binding. To satisify the dependencies in the previous example, you might have bound the following implementations in a Guice module, where <literal>@Special</literal> is an annotation you define in your application."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:48(programlisting) 
+#, no-wrap
+msgid "public class MyGuicyModule implements Module\n{\n   public void configure(Binder binder)\n   {\n      binder.bind(MyObject.class)\n         .toInstance(new MyObject(\"regular\"));\n\n      binder.bind(MyObject.class).annotatedWith(Special.class)\n         .toInstance(new MyObject(\"special\"));\n   }\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:60(para) 
+msgid "Great, but which Guice injector will be used to inject the dependencies? Well, you need to perform some setup first."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:69(title) 
+msgid "Configuring an injector"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:71(para) 
+msgid "You tell Seam which Guice injector to use by hooking it into the injection property of the Guice initization component in the Seam component descriptor (components.xml):"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:89(para) 
+msgid "<literal>myGuiceInjector</literal> must resolve to a Seam component that implements the Guice <literal>Injector</literal> interface."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:94(para) 
+msgid "Having to create an injector is boiler-plate code, though. What you really want to be able to do is simply hook up Seam to your Guice modules. Fortunately, there is a built-in Seam component that implements the <literal>Injector</literal> interface to do exactly that. You can configure it in the Seam component descriptor with this additional stanza."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:108(para) 
+msgid "Of course you can also use an injector that is already used in other, possibly non-Seam part of you application. That's one of the main motivations for creating this integration. Since the injector is defined with EL expression, you can obtain it in whatever way you like. For instance, you may use the Seam factory component pattern to provide injector."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:115(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuiceInjectorFactory\")\npublic InjectorFactory\n{\n   @Factory(name = \"myGuiceInjector\", scope = APPLICATION, create = true)\n   public Injector getInjector()\n   {\n      // Your code that returns injector    \n   }\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:128(title) 
+msgid "Using multiple injectors"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:130(para) 
+msgid "By default, an injector configured in the Seam component descriptor is used. If you really need to use multiple injectors (AFAIK, you should use multiple modules instead), you can specify different injector for every Seam component in the <literal>@Guice</literal> annotation."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:137(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuicyComponent\")\n at Guice(\"myGuiceInjector\")\npublic class MyGuicyComponent\n{\n   @Inject MyObject myObject;\n   ...\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:147(para) 
+msgid "That's all there is to it! Check out the guice example in the Seam distribution to see the Seam Guice integration in action!"
+msgstr ""
+
+#. Put one translator per line, in the form of NAME <EMAIL>, YEAR1, YEAR2.
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:0(None) 
+msgid "translator-credits"
+msgstr ""
+

Added: trunk/doc/Seam_Reference_Guide/fr-FR/Guice.po
===================================================================
--- trunk/doc/Seam_Reference_Guide/fr-FR/Guice.po	                        (rev 0)
+++ trunk/doc/Seam_Reference_Guide/fr-FR/Guice.po	2009-04-12 05:22:10 UTC (rev 10388)
@@ -0,0 +1,96 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"POT-Creation-Date: 2009-04-12 01:20-0400\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Language-Team: LANGUAGE <LL at li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:6(title) 
+msgid "Guice integration"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:8(para) 
+msgid "Google Guice is a library that provides lightweight dependency injection through type-safe resolution. The Guice integration (part of the Seam IoC module) allows use of Guice injection for all Seam components annotated with the <literal>@Guice</literal> annotation. In addition to the regular bijection that Seam performs (which becomes optional), Seam also delegates to known Guice injectors to satisify the dependencies of the component. Guice may be useful to tie non-Seam parts of large or legacy applications together with Seam."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:17(note) 
+msgid "The Guice integration is bundled in the jboss-seam-ioc library. This dependency is required for all integration techniques covered in this chapter. You will also need the Guice JAR file on the classpath."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:24(title) 
+msgid "Creating a hybrid Seam-Guice component"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:26(para) 
+msgid "The goal is to create a hybrid Seam-Guice component. The rule for how to do this is very simple. If you want to use Guice injection in your Seam component, annotate it with the <literal>@Guice</literal> annotation (after importing the type <literal>org.jboss.seam.ioc.guice.Guice</literal>)."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:33(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuicyComponent\")\n at Guice public class MyGuicyComponent\n{\n   @Inject MyObject myObject;\n   @Inject @Special MyObject mySpecialObject;\n   ...\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:41(para) 
+msgid "This Guice injection will happen on every method call, just like with bijection. Guice injects based on type and binding. To satisify the dependencies in the previous example, you might have bound the following implementations in a Guice module, where <literal>@Special</literal> is an annotation you define in your application."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:48(programlisting) 
+#, no-wrap
+msgid "public class MyGuicyModule implements Module\n{\n   public void configure(Binder binder)\n   {\n      binder.bind(MyObject.class)\n         .toInstance(new MyObject(\"regular\"));\n\n      binder.bind(MyObject.class).annotatedWith(Special.class)\n         .toInstance(new MyObject(\"special\"));\n   }\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:60(para) 
+msgid "Great, but which Guice injector will be used to inject the dependencies? Well, you need to perform some setup first."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:69(title) 
+msgid "Configuring an injector"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:71(para) 
+msgid "You tell Seam which Guice injector to use by hooking it into the injection property of the Guice initization component in the Seam component descriptor (components.xml):"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:89(para) 
+msgid "<literal>myGuiceInjector</literal> must resolve to a Seam component that implements the Guice <literal>Injector</literal> interface."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:94(para) 
+msgid "Having to create an injector is boiler-plate code, though. What you really want to be able to do is simply hook up Seam to your Guice modules. Fortunately, there is a built-in Seam component that implements the <literal>Injector</literal> interface to do exactly that. You can configure it in the Seam component descriptor with this additional stanza."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:108(para) 
+msgid "Of course you can also use an injector that is already used in other, possibly non-Seam part of you application. That's one of the main motivations for creating this integration. Since the injector is defined with EL expression, you can obtain it in whatever way you like. For instance, you may use the Seam factory component pattern to provide injector."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:115(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuiceInjectorFactory\")\npublic InjectorFactory\n{\n   @Factory(name = \"myGuiceInjector\", scope = APPLICATION, create = true)\n   public Injector getInjector()\n   {\n      // Your code that returns injector    \n   }\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:128(title) 
+msgid "Using multiple injectors"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:130(para) 
+msgid "By default, an injector configured in the Seam component descriptor is used. If you really need to use multiple injectors (AFAIK, you should use multiple modules instead), you can specify different injector for every Seam component in the <literal>@Guice</literal> annotation."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:137(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuicyComponent\")\n at Guice(\"myGuiceInjector\")\npublic class MyGuicyComponent\n{\n   @Inject MyObject myObject;\n   ...\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:147(para) 
+msgid "That's all there is to it! Check out the guice example in the Seam distribution to see the Seam Guice integration in action!"
+msgstr ""
+
+#. Put one translator per line, in the form of NAME <EMAIL>, YEAR1, YEAR2.
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:0(None) 
+msgid "translator-credits"
+msgstr ""
+

Added: trunk/doc/Seam_Reference_Guide/gu-IN/Guice.po
===================================================================
--- trunk/doc/Seam_Reference_Guide/gu-IN/Guice.po	                        (rev 0)
+++ trunk/doc/Seam_Reference_Guide/gu-IN/Guice.po	2009-04-12 05:22:10 UTC (rev 10388)
@@ -0,0 +1,96 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"POT-Creation-Date: 2009-04-12 01:20-0400\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Language-Team: LANGUAGE <LL at li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:6(title) 
+msgid "Guice integration"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:8(para) 
+msgid "Google Guice is a library that provides lightweight dependency injection through type-safe resolution. The Guice integration (part of the Seam IoC module) allows use of Guice injection for all Seam components annotated with the <literal>@Guice</literal> annotation. In addition to the regular bijection that Seam performs (which becomes optional), Seam also delegates to known Guice injectors to satisify the dependencies of the component. Guice may be useful to tie non-Seam parts of large or legacy applications together with Seam."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:17(note) 
+msgid "The Guice integration is bundled in the jboss-seam-ioc library. This dependency is required for all integration techniques covered in this chapter. You will also need the Guice JAR file on the classpath."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:24(title) 
+msgid "Creating a hybrid Seam-Guice component"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:26(para) 
+msgid "The goal is to create a hybrid Seam-Guice component. The rule for how to do this is very simple. If you want to use Guice injection in your Seam component, annotate it with the <literal>@Guice</literal> annotation (after importing the type <literal>org.jboss.seam.ioc.guice.Guice</literal>)."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:33(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuicyComponent\")\n at Guice public class MyGuicyComponent\n{\n   @Inject MyObject myObject;\n   @Inject @Special MyObject mySpecialObject;\n   ...\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:41(para) 
+msgid "This Guice injection will happen on every method call, just like with bijection. Guice injects based on type and binding. To satisify the dependencies in the previous example, you might have bound the following implementations in a Guice module, where <literal>@Special</literal> is an annotation you define in your application."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:48(programlisting) 
+#, no-wrap
+msgid "public class MyGuicyModule implements Module\n{\n   public void configure(Binder binder)\n   {\n      binder.bind(MyObject.class)\n         .toInstance(new MyObject(\"regular\"));\n\n      binder.bind(MyObject.class).annotatedWith(Special.class)\n         .toInstance(new MyObject(\"special\"));\n   }\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:60(para) 
+msgid "Great, but which Guice injector will be used to inject the dependencies? Well, you need to perform some setup first."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:69(title) 
+msgid "Configuring an injector"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:71(para) 
+msgid "You tell Seam which Guice injector to use by hooking it into the injection property of the Guice initization component in the Seam component descriptor (components.xml):"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:89(para) 
+msgid "<literal>myGuiceInjector</literal> must resolve to a Seam component that implements the Guice <literal>Injector</literal> interface."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:94(para) 
+msgid "Having to create an injector is boiler-plate code, though. What you really want to be able to do is simply hook up Seam to your Guice modules. Fortunately, there is a built-in Seam component that implements the <literal>Injector</literal> interface to do exactly that. You can configure it in the Seam component descriptor with this additional stanza."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:108(para) 
+msgid "Of course you can also use an injector that is already used in other, possibly non-Seam part of you application. That's one of the main motivations for creating this integration. Since the injector is defined with EL expression, you can obtain it in whatever way you like. For instance, you may use the Seam factory component pattern to provide injector."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:115(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuiceInjectorFactory\")\npublic InjectorFactory\n{\n   @Factory(name = \"myGuiceInjector\", scope = APPLICATION, create = true)\n   public Injector getInjector()\n   {\n      // Your code that returns injector    \n   }\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:128(title) 
+msgid "Using multiple injectors"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:130(para) 
+msgid "By default, an injector configured in the Seam component descriptor is used. If you really need to use multiple injectors (AFAIK, you should use multiple modules instead), you can specify different injector for every Seam component in the <literal>@Guice</literal> annotation."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:137(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuicyComponent\")\n at Guice(\"myGuiceInjector\")\npublic class MyGuicyComponent\n{\n   @Inject MyObject myObject;\n   ...\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:147(para) 
+msgid "That's all there is to it! Check out the guice example in the Seam distribution to see the Seam Guice integration in action!"
+msgstr ""
+
+#. Put one translator per line, in the form of NAME <EMAIL>, YEAR1, YEAR2.
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:0(None) 
+msgid "translator-credits"
+msgstr ""
+

Added: trunk/doc/Seam_Reference_Guide/hi-IN/Guice.po
===================================================================
--- trunk/doc/Seam_Reference_Guide/hi-IN/Guice.po	                        (rev 0)
+++ trunk/doc/Seam_Reference_Guide/hi-IN/Guice.po	2009-04-12 05:22:10 UTC (rev 10388)
@@ -0,0 +1,96 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"POT-Creation-Date: 2009-04-12 01:20-0400\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Language-Team: LANGUAGE <LL at li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:6(title) 
+msgid "Guice integration"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:8(para) 
+msgid "Google Guice is a library that provides lightweight dependency injection through type-safe resolution. The Guice integration (part of the Seam IoC module) allows use of Guice injection for all Seam components annotated with the <literal>@Guice</literal> annotation. In addition to the regular bijection that Seam performs (which becomes optional), Seam also delegates to known Guice injectors to satisify the dependencies of the component. Guice may be useful to tie non-Seam parts of large or legacy applications together with Seam."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:17(note) 
+msgid "The Guice integration is bundled in the jboss-seam-ioc library. This dependency is required for all integration techniques covered in this chapter. You will also need the Guice JAR file on the classpath."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:24(title) 
+msgid "Creating a hybrid Seam-Guice component"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:26(para) 
+msgid "The goal is to create a hybrid Seam-Guice component. The rule for how to do this is very simple. If you want to use Guice injection in your Seam component, annotate it with the <literal>@Guice</literal> annotation (after importing the type <literal>org.jboss.seam.ioc.guice.Guice</literal>)."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:33(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuicyComponent\")\n at Guice public class MyGuicyComponent\n{\n   @Inject MyObject myObject;\n   @Inject @Special MyObject mySpecialObject;\n   ...\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:41(para) 
+msgid "This Guice injection will happen on every method call, just like with bijection. Guice injects based on type and binding. To satisify the dependencies in the previous example, you might have bound the following implementations in a Guice module, where <literal>@Special</literal> is an annotation you define in your application."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:48(programlisting) 
+#, no-wrap
+msgid "public class MyGuicyModule implements Module\n{\n   public void configure(Binder binder)\n   {\n      binder.bind(MyObject.class)\n         .toInstance(new MyObject(\"regular\"));\n\n      binder.bind(MyObject.class).annotatedWith(Special.class)\n         .toInstance(new MyObject(\"special\"));\n   }\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:60(para) 
+msgid "Great, but which Guice injector will be used to inject the dependencies? Well, you need to perform some setup first."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:69(title) 
+msgid "Configuring an injector"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:71(para) 
+msgid "You tell Seam which Guice injector to use by hooking it into the injection property of the Guice initization component in the Seam component descriptor (components.xml):"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:89(para) 
+msgid "<literal>myGuiceInjector</literal> must resolve to a Seam component that implements the Guice <literal>Injector</literal> interface."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:94(para) 
+msgid "Having to create an injector is boiler-plate code, though. What you really want to be able to do is simply hook up Seam to your Guice modules. Fortunately, there is a built-in Seam component that implements the <literal>Injector</literal> interface to do exactly that. You can configure it in the Seam component descriptor with this additional stanza."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:108(para) 
+msgid "Of course you can also use an injector that is already used in other, possibly non-Seam part of you application. That's one of the main motivations for creating this integration. Since the injector is defined with EL expression, you can obtain it in whatever way you like. For instance, you may use the Seam factory component pattern to provide injector."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:115(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuiceInjectorFactory\")\npublic InjectorFactory\n{\n   @Factory(name = \"myGuiceInjector\", scope = APPLICATION, create = true)\n   public Injector getInjector()\n   {\n      // Your code that returns injector    \n   }\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:128(title) 
+msgid "Using multiple injectors"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:130(para) 
+msgid "By default, an injector configured in the Seam component descriptor is used. If you really need to use multiple injectors (AFAIK, you should use multiple modules instead), you can specify different injector for every Seam component in the <literal>@Guice</literal> annotation."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:137(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuicyComponent\")\n at Guice(\"myGuiceInjector\")\npublic class MyGuicyComponent\n{\n   @Inject MyObject myObject;\n   ...\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:147(para) 
+msgid "That's all there is to it! Check out the guice example in the Seam distribution to see the Seam Guice integration in action!"
+msgstr ""
+
+#. Put one translator per line, in the form of NAME <EMAIL>, YEAR1, YEAR2.
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:0(None) 
+msgid "translator-credits"
+msgstr ""
+

Added: trunk/doc/Seam_Reference_Guide/it-IT/Guice.po
===================================================================
--- trunk/doc/Seam_Reference_Guide/it-IT/Guice.po	                        (rev 0)
+++ trunk/doc/Seam_Reference_Guide/it-IT/Guice.po	2009-04-12 05:22:10 UTC (rev 10388)
@@ -0,0 +1,96 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"POT-Creation-Date: 2009-04-12 01:20-0400\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Language-Team: LANGUAGE <LL at li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:6(title) 
+msgid "Guice integration"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:8(para) 
+msgid "Google Guice is a library that provides lightweight dependency injection through type-safe resolution. The Guice integration (part of the Seam IoC module) allows use of Guice injection for all Seam components annotated with the <literal>@Guice</literal> annotation. In addition to the regular bijection that Seam performs (which becomes optional), Seam also delegates to known Guice injectors to satisify the dependencies of the component. Guice may be useful to tie non-Seam parts of large or legacy applications together with Seam."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:17(note) 
+msgid "The Guice integration is bundled in the jboss-seam-ioc library. This dependency is required for all integration techniques covered in this chapter. You will also need the Guice JAR file on the classpath."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:24(title) 
+msgid "Creating a hybrid Seam-Guice component"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:26(para) 
+msgid "The goal is to create a hybrid Seam-Guice component. The rule for how to do this is very simple. If you want to use Guice injection in your Seam component, annotate it with the <literal>@Guice</literal> annotation (after importing the type <literal>org.jboss.seam.ioc.guice.Guice</literal>)."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:33(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuicyComponent\")\n at Guice public class MyGuicyComponent\n{\n   @Inject MyObject myObject;\n   @Inject @Special MyObject mySpecialObject;\n   ...\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:41(para) 
+msgid "This Guice injection will happen on every method call, just like with bijection. Guice injects based on type and binding. To satisify the dependencies in the previous example, you might have bound the following implementations in a Guice module, where <literal>@Special</literal> is an annotation you define in your application."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:48(programlisting) 
+#, no-wrap
+msgid "public class MyGuicyModule implements Module\n{\n   public void configure(Binder binder)\n   {\n      binder.bind(MyObject.class)\n         .toInstance(new MyObject(\"regular\"));\n\n      binder.bind(MyObject.class).annotatedWith(Special.class)\n         .toInstance(new MyObject(\"special\"));\n   }\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:60(para) 
+msgid "Great, but which Guice injector will be used to inject the dependencies? Well, you need to perform some setup first."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:69(title) 
+msgid "Configuring an injector"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:71(para) 
+msgid "You tell Seam which Guice injector to use by hooking it into the injection property of the Guice initization component in the Seam component descriptor (components.xml):"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:89(para) 
+msgid "<literal>myGuiceInjector</literal> must resolve to a Seam component that implements the Guice <literal>Injector</literal> interface."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:94(para) 
+msgid "Having to create an injector is boiler-plate code, though. What you really want to be able to do is simply hook up Seam to your Guice modules. Fortunately, there is a built-in Seam component that implements the <literal>Injector</literal> interface to do exactly that. You can configure it in the Seam component descriptor with this additional stanza."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:108(para) 
+msgid "Of course you can also use an injector that is already used in other, possibly non-Seam part of you application. That's one of the main motivations for creating this integration. Since the injector is defined with EL expression, you can obtain it in whatever way you like. For instance, you may use the Seam factory component pattern to provide injector."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:115(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuiceInjectorFactory\")\npublic InjectorFactory\n{\n   @Factory(name = \"myGuiceInjector\", scope = APPLICATION, create = true)\n   public Injector getInjector()\n   {\n      // Your code that returns injector    \n   }\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:128(title) 
+msgid "Using multiple injectors"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:130(para) 
+msgid "By default, an injector configured in the Seam component descriptor is used. If you really need to use multiple injectors (AFAIK, you should use multiple modules instead), you can specify different injector for every Seam component in the <literal>@Guice</literal> annotation."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:137(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuicyComponent\")\n at Guice(\"myGuiceInjector\")\npublic class MyGuicyComponent\n{\n   @Inject MyObject myObject;\n   ...\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:147(para) 
+msgid "That's all there is to it! Check out the guice example in the Seam distribution to see the Seam Guice integration in action!"
+msgstr ""
+
+#. Put one translator per line, in the form of NAME <EMAIL>, YEAR1, YEAR2.
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:0(None) 
+msgid "translator-credits"
+msgstr ""
+

Added: trunk/doc/Seam_Reference_Guide/ja-JP/Guice.po
===================================================================
--- trunk/doc/Seam_Reference_Guide/ja-JP/Guice.po	                        (rev 0)
+++ trunk/doc/Seam_Reference_Guide/ja-JP/Guice.po	2009-04-12 05:22:10 UTC (rev 10388)
@@ -0,0 +1,96 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"POT-Creation-Date: 2009-04-12 01:20-0400\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Language-Team: LANGUAGE <LL at li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:6(title) 
+msgid "Guice integration"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:8(para) 
+msgid "Google Guice is a library that provides lightweight dependency injection through type-safe resolution. The Guice integration (part of the Seam IoC module) allows use of Guice injection for all Seam components annotated with the <literal>@Guice</literal> annotation. In addition to the regular bijection that Seam performs (which becomes optional), Seam also delegates to known Guice injectors to satisify the dependencies of the component. Guice may be useful to tie non-Seam parts of large or legacy applications together with Seam."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:17(note) 
+msgid "The Guice integration is bundled in the jboss-seam-ioc library. This dependency is required for all integration techniques covered in this chapter. You will also need the Guice JAR file on the classpath."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:24(title) 
+msgid "Creating a hybrid Seam-Guice component"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:26(para) 
+msgid "The goal is to create a hybrid Seam-Guice component. The rule for how to do this is very simple. If you want to use Guice injection in your Seam component, annotate it with the <literal>@Guice</literal> annotation (after importing the type <literal>org.jboss.seam.ioc.guice.Guice</literal>)."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:33(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuicyComponent\")\n at Guice public class MyGuicyComponent\n{\n   @Inject MyObject myObject;\n   @Inject @Special MyObject mySpecialObject;\n   ...\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:41(para) 
+msgid "This Guice injection will happen on every method call, just like with bijection. Guice injects based on type and binding. To satisify the dependencies in the previous example, you might have bound the following implementations in a Guice module, where <literal>@Special</literal> is an annotation you define in your application."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:48(programlisting) 
+#, no-wrap
+msgid "public class MyGuicyModule implements Module\n{\n   public void configure(Binder binder)\n   {\n      binder.bind(MyObject.class)\n         .toInstance(new MyObject(\"regular\"));\n\n      binder.bind(MyObject.class).annotatedWith(Special.class)\n         .toInstance(new MyObject(\"special\"));\n   }\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:60(para) 
+msgid "Great, but which Guice injector will be used to inject the dependencies? Well, you need to perform some setup first."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:69(title) 
+msgid "Configuring an injector"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:71(para) 
+msgid "You tell Seam which Guice injector to use by hooking it into the injection property of the Guice initization component in the Seam component descriptor (components.xml):"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:89(para) 
+msgid "<literal>myGuiceInjector</literal> must resolve to a Seam component that implements the Guice <literal>Injector</literal> interface."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:94(para) 
+msgid "Having to create an injector is boiler-plate code, though. What you really want to be able to do is simply hook up Seam to your Guice modules. Fortunately, there is a built-in Seam component that implements the <literal>Injector</literal> interface to do exactly that. You can configure it in the Seam component descriptor with this additional stanza."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:108(para) 
+msgid "Of course you can also use an injector that is already used in other, possibly non-Seam part of you application. That's one of the main motivations for creating this integration. Since the injector is defined with EL expression, you can obtain it in whatever way you like. For instance, you may use the Seam factory component pattern to provide injector."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:115(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuiceInjectorFactory\")\npublic InjectorFactory\n{\n   @Factory(name = \"myGuiceInjector\", scope = APPLICATION, create = true)\n   public Injector getInjector()\n   {\n      // Your code that returns injector    \n   }\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:128(title) 
+msgid "Using multiple injectors"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:130(para) 
+msgid "By default, an injector configured in the Seam component descriptor is used. If you really need to use multiple injectors (AFAIK, you should use multiple modules instead), you can specify different injector for every Seam component in the <literal>@Guice</literal> annotation."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:137(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuicyComponent\")\n at Guice(\"myGuiceInjector\")\npublic class MyGuicyComponent\n{\n   @Inject MyObject myObject;\n   ...\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:147(para) 
+msgid "That's all there is to it! Check out the guice example in the Seam distribution to see the Seam Guice integration in action!"
+msgstr ""
+
+#. Put one translator per line, in the form of NAME <EMAIL>, YEAR1, YEAR2.
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:0(None) 
+msgid "translator-credits"
+msgstr ""
+

Added: trunk/doc/Seam_Reference_Guide/kn-IN/Guice.po
===================================================================
--- trunk/doc/Seam_Reference_Guide/kn-IN/Guice.po	                        (rev 0)
+++ trunk/doc/Seam_Reference_Guide/kn-IN/Guice.po	2009-04-12 05:22:10 UTC (rev 10388)
@@ -0,0 +1,96 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"POT-Creation-Date: 2009-04-12 01:20-0400\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Language-Team: LANGUAGE <LL at li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:6(title) 
+msgid "Guice integration"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:8(para) 
+msgid "Google Guice is a library that provides lightweight dependency injection through type-safe resolution. The Guice integration (part of the Seam IoC module) allows use of Guice injection for all Seam components annotated with the <literal>@Guice</literal> annotation. In addition to the regular bijection that Seam performs (which becomes optional), Seam also delegates to known Guice injectors to satisify the dependencies of the component. Guice may be useful to tie non-Seam parts of large or legacy applications together with Seam."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:17(note) 
+msgid "The Guice integration is bundled in the jboss-seam-ioc library. This dependency is required for all integration techniques covered in this chapter. You will also need the Guice JAR file on the classpath."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:24(title) 
+msgid "Creating a hybrid Seam-Guice component"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:26(para) 
+msgid "The goal is to create a hybrid Seam-Guice component. The rule for how to do this is very simple. If you want to use Guice injection in your Seam component, annotate it with the <literal>@Guice</literal> annotation (after importing the type <literal>org.jboss.seam.ioc.guice.Guice</literal>)."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:33(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuicyComponent\")\n at Guice public class MyGuicyComponent\n{\n   @Inject MyObject myObject;\n   @Inject @Special MyObject mySpecialObject;\n   ...\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:41(para) 
+msgid "This Guice injection will happen on every method call, just like with bijection. Guice injects based on type and binding. To satisify the dependencies in the previous example, you might have bound the following implementations in a Guice module, where <literal>@Special</literal> is an annotation you define in your application."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:48(programlisting) 
+#, no-wrap
+msgid "public class MyGuicyModule implements Module\n{\n   public void configure(Binder binder)\n   {\n      binder.bind(MyObject.class)\n         .toInstance(new MyObject(\"regular\"));\n\n      binder.bind(MyObject.class).annotatedWith(Special.class)\n         .toInstance(new MyObject(\"special\"));\n   }\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:60(para) 
+msgid "Great, but which Guice injector will be used to inject the dependencies? Well, you need to perform some setup first."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:69(title) 
+msgid "Configuring an injector"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:71(para) 
+msgid "You tell Seam which Guice injector to use by hooking it into the injection property of the Guice initization component in the Seam component descriptor (components.xml):"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:89(para) 
+msgid "<literal>myGuiceInjector</literal> must resolve to a Seam component that implements the Guice <literal>Injector</literal> interface."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:94(para) 
+msgid "Having to create an injector is boiler-plate code, though. What you really want to be able to do is simply hook up Seam to your Guice modules. Fortunately, there is a built-in Seam component that implements the <literal>Injector</literal> interface to do exactly that. You can configure it in the Seam component descriptor with this additional stanza."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:108(para) 
+msgid "Of course you can also use an injector that is already used in other, possibly non-Seam part of you application. That's one of the main motivations for creating this integration. Since the injector is defined with EL expression, you can obtain it in whatever way you like. For instance, you may use the Seam factory component pattern to provide injector."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:115(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuiceInjectorFactory\")\npublic InjectorFactory\n{\n   @Factory(name = \"myGuiceInjector\", scope = APPLICATION, create = true)\n   public Injector getInjector()\n   {\n      // Your code that returns injector    \n   }\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:128(title) 
+msgid "Using multiple injectors"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:130(para) 
+msgid "By default, an injector configured in the Seam component descriptor is used. If you really need to use multiple injectors (AFAIK, you should use multiple modules instead), you can specify different injector for every Seam component in the <literal>@Guice</literal> annotation."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:137(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuicyComponent\")\n at Guice(\"myGuiceInjector\")\npublic class MyGuicyComponent\n{\n   @Inject MyObject myObject;\n   ...\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:147(para) 
+msgid "That's all there is to it! Check out the guice example in the Seam distribution to see the Seam Guice integration in action!"
+msgstr ""
+
+#. Put one translator per line, in the form of NAME <EMAIL>, YEAR1, YEAR2.
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:0(None) 
+msgid "translator-credits"
+msgstr ""
+

Added: trunk/doc/Seam_Reference_Guide/ko-KR/Guice.po
===================================================================
--- trunk/doc/Seam_Reference_Guide/ko-KR/Guice.po	                        (rev 0)
+++ trunk/doc/Seam_Reference_Guide/ko-KR/Guice.po	2009-04-12 05:22:10 UTC (rev 10388)
@@ -0,0 +1,96 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"POT-Creation-Date: 2009-04-12 01:20-0400\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Language-Team: LANGUAGE <LL at li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:6(title) 
+msgid "Guice integration"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:8(para) 
+msgid "Google Guice is a library that provides lightweight dependency injection through type-safe resolution. The Guice integration (part of the Seam IoC module) allows use of Guice injection for all Seam components annotated with the <literal>@Guice</literal> annotation. In addition to the regular bijection that Seam performs (which becomes optional), Seam also delegates to known Guice injectors to satisify the dependencies of the component. Guice may be useful to tie non-Seam parts of large or legacy applications together with Seam."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:17(note) 
+msgid "The Guice integration is bundled in the jboss-seam-ioc library. This dependency is required for all integration techniques covered in this chapter. You will also need the Guice JAR file on the classpath."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:24(title) 
+msgid "Creating a hybrid Seam-Guice component"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:26(para) 
+msgid "The goal is to create a hybrid Seam-Guice component. The rule for how to do this is very simple. If you want to use Guice injection in your Seam component, annotate it with the <literal>@Guice</literal> annotation (after importing the type <literal>org.jboss.seam.ioc.guice.Guice</literal>)."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:33(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuicyComponent\")\n at Guice public class MyGuicyComponent\n{\n   @Inject MyObject myObject;\n   @Inject @Special MyObject mySpecialObject;\n   ...\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:41(para) 
+msgid "This Guice injection will happen on every method call, just like with bijection. Guice injects based on type and binding. To satisify the dependencies in the previous example, you might have bound the following implementations in a Guice module, where <literal>@Special</literal> is an annotation you define in your application."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:48(programlisting) 
+#, no-wrap
+msgid "public class MyGuicyModule implements Module\n{\n   public void configure(Binder binder)\n   {\n      binder.bind(MyObject.class)\n         .toInstance(new MyObject(\"regular\"));\n\n      binder.bind(MyObject.class).annotatedWith(Special.class)\n         .toInstance(new MyObject(\"special\"));\n   }\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:60(para) 
+msgid "Great, but which Guice injector will be used to inject the dependencies? Well, you need to perform some setup first."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:69(title) 
+msgid "Configuring an injector"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:71(para) 
+msgid "You tell Seam which Guice injector to use by hooking it into the injection property of the Guice initization component in the Seam component descriptor (components.xml):"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:89(para) 
+msgid "<literal>myGuiceInjector</literal> must resolve to a Seam component that implements the Guice <literal>Injector</literal> interface."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:94(para) 
+msgid "Having to create an injector is boiler-plate code, though. What you really want to be able to do is simply hook up Seam to your Guice modules. Fortunately, there is a built-in Seam component that implements the <literal>Injector</literal> interface to do exactly that. You can configure it in the Seam component descriptor with this additional stanza."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:108(para) 
+msgid "Of course you can also use an injector that is already used in other, possibly non-Seam part of you application. That's one of the main motivations for creating this integration. Since the injector is defined with EL expression, you can obtain it in whatever way you like. For instance, you may use the Seam factory component pattern to provide injector."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:115(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuiceInjectorFactory\")\npublic InjectorFactory\n{\n   @Factory(name = \"myGuiceInjector\", scope = APPLICATION, create = true)\n   public Injector getInjector()\n   {\n      // Your code that returns injector    \n   }\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:128(title) 
+msgid "Using multiple injectors"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:130(para) 
+msgid "By default, an injector configured in the Seam component descriptor is used. If you really need to use multiple injectors (AFAIK, you should use multiple modules instead), you can specify different injector for every Seam component in the <literal>@Guice</literal> annotation."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:137(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuicyComponent\")\n at Guice(\"myGuiceInjector\")\npublic class MyGuicyComponent\n{\n   @Inject MyObject myObject;\n   ...\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:147(para) 
+msgid "That's all there is to it! Check out the guice example in the Seam distribution to see the Seam Guice integration in action!"
+msgstr ""
+
+#. Put one translator per line, in the form of NAME <EMAIL>, YEAR1, YEAR2.
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:0(None) 
+msgid "translator-credits"
+msgstr ""
+

Added: trunk/doc/Seam_Reference_Guide/ml-IN/Guice.po
===================================================================
--- trunk/doc/Seam_Reference_Guide/ml-IN/Guice.po	                        (rev 0)
+++ trunk/doc/Seam_Reference_Guide/ml-IN/Guice.po	2009-04-12 05:22:10 UTC (rev 10388)
@@ -0,0 +1,96 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"POT-Creation-Date: 2009-04-12 01:20-0400\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Language-Team: LANGUAGE <LL at li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:6(title) 
+msgid "Guice integration"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:8(para) 
+msgid "Google Guice is a library that provides lightweight dependency injection through type-safe resolution. The Guice integration (part of the Seam IoC module) allows use of Guice injection for all Seam components annotated with the <literal>@Guice</literal> annotation. In addition to the regular bijection that Seam performs (which becomes optional), Seam also delegates to known Guice injectors to satisify the dependencies of the component. Guice may be useful to tie non-Seam parts of large or legacy applications together with Seam."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:17(note) 
+msgid "The Guice integration is bundled in the jboss-seam-ioc library. This dependency is required for all integration techniques covered in this chapter. You will also need the Guice JAR file on the classpath."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:24(title) 
+msgid "Creating a hybrid Seam-Guice component"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:26(para) 
+msgid "The goal is to create a hybrid Seam-Guice component. The rule for how to do this is very simple. If you want to use Guice injection in your Seam component, annotate it with the <literal>@Guice</literal> annotation (after importing the type <literal>org.jboss.seam.ioc.guice.Guice</literal>)."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:33(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuicyComponent\")\n at Guice public class MyGuicyComponent\n{\n   @Inject MyObject myObject;\n   @Inject @Special MyObject mySpecialObject;\n   ...\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:41(para) 
+msgid "This Guice injection will happen on every method call, just like with bijection. Guice injects based on type and binding. To satisify the dependencies in the previous example, you might have bound the following implementations in a Guice module, where <literal>@Special</literal> is an annotation you define in your application."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:48(programlisting) 
+#, no-wrap
+msgid "public class MyGuicyModule implements Module\n{\n   public void configure(Binder binder)\n   {\n      binder.bind(MyObject.class)\n         .toInstance(new MyObject(\"regular\"));\n\n      binder.bind(MyObject.class).annotatedWith(Special.class)\n         .toInstance(new MyObject(\"special\"));\n   }\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:60(para) 
+msgid "Great, but which Guice injector will be used to inject the dependencies? Well, you need to perform some setup first."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:69(title) 
+msgid "Configuring an injector"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:71(para) 
+msgid "You tell Seam which Guice injector to use by hooking it into the injection property of the Guice initization component in the Seam component descriptor (components.xml):"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:89(para) 
+msgid "<literal>myGuiceInjector</literal> must resolve to a Seam component that implements the Guice <literal>Injector</literal> interface."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:94(para) 
+msgid "Having to create an injector is boiler-plate code, though. What you really want to be able to do is simply hook up Seam to your Guice modules. Fortunately, there is a built-in Seam component that implements the <literal>Injector</literal> interface to do exactly that. You can configure it in the Seam component descriptor with this additional stanza."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:108(para) 
+msgid "Of course you can also use an injector that is already used in other, possibly non-Seam part of you application. That's one of the main motivations for creating this integration. Since the injector is defined with EL expression, you can obtain it in whatever way you like. For instance, you may use the Seam factory component pattern to provide injector."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:115(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuiceInjectorFactory\")\npublic InjectorFactory\n{\n   @Factory(name = \"myGuiceInjector\", scope = APPLICATION, create = true)\n   public Injector getInjector()\n   {\n      // Your code that returns injector    \n   }\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:128(title) 
+msgid "Using multiple injectors"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:130(para) 
+msgid "By default, an injector configured in the Seam component descriptor is used. If you really need to use multiple injectors (AFAIK, you should use multiple modules instead), you can specify different injector for every Seam component in the <literal>@Guice</literal> annotation."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:137(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuicyComponent\")\n at Guice(\"myGuiceInjector\")\npublic class MyGuicyComponent\n{\n   @Inject MyObject myObject;\n   ...\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:147(para) 
+msgid "That's all there is to it! Check out the guice example in the Seam distribution to see the Seam Guice integration in action!"
+msgstr ""
+
+#. Put one translator per line, in the form of NAME <EMAIL>, YEAR1, YEAR2.
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:0(None) 
+msgid "translator-credits"
+msgstr ""
+

Added: trunk/doc/Seam_Reference_Guide/mr-IN/Guice.po
===================================================================
--- trunk/doc/Seam_Reference_Guide/mr-IN/Guice.po	                        (rev 0)
+++ trunk/doc/Seam_Reference_Guide/mr-IN/Guice.po	2009-04-12 05:22:10 UTC (rev 10388)
@@ -0,0 +1,96 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"POT-Creation-Date: 2009-04-12 01:20-0400\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Language-Team: LANGUAGE <LL at li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:6(title) 
+msgid "Guice integration"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:8(para) 
+msgid "Google Guice is a library that provides lightweight dependency injection through type-safe resolution. The Guice integration (part of the Seam IoC module) allows use of Guice injection for all Seam components annotated with the <literal>@Guice</literal> annotation. In addition to the regular bijection that Seam performs (which becomes optional), Seam also delegates to known Guice injectors to satisify the dependencies of the component. Guice may be useful to tie non-Seam parts of large or legacy applications together with Seam."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:17(note) 
+msgid "The Guice integration is bundled in the jboss-seam-ioc library. This dependency is required for all integration techniques covered in this chapter. You will also need the Guice JAR file on the classpath."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:24(title) 
+msgid "Creating a hybrid Seam-Guice component"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:26(para) 
+msgid "The goal is to create a hybrid Seam-Guice component. The rule for how to do this is very simple. If you want to use Guice injection in your Seam component, annotate it with the <literal>@Guice</literal> annotation (after importing the type <literal>org.jboss.seam.ioc.guice.Guice</literal>)."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:33(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuicyComponent\")\n at Guice public class MyGuicyComponent\n{\n   @Inject MyObject myObject;\n   @Inject @Special MyObject mySpecialObject;\n   ...\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:41(para) 
+msgid "This Guice injection will happen on every method call, just like with bijection. Guice injects based on type and binding. To satisify the dependencies in the previous example, you might have bound the following implementations in a Guice module, where <literal>@Special</literal> is an annotation you define in your application."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:48(programlisting) 
+#, no-wrap
+msgid "public class MyGuicyModule implements Module\n{\n   public void configure(Binder binder)\n   {\n      binder.bind(MyObject.class)\n         .toInstance(new MyObject(\"regular\"));\n\n      binder.bind(MyObject.class).annotatedWith(Special.class)\n         .toInstance(new MyObject(\"special\"));\n   }\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:60(para) 
+msgid "Great, but which Guice injector will be used to inject the dependencies? Well, you need to perform some setup first."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:69(title) 
+msgid "Configuring an injector"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:71(para) 
+msgid "You tell Seam which Guice injector to use by hooking it into the injection property of the Guice initization component in the Seam component descriptor (components.xml):"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:89(para) 
+msgid "<literal>myGuiceInjector</literal> must resolve to a Seam component that implements the Guice <literal>Injector</literal> interface."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:94(para) 
+msgid "Having to create an injector is boiler-plate code, though. What you really want to be able to do is simply hook up Seam to your Guice modules. Fortunately, there is a built-in Seam component that implements the <literal>Injector</literal> interface to do exactly that. You can configure it in the Seam component descriptor with this additional stanza."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:108(para) 
+msgid "Of course you can also use an injector that is already used in other, possibly non-Seam part of you application. That's one of the main motivations for creating this integration. Since the injector is defined with EL expression, you can obtain it in whatever way you like. For instance, you may use the Seam factory component pattern to provide injector."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:115(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuiceInjectorFactory\")\npublic InjectorFactory\n{\n   @Factory(name = \"myGuiceInjector\", scope = APPLICATION, create = true)\n   public Injector getInjector()\n   {\n      // Your code that returns injector    \n   }\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:128(title) 
+msgid "Using multiple injectors"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:130(para) 
+msgid "By default, an injector configured in the Seam component descriptor is used. If you really need to use multiple injectors (AFAIK, you should use multiple modules instead), you can specify different injector for every Seam component in the <literal>@Guice</literal> annotation."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:137(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuicyComponent\")\n at Guice(\"myGuiceInjector\")\npublic class MyGuicyComponent\n{\n   @Inject MyObject myObject;\n   ...\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:147(para) 
+msgid "That's all there is to it! Check out the guice example in the Seam distribution to see the Seam Guice integration in action!"
+msgstr ""
+
+#. Put one translator per line, in the form of NAME <EMAIL>, YEAR1, YEAR2.
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:0(None) 
+msgid "translator-credits"
+msgstr ""
+

Added: trunk/doc/Seam_Reference_Guide/or-IN/Guice.po
===================================================================
--- trunk/doc/Seam_Reference_Guide/or-IN/Guice.po	                        (rev 0)
+++ trunk/doc/Seam_Reference_Guide/or-IN/Guice.po	2009-04-12 05:22:10 UTC (rev 10388)
@@ -0,0 +1,96 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"POT-Creation-Date: 2009-04-12 01:20-0400\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Language-Team: LANGUAGE <LL at li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:6(title) 
+msgid "Guice integration"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:8(para) 
+msgid "Google Guice is a library that provides lightweight dependency injection through type-safe resolution. The Guice integration (part of the Seam IoC module) allows use of Guice injection for all Seam components annotated with the <literal>@Guice</literal> annotation. In addition to the regular bijection that Seam performs (which becomes optional), Seam also delegates to known Guice injectors to satisify the dependencies of the component. Guice may be useful to tie non-Seam parts of large or legacy applications together with Seam."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:17(note) 
+msgid "The Guice integration is bundled in the jboss-seam-ioc library. This dependency is required for all integration techniques covered in this chapter. You will also need the Guice JAR file on the classpath."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:24(title) 
+msgid "Creating a hybrid Seam-Guice component"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:26(para) 
+msgid "The goal is to create a hybrid Seam-Guice component. The rule for how to do this is very simple. If you want to use Guice injection in your Seam component, annotate it with the <literal>@Guice</literal> annotation (after importing the type <literal>org.jboss.seam.ioc.guice.Guice</literal>)."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:33(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuicyComponent\")\n at Guice public class MyGuicyComponent\n{\n   @Inject MyObject myObject;\n   @Inject @Special MyObject mySpecialObject;\n   ...\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:41(para) 
+msgid "This Guice injection will happen on every method call, just like with bijection. Guice injects based on type and binding. To satisify the dependencies in the previous example, you might have bound the following implementations in a Guice module, where <literal>@Special</literal> is an annotation you define in your application."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:48(programlisting) 
+#, no-wrap
+msgid "public class MyGuicyModule implements Module\n{\n   public void configure(Binder binder)\n   {\n      binder.bind(MyObject.class)\n         .toInstance(new MyObject(\"regular\"));\n\n      binder.bind(MyObject.class).annotatedWith(Special.class)\n         .toInstance(new MyObject(\"special\"));\n   }\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:60(para) 
+msgid "Great, but which Guice injector will be used to inject the dependencies? Well, you need to perform some setup first."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:69(title) 
+msgid "Configuring an injector"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:71(para) 
+msgid "You tell Seam which Guice injector to use by hooking it into the injection property of the Guice initization component in the Seam component descriptor (components.xml):"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:89(para) 
+msgid "<literal>myGuiceInjector</literal> must resolve to a Seam component that implements the Guice <literal>Injector</literal> interface."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:94(para) 
+msgid "Having to create an injector is boiler-plate code, though. What you really want to be able to do is simply hook up Seam to your Guice modules. Fortunately, there is a built-in Seam component that implements the <literal>Injector</literal> interface to do exactly that. You can configure it in the Seam component descriptor with this additional stanza."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:108(para) 
+msgid "Of course you can also use an injector that is already used in other, possibly non-Seam part of you application. That's one of the main motivations for creating this integration. Since the injector is defined with EL expression, you can obtain it in whatever way you like. For instance, you may use the Seam factory component pattern to provide injector."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:115(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuiceInjectorFactory\")\npublic InjectorFactory\n{\n   @Factory(name = \"myGuiceInjector\", scope = APPLICATION, create = true)\n   public Injector getInjector()\n   {\n      // Your code that returns injector    \n   }\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:128(title) 
+msgid "Using multiple injectors"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:130(para) 
+msgid "By default, an injector configured in the Seam component descriptor is used. If you really need to use multiple injectors (AFAIK, you should use multiple modules instead), you can specify different injector for every Seam component in the <literal>@Guice</literal> annotation."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:137(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuicyComponent\")\n at Guice(\"myGuiceInjector\")\npublic class MyGuicyComponent\n{\n   @Inject MyObject myObject;\n   ...\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:147(para) 
+msgid "That's all there is to it! Check out the guice example in the Seam distribution to see the Seam Guice integration in action!"
+msgstr ""
+
+#. Put one translator per line, in the form of NAME <EMAIL>, YEAR1, YEAR2.
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:0(None) 
+msgid "translator-credits"
+msgstr ""
+

Added: trunk/doc/Seam_Reference_Guide/pa-IN/Guice.po
===================================================================
--- trunk/doc/Seam_Reference_Guide/pa-IN/Guice.po	                        (rev 0)
+++ trunk/doc/Seam_Reference_Guide/pa-IN/Guice.po	2009-04-12 05:22:10 UTC (rev 10388)
@@ -0,0 +1,96 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"POT-Creation-Date: 2009-04-12 01:20-0400\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Language-Team: LANGUAGE <LL at li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:6(title) 
+msgid "Guice integration"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:8(para) 
+msgid "Google Guice is a library that provides lightweight dependency injection through type-safe resolution. The Guice integration (part of the Seam IoC module) allows use of Guice injection for all Seam components annotated with the <literal>@Guice</literal> annotation. In addition to the regular bijection that Seam performs (which becomes optional), Seam also delegates to known Guice injectors to satisify the dependencies of the component. Guice may be useful to tie non-Seam parts of large or legacy applications together with Seam."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:17(note) 
+msgid "The Guice integration is bundled in the jboss-seam-ioc library. This dependency is required for all integration techniques covered in this chapter. You will also need the Guice JAR file on the classpath."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:24(title) 
+msgid "Creating a hybrid Seam-Guice component"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:26(para) 
+msgid "The goal is to create a hybrid Seam-Guice component. The rule for how to do this is very simple. If you want to use Guice injection in your Seam component, annotate it with the <literal>@Guice</literal> annotation (after importing the type <literal>org.jboss.seam.ioc.guice.Guice</literal>)."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:33(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuicyComponent\")\n at Guice public class MyGuicyComponent\n{\n   @Inject MyObject myObject;\n   @Inject @Special MyObject mySpecialObject;\n   ...\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:41(para) 
+msgid "This Guice injection will happen on every method call, just like with bijection. Guice injects based on type and binding. To satisify the dependencies in the previous example, you might have bound the following implementations in a Guice module, where <literal>@Special</literal> is an annotation you define in your application."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:48(programlisting) 
+#, no-wrap
+msgid "public class MyGuicyModule implements Module\n{\n   public void configure(Binder binder)\n   {\n      binder.bind(MyObject.class)\n         .toInstance(new MyObject(\"regular\"));\n\n      binder.bind(MyObject.class).annotatedWith(Special.class)\n         .toInstance(new MyObject(\"special\"));\n   }\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:60(para) 
+msgid "Great, but which Guice injector will be used to inject the dependencies? Well, you need to perform some setup first."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:69(title) 
+msgid "Configuring an injector"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:71(para) 
+msgid "You tell Seam which Guice injector to use by hooking it into the injection property of the Guice initization component in the Seam component descriptor (components.xml):"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:89(para) 
+msgid "<literal>myGuiceInjector</literal> must resolve to a Seam component that implements the Guice <literal>Injector</literal> interface."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:94(para) 
+msgid "Having to create an injector is boiler-plate code, though. What you really want to be able to do is simply hook up Seam to your Guice modules. Fortunately, there is a built-in Seam component that implements the <literal>Injector</literal> interface to do exactly that. You can configure it in the Seam component descriptor with this additional stanza."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:108(para) 
+msgid "Of course you can also use an injector that is already used in other, possibly non-Seam part of you application. That's one of the main motivations for creating this integration. Since the injector is defined with EL expression, you can obtain it in whatever way you like. For instance, you may use the Seam factory component pattern to provide injector."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:115(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuiceInjectorFactory\")\npublic InjectorFactory\n{\n   @Factory(name = \"myGuiceInjector\", scope = APPLICATION, create = true)\n   public Injector getInjector()\n   {\n      // Your code that returns injector    \n   }\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:128(title) 
+msgid "Using multiple injectors"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:130(para) 
+msgid "By default, an injector configured in the Seam component descriptor is used. If you really need to use multiple injectors (AFAIK, you should use multiple modules instead), you can specify different injector for every Seam component in the <literal>@Guice</literal> annotation."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:137(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuicyComponent\")\n at Guice(\"myGuiceInjector\")\npublic class MyGuicyComponent\n{\n   @Inject MyObject myObject;\n   ...\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:147(para) 
+msgid "That's all there is to it! Check out the guice example in the Seam distribution to see the Seam Guice integration in action!"
+msgstr ""
+
+#. Put one translator per line, in the form of NAME <EMAIL>, YEAR1, YEAR2.
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:0(None) 
+msgid "translator-credits"
+msgstr ""
+

Added: trunk/doc/Seam_Reference_Guide/pot/Guice.pot
===================================================================
--- trunk/doc/Seam_Reference_Guide/pot/Guice.pot	                        (rev 0)
+++ trunk/doc/Seam_Reference_Guide/pot/Guice.pot	2009-04-12 05:22:10 UTC (rev 10388)
@@ -0,0 +1,194 @@
+# SOME DESCRIPTIVE TITLE.
+# FIRST AUTHOR <EMAIL at ADDRESS>, YEAR.
+#
+#, fuzzy
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"Report-Msgid-Bugs-To: http://bugs.kde.org\n"
+"POT-Creation-Date: 2009-04-12 05:18+0000\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Language-Team: LANGUAGE <kde-i18n-doc at kde.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: application/x-xml2pot; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+#. Tag: title
+#: Guice.xml:6
+#, no-c-format
+msgid "Guice integration"
+msgstr ""
+
+#. Tag: para
+#: Guice.xml:8
+#, no-c-format
+msgid "Google Guice is a library that provides lightweight dependency injection through type-safe resolution. The Guice integration (part of the Seam IoC module) allows use of Guice injection for all Seam components annotated with the <literal>@Guice</literal> annotation. In addition to the regular bijection that Seam performs (which becomes optional), Seam also delegates to known Guice injectors to satisify the dependencies of the component. Guice may be useful to tie non-Seam parts of large or legacy applications together with Seam."
+msgstr ""
+
+#. Tag: note
+#: Guice.xml:17
+#, no-c-format
+msgid "The Guice integration is bundled in the jboss-seam-ioc library. This dependency is required for all integration techniques covered in this chapter. You will also need the Guice JAR file on the classpath."
+msgstr ""
+
+#. Tag: title
+#: Guice.xml:24
+#, no-c-format
+msgid "Creating a hybrid Seam-Guice component"
+msgstr ""
+
+#. Tag: para
+#: Guice.xml:26
+#, no-c-format
+msgid "The goal is to create a hybrid Seam-Guice component. The rule for how to do this is very simple. If you want to use Guice injection in your Seam component, annotate it with the <literal>@Guice</literal> annotation (after importing the type <literal>org.jboss.seam.ioc.guice.Guice</literal>)."
+msgstr ""
+
+#. Tag: programlisting
+#: Guice.xml:33
+#, no-c-format
+msgid ""
+      "@Name(\"myGuicyComponent\")\n"
+      "@Guice public class MyGuicyComponent\n"
+      "{\n"
+      "   @Inject MyObject myObject;\n"
+      "   @Inject @Special MyObject mySpecialObject;\n"
+      "   ...\n"
+      "}"
+msgstr ""
+
+#. Tag: para
+#: Guice.xml:35
+#, no-c-format
+msgid "This Guice injection will happen on every method call, just like with bijection. Guice injects based on type and binding. To satisify the dependencies in the previous example, you might have bound the following implementations in a Guice module, where <literal>@Special</literal> is an annotation you define in your application."
+msgstr ""
+
+#. Tag: programlisting
+#: Guice.xml:42
+#, no-c-format
+msgid ""
+      "public class MyGuicyModule implements Module\n"
+      "{\n"
+      "   public void configure(Binder binder)\n"
+      "   {\n"
+      "      binder.bind(MyObject.class)\n"
+      "         .toInstance(new MyObject(\"regular\"));\n"
+      "\n"
+      "      binder.bind(MyObject.class).annotatedWith(Special.class)\n"
+      "         .toInstance(new MyObject(\"special\"));\n"
+      "   }\n"
+      "}"
+msgstr ""
+
+#. Tag: para
+#: Guice.xml:44
+#, no-c-format
+msgid "Great, but which Guice injector will be used to inject the dependencies? Well, you need to perform some setup first."
+msgstr ""
+
+#. Tag: title
+#: Guice.xml:53
+#, no-c-format
+msgid "Configuring an injector"
+msgstr ""
+
+#. Tag: para
+#: Guice.xml:55
+#, no-c-format
+msgid "You tell Seam which Guice injector to use by hooking it into the injection property of the Guice initization component in the Seam component descriptor (components.xml):"
+msgstr ""
+
+#. Tag: programlisting
+#: Guice.xml:60
+#, no-c-format
+msgid ""
+      "<![CDATA[<components xmlns=\"http://jboss.com/products/seam/components\"\n"
+      "   xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n"
+      "   xmlns:guice=\"http://jboss.org/products/seam/guice\"\n"
+      "   xsi:schemaLocation=\"\n"
+      "      http://jboss.com/products/seam/guice\n"
+      "      http://jboss.com/products/seam/guice-2.1.xsd\n"
+      "      http://jboss.com/products/seam/components\n"
+      "      http://jboss.com/products/seam/components-2.1.xsd\">\n"
+      "\n"
+      "   <guice:init injector=\"#{myGuiceInjector}\"/>\n"
+      "\n"
+      "</components>]]>"
+msgstr ""
+
+#. Tag: para
+#: Guice.xml:62
+#, no-c-format
+msgid "<literal>myGuiceInjector</literal> must resolve to a Seam component that implements the Guice <literal>Injector</literal> interface."
+msgstr ""
+
+#. Tag: para
+#: Guice.xml:67
+#, no-c-format
+msgid "Having to create an injector is boiler-plate code, though. What you really want to be able to do is simply hook up Seam to your Guice modules. Fortunately, there is a built-in Seam component that implements the <literal>Injector</literal> interface to do exactly that. You can configure it in the Seam component descriptor with this additional stanza."
+msgstr ""
+
+#. Tag: programlisting
+#: Guice.xml:74
+#, no-c-format
+msgid ""
+      "<![CDATA[<guice:injector name=\"myGuiceInjector\">\n"
+      "   <guice:modules>  \n"
+      "      <value>com.example.guice.GuiceModule1</value>  \n"
+      "      <value>com.example.guice.GuiceModule2</value>  \n"
+      "   </guice:modules>  \n"
+      "</guice:injector>]]>"
+msgstr ""
+
+#. Tag: para
+#: Guice.xml:76
+#, no-c-format
+msgid "Of course you can also use an injector that is already used in other, possibly non-Seam part of you application. That's one of the main motivations for creating this integration. Since the injector is defined with EL expression, you can obtain it in whatever way you like. For instance, you may use the Seam factory component pattern to provide injector."
+msgstr ""
+
+#. Tag: programlisting
+#: Guice.xml:83
+#, no-c-format
+msgid ""
+      "@Name(\"myGuiceInjectorFactory\")\n"
+      "public InjectorFactory\n"
+      "{\n"
+      "   @Factory(name = \"myGuiceInjector\", scope = APPLICATION, create = true)\n"
+      "   public Injector getInjector()\n"
+      "   {\n"
+      "      // Your code that returns injector    \n"
+      "   }\n"
+      "}"
+msgstr ""
+
+#. Tag: title
+#: Guice.xml:88
+#, no-c-format
+msgid "Using multiple injectors"
+msgstr ""
+
+#. Tag: para
+#: Guice.xml:90
+#, no-c-format
+msgid "By default, an injector configured in the Seam component descriptor is used. If you really need to use multiple injectors (AFAIK, you should use multiple modules instead), you can specify different injector for every Seam component in the <literal>@Guice</literal> annotation."
+msgstr ""
+
+#. Tag: programlisting
+#: Guice.xml:97
+#, no-c-format
+msgid ""
+      "@Name(\"myGuicyComponent\")\n"
+      "@Guice(\"myGuiceInjector\")\n"
+      "public class MyGuicyComponent\n"
+      "{\n"
+      "   @Inject MyObject myObject;\n"
+      "   ...\n"
+      "}"
+msgstr ""
+
+#. Tag: para
+#: Guice.xml:101
+#, no-c-format
+msgid "That's all there is to it! Check out the guice example in the Seam distribution to see the Seam Guice integration in action!"
+msgstr ""
+

Added: trunk/doc/Seam_Reference_Guide/pt-BR/Guice.po
===================================================================
--- trunk/doc/Seam_Reference_Guide/pt-BR/Guice.po	                        (rev 0)
+++ trunk/doc/Seam_Reference_Guide/pt-BR/Guice.po	2009-04-12 05:22:10 UTC (rev 10388)
@@ -0,0 +1,96 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"POT-Creation-Date: 2009-04-12 01:20-0400\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Language-Team: LANGUAGE <LL at li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:6(title) 
+msgid "Guice integration"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:8(para) 
+msgid "Google Guice is a library that provides lightweight dependency injection through type-safe resolution. The Guice integration (part of the Seam IoC module) allows use of Guice injection for all Seam components annotated with the <literal>@Guice</literal> annotation. In addition to the regular bijection that Seam performs (which becomes optional), Seam also delegates to known Guice injectors to satisify the dependencies of the component. Guice may be useful to tie non-Seam parts of large or legacy applications together with Seam."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:17(note) 
+msgid "The Guice integration is bundled in the jboss-seam-ioc library. This dependency is required for all integration techniques covered in this chapter. You will also need the Guice JAR file on the classpath."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:24(title) 
+msgid "Creating a hybrid Seam-Guice component"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:26(para) 
+msgid "The goal is to create a hybrid Seam-Guice component. The rule for how to do this is very simple. If you want to use Guice injection in your Seam component, annotate it with the <literal>@Guice</literal> annotation (after importing the type <literal>org.jboss.seam.ioc.guice.Guice</literal>)."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:33(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuicyComponent\")\n at Guice public class MyGuicyComponent\n{\n   @Inject MyObject myObject;\n   @Inject @Special MyObject mySpecialObject;\n   ...\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:41(para) 
+msgid "This Guice injection will happen on every method call, just like with bijection. Guice injects based on type and binding. To satisify the dependencies in the previous example, you might have bound the following implementations in a Guice module, where <literal>@Special</literal> is an annotation you define in your application."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:48(programlisting) 
+#, no-wrap
+msgid "public class MyGuicyModule implements Module\n{\n   public void configure(Binder binder)\n   {\n      binder.bind(MyObject.class)\n         .toInstance(new MyObject(\"regular\"));\n\n      binder.bind(MyObject.class).annotatedWith(Special.class)\n         .toInstance(new MyObject(\"special\"));\n   }\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:60(para) 
+msgid "Great, but which Guice injector will be used to inject the dependencies? Well, you need to perform some setup first."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:69(title) 
+msgid "Configuring an injector"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:71(para) 
+msgid "You tell Seam which Guice injector to use by hooking it into the injection property of the Guice initization component in the Seam component descriptor (components.xml):"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:89(para) 
+msgid "<literal>myGuiceInjector</literal> must resolve to a Seam component that implements the Guice <literal>Injector</literal> interface."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:94(para) 
+msgid "Having to create an injector is boiler-plate code, though. What you really want to be able to do is simply hook up Seam to your Guice modules. Fortunately, there is a built-in Seam component that implements the <literal>Injector</literal> interface to do exactly that. You can configure it in the Seam component descriptor with this additional stanza."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:108(para) 
+msgid "Of course you can also use an injector that is already used in other, possibly non-Seam part of you application. That's one of the main motivations for creating this integration. Since the injector is defined with EL expression, you can obtain it in whatever way you like. For instance, you may use the Seam factory component pattern to provide injector."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:115(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuiceInjectorFactory\")\npublic InjectorFactory\n{\n   @Factory(name = \"myGuiceInjector\", scope = APPLICATION, create = true)\n   public Injector getInjector()\n   {\n      // Your code that returns injector    \n   }\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:128(title) 
+msgid "Using multiple injectors"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:130(para) 
+msgid "By default, an injector configured in the Seam component descriptor is used. If you really need to use multiple injectors (AFAIK, you should use multiple modules instead), you can specify different injector for every Seam component in the <literal>@Guice</literal> annotation."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:137(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuicyComponent\")\n at Guice(\"myGuiceInjector\")\npublic class MyGuicyComponent\n{\n   @Inject MyObject myObject;\n   ...\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:147(para) 
+msgid "That's all there is to it! Check out the guice example in the Seam distribution to see the Seam Guice integration in action!"
+msgstr ""
+
+#. Put one translator per line, in the form of NAME <EMAIL>, YEAR1, YEAR2.
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:0(None) 
+msgid "translator-credits"
+msgstr ""
+

Added: trunk/doc/Seam_Reference_Guide/ru-RU/Guice.po
===================================================================
--- trunk/doc/Seam_Reference_Guide/ru-RU/Guice.po	                        (rev 0)
+++ trunk/doc/Seam_Reference_Guide/ru-RU/Guice.po	2009-04-12 05:22:10 UTC (rev 10388)
@@ -0,0 +1,96 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"POT-Creation-Date: 2009-04-12 01:20-0400\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Language-Team: LANGUAGE <LL at li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:6(title) 
+msgid "Guice integration"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:8(para) 
+msgid "Google Guice is a library that provides lightweight dependency injection through type-safe resolution. The Guice integration (part of the Seam IoC module) allows use of Guice injection for all Seam components annotated with the <literal>@Guice</literal> annotation. In addition to the regular bijection that Seam performs (which becomes optional), Seam also delegates to known Guice injectors to satisify the dependencies of the component. Guice may be useful to tie non-Seam parts of large or legacy applications together with Seam."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:17(note) 
+msgid "The Guice integration is bundled in the jboss-seam-ioc library. This dependency is required for all integration techniques covered in this chapter. You will also need the Guice JAR file on the classpath."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:24(title) 
+msgid "Creating a hybrid Seam-Guice component"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:26(para) 
+msgid "The goal is to create a hybrid Seam-Guice component. The rule for how to do this is very simple. If you want to use Guice injection in your Seam component, annotate it with the <literal>@Guice</literal> annotation (after importing the type <literal>org.jboss.seam.ioc.guice.Guice</literal>)."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:33(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuicyComponent\")\n at Guice public class MyGuicyComponent\n{\n   @Inject MyObject myObject;\n   @Inject @Special MyObject mySpecialObject;\n   ...\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:41(para) 
+msgid "This Guice injection will happen on every method call, just like with bijection. Guice injects based on type and binding. To satisify the dependencies in the previous example, you might have bound the following implementations in a Guice module, where <literal>@Special</literal> is an annotation you define in your application."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:48(programlisting) 
+#, no-wrap
+msgid "public class MyGuicyModule implements Module\n{\n   public void configure(Binder binder)\n   {\n      binder.bind(MyObject.class)\n         .toInstance(new MyObject(\"regular\"));\n\n      binder.bind(MyObject.class).annotatedWith(Special.class)\n         .toInstance(new MyObject(\"special\"));\n   }\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:60(para) 
+msgid "Great, but which Guice injector will be used to inject the dependencies? Well, you need to perform some setup first."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:69(title) 
+msgid "Configuring an injector"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:71(para) 
+msgid "You tell Seam which Guice injector to use by hooking it into the injection property of the Guice initization component in the Seam component descriptor (components.xml):"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:89(para) 
+msgid "<literal>myGuiceInjector</literal> must resolve to a Seam component that implements the Guice <literal>Injector</literal> interface."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:94(para) 
+msgid "Having to create an injector is boiler-plate code, though. What you really want to be able to do is simply hook up Seam to your Guice modules. Fortunately, there is a built-in Seam component that implements the <literal>Injector</literal> interface to do exactly that. You can configure it in the Seam component descriptor with this additional stanza."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:108(para) 
+msgid "Of course you can also use an injector that is already used in other, possibly non-Seam part of you application. That's one of the main motivations for creating this integration. Since the injector is defined with EL expression, you can obtain it in whatever way you like. For instance, you may use the Seam factory component pattern to provide injector."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:115(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuiceInjectorFactory\")\npublic InjectorFactory\n{\n   @Factory(name = \"myGuiceInjector\", scope = APPLICATION, create = true)\n   public Injector getInjector()\n   {\n      // Your code that returns injector    \n   }\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:128(title) 
+msgid "Using multiple injectors"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:130(para) 
+msgid "By default, an injector configured in the Seam component descriptor is used. If you really need to use multiple injectors (AFAIK, you should use multiple modules instead), you can specify different injector for every Seam component in the <literal>@Guice</literal> annotation."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:137(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuicyComponent\")\n at Guice(\"myGuiceInjector\")\npublic class MyGuicyComponent\n{\n   @Inject MyObject myObject;\n   ...\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:147(para) 
+msgid "That's all there is to it! Check out the guice example in the Seam distribution to see the Seam Guice integration in action!"
+msgstr ""
+
+#. Put one translator per line, in the form of NAME <EMAIL>, YEAR1, YEAR2.
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:0(None) 
+msgid "translator-credits"
+msgstr ""
+

Added: trunk/doc/Seam_Reference_Guide/si-LK/Guice.po
===================================================================
--- trunk/doc/Seam_Reference_Guide/si-LK/Guice.po	                        (rev 0)
+++ trunk/doc/Seam_Reference_Guide/si-LK/Guice.po	2009-04-12 05:22:10 UTC (rev 10388)
@@ -0,0 +1,96 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"POT-Creation-Date: 2009-04-12 01:20-0400\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Language-Team: LANGUAGE <LL at li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:6(title) 
+msgid "Guice integration"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:8(para) 
+msgid "Google Guice is a library that provides lightweight dependency injection through type-safe resolution. The Guice integration (part of the Seam IoC module) allows use of Guice injection for all Seam components annotated with the <literal>@Guice</literal> annotation. In addition to the regular bijection that Seam performs (which becomes optional), Seam also delegates to known Guice injectors to satisify the dependencies of the component. Guice may be useful to tie non-Seam parts of large or legacy applications together with Seam."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:17(note) 
+msgid "The Guice integration is bundled in the jboss-seam-ioc library. This dependency is required for all integration techniques covered in this chapter. You will also need the Guice JAR file on the classpath."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:24(title) 
+msgid "Creating a hybrid Seam-Guice component"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:26(para) 
+msgid "The goal is to create a hybrid Seam-Guice component. The rule for how to do this is very simple. If you want to use Guice injection in your Seam component, annotate it with the <literal>@Guice</literal> annotation (after importing the type <literal>org.jboss.seam.ioc.guice.Guice</literal>)."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:33(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuicyComponent\")\n at Guice public class MyGuicyComponent\n{\n   @Inject MyObject myObject;\n   @Inject @Special MyObject mySpecialObject;\n   ...\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:41(para) 
+msgid "This Guice injection will happen on every method call, just like with bijection. Guice injects based on type and binding. To satisify the dependencies in the previous example, you might have bound the following implementations in a Guice module, where <literal>@Special</literal> is an annotation you define in your application."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:48(programlisting) 
+#, no-wrap
+msgid "public class MyGuicyModule implements Module\n{\n   public void configure(Binder binder)\n   {\n      binder.bind(MyObject.class)\n         .toInstance(new MyObject(\"regular\"));\n\n      binder.bind(MyObject.class).annotatedWith(Special.class)\n         .toInstance(new MyObject(\"special\"));\n   }\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:60(para) 
+msgid "Great, but which Guice injector will be used to inject the dependencies? Well, you need to perform some setup first."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:69(title) 
+msgid "Configuring an injector"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:71(para) 
+msgid "You tell Seam which Guice injector to use by hooking it into the injection property of the Guice initization component in the Seam component descriptor (components.xml):"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:89(para) 
+msgid "<literal>myGuiceInjector</literal> must resolve to a Seam component that implements the Guice <literal>Injector</literal> interface."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:94(para) 
+msgid "Having to create an injector is boiler-plate code, though. What you really want to be able to do is simply hook up Seam to your Guice modules. Fortunately, there is a built-in Seam component that implements the <literal>Injector</literal> interface to do exactly that. You can configure it in the Seam component descriptor with this additional stanza."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:108(para) 
+msgid "Of course you can also use an injector that is already used in other, possibly non-Seam part of you application. That's one of the main motivations for creating this integration. Since the injector is defined with EL expression, you can obtain it in whatever way you like. For instance, you may use the Seam factory component pattern to provide injector."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:115(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuiceInjectorFactory\")\npublic InjectorFactory\n{\n   @Factory(name = \"myGuiceInjector\", scope = APPLICATION, create = true)\n   public Injector getInjector()\n   {\n      // Your code that returns injector    \n   }\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:128(title) 
+msgid "Using multiple injectors"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:130(para) 
+msgid "By default, an injector configured in the Seam component descriptor is used. If you really need to use multiple injectors (AFAIK, you should use multiple modules instead), you can specify different injector for every Seam component in the <literal>@Guice</literal> annotation."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:137(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuicyComponent\")\n at Guice(\"myGuiceInjector\")\npublic class MyGuicyComponent\n{\n   @Inject MyObject myObject;\n   ...\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:147(para) 
+msgid "That's all there is to it! Check out the guice example in the Seam distribution to see the Seam Guice integration in action!"
+msgstr ""
+
+#. Put one translator per line, in the form of NAME <EMAIL>, YEAR1, YEAR2.
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:0(None) 
+msgid "translator-credits"
+msgstr ""
+

Added: trunk/doc/Seam_Reference_Guide/sl-SL/Guice.po
===================================================================
--- trunk/doc/Seam_Reference_Guide/sl-SL/Guice.po	                        (rev 0)
+++ trunk/doc/Seam_Reference_Guide/sl-SL/Guice.po	2009-04-12 05:22:10 UTC (rev 10388)
@@ -0,0 +1,96 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"POT-Creation-Date: 2009-04-12 01:20-0400\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Language-Team: LANGUAGE <LL at li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:6(title) 
+msgid "Guice integration"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:8(para) 
+msgid "Google Guice is a library that provides lightweight dependency injection through type-safe resolution. The Guice integration (part of the Seam IoC module) allows use of Guice injection for all Seam components annotated with the <literal>@Guice</literal> annotation. In addition to the regular bijection that Seam performs (which becomes optional), Seam also delegates to known Guice injectors to satisify the dependencies of the component. Guice may be useful to tie non-Seam parts of large or legacy applications together with Seam."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:17(note) 
+msgid "The Guice integration is bundled in the jboss-seam-ioc library. This dependency is required for all integration techniques covered in this chapter. You will also need the Guice JAR file on the classpath."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:24(title) 
+msgid "Creating a hybrid Seam-Guice component"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:26(para) 
+msgid "The goal is to create a hybrid Seam-Guice component. The rule for how to do this is very simple. If you want to use Guice injection in your Seam component, annotate it with the <literal>@Guice</literal> annotation (after importing the type <literal>org.jboss.seam.ioc.guice.Guice</literal>)."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:33(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuicyComponent\")\n at Guice public class MyGuicyComponent\n{\n   @Inject MyObject myObject;\n   @Inject @Special MyObject mySpecialObject;\n   ...\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:41(para) 
+msgid "This Guice injection will happen on every method call, just like with bijection. Guice injects based on type and binding. To satisify the dependencies in the previous example, you might have bound the following implementations in a Guice module, where <literal>@Special</literal> is an annotation you define in your application."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:48(programlisting) 
+#, no-wrap
+msgid "public class MyGuicyModule implements Module\n{\n   public void configure(Binder binder)\n   {\n      binder.bind(MyObject.class)\n         .toInstance(new MyObject(\"regular\"));\n\n      binder.bind(MyObject.class).annotatedWith(Special.class)\n         .toInstance(new MyObject(\"special\"));\n   }\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:60(para) 
+msgid "Great, but which Guice injector will be used to inject the dependencies? Well, you need to perform some setup first."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:69(title) 
+msgid "Configuring an injector"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:71(para) 
+msgid "You tell Seam which Guice injector to use by hooking it into the injection property of the Guice initization component in the Seam component descriptor (components.xml):"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:89(para) 
+msgid "<literal>myGuiceInjector</literal> must resolve to a Seam component that implements the Guice <literal>Injector</literal> interface."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:94(para) 
+msgid "Having to create an injector is boiler-plate code, though. What you really want to be able to do is simply hook up Seam to your Guice modules. Fortunately, there is a built-in Seam component that implements the <literal>Injector</literal> interface to do exactly that. You can configure it in the Seam component descriptor with this additional stanza."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:108(para) 
+msgid "Of course you can also use an injector that is already used in other, possibly non-Seam part of you application. That's one of the main motivations for creating this integration. Since the injector is defined with EL expression, you can obtain it in whatever way you like. For instance, you may use the Seam factory component pattern to provide injector."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:115(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuiceInjectorFactory\")\npublic InjectorFactory\n{\n   @Factory(name = \"myGuiceInjector\", scope = APPLICATION, create = true)\n   public Injector getInjector()\n   {\n      // Your code that returns injector    \n   }\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:128(title) 
+msgid "Using multiple injectors"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:130(para) 
+msgid "By default, an injector configured in the Seam component descriptor is used. If you really need to use multiple injectors (AFAIK, you should use multiple modules instead), you can specify different injector for every Seam component in the <literal>@Guice</literal> annotation."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:137(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuicyComponent\")\n at Guice(\"myGuiceInjector\")\npublic class MyGuicyComponent\n{\n   @Inject MyObject myObject;\n   ...\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:147(para) 
+msgid "That's all there is to it! Check out the guice example in the Seam distribution to see the Seam Guice integration in action!"
+msgstr ""
+
+#. Put one translator per line, in the form of NAME <EMAIL>, YEAR1, YEAR2.
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:0(None) 
+msgid "translator-credits"
+msgstr ""
+

Added: trunk/doc/Seam_Reference_Guide/ta-IN/Guice.po
===================================================================
--- trunk/doc/Seam_Reference_Guide/ta-IN/Guice.po	                        (rev 0)
+++ trunk/doc/Seam_Reference_Guide/ta-IN/Guice.po	2009-04-12 05:22:10 UTC (rev 10388)
@@ -0,0 +1,96 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"POT-Creation-Date: 2009-04-12 01:20-0400\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Language-Team: LANGUAGE <LL at li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:6(title) 
+msgid "Guice integration"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:8(para) 
+msgid "Google Guice is a library that provides lightweight dependency injection through type-safe resolution. The Guice integration (part of the Seam IoC module) allows use of Guice injection for all Seam components annotated with the <literal>@Guice</literal> annotation. In addition to the regular bijection that Seam performs (which becomes optional), Seam also delegates to known Guice injectors to satisify the dependencies of the component. Guice may be useful to tie non-Seam parts of large or legacy applications together with Seam."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:17(note) 
+msgid "The Guice integration is bundled in the jboss-seam-ioc library. This dependency is required for all integration techniques covered in this chapter. You will also need the Guice JAR file on the classpath."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:24(title) 
+msgid "Creating a hybrid Seam-Guice component"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:26(para) 
+msgid "The goal is to create a hybrid Seam-Guice component. The rule for how to do this is very simple. If you want to use Guice injection in your Seam component, annotate it with the <literal>@Guice</literal> annotation (after importing the type <literal>org.jboss.seam.ioc.guice.Guice</literal>)."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:33(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuicyComponent\")\n at Guice public class MyGuicyComponent\n{\n   @Inject MyObject myObject;\n   @Inject @Special MyObject mySpecialObject;\n   ...\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:41(para) 
+msgid "This Guice injection will happen on every method call, just like with bijection. Guice injects based on type and binding. To satisify the dependencies in the previous example, you might have bound the following implementations in a Guice module, where <literal>@Special</literal> is an annotation you define in your application."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:48(programlisting) 
+#, no-wrap
+msgid "public class MyGuicyModule implements Module\n{\n   public void configure(Binder binder)\n   {\n      binder.bind(MyObject.class)\n         .toInstance(new MyObject(\"regular\"));\n\n      binder.bind(MyObject.class).annotatedWith(Special.class)\n         .toInstance(new MyObject(\"special\"));\n   }\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:60(para) 
+msgid "Great, but which Guice injector will be used to inject the dependencies? Well, you need to perform some setup first."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:69(title) 
+msgid "Configuring an injector"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:71(para) 
+msgid "You tell Seam which Guice injector to use by hooking it into the injection property of the Guice initization component in the Seam component descriptor (components.xml):"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:89(para) 
+msgid "<literal>myGuiceInjector</literal> must resolve to a Seam component that implements the Guice <literal>Injector</literal> interface."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:94(para) 
+msgid "Having to create an injector is boiler-plate code, though. What you really want to be able to do is simply hook up Seam to your Guice modules. Fortunately, there is a built-in Seam component that implements the <literal>Injector</literal> interface to do exactly that. You can configure it in the Seam component descriptor with this additional stanza."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:108(para) 
+msgid "Of course you can also use an injector that is already used in other, possibly non-Seam part of you application. That's one of the main motivations for creating this integration. Since the injector is defined with EL expression, you can obtain it in whatever way you like. For instance, you may use the Seam factory component pattern to provide injector."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:115(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuiceInjectorFactory\")\npublic InjectorFactory\n{\n   @Factory(name = \"myGuiceInjector\", scope = APPLICATION, create = true)\n   public Injector getInjector()\n   {\n      // Your code that returns injector    \n   }\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:128(title) 
+msgid "Using multiple injectors"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:130(para) 
+msgid "By default, an injector configured in the Seam component descriptor is used. If you really need to use multiple injectors (AFAIK, you should use multiple modules instead), you can specify different injector for every Seam component in the <literal>@Guice</literal> annotation."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:137(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuicyComponent\")\n at Guice(\"myGuiceInjector\")\npublic class MyGuicyComponent\n{\n   @Inject MyObject myObject;\n   ...\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:147(para) 
+msgid "That's all there is to it! Check out the guice example in the Seam distribution to see the Seam Guice integration in action!"
+msgstr ""
+
+#. Put one translator per line, in the form of NAME <EMAIL>, YEAR1, YEAR2.
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:0(None) 
+msgid "translator-credits"
+msgstr ""
+

Added: trunk/doc/Seam_Reference_Guide/te-IN/Guice.po
===================================================================
--- trunk/doc/Seam_Reference_Guide/te-IN/Guice.po	                        (rev 0)
+++ trunk/doc/Seam_Reference_Guide/te-IN/Guice.po	2009-04-12 05:22:10 UTC (rev 10388)
@@ -0,0 +1,96 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"POT-Creation-Date: 2009-04-12 01:20-0400\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Language-Team: LANGUAGE <LL at li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:6(title) 
+msgid "Guice integration"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:8(para) 
+msgid "Google Guice is a library that provides lightweight dependency injection through type-safe resolution. The Guice integration (part of the Seam IoC module) allows use of Guice injection for all Seam components annotated with the <literal>@Guice</literal> annotation. In addition to the regular bijection that Seam performs (which becomes optional), Seam also delegates to known Guice injectors to satisify the dependencies of the component. Guice may be useful to tie non-Seam parts of large or legacy applications together with Seam."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:17(note) 
+msgid "The Guice integration is bundled in the jboss-seam-ioc library. This dependency is required for all integration techniques covered in this chapter. You will also need the Guice JAR file on the classpath."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:24(title) 
+msgid "Creating a hybrid Seam-Guice component"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:26(para) 
+msgid "The goal is to create a hybrid Seam-Guice component. The rule for how to do this is very simple. If you want to use Guice injection in your Seam component, annotate it with the <literal>@Guice</literal> annotation (after importing the type <literal>org.jboss.seam.ioc.guice.Guice</literal>)."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:33(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuicyComponent\")\n at Guice public class MyGuicyComponent\n{\n   @Inject MyObject myObject;\n   @Inject @Special MyObject mySpecialObject;\n   ...\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:41(para) 
+msgid "This Guice injection will happen on every method call, just like with bijection. Guice injects based on type and binding. To satisify the dependencies in the previous example, you might have bound the following implementations in a Guice module, where <literal>@Special</literal> is an annotation you define in your application."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:48(programlisting) 
+#, no-wrap
+msgid "public class MyGuicyModule implements Module\n{\n   public void configure(Binder binder)\n   {\n      binder.bind(MyObject.class)\n         .toInstance(new MyObject(\"regular\"));\n\n      binder.bind(MyObject.class).annotatedWith(Special.class)\n         .toInstance(new MyObject(\"special\"));\n   }\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:60(para) 
+msgid "Great, but which Guice injector will be used to inject the dependencies? Well, you need to perform some setup first."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:69(title) 
+msgid "Configuring an injector"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:71(para) 
+msgid "You tell Seam which Guice injector to use by hooking it into the injection property of the Guice initization component in the Seam component descriptor (components.xml):"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:89(para) 
+msgid "<literal>myGuiceInjector</literal> must resolve to a Seam component that implements the Guice <literal>Injector</literal> interface."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:94(para) 
+msgid "Having to create an injector is boiler-plate code, though. What you really want to be able to do is simply hook up Seam to your Guice modules. Fortunately, there is a built-in Seam component that implements the <literal>Injector</literal> interface to do exactly that. You can configure it in the Seam component descriptor with this additional stanza."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:108(para) 
+msgid "Of course you can also use an injector that is already used in other, possibly non-Seam part of you application. That's one of the main motivations for creating this integration. Since the injector is defined with EL expression, you can obtain it in whatever way you like. For instance, you may use the Seam factory component pattern to provide injector."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:115(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuiceInjectorFactory\")\npublic InjectorFactory\n{\n   @Factory(name = \"myGuiceInjector\", scope = APPLICATION, create = true)\n   public Injector getInjector()\n   {\n      // Your code that returns injector    \n   }\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:128(title) 
+msgid "Using multiple injectors"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:130(para) 
+msgid "By default, an injector configured in the Seam component descriptor is used. If you really need to use multiple injectors (AFAIK, you should use multiple modules instead), you can specify different injector for every Seam component in the <literal>@Guice</literal> annotation."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:137(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuicyComponent\")\n at Guice(\"myGuiceInjector\")\npublic class MyGuicyComponent\n{\n   @Inject MyObject myObject;\n   ...\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:147(para) 
+msgid "That's all there is to it! Check out the guice example in the Seam distribution to see the Seam Guice integration in action!"
+msgstr ""
+
+#. Put one translator per line, in the form of NAME <EMAIL>, YEAR1, YEAR2.
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:0(None) 
+msgid "translator-credits"
+msgstr ""
+

Added: trunk/doc/Seam_Reference_Guide/zh-CN/Guice.po
===================================================================
--- trunk/doc/Seam_Reference_Guide/zh-CN/Guice.po	                        (rev 0)
+++ trunk/doc/Seam_Reference_Guide/zh-CN/Guice.po	2009-04-12 05:22:10 UTC (rev 10388)
@@ -0,0 +1,96 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"POT-Creation-Date: 2009-04-12 01:20-0400\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Language-Team: LANGUAGE <LL at li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:6(title) 
+msgid "Guice integration"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:8(para) 
+msgid "Google Guice is a library that provides lightweight dependency injection through type-safe resolution. The Guice integration (part of the Seam IoC module) allows use of Guice injection for all Seam components annotated with the <literal>@Guice</literal> annotation. In addition to the regular bijection that Seam performs (which becomes optional), Seam also delegates to known Guice injectors to satisify the dependencies of the component. Guice may be useful to tie non-Seam parts of large or legacy applications together with Seam."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:17(note) 
+msgid "The Guice integration is bundled in the jboss-seam-ioc library. This dependency is required for all integration techniques covered in this chapter. You will also need the Guice JAR file on the classpath."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:24(title) 
+msgid "Creating a hybrid Seam-Guice component"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:26(para) 
+msgid "The goal is to create a hybrid Seam-Guice component. The rule for how to do this is very simple. If you want to use Guice injection in your Seam component, annotate it with the <literal>@Guice</literal> annotation (after importing the type <literal>org.jboss.seam.ioc.guice.Guice</literal>)."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:33(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuicyComponent\")\n at Guice public class MyGuicyComponent\n{\n   @Inject MyObject myObject;\n   @Inject @Special MyObject mySpecialObject;\n   ...\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:41(para) 
+msgid "This Guice injection will happen on every method call, just like with bijection. Guice injects based on type and binding. To satisify the dependencies in the previous example, you might have bound the following implementations in a Guice module, where <literal>@Special</literal> is an annotation you define in your application."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:48(programlisting) 
+#, no-wrap
+msgid "public class MyGuicyModule implements Module\n{\n   public void configure(Binder binder)\n   {\n      binder.bind(MyObject.class)\n         .toInstance(new MyObject(\"regular\"));\n\n      binder.bind(MyObject.class).annotatedWith(Special.class)\n         .toInstance(new MyObject(\"special\"));\n   }\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:60(para) 
+msgid "Great, but which Guice injector will be used to inject the dependencies? Well, you need to perform some setup first."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:69(title) 
+msgid "Configuring an injector"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:71(para) 
+msgid "You tell Seam which Guice injector to use by hooking it into the injection property of the Guice initization component in the Seam component descriptor (components.xml):"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:89(para) 
+msgid "<literal>myGuiceInjector</literal> must resolve to a Seam component that implements the Guice <literal>Injector</literal> interface."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:94(para) 
+msgid "Having to create an injector is boiler-plate code, though. What you really want to be able to do is simply hook up Seam to your Guice modules. Fortunately, there is a built-in Seam component that implements the <literal>Injector</literal> interface to do exactly that. You can configure it in the Seam component descriptor with this additional stanza."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:108(para) 
+msgid "Of course you can also use an injector that is already used in other, possibly non-Seam part of you application. That's one of the main motivations for creating this integration. Since the injector is defined with EL expression, you can obtain it in whatever way you like. For instance, you may use the Seam factory component pattern to provide injector."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:115(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuiceInjectorFactory\")\npublic InjectorFactory\n{\n   @Factory(name = \"myGuiceInjector\", scope = APPLICATION, create = true)\n   public Injector getInjector()\n   {\n      // Your code that returns injector    \n   }\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:128(title) 
+msgid "Using multiple injectors"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:130(para) 
+msgid "By default, an injector configured in the Seam component descriptor is used. If you really need to use multiple injectors (AFAIK, you should use multiple modules instead), you can specify different injector for every Seam component in the <literal>@Guice</literal> annotation."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:137(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuicyComponent\")\n at Guice(\"myGuiceInjector\")\npublic class MyGuicyComponent\n{\n   @Inject MyObject myObject;\n   ...\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:147(para) 
+msgid "That's all there is to it! Check out the guice example in the Seam distribution to see the Seam Guice integration in action!"
+msgstr ""
+
+#. Put one translator per line, in the form of NAME <EMAIL>, YEAR1, YEAR2.
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:0(None) 
+msgid "translator-credits"
+msgstr ""
+

Added: trunk/doc/Seam_Reference_Guide/zh-TW/Guice.po
===================================================================
--- trunk/doc/Seam_Reference_Guide/zh-TW/Guice.po	                        (rev 0)
+++ trunk/doc/Seam_Reference_Guide/zh-TW/Guice.po	2009-04-12 05:22:10 UTC (rev 10388)
@@ -0,0 +1,96 @@
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\n"
+"POT-Creation-Date: 2009-04-12 01:20-0400\n"
+"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
+"Last-Translator: FULL NAME <EMAIL at ADDRESS>\n"
+"Language-Team: LANGUAGE <LL at li.org>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bit\n"
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:6(title) 
+msgid "Guice integration"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:8(para) 
+msgid "Google Guice is a library that provides lightweight dependency injection through type-safe resolution. The Guice integration (part of the Seam IoC module) allows use of Guice injection for all Seam components annotated with the <literal>@Guice</literal> annotation. In addition to the regular bijection that Seam performs (which becomes optional), Seam also delegates to known Guice injectors to satisify the dependencies of the component. Guice may be useful to tie non-Seam parts of large or legacy applications together with Seam."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:17(note) 
+msgid "The Guice integration is bundled in the jboss-seam-ioc library. This dependency is required for all integration techniques covered in this chapter. You will also need the Guice JAR file on the classpath."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:24(title) 
+msgid "Creating a hybrid Seam-Guice component"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:26(para) 
+msgid "The goal is to create a hybrid Seam-Guice component. The rule for how to do this is very simple. If you want to use Guice injection in your Seam component, annotate it with the <literal>@Guice</literal> annotation (after importing the type <literal>org.jboss.seam.ioc.guice.Guice</literal>)."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:33(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuicyComponent\")\n at Guice public class MyGuicyComponent\n{\n   @Inject MyObject myObject;\n   @Inject @Special MyObject mySpecialObject;\n   ...\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:41(para) 
+msgid "This Guice injection will happen on every method call, just like with bijection. Guice injects based on type and binding. To satisify the dependencies in the previous example, you might have bound the following implementations in a Guice module, where <literal>@Special</literal> is an annotation you define in your application."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:48(programlisting) 
+#, no-wrap
+msgid "public class MyGuicyModule implements Module\n{\n   public void configure(Binder binder)\n   {\n      binder.bind(MyObject.class)\n         .toInstance(new MyObject(\"regular\"));\n\n      binder.bind(MyObject.class).annotatedWith(Special.class)\n         .toInstance(new MyObject(\"special\"));\n   }\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:60(para) 
+msgid "Great, but which Guice injector will be used to inject the dependencies? Well, you need to perform some setup first."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:69(title) 
+msgid "Configuring an injector"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:71(para) 
+msgid "You tell Seam which Guice injector to use by hooking it into the injection property of the Guice initization component in the Seam component descriptor (components.xml):"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:89(para) 
+msgid "<literal>myGuiceInjector</literal> must resolve to a Seam component that implements the Guice <literal>Injector</literal> interface."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:94(para) 
+msgid "Having to create an injector is boiler-plate code, though. What you really want to be able to do is simply hook up Seam to your Guice modules. Fortunately, there is a built-in Seam component that implements the <literal>Injector</literal> interface to do exactly that. You can configure it in the Seam component descriptor with this additional stanza."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:108(para) 
+msgid "Of course you can also use an injector that is already used in other, possibly non-Seam part of you application. That's one of the main motivations for creating this integration. Since the injector is defined with EL expression, you can obtain it in whatever way you like. For instance, you may use the Seam factory component pattern to provide injector."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:115(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuiceInjectorFactory\")\npublic InjectorFactory\n{\n   @Factory(name = \"myGuiceInjector\", scope = APPLICATION, create = true)\n   public Injector getInjector()\n   {\n      // Your code that returns injector    \n   }\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:128(title) 
+msgid "Using multiple injectors"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:130(para) 
+msgid "By default, an injector configured in the Seam component descriptor is used. If you really need to use multiple injectors (AFAIK, you should use multiple modules instead), you can specify different injector for every Seam component in the <literal>@Guice</literal> annotation."
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:137(programlisting) 
+#, no-wrap
+msgid "@Name(\"myGuicyComponent\")\n at Guice(\"myGuiceInjector\")\npublic class MyGuicyComponent\n{\n   @Inject MyObject myObject;\n   ...\n}"
+msgstr ""
+
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:147(para) 
+msgid "That's all there is to it! Check out the guice example in the Seam distribution to see the Seam Guice integration in action!"
+msgstr ""
+
+#. Put one translator per line, in the form of NAME <EMAIL>, YEAR1, YEAR2.
+#: doc/Seam_Reference_Guide/en-US/Guice.xml:0(None) 
+msgid "translator-credits"
+msgstr ""
+


