← 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/ClutterFlowContents.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/ClutterFlowContents.cs
55
55
 
56
56
    public class ClutterFlowContents : VBox, ISourceContents, ITrackModelSourceContents
57
57
    {
58
 
                #region Fields
59
 
 
60
 
                //WIDGETS:
61
 
                private Paned container;
62
 
                public Paned Container {
63
 
                        get { return container; }
64
 
                }
65
 
 
66
 
                private Hyena.Widgets.RoundedFrame frame;
67
 
                private ClutterFlowView filter_view;
68
 
                public ClutterFlowView FilterView {
69
 
                        get { return filter_view; }
70
 
                }
71
 
 
72
 
                private Gtk.Expander main_expander;
73
 
                private TrackListView main_view;
 
58
        #region Fields
 
59
 
 
60
        //WIDGETS:
 
61
        private Paned container;
 
62
        public Paned Container {
 
63
            get { return container; }
 
64
        }
 
65
 
 
66
        private Hyena.Widgets.RoundedFrame frame;
 
67
        private ClutterFlowView filter_view;
 
68
        public ClutterFlowView FilterView {
 
69
            get { return filter_view; }
 
70
        }
 
71
 
 
72
        private Gtk.Expander main_expander;
 
73
        private TrackListView main_view;
74
74
        public TrackListView TrackView {
75
75
            get { return main_view; }
76
76
        }
77
 
                IListView<TrackInfo> ITrackModelSourceContents.TrackView {
 
77
        IListView<TrackInfo> ITrackModelSourceContents.TrackView {
78
78
            get { return TrackView; }
79
79
        }
80
80
 
82
82
            get { return this; }
83
83
        }
84
84
 
85
 
                //FULLSCREEN HANDLING:
 
85
        //FULLSCREEN HANDLING:
86
86
        private Gtk.Window video_window;
87
87
        private FullscreenAdapter fullscreen_adapter;
88
88
        private ScreensaverManager screensaver;
89
 
                
90
 
                protected bool is_fullscreen = false;
91
 
                public bool IsFullscreen {
92
 
                        get { return is_fullscreen; }
93
 
                }               
94
 
                
95
 
                //SOURCE, TRACKMODEL & (ALBUM) FILTERS:
 
89
 
 
90
        protected bool is_fullscreen = false;
 
91
        public bool IsFullscreen {
 
92
            get { return is_fullscreen; }
 
93
        }
 
94
 
 
95
        //SOURCE, TRACKMODEL & (ALBUM) FILTERS:
96
96
        protected MusicLibrarySource source;
97
97
        public ISource Source {
98
98
            get { return source; }
104
104
 
105
105
        protected FilterListModel<AlbumInfo> external_filter; //this is actually fetched from the MusicLibrary
106
106
 
107
 
                //PLAYBACK RELATED:
108
 
                private TrackInfo transitioned_track;
 
107
        //PLAYBACK RELATED:
 
108
        private TrackInfo transitioned_track;
109
109
 
110
110
        private bool IsParentSource {
111
111
            get { return ServiceManager.PlaybackController.Source!=null && ServiceManager.PlaybackController.Source.Parent==source; }
112
112
        }
113
 
                private bool IsActiveSource {
114
 
                        get { return ServiceManager.SourceManager.ActiveSource==source; }
115
 
                }
116
 
                private bool IsPlaybackSource {
117
 
                        get { return ServiceManager.PlaybackController.Source==source; }
118
 
                }
119
 
                private bool InPartyMode {
120
 
                        get {
121
 
                                return (external_filter!=null && (IsPlaybackSource || IsParentSource) && IsActiveSource && external_filter.Selection.AllSelected);
122
 
                        }
123
 
                }
124
 
 
125
 
                //GENERIC:
126
 
                private string name;
127
 
                #endregion
128
 
                
129
 
                #region Initialising
 
113
        private bool IsActiveSource {
 
114
            get { return ServiceManager.SourceManager.ActiveSource==source; }
 
115
        }
 
116
        private bool IsPlaybackSource {
 
117
            get { return ServiceManager.PlaybackController.Source==source; }
 
118
        }
 
119
        private bool InPartyMode {
 
120
            get {
 
121
                return (external_filter!=null && (IsPlaybackSource || IsParentSource) && IsActiveSource && external_filter.Selection.AllSelected);
 
122
            }
 
123
        }
 
124
 
 
125
        //GENERIC:
 
126
        private string name;
 
127
        #endregion
 
128
 
 
129
        #region Initialising
130
130
        public ClutterFlowContents ()
131
131
        {
132
 
                        name = "ClutterFlowView";
133
 
            InitializeInterface ();             
134
 
                        Layout ();
135
 
                        SetupFullscreenHandling ();
136
 
                        SetupPlaybackHandling ();
 
132
            name = "ClutterFlowView";
 
133
            InitializeInterface ();
 
134
            Layout ();
 
135
            SetupFullscreenHandling ();
 
136
            SetupPlaybackHandling ();
137
137
            NoShowAll = true;
138
138
        }
139
139
 
140
140
        protected bool disposed = false;
141
141
        public override void Dispose ()
142
142
        {
143
 
            if (disposed)
 
143
            if (disposed) {
144
144
                return;
 
145
            }
145
146
            disposed = true;
146
147
 
147
148
            ResetSource ();
148
149
 
149
150
            video_window.Hidden -= OnFullscreenWindowHidden;
150
 
            FilterView.UpdatedAlbum -= HandleUpdatedAlbum;
151
 
            FilterView.PMButton.Toggled -= HandlePMButtonToggled;
152
 
            FilterView.FSButton.Toggled -= HandleFSButtonToggled;
 
151
            filter_view.UpdatedAlbum -= HandleUpdatedAlbum;
 
152
            filter_view.PMButton.Toggled -= HandlePMButtonToggled;
 
153
            filter_view.FSButton.Toggled -= HandleFSButtonToggled;
 
154
            filter_view.SortButton.Toggled -= HandleSortButtonToggled;
 
155
 
 
156
            FilterView.AlbumLoader.SortingChanged -= HandleSortingChanged;
153
157
 
154
158
            ServiceManager.SourceManager.ActiveSourceChanged -= HandleActiveSourceChanged;
155
159
            ServiceManager.PlaybackController.TrackStarted -= OnPlaybackControllerTrackStarted;
156
160
            ServiceManager.PlaybackController.SourceChanged -= OnPlaybackSourceChanged;
157
 
                        ServiceManager.PlayerEngine.DisconnectEvent (OnPlayerEvent);
 
161
            ServiceManager.PlayerEngine.DisconnectEvent (OnPlayerEvent);
158
162
 
159
163
            Reset ();
160
 
            if (filter_view.Parent!=null) frame.Remove (filter_view);
161
 
            filter_view.DetachEvents ();
 
164
            if (filter_view.Parent != null) {
 
165
                frame.Remove (filter_view);
 
166
            }
 
167
            filter_view.Dispose ();
162
168
 
163
169
            fullscreen_adapter.Dispose ();
164
170
            screensaver.Dispose ();
165
171
 
166
172
            base.Dispose ();
167
173
        }
168
 
                #endregion
 
174
        #endregion
169
175
 
170
 
                #region Packing & Resetting
 
176
        #region Packing & Resetting
171
177
        private void Layout ()
172
178
        {
173
179
            Reset ();
177
183
            frame = new Hyena.Widgets.RoundedFrame ();
178
184
            frame.SetFillColor (new Cairo.Color (0, 0, 0));
179
185
            frame.DrawBorder = false;
180
 
                        frame.Add (filter_view);
181
 
                        filter_view.Show();
 
186
            frame.Add (filter_view);
 
187
            filter_view.Show();
182
188
            frame.Show ();
183
189
 
184
 
                        container.Pack1 (frame, false, false);
 
190
            container.Pack1 (frame, false, false);
185
191
            main_expander.Activated += OnExpander;
186
192
            main_expander.SizeRequested += HandleSizeRequested;
187
193
            container.Pack2 (main_expander, true, false);
188
194
 
189
195
            container.Position = 175;
190
196
            PersistentPaneController.Control (container, ControllerName (-1));
191
 
                        
 
197
 
192
198
            ShowPack ();
193
199
        }
194
 
                
 
200
 
195
201
        private string ControllerName (int filter)
196
202
        {
197
203
            if (filter == -1)
212
218
        {
213
219
            // The main container gets destroyed since it will be recreated.
214
220
            if (container != null) {
215
 
                                if (frame != null) container.Remove (frame);
216
 
                                if (main_expander != null) container.Remove (main_expander);
 
221
                if (frame != null) container.Remove (frame);
 
222
                if (main_expander != null) container.Remove (main_expander);
217
223
                main_expander.Activated -= OnExpander;
218
224
                main_expander.SizeRequested -= HandleSizeRequested;
219
225
                Remove (container);
220
226
            }
221
227
        }
222
 
                #endregion
223
 
                
224
 
                #region View Setup
225
 
                
 
228
        #endregion
 
229
 
 
230
        #region View Setup
 
231
 
226
232
        protected void InitializeInterface ()
227
233
        {
228
234
            SetupMainView ();
229
 
                        SetupFilterView ();
 
235
            SetupFilterView ();
230
236
        }
231
237
 
232
238
        protected void SetupMainView ()
238
244
        }
239
245
 
240
246
        protected void SetupFilterView ()
241
 
        {               
242
 
                        filter_view = ClutterFlowManager.FilterView;
243
 
                        filter_view.FSButton.IsActive = IsFullscreen;
244
 
                        filter_view.PMButton.IsActive = InPartyMode;
245
 
                        filter_view.LabelTrackIsVisible = ClutterFlowSchemas.DisplayTitle.Get () && IsFullscreen;
246
 
                        filter_view.SortButton.IsActive = (ClutterFlowSchemas.SortBy.Get () != ClutterFlowSchemas.SortBy.DefaultValue);
 
247
        {
 
248
            filter_view = new ClutterFlowView ();
 
249
            filter_view.FSButton.IsActive = IsFullscreen;
 
250
            filter_view.PMButton.IsActive = InPartyMode;
 
251
            filter_view.LabelTrackIsVisible = ClutterFlowSchemas.DisplayTitle.Get () && IsFullscreen;
 
252
            filter_view.SortButton.IsActive = (ClutterFlowSchemas.SortBy.Get () != ClutterFlowSchemas.SortBy.DefaultValue);
247
253
        }
248
 
                
 
254
 
249
255
        private Expander CreateScrollableExpander (Widget view)
250
256
        {
251
257
            ScrolledWindow window = null;
278
284
            if (!main_expander.Expanded)
279
285
                container.Position = container.Allocation.Height - main_expander.LabelWidget.HeightRequest;
280
286
        }
281
 
                #endregion
282
 
 
283
 
                #region Fullscreen Handling
284
 
 
285
 
                protected void SetupFullscreenHandling ()
286
 
                {
287
 
                        GtkElementsService service = ServiceManager.Get<GtkElementsService> ();
288
 
                        
 
287
        #endregion
 
288
 
 
289
        #region Fullscreen Handling
 
290
 
 
291
        protected void SetupFullscreenHandling ()
 
292
        {
 
293
            GtkElementsService service = ServiceManager.Get<GtkElementsService> ();
 
294
 
289
295
            fullscreen_adapter = new FullscreenAdapter ();
290
296
            screensaver = new ScreensaverManager ();
291
 
                        
 
297
 
292
298
            video_window = new FullscreenWindow (service.PrimaryWindow);
293
299
            video_window.Hidden += OnFullscreenWindowHidden;
294
300
            video_window.Realize ();
295
 
                }
296
 
                
297
 
                protected override void OnMapped ()
298
 
                {
299
 
                        OverrideFullscreen ();
300
 
                        base.OnMapped ();
301
 
                }
302
 
 
303
 
                protected override void OnUnmapped ()
304
 
                {
305
 
                        RelinquishFullscreen ();
306
 
                        base.OnUnmapped ();
307
 
                }
 
301
        }
 
302
 
 
303
        protected override void OnMapped ()
 
304
        {
 
305
            OverrideFullscreen ();
 
306
            base.OnMapped ();
 
307
        }
 
308
 
 
309
        protected override void OnUnmapped ()
 
310
        {
 
311
            RelinquishFullscreen ();
 
312
            base.OnUnmapped ();
 
313
        }
308
314
 
309
315
#region Video Fullscreen Override
310
316
 
311
317
        private ViewActions.FullscreenHandler previous_fullscreen_handler;
312
 
                
 
318
 
313
319
        private void DisableFullscreenAction ()
314
320
        {
315
321
            InterfaceActionService service = ServiceManager.Get<InterfaceActionService> ();
344
350
 
345
351
            service.ViewActions.Fullscreen = previous_fullscreen_handler;
346
352
        }
347
 
        
 
353
 
348
354
        private void OnFullscreenWindowHidden (object o, EventArgs args)
349
355
        {
350
356
            MoveVideoInternal ();
351
357
            DisableFullscreenAction ();
352
358
        }
353
359
 
354
 
                private bool handlingFullScreen = false;
 
360
        private bool handlingFullScreen = false;
355
361
        private void FullscreenHandler (bool fullscreen)
356
362
        {
357
 
                        if (!handlingFullScreen) {
358
 
                                handlingFullScreen = true;
359
 
                                FilterView.FSButton.IsActive = fullscreen;
360
 
                                FilterView.LabelTrackIsVisible = ClutterFlowSchemas.DisplayTitle.Get () && fullscreen;
361
 
                    if (fullscreen) {
362
 
                        MoveVideoExternal (true);
363
 
                        video_window.Show ();
364
 
                        fullscreen_adapter.Fullscreen (video_window, true);
365
 
                        screensaver.Inhibit ();
366
 
                    } else {
367
 
                        video_window.Hide ();
368
 
                        screensaver.UnInhibit ();
369
 
                        fullscreen_adapter.Fullscreen (video_window, false);
370
 
                        video_window.Hide ();
371
 
                    }
372
 
                                handlingFullScreen = false;
373
 
                        }
 
363
            if (!handlingFullScreen) {
 
364
                handlingFullScreen = true;
 
365
                FilterView.FSButton.IsActive = fullscreen;
 
366
                FilterView.LabelTrackIsVisible = ClutterFlowSchemas.DisplayTitle.Get () && fullscreen;
 
367
                if (fullscreen) {
 
368
                    MoveVideoExternal (true);
 
369
                    video_window.Show ();
 
370
                    fullscreen_adapter.Fullscreen (video_window, true);
 
371
                    screensaver.Inhibit ();
 
372
                } else {
 
373
                    video_window.Hide ();
 
374
                    screensaver.UnInhibit ();
 
375
                    fullscreen_adapter.Fullscreen (video_window, false);
 
376
                    video_window.Hide ();
 
377
                }
 
378
                handlingFullScreen = false;
 
379
            }
374
380
        }
375
381
 
376
382
#endregion
381
387
                filter_view.Reparent (video_window);
382
388
                filter_view.Show ();
383
389
            }
384
 
                        is_fullscreen = true;
385
 
                        if (hidden)
386
 
                                video_window.Hide();
387
 
                        else
388
 
                                video_window.Show();
 
390
            is_fullscreen = true;
 
391
            if (hidden)
 
392
                video_window.Hide();
 
393
            else
 
394
                video_window.Show();
389
395
        }
390
396
 
391
397
        private void MoveVideoInternal ()
392
398
        {
393
399
            if (filter_view.Parent != frame) {
394
 
                                if (filter_view.Parent != null)
395
 
                                        (filter_view.Parent as Container).Remove (filter_view);
396
 
                                frame.Add (filter_view);
397
 
                                frame.QueueDraw ();
398
 
                        }
399
 
                        is_fullscreen = false;
400
 
                        ShowPack ();
401
 
                        
 
400
                if (filter_view.Parent != null)
 
401
                    (filter_view.Parent as Container).Remove (filter_view);
 
402
                frame.Add (filter_view);
 
403
                frame.QueueDraw ();
 
404
            }
 
405
            is_fullscreen = false;
 
406
            ShowPack ();
 
407
 
402
408
        }
