/// <summary>
/// helper for all list by functions
/// </summary>
private async Task GroupByHelperAsync(QueryOptions queryOptions)
{
GroupedFiles.Clear();
StorageFolder picturesFolder = await KnownFolders.GetFolderForUserAsync(null /* current user */, KnownFolderId.PicturesLibrary);
StorageFolderQueryResult queryResult = picturesFolder.CreateFolderQueryWithOptions(queryOptions);
IReadOnlyList <StorageFolder> folderList = await queryResult.GetFoldersAsync();
foreach (StorageFolder folder in folderList)
{
IReadOnlyList <StorageFile> fileList = await folder.GetFilesAsync();
var newList = new List <string>();
newList.Add("Group: " + folder.Name + " (" + fileList.Count + ")");
GroupedFiles.Add(newList);
foreach (StorageFile file in fileList)
{
newList.Add(file.Name);
}
}
}
private async static Task <IReadOnlyList <IStorageItem> > EnumerateFileQuery(string path, string searchPattern, SearchOption searchOption, SearchTarget searchTarget)
{
// Get a StorageFolder for "path"
string fullPath = Path.GetFullPath(path);
StorageFolder folder = await StorageFolder.GetFolderFromPathAsync(fullPath).TranslateWinRTTask(fullPath, isDirectory: true);
// Construct a query for the search.
QueryOptions query = new QueryOptions();
// Translate SearchOption into FolderDepth
query.FolderDepth = searchOption == SearchOption.AllDirectories ? FolderDepth.Deep : FolderDepth.Shallow;
// Construct an AQS filter
string normalizedSearchPattern = PathHelpers.NormalizeSearchPattern(searchPattern);
if (normalizedSearchPattern.Length == 0)
{
// An empty searchPattern will return no results and requires no AQS parsing.
return(new IStorageItem[0]);
}
else
{
// Parse the query as an ItemPathDisplay filter.
string searchPath = PathHelpers.GetFullSearchString(fullPath, normalizedSearchPattern);
string aqs = "System.ItemPathDisplay:~\"" + searchPath + "\"";
query.ApplicationSearchFilter = aqs;
// If the filtered path is deeper than the given user path, we need to get a new folder for it.
// This occurs when someone does something like Enumerate("C:\first\second\", "C:\first\second\third\*").
// When AllDirectories is set this isn't an issue, but for TopDirectoryOnly we have to do some special work
// to make sure something is actually returned when the searchPattern is a subdirectory of the path.
// To do this, we attempt to get a new StorageFolder for the subdirectory and return an empty enumerable
// if we can't.
string searchPatternDirName = Path.GetDirectoryName(normalizedSearchPattern);
string userPath = string.IsNullOrEmpty(searchPatternDirName) ? fullPath : Path.Combine(fullPath, searchPatternDirName);
if (userPath != folder.Path)
{
folder = await StorageFolder.GetFolderFromPathAsync(userPath).TranslateWinRTTask(userPath, isDirectory: true);
}
}
// Execute our built query
if (searchTarget == SearchTarget.Files)
{
StorageFileQueryResult queryResult = folder.CreateFileQueryWithOptions(query);
return(await queryResult.GetFilesAsync().TranslateWinRTTask(folder.Path, isDirectory: true));
}
else if (searchTarget == SearchTarget.Directories)
{
StorageFolderQueryResult queryResult = folder.CreateFolderQueryWithOptions(query);
return(await queryResult.GetFoldersAsync().TranslateWinRTTask(folder.Path, isDirectory: true));
}
else
{
StorageItemQueryResult queryResult = folder.CreateItemQueryWithOptions(query);
return(await queryResult.GetItemsAsync().TranslateWinRTTask(folder.Path, isDirectory: true));
}
}
public static async Task CopyAsync(StorageFolder source, StorageFolder destination)
{
if (_cancel)
{
return;
}
// If the destination exists, delete it.
var targetFolder = await destination.TryGetItemAsync(source.DisplayName);
if (targetFolder is StorageFolder)
{
await targetFolder.DeleteAsync();
}
targetFolder = await destination.CreateFolderAsync(source.DisplayName);
// Get all files (shallow) from source
var queryOptions = new QueryOptions
{
IndexerOption = IndexerOption.DoNotUseIndexer, // Avoid problems cause by out of sync indexer
FolderDepth = FolderDepth.Shallow,
};
var queryFiles = source.CreateFileQueryWithOptions(queryOptions);
var files = await queryFiles.GetFilesAsync();
// Copy files into target folder
foreach (var storageFile in files)
{
await storageFile.CopyAsync((StorageFolder)targetFolder, storageFile.Name, NameCollisionOption.ReplaceExisting);
FileCount++;
updateProgress?.Invoke(FileCount, FolderCount);
if (_cancel)
{
return;
}
}
// Get all folders (shallow) from source
var queryFolders = source.CreateFolderQueryWithOptions(queryOptions);
var folders = await queryFolders.GetFoldersAsync();
// For each folder call CopyAsync with new destination as destination
foreach (var storageFolder in folders)
{
await CopyAsync(storageFolder, (StorageFolder)targetFolder);
FolderCount++;
if (_cancel)
{
return;
}
}
}
internal static StorageFolderQueryResult GetVideoFoldersQuery(StorageFolder Folder)
{
if (videoFolderOptions is default(QueryOptions))
{
videoFolderOptions = new QueryOptions(CommonFolderQuery.DefaultQuery)
{
IndexerOption = IndexerOption.UseIndexerWhenAvailable
};
}
return(Folder.CreateFolderQueryWithOptions(videoFolderOptions));
}
public static async Task <List <StorageFile> > Search4Files(string filename, StorageFolder destination)
{
if (_cancel)
{
return(null);
}
// Get all files (shallow) from source
var queryOptions = new QueryOptions
{
IndexerOption = IndexerOption.DoNotUseIndexer, // Avoid problems cause by out of sync indexer
FolderDepth = FolderDepth.Shallow,
};
var queryFiles = destination.CreateFileQueryWithOptions(queryOptions);
var files = await queryFiles.GetFilesAsync();
var fil = from f in files where f.Name.Contains(filename) select f;
if (fil.Count() > 0)
{
return(fil.ToList <StorageFile>());
}
// Get all folders (shallow) from source
var queryFolders = destination.CreateFolderQueryWithOptions(queryOptions);
var folders = await queryFolders.GetFoldersAsync();
// For each folder, call query
foreach (var storageFolder in folders)
{
var fill = await Search4Files(filename, storageFolder);
if (fill != null)
{
return(fill);
}
if (_cancel)
{
return(null);
}
}
return(null);
}
private async static Task <IReadOnlyList <StorageFolder> > GetWslDriveAsync()
{
try
{
StorageFolder WslBaseFolder = await StorageFolder.GetFolderFromPathAsync(@"\\wsl$");
StorageFolderQueryResult Query = WslBaseFolder.CreateFolderQueryWithOptions(new QueryOptions
{
FolderDepth = FolderDepth.Shallow,
IndexerOption = IndexerOption.DoNotUseIndexer
});
return(await Query.GetFoldersAsync());
}
catch
{
return(new List <StorageFolder>(0));
}
}
/// <summary>
/// helper for all list by functions
/// </summary>
async Task GroupByHelperAsync(QueryOptions queryOptions)
{
OutputPanel.Children.Clear();
StorageFolder picturesFolder = KnownFolders.PicturesLibrary;
StorageFolderQueryResult queryResult = picturesFolder.CreateFolderQueryWithOptions(queryOptions);
IReadOnlyList <StorageFolder> folderList = await queryResult.GetFoldersAsync();
foreach (StorageFolder folder in folderList)
{
IReadOnlyList <StorageFile> fileList = await folder.GetFilesAsync();
OutputPanel.Children.Add(CreateHeaderTextBlock(folder.Name + " (" + fileList.Count + ")"));
foreach (StorageFile file in fileList)
{
OutputPanel.Children.Add(CreateLineItemTextBlock(file.Name));
}
}
}
public override async Task <string[]> GetFolderEntries()
{
var options = new QueryOptions(CommonFolderQuery.DefaultQuery);
options.FolderDepth = FolderDepth.Deep;
var subFolders = await folder.CreateFolderQueryWithOptions(options).GetFoldersAsync();
var output = new List <string>(subFolders.Count);
output.Add(@"\");
var startIndex = folder.Path.Length + 1;
foreach (var folder in subFolders)
{
output.Add(folder.Path.Substring(startIndex));
}
return(output.ToArray());
}
public static async Task <List <StorageFolder> > GetSubfolders(StorageFolder parent)
{
List <StorageFolder> subfolders = new List <StorageFolder>();
if (parent == null)
{
return(subfolders);
}
await FileErrorHelper.RunMethodAsync(async delegate(String path)
{
var clock = new WallClockMeasurement();
var folderOptions = new QueryOptions(CommonFolderQuery.DefaultQuery);
folderOptions.FolderDepth = FolderDepth.Deep;
var folderQuery = parent.CreateFolderQueryWithOptions(folderOptions);
var unsortedFolders = await folderQuery.GetFoldersAsync();
subfolders = unsortedFolders.OrderBy(f => f.Path).ToList();
clock.Report(0, "Querying " + subfolders.Count() + " subfolders of " + parent.Path);
}, parent.Path);
return(subfolders);
}
private async Task SwitchFolderAsync(string path, CancellationToken cancellationToken)
{
currentPath = path;
currentFolder = await FileSystem.GetFolderAsync(path);
var indexedState = await currentFolder.GetIndexedStateAsync();
fileQueryOptions.SetThumbnailPrefetch(thumbnailOptions.Mode, thumbnailOptions.Size, thumbnailOptions.Scale);
if (indexedState == IndexedState.FullyIndexed)
{
fileQueryOptions.IndexerOption = IndexerOption.OnlyUseIndexerAndOptimizeForIndexedProperties;
folderQueryOptions.IndexerOption = IndexerOption.OnlyUseIndexerAndOptimizeForIndexedProperties;
}
else
{
fileQueryOptions.IndexerOption = IndexerOption.UseIndexerWhenAvailable;
folderQueryOptions.IndexerOption = IndexerOption.UseIndexerWhenAvailable;
}
folderQuery = currentFolder.CreateFolderQueryWithOptions(folderQueryOptions);
fileQuery = currentFolder.CreateFileQueryWithOptions(fileQueryOptions);
Clear();
await LoadFoldersAsync(cancellationToken);
await LoadFilesAsync(cancellationToken);
//var folders = await folderQuery.GetFoldersAsync();
//var files = await fileQuery.GetFilesAsync();
//await AddFoldersAsync(folders, cancellationToken);
//await AddFilesAsync(files, cancellationToken);
fileQuery.ContentsChanged += ItemQuery_ContentsChanged;
s.Stop();
Debug.WriteLine("Load took: " + s.ElapsedMilliseconds + "ms");
}
public async void MemoryFriendlyGetItemsAsync(string path, Page passedPage)
{
TextState.isVisible = Visibility.Collapsed;
tokenSource = new CancellationTokenSource();
CancellationToken token = App.ViewModel.tokenSource.Token;
pageName = passedPage.Name;
Universal.path = path;
// Personalize retrieved items for view they are displayed in
switch (pageName)
{
case "GenericItemView":
isPhotoAlbumMode = false;
break;
case "PhotoAlbumViewer":
isPhotoAlbumMode = true;
break;
case "ClassicModePage":
isPhotoAlbumMode = false;
break;
}
if (pageName != "ClassicModePage")
{
FilesAndFolders.Clear();
}
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
Universal.path = path; // Set visible path to reflect new navigation
try
{
PVIS.isVisible = Visibility.Visible;
TextState.isVisible = Visibility.Collapsed;
switch (Universal.path)
{
case "Desktop":
Universal.path = MainPage.DesktopPath;
break;
case "Downloads":
Universal.path = MainPage.DownloadsPath;
break;
case "Documents":
Universal.path = MainPage.DocumentsPath;
break;
case "Pictures":
Universal.path = MainPage.PicturesPath;
break;
case "Music":
Universal.path = MainPage.MusicPath;
break;
case "Videos":
Universal.path = MainPage.VideosPath;
break;
case "OneDrive":
Universal.path = MainPage.OneDrivePath;
break;
}
folder = await StorageFolder.GetFolderFromPathAsync(Universal.path);
History.AddToHistory(Universal.path);
if (History.HistoryList.Count == 1)
{
BS.isEnabled = false;
}
else if (History.HistoryList.Count > 1)
{
BS.isEnabled = true;
}
QueryOptions options = new QueryOptions()
{
FolderDepth = FolderDepth.Shallow,
IndexerOption = IndexerOption.UseIndexerWhenAvailable
};
string sort = "By_Name";
if (sort == "By_Name")
{
SortEntry entry = new SortEntry()
{
AscendingOrder = true,
PropertyName = "System.FileName"
};
options.SortOrder.Add(entry);
}
uint index = 0;
const uint step = 250;
if (!folder.AreQueryOptionsSupported(options))
{
options.SortOrder.Clear();
}
folderQueryResult = folder.CreateFolderQueryWithOptions(options);
IReadOnlyList <StorageFolder> folders = await folderQueryResult.GetFoldersAsync(index, step);
int foldersCountSnapshot = folders.Count;
while (folders.Count != 0)
{
foreach (StorageFolder folder in folders)
{
if (token.IsCancellationRequested)
{
return;
}
gotFolName = folder.Name.ToString();
gotFolDate = folder.DateCreated.ToString();
gotFolPath = folder.Path.ToString();
gotFolType = "Folder";
gotFolImg = Visibility.Visible;
gotFileImgVis = Visibility.Collapsed;
gotEmptyImgVis = Visibility.Collapsed;
if (pageName == "ClassicModePage")
{
ClassicFolderList.Add(new Classic_ListedFolderItem()
{
FileName = gotFolName, FileDate = gotFolDate, FileExtension = gotFolType, FilePath = gotFolPath
});
}
else
{
FilesAndFolders.Add(new ListedItem()
{
EmptyImgVis = gotEmptyImgVis, ItemIndex = FilesAndFolders.Count, FileImg = null, FileIconVis = gotFileImgVis, FolderImg = gotFolImg, FileName = gotFolName, FileDate = gotFolDate, FileExtension = gotFolType, FilePath = gotFolPath
});
}
}
index += step;
folders = await folderQueryResult.GetFoldersAsync(index, step);
}
index = 0;
fileQueryResult = folder.CreateFileQueryWithOptions(options);
IReadOnlyList <StorageFile> files = await fileQueryResult.GetFilesAsync(index, step);
int filesCountSnapshot = files.Count;
while (files.Count != 0)
{
foreach (StorageFile file in files)
{
if (token.IsCancellationRequested)
{
return;
}
gotName = file.DisplayName.ToString();
gotDate = file.DateCreated.ToString(); // In the future, parse date to human readable format
if (file.FileType.ToString() == ".exe")
{
gotType = "Executable";
}
else
{
gotType = file.DisplayType;
}
gotPath = file.Path.ToString();
gotFolImg = Visibility.Collapsed;
gotDotFileExtension = file.FileType;
if (isPhotoAlbumMode == false)
{
const uint requestedSize = 20;
const ThumbnailMode thumbnailMode = ThumbnailMode.ListView;
const ThumbnailOptions thumbnailOptions = ThumbnailOptions.UseCurrentScale;
try
{
gotFileImg = await file.GetThumbnailAsync(thumbnailMode, requestedSize, thumbnailOptions);
BitmapImage icon = new BitmapImage();
if (gotFileImg != null)
{
gotEmptyImgVis = Visibility.Collapsed;
icon.SetSource(gotFileImg.CloneStream());
}
else
{
gotEmptyImgVis = Visibility.Visible;
}
gotFileImgVis = Visibility.Visible;
if (pageName == "ClassicModePage")
{
ClassicFileList.Add(new ListedItem()
{
FileImg = icon, FileIconVis = gotFileImgVis, FolderImg = gotFolImg, FileName = gotName, FileDate = gotDate, FileExtension = gotType, FilePath = gotPath
});
}
else
{
FilesAndFolders.Add(new ListedItem()
{
DotFileExtension = gotDotFileExtension, EmptyImgVis = gotEmptyImgVis, FileImg = icon, FileIconVis = gotFileImgVis, FolderImg = gotFolImg, FileName = gotName, FileDate = gotDate, FileExtension = gotType, FilePath = gotPath
});
}
}
catch
{
// Silent catch here to avoid crash
// TODO maybe some logging could be added in the future...
}
}
else
{
const uint requestedSize = 275;
const ThumbnailMode thumbnailMode = ThumbnailMode.PicturesView;
const ThumbnailOptions thumbnailOptions = ThumbnailOptions.ResizeThumbnail;
try
{
gotFileImg = await file.GetThumbnailAsync(thumbnailMode, requestedSize, thumbnailOptions);
BitmapImage icon = new BitmapImage();
if (gotFileImg != null)
{
gotEmptyImgVis = Visibility.Collapsed;
icon.SetSource(gotFileImg.CloneStream());
}
else
{
gotEmptyImgVis = Visibility.Visible;
}
gotFileImgVis = Visibility.Visible;
if (pageName == "ClassicModePage")
{
ClassicFileList.Add(new ListedItem()
{
FileImg = icon, FileIconVis = gotFileImgVis, FolderImg = gotFolImg, FileName = gotName, FileDate = gotDate, FileExtension = gotType, FilePath = gotPath
});
}
else
{
FilesAndFolders.Add(new ListedItem()
{
DotFileExtension = gotDotFileExtension, EmptyImgVis = gotEmptyImgVis, FileImg = icon, FileIconVis = gotFileImgVis, FolderImg = gotFolImg, FileName = gotName, FileDate = gotDate, FileExtension = gotType, FilePath = gotPath
});
}
}
catch
{
// Silent catch here to avoid crash
// TODO maybe some logging could be added in the future...
}
}
}
index += step;
files = await fileQueryResult.GetFilesAsync(index, step);
}
if (foldersCountSnapshot + filesCountSnapshot == 0)
{
TextState.isVisible = Visibility.Visible;
}
if (pageName != "ClassicModePage")
{
PVIS.isVisible = Visibility.Collapsed;
}
PVIS.isVisible = Visibility.Collapsed;
stopwatch.Stop();
Debug.WriteLine("Loading of: " + path + " completed in " + stopwatch.ElapsedMilliseconds + " Milliseconds.");
}
catch (UnauthorizedAccessException e)
{
if (path.Contains(@"C:\"))
{
DisplayConsentDialog();
}
else
{
MessageDialog unsupportedDevice = new MessageDialog("This device may be unsupported. Please file an issue report in Settings - About containing what device we couldn't access. Technical information: " + e, "Unsupported Device");
await unsupportedDevice.ShowAsync();
}
stopwatch.Stop();
Debug.WriteLine("Loading of: " + Universal.path + " failed in " + stopwatch.ElapsedMilliseconds + " Milliseconds.");
}
catch (COMException e)
{
stopwatch.Stop();
Debug.WriteLine("Loading of: " + Universal.path + " failed in " + stopwatch.ElapsedMilliseconds + " Milliseconds.");
Frame rootFrame = Window.Current.Content as Frame;
MessageDialog driveGone = new MessageDialog(e.Message, "Drive Unplugged");
await driveGone.ShowAsync();
rootFrame.Navigate(typeof(MainPage), new SuppressNavigationTransitionInfo());
}
tokenSource = null;
}
public async void AddItemsToCollectionAsync(string path, Page currentPage)
{
CancelLoadAndClearFiles();
_cancellationTokenSource = new CancellationTokenSource();
var tokenSourceCopy = _cancellationTokenSource;
TextState.isVisible = Visibility.Collapsed;
_pageName = currentPage.Name;
Universal.path = path;
if (!_pageName.Contains("Classic"))
{
_filesAndFolders.Clear();
}
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
PVIS.isVisible = Visibility.Visible;
switch (Universal.path)
{
case "Desktop":
Universal.path = MainPage.DesktopPath;
break;
case "Downloads":
Universal.path = MainPage.DownloadsPath;
break;
case "Documents":
Universal.path = MainPage.DocumentsPath;
break;
case "Pictures":
Universal.path = MainPage.PicturesPath;
break;
case "Music":
Universal.path = MainPage.MusicPath;
break;
case "Videos":
Universal.path = MainPage.VideosPath;
break;
case "OneDrive":
Universal.path = MainPage.OneDrivePath;
break;
}
try
{
_rootFolder = await StorageFolder.GetFolderFromPathAsync(Universal.path);
History.AddToHistory(Universal.path);
if (History.HistoryList.Count == 1) // If this is the only item present in History, we don't want back button to be enabled
{
BS.isEnabled = false;
}
else if (History.HistoryList.Count > 1) // Otherwise, if this is not the first item, we'll enable back click
{
BS.isEnabled = true;
}
switch (await _rootFolder.GetIndexedStateAsync())
{
case (IndexedState.FullyIndexed):
_options = new QueryOptions();
_options.FolderDepth = FolderDepth.Shallow;
if (_pageName.Contains("Generic"))
{
_options.SetThumbnailPrefetch(ThumbnailMode.ListView, 20, ThumbnailOptions.UseCurrentScale);
_options.SetPropertyPrefetch(PropertyPrefetchOptions.BasicProperties, new string[] { "System.DateModified", "System.ContentType", "System.Size", "System.FileExtension" });
}
else if (_pageName.Contains("Photo"))
{
_options.SetThumbnailPrefetch(ThumbnailMode.PicturesView, 275, ThumbnailOptions.ResizeThumbnail);
_options.SetPropertyPrefetch(PropertyPrefetchOptions.BasicProperties, new string[] { "System.FileExtension" });
}
_options.IndexerOption = IndexerOption.OnlyUseIndexerAndOptimizeForIndexedProperties;
break;
default:
_options = new QueryOptions();
_options.FolderDepth = FolderDepth.Shallow;
if (_pageName.Contains("Generic"))
{
_options.SetThumbnailPrefetch(ThumbnailMode.ListView, 20, ThumbnailOptions.UseCurrentScale);
_options.SetPropertyPrefetch(PropertyPrefetchOptions.BasicProperties, new string[] { "System.DateModified", "System.ContentType", "System.ItemPathDisplay", "System.Size", "System.FileExtension" });
}
else if (_pageName.Contains("Photo"))
{
_options.SetThumbnailPrefetch(ThumbnailMode.PicturesView, 275, ThumbnailOptions.ResizeThumbnail);
_options.SetPropertyPrefetch(PropertyPrefetchOptions.BasicProperties, new string[] { "System.FileExtension" });
}
_options.IndexerOption = IndexerOption.UseIndexerWhenAvailable;
break;
}
SortEntry sort = new SortEntry()
{
PropertyName = "System.FileName",
AscendingOrder = true
};
_options.SortOrder.Add(sort);
if (!_rootFolder.AreQueryOptionsSupported(_options))
{
_options.SortOrder.Clear();
}
uint index = 0;
_folderQueryResult = _rootFolder.CreateFolderQueryWithOptions(_options);
//_folderQueryResult.ContentsChanged += FolderContentsChanged;
var numFolders = await _folderQueryResult.GetItemCountAsync();
IReadOnlyList <StorageFolder> storageFolders = await _folderQueryResult.GetFoldersAsync(index, _step);
while (storageFolders.Count > 0)
{
foreach (StorageFolder folder in storageFolders)
{
if (tokenSourceCopy.IsCancellationRequested)
{
return;
}
await AddFolder(folder, _pageName, tokenSourceCopy.Token);
}
index += _step;
storageFolders = await _folderQueryResult.GetFoldersAsync(index, _step);
}
index = 0;
_fileQueryResult = _rootFolder.CreateFileQueryWithOptions(_options);
_fileQueryResult.ContentsChanged += FileContentsChanged;
var numFiles = await _fileQueryResult.GetItemCountAsync();
IReadOnlyList <StorageFile> storageFiles = await _fileQueryResult.GetFilesAsync(index, _step);
while (storageFiles.Count > 0)
{
foreach (StorageFile file in storageFiles)
{
if (tokenSourceCopy.IsCancellationRequested)
{
return;
}
await AddFile(file, _pageName, tokenSourceCopy.Token);
}
index += _step;
storageFiles = await _fileQueryResult.GetFilesAsync(index, _step);
}
if (numFiles + numFolders == 0)
{
TextState.isVisible = Visibility.Visible;
}
stopwatch.Stop();
Debug.WriteLine("Loading of items in " + Universal.path + " completed in " + stopwatch.Elapsed.Seconds + " seconds.\n");
}
catch (UnauthorizedAccessException e)
{
if (path.Contains(@"C:\"))
{
DisplayConsentDialog();
}
else
{
MessageDialog unsupportedDevice = new MessageDialog("This device may be unsupported. Please file an issue report in Settings - About containing what device we couldn't access. Technical information: " + e, "Unsupported Device");
await unsupportedDevice.ShowAsync();
return;
}
}
catch (COMException e)
{
Frame rootFrame = Window.Current.Content as Frame;
MessageDialog driveGone = new MessageDialog(e.Message, "Drive Unplugged");
await driveGone.ShowAsync();
rootFrame.Navigate(typeof(MainPage), new SuppressNavigationTransitionInfo());
return;
}
if (!_pageName.Contains("Classic"))
{
PVIS.isVisible = Visibility.Collapsed;
}
PVIS.isVisible = Visibility.Collapsed;
}