<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Language" content="en-us" />
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
<link rel="stylesheet" href="default_style.css" type="text/css" title="main" media="screen" />
<title>Eclipse Project 4.4 M2 News</title>
</head>
<body>
<h1>Eclipse Project 4.4 M2 - New and Noteworthy</h1>
<p>Here are some of the more noteworthy things available in milestone build M2 
  (September 20, 2013) which is now available for <a href="http://download.eclipse.org/eclipse/downloads/" target="_top">download</a>.
</p>
<ul>
  <li><a href="#Platform">Platform</a></li>
  <li><a href="#PDE">PDE</a></li>
  <li><a href="#Equinox">Equinox</a></li>
</ul>

<table class="news" border="0" cellpadding="10" cellspacing="0" width="80%">
  <tr>
    <td colspan="2" class="section" id="Platform">Platform</td>
  </tr>
  <tr id="reorder-perspectives"> 
    <td class="title">Perspective re-ordering</td>
    <td class="content">
      You can now drag and drop the items in the perspective switcher to change the order of your open perspectives.
    <p><img src="images/move-persp-items.png" alt="moveitems"/></p>
    </td>
  </tr>
  <tr id="timing-api"> 
    <td class="title">Added UI timing API</td>
    <td class="content"> 
      SWT has added two new events, <tt>SWT.PreEvent</tt> and <tt>SWT.PostEvent</tt>,
      which are sent before and after all events and async runnables. These events can
      be used to measure the time spent on processing any events. This 
      can be useful for detecting slow event listeners. Because of its pervasive effect
      on all events, this listener should be used with <b>extreme</b> caution.
      For an example of how this can be used, take a look at the 
      <a href="http://git.eclipse.org/c/platform/eclipse.platform.swt.git/tree/examples/org.eclipse.swt.examples.watchdog">
      Watchdog</a> plugin in SWT examples.
    </td>
  </tr>
  <tr id="debug-examples"> 
    <td class="title">New debugger examples</td>
    <td class="content"> 
      New examples have been added to the Platform Debug git repository. The <code>org.eclipse.debug.examples.mixedmode</code> project demonstrates
      how to use Debug's mixed-mode launching support. The <code>org.eclipse.debug.examples.memory</code> project provides sample content to display
      in the <b>Memory</b> and <b>Registers</b> views.
    </td>
  </tr>
  <tr>
    <td colspan="2" class="section" id="PDE">PDE</td>
  </tr>
  <tr id="api-tag-visibility">
    <td class="title">API Tools javadoc tag visibility matches Java Language Specification</td>
    <td class="content">
     API Tools supports API restrictions using <a href="http://wiki.eclipse.org/PDE/API_Tools/Javadoc_Tags">javadoc tags</a> such as 
     @noextend and @noreference. The API Tools builder has an option to add problem markers for invalid use of the tags. The
     logic to check whether a tag is valid has been upgraded and now follows the visibility rules in the 
     <a href="http://docs.oracle.com/javase/specs/">Java Language Specification (JLS)</a>.
     <p><img src="images/tag-visibility.png" alt="Example tag visibility problem"/></p>
    </td>
  </tr>
  <tr id="api-tools-bree">
    <td class="title">API Tools moved to JavaSE-1.6</td>
    <td class="content">
     All API Tools plug-ins now have a bundle required execution environment (BREE) of JavaSE-1.6.
    </td>
  </tr>
  <tr id="target-no-preferences">
    <td class="title">Target platform content is no longer stored in preferences</td>
    <td class="content">
     The target platform specified on the <b>Target Platform</b> preference page uses flexible target definitions, stored in .target files,
     to specify the set of plug-ins PDE should build against and use to launch applications. However, the content of the target platform 
     was previously stored in preferences. This could lead to inconsistencies between what you expect to exist in the target platform and 
     what is actually available. This problem was more noticeable when using a complex target definition containing feature or software 
     site locations.
     
     <p>In Luna, the target platform information is always created from the target definition chosen on the preference
     page. In addition to reducing inconsistencies in the target, there are performance improvements when interacting with the 
     target.</p>
    </td>
  </tr>
  <tr id="feature-dialog-contains-plugins">
    <td class="title">Feature selection dialog filters by plug-ins</td>
    <td class="content">
     When entering text into the filter field of the feature selection dialog, features that contain a plug-in matching
     the filter will be returned. This provides a quick way to add the correct feature to include in a product.
     <p><img src="images/feature-selection.png" alt="The feature selection dialog"/></p>
    </td>
  </tr>
  <tr id="bundle-exceptions-in-editor">
    <td class="title">OSGi bundle exceptions are displayed in the manifest editor</td>
    <td class="content">
     Certain syntax errors, such as missing a comma between entries in the <code>Require-Bundle</code> header, cause bundle exceptions
     when PDE tries to add the bundle to an OSGi State. The exceptions are now logged and displayed in the manifest editor.   
     <p><img src="images/bundle-exception.png" alt="Bundle exception displayed in the manifest editor"/></p>
    </td>
  </tr>
  <tr>
    <td colspan="2" class="section" id="Equinox">Equinox</td>
  </tr>
  <tr id="framework-update">
    <td class="title">Equinox OSGi framework update</td>

    <td class="content">
      The Equinox Framework implementation has been updated to implement the latest
      API available for the upcoming OSGi R6 Core Framework specification 
      (to be finalized in March 2014).  Most of these
      were implemented as part of M1 also.  They are mentioned here again because
      OSGi has made the RFCs publicly available in a git repository as they are
      being written.  See the links below for the latest RFC documents:
      <ul>
         <li> Introduction of Service Scopes to the OSGi Service Registry
             (<a href="https://github.com/osgi/design/tree/master/rfcs/rfc0195">RFC 195</a>)
         </li>
         <li> Improvements of Weaving Hooks
             (<a href="https://github.com/osgi/design/tree/master/rfcs/rfc0191">RFC 191</a>)
         </li>
         <li> Clarification of hooks on the system bundle
             (<a href="https://github.com/osgi/design/tree/master/rfcs/rfc0198">RFC 198</a>)
         </li>
         <li> Native environment namespace
             (<a href="https://github.com/osgi/design/tree/master/rfcs/rfc0188">RFC 188</a>)
         </li>
         <li> Data Transfer Objects
             (<a href="https://github.com/osgi/design/tree/master/rfcs/rfc0185">RFC 185</a>)
         </li>
         <li> Extension Bundle Activators - new to M2
             (<a href="https://github.com/osgi/design/tree/master/rfcs/rfc0204">RFC 204</a>)
         </li>
         <li> Addition of FrameworkWiring.findProviders - no RFC
         </li>
      </ul>
    </td>
  </tr>
  <tr id="cm-update">
    <td class="title">Equinox Configuration Admin update</td>

    <td class="content">
      The Equinox Configuration Admin implementation has been updated to implement
      the OSGi Configuration Admin Service Specification version 1.5.  The previous
      release of Equinox Configuration Admin implemented version 1.3.
    </td>
  </tr>
  <tr id="region-update">
    <td class="title">Equinox Regions update</td>

    <td class="content">
      The Equinox Regions implementation has been updated to take advantage
      of Extension Bundle Activators
      (<a href="https://github.com/osgi/design/tree/master/rfcs/rfc0204">RFC 204</a>)
       coming in the OSGi R6 specification.
      This allows Equinox Regions to insert its isolation model before
      the framework is launched so that proper region behavior can be
      established before any bundles are loaded in the framework.
    </td>
  </tr>
  <tr id="metatype-update">
    <td class="title">Equinox Metatype update</td>

    <td class="content">
      The Equinox Metatype API has been updated to add the methods to
      get the minimum and maximum values of an attribute definition.
      (see <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=416640">bug 416640</a>)
    </td>
  </tr>
  <tr> 
    <td colspan="2">  </td>
  </tr>
</table>
<p>The above features are just the ones that are new since the previous milestone
build. Summaries for earlier Luna milestone builds:</p>
<ul>
  <li><a href="http://download.eclipse.org/eclipse/downloads/drops4/S-4.4M1-201308072000/news/">New for Eclipse Luna milestone build M1 (August 9, 2013)</a></li>
</ul>
</body>
</html>
