<!DOCTYPE html>
<html><head>
<title>Single-User Installation</title>
<meta HTTP-EQUIV="content-type" CONTENT="text/html; charset=UTF-8">
</head>
<body>
<table align="right">
  <tr>
    <td><div align="left"><a href="ooo_install.html">Previous</a></div></td>
    <td><div align="center"><a href="toc.html">Contents</a></div></td>
    <td><div align="right"><a href="mu_install.html">Next</a></div></td>
  </tr>
</table>
<br>
<hr>
<h2>Single-User Installation</h2>
<p>The single-user installation is what you use to set up OpenOffice.org on one computer for one specific user only.</p>
<p>When installing OpenOffice.org as a single-user installation, log in to the system as that single specific user and install OpenOffice.org in any directory of your choice to which you have full access rights.</p>

<TABLE WIDTH=100% BORDER=1 CELLPADDING=4 CELLSPACING=0 FRAME=VOID RULES=NONE>
	<TR VALIGN=TOP>
		<TD WIDTH=17%>
			<IMG SRC="img/achtung.png" ALIGN=LEFT WIDTH=32 HEIGHT=32 BORDER=0>
		</TD>
		<TD WIDTH=83%>
			<p>This type of installation should typically NOT be used on Unix / Linux systems.</p>
			<p>Since Unix systems are rarely ever restricted to a single specific user,  using the supplied <CODE CLASS="western">install</CODE> script or using  the Multi-User  / Network installation method is strongly recommended.</p>
		</TD>
	</TR>
</TABLE>
<br>
<h3>Installation Requirements</h3>
<p>The directory into which OpenOffice.org is to be installed should have approximately 190 to 250 MB of free space, depending on the installation options you select. You will also need up to 40 MB of additional space for temporary files during installation. After successful completion of the installation, the temporary files will be automatically deleted.</p>
<p></p>
<h3>Starting the Installation</h3>

<TABLE WIDTH=100% BORDER=1 CELLPADDING=4 CELLSPACING=0 FRAME=VOID RULES=NONE>
	<TR VALIGN=TOP>
		<TD WIDTH=17%>
			<IMG SRC="img/achtung.png" ALIGN=LEFT WIDTH=32 HEIGHT=32 BORDER=0>
		</TD>
		<TD WIDTH=83%>
			<p>If you have already installed a previous version of OpenOffice.org, you should first check to see if this file exists:</p>
			<UL>
				<LI><code>.sversionrc</code> file in your <B>Unix</B> home directory or;</li>
				<LI><code>sversion.ini</code> file in the <B>Windows</B> user directory.</li>
			</UL>
			<p>This file contains the path and version number of an already installed OpenOffice.org. If the version number is identical to the version number of the OpenOffice.org to be installed, you must deinstall the old OpenOffice.org version before you can install the new one.</p>
		</TD>
	</TR>
</TABLE>

<UL>
	<LI>If necessary, log in to the system with your user name. You do not need any system administrator rights for a single-user installation.</li>
</UL>

<TABLE WIDTH=100% BORDER=1 CELLPADDING=4 CELLSPACING=0 FRAME=VOID RULES=NONE>
	<TR VALIGN=TOP>
		<TD WIDTH=17%>
			<IMG SRC="img/unix.png" WIDTH=50 HEIGHT=21 BORDER=0>
		</TD>
		<TD WIDTH=83%>
			<UL>
				<LI>Under <B>Unix</B>, go to the graphical X Window interface if it was not already automatically activated.</li>
				<LI>Go to the directory where the installation files reside &ndash; either by command line in a terminal window or through the File Manager.</li>
				<LI>Start the installation script with the command: <code>./setup </code></li>
                        </ul>
                </TD>
	</TR>
</TABLE>
<br><br>
<TABLE WIDTH=100% BORDER=1 CELLPADDING=4 CELLSPACING=0 FRAME=VOID RULES=NONE>
	<TR VALIGN=TOP>
		<TD WIDTH=17%>
			<IMG SRC="img/win.png" ALIGN=LEFT WIDTH=50 HEIGHT=21 BORDER=0>
		</TD>
		<TD WIDTH=83%>
			<UL>
				<LI>Under <B>Windows</B>, you can use the Windows Explorer to run the OpenOffice.org setup program. To start the setup program with a parameter, open the Start menu on the Windows Start bar, select the <B>Run...</B> command and enter the following line in the text box (you can also use the <B>Browse</B> button to find the file and to correctly enter the path in the text box):<br><br>
				<code>X:\{tempdir}\install\setup.exe -parameter</code><br><br>
				where X:\{tempdir} is the temporary directory where the installation files reside after decompressing the downloaded installation file.</li>
				<li>To run the single-user installation, you do not have to give the setup program parameters. More information on setup parameters can be found in the Appendix.</li>
			</uL>
		</TD>
	</TR>