403
 
                #endregion
404
 
 
405
 
                #region Playback Handling
406
 
                
407
 
                private void SetupPlaybackHandling ()
408
 
                {
409
 
                        FilterView.UpdatedAlbum += HandleUpdatedAlbum;
410
 
                        FilterView.PMButton.Toggled += HandlePMButtonToggled;
411
 
                        FilterView.FSButton.Toggled += HandleFSButtonToggled;
412
 
                        FilterView.SortButton.Toggled += HandleSortButtonToggled;
413
 
 
414
 
                        ServiceManager.SourceManager.ActiveSourceChanged += HandleActiveSourceChanged;                  
 
409
        #endregion
 
410
 
 
411
        #region Playback Handling
 
412
 
 
413
        private void SetupPlaybackHandling ()
 
414
        {
 
415
            filter_view.UpdatedAlbum += HandleUpdatedAlbum;
 
416
            filter_view.PMButton.Toggled += HandlePMButtonToggled;
 
417
            filter_view.FSButton.Toggled += HandleFSButtonToggled;
 
418
            filter_view.SortButton.Toggled += HandleSortButtonToggled;
 
419
 
 
420
            ServiceManager.SourceManager.ActiveSourceChanged += HandleActiveSourceChanged;
415
421
            ServiceManager.PlaybackController.TrackStarted += OnPlaybackControllerTrackStarted;
416
 
                        ServiceManager.PlayerEngine.ConnectEvent (OnPlayerEvent);
417
 
                        ServiceManager.PlaybackController.SourceChanged += OnPlaybackSourceChanged;
418
 
                        FilterView.AlbumLoader.SortingChanged += HandleSortingChanged;
419
 
                }
420
 
                
421
 
                private void HandleUpdatedAlbum(object sender, EventArgs e)
422
 
                {
423
 
                        if (!IsActiveSource) ServiceManager.SourceManager.SetActiveSource (source);
424
 
                        SelectActiveAlbum ();
425
 
                        UpdatePlayback ();
426
 
                        FilterView.PMButton.SetSilent (InPartyMode);
427
 
                }
428
 
 
429
 
                private void HandlePMButtonToggled(object sender, EventArgs e)
430
 
                {
431
 
                        if (!IsActiveSource) ServiceManager.SourceManager.SetActiveSource (source);
432
 
                        if (FilterView.PMButton.IsActive) {
433
 
                                SelectAllTracks ();
434
 
                                UpdatePlayback ();
435
 
                        } else
436
 
                                FilterView.UpdateAlbum ();
437
 
                }
438
 
 
439
 
                private void HandleFSButtonToggled(object sender, EventArgs e)
440
 
                {
 
422
            ServiceManager.PlayerEngine.ConnectEvent (OnPlayerEvent);
 
423
            ServiceManager.PlaybackController.SourceChanged += OnPlaybackSourceChanged;
 
424
            FilterView.AlbumLoader.SortingChanged += HandleSortingChanged;
 
425
        }
 
426
 
 
427
        private void HandleUpdatedAlbum(object sender, EventArgs e)
 
428
        {
 
429
            if (!IsActiveSource) {
 
430
                ServiceManager.SourceManager.SetActiveSource (source);
 
431
            }
 
432
            SelectActiveAlbum ();
 
433
            UpdatePlayback ();
 
434
            FilterView.PMButton.SetSilent (InPartyMode);
 
435
        }
 
436
 
 
437
        private void HandlePMButtonToggled(object sender, EventArgs e)
 
438
        {
 
439
            if (!IsActiveSource) {
 
440
                ServiceManager.SourceManager.SetActiveSource (source);
 
441
            }
 
442
            if (FilterView.PMButton.IsActive) {
 
443
                SelectAllTracks ();
 
444
                UpdatePlayback ();
 
445
            } else {
 
446
                FilterView.UpdateAlbum ();
 
447
            }
 
448
        }
 
449
 
 
450
        private void HandleFSButtonToggled(object sender, EventArgs e)
 
451
        {
441
452
            InterfaceActionService service = ServiceManager.Get<InterfaceActionService> ();
442
 
            if (service == null || service.ViewActions == null)
 
453
            if (service == null || service.ViewActions == null) {
443
454
                return;
444
 
                        service.ViewActions.Fullscreen (FilterView.FSButton.IsActive);
445
 
                }
446
 
                
447
 
 
448
 
                private void HandleSortButtonToggled (object sender, EventArgs e)
449
 
                {
450
 
                        if (!FilterView.SortButton.IsActive)
451
 
                                FilterView.AlbumLoader.SortBy = SortOptions.Artist;
452
 
                        else
453
 
                                FilterView.AlbumLoader.SortBy = SortOptions.Album;
454
 
                }       
455
 
                
456
 
 
457
 
                private void HandleSortingChanged (object sender, EventArgs e)
458
 
                {
459
 
                        if (FilterView.AlbumLoader.SortBy.GetType () == typeof(AlbumArtistComparer))
460
 
                                FilterView.SortButton.IsActive = false;
461
 
                        else
462
 
                                FilterView.SortButton.IsActive = true;
463
 
                }               
464
 
                
465
 
                private void HandleActiveSourceChanged (SourceEventArgs args)
466
 
                {
467
 
                        FilterView.PMButton.SetSilent (InPartyMode);
468
 
                }       
469
 
                private void OnPlayerEvent (PlayerEventArgs args)
470
 
                {
471
 
                        CheckForSwitch ();
472
 
                }               
 
455
            }
 
456
            service.ViewActions.Fullscreen (FilterView.FSButton.IsActive);
 
457
        }
 
