<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<!--
   Licensed to the Apache Software Foundation (ASF) under one
   or more contributor license agreements.  See the NOTICE file
   distributed with this work for additional information
   regarding copyright ownership.  The ASF licenses this file
   to you under the Apache License, Version 2.0 (the
   "License"); you may not use this file except in compliance
   with the License.  You may obtain a copy of the License at

     http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing,
   software distributed under the License is distributed on an
   "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
   KIND, either express or implied.  See the License for the
   specific language governing permissions and limitations
   under the License.    
-->
<html>
<head>
	<script type="text/javascript">var xookiConfig = {level: 0};</script>	
	<script type="text/javascript" src="xooki/xooki.js"></script>
</head>
<body>
	<textarea id="xooki-source">
Apache IvyDE maintains a global configuration, which controls the behaviour of every Ivy instance in every project in the workspace. This global configuration can be overrided in each <a href="cpc/edit.html">project</a>.

The global configuration can be found in the preferences of Eclipse (menu Window > Preferences for Windows and Linux users, Eclipse > Preferences for mac users), and select the item Ivy.

<h1><a name="global"></a>Global Ivy preferences</h1>

<center><img src="images/pref.jpg"/></center>

<h4>Offline</h4>
<p>If checked, it will force Ivy to never check resources via any network and trust its cache</p>
<h4>Open the Ivy console on startup</h4>
<p>If checked, the Ivy console will be opened on startup so that every log from Ivy will be printed. This is especially usefull when looking for debug log from IvyDE starting up.</p>
<h4>On Eclipse startup:</h4>
<p>Specifies what Apache IvyDE should do in every project containing an IvyDE managed classpath container when Eclipse&#153; is starting up.</p>
<h4>On Ivy file change:</h4>
<p>Controls whether a resolve is performed each time Eclipse detects a change on an ivy.xml file configured by an IvyDE container via a save in the editor, a refresh, or a team/update.</p>
<h4>Organisation:</h4>
<p>Your company name for Ivy editor completion.</p>
<h4>Organisation URL:</h4>
<p>Your company web site url for Ivy editor completion.</p>
<h4>Open a popup on each failed resolve</h4>
<p>On a resolve error, IvyDE mark an error on the ivy.xml of the project; if checked it will also open a popup with a detailed error message</p>

<h1><a name="advanced"></a>Advanced</h1>

<center><img src="images/pref_advanced.jpg"/></center>

<h4>Resolve before launch:</h4>
<p>An IvyDE container can be used in the classpath of a launch configuration, and the container can be resolved on each launch. See the documentation about <a href="cpc/launch.html">launch configurations</a> for further information on this feature.</p>

<h4>Use extended resolve id</h4>
<p>A resolve id is an identifier which helps Ivy to make cache of results of resolve. By default IvyDE each the id which is composed of the organisation and the module name. An extended resolve id is also composed of the status, branch and revision. If you have troubles with the resolve of multiple versions of the same project within the same workspace, you should probably enable this option.</p>

<h1><a name="classpath"></a>Classpath container</h1>

<center><img src="images/pref_classpath.jpg"/></center>

<h4>Resolve dependencies in workspace:</h4>
<p>Apache IvyDE allows Ivy dependencies between projects in the workspace to be realized through project references rather than jars from the repository.  See the <a href="cpc/workspace.html">documentation</a> for further information on this feature.</p>
<h4>Resolve dependencies transitively</h4>
<p>If unchecked, the dependencies will be resolved with transitivity disabled regardless to the settings in ivy.xml</p>
<h4>Read OSGi metadata:</h4>
<p>If your classpath is based on jars which are actually OSGi bundles, checking this option will make IvyDE read the jar manifests and setup the specific OSGi visibility constraints.</p>
<h4>Accepted types:</h4>
<p>A comma separated list of extensions which will make IvyDE add the artifact to the classpath. Setting <tt>*</tt> will make very kind of type accepted. Note that a type specified as a <a href="#mapping">source or javadoc type</a> won't be accepted in any manner.</p>
<h4>Order of the classpath entries:</h4>
<p>By default, the classpath container entries are ordered by order of declaration in the ivy.xml. When there are many entries, it can be useful to have them ordered lexically for enhanced readability.</p>
<h4>Build the classpath with:</h4>
<p>Either Ivy with build a classpath with references to the artifacts in its cache.</p>
<p>Or Ivy will retrieve the artifacts with the specified pattern, and then build a classpath with the retrieved jars.
  <ul><li><u>Retrieve pattern:</u> The pattern to use for the retrieve. Check <a href="../../../history/latest-milestone/use/retrieve.html">Ivy documentation</a> for pattern explanation.</li>
    <li><u>Delete old retrieve artifacts:</u> On each retrieve, the previously retrieved libraries will be removed (similar to the sync argument in the Ant task).</li>
    <li><u>Types:</u> The types of artifact to retrieve (a comma separated list)</li>
  </ul>
