| C | |
| calcAttraction, mxFastOrganicLayout | |
| calcPositions, mxFastOrganicLayout | |
| calcRepulsion, mxFastOrganicLayout | |
| 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 | |
| cellsAdded | |
| cellsFolded, mxGraph | |
| cellSizeUpdated, mxGraph | |
| cellsMoved | |
| cellsOrdered, mxGraph | |
| cellsRemoved, mxGraph | |
| cellsResized | |
| cellsToggled, mxGraph | |
| changePoints | |
| changeSelection, mxGraphSelectionModel | |
| changeTerminalPoint, mxEdgeHandler | |
| check, mxMultiplicity | |
| checkBounds | |
| checkNeighbors, mxMultiplicity | |
| checkTerminal, mxMultiplicity | |
| checkTolerance, mxVertexHandler | |
| checkType, mxMultiplicity | |
| childMoved, mxGraphView | |
| circle, mxCircleLayout | |
| clear | |
| clearCellOverlays, mxGraph | |
| clearSelection | |
| click, mxGraph | |
| clone | |
| cloneCell, mxGraphModel | |
| cloneCellImpl, mxGraphModel | |
| cloneCells | |
| clonePreviewState, mxEdgeHandler | |
| cloneTemplate, mxObjectCodec | |
| cloneValue, mxCell | |
| close | |
| collapsedStateForCellChanged, mxGraphModel | |
| compare | |
| computeAspect, mxStencil | |
| configure, mxEditor | |
| configureCanvas | |
| configureShape, mxCellRenderer | |
| confirm, mxUtils | |
| connect | |
| connectCell, mxGraph | |
| constrainChild, mxGraph | |
| constrainChildCells, mxGraph | |
| consume | |
| consumeCycleAttribute, mxEditor | |
| consumePanningTrigger, mxPanningHandler | |
| contains | |
| convert, mxUrlConverter | |
| convertPoint | |
| convertValueFromXml, mxObjectCodec | |
| convertValueToString, mxGraph | |
| convertValueToXml, mxObjectCodec | |
| convertWaypoint, mxConnectionHandler | |
| copy | |
| create | |
| createBackgroundPageShape, mxGraphView | |
| createBends | |
| createBoundingBox, mxShape | |
| createBounds, mxVertexHandler | |
| createCanvas, mxShape | |
| createCellEditor, mxGraph | |
| createCellOverlays, mxCellRenderer | |
| createCellRenderer, mxGraph | |
| createClip, mxSvgCanvas2D | |
| createConditions, mxDefaultPopupMenu | |
| createControl, mxCellRenderer | |
| createDashPattern, mxSvgCanvas2D | |
| createDefaultEdgeStyle, mxStylesheet | |
| createDefaultVertexStyle, mxStylesheet | |
| createDiagramLayout, mxEditor | |
| createDiv, mxSvgCanvas2D | |
| createDragElement, mxDragSource | |
| createEdge | |
| createEdgeState, mxConnectionHandler | |
| createElement | |
| createFill, mxVmlCanvas2D | |
| createGradientId, mxSvgCanvas2D | |
| createGraph, mxEditor | |
| createGraphView, mxGraph | |
| createGroup, mxEditor | |
| createGroupCell, mxGraph | |
| createGuideShape, mxGuide | |
| createHandler, mxGraph | |
| createHandlers, mxGraph | |
| createHandleShape, mxEdgeHandler | |
| createHtml | |
| createHtmlPane, mxGraphView | |
| createIcons, mxConnectionHandler | |
| createId, mxGraphModel | |
| createImage, mxUtils | |
| createIndicatorShape, mxCellRenderer | |
| createInternalCells | |
| createLabel, mxCellRenderer | |
| createLayoutManager, mxEditor | |
| createLine, mxCompactTreeLayout | |
| createMarker | |
| createMenu, mxDefaultPopupMenu | |
| createNode, mxCompactTreeLayout | |
| createPageSelector, mxPrintPreview | |
| createPanningManager, mxGraph | |
| createPopupMenu, mxEditor | |
| createPreviewElement, mxDragSource | |
| createPreviewShape, mxGraphHandler | |
| createProperties, mxEditor | |
| createRect, mxVmlCanvas2D | |
| createRoot, mxGraphModel | |
| createSelectionModel, mxGraph | |
| createSelectionShape | |
| createSession, mxEditor | |
| createShadow | |
| createShadowFill, mxVmlCanvas2D | |
| createShadowStroke, mxVmlCanvas2D | |
| createShape | |
| createSizer | |
| createSizerShape, mxVertexHandler | |
| createState | |
| createStroke, mxVmlCanvas2D | |
| createStyle, mxSvgCanvas2D | |
| createStylesheet, mxGraph | |
| createSubmenu, mxPopupMenu | |
| createSvg, mxShape | |
| createSvgCanvas, mxShape | |
| createSvgGradient, mxSvgCanvas2D | |
| createSwimlaneLayout, mxEditor | |
| createSwimlaneManager, mxEditor | |
| createTargetVertex, mxConnectionHandler | |
| createTasks, mxEditor | |
| createText, mxVmlCanvas2D | |
| createTextDiv, mxCellEditor | |
| createTolerance, mxSvgCanvas2D | |
| createToolbar, mxEditor | |
| createTransparentFill, mxVmlCanvas2D | |
| createUndoableEdit | |
| createUrlConverter, mxAbstractCanvas2D | |
| createVertex, mxGraph | |
| createVirtualBend, mxElbowEdgeHandler | |
| createVml, mxShape | |
| createVmlCanvas, mxShape | |
| 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()
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 )
Adds removed cells to the codec object lookup for references to the removed cells after this point in time.
mxSession.prototype.cellRemoved = function( cell, codec )
Resizes the parents recursively so that they contain the complete area of the resized child cell.
mxGraph.prototype.cellResized = function( cell, bounds, ignoreRelative, recurse )
Called from moveCellsIntoParent to invoke the move hook in the automatic layout of each modified cell’s parent.
mxSpaceManager.prototype.cellResized = function( cell )
Adds the specified cells to the given parent.
mxGraph.prototype.cellsAdded = function( cells, parent, index, source, target, absolute, constrain )
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 the 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 moveCellsIntoParent to invoke the move hook in the automatic layout of each modified cell’s parent.
mxSpaceManager.prototype.cellsResized = function( cells )
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 )
Changes the points of the given edge to reflect the current state of the handler.
mxEdgeSegmentHandler.prototype.changePoints = function( edge, points )
Changes the control points of the given edge in the graph model.
mxEdgeHandler.prototype.changePoints = function( edge, points )
Inner callback to add the specified mxCell to the selection.
mxGraphSelectionModel.prototype.changeSelection = function( added, removed )
Changes the terminal point of the given edge.
mxEdgeHandler.prototype.changeTerminalPoint = function( edge, point, isSource )
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()
Checks if there are any valid neighbours in validNeighbors.
mxMultiplicity.prototype.checkNeighbors = function( graph, edge, source, target )
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 )
Invoked when a child state was moved as a result of late evaluation of its position.
mxGraphView.prototype.childMoved = function( parent, child )
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 )
Removes the object id from the given object.
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 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 a deep clone of the given mxCell (including the children) which is created using cloneCells.
mxGraphModel.prototype.cloneCell = function( cell )
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 )
Returns an array of clones for the given array of mxCells.
mxGraphModel.prototype.cloneCells = function( cells, includeChildren )
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()
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 )
Creates and returns a session for the specified parameters, installing the onChange function as a change listener for the session.
mxEditor.prototype.connect = function ( urlInit, urlPoll, urlNotify, onChange )
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 )
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 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.
convert: function( url )
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 )
Converts booleans and numeric values to the respective types.
mxObjectCodec.prototype.convertValueFromXml = function( value )
Returns the textual representation for the given cell.
mxGraph.prototype.convertValueToString = function( cell )
Converts true to “1” and false to “0”.
mxObjectCodec.prototype.convertValueToXml = function( value )
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.Returns the original array of cells that has been cloned.
copy: function( graph, cells )
Copies the specified content to the local clipboard.
copy: function( content )
Creates the cell path for the given cell.
create: function( cell )
Creates the DOM nodes for the HTML display.
mxGraphView.prototype.createHtml = function()
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()
Destroys the given canvas which was used for drawing.
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 the control for the given cell state.
mxCellRenderer.prototype.createControl = function( state )
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, align, valign, style, overflow )
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 )
Hook to return an mxCellState which may be used during the preview.
mxConnectionHandler.prototype.createEdgeState = function( me )
Private helper function to create SVG elements
mxSvgCanvas2D.prototype.createElement = function( tagName, namespace )
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()
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 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( container )
Creates the shape used to display the given bend.
mxEdgeHandler.prototype.createHandleShape = function( index )
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 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 )
mxCompactTreeLayout.prototype.createNode = function( cell )
Creates the page selector table.
mxPrintPreview.prototype.createPageSelector = function( vpages, hpages )
Creates and returns an mxPanningManager.
mxGraph.prototype.createPanningManager = function()
Uses popupHandler to create the menu in the graph’s panning handler.
mxEditor.prototype.createPopupMenu = function ( menu, cell, evt )
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 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 and returns and mxSession using urlInit, urlPoll and urlNotify.
mxEditor.prototype.createSession = function ()
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 the shape for the given cell state.
mxCellRenderer.prototype.createShape = function( state )
Creates the preview shape for new connections.
mxConnectionHandler.prototype.createShape = function()
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 and 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 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 the textDiv used for measuring text.
mxCellEditor.prototype.createTextDiv = function()
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 a transparent fill.
mxVmlCanvas2D.prototype.createTransparentFill = function()
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()
Creates a new mxUndoableEdit that implements the notify function to fire a change and notify event via the model.
mxSession.prototype.createUndoableEdit = function( changes )
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 )
Creates a virtual bend that supports double clicking and calls mxGraph.flipEdge.
mxElbowEdgeHandler.prototype.createVirtualBend = 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()
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 )