dep-selector-libgecode 1.0.0.alpha.0

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/gist/treecanvas.hh

@@ -0,0 +1,369 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2006
+ *
+ *  Last modified:
+ *     $Date: 2010-08-12 18:29:27 +1000 (Thu, 12 Aug 2010) $ by $Author: tack $
+ *     $Revision: 11346 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#ifndef GECODE_GIST_TREECANVAS_HH
+#define GECODE_GIST_TREECANVAS_HH
+
+#include <QtGui>
+
+#include <gecode/kernel.hh>
+#include <gecode/gist.hh>
+
+#include <gecode/gist/visualnode.hh>
+
+namespace Gecode {  namespace Gist {
+
+  /// \brief Parameters for the tree layout
+  namespace LayoutConfig {
+    /// Minimum scale factor
+    const int minScale = 10;
+    /// Maximum scale factor
+    const int maxScale = 400;
+    /// Default scale factor
+    const int defScale = 100;
+    /// Maximum scale factor for automatic zoom
+    const int maxAutoZoomScale = defScale;
+  }
+
+  class TreeCanvas;
+
+  /// \brief A thread that concurrently explores the tree
+  class SearcherThread : public QThread {
+    Q_OBJECT
+  private:
+    VisualNode* node;
+    int depth;
+    bool a;
+    TreeCanvas* t;
+    void updateCanvas(void);
+  public:
+    void search(VisualNode* n, bool all, TreeCanvas* ti);
+
+  Q_SIGNALS:
+    void update(int w, int h, int scale0);
+    void statusChanged(bool);
+    void scaleChanged(int);
+    void solution(const Space*);
+    void searchFinished(void);
+  protected:
+    void run(void);
+  };
+
+  /// \brief A canvas that displays the search tree
+  class GECODE_GIST_EXPORT TreeCanvas : public QWidget {
+    Q_OBJECT
+
+    friend class SearcherThread;
+    friend class Gist;
+
+  public:
+    /// Constructor
+    TreeCanvas(Space* rootSpace, bool bab, QWidget* parent, 
+               const Options& opt);
+    /// Destructor
+    ~TreeCanvas(void);
+
+    /// Add inspector \a i
+    void addDoubleClickInspector(Inspector* i);
+    /// Set active inspector
+    void activateDoubleClickInspector(int i, bool active);
+    /// Add inspector \a i
+    void addSolutionInspector(Inspector* i);
+    /// Set active inspector
+    void activateSolutionInspector(int i, bool active);
+    /// Add inspector \a i
+    void addMoveInspector(Inspector* i);
+    /// Set active inspector
+    void activateMoveInspector(int i, bool active);
+    /// Add comparator \a c
+    void addComparator(Comparator* c);
+    /// Set active comparator
+    void activateComparator(int i, bool active);
+
+  public Q_SLOTS:
+    /// Set scale factor to \a scale0
+    void scaleTree(int scale0, int zoomx=-1, int zoomy=-1);
+
+    /// Explore complete subtree of selected node
+    void searchAll(void);
+    /// Find next solution below selected node
+    void searchOne(void);
+    /// Toggle hidden state of selected node
+    void toggleHidden(void);
+    /// Hide failed subtrees of selected node
+    void hideFailed(void);
+    /// Unhide all nodes below selected node
+    void unhideAll(void);
+    /// Do not stop at selected stop node
+    void toggleStop(void);
+    /// Do not stop at any stop node
+    void unstopAll(void);
+    /// Export pdf of the current subtree
+    void exportPDF(void);
+    /// Export pdf of the whole tree
+    void exportWholeTreePDF(void);
+    /// Print the tree
+    void print(void);
+    /// Zoom the canvas so that the whole tree fits
+    void zoomToFit(void);
+    /// Center the view on the currently selected node
+    void centerCurrentNode(void);
+    /**
+     * \brief Call the double click inspector for the currently selected node
+     *
+     * If \a fix is true, then the node is inspected after fixpoint
+     * computation, otherwise its status after branching but before
+     * fixpoint computation is inspected.
+     */
+    void inspectCurrentNode(bool fix=true, int inspectorNo=-1);
+    /// Calls inspectCurrentNode(false)
+    void inspectBeforeFP(void);
+
+    /// Stop current search
+    void stopSearch(void);
+
+    /// Reset
+    void reset(void);
+
+    /// Move selection to the parent of the selected node
+    void navUp(void);
+    /// Move selection to the first child of the selected node
+    void navDown(void);
+    /// Move selection to the left sibling of the selected node
+    void navLeft(void);
+    /// Move selection to the right sibling of the selected node
+    void navRight(void);
+    /// Move selection to the root node
+    void navRoot(void);
+    /// Move selection to next solution (in DFS order)
+    void navNextSol(bool back = false);
+    /// Move selection to previous solution (in DFS order)
+    void navPrevSol(void);
+
+    /// Bookmark current node
+    void bookmarkNode(void);
+    /// Set the current node to be the head of the path
+    void setPath(void);
+    /// Call the double click inspector for all nodes on the path from root to head of the path
+    void inspectPath(void);
+    /// Wait for click on node to compare with current node
+    void startCompareNodes(void);
+    /// Wait for click on node to compare with current node before fixpoint
+    void startCompareNodesBeforeFP(void);
+    
+    /// Re-emit status change information for current node
+    void emitStatusChanged(void);
+
+    /// Set recomputation distances
+    void setRecompDistances(int c_d, int a_d);
+    /// Set preference whether to automatically hide failed subtrees
+    void setAutoHideFailed(bool b);
+    /// Set preference whether to automatically zoom to fit
+    void setAutoZoom(bool b);
+    /// Return preference whether to automatically hide failed subtrees
+    bool getAutoHideFailed(void);
+    /// Return preference whether to automatically zoom to fit
+    bool getAutoZoom(void);
+    /// Set preference whether to show copies in the tree
+    void setShowCopies(bool b);
+    /// Return preference whether to show copies in the tree
+    bool getShowCopies(void);
+    /// Set refresh rate
+    void setRefresh(int i);
+    /// Set refresh pause in msec
+    void setRefreshPause(int i);
+    /// Return preference whether to use smooth scrolling and zooming
+    bool getSmoothScrollAndZoom(void);
+    /// Set preference whether to use smooth scrolling and zooming
+    void setSmoothScrollAndZoom(bool b);
+    /// Resize to the outer widget size if auto zoom is enabled
+    void resizeToOuter(void);
+
+    /// Stop search and wait for it to finish
+    bool finish(void);
+
+  Q_SIGNALS:
+    /// The scale factor has changed
+    void scaleChanged(int);
+    /// The auto-zoom state was changed
+    void autoZoomChanged(bool);
+    /// Context menu triggered
+    void contextMenu(QContextMenuEvent*);
+    /// Status bar update
+    void statusChanged(VisualNode*,const Statistics&, bool);
+    /// Signals that a solution has been found
+    void solution(const Space*);
+    /// Signals that %Gist is finished
+    void searchFinished(void);
+    /// Signals that a bookmark has been added
+    void addedBookmark(const QString& id);
+    /// Signals that a bookmark has been removed
+    void removedBookmark(int idx);
+  protected:
+    /// Mutex for synchronizing acccess to the tree
+    QMutex mutex;
+    /// Mutex for synchronizing layout and drawing
+    QMutex layoutMutex;
+    /// Search engine thread
+    SearcherThread searcher;
+    /// Flag signalling the search to stop
+    bool stopSearchFlag;
+    /// Flag signalling that Gist is ready to be closed
+    bool finishedFlag;
+    /// Allocator for nodes
+    Node::NodeAllocator* na;
+    /// The root node of the tree
+    VisualNode* root;
+    /// The currently best solution (for branch-and-bound)
+    BestNode* curBest;
+    /// The currently selected node
+    VisualNode* currentNode;
+    /// The head of the currently selected path
+    VisualNode* pathHead;
+    /// The registered click inspectors, and whether they are active
+    QVector<QPair<Inspector*,bool> > doubleClickInspectors;
+    /// The registered solution inspectors, and whether they are active
+    QVector<QPair<Inspector*,bool> > solutionInspectors;
+    /// The registered move inspectors, and whether they are active
+    QVector<QPair<Inspector*,bool> > moveInspectors;
+    /// The registered comparators, and whether they are active
+    QVector<QPair<Comparator*,bool> > comparators;
+
+    /// The bookmarks map
+    QVector<VisualNode*> bookmarks;
+
+    /// Whether node comparison action is running
+    bool compareNodes;
+    /// Whether node comparison action computes fixpoint
+    bool compareNodesBeforeFP;
+
+    /// The scale bar
+    QSlider* scaleBar;
+
+    /// Statistics about the search tree
+    Statistics stats;
+
+    /// Current scale factor
+    double scale;
+    /// Offset on the x axis so that the tree is centered
+    int xtrans;
+
+    /// Whether to hide failed subtrees automatically
+    bool autoHideFailed;
+    /// Whether to zoom automatically
+    bool autoZoom;
+    /// Whether to show copies in the tree
+    bool showCopies;
+    /// Refresh rate
+    int refresh;
+    /// Time (in msec) to pause after each refresh
+    int refreshPause;
+    /// Whether to use smooth scrolling and zooming
+    bool smoothScrollAndZoom;
+
+    /// The recomputation distance
+    int c_d;
+    /// The adaptive recomputation distance
+    int a_d;
+
+    /// Return the node corresponding to the \a event position
+    VisualNode* eventNode(QEvent *event);
+    /// General event handler, used for displaying tool tips
+    bool event(QEvent *event);
+    /// Paint the tree
+    void paintEvent(QPaintEvent* event);
+    /// Handle mouse press event
+    void mousePressEvent(QMouseEvent* event);
+    /// Handle mouse double click event
+    void mouseDoubleClickEvent(QMouseEvent* event);
+    /// Handle context menu event
+    void contextMenuEvent(QContextMenuEvent* event);
+    /// Handle resize event
+    void resizeEvent(QResizeEvent* event);
+    /// Handle mouse wheel events
+    void wheelEvent(QWheelEvent* event);
+    /// Set the selected node to \a n
+    void setCurrentNode(VisualNode* n, bool update=true);
+
+    /// Timer for smooth zooming
+    QTimeLine zoomTimeLine;
+    /// Timer for smooth scrolling
+    QTimeLine scrollTimeLine;
+    /// Target x coordinate after smooth scrolling
+    int targetX;
+    /// Source x coordinate after smooth scrolling
+    int sourceX;
+    /// Target y coordinate after smooth scrolling
+    int targetY;
+    /// Target y coordinate after smooth scrolling
+    int sourceY;
+
+    /// Target width after layout
+    int targetW;
+    /// Target height after layout
+    int targetH;
+    /// Target scale after layout
+    int targetScale;
+    /// Timer id for delaying the update
+    int layoutDoneTimerId;
+
+    /// Timer invoked for smooth zooming and scrolling
+    virtual void timerEvent(QTimerEvent* e);
+
+  public Q_SLOTS:
+    /// Update display
+    void update(void);
+    /// React to scroll events
+    void scroll(void);
+    /// Layout done
+    void layoutDone(int w, int h, int scale0);
+  private Q_SLOTS:
+    /// Search has finished
+    void statusChanged(bool);
+    /// Export PDF of the subtree of \a n
+    void exportNodePDF(VisualNode* n);
+    /// A new solution \a s has been found
+    void inspectSolution(const Space* s);
+    /// Scroll to \a i percent of the target
+    void scroll(int i);
+  };
+
+}}
+
+#endif
+
+// STATISTICS: gist-any

