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.
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 MergeNodes
getNodeRanking()
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()
.