/*
 * @(#)FlatScrollPane.java 12/13/2006
 *
 * Copyright 2002 - 2006 JIDE Software Inc. All rights reserved.
 */

package com.jidesoft.swing;

import com.jidesoft.icons.JideIconsFactory;

import javax.swing.*;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import javax.swing.plaf.UIResource;
import java.awt.*;
import java.awt.event.*;

/**
 * <code>SimpleScrollPane</code> is a special scroll pane. There is no scroll bar. It just uses four scroll buttons to
 * do the scrolling.
 */
public class SimpleScrollPane extends JScrollPane implements ChangeListener, MouseWheelListener {

    private AbstractButton _scrollUpButton;
    private AbstractButton _scrollDownButton;

    private AbstractButton _scrollLeftButton;
    private AbstractButton _scrollRightButton;

    private int _horizontalUnitIncrement = 10;
    private boolean _horizontalUnitIncrementSet = false;

    private int _verticalUnitIncrement = 10;
    private boolean _verticalUnitIncrementSet = false;

    private int _repeatDelay = 50;
    private boolean _scrollOnRollover = true;

    public static final String SCROLL_UP_BUTTON = "SCROLL_UP_BUTTON";
    public static final String SCROLL_DOWN_BUTTON = "SCROLL_DOWN_BUTTON";
    public static final String SCROLL_LEFT_BUTTON = "SCROLL_LEFT_BUTTON";
    public static final String SCROLL_RIGHT_BUTTON = "SCROLL_RIGHT_BUTTON";

    /**
     * Creates a <code>JideScrollPane</code> that displays the view component in a viewport whose view position can be
     * controlled with a pair of scrollbars. The scrollbar policies specify when the scrollbars are displayed, For
     * example, if <code>vsbPolicy</code> is <code>VERTICAL_SCROLLBAR_AS_NEEDED</code> then the vertical scrollbar only
     * appears if the view doesn't fit vertically. The available policy settings are listed at {@link
     * #setVerticalScrollBarPolicy} and {@link #setHorizontalScrollBarPolicy}.
     *
     * @param view      the component to display in the scrollpanes viewport
     * @param vsbPolicy an integer that specifies the vertical scrollbar policy
     * @param hsbPolicy an integer that specifies the horizontal scrollbar policy
     * @see #setViewportView
     */
    public SimpleScrollPane(Component view, int vsbPolicy, int hsbPolicy) {
        setLayout(new SimpleScrollPaneLayout.UIResource());
        setVerticalScrollBarPolicy(vsbPolicy);
        setHorizontalScrollBarPolicy(hsbPolicy);
        setViewport(createViewport());
        setScrollUpButton(createScrollButton(SwingConstants.NORTH));
        setScrollDownButton(createScrollButton(SwingConstants.SOUTH));
        setScrollLeftButton(createScrollButton(SwingConstants.WEST));
        setScrollRightButton(createScrollButton(SwingConstants.EAST));
        if (null != view) {
            setViewportView(view);
        }
        updateButtonState();
        setOpaque(true);
        setFocusable(false);
        if (getHorizontalScrollBar() != null) {
            getHorizontalScrollBar().setVisible(false);
            getHorizontalScrollBar().setFocusable(false);
        }
        if (getVerticalScrollBar() != null) {
            getVerticalScrollBar().setVisible(false);
            getVerticalScrollBar().setFocusable(false);
        }
        updateUI();

        if (!getComponentOrientation().isLeftToRight()) {
            viewport.setViewPosition(new Point(Integer.MAX_VALUE, 0));
        }

        if (this.isWheelScrollingEnabled())
            this.addMouseWheelListener(this);
    }


    /**
     * Creates a <code>JideScrollPane</code> that displays the contents of the specified component, where both
     * horizontal and vertical scrollbars appear whenever the component's contents are larger than the view.
     *
     * @param view the component to display in the scrollpane's viewport
     * @see #setViewportView
     */
    public SimpleScrollPane(Component view) {
        this(view, VERTICAL_SCROLLBAR_AS_NEEDED, HORIZONTAL_SCROLLBAR_AS_NEEDED);
    }


    /**
     * Creates an empty (no viewport view) <code>JideScrollPane</code> with specified scrollbar policies. The available
     * policy settings are listed at {@link #setVerticalScrollBarPolicy} and {@link #setHorizontalScrollBarPolicy}.
     *
     * @param vsbPolicy an integer that specifies the vertical scrollbar policy
     * @param hsbPolicy an integer that specifies the horizontal scrollbar policy
     * @see #setViewportView
     */
    public SimpleScrollPane(int vsbPolicy, int hsbPolicy) {
        this(null, vsbPolicy, hsbPolicy);
    }


