<html><head>
<meta HTTP-EQUIV="content-type" CONTENT="text/html; charset=UTF-8">
</head>
<body>

<h2>Documentation - Setup Guides</h2>

<p><em>This page was last updated on $Date: 2009/06/15 10:17:12 $</em>.</p>
<!--
<h3>Recent Additions</h3>
<ul>
	<li><strong>August 16, 2006</strong> - New Revision A_10 of Setup Guide for OpenOffice.org 2.0 in Slovenian</li>
	<li><strong>June 20, 2006</strong> - New Revision A_10 of Setup Guide for OpenOffice.org 2.0 in Indonesian</li>
	<li><strong>June 13, 2006</strong> - New edition of Setup Guide with more MacOS instructions.</li>
	<li><strong>April 04, 2006</strong> - new Revision of Setup Guide for OpenOffice.org 2.0 in French and German.</li>
	<li><strong>March 11, 2006</strong> - Revision A_07 of Setup Guide for OpenOffice.org 2.0 in Indonesian.</li>
	<li><strong>March 07, 2006</strong> - Revision A_07 of Setup Guide for OpenOffice.org 2.0 in English and A4 page size.</li>
	<li><strong>February 20, 2006</strong> - Initial version of Setup Guide for OpenOffice.org 2.0 in Japanese.</li>
	<li><strong>February 16, 2006</strong> - Initial version of Setup Guide for OpenOffice.org 2.0 in Slovenian.</li>
         <li><strong>January 6, 2006</strong> - Initial version of Setup Guide for OpenOffice.org 2.0 in Dansk.</li>
         <li><strong>January 2, 2006</strong> - Initial version of Setup Guide for OpenOffice.org 2.0 in Indonesian.</li>
         <li><strong>November 26, 2005</strong> - Initial version of Setup Guide for OpenOffice.org 2.0 in Brazilian Portugeuse.</li>
	<li><strong>October 23, 2005</strong> - Initial version of Setup Guide for OpenOffice.org 2.0 in English and A4 page size.</li>
         <li><strong>October 16, 2005</strong> - Initial version of Setup Guide for OpenOffice.org 2.0 in English.</li>
         <li><strong>September 20, 2005</strong> - added draft version of Setup Guide for OpenOffice.org 2.0 in French.</li>

</ul>
-->
<h3>Mission Statement</h3>

<p>To provide comprehensible documentation in multiple languages to guide users through the setup process of OpenOffice.org.</p>

<h3>Summary</h3>

<p>This area provides the source files (Writer *.sxw files and image files), the <acronym title="Portable Document Format">PDF</acronym> files, and the compressed .zip files (source and PDF files) for the OpenOffice.org Setup Guides. The English version of the Setup Guide is the master document. Source files are available for the following OpenOffice.org releases:</p>

<ul>
        <li>OpenOffice.org 3.x (Draft not yet available)</li>
	<li><a href="#12" title="OpenOffice 2.0 Setup Guide">OpenOffice.org 2.0</a> (current release)</li>
	<li><a href="#11" title="OpenOffice 1.1 Setup Guide">OpenOffice.org 1.1</a></li>
	<li><a href="#10x" title="OpenOffice 1.0x Setup Guide">OpenOffice.org 1.0x</a></li>
</ul>

<div style="border: 1px dotted red; padding: 0px 5px; background: rgb(255, 255, 204)">
<p>If you would like to participate in the localization of the Setup Guide into your own language, please contact <strong>Scott Carr</strong> at: <a href="&#109;&#97;&#105;&#108;&#116;&#111;&#58;&#107;&#99;&#97;&#114;&#114;&#64;&#111;&#112;&#101;&#110;&#111;&#102;&#102;&#105;&#99;&#101;&#46;&#111;&#114;&#103;">&#107;&#99;&#97;&#114;&#114;&#64;&#111;&#112;&#101;&#110;&#111;&#102;&#102;&#105;&#99;&#101;&#46;&#111;&#114;&#103;</a>.</dd>
If you attach a finished guide to an issue, please ensure that you enter this address to the <strong>Add CC</strong> box in the Issue form.</p>
</div>

<br />

<!-- Setup Guides for OpenOffice.org 2.x -->
<a name="12"></a>
<table cellpadding="4" cellspacing="1" bgcolor="#ffffff" width="100%">
		<caption><h3 style="padding: 4px; background: #00315a; color: #ffffff">Setup Guides for OpenOffice.org 2.x</h3></caption>
	<tbody>
	<tr bgcolor="#99ccff"><font color="#00315a">
  		<th width="175">Language</th>
  		<th width="150">Links</th>
  		<th>Revision - Status</th>
  		<th>Remarks - Required Changes</th>
			</font>
	</tr>

	<tr bgcolor="#f0f0f0" valign="top" >
		<td><a name="en"></a><strong>English</strong><br /><em>updated  $Date: 2009/06/15 10:17:12 $</td>
