public ClipboardDataControlPackage(
IClipboardDataPackage data,
IClipboardControl control)
{
Data = data;
Control = control;
}
async Task <IReadOnlyCollection <IClipboardData> > GetSupportedData(
IClipboardDataPackage package)
{
var supportedData = await asyncFilter.FilterAsync(package.Contents, CanPerformAsync);
return(supportedData);
}
public async Task <bool> CanPerformAsync(
IClipboardDataPackage package)
{
var supportedData = await GetSupportedData(package);
return(supportedData.Any());
}
private void InjectPackageContents(IClipboardDataPackage package)
{
foreach (var clipboardData in package.Contents)
{
InjectClipboardData(clipboardData);
}
}
public async Task PerformAsync(
IClipboardDataPackage package)
{
await DoForEveryLinkAsync(
package,
link => processManager.LaunchCommand(link));
}
public async Task <bool> CanPerformAsync(
IClipboardDataPackage package)
{
var supportedData = await asyncFilter.FilterAsync(package.Contents, CanPerformAsync);
return(supportedData.Any());
}
public async Task PerformAsync(
IClipboardDataPackage package)
{
var textData = (IClipboardTextData) await GetFirstSupportedItem(package);
clipboardInjectionService.InjectText(textData.Text);
}
public ClipboardDataControlPackage(
IClipboardDataPackage data,
IClipboardControl control)
{
Data = data;
Control = control;
}
async Task <IClipboardData> GetFirstSupportedDataAsync(IClipboardDataPackage package)
{
var validItems = await asyncFilter.FilterAsync(package.Contents, CanPerformAsync)
.ConfigureAwait(false);
return(validItems.FirstOrDefault());
}
void InjectPackageContents(IClipboardDataPackage package)
{
foreach (var clipboardData in package.Contents)
{
InjectClipboardData(clipboardData);
}
}
public async Task PerformAsync(
IClipboardDataPackage package)
{
clipboardInjectionService.InjectData(package);
await clipboardPasteService.PasteClipboardContentsAsync();
logger.Information("Paste action performed.", 1);
}
void InjectPackageContents(
IClipboardHandle session, IClipboardDataPackage package)
{
foreach (var clipboardData in package.Contents)
{
InjectClipboardData(session, clipboardData);
}
}
public async Task PerformAsync(
IClipboardDataPackage package)
{
clipboardInjectionService.InjectData(package);
await clipboardPasteService.PasteClipboardContentsAsync();
logger.Information("Paste action performed.", 1);
}
public IClipboardDataControlPackage CreateFromDataPackage(IClipboardDataPackage dataPackage)
{
ClipboardDataControlPackage package = null;
mainThreadInvoker.Invoke(
() => package = CreateDataControlPackageFromDataPackage(dataPackage));
return(package);
}
async Task <IEnumerable <IAction> > GetSupportedActionsFromDataAsync(IClipboardDataPackage data)
{
using (performanceHandleFactory.StartMeasuringPerformance())
{
var allowedActions = await asyncFilter.FilterAsync(allActions, action => action.CanPerformAsync(data)).ConfigureAwait(false);
return(allowedActions.OrderBy(x => x.Order));
}
}
async Task <IReadOnlyList <string> > ExtractLinksFromPackageAsync(IClipboardDataPackage package)
{
var textData = (IClipboardTextData) await GetFirstSupportedItemAsync(package)
.ConfigureAwait(false);
var links = await linkParser.ExtractLinksFromTextAsync(textData.Text);
return(new List <string>(links));
}
public async Task <string> GetTitleAsync(IClipboardDataPackage package)
{
if (await clipboardPersistenceService.IsPersistedAsync(package))
{
return("Unpin from clipboard");
}
return("Pin to clipboard");
}
void InjectPackageContents(
IClipboardHandle session,
IClipboardDataPackage package)
{
foreach (var clipboardData in package.Contents)
{
InjectClipboardData(session, clipboardData);
}
}
public async Task PerformAsync(
IClipboardDataPackage processedData)
{
var supportedDataCollection = await GetSupportedData(processedData);
var firstSupportedData = supportedDataCollection.FirstOrDefault();
var zipFilePath = await ZipDataAsync(firstSupportedData);
clipboardInjectionService.InjectFiles(zipFilePath);
}
void DecoratePackageWithClipboardData(
IEnumerable <IClipboardFormat> formats,
IClipboardDataPackage package)
{
foreach (var format in formats)
{
DecoratePackageWithClipboardDataForFormat(package, format);
}
}
void DecoratePackageWithClipboardData(
IEnumerable<uint> formats,
IClipboardDataPackage package)
{
foreach (var format in formats)
{
DecoratePackageWithClipboardDataForFormat(package, format);
}
}
async Task DoForEveryLinkAsync(IClipboardDataPackage package, Action <string> action)
{
var links = await ExtractLinksFromPackageAsync(package);
foreach (var link in links)
{
action(link);
}
}
static IClipboardTextData GetFirstSupportedItem(IClipboardDataPackage package)
{
var supportedItems = package
.Contents
.Where(CanPerform)
.Cast <IClipboardTextData>();
return(supportedItems.FirstOrDefault());
}
public async Task PerformAsync(
IClipboardDataPackage package)
{
var textData = (IClipboardTextData) await GetFirstSupportedItem(package);
await clipboardInjectionService.InjectTextAsync(textData.Text);
await clipboardPasteService.PasteClipboardContentsAsync();
}
public async Task PerformAsync(IClipboardDataPackage package)
{
var textData = (IClipboardTextData)await GetFirstSupportedDataAsync(package).ConfigureAwait(false);
var links = await linkParser.ExtractLinksFromTextAsync(textData.Text).ConfigureAwait(false);
var imagesBytes = await DownloadLinksAsync(links).ConfigureAwait(false);
var images = InterpretImages(imagesBytes);
InjectImages(images);
}
public async Task <bool> CanPerformAsync(
IClipboardDataPackage package)
{
if (package == null)
{
throw new ArgumentNullException(nameof(package));
}
return(true);
}
public async Task PerformAsync(
IClipboardDataPackage package)
{
var textData = (IClipboardTextData)await GetFirstSupportedItem(package).ConfigureAwait(false);
var links = await linkParser.ExtractLinksFromTextAsync(textData.Text).ConfigureAwait(false);
foreach(var link in links)
{
processManager.LaunchCommand(link);
}
}
public async Task<bool> CanPerformAsync(
IClipboardDataPackage package)
{
if (package == null)
{
throw new ArgumentNullException(nameof(package));
}
return true;
}
public async Task PerformAsync(
IClipboardDataPackage processedData)
{
var supportedDataCollection = await GetSupportedData(processedData);
var firstSupportedData = supportedDataCollection.FirstOrDefault();
var zipFilePath = await ZipDataAsync(firstSupportedData);
await clipboardInjectionService.InjectFilesAsync(zipFilePath);
}
public async Task PerformAsync(IClipboardDataPackage package)
{
var links = await ExtractLinksFromPackageAsync(package);
var imagesBytes = await DownloadLinksAsync(links)
.ConfigureAwait(false);
var images = InterpretImages(imagesBytes);
await InjectImagesAsync(images);
}
IClipboardControl CreateControlFromDataPackage(IClipboardDataPackage dataPackage)
{
var matchingFactory = controlFactories.FirstOrDefault(x => x.CanBuildControl(dataPackage));
if (matchingFactory != null)
{
return(matchingFactory.BuildControl(dataPackage));
}
return(null);
}
public async Task PerformAsync(
IClipboardDataPackage package)
{
var textData = (IClipboardTextData) await GetFirstSupportedItem(package).ConfigureAwait(false);
var links = await linkParser.ExtractLinksFromTextAsync(textData.Text).ConfigureAwait(false);
foreach (var link in links)
{
processManager.LaunchCommand(link);
}
}
public void InjectData(IClipboardDataPackage package)
{
clipboardCopyInterceptor.SkipNext();
using (clipboardHandleFactory.StartNewSession())
{
ClipboardApi.EmptyClipboard();
InjectPackageContents(package);
}
logger.Information("Clipboard package has been injected to the clipboard.", 1);
}
public void InjectData(IClipboardDataPackage package)
{
clipboardCopyInterceptor.SkipNext();
using (clipboardHandleFactory.StartNewSession())
{
ClipboardApi.EmptyClipboard();
InjectPackageContents(package);
}
logger.Information("Clipboard package has been injected to the clipboard.", 1);
}
public async Task InjectDataAsync(IClipboardDataPackage package)
{
clipboardCopyInterceptor.SkipNext();
using (var session = clipboardHandleFactory.StartNewSession())
{
session.EmptyClipboard();
InjectPackageContents(session, package);
}
logger.Information("Clipboard package has been injected to the clipboard.", 1);
}
public async Task PerformAsync(IClipboardDataPackage package)
{
var textData = (IClipboardTextData) await GetFirstSupportedDataAsync(package).ConfigureAwait(false);
var links = await linkParser.ExtractLinksFromTextAsync(textData.Text).ConfigureAwait(false);
var imagesBytes = await DownloadLinksAsync(links).ConfigureAwait(false);
var images = InterpretImages(imagesBytes);
InjectImages(images);
}
public async Task PerformAsync(IClipboardDataPackage package)
{
var supportedItem = GetFirstSupportedItem(package);
var randomFileName = DateTime.Now.Ticks;
var randomFilePath = fileManager.WriteBytesToTemporaryFile(
$"{randomFileName}.txt",
Encoding.UTF8.GetBytes(supportedItem.Text));
await clipboardInjectionService.InjectFilesAsync(
randomFilePath);
}
IClipboardControl CreateControlFromDataPackage(IClipboardDataPackage dataPackage)
{
foreach (var item in dataPackage.Contents)
{
var matchingFactory = controlFactories.FirstOrDefault(x => x.CanBuildControl(item));
if (matchingFactory != null)
{
return matchingFactory.BuildControl(item);
}
}
return null;
}
ClipboardDataControlPackage CreateDataControlPackageFromDataPackage(IClipboardDataPackage dataPackage)
{
var control = CreateControlFromDataPackage(dataPackage);
if (control == null)
{
return(null);
}
var package = new ClipboardDataControlPackage(dataPackage, control);
return(package);
}
IClipboardControl CreateControlFromDataPackage(IClipboardDataPackage dataPackage)
{
foreach (var item in dataPackage.Contents)
{
var matchingFactory = controlFactories.FirstOrDefault(x => x.CanBuildControl(item));
if (matchingFactory != null)
{
return(matchingFactory.BuildControl(item));
}
}
return(null);
}
private void DecoratePackageWithClipboardData(
IEnumerable<uint> formats,
IClipboardDataPackage package)
{
foreach (var format in formats)
{
var dataFactory = dataFactories.FirstOrDefault(x => x.CanBuildData(format));
if (dataFactory != null)
{
DecoratePackageWithFormatDataUsingFactory(package, dataFactory, format);
}
}
}
public async Task PersistClipboardPackageAsync(IClipboardDataPackage package)
{
var packageFolder = PrepareUniquePackageFolder();
for (var i = 0; i < package.Contents.Count; i++)
{
var content = package.Contents[i];
var filePath = Path.Combine(
packageFolder,
i + 1 + "." + content.RawFormat);
fileManager.WriteBytesToFile(
filePath,
content.RawData);
}
}
void DecoratePackageWithClipboardDataFromRawDataAndFormat(
IClipboardDataPackage package,
uint format,
byte[] rawData)
{
var factory = FindCapableFactoryFromFormat(format);
var clipboardData = factory?.BuildData(format, rawData);
if (clipboardData != null)
{
package.AddData(clipboardData);
}
}
private void DecoratePackageWithFormatDataUsingFactory(
IClipboardDataPackage package,
IClipboardDataControlFactory factory,
uint format)
{
var unwrapper = memoryUnwrappers.FirstOrDefault(x => x.CanUnwrap(format));
var rawData = unwrapper?.UnwrapStructure(format);
if (rawData == null) return;
var clipboardData = factory.BuildData(format, rawData);
if (clipboardData != null)
{
package.AddData(clipboardData);
}
}
public Task PerformAsync(
IClipboardDataPackage package)
{
throw new NotImplementedException();
}
public async Task<bool> CanPerformAsync(
IClipboardDataPackage package)
{
var supportedData = await asyncFilter.FilterAsync(package.Contents, CanPerformAsync);
return supportedData.Any();
}
void DecoratePackageWithClipboardDataForFormat(
IClipboardDataPackage package,
uint format)
{
var unwrapper = memoryUnwrappers
.FirstOrDefault(
x => x.CanUnwrap(format));
var rawData = unwrapper?.UnwrapStructure(format);
if (rawData == null)
{
return;
}
DecoratePackageWithClipboardDataFromRawDataAndFormat(package, format, rawData);
}
public async Task<bool> CanPerformAsync(IClipboardDataPackage package)
{
return await GetFirstSupportedDataAsync(package).ConfigureAwait(false) != null;
}
async Task<IClipboardData> GetFirstSupportedItem(IClipboardDataPackage data)
{
var supportedData = await asyncFilter.FilterAsync(data.Contents, CanPerformAsync);
return supportedData.FirstOrDefault();
}
public async Task<bool> CanPerformAsync(
IClipboardDataPackage data)
{
return await GetFirstSupportedItem(data) != null;
}
public async Task<bool> CanPerformAsync(IClipboardDataPackage package)
{
return GetRelevantData(package)
.Any();
}
public async Task PerformAsync(IClipboardDataPackage package)
{
foreach (var item in GetRelevantData(package)) { }
}
static IEnumerable<IClipboardData> GetRelevantData(IClipboardDataPackage package)
{
return package.Contents
.Where(x => x.RawData != null);
}
async Task<IClipboardData> GetFirstSupportedDataAsync(IClipboardDataPackage package)
{
var validItems = await asyncFilter.FilterAsync(package.Contents, CanPerformAsync).ConfigureAwait(false);
return validItems.FirstOrDefault();
}
public Task DeletePackageAsync(IClipboardDataPackage package)
{
throw new NotImplementedException();
}
public async Task PerformAsync(
IClipboardDataPackage package)
{
var textData = (IClipboardTextData) await GetFirstSupportedItem(package);
clipboardInjectionService.InjectText(textData.Text);
}
async Task<IReadOnlyCollection<IClipboardData>> GetSupportedData(
IClipboardDataPackage package)
{
var supportedData = await asyncFilter.FilterAsync(package.Contents, CanPerformAsync);
return supportedData;
}
public async Task<bool> CanPerformAsync(
IClipboardDataPackage package)
{
var supportedData = await GetSupportedData(package);
return supportedData.Any();
}
void DecoratePackageWithClipboardDataFromRawDataAndFormat(
IClipboardDataPackage package,
uint format,
byte[] rawData)
{
var factory = FindCapableFactoryFromFormat(format);
var clipboardData = factory?.BuildData(format, rawData);
if (clipboardData != null)
{
package.AddData(clipboardData);
}
}
