Meter.cs

Siirry tämän tiedoston dokumentaatioon.

#region MIT License
/*
 * Copyright (c) 2009 University of Jyväskylä, Department of Mathematical
 * Information Technology.
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 * 
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
#endregion
 
/*
 * Authors: Tero Jäntti, Tomi Karppinen, Janne Nikkanen.
 */
 
using System;
using System.Collections.Generic;
 
namespace Jypeli
{
    public enum TriggerDirection
    {
        Up,
 
        Down,
        
        Irrelevant
    };
 
    public abstract class Meter
    {
        public abstract double RelativeValue { get; set; }
 
        internal abstract double GetValue();
        internal abstract double GetMinValue();
        internal abstract double GetMaxValue();
 
        public Meter<T> OfType<T>() where T : struct, IComparable<T>, IEquatable<T>
        {
            Type meterType = this.GetType();
 
#if WINDOWS_STOREAPP
            Type[] genargs = meterType.GenericTypeArguments;
#else
            Type[] genargs = meterType.GetGenericArguments();
#endif
 
            if ( genargs.Length < 1 ) throw new ArgumentException( "This meter is not typed" );
            if ( genargs[0] != typeof( T ) ) throw new ArgumentException( String.Format( "This meter measures {0}, not {1}", genargs[0].Name, typeof( T ).Name ) );
 
            return (Meter<T>)this;
        }
    }
 
    [Save]
    public abstract class Meter<ValueType> : Meter where ValueType : struct, IComparable<ValueType>, IEquatable<ValueType>
    {
        private struct Trigger
        {
            public ValueType value;
            public TriggerDirection direction;
            public Action method;
 
            public Trigger(ValueType value, TriggerDirection direction, Action method)
            {
                this.value = value;
                this.direction = direction;
                this.method = method;
            }
        }
 
        private bool valueSet;
 
        private ValueType val;
        private ValueType minval;
        private ValueType maxval;
        private ValueType defval;
 
        private List<Trigger> triggers;
 
        [Save]
        public ValueType Value
        {
            get { return val; }
            set
            {
                if ( value.Equals( val ) )
                    return;
 
                ValueType oldval = val;
                valueSet = true;
 
                if (value.CompareTo(minval) < 0) value = minval;
                if (value.CompareTo(maxval) > 0) value = maxval;
 
                val = value;
                OnChange(oldval, value);
                CheckLimits( oldval, value );
                CheckTriggers(oldval, value);
            }
        }
 
        public ValueType DefaultValue
        {
            get { return defval; }
            set
            {
                defval = clampValue( value, minval, maxval );
                if ( !valueSet ) Value = value;
            }
        }
 
        public ValueType MinValue
        {
            get { return minval; }
            set { minval = value; updateBounds(); }
        }
 
        public ValueType MaxValue
        {
            get { return maxval; }
            set { maxval = value; updateBounds(); }
        }
 
        #region Events
 
        public delegate void ChangeHandler( ValueType oldValue, ValueType newValue );
 
        public event ChangeHandler Changed;
 
        public event Action LowerLimit;
 
        public event Action UpperLimit;
 
 
        private void OnChange( ValueType oldValue, ValueType newValue )
        {
            if ( Changed != null )
                Changed( oldValue, newValue );
        }
 
        private void CheckLimits( ValueType oldValue, ValueType newValue )
        {
            if ( LowerLimit != null && newValue.CompareTo( minval ) <= 0 )
            {
                LowerLimit();
                return;
            }
 
            if ( UpperLimit != null && newValue.CompareTo( maxval ) >= 0 )
            {
                UpperLimit();
                return;
            }
        }
 
        private void CheckTriggers( ValueType oldValue, ValueType newValue )
        {
            if ( triggers == null ) return;
 
            foreach ( Trigger t in triggers )
            {
                if ( t.direction != TriggerDirection.Down && oldValue.CompareTo( t.value ) < 0 && newValue.CompareTo( t.value ) >= 0 )
                    t.method();
                
                else if ( t.direction != TriggerDirection.Up && oldValue.CompareTo( t.value ) > 0 && newValue.CompareTo( t.value ) <= 0 )
                    t.method();
            }
        }
 
        #endregion
 
        public Meter( ValueType defaultVal, ValueType minVal, ValueType maxVal )
        {
            minval = minVal;
            maxval = maxVal;
            defval = defaultVal;
            val = defaultVal;
            updateBounds();
        }
 
        public Meter( Meter<ValueType> src )
        {
            minval = src.minval;
            maxval = src.maxval;
            defval = src.defval;
            val = src.val;
            updateBounds();
        }
 
        public void Reset()
        {
            Value = DefaultValue;
        }
 
        public void SetValue( ValueType value )
        {
            Value = value;
        }
 
        public void AddTrigger( ValueType value, TriggerDirection direction, Action method )
        {
            if ( triggers == null ) triggers = new List<Trigger>();
            triggers.Add( new Trigger( value, direction, method ) );
        }
 
        public void AddTrigger( ValueType value, TriggerDirection direction, Action<ValueType> method )
        {
            AddTrigger( value, direction, delegate() { method( this.Value ); } );
        }
 
        public void RemoveTriggers( ValueType value )
        {
            if ( triggers == null ) return;
            triggers.RemoveAll( t => t.value.Equals( value ) );
        }
 
        public void RemoveTriggers( Action method )
        {
            if ( triggers == null ) return;
            triggers.RemoveAll( t => t.method == method );
        }
 
        public void ClearTriggers()
        {
            if ( triggers == null ) return;
            triggers.Clear();
        }
 
        private static ValueType clampValue( ValueType v, ValueType min, ValueType max )
        {
            if ( v.CompareTo( min ) < 0 )
                return min;
 
            if ( v.CompareTo( max ) > 0 )
                return max;
 
            return v;
        }
 
        private static void clampValue( ref ValueType v, ValueType min, ValueType max )
        {
            if ( v.CompareTo( min ) < 0 )
                v = min;
 
            else if ( v.CompareTo( max ) > 0 )
                v = max;
        }
 
        private void updateBounds()
        {
            clampValue( ref val, minval, maxval );
            clampValue( ref defval, minval, maxval );
        }
 
        public override String ToString()
        {
            return Value.ToString();
        }
    }    
}