mxFastOrganicLayout.prototype.calcAttraction = function()

mxFastOrganicLayout.prototype.calcPositions = function()

mxFastOrganicLayout.prototype.calcRepulsion = function()

mxRadialTreeLayout.prototype.calcRowDims = function( row, rowNum )

mxMedianHybridCrossingReduction.prototype.calculateCrossings = function( model )

mxCoordinateAssignment.prototype.calculatedWeightedValue = function(     currentCell,     collection )

mxMedianHybridCrossingReduction.prototype.calculateRankCrossing = function(     i,     model )

mxCoordinateAssignment.prototype.calculateWidestRank = function( graph, model )

mxGraph.prototype.canExportCell = function( cell )

mxGraph.prototype.canImportCell = function( cell )

mxUndoManager.prototype.canRedo = function()

mxUndoManager.prototype.canUndo = function()

cascadeOpacity: function( graph, cell, opacity )

cascadeOpacity: function( graph, cell, opacity )

mxGraphModel.prototype.cellAdded = function( cell )

mxGraphSelectionModel.prototype.cellAdded = function( cell )

mxGraphModel.prototype.cellCloned = function( cell )

mxGraph.prototype.cellConnected = function( edge, terminal, source, constraint )

mxGraph.prototype.cellLabelChanged = function( cell, value, autoSize )

mxGraphModel.prototype.cellRemoved = function( cell )

mxGraphSelectionModel.prototype.cellRemoved = function( cell )

mxGraph.prototype.cellResized = function( cell, bounds, ignoreRelative, recurse )

mxGraph.prototype.cellsAdded = function( cells, parent, index, source, target, absolute, constrain, extend )

mxSwimlaneManager.prototype.cellsAdded = function( cells )

mxGraph.prototype.cellsFolded = function( cells, collapse, recurse, checkFoldable )

mxGraph.prototype.cellSizeUpdated = function( cell, ignoreChildren )

mxGraph.prototype.cellsMoved = function( cells, dx, dy, disconnect, constrain, extend )

mxLayoutManager.prototype.cellsMoved = function( cells, evt )

mxGraph.prototype.cellsOrdered = function( cells, back )

mxGraph.prototype.cellsRemoved = function( cells )

mxGraph.prototype.cellsResized = function( cells, bounds, recurse )

mxLayoutManager.prototype.cellsResized = function( cells, bounds, prev )

mxSwimlaneManager.prototype.cellsResized = function( cells )

mxGraph.prototype.cellsToggled = function( cells, show )

mxGraph.prototype.center = function( horizontal, vertical, cx, cy )

mxEdgeHandler.prototype.changePoints = function( edge, points, clone )

mxGraphSelectionModel.prototype.changeSelection = function( added, removed )

mxEdgeHandler.prototype.changeTerminalPoint = function( edge, point, isSource, clone )

mxMultiplicity.prototype.check = function( graph, edge, source, target, sourceOut, targetIn )

mxShape.prototype.checkBounds = function()

mxText.prototype.checkBounds = function()

mxConnectionHandler.prototype.checkConstraints = function( c1, c2 )

mxEdgeHandler.prototype.checkLabelHandle = function( b )

mxMultiplicity.prototype.checkNeighbors = function( graph, edge, source, target )

mxCellRenderer.prototype.checkPlaceholderStyles = function( state )

mxGraphHandler.prototype.checkPreview = function()

mxMultiplicity.prototype.checkTerminal = function( graph, terminal, edge )

mxVertexHandler.prototype.checkTolerance = function( me )

mxMultiplicity.prototype.checkType = function( graph, value, type, attr, attrValue )

mxCircleLayout.prototype.circle = function( vertices, r, left, top )

mxDictionary.prototype.clear = function()

mxGraphModel.prototype.clear = function()

mxGraphSelectionModel.prototype.clear = function()

mxGraphView.prototype.clear = function( cell, force, recurse )

clear: function( obj )

mxShape.prototype.clear = function()

mxUndoManager.prototype.clear = function()

mxGraph.prototype.clearCellOverlays = function( cell )

mxCellEditor.prototype.clearSelection = function()

