main page modules namespaces classes files
Gecode/J home

VisualNode.java

Go to the documentation of this file.

/* -*- indent-tabs-mode: nil -*- */
/*
 *  Main authors:
 *     Marco Kuhlmann <kuhlmann@ps.uni-sb.de>
 *     Guido Tack <tack@gecode.org>
 *
 *  Copyright:
 *     Marco Kuhlmann, 2005
 *     Guido Tack, 2006
 *
 *  Last modified:
 *     $Date: 2006-10-26 11:31:58 +0200 (Thu, 26 Oct 2006) $ by $Author: tack $
 *     $Revision: 3796 $
 *
 *  This file is part of Gecode, the generic constraint
 *  development environment:
 *     http://www.gecode.org
 *
 *  See the file "LICENSE" for information on usage and
 *  redistribution of this file, and for a
 *     DISCLAIMER OF ALL WARRANTIES.
 *
 */

package org.gecode.gist;

import java.util.*;

abstract public class VisualNode extends Node {

    protected static int unit = 100;
    protected static int halfUnit = unit / 2;
    
    public static int horizontalOffset = halfUnit;
    public static int verticalOffset = unit + unit;
    
    // relative offset with respect to parent node
    protected int offset;
    
    // flag; true if the node needs re-display
    private boolean dirty = false;
    private boolean hidden = false;
    
    // shape and bounding box associated to the node
    private Shape shape;
    private BoundingBox boundingBox;
        
    public VisualNode() {
        super();
    }
    
    // return the width of the node
    abstract public int getWidth();
    
    protected abstract Shape getUnknownShape();
    protected abstract Shape getHiddenShape();

    public void hide() {
        if (! hidden) {
            hidden = true;
            dirtyUp();
        }
    }
    
    public void unhide() {
        if (hidden) {
            hidden = false;
            dirtyUp();
        }
    }
    
    public void toggleHidden() {
        hidden = ! hidden;
        dirtyUp();
    }

    public boolean isHidden() {
        return hidden;
    }

    public void unhideAll() {
        DefaultNodeCursor cursor =
            new DefaultNodeCursor(this) {
                public void processCurrentNode() {
                    ((VisualNode) getCurrentNode()).unhide();
                }
            };
        PreOrderNodeVisitor visitor = new PreOrderNodeVisitor(cursor);
        visitor.run();
    }
    
    public void dirtyUp() {
            VisualNode cur = this;
        while (! cur.dirty) {
            cur.dirty = true;
            if (! cur.isRoot()) {
                cur = (VisualNode) cur.getParent();
            }
        }
    }
    
    public void layout() {
        LayoutCursor cursor = new LayoutCursor(this);
        PostOrderNodeVisitor visitor = new PostOrderNodeVisitor(cursor);
        visitor.run();
    }
        
    public boolean containsCoordinateAtDepth(int x, int depth) {
        if (x < boundingBox.left ||
            x > boundingBox.right ||
            depth > boundingBox.depth) {
            return false;
        }
        Extent theExtent = shape.getExtentAtDepth(depth);
        if (theExtent != null) {
            return (theExtent.extentL <= x && x <= theExtent.extentR);
        } else {
            return false;
        }
    }
    
    public VisualNode findNode(int x, int y, Coordinate coordinate) {
        VisualNode cur = this;
        int depth = y / verticalOffset;

        while (depth > 0 && cur != null) {
            if (cur.isHidden()) {
                break;
            }
            Iterator childrenIterator = cur.childrenIterator();
            cur = null;
            while (childrenIterator.hasNext()) {
                VisualNode nextChild = (VisualNode) childrenIterator.next();
                int newX = x - nextChild.offset;
                if (nextChild.containsCoordinateAtDepth(newX, depth - 1)) {
                    cur = nextChild;
                    x = newX;
                    break;
                }
            }
            depth = depth-1;
            y = y - verticalOffset;
        }
        coordinate.set(x, y);
        return cur;
    }

    public Coordinate coordinates() {
        VisualNode cur = this;
        Coordinate p = new Coordinate(0,0);
        while (cur != null) {
            p.set(p.x() + cur.offset,
                  p.y() + verticalOffset);
            cur = (VisualNode) cur.getParent();
        }
        return p;
    }
    
    public abstract void drawNode(Object graphicsContext, int x, int y);
    public abstract void connect(Object graphicsContext, int x, int y, int momX, int momY);
    
    public void draw(Object graphicsContext, Rect clippingRect) {
        DrawingCursor cursor = new DrawingCursor(this, graphicsContext, clippingRect);
        PreOrderNodeVisitor visitor = new PreOrderNodeVisitor(cursor);
        visitor.run();
    }
    
    public BoundingBox getBoundingBox() {
        return boundingBox;
    }
    
    public int getOffset() {
        return offset;
    }
    
    public void setOffset(int theOffset) {
        offset = theOffset;
    }
    
    public int getVerticalOffset() {
        return verticalOffset;
    }
    
    public boolean isDirty() {
        return dirty;
    }
    
    public void setDirty(boolean newDirty) {
        dirty = newDirty;
    }
    
    public int getHorizontalOffset() {
        return horizontalOffset;
    }
    
    public void setBoundingBox(BoundingBox theBoundingBox) {
        boundingBox = theBoundingBox;
    }
    
    public void setShape(Shape theShape) {
        shape = theShape;
    }
    
    public Shape getShape() {
        return shape;
    }
    
}