main page modules namespaces classes files
Gecode/J home

PostscriptCursor.java

Go to the documentation of this file.

/*
 *  Main authors:
 *     Marco Kuhlmann <kuhlmann@ps.uni-sb.de>
 *
 *  Copyright:
 *     Marco Kuhlmann, 2005
 *
 *  Last modified:
 *     $Date: 2006-02-09 16:32:56 +0100 (Thu, 09 Feb 2006) $ by $Author: tack $
 *     $Revision: 2943 $
 *
 *  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.explorer.postscript;

import org.gecode.explorer.*;
import java.util.ArrayList;

public class PostscriptCursor extends DefaultNodeCursor {
    protected static final int verticalOffset = 38;

    protected static final PSColor black = new PSColor(0.0,0.0,0.0);
    protected static final PSColor blue = new PSColor(0.0,0.36,0.63);
    protected static final PSColor white = new PSColor(1.0,1.0,1.0);
    protected static final PSColor red = new PSColor(0.85,0.14,0.11);
    protected static final PSColor green = new PSColor(0.04,0.46,0.27);
    protected static final PSColor lightgray = new PSColor(0.92,0.92,0.92);
    
    int x;
    int y;

    ArrayList<Path> ps;
    
    public PostscriptCursor(SpaceNode theNode, ArrayList<Path> ps0) {
        super(theNode);
        this.x = 0;
        this.y = 0;
        this.ps = ps0;
    }
    
    private SpaceNode getSpaceNode() {
        return ((SpaceNode) super.getCurrentNode());
    }
    
    public void moveUpwards() {
        SpaceNode currentNode = getSpaceNode();
        x = x - currentNode.getOffset();
        y = y - verticalOffset;
        super.moveUpwards();
    }
        
    public boolean mayMoveDownwards() {
        return (super.mayMoveDownwards() &&
                ! getSpaceNode().isHidden() );
    }
    
    public void moveDownwards() {
        super.moveDownwards();
        SpaceNode currentNode = getSpaceNode();
        x = x + currentNode.getOffset();
        y = y + verticalOffset;
    }
    
    public void moveSidewards() {
        x = x - getSpaceNode().getOffset();
        super.moveSidewards();
        x = x + getSpaceNode().getOffset();
    }
    
/*    private boolean isClipped() {
        return false;
    }*/

    private void drawHidden(ArrayList<Path> ps, int x, int y,
                            boolean solved, boolean open)
    {
        PSColor fill = solved ? green : red;
        ps.add(new Triangle(x,-y+10,x-16,-y-38,x+16,-y-38,black,fill));
    }
    private void drawFailed(ArrayList<Path> ps, int x, int y)
    {
        ps.add(new Rectangle(x-7,-y+7,x+7,-y-7,black,red));
    }
    private void drawSolved(ArrayList<Path> ps, int x, int y)
    {
        ps.add(new Diamond(x, -y-10, 10, black, green));
    }
    private void drawChoice(ArrayList<Path> ps, int x, int y)
    {
        ps.add(new Circle(x, -y, 10, black, blue));
    }
    private void drawUndetermined(ArrayList<Path> ps, int x, int y)
    {
        ps.add(new Circle(x, -y, 10, black, white));
    }
    
    public void processCurrentNode() {
        SpaceNode currentNode = getSpaceNode();
        int parentX = (x - currentNode.getOffset())/5;
        int myx = x / 5;
        int parentY = y - verticalOffset;
        if (! currentNode.isRoot()) {
            if (currentNode.isHidden()) {
                ps.add(new Line(myx, -y+10, parentX, -y+28, black));
            } else {
                switch(currentNode.getStatus()) {
                    case SOLVED:
                    case UNDETERMINED:
                    case BRANCH:
                        ps.add(new Line(myx, -y+10, parentX, -y+28, black));
                        break;
                    case FAILED:
                        ps.add(new Line(myx, -y+7, parentX, -y+28, black));
                        break;
                }
            }
        }
        if (currentNode.isHidden()) {
            drawHidden(ps, myx, y,
                       currentNode.hasSolvedChildren(),
                       currentNode.isOpen());
        } else {
            switch(currentNode.getStatus()) {
                case UNDETERMINED:
                    drawUndetermined(ps,myx,y);
                    break;
                case FAILED:
                    drawFailed(ps,myx,y);
                    break;
               case SOLVED:
                   drawSolved(ps,myx,y);
                    break;
               case BRANCH:
                   drawChoice(ps,myx,y);
                    break;
            }
        }
    }
    
}