/* Extension of plot that allows interactive modification of plot data.

 Copyright (c) 1998-2014 The Regents of the University of California.
 All rights reserved.
 Permission is hereby granted, without written agreement and without
 license or royalty fees, to use, copy, modify, and distribute this
 software and its documentation for any purpose, provided that the above
 copyright notice and the following two paragraphs appear in all copies
 of this software.

 IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY
 FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
 ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF
 THE UNIVERSITY OF CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF
 SUCH DAMAGE.

 THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES,
 INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE
 PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND THE UNIVERSITY OF
 CALIFORNIA HAS NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES,
 ENHANCEMENTS, OR MODIFICATIONS.

 PT_COPYRIGHT_VERSION_2
 COPYRIGHTENDKEY

 */
package ptolemy.plot;

import java.awt.Color;
import java.awt.Graphics;
import java.awt.event.InputEvent;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseMotionListener;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.Stack;
import java.util.Vector;

///////////////////////////////////////////////////////////////////
//// EditablePlot

/**
 This extension of Plot permits interactive modification of plotted
 data, one dataset at a time.  By default, you can modify dataset
 number zero (the first one given).  To change this default, call
 setEditable().  To edit a plot, use the right mouse button.
 Click and drag to the left to trace out new values for the data.
 To read back the modified data, use getData().  To undo a change to
 the data, type Control-Z.  To redo the change, type Control-Y.
 The undo history is infinite.
 <p>
 The style of editing is very particular.  This class assumes the data
 specify a function of <i>x</i>.  I.e., there there is exactly one
 <i>y</i> value for every <i>x</i> value.  Thus, with the right mouse
 button, you are allowed to trace out new <i>y</i> values
 starting with some leftmost <i>x</i> value.  You can only trace
 values to the right.  This feature makes it easy to trace values
 with discontinuities.  Just start at the left, and drag to the right
 to the point of the discontinuity, then drag to the left,
 then right again.  You will have to try it...
 Notice that this style of editing probably does not make sense with
 error bars, since there is no mechanism for editing the error bars.
 <p>
 To be able to modify the data in a dataset, of course, there must
 be data in the dataset.  Thus, you should create a dataset (for
 example by calling addPoint()) before editing it.  Only the visible
 part of the dataset can be edited (that is, the portion of the dataset
 along the visible part of the horizontal axis).  If you zoom in, then,
 you can edit particular points more precisely.
 <p>
 To be notified when the user sketches a new signal, create an
 object that implements the EditListener interface and add that
 listener using addEditListener().

 @author Edward A. Lee
 @version $Id$
 @since Ptolemy II 0.4
 @Pt.ProposedRating Red (cxh)
 @Pt.AcceptedRating Red (cxh)
 */
@SuppressWarnings("serial")
public class EditablePlot extends Plot {
    /** Constructor.
     */
    public EditablePlot() {
        super();
        addMouseListener(new EditMouseListener());
        addMouseMotionListener(new ModifyListener());
        addKeyListener(new UndoListener());
    }

    ///////////////////////////////////////////////////////////////////
    ////                         public methods                    ////

    /** Add a listener to be informed when the user modifies a data set.
     *  @param listener The listener.
     *  @see EditListener
     *  @see #removeEditListener(EditListener)
     */
    public void addEditListener(EditListener listener) {
        if (_editListeners == null) {
            _editListeners = new Vector();
        } else {
            if (_editListeners.contains(listener)) {
                return;
            }
        }

        _editListeners.addElement(listener);
    }

    /** Get the data in the specified dataset. This is returned as
     *  a two-dimensional array, where the first index specifies
     *  X or Y data (index 0 or 1 respectively), and the second
     *  index specifies the point.
     *  @param dataset The dataset.
     *  @return The data in the specified dataset.
     */
    public double[][] getData(int dataset) {
        _checkDatasetIndex(dataset);

        ArrayList<PlotPoint> pts = _points.get(dataset);
        int size = pts.size();
        double[][] result = new double[2][size];

        for (int i = 0; i < size; i++) {
            PlotPoint pt = pts.get(i);
            result[0][i] = pt.x;
            result[1][i] = pt.y;
        }

        return result;
    }