458
 
 
459
 
 
460
        private void HandleSortButtonToggled (object sender, EventArgs e)
 
461
        {
 
462
            if (!FilterView.SortButton.IsActive) {
 
463
                FilterView.AlbumLoader.SortBy = SortOptions.Artist;
 
464
            } else {
 
465
                FilterView.AlbumLoader.SortBy = SortOptions.Album;
 
466
            }
 
467
        }
 
468
 
 
469
 
 
470
        private void HandleSortingChanged (object sender, EventArgs e)
 
471
        {
 
472
            FilterView.CoverManager.ReloadCovers ();
 
473
 
 
474
            if (FilterView.AlbumLoader.SortBy.GetType () == typeof(AlbumArtistComparer)) {
 
475
                FilterView.SortButton.IsActive = false;
 
476
            } else {
 
477
                FilterView.SortButton.IsActive = true;
 
478
            }
 
479
        }
 
480
 
 
481
        private void HandleActiveSourceChanged (SourceEventArgs args)
 
482
        {
 
483
            FilterView.PMButton.SetSilent (InPartyMode);
 
484
        }
 
485
        private void OnPlayerEvent (PlayerEventArgs args)
 
486
        {
 
487
            CheckForSwitch ();
 
488
        }
473
489
        private void OnPlaybackControllerTrackStarted (object o, EventArgs args)
