/*
 * Licensed Materials - Property of Rogue Wave Software, Inc. 
 * © Copyright Rogue Wave Software, Inc. 2014, 2015 
 * © Copyright IBM Corp. 2009, 2014
 * © Copyright ILOG 1996, 2009
 * All Rights Reserved.
 *
 * Note to U.S. Government Users Restricted Rights:
 * The Software and Documentation were developed at private expense and
 * are "Commercial Items" as that term is defined at 48 CFR 2.101,
 * consisting of "Commercial Computer Software" and
 * "Commercial Computer Software Documentation", as such terms are
 * used in 48 CFR 12.212 or 48 CFR 227.7202-1 through 227.7202-4,
 * as applicable.
 */

import ilog.views.IlvGrapher;
import ilog.views.IlvHandlesSelection;
import ilog.views.IlvManagerView;
import ilog.views.IlvTransformer;
import ilog.views.IlvRect;

import ilog.views.interactor.IlvSelectInteractor;
import ilog.views.interactor.IlvZoomViewInteractor;

import ilog.views.swing.IlvJScrollManagerView;
import ilog.views.swing.IlvJManagerViewControlBar;

import ilog.views.graphlayout.IlvGraphLayout;
import ilog.views.graphlayout.IlvGraphLayoutReport;
import ilog.views.graphlayout.IlvGraphLayoutException;
import ilog.views.graphlayout.IlvGrapherAdapter;
import ilog.views.graphlayout.GraphLayoutEvent;
import ilog.views.graphlayout.GraphLayoutEventListener;
import ilog.views.graphlayout.random.IlvRandomLayout;
import ilog.views.graphlayout.uniformlengthedges.IlvUniformLengthEdgesLayout;

import ilog.views.util.IlvProductUtil;
import ilog.views.util.IlvResourceUtil;
import ilog.views.util.IlvLocaleUtil;

import ilog.views.util.swing.IlvSwingUtil;
  
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.util.*;
import java.net.*;
import java.io.*;
import java.text.*;

/**
 * This is a very simple applet/application that shows how to use the
 * stopImmediate method to stop a running layout.
 * This is a multi threaded version.
 * The applet allows to randomize the graph, stop start layout or to stop
 * layout. The layout is animated.
 * This applet is not based on CSS styling.
 */
