JavaInterface/tests/EclipseMapColourer.java

// BEGIN LICENSE BLOCK
// Version: CMPL 1.1
//
// The contents of this file are subject to the Cisco-style Mozilla Public
// License Version 1.1 (the "License"); you may not use this file except
// in compliance with the License.  You may obtain a copy of the License
// at www.eclipse-clp.org/license.
//
// Software distributed under the License is distributed on an "AS IS"
// basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See
// the License for the specific language governing rights and limitations
// under the License.
//
// The Original Code is  The ECLiPSe Constraint Logic Programming System.
// The Initial Developer of the Original Code is  Cisco Systems, Inc.
// Portions created by the Initial Developer are
// Copyright (C) 2002 - 2006 Cisco Systems, Inc.  All Rights Reserved.
//
// Contributor(s): Andrew Cheadle, IC-Parc
//
// END LICENSE BLOCK

/*
 * EclipseMapColourer.java
 *
 * Program:   ECLiPSe Java Map Colouring Demo
 * System:    ECLiPSe Constraint Logic Programming System
 * Author/s    Andrew Cheadle, IC-Parc
 */


// Class imports
import java.awt.*;
import java.awt.event.*;
import javax.swing.event.*;
import javax.swing.JMenu;
import javax.swing.JMenuItem;
import javax.swing.JMenuBar;
import javax.swing.JRadioButtonMenuItem;
import javax.swing.ButtonGroup;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JDialog;
import javax.swing.JPanel;
import javax.swing.JTextArea;
import javax.swing.JTextField;
import javax.swing.JLabel;
import javax.swing.JSlider;
import javax.swing.border.BevelBorder;
import javax.swing.border.EtchedBorder;
import javax.swing.JFileChooser;
import javax.swing.JOptionPane;
import javax.swing.ImageIcon;
import java.io.*;
import java.awt.image.*;
import java.util.Vector;
import java.awt.geom.Rectangle2D;
import javax.swing.filechooser.FileFilter;
import com.parctechnologies.eclipse.*;

// The application is implemented by extending the
// swing JFrame class.
public class EclipseMapColourer extends JFrame
{
  // Class constructor
  public EclipseMapColourer()
  {
    // Construct a JFrame with the appropriate title
    super("Java ECLiPSe Map Colouring Demo");

    // Build and layout the main map colouring frame
    buildApplicationFrame();

    // Build and layout the map resizing dialog
    buildmapSizeDialog();

    // Create a Map file chooser
    mapFileChooser = new JFileChooser();

    // Add a file filter to the MAP file selector
    mapFileChooser.addChoosableFileFilter(new MapFileFilter());

    // Colouring thread is not running
    colouringThread = null;
  }