<!--                <td>
                        <ul>
                                <li>source files</li>
                                <li>pdf</li>
                                <li>zip</a></font></li>
                        </ul>
                </td> -->
  		<td>
			<ul>
<!--				<li><a href="/source/browse/documentation/www/setup_guide2/2.x/en" title="Writer .sxw file and images">source files</a></li> -->
				<li><a href="http://documentation.openoffice.org/source/browse/documentation/www/setup_guide2/2.x/en/" title="Writer .odt file with linked images">source files</a></li>
				<li><a href="2.x/en/SETUP_GUIDE.pdf" title="PDF version of the Setup Guide. This is the version for endusers.">pdf (US letter)</a></li>
				<li><a href="2.x/en/SETUP_GUIDE_A4.pdf" title="PDF version of the Setup Guide. This is the version for A4 endusers.">pdf (A4)</a></li>
				<li><a href="2.x/en/SETUP_GUIDE.zip" title="ZIP version of the Setup Guide. This is the version for endusers.">zip</a></li>
<!--				<li><a href="2.x/en/SETUP_GUIDE.zip" title="The source files and the PDF file of the Setup Guide stored in a compressed zip archive.">zip</a></font></li> -->
			</ul>
		</td>
		<td><strong>Revision A</strong><br /></td>
  		<td>This is the master document. The release is as complete as possible. If you can help, please add your comments/changes to issue <a href="http://www.openoffice.org/issues/show_bug.cgi?id=37513">37513</a></td>
	</tr>

         <tr bgcolor="#f0f0f0" valign="top" >
		<td><a name="en"></a><strong>Brazilian Portuguese</strong><br /><em>updated  frequently</em</td>
<!--                <td>
                        <ul>
                                <li>source files</li>
                                <li>pdf</li>
                                <li>zip</a></font></li>
                        </ul>
                </td> -->
  		<td>
			<ul>
<!--				<li><a href="/source/browse/documentation/www/setup_guide2/2.x/de" title="Writer .sxw file and images">source files</a></li> -->
				<li><a href="2.x/pt/SETUP_GUIDE_PT-BR.odt" title="Writer .sxw file with embedded images">source files</a></li>
				<li><a href="2.x/pt/SETUP_GUIDE_PT-BR.pdf" title="PDF version of the Brazilian Setup Guide. This is the version for endusers.">pdf</a></li>
				<li><a href="2.x/pt/SETUP_GUIDE_PT-BR.zip" title="The source files and the PDF file of the Brazilian Setup Guide stored in a compressed zip archive.">zip</a></li>
			</ul>
		</td>
		<td><strong>Revision A </strong><br /><font color=red> finished</font></td>
  		<td>This is the Brazilian Portuguese language document. The draft is incomplete but serviceable. If you can help, please add your comments/changes to issue <a href="http://www.openoffice.org/issues/show_bug.cgi?id=37513">37513</a></td>
	</tr>
 	<tr bgcolor="#f0f0f0" valign="top" >
                <td><a name="fr"></a><strong>French</strong><br /><em> started</em</td>
<!--                <td>
                        <ul>
                                <li>source files</li>
                                <li>pdf</li>
                                <li>zip</a></font></li>
                        </ul>
                </td> -->
                <td>
                        <ul>
<!--                            <li><a href="/source/browse/documentation/www/setup_guide2/2.x/en" title="Writer .sxw file and images">source files</a></li> -->                                <li><a href="2.x/fr/SETUP_GUIDE_FR.odt" title="Writer .odt file with embedded images">source files</a></li>
                                <li><a href="2.x/fr/SETUP_GUIDE_FR.pdf" title="PDF version of the Setup Guide. This is the version for endusers.">pdf</a></li>
<!--                            <li><a href="2.x/fr/SETUP_GUIDE.zip" title="The source files and the PDF file of the Setup Guide stored in a compressed zip archive.">zip</a></font></li> -->
                        </ul>
                </td>
                <td><strong>Revision A (Draft)</strong><br /><font color=red> unfinished</font></td>
                <td>This is the French language document. The draft is incomplete but serviceable. If you can help, please add your comments/changes to issue <a href="http://www.openoffice.org/issues/show_bug.cgi?id=37513">37513</a></td>
        </tr>

 	<tr bgcolor="#f0f0f0" valign="top" >
                <td><a name="da"></a><strong>Dansk</strong><br /><em> started</em</td>
