| G | |
| geometryForCellChanged, mxGraphModel | |
| get | |
| getAlignmentAsPoint, mxUtils | |
| getAlignmentTolerance, mxConnectionHandler | |
| getAll, mxUtils | |
| getAllConnectionConstraints, mxGraph | |
| getAllEdges, mxGraph | |
| getAlternateContent, mxSvgCanvas2D | |
| getAppendices, mxPrintPreview | |
| getArcSize | |
| getAttribute, mxCell | |
| getAttributeName, mxObjectCodec | |
| getAutoDirection, mxText | |
| getBackgroundColor, mxCellEditor | |
| getBackgroundImage, mxGraph | |
| getBackgroundPageBounds, mxGraphView | |
| getBackgroundPane, mxGraphView | |
| getBaseDomain, mxUrlConverter | |
| getBaseUrl | |
| getBorder, mxGraph | |
| getBorderSizes, mxGraph | |
| getBoundingBox | |
| getBoundingBoxFromGeometry, mxGraph | |
| getBounds | |
| getBoundsForGroup, mxGraph | |
| getCanvas, mxGraphView | |
| getCell | |
| getCellAt | |
| getCellBounds | |
| getCellContainmentArea, mxGraph | |
| getCellForEvent, mxConstraintHandler | |
| getCellForPopupEvent, mxPopupMenuHandler | |
| getCellGeometry, mxGraph | |
| getCellOverlays, mxGraph | |
| getCells | |
| getCellsBeyond, mxGraph | |
| getCellsForChange, mxLayoutManager | |
| getCellsForEdit, mxLayoutManager | |
| getCellsForGroup, mxGraph | |
| getCellStates, mxGraphView | |
| getCellStyle | |
| getCellValidationError, mxGraph | |
| getCenterX, mxRectangle | |
| getCenterY, mxRectangle | |
| getChildAt | |
| getChildCells | |
| getChildCount | |
| getChildEdges | |
| getChildNodes, mxUtils | |
| getChildOffsetForCell, mxGraph | |
| getChildren, mxGraphModel | |
| getChildVertices | |
| getClientX, mxEvent | |
| getClientY, mxEvent | |
| getCloneableCells, mxGraph | |
| getCodec, mxCodecRegistry | |
| getColor, mxUtils | |
| getConnectImage, mxConnectionHandler | |
| getConnectionConstraint, mxGraph | |
| getConnectionPoint, mxGraph | |
| getConnections | |
| getConstraint, mxGraphLayout | |
| getControlBounds, mxCellRenderer | |
| getCoreCell | |
| getCoverPages, mxPrintPreview | |
| getCurrentPoints | |
| getCurrentRoot, mxGraph | |
| getCurrentStrokeWidth, mxSvgCanvas2D | |
| getCurrentStyle, mxUtils | |
| getCurrentValue, mxCellEditor | |
| getCursor, mxShape | |
| getCursorForBend, mxElbowEdgeHandler | |
| getCursorForCell, mxGraph | |
| getCursorForMouseEvent, mxGraph | |
| getDecoratorPane, mxGraphView | |
| getDefaultBundle, mxResources | |
| getDefaultEdgeStyle, mxStylesheet | |
| getDefaultParent, mxGraph | |
| getDefaultVertexStyle, mxStylesheet | |
| getDeletableCells, mxGraph | |
| getDelta | |
| getDescendants, mxGraphModel | |
| getDirectedBounds, mxUtils | |
| getDirectedEdgeCount, mxGraphModel | |
| getDocType, mxPrintPreview | |
| getDocumentElement, mxXmlRequest | |
| getDocumentHeight, mxDivResizer | |
| getDocumentScrollOrigin, mxUtils | |
| getDocumentWidth, mxDivResizer | |
| getDrawPane, mxGraphView | |
| getDropTarget | |
| getEdgeAt | |
| getEdgeColor, mxConnectionHandler | |
| getEdgeCount | |
| getEdgeId, mxParallelEdgeLayout | |
| getEdgeIndex, mxCell | |
| getEdges | |
| getEdgesBetween | |
| getEdgeStyle | |
| getEdgeValidationError, mxGraph | |
| getEdgeWidth | |
| getEditingCell, mxCellEditor | |
| getEditingValue, mxGraph | |
| getEditorBounds, mxCellEditor | |
| getElement, mxWindow | |
| getElementById, mxCodec | |
| getElementForEvent, mxDragSource | |
| getEmptyBounds, mxGraphView | |
| getEmptyLabelText, mxCellEditor | |
| getEndArrowWidth, mxArrowConnector | |
| getEvent, mxMouseEvent | |
| getEventSource, mxEventSource | |
| getEventState, mxGraph | |
| getExportableCells, mxGraph | |
| getFieldName, mxObjectCodec | |
| getFieldTemplate, mxObjectCodec | |
| getFirstSelectableCell, mxGraphSelectionModel | |
| getFixedTerminalPoint, mxGraphView | |
| getFloatingTerminalPoint, mxGraphView | |
| getFoldableCells, mxGraph | |
| getFoldingImage, mxGraph | |
| getFunction, mxKeyHandler | |
| getFunctionName, mxUtils | |
| getGeneralPurposeVariable | |
| getGeometry | |
| getGradientBounds | |
| getGraph | |
| getGraphBounds | |
| getGraphForEvent, mxDragSource | |
| getGraphX, mxMouseEvent | |
| getGraphY, mxMouseEvent | |
| getGridSize, mxGraph | |
| getGuideStates, mxGraphHandler | |
| getGuideTolerance, mxGuide | |
| getHandleFillColor, mxEdgeHandler | |
| getHandleForEvent | |
| getHandler, mxSelectionCellsHandler | |
| getHotspot, mxCellMarker | |
| getId | |
| getImage | |
| getImageBounds | |
| getImageForConstraint, mxConstraintHandler | |
| getImageFromBundles, mxGraph | |
| getImportableCells, mxGraph | |
| getIncomingEdges | |
| getIndex, mxCell | |
| getIndicatorBounds, mxLabel | |
| getIndicatorColor, mxGraph | |
| getIndicatorGradientColor, mxGraph | |
| getIndicatorImage, mxGraph | |
| getIndicatorShape, mxGraph | |
| getInitialCellForEvent, mxGraphHandler | |
| getInitialValue, mxCellEditor | |
| getInnerHtml, mxUtils | |
| getKeys, mxDictionary | |
| getLabel, mxGraph | |
| getLabelBounds | |
| getLabelMargins, mxShape | |
| getLabelValue, mxCellRenderer | |
| getLayout, mxLayoutManager | |
| getLinkForCell, mxGraph | |
| getLinkForCellState | |
| getMainEvent, mxEvent | |
| getMargin, mxText | |
| getMarkedState, mxCellMarker | |
| getMarkerColor, mxCellMarker | |
| getMaximumGraphBounds, mxGraph | |
| getMinimumSize | |
| getModel | |
| getMovableCells, mxGraph | |
| getName | |
| getNearestCommonAncestor, mxGraphModel | |
| getNextLayerConnectedCells | |
| getNextPoint, mxGraphView | |
| getNumber, mxUtils | |
| getObject, mxCodec | |
| getOffset, mxUtils | |
| getOpposites | |
| getOrigin, mxGraphModel | |
| getOriginForCell, mxMorphing | |
| getOuterHtml, mxUtils | |
| getOutgoingEdges | |
| getOutlineConstraint, mxGraph | |
| getOutlineOffset, mxOutline | |
| getOverlap, mxGraph | |
| getOverlayPane, mxGraphView | |
| getPaintBounds, mxCellState | |
| getParent | |
| getParentOffset, mxGraphLayout | |
| getParentPath, mxCellPath | |
| getParents, mxGraphModel | |
| getParentSize, mxStackLayout | |
| getPerimeterBounds | |
| getPerimeterFunction, mxGraphView | |
| getPerimeterPoint | |
| getPoint | |
| getPointForEvent | |
| getPosition, mxHandle | |
| getPreferredPageSize, mxGraph | |
| getPreferredSizeForCell, mxGraph | |
| getPrettyXML, mxUtils | |
| getPreviewBounds, mxGraphHandler | |
| getPreviewPoints | |
| getPreviewTerminalState, mxEdgeHandler | |
| getPreviousLayerConnectedCells | |
| getProperties, mxEventObject | |
| getProperty, mxEventObject | |
| getRadius, mxCircleLayout | |
| getRankValue, mxGraphHierarchyNode | |
| getRelativePoint, mxGraphView | |
| getRemovedCellsForChanges, mxGraph | |
| getRoot | |
| getRootTitle, mxEditor | |
| getRotatedPoint, mxUtils | |
| getRotation | |
| getRotationHandlePosition, mxVertexHandler | |
| getRoutingCenterX, mxGraphView | |
| getRoutingCenterY, mxGraphView | |
| getScale, mxGraphView | |
| getScaleForPageCount, mxUtils | |
| getScrollOrigin, mxUtils | |
| getSelectionBounds, mxVertexHandler | |
| getSelectionCell, mxGraph | |
| getSelectionCells, mxGraph | |
| getSelectionCellsForChanges, mxGraph | |
| getSelectionColor | |
| getSelectionCount, mxGraph | |
| getSelectionModel, mxGraph | |
| getSelectionPoints, mxEdgeHandler | |
| getSelectionStrokeWidth | |
| getShape, mxCellRenderer | |
| getShapeConstructor, mxCellRenderer | |
| getShapeRotation | |
| getShapesForState, mxCellRenderer | |
| getSizeForString, mxUtils | |
| getSnapToTerminalTolerance, mxEdgeHandler | |
| getSource | |
| getSourceContainerSize, mxOutline | |
| getSourcePerimeterPoint, mxConnectionHandler | |
| getSpacing, mxText | |
| getSpecialBundle, mxResources | |
| getStartArrowWidth, mxArrowConnector | |
| getStartSize, mxGraph | |
| getState | |
| getStateForEvent | |
| getStates, mxGraphView | |
| getStateToMark, mxCellMarker | |
| getStatus, mxXmlRequest | |
| getStencil, mxStencilRegistry | |
| getStringValue, mxStylesheetCodec | |
| getStyle | |
| getStylename, mxUtils | |
| getStylenames, mxUtils | |
| getStylesheet, mxGraph | |
| getSvgGradient, mxSvgCanvas2D | |
| getSvgScreenOffset | |
| getSwimlane, mxGraph | |
| getSwimlaneAt, mxGraph | |
| getTable, mxForm | |
| getTargetPerimeterPoint, mxConnectionHandler | |
| getTemplate, mxEditor | |
| getTerminal | |
| getTerminalForPort, mxGraph | |
| getTerminalPoint, mxGeometry | |
| getTerminalPort, mxGraphView | |
| getText, mxXmlRequest | |
| getTextContent, mxUtils | |
| getTextRotation | |
| getTextScale, mxCellRenderer | |
| getTitle, mxEditor | |
| getTolerance | |
| getTooltip, mxGraph | |
| getTooltipForCell, mxGraph | |
| getTooltipForNode | |
| getTopmostCells, mxGraphModel | |
| getTotalRotation, mxHandle | |
| getTranslate, mxGraphView | |
| getTranslateForEvent, mxOutline | |
| getTranslateForRoot, mxGraph | |
| getUrlImage, mxEditor | |
| getUrlPost, mxEditor | |
| getValidState, mxCellMarker | |
| getValue | |
| getValues, mxDictionary | |
| getVertexBounds, mxGraphLayout | |
| getVerticalAlign, mxGraph | |
| getView, mxGraph | |
| getViewXml, mxUtils | |
| getVisibleTerminal | |
| getVisibleTerminalState, mxCellState | |
| getVmlDashPattern, mxVmlCanvas2D | |
| getWindow, mxPrintPreview | |
| getX | |
| getXml | |
| getY | |
| graphContainsEvent, mxDragSource | |
| graphModelChanged | |
| graphRenderHint, mxOutline | |
| groupCells | |
| grow, mxRectangle |
Inner callback to update the mxGeometry of the given mxCell using mxCell.setGeometry and return the previous mxGeometry.
mxGraphModel.prototype.geometryForCellChanged = function( cell, geometry )
Returns the value for the given key.
mxDictionary.prototype.get = function( key )
Returns the ID for the given object or function or null if no object is specified.
get: function( obj )
Returns the value for the specified resource key.
get: function( key, params, defaultValue )
Loads the specified URL asynchronously and invokes the given functions depending on the request status.
get: function( url, onload, onerror, binary, timeout, ontimeout )
Returns an mxPoint that represents the horizontal and vertical alignment for numeric computations.
getAlignmentAsPoint: function( align, valign )
Returns the tolerance for aligning new targets to sources.
mxConnectionHandler.prototype.getAlignmentTolerance = function( evt )
Loads the URLs in the given array asynchronously and invokes the given function if all requests returned with a valid 2xx status.
getAll: function( urls, onload, onerror )
Returns an array of all mxConnectionConstraints for the given terminal.
mxGraph.prototype.getAllConnectionConstraints = function( terminal, source )
Returns all edges connected to the given cells or its descendants.
mxGraph.prototype.getAllEdges = function( cells )
Returns the pages to be added after the print output.
mxPrintPreview.prototype.getAppendices = function()
Returns the arc size for the given dimension.
mxShape.prototype.getArcSize = function( w, h )
Returns the arcsize for the swimlane.
mxSwimlane.prototype.getArcSize = function( w, h, start )
Returns the specified attribute from the user object if it is an XML node.
mxCell.prototype.getAttribute = function( name, defaultValue )
Returns the attributename for the given fieldname.
mxObjectCodec.prototype.getAttributeName = function( fieldname )
Used to determine the automatic text direction.
mxText.prototype.getAutoDirection = function()
Returns the background color for the in-place editor.
mxCellEditor.prototype.getBackgroundColor = function( state )
Returns the backgroundImage as an mxImage.
mxGraph.prototype.getBackgroundImage = function()
Returns the bounds for the background page.
mxGraphView.prototype.getBackgroundPageBounds = function()
Returns the DOM node that represents the background layer.
mxGraphView.prototype.getBackgroundPane = function()
Returns baseDomain.
mxUrlConverter.prototype.getBaseDomain = function()
Returns the URL of the page without the hash part.
mxSvgCanvas2D.prototype.getBaseUrl = function()
Returns baseUrl.
mxUrlConverter.prototype.getBaseUrl = function()
Returns the value of border.
mxGraph.prototype.getBorder = function()
Returns the size of the border and padding on all four sides of the container.
mxGraph.prototype.getBorderSizes = function()
Returns the bounding box for the given array of mxCells.
mxGraph.prototype.getBoundingBox = function( cells )
Returns the union of the mxCellStates for the given array of mxCells.
mxGraphHandler.prototype.getBoundingBox = function( cells )
Returns the bounding box of the shape and the label for the given mxCellState and its children if recurse is true.
mxGraphView.prototype.getBoundingBox = function( state, recurse )
Returns the bounding box for the rotated rectangle.
getBoundingBox: function( rect, rotation, cx )
Returns the bounding box for the geometries of the vertices in the given array of cells.
mxGraph.prototype.getBoundingBoxFromGeometry = function( cells, includeEdges )
Returns the bounds of the overlay for the given mxCellState as an mxRectangle.
mxCellOverlay.prototype.getBounds = function( state )
Returns the union of all mxCellStates for the given array of mxCells.
mxGraphView.prototype.getBounds = function( cells )
Returns the bounds to be used for the given group and children.
mxGraph.prototype.getBoundsForGroup = function( group, children, border )
Returns the DOM node that contains the background-, draw- and overlay- and decoratorpanes.
mxGraphView.prototype.getCanvas = function()
Returns the mxCell for the given event and cell.
mxCellMarker.prototype.getCell = function( me )
Returns the mxCell for the specified Id or null if no cell can be found for the given Id.
mxGraphModel.prototype.getCell = function( id )
Returns the mxCell in state is not null.
mxMouseEvent.prototype.getCell = function()
Creates and returns the mxCellMarker used in marker.
mxEdgeHandler.prototype.getCellAt = function( x, y )
Returns the bottom-most cell that intersects the given point (x, y) in the cell hierarchy starting at the given parent.
mxGraph.prototype.getCellAt = function( x, y, parent, vertices, edges, ignoreFn )
Returns the unscaled, untranslated bounds.
mxCellState.prototype.getCellBounds = function()
Returns the scaled, translated bounds for the given cell.
mxGraph.prototype.getCellBounds = function( cell, includeEdges, includeDescendants )
Returns the mxRectangle inside which a cell is to be kept.
mxGraph.prototype.getCellContainmentArea = function( cell )
Returns the cell for the given event.
mxConstraintHandler.prototype.getCellForEvent = function( me, point )
Hook to return the cell for the mouse up popup trigger handling.
mxPopupMenuHandler.prototype.getCellForPopupEvent = function( me )
Returns the mxGeometry for the given cell.
mxGraph.prototype.getCellGeometry = function( cell )
Returns the array of mxCellOverlays for the given cell or null, if no overlays are defined.
mxGraph.prototype.getCellOverlays = function( cell )
Returns the cells in the clipboard.
getCells: function()
Returns the child vertices and edges of the given parent that are contained in the given rectangle.
mxGraph.prototype.getCells = function( x, y, width, height, parent, result )
Returns the cells to be modified by this handler.
mxGraphHandler.prototype.getCells = function( initialCell )
Returns the children of the given parent that are contained in the halfpane from the given point (x0, y0) rightwards or downwards depending on rightHalfpane and bottomHalfpane.
mxGraph.prototype.getCellsBeyond = function( x0, y0, parent, rightHalfpane, bottomHalfpane )
Executes all layouts which have been scheduled during the changes.
mxLayoutManager.prototype.getCellsForChange = function( change )
Returns the cells with the same parent as the first cell in the given array.
mxGraph.prototype.getCellsForGroup = function( cells )
Returns the mxCellStates for the given array of mxCells.
mxGraphView.prototype.getCellStates = function( cells )
Returns an array of key, value pairs representing the cell style for the given cell.
mxGraph.prototype.getCellStyle = function( cell )
Returns the cell style for the specified stylename or the given defaultStyle if no style can be found for the given stylename.
mxStylesheet.prototype.getCellStyle = function( name, defaultStyle )
Checks all multiplicities that cannot be enforced while the graph is being modified, namely, all multiplicities that require a minimum of 1 edge.
mxGraph.prototype.getCellValidationError = function( cell )
Returns the x-coordinate of the center point.
mxRectangle.prototype.getCenterX = function ()
Returns the y-coordinate of the center point.
mxRectangle.prototype.getCenterY = function ()
Returns the child at the specified index.
mxCell.prototype.getChildAt = function( index )
Returns the child of the given mxCell at the given index.
mxGraphModel.prototype.getChildAt = function( cell, index )
Returns the visible child vertices or edges in the given parent.
mxGraph.prototype.getChildCells = function( parent, vertices, edges )
Returns the children of the given cell that are vertices and/or edges depending on the arguments.
mxGraphModel.prototype.getChildCells = function( parent, vertices, edges )
Returns the number of child cells.
mxCell.prototype.getChildCount = function()
Returns the number of children in the given cell.
mxGraphModel.prototype.getChildCount = function( cell )
Returns the visible child edges of the given parent.
mxGraph.prototype.getChildEdges = function( parent )
Returns the child edges of the given parent.
mxGraphModel.prototype.getChildEdges = function( parent )
Returns an array of child nodes that are of the given node type.
getChildNodes: function( node, nodeType )
Returns the offset to be used for the cells inside the given cell.
mxGraph.prototype.getChildOffsetForCell = function( cell )
Returns all children of the given mxCell as an array of mxCells.
mxGraphModel.prototype.getChildren = function( cell )
Returns the visible child vertices of the given parent.
mxGraph.prototype.getChildVertices = function( parent )
Returns the child vertices of the given parent.
mxGraphModel.prototype.getChildVertices = function( parent )
Returns true if the meta key is pressed for the given event.
getClientX: function( e )
Returns true if the meta key is pressed for the given event.
getClientY: function( e )
Returns the cells which may be exported in the given array of cells.
mxGraph.prototype.getCloneableCells = function( cells )
Returns a codec that handles objects that are constructed using the given constructor.
getCodec: function( ctor )
Returns the color value for the given key in the given associative array or the given default value if the value is null.
getColor: function( array, key, defaultValue )
Hook to return the mxImage used for the connection icon of the given mxCellState.
mxConnectionHandler.prototype.getConnectImage = function( state )
Returns an mxConnectionConstraint that describes the given connection point.
mxGraph.prototype.getConnectionConstraint = function( edge, terminal, source )
Returns the nearest point in the list of absolute points or the center of the opposite terminal.
mxGraph.prototype.getConnectionPoint = function( vertex, constraint )
Returns all visible edges connected to the given cell without loops.
mxGraph.prototype.getConnections = function( cell, parent )
Returns all edges of the given cell without loops.
mxGraphModel.prototype.getConnections = function( cell )
Returns the constraint for the given key and cell.
mxGraphLayout.prototype.getConstraint = function( key, cell, edge, source )
Returns the bounds to be used to draw the control (folding icon) of the given state.
mxCellRenderer.prototype.getControlBounds = function( state, w, h )
Gets the first core edge associated with this wrapper
mxGraphHierarchyEdge.prototype.getCoreCell = function()
Gets the core vertex associated with this wrapper
mxGraphHierarchyNode.prototype.getCoreCell = function()
Returns the pages to be added before the print output.
mxPrintPreview.prototype.getCoverPages = function()
Returns the current absolute points.
mxEdgeSegmentHandler.prototype.getCurrentPoints = function()
Returns the current root of the displayed cell hierarchy.
mxGraph.prototype.getCurrentRoot = function()
Returns the current stroke width (>= 1), ie.
mxSvgCanvas2D.prototype.getCurrentStrokeWidth = function()
Returns the current style of the specified element.
getCurrentStyle: function()
Returns the current editing value.
mxCellEditor.prototype.getCurrentValue = function( state )
Returns the current cursor.
mxShape.prototype.getCursor = function()
Returns the cursor to be used for the bend.
mxElbowEdgeHandler.prototype.getCursorForBend = function()
Returns the cursor value to be used for the CSS of the shape for the given cell.
mxGraph.prototype.getCursorForCell = function( cell )
Returns the cursor value to be used for the CSS of the shape for the given event.
mxGraph.prototype.getCursorForMouseEvent = function( me )
Returns the DOM node that represents the topmost drawing layer.
mxGraphView.prototype.getDecoratorPane = function()
Hook for subclassers to return the URL for the special bundle.
getDefaultBundle: function( basename, lan )
Sets the default style for edges.
mxStylesheet.prototype.getDefaultEdgeStyle = function()
Returns defaultParent or mxGraphView.currentRoot or the first child child of mxGraphModel.root if both are null.
mxGraph.prototype.getDefaultParent = function()
Returns the default style for vertices.
mxStylesheet.prototype.getDefaultVertexStyle = function()
Returns the cells which may be exported in the given array of cells.
mxGraph.prototype.getDeletableCells = function( cells )
Returns an mxPoint that represents the vector for moving the cells for the given mxMouseEvent.
mxGraphHandler.prototype.getDelta = function( me )
Returns the vector between the current rendered state and the future location of the state after the display will be updated.
mxMorphing.prototype.getDelta = function( state )
Returns all descendants of the given cell and the cell itself in an array.
mxGraphModel.prototype.getDescendants = function( parent )
Adds the given margins to the given rectangle and rotates and flips the rectangle according to the respective styles in style.
getDirectedBounds: function ( rect, m, style, flipH, flipV )
Returns the number of incoming or outgoing edges, ignoring the given edge.
mxGraphModel.prototype.getDirectedEdgeCount = function( cell, outgoing, ignoredEdge )
Returns the document element of the response XML document.
mxXmlRequest.prototype.getDocumentElement = function()
Hook for subclassers to return the height of the document (without scrollbars).
mxDivResizer.prototype.getDocumentHeight = function()
Returns the scroll origin of the given document or the current document if no document is given.
getDocumentScrollOrigin: function( doc )
Hook for subclassers to return the width of the document (without scrollbars).
mxDivResizer.prototype.getDocumentWidth = function()
Returns the DOM node that represents the main drawing layer.
mxGraphView.prototype.getDrawPane = function()
Returns the drop target for the given graph and coordinates.
mxDragSource.prototype.getDropTarget = function( graph, x, y, evt )
Returns the given cell if it is a drop target for the given cells or the nearest ancestor that may be used as a drop target for the given cells.
mxGraph.prototype.getDropTarget = function( cells, evt, cell, clone )
Returns the edge at the specified index in edges.
mxCell.prototype.getEdgeAt = function( index )
Returns the edge of cell at the given index.
mxGraphModel.prototype.getEdgeAt = function( cell, index )
Returns the number of edges in the edge array.
mxCell.prototype.getEdgeCount = function()
Returns the number of distinct edges connected to the given cell.
mxGraphModel.prototype.getEdgeCount = function( cell )
Returns a unique ID for the given edge.
mxParallelEdgeLayout.prototype.getEdgeId = function( edge )
Returns the index of the specified edge in edges.
mxCell.prototype.getEdgeIndex = function( edge )
Returns the incoming and/or outgoing edges for the given cell.
mxGraph.prototype.getEdges = function( cell, parent, incoming, outgoing, includeLoops, recurse )
Returns all distinct edges connected to this cell as a new array of mxCells.
mxGraphModel.prototype.getEdges = function( cell, incoming, outgoing, includeLoops )
Returns the connected edges for the given cell.
mxHierarchicalLayout.prototype.getEdges = function( cell )
Returns the connected edges for the given cell.
mxSwimlaneLayout.prototype.getEdges = function( cell )
Returns the edges between the given source and target.
mxGraph.prototype.getEdgesBetween = function( source, target, directed )
Returns all edges between the given source and target pair.
mxGraphModel.prototype.getEdgesBetween = function( source, target, directed )
Returns the edges between the given source and target.
mxHierarchicalLayout.prototype.getEdgesBetween = function( source, target, directed )
Returns the edges between the given source and target.
mxSwimlaneLayout.prototype.getEdgesBetween = function( source, target, directed )
Returns a string identifying the style of new edges.
mxEditor.prototype.getEdgeStyle = function ()
Returns the edge style function to be used to render the given edge state.
mxGraphView.prototype.getEdgeStyle = function( edge, points, source, target )
Returns the validation error message to be displayed when inserting or changing an edges’ connectivity.
mxGraph.prototype.getEdgeValidationError = function( edge, source, target )
Returns the width of the body of the edge
mxArrowConnector.prototype.getEdgeWidth = function()
Returns the width used to draw the preview edge.
mxConnectionHandler.prototype.getEdgeWidth = function( valid )
Returns the cell that is currently being edited or null if no cell is being edited.
mxCellEditor.prototype.getEditingCell = function ()
Returns the initial value for in-place editing.
mxGraph.prototype.getEditingValue = function( cell, evt )
Returns the mxRectangle that defines the bounds of the editor.
mxCellEditor.prototype.getEditorBounds = function( state )
Returuns the outermost DOM node that makes up the window.
mxWindow.prototype.getElement = function()
Returns the element with the given ID from document.
mxCodec.prototype.getElementById = function( id )
Returns the topmost element under the given event.
mxDragSource.prototype.getElementForEvent = function( evt )
Returns the bounds for an empty graph.
mxGraphView.prototype.getEmptyBounds = function()
Returns the initial label value to be used of the label of the given cell is empty.
mxCellEditor.prototype.getEmptyLabelText = function ( cell )
Returns the width of the end arrow
mxArrowConnector.prototype.getEndArrowWidth = function()
Returns evt.
mxMouseEvent.prototype.getEvent = function()
Returns eventSource.
mxEventSource.prototype.getEventSource = function()
Returns the mxCellState to be used when firing the mouse event for the given state.
mxGraph.prototype.getEventState = function( state )
Returns the cells which may be exported in the given array of cells.
mxGraph.prototype.getExportableCells = function( cells )
Returns the fieldname for the given attributename.
mxObjectCodec.prototype.getFieldName = function( attributename )
Returns the template instance for the given field.
mxObjectCodec.prototype.getFieldTemplate = function( obj, fieldname, child )
Returns the first selectable cell in the given array of cells.
mxGraphSelectionModel.prototype.getFirstSelectableCell = function( cells )
Returns the fixed source or target terminal point for the given edge.
mxGraphView.prototype.getFixedTerminalPoint = function( edge, terminal, source, constraint )
Returns the floating terminal point for the given edge, start and end state, where start is the source if source is true.
mxGraphView.prototype.getFloatingTerminalPoint = function( edge, start, end, source )
Returns the cells which are movable in the given array of cells.
mxGraph.prototype.getFoldableCells = function( cells, collapse )
Returns the mxImage used to display the collapsed state of the specified cell state.
mxGraph.prototype.getFoldingImage = function( state )
Returns the function associated with the given key event or null if no function is associated with the given event.
mxKeyHandler.prototype.getFunction = function( evt )
Returns the name for the given function.
getFunctionName: function( f )
Gets the value of temp for the specified layer
mxGraphAbstractHierarchyCell.prototype.getGeneralPurposeVariable = function( layer )
Gets the value of temp for the specified layer
mxGraphHierarchyEdge.prototype.getGeneralPurposeVariable = function( layer )
Gets the value of temp for the specified layer
mxGraphHierarchyNode.prototype.getGeneralPurposeVariable = function( layer )
Returns the mxGeometry that describes the geometry.
mxCell.prototype.getGeometry = function()
Returns the mxGeometry of the given mxCell.
mxGraphModel.prototype.getGeometry = function( cell )
Returns the bounding box for the gradient box for this shape.
mxShape.prototype.getGradientBounds = function( c, x, y, w, h )
Returns the graph that this layout operates on.
mxGraphLayout.prototype.getGraph = function()
Returns the graph that this layout operates on.
mxLayoutManager.prototype.getGraph = function()
Returns the graph that this manager operates on.
mxSwimlaneManager.prototype.getGraph = function()
Returns the bounds of the visible graph.
mxGraph.prototype.getGraphBounds = function()
Returns graphBounds.
mxGraphView.prototype.getGraphBounds = function()
Returns the graph for the given mouse event.
mxDragSource.prototype.getGraphForEvent = function( evt )
Returns graphX.
mxMouseEvent.prototype.getGraphX = function()
Returns graphY.
mxMouseEvent.prototype.getGraphY = function()
Returns gridSize.
mxGraph.prototype.getGridSize = function()
Creates an array of cell states which should be used as guides.
mxGraphHandler.prototype.getGuideStates = function()
Returns the tolerance for the guides.
mxGuide.prototype.getGuideTolerance = function()
Returns the fillcolor for the handle at the given index.
mxEdgeHandler.prototype.getHandleFillColor = function( index )
Returns the index of the handle for the given event.
mxEdgeHandler.prototype.getHandleForEvent = function( me )
Returns the index of the handle for the given event.
mxVertexHandler.prototype.getHandleForEvent = function( me )
Returns the handler for the given cell.
mxSelectionCellsHandler.prototype.getHandler = function( cell )
Returns the hotspot.
mxCellMarker.prototype.getHotspot = function()
Returns the Id of the cell as a string.
mxCell.prototype.getId = function()
Returns the ID of the specified object.
mxCodec.prototype.getId = function( obj )
Returns the image URL for the given cell state.
mxGraph.prototype.getImage = function( state )
Returns the value for the given key.
mxImageBundle.prototype.getImage = function( key )
Generic background painting implementation.
mxLabel.prototype.getImageBounds = function( x, y, w, h )
Paints the swimlane vertex shape.
mxSwimlane.prototype.getImageBounds = function( x, y, w, h )
Returns the tolerance to be used for intersecting connection points.
mxConstraintHandler.prototype.getImageForConstraint = function( state, constraint, point )
Searches all imageBundles for the specified key and returns the value for the first match or null if the key is not found.
mxGraph.prototype.getImageFromBundles = function( key )
Returns the cells which may be imported in the given array of cells.
mxGraph.prototype.getImportableCells = function( cells )
Returns the visible incoming edges for the given cell.
mxGraph.prototype.getIncomingEdges = function( cell, parent )
Returns the incoming edges of the given cell without loops.
mxGraphModel.prototype.getIncomingEdges = function( cell )
Returns the index of the specified child in the child array.
mxCell.prototype.getIndex = function( child )
Generic background painting implementation.
mxLabel.prototype.getIndicatorBounds = function( x, y, w, h )
Returns the indicator color for the given cell state.
mxGraph.prototype.getIndicatorColor = function( state )
Returns the indicator gradient color for the given cell state.
mxGraph.prototype.getIndicatorGradientColor = function( state )
Returns the indicator image for the given cell state.
mxGraph.prototype.getIndicatorImage = function( state )
Returns the indicator shape for the given cell state.
mxGraph.prototype.getIndicatorShape = function( state )
Hook to return initial cell for the given event.
mxGraphHandler.prototype.getInitialCellForEvent = function( me )
Gets the initial editing value for the given cell.
mxCellEditor.prototype.getInitialValue = function( state, trigger )
Returns the inner HTML for the given node as a string or an empty string if no node was specified.
getInnerHtml: function()
Returns all keys as an array.
mxDictionary.prototype.getKeys = function()
Returns a string or DOM node that represents the label for the given cell.
mxGraph.prototype.getLabel = function( cell )
Returns the bounds to be used to draw the label of the given state.
mxCellRenderer.prototype.getLabelBounds = function( state )
Returns the bounds for the label.
mxDoubleEllipse.prototype.getLabelBounds = function( rect )
Returns the mxRectangle for the label bounds of this shape, based on the given scaled and translated bounds of the shape.
mxShape.prototype.getLabelBounds = function( rect )
Returns the scaled top, left, bottom and right margin to be used for computing the label bounds as an mxRectangle, where the bottom and right margin are defined in the width and height of the rectangle, respectively.
mxShape.prototype.getLabelMargins= function( rect )
Returns the value to be used for the label.
mxCellRenderer.prototype.getLabelValue = function( state )
Returns the layout to be executed for the given graph and parent.
mxLayoutManager.prototype.getLayout = function( parent )
Returns the string to be used as the link for the given cell.
mxGraph.prototype.getLinkForCell = function( cell )
Returns the link for the given cell state and canvas.
mxImageExport.prototype.getLinkForCellState = function( state, canvas )
Returns the link for the given cell state.
mxPrintPreview.prototype.getLinkForCellState = function( state )
Returns the touch or mouse event that contains the mouse coordinates.
getMainEvent: function( e )
Returns the markedState.
mxCellMarker.prototype.getMarkedState = function()
Returns the valid- or invalidColor depending on the value of isValid.
mxCellMarker.prototype.getMarkerColor = function( evt, state, isValid )
Returns the bounds inside which the diagram should be kept as an mxRectangle.
mxGraph.prototype.getMaximumGraphBounds = function()
Returns the minimum width and height for editing the given state.
mxCellEditor.prototype.getMinimumSize = function( state )
Returns an mxRectangle that specifies the size for the minimized window.
mxWindow.prototype.getMinimumSize = function()
Returns the mxGraphModel that contains the cells.
mxGraph.prototype.getModel = function()
Returns the internal mxGraphHierarchyModel for this layout algorithm.
mxHierarchicalLayout.prototype.getModel = function()
Returns the internal mxSwimlaneModel for this layout algorithm.
mxSwimlaneLayout.prototype.getModel = function()
Returns the cells which are movable in the given array of cells.
mxGraph.prototype.getMovableCells = function( cells )
Returns name.
mxEventObject.prototype.getName = function()
Returns the name used for the nodenames and lookup of the codec when classes are encoded and nodes are decoded.
mxObjectCodec.prototype.getName = function()
Returns the name for the given value.
getName: function( value )
Returns the nearest common ancestor for the specified cells.
mxGraphModel.prototype.getNearestCommonAncestor = function( cell1, cell2 )
Returns the cells this cell connects to on the next layer up
mxGraphAbstractHierarchyCell.prototype.getNextLayerConnectedCells = function( layer )
Returns the cells this cell connects to on the next layer up
mxGraphHierarchyEdge.prototype.getNextLayerConnectedCells = function( layer )
Returns the cells this cell connects to on the next layer up
mxGraphHierarchyNode.prototype.getNextLayerConnectedCells = function( layer )
Returns the nearest point in the list of absolute points or the center of the opposite terminal.
mxGraphView.prototype.getNextPoint = function( edge, opposite, source )
Returns the numeric value for the given key in the given associative array or the given default value (or 0) if the value is null.
getNumber: function( array, key, defaultValue )
Returns the decoded object for the element with the specified ID in document.
mxCodec.prototype.getObject = function( id )
Returns the offset for the specified container as an mxPoint.
getOffset: function( container, scrollOffset )
Returns all distinct visible opposite cells for the specified terminal on the given edges.
mxGraph.prototype.getOpposites = function( edges, terminal, sources, targets )
Returns all opposite vertices wrt terminal for the given edges, only returning sources and/or targets as specified.
mxGraphModel.prototype.getOpposites = function( edges, terminal, sources, targets )
Returns the absolute, accumulated origin for the children inside the given parent as an mxPoint.
mxGraphModel.prototype.getOrigin = function( cell )
Returns the top, left corner of the given cell.
mxMorphing.prototype.getOriginForCell = function( cell )
Returns the outer HTML for the given node as a string or an empty string if no node was specified.
getOuterHtml: function()
Returns the visible outgoing edges for the given cell.
mxGraph.prototype.getOutgoingEdges = function( cell, parent )
Returns the outgoing edges of the given cell without loops.
mxGraphModel.prototype.getOutgoingEdges = function( cell )
Returns the constraint used to connect to the outline of the given state.
mxGraph.prototype.getOutlineConstraint = function( point, terminalState, me )
Returns the offset for drawing the outline graph.
mxOutline.prototype.getOutlineOffset = function( scale )
Returns a decimal number representing the amount of the width and height of the given cell that is allowed to overlap its parent.
mxGraph.prototype.getOverlap = function( cell )
Returns the DOM node that represents the layer above the drawing layer.
mxGraphView.prototype.getOverlayPane = function()
Returns the unscaled, untranslated paint bounds.
mxCellState.prototype.getPaintBounds = function()
Returns the cell’s parent.
mxCell.prototype.getParent = function()
Returns the parent of the given cell.
mxGraphModel.prototype.getParent = function( cell )
Determines the offset of the given parent to the parent of the layout
mxGraphLayout.prototype.getParentOffset = function( parent )
Returns the path for the parent of the cell represented by the given path.
getParentPath: function( path )
Returns an array that represents the set (no duplicates) of all parents for the given array of cells.
mxGraphModel.prototype.getParents = function( cells )
Returns the size for the parent container or the size of the graph container if the parent is a layer or the root of the model.
mxStackLayout.prototype.getParentSize = function( parent )
Returns the mxRectangle that should be used as the perimeter of the cell.
mxCellState.prototype.getPerimeterBounds = function( border, bounds )
Returns the perimeter bounds for the given terminal, edge pair as an mxRectangle.
mxGraphView.prototype.getPerimeterBounds = function( terminal, border )
Returns the perimeter function for the given state.
mxGraphView.prototype.getPerimeterFunction = function( state )
Returns an mxPoint that defines the location of the intersection point between the perimeter and the line between the center of the shape and the given point.
mxGraphView.prototype.getPerimeterPoint = function( terminal, next, orthogonal, border )
Returns the intersection between the polygon defined by the array of points and the line between center and point.
getPerimeterPoint: function ( pts, center, point )
Returns the absolute point on the edge for the given relative mxGeometry as an mxPoint.
mxGraphView.prototype.getPoint = function( state, geometry )
Returns the top, left corner as a new mxPoint.
mxRectangle.prototype.getPoint = function()
Returns the point for the given event.
mxEdgeHandler.prototype.getPointForEvent = function( me )
Returns an mxPoint representing the given event in the unscaled, non-translated coordinate space of container and applies the grid.
mxGraph.prototype.getPointForEvent = function( evt, addOffset )
Hook for subclassers to return the current position of the handle.
mxHandle.prototype.getPosition = function( bounds )
Returns the preferred size of the background page if preferPageSize is true.
mxGraph.prototype.getPreferredPageSize = function( bounds, width, height )
Returns the preferred width and height of the given mxCell as an mxRectangle.
mxGraph.prototype.getPreferredSizeForCell = function( cell )
Returns the mxRectangle used as the preview bounds for moving the given cells.
mxGraphHandler.prototype.getPreviewBounds = function( cells )
Updates the given preview state taking into account the state of the constraint handler.
mxEdgeSegmentHandler.prototype.getPreviewPoints = function( point )
Updates the given preview state taking into account the state of the constraint handler.
mxEdgeHandler.prototype.getPreviewPoints = function( pt, me )
Updates the given preview state taking into account the state of the constraint handler.
mxEdgeHandler.prototype.getPreviewTerminalState = function( me )
Returns the cells this cell connects to on the next layer down
mxGraphAbstractHierarchyCell.prototype.getPreviousLayerConnectedCells = function( layer )
Returns the cells this cell connects to on the next layer down
mxGraphHierarchyEdge.prototype.getPreviousLayerConnectedCells = function( layer )
Returns the cells this cell connects to on the next layer down
mxGraphHierarchyNode.prototype.getPreviousLayerConnectedCells = function( layer )
Returns properties.
mxEventObject.prototype.getProperties = function()
Returns the property for the given key.
mxEventObject.prototype.getProperty = function( key )
Returns the radius to be used for the given vertex count.
mxCircleLayout.prototype.getRadius = function( count, max )
Returns the integer value of the layer that this node resides in
mxGraphHierarchyNode.prototype.getRankValue = function( layer )
Gets the relative point that describes the given, absolute label position for the given edge state.
mxGraphView.prototype.getRelativePoint = function( edgeState, x, y )
Returns the cells that have been removed from the model.
mxGraph.prototype.getRemovedCellsForChanges = function( changes )
Returns the root of the model or the topmost parent of the given cell.
mxGraphModel.prototype.getRoot = function( cell )
Returns the root cell for painting the graph.
mxPrintPreview.prototype.getRoot = function()
Returns the string value of the root cell in mxGraph.model.
mxEditor.prototype.getRootTitle = function ()
Rotates the given point by the given cos and sin.
getRotatedPoint: function( pt, cos, sin, c )
Returns the rotation defined in the style of the cell.
mxHandle.prototype.getRotation = function()
Returns 0.
mxPolyline.prototype.getRotation = function()
Returns the rotation from the style.
mxShape.prototype.getRotation = function()
Returns an mxPoint that defines the rotation handle position.
mxVertexHandler.prototype.getRotationHandlePosition = function()
Returns the x-coordinate of the center point for automatic routing.
mxGraphView.prototype.getRoutingCenterX = function ( state )
Returns the y-coordinate of the center point for automatic routing.
mxGraphView.prototype.getRoutingCenterY = function ( state )
Returns the scale.
mxGraphView.prototype.getScale = function()
Returns the scale to be used for printing the graph with the given bounds across the specifies number of pages with the given format.
getScaleForPageCount: function( pageCount, graph, pageFormat, border )
Returns the top, left corner of the viewrect as an mxPoint.
getScrollOrigin: function( node, includeAncestors, includeDocument )
Returns the mxRectangle that defines the bounds of the selection border.
mxVertexHandler.prototype.getSelectionBounds = function( state )
Returns the first cell from the array of selected mxCells.
mxGraph.prototype.getSelectionCell = function()
Returns the array of selected mxCells.
mxGraph.prototype.getSelectionCells = function()
Returns the cells to be selected for the given array of changes.
mxGraph.prototype.getSelectionCellsForChanges = function( changes )
Returns mxConstants.EDGE_SELECTION_COLOR.
mxEdgeHandler.prototype.getSelectionColor = function()
Returns mxConstants.VERTEX_SELECTION_COLOR.
mxVertexHandler.prototype.getSelectionColor = function()
Returns the number of selected cells.
mxGraph.prototype.getSelectionCount = function()
Returns the mxGraphSelectionModel that contains the selection.
mxGraph.prototype.getSelectionModel = function()
Returns the list of points that defines the selection stroke.
mxEdgeHandler.prototype.getSelectionPoints = function( state )
Returns mxConstants.EDGE_SELECTION_STROKEWIDTH.
mxEdgeHandler.prototype.getSelectionStrokeWidth = function()
Returns mxConstants.VERTEX_SELECTION_STROKEWIDTH.
mxVertexHandler.prototype.getSelectionStrokeWidth = function()
Returns the shape for the given name from defaultShapes.
mxCellRenderer.prototype.getShape = function( name )
Returns the constructor to be used for creating the shape.
mxCellRenderer.prototype.getShapeConstructor = function( state )
Returns 0.
mxPolyline.prototype.getShapeRotation = function()
Returns the actual rotation of the shape.
mxShape.prototype.getShapeRotation = function()
Returns 0 to avoid using rotation in the canvas via updateTransform.
mxText.prototype.getShapeRotation = function()
Returns the mxShapes for the given cell state in the order in which they should appear in the DOM.
mxCellRenderer.prototype.getShapesForState = function( state )
Returns an mxRectangle with the size (width and height in pixels) of the given string.
getSizeForString: function( text, fontSize, fontFamily, textWidth )
Returns the tolerance for the guides.
mxEdgeHandler.prototype.getSnapToTerminalTolerance = function()
Returns the event’s target or srcElement depending on the browser.
getSource: function( evt )
Returns the target DOM element using mxEvent.getSource for evt.
mxMouseEvent.prototype.getSource = function()
Returns the size of the source container.
mxOutline.prototype.getSourceContainerSize = function()
Hook to update the icon position(s) based on a mouseOver event.
mxConnectionHandler.prototype.getSourcePerimeterPoint = function( state, next, me )
Returns the spacing as an mxPoint.
mxText.prototype.getSpacing = function()
Hook for subclassers to return the URL for the special bundle.
getSpecialBundle: function( basename, lan )
Returns the width of the start arrow
mxArrowConnector.prototype.getStartArrowWidth = function()
Returns the start size of the given swimlane, that is, the width or height of the part that contains the title, depending on the horizontal style.
mxGraph.prototype.getStartSize = function( swimlane )
Uses getCell, getStateToMark and intersects to return the mxCellState for the given mxMouseEvent.
mxCellMarker.prototype.getState = function( me )
Returns the mxCellState for the given cell.
mxGraphView.prototype.getState = function( cell, create )
Returns state.
mxMouseEvent.prototype.getState = function()
Returns the mxCellState to be used for showing a tooltip for this event.
mxTooltipHandler.prototype.getStateForEvent = function( me )
Returns states.
mxGraphView.prototype.getStates = function()
Returns the mxCellState to be marked for the given mxCellState under the mouse.
mxCellMarker.prototype.getStateToMark = function( state )
Returns the status as a number, eg.
mxXmlRequest.prototype.getStatus = function()
Returns the mxStencil for the given name.
getStencil: function( name )
Returns the string for encoding the given value.
codec.getStringValue = function( key, value )
Returns a string that describes the style.
mxCell.prototype.getStyle = function()
Returns the style of the given mxCell.
mxGraphModel.prototype.getStyle = function( cell )
Returns the stylename in a style of the form [(stylename|key=value);] or an empty string if the given style does not contain a stylename.
getStylename: function( style )
Returns the stylenames in a style of the form [(stylename|key=value);] or an empty array if the given style does not contain any stylenames.
getStylenames: function( style )
Returns the mxStylesheet that defines the style.
mxGraph.prototype.getStylesheet = function()
Private helper function to create SVG elements
mxSvgCanvas2D.prototype.getSvgGradient = function( start, end, alpha1, alpha2, direction )
Disables offset in IE9 for crisper image output.
mxImageShape.prototype.getSvgScreenOffset = function()
Returns 0, or 0.5 if strokewidth % 2 == 1.
mxShape.prototype.getSvgScreenOffset = function()
Disables offset in IE9 for crisper image output.
mxText.prototype.getSvgScreenOffset = function()
Returns the nearest ancestor of the given cell which is a swimlane, or the given cell, if it is itself a swimlane.
mxGraph.prototype.getSwimlane = function( cell )
Returns the bottom-most swimlane that intersects the given point (x, y) in the cell hierarchy that starts at the given parent.
mxGraph.prototype.getSwimlaneAt = function ( x, y, parent )
Returns the table that contains this form.
mxForm.prototype.getTable = function()
Returns the perimeter point for the given target state.
mxConnectionHandler.prototype.getTargetPerimeterPoint = function( state, me )
Returns the template for the given name.
mxEditor.prototype.getTemplate = function ( name )
Returns the source or target terminal.
mxCell.prototype.getTerminal = function( source )
Returns the source or target mxCell of the given edge depending on the value of the boolean parameter.
mxGraphModel.prototype.getTerminal = function( edge, isSource )
Returns the terminal to be used for a given port.
mxGraph.prototype.getTerminalForPort = function( cell, source )
Returns the mxPoint representing the source or target point of this edge.
mxGeometry.prototype.getTerminalPoint = function( isSource )
Returns an mxCellState that represents the source or target terminal or port for the given edge.
mxGraphView.prototype.getTerminalPort = function( state, terminal, source )
Returns the response as a string.
mxXmlRequest.prototype.getText = function()
Returns the text content of the specified node.
getTextContent: function( node )
Returns the rotation for the text label.
mxShape.prototype.getTextRotation = function()
Returns the rotation for the text label of the corresponding shape.
mxText.prototype.getTextRotation = function()
Returns the scaling used for the label of the given state
mxCellRenderer.prototype.getTextScale = function( state )
Returns the string value for the current root of the diagram.
mxEditor.prototype.getTitle = function ()
Returns the tolerance to be used for intersecting connection points.
mxConstraintHandler.prototype.getTolerance = function( me )
Returns tolerance.
mxGraph.prototype.getTolerance = function()
Returns the string or DOM node that represents the tooltip for the given state, node and coordinate pair.
mxGraph.prototype.getTooltip = function( state, node, x, y )
Returns the string or DOM node to be used as the tooltip for the given cell.
mxGraph.prototype.getTooltipForCell = function( cell )
Returns no tooltips.
mxEdgeSegmentHandler.prototype.getTooltipForNode = function( node )
Returns the tooltip for the given node.
mxElbowEdgeHandler.prototype.getTooltipForNode = function( node )
Returns the topmost cells of the hierarchy in an array that contains no descendants for each mxCell that it contains.
mxGraphModel.prototype.getTopmostCells = function( cells )
Returns the rotation from the style and the rotation from the direction of the cell.
mxHandle.prototype.getTotalRotation = function()
Returns the translate.
mxGraphView.prototype.getTranslate = function()
Gets the translate for the given mouse event.
mxOutline.prototype.getTranslateForEvent = function( me )
Returns the translation to be used if the given cell is the root cell as an mxPoint.
mxGraph.prototype.getTranslateForRoot = function( cell )
Returns the URL to create the image with.
mxEditor.prototype.getUrlImage = function ()
Returns the URL to post the diagram to.
mxEditor.prototype.getUrlPost = function ()
Returns the validState.
mxCellMarker.prototype.getValidState = function()
Returns the user object of the cell.
mxCell.prototype.getValue = function()
Returns the user object of the given mxCell using mxCell.getValue.
mxGraphModel.prototype.getValue = function( cell )
Returns the value associated with the given name.
getValue: function( name )
Returns the value for the given key in the given associative array or the given default value if the value is null.
getValue: function( array, key, defaultValue )
Returns all values as an array.
mxDictionary.prototype.getValues = function()
Returns an mxRectangle that defines the bounds of the given cell or the bounding box if useBoundingBox is true.
mxGraphLayout.prototype.getVertexBounds = function( cell )
Returns the vertical alignment for the given cell state.
mxGraph.prototype.getVerticalAlign = function( state )
Returns the mxGraphView that contains the mxCellStates.
mxGraph.prototype.getView = function()
getViewXml: function( graph, scale, cells, x0, y0 )
Returns the visible source or target terminal cell.
mxCellState.prototype.getVisibleTerminal = function( source )
Returns the nearest ancestor terminal that is visible.
mxGraphView.prototype.getVisibleTerminal = function( edge, source )
Helper function to return visible terminal for edge allowing for ports
mxHierarchicalLayout.prototype.getVisibleTerminal = function( edge, source )
Helper function to return visible terminal for edge allowing for ports
mxSwimlaneLayout.prototype.getVisibleTerminal = function( edge, source )
Returns the visible source or target terminal state.
mxCellState.prototype.getVisibleTerminalState = function( source )
Returns wnd.
mxPrintPreview.prototype.getWindow = function()
Gets the value of x on the specified layer
mxGraphAbstractHierarchyCell.prototype.getX = function( layer )
Returns evt.clientX.
mxMouseEvent.prototype.getX = function()
Returns the current position on the x-axis.
mxWindow.prototype.getX = function()
Returns the XML content of the specified node.
getXml: function( node, linefeed )
Returns the response as an XML document.
mxXmlRequest.prototype.getXml = function()
Returns evt.clientY.
mxMouseEvent.prototype.getY = function()
Returns the current position on the y-axis.
mxWindow.prototype.getY = function()
Returns true if the given graph contains the given event.
mxDragSource.prototype.graphContainsEvent = function( graph, evt )
Invoked when the graph model has changed.
mxAutoSaveManager.prototype.graphModelChanged = function( changes )
Called when the graph model changes.
mxGraph.prototype.graphModelChanged = function( changes )
Invokes createGroup to create a new group cell and the invokes mxGraph.groupCells, using the grid size of the graph as the spacing in the group’s content area.
mxEditor.prototype.groupCells = function ()
Adds the cells into the given group.
mxGraph.prototype.groupCells = function( group, border, cells )
Grows the rectangle by the given amount, that is, this method subtracts the given amount from the x- and y-coordinates and adds twice the amount to the width and height.
mxRectangle.prototype.grow = function( amount )