nVLC

//    nVLC
//    
//    Author:  Roman Ginzburg
//
//    nVLC 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.
//
//    nVLC 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.
//     
// ========================================================================

using System;
using System.Collections.Generic;
using Declarations;
using Declarations.Events;
using Declarations.Media;
using Implementation.Events;
using LibVlcWrapper;

namespace Implementation.Media
{
   internal class MediaList : DisposableBase, IMediaList, INativePointer, IEventProvider, IReferenceCount
   {
      protected IntPtr m_hMediaList;
      protected IntPtr m_hMediaLib;
      IntPtr m_hEventManager = IntPtr.Zero;
      IMediaListEvents m_events = null;

      public MediaList(IntPtr hMediaLib)
      {
         m_hMediaLib = hMediaLib;
         m_hMediaList = LibVlcMethods.libvlc_media_list_new(hMediaLib);
      }

      public MediaList(IntPtr hMediaList, ReferenceCountAction action)
      {
         m_hMediaList = hMediaList;

         switch (action)
         {
            case ReferenceCountAction.AddRef:
               this.AddRef();
               break;
            case ReferenceCountAction.Release:
               this.Release();
               break;
         }
      }

      protected struct MediaListLock : IDisposable
      {
         IntPtr m_hMediaList;

         public MediaListLock(IntPtr hMediaList)
         {
            m_hMediaList = hMediaList;
            LibVlcMethods.libvlc_media_list_lock(m_hMediaList);
         }

         #region IDisposable Members

         public void Dispose()
         {
            LibVlcMethods.libvlc_media_list_unlock(m_hMediaList);
         }

         #endregion
      }

      #region IList<IMedia> Members

      public int IndexOf(IMedia item)
      {
         using (new MediaListLock(m_hMediaList))
         {
            return LibVlcMethods.libvlc_media_list_index_of_item(m_hMediaList, ((INativePointer)item).Pointer);
         }
      }

      public void Insert(int index, IMedia item)
      {
         using (new MediaListLock(m_hMediaList))
         {
            LibVlcMethods.libvlc_media_list_insert_media(m_hMediaList, ((INativePointer)item).Pointer, index);
         }
      }

      public void RemoveAt(int index)
      {
         using (new MediaListLock(m_hMediaList))
         {
            LibVlcMethods.libvlc_media_list_remove_index(m_hMediaList, index);
         }
      }

      public IMedia this[int index]
      {
         get
         {
            using (new MediaListLock(m_hMediaList))
            {
               IntPtr hMedia = LibVlcMethods.libvlc_media_list_item_at_index(m_hMediaList, index);
               if (hMedia == IntPtr.Zero)
               {
                  throw new Exception(string.Format("Media at index {0} not found", index));
               }

               return new BasicMedia(hMedia, ReferenceCountAction.AddRef);
            }
         }
         set
         {
            this.Insert(index, value);
         }
      }

      #endregion

      #region ICollection<IMedia> Members

      public void Add(IMedia item)
      {
         using (new MediaListLock(m_hMediaList))
         {
            LibVlcMethods.libvlc_media_list_add_media(m_hMediaList, ((INativePointer)item).Pointer);
         }
      }

      public void Clear()
      {
         using (new MediaListLock(m_hMediaList))
         {
            int count = LibVlcMethods.libvlc_media_list_count(m_hMediaList);

            for (int i = 0; i < count; i++)
            {
               LibVlcMethods.libvlc_media_list_remove_index(m_hMediaList, 0);
            }
         }
      }

      public bool Contains(IMedia item)
      {
         return this.IndexOf(item) != -1;
      }

      public void CopyTo(IMedia[] array, int arrayIndex)
      {
         throw new NotImplementedException();
      }

      public int Count
      {
         get
         {
            using (new MediaListLock(m_hMediaList))
            {
               return LibVlcMethods.libvlc_media_list_count(m_hMediaList);
            }
         }
      }

      public bool IsReadOnly
      {
         get 
         { 
            return LibVlcMethods.libvlc_media_list_is_readonly(m_hMediaList) == 0; 
         }
      }

      public bool Remove(IMedia item)
      {
         int index = this.IndexOf(item);
         if (index < 0)
         {
            return false;
         }

         this.RemoveAt(index);
         return true;
      }

      #endregion

      #region IEnumerable<IMedia> Members

      public IEnumerator<IMedia> GetEnumerator()
      {
         throw new NotImplementedException();
      }

      #endregion

      #region IEnumerable Members

      System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
      {
         return this.GetEnumerator();
      }

      #endregion

      protected override void Dispose(bool disposing)
      {
         Release();
      }

      #region INativePointer Members

      public IntPtr Pointer
      {
         get 
         { 
            return m_hMediaList; 
         }
      }

      #endregion

      #region IEventProvider Members

      public IntPtr EventManagerHandle
      {
         get 
         {
            if (m_hEventManager == IntPtr.Zero)
            {
               m_hEventManager = LibVlcMethods.libvlc_media_list_event_manager(m_hMediaList);
            }

            return m_hEventManager;
         }
      }

      #endregion

      #region IMediaList Members

      public IMediaListEvents Events
      {
         get 
         {
            if (m_events == null)
            {
               m_events = new MediaListEventManager(this);
            }
            return m_events;
         }
      }

      #endregion

      #region IReferenceCount Members

      public void AddRef()
      {
         LibVlcMethods.libvlc_media_list_retain(m_hMediaList);
      }

      public void Release()
      {
         try
         {
            LibVlcMethods.libvlc_media_list_release(m_hMediaList);
         }
         catch (AccessViolationException)
         { }
      }

      #endregion
   }
}