    /**
     * Creates an empty (no viewport view) <code>JideScrollPane</code> where both horizontal and vertical scrollbars
     * appear when needed.
     */
    public SimpleScrollPane() {
        this(null, VERTICAL_SCROLLBAR_AS_NEEDED, HORIZONTAL_SCROLLBAR_AS_NEEDED);
    }

    @Override
    public void updateUI() {
        super.updateUI();
        setLayout(new SimpleScrollPaneLayout.UIResource());
        LookAndFeel.installBorder(this, "JideScrollPane.border");
        getViewport().addChangeListener(this);
    }

    public void stateChanged(ChangeEvent e) {
        if (e.getSource() == getViewport()) {
            updateButtonState();
        }
    }

    public AbstractButton getScrollUpButton() {
        return _scrollUpButton;
    }

    public void setScrollUpButton(AbstractButton scrollUpButton) {
        AbstractButton old = getScrollUpButton();
        _scrollUpButton = scrollUpButton;
        add(_scrollUpButton, SCROLL_UP_BUTTON);
        firePropertyChange("scrollUpButton", old, _scrollUpButton);

        revalidate();
        repaint();
    }

    public AbstractButton getScrollDownButton() {
        return _scrollDownButton;
    }

    public void setScrollDownButton(AbstractButton scrollDownButton) {
        AbstractButton old = getScrollDownButton();
        _scrollDownButton = scrollDownButton;
        add(_scrollDownButton, SCROLL_DOWN_BUTTON);
        firePropertyChange("scrollDownButton", old, _scrollDownButton);

        revalidate();
        repaint();
    }

    public AbstractButton getScrollLeftButton() {
        return _scrollLeftButton;
    }

    public void setScrollLeftButton(AbstractButton scrollLeftButton) {
        AbstractButton old = getScrollLeftButton();
        _scrollLeftButton = scrollLeftButton;
        add(_scrollLeftButton, SCROLL_LEFT_BUTTON);
        firePropertyChange("scrollLeftButton", old, _scrollLeftButton);

        revalidate();
        repaint();
    }

    public AbstractButton getScrollRightButton() {
        return _scrollRightButton;
    }

    public void setScrollRightButton(AbstractButton scrollRightButton) {
        AbstractButton old = getScrollRightButton();
        _scrollRightButton = scrollRightButton;
        add(_scrollRightButton, SCROLL_RIGHT_BUTTON);
        firePropertyChange("scrollRightButton", old, _scrollRightButton);

        revalidate();
        repaint();
    }

    /**
     * The scroll button for SimpleScrollPane. You can extend this class to create your own buttons.
     */
    public class ScrollButton extends JideButton implements MouseListener, ActionListener, UIResource {
        private int _type;
        private Timer _timer;

        /**
         * Creates a ScrollButton.
         *
         * @param type one of the four values - NORTH, SOUTH, WEST, EAST as defined in SwingConstants.
         */
        public ScrollButton(int type) {
            _type = type;
            switch (type) {
                case SwingConstants.NORTH:
                    setIcon(JideIconsFactory.getImageIcon(JideIconsFactory.Arrow.UP));
                    break;
                case SwingConstants.SOUTH:
                    setIcon(JideIconsFactory.getImageIcon(JideIconsFactory.Arrow.DOWN));
                    break;
                case SwingConstants.WEST:
                    setIcon(JideIconsFactory.getImageIcon(JideIconsFactory.Arrow.LEFT));
                    break;
                case SwingConstants.EAST:
                    setIcon(JideIconsFactory.getImageIcon(JideIconsFactory.Arrow.RIGHT));
                    break;
            }
            addActionListener(this);
            addMouseListener(this);
            setPreferredSize(new Dimension(10, 10));
            setMinimumSize(new Dimension(10, 10));
        }

        public void actionPerformed(ActionEvent e) {
            scroll(getViewport(), _type);
            updateButtonState();
        }

        public void mouseClicked(MouseEvent e) {
        }

        public void mousePressed(MouseEvent e) {
            if (!isScrollOnRollover()) {
                startTimer(e, 500);
            }
            else {
                updateTimer(e);
            }
        }

        public void mouseReleased(MouseEvent e) {
            if (!isScrollOnRollover()) {
                stopTimer();
            }
            else {
                updateTimer(e);
            }
        }

        public void mouseEntered(MouseEvent e) {
            if (isScrollOnRollover()) {
                startTimer(e, 500);
            }
        }

        private void updateTimer(MouseEvent e) {
            if (_timer != null) {
                _timer.setDelay(getDelay(e));
            }
        }

        private void startTimer(MouseEvent e, int initDelay) {
            stopTimer();
            _timer = new Timer(getDelay(e), this);
            _timer.setInitialDelay(initDelay);
            _timer.start();
        }

        private void stopTimer() {
            if (_timer != null) {
                _timer.stop();
                _timer = null;
            }
        }

