Fetching contributors…
Cannot retrieve contributors at this time
415 lines (254 sloc) 39.2 KB

GEF 5.0.0 (Oxygen)

Annual release providing major revisions (5.0.0) of all production components, which have been adopted to the original project namespace ('GEF4 + 1 = GEF 5') and are now consistently referred to as GEF components.

GEF Common (5.0.0)

  • #506816 Ensured AdaptableSupport and ActivatableSupport do not interleave. Both are now side-effect free, i.e. AdaptableSupport no longer deals with activating/deactivating of adapters, while ActivatableSupport now ignores registered adapters.

  • #506330 Added support for transitive role-based adapter bindings. This can be used to inject different types of adapters dependent on the adaptable-'position' within the adaptable-adapter chain. In case an adapter map binding is bound to a (potentially transitive) role, its injection is now deferred until the complete adaptable-adapter chain has been established. A potential use case is to bind different behaviors and policies for visual parts within respective viewers:

  // bindings related to GeometricShapePart within content viewer
    AdapterKey.get(IViewer.class, CONTENT_VIEWER_ROLE)));
  // bindings related to GeometricShapePart within palette viewer  
    AdapterKey.get(IViewer.class, PALETTE_VIEWER_ROLE)));
  • #516080 Fixed several issues related to scoping of adapters. Revised adapter injection to properly follow Guice API.

GEF Geometry (5.0.0)

  • Added support for computing Bezier offset approximation.

For a given BezierCurve, the offset at a given (signed) distance can be computed via the new #getOffsetRefined() and #getOffsetUnprocessed() methods. The offset is an approximation consisting of multiple continuous BezierCurve objects, so that it can be represented by a PolyBezier. During refinement, segments are removed from the unprocessed offset approximation that do not contribute to the offset outline, i.e. local self-intersections and start/end segments covered by other offset outlines. Most global self-intersections should be preserved. However, in some cases the algorithm might cut them out, which needs to be addressed in a later version.

On the other hand, no segments are removed from the unprocessed offset. Therefore, you can see segments containing cusps, which are contained within the offset, and do not contribute to its outline. The refinement process is meant to remove as many segments, not contributing to the offset outline, from the unprocessed offset, as possible, so that it is still a continuous curve, which can be represented as a PolyBezier.

GEF FX (5.0.0)

  • #501056, #495469, #499676, #510946, #511983, #511601 Reimplemented event forwarding within FXCanvasEx, so it can now be transparently used in a Java 8 and 9 environment (see 'GEF4 + 1 = GEF 5' for details). Complemented functionality by adding a workaround for JDK-8159227.

  • #501329 Reimplemented grid by using a tile-based JavaFX background within InfiniteCanvas, increasing performance significantly and removing overflow caused restrictions of zoom and scroll.

GEF MVC (5.0.0)

  • #496248 As motivated in 'GEF4 + 1 = GEF 5', MVC was merged with MVC.FX and MVC.UI with MVC.FX.UI to remove JavaFX indepent abstractions. While being bound to JavaFX, the code base is now much more slim and easier to use.

  • #510415 Renamed 'Tool' into 'Gesture', 'InteractionPolicy' into 'Handler', and 'TransactionPolicy' into 'Policy', so concepts are more concisely named (and better distinguishable).

  • #504480 Revised IBendableContentPart and introduced ITransformableContentPart and IResizableContentPart abstractions to provide support for basic graphical operations through callbacks within IContentPart (as in case of content related operations).

  • Separated hover concept into 'transient' and 'intended' hover.

  • #506331 Ensured that IContentPart, IFeedbackPart, and IHandlePart are now adapted to the viewer (IAdaptable.Bound) so that role-based adapter map binding can now be used for them. This enables that the same visual parts can be re-used in content and palette viewers, but with different behavior and policy bindings.

  • #482139 Provided several action implementations related to zooming and scrolling of the viewport:

  • #503342 Replaced ContentModel with a dedicated contents property within IViewer, as its a first-level concept.

  • #501716 Refactored snapping support and added support for snap-to-geometry.