<!--                <td>
                        <ul>
                                <li>source files</li>
                                <li>pdf</li>
                                <li>zip</a></font></li>
                        </ul>
                </td> -->
                <td>
                        <ul>
                                <li><a href="http://doc.oooforum.dk/Setup.odt" title="Writer .odt file with embedded images">source files</a></li>
                                <li><a href="http://doc.oooforum.dk/Setup.pdf" title="PDF version of Setup Guide. This is the version for endusers.">pdf (full)</a></li>
                                <li><a href="http://da.openoffice.org/doc/Quickinstall.pdf" title="PDF version of the Dansk Quickinstall Guide.">pdf (quick)</a></li>
<!--                            <li><a href="2.x/fr/SETUP_GUIDE.zip" title="The source files and the PDF file of the Setup Guide stored in a compressed zip archive.">zip</a></font></li> -->
                        </ul>
                </td>
                <td><strong>Revision A (Draft)</strong><br /><font color=red> unfinished</font></td>
                <td>This is the Dansk language document. The draft is incomplete but serviceable. If you can help, please add your comments/changes to issue <a href="http://www.openoffice.org/issues/show_bug.cgi?id=37513">37513</a></td>
        </tr>
	<tr bgcolor="#f0f0f0" valign="top" >
		<td><a name="de"></a><strong>German</strong><br /><em>updated  frequently</em</td>
<!--                <td>
                        <ul>
                                <li>source files</li>
                                <li>pdf</li>
                                <li>zip</a></font></li>
                        </ul>
                </td> -->
  		<td>
			<ul>
<!--				<li><a href="/source/browse/documentation/www/setup_guide2/2.x/de" title="Writer .sxw file and images">source files</a></li> -->
				<li><a href="2.x/de/installations_handbuch.sxw" title="Writer .sxw file with linked images">source files</a></li>
				<li><a href="2.x/de/installations_handbuch.pdf" title="PDF version of the German Setup Guide. This is the version for endusers.">pdf</a></li>
				<li><a href="2.x/de/installations_handbuch.zip" title="The source files of the German Setup Guide stored in a compressed zip archive.">zip</a></font></li>
			</ul>
		</td>
		<td><strong>Revision A </strong><br /><font color=red> finished</font></td>
  		<td>This is the German language document. The release is as complete as possible. If you can help, please add your comments/changes to issue <a href="http://www.openoffice.org/issues/show_bug.cgi?id=49355">49355</a></td>
	</tr>
         <tr bgcolor="#f0f0f0" valign="top" >
		<td><a name="in"></a><strong>Indonesian</strong><br /><em>updated  frequently</em</td>
  		<td>
			<ul>
				<li><a href="2.x/id/SETUP_GUIDE_ID.pdf" title="PDF version of the Indonesian Setup Guide. This is the version for endusers.">pdf</a></li>
				<li><a href="2.x/id/SETUP_GUIDE_ID.zip" title="ZIP">source files</a></li>
			</ul>
		</td>
		<td><strong>Revision A</strong><br /><font color=red> finished</font></td>
  		<td>This is the Indonesian language document. The edition is complete and serviceable. If you can help, please add your comments/changes to issue <a href="http://www.openoffice.org/issues/show_bug.cgi?id=56753">56753</a></td>
	</tr>
<tr bgcolor="#f0f0f0" valign="top" >
		<td><a name="in"></a><strong>Japanese</strong><br /><em>updated  frequently</em</td>
  		<td>
			<ul>
				<li><a href="2.x/ja/SETUP_GUIDE_A4J.pdf" title="PDF version of the Japanese Setup Guide. This is the version for endusers.">pdf</a></li>
				<li><a href="2.x/ja/SETUP_GUIDE_A4J.odt" title="ODT">source files</a></li>
			</ul>
		</td>
		<td><strong>Revision A</strong><br /><font color=red> finished</font></td>
  		<td>This is the Japanes language document. The edition is complete and serviceable. If you can help, please add your comments/changes to issue <a href="http://www.openoffice.org/issues/show_bug.cgi?id=37513">37513</a></td>
	</tr>
         <tr bgcolor="#f0f0f0" valign="top" >
		<td><a name="in"></a><strong>Slovenian</strong><br /><em>updated  frequently</em</td>
  		<td>
			<ul>
				<li><a href="2.x/sl/Namestitveni_vodnik_OpenOffice.org_2.0_sl_A4.pdf" title="PDF version of the Slovenian Setup Guide. This is the version for endusers.">pdf</a></li>
				<li><a href="2.x/sl/Namestitveni_vodnik_OpenOffice.org_2.0_sl_A4.odt" title="ODT">source files</a></li>
			</ul>
		</td>
		<td><strong>Revision A</strong><br /><font color=red> finished</font></td>
  		<td>This is the Slovenian language document. The edition is complete and serviceable. If you can help, please add your comments/changes to issue <a href="http://www.openoffice.org/issues/show_bug.cgi?id=56753">56753</a></td>
	</tr>
 </table>

