<!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 name="copyright" content="Copyright (c) Eclipse contributors and others 2018. This page is made available under license. For full details, see the LEGAL section in the documentation that contains this page."/>
<meta http-equiv="Content-Language" content="en-us"/>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
<link rel="STYLESHEET" href="../book.css" type="text/css"/>
<style type="text/css">
body {max-width: 900px;}
table.news col.title {width: 30%;}
/*img {max-width: 520px;}*/
table.news {table-layout: fixed; border-collapse: collapse; width: 100%;}
table.news td {border-top: solid thin black; padding: 10px; overflow: visible;}
table.news tr {vertical-align: top;}
table.news tr td.section {font-size: 20px; font-weight: bold;}
table.news tr td.title {vertical-align: top; font-weight: bold;}
table.news tr td.content {vertical-align: top;}
ul {padding-left: 13px;}
</style>
<title>Eclipse Platform What's New in Photon</title>
</head>

<body>
<h2>What's New in Photon</h2>
<p>Here are descriptions of some of the more interesting or significant changes 
made to the Eclipse Platform for the Photon (4.8) release of Eclipse. They are grouped into:</p>
<ul><!-- NOTE: Sync ../topics_WhatsNew.xml with this! -->
  <li><a href="#ViewsAndDialogs">Views, Dialogs and Toolbar</a></li>
  <li><a href="#Editor">Editors</a></li>
  <li><a href="#Debug">Debug</a></li>
  <li><a href="#Preferences">Preferences</a></li>
  <li><a href="#StylingThemes">Themes and Styling </a></li>
  <li><a href="#GeneralUpdates">General Updates</a></li>
</ul>
<p>
Plug-in developers will also be interested in the corresponding 
<a href="../../org.eclipse.platform.doc.isv/whatsNew/platform_isv_whatsnew.html">What's new</a>
document in the plug-in developer's guide.</p>
<p>We also recommend to read the <a href="../tips/platform_tips.html">Tips and Tricks</a>.</p>
<br/>

<table class="news">
<colgroup>
  <col class="title" />
  <col />