mxGraph.prototype.clearSelection = function()

clearSelection: function()

mxGraph.prototype.click = function( me )

mxCell.prototype.clone = function()

mxCellState.prototype.clone = function()

mxPoint.prototype.clone = function()

clone: function( obj, transients, shallow )

mxGraph.prototype.cloneCell = function( cell, allowInvalidEdges, mapping, keepPosition )

mxGraphModel.prototype.cloneCell = function( cell, includeChildren )

mxGraphModel.prototype.cloneCellImpl = function( cell, mapping, includeChildren )

mxGraph.prototype.cloneCells = function( cells, allowInvalidEdges, mapping, keepPosition )

mxGraphModel.prototype.cloneCells = function( cells, includeChildren, mapping )

mxEdgeHandler.prototype.clonePreviewState = function( point, terminal )

mxObjectCodec.prototype.cloneTemplate = function()

mxCell.prototype.cloneValue = function()

mxAbstractCanvas2D.prototype.close = function( x1, y1, x2, y2, x3, y3 )

mxPrintPreview.prototype.close = function()

mxXmlCanvas2D.prototype.close = function()

mxPrintPreview.prototype.closeDocument = function()

mxGraphModel.prototype.collapsedStateForCellChanged = function( cell, collapsed )

MedianCellSorter.prototype.compare = function( a, b )

compare: function( p1, p2 )

WeightedCellSorter.prototype.compare = function( a, b )

mxStencil.prototype.computeAspect = function( shape, x, y, w, h, direction )

mxEditor.prototype.configure = ( node ) =>

mxShape.prototype.configureCanvas = function( c, x, y, w, h )

mxText.prototype.configureCanvas = function( c, x, y, w, h )

mxCellRenderer.prototype.configureShape = function( state )

confirm: function( message )

mxConnectionHandler.prototype.connect = function( source, target, evt, dropTarget )

mxDefaultToolbar.prototype.connect = function( vertex, evt, source )

mxEdgeHandler.prototype.connect = function( edge, terminal, isSource, isClone, me )

mxGraph.prototype.connectCell = function( edge, terminal, source, constraint )

mxGraph.prototype.constrainChild = function( cell, sizeFirst )

mxGraph.prototype.constrainChildCells = function( cell )

consume: function( evt, preventDefault, stopPropagation )

mxEventObject.prototype.consume = function()

mxMouseEvent.prototype.consume = function( preventDefault )

mxEditor.prototype.consumeCycleAttribute = ( cell ) =>

mxGraph.prototype.consumeMouseEvent = function( evtName, me, sender )

mxGraphHandler.prototype.consumeMouseEvent = function( evtName, me )

mxPanningHandler.prototype.consumePanningTrigger = function( me )

mxGraphModel.prototype.contains = function( cell )

contains: function( bounds, x, y )

mxUrlConverter.prototype.convert = function( url )

mxObjectCodec.prototype.convertAttributeFromXml = function( dec, attr, obj )

mxObjectCodec.prototype.convertAttributeToXml = function( enc, obj, name, value )

mxSvgCanvas2D.prototype.convertHtml = function( val )

mxEdgeHandler.prototype.convertPoint = function( point, gridEnabled )

mxElbowEdgeHandler.prototype.convertPoint = function( point, gridEnabled )

convertPoint: function( container, x, y )

mxGraph.prototype.convertValueToString = function( cell )

mxConnectionHandler.prototype.convertWaypoint = function( point )

copy: function( graph, cells )

mxHandle.prototype.copyStyle = function( key )

create: function( cell )

mxShape.prototype.create = function( container )

mxXmlRequest.prototype.create = function()

mxGraphView.prototype.createBackgroundPageShape = function( bounds )

mxEdgeSegmentHandler.prototype.createBends = function()

mxEdgeHandler.prototype.createBends = function()

mxElbowEdgeHandler.prototype.createBends = function()

mxShape.prototype.createBoundingBox = function()

mxShape.prototype.createCanvas = function()

mxGraph.prototype.createCellEditor = function()

mxCellRenderer.prototype.createCellOverlays = function( state )

