protected void processNodeOutgoing(TreeNode node)
	{
		mxIGraphModel model = graph.getModel();

		TreeNode child = node.child;
		Object parentCell = node.cell;

		int childCount = 0;
		List<WeightedCellSorter> sortedCells = new ArrayList<WeightedCellSorter>();

		while (child != null)
		{
			childCount++;

			double sortingCriterion = child.x;

			if (this.horizontal)
			{
				sortingCriterion = child.y;
			}

			sortedCells.add(new WeightedCellSorter(child,
					(int) sortingCriterion));
			child = child.next;
		}

		WeightedCellSorter[] sortedCellsArray = sortedCells
				.toArray(new WeightedCellSorter[sortedCells.size()]);
		Arrays.sort(sortedCellsArray);

		double availableWidth = node.width;

		double requiredWidth = (childCount + 1) * prefHozEdgeSep;

		// Add a buffer on the edges of the vertex if the edge count allows
		if (availableWidth > requiredWidth + (2 * prefHozEdgeSep))
		{
			availableWidth -= 2 * prefHozEdgeSep;
		}

		double edgeSpacing = availableWidth / childCount;

		double currentXOffset = edgeSpacing / 2.0;

		if (availableWidth > requiredWidth + (2 * prefHozEdgeSep))
		{
			currentXOffset += prefHozEdgeSep;
		}

		double currentYOffset = minEdgeJetty - prefVertEdgeOff;
		double maxYOffset = 0;

		mxRectangle parentBounds = getVertexBounds(parentCell);
		child = node.child;

		for (int j = 0; j < sortedCellsArray.length; j++)
		{
			Object childCell = sortedCellsArray[j].cell.cell;
			mxRectangle childBounds = getVertexBounds(childCell);

			Object[] edges = mxGraphModel.getEdgesBetween(model, parentCell,
					childCell);

			List<mxPoint> newPoints = new ArrayList<mxPoint>(3);
			double x = 0;
			double y = 0;

			for (int i = 0; i < edges.length; i++)
			{
				if (this.horizontal)
				{
					// Use opposite co-ords, calculation was done for 
					// 
					x = parentBounds.getX() + parentBounds.getWidth();
					y = parentBounds.getY() + currentXOffset;
					newPoints.add(new mxPoint(x, y));
					x = parentBounds.getX() + parentBounds.getWidth()
							+ currentYOffset;
					newPoints.add(new mxPoint(x, y));
					y = childBounds.getY() + childBounds.getHeight() / 2.0;
					newPoints.add(new mxPoint(x, y));
					setEdgePoints(edges[i], newPoints);
				}
				else
				{
					x = parentBounds.getX() + currentXOffset;
					y = parentBounds.getY() + parentBounds.getHeight();
					newPoints.add(new mxPoint(x, y));
					y = parentBounds.getY() + parentBounds.getHeight()
							+ currentYOffset;
					newPoints.add(new mxPoint(x, y));
					x = childBounds.getX() + childBounds.getWidth() / 2.0;
					newPoints.add(new mxPoint(x, y));
					setEdgePoints(edges[i], newPoints);
				}
			}

			if (j < (float) childCount / 2.0f)
			{
				currentYOffset += prefVertEdgeOff;
			}
			else if (j > (float) childCount / 2.0f)
			{
				currentYOffset -= prefVertEdgeOff;
			}
			// Ignore the case if equals, this means the second of 2
			// jettys with the same y (even number of edges)

			//								pos[k * 2] = currentX;
			currentXOffset += edgeSpacing;
			//								pos[k * 2 + 1] = currentYOffset;

			maxYOffset = Math.max(maxYOffset, currentYOffset);
		}
	}