{

/**

var $EMPTY_POINT;

/**

var $graph;

/**

var $graphBounds;

/**

var $scale = 1;

/**

var $translate;

/**

var $states = array();

/**

function mxGraphView($graph)

{

$this->EMPTY_POINT = new mxPoint();

$this->graph = $graph;

$this->translate = new mxPoint();

$this->graphBounds = new mxRectangle();

}

/**

function setScale($scale)

{

$previous = $this->scale;

if ($this->scale != $scale)

{

$this->scale = $scale;

$this->revalidate();

}

$this->fireEvent(new mxEventObject(mxEvent::$SCALE, "scale", $scale, "previousScale", $previous));

}

/**

function setTranslate($translate)

{

$previous = $this->translate;

if ($this->translate->x != $translate->x ||

$this->translate->y != $translate->y)

{

$this->translate = $translate;

$this->revalidate();

}

$this->fireEvent(new mxEventObject(mxEvent::$TRANSLATE, "translate", $translate, "previousTranslate", $previous));

}

/**

function getGraphBounds()

{

return $this->graphBounds;

}

/**

function setGraphBounds($value)

{

$this->graphBounds = $value;

}

/**

function getBounds($cells, $boundingBox = false)

{

$cellCount = sizeof($cells);

$result = null;

if ($cellCount > 0)

{

$model = $this->graph->getModel();

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

{

if ($model->isVertex($cells[$i]) || $model->isEdge($cells[$i]))

{

$state = $this->getState($cells[$i]);

if ($state != null)

{

$bounds = ($boundingBox) ? $state->boundingBox : $state;

if ($bounds != null)

{

if ($result == null)

{

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

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

}

else

{

$result->add($bounds);

}

}

}

}

}

}

return $result;

}

/**

function revalidate()

{

$this->invalidate();

$this->validate();

}

/**

function invalidate()

{

// LATER: Invalidate cell states recursively

$this->states = array();

}

/**

function validate($cell = null)

{

// Checks if cache is invalid

if (sizeof($this->states) == 0)

{

$graphBounds = $this->getBoundingBox($this->validateCellState(

$this->validateCell(($cell != null) ? $cell : $this->graph->model->root)));

$this->setGraphBounds(isset($graphBounds) ? $graphBounds : new mxRectangle());

}

}

/**

function getBoundingBox($state, $recurse = true)

{

$bbox = null;

if ($state != null)

{

if ($state->boundingBox != null)

{

$bbox = $state->boundingBox->copy();

}

if ($recurse)

{

$model = $this->graph->getModel();

$childCount = $model->getChildCount($state->cell);

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

{

$bounds = $this->getBoundingBox($this->getState($model->getChildAt($state->cell, $i)));

if ($bounds != null)

{

if ($bbox == null)

{

$bbox = $bounds;

}

else

{

$bbox->add($bounds);

}

}

}

}

}

return $bbox;

}

/**

function validateCell($cell, $visible = true)

{

if ($cell != null)

{

$visible = $visible && $this->graph->isCellVisible($cell);

$state = $this->getState($cell, $visible);

if ($state != null && !$visible)

{

$this->removeState($cell);

}

else

{

$model = $this->graph->getModel();

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

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

{

$this->validateCell($model->getChildAt($cell, $i), $visible &&

!$this->graph->isCellCollapsed($cell));

}

}

}

return $cell;

}

/**

function validateCellState($cell, $recurse = true)

{

$state = null;

if ($cell != null)

{

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

if ($state != null)

{

$model = $this->graph->getModel();

if ($state->invalid)

{

$state->invalid = false;

$this->validateCellState($model->getParent($cell), false);

$source = $this->validateCellState($this->getVisibleTerminal($cell, true), false);

$target = $this->validateCellState($this->getVisibleTerminal($cell, false), false);

$this->updateCellState($state, $source, $target);

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

{

$this->updateLabelBounds($state);

$this->updateBoundingBox($state);

}

}

if ($recurse)

{

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

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

{

$this->validateCellState($model->getChildAt($cell, $i));

}

}

}

}

return $state;

}

/**

function updateCellState($state, $source, $target)

{

$state->absoluteOffset->x = 0;

$state->absoluteOffset->y = 0;

$state->origin->x = 0;

$state->origin->y = 0;

$state->length = 0;

$model = $this->graph->getModel();

$pState = $this->getState($model->getParent($state->cell));

if ($pState != null)

{

$state->origin->x += $pState->origin->x;

$state->origin->y += $pState->origin->y;

}

$offset = $this->graph->getChildOffsetForCell($state->cell);

if ($offset != null)

{

$state->origin->x += $offset->x;

$state->origin->y += $offset->y;

}

$geo = $this->graph->getCellGeometry($state->cell);

if ($geo != null)

{

if (!$model->isEdge($state->cell))

{

$offset = $geo->offset;

if ($offset == null)

{

$offset = $this->EMPTY_POINT;

}

if ($geo->relative && $pState != null)

{

if ($model->isEdge($pState->cell))

{

$origin = $this->getPoint($pState, $geo);

if ($origin != null)

{

$state->origin->x += ($origin->x / $this->scale) - $pState->origin->x - $this->translate->x;

$state->origin->y += ($origin->y / $this->scale) - $pState->origin->y - $this->translate->y;

}

}

else

{

$state->origin->x += $geo->x * $pState->width / $this->scale + $offset->x;

$state->origin->y += $geo->y * $pState->height / $this->scale + $offset->y;

}

}

else

{

$state->absoluteOffset->x = $this->scale * $offset->x;

$state->absoluteOffset->y = $this->scale * $offset->y;

$state->origin->x += $geo->x;

$state->origin->y += $geo->y;

}

}

$state->x = $this->scale * ($this->translate->x + $state->origin->x);

$state->y = $this->scale * ($this->translate->y + $state->origin->y);

$state->width = $this->scale * $geo->width;

$state->height = $this->scale * $geo->height;

if ($model->isVertex($state->cell))

{

$this->updateVertexState($state, $geo);

}

if ($model->isEdge($state->cell))

{

$this->updateEdgeState($state, $geo, $source, $target);

}

}

}

/**

function updateVertexState($state, $geo)

{

// LATER: Add support for rotation

$this->updateVertexLabelOffset($state);

}

/**

function updateEdgeState($state, $geo, $source, $target)

{

// This will remove edges with no terminals and no terminal points

// as such edges are invalid and produce NPEs in the edge styles.

// Also removes connected edges that have no visible terminals.

if (($this->graph->model->getTerminal($state->cell, true) != null && $source == null) ||

($source == null && $geo->getTerminalPoint(true) == null) ||

($this->graph->model->getTerminal($state->cell, false) != null && $target == null) ||

($target == null && $geo->getTerminalPoint(false) == null))

{

$this->removeState($state->cell, true);

}

else

{

$this->updateFixedTerminalPoints($state, $source, $target);

$this->updatePoints($state, $geo->points, $source, $target);

$this->updateFloatingTerminalPoints($state, $source, $target);

$pts = $state->absolutePoints;

if ($pts == null || sizeof($pts) < 1 || $pts[0] == null || $pts[sizeof($pts) - 1] == null)

{

// This will remove edges with invalid points from the list of states in the view.

// Happens if the one of the terminals and the corresponding terminal point is null.

$this->removeState($state->cell, true);

}

else

{

$this->updateEdgeBounds($state);

$state->absoluteOffset = $this->getPoint($state, $geo);

}

}

}

/**

function updateVertexLabelOffset($state)

{

$horizontal = mxUtils::getValue($state->style,

mxConstants::$STYLE_LABEL_POSITION,

mxConstants::$ALIGN_CENTER);

if ($horizontal == mxConstants::$ALIGN_LEFT)

{

$state->absoluteOffset->x -= $state->width;

}

else if ($horizontal == mxConstants::$ALIGN_RIGHT)

{

$state->absoluteOffset->x += $state->width;

}

$vertical = mxUtils::getValue($state->style,

mxConstants::$STYLE_VERTICAL_LABEL_POSITION,

mxConstants::$ALIGN_MIDDLE);

if ($vertical == mxConstants::$ALIGN_TOP)

{

$state->absoluteOffset->y -= $state->height;

}

else if ($vertical == mxConstants::$ALIGN_BOTTOM)

{

$state->absoluteOffset->y += $state->height;

}

}

/**

function updateLabelBounds($state)

{

$cell = $state->cell;

$style = $state->style;

if (mxUtils::getValue($style, mxConstants::$STYLE_OVERFLOW) == "fill")

{

$state->labelBounds = new mxRectangle($state->x, $state->y, $state->width, $state->height);

}

else

{

$label = $this->graph->getLabel($cell);

$vertexBounds = (!$this->graph->model->isEdge($cell)) ? $state : null;

$state->labelBounds = mxUtils::getLabelPaintBounds($label, $style,

false, $state->absoluteOffset, $vertexBounds, $this->scale);

}

}

/**

function updateBoundingBox($state)

{

// Gets the cell bounds and adds shadows and markers

$rect = new mxRectangle($state->x, $state->y, $state->width, $state->height);

$style = $state->style;

// Adds extra pixels for the marker and stroke assuming

// that the border stroke is centered around the bounds

// and the first pixel is drawn inside the bounds

$strokeWidth = max(1, mxUtils::getNumber($style,

mxConstants::$STYLE_STROKEWIDTH, 1) * $this->scale);

$strokeWidth -= max(1, $strokeWidth / 2);

if ($this->graph->model->isEdge($state->cell))

{

$ms = 0;

if (isset($style[mxConstants::$STYLE_ENDARROW])

|| isset($style[mxConstants::$STYLE_STARTARROW]))

{

$ms = round(mxConstants::$DEFAULT_MARKERSIZE * $this->scale);

}

// Adds the strokewidth

$rect->grow($ms + $strokeWidth);

// Adds worst case border for an arrow shape

if (mxUtils::getValue($style, mxConstants::$STYLE_SHAPE) ==

mxConstants::$SHAPE_ARROW)

{

$rect->grow(mxConstants::$ARROW_WIDTH / 2);

}

}

else

{

$rect->grow($strokeWidth);

}

// Adds extra pixels for the shadow

if (mxUtils::getValue($style, mxConstants::$STYLE_SHADOW, false) == true)

{

$rect->width += mxConstants::$SHADOW_OFFSETX;

$rect->height += mxConstants::$SHADOW_OFFSETY;

}

// Adds oversize images in labels

if (mxUtils::getValue($style, mxConstants::$STYLE_SHAPE) ==

mxConstants::$SHAPE_LABEL)

{

if (mxUtils::getValue($style, mxConstants::$STYLE_IMAGE) != null)

{

$w = mxUtils::$getValue($style,

mxConstants::$STYLE_IMAGE_WIDTH,

mxConstants::$DEFAULT_IMAGESIZE) * $this->scale;

$h = mxUtils::$getValue($style,

mxConstants::$STYLE_IMAGE_HEIGHT,

mxConstants::$DEFAULT_IMAGESIZE) * $this->scale;

$x = $state->x;

$y = 0;

$imgAlign = mxUtils::getValue($style, mxConstants::$STYLE_IMAGE_ALIGN,

mxConstants::$ALIGN_CENTER);

$imgValign = mxUtils::getValue(style,

mxConstants::$STYLE_IMAGE_VERTICAL_ALIGN,

mxConstants::$ALIGN_MIDDLE);

if ($imgAlign == mxConstants::$ALIGN_RIGHT)

{

$x += $state->width - $w;

}

else if ($imgAlign == mxConstants::$ALIGN_CENTER)

{

$x += ($state->width - $w) / 2;

}

if ($imgValign == mxConstants::$ALIGN_TOP)

{

$y = $state->y;

}

else if ($imgValign == mxConstants::$ALIGN_BOTTOM)

{

$y = $state->y + $state->height - $h;

}

else

{

$y = $state->y + ($state->height - $h) / 2;

}

$rect->add(new mxRectangle($x, $y, $w, $h));

}

}

// No need to add rotated rectangle bounds here because

// GD does not support rotation

// Unifies the cell bounds and the label bounds

$rect->add($state->labelBounds);

$state->boundingBox = $rect;

return $rect;

}

/**

function updateFixedTerminalPoints($edge, $source, $target)

{

$this->updateFixedTerminalPoint($edge, $source, true,

$this->graph->getConnectionConstraint($edge, $source, true));

$this->updateFixedTerminalPoint($edge, $target, false,

$this->graph->getConnectionConstraint($edge, $target, false));

}

/**

function updateFixedTerminalPoint($edge, $terminal, $source, $constraint)

{

$pt = null;

if (isset($constraint))

{

$pt = $this->graph->getConnectionPoint($terminal, $constraint);

}

if (!isset($pt) && !isset($terminal))

{

$s = $this->scale;

$tr = $this->translate;

$orig = $edge->origin;

$geo = $this->graph->getCellGeometry($edge->cell);

$pt = $geo->getTerminalPoint($source);

if (isset($pt))

{

$pt = new mxPoint($s * ($tr->x + $pt->x + $orig->x),

$s * ($tr->y + $pt->y + $orig->y));

}

}

if (!is_array($edge->absolutePoints))

{

$edge->absolutePoints = array();

}

$n = sizeof($edge->absolutePoints);

if ($source)

{

if ($n > 0)

{

$state->absolutePoints[0] = $pt;

}

else

{

array_push($edge->absolutePoints, $pt);

}

}

else

{

$n = sizeof($edge->absolutePoints);

if ($n > 1)

{

$edge->absolutePoints[$n - 1] = $pt;

}

else

{

array_push($edge->absolutePoints, $pt);

}

}

}

/**

function updatePoints($edge, $points, $source, $target)

{

if (isset($edge))

{

$pts = array();

array_push($pts, $edge->absolutePoints[0]);

$edgeStyle = $this->getEdgeStyle($edge, $points, $source, $target);

if (isset($edgeStyle))

{

$src = $this->getTerminalPort($edge, $source, true);

$trg = $this->getTerminalPort($edge, $target, false);

$edgeStyle->apply($edge, $src, $trg, $points, $pts);

}

else if (isset($points))

{

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

{

if (isset($points[$i]))

{

$pt = $points[$i]->copy();

array_push($pts, $this->transformControlPoint($edge, $pt));

}

}

}

$n = sizeof($edge->absolutePoints);

array_push($pts, $edge->absolutePoints[$n-1]);

$edge->absolutePoints = $pts;

}

}

/**

function transformControlPoint($state, $pt)

{

$orig = $state->origin;

return new mxPoint($this->scale * ($pt->x + $this->translate->x + $orig->x),

$this->scale * ($pt->y + $this->translate->y + $orig->y));

}

/**

function getEdgeStyle($edge, $points, $source, $target)

{

$edgeStyle = null;

if (isset($source) && $source === $target)

{

$edgeStyle = mxUtils::getValue($edge->style, mxConstants::$STYLE_LOOP);

if (!isset($edgeStyle))

{

$edgeStyle = $this->graph->defaultLoopStyle;

}

}

else if (!mxUtils::getValue($edge->style, mxConstants::$STYLE_NOEDGESTYLE, false))

{

$edgeStyle = mxUtils::getValue($edge->style, mxConstants::$STYLE_EDGE);

}

// Converts string values to objects

if (is_string($edgeStyle))

{

$tmp = mxStyleRegistry::getValue($edgeStyle);

if ($tmp == null && strpos($edgeStyle, ".") !== false)

{

$tmp = mxUtils::evaluate($edgeStyle);

}

$edgeStyle = $tmp;

}

if ($edgeStyle instanceof mxEdgeStyleFunction)

{

return $edgeStyle;

}

return null;

}

/**

function updateFloatingTerminalPoints($state, $source, $target)

{

$pts = $state->absolutePoints;

$p0 = $pts[0];

$pe = $pts[sizeof($pts) - 1];

if (!isset($pe) && isset($target))

{

$this->updateFloatingTerminalPoint($state, $target, $source, false);

}

if (!isset($p0) && isset($source))

{

$this->updateFloatingTerminalPoint($state, $source, $target, true);

}

}

/**

function updateFloatingTerminalPoint($edge, $start, $end, $source)

{

$start = $this->getTerminalPort($edge, $start, $source);

$next = $this->getNextPoint($edge, $end, $source);

$border = mxUtils::getNumber($edge->style, mxConstants::$STYLE_PERIMETER_SPACING);

$border = mxUtils::getNumber($edge->style, ($source) ?

mxConstants::$STYLE_SOURCE_PERIMETER_SPACING :

mxConstants::$STYLE_TARGET_PERIMETER_SPACING);

$pt = $this->getPerimeterPoint($start, $next, $this->graph->isOrthogonal($edge), $border);

$index = ($source) ? 0 : sizeof($edge->absolutePoints) - 1;

$edge->absolutePoints[$index] = $pt;

}

/**

function getTerminalPort($state, $terminal, $source)

{

$key = ($source) ? mxConstants::$STYLE_SOURCE_PORT

: mxConstants::$STYLE_TARGET_PORT;

$id = mxUtils::getValue($state->style, $key);

if ($id != null)

{

$tmp = $this->getState($this->graph->model->getCell($id));

// Only uses ports where a cell state exists

if (isset($tmp))

{

$terminal = $tmp;

}

}

return $terminal;

}

/**

function getPerimeterPoint($terminal, $next, $orthogonal, $border = null)

{

$point = null;

if ($terminal != null)

{

$perimeter = $this->getPerimeterFunction($terminal);

if (isset($perimeter) && isset($next))

{

$bounds = $this->getPerimeterBounds($terminal, $border);

if ($bounds->width > 0 || $bounds->height > 0)

{

$point = $perimeter->apply($bounds, $terminal, $next, $orthogonal);

}

}

if (!isset($point))

{

$point = $this->getPoint($terminal);