Graphical Editing Framework: Difference between revisions

Revision as of 09:14, 21 June 2013

Latest revision as of 17:20, 30 April 2025

(17 intermediate revisions by 10 users not shown)

Line 1:

{{More citations needed|date=January 2024}}

The '''Graphical Editing Framework''' '''(GEF)''' is an [[Eclipse (software)|Eclipse]] project that provides framework and end-user components related to graphical applications.<ref>{{Cite web |last=Web |first=Eclipse |date=2013-01-31 |title=Eclipse Graphical Editing Framework (GEF) |url=https://projects.eclipse.org/projects/tools.gef |access-date=2024-01-12 |website=projects.eclipse.org |language=en}}</ref>

== History ==

'''Graphical Editing Framework''' '''(GEF)''' is a framework that was developed for the [[Eclipse (software)|Eclipse]] platform. It is used to create graphical editors for various diagrams like electrical networks or tree diagrams. Such diagrams offer easy editing capabilities for data in specific domains and are well suited as a graphical representation of that data. GEF editors can be used inside an Eclipse RCP application, the application framework offered by Eclipse. Usually, GEF is used as a part of the [[Graphical Modeling Framework|Graphical Modeling Framework (GMF)]] which combines the [[Eclipse Modeling Framework|Eclipse Modeling Framework (EMF)]] and GEF to create the code for both the data model and the diagram editor.

GEF was initially developed as part of IBM's etools (<code>com.ibm.etools.gef</code>) and was contributed to [[Eclipse (software)|Eclipse]] in 2002 in version 2.0.0, consisting then of two components: Draw2d, a 2D visualization component based on the [[Standard Widget Toolkit|Standard Widget Toolkit (SWT)]] and GEF (MVC), a related model-view-controller framework that can be used to realize graphical editors as part of Eclipse Rich Client Platform (RCP) applications. The first release at Eclipse was GEF 2.1.0 in March 2003. The next major version, GEF 3.0.0, was released in June 2004, providing many new features like support for rules and guides. Zest was added as a third project component in 2007 in version 1.0.0 as part of the GEF 3.4.0 release. Since 2004, when GEF 3.0.0 was released, only compatible changes have been applied to the framework's [[API|application programming interface]] (API).

A new major revision of the framework has been developed in parallel to the maintenance of the GEF 3.x components by the project team since 2010. It is a complete redesign that is much more modular, uses JavaFX instead of SWT as underlying rendering framework, and can be used also independently of Eclipse RCP applications. Commonly referred to as GEF4, its components were initially released in version 0.1.0 (with still provisional API) in June 2015 as part of the GEF 3.10.0 (Mars) release. The GEF4 components are to be published in version 1.0.0 as part of the GEF 4.0.0 (Neon) release in June 2016.

==Structure==

Editors generated with GEF consist of the following components:

== GEF 3.x ==

GEF 3.x provides framework technology to realize graphical editors and views as part of [[Eclipse (software)#Rich Client Platform|Eclipse Rich Client Platform (RCP)]] applications. It is internally decomposed into three components:

* Draw2d – A 2D visualization component based on the [[Standard Widget Toolkit|Standard Widget Toolkit (SWT)]]

* GEF (MVC) - A model-view-controller component that can be used to realize graphical editors as part of Eclipse Rich Client Product (RCP) applications

* Zest - A graph-based visualization toolkit that can be used to realize views for visualization of graph-like data structures as part of Eclipse RCP applications

While graphical applications can be built on top of the GEF 3.x components directly, Draw2d and GEF (MVC) are also used by the [[Graphical Modeling Framework|Graphical Modeling Framework (GMF)]], which combines them with the [[Eclipse Modeling Framework|Eclipse Modeling Framework (EMF)]] to create the code for both the data model and the graphical editor.

=== Architecture ===

Editors generatedcreated with GEF (MVC) consist of the following components:

* The diagram editor including tool palette

* Figures which graphically represent the underlying data model elements

Line 11 ⟶ 24:

* Command objects that edit the model and provide [[undo]]-redo

==== Design Patternpattern Usageusage ====

GEF makes heavy use of [[design patterns|Design Patternspattern]]s. These patterns are often mandatory under GEF and developers are required to understand them.

* [[Model-View-Controller]] is an architectural design pattern which divides an application into separate parts which communicate with each other in a specific way. The goal is to separate data model (model), [[graphical user interface]] (view) and [[business logic]] (controller). GEF uses the MVC pattern extensively.

** Model: The data model can either be generated using EMF, self-implemented by the user or it may already exist in case of a legacy software.

=== Model-View-Controller Pattern in GEF ===

** Controller: The EditParts act as controllers. Typically, each model element has its matching EditPart. EditParts may contain other EditParts thereby matching model elements containing other model elements. EditParts also have a reference to the figure which graphically represents the model element. Finally, EditParts evaluate requests and create the appropriate command to edit the underlying model.

[[Model-View-Controller]] is an architectural design pattern which divides an application into separate parts which communicate with each other in a specific way. The goal is to separate data model (model), graphical user interface (view) and business logic (controller). GEF uses the MVC pattern extensively.

** View: For each element within the model, including connections, a figure has to be implemented using the Draw2d framework. Often timesOftentimes the figure is some geometrical drawing.

* Model: The data model can either be generated using EMF, self-implemented by the user or it may already exist in case of a legacy software.

* Controller: The EditParts act as controllers. Typically, each model element has its matching EditPart. EditParts may contain other EditParts thereby matching model elements containing other model elements. EditParts also have a reference to the figure which graphically represents the model element. Finally, EditParts evaluate requests and create the appropriate command to edit the underlying model.

* View: For each element within the model, including connections, a figure has to be implemented using the Draw2d framework. Often times the figure is some geometrical drawing.

=== Other Featured Design Patterns ===

* [[Factory pattern|Factory]]: Creating models from palette, creating EditParts and creating Figures

* [[Observer pattern|Observer]]: Typically a controller (EditPart) listening on Model and View

Line 28 ⟶ 36:

* [[Chain-of-responsibility pattern|Chain of responsibility]]: To decide which EditPolicy should handle a Request

==== Request and Responseresponse Mechanismmechanism ====

Any user action with the editor can generate a request. The nature of the request is understood by the context of invocation. The context is determined by the EditPart the user interacts with and the active tool. The tool can be any selected entry in a tool palette. The request is handed over to the selected EditPart, which in turn returns a Command.

This is achieved using the [[Chain-of-responsibility pattern|Chainchain of responsibility]] mechanism over Editpolicies. The editpolicies determine if they can handle the request, otherwise they pass on to the next editpolicy. The order of declaration of editpolicies determine the order in which the request is passed around. The capable editpolicy creates a command. This command is handed back to the tool which initiated the "Request". Execution of the command causes the model to be modified (Response).

Any user action with the editor can generate a request. The nature of the request is understood by the context of invocation. The context is determined by the EditPart the user interacts with and the active tool. The tool can be any selected entry in a tool palette. The request is handed over to the selected EditPart, which in turn returns a Command.

==References==

This is achieved using the [[Chain-of-responsibility pattern|Chain of responsibility]] mechanism over Editpolicies. The editpolicies determine if they can handle the request, otherwise they pass on to the next editpolicy. The order of declaration of editpolicies determine the order in which the request is passed around. The capable editpolicy creates a command. This command is handed back to the tool which initiated the "Request". Execution of the command causes the model to be modified (Response).

{{Reflist}}

==External links==

* [https://github.com/eclipse/gef-classic GEF Source Repository]

* [http://www-128.ibm.com/developerworks/opensource/library/os-gef/ Create an eclipse-based application using the Graphical Editing Framework]

* [http://www.ibm.com/developerworks/library/os-eclipse-gef11/ Create an eclipse-based application using the Graphical Editing Framework (new version)]

* [http://wiki.eclipse.org/index.php/Graphical_Editing_Framework GEF on Eclipsepedia]

* [http://gef.tigris.org/ A similar Graph Editing Framework at tigris.org]

{{Eclipse Foundation}}

[[Category:Graphics software]]

[[Category:Eclipse (software)]]