← Back to branch summary

~noskcaj/ubuntu/vivid/banshee-community-extensions/merge

« back to all changes in this revision

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

  • Committer: Bazaar Package Importer
  • Author(s): Iain Lane
  • Date: 2011-06-26 13:31:44 UTC
  • mfrom: (4.1.7 experimental)
  • Revision ID: james.westby@ubuntu.com-20110626133144-62h4ohgg03p5y9nl
Tags: 2.1.1-2ubuntu1
* [c0b3875] Merge from Debian Unstable, remaining changes:
  + Enable LIRC and AppIndicator extensions

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/ClutterFlow/Banshee.ClutterFlow/ClutterFlowView.cs
47
47
 
48
48
namespace Banshee.ClutterFlow
49
49
{
50
 
        
51
 
        public class ClutterFlowView : Clutter.Embed
52
 
        {
 
50
 
 
51
    public class ClutterFlowView : Clutter.Embed
 
52
    {
53
53
        #region Fields
54
54
        #region Active/Current Album Related
55
 
                public event EventHandler UpdatedAlbum;
56
 
 
57
 
                private AlbumInfo activeAlbum = null;
58
 
                public AlbumInfo ActiveAlbum {
59
 
                        get { return activeAlbum; }
60
 
                        protected set { activeAlbum = value; }
61
 
                }               
62
 
                private int activeIndex = -1;
63
 
                public int ActiveIndex {
64
 
                        get { return activeIndex; }
65
 
                        protected set { activeIndex = value; }
66
 
                }
67
 
                public int ActiveModelIndex {
68
 
                        get {
69
 
                                int ret = AlbumLoader.ConvertIndexToModelIndex (ActiveIndex);
70
 
                                Hyena.Log.DebugFormat ("ActiveModelIndex_get will return {0}", ret);
71
 
                                return ret;
72
 
                        }
73
 
                }               
74
 
                public AlbumInfo CurrentAlbum {
75
 
                        get { return albumLoader.CurrentAlbum; }
76
 
                }
77
 
                public int CurrentIndex {
78
 
                        get { return albumLoader.CurrentIndex; }
79
 
                }
80
 
                public int CurrentModelIndex {
81
 
                        get { return AlbumLoader.ConvertIndexToModelIndex (CurrentIndex); }
82
 
                }               
 
55
        public event EventHandler UpdatedAlbum;
 
56
 
 
57
        private AlbumInfo activeAlbum = null;
 
58
        public AlbumInfo ActiveAlbum {
 
59
            get { return activeAlbum; }
 
60
            protected set { activeAlbum = value; }
 
61
        }
 
62
        private int activeIndex = -1;
 
63
        public int ActiveIndex {
 
64
            get { return activeIndex; }
 
65
            protected set { activeIndex = value; }
 
66
        }
 
67
        public int ActiveModelIndex {
 
68
            get {
 
69
                int ret = AlbumLoader.ConvertIndexToModelIndex (ActiveIndex);
 
70
                Hyena.Log.DebugFormat ("ActiveModelIndex_get will return {0}", ret);
 
71
                return ret;
 
72
            }
 
73
        }
 
74
 
 
75
        public AlbumInfo CurrentAlbum {
 
76
            get {
 
77
                var album_actor = cover_manager.CurrentCover as ClutterFlowAlbum;
 
78
                if (album_actor != null) {
 
79
                    return album_actor.Album;
 
80
                } else {
 
81
                    return null;
 
82
                }
 
83
            }
 
84
        }
 
85
 
 
86
        public int CurrentIndex {
 
87
            get {
 
88
                var album_actor = cover_manager.CurrentCover as ClutterFlowAlbum;
 
89
                if (album_actor != null) {
 
90
                    return album_actor.Index;
 
91
                } else {
 
92
                    return -1;
 
93
                }
 
94
            }
 
95
        }
 
96
 
 
97
        public int CurrentModelIndex {
 
98
            get { return AlbumLoader.ConvertIndexToModelIndex (CurrentIndex); }
 
99
        }
83
100
        #endregion
84
101
 
85
102
        #region General
86
 
                private AlbumLoader albumLoader;
87
 
                public AlbumLoader AlbumLoader {
88
 
                        get { return albumLoader; }
89
 
                }
90
 
                private CoverManager coverManager;
91
 
                public CoverManager CoverManager {
92
 
                        get { return coverManager; }
93
 
                }
94
 
                
 
103
        private AlbumLoader album_loader;
 
104
        public AlbumLoader AlbumLoader {
 
105
            get { return album_loader; }
 
106
        }
 
107
        private CoverManager cover_manager;
 
108
        public CoverManager CoverManager {
 
109
            get { return cover_manager; }
 
110
        }
 
111
 
 
112
        private int model_count;
 
113
 
95
114
        public virtual IListModel<AlbumInfo> Model {
96
 
            get { return albumLoader.Model; }
 
115
            get { return album_loader.Model; }
97
116
        }
98
117
 
99
118
        public void SetModel (FilterListModel<AlbumInfo> value)
100
119
        {
101
 
            albumLoader.Model = value;
 
120
            if (value != album_loader.Model) {
 
121
                if (album_loader.Model != null) {
 
122
                    album_loader.Model.Cleared -= OnModelClearedHandler;
 
123
                    album_loader.Model.Reloaded -= OnModelReloadedHandler;
 
124
                }
 
125
 
 
126
                album_loader.Model = value;
 
127
 
 
128
                if (album_loader.Model != null) {
 
129
                    album_loader.Model.Cleared += OnModelClearedHandler;
 
130
                    album_loader.Model.Reloaded += OnModelReloadedHandler;
 
131
                    model_count = album_loader.Model.Count;
 
132
                }
 
133
                CoverManager.ReloadCovers ();
 
134
            }
102
135
        }
 
136
 
103
137
        protected bool attached = false;
104
138
        public bool Attached {
105
139
            get { return attached; }
107
141
        #endregion
108
142
 
109
143
        #region User Interface & Interaction
110
 
                private bool dragging = false;                  // wether or not we are currently dragging the viewport around
111
 
                private double mouse_x, mouse_y;
112
 
                private float drag_x0, drag_y0;         // initial coordinates when the mouse button was pressed down
113
 
                private int start_index;
114
 
                
115
 
                private float drag_sens = 0.3f;
116
 
                public float DragSensitivity {
117
 
                        get { return drag_sens; }
118
 
                        set {
119
 
                                if (value<0.01f) value = 0.01f;
120
 
                                if (value>2.0f) value = 2.0f;
121
 
                                drag_sens = value;
122
 
                        }
123
 
                }
124
 
                
125
 
                
126
 
                private ClutterFlowSlider slider;
127
 
                public ClutterFlowSlider Slider {
128
 
                        get { return slider;    }
129
 
                }
130
 
                private ClutterWidgetBar widget_bar;
131
 
                public ClutterWidgetBar WidgetBar {
132
 
                        get { return widget_bar;        }
133
 
                }
134
 
                private PartyModeButton pm_button;
135
 
                public PartyModeButton PMButton {
136
 
                        get { return pm_button; }
137
 
                }
138
 
                private FullscreenButton fs_button;
139
 
                public FullscreenButton FSButton {
140
 
                        get { return fs_button; }
141
 
                }
142
 
                private SortButton sort_button;
143
 
                public SortButton SortButton {
144
 
                        get { return sort_button; }
145
 
                }               
146
 
                private CoverCaption caption_cover;
147
 
                public CoverCaption LabelCover {
148
 
                        get { return caption_cover;     }
149
 
                }
150
 
                private TrackCaption caption_track;
151
 
                public TrackCaption LabelTrack {
152
 
                        get { return caption_track;     }
153
 
                }
154
 
                
155
 
                public bool LabelCoverIsVisible {
156
 
                        set { if (value) caption_cover.ShowAll(); else caption_cover.HideAll(); }
157
 
                }
158
 
                public bool LabelTrackIsVisible {
159
 
                        set { if (value) caption_track.ShowAll(); else caption_track.HideAll(); }
160
 
                }
161
 
 
162
 
                
163
 
                private const float rotSens = 0.00001f;
164
 
                private const float viewportMaxAngleX = 10; // maximum X viewport angle
165
 
                private const float viewportMinAngleX = -30; // maximum X viewport angle
166
 
                private const float viewportMaxAngleY = -15; // maximum Y viewport angle
167
 
                private float viewportAngleX = -5f;                      // current X viewport angle
168
 
                public float ViewportAngleX {
169
 
                        get { return viewportAngleX; }
170
 
                        set {
171
 
                                if (value!=viewportAngleX) {
172
 
                                        viewportAngleX = value;
173
 
                                        if (viewportAngleX < viewportMinAngleX) viewportAngleX = viewportMinAngleX;
174
 
                                        if (viewportAngleX > viewportMaxAngleX) viewportAngleX = viewportMaxAngleX;
175
 
 
176
 
                                        if (viewportAngleX < -1f && viewportAngleX > -9f)
177
 
                                                coverManager.SetRotation(RotateAxis.Y, -5f, coverManager.Width*0.5f,coverManager.Height*0.5f,coverManager.Behaviour.ZFar);
178
 
                                        else
179
 
                                                coverManager.SetRotation(RotateAxis.X, viewportAngleX, coverManager.Width*0.5f,coverManager.Height*0.5f,coverManager.Behaviour.ZFar);
180
 
                                        
181
 
                                }
182
 
                        }
183
 
                }
184
 
                private float viewportAngleY = 0;                       // current Y viewport angle
185
 
                public float ViewportAngleY {
186
 
                        get { return viewportAngleY; }
187
 
                        set {
188
 
                                if (value!=viewportAngleY) {
189
 
                                        viewportAngleY = value;
190
 
                                        if (viewportAngleY < viewportMaxAngleY) viewportAngleY = viewportMaxAngleY;
191
 
                                        if (viewportAngleY > -viewportMaxAngleY) viewportAngleY = -viewportMaxAngleY;
192
 
 
193
 
                                        if (viewportAngleY > -4f && viewportAngleY < 4f)
194
 
                                                coverManager.SetRotation(RotateAxis.Y, 0, coverManager.Width*0.5f,coverManager.Height*0.5f,coverManager.Behaviour.ZFar);
195
 
                                        else
196
 
                                                coverManager.SetRotation(RotateAxis.Y, viewportAngleY, coverManager.Width*0.5f,coverManager.Height*0.5f,coverManager.Behaviour.ZFar);
197
 
                                }
198
 
                        }
199
 
                }
200
 
        #endregion
201
 
        #endregion
202
 
 
203
 
                #region Initialisation
 
144
        private bool dragging = false;            // wether or not we are currently dragging the viewport around
 
145
        private double mouse_x, mouse_y;
 
146
        private float drag_x0, drag_y0;        // initial coordinates when the mouse button was pressed down
 
147
        private int start_index;
 
148
 
 
149
        private float drag_sens = 0.3f;
 
150
        public float DragSensitivity {
 
151
            get { return drag_sens; }
 
152
            set {
 
153
                if (value < 0.01f) {
 
154
                    value = 0.01f;
 
155
                }
 
156
                if (value > 2.0f) {
 
157
                    value = 2.0f;
 
158
                }
 
159
                drag_sens = value;
 
160
            }
 
161
        }
 
162
 
 
163
        private ClutterFlowSlider slider;
 
164
        public ClutterFlowSlider Slider {
 
165
            get { return slider;    }
 
166
        }
 
167
        private ClutterWidgetBar widget_bar;
 
168
        public ClutterWidgetBar WidgetBar {
 
169
            get { return widget_bar;    }
 
170
        }
 
171
        private PartyModeButton pm_button;
 
172
        public PartyModeButton PMButton {
 
173
            get { return pm_button;    }
 
174
        }
 
175
        private FullscreenButton fs_button;
 
176
        public FullscreenButton FSButton {
 
177
            get { return fs_button; }
 
178
        }
 
179
        private SortButton sort_button;
 
180
        public SortButton SortButton {
 
181
            get { return sort_button; }
 
182
        }
 
183
        private CoverCaption caption_cover;
 
184
        public CoverCaption LabelCover {
 
185
            get { return caption_cover;    }
 
186
        }
 
187
        private TrackCaption caption_track;
 
188
        public TrackCaption LabelTrack {
 
189
            get { return caption_track;    }
 
190
        }
 
191
 
 
192
        public bool LabelCoverIsVisible {
 
193
            set {
 
194
                if (value) {
 
195
                    caption_cover.ShowAll();
 
196
                } else {
 
197
                    caption_cover.HideAll();
 
198
                }
 
199
            }
 
200
        }
 
201
        public bool LabelTrackIsVisible {
 
202
            set { if (value) {
 
203
                    caption_track.ShowAll();
 
204
                } else {
 
205
                    caption_track.HideAll();
 
206
                }
 
207
            }
 
208
        }
 
209
 
 
210
 
 
211
        private const float rotSens = 0.00001f;
 
212
        private const float viewportMaxAngleX = 10; // maximum X viewport angle
 
213
        private const float viewportMinAngleX = -30; // maximum X viewport angle
 
214
        private const float viewportMaxAngleY = -15; // maximum Y viewport angle
 
215
        private float viewportAngleX = -5f;             // current X viewport angle
 
216
        public float ViewportAngleX {
 
217
            get { return viewportAngleX; }
 
218
            set {
 
219
                if (value != viewportAngleX) {
 
220
                    viewportAngleX = value;
 
221
                    if (viewportAngleX < viewportMinAngleX) {
 
222
                        viewportAngleX = viewportMinAngleX;
 
223
                    }
 
224
                    if (viewportAngleX > viewportMaxAngleX) {
 
225
                        viewportAngleX = viewportMaxAngleX;
 
226
                    }
 
227
 
 
228
                    if (viewportAngleX < -1f && viewportAngleX > -9f) {
 
229
                        cover_manager.SetRotation(RotateAxis.Y, -5f, cover_manager.Width*0.5f,cover_manager.Height*0.5f,cover_manager.Behaviour.ZFar);
 
230
                    } else {
 
231
                        cover_manager.SetRotation(RotateAxis.X, viewportAngleX, cover_manager.Width*0.5f,cover_manager.Height*0.5f,cover_manager.Behaviour.ZFar);
 
232
                    }
 
233
                }
 
234
            }
 
235
        }
 
236
        private float viewportAngleY = 0;            // current Y viewport angle
 
237
        public float ViewportAngleY {
 
238
            get { return viewportAngleY; }
 
239
            set {
 
240
                if (value != viewportAngleY) {
 
241
                    viewportAngleY = value;
 
242
                    if (viewportAngleY < viewportMaxAngleY) {
 
243
                        viewportAngleY = viewportMaxAngleY;
 
244
                    }
 
245
                    if (viewportAngleY > -viewportMaxAngleY) {
 
246
                        viewportAngleY = -viewportMaxAngleY;
 
247
                    }
 
248
 
 
249
                    if (viewportAngleY > -4f && viewportAngleY < 4f) {
 
250
                        cover_manager.SetRotation(RotateAxis.Y, 0, cover_manager.Width*0.5f,cover_manager.Height*0.5f,cover_manager.Behaviour.ZFar);
 
251
                    } else {
 
252
                        cover_manager.SetRotation(RotateAxis.Y, viewportAngleY, cover_manager.Width*0.5f,cover_manager.Height*0.5f,cover_manager.Behaviour.ZFar);
 
253
                    }
 
254
                }
 
255
            }
 
256
        }
 
257
        #endregion
 
258
        #endregion
 
259
 
 
260
        #region Initialisation
204
261
        public ClutterFlowView () : base ()
205
262
        {
206
 
                        SetSizeRequest (300, 200);
207
 
                        Clutter.Global.MotionEventsEnabled = true;
 
263
            SetSizeRequest (300, 200);
 
264
            Clutter.Global.MotionEventsEnabled = true;
208
265
 
209
 
                        coverManager = new CoverManager();
210
 
                        albumLoader = new AlbumLoader (coverManager);
 
266
            album_loader = new AlbumLoader ();
 
267
            cover_manager = new CoverManager (album_loader, GetDefaultSurface, ClutterFlowSchemas.TextureSize.Get ());
211
268
 
212
269
            AttachEvents ();
213
 
                        
214
 
                        SetupViewport ();
215
 
                        SetupSlider ();
216
 
                        SetupLabels ();
217
 
                        SetupWidgetBar ();
218
 
                }
219
 
 
220
 
        public void AttachEvents ()
 
270
 
 
271
            SetupViewport ();
 
272
            SetupSlider ();
 
273
            SetupLabels ();
 
274
            SetupWidgetBar ();
 
275
        }
 
276
 
 
277
        private void AttachEvents ()
221
278
        {
222
 
            if (attached)
 
279
            if (attached) {
223
280
                return;
 
281
            }
224
282
            attached = true;
225
283
 
226
284
            Stage.AllocationChanged += HandleAllocationChanged;
228
286
            Stage.ButtonReleaseEvent += HandleButtonReleaseEvent;
229
287
            Stage.ButtonPressEvent += HandleButtonPressEvent;
230
288
            Stage.MotionEvent += HandleMotionEvent;
231
 
                        albumLoader.ActorActivated += HandleActorActivated;
 
289
            cover_manager.ActorActivated += HandleActorActivated;
232
290
        }
233
291
 
234
 
        public void DetachEvents ()
 
292
        private void DetachEvents ()
235
293
        {
236
294
            if (!attached)
237
295
                return;
241
299
            Stage.ButtonReleaseEvent -= HandleButtonReleaseEvent;
242
300
            Stage.ButtonPressEvent -= HandleButtonPressEvent;
243
301
            Stage.MotionEvent -= HandleMotionEvent;
244
 
                        albumLoader.ActorActivated -= HandleActorActivated;
 
302
            cover_manager.ActorActivated -= HandleActorActivated;
245
303
 
246
304
            attached = false;
247
305
        }
249
307
        protected bool disposed = false;
250
308
        public override void Dispose ()
251
309
        {
252
 
            if (disposed)
 
310
            if (disposed) {
253
311
                return;
 
312
            }
254
313
            disposed = true;
255
314
 
256
315
            DetachEvents ();
257
316
            AlbumLoader.Dispose ();
258
317
            CoverManager.Dispose ();
259
 
 
260
 
            //base.Dispose ();
261
318
        }
262
319
 
263
320
 
264
 
                protected void SetupViewport ()
265
 
                {
266
 
                        Stage.Color = new Clutter.Color (0x00, 0x00, 0x00, 0xff);
267
 
                        coverManager.SetRotation (RotateAxis.X, viewportAngleX, Stage.Width/2, Stage.Height/2,0);
268
 
                        Stage.Add (coverManager);
 
321
        protected void SetupViewport ()
 
322
        {
 
323
            Stage.Color = new Clutter.Color (0x00, 0x00, 0x00, 0xff);
 
324
            cover_manager.SetRotation (RotateAxis.X, viewportAngleX, Stage.Width/2, Stage.Height/2,0);
 
325
            Stage.Add (cover_manager);
269
326
 
270
 
                        
271
 
                        
272
 
                        coverManager.EmptyActor.SetToPb(
273
 
                    IconThemeUtils.LoadIcon (coverManager.TextureSize, "gtk-stop", "clutterflow-large.png")
 
327
            cover_manager.EmptyActor.SetToPb (
 
328
                IconThemeUtils.LoadIcon (cover_manager.TextureSize, "gtk-stop", "clutterflow-large.png")
274
329
            );
275
 
            CoverManager.DoubleClickTime = (uint) Gtk.Settings.GetForScreen(this.Screen).DoubleClickTime;
276
 
                        coverManager.LowerBottom ();
277
 
                        coverManager.Show ();
278
 
                }
279
 
                
280
 
                protected void SetupSlider ()
281
 
                {
282
 
                        slider = new ClutterFlowSlider (400, 40, coverManager);
283
 
                        Stage.Add (slider);
284
 
                }       
285
 
                
286
 
                protected void SetupLabels () {
287
 
                        caption_cover = new CoverCaption (coverManager, "Sans Bold 10", new Clutter.Color(1.0f,1.0f,1.0f,1.0f));
288
 
                        Stage.Add (caption_cover);
289
 
 
290
 
                        caption_track = new TrackCaption (coverManager, "Sans Bold 10", new Clutter.Color(1.0f,1.0f,1.0f,1.0f));
291
 
                        Stage.Add (caption_track);
292
 
                }
293
 
 
294
 
                protected void SetupWidgetBar ()
295
 
                {
296
 
                        pm_button = new PartyModeButton ();
297
 
                        fs_button = new FullscreenButton ();
298
 
                        sort_button = new SortButton ();
299
 
                        
300
 
                        widget_bar = new ClutterWidgetBar (new Actor[] { pm_button, fs_button, sort_button });
301
 
                        widget_bar.ShowAll ();
302
 
                        Stage.Add (widget_bar);
303
 
                        widget_bar.SetPosition (5, 5);
304
 
                }
305
 
                #endregion
306
 
                
307
 
                #region Rendering
308
 
                //Update all elements:
309
 
                protected void RedrawInterface ()
310
 
                {
311
 
                        slider.Update ();
312
 
                        caption_cover.Update ();
313
 
                        caption_track.Update ();
314
 
 
315
 
                        widget_bar.SetPosition (5, 5);
316
 
                        RedrawViewport ();
317
 
                }
318
 
                
319
 
                //Update the coverStage position:
320
 
                protected void RedrawViewport ()
321
 
                {
322
 
                        coverManager.UpdateBehaviour();
323
 
                        coverManager.SetRotation(RotateAxis.X, viewportAngleX, coverManager.Width*0.5f, coverManager.Height*0.5f,0);
324
 
                        if (!coverManager.IsVisible) coverManager.Show();
325
 
                        coverManager.LowerBottom();
326
 
                }
327
 
                #endregion
328
 
                
329
 
                #region Event Handling
330
 
 
331
 
                protected override void OnSizeAllocated (Gdk.Rectangle allocation)
332
 
                {
333
 
                        base.OnSizeAllocated (allocation);
334
 
                        RedrawInterface();
335
 
                }
336
 
 
337
 
                
338
 
                private void HandleAllocationChanged (object o, AllocationChangedArgs args)
339
 
                {       
340
 
                        RedrawInterface();
341
 
                }
342
 
 
343
 
 
344
 
        private void HandleActorActivated (ClutterFlowAlbum actor, EventArgs e)
345
 
        {
346
 
                UpdateAlbum (actor);
347
 
        }
348
 
                
349
 
                private void HandleButtonPressEvent(object o, Clutter.ButtonPressEventArgs args)
350
 
                {
351
 
                        Clutter.EventHelper.GetCoords (args.Event, out drag_x0, out drag_y0);
352
 
                        args.RetVal = true;
353
 
                }
354
 
                
355
 
                void HandleButtonReleaseEvent (object o, Clutter.ButtonReleaseEventArgs args)
356
 
                {
357
 
                        //if (args.Event.Button==1 && !dragging  && coverManager.CurrentCover!=null && ActiveAlbum != CurrentAlbum)
358
 
                        //      UpdateAlbum ();
359
 
                        if (dragging) Clutter.Ungrab.Pointer ();
360
 
                        dragging = false;
361
 
                        args.RetVal = true;
362
 
                }
363
 
                
364
 
                private void HandleMotionEvent (object o, Clutter.MotionEventArgs args)
365
 
                {
366
 
                        if ((args.Event.ModifierState.value__ & Clutter.ModifierType.Button1Mask.value__)!=0) {
367
 
                                float drag_x; float drag_y;
368
 
                                Clutter.EventHelper.GetCoords (args.Event, out drag_x, out drag_y);
369
 
                                if (!dragging) {
370
 
                                        if (Math.Abs(drag_x0 - drag_x) > 2 && Math.Abs(drag_y0 - drag_y) > 2) {
371
 
                                                start_index = CoverManager.TargetIndex;
372
 
                                                Clutter.Grab.Pointer (Stage);
373
 
                                                dragging = true;
374
 
                                        }
375
 
                                } else {
376
 
                                        if ((args.Event.ModifierState.value__ & Clutter.ModifierType.ControlMask.value__)!=0) {
377
 
                                                if (!dragging) Clutter.Grab.Pointer (Stage);
378
 
                                                ViewportAngleY += (float) (mouse_x - args.Event.X)*rotSens;
379
 
                                                ViewportAngleX += (float) (mouse_y - args.Event.Y)*rotSens;
380
 
                                        } else {
381
 
                                                CoverManager.TargetIndex = start_index + (int) ((drag_x0 - drag_x)*drag_sens);
382
 
                                        }
383
 
                                }
384
 
                        } else {
385
 
                                if (dragging) Clutter.Ungrab.Pointer ();
386
 
                                dragging = false;
387
 
                        }
388
 
                        mouse_x = args.Event.X;
389
 
                        mouse_y = args.Event.Y;
390
 
                        
391
 
                        args.RetVal = dragging;
392
 
                }
393
 
                
394
 
                private void HandleScroll (object o, Clutter.ScrollEventArgs args)
395
 
                {
396
 
                        if (args.Event.Direction==Clutter.ScrollDirection.Down
397
 
                                || args.Event.Direction==Clutter.ScrollDirection.Left)
398
 
                                Scroll(true);
399
 
                        else
400
 
                                Scroll(false);
401
 
                }
402
 
                
403
 
                public void Scroll (bool Backward)
404
 
                {
405
 
                        if (Backward) coverManager.TargetIndex--;
406
 
                        else coverManager.TargetIndex++;
407
 
                }
408
 
 
409
 
                public void UpdateAlbum ()
410
 
                {
411
 
                        UpdateAlbum (albumLoader.CurrentActor);
412
 
                }
413
 
                
414
 
                public void UpdateAlbum (ClutterFlowAlbum actor)
415
 
                {
416
 
                        ActiveAlbum = actor.Album;
417
 
                        ActiveIndex = actor.Index;
418
 
                        if (UpdatedAlbum!=null) UpdatedAlbum (ActiveAlbum, EventArgs.Empty);
419
 
                }
420
 
                #endregion
421
 
                
422
 
        }       
 
330
            CoverManager.DoubleClickTime = (uint) Gtk.Settings.GetForScreen (this.Screen).DoubleClickTime;
 
331
            cover_manager.LowerBottom ();
 
332
            cover_manager.Show ();
 
333
        }
 
334
 
 
335
        protected void SetupSlider ()
 
336
        {
 
337
            slider = new ClutterFlowSlider (400, 40, cover_manager);
 
338
            Stage.Add (slider);
 
339
        }
 
340
 
 
341
        protected void SetupLabels () {
 
342
            caption_cover = new CoverCaption (cover_manager, "Sans Bold 10", new Clutter.Color(1.0f,1.0f,1.0f,1.0f));
 
343
            Stage.Add (caption_cover);
 
344
 
 
345
            caption_track = new TrackCaption (cover_manager, "Sans Bold 10", new Clutter.Color(1.0f,1.0f,1.0f,1.0f));
 
346
            Stage.Add (caption_track);
 
347
        }
 
348
 
 
349
        protected void SetupWidgetBar ()
 
350
        {
 
351
            pm_button = new PartyModeButton ();
 
352
            fs_button = new FullscreenButton ();
 
353
            sort_button = new SortButton ();
 
354
 
 
355
            widget_bar = new ClutterWidgetBar (new Actor[] { pm_button, fs_button, sort_button });
 
356
            widget_bar.ShowAll ();
 
357
            Stage.Add (widget_bar);
 
358
            widget_bar.SetPosition (5, 5);
 
359
        }
 
360
        #endregion
 
361
 
 
362
        #region Rendering
 
363
        //Update all elements:
 
364
        protected void RedrawInterface ()
 
365
        {
 
366
            slider.Update ();
 
367
            caption_cover.Update ();
 
368
            caption_track.Update ();
 
369
 
 
370
            widget_bar.SetPosition (5, 5);
 
371
            RedrawViewport ();
 
372
        }
 
373
 
 
374
        //Update the coverStage position:
 
375
        protected void RedrawViewport ()
 
376
        {
 
377
            cover_manager.UpdateBehaviour ();
 
378
            cover_manager.SetRotation (RotateAxis.X, viewportAngleX, cover_manager.Width*0.5f, cover_manager.Height*0.5f,0);
 
379
            if (!cover_manager.IsVisible) {
 
380
                cover_manager.Show ();
 
381
            }
 
382
            cover_manager.LowerBottom ();
 
383
        }
 
384
        #endregion
 
385
 
 
386
        protected Cairo.ImageSurface GetDefaultSurface ()
 
387
        {
 
388
            Cairo.ImageSurface surface = new Cairo.ImageSurface(Cairo.Format.ARGB32, CoverManager.TextureSize, CoverManager.TextureSize);
 
389
            Cairo.Context context = new Cairo.Context(surface);
 
390
            Gdk.CairoHelper.SetSourcePixbuf(context, IconThemeUtils.LoadIcon (CoverManager.TextureSize, "media-optical", "browser-album-cover"), 0, 0);
 
391
            context.Paint();
 
392
            //((IDisposable) context.Target).Dispose();
 
393
            ((IDisposable) context).Dispose();
 
394
            return surface;
 
395
        }
 
396
 
 
397
 
 
398
        #region Event Handling
 
399
 
 
400
        protected override void OnSizeAllocated (Gdk.Rectangle allocation)
 
401
        {
 
402
            base.OnSizeAllocated (allocation);
 
403
            RedrawInterface ();
 
404
        }
 
405
 
 
406
 
 
407
        private void HandleAllocationChanged (object o, AllocationChangedArgs args)
 
408
        {
 
409
            RedrawInterface ();
 
410
        }
 
411
 
 
412
 
 
413
        private void HandleActorActivated (ClutterFlowBaseActor actor, EventArgs e)
 
414
        {
 
415
            var album_actor = actor as ClutterFlowAlbum;
 
416
            if (album_actor != null) {
 
417
                UpdateAlbum (album_actor);
 
418
            }
 
419
        }
 
420
 
 
421
        private void HandleButtonPressEvent (object o, Clutter.ButtonPressEventArgs args)
 
422
        {
 
423
            Clutter.EventHelper.GetCoords (args.Event, out drag_x0, out drag_y0);
 
424
            args.RetVal = true;
 
425
        }
 
426
 
 
427
        void HandleButtonReleaseEvent (object o, Clutter.ButtonReleaseEventArgs args)
 
428
        {
 
429
            //if (args.Event.Button==1 && !dragging  && coverManager.CurrentCover!=null && ActiveAlbum != CurrentAlbum)
 
430
            //    UpdateAlbum ();
 
431
            if (dragging) {
 
432
                Clutter.Ungrab.Pointer ();
 
433
            }
 
434
            dragging = false;
 
435
            args.RetVal = true;
 
436
        }
 
437
 
 
438
        private void HandleMotionEvent (object o, Clutter.MotionEventArgs args)
 
439
        {
 
440
            if ((args.Event.ModifierState.value__ & Clutter.ModifierType.Button1Mask.value__) != 0) {
 
441
                float drag_x; float drag_y;
 
442
                Clutter.EventHelper.GetCoords (args.Event, out drag_x, out drag_y);
 
443
                if (!dragging) {
 
444
                    if (Math.Abs(drag_x0 - drag_x) > 2 && Math.Abs(drag_y0 - drag_y) > 2) {
 
445
                        start_index = CoverManager.TargetIndex;
 
446
                        Clutter.Grab.Pointer (Stage);
 
447
                        dragging = true;
 
448
                    }
 
449
                } else {
 
450
                    if ((args.Event.ModifierState.value__ & Clutter.ModifierType.ControlMask.value__)!=0) {
 
451
                        if (!dragging) {
 
452
                            Clutter.Grab.Pointer (Stage);
 
453
                        }
 
454
                        ViewportAngleY += (float) (mouse_x - args.Event.X)*rotSens;
 
455
                        ViewportAngleX += (float) (mouse_y - args.Event.Y)*rotSens;
 
456
                    } else {
 
457
                        CoverManager.TargetIndex = start_index + (int) ((drag_x0 - drag_x)*drag_sens);
 
458
                    }
 
459
                }
 
460
            } else {
 
461
                if (dragging) {
 
462
                    Clutter.Ungrab.Pointer ();
 
463
                }
 
464
                dragging = false;
 
465
            }
 
466
            mouse_x = args.Event.X;
 
467
            mouse_y = args.Event.Y;
 
468
 
 
469
            args.RetVal = dragging;
 
470
        }
 
471
 
 
472
        private void HandleScroll (object o, Clutter.ScrollEventArgs args)
 
473
        {
 
474
            if (args.Event.Direction == Clutter.ScrollDirection.Down
 
475
                || args.Event.Direction == Clutter.ScrollDirection.Left) {
 
476
                Scroll (true);
 
477
            } else {
 
478
                Scroll (false);
 
479
            }
 
480
        }
 
481
 
 
482
        public void Scroll (bool Backward)
 
483
        {
 
484
            if (Backward) {
 
485
                cover_manager.TargetIndex--;
 
486
            } else {
 
487
                cover_manager.TargetIndex++;
 
488
            }
 
489
        }
 
490
 
 
491
        private void ScrollTo (string key)
 
492
        {
 
493
            ClutterFlowBaseActor actor = null;
 
494
            album_loader.Cache.TryGetValue (key, out actor);
 
495
            if (actor != null && cover_manager.Covers.Contains (actor)) {
 
496
                cover_manager.TargetIndex = actor.Index;
 
497
            }
 
498
        }
 
499
 
 
500
        public void ScrollTo (AlbumInfo album)
 
501
        {
 
502
            cover_manager.Timeline.Timeout = 500; //give 'm some time to load the song etc.
 
503
            ScrollTo (ClutterFlowAlbum.CreateCacheKey (album));
 
504
        }
 
505
 
 
506
 
 
507
        public void UpdateAlbum ()
 
508
        {
 
509
            UpdateAlbum (cover_manager.CurrentCover as ClutterFlowAlbum);
 
510
        }
 
511
 
 
512
        public void UpdateAlbum (ClutterFlowAlbum actor)
 
513
        {
 
514
            ActiveAlbum = actor.Album;
 
515
            ActiveIndex = actor.Index;
 
516
            if (UpdatedAlbum != null) {
 
517
                UpdatedAlbum (ActiveAlbum, EventArgs.Empty);
 
518
            }
 
519
        }
 
520
 
 
521
        protected void OnModelClearedHandler (object o, EventArgs args)
 
522
        {
 
523
            CoverManager.ReloadCovers ();
 
524
        }
 
525
 
 
526
        protected void OnModelReloadedHandler (object o, EventArgs args)
 
527
        {
 
528
            if (model_count != album_loader.Model.Count) {
 
529
                model_count = album_loader.Model.Count;
 
530
                CoverManager.ReloadCovers ();
 
531
            }
 
532
        }
 
533
        #endregion
 
534
    }
423
535
}