protected void SetSubItems(ListItem item, bool forceUpdate)
{
if (item == null)
{
return;
}
HomeMenuGroup group = item.AdditionalProperties[KEY_ITEM_GROUP] as HomeMenuGroup;
bool fireChange = false;
var actions = _homeProxy.GetGroupActions(group);
if (forceUpdate || SubItemsNeedUpdate(_subItems, actions))
{
_subItemNavigationList.Clear();
_subItems.Clear();
List <SubItem> subItems = CreateSubItems(actions);
CollectionUtils.AddAll(_subItemNavigationList, subItems);
CollectionUtils.AddAll(_subItems, subItems);
fireChange = true;
}
FocusCurrentSubItem(item);
if (fireChange)
{
_subItems.FireChange();
}
}
public override void AddPotentialFocusableElements(RectangleF?startingRect, ICollection <FrameworkElement> elements)
{
ICollection <FrameworkElement> potentialElements = new List <FrameworkElement>();
base.AddPotentialFocusableElements(startingRect, potentialElements);
object restoreFocusItem = RestoreFocusItem;
// Try and find the element that has the restoreFocusItem as Context
if (restoreFocusItem != null && _itemsHostPanel != null)
{
foreach (FrameworkElement potentialElement in potentialElements)
{
Visual element = potentialElement;
while (element != null && element.VisualParent != _itemsHostPanel)
{
element = element.VisualParent;
}
if (element?.Context == restoreFocusItem)
{
// Just add this element to ensure that
// it gets the focus
elements.Add(potentialElement);
return;
}
}
}
// No matching element found, use the default focus selection
CollectionUtils.AddAll(elements, potentialElements);
}
private void LoadPlugins(string playerPluginsDirectory)
{
Log.Info("Loading player add-ins from '{0}'", playerPluginsDirectory);
if (!Directory.Exists(playerPluginsDirectory))
{
Log.Error("Unable to find player add-ins folder '{0}'", playerPluginsDirectory);
return;
}
IDictionary <int, string> plugins = Bass.BASS_PluginLoadDirectory(playerPluginsDirectory);
foreach (string pluginFile in plugins.Values)
{
Log.Debug("Loaded plugin '{0}'", pluginFile);
}
CollectionUtils.AddAll(_decoderPluginHandles, plugins.Keys);
if (plugins.Count == 0)
{
Log.Info("No audio decoders loaded; probably already loaded.");
}
else
{
Log.Info("Loaded {0} audio decoders.", plugins.Count);
}
}
/// <summary>
/// Allows a secondary filter of the already loaded <see cref="Items"/> by the given <paramref name="search"/> term.
/// </summary>
/// <param name="search">Search term (or key)</param>
public virtual void ApplySecondaryFilter(string search)
{
IItemsFilter filter = _filter;
if (filter == null)
{
return;
}
// Init backup list
if (_originalList == null)
{
_originalList = new ItemsList();
CollectionUtils.AddAll(_originalList, _items);
}
filter.Filter(_items, _originalList, search);
IsFiltered = filter.IsFiltered;
if (IsFiltered)
{
// Filter defined by class
NumItemsStr = filter.Text;
}
else
{
// Restore default text
NumItemsStr = Utils.BuildNumItemsStr(NumItems, TotalNumItems);
}
}
public ICollection <DvStateVariable> GetDueEvents()
{
DateTime now = DateTime.Now;
ICollection <DvStateVariable> result = null;
// Continue stepping through the (sorted) list of pending event notifications and collect all
// variables to event until we find an entry which is scheduled in the future
KeyValuePair <DateTime, HashSet <DvStateVariable> >?kvp;
while ((kvp = GetFirstScheduledEventNotification()).HasValue)
{
if (kvp.Value.Key <= now)
{
if (result == null)
{
result = new HashSet <DvStateVariable>();
}
CollectionUtils.AddAll(result, kvp.Value.Value);
_scheduledEventNotifications.RemoveAt(0);
}
else
{
break;
}
}
return(result);
}
protected ICollection <ListItem> CollectSkinResourcesColors(SkinResources resourceBundle)
{
ICollection <ListItem> result = new List <ListItem>();
foreach (KeyValuePair <object, object> localStyleResource in resourceBundle.LocalStyleResources)
{
object key = localStyleResource.Key;
object value = localStyleResource.Value;
object c;
object testString;
int testInt;
if (TypeConverter.Convert(value, typeof(Color), out c))
{
// Avoid conversion of strings containing int values
if (!TypeConverter.Convert(value, typeof(string), out testString) || !int.TryParse((string)testString, out testInt))
{
Color color = (Color)c;
result.Add(BuildColorListItem(key.ToString(), color));
}
}
}
SkinResources inherited = resourceBundle.InheritedSkinResources;
if (inherited != null)
{
CollectionUtils.AddAll(result, CollectSkinResourcesColors(inherited));
}
return(result);
}
public void SaveSharesToSettings()
{
SharesSettings settings = new SharesSettings();
CollectionUtils.AddAll(settings.LocalShares, _shares.Values);
ServiceRegistration.Get <ISettingsManager>().Save(settings);
}
protected ICollection <IFileSystemResourceAccessor> WrapLocalFsResourceAccessors(ICollection <IFileSystemResourceAccessor> localFsResourceAccessors)
{
ICollection <IFileSystemResourceAccessor> result = new List <IFileSystemResourceAccessor>();
CollectionUtils.AddAll(result, localFsResourceAccessors.Select(resourceAccessor => new NetworkNeighborhoodResourceAccessor(_parent, resourceAccessor.Path.Substring(1))));
return(result);
}
private static void SetMultiEpisodeDetailsl(SeriesInfo seriesInfo, List <TvdbEpisode> episodes)
{
seriesInfo.TotalRating = episodes.Sum(e => e.Rating) / episodes.Count; // Average rating
seriesInfo.Episode = string.Join("; ", episodes.OrderBy(e => e.EpisodeNumber).Select(e => e.EpisodeName).ToArray());
seriesInfo.Summary = string.Join("\r\n\r\n", episodes.OrderBy(e => e.EpisodeNumber).
Select(e => string.Format("{0,02}) {1}", e.EpisodeNumber, e.Overview)).ToArray());
// Don't clear seriesInfo.Actors again. It's already been filled with actors from series details.
var guestStars = episodes.SelectMany(e => e.GuestStars).Distinct().ToList();
if (guestStars.Count > 0)
{
CollectionUtils.AddAll(seriesInfo.Actors, guestStars);
}
seriesInfo.Directors.Clear();
var directors = episodes.SelectMany(e => e.Directors).Distinct().ToList();
if (directors.Count > 0)
{
CollectionUtils.AddAll(seriesInfo.Directors, directors);
}
var writers = episodes.SelectMany(e => e.Writer).Distinct().ToList();
seriesInfo.Writers.Clear();
if (writers.Count > 0)
{
CollectionUtils.AddAll(seriesInfo.Writers, writers);
}
}
/// <summary>
/// Tries to lookup the series from TheTvDB and updates the given <paramref name="seriesInfo"/> with the online information (Series and Episode names).
/// </summary>
/// <param name="seriesInfo">Series to check</param>
/// <returns><c>true</c> if successful</returns>
public bool FindAndUpdateSeries(SeriesInfo seriesInfo)
{
TvdbSeries seriesDetail;
if (TryMatch(seriesInfo, false, out seriesDetail))
{
int tvDbId = 0;
if (seriesDetail != null)
{
tvDbId = seriesDetail.Id;
seriesInfo.Series = seriesDetail.SeriesName;
seriesInfo.Actors.Clear();
if (seriesDetail.Actors.Count > 0)
{
CollectionUtils.AddAll(seriesInfo.Actors, seriesDetail.Actors);
}
seriesInfo.Genres.Clear();
if (seriesDetail.Genre.Count > 0)
{
CollectionUtils.AddAll(seriesInfo.Genres, seriesDetail.Genre);
}
// Also try to fill episode title from series details (most file names don't contain episode name).
TryMatchEpisode(seriesInfo, seriesDetail);
}
if (tvDbId > 0)
{
ScheduleDownload(tvDbId);
}
return(true);
}
return(false);
}
/// <summary>
/// Filter remaining keys using an IDictionary of available indexes.
/// </summary>
/// <remarks>
/// The filter is responsible for removing all keys from the passed
/// set of keys that the applicable indexes can prove should be
/// filtered. If the filter does not fully evaluate the remaining
/// keys using just the index information, it must return a filter
/// (which may be an <see cref="IEntryFilter"/>) that can complete the
/// task using an iterating implementation. If, on the other hand, the
/// filter does fully evaluate the remaining keys using just the index
/// information, then it should return <c>null</c> to indicate that no
/// further filtering is necessary.
/// </remarks>
/// <param name="indexes">
/// The available <see cref="ICacheIndex"/> objects keyed by the
/// related IValueExtractor; read-only.
/// </param>
/// <param name="keys">
/// The mutable set of keys that remain to be filtered.
/// </param>
/// <returns>
/// An <see cref="IFilter"/> object that can be used to process the
/// remaining keys, or <c>null</c> if no additional filter processing
/// is necessary.
/// </returns>
public IFilter ApplyIndex(IDictionary indexes, ICollection keys)
{
var index = (ICacheIndex)indexes[ValueExtractor];
if (index == null)
{
// there is no relevant index
return(this);
}
var values = (ICollection)Value;
var setIn = new HashSet();
foreach (object oValue in values)
{
var colEQ = (ICollection)index.IndexContents[oValue];
if (colEQ != null)
{
CollectionUtils.AddAll(setIn, colEQ);
}
}
if (setIn.Count == 0)
{
CollectionUtils.Clear(keys);
}
else
{
CollectionUtils.RetainAll(keys, setIn);
}
return(null);
}
public override async Task <bool> UpdateItemsAsync(int maxItems, UpdateReason updateReason)
{
if (!TryInitTvHandler())
{
return(false);
}
var tvHandlerScheduleControl = _tvHandler.ScheduleControl;
if (tvHandlerScheduleControl == null)
{
return(false);
}
if (!updateReason.HasFlag(UpdateReason.Forced) && !updateReason.HasFlag(UpdateReason.PeriodicMinute))
{
return(true);
}
var scheduleResult = await tvHandlerScheduleControl.GetSchedulesAsync();
if (!scheduleResult.Success)
{
return(false);
}
var schedules = scheduleResult.Result;
var scheduleSortList = new List <Tuple <ISchedule, ProgramProperties> >();
foreach (ISchedule schedule in schedules)
{
var programResult = await tvHandlerScheduleControl.GetProgramsForScheduleAsync(schedule);
if (!programResult.Success || programResult.Result.Count == 0)
{
continue;
}
ProgramProperties programProperties = new ProgramProperties();
programProperties.SetProgram(programResult.Result.OrderBy(p => p.StartTime).First());
scheduleSortList.Add(new Tuple <ISchedule, ProgramProperties>(schedule, programProperties));
}
scheduleSortList.Sort(ChannelAndProgramStartTimeComparison);
var scheduleList = new List <Tuple <ISchedule, ProgramProperties> >(scheduleSortList.Take(maxItems));
if (_currentSchedules.Select(s => s.Item1.ScheduleId).SequenceEqual(scheduleList.Select(s => s.Item1.ScheduleId)))
{
return(true);
}
ListItem[] items = scheduleList.Select(s => CreateScheduleItem(s.Item1, s.Item2)).ToArray();
lock (_allItems.SyncRoot)
{
_currentSchedules = scheduleList;
_allItems.Clear();
CollectionUtils.AddAll(_allItems, items);
}
_allItems.FireChange();
return(true);
}
/// <summary>
/// Add the specified collection of keys to the Bundle.
/// </summary>
/// <note>
/// A call to this method must be externally synchronized for
/// this Bundle object.
/// </note>
/// <param name="colKeys">
/// The collection of keys to add to this Bundle.
/// </param>
/// <returns>
/// True if this Bundle was empty prior to this call.
/// </returns>
public bool AddAll(ICollection colKeys)
{
ICollection setKeys = m_setKeys;
bool isFirst = setKeys.Count == 0;
CollectionUtils.AddAll(setKeys, colKeys);
return(isFirst);
}
/// <summary>
/// Add the specified collection of entries to the Bundle.
/// </summary>
/// <note>
/// A call to this method must be externally synchronized
/// for this Bundle object.
/// </note>
/// <param name="dictionary">
/// The collection of entries.
/// </param>
/// <returns>
/// True if this Bundle was empty prior to this call.
/// </returns>
public bool AddAll(IDictionary dictionary)
{
IDictionary mapEntries = m_mapEntries;
bool isFirst = mapEntries.Count == 0;
CollectionUtils.AddAll(mapEntries, dictionary);
return(isFirst);
}
public void TestAddAllByNullElements()
{
var collection = new List <string> {
"Satish", "Kumar"
};
Assert.Throws <NullReferenceException>(() => CollectionUtils.AddAll(collection, null));
}
public void ExportPlaylistContents(PlaylistContents data)
{
IList <MediaItem> items = data.ItemList;
items.Clear();
lock (_syncObj)
CollectionUtils.AddAll(items, _itemList);
}
public void ExportPlaylistRawData(PlaylistRawData data)
{
IList <Guid> idList = data.MediaItemIds;
idList.Clear();
lock (_syncObj)
CollectionUtils.AddAll(idList, _itemList.Select(item => item.MediaItemId));
}
protected void LoadPendingImportJobs()
{
lock (_syncObj)
{
_importJobs.Clear();
CollectionUtils.AddAll(_importJobs, _settings.Settings.PendingImportJobs);
_importJobsReadyAvailableEvent.Set();
}
}
private void InitPluginAssemblyList()
{
IPluginManager pluginManager = ServiceRegistration.Get <IPluginManager>();
foreach (PluginRuntime plugin in pluginManager.AvailablePlugins.Values)
{
CollectionUtils.AddAll(_knownAssemblies, plugin.Metadata.AssemblyFilePaths);
}
}
protected void CyclePositionedItems()
{
var tmpItems = _nextPageItems.ToList();
_positionedItems.Clear();
CollectionUtils.AddAll(_positionedItems, tmpItems);
SetFocusOnNewPage();
_positionedItems.FireChange();
}
protected void UpdateMediaCategories(ICollection <string> selectedCategories)
{
_mediaCategories.Clear();
if (selectedCategories != null)
{
CollectionUtils.AddAll(_mediaCategories, selectedCategories);
}
IsMediaCategoriesSelected = _mediaCategories.Count > 0;
}
/// <summary>
/// Builds a subquery that returns the ids of the media items returned by the <paramref name="filter"/>.
/// </summary>
/// <param name="filter">Relationship filter instance to create the sub query for.</param>
/// <param name="subqueryFilter">Additional filter to apply to all subqueries.</param>
/// <param name="miaManagement">MIA_Management instance to generate attribute column names.</param>
/// <param name="bvNamespace">Namespace used to build bind var names.</param>
/// <param name="resultParts">Statement parts for the filter.</param>
/// <param name="resultBindVars">Bind variables for the filter.</param>
public static void BuildRelationshipSubquery(AbstractRelationshipFilter filter, IFilter subqueryFilter, MIA_Management miaManagement,
BindVarNamespace bvNamespace, IList <object> resultParts, IList <BindVar> resultBindVars)
{
//Simple relationship filter with linked id
BindVar linkedIdVar = null;
RelationshipFilter relationshipFilter = filter as RelationshipFilter;
if (relationshipFilter != null && relationshipFilter.LinkedMediaItemId != Guid.Empty)
{
linkedIdVar = new BindVar(bvNamespace.CreateNewBindVarName("V"), relationshipFilter.LinkedMediaItemId, typeof(Guid));
resultBindVars.Add(linkedIdVar);
}
//Role
BindVar roleVar = null;
if (filter.Role != Guid.Empty)
{
roleVar = new BindVar(bvNamespace.CreateNewBindVarName("V"), filter.Role, typeof(Guid));
resultBindVars.Add(roleVar);
}
//Linked role
BindVar linkedRoleVar = null;
if (filter.LinkedRole != Guid.Empty)
{
linkedRoleVar = new BindVar(bvNamespace.CreateNewBindVarName("V"), filter.LinkedRole, typeof(Guid));
resultBindVars.Add(linkedRoleVar);
}
//Complex relationship filter with linked filter
string sqlStatement = null;
IList <BindVar> bindVars = null;
FilteredRelationshipFilter filteredRelationshipFilter = filter as FilteredRelationshipFilter;
if (filteredRelationshipFilter != null && filteredRelationshipFilter.Filter != null)
{
//Build a sub query for the linked filter
string idAlias = null;
ICollection <QueryAttribute> requiredAttributes = new List <QueryAttribute>();
SubQueryBuilder filterBuilder = new SubQueryBuilder(miaManagement, requiredAttributes,
new List <MediaItemAspectMetadata>(), filteredRelationshipFilter.Filter, subqueryFilter, bvNamespace.BindVarCounter);
filterBuilder.GenerateSqlStatement(out idAlias, out sqlStatement, out bindVars);
sqlStatement = " SELECT TS." + idAlias + " FROM (" + sqlStatement + ") TS";
bvNamespace.BindVarCounter += bindVars.Count;
CollectionUtils.AddAll(resultBindVars, bindVars);
}
//Relationships are only stored for one party in the relationship so we need to union the query with a query
//that reverses the relationship to ensure that all relationships are selected
BuildRelationshipSubqueryPart(roleVar, linkedRoleVar, linkedIdVar, sqlStatement, false, miaManagement, resultParts);
resultParts.Add(" UNION ");
BuildRelationshipSubqueryPart(roleVar, linkedRoleVar, linkedIdVar, sqlStatement, true, miaManagement, resultParts);
}
public void TestAddAllByInt()
{
var collection = new List <int> {
1, 2
};
var elements = new[] { 3, 4 };
Assert.True(CollectionUtils.AddAll(collection, elements));
Assert.True(collection.Contains(3));
}
public void TestAddAll()
{
var collection = new List <string> {
"Satish", "Kumar"
};
var elements = new[] { "Roronoa", "Zoro" };
Assert.True(CollectionUtils.AddAll(collection, elements));
Assert.True(collection.Contains("Roronoa"));
}
protected ICollection <Guid> GetMetadataExtractorIdsForMediaCategories(IEnumerable <string> mediaCategories)
{
IMediaAccessor mediaAccessor = ServiceRegistration.Get <IMediaAccessor>();
ICollection <Guid> result = new HashSet <Guid>();
foreach (string mediaCategory in mediaCategories)
{
CollectionUtils.AddAll(result, mediaAccessor.GetMetadataExtractorsForCategory(mediaCategory));
}
return(result);
}
protected ICollection <IFileSystemResourceAccessor> WrapLocalFsResourceAccessors(ICollection <IFileSystemResourceAccessor> localFsResourceAccessors)
{
ICollection <IFileSystemResourceAccessor> result = new List <IFileSystemResourceAccessor>();
if (localFsResourceAccessors != null && localFsResourceAccessors.Count > 0)
{
CollectionUtils.AddAll(result, localFsResourceAccessors.Where(resourceAccessor => resourceAccessor != null && resourceAccessor.Path != null).
Select(resourceAccessor => new NetworkNeighborhoodResourceAccessor(_parent, resourceAccessor.Path.Substring(1))));
}
return(result);
}
protected void InitFilter()
{
_actionIds.Clear();
var filter = Filter;
if (string.IsNullOrEmpty(filter))
{
return;
}
CollectionUtils.AddAll(_actionIds, filter.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries).Select(s => new Guid(s)));
}
protected void LoadPendingImportJobs()
{
lock (_syncObj)
{
ISettingsManager settingsManager = ServiceRegistration.Get <ISettingsManager>();
ImporterWorkerSettings settings = settingsManager.Load <ImporterWorkerSettings>();
_importJobs.Clear();
CollectionUtils.AddAll(_importJobs, settings.PendingImportJobs);
_importJobsReadyAvailableEvent.Set();
}
}
protected static ICollection <string> UnrollPathSegments(ResourcePath rp)
{
ICollection <string> result = new List <string>();
foreach (ProviderPathSegment segment in rp._pathSegments)
{
result.Add(segment.ProviderId.ToString());
CollectionUtils.AddAll(result, segment.Path.Split(new char[] { '/' }, StringSplitOptions.RemoveEmptyEntries));
}
return(result);
}
protected bool InitializePropertiesWithShare(Share share, string nativeSystem)
{
_origShare = share;
BaseResourceProvider = GetBaseResourceProviderMetadata(share.BaseResourcePath);
NativeSystem = nativeSystem;
ChoosenResourcePath = share.BaseResourcePath;
ShareName = share.Name;
MediaCategories.Clear();
CollectionUtils.AddAll(MediaCategories, share.MediaCategories);
return(true);
}
