C | |
calcAttraction, mxFastOrganicLayout | |
calcPositions, mxFastOrganicLayout | |
calcRepulsion, mxFastOrganicLayout | |
calcRowDims, mxRadialTreeLayout | |
calculateCrossings, mxMedianHybridCrossingReduction | |
calculatedWeightedValue, mxCoordinateAssignment | |
calculateRankCrossing, mxMedianHybridCrossingReduction | |
calculateWidestRank, mxCoordinateAssignment | |
canExportCell, mxGraph | |
canImportCell, mxGraph | |
canRedo, mxUndoManager | |
canUndo, mxUndoManager | |
cascadeOpacity | |
cellAdded | |
cellCloned, mxGraphModel | |
cellConnected, mxGraph | |
cellLabelChanged, mxGraph | |
cellRemoved | |
cellResized, mxGraph | |
cellsAdded | |
cellsFolded, mxGraph | |
cellSizeUpdated, mxGraph | |
cellsMoved | |
cellsOrdered, mxGraph | |
cellsRemoved, mxGraph | |
cellsResized | |
cellsToggled, mxGraph | |
center, mxGraph | |
changePoints, mxEdgeHandler | |
changeSelection, mxGraphSelectionModel | |
changeTerminalPoint, mxEdgeHandler | |
check, mxMultiplicity | |
checkBounds | |
checkConstraints, mxConnectionHandler | |
checkLabelHandle, mxEdgeHandler | |
checkNeighbors, mxMultiplicity | |
checkPlaceholderStyles, mxCellRenderer | |
checkPreview, mxGraphHandler | |
checkTerminal, mxMultiplicity | |
checkTolerance, mxVertexHandler | |
checkType, mxMultiplicity | |
circle, mxCircleLayout | |
clear | |
clearCellOverlays, mxGraph | |
clearSelection | |
click, mxGraph | |
clone | |
cloneCell | |
cloneCellImpl, mxGraphModel | |
cloneCells | |
clonePreviewState, mxEdgeHandler | |
cloneTemplate, mxObjectCodec | |
cloneValue, mxCell | |
close | |
closeDocument, mxPrintPreview | |
collapsedStateForCellChanged, mxGraphModel | |
compare | |
computeAspect, mxStencil | |
configure, mxEditor | |
configureCanvas | |
configureShape, mxCellRenderer | |
confirm, mxUtils | |
connect | |
connectCell, mxGraph | |
constrainChild, mxGraph | |
constrainChildCells, mxGraph | |
consume | |
consumeCycleAttribute, mxEditor | |
consumeMouseEvent | |
consumePanningTrigger, mxPanningHandler | |
contains | |
convert, mxUrlConverter | |
convertAttributeFromXml, mxObjectCodec | |
convertAttributeToXml, mxObjectCodec | |
convertHtml, mxSvgCanvas2D | |
convertPoint | |
convertValueToString, mxGraph | |
convertWaypoint, mxConnectionHandler | |
copy, mxClipboard | |
copyStyle, mxHandle | |
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 | |
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 | |
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 | |
curveTo | |
cut, mxClipboard | |
cycleAttribute, mxEditor | |
cycleStage |
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()
Sets the opacity on the given cell and its descendants.
cascadeOpacity: function( graph, cell, opacity )
See mxEffects.cascadeOpacity.
cascadeOpacity: function( graph, cell, opacity )
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 )
Sets the new label for a cell.
mxGraph.prototype.cellLabelChanged = function( cell, value, autoSize )
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 )
Resizes the parents recursively so that they contain the complete area of the resized child cell.
mxGraph.prototype.cellResized = function( cell, bounds, ignoreRelative, recurse )
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 )
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 )
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 )
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 )
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 )
Changes the control points of the given edge in the graph model.
mxEdgeHandler.prototype.changePoints = function( edge, points, clone )
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 )
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 )
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 )
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 )
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()
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()
Processes a singleclick on an optional cell and fires a click event.
mxGraph.prototype.click = function( me )
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 )
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()
Writes the closing tags for body and page after calling writePostfix.
mxPrintPreview.prototype.closeDocument = function()
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 )
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 )
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 )
Configures the editor using the specified node.
mxEditor.prototype.configure = function ( 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 )
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 )
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 )
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 = function ( cell )
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 )
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 )
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 )
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 )
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 = function ()
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 = function ( 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 = function ()
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 = function ()
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 )
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 = function ( 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 = function ( 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 = function ( 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 = function ()
Sets the graph’s container using mxGraph.init.
mxEditor.prototype.createSwimlaneManager = function ( graph )
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 = function ( 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 = function ()
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 )
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 )
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 = function ( cell )
Executes the cycle stage using mxMinimumCycleRemover.
mxHierarchicalLayout.prototype.cycleStage = function( parent )
Executes the cycle stage using mxMinimumCycleRemover.
mxSwimlaneLayout.prototype.cycleStage = function( parent )