static async Task<bool> CanPerformAsync(
IClipboardData data)
{
return
data is IClipboardFileData ||
data is IClipboardFileCollectionData;
}
bool IsSuitableFileData(
IClipboardData clipboardData)
{
var fileData = clipboardData as IClipboardFileData;
return (fileData != null) &&
(fileTypeInterpreter.GetFileTypeFromFileName(fileData.FileName) == FileType.Image);
}
void InjectClipboardData(
IClipboardHandle session,
IClipboardData clipboardData)
{
using (var memoryHandle = memoryHandleFactory.AllocateInMemory(clipboardData.RawData))
{
var globalPointer = AllocateInMemory(clipboardData);
var target = generalNativeApi.GlobalLock(globalPointer);
if (target == IntPtr.Zero)
{
throw new InvalidOperationException("Could not allocate memory.");
}
generalNativeApi.CopyMemory(
target,
memoryHandle.Pointer,
(uint) clipboardData.RawData.Length);
generalNativeApi.GlobalUnlock(target);
if (session.SetClipboardData(clipboardData.RawFormat, globalPointer) !=
IntPtr.Zero)
{
return;
}
generalNativeApi.GlobalFree(globalPointer);
throw new Exception("Could not set clipboard data.");
}
}
async Task<bool> CanPerformAsync(IClipboardData data)
{
var textData = data as IClipboardTextData;
return (textData != null) &&
await linkParser.HasLinkOfTypeAsync(textData.Text, LinkType.ImageFile)
.ConfigureAwait(false);
}
public UIElement BuildControl(IClipboardData clipboardData)
{
var textData = (ClipboardTextData)clipboardData;
return new ClipboardTextDataControl()
{
DataContext = new ClipboardTextDataViewModel(textData)
};
}
public IClipboardControl BuildControl(IClipboardData clipboardData)
{
return new ClipboardImageDataControl()
{
DataContext = new ClipboardImageDataViewModel(environmentInformation)
{
Data = (IClipboardImageData)clipboardData
}
};
}
public IClipboardControl BuildControl(IClipboardData data)
{
if (data == null)
{
throw new ArgumentException(
"Data must be set when constructing a clipboard control.",
nameof(data));
}
return CreateImageDataControl((IClipboardImageData) data);
}
public IClipboardControl BuildControl(IClipboardData clipboardData)
{
var clipboardFileCollectionData = clipboardData as IClipboardFileCollectionData;
if (clipboardFileCollectionData != null)
{
return clipboardFileCollectionControlFactory.CreateControl(
clipboardFileCollectionData);
}
var clipboardFileData = clipboardData as IClipboardFileData;
if (clipboardFileData != null)
{
return clipboardFileControlFactory.CreateControl(
clipboardFileData);
}
throw new ArgumentException(
"Unknown clipboard data type.", nameof(clipboardData));
}
public UIElement BuildControl(IClipboardData clipboardData)
{
if(clipboardData is ClipboardFileCollectionData)
{
return new ClipboardFileCollectionDataControl()
{
DataContext = new ClipboardFileCollectionDataViewModel((ClipboardFileCollectionData)clipboardData)
};
} else if(clipboardData is ClipboardFileData)
{
return new ClipboardFileDataControl()
{
DataContext = new ClipboardFileDataViewModel((ClipboardFileData)clipboardData)
};
} else
{
throw new ArgumentException("Unknown clipboard data type.", nameof(clipboardData));
}
}
public IClipboardControl BuildControl(IClipboardData clipboardData)
{
if (clipboardData
is IClipboardFileCollectionData)
{
return clipboardFileCollectionControlFactory.CreateControl(
(IClipboardFileCollectionData)clipboardData);
}
else if (clipboardData
is IClipboardFileData)
{
return clipboardFileControlFactory.CreateControl(
(IClipboardFileData)clipboardData);
}
else
{
throw new ArgumentException(
"Unknown clipboard data type.", nameof(clipboardData));
}
}
public IntPtr GetDataPointer(IClipboardData clipboardData)
{
using (var memoryHandle = memoryHandleFactory.AllocateInMemory(clipboardData.RawData))
{
var globalPointer = AllocateInMemory(clipboardData);
var target = generalNativeApi.GlobalLock(globalPointer);
if (target == IntPtr.Zero)
{
throw new InvalidOperationException("Could not allocate memory.");
}
generalNativeApi.CopyMemory(
target,
memoryHandle.Pointer,
(uint)clipboardData.RawData.Length);
generalNativeApi.GlobalUnlock(target);
return(globalPointer);
}
}
void InjectClipboardData(
IClipboardHandle session,
IClipboardData clipboardData)
{
var wrappers = memoryWrappers
.Where(x => x.CanWrap(clipboardData))
.ToArray();
if (wrappers.Length > 0)
{
logger.Verbose("Injecting {bytes} bytes of {format} format into the clipboard.", clipboardData.RawData.Length, clipboardData.RawFormat);
}
else
{
logger.Verbose("No suitable memory wrapper found for format {format}.", clipboardData.RawFormat);
}
foreach (var wrapper in wrappers)
{
var success = session.SetClipboardData(
clipboardData.RawFormat.Number,
wrapper.GetDataPointer(
clipboardData));
if (success == IntPtr.Zero)
{
throw new Exception(
"Could not set clipboard data format " + clipboardData.RawFormat + " from " + clipboardData.Package.Source.ProcessName + ".",
new Win32Exception(Marshal.GetLastWin32Error()));
}
var formats = session.GetClipboardFormats();
if (formats.All(x => x.Number != clipboardData.RawFormat.Number))
{
logger.Warning(
"The format {format} was not found in the clipboard after attempting injecting it to the clipboard.",
clipboardData.RawFormat);
}
}
}
void InjectClipboardData(IClipboardData clipboardData)
{
using (var memoryHandle = memoryHandleFactory.AllocateInMemory(clipboardData.RawData))
{
var globalPointer = AllocateInMemory(clipboardData);
var target = GeneralApi.GlobalLock(globalPointer);
if (target == IntPtr.Zero)
{
throw new InvalidOperationException("Could not allocate memory.");
}
GeneralApi.CopyMemory(target, memoryHandle.Pointer, (uint)clipboardData.RawData.Length);
GeneralApi.GlobalUnlock(target);
if (ClipboardApi.SetClipboardData(clipboardData.RawFormat, globalPointer) == IntPtr.Zero)
{
GeneralApi.GlobalFree(globalPointer);
throw new Exception("Could not set clipboard data.");
}
}
}
public bool CanBuildControl(IClipboardData data)
{
return(data is IClipboardFileCollectionData);
}
public void AddData(IClipboardData data)
{
this.data.Add(data);
}
public bool CanBuildControl(IClipboardData data)
{
return data is IClipboardImageData;
}
public IClipboardControl BuildControl(IClipboardData clipboardData)
{
throw new NotImplementedException();
}
private static bool IsSuitableImageData(
IClipboardData clipboardData)
{
return clipboardData is IClipboardImageData;
}
public IClipboardControl BuildControl(IClipboardData clipboardData)
{
return textControlFactory.CreateControl((IClipboardTextData)clipboardData);
}
static bool CanPerform(IClipboardData data)
{
var textData = data as IClipboardTextData;
return(textData != null);
}
async Task <bool> CanPerformAsync(IClipboardData data)
{
return(data is IClipboardTextData textData &&
await linkParser.HasLinkOfTypeAsync(textData.Text, LinkType.ImageFile)
.ConfigureAwait(false));
}
public void AddData(IClipboardData data)
{
data.Package = this;
dataCollection.Add(data);
}
async Task<bool> CanPerformAsync(IClipboardData data)
{
var textData = data as IClipboardTextData;
return textData != null && await linkParser.HasLinkAsync(textData.Text).ConfigureAwait(false);
}
async Task<string> ZipDataAsync(IClipboardData data)
{
var clipboardFileData = data as IClipboardFileData;
if (clipboardFileData != null)
{
return await ZipFileCollectionDataAsync(clipboardFileData);
}
var clipboardFileCollectionData = data as IClipboardFileCollectionData;
if (clipboardFileCollectionData != null)
{
return await ZipFileCollectionDataAsync(
clipboardFileCollectionData
.Files
.ToArray());
}
throw new InvalidOperationException("Unknown data format.");
}
public bool CanBuildControl(IClipboardData data)
{
return(false);
}
public IClipboardControl BuildControl(IClipboardData clipboardData)
{
throw new NotImplementedException();
}
public void AddData(IClipboardData data)
{
dataCollection.Add(data);
}
public bool CanBuildControl(IClipboardData data)
{
return data is IClipboardFileCollectionData;
}
static async Task<bool> CanPerformAsync(
IClipboardData data)
{
return data is IClipboardTextData;
}
static async Task <bool> CanPerformAsync(
IClipboardData data)
{
return(data is IClipboardTextData);
}
static IntPtr AllocateInMemory(IClipboardData clipboardData)
{
return(GeneralApi.GlobalAlloc(
GeneralApi.GMEM_ZEROINIT | GeneralApi.GMEM_MOVABLE,
(UIntPtr)clipboardData.RawData.Length));
}
async Task <bool> CanPerformAsync(
IClipboardData clipboardData)
{
return(IsSuitableImageData(clipboardData) || IsSuitableFileData(clipboardData));
}
private async Task<bool> CanPerformAsync(
IClipboardData clipboardData)
{
return IsSuitableImageData(clipboardData) || IsSuitableFileData(clipboardData);
}
public bool CanBuildControl(IClipboardData data)
{
return data is ClipboardTextData;
}
public bool CanBuildControl(IClipboardData data)
{
return false;
}
public void AddData(IClipboardData data)
{
dataCollection.Add(data);
}
async Task <bool> CanPerformAsync(
IClipboardData data)
{
return(data is IClipboardTextData && data.RawFormat.Name == "Rich Text Format");
}
public bool CanWrap(IClipboardData clipboardData)
{
return(excludedFormats.All(x => x != clipboardData.RawFormat.Number));
}
public IClipboardControl BuildControl(IClipboardData clipboardData)
{
return(textControlFactory.CreateControl((IClipboardTextData)clipboardData));
}
async Task <bool> CanPerformAsync(IClipboardData data)
{
var textData = data as IClipboardTextData;
return(textData != null && await linkParser.HasLinkOfTypeAsync(textData.Text, LinkType.ImageFile).ConfigureAwait(false));
}
static bool IsSuitableImageData(
IClipboardData clipboardData)
{
return(clipboardData is IClipboardImageData);
}
public void AddData(IClipboardData data)
{
this.data.Add(data);
}
private static IntPtr AllocateInMemory(IClipboardData clipboardData)
{
return GeneralApi.GlobalAlloc(
GeneralApi.GMEM_ZEROINIT | GeneralApi.GMEM_MOVABLE,
(UIntPtr) clipboardData.RawData.Length);
}
public bool CanBuildControl(IClipboardData data)
{
return(data is IClipboardImageData);
}