  // Build and layout the main map colouring frame
  private void buildApplicationFrame()
  {
    // Control Panel
    controlButtonPanel = new JPanel();

    runButton = new JButton();
    // When the 'Run' button is clicked start map colouring
    runButton.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent evt) {
          startSearch();
        }
      });

    moreButton = new JButton();
    // When the 'More' button is clicked continue map colouring
    moreButton.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent evt) {
          continueSearch();
        }
      });

    finishButton = new JButton();
    // When the 'Finish' button is clicked terminate map colouring
    finishButton.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent evt) {
          endSearch();
        }
      });

    // Default ImageBuffer - blank
    imageBuffer = new BufferedImage(100, 100,
                                    BufferedImage.TYPE_INT_ARGB);

    // Panel for displaying (coloured) map
    mapPanel = new MapPanel();

    // Panel and text are for status bar
    statusPanel = new JPanel();
    statusPanel.setLayout(new GridLayout(1, 1));
    statusPanel.setBorder(new BevelBorder(BevelBorder.LOWERED));
    statusTextArea = new JTextArea();
    statusTextArea.setBackground(new Color(204, 204, 204));
    statusTextArea.setEditable(false);
    statusTextArea.setText(" Status: ");
    statusTextArea.setToolTipText("Status of Map colouring");
    statusPanel.add(statusTextArea);

    // Menus
    menuBar = new JMenuBar();

    // File, New Map, Map Size..., Exit
    fileMenu = new JMenu();
    newMapMenuItem = new JMenuItem();
    mapSizeMenuItem = new JMenuItem();
    exitMenuItem = new JMenuItem();

    // Method
    methodMenu = new JMenu();

    // Solver
    solverMenu = new JMenu();
    solverButtonGroup = new ButtonGroup();
    fdMenuItem = new JRadioButtonMenuItem();
    icMenuItem = new JRadioButtonMenuItem();
    delayTilGrndMenuItem = new JRadioButtonMenuItem();
    prologMenuItem = new JRadioButtonMenuItem();

    // Value Choice
    valueChoiceMenu = new JMenu();
    valueChoiceButtonGroup = new ButtonGroup();
    indomainMenuItem = new JRadioButtonMenuItem();
    indomainRandomMenuItem = new JRadioButtonMenuItem();
    rotateColoursMenuItem = new JRadioButtonMenuItem();

    // Variable Selection
    variableSelectionMenu = new JMenu();
    variableSelectionButtonGroup = new ButtonGroup();
    inputOrderMenuItem = new JRadioButtonMenuItem();
    firstFailMenuItem = new JRadioButtonMenuItem();
    occurrenceMenuItem = new JRadioButtonMenuItem();
    mostConstrainedMenuItem = new JRadioButtonMenuItem();
    antiFirstFailMenuItem = new JRadioButtonMenuItem();

    // Help
    helpMenu = new JMenu();
    aboutMenuItem = new JMenuItem();
    aboutMenuItem.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent evt) {
          JOptionPane.showMessageDialog(null, "JAVA ECLiPSe Map Colouring " +
                                        "Demo\nCopyright: Cisco Systems Inc, 2002\n",
                                        "About ECLiPSe Map Colourer...",
                                        JOptionPane.PLAIN_MESSAGE,
                                        new ImageIcon("ic-parc.gif"));
        }
      });

    // Configure menus
    setJMenuBar(menuBar);

    // File, New Map, Map Size..., Exit
    fileMenu.setText("File");
    newMapMenuItem.setText("New Map...");
    newMapMenuItem.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent evt) {
          chooseMapFile();
        }
      });
    fileMenu.add(newMapMenuItem);
    mapSizeMenuItem.setText("Map Size...");
    mapSizeMenuItem.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent evt) {
          mapSizeDialog.show();
        }
      });
    fileMenu.add(mapSizeMenuItem);
    fileMenu.addSeparator();
    exitMenuItem.setText("Exit");
    exitMenuItem.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent evt) {
          exitForm();
        }
      });
    fileMenu.add(exitMenuItem);
    menuBar.add(fileMenu);


    // Method
    methodMenu.setText("Method");
    menuBar.add(methodMenu);

    // Solver
    solverMenu.setText("Solver");
    methodMenu.add(solverMenu);

    // FD
    fdMenuItem.setSelected(true);
    fdMenuItem.setText("FD");
    fdMenuItem.setActionCommand("fd");
    solverMenu.add(fdMenuItem);
    solverButtonGroup.add(fdMenuItem);

    // IC
    icMenuItem.setText("IC");
    icMenuItem.setActionCommand("ic");
    solverMenu.add(icMenuItem);
    solverButtonGroup.add(icMenuItem);

    // Delay Until Ground
    delayTilGrndMenuItem.setText("Delay Until Ground");
    delayTilGrndMenuItem.setActionCommand("delay");
    solverMenu.add(delayTilGrndMenuItem);
    solverButtonGroup.add(delayTilGrndMenuItem);

    // Prolog
    prologMenuItem.setText("Prolog (Generate & Test)");
    prologMenuItem.setActionCommand("prolog");
    solverMenu.add(prologMenuItem);
    solverButtonGroup.add(prologMenuItem);

    // Value Choice
    valueChoiceMenu.setText("Value Choice");
    methodMenu.add(valueChoiceMenu);

    // Indomain
    indomainMenuItem.setText("In-Domain");
    indomainMenuItem.setSelected(true);
    indomainMenuItem.setActionCommand("indomain");
    valueChoiceMenu.add(indomainMenuItem);
    valueChoiceButtonGroup.add(indomainMenuItem);

    // Indomain_random
    indomainRandomMenuItem.setText("Random-In-Domain");
    indomainRandomMenuItem.setActionCommand("indomain_random");
    valueChoiceMenu.add(indomainRandomMenuItem);
    valueChoiceButtonGroup.add(indomainRandomMenuItem);

    // Rotate Colours
    rotateColoursMenuItem.setText("Rotate Colours");
    rotateColoursMenuItem.setActionCommand("rotate");
    valueChoiceMenu.add(rotateColoursMenuItem);
    valueChoiceButtonGroup.add(rotateColoursMenuItem);

    // Variable Selection
    variableSelectionMenu.setText("Variable Selection");
    methodMenu.add(variableSelectionMenu);

    // Input Order
    inputOrderMenuItem.setText("Input Order");
    inputOrderMenuItem.setSelected(true);
    inputOrderMenuItem.setActionCommand("input_order");
    variableSelectionMenu.add(inputOrderMenuItem);
    variableSelectionButtonGroup.add(inputOrderMenuItem);

    // First-Fail
    firstFailMenuItem.setText("First-Fail");
    firstFailMenuItem.setActionCommand("first_fail");
    variableSelectionMenu.add(firstFailMenuItem);
    variableSelectionButtonGroup.add(firstFailMenuItem);

    // Occurrence
    occurrenceMenuItem.setText("Occurrence");
    occurrenceMenuItem.setActionCommand("occurrence");
    variableSelectionMenu.add(occurrenceMenuItem);
    variableSelectionButtonGroup.add(occurrenceMenuItem);

    // Most Contrained
    mostConstrainedMenuItem.setText("Most Constrained");
    mostConstrainedMenuItem.setActionCommand("most_constrained");
    variableSelectionMenu.add(mostConstrainedMenuItem);
    variableSelectionButtonGroup.add(mostConstrainedMenuItem);

    // Anti-First-Fail
    antiFirstFailMenuItem.setText("Anti-First-Fail");
    antiFirstFailMenuItem.setActionCommand("anti_first_fail");
    variableSelectionMenu.add(antiFirstFailMenuItem);
    variableSelectionButtonGroup.add(antiFirstFailMenuItem);

    // Help
    helpMenu.setText("Help");
    menuBar.add(helpMenu);

    // About
    aboutMenuItem.setText("About");
    helpMenu.add(aboutMenuItem);

    // Configure window

    // Listen for the window close event
    addWindowListener(new WindowAdapter() {
        public void windowClosing(WindowEvent evt) {
          exitForm();
        }
      });

    // Set a grid layout for the control panel
    controlButtonPanel.setLayout(new GridLayout(1, 3));

    // Add the Run button
    runButton.setText("Run");
    runButton.setToolTipText("Start map colouring search");
    runButton.setBorder(new BevelBorder(BevelBorder.RAISED));
    controlButtonPanel.add(runButton);

    // Add the More button
    moreButton.setText("More");
    moreButton.setToolTipText("Find next map colouring solution");
    moreButton.setBorder(new BevelBorder(BevelBorder.RAISED));
    moreButton.setEnabled(false);
    controlButtonPanel.add(moreButton);

    // Add the Finish button
    finishButton.setText("Finish");
    finishButton.setToolTipText("Terminate map colouring search");
    finishButton.setBorder(new BevelBorder(BevelBorder.RAISED));
    finishButton.setEnabled(false);
    controlButtonPanel.add(finishButton);

    // Place the control panel at the top of the window
    getContentPane().add(controlButtonPanel, BorderLayout.NORTH);

    // Place the map panel in the center of the window
    getContentPane().add(mapPanel, BorderLayout.CENTER);

    // Place the status panel at the bottom of the window
    getContentPane().add(statusPanel, BorderLayout.SOUTH);

    // Lay everything out neatly
    pack();
  }

  // Build and layout the map resizing dialog
  private void buildmapSizeDialog()
  {
    // Map size and scaling modal dialog box
    mapSizeDialog = new JDialog(this, "Map Size", true);
    mapSizeDialog.setResizable(false);
    mapSizeDialog.getContentPane().setLayout(new GridLayout(1,1));
    mapSizeDialog.setSize(332, 94);

    // An etched frame to enclose the widgets
    mapSizePanel = new JPanel();
    mapSizePanel.setLayout(null);
    mapSizePanel.setBorder(new EtchedBorder());

    // Map sizing widgets
    mapSizeLabel = new JLabel();
    mapSizeLabel.setText("Map size:");
    mapSizeLabel.setBounds(10, 10, 58, 16);
    mapSizePanel.add(mapSizeLabel);

    mapSizeSlider = new JSlider();
    mapSizeSlider.setMinorTickSpacing(1);
    mapSizeSlider.setBounds(73, 10, 192, 16);
    mapSizeSlider.addChangeListener(new ChangeListener() {
        public void stateChanged(ChangeEvent e) {
          JSlider source = (JSlider)e.getSource();
          if (!source.getValueIsAdjusting()) {
            mapSizeTextField.setText("" + source.getValue());
          }
        }
      });
    mapSizePanel.add(mapSizeSlider);

    mapSizeTextField = new JTextField();
    mapSizeTextField.setBorder(new BevelBorder(BevelBorder.LOWERED));
    mapSizeTextField.setHorizontalAlignment(JTextField.CENTER);
    mapSizeTextField.setBounds(270, 8, 40, 20);
    mapSizePanel.add(mapSizeTextField);

    // Map scaling widgets
    mapScalingLabel = new JLabel();
    mapScalingLabel.setText("Map scale:");
    mapScalingLabel.setBounds(10, 40, 64, 16);
    mapSizePanel.add(mapScalingLabel);

    mapScalingTextField = new JTextField();
    mapScalingTextField.setBorder(new BevelBorder(BevelBorder.LOWERED));
    mapScalingTextField.setHorizontalAlignment(JTextField.CENTER);
    mapScalingTextField.setText("" + scalingFactor);
    mapScalingTextField.setBounds(80, 38, 110, 20);
    mapSizePanel.add(mapScalingTextField);

    // 'Ok' button closes window and re-sizes/re-scales the map
    mapSizeOkButton = new JButton();
    mapSizeOkButton.setText("Ok");
    mapSizeOkButton.setBorder(new BevelBorder(BevelBorder.RAISED));
    mapSizeOkButton.setBounds(206, 40, 50, 20);
    mapSizeOkButton.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent evt) {
          int newScalingFactor, newMapSize;

          newScalingFactor = (new Integer(mapScalingTextField.getText())).intValue();
          newMapSize = (new Integer(mapSizeTextField.getText())).intValue();
          resizeMap(newMapSize, newScalingFactor);
          mapSizeDialog.hide();
        }
      });
    mapSizePanel.add(mapSizeOkButton);

    // 'Close' button just closes the window
    mapSizeCancelButton = new JButton();
    mapSizeCancelButton.setText("Cancel");
    mapSizeCancelButton.setBorder(new BevelBorder(BevelBorder.RAISED));
    mapSizeCancelButton.setBounds(262, 40, 50, 20);
    mapSizeCancelButton.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent evt) {
          mapSizeDialog.hide();
        }
      });
    mapSizePanel.add(mapSizeCancelButton);

    mapSizeDialog.getContentPane().add(mapSizePanel);
  }

  // Exit the application - the window is closed or 'Exit' is selected
  private void exitForm()
  {
    // Stop the thread - otherwise System.exit() will wait for thread
    // completion, i.e. map colouring to complete
    if (colouringThread != null) {
      // Thread.stop() is deprecated, however, the thread is
      // only ever stopped at termination - the reasons cited
      // for not using Thread.stop() do not apply. Because of
      // the Java - ECLiPSe control model, it is better to do this
      // than litter the code with checks for an 'exit variable'
      // becoming 'true' and the exit not being actioned until
      // control returns from ECLiPSe to one of these cancellation
      // points.
      colouringThread.stop();
    }

    try {
      // Destroy the Eclipse
      ((EmbeddedEclipse) eclipse).destroy();
    }
    catch(Exception expn) {
      System.out.println("Exception caught whilst " +
                         "destroying ECLiPSe engine: " +
                         expn.getMessage());
    }

    // Exit!!
    System.exit(0);
  }

  // Open the map file selector dialog and on selection
  // of a file compile the map data
  private void chooseMapFile()
  {
    int returnVal = mapFileChooser.showOpenDialog(this);
    if(returnVal == JFileChooser.APPROVE_OPTION) {
      compileMapData(mapFileChooser.getSelectedFile().getAbsolutePath());
    }
  }

  // The 'Run' button has been clicked, initiate map
  // colouring solution search
  private void startSearch()
  {
    // Set the status
    statusTextArea.setText(" Status: Colouring map - searching for a solution");

    // Kick off a new thread that passes control to the ECLiPSe engine
    // and waits for completion of the 'colouring' predicate. This must
    // be done in a new thread otherwise the Java AWT event handling thread
    // will be used and whilst ECLiPSe has control. As a result the user won't
    // be able to perform any interaction and the map will not be updated with
    // colours in real-time.
    (colouringThread = new Thread() {
        public void run() {

          CompoundTerm result;
          solutionCount = 0;

          // Disable operations that are not allowed whilst colouring is
          // in progress.
          runButton.setEnabled(false);
          methodMenu.setEnabled(false);
          newMapMenuItem.setEnabled(false);
          mapSizeMenuItem.setEnabled(false);

          // Pass control to the embedded ECLiPSe engine and execute
          // the 'colouring' predicate
          try {
	    Object[] colouringArgs = {new Atom(solverButtonGroup.getSelection().getActionCommand()),

                                      new Atom(variableSelectionButtonGroup.getSelection().getActionCommand()),
				      new Atom(valueChoiceButtonGroup.getSelection().getActionCommand()),
                                      new Integer(mapSize), null, null};

            result = eclipse.rpc(new CompoundTermImpl("colouring", colouringArgs));

            // The top-level functor of the goal term is 'colouring'.
            // The fifth and sixth arguments are the return arguments
            // with the number of backtracks performed and the execution time. The
            // remaining arguments are populated from the radio button menu items.
            Integer backtracks = (Integer)result.arg(5);
            Double time = (Double)result.arg(6);

            if (backtracks != null) {
              statusTextArea.setText(" Status: " + solutionCount + " solution(s) found " +
                                     "in " + time.doubleValue() + " seconds with " +
                                     backtracks.intValue() + " backtracks");
            }
            else {
              statusTextArea.setText(" Status: " + solutionCount + " solution(s) found " +
                                     "in " + time.doubleValue() + " seconds");
            }
          }
          catch(Exception msqExpn) {
            System.out.println( "Exception caught whilst invoking " +
                                "remote predicate 'colouring': " +
                                msqExpn.getMessage());
          }

          // Colouring completed - enable all operations
          runButton.setEnabled(true);
          methodMenu.setEnabled(true);
          newMapMenuItem.setEnabled(true);
          mapSizeMenuItem.setEnabled(true);

          // Colouring thread is not running
          colouringThread = null;
        }
      }).start();
  }

  // The 'Continue' button has been clicked, continue map
  // colouring solution search
  private void continueSearch()
  {
    // Set the status
    statusTextArea.setText(" Status: Colouring map - searching for a solution");

    // Disable operations that are not allowed whilst colouring is
    // in progress.
    moreButton.setEnabled(false);
    finishButton.setEnabled(false);

    // Indicate (another) solution has been found
    solutionCount ++;

    // Pass control back to ECLiPSe indicating it should
    // continue the search
    controlDataProducer.writeContinueAction("yes");
  }

  // The 'Finish' button has been clicked, terminate map
  // colouring solution search
  private void endSearch()
  {
    // Enable/disable the appropriate operations
    runButton.setEnabled(true);
    moreButton.setEnabled(false);
    finishButton.setEnabled(false);
    methodMenu.setEnabled(true);
    newMapMenuItem.setEnabled(true);
    mapSizeMenuItem.setEnabled(true);

    // Indicate (another) solution has been found
    solutionCount ++;

    // Pass control back to ECLiPSe indicating it should
    // terminate the search
    controlDataProducer.writeContinueAction("no");
  }

  // Draw the map on the image buffer and set the size of the
  // application frame appropriately
  private void setupMap()
  {
    int cnt, rectCnt;
    Rectangle rect;
    Graphics2D gbi = imageBuffer.createGraphics();

    gbi.setColor(Color.gray);

    // Draw and fill every rectangle for every country
    for(cnt = 0; cnt < mapSize; cnt++) {
      for(rectCnt = 0; rectCnt < countries[cnt].size(); rectCnt++) {
        rect = (Rectangle)countries[cnt].elementAt(rectCnt);
        gbi.draw(rect);
        gbi.fill(rect);
      }
    }

    // Set the size of the application frame appropriately
    this.setSize(maxWidth + 20, maxHeight + 35 +
                 controlButtonPanel.getHeight() +
                 menuBar.getHeight() + statusPanel.getHeight());
  }

  // The map size and scale has been updated, reflect this on the
  // map
  private void resizeMap(int newMapSize, int newScalingFactor)
  {
    int cnt, rectCnt, x, y, width, height;
    Rectangle rect, newRect;
    Vector[] newCountries;

    // A new vector for the new country dimensions
    newCountries = new Vector[maxMapSize];

    // No longer no the maximum width and height of the image buffer
    maxWidth = 0;
    maxHeight = 0;

    // Apply scaling to every rectangle of every country
    for(cnt = 0; cnt < maxMapSize; cnt++) {
      newCountries[cnt] = new Vector();
      for(rectCnt = 0; rectCnt < countries[cnt].size(); rectCnt++) {
        rect = (Rectangle)countries[cnt].elementAt(rectCnt);
        x = (((rect.x - 1) / scalingFactor) * newScalingFactor) + 1;
        y = (((rect.y - 1) / scalingFactor) * newScalingFactor) + 1;
        width = (((rect.width + 2) / scalingFactor) * newScalingFactor) - 2;
        height = (((rect.height + 2) / scalingFactor) * newScalingFactor) - 2;

        newRect = new Rectangle(x, y, width, height);

          newCountries[cnt].addElement(newRect);

          // Update the maximum width and height of the image buffer
          if ( width > maxWidth ) maxWidth = width;
          if ( height > maxHeight ) maxHeight = height;
      }
    }

    // Update the scaling and sizing factors
    mapSize = newMapSize;
    scalingFactor = newScalingFactor;

    // Update the countries data structure
    countries = newCountries;

    // Create a new image buffer
    imageBuffer = new BufferedImage(maxWidth, maxHeight,
                                    BufferedImage.TYPE_INT_ARGB);

    // Draw the map on the image buffer and set the size of the
    // application frame appropriately
    setupMap();

    // Make a request for components to be laid out by
    // the layout manmager
    validate();

    // Redraw the window
    repaint();
  }

  // A colour translation function translating the prolog map colours
  // to appropriate Java colours
  private Color convertColour(String colour)
  {
    if (colour.equals("green")) return Color.green;
    if (colour.equals("purple")) return Color.magenta;
    if (colour.equals("red")) return Color.red;
    if (colour.equals("yellow")) return Color.yellow;
    if (colour.equals("darkgray")) return Color.gray;

    System.out.println("Colour '" + colour + "' is unmapped.");
    return Color.white;
  }

  // A country has been update with a new colour - reflect this
  // on the map
  private void updateMap(int countryIndex, String colour)
  {
    int rectCnt;
    Rectangle rect;
    Graphics2D gbi = (Graphics2D)imageBuffer.getGraphics();

    gbi.setColor(convertColour(colour));

    // Draw and fill every rectangle of the country in the appropriate
    // colour
    for(rectCnt = 0; rectCnt < countries[countryIndex].size(); rectCnt++) {
      rect = (Rectangle)countries[countryIndex].elementAt(rectCnt);
      gbi.draw(rect);
      gbi.fill(rect);

      // Redraw the window
      repaint();
    }
  }

  // When initialising, compile a default map file
  private void compileDefaultMapData()
  {
    // Get the pathname separator, e.g. '/' (UNIX) or a '\'
    // (Windows)
    String seperator = System.getProperty("file.separator");

    // Locate the default map file
    String defaultMapFile =
      System.getProperty("eclipse.directory") +
      seperator + "lib_tcl" + seperator + "map_data.map";

    // Compile the default map data
    compileMapData(defaultMapFile);
  }

  // Instruct the embedded ECLiPSe engine to compile a
  // new map file and pass it control to do so the
  // country data will be received on the 'setup_map' queue
  private void compileMapData(String filename)
  {
    CompoundTerm result;

    // Make an embedded ECLiPSe call to 'init_map' predicate
    try {

      result = eclipse.rpc( new CompoundTermImpl("init_map", filename, null));

      // The top-level functor of the goal term is 'init_map'.
      // The first and second arguments of the goal term are the
      // filename and the maximum size of the map. It is the second
      // argument that we're interested in.
      Integer retMaxMapSize = (Integer)result.arg(2);

      // Reflect the map size in the appropriate variables and
      // window widgets
      mapSize = maxMapSize = retMaxMapSize.intValue();
      mapSizeSlider.setMaximum(maxMapSize);
      mapSizeSlider.setValue(maxMapSize);
      mapSizeTextField.setText("" + mapSize);
    }
    catch(Exception msqExpn) {
      System.out.println( "Exception caught whilst invoking " +
                          "remote predicate 'init_map': " +
                          msqExpn.getMessage());
      return;
    }

    // Create a fixed size array containing dynamic arrays of
    // rectangles to store the country data. Each country is represented
    // as a dynamic array of rectangles
    countries = new Vector[maxMapSize];

    // Make an embedded ECLiPSe call to 'get_map_data' predicate
    try {
      result = eclipse.rpc( new CompoundTermImpl("get_map_data",
                                new Integer(mapSize)));
    }
    catch(Exception msqExpn) {
      System.out.println( "Exception caught whilst invoking " +
                          "remote predicate 'get_map_data': " +
                          msqExpn.getMessage());
    }

    repaint();
    statusTextArea.setText(" Status: Map file '" + filename
                           + "' loaded");
  }

  // Embed an ECLiPSe engine, initialise it, compile in the
  // map colouring program and setup the 'setup_map',
  // 'update_map' and 'continue' Java - ECLiPSe EXDR
  // interface queues
  private void loadECLiPSeMapColouringEngine()
  {
    String seperator;

    eclipseEngineOptions = new EclipseEngineOptions();

    // Connect the Eclipse's standard streams to the JVM's
    eclipseEngineOptions.setUseQueues(false);

    try {
      // Initialise Eclipse
      eclipse = EmbeddedEclipse.getInstance(eclipseEngineOptions);
    }
    catch(Exception expn) {
      System.out.println("Exception caught whilst " +
                         "initialising ECLiPSe engine: " +
                         expn.getMessage());
      System.exit(0);
    }

    seperator = System.getProperty("file.separator");

    // Locate the map colouring program
    mapColouringProgram = new File(System.getProperty("eclipse.directory") +
                                   seperator + "lib_tcl" + seperator +
                                   "mapcolour.ecl");

    // Compile the map colouring solver
    try {
      eclipse.compile(mapColouringProgram);
    }
    catch(Exception miscExpn) {
      System.out.println( "Exception caught whilst compiling " +
                          "'mapcolour.ecl': " +
                          miscExpn.getMessage());
      System.exit(0);
    }

    // Set up the java representation of the queue streams
    try {
      continueQueue = eclipse.getToEclipseQueue("continue");
    }
    catch(Exception cqExpn) {
      System.out.println( "Exception caught whilst creating " +
                          "continue queue: " +
                          cqExpn.getMessage());
      System.exit(0);
    }

    // Add a producer to the continueQueue ToEclipseQueue
    try {
      controlDataProducer = new ControlDataProducer();
      continueQueue.setListener(controlDataProducer);
    }
    catch(IOException cqIOExpn) {
      System.out.println( "I/O Exception caught whilst creating " +
                          "control queue listener: " +
                          cqIOExpn.getMessage());
      System.exit(0);
    }

    try {
      setupMapQueue = eclipse.getFromEclipseQueue("setup_map");
    }
    catch(Exception msqExpn) {
      System.out.println( "Exception caught whilst creating " +
                          "map setup queue: " +
                          msqExpn.getMessage());
      System.exit(0);
    }

    // Add a listener to the setupMapQueue FromEclipseQueue
    try {
      setupMapQueue.setListener(new SetupMapDataListener());
    }
    catch(IOException msqIOExpn) {
      System.out.println( "I/O Exception caught whilst creating " +
                          "map setup queue listener: " +
                          msqIOExpn.getMessage());
      System.exit(0);
    }

    try {
      updateMapQueue = eclipse.getFromEclipseQueue("update_map");
    }
    catch(Exception muqExpn) {
      System.out.println( "Exception caught whilst creating " +
                          "map update queue: " +
                          muqExpn.getMessage());
      System.exit(0);
    }

    // Add a listener to the updateMapQueue FromEclipseQueue
    try {
      updateMapQueue.setListener(new UpdateMapDataListener());
    }
    catch(IOException muqIOExpn) {
      System.out.println( "I/O Exception caught whilst creating " +
                          "map update queue listener: " +
                          muqIOExpn.getMessage());
      System.exit(0);
    }
  }

  // Static 'main' function defining the application -
  // load the default map data and show the application frame
  public static void main(String args[])
  {
    EclipseMapColourer mapColourerApp;

    // Construct the application frame
    mapColourerApp = new EclipseMapColourer();

    // Initialise and configure ECLiPSe engine
    mapColourerApp.loadECLiPSeMapColouringEngine();

    // Create the EclipseMapColourer

    // Load the default map data
    mapColourerApp.compileDefaultMapData();

    // Open the EclipseMapColourer frame
    mapColourerApp.setResizable(false);
    mapColourerApp.show();
  }

  // Private class variable declarations

  // GUI objects
  private JMenuItem aboutMenuItem;
  private JRadioButtonMenuItem rotateColoursMenuItem;
  private JRadioButtonMenuItem indomainRandomMenuItem;
  private JMenu fileMenu;
  private JPanel controlButtonPanel;
  private MapPanel mapPanel;
  private JPanel statusPanel;
  private JTextArea statusTextArea;
  private JMenuBar menuBar;
  private JMenu valueChoiceMenu;
  private JRadioButtonMenuItem fdMenuItem;
  private JMenu variableSelectionMenu;
  private JMenuItem mapSizeMenuItem;
  private JButton moreButton;
  private JRadioButtonMenuItem delayTilGrndMenuItem;
  private JButton finishButton;
  private JRadioButtonMenuItem firstFailMenuItem;
  private JMenu methodMenu;
  private JRadioButtonMenuItem antiFirstFailMenuItem;
  private JButton runButton;
  private JRadioButtonMenuItem indomainMenuItem;
  private JRadioButtonMenuItem inputOrderMenuItem;
  private JMenu solverMenu;
  private JMenuItem exitMenuItem;
  private JMenuItem newMapMenuItem;
  private JRadioButtonMenuItem icMenuItem;
  private JRadioButtonMenuItem prologMenuItem;
  private JRadioButtonMenuItem mostConstrainedMenuItem;
  private JRadioButtonMenuItem occurrenceMenuItem;
  private JMenu helpMenu;
  private ButtonGroup solverButtonGroup;
  private ButtonGroup valueChoiceButtonGroup;
  private ButtonGroup variableSelectionButtonGroup;
  private JFileChooser mapFileChooser;
  private JDialog mapSizeDialog;
  private JPanel mapSizePanel;
  private JLabel mapSizeLabel;
  private JSlider mapSizeSlider;
  private JTextField mapSizeTextField;
  private JLabel mapScalingLabel;
  private JTextField mapScalingTextField;
  private JButton mapSizeOkButton;
  private JButton mapSizeCancelButton;

  // Map related objects
  private Vector[] countries;
  private int scalingFactor = 20;
  private BufferedImage imageBuffer;
  private int maxWidth;
  private int maxHeight;
  private Thread colouringThread;
  private int maxMapSize;
  private int mapSize;
  private int solutionCount;

  // ECLiPSe Objects

  // Create some default Eclipse options
  private EclipseEngineOptions eclipseEngineOptions;

  // Object representing the Eclipse process
  private EclipseEngine eclipse;

  // Path of the Eclipse program
  private File mapColouringProgram;

  // Data going out from java
  private ToEclipseQueue continueQueue;
  private ControlDataProducer controlDataProducer;

  // Data coming in from eclipse
  private FromEclipseQueue setupMapQueue;
  private FromEclipseQueue updateMapQueue;

  // Define an inner class that extends a JPanel
  // allowing us to display an image buffer on it
  class MapPanel extends JPanel
  {
    // Override the update() and paint()
    // methods to draw our image buffer
    // on the appropriate graphics context

    public void update(Graphics g)
    {
      super.update(g);
      paint(g);
    }

    public void paint(Graphics g)
    {
      super.paint(g);
      g.drawImage(imageBuffer,0,0, this);
    }
  }

  // Define inner class that allows the JFileChooser
  // to filter possible file selections to those with
  // '.map' extensions.
  class MapFileFilter extends FileFilter
  {
    // Whether a file should be filtered or not
    public boolean accept(File f) {
      if (f.isDirectory()) {
        return true;
      }

      String extension = getExtension(f);
      if (extension != null) {
        if (extension.equals("map") ||
            extension.equals("MAP")) {
          return true;
        } else {
          return false;
        }
      }

      return false;
    }

    // The description of this filter
    public String getDescription() {
      return "Map files";
    }

    // Locate the file extension
    private String getExtension(File f)
    {
      String s = f.getName();
      int i = s.lastIndexOf('.');
      if (i > 0 &&  i < s.length() - 1)
        return s.substring(i+1).toLowerCase();
      return "";
    }
  }

  // Define an inner class that reads map country data
  // from the 'setup_map' queue populated by ECLiPSe
  // engine during 'get_map_data' predicate call. The
  // uncoloured map is then drawn.
  class SetupMapDataListener implements QueueListener
  {
    FromEclipseQueue input_queue_stream = null;
    EXDRInputStream input_queue_stream_formatted = null;

    // Called when Eclipse flushes source
    public void dataAvailable(Object source)
    {
      CompoundTerm data;
      int x1, y1, x2, y2, countryIndex;
      Rectangle rect;

      // Reset the maximum size of the map
      maxWidth = 0;
      maxHeight = 0;

      if(input_queue_stream == null)
      {
	input_queue_stream = (FromEclipseQueue) source;
	input_queue_stream_formatted =
	  new EXDRInputStream(input_queue_stream);
      }

      try
      {
        // Repeatedly read terms from stream until 'end' atom is read
        for ( ;; ) {
          data = (CompoundTerm)input_queue_stream_formatted.readTerm();
          if (data.functor().equals("end")) break;

          // Add a rectangle for the appropriate country - note the
          // index in the data structure is the country name - 1
          countryIndex = ((Integer)(data.arg(1))).intValue() - 1;
          x1 = (((Integer)(data.arg(2))).intValue() * scalingFactor) + 1;
          y1 = (((Integer)(data.arg(3))).intValue() * scalingFactor) + 1;
          x2 = (((Integer)(data.arg(4))).intValue() * scalingFactor) - 1;
          y2 = (((Integer)(data.arg(5))).intValue() * scalingFactor) - 1;

          rect = new Rectangle(x1, y1, x2-x1, y2-y1);
          if (countries[countryIndex] == null) {
            countries[countryIndex] = new Vector();
          }

          countries[countryIndex].addElement(rect);

          // Update the maximum width and height of the image buffer
          if ( x2 > maxWidth ) maxWidth = x2;
          if ( y2 > maxHeight ) maxHeight = y2;
        }
      } catch(IOException ioe){
        System.out.println( "I/O Exception caught whilst reading data on" +
                            "'setup_map' queue: " +
                            ioe.getMessage());
        return;
      }

      // Calculate the size of the image buffer
      imageBuffer = new BufferedImage(maxWidth, maxHeight,
                                      BufferedImage.TYPE_INT_ARGB);

      // Draw the uncoloured map
      setupMap();
    }

    // Required to implement QueueListener
    public void dataRequest(Object source)
    {
    }
  }

  // Define an inner class that reads map country data
  // from the 'update_map' queue populated by ECLiPSe
  // engine during 'colouring' predicate call. The
  // map is then drawn with the appropriate country (re)coloured.
  class UpdateMapDataListener implements QueueListener
  {
    FromEclipseQueue input_queue_stream = null;
    EXDRInputStream input_queue_stream_formatted = null;

    // Called when Eclipse flushes source
    public void dataAvailable(Object source)
    {
      CompoundTerm data;

      if(input_queue_stream == null)
      {
	input_queue_stream = (FromEclipseQueue) source;
	input_queue_stream_formatted =
	  new EXDRInputStream(input_queue_stream);
      }

      try
      {
        // Repeatedly read terms from stream while data is available
        // The first argument is the map name/number, the second is an
        // atom indicating the new colour of the country
        while(((InputStream) source).available() > 0)
        {
          data = (CompoundTerm)input_queue_stream_formatted.readTerm();
          updateMap(((Integer)(data.arg(1))).intValue() - 1,
            ((Atom)(data.arg(2))).functor());
        }
      } catch(IOException ioe){
        System.out.println( "I/O Exception caught whilst reading data on" +
                            "'update_map' queue: " +
                            ioe.getMessage());
      }
    }

    // Required to implement QueueListener
    public void dataRequest(Object source)
    {
    }
  }

  // Define an inner class that writes the search control data
  // to the 'control' queue that ECLiPSe engine reads from having
  // found a solution in the 'colouring' predicate call.
  // The call will block the thread until the user presses the 'More'
  // or 'Finish' button. We use the Java wait()/notify() mechanism to
  // coordinate this.
  class ControlDataProducer implements QueueListener
  {
    private ToEclipseQueue output_queue_stream = null;
    private EXDROutputStream output_queue_stream_formatted = null;
    private Atom continueAction = null;

    // Required to implement QueueListener
    public void dataAvailable(Object source)
    {
    }

    // Called when Eclipse tries to read from source when it is empty.
    // A solution has been found, wait for user action
    public synchronized void dataRequest(Object source)
    {
      int tmpSolutionCount = solutionCount + 1;

      if(output_queue_stream == null)
      {
	output_queue_stream = (ToEclipseQueue) source;
	output_queue_stream_formatted =
	  new EXDROutputStream(output_queue_stream);
      }

      statusTextArea.setText(" Status: " + tmpSolutionCount +
                             " solution(s) found. Continue search?");
      runButton.setEnabled(false);
      moreButton.setEnabled(true);
      finishButton.setEnabled(true);

      while(continueAction == null) {
        try
        {
          wait();
        } catch(Exception expn){
          System.out.println( "Exception caught whilst waiting " +
                              "on user continue action: " +
                              expn.getMessage());
        }
      }

      // Write the user action
      try
      {
        output_queue_stream_formatted.write(continueAction);
        output_queue_stream_formatted.flush();
      } catch(IOException ioe){
        System.out.println( "I/O Exception caught whilst writing " +
                            "continue action: " +
                            ioe.getMessage());
      }

      continueAction = null;
    }

    // The user has clicked 'More' or 'Finish' button, indicate this
    // action to the paused colouring thread
    public synchronized void writeContinueAction(String action)
    {
      continueAction = new Atom(action);
      notify();
    }
  }
}