<br clear="all" />
<!-- Setup Guides for OpenOffice.org 1.1 -->
<a name="11"></a>
<table cellpadding="4" cellspacing="1" bgcolor="#ffffff" width="100%">
		<caption><h3 style="padding: 4px; background: #00315a; color: #ffffff">Setup Guides for OpenOffice.org 1.1</h3></caption>
	<tbody>
	<tr bgcolor="#99ccff"><font color="#00315a">
  		<th width="175">Language</th>
  		<th width="150">Links</th>
  		<th>Revision - Status</th>
  		<th>Remarks - Required Changes</th>
			</font>
	</tr>
	<tr bgcolor="#f0f0f0" valign="top" >
		<td><a name="en"></a><strong>English</strong><br /><em>updated November 18 2004</em</td>
  		<td>
			<ul>
				<li><a href="/source/browse/documentation/www/setup_guide2/1.1.x/en" title="Writer .sxw file and images">source files</a></li>
				<li><a href="1.1.x/en/SETUP_GUIDE.pdf" title="PDF version of the Setup Guide. This is the version for endusers.">pdf</a></li>
				<li><a href="1.1.x/en/SETUP_GUIDE.zip" title="The source files and the PDF file of the Setup Guide stored in a compressed zip archive.">zip</a></font></li>
			</ul>
		</td>
		<td><strong>Revision B (Master)</strong><br />finished</td>
  		<td>This is the master document.</td>
	</tr>
	<tr bgcolor="#e0eeee" valign="top" >
		<td><a name="cn"></a>Chinese (simplified)</td>
  		<td>
			<ul>
				<li><a href="/source/browse/documentation/www/setup_guide2/1.1.x/zh-CN" title="Writer .sxw file and images">source files</a></li>
				<li><a href="1.1.x/zh-CN/SETUP_GUIDE.pdf" title="PDF version of the Setup Guide. This is the version for endusers.">pdf</a></li>
				<li><a href="1.1.x/zh-CN/SETUP_GUIDE.zip" title="The source files and the PDF file of the Setup Guide stored in a compressed zip archive.">zip</a></font></li>
			</ul>
		</td>
		<td><font color="#ff0000">unfinished</font></td>
  		<td>The following changes need to be made:
			<ol>
				<li>Replace StarOffice screen shots with OpenOffice.org screen shots.</li>
				<li>Remove the sections that mention the StarOffice installation CD, the Adabas database, as well as StarOffice feedback page.</li>
				<li>Review final version of the guide.</li>
			</ol>
		</td>
	</tr>
	<tr bgcolor="#e0eeee" valign="top" >
		<td><a name="tw"></a>Chinese (traditional)</td>
  		<td>
			<ul>
				<li><a href="/source/browse/documentation/www/setup_guide2/1.1.x/zh-TW" title="Writer .sxw file and images">source files</a></li>
				<li><a href="1.1.x/zh-TW/SETUP_GUIDE.pdf" title="PDF version of the Setup Guide. This is the version for endusers.">pdf</a></li>
				<li><a href="1.1.x/zh-TW/SETUP_GUIDE.zip" title="The source files and the PDF file of the Setup Guide stored in a compressed zip archive.">zip</a></font></li>
			</ul>
		</td>
		<td><font color="#ff0000">unfinished</font></td>
  		<td>The following changes need to be made:
			<ol>
				<li>Replace StarOffice screen shots with OpenOffice.org screen shots.</li>
				<li>Remove the sections that mention the StarOffice installation CD, the Adabas database, as well as StarOffice feedback page.</li>
	 			<li>Review final version of the guide.</li>
			</ol>
		</td>
	</tr>