</TABLE>
<br>
<h3>The Setup Procedure</h3>
<br>
<h4>Welcome</h4>

<p>The first thing to appear on the screen is a welcome dialog.</p>

<IMG SRC="img/setup_welcome.png">

<p>In many of the setup program dialogs you will see a <B>Help</B> button which displays brief information about the current dialog. After you have read the Help text, use the <B>Back</B> button to return to the setup program. Do NOT close the Help with the &quot;X&quot; system button (top right) as this would exit the setup program.</p>
<UL>
	<LI>Confirm the Welcome dialog by clicking the <B>Next</B> button.</li>
</UL>
<br>
<h4>Important Information</h4>

<p>Now a window appears containing the <code>readme.txt</code> file (Windows) or <code>README</code> file(Solaris and Linux). This file can also be opened and read from the OpenOffice.org directory after the installation process is completed.</p>

<IMG SRC="img/setup_important.png">

<UL>
	<LI>Read the information and confirm by clicking <B>Next</B>.
</UL>
<br>
<h4>License Agreement</h4>

<p>The next dialog contains the license agreement.</p>

<IMG SRC="img/setup_license.png">

<UL>
	<LI>Carefully read the license agreement. If you agree to all points, click <B>Accept</B> to continue with the installation. If you do not agree to the license agreement click <B>Cancel</B>. In the latter case OpenOffice.org will not be installed.</li>
</UL>
<br>
<h4>User Data</h4>

<p>You will now see the <B>Enter User Data</B> dialog.</p>

<IMG SRC="img/setup_userdata.png">

<UL>
	<LI>Enter your personal data.<br>
	The data entered here will be used in fields in OpenOffice.org, for example, to automatically insert your data into the corresponding fields in letter and fax templates.</li><br>
	You can also access this dialog later by choosing <B>Tools - Options - OpenOffice.org - User Data</B>.</li>
        <LI>Click <B>Next</B> to continue the installation.</li>
</UL>
<br>
<h4>Type of Installation</h4>

<p>The next dialog in the OpenOffice.org setup program allows you to select the type of installation to be carried out.</p>
<p>The memory requirements shown here are approximates based on the cluster sizes of the next target directory containing sufficient free space.</p>

<IMG SRC="img/setup_type.png">

<p>We recommend the <B>Standard Installation</B> for most users. This generally means that all of the components will be installed together with a selection of filters. If you select this option you will only be prompted to specify the directory in which OpenOffice.org is to be installed.</p>
<p>In the <B>Custom Installation</B> you also first see a dialog for selecting the installation directory. Then, in the subsequent dialog, you select the individual components to be installed.</p>
<p>The <B>Minimum installation</B> will only install those components that are required to run OpenOffice.org. If this is chosen the Help files will not be installed nor will the majority of the samples and templates. After choosing this option you will only be required to enter the name of the directory in which OpenOffice.org is to be installed.</p>
<UL>
	<LI>Select the type of installation suitable to your needs.</li>
	<LI>Click <B>Next</B> to continue the installation.</li>
</UL>
<br>
<h4>Component Selection</h4>

<p>If you have selected the <B>Custom Installation</B> you will now see  dialog for selecting the components to be installed.</p>

<IMG SRC="img/setup_modules.png">

<p>As a rule, all of the components which have a colored box next to their name will be installed. If you do not want to install a particular component, click the box next to the name and it will change to gray. Each time you click one of the boxes, it will change from colored to gray or vice versa, and the corresponding component and all subordinate components will either be part of the installation (colored) or not part of the installation (gray).</p>
<p>When you click the plus sign next to the name of a component, a list of the subordinate components will be revealed. Again, clicking the individual boxes will either include the components in or exclude them from the installation. If a group entry contains components to be installed as well as components excluded from installation, the box in front of the group entry will appear semi-transparent. For example, the box in front of the OpenOffice.org Writer text filters is by default semi-transparent because the default setting does not include all filters.</p>
<p>You can use the <B>Default</B> button, to restore the settings that were originally shown when the dialog was opened for the first time.</p>
<p>Entries shown in red denote that these components will be installed no matter what and that they cannot be deselected.</p>

<UL>
	<LI>Select the modules and components you want to include in the installation.</li>
	<LI>Click <B>Next</B> to continue the installation.</li>
</UL>
<br>
<H4>Installation Directory</H4>
<P>The next dialog to appear is for selecting the installation directory.</P>

<IMG SRC="img/setup_directory.png">

<p>In the top part of the dialog, there is a list of the drives on your system with details regarding how much space is required and how much space is available. The amount of memory required can differ due to different drives and cluster sizes.</p>

