| 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, mxSpaceManager | |
| cellsAdded | |
| cellsFolded, mxGraph | |
| cellSizeUpdated, mxGraph | |
| cellsMoved | |
| cellsOrdered, mxGraph | |
| cellsRemoved, mxGraph | |
| cellsResized | |
| cellsToggled, mxGraph | |
| changePoints | |
| changeSelection, mxGraphSelectionModel | |
| changeTerminalPoint | |
| check, mxMultiplicity | |
| checkNeighbors, mxMultiplicity | |
| checkTerminal, mxMultiplicity | |
| checkType, mxMultiplicity | |
| childMoved, mxGraphView | |
| circle, mxCircleLayout | |
| clear | |
| clearCellOverlays, mxGraph | |
| clearSelection | |
| click, mxGraph | |
| clip | |
| clone | |
| cloneCell, mxGraphModel | |
| cloneCellImpl, mxGraphModel | |
| cloneCells | |
| clonePreviewState, mxEdgeHandler | |
| cloneTemplate, mxObjectCodec | |
| cloneValue, mxCell | |
| close | |
| collapsedStateForCellChanged, mxGraphModel | |
| compare | |
| computeAspect, mxStencil | |
| configure, mxEditor | |
| configureHtmlShape | |
| configureShape, mxCellRenderer | |
| configureSvgShape | |
| configureTransparentBackground | |
| configureVmlShape | |
| confirm, mxUtils | |
| connect | |
| connectCell, mxGraph | |
| constrainChild, 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 | |
| createCellEditor, mxGraph | |
| createCellOverlays, mxCellRenderer | |
| createCellRenderer, mxGraph | |
| createConditions, mxDefaultPopupMenu | |
| createControl, mxCellRenderer | |
| createDashPattern, mxConnector | |
| createDefaultEdgeStyle, mxStylesheet | |
| createDefaultVertexStyle, mxStylesheet | |
| createDiagramLayout, mxEditor | |
| createDragElement, mxDragSource | |
| createEdge | |
| createEdgeState, mxConnectionHandler | |
| createForeignObject, mxText | |
| createGraph, mxEditor | |
| createGraphView, mxGraph | |
| createGroup, mxEditor | |
| createGroupCell, mxGraph | |
| createGuideShape, mxGuide | |
| createHandler, mxGraph | |
| createHandlers, mxGraph | |
| createHandleShape, mxEdgeHandler | |
| createHtml | |
| createHtmlPane, mxGraphView | |
| createHtmlTable, mxText | |
| createIcons, mxConnectionHandler | |
| createId, mxGraphModel | |
| createImage, mxUtils | |
| createInternalCells, mxGraphHierarchyModel | |
| createLabel, mxCellRenderer | |
| createLayoutManager, mxEditor | |
| createLine, mxCompactTreeLayout | |
| createMarker | |
| createMenu, mxDefaultPopupMenu | |
| createNode, mxCompactTreeLayout | |
| createPageSelector, mxPrintPreview | |
| createPanningManager, mxGraph | |
| createPath, mxShape | |
| createPoints, mxShape | |
| createPopupMenu, mxEditor | |
| createPreviewElement, mxDragSource | |
| createPreviewShape, mxGraphHandler | |
| createProperties, mxEditor | |
| createRoot, mxGraphModel | |
| createSelectionModel, mxGraph | |
| createSelectionShape | |
| createSession, mxEditor | |
| createShape | |
| createSizer | |
| createSizerShape, mxVertexHandler | |
| createState, mxGraphView | |
| createStylesheet, mxGraph | |
| createSubmenu, mxPopupMenu | |
| createSvg | |
| createSvgGradient, mxShape | |
| createSvgGroup, mxShape | |
| createSvgPipe, mxShape | |
| createSvgShadow, mxShape | |
| createSvgSpan | |
| createSwimlaneLayout, mxEditor | |
| createSwimlaneManager, mxEditor | |
| createTargetVertex, mxConnectionHandler | |
| createTasks, mxEditor | |
| createToolbar, mxEditor | |
| createUndoableEdit | |
| createVertex, mxGraph | |
| createVirtualBend, mxElbowEdgeHandler | |
| createVml | |
| createVmlImage, mxLabel | |
| createVmlPane, mxGraphView | |
| createVmlShadow, mxShape | |
| createXmlDocument, mxUtils | |
| crossingStage, mxHierarchicalLayout | |
| curveTo | |
| cut, mxClipboard | |
| cycleAttribute, mxEditor | |
| cycleStage, mxHierarchicalLayout |
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 )
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 )
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 )
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 )
Calls refresh after mxEdgeHandler.changeTerminalPoint.
mxEdgeSegmentHandler.prototype.changeTerminalPoint = function( edge, point, isSource )
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 )
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 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 )
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 )
Uses the current path for clipping.
clip: function()
Uses the current path for clipping.
clip: function()
Returns a clone of the cell.
mxCell.prototype.clone = function()
Returns a clone of this mxPoint.
mxCellState.prototype.clone = function()
Overrides the clone method to add special fields.
mxLine.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 path.
mxPath.prototype.close = function()
Closes the print preview window.
mxPrintPreview.prototype.close = function()
Closes the current path.
close: function()
Closes the current path.
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( state, bounds, direction )
Configures the editor using the specified node.
mxEditor.prototype.configure = function ( node )
Overrides mxShape.configureHtmlShape to clear the border and background.
mxConnector.prototype.configureHtmlShape = function( node )
Configures the specified HTML node by applying the current color, bounds, shadow, opacity etc.
mxShape.prototype.configureHtmlShape = function( node )
Overrides method to set the overflow style to visible.
mxStencilShape.prototype.configureHtmlShape = function( node )
Configures the shape for the given cell state.
mxCellRenderer.prototype.configureShape = function( state )
Extends method to set opacity on images.
mxImageShape.prototype.configureSvgShape = function( node )
Configures the specified SVG node by applying the current color, bounds, shadow, opacity etc.
mxShape.prototype.configureSvgShape = function( node )
Overidden to remove transparent background.
mxArrow.prototype.configureTransparentBackground = function( node )
Workaround for security warning in IE if this is used in the overlay pane of a diagram.
mxImageShape.prototype.configureTransparentBackground = function( node )
Hook to make the background of a shape transparent.
mxShape.prototype.configureTransparentBackground = function( node )
Configures the specified VML node by applying the current color, bounds, shadow, opacity etc.
mxShape.prototype.configureVmlShape = function( node )
Configures the specified VML node by applying the current color, bounds, shadow, opacity etc.
mxStencilShape.prototype.configureVmlShape = function( node )
Displays the given message in a confirm dialog.
confirm: function( message )
Calls refresh after mxEdgeHandler.connect.
mxEdgeSegmentHandler.prototype.connect = function( edge, terminal, isSource, isClone, me )
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 )
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.
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 )
Overrides the method to make sure the stroke is never null.
mxCylinder.prototype.create = function( container )
Creates the DOM nodes for the HTML display.
mxGraphView.prototype.createHtml = function()
Override to create HTML regardless of gradient and rounded property.
mxImageShape.prototype.create = function()
Override to create HTML regardless of gradient and rounded property.
mxPolyline.prototype.create = function()
Creates and returns the DOM node(s) for the shape in the given container.
mxShape.prototype.create = function( container )
Override to create HTML regardless of gradient and rounded property.
mxText.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 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()
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 a dash pattern for the given factor.
mxConnector.prototype.createDashPattern = function( factor )
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 ()
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 )
Creates and returns the foreignObject node to represent this shape.
mxText.prototype.createForeignObject = function()
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 node to represent this shape.
mxLabel.prototype.createHtml = function()
Creates and returns the HTML node to represent this shape.
mxRectangleShape.prototype.createHtml = function()
Creates and returns the HTML node to represent this shape.
mxRhombus.prototype.createHtml = function()
Creates and returns the HTML DOM node(s) to represent this shape.
mxShape.prototype.createHtml = function()
Creates and returns the HTML node to represent this shape.
mxSwimlane.prototype.createHtml = function()
Creates and returns the HTML node to represent this shape.
mxText.prototype.createHtml = function()
Creates and returns a drawing pane in HTML (DIV).
mxGraphView.prototype.createHtmlPane = function( width, height )
Creates and returns a HTML table with a table body and a single row with a single cell.
mxText.prototype.createHtmlTable = function()
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 quirs mode.
createImage: function( src )
Creates all edges in the internal model
mxGraphHierarchyModel.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()
Creates and returns the mxCellMarker used in marker.
mxEdgeHandler.prototype.createMarker = function()
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()
Creates an mxPath for the specified format and origin.
mxShape.prototype.createPath = function( arg )
Creates a path expression using the specified commands for this.points.
mxShape.prototype.createPoints = function( moveCmd, lineCmd, curveCmd, isRelative )
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 )
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 the built-in session using urlInit, urlPoll and urlNotify.
mxEditor.prototype.createSession = function ()
Creates and returns the highlight shape for the given state.
mxCellHighlight.prototype.createShape = function( state )
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 a shape wrapper for the custom shape in the given cell state and links its output to the given canvas.
mxImageExport.prototype.createShape = function( state, canvas )
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 and returns an mxCellState for the given cell and initializes it using mxCellRenderer.initialize.
mxGraphView.prototype.createState = function( cell )
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.
mxActor.prototype.createSvg = function()
Extends mxActor.createSvg to ignore fill if enableFill is false and create an event handling shape if this.addPipe is true.
mxArrow.prototype.createSvg = function()
Creates and returns the SVG node to represent this shape.
mxConnector.prototype.createSvg = function()
Creates and returns the SVG node(s) to represent this shape.
mxCylinder.prototype.createSvg = function()
Creates and returns the SVG node(s) to represent this shape.
mxDoubleEllipse.prototype.createSvg = function()
Creates and returns the SVG node(s) to represent this shape.
mxEllipse.prototype.createSvg = function()
Creates and returns the SVG node to represent this shape.
mxLabel.prototype.createSvg = function()
Creates and returns the SVG node(s) to represent this shape.
mxLine.prototype.createSvg = function()
Creates and returns the SVG node(s) to represent this shape.
mxPolyline.prototype.createSvg = function()
Creates and returns the SVG node to represent this shape.
mxRectangleShape.prototype.createSvg = function()
Creates and returns the SVG node(s) to represent this shape.
mxRhombus.prototype.createSvg = function()
Creates and returns the SVG node(s) to represent this shape.
mxStencilShape.prototype.createSvg = function()
Creates and returns the SVG node(s) to represent this shape.
mxSwimlane.prototype.createSvg = function()
Creates and returns the SVG node(s) to represent this shape.
mxText.prototype.createSvg = function()
Creates a gradient object for SVG using the specified startcolor, endcolor and opacity.
mxShape.prototype.createSvgGradient = function( id, start, end, node )
Creates a SVG group element and adds the given shape as a child of the element.
mxShape.prototype.createSvgGroup = function( shape )
Creates an invisible path which is used to increase the hit detection for edges in SVG.
mxShape.prototype.createSvgPipe = function( id, start, end, node )
Creates a clone of the given node and configures the node’s color to use mxConstants.SHADOWCOLOR.
mxShape.prototype.createSvgShadow = function( node )
Creats an SVG tspan node for the given text.
mxText.prototype.createSvgSpan = function( text )
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 toolbar with no container.
mxEditor.prototype.createToolbar = 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 )
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(s) to represent this shape.
mxActor.prototype.createVml = function()
Extends mxShape.createVml to ignore fill if enableFill is false.
mxArrow.prototype.createVml = function()
Creates and returns the VML node to represent this shape.
mxConnector.prototype.createVml = function()
Creates and returns the VML node to represent this shape.
mxCylinder.prototype.createVml = function()
Creates and returns the VML node to represent this shape.
mxDoubleEllipse.prototype.createVml = function()
Creates and returns the VML node to represent this shape.
mxEllipse.prototype.createVml = function()
Creates and returns the VML node to represent this shape.
mxLabel.prototype.createVml = function()
Creates and returns the VML node to represent this shape.
mxLine.prototype.createVml = function()
Creates and returns the VML node to represent this shape.
mxRectangleShape.prototype.createVml = function()
Creates and returns the VML node(s) to represent this shape.
mxRhombus.prototype.createVml = function()
Creates and returns the VML node to represent this shape.
mxStencilShape.prototype.createVml = function()
Creates and returns the VML node(s) to represent this shape.
mxSwimlane.prototype.createVml = function()
Creates and returns the VML node(s) to represent this shape.
mxText.prototype.createVml = function()
Creates an image node for the given image src and opacity to be used in VML.
mxLabel.prototype.createVmlImage = function( src, opacity )
Creates a drawing pane in VML (group).
mxGraphView.prototype.createVmlPane = function( width, height )
Creates the VML shadow node.
mxShape.prototype.createVmlShadow = function( node )
Returns a new, empty XML document.
createXmlDocument: function()
Executes the crossing stage using mxMedianHybridCrossingReduction.
mxHierarchicalLayout.prototype.crossingStage = function( parent )
Draws a cubic Bézier curve from the current point to (x, y) using (x1, y1) as the control point at the beginning of the curve and (x2, y2) as the control point at the end of the curve.
mxPath.prototype.curveTo = function( x1, y1, x2, y2, x, y )
Adds a bezier curve to the current path.
curveTo: function( x1, y1, x2, y2, x3, y3 )
Adds a bezier curve to the current path.
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 )