| G | |
| geometryForCellChanged, mxGraphModel | |
| get | |
| getAlignmentTolerance, mxConnectionHandler | |
| getAllConnectionConstraints, mxGraph | |
| getAllEdges, mxGraph | |
| getAttribute, mxCell | |
| getAttributeName, mxObjectCodec | |
| getBackgroundBounds, mxImageExport | |
| getBackgroundImage, mxGraph | |
| getBackgroundPageBounds, mxGraphView | |
| getBackgroundPane, mxGraphView | |
| getBaseDomain, mxUrlConverter | |
| getBaseUrl, mxUrlConverter | |
| getBorder, mxGraph | |
| getBorderSizes, mxGraph | |
| getBoundingBox, mxUtils | |
| getBoundingBoxFromGeometry, mxGraph | |
| getBounds | |
| getBoundsForGroup, mxGraph | |
| getCanvas, mxGraphView | |
| getCell | |
| getCellAt, mxGraph | |
| getCellBounds, mxGraph | |
| getCellContainmentArea, mxGraph | |
| getCellForPopupEvent, mxPanningHandler | |
| getCellGeometry, mxGraph | |
| getCellOverlays, mxGraph | |
| getCells | |
| getCellsBeyond, mxGraph | |
| getCellsForChange, mxLayoutManager | |
| getCellsForEdit, mxLayoutManager | |
| getCellsForGroup, mxGraph | |
| getCellStates, mxGraphView | |
| getCellsToShift, mxSpaceManager | |
| 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 | |
| getConverter | |
| getCoreCell | |
| getCurrentRoot, mxGraph | |
| getCurrentStyle, mxUtils | |
| getCurrentValue, mxCellEditor | |
| getCursor, mxShape | |
| getCursorForBend, mxElbowEdgeHandler | |
| getCursorForCell, mxGraph | |
| getDefaultBundle, mxResources | |
| getDefaultEdgeStyle, mxStylesheet | |
| getDefaultParent, mxGraph | |
| getDefaultVertexStyle, mxStylesheet | |
| getDeletableCells, mxGraph | |
| getDelta, mxMorphing | |
| getDescendants, mxGraphModel | |
| getDirectedEdgeCount, mxGraphModel | |
| getDocType, mxPrintPreview | |
| getDocument, mxXmlCanvas2D | |
| getDocumentElement, mxXmlRequest | |
| getDocumentHeight, mxDivResizer | |
| getDocumentWidth, mxDivResizer | |
| getDrawPane, mxGraphView | |
| getDropTarget | |
| getEdgeAt | |
| getEdgeColor, mxConnectionHandler | |
| getEdgeCount | |
| getEdgeId, mxParallelEdgeLayout | |
| getEdgeIndex, mxCell | |
| getEdges | |
| getEdgesBetween | |
| getEdgeStyle | |
| getEdgeValidationError, mxGraph | |
| getEdgeWidth, mxConnectionHandler | |
| getEditingCell, mxCellEditor | |
| getEditingValue, mxGraph | |
| getEditorBounds, mxCellEditor | |
| getElement, mxWindow | |
| getElementById, mxCodec | |
| getEmptyLabelText, mxCellEditor | |
| getEvent, mxMouseEvent | |
| getEventSource, mxEventSource | |
| getExportableCells, mxGraph | |
| getFieldName, mxObjectCodec | |
| getFieldTemplate, mxObjectCodec | |
| getFirstSelectableCell, mxGraphSelectionModel | |
| getFoldableCells, mxGraph | |
| getFoldingImage, mxGraph | |
| getFunction, mxKeyHandler | |
| getFunctionName, mxUtils | |
| getGeneralPurposeVariable | |
| getGeometry | |
| getGradientId, mxShape | |
| getGraph | |
| getGraphBounds | |
| getGraphForEvent, mxDragSource | |
| getGraphX, mxMouseEvent | |
| getGraphY, mxMouseEvent | |
| getGridSize, mxGraph | |
| getGuideStates, mxGraphHandler | |
| getGuideTolerance, mxGuide | |
| getHandleFillColor, mxEdgeHandler | |
| getHandleForEvent | |
| getHandler, mxSelectionCellsHandler | |
| getHotspot, mxCellMarker | |
| getId | |
| getImage | |
| getImageBounds, mxImageExport | |
| getImageForConstraint, mxConstraintHandler | |
| getImageFromBundles, mxGraph | |
| getImportableCells, mxGraph | |
| getIncomingEdges | |
| getIndex, mxCell | |
| getIndicatorColor, mxGraph | |
| getIndicatorGradientColor, mxGraph | |
| getIndicatorImage, mxGraph | |
| getIndicatorShape, mxGraph | |
| getInitialCellForEvent, mxGraphHandler | |
| getInitialValue, mxCellEditor | |
| getInnerHtml, mxUtils | |
| getKeys, mxDictionary | |
| getLabel, mxGraph | |
| getLabelBounds, mxCellRenderer | |
| getLabelValue, mxCellRenderer | |
| getLayout, mxLayoutManager | |
| getMainEvent, mxEvent | |
| getMarkedState, mxCellMarker | |
| getMarkerColor, mxCellMarker | |
| getMaximumGraphBounds, mxGraph | |
| getMinimumSize | |
| getModel | |
| getMovableCells, mxGraph | |
| getName | |
| getNearestCommonAncestor, mxGraphModel | |
| getNextLayerConnectedCells | |
| getNextPoint, mxGraphView | |
| getNumber, mxUtils | |
| getObject, mxCodec | |
| getOffset | |
| getOpposites | |
| getOrigin, mxGraphModel | |
| getOriginForCell, mxMorphing | |
| getOuterHtml, mxUtils | |
| getOutgoingEdges | |
| getOutlineOffset, mxOutline | |
| getOverlap, mxGraph | |
| getOverlayPane, mxGraphView | |
| getParent | |
| getParentOffset, mxGraphLayout | |
| getParentPath, mxCellPath | |
| getParents, mxGraphModel | |
| getParentSize, mxStackLayout | |
| getPath, mxPath | |
| getPerimeterBounds | |
| getPerimeterFunction, mxGraphView | |
| getPerimeterPoint, mxGraphView | |
| getPoint | |
| getPointForEvent | |
| 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, mxGraphModel | |
| getRootTitle, mxEditor | |
| getRotatedPoint, mxUtils | |
| getRotation, mxShape | |
| 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 | |
| getShapeConstructor, mxCellRenderer | |
| getSizeForString, mxUtils | |
| getSnapToTerminalTolerance, mxEdgeHandler | |
| getSource | |
| getSourceContainerSize, mxOutline | |
| getSourcePerimeterPoint, mxConnectionHandler | |
| getSpacing, mxText | |
| getSpecialBundle, mxResources | |
| getStartSize, mxGraph | |
| getState | |
| getStates, mxGraphView | |
| getStateToMark, mxCellMarker | |
| getStatus, mxXmlRequest | |
| getStencil, mxStencilRegistry | |
| getStringValue, mxStylesheetCodec | |
| getStyle | |
| getStylename, mxUtils | |
| getStylenames, mxUtils | |
| getStylesheet, mxGraph | |
| getSvgClip, mxText | |
| getSvgShadowTransform, mxShape | |
| getSwimlane, mxGraph | |
| getSwimlaneAt, mxGraph | |
| getTable, mxForm | |
| getTableSize, mxText | |
| getTargetPerimeterPoint, mxConnectionHandler | |
| getTemplate, mxEditor | |
| getTerminal | |
| getTerminalForPort, mxGraph | |
| getTerminalPoint, mxGeometry | |
| getTerminalPort, mxGraphView | |
| getText, mxXmlRequest | |
| getTextContent, mxUtils | |
| getTextScale, mxCellRenderer | |
| getTitle, mxEditor | |
| getTolerance | |
| getTooltip, mxGraph | |
| getTooltipForCell, mxGraph | |
| getTooltipForNode, mxElbowEdgeHandler | |
| getTopmostCells, mxGraphModel | |
| getTranslate, mxGraphView | |
| getTranslateForRoot, mxGraph | |
| getUrlImage, mxEditor | |
| getUrlPost, mxEditor | |
| getValidState, mxCellMarker | |
| getValue | |
| getValues, mxDictionary | |
| getVertexBounds, mxGraphLayout | |
| getVerticalAlign, mxGraph | |
| getVerticalOffset, mxText | |
| getView, mxGraph | |
| getViewXml, mxUtils | |
| getVisibleTerminal | |
| getVisibleTerminalState, mxCellState | |
| 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 object id for the given object.
get: function( obj )
Returns the value for the specified resource key.
get: function( key, params, defaultValue )
Sends an asynchronous get request to the given URL, fires a get event and invokes the given onLoad function when a response is received.
mxSession.prototype.get = function( url, onLoad, onError )
Loads the specified URL asynchronously and invokes the given functions depending on the request status.
get: function( url, onload, onerror )
Returns the tolerance for aligning new targets to sources.
mxConnectionHandler.prototype.getAlignmentTolerance = function()
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 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 )
Draws the given state to the given canvas.
mxImageExport.prototype.getBackgroundBounds = 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.
getBaseDomain: function()
Returns baseUrl.
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 rotated rectangle.
getBoundingBox: function( rect, rotation )
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 bounds (on the screen) 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 overlaypane.
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()
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 )
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 )
Hook to return the cell for the mouse up popup trigger handling.
mxPanningHandler.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 children of the given parent that are contained in the given rectangle (x, y, width, height).
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 and/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 the cells to shift after a resize of the specified mxCellState.
mxSpaceManager.prototype.getCellsToShift = function( state )
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 )
Returns converter.
getConverter: function()
Returns converter.
getConverter: function()
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 current root of the displayed cell hierarchy.
mxGraph.prototype.getCurrentRoot = function()
Returns the current style of the specified element.
getCurrentStyle: function()
Returns the current editing value.
mxCellEditor.prototype.getCurrentValue = function()
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 )
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 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 )
Returns the number of incoming or outgoing edges, ignoring the given edge.
mxGraphModel.prototype.getDirectedEdgeCount = function( cell, outgoing, ignoredEdge )
Returns the owner document of the root element.
getDocument: function()
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()
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 )
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 )
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 color used to draw the preview edge.
mxConnectionHandler.prototype.getEdgeColor = function( valid )
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 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 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 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, attr )
Returns the initial label value to be used of the label of the given cell is empty.
mxCellEditor.prototype.getEmptyLabelText = function ( cell )
Returns evt.
mxMouseEvent.prototype.getEvent = function()
Returns eventSource.
mxEventSource.prototype.getEventSource = function()
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 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, geometry )
Creates a unique ID for the gradient of this shape.
mxShape.prototype.getGradientId = function( start, end )
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 layout operates on.
mxSpaceManager.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 )
Draws the given state to the given canvas.
mxImageExport.prototype.getImageBounds = function( state )
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 )
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 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 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 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 description of the space between the bounds size and the label size as an mxPoint.
mxText.prototype.getOffset = function( outerWidth, outerHeight, actualWidth, actualHeight, horizontal )
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 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 topmost drawing layer.
mxGraphView.prototype.getOverlayPane = 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 string that represents the path in format.
mxPath.prototype.getPath = function()
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 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 )
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( point )
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 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 current rotation including direction.
mxShape.prototype.getRotation = 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 )
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 constructor to be used for creating the shape.
mxCellRenderer.prototype.getShapeConstructor = function( state )
Returns an mxRectangle with the size (width and height in pixels) of the given string.
getSizeForString: function( text, fontSize, fontFamily )
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( horizontal )
Hook for subclassers to return the URL for the special bundle.
getSpecialBundle: function( basename, lan )
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 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()
Returns a new or existing SVG clip path which is a descendant of the given SVG node with a unique ID.
mxText.prototype.getSvgClip = function( svg, x, y, w, h )
Returns the current transformation for SVG shadows.
mxShape.prototype.getSvgShadowTransform = function( node, shadow )
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 actual size of the table.
mxText.prototype.getTableSize = function( table )
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 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()
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 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 translate.
mxGraphView.prototype.getTranslate = function()
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 factors for the offset to be added to the text vertical text rotation.
mxText.prototype.getVerticalOffset = function( offset )
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 )
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 )