/// <summary> /// This will be called when the menu item in the Editor is clicked /// </summary> public bool Upload(ICaptureDetails captureDetails, ISurface surfaceToUpload, out string uploadUrl) { uploadUrl = null; SurfaceOutputSettings outputSettings = new SurfaceOutputSettings(config.UploadFormat, config.UploadJpegQuality, false); try { string dropboxUrl = null; new PleaseWaitForm().ShowAndWait(Attributes.Name, Language.GetString("dropbox", LangKey.communication_wait), delegate() { string filename = Path.GetFileName(FilenameHelper.GetFilename(config.UploadFormat, captureDetails)); dropboxUrl = DropboxUtils.UploadToDropbox(surfaceToUpload, outputSettings, filename); } ); if (dropboxUrl == null) { return(false); } uploadUrl = dropboxUrl; return(true); } catch (Exception e) { LOG.Error(e); MessageBox.Show(Language.GetString("dropbox", LangKey.upload_failure) + " " + e.Message); return(false); } }
public bool Upload(ICaptureDetails captureDetails, ISurface surfaceToUpload, out string uploadUrl) { SurfaceOutputSettings outputSettings = new SurfaceOutputSettings(config.UploadFormat, config.UploadJpegQuality); try { string url = null; new PleaseWaitForm().ShowAndWait("Picasa plug-in", Language.GetString("picasa", LangKey.communication_wait), delegate() { string filename = Path.GetFileName(FilenameHelper.GetFilename(config.UploadFormat, captureDetails)); string contentType = "image/" + config.UploadFormat.ToString(); url = PicasaUtils.UploadToPicasa(surfaceToUpload, outputSettings, captureDetails.Title, filename); } ); uploadUrl = url; if (uploadUrl != null && config.AfterUploadLinkToClipBoard) { ClipboardHelper.SetClipboardData(uploadUrl); } return(true); } catch (Exception e) { MessageBox.Show(Language.GetString("picasa", LangKey.upload_failure) + " " + e.ToString()); } uploadUrl = null; return(false); }
public void Upload(ICaptureDetails captureDetails, ISurface surface, ExportInformation exportInformation) { SurfaceOutputSettings outputSettings = new SurfaceOutputSettings(config.UploadFormat, config.UploadJpegQuality, false); try { string flickrUrl = null; new PleaseWaitForm().ShowAndWait("Flickr plug-in", Language.GetString("flickr", LangKey.communication_wait), delegate() { string filename = Path.GetFileName(FilenameHelper.GetFilename(config.UploadFormat, captureDetails)); flickrUrl = FlickrUtils.UploadToFlickr(surface, outputSettings, captureDetails.Title, filename); } ); if (flickrUrl == null) { exportInformation.ExportMade = false; return; } exportInformation.ExportMade = true; exportInformation.Uri = flickrUrl; if (config.AfterUploadLinkToClipBoard) { ClipboardHelper.SetClipboardData(flickrUrl); } } catch (Exception e) { MessageBox.Show(Language.GetString("flickr", LangKey.upload_failure) + " " + e.Message); } }
/// <summary> /// This will be called when the menu item in the Editor is clicked /// </summary> public string Upload(ICaptureDetails captureDetails, ISurface surfaceToUpload) { SurfaceOutputSettings outputSettings = new SurfaceOutputSettings(config.UploadFormat, config.UploadJpegQuality, false); try { string url = null; string filename = Path.GetFileName(FilenameHelper.GetFilename(config.UploadFormat, captureDetails)); SurfaceContainer imageToUpload = new SurfaceContainer(surfaceToUpload, outputSettings, filename); new PleaseWaitForm().ShowAndWait("Box plug-in", Language.GetString("box", LangKey.communication_wait), delegate() { url = BoxUtils.UploadToBox(imageToUpload, captureDetails.Title, filename); } ); if (url != null && config.AfterUploadLinkToClipBoard) { ClipboardHelper.SetClipboardData(url); } return(url); } catch (Exception ex) { LOG.Error("Error uploading.", ex); MessageBox.Show(Language.GetString("box", LangKey.upload_failure) + " " + ex.ToString()); return(null); } }
public bool Upload(ICaptureDetails captureDetails, ISurface surface, out string uploadUrl) { SurfaceOutputSettings outputSettings = new SurfaceOutputSettings(_config.UploadFormat, _config.UploadJpegQuality, false); uploadUrl = null; try { string flickrUrl = null; new PleaseWaitForm().ShowAndWait(Attributes.Name, Language.GetString("flickr", LangKey.communication_wait), delegate { string filename = Path.GetFileName(FilenameHelper.GetFilename(_config.UploadFormat, captureDetails)); flickrUrl = FlickrUtils.UploadToFlickr(surface, outputSettings, captureDetails.Title, filename); } ); if (flickrUrl == null) { return(false); } uploadUrl = flickrUrl; if (_config.AfterUploadLinkToClipBoard) { ClipboardHelper.SetClipboardData(flickrUrl); } return(true); } catch (Exception e) { Log.Error("Error uploading.", e); MessageBox.Show(Language.GetString("flickr", LangKey.upload_failure) + " " + e.Message); } return(false); }
public override ExportInformation ExportCapture(bool manuallyInitiated, ISurface surfaceToUpload, ICaptureDetails captureDetails) { ExportInformation exportInformation = new ExportInformation(Designation, Description); string filename = Path.GetFileName(FilenameHelper.GetFilename(Config.UploadFormat, captureDetails)); SurfaceOutputSettings outputSettings = new SurfaceOutputSettings(Config.UploadFormat, Config.UploadJpegQuality, Config.UploadReduceColors); if (_jiraIssue != null) { try { // Run upload in the background new PleaseWaitForm().ShowAndWait(Description, Language.GetString("jira", LangKey.communication_wait), async() => { var surfaceContainer = new SurfaceContainer(surfaceToUpload, outputSettings, filename); await _jiraPlugin.JiraConnector.AttachAsync(_jiraIssue.Key, surfaceContainer); surfaceToUpload.UploadUrl = _jiraPlugin.JiraConnector.JiraBaseUri.AppendSegments("browse", _jiraIssue.Key).AbsoluteUri; } ); Log.DebugFormat("Uploaded to Jira {0}", _jiraIssue.Key); exportInformation.ExportMade = true; exportInformation.Uri = surfaceToUpload.UploadUrl; } catch (Exception e) { MessageBox.Show(Language.GetString("jira", LangKey.upload_failure) + " " + e.Message); } } else { var jiraForm = new JiraForm(_jiraPlugin.JiraConnector); jiraForm.SetFilename(filename); var dialogResult = jiraForm.ShowDialog(); if (dialogResult == DialogResult.OK) { try { surfaceToUpload.UploadUrl = _jiraPlugin.JiraConnector.JiraBaseUri.AppendSegments("browse", jiraForm.GetJiraIssue().Key).AbsoluteUri; // Run upload in the background new PleaseWaitForm().ShowAndWait(Description, Language.GetString("jira", LangKey.communication_wait), async() => { await jiraForm.UploadAsync(new SurfaceContainer(surfaceToUpload, outputSettings, filename)); } ); Log.DebugFormat("Uploaded to Jira {0}", jiraForm.GetJiraIssue().Key); exportInformation.ExportMade = true; exportInformation.Uri = surfaceToUpload.UploadUrl; } catch (Exception e) { MessageBox.Show(Language.GetString("jira", LangKey.upload_failure) + " " + e.Message); } } } ProcessExport(exportInformation, surfaceToUpload); return(exportInformation); }
public override ExportInformation ExportCapture(bool manuallyInitiated, ISurface surfaceToUpload, ICaptureDetails captureDetails) { ExportInformation exportInformation = new ExportInformation(this.Designation, this.Description); string filename = Path.GetFileName(FilenameHelper.GetFilename(config.UploadFormat, captureDetails)); SurfaceOutputSettings outputSettings = new SurfaceOutputSettings(config.UploadFormat, config.UploadJpegQuality, config.UploadReduceColors); if (jira != null) { try { // Run upload in the background new PleaseWaitForm().ShowAndWait(Description, Language.GetString("jira", LangKey.communication_wait), delegate() { jiraPlugin.JiraConnector.addAttachment(jira.Key, filename, new SurfaceContainer(surfaceToUpload, outputSettings, filename)); } ); LOG.Debug("Uploaded to Jira."); exportInformation.ExportMade = true; // TODO: This can't work: exportInformation.Uri = surfaceToUpload.UploadURL; } catch (Exception e) { MessageBox.Show(Language.GetString("jira", LangKey.upload_failure) + " " + e.Message); } } else { JiraForm jiraForm = new JiraForm(jiraPlugin.JiraConnector); if (jiraPlugin.JiraConnector.isLoggedIn) { jiraForm.setFilename(filename); DialogResult result = jiraForm.ShowDialog(); if (result == DialogResult.OK) { try { // Run upload in the background new PleaseWaitForm().ShowAndWait(Description, Language.GetString("jira", LangKey.communication_wait), delegate() { jiraForm.upload(new SurfaceContainer(surfaceToUpload, outputSettings, filename)); } ); LOG.Debug("Uploaded to Jira."); exportInformation.ExportMade = true; // TODO: This can't work: exportInformation.Uri = surfaceToUpload.UploadURL; } catch (Exception e) { MessageBox.Show(Language.GetString("jira", LangKey.upload_failure) + " " + e.Message); } } } } ProcessExport(exportInformation, surfaceToUpload); return(exportInformation); }
public override ExportInformation ExportCapture(bool manuallyInitiated, ISurface surface, ICaptureDetails captureDetails) { ExportInformation exportInformation = new ExportInformation(this.Designation, this.Description); // force password check to take place before the pages load if (!ConfluencePlugin.ConfluenceConnector.isLoggedIn) { return(exportInformation); } Page selectedPage = page; bool openPage = (page == null) && config.OpenPageAfterUpload; string filename = FilenameHelper.GetFilename(config.UploadFormat, captureDetails); if (selectedPage == null) { ConfluenceUpload confluenceUpload = new ConfluenceUpload(filename); Nullable <bool> dialogResult = confluenceUpload.ShowDialog(); if (dialogResult.HasValue && dialogResult.Value) { selectedPage = confluenceUpload.SelectedPage; if (confluenceUpload.isOpenPageSelected) { openPage = false; } filename = confluenceUpload.Filename; } } if (selectedPage != null) { string errorMessage; bool uploaded = upload(surface, selectedPage, filename, out errorMessage); if (uploaded) { if (openPage) { try { Process.Start(selectedPage.Url); } catch { } } exportInformation.ExportMade = true; exportInformation.Uri = selectedPage.Url; } else { exportInformation.ErrorMessage = errorMessage; } } ProcessExport(exportInformation, surface); return(exportInformation); }
/// <summary> /// Export the capture to Photobucket /// </summary> /// <param name="manuallyInitiated"></param> /// <param name="surface"></param> /// <param name="captureDetails"></param> /// <returns></returns> public override async Task <ExportInformation> ExportCaptureAsync(bool manuallyInitiated, ISurface surface, ICaptureDetails captureDetails) { var exportInformation = new ExportInformation(Designation, Description); var outputSettings = new SurfaceOutputSettings(_photobucketConfiguration.UploadFormat, _photobucketConfiguration.UploadJpegQuality, false); var filename = Path.GetFileName(FilenameHelper.GetFilename(_photobucketConfiguration.UploadFormat, captureDetails)); var uploaded = await UploadToPhotobucket(surface, outputSettings, filename, captureDetails.Title, _albumPath); if (uploaded != null) { exportInformation.ExportMade = true; exportInformation.Uri = uploaded.Original; } ProcessExport(exportInformation, surface); return(exportInformation); }
/// <summary> /// Upload the capture to imgur /// </summary> /// <param name="captureDetails"></param> /// <param name="image"></param> /// <param name="uploadURL">out string for the url</param> /// <returns>true if the upload succeeded</returns> public bool Upload(ICaptureDetails captureDetails, ISurface surfaceToUpload, out string uploadURL) { SurfaceOutputSettings outputSettings = new SurfaceOutputSettings(config.UploadFormat, config.UploadJpegQuality, config.UploadReduceColors); try { string filename = Path.GetFileName(FilenameHelper.GetFilename(config.UploadFormat, captureDetails)); ImgurInfo imgurInfo = null; // Run upload in the background new PleaseWaitForm().ShowAndWait("Imgur plug-in", Language.GetString("imgur", LangKey.communication_wait), delegate() { imgurInfo = ImgurUtils.UploadToImgur(surfaceToUpload, outputSettings, captureDetails.Title, filename); LOG.InfoFormat("Storing imgur upload for hash {0} and delete hash {1}", imgurInfo.Hash, imgurInfo.DeleteHash); config.ImgurUploadHistory.Add(imgurInfo.Hash, imgurInfo.DeleteHash); config.runtimeImgurHistory.Add(imgurInfo.Hash, imgurInfo); CheckHistory(); } ); // TODO: Optimize a second call for export using (Image tmpImage = surfaceToUpload.GetImageForExport()) { imgurInfo.Image = ImageHelper.CreateThumbnail(tmpImage, 90, 90); } IniConfig.Save(); uploadURL = null; try { if (config.UsePageLink) { uploadURL = imgurInfo.Page; ClipboardHelper.SetClipboardData(imgurInfo.Page); } else { uploadURL = imgurInfo.Original; ClipboardHelper.SetClipboardData(imgurInfo.Original); } } catch (Exception ex) { LOG.Error("Can't write to clipboard: ", ex); } return(true); } catch (Exception e) { LOG.Error(e); MessageBox.Show(Language.GetString("imgur", LangKey.upload_failure) + " " + e.Message); } uploadURL = null; return(false); }
public override ExportInformation ExportCapture(bool manuallyInitiated, ISurface surface, ICaptureDetails captureDetails) { ExportInformation exportInformation = new ExportInformation(this.Designation, this.Description); CoreConfiguration config = IniConfig.GetIniSection <CoreConfiguration>(); SurfaceOutputSettings outputSettings = new SurfaceOutputSettings(); string file = FilenameHelper.GetFilename(OutputFormat.png, null); string filePath = Path.Combine(config.OutputFilePath, file); using (FileStream stream = new FileStream(filePath, FileMode.Create)) { ImageOutput.SaveToStream(surface, stream, outputSettings); } exportInformation.Filepath = filePath; exportInformation.ExportMade = true; ProcessExport(exportInformation, surface); return(exportInformation); }
/// <summary> /// Upload the capture to qiniu cloud /// </summary> /// <param name="captureDetails"></param> /// <param name="surfaceToUpload">ISurface</param> /// <param name="albumPath">Path to the album</param> /// <param name="uploadUrl">out string for the url</param> /// <returns>true if the upload succeeded</returns> public bool Upload(ICaptureDetails captureDetails, ISurface surfaceToUpload, out string uploadUrl) { SurfaceOutputSettings outputSettings = new SurfaceOutputSettings(_config.UploadFormat, _config.UploadJpegQuality, _config.UploadReduceColors); try { string filename = _config.ImageNamePrefix + DateTime.Now.ToString("yyyyMMddHHmmss") + "." + _config.UploadFormat.ToString().ToLower(); Path.GetFileName(FilenameHelper.GetFilename(_config.UploadFormat, captureDetails)); string path = Directory.GetCurrentDirectory(); string fullPath = Path.Combine(path, filename); // public static void Save(ISurface surface, string fullPath, bool allowOverwrite, SurfaceOutputSettings outputSettings, bool copyPathToClipboard) // Run upload in the background MemoryStream streamoutput = new MemoryStream(); ImageOutput.SaveToStream(surfaceToUpload, streamoutput, outputSettings); new PleaseWaitForm().ShowAndWait(Attributes.Name, Language.GetString("qiniu", LangKey.communication_wait), delegate { HttpResult result = QiniuUtils.UploadFile(streamoutput, filename); } ); // This causes an exeption if the upload failed :) //Log.DebugFormat("Uploaded to qiniu page: " + qiniuInfo.Page); uploadUrl = _config.DefaultDomain + filename; string markdownURL = "![](" + uploadUrl + ")"; Clipboard.SetText(markdownURL); return(true); } catch (Exception e) { Log.Error(e); MessageBox.Show(Language.GetString("qiniu", LangKey.upload_failure) + " " + e.Message); } uploadUrl = null; return(false); }
public async Task <string> Upload(ICaptureDetails captureDetails, ISurface surface) { string uploadUrl = null; var outputSettings = new SurfaceOutputSettings(_flickrConfiguration.UploadFormat, _flickrConfiguration.UploadJpegQuality, false); try { var cancellationTokenSource = new CancellationTokenSource(); using (var pleaseWaitForm = new PleaseWaitForm("Flickr", _flickrLanguage.CommunicationWait, cancellationTokenSource)) { pleaseWaitForm.Show(); try { var filename = Path.GetFileName(FilenameHelper.GetFilename(_flickrConfiguration.UploadFormat, captureDetails)); uploadUrl = await FlickrUtils.UploadToFlickrAsync(surface, outputSettings, captureDetails.Title, filename); } finally { pleaseWaitForm.Close(); } } if (uploadUrl == null) { return(null); } if (_flickrConfiguration.AfterUploadLinkToClipBoard) { ClipboardHelper.SetClipboardData(uploadUrl); } } catch (Exception e) { Log.Error().WriteLine(e, "Error uploading."); MessageBox.Show(_flickrLanguage.UploadFailure + " " + e.Message); } return(uploadUrl); }
/// <summary> /// Upload the capture to Photobucket /// </summary> /// <param name="captureDetails"></param> /// <param name="surfaceToUpload">ISurface</param> /// <param name="uploadURL">out string for the url</param> /// <returns>true if the upload succeeded</returns> public bool Upload(ICaptureDetails captureDetails, ISurface surfaceToUpload, string albumPath, out string uploadURL) { SurfaceOutputSettings outputSettings = new SurfaceOutputSettings(config.OutputFileFormat, config.OutputFileJpegQuality, config.OutputFileAutoReduceColors); try { string filename = Path.GetFileName(FilenameHelper.GetFilename(config.OutputFileFormat, captureDetails)); PhotobucketInfo photobucketInfo = null; // Run upload in the background new PleaseWaitForm().ShowAndWait("Photobucket plug-in", Language.GetString("photobucket", LangKey.communication_wait), delegate() { photobucketInfo = PhotobucketUtils.UploadToPhotobucket(surfaceToUpload, outputSettings, albumPath, captureDetails.Title, filename); } ); // This causes an exeption if the upload failed :) LOG.DebugFormat("Uploaded to Photobucket page: " + photobucketInfo.Page); uploadURL = null; try { if (config.UsePageLink) { uploadURL = photobucketInfo.Page; Clipboard.SetText(photobucketInfo.Page); } else { uploadURL = photobucketInfo.Original; Clipboard.SetText(photobucketInfo.Original); } } catch (Exception ex) { LOG.Error("Can't write to clipboard: ", ex); } return(true); } catch (Exception e) { LOG.Error(e); MessageBox.Show(Language.GetString("photobucket", LangKey.upload_failure) + " " + e.Message); } uploadURL = null; return(false); }
/// <summary> /// This will be called when the menu item in the Editor is clicked /// </summary> private async Task <string> UploadAsync(ICaptureDetails captureDetails, ISurface surfaceToUpload, CancellationToken cancellationToken = default) { string dropboxUrl = null; var outputSettings = new SurfaceOutputSettings(_dropboxPluginConfiguration.UploadFormat, _dropboxPluginConfiguration.UploadJpegQuality, false); try { var cancellationTokenSource = new CancellationTokenSource(); using (var pleaseWaitForm = new PleaseWaitForm("Dropbox", _dropboxLanguage.CommunicationWait, cancellationTokenSource)) { pleaseWaitForm.Show(); try { var filename = Path.GetFileName(FilenameHelper.GetFilename(_dropboxPluginConfiguration.UploadFormat, captureDetails)); using (var imageStream = new MemoryStream()) { ImageOutput.SaveToStream(surfaceToUpload, imageStream, outputSettings); imageStream.Position = 0; using (var streamContent = new StreamContent(imageStream)) { streamContent.Headers.ContentType = new MediaTypeHeaderValue("image/" + outputSettings.Format); dropboxUrl = await UploadAsync(filename, streamContent, null, cancellationToken); } } } finally { pleaseWaitForm.Close(); } } } catch (Exception e) { Log.Error().WriteLine(e); MessageBox.Show(_dropboxLanguage.UploadFailure + " " + e.Message); } return(dropboxUrl); }
/// <summary> /// Upload the capture to FogBugz /// </summary> /// <returns>true if the upload succeeded</returns> public bool Upload(ICaptureDetails captureDetails, ISurface surfaceToUpload) { SurfaceOutputSettings outputSettings = new SurfaceOutputSettings(OutputFormat.jpg, 90, false); using (MemoryStream stream = new MemoryStream()) { surfaceToUpload.GetImageForExport().Save(stream, System.Drawing.Imaging.ImageFormat.Jpeg); try { string filename = Path.GetFileName(FilenameHelper.GetFilename(OutputFormat.jpg, captureDetails)); CaseSearchForm caseSearchForm = new CaseSearchForm(config, this.host, filename, captureDetails, stream); if (caseSearchForm.ShowDialog() == DialogResult.OK) { IniConfig.Save(); return(true); } } catch (Exception e) { MessageBox.Show(Language.GetString("fogbugz", LangKey.upload_failure) + " " + e.Message); } } return(false); }
/// <summary> /// /// </summary> /// <param name="surface"></param> /// <param name="progress"></param> /// <param name="token"></param> /// <returns></returns> public async Task <string> UploadToPicasa(ISurface surface, IProgress <int> progress = null, CancellationToken token = default) { string filename = Path.GetFileName(FilenameHelper.GetFilename(_googlePhotosConfiguration.UploadFormat, surface.CaptureDetails)); var outputSettings = new SurfaceOutputSettings(_googlePhotosConfiguration.UploadFormat, _googlePhotosConfiguration.UploadJpegQuality); // Fill the OAuth2Settings var oAuthHttpBehaviour = HttpBehaviour.Current.ShallowClone(); // Use UploadProgress if (progress != null) { oAuthHttpBehaviour.UploadProgress = percent => { UiContext.RunOn(() => progress.Report((int)(percent * 100))); }; } oAuthHttpBehaviour.OnHttpMessageHandlerCreated = httpMessageHandler => new OAuth2HttpMessageHandler(_oAuth2Settings, oAuthHttpBehaviour, httpMessageHandler); if (_googlePhotosConfiguration.AddFilename) { oAuthHttpBehaviour.OnHttpClientCreated = httpClient => httpClient.AddDefaultRequestHeader("Slug", Uri.EscapeDataString(filename)); } string response; var uploadUri = new Uri("https://picasaweb.google.com/data/feed/api/user").AppendSegments(_googlePhotosConfiguration.UploadUser, "albumid", _googlePhotosConfiguration.UploadAlbum); using (var imageStream = new MemoryStream()) { ImageOutput.SaveToStream(surface, imageStream, outputSettings); imageStream.Position = 0; using (var content = new StreamContent(imageStream)) { content.Headers.Add("Content-Type", "image/" + outputSettings.Format); oAuthHttpBehaviour.MakeCurrent(); response = await uploadUri.PostAsync <string>(content, token); } } return(ParseResponse(response)); }
public override ExportInformation ExportCapture(bool manuallyInitiated, ISurface surface, ICaptureDetails captureDetails) { var exportInformation = new ExportInformation(this.Designation, this.Description); string filename = Path.GetFileName(FilenameHelper.GetFilename(config.UploadFormat, captureDetails)); var outputSettings = new SurfaceOutputSettings(config.UploadFormat, config.UploadJpegQuality, config.UploadReduceColors); try { // Run upload in the background new PleaseWaitForm().ShowAndWait(Description, "Uploading", delegate() { demoPlugin.DemoConnector.AddAttachment(filename, new SurfaceContainer(surface, outputSettings, filename)); } ); LOG.Debug("Uploaded to Jira."); exportInformation.ExportMade = true; } catch (Exception e) { MessageBox.Show("Upload failure"); } return(exportInformation); }
protected override ExportInformation ExportCapture(bool manuallyInitiated, ISurface surface, ICaptureDetails captureDetails) { var exportInformation = new ExportInformation(Designation, Description); var filename = Path.GetFileName(FilenameHelper.GetFilename(_jiraConfiguration.UploadFormat, captureDetails)); var outputSettings = new SurfaceOutputSettings(_jiraConfiguration.UploadFormat, _jiraConfiguration.UploadJpegQuality, _jiraConfiguration.UploadReduceColors); if (_jiraIssue != null) { try { // Run upload in the background new PleaseWaitForm().ShowAndWait(Description, Language.GetString("jira", LangKey.communication_wait), async() => { var surfaceContainer = new SurfaceContainer(surface, outputSettings, filename); await _jiraConnector.AttachAsync(_jiraIssue.Key, surfaceContainer); surface.UploadUrl = _jiraConnector.JiraBaseUri.AppendSegments("browse", _jiraIssue.Key).AbsoluteUri; } ); Log.Debug().WriteLine("Uploaded to Jira {0}", _jiraIssue.Key); exportInformation.ExportMade = true; exportInformation.Uri = surface.UploadUrl; } catch (Exception e) { MessageBox.Show(Language.GetString("jira", LangKey.upload_failure) + " " + e.Message); } } else { // TODO: set filename // _jiraViewModel.SetFilename(filename); if (_windowManager.ShowDialog(_jiraViewModel) == true) { try { surface.UploadUrl = _jiraConnector.JiraBaseUri.AppendSegments("browse", _jiraViewModel.JiraIssue.Key).AbsoluteUri; // Run upload in the background new PleaseWaitForm().ShowAndWait(Description, Language.GetString("jira", LangKey.communication_wait), async() => { var attachment = new SurfaceContainer(surface, outputSettings, _jiraViewModel.Filename); await _jiraConnector.AttachAsync(_jiraViewModel.JiraIssue.Key, attachment); if (!string.IsNullOrEmpty(_jiraViewModel.Comment)) { await _jiraConnector.AddCommentAsync(_jiraViewModel.JiraIssue.Key, _jiraViewModel.Comment); } } ); Log.Debug().WriteLine("Uploaded to Jira {0}", _jiraViewModel.JiraIssue.Key); exportInformation.ExportMade = true; exportInformation.Uri = surface.UploadUrl; } catch (Exception e) { MessageBox.Show(Language.GetString("jira", LangKey.upload_failure) + " " + e.Message); } } } ProcessExport(exportInformation, surface); return(exportInformation); }
/// <summary> /// Share the surface by using the Share-UI of Windows 10 /// </summary> /// <param name="shareInfo">ShareInfo</param> /// <param name="handle">IntPtr with the handle for the hosting window</param> /// <param name="surface">ISurface with the bitmap to share</param> /// <param name="captureDetails">ICaptureDetails</param> /// <returns>Task with string, which describes the application which was used to share with</returns> private async Task Share(ShareInfo shareInfo, IntPtr handle, ISurface surface, ICaptureDetails captureDetails) { using (var imageStream = new MemoryRandomAccessStream()) using (var logoStream = new MemoryRandomAccessStream()) using (var thumbnailStream = new MemoryRandomAccessStream()) { var outputSettings = new SurfaceOutputSettings(); outputSettings.PreventGreenshotFormat(); // Create capture for export ImageOutput.SaveToStream(surface, imageStream, outputSettings); imageStream.Position = 0; Log.Debug().WriteLine("Created RandomAccessStreamReference for the image"); var imageRandomAccessStreamReference = RandomAccessStreamReference.CreateFromStream(imageStream); // Create thumbnail RandomAccessStreamReference thumbnailRandomAccessStreamReference; using (var tmpImageForThumbnail = surface.GetBitmapForExport()) using (var thumbnail = tmpImageForThumbnail.CreateThumbnail(240, 160)) { ImageOutput.SaveToStream(thumbnail, null, thumbnailStream, outputSettings); thumbnailStream.Position = 0; thumbnailRandomAccessStreamReference = RandomAccessStreamReference.CreateFromStream(thumbnailStream); Log.Debug().WriteLine("Created RandomAccessStreamReference for the thumbnail"); } // Create logo RandomAccessStreamReference logoRandomAccessStreamReference; using (var logo = GreenshotResources.GetGreenshotIcon().ToBitmap()) using (var logoThumbnail = logo.CreateThumbnail(30, 30)) { ImageOutput.SaveToStream(logoThumbnail, null, logoStream, outputSettings); logoStream.Position = 0; logoRandomAccessStreamReference = RandomAccessStreamReference.CreateFromStream(logoStream); Log.Info().WriteLine("Created RandomAccessStreamReference for the logo"); } var dataTransferManagerHelper = new DataTransferManagerHelper(handle); dataTransferManagerHelper.DataTransferManager.ShareProvidersRequested += (sender, args) => { shareInfo.AreShareProvidersRequested = true; Log.Debug().WriteLine("Share providers requested: {0}", string.Join(",", args.Providers.Select(p => p.Title))); }; dataTransferManagerHelper.DataTransferManager.TargetApplicationChosen += (dtm, args) => { shareInfo.ApplicationName = args.ApplicationName; Log.Debug().WriteLine("TargetApplicationChosen: {0}", args.ApplicationName); }; var filename = FilenameHelper.GetFilename(OutputFormats.png, captureDetails); var storageFile = await StorageFile.CreateStreamedFileAsync(filename, async streamedFileDataRequest => { shareInfo.IsDeferredFileCreated = true; // Information on the "how" was found here: https://socialeboladev.wordpress.com/2013/03/15/how-to-use-createstreamedfileasync/ Log.Debug().WriteLine("Creating deferred file {0}", filename); try { using (var deferredStream = streamedFileDataRequest.AsStreamForWrite()) { await imageStream.CopyToAsync(deferredStream).ConfigureAwait(false); await imageStream.FlushAsync().ConfigureAwait(false); } // Signal that the stream is ready streamedFileDataRequest.Dispose(); } catch (Exception) { streamedFileDataRequest.FailAndClose(StreamedFileFailureMode.Incomplete); } }, imageRandomAccessStreamReference).AsTask().ConfigureAwait(false); dataTransferManagerHelper.DataTransferManager.DataRequested += (dataTransferManager, dataRequestedEventArgs) => { var deferral = dataRequestedEventArgs.Request.GetDeferral(); try { shareInfo.IsDataRequested = true; Log.Debug().WriteLine("DataRequested with operation {0}", dataRequestedEventArgs.Request.Data.RequestedOperation); var dataPackage = dataRequestedEventArgs.Request.Data; dataPackage.OperationCompleted += (dp, eventArgs) => { Log.Debug().WriteLine("OperationCompleted: {0}, shared with", eventArgs.Operation); shareInfo.CompletedWithOperation = eventArgs.Operation; shareInfo.AcceptedFormat = eventArgs.AcceptedFormatId; shareInfo.ShareTask.TrySetResult(true); }; dataPackage.Destroyed += (dp, o) => { shareInfo.IsDestroyed = true; Log.Debug().WriteLine("Destroyed"); shareInfo.ShareTask.TrySetResult(true); }; dataPackage.ShareCompleted += (dp, shareCompletedEventArgs) => { shareInfo.IsShareCompleted = true; Log.Debug().WriteLine("ShareCompleted"); shareInfo.ShareTask.TrySetResult(true); }; dataPackage.Properties.Title = captureDetails.Title; dataPackage.Properties.ApplicationName = "Greenshot"; dataPackage.Properties.Description = "Share a screenshot"; dataPackage.Properties.Thumbnail = thumbnailRandomAccessStreamReference; dataPackage.Properties.Square30x30Logo = logoRandomAccessStreamReference; dataPackage.Properties.LogoBackgroundColor = Color.FromArgb(0xff, 0x3d, 0x3d, 0x3d); dataPackage.SetStorageItems(new[] { storageFile }); dataPackage.SetBitmap(imageRandomAccessStreamReference); } finally { deferral.Complete(); Log.Debug().WriteLine("Called deferral.Complete()"); } }; dataTransferManagerHelper.ShowShareUi(); Log.Debug().WriteLine("ShowShareUi finished."); await shareInfo.ShareTask.Task.ConfigureAwait(false); } }
/// <summary> /// Share the screenshot with a windows app /// </summary> /// <param name="manuallyInitiated"></param> /// <param name="surface"></param> /// <param name="captureDetails"></param> /// <returns>ExportInformation</returns> public override ExportInformation ExportCapture(bool manuallyInitiated, ISurface surface, ICaptureDetails captureDetails) { var exportInformation = new ExportInformation(Designation, Description); try { var handle = PluginUtils.Host.GreenshotForm.Handle; var exportTarget = Task.Run(async() => { var taskCompletionSource = new TaskCompletionSource <string>(); using (var imageStream = new MemoryRandomAccessStream()) using (var logoStream = new MemoryRandomAccessStream()) using (var thumbnailStream = new MemoryRandomAccessStream()) { var outputSettings = new SurfaceOutputSettings(); outputSettings.PreventGreenshotFormat(); // Create capture for export ImageOutput.SaveToStream(surface, imageStream, outputSettings); imageStream.Position = 0; Log.Info("Created RandomAccessStreamReference for the image"); var imageRandomAccessStreamReference = RandomAccessStreamReference.CreateFromStream(imageStream); RandomAccessStreamReference thumbnailRandomAccessStreamReference; RandomAccessStreamReference logoRandomAccessStreamReference; // Create thumbnail using (var tmpImageForThumbnail = surface.GetImageForExport()) { using (var thumbnail = ImageHelper.CreateThumbnail(tmpImageForThumbnail, 240, 160)) { ImageOutput.SaveToStream(thumbnail, null, thumbnailStream, outputSettings); thumbnailStream.Position = 0; thumbnailRandomAccessStreamReference = RandomAccessStreamReference.CreateFromStream(thumbnailStream); Log.Info("Created RandomAccessStreamReference for the thumbnail"); } } // Create logo using (var logo = GreenshotResources.getGreenshotIcon().ToBitmap()) { using (var logoThumbnail = ImageHelper.CreateThumbnail(logo, 30, 30)) { ImageOutput.SaveToStream(logoThumbnail, null, logoStream, outputSettings); logoStream.Position = 0; logoRandomAccessStreamReference = RandomAccessStreamReference.CreateFromStream(logoStream); Log.Info("Created RandomAccessStreamReference for the logo"); } } string applicationName = null; var dataTransferManagerHelper = new DataTransferManagerHelper(handle); dataTransferManagerHelper.DataTransferManager.TargetApplicationChosen += (dtm, args) => { Log.InfoFormat("Trying to share with {0}", args.ApplicationName); applicationName = args.ApplicationName; }; var filename = FilenameHelper.GetFilename(OutputFormat.png, captureDetails); var storageFile = await StorageFile.CreateStreamedFileAsync(filename, async streamedFileDataRequest => { // Information on how was found here: https://socialeboladev.wordpress.com/2013/03/15/how-to-use-createstreamedfileasync/ Log.DebugFormat("Creating deferred file {0}", filename); try { using (var deferredStream = streamedFileDataRequest.AsStreamForWrite()) { await imageStream.CopyToAsync(deferredStream).ConfigureAwait(false); await imageStream.FlushAsync().ConfigureAwait(false); } // Signal that the stream is ready streamedFileDataRequest.Dispose(); } catch (Exception) { streamedFileDataRequest.FailAndClose(StreamedFileFailureMode.Incomplete); } // Signal transfer ready to the await down below taskCompletionSource.TrySetResult(applicationName); }, imageRandomAccessStreamReference).AsTask().ConfigureAwait(false); dataTransferManagerHelper.DataTransferManager.DataRequested += (sender, args) => { var deferral = args.Request.GetDeferral(); args.Request.Data.OperationCompleted += (dp, eventArgs) => { Log.DebugFormat("OperationCompleted: {0}, shared with", eventArgs.Operation); taskCompletionSource.TrySetResult(applicationName); }; var dataPackage = args.Request.Data; dataPackage.Properties.Title = captureDetails.Title; dataPackage.Properties.ApplicationName = "Greenshot"; dataPackage.Properties.Description = "Share a screenshot"; dataPackage.Properties.Thumbnail = thumbnailRandomAccessStreamReference; dataPackage.Properties.Square30x30Logo = logoRandomAccessStreamReference; dataPackage.Properties.LogoBackgroundColor = Color.FromArgb(0xff, 0x3d, 0x3d, 0x3d); dataPackage.SetStorageItems(new List <IStorageItem> { storageFile }); dataPackage.SetBitmap(imageRandomAccessStreamReference); dataPackage.Destroyed += (dp, o) => { Log.Debug("Destroyed."); }; deferral.Complete(); }; dataTransferManagerHelper.ShowShareUi(); return(await taskCompletionSource.Task.ConfigureAwait(false)); } }).Result; if (string.IsNullOrWhiteSpace(exportTarget)) { exportInformation.ExportMade = false; } else { exportInformation.ExportMade = true; exportInformation.DestinationDescription = exportTarget; } } catch (Exception ex) { exportInformation.ExportMade = false; exportInformation.ErrorMessage = ex.Message; } ProcessExport(exportInformation, surface); return(exportInformation); }
public bool Upload(ICaptureDetails captureDetails, Image image) { using (MemoryStream stream = new MemoryStream()) { SurfaceOutputSettings outputSettings = new SurfaceOutputSettings { Format = config.UploadFormat, JPGQuality = config.UploadJpegQuality }; ImageOutput.SaveToStream(image, null, stream, outputSettings); byte[] buffer = stream.GetBuffer(); try { string filename = Path.GetFileName(FilenameHelper.GetFilename(config.UploadFormat, captureDetails)); string contentType = $"image/{config.UploadFormat}"; TFSInfo tfsInfo = TFSUtils.UploadToTFS(buffer, captureDetails.DateTime.ToString(CultureInfo.CurrentCulture), filename, contentType); if (tfsInfo == null) { return(false); } else { if (config.TfsUploadHistory == null) { config.TfsUploadHistory = new Dictionary <string, string>(); } if (tfsInfo.ID != null) { LOG.InfoFormat("Storing TFS upload for id {0}", tfsInfo.ID); config.TfsUploadHistory.Add(tfsInfo.ID, tfsInfo.ID); config.runtimeTfsHistory.Add(tfsInfo.ID, tfsInfo); } // Make sure the configuration is save, so we don't lose the deleteHash IniConfig.Save(); // Make sure the history is loaded, will be done only once TFSUtils.LoadHistory(); // Show if (config.AfterUploadOpenHistory) { TFSHistory.ShowHistory(); } if (config.AfterUploadLinkToClipBoard && !string.IsNullOrEmpty(tfsInfo.WebEditUrl)) { Clipboard.SetText(tfsInfo.WebEditUrl); } if (config.AfterUploadOpenWorkItem && !string.IsNullOrEmpty(tfsInfo.WebEditUrl)) { System.Diagnostics.Process.Start(tfsInfo.WebEditUrl); } return(true); } } catch (Exception e) { MessageBox.Show(Language.GetString("tfs", $"{LangKey.upload_failure} {e}")); } finally { //backgroundForm.CloseDialog(); } } return(false); }
/// <summary> /// Do the actual upload to Box /// For more details on the available parameters, see: /// http://developers.box.net/w/page/12923951/ApiFunction_Upload%20and%20Download /// </summary> /// <param name="surface">ICapture</param> /// <param name="progress">IProgress</param> /// <param name="cancellationToken">CancellationToken</param> /// <returns>url to uploaded image</returns> public async Task <string> UploadToBoxAsync(ICaptureDetails captureDetails, ISurface surface, IProgress <int> progress = null, CancellationToken cancellationToken = default) { string filename = Path.GetFileName(FilenameHelper.GetFilename(_boxConfiguration.UploadFormat, captureDetails)); var outputSettings = new SurfaceOutputSettings(_boxConfiguration.UploadFormat, _boxConfiguration.UploadJpegQuality, false); var oauthHttpBehaviour = HttpBehaviour.Current.ShallowClone(); // Use UploadProgress if (progress != null) { oauthHttpBehaviour.UploadProgress = percent => { UiContext.RunOn(() => progress.Report((int)(percent * 100))); }; } oauthHttpBehaviour.OnHttpMessageHandlerCreated = httpMessageHandler => new OAuth2HttpMessageHandler(_oauth2Settings, oauthHttpBehaviour, httpMessageHandler); // TODO: See if the PostAsync<Bitmap> can be used? Or at least the HttpContentFactory? using (var imageStream = new MemoryStream()) { var multiPartContent = new MultipartFormDataContent(); var parentIdContent = new StringContent(_boxConfiguration.FolderId); parentIdContent.Headers.ContentDisposition = new ContentDispositionHeaderValue("form-data") { Name = "\"parent_id\"" }; multiPartContent.Add(parentIdContent); ImageOutput.SaveToStream(surface, imageStream, outputSettings); imageStream.Position = 0; BoxFile response; using (var streamContent = new StreamContent(imageStream)) { streamContent.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream"); //"image/" + outputSettings.Format); streamContent.Headers.ContentDisposition = new ContentDispositionHeaderValue("form-data") { Name = "\"file\"", FileName = "\"" + filename + "\"" }; // the extra quotes are important here multiPartContent.Add(streamContent); oauthHttpBehaviour.MakeCurrent(); response = await UploadFileUri.PostAsync <BoxFile>(multiPartContent, cancellationToken); } if (response == null) { return(null); } if (_boxConfiguration.UseSharedLink) { if (response.SharedLink?.Url == null) { var uriForSharedLink = FilesUri.AppendSegments(response.Id); var updateAccess = new { shared_link = new { access = "open" } }; oauthHttpBehaviour.MakeCurrent(); response = await uriForSharedLink.PostAsync <BoxFile>(updateAccess, cancellationToken); } return(response.SharedLink.Url); } return($"http://www.box.com/files/0/f/0/1/f_{response.Id}"); } }