    /** Redo the latest signal editing operation that was undone by
     *  calling undo(), if there was one.  Otherwise, do nothing.
     */
    public void redo() {
        if (_redoStack.empty()) {
            return;
        }

        Object[] save = new Object[2];
        save[0] = Integer.valueOf(_dataset);
        save[1] = getData(_dataset);
        _undoStack.push(save);

        Object[] saved = (Object[]) _redoStack.pop();
        _setData(((Integer) saved[0]).intValue(), (double[][]) saved[1]);

        // Ensure replot of offscreen buffer.
        _plotImage = null;
        repaint();
        _notifyListeners(_dataset);
    }

    /** Unregister a edit listener.  If the specified listener has not
     *  been previously registered, then do nothing.
     *  @param listener The listener to remove from the list of listeners
     *   to which edit events are sent.
     *  @see #addEditListener(EditListener)
     */
    public void removeEditListener(EditListener listener) {
        if (_editListeners == null) {
            return;
        }

        _editListeners.removeElement(listener);
    }

    /** Specify which dataset is editable. By default, if this method is
     *  not called, dataset number zero is editable.  If you call this
     *  method with a negative number, then no dataset will be editable.
     *  @param dataset The editable dataset.
     */
    public void setEditable(int dataset) {
        if (dataset >= 0) {
            _checkDatasetIndex(dataset);
        }

        _dataset = dataset;
    }

    /** Undo the latest signal editing operation, if there was one.
     *  Otherwise, do nothing.
     */
    public void undo() {
        if (_undoStack.empty()) {
            return;
        }

        Object[] save = new Object[2];
        save[0] = Integer.valueOf(_dataset);
        save[1] = getData(_dataset);
        _redoStack.push(save);

        Object[] saved = (Object[]) _undoStack.pop();
        _setData(((Integer) saved[0]).intValue(), (double[][]) saved[1]);

        // Ensure replot of offscreen buffer.
        _plotImage = null;
        repaint();
        _notifyListeners(_dataset);
    }

    ///////////////////////////////////////////////////////////////////
    ////                         private methods                   ////
    // Clear the editing spec and modify the dataset.
    private synchronized void _edit(int x, int y) {
        if (_dataset < 0) {
            return;
        }

        // Save for undo.
        Object[] save = new Object[2];
        save[0] = Integer.valueOf(_dataset);
        save[1] = getData(_dataset);

        // FIXME: Need a way to notify menus to enable items...
        _undoStack.push(save);

        // NOTE: the clear() method was added in jdk 1.2, so we don't
        // use it here for maximal compatibility...
        // _redoStack.clear();
        while (!_redoStack.empty()) {
            _redoStack.pop();
        }

        // constrain to be in range
        if (y > _lry) {
            y = _lry;
        }

        if (y < _uly) {
            y = _uly;
        }

        if (x > _lrx) {
            x = _lrx;
        }

        if (x < _ulx) {
            x = _ulx;
        }

        _editPoint(x, y);

        // Edit the points in the signal.
        ArrayList<PlotPoint> pts = _points.get(_dataset);

        for (int i = 0; i < pts.size(); i++) {
            PlotPoint pt = pts.get(i);

            // Only bother with points in visual range
            if (pt.x >= _xMin && pt.x <= _xMax) {
                int index = (int) ((pt.x - _xMin) * _xscale)
                        - (_lrx - _ulx - _editSpecX.length);

                if (index >= 0 && index < _editSpecX.length) {
                    if (_editSpecSet[index]) {
                        pt.y = _yMax - (_editSpecY[index] - _uly) / _yscale;

                        // For auto-ranging, keep track of min and max.
                        if (pt.y < _yBottom) {
                            _yBottom = pt.y;
                        }

                        if (pt.y > _yTop) {
                            _yTop = pt.y;
                        }
                    }
                }
            }
        }

        // Ensure replot of offscreen buffer.
        _plotImage = null;
        repaint();

        // Erase the guide
        // I don't think we need to do this, since we call repaint().
        //         graphics.setXORMode(_editColor);
        //         for (int i = 0; i < _editSpecX.length; i++) {
        //             if (_editSpecSet[i]) {
        //                 graphics.drawLine(_editSpecX[i], _editSpecY[i]-1,
        //                         _editSpecX[i], _editSpecY[i]+1);
        //             }
        //         }
        //         graphics.setPaintMode();
        _notifyListeners(_dataset);
    }

