C# Synth Toolkit - Part II

#region License

/* Copyright (c) 2007 Leslie Sanford
 * 
 * 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

#region Contact

/*
 * Leslie Sanford
 * Email: jabberdabber@hotmail.com
 */

#endregion

using System;
using System.Collections;
using System.Collections.Generic;
using Sanford.Multimedia.Midi;

namespace Sanford.Multimedia.Synth
{
    /// <summary>
    /// Keeps track of which notes are currently playing.
    /// </summary>
    internal sealed class NoteTracker : IEnumerable<ChannelMessage>
    {
        #region NoteTrack Members

        #region Fields

        // The list of note-on messages currently playing.
        private List<ChannelMessage> noteOnMessages = new List<ChannelMessage>();

        private int lastNote = 69;

        #endregion

        #region Methods

        /// <summary>
        /// Tracks a note-on messages.
        /// </summary>
        /// <param name="message">
        /// The note-on message to track.
        /// </param>
        /// <remarks>
        /// The NoteTracker will add the specified note-on message to its list
        /// of note-on messages. It will not remove the message until receiving
        /// a corresponding note-off message.
        /// </remarks>
        /// <exception cref="ArgumentNullException">
        /// message is null.
        /// </exception>
        /// <exception cref="ArgumentException">
        /// message is not a note-on message.
        /// </exception>
        public void NoteOn(ChannelMessage message)
        {
            #region Require

            if(message == null)
            {
                throw new ArgumentNullException("message");
            }
            else if(message.Command != ChannelCommand.NoteOn ||
                (message.Command == ChannelCommand.NoteOn && message.Data2 == 0))
            {
                throw new ArgumentException("Not a note on message.");
            }

            #endregion

            noteOnMessages.Add(message);

            lastNote = message.Data1;
        }

        /// <summary>
        /// Tracks a note-off message.
        /// </summary>
        /// <param name="message">
        /// The note-off message to track.
        /// </param>
        /// <remarks>
        /// The NoteTracker will remove the note-on message that corresponds to
        /// the specified note-off message from its list of note-on messages,
        /// if one exists.
        /// </remarks>
        /// <exception cref="ArgumentNullException">
        /// message is null.
        /// </exception>
        /// <exception cref="ArgumentException">
        /// message is not a note-off message.
        /// </exception>
        public void NoteOff(ChannelMessage message)
        {
            #region Require

            if(message == null)
            {
                throw new ArgumentNullException("message");
            }
            else if(message.Command != ChannelCommand.NoteOff)
            {
                if(message.Command == ChannelCommand.NoteOn)
                {
                    if(message.Data2 > 0)
                    {
                        throw new ArgumentException("Not a note off message.");
                    }
                }
                else
                {
                    throw new ArgumentException("Not a note off message.");
                }
            }

            #endregion

            // Find the index into the list for the corresponding note-on message.
            int index = noteOnMessages.FindIndex(delegate(ChannelMessage m)
            {
                // If the message matches.
                if(message.MidiChannel == m.MidiChannel && message.Data1 == m.Data1)
                {
                    // The message has been found.
                    return true;
                }
                // Else the message does note match.
                else
                {
                    // The message has not yet been found.
                    return false;
                }
            });

            // If a corresponding note-on message was found.
            if(index >= 0)
            {
                // Remove it from the list of note-on messages.
                noteOnMessages.RemoveAt(index);

                if(noteOnMessages.Count > 0)
                {
                    lastNote = noteOnMessages[noteOnMessages.Count - 1].Data1;
                }
            }
        }

        /// <summary>
        /// Clears all note-on messages from the NoteTracker's list.
        /// </summary>
        public void Clear()
        {
            noteOnMessages.Clear();
        }

        #endregion

        #region Properties

        /// <summary>
        /// The number of note-on messages currently being tracked.
        /// </summary>
        public int Count
        {
            get
            {
                return noteOnMessages.Count;
            }
        }

        /// <summary> 
        /// Gets the latest note currently playing. 
        /// </summary>
        public int LastNote
        {
            get
            {
                return lastNote;
            }
        }

        #endregion

        #endregion

        #region IEnumerable<ChannelMessage> Members

        public IEnumerator<ChannelMessage> GetEnumerator()
        {
            return noteOnMessages.GetEnumerator();
        }

        #endregion

        #region IEnumerable Members

        IEnumerator IEnumerable.GetEnumerator()
        {
            return noteOnMessages.GetEnumerator();
        }

        #endregion
    }
}