source: trunk/src/org/expeditee/gui/PopupManager.java@ 1102

/**
 *    PopupManager.java
 *    Copyright (C) 2010 New Zealand Digital Library, http://expeditee.org
 *
 *    This program is free software: you can redistribute it and/or modify
 *    it under the terms of the GNU General Public License as published by
 *    the Free Software Foundation, either version 3 of the License, or
 *    (at your option) any later version.
 *
 *    This program is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *    GNU General Public License for more details.
 *
 *    You should have received a copy of the GNU General Public License
 *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

package org.expeditee.gui;

import java.util.LinkedList;
import java.util.List;

import org.expeditee.core.Point;
import org.expeditee.core.bounds.AxisAlignedBoxBounds;
import org.expeditee.gio.EcosystemManager;
import org.expeditee.gio.EcosystemManager.Ecosystem;

/**
 * A centralised container for all custom pop-ups in expeditee.
 * 
 * @author Brook Novak
 */
public final class PopupManager implements DisplayObserver
{
        /** Singleton */
        private static PopupManager _instance = null;
        
        /**
         * @return The singleton instance.
         */
        public static PopupManager getInstance()
        {
                // Only valid for Swing ecosystems
                if (EcosystemManager.getType() != Ecosystem.Swing) return null;
                
                // Construct the instance
                if (_instance == null) _instance = new PopupManager();
                
                return _instance;
        }
        
        /** Singleton */
        private PopupManager()
        {
        } 
        
        private LinkedList<Popup> _popups = new LinkedList<Popup>();

        /** Time its takes for a maximise/minimise to animate, in milliseconds. */
        //private final int ANIMATION_DURATION = 180;
        /** in milliseconds. TODO: Expand. cts16 */
        //private final int ANIMATION_RATE = 30;
        
        public void add(Popup p)
        {
                if (p == null) return;

                synchronized(_popups) {
                        if (!_popups.contains(p)) _popups.add(p);
                }
        }
        
        public void remove(Popup p)
        {
                if (p == null) return;

                synchronized(_popups) {
                        if (_popups.contains(p)) _popups.remove(p);
                }
        }
        
        public List<Popup> getPopups()
        {
                synchronized(_popups) {
                        return new LinkedList<Popup>(_popups);
                }
        }
        
        /**
         * Determines whether a given point is over a pop-up.
         * 
         * @param p
         * 
         * @return True if p is over a pop-up
         * 
         * @throws NullPointerException
         *              If p is null
         */
        public boolean isPointOverPopup(Point p)
        {
                if (p == null) throw new NullPointerException("p");

                synchronized(_popups) {
                        for (Popup popup : _popups) {
                                if (popup.getBounds().contains(p)) return true;
                        }
                }
                
                return false;
        }
        
        /**
         * Use this instead of isVisible to determine if the popup is showing or not,
         * since it considers animation.
         * 
         * @return
         *              True if this popup is showing. <b>IMPORTANT:</b> This includes
         *              if the popup is not yet visible, but in an animation sequence for showing...
         * 
         * @throws NullPointerException
         *              If p is null
         */
        public boolean isShowing(Popup p)
        {
                if (p == null) throw new NullPointerException("p");

                synchronized(_popups) {
                        return _popups.contains(p) && p.isShowing();
                }
        }
        
        /**
         * @return
         *              True if a pop-up is showing. False otherwise.
         */
        public boolean isAnyPopupsShowing()
        {
                synchronized(_popups) {
                        return !_popups.isEmpty();
                }
        }
        
        public void hideAutoHidePopups()
        {
                synchronized(_popups) {
                        for (Popup p : _popups) {
                                if (p.doesAutoHide()) p.hide();
                        }
                }
        }
        
        /**
         * @return
         *              True if the mouse click event for going back a frame should be consumed
         *              due to a pop-up requesting this event to be consumed currently showing.
         */
        public boolean shouldConsumeBackClick()
        {
                synchronized(_popups) {
                        for (Popup p : _popups) {
                                if (p.shouldConsumeBackClick()) return true;
                        }
                }
                
                return false;
        }
        
        public void frameChanged()
        {
        }

        /**
         * Paints current popup animations to the expeditee browser content pane.
         */
        public void paint()
        {
                synchronized (_popups) {
                        for (Popup popup : _popups) {
                                popup.update();
                                popup.paint();
                        }
                }
        }
        
        /**
         * Provides animations for a popup when hiding or when showing.
         * 
         * Note that {@link PopupAnimator#paint(Graphics)} and {@link PopupAnimator#update(float)} 
         * will always be invoked at seperate times - so do not have to worry about thread-safety.
         * 
         * These should only be used once... one per popup at a time.
         * 
         * @author Brook Novak
         */
        public static abstract class PopupAnimator
        {
                /** True if animating to show the popup, false if to hide. */
                private boolean _showing = true;
                
                /** Whether the animation is currently paused. */
                private boolean _paused = true;
                
                private long _startTime;
                private long _duration;
                private long _animationCurrentTime;
                
                public PopupAnimator()
                {
                        _animationCurrentTime = _startTime = System.currentTimeMillis();
                        _duration = getDurationMillis();
                }
                
                /**
                 * @return False if the animation has finished, true if further updates are required.
                 */
                public boolean update()
                {
                        long currentTime = System.currentTimeMillis();
                        
                        if (currentTime > _startTime + _duration) {
                                currentTime = _startTime + _duration;
                        }
                        
                        // If paused, make sure elapsed time stays constant
                        if (_paused) {
                                _startTime += currentTime - _animationCurrentTime;
                        }
                        
                        _animationCurrentTime = currentTime;
                        
                        return !isFinished();
                }
                
                public void hide()
                {
                        if (!_showing) return;
                        
                        _showing = false;
                        complementAnimationProgress();
                }
                
                public void show()
                {
                        if (_showing) return;
                        
                        _showing = true;
                        complementAnimationProgress();
                }
                
                public boolean isShowing()
                {
                        return _showing;
                }
                
                public void start()
                {
                        _animationCurrentTime = _startTime = System.currentTimeMillis();
                        unpause();
                }
                
                public void pause()
                {
                        pause(true);
                }
                
                public void unpause()
                {
                        pause(false);
                }
                
                public void pause(boolean pause)
                {
                        _paused = pause;
                }
                
                private void complementAnimationProgress()
                {
                        _startTime = _animationCurrentTime - ((_startTime + _duration) - _animationCurrentTime);
                }
                
                public float getProgress()
                {
                        return (_animationCurrentTime - _startTime) / ((float) _duration);
                }
                
                public boolean isFinished()
                {
                        return _animationCurrentTime != _startTime + _duration;
                }
                
                public abstract long getDurationMillis();
                
                public abstract AxisAlignedBoxBounds getAnimatedBounds(AxisAlignedBoxBounds fullBounds);
                
        }
        
        public static class ExpandShrinkAnimator extends PopupAnimator
        {
                public static final long DURATION_MS = 2000;
                
                public AxisAlignedBoxBounds _initialBounds = null;
                
                public ExpandShrinkAnimator()
                {
                }
                
                public ExpandShrinkAnimator(AxisAlignedBoxBounds initialBounds)
                {
                        setInitialBounds(initialBounds);
                }
                
                public void setInitialBounds(AxisAlignedBoxBounds initialBounds)
                {
                        _initialBounds = initialBounds;
                }
                
                @Override
                public long getDurationMillis() { return DURATION_MS; }

                @Override
                public AxisAlignedBoxBounds getAnimatedBounds(AxisAlignedBoxBounds fullBounds)
                {
                        if (_initialBounds == null) {
                                setInitialBounds(fullBounds.clone());
                                _initialBounds.getTopLeft().y += _initialBounds.getSize().height; 
                                _initialBounds.getSize().height = 0;
                        }
                        
                        float percentShown = getProgress();
                        if (!isShowing()) percentShown = 1 - percentShown;
                        
                        return AxisAlignedBoxBounds.lerp(_initialBounds, fullBounds, percentShown);
                }
        }
}