<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
  <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
  <title>OpenOffice.org - Starting Instructions</title>
</head>

<body>

<h2>Instructions for Installing and Setting Up OpenOffice.org 1.1.x</h2>

<p><i>Last updated: 2005-12-21</i></p>

<ul>
  <li><a href="#win">Windows</a></li>
  <li><a href="#multiple">Windows, Multiple User Environments</a></li>
  <li><a href="#linux">Linux</a></li>
  <li><a href="#other_linux">Packages for Linux Distributions</a></li>
  <li><a href="#fileassoc">File Associations</a></li>
</ul>

<hr style="display: block;"/>

<h3>Windows 98/ME/NT/2000/XP Quick-Start Guide for OpenOffice.org 1.1.x</h3>

<p>Welcome to OpenOffice.org's Quick-Start Guide for Windows environments. Below you will find step-by-step instructions to install OpenOffice.org version
1.1 on your system. Before beginning installation, you may want to print this instruction sheet for reference while the setup program is executing.</p>

<p><b>Note:</b> If you want to install a shared OpenOffice.org, to be used by many users, you will need to read these instructions.</p>

<p><b>Note:</b> If you will be installing OpenOffice.org on a Windows PC used by more than one user, and you want all users to be able to use OpenOffice.org
(each user logs in separately), please see the <a href="#multiple">Quick-Start Guide for Multiple Users</a>. <strong>Java is optional. </strong>The JRE/JDK may
be downloaded from <a href="http://java.com/">Java.com</a> depending on your needs. Check
<a href="//dev_docs/source/sys_reqs_11.html">System Requirements</a> for additional information.</p>

<ul>

  <li><a href="#gtgstarted">Getting Started</a></li>
  <!--
  <li><a href="#win98me">Special Instructions for Win98/ME Users</a></li>
  -->
  <li><a href="#install">Unzipping/Executing the Installation Program</a></li>
  <li><a href="#reading">Further Reading</a></li>
</ul>

<h3>Getting Started<a name="gtgstarted"></a></h3>

<p>The first thing you'll want to do is read through these instructions completely, and use the OpenOffice.org site to answer any questions you might have.
The site contains documentation for users of all levels, beginner to advanced; a good place to get started for all new users of OpenOffice.org would be
browsing the <a href="//faq.html">FAQ</a>. You will also want to review the System Requirements for OpenOffice.org use:</p>

<ul>
  <li>A Pentium-compatible PC</li>
  <li>Microsoft Windows 98, NT, 2000 or XP (2000, ME or XP required for Asian/CJK versions)</li>
  <li>64 MB RAM minimum</li>
  <li>250 MB hard disk space</li>
  <!-- remove unicows
  <li>The Microsoft Layer for Unicode &ndash; unicows.dll (<b>Win98/Me users only</b> - instructions for this are covered in next section)</li>
  -->
</ul>

<!--
<p><b>Note:</b> [Update 2004/10]: The new installation of OpenOffice.org is a self-extracting archive and does not require a separate unzipping utility such
as 7-Zip.</p>
-->

<!--
<p>The file you'll be downloading is approximately over 60 MB in size &ndash; a 2.5 hour download with a 56kbps dial-up connection. This file is compressed
using ZIP compression, and you'll need a utility like <a href="http://www.7-zip.org">7-Zip</a> in order to unpack the files. Some versions of Windows
support "compressed folders" which automatically packs/unpacks these kinds of files. In Windows Explorer, the icons have a "zipper" down the middle.</p>
-->

<p>To download the most current version of OpenOffice.org, navigate to the
<a href="/download/index.html" target="_blank">Download Homepage</a> page and click on the link to the latest build; then choose a
mirror (download location) closest to you. You may also want to copy the downloaded file to a backup medium (CD-ROM, ZIP disk, etc.)</p>

<p><strong><a name="fileassoc"></a><b>Note:</b> Depending on your install set you may be asked if you want OpenOffice.org to be your default Office
suite.</strong> If you answer &quot;yes&quot; and then change your mind, returning to the prior state is tedious. You need to reassociate all Office
files.</p>

<h3>Unzipping/Executing the Installation Program<a name="install"></a></h3>

<p>Either using Windows Explorer or Mozilla/Netscape's Download Manager, navigate to the OpenOffice.org file you downloaded. Windows Explorer users will
want to find the file and double-click to launch the Installation program. Alternately, Mozilla/Netscape users will want to open the Download Manager,
highlight the file, and click &ldquo;Launch File&rdquo;. In either case, your unzip utility will start if one is successfully installed on your system.</p>

