visualnode.hh

Go to the documentation of this file.

/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
/*
 *  Main authors:
 *     Guido Tack <tack@gecode.org>
 *
 *  Copyright:
 *     Guido Tack, 2006
 *
 *  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_VISUALNODE_HH
#define GECODE_GIST_VISUALNODE_HH

#include <gecode/gist/spacenode.hh>
#include <gecode/kernel.hh>
#include <string>

namespace Gecode { namespace Gist {

  class Layout {
  public:
    static const int dist_y = 38;
    static const int extent = 20;
    static const int minimalSeparation = 10;
  };

  class BoundingBox {
  public:
    int left;
    int right;
    BoundingBox(void) {}
  };

  class Extent {
  public:
    int l;
    int r;
    Extent(void);
    Extent(int l0, int r0);
    Extent(int width);

    void extend(int deltaL, int deltaR);
    void move(int delta);
  };

  class Shape {
  private:
    int _depth;
    BoundingBox bb;
    Extent shape[1];
    Shape(const Shape&);
    Shape& operator =(const Shape&);
    Shape(void);
  public:
    static Shape* allocate(int d);
    // Destruct
    static void deallocate(Shape*);

    static Shape* leaf;
    static Shape* hidden;

    int depth(void) const;
    void setDepth(int d);
    void computeBoundingBox(void);
    const Extent& operator [](int i) const;
    Extent& operator [](int i);
    bool getExtentAtDepth(int depth, Extent& extent);
    const BoundingBox& getBoundingBox(void) const;
  };

  class VisualNode : public SpaceNode {
  protected:
    enum VisualNodeFlags {
      DIRTY = SpaceNode::LASTBIT+1,
      CHILDRENLAYOUTDONE,
      HIDDEN,
      MARKED,
      ONPATH,
      BOOKMARKED
    };

    int offset;
    Shape* shape;

    bool containsCoordinateAtDepth(int x, int depth);
  public:
    VisualNode(int p);
    VisualNode(Space* root);

    bool isHidden(void);
    void setHidden(bool h);
    void setStop(bool h);
    void dirtyUp(const NodeAllocator& na);
    void layout(const NodeAllocator& na);
    int getOffset(void);
    void setOffset(int n);
    bool isDirty(void);
    void setDirty(bool d);
    bool childrenLayoutIsDone(void);
    void setChildrenLayoutDone(bool d);
    bool isMarked(void);
    void setMarked(bool m);
    bool isBookmarked(void);
    void setBookmarked(bool m);
    void pathUp(const NodeAllocator& na);
    void unPathUp(const NodeAllocator& na);
    bool isOnPath(void);
    int getPathAlternative(const NodeAllocator& na);
    void setOnPath(bool onPath0);

    void toggleHidden(const NodeAllocator& na);
    void hideFailed(const NodeAllocator& na, bool onlyDirty=false);
    void unhideAll(const NodeAllocator& na);
    void toggleStop(const NodeAllocator& na);
    void unstopAll(const NodeAllocator& na);

    Shape* getShape(void);
    void setShape(Shape* s);
    void computeShape(const NodeAllocator& na);
    BoundingBox getBoundingBox(void);
    void changedStatus(const NodeAllocator& na);
    VisualNode* findNode(const NodeAllocator& na, int x, int y);

    void labelBranches(NodeAllocator& na,
                       BestNode* curBest, int c_d, int a_d);
    void labelPath(NodeAllocator& na,
                   BestNode* curBest, int c_d, int a_d);
    std::string getBranchLabel(NodeAllocator& na,
                               VisualNode* p, const Choice* c,
                               BestNode* curBest, int c_d, int a_d, int alt);

    std::string toolTip(NodeAllocator& na, BestNode* curBest,
                        int c_d, int a_d);

    void dispose(void);
  };

}}

#include <gecode/gist/node.hpp>
#include <gecode/gist/spacenode.hpp>
#include <gecode/gist/visualnode.hpp>

#endif

// STATISTICS: gist-any