Current File : /home/tjamichg/cursos.tjamich.gob.mx/main/inc/lib/mxgraph/src/js/view/mxLayoutManager.js
/**
* Copyright (c) 2006-2015, JGraph Ltd
* Copyright (c) 2006-2015, Gaudenz Alder
*/
/**
* Class: mxLayoutManager
*
* Implements a layout manager that runs a given layout after any changes to the graph:
*
* Example:
*
* (code)
* var layoutMgr = new mxLayoutManager(graph);
* layoutMgr.getLayout = function(cell)
* {
* return layout;
* };
* (end)
*
* Event: mxEvent.LAYOUT_CELLS
*
* Fires between begin- and endUpdate after all cells have been layouted in
* <layoutCells>. The <code>cells</code> property contains all cells that have
* been passed to <layoutCells>.
*
* Constructor: mxLayoutManager
*
* Constructs a new automatic layout for the given graph.
*
* Arguments:
*
* graph - Reference to the enclosing graph.
*/
function mxLayoutManager(graph)
{
// Executes the layout before the changes are dispatched
this.undoHandler = mxUtils.bind(this, function(sender, evt)
{
if (this.isEnabled())
{
this.beforeUndo(evt.getProperty('edit'));
}
});
// Notifies the layout of a move operation inside a parent
this.moveHandler = mxUtils.bind(this, function(sender, evt)
{
if (this.isEnabled())
{
this.cellsMoved(evt.getProperty('cells'), evt.getProperty('event'));
}
});
this.setGraph(graph);
};
/**
* Extends mxEventSource.
*/
mxLayoutManager.prototype = new mxEventSource();
mxLayoutManager.prototype.constructor = mxLayoutManager;
/**
* Variable: graph
*
* Reference to the enclosing <mxGraph>.
*/
mxLayoutManager.prototype.graph = null;
/**
* Variable: bubbling
*
* Specifies if the layout should bubble along
* the cell hierarchy. Default is true.
*/
mxLayoutManager.prototype.bubbling = true;
/**
* Variable: enabled
*
* Specifies if event handling is enabled. Default is true.
*/
mxLayoutManager.prototype.enabled = true;
/**
* Variable: updateHandler
*
* Holds the function that handles the endUpdate event.
*/
mxLayoutManager.prototype.updateHandler = null;
/**
* Variable: moveHandler
*
* Holds the function that handles the move event.
*/
mxLayoutManager.prototype.moveHandler = null;
/**
* Function: isEnabled
*
* Returns true if events are handled. This implementation
* returns <enabled>.
*/
mxLayoutManager.prototype.isEnabled = function()
{
return this.enabled;
};
/**
* Function: setEnabled
*
* Enables or disables event handling. This implementation
* updates <enabled>.
*
* Parameters:
*
* enabled - Boolean that specifies the new enabled state.
*/
mxLayoutManager.prototype.setEnabled = function(enabled)
{
this.enabled = enabled;
};
/**
* Function: isBubbling
*
* Returns true if a layout should bubble, that is, if the parent layout
* should be executed whenever a cell layout (layout of the children of
* a cell) has been executed. This implementation returns <bubbling>.
*/
mxLayoutManager.prototype.isBubbling = function()
{
return this.bubbling;
};
/**
* Function: setBubbling
*
* Sets <bubbling>.
*/
mxLayoutManager.prototype.setBubbling = function(value)
{
this.bubbling = value;
};
/**
* Function: getGraph
*
* Returns the graph that this layout operates on.
*/
mxLayoutManager.prototype.getGraph = function()
{
return this.graph;
};
/**
* Function: setGraph
*
* Sets the graph that the layouts operate on.
*/
mxLayoutManager.prototype.setGraph = function(graph)
{
if (this.graph != null)
{
var model = this.graph.getModel();
model.removeListener(this.undoHandler);
this.graph.removeListener(this.moveHandler);
}
this.graph = graph;
if (this.graph != null)
{
var model = this.graph.getModel();
model.addListener(mxEvent.BEFORE_UNDO, this.undoHandler);
this.graph.addListener(mxEvent.MOVE_CELLS, this.moveHandler);
}
};
/**
* Function: getLayout
*
* Returns the layout to be executed for the given graph and parent.
*/
mxLayoutManager.prototype.getLayout = function(parent)
{
return null;
};
/**
* Function: beforeUndo
*
* Called from the undoHandler.
*
* Parameters:
*
* cell - Array of <mxCells> that have been moved.
* evt - Mouse event that represents the mousedown.
*/
mxLayoutManager.prototype.beforeUndo = function(undoableEdit)
{
var cells = this.getCellsForChanges(undoableEdit.changes);
var model = this.getGraph().getModel();
// Adds all descendants
var tmp = [];
for (var i = 0; i < cells.length; i++)
{
tmp = tmp.concat(model.getDescendants(cells[i]));
}
cells = tmp;
// Adds all parent ancestors
if (this.isBubbling())
{
tmp = model.getParents(cells);
while (tmp.length > 0)
{
cells = cells.concat(tmp);
tmp = model.getParents(tmp);
}
}
this.executeLayoutForCells(cells);
};
/**
* Function: executeLayout
*
* Executes the given layout on the given parent.
*/
mxLayoutManager.prototype.executeLayoutForCells = function(cells)
{
// Adds reverse to this array to avoid duplicate execution of leafes
// Works like capture/bubble for events, first executes all layout
// from top to bottom and in reverse order and removes duplicates.
var sorted = mxUtils.sortCells(cells, true);
sorted = sorted.concat(sorted.slice().reverse());
this.layoutCells(sorted);
};
/**
* Function: cellsMoved
*
* Called from the moveHandler.
*
* Parameters:
*
* cell - Array of <mxCells> that have been moved.
* evt - Mouse event that represents the mousedown.
*/
mxLayoutManager.prototype.cellsMoved = function(cells, evt)
{
if (cells != null && evt != null)
{
var point = mxUtils.convertPoint(this.getGraph().container,
mxEvent.getClientX(evt), mxEvent.getClientY(evt));
var model = this.getGraph().getModel();
// Checks if a layout exists to take care of the moving if the
// parent itself is not being moved
for (var i = 0; i < cells.length; i++)
{
var parent = model.getParent(cells[i]);
if (mxUtils.indexOf(cells, parent) < 0)
{
var layout = this.getLayout(parent);
if (layout != null)
{
layout.moveCell(cells[i], point.x, point.y);
}
}
}
}
};
/**
* Function: getCellsForEdit
*
* Returns the cells to be layouted for the given sequence of changes.
*/
mxLayoutManager.prototype.getCellsForChanges = function(changes)
{
var dict = new mxDictionary();
var result = [];
for (var i = 0; i < changes.length; i++)
{
var change = changes[i];
if (change instanceof mxRootChange)
{
return [];
}
else
{
var cells = this.getCellsForChange(change);
for (var j = 0; j < cells.length; j++)
{
if (cells[j] != null && !dict.get(cells[j]))
{
dict.put(cells[j], true);
result.push(cells[j]);
}
}
}
}
return result;
};
/**
* Function: getCellsForChange
*
* Executes all layouts which have been scheduled during the
* changes.
*/
mxLayoutManager.prototype.getCellsForChange = function(change)
{
var model = this.getGraph().getModel();
if (change instanceof mxChildChange)
{
return [change.child, change.previous, model.getParent(change.child)];
}
else if (change instanceof mxTerminalChange || change instanceof mxGeometryChange)
{
return [change.cell, model.getParent(change.cell)];
}
else if (change instanceof mxVisibleChange || change instanceof mxStyleChange)
{
return [change.cell];
}
return [];
};
/**
* Function: layoutCells
*
* Executes all layouts which have been scheduled during the
* changes.
*/
mxLayoutManager.prototype.layoutCells = function(cells)
{
if (cells.length > 0)
{
// Invokes the layouts while removing duplicates
var model = this.getGraph().getModel();
model.beginUpdate();
try
{
var last = null;
for (var i = 0; i < cells.length; i++)
{
if (cells[i] != model.getRoot() && cells[i] != last)
{
if (this.executeLayout(this.getLayout(cells[i]), cells[i]))
{
last = cells[i];
}
}
}
this.fireEvent(new mxEventObject(mxEvent.LAYOUT_CELLS, 'cells', cells));
}
finally
{
model.endUpdate();
}
}
};
/**
* Function: executeLayout
*
* Executes the given layout on the given parent.
*/
mxLayoutManager.prototype.executeLayout = function(layout, parent)
{
var result = false;
if (layout != null && parent != null)
{
layout.execute(parent);
result = true;
}
return result;
};
/**
* Function: destroy
*
* Removes all handlers from the <graph> and deletes the reference to it.
*/
mxLayoutManager.prototype.destroy = function()
{
this.setGraph(null);
};
Mini Shell