root/lang/csharp/iTunesCOMWrap/trunk/iTunesCOMWrap/Playlists.cs @ 19312

Revision 19312, 18.6 kB (checked in by topia, 6 years ago)

add Playlist.SameTrack? methods.
* add TracksNeverDuplicate? internal property.
* fix regression of LibraryPlaylist?.SameTracks?(IItemTrack track).

  • Property svn:eol-style set to CRLF
  • Property svn:keywords set to Id URL Date Rev Author
Line 
1// $Id$
2using System;
3using System.Collections;
4using System.Collections.Generic;
5using System.Linq;
6using Clovery.iTunesHelper.COMWrap.Interfaces;
7using Clovery.iTunesHelper.COMWrap.Interfaces.Internal;
8using Clovery.iTunesHelper.COMWrap.Internal;
9using iTunes = iTunesLib;
10
11namespace Clovery.iTunesHelper.COMWrap
12{
13    internal class Playlist : ITObject, IPlaylist
14    {
15        internal Playlist(iTunes.IITPlaylist _internal, ITunesApp _app)
16            : base(_internal, _app)
17        {
18        }
19
20        public iTunes.IITPlaylist __asIITPlaylist
21        {
22            get { return (iTunesLib.IITPlaylist) this._internal; }
23        }
24
25        public void PlayFirstTrack()
26        {
27            this.__asIITPlaylist.PlayFirstTrack();
28        }
29
30        public void Delete()
31        {
32            this.__asIITPlaylist.Delete();
33        }
34
35        public void Print(bool showPrintDialog, PlaylistPrintKind printKind, string theme)
36        {
37            this.__asIITPlaylist.Print(showPrintDialog, (iTunesLib.ITPlaylistPrintKind) printKind, theme);
38        }
39
40        public ITrackCollection Search(string searchText, PlaylistSearchField searchFields)
41        {
42            return this.factory.CreateTrackCollection(
43                this.__asIITPlaylist.Search(
44                    searchText, (iTunes.ITPlaylistSearchField) searchFields));
45        }
46
47        public ITrack SameTrack(ITrack track)
48        {
49            return this.SameTrack(track.TrackDatabaseID, track.Name);
50        }
51
52        public ITrack SameTrack(IItemTrack track)
53        {
54            return this.Tracks.ItemByPersistentID[track.PersistentID];
55        }
56
57        public ITrack SameTrack(int trackDatabaseID, string name)
58        {
59            var trackCollection = name == null
60                                      ? this.Tracks
61                                      : this.Search(name, PlaylistSearchField.SongNames);
62
63            if (trackCollection == null) return null;
64            foreach (var track in trackCollection)
65                if (track.TrackDatabaseID == trackDatabaseID)
66                    return track;
67            return null;
68        }
69
70        public ITrack SameTrack(int trackDatabaseID)
71        {
72            return this.SameTrack(trackDatabaseID, null);
73        }
74
75        public List<ITrack> SameTracks(ITrack track)
76        {
77            if (this.TracksNeverDuplicates)
78                return new[] {this.SameTrack(track)}.ToList();
79
80            return this.SameTracks(track.TrackDatabaseID, track.Name);
81        }
82
83        public List<ITrack> SameTracks(IItemTrack track)
84        {
85            if (this.TracksNeverDuplicates)
86                return new[] {this.SameTrack(track)}.ToList();
87
88            // fall quickly, but didn't work with LibraryPlaylist.
89            // LibraryPlaylist.TracksNeverDuplicates should be true, but do double-checking.
90            if (this as LibraryPlaylist != null)
91                throw new InvalidOperationException("LibraryPlaylist can't use this implementation.");
92
93            var playlistCollection = track.Playlists;
94            if (playlistCollection == null || !playlistCollection.Contains(this))
95                return new List<ITrack>();
96            return this.SameTracks((ITrack) track);
97        }
98
99        public List<ITrack> SameTracks(int trackDatabaseId, string name)
100        {
101            if (this.TracksNeverDuplicates)
102                return new[] {this.SameTrack(trackDatabaseId, name)}.ToList();
103
104            var trackCollection = name == null
105                                      ? this.Tracks
106                                      : this.Search(name, PlaylistSearchField.SongNames);
107
108            if (trackCollection == null) return new List<ITrack>();
109            return trackCollection.Where(track => track.TrackDatabaseID == trackDatabaseId).ToList();
110        }
111
112        public List<ITrack> SameTracks(int trackDatabaseID)
113        {
114            if (this.TracksNeverDuplicates)
115                return new[] {this.SameTrack(trackDatabaseID)}.ToList();
116
117            return this.SameTracks(trackDatabaseID, null);
118        }
119
120        public ITrackCollection Tracks
121        {
122            get { return this.factory.CreateTrackCollection(this.__asIITPlaylist.Tracks); }
123        }
124
125        public bool Visible
126        {
127            get { return this.__asIITPlaylist.Visible; }
128        }
129
130        public string Time
131        {
132            get { return this.__asIITPlaylist.Time; }
133        }
134
135        public PlaylistRepeatMode SongRepeat
136        {
137            get { return (PlaylistRepeatMode) this.__asIITPlaylist.SongRepeat; }
138            set { this.__asIITPlaylist.SongRepeat = (iTunesLib.ITPlaylistRepeatMode) value; }
139        }
140
141        public double Size
142        {
143            get { return this.__asIITPlaylist.Size; }
144        }
145
146        public bool Shuffle
147        {
148            get { return this.__asIITPlaylist.Shuffle; }
149            set { this.__asIITPlaylist.Shuffle = value; }
150        }
151
152        public int Duration
153        {
154            get { return this.__asIITPlaylist.Duration; }
155        }
156
157        public ISource Source
158        {
159            get { return this.factory.CreateSource(this.__asIITPlaylist.Source); }
160        }
161
162        public PlaylistKind Kind
163        {
164            get { return (PlaylistKind) this.__asIITPlaylist.Kind; }
165        }
166
167        public bool CanSetShuffle
168        {
169            get
170            {
171                object _temporary = this.__asIITPlaylist;
172                return this._app._asIiTunes.get_CanSetShuffle(ref _temporary);
173            }
174        }
175
176        public bool CanSetSongRepeat
177        {
178            get
179            {
180                object _temporary = this.__asIITPlaylist;
181                return this._app._asIiTunes.get_CanSetSongRepeat(ref _temporary);
182            }
183        }
184
185        internal protected virtual bool TracksNeverDuplicates
186        {
187            get { return false; }
188        }
189    }
190
191    internal class AudioCDPlaylist : Playlist, IAudioCDPlaylist
192    {
193        protected internal AudioCDPlaylist(iTunes.IITAudioCDPlaylist _internal, ITunesApp _app) :
194            base(_internal, _app)
195        {
196        }
197
198        protected internal iTunes.IITAudioCDPlaylist _asIITAudioCDPlaylist
199        {
200            get { return (iTunesLib.IITAudioCDPlaylist) this._internal; }
201        }
202
203        public void Reveal()
204        {
205            this._asIITAudioCDPlaylist.Reveal();
206        }
207
208        public string Artist
209        {
210            get { return this._asIITAudioCDPlaylist.Artist; }
211        }
212
213        public bool Compilation
214        {
215            get { return this._asIITAudioCDPlaylist.Compilation; }
216        }
217
218        public string Composer
219        {
220            get { return this._asIITAudioCDPlaylist.Composer; }
221        }
222
223        public int DiscCount
224        {
225            get { return this._asIITAudioCDPlaylist.DiscCount; }
226        }
227
228        public int DiscNumber
229        {
230            get { return this._asIITAudioCDPlaylist.DiscNumber; }
231        }
232
233        public string Genre
234        {
235            get { return this._asIITAudioCDPlaylist.Genre; }
236        }
237
238        public int Year
239        {
240            get { return this._asIITAudioCDPlaylist.Year; }
241        }
242
243        internal protected override bool TracksNeverDuplicates
244        {
245            get { return true; }
246        }
247    }
248
249    internal class LibraryPlaylist : Playlist, ILibraryPlaylist
250    {
251        protected internal LibraryPlaylist(iTunes.IITLibraryPlaylist _internal, ITunesApp _app)
252            : base(_internal, _app)
253        {
254        }
255
256        protected internal iTunes.IITLibraryPlaylist _asIITLibraryPlaylist
257        {
258            get { return (iTunesLib.IITLibraryPlaylist) this._internal; }
259        }
260
261        public IOperationStatus AddFile(string filePath)
262        {
263            return this.factory.CreateOperationStatus(this._asIITLibraryPlaylist.AddFile(filePath));
264        }
265
266        public IOperationStatus AddFiles(string[] filePaths)
267        {
268            object real = filePaths;
269            return this.factory.CreateOperationStatus(this._asIITLibraryPlaylist.AddFiles(ref real));
270        }
271
272        public IURLTrack AddURL(string URL)
273        {
274            return this.factory.CreateURLTrack(this._asIITLibraryPlaylist.AddURL(URL));
275        }
276
277        public ITrack AddTrack(ITrack iTrackToAdd)
278        {
279            object _real = iTrackToAdd.__internalObject;
280            return this.factory.CreateTrack(this._asIITLibraryPlaylist.AddTrack(ref _real));
281        }
282
283        internal protected override bool TracksNeverDuplicates
284        {
285            get { return true; }
286        }
287    }
288
289    internal class UserPlaylist : Playlist, IUserPlaylist
290    {
291        protected internal bool _smart;
292
293        protected internal UserPlaylist(iTunes.IITUserPlaylist _internal, ITunesApp _app)
294            : base(_internal, _app)
295        {
296            this._smart = this._asIITUserPlaylist.Smart;
297        }
298
299        protected internal iTunes.IITUserPlaylist _asIITUserPlaylist
300        {
301            get { return (iTunesLib.IITUserPlaylist) this._internal; }
302        }
303
304        public IOperationStatus AddFile(string filePath)
305        {
306            return this.factory.CreateOperationStatus(this._asIITUserPlaylist.AddFile(filePath));
307        }
308
309        public IOperationStatus AddFiles(string[] filePaths)
310        {
311            object real = filePaths;
312            return this.factory.CreateOperationStatus(this._asIITUserPlaylist.AddFiles(ref real));
313        }
314
315        public IURLTrack AddURL(string URL)
316        {
317            return this.factory.CreateURLTrack(this._asIITUserPlaylist.AddURL(URL));
318        }
319
320        public ITrack AddTrack(ITrack iTrackToAdd)
321        {
322            object _real = iTrackToAdd.__internalObject;
323            return this.factory.CreateTrack(this._asIITUserPlaylist.AddTrack(ref _real));
324        }
325
326        public IPlaylist CreatePlaylist(string playlistName)
327        {
328            return this.factory.CreatePlaylist(this._asIITUserPlaylist.CreatePlaylist(playlistName));
329        }
330
331        public IPlaylist CreateFolder(string folderName)
332        {
333            return this.factory.CreatePlaylist(this._asIITUserPlaylist.CreateFolder(folderName));
334        }
335
336        public IPlaylist GetOrCreatePlaylist(string playlistName)
337        {
338            IPlaylist playlist = this.Children[playlistName];
339            if (playlist != null)
340            {
341                return playlist;
342            }
343            return this.CreatePlaylist(playlistName);
344        }
345
346        public IPlaylist GetOrCreateFolder(string folderName)
347        {
348            IPlaylist playlist = this.Children[folderName];
349            if (playlist != null)
350            {
351                return playlist;
352            }
353            return this.CreateFolder(folderName);
354        }
355
356        public void Reveal()
357        {
358            this._asIITUserPlaylist.Reveal();
359        }
360
361        public bool Shared
362        {
363            get { return this._asIITUserPlaylist.Shared; }
364            set { this._asIITUserPlaylist.Shared = value; }
365        }
366
367        public bool Smart
368        {
369            get { return this._smart; }
370        }
371
372        internal protected override bool TracksNeverDuplicates
373        {
374            get { return this.Smart; }
375        }
376
377        public UserPlaylistSpecialKind SpecialKind
378        {
379            get { return (UserPlaylistSpecialKind) this._asIITUserPlaylist.SpecialKind; }
380        }
381
382        public IUserPlaylist Parent
383        {
384            get { return this.factory.CreateUserPlaylist(this._asIITUserPlaylist.get_Parent()); }
385            set
386            {
387                object playlist = value.__internalObject;
388                this._asIITUserPlaylist.set_Parent(ref playlist);
389            }
390        }
391
392        public IChildPlaylistCollection Children
393        {
394            get { return new ChildPlaylistCollection(this, this.Source); }
395        }
396    }
397
398    internal class PlaylistCollection : ITBaseCollection<IPlaylist>,
399                                    ItemCreatableCollection<iTunes.IITPlaylist, IPlaylist>, IPlaylistCollection
400    {
401        private readonly IIndexedCollection<string, IPlaylist> _itemByName;
402        private readonly IIndexedCollection<long, IPlaylist> _itemByPersistentID;
403
404        protected internal PlaylistCollection(iTunes.IITPlaylistCollection _internal, ITunesApp _app)
405            : base(_internal, _app)
406        {
407            this._itemByName = new ParentStringIndexerReferrer<PlaylistCollection, IPlaylist>(this);
408            this._itemByPersistentID = new PlaylistPersistentIDIndex(this);
409        }
410
411        protected internal iTunesLib.IITPlaylistCollection _asIITPlaylistCollection
412        {
413            get { return (iTunesLib.IITPlaylistCollection)this._internal; }
414        }
415
416        public override int Count
417        {
418            get { return this._asIITPlaylistCollection.Count; }
419        }
420
421        public IPlaylist this[int Index]
422        {
423            get { return this.CreateItem(this._asIITPlaylistCollection[Index]); }
424        }
425
426        public IPlaylist this[string Name]
427        {
428            get { return this.CreateItem(this._asIITPlaylistCollection.get_ItemByName(Name)); }
429        }
430
431        public List<IPlaylist> this[string Name, int? maxCounts]
432        {
433            get
434            {
435                List<IPlaylist> playlists = new List<IPlaylist>();
436                foreach (IPlaylist playlist in this)
437                    if (playlist.Name == Name)
438                    {
439                        playlists.Add(playlist);
440                        if (maxCounts != null && --maxCounts == 0)
441                            return playlists;
442                    }
443                return playlists;
444            }
445        }
446
447        public IIndexedCollection<string, IPlaylist> ItemByName
448        {
449            get { return this._itemByName; }
450        }
451
452        public IIndexedCollection<long, IPlaylist> ItemByPersistentID
453        {
454            get { return this._itemByPersistentID; }
455        }
456
457        public IPlaylist CreateItem(iTunes.IITPlaylist item)
458        {
459            return this._app.factory.CreatePlaylist(item);
460        }
461
462        protected internal override IEnumerator<IPlaylist> _GetEnumerator()
463        {
464            return
465                new ITBaseEnumerator<iTunesLib.IITPlaylist, IPlaylist, PlaylistCollection>(
466                    this._asIITPlaylistCollection.GetEnumerator(), this);
467        }
468    }
469
470    namespace Internal
471    {
472        internal class PlaylistPersistentIDIndex : IIndexedCollection<long, IPlaylist>
473        {
474            protected internal readonly PlaylistCollection _parent;
475
476            internal PlaylistPersistentIDIndex(PlaylistCollection _parent)
477            {
478                this._parent = _parent;
479            }
480
481            public IPlaylist this[long PersistentID]
482            {
483                get
484                {
485                    PlaylistCollection collection = this._parent;
486                    int highID, lowID;
487                    Utils.SplitInt64ToInt32(PersistentID, out highID, out lowID);
488                    return collection.CreateItem(collection._asIITPlaylistCollection.get_ItemByPersistentID(highID, lowID));
489                }
490            }
491        }
492
493        internal class ChildPlaylistCollection : IChildPlaylistCollection
494        {
495            private readonly IIndexedCollection<string, IPlaylist> _itemByName;
496            private readonly List<IPlaylist> list;
497
498            public ChildPlaylistCollection(IPlaylist parent, ISource source)
499            {
500                this.list = new List<IPlaylist>();
501                IUserPlaylist userPlaylist;
502                foreach (IPlaylist playlist in source.Playlists)
503                {
504                    userPlaylist = playlist as IUserPlaylist;
505                    if (userPlaylist == null)
506                        continue;
507                    if (!userPlaylist.Parent.Equals(parent))
508                        continue;
509                    this.list.Add(userPlaylist);
510                }
511                this._itemByName = new ParentStringIndexerReferrer<ChildPlaylistCollection, IPlaylist>(this);
512            }
513
514            public int Count
515            {
516                get { return this.list.Count; }
517            }
518
519            public IPlaylist this[int Index]
520            {
521                get { return this.list[Index]; }
522            }
523
524            public IPlaylist this[string Name]
525            {
526                get
527                {
528                    List<IPlaylist> playlists = this[Name, 1];
529                    return playlists.Count == 0 ? null : playlists[0];
530                }
531            }
532
533            public List<IPlaylist> this[string Name, int? maxCounts]
534            {
535                get
536                {
537                    List<IPlaylist> playlists = new List<IPlaylist>();
538                    foreach (IPlaylist playlist in this)
539                        if (playlist.Name == Name)
540                        {
541                            playlists.Add(playlist);
542                            if (maxCounts != null && --maxCounts == 0)
543                                return playlists;
544                        }
545                    return playlists;
546                }
547            }
548
549            public IIndexedCollection<string, IPlaylist> ItemByName
550            {
551                get { return this._itemByName; }
552            }
553
554            ///<summary>
555            ///Returns an enumerator that iterates through the collection.
556            ///</summary>
557            ///
558            ///<returns>
559            ///A <see cref="T:System.Collections.Generic.IEnumerator`1"/> that can be used to iterate through the collection.
560            ///</returns>
561            ///<filterpriority>1</filterpriority>
562            IEnumerator<IPlaylist> IEnumerable<IPlaylist>.GetEnumerator()
563            {
564                return this.list.GetEnumerator();
565            }
566
567            ///<summary>
568            ///Returns an enumerator that iterates through a collection.
569            ///</summary>
570            ///
571            ///<returns>
572            ///An <see cref="T:System.Collections.IEnumerator"/> object that can be used to iterate through the collection.
573            ///</returns>
574            ///<filterpriority>2</filterpriority>
575            public IEnumerator GetEnumerator()
576            {
577                return ((IEnumerable<IPlaylist>)this).GetEnumerator();
578            }
579        }
580    }
581
582}
Note: See TracBrowser for help on using the browser.