GEF Graph (5.0.0)

  • #508822, #509077 Made several improvement to graph, node, and edge builders.

  • #497662, #509078 Fixed several issues related to GraphCopier.

GEF Layout (5.0.0)

  • Changed that ILayoutAlgorithm no longer has to keep a reference to the LayoutContext, which is now passed in on layout calls. Revised implementations of algorithms to remove code that was unused because it dealt with 'dynamic' layout.

GEF DOT (5.0.0)

  • #491261 Provide a consistent API for importing and exporting of DOT. Re-implemented DotImport using Xtend, merging DotInterpreter into it.

  • #321775 Added support for HTML IDs in the DOT host grammar as well as support for parsing and serializing HTML-like labels within DOT editor.

  • #511843 Added support for Subgraphs/Clusters within DotImport, DotExport, DOT editor and DOT Graph view.


GEF 4.1.0 (Neon.1)

Update release providing minor (1.1.0) respectively micro (1.0.1) revisions of all GEF4 components (Common, Geometry, FX, MVC, Graph, Layout, Zest, DOT, and Cloudio). All API extensions are motivated by bugfixing, the API is fully backwards compatible to that of the previous GEF 4.0.0 (Neon) release.

GEF 4.0.0 (Neon)

Annual release providing first graduation revisions (1.0.0) of the previously only preliminary published GEF4 components (Common, Geometry, FX, MVC, Graph, Layout, Zest, DOT, and Cloudio).

As declared in the 4.0.0 (Neon) project plan, the decision about contributing GEF4 in version 1.0.0 (instead of 0.3.0) and an overall 4.0.0 release (instead of 3.11.0) was postponed up to M5. That is, Bugzilla entries commented before Neon M6 will refer to a 3.11.0 release and milestone contributions (including M5) include GEF4 components in version 0.3.0.

Please note that several incompatible changes to the (up to 0.2.0 provisional) API of GEF4 were made. The list of added and removed classes is documented in the GEF4 0.2.0-1.0.0 API Diff. The most notable API changes are outlined below.

GEF4 Common (1.0.0)

  • #484774 As outlined in detail in 'GEF4 Collections and Properties - Guava goes FX' the property notification support provided by Common has been replaced with JavaFX observable collections and properties. In this turn, the Common component has been augmented to provide observable collections and related collection properties for Guava's SetMultimap and Multiset, as well as replacements for the ObservableSet, ObservableList, and ObservableMap collections and related collection properties provided by JavaFX.

  • #482972 The adapter map injection support, described in detail in 'Adaptable - GEF4's interpretation of a classic', has been updated to ensure that adapter can always been retrieved via their actual runtime type, as well as been augmented with support for role-based adapter injection.

  • #481677 Adapter map bindings can now be restricted to an adaptable of a certain role. Thereby, different bindings can e.g. be provided for a 'content' FXViewer and a 'palette' FXViewer.

