<!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>Apache OpenOffice - ReadMe</title>
	

	
</head>

<body>

<h2>Apache OpenOffice ReadMe</h2>
<!-- Most of this information is generic. Change date on update. -->
<h5>Last Update: 2017-12-30</h5>


<p>Dear User</p>

<p>This file contains important information about this program. Please read this information very carefully before starting work.</p>

<p>The Apache OpenOffice Community, responsible for the development of this product, would like to invite you to participate as a community member.
As a new user, you can check out the Apache OpenOffice project site at <a href="https://openoffice.apache.org">openoffice.apache.org</a>.
Please also read the sections below about getting involved in the Apache OpenOffice project.</p>

<h3>Is OpenOffice really free for any user?</h3>

<p>OpenOffice is free for use by everybody. You may take this copy of OpenOffice and install it on as many computers as you like, 
and use it for any purpose you like (including commercial, government, public administration and educational use). 
For further details see the license text delivered together with OpenOffice or <a href="">https://www.openoffice.org/license.html</a></p>


<h3>Why is OpenOffice free for any user?</h3>

<p>You can use this copy of OpenOffice today free of charge because individual contributors and corporate sponsors have designed, developed, tested,
translated, documented, supported, marketed, and helped in many other ways to make OpenOffice what it is today - the world's leading open-source
office software.</p> 

<p>If you appreciate their efforts, and would like to ensure Apache OpenOffice continues into the future, 
please consider contributing to the project - see <a href="https://openoffice.apache.org/get-involved.html">https://openoffice.apache.org/get-involved.html</a> for details on contributing time,
 and <a href="https://www.apache.org/foundation/contributing.html">https://www.apache.org/foundation/contributing.html</a> for details on donations. Everyone has a contribution to make.</p>


<h2>Notes on Installation</h2>

<h3><a href="https://www.openoffice.org/dev_docs/source/sys_reqs.html">General System Requirements</a></h3>


<h3>Problems During Program Startup</h3>

<p>If you encounter any startup problems not covered in your system specific README file, please
subscribe to our <a href="mailto:users-subscribe@openoffice.apache.org">users mailing list</a>, or <a href="https://forum.openoffice.org/">Community Forums</a>
for further assistance.</p>


<h3>Shortcut Keys</h3>

<p>Only shortcut keys (key combinations) not used your installed operating system can be used in OpenOffice. If a key combination in OpenOffice does not
work as described in the OpenOffice Help, check if that shortcut is already used by the operating system. To resolve such conflicts, you can change the
keys assigned by your operating system. Alternatively, you can change almost any key assignment in OpenOffice. For more information on this topic,
refer to the OpenOffice Help or the Help documentation of your operating system.</p>

<p>Due to a conflict with input method switching on multiple platforms, the following shortcut keys have been changed:</p>

<ul type="circle">
  <li>[Ctrl]-[Space] is now [Ctrl]-[Shift]-[Space]</li>
  <li>[Ctrl]-[Shift]-[Space] is now [Ctrl]-[M]</li>
</ul>

<h3>File Locking -- Linux, Mac, Solaris</h3>

<p>In the default setting, file locking is turned on in OpenOffice. To deactivate it, you have to set the appropriate environment variables
SAL_ENABLE_FILE_LOCKING=0 and export SAL_ENABLE_FILE_LOCKING. These entries are already in enabled form in the soffice script file.</p>

<p>Warning: The activated file locking feature can cause problems with Solaris 2.5.1 and 2.7 used in conjunction with Linux NFS 2.0. If your system
environment has these parameters, we strongly recommend that you avoid using the file locking feature. Otherwise, OpenOffice.org will hang when you try to
open a file from a NFS mounted directory from a Linux computer.</p>

<h2>Important Accessibility Notes</h2>

<p>For information on the accessibility features in OpenOffice, see <a href="https://www.openoffice.org/ui/accessibility/quickstart.html">Accessibility Quick Start</a>.</p>


<h2>User Support</h2>

<p>
The main support page <a href="https://support.openoffice.org/">https://support.openoffice.org/</a> offers various possibilities for help with OpenOffice. 
Your question may have already been answered - check the Community Forum at <a href="https://forum.openoffice.org">https://forum.openoffice.org</a> or 
search the archives of the 'users@openoffice.apache.org' mailing list from <a href="https://openoffice.apache.org/mailing-lists.html">https://openoffice.apache.org/mailing-lists.html</a>. 
Alternatively, you can send in your questions to <a href="mailto:users@openoffice.apache.org">users@openoffice.apache.org</a>. 
How to subscribe to the list (to get an email response) is explained on 
the <a href="https://openoffice.apache.org/mailing-lists.html">mailing list page</a>.


<h2>Report Bugs &amp; Issues</h2>

<p>OpenOffice uses <a href="https://bz.apache.org/ooo/">BugZilla</a>, our mechanism for reporting, tracking and solving bugs and issues. We encourage all users to feel
entitled and welcome to report issues that may arise on your particular platform. Energetic reporting of issues is one of the most important contributions
that the user community can make to the ongoing development and improvement of the suite.</p>

<h2>Getting Involved</h2>

<p>The OpenOffice Community would very much benefit from your active participation in the development of this important open source project.</p>

<p>As a user, you are already a valuable part of the suite's development process and we would like to encourage you to take an even more active role with
a view to being a long-term contributor to the community. Please join and check out the user page at 
<a href="https://openoffice.apache.org/get-involved.html">https://openoffice.apache.org/get-involved.html</a>

<h3>Way to Start</h3>

<p>The best way to start contributing is to subscribe to one or more of the mailing lists, lurk for a while, and gradually use the mail archives to
familiarize yourself with many of the topics covered since the OpenOffice source code was released back in October 2000. When you're comfortable, all you need to do is send an email self-introduction 
to one of our mailing lists and jump right in.</p>

<h3>Subscribe</h3>


<p>Here are a few of the OpenOffice mailing lists to which you can subscribe at https://openoffice.apache.org/mailing-lists.html
<ul>
    <li>News: announce@openoffice.apache.org *recommended to all users* (light traffic)</li>

    <li>Main user forum: users@openoffice.apache.org *easy way to lurk on discussions* (heavy traffic)</li>

    <li>General project development and discussion list: dev@openoffice.apache.org (heavy traffic)</li>
</ul>

<h3>Joining the Project</h3>

<p>

You can make major contributions to this important open source project even if you have limited software design 
or coding experience. Yes, you!</p>

<p>At <a href="https://openoffice.apache.org/get-involved.html">Get Involved</a> you will find a first overview where you can start,
 ranging from Localization, QA, and user support to some real core coding projects. 
 If you are not a developer, you can help with Documentation or Marketing, for example. 
 The OpenOffice marketing is applying both guerrilla and traditional commercial techniques to marketing open source software, 
 and we are doing it across language and cultural barriers, so you can help just by 
 spreading the word and telling a friend about this office suite. You can help by joining the marketing 
 mailing list <em>marketing@openoffice.apache.org</em> where you can provide point communication contact with press, media, 
 government agencies, consultants, schools, Linux Users Groups and developers in your country and local community.</p>

<p>We hope you enjoy working with the new OpenOffice 4.1.5 and will join us online.</p>

<p>The Apache OpenOffice Community </p>


<h2>Used / Modified Source Code</h2>

<p>For detailed information about used and/or modified source code, see the NOTICE file which is part of the installation.</p>

</body>
</html>