474
 
        {               
 
490
        {
475
491
            CheckForSwitch ();
476
 
        }               
 
492
        }
477
493
        private void OnPlaybackSourceChanged (object o, EventArgs args)
478
494
        {
479
 
                        FilterView.PMButton.SetSilent (InPartyMode);
 
495
            FilterView.PMButton.SetSilent (InPartyMode);
480
496
        }
481
 
                
482
 
                /// <summary>
483
 
                /// Checks if we are in PartyMode & if a new song started playing
484
 
                /// Called from OnPlaybackControllerTrackStarted
485
 
                /// </summary>
 
497
 
 
498
        /// <summary>
 
499
        /// Checks if we are in PartyMode & if a new song started playing
 
500
        /// Called from OnPlaybackControllerTrackStarted
 
501
        /// </summary>
486
502
        private void CheckForSwitch ()
487
503
        {
488
 
                        ThreadAssist.ProxyToMain (delegate {
489
 
                    TrackInfo current_track = ServiceManager.PlaybackController.CurrentTrack;
490
 
                    if (current_track != null && transitioned_track != current_track) {
491
 
                                        if (IsActiveSource)
492
 
                                                FilterView.LabelTrack.SetValueWithAnim (current_track.TrackNumber + " - " + current_track.TrackTitle);
493
 
                                        if (InPartyMode) {
494
 
                                                DatabaseAlbumInfo album = DatabaseAlbumInfo.FindOrCreate (
495
 
                                                                DatabaseArtistInfo.FindOrCreate (current_track.AlbumArtist, current_track.AlbumArtistSort),
496
 
                                                                current_track.AlbumTitle, current_track.AlbumTitleSort, current_track.IsCompilation);
497
 
                                                FilterView.AlbumLoader.ScrollTo(album);
498
 
                                        }
499
 
                                        transitioned_track = ServiceManager.PlayerEngine.CurrentTrack;
500
 
                                }
501
 
                                
502
 
                        });
503
 
        }