</colgroup>
<tbody>

  <!-- ******************* Views, Dialogs and Toolbar ************************************* -->
  <tr>
    <td id="ViewsAndDialogs" class="section" colspan="2">
    <h2>Views, Dialogs and Toolbar </h2>
    </td>
  </tr>
  
  <tr id="windows-modern-directory-dialog">
    <td class="title">DirectoryDialog on Windows now uses modern style</td>
    <td class="content">
      The <b>DirectoryDialog</b> on Windows has been re-implemented to use the modern native widget introduced in Windows Vista. 
      The new look and feel is as illustrated below: 
      <p>
        <img src="images/windows-modern-directory-dialog.png" alt=""/>
      </p>
      <p>
		<b>Regarding usage of newer <code>DirectoryDialog</code> on Windows:</b>
		In the old <code>DirectoryDialog</code>, there was an option to set a text message to specify the purpose of the <code>DirectoryDialog</code> using <code>DirectoryDialog#setMessage(String)</code>.
		This functionality is no more available with the newer <code>DirectoryDialog</code>.
      </p>
      <p>
		Hence, you should revisit the usage of <code>DirectoryDialog.setMessage(String)</code> in your projects, and if needed elaborate the Title field of <code>DirectoryDialog</code> using <code>DirectoryDialog.setText(String)</code> method.
      </p>
      <p>
		<b>Note:</b> It's recommended to use a minimal set of words in the Title field of <code>DirectoryDialog</code> and avoid making it look clumsy.
      </p>
    </td>
  </tr>
  
  <tr id="quickaccess-matches-preference-keywords">
    <td class="title">Quick-Access matches Preference pages by keyword</td>
    <td class="content">
      <b>Quick-Access</b> (<code>Ctrl+3</code>) now also returns Preference pages that have a keyword matching user
      input.
      <p>
        <img src="images/quickAccessMatchesPrefKeywords.png" alt=""/>
      </p>
    </td>
  </tr>
  
  <tr id="perfect-match-first-selection-dialogs">
    <td class="title">Perfect matches appear first in selection dialogs</td>
    <td class="content">
      Within selection dialogs, including <b>Open Type</b> and <b>Open Resource</b>, perfect matches appear as the first result, ensuring that users no longer have to scroll through historical matches and the alphabetically sorted list to find their desired result.
      <p>
        <img src="images/perfect-match-first-search.png" alt=""/>
      </p>
    </td>
  </tr>
  
  <tr id="open-resource-highlight-matching">
    <td class="title">Open resource dialog highlights matching characters</td>
    <td class="content">
      The matching characters from the filter are now highlighted in the <b>Open Resource</b> dialog.
      <p>
      <img src="images/open-resource-highlight-matching.png" alt=""/>
      </p>
    </td>
  </tr>
  
  <tr id="open-resource-highlighting">
    <td class="title">Expanded highlighting in Open Resource Dialog</td>
    <td class="content">
      The <b>Open Resource</b> dialog now shows you how the search term matches the found resources by highlighting the names based on camel-case and pattern ( * and ? ) searches.
      <p>
        <img src="images/open-resource-highlight.png" alt=""/>
      </p>
    </td>
  </tr>
  
  <tr id="open-resource-dialog-paths">
    <td class="title">Open resource dialog always shows the paths</td>
    <td class="content">
      You can now use the <b>Open Resource</b> dialog to see the file paths.
      Previously it only showed the paths if there were duplicate entries.
      <p><img src="images/open-resource-dialog.png" alt="after"/></p>
    </td>
  </tr>
  
  <tr id="unde-redo-toolbar">
    <td class="title">Undo/Redo Toolbar Buttons</td>
    <td class="content">
      The main <b>Toolbar</b> can now show Undo and Redo buttons.
      <p>
        <img src="images/undo-redo-toolbar.png" alt=""/>
      </p>
      <p>The buttons are not available by default. They can be added via <b>Window > Perspective > Customize Perspective...</b></p>
      <p>
        <img src="images/undo-redo-customize.png" alt=""/>
      </p>
    </td>
  </tr>
  
  <tr id="browser-autorefresh">
    <td class="title">Browser Editor can toggle auto-refresh</td>
    <td class="content">
      The <b>Browser Editor</b> now contains a drop down option for enabling auto-refresh for local pages. When enabled, the <b>Browser Editor</b> will automatically refresh if the opened file is edited and saved.
      <p>
        <img src="images/browser-autorefresh.png" alt=""/>
      </p>
    </td>
  </tr>

 <tr id="edit-project-natures">
    <td class="title">Modify project natures</td>
    <td class="content">
      The <b>Project Properties</b> dialog now features a page to add or remove natures on a project.
      <p>
        <img src="images/editNatures.png" alt="" />
      </p>
      As mentioned on the page, some natures may not properly handle manual addition/removal, so using
      this can lead to some inconsistencies in those cases.
    </td>
  </tr>
  
  <tr id="open-close-workingset-projects">
    <td class="title">Open/Close Projects by Working Set in Project Explorer</td>
    <td class="content">
      The ability to Open, Close, Close Unrelated, and Build all appropriate projects in a Working Set has been added to the right click menu of Working Sets in the <b>Project Explorer</b>.
      <p>
        <img src="images/open_close_workingsets.png" alt=""/>
      </p>
    </td>
  </tr>
  
   <tr id="close-newly-imported-projects-upon-completion">
    <td class="title">Close newly imported projects upon completion</td>
    <td class="content">
      The <b>Import Wizard</b> offers you the option to close the newly imported projects upon completion of the import process.
	  This might be beneficial if you're importing many projects and/or some projects have time-consuming builders configured.
	  <p>
	  This affects the wizards reachable via <b>File > Open Projects...</b>, <b>File > Import... > Existing Projects into Workspace</b>
	  and <b>File > Import > Projects from Folder or Archive</b>
	  </p>
      <p>
        <img src="images/close-newly-imported-projects-upon-completion.png" alt="Smart Import Wizard"/>
      </p>
    </td>
  </tr>
  
  <tr id="delete-nested-projects">
  	<td class="title">Delete nested projects</td>
  	<td class="content">
  		The <b>Delete Resources</b> dialog now shows a <b>Delete nested projects</b> option to delete all projects whose location on file system is a descendant of one of the selected projects.
  		<p>
        <img src="images/delete-nested-projects.png" alt=""/>
      </p>
  	</td>
  </tr>
  
  <!-- ******************* Editors ************************************* -->
  <tr>
    <td id="Editor" class="section" colspan="2">
    <h2>Editors </h2>
    </td>
  </tr>

  <tr id="default-font-macos">
    <td class="title">Improve readability of default text font on macOS</td>
    <td class="content">
      Reading the source code is the task developers perform the most during coding. So text editors must assist the user as good as possible with that.
      <p>
      Up to now Eclipse running on macOS used the font "Monaco" as the default text editor font. This font does not contain a bold font face. But a lot of source code editors render keywords in the bold font face. With "Monaco" this feature was not available.<br/>
      </p>
      Before:
      <p>
      <img src="images/Monaco.png" alt=""/>
      </p>
      <p>
      On macOS Eclipse Photon now uses the "Menlo" font as the default text font, which does also contain bold font faces. This increases readability in source code editors using bold font faces.<br/>
      </p>
	  After:
      <p>
      <img src="images/Menlo.png" alt=""/>
      </p>
    </td>
  </tr>
  
  <tr id="swt-gtk3-caret-performance">
    <td class="title">Improved caret performance on GTK3</td>
	<td class="content">Caret performance on the SWT GTK3 port has been enhanced to allow for smoother
		drawing. Previously the caret stuttered when moved or when other controls in the same
		shell were manipulated. Now the caret moves smoothly and blinks at a consistent rate.
	</td>
  </tr>
  
  <!-- ******************* Debug ************************************* -->
  <tr>
    <td id="Debug" class="section" colspan="2">
    <h2>Debug </h2>
    </td>
  </tr>
  
  <tr id="debug-perspective-changed">
    <td class="title">Debug perspective layout changed</td>
    <td class="content">
      Default <b>Debug Perspective</b> layout has changed, see screenshot below. 
      <p>
      The aim is to give the editor area more space and to show more relevant information without scrolling.
      <b>Display View, Expressions View and Project Explorer</b> are now shown by default, <b>Problems View</b> replaces <b>Tasks</b>.
      </p>
      <p>
        <img src="images/debug_perspective_changes.png" alt=""/>
      </p>
    </td>
  </tr>
  
  <tr id="export-launch-configurations">
    <td class="title">Right click option to export Launch Configurations</td>
    <td class="content">
      The <b>Export Launch Configurations Wizard</b> is now accessible through the right click menu on Launch Configurations. This wizard is still available with <b>File > Export > Run/Debug > Launch Configurations</b>
      <p>
        <img src="images/right-click-export-launch-config.png" alt=""/>
      </p>
    </td>
  </tr>
  
   <tr id="worker-deobfuscated-platform">
    <td class="title">Workers use job names as thread names</td>
    <td class="content">
      The <b>Jobs Framework</b> now uses <code>Job</code> names for <code>Worker</code> thread names.
      <p>
      Previously all running <code>Worker</code>'s got enumerated thread names, without any hint what the
      current <code>Worker</code> is actually doing:
      </p>
      <p>
        <img src="images/worker_obfuscated.png" alt="Worker names before M5" />
      </p>

      Now the <code>Job</code> name is added
      next to the <code>Worker</code> name:

      <p>
        <img src="images/worker_deobfuscated.png" alt="Worker names after M5" />
      </p>
    </td>
  </tr>
  
  <!-- ****************** Preferences ************************************* -->
  <tr>
    <td id="Preferences" class="section" colspan="2">
    <h2>Preferences </h2>
    </td>
  </tr>
  
   <tr id="content-type-editor-association">
    <td class="title">Manage associations of content types with editors</td>
    <td class="content">
      The <b>Content Types</b> Preference page has been extended to allow you to view, create and 
      remove associations with editors.
      <p>
      <img src="images/content-type-editor-association.png" alt=""/>
      </p>
      Using the content type to define editor association is to be preferred over using the <b>File Associations</b>
      preferences.
    </td>
  </tr>
  
  <tr id="contenttype-filename-pattern">
    <td class="title">Associate content type with a file name pattern</td>
    <td class="content">
      From the <b>Preferences > General > Content Types</b> preference page, you can now
      associate a content type with a file name pattern and use <code>?</code> or <code>*</code> wildcards at any place in that pattern
      (respectively to match any character or any string).
    <img src="images/wildcard-content-type-association.png" alt=""/>
    </td>
  </tr>
  
   <tr id="parallel-builds-preference">
    <td class="title">Allow workspace to build projects in parallel</td>
    <td class="content">
      The <b>Workspace</b> preference page now has a new option to allow the workspace to build projects in parallel:
      <p><img src="images/preferences-simultaneous-builds.png" alt="preference page screenshot"/></p>
      <p>Under some safe circumstances, the workspace can now choose to build independent projects in parallel. In such
      case, the maximum amount of jobs/threads that will be running builds in parallel will be controlled by this preference. A value of
      <code>1</code> will indicate that build won't be parallelized keeping the legacy behavior.</p>
      <p>The optimal value will depend on the machine and workspace projects specificities. Recommendation is to try relatively
      low values (such as <code>4</code>) first which will allow to save time, when allowed by projects, while not risking
      the CPU overload.</p>
    </td>
  </tr>
  
  <tr id="report-missing-nature-as-marker">
    <td class="title">Report reference to missing nature as error marker</td>
    <td class="comment">
      On the <b>Workspace</b> preference page, there is now a new option to define the severity of an error marker
      to show on a project when it references a nature that is not available.
      <p>
        <img src="images/missing-nature-preference.png" alt=""/>
      </p>
      <p>As a typical error marker, it is shown as decorator in the <b>Project Explorer</b> and as an
      entry in the <b>Problems</b> view.</p>
      <p>
        <img src="images/missing-nature-marker.png" alt=""/>
      </p>
      <p>Clients can associate marker resolution factories to these markers, whose type id is <code>org.eclipse.core.resources.unknownNature</code>.</p>
    </td>
  </tr>
  
  <tr id="keys-export-commandid-csv">
    <td class="title">Export command id of key bindings to CSV</td>
    <td class="content">
      On the <b>Keys</b> preference page the <b>Export CSV</b> action exports additionally the command id for key bindings.
      <p>
        <img src="images/export-keys-dialog.png" alt="Keys Preference Page"/>
      </p>
      <p>
        <img src="images/export-keys-csv.png" alt="Exported CSV file"/>
      </p>
    </td>
  </tr>
  
  <tr id="preference-import-export-buttons">
    <td class="title">Import/export preferences from preference dialog</td>
    <td class="content">
     Easily accessible buttons for opening the <b>Import/Export</b> preferences wizards have been added to the lower left corner of the <b>Preferences</b> dialog. The wizards are still accessible through the <b>File > Import...</b> and <b>File > Export...</b> wizards.
     <p>
    <img src="images/preference-import-export.png" alt=""/>
    </p>
    </td>
  </tr>

  <!-- ******************* Themes and Styling ************************************* -->
  <tr>
    <td id="StylingThemes" class="section" colspan="2">
    <h2>Themes and Styling </h2>
    </td>
  </tr>
  
  <tr id="macos-waiting-cursor">
    <td class="title">Animated waiting cursor on macOS</td>
    <td class="content">
      During long running UI actions the cursor switches to a waiting cursor. On macOS, this used to be a static black/white circle.
      <p>In Eclipse Photon the macOS system's busy cursor is changed to a spinning blue ball (also called beach ball).</p>
      <p>
        <img src="images/macos-wait-cursor.png" alt=""/>
      </p>
    </td>
  </tr>
  
  <tr id="range-indicator-color">
    <td class="title">Configure the color of text editor's range indicator</td>
    <td class="content">
      The <b>Text Editor</b>'s range indicators's color can now be configured via the <b>Colors and Fonts</b> preference page.
      <p><img src="images/range_ind_pref.png" alt="Range indicator in the Colors and Fonts preference page"/></p>
    </td>
  </tr>

  <tr id="range-indicator-dark-theme">
    <td class="title">Styling for text editor's range indicator</td>
    <td class="content">
      The Eclipse default dark theme now includes styling for the <b>Text Editor</b>'s range indicator.
      <p><img src="images/range_ind_dark.png" alt="Range indicator in the dark theme"/></p>
    </td>
  </tr>

  <tr id="text-editor-icons-dark-theme">
    <td class="title">Improved text operation icons for the dark theme</td>
    <td class="content">
      The block selection, word warp and show whitespace icons have been adjusted to look good in the dark theme.
      <p>Before:<br/><img src="images/old-text-toolbar-entries.png" alt="before"/></p>
      <p>After:<br/><img src="images/new-text-toolbar-entries.png" alt="after"/></p>
    </td>
  </tr>

  <tr id="popup-dialog-dark-theme">
    <td class="title">Improved popup dialogs for the dark theme</td>
    <td class="content">
      Popup dialogs, for example the platform's update notification popup now uses a dark background and a light foreground color in the dark theme.
      <p><img src="images/update_dialog_dark.png" alt="Update dialog in dark theme"/></p>
    </td>
  </tr>

  <tr id="font-dark-text-editor">
    <td class="title">Improved text color in text editor for the dark theme</td>
    <td class="content">
      The <b>Text Editor</b> now uses an improved font color in the dark theme so that you can read better.
      <p><img src="images/text-editor-dark-font-new.png" alt="after"/></p>
    </td>
  </tr>
  
   <tr id="flat-layout-tabbed-properties-view">
    <td class="title">Flat layout in tabbed properties view</td>
    <td class="content">
      In the light theme the <b>Tabbed Properties</b> view now completely uses the same flat styling as the form-based editors do.
      <p>
        <img src="images/prop_light.png" alt=""/>
      </p>
    </td>
  </tr>

  <tr id="expand_collapse-dark-theme">
    <td class="title">Improved the text editor's expand and collapse nodes for the dark theme</td>
    <td class="content">
      The collapse and expand nodes in the text editor's left hand side ruler were improved for the dark theme.
      <p><img src="images/expand_old_new.png" alt="old and new version of the icons"/></p>

    </td>
  </tr>
  <tr id="occurrences_generic_editor-dark-theme">
    <td class="title">Improved the generic editor's mark occurrences annotation color for the dark theme</td>
    <td class="content">
      The occurrences annotation marker color in the generic editor's left hand side ruler were improved for the dark theme. Image is zoomed for better visibility.
      <p><img src="images/annotations.png" alt="old and new version of occurrence annotation"/></p>

    </td>
  </tr>
  <tr id="occurrences_label_generic_editor-dark-theme">
    <td class="title">Improved the generic editor's mark occurrences annotation label</td>
    <td class="content">
      The occurrences annotation marker label has been improved to show the word occurring rather than the line. In the image below, see the difference between old label at the top and the new one at the bottom.
      <p><img src="images/annotationlabel.png" alt="old and new version of occurrence annotation"/></p>

    </td>
  </tr>

  <tr id="canvas-css-styling">
    <td class="title">Canvas elements are  styled in the default dark theme</td>
    <td class="content">
      The default dark theme now contains CSS for styling Canvas elements by default.
      <p><b>Old:</b></p>
      <p><img src="images/color-fonts-canvas-old.png" alt=""/></p>
      <p><b>New:</b></p>
      <p><img src="images/color-fonts-canvas-new.png" alt=""/></p>

    </td>
  </tr>

  <tr id="detach-editor-view">
    <td class="title">Detach view or editor via its context menu</td>
    <td class="content">
      You can now detach a view or an editor via its context menu.
      <p><img src="images/detach-editor.png" alt=""/></p>

    </td>
  </tr>

  <tr id="links_in-dark-theme">
    <td class="title">Consistently use blue color for links in the dark theme</td>
    <td class="content">
      Links now consistently use a light blue color in the dark theme. One example where this was very visible is PDE's manifest editor:
      <p><img src="images/links_in_dark_theme.png" alt="PDE's mantifest editor showing before and after"/></p>
    </td>
  </tr>

  <tr id="tree-table-scaling">
    <td class="title">Improved Tree and Table widget scaling at high DPI on Windows</td>
    <td class="content">
      Trees and Tables scale Checkboxes and expand/collapse buttons properly.
      <p><img src="images/tree-table-scaling.png" alt="Tree widget image before and after"/></p>
    </td>
  </tr>

  <tr id="gtk3-theme-override-support">
    <td class="title">GTK_THEME override support for SWT-GTK3</td>
    <td class="content">
      Eclipse SWT on GTK3.14+ now supports the use of GTK_THEME as an environment variable. SWT applications are correctly styled
      when using the GTK_THEME environment variable to override the system theme, and/or specify a dark variant. Below are the before
      and after screenshots of ControlExample running with GTK_THEME=Adwaita:dark set.
      <p><b>Before:</b><br/><img src="images/gtk3-theme-override-support-before.png" alt="before"/></p>
      <p><b>After:</b><br/><img src="images/gtk3-theme-override-support-after.png" alt="after"/></p>
    </td>
  </tr>
  <!-- ******************* General Updates ************************************* -->
  <tr>
    <td id="GeneralUpdates" class="section" colspan="2">
    <h2>General Updates </h2>
    </td>
  </tr>

  <tr id="gtk3-accessibility">
    <td class="title">Accessibility support on GTK3</td>
    <td class="content">
      Significant improvements have been made in the <b>Accessibility</b> support on the SWT Linux/GTK3 port. Prior to Photon, accessibility support on GTK3 was limited and often led to assistive technologies not interacting properly with SWT.
      <p>In Photon, Eclipse on Linux is accessible again. Users are able to use assistive technologies seamlessly with SWT GTK3, just as they were able to with GTK2, and without any hangs or crashes.</p>
    </td>
  </tr>
  
  <tr id="refresh-on-access">
    <td class="title">Refresh on access 'ON' by default</td>
    <td class="content">
      For years the Eclipse IDE is shipping with a customization that files are automatically refreshed if the user accesses them.
      But, other Eclipse based tools like the Spring Tools Suite were missing this customization.
      <p>Refresh file on access is now 'ON' by default, so the other Eclipse based tools do not have to manually instruct their IDE to see the update.</p>
    </td>
  </tr>
  
  <tr id="e4-tools">
    <td class="title">Added e4 tools to SDK product</td>
    <td class="content">
      The e4 tools for developing e4 based IDE and RCP components are now included in the SDK.
      The tooling can be removed via the <b>Installation Details</b> dialog.
    </td>
  </tr>

  <tr id="swt-gtk3-memory-usage">
    <td class="title">Improved memory usage on SWT-GTK3</td>
    <td class="content">
      Eclipse SWT on GTK3 has reduced memory usage after resolving a memory leak in setBackground/setForeground Color machinery. The leak
      was approximately 50MB/hour and affected clients running SWT on GTK3.14+.
    </td>
  </tr>

  <tr id="ant-version-upgrade">
    <td class="title">Ant 1.10.3</td>
    <td class="content">
      Eclipse has adopted Ant version 1.10.3.
    </td>
  </tr>
  
  <tr id="lucene-7.0-update">
    <td class="title">Lucene update</td>
    <td class="content">
      Lucene bundles have been updated to version 7.0. The org.apache.lucene.misc bundle is not included as it's no longer needed by the Help system. 
      This new Lucene version comes with new index version thus clients providing prebuilt indexes have to rebuild them with Lucene 7.0 for the index to be used, 
      if the old version is supplied, Eclipse Help system will not use that index and generate a new one locally.
    </td>
  </tr>
  
  <tr id="winxp-dropped">
    <td class="title">Dropped support for Windows XP</td>
    <td class="content">
	  Eclipse has dropped support for the Windows XP Operating System and other Windows versions older than Windows Vista.
	  <p>
	  For more information, please read the <a href="https://dev.eclipse.org/mhonarc/lists/cross-project-issues-dev/msg15385.html" target="_blank">announcement</a> made by the Eclipse PMC.
	  </p>
    </td>
  </tr>
  
  <tr id="dropped-xulr-support">
    <td class="title">Dropped support for XULRunner</td>
    <td class="content">
    	  Eclipse/SWT has dropped support for XULRunner as a browser rendering engine on all platforms.
    </td>
  </tr>
  
  <tr id="cvs-removal">
    <td class="title">Removed CVS from SDK product</td>
    <td class="content">
      CVS support is not included in the SDK anymore. The CVS feature can be installed from the platform update site.
    </td>
  </tr>

</tbody>
</table>

</body>
</html>