    // Make a record of a new edit point.
    private synchronized void _editPoint(int x, int y) {
        if (_dataset < 0) {
            return;
        }

        Graphics graphics = getGraphics();

        // constrain to be in range
        if (y > _lry) {
            y = _lry;
        }

        if (y < _uly) {
            y = _uly;
        }

        if (x > _lrx) {
            x = _lrx;
        }

        if (x < _ulx) {
            x = _ulx;
        }

        if (x <= _currentEditX || x >= _lrx) {
            // ignore
            return;
        }

        int step = _currentEditX;

        while (step <= x) {
            int index = step - (_lrx - _editSpecX.length);
            double proportion = (step - _currentEditX)
                    / (double) (x - _currentEditX);
            int newY = (int) (_currentEditY + proportion * (y - _currentEditY));

            if (!_editSpecSet[index]) {
                _editSpecX[index] = step;
                _editSpecY[index] = newY;
                _editSpecSet[index] = true;

                // Draw point, linearly interpolated from previous point
                graphics.setXORMode(_editColor);
                graphics.drawLine(step, newY - 1, step, newY + 1);
                graphics.setPaintMode();
            }

            step++;
        }

        _currentEditX = x;
        _currentEditY = y;
    }

    // Make a record of the starting x and y position of an edit.
    private synchronized void _editStart(int x, int y) {
        if (_dataset < 0) {
            return;
        }

        // constrain to be in range
        if (y > _lry) {
            y = _lry;
        }

        if (y < _uly) {
            y = _uly;
        }

        if (x > _lrx) {
            x = _lrx;
        }

        if (x < _ulx) {
            x = _ulx;
        }

        // Allocate a vector to store the points.
        int size = _lrx - x + 1;
        _editSpecX = new int[size];
        _editSpecY = new int[size];
        _editSpecSet = new boolean[size];

        _editSpecX[0] = x;
        _editSpecY[0] = y;
        _editSpecSet[0] = true;

        _currentEditX = x;
        _currentEditY = y;

        Graphics graphics = getGraphics();

        // Draw point (as a 3 pixel vertical line, for thickness)
        graphics.setXORMode(_editColor);
        graphics.drawLine(x, y - 1, x, y + 1);
        graphics.setPaintMode();
    }

    // Notify all edit listeners that have registered.
    private void _notifyListeners(int dataset) {
        if (_editListeners == null) {
            return;
        } else {
            Enumeration listeners = _editListeners.elements();

            while (listeners.hasMoreElements()) {
                ((EditListener) listeners.nextElement()).editDataModified(this,
                        dataset);
            }
        }
    }

    // Set the data in the specified dataset. The argument is of the
    // form returned by getData.
    private void _setData(int dataset, double[][] data) {
        _checkDatasetIndex(dataset);

        ArrayList<PlotPoint> pts = _points.get(dataset);
        int size = pts.size();

        if (data[0].length < size) {
            size = data[0].length;
        }

        for (int i = 0; i < size; i++) {
            PlotPoint pt = pts.get(i);
            pt.x = data[0][i];
            pt.y = data[1][i];
        }
    }

