| C | |
| cacheEnabled, mxText | |
| cacheOffsetSize, mxSvgCanvas2D | |
| calcAttraction, mxFastOrganicLayout | |
| calcPositions, mxFastOrganicLayout | |
| calcRepulsion, mxFastOrganicLayout | |
| calcRowDims, mxRadialTreeLayout | |
| calculateCrossings, mxMedianHybridCrossingReduction | |
| calculatedWeightedValue, mxCoordinateAssignment | |
| calculateRankCrossing, mxMedianHybridCrossingReduction | |
| calculateWidestRank, mxCoordinateAssignment | |
| canExportCell, mxGraph | |
| canImportCell, mxGraph | |
| canRedo, mxUndoManager | |
| canUndo, mxUndoManager | |
| captureDocumentGesture, mxGraphView | |
| cascadeOpacity | |
| cell | |
| Cell alignment and orientation, mxGraph | |
| Cell cloning,insertion and removal, mxGraph | |
| Cell connecting and connection constraints, mxGraph | |
| Cell moving, mxGraph | |
| Cell retrieval, mxGraph | |
| Cell sizing, mxGraph | |
| Cell styles, mxGraph | |
| Cell visibility, mxGraph | |
| CELL_CONNECTED | |
| cellAdded | |
| cellCloned, mxGraphModel | |
| cellConnected, mxGraph | |
| cellEditor, mxGraph | |
| cellLabelChanged, mxGraph | |
| cellLocation, mxFastOrganicLayout | |
| cellRemoved | |
| cellRenderer, mxGraph | |
| cellResized, mxGraph | |
| cells | |
| CELLS_ADDED | |
| CELLS_FOLDED | |
| CELLS_MOVED | |
| CELLS_ORDERED | |
| CELLS_REMOVED | |
| CELLS_RESIZED | |
| CELLS_TOGGLED, mxEvent | |
| cellsAdded | |
| cellsBendable, mxGraph | |
| cellsCloneable, mxGraph | |
| cellsDeletable, mxGraph | |
| cellsDisconnectable, mxGraph | |
| cellsEditable, mxGraph | |
| cellsFolded, mxGraph | |
| cellSizeUpdated, mxGraph | |
| cellsLocked, mxGraph | |
| cellsMovable, mxGraph | |
| cellsMoved | |
| cellsOrdered, mxGraph | |
| cellsRemoved, mxGraph | |
| cellsResizable, mxGraph | |
| cellsResized | |
| cellsSelectable, mxGraph | |
| cellsToggled, mxGraph | |
| center, mxGraph | |
| centerZoom, mxGraph | |
| CHANGE | |
| changeHandler | |
| changePoints, mxEdgeHandler | |
| changes, mxUndoableEdit | |
| changeSelection, mxGraphSelectionModel | |
| changeTerminalPoint, mxEdgeHandler | |
| channelBuffer | |
| check, mxMultiplicity | |
| checkBounds | |
| checkConstraints, mxConnectionHandler | |
| checkEventSource, mxDragSource | |
| checkLabelHandle, mxEdgeHandler | |
| checkNeighbors, mxMultiplicity | |
| checkOverlap, mxParallelEdgeLayout | |
| checkPlaceholderStyles, mxCellRenderer | |
| checkPreview, mxGraphHandler | |
| checkTerminal, mxMultiplicity | |
| checkTolerance, mxVertexHandler | |
| checkType, mxMultiplicity | |
| children, mxCell | |
| circle, mxCircleLayout | |
| clear | |
| CLEAR | |
| clearCellOverlays, mxGraph | |
| clearSelection | |
| clearSelectionOnBackground, mxPopupMenuHandler | |
| click, mxGraph | |
| CLICK | |
| clipping, mxPrintPreview | |
| clone | |
| cloneCell | |
| cloneCellImpl, mxGraphModel | |
| cloneCells | |
| cloneEnabled | |
| cloneInvalidEdges, mxGraph | |
| clonePreviewState, mxEdgeHandler | |
| cloneTemplate, mxObjectCodec | |
| cloneValue, mxCell | |
| close | |
| CLOSE | |
| closeDocument, mxPrintPreview | |
| closeImage, mxWindow | |
| closeOp | |
| closeResource, mxUtils | |
| codecs, mxCodecRegistry | |
| collapsed, mxCell | |
| collapsedImage, mxGraph | |
| collapsedStateForCellChanged, mxGraphModel | |
| collapseExpandResource, mxGraph | |
| collapseToPreferredSize, mxGraph | |
| compare | |
| compressed, mxXmlCanvas2D | |
| computeAspect, mxStencil | |
| config, mxDefaultPopupMenu | |
| configure, mxEditor | |
| configureCanvas | |
| configureShape, mxCellRenderer | |
| confirm, mxUtils | |
| connect | |
| CONNECT | |
| CONNECT_CELL | |
| CONNECT_HANDLE_FILLCOLOR, mxConstants | |
| connectable, mxCell | |
| connectableEdges, mxGraph | |
| connectCell, mxGraph | |
| connectIconOffset, mxConnectionHandler | |
| connectImage, mxConnectionHandler | |
| connectOnDrop | |
| connectsAsSource, mxGraphHierarchyNode | |
| connectsAsTarget, mxGraphHierarchyNode | |
| consoleName, mxLog | |
| constrainChild, mxGraph | |
| constrainChildCells, mxGraph | |
| constrainChildren, mxGraph | |
| constrainGroupByChildren, mxVertexHandler | |
| constrainRelativeChildren, mxGraph | |
| CONSTRAINT_HIGHLIGHT_SIZE, mxConstants | |
| constraintHandler | |
| constraints, mxStencil | |
| consume | |
| consumeCycleAttribute, mxEditor | |
| consumed | |
| consumeMouseEvent | |
| consumePanningTrigger, mxPanningHandler | |
| container, mxToolbar | |
| contains | |
| containsValidationErrorsResource, mxGraph | |
| content, mxWindow | |
| contentHeightCorrection, mxWindow | |
| controlKeys, mxKeyHandler | |
| Controls and Handlers, mxEditor | |
| controlShiftKeys, mxKeyHandler | |
| convert, mxUrlConverter | |
| convertAttributeFromXml, mxObjectCodec | |
| convertAttributeToXml, mxObjectCodec | |
| converter, mxAbstractCanvas2D | |
| convertHtml, mxSvgCanvas2D | |
| convertPoint | |
| convertValueToString, mxGraph | |
| convertWaypoint, mxConnectionHandler | |
| copy, mxClipboard | |
| copyStyle, mxHandle | |
| count, mxCellStatePreview | |
| counter, mxObjectIdentity | |
| countError, mxMultiplicity | |
| create | |
| createBackgroundPageShape, mxGraphView | |
| createBends | |
| createBoundingBox, mxShape | |
| createBounds, mxVertexHandler | |
| createCanvas, mxShape | |
| createCellEditor, mxGraph | |
| createCellOverlays, mxCellRenderer | |
| createCellRenderer, mxGraph | |
| createClip, mxSvgCanvas2D | |
| createConditions, mxDefaultPopupMenu | |
| createConnectionHandler, mxGraph | |
| createControl, mxCellRenderer | |
| createControlClickHandler, mxCellRenderer | |
| createCustomHandles | |
| createDashPattern, mxSvgCanvas2D | |
| createDefaultEdgeStyle, mxStylesheet | |
| createDefaultVertexStyle, mxStylesheet | |
| createDiagramLayout, mxEditor | |
| createDiv, mxSvgCanvas2D | |
| createDragElement, mxDragSource | |
| createEdge | |
| createEdgeHandler, mxGraph | |
| createEdgeSegmentHandler, mxGraph | |
| createEdgeState, mxConnectionHandler | |
| createElbowEdgeHandler, mxGraph | |
| createElement | |
| createFill, mxVmlCanvas2D | |
| createGhostPreview, mxVertexHandler | |
| createGradientId, mxSvgCanvas2D | |
| createGraph | |
| createGraphHandler, mxGraph | |
| createGraphView, mxGraph | |
| createGroup, mxEditor | |
| createGroupCell, mxGraph | |
| createGuideShape, mxGuide | |
| createHandler, mxGraph | |
| createHandlers, mxGraph | |
| createHandleShape, mxEdgeHandler | |
| createHighlightShape, mxConstraintHandler | |
| createHtml | |
| createHtmlPane, mxGraphView | |
| createIcons, mxConnectionHandler | |
| createId, mxGraphModel | |
| createIds, mxGraphModel | |
| createImage, mxUtils | |
| createIndicatorShape, mxCellRenderer | |
| createInternalCells | |
| createLabel, mxCellRenderer | |
| createLabelHandleShape, mxEdgeHandler | |
| createLayoutManager, mxEditor | |
| createLine, mxCompactTreeLayout | |
| createMarker | |
| createMenu, mxDefaultPopupMenu | |
| createMsXmlDocument, mxUtils | |
| createNode, mxCompactTreeLayout | |
| createPageSelector, mxPrintPreview | |
| createPanningHandler, mxGraph | |
| createPanningManager, mxGraph | |
| createParentHighlightShape | |
| createPopupMenu, mxEditor | |
| createPopupMenuHandler, mxGraph | |
| createPreviewElement, mxDragSource | |
| createPreviewShape, mxGraphHandler | |
| createProperties, mxEditor | |
| createRect, mxVmlCanvas2D | |
| createRoot, mxGraphModel | |
| createSelectionCellsHandler, mxGraph | |
| createSelectionModel, mxGraph | |
| createSelectionShape | |
| createShadow | |
| createShadowFill, mxVmlCanvas2D | |
| createShadowStroke, mxVmlCanvas2D | |
| createShape | |
| createSizer | |
| createSizerShape, mxVertexHandler | |
| createState | |
| createStroke, mxVmlCanvas2D | |
| createStyle, mxSvgCanvas2D | |
| createStylesheet, mxGraph | |
| createSubmenu, mxPopupMenu | |
| createSvg | |
| createSvgCanvas, mxShape | |
| createSvgGradient, mxSvgCanvas2D | |
| createSwimlaneLayout, mxEditor | |
| createSwimlaneManager, mxEditor | |
| createTarget, mxConnectionHandler | |
| createTargetVertex, mxConnectionHandler | |
| createTasks, mxEditor | |
| createText, mxVmlCanvas2D | |
| createTolerance, mxSvgCanvas2D | |
| createToolbar, mxEditor | |
| createTooltipHandler, mxGraph | |
| createTransparentFill, mxVmlCanvas2D | |
| createTransparentSvgRectangle, mxShape | |
| createUndoableEdit, mxGraphModel | |
| createUrlConverter, mxAbstractCanvas2D | |
| createVertex, mxGraph | |
| createVertexHandler, mxGraph | |
| createVirtualBend, mxElbowEdgeHandler | |
| createVirtualBends, mxEdgeHandler | |
| createVml | |
| createVmlCanvas, mxShape | |
| createVmlElement, mxVmlCanvas2D | |
| createVmlGroup, mxShape | |
| createVmlPane, mxGraphView | |
| createXmlDocument, mxUtils | |
| crossingStage | |
| currentBestCrossings, mxMedianHybridCrossingReduction | |
| currentColor, mxCellMarker | |
| currentDropTarget, mxDragSource | |
| currentDx, mxGraphHandler | |
| currentDy, mxGraphHandler | |
| currentEdit, mxGraphModel | |
| currentFileResource, mxEditor | |
| currentGraph, mxDragSource | |
| currentGuide, mxDragSource | |
| currentPoint, mxDragSource | |
| currentRoot, mxGraphView | |
| currentX, mxRubberband | |
| currentXDelta, mxCoordinateAssignment | |
| currentY, mxRubberband | |
| cursor | |
| CURSOR_BEND_HANDLE, mxConstants | |
| CURSOR_CONNECT, mxConstants | |
| CURSOR_LABEL_HANDLE, mxConstants | |
| CURSOR_MOVABLE_EDGE, mxConstants | |
| CURSOR_MOVABLE_VERTEX, mxConstants | |
| CURSOR_TERMINAL_HANDLE, mxConstants | |
| CURSOR_VIRTUAL_BEND_HANDLE, mxConstants | |
| curveOp | |
| curveTo | |
| CUSTOM_HANDLE, mxEvent | |
| cut, mxClipboard | |
| cycleAttribute, mxEditor | |
| cycleAttributeIndex, mxEditor | |
| cycleAttributeName, mxEditor | |
| cycleAttributeValues, mxEditor | |
| cycleStage |
Specifies if caching for HTML labels should be enabled.
mxText.prototype.cacheEnabled
Specifies if offsetWidth and offsetHeight should be cached.
mxSvgCanvas2D.prototype.cacheOffsetSize
Calculates the attractive forces between all laid out nodes linked by edges
mxFastOrganicLayout.prototype.calcAttraction = function()
Takes the displacements calculated for each cell and applies them to the local cache of cell positions.
mxFastOrganicLayout.prototype.calcPositions = function()
Calculates the repulsive forces between all laid out nodes
mxFastOrganicLayout.prototype.calcRepulsion = function()
Recursive function to calculate the dimensions of each row
mxRadialTreeLayout.prototype.calcRowDims = function( row, rowNum )
Calculates the total number of edge crossing in the current graph.
mxMedianHybridCrossingReduction.prototype.calculateCrossings = function( model )
Calculates the priority the specified cell has based on the type of its cell and the cells it is connected to on the next layer
mxCoordinateAssignment.prototype.calculatedWeightedValue = function( currentCell, collection )
Calculates the number of edges crossings between the specified rank and the rank below it.
mxMedianHybridCrossingReduction.prototype.calculateRankCrossing = function( i, model )
Calculates the width rank in the hierarchy.
mxCoordinateAssignment.prototype.calculateWidestRank = function( graph, model )
Returns true if the given cell may be exported to the clipboard.
mxGraph.prototype.canExportCell = function( cell )
Returns true if the given cell may be imported from the clipboard.
mxGraph.prototype.canImportCell = function( cell )
Returns true if a redo is possible.
mxUndoManager.prototype.canRedo = function()
Returns true if an undo is possible.
mxUndoManager.prototype.canUndo = function()
Specifies if a gesture should be captured when it goes outside of the graph container.
mxGraphView.prototype.captureDocumentGesture
Sets the opacity on the given cell and its descendants.
cascadeOpacity: function( graph, cell, opacity )
See mxEffects.cascadeOpacity.
cascadeOpacity: function( graph, cell, opacity )
The cell whose median value is being calculated
MedianCellSorter.prototype.cell
Reference to the mxCell that is represented by this state.
mxCellState.prototype.cell
The graph cell this object represents.
mxGraphHierarchyNode.prototype.cell
The cell whose median value is being calculated.
WeightedCellSorter.prototype.cell
Specifies the event name for cellConnected.
CELL_CONNECTED: 'cellConnected'
Inner callback to update cells when a cell has been added.
mxGraphModel.prototype.cellAdded = function( cell )
Inner callback to add the specified mxCell to the selection.
mxGraphSelectionModel.prototype.cellAdded = function( cell )
Hook for cloning the cell.
mxGraphModel.prototype.cellCloned = function( cell )
Sets the new terminal for the given edge and resets the edge points if resetEdgesOnConnect is true.
mxGraph.prototype.cellConnected = function( edge, terminal, source, constraint )
Holds the mxCellEditor that is used as the in-place editing.
mxGraph.prototype.cellEditor
Sets the new label for a cell.
mxGraph.prototype.cellLabelChanged = function( cell, value, autoSize )
An array of locally stored co-ordinate positions for the vertices.
mxFastOrganicLayout.prototype.cellLocation
Inner callback to update cells when a cell has been removed.
mxGraphModel.prototype.cellRemoved = function( cell )
Inner callback to remove the specified mxCell from the selection.
mxGraphSelectionModel.prototype.cellRemoved = function( cell )
Holds the mxCellRenderer for rendering the cells in the graph.
mxGraph.prototype.cellRenderer
Resizes the parents recursively so that they contain the complete area of the resized child cell.
mxGraph.prototype.cellResized = function( cell, bounds, ignoreRelative, recurse )
Holds the array of mxCells currently in the clipboard.
cells: null
Maps from Ids to cells.
mxGraphModel.prototype.cells
Optional array of cells to be animated.
mxMorphing.prototype.cells
Specifies the event name for cellsAdded.
CELLS_ADDED: 'cellsAdded'
Specifies the event name for cellsFolded.
CELLS_FOLDED: 'cellsFolded'
Specifies the event name for cellsMoved.
CELLS_MOVED: 'cellsMoved'
Specifies the event name for cellsOrdered.
CELLS_ORDERED: 'cellsOrdered'
Specifies the event name for cellsRemoved.
CELLS_REMOVED: 'cellsRemoved'
Specifies the event name for cellsResized.
CELLS_RESIZED: 'cellsResized'
Specifies the event name for cellsToggled.
CELLS_TOGGLED: 'cellsToggled'
Adds the specified cells to the given parent.
mxGraph.prototype.cellsAdded = function( cells, parent, index, source, target, absolute, constrain, extend )
Called if any cells have been added.
mxSwimlaneManager.prototype.cellsAdded = function( cells )
Specifies the return value for isCellsBendable.
mxGraph.prototype.cellsBendable
Specifies the return value for isCellCloneable.
mxGraph.prototype.cellsCloneable
Specifies the return value for isCellDeletable.
mxGraph.prototype.cellsDeletable
Specifies the return value for isCellDisconntable.
mxGraph.prototype.cellsDisconnectable
Specifies the return value for isCellEditable.
mxGraph.prototype.cellsEditable
Sets the collapsed state of the specified cells.
mxGraph.prototype.cellsFolded = function( cells, collapse, recurse, checkFoldable )
Updates the size of the given cell in the model using getPreferredSizeForCell to get the new size.
mxGraph.prototype.cellSizeUpdated = function( cell, ignoreChildren )
Specifies the return value for isCellLocked.
mxGraph.prototype.cellsLocked
Specifies the return value for isCellMovable.
mxGraph.prototype.cellsMovable
Moves the specified cells by the given vector, disconnecting the cells using disconnectGraph is disconnect is true.
mxGraph.prototype.cellsMoved = function( cells, dx, dy, disconnect, constrain, extend )
Called from moveHandler.
mxLayoutManager.prototype.cellsMoved = function( cells, evt )
Moves the given cells to the front or back.
mxGraph.prototype.cellsOrdered = function( cells, back )
Removes the given cells from the model.
mxGraph.prototype.cellsRemoved = function( cells )
Specifies the return value for isCellResizable.
mxGraph.prototype.cellsResizable
Sets the bounds of the given cells and fires a mxEvent.CELLS_RESIZED event.
mxGraph.prototype.cellsResized = function( cells, bounds, recurse )
Called from resizeHandler.
mxLayoutManager.prototype.cellsResized = function( cells, bounds, prev )
Called if any cells have been resizes.
mxSwimlaneManager.prototype.cellsResized = function( cells )
Specifies the return value for isCellSelectable.
mxGraph.prototype.cellsSelectable
Sets the visible state of the specified cells.
mxGraph.prototype.cellsToggled = function( cells, show )
Centers the graph in the container.
mxGraph.prototype.center = function( horizontal, vertical, cx, cy )
Specifies if the zoom operations should go into the center of the actual diagram rather than going from top, left.
mxGraph.prototype.centerZoom
Specifies the event name for change.
CHANGE: 'change'
Holds the function that handles graph model changes.
mxAutoSaveManager.prototype.changeHandler
Holds the change event listener for later removal.
mxConnectionHandler.prototype.changeHandler
Changes the control points of the given edge in the graph model.
mxEdgeHandler.prototype.changePoints = function( edge, points, clone )
Array that contains the changes that make up this edit.
mxUndoableEdit.prototype.changes
Adds/removes the specified arrays of mxCell to/from the selection.
mxGraphSelectionModel.prototype.changeSelection = function( added, removed )
Changes the terminal point of the given edge.
mxEdgeHandler.prototype.changeTerminalPoint = function( edge, point, isSource, clone )
The size of the vertical buffer in the center of inter-rank channels where edge control points should not be placed.
mxCompactTreeLayout.prototype.channelBuffer
The size of the vertical buffer in the center of inter-rank channels where edge control points should not be placed Default is 4.
mxCoordinateAssignment.prototype.channelBuffer
Checks the multiplicity for the given arguments and returns the error for the given connection or null if the multiplicity does not apply.
mxMultiplicity.prototype.check = function( graph, edge, source, target, sourceOut, targetIn )
Returns true if the bounds are not null and all of its variables are numeric.
mxShape.prototype.checkBounds = function()
Returns true if the bounds are not null and all of its variables are numeric.
mxText.prototype.checkBounds = function()
Returns true if the connection for the given constraints is valid.
mxConnectionHandler.prototype.checkConstraints = function( c1, c2 )
Whether the event source should be checked in graphContainerEvent.
mxDragSource.prototype.checkEventSource
Checks if the label handle intersects the given bounds and moves it if it intersects.
mxEdgeHandler.prototype.checkLabelHandle = function( b )
Checks if there are any valid neighbours in validNeighbors.
mxMultiplicity.prototype.checkNeighbors = function( graph, edge, source, target )
Specifies if only overlapping edges should be considered parallel.
mxParallelEdgeLayout.prototype.checkOverlap
Checks if the style of the given mxCellState contains ‘inherit’, ‘indicated’ or ‘swimlane’ for colors that support those keywords.
mxCellRenderer.prototype.checkPlaceholderStyles = function( state )
Updates the preview if cloning state has changed.
mxGraphHandler.prototype.checkPreview = function()
Checks the given terminal cell and returns true if this rule applies.
mxMultiplicity.prototype.checkTerminal = function( graph, terminal, edge )
Checks if the coordinates for the given event are within the mxGraph.tolerance.
mxVertexHandler.prototype.checkTolerance = function( me )
Checks the type of the given value.
mxMultiplicity.prototype.checkType = function( graph, value, type, attr, attrValue )
Holds the child cells.
mxCell.prototype.children
Executes the circular layout for the specified array of vertices and the given radius.
mxCircleLayout.prototype.circle = function( vertices, r, left, top )
Clears the dictionary.
mxDictionary.prototype.clear = function()
Sets a new root using createRoot.
mxGraphModel.prototype.clear = function()
Clears the selection and fires a change event if the selection was not empty.
mxGraphSelectionModel.prototype.clear = function()
Removes the state of the given cell and all descendants if the given cell is not the current root.
mxGraphView.prototype.clear = function( cell, force, recurse )
Deletes the ID from the given object or function.
clear: function( obj )
Removes all child nodes and resets all CSS.
mxShape.prototype.clear = function()
Clears the command history.
mxUndoManager.prototype.clear = function()
Specifies the event name for clear.
CLEAR: 'clear'
Removes all mxCellOverlays in the graph for the given cell and all its descendants.
mxGraph.prototype.clearCellOverlays = function( cell )
Clears the selection.
mxCellEditor.prototype.clearSelection = function()
Clears the selection using mxGraphSelectionModel.clear.
mxGraph.prototype.clearSelection = function()
Clears the current selection in the page.
clearSelection: function()
Specifies if cells should be deselected if a popupmenu is displayed for the diagram background.
mxPopupMenuHandler.prototype.clearSelectionOnBackground
Processes a singleclick on an optional cell and fires a click event.
mxGraph.prototype.click = function( me )
Specifies the event name for click.
CLICK: 'click'
Specifies is clipping should be used to avoid creating too many cell states in large diagrams.
mxPrintPreview.prototype.clipping
Returns a clone of the cell.
mxCell.prototype.clone = function()
Returns a clone of this mxPoint.
mxCellState.prototype.clone = function()
Returns a clone of this mxPoint.
mxPoint.prototype.clone = function()
Recursively clones the specified object ignoring all fieldnames in the given array of transient fields.
clone: function( obj, transients, shallow )
Returns the clone for the given cell.
mxGraph.prototype.cloneCell = function( cell, allowInvalidEdges, mapping, keepPosition )
Returns a deep clone of the given mxCell (including the children) which is created using cloneCells.
mxGraphModel.prototype.cloneCell = function( cell, includeChildren )
Inner helper method for cloning cells recursively.
mxGraphModel.prototype.cloneCellImpl = function( cell, mapping, includeChildren )
Returns the clones for the given cells.
mxGraph.prototype.cloneCells = function( cells, allowInvalidEdges, mapping, keepPosition )
Returns an array of clones for the given array of mxCells.
mxGraphModel.prototype.cloneCells = function( cells, includeChildren, mapping )
Specifies if cloning by control-drag is enabled.
mxEdgeHandler.prototype.cloneEnabled
Specifies if cloning by control-drag is enabled.
mxGraphHandler.prototype.cloneEnabled
Specifies if edges that are cloned should be validated and only inserted if they are valid.
mxGraph.prototype.cloneInvalidEdges
Returns a clone of the current preview state for the given point and terminal.
mxEdgeHandler.prototype.clonePreviewState = function( point, terminal )
Returns a new instance of the template for this codec.
mxObjectCodec.prototype.cloneTemplate = function()
Returns a clone of the cell’s user object.
mxCell.prototype.cloneValue = function()
Closes the current path.
mxAbstractCanvas2D.prototype.close = function( x1, y1, x2, y2, x3, y3 )
Closes the print preview window.
mxPrintPreview.prototype.close = function()
Closes the current path.
mxXmlCanvas2D.prototype.close = function()
Specifies the event name for close.
CLOSE: 'close'
Writes the closing tags for body and page after calling writePostfix.
mxPrintPreview.prototype.closeDocument = function()
URL of the image to be used for the close icon in the titlebar.
mxWindow.prototype.closeImage
Holds the operator for closing curves.
mxAbstractCanvas2D.prototype.closeOp
Holds the operator for closing curves.
mxVmlCanvas2D.prototype.closeOp
Specifies the resource key for the label of the close button.
closeResource: ( mxClient. language ! = 'none' ) ? 'close' : ''
Maps from constructor names to codecs.
codecs: []
Specifies whether the cell is collapsed.
mxCell.prototype.collapsed
Specifies the mxImage to indicate a collapsed state.
mxGraph.prototype.collapsedImage
Inner callback to update the collapsed state of the given mxCell using mxCell.setCollapsed and return the previous collapsed state.
mxGraphModel.prototype.collapsedStateForCellChanged = function( cell, collapsed )
Specifies the resource key for the tooltip on the collapse/expand icon.
mxGraph.prototype.collapseExpandResource
Specifies if the cell size should be changed to the preferred size when a cell is first collapsed.
mxGraph.prototype.collapseToPreferredSize
Compares two MedianCellSorters.
MedianCellSorter.prototype.compare = function( a, b )
Compares the given cell paths and returns -1 if p1 is smaller, 0 if p1 is equal and 1 if p1 is greater than p2.
compare: function( p1, p2 )
Compares two WeightedCellSorters.
WeightedCellSorter.prototype.compare = function( a, b )
Specifies if the output should be compressed by removing redundant calls.
mxXmlCanvas2D.prototype.compressed
Returns a rectangle that contains the offset in x and y and the horizontal and vertical scale in width and height used to draw this shape inside the given mxRectangle.
mxStencil.prototype.computeAspect = function( shape, x, y, w, h, direction )
XML node used as the description of new menu items.
mxDefaultPopupMenu.prototype.config
Configures the editor using the specified node.
mxEditor.prototype.configure = ( node ) =>
Sets the state of the canvas for drawing the shape.
mxShape.prototype.configureCanvas = function( c, x, y, w, h )
Sets the state of the canvas for drawing the shape.
mxText.prototype.configureCanvas = function( c, x, y, w, h )
Configures the shape for the given cell state.
mxCellRenderer.prototype.configureShape = function( state )
Displays the given message in a confirm dialog.
confirm: function( message )
Connects the given source and target using a new edge.
mxConnectionHandler.prototype.connect = function( source, target, evt, dropTarget )
Handles a drop by connecting the given vertex to the given source cell.
mxDefaultToolbar.prototype.connect = function( vertex, evt, source )
Changes the terminal or terminal point of the given edge in the graph model.
mxEdgeHandler.prototype.connect = function( edge, terminal, isSource, isClone, me )
Specifies the event name for connect.
CONNECT: 'connect'
Specifies the event name for connectCell.
CONNECT_CELL: 'connectCell'
Defines the color to be used for the connect handle fill color.
CONNECT_HANDLE_FILLCOLOR: '#0000FF'
Specifies whether the cell is connectable.
mxCell.prototype.connectable
Specifies if edges are connectable.
mxGraph.prototype.connectableEdges
Connects the specified end of the given edge to the given terminal using cellConnected and fires mxEvent.CONNECT_CELL while the transaction is in progress.
mxGraph.prototype.connectCell = function( edge, terminal, source, constraint )
Holds the offset for connect icons during connection preview.
mxConnectionHandler.prototype.connectIconOffset
mxImage that is used to trigger the creation of a new connection.
mxConnectionHandler.prototype.connectImage
Specifies if elements should be connected if new cells are dropped onto connectable elements.
mxDefaultToolbar.prototype.connectOnDrop
Specifies if drop events are interpreted as new connections if no other drop action is defined.
mxGraphHandler.prototype.connectOnDrop
Collection of hierarchy edges that have this node as a source
mxGraphHierarchyNode.prototype.connectsAsSource
Collection of hierarchy edges that have this node as a target
mxGraphHierarchyNode.prototype.connectsAsTarget
Specifies the name of the console window.
consoleName: 'Console'
Keeps the given cell inside the bounds returned by getCellContainmentArea for its parent, according to the rules defined by getOverlap and isConstrainChild.
mxGraph.prototype.constrainChild = function( cell, sizeFirst )
Constrains the children of the given cell using constrainChild.
mxGraph.prototype.constrainChildCells = function( cell )
Specifies if a child should be constrained inside the parent bounds after a move or resize of the child.
mxGraph.prototype.constrainChildren
Specifies if the size of groups should be constrained by the children.
mxVertexHandler.prototype.constrainGroupByChildren
Specifies if child cells with relative geometries should be constrained inside the parent bounds, if constrainChildren is true, and/or the maximumGraphBounds.
mxGraph.prototype.constrainRelativeChildren
Holds the mxConstraintHandler used for drawing and highlighting constraints.
mxConnectionHandler.prototype.constraintHandler
Holds the mxConstraintHandler used for drawing and highlighting constraints.
mxEdgeHandler.prototype.constraintHandler
Holds an array of mxConnectionConstraints as defined in the shape.
mxStencil.prototype.constraints
Consumes the given event.
consume: function( evt, preventDefault, stopPropagation )
Consumes the event.
mxEventObject.prototype.consume = function()
Sets consumed to true and invokes preventDefault on the native event if such a method is defined.
mxMouseEvent.prototype.consume = function( preventDefault )
Returns the next attribute in cycleAttributeValues or null, if not attribute should be used in the specified cell.
mxEditor.prototype.consumeCycleAttribute = ( cell ) =>
Holds the consumed state.
mxEventObject.prototype.consumed
Holds the consumed state of this event.
mxMouseEvent.prototype.consumed
Consumes the given mxMouseEvent if it’s a touchStart event.
mxGraph.prototype.consumeMouseEvent = function( evtName, me, sender )
Consumes the given mouse event.
mxGraphHandler.prototype.consumeMouseEvent = function( evtName, me )
Consumes the given mxMouseEvent if it was a panning trigger in mouseDown.
mxPanningHandler.prototype.consumePanningTrigger = function( me )
Reference to the DOM nodes that contains the toolbar.
mxToolbar.prototype.container
Returns true if the model contains the given mxCell.
mxGraphModel.prototype.contains = function( cell )
Returns true if the specified point (x, y) is contained in the given rectangle.
contains: function( bounds, x, y )
Specifies the resource key for the warning message to be displayed when a collapsed cell contains validation errors.
mxGraph.prototype.containsValidationErrorsResource
Reference to the DOM node that represents the window content.
mxWindow.prototype.content
Defines the correction factor for computing the height of the contentWrapper.
mxWindow.prototype.contentHeightCorrection
Maps from keycodes to functions for pressed control keys.
mxKeyHandler.prototype.controlKeys
Maps from keycodes to functions for pressed control and shift keys.
mxKeyHandler.prototype.controlShiftKeys
Converts the given URL to an absolute URL with protol and domain.
mxUrlConverter.prototype.convert = function( url )
Converts booleans and numeric values to the respective types.
mxObjectCodec.prototype.convertAttributeFromXml = function( dec, attr, obj )
Converts true to “1” and false to “0” is isBooleanAttribute returns true.
mxObjectCodec.prototype.convertAttributeToXml = function( enc, obj, name, value )
Holds the mxUrlConverter to convert image URLs.
this.converter
Converts the given HTML string to XHTML.
mxSvgCanvas2D.prototype.convertHtml = function( val )
Converts the given point in-place from screen to unscaled, untranslated graph coordinates and applies the grid.
mxEdgeHandler.prototype.convertPoint = function( point, gridEnabled )
Converts the given point in-place from screen to unscaled, untranslated graph coordinates and applies the grid.
mxElbowEdgeHandler.prototype.convertPoint = function( point, gridEnabled )
Converts the specified point (x, y) using the offset of the specified container and returns a new mxPoint with the result.
convertPoint: function( container, x, y )
Returns the textual representation for the given cell.
mxGraph.prototype.convertValueToString = function( cell )
Converts the given point from screen coordinates to model coordinates.
mxConnectionHandler.prototype.convertWaypoint = function( point )
Copies the given array of mxCells from the specified graph to cells.
copy: function( graph, cells )
Sets the cell style with the given name to the corresponding value in state.
mxHandle.prototype.copyStyle = function( key )
Contains the number of entries in the map.
mxCellStatePreview.prototype.count
Current counter.
counter: 0
Holds the localized error message to be displayed if the number of connections for which the rule applies is smaller than min or greater than max.
mxMultiplicity.prototype.countError
Creates the cell path for the given cell.
create: function( cell )
Creates and returns the DOM node(s) for the shape in the given container.
mxShape.prototype.create = function( container )
Creates and returns the inner request object.
mxXmlRequest.prototype.create = function()
Creates and returns the shape used as the background page.
mxGraphView.prototype.createBackgroundPageShape = function( bounds )
Adds custom bends for the center of each segment.
mxEdgeSegmentHandler.prototype.createBends = function()
Creates and returns the bends used for modifying the edge.
mxEdgeHandler.prototype.createBends = function()
Overrides mxEdgeHandler.createBends to create custom bends.
mxElbowEdgeHandler.prototype.createBends = function()
Returns a new rectangle that represents the bounding box of the bare shape with no shadows or strokewidths.
mxShape.prototype.createBoundingBox = function()
Creates a new canvas for drawing this shape.
mxShape.prototype.createCanvas = function()
Creates a new mxCellEditor to be used in this graph.
mxGraph.prototype.createCellEditor = function()
Creates the actual shape for showing the overlay for the given cell state.
mxCellRenderer.prototype.createCellOverlays = function( state )
Creates a new mxCellRenderer to be used in this graph.
mxGraph.prototype.createCellRenderer = function()
Creates a clip for the given coordinates.
mxSvgCanvas2D.prototype.createClip = function( x, y, w, h )
Evaluates the default conditions for the given context.
mxDefaultPopupMenu.prototype.createConditions = function( editor, cell, evt )
Creates and returns a new mxConnectionHandler to be used in this graph.
mxGraph.prototype.createConnectionHandler = function()
Creates the control for the given cell state.
mxCellRenderer.prototype.createControl = function( state )
Hook for creating the click handler for the folding icon.
mxCellRenderer.prototype.createControlClickHandler = function( state )
Returns an array of custom handles.
mxEdgeHandler.prototype.createCustomHandles = function()
Returns an array of custom handles.
mxVertexHandler.prototype.createCustomHandles = function()
Creates the SVG dash pattern for the given state.
mxSvgCanvas2D.prototype.createDashPattern = function( scale )
Creates and returns the default edge style.
mxStylesheet.prototype.createDefaultEdgeStyle = function()
Creates and returns the default vertex style.
mxStylesheet.prototype.createDefaultVertexStyle = function()
Creates the layout instance used to layout the swimlanes in the diagram.
mxEditor.prototype.createDiagramLayout = () =>
Private helper function to create SVG elements
mxSvgCanvas2D.prototype.createDiv = function( str )
Creates and returns a clone of the dragElementPrototype or the element if the former is not defined.
mxDragSource.prototype.createDragElement = function( evt )
Creates and returns a new edge using factoryMethod if one exists.
mxConnectionHandler.prototype.createEdge = function( value, source, target, style )
Uses defaultEdge as the prototype for creating new edges in the connection handler of the graph.
mxEditor.prototype.createEdge = ( source, target ) =>
Hook method that creates the new edge for insertEdge.
mxGraph.prototype.createEdge = function( parent, id, value, source, target, style )
Hooks to create a new mxEdgeHandler for the given mxCellState.
mxGraph.prototype.createEdgeHandler = function( state, edgeStyle )
Hooks to create a new mxEdgeSegmentHandler for the given mxCellState.
mxGraph.prototype.createEdgeSegmentHandler = function( state )
Hook to return an mxCellState which may be used during the preview.
mxConnectionHandler.prototype.createEdgeState = function( me )
Hooks to create a new mxElbowEdgeHandler for the given mxCellState.
mxGraph.prototype.createElbowEdgeHandler = function( state )
Private helper function to create SVG elements
mxSvgCanvas2D.prototype.createElement = function( tagName, namespace )
Creates the given element using the document.
mxVmlCanvas2D.prototype.createElement = function( name )
Creates the given element using the owner document of root.
mxXmlCanvas2D.prototype.createElement = function( name )
Creates a fill for the current state.
mxVmlCanvas2D.prototype.createFill = function()
Starts the handling of the mouse gesture.
mxVertexHandler.prototype.createGhostPreview = function()
Private helper function to create SVG elements
mxSvgCanvas2D.prototype.createGradientId = function( start, end, alpha1, alpha2, direction )
Creates the graph for the editor.
mxEditor.prototype.createGraph = () =>
Creates the mxGraph used in the outline.
mxOutline.prototype.createGraph = function( container )
Creates and returns a new mxGraphHandler to be used in this graph.
mxGraph.prototype.createGraphHandler = function()
Creates a new mxGraphView to be used in this graph.
mxGraph.prototype.createGraphView = function()
Creates and returns a clone of defaultGroup to be used as a new group cell in group.
mxEditor.prototype.createGroup = () =>
Hook for creating the group cell to hold the given array of mxCells if no group cell was given to the group function.
mxGraph.prototype.createGroupCell = function( cells )
Returns the mxShape to be used for painting the respective guide.
mxGuide.prototype.createGuideShape = function( horizontal )
Creates a new handler for the given cell state.
mxGraph.prototype.createHandler = function( state )
Creates the tooltip-, panning-, connection- and graph-handler (in this order).
mxGraph.prototype.createHandlers = function()
Creates the shape used to display the given bend.
mxEdgeHandler.prototype.createHandleShape = function( index )
Create the shape used to paint the highlight.
mxConstraintHandler.prototype.createHighlightShape = function()
Creates the DOM nodes for the HTML display.
mxGraphView.prototype.createHtml = function()
Creates and returns the HTML DOM node(s) to represent this shape.
mxImageShape.prototype.createHtml = function()
Creates and returns the HTML DOM node(s) to represent this shape.
mxShape.prototype.createHtml = function()
Creates and returns a drawing pane in HTML (DIV).
mxGraphView.prototype.createHtmlPane = function( width, height )
Creates the array mxImageShapes that represent the connect icons for the given mxCellState.
mxConnectionHandler.prototype.createIcons = function( state )
Hook method to create an Id for the specified cell.
mxGraphModel.prototype.createId = function( cell )
Specifies if the model should automatically create Ids for new cells.
mxGraphModel.prototype.createIds
Creates and returns an image (IMG node) or VML image (v:image) in IE6 in quirks mode.
createImage: function( src )
Creates the indicator shape for the given cell state.
mxCellRenderer.prototype.createIndicatorShape = function( state )
Creates all edges in the internal model
mxGraphHierarchyModel.prototype.createInternalCells = function( layout, vertices, internalVertices )
Creates all edges in the internal model
mxSwimlaneModel.prototype.createInternalCells = function( layout, vertices, internalVertices )
Creates the label for the given cell state.
mxCellRenderer.prototype.createLabel = function( state, value )
Creates the shape used to display the the label handle.
mxEdgeHandler.prototype.createLabelHandleShape = function()
Creates a layout manager for the swimlane and diagram layouts, that is, the locally defined inter- and intraswimlane layouts.
mxEditor.prototype.createLayoutManager = ( graph ) =>
mxCompactTreeLayout.prototype.createLine = function( dx, dy, next )
Creates and returns the mxCellMarker used in marker.
mxConnectionHandler.prototype.createMarker = function()
Prepares the marker by adding offsets in pts and returning a function to paint the marker.
mxConnector.prototype.createMarker = function( c, pts, source )
Creates and returns the mxCellMarker used in marker.
mxEdgeHandler.prototype.createMarker = function()
Returns a function to paint the given marker.
createMarker: function( canvas, shape, type, pe, unitX, unitY, size, source, sw, filled )
This function is called from mxEditor to add items to the given menu based on config.
mxDefaultPopupMenu.prototype.createMenu = function( editor, menu, cell, evt )
Returns a new, empty Microsoft.XMLDOM document using ActiveXObject.
createMsXmlDocument: function()
mxCompactTreeLayout.prototype.createNode = function( cell )
Creates the page selector table.
mxPrintPreview.prototype.createPageSelector = function( vpages, hpages )
Creates and returns a new mxPanningHandler to be used in this graph.
mxGraph.prototype.createPanningHandler = function()
Creates and returns an mxPanningManager.
mxGraph.prototype.createPanningManager = function()
Creates the shape used to draw the selection border.
mxEdgeHandler.prototype.createParentHighlightShape = function( bounds )
Creates the shape used to draw the selection border.
mxVertexHandler.prototype.createParentHighlightShape = function( bounds )
Uses popupHandler to create the menu in the graph’s panning handler.
mxEditor.prototype.createPopupMenu = ( menu, cell, evt ) =>
Creates and returns a new mxPopupMenuHandler to be used in this graph.
mxGraph.prototype.createPopupMenuHandler = function()
Creates and returns an element which can be used as a preview in the given graph.
mxDragSource.prototype.createPreviewElement = function( graph )
Creates the shape used to draw the preview for the given bounds.
mxGraphHandler.prototype.createPreviewShape = function( bounds )
Creates and returns the DOM node that represents the contents of the properties dialog for the given cell.
mxEditor.prototype.createProperties = ( cell ) =>
Sets the glass gradient.
mxVmlCanvas2D.prototype.createRect = function( nodeName, x, y, w, h )
Creates a new root cell with a default layer (child 0).
mxGraphModel.prototype.createRoot = function()
Creates and returns a new mxTooltipHandler to be used in this graph.
mxGraph.prototype.createSelectionCellsHandler = function()
Creates a new mxGraphSelectionModel to be used in this graph.
mxGraph.prototype.createSelectionModel = function()
Creates the shape used to draw the selection border.
mxEdgeHandler.prototype.createSelectionShape = function( points )
Creates the shape used to draw the selection border.
mxVertexHandler.prototype.createSelectionShape = function( bounds )
Creates a shadow for the given node.
mxSvgCanvas2D.prototype.createShadow = function( node )
Creates a shadow for the given node.
mxVmlCanvas2D.prototype.createShadow = function( node, filled, stroked )
Creates the fill for the shadow.
mxVmlCanvas2D.prototype.createShadowFill = function()
Creates the stroke for the shadow.
mxVmlCanvas2D.prototype.createShadowStroke = function()
Creates and returns the highlight shape for the given state.
mxCellHighlight.prototype.createShape = function()
Creates and returns the shape for the given cell state.
mxCellRenderer.prototype.createShape = function( state )
Creates the preview shape for new connections.
mxConnectionHandler.prototype.createShape = function()
Creates and returns the shape for this handle.
mxHandle.prototype.createShape = function( html )
Creates the rubberband selection shape.
mxRubberband.prototype.createShape = function()
Creates the shape used as the sizer.
mxOutline.prototype.createSizer = function()
Creates a sizer handle for the specified cursor and index and returns the new mxRectangleShape that represents the handle.
mxVertexHandler.prototype.createSizer = function( cursor, index, size, fillColor )
Creates the shape used for the sizer handle for the specified bounds an index.
mxVertexHandler.prototype.createSizerShape = function( bounds, index, fillColor )
Creates the state of the this canvas.
mxAbstractCanvas2D.prototype.createState = function()
Creates and returns an mxCellState for the given cell and initializes it using mxCellRenderer.initialize.
mxGraphView.prototype.createState = function( cell )
Creates a fill for the current state.
mxVmlCanvas2D.prototype.createStroke = function()
Creates the optional style section.
mxSvgCanvas2D.prototype.createStyle = function( x )
Creates a new mxGraphSelectionModel to be used in this graph.
mxGraph.prototype.createStylesheet = function()
Creates the nodes required to add submenu items inside the given parent item.
mxPopupMenu.prototype.createSubmenu = function( parent )
Creates and returns the DOM nodes for the SVG display.
mxGraphView.prototype.createSvg = function()
Creates and returns the SVG node(s) to represent this shape.
mxShape.prototype.createSvg = function()
Creates and returns an mxSvgCanvas2D for rendering this shape.
mxShape.prototype.createSvgCanvas = function()
Creates the given SVG gradient.
mxSvgCanvas2D.prototype.createSvgGradient = function( start, end, alpha1, alpha2, direction )
Creates the layout instance used to layout the children of each swimlane.
mxEditor.prototype.createSwimlaneLayout = () =>
Sets the graph’s container using mxGraph.init.
mxEditor.prototype.createSwimlaneManager = ( graph ) =>
Specifies if createTargetVertex should be called if no target was under the mouse for the new connection.
mxConnectionHandler.prototype.createTarget
Hook method for creating new vertices on the fly if no target was under the mouse.
mxConnectionHandler.prototype.createTargetVertex = function( evt, source )
Updates the contents of the given DOM node to display the tasks associated with the current editor state.
mxEditor.prototype.createTasks = ( div ) =>
Creates a hit detection tolerance shape for the given node.
mxSvgCanvas2D.prototype.createTolerance = function( node )
Creates the toolbar with no container.
mxEditor.prototype.createToolbar = () =>
Creates and returns a new mxTooltipHandler to be used in this graph.
mxGraph.prototype.createTooltipHandler = function()
Creates a transparent fill.
mxVmlCanvas2D.prototype.createTransparentFill = function()
Adds a transparent rectangle that catches all events.
mxShape.prototype.createTransparentSvgRectangle = function( x, y, w, h )
Creates a new mxUndoableEdit that implements the notify function to fire a change and notify event through the mxUndoableEdit’s source.
mxGraphModel.prototype.createUndoableEdit = function( significant )
Create a new mxUrlConverter and returns it.
mxAbstractCanvas2D.prototype.createUrlConverter = function()
Hook method that creates the new vertex for insertVertex.
mxGraph.prototype.createVertex = function( parent, id, value, x, y, width, height, style, relative )
Hooks to create a new mxVertexHandler for the given mxCellState.
mxGraph.prototype.createVertexHandler = function( state )
Creates a virtual bend that supports double clicking and calls mxGraph.flipEdge.
mxElbowEdgeHandler.prototype.createVirtualBend = function( dblClickHandler )
Creates and returns the bends used for modifying the edge.
mxEdgeHandler.prototype.createVirtualBends = function()
Creates the DOM nodes for the VML display.
mxGraphView.prototype.createVml = function()
Creates and returns the VML node to represent this shape.
mxShape.prototype.createVml = function()
Creates and returns an mxVmlCanvas2D for rendering this shape.
mxShape.prototype.createVmlCanvas = function()
Creates a new element using createElement and prefixes the given name with mxClient.VML_PREFIX.
mxVmlCanvas2D.prototype.createVmlElement = function( name )
Returns the temporary element used for rendering in IE8 standards mode.
mxShape.prototype.createVmlGroup = function()
Creates a drawing pane in VML (group).
mxGraphView.prototype.createVmlPane = function( width, height )
Returns a new, empty XML document.
createXmlDocument: function()
Executes the crossing stage using mxMedianHybridCrossingReduction.
mxHierarchicalLayout.prototype.crossingStage = function( parent )
Executes the crossing stage using mxMedianHybridCrossingReduction.
mxSwimlaneLayout.prototype.crossingStage = function( parent )
The total number of crossings found in the best configuration so far
mxMedianHybridCrossingReduction.prototype.currentBestCrossings
Holds the current marker color.
mxCellMarker.prototype.currentColor
Holds the current drop target under the mouse.
mxDragSource.prototype.currentDropTarget
Stores the x-coordinate of the current mouse move.
mxGraphHandler.prototype.currentDx
Stores the y-coordinate of the current mouse move.
mxGraphHandler.prototype.currentDy
Holds the changes for the current transaction.
mxGraphModel.prototype.currentEdit
Specifies the resource key for the current file info.
mxEditor.prototype.currentFileResource
Reference to the mxGraph that is the current drop target.
mxDragSource.prototype.currentGraph
Holds an mxGuide for the currentGraph if dragPreview is not null.
mxDragSource.prototype.currentGuide
Holds the current drop location.
mxDragSource.prototype.currentPoint
mxCell that acts as the root of the displayed cell hierarchy.
mxGraphView.prototype.currentRoot
Holds the value of the x argument in the last call to update.
mxRubberband.prototype.currentX
The sum of x-displacements for the current iteration
mxCoordinateAssignment.prototype.currentXDelta
Holds the value of the y argument in the last call to update.
mxRubberband.prototype.currentY
Holds the cursor for the overlay.
mxCellOverlay.prototype.cursor
Specifies the cursor to be used while the handler is active.
mxConnectionHandler.prototype.cursor
Specifies the cursor to be used for this handle.
mxHandle.prototype.cursor
Defines the cursor for a movable bend.
CURSOR_BEND_HANDLE: 'crosshair'
Defines the cursor for a connectable state.
CURSOR_CONNECT: 'pointer'
Defines the cursor for a movable label.
CURSOR_LABEL_HANDLE: 'default'
Defines the cursor for a movable edge.
CURSOR_MOVABLE_EDGE: 'move'
Defines the cursor for a movable vertex.
CURSOR_MOVABLE_VERTEX: 'move'
Defines the cursor for a terminal handle.
CURSOR_TERMINAL_HANDLE: 'pointer'
Defines the cursor for a movable bend.
CURSOR_VIRTUAL_BEND_HANDLE: 'crosshair'
Contains the string used for bezier curves.
mxAbstractCanvas2D.prototype.curveOp
Contains the string used for bezier curves.
mxVmlCanvas2D.prototype.curveOp
Adds a bezier curve to the current path.
mxAbstractCanvas2D.prototype.curveTo = function( x1, y1, x2, y2, x3, y3 )
Adds a bezier curve to the current path.
mxXmlCanvas2D.prototype.curveTo = function( x1, y1, x2, y2, x3, y3 )
Start index for the custom handles in an mxMouseEvent.
CUSTOM_HANDLE: -100
Cuts the given array of mxCells from the specified graph.
cut: function( graph, cells )
Uses the returned value from consumeCycleAttribute as the value for the cycleAttributeName key in the given cell’s style.
mxEditor.prototype.cycleAttribute = ( cell ) =>
Index of the last consumed attribute index.
mxEditor.prototype.cycleAttributeIndex
Name of the attribute to be assigned a cycleAttributeValues when inserting new swimlanes.
mxEditor.prototype.cycleAttributeName
Specifies the attribute values to be cycled when inserting new swimlanes.
mxEditor.prototype.cycleAttributeValues
Executes the cycle stage using mxMinimumCycleRemover.
mxHierarchicalLayout.prototype.cycleStage = function( parent )
Executes the cycle stage using mxMinimumCycleRemover.
mxSwimlaneLayout.prototype.cycleStage = function( parent )