main page modules namespaces classes files
Gecode/J home

UINode.java

Go to the documentation of this file.

/*
 *  Main authors:
 *     Guido Tack <tack@gecode.org>
 *
 *  Copyright:
 *     Guido Tack, 2006
 *
 *  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.swing;

import java.awt.Graphics2D;

import java.awt.Point;
import java.awt.geom.Line2D;

//import java.awt.geom.*;
import org.gecode.explorer.*;
import org.gecode.Gecode;
import org.gecode.Space;

class UINode extends SpaceNode {
    final static Shape unitShape =
        new Shape(new Extent(unit), new Shape(new Extent(unit+halfUnit)));

    GraphicsNode gNode;

    static HiddenNode hiddenNode = new HiddenNode();

    boolean marked = false;
    boolean hasShadow = false;

    public UINode(Space root, boolean bab, Statistics stats) {
        super(root,stats);
        if (bab) {
                initCurBest(new BestSpace());
        }
        gNode = new UnknownNode();
    }
    public UINode(int alternative, BestSpace best, Statistics stats) {
        super(alternative, best, stats);
        gNode = new UnknownNode();
    }

    public void mark() {
        marked = true;
    }
    public void unmark() {
        marked = true;
    }
    public void togglemark() {
        marked = !marked;
    }

    public int getWidth() { return unit; }
    protected Shape getUnknownShape() { return unitShape; }
    protected Shape getHiddenShape() { return unitShape; }

    public void drawNode(Object graphicsContext, int x, int y) {
        Graphics2D g2 = (Graphics2D) graphicsContext;
        if (isHidden()) {
            hiddenNode.draw(g2, x, y, hasShadow, hasFailedChildren(),
                            hasSolvedChildren(), isOpen());
        } else {
            gNode.draw(g2, x, y, hasShadow);
        }
    }


    public void move(int xoff) {}
    public void connect(Object graphicsContext,
                        int x, int y,
                        int momX, int momY) {
        
        Graphics2D g2 = (Graphics2D) graphicsContext;
        g2.setPaint(GraphicsNode.fg);
        g2.setStroke(GraphicsNode.stroke);
        
        Point realCoords = ((UINode)getParent()).gNode.getConnector(momX, momY);
        
        g2.draw(new Line2D.Double(x, y, realCoords.x, realCoords.y));
    }
    public SpaceNode createChild(int i) {
        return new UINode(i, curBest, stats);
    }

    public VisualNode findNodeForPoint(int x, int y) {
        Coordinate foundPoint = new Coordinate();
        UINode found = (UINode) super.findNode(x, y, foundPoint);
        if (found != null) {
            if (found.isHidden()) {
                if (hiddenNode.containsPoint(foundPoint))
                    return found;
            } else {
                if (found.gNode.containsPoint(foundPoint))
                    return found;
            }
        }
        return null;
    }

    public int getNumberOfChildNodes() {
        if (getStatus() == Undetermined) {
            int kids = super.getNumberOfChildNodes();
            switch(getStatus()) {
            case FAILED:
                gNode = new FailureNode();
                break;
            case SOLVED:
                gNode = new SuccessNode();
                break;
            case BRANCH:
                gNode = new ChoiceNode();
                break;
            }
            return kids;
        } else {
            return super.getNumberOfChildNodes();
        }
    }
}