        private int getDelay(MouseEvent e) {
            if (isScrollOnRollover()) {
                return SwingUtilities.isLeftMouseButton(e) ? getRepeatDelay() : getRepeatDelay() * 2;
            }
            else {
                return getRepeatDelay();
            }
        }

        public void mouseExited(MouseEvent e) {
            if (isScrollOnRollover()) {
                stopTimer();
            }
        }
    }

    /**
     * Creates the scroll button. You can override this method to change the attributes on the button. For example, you
     * can do this to create a bigger scroll button.
     * <code><pre>
     * SimpleScrollPane pane = new SimpleScrollPane(){
     *     protected AbstractButton createScrollButton(int type) {
     *         AbstractButton scrollButton = super.createScrollButton(type);
     *         scrollButton.setPreferredSize(new Dimension(20, 20));
     *         return scrollButton;
     *     }
     * };
     * </pre></code>
     *
     * @param type the type of the scroll button. It could be {@link javax.swing.SwingConstants#NORTH}, {@link
     *             javax.swing.SwingConstants#SOUTH}, {@link javax.swing.SwingConstants#WEST} or {@link
     *             javax.swing.SwingConstants#EAST} .
     * @return the scroll button.
     */
    protected AbstractButton createScrollButton(int type) {
        return new ScrollButton(type);
    }

    protected void updateButtonState() {
        Point p = viewport.getViewPosition();
        _scrollUpButton.setEnabled(p.y != 0);
        _scrollDownButton.setEnabled(p.y != viewport.getViewSize().height - viewport.getViewRect().height);
        _scrollLeftButton.setEnabled(p.x != 0);
        _scrollRightButton.setEnabled(p.x != viewport.getViewSize().width - viewport.getViewRect().width);
        revalidate();
        repaint();
    }

    public void scroll(JViewport viewport, int type) {
        Point p = viewport.getViewPosition();

        JViewport vp = getViewport();
        switch (type) {
            case SwingConstants.NORTH:
                if (!_verticalUnitIncrementSet && (vp != null) &&
                        (vp.getView() instanceof Scrollable)) {
                    Scrollable view = (Scrollable) (vp.getView());
                    Rectangle vr = vp.getViewRect();
                    p.y -= view.getScrollableUnitIncrement(vr, SwingConstants.VERTICAL, -1);
                }
                else {
                    p.y -= getVerticalUnitIncrement();
                }
                if (p.y < 0) {
                    p.y = 0;
                }
                break;
            case SwingConstants.SOUTH:
                if (!_verticalUnitIncrementSet && (vp != null) &&
                        (vp.getView() instanceof Scrollable)) {
                    Scrollable view = (Scrollable) (vp.getView());
                    Rectangle vr = vp.getViewRect();
                    p.y += view.getScrollableUnitIncrement(vr, SwingConstants.VERTICAL, 1);
                }
                else {
                    p.y += getVerticalUnitIncrement();
                }
                if (p.y + viewport.getViewRect().height > viewport.getViewSize().height) {
                    p.y = viewport.getViewSize().height - viewport.getViewRect().height;
                }
                break;
            case SwingConstants.WEST:
                if (!_horizontalUnitIncrementSet && (vp != null) &&
                        (vp.getView() instanceof Scrollable)) {
                    Scrollable view = (Scrollable) (vp.getView());
                    Rectangle vr = vp.getViewRect();
                    p.x -= view.getScrollableUnitIncrement(vr, SwingConstants.HORIZONTAL, -1);
                }
                else {
                    p.x -= getHorizontalUnitIncrement();
                }
                if (p.x < 0) {
                    p.x = 0;
                }
                break;
            case SwingConstants.EAST:
                if (!_horizontalUnitIncrementSet && (vp != null) &&
                        (vp.getView() instanceof Scrollable)) {
                    Scrollable view = (Scrollable) (vp.getView());
                    Rectangle vr = vp.getViewRect();
                    p.x += view.getScrollableUnitIncrement(vr, SwingConstants.HORIZONTAL, 1);
                }
                else {
                    p.x += getHorizontalUnitIncrement();
                }
                if (p.x + viewport.getViewRect().width > viewport.getViewSize().width) {
                    p.x = viewport.getViewSize().width - viewport.getViewRect().width;
                }
                break;
        }

        viewport.setViewPosition(p);
    }

    @Override
    public Rectangle getViewportBorderBounds() {
        Rectangle borderR = new Rectangle(getSize());

        Insets insets = getInsets();
        borderR.x = insets.left;
        borderR.y = insets.top;
        borderR.width -= insets.left + insets.right;
        borderR.height -= insets.top + insets.bottom;

        if (_scrollUpButton != null && _scrollUpButton.isVisible()) {
            borderR.y += _scrollUpButton.getHeight();
            borderR.height -= _scrollUpButton.getHeight();
        }

        if (_scrollLeftButton != null && _scrollLeftButton.isVisible()) {
            borderR.x += _scrollLeftButton.getWidth();
            borderR.width -= _scrollLeftButton.getWidth();
        }

        if (_scrollDownButton != null && _scrollDownButton.isVisible()) {
            borderR.height -= _scrollDownButton.getHeight();
        }

        if (_scrollRightButton != null && _scrollRightButton.isVisible()) {
            borderR.width -= _scrollRightButton.getWidth();
        }

        return borderR;
    }

