| N | |
| notify | |
| O | |
| offset, mxCompactTreeLayout | |
| onEncode, mxRootChangeCodec | |
| onInit | |
| open | |
| order, mxCellRenderer | |
| orderCells, mxGraph | |
| orderEdge, mxCellRenderer | |
| OrthConnector, mxEdgeStyle | |
| outline, mxOutline | |
| P | |
| paintMarker, mxMarker | |
| panGraph | |
| para, mxUtils | |
| parentForCellChanged, mxGraphModel | |
| parse, mxResources | |
| parseConstraint, mxStencil | |
| parseConstraints, mxStencil | |
| parseDescription, mxStencil | |
| parseXml, mxUtils | |
| paste, mxClipboard | |
| placeLabels, mxEdgeLabelLayout | |
| placementStage, mxHierarchicalLayout | |
| poll, mxSession | |
| popup | |
| post, mxUtils | |
| postConfigureShape, mxCellRenderer | |
| postDiagram, mxEditor | |
| postProcessCellStyle, mxGraph | |
| print, mxPrintPreview | |
| printScreen, mxUtils | |
| process, mxCellMarker | |
| processChange, mxGraph | |
| processDelta, mxSession | |
| processEdit, mxSession | |
| processInclude, mxObjectCodec | |
| processReversedEdge, mxCoordinateAssignment | |
| processState, mxSession | |
| prompt, mxUtils | |
| ptSeqDistSq, mxUtils | |
| put, mxDictionary | |
| putCellStyle, mxStylesheet | |
| putDefaultEdgeStyle, mxStylesheet | |
| putDefaultVertexStyle, mxStylesheet | |
| putImage, mxImageBundle | |
| putObject, mxCodec | |
| putValue, mxStyleRegistry | |
| Q | |
| quadTo |
Sends out the specified XML to urlNotify and fires a notify event.
mxSession.prototype.notify = function( xml, onLoad, onError )
Hook to notify any listeners of the changes after an undo or redo has been carried out.
mxUndoableEdit.prototype.notify = function()
mxCompactTreeLayout.prototype.offset = function( p1, p2, a1, a2, b1, b2 )
Opens the specified file synchronously and parses it using readGraphModel.
mxEditor.prototype.open = function ( filename )
Shows the print preview window.
mxPrintPreview.prototype.open = function( css )
Opens the specified file from the local filesystem and returns the contents of the file as a string.
open: function( filename )
Orders the DOM node of the shape for the given state according to the position of the corresponding cell in the graph model.
mxCellRenderer.prototype.order = function( state )
Moves the given cells to the front or back.
mxGraph.prototype.orderCells = function( back, cells )
Orders the DOM node of the shape for the given edge’s state according to the mxGraph.keepEdgesInBackground and mxGraph.keepEdgesInBackground rules.
mxCellRenderer.prototype.orderEdge = function( state )
Implements a local orthogonal router between the given cells.
OrthConnector: function( state, source, target, points, result )
Paints the given marker.
paintMarker: function( node, type, p0, pe, color, strokewidth, size, scale, x0, y0, source, style )
Shifts the graph display by the given amount.
mxGraph.prototype.panGraph = function( dx, dy )
Pans graph by the given amount.
mxPanningHandler.prototype.panGraph = function( dx, dy )
Appends a new paragraph with the given text to the specified parent and returns the paragraph.
para: function( parent, text )
Inner callback to update the parent of a cell using mxCell.insert on the parent and return the previous parent.
mxGraphModel.prototype.parentForCellChanged = function( cell, parent, index )
Parses the key, value pairs in the specified text and stores them as local resources.
parse: function( text )
Parses the given XML node and returns its mxConnectionConstraint.
mxStencil.prototype.parseConstraint = function( node )
Reads the constraints from desc into constraints using parseConstraint.
mxStencil.prototype.parseConstraints = function()
Reads w0, h0, aspect, bgNodes and fgNodes from desc.
mxStencil.prototype.parseDescription = function()
Parses the specified XML string into a new XML document and returns the new document.
parseXml: function()
Pastes the cells into the specified graph restoring the relation to parents, if possible.
paste: function( graph )
Places the labels of the given edges.
mxEdgeLabelLayout.prototype.placeLabels = function( v, e )
Executes the placement stage using mxCoordinateAssignment.
mxHierarchicalLayout.prototype.placementStage = function( initialX, parent )
Sends an asynchronous GET request to urlPoll.
mxSession.prototype.poll = function()
Shows the popup menu for the given event and cell.
mxPopupMenu.prototype.popup = function( x, y, cell, evt )
Shows the specified text content in a new mxWindow or a new browser window if isInternalWindow is false.
popup: function( content, isInternalWindow )
Posts the specified params to the given URL asynchronously and invokes the given functions depending on the request status.
post: function( url, params, onload, onerror )
Replaces any reserved words used for attributes, eg.
mxCellRenderer.prototype.postConfigureShape = function( state )
Hook for subclassers to override the posting of a diagram represented by the given node to the given URL.
mxEditor.prototype.postDiagram = function ( url, data )
Tries to resolve the value for the image style in the image bundles and turns short data URIs as defined in mxImageBundle to data URIs as defined in RFC 2397 of the IETF.
mxGraph.prototype.postProcessCellStyle = function( style )
Opens the print preview and shows the print dialog.
mxPrintPreview.prototype.print = function()
Prints the specified graph using a new window and the built-in print dialog.
printScreen: function( graph )
Processes the given event and cell and marks the state returned by getState with the color returned by getMarkerColor.
mxCellMarker.prototype.process = function( me )
Processes the given change and invalidates the respective cached data in view.
mxGraph.prototype.processChange = function( change )
Processes the given delta node which contains a sequence of edits which in turn map to one transaction on the remote model each.
mxSession.prototype.processDelta = function( node )
Processes the given edit by executing its changes and firing the required events via the model.
mxSession.prototype.processEdit = function( node )
Returns true if the given node is an include directive and executes the include by decoding the XML document.
mxObjectCodec.prototype.processInclude = function( dec, node, into )
Hook to add additional processing
mxCoordinateAssignment.prototype.processReversedEdge = function( graph, model )
Processes the given state node which contains the current state of the remote model.
mxSession.prototype.processState = function( node )
Displays the given message in a prompt dialog.
prompt: function( message, defaultValue )
Stores the value under the given key and returns the previous value for that key.
mxDictionary.prototype.put = function( key, value )
Stores the given map of key, value pairs under the given name in styles.
mxStylesheet.prototype.putCellStyle = function( name, style )
Sets the default style for edges using defaultEdge as the stylename.
mxStylesheet.prototype.putDefaultEdgeStyle = function( style )
Sets the default style for vertices using defaultVertex as the stylename.
mxStylesheet.prototype.putDefaultVertexStyle = function( style )
Adds the specified entry to the map.
mxImageBundle.prototype.putImage = function( key, value, fallback )
Assoiates the given object with the given ID and returns the given object.
mxCodec.prototype.putObject = function( id, obj )
Puts the given object into the registry under the given name.
putValue: function( name, obj )
Draws a quadratic Bézier curve from the current point to (x, y) using (x1, y1) as the control point.
mxPath.prototype.quadTo = function( x1, y1, x, y )
Adds a quadratic curve to the current path.
quadTo: function( x1, y1, x2, y2 )
Adds a quadratic curve to the current path.
quadTo: function( x1, y1, x2, y2 )