← Back to branch summary

~ubuntu-branches/debian/jessie/banshee-community-extensions/jessie

« back to all changes in this revision

Viewing changes to src/ClutterFlow/Banshee.ClutterFlow/AlbumLoader.cs

  • Committer: Package Import Robot
  • Author(s): Chow Loong Jin
  • Date: 2011-09-20 18:45:46 UTC
  • mfrom: (1.2.9 upstream) (5.1.8 experimental)
  • Revision ID: package-import@ubuntu.com-20110920184546-3ahue2qplydc4t0e
Tags: 2.2.0-1
* [4940fab] Imported Upstream version 2.2.0
  + Notable bug fixes:
    - Karaoke: Fix crash when switching to Now Playing
    - Lyrics: Fix crash when switching to Now Playing

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/ClutterFlow/Banshee.ClutterFlow/AlbumLoader.cs
28
28
using System.Collections.Generic;
29
29
 
30
30
using Banshee.Collection;
31
 
using Banshee.Collection.Database;
32
 
using Hyena.Data;
33
31
 
34
32
using ClutterFlow;
35
33
 
36
34
namespace Banshee.ClutterFlow
37
35
{
38
 
 
39
 
        public interface ISortComparer<T> : IComparer<T>
40
 
        {
41
 
                string GetSortLabel (T obj);
42
 
        }
43
 
        
44
 
        public abstract class AlbumComparer : ISortComparer<AlbumInfo>
45
 
        {
46
 
                protected virtual string GetTitle (AlbumInfo obj)
47
 
                {
48
 
                        return (obj.TitleSort ?? obj.Title ?? obj.DisplayTitle ?? "");
49
 
                }
50
 
                
51
 
                protected virtual string GetArtist (AlbumInfo obj)
52
 
                {
53
 
                        return (obj.ArtistNameSort ?? obj.ArtistName ?? obj.DisplayArtistName ?? "");
54
 
                }
55
 
                
56
 
                public abstract int Compare (AlbumInfo x, AlbumInfo y);
57
 
                public abstract string GetSortLabel (AlbumInfo obj);
58
 
        }
59
 
        
60
 
        public class AlbumAlbumComparer : AlbumComparer
61
 
        {
62
 
                
63
 
                public override string GetSortLabel (AlbumInfo obj)
64
 
                {
65
 
                        if (obj!=null) {
66
 
                                return obj.TitleSort ?? obj.Title ?? "?";
67
 
                        } else
68
 
                                return "?";
69
 
                }
70
 
                
71
 
                public override int Compare (AlbumInfo x, AlbumInfo y)
72
 
                {
73
 
                        string tx = GetTitle(x) + GetArtist(x);
74
 
                        string ty = GetTitle(y) + GetArtist(y);
75
 
                        return tx.CompareTo(ty);
76
 
                }
77
 
        }
78
 
 
79
 
        public class AlbumArtistComparer : AlbumComparer
80
 
        {
81
 
                public override string GetSortLabel (AlbumInfo obj)
82
 
                {
83
 
                        if (obj!=null) {
84
 
                                return obj.ArtistNameSort ?? obj.ArtistName ?? "?";
85
 
                        } else
86
 
                                return "?";
87
 
                }                       
88
 
                
89
 
                public override int Compare (AlbumInfo x, AlbumInfo y)
90
 
                {
91
 
                        string tx = GetArtist(x) + GetTitle(x);
92
 
                        string ty = GetArtist(y) + GetTitle(y);
93
 
                        return tx.CompareTo(ty);
94
 
                }
95
 
        }
96
 
        
97
 
        public enum SortOptions { Artist = 0 , Album = 1 }
98
 
        
99
 
    public abstract class BansheeActorLoader<TGen> : ActorLoader<string, TGen> where TGen : ICacheableItem, new()
100
 
        {
101
 
                
102
 
                #region Fields
103
 
                #pragma warning disable 0067
104
 
                public event EventHandler SortingChanged;
105
 
                #pragma warning restore 0067
106
 
                protected void InvokeSortingChanged ()
107
 
                {
108
 
                        ClutterFlowSchemas.SortBy.Set (Enum.GetName(typeof(SortOptions), SortBy));
109
 
                        if (SortingChanged!=null) SortingChanged (this, EventArgs.Empty);
110
 
                }
111
 
 
112
 
                protected SortOptions sort_by = (SortOptions) Enum.Parse(typeof(SortOptions), ClutterFlowSchemas.SortBy.Get ());
113
 
                public virtual SortOptions SortBy {
114
 
                        get { return sort_by; }
115
 
                        set {
116
 
                                if (value!=sort_by) {
117
 
                                        sort_by = value;
118
 
                                        RefreshCoverManager ();
119
 
                                        InvokeSortingChanged ();
120
 
                                }
121
 
                        }
122
 
                }
123
 
                
124
 
                protected abstract ISortComparer<TGen> Comparer { get; }
125
 
                
126
 
        private int count; //previous model count
127
 
                
128
 
                protected List<int> index_map; //maps list indeces to model indeces
129
 
 
130
 
        private FilterListModel<TGen> model;
131
 
        public virtual FilterListModel<TGen> Model {
132
 
            get { return model; }
133
 
            set {
134
 
                if (value!=model) {
135
 
                    if (model != null) {
136
 
                        model.Cleared -= OnModelClearedHandler;
137
 
                        model.Reloaded -= OnModelReloadedHandler;
138
 
                    }
139
 
 
140
 
                    model = value;
141
 
 
142
 
                    if (model != null) {
143
 
                        model.Cleared += OnModelClearedHandler;
144
 
                        model.Reloaded += OnModelReloadedHandler;
145
 
                        count = model.Count;
146
 
                    }
147
 
                    RefreshCoverManager ();
148
 
                }
149
 
            }
150
 
        }
151
 
                #endregion
152
 
                
153
 
        public BansheeActorLoader (CoverManager coverManager) : base (coverManager) { }
154
 
        public override void Dispose ()
155
 
        {
156
 
            Model = null;
157
 
            base.Dispose ();
158
 
        }
159
 
                
160
 
        public override List<ClutterFlowBaseActor> GetActors (System.Action<ClutterFlowBaseActor> method_call)
161
 
        {
162
 
            SortedList<TGen, ClutterFlowBaseActor> list =
163
 
                                new SortedList<TGen, ClutterFlowBaseActor>(Comparer);
164
 
            if (Model!=null) {
165
 
                                for (int i = 1; i < Model.Count; i++)
166
 
                        AddActorToList(Model[i], list);
167
 
                                index_map = new List<int>(list.Values.Count);
168
 
                                for (int i = 0; i < list.Values.Count; i++) {
169
 
                                        ClutterFlowBaseActor actor = list.Values[i];
170
 
                                        index_map.Add(actor.Index);
171
 
                        actor.Index = i;
172
 
                                        if (method_call!=null) method_call(actor);
173
 
                                }
174
 
                        }
175
 
            return new List<ClutterFlowBaseActor>(list.Values);
176
 
        }
177
 
                
178
 
                public virtual int ConvertIndexToModelIndex (int index)
179
 
                {
180
 
                        return (index_map!=null && index_map.Count > index) ? index_map[index] : 0;
181
 
                }
182
 
 
183
 
        #region Event Handlers
184
 
        protected void OnModelClearedHandler (object o, EventArgs args)
185
 
        {
186
 
            RefreshCoverManager ();
187
 
        }
188
 
 
189
 
        protected void OnModelReloadedHandler (object o, EventArgs args)
190
 
        {
191
 
            if (count!=model.Count) {
192
 
                count=model.Count;
193
 
                RefreshCoverManager ();
194
 
            }
195
 
        }
196
 
        #endregion
197
 
    }
198
 
 
199
 
    public class AlbumLoader : BansheeActorLoader<AlbumInfo>
 
36
    public class AlbumLoader : IActorLoader
200
37
    {
201
 
 
202
 
                #region Events
203
 
                public event ActorEventHandler<ClutterFlowAlbum> ActorActivated;
204
 
                protected void InvokeActorActivated (ClutterFlowAlbum actor) {
205
 
                        if (ActorActivated!=null) ActorActivated (actor, EventArgs.Empty);
206
 
                }
207
 
                #endregion
208
 
                
 
38
        #region Events
 
39
        public event EventHandler SortingChanged;
 
40
 
 
41
        protected void OnSortingChanged ()
 
42
        {
 
43
            var handler = SortingChanged;
 
44
            if (handler != null) {
 
45
                handler (this, EventArgs.Empty);
 
46
            }
 
47
        }
 
48
        #endregion
 
49
 
209
50
        #region Fields
210
 
                protected static ISortComparer<AlbumInfo> sort_by_name = new AlbumAlbumComparer ();
211
 
                protected static ISortComparer<AlbumInfo> sort_by_arst = new AlbumArtistComparer ();
212
 
                
213
 
                protected override ISortComparer<AlbumInfo> Comparer {
214
 
                        get {
215
 
                                switch (SortBy) {
216
 
                                case SortOptions.Album:
217
 
                                        return sort_by_name;
218
 
                                case SortOptions.Artist:
219
 
                                        return sort_by_arst;
220
 
                                default:
221
 
                                        return sort_by_name;
222
 
                                }
223
 
                        }
224
 
                }
225
 
                
226
 
                public ClutterFlowAlbum CurrentActor {
227
 
                        get { return (ClutterFlowAlbum) CoverManager.CurrentCover; }
228
 
                }
229
 
                
230
 
        public AlbumInfo CurrentAlbum {
231
 
            get {
232
 
                if (CoverManager.CurrentCover!=null && CoverManager.CurrentCover is ClutterFlowAlbum)
233
 
                    return (CoverManager.CurrentCover as ClutterFlowAlbum).Album;
234
 
                else
235
 
                    return null;
236
 
            }
237
 
        }
238
 
        public int CurrentIndex {
239
 
            get {
240
 
                if (CoverManager.CurrentCover!=null && CoverManager.CurrentCover is ClutterFlowAlbum)
241
 
                    return (CoverManager.CurrentCover as ClutterFlowAlbum).Index;
242
 
                else
243
 
                    return -1;
244
 
            }
 
51
        private Dictionary<string, ClutterFlowBaseActor> cached_covers = new Dictionary<string, ClutterFlowBaseActor> ();
 
52
        public Dictionary<string, ClutterFlowBaseActor> Cache {
 
53
            get { return cached_covers; }
 
54
        }
 
55
 
 
56
        protected static ISortComparer<AlbumInfo> sort_by_name = new AlbumAlbumComparer ();
 
57
        protected static ISortComparer<AlbumInfo> sort_by_artist = new AlbumArtistComparer ();
 
58
 
 
59
        protected ISortComparer<AlbumInfo> Comparer {
 
60
            get {
 
61
                switch (SortBy) {
 
62
                case SortOptions.Album:
 
63
                    return sort_by_name;
 
64
                case SortOptions.Artist:
 
65
                    return sort_by_artist;
 
66
                default:
 
67
                    return sort_by_name;
 
68
                }
 
69
            }
 
70
        }
 
71
 
 
72
        private SortOptions sort_by = (SortOptions) Enum.Parse(typeof(SortOptions), ClutterFlowSchemas.SortBy.Get ());
 
73
        public SortOptions SortBy {
 
74
            get { return sort_by; }
 
75
            set {
 
76
                if (value != sort_by) {
 
77
                    sort_by = value;
 
78
                    ClutterFlowSchemas.SortBy.Set (Enum.GetName(typeof(SortOptions), SortBy));
 
79
                    OnSortingChanged ();
 
80
                }
 
81
            }
 
82
        }
 
83
 
 
84
        //maps list indices to model indices
 
85
        private List<int> index_map;
 
86
 
 
87
        private FilterListModel<AlbumInfo> model;
 
88
        public FilterListModel<AlbumInfo> Model {
 
89
            get { return model; }
 
90
            set { model = value; }
245
91
        }
246
92
        #endregion
247
93
 
248
 
        public AlbumLoader (CoverManager coverManager) : base (coverManager)
249
 
        {
250
 
        }
251
 
 
252
 
        public virtual void ScrollTo (AlbumInfo generator)
253
 
        {
254
 
            CoverManager.Timeline.Timeout = 500; //give 'm some time to load the song etc.
255
 
            ScrollTo (ClutterFlowAlbum.CreateCacheKey (generator));
256
 
        }
257
 
                
258
 
        protected override ClutterFlowBaseActor AddActorToList (AlbumInfo generator, SortedList<AlbumInfo, ClutterFlowBaseActor> list)
259
 
        {
260
 
            if (generator == null)
 
94
        public AlbumLoader ()
 
95
        { }
 
96
 
 
97
        protected bool disposed = false;
 
98
        public void Dispose ()
 
99
        {
 
100
            if (disposed) {
 
101
                return;
 
102
            }
 
103
            disposed = true;
 
104
 
 
105
            foreach (ClutterFlowBaseActor actor in cached_covers.Values) {
 
106
                actor.Dispose ();
 
107
            }
 
108
            cached_covers.Clear ();
 
109
        }
 
110
 
 
111
        private ClutterFlowBaseActor AddActorToList (AlbumInfo generator, SortedList<AlbumInfo, ClutterFlowBaseActor> list, CoverManager cover_manager)
 
112
        {
 
113
            if (generator == null) {
261
114
                generator = new AlbumInfo (AlbumInfo.UnknownAlbumTitle);
 
115
            }
262
116
            string key = ClutterFlowAlbum.CreateCacheKey(generator);
263
 
            ClutterFlowBaseActor actor = Cache.ContainsKey (key) ? Cache[key] : null;
264
 
            if (actor==null) {
265
 
                actor = new ClutterFlowAlbum (generator, CoverManager);
266
 
                                actor.Hide ();
 
117
            ClutterFlowBaseActor actor = null;
 
118
            if (!Cache.TryGetValue (key, out actor)) {
 
119
                actor = new ClutterFlowAlbum (generator, cover_manager);
 
120
                actor.Hide ();
267
121
                Cache.Add (key, actor);
268
122
            }
269
 
                        actor.SortLabel = Comparer.GetSortLabel(generator);
 
123
            actor.SortLabel = Comparer.GetSortLabel (generator);
270
124
            list[generator] = actor;
271
 
                        actor.Index = list.Count;
 
125
            actor.Index = list.Count;
272
126
            return actor;
273
127
        }
274
 
                
275
 
                public override void HandleActorActivated (ClutterFlowBaseActor actor, EventArgs args)
276
 
                {
277
 
                        if (actor is ClutterFlowAlbum)
278
 
                                InvokeActorActivated (actor as ClutterFlowAlbum);
279
 
                }
 
128
 
 
129
        public List<ClutterFlowBaseActor> GetActors (CoverManager cover_manager)
 
130
        {
 
131
            SortedList<AlbumInfo, ClutterFlowBaseActor> list =
 
132
                new SortedList<AlbumInfo, ClutterFlowBaseActor>(Comparer);
 
133
            if (Model != null) {
 
134
                for (int i = 1; i < Model.Count; i++) {
 
135
                    AddActorToList(Model[i], list, cover_manager);
 
136
                }
 
137
                index_map = new List<int>(list.Values.Count);
 
138
                for (int i = 0; i < list.Values.Count; i++) {
 
139
                    ClutterFlowBaseActor actor = list.Values[i];
 
140
                    index_map.Add(actor.Index);
 
141
                    actor.Index = i;
 
142
                }
 
143
            }
 
144
            return new List<ClutterFlowBaseActor>(list.Values);
 
145
        }
 
146
 
 
147
        public int ConvertIndexToModelIndex (int index)
 
148
        {
 
149
            return (index_map != null && index_map.Count > index) ? index_map[index] : 0;
 
150
        }
280
151
    }
281
152
}