mirror of
https://github.com/ZuneDev/ZuneShell.dll.git
synced 2026-07-27 13:11:51 -07:00
569 lines
25 KiB
C#
569 lines
25 KiB
C#
// Decompiled with JetBrains decompiler
|
|
// Type: ZuneUI.SyncControls
|
|
// 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.Util;
|
|
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.ComponentModel;
|
|
using System.IO;
|
|
using UIXControls;
|
|
|
|
namespace ZuneUI
|
|
{
|
|
public class SyncControls : ModelItem
|
|
{
|
|
private UIDeviceList _deviceList;
|
|
private UIDevice _currentDevice;
|
|
private UIDevice _deferredArrivalDevice;
|
|
private string _canonicalNameToMakeActive;
|
|
private bool _changeIntoSetupDevice;
|
|
private Command _deviceSignInFailureEvent;
|
|
private Queue<UIDevice> _failedSignInQueue;
|
|
private DownloadTaskList _downloadTasks;
|
|
private bool _haveSeenDownloadsOngoing;
|
|
private MessageBox _currentUnlinkedDeviceDialog;
|
|
private bool _showSyncInstructionsToast;
|
|
private bool _displayWirelessSyncBanner;
|
|
private static string _sizeInKB = Shell.LoadString(StringId.IDS_GAS_GAUGE_SIZE_IN_KB);
|
|
private static string _sizeInMB = Shell.LoadString(StringId.IDS_GAS_GAUGE_SIZE_IN_MB);
|
|
private static string _sizeInGB = Shell.LoadString(StringId.IDS_GAS_GAUGE_SIZE_IN_GB);
|
|
private static long _devicelandKilobyte = 1024;
|
|
private static long _devicelandMegabyte = DevicelandKilobyte * DevicelandKilobyte;
|
|
private static long _devicelandGigabyte = DevicelandMegabyte * DevicelandKilobyte;
|
|
private static SyncControls s_singletonInstance;
|
|
private static string _unlinkedDeviceNagDialogTitle = Shell.LoadString(StringId.IDS_DIALOG_TITLE_LINK_TO_SYNC_FRIENDS);
|
|
private static string _unlinkedDeviceNagDialogMessageBase = Shell.LoadString(StringId.IDS_DIALOG_TEXT_LINK_TO_SYNC_FRIENDS);
|
|
|
|
private SyncControls(IModelItemOwner owner)
|
|
: base(owner)
|
|
{
|
|
this._deviceList = SingletonModelItem<UIDeviceList>.Instance;
|
|
this._deviceList.DeviceAddedEvent += new DeviceListEventHandler(this.OnDeviceAdded);
|
|
this._deviceList.DeviceRemovedEvent += new DeviceListEventHandler(this.OnDeviceRemoved);
|
|
this._deviceList.DeviceConnectedEvent += new DeviceListEventHandler(this.OnDeviceConnected);
|
|
this._deviceList.DeviceDisconnectedEvent += new DeviceListEventHandler(this.OnDeviceDisconnected);
|
|
this._currentDevice = UIDeviceList.NullDevice;
|
|
SignIn.Instance.PropertyChanged += new PropertyChangedEventHandler(this.SignInPropertyChanged);
|
|
AccountCreationWizard.CreationCompleted += new EventHandler(this.AccountCreationFinished);
|
|
DeviceManagement.DeviceConnectionHandled += new DeviceConnectionHandledEventHandler(this.OnDeviceConnectionHandled);
|
|
this.UpdateWirelessSyncBannerDisplay();
|
|
}
|
|
|
|
protected override void OnDispose(bool fDisposing)
|
|
{
|
|
if (fDisposing)
|
|
{
|
|
if (this._deviceList != null)
|
|
{
|
|
this._deviceList.DeviceAddedEvent -= new DeviceListEventHandler(this.OnDeviceAdded);
|
|
this._deviceList.DeviceRemovedEvent -= new DeviceListEventHandler(this.OnDeviceRemoved);
|
|
this._deviceList.DeviceConnectedEvent -= new DeviceListEventHandler(this.OnDeviceConnected);
|
|
this._deviceList.DeviceDisconnectedEvent -= new DeviceListEventHandler(this.OnDeviceDisconnected);
|
|
this._deviceList = null;
|
|
}
|
|
if (this._downloadTasks != null)
|
|
{
|
|
this._downloadTasks.ActiveDownloads.PropertyChanged -= new PropertyChangedEventHandler(this.OnDownloadPropertyChanged);
|
|
this._downloadTasks = null;
|
|
}
|
|
SignIn.Instance.PropertyChanged -= new PropertyChangedEventHandler(this.SignInPropertyChanged);
|
|
AccountCreationWizard.CreationCompleted -= new EventHandler(this.AccountCreationFinished);
|
|
DeviceManagement.DeviceConnectionHandled -= new DeviceConnectionHandledEventHandler(this.OnDeviceConnectionHandled);
|
|
}
|
|
base.OnDispose(fDisposing);
|
|
}
|
|
|
|
public bool ShowPhoneWelcomeMessage
|
|
{
|
|
get => ClientConfiguration.FUE.ShowPhoneFUEDeviceLandOptions;
|
|
set
|
|
{
|
|
if (ClientConfiguration.FUE.ShowPhoneFUEDeviceLandOptions == value)
|
|
return;
|
|
ClientConfiguration.FUE.ShowPhoneFUEDeviceLandOptions = value;
|
|
this.FirePropertyChanged(nameof(ShowPhoneWelcomeMessage));
|
|
}
|
|
}
|
|
|
|
public bool ShowSyncInstructionsToast
|
|
{
|
|
get => this._showSyncInstructionsToast;
|
|
set
|
|
{
|
|
if (this._showSyncInstructionsToast == value)
|
|
return;
|
|
if (this.CurrentDevice.Class == DeviceClass.Classic || this.CurrentDevice.Class == DeviceClass.ZuneHD)
|
|
{
|
|
bool flag = value && ClientConfiguration.Devices.ShowSyncInstructionsToast;
|
|
value = flag;
|
|
ClientConfiguration.Devices.ShowSyncInstructionsToast = flag;
|
|
}
|
|
this._showSyncInstructionsToast = value;
|
|
this.FirePropertyChanged(nameof(ShowSyncInstructionsToast));
|
|
}
|
|
}
|
|
|
|
public bool DisplayWirelessSyncBanner
|
|
{
|
|
get => this._displayWirelessSyncBanner && !this.CurrentDevice.IsWirelessSyncEnabled;
|
|
set
|
|
{
|
|
if (this._displayWirelessSyncBanner == value)
|
|
return;
|
|
this._displayWirelessSyncBanner = value;
|
|
this.FirePropertyChanged(nameof(DisplayWirelessSyncBanner));
|
|
}
|
|
}
|
|
|
|
public UIDevice CurrentDevice
|
|
{
|
|
get => this._currentDevice ?? UIDeviceList.NullDevice;
|
|
private set
|
|
{
|
|
if (this._currentDevice == value)
|
|
return;
|
|
this._currentDevice = value ?? UIDeviceList.NullDevice;
|
|
PhoneBrandingStringMap.Instance.BrandingEnabled = this._currentDevice != null && this._currentDevice.SupportsBrandingType(DeviceBranding.WindowsPhone);
|
|
KinBrandingStringMap.Instance.BrandingEnabled = this._currentDevice != null && this._currentDevice.SupportsBrandingType(DeviceBranding.Kin);
|
|
this.FirePropertyChanged(nameof(CurrentDevice));
|
|
}
|
|
}
|
|
|
|
public UIDevice CurrentDeviceOverride => DeviceManagement.SetupDevice ?? this.CurrentDevice;
|
|
|
|
public bool ChangeIntoSetupDevice
|
|
{
|
|
get => this._changeIntoSetupDevice;
|
|
set
|
|
{
|
|
if (this._changeIntoSetupDevice == value)
|
|
return;
|
|
this._changeIntoSetupDevice = value;
|
|
this.FirePropertyChanged(nameof(ChangeIntoSetupDevice));
|
|
}
|
|
}
|
|
|
|
public Command DeviceSignInFailureEvent
|
|
{
|
|
get
|
|
{
|
|
if (this._deviceSignInFailureEvent == null)
|
|
this._deviceSignInFailureEvent = new Command(this);
|
|
return this._deviceSignInFailureEvent;
|
|
}
|
|
}
|
|
|
|
public Queue<UIDevice> FailedSignInDevices
|
|
{
|
|
get
|
|
{
|
|
if (this._failedSignInQueue == null)
|
|
this._failedSignInQueue = new Queue<UIDevice>();
|
|
return this._failedSignInQueue;
|
|
}
|
|
}
|
|
|
|
public UIDevice CurrentFailedSignInDevice
|
|
{
|
|
get
|
|
{
|
|
try
|
|
{
|
|
return this.FailedSignInDevices.Peek();
|
|
}
|
|
catch (InvalidOperationException ex)
|
|
{
|
|
return UIDeviceList.NullDevice;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void SetCurrentDevice(UIDevice device)
|
|
{
|
|
if (device == null)
|
|
device = UIDeviceList.NullDevice;
|
|
if (this._canonicalNameToMakeActive != null && device.CanonicalName != null && device.CanonicalName.StartsWith(this._canonicalNameToMakeActive))
|
|
{
|
|
this._canonicalNameToMakeActive = null;
|
|
if ((!(ZuneShell.DefaultInstance.CurrentPage is QuickplayPage) || !ClientConfiguration.FUE.ShowArtistChooser) && (ZuneShell.DefaultInstance.Management.CurrentCategoryPage == null || !ZuneShell.DefaultInstance.Management.CurrentCategoryPage.IsWizard))
|
|
ZuneShell.DefaultInstance.NavigateToPage(new Deviceland());
|
|
}
|
|
if (device == this.CurrentDevice)
|
|
return;
|
|
Management management = null;
|
|
CategoryPage categoryPage = null;
|
|
if (ZuneShell.DefaultInstance != null)
|
|
management = ZuneShell.DefaultInstance.Management;
|
|
if (management != null)
|
|
categoryPage = management.CurrentCategoryPage;
|
|
categoryPage?.RestartSyncIfNecessary();
|
|
this.CurrentDevice = device;
|
|
ClientConfiguration.Devices.CurrentDeviceID = this.CurrentDevice.ID;
|
|
categoryPage?.PauseSyncIfNecessary();
|
|
management?.DisposeDeviceManagement(false);
|
|
}
|
|
|
|
public void Phase3Init()
|
|
{
|
|
this._downloadTasks = DownloadTaskList.Instance;
|
|
this._downloadTasks.ActiveDownloads.PropertyChanged += new PropertyChangedEventHandler(this.OnDownloadPropertyChanged);
|
|
this._haveSeenDownloadsOngoing = this._downloadTasks.ActiveDownloads.Count > 0;
|
|
}
|
|
|
|
public void SetCurrentDeviceByCanonicalName(string canonicalName)
|
|
{
|
|
this._canonicalNameToMakeActive = canonicalName.ToLower();
|
|
if (this._deviceList == null)
|
|
return;
|
|
foreach (UIDevice device in this._deviceList)
|
|
{
|
|
if (device.IsConnectedToClient && device.CanonicalName.StartsWith(this._canonicalNameToMakeActive))
|
|
{
|
|
this.SetCurrentDevice(device);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void SetCurrentDeviceIfNecessary(UIDevice device, bool comingOutOfFirstConnect)
|
|
{
|
|
if (!device.IsConnectedToClientPhysically)
|
|
return;
|
|
this.SetCurrentDevice(device);
|
|
if (comingOutOfFirstConnect)
|
|
return;
|
|
this.ShowUnlinkedDeviceNagDialogIfNecessary();
|
|
}
|
|
|
|
public UIDevice FindNewActiveDevice() => this.FindNewActiveDevice(null);
|
|
|
|
public UIDevice FindNewActiveDevice(UIDevice excludedDevice)
|
|
{
|
|
foreach (UIDevice device in this._deviceList)
|
|
{
|
|
if (device != excludedDevice)
|
|
return device;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public void DeleteCurrentDevice()
|
|
{
|
|
if (!this.CurrentDevice.IsValid)
|
|
return;
|
|
MessageBox.Show(Shell.LoadString(StringId.IDS_DELETE_DIALOG_TITLE), Shell.LoadString(StringId.IDS_DELETE_DIALOG_TEXT), new EventHandler(this.ConfirmedDeleteDevice));
|
|
}
|
|
|
|
private void ConfirmedDeleteDevice(object sender, EventArgs e)
|
|
{
|
|
if (this.CurrentDevice.IsGuest || !this.CurrentDevice.SupportsWirelessSetupMethod1 && !this.CurrentDevice.SupportsWirelessSetupMethod2)
|
|
this.DeleteCurrentDeviceWorker();
|
|
else
|
|
WirelessSync.Instance.ClearWirelessOnDeviceForForget();
|
|
}
|
|
|
|
public void DeleteCurrentDeviceWorker()
|
|
{
|
|
if (this.CurrentDevice == null)
|
|
return;
|
|
string message = this.CurrentDevice.SupportsBrandingType(DeviceBranding.WindowsPhone) ? Shell.LoadString(StringId.IDS_PHONE_FORGET_DEVICE_DIALOG_CONTENT) : Shell.LoadString(StringId.IDS_FORGET_DEVICE_DIALOG_CONTENT);
|
|
ZuneShell.DefaultInstance.Management.CommitList.RemoveByIntValue(this.CurrentDevice.ID);
|
|
HRESULT hresult = this._deviceList.DeleteDevice(this.CurrentDevice);
|
|
if (hresult.IsError)
|
|
Shell.ShowErrorDialog(hresult.Int, StringId.IDS_DELETE_DEVICE_FAILED);
|
|
else
|
|
MessageBox.Show(Shell.LoadString(StringId.IDS_FORGET_DEVICE_DIALOG_TITLE), message, null);
|
|
}
|
|
|
|
public void PromptForAccountLinkage() => this.ShowUnlinkedDeviceNagDialog(false);
|
|
|
|
public void HideWirelessSyncBanner()
|
|
{
|
|
ClientConfiguration.Devices.ConnectionsUntilWirelessSyncBannerDisplay = -1;
|
|
this.UpdateWirelessSyncBannerDisplay();
|
|
}
|
|
|
|
public void AddDeviceToFailedSignInQueue(UIDevice device)
|
|
{
|
|
device.IsLockedAgainstSyncing = true;
|
|
this.FailedSignInDevices.Enqueue(device);
|
|
if (this.FailedSignInDevices.Count != 1)
|
|
return;
|
|
this.ShowFailedSignInMessageBox();
|
|
}
|
|
|
|
public void HandleFailedSignInDevice(string username, string password)
|
|
{
|
|
this.CurrentFailedSignInDevice.SendMarketplaceCredentials(username, password);
|
|
this.IgnoreFailedSignInDevice();
|
|
}
|
|
|
|
public void IgnoreFailedSignInDevice()
|
|
{
|
|
try
|
|
{
|
|
UIDevice uiDevice = this.FailedSignInDevices.Dequeue();
|
|
uiDevice.IsLockedAgainstSyncing = false;
|
|
uiDevice.BeginSync();
|
|
}
|
|
catch (InvalidOperationException ex)
|
|
{
|
|
}
|
|
if (this.FailedSignInDevices.Count <= 0)
|
|
return;
|
|
this.ShowFailedSignInMessageBox();
|
|
}
|
|
|
|
public void HandleFailedSignInDeviceGuidMismatch()
|
|
{
|
|
string message = string.IsNullOrEmpty(this.CurrentFailedSignInDevice.ZuneTag) ? string.Format(Shell.LoadString(StringId.IDS_DEVICE_CREDS_GUID_MISMATCH_TEXT_UNKNONW_ZUNETAG), CurrentFailedSignInDevice.Name, SignIn.Instance.ZuneTag) : string.Format(Shell.LoadString(StringId.IDS_DEVICE_CREDS_GUID_MISMATCH_TEXT), CurrentFailedSignInDevice.Name, CurrentFailedSignInDevice.ZuneTag, SignIn.Instance.ZuneTag);
|
|
MessageBox.Show(Shell.LoadString(StringId.IDS_DEVICE_CREDS_GUID_MISMATCH_TITLE), message, new Command(this, Shell.LoadString(StringId.IDS_ENTER_CREDENTIALS), delegate
|
|
{
|
|
this.DeviceSignInFailureEvent.Invoke();
|
|
}), null, delegate
|
|
{
|
|
this.IgnoreFailedSignInDevice();
|
|
}, true);
|
|
}
|
|
|
|
private void ShowFailedSignInMessageBox()
|
|
{
|
|
string message = string.IsNullOrEmpty(this.CurrentFailedSignInDevice.ZuneTag) ? string.Format(Shell.LoadString(StringId.IDS_DEVICE_SIGN_IN_FAILURE_TEXT_UNKNONW_ZUNETAG), CurrentFailedSignInDevice.Name) : string.Format(Shell.LoadString(StringId.IDS_DEVICE_SIGN_IN_FAILURE_TEXT), CurrentFailedSignInDevice.Name, CurrentFailedSignInDevice.ZuneTag);
|
|
MessageBox.Show(Shell.LoadString(StringId.IDS_DEVICE_SIGN_IN_FAILURE_TITLE), message, new Command(this, Shell.LoadString(StringId.IDS_ENTER_CREDENTIALS), delegate
|
|
{
|
|
this.DeviceSignInFailureEvent.Invoke();
|
|
}), null, delegate
|
|
{
|
|
this.IgnoreFailedSignInDevice();
|
|
}, true);
|
|
}
|
|
|
|
private void OnFUECompleted(object sender, EventArgs args)
|
|
{
|
|
Fue.FUECompleted -= new EventHandler(this.OnFUECompleted);
|
|
if (this._deferredArrivalDevice != null)
|
|
this.OnDeviceConnected(null, new DeviceListEventArgs(this._deferredArrivalDevice));
|
|
this._deferredArrivalDevice = null;
|
|
}
|
|
|
|
private void OnDeviceConnected(object sender, DeviceListEventArgs args)
|
|
{
|
|
if (args.Device.SupportsBrandingType(DeviceBranding.WindowsPhone) && ZuneApplication.IsDesktopLocked && !args.Device.IsConnectedToClientWirelessly)
|
|
SingletonModelItem<UIDeviceList>.Instance.HideDevice(args.Device);
|
|
else if (Fue.Instance.IsFirstLaunch)
|
|
{
|
|
if (ZuneApplication.InstallContext != SetupInstallContext.Zune && args.Device.SupportsBrandingType(DeviceBranding.WindowsPhone) && !args.Device.RequiresAutoRestore)
|
|
return;
|
|
this._deferredArrivalDevice = args.Device;
|
|
Fue.FUECompleted += new EventHandler(this.OnFUECompleted);
|
|
}
|
|
else
|
|
{
|
|
DeviceManagement.SetupQueue[args.Device.ID] = args.Device;
|
|
if (ClientConfiguration.Devices.ConnectionsUntilWirelessSyncBannerDisplay > 0)
|
|
--ClientConfiguration.Devices.ConnectionsUntilWirelessSyncBannerDisplay;
|
|
this.UpdateWirelessSyncBannerDisplay();
|
|
}
|
|
}
|
|
|
|
private void OnDeviceDisconnected(object sender, DeviceListEventArgs args)
|
|
{
|
|
if (this._deferredArrivalDevice == args.Device)
|
|
{
|
|
this._deferredArrivalDevice = null;
|
|
Fue.FUECompleted -= new EventHandler(this.OnFUECompleted);
|
|
}
|
|
else
|
|
{
|
|
if (args.Device == this.CurrentDevice)
|
|
{
|
|
ZuneShell.DefaultInstance.Management.DisposeDeviceManagement(false);
|
|
this.HideUnlinkedDeviceNagDialog();
|
|
foreach (UIDevice device in this._deviceList)
|
|
{
|
|
if (device != args.Device && device.IsConnectedToClientPhysically)
|
|
{
|
|
this.SetCurrentDevice(device);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (DeviceManagement.SetupDevice != args.Device)
|
|
return;
|
|
ZuneShell.DefaultInstance.Management.AlertedDeviceCategory = null;
|
|
}
|
|
}
|
|
|
|
private void OnDeviceAdded(object sender, DeviceListEventArgs args)
|
|
{
|
|
if (args.Device.ID != ClientConfiguration.Devices.CurrentDeviceID && ClientConfiguration.Devices.CurrentDeviceID != 0 && (this.CurrentDevice.IsConnectedToClient || !args.Device.IsConnectedToClient))
|
|
return;
|
|
this.SetCurrentDevice(args.Device);
|
|
}
|
|
|
|
private void OnDeviceRemoved(object sender, DeviceListEventArgs args)
|
|
{
|
|
if (args.Device != this.CurrentDevice)
|
|
return;
|
|
this.SetCurrentDevice(this.FindNewActiveDevice(this.CurrentDevice));
|
|
}
|
|
|
|
private void OnDeviceConnectionHandled(object sender, DeviceConnectionHandledEventArgs args)
|
|
{
|
|
if (!args.IsFirstConnect)
|
|
return;
|
|
ClientConfiguration.Devices.ConnectionsUntilWirelessSyncBannerDisplay = 1;
|
|
this.UpdateWirelessSyncBannerDisplay();
|
|
}
|
|
|
|
private void UpdateWirelessSyncBannerDisplay() => this.DisplayWirelessSyncBanner = ClientConfiguration.Devices.ConnectionsUntilWirelessSyncBannerDisplay == 0;
|
|
|
|
private void OnDownloadPropertyChanged(object sender, PropertyChangedEventArgs args)
|
|
{
|
|
if (!(args.PropertyName == "Count"))
|
|
return;
|
|
if (this._downloadTasks.ActiveDownloads.Count > 0)
|
|
{
|
|
this._haveSeenDownloadsOngoing = true;
|
|
}
|
|
else
|
|
{
|
|
if (!this._haveSeenDownloadsOngoing)
|
|
return;
|
|
foreach (UIDevice device in this._deviceList)
|
|
{
|
|
if (device.IsConnectedToClient)
|
|
device.BeginSync(true, true);
|
|
}
|
|
this._haveSeenDownloadsOngoing = false;
|
|
}
|
|
}
|
|
|
|
private void SignInPropertyChanged(object sender, PropertyChangedEventArgs args)
|
|
{
|
|
if (!(args.PropertyName == "SignedIn") || !SignIn.Instance.SignedIn)
|
|
return;
|
|
this.ShowUnlinkedDeviceNagDialogIfNecessary();
|
|
}
|
|
|
|
private void AccountCreationFinished(object sender, EventArgs args) => this.ShowUnlinkedDeviceNagDialogIfNecessary();
|
|
|
|
private void ShowUnlinkedDeviceNagDialogIfNecessary()
|
|
{
|
|
if (!this.CurrentDevice.PromptForAccountLinkage || this.CurrentDevice.IsGuest || (this.CurrentDevice.UserId != 0 || !this.CurrentDevice.IsConnectedToClientPhysically) || (!this.CurrentDevice.SupportsZuneTagLinking || !SignIn.Instance.SignedIn || (AccountCreationWizard.AccountCreationInProgress || ZuneShell.DefaultInstance.CurrentPage is DialogPage)))
|
|
return;
|
|
this.ShowUnlinkedDeviceNagDialog(true);
|
|
}
|
|
|
|
private void ShowUnlinkedDeviceNagDialog(bool allowUserToOptOut)
|
|
{
|
|
if (!SettingsExperience.ShouldShowDeviceMarketplaceCategory)
|
|
return;
|
|
this.HideUnlinkedDeviceNagDialog();
|
|
SQMLog.Log(SQMDataId.UnlinkedDeviceNagDialogShow, 1);
|
|
UIDevice device = this.CurrentDevice;
|
|
BooleanChoice optOutChoice = null;
|
|
Command okCommand = new Command(this, DialogHelper.DialogYes, delegate
|
|
{
|
|
SQMLog.Log(SQMDataId.UnlinkedDeviceNagDialogYes, 1);
|
|
Shell.SettingsFrame.Settings.Device.Invoke(SettingCategories.DeviceMarketplace);
|
|
});
|
|
EventHandler cancelCommand = delegate
|
|
{
|
|
SQMLog.Log(SQMDataId.UnlinkedDeviceNagDialogNo, 1);
|
|
if (optOutChoice == null || optOutChoice.Value)
|
|
return;
|
|
SQMLog.Log(SQMDataId.UnlinkedDeviceNagDialogNoShow, 1);
|
|
};
|
|
if (allowUserToOptOut)
|
|
{
|
|
optOutChoice = new BooleanChoice();
|
|
optOutChoice.Value = !device.PromptForAccountLinkage;
|
|
optOutChoice.ChosenChanged += delegate
|
|
{
|
|
device.PromptForAccountLinkage = !optOutChoice.Value;
|
|
};
|
|
optOutChoice.Description = Shell.LoadString(StringId.IDS_DONT_SHOW_THIS_MESSAGE_AGAIN);
|
|
}
|
|
this._currentUnlinkedDeviceDialog = MessageBox.Show(_unlinkedDeviceNagDialogTitle, string.Format(_unlinkedDeviceNagDialogMessageBase, device.Name), DialogHelper.DialogNo, true, okCommand, null, null, cancelCommand, optOutChoice);
|
|
}
|
|
|
|
private void HideUnlinkedDeviceNagDialog()
|
|
{
|
|
if (this._currentUnlinkedDeviceDialog == null || this._currentUnlinkedDeviceDialog.WouldLikeToBeHidden)
|
|
return;
|
|
this._currentUnlinkedDeviceDialog.Hide();
|
|
}
|
|
|
|
public static int ConvertSyncOperationToInt(ESyncOperation operation) => (int)operation;
|
|
|
|
public static int ConvertSyncStateToInt(ESyncState state) => (int)state;
|
|
|
|
public static int ConvertSyncStatusToInt(TrackSyncStatus status) => (int)status;
|
|
|
|
public static int GetGasGaugeSegmentWidth(
|
|
int maxWidth,
|
|
long size,
|
|
long totalSize,
|
|
int margins)
|
|
{
|
|
totalSize = Math.Max(totalSize, 1L);
|
|
size = Math.Max(size, 0L);
|
|
return Math.Max((int)Math.Min(maxWidth * size / totalSize, maxWidth - margins), 0);
|
|
}
|
|
|
|
public static long DevicelandKilobyte => _devicelandKilobyte;
|
|
|
|
public static long DevicelandMegabyte => _devicelandMegabyte;
|
|
|
|
public static long DevicelandGigabyte => _devicelandGigabyte;
|
|
|
|
public static string FormatLongAsSize(long sizeInBytes)
|
|
{
|
|
if (sizeInBytes < DevicelandMegabyte && sizeInBytes != 0L)
|
|
return string.Format(_sizeInKB, (float)(sizeInBytes / (double)DevicelandKilobyte));
|
|
return sizeInBytes < DevicelandGigabyte ? string.Format(_sizeInMB, (float)(sizeInBytes / (double)DevicelandMegabyte)) : string.Format(_sizeInGB, (float)(sizeInBytes / (double)DevicelandGigabyte));
|
|
}
|
|
|
|
public void BrowseAndReplaceMedia(IList items, int mediaType) => FileOpenDialog.Show(Shell.LoadString(StringId.IDS_OPEN_FILE_DIALOG_TITLE), ZuneShell.DefaultInstance.Management.MediaFolder, args =>
|
|
{
|
|
string path = (string)args;
|
|
if (string.IsNullOrEmpty(path))
|
|
return;
|
|
Shell.DeleteMedia(items, false);
|
|
Application.DeferredInvoke(delegate
|
|
{
|
|
try
|
|
{
|
|
if (!ZuneApplication.ZuneLibrary.CanAddMedia(path, (EMediaTypes)mediaType))
|
|
return;
|
|
ZuneApplication.ZuneLibrary.AddMedia(path);
|
|
}
|
|
catch (UnauthorizedAccessException ex)
|
|
{
|
|
}
|
|
catch (IOException ex)
|
|
{
|
|
}
|
|
}, null);
|
|
});
|
|
|
|
public static SyncControls Instance
|
|
{
|
|
get
|
|
{
|
|
if (s_singletonInstance == null)
|
|
s_singletonInstance = new SyncControls(ZuneShell.DefaultInstance);
|
|
return s_singletonInstance;
|
|
}
|
|
}
|
|
}
|
|
}
|