removed state from BranchLayoutStrategy, made BranchLayoutStrategy global to all BranchView's

3 files changed, 160 insertions, 153 deletions

diff --git a/plugins/org.eclipse.emf.cdo.ui.branch/src/org/eclipse/emf/cdo/ui/internal/branch/layout/BranchLayoutStrategy.java b/plugins/org.eclipse.emf.cdo.ui.branch/src/org/eclipse/emf/cdo/ui/internal/branch/layout/BranchLayoutStrategy.java
index 3423b63015..f486290b74 100644
--- a/plugins/org.eclipse.emf.cdo.ui.branch/src/org/eclipse/emf/cdo/ui/internal/branch/layout/BranchLayoutStrategy.java
+++ b/plugins/org.eclipse.emf.cdo.ui.branch/src/org/eclipse/emf/cdo/ui/internal/branch/layout/BranchLayoutStrategy.java
@@ -20,10 +20,6 @@ import org.eclipse.zest.layouts.dataStructures.DisplayIndependentDimension;
 import org.eclipse.zest.layouts.dataStructures.DisplayIndependentRectangle;
 import org.eclipse.zest.layouts.dataStructures.InternalNode;
 
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.List;
-
 /**
  * A strategy that layouts a branch. A branch centers its (sibling) nodes below each other while using their time stamp
  * to set the y coordinate. Sub-Branches are displaced to the right or to the left (left and right sub branches are
@@ -35,18 +31,18 @@ import java.util.List;
  */
 public class BranchLayoutStrategy
 {
-  private final SubBranchSproutingStrategy SPROUT_RIGHT = new SubBranchSproutingStrategy()
+  private final SubBranchSproutingStrategy sproutRight = new SubBranchSproutingStrategy()
   {
     @Override
-    protected void addSubBranchReference(BranchView branch)
+    protected void addSubBranchReference(BranchView branchView, BranchView subBranchView)
     {
-      rightSproutingBranches.addFirst(branch);
+      branchView.addRightSproutingBranch(subBranchView);
     }
 
     @Override
-    protected BranchView getLatestSubBranch()
+    protected BranchView getLatestSubBranch(BranchView branchView)
     {
-      return rightSproutingBranches.peekFirst();
+      return branchView.getLatestRightSubBranchView();
     }
 
     @Override
@@ -56,7 +52,7 @@ public class BranchLayoutStrategy
       InternalNode branchPointInternalNode = BranchTreeUtils.getInternalNode(branchPointNode);
       return new DisplayIndependentDimension( //
           // translate branch completely to visible area
-          Math.abs(subBranch.getLayoutStrategy().getBounds().x)
+          Math.abs(subBranch.getBounds().x)
           // add branch point position and its width
               + branchPointInternalNode.getInternalX() + branchPointInternalNode.getInternalWidth() //
               // add padding
@@ -66,24 +62,24 @@ public class BranchLayoutStrategy
     @Override
     protected DisplayIndependentDimension getTranslationToLatterBranch(BranchView subBranch, BranchView latterBranch)
     {
-      ExtendedDisplayIndependentRectangle latterBranchBounds = latterBranch.getLayoutStrategy().getBounds();
+      ExtendedDisplayIndependentRectangle latterBranchBounds = latterBranch.getBounds();
       return new DisplayIndependentDimension(//
           latterBranchBounds.x + latterBranchBounds.width, 0);
     }
   };
 
-  private final SubBranchSproutingStrategy SPROUT_LEFT = new SubBranchSproutingStrategy()
+  private final SubBranchSproutingStrategy sproutLeft = new SubBranchSproutingStrategy()
   {
     @Override
-    protected void addSubBranchReference(BranchView branch)
+    protected void addSubBranchReference(BranchView branchView, BranchView subBranchView)
     {
-      leftSproutingBranches.addFirst(branch);
+      branchView.addLeftSproutingBranch(subBranchView);
     }
 
     @Override
-    protected BranchView getLatestSubBranch()
+    protected BranchView getLatestSubBranch(BranchView branchView)
     {
-      return leftSproutingBranches.peekFirst();
+      return branchView.getLatestLeftSubBranchView();
     }
 
     @Override
@@ -91,7 +87,7 @@ public class BranchLayoutStrategy
         BranchPointNode branchPointNode)
     {
       InternalNode branchPointInternalNode = BranchTreeUtils.getInternalNode(branchPointNode);
-      DisplayIndependentRectangle subBranchBounds = subBranch.getLayoutStrategy().getBounds();
+      DisplayIndependentRectangle subBranchBounds = subBranch.getBounds();
       return new DisplayIndependentDimension(-( //
           // translate completely to invisible area
           subBranchBounds.width + subBranchBounds.x
@@ -102,62 +98,55 @@ public class BranchLayoutStrategy
     }
 
     @Override
-    protected DisplayIndependentDimension getTranslationToLatterBranch(BranchView subBranch, BranchView latterBranch)
+    protected DisplayIndependentDimension getTranslationToLatterBranch(BranchView subBranch, BranchView latterBranchView)
     {
-      DisplayIndependentRectangle latterBranchBounds = latterBranch.getLayoutStrategy().getBounds();
+      DisplayIndependentRectangle latterBranchBounds = latterBranchView.getBounds();
       return new DisplayIndependentDimension( //
           latterBranchBounds.x - getBranchPadding(), 0);
     }
   };
 
-  private SubBranchSproutingStrategy currentSproutingStrategy = SPROUT_RIGHT;
-
-  // protected Deque<AbstractBranchPointNode> nodeDeque = new Deque<AbstractBranchPointNode>();
-  //
-  // private Deque<BranchView> leftSproutingBranches = new Deque<BranchView>();
-  //
-  // private Deque<BranchView> rightSproutingBranches = new Deque<BranchView>();
-  //
-  // private ExtendedDisplayIndependentRectangle bounds;
-  //
-  // private ExtendedDisplayIndependentRectangle siblingBounds;
+  private SubBranchSproutingStrategy currentSproutingStrategy = sproutRight;
 
   protected BranchLayoutStrategy()
   {
   }
 
-  public void setRootNode(AbstractBranchPointNode node)
+  public void layoutBaselineNode(BranchView branchView, AbstractBranchPointNode node)
   {
-    nodeDeque.add(node);
     BranchTreeUtils.setInternalSize(node);
-    setRootNodeLocation(node);
-    initBranchBounds(node);
+    setBaselineNodeLocation(node);
+    initBranchBounds(branchView, node);
   }
 
-  protected void initBranchBounds(AbstractBranchPointNode node)
+  protected void initBranchBounds(BranchView branchView, AbstractBranchPointNode node)
   {
-    InternalNode rootInternalNode = BranchTreeUtils.getInternalNode(node);
-    bounds = new ExtendedDisplayIndependentRectangle(rootInternalNode.getInternalX(), rootInternalNode.getInternalY(),
-        rootInternalNode.getInternalWidth(), rootInternalNode.getInternalHeight());
-    siblingBounds = new ExtendedDisplayIndependentRectangle(bounds);
+    InternalNode baselineInternalNode = BranchTreeUtils.getInternalNode(node);
+    ExtendedDisplayIndependentRectangle bounds = new ExtendedDisplayIndependentRectangle(baselineInternalNode
+        .getInternalX(), baselineInternalNode.getInternalY(), baselineInternalNode.getInternalWidth(),
+        baselineInternalNode.getInternalHeight());
+    branchView.setBounds(bounds);
   }
 
   /**
-   * Layout the given node as sibling node of the root (and its siblings) node.
+   * Layout the given node as sibling node to the baseline node (and its siblings).
+   * 
+   * @param branchView
+   *          the branch view to layout the node to
+   * @param node
+   *          the node to layout
    */
-  public void addNode(AbstractBranchPointNode node)
+  public void layoutNode(BranchView branchView, AbstractBranchPointNode node, AbstractBranchPointNode previousNode)
   {
-    AbstractBranchPointNode previousNode = nodeDeque.peekLast();
-    nodeDeque.add(node);
     BranchTreeUtils.setInternalSize(node);
     setSiblingNodeLocation(node, previousNode);
-    setBranchBounds(node);
+    setBranchBounds(branchView, node);
   }
 
   /**
    * Sets the bounds of the given node. The node is centered horizontally to the given previous node.
    */
-  protected void setRootNodeLocation(AbstractBranchPointNode node)
+  protected void setBaselineNodeLocation(AbstractBranchPointNode node)
   {
     BranchTreeUtils.setInternalSize(node);
 
@@ -179,17 +168,11 @@ public class BranchLayoutStrategy
    * Sets the bounds of the current branch for the given additional node. The bounds are expanded if the size of the
    * node requires it.
    */
-  protected void setBranchBounds(AbstractBranchPointNode node)
+  protected void setBranchBounds(BranchView branchView, AbstractBranchPointNode node)
   {
     InternalNode internalNode = BranchTreeUtils.getInternalNode(node);
 
-    bounds.union( //
-        internalNode.getInternalX() //
-        , internalNode.getInternalY() //
-        , internalNode.getInternalWidth() //
-        , internalNode.getInternalHeight());
-
-    siblingBounds.union(//
+    branchView.getBounds().union( //
         internalNode.getInternalX() //
         , internalNode.getInternalY() //
         , internalNode.getInternalWidth() //
@@ -202,39 +185,30 @@ public class BranchLayoutStrategy
    * previous one to the left etc. .
    * 
    * @param branchPointNode
-   *          the node on the current branch, the sub-branch's attached to
-   * @param subBranch
-   *          the sub branch to add
-   * @return the branch that precedes the given branch
+   *          the node on the current branch view that the sub-branch view shall be attached to
+   * @param subBranchView
+   *          the sub branch view to add
+   * @param branchView
+   *          the branch view
    */
-  public void layoutBranch(BranchView subBranch, BranchPointNode branchPointNode)
+  public void layoutBranch(BranchView branchView, BranchView subBranchView, BranchPointNode branchPointNode)
   {
-    if (subBranch != null)
+    if (subBranchView != null)
     {
-      currentSproutingStrategy.setSubBranchLocation(subBranch, branchPointNode);
-      bounds.union(subBranch.getLayoutStrategy().getBounds());
+      currentSproutingStrategy.setSubBranchLocation(branchView, subBranchView, branchPointNode);
+      branchView.getBounds().union(subBranchView.getBounds());
       currentSproutingStrategy.switchSproutingStrategy();
     }
   }
 
   /**
-   * Gets all nodes within this branch.
-   * 
-   * @see AbstractBranchPointNode
-   */
-  public Collection<AbstractBranchPointNode> getNodes()
-  {
-    return nodeDeque;
-  }
-
-  /**
    * Translates this branch by the given dimension.
    */
-  public void translate(DisplayIndependentDimension dimension)
+  public void translate(BranchView branchView, DisplayIndependentDimension dimension)
   {
-    translateSiblingNodes(dimension);
-    translateSubBranches(dimension);
-    bounds.translate(dimension.width, dimension.height);
+    translateSiblingNodes(branchView, dimension);
+    translateSubBranches(branchView, dimension);
+    branchView.getBounds().translate(dimension.width, dimension.height);
   }
 
   /**
@@ -243,100 +217,74 @@ public class BranchLayoutStrategy
    * @param dimension
    *          the dimension to translate this branch by
    */
-  private void translateSubBranches(DisplayIndependentDimension dimension)
+  private void translateSubBranches(BranchView branchView, DisplayIndependentDimension dimension)
   {
-    for (BranchView branch : getSubBranches())
+    for (BranchView branch : branchView.getSubBranches())
     {
-      branch.getLayoutStrategy().translate(dimension);
+      branch.getLayoutStrategy().translate(branchView, dimension);
     }
   }
 
   /**
-   * Returns all sub branches of this branch.
-   * 
-   * @return the sub branches
-   */
-  Collection<BranchView> getSubBranches()
-  {
-    List<BranchView> branchList = new ArrayList<BranchView>(leftSproutingBranches);
-    branchList.addAll(rightSproutingBranches);
-    return branchList;
-  }
-
-  /**
    * Translates all the sibling nodes of this branch by the given horizontal and vertical offset.
    */
-  private void translateSiblingNodes(DisplayIndependentDimension dimension)
+  private void translateSiblingNodes(BranchView branchView, DisplayIndependentDimension dimension)
   {
-    for (AbstractBranchPointNode node : getNodes())
+    for (AbstractBranchPointNode node : branchView.getNodes())
     {
       BranchTreeUtils.translateInternalLocation(node, dimension.width, dimension.height);
     }
   }
 
   /**
-   * Returns whether the bounds of the given branch intersects the bounds of this branch.
-   * 
-   * @return true, if the given branch intersects this branch
-   */
-  boolean collidesWith(BranchView branch)
-  {
-    return bounds.bottomEndsBefore(branch.getLayoutStrategy().bounds);
-  }
-
-  /**
-   * Gets the bounds.
-   */
-  ExtendedDisplayIndependentRectangle getBounds()
-  {
-    return bounds;
-  }
-
-  /**
    * A layout strategy that handles the layout of sub branches in this branch
    */
   protected abstract class SubBranchSproutingStrategy
   {
     /**
-     * Adds the reference to the sub branch.
+     * Adds the given sub branch view reference to the given branch view.
      * 
-     * @param branch
-     *          the branch
+     * @param branchView
+     *          the branch view to add the sub branch to
+     * @param subBranchView
+     *          the sub branch view to add
      */
-    protected abstract void addSubBranchReference(BranchView branch);
+    protected abstract void addSubBranchReference(BranchView branchView, BranchView subBranchView);
 
     /**
-     * Gets the latest sub branch.
+     * Gets the latest sub branch of the given sub branch view.
      * 
+     * @param branchView
+     *          the branch view to retrieve the latest sub branch from
      * @return the latest sub branch
      */
-    protected abstract BranchView getLatestSubBranch();
+    protected abstract BranchView getLatestSubBranch(BranchView branchView);
 
     /**
-     * Sets the location of the given sub branch in the current branch. Branches are created and located with their root
-     * node at x == 0, y == 0. The bounds of the sub branch (and its sub sub-branches) are from negative x-coordinates
-     * up to positive x-coordinates. The purpose of this method is to translate the whole sub branch to the correct
-     * location to the right or to the left of its branch point.
+     * Sets the location of the given sub branch in the current branch. Branches are created and located with their
+     * baseline node at x == 0, y == 0. The bounds of the sub branch (and its sub sub-branches) are from negative
+     * x-coordinates up to positive x-coordinates. The purpose of this method is to translate the whole sub branch to
+     * the correct location to the right or to the left of its branch point.
      * 
-     * @param subBranch
+     * @param subBranchView
      *          the sub branch to layout in the current branch
+     * @param subBranchView2
      * @param branchPointNode
      *          the branch point node the given sub branch is attached to
      */
-    void setSubBranchLocation(BranchView subBranch, BranchPointNode branchPointNode)
+    void setSubBranchLocation(BranchView subBranchView, BranchView branchView, BranchPointNode branchPointNode)
     {
       // translate branch off the branchPointNode (to the right or to the left)
-      DisplayIndependentDimension translation = getTranslationToBranchPoint(subBranch, branchPointNode);
-      ExtendedDisplayIndependentRectangle subBranchBounds = subBranch.getLayoutStrategy().getBounds();
-      BranchView latterBranch = currentSproutingStrategy.getLatestSubBranch();
-      if (latterBranch != null && !subBranchBounds.bottomEndsBefore(latterBranch.getLayoutStrategy().getBounds()))
+      DisplayIndependentDimension translation = getTranslationToBranchPoint(subBranchView, branchPointNode);
+      BranchView latterBranch = currentSproutingStrategy.getLatestSubBranch(branchView);
+      if (latterBranch != null && !subBranchView.getBounds().bottomEndsBefore(latterBranch.getBounds()))
       {
         // collides vertically with latter sub-branch -> additionally translate off latter branch (to the right or to
         // the left)
-        translation = GeometryUtils.union(translation, getTranslationToLatterBranch(subBranch, latterBranch));
+        translation = GeometryUtils.union(translation, getTranslationToLatterBranch(subBranchView, latterBranch));
       }
-      subBranch.getLayoutStrategy().translate(translation);
-      addSubBranchReference(subBranch);
+      translate(subBranchView, translation);
+      addSubBranchReference(branchView, subBranchView);
     }
 
     /**
@@ -371,13 +319,13 @@ public class BranchLayoutStrategy
      */
     protected void switchSproutingStrategy()
     {
-      if (currentSproutingStrategy == SPROUT_RIGHT)
+      if (currentSproutingStrategy == sproutRight)
       {
-        currentSproutingStrategy = SPROUT_LEFT;
+        currentSproutingStrategy = sproutLeft;
       }
       else
       {
-        currentSproutingStrategy = SPROUT_RIGHT;
+        currentSproutingStrategy = sproutRight;
       }
     }
 
diff --git a/plugins/org.eclipse.emf.cdo.ui.branch/src/org/eclipse/emf/cdo/ui/internal/branch/layout/BranchTreeLayoutAlgorithm.java b/plugins/org.eclipse.emf.cdo.ui.branch/src/org/eclipse/emf/cdo/ui/internal/branch/layout/BranchTreeLayoutAlgorithm.java
index f7004c5e34..602a30e4b2 100644
--- a/plugins/org.eclipse.emf.cdo.ui.branch/src/org/eclipse/emf/cdo/ui/internal/branch/layout/BranchTreeLayoutAlgorithm.java
+++ b/plugins/org.eclipse.emf.cdo.ui.branch/src/org/eclipse/emf/cdo/ui/internal/branch/layout/BranchTreeLayoutAlgorithm.java
@@ -10,11 +10,11 @@
  */
 package org.eclipse.emf.cdo.ui.internal.branch.layout;
 
+import org.eclipse.emf.cdo.common.branch.CDOBranch;
 import org.eclipse.emf.cdo.ui.internal.branch.item.AbstractBranchPointNode;
 import org.eclipse.emf.cdo.ui.internal.branch.item.BranchTreeUtils;
 import org.eclipse.emf.cdo.ui.internal.branch.item.RootNode;
 
-import org.eclipse.core.runtime.Assert;
 import org.eclipse.zest.layouts.LayoutStyles;
 import org.eclipse.zest.layouts.algorithms.AbstractLayoutAlgorithm;
 import org.eclipse.zest.layouts.dataStructures.DisplayIndependentRectangle;
@@ -54,21 +54,25 @@ public class BranchTreeLayoutAlgorithm extends AbstractLayoutAlgorithm
     this(LayoutStyles.NONE);
   }
 
+  @Override
   public void setLayoutArea(double x, double y, double width, double height)
   {
     throw new RuntimeException();
   }
 
+  @Override
   protected int getCurrentLayoutStep()
   {
     return 0;
   }
 
+  @Override
   protected int getTotalNumberOfLayoutSteps()
   {
     return LAYOUT_STEPS;
   }
 
+  @Override
   protected void preLayoutAlgorithm(InternalNode[] entitiesToLayout, InternalRelationship[] relationshipsToConsider,
       double x, double y, double width, double height)
   {
@@ -77,8 +81,6 @@ public class BranchTreeLayoutAlgorithm extends AbstractLayoutAlgorithm
     if (entitiesToLayout.length > 0)
     {
       initRootAndLatestNode(entitiesToLayout);
-      Assert.isTrue(rootNode != null, "root node was not found");
-      Assert.isTrue(latestNode != null, "latest node was not found");
     }
   }
 
@@ -101,15 +103,15 @@ public class BranchTreeLayoutAlgorithm extends AbstractLayoutAlgorithm
         {
           rootNode = (RootNode)node.getLatter(rootNode);
         }
-        latestNode = (AbstractBranchPointNode)node.getLatter(latestNode);
+        latestNode = node.getLatter(latestNode);
       }
     }
   }
 
+  @Override
   protected void applyLayoutInternal(InternalNode[] entitiesToLayout, InternalRelationship[] relationshipsToConsider,
       double boundsX, double boundsY, double boundsWidth, double boundsHeight)
   {
-
     if (entitiesToLayout.length > 0)
     {
       buildBranch(rootNode);
@@ -120,15 +122,18 @@ public class BranchTreeLayoutAlgorithm extends AbstractLayoutAlgorithm
 
   private BranchView buildBranch(AbstractBranchPointNode branchRootNode)
   {
-    return new BranchView(branchRootNode);
+    CDOBranch branch = branchRootNode.getBranch();
+    return new BranchView(branch, branchRootNode, new BranchLayoutStrategy());
   }
 
+  @Override
   protected void postLayoutAlgorithm(InternalNode[] entitiesToLayout, InternalRelationship[] relationshipsToConsider)
   {
     updateLayoutLocations(entitiesToLayout);
     fireProgressEvent(LAYOUT_STEPS, LAYOUT_STEPS);
   }
 
+  @Override
   protected boolean isValidConfiguration(boolean asynchronous, boolean continueous)
   {
     if (asynchronous && continueous)
diff --git a/plugins/org.eclipse.emf.cdo.ui.branch/src/org/eclipse/emf/cdo/ui/internal/branch/layout/BranchView.java b/plugins/org.eclipse.emf.cdo.ui.branch/src/org/eclipse/emf/cdo/ui/internal/branch/layout/BranchView.java
index f9d12cbb24..5a8f3b0850 100644
--- a/plugins/org.eclipse.emf.cdo.ui.branch/src/org/eclipse/emf/cdo/ui/internal/branch/layout/BranchView.java
+++ b/plugins/org.eclipse.emf.cdo.ui.branch/src/org/eclipse/emf/cdo/ui/internal/branch/layout/BranchView.java
@@ -15,11 +15,13 @@ import org.eclipse.emf.cdo.ui.internal.branch.geometry.ExtendedDisplayIndependen
 import org.eclipse.emf.cdo.ui.internal.branch.item.AbstractBranchPointNode;
 import org.eclipse.emf.cdo.ui.internal.branch.item.BranchPointNode;
 
+import java.util.ArrayList;
 import java.util.Collection;
+import java.util.List;
 
 /**
- * A Branch is a structure that holds the root node of a branch. Its main purpose is to climb through the branch tree
- * and call the layout strategy on all nodes in an appropriate manner.
+ * A Branch is a structure that holds the baseline node of a branch. Its main purpose is to climb through the branch
+ * tree and call the layout strategy on all nodes in an appropriate manner.
  * <p>
  * The strategy is to first lay out all (sibling) nodes in the order of their time stamp. Sub-branches are skipped. In a
  * second step all branches are positioned while beginning with the latest one (in terms of time stamp).
@@ -33,8 +35,6 @@ public class BranchView
 
   private AbstractBranchPointNode baselineNode;
 
-  private BranchLayoutStrategy layoutStrategy = new BranchLayoutStrategy();
-
   protected Deque<AbstractBranchPointNode> nodes = new Deque<AbstractBranchPointNode>();
 
   private Deque<BranchView> leftSproutingBranchViews = new Deque<BranchView>();
@@ -43,20 +43,22 @@ public class BranchView
 
   private ExtendedDisplayIndependentRectangle bounds;
 
-  private ExtendedDisplayIndependentRectangle siblingBounds;
+  private BranchLayoutStrategy layoutStrategy;
 
-  public BranchView(CDOBranch branch, AbstractBranchPointNode baselineNode)
+  public BranchView(CDOBranch branch, AbstractBranchPointNode baselineNode, BranchLayoutStrategy layoutStrategy)
   {
     this.branch = branch;
     this.baselineNode = baselineNode;
-    layoutStrategy.setRootNode(baselineNode);
+    this.layoutStrategy = layoutStrategy;
+    nodes.add(baselineNode);
+    layoutStrategy.layoutBaselineNode(this, baselineNode);
     addNode(baselineNode.getNextSibling());
 
     if (baselineNode instanceof BranchPointNode)
     {
       // add a branch to this node
       BranchPointNode branchpointNode = (BranchPointNode)baselineNode;
-      addBranchView(branchpointNode.getNextChild(), branchpointNode);
+      addBranchView(branch, branchpointNode.getNextChild(), branchpointNode);
     }
   }
 
@@ -103,7 +105,8 @@ public class BranchView
   {
     if (node != null)
     {
-      layoutStrategy.addNode(node);
+      AbstractBranchPointNode previousNode = nodes.peekLast();
+      layoutStrategy.layoutNode(this, node, previousNode);
       // recursively navigate to sibling
       addNode(node.getNextSibling());
 
@@ -111,20 +114,71 @@ public class BranchView
       {
         // add a branch to this node
         BranchPointNode branchpointNode = (BranchPointNode)node;
-        addBranchView(branchpointNode.getNextChild(), branchpointNode);
+        addBranchView(branch, branchpointNode.getNextChild(), branchpointNode);
       }
     }
   }
 
   /**
-   * Adds a sub-branch to the given branch point node with the given root node.
+   * Adds a sub-branch to the given branch point node with the given baseline node.
    */
-  private void addBranchView(CDOBranch branch, AbstractBranchPointNode rootNode, BranchPointNode branchPointNode)
+  private void addBranchView(CDOBranch branch, AbstractBranchPointNode baselineNode, BranchPointNode branchPointNode)
   {
-    if (rootNode != null)
+    if (baselineNode != null)
     {
-      BranchView subBranch = new BranchView(branch, rootNode);
-      layoutStrategy.layoutBranch(subBranch, branchPointNode);
+      BranchView subBranch = new BranchView(branch, baselineNode, layoutStrategy);
+      layoutStrategy.layoutBranch(this, subBranch, branchPointNode);
     }
   }
+
+  /**
+   * Returns the bounds of this branch view. The bounds returned contain all sub-branches (and their nodes)
+   * 
+   * @return the bounds
+   * @see #getNudeBranchBounds()
+   */
+  public ExtendedDisplayIndependentRectangle getBounds()
+  {
+    return bounds;
+  }
+
+  /**
+   * Sets the bounds of this branch view. The bounds must contain this branch and all its sub branch views (and all
+   * their nodes)
+   * 
+   * @param bounds
+   *          the new bounds
+   */
+  public void setBounds(ExtendedDisplayIndependentRectangle bounds)
+  {
+    this.bounds = bounds;
+  }
+
+  public void addLeftSproutingBranch(BranchView branchView)
+  {
+    leftSproutingBranchViews.addFirst(branchView);
+  }
+
+  public void addRightSproutingBranch(BranchView branchView)
+  {
+    rightSproutingBranchViews.addFirst(branchView);
+  }
+
+  public BranchView getLatestRightSubBranchView()
+  {
+    return rightSproutingBranchViews.peekFirst();
+  }
+
+  public BranchView getLatestLeftSubBranchView()
+  {
+    return leftSproutingBranchViews.peekFirst();
+  }
+
+  public Collection<BranchView> getSubBranches()
+  {
+    List<BranchView> branchList = new ArrayList<BranchView>(leftSproutingBranchViews);
+    branchList.addAll(rightSproutingBranchViews);
+    return branchList;
+  }
+
 }