zune/ZuneShell.dll
0
0
Fork 0
mirror of https://github.com/ZuneDev/ZuneShell.dll.git synced 2026-07-27 13:11:51 -07:00
Code Issues Packages Projects Releases Wiki Activity
Files
5d7546edafbb0e97ba6993dddbce40958753f1c4
ZuneShell.dll/ZuneUI/Management.cs
T

2189 lines
96 KiB
C#
Raw Blame History

// Decompiled with JetBrains decompiler
// Type: ZuneUI.Management
// Assembly: ZuneShell, Version=4.7.0.0, Culture=neutral, PublicKeyToken=ddd0da4d3e678217
// MVID: FC8028F3-A47B-4FB4-B35B-11D1752D8264
// Assembly location: C:\Program Files\Zune\ZuneShell.dll
using Microsoft.Iris;
using Microsoft.Zune.Configuration;
using Microsoft.Zune.Shell;
using Microsoft.Zune.Subscription;
using Microsoft.Zune.Util;
using MicrosoftZuneLibrary;
using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.IO;
using System.Threading;
using UIXControls;
namespace ZuneUI
{
public class Management : ModelItem
{
private static CategoryPage _currentCategoryPage;
private Category _alertedDeviceCategory;
private DeviceManagement _deviceManagement;
private bool _deviceManagementLocked;
private CommitListHashtable _commitList;
private bool _hasPendingCommits;
private bool _changeRequiresElevation;
private BooleanChoice _sqmChoice;
private ListDataSet _monitoredAudioFolders;
private ListDataSet _monitoredPhotoFolders;
private ListDataSet _monitoredPodcastFolders;
private ListDataSet _monitoredVideoFolders;
private BooleanChoice _mediaInfoChoice;
private BooleanChoice _metadataChoice;
private List<MonitoredFolder> _removedMonitoredFoldersToRemoveFromCollection;
private ProxySettingDelegate[] _actionsToCommitOnLibraryIntegrate;
private Choice _podcastDefaultKeepEpisodesChoice;
private Choice _podcastPlaybackChoice;
private string[] _defaultFileTypeExtensions = new string[7]
{
".mp3",
".m4a",
".mp4",
".m4b",
".m4v",
".mbr",
".zpl"
};
private IFileAssociationHandler _fileAssocHandler;
private IList<BooleanInputChoice> _allFileTypes;
private IList<BooleanInputChoice> _audioFileTypes;
private IList<BooleanInputChoice> _videoFileTypes;
private IList<FileAssociationInfo> _fileAssociationInfoList;
private bool _canFileAssociationBeChanged;
private ITunerInfoHandler _tunerHandler;
private ArrayListDataSet _registeredComputersModelList;
private ArrayListDataSet _registeredDevicesModelList;
private ArrayListDataSet _registeredAppStoreDevicesModelList;
private string _nextPCDeregistrationDate;
private string _nextSubscriptionDeviceDeregistrationDate;
private string _nextAppStoreDeviceDeregistrationDate;
private IntRangedValue _slideShowSpeed;
private Choice _burnDiscFormat;
private BooleanChoice _autoEjectCDAfterBurn;
private Choice _burnSpeed;
private Choice _recordMode;
private Choice _recordRate;
private BooleanChoice _autoCopyCD;
private BooleanChoice _autoEjectCD;
private string _mediaFolder;
private string _videoMediaFolder;
private string _photoMediaFolder;
private string _podcastMediaFolder;
private Choice _wmaRate;
private Choice _wmavRate;
private Choice _mp3Rate;
private string _sharingError;
private string _sharingDisplayName;
private BooleanChoice _sharingEnableMusic;
private BooleanChoice _sharingEnableVideo;
private BooleanChoice _sharingEnablePhoto;
private Choice _sharingSelectDeviceChoice;
private IList<Command> _sharingSelectDeviceOptions;
private bool _sharingAllDevicesEnabled;
private IList<BooleanInputChoice> _sharingDeviceList;
private uint _sharingDeviceIndex;
private HMESettings _HME;
private bool _nssDeviceListChangeEventAdded;
private string _backgroundImage;
private WindowColor _backgroundColor;
private BooleanChoice _showNowPlayingBackgroundOnIdle;
private Choice _screenGraphicsSlider;
private BooleanChoice _playSounds;
private BooleanChoice _compactModeAlwaysOnTop;
private BooleanChoice _ratingsChoice;
private BooleanChoice _applyRatingsChoice;
private Choice _startupPageChoice;
private bool _autoLaunchZuneOnConnect;
private object mylock = new object();
public Management()
{
this._autoLaunchZuneOnConnect = ClientConfiguration.Devices.AutoLaunchZuneOnConnect;
ClientConfiguration.Groveler.OnConfigurationChanged += new ConfigurationChangeEventHandler(this.OnGrovelerConfigurationChanged);
this._actionsToCommitOnLibraryIntegrate = new ProxySettingDelegate[5]
{
new ProxySettingDelegate(this.OnMonitoredFoldersCommit),
new ProxySettingDelegate(this.OnMediaFolderCommit),
new ProxySettingDelegate(this.OnVideoMediaFolderCommit),
new ProxySettingDelegate(this.OnPhotoMediaFolderCommit),
new ProxySettingDelegate(this.OnPodcastMediaFolderCommit)
};
}
protected override void OnDispose(bool disposing)
{
if (disposing)
{
this.DisposeDeviceManagement(true);
ClientConfiguration.Groveler.OnConfigurationChanged -= new ConfigurationChangeEventHandler(this.OnGrovelerConfigurationChanged);
}
if (this._fileAssocHandler != null)
{
((IDisposable)this._fileAssocHandler).Dispose();
this._fileAssocHandler = null;
}
base.OnDispose(disposing);
}
private IFileAssociationHandler FileAssocHandler
{
get
{
if (this._fileAssocHandler == null)
this._fileAssocHandler = FileAssociationHandlerFactory.CreateFileAssociationHandler();
return this._fileAssocHandler;
}
}
public DeviceManagement DeviceManagement
{
get
{
if (this._deviceManagement == null && !this.DeviceManagementLocked)
this._deviceManagement = new DeviceManagement();
return this._deviceManagement;
}
}
public bool DeviceManagementLocked
{
get => this._deviceManagementLocked;
private set
{
if (this._deviceManagementLocked == value)
return;
this._deviceManagementLocked = value;
this.FirePropertyChanged(nameof(DeviceManagementLocked));
}
}
public void DisposeDeviceManagement(bool deviceManagementLocked)
{
this.DeviceManagementLocked = deviceManagementLocked;
if (this._deviceManagement == null)
return;
UIDevice currentDeviceOverride = SyncControls.Instance.CurrentDeviceOverride;
if (currentDeviceOverride.IsValid)
{
this.CommitList.RemoveByIntValue(currentDeviceOverride.IsGuest ? -1 : currentDeviceOverride.ID);
this.CommitList.RemoveByStringValue("OnSyncPartnershipCommit");
}
else
this.CommitList.RemoveByIntValue(-1);
this._deviceManagement.Dispose();
this._deviceManagement = null;
this.FirePropertyChanged("DeviceManagementChanged");
}
public bool DeviceManagementChanged => true;
public CommitListHashtable CommitList
{
get
{
if (this._commitList == null)
this._commitList = new CommitListHashtable();
return this._commitList;
}
set
{
if (this._commitList == value)
return;
this._commitList = value;
this.FirePropertyChanged(nameof(CommitList));
if (value != null)
return;
this.HasPendingCommits = false;
}
}
public bool HasPendingCommits
{
get => this._hasPendingCommits;
internal set
{
if (this._hasPendingCommits == value)
return;
this._hasPendingCommits = value;
this.FirePropertyChanged(nameof(HasPendingCommits));
}
}
public bool ActiveDeviceHasPendingCommits => this.CommitList.ContainsIntValue(SyncControls.Instance.CurrentDevice.ID);
public bool ChangeRequiresElevation
{
get => this._changeRequiresElevation;
set
{
if (this._changeRequiresElevation == value)
return;
this._changeRequiresElevation = value;
this.FirePropertyChanged(nameof(ChangeRequiresElevation));
}
}
public string BuildNumber => VersionInfo.BuildNumber;
public Choice RecordMode
{
get
{
if (this._recordMode == null)
{
this._wmaRate = new Choice(this);
this._wmaRate.Options = (new NamedIntOption[6]
{
new NamedIntOption( null, Shell.LoadString(StringId.IDS_RIP_WMA_48), 48000),
new NamedIntOption( null, Shell.LoadString(StringId.IDS_RIP_WMA_64), 64000),
new NamedIntOption( null, Shell.LoadString(StringId.IDS_RIP_WMA_96), 96000),
new NamedIntOption( null, Shell.LoadString(StringId.IDS_RIP_WMA_128), 128000),
new NamedIntOption( null, Shell.LoadString(StringId.IDS_RIP_WMA_160), 160000),
new NamedIntOption( null, Shell.LoadString(StringId.IDS_RIP_WMA_192), 192000)
});
NamedIntOption.SelectOptionByValue(this._wmaRate, ClientConfiguration.Recorder.WMARecordRate);
this._wmaRate.ChosenChanged += (sender, args) => this.CommitList[new ProxySettingDelegate(this.OnWmaRateCommit)] = null;
this._wmavRate = new Choice(this);
this._wmavRate.Options = (new NamedIntOption[5]
{
new NamedIntOption( null, Shell.LoadString(StringId.IDS_RIP_WMAV_25), 25),
new NamedIntOption( null, Shell.LoadString(StringId.IDS_RIP_WMAV_50), 50),
new NamedIntOption( null, Shell.LoadString(StringId.IDS_RIP_WMAV_75), 75),
new NamedIntOption( null, Shell.LoadString(StringId.IDS_RIP_WMAV_90), 90),
new NamedIntOption( null, Shell.LoadString(StringId.IDS_RIP_WMAV_98), 98)
});
NamedIntOption.SelectOptionByValue(this._wmavRate, ClientConfiguration.Recorder.WMAVBRRecordQuality);
this._wmavRate.ChosenChanged += (sender, args) => this.CommitList[new ProxySettingDelegate(this.OnWmavRateCommit)] = null;
this._mp3Rate = new Choice(this);
this._mp3Rate.Options = (new NamedIntOption[4]
{
new NamedIntOption( null, Shell.LoadString(StringId.IDS_RIP_MP3_128), 128000),
new NamedIntOption( null, Shell.LoadString(StringId.IDS_RIP_MP3_192), 192000),
new NamedIntOption( null, Shell.LoadString(StringId.IDS_RIP_MP3_256), 256000),
new NamedIntOption( null, Shell.LoadString(StringId.IDS_RIP_MP3_320), 320000)
});
NamedIntOption.SelectOptionByValue(this._mp3Rate, ClientConfiguration.Recorder.MP3RecordRate);
this._mp3Rate.ChosenChanged += (sender, args) => this.CommitList[new ProxySettingDelegate(this.OnMp3RateCommit)] = null;
this._recordMode = new Choice(this);
this._recordMode.Options = (new RecordModeOption[4]
{
new RecordModeOption( null, Shell.LoadString(StringId.IDS_WMA_OPTION), 0, this._wmaRate),
new RecordModeOption( null, Shell.LoadString(StringId.IDS_WMA_VARIABLE_OPTION), 3, this._wmavRate),
new RecordModeOption( null, Shell.LoadString(StringId.IDS_WMA_LOSSLESS_OPTION), 1, null),
new RecordModeOption( null, Shell.LoadString(StringId.IDS_MP3_OPTION), 2, this._mp3Rate)
});
NamedIntOption.SelectOptionByValue(this._recordMode, ClientConfiguration.Recorder.RecordMode);
this._recordMode.ChosenChanged += (sender, args) =>
{
this.CommitList[new ProxySettingDelegate(this.OnRecordModeCommit)] = null;
this.RecordRate = ((RecordModeOption)this._recordMode.ChosenValue).BitRate;
};
this.RecordRate = ((RecordModeOption)this._recordMode.ChosenValue).BitRate;
}
return this._recordMode;
}
}
private void OnWmaRateCommit(object data) => ClientConfiguration.Recorder.WMARecordRate = ((NamedIntOption)this._wmaRate.ChosenValue).Value;
private void OnWmavRateCommit(object data) => ClientConfiguration.Recorder.WMAVBRRecordQuality = ((NamedIntOption)this._wmavRate.ChosenValue).Value;
private void OnMp3RateCommit(object data) => ClientConfiguration.Recorder.MP3RecordRate = ((NamedIntOption)this._mp3Rate.ChosenValue).Value;
private void OnRecordModeCommit(object data) => ClientConfiguration.Recorder.RecordMode = ((NamedIntOption)this._recordMode.ChosenValue).Value;
public Choice RecordRate
{
get => this._recordRate;
private set
{
if (this._recordRate == value)
return;
this._recordRate = value;
this.FirePropertyChanged(nameof(RecordRate));
}
}
public Category AlertedDeviceCategory
{
get => this._alertedDeviceCategory;
set
{
if (this._alertedDeviceCategory == value)
return;
if (_currentCategoryPage != null && value != null && this._alertedDeviceCategory != null)
{
_currentCategoryPage.CurrentCategory = this._alertedDeviceCategory;
this._alertedDeviceCategory = null;
}
else
{
this._alertedDeviceCategory = value;
this.FirePropertyChanged(nameof(AlertedDeviceCategory));
}
}
}
public CategoryPage CurrentCategoryPage
{
get => _currentCategoryPage;
set
{
if (_currentCategoryPage == value)
return;
_currentCategoryPage = value;
this.FirePropertyChanged(nameof(CurrentCategoryPage));
}
}
public static void NavigateToSetupLandWizard(SetupLandPage page) => NavigateAwayFromCategory(new SetupLandWizardNavigationCommand(page));
public static void NavigateToCategory(Category category)
{
if (ZuneShell.DefaultInstance.Management.CurrentCategoryPage == null)
return;
ZuneShell.DefaultInstance.Management.CurrentCategoryPage.CurrentCategory = category;
}
public static void NavigateAwayFromCategory(Command confirmed)
{
Management management = ZuneShell.DefaultInstance.Management;
if (management.HasPendingCommits)
{
Command yesCommand = new Command(null, Shell.LoadString(StringId.IDS_DIALOG_YES), null);
yesCommand.Invoked += (sender, args) =>
{
management.CommitListSave();
NavigateAwayFromCategory(confirmed);
};
Command noCommand = new Command(null, Shell.LoadString(StringId.IDS_DIALOG_NO), null);
noCommand.Invoked += (sender, args) =>
{
management.CommitList = null;
NavigateAwayFromCategory(confirmed);
};
MessageBox.Show(Shell.LoadString(StringId.IDS_SAVE_CHANGES_DIALOG_TITLE), Shell.LoadString(StringId.IDS_SAVE_CHANGES_ON_BACK_DIALOG_TEXT), yesCommand, noCommand, null);
}
else
{
if (Shell.SettingsFrame.IsCurrent && !Shell.SettingsFrame.Wizard.FUE.IsCurrent && management.CurrentCategoryPage != null)
management.CurrentCategoryPage.CancelAndExit();
Application.DeferredInvoke(delegate
{
confirmed?.Invoke();
}, null);
}
}
public void CommitListSave()
{
this.CheckForAutomatedRequirements();
this.CommitList.Save();
}
public void CheckForAutomatedRequirements()
{
if (DeviceManagement.SetupDevice == null)
return;
this.DeviceManagement.CheckForAutomatedRequirements();
}
public bool CanFileAssociationBeChanged
{
get => this._canFileAssociationBeChanged;
private set
{
if (this._canFileAssociationBeChanged == value)
return;
this._canFileAssociationBeChanged = value;
this.FirePropertyChanged(nameof(CanFileAssociationBeChanged));
}
}
public SubscriptionState SubscribeToChannelFeed(
bool isPersonalChannel,
Guid channelId,
string feedUrl,
string title,
ESubscriptionSource source)
{
return this.SubscribeToFeed(feedUrl, title, channelId, isPersonalChannel, source, EMediaTypes.eMediaTypePlaylist, Shell.LoadString(StringId.IDS_PLAYLIST_SUBSCRIPTION_ERROR));
}
public SubscriptionState SubscribeToPodcastFeed(
string feedUrl,
string title,
ESubscriptionSource source)
{
return this.SubscribeToPodcastFeed(feedUrl, title, Guid.Empty, source);
}
public SubscriptionState SubscribeToPodcastFeed(
string feedUrl,
string title,
Guid serviceId,
ESubscriptionSource source)
{
return this.SubscribeToFeed(feedUrl, title, serviceId, false, source, EMediaTypes.eMediaTypePodcastSeries, Shell.LoadString(StringId.IDS_PODCAST_SUBSCRIPTION_ERROR));
}
private SubscriptionState SubscribeToFeed(
string feedUrl,
string title,
Guid serviceId,
bool isPersonalChannel,
ESubscriptionSource source,
EMediaTypes mediaType,
string errorDialogHeader)
{
int subscriptionMediaId = 0;
SubscriptionState subscriptionState = null;
HRESULT hresult = SubscriptionManager.Instance.Subscribe(feedUrl, title, serviceId, isPersonalChannel, mediaType, source, out subscriptionMediaId);
if (hresult.IsSuccess)
subscriptionState = new SubscriptionState(true, true, subscriptionMediaId);
else
ErrorDialogInfo.Show(hresult.Int, errorDialogHeader);
return subscriptionState;
}
public SubscriptionState GetSubscriptionState(
string feedURL,
EMediaTypes subscriptionType)
{
if (string.IsNullOrEmpty(feedURL))
return null;
try
{
int subscriptionMediaId = -1;
bool isSubscribed;
bool byUrl = SubscriptionManager.Instance.FindByUrl(feedURL, subscriptionType, out subscriptionMediaId, out isSubscribed);
return new SubscriptionState(isSubscribed, byUrl, subscriptionMediaId);
}
catch (ApplicationException ex)
{
}
return null;
}
public SubscriptionState GetSubscriptionState(
Guid serviceId,
EMediaTypes subscriptionType)
{
if (serviceId == Guid.Empty)
return null;
try
{
int subscriptionMediaId = -1;
bool isSubscribed;
bool byServiceId = SubscriptionManager.Instance.FindByServiceId(serviceId, subscriptionType, out subscriptionMediaId, out isSubscribed);
return new SubscriptionState(isSubscribed, byServiceId, subscriptionMediaId);
}
catch (ApplicationException ex)
{
}
return null;
}
private void OnGrovelerConfigurationChanged(object sender, ConfigurationChangeEventArgs e) => Application.DeferredInvoke(delegate
{
if (!this.UsingWin7Libraries)
return;
if (e.PropertyName == "RipDirectory" || e.PropertyName == "MonitoredAudioFolders")
{
if (this._monitoredAudioFolders != null)
{
this._monitoredAudioFolders = null;
this.FirePropertyChanged("MonitoredAudioFolders");
}
if (this._mediaFolder == null)
return;
this._mediaFolder = null;
this.FirePropertyChanged("MediaFolder");
}
else if (e.PropertyName == "PhotoMediaFolder" || e.PropertyName == "MonitoredPhotoFolders")
{
if (this._monitoredPhotoFolders != null)
{
this._monitoredPhotoFolders = null;
this.FirePropertyChanged("MonitoredPhotoFolders");
}
if (this._photoMediaFolder == null)
return;
this._photoMediaFolder = null;
this.FirePropertyChanged("PhotoMediaFolder");
}
else if (e.PropertyName == "PodcastMediaFolder" || e.PropertyName == "MonitoredPodcastFolders")
{
if (this._monitoredPodcastFolders != null)
{
this._monitoredPodcastFolders = null;
this.FirePropertyChanged("MonitoredPodcastFolders");
}
if (this._podcastMediaFolder == null)
return;
this._podcastMediaFolder = null;
this.FirePropertyChanged("PodcastMediaFolder");
}
else
{
if (!(e.PropertyName == "VideoMediaFolder") && !(e.PropertyName == "MonitoredVideoFolders"))
return;
if (this._monitoredVideoFolders != null)
{
this._monitoredVideoFolders = null;
this.FirePropertyChanged("MonitoredVideoFolders");
}
if (this._videoMediaFolder == null)
return;
this._videoMediaFolder = null;
this.FirePropertyChanged("VideoMediaFolder");
}
}, null);
public ListDataSet MonitoredAudioFolders
{
get
{
if (this._monitoredAudioFolders == null)
{
if (this.UsingWin7Libraries)
this._monitoredAudioFolders = this.StringsToListDataSet(ClientConfiguration.Groveler.RipDirectory, ClientConfiguration.Groveler.MonitoredAudioFolders);
else
this._monitoredAudioFolders = this.StringsToListDataSet((object)ClientConfiguration.Groveler.MonitoredAudioFolders);
}
return this._monitoredAudioFolders;
}
}
public ListDataSet MonitoredPhotoFolders
{
get
{
if (this._monitoredPhotoFolders == null)
{
if (this.UsingWin7Libraries)
this._monitoredPhotoFolders = this.StringsToListDataSet(ClientConfiguration.Groveler.PhotoMediaFolder, ClientConfiguration.Groveler.MonitoredPhotoFolders);
else
this._monitoredPhotoFolders = this.StringsToListDataSet((object)ClientConfiguration.Groveler.MonitoredPhotoFolders);
}
return this._monitoredPhotoFolders;
}
}
public ListDataSet MonitoredPodcastFolders
{
get
{
if (this._monitoredPodcastFolders == null)
{
if (this.UsingWin7Libraries)
this._monitoredPodcastFolders = this.StringsToListDataSet(ClientConfiguration.Groveler.PodcastMediaFolder, ClientConfiguration.Groveler.MonitoredPodcastFolders);
else
this._monitoredPodcastFolders = this.StringsToListDataSet((object)ClientConfiguration.Groveler.MonitoredPodcastFolders);
}
return this._monitoredPodcastFolders;
}
}
public ListDataSet MonitoredVideoFolders
{
get
{
if (this._monitoredVideoFolders == null)
{
if (this.UsingWin7Libraries)
this._monitoredVideoFolders = this.StringsToListDataSet(ClientConfiguration.Groveler.VideoMediaFolder, ClientConfiguration.Groveler.MonitoredVideoFolders);
else
this._monitoredVideoFolders = this.StringsToListDataSet((object)ClientConfiguration.Groveler.MonitoredVideoFolders);
}
return this._monitoredVideoFolders;
}
}
public bool Win7LibrariesAreAvailable => OSVersion.IsWin7();
public bool UsingWin7Libraries => this.Win7LibrariesAreAvailable && ClientConfiguration.Groveler.LibrarySync != -1;
public void UseWin7Libraries()
{
foreach (ProxySettingDelegate proxySettingDelegate in this._actionsToCommitOnLibraryIntegrate)
{
if (this.CommitList.ContainsKey(proxySettingDelegate))
{
this.CommitList.Remove(proxySettingDelegate);
proxySettingDelegate(null);
}
}
SQMLog.Log(SQMDataId.ZuneWin7LibraryOpt, 0);
this.SetWin7LibrariesUsage(Win7LibrariesUsage.BeginIntegration);
}
public void DoNotUseWin7Libraries()
{
SQMLog.Log(SQMDataId.ZuneWin7LibraryOpt, 1);
this.SetWin7LibrariesUsage(Win7LibrariesUsage.DoNotIntegrate);
}
private void SetWin7LibrariesUsage(Win7LibrariesUsage usage)
{
ClientConfiguration.Groveler.LibrarySync = (int)usage;
this.FirePropertyChanged("UsingWin7Libraries");
}
private ListDataSet StringsToListDataSet(params object[] source)
{
ListDataSet listDataSet = new ArrayListDataSet(this);
if (source != null && source.Length > 0)
{
Dictionary<string, object> dictionary = new Dictionary<string, object>();
foreach (object obj in source)
{
if (obj != null)
{
if (!(obj is IEnumerable<string> strings))
strings = (new string[1]
{
obj.ToString()
});
if (strings != null)
{
foreach (string str in strings)
{
if (!string.IsNullOrEmpty(str))
{
string lower = str.ToLower();
if (!dictionary.ContainsKey(lower))
{
dictionary.Add(lower, null);
listDataSet.Add(str);
}
}
}
}
}
}
}
listDataSet.Sort();
return listDataSet;
}
private IList<string> ListDataSetToIList(ListDataSet listDataSet)
{
if (listDataSet == null)
return new List<string>();
IList<string> stringList = new List<string>(listDataSet.Count);
for (int itemIndex = 0; itemIndex < listDataSet.Count; ++itemIndex)
stringList.Add((string)listDataSet[itemIndex]);
return stringList;
}
internal bool IsMonitored(ListDataSet monitoredFolders, string path)
{
DirectoryInfo directoryInfo = new DirectoryInfo(path);
foreach (string monitoredFolder in monitoredFolders)
{
if (this.IsSubfolder(monitoredFolder, path))
return true;
}
return false;
}
private bool IsSubfolder(string root, string subfolder)
{
try
{
for (; subfolder != null; subfolder = Path.GetDirectoryName(subfolder))
{
if (subfolder.Equals(root, StringComparison.OrdinalIgnoreCase))
return true;
}
}
catch (ArgumentException ex)
{
}
catch (PathTooLongException ex)
{
}
return false;
}
public void AddMonitoredFolder(ListDataSet monitoredFolders) => FolderBrowseDialog.Show(Shell.LoadString(StringId.IDS_ADD_MONITORED_FOLDER_DIALOG_TITLE), args =>
{
if (args == null)
return;
string str = (string)args;
if (ZuneApplication.ZuneLibrary.CanAddFromFolder(str))
this.AddMonitoredFolder(monitoredFolders, str, false);
else
MessageBox.Show(Shell.LoadString(StringId.IDS_INVALID_MONITORED_FOLDER_TITLE), Shell.LoadString(StringId.IDS_INVALID_MONITORED_FOLDER_MESSAGE), null);
});
public void AddMonitoredFolder(ListDataSet monitoredFolders, string path, bool commit)
{
bool flag = false;
for (int itemIndex = 0; itemIndex < monitoredFolders.Count; ++itemIndex)
{
if (monitoredFolders[itemIndex].Equals(path))
{
flag = true;
break;
}
}
if (!flag)
monitoredFolders.Add(path);
this.SaveMonitoredFolders(commit);
}
public void OpenMediaFile() => FileOpenDialog.Show(Shell.LoadString(StringId.IDS_OPEN_FILE_DIALOG_TITLE), this.MediaFolder, args => { });
public bool RemoveChildMonitoredFolders(string path, bool commit)
{
bool flag = false | this.RemoveChildMonitoredFolders(this.MonitoredAudioFolders, EMediaTypes.eMediaTypeAudio, path) | this.RemoveChildMonitoredFolders(this.MonitoredPhotoFolders, EMediaTypes.eMediaTypeImage, path) | this.RemoveChildMonitoredFolders(this.MonitoredPodcastFolders, EMediaTypes.eMediaTypePodcastEpisode, path) | this.RemoveChildMonitoredFolders(this.MonitoredVideoFolders, EMediaTypes.eMediaTypeVideo, path);
this.SaveMonitoredFolders(commit);
return flag;
}
private bool RemoveChildMonitoredFolders(
ListDataSet monitoredFolders,
EMediaTypes type,
string path)
{
EWin7LibraryKind libraryKind;
switch (type)
{
case EMediaTypes.eMediaTypeAudio:
libraryKind = EWin7LibraryKind.eMusicLibrary;
break;
case EMediaTypes.eMediaTypeVideo:
libraryKind = EWin7LibraryKind.eVideoLibrary;
break;
case EMediaTypes.eMediaTypeImage:
libraryKind = EWin7LibraryKind.ePicturesLibrary;
break;
case EMediaTypes.eMediaTypePodcastEpisode:
libraryKind = EWin7LibraryKind.ePodcastLibrary;
break;
default:
return false;
}
List<int> intList = new List<int>();
for (int itemIndex = 0; itemIndex < monitoredFolders.Count; ++itemIndex)
{
if (this.IsSubfolder(path, (string)monitoredFolders[itemIndex]))
intList.Add(itemIndex);
}
foreach (int num in intList)
{
if (this.UsingWin7Libraries)
Win7ShellManager.Instance.RemoveLocationFromLibrary(libraryKind, out bool _, (string)monitoredFolders[num]);
else
this.RemoveMonitoredFolder(monitoredFolders, num, type);
}
return intList.Count > 0;
}
public void RemoveMonitoredFolder(ListDataSet monitoredFolders, string path, bool commit)
{
for (int index = 0; index < monitoredFolders.Count; ++index)
{
if (path.Equals((string)monitoredFolders[index], StringComparison.OrdinalIgnoreCase))
{
this.RemoveMonitoredFolder(monitoredFolders, index, commit);
break;
}
}
}
private void RemoveMonitoredFolder(ListDataSet monitoredFolders, int index) => this.RemoveMonitoredFolder(monitoredFolders, index, false);
public void RemoveMonitoredFolder(
ListDataSet monitoredFolders,
int index,
EMediaTypes mediaType)
{
if (this._removedMonitoredFoldersToRemoveFromCollection == null)
this._removedMonitoredFoldersToRemoveFromCollection = new List<MonitoredFolder>();
this._removedMonitoredFoldersToRemoveFromCollection.Add(new MonitoredFolder((string)monitoredFolders[index], mediaType));
this.RemoveMonitoredFolder(monitoredFolders, index, false);
}
private void RemoveMonitoredFolder(ListDataSet monitoredFolders, int index, bool commit)
{
monitoredFolders.RemoveAt(index);
this.SaveMonitoredFolders(commit);
}
private void SaveMonitoredFolders() => this.SaveMonitoredFolders(false);
public void SaveMonitoredFolders(bool commit)
{
if (commit)
this.OnMonitoredFoldersCommit(null);
else
this.CommitList[new ProxySettingDelegate(this.OnMonitoredFoldersCommit)] = null;
}
public void OpenLibraryDialog(EMediaTypes mediaType)
{
IntPtr winHandle = Application.Window.Handle;
Thread thread = new Thread(args =>
{
EWin7LibraryKind libraryKind = EWin7LibraryKind.eMusicLibrary;
switch (mediaType)
{
case EMediaTypes.eMediaTypeAudio:
libraryKind = EWin7LibraryKind.eMusicLibrary;
break;
case EMediaTypes.eMediaTypeVideo:
libraryKind = EWin7LibraryKind.eVideoLibrary;
break;
case EMediaTypes.eMediaTypeImage:
libraryKind = EWin7LibraryKind.ePicturesLibrary;
break;
case EMediaTypes.eMediaTypePodcastEpisode:
libraryKind = EWin7LibraryKind.ePodcastLibrary;
break;
}
Win7ShellManager.Instance.ShowLibraryDialog(libraryKind, winHandle, null, null);
});
thread.TrySetApartmentState(ApartmentState.STA);
thread.Start();
}
private void OnMonitoredFoldersCommit(object data)
{
SQMLog.LogToStream(SQMDataId.MonitoredAudioFolders, (uint)this.MonitoredAudioFolders.Count);
SQMLog.LogToStream(SQMDataId.MonitoredPhotoFolders, (uint)this.MonitoredPhotoFolders.Count);
SQMLog.LogToStream(SQMDataId.MonitoredPodcastFolders, (uint)this.MonitoredPodcastFolders.Count);
SQMLog.LogToStream(SQMDataId.MonitoredVideoFolders, (uint)this.MonitoredVideoFolders.Count);
if (!this.UsingWin7Libraries)
{
if (this._removedMonitoredFoldersToRemoveFromCollection != null)
{
foreach (MonitoredFolder foldersToRemoveFrom in this._removedMonitoredFoldersToRemoveFromCollection)
ZuneApplication.ZuneLibrary.DeleteRootFolder(foldersToRemoveFrom.Path, foldersToRemoveFrom.Schema);
}
ClientConfiguration.Groveler.MonitoredAudioFolders = this.ListDataSetToIList(this.MonitoredAudioFolders);
ClientConfiguration.Groveler.MonitoredPhotoFolders = this.ListDataSetToIList(this.MonitoredPhotoFolders);
ClientConfiguration.Groveler.MonitoredPodcastFolders = this.ListDataSetToIList(this.MonitoredPodcastFolders);
ClientConfiguration.Groveler.MonitoredVideoFolders = this.ListDataSetToIList(this.MonitoredVideoFolders);
this._removedMonitoredFoldersToRemoveFromCollection = null;
this._monitoredAudioFolders = null;
this._monitoredPhotoFolders = null;
this._monitoredPodcastFolders = null;
this._monitoredVideoFolders = null;
}
if (!this.HME.SharingEnabled)
return;
this.HME.SetSharedFoldersList(true);
}
public BooleanChoice AutoCopyCD
{
get
{
if (this._autoCopyCD == null)
{
this._autoCopyCD = new BooleanChoice(this, Shell.LoadString(StringId.IDS_AUTO_RIP));
this._autoCopyCD.Value = ClientConfiguration.Recorder.AutoCopyCD != 0;
this._autoCopyCD.ChosenChanged += (sender, args) => this.CommitList[new ProxySettingDelegate(this.OnAutoCopyCDCommit)] = null;
}
return this._autoCopyCD;
}
}
private void OnAutoCopyCDCommit(object data) => ClientConfiguration.Recorder.AutoCopyCD = this._autoCopyCD.Value ? 1 : 0;
public BooleanChoice AutoEjectCD
{
get
{
if (this._autoEjectCD == null)
{
this._autoEjectCD = new BooleanChoice(this, Shell.LoadString(StringId.IDS_EJECT_AFTER_RIP));
this._autoEjectCD.Value = ClientConfiguration.Recorder.AutoEjectCD != 0;
this._autoEjectCD.ChosenChanged += (sender, args) => this.CommitList[new ProxySettingDelegate(this.OnAutoEjectCDCommit)] = null;
}
return this._autoEjectCD;
}
}
private void OnAutoEjectCDCommit(object data) => ClientConfiguration.Recorder.AutoEjectCD = this._autoEjectCD.Value ? 1 : 0;
public bool MediaFolderHasSharedPathWithMonitoredFolder(
string monitoredFolder,
string mediaFolder)
{
bool flag = false;
if (!string.IsNullOrEmpty(monitoredFolder) && !string.IsNullOrEmpty(mediaFolder))
{
string localizedFolderPath1 = LocalizationHelper.GetLocalizedFolderPath(monitoredFolder);
string localizedFolderPath2 = LocalizationHelper.GetLocalizedFolderPath(mediaFolder);
if (localizedFolderPath1[localizedFolderPath1.Length - 1] != Path.PathSeparator)
localizedFolderPath1 += (string)(object)Path.PathSeparator;
if (localizedFolderPath2[localizedFolderPath2.Length - 1] != Path.PathSeparator)
localizedFolderPath2 += (string)(object)Path.PathSeparator;
flag = localizedFolderPath1.ToLower().IndexOf(localizedFolderPath2.ToLower()) == 0;
}
return flag;
}
public string MediaFolder
{
get
{
if (this._mediaFolder == null)
this._mediaFolder = LocalizationHelper.GetLocalizedFolderPath(ClientConfiguration.Groveler.RipDirectory);
return this._mediaFolder;
}
set
{
if (!(this._mediaFolder != value))
return;
this.CommitList[new ProxySettingDelegate(this.OnMediaFolderCommit)] = null;
this._mediaFolder = value;
this.FirePropertyChanged(nameof(MediaFolder));
}
}
private void OnMediaFolderCommit(object data)
{
if (this.UsingWin7Libraries)
return;
ClientConfiguration.Groveler.RipDirectory = this._mediaFolder;
this.UpdateSharedFoldersList();
this._mediaFolder = null;
}
public string VideoMediaFolder
{
get
{
if (this._videoMediaFolder == null)
{
this._videoMediaFolder = ClientConfiguration.Groveler.VideoMediaFolder;
string[] strArray;
string str;
string videoMediaFolder;
if (string.IsNullOrEmpty(this._videoMediaFolder) && ((HRESULT)ZuneApplication.ZuneLibrary.GetKnownFolders(out strArray, out strArray, out strArray, out strArray, out strArray, out str, out videoMediaFolder, out str, out str, out str)).IsSuccess)
this._videoMediaFolder = LocalizationHelper.GetLocalizedFolderPath(videoMediaFolder);
}
return this._videoMediaFolder;
}
set
{
if (!(this._videoMediaFolder != value))
return;
this.CommitList[new ProxySettingDelegate(this.OnVideoMediaFolderCommit)] = null;
this._videoMediaFolder = value;
this.FirePropertyChanged(nameof(VideoMediaFolder));
}
}
private void OnVideoMediaFolderCommit(object data)
{
if (this.UsingWin7Libraries)
return;
ClientConfiguration.Groveler.VideoMediaFolder = this._videoMediaFolder;
this.UpdateSharedFoldersList();
this._videoMediaFolder = null;
}
public string PhotoMediaFolder
{
get
{
if (this._photoMediaFolder == null)
{
this._photoMediaFolder = ClientConfiguration.Groveler.PhotoMediaFolder;
string[] strArray;
string str;
string photoMediaFolder;
if (string.IsNullOrEmpty(this._photoMediaFolder) && ((HRESULT)ZuneApplication.ZuneLibrary.GetKnownFolders(out strArray, out strArray, out strArray, out strArray, out strArray, out str, out str, out photoMediaFolder, out str, out str)).IsSuccess)
this._photoMediaFolder = LocalizationHelper.GetLocalizedFolderPath(photoMediaFolder);
}
return this._photoMediaFolder;
}
set
{
if (!(this._photoMediaFolder != value))
return;
this.CommitList[new ProxySettingDelegate(this.OnPhotoMediaFolderCommit)] = null;
this._photoMediaFolder = value;
this.FirePropertyChanged(nameof(PhotoMediaFolder));
}
}
private void OnPhotoMediaFolderCommit(object data)
{
if (this.UsingWin7Libraries)
return;
ClientConfiguration.Groveler.PhotoMediaFolder = this._photoMediaFolder;
this.UpdateSharedFoldersList();
this._photoMediaFolder = null;
}
public string PodcastMediaFolder
{
get
{
if (this._podcastMediaFolder == null)
{
this._podcastMediaFolder = ClientConfiguration.Groveler.PodcastMediaFolder;
string[] strArray;
string str;
string podcastMediaFolder;
if (string.IsNullOrEmpty(this._podcastMediaFolder) && ((HRESULT)ZuneApplication.ZuneLibrary.GetKnownFolders(out strArray, out strArray, out strArray, out strArray, out strArray, out str, out str, out str, out podcastMediaFolder, out str)).IsSuccess)
this._podcastMediaFolder = LocalizationHelper.GetLocalizedFolderPath(podcastMediaFolder);
}
return this._podcastMediaFolder;
}
set
{
if (!(this._podcastMediaFolder != value))
return;
this.CommitList[new ProxySettingDelegate(this.OnPodcastMediaFolderCommit)] = null;
this._podcastMediaFolder = value;
this.FirePropertyChanged(nameof(PodcastMediaFolder));
}
}
private void OnPodcastMediaFolderCommit(object data)
{
if (this.UsingWin7Libraries)
return;
ClientConfiguration.Groveler.PodcastMediaFolder = this._podcastMediaFolder;
this.UpdateSharedFoldersList();
this._podcastMediaFolder = null;
}
private void UpdateSharedFoldersList()
{
if (!this.HME.SharingEnabled)
return;
this.HME.SetSharedFoldersList(true);
}
public void ChooseMediaFolder(MediaType mediaType) => FolderBrowseDialog.Show(Shell.LoadString(StringId.IDS_CHANGE_MEDIA_FOLDER_DIALOG_TITLE), args =>
{
string folder = (string)args;
if (folder == null)
return;
if (FolderBrowseDialog.CanWriteToFolder(folder) && ZuneApplication.ZuneLibrary.CanAddFromFolder(folder))
{
switch (mediaType)
{
case MediaType.Track:
this.MediaFolder = folder;
break;
case MediaType.Video:
this.VideoMediaFolder = folder;
break;
case MediaType.Photo:
this.PhotoMediaFolder = folder;
break;
case MediaType.Podcast:
this.PodcastMediaFolder = folder;
break;
}
}
else
MessageBox.Show(Shell.LoadString(StringId.IDS_INVALID_MEDIA_FOLDER_TITLE), Shell.LoadString(StringId.IDS_INVALID_MEDIA_FOLDER_MESSAGE), null);
}, true);
public BooleanChoice AutoEjectCDAfterBurn
{
get
{
if (this._autoEjectCDAfterBurn == null)
{
this._autoEjectCDAfterBurn = new BooleanChoice(this, Shell.LoadString(StringId.IDS_BURN_AUTO_EJECT_CHECK));
this._autoEjectCDAfterBurn.Value = ClientConfiguration.CDBurn.AutoEject;
this._autoEjectCDAfterBurn.ChosenChanged += (sender, args) => this.CommitList[new ProxySettingDelegate(this.OnAutoEjectCDAfterBurnCommit)] = null;
}
return this._autoEjectCDAfterBurn;
}
}
private void OnAutoEjectCDAfterBurnCommit(object data) => ClientConfiguration.CDBurn.AutoEject = this._autoEjectCDAfterBurn.Value;
public Choice BurnFormat
{
get
{
if (this._burnDiscFormat == null)
{
this._burnDiscFormat = new Choice(this);
this._burnDiscFormat.Options = (new NamedIntOption[2]
{
new NamedIntOption( null, Shell.LoadString(StringId.IDS_BURN_AUDIO_OPTION), 0),
new NamedIntOption( null, Shell.LoadString(StringId.IDS_BURN_DATA_OPTION), 1)
});
NamedIntOption.SelectOptionByValue(this._burnDiscFormat, ClientConfiguration.CDBurn.DiscFormat);
this._burnDiscFormat.ChosenChanged += (sender, args) => this.CommitList[new ProxySettingDelegate(this.OnBurnDiscFormatCommit)] = null;
}
return this._burnDiscFormat;
}
}
private void OnBurnDiscFormatCommit(object data)
{
ClientConfiguration.CDBurn.DiscFormat = ((NamedIntOption)this._burnDiscFormat.ChosenValue).Value;
CDAccess.Instance.UpdateIsAudioBurn();
}
public Choice BurnSpeed
{
get
{
if (this._burnSpeed == null)
{
this._burnSpeed = new Choice(this);
this._burnSpeed.Options = (new NamedIntOption[4]
{
new NamedIntOption( null, Shell.LoadString(StringId.IDS_BURN_FASTEST_OPTION), 0),
new NamedIntOption( null, Shell.LoadString(StringId.IDS_BURN_FAST_OPTION), 1),
new NamedIntOption( null, Shell.LoadString(StringId.IDS_BURN_MEDIUM_OPTION), 2),
new NamedIntOption( null, Shell.LoadString(StringId.IDS_BURN_SLOW_OPTION), 3)
});
NamedIntOption.SelectOptionByValue(this._burnSpeed, ClientConfiguration.CDBurn.BurnSpeed);
this._burnSpeed.ChosenChanged += (sender, args) => this.CommitList[new ProxySettingDelegate(this.OnBurnSpeedCommit)] = null;
}
return this._burnSpeed;
}
}
private void OnBurnSpeedCommit(object data) => ClientConfiguration.CDBurn.BurnSpeed = ((NamedIntOption)this._burnSpeed.ChosenValue).Value;
public BooleanChoice MediaInfoChoice
{
get
{
if (this._mediaInfoChoice == null)
{
StringId stringId = StringId.IDS_UPDATE_METADATA_CHECK;
if (FeatureEnablement.IsFeatureEnabled(Features.eQuickMixZmp) || FeatureEnablement.IsFeatureEnabled(Features.eQuickMixLocal))
stringId = !FeatureEnablement.IsFeatureEnabled(Features.eMixview) ? StringId.IDS_UPDATE_METADATA_QUICKMIX_CHECK : StringId.IDS_UPDATE_METADATA_FEATURES_CHECK;
this._mediaInfoChoice = new BooleanChoice(this, Shell.LoadString(stringId));
this._mediaInfoChoice.Value = ClientConfiguration.MediaStore.ConnectToInternetForAlbumMetadata;
this._mediaInfoChoice.ChosenChanged += (sender, args) => this.CommitList[new ProxySettingDelegate(this.OnMediaInfoChoiceCommit)] = null;
}
return this._mediaInfoChoice;
}
}
private void OnMediaInfoChoiceCommit(object data) => ClientConfiguration.MediaStore.ConnectToInternetForAlbumMetadata = this._mediaInfoChoice.Value;
public void ScanAndClearDeletedMedia() => ZuneLibrary.ScanAndClearDeletedMedia();
public BooleanChoice SqmChoice
{
get
{
if (this._sqmChoice == null)
{
this._sqmChoice = new BooleanChoice(this, Shell.LoadString(StringId.IDS_USAGE_DATA_CHECK));
this._sqmChoice.Value = ClientConfiguration.SQM.UsageTracking;
this._sqmChoice.ChosenChanged += (sender, args) => this.CommitList[new ProxySettingDelegate(this.OnSqmChoiceCommit)] = null;
}
return this._sqmChoice;
}
}
private void OnSqmChoiceCommit(object data)
{
ClientConfiguration.SQM.UsageTracking = this._sqmChoice.Value;
ClientConfiguration.FUE.AcceptedPrivacyStatement = this._sqmChoice.Value;
}
public Choice PodcastDefaultKeepEpisodesChoice
{
get
{
if (this._podcastDefaultKeepEpisodesChoice == null)
{
Choice choice = new Choice(this);
choice.Options = NamedIntOption.PodcastKeepOptions;
NamedIntOption.SelectOptionByValue(choice, ClientConfiguration.Series.PodcastDefaultKeepEpisodes);
this._podcastDefaultKeepEpisodesChoice = choice;
choice.ChosenChanged += (sender, args) => this.CommitList[new ProxySettingDelegate(this.OnPodcastDefaultKeepEpisodesChoiceCommit)] = null;
}
return this._podcastDefaultKeepEpisodesChoice;
}
}
private void OnPodcastDefaultKeepEpisodesChoiceCommit(object data) => ClientConfiguration.Series.PodcastDefaultKeepEpisodes = ((NamedIntOption)this._podcastDefaultKeepEpisodesChoice.ChosenValue).Value;
public Choice PodcastPlaybackChoice
{
get
{
if (this._podcastPlaybackChoice == null)
{
this._podcastPlaybackChoice = new Choice(this);
this._podcastPlaybackChoice.Options = NamedIntOption.PodcastPlaybackOptions;
NamedIntOption.SelectOptionByValue(this._podcastPlaybackChoice, ClientConfiguration.Series.PodcastDefaultPlaybackOrder);
this._podcastPlaybackChoice.ChosenChanged += (sender, args) => this.CommitList[new ProxySettingDelegate(this.OnPodcastPlaybackChoiceCommit)] = null;
}
return this._podcastPlaybackChoice;
}
}
private void OnPodcastPlaybackChoiceCommit(object data) => ClientConfiguration.Series.PodcastDefaultPlaybackOrder = ((NamedIntOption)this._podcastPlaybackChoice.ChosenValue).Value;
public BooleanChoice MetadataChoice
{
get
{
if (this._metadataChoice == null)
{
Command[] commandArray = new Command[2];
Command command1 = new Command(this, Shell.LoadString(StringId.IDS_MISSING_METADATA), null);
commandArray[0] = command1;
Command command2 = new Command(this, Shell.LoadString(StringId.IDS_OVERWRITE_METADATA), null);
commandArray[1] = command2;
this._metadataChoice = new BooleanChoice(this);
this._metadataChoice.Options = commandArray;
this._metadataChoice.Value = ClientConfiguration.MediaStore.OverwriteAllMetadata;
this._metadataChoice.ChosenChanged += (sender, args) => this.CommitList[new ProxySettingDelegate(this.OnMetadataChoiceCommit)] = null;
}
return this._metadataChoice;
}
}
private void OnMetadataChoiceCommit(object data) => ClientConfiguration.MediaStore.OverwriteAllMetadata = this._metadataChoice.Value;
public IList AudioFileTypes
{
get
{
if (this._audioFileTypes == null)
this.PopulateFileTypes();
return (IList)this._audioFileTypes;
}
}
public IList VideoFileTypes
{
get
{
if (this._videoFileTypes == null)
this.PopulateFileTypes();
return (IList)this._videoFileTypes;
}
}
private void PopulateFileTypes()
{
if (this._audioFileTypes != null && this._videoFileTypes != null)
return;
this._allFileTypes = new List<BooleanInputChoice>();
this._audioFileTypes = new List<BooleanInputChoice>();
this._videoFileTypes = new List<BooleanInputChoice>();
HRESULT associationInfoList = this.FileAssocHandler.GetFileAssociationInfoList(out this._fileAssociationInfoList);
if (associationInfoList.IsSuccess)
{
this.CanFileAssociationBeChanged = this.FileAssocHandler.CanAssociationBeChanged();
string format = Shell.LoadString(StringId.IDS_FILE_TYPES_DESCRIPTION_FORMAT);
for (int index = 0; index < this._fileAssociationInfoList.Count; ++index)
{
string extension = this._fileAssociationInfoList[index].Extension;
BooleanInputChoice booleanInputChoice = new BooleanInputChoice(this, string.Format(format, extension.Substring(1), _fileAssociationInfoList[index].Description), this.CanFileAssociationBeChanged);
if (ClientConfiguration.FUE.ShowFUE && this.CanFileAssociationBeChanged && Array.IndexOf(this._defaultFileTypeExtensions, extension) >= 0)
this._fileAssociationInfoList[index].IsCurrentlyOwned = true;
booleanInputChoice.Value = this._fileAssociationInfoList[index].IsCurrentlyOwned;
booleanInputChoice.ChosenChanged += (sender, args) => this.CommitList[new ProxySettingDelegate(this.OnFileTypesCommit)] = null;
switch (this._fileAssociationInfoList[index].MediaType)
{
case EMediaTypes.eMediaTypeAudio:
this._audioFileTypes.Add(booleanInputChoice);
break;
case EMediaTypes.eMediaTypeVideo:
this._videoFileTypes.Add(booleanInputChoice);
break;
}
this._allFileTypes.Add(booleanInputChoice);
}
}
else
ErrorDialogInfo.Show(associationInfoList.Int, Shell.LoadString(StringId.IDS_FILE_TYPES_ERROR_DIALOG_TITLE));
}
private void OnFileTypesCommit(object data)
{
if (this.FileAssocHandler == null || !this.CanFileAssociationBeChanged)
return;
for (int index = 0; index < this._allFileTypes.Count; ++index)
this._fileAssociationInfoList[index].IsCurrentlyOwned = this._allFileTypes[index].Value;
HRESULT hresult = this.FileAssocHandler.SetFileAssociationInfo(this._fileAssociationInfoList);
if (hresult.IsError)
ErrorDialogInfo.Show(hresult.Int, Shell.LoadString(StringId.IDS_FILE_TYPES_ERROR_DIALOG_TITLE));
if (!Shell.SettingsFrame.Wizard.IsCurrent)
return;
Fue.Instance.SetFileTypeAssociationsAreSet();
}
public void SelectAllFileTypes()
{
if (!this.CanFileAssociationBeChanged)
return;
for (int index = 0; index < this._allFileTypes.Count; ++index)
this._allFileTypes[index].Value = true;
}
public void SaveFileTypesAsDefault()
{
if (!this.FileAssocHandler.CanAssociationBeChanged())
return;
IList<FileAssociationInfo> fileAssociationInfoList;
HRESULT hresult = this.FileAssocHandler.GetFileAssociationInfoList(out fileAssociationInfoList);
if (hresult.IsSuccess)
{
for (int index = 0; index < fileAssociationInfoList.Count; ++index)
{
if (Array.IndexOf(this._defaultFileTypeExtensions, fileAssociationInfoList[index].Extension) >= 0)
fileAssociationInfoList[index].IsCurrentlyOwned = true;
}
hresult = this.FileAssocHandler.SetFileAssociationInfo(fileAssociationInfoList);
if (!hresult.IsError)
return;
ErrorDialogInfo.Show(hresult.Int, Shell.LoadString(StringId.IDS_FILE_TYPES_ERROR_DIALOG_TITLE));
}
else
ErrorDialogInfo.Show(hresult.Int, Shell.LoadString(StringId.IDS_FILE_TYPES_ERROR_DIALOG_TITLE));
}
public void ResetWarningMessages()
{
ClientConfiguration.MediaStore.LibraryDefaultDeleteChoice = 0;
ClientConfiguration.MediaStore.PlaylistDefaultDeleteChoice = 0;
ClientConfiguration.Pictures.DisplayAutouploadNotification = true;
ClientConfiguration.Series.PodcastDefaultUnsubscribeChoice = 0;
ClientConfiguration.Service.InhibitSubscriptionMachineCountExceededSignInWarning = false;
ClientConfiguration.Service.InhibitSubscriptionBillingViolationSignInWarning = false;
ClientConfiguration.Service.InhibitSubscriptionEndingWarning = false;
ClientConfiguration.Service.InhibitSubscriptionFreePurchasePrompt = false;
ClientConfiguration.Service.InhibitWinPhoneAppPurchaseConfirmation = false;
ClientConfiguration.Service.InhibitReviewRefreshWarning = false;
ClientConfiguration.Shell.ShowAppsForZuneHDOnlyHeader = true;
ClientConfiguration.Shell.ShowAppsForWindowsPhoneOnlyHeader = true;
ClientConfiguration.MediaStore.ConfirmAccountDevicePCDeletion = true;
ClientConfiguration.MediaStore.ConfirmAccountDevicePortableDeletion = true;
ClientConfiguration.MediaStore.ConfirmDeviceMediaDeletion = true;
ClientConfiguration.MediaStore.ConfirmMultiAlbumEdit = true;
ClientConfiguration.MediaStore.ConfirmMultiSongEdit = true;
ClientConfiguration.MediaStore.ConfirmMultiVideoEdit = true;
ClientConfiguration.MediaStore.ConfirmPasteAlbumArt = true;
ClientConfiguration.MediaStore.AlertSyncAllFriendsBehavior = true;
ClientConfiguration.Social.ConfirmAcceptFriend = true;
ClientConfiguration.Social.ConfirmDeleteFriend = true;
ClientConfiguration.QuickMix.OnlyEnableItemsWithQuickMix = false;
ClientConfiguration.Devices.ShowExcludeFromSyncWarning = true;
ClientConfiguration.Devices.ShowSyncInstructionsToast = true;
foreach (UIDevice uiDevice in SingletonModelItem<UIDeviceList>.Instance)
uiDevice.PromptForAccountLinkage = true;
}
public bool InhibitSubscriptionMachineCountExceededSignInWarning
{
get => ClientConfiguration.Service.InhibitSubscriptionMachineCountExceededSignInWarning;
set => ClientConfiguration.Service.InhibitSubscriptionMachineCountExceededSignInWarning = value;
}
public bool InhibitSubscriptionBillingViolationSignInWarning
{
get => ClientConfiguration.Service.InhibitSubscriptionBillingViolationSignInWarning;
set => ClientConfiguration.Service.InhibitSubscriptionBillingViolationSignInWarning = value;
}
public bool InhibitSubscriptionEndingWarning
{
get => ClientConfiguration.Service.InhibitSubscriptionEndingWarning;
set => ClientConfiguration.Service.InhibitSubscriptionEndingWarning = value;
}
public bool InhibitSubscriptionFreePurchasePrompt
{
get => ClientConfiguration.Service.InhibitSubscriptionFreePurchasePrompt;
set => ClientConfiguration.Service.InhibitSubscriptionFreePurchasePrompt = value;
}
public int LibraryDefaultDeleteChoice
{
get => ClientConfiguration.MediaStore.LibraryDefaultDeleteChoice;
set => ClientConfiguration.MediaStore.LibraryDefaultDeleteChoice = value;
}
public int PlaylistDefaultDeleteChoice
{
get => ClientConfiguration.MediaStore.PlaylistDefaultDeleteChoice;
set => ClientConfiguration.MediaStore.PlaylistDefaultDeleteChoice = value;
}
public bool ConfirmAcceptFriend
{
get => ClientConfiguration.Social.ConfirmAcceptFriend;
set => ClientConfiguration.Social.ConfirmAcceptFriend = value;
}
public bool ConfirmDeleteFriend
{
get => ClientConfiguration.Social.ConfirmDeleteFriend;
set => ClientConfiguration.Social.ConfirmDeleteFriend = value;
}
public bool ConfirmAccountDevicePCDeletion
{
get => ClientConfiguration.MediaStore.ConfirmAccountDevicePCDeletion;
set => ClientConfiguration.MediaStore.ConfirmAccountDevicePCDeletion = value;
}
public bool ConfirmAccountDevicePortableDeletion
{
get => ClientConfiguration.MediaStore.ConfirmAccountDevicePortableDeletion;
set => ClientConfiguration.MediaStore.ConfirmAccountDevicePortableDeletion = value;
}
public bool ConfirmDeviceMediaDeletion
{
get => ClientConfiguration.MediaStore.ConfirmDeviceMediaDeletion;
set => ClientConfiguration.MediaStore.ConfirmDeviceMediaDeletion = value;
}
public bool ConfirmMultiAlbumEdit
{
get => ClientConfiguration.MediaStore.ConfirmMultiAlbumEdit;
set => ClientConfiguration.MediaStore.ConfirmMultiAlbumEdit = value;
}
public bool ConfirmMultiSongEdit
{
get => ClientConfiguration.MediaStore.ConfirmMultiSongEdit;
set => ClientConfiguration.MediaStore.ConfirmMultiSongEdit = value;
}
public bool ConfirmMultiVideoEdit
{
get => ClientConfiguration.MediaStore.ConfirmMultiVideoEdit;
set => ClientConfiguration.MediaStore.ConfirmMultiVideoEdit = value;
}
public bool ConfirmPasteAlbumArt
{
get => ClientConfiguration.MediaStore.ConfirmPasteAlbumArt;
set => ClientConfiguration.MediaStore.ConfirmPasteAlbumArt = value;
}
public ArrayListDataSet DeviceList
{
get
{
if (this._registeredDevicesModelList == null)
this.InitRegisteredTuners();
return this._registeredDevicesModelList;
}
}
public ArrayListDataSet AppStoreDeviceList
{
get
{
if (this._registeredAppStoreDevicesModelList == null)
this.InitRegisteredTuners();
return this._registeredAppStoreDevicesModelList;
}
}
public ArrayListDataSet ComputerList
{
get
{
if (this._registeredComputersModelList == null)
this.InitRegisteredTuners();
return this._registeredComputersModelList;
}
}
public string NextPCDeregistrationDate
{
get => this._nextPCDeregistrationDate;
private set
{
if (!(this._nextPCDeregistrationDate != value))
return;
this._nextPCDeregistrationDate = value;
this.FirePropertyChanged(nameof(NextPCDeregistrationDate));
}
}
public string NextSubscriptionDeviceDeregistrationDate
{
get => this._nextSubscriptionDeviceDeregistrationDate;
private set
{
if (!(this._nextSubscriptionDeviceDeregistrationDate != value))
return;
this._nextSubscriptionDeviceDeregistrationDate = value;
this.FirePropertyChanged(nameof(NextSubscriptionDeviceDeregistrationDate));
}
}
public string NextAppStoreDeviceDeregistrationDate
{
get => this._nextAppStoreDeviceDeregistrationDate;
private set
{
if (!(this._nextAppStoreDeviceDeregistrationDate != value))
return;
this._nextAppStoreDeviceDeregistrationDate = value;
this.FirePropertyChanged(nameof(NextAppStoreDeviceDeregistrationDate));
}
}
public bool CanShowDeviceList
{
get
{
if (this._tunerHandler == null)
this.InitRegisteredTuners();
return this._tunerHandler.CanQueryTunerList();
}
}
public void RemoveTuner(TunerInfo tunerInfo)
{
if (this._tunerHandler == null)
this.InitRegisteredTuners();
this._tunerHandler.DeregisterTuner(tunerInfo);
}
public void RefreshTunerList()
{
if (!this._tunerHandler.CanQueryTunerList())
return;
this._tunerHandler.RefreshTunerList();
}
private void OnTunerInfoChanged(object oSenderUNUSED, EventArgs eargs)
{
if (eargs != null && eargs.GetType() == typeof(EventArgsHR) && ((EventArgsHR)eargs).HResult == HRESULT._ZEST_E_TOO_MANY_DEREGISTRATIONS_WITHIN_MONTH)
Application.DeferredInvoke(new DeferredInvokeHandler(this.DisplayServiceErrorMessage), eargs);
else
Application.DeferredInvoke(new DeferredInvokeHandler(this.UpdateRegisteredTunersList), DeferredInvokePriority.Normal);
}
private void DisplayServiceErrorMessage(object eargs) => Shell.ShowErrorDialog(((EventArgsHR)eargs).HResult, StringId.IDS_REGDEVICES_CANT_REMOVE);
private void UpdateRegisteredTunersList(object argsUNUSED)
{
if (this._registeredComputersModelList == null || this._registeredDevicesModelList == null || this._registeredAppStoreDevicesModelList == null)
return;
int count1 = this._registeredComputersModelList.Count;
int count2 = this._registeredDevicesModelList.Count;
int count3 = this._registeredAppStoreDevicesModelList.Count;
this._registeredComputersModelList.Clear();
this._registeredDevicesModelList.Clear();
this._registeredAppStoreDevicesModelList.Clear();
foreach (object pcs in this._tunerHandler.GetPCsList())
this._registeredComputersModelList.Add(pcs);
foreach (object devices in this._tunerHandler.GetDevicesList())
this._registeredDevicesModelList.Add(devices);
foreach (object appStoreDevices in this._tunerHandler.GetAppStoreDevicesList())
this._registeredAppStoreDevicesModelList.Add(appStoreDevices);
DateTime deregistrationDate1 = this._tunerHandler.GetNextPCDeregistrationDate();
this.NextPCDeregistrationDate = !(deregistrationDate1 != DateTime.MinValue) || !(deregistrationDate1 > DateTime.Now) ? null : deregistrationDate1.AddDays(1.0).ToShortDateString();
DateTime deregistrationDate2 = this._tunerHandler.GetNextSubscriptionDeviceDeregistrationDate();
this.NextSubscriptionDeviceDeregistrationDate = !(deregistrationDate2 != DateTime.MinValue) || !(deregistrationDate2 > DateTime.Now) ? null : deregistrationDate2.AddDays(1.0).ToShortDateString();
DateTime deregistrationDate3 = this._tunerHandler.GetNextAppStoreDeviceDeregistrationDate();
this.NextAppStoreDeviceDeregistrationDate = !(deregistrationDate3 != DateTime.MinValue) || !(deregistrationDate3 > DateTime.Now) ? null : deregistrationDate3.AddDays(1.0).ToShortDateString();
if (this._registeredComputersModelList.Count >= count1 && this._registeredDevicesModelList.Count >= count2 && this._registeredAppStoreDevicesModelList.Count >= count3)
return;
SignIn.Instance.RefreshAccount();
}
private void InitRegisteredTuners()
{
this._tunerHandler = TunerInfoHandlerFactory.CreateTunerInfoHandler();
this._tunerHandler.OnChanged += new EventHandler(this.OnTunerInfoChanged);
this._registeredComputersModelList = new ArrayListDataSet();
this._registeredDevicesModelList = new ArrayListDataSet();
this._registeredAppStoreDevicesModelList = new ArrayListDataSet();
this._nextPCDeregistrationDate = null;
this._nextSubscriptionDeviceDeregistrationDate = null;
this._nextAppStoreDeviceDeregistrationDate = null;
if (!this._tunerHandler.CanQueryTunerList())
return;
this._tunerHandler.RefreshTunerList();
}
public IntRangedValue SlideShowSpeed
{
get
{
if (this._slideShowSpeed == null)
{
this._slideShowSpeed = new IntRangedValue(this);
this._slideShowSpeed.MinValue = 3000;
this._slideShowSpeed.MaxValue = 10000;
this._slideShowSpeed.Step = 1000;
this._slideShowSpeed.Value = ClientConfiguration.GeneralSettings.SlideShowSpeed;
this._slideShowSpeed.PropertyChanged += (sender, args) => this.CommitList[new ProxySettingDelegate(this.OnSlideShowSpeedCommit)] = null;
}
return this._slideShowSpeed;
}
}
private void OnSlideShowSpeedCommit(object data) => ClientConfiguration.GeneralSettings.SlideShowSpeed = this._slideShowSpeed.Value;
public HMESettings HME
{
get
{
if (this._HME == null)
{
lock (this.mylock)
{
if (this._HME == null)
{
HMESettings hmeSettings = new HMESettings();
int num = ((HRESULT)hmeSettings.Init()).IsError ? 1 : 0;
this._sharingAllDevicesEnabled = hmeSettings.GetAllDevicesEnabled();
this._HME = hmeSettings;
}
}
}
return this._HME;
}
}
public bool UserCanModifySharing => Environment.OSVersion.Version.Major >= 6 || !this.SharingEnableRequiresElevation || this.SharingEnabled;
public bool SharingEnableRequiresElevation => Environment.OSVersion.Version.Major < 6 ? this.HME.SharingEnableRequiresLoginAsAdmin : this.HME.SharingEnableRequiresElevation;
public bool SharingEnabled => this.HME.SharingEnabled;
private void SetSharingEnabledForAllMediaTypes(bool music, bool video, bool pictures)
{
this.HME.SetSharingEnabledForMediaType(EMediaTypes.eMediaTypeAudio, music);
this.HME.SetSharingEnabledForMediaType(EMediaTypes.eMediaTypeVideo, video);
this.HME.SetSharingEnabledForMediaType(EMediaTypes.eMediaTypeImage, pictures);
}
private void OnMediaSharingUpdate(object data)
{
if (this.HME == null)
return;
bool flag = this._sharingEnableMusic.Value || this._sharingEnableVideo.Value || this._sharingEnablePhoto.Value;
HRESULT hresult1 = 0;
if (flag)
{
if (((HRESULT)this.HME.EnableSharingForUser()).IsSuccess)
this.SetSharingEnabledForAllMediaTypes(this._sharingEnableMusic.Value, this._sharingEnableVideo.Value, this._sharingEnablePhoto.Value);
else
this.SetSharingEnabledForAllMediaTypes(false, false, false);
}
else
{
HRESULT hresult2 = this.HME.DisableSharingForMachine();
if (hresult2.IsSuccess)
hresult2 = this.HME.DisableSharingForUser();
if (hresult2.IsSuccess)
this.SetSharingEnabledForAllMediaTypes(false, false, false);
}
this.HME.SetAllDevicesEnabled(this._sharingAllDevicesEnabled);
if (!this._sharingAllDevicesEnabled)
this.HME.EnableDevice(this._sharingDeviceIndex, true);
this.HME.SetDisplayName(this._sharingDisplayName);
}
public string SharingDisplayName
{
get
{
if (this._sharingDisplayName == null)
this.HME.GetDisplayName(ref this._sharingDisplayName);
return this._sharingDisplayName;
}
set
{
if (string.IsNullOrEmpty(value))
{
this.SharingError = Shell.LoadString(StringId.IDS_SHARE_NAME_EMPTY);
}
else
{
if (!(this._sharingDisplayName != value))
return;
this.SharingError = string.Empty;
this._sharingDisplayName = value;
this.CommitList[new ProxySettingDelegate(this.OnMediaSharingUpdate)] = null;
}
}
}
public string SharingError
{
get => this._sharingError;
set
{
if (!(this._sharingError != value))
return;
this._sharingError = value;
this.FirePropertyChanged(nameof(SharingError));
}
}
public BooleanChoice SharingEnableMusic
{
get
{
if (this._sharingEnableMusic == null)
{
this._sharingEnableMusic = new BooleanChoice(this, Shell.LoadString(StringId.IDS_SHARE_MUSIC_CHECK));
this._sharingEnableMusic.Value = this.HME.GetSharingEnabledForMediaType(EMediaTypes.eMediaTypeAudio);
this._sharingEnableMusic.ChosenChanged += (sender, args) =>
{
this.CommitList[new ProxySettingDelegate(this.OnMediaSharingUpdate)] = null;
if (!this.SharingEnableRequiresElevation)
return;
this.ChangeRequiresElevation = true;
};
}
return this._sharingEnableMusic;
}
}
public BooleanChoice SharingEnableVideo
{
get
{
if (this._sharingEnableVideo == null)
{
this._sharingEnableVideo = new BooleanChoice(this, Shell.LoadString(StringId.IDS_SHARE_VIDEOS_CHECK));
this._sharingEnableVideo.Value = this.HME.GetSharingEnabledForMediaType(EMediaTypes.eMediaTypeVideo);
this._sharingEnableVideo.ChosenChanged += (sender, args) =>
{
this.CommitList[new ProxySettingDelegate(this.OnMediaSharingUpdate)] = null;
if (!this.SharingEnableRequiresElevation)
return;
this.ChangeRequiresElevation = true;
};
}
return this._sharingEnableVideo;
}
}
public BooleanChoice SharingEnablePhoto
{
get
{
if (this._sharingEnablePhoto == null)
{
this._sharingEnablePhoto = new BooleanChoice(this, Shell.LoadString(StringId.IDS_SHARE_PICTURES_CHECK));
this._sharingEnablePhoto.Value = this.HME.GetSharingEnabledForMediaType(EMediaTypes.eMediaTypeImage);
this._sharingEnablePhoto.ChosenChanged += (sender, args) =>
{
this.CommitList[new ProxySettingDelegate(this.OnMediaSharingUpdate)] = null;
if (!this.SharingEnableRequiresElevation)
return;
this.ChangeRequiresElevation = true;
};
}
return this._sharingEnablePhoto;
}
}
public Choice SharingSelectDeviceChoice
{
get
{
if (this._sharingSelectDeviceChoice == null)
{
this._sharingSelectDeviceOptions = new List<Command>();
Command command1 = new Command(this, Shell.LoadString(StringId.IDS_GLOBAL_SHARING_OPTION), null);
command1.Data.Add("value", true);
this._sharingSelectDeviceOptions.Add(command1);
Command command2 = new Command(this, Shell.LoadString(StringId.IDS_SELECTIVE_SHARING_OPTION), null);
command2.Data.Add("value", false);
command2.Available = this.SharingEnabled;
this._sharingSelectDeviceOptions.Add(command2);
this._sharingSelectDeviceChoice = new Choice(this);
this._sharingSelectDeviceChoice.Options = (IList)this._sharingSelectDeviceOptions;
this._sharingSelectDeviceChoice.ChosenChanged += (sender, args) => this.SharingAllDevicesEnabled = (bool)this._sharingSelectDeviceOptions[((Choice)sender).ChosenIndex].Data["value"];
}
return this._sharingSelectDeviceChoice;
}
}
public bool SharingAllDevicesEnabled
{
get => this._sharingAllDevicesEnabled;
set
{
if (this._sharingAllDevicesEnabled == value)
return;
this._sharingAllDevicesEnabled = value;
this.CommitList[new ProxySettingDelegate(this.OnMediaSharingUpdate)] = null;
this.FirePropertyChanged(nameof(SharingAllDevicesEnabled));
}
}
public IList SharingDeviceList
{
get
{
if (this._sharingDeviceList == null)
this._sharingDeviceList = this.CreateSharingDeviceList();
return (IList)this._sharingDeviceList;
}
}
private IList<BooleanInputChoice> CreateSharingDeviceList()
{
IList<BooleanInputChoice> booleanInputChoiceList = new List<BooleanInputChoice>();
uint deviceCount = this.HME.GetDeviceCount();
string strName = "";
string strMAC = "";
string strSerialNumber = "";
for (uint dwIndex = 0; dwIndex < deviceCount; ++dwIndex)
{
this.HME.GetDeviceProps(dwIndex, ref strName, ref strMAC, ref strSerialNumber);
BooleanInputChoice booleanInputChoice = new BooleanInputChoice(this, deviceCount > 1U ? string.Format(Shell.LoadString(StringId.IDS_XBOX360_NAME_AND_SERIAL_NUMBER), strName, strSerialNumber) : strName, true);
booleanInputChoice.Data["index"] = dwIndex;
booleanInputChoice.Value = this.HME.GetDeviceEnabled(dwIndex);
booleanInputChoice.ChosenChanged += new EventHandler(this.HandleSharingDeviceListValueChanged);
booleanInputChoiceList.Add(booleanInputChoice);
}
if (!this._nssDeviceListChangeEventAdded)
{
this.HME.NSSDeviceListChangeEvent += new NSSDeviceListChangeHandler(this.HandleNSSDeviceListChangeEvent);
this._nssDeviceListChangeEventAdded = true;
}
return booleanInputChoiceList;
}
public void RemoveNSSDeviceListChangeEvent()
{
if (!this._nssDeviceListChangeEventAdded)
return;
this.HME.NSSDeviceListChangeEvent -= new NSSDeviceListChangeHandler(this.HandleNSSDeviceListChangeEvent);
this._nssDeviceListChangeEventAdded = false;
this._sharingDeviceList = null;
}
private void HandleNSSDeviceListChangeEvent() => Application.DeferredInvoke(delegate
{
if (this._sharingDeviceList == null)
return;
this._sharingDeviceList = this.CreateSharingDeviceList();
this.FirePropertyChanged("SharingDeviceList");
}, null);
private void HandleSharingDeviceListValueChanged(object sender, EventArgs args) => this._sharingDeviceIndex = (uint)((ModelItem)sender).Data["index"];
public bool ReevaluateVideoSettings
{
get => ClientConfiguration.GeneralSettings.ReevaluateVideoSettings;
set
{
ClientConfiguration.GeneralSettings.ReevaluateVideoSettings = value;
this.FirePropertyChanged(nameof(ReevaluateVideoSettings));
}
}
public RenderingType RequestedRenderingType
{
get
{
RenderingType renderingType = (RenderingType)ClientConfiguration.GeneralSettings.RenderingType;
if (renderingType == RenderingType.Default)
renderingType = Application.RenderingType;
return renderingType;
}
set
{
ClientConfiguration.GeneralSettings.RenderingType = (int)value;
this.ReevaluateVideoSettings = Application.RenderingType != RenderingType.DX9 && value == RenderingType.DX9;
this.FirePropertyChanged(nameof(RequestedRenderingType));
}
}
private void ReevaluateVideoAcceleration(object sender, EventArgs args) => this.RequestedRenderingType = RenderingType.DX9;
public RenderingQuality RequestedRenderingQuality
{
get => (RenderingQuality)ClientConfiguration.GeneralSettings.RenderingQuality;
set
{
ClientConfiguration.GeneralSettings.RenderingQuality = (int)value;
this.FirePropertyChanged(nameof(RequestedRenderingQuality));
}
}
public bool AnimationsEnabled
{
get => ClientConfiguration.GeneralSettings.AnimationsEnabled;
set
{
ClientConfiguration.GeneralSettings.AnimationsEnabled = value;
this.FirePropertyChanged(nameof(AnimationsEnabled));
}
}
public Choice ScreenGraphicsSlider
{
get
{
if (this._screenGraphicsSlider == null)
{
Choice choice = new Choice(this);
choice.Options = NamedIntOption.ScreenGraphicsOptions;
ScreenGraphics screenGraphics = Application.RenderingType != RenderingType.GDI ? (Application.RenderingQuality != RenderingQuality.MaxQuality ? (!Application.AnimationsEnabled ? ScreenGraphics.Advanced : ScreenGraphics.AdvancedWithAnimation) : ScreenGraphics.Premium) : ScreenGraphics.Basic;
NamedIntOption.SelectOptionByValue(choice, (int)screenGraphics);
this._screenGraphicsSlider = choice;
choice.ChosenChanged += (sender, args) => this.CommitList[new ProxySettingDelegate(this.OnScreenGraphicsSliderCommit)] = null;
}
return this._screenGraphicsSlider;
}
}
private void OnScreenGraphicsSliderCommit(object data)
{
ScreenGraphics screenGraphics = (ScreenGraphics)((NamedIntOption)this._screenGraphicsSlider.ChosenValue).Value;
RenderingType requestedRenderingType = this.RequestedRenderingType;
switch (screenGraphics)
{
case ScreenGraphics.Basic:
this.RequestedRenderingType = RenderingType.GDI;
this.RequestedRenderingQuality = RenderingQuality.MinQuality;
this.AnimationsEnabled = false;
break;
case ScreenGraphics.Advanced:
this.RequestedRenderingType = RenderingType.DX9;
this.RequestedRenderingQuality = RenderingQuality.MinQuality;
this.AnimationsEnabled = false;
break;
case ScreenGraphics.AdvancedWithAnimation:
this.RequestedRenderingType = RenderingType.DX9;
this.RequestedRenderingQuality = RenderingQuality.MinQuality;
this.AnimationsEnabled = true;
break;
case ScreenGraphics.Premium:
this.RequestedRenderingType = RenderingType.DX9;
this.RequestedRenderingQuality = RenderingQuality.MaxQuality;
this.AnimationsEnabled = true;
break;
}
if (requestedRenderingType == RenderingType.GDI && this.RequestedRenderingType == RenderingType.DX9)
MessageBox.Show(Shell.LoadString(StringId.IDS_SCREEN_GRAPHICS_TITLE), Shell.LoadString(StringId.IDS_ACCELERATION_PROMPT_TEXT), null);
else
MessageBox.Show(Shell.LoadString(StringId.IDS_SCREEN_GRAPHICS_TITLE), Shell.LoadString(StringId.IDS_ACCELERATION_RESTART_TEXT), null);
}
public string BackgroundImage
{
get
{
if (this._backgroundImage == null)
this._backgroundImage = ClientConfiguration.Shell.BackgroundImage;
return this._backgroundImage;
}
set
{
if (!(this._backgroundImage != value))
return;
this.CommitList[new ProxySettingDelegate(this.OnBackgroundImageCommit)] = null;
this._backgroundImage = value;
this.FirePropertyChanged(nameof(BackgroundImage));
}
}
public WindowColor BackgroundColor
{
get => this._backgroundColor;
set => this._backgroundColor = value;
}
private void OnBackgroundImageCommit(object data)
{
ClientConfiguration.Shell.BackgroundImage = this._backgroundImage;
ClientConfiguration.Shell.BackgroundColor = Shell.WindowColorToRGB(this._backgroundColor);
((Shell)ZuneShell.DefaultInstance).BackgroundImage = this._backgroundImage;
Application.Window.SetBackgroundColor(this._backgroundColor);
}
public BooleanChoice ShowNowPlayingBackgroundOnIdle
{
get
{
if (this._showNowPlayingBackgroundOnIdle == null)
{
this._showNowPlayingBackgroundOnIdle = new BooleanChoice(this, Shell.LoadString(StringId.IDS_SHOW_NOWPLAYING_ON_IDLE_DESCRIPTION));
this._showNowPlayingBackgroundOnIdle.Value = ClientConfiguration.Shell.ShowNowPlayingBackgroundOnIdleTimeout > 0;
this._showNowPlayingBackgroundOnIdle.ChosenChanged += (sender, args) => this.CommitList[new ProxySettingDelegate(this.OnShowNowPlayingBackgroundOnIdleCommit)] = null;
}
return this._showNowPlayingBackgroundOnIdle;
}
}
private void OnShowNowPlayingBackgroundOnIdleCommit(object data)
{
int num = this._showNowPlayingBackgroundOnIdle.Value ? 90 : 0;
ClientConfiguration.Shell.ShowNowPlayingBackgroundOnIdleTimeout = num;
((Shell)ZuneShell.DefaultInstance).ShowNowPlayingBackgroundOnIdleTimeout = num;
}
public BooleanChoice PlaySounds
{
get
{
if (this._playSounds == null)
{
this._playSounds = new BooleanChoice(this, Shell.LoadString(StringId.IDS_SOUNDS_DESCRIPTION));
this._playSounds.Value = ClientConfiguration.Shell.Sounds;
this._playSounds.ChosenChanged += (sender, args) => this.CommitList[new ProxySettingDelegate(this.OnPlaySoundsCommit)] = null;
}
return this._playSounds;
}
}
private void OnPlaySoundsCommit(object data)
{
ClientConfiguration.Shell.Sounds = this._playSounds.Value;
((Shell)ZuneShell.DefaultInstance).PlaySounds = this._playSounds.Value;
}
public BooleanChoice CompactModeAlwaysOnTop
{
get
{
if (this._compactModeAlwaysOnTop == null)
{
this._compactModeAlwaysOnTop = new BooleanChoice(this, Shell.LoadString(StringId.IDS_COMPACT_MODE_ALWAYS_ON_TOP));
this._compactModeAlwaysOnTop.Value = ClientConfiguration.GeneralSettings.CompactModeAlwaysOnTop;
this._compactModeAlwaysOnTop.ChosenChanged += (sender, args) => this.CommitList[new ProxySettingDelegate(this.OnCompactModeAlwaysOnTopCommit)] = null;
}
return this._compactModeAlwaysOnTop;
}
}
private void OnCompactModeAlwaysOnTopCommit(object data)
{
ClientConfiguration.GeneralSettings.CompactModeAlwaysOnTop = this._compactModeAlwaysOnTop.Value;
((Shell)ZuneShell.DefaultInstance).CompactModeAlwaysOnTop = this._compactModeAlwaysOnTop.Value;
SQMLog.Log(SQMDataId.CompactModeOnTopSetting, 1);
}
public BooleanChoice RatingsChoice
{
get
{
if (this._ratingsChoice == null)
{
Command[] commandArray = new Command[2]
{
new RichLayoutCommand( this, Shell.LoadString(StringId.IDS_COMMON_RATINGS_ALL_USERS_OPTION), true),
new RichLayoutCommand( this, Shell.LoadString(StringId.IDS_PERSONAL_RATINGS_EACH_USER_OPTION), false)
};
this._ratingsChoice = new BooleanChoice(this);
this._ratingsChoice.Options = commandArray;
this._ratingsChoice.Value = !ClientConfiguration.MediaStore.SharedUserRatings;
this._ratingsChoice.ChosenChanged += (sender, args) => this.CommitList[new ProxySettingDelegate(this.OnRatingsCommit)] = null;
}
return this._ratingsChoice;
}
}
private void OnRatingsCommit(object data)
{
ClientConfiguration.MediaStore.SharedUserRatings = !this._ratingsChoice.Value;
if (!this._applyRatingsChoice.Value || this._ratingsChoice.Value)
return;
ZuneLibrary.ExportUserRatings(SignIn.Instance.LastSignedInUserId, EMediaTypes.eMediaTypeAudio);
}
public BooleanChoice ApplyRatingsChoice
{
get
{
if (this._applyRatingsChoice == null)
{
this._applyRatingsChoice = new BooleanChoice(this, Shell.LoadString(StringId.IDS_APPLY_RATINGS_DIALOG_DESCRIPTION));
this._applyRatingsChoice.Value = false;
this._applyRatingsChoice.ChosenChanged += (sender, args) => this.CommitList[new ProxySettingDelegate(this.OnRatingsCommit)] = null;
}
return this._applyRatingsChoice;
}
}
public Choice StartupPageChoice
{
get
{
if (this._startupPageChoice == null)
{
List<Command> commandList = new List<Command>();
if (FeatureEnablement.IsFeatureEnabled(Features.eQuickplay))
commandList.Add(new NamedStringOption(Shell.LoadString(StringId.IDS_VIEW_STARTUPPAGE_QUICKPLAY_CHOICE), Shell.MainFrame.Quickplay.DefaultUIPath));
commandList.Add(new NamedStringOption(Shell.LoadString(StringId.IDS_VIEW_STARTUPPAGE_COLLECTION_CHOICE), Shell.MainFrame.Collection.DefaultUIPath));
if (FeatureEnablement.IsFeatureEnabled(Features.eMarketplace))
commandList.Add(new NamedStringOption(Shell.LoadString(StringId.IDS_VIEW_STARTUPPAGE_MARKETPLACE_CHOICE), Shell.MainFrame.Marketplace.DefaultUIPath));
if (FeatureEnablement.IsFeatureEnabled(Features.eSocial))
commandList.Add(new NamedStringOption(Shell.LoadString(StringId.IDS_VIEW_STARTUPPAGE_SOCIAL_CHOICE), Shell.MainFrame.Social.DefaultUIPath));
this._startupPageChoice = new Choice(this);
this._startupPageChoice.Options = commandList;
foreach (NamedStringOption namedStringOption in commandList)
{
if (namedStringOption.Value == ClientConfiguration.Shell.StartupPage)
{
this._startupPageChoice.ChosenValue = namedStringOption;
break;
}
}
this._startupPageChoice.ChosenChanged += (sender, args) => this.CommitList[new ProxySettingDelegate(this.OnStartupPageCommit)] = null;
}
return this._startupPageChoice;
}
}
private void OnStartupPageCommit(object data)
{
ClientConfiguration.Shell.StartupPage = ((NamedStringOption)this._startupPageChoice.ChosenValue).Value;
ClientConfiguration.Quickplay.CheckUseCount = false;
}
public bool AutoLaunchZuneOnConnect
{
get => this._autoLaunchZuneOnConnect;
set
{
if (this._autoLaunchZuneOnConnect == value)
return;
this._autoLaunchZuneOnConnect = value;
this.CommitList[new ProxySettingDelegate(this.OnAutoLaunchZuneOnConnectCommit)] = null;
this.FirePropertyChanged(nameof(AutoLaunchZuneOnConnect));
}
}
private void OnAutoLaunchZuneOnConnectCommit(object data) => ClientConfiguration.Devices.AutoLaunchZuneOnConnect = this._autoLaunchZuneOnConnect;
private struct MonitoredFolder
{
public readonly string Path;
public readonly EMediaTypes Schema;
public MonitoredFolder(string path, EMediaTypes schema)
{
this.Path = path;
this.Schema = schema;
}
}
}
}
Reference in New Issue View Git Blame Copy Permalink