public async Task ProcessComandsAsync(DataPackageView dataview)
{
if (DropDataViewCommand != null)
{
DropDataViewCommand.Execute(dataview);
}
if (dataview.Contains(StandardDataFormats.ApplicationLink) && DropApplicationLinkCommand != null)
{
Uri uri = await dataview.GetApplicationLinkAsync();
DropApplicationLinkCommand.Execute(uri);
}
if (dataview.Contains(StandardDataFormats.Bitmap) && DropBitmapCommand != null)
{
RandomAccessStreamReference stream = await dataview.GetBitmapAsync();
DropBitmapCommand.Execute(stream);
}
if (dataview.Contains(StandardDataFormats.Html) && DropHtmlCommand != null)
{
string html = await dataview.GetHtmlFormatAsync();
DropHtmlCommand.Execute(html);
}
if (dataview.Contains(StandardDataFormats.Rtf) && DropRtfCommand != null)
{
string rtf = await dataview.GetRtfAsync();
DropRtfCommand.Execute(rtf);
}
if (dataview.Contains(StandardDataFormats.StorageItems) && DropStorageItemsCommand != null)
{
IReadOnlyList <IStorageItem> storageItems = await dataview.GetStorageItemsAsync();
DropStorageItemsCommand.Execute(storageItems);
}
if (dataview.Contains(StandardDataFormats.Text) && DropTextCommand != null)
{
string text = await dataview.GetTextAsync();
DropTextCommand.Execute(text);
}
if (dataview.Contains(StandardDataFormats.WebLink) && DropWebLinkCommand != null)
{
Uri uri = await dataview.GetWebLinkAsync();
DropWebLinkCommand.Execute(uri);
}
}
public async Task ProcessComandsAsync(DataPackageView dataview)
{
if (DropDataViewAction != null)
{
DropDataViewAction.Invoke(dataview);
}
if (dataview.Contains(StandardDataFormats.ApplicationLink) && DropApplicationLinkAction != null)
{
var uri = await dataview.GetApplicationLinkAsync();
DropApplicationLinkAction.Invoke(uri);
}
if (dataview.Contains(StandardDataFormats.Bitmap) && DropBitmapAction != null)
{
var stream = await dataview.GetBitmapAsync();
DropBitmapAction.Invoke(stream);
}
if (dataview.Contains(StandardDataFormats.Html) && DropHtmlAction != null)
{
var html = await dataview.GetHtmlFormatAsync();
DropHtmlAction.Invoke(html);
}
if (dataview.Contains(StandardDataFormats.Rtf) && DropRtfAction != null)
{
var rtf = await dataview.GetRtfAsync();
DropRtfAction.Invoke(rtf);
}
if (dataview.Contains(StandardDataFormats.StorageItems) && DropStorageItemsAction != null)
{
var storageItems = await dataview.GetStorageItemsAsync();
DropStorageItemsAction.Invoke(storageItems);
}
if (dataview.Contains(StandardDataFormats.Text) && DropTextAction != null)
{
var text = await dataview.GetTextAsync();
DropTextAction.Invoke(text);
}
if (dataview.Contains(StandardDataFormats.WebLink) && DropWebLinkAction != null)
{
var uri = await dataview.GetWebLinkAsync();
DropWebLinkAction.Invoke(uri);
}
}
internal static string GetText()
{
string toReturn = null;
DataPackageView dataPackageView = Windows.ApplicationModel.DataTransfer.Clipboard.GetContent();
if (dataPackageView.Contains(StandardDataFormats.Text))
{
toReturn = Task.Run(async() => await dataPackageView.GetTextAsync()).Result;
}
return(toReturn);
}
private async Task InsertItems(DataPackageView dataview, ObservableCollection <CustomItem> target)
{
if (dataview.Contains(StandardDataFormats.StorageItems))
{
var items = await dataview.GetStorageItemsAsync();
foreach (StorageFile item in items)
{
target.Add(await CustomItemFactory.Create(item));
}
}
}
public static async Task <string> OutputClipboardText()
{
DataPackageView dataPackageView = Clipboard.GetContent();
if (dataPackageView.Contains(StandardDataFormats.Text))
{
string text = await dataPackageView.GetTextAsync();
return(text);
}
return(await Task.FromResult(String.Empty));
}
public void Clipboard_ContentChanged(object sender, object e)
{
try
{
// Clipboard.GetContent() will throw UnauthorizedAccessException
// if the app window is not in the foreground and active
DataPackageView packageView = Clipboard.GetContent();
if (packageView.Contains(StandardDataFormats.StorageItems) || packageView.Contains(StandardDataFormats.Bitmap))
{
IsPasteEnabled = true;
}
else
{
IsPasteEnabled = false;
}
}
catch
{
IsPasteEnabled = false;
}
}
public async Task <string> GetText()
{
DataPackageView dataPackageView = Windows.ApplicationModel.DataTransfer.Clipboard.GetContent();
if (dataPackageView.Contains(StandardDataFormats.Text))
{
string text = await dataPackageView.GetTextAsync();
return(text);
}
return("");
}
public async Task <Stream> GetClipboardAsync()
{
DataPackageView dataPackageView = Clipboard.GetContent();
if (dataPackageView.Contains(StandardDataFormats.Bitmap))
{
var randomAccessStreamReference = await dataPackageView.GetBitmapAsync();
return((await randomAccessStreamReference.OpenReadAsync()).AsStream());
}
return(null);
}
// 拖动进入目标区域时发生
private async void Draggrid_DragEnter(object sender, DragEventArgs e)
{
var deferral = e.GetDeferral();
DataPackageView dataview = e.DataView;
if (dataview.Contains(StandardDataFormats.StorageItems))
{
var items = await dataview.GetStorageItemsAsync();
if (items != null)
{
IStorageItem item = items[0];
if (item.IsOfType(StorageItemTypes.File))
{
e.AcceptedOperation = DataPackageOperation.Link;
StorageFile file = (StorageFile)item;
// 使用using块避免出现Thumbnail不可用的异常
using (StorageItemThumbnail img = await file.GetScaledImageAsThumbnailAsync(ThumbnailMode.VideosView))
{
if (img != null)
{
BitmapImage bmp = new BitmapImage()
{
DecodePixelWidth = 150
};
bmp.SetSource(img);
e.DragUIOverride.SetContentFromBitmapImage(bmp);
}
}
// e.DragUIOverride.Caption = file.DisplayName;
// e.DragUIOverride.IsCaptionVisible = false;
if (file.ContentType.Split('/')[0] == "video")
{
dragfile = file;
}
}
else
{
// 不用 DataPackageOperation.None 原因：不是约定的用法
deferral.Complete();
return;
}
}
}
else
{
deferral.Complete();
return;
}
// dragarea.Background.Opacity = 0;
deferral.Complete();
}
private async void Clipboard_ContentChanged(object sender, object e)
{
if (isFocused)
{
DataPackageView dataPackageView = Clipboard.GetContent();
if (dataPackageView.Contains(StandardDataFormats.Text))
{
string text = await dataPackageView.GetTextAsync();
currentClipboardValue = text;
}
}
}
public async void Paste()
{
DataPackageView dataPackageView = Clipboard.GetContent();
if (dataPackageView.Contains(StandardDataFormats.Text))
{
string text = await dataPackageView.GetTextAsync();
// To output the text from this example, you need a TextBlock control
_core.Document.Selection.SetText(TextSetOptions.None, text);
_core.Document.Selection.SetRange(_core.Document.Selection.EndPosition, _core.Document.Selection.EndPosition);
}
}
void OutputChange()
{
Clipboard.ContentChanged += async(s, e) =>
{
DataPackageView dataPackageView = Clipboard.GetContent();
if (dataPackageView.Contains(StandardDataFormats.Text))
{
string text = await dataPackageView.GetTextAsync();
outputtext.Text = "Clipboard now contains:" + text;
}
};
}
async void Paste()
{
DataPackageView dataPackageView = Clipboard.GetContent();
if (dataPackageView.Contains(StandardDataFormats.StorageItems))
{
var fl = await dataPackageView.GetStorageItemsAsync();
var f = fl.FirstOrDefault();
CopyFiltToResourceFolder(f as StorageFile);
AddItem(f as StorageFile);
}
}
// <Snippetcs_TrackClipboardChanges>
private async void TrackClipboardChanges_EventHandler(object sender, object e)
{
DataPackageView dataPackageView = Clipboard.GetContent();
if (dataPackageView.Contains(StandardDataFormats.Text))
{
String text = await dataPackageView.GetTextAsync();
// To output the text from this example, you need a TextBlock control
// with a name of "TextOutput".
TextOutput.Text = "Clipboard now contains: " + text;
}
}
private async void Clipboard_ContentChanged(object sender, object e)
{
DataPackageView dataPackageView = Clipboard.GetContent();
if (dataPackageView.Contains(StandardDataFormats.Text))
{
string text = await dataPackageView.GetTextAsync();
Clipboard.Clear();
// To output the text from this example, you need a TextBlock control
Debug.WriteLine("Clipboard now contains: " + text);
}
}
private async void Grid_Drop(object sender, DragEventArgs e)
{
var defer = e.GetDeferral();
try
{
DataPackageView dataView = e.DataView;
// 拖放类型为文件存储。
if (dataView.Contains(StandardDataFormats.StorageItems))
{
var files = await dataView.GetStorageItemsAsync();
StorageFile file = files.OfType <StorageFile>().First();
//
if (file.FileType == ".png" || file.FileType == ".jpg" || file.FileType == ".jpeg" || file.FileType == ".gif")
{
// 拖放的是图片文件。
string constpath = "D:\\UWP-master\\NavDemo\\NavDemo\\";
int flag = 1;
for (int i = 0; i < constpath.Length; ++i)
{
if (file.Path[i] != constpath[i])
{
flag = 0;
break;
}
}
if (flag == 0)
{
await new Windows.UI.Popups.MessageDialog("请选择在工程文件夹下的图片，否则无效").ShowAsync();
return;
}
else
{
StrongTypeViewModel.friend.iconFriend = "ms-appx:///" + file.Path.Substring(constpath.Length);
}
BitmapImage bitmap = new BitmapImage();
await bitmap.SetSourceAsync(await file.OpenAsync(FileAccessMode.Read));
imageBrushFriend.ImageSource = bitmap;
}
}
}
finally
{
defer.Complete();
}
}
bool CheckClipboardForBitmap()
{
// ClipBoard.GetContentで アクセス拒否が発生する場合がある
try
{
DataPackageView dataView = Clipboard.GetContent();
return(dataView.Contains(StandardDataFormats.Bitmap));
}
catch (Exception e)
{
System.Diagnostics.Debug.WriteLine("Clipboard.GetContente:{0}", e.Message);
return(false);
}
}
public byte[] GetImageData()
{
DataPackageView dataPackageView = Clipboard.GetContent();
if (dataPackageView.Contains(StandardDataFormats.Bitmap))
{
using (MemoryStream ms = new MemoryStream())
{
dataPackageView.GetBitmapAsync().GetResults().OpenReadAsync().GetResults().GetInputStreamAt(0).AsStreamForRead().CopyTo(ms);
return(ms.ToArray());
}
}
return(null);
}
private async Task LoadDataPackageView(DataPackageView view)
{
if (view.Contains(StandardDataFormats.Bitmap))
{
var bitmap = await view.GetBitmapAsync();
await LoadImageAndDecode(bitmap);
}
else if (view.Contains(StandardDataFormats.Text))
{
QRTextBox.Text = await view.GetTextAsync();
UpdateQRCodeImage();
}
else if (view.Contains(StandardDataFormats.StorageItems))
{
var items = await view.GetStorageItemsAsync();
if (items[0] is IStorageFile file)
{
await LoadFile(file);
}
}
}
protected virtual void PasteRowsToClipboard()
#endif
{
if (this.TreeGrid.SelectedItem == null)
{
return;
}
var args = this.RaisePasteContentEvent(new GridCopyPasteEventArgs(false, this.TreeGrid));
if (args.Handled)
{
return;
}
#if UWP
DataPackageView dataPackage = null;
dataPackage = Clipboard.GetContent();
DataPackage package = new DataPackage();
if (dataPackage.AvailableFormats.Count <= 0)
{
return;
}
package.SetText(await dataPackage.GetTextAsync());
#else
IDataObject dataObject = null;
dataObject = Clipboard.GetDataObject();
#endif
#if UWP
if (dataPackage.Contains(StandardDataFormats.Text))
{
var clipBoardContent = await dataPackage.GetTextAsync();
#else
if (dataObject.GetDataPresent(DataFormats.UnicodeText))
{
var clipBoardContent = dataObject.GetData(DataFormats.UnicodeText) as string;
#endif
if (clipBoardContent == null)
{
return;
}
var copiedRecords = Regex.Split(clipBoardContent.ToString(), @"\r\n");
//Considered only ExcludeHeader while pasting
if (TreeGrid.GridPasteOption.HasFlag(GridPasteOption.ExcludeFirstLine))
{
copiedRecords = copiedRecords.Skip(1).ToArray();
}
PasteRows(copiedRecords);
}
}
public static void ContentChanged()
{
Clipboard.ContentChanged += async(s, e) =>
{
DataPackageView dataPackageView = Clipboard.GetContent();
if (dataPackageView.Contains(StandardDataFormats.Text))
{
string text = await dataPackageView.GetTextAsync();
ClipboardText = text;
}
UpdateInternalNofinication();
};
}
private async void OnAddImageClicked(object sender, RoutedEventArgs e)
{
DataPackageView package = Clipboard.GetContent();
string imageUrl = string.Empty;
if (package.Contains(StandardDataFormats.Text))
{
imageUrl = await package.GetTextAsync();
}
else if (package.Contains(StandardDataFormats.ApplicationLink))
{
Uri imageUri = await package.GetWebLinkAsync();
imageUrl = imageUri.AbsoluteUri;
}
GraphServiceClient client = AuthenticationHelper.GetAuthenticatedClient();
var requestBuilder = client.Me.Activities.Request();
UserActivity activity = new UserActivity()
{
ActivationUrl = "blah",
ActivitySourceHost = "studiovn.life",
AppActivityId = Base64UrlEncoder.Encode(imageUrl),
VisualElements = new VisualInfo()
{
DisplayText = "Test"
},
ContentInfo = new JObject()
};
activity.VisualElements.DisplayText = "Test";
activity.ContentInfo["imageUrl"] = imageUrl;
var result = await requestBuilder.AddUserActivityAsync(activity);
this.viewModel.Images.Insert(0, new CloudImageViewModel(imageUrl));
}
public Clipboard()
{
if (!Cp.IsHistoryEnabled())
{
Console.WriteLine("[+] Turning on clipboard history feature...");
try
{
var rk = Registry.CurrentUser.OpenSubKey(@"Software\Microsoft\Clipboard", true);
if (rk == null)
{
Console.WriteLine(
"[!] Clipboard history feature not available on target! Target needs to be at least Win10 Build 1809.\n[!] Exiting...\n");
return;
}
rk.SetValue("EnableClipboardHistory", "1", RegistryValueKind.DWord);
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
Cp.ContentChanged += async(s, e) =>
{
DataPackageView dataPackageView = Cp.GetContent();
foreach (var availableFormat in dataPackageView.AvailableFormats)
{
Console.WriteLine(availableFormat);
}
var a = await Cp.GetHistoryItemsAsync();
var b = a.Items;
foreach (var it in b)
{
Console.WriteLine(it.Timestamp);
}
if (dataPackageView.Contains(StandardDataFormats.Text))
{
string text = await dataPackageView.GetTextAsync();
Console.WriteLine(text);
}
};
Cp.HistoryChanged += async(s, e) => { Console.WriteLine("History Changed!"); };
}
private async void TextBox_Clipboard(object sender, TextControlPasteEventArgs e)
{
DataPackageView data = Clipboard.GetContent();
if (data != null)
{
if (data.Contains(StandardDataFormats.Bitmap))
{
RandomAccessStreamReference file = await data.GetBitmapAsync();
BitmapImage image = new BitmapImage();
await image.SetSourceAsync(await file.OpenReadAsync());
this.image.Source = image;
View.Image = image;
_upload = true;
}
else if (data.Contains(StandardDataFormats.StorageItems))
{
StorageFile file = (await data.GetStorageItemsAsync()).First() as StorageFile;
await ImageStorageFile(file);
}
}
}
public static async Task <string> PasteTextAsync()
{
DataPackageView package = Clipboard.GetContent();
if (package == null)
{
return(null);
}
if (package.Contains(StandardDataFormats.Text) == false)
{
return(null);
}
return(await package.GetTextAsync());
}
public static async Task <bool> CheckIfContainsAvailableDataAsync(this DataPackageView View)
{
if (View.Contains(StandardDataFormats.StorageItems))
{
return(true);
}
else if (View.Contains(StandardDataFormats.Text))
{
string XmlText = await View.GetTextAsync();
if (XmlText.Contains("RX-Explorer"))
{
XmlDocument Document = new XmlDocument();
Document.LoadXml(XmlText);
IXmlNode KindNode = Document.SelectSingleNode("/RX-Explorer/Kind");
if (KindNode?.InnerText == "RX-Explorer-TransferNotStorageItem")
{
return(true);
}
else
{
return(false);
}
}
else
{
return(false);
}
}
else
{
return(false);
}
}
private async void TextOutput_DoubleTapped(object sender, DoubleTappedRoutedEventArgs e)
{
// <Snippetcs_GetClipboardContent>
DataPackageView dataPackageView = Clipboard.GetContent();
if (dataPackageView.Contains(StandardDataFormats.Text))
{
String text = await dataPackageView.GetTextAsync();
// To output the text from this example, you need a TextBlock control
// with a name of "TextOutput".
TextOutput.Text = "Clipboard now contains: " + text;
}
// </Snippetcs_GetClipboardContent>
}
public static async Task <IRandomAccessStreamReference> PasteBitmapAsync()
{
DataPackageView package = Clipboard.GetContent();
if (package == null)
{
return(null);
}
if (package.Contains(StandardDataFormats.Bitmap) == false)
{
return(null);
}
return(await package.GetBitmapAsync());
}
/// <summary>
/// 打开剪贴板查看是否包含合法url
/// </summary>
/// https://blog.csdn.net/lindexi_gd/article/details/50479180
/// <returns>没有返回string.Empty</returns>
public static async Task <string> CheckClipBoardAsync()
{
DataPackageView con = Clipboard.GetContent();
string str = string.Empty;
if (con.Contains(StandardDataFormats.Text))
{
str = await con.GetTextAsync();
if (MaybeLegal(str))
{
return(str);
}
}
return(string.Empty);
}
public static async Task <T> GetData <T>(this DataPackageView data, string dataFormat)
where T : class
{
try
{
if (data.Contains(dataFormat))
{
return(await data.GetDataAsync(dataFormat) as T);
}
return(default(T));
}
catch (Exception)
{
return(default(T));
}
}