<!-- czech -->
	<tr bgcolor="#f0f0f0" valign="top">
		<td><a id="cz"></a><strong>Czech</strong></td>
      <td>
			<ul>
			<li><a href="/source/browse/documentation/www/setup_guide2/1.1.x/cs/" title="Writer .sxw file and images">source files</a></li>
			<li><a href="1.1.x/cs/ooo_setup_czech.pdf" title="PDF version of the Setup Guide. This is the version for endusers.">pdf</a></li>
			<li><a href="1.1.x/cs/ooo_setup_czech.zip" title="The source files and the PDF file of the Setup Guide stored in a compressed zip archive.">zip</a></li>
			</ul>
		</td>
      <td><strong>Revision A</strong><br />finished</td>
      <td>Thanks to the <strong>Czech Localization Team</strong>.</td>
	</tr>
	<tr bgcolor="#f0f0f0" valign="top" >
		<td><a name="fr"></a><strong>French</strong><br /><em>updated Feb 27, 2004</em></td>
  		<td>
			<ul>
				<li><a href="/source/browse/documentation/www/setup_guide2/1.1.x/fr" title="Writer .sxw file and images">source files</a></li>
				<li><a href="1.1.x/fr/OO_SETUP_GUIDE.pdf" title="PDF version of the Setup Guide. This is the version for endusers.">pdf</a></li>
				<li><a href="1.1.x/fr/SETUP_GUIDE.zip" title="The source files and the PDF file of the Setup Guide stored in a compressed zip archive.">zip</a></li>
			</ul>
		</td>
		<td><strong>Revision B</strong><br />finished</td>
  		<td>Thanks to <strong>Sophie Gautier</strong>.</td>
	</tr>
	<tr bgcolor="#f0f0f0" valign="top">
		<td><a name="de"></a><strong>German</strong><br /><em>updated Aug 21, 2003</em></td>
  		<td>
			<ul>
			<li><a href="/source/browse/documentation/www/setup_guide2/1.1.x/de" title="Writer .sxw file and images">source files</a></li>
			<li><a href="1.1.x/de/SETUP_GUIDE.PDF" title="PDF version of the Setup Guide. This is the version for endusers.">pdf</a></li>
			<li><a href="1.1.x/de/SETUP_GUIDE.zip" title="The source files and the PDF file of the Setup Guide stored in a compressed zip archive.">zip</a></li>
			</ul>
		</td>
		<td><strong>Revision B</strong><br />finished</td>
  		<td>Thanks to <strong>Andre Schnabel</strong>, <strong>Andreas Mantke</strong>, and <strong>Helga Fischer</strong>.</td>
	</tr>

	<tr bgcolor="#f0f0f0" valign="top">
		<td><a name="gr"></a><strong>Greek</strong><br /><em>updated Aug, 19 2004</em></td>
  		<td>
			<ul>
			<li><a href="1.1.x/gr/SETUP_GUIDE.pdf" title="PDF version of the Setup Guide. This is the version for endusers.">pdf</a></li>
			</ul>
		</td>
		<td><strong>Revision D</strong><br />finished</td>
  		<td>Thanks to <strong>izone</strong>.</td>
	</tr>

