This documents provides Gephi APIs documentation and gives details about current status of each API. Each API is categorized by it's stability: stable, under development, deprecated or friend.
PreviewMouseListener and implement MouseResponsiveRenderer interface in the renderers that use the listener.
getShortDescription() method to the StatisticsUI API. It enables to get a short description of statistics (used to display tooltips).
needsItemBuilder method to Renderer in Preview API.
This helps to avoid building unnecessary items while refreshing preview.
getDisplayName method to Renderer and support for extending default preview renderers.PreviewModel and PreviewController.:RankingController.RangeFilter interface in Filters API to help create range filters. The filter system now automatically
manage the range values and bounds. The Range object now also supports exclusive intervals.AttributableFilter filter type. This is useful for filters manipulating Attributable
objects regardless whether they belong to a node or edge. Also note new useful abstract plugin implementations have been added to
the FiltersPlugin module. Use AbstractFilter for any filter and AbstractAttributeFilter for
filters based on attributes. Filter builders are also provided.PerspectiveMember SPI has to go
away and will break compatibility. Top components now directly declare the perspective they belong to in the
@TopComponent.Registration annotation, for instance roles = {"overview"} for the Overview perspective.REPLACE_COLUMN event type in AttributeEvent.
TIME_FORMAT event in DynamicModelEvent. The event is triggered when the time format
is initialized.PerspectiveAPI module and move API/SPI interfaces from the DesktopPerspective
module. Add a PerspectiveController to find and manage perspectives.getGraphTable() in the AttributeModel. The GraphView elements
can also have attributes using the same system as nodes and egdes. The data can be accessed through the Graph.getAttributes()
method.
DesktopPerspective SPI. Modules willing to declare a panel part of a perspective
should implement the PerspectiveMember interface. The interface now asks for the TopComponent's ID.
DynamicStatistics SPI in the StatisticsAPI module. The interface extends Statistics
and implement the calculation of metrics over time.
ADD_NODES and ADD_EDGES are merged
into a ADD_NODES_AND_EDGES event. Similarly REMOVE_NODES and REMOVE_EDGES are merged into a
REMOVE_NODES_AND_EDGES event. GraphEventData remains the same and still contains both added/removed nodes and
edges. Users may simply test if arrays returned by addedNodes(), addedEdges(), removedNodes() and
removedEdges() are null before using them.
executeLayout(numIterations) method in LayoutController.
StatisticsController now supports synchronous algorithm execution through the execute(Statistics)
method.startAutoTransform() and stopAutoTransform() in Ranking API to control auto transformations.
The model also allows to retrieve the ranking used in the auto transformation. An additional refreshRanking() method has been added
in the RankingBuilder SPI for a smoother auto transformation support.AttributeRowsMergeStrategy interface to Data Laboratory API. This is a type of manipulator that defines
and strategy for merging values of a row (node or edge) for an specific column. It should be used by other manipulators such as
NodesManipulator MergeNodesgetNodeRanking() and getEdgeRanking in the model, we
introduce the concept of element type and generalize methods to it. Use Ranking.NODE_ELEMENT to obtain a node
ranking and Ranking.EDGE_ELEMENT for an edge ranking. Same idea for transformers, which are now defined by a unique name.
Default transformers' name can be found in the Transformer interface. A RankingEvent has also been created.
API users have to update to their client code to be compatible.Attributable. That allows to manipulate objects with attributes
regardless if the object is a node or an edge. Node, Edge, NodeData and EdgeData now
now implements this interface, and a getAttributes() method has been added to Node and Edge to
make development easier.setCurrentQuery() method on FilterController.WorkspacePersistenceProvider interface
from ProjectAPI now uses StAX instead of DOM. The writeXML() method now uses XMLStreamWriter and readXML()
XMLStreamReader. Backward compatibility can't be assured, modules have to use switch to StAX.
NodesManipulator and EdgesManipulator). Also now Visualization API has an SPI for adding context menu actions
(GraphContextMenuItem) to nodes like DataLaboratory does with NodesManipulator. Note that they share the interface
ContextMenuItemManipulator from Data Laboratory API, so they are compatible, being able to reuse actions on nodes for Overview and Data Laboratory.
removeMetaEdge(Edge) to manually remove meta edges. Add getTotalEdgeCount() method
to globally count the number of edges, regardless if the edge is proper or meta.
getEdgesAndMetaEdges(Node) and
getTotalDegree(Node) methods, as well as their in and out variants for HierarchicalDirectedGraph.
flatten() method to HierarchicalGraph to flatten the hierarchical graph and transform
meta edges into regular edges.
destroy(Filter filter) in FilterBuilder to receive notification when a filter
query is removed and clean-up.
MetaEdgeBuilder in Graph SPI to allow custom builders. Add GraphSettings.setMetaEdgeBuilder()
in the graph model settings.
StatisticsModel to store reports directly instead of Statistics instance. As a
consequence, the model has now a getReport() and a getResult() method that UI can use. The currently
running statistics can now be get with a new getRunning() method.
AttributeModel instead of AttributeTable and will receive events for all tables. Refactoring of the
AttributeEvent class with AttributeTable as source and a new AttributeEventData object as data.
A new SET_VALUE has been implemented for getting events when attribute values are set.
AttributeRowFactory, the newNodeRow() method now takes the owner object
NodeData as a parameter. Similarly for newEdgeRow() and newRowForTable().
getEdge(Node, Node) in GraphAPI for consistency reasons.
Processor has now setters instead of a process() method
with parameters. How processors are created remains the same. Creation of a ProcessorUI interface for processors settings
configuration. A ProcessorUI implementation provides a panel, which is shown when the import report is closing. The
ProcessorUI also allows to disable a processor with some conditions.
getColor() method in NodeDraft and EdgeDraft.
TopComponent that belong to a perspective. Plugins can implement
PerspectiveMember to define the open and close behaviour.
AbstractList.
addAttributeValue() method in NodeDraft and EdgeDraft. For improving data
cleanup possibilities, NodeDraftGetter and EdgeDraftgetter now returns an AttributeRow
instead of a list of attribute values only. Finally to profit from latest improvements, draft elements returns directly a
TimeInterval type instead of the list of slices. Methods with 'Slice' have been renamed to 'Interval' for
consistency reasons.
DynamicType
GraphEvent has now precise events, including
ADD_NODES, REMOVE_NODES, ADD_EDGES, REMOVE_EDGES and
VISIBLE_VIEW. A new GraphEventData interface has been created to retrieve elements related to
the events.
ExporterBuilder interface for
exporter creation and different exporters: GraphExporter, VectorExporter, ByteExporter
and CharacterExporter that covers common cases. The way exporters write data has been rationalized by using either
java.io.Writer (text) or java.io.OutputStream (byte). The ExportController has been improved
to support all use-cases, including file, writer and stream export.
DatabaseImporter, the
SpigotImporter interface is a new type of Importers. Modifications have also be made to the
ImportController to support spigot import.
ImporterBuilder interface has been created and should be registered with the @ServiceProvider
annotation. The various importers types have been simplified and leave more choice to the implementations about how the
input is managed. XML and Text file importers has been merged in a FileImporter interface, working with the
java.io.Reader. Utility static methods, for instance get Document from Reader can now be found in a new
ImportUtils class. The ImportController has been simplified for File import and now accepts
java.io.Reader also. The main improvement on these modules in the support of UI components for importers.
The aim is to let importers define an ImporterUI implementation to manage settings of these importers.
Graph:
Graph.setId(Node, String)Graph.setId(Edge, String)Graph.getNode(String)Graph.getEdge(String)NodeData.setId() and EdgeData.setId() methods have been removed, compatibility can't be kept.
Factory has also be changed to allow to create elements with String ID directly, as it's not possible anymore to
do it from NodeData.
AttributeTable
has been replaced by a more traditional event management system, with new AttributeEvent and
AttributeListener interfaces. The dispatch implementation is also now on a separate thread.
ImportController is now
doing import task only and a new ImportControllerUI is displaying the user interface (Report Panel). The
ImportControllerUI interface is located in the DesktopProject module and should be user to properly
import file from Plugins. The ImportController methods could be used from the toolkit.
doImport() method in ImportController that accepts
InputStream. In ImportAPI also, add getWeight() in EdgeDraft to let importers
increment weight. New AttributeUtils methods. Progress in GraphAPI and ImportAPI documentation.
TimeIntervalMin
and TimeIntervalMax. Changes in GraphAPI about elements counting. Henceforth only enabled elements are counted,
in node and edge counting, but also in degree methods. This counting is more logical, as it match with the
number of elements returned by getNodes() and getEdges().