Renamed a bunch of events to conform to .NET event pattern

gladish · gladish · commit 18642d677998 · 2015-01-07T21:29:29.000-05:00
diff --git a/Spotify/DomainObject.cs b/Spotify/DomainObject.cs
@@ -121,7 +121,7 @@ private set
             {
                 _handle = value;
             }
-        }
+        }    
 
         protected delegate int MakeListGetCount(IntPtr p);
         protected delegate IntPtr MakeListGetItem<T>(IntPtr p, int index);
diff --git a/Spotify/Image.cs b/Spotify/Image.cs
@@ -7,12 +7,12 @@ namespace Spotify
 {
     public class Image : DomainObject
     {
-        public event EventHandler OnLoaded;
+        public event EventHandler Loaded;
 
         internal Image(IntPtr handle, bool preIncremented = true)
             : base(handle, LibSpotify.sp_image_add_ref_r, LibSpotify.sp_image_release_r, preIncremented)
         {
-            ThrowHelper.ThrowIfError(LibSpotify.sp_image_add_load_callback_r(Handle, HandleImageLoaded, IntPtr.Zero));
+            ThrowHelper.ThrowIfError(LibSpotify.sp_image_add_load_callback_r(Handle, OnImageLoaded, IntPtr.Zero));
         }
 
         public System.Drawing.Image ToImage()
@@ -28,15 +28,15 @@ protected override void Dispose(bool disposing)
 
             if (disposing)
             {
-                LibSpotify.sp_image_remove_load_callback_r(Handle, HandleImageLoaded, IntPtr.Zero);
+                LibSpotify.sp_image_remove_load_callback_r(Handle, OnImageLoaded, IntPtr.Zero);
             }
 
             base.Dispose(disposing);
         }
 
-        private void HandleImageLoaded(IntPtr image, IntPtr user)
+        private void OnImageLoaded(IntPtr image, IntPtr user)
         {
-            EventDispatcher.Dispatch(this, image, OnLoaded, EventArgs.Empty);
+            EventDispatcher.Dispatch(this, image, Loaded, EventArgs.Empty);
         }
 
         public bool IsLoaded
diff --git a/Spotify/Internal/ImageLoader.cs b/Spotify/Internal/ImageLoader.cs
@@ -25,7 +25,7 @@ public static IAsyncResult Begin(ImageLoad load, IntPtr p, Session session, Imag
             AsyncLoadImageResult result = new AsyncLoadImageResult(userCallback, state);
             Image image = new Image(LibSpotify.sp_image_create_r(session.Handle, load(p, size)));
             result.Closure = image;
-            image.OnLoaded += result.HandleImageLoaded;
+            image.Loaded += result.HandleImageLoaded;
             return result;
         }
 
diff --git a/Spotify/LibSpotify.cs b/Spotify/LibSpotify.cs
@@ -1140,29 +1140,7 @@ public static System.IntPtr sp_playlist_subscribers_r(System.IntPtr playlist)
         {
             lock (_apiLock)
                 return sp_playlist_subscribers(playlist);
-        }
-
-        internal static IList<string> GetPlaylistSubscribers(IntPtr playlist)
-        {
-            List<string> subscribers = new List<string>();
-
-            IntPtr p = LibSpotify.sp_playlist_subscribers_r(playlist);
-            if (p != IntPtr.Zero)
-            {
-                int n = Marshal.ReadInt32(p);
-
-                int offset = Marshal.SizeOf(typeof(Int32));
-                for (int i = 0; i < n; ++i)
-                {
-                    subscribers.Add(ReadUtf8(Marshal.ReadIntPtr(p, offset)));
-                    offset += Marshal.SizeOf(typeof(IntPtr));
-                }
-
-                LibSpotify.sp_playlist_subscribers_free_r(p);
-            }
-
-            return subscribers;
-        }
+        }        
 
         [System.Runtime.InteropServices.DllImport("libspotify")]
         private static extern Spotify.Error sp_playlist_subscribers_free(System.IntPtr subscribers);
diff --git a/Spotify/Playlist.cs b/Spotify/Playlist.cs
@@ -1,6 +1,7 @@
 ﻿using System;
 using System.Collections.Generic;
 using System.ComponentModel;