504
 
                
505
 
                private void UpdatePlayback ()
506
 
                {
507
 
                        if (!ClutterFlowSchemas.InstantPlayback.Get ()) {
508
 
                                ServiceManager.PlaybackController.NextSource = source;
509
 
                                if (!ServiceManager.PlayerEngine.IsPlaying())
510
 
                                        ServiceManager.PlayerEngine.Play();
511
 
                        } else {
512
 
                                ServiceManager.PlaybackController.Source = source;
513
 
                                if (!ServiceManager.PlayerEngine.IsPlaying())
514
 
                                        ServiceManager.PlayerEngine.Play();
515
 
                                else
516
 
                                        ServiceManager.PlaybackController.Next();
517
 
                        }
518
 
                }
519
 
                #endregion
520
 
 
521
 
                #region Source Handling         
 
504
            ThreadAssist.ProxyToMain (delegate {
 
505
                TrackInfo current_track = ServiceManager.PlaybackController.CurrentTrack;
 
506
                if (current_track != null && transitioned_track != current_track) {
 
507
                    if (IsActiveSource)
 
508
                        FilterView.LabelTrack.SetValueWithAnim (current_track.TrackNumber + " - " + current_track.TrackTitle);
 
509
                    if (InPartyMode) {
 
510
                        DatabaseAlbumInfo album = DatabaseAlbumInfo.FindOrCreate (
 
511
                                DatabaseArtistInfo.FindOrCreate (current_track.AlbumArtist, current_track.AlbumArtistSort),
 
512
                                current_track.AlbumTitle, current_track.AlbumTitleSort, current_track.IsCompilation);
 
513
                        FilterView.ScrollTo (album);
 
514
                    }
 
515
                    transitioned_track = ServiceManager.PlayerEngine.CurrentTrack;
 
516
                }
 
517
 
 
518
            });
 