public class StopLayoutApplet 
  extends JApplet
{
  static {
    // This applet is designed to run only with default resource bundle
    // and various selected other resource bundles.
    // Setting the available resource suffixes avoids that the applet
    // tries to load resource bundles for other locales over the net,
    // even if the current locale of the browser is different.
    if (IlvResourceUtil.isInApplet())
      IlvResourceUtil.setAvailableResourceSuffixes("", "_ja");

    // Test code whether the demo works in RTL locales
    // Locale newLocale = new Locale("he");
    // IlvSwingUtil.setDefaultLocale(newLocale);
  }

  {
    // This sample uses JViews Diagrammer features. When deploying an
    // application that includes this code, you need to be in possession
    // of a JViews Diagrammer Deployment license.
    IlvProductUtil.DeploymentLicenseRequired(
        IlvProductUtil.JViews_Diagrammer_Deployment);
  }

  /** The grapher */
  IlvGrapher grapher = new IlvGrapher();

  /** The view of the grapher */
  IlvManagerView mgrview = new IlvManagerView(grapher);

  /** An instance of the Uniform Length Edges Layout algorithm */
  IlvUniformLengthEdgesLayout layout = new IlvUniformLengthEdgesLayout();

  /** An instance of the Random Layout algorithm */
  IlvRandomLayout randomLayout = new IlvRandomLayout();

  /** Whether the applet is busy */
  boolean busy = false;

  /** A text field to display messages */
  JTextField msgLine = new JTextField();

  /** The chooses for file and layout style */
  JComboBox fileChooser = new JComboBox();

  /** A graph layout event listener */
  GraphLayoutIterationListener layoutListener = new GraphLayoutIterationListener(this);

  /** The buttons */
  JButton randomButton = new JButton(getString("RandomizeButton.Label"));
  JButton layoutButton = new JButton(getString("StartLayoutButton.Label"));
  JButton stopButton = new JButton(getString("StopLayoutButton.Label"));

  /**
   * Initializes the applet/application.
   */
  public void init()
  {
    showMessage(getString("InitMessage"));

    JPanel panel;
    super.init();

    // attach the grapher to the layout instances
    IlvGrapherAdapter adapter = new IlvGrapherAdapter(grapher);
    adapter.setAnimationRedrawMode(IlvManagerView.THREADED_REDRAW);
    layout.attach(adapter);
    randomLayout.attach(adapter);

    // Because the nodes can have different sizes, ask the Uniform Length Edges 
    // layout to take into account the size of each node
    layout.setRespectNodeSizes(true);

    // many iterations
    layout.setAllowedNumberOfIterations(100000);

    // animation should be on
    layout.setAnimate(true);

    // install the layout iteration listener on the layout instance
    layout.addGraphLayoutEventListener(layoutListener);

    // use manager coordinates
    layout.setCoordinatesMode(IlvGraphLayout.MANAGER_COORDINATES);
    randomLayout.setCoordinatesMode(IlvGraphLayout.MANAGER_COORDINATES);

    // create the scroll manager view 
    IlvJScrollManagerView scrollManView = new IlvJScrollManagerView(mgrview);

    // Some settings on the manager view and on the scroll manager view
    mgrview.setAntialiasing(true);
    mgrview.setKeepingAspectRatio(true);
    mgrview.setBackground(Color.white);
    mgrview.setForeground(SystemColor.windowText);   
    Color xc = SystemColor.windowText;
    xc = new Color(255-xc.getRed(), 255-xc.getGreen(), 255-xc.getBlue());
    mgrview.setDefaultXORColor(xc);
    mgrview.setDefaultGhostColor(SystemColor.windowText);
    mgrview.setZoomFactorRange(0.003, 10.0);

    // Settings parameters for selection handles
    IlvHandlesSelection.defaultHandleColor = Color.black;
    IlvHandlesSelection.defaultHandleBackgroundColor = Color.white;
    IlvHandlesSelection.defaultHandleShape = IlvHandlesSelection.SQUARE_SHAPE;

    // set the layout manager
    getContentPane().setLayout(new BorderLayout(0,0));

    // fit so far all together
    getContentPane().add("Center", scrollManView);
    getContentPane().add("North", panel = new JPanel());
    panel.setLayout(new FlowLayout(FlowLayout.LEADING));

    // create the standard control bar
    IlvJManagerViewControlBar controlBar = new IlvJManagerViewControlBar();
    controlBar.setView(mgrview);
    panel.add(controlBar);

    // modify the interactors such that the demo looks better
    ((IlvSelectInteractor)controlBar.getSelectInteractor()).setOpaqueMove(true);
    ((IlvZoomViewInteractor)controlBar.getZoomViewInteractor()).setPermanent(true);

    // set the initial interactor
    mgrview.setInteractor(controlBar.getSelectInteractor());

    // graph selection 
    panel.add(new JLabel(getString("fileChooser.Label")));    
    panel.add(fileChooser);
    fileChooser.addItem("demo1");
    fileChooser.addItem("demo2");    
    fileChooser.setToolTipText(getString("fileChooser.Tooltip"));
    fileChooser.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent event) {
          if (busy) {
            showMessage(getString("AnimRunningMessage"));
            return;
          }
          JComboBox comboBox = (JComboBox)event.getSource();
          String fileName = (String)comboBox.getSelectedItem();
          loadGrapher(fileName);
        }
      });

    // create the panel on bottom
    JPanel bottomPanel = new JPanel();
    bottomPanel.setLayout(new BorderLayout());
    getContentPane().add("South", bottomPanel);

    // the panel with the buttons
    JPanel buttonPanel = new JPanel();
    buttonPanel.setLayout(new FlowLayout(FlowLayout.LEADING));
    buttonPanel.add(randomButton);
    buttonPanel.add(layoutButton);
    buttonPanel.add(stopButton);
    bottomPanel.add("North", buttonPanel);

    randomButton.setToolTipText(getString("RandomizeButton.Tooltip"));
    randomButton.addActionListener(new ActionListener() {
      public void actionPerformed(ActionEvent e) {
        if (busy) {
          showMessage(getString("LayoutRunningMessage"));
          return;
        }
        Thread layoutThread =
          new Thread(new GraphLayoutPerformer(
            StopLayoutApplet.this, randomLayout, grapher));
        layoutThread.start();
      }
    });

    layoutButton.setToolTipText(getString("StartLayoutButton.Tooltip"));
    layoutButton.addActionListener(new ActionListener() {
      public void actionPerformed(ActionEvent e) {
        if (busy) {
          showMessage(getString("LayoutRunningMessage"));
          return;
        }
        Thread layoutThread =
          new Thread(new GraphLayoutPerformer(
            StopLayoutApplet.this, layout, grapher));
        layoutThread.start();
      }
    });

    stopButton.setToolTipText(getString("StopLayoutButton.Tooltip"));
    stopButton.addActionListener(new ActionListener() {
      public void actionPerformed(ActionEvent e) {
        if (busy)
          showMessage(getString("LayoutStoppedMessage"));
        else
          showMessage(getString("NoStopMessage"));
        layout.stopImmediately();
      }
    });

    // add the message line to the bottom panel
    bottomPanel.add("South", msgLine);
    msgLine.setEditable(false);

    // set the component orientation according to the locale
    Locale loc = IlvSwingUtil.getDefaultLocale();
    ComponentOrientation co = ComponentOrientation.getOrientation(loc);
    getContentPane().applyComponentOrientation(co);

    // load a sample grapher
    loadGrapher("demo1");

    // wait for the users input
    busy = false;
  }

  /**
   * Called when this applet is being reclaimed in order to destroy
   * any resources that it has allocated.
   */
  public void destroy()
  {
    super.destroy();

    // This method is intended to workaround memory management issues
    // in the Sun JRE. Please refer to the method documentation for more
    // details and a description of the known issues.
    IlvSwingUtil.cleanupApplet();
  }

  /**
   * Allows you to run the demo as a standalone application.
   */
  public static void main(String[] arg)
  {
    // Sun recommends that to put the entire GUI initialization into the
    // AWT thread
    SwingUtilities.invokeLater(
      new Runnable() {
        public void run() {
          StopLayoutApplet applet = new StopLayoutApplet();
          applet.init();

          JFrame frame = new JFrame(getString("Frame.Label"));
          frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
          frame.setSize(600, 600);
          frame.getContentPane().add(applet);
          frame.setVisible(true);
        }
      });
  }

  /**
   * Load a sample IVL file.
   * @param fileNameBase The base of the filename, excluding the path prefix
   *                     and the extension suffix.
   */
  private void loadGrapher(String fileNameBase)
  {
    try {
      showMessage(getString("FileReadingStartMessage"), fileNameBase);
      grapher.deleteAll(false);
      try {
        grapher.read(
          IlvSwingUtil.getRelativeURL(this, "data/" + fileNameBase + ".ivl"));
      } catch (Exception ex1) {
        // This case occurs only when we pack the entire application into
        // one jar including the data files, and start as application
        grapher.read(getClass().getResource("data/" + fileNameBase + ".ivl"));
      }
      // the transformer may have been modified, so
      // we set the identity transformer
      mgrview.setTransformer(new IlvTransformer());
      grapher.reDraw();
      showMessage(getString("FileReadingDoneMessage"), fileNameBase);
    } catch (Exception e) {
      // e.printStackTrace();
      showMessage(e.getMessage());
    }
  }

  /**
   * Displays a message.
   */
  synchronized void showMessage(String message)
  {
    // the message is displayed in the message line
    msgLine.setText(message);
  }

  synchronized void showMessage(String msgformat, Object val)
  {
    Object[] args = { val };
    showMessage(MessageFormat.format(msgformat, args));
  }

  /**
   * Returns a string.
   */
  static String getString(String key)
  {
    return IlvResourceUtil.getString(key, StopLayoutApplet.class,
                                     IlvLocaleUtil.getCurrentLocale());
  }
}