+using System.Runtime.InteropServices;
 using System.Linq;
 
 using Spotify.Internal;
@@ -21,7 +22,7 @@ public class Playlist : DomainObject //, INotifyPropertyChanged
         public event EventHandler<PlaylistTrackSeenChangedEventArgs> TrackSeenChanged;
         public event EventHandler<PlaylistDescriptionChangedEventArgs> DescriptionChanged;
 
-        //public event PropertyChangedEventHandler PropertyChanged;
+        // public event PropertyChangedEventHandler PropertyChanged;
 
         // TODO ImageChanged
 
@@ -64,7 +65,6 @@ public bool IsLoaded
             }
         }
 
-
         // I'm still unsure whether exposing NumTracks/TrackAt(int) is better than a List of Tracks. The obvious
         // advantage is not creating a list of Disposable objects everytime someone touches the Tracks. Maybe caching
         // the results would be better and just invalidating on changes
@@ -83,17 +83,15 @@ private Track TrackAt(int index)
             return ListItem(index, p => { return new Track(p, false); },
                 LibSpotify.sp_playlist_num_tracks_r, LibSpotify.sp_playlist_track_r);
         }
-
-
-        private IList<Track> _tracks = null;
+        
         public IList<Track> Tracks
         {
             get
             {
                 if (_tracks == null)
                     _tracks = MakeList(p => { return new Track(p, false); }, LibSpotify.sp_playlist_num_tracks_r, LibSpotify.sp_playlist_track_r);
                 return _tracks;
-            }
+            }            
         }
 
         public string Name
@@ -156,21 +154,20 @@ public string Description
             }
         }
 
-        public int NumSubscribers
+        private int NumSubscribers
         {
             get
             {
                 return Convert.ToInt32(LibSpotify.sp_playlist_num_subscribers_r(Handle));
             }
         }
-
-        public IList<string> _subscribers = null;
+        
         public IList<string> Subscribers
         {
             get
             {
                 if (_subscribers == null)
-                    _subscribers = LibSpotify.GetPlaylistSubscribers(Handle);
+                    _subscribers = MarshalPlaylistSubscribers(Handle);
                 return _subscribers;
             }
         }
@@ -263,7 +260,29 @@ public string GetTrackMessage(Track t)
         }
         #endregion
 
-        #region Private Methods        
+        #region Private Methods   
+        private static IList<string> MarshalPlaylistSubscribers(IntPtr playlist)
+        {
+            List<string> subscribers = new List<string>();
+
+            IntPtr p = LibSpotify.sp_playlist_subscribers_r(playlist);
+            if (p != IntPtr.Zero)
+            {
+                int n = Marshal.ReadInt32(p);
+
+                int offset = Marshal.SizeOf(typeof(Int32));
+                for (int i = 0; i < n; ++i)
+                {
+                    subscribers.Add(LibSpotify.ReadUtf8(Marshal.ReadIntPtr(p, offset)));
+                    offset += Marshal.SizeOf(typeof(IntPtr));
+                }
+
+                LibSpotify.sp_playlist_subscribers_free_r(p);
+            }
+
+            return subscribers;
+        }
+
         private static void ThrowIfDuplicates(IEnumerable<int> e)
         {
             // check for duplicates
@@ -364,6 +383,8 @@ private void OnSubscribersChanged(IntPtr playlist, IntPtr state)
         #endregion
 
         #region Fields
+        private IList<Track> _tracks = null;
+        private IList<string> _subscribers = null;
         private LibSpotify.sp_playlist_callbacks _callbacks;
         #endregion
     }