519
        }
 
520
 
 
521
        private void UpdatePlayback ()
 
522
        {
 
523
            if (!ClutterFlowSchemas.InstantPlayback.Get ()) {
 
524
                ServiceManager.PlaybackController.NextSource = source;
 
525
                if (!ServiceManager.PlayerEngine.IsPlaying()) {
 
526
                    ServiceManager.PlayerEngine.Play();
 
527
                }
 
528
            } else {
 
529
                ServiceManager.PlaybackController.Source = source;
 
530
                if (!ServiceManager.PlayerEngine.IsPlaying()) {
 
531
                    ServiceManager.PlayerEngine.Play();
 
532
                } else {
 
533
                    ServiceManager.PlaybackController.Next();
 
534
                }
 
535
            }
 
536
        }
 
537
        #endregion
 
538
 
 
539
        #region Source Handling
522
540
        public bool SetSource (ISource source)
523
541
        {
524
 
                        if ((source as MusicLibrarySource) == null)
525
 
                                return false;
526
 
                        if ((source as MusicLibrarySource)==this.source) {
 
542
            if ((source as MusicLibrarySource) == null) {
 
543
                return false;
 
544
            }
 
545
            if ((source as MusicLibrarySource)==this.source) {
527
546
                SelectAllTracks ();
528
 
                                return true;
529
 
                        } else
530
 
                                ResetSource ();
531
 
                        
532
 
                        this.source = (source as MusicLibrarySource);
533
 
                        this.source.TrackModel.Selection.Clear (false);
534
 
                        this.source.TracksAdded += HandleTracksAdded;
535
 
                        this.source.TracksDeleted += HandleTracksDeleted;
536
 
 
537
 
                        foreach (IFilterListModel list_model in this.source.CurrentFilters) {
538
 
                                list_model.Clear (); //clear selections, we need all albums!!
539
 
                                if (list_model is FilterListModel<AlbumInfo>) {
540
 
                                        external_filter = list_model as FilterListModel<AlbumInfo>;
541
 
                                        break;
542
 
                                }
543
 
                        }
544
 
                        
545
 
                        main_view.SetModel (TrackModel);
546
 
                        FilterView.SetModel (external_filter);
547
 
                        
548
 
                        return true;
549
 
        }
550
 
 
551
 
                private void HandleTracksAdded (Source sender, TrackEventArgs args)
552
 
                {
553
 
                        SelectAllTracks ();
554
 
                }
555
 
 
556
 
                private void HandleTracksDeleted (Source sender, TrackEventArgs args)
557
 
                {
558
 
                        SelectAllTracks ();
559
 
                }
 
547
                return true;
 
548
            } else {
 
549
                ResetSource ();
 
550
            }
 
