public void RemoveItemDetail(ItemDetailViewModel detail)
        {
            if (detail == null)
            {
                throw new ArgumentNullException(nameof(detail));
            }
            bool updateCurrentChanged = false;

            if (_currentItemDetails.IndexOf(detail) == _currentItemDetails.Count - 1)
            {
                updateCurrentChanged = true;
            }
            _currentItemDetails.Remove(detail);
            if (updateCurrentChanged)
            {
                if (_currentItemDetails.Count == 0)
                {
                    CurrentItemChanged?.Invoke(this, new ItemDetailViewModelEventArgs {
                        Item = null
                    });
                }
                else
                {
                    ItemDetailViewModel lastItem = _currentItemDetails[_currentItemDetails.Count - 1];
                    CurrentItemChanged?.Invoke(this, new ItemDetailViewModelEventArgs {
                        Item = lastItem
                    });
                }
            }
        }
        public PlayingQueue(MediaPlayer player, LibraryService libraryService)
        {
            this.player         = player;
            this.libraryService = libraryService;

            player.Source   = null;
            player.AutoPlay = true;

            queue = new MediaPlaybackList();
            items = new TrackList(queue);

            queue.CurrentItemChanged += (s, a) =>
            {
                CurrentItemChanged?.Invoke(
                    (Track)a.NewItem?.Source.CustomProperties["track"],
                    (Track)a.OldItem?.Source.CustomProperties["track"]);
            };

            queue.Items.VectorChanged += (sender, a) =>
            {
                /* If the playbacklist is empty we unset the player source */
                if (sender.Count > 0)
                {
                    if (player.Source == null)
                    {
                        player.Source = queue;
                    }
                }
                else
                {
                    player.Source = null;
                }
            };
        }
Exemple #3
0
        /// <summary>
        /// Déclenche l'événement <see cref="CurrentItemChanged"/>
        /// </summary>
        /// <param name="oldItem">Ancienne valeur</param>
        protected virtual void OnCurrentItemChanged(T oldItem)
        {
            if (CurrentItem != null && !SelectedItems.Contains(CurrentItem))
            {
                _selectedItems.Add(CurrentItem);
            }

            if (oldItem != null && SelectedItems.Contains(oldItem))
            {
                _selectedItems.Remove(oldItem);
            }

            CurrentItemChanged?.Invoke(this, new CurrentItemChangedEventArgs(oldItem));

            if (oldItem is INotifyPropertyChanged npc)
            {
                npc.PropertyChanged -= CurrentItem_PropertyChanged;
            }

            npc = CurrentItem as INotifyPropertyChanged;
            if (npc != null)
            {
                npc.PropertyChanged += CurrentItem_PropertyChanged;
            }

            // TODO :Refresh commands
            //DetailCommand.RaiseCanExecuteChanged();
        }
 private void Update()
 {
     if (_closestItem != ClosestItemIndex)
     {
         CurrentItemChanged.Invoke(ClosestItemIndex);
         ChangePaginationInfo(ClosestItemIndex);
         _closestItem = ClosestItemIndex;
     }
 }
Exemple #5
0
        protected virtual void OnCurrentItemChanged(object sender, EventArgs e)
        {
            if (CurrentItem != null)
            {
                ((Control)((sbutton)sender).Tag).BringToFront();
            }

            // Invoke.
            CurrentItemChanged?.Invoke(sender, e);
        }
 private void Update()
 {
     if (IsScrollRectAvailable)
     {
         if (_closestItem != ClosestItemIndex)
         {
             CurrentItemChanged.Invoke(ClosestItemIndex);
             ChangePaginationInfo(ClosestItemIndex);
             _closestItem = ClosestItemIndex;
         }
     }
 }
 private void RaiseCurrentItemChanged()
 {
     CurrentItemChanged?.Invoke(this, CurrentItem);
     if (dispatcher == null || dispatcher.HasThreadAccess)
     {
         PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(CurrentItem)));
         PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(NextItem)));
     }
     else
     {
         var _ = dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
         {
             PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(CurrentItem)));
             PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(nameof(NextItem)));
         });
     }
 }