<p>Using the compression utility, extract all the files into a separate directory on your hard drive. Once the files are decompressed, navigate to the
folder, find &ldquo;SETUP.EXE&rdquo;, and double-click to launch the OpenOffice.org installation program. Follow the prompts, and OpenOffice.org will be
installed on your system, ready for use.</p>

<h3>Further Reading<a name="reading"></a></h3>

<p>If you'd like a more detailed guide to installing OpenOffice.org, please visit the
<a href="http://documentation.openoffice.org/setup_guide2/index.html">Setup Guide</a> site where you can download documentation in many languages.</p>

<p>Thank you for using OpenOffice.org, and welcome!</p>

Jack Cole<br />
Volunteer, <a href="http://documentation.openoffice.org">Documentation Project</a>

<hr style="display: block;"/>

<h3>Quick-Start Guide, Windows in a Multiple User Environment<a name="multiple"></a></h3>

<p>If you have multiple users set up on your machine, then each user who wishes to use OpenOffice.org 1.x will need to install separately. This uses up a
lot of disk space. As an alternative, you can use the multi-user option instead, though installation is a little more complicated:</p>

<ol>
  <li>The new installation of OpenOffice.org is a self-extracting archive and does not  require a separate unzipping utility such as 7-Zip.</li>
  <li>Extract the downloaded file into its own folder. If you have Compressed Folders installed, the easiest way to do this is to right click on the file
  and then choose <b>Extract All...</b> </li>
  <li>Open <b>Command Prompt</b> (if you have Windows NT, 2000 or XP) or <b>MS-DOS prompt</b> (for other versions of Windows). You should find this on the
  Start Menu somewhere under Programs (on some versions of Windows, it is in the Accessories folder).</li>
  <li>You should then type the location of the folder followed by "install\setup /net". For example, if you unzipped the files to "C:\OpenOffice Setup\"
  you would type <b>C:\OpenOffice Setup\OOo_1.1x_Win32Intel_install\setup /net</b> followed by Return.</li>
  <li>Then follow the on screen prompts ... make a note of the folder in which OpenOffice.org 1.0 is installed onto your computer.</li>
  <li><b>Note: Depending on your install set you may be asked if you want OpenOffice.org to be your default Office suite.</b> If you answer &quot;yes&quot;
  and then change your mind, returning to the prior state is tedious. You need to reassociate all Office files.</li>
</ol>

<p>This will install a shared version of OpenOffice.org on your computer. When each new user on your machine opens OpenOffice for the first time, they will
be taken through a few steps to install user portions of the software in their individual areas.</p>

<p>Lee Corbin, Louis Su&aacute;rez-Potts<br />
Allround Superman,<br />
OpenOffice.org Graphic Design Maverick<br />
Volunteer, <a href="/project/marketing/">Marketing Project</a><br />
Author of Dictinstall</p>

<hr style="display: block;"/>

<h3>Linux Set Up<a name="linux"></a></h3>

<p><i>Last updated: 2003-10-22</i></p>

<p>Installing OpenOffice.org on Linux is very easy! To make sure you get the best possible setup, simply follow these steps.</p>

<h3>Prerequisites</h3>

<p>If you want Java integration, you want to make sure you have the latest JRE installed. It should be at least JRE 1.4. You can find the JRE for Linux at
<a href="http://www.java.com/en/download/linux_manual.jsp">the Java JRE for Linux download site.</a> Alternatively, it might be included on the installation
media of your distro as part of a complete Java development environment.</p>

<h3>Installation Steps</h3>

<p> The following steps assume you want to install OpenOffice on a multi-user Linux setup in an area accessible to all users on your system. This is
referred to as a "network" or "multi-user" setup. Additionally you may install OpenOffice in a "single-user" setup. Consult details in the
<a href="http://documentation.openoffice.org/setup_guide/index.html">User Setup Guide</a> (a pdf file) included with the installation archive for further
details. These instructions assume you are using some X11 window manager to perform the actual installation. The setup is an X application.</p>