<tr bgcolor="#f0f0f0" valign="top" >
		<td><a name="id"></a><strong>Indonesian</strong><br /><em>updated Dec 17, 2003</em></td>
  		<td>
			<ul>
				<li><a href="/source/browse/documentation/www/setup_guide2/1.1.x/id" title="Writer .sxw file and images">source files</a></li>
				<li><a href="1.1.x/id/SETUP_GUIDE.pdf" title="PDF version of the Setup Guide. This is the version for endusers.">pdf</a></li>
				<li><a href="1.1.x/id/SETUP_GUIDE.zip" title="The source files and the PDF file of the Setup Guide stored in a compressed zip archive.">zip</a></li>
			</ul>
		</td>
		<td><strong>Revision A</strong><br />finished</td>
  		<td>Thanks to <strong>Willy Sudiarto Raharjo</strong>.</td>
	</tr>
	<tr bgcolor="#f0f0f0" valign="top" >
		<td><a name="it"></a><strong>Italian</strong><br /><em>updated Aug 27, 2003</em></td>
  		<td>
			<ul>
				<li><a href="/source/browse/documentation/www/setup_guide2/1.1.x/it" title="Writer .sxw file and images">source files</a></li>
				<li><a href="1.1.x/it/SETUP_GUIDE.pdf" title="PDF version of the Setup Guide. This is the version for endusers.">pdf</a></li>
				<li><a href="1.1.x/it/SETUP_GUIDE.zip" title="The source files and the PDF file of the Setup Guide stored in a compressed zip archive.">zip</a></li>
			</ul>
		</td>
		<td><strong>Revision A</strong><br /><font color="#ff0000">unfinished</font></td>
  		<td>Thanks to <strong>Andrea Sanavia</strong><br />The following changes still need to be made:
			<ol>
				<li>Remove the sections that mention the StarOffice installation CD, the Adabas database, as well as StarOffice feedback page.</li>
			</ol>
		</td>
	</tr>
	<tr bgcolor="#f0f0f0" valign="top" >
		<td><a name="ja"></a><strong>Japanese</strong><br><em>updated Jun 09, 2004/em></td>
  		<td>
			<ul>
				<li><a href="/source/browse/documentation/www/setup_guide2/1.1.x/ja" title="Writer .sxw file and images">source files</a></li>
				<li><a href="1.1.x/ja/SETUP_GUIDE.pdf" title="PDF version of the Setup Guide. This is the version for endusers.">pdf</a></li>
				<li><a href="1.1.x/ja/SETUP_GUIDE.zip" title="The source files and the PDF file of the Setup Guide stored in a compressed zip archive.">zip</a></li>
			</ul>
		</td>
		<td><strong>Revison A</strong></td>
		<td>Thanks to the <strong>Japanese Localization Team</strong>.</td>

	</tr>
	<tr bgcolor="#f0f0f0" valign="top" >
		<td><a name="ko"></a><strong>Korean</strong></td>
  		<td>
			<ul>
				<li><a href="/source/browse/documentation/www/setup_guide2/1.1.x/ko" title="Writer .sxw file and images">source files</a></li>
				<li><a href="1.1.x/ko/SETUP_GUIDE.pdf" title="PDF version of the Setup Guide. This is the version for endusers.">pdf</a></li>
				<li><a href="1.1.x/ko/SETUP_GUIDE.zip" title="The source files and the PDF file of the Setup Guide stored in a compressed zip archive.">zip</a></li>
			</ul>
		</td>
		<td><strong>Revision A</strong><br />finished</td>
  	<td>Thanks to <strong>Jeongkyu Kim</strong>.</td>
	</tr>
	<tr bgcolor="#f0f0f0" valign="top">
		<td><a name="pt"></a><strong>Portuguese</strong><br /><em>updated Aug 21, 2003</em></td>
  		<td>
			<ul>
				<li><a href="/source/browse/documentation/www/setup_guide2/1.1.x/pt" title="Writer .sxw file and images">source files</a></li>
				<li><a href="1.1.x/pt/SETUP_GUIDE.pdf" title="PDF version of the Setup Guide. This is the version for endusers.">pdf</a></li>
				<li><a href="1.1.x/pt/SETUP_GUIDE.zip" title="The source files and the PDF file of the Setup Guide stored in a compressed zip archive.">zip</a></li>
			</ul>
		</td>
		<td><strong>Revision A</strong><br /><font color="#ff0000">unfinished</font></td>
  		<td>Thanks to <strong>Pedro Pinto</strong> for localizing this guide and <strong>Vitor Domingos</strong> for the reviewing it.<br />
			The following changes still need to be made:
			<ol>
				<li>Replace StarOffice screen shots with OpenOffice.org screen shots.</li>
			</ol>
		</td>
	</tr>
	<tr bgcolor="#f0f0f0" valign="top" >
		<td><a name="es"></a><strong>Spanish</strong><br /><em>updated June 15, 2004</em></td>
  		<td>
			<ul>
				<li><a href="/source/browse/documentation/www/setup_guide2/1.1.x/es" title="Writer .sxw file and images">source files</a></li>
				<li><a href="1.1.x/es/SETUP_GUIDE.pdf" title="PDF version of the Setup Guide. This is the version for endusers.">pdf</a></li>
				<li><a href="1.1.x/es/SETUP_GUIDE.zip" title="The source files and the PDF file of the Setup Guide stored in a compressed zip archive.">zip</a></li>
			</ul>
		</td>
		<td><strong>Revision A</strong><br />finished</td>
  		<td>Thanks to <strong>Jos&eacute;  Manuel Mac&iacute;as</strong>.</td>
	</tr>
	</tbody>
</table>

<br clear="all" />

<!-- Setup Guides for OpenOffice.org 1.0.x -->
<table cellpadding="4" cellspacing="1" bgcolor="#ffffff" width="100%">