mxGraph.prototype.createCellRenderer = function()

mxSvgCanvas2D.prototype.createClip = function( x, y, w, h )

mxDefaultPopupMenu.prototype.createConditions = function( editor, cell, evt )

mxGraph.prototype.createConnectionHandler = function()

mxCellRenderer.prototype.createControl = function( state )

mxCellRenderer.prototype.createControlClickHandler = function( state )

mxEdgeHandler.prototype.createCustomHandles = function()

mxVertexHandler.prototype.createCustomHandles = function()

mxSvgCanvas2D.prototype.createDashPattern = function( scale )

mxStylesheet.prototype.createDefaultEdgeStyle = function()

mxStylesheet.prototype.createDefaultVertexStyle = function()

mxEditor.prototype.createDiagramLayout = () =>

mxSvgCanvas2D.prototype.createDiv = function( str )

mxDragSource.prototype.createDragElement = function( evt )

mxConnectionHandler.prototype.createEdge = function( value, source, target, style )

mxEditor.prototype.createEdge = ( source, target ) =>

mxGraph.prototype.createEdge = function( parent, id, value, source, target, style )

mxGraph.prototype.createEdgeHandler = function( state, edgeStyle )

mxGraph.prototype.createEdgeSegmentHandler = function( state )

mxConnectionHandler.prototype.createEdgeState = function( me )

mxGraph.prototype.createElbowEdgeHandler = function( state )

mxSvgCanvas2D.prototype.createElement = function( tagName, namespace )

mxVmlCanvas2D.prototype.createElement = function( name )

mxXmlCanvas2D.prototype.createElement = function( name )

mxVmlCanvas2D.prototype.createFill = function()

mxVertexHandler.prototype.createGhostPreview = function()

mxSvgCanvas2D.prototype.createGradientId = function( start, end, alpha1, alpha2, direction )

mxEditor.prototype.createGraph = () =>

mxOutline.prototype.createGraph = function( container )

mxGraph.prototype.createGraphHandler = function()

mxGraph.prototype.createGraphView = function()

mxEditor.prototype.createGroup = () =>

mxGraph.prototype.createGroupCell = function( cells )

mxGuide.prototype.createGuideShape = function( horizontal )

mxGraph.prototype.createHandler = function( state )

mxGraph.prototype.createHandlers = function()

mxEdgeHandler.prototype.createHandleShape = function( index )

mxConstraintHandler.prototype.createHighlightShape = function()

mxGraphView.prototype.createHtml = function()

mxImageShape.prototype.createHtml = function()

mxShape.prototype.createHtml = function()

mxGraphView.prototype.createHtmlPane = function( width, height )

mxConnectionHandler.prototype.createIcons = function( state )

mxGraphModel.prototype.createId = function( cell )

createImage: function( src )

mxCellRenderer.prototype.createIndicatorShape = function( state )

mxGraphHierarchyModel.prototype.createInternalCells = function( layout, vertices, internalVertices )

mxSwimlaneModel.prototype.createInternalCells = function( layout, vertices, internalVertices )

mxCellRenderer.prototype.createLabel = function( state, value )

mxEdgeHandler.prototype.createLabelHandleShape = function()

mxEditor.prototype.createLayoutManager = ( graph ) =>

mxCompactTreeLayout.prototype.createLine = function( dx, dy, next )

mxConnectionHandler.prototype.createMarker = function()

mxConnector.prototype.createMarker = function( c, pts, source )

mxEdgeHandler.prototype.createMarker = function()

createMarker: function( canvas, shape, type, pe, unitX, unitY, size, source, sw, filled )

mxDefaultPopupMenu.prototype.createMenu = function( editor, menu, cell, evt )

createMsXmlDocument: function()

mxCompactTreeLayout.prototype.createNode = function( cell )

mxPrintPreview.prototype.createPageSelector = function( vpages, hpages )

mxGraph.prototype.createPanningHandler = function()

mxGraph.prototype.createPanningManager = function()

mxEdgeHandler.prototype.createParentHighlightShape = function( bounds )

mxVertexHandler.prototype.createParentHighlightShape = function( bounds )