Exemple #8
0
        /*private async void Items_VectorChanged(IObservableVector<MediaPlaybackItem> sender, IVectorChangedEventArgs args)
         * {
         *  if (disposed) return;
         *  await dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
         *  {
         *      if (disposed) return;
         *      HandlePlaybackListChanges(sender);
         *  });
         * }*/


        private void SubscribedPlaybackList_CurrentItemChanged(MediaPlaybackList sender, CurrentMediaPlaybackItemChangedEventArgs args)
        {
            if (disposed)
            {
                return;
            }
#if (DEBUG)
            System.Diagnostics.Debug.WriteLine("SubscribedPlaybackList_CurrentItemChanged " + args.NewItem?.ToString());
#endif

            CurrentItemChanged?.Invoke(sender, args);
            if (args.NewItem != null)
            {
                loadProperties(args.NewItem);
                Playing?.Invoke(this, args.NewItem);
            }
        }
        public void AddItemDetails(IEnumerable <ItemDetailViewModel> details)
        {
            if (details == null)
            {
                throw new ArgumentNullException(nameof(details));
            }

            foreach (var detail in details)
            {
                if (!_currentItemDetails.Contains(detail))
                {
                    _currentItemDetails.Add(detail);
                    CurrentItemChanged?.Invoke(this, new ItemDetailViewModelEventArgs {
                        Item = detail
                    });
                }
            }
        }
Exemple #10
0
        private void DataGrid_CurrentCellChanged(object sender, EventArgs e)
        {
            DataGrid  grid = (DataGrid)sender;
            NetObject selectedNetObject = null;

            if (grid.CurrentCell.Item.GetType() == typeof(Project))
            {
                selectedNetObject = selectedProject;
            }
            else if (grid.CurrentCell.Item.GetType() == typeof(Todo))
            {
                selectedNetObject = selectedTodo;
            }
            else
            {
                return;
            }

            if (selectedNetObject == null || selectedNetObject.pId != ((NetObject)grid.CurrentCell.Item).pId)
            {
                NetObject netObject = (NetObject)grid.CurrentCell.Item;
                if (netObject.pId != Guid.Empty)
                {
                    CurrentItemChanged data = new CurrentItemChanged()
                    {
                        PK   = netObject.pId,
                        Type = netObject.GetType().ToString()
                    };

                    tornado14Observer.Send(new Package(SENDERID, 12, (int)EventMapping.CurrentItemChanged_15, Method.PUT, XmlSerializationHelper.Serialize(data)));
                    if (selectedTodo != null)
                    {
                        todoViewSource.View.Refresh();
                        todoViewSource.View.MoveCurrentTo(selectedTodo.pId);
                    }
                }
                selectedNetObject = (NetObject)grid.CurrentCell.Item;
            }
        }
Exemple #11
0
        private void HandlePUT(Package package)
        {
            if (package.Event == (int)EventMapping.DataItemChanged_13)
            {
                DataItemChanged putParams = XmlSerializationHelper.Desirialize <DataItemChanged>(package.Data);

                if (putParams.Type == typeof(Todo).ToString())
                {
                    Todo currentTodo = null;
                    foreach (Todo todo in TodoList)
                    {
                        if (todo.pId == putParams.PK)
                        {
                            currentTodo = todo;
                            break;
                        }
                    }
                    Todo.SetPropValue(currentTodo, putParams.PropertyName, putParams.Value);
                    currentTodo.DidNotReadLoL = true;
                }
                else if (putParams.Type == typeof(Project).ToString())
                {
                    Project currentProject = null;
                    foreach (Project project in ProjectList)
                    {
                        if (project.pId == putParams.PK)
                        {
                            currentProject = project;
                            break;
                        }
                    }
                    Project.SetPropValue(currentProject, putParams.PropertyName, putParams.Value);
                    currentProject.DidNotReadLoL = true;
                    selectedProject = currentProject;
                }
            }
            else if (package.Event == (int)EventMapping.CurrentItemChanged_15)
            {
                CurrentItemChanged putParams = XmlSerializationHelper.Desirialize <CurrentItemChanged>(package.Data);
                if (putParams.Type == typeof(Todo).ToString())
                {
                    object pk = TodoList.Where(todo => todo.pId == putParams.PK).First();
                    SelectedDataItemChanged(pk, putParams.Type);
                    selectedTodo = (Todo)pk;
                }
                else if (putParams.Type == typeof(Project).ToString())
                {
                    object pk = ProjectList.Where(project => project.pId == putParams.PK).First();
                    SelectedDataItemChanged(pk, putParams.Type);
                    selectedProject = (Project)pk;
                }
                else
                {
                    throw new Exception("Unknown Type");
                }
            }
            else if (package.Event == (int)EventMapping.DataItemBeginChanging_16)
            {
                DataItemBeginChanging putParams = XmlSerializationHelper.Desirialize <DataItemBeginChanging>(package.Data);
                DataItemStartChanging(putParams);
            }
            else if (package.Event == (int)EventMapping.DataItemEndChanging_17)
            {
                DataItemEndChanging putParams = XmlSerializationHelper.Desirialize <DataItemEndChanging>(package.Data);
                DataItemEndChanging(putParams);
            }
        }
 private void BindingSource1_CurrentItemChanged(object sender, EventArgs e)
 {
     CurrentItemChanged?.Invoke(this, EventArgs.Empty);
 }
