| /** |
| * Copyright (c) 2006-2015, JGraph Ltd |
| * Copyright (c) 2006-2015, Gaudenz Alder |
| */ |
| var mxCellPath = |
| { |
| |
| /** |
| * Class: mxCellPath |
| * |
| * Implements a mechanism for temporary cell Ids. |
| * |
| * Variable: PATH_SEPARATOR |
| * |
| * Defines the separator between the path components. Default is ".". |
| */ |
| PATH_SEPARATOR: '.', |
| |
| /** |
| * Function: create |
| * |
| * Creates the cell path for the given cell. The cell path is a |
| * concatenation of the indices of all ancestors on the (finite) path to |
| * the root, eg. "0.0.0.1". |
| * |
| * Parameters: |
| * |
| * cell - Cell whose path should be returned. |
| */ |
| create: function(cell) |
| { |
| var result = ''; |
| |
| if (cell != null) |
| { |
| var parent = cell.getParent(); |
| |
| while (parent != null) |
| { |
| var index = parent.getIndex(cell); |
| result = index + mxCellPath.PATH_SEPARATOR + result; |
| |
| cell = parent; |
| parent = cell.getParent(); |
| } |
| } |
| |
| // Removes trailing separator |
| var n = result.length; |
| |
| if (n > 1) |
| { |
| result = result.substring(0, n - 1); |
| } |
| |
| return result; |
| }, |
| |
| /** |
| * Function: getParentPath |
| * |
| * Returns the path for the parent of the cell represented by the given |
| * path. Returns null if the given path has no parent. |
| * |
| * Parameters: |
| * |
| * path - Path whose parent path should be returned. |
| */ |
| getParentPath: function(path) |
| { |
| if (path != null) |
| { |
| var index = path.lastIndexOf(mxCellPath.PATH_SEPARATOR); |
| |
| if (index >= 0) |
| { |
| return path.substring(0, index); |
| } |
| else if (path.length > 0) |
| { |
| return ''; |
| } |
| } |
| |
| return null; |
| }, |
| |
| /** |
| * Function: resolve |
| * |
| * Returns the cell for the specified cell path using the given root as the |
| * root of the path. |
| * |
| * Parameters: |
| * |
| * root - Root cell of the path to be resolved. |
| * path - String that defines the path. |
| */ |
| resolve: function(root, path) |
| { |
| var parent = root; |
| |
| if (path != null) |
| { |
| var tokens = path.split(mxCellPath.PATH_SEPARATOR); |
| |
| for (var i=0; i<tokens.length; i++) |
| { |
| parent = parent.getChildAt(parseInt(tokens[i])); |
| } |
| } |
| |
| return parent; |
| }, |
| |
| /** |
| * Function: compare |
| * |
| * Compares the given cell paths and returns -1 if p1 is smaller, 0 if |
| * p1 is equal and 1 if p1 is greater than p2. |
| */ |
| compare: function(p1, p2) |
| { |
| var min = Math.min(p1.length, p2.length); |
| var comp = 0; |
| |
| for (var i = 0; i < min; i++) |
| { |
| if (p1[i] != p2[i]) |
| { |
| if (p1[i].length == 0 || |
| p2[i].length == 0) |
| { |
| comp = (p1[i] == p2[i]) ? 0 : ((p1[i] > p2[i]) ? 1 : -1); |
| } |
| else |
| { |
| var t1 = parseInt(p1[i]); |
| var t2 = parseInt(p2[i]); |
| |
| comp = (t1 == t2) ? 0 : ((t1 > t2) ? 1 : -1); |
| } |
| |
| break; |
| } |
| } |
| |
| // Compares path length if both paths are equal to this point |
| if (comp == 0) |
| { |
| var t1 = p1.length; |
| var t2 = p2.length; |
| |
| if (t1 != t2) |
| { |
| comp = (t1 > t2) ? 1 : -1; |
| } |
| } |
| |
| return comp; |
| } |
| |
| }; |