mxEditor.prototype.createPopupMenu = ( menu, cell, evt ) =>

mxGraph.prototype.createPopupMenuHandler = function()

mxDragSource.prototype.createPreviewElement = function( graph )

mxGraphHandler.prototype.createPreviewShape = function( bounds )

mxEditor.prototype.createProperties = ( cell ) =>

mxVmlCanvas2D.prototype.createRect = function( nodeName, x, y, w, h )

mxGraphModel.prototype.createRoot = function()

mxGraph.prototype.createSelectionCellsHandler = function()

mxGraph.prototype.createSelectionModel = function()

mxEdgeHandler.prototype.createSelectionShape = function( points )

mxVertexHandler.prototype.createSelectionShape = function( bounds )

mxSvgCanvas2D.prototype.createShadow = function( node )

mxVmlCanvas2D.prototype.createShadow = function( node, filled, stroked )

mxVmlCanvas2D.prototype.createShadowFill = function()

mxVmlCanvas2D.prototype.createShadowStroke = function()

mxCellHighlight.prototype.createShape = function()

mxCellRenderer.prototype.createShape = function( state )

mxConnectionHandler.prototype.createShape = function()

mxHandle.prototype.createShape = function( html )

mxRubberband.prototype.createShape = function()

mxOutline.prototype.createSizer = function()

mxVertexHandler.prototype.createSizer = function( cursor, index, size, fillColor )

mxVertexHandler.prototype.createSizerShape = function( bounds, index, fillColor )

mxAbstractCanvas2D.prototype.createState = function()

mxGraphView.prototype.createState = function( cell )

mxVmlCanvas2D.prototype.createStroke = function()

mxSvgCanvas2D.prototype.createStyle = function( x )

mxGraph.prototype.createStylesheet = function()

mxPopupMenu.prototype.createSubmenu = function( parent )

mxGraphView.prototype.createSvg = function()

mxShape.prototype.createSvg = function()

mxShape.prototype.createSvgCanvas = function()

mxSvgCanvas2D.prototype.createSvgGradient = function( start, end, alpha1, alpha2, direction )

mxEditor.prototype.createSwimlaneLayout = () =>

mxEditor.prototype.createSwimlaneManager = ( graph ) =>

mxConnectionHandler.prototype.createTargetVertex = function( evt, source )

mxEditor.prototype.createTasks = ( div ) =>

mxSvgCanvas2D.prototype.createTolerance = function( node )

mxEditor.prototype.createToolbar = () =>

mxGraph.prototype.createTooltipHandler = function()

mxVmlCanvas2D.prototype.createTransparentFill = function()

mxShape.prototype.createTransparentSvgRectangle = function( x, y, w, h )

mxGraphModel.prototype.createUndoableEdit = function( significant )

mxAbstractCanvas2D.prototype.createUrlConverter = function()

mxGraph.prototype.createVertex = function( parent, id, value, x, y, width, height, style, relative )

mxGraph.prototype.createVertexHandler = function( state )

mxElbowEdgeHandler.prototype.createVirtualBend = function( dblClickHandler )

mxEdgeHandler.prototype.createVirtualBends = function()

mxGraphView.prototype.createVml = function()

mxShape.prototype.createVml = function()

mxShape.prototype.createVmlCanvas = function()

mxVmlCanvas2D.prototype.createVmlElement = function( name )

mxShape.prototype.createVmlGroup = function()

mxGraphView.prototype.createVmlPane = function( width, height )

createXmlDocument: function()

mxHierarchicalLayout.prototype.crossingStage = function( parent )

mxSwimlaneLayout.prototype.crossingStage = function( parent )

mxAbstractCanvas2D.prototype.curveTo = function( x1, y1, x2, y2, x3, y3 )

mxXmlCanvas2D.prototype.curveTo = function( x1, y1, x2, y2, x3, y3 )

cut: function( graph, cells )

mxEditor.prototype.cycleAttribute = ( cell ) =>

mxHierarchicalLayout.prototype.cycleStage = function( parent )

mxSwimlaneLayout.prototype.cycleStage = function( parent )