Exemple #13
0
 private void OnCurrentItemChanged()
 {
     CurrentItemChanged?.Invoke(this, CurrentItem);
 }
Exemple #14
0
        public override void ObserveValue(NSString keyPath, NSObject ofObject, NSDictionary change, IntPtr context)
        {
            if (context != observerContext)
            {
                Log.Debug($"context != observerContext | returning");

                base.ObserveValue(keyPath, ofObject, change, context);

                return;
            }

            if (keyPath == null)
            {
                return;
            }


            if (keyPath == AVUrlAsset_Playable)
            {
                Log.Debug($"ObserveValue: {keyPath} | {Asset?.UrlAsset?.Playable}");

                if ((Asset?.UrlAsset?.Cache?.IsPlayableOffline ?? false) || (Asset?.UrlAsset?.Playable ?? false))
                {
                    PlayerItem = new AVPlayerItem(Asset.UrlAsset);

                    Player.ReplaceCurrentItemWithPlayerItem(PlayerItem);
                }
                else
                {
                    Log.Debug($"FAILED: {Asset?.UrlAsset?.Url}");
                }
            }
            else if (keyPath == AVPlayerItem_Status)
            {
                if (PlayerItem?.Status == AVPlayerItemStatus.ReadyToPlay)
                {
                    Log.Debug($"PlayerItem.Status = ReadyToPlay | {PlayerItem?.Error}");

                    if (!readyForPlayback)
                    {
                        readyForPlayback = true;

                        //ReadyToPlay?.Invoke (this, Player);
                        Player.Play();

                        setupRemoteTransportControls();
                    }
                    else
                    {
                        if (Player?.Rate == 0)
                        {
                            Player.Play();
                        }

                        //addPeriodicTimeObserver ();
                    }

                    updateCommandCenterNowPlayingInfo();
                }
                else if (PlayerItem?.Status == AVPlayerItemStatus.Unknown)
                {
                    //removePeriodicTimeObserver ();
                    Log.Debug($"PlayerItem.Status = Unknown | {PlayerItem?.Error}");
                }
                else if (PlayerItem?.Status == AVPlayerItemStatus.Failed)
                {
                    Log.Debug($"PlayerItem.Status = Failed | {PlayerItem?.Error}");
                }
            }
            else if (keyPath == AVPlayer_CurrentItem)
            {
                Log.Debug($"ObserveValue: {keyPath} | ");

                CurrentItemChanged?.Invoke(this, Player);
            }
            else
            {
                Log.Debug($"ObserveValue: {keyPath} | ");

                base.ObserveValue(keyPath, ofObject, change, context);
            }
        }
 void CurrentItemPropertyChanged()
 {
     CurrentItemChanged?.Invoke(this, new EventArgs());
 }
Exemple #16
0
        //private void UpdatePopupSize()
        //{
        //    return;
        //    if (_popup == null || lowerThan14393)
        //    {
        //        return;
        //    }
        //    var windowRect = Window.Current.Bounds;
        //    if (DeviceInfo.IsNarrowSrceen)
        //    {
        //        //Gets the visible region of the window (app view). The visible region is the region
        //        //not occluded by chrome such as the status bar and app bar.
        //        windowRect = ApplicationView.GetForCurrentView().VisibleBounds;
        //    }
        //    _popup.Width = windowRect.Width;
        //    _popup.Height = windowRect.Height;
        //}

        private void OnCurrentItemChanged(DependencyPropertyChangedEventArgs e)
        {
            CurrentItemChanged?.Invoke(this, e);
        }