A control that displays a network of related objects using the well-known
paradigm of a graph.
A JGraph object doesn't actually contain your data; it simply provides a view
of the data. Like any non-trivial Swing component, the graph gets data by
querying its data model.
JGraph displays its data by drawing individual elements. Each element
displayed by the graph contains exactly one item of data, which is called a
cell. A cell may either be a vertex or an edge. Vertices may have neighbours
or not, and edges may have source and target vertices or not, depending on
whether they are connected.
Creating a Graph
The following code creates a JGraph object:
JGraph graph = new JGraph();
...
JScrollPane graphLayoutCache = new JScrollPane(graph)
The code creates an instance of JGraph and puts it in a scroll pane. JGraphs
constructor is called with no arguments in this example, which causes the
constructor to create a sample model.
Editing
Outmoved, cloned, resized, and shaped, or connected/disconnected to or from
other cells.
Keyboard Bindings
JGraph defines the following set of keyboard bindings:
- Alt-Click forces marquee selection if over a cell.
- Shift- or Ctrl-Select extends or toggles the selection.
- Shift-Drag constrains the offset to one direction.
- Ctrl-Drag clones the selection.
- Doubleclick/F2 starts editing a cell.
You can change the number of clicks that triggers editing using
setEditClickCount().
Customization
There are a number of additional methods that customize JGraph. For example,
setMinimumMove() defines the minimum amount of pixels before a move operation
is initiated. setSnapSize() defines the maximum distance for a cell to be
selected. setFloatEnabled() enables/disables port floating.
With setDisconnectOnMove() you can indicate if the selected subgraph should
be disconnected from the unselected rest when a move operation is initiated.
setDragEnabled() enables/disables the use of Drag And Drop, and
setDropEnabled() sets if the graph accepts Drops from external sources.
Customizing a graphs display
JGraph performs some look-and-feel specific painting. You can customize this
painting in a limited way. For example, you can modify the grid using
setGridColor() and setGridSize(), and you can change the handle colors using
setHandleColor() and setLockedHandleColor().
If you want finer control over the rendering, you can subclass one of the
default renderers, and extend its paint()-method. A renderer is a
Component-extension that paints a cell based on its attributes. Thus, neither
the JGraph nor its look-and-feel-specific implementation actually contain the
code that paints the cell. Instead, the graph uses the cell renderers
painting code.
Selection
Apart from the single-cell and marquee-selection, JGraphs selection model
also allows to "step-into" groups, and select children. This feature can be
disabled using the setAllowsChildSelection() method of the selection model
instance.
If you are interested in knowing when the selection changes implement the
GraphSelectionListener
interface and add the instance using
the method
addGraphSelectionListener
.
valueChanged
will be invoked when the selection changes, that
is if the user clicks twice on the same vertex
valueChanged
will only be invoked once.
Change Notification
For detection of double-clicks or when a user clicks on a cell, regardless of
whether or not it was selected, I recommend you implement a MouseListener and
use
getFirstCellForLocation
.
Undo Support
To enable Undo-Support, a
GraphUndoManager
must be added using
addGraphSelectionListener
. The GraphUndoManager is an
extension of Swing's
GraphUndoManager
that maintains a command
history in the context of multiple views. In this setup, a cell may have a
set of attributes in each view attached to the model.
For example, consider a position that is stored separately in each view. If a
node is inserted, the change will be visible in all attached views, resulting
in a new node that pops-up at the initial position. If the node is
subsequently moved, say, in view1, this does not constitute a change in
view2. If view2 does an "undo", the move
and the insertion must be
undone, whereas an "undo" in view1 will only undo the previous move
operation.
Like all
JComponent
classes, you can use
javax.swing.InputMap
and
javax.swing.ActionMap
to associate
an
javax.swing.Action
object with a
javax.swing.KeyStroke
and
execute the action under specified conditions.
ANTIALIASED_PROPERTY
public static final String ANTIALIASED_PROPERTY
Bound property name for antiAliased
.
CROSS_GRID_MODE
public static final int CROSS_GRID_MODE
DOT_GRID_MODE
public static final int DOT_GRID_MODE
EDITABLE_PROPERTY
public static final String EDITABLE_PROPERTY
Bound property name for editable
.
GRAPH_LAYOUT_CACHE_PROPERTY
public static final String GRAPH_LAYOUT_CACHE_PROPERTY
Bound property name for graphModel
.
GRAPH_MODEL_PROPERTY
public static final String GRAPH_MODEL_PROPERTY
Bound property name for graphModel
.
GRID_COLOR_PROPERTY
public static final String GRID_COLOR_PROPERTY
Bound property name for gridColor
.
GRID_SIZE_PROPERTY
public static final String GRID_SIZE_PROPERTY
Bound property name for gridSize
.
GRID_VISIBLE_PROPERTY
public static final String GRID_VISIBLE_PROPERTY
Bound property name for gridVisible
.
HANDLE_COLOR_PROPERTY
public static final String HANDLE_COLOR_PROPERTY
Bound property name for gridColor
.
HANDLE_SIZE_PROPERTY
public static final String HANDLE_SIZE_PROPERTY
Bound property name for gridColor
.
INVOKES_STOP_CELL_EDITING_PROPERTY
public static final String INVOKES_STOP_CELL_EDITING_PROPERTY
Bound property name for messagesStopCellEditing
.
IS_MAC
public static boolean IS_MAC
LINE_GRID_MODE
public static final int LINE_GRID_MODE
LOCKED_HANDLE_COLOR_PROPERTY
public static final String LOCKED_HANDLE_COLOR_PROPERTY
Bound property name for gridColor
.
MARQUEE_HANDLER_PROPERTY
public static final String MARQUEE_HANDLER_PROPERTY
Bound property name for graphModel
.
PORTS_SCALED_PROPERTY
public static final String PORTS_SCALED_PROPERTY
Bound property name for portsScaled
.
PORTS_VISIBLE_PROPERTY
public static final String PORTS_VISIBLE_PROPERTY
Bound property name for gridVisible
.
PROPERTY_BACKGROUNDIMAGE
public static final String PROPERTY_BACKGROUNDIMAGE
Bound property name for backgroundImage
.
SCALE_PROPERTY
public static final String SCALE_PROPERTY
Bound property name for scale
.
SELECTIONENABLED_PROPERTY
public static final String SELECTIONENABLED_PROPERTY
Bound property name for selectionEnabled
.
SELECTION_MODEL_PROPERTY
public static final String SELECTION_MODEL_PROPERTY
Bound property name for selectionModel
.
VERSION
public static final String VERSION
antiAliased
protected boolean antiAliased
True if the graph is anti-aliased. Default is false. Bound property.
autoResizeGraph
protected boolean autoResizeGraph
True if the graph should be auto resized when cells are moved below the
bottom right corner. Default is true.
backgroundComponent
protected Component backgroundComponent
A Component responsible for drawing the background image, if any
backgroundImage
protected ImageIcon backgroundImage
Holds the background image.
backgroundScaled
protected boolean backgroundScaled
Whether or not the background image is scaled on zooming
bendable
protected boolean bendable
True if the graph allows points to be modified/added/removed. Default is
true.
cloneable
protected boolean cloneable
True if the graph allows "ctrl-drag" operations. Default is false.
connectable
protected boolean connectable
True if the graph allows new connections to be established. Default is
true.
disconnectOnMove
protected boolean disconnectOnMove
True if selected edges are disconnected from unselected vertices on move.
Default is false.
disconnectable
protected boolean disconnectable
True if the graph allows existing connections to be removed. Default is
true.
dragEnabled
protected boolean dragEnabled
True if Drag-and-Drop should be used for move operations. Default is
false due to a JDK bug.
dropEnabled
protected boolean dropEnabled
True if the graph accepts transfers from other components (graphs). This
also affects the clipboard. Default is true.
edgeLabelsMovable
protected boolean edgeLabelsMovable
True if the labels on edges may be moved.
editClickCount
protected int editClickCount
Number of clicks for editing to start. Default is 2 clicks.
editable
protected boolean editable
True if the graph allows editing the value of a cell. Bound property.
enabled
protected boolean enabled
True if the graph allows interactions. Default is true.
graphLayoutCache
protected GraphLayoutCache graphLayoutCache
The view that defines the display properties of the model. Bound
property.
graphModel
protected GraphModel graphModel
The model that defines the graph displayed by this object. Bound
property.
gridColor
protected Color gridColor
The color of the grid. Changes when the Look-and-Feel changes.
gridEnabled
protected boolean gridEnabled
True if the snap method should be active (snap to grid).
gridMode
protected int gridMode
The style of the grid. Use one of the _GRID_MODE constants.
gridSize
protected double gridSize
The size of the grid in points. Default is 10. Bound property.
gridVisible
protected boolean gridVisible
True if the grid is visible. Bound property.
groupsEditable
protected boolean groupsEditable
True if the graph allows editing of non-leaf cells. Bound property.
handleColor
protected Color handleColor
Color of the handles and locked handles. Changes when the Look-and-Feel
changes.
handleSize
protected int handleSize
Size of a handle. Default is 3 pixels.
highlightColor
protected Color highlightColor
Highlight Color. Changes when the Look-and-Feel changes.
invokesStopCellEditing
protected boolean invokesStopCellEditing
If true, when editing is to be stopped by way of selection changing, data
in graph changing or other means stopCellEditing
is
invoked, and changes are saved. If false, cancelCellEditing
is invoked, and changes are discarded.
isJumpToDefaultPort
protected boolean isJumpToDefaultPort
True if getPortViewAt should return the default port if no other port is
found. Default is false.
isMoveIntoGroups
protected boolean isMoveIntoGroups
Specifies if cells should be added to a group when moved over the group's
area. Default is false.
isMoveOutOfGroups
protected boolean isMoveOutOfGroups
Specifies if cells should be removed from groups when removed from the
group area. Default is false.
lastBufferAllocated
protected boolean lastBufferAllocated
Stores whether the last double buffer allocation worked or not
lockedHandleColor
protected Color lockedHandleColor
Color of the handles and locked handles. Changes when the Look-and-Feel
changes.
marqueeColor
protected Color marqueeColor
Color of the marquee. Changes when the Look-and-Feel changes.
minimumMove
protected int minimumMove
Minimum amount of pixels to start a move transaction. Default is 5.
moveBelowZero
protected boolean moveBelowZero
True if the graph allows to move cells below zero.
moveBeyondGraphBounds
protected boolean moveBeyondGraphBounds
True if the graph allows to move cells beyond the graph bounds
moveable
protected boolean moveable
True if the graph allows move operations. Default is true.
offgraphics
protected Graphics offgraphics
Graphics object of off screen image
offscreen
protected Image offscreen
Off screen image for double buffering
offscreenBounds
protected Rectangle2D offscreenBounds
The bounds of the offscreen buffer
offscreenBuffer
protected int offscreenBuffer
The buffer around the offscreen graphics object that provides the
specified distance of scrolling before the buffer has to be redrawn.
Increasing the value means fewer redraws but more memory is required.
offscreenDirty
protected Rectangle2D offscreenDirty
Whether or not the current background image is correct
offscreenOffset
protected Point2D offscreenOffset
The offset of the offscreen buffer
portsOnTop
protected boolean portsOnTop
True if port are painted above all other cells.
portsScaled
protected boolean portsScaled
True if the ports are scaled. Bound property.
portsVisible
protected boolean portsVisible
True if the ports are visible. Bound property.
previewInvalidNullPorts
protected boolean previewInvalidNullPorts
True if the graph allows invalid null ports during previews (aka flip
back edges). Default is true.
scale
protected double scale
Scale of the graph. Default is 1. Bound property.
selectionEnabled
protected boolean selectionEnabled
True if the graph allows selection of cells. Note: You must also disable
selectNewCells if you disable this. Bound property.
selectionModel
protected GraphSelectionModel selectionModel
Models the set of selected objects in this graph. Bound property.
sizeable
protected boolean sizeable
True if the graph allows cells to be resized. Default is true.
tolerance
protected int tolerance
Maximum distance between a cell and the mousepointer. Default is 4.
volatileOffscreen
protected boolean volatileOffscreen
Whether or not to try to use a volatile offscreen buffer for double
buffering. Volatile
wholeOffscreenDirty
protected boolean wholeOffscreenDirty
wholeOffscreenDirtyProportion
protected double wholeOffscreenDirtyProportion
xorEnabled
protected boolean xorEnabled
True if the graph accepts transfers from other components (graphs). This
also affects the clipboard. Default is true.
addGraphSelectionListener
public void addGraphSelectionListener(GraphSelectionListener tsl)
Adds a listener for GraphSelection
events.
tsl
- the GraphSelectionListener
that will be
notified when a cell is selected or deselected (a "negative
selection")
addOffscreenDirty
public void addOffscreenDirty(Rectangle2D offscreenDirty)
Adds the specified area to the region deemed dirty for the next double
buffered redraw
offscreenDirty
- the region to add
addSampleData
public static void addSampleData(GraphModel model)
Creates and returns a sample GraphModel
. Used primarily
for beanbuilders to show something interesting.
addSelectionCell
public void addSelectionCell(Object cell)
Adds the cell identified by the specified Object
to the
current selection.
cell
- the cell to be added to the selection
addSelectionCells
public void addSelectionCells(Object[] cells)
Adds each cell in the array of cells to the current selection.
cells
- an array of objects that specifies the cells to add
cancelEditing
public void cancelEditing()
Cancels the current editing session. Has no effect if the graph isn't
being edited.
clearOffscreen
public void clearOffscreen()
Invalidate the offscreen region, do not just delete it, since if the new
region is smaller than the old you may not wish to re-create the buffer
clearOffscreenDirty
public void clearOffscreenDirty()
Clears the region deemed dirty for the next double buffered redraw
clearSelection
public void clearSelection()
Clears the selection.
cloneCells
public Map cloneCells(Object[] cells)
Returns a map of (cell, clone)-pairs for all cells
and
their children. Special care is taken to replace the anchor references
between ports. (Iterative implementation.)
convertValueToString
public String convertValueToString(Object value)
Converts the specified value to string. If the value is an instance of
CellView then the corresponding value or cell is used.
createBounds
public static Map createBounds(AttributeMap map,
int x,
int y,
Color c)
Returns an attributeMap for the specified position and color.
createBufferedImage
protected void createBufferedImage(int width,
int height)
Utility method to create a standard buffered image
drawImage
public boolean drawImage(Graphics g)
drawImage
public boolean drawImage(int dx1,
int dy1,
int dx2,
int dy2,
int sx1,
int sy1,
int sx2,
int sy2)
Utility method to draw the off screen buffer
dx1
- the x coordinate of the first corner of the
destination rectangle.dy1
- the y coordinate of the first corner of the
destination rectangle.dx2
- the x coordinate of the second corner of the
destination rectangle.dy2
- the y coordinate of the second corner of the
destination rectangle.sx1
- the x coordinate of the first corner of the source
rectangle.sy1
- the y coordinate of the first corner of the source
rectangle.sx2
- the x coordinate of the second corner of the source
rectangle.sy2
- the y coordinate of the second corner of the source
rectangle.
true
if the current output representation is
complete; false
otherwise.
fireValueChanged
protected void fireValueChanged(GraphSelectionEvent e)
Notifies all listeners that have registered interest for notification on
this event type. The event instance is lazily created using the
parameters passed into the fire method.
e
- the GraphSelectionEvent
generated by the
GraphSelectionModel
when a cell is selected or
deselected
javax.swing.event.EventListenerList
fromScreen
public Point2D fromScreen(Point2D p)
Downscale the given point in place, using the given instance.
p
- the point to be downscaled
- the downscaled point instance
fromScreen
public Rectangle2D fromScreen(Rectangle2D rect)
Downscale the given rectangle in place, using the given instance.
rect
- the rectangle to be downscaled
- the down-scaled rectangle instance
getAttributes
public AttributeMap getAttributes(Object cell)
Returns the attributes for the specified cell. If the layout cache
returns a view for the cell then this method returns allAttributes,
otherwise the method returns model.getAttributes(cell).
getBackgroundComponent
public Component getBackgroundComponent()
getBackgroundImage
public ImageIcon getBackgroundImage()
Returns the background image.
- Returns the backgroundImage.
getCellBounds
public Rectangle2D getCellBounds(Object cell)
Returns the bounding rectangle of the specified cell.
getCellBounds
public Rectangle2D getCellBounds(Object[] cells)
Returns the bounding rectangle of the specified cells.
getCenterPoint
public Point2D getCenterPoint()
Returns the center of the component relative to the parent viewport's
position.
getDefaultPortForCell
public PortView getDefaultPortForCell(Object cell)
Returns the default portview for the specified cell. The default
implementation returns the first floating port (ie. the first port that
does not define an offset) or the port, if there is only one
port.
cell
- the cell whose port is to be obtained
- the port view of the specified cell
getDescendants
public Object[] getDescendants(Object[] cells)
Returns all cells
including all descendants in the passed
in order of cells.
getEdgeLabelsMovable
public boolean getEdgeLabelsMovable()
Returns true if edge labels may be dragged and dropped.
- whether edge labels may be dragged and dropped
getEditClickCount
public int getEditClickCount()
Returns the number of clicks for editing to start.
getEditingCell
public Object getEditingCell()
Returns the cell that is currently being edited.
getFirstCellForLocation
public Object getFirstCellForLocation(double x,
double y)
Returns the topmost cell at the specified location.
x
- an integer giving the number of pixels horizontally from the
left edge of the display area, minus any left marginy
- an integer giving the number of pixels vertically from the top
of the display area, minus any top margin
- the topmost cell at the specified location
getGraphLayoutCache
public GraphLayoutCache getGraphLayoutCache()
Returns the GraphLayoutCache
that is providing the
view-data.
- the view that is providing the view-data
getGridColor
public Color getGridColor()
Returns the current grid color.
getGridMode
public int getGridMode()
Returns the current grid view mode.
getGridSize
public double getGridSize()
Returns the size of the grid in pixels.
- the size of the grid as an int
getHandleColor
public Color getHandleColor()
Returns the current handle color.
getHandleSize
public int getHandleSize()
Returns the size of the handles.
getHighlightColor
public Color getHighlightColor()
Returns the current highlight color.
getImage
public BufferedImage getImage(Color bg,
int inset)
Returns a BufferedImage
for the graph using inset as an empty
border around the cells of the graph. If bg is null then a transparent
background is applied to the image, else the background is filled with
the bg color. Therefore, one should only use a null background if the
fileformat support transparency, eg. GIF and PNG. For JPG, you can use
Color.WHITE
for example.
- Returns an image of the graph.
getInvokesStopCellEditing
public boolean getInvokesStopCellEditing()
Returns the indicator that tells what happens when editing is
interrupted.
- the indicator that tells what happens when editing is interrupted
getLeafViewAt
public CellView getLeafViewAt(double x,
double y)
Returns the next view at the specified location wrt. c
in
the specified array of views. The views must be in order, as returned,
for example, by GraphLayoutCache.order(Object[]).
getLockedHandleColor
public Color getLockedHandleColor()
Returns the current second handle color.
getMarqueeColor
public Color getMarqueeColor()
Returns the current marquee color.
getMarqueeHandler
public BasicMarqueeHandler getMarqueeHandler()
Returns the MarqueeHandler
that will handle marquee
selection.
getMinimumMove
public int getMinimumMove()
Returns the miminum amount of pixels for a move operation.
getModel
public GraphModel getModel()
Returns the GraphModel
that is providing the data.
- the model that is providing the data
getNextCellForLocation
public Object getNextCellForLocation(Object current,
double x,
double y)
Returns the cell at the specified location that is "behind" the
current
cell. Returns the topmost cell if there are no
more cells behind current
. Note: This does only return
visible cells.
getNextSelectableViewAt
public CellView getNextSelectableViewAt(CellView current,
double x,
double y)
Note: Arguments are not expected to be scaled (they are scaled in here).
getNextViewAt
public CellView getNextViewAt(CellView current,
double x,
double y)
Returns the next view at the specified location wrt. current
.
This is used to iterate overlapping cells, and cells that are grouped.
The current selection affects this method.
Note: This returns the next selectable view.
Note: Arguments are not expected to be scaled (they are scaled in here).
getNextViewAt
public CellView getNextViewAt(CellView current,
double x,
double y,
boolean leafsOnly)
Returns the next view at the specified location wrt. current
.
This is used to iterate overlapping cells, and cells that are grouped.
The current selection affects this method.
Note: This returns the next selectable view.
Note: Arguments are not expected to be scaled (they are scaled in here).
getNextViewAt
public CellView getNextViewAt(CellView[] cells,
CellView c,
double x,
double y)
Returns the next view at the specified location wrt. c
in
the specified array of views. The views must be in order, as returned,
for example, by GraphLayoutCache.order(Object[]).
getNextViewAt
public CellView getNextViewAt(CellView[] cells,
CellView c,
double x,
double y,
boolean leafsOnly)
Returns the next view at the specified location wrt. c
in
the specified array of views. The views must be in order, as returned,
for example, by GraphLayoutCache.order(Object[]).
getOffgraphics
public Graphics getOffgraphics()
Returns the current double buffering graphics object. Checks to see if
the graph bounds has changed since the last time the off screen image was
created and if so, creates a new image.
getOffscreen
public Image getOffscreen()
getOffscreenDirty
public Rectangle2D getOffscreenDirty()
Returns the area that is deemed dirty for the next double buffered redraw
- the area that is deemed dirty for the next double buffered redraw
getOffscreenOffset
public Point2D getOffscreenOffset()
getPortForLocation
public Object getPortForLocation(double x,
double y)
Convenience method to return the port at the specified location.
getPortViewAt
public PortView getPortViewAt(double x,
double y)
Returns the portview at the specified location.
Note: Arguments are not expected to be scaled (they are scaled in here).
getPortViewAt
public PortView getPortViewAt(double x,
double y,
int tolerance)
Returns the portview at the specified location.
Note: Arguments are not expected to be scaled (they are scaled in here).
getPreferredScrollableViewportSize
public Dimension getPreferredScrollableViewportSize()
Returns the preferred display size of a JGraph
. The
height is determined from getPreferredWidth
.
- the graph's preferred size
getRoots
public Object[] getRoots()
Returns all root cells (cells that have no parent) that the model
contains.
getRoots
public Object[] getRoots(Rectangle clip)
Returns all cells that intersect the given rectangle.
getScale
public double getScale()
Returns the current scale.
- the current scale as a double
getScrollableBlockIncrement
public int getScrollableBlockIncrement(Rectangle visibleRect,
int orientation,
int direction)
Returns the amount for a block increment, which is the height or width of
visibleRect
, based on orientation
.
visibleRect
- the view area visible within the viewportorientation
- either SwingConstants.VERTICAL
or
SwingConstants.HORIZONTAL
direction
- less than zero to scroll up/left, greater than zero for
down/right.
- the "block" increment for scrolling in the specified direction
javax.swing.JScrollBar.setBlockIncrement(int)
getScrollableTracksViewportHeight
public boolean getScrollableTracksViewportHeight()
Returns false to indicate that the height of the viewport does not
determine the height of the graph, unless the preferred height of the
graph is smaller than the viewports height. In other words: ensure that
the graph is never smaller than its viewport.
Scrollable.getScrollableTracksViewportHeight
getScrollableTracksViewportWidth
public boolean getScrollableTracksViewportWidth()
Returns false to indicate that the width of the viewport does not
determine the width of the graph, unless the preferred width of the graph
is smaller than the viewports width. In other words: ensure that the
graph is never smaller than its viewport.
Scrollable.getScrollableTracksViewportWidth
getScrollableUnitIncrement
public int getScrollableUnitIncrement(Rectangle visibleRect,
int orientation,
int direction)
Returns the amount to increment when scrolling. The amount is 4.
visibleRect
- the view area visible within the viewportorientation
- either SwingConstants.VERTICAL
or
SwingConstants.HORIZONTAL
direction
- less than zero to scroll up/left, greater than zero for
down/right
- the "unit" increment for scrolling in the specified direction
javax.swing.JScrollBar.setUnitIncrement(int)
getSelectionCell
public Object getSelectionCell()
Returns the first selected cell.
- the
Object
for the first selected cell, or
null
if nothing is currently selected
getSelectionCellAt
public Object getSelectionCellAt(Point2D pt)
Returns the selection cell at the specified location.
- Returns the selection cell for
pt
.
getSelectionCells
public Object[] getSelectionCells()
Returns all selected cells.
- an array of objects representing the selected cells, or
null
if nothing is currently selected
getSelectionCells
public Object[] getSelectionCells(Object[] cells)
Returns all selected cells in cells
.
getSelectionCount
public int getSelectionCount()
Returns the number of cells selected.
- the number of cells selected
getSelectionModel
public GraphSelectionModel getSelectionModel()
Returns the model for selections. This should always return a non-
null
value. If you don't want to allow anything to be
selected set the selection model to null
, which forces an
empty selection model to be used.
- the current selection model
getTolerance
public int getTolerance()
Returns the maximum distance between the mousepointer and a cell to be
selected.
getToolTipText
public String getToolTipText(MouseEvent e)
Overrides
JComponent
's
getToolTipText
method in order to allow the graph to create a tooltip for the topmost
cell under the mousepointer. This differs from JTree where the renderers
tooltip is used.
NOTE: For
JGraph
to properly display tooltips of its
renderers,
JGraph
must be a registered component with the
ToolTipManager
. This can be done by invoking
ToolTipManager.sharedInstance().registerComponent(graph)
.
This is not done automatically!
e
- the MouseEvent
that initiated the
ToolTip
display
- a string containing the tooltip or
null
if
event
is null
getTopmostViewAt
public CellView getTopmostViewAt(double x,
double y,
boolean reverse,
boolean leafsOnly)
Returns the topmost cell view at the specified location using the view's
bounds on non-leafs to check for containment. If reverse is true this
will return the innermost view.
getUI
public GraphUI getUI()
Returns the L&F object that renders this component.
- the GraphUI object that renders this component
getUIClassID
public String getUIClassID()
Returns the name of the L&F class that renders this component.
getViewPortBounds
public Rectangle2D getViewPortBounds()
Return the bounds of the parent viewport, if one exists. If one does not
exist, null is returned
- the bounds of the parent viewport
graphDidChange
public void graphDidChange()
Messaged when the graph has changed enough that we need to resize the
bounds, but not enough that we need to remove the cells (e.g cells were
inserted into the graph). You should never have to invoke this, the UI
will invoke this as it needs to. (Note: This is invoked by GraphUI, eg.
after moving.)
isAntiAliased
public boolean isAntiAliased()
Returns true if the graph will be anti aliased.
- true if the graph is anti aliased
isAutoResizeGraph
public boolean isAutoResizeGraph()
Returns true if the graph should be automatically resized when cells are
being moved below the bottom right corner. Note if the value of
moveBeyondGraphBounds
if false
auto resizing
is automatically disabled
isBackgroundScaled
public boolean isBackgroundScaled()
isBendable
public boolean isBendable()
Returns true if the graph allows adding/removing/modifying points.
isCellEditable
public boolean isCellEditable(Object cell)
Returns true
if the graph and the cell are editable. This
is invoked from the UI before editing begins to ensure that the given
cell can be edited.
- true if the specified cell is editable
isCellSelected
public boolean isCellSelected(Object cell)
Returns true if the cell is currently selected.
cell
- an object identifying a cell
- true if the cell is selected
isCloneable
public boolean isCloneable()
Returns true if cells are cloned on CTRL-Drag operations.
isConnectable
public boolean isConnectable()
Returns true if the graph allows new connections to be established.
isDisconnectOnMove
public boolean isDisconnectOnMove()
Returns true if selected edges should be disconnected from unselected
vertices when they are moved.
isDisconnectable
public boolean isDisconnectable()
Returns true if the graph allows existing connections to be removed.
isDragEnabled
public boolean isDragEnabled()
Returns true if the graph uses Drag-and-Drop to move cells.
isDropEnabled
public boolean isDropEnabled()
Returns true if the graph accepts drops/pastes from external sources.
isEditable
public boolean isEditable()
Returns true if the graph is editable (if it allows cells to be edited).
- true if the graph is editable
isEditing
public boolean isEditing()
Returns true if the graph is being edited. The item that is being edited
can be obtained using getEditingCell
.
- true if the user is currently editing a cell
isGridEnabled
public boolean isGridEnabled()
Returns true if the grid is active.
isGridVisible
public boolean isGridVisible()
Returns true if the grid will be visible.
- true if the grid is visible
isGroupsEditable
public boolean isGroupsEditable()
isJumpToDefaultPort
public boolean isJumpToDefaultPort()
Returns true if getPortViewAt should return the default port if no other
port is found.
isMoveBelowZero
public boolean isMoveBelowZero()
Returns true if the graph allows to move cells below zero.
isMoveBeyondGraphBounds
public boolean isMoveBeyondGraphBounds()
- the moveBeyondGraphBounds
isMoveIntoGroups
public boolean isMoveIntoGroups()
Returns true if cells should be added to groups when moved over the
group's area.
isMoveOutOfGroups
public boolean isMoveOutOfGroups()
Returns true if cells should be removed from groups when removed from the
group's area.
isMoveable
public boolean isMoveable()
isPortsOnTop
public boolean isPortsOnTop()
isPortsScaled
public boolean isPortsScaled()
Returns true if the ports will be scaled.
- true if the ports are visible
isPortsVisible
public boolean isPortsVisible()
Returns true if the ports will be visible.
- true if the ports are visible
isPreviewInvalidNullPorts
public boolean isPreviewInvalidNullPorts()
Returns true if graph allows invalid null ports during previews
- true if the graph allows invalid null ports during previews
isSelectionEmpty
public boolean isSelectionEmpty()
Returns true if the selection is currently empty.
- true if the selection is currently empty
isSelectionEnabled
public boolean isSelectionEnabled()
Returns true if the cell selection is enabled
- true if the cell selection is enabled
isSizeable
public boolean isSizeable()
Returns true if the graph allows cells to be resized.
isVolatileOffscreen
public boolean isVolatileOffscreen()
isXorEnabled
public boolean isXorEnabled()
Returns true if the graph accepts drops/pastes from external sources.
main
public static void main(String[] args)
order
public Object[] order(Object[] cells)
Returns all cells
including all descendants ordered using
the current layering data stored by the model.
paramString
protected String paramString()
Returns a string representation of this JGraph
. This
method is intended to be used only for debugging purposes, and the
content and format of the returned string may vary between
implementations. The returned string may be empty but may not be
null
.
- a string representation of this
JGraph
.
releaseOffscreenResources
public void releaseOffscreenResources()
Schedules the offscreen resources taken by the offscreen buffer to
be reclaimed. Note that this does not force garbage collection
removeGraphSelectionListener
public void removeGraphSelectionListener(GraphSelectionListener tsl)
Removes a GraphSelection
listener.
tsl
- the GraphSelectionListener
to remove
removeSelectionCell
public void removeSelectionCell(Object cell)
Removes the cell identified by the specified Object from the current
selection.
cell
- the cell to be removed from the selection
scrollCellToVisible
public void scrollCellToVisible(Object cell)
Scrolls to the specified cell. Only works when this JGraph
is contained in a JScrollPane
.
cell
- the object identifying the cell to bring into view
scrollPointToVisible
public void scrollPointToVisible(Point2D p)
Makes sure the specified point is visible.
p
- the point that should be visible
setAntiAliased
public void setAntiAliased(boolean newValue)
Sets antialiasing on or off based on the boolean value.
Fires a property change for the ANTIALIASED_PROPERTY.
newValue
- whether to turn antialiasing on or off
setAutoResizeGraph
public void setAutoResizeGraph(boolean autoResizeGraph)
Sets whether or not the graph should be automatically resize when cells
are being moved below the bottom right corner
setBackground
public void setBackground(Color bg)
Override parent to clear offscreen double buffer
setBackgroundComponent
public void setBackgroundComponent(Component backgroundComponent)
backgroundComponent
- the backgroundComponent to set
setBackgroundImage
public void setBackgroundImage(ImageIcon backgroundImage)
backgroundImage
- The backgroundImage to set.
setBackgroundScaled
public void setBackgroundScaled(boolean backgroundScaled)
backgroundScaled
- the backgroundScaled to set
setBendable
public void setBendable(boolean flag)
Sets if the graph allows adding/removing/modifying points.
setCloneable
public void setCloneable(boolean flag)
Sets if cells are cloned on CTRL-Drag operations.
setConnectable
public void setConnectable(boolean flag)
Setse if the graph allows new connections to be established.
setDisconnectOnMove
public void setDisconnectOnMove(boolean flag)
Sets if selected edges should be disconnected from unselected vertices
when they are moved.
setDisconnectable
public void setDisconnectable(boolean flag)
Sets if the graph allows existing connections to be removed.
setDragEnabled
public void setDragEnabled(boolean flag)
Sets if the graph uses Drag-and-Drop to move cells.
setDropEnabled
public void setDropEnabled(boolean flag)
Sets if the graph accepts drops/pastes from external sources.
setEdgeLabelsMovable
public void setEdgeLabelsMovable(boolean edgeLabelsMovable)
Set if edge labels may be moved with the mouse or not.
edgeLabelsMovable
- true if edge labels may be dragged
setEditClickCount
public void setEditClickCount(int count)
Sets the number of clicks for editing to start.
setEditable
public void setEditable(boolean flag)
Determines whether the graph is editable. Fires a property change event
if the new setting is different from the existing setting.
Note: Editable determines whether the graph allows editing. This is not
to be confused with enabled, which allows the graph to handle mouse
events (including editing).
flag
- a boolean value, true if the graph is editable
setGraphLayoutCache
public void setGraphLayoutCache(GraphLayoutCache newLayoutCache)
Sets the
GraphLayoutCache
that will provide the view-data.
Note: Updates the graphs's model using using the model from the layout
cache.
Fires a property change for the GRAPH_LAYOUT_CACHE_PROPERTY.
newLayoutCache
- the GraphLayoutCache
that is to provide the
view-data
setGridColor
public void setGridColor(Color newColor)
Sets the current grid color.
setGridEnabled
public void setGridEnabled(boolean flag)
If set to true, the grid will be active.
setGridMode
public void setGridMode(int mode)
Sets the current grid view mode.
mode
- The current grid view mode. Valid values are
DOT_GRID_MODE
,CROSS_GRID_MODE
, and
LINE_GRID_MODE
.
setGridSize
public void setGridSize(double newSize)
Sets the size of the grid.
Fires a property change for the GRID_SIZE_PROPERTY.
newSize
- the new size of the grid in pixels
setGridVisible
public void setGridVisible(boolean flag)
If set to true, the grid will be visible.
Fires a property change for the GRID_VISIBLE_PROPERTY.
setGroupsEditable
public void setGroupsEditable(boolean groupsEditable)
groupsEditable
- the groupsEditable to set
setHandleColor
public void setHandleColor(Color newColor)
Sets the current handle color.
setHandleSize
public void setHandleSize(int size)
Sets the size of the handles.
setHighlightColor
public void setHighlightColor(Color newColor)
Sets the current selection highlight color.
setInvokesStopCellEditing
public void setInvokesStopCellEditing(boolean newValue)
Determines what happens when editing is interrupted by selecting another
cell in the graph, a change in the graph's data, or by some other means.
Setting this property to
true
causes the changes to be
automatically saved when editing is interrupted.
Fires a property change for the INVOKES_STOP_CELL_EDITING_PROPERTY.
newValue
- true means that stopCellEditing
is invoked when
editing is interruped, and data is saved; false means that
cancelCellEditing
is invoked, and changes are
lost
setJumpToDefaultPort
public void setJumpToDefaultPort(boolean flag)
Sets if getPortViewAt should return the default port if no other port is
found.
setLockedHandleColor
public void setLockedHandleColor(Color newColor)
Sets the current second handle color.
setMarqueeColor
public void setMarqueeColor(Color newColor)
Sets the current marquee color.
setMarqueeHandler
public void setMarqueeHandler(BasicMarqueeHandler newMarquee)
Sets the MarqueeHandler
that will handle marquee
selection.
newMarquee
- the BasicMarqueeHandler
that is to provide
marquee handling
setMinimumMove
public void setMinimumMove(int pixels)
Sets the miminum amount of pixels for a move operation.
setModel
public void setModel(GraphModel newModel)
Sets the
GraphModel
that will provide the data. Note:
Updates the current GraphLayoutCache's model using setModel if the
GraphLayoutCache points to a different model.
Fires a property change for the GRAPH_MODEL_PROPERTY.
newModel
- the GraphModel
that is to provide the data
setMoveBelowZero
public void setMoveBelowZero(boolean moveBelowZero)
Sets if the graph should auto resize when cells are being moved below the
bottom right corner.
setMoveBeyondGraphBounds
public void setMoveBeyondGraphBounds(boolean moveBeyondGraphBounds)
moveBeyondGraphBounds
- the moveBeyondGraphBounds to set
setMoveIntoGroups
public void setMoveIntoGroups(boolean flag)
Specifies if cells should be added to groups when moved over the group's
area.
setMoveOutOfGroups
public void setMoveOutOfGroups(boolean flag)
Specifies if cells should be removed from groups when removed from the
group's area.
setMoveable
public void setMoveable(boolean flag)
Sets if the graph allows movement of cells.
setOffscreenOffset
public void setOffscreenOffset(Point2D offscreenOffset)
offscreenOffset
- the offscreenOffset to set
setOpaque
public void setOpaque(boolean opaque)
setPortsOnTop
public void setPortsOnTop(boolean portsOnTop)
setPortsScaled
public void setPortsScaled(boolean flag)
If set to true, the ports will be scaled.
Fires a property change for the PORTS_SCALED_PROPERTY.
setPortsVisible
public void setPortsVisible(boolean flag)
If set to true, the ports will be visible.
Fires a property change for the PORTS_VISIBLE_PROPERTY.
setPreviewInvalidNullPorts
public void setPreviewInvalidNullPorts(boolean flag)
Determines whether the graph allows invalid null ports during previews
flag
- a boolean value, true if the graph allows invalid null ports
during previews
setScale
public void setScale(double newValue)
Sets the current scale.
Fires a property change for the SCALE_PROPERTY.
setScale
public void setScale(double newValue,
Point2D center)
Sets the current scale and centers the graph to the specified point
newValue
- the new scalecenter
- the center of the graph
setSelectionCell
public void setSelectionCell(Object cell)
Selects the specified cell.
cell
- the Object
specifying the cell to select
setSelectionCells
public void setSelectionCells(Object[] cells)
Selects the specified cells.
cells
- an array of objects that specifies the cells to select
setSelectionEnabled
public void setSelectionEnabled(boolean flag)
Determines whether cell selection is enabled. Fires a property change
event if the new setting is different from the existing setting.
flag
- a boolean value, true if cell selection is enabled
setSelectionModel
public void setSelectionModel(GraphSelectionModel selectionModel)
Sets the graph's selection model. When a null
value is
specified an emtpy selectionModel
is used, which does not
allow selections.
selectionModel
- the GraphSelectionModel
to use, or
null
to disable selections
setSizeable
public void setSizeable(boolean flag)
Sets if the graph allows cells to be resized.
setTolerance
public void setTolerance(int size)
Sets the maximum distance between the mousepointer and a cell to be
selected.
setUI
public void setUI(GraphUI ui)
Sets the L&F object that renders this component.
ui
- the GraphUI L&F object
javax.swing.UIDefaults.getUI(JComponent)
setVolatileOffscreen
public void setVolatileOffscreen(boolean volatileOffscreen)
volatileOffscreen
- the volatileOffscreen to set
setXorEnabled
public void setXorEnabled(boolean flag)
Sets if the graph accepts drops/pastes from external sources.
setupOffScreen
protected void setupOffScreen(int x,
int y,
int width,
int height,
Rectangle2D newOffscreenBuffer)
Utility method that initialises the offscreen graphics area
x
- y
- width
- height
- newOffscreenBuffer
-
snap
public Dimension2D snap(Dimension2D d)
Returns the given dimension applied to the grid.
d
- a dimension in screen coordinates to snap to.
- the same dimension applied to the grid.
snap
public Point2D snap(Point2D p)
Returns the given point applied to the grid.
p
- a point in screen coordinates.
- the same point applied to the grid.
snap
public Rectangle2D snap(Rectangle2D r)
Returns the given rectangle applied to the grid.
r
- a rectangle in screen coordinates.
- the same rectangle applied to the grid.
startEditingAtCell
public void startEditingAtCell(Object cell)
Selects the specified cell and initiates editing. The edit-attempt fails
if the CellEditor
does not allow editing for the specified
item.
stopEditing
public boolean stopEditing()
Ends the current editing session. (The
DefaultGraphCellEditor
object saves any edits that are
currently in progress on a cell. Other implementations may operate
differently.) Has no effect if the tree isn't being edited.
Note:
To make edit-saves automatic whenever the user changes their position in
the graph, use setInvokesStopCellEditing(boolean)
.
- true if editing was in progress and is now stopped, false if
editing was not in progress
toScreen
public Point2D toScreen(Point2D p)
Upscale the given point in place, using the given instance.
p
- the point to be upscaled
- the upscaled point instance
toScreen
public Rectangle2D toScreen(Rectangle2D rect)
Upscale the given rectangle in place, using the given instance.
rect
- the rectangle to be upscaled
- the upscaled rectangle instance
updateAutoSize
public void updateAutoSize(CellView view)
Computes and updates the size for view
.
updateUI
public void updateUI()
Notification from the UIManager
that the L&F has changed.
Replaces the current UI object with the latest version from the
UIManager
. Subclassers can override this to support
different GraphUIs.