diff --git a/Spotify/PlaylistContainer.cs b/Spotify/PlaylistContainer.cs
@@ -9,20 +9,20 @@ namespace Spotify
     public class PlaylistContainer : DomainObject
     {
         #region Events
-        public event EventHandler<PlaylistAddedEventArgs> OnPlaylistAdded;
-        public event EventHandler<PlaylistRemovedEventArgs> OnPlaylistRemoved;
-        public event EventHandler OnPlaylistMoved;
-        public event EventHandler OnLoaded;
+        public event EventHandler<PlaylistAddedEventArgs> PlaylistAdded;
+        public event EventHandler<PlaylistRemovedEventArgs> PlaylistRemoved;
+        public event EventHandler PlaylistMoved;
+        public event EventHandler Loaded;
         #endregion
 
         internal PlaylistContainer(IntPtr handle, bool preIncremented = true)
             : base(handle, LibSpotify.sp_playlistcontainer_add_ref_r, LibSpotify.sp_playlistcontainer_release_r, preIncremented)
         {
             LibSpotify.sp_playlistcontainer_callbacks callbacks = new LibSpotify.sp_playlistcontainer_callbacks();
-            callbacks.playlist_added = RaisePlaylistAdded;
-            callbacks.playlist_removed = RaisePlaylistRemoved;
-            callbacks.playlist_moved = RaisePlaylistMoved;
-            callbacks.container_loaded = RaiseContainerLoaded;
+            callbacks.playlist_added = OnPlaylistAdded;
+            callbacks.playlist_removed = OnPlaylistRemoved;
+            callbacks.playlist_moved = OnPlaylistMoved;
+            callbacks.container_loaded = OnContainerLoaded;
 
             ThrowHelper.ThrowIfError(LibSpotify.sp_playlistcontainer_add_callbacks_r(Handle,
                 ref callbacks, IntPtr.Zero));
@@ -134,26 +134,26 @@ public void AddFolder(int index, string name)
         
 
         #region Private Methods
-        private void RaiseContainerLoaded(IntPtr playlistContainer, IntPtr state)
+        private void OnContainerLoaded(IntPtr playlistContainer, IntPtr state)
         {
-            EventDispatcher.Dispatch(this, playlistContainer, OnLoaded, EventArgs.Empty);
+            EventDispatcher.Dispatch(this, playlistContainer, Loaded, EventArgs.Empty);
         }
 
-        private void RaisePlaylistAdded(IntPtr playlistContainer, IntPtr playlist, int position, IntPtr state)
+        private void OnPlaylistAdded(IntPtr playlistContainer, IntPtr playlist, int position, IntPtr state)
         {
-            EventDispatcher.Dispatch(this, playlistContainer, OnPlaylistAdded,
+            EventDispatcher.Dispatch(this, playlistContainer, PlaylistAdded,
                 new PlaylistAddedEventArgs(playlist, position));
         }
 
-        private void RaisePlaylistMoved(IntPtr playlistContainer, IntPtr playlist, int position, int newPosition, IntPtr state)
+        private void OnPlaylistMoved(IntPtr playlistContainer, IntPtr playlist, int position, int newPosition, IntPtr state)
         {
-            EventDispatcher.Dispatch(this, playlistContainer, OnPlaylistMoved,
+            EventDispatcher.Dispatch(this, playlistContainer, PlaylistMoved,
                 new PlaylistMovedEventArgs(playlist, position, newPosition));
         }
 
-        private void RaisePlaylistRemoved(IntPtr playlistContainer, IntPtr playlist, int position, IntPtr state)
+        private void OnPlaylistRemoved(IntPtr playlistContainer, IntPtr playlist, int position, IntPtr state)
         {
-            EventDispatcher.Dispatch(this, playlistContainer, OnPlaylistRemoved,
+            EventDispatcher.Dispatch(this, playlistContainer, PlaylistRemoved,
                 new PlaylistRemovedEventArgs(playlist, position));
         }
         #endregion
diff --git a/Spotify/Session.cs b/Spotify/Session.cs
diff --git a/Spotify/SessionLogin.cs b/Spotify/SessionLogin.cs
diff --git a/examples/jukebox/Program.cs b/examples/jukebox/Program.cs

Original file line number	Diff line number	Diff line change
`@@ -121,7 +121,7 @@ private set`
`121`	`121`	`{`
`122`	`122`	`_handle = value;`
`123`	`123`	`}`
`124`		`- }`
	`124`	`+ }`
`125`	`125`
`126`	`126`	`protected delegate int MakeListGetCount(IntPtr p);`
`127`	`127`	`protected delegate IntPtr MakeListGetItem<T>(IntPtr p, int index);`
Original file line number	Diff line number	Diff line change
`@@ -7,12 +7,12 @@ namespace Spotify`
`7`	`7`	`{`
`8`	`8`	`public class Image : DomainObject`
`9`	`9`	`{`
`10`		`- public event EventHandler OnLoaded;`
	`10`	`+ public event EventHandler Loaded;`
`11`	`11`
`12`	`12`	`internal Image(IntPtr handle, bool preIncremented = true)`
`13`	`13`	`: base(handle, LibSpotify.sp_image_add_ref_r, LibSpotify.sp_image_release_r, preIncremented)`
`14`	`14`	`{`
`15`		`- ThrowHelper.ThrowIfError(LibSpotify.sp_image_add_load_callback_r(Handle, HandleImageLoaded, IntPtr.Zero));`
	`15`	`+ ThrowHelper.ThrowIfError(LibSpotify.sp_image_add_load_callback_r(Handle, OnImageLoaded, IntPtr.Zero));`
`16`	`16`	`}`
`17`	`17`
`18`	`18`	`public System.Drawing.Image ToImage()`
`@@ -28,15 +28,15 @@ protected override void Dispose(bool disposing)`
`28`	`28`
`29`	`29`	`if (disposing)`
`30`	`30`	`{`
`31`		`- LibSpotify.sp_image_remove_load_callback_r(Handle, HandleImageLoaded, IntPtr.Zero);`
	`31`	`+ LibSpotify.sp_image_remove_load_callback_r(Handle, OnImageLoaded, IntPtr.Zero);`
`32`	`32`	`}`
`33`	`33`
`34`	`34`	`base.Dispose(disposing);`
`35`	`35`	`}`
`36`	`36`
`37`		`- private void HandleImageLoaded(IntPtr image, IntPtr user)`
	`37`	`+ private void OnImageLoaded(IntPtr image, IntPtr user)`
`38`	`38`	`{`
`39`		`- EventDispatcher.Dispatch(this, image, OnLoaded, EventArgs.Empty);`
	`39`	`+ EventDispatcher.Dispatch(this, image, Loaded, EventArgs.Empty);`
`40`	`40`	`}`
`41`	`41`
`42`	`42`	`public bool IsLoaded`
Original file line number	Diff line number	Diff line change
`@@ -25,7 +25,7 @@ public static IAsyncResult Begin(ImageLoad load, IntPtr p, Session session, Imag`
`25`	`25`	`AsyncLoadImageResult result = new AsyncLoadImageResult(userCallback, state);`
`26`	`26`	`Image image = new Image(LibSpotify.sp_image_create_r(session.Handle, load(p, size)));`
`27`	`27`	`result.Closure = image;`
`28`		`- image.OnLoaded += result.HandleImageLoaded;`
	`28`	`+ image.Loaded += result.HandleImageLoaded;`
`29`	`29`	`return result;`
`30`	`30`	`}`
`31`	`31`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,7 @@`
`1`	`1`	`using System;`
`2`	`2`	`using System.Collections.Generic;`
`3`	`3`	`using System.ComponentModel;`
	`4`	`+using System.Runtime.InteropServices;`
`4`	`5`	`using System.Linq;`
`5`	`6`
`6`	`7`	`using Spotify.Internal;`
`@@ -21,7 +22,7 @@ public class Playlist : DomainObject //, INotifyPropertyChanged`
`21`	`22`	`public event EventHandler<PlaylistTrackSeenChangedEventArgs> TrackSeenChanged;`
`22`	`23`	`public event EventHandler<PlaylistDescriptionChangedEventArgs> DescriptionChanged;`
`23`	`24`
`24`		`- //public event PropertyChangedEventHandler PropertyChanged;`
	`25`	`+ // public event PropertyChangedEventHandler PropertyChanged;`
`25`	`26`
`26`	`27`	`// TODO ImageChanged`
`27`	`28`
`@@ -64,7 +65,6 @@ public bool IsLoaded`
`64`	`65`	`}`
`65`	`66`	`}`
`66`	`67`
`67`		`-`
`68`	`68`	`// I'm still unsure whether exposing NumTracks/TrackAt(int) is better than a List of Tracks. The obvious`
`69`	`69`	`// advantage is not creating a list of Disposable objects everytime someone touches the Tracks. Maybe caching`
`70`	`70`	`// the results would be better and just invalidating on changes`
`@@ -83,17 +83,15 @@ private Track TrackAt(int index)`
`83`	`83`	`return ListItem(index, p => { return new Track(p, false); },`
`84`	`84`	`LibSpotify.sp_playlist_num_tracks_r, LibSpotify.sp_playlist_track_r);`
`85`	`85`	`}`
`86`		`-`
`87`		`-`
`88`		`- private IList<Track> _tracks = null;`
	`86`	`+`
`89`	`87`	`public IList<Track> Tracks`
`90`	`88`	`{`
`91`	`89`	`get`
`92`	`90`	`{`
`93`	`91`	`if (_tracks == null)`
`94`	`92`	`_tracks = MakeList(p => { return new Track(p, false); }, LibSpotify.sp_playlist_num_tracks_r, LibSpotify.sp_playlist_track_r);`
`95`	`93`	`return _tracks;`
`96`		`- }`
	`94`	`+ }`
`97`	`95`	`}`
`98`	`96`
`99`	`97`	`public string Name`
`@@ -156,21 +154,20 @@ public string Description`
`156`	`154`	`}`
`157`	`155`	`}`
`158`	`156`
`159`		`- public int NumSubscribers`
	`157`	`+ private int NumSubscribers`
`160`	`158`	`{`
`161`	`159`	`get`
`162`	`160`	`{`
`163`	`161`	`return Convert.ToInt32(LibSpotify.sp_playlist_num_subscribers_r(Handle));`
`164`	`162`	`}`
`165`	`163`	`}`
`166`		`-`
`167`		`- public IList<string> _subscribers = null;`
	`164`	`+`
`168`	`165`	`public IList<string> Subscribers`
`169`	`166`	`{`
`170`	`167`	`get`
`171`	`168`	`{`
`172`	`169`	`if (_subscribers == null)`
`173`		`- _subscribers = LibSpotify.GetPlaylistSubscribers(Handle);`
	`170`	`+ _subscribers = MarshalPlaylistSubscribers(Handle);`
`174`	`171`	`return _subscribers;`
`175`	`172`	`}`
`176`	`173`	`}`
`@@ -263,7 +260,29 @@ public string GetTrackMessage(Track t)`
`263`	`260`	`}`
`264`	`261`	`#endregion`
`265`	`262`
`266`		`- #region Private Methods`
	`263`	`+ #region Private Methods`
	`264`	`+ private static IList<string> MarshalPlaylistSubscribers(IntPtr playlist)`
	`265`	`+ {`
	`266`	`+ List<string> subscribers = new List<string>();`
	`267`	`+`
	`268`	`+ IntPtr p = LibSpotify.sp_playlist_subscribers_r(playlist);`
	`269`	`+ if (p != IntPtr.Zero)`
	`270`	`+ {`
	`271`	`+ int n = Marshal.ReadInt32(p);`
	`272`	`+`
	`273`	`+ int offset = Marshal.SizeOf(typeof(Int32));`
	`274`	`+ for (int i = 0; i < n; ++i)`
	`275`	`+ {`
	`276`	`+ subscribers.Add(LibSpotify.ReadUtf8(Marshal.ReadIntPtr(p, offset)));`
	`277`	`+ offset += Marshal.SizeOf(typeof(IntPtr));`
	`278`	`+ }`
	`279`	`+`
	`280`	`+ LibSpotify.sp_playlist_subscribers_free_r(p);`
	`281`	`+ }`
	`282`	`+`
	`283`	`+ return subscribers;`
	`284`	`+ }`
	`285`	`+`
`267`	`286`	`private static void ThrowIfDuplicates(IEnumerable<int> e)`
`268`	`287`	`{`
`269`	`288`	`// check for duplicates`
`@@ -364,6 +383,8 @@ private void OnSubscribersChanged(IntPtr playlist, IntPtr state)`
`364`	`383`	`#endregion`
`365`	`384`
`366`	`385`	`#region Fields`
	`386`	`+ private IList<Track> _tracks = null;`
	`387`	`+ private IList<string> _subscribers = null;`
`367`	`388`	`private LibSpotify.sp_playlist_callbacks _callbacks;`
`368`	`389`	`#endregion`
`369`	`390`	`}`