public static Bitmap AnnotateImage(Bitmap bmp, string filePath, TaskSettings taskSettings, bool taskMode = false)
{
if (bmp != null)
{
using (bmp)
{
RegionCaptureMode mode = taskMode ? RegionCaptureMode.TaskEditor : RegionCaptureMode.Editor;
RegionCaptureOptions options = taskSettings.CaptureSettingsReference.SurfaceOptions;
using (RegionCaptureForm form = new RegionCaptureForm(mode, options, bmp))
{
form.ImageFilePath = filePath;
form.SaveImageRequested += (output, newFilePath) =>
{
using (output)
{
if (string.IsNullOrEmpty(newFilePath))
{
string fileName = GetFilename(taskSettings, taskSettings.ImageSettings.ImageFormat.GetDescription(), output);
newFilePath = Path.Combine(taskSettings.GetScreenshotsFolder(), fileName);
}
ImageHelpers.SaveImage(output, newFilePath);
}
return(newFilePath);
};
form.SaveImageAsRequested += (output, newFilePath) =>
{
using (output)
{
if (string.IsNullOrEmpty(newFilePath))
{
string fileName = GetFilename(taskSettings, taskSettings.ImageSettings.ImageFormat.GetDescription(), output);
newFilePath = Path.Combine(taskSettings.GetScreenshotsFolder(), fileName);
}
newFilePath = ImageHelpers.SaveImageFileDialog(output, newFilePath);
}
return(newFilePath);
};
form.CopyImageRequested += output =>
{
Option.MainForm.Invoke(() =>
{
using (output) { ClipboardHelpers.CopyImage(output); }
});
};
form.UploadImageRequested += output =>
{
Option.MainForm.Invoke(() =>
{
//UploadManager.UploadImage(output);
});
};
form.PrintImageRequested += output =>
{
Option.MainForm.Invoke(() =>
{
using (output) { PrintImage(output); }
});
};
form.ShowDialog();
switch (form.Result)
{
case RegionResult.Close: // Esc
case RegionResult.AnnotateCancelTask:
return(null);
case RegionResult.Region: // Enter
case RegionResult.AnnotateRunAfterCaptureTasks:
return(form.GetResultImage());
case RegionResult.Fullscreen: // Space or right click
case RegionResult.AnnotateContinueTask:
return((Bitmap)form.Canvas.Clone());
}
}
}
}
return(null);
}
private void btnCopyPreview_Click(object sender, EventArgs e)
{
ClipboardHelpers.CopyText($"{Path.GetFileName(Options.FFmpeg.FFmpegPath)} {Options.GetFFmpegCommands()}");
}
private void tsbCopyThumbnailURL_Click(object sender, EventArgs e)
{
ClipboardHelpers.CopyText(Result.ThumbnailURL);
}
public async void StartRecording(TaskSettings TaskSettings)
{
if (TaskSettings.CaptureSettings.RunScreencastCLI)
{
if (!Program.Settings.VideoEncoders.IsValidIndex(TaskSettings.CaptureSettings.VideoEncoderSelected))
{
MessageBox.Show("There is no valid CLI video encoder selected.", Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Warning);
return;
}
else if (!Program.Settings.VideoEncoders[TaskSettings.CaptureSettings.VideoEncoderSelected].IsValid())
{
MessageBox.Show("CLI video encoder file does not exist: " + Program.Settings.VideoEncoders[TaskSettings.CaptureSettings.VideoEncoderSelected].Path,
Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Warning);
return;
}
}
if (TaskSettings.CaptureSettings.ScreenRecordOutput == ScreenRecordOutput.FFmpeg && !File.Exists(TaskSettings.CaptureSettings.FFmpegOptions.CLIPath))
{
string ffmpegText = string.IsNullOrEmpty(TaskSettings.CaptureSettings.FFmpegOptions.CLIPath) ? "ffmpeg.exe" : TaskSettings.CaptureSettings.FFmpegOptions.CLIPath;
if (MessageBox.Show(ffmpegText + " does not exist." + Environment.NewLine + Environment.NewLine + "Would you like to automatically download it?",
Application.ProductName + " - Missing ffmpeg.exe", MessageBoxButtons.YesNo, MessageBoxIcon.Warning) == DialogResult.Yes)
{
if (FFmpegHelper.DownloadFFmpeg(false, DownloaderForm_InstallRequested) == DialogResult.OK)
{
Program.DefaultTaskSettings.CaptureSettings.FFmpegOptions.CLIPath = TaskSettings.TaskSettingsReference.CaptureSettings.FFmpegOptions.CLIPath =
TaskSettings.CaptureSettings.FFmpegOptions.CLIPath = Path.Combine(Program.ToolsFolder, "ffmpeg.exe");
}
}
else
{
return;
}
}
SelectRegion();
if (IsRecording || captureRectangle.IsEmpty || screenRecorder != null)
{
return;
}
IsRecording = true;
Screenshot.CaptureCursor = TaskSettings.CaptureSettings.ShowCursor;
TrayIcon.Icon = Resources.control_record_yellow.ToIcon();
TrayIcon.Visible = true;
string path = "";
try
{
using (ScreenRegionManager screenRegionManager = new ScreenRegionManager())
{
screenRegionManager.Start(captureRectangle);
await TaskEx.Run(() =>
{
if (TaskSettings.CaptureSettings.ScreenRecordOutput == ScreenRecordOutput.AVI)
{
path = Path.Combine(TaskSettings.CaptureFolder, TaskHelpers.GetFilename(TaskSettings, "avi"));
}
else if (TaskSettings.CaptureSettings.ScreenRecordOutput == ScreenRecordOutput.FFmpeg)
{
path = Path.Combine(TaskSettings.CaptureFolder, TaskHelpers.GetFilename(TaskSettings, TaskSettings.CaptureSettings.FFmpegOptions.Extension));
}
else
{
path = Program.ScreenRecorderCacheFilePath;
}
ScreencastOptions options = new ScreencastOptions()
{
CaptureArea = captureRectangle,
GIFFPS = TaskSettings.CaptureSettings.GIFFPS,
ScreenRecordFPS = TaskSettings.CaptureSettings.ScreenRecordFPS,
OutputPath = path,
Duration = TaskSettings.CaptureSettings.ScreenRecordFixedDuration ? TaskSettings.CaptureSettings.ScreenRecordDuration : 0,
AVI = TaskSettings.CaptureSettings.AVIOptions,
FFmpeg = TaskSettings.CaptureSettings.FFmpegOptions,
DrawCursor = TaskSettings.CaptureSettings.ShowCursor
};
screenRecorder = new ScreenRecorder(options, captureRectangle, TaskSettings.CaptureSettings.ScreenRecordOutput);
int delay = (int)(TaskSettings.CaptureSettings.ScreenRecordStartDelay * 1000);
if (delay > 0)
{
Thread.Sleep(delay);
}
screenRegionManager.ChangeColor();
this.InvokeSafe(() => TrayIcon.Icon = Resources.control_record.ToIcon());
screenRecorder.StartRecording();
});
}
if (screenRecorder != null)
{
TrayIcon.Icon = Resources.camcorder__pencil.ToIcon();
await TaskEx.Run(() =>
{
string sourceFilePath = path;
if (TaskSettings.CaptureSettings.ScreenRecordOutput == ScreenRecordOutput.GIF)
{
if (TaskSettings.CaptureSettings.RunScreencastCLI)
{
sourceFilePath = Path.ChangeExtension(Program.ScreenRecorderCacheFilePath, "gif");
}
else
{
sourceFilePath = path = Path.Combine(TaskSettings.CaptureFolder, TaskHelpers.GetFilename(TaskSettings, "gif"));
}
screenRecorder.SaveAsGIF(sourceFilePath, TaskSettings.ImageSettings.ImageGIFQuality);
}
if (TaskSettings.CaptureSettings.RunScreencastCLI)
{
VideoEncoder encoder = Program.Settings.VideoEncoders[TaskSettings.CaptureSettings.VideoEncoderSelected];
path = Path.Combine(TaskSettings.CaptureFolder, TaskHelpers.GetFilename(TaskSettings, encoder.OutputExtension));
screenRecorder.EncodeUsingCommandLine(encoder, sourceFilePath, path);
}
});
}
}
finally
{
if (screenRecorder != null)
{
if (TaskSettings.CaptureSettings.RunScreencastCLI &&
!string.IsNullOrEmpty(screenRecorder.CachePath) && File.Exists(screenRecorder.CachePath))
{
File.Delete(screenRecorder.CachePath);
}
screenRecorder.Dispose();
screenRecorder = null;
}
if (TrayIcon.Visible)
{
TrayIcon.Visible = false;
}
}
if (!string.IsNullOrEmpty(path) && File.Exists(path))
{
if (TaskSettings.AfterCaptureJob.HasFlag(AfterCaptureTasks.UploadImageToHost))
{
UploadManager.UploadFile(path, TaskSettings);
}
else
{
if (TaskSettings.AfterCaptureJob.HasFlag(AfterCaptureTasks.CopyFilePathToClipboard))
{
ClipboardHelpers.CopyText(path);
}
TaskHelpers.ShowResultNotifications(path, TaskSettings, path);
}
}
IsRecording = false;
}
private bool DoAfterCaptureJobs()
{
if (Image == null)
{
return(true);
}
if (Info.TaskSettings.AfterCaptureJob.HasFlag(AfterCaptureTasks.AddImageEffects))
{
Image = TaskHelpers.AddImageEffects(Image, Info.TaskSettings.ImageSettingsReference);
if (Image == null)
{
DebugHelper.WriteLine("Error: Applying image effects resulted empty image.");
return(false);
}
}
if (Info.TaskSettings.AfterCaptureJob.HasFlag(AfterCaptureTasks.AnnotateImage))
{
Image = TaskHelpers.AnnotateImage(Image, null, Info.TaskSettings, true);
if (Image == null)
{
return(false);
}
}
if (Info.TaskSettings.AfterCaptureJob.HasFlag(AfterCaptureTasks.CopyImageToClipboard))
{
ClipboardHelpers.CopyImage(Image);
DebugHelper.WriteLine("Image copied to clipboard.");
}
if (Info.TaskSettings.AfterCaptureJob.HasFlag(AfterCaptureTasks.SendImageToPrinter))
{
TaskHelpers.PrintImage(Image);
}
if (Info.TaskSettings.AfterCaptureJob.HasFlagAny(AfterCaptureTasks.SaveImageToFile, AfterCaptureTasks.SaveImageToFileWithDialog, AfterCaptureTasks.DoOCR,
AfterCaptureTasks.UploadImageToHost))
{
ImageData imageData = TaskHelpers.PrepareImage(Image, Info.TaskSettings);
Data = imageData.ImageStream;
Info.FileName = Path.ChangeExtension(Info.FileName, imageData.ImageFormat.GetDescription());
if (Info.TaskSettings.AfterCaptureJob.HasFlag(AfterCaptureTasks.SaveImageToFile))
{
string filePath = TaskHelpers.HandleExistsFile(Info.TaskSettings.CaptureFolder, Info.FileName, Info.TaskSettings);
if (!string.IsNullOrEmpty(filePath))
{
Info.FilePath = filePath;
imageData.Write(Info.FilePath);
DebugHelper.WriteLine("Image saved to file: " + Info.FilePath);
}
}
if (Info.TaskSettings.AfterCaptureJob.HasFlag(AfterCaptureTasks.SaveImageToFileWithDialog))
{
using (SaveFileDialog sfd = new SaveFileDialog())
{
bool imageSaved;
do
{
if (string.IsNullOrEmpty(lastSaveAsFolder) || !Directory.Exists(lastSaveAsFolder))
{
lastSaveAsFolder = Info.TaskSettings.CaptureFolder;
}
sfd.InitialDirectory = lastSaveAsFolder;
sfd.FileName = Info.FileName;
sfd.DefaultExt = Path.GetExtension(Info.FileName).Substring(1);
sfd.Filter = string.Format("*{0}|*{0}|All files (*.*)|*.*", Path.GetExtension(Info.FileName));
sfd.Title = Resources.UploadTask_DoAfterCaptureJobs_Choose_a_folder_to_save + " " + Path.GetFileName(Info.FileName);
if (sfd.ShowDialog() == DialogResult.OK && !string.IsNullOrEmpty(sfd.FileName))
{
Info.FilePath = sfd.FileName;
lastSaveAsFolder = Path.GetDirectoryName(Info.FilePath);
imageSaved = imageData.Write(Info.FilePath);
if (imageSaved)
{
DebugHelper.WriteLine("Image saved to file with dialog: " + Info.FilePath);
}
}
else
{
break;
}
} while (!imageSaved);
}
}
if (Info.TaskSettings.AfterCaptureJob.HasFlag(AfterCaptureTasks.SaveThumbnailImageToFile))
{
string thumbnailFilename, thumbnailFolder;
if (!string.IsNullOrEmpty(Info.FilePath))
{
thumbnailFilename = Path.GetFileName(Info.FilePath);
thumbnailFolder = Path.GetDirectoryName(Info.FilePath);
}
else
{
thumbnailFilename = Info.FileName;
thumbnailFolder = Info.TaskSettings.CaptureFolder;
}
Info.ThumbnailFilePath = TaskHelpers.CreateThumbnail(Image, thumbnailFolder, thumbnailFilename, Info.TaskSettings);
if (!string.IsNullOrEmpty(Info.ThumbnailFilePath))
{
DebugHelper.WriteLine("Thumbnail saved to file: " + Info.ThumbnailFilePath);
}
}
}
return(true);
}
private void DoAfterCaptureJobs()
{
if (Info.TaskSettings.AfterCaptureJob.HasFlag(AfterCaptureTasks.AddImageEffects))
{
tempImage = TaskHelpers.AddImageEffects(tempImage, Info.TaskSettings);
}
if (Info.TaskSettings.AfterCaptureJob.HasFlag(AfterCaptureTasks.AddWatermark) && Info.TaskSettings.ImageSettings.WatermarkConfig != null)
{
WatermarkManager watermarkManager = new WatermarkManager(Info.TaskSettings.ImageSettings.WatermarkConfig);
watermarkManager.ApplyWatermark(tempImage);
}
if (Info.TaskSettings.AfterCaptureJob.HasFlag(AfterCaptureTasks.AnnotateImage))
{
tempImage = TaskHelpers.AnnotateImage(tempImage);
}
if (Info.TaskSettings.AfterCaptureJob.HasFlag(AfterCaptureTasks.CopyImageToClipboard))
{
ClipboardHelpers.CopyImage(tempImage);
DebugHelper.WriteLine("CopyImageToClipboard");
}
if (Info.TaskSettings.AfterCaptureJob.HasFlag(AfterCaptureTasks.SendImageToPrinter))
{
if (Program.Settings.DontShowPrintSettingsDialog)
{
using (PrintHelper printHelper = new PrintHelper(tempImage))
{
printHelper.Settings = Program.Settings.PrintSettings;
printHelper.Print();
}
}
else
{
using (PrintForm printForm = new PrintForm(tempImage, Program.Settings.PrintSettings))
{
printForm.ShowDialog();
}
}
}
if (Info.TaskSettings.AfterCaptureJob.HasFlagAny(AfterCaptureTasks.SaveImageToFile, AfterCaptureTasks.SaveImageToFileWithDialog,
AfterCaptureTasks.UploadImageToHost))
{
using (tempImage)
{
ImageData imageData = TaskHelpers.PrepareImage(tempImage, Info.TaskSettings);
Data = imageData.ImageStream;
Info.FileName = Path.ChangeExtension(Info.FileName, imageData.ImageFormat.GetDescription());
if (Info.TaskSettings.AfterCaptureJob.HasFlag(AfterCaptureTasks.SaveImageToFile))
{
Info.FilePath = Path.Combine(Program.ScreenshotsPath, Info.FileName);
imageData.Write(Info.FilePath);
DebugHelper.WriteLine("SaveImageToFile: " + Info.FilePath);
}
if (Info.TaskSettings.AfterCaptureJob.HasFlag(AfterCaptureTasks.SaveImageToFileWithDialog))
{
using (SaveFileDialog sfd = new SaveFileDialog())
{
sfd.InitialDirectory = Program.ScreenshotsPath;
sfd.FileName = Info.FileName;
sfd.DefaultExt = Path.GetExtension(Info.FileName).Substring(1);
sfd.Filter = string.Format("*{0}|*{0}|All files (*.*)|*.*", Path.GetExtension(Info.FileName));
sfd.Title = "Choose a folder to save " + Path.GetFileName(Info.FileName);
if (sfd.ShowDialog() == DialogResult.OK && !string.IsNullOrEmpty(sfd.FileName))
{
Info.FilePath = sfd.FileName;
imageData.Write(Info.FilePath);
DebugHelper.WriteLine("SaveImageToFileWithDialog: " + Info.FilePath);
}
}
}
if (Info.TaskSettings.AfterCaptureJob.HasFlag(AfterCaptureTasks.CopyFileToClipboard) && !string.IsNullOrEmpty(Info.FilePath) &&
File.Exists(Info.FilePath))
{
ClipboardHelpers.CopyFile(Info.FilePath);
}
else if (Info.TaskSettings.AfterCaptureJob.HasFlag(AfterCaptureTasks.CopyFilePathToClipboard) && !string.IsNullOrEmpty(Info.FilePath))
{
ClipboardHelpers.CopyText(Info.FilePath);
}
if (Info.TaskSettings.AfterCaptureJob.HasFlag(AfterCaptureTasks.PerformActions) && Info.TaskSettings.ExternalPrograms != null &&
!string.IsNullOrEmpty(Info.FilePath) && File.Exists(Info.FilePath))
{
var actions = Info.TaskSettings.ExternalPrograms.Where(x => x.IsActive);
if (actions.Count() > 0)
{
if (Data != null)
{
Data.Dispose();
}
foreach (ExternalProgram fileAction in actions)
{
fileAction.Run(Info.FilePath);
}
Data = new FileStream(Info.FilePath, FileMode.Open, FileAccess.Read, FileShare.Read);
}
}
}
}
}
private void ThreadDoWork()
{
CreateTaskReferenceHelper();
try
{
StopRequested = !DoThreadJob();
OnImageReady();
if (!StopRequested)
{
if (Info.IsUploadJob && TaskHelpers.IsUploadAllowed())
{
DoUploadJob();
}
else
{
Info.Result.IsURLExpected = false;
}
}
}
finally
{
KeepImage = Image != null && Info.TaskSettings.GeneralSettings.ShowToastNotificationAfterTaskCompleted;
Dispose();
if (EarlyURLCopied && (StopRequested || Info.Result == null || string.IsNullOrEmpty(Info.Result.URL)) && ClipboardHelpers.ContainsText())
{
ClipboardHelpers.Clear();
}
if ((Info.Job == TaskJob.Job || (Info.Job == TaskJob.FileUpload && Info.TaskSettings.AdvancedSettings.UseAfterCaptureTasksDuringFileUpload)) &&
Info.TaskSettings.AfterCaptureJob.HasFlag(AfterCaptureTasks.DeleteFile) && !string.IsNullOrEmpty(Info.FilePath) && File.Exists(Info.FilePath))
{
File.Delete(Info.FilePath);
}
}
if (!StopRequested && Info.Result != null && Info.Result.IsURLExpected && !Info.Result.IsError)
{
if (string.IsNullOrEmpty(Info.Result.URL))
{
AddErrorMessage(Resources.UploadTask_ThreadDoWork_URL_is_empty_);
}
else
{
DoAfterUploadJobs();
}
}
}
private void tsmiCopyCMYK_Click(object sender, EventArgs e)
{
CMYK cmyk = colorPicker.SelectedColor.CMYK;
ClipboardHelpers.CopyText($"{cmyk.Cyan100:0.0}%, {cmyk.Magenta100:0.0}%, {cmyk.Yellow100:0.0}%, {cmyk.Key100:0.0}%");
}
private void tsmiCopyDecimal_Click(object sender, EventArgs e)
{
int dec = ColorHelpers.ColorToDecimal(colorPicker.SelectedColor, ColorFormat.RGB);
ClipboardHelpers.CopyText(dec.ToString());
}
private void tsmiCopyHex_Click(object sender, EventArgs e)
{
string hex = ColorHelpers.ColorToHex(colorPicker.SelectedColor, ColorFormat.RGB);
ClipboardHelpers.CopyText("#" + hex);
}
private void tsmiCopyHSB_Click(object sender, EventArgs e)
{
HSB hsb = colorPicker.SelectedColor.HSB;
ClipboardHelpers.CopyText($"{hsb.Hue360:0.0}°, {hsb.Saturation100:0.0}%, {hsb.Brightness100:0.0}%");
}
private void tsmiCopyRGB_Click(object sender, EventArgs e)
{
RGBA rgba = colorPicker.SelectedColor.RGBA;
ClipboardHelpers.CopyText($"{rgba.Red}, {rgba.Green}, {rgba.Blue}");
}
private void tsbCopyStats_Click(object sender, EventArgs e)
{
string stats = OutputStats(allHistoryItems);
ClipboardHelpers.CopyText(stats);
}
private void tsbResponseTextCopy_Click(object sender, EventArgs e)
{
ClipboardHelpers.CopyText(rtbResponseText.Text);
}
public void CopyThumbnailImage()
{
if (IsItemSelected && SelectedItem.IsThumbnailFileExist) ClipboardHelpers.CopyImageFromFile(SelectedItem.Info.ThumbnailFilePath);
}
private void tsmiCopyPosition_Click(object sender, EventArgs e)
{
ClipboardHelpers.CopyText($"{txtX.Text}, {txtY.Text}");
}
public static void ClipboardUpload(TaskSettings taskSettings = null)
{
if (taskSettings == null)
{
taskSettings = TaskSettings.GetDefaultTaskSettings();
}
if (Clipboard.ContainsImage())
{
Image img = ClipboardHelpers.GetImage();
if (img != null)
{
if (!taskSettings.AdvancedSettings.ProcessImagesDuringClipboardUpload)
{
taskSettings.AfterCaptureJob = AfterCaptureTasks.UploadImageToHost;
}
RunImageTask(img, taskSettings);
}
}
else if (Clipboard.ContainsText())
{
string text = Clipboard.GetText();
if (!string.IsNullOrEmpty(text))
{
string url = text.Trim();
if (URLHelpers.IsValidURL(url))
{
if (taskSettings.UploadSettings.ClipboardUploadURLContents)
{
DownloadAndUploadFile(url, taskSettings);
return;
}
if (taskSettings.UploadSettings.ClipboardUploadShortenURL)
{
ShortenURL(url, taskSettings);
return;
}
if (taskSettings.UploadSettings.ClipboardUploadShareURL)
{
ShareURL(url, taskSettings);
return;
}
}
if (taskSettings.UploadSettings.ClipboardUploadAutoIndexFolder && text.Length <= 260 && Directory.Exists(text))
{
IndexFolder(text, taskSettings);
}
else
{
UploadText(text, taskSettings, true);
}
}
}
else if (Clipboard.ContainsFileDropList())
{
string[] files = Clipboard.GetFileDropList().OfType <string>().ToArray();
if (files.Length > 0)
{
UploadFile(files, taskSettings);
}
}
}
private void ExecuteAction(ToastClickAction action)
{
switch (action)
{
case ToastClickAction.AnnotateImage:
if (!string.IsNullOrEmpty(Config.FilePath) && Helpers.IsImageFile(Config.FilePath))
{
TaskHelpers.AnnotateImageFromFile(Config.FilePath);
}
break;
case ToastClickAction.CopyImageToClipboard:
if (!string.IsNullOrEmpty(Config.FilePath))
{
ClipboardHelpers.CopyImageFromFile(Config.FilePath);
}
break;
case ToastClickAction.CopyFile:
if (!string.IsNullOrEmpty(Config.FilePath))
{
ClipboardHelpers.CopyFile(Config.FilePath);
}
break;
case ToastClickAction.CopyFilePath:
if (!string.IsNullOrEmpty(Config.FilePath))
{
ClipboardHelpers.CopyText(Config.FilePath);
}
break;
case ToastClickAction.CopyUrl:
if (!string.IsNullOrEmpty(Config.URL))
{
ClipboardHelpers.CopyText(Config.URL);
}
break;
case ToastClickAction.OpenFile:
if (!string.IsNullOrEmpty(Config.FilePath))
{
Helpers.OpenFile(Config.FilePath);
}
break;
case ToastClickAction.OpenFolder:
if (!string.IsNullOrEmpty(Config.FilePath))
{
Helpers.OpenFolderWithFile(Config.FilePath);
}
break;
case ToastClickAction.OpenUrl:
if (!string.IsNullOrEmpty(Config.URL))
{
URLHelpers.OpenURL(Config.URL);
}
break;
case ToastClickAction.Upload:
if (!string.IsNullOrEmpty(Config.FilePath))
{
UploadManager.UploadFile(Config.FilePath);
}
break;
}
}
private void DoAfterUploadJobs()
{
try
{
if (Info.TaskSettings.AfterUploadJob.HasFlag(AfterUploadTasks.UseURLShortener) || Info.Job == TaskJob.ShortenURL)
{
UploadResult result = ShortenURL(Info.Result.URL);
if (result != null)
{
Info.Result.ShortenedURL = result.ShortenedURL;
}
}
if (Info.TaskSettings.AfterUploadJob.HasFlag(AfterUploadTasks.ShareURLToSocialNetworkingService))
{
OAuthInfo twitterOAuth = Program.UploadersConfig.TwitterOAuthInfoList.ReturnIfValidIndex(Program.UploadersConfig.TwitterSelectedAccount);
if (twitterOAuth != null)
{
using (TwitterMsg twitter = new TwitterMsg(twitterOAuth))
{
twitter.Message = Info.Result.ToString();
twitter.Config = Program.UploadersConfig.TwitterClientConfig;
twitter.ShowDialog();
}
}
}
if (Info.TaskSettings.AfterUploadJob.HasFlag(AfterUploadTasks.SendURLWithEmail))
{
using (EmailForm emailForm = new EmailForm(Program.UploadersConfig.EmailRememberLastTo ? Program.UploadersConfig.EmailLastTo : string.Empty,
Program.UploadersConfig.EmailDefaultSubject, Info.Result.ToString()))
{
emailForm.Icon = Resources.ShareX_Icon;
if (emailForm.ShowDialog() == DialogResult.OK)
{
if (Program.UploadersConfig.EmailRememberLastTo)
{
Program.UploadersConfig.EmailLastTo = emailForm.ToEmail;
}
Email email = new Email
{
SmtpServer = Program.UploadersConfig.EmailSmtpServer,
SmtpPort = Program.UploadersConfig.EmailSmtpPort,
FromEmail = Program.UploadersConfig.EmailFrom,
Password = Program.UploadersConfig.EmailPassword
};
email.Send(emailForm.ToEmail, emailForm.Subject, emailForm.Body);
}
}
}
if (Info.TaskSettings.AfterUploadJob.HasFlag(AfterUploadTasks.CopyURLToClipboard))
{
string txt;
if (!string.IsNullOrEmpty(Info.TaskSettings.AdvancedSettings.ClipboardContentFormat))
{
txt = new UploadInfoParser().Parse(Info, Info.TaskSettings.AdvancedSettings.ClipboardContentFormat);
}
else
{
txt = Info.Result.ToString();
}
if (!string.IsNullOrEmpty(txt))
{
ClipboardHelpers.CopyText(txt);
}
}
}
catch (Exception e)
{
DebugHelper.WriteException(e);
if (Info.Result == null)
{
Info.Result = new UploadResult();
}
Info.Result.Errors.Add(e.ToString());
}
}
private void DoAfterCaptureJobs()
{
if (Info.TaskSettings.AfterCaptureJob.HasFlag(AfterCaptureTasks.AddImageEffects))
{
tempImage = TaskHelpers.AddImageEffects(tempImage, Info.TaskSettings);
}
if (Info.TaskSettings.AfterCaptureJob.HasFlag(AfterCaptureTasks.AddWatermark) && Info.TaskSettings.ImageSettings.WatermarkConfig != null)
{
Info.TaskSettings.ImageSettings.WatermarkConfig.Apply(tempImage);
}
if (Info.TaskSettings.AfterCaptureJob.HasFlag(AfterCaptureTasks.AnnotateImage))
{
tempImage = TaskHelpers.AnnotateImage(tempImage, Info.FileName);
}
if (Info.TaskSettings.AfterCaptureJob.HasFlag(AfterCaptureTasks.CopyImageToClipboard))
{
ClipboardHelpers.CopyImage(tempImage);
DebugHelper.WriteLine("CopyImageToClipboard");
}
if (Info.TaskSettings.AfterCaptureJob.HasFlag(AfterCaptureTasks.SendImageToPrinter))
{
if (Program.Settings.DontShowPrintSettingsDialog)
{
using (PrintHelper printHelper = new PrintHelper(tempImage))
{
printHelper.Settings = Program.Settings.PrintSettings;
printHelper.Print();
}
}
else
{
using (PrintForm printForm = new PrintForm(tempImage, Program.Settings.PrintSettings))
{
printForm.ShowDialog();
}
}
}
if (Info.TaskSettings.AfterCaptureJob.HasFlagAny(AfterCaptureTasks.SaveImageToFile, AfterCaptureTasks.SaveImageToFileWithDialog, AfterCaptureTasks.UploadImageToHost))
{
using (tempImage)
{
ImageData imageData = TaskHelpers.PrepareImage(tempImage, Info.TaskSettings);
Data = imageData.ImageStream;
Info.FileName = Path.ChangeExtension(Info.FileName, imageData.ImageFormat.GetDescription());
if (Info.TaskSettings.AfterCaptureJob.HasFlag(AfterCaptureTasks.SaveImageToFile))
{
string filePath = TaskHelpers.CheckFilePath(Info.TaskSettings.CaptureFolder, Info.FileName, Info.TaskSettings);
if (!string.IsNullOrEmpty(filePath))
{
Info.FilePath = filePath;
imageData.Write(Info.FilePath);
DebugHelper.WriteLine("SaveImageToFile: " + Info.FilePath);
}
}
if (Info.TaskSettings.AfterCaptureJob.HasFlag(AfterCaptureTasks.SaveImageToFileWithDialog))
{
using (SaveFileDialog sfd = new SaveFileDialog())
{
if (string.IsNullOrEmpty(lastSaveAsFolder) || !Directory.Exists(lastSaveAsFolder))
{
lastSaveAsFolder = Info.TaskSettings.CaptureFolder;
}
sfd.InitialDirectory = lastSaveAsFolder;
sfd.FileName = Info.FileName;
sfd.DefaultExt = Path.GetExtension(Info.FileName).Substring(1);
sfd.Filter = string.Format("*{0}|*{0}|All files (*.*)|*.*", Path.GetExtension(Info.FileName));
sfd.Title = "Choose a folder to save " + Path.GetFileName(Info.FileName);
if (sfd.ShowDialog() == DialogResult.OK && !string.IsNullOrEmpty(sfd.FileName))
{
Info.FilePath = sfd.FileName;
lastSaveAsFolder = Path.GetDirectoryName(Info.FilePath);
imageData.Write(Info.FilePath);
DebugHelper.WriteLine("SaveImageToFileWithDialog: " + Info.FilePath);
}
}
}
if (Info.TaskSettings.AfterCaptureJob.HasFlag(AfterCaptureTasks.SaveThumbnailImageToFile))
{
string thumbnailFilename, thumbnailFolder;
if (!string.IsNullOrEmpty(Info.FilePath))
{
thumbnailFilename = Path.GetFileName(Info.FilePath);
thumbnailFolder = Path.GetDirectoryName(Info.FilePath);
}
else
{
thumbnailFilename = Info.FileName;
thumbnailFolder = Info.TaskSettings.CaptureFolder;
}
Info.ThumbnailFilePath = TaskHelpers.CreateThumbnail(tempImage, thumbnailFolder, thumbnailFilename, Info.TaskSettings);
if (!string.IsNullOrEmpty(Info.ThumbnailFilePath))
{
DebugHelper.WriteLine("SaveThumbnailImageToFile: " + Info.ThumbnailFilePath);
}
}
}
}
}
private void DoFileJobs()
{
if (!string.IsNullOrEmpty(Info.FilePath) && File.Exists(Info.FilePath))
{
if (Info.TaskSettings.AfterCaptureJob.HasFlag(AfterCaptureTasks.PerformActions) && Info.TaskSettings.ExternalPrograms != null)
{
IEnumerable <ExternalProgram> actions = Info.TaskSettings.ExternalPrograms.Where(x => x.IsActive);
if (actions.Count() > 0)
{
bool isFileModified = false;
string fileName = Info.FileName;
foreach (ExternalProgram fileAction in actions)
{
string modifiedPath = fileAction.Run(Info.FilePath);
if (!string.IsNullOrEmpty(modifiedPath))
{
isFileModified = true;
Info.FilePath = modifiedPath;
if (Data != null)
{
Data.Dispose();
}
fileAction.DeletePendingInputFile();
}
}
if (isFileModified)
{
string extension = FileHelpers.GetFileNameExtension(Info.FilePath);
Info.FileName = FileHelpers.ChangeFileNameExtension(fileName, extension);
LoadFileStream();
}
}
}
if (Info.TaskSettings.AfterCaptureJob.HasFlag(AfterCaptureTasks.CopyFileToClipboard))
{
ClipboardHelpers.CopyFile(Info.FilePath);
}
else if (Info.TaskSettings.AfterCaptureJob.HasFlag(AfterCaptureTasks.CopyFilePathToClipboard))
{
ClipboardHelpers.CopyText(Info.FilePath);
}
if (Info.TaskSettings.AfterCaptureJob.HasFlag(AfterCaptureTasks.ShowInExplorer))
{
FileHelpers.OpenFolderWithFile(Info.FilePath);
}
if (Info.TaskSettings.AfterCaptureJob.HasFlag(AfterCaptureTasks.ScanQRCode) && Info.DataType == EDataType.Image)
{
QRCodeForm.OpenFormDecodeFromFile(Info.FilePath).ShowDialog();
}
}
}
private void btnCopyPreview_Click(object sender, EventArgs e)
{
ClipboardHelpers.CopyText("ffmpeg " + Options.GetFFmpegCommands());
}
private void NotificationForm_MouseClick(object sender, MouseEventArgs e)
{
tDuration.Stop();
Close();
if (e.Button == MouseButtons.Left)
{
switch (ToastConfig.Action)
{
case ToastClickAction.AnnotateImage:
if (!string.IsNullOrEmpty(ToastConfig.FilePath) && Helpers.IsImageFile(ToastConfig.FilePath))
{
TaskHelpers.AnnotateImage(ToastConfig.FilePath);
}
break;
case ToastClickAction.CopyImageToClipboard:
if (!string.IsNullOrEmpty(ToastConfig.FilePath))
{
ClipboardHelpers.CopyImageFromFile(ToastConfig.FilePath);
}
break;
case ToastClickAction.CopyUrl:
if (!string.IsNullOrEmpty(ToastConfig.URL))
{
ClipboardHelpers.CopyText(ToastConfig.URL);
}
break;
case ToastClickAction.OpenFile:
if (!string.IsNullOrEmpty(ToastConfig.FilePath))
{
URLHelpers.OpenURL(ToastConfig.FilePath);
}
break;
case ToastClickAction.OpenFolder:
if (!string.IsNullOrEmpty(ToastConfig.FilePath))
{
Helpers.OpenFolderWithFile(ToastConfig.FilePath);
}
break;
case ToastClickAction.OpenUrl:
if (!string.IsNullOrEmpty(ToastConfig.URL))
{
URLHelpers.OpenURL(ToastConfig.URL);
}
break;
case ToastClickAction.Upload:
if (!string.IsNullOrEmpty(ToastConfig.FilePath))
{
UploadManager.UploadFile(ToastConfig.FilePath);
}
break;
}
}
}
public void CopyFile()
{
if (IsItemSelected && SelectedItem.IsFileExist) ClipboardHelpers.CopyFile(SelectedItem.Info.FilePath);
}
private void DoAfterUploadJobs()
{
try
{
if (Info.TaskSettings.AdvancedSettings.ResultForceHTTPS)
{
Info.Result.ForceHTTPS();
}
if (Info.Job != TaskJob.ShareURL && (Info.TaskSettings.AfterUploadJob.HasFlag(AfterUploadTasks.UseURLShortener) || Info.Job == TaskJob.ShortenURL ||
(Info.TaskSettings.AdvancedSettings.AutoShortenURLLength > 0 && Info.Result.URL.Length > Info.TaskSettings.AdvancedSettings.AutoShortenURLLength)))
{
UploadResult result = ShortenURL(Info.Result.URL);
if (result != null)
{
Info.Result.ShortenedURL = result.ShortenedURL;
Info.Result.Errors.AddRange(result.Errors);
}
}
if (Info.Job != TaskJob.ShortenURL && (Info.TaskSettings.AfterUploadJob.HasFlag(AfterUploadTasks.ShareURL) || Info.Job == TaskJob.ShareURL))
{
UploadResult result = ShareURL(Info.Result.ToString());
if (result != null)
{
Info.Result.Errors.AddRange(result.Errors);
}
if (Info.Job == TaskJob.ShareURL)
{
Info.Result.IsURLExpected = false;
}
}
if (Info.TaskSettings.AfterUploadJob.HasFlag(AfterUploadTasks.CopyURLToClipboard))
{
string txt;
if (!string.IsNullOrEmpty(Info.TaskSettings.AdvancedSettings.ClipboardContentFormat))
{
txt = new UploadInfoParser().Parse(Info, Info.TaskSettings.AdvancedSettings.ClipboardContentFormat);
}
else
{
txt = Info.Result.ToString();
}
if (!string.IsNullOrEmpty(txt))
{
ClipboardHelpers.CopyText(txt);
}
}
if (Info.TaskSettings.AfterUploadJob.HasFlag(AfterUploadTasks.OpenURL))
{
string result;
if (!string.IsNullOrEmpty(Info.TaskSettings.AdvancedSettings.OpenURLFormat))
{
result = new UploadInfoParser().Parse(Info, Info.TaskSettings.AdvancedSettings.OpenURLFormat);
}
else
{
result = Info.Result.ToString();
}
URLHelpers.OpenURL(result);
}
if (Info.TaskSettings.AfterUploadJob.HasFlag(AfterUploadTasks.ShowQRCode))
{
threadWorker.InvokeAsync(() => new QRCodeForm(Info.Result.ToString()).Show());
}
}
catch (Exception e)
{
DebugHelper.WriteException(e);
AddErrorMessage(e.ToString());
}
}
public void CopyImage()
{
if (IsItemSelected && SelectedItem.IsImageFile) ClipboardHelpers.CopyImageFromFile(SelectedItem.Info.FilePath);
}
private void tsbCopyShortenedURL_Click(object sender, EventArgs e)
{
ClipboardHelpers.CopyText(Result.ShortenedURL);
}
public void CopyText()
{
if (IsItemSelected && SelectedItem.IsTextFile) ClipboardHelpers.CopyTextFromFile(SelectedItem.Info.FilePath);
}
private void tsbCopyDeletionURL_Click(object sender, EventArgs e)
{
ClipboardHelpers.CopyText(Result.DeletionURL);
}
public static Image AnnotateImage(Image img)
{
return(ImageHelpers.AnnotateImage(img, !Program.IsSandbox, Program.PersonalPath,
x => Program.MainForm.InvokeSafe(() => ClipboardHelpers.CopyImage(x)),
x => Program.MainForm.InvokeSafe(() => UploadManager.RunImageTask(x))));
}