main page modules namespaces classes files
Gecode/J home

GistController.java

Go to the documentation of this file.

/* -*- indent-tabs-mode: nil -*- */
/*
 *  Main authors:
 *     Mikael Lagerkvist <lagerkvist@gecode.org>
 *     Guido Tack <tack@gecode.org>
 *
 *  Copyright:
 *     Mikael Lagerkvist, 2006
 *     Guido Tack, 2006
 *
 *  Last modified:
 *     $Date: 2006-11-01 16:12:24 +0100 (Wed, 01 Nov 2006) $ by $Author: tack $
 *     $Revision: 3857 $
 *
 *  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 org.gecode.*;
import org.gecode.gist.postscript.*;
import java.util.Hashtable;
import java.util.Enumeration;
import java.io.File;

public class GistController
    implements StatisticsListener {

    private Space _rootSpace;
    private boolean _bab;

    private SpaceNode _root;
    private SpaceNode _currentNode;

    private GistUIInterface _ui;

    private Statistics _stats;
    private int breakAfterSolutions = 0;
    private int solutionsSinceBreak = 0;
    private int breakAfterNodes = 0;
    private int nodesSinceBreak = 0;
    private boolean cancelSearch = false;

    private Hashtable<String, GistEventListener> _actionTable;
    private String _selectedAction;

    public GistController(Space rootSpace, boolean bab) {
        _rootSpace = rootSpace;
        _bab = bab;
        _stats = new Statistics();
        _stats.registerSolutionListener(this);
        _actionTable = new Hashtable<String, GistEventListener>();
        _selectedAction = "default";
        if (rootSpace instanceof GistEventListener) {
            GistEventListener e = (GistEventListener) rootSpace;
            _actionTable.put(e.getName(), e);
            _selectedAction=e.getName();
        }
    }

    public void selectInspectionAction(String action) {
        _selectedAction = action;
    }
    public String getSelectedAction() {
        return _selectedAction;
    }
    public Enumeration<String> getListeners() {
        return _actionTable.keys();
    }

    public void registerUI(GistUIInterface ui) {
        _ui = ui;
        _rootSpace.status(new long[1]);
        if (_rootSpace.failed()) {
            _root = ui.createRoot(_rootSpace, _bab, _stats);
        } else {
            _root = ui.createRoot(_rootSpace.cloneSpace(), _bab, _stats);
        }
        _currentNode = _root;
        _root.layout();
    }

    public void exploreOne() {
        breakAfterSolutions = 1;
        solutionsSinceBreak = 0;
        breakAfterNodes = Config.searchCutoff();
        nodesSinceBreak = 0;
        cancelSearch = false;
        DFS dfs = new DFS();
        dfs.setup(_currentNode);
        while ( (!dfs.step()) && (!cancelSearch) );
        searchDone();
    }

    public void exploreAll() {
        breakAfterSolutions = 0;
        breakAfterNodes = Config.searchCutoff();
        nodesSinceBreak = 0;
        cancelSearch = false;
        DFS dfs = new DFS();
        dfs.setup(_currentNode);
        while ( (!dfs.step()) && (!cancelSearch) );
        searchDone();
    }

    public void exploreN() {
        breakAfterSolutions = Config.n();
        solutionsSinceBreak = 0;
        breakAfterNodes = Config.searchCutoff();
        nodesSinceBreak = 0;
        cancelSearch = false;
        DFS dfs = new DFS();
        dfs.setup(_currentNode);
        while ( (!dfs.step()) && (!cancelSearch) );
        searchDone();
    }

    public void reset() {
        _stats.reset();
        if (_rootSpace.failed()) {
            _root = _ui.createRoot(_rootSpace, _bab, _stats);
        } else {
            _root = _ui.createRoot(_rootSpace.cloneSpace(), _bab, _stats);
        }
        _currentNode = _root;
        _root.dirtyUp();
        stateChanged();
    }

    public void saveAs() {
        File file = _ui.saveFilename();
        if (file != null) {
            String fn = file.getName().toLowerCase();
            if (! (fn.endsWith(".eps") || fn.endsWith(".ps") ) ) {
                file = new File(file.getParentFile(), fn+".eps");
            }
            if (file.exists() && ! _ui.overwriteDialog() ) {
                return;
            }
            try {
                Postscript.saveAs(_root,file);
            } catch (java.io.IOException e) {
                _ui.reportError("Error",
                                "Error while saving postscript file:\n"
                                        +e.getMessage());
            }
        }
    }
    
    public void addEventListener(GistEventListener e) {
        _actionTable.put(e.getName(), e);
        _selectedAction=e.getName();
        _ui.updateEventListeners();
    }

    public void setCurrentNode(SpaceNode c) {
        _currentNode = c;
        _ui.setCurrentNode(c);
        switch (_currentNode.getStatus()) {
        case FAILED :
            _ui.menuInspectActive(false, _currentNode.isRoot(), true);
            _ui.menuSearchActive(false);
            _ui.menuHideNodeActive(false, false);
            _ui.menuUnhideAllActive(false);
            _ui.menuHideFailedActive(false);
            break;
        case SOLVED:
            _ui.menuInspectActive(true, _currentNode.isRoot(), true);
            _ui.menuSearchActive(false);
            _ui.menuHideNodeActive(false, false);
            _ui.menuUnhideAllActive(false);
            _ui.menuHideFailedActive(false);
            break;
        case UNDETERMINED :
            _ui.menuInspectActive(true, _currentNode.isRoot(), false);
            _ui.menuSearchActive(true);
            _ui.menuHideNodeActive(false, false);
            _ui.menuUnhideAllActive(false);
            _ui.menuHideFailedActive(false);
            break;
        default:
            _ui.menuInspectActive(!_currentNode.isHidden(), 
                                  _currentNode.isRoot(), false);
            _ui.menuSearchActive(!_currentNode.isHidden() &&
                                 _currentNode.isOpen());
            _ui.menuHideNodeActive(true, _currentNode.isHidden());
            _ui.menuUnhideAllActive(true);
            _ui.menuHideFailedActive(!_currentNode.isHidden());
            break;
        }
    }

    public SpaceNode getCurrentNode() {
        return _currentNode;
    }

    private void invokeAction(SpaceNode node) {
        if (_selectedAction.equals("default")) {
            _ui.inspect(node.getSpace().toString());
        } else {
            GistEventListener el = _actionTable.get(_selectedAction);
            if (el != null) {
                el.nodeClickEvent(_ui, node);
            }
        }
    }

    public void inspect() {
        if (_currentNode.isHidden()) {
            toggleHidden();
            return;
        }
        switch (_currentNode.getStatus()) {
        case UNDETERMINED:
            {
                DFS dfs = new DFS();
                dfs.setup(_currentNode);
                dfs.step();
                stateChanged();
                break;
            }
        case FAILED:
            break;
        default:
            invokeAction(_currentNode);
            break;
        }

    }

    public void inspectBranches() {
        if (_currentNode.isHidden()) {
            toggleHidden();
            return;
        }
        switch (_currentNode.getStatus()) {
        case FAILED :
            break;
        case SOLVED:
            inspect();
            break;
        case UNDETERMINED:
            {
                DFS dfs = new DFS();
                dfs.setup(_currentNode);
                dfs.step();
                stateChanged();
                inspectBranches();
                break;
            }
        default:
            {
                String out = "";
                Space s = _currentNode.getSpace();
                s.status(new long[1]);
                long alt = s.description().alternatives();
                out += "There are " + alt + " branches available:\n";
                for (int i = 0; i < alt; ++i) {
                    out += "Branch " + i + "\n";
                    Space v = s.cloneSpace();
                    v.status(new long[1]);
                    BranchingDesc desc = v.description();
                    v.commit(desc, i);
                    out += "\t" + v.toString().replaceAll("\n", "\n\t").trim() + "\n";
                }
                _ui.inspect(out);
                break;
            }
        }        
    }

    public void inspectBeforePropagation() {
        if (_currentNode == _root) return;
        if (_currentNode.isHidden()) {
            toggleHidden();
            return;
        }
        switch (_currentNode.getStatus()) {
        case UNDETERMINED:
            {
                DFS dfs = new DFS();
                dfs.setup(_currentNode);
                dfs.step();
                stateChanged();
                inspectBeforePropagation();
                break;
            }
        default:
            {
                String out = "Before propagation:\n";
                Space s = ((SpaceNode)_currentNode.getParent()).getSpace();
                s.status(new long[1]); 
                BranchingDesc desc = s.description();
                s.commit(desc, _currentNode.getAlternative());
                out += "\t" + s.toString().replaceAll("\n", "\n\t").trim() + "\n";
                _ui.inspect(out);
                break;
            }
        }        
    }

    public int[] getStatistics() {
        int[] res = new int[5];

        res[0] = _stats.getSolutions();
        res[1] = _stats.getFailures();
        res[2] = _stats.getChoices();
        res[3] = _stats.getUndetermined();
        res[4] = _stats.getDepth();

        return res;
    }
    
    public SpaceNode getRoot() {
        return _root;
    }

    public void toggleHidden() {
        _currentNode.toggleHidden();
        stateChanged();
    }
    public void hideFailed() {
        _currentNode.hideFailed();
        stateChanged();
    }
    public void unhideAll() {
        _currentNode.unhideAll();
        stateChanged();
    }

    public void newSolution(int solutions) {
        solutionsSinceBreak++;
        if (breakAfterSolutions != 0 &&
            solutionsSinceBreak>=breakAfterSolutions)
            cancelSearch = true;
    }

    public void newNode() {
        nodesSinceBreak++;
        if (breakAfterNodes != 0 &&
            nodesSinceBreak>=breakAfterNodes)
            cancelSearch = true;
    }

    public void scaleToFit() {
        _ui.scaleToFit();
    }

    public void searchDone() {
        if (Config.hide())
          _currentNode.hideFailed();
        stateChanged();        
    }

    private void stateChanged() {
        _root.layout();
        if (Config.zoom())
          _ui.scaleToFit();
        _ui.update();
        setCurrentNode(_currentNode);
    }


    public void navUp() {
        SpaceNode p = (SpaceNode) _currentNode.getParent();
        if (p != null)
            setCurrentNode(p);
    }
    public void navDown() {
        if (_currentNode.getStatus() == NodeStatus.BRANCH &&
            !_currentNode.isHidden())
            setCurrentNode((SpaceNode)_currentNode.getChild(0));
    }
    public void navLeft() {
        SpaceNode p = (SpaceNode) _currentNode.getParent();
        if (p != null) {
            int alt = _currentNode.getAlternative();
            if (alt > 0)
                setCurrentNode((SpaceNode) p.getChild(alt-1));
        }
    }
    public void navRight() {
        SpaceNode p = (SpaceNode) _currentNode.getParent();
        if (p != null) {
            int alt = _currentNode.getAlternative();
            if (alt + 1 < p.getNumberOfChildren())
                setCurrentNode((SpaceNode) p.getChild(alt+1));
        }
    }

    private void findNextSolution(SpaceNode current) {
        SpaceNode p = current;
        int alt;
        while (true) {
            if (p.getStatus() == NodeStatus.SOLVED) {
                setCurrentNode(p);
                return;
            } else if (p.hasSolvedChildren()) {
                p = (SpaceNode) p.getChild(0);
            } else if (p.getParent() != null) {
                SpaceNode pp = (SpaceNode)p.getParent();
                alt = p.getAlternative();
                if (alt + 1 < pp.getNumberOfChildren()) {
                    p = (SpaceNode)pp.getChild(alt+1);
                } else {
                    return;
                }
            } else {
                return;
            }
        }
    }

    public void jumpNextSol() {

        if (_currentNode.getStatus() != NodeStatus.SOLVED &&
            _currentNode.hasSolvedChildren()) {
            findNextSolution(_currentNode);
            return;
        }

        SpaceNode p = (SpaceNode) _currentNode.getParent();
        int alt = _currentNode.getAlternative();
        while (p != null) {
            if (alt + 1 < p.getNumberOfChildren() &&
                ((SpaceNode)p.getChild(alt+1)).hasSolvedChildren() ) {
                p = (SpaceNode) p.getChild(alt+1);                
                findNextSolution(p);
                return;
            } else {
                alt = p.getAlternative();
                p = (SpaceNode) p.getParent();
            }
        }
    }
    public void jumpPrevSol() {
        SpaceNode p = (SpaceNode) _currentNode.getParent();
        int alt = _currentNode.getAlternative();
        while (p != null) {
            if (alt > 0 &&
                ((SpaceNode)p.getChild(alt-1)).hasSolvedChildren() ) {
                
                p = (SpaceNode) p.getChild(alt-1);

                while (true) {
                    if (p.getStatus() == NodeStatus.SOLVED) {
                        setCurrentNode(p);
                        return;
                    } else if (p.hasSolvedChildren()) {
                        p = (SpaceNode) p.getChild(p.getNumberOfChildren()-1);
                    } else if (p.getParent() != null) {
                        SpaceNode pp = (SpaceNode)p.getParent();
                        alt = p.getAlternative();
                        if (alt > 0) {
                            p = (SpaceNode)pp.getChild(alt-1);
                        } else {
                            return;
                        }
                    } else {
                        return;
                    }
                }
            } else {
                alt = p.getAlternative();
                p = (SpaceNode) p.getParent();
            }
        }

    }

    public void jumpRoot() {
        setCurrentNode(_root);
    }
    public void jumpLeftmost() {
        SpaceNode p = _root;
        while (p.getNumberOfChildren() > 0) {
            p = (SpaceNode) p.getChild(0);
        }
        setCurrentNode(p);
    }
    public void jumpRightmost() {
        SpaceNode p = _root;
        while (p.getNumberOfChildren() > 0) {
            p = (SpaceNode) p.getChild(p.getNumberOfChildren()-1);
        }
        setCurrentNode(p);
    }
    
    public void centerCursor() {
        _ui.centerCursor();
    }
}