<ol>
  <li>Make sure you are root</li>
  <li>Download the tarball from OpenOffice.org (the download can be done from any user account and then moved), and extract the tarball (.tar.gz file) to a
  temporary directory. <br />
  "<code>/tmp</code>" is a good place for example. For the purpose of this example, I will assume you have downloaded the tarball to your <code>/tmp</code>
  directory.</li>
  <li>Open a terminal, such as xterm or konsole. <br />
  To extract the tarball, change to the <code>/tmp</code> directory: <code>cd /tmp</code><br />
  and extract the tarball: "<code>tar -zxvf [tarball name]</code>".</li>
  <li>This should create a directory "<code>OOo_1.1x_LinuxIntel_install</code>".<br />
  ("x" in this sense is a suffix to version 1.1 that will depend on the version you downloaded.)</li>
  <li> Change into this directory: "<code>cd OOo_1.1x_LinuxIntel_install</code>".</li>
  <li>Execute the setup script for a "network" installation.<br />
  This is done with the following command: "<code>./setup -net</code>"<br />
  This is a friendly installation process which will prompt you for a destination directory and other OpenOffice installation options. When the setup is
  finished, you should have a complete "network" installation installed in the destination directory you specified. Tips on installing OpenOffice.org with
  an NFS setup can be found on our <a href="nfs_tips.html">nfs tips</a> page.
  <p> <b>Note:</b> It is NOT advisable to install over an existing OpenOffice installation. If you want to use the same destination as an existing version of
  OpenOffice, delete the contents of the existing directory!</p></li>
  <li> Part of the installation process includes telling OpenOffice about your Java installation. Normally this can be automatically found or you may need
  to supply it, or install the JRE supplied with OpenOffice if you don't already have it installed. (But see Prerequisites for more control over this.)</li>
  <li>Each user on your system should then execute the user-setup for OpenOffice.org.<br />
  To do so, login as a regular user, then change into the program directory where you installed OpenOffice.org:<br />
  "<code>cd /opt/OpenOffice.org1.1.0</code>", for example<br />
  and execute the following command:<br />
  "<code>./setup</code>"<br />
  The user portion of setup will now execute. Tell setup to perform a Workstation installation (should copy about 1.4 MB of files to your home directory)
  and typically let it default to the directory it recommends for storage of the local files in your user directory.<br />
  Example: "<code>/home/billg/OpenOffice.org1.1.0</code>"<br />
  Follow the instructions and fill in your contact details.
  <p>If your users have been previously running an older version of OpenOffice, they should delete the current version of "<code>.sversionrc</code>" before
  starting up the newly installed version. This will reinitialize the version information for the new setup.</p></li>
  <li>That's it! If you use GNOME or KDE (provided your distro keeps the KDE user files in <code>~/.kde2</code>), you will find that OpenOffice.org is fully
  integrated in your environment. If you use a different Windowmanager, you can start OpenOffice.org by typing <code>~/OpenOffice.org1.1.0/soffice</code></li>
  <li>You may remove the install files in /tmp, if you are done installing. (thanks to Henrik Eismark for pointing this out)</li>
</ol>

<p>Have Fun!</p>

<p><a href="mailto:kschenk@openoffice.org">Kay Schenk</a>,<br />
Volunteer Co-Lead <a href="/project/website/">Website Project</a></p>

<hr style="display: block;"/>

<h3>Packages for Linux Distributions (Not compiled by OpenOffice.org Staff)<a name="other_linux"></a></h3>

<p><i>Last updated: 2003-12-29</i></p>

<p>Many Linux Distributions now include a version of OpenOffice.org in their own native package manager format (.rpm, .deb, etc.). These packages have been
built and are supported by the distributions' own teams, not by OpenOffice.org. Some distributions have strict policies around licensing, which means they
have chosen to disable parts of OpenOffice.org which rely on software which does not meet their criteria (e.g., the Fedora RPMs have disabled the parts of
OpenOffice.org which require Java).</p>

<p>Please check carefully before using a third-party build that it does actually include all the parts of OpenOffice.org that you will require. Replacing
a 'native' distribution build with the full OpenOffice.org original build can be tricky, but can usually be successfully accomplished by completely
removing the existing 'native' install.</p>

<p>A few distributions providing 'native' (possibly customized) OpenOffice.org:</p>

<ul>
  <li><a href="http://linux-debian.de/">Debian GNU/Linux</a> Apt-Gettable OpenOffice.org, plus pspfontcache hotfix! (You will have to search a little; Debian
  updated its website.)</li>
  <li><a href="http://www.linux-mandrake.com/en/features.php3">Mandrake Linux</a></li>
  <li><a href="http://www.redhat.com/docs/manuals/linux/RHL-9-Manual/getting-started-guide/ch-docs.html">RedHat</a></li>
  <li><a href="http://www.suse.com/us/private/products/suse_linux/prof/packages_professional/openoffice_org-en.html">SuSE</a></li>
</ul>

</body>
</html>