data/ext/libgecode3/vendor/gecode-3.7.3/gecode/gist/visualnode.cpp

@@ -0,0 +1,473 @@
+/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ *  Main authors:
+ *     Guido Tack <tack@gecode.org>
+ *
+ *  Copyright:
+ *     Guido Tack, 2006
+ *
+ *  Last modified:
+ *     $Date: 2010-09-03 21:50:47 +1000 (Fri, 03 Sep 2010) $ by $Author: tack $
+ *     $Revision: 11389 $
+ *
+ *  This file is part of Gecode, the generic constraint
+ *  development environment:
+ *     http://www.gecode.org
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#include <gecode/gist/visualnode.hh>
+
+#include <gecode/gist/layoutcursor.hh>
+#include <gecode/gist/nodevisitor.hh>
+
+#include <utility>
+
+namespace Gecode { namespace Gist {
+
+  Shape* Shape::leaf;
+  Shape* Shape::hidden;
+
+  /// Allocate shapes statically
+  class ShapeAllocator {
+  public:
+    /// Constructor
+    ShapeAllocator(void) {
+      Shape::leaf = Shape::allocate(1);
+      Shape::hidden = Shape::allocate(2);
+      (*Shape::hidden)[1] = Extent(Layout::extent);
+      Shape::leaf->computeBoundingBox();
+      Shape::hidden->computeBoundingBox();
+    }
+    ~ShapeAllocator(void) {
+      Shape::deallocate(Shape::leaf);
+      Shape::deallocate(Shape::hidden);
+    }
+  };
+
+  /// Allocate shapes statically
+  ShapeAllocator shapeAllocator;
+
+  VisualNode::VisualNode(int p)
+  : SpaceNode(p)
+  , offset(0)
+  {
+    shape = NULL;
+    setDirty(true);
+    setChildrenLayoutDone(false);
+    setHidden(false);
+    setMarked(false);
+    setOnPath(false);
+    setBookmarked(false);
+  }
+
+  VisualNode::VisualNode(Space* root)
+  : SpaceNode(root)
+  , offset(0)
+  {
+    shape = NULL;
+    setDirty(true);
+    setChildrenLayoutDone(false);
+    setHidden(false);
+    setMarked(false);
+    setOnPath(false);
+    setBookmarked(false);
+  }
+
+  void
+  VisualNode::dispose(void) {
+    Shape::deallocate(shape);
+    SpaceNode::dispose();
+  }
+
+  void
+  VisualNode::dirtyUp(const NodeAllocator& na) {
+    VisualNode* cur = this;
+    while (!cur->isDirty()) {
+      cur->setDirty(true);
+      if (! cur->isRoot()) {
+        cur = cur->getParent(na);
+      }
+    }
+  }
+
+  void
+  VisualNode::layout(const NodeAllocator& na) {
+    LayoutCursor l(this,na);
+    PostorderNodeVisitor<LayoutCursor>(l).run();
+    // int nodesLayouted = 1;
+    // clock_t t0 = clock();
+    // while (p.next()) {}
+    // while (p.next()) { nodesLayouted++; }
+    // double t = (static_cast<double>(clock()-t0) / CLOCKS_PER_SEC) * 1000.0;
+    // double nps = static_cast<double>(nodesLayouted) /
+    //   (static_cast<double>(clock()-t0) / CLOCKS_PER_SEC);
+    // std::cout << "Layout done. " << nodesLayouted << " nodes in "
+    //   << t << " ms. " << nps << " nodes/s." << std::endl;
+  }
+
+  void VisualNode::pathUp(const NodeAllocator& na) {
+    VisualNode* cur = this;
+    while (cur) {
+      cur->setOnPath(true);
+      cur = cur->getParent(na);
+    }
+  }
+
+  void VisualNode::unPathUp(const NodeAllocator& na) {
+    VisualNode* cur = this;
+    while (!cur->isRoot()) {
+      cur->setOnPath(false);
+      cur = cur->getParent(na);
+    }
+  }
+
+  int
+  VisualNode::getPathAlternative(const NodeAllocator& na) {
+    for (int i=getNumberOfChildren(); i--;) {
+      if (getChild(na,i)->isOnPath())
+        return i;
+    }
+    return -1;
+  }
+
+  void
+  VisualNode::toggleHidden(const NodeAllocator& na) {
+    setHidden(!isHidden());
+    dirtyUp(na);
+  }
+
+  void
+  VisualNode::hideFailed(const NodeAllocator& na, bool onlyDirty) {
+    HideFailedCursor c(this,na,onlyDirty);
+    PreorderNodeVisitor<HideFailedCursor>(c).run();
+    dirtyUp(na);
+  }
+
+  void
+  VisualNode::unhideAll(const NodeAllocator& na) {
+    UnhideAllCursor c(this,na);
+    PreorderNodeVisitor<UnhideAllCursor>(c).run();
+    dirtyUp(na);
+  }
+
+  void
+  VisualNode::toggleStop(const NodeAllocator& na) {
+    if (getStatus() == STOP)
+      setStatus(UNSTOP);
+    else if (getStatus() == UNSTOP)
+      setStatus(STOP);
+    dirtyUp(na);
+  }
+  
+  void
+  VisualNode::unstopAll(const NodeAllocator& na) {
+    UnstopAllCursor c(this,na);
+    PreorderNodeVisitor<UnstopAllCursor>(c).run();
+    dirtyUp(na);
+  }
+
+  void
+  VisualNode::changedStatus(const NodeAllocator& na) { dirtyUp(na); }
+
+  bool
+  VisualNode::containsCoordinateAtDepth(int x, int depth) {
+    BoundingBox box = getShape()->getBoundingBox();
+    if (x < box.left ||
+        x > box.right ||
+        depth >= getShape()->depth()) {
+      return false;
+    }
+    Extent theExtent;
+    if (getShape()->getExtentAtDepth(depth, theExtent)) {
+      return (theExtent.l <= x && x <= theExtent.r);
+    } else {
+      return false;
+    }
+  }
+
+  VisualNode*
+  VisualNode::findNode(const NodeAllocator& na, int x, int y) {
+    VisualNode* cur = this;
+    int depth = y / Layout::dist_y;
+
+    while (depth > 0 && cur != NULL) {
+      if (cur->isHidden()) {
+        break;
+      }
+      VisualNode* oldCur = cur;
+      cur = NULL;
+      for (unsigned int i=0; i<oldCur->getNumberOfChildren(); i++) {
+        VisualNode* nextChild = oldCur->getChild(na,i);
+        int newX = x - nextChild->getOffset();
+        if (nextChild->containsCoordinateAtDepth(newX, depth - 1)) {
+          cur = nextChild;
+          x = newX;
+          break;
+        }
+      }
+      depth--;
+      y -= Layout::dist_y;
+    }
+
+    if(cur == this && !cur->containsCoordinateAtDepth(x, 0)) {
+      return NULL;
+    }
+    return cur;
+  }
+
+  std::string
+  VisualNode::toolTip(BestNode*, int, int) {
+    return "";
+  }
+
+  /// \brief Helper functions for the layout algorithm
+  class Layouter {
+  public:
+    /// Compute distance needed between \a shape1 and \a shape2
+    template<class S1, class S2>
+    static int getAlpha(const S1& shape1, int depth1,
+                        const S2& shape2, int depth2);
+    /// Merge \a shape1 and \a shape2 into \a result with distance \a alpha
+    template<class S1, class S2>
+    static void merge(Extent* result,
+                      const S1& shape1, int depth1,
+                      const S2& shape2, int depth2, int alpha);
+  };
+
+  template<class S1, class S2>
+  int
+  Layouter::getAlpha(const S1& shape1, int depth1,
+                     const S2& shape2, int depth2) {
+    int alpha = Layout::minimalSeparation;
+    int extentR = 0;
+    int extentL = 0;
+    for (int i=0; i<depth1 && i<depth2; i++) {
+      extentR += shape1[i].r;
+      extentL += shape2[i].l;
+      alpha = std::max(alpha, extentR - extentL + Layout::minimalSeparation);
+    }
+    return alpha;
+  }
+
+  template<class S1, class S2>
+  void
+  Layouter::merge(Extent* result,
+                  const S1& shape1, int depth1,
+                  const S2& shape2, int depth2, int alpha) {
+    if (depth1 == 0) {
+      for (int i=depth2; i--;)
+        result[i] = shape2[i];
+    } else if (depth2 == 0) {
+      for (int i=depth1; i--;)
+        result[i] = shape1[i];
+    } else {
+      // Extend the topmost right extent by alpha.  This, in effect,
+      // moves the second shape to the right by alpha units.
+      int topmostL = shape1[0].l;
+      int topmostR = shape2[0].r;
+      int backoffTo1 =
+        shape1[0].r - alpha - shape2[0].r;
+      int backoffTo2 =
+        shape2[0].l + alpha - shape1[0].l;
+
+      result[0] = Extent(topmostL, topmostR+alpha);
+
+      // Now, since extents are given in relative units, in order to
+      // compute the extents of the merged shape, we can just collect the
+      // extents of shape1 and shape2, until one of the shapes ends.  If
+      // this happens, we need to "back-off" to the axis of the deeper
+      // shape in order to properly determine the remaining extents.
+      int i=1;
+      for (; i<depth1 && i<depth2; i++) {
+        Extent currentExtent1 = shape1[i];
+        Extent currentExtent2 = shape2[i];
+        int newExtentL = currentExtent1.l;
+        int newExtentR = currentExtent2.r;
+        result[i] = Extent(newExtentL, newExtentR);
+        backoffTo1 += currentExtent1.r - currentExtent2.r;
+        backoffTo2 += currentExtent2.l - currentExtent1.l;
+      }
+
+      // If shape1 is deeper than shape2, back off to the axis of shape1,
+      // and process the remaining extents of shape1.
+      if (i<depth1) {
+        Extent currentExtent1 = shape1[i];
+        int newExtentL = currentExtent1.l;
+        int newExtentR = currentExtent1.r;
+        result[i] = Extent(newExtentL, newExtentR+backoffTo1);
+        ++i;
+        for (; i<depth1; i++) {
+          result[i] = shape1[i];
+        }
+      }
+
+      // Vice versa, if shape2 is deeper than shape1, back off to the
+      // axis of shape2, and process the remaining extents of shape2.
+      if (i<depth2) {
+        Extent currentExtent2 = shape2[i];
+        int newExtentL = currentExtent2.l;
+        int newExtentR = currentExtent2.r;
+        result[i] = Extent(newExtentL+backoffTo2, newExtentR);
+        ++i;
+        for (; i<depth2; i++) {
+          result[i] = shape2[i];
+        }
+      }
+    }
+  }
+
+  void
+  VisualNode::setShape(Shape* s) {
+    if (shape != s)
+      Shape::deallocate(shape);
+    shape = s;
+    shape->computeBoundingBox();
+  }
+
+  void
+  VisualNode::computeShape(const NodeAllocator& na, VisualNode* root) {
+    int numberOfShapes = getNumberOfChildren();
+    Extent extent(Layout::extent);
+
+    int maxDepth = 0;
+    for (int i = numberOfShapes; i--;)
+      maxDepth = std::max(maxDepth, getChild(na,i)->getShape()->depth());
+    Shape* mergedShape;
+    if (getShape() && getShape()->depth() >= maxDepth+1) {
+      mergedShape = getShape();
+      mergedShape->setDepth(maxDepth+1);
+    } else {
+      mergedShape = Shape::allocate(maxDepth+1);
+    }
+
+    if (numberOfShapes == 1) {
+      getChild(na,0)->setOffset(0);
+      const Shape* childShape = getChild(na,0)->getShape();
+      for (int i=childShape->depth(); i--;)
+        (*mergedShape)[i+1] = (*childShape)[i];
+      (*mergedShape)[1].extend(- extent.l, - extent.r);
+      setShape(mergedShape);
+    } else {
+      // alpha stores the necessary distances between the
+      // axes of the shapes in the list: alpha[i].first gives the distance
+      // between shape[i] and shape[i-1], when shape[i-1] and shape[i]
+      // are merged left-to-right; alpha[i].second gives the distance between
+      // shape[i] and shape[i+1], when shape[i] and shape[i+1] are merged
+      // right-to-left.
+      assert(root->copy != NULL);
+      Region r(*root->copy);
+      std::pair<int,int>* alpha =
+        r.alloc<std::pair<int,int> >(numberOfShapes);
+
+      // distance between the leftmost and the rightmost axis in the list
+      int width = 0;
+
+      Extent* currentShapeL = r.alloc<Extent>(maxDepth);
+      int ldepth = getChild(na,0)->getShape()->depth();
+      for (int i=ldepth; i--;)
+        currentShapeL[i] = (*getChild(na,0)->getShape())[i];
+
+      // After merging, we can pick the result of either merging left or right
+      // Here we chose the result of merging right
+      Shape* rShape = getChild(na,numberOfShapes-1)->getShape();
+      int rdepth = rShape->depth();
+      for (int i=rdepth; i--;)
+        (*mergedShape)[i+1] = (*rShape)[i];
+      Extent* currentShapeR = &(*mergedShape)[1];
+
+      for (int i = 1; i < numberOfShapes; i++) {
+        // Merge left-to-right.  Note that due to the asymmetry of the
+        // merge operation, nextAlphaL is the distance between the
+        // *leftmost* axis in the shape list, and the axis of
+        // nextShapeL; what we are really interested in is the distance
+        // between the *previous* axis and the axis of nextShapeL.
+        // This explains the correction.
+
+        Shape* nextShapeL = getChild(na,i)->getShape();
+        int nextAlphaL =
+          Layouter::getAlpha<Extent*,Shape>(&currentShapeL[0], ldepth,
+                             *nextShapeL, nextShapeL->depth());
+        Layouter::merge<Extent*,Shape>(&currentShapeL[0],
+                                       &currentShapeL[0], ldepth,
+                                       *nextShapeL, nextShapeL->depth(), 
+                                       nextAlphaL);
+        ldepth = std::max(ldepth,nextShapeL->depth());
+        alpha[i].first = nextAlphaL - width;
+        width = nextAlphaL;
+
+        // Merge right-to-left.  Here, a correction of nextAlphaR is
+        // not required.
+        Shape* nextShapeR = getChild(na,numberOfShapes-1-i)->getShape();
+        int nextAlphaR =
+          Layouter::getAlpha<Shape,Extent*>(*nextShapeR, nextShapeR->depth(),
+                               &currentShapeR[0], rdepth);
+        Layouter::merge<Shape,Extent*>(&currentShapeR[0],
+                                       *nextShapeR, nextShapeR->depth(),
+                                       &currentShapeR[0], rdepth,
+                                       nextAlphaR);
+        rdepth = std::max(rdepth,nextShapeR->depth());
+        alpha[numberOfShapes - i].second = nextAlphaR;
+      }
+
+      // The merged shape has to be adjusted to its topmost extent
+      (*mergedShape)[1].extend(- extent.l, - extent.r);
+
+      // After the loop, the merged shape has the same axis as the
+      // leftmost shape in the list.  What we want is to move the axis
+      // such that it is the center of the axis of the leftmost shape in
+      // the list and the axis of the rightmost shape.
+      int halfWidth = false ? 0 : width / 2;
+      (*mergedShape)[1].move(- halfWidth);
+
+      // Finally, for the offset lists.  Now that the axis of the merged
+      // shape is at the center of the two extreme axes, the first shape
+      // needs to be offset by -halfWidth units with respect to the new
+      // axis.  As for the offsets for the other shapes, we take the
+      // median of the alphaL and alphaR values, as suggested in
+      // Kennedy's paper.
+      int offset = - halfWidth;
+      getChild(na,0)->setOffset(offset);
+      for (int i = 1; i < numberOfShapes; i++) {
+        offset += (alpha[i].first + alpha[i].second) / 2;
+        getChild(na,i)->setOffset(offset);
+      }
+      setShape(mergedShape);
+    }
+  }
+
+  size_t
+  VisualNode::size(void) const {
+    size_t s = sizeof(*this);
+    s += sizeof(Node*)*getNumberOfChildren();
+    if (shape && shape != Shape::leaf && shape != Shape::hidden) {
+      s += sizeof(Shape)+sizeof(Extent)*(shape->depth()-1);
+    }
+    if (copy)
+      s += static_cast<Space*>(Support::funmark(copy))->allocated();
+    s += (choice != NULL ? choice->size() : 0);
+    return s;
+  }
+
+}}
+
+// STATISTICS: gist-any