{

/**

var $model;

/**

var $stylesheet;

/**

var $view;

/**

var $gridSize = 10;

/**

var $labelsVisible = true;

/**

var $defaultLoopStyle = "mxEdgeStyle.Loop";

/**

protected $imageBundles = array();

/**

function mxGraph($model = null, $stylesheet = null)

{

$this->model = ($model != null) ? $model : new mxGraphModel();

$this->stylesheet = ($stylesheet != null) ? $stylesheet : $this->createStylesheet();

$this->view = $this->createGraphView();

$this->view->revalidate();

$this->model->addListener(mxEvent::$GRAPH_MODEL_CHANGED, $this);

}

/**

function createStylesheet()

{

return new mxStylesheet();

}

/**

function createGraphView()

{

return new mxGraphView($this);

}

/**

function getModel()

{

return $this->model;

}

/**

function getStylesheet()

{

return $this->stylesheet;

}

/**

function getView()

{

return $this->view;

}

/**

function getDefaultParent()

{

$model = $this->model;

return $model->getChildAt($model->getRoot(), 0);

}

/**

function convertValueToString($cell)

{

$result = $this->model->getValue($cell);

return ($result != null) ? $result : "";

}

/**

function getLabel($cell)

{

$result = "";

if ($cell != null)

{

$state = $this->view->getState($cell);

$style = ($state != null) ?

$state->style : $this->getCellStyle($cell);

if ($this->labelsVisible &&

!mxUtils::getValue($style, mxConstants::$STYLE_NOLABEL, false))

{

$result = $this->convertValueToString($cell);

}

}

return $result;

}

/**

function getChildOffsetForCell($cell)

{

return null;

}

/**

function isOrthogonal($edge)

{

if (isset($edge->style[mxConstants::$STYLE_ORTHOGONAL]))

{

return mxUtils::getValue($edge->style, mxConstants::$STYLE_ORTHOGONAL);

}

$edgeStyle = $this->view->getEdgeStyle($edge, null, null, null);

return $edgeStyle === mxEdgeStyle::$ElbowConnector ||

$edgeStyle === mxEdgeStyle::$SideToSide ||

$edgeStyle === mxEdgeStyle::$TopToBottom ||

$edgeStyle === mxEdgeStyle::$EntityRelation;

}

/**

function isCellVisible($cell)

{

return $this->model->isVisible($cell);

}

/**

function isCellCollapsed($cell)

{

return $this->model->isCollapsed($cell);

}

/**

function isCellConnectable($cell)

{

return $this->model->isConnectable($cell);

}

/**

function getCellGeometry($cell)

{

return $this->model->getGeometry($cell);

}

/**

function getCellStyle($cell)

{

$style = ($this->model->isVertex($cell)) ?

$this->stylesheet->getDefaultVertexStyle() :

$this->stylesheet->getDefaultEdgeStyle();

$name = $this->model->getStyle($cell);

if ($name != null)

{

$style = $this->postProcessCellStyle($this->stylesheet->getCellStyle($name, $style));

}

if ($style == null)

{

$style = array();

}

return $style;

}

/**

function postProcessCellStyle($style)

{

if (isset($style) && array_key_exists(mxConstants::$STYLE_IMAGE, $style))

{

$key = $style[mxConstants::$STYLE_IMAGE];

$image = $this->getImageFromBundles($key);

if (isset($image))

{

$style[mxConstants::$STYLE_IMAGE] = $image;

}

else

{

$image = $key;

}

// Converts short data uris to normal data uris

if (isset($image) && substr($image, 0, 11) == "data:image/")

{

$comma = strpos($image, ",");

if ($comma !== false)

{

$image = substr($image, 0, $comma).";base64,".

substr($image, $comma + 1);

}

$style[mxConstants::$STYLE_IMAGE] = $image;

}

}

return $style;

}

/**

function setCellStyles($key, $value, $cells)

{

mxUtils::setCellStyles($this->model, $cells, $key, $value);

}

/**

function addImageBundle($bundle)

{

array_push($this->imageBundles, $bundle);

}

/**

function removeImageBundle($bundle)

{

$tmp = array();

for ($i = 0; $i < sizeof($this->imageBundles); $i++)

{

if ($this->imageBundles[$i] !== $bundle)

{

array_push($tmp, $this->imageBundles[$i]);

}

}

$this->imageBundles = $tmp;

}

/**

function getImageFromBundles($key)

{

if (isset($key))

{

for ($i = 0; $i < sizeof($this->imageBundles); $i++)

{

$image = $this->imageBundles[$i]->getImage($key);

if (isset($image))

{

return $image;

}

}

}

return null;

}

/**

function getImageBundles()

{

return $this->imageBundles;

}

/**

function setImageBundles($value)

{

$this->imageBundles = $value;

}

/**

function insertVertex($parent, $id = null, $value = null, $x = 0, $y = 0,

$width = 1, $height = 1, $style = null, $relative = false)

{

if ($parent == null)

{

$parent = $this->getDefaultParent();

}

$vertex = $this->createVertex($parent, $id, $value, $x, $y, $width, $height, $style, $relative);

$index = $this->model->getChildCount($parent);

return $this->model->add($parent, $vertex, $index);

}

/**

function createVertex($parent, $id = null, $value = null, $x = 0, $y = 0,

$width = 1, $height = 1, $style = null, $relative = false)

{

$geometry = new mxGeometry($x, $y, $width, $height);

$geometry->relative = $relative;

$vertex = new mxCell($value, $geometry, $style);

$vertex->setId($id);

$vertex->setVertex(true);

return $vertex;

}

/**

function insertEdge($parent, $id = null, $value = null,

$source = null, $target = null, $style = null)

{

if ($parent == null)

{

$parent = $this->getDefaultParent();

}

$edge = $this->createEdge($parent, $id, $value, $source, $target, $style);

// Appends the edge to the given parent and sets

// the edge terminals in a single transaction

$index = $this->model->getChildCount($parent);

$this->model->beginUpdate();

try

{

$edge = $this->model->add($parent, $edge, $index);

$this->model->setTerminal($edge, $source, true);

$this->model->setTerminal($edge, $target, false);

}

catch (Exception $e)

{

$this->model->endUpdate();

throw($e);

}

$this->model->endUpdate();

return $edge;

}

/**

function createEdge($parent, $id = null, $value = null,

$source = null, $target = null, $style = null)

{

$geometry = new mxGeometry();

$edge = new mxCell($value, $geometry, $style);

$edge->setId($id);

$edge->setEdge(true);

$edge->geometry->relative = true;

return $edge;

}

/**

function getGraphBounds()

{

return $this->getView()->getGraphBounds();

}

/**

function getBoundingBox($cell, $includeEdges = false, $includeDescendants = false)

{

return $this->getCellBounds($cell, $includeEdges, $includeDescendants, true);

}

/**

function getPaintBounds($cells)

{

return $this->getBoundsForCells($cells, false, true, true);

}

/**

function getBoundsForCells($cells, $includeEdges = false, $includeDescendants = false, $boundingBox = false)

{

$cellCount = sizeof($cells);

$result = null;

if ($cellCount > 0)

{

for ($i = 0; $i < $cellCount; $i++)

{

$bounds = $this->getCellBounds($cells[$i], $includeEdges,

$includeDescendants, $boundingBox);

if ($bounds != null)

{

if ($result == null)

{

$result = new mxRectangle($bounds->x, $bounds->y,

$bounds->width, $bounds->height);

}

else

{

$result->add($bounds);

}

}

}

}

return $result;

}

/**

function getCellBounds($cell, $includeEdges = false, $includeDescendants = false, $boundingBox = false)

{

$cells = array($cell);

// Includes the connected edges

if ($includeEdges)

{

$edgeCount = $this->model->getEdgeCount($cell);

for ($i = 0; $i < $edgeCount; $i++)

{

array_push($cells, $this->model->getEdgeAt($cell, $i));

}

}

$result = $this->view->getBounds($cells, $boundingBox);

// Recursively includes the bounds of the children

if ($includeDescendants)

{

for ($i = 0; $i < sizeof($cells); $i++)

{

$childCount = $this->model->getChildCount($cells[$i]);

for ($j = 0; $j < $childCount; $j++)

{

$tmp = $this->getCellBounds($this->model->getChildAt($cells[$i], $j),

$includeEdges, true, $boundingBox);

if ($result != null)

{

$result->add($tmp);

}

else

{

$result = $tmp;

}

}

}

}

return $result;

}

/**

function getConnectionConstraint($edge, $terminal, $source)

{

$point = null;

$x = mxUtils::getValue($edge->style,

($source) ? mxConstants::$STYLE_EXIT_X :

mxConstants::$STYLE_ENTRY_X);

if (isset($x))

{

$y = mxUtils::getValue($edge->style,

(($source) ? mxConstants::$STYLE_EXIT_Y :

mxConstants::$STYLE_ENTRY_Y));

if (isset($y))

{

$point = new mxPoint($x, $y);

}

}

$perimeter = false;

if (isset($point))

{

$perimeter = mxUtils::getValue($edge->style, ($source) ?

mxConstants::$STYLE_EXIT_PERIMETER :

mxConstants::$STYLE_ENTRY_PERIMETER, true);

}

return new mxConnectionConstraint($point, $perimeter);

}

/**

function getConnectionPoint($vertex, $constraint)

{

$point = null;

if (isset($vertex) && isset($constraint->point))

{

$point = new mxPoint($vertex->x + $constraint->point->x * $vertex->width,

$vertex->y + $constraint->point->y * $vertex->height);

}

if (isset($point) && $constraint->perimeter)

{

$point = $this->view->getPerimeterPoint($vertex, $point, false);

}

return $point;

}

/**

function findTreeRoots($parent, $isolate = false, $invert = false)

{

$roots = array();

if ($parent != null)

{

$model = $this->getModel();

$childCount = $model->getChildCount($parent);

$maxDiff = 0;

for ($i=0; $i<$childCount; $i++)

{

$cell = $model->getChildAt($parent, $i);

if ($this->model->isVertex($cell) &&

$this->isCellVisible($cell))

{

$edgeCount = $model->getEdgeCount($cell);

$fanOut = 0;

$fanIn = 0;

for ($j = 0; $j < $edgeCount; $j++)

{

$edge = $model->getEdgeAt($cell, $j);

if ($this->isCellVisible($edge))

{

$source = $this->view->getVisibleTerminal($edge, true);

$target = $this->view->getVisibleTerminal($edge, false);

if ($source !== $target)

{

if ($source === $cell && (!$isolate ||

$this->model->getParent(target) == $parent))

{

$fanOut++;

}

else if (!$isolate ||

$this->model->getParent(source) == $parent)

{

$fanIn++;

}

}

}

}

if (($invert && $fanOut == 0 && $fanIn > 0) ||

(!$invert && $fanIn == 0 && $fanOut > 0))

{

array_push($roots, $cell);

}

$diff = ($invert) ? $fanIn - $fanOut : $fanOut - $fanIn;

if ($diff > $maxDiff)

{

$maxDiff = $diff;

$best = $cell;

}

}

}

if (sizeof($roots) == 0 && $best != null)

{

array_push($roots, $best);

}

}

return $roots;

}

/**

function createImage($clip = null, $background = null)

{

return mxGdCanvas::drawGraph($this, $clip, $background);

}

/**

function drawGraph($canvas)

{

$this->drawCell($canvas, $this->model->getRoot());

}

/**

function drawCell($canvas, $cell)

{

$this->drawState($canvas, $this->view->getState($cell),

$this->getLabel($cell));

// Draws the children on top

$childCount = $cell->getChildCount();

for ($i = 0; $i < $childCount; $i++)

{

$child = $cell->getChildAt($i);

$this->drawCell($canvas, $child);

}

}

/**

function drawState($canvas, $state, $label)

{

$cell = (isset($state)) ? $state->cell : null;

if ($cell != null && $cell !== $this->model->getRoot() &&

($this->model->isVertex($cell) || $this->model->isEdge($cell)))

{

$canvas->drawCell($state);

if ($label != null && $state->labelBounds != null)

{

$canvas->drawLabel($label, $state, false);

}

}

}

/**

function graphModelChanged($event)

{

$this->view->revalidate();

}