<UL>
	<LI>You can also select the installation path from a selection dialog by clicking <B>Browse</B> or by directly entering the path in the text box. If the directory entered does not exist, you will be asked if it should be created. OpenOffice.org will install files and other subfolders with files in the directory you specify.</li>
	<LI>Click <B>Next</B> to continue the installation.</li>
</UL>
<br>
<h4>Concluding the Installation Options</h4>

<IMG SRC="img/setup_copystart.png">

<p>A dialog will inform you that all of the details needed to copy the program files have been entered.</p>

<UL>
	<LI>Click <B>Install</B> to continue the installation.</li>
</UL>
<br>
<h4>Assigning File Types</h4>

<p>In the following dialog, select which <B>additional</B> file types are to be opened with OpenOffice.org. OpenOffice.org will be registered in the operating system as the default program for these file types.</p>

<IMG SRC="img/setup_filetypes.png">

<UL>
	<LI>Select the <B>file types</B> that OpenOffice.org is to open in addition to its own file types.</li>
	<LI>To use OpenOffice.org as default editor for HTML files (Web pages), mark the check box under <B>Default HTML Editor</B>. This setting only applies to editing HTML files. They will be opened with your browser (e.g. Netscape).</li>
	<LI>Click <B>OK</B>.</li>
</UL>
<br>
<h4>Java&trade; Runtime Environment</h4>

<p>The next dialog to appear lists the Java Runtime Environment versions registered in your system.</p>

<IMG SRC="img/setup_javalist.png">

<p>In this dialog, select the Java Runtime Environment you want to use. You require version 1.3.1 or higher. If you have already installed a newer version than 1.3.1, you do not have to install the version provided as long as OpenOffice.org identifies your version as <B>verified</B>.</p>

<UL>
	<LI>Select the preferred option and click <B>OK</B>.</li>
</UL>
<br>
<h4>Copying the Files</h4>

<IMG SRC="img/setup_progress.png">

<p>On screen, you will see how the installation is progressing and approximately how much time is left till the installation is complete.</p>
<br>
<h4>Concluding the Installation</h4>

<p>After the process of copying and registering the files is finished, you will see the final dialog.</p>

<IMG SRC="img/setup_finished.png">

<UL>
	<LI>Click <B>Complete</B> to finish the installation.</li>
</UL>
<br>
<H4>Starting OpenOffice.org</H4>
<TABLE WIDTH=100% BORDER=1 CELLPADDING=4 CELLSPACING=0 FRAME=VOID RULES=NONE>
	<TR VALIGN=TOP>
		<TD WIDTH=17%>
			<IMG SRC="img/unix.png">
		</TD>
		<TD WIDTH=83%>
			<p>To start OpenOffice.org under <B>Unix</B>, go to the OpenOffice.org1.0/program directory, or to the local OpenOffice.org directory in your home directory, and start OpenOffice.org with the command</P>
			<code>./soffice</code>
                        <P>You can also place the OpenOffice.org1.0/program directory into the path for programs under <B>Unix</B>. You will then be able to start OpenOffice.org by using the command &quot;<code>soffice</code>&quot; in any directory. To set up the default printer, call the Printer Administration Utility <B>spadmin</B>, which is described in the Appendix.</P>
			<P>After completing the installation process under the <B>Solaris Operating Environment</B>, you should log out and log in again to update the CDE integration.</P>
		</TD>
	</TR>
</TABLE>
<BR><br>
<TABLE WIDTH=100% BORDER=1 CELLPADDING=4 CELLSPACING=0 FRAME=VOID RULES=NONE>
	<TR VALIGN=TOP>
		<TD WIDTH=17%>
			<IMG SRC="img/win.png">
		</TD>
		<TD WIDTH=83%>
			<P>Under <B>Windows</B> in the Start menu under programs / OpenOffice.org 1.0, you will now find menu entries for starting the various OpenOffice.org components that have been installed.</P>
			<P>During the OpenOffice.org installation, a link is created in the autostart folder of the <B>Windows</B> Start menu. This link leads to the OpenOffice.org Quickstarter, which is available in the system tray after you restart your system.</P>
			<P>Right-click the Quickstarter icon to activate a context menu from which you can start various OpenOffice.org components.</P>
			<P>Detailed information on Quickstarter functionality can be found in the Help under the word &quot;Quickstart&quot;.</P>
		</TD>
	</TR>
</TABLE>
<hr>
<table align="right">
  <tr>
    <td><div align="left"><a href="ooo_install.html">Previous</a></div></td>
    <td><div align="center"><a href="toc.html">Contents</a></div></td>
    <td><div align="right"><a href="mu_install.html">Next</a></div></td>
  </tr>
</table></body>
</html>

