<!doctype html public "-//w3c//dtd html 4.0 transitional//en">
<html>
<head>
   <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
   <meta name="Author" content="hfghfgh">
   <meta name="GENERATOR" content="Mozilla/4.76 [en] (Windows NT 5.0; U) [Netscape]">
   <title>Splitting org.eclipse.ui</title>
</head>
<body>

<center>
<h1>
Status of Splitting org.eclipse.ui</h1></center>

<center>
<address>
Kai-Uwe Maetzel, Daniel Megert</address></center>

<center>
<address>
25th September 2002</address></center>

<p><br>This is the release note we sent out on the platform-ui-dev mailing
list.
<br>&nbsp;
<p>We have completed the initial transition to the new structure of&nbsp;
<tt>org.eclipse.ui</tt>.
<p>Kim updated the CVS module <tt>platform-ui</tt> to contain all the plug-ins
that&nbsp; are part of the new structure. Dean ran a nightly build to make
sure that the new structure does not cause serious build failures. We ran
multiple tests to ensure that the new layout can be used for self hosting.
To update your workspace you can delete <tt>org.eclipse.ui</tt> and check
out the module <tt>platform-ui</tt>. You can work with binary projects
by importing <tt>org.eclipse.ui</tt> and all its required projects using
the PDE import wizard.
<p>In addition to the changes outlined in the announcement we made the
following modifications:
<ul>
<li>
Rather than having fragments we have released the "everything is a plug-in"
version. This is because we experienced problems when importing the fragments
as binary projects and also when running the build machinery we use for
nightly and integration builds. Depending on the progress we make in solving
these issues and accelerating class loading we might switch back to fragments
in the future.</li>

<li>
We renamed source folders where appropriate using <tt>src</tt> for the
default source folder and <tt>extensions</tt> for the folder containing
package fragments of packages defined in required plug-ins.</li>

<li>
class <tt>PreferenceStore</tt>: We removed the newly introduced usage of
<tt>Workspace.run(ISafeRunnable)</tt>. This needs to be solved in an <tt>org.eclipse.core.runtime</tt>
independent way if JFace should not depend on this plug-in (to be decided).</li>

<li>
class <tt>FontRegistry</tt>: We removed newly introduced dependency on
<tt>WorkbenchUI</tt> and the usage of <tt>Workspace.run(ISafeRunnable)</tt>.
This needs to be solved in an org.eclipse.core.runtime independent way
if JFace should not depend on this plug-in (to be decided).</li>

<li>
class <tt>Dialog</tt>: We changed the package visible fields to protected.</li>
</ul>
When working with the new layout you might see the following types of&nbsp;
problems:
<ul>
<li>
<tt>ClassNotFoundException</tt> if there are problems in the plug-in dependencies
setup.</li>

<li>
<tt>IllegalArgumentException</tt> in the case of accessing package visible
members from package fragments located in different plug-ins. We tested
multiple scenarios and fixed several of those problems. It still might
occur. You can solve this problem by changing the visibility of the affected
members from package visible to protected.</li>

<li>
Open issue: We have not yet looked into the tests of org.eclipse.ui and
the doc plug-ins.</li>
</ul>

<p><br>Please keep in mind that the new structure is an initial version.
There are open issues and the org.eclipse.ui team will decide about further
restructuring if necessary.
<br>&nbsp;
<br>&nbsp;
<br>&nbsp;
<br>&nbsp;
<br>&nbsp;
<br>&nbsp;
</body>
</html>