// ----------------------------------------------------------------------------
// The GraphLayoutPerformer, a Runnable that performs the layout.

class GraphLayoutPerformer
  implements Runnable
{
  StopLayoutApplet applet;
  IlvGraphLayout layout;
  IlvGrapher grapher;

  GraphLayoutPerformer(
    StopLayoutApplet applet, IlvGraphLayout layout, IlvGrapher grapher)
  {
    this.applet = applet;
    this.layout = layout;
    this.grapher = grapher;
  }

  public void run()
  {
    // and mark the applet as busy to prevent further input
    applet.busy = true;

    // show a start message 
    applet.showMessage(applet.getString("LayoutStartMessage"));

    // sleep to get the awt thread the opportunity to draw the message
    try {
      Thread.currentThread().sleep(20);
    }
    catch (InterruptedException e) {}

    try {
      // perform the layout and get the layout report
      IlvGraphLayoutReport layoutReport = layout.performLayout(true, true);


      if (layoutReport.getCode() == layoutReport.LAYOUT_DONE) {
        applet.showMessage(applet.getString("LayoutReallyDoneMessage"));
        applet.mgrview.fitTransformerToContent();
      } else {
        applet.showMessage(applet.getString("LayoutDoneMessage"),
                  layoutReport.codeToString(layoutReport.getCode(),
                                            IlvLocaleUtil.getCurrentULocale()));
      }

      grapher.reDraw();
    }
    catch (IlvGraphLayoutException e) {
      // e.printStackTrace();
      applet.showMessage(e.getMessage());
    }
    finally {
      // mark the applet as not busy anymore
      applet.busy = false;
    }
  }
}

