private string GetClipboardContent()
{
if (WinClipboard.ContainsText())
{
return(WinClipboard.GetText());
}
// ReSharper disable once InvertIf
if (WinClipboard.ContainsImage())
{
MemoryStream imageStream = (MemoryStream)WinClipboard.GetData(DataFormats.Dib);
BitmapSource imageBitmap = DibToBitmapConverter.Read(imageStream);
if (imageBitmap == null)
{
Logger.Error("Unable to create bitmap from image copied into the clipboard!");
return(null);
}
using (MemoryStream rawImage = new MemoryStream()) {
BitmapEncoder encoder = new PngBitmapEncoder();
encoder.Frames.Add(BitmapFrame.Create(imageBitmap));
encoder.Save(rawImage);
return($"{pngImageHeader}{Convert.ToBase64String(rawImage.ToArray())}");
}
}
return(null);
}
public void AttachClipboardImage()
{
if (!CanAttachImage)
{
return;
}
try
{
BitmapSource image;
if (!Clipboard.ContainsImage() || (image = WinFormsClipboard.GetWpfImage()) == null)
{
return;
}
var tempPath = Path.Combine(_tempDir, Path.GetRandomFileName() + ".png");
using (var fs = new FileStream(tempPath, FileMode.Create))
{
var encoder = new PngBitmapEncoder();
encoder.Frames.Add(BitmapFrame.Create(image));
encoder.Save(fs);
}
AttachImageFromPath(tempPath);
}
catch (Exception ex)
{
ShowImageAttachErrorMessage(ex);
}
}
public bool IsTypeAvailable(TransferDataType type)
{
if (type == null)
{
throw new ArgumentNullException("type");
}
if (type == TransferDataType.Image)
{
return(WindowsClipboard.ContainsImage());
}
if (type == TransferDataType.Text)
{
return(WindowsClipboard.ContainsText(TextDataFormat.UnicodeText) ||
WindowsClipboard.ContainsText(TextDataFormat.Text));
}
if (type == TransferDataType.Rtf)
{
return(WindowsClipboard.ContainsText(TextDataFormat.Rtf));
}
throw new NotImplementedException();
}
public IResponse <BitmapSource> GetImageFromClipboard()
{
if (!Clipboard.ContainsImage())
{
return(Response <BitmapSource> .FromFailure("No image on clipboard"));
}
var clipboardData = System.Windows.Forms.Clipboard.GetDataObject();
if (clipboardData == null)
{
return(Response <BitmapSource> .FromFailure("No data on clipboard"));
}
if (!clipboardData.GetDataPresent(System.Windows.Forms.DataFormats.Bitmap))
{
return(Response <BitmapSource> .FromFailure("Failed to get bitmap from clipboard"));
}
var bitmap =
(System.Drawing.Bitmap)clipboardData.GetData(System.Windows.Forms.DataFormats.Bitmap);
var hBitmap = bitmap.GetHbitmap();
try
{
var bitmapSource = Imaging.CreateBitmapSourceFromHBitmap(
hBitmap,
IntPtr.Zero,
Int32Rect.Empty,
BitmapSizeOptions.FromEmptyOptions());
return(Response <BitmapSource> .FromSuccess(bitmapSource));
}
finally
{
Native.Gdi32.DeleteObject(hBitmap);
}
}
/// <summary>
/// Handle pasting and handle images
/// </summary>
public void PasteOperation()
{
if (Clipboard.ContainsImage())
{
string imagePath = null;
var bmpSource = Clipboard.GetImage();
using (var bitMap = WindowUtilities.BitmapSourceToBitmap(bmpSource))
{
imagePath = AddinManager.Current.RaiseOnSaveImage(bitMap);
}
if (!string.IsNullOrEmpty(imagePath))
{
SetSelection($"");
PreviewMarkdownCallback(); // force a preview refresh
return;
}
string initialFolder = null;
if (!string.IsNullOrEmpty(MarkdownDocument.Filename) && MarkdownDocument.Filename != "untitled")
{
initialFolder = Path.GetDirectoryName(MarkdownDocument.Filename);
}
var sd = new SaveFileDialog
{
Filter = "Image files (*.png;*.jpg;*.gif;)|*.png;*.jpg;*.jpeg;*.gif|All Files (*.*)|*.*",
FilterIndex = 1,
Title = "Save Image from Clipboard as",
InitialDirectory = initialFolder,
CheckFileExists = false,
OverwritePrompt = true,
CheckPathExists = true,
RestoreDirectory = true
};
var result = sd.ShowDialog();
if (result != null && result.Value)
{
imagePath = sd.FileName;
try
{
var ext = Path.GetExtension(imagePath)?.ToLower();
using (var fileStream = new FileStream(imagePath, FileMode.Create))
{
BitmapEncoder encoder = null;
if (ext == ".png")
{
encoder = new PngBitmapEncoder();
}
else if (ext == ".jpg" || ext == ".jpeg")
{
encoder = new JpegBitmapEncoder();
}
else if (ext == ".gif")
{
encoder = new GifBitmapEncoder();
}
encoder.Frames.Add(BitmapFrame.Create(bmpSource));
encoder.Save(fileStream);
}
}
catch (Exception ex)
{
MessageBox.Show("Couldn't copy file to new location: \r\n" + ex.Message, mmApp.ApplicationName);
return;
}
string relPath = Path.GetDirectoryName(sd.FileName);
if (initialFolder != null)
{
try
{
relPath = FileUtils.GetRelativePath(sd.FileName, initialFolder);
}
catch (Exception ex)
{
mmApp.Log($"Failed to get relative path.\r\nFile: {sd.FileName}, Path: {imagePath}", ex);
}
if (!relPath.StartsWith("..\\"))
{
imagePath = relPath;
}
}
if (imagePath.Contains(":\\"))
{
imagePath = "file:///" + imagePath;
}
SetSelection($"");
PreviewMarkdownCallback(); // force a preview refresh
}
}
else if (Clipboard.ContainsText())
{
// just paste as is at cursor or selection
SetSelection(Clipboard.GetText());
}
}
public DataPackageView GetContent()
{
var dataPackage = new DataPackage();
if (Clipboard.ContainsImage())
{
dataPackage.SetDataProvider(StandardDataFormats.Bitmap, async ct =>
{
var bitmap = Clipboard.GetImage();
var bitmapStream = new MemoryStream();
var bitmapEncoder = new BmpBitmapEncoder();
bitmapEncoder.Frames.Add(BitmapFrame.Create(bitmap));
bitmapEncoder.Save(bitmapStream);
// Letting a MemoryStream run around does not cause problems.
// The GC will take care of it, just like a byte[].
return(RandomAccessStreamReference.CreateFromStream(bitmapStream.AsRandomAccessStream()));
});
}
if (Clipboard.ContainsText())
{
// Copying significant amounts of text still makes Clipboard.GetText() slow, so
// we'll still use the SetDataProvider
dataPackage.SetDataProvider(StandardDataFormats.Text, async ct =>
{
return(Clipboard.GetText());
});
}
if (Clipboard.ContainsData(DataFormats.Html))
{
dataPackage.SetDataProvider(StandardDataFormats.Html, async ct =>
{
return(Clipboard.GetData(DataFormats.Html));
});
}
if (Clipboard.ContainsData(DataFormats.Rtf))
{
dataPackage.SetDataProvider(StandardDataFormats.Rtf, async ct =>
{
return(Clipboard.GetData(DataFormats.Rtf));
});
}
if (Clipboard.ContainsFileDropList())
{
dataPackage.SetDataProvider(StandardDataFormats.StorageItems, async ct =>
{
var list = Clipboard.GetFileDropList();
var storageItemList = new List <IStorageItem>(list.Count);
foreach (var path in list)
{
var attr = File.GetAttributes(path);
if (attr.HasFlag(global::System.IO.FileAttributes.Directory))
{
storageItemList.Add(await StorageFolder.GetFolderFromPathAsync(path));
}
else
{
storageItemList.Add(await StorageFile.GetFileFromPathAsync(path));
}
}
return(storageItemList);
});
}
return(dataPackage.GetView());
}