<caption><a name="10x"></a><h3 style="padding: 4px; background: #00315a; color: #ffffff">Setup Guides for OpenOffice.org 1.0.x</h3></caption>
	<tbody>
  <tr bgcolor="#99ccff"><font color="#00315a">
  		<th width="175">Language</th>
  		<th width="150">Links</th>
  		<th>Revision - Status</th>
  		<th>Remarks - Required Changes</th>
			</font>
	</tr>
	<tr bgcolor="#f0f0f0" valign="top">
		<td><strong>English</strong></td>
  		<td>
			<ul>
				<li><a href="/source/browse/documentation/www/setup_guide2/1.0.x/en/" title="Writer .sxw file and images">source files</a></li>
				<li><a href="1.0.x/en/ooo_setup_english.pdf" title="PDF version of the Setup Guide. This is the version for endusers.">pdf</a></li>
				<li><a href="1.0.x/en/ooo_setup_english.zip">zip</a></li>
			</ul>
		</td>
		<td><strong>Revision D</strong> (Master)<br />finished</td>
  		<td>This is the master document.<br />All changes should be reflected here.</td>
	</tr>
		<tr bgcolor="#f0f0f0" valign="top">
		<td><strong>German</strong></td>
 		<td>
		<ul>
			<li><a href="/source/browse/documentation/www/setup_guide2/1.0.x/de/" title="Writer .sxw file and images">source files</a></li>
			<li><a href="1.0.x/de/ooo_setup_german.pdf" title="PDF version of the Setup Guide. This is the version for endusers.">pdf</a></li>
		</ul>
		</td>
		<td><strong>Revision D</strong><br />finished</td>
		<td>&nbsp;</td>
	</tr>
	<tr bgcolor="#f0f0f0" valign="top">
		<td><strong>French</strong></td>
		<td>
		<ul>
		<li><a href="/source/browse/documentation/www/setup_guide2/1.0.x/fr/" title="Writer .sxw file and images">source files</a></li>
		<li><a href="1.0.x/fr/ooo_setup_french.pdf" title="PDF version of the Setup Guide. This is the version for endusers.">pdf</a></li>
		</ul>
		</td>
  		<td><strong>Revision D</strong><br />finished</td>
		<td>&nbsp;</td>
	</tr>
	<tr bgcolor="#f0f0f0" valign="top">
		<td><strong>Dutch</strong></td>
      <td>
			<ul>
			<li><a href="/source/browse/documentation/www/setup_guide2/1.0.x/nl/" title="Writer .sxw file and images">source files</a></li>
			<li><a href="1.0.x/nl/ooo_setup_dutch.pdf" title="PDF version of the Setup Guide. This is the version for endusers.">pdf</a></li>
			</ul>
		</td>
      <td><strong>Revision D</strong><br />finished</td>
		<td>Thanks to <strong>Arthur Buijs</strong> for localizing this guide.</td>
	</tr>
	<tr bgcolor="#f0f0f0" valign="top">
		<td><strong>Italian</strong></td>
		<td>
		<ul>
		<li><a href="/source/browse/documentation/www/setup_guide2/1.0.x/it/" title="Writer .sxw file and images">source files</a></li>
		<li><a href="1.0.x/it/ooo_setup_italian.pdf" title="PDF version of the Setup Guide. This is the version for endusers.">pdf</a></li>
		</ul>
		</td>
		<td><strong>Revision D</strong><br />finished</td>
		<td>&nbsp;</td>
	</tr>
	<tr bgcolor="#f0f0f0" valign="top">
		<td><strong>Czech</strong></td>
      <td>
			<ul>
			<li><a href="/source/browse/documentation/www/setup_guide2/1.0.x/cs/" title="Writer .sxw file and images">source files</a></li>
			<li><a href="1.0.x/cs/ooo_setup_czech.pdf" title="PDF version of the Setup Guide. This is the version for endusers.">pdf</a></li>
			</ul>
		</td>
      <td><strong>Revision D</strong><br />finished</td>
      <td>Thanks to the <strong>Czech Localization Team</strong>.</td>
	</tr>
	<tr bgcolor="#f0f0f0" valign="top">
		<td><strong>Japanese</strong></td>
		<td>
			<ul>
			<li><a href="/source/browse/documentation/www/setup_guide2/1.0.x/ja/" title="Writer .sxw file and images">source files</a></li>
			<li><a href="1.0.x/ja/ooo_setup_japanese.pdf" title="PDF version of the Setup Guide. This is the version for endusers.">pdf</a></li>
			</ul>
		</td>
      <td><strong>Revision D</strong><br />finished</td>
  		<td>Thanks to the <strong>Japanese Localization Team</strong>.</td>
	</tr>
	<tr bgcolor="#f0f0f0" valign="top">
		<td><strong>Hungarian</strong></td>
		<td>
		<ul>
		<li><a href="/source/browse/documentation/www/setup_guide2/1.0.x/hu/" title="Writer .sxw file and images">source files</a></li>
		<li><a href="1.0.x/hu/ooo_setup_hungarian.pdf" title="PDF version of the Setup Guide. This is the version for endusers.">pdf</a></li>
		</ul>
		</td>
    <td><strong>Revision D</strong><br />finished</td>
  	<td>Thanks to <strong>Andr&aacute;s T&iacute;m&aacute;r</strong>.</td>
	</tr>
	<tr bgcolor="#f0f0f0" valign="top">
		<td><strong>Danish</strong></td>
		<td>
		<ul>
		<li><a href="/source/browse/documentation/www/setup_guide2/1.0.x/da/" title="Writer .sxw file and images">source files</a></li>
		<li><a href="1.0.x/da/ooo_setup_danish.pdf" title="PDF version of the Setup Guide. This is the version for endusers.">pdf</a></li>
		</ul>
		</td>
    <td><strong>Revision D</strong><br />finished</td>
  	<td>Thanks to <strong>Lars J&oslash;rgen Helbo</strong>.</td>
	</tr>
	<tr bgcolor="#e0eeee" valign="top" >
		<td>Spanish</td>
		<td>
		<ul>
		<li><a href="/source/browse/documentation/www/setup_guide2/1.0.x/es/" title="Writer .sxw file and images">source files</a></li>
		</ul>
		</td>
		<td><font color="#ff0000">unfinished</font></td>
		<td>The following changes need to be made:
		<ol>
			<li>Replace StarOffice screen shots with OpenOffice.org screen shots.</li>
			<li>Remove sections that do not apply to OpenOffice.org.</li>
 			<li>Review final version of the guide.</li>
		</ol>
		</td>
	</tr>
	<tr bgcolor="#e0eeee" valign="top" >
		<td>Korean</td>
		<td>
		<ul>
		<li><a href="/source/browse/documentation/www/setup_guide2/1.0.x/ko/" title="Writer .sxw file and images">source files</a></li>
		</ul>
		</td>
		<td><font color="#ff0000">unfinished</font></td>
		<td>The following changes need to be made:
		<ol>
			<li>Replace StarOffice screen shots with OpenOffice.org screen shots.</li>
			<li>Remove sections that do not apply to OpenOffice.org.</li>
			<li>Review final version of the guide.</li>
		</ol>
		</td>
	</tr>
	<tr bgcolor="#e0eeee" valign="top" >
		<td>Chinese (simplified)</td>
		<td>
		<ul>
		<li><a href="/source/browse/documentation/www/setup_guide2/1.0.x/zh-CN/" title="Writer .sxw file and images">source files</a></li>
		</ul>
		</td>
		<td><font color="#ff0000">unfinished</font></td>
		<td>The following changes need to be made:
		<ol>
			<li>Replace StarOffice screen shots with OpenOffice.org screen shots.</li>
			<li>Remove sections that do not apply to OpenOffice.org.</li>
			<li>Review final version of the guide.</li>
		</ol>
		</td>
	</tr>
	<tr bgcolor="#e0eeee" valign="top" >
		<td>Chinese (traditional)</td>
		<td>
		<ul>
		<li><a href="/source/browse/documentation/www/setup_guide2/1.0.x/zh-TW/" title="Writer .sxw file and images">source files</a></li>
		</ul>
		</td>
		<td><font color="#ff0000">unfinished</font></td>
		<td>The following changes need to be made:
		<ol>
			<li>Replace StarOffice screen shots with OpenOffice.org screen shots.</li>
			<li>Remove sections that do not apply to OpenOffice.org.</li>
			<li>Review final version of the guide.</li>
		</ol>
		</td>
	</tr>
	<tr bgcolor="#e0eeee" valign="top" >
		<td>Thai</td>
		<td>
		<ul>
		<li><a href="/source/browse/documentation/www/setup_guide2/1.0.x/th/" title="Writer .sxw file and images">source files</a></li>
		</ul>
		</td>
		<td><font color="#ff0000">unfinished</font></td>
		<td>First version thanks to <strong>Arthit Suriyawongkul</strong>.<br />The following changes need to be made:
		<ol>
			<li>Replace StarOffice screen shots with OpenOffice.org screen shots.</li>
			<li>Remove sections that do not apply to OpenOffice.org.</li>
			<li>Review final version of the guide.</li>
		</ol>
		</td>
	</tr>
	</tbody>
</table>

</body>
</html>