551
 
 
552
            this.source = (source as MusicLibrarySource);
 
553
            this.source.TrackModel.Selection.Clear (false);
 
554
            this.source.TracksAdded += HandleTracksAdded;
 
555
            this.source.TracksDeleted += HandleTracksDeleted;
 
556
 
 
557
            foreach (IFilterListModel list_model in this.source.CurrentFilters) {
 
558
                list_model.Clear (); //clear selections, we need all albums!!
 
559
                if (list_model is FilterListModel<AlbumInfo>) {
 
560
                    external_filter = list_model as FilterListModel<AlbumInfo>;
 
561
                    break;
 
562
                }
 
563
            }
 
564
 
 
565
            main_view.SetModel (TrackModel);
 
566
            FilterView.SetModel (external_filter);
 
567
 
 
568
            return true;
 
569
        }
 
570
 
 
571
        private void HandleTracksAdded (Source sender, TrackEventArgs args)
 
572
        {
 
573
            SelectAllTracks ();
 
574
        }
 
575
 
 
576
        private void HandleTracksDeleted (Source sender, TrackEventArgs args)
 
577
        {
 
578
            SelectAllTracks ();
 
579
        }
560
580
 
561
581
        public void ResetSource ()
562
582
        {
563
 
                        if (source!=null) {
 
583
            if (source!=null) {
564
584
                source.TracksAdded -= HandleTracksAdded;
565
585
                source.TracksDeleted -= HandleTracksDeleted;
566
 
                    source = null;
567
 
                        }
 
586
                source = null;
 
587
            }
568
588
            TrackView.SetModel (null);
569
 
                        FilterView.SetModel (null);
 
589
            FilterView.SetModel (null);
570
590
        }
571
591
 
572
592
        protected void SelectActiveAlbum () // to implement sorting: create a DatabaseAlbumListModel subclass
573
593
        {
574
 
                        AlbumInfo album = FilterView.ActiveAlbum;
575
 
                        if (album!=null) {
576
 
                                external_filter.Selection.Clear (false);
577
 
                                external_filter.Selection.Select (FilterView.ActiveModelIndex);
578
 
                        }
579
 
        }
580
 
                protected void SelectAllTracks ()
581
 
                {
582
 
                        external_filter.Selection.SelectAll ();
583
 
                }               
584
 
                #endregion
 
594
            AlbumInfo album = FilterView.ActiveAlbum;
 
595
            if (album!=null) {
 
596
                external_filter.Selection.Clear (false);
 
597
                external_filter.Selection.Select (FilterView.ActiveModelIndex);
 
598
            }
 
599
        }
 
600
        protected void SelectAllTracks ()
 
601
        {
 
602
            external_filter.Selection.SelectAll ();
 
603
        }
 
604
        #endregion
585
605
    }
586
606
}