/// <summary>
/// Do the actual upload to OneDrive
/// </summary>
/// <param name="oAuth2Settings">OAuth2Settings</param>
/// <param name="surfaceToUpload">ISurface to upload</param>
/// <param name="outputSettings">OutputSettings for the image file format</param>
/// <param name="title">Title</param>
/// <param name="filename">Filename</param>
/// <param name="progress">IProgress</param>
/// <param name="token">CancellationToken</param>
/// <returns>ImgurInfo with details</returns>
public static async Task <OneDriveUploadResponse> UploadToOneDriveAsync(OAuth2Settings oAuth2Settings, ISurface surfaceToUpload,
SurfaceOutputSettings outputSettings, string title, string filename, IProgress <int> progress = null,
CancellationToken token = default)
{
var uploadUri = new Uri(UrlUtils.GetUploadUrl(filename));
var localBehaviour = Behaviour.ShallowClone();
if (progress != null)
{
localBehaviour.UploadProgress = percent => { UiContext.RunOn(() => progress.Report((int)(percent * 100)), token); };
}
var oauthHttpBehaviour = OAuth2HttpBehaviourFactory.Create(oAuth2Settings, localBehaviour);
using (var imageStream = new MemoryStream())
{
ImageOutput.SaveToStream(surfaceToUpload, imageStream, outputSettings);
imageStream.Position = 0;
using (var content = new StreamContent(imageStream))
{
content.Headers.Add("Content-Type", "image/" + outputSettings.Format);
oauthHttpBehaviour.MakeCurrent();
return(await uploadUri.PostAsync <OneDriveUploadResponse>(content, token));
}
}
}
/// <summary>
/// Export the capture to outlook
/// </summary>
/// <param name="manuallyInitiated"></param>
/// <param name="surface"></param>
/// <param name="captureDetails"></param>
/// <returns></returns>
public override ExportInformation ExportCapture(bool manuallyInitiated, ISurface surface, ICaptureDetails captureDetails)
{
ExportInformation exportInformation = new ExportInformation(this.Designation, this.Description);
// Outlook logic
string tmpFile = captureDetails.Filename;
if (tmpFile == null || surface.Modified || !Regex.IsMatch(tmpFile, @".*(\.png|\.gif|\.jpg|\.jpeg|\.tiff|\.bmp)$"))
{
tmpFile = ImageOutput.SaveNamedTmpFile(surface, captureDetails, new SurfaceOutputSettings().PreventGreenshotFormat());
}
else
{
LOG.InfoFormat("Using already available file: {0}", tmpFile);
}
// Create a attachment name for the image
string attachmentName = captureDetails.Title;
if (!string.IsNullOrEmpty(attachmentName))
{
attachmentName = attachmentName.Trim();
}
// Set default if non is set
if (string.IsNullOrEmpty(attachmentName))
{
attachmentName = "Greenshot Capture";
}
// Make sure it's "clean" so it doesn't corrupt the header
attachmentName = Regex.Replace(attachmentName, @"[^\x20\d\w]", "");
if (outlookInspectorCaption != null)
{
OutlookEmailExporter.ExportToInspector(outlookInspectorCaption, tmpFile, attachmentName);
exportInformation.ExportMade = true;
}
else
{
if (!manuallyInitiated)
{
IDictionary <string, OlObjectClass> inspectorCaptions = OutlookEmailExporter.RetrievePossibleTargets();
if (inspectorCaptions != null && inspectorCaptions.Count > 0)
{
List <IDestination> destinations = new List <IDestination>();
destinations.Add(new OutlookDestination());
foreach (string inspectorCaption in inspectorCaptions.Keys)
{
destinations.Add(new OutlookDestination(inspectorCaption, inspectorCaptions[inspectorCaption]));
}
// Return the ExportInformation from the picker without processing, as this indirectly comes from us self
return(ShowPickerMenu(false, surface, captureDetails, destinations));
}
}
else
{
exportInformation.ExportMade = OutlookEmailExporter.ExportToOutlook(conf.OutlookEmailFormat, tmpFile, FilenameHelper.FillPattern(conf.EmailSubjectPattern, captureDetails, false), attachmentName, conf.EmailTo, conf.EmailCC, conf.EmailBCC, null);
}
}
ProcessExport(exportInformation, surface);
return(exportInformation);
}
/// <summary>
/// Export the capture to the specified page
/// </summary>
/// <param name="oneNoteApplication">IOneNoteApplication</param>
/// <param name="surfaceToUpload">ISurface</param>
/// <param name="page">OneNotePage</param>
/// <returns>bool true if everything worked</returns>
private static bool ExportToPage(IOneNoteApplication oneNoteApplication, ISurface surfaceToUpload, OneNotePage page)
{
if (oneNoteApplication == null)
{
return(false);
}
using (var pngStream = new MemoryStream())
{
var pngOutputSettings = new SurfaceOutputSettings(OutputFormats.png, 100, false);
ImageOutput.SaveToStream(surfaceToUpload, pngStream, pngOutputSettings);
var base64String = Convert.ToBase64String(pngStream.GetBuffer());
var imageXmlStr = string.Format(XmlImageContent, base64String, surfaceToUpload.Screenshot.Width, surfaceToUpload.Screenshot.Height);
var pageChangesXml = string.Format(XmlOutline, imageXmlStr, page.ID, OnenoteNamespace2010, page.Name);
Log.Info().WriteLine("Sending XML: {0}", pageChangesXml);
oneNoteApplication.UpdatePageContent(pageChangesXml, DateTime.MinValue, XMLSchema.xs2010, false);
try
{
oneNoteApplication.NavigateTo(page.ID, null, false);
}
catch (Exception ex)
{
Log.Warn().WriteLine(ex, "Unable to navigate to the target page");
}
return(true);
}
}
public override ExportInformation ExportCapture(bool manuallyInitiated, ISurface surface, ICaptureDetails captureDetails)
{
ExportInformation exportInformation = new ExportInformation(Designation, Description);
bool outputMade;
bool overwrite;
string fullPath;
// Get output settings from the configuration
SurfaceOutputSettings outputSettings = new SurfaceOutputSettings();
if (captureDetails != null && captureDetails.Filename != null)
{
// As we save a pre-selected file, allow to overwrite.
overwrite = true;
LOG.InfoFormat("Using previous filename");
fullPath = captureDetails.Filename;
outputSettings.Format = ImageOutput.FormatForFilename(fullPath);
}
else
{
fullPath = CreateNewFilename(captureDetails);
// As we generate a file, the configuration tells us if we allow to overwrite
overwrite = conf.OutputFileAllowOverwrite;
}
if (conf.OutputFilePromptQuality)
{
QualityDialog qualityDialog = new QualityDialog(outputSettings);
qualityDialog.ShowDialog();
}
// Catching any exception to prevent that the user can't write in the directory.
// This is done for e.g. bugs #2974608, #2963943, #2816163, #2795317, #2789218, #3004642
try {
ImageOutput.Save(surface, fullPath, overwrite, outputSettings, conf.OutputFileCopyPathToClipboard);
outputMade = true;
} catch (ArgumentException ex1) {
// Our generated filename exists, display 'save-as'
LOG.InfoFormat("Not overwriting: {0}", ex1.Message);
// when we don't allow to overwrite present a new SaveWithDialog
fullPath = ImageOutput.SaveWithDialog(surface, captureDetails);
outputMade = (fullPath != null);
} catch (Exception ex2) {
LOG.Error("Error saving screenshot!", ex2);
// Show the problem
MessageBox.Show(Language.GetString(LangKey.error_save), Language.GetString(LangKey.error));
// when save failed we present a SaveWithDialog
fullPath = ImageOutput.SaveWithDialog(surface, captureDetails);
outputMade = (fullPath != null);
}
// Don't overwrite filename if no output is made
if (outputMade)
{
exportInformation.ExportMade = outputMade;
exportInformation.Filepath = fullPath;
captureDetails.Filename = fullPath;
conf.OutputFileAsFullpath = fullPath;
}
ProcessExport(exportInformation, surface);
return(exportInformation);
}
public override ExportInformation ExportCapture(bool manuallyInitiated, ISurface surface, ICaptureDetails captureDetails)
{
ExportInformation exportInformation = new ExportInformation(this.Designation, this.Description);
string tmpFile = captureDetails.Filename;
if (tmpFile == null || surface.Modified || !Regex.IsMatch(tmpFile, @".*(\.png|\.gif|\.jpg|\.jpeg|\.tiff|\.bmp)$"))
{
tmpFile = ImageOutput.SaveNamedTmpFile(surface, captureDetails, new SurfaceOutputSettings().PreventGreenshotFormat());
}
if (documentCaption != null)
{
try {
WordExporter.InsertIntoExistingDocument(documentCaption, tmpFile);
exportInformation.ExportMade = true;
} catch (Exception) {
try {
WordExporter.InsertIntoExistingDocument(documentCaption, tmpFile);
exportInformation.ExportMade = true;
} catch (Exception ex) {
LOG.Error(ex);
// TODO: Change to general logic in ProcessExport
surface.SendMessageEvent(this, SurfaceMessageTyp.Error, Language.GetFormattedString("destination_exportfailed", Description));
}
}
}
else
{
if (!manuallyInitiated)
{
List <string> documents = WordExporter.GetWordDocuments();
if (documents != null && documents.Count > 0)
{
List <IDestination> destinations = new List <IDestination>();
destinations.Add(new WordDestination());
foreach (string document in documents)
{
destinations.Add(new WordDestination(document));
}
// Return the ExportInformation from the picker without processing, as this indirectly comes from us self
return(ShowPickerMenu(false, surface, captureDetails, destinations));
}
}
try {
WordExporter.InsertIntoNewDocument(tmpFile, null, null);
exportInformation.ExportMade = true;
} catch (Exception) {
// Retry once, just in case
try {
WordExporter.InsertIntoNewDocument(tmpFile, null, null);
exportInformation.ExportMade = true;
} catch (Exception ex) {
LOG.Error(ex);
// TODO: Change to general logic in ProcessExport
surface.SendMessageEvent(this, SurfaceMessageTyp.Error, Language.GetFormattedString("destination_exportfailed", Description));
}
}
}
ProcessExport(exportInformation, surface);
return(exportInformation);
}
public override ExportInformation ExportCapture(bool manuallyInitiated, ISurface surface, ICaptureDetails captureDetails)
{
base.SetDefaults(surface);
ExportInformation exportInformation = new ExportInformation(Designation, Description);
bool createdFile = false;
string imageFile = captureDetails.Filename;
if (imageFile == null || surface.Modified || !Regex.IsMatch(imageFile, @".*(\.png|\.gif|\.jpg|\.jpeg|\.tiff|\.bmp)$"))
{
imageFile = ImageOutput.SaveNamedTmpFile(surface, captureDetails, new SurfaceOutputSettings().PreventGreenshotFormat());
createdFile = true;
}
if (_workbookName != null)
{
ExcelExporter.InsertIntoExistingWorkbook(_workbookName, imageFile, surface.Image.Size);
}
else
{
ExcelExporter.InsertIntoNewWorkbook(imageFile, surface.Image.Size);
}
exportInformation.ExportMade = true;
ProcessExport(exportInformation, surface);
// Cleanup imageFile if we created it here, so less tmp-files are generated and left
if (createdFile)
{
ImageOutput.DeleteNamedTmpFile(imageFile);
}
return(exportInformation);
}
static ImageOutput[] TransformToCubeFaces(byte[] srcStream, int width, int height)
{
List <ImageOutput> imageOutputs = new List <ImageOutput>();
for (int i = 0; i <= 5; i++)
{
ImageOutput imageOutPut = new ImageOutput
{
Height = outWidth,
Width = outWidth,
Data = new byte[4 * outWidth * outWidth],
};
imageOutputs.Add(imageOutPut);
}
imageOutputs.ToArray();
List <ImageOutput> listOutPut = new List <ImageOutput>();
for (int i = 0; i < 6; i++)
{
ImageOutput result = ConvertToCubeFaces(width, height, srcStream, imageOutputs[i], i);
listOutPut.Add(result);
}
return(listOutPut.ToArray());
}
public static ImageOutput loadByUsingImageSharp(string imageName)
{
var image = Image.Load <Rgba32>(imageName);
var imgOut = new ImageOutput();
Console.WriteLine("image.Metadata" + image.Metadata.ToString());
imgOut.Width = image.Width;
imgOut.Height = image.Height;
imgOut.Data = MemoryMarshal.AsBytes(image.GetPixelSpan()).ToArray();
Console.WriteLine("rgbaBytes " + imgOut.Data.Length);
return(imgOut);
// using (var image = Image.Load<Rgba32>(imageName, out format))
// {
// Console.WriteLine(image.Width + " " + image.Height);
// // using (var ms = new MemoryStream())
// // {
// // image.Save(ms, format);
// // var buff = ms.ToArray();
// // Console.WriteLine(format);
// // Console.WriteLine(buff.Length);
// // }
// return image;
// }
}
public async Task <IActionResult> UploadImage(IFormFile file, [FromForm] string name, [FromForm] string tags)
{
if (file == null)
{
file = Request.Form.Files[0];
}
ImageOutput output = new ImageOutput();
if (file != null)
{
if (file.Length > 0)
{
//验证是否是图片
if (ImageValidation.IsCheck(file))
{
ImageInput input = new ImageInput();
input.File = file;
input.Name = name;
input.Tags = tags;
ImageHandleService handleService = new ImageHandleService();
//处理图片
output = await handleService.Processing(input, Request);
return(Ok(output));
}
}
}
return(BadRequest("图片上传失败！"));
}
public static string SaveImage(Image img)
{
if (img != null)
{
return(ImageOutput.SaveWithDialog(img));
}
return(string.Empty);
}
/// <summary>
/// Place the bitmap as HTML on the clipboard
/// </summary>
/// <param name="clipboardAccessToken">IClipboardAccessToken</param>
/// <param name="surface">ISurface</param>
public static void SetAsHtml(this IClipboardAccessToken clipboardAccessToken, ISurface surface)
{
var pngOutputSettings = new SurfaceOutputSettings(OutputFormats.png, 100, false);
// This file is automatically deleted when Greenshot exits.
var filename = ImageOutput.SaveNamedTmpFile(surface, surface.CaptureDetails, pngOutputSettings);
// Set the PNG stream
var htmlText = GenerateHtmlString(new NativeSize(surface.Width, surface.Height), filename);
clipboardAccessToken.SetAsHtml(htmlText);
}
private void CopyMainImages(IEnumerable <Entity> entities, string inputPath, string outputPath)
{
//build the mod input list
var inputDirectories = StellarisDirectoryHelper
.CreateCombinedList(StellarisDirectoryHelper, modDirectoryHelpers, Last)
.Select(x => Path.Combine(x.Icons, inputPath)).ToList();
// tech images
ImageOutput.TransformAndOutputImages(inputDirectories, Path.Combine(outputRoot, outputPath), entities);
}
/// <summary>
/// Place the bitmap on the clipboard
/// </summary>
/// <param name="clipboardAccessToken">IClipboardAccessToken</param>
/// <param name="surface">ISurface</param>
/// <param name="outputSettings">SurfaceOutputSettings specifying how to output the surface</param>
public static void SetAsBitmap(this IClipboardAccessToken clipboardAccessToken, ISurface surface, SurfaceOutputSettings outputSettings)
{
using (var bitmapStream = new MemoryStream())
{
ImageOutput.SaveToStream(surface, bitmapStream, outputSettings);
bitmapStream.Seek(0, SeekOrigin.Begin);
// Set the stream
var clipboardFormat = ClipboardFormatExtensions.MapFormatToId(outputSettings.Format.ToString().ToUpperInvariant());
clipboardAccessToken.SetAsStream(clipboardFormat, bitmapStream);
}
}
/// <summary>
/// Place the bitmap as embedded HTML on the clipboard
/// </summary>
/// <param name="clipboardAccessToken">IClipboardAccessToken</param>
/// <param name="surface">ISurface</param>
public static void SetAsEmbeddedHtml(this IClipboardAccessToken clipboardAccessToken, ISurface surface)
{
using (var pngStream = new MemoryStream())
{
var pngOutputSettings = new SurfaceOutputSettings(OutputFormats.png, 100, false);
ImageOutput.SaveToStream(surface, pngStream, pngOutputSettings);
pngStream.Seek(0, SeekOrigin.Begin);
// Set the PNG stream
var htmlText = GenerateHtmlDataUrlString(new NativeSize(surface.Width, surface.Height), pngStream);
clipboardAccessToken.SetAsHtml(htmlText);
}
}
void SaveToolStripMenuItemClick(object sender, System.EventArgs e)
{
try
{
ImageOutput.Save(surface.GetImageForExport(), lastSaveFullPath);
updateStatusLabel(lang.GetString("editor_imagesaved").Replace("%storagelocation%", lastSaveFullPath), fileSavedStatusContextMenu);
}
catch (System.Runtime.InteropServices.ExternalException)
{
MessageBox.Show(lang.GetString("error_nowriteaccess").Replace("%path%", lastSaveFullPath).Replace(@"\\", @"\"), lang.GetString("error"));
}
}
protected override void EndRecording(RecordingSession session)
{
// Restore the asyncShaderCompilation setting
EditorSettings.asyncShaderCompilation = m_asyncShaderCompileSetting;
#if OIIO_AVAILABLE
if (m_imgOutput != null)
{
ImageOutput.destroy(m_imgOutput);
}
#endif
base.EndRecording(session);
}
/// <summary>
/// Place the bitmap on the clipboard as DIB
/// </summary>
/// <param name="clipboardAccessToken">IClipboardAccessToken</param>
/// <param name="surface">ISurface</param>
public static void SetAsDeviceIndependendBitmap(this IClipboardAccessToken clipboardAccessToken, ISurface surface)
{
using (var bitmapStream = new MemoryStream())
{
ImageOutput.SaveToStream(surface, bitmapStream, new SurfaceOutputSettings {
Format = OutputFormats.bmp
});
bitmapStream.Seek(Marshal.SizeOf(typeof(BitmapFileHeader)), SeekOrigin.Begin);
// Set the stream
clipboardAccessToken.SetAsStream(StandardClipboardFormats.DeviceIndependentBitmap, bitmapStream);
}
}
void CopyImageToClipboardToolStripMenuItemClick(object sender, System.EventArgs e)
{
try
{
ImageOutput.PrepareClipboardObject();
ImageOutput.CopyToClipboard(surface.GetImageForExport());
updateStatusLabel(lang.GetString("editor_storedtoclipboard"));
}
catch (Exception)
{
updateStatusLabel(lang.GetString("editor_clipboardfailed"));
}
}
void SaveAsToolStripMenuItemClick(object sender, System.EventArgs e)
{
lastSaveFullPath = ImageOutput.SaveWithDialog(surface.GetImageForExport());
if (lastSaveFullPath != null)
{
SetImagePath(lastSaveFullPath);
updateStatusLabel(lang.GetString("editor_imagesaved").Replace("%storagelocation%", lastSaveFullPath), fileSavedStatusContextMenu);
}
else
{
clearStatusLabel();
}
}
public void Run()
{
Renderer renderer = new Renderer(new OrthoRenderManager(new Math.Vector3f(0, 0, 1), width, height), new PhongDirectContributionModel());
Scene scene = new Scene();
scene.AddRenderObject(new Sphere(new Math.Vector3f(320, 320, 650), 150, new Color(1, 0, 1)));
scene.AddRenderObject(new Sphere(new Math.Vector3f(320, 500, 800), 150, new Color(1, 0, 1)));
OutputData data = renderer.RenderScene(scene);
ImageOutput imageOut = new ImageOutput(width, height, data);
imageOut.WriteOutput(@"C:\users\Ethan\Desktop\RayTraceSceneTest.png");
}
/// <summary>
/// Shutdown / cleanup
/// </summary>
public void Exit()
{
Log.Info().WriteLine("Exit: " + EnvironmentInfo.EnvironmentToString(false));
ImageOutput.RemoveTmpFiles();
// make the icon invisible otherwise it stays even after exit!!
if (notifyIcon != null)
{
notifyIcon.Visible = false;
notifyIcon.Dispose();
notifyIcon = null;
}
}
public static void ExportToPage(ISurface surfaceToUpload, OneNotePage page)
{
using (MemoryStream pngStream = new MemoryStream()) {
SurfaceOutputSettings pngOutputSettings = new SurfaceOutputSettings(OutputFormat.png, 100, false);
ImageOutput.SaveToStream(surfaceToUpload, pngStream, pngOutputSettings);
string base64String = Convert.ToBase64String(pngStream.GetBuffer());
string imageXmlStr = string.Format(XML_IMAGE_CONTENT, base64String, surfaceToUpload.Image.Width, surfaceToUpload.Image.Height);
string pageChangesXml = string.Format(XML_OUTLINE, new object[] { imageXmlStr, page.PageID, ONENOTE_NAMESPACE_2010, page.PageName });
using (IOneNoteApplication oneNoteApplication = COMWrapper.GetOrCreateInstance <IOneNoteApplication>()) {
LOG.InfoFormat("Sending XML: {0}", pageChangesXml);
oneNoteApplication.UpdatePageContent(pageChangesXml, DateTime.MinValue, XMLSchema.xs2010, false);
}
}
}
protected override ExportInformation ExportCapture(bool manuallyInitiated, ISurface surface, ICaptureDetails captureDetails)
{
var exportInformation = new ExportInformation(Designation, Description);
// Bug #2918756 don't overwrite path if SaveWithDialog returns null!
var savedTo = ImageOutput.SaveWithDialog(surface, captureDetails);
if (savedTo != null)
{
exportInformation.ExportMade = true;
exportInformation.Filepath = savedTo;
captureDetails.Filename = savedTo;
_coreConfiguration.OutputFileAsFullpath = savedTo;
}
ProcessExport(exportInformation, surface);
return(exportInformation);
}
public override ExportInformation ExportCapture(bool manuallyInitiated, ISurface surface, ICaptureDetails captureDetails)
{
ExportInformation exportInformation = new ExportInformation(this.Designation, this.Description);
SurfaceOutputSettings outputSettings = new SurfaceOutputSettings();
if (presetCommand != null)
{
bool runInBackground = presetCommand.RunInBackground;
string fullPath = captureDetails.Filename;
if (fullPath == null)
{
fullPath = ImageOutput.SaveNamedTmpFile(surface, captureDetails, outputSettings);
}
string output = null;
if (runInBackground)
{
Thread commandThread = new Thread(delegate() {
CallExternalCommand(presetCommand, fullPath, out output);
});
commandThread.Name = "Running " + presetCommand;
commandThread.IsBackground = true;
commandThread.Start();
exportInformation.ExportMade = true;
}
else
{
try {
if (CallExternalCommand(presetCommand, fullPath, out output) == 0)
{
exportInformation.ExportMade = true;
}
else
{
exportInformation.ErrorMessage = output;
}
} catch (Exception ex) {
exportInformation.ErrorMessage = ex.Message;
}
}
//exportInformation.Uri = "file://" + fullPath;
}
ProcessExport(exportInformation, surface);
return(exportInformation);
}
public override bool ExportCapture(bool manuallyInitiated, ISurface surface, ICaptureDetails captureDetails)
{
bool outputMade = false;
string pattern = "${title}";
if (string.IsNullOrEmpty(pattern))
{
pattern = "greenshot ${capturetime}";
}
string filename = FilenameHelper.GetFilenameFromPattern(pattern, conf.OutputFileFormat, captureDetails);
string filepath = FilenameHelper.FillVariables(conf.OutputFilePath, false);
string fullPath = Path.Combine(filepath, filename);
// Catching any exception to prevent that the user can't write in the directory.
// This is done for e.g. bugs #2974608, #2963943, #2816163, #2795317, #2789218, #3004642
using (Image image = surface.GetImageForExport())
{
try
{
// TODO: For now we overwrite, but this should be fixed some time
ImageOutput.Save(image, fullPath, true);
outputMade = true;
}
catch (Exception e)
{
LOG.Error("Error saving screenshot!", e);
// Show the problem
MessageBox.Show(Language.GetString(LangKey.error_save), Language.GetString(LangKey.error));
// when save failed we present a SaveWithDialog
fullPath = ImageOutput.SaveWithDialog(image, captureDetails);
outputMade = (fullPath != null);
}
}
// Don't overwite filename if no output is made
if (outputMade)
{
surface.LastSaveFullPath = fullPath;
surface.Modified = false;
captureDetails.Filename = fullPath;
surface.SendMessageEvent(this, SurfaceMessageTyp.FileSaved, Language.GetFormattedString(LangKey.editor_imagesaved, surface.LastSaveFullPath));
}
else
{
surface.SendMessageEvent(this, SurfaceMessageTyp.Info, "");
}
return(outputMade);
}
public override ExportInformation ExportCapture(bool manuallyInitiated, ISurface surface, ICaptureDetails captureDetails)
{
ExportInformation exportInformation = new ExportInformation(this.Designation, this.Description);
string savedTo = null;
// Bug #2918756 don't overwrite path if SaveWithDialog returns null!
savedTo = ImageOutput.SaveWithDialog(surface, captureDetails);
if (savedTo != null)
{
exportInformation.ExportMade = true;
exportInformation.Filepath = savedTo;
captureDetails.Filename = savedTo;
conf.OutputFileAsFullpath = savedTo;
}
ProcessExport(exportInformation, surface);
return(exportInformation);
}
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);
}
public override bool ExportCapture(bool manuallyInitiated, ISurface surface, ICaptureDetails captureDetails)
{
string savedTo = null;
using (Image image = surface.GetImageForExport()) {
// Bug #2918756 don't overwrite path if SaveWithDialog returns null!
savedTo = ImageOutput.SaveWithDialog(image, captureDetails);
if (savedTo != null)
{
surface.Modified = false;
surface.LastSaveFullPath = savedTo;
captureDetails.Filename = savedTo;
surface.SendMessageEvent(this, SurfaceMessageTyp.FileSaved, Language.GetFormattedString(LangKey.editor_imagesaved, surface.LastSaveFullPath));
}
}
return(savedTo != null);
}
public override ExportInformation ExportCapture(bool manuallyInitiated, ISurface surface, ICaptureDetails captureDetails)
{
ExportInformation exportInformation = new ExportInformation(Designation, Description);
SurfaceOutputSettings outputSettings = new SurfaceOutputSettings();
outputSettings.PreventGreenshotFormat();
if (_presetCommand != null)
{
if (!config.RunInbackground.ContainsKey(_presetCommand))
{
config.RunInbackground.Add(_presetCommand, true);
}
bool runInBackground = config.RunInbackground[_presetCommand];
string fullPath = captureDetails.Filename;
if (fullPath == null)
{
fullPath = ImageOutput.SaveNamedTmpFile(surface, captureDetails, outputSettings);
}
string output;
string error;
if (runInBackground)
{
Thread commandThread = new Thread(delegate()
{
CallExternalCommand(exportInformation, fullPath, out output, out error);
ProcessExport(exportInformation, surface);
})
{
Name = "Running " + _presetCommand,
IsBackground = true
};
commandThread.SetApartmentState(ApartmentState.STA);
commandThread.Start();
exportInformation.ExportMade = true;
}
else
{
CallExternalCommand(exportInformation, fullPath, out output, out error);
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);
}
protected override bool BeginRecording(RecordingSession session)
{
if (!base.BeginRecording(session))
{
return(false);
}
// Save the async compile shader setting to restore it at the end of recording
m_asyncShaderCompileSetting = EditorSettings.asyncShaderCompilation;
// Disable async compile shader setting when recording
EditorSettings.asyncShaderCompilation = false;
Settings.FileNameGenerator.CreateDirectory(session);
#if OIIO_AVAILABLE
m_imgOutput = ImageOutput.create("dummy." + m_Settings.extension);
#endif
return(true);
}