</p>

<h1><a name="settings"></a>Ivy settings</h1>

<center><img src="images/pref_settings.jpg"/></center>

<h4>Reload the settings only on demand:</h4>
<p>By default, Apache IvyDE will parse the ivy settings file each times it is needed (each resolve, refresh, clean cache or completion in the ivy editor). For remote ivysettings this can slow the UI dramatically, so it is possible to make IvyDE keep the settings in a cache and only reload them via the context menu on the container).</p>
<h4>Ivy settings path:</h4>
<p>The path to your ivy settings file. Leave it blank to use Ivy default resolvers. See also the documentation about <a href="eclipsevar.html">Eclipse variables</a>.</p>
<h4>Ivy user dir:</h4>
<p>The path to the default Ivy user directory, where Ivy have its default cache location</p>
<h4>Property files:</h4>
<p>This is a list of Java properties files to load before loading the ivysettings.xml. Specify in this files properties which you expect to use in the ivysettings.xml</p>

<h1><a name="mapping"></a>Source/Javadoc mapping</h1>

<center><img src="images/pref_source_javadoc_mapping.jpg"/></center>

<h4>Sources types:</h4>
<p>A comma separated list of Ivy "type" names which should be considered sources.</p>
<h4>Sources suffixes:</h4>
<p>A comma separated list of suffixes which will make IvyDE attach as source the artifact with the suffix to the artifact without the suffix. For instance, "commons-lang-sources.jar" will be attached as source to "commons-lang.jar" with the default value.</p>
<h4>Javadoc types:</h4>
<p>same as sources types but for javadocs</p>
<h4>Javadoc suffixes:</h4>
<p>same as sources suffixes but for javadocs</p>
<h4>Auto map jar artifacts with unique source artifact</h4>
<p>If checked, in case there is only one artifact which is detected of type source, then IvyDE will consider this artifact the source of every jar of the module</p>
<h4>Auto map jar artifacts with unique javadoc artifact</h4>
<p>Same as above but with javadoc</p>

<p>For further information on how the mapping works, checkout this <a href="cpc/jarmapping.html">specific documentation</a>.</p>

<h1><a name="workspace"></a>Workspace resolver</h1>

<center><img src="images/pref_workspace.jpg"/></center>

<h4>Closing trigger resolve:</h4>
<p>Closing a project which has the workspace resolver enabled will trigger a resolve on every project that depends on it.</p>
<h4>Opening trigger resolve:</h4>
<p>When a project is opened, IvyDE will trigger the resolve of every other project which has the workspace resolver enabled.</p>
<h4>Ignore version when resolving workspace projects:</h4>
<p>This option forces the workspace resolver to ignore the version of a module specified in an ivy.xml if a project containing an Ivy file with that module organization and name is found in the workspace, instead substituting a project reference.  This may have unintended consequences.</p>

<p>For further information on how the workspace resolver works, checkout this <a href="cpc/workspace.html">specific documentation</a>.</p>

<h1><a name="xmleditor"></a>XML Editor</h1>

This configuration panel allow you to change the color used in the <a href="ivyeditor.html">Ivy file editor</a> and the <a href="settingseditor.html">Ivy settings editor</a>.

<center><img src="images/xml_editor_color.jpg"/></center>

</textarea>
<script type="text/javascript">xooki.postProcess();</script>
</body>
</html>
