<!DOCTYPE html>
<html><head>
<title>Multi-User or Network 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="single_install.html">Previous</a></div></td>
    <td><div align="center"><a href="toc.html">Contents</a></div></td>
    <td><div align="right"><a href="appendix.html">Next</a></div></td>
  </tr>
</table>
<br>
<hr>
<H2>Multi-User or Network Installation</H2>
<H3>Installation Phase 1</H3>
<P>The multi-user / network installation of OpenOffice.org is carried out in two phases. First, login as root or system administrator or as a normal user with corresponding system access rights on the target computer or network computer. Carry out the complete OpenOffice.org installation in a directory to which the users have read and execute access rights. Second, after the <B>Phase 1 </B> is complete, each user can log in to the system and perform a <B>Workstation Installation</B> of OpenOffice.org in a folder in his or her home directory.</P>
<P>To start up the Phase 1 installation, simply Invoke the setup program from the installation directory and add the parameter <B>-net.</B></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">
		</TD>
		<TD WIDTH=83%>
			<P>The <B>Phase 1</B> installation does not result in an OpenOffice.org version that can be run directly (even by root or the system adminstrator). Thus, if required, the root or the system administrator also has to carry out a workstation installation.</P>
		</TD>
	</TR>
</TABLE>
<br>
<H4>Installation Requirements</H4>
<P>About 250 MB of space needs to be available on the target machine directory which is to contain the OpenOffice.org installation. During the installation about 20 MB space is required for temporary files. The temporary files will be automatically deleted after the installation has been completed successfully. Under Unix you will need a swap volume of about 80 MB.</P>
<br>
<H4>Starting the Installation</H4>
<UL>
	<LI>Log in to the system as system administrator or root</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">
		</TD>
		<TD WIDTH=83%>
			<UL>
				<LI>Go to the graphical X Window interface if it was not already automatically activated.</li>
				<LI>Go to the installation directory either by command line in a terminal window or through the File Manager.</li>
				<LI>Call the installation script with the command<br><br>
				<code>./setup -net</code><br><br>
				As an alternative, Unix users may use the <CODE>install</CODE> script from the command line to perform a non-graphical installation.</li>
				<li>Type<br><br>
				<CODE>./install --help</CODE><br><br>
				for its syntax or see <I>Automated Installation under Unix</I> in the Appendix for more information.</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">
		</TD>
		<TD WIDTH=83%>
			<UL>
				<LI>Call the Setup.exe program from the installation directory using the <B>-net</B> parameter.</li>
				<li>To start the setup program by using a parameter, open the Start menu on the 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 -net</code><br><br>
				where X:\{tempdir} is the temporary installation directory where the installation files reside after decompressing the downloaded installation file.</li>
			</uL>
		</TD>
	</TR>
</TABLE>
<br><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>.</li>
</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.</P>
</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>When installing OpenOffice.org on a network server you should install all of the available components. To do this select the <B>Custom Installation</B> and select all of the options contained in the dialog following on from the next one in which a directory is chosen.</P>
<UL>
	<LI>Select <B>Custom Installation</B>.</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>

<TABLE WIDTH=100% BORDER=1 CELLPADDING=4 CELLSPACING=0 FRAME=VOID RULES=NONE>
	<TR VALIGN=TOP>
		<TD WIDTH=17%>
			<IMG SRC="img/achtung.png">
		</TD>
		<TD WIDTH=83%>
			<p>Select a directory in which all users have read and execute rights so that the workstation installations can be carried out.</p>
		</TD>
	</TR>
</TABLE>
<br>
<H4>Component Selection</H4>
<P>If you have selected the <B>Custom Installation</B> you will now see a 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>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>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.</P>
</UL>
<P>Now, with the aid of the <B>workstation installation</B>, each user can install OpenOffice.org in his or her Home directory or local hard disk.</P>


<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>As system administrator, you can also call the printer administration utility <B>spadmin</B> in order to, among other things, define printer settings for the individual user installations and to install fonts. You can find more details on spadmin in the Appendix.</P>
		</TD>
	</TR>
</TABLE>
<br><br>
<H3>Workstation Installation</H3>
<p>Every user can carry out a user installation under his or her login name by calling the setup program from the installation made in Phase 1.</P>
<br>
<H4>Installation Requirements</H4>
<p>About 2 to 4 MB of free space is required  on the hard disk where OpenOffice.org is to be installed.</P>
<br>
<H4>Starting the Installation</H4>
<P>Before the workstation installation can be initiated, a Phase 1 installation must have been carried out successfully as described under <I>Installation Phase 1</I></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">
		</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>Log in to the system with your user name.</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">
		</TD>
		<TD WIDTH=83%>
			<UL>
				<LI>Go to the graphical X Window interface.</li>
				<LI>Open a terminal window and use the command line to go to the network installation path on the server and then to the program sub-directory. If the server installation was made in the directory /opt/OpenOffice.org1.0, this could be done using the command:<br><br>
				<code>cd  /opt/OpenOffice.org1.0/program</code><br><br></li>
				<LI>Start the installation script with the command<br><br>
				<code>./setup</code><br><br></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">
		</TD>
		<TD WIDTH=83%>
			<UL>
				<LI>Run the Setup.exe program located in the network installation directory on the server.</li>
				<li>When working under Windows you can use the Windows Explorer to call up the setup program.</li>
			</UL>
		</TD>
	</TR>
</TABLE>
<br><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>.</li>
</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.<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.</P>
</UL>
<br>
<H4>Type of Installation</H4>

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

<UL>
	<LI>Select the <B>Workstation Installation</B> as your user installation. Only the files that contain variable data for a user will be installed.<br>
	The <B>Local Installation</B> option installs a complete OpenOffice.org locally. The server installation serves as the source.</li>
	<LI>Click <B>Next</B> to continue the installation.</P>
</UL>
<br>
<H4>Installation Directory</H4>
<p>The next dialog to appear is for selecting the installation directory.</P>

<IMG SRC="img/setup_workstationdirectory.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.</P>
</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.</P>
	<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.</P>
</UL>
<br><br>
<H3>Starting OpenOffice.org</H3>

<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>
<BR><BR>
<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<br><br>
			<code>./soffice</code><br><br>
			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;soffice&quot; in any directory. To set up the default printer, call the Printer Administration Utility <B>spadmin</B>, which is described in the Appendix.</li>
			<li>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.</li>
		</TD>
	</TR>
</TABLE>
<hr>
<table align="right">
  <tr>
    <td><div align="left"><a href="single_install.html">Previous</a></div></td>
    <td><div align="center"><a href="toc.html">Contents</a></div></td>
    <td><div align="right"><a href="appendix.html">Next</a></div></td>
  </tr>
</table></body>
</html>