    ///////////////////////////////////////////////////////////////////
    ////                         private variables                 ////
    private int[] _editSpecX;

    ///////////////////////////////////////////////////////////////////
    ////                         private variables                 ////
    private int[] _editSpecY;

    private boolean[] _editSpecSet;

    private int _currentEditX;

    private int _currentEditY;

    private int _dataset = 0;

    // Call setXORMode with a hardwired color because
    // _background does not work in an application,
    // and _foreground does not work in an applet
    private static final Color _editColor = Color.white;

    // Stack for undo.
    private Stack _undoStack = new Stack();

    private Stack _redoStack = new Stack();

    // Edit listeners.
    private Vector _editListeners = null;

    ///////////////////////////////////////////////////////////////////
    ////                         inner classes                     ////

    /** Listen for mouse button events.  See the class comment for
     * details.
     */
    public class EditMouseListener implements MouseListener {
        /** Ignored by this listener.
         *  @param event Ignored.
         */
        @Override
        public void mouseClicked(MouseEvent event) {
        }

        /** Ignored by this listener.
         *  @param event Ignored.
         */
        @Override
        public void mouseEntered(MouseEvent event) {
        }

        /** Ignored by this listener.
         *  @param event Ignored.
         */
        @Override
        public void mouseExited(MouseEvent event) {
        }

        /** If the 3rd button is pressed, then start the edit.
         *  @param event The event.
         */
        @Override
        public void mousePressed(MouseEvent event) {
            if ((event.getModifiers() & InputEvent.BUTTON3_MASK) != 0) {
                EditablePlot.this._editStart(event.getX(), event.getY());
            }
        }

        /** If the 3rd button is released, then modify the X and Y
         *  coordinates of the edit dataset.
         *  @param event The event.
         */
        @Override
        public void mouseReleased(MouseEvent event) {
            if ((event.getModifiers() & InputEvent.BUTTON3_MASK) != 0) {
                EditablePlot.this._edit(event.getX(), event.getY());
            }
        }
    }

    /** Listen for mouse motion events.  See the class comment for
     * details.
     */
    public class ModifyListener implements MouseMotionListener {
        /** If the mouse is dragged and the 3rd button is pressed,
         *  then make a record of a new edit point.
         *  @param event The event.
         */
        @Override
        public void mouseDragged(MouseEvent event) {
            if ((event.getModifiers() & InputEvent.BUTTON3_MASK) != 0) {
                EditablePlot.this._editPoint(event.getX(), event.getY());
            }
        }

        /** Ignored by this listener.
         *  @param event Ignored.
         */
        @Override
        public void mouseMoved(MouseEvent event) {
        }
    }

    /** Control-Z is undo and Control-Y is redo.
     */
    public class UndoListener implements KeyListener {
        /** Handle Control, Z or Y being pressed with
         *  by calling undo() or redo().
         *  @param e The KeyEvent.
         */
        @Override
        public void keyPressed(KeyEvent e) {
            int keycode = e.getKeyCode();

            switch (keycode) {
            case KeyEvent.VK_CONTROL:
                _control = true;
                break;

            case KeyEvent.VK_Z:

                if (_control) {
                    undo();
                }

                break;

            case KeyEvent.VK_Y:

                if (_control) {
                    redo();
                }

                break;

            default:
                // None
            }
        }

        /** Handle Control being released.
         *  @param e The KeyEvent.
         */
        @Override
        public void keyReleased(KeyEvent e) {
            int keycode = e.getKeyCode();

            switch (keycode) {
            case KeyEvent.VK_CONTROL:
                _control = false;
                break;

            default:
                // None
            }
        }

        /** Ignored by this class.
         *  The keyTyped method is broken in jdk 1.1.4.
         *  It always gets "unknown key code".
         * @param e Ignored by this method.
         */
        @Override
        public void keyTyped(KeyEvent e) {
        }

        /** True of the Control key was pressed, but not yet
         * released.
         */
        private boolean _control = false;
    }
}