<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>

<meta http-equiv="content-type" content="text/html; charset=utf-8">

<title>NetBeans 5.5.1 UML Modeling Download and Installation Instructions</title>
<meta name="description" content="NetBeans 5.5.1, UML Modeling Download and Installation Instructions">
<link rel="stylesheet" type="text/css" href="../../../..//netbeans.css" media="screen">
</head>

<body>
<!-- Begin Content Area -->
<a name="top"></a>
<h1>
NetBeans 5.5.1 UML Modeling Download and Installation Instructions </h1>
<blockquote>
<p>NetBeans 5.5.1 UML Modeling provides UML modeling <a href="../../../../features/uml/index.html">features</a> to 
the NetBeans IDE. UML modeling allows analysts and designers to design applications using a standard modeling language. Developers 
are then able to generate source code from the UML model and update the model from changes made in their source code.</p> 
<p>UML Modeling can be downloaded and installed via the NetBeans Update Center. You can access the update center by clicking 
Tools &gt;Update Center in the main menu of the NetBeans IDE.<br>
<br>
<b>Note to Mac Users</b>: NetBeans UML Modeling is currently not supported on the Macintosh OS X platform. Please see the <a href="uml-mac-relnotes.html">Release Notes for the Mac OS platform</a> to get more information about the known issues and workarounds.</p>
<p><b>Contents</b></p>
	<ul>
		<li><a href="#prerequisites" title="Prerequisites">Prerequisite</a></li>
		<li><a href="#installation" title="Installing the Software">Downloading and Installing the Software</a>
		  <div></div>
	  </li>
		<li><a href="#Increasing_Memory_Settings">Increasing Memory Settings</a></li>
</ul>
</blockquote>
<!-- PREREQUISITES -->
<h2><a name="prerequisites"></a>Prerequisite</h2>
<p>This topic specifies the prerequisite that must be met before you start to install NetBeans UML Modeling.</p>

<blockquote>
<h3>Required Software</h3>
<p>The following software must be installed before you attempt to install NetBeans UML Modeling:</p>
	<ul>
		<li>NetBeans IDE 5.5.1 (hereinafter referred to as the IDE)  <a href="https://netbeans.org/features/index.html" title="Download IDE now">Download IDE now</a>.</li>
  </ul>
<b>Note:</b>  For information about system requirements for NetBeans UML Modeling, see the <a href="uml-relnotes.html#sysreqs">NetBeans UML Modeling Release Notes</a>.
<br>
</blockquote>

<p align="center"><a href="#top">top</a></p>
<br>

<!-- INSTALLATION -->
<h2><a name="installation"></a>Downloading and Installing  the Software </h2>
<p>This section contains instructions for downloading and installing NetBeans UML Modeling on all supported 
platforms.</p>
<p><b>Note:</b> 
If you have previously installed any Beta versions of NetBeans UML Modeling, you do not need to uninstall the Beta 
version. However, there will be some slight differences in the latter part of the installation process and these will be noted in the steps below.</p>

<!-- RELEASE_UC -->
<ol>
<li>Click Tools &gt; Update Center from the main menu of the IDE.<br>
The Update Center wizard appears. <br>
<br></li>
<li>In the Select Location of Modules page, select the NetBeans
Update Center checkbox, if it is not already selected.<br><br></li>
<li>Optionally, unselect all other checkboxes to minimize the number of items in the resulting list of available modules. <br><br></li>
<li> Click Next.<br>
A progress dialog appears as the IDE connects to the the NetBeans Update
Center. <br>
<br></li>
  <li>In the Select Modules to Install page of the Update Center
wizard, scroll to the UML Modeling node under the Features folder. <br><br></li>
  <li>Select the UML Modeling module and click Add.&nbsp;<br>
All the UML Modeling module and its required dependent library modules
should appear in the Include in Install pane on the right.<br><br></li>
  <li>Click More to view the UML Modeling project page.<br>
A separate web browser displays the UML project page.<br><br></li>
  <li>Return to the Update Center wizard and click Next.<br><br></li>
  <li>Read and Accept the four UML licenses.<br>
The Download Modules page appears and progress is shown as the modules
are downloaded.&nbsp; <br>
<p><b>Note:</b> If you are upgrading from a Beta version of NetBeans UML Modeling, you will not be prompted to accept the four UML licenses.</p></li>
<li>After the modules have been downloaded, click Next.<br>
The list of certificates are made available for your viewing. <br><br></li>
<li>Click Finish.
    <br>
 If you are upgrading from a Beta version of NetBeans UML Modeling, the Restart the IDE dialog appears. Proceed to the <a href= "#restart_ide1">next step</a> <br>
 <br>
 If you  are not upgrading from a Beta version, the installation of the UML module continues. This takes a few minutes after the Update Center wizard
  disappears.&nbsp; When the installation is complete, you will see the
  message <tt>'Turning on
  modules...done</tt>' displayed in the lower left corner of the IDE
  window.<br><br></li>
<li><a name="restart_ide1"></a>From the Restart the IDE dialog, choose Restart the IDE and click OK to continue with the installation of NetBeans UML Modeling.<br>
  If you choose Install Later, NetBeans UML Modeling is not installed until the next time the IDE is restarted. <br>
  <br>
</li>
<li>Read the <a href="uml-relnotes.html">Release Notes</a> page for important information about the release.<br>
</li>
</ol>
<p align="center"><a href="#top">top</a></p>

<!-- INCREASE_MEMORY -->
<br>
<h2><a name="Increasing_Memory_Settings"></a>Increasing Memory Settings</h2>
<p>The default memory settings for NetBeans should be increased when working with UML projects in the IDE. Once you have installed the UML module, use the following steps <a href="#Increasing_Memory_Settings"></a> to ensure proper memory settings in the IDE while working with UML projects. </p>
<ol>
  <li>From the main menu of the IDE, click Help &gt; About and click the Detail tab.<br><br></li>
  <li>Determine the path to the <i>NetBeans551-install-directory</i> in which you installed the NetBeans 5.5.1 IDE by   locating the <code>Current Dir</code> field.<br>
For example, the default installation directory is <code>C:\Program
Files\netbeans-5.5.1 </code>on the Microsoft Windows platform.<br>
  <br><br></li>
  <li>Change directory to the <i>NetBeans551-install-directory</i> you identified in the previous step.<br>
    <br></li>
  <li>Change to the <code>etc/</code> directory. <br><br></li>
  <li>Edit the <code>netbeans.conf</code> file.<br><br></li>
  <li>In the <code>netbeans_default_options</code> line, change the <code>-J-Xmx128m</code> command line switch option to <code>-J-Xmx512m</code>.<br>
    <b>Note:</b>    If after completing this step you still experience heap overflows while working with larger files,
you should increase this value further.<br><br></li>
</ol>
<p align="center"><a href="#top">top</a></p>
<br>
<script src="http://www.google-analytics.com/urchin.js" type="text/javascript">
</script>
<script type="text/javascript">
_uacct = "UA-1613612-2";
urchinTracker();
</script>
</body>
</html>
