public static async void PasteItemWithStatus(DataPackageView packageView, string destinationPath, DataPackageOperation acceptedOperation)
{
var CurrentInstance = App.CurrentInstance;
PostedStatusBanner banner = App.CurrentInstance.StatusBarControl.OngoingTasksControl.PostBanner(
null,
CurrentInstance.FilesystemViewModel.WorkingDirectory,
0,
StatusBanner.StatusBannerSeverity.Ongoing,
StatusBanner.StatusBannerOperation.Paste);
Stopwatch sw = new Stopwatch();
sw.Start();
await PasteItem(packageView, destinationPath, acceptedOperation, CurrentInstance, banner.Progress);
banner.Remove();
sw.Stop();
if (sw.Elapsed.TotalSeconds >= 10)
{
App.CurrentInstance.StatusBarControl.OngoingTasksControl.PostBanner(
"Paste Complete",
"The operation has completed.",
0,
StatusBanner.StatusBannerSeverity.Success,
StatusBanner.StatusBannerOperation.Paste);
}
}
public async Task <ReturnResult> MoveItemsAsync(IEnumerable <PathWithType> source, IEnumerable <string> destination, bool registerHistory)
{
PostedStatusBanner banner = associatedInstance.BottomStatusStripControl.OngoingTasksControl.PostBanner(
string.Empty,
associatedInstance.FilesystemViewModel.WorkingDirectory,
0,
ReturnResult.InProgress,
FileOperationType.Move);
ReturnResult returnStatus = ReturnResult.InProgress;
banner.ErrorCode.ProgressChanged += (s, e) => returnStatus = e.ToStatus();
Stopwatch sw = new Stopwatch();
sw.Start();
IStorageHistory history;
List <IStorageHistory> rawStorageHistory = new List <IStorageHistory>();
associatedInstance.ContentPage.ClearSelection();
for (int i = 0; i < source.Count(); i++)
{
rawStorageHistory.Add(await filesystemOperations.MoveAsync(
source.ElementAt(i),
destination.ElementAt(i),
banner.Progress,
banner.ErrorCode,
cancellationToken));
}
if (rawStorageHistory.TrueForAll((item) => item != null))
{
history = new StorageHistory(
rawStorageHistory[0].OperationType,
rawStorageHistory.SelectMany((item) => item.Source).ToList(),
rawStorageHistory.SelectMany((item) => item.Destination).ToList());
if (registerHistory && source.Any((item) => !string.IsNullOrWhiteSpace(item.Path)))
{
App.HistoryWrapper.AddHistory(history);
}
}
banner.Remove();
sw.Stop();
if (sw.Elapsed.TotalSeconds >= 10)
{
associatedInstance.BottomStatusStripControl.OngoingTasksControl.PostBanner(
"Move Complete",
"The operation has completed.",
0,
ReturnResult.Success,
FileOperationType.Move);
}
return(returnStatus);
}
public async void DecompressArchiveToChildFolder()
{
var selectedItem = associatedInstance?.SlimContentPage?.SelectedItem;
if (selectedItem == null)
{
return;
}
BaseStorageFile archive = await StorageHelpers.ToStorageItem <BaseStorageFile>(selectedItem.ItemPath);
BaseStorageFolder currentFolder = await StorageHelpers.ToStorageItem <BaseStorageFolder>(associatedInstance.FilesystemViewModel.CurrentFolder.ItemPath);
BaseStorageFolder destinationFolder = null;
if (currentFolder != null)
{
destinationFolder = await FilesystemTasks.Wrap(() => currentFolder.CreateFolderAsync(Path.GetFileNameWithoutExtension(archive.Path), CreationCollisionOption.OpenIfExists).AsTask());
}
if (archive != null && destinationFolder != null)
{
CancellationTokenSource extractCancellation = new CancellationTokenSource();
PostedStatusBanner banner = App.OngoingTasksViewModel.PostOperationBanner(
string.Empty,
"ExtractingArchiveText".GetLocalized(),
0,
ReturnResult.InProgress,
FileOperationType.Extract,
extractCancellation);
Stopwatch sw = new Stopwatch();
sw.Start();
await ZipHelpers.ExtractArchive(archive, destinationFolder, banner.Progress, extractCancellation.Token);
sw.Stop();
banner.Remove();
if (sw.Elapsed.TotalSeconds >= 6)
{
App.OngoingTasksViewModel.PostBanner(
"ExtractingCompleteText".GetLocalized(),
"ArchiveExtractionCompletedSuccessfullyText".GetLocalized(),
0,
ReturnResult.Success,
FileOperationType.Extract);
}
}
}
public async void DecompressArchiveToChildFolder()
{
StorageFile archive = await StorageItemHelpers.ToStorageItem <StorageFile>(associatedInstance.SlimContentPage.SelectedItem.ItemPath);
StorageFolder currentFolder = await StorageItemHelpers.ToStorageItem <StorageFolder>(associatedInstance.FilesystemViewModel.CurrentFolder.ItemPath);
StorageFolder destinationFolder = null;
if (currentFolder != null)
{
destinationFolder = await currentFolder.CreateFolderAsync(Path.GetFileNameWithoutExtension(archive.Path), CreationCollisionOption.OpenIfExists);
}
if (archive != null && destinationFolder != null)
{
CancellationTokenSource extractCancellation = new CancellationTokenSource();
PostedStatusBanner banner = App.StatusCenterViewModel.PostOperationBanner(
string.Empty,
"Extracting archive",
0,
ReturnResult.InProgress,
FileOperationType.Extract,
extractCancellation);
Stopwatch sw = new Stopwatch();
sw.Start();
await ZipHelpers.ExtractArchive(archive, destinationFolder, banner.Progress, extractCancellation.Token);
sw.Stop();
banner.Remove();
if (sw.Elapsed.TotalSeconds >= 6)
{
App.StatusCenterViewModel.PostBanner(
"Extracting complete!",
"The archive extraction completed successfully.",
0,
ReturnResult.Success,
FileOperationType.Extract);
}
}
}
public async Task <ReturnResult> MoveItemAsync(PathWithType source, string destination, bool registerHistory)
{
PostedStatusBanner banner = associatedInstance.BottomStatusStripControl.OngoingTasksControl.PostBanner(
string.Empty,
associatedInstance.FilesystemViewModel.WorkingDirectory,
0,
ReturnResult.InProgress,
FileOperationType.Move);
ReturnResult returnStatus = ReturnResult.InProgress;
banner.ErrorCode.ProgressChanged += (s, e) => returnStatus = e.ToStatus();
Stopwatch sw = new Stopwatch();
sw.Start();
associatedInstance.ContentPage.ClearSelection();
IStorageHistory history = await filesystemOperations.MoveAsync(source, destination, banner.Progress, banner.ErrorCode, cancellationToken);
if (registerHistory && !string.IsNullOrWhiteSpace(source.Path))
{
App.HistoryWrapper.AddHistory(history);
}
banner.Remove();
sw.Stop();
if (sw.Elapsed.TotalSeconds >= 10)
{
associatedInstance.BottomStatusStripControl.OngoingTasksControl.PostBanner(
"Move Complete",
"The operation has completed.",
0,
ReturnResult.Success,
FileOperationType.Move);
}
return(returnStatus);
}
public async void DecompressArchiveHere()
{
StorageFile archive = await StorageItemHelpers.ToStorageItem <StorageFile>(associatedInstance.SlimContentPage.SelectedItem.ItemPath);
StorageFolder currentFolder = await StorageItemHelpers.ToStorageItem <StorageFolder>(associatedInstance.FilesystemViewModel.CurrentFolder.ItemPath);
if (archive != null && currentFolder != null)
{
CancellationTokenSource extractCancellation = new CancellationTokenSource();
PostedStatusBanner banner = App.StatusCenterViewModel.PostOperationBanner(
string.Empty,
"ExtractingArchiveText".GetLocalized(),
0,
ReturnResult.InProgress,
FileOperationType.Extract,
extractCancellation);
Stopwatch sw = new Stopwatch();
sw.Start();
await ZipHelpers.ExtractArchive(archive, currentFolder, banner.Progress, extractCancellation.Token);
sw.Stop();
banner.Remove();
if (sw.Elapsed.TotalSeconds >= 6)
{
App.StatusCenterViewModel.PostBanner(
"ExtractingCompleteText".GetLocalized(),
"ArchiveExtractionCompletedSuccessfullyText".GetLocalized(),
0,
ReturnResult.Success,
FileOperationType.Extract);
}
}
}
public async void DecompressArchive()
{
BaseStorageFile archive = await StorageHelpers.ToStorageItem <BaseStorageFile>(associatedInstance.SlimContentPage.SelectedItem.ItemPath);
if (archive != null)
{
DecompressArchiveDialog decompressArchiveDialog = new DecompressArchiveDialog();
DecompressArchiveDialogViewModel decompressArchiveViewModel = new DecompressArchiveDialogViewModel(archive);
decompressArchiveDialog.ViewModel = decompressArchiveViewModel;
ContentDialogResult option = await decompressArchiveDialog.ShowAsync();
if (option == ContentDialogResult.Primary)
{
// Check if archive still exists
if (!StorageHelpers.Exists(archive.Path))
{
return;
}
CancellationTokenSource extractCancellation = new CancellationTokenSource();
PostedStatusBanner banner = App.OngoingTasksViewModel.PostOperationBanner(
string.Empty,
"ExtractingArchiveText".GetLocalized(),
0,
ReturnResult.InProgress,
FileOperationType.Extract,
extractCancellation);
BaseStorageFolder destinationFolder = decompressArchiveViewModel.DestinationFolder;
string destinationFolderPath = decompressArchiveViewModel.DestinationFolderPath;
if (destinationFolder == null)
{
BaseStorageFolder parentFolder = await StorageHelpers.ToStorageItem <BaseStorageFolder>(Path.GetDirectoryName(archive.Path));
destinationFolder = await FilesystemTasks.Wrap(() => parentFolder.CreateFolderAsync(Path.GetFileName(destinationFolderPath), CreationCollisionOption.GenerateUniqueName).AsTask());
}
if (destinationFolder == null)
{
return; // Could not create dest folder
}
Stopwatch sw = new Stopwatch();
sw.Start();
await ZipHelpers.ExtractArchive(archive, destinationFolder, banner.Progress, extractCancellation.Token);
sw.Stop();
banner.Remove();
if (sw.Elapsed.TotalSeconds >= 6)
{
App.OngoingTasksViewModel.PostBanner(
"ExtractingCompleteText".GetLocalized(),
"ArchiveExtractionCompletedSuccessfullyText".GetLocalized(),
0,
ReturnResult.Success,
FileOperationType.Extract);
}
if (decompressArchiveViewModel.OpenDestinationFolderOnCompletion)
{
await NavigationHelpers.OpenPath(destinationFolderPath, associatedInstance, FilesystemItemType.Directory);
}
}
}
}
public static async void DeleteItemWithStatus(StorageDeleteOption deleteOption)
{
var deleteFromRecycleBin = App.CurrentInstance.FilesystemViewModel.WorkingDirectory.StartsWith(App.AppSettings.RecycleBinPath);
if (deleteFromRecycleBin)
{
// Permanently delete if deleting from recycle bin
deleteOption = StorageDeleteOption.PermanentDelete;
}
// Get selected items before showing the prompt to prevent deleting items selected after the prompt
var CurrentInstance = App.CurrentInstance;
PostedStatusBanner bannerResult = null;
if (deleteOption == StorageDeleteOption.PermanentDelete)
{
bannerResult = App.CurrentInstance.StatusBarControl.OngoingTasksControl.PostBanner(null,
CurrentInstance.FilesystemViewModel.WorkingDirectory,
0,
StatusBanner.StatusBannerSeverity.Ongoing,
StatusBanner.StatusBannerOperation.Delete);
}
else
{
bannerResult = App.CurrentInstance.StatusBarControl.OngoingTasksControl.PostBanner(null,
CurrentInstance.FilesystemViewModel.WorkingDirectory,
0,
StatusBanner.StatusBannerSeverity.Ongoing,
StatusBanner.StatusBannerOperation.Recycle);
}
try
{
Stopwatch sw = new Stopwatch();
sw.Start();
await DeleteItem(deleteOption, CurrentInstance, bannerResult.Progress);
bannerResult.Remove();
sw.Stop();
if (sw.Elapsed.TotalSeconds >= 10)
{
if (deleteOption == StorageDeleteOption.PermanentDelete)
{
App.CurrentInstance.StatusBarControl.OngoingTasksControl.PostBanner(
"Deletion Complete",
"The operation has completed.",
0,
StatusBanner.StatusBannerSeverity.Success,
StatusBanner.StatusBannerOperation.Delete);
}
else
{
App.CurrentInstance.StatusBarControl.OngoingTasksControl.PostBanner(
"Recycle Complete",
"The operation has completed.",
0,
StatusBanner.StatusBannerSeverity.Success,
StatusBanner.StatusBannerOperation.Recycle);
}
}
App.CurrentInstance.NavigationToolbar.CanGoForward = false;
}
catch (UnauthorizedAccessException)
{
bannerResult.Remove();
App.CurrentInstance.StatusBarControl.OngoingTasksControl.PostBanner(
ResourceController.GetTranslation("AccessDeniedDeleteDialog/Title"),
ResourceController.GetTranslation("AccessDeniedDeleteDialog/Text"),
0,
StatusBanner.StatusBannerSeverity.Error,
StatusBanner.StatusBannerOperation.Delete);
}
catch (FileNotFoundException)
{
bannerResult.Remove();
App.CurrentInstance.StatusBarControl.OngoingTasksControl.PostBanner(
ResourceController.GetTranslation("FileNotFoundDialog/Title"),
ResourceController.GetTranslation("FileNotFoundDialog/Text"),
0,
StatusBanner.StatusBannerSeverity.Error,
StatusBanner.StatusBannerOperation.Delete);
}
catch (IOException)
{
bannerResult.Remove();
App.CurrentInstance.StatusBarControl.OngoingTasksControl.PostActionBanner(
ResourceController.GetTranslation("FileInUseDeleteDialog/Title"),
ResourceController.GetTranslation("FileInUseDeleteDialog/Text"),
ResourceController.GetTranslation("FileInUseDeleteDialog/PrimaryButtonText"),
ResourceController.GetTranslation("FileInUseDeleteDialog/SecondaryButtonText"), () => { DeleteItemWithStatus(deleteOption); });
}
}
public async void DeleteItemWithStatus(StorageDeleteOption deleteOption)
{
var deleteFromRecycleBin = AppInstance.FilesystemViewModel.WorkingDirectory.StartsWith(App.AppSettings.RecycleBinPath);
if (deleteFromRecycleBin)
{
// Permanently delete if deleting from recycle bin
deleteOption = StorageDeleteOption.PermanentDelete;
}
PostedStatusBanner bannerResult = null;
if (deleteOption == StorageDeleteOption.PermanentDelete)
{
bannerResult = AppInstance.BottomStatusStripControl.OngoingTasksControl.PostBanner(null,
AppInstance.FilesystemViewModel.WorkingDirectory,
0,
StatusBanner.StatusBannerSeverity.Ongoing,
StatusBanner.StatusBannerOperation.Delete);
}
else
{
bannerResult = AppInstance.BottomStatusStripControl.OngoingTasksControl.PostBanner(null,
AppInstance.FilesystemViewModel.WorkingDirectory,
0,
StatusBanner.StatusBannerSeverity.Ongoing,
StatusBanner.StatusBannerOperation.Recycle);
}
Stopwatch sw = new Stopwatch();
sw.Start();
var res = await DeleteItemAsync(deleteOption, AppInstance, bannerResult.Progress);
bannerResult.Remove();
sw.Stop();
if (!res)
{
if (res.ErrorCode == FilesystemErrorCode.ERROR_UNAUTHORIZED)
{
bannerResult.Remove();
AppInstance.BottomStatusStripControl.OngoingTasksControl.PostBanner(
"AccessDeniedDeleteDialog/Title".GetLocalized(),
"AccessDeniedDeleteDialog/Text".GetLocalized(),
0,
StatusBanner.StatusBannerSeverity.Error,
StatusBanner.StatusBannerOperation.Delete);
}
else if (res.ErrorCode == FilesystemErrorCode.ERROR_NOTFOUND)
{
bannerResult.Remove();
AppInstance.BottomStatusStripControl.OngoingTasksControl.PostBanner(
"FileNotFoundDialog/Title".GetLocalized(),
"FileNotFoundDialog/Text".GetLocalized(),
0,
StatusBanner.StatusBannerSeverity.Error,
StatusBanner.StatusBannerOperation.Delete);
}
else if (res.ErrorCode == FilesystemErrorCode.ERROR_INUSE)
{
bannerResult.Remove();
AppInstance.BottomStatusStripControl.OngoingTasksControl.PostActionBanner(
"FileInUseDeleteDialog/Title".GetLocalized(),
"FileInUseDeleteDialog/Text".GetLocalized(),
"FileInUseDeleteDialog/PrimaryButtonText".GetLocalized(),
"FileInUseDeleteDialog/SecondaryButtonText".GetLocalized(), () => { DeleteItemWithStatus(deleteOption); });
}
}
else if (sw.Elapsed.TotalSeconds >= 10)
{
if (deleteOption == StorageDeleteOption.PermanentDelete)
{
AppInstance.BottomStatusStripControl.OngoingTasksControl.PostBanner(
"Deletion Complete",
"The operation has completed.",
0,
StatusBanner.StatusBannerSeverity.Success,
StatusBanner.StatusBannerOperation.Delete);
}
else
{
AppInstance.BottomStatusStripControl.OngoingTasksControl.PostBanner(
"Recycle Complete",
"The operation has completed.",
0,
StatusBanner.StatusBannerSeverity.Success,
StatusBanner.StatusBannerOperation.Recycle);
}
}
AppInstance.NavigationToolbar.CanGoForward = false;
}
public static async void CutItem(IShellPage associatedInstance)
{
DataPackage dataPackage = new DataPackage()
{
RequestedOperation = DataPackageOperation.Move
};
ConcurrentBag <IStorageItem> items = new ConcurrentBag <IStorageItem>();
if (associatedInstance.SlimContentPage.IsItemSelected)
{
// First, reset DataGrid Rows that may be in "cut" command mode
associatedInstance.SlimContentPage.ItemManipulationModel.RefreshItemsOpacity();
var itemsCount = associatedInstance.SlimContentPage.SelectedItems.Count;
PostedStatusBanner banner = itemsCount > 50 ? App.OngoingTasksViewModel.PostOperationBanner(
string.Empty,
string.Format("StatusPreparingItemsDetails_Plural".GetLocalized(), itemsCount),
0,
ReturnResult.InProgress,
FileOperationType.Prepare, new CancellationTokenSource()) : null;
try
{
var dispatcherQueue = DispatcherQueue.GetForCurrentThread();
await associatedInstance.SlimContentPage.SelectedItems.ToList().ParallelForEachAsync(async listedItem =>
{
if (banner != null)
{
((IProgress <float>)banner.Progress).Report(items.Count / (float)itemsCount * 100);
}
// FTP don't support cut, fallback to copy
if (listedItem is not FtpItem)
{
_ = dispatcherQueue.TryEnqueue(DispatcherQueuePriority.Low, () =>
{
// Dim opacities accordingly
listedItem.Opacity = Constants.UI.DimItemOpacity;
});
}
if (listedItem is FtpItem ftpItem)
{
if (ftpItem.PrimaryItemAttribute is StorageItemTypes.File or StorageItemTypes.Folder)
{
items.Add(await ftpItem.ToStorageItem());
}
}
else if (listedItem.PrimaryItemAttribute == StorageItemTypes.File || listedItem is ZipItem)
{
var result = await associatedInstance.FilesystemViewModel.GetFileFromPathAsync(listedItem.ItemPath)
.OnSuccess(t => items.Add(t));
if (!result)
{
throw new IOException($"Failed to process {listedItem.ItemPath}.", (int)result.ErrorCode);
}
}
else
{
var result = await associatedInstance.FilesystemViewModel.GetFolderFromPathAsync(listedItem.ItemPath)
.OnSuccess(t => items.Add(t));
if (!result)
{
throw new IOException($"Failed to process {listedItem.ItemPath}.", (int)result.ErrorCode);
}
}
}, 10, banner?.CancellationToken ?? default);
}
catch (Exception ex)
{
if (ex.HResult == (int)FileSystemStatusCode.Unauthorized)
{
// Try again with fulltrust process
var connection = await AppServiceConnectionHelper.Instance;
if (connection != null)
{
string filePaths = string.Join('|', associatedInstance.SlimContentPage.SelectedItems.Select(x => x.ItemPath));
AppServiceResponseStatus status = await connection.SendMessageAsync(new ValueSet()
{
{ "Arguments", "FileOperation" },
{ "fileop", "Clipboard" },
{ "filepath", filePaths },
{ "operation", (int)DataPackageOperation.Move }
});
if (status == AppServiceResponseStatus.Success)
{
banner?.Remove();
return;
}
}
}
associatedInstance.SlimContentPage.ItemManipulationModel.RefreshItemsOpacity();
banner?.Remove();
return;
}
banner?.Remove();
}
var onlyStandard = items.All(x => x is StorageFile || x is StorageFolder || x is SystemStorageFile || x is SystemStorageFolder);
if (onlyStandard)
{
items = new ConcurrentBag <IStorageItem>(await items.ToStandardStorageItemsAsync());
}
if (!items.Any())
{
return;
}
dataPackage.Properties.PackageFamilyName = Windows.ApplicationModel.Package.Current.Id.FamilyName;
dataPackage.SetStorageItems(items, false);
try
{
Clipboard.SetContent(dataPackage);
}
catch
{
dataPackage = null;
}
}
public static async Task CopyItem(IShellPage associatedInstance)
{
DataPackage dataPackage = new DataPackage()
{
RequestedOperation = DataPackageOperation.Copy
};
ConcurrentBag <IStorageItem> items = new ConcurrentBag <IStorageItem>();
if (associatedInstance.SlimContentPage.IsItemSelected)
{
var itemsCount = associatedInstance.SlimContentPage.SelectedItems.Count;
PostedStatusBanner banner = itemsCount > 50 ? App.OngoingTasksViewModel.PostOperationBanner(
string.Empty,
string.Format("StatusPreparingItemsDetails_Plural".GetLocalized(), itemsCount),
0,
ReturnResult.InProgress,
FileOperationType.Prepare, new CancellationTokenSource()) : null;
try
{
await associatedInstance.SlimContentPage.SelectedItems.ToList().ParallelForEach(async listedItem =>
{
if (banner != null)
{
((IProgress <float>)banner.Progress).Report(items.Count / (float)itemsCount * 100);
}
if (listedItem is FtpItem ftpItem)
{
if (listedItem.PrimaryItemAttribute == StorageItemTypes.File)
{
items.Add(await new FtpStorageFile(ftpItem).ToStorageFileAsync());
}
else if (listedItem.PrimaryItemAttribute == StorageItemTypes.Folder)
{
items.Add(new FtpStorageFolder(ftpItem));
}
}
else if (listedItem.PrimaryItemAttribute == StorageItemTypes.File || listedItem is ZipItem)
{
var result = await associatedInstance.FilesystemViewModel.GetFileFromPathAsync(listedItem.ItemPath)
.OnSuccess(t => items.Add(t));
if (!result)
{
throw new IOException($"Failed to process {listedItem.ItemPath}.", (int)result.ErrorCode);
}
}
else
{
var result = await associatedInstance.FilesystemViewModel.GetFolderFromPathAsync(listedItem.ItemPath)
.OnSuccess(t => items.Add(t));
if (!result)
{
throw new IOException($"Failed to process {listedItem.ItemPath}.", (int)result.ErrorCode);
}
}
}, 10, banner?.CancellationToken ?? default);
}
catch (Exception ex)
{
if (ex.HResult == (int)FileSystemStatusCode.Unauthorized)
{
// Try again with fulltrust process
var connection = await AppServiceConnectionHelper.Instance;
if (connection != null)
{
string filePaths = string.Join('|', associatedInstance.SlimContentPage.SelectedItems.Select(x => x.ItemPath));
AppServiceResponseStatus status = await connection.SendMessageAsync(new ValueSet()
{
{ "Arguments", "FileOperation" },
{ "fileop", "Clipboard" },
{ "filepath", filePaths },
{ "operation", (int)DataPackageOperation.Copy }
});
if (status == AppServiceResponseStatus.Success)
{
banner?.Remove();
return;
}
}
}
banner?.Remove();
return;
}
banner?.Remove();
}
var onlyStandard = items.All(x => x is StorageFile || x is StorageFolder || x is SystemStorageFile || x is SystemStorageFolder);
if (onlyStandard)
{
items = new ConcurrentBag <IStorageItem>(await items.ToStandardStorageItemsAsync());
}
if (!items.Any())
{
return;
}
dataPackage.Properties.PackageFamilyName = Windows.ApplicationModel.Package.Current.Id.FamilyName;
dataPackage.SetStorageItems(items, false);
try
{
Clipboard.SetContent(dataPackage);
}
catch
{
dataPackage = null;
}
}
