<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html lang="en">
<head>
<meta name="copyright" content="Copyright (c) 2006, 2015 IBM Corporation and others. This page is made available under license. For full details see the LEGAL in the documentation book that contains this page." >
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
<title>Product Export</title>
<script language="JavaScript" type="text/javascript" src="PLUGINS_ROOT/org.eclipse.help/livehelp.js"></script>
<link href="../../book.css" rel="stylesheet" type="text/css">
</head>

<body>
<h1>Product Export</h1>
<p>PDE provides an <strong>Eclipse Product Export</strong> wizard to export an Eclipse product defined in a <em>product configuration</em>. The wizard shields you from Ant scripts and does not pollute your workspace with resources generated during the build operation. The wizard is available under <a class="command-link" href='javascript:executeCommand("org.eclipse.ui.file.export(exportWizardId=org.eclipse.pde.ui.productExportWizard)")'>
<img src="PLUGINS_ROOT/org.eclipse.help/command_link.png" alt="Open the product export wizard">
<strong>File &gt; Export... &gt; Plug-in Development &gt; Eclipse Product</strong>
</a>.</p>
<p><img src="../../images/export_wizards/product.png" alt="Product Export" ></p>

<h2>Product Configuration</h2>
<p>The <em>Eclipse Product</em> export  wizard is centered around the <a href="../file_wizards/new_product_config.htm">product configuration</a>, which encapsulates all the data that the wizard needs to build the plug-ins and features and generate all the configuration files that are necessary to run the product. </p>
<p>The <strong>Browse...</strong> button lets you browse through all of the available <em>.product</em> files in the workspace and select the <em>product configuration</em> that will define the product's build process. </p>
<p>The <strong>Root directory</strong> is the name of the top-level directory of the packaged product. It is set to <em>eclipse</em> by default; however, it can be changed to any name - including names with more than one segment. For example, if the root directory is set to <em>rcp/product</em>, then the product executable and the <em>plugins/</em> directory will be placed in a <em>rcp/product</em> directory. </p>

<h2>Synchronization</h2>
<p>PDE uses the product configuration only to help create and customize the product. In order for certain types of data stored in the product configuration to take effect at runtime (e.g. window images, the <em>About dialog</em> image and text, etc.), corresponding properties must be written to the <em>org.eclipse.core.runtime.products</em> extension in the product's defining plug-in manifest file. </p>
<p>The <strong>Synchronize before exporting</strong> option ensures that the plug-in manifest files are always up-to-date (the option is <em>on</em> by default).</p>

<h2>Destination</h2>
<p>The default option is to export a <strong>Directory</strong>. The product's <strong>Root directory</strong> is stored directly in the specified directory. </p>
<p>When the option to export to an <strong>Archive file</strong> is selected, the product is packaged in a ZIP archive. </p>

<h2>Source Code </h2>
<p>The <strong>Include source code</strong> option results in the exporting of source code as well as binaries. If a plug-in is packaged as a JAR, the source code will be placed in a <em>src/</em> folder at the root of the JAR. If the plug-in is packaged as a flat directory, the source code will be placed in a source ZIP inside the plug-in directory as a sibling to the library JAR.</p>

<h2>P2 Metadata </h2>
<p>The <strong>Generate metadata repository</strong> option allows you to also generate p2 metadata along with your exported feature.  This does not create a p2-enabled product, just the metadata which can then be used to install using p2.</p>

<h2>One-Click Cross-Platform Export</h2>
<p>The <strong>Export for multiple platforms</strong> option is only available when PDE detects that the org.eclipse.equinox.executable feature is installed in the target platform. When this option is selected, a second wizard page is available and displays a list of available platforms to export to. This list is compiled by navigating the directory structure of the installed <em>org.eclipse.platform.launchers</em> feature to retrieve the different platform combinations. </p>
<p><img src="../../images/export_wizards/cross_platform.PNG" alt="Cross Platform Export" > </p>
<p>In a single operation, PDE generates a product for each selected platform and places it in a directory whose name is of the form <em>&lt;os&gt;_&lt;ws&gt;_&lt;arch&gt;</em>.  The <em>os</em> variable represents the selected operating system.  The <em>ws</em> variable represents the selected windowing system.  And, the <em>arch</em> variable represents the selected processor architecture.</p>

<p><img src="../../../images/ngrelr.png" alt="Related reference" border="0"></p>
<p>
<a href="export_wizards.htm">Export Wizards</a>
</p>

</body>
</html>
