public FilterValue(string title, FilterTreePath relativeFilterPath, IFilter selectAttributeFilter, int numItems, MLFilterCriterion criterion) { _title = title; _relativeFilterPath = relativeFilterPath; _selectAttributeFilter = selectAttributeFilter; _numItems = numItems; _criterion = criterion; }
public FilterValue(string title, FilterTreePath relativeFilterPath, IFilter selectAttributeFilter, MediaItem item, MLFilterCriterion criterion) { _title = title; _relativeFilterPath = relativeFilterPath; _selectAttributeFilter = selectAttributeFilter; _item = item; _criterion = criterion; if (item != null) { _linkedId = item.MediaItemId; } }
protected AbstractSeriesFilterScreenData(string screen, string menuItemLabel, string navbarSubViewNavigationDisplayLabel, MLFilterCriterion filterCriterion) : base(screen, menuItemLabel, navbarSubViewNavigationDisplayLabel, filterCriterion) { _filterPath = new FilterTreePath(SeriesAspect.ROLE_SERIES); _necessaryFilteredMIATypeIds = Consts.NECESSARY_SERIES_MIAS; }
/// <summary> /// Updates the GUI data for a filter values selection screen which reflects the available filter values for /// the current base view specification of our <see cref="AbstractScreenData._navigationData"/>. /// </summary> protected async Task ReloadFilterValuesList(bool createNewList) { MediaLibraryQueryViewSpecification currentVS = _navigationData.BaseViewSpecification as MediaLibraryQueryViewSpecification; if (currentVS == null) { // Should never happen ServiceRegistration.Get <ILogger>().Error("FilterScreenData: Wrong type of media library view '{0}'", _navigationData.BaseViewSpecification); return; } // Control other threads reentering this method lock (_syncObj) { if (_buildingList) { // Another thread is already building the items list - mark it as dirty and let the other thread // rebuild it. _listDirty = true; return; } // Mark the list as being built _buildingList = true; _listDirty = false; } try { ItemsList items; if (createNewList) { items = new ItemsList(); } else { items = _items; items.Clear(); } try { Display_ListBeingBuilt(); IFilter filter = currentVS.FilterTree.BuildFilter(_filterPath); ICollection <Guid> necessaryMIAs = _necessaryFilteredMIATypeIds ?? currentVS.NecessaryMIATypeIds; // If the number of values to create exceeds MAX_NUM_ITEMS_VISIBLE we need to try and group the items. // We request all values first, rather than groups, on the assumption that most of the time the limit // shouldn't be reached given that we are filtering the values. bool grouping = false; ICollection <FilterValue> fv = await _filterCriterion.GetAvailableValuesAsync(necessaryMIAs, _clusterFilter, filter).ConfigureAwait(false); if (fv.Count > Consts.MAX_NUM_ITEMS_VISIBLE && _clusterFilter == null) { ICollection <FilterValue> groupValues = await _filterCriterion.GroupValuesAsync(necessaryMIAs, _clusterFilter, filter).ConfigureAwait(false); if (groupValues != null && groupValues.Count > 0) { fv = groupValues; grouping = true; } } if (fv.Count > Consts.MAX_NUM_ITEMS_VISIBLE) { Display_TooManyItems(fv.Count); } else { bool dirty; lock (_syncObj) dirty = _listDirty; if (dirty) { UpdateOrRebuildView(items, createNewList); return; } _sortable = true; int totalNumItems = 0; List <FilterItem> itemsList = new List <FilterItem>(); // Build collection of available (filter/display) screens which will remain in the next view - that is all currently // available screens without the screen which equals this current screen. But we cannot simply remove "this" // from the collection, because "this" could be a derived screen (in case our base screen showed groups). // So we need an equality criterion when the screen to be removed is equal to this screen in terms of its // filter criterion. But with the given data, we actually cannot derive that equality. // So we simply use the MenuItemLabel, which should be the same in this and the base screen of the same filter. foreach (FilterValue f in fv) { //Used for enclosure FilterValue filterValue = f; _sortable &= filterValue.Item != null; string filterTitle = filterValue.Title; IFilter selectAttributeFilter = filterValue.SelectAttributeFilter; MediaLibraryQueryViewSpecification subVS = currentVS.CreateSubViewSpecification(filterTitle, FilterTreePath.Combine(_filterPath, filterValue.RelativeFilterPath), filterValue.Filter, filterValue.LinkedId); T filterValueItem = new T { // Support non-playable MediaItems (i.e. Series, Seasons) MediaItem = filterValue.Item, SimpleTitle = filterTitle, NumItems = filterValue.NumItems, Id = filterValue.Id, Command = new MethodDelegateCommand(() => { if (grouping) { NavigateToGroup(subVS, selectAttributeFilter); } else { NavigateToSubView(subVS); } }), View = subVS.BuildView() }; itemsList.Add(filterValueItem); if (filterValue.NumItems.HasValue) { totalNumItems += filterValue.NumItems.Value; } } if (_sortable) { Sorting.Sorting sorting = CurrentSorting; if (sorting != null) { itemsList.Sort((i1, i2) => sorting.Compare(i1.MediaItem, i2.MediaItem)); } } // Derived classes can implement special initial selection handling here, // e.g. the first unwatched episode could be selected from a list of episodes SetSelectedItem(itemsList); CollectionUtils.AddAll(items, itemsList); Display_Normal(items.Count, totalNumItems == 0 ? new int?() : totalNumItems); } } catch (Exception e) { ServiceRegistration.Get <ILogger>().Warn("AbstractFiltersScreenData: Error creating filter values list", e); Display_ItemsInvalid(); } UpdateOrRebuildView(items, createNewList); } finally { lock (_syncObj) _buildingList = false; } }
public MediaLibraryQueryViewSpecification CreateSubViewSpecification(string viewDisplayName, FilterTreePath filterPath, IFilter filter, Guid?linkedId) { IFilterTree newFilterTree = _filterTree.DeepCopy(); if (linkedId.HasValue) { newFilterTree.AddLinkedId(linkedId.Value, filterPath); } else if (filter != null) { newFilterTree.AddFilter(filter, filterPath); } return(new MediaLibraryQueryViewSpecification(viewDisplayName, newFilterTree, _necessaryMIATypeIds, _optionalMIATypeIds, _onlyOnline) { MaxNumItems = _maxNumItems, FilterPath = filterPath }); }