    public int getHorizontalUnitIncrement() {
        return _horizontalUnitIncrement;
    }

    public void setHorizontalUnitIncrement(int horizontalUnitIncrement) {
        _horizontalUnitIncrementSet = true;
        if (horizontalUnitIncrement != _horizontalUnitIncrement) {
            int old = _horizontalUnitIncrement;
            _horizontalUnitIncrement = horizontalUnitIncrement;
            firePropertyChange("horizontalUnitIncrement", old, _horizontalUnitIncrement);
        }
    }

    public int getVerticalUnitIncrement() {
        return _verticalUnitIncrement;
    }

    public void setVerticalUnitIncrement(int verticalUnitIncrement) {
        _verticalUnitIncrementSet = true;
        if (verticalUnitIncrement != _verticalUnitIncrement) {
            int old = _verticalUnitIncrement;
            _verticalUnitIncrement = verticalUnitIncrement;
            firePropertyChange("verticalUnitIncrement", old, _verticalUnitIncrement);
        }
    }

    /**
     * Checks if the scroll button scrolls on rollover.
     *
     * @return true if it scrolls on rollover.
     */
    public boolean isScrollOnRollover() {
        return _scrollOnRollover;
    }

    /**
     * Sets scroll on rollover. If true, the scrolling will start when mouse is placed above the scroll button. If
     * false, the scrolling will start only when you click or press and hold the mouse button.
     *
     * @param scrollOnRollover true or false.
     */
    public void setScrollOnRollover(boolean scrollOnRollover) {
        if (_scrollOnRollover != scrollOnRollover) {
            boolean old = _scrollOnRollover;
            _scrollOnRollover = scrollOnRollover;
            firePropertyChange("scrollOnRollover", old, _scrollOnRollover);
        }
    }

    /**
     * Gets the delay in ms between each unit scrolling.
     *
     * @return the delay.
     */
    public int getRepeatDelay() {
        return _repeatDelay;
    }

    /**
     * Sets the delay in ms between each unit scrolling. By default, it's 50. The big thenumberr, the slow the
     * scrolling.
     *
     * @param repeatDelay the new repeat delay.
     */
    public void setRepeatDelay(int repeatDelay) {
        if (repeatDelay != _repeatDelay) {
            int old = _repeatDelay;
            _repeatDelay = repeatDelay;
            firePropertyChange("repeatDelay", old, _repeatDelay);
        }
    }


    public void mouseWheelMoved(MouseWheelEvent e) {
        if (this.isWheelScrollingEnabled() && e.getScrollAmount() != 0) {
            boolean scrollingUp = (e.getWheelRotation() >= 0);
            int direction = SwingConstants.CENTER;

            if (!this.isButtonVisible(scrollingUp))
                return;

            direction = this.getScrollDirection(scrollingUp);
            if (direction != SwingConstants.CENTER)
                this.scroll(this.getViewport(), direction);
        }
    }

    private boolean isButtonVisible(boolean scrollingUp) {
        if (scrollingUp)
            return (((_scrollUpButton != null) && _scrollUpButton.isVisible()) ||
                    ((_scrollLeftButton != null) && _scrollLeftButton.isVisible()));
        else
            return (((_scrollDownButton != null) && _scrollDownButton.isVisible()) ||
                    ((_scrollRightButton != null) && _scrollRightButton.isVisible()));
    }

    private int getScrollDirection(boolean scrollingUp) {
        if (scrollingUp) {
            if ((_scrollUpButton != null) && _scrollUpButton.isVisible()) return SwingConstants.SOUTH;
            if ((_scrollLeftButton != null) && _scrollLeftButton.isVisible()) return SwingConstants.EAST;
        }
        else {
            if ((_scrollDownButton != null) && _scrollDownButton.isVisible()) return SwingConstants.NORTH;
            if ((_scrollRightButton != null) && _scrollRightButton.isVisible()) return SwingConstants.WEST;
        }

        return SwingConstants.CENTER;
    }

    @Override
    public void setWheelScrollingEnabled(boolean handleWheel) {
        if (handleWheel && !isWheelScrollingEnabled())
            this.addMouseWheelListener(this);
        if (!handleWheel && isWheelScrollingEnabled())
            this.removeMouseWheelListener(this);
        super.setWheelScrollingEnabled(handleWheel);
    }
}