// ----------------------------------------------------------------------------
// The Layout Iteration Listener.

/**
 * A graph layout iteration listener. Implementing the interface
 * GraphLayoutEventListener gives you the possibility to receive
 * during the layout information about the behavior of the layout 
 * algorithm. This information is contained in the graph layout event.
 * 
 * In our case, we will sleep a short while each time the method
 * layoutStepPerformed is called, that is after each iteration of
 * the layout algorithm. This is important because it gives the other
 * threads the opportunity to perform their tasks.
 * We will also print a dot each time the method layoutStepPerformed is called.
 */
class GraphLayoutIterationListener
  implements GraphLayoutEventListener
{
  private String toShow = "";
  private StopLayoutApplet applet;
  private static final int MAX_LENGTH = 50;

  GraphLayoutIterationListener(StopLayoutApplet applet)
  {
    this.applet = applet;
  }

  /** 
   * This method is automatically called by the layout algorithm.
   */
  public void layoutStepPerformed(GraphLayoutEvent event)
  {
    // the status area has a limited width, so we are forced to 
    // reinitialize the message string
    if (toShow.length() > MAX_LENGTH)
      toShow = "";

    toShow += ".";

    applet.showMessage(toShow);

    // sleep to get the paint thread the opportunity to work
    try {
      Thread.currentThread().sleep(100);
    }
    catch (InterruptedException e) {}
  }

  /**
   * Initialize the listener by reseting the toShow variable.
   * This method must be called before the layout is started.
   */
  void initialize()
  {
    toShow = "";
  }
}