/// <summary>
/// Test monitoring the clipboard
/// </summary>
/// <returns></returns>
//[WpfFact]
public async Task TestClipboardMonitor_WaitForCopy()
{
var tcs = new TaskCompletionSource <bool>();
var subscription = ClipboardMonitor.OnUpdate.Subscribe(clipboard =>
{
Log.Debug().WriteLine("Formats {0}", string.Join(",", clipboard.Formats));
Log.Debug().WriteLine("Owner {0}", clipboard.OwnerHandle);
Log.Debug().WriteLine("Sequence {0}", clipboard.Id);
if (clipboard.Formats.Contains("PNG"))
{
using (ClipboardNative.Lock())
{
var stream = ClipboardNative.GetAsStream("PNG");
using (var fileStream = File.Create(@"D:\test.png"))
{
stream.CopyTo(fileStream);
}
}
}
tcs.TrySetResult(true);
});
await tcs.Task;
subscription.Dispose();
}
/// <inheritdoc />
public void CopyToClipboard(string origin, string text)
{
using (var clipboardAccessToken = ClipboardNative.Access())
{
clipboardAccessToken.SetAsUnicodeString(text);
}
}
public async Task TestClipboardMonitor_Text()
{
const string testString = "Dapplo.Windows.Tests.ClipboardTests";
bool hasNewContent = false;
var subscription = ClipboardNative.OnUpdate.Where(clipboard => clipboard.Formats.Contains("TEST_FORMAT")).Subscribe(clipboard =>
{
Log.Debug().WriteLine("Detected change {0}", string.Join(",", clipboard.Formats));
Log.Debug().WriteLine("Owner {0}", clipboard.OwnerHandle);
Log.Debug().WriteLine("Sequence {0}", clipboard.Id);
hasNewContent = true;
});
using (var clipboardAccessToken = ClipboardNative.Access())
{
clipboardAccessToken.ClearContents();
clipboardAccessToken.SetAsUnicodeString(testString, "TEST_FORMAT");
}
await Task.Delay(100);
subscription.Dispose();
// Doesn't work on AppVeyor!!
Assert.True(hasNewContent);
}
public async Task TestClipboardStore_MemoryStream()
{
const string testString = "Dapplo.Windows.Tests.ClipboardTests";
var testStream = new MemoryStream();
var bytes = Encoding.Unicode.GetBytes(testString + "\0");
Assert.Equal(testString, Encoding.Unicode.GetString(bytes).TrimEnd('\0'));
testStream.Write(bytes, 0, bytes.Length);
testStream.Seek(0, SeekOrigin.Begin);
Assert.Equal(testString, Encoding.Unicode.GetString(testStream.GetBuffer(), 0, (int)testStream.Length).TrimEnd('\0'));
using (var clipboardAccessToken = ClipboardNative.Access())
{
clipboardAccessToken.ClearContents();
clipboardAccessToken.SetAsStream(StandardClipboardFormats.UnicodeText, testStream);
}
await Task.Delay(100);
using (var clipboardAccessToken = ClipboardNative.Access())
{
Assert.Equal(testString, clipboardAccessToken.GetAsUnicodeString());
var unicodeBytes = clipboardAccessToken.GetAsBytes(StandardClipboardFormats.UnicodeText);
Assert.Equal(testString, Encoding.Unicode.GetString(unicodeBytes, 0, unicodeBytes.Length).TrimEnd('\0'));
var unicodeStream = clipboardAccessToken.GetAsStream(StandardClipboardFormats.UnicodeText);
using (var memoryStream = new MemoryStream())
{
unicodeStream.CopyTo(memoryStream);
Assert.Equal(testString, Encoding.Unicode.GetString(memoryStream.GetBuffer(), 0, (int)memoryStream.Length).TrimEnd('\0'));
}
}
}
public async Task TestClipboardStore_MemoryStream()
{
const string testString = "Dapplo.Windows.Tests.ClipboardTests";
var testStream = new MemoryStream();
var bytes = Encoding.Unicode.GetBytes(testString + "\0");
Assert.Equal(testString, Encoding.Unicode.GetString(bytes).TrimEnd('\0'));
testStream.Write(bytes, 0, bytes.Length);
Assert.Equal(testString, Encoding.Unicode.GetString(testStream.GetBuffer(), 0, (int)testStream.Length).TrimEnd('\0'));
MemoryStream resultStream;
using (ClipboardNative.Lock())
{
ClipboardNative.Clear();
ClipboardNative.SetAsStream("CF_UNICODETEXT", testStream);
}
await Task.Delay(1000);
using (ClipboardNative.Lock())
{
resultStream = ClipboardNative.GetAsStream("CF_UNICODETEXT");
}
Assert.Equal(testString, Encoding.Unicode.GetString(resultStream.GetBuffer(), 0, (int)resultStream.Length).TrimEnd('\0'));
}
/// <summary>
/// Place the clip back onto the clipboard
/// </summary>
/// <param name="clip">Clip</param>
/// <param name="fromExisting">bool</param>
public static void PlaceOnClipboard(this Clip clip, bool fromExisting = false)
{
var handle = WinProcHandler.Instance.Handle;
if (InteropWindowFactory.CreateFor(clip.OriginalWindowHandle).Exists())
{
handle = clip.OriginalWindowHandle;
}
// TODO: Prevent detecting the restore, especially if Dopy doesn't "paste" with it's Window handle
using var clipboardAccessToken = ClipboardNative.Access(handle);
clipboardAccessToken.ClearContents();
// Make the clipboard as modified by DOPY
if (fromExisting || clip.IsModifiedByDopy)
{
clipboardAccessToken.SetAsUnicodeString($"On {DateTime.Now:O}", ClipboardFormats.Dopy);
}
foreach (var key in clip.Contents.Keys)
{
clipboardAccessToken.SetAsStream(key, clip.Contents[key]);
}
if (!string.IsNullOrEmpty(clip.ClipboardText))
{
clipboardAccessToken.SetAsUnicodeString(clip.ClipboardText);
}
}
/// <inheritdoc />
public string GetClipboardString()
{
using (var clipboardAccessToken = ClipboardNative.Access())
{
return(clipboardAccessToken.GetAsUnicodeString());
}
}
/// <summary>
/// Test monitoring the clipboard
/// </summary>
/// <returns></returns>
public async Task TestClipboardMonitor_WaitForCopy()
{
var tcs = new TaskCompletionSource <bool>(TaskCreationOptions.RunContinuationsAsynchronously);
var subscription = ClipboardNative.OnUpdate.Skip(1).Subscribe(clipboardUpdateInformation =>
{
Log.Debug().WriteLine("Formats {0}", string.Join(",", clipboardUpdateInformation.Formats));
Log.Debug().WriteLine("Owner {0}", clipboardUpdateInformation.OwnerHandle);
Log.Debug().WriteLine("Sequence {0}", clipboardUpdateInformation.Id);
if (clipboardUpdateInformation.Formats.Contains("PNG"))
{
using (var clipboard = ClipboardNative.Access())
{
using (var stream = clipboard.GetAsStream("PNG"))
{
using (var fileStream = File.Create(@"c:\projects\test.png"))
{
stream.CopyTo(fileStream);
}
}
}
}
tcs.TrySetResult(true);
});
await tcs.Task;
subscription.Dispose();
}
public async Task Test_ClipboardAccess_LockTimeout_Exception()
{
using (await ClipboardNative.AccessAsync())
using (var clipboardAccessToken = await ClipboardNative.AccessAsync())
{
Assert.Throws <ClipboardAccessDeniedException>(() => clipboardAccessToken.ThrowWhenNoAccess());
}
}
/// <summary>
/// Used from the View
/// </summary>
public void CopyToClipboard()
{
using (var clipboardAccessToken = ClipboardNative.Access())
{
clipboardAccessToken.ClearContents();
clipboardAccessToken.SetAsUrl(SelectedImgur.Data.Link?.AbsoluteUri);
}
}
/// <summary>
/// Test if the clipboard contains files
/// </summary>
/// <returns></returns>
//[WpfFact]
public void TestClipboard_Filenames()
{
using (ClipboardNative.Lock())
{
var filenames = ClipboardNative.GetFilenames().ToList();
Assert.True(filenames.Any());
}
}
/// <summary>
/// Test if the clipboard contains files
/// </summary>
/// <returns></returns>
//[WpfFact]
public void TestClipboard_Filenames()
{
using (var clipboardAccessToken = ClipboardNative.Access())
{
var filenames = clipboardAccessToken.GetFilenames();
Assert.True(filenames.Any());
}
}
public void CopyToClipboard()
{
// TODO: Build url
using (var clipboardAccessToken = ClipboardNative.Access())
{
clipboardAccessToken.ClearContents();
clipboardAccessToken.SetAsUrl(SelectedLutim.LutimInfo.Short);
}
}
public async Task Test_ClipboardAccess_LockTimeout()
{
using (var outerClipboardAcess = await ClipboardNative.AccessAsync())
{
Assert.True(outerClipboardAcess.CanAccess);
var clipboardAccessToken = await ClipboardNative.AccessAsync();
Assert.True(clipboardAccessToken.IsLockTimeout);
}
}
protected override ExportInformation ExportCapture(bool manuallyInitiated, ISurface surface, ICaptureDetails captureDetails)
{
var exportInformation = new ExportInformation(Designation, Description);
try
{
using (var clipboardAccessToken = ClipboardNative.Access())
{
clipboardAccessToken.ClearContents();
// TODO: Test if this works
if (!string.IsNullOrEmpty(surface.LastSaveFullPath))
{
clipboardAccessToken.SetAsUnicodeString(surface.LastSaveFullPath);
}
foreach (var clipboardFormat in CoreConfiguration.ClipboardFormats)
{
switch (clipboardFormat)
{
case ClipboardFormats.DIB:
clipboardAccessToken.SetAsDeviceIndependendBitmap(surface);
break;
case ClipboardFormats.DIBV5:
clipboardAccessToken.SetAsFormat17(surface);
break;
case ClipboardFormats.PNG:
clipboardAccessToken.SetAsBitmap(surface, new SurfaceOutputSettings(OutputFormats.png));
break;
case ClipboardFormats.BITMAP:
clipboardAccessToken.SetAsBitmap(surface, new SurfaceOutputSettings(OutputFormats.bmp));
break;
case ClipboardFormats.HTML:
clipboardAccessToken.SetAsHtml(surface);
break;
case ClipboardFormats.HTMLDATAURL:
clipboardAccessToken.SetAsEmbeddedHtml(surface);
break;
}
}
}
exportInformation.ExportMade = true;
}
catch (Exception)
{
// TODO: Change to general logic in ProcessExport
surface.SendMessageEvent(this, SurfaceMessageTyp.Error, "Error"); //GreenshotLanguage.editorclipboardfailed);
}
ProcessExport(exportInformation, surface);
return(exportInformation);
}
public static List <ClipboardFormat> GetFormats()
{
uint format = 0;
var list = new List <ClipboardFormat>();
while ((format = ClipboardNative.EnumClipboardFormats(format)) != 0)
{
list.Add(format);
}
return(list);
}
/// <summary>
///
/// </summary>
public FormatsViewModel(
IDopyTranslations dopyTranslations,
IDopyConfiguration dopyConfiguration)
{
DopyTranslations = dopyTranslations;
DopyConfiguration = dopyConfiguration;
dopyTranslations.CreateDisplayNameBinding(this, nameof(IDopyTranslations.FormatsConfigTitle));
Id = "F_Formats";
SelectedFormats = new ObservableCollection <string>(DopyConfiguration.IncludeFormats);
using var clipboardAccessToken = ClipboardNative.Access();
AvailableFormats = new ObservableCollection <string>(clipboardAccessToken.AvailableFormats());
}
/// <summary>
/// Upload the capture to OneDrive
/// </summary>
/// <param name="captureDetails">ICaptureDetails</param>
/// <param name="surfaceToUpload">ISurface</param>
/// <returns>Uri</returns>
private async Task <Uri> Upload(ICaptureDetails captureDetails, ISurface surfaceToUpload)
{
try
{
Uri response;
var cancellationTokenSource = new CancellationTokenSource();
using (var ownedPleaseWaitForm = _pleaseWaitFormFactory(cancellationTokenSource))
{
ownedPleaseWaitForm.Value.SetDetails("OneDrive", _oneDriveLanguage.CommunicationWait);
ownedPleaseWaitForm.Value.Show();
try
{
var oneDriveResponse = await UploadToOneDriveAsync(_oauth2Settings, surfaceToUpload, null, cancellationTokenSource.Token);
Log.Info().WriteLine($"id: {oneDriveResponse.Id}");
if (_oneDriveConfiguration.LinkType == OneDriveLinkType.@private)
{
response = new Uri(oneDriveResponse.WebUrl);
}
else
{
var sharableLink = await CreateSharableLinkAync(_oauth2Settings, oneDriveResponse.Id, _oneDriveConfiguration.LinkType);
response = new Uri(sharableLink.Link.WebUrl);
}
}
finally
{
ownedPleaseWaitForm.Value.Close();
}
}
if (_oneDriveConfiguration.AfterUploadLinkToClipBoard)
{
using (var clipboardAccessToken = ClipboardNative.Access())
{
clipboardAccessToken.ClearContents();
clipboardAccessToken.SetAsUrl(response.AbsoluteUri);
}
}
return(response);
}
catch (Exception e)
{
Log.Error().WriteLine(e, "Error uploading.");
MessageBox.Show(_oneDriveLanguage.UploadFailure + " " + e.Message);
}
return(null);
}
private void ContextMenuOpening(object sender, CancelEventArgs e)
{
using (var clipboardAccessToken = ClipboardNative.Access())
{
contextmenu_captureclipboard.Enabled = clipboardAccessToken.HasImage();
}
contextmenu_capturelastregion.Enabled = _coreConfiguration.LastCapturedRegion != NativeRect.Empty;
// IE context menu code
try
{
if (_coreConfiguration.IECapture && IeCaptureHelper.IsIeRunning())
{
contextmenu_captureie.Enabled = true;
contextmenu_captureiefromlist.Enabled = true;
}
else
{
contextmenu_captureie.Enabled = false;
contextmenu_captureiefromlist.Enabled = false;
}
}
catch (Exception ex)
{
Log.Warn().WriteLine("Problem accessing IE information: {0}", ex.Message);
}
// Multi-Screen captures
contextmenu_capturefullscreen.Click -= CaptureFullScreenToolStripMenuItemClick;
contextmenu_capturefullscreen.DropDownOpening -= MultiScreenDropDownOpening;
contextmenu_capturefullscreen.DropDownClosed -= MultiScreenDropDownClosing;
if (Screen.AllScreens.Length > 1)
{
contextmenu_capturefullscreen.DropDownOpening += MultiScreenDropDownOpening;
contextmenu_capturefullscreen.DropDownClosed += MultiScreenDropDownClosing;
}
else
{
contextmenu_capturefullscreen.Click += CaptureFullScreenToolStripMenuItemClick;
}
var now = DateTime.Now;
if (now.Month == 12 && now.Day > 19 && now.Day < 27 || // christmas
now.Month == 3 && now.Day > 13 && now.Day < 21)
{
// birthday
var resources = new ComponentResourceManager(typeof(MainForm));
contextmenu_donate.Image = (Image)resources.GetObject("contextmenu_present.Image");
}
}
public async Task TestClipboardStore_String()
{
const string testString = "Dapplo.Windows.Tests.ClipboardTests";
using (ClipboardNative.Lock())
{
ClipboardNative.Clear();
ClipboardNative.SetAsUnicodeString(testString);
}
await Task.Delay(1000);
using (ClipboardNative.Lock())
{
Assert.Equal(testString, ClipboardNative.GetAsUnicodeString());
}
}
public async Task TestClipboardStore_String()
{
const string testString = "Dapplo.Windows.Tests.ClipboardTests";
using (var clipboardAccessToken = ClipboardNative.Access())
{
clipboardAccessToken.ClearContents();
clipboardAccessToken.SetAsUnicodeString(testString);
}
await Task.Delay(100);
using (var clipboardAccessToken = ClipboardNative.Access())
{
Assert.Equal(testString, clipboardAccessToken.GetAsUnicodeString());
}
}
public void TestClipboard_RegisterFormat()
{
string format = "DAPPLO.DOPY" + ClipboardNative.SequenceNumber;
// Register the format
var id1 = ClipboardNative.RegisterFormat(format);
// Register the format again
var id2 = ClipboardNative.RegisterFormat(format);
Assert.Equal(id1, id2);
// Make sure it works
using (ClipboardNative.Lock())
{
ClipboardNative.Clear();
ClipboardNative.SetAsUnicodeString("Blub", format);
}
}
public void TestClipboard_RegisterFormat()
{
string format = "DAPPLO.DOPY" + ClipboardNative.SequenceNumber;
// Register the format
var id1 = ClipboardFormatExtensions.RegisterFormat(format);
// Register the format again
var id2 = ClipboardFormatExtensions.RegisterFormat(format);
Assert.Equal(id1, id2);
// Make sure it works
using (var clipboard = ClipboardNative.Access())
{
clipboard.ClearContents();
clipboard.SetAsUnicodeString("Blub", format);
}
}
/// <summary>
/// Run the Windows 10 OCR engine to process the text on the captured image
/// </summary>
/// <param name="manuallyInitiated"></param>
/// <param name="surface"></param>
/// <param name="captureDetails"></param>
/// <returns>ExportInformation</returns>
public override async Task <ExportInformation> ExportCaptureAsync(bool manuallyInitiated, ISurface surface, ICaptureDetails captureDetails)
{
var exportInformation = new ExportInformation(Designation, Description);
try
{
string text;
var ocrEngine = OcrEngine.TryCreateFromUserProfileLanguages();
using (var imageStream = new MemoryStream())
{
ImageOutput.SaveToStream(surface, imageStream, new SurfaceOutputSettings());
imageStream.Position = 0;
var decoder = await BitmapDecoder.CreateAsync(imageStream.AsRandomAccessStream());
var softwareBitmap = await decoder.GetSoftwareBitmapAsync();
var ocrResult = await ocrEngine.RecognizeAsync(softwareBitmap);
text = ocrResult.Text;
}
// Check if we found text
if (!string.IsNullOrWhiteSpace(text))
{
// Place the OCR text on the clipboard
using (var clipboardAccessToken = ClipboardNative.Access())
{
clipboardAccessToken.ClearContents();
clipboardAccessToken.SetAsUnicodeString(text);
}
}
exportInformation.ExportMade = true;
}
catch (Exception ex)
{
exportInformation.ExportMade = false;
exportInformation.ErrorMessage = ex.Message;
}
ProcessExport(exportInformation, surface);
return(exportInformation);
}
/// <summary>
/// Upload the capture to Tfs
/// </summary>
/// <param name="workItem">WorkItem</param>
/// <param name="surfaceToUpload">ISurface</param>
/// <returns>Uri</returns>
private async Task <Uri> Upload(WorkItem workItem, ISurface surfaceToUpload)
{
try
{
Uri response;
var cancellationTokenSource = new CancellationTokenSource();
using (var ownedPleaseWaitForm = _pleaseWaitFormFactory(cancellationTokenSource))
{
ownedPleaseWaitForm.Value.SetDetails("TFS plug-in", _tfsLanguage.CommunicationWait);
ownedPleaseWaitForm.Value.Show();
try
{
var result = await _tfsClient.CreateAttachment(surfaceToUpload);
await _tfsClient.LinkAttachment(workItem, result);
response = result.Url;
}
finally
{
ownedPleaseWaitForm.Value.Close();
}
}
if (_tfsConfiguration.AfterUploadLinkToClipBoard)
{
using (var clipboardAccessToken = ClipboardNative.Access())
{
clipboardAccessToken.ClearContents();
clipboardAccessToken.SetAsUrl(response.AbsoluteUri);
}
}
return(response);
}
catch (Exception e)
{
Log.Error().WriteLine(e, "Error uploading.");
MessageBox.Show(_tfsLanguage.UploadFailure + " " + e.Message);
}
return(null);
}
public async Task <string> Upload(ICaptureDetails captureDetails, ISurface surface)
{
string uploadUrl = null;
try
{
var cancellationTokenSource = new CancellationTokenSource();
using (var ownedPleaseWaitForm = _pleaseWaitFormFactory(cancellationTokenSource))
{
ownedPleaseWaitForm.Value.SetDetails("Flickr", _flickrLanguage.CommunicationWait);
ownedPleaseWaitForm.Value.Show();
try
{
uploadUrl = await UploadToFlickrAsync(surface, captureDetails.Title, cancellationTokenSource.Token);
}
finally
{
ownedPleaseWaitForm.Value.Close();
}
}
if (uploadUrl == null)
{
return(null);
}
if (_flickrConfiguration.AfterUploadLinkToClipBoard)
{
using (var clipboardAccessToken = ClipboardNative.Access())
{
clipboardAccessToken.ClearContents();
clipboardAccessToken.SetAsUrl(uploadUrl);
}
}
}
catch (Exception e)
{
Log.Error().WriteLine(e, "Error uploading.");
MessageBox.Show(_flickrLanguage.UploadFailure + @" " + e.Message);
}
return(uploadUrl);
}
public override async Task <ExportInformation> ExportCaptureAsync(bool manuallyInitiated, ISurface surface, ICaptureDetails captureDetails)
{
var exportInformation = new ExportInformation(Designation, Description);
var uploadUrl = await UploadAsync(surface).ConfigureAwait(true);
if (uploadUrl != null)
{
exportInformation.Uri = uploadUrl;
exportInformation.ExportMade = true;
if (_dropboxPluginConfiguration.AfterUploadLinkToClipBoard)
{
using (var clipboardAccessToken = ClipboardNative.Access())
{
clipboardAccessToken.ClearContents();
clipboardAccessToken.SetAsUrl(uploadUrl);
}
}
}
ProcessExport(exportInformation, surface);
return(exportInformation);
}
/// <summary>
/// Saves image to specific path with specified quality
/// </summary>
public static void Save(ISurface surface, string fullPath, bool allowOverwrite, SurfaceOutputSettings outputSettings, bool copyPathToClipboard)
{
fullPath = FilenameHelper.MakeFqFilenameSafe(fullPath);
var path = Path.GetDirectoryName(fullPath);
// check whether path exists - if not create it
if (path != null)
{
var di = new DirectoryInfo(path);
if (!di.Exists)
{
Directory.CreateDirectory(di.FullName);
}
}
if (!allowOverwrite && File.Exists(fullPath))
{
var throwingException = new ArgumentException("File '" + fullPath + "' already exists.");
throwingException.Data.Add("fullPath", fullPath);
throw throwingException;
}
Log.Debug().WriteLine("Saving surface to {0}", fullPath);
// Create the stream and call SaveToStream
using (var stream = new FileStream(fullPath, FileMode.Create, FileAccess.Write))
{
SaveToStream(surface, stream, outputSettings);
}
// TODO: This should not be done here, remove this!!
if (copyPathToClipboard)
{
using (var clipboardAccessToken = ClipboardNative.Access())
{
clipboardAccessToken.ClearContents();
// TODO: File??
clipboardAccessToken.SetAsUnicodeString(fullPath);
}
}
}
/// <inheritdoc />
public override async Task <ExportInformation> ExportCaptureAsync(bool manuallyInitiated, ISurface surface, ICaptureDetails captureDetails)
{
var exportInformation = new ExportInformation(Designation, Description);
var fullPath = captureDetails.Filename ?? surface.SaveNamedTmpFile(CoreConfiguration, _externalCommandConfiguration);
using (var cli = new Cli(_externalCommandDefinition.Command))
{
var arguments = string.Format(_externalCommandDefinition.Arguments, fullPath);
// Execute
var output = await cli.ExecuteAsync(arguments).ConfigureAwait(true);
if (_externalCommandDefinition.CommandBehavior.HasFlag(CommandBehaviors.ParseOutputForUris))
{
var uriMatches = UriRegexp.Matches(output.StandardOutput);
if (uriMatches.Count > 0)
{
exportInformation.Uri = uriMatches[0].Groups[1].Value;
using (var clipboardAccessToken = ClipboardNative.Access())
{
clipboardAccessToken.ClearContents();
clipboardAccessToken.SetAsUrl(exportInformation.Uri);
}
}
}
if (_externalCommandDefinition.CommandBehavior.HasFlag(CommandBehaviors.DeleteOnExit))
{
File.Delete(fullPath);
}
}
ProcessExport(exportInformation, surface);
return(exportInformation);
}
/// <summary>
/// Upload the capture to lutim
/// </summary>
/// <param name="surfaceToUpload">ISurface</param>
/// <returns>true if the upload succeeded</returns>
private async Task <string> Upload(ISurface surfaceToUpload)
{
string uploadUrl;
try
{
LutimInfo lutimInfo;
var cancellationTokenSource = new CancellationTokenSource();
using (var ownedPleaseWaitForm = _pleaseWaitFormFactory(cancellationTokenSource))
{
ownedPleaseWaitForm.Value.SetDetails("Lutim", _lutimLanguage.CommunicationWait);
ownedPleaseWaitForm.Value.Show();
try
{
lutimInfo = await _lutimApi.UploadToLutim(surfaceToUpload).ConfigureAwait(true);
if (lutimInfo != null)
{
Log.Info().WriteLine("Storing lutim upload for hash {0} and delete hash {1}",
lutimInfo.Short, lutimInfo.Token);
// TODO: Write somewhere
// _lutimConfiguration.LutimUploadHistory.Add(lutimInfo.Short, lutimInfo.ToIniString());
_lutimConfiguration.RuntimeLutimHistory.Add(lutimInfo.Short, lutimInfo);
// TODO: Update
// UpdateHistoryMenuItem();
}
}
finally
{
ownedPleaseWaitForm.Value.Close();
}
}
if (lutimInfo != null)
{
uploadUrl = lutimInfo.Short;
if (string.IsNullOrEmpty(uploadUrl) || !_lutimConfiguration.CopyLinkToClipboard)
{
return(uploadUrl);
}
try
{
using (var clipboardAccessToken = ClipboardNative.Access())
{
clipboardAccessToken.ClearContents();
clipboardAccessToken.SetAsUrl(uploadUrl);
}
}
catch (Exception ex)
{
Log.Error().WriteLine(ex, "Can't write to clipboard: ");
return(null);
}
return(uploadUrl);
}
}
catch (Exception e)
{
Log.Error().WriteLine(e, "Error uploading.");
MessageBox.Show(_lutimLanguage.UploadFailure + " " + e.Message);
}
return(null);
}