protected void configure() {
  // bind adapters for FXRootPart of role 'FXDomain.CONTENT_VIEWER_ROLE'
  bindContentViewerRootPartAdapters(AdapterMaps.getAdapterMapBinder(binder(), FXRootPart.class, FXDomain.CONTENT_VIEWER_ROLE));

GEF4 FX (1.0.0)

  • #471154 Renamed FX.UI module into FX.SWT module and added FXColorPicker, FXSimpleLinearGradientPicker, and FXAdvancedLinearGradientPicker, which were provided by MVC.FX.UI module before (refactored from AbstractFXColorPicker, FXColorPicker, FXSimpleGradientPicker, and FXAdvancedGradientPicker). Introduced new FX.JFace module, which provides FXPaintCellEditor and FXPaintSelectionDialog, which were provided by MVC.FX.UI module before (refactored from FXFillCellEditor and FXFillSelectionDialog).

  • #479395 Merged ScrollPaneEx and FXGridCanvas into a newly created InfiniteCanvas. The InfiniteCanvas does now allow to insert visuals at different "positions" inside of the InfiniteCanvas: underlay group, scrolled underlay group, content group, scrolled overlay group, overlay group.

  • #454681 Added support to Connection for having a clickable area that is thicker than the connection stroke and allows to select also very thin connections. Its width is exposed by a property of Connection, so it can be bound (e.g. to adjust the width of the clickable area dependent on the scaling). Enhanced the MVC logo example to demonstrate example usage of this feature.

  • #454907 Ensured that Connection properly clips its start and end decorations.

  • #488356 Introduced support for orthogonal routing of a Connection, including support for start and end poin hints. While doing so, separated routing (manipulation of control points) from interpolating (visual appearance), so that routers (straight, orthogonal) and interpolators (poly-line, poly-bezier) can be freely mixed.

  • Revised DynamicAnchor and its IComputationStrategy to be comparable to a JavaFX binding, where the resulting position value is based on observable computation parameters that might depend on the anchorage (static) or anchored visual (dynamic). This allows to determine the values of computation parameters via JavaFX bindings.
getComputationParameter(AnchorageReferenceGeometry.class).bind(new ObjectBinding<IGeometry>() {

  protected IGeometry computeValue() {
    return NodeUtils.getShapeOutline(anchorage);
  • #443954 GeometryNode has been revised to extend Region instead of Parent, so it no longer relies on overriding the impl_computeLayoutBounds() method that is deprecated and announced to be removed in future JavaFX releases. The API of GeometryNode was enhanced so that it does now allow to use relocate(double, double) and resize(double, double) to update the layout bounds (including layoutX and layoutY) while relocateGeometry(double, double) and resizeGeometry(double, double) can be used to update the geometric bounds. The layout bounds (and layoutX, layoutY) resemble the geometric bounds, expanded by a stroke offset (dependent on stroke width and type) and border insets.

GEF4 MVC (1.0.0)

  • #477352 The FXTransformPolicy now provides an API for the creation and manipulation of transformation matrices. These matrices are then concatenated, together with the initial host transformation matrix, to yield the new host transformation matrix. Therefore, complex transformations can be set up properly at one point, and the important values can be changed later on, e.g. during user interaction. All transaction and interaction policies related to transforms (FXRelocateConnectionPolicy, FXRelocateOnDragPolicy, FXResizeRelocateOnHandleDragPolicy, FXResizeRelocatePolicy, FXRotatePolicy, FXRotateSelectedOnHandleDragPolicy, FXRotateSelectedOnRotatePolicy, FXScaleRelocateOnHandleDragPolicy, and FXScaleRelocatePolicy) have been renamed to express the actual transformation (e.g. "translate" instead of "relocate"). Additionally, the intermediate FXResizeRelocatePolicy, FXRotatePolicy, and FXScaleRelocatePolicy have been removed. The policies that were dependent on those intermediate policies now directly use the FXTransformPolicy.

  • #479612 Cleaned up ContentPolicy to only provide operations related to the content of the respective host part. It is intended to be registered at each IContentPart. Moved all "higher-level" operations into CreationPolicy and DeletionPolicy, which are to be registered at the IRootPart alone.

  • #480875 Updating the selection, hover, and focus models is now handled within the CreationPolicy and the DeletionPolicy and the ClearHoverFocusSelectionOperation has been removed. The CreationPolicy selects and focusses a newly created part. The DeletionPolicy removes the deleted parts from the selection and focus models. Moreover, the CreationPolicy creates the IContentPart before executing operations on the history. Therefore, the content part can be used for live feedback even though the creation is not yet committed.

  • #481600 Changed the implementation of ContentBehavior to ensure that deactivation does not remove children of its host. This way, deactivation of an FXViewer can now be temporarily applied (to disable all listeners) without loosing the content of the viewer.

  • #488358 In addition to straight routing based on circle handles, FXBendFirstAnchorageOnSegmentHandleDragPolicy and FXBendConnectionPolicy now support orthogonal routing based on rectangle handles. Analogously to the way point based case, non-filled handle can be used to create new segments, whereas solid handles are used to move segments. Overlay of segments and 'normalization' (i.e. removal of overlaid segments) are performed during interaction.

  • #493553 IDomain now accepts only ITransactionalOperations to execute. This allows to filter non content-related operations (like selection of focus change) in case only content-relevant changes should be undoable.

  • #481688 The MVC Logo example has been augmented by a fly-out palette for object creation, to demonstrate how multiple viewers can be combined in a single domain.

GEF4 Layout (1.0.0)

  • #491097 The LayoutContext and ILayoutAlgorithm now use a Graph data model as input and output model for layout calculations instead of its own layout interface abstractions.
Graph graph = ...

GEF4 Graph (1.0.0)

  • #480293 Enhanced the builder API so that graph-, node-, and edge-builders can be chained appropriately. Node-builders can now be provided with an Object-key, that can be referred to by edge-builders.
Graph g1 = new Graph.Builder()
.attr(DotAttributes._TYPE__G, DotAttributes._TYPE__G__DIGRAPH)//
.attr(DotAttributes.LABEL__GNE, "1")//
.attr(DotAttributes.ID__GNE, "1")//
.attr(DotAttributes.LABEL__GNE, "2")//
.attr(DotAttributes.ID__GNE, "2")//
.attr(DotAttributes.LABEL__GNE, "3")//
.attr(DotAttributes.ID__GNE, "3")//
.edge("n1", "n2")//
.edge("n1", "n3")//
  • #484774 All relevant properties are now exposed as JavaFX observable collections/properties.

GEF4 Zest (1.0.0)

  • #470636 Separated out the Zest JFace-API into an own module (Zest.FX.JFace), so it can be consumed without introducing dependencies on the Eclipse Workbench UI.

  • #478944 Removed IEdgeDecorationProvider from Zest.FX.JFace. Respective ZestProperties.EDGE_SOURCE_DECORATION and ZestProperties.EDGE_TARGET_DECORATION attributes may be provided via IGraphNodeLabelProvider#getEdgeAttributes() instead.

class MyLabelProvider extends LabelProvider  implements IGraphAttributesProvider {	
  public Map<String, Object> getEdgeAttributes(Object sourceNode, Object targetNode) {
    Map<String, Object> edgeAttributes = new HashMap<>();
    edgeAttributes.put(ZestProperties.SOURCE_DECORATION__E, new CircleHead());
    edgeAttributes.put(ZestProperties.TARGET_DECORATION__E, new DiamondHead());
    edgeAttributes.put(ZestProperties.CURVE_CSS_STYLE__E, "-fx-stroke: red;");
    return edgeAttributes;

GEF4 DOT (1.0.0)

The DOT component has been completely revised and has made significant progress towards a full DOT authoring environment. It does not provide public API yet and is currently limited to provide end-user functionality.

  • #446639 A Graphviz preference page has been added, via which the path to the native dot executable and a Graphviz export format can be specified.

  • #337644 A 'Sync Graphviz Export' toggle has been added as a DOT editor action to the main toolbar (it was previously located in the DOT Graph view). If enabled, it will export the persisted state of a currently edited DOT file in the format specified in the Graphviz preferences.

  • The DOT Graph view will now use the native dot executable (if specified via the preferences) for layout (native mode), while it will otherwise use a comparable Layout algorithm (emulated mode).

  • #477980 The DOT Graph view now also provides additional rendering capabilities, including edge decorations, splines, as well as all available kind of labels (for edges and nodes).

  • The DOT editor has been enhanced with additional validation support for arrowtype, point, splinetype, shape, and style attribute values.

GEF 3.10.1 (Mars.1)

Update release providing minor revisions (0.2.0) of the preliminary GEF4 components.

Please note that some minor adjustments have been applied to the provisional API of GEF4. The list of added and removed classes can be found at GEF4 0.1.0-0.2.0 API Diff. The most notable API changes are outlined below.

GEF4 MVC (0.2.0)

  • #472649, #472650 Removed getContents() callback from FXView and FXEditor, so that population of viewers is now completely left to subclasses. Modularized createPartControl() and dispose methods so clients can easily overwrite and adopt individual aspects. In detail, introduced hookViewers(), unhookViewers(), activate(), and deactivate() hook methods.

  • #472646 Fixed that multiple FXViewers could not share a JavaFX scene. FXViewer was responsible of creating a JavaFX scene and was provided with an ISceneContainer implementation, to hook the scene into a Stage (standalone) or FXCanvas (Eclipse UI integration) as follows:

// standalone
viewer.setSceneContainer(new FXStageSceneContainer(primaryStage));

// Eclipse UI integration
viewer.setSceneContainer(new FXCanvasSceneContainer(canvas));

The FXViewer had full control over the scene creation, so other root visuals than those provided by the viewer could not be set for the scene. This responsibility was moved out of FXViewer, so its visuals are now hooked into the scene as follows:

// standalone
primaryStage.setScene(new Scene(viewer.getScrollPane()));

// Eclipse UI integration
canvas.setScene(new Scene(viewer.getScrollPane()));

Thereby, several FXViewers can now share a single scene, which is e.g. necessary to create a palette viewer. By means of an JavaFX SplitPane, this could look like follows:

// embed two viewers into a single scene by means of a SplitPane
SplitPane sp = new SplitPane();
sp.getItems().addAll(viewer1.getScrollPane(), viewer2.getScrollPane());
primaryStage.setScene(new Scene(sp));

The now obsolete org.eclipse.gef4.mvc.fx.viewer.ISceneContainer abstraction and the related org.eclipse.gef4.mvc.fx.FXStageSceneContainer, and org.eclipse.gef4.mvc.fx.ui.FXCanvasSceneContainer implementations were removed.

  • #472650 Enabled that multiple viewers can easily be used with an FXView or FXEditor by factoring out hookViewers() and populateViewers() hook methods from createPartControl(), with a default implementation that is based on a single default viewer, which can easily be overwritten by subclasses to hook/populate multiple viewers.

  • #471031 Enhanced customizing of the default resize mechanism by allowing to overwrite the identification of the to-be-resized visual (only the part's "main" visual was allowed before) as well as the initial size (the visual's layout-bounds were used before).

  • #470612 Added checks to determine the dirty state of an FXEditor based on the undo-history.

  • #469491 Added a widget for creating/manipulating multi-stop linear gradients:

GEF4 Zest (0.2.0)

  • #466815 Renamed org.eclipse.gef4.zest.fx.models.ViewportStackModel to org.eclipse.gef4.zest.fx.models.NavigationModel and refactored it basically. Introduced org.eclipse.gef4.zest.fx.policies.NavigationPolicy, refactoring those parts of the semantic zooming that depended on the ViewportStackModel directly to use the new NavigationPolicy instead.

GEF4 Cloudio (0.2.0)

  • #473695 Made IEditableCloudLabelProvider and CloudOptionsComposite internal by moving them to an internal package.

GEF 3.10.0 (Mars)

Annual release providing first (preliminary) snapshot (0.1.0) of the new GEF4 components. The most significant changes, implemented during the Mars release timeframe, is depicted per component in the following.

GEF4 Common (0.1.0)

The Common component has been created by extracting generic abstractions (e.g. IActivatable or IAdaptable) and supporting classes from the FX and MVC components. It provides functionality that is (potentially) used by all other components and was basically written from scratch.

  • To combine the IAdaptable-mechanism with Google Guice-based dependency injection, a specific map-binding was introduced, which allows to inject adapters into an IAdaptable (see 'IAdaptable - GEF4's interpretation of a classic' for details).

  • #453119 Augmented IAdaptable to enable registration and retrieval of adapters based on TypeToken keys. This way, registration of adapters can not only be performed based on raw types (e.g. Provider.class) but also using parameterized types (e.g. Provider or Provider) (see 'IAdaptable - GEF4's interpretation of a classic' for details).

  • #458320 Implemented a specific Guice Scope (AdaptableScope) that allows to (transitively) scope instances to IAdaptables.

GEF4 Geometry (0.1.0)

The Geometry component had been written from scratch to provide a decent double-based geometry API before the Mars release timeframe. It was only marginally extended within.

  • Extended the ICurve interface with a method (getNearestIntersection(ICurve, Point)) that allows to compute the intersection point with another ICurve nearest to some reference point. This is e.g. quite handy when computing anchor position within FXChopBoxAnchor.

GEF4 Graph (0.1.0)

The Graph component has been factored out of the former Zest2 code base (DOT4Zest).

  • Changed that a constructed Graph is immmutable. The limitation of read-only access had prevented use cases of Zest and DOT, where a constructed Graph had to be modified after its initial construction.

  • Added support for nested graphs, so that a Node can now refer to a nested Graph. The node containing the nested graph is referred to as the 'nesting node'.

  • The GraphCopier that was initially bundled with the DOT component as ZestGraphImport was moved to Graph, as it provides generic capabilities to copy Graph instances and is not bound to Zest or DOT.

GEF4 Layout (0.1.0)

The Layout component has been factored out of the former Zest2 code base (org.eclipse.gef4.zest.layouts), which was initially created by forking Zest 1.x (org.eclipse.zest.layouts). It has been significantly refactored within this process.

  • Moved the Sugiyama-specific abstractions (LayerProvider, NodeWrapper, CrossingReducer) into the SugiyamaLayoutAlgorithm as nested classes. Removed the ExpandCollapseManager from the LayoutContext, as it is specific to the SpaceTreeLayoutAlgorithm.

GEF4 FX (0.1.0)

The FX component has been written from scratch to replace the Draw2d 3.x legacy component. It uses JavaFX for visualization and provides support for integrating JavaFX into SWT. A lightweight rendering support for SWT (as provided by Draw2d is not part of this component).

  • #441463 Removed the need for specific SwtFXScene implementation by ensuring that FXControlAdapter (formerly SwtFXControlAdapter) can work with an arbitrary JavaFX Scene.

  • #442971, #444009 Revised anchor abstraction so that IFXAnchor#attach() and IFXAnchor#detach() now take an additional IAdaptable argument, which may be used to provide additional information to the specific anchor. In case of an FXChopBoxAnchor, this mechanism is used to pass in a FXChopBoxAnchor$ReferencePointProvider, thereby replicating the old FXChopBoxHelper mechanism which involved direct coupling. Furthermore, an FXChopBoxAnchor$ComputationStrategy interface has been extracted from the FXChopBoxAnchor (an implementation can be passed in via its constructor), so the strategy, which is used to compute anchor positions, can be replaced.

  • #443781 An IFXConnectionRouter interface has been extracted from FXConnection. It can be passed in via FXConnection#setRouter() and is responsible of computing a curve geometry from the passed in (manually provided) waypoints of the connection.

  • Introduced ScrollPaneEx, which is an alternative to JavaFX's ScrollPane. The ScrollPaneEx provides a set-up which is suitable for graphical viewers/editors, i.e. an "infinite" canvas with viewport transformation, reveal(Node) functionality, fully controllable behavior, etc.

GEF4 MVC (0.1.0)

The MVC component has been written from scratch to replace the GEF (MVC) 3.x legacy component. While some proven concepts have been adopted, the component is a complete re-design.

  • Added grid layer and implemented snap-to-grid support. The new grid layer is created as an underlying layer by default. Visibility of the layer can be controlled via a GridModel, which is to be registered as an IViewer adapter. The GridModel allows to select the grid cell height and width and whether the grid is to be zoomed with the contents layer or not. It can also be used to enable/disable snap-to-grid, which is respected by the FXResizeRelocatePolicy and FXBendPoliy.

  • To enable that handles are only displayed during mouse hover (and a short delay after), FXHoverBehavior and the FXDefaultHandlePartFactory now support the creation (and automatic removal) of hover handles.

  • The IDomain now allows to open/close transactions, executing a set of related IUndoableOperation as an atomic (composite) operation. This way, several (transaction) policies can independently execute operations during an interaction, while undo/redo is performed for the overall transaction.

  • Introduced ContentPolicy to formalize that parts of the interaction that affects the content (i.e. the to be visualized model). The content ContentPolicy provides undoable operations to add child content to a parent, to anchor content on other content, etc. All these operations delegate to the respective host IContentPart. As the respective content parts have to be implemented by adopters anyway, the model visualization and model manipulation related code can be kept in a single place (namely within the IContentPart). Furthermore, the ContentPolicy is generic and can be re-used independently.

  • #449129, #462787 Added support for touch gesture-based interactions. The MVC logo example demonstrates gesture-based panning/scrolling, zooming, and rotating.

GEF4 Zest (0.1.0)

The Zest component has been basically re-written from scratch to replace the Zest 1.x legacy component, as well as the intermediary replacement in the form of the Zest2 code base (org.eclipse.gef4.zest.core and org.eclipse.gef4.zest.jface), which was created by forking Zest 1.x (org.eclipse.zest.core). It is now based on the Graph and Layout components, which were factored out of the same code base, and uses MVC as the underlying model-view-controller framework.

  • #438734 Re-implemented the functionality of zest.core within ZEST.FX and Zest.FX.UI.

  • #441131 Created a replacement API for zest.jface in terms of the ZestContentViewer. While custom content and "label" providers are defined within org.eclipse.gef4.zest.fx.ui.jface, the JFace ILabelProvider, IColorProvider, IFontProvider, and IToolTipProvider are also accepted.

  • Nodes can now be hidden using the '-' hover handle on the node. Sibling nodes, connected to the hidden node will indicate the number of hidden nodes, connected to them, by means of a (red circle) decoration. Using the '+' hover handle on any such sibling node, will make the hidden nodes visible again.

  • Implemented inline-rendering of nested graphs. Nesting nodes will now render their nested nodes at a certain zoom threshold. Zooming can be performed with the mouse wheel and 'Alt' or 'Ctrl' key, or by using a pinch-spread gesture (on devices which support touch gestures).

  • Implemented navigating to/from nested graphs. Only one level of a hierarchy is rendered as once, but you can open a nested graph by double clicking the corresponding node. Navigating is further supported by using zoom. When zooming a nesting node further, from a certain zoom threshold onwards, the viewer contents will be switched to render only the nested graph. Zooming out will return to the above graph level.

GEF4 DOT (0.1.0)

The DOT component has been factored out of the Zest2 code base (DOT4Zest) and has been completely revised to be internally based on the new Zest component.

  • #441129 Replacing the former Zest2 code within org.eclipse.gef4.zest.ui that still depended on Draw2d 3.x, a new DOT Graph view was introduced, which is based on Zest and thus uses JavaFX for visualization purposes.

  • #451097 Refactored grammar definition and fixed several parsing issues within DOT editor.

  • #450448 Add proper support for lexical and semantic syntax coloring within DOT editor.

  • #452650 Implemented a proper outline view for the DOT editor.

GEF4 Cloudio (0.1.0)

The Cloudio component has been factored out of the Zest2 code base (Cloudio) into a standalone component. It does not rely on other GEF4 components and was not yet migrated to use JavaFX for rendering.