source: trunk/src/org/expeditee/core/Lifetime.java@ 1097

package org.expeditee.core;

import org.expeditee.gio.EcosystemManager;
import org.expeditee.gio.TimeoutQueue.TimeoutHandle;
import org.expeditee.gio.input.InputEvent;
import org.expeditee.gio.input.InputEvent.InputType;
import org.expeditee.gio.input.InputEventListener;
import org.expeditee.gio.input.TimeoutInputEvent;

public class Lifetime
{
        /** Value representing an infinitely-long popup lifetime. */
        public static final long INFINITE_LIFETIME = -1;
        
        /** The length of this lifetime. */
        private long _lifetime;
        /** The time as returned by System.currentTimeMillis() when this lifetime will expire. */
        private long _deathTime;
        
        private TimeoutHandle _expiryHandle = null;
        private Runnable _expiryRoutine = null;
        private InputEventListener _expiryListener = new InputEventListener()
        {
                @Override
                public boolean onInputEvent(InputEvent event)
                {
                        if (event.getInputType() == InputType.TIMEOUT) {
                                TimeoutInputEvent timeoutEvent = (TimeoutInputEvent) event;
                                if (timeoutEvent.getHandle() == _expiryHandle) {
                                        _expiryRoutine.run();
                                        cancelExpiry();
                                }
                        }
                        return false;
                }
        };
        
        public Lifetime(long lifetime)
        {
                if (lifetime < 0) lifetime = INFINITE_LIFETIME;
                _lifetime = lifetime;
                refresh();
        }
        
        public void setLifetime(long lifetime)
        {
                if (lifetime < 0) lifetime = INFINITE_LIFETIME;
                
                if (_lifetime != INFINITE_LIFETIME) _deathTime -= _lifetime;
                
                _lifetime = lifetime;
                
                if (_lifetime != INFINITE_LIFETIME) _deathTime += _lifetime;
        }
        
        public void refresh()
        {
                if (_lifetime == INFINITE_LIFETIME) {
                        _deathTime = System.currentTimeMillis();
                } else {
                        _deathTime = System.currentTimeMillis() + _lifetime;
                }
        }
        
        public long remainingLifetime()
        {
                if (_lifetime == INFINITE_LIFETIME) return INFINITE_LIFETIME;
                
                long remaining = _deathTime - System.currentTimeMillis();
                
                if (remaining < 0) remaining = 0;
                
                return remaining;
        }
        
        public boolean hasExpired()
        {
                return remainingLifetime() == 0;
        }
        
        public void cancelExpiry()
        {
                if (_expiryHandle != null) {
                        EcosystemManager.getInputManager().cancelTimeout(_expiryHandle);
                        EcosystemManager.getInputManager().removeInputEventListener(_expiryListener);
                        _expiryHandle = null;
                        _expiryRoutine = null;
                }
        }
        
        public void onExpiry(Runnable routine)
        {       
                if (_expiryHandle != null) {
                        cancelExpiry();
                }
                
                if (routine == null || _lifetime == INFINITE_LIFETIME) return;
                
                _expiryRoutine = routine;
                
                EcosystemManager.getInputManager().registerInputEventListener(_expiryListener);
                
                _expiryHandle = EcosystemManager.getInputManager().addTimeout((int) remainingLifetime());
        }

}