root/lang/csharp/iTunesCOMWrap/trunk/iTunesCOMWrap/Application.cs @ 11205

// $Id$
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices;
using Clovery.iTunesHelper.COMWrap.Interfaces;
using iTunes = iTunesLib;

namespace Clovery.iTunesHelper.COMWrap
{
    public class ITunesApp : IITFactory
    {
        private readonly IITunesWrappedObjectFactory _objectFactory;
        protected internal object _internal;
        public IIndexedCollection<IPlaylist, bool> CanSetShuffle = new CanSetShufflePlaylistCollection();
        public IIndexedCollection<IPlaylist, bool> CanSetSongRepeat = new CanSetSongRepeatPlaylistCollection();

        internal ITunesApp(iTunes.iTunesApp _internal, bool useCache)
        {
            this._internal = _internal;
            if (!this._asIiTunes.CheckVersion(
                     (int) SupportedVersion.MajorVersion,
                     (int) SupportedVersion.MinorVersion))
                throw new NotSupportedException("not supported iTunes version");

            if (useCache)
            {
                this._objectFactory = new ITunesWrappedCachedObjectFactory(this);
                this.AttachEvents();
            }
            else
            {
                this._objectFactory = new ITunesWrappedObjectFactory(this);
            }
        }

        public ITunesApp(bool useCache)
            : this(new iTunes.iTunesAppClass(), useCache)
        {
        }

        public ITunesApp() : this(false)
        {
        }

        protected internal iTunes.IiTunes _asIiTunes
        {
            get { return (iTunes.IiTunes) this._internal; }
        }

        protected internal iTunes._IiTunesEvents_Event _asIiTunesEvents_Event
        {
            get { return (iTunes._IiTunesEvents_Event) this._internal; }
        }

        public object __internalObject
        {
            get { return this._internal; }
        }

        public bool Attached
        {
            get { return this._internal != null; }
        }

        public bool EventAttached { get; private set; }

        public void AttachEvents()
        {
            if (this.EventAttached) return;
            this.EventAttached = true;
            this._asIiTunesEvents_Event.OnDatabaseChangedEvent += this._onITDatabaseChangedEvent;
            this._asIiTunesEvents_Event.OnPlayerPlayEvent += this._onPlayerPlayEvent;
            this._asIiTunesEvents_Event.OnPlayerStopEvent += this._onPlayerStopEvent;
            this._asIiTunesEvents_Event.OnPlayerPlayingTrackChangedEvent += this._onPlayerPlayingTrackChangedEvent;
            this._asIiTunesEvents_Event.OnCOMCallsDisabledEvent += this._onCOMCallsDisabledEvent;
            this._asIiTunesEvents_Event.OnCOMCallsEnabledEvent += this._onCOMCallsEnabledEvent;
            this._asIiTunesEvents_Event.OnQuittingEvent += this._onQuittingEvent;
            this._asIiTunesEvents_Event.OnAboutToPromptUserToQuitEvent += this._onAbortToPromptUserToQuitEvent;
            this._asIiTunesEvents_Event.OnSoundVolumeChangedEvent += this._onSoundVolumeChangedEvent;
            var e = this.EventAttachStatusChangedEvent;
            if (e != null) e(this, new EventAttachStatusChangedEventArgs(this.EventAttached));
        }

        public void DetachEvents()
        {
            if (!this.EventAttached) return;
            this.EventAttached = false;
            this._asIiTunesEvents_Event.OnDatabaseChangedEvent -= this._onITDatabaseChangedEvent;
            this._asIiTunesEvents_Event.OnPlayerPlayEvent -= this._onPlayerPlayEvent;
            this._asIiTunesEvents_Event.OnPlayerStopEvent -= this._onPlayerStopEvent;
            this._asIiTunesEvents_Event.OnPlayerPlayingTrackChangedEvent -= this._onPlayerPlayingTrackChangedEvent;
            this._asIiTunesEvents_Event.OnCOMCallsDisabledEvent -= this._onCOMCallsDisabledEvent;
            this._asIiTunesEvents_Event.OnCOMCallsEnabledEvent -= this._onCOMCallsEnabledEvent;
            this._asIiTunesEvents_Event.OnQuittingEvent -= this._onQuittingEvent;
            this._asIiTunesEvents_Event.OnAboutToPromptUserToQuitEvent -= this._onAbortToPromptUserToQuitEvent;
            this._asIiTunesEvents_Event.OnSoundVolumeChangedEvent -= this._onSoundVolumeChangedEvent;
            var e = this.EventAttachStatusChangedEvent;
            if (e != null) e(this, new EventAttachStatusChangedEventArgs(this.EventAttached));
        }

        public ISourceCollection Sources
        {
            get { return this.factory.CreateSourceCollection(this._asIiTunes.Sources); }
        }

        public IEncoderCollection Encoders
        {
            get { return this.factory.CreateEncoderCollection(this._asIiTunes.Encoders); }
        }

        public IEQPresetCollection EQPresets
        {
            get { return this.factory.CreateEQPresetCollection(this._asIiTunes.EQPresets); }
        }

        public IVisualCollection Visuals
        {
            get { return this.factory.CreateVisualCollection(this._asIiTunes.Visuals); }
        }

        public IWindowCollection Windows
        {
            get { return this.factory.CreateWindowCollection(this._asIiTunes.Windows); }
        }

        public int SoundVolume
        {
            get { return this._asIiTunes.SoundVolume; }
            set { this._asIiTunes.SoundVolume = value; }
        }

        public bool Mute
        {
            get { return this._asIiTunes.Mute; }
            set { this._asIiTunes.Mute = value; }
        }

        public PlayerState PlayerState
        {
            get { return (PlayerState) this._asIiTunes.PlayerState; }
        }

        public int PlayerPosition
        {
            get { return this._asIiTunes.PlayerPosition; }
            set { this._asIiTunes.PlayerPosition = value; }
        }

        public IEncoder CurrentEncoder
        {
            get { return this.factory.CreateEncoder(this._asIiTunes.CurrentEncoder); }
            set { this._asIiTunes.CurrentEncoder = value.__asIITEncoder; }
        }

        public bool VisualsEnabled
        {
            get { return this._asIiTunes.VisualsEnabled; }
            set { this._asIiTunes.VisualsEnabled = value; }
        }

        public bool FullScreenVisuals
        {
            get { return this._asIiTunes.FullScreenVisuals; }
            set { this._asIiTunes.FullScreenVisuals = value; }
        }

        public VisualSize VisualSize
        {
            get { return (VisualSize) this._asIiTunes.VisualSize; }
            set { this._asIiTunes.VisualSize = (iTunes.ITVisualSize) value; }
        }

        public IVisual CurrentVisual
        {
            get { return this.factory.CreateVisual(this._asIiTunes.CurrentVisual); }
            set { this._asIiTunes.CurrentVisual = value.__asIITVisual; }
        }

        public bool EQEnabled
        {
            get { return this._asIiTunes.EQEnabled; }
            set { this._asIiTunes.EQEnabled = value; }
        }

        public IEQPreset CurrentEQPreset
        {
            get { return this.factory.CreateEQPreset(this._asIiTunes.CurrentEQPreset); }
            set { this._asIiTunes.CurrentEQPreset = value.__asIITEQPreset; }
        }

        public string CurrentStreamTitle
        {
            get { return this._asIiTunes.CurrentStreamTitle; }
        }

        public string CurrentStreamURL
        {
            get { return this._asIiTunes.CurrentStreamURL; }
        }

        public IBrowserWindow BrowserWindow
        {
            get { return this.factory.CreateBrowserWindow(this._asIiTunes.BrowserWindow); }
        }

        public IWindow EQWindow
        {
            get { return this.factory.CreateWindow(this._asIiTunes.EQWindow); }
        }

        public ISource LibrarySource
        {
            get { return this.factory.CreateSource(this._asIiTunes.LibrarySource); }
        }

        public ILibraryPlaylist LibraryPlaylist
        {
            get { return this.factory.CreateLibraryPlaylist(this._asIiTunes.LibraryPlaylist); }
        }

        public ITrack CurrentTrack
        {
            get { return this.factory.CreateTrack(this._asIiTunes.CurrentTrack); }
        }

        public IPlaylist CurrentPlaylist
        {
            get { return this.factory.CreatePlaylist(this._asIiTunes.CurrentPlaylist); }
        }

        public ITrackCollection SelectedTracks
        {
            get { return this.factory.CreateTrackCollection(this._asIiTunes.SelectedTracks); }
        }

        public string Version
        {
            get { return this._asIiTunes.Version; }
        }

        public bool AppCommandMessageProcessingEnabled
        {
            get { return this._asIiTunes.AppCommandMessageProcessingEnabled; }
            set { this._asIiTunes.AppCommandMessageProcessingEnabled = value; }
        }

        public bool ForceToForegroundOnDialog
        {
            get { return this._asIiTunes.ForceToForegroundOnDialog; }
            set { this._asIiTunes.ForceToForegroundOnDialog = value; }
        }

        public IConvertOperationStatusWithEvents ConvertOperationStatus
        {
            get { return this.factory.CreateConvertOperationStatus(this._asIiTunes.ConvertOperationStatus); }
        }

        public bool SoundVolumeControlEnabled
        {
            get { return this._asIiTunes.SoundVolumeControlEnabled; }
        }

        public string LibraryXMLPath
        {
            get { return this._asIiTunes.LibraryXMLPath; }
        }

        public IITunesWrappedObjectFactory factory
        {
            get { return this._objectFactory; }
        }

        // ~ITunesApp()
        // {
        //     //this.DetachEvents();
        // }

        private void _onITDatabaseChangedEvent(object deletedObjectIDs, object changedObjectIDs)
        {
            var deletedObjects = new List<IITObject>();
            if (deletedObjectIDs != null)
            {
                var ObjectIDs = deletedObjectIDs as object[,];
                if (ObjectIDs != null)
                {
                    for (int i = ObjectIDs.GetLowerBound(0); i <= ObjectIDs.GetUpperBound(0); i++)
                        deletedObjects.Add(
                            this.factory.GetCacheOrAbstractObject<ITObject>(
                                (int) ObjectIDs[i, 0], (int) ObjectIDs[i, 1],
                                (int) ObjectIDs[i, 2], (int) ObjectIDs[i, 3]));
                }
            }
            var changedObjects = new List<IITObject>();
            if (changedObjectIDs != null)
            {
                var ObjectIDs = changedObjectIDs as object[,];
                if (ObjectIDs != null)
                {
                    for (int i = ObjectIDs.GetLowerBound(0); i <= ObjectIDs.GetUpperBound(0); i++)
                        changedObjects.Add(
                            this.GetITObjectByID(
                                (int) ObjectIDs[i, 0], (int) ObjectIDs[i, 1],
                                (int) ObjectIDs[i, 2], (int) ObjectIDs[i, 3]));
                }
            }
            var e = this.DatabaseChangedEvent;
            if (e != null)
                e(this,
                  new DatabaseChangedEventArgs(deletedObjects.ToArray(), changedObjects.ToArray()));
        }

        private void _onPlayerPlayEvent(object track)
        {
            var e = this.PlayerPlayEvent;
            if (e != null) e(this, new TrackEventArgs(this.factory.CreateTrack(track as iTunes.IITTrack)));
        }

        private void _onPlayerStopEvent(object track)
        {
            var e = this.PlayerStopEvent;
            if (e != null) e(this, new TrackEventArgs(this.factory.CreateTrack(track as iTunes.IITTrack)));
        }

        private void _onPlayerPlayingTrackChangedEvent(object track)
        {
            var e = this.PlayerPlayingTrackChangedEvent;
            if (e != null)
                e(this, new TrackEventArgs(this.factory.CreateTrack(track as iTunes.IITTrack)));
        }

        private void _onCOMCallsDisabledEvent(iTunes.ITCOMDisabledReason reason)
        {
            var e = this.COMCallsDisabledEvent;
            if (e != null) e(this, new COMCallsDisabledEventArgs((COMDisabledReason) reason));
        }

        private void _onCOMCallsEnabledEvent()
        {
            var e = this.COMCallsEnabledEvent;
            if (e != null) e(this, EventArgs.Empty);
        }

        private void _onQuittingEvent()
        {
            var e = this.QuittingEvent;
            if (e != null) e(this, EventArgs.Empty);
        }

        private void _onAbortToPromptUserToQuitEvent()
        {
            var e = this.AbortToPromptUserToQuitEvent;
            if (e != null) e(this, EventArgs.Empty);
        }

        private void _onSoundVolumeChangedEvent(int newVolume)
        {
            var e = this.SoundVolumeChangedEvent;
            if (e != null) e(this, new SoundVolumeChangedEventArgs(newVolume));
        }

        static private object _convertToITObjects(IITInternalObject track)
        {
            return track.__internalObject;
        }

        public event EventHandler<DatabaseChangedEventArgs> DatabaseChangedEvent;
        public event EventHandler<TrackEventArgs> PlayerPlayEvent;
        public event EventHandler<TrackEventArgs> PlayerStopEvent;
        public event EventHandler<TrackEventArgs> PlayerPlayingTrackChangedEvent;
        public event EventHandler<COMCallsDisabledEventArgs> COMCallsDisabledEvent;
        public event EventHandler<EventArgs> COMCallsEnabledEvent;
        public event EventHandler<EventArgs> QuittingEvent;
        public event EventHandler<EventArgs> AbortToPromptUserToQuitEvent;
        public event EventHandler<SoundVolumeChangedEventArgs> SoundVolumeChangedEvent;
        public event EventHandler<EventAttachStatusChangedEventArgs> EventAttachStatusChangedEvent;

        public void BackTrack()
        {
            this._asIiTunes.BackTrack();
        }

        public void FastForward()
        {
            this._asIiTunes.FastForward();
        }

        public void NextTrack()
        {
            this._asIiTunes.NextTrack();
        }

        public void Pause()
        {
            this._asIiTunes.Pause();
        }

        public void Play()
        {
            this._asIiTunes.Play();
        }

        public void PlayFile(string filePath)
        {
            this._asIiTunes.PlayFile(filePath);
        }

        public void PlayPause()
        {
            this._asIiTunes.PlayPause();
        }

        public void PreviousTrack()
        {
            this._asIiTunes.PreviousTrack();
        }

        public void Resume()
        {
            this._asIiTunes.Resume();
        }

        public void Rewind()
        {
            this._asIiTunes.Rewind();
        }

        public void Stop()
        {
            this._asIiTunes.Stop();
        }

        public IConvertOperationStatusWithEvents ConvertFile(string filePath)
        {
            return this.factory.CreateConvertOperationStatus(this._asIiTunes.ConvertFile2(filePath));
        }

        public IConvertOperationStatusWithEvents ConvertFiles(string[] filePaths)
        {
            object real = filePaths;
            return this.factory.CreateConvertOperationStatus(this._asIiTunes.ConvertFiles2(ref real));
        }

        public IConvertOperationStatusWithEvents ConvertTrack(ITrack iTrackToConvert)
        {
            object real = _convertToITObjects(iTrackToConvert);
            return this.factory.CreateConvertOperationStatus(this._asIiTunes.ConvertTrack2(ref real));
        }

        public IConvertOperationStatusWithEvents ConvertTracks(ITrack[] iTracksToConvert)
        {
            object real =
                iTracksToConvert.ToList().ConvertAll(
                    new Converter<ITrack, object>(_convertToITObjects)).ToArray();
            return this.factory.CreateConvertOperationStatus(this._asIiTunes.ConvertTracks2(ref real));
        }

        public bool CheckVersion(int majorVersion, int minorVersion)
        {
            return this._asIiTunes.CheckVersion(majorVersion, minorVersion);
        }

        public IITObject GetITObjectByID(int sourceID, int playlistID, int trackID, int databaseID)
        {
            try
            {
                return this.factory.CreateObject(
                    this._asIiTunes.GetITObjectByID(sourceID, playlistID, trackID, databaseID));
            } catch (COMException)
            {
                return null;
            }
        }

        public IPlaylist CreatePlaylist(string playlistName)
        {
            return this.factory.CreatePlaylist(this._asIiTunes.CreatePlaylist(playlistName));
        }

        public void OpenURL(string URL)
        {
            this._asIiTunes.OpenURL(URL);
        }

        public void GotoMusicStoreHomePage()
        {
            this._asIiTunes.GotoMusicStoreHomePage();
        }

        public void UpdateIPod()
        {
            this._asIiTunes.UpdateIPod();
        }

        public void Authorize(int numElems, ref object data, ref string names)
        {
            this._asIiTunes.Authorize(numElems, ref data, ref names);
        }

        public void Quit()
        {
            this._asIiTunes.Quit();
        }

        public void SetOptions(int options)
        {
            this._asIiTunes.SetOptions(options);
        }

        public IEQPreset CreateEQPreset(string eqPresetName)
        {
            return this.factory.CreateEQPreset(this._asIiTunes.CreateEQPreset(eqPresetName));
        }

        public IPlaylist CreatePlaylistInSource(string playlistName, ISource iSource)
        {
            return iSource.CreatePlaylist(playlistName);
        }

        public void GetPlayerButtonsState(out bool previousEnabled, out PlayButtonState playPauseStopState,
                                          out bool nextEnabled)
        {
            iTunes.ITPlayButtonState tempPlayPauseStopState;
            this._asIiTunes.GetPlayerButtonsState(out previousEnabled, out tempPlayPauseStopState, out nextEnabled);
            playPauseStopState = (PlayButtonState) tempPlayPauseStopState;
        }

        public void PlayerButtonClicked(PlayerButton playerButton, int playerButtonModifierKeys)
        {
            this._asIiTunes.PlayerButtonClicked((iTunes.ITPlayerButton) playerButton, playerButtonModifierKeys);
        }

        public void SubscribeToPodcast(string URL)
        {
            this._asIiTunes.SubscribeToPodcast(URL);
        }

        public void UpdatePodcastFeeds()
        {
            this._asIiTunes.UpdatePodcastFeeds();
        }

        public IPlaylist CreateFolder(string folderName)
        {
            return this.factory.CreatePlaylist(this._asIiTunes.CreateFolder(folderName));
        }

        public IPlaylist CreateFolderInSource(string folderName, ISource iSource)
        {
            return iSource.CreateFolder(folderName);
        }
    }

    internal class CanSetShufflePlaylistCollection : IIndexedCollection<IPlaylist, bool>
    {
        public bool this[IPlaylist Playlist]
        {
            get { return Playlist.CanSetShuffle; }
        }
    }

    internal class CanSetSongRepeatPlaylistCollection : IIndexedCollection<IPlaylist, bool>
    {
        public bool this[IPlaylist Playlist]
        {
            get { return Playlist.CanSetSongRepeat; }
        }
    }

    public class DatabaseChangedEventArgs : EventArgs
    {
        private readonly IITObject[] changedObjects;
        private readonly IITObject[] deletedObjects;

        public DatabaseChangedEventArgs(IITObject[] deletedObjects, IITObject[] changedObjects)
        {
            this.deletedObjects = deletedObjects;
            this.changedObjects = changedObjects;
        }

        public IITObject[] DeletedObjects
        {
            get { return this.deletedObjects; }
        }

        public IITObject[] ChangedObjects
        {
            get { return this.changedObjects; }
        }
    }

    public class TrackEventArgs : EventArgs
    {
        private readonly ITrack track;

        public TrackEventArgs(ITrack track)
        {
            this.track = track;
        }

        public ITrack Track
        {
            get { return this.track; }
        }
    }

    public class COMCallsDisabledEventArgs : EventArgs
    {
        private readonly COMDisabledReason reason;

        public COMCallsDisabledEventArgs(COMDisabledReason reason)
        {
            this.reason = reason;
        }

        public COMDisabledReason Reason
        {
            get { return this.reason; }
        }
    }

    public class SoundVolumeChangedEventArgs : EventArgs
    {
        private readonly int newVolume;

        public SoundVolumeChangedEventArgs(int newVolume)
        {
            this.newVolume = newVolume;
        }

        public int NewVolume
        {
            get { return this.newVolume; }
        }
    }
}