CodeMirror/ShareX
1
0
Fork 0
mirror of https://github.com/ShareX/ShareX.git synced 2024-10-01 17:56:51 +13:00
Code Issues Projects Releases Packages Wiki Activity

Dynamic preview of main window or hotkey task settings

Browse source
This commit is contained in:
mcored 2014-05-12 06:06:26 +08:00
parent b999f27990
commit 474ffef071
18 changed files with 596 additions and 400 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
Docs/VersionHistory.txt
View file

@ -1,6 +1,6 @@
ShareX 8.8.1
* Capture screencasts (screen recordings) using FFmpeg
* Screencast using FFmpeg
* Clipboard Upload supports image or file URLs in their respective data types
* DreamObjects hosting support via Amazon S3
* Video Compression Manager (VCM) options to use Video for Windows (VfW) encoders

2
ShareX/Forms/AfterUploadForm.cs
View file

@ -48,7 +48,7 @@ public AfterUploadForm(TaskInfo info)
InitializeComponent();
Icon = ShareXResources.Icon;
Info = info;
if (Info.TaskSettings.AdvancedSettings.AutoCloseAfterUploadForm) tmrClose.Start();
if (Info.TaskSettings.SafeAdvancedSettings.AutoCloseAfterUploadForm) tmrClose.Start();
bool isFileExist = !string.IsNullOrEmpty(info.FilePath) && File.Exists(info.FilePath);

4
ShareX/Forms/AutoCaptureForm.cs
View file

@ -108,9 +108,9 @@ private void TakeScreenshot()
{
TaskSettings taskSettings = TaskSettings.GetDefaultTaskSettings();
taskSettings.UseDefaultAfterCaptureJob = false;
taskSettings.AfterCaptureJob = taskSettings.AfterCaptureJob.Remove(AfterCaptureTasks.AnnotateImage);
taskSettings.SafeAfterTasks.AfterCaptureJob = taskSettings.SafeAfterTasks.AfterCaptureJob.Remove(AfterCaptureTasks.AnnotateImage);
taskSettings.UseDefaultAdvancedSettings = false;
taskSettings.AdvancedSettings.DisableNotifications = true;
taskSettings.SafeAdvancedSettings.DisableNotifications = true;
UploadManager.RunImageTask(img, taskSettings);
}

54
ShareX/Forms/MainForm.cs
View file

@ -82,21 +82,21 @@ private void InitControls()
Text = Program.Title;
Icon = ShareXResources.Icon;
AddMultiEnumItems<AfterCaptureTasks>(x => Program.DefaultTaskSettings.AfterCaptureJob = Program.DefaultTaskSettings.AfterCaptureJob.Swap(x),
AddMultiEnumItems<AfterCaptureTasks>(x => Program.DefaultTaskSettings.SafeAfterTasks.AfterCaptureJob = Program.DefaultTaskSettings.SafeAfterTasks.AfterCaptureJob.Swap(x),
tsddbAfterCaptureTasks, tsmiTrayAfterCaptureTasks);
AddMultiEnumItems<AfterUploadTasks>(x => Program.DefaultTaskSettings.AfterUploadJob = Program.DefaultTaskSettings.AfterUploadJob.Swap(x),
AddMultiEnumItems<AfterUploadTasks>(x => Program.DefaultTaskSettings.SafeAfterTasks.AfterUploadJob = Program.DefaultTaskSettings.SafeAfterTasks.AfterUploadJob.Swap(x),
tsddbAfterUploadTasks, tsmiTrayAfterUploadTasks);
AddEnumItems<ImageDestination>(x => Program.DefaultTaskSettings.ImageDestination = x, tsmiImageUploaders, tsmiTrayImageUploaders);
AddEnumItems<ImageDestination>(x => Program.DefaultTaskSettings.SafeDestinations.ImageDestination = x, tsmiImageUploaders, tsmiTrayImageUploaders);
tsmiImageFileUploaders = (ToolStripDropDownItem)tsmiImageUploaders.DropDownItems[tsmiImageUploaders.DropDownItems.Count - 1];
tsmiTrayImageFileUploaders = (ToolStripDropDownItem)tsmiTrayImageUploaders.DropDownItems[tsmiTrayImageUploaders.DropDownItems.Count - 1];
AddEnumItems<FileDestination>(x => Program.DefaultTaskSettings.ImageFileDestination = x, tsmiImageFileUploaders, tsmiTrayImageFileUploaders);
AddEnumItems<TextDestination>(x => Program.DefaultTaskSettings.TextDestination = x, tsmiTextUploaders, tsmiTrayTextUploaders);
AddEnumItems<FileDestination>(x => Program.DefaultTaskSettings.SafeDestinations.ImageFileDestination = x, tsmiImageFileUploaders, tsmiTrayImageFileUploaders);
AddEnumItems<TextDestination>(x => Program.DefaultTaskSettings.SafeDestinations.TextDestination = x, tsmiTextUploaders, tsmiTrayTextUploaders);
tsmiTextFileUploaders = (ToolStripDropDownItem)tsmiTextUploaders.DropDownItems[tsmiTextUploaders.DropDownItems.Count - 1];
tsmiTrayTextFileUploaders = (ToolStripDropDownItem)tsmiTrayTextUploaders.DropDownItems[tsmiTrayTextUploaders.DropDownItems.Count - 1];
AddEnumItems<FileDestination>(x => Program.DefaultTaskSettings.TextFileDestination = x, tsmiTextFileUploaders, tsmiTrayTextFileUploaders);
AddEnumItems<FileDestination>(x => Program.DefaultTaskSettings.FileDestination = x, tsmiFileUploaders, tsmiTrayFileUploaders);
AddEnumItems<UrlShortenerType>(x => Program.DefaultTaskSettings.URLShortenerDestination = x, tsmiURLShorteners, tsmiTrayURLShorteners);
AddEnumItems<SocialNetworkingService>(x => Program.DefaultTaskSettings.SocialNetworkingServiceDestination = x, tsmiSocialServices, tsmiTraySocialServices);
AddEnumItems<FileDestination>(x => Program.DefaultTaskSettings.SafeDestinations.TextFileDestination = x, tsmiTextFileUploaders, tsmiTrayTextFileUploaders);
AddEnumItems<FileDestination>(x => Program.DefaultTaskSettings.SafeDestinations.FileDestination = x, tsmiFileUploaders, tsmiTrayFileUploaders);
AddEnumItems<UrlShortenerType>(x => Program.DefaultTaskSettings.SafeDestinations.URLShortenerDestination = x, tsmiURLShorteners, tsmiTrayURLShorteners);
AddEnumItems<SocialNetworkingService>(x => Program.DefaultTaskSettings.SafeDestinations.SocialNetworkingServiceDestination = x, tsmiSocialServices, tsmiTraySocialServices);
ImageList il = new ImageList();
il.ColorDepth = ColorDepth.Depth32Bit;
@ -395,32 +395,32 @@ private void AfterSettingsJobs()
public void UpdateMainFormSettings()
{
SetMultiEnumChecked(Program.DefaultTaskSettings.AfterCaptureJob, tsddbAfterCaptureTasks, tsmiTrayAfterCaptureTasks);
SetMultiEnumChecked(Program.DefaultTaskSettings.AfterUploadJob, tsddbAfterUploadTasks, tsmiTrayAfterUploadTasks);
SetEnumChecked(Program.DefaultTaskSettings.ImageDestination, tsmiImageUploaders, tsmiTrayImageUploaders);
SetEnumChecked(Program.DefaultTaskSettings.ImageFileDestination, tsmiImageFileUploaders, tsmiTrayImageFileUploaders);
SetEnumChecked(Program.DefaultTaskSettings.TextDestination, tsmiTextUploaders, tsmiTrayTextUploaders);
SetEnumChecked(Program.DefaultTaskSettings.TextFileDestination, tsmiTextFileUploaders, tsmiTrayTextFileUploaders);
SetEnumChecked(Program.DefaultTaskSettings.FileDestination, tsmiFileUploaders, tsmiTrayFileUploaders);
SetEnumChecked(Program.DefaultTaskSettings.URLShortenerDestination, tsmiURLShorteners, tsmiTrayURLShorteners);
SetEnumChecked(Program.DefaultTaskSettings.SocialNetworkingServiceDestination, tsmiSocialServices, tsmiTraySocialServices);
SetMultiEnumChecked(Program.DefaultTaskSettings.SafeAfterTasks.AfterCaptureJob, tsddbAfterCaptureTasks, tsmiTrayAfterCaptureTasks);
SetMultiEnumChecked(Program.DefaultTaskSettings.SafeAfterTasks.AfterUploadJob, tsddbAfterUploadTasks, tsmiTrayAfterUploadTasks);
SetEnumChecked(Program.DefaultTaskSettings.SafeDestinations.ImageDestination, tsmiImageUploaders, tsmiTrayImageUploaders);
SetEnumChecked(Program.DefaultTaskSettings.SafeDestinations.ImageFileDestination, tsmiImageFileUploaders, tsmiTrayImageFileUploaders);
SetEnumChecked(Program.DefaultTaskSettings.SafeDestinations.TextDestination, tsmiTextUploaders, tsmiTrayTextUploaders);
SetEnumChecked(Program.DefaultTaskSettings.SafeDestinations.TextFileDestination, tsmiTextFileUploaders, tsmiTrayTextFileUploaders);
SetEnumChecked(Program.DefaultTaskSettings.SafeDestinations.FileDestination, tsmiFileUploaders, tsmiTrayFileUploaders);
SetEnumChecked(Program.DefaultTaskSettings.SafeDestinations.URLShortenerDestination, tsmiURLShorteners, tsmiTrayURLShorteners);
SetEnumChecked(Program.DefaultTaskSettings.SafeDestinations.SocialNetworkingServiceDestination, tsmiSocialServices, tsmiTraySocialServices);
}
private void UpdateUploaderMenuNames()
{
string imageUploader = Program.DefaultTaskSettings.ImageDestination == ImageDestination.FileUploader ?
Program.DefaultTaskSettings.ImageFileDestination.GetDescription() : Program.DefaultTaskSettings.ImageDestination.GetDescription();
string imageUploader = Program.DefaultTaskSettings.SafeDestinations.ImageDestination == ImageDestination.FileUploader ?
Program.DefaultTaskSettings.SafeDestinations.ImageFileDestination.GetDescription() : Program.DefaultTaskSettings.SafeDestinations.ImageDestination.GetDescription();
tsmiImageUploaders.Text = tsmiTrayImageUploaders.Text = "Image uploader: " + imageUploader;
string textUploader = Program.DefaultTaskSettings.TextDestination == TextDestination.FileUploader ?
Program.DefaultTaskSettings.TextFileDestination.GetDescription() : Program.DefaultTaskSettings.TextDestination.GetDescription();
string textUploader = Program.DefaultTaskSettings.SafeDestinations.TextDestination == TextDestination.FileUploader ?
Program.DefaultTaskSettings.SafeDestinations.TextFileDestination.GetDescription() : Program.DefaultTaskSettings.SafeDestinations.TextDestination.GetDescription();
tsmiTextUploaders.Text = tsmiTrayTextUploaders.Text = "Text uploader: " + textUploader;
tsmiFileUploaders.Text = tsmiTrayFileUploaders.Text = "File uploader: " + Program.DefaultTaskSettings.FileDestination.GetDescription();
tsmiFileUploaders.Text = tsmiTrayFileUploaders.Text = "File uploader: " + Program.DefaultTaskSettings.SafeDestinations.FileDestination.GetDescription();
tsmiURLShorteners.Text = tsmiTrayURLShorteners.Text = "URL shortener: " + Program.DefaultTaskSettings.URLShortenerDestination.GetDescription();
tsmiURLShorteners.Text = tsmiTrayURLShorteners.Text = "URL shortener: " + Program.DefaultTaskSettings.SafeDestinations.URLShortenerDestination.GetDescription();
tsmiSocialServices.Text = tsmiTraySocialServices.Text = "Social networking service: " + Program.DefaultTaskSettings.SocialNetworkingServiceDestination.GetDescription();
tsmiSocialServices.Text = tsmiTraySocialServices.Text = "Social networking service: " + Program.DefaultTaskSettings.SafeDestinations.SocialNetworkingServiceDestination.GetDescription();
}
private void AutoCheckUpdate()
@ -658,12 +658,12 @@ private void tsmiTestUploaders_Click(object sender, EventArgs e)
private void tsmiTestShapeCapture_Click(object sender, EventArgs e)
{
new RegionCapturePreview(Program.DefaultTaskSettings.CaptureSettings.SurfaceOptions).Show();
new RegionCapturePreview(Program.DefaultTaskSettings.SafeCaptureSettings.SurfaceOptions).Show();
}
private void tsmiScreenRecorder_Click(object sender, EventArgs e)
{
TaskHelpers.DoScreenRecorder();
TaskHelpers.DoScreenRecorder(Program.DefaultTaskSettings);
}
private void tsmiAutoCapture_Click(object sender, EventArgs e)

42
ShareX/Forms/MainForm_Capture.cs
View file

@ -185,9 +185,9 @@ private void DoCapture(ScreenCaptureDelegate capture, CaptureType captureType, T
{
if (taskSettings == null) taskSettings = TaskSettings.GetDefaultTaskSettings();
if (taskSettings.CaptureSettings.IsDelayScreenshot && taskSettings.CaptureSettings.DelayScreenshot > 0)
if (taskSettings.SafeCaptureSettings.IsDelayScreenshot && taskSettings.SafeCaptureSettings.DelayScreenshot > 0)
{
int sleep = (int)(taskSettings.CaptureSettings.DelayScreenshot * 1000);
int sleep = (int)(taskSettings.SafeCaptureSettings.DelayScreenshot * 1000);
BackgroundWorker bw = new BackgroundWorker();
bw.DoWork += (sender, e) => Thread.Sleep(sleep);
bw.RunWorkerCompleted += (sender, e) => DoCaptureWork(capture, captureType, taskSettings, autoHideForm);
@ -211,11 +211,11 @@ private void DoCaptureWork(ScreenCaptureDelegate capture, CaptureType captureTyp
try
{
Screenshot.CaptureCursor = taskSettings.CaptureSettings.ShowCursor;
Screenshot.CaptureShadow = taskSettings.CaptureSettings.CaptureShadow;
Screenshot.ShadowOffset = taskSettings.CaptureSettings.CaptureShadowOffset;
Screenshot.CaptureClientArea = taskSettings.CaptureSettings.CaptureClientArea;
Screenshot.AutoHideTaskbar = taskSettings.CaptureSettings.CaptureAutoHideTaskbar;
Screenshot.CaptureCursor = taskSettings.SafeCaptureSettings.ShowCursor;
Screenshot.CaptureShadow = taskSettings.SafeCaptureSettings.CaptureShadow;
Screenshot.ShadowOffset = taskSettings.SafeCaptureSettings.CaptureShadowOffset;
Screenshot.CaptureClientArea = taskSettings.SafeCaptureSettings.CaptureClientArea;
Screenshot.AutoHideTaskbar = taskSettings.SafeCaptureSettings.CaptureAutoHideTaskbar;
img = capture();
}
@ -238,29 +238,29 @@ private void AfterCapture(Image img, CaptureType captureType, TaskSettings taskS
{
if (img != null)
{
if (taskSettings.GeneralSettings.PlaySoundAfterCapture)
if (taskSettings.SafeGeneralSettings.PlaySoundAfterCapture)
{
Helpers.PlaySoundAsync(Resources.CameraSound);
}
if (taskSettings.ImageSettings.ImageEffectOnlyRegionCapture && !IsRegionCapture(captureType))
if (taskSettings.SafeImageSettings.ImageEffectOnlyRegionCapture && !IsRegionCapture(captureType))
{
taskSettings.AfterCaptureJob = taskSettings.AfterCaptureJob.Remove(AfterCaptureTasks.AddImageEffects);
taskSettings.SafeAfterTasks.AfterCaptureJob = taskSettings.SafeAfterTasks.AfterCaptureJob.Remove(AfterCaptureTasks.AddImageEffects);
}
if (taskSettings.GeneralSettings.ShowAfterCaptureTasksForm)
if (taskSettings.SafeGeneralSettings.ShowAfterCaptureTasksForm)
{
using (AfterCaptureForm afterCaptureForm = new AfterCaptureForm(img, taskSettings.AfterCaptureJob))
using (AfterCaptureForm afterCaptureForm = new AfterCaptureForm(img, taskSettings.SafeAfterTasks.AfterCaptureJob))
{
afterCaptureForm.ShowDialog();
switch (afterCaptureForm.Result)
{
case AfterCaptureFormResult.Continue:
taskSettings.AfterCaptureJob = afterCaptureForm.AfterCaptureTasks;
taskSettings.SafeAfterTasks.AfterCaptureJob = afterCaptureForm.AfterCaptureTasks;
break;
case AfterCaptureFormResult.Copy:
taskSettings.AfterCaptureJob = AfterCaptureTasks.CopyImageToClipboard;
taskSettings.SafeAfterTasks.AfterCaptureJob = AfterCaptureTasks.CopyImageToClipboard;
break;
case AfterCaptureFormResult.Cancel:
if (img != null) img.Dispose();
@ -295,7 +295,7 @@ private void CaptureActiveWindow(TaskSettings taskSettings, bool autoHideForm =
}
}
if (taskSettings.CaptureSettings.CaptureTransparent && !taskSettings.CaptureSettings.CaptureClientArea)
if (taskSettings.SafeCaptureSettings.CaptureTransparent && !taskSettings.SafeCaptureSettings.CaptureClientArea)
{
img = Screenshot.CaptureActiveWindowTransparent();
}
@ -330,7 +330,7 @@ private void CaptureWindow(IntPtr handle, TaskSettings taskSettings = null, bool
NativeMethods.SetForegroundWindow(handle);
Thread.Sleep(250);
if (taskSettings.CaptureSettings.CaptureTransparent && !taskSettings.CaptureSettings.CaptureClientArea)
if (taskSettings.SafeCaptureSettings.CaptureTransparent && !taskSettings.SafeCaptureSettings.CaptureClientArea)
{
return Screenshot.CaptureWindowTransparent(handle);
}
@ -347,7 +347,7 @@ private void CaptureRegion(CaptureType captureType, TaskSettings taskSettings, b
{
default:
case CaptureType.Rectangle:
if (taskSettings.AdvancedSettings.UseLightRectangleCrop)
if (taskSettings.SafeAdvancedSettings.UseLightRectangleCrop)
{
CaptureLightRectangle(taskSettings, autoHideForm);
return;
@ -387,7 +387,7 @@ private void CaptureRegion(CaptureType captureType, TaskSettings taskSettings, b
try
{
surface.Config = taskSettings.CaptureSettings.SurfaceOptions;
surface.Config = taskSettings.SafeCaptureSettings.SurfaceOptions;
surface.SurfaceImage = screenshot;
surface.Prepare();
surface.ShowDialog();
@ -431,17 +431,17 @@ private void CaptureLightRectangle(TaskSettings taskSettings, bool autoHideForm
private void CaptureLastRegion(TaskSettings taskSettings, bool autoHideForm = true)
{
if (!taskSettings.AdvancedSettings.UseLightRectangleCrop && Surface.LastRegionFillPath != null)
if (!taskSettings.SafeAdvancedSettings.UseLightRectangleCrop && Surface.LastRegionFillPath != null)
{
DoCapture(() =>
{
using (Image screenshot = Screenshot.CaptureFullscreen())
{
return ShapeCaptureHelpers.GetRegionImage(screenshot, Surface.LastRegionFillPath, Surface.LastRegionDrawPath, taskSettings.CaptureSettings.SurfaceOptions);
return ShapeCaptureHelpers.GetRegionImage(screenshot, Surface.LastRegionFillPath, Surface.LastRegionDrawPath, taskSettings.SafeCaptureSettings.SurfaceOptions);
}
}, CaptureType.LastRegion, taskSettings, autoHideForm);
}
else if (taskSettings.AdvancedSettings.UseLightRectangleCrop && !RectangleLight.LastSelectionRectangle0Based.IsEmpty)
else if (taskSettings.SafeAdvancedSettings.UseLightRectangleCrop && !RectangleLight.LastSelectionRectangle0Based.IsEmpty)
{
DoCapture(() =>
{

2
ShareX/Forms/ScreenColorPicker.cs
View file

@ -48,7 +48,7 @@ public ScreenColorPicker(TaskSettings taskSettings)
{
if (taskSettings != null)
{
surfaceOptions = taskSettings.CaptureSettings.SurfaceOptions;
surfaceOptions = taskSettings.SafeCaptureSettings.SurfaceOptions;
}
else
{

56
ShareX/Forms/ScreenRecordForm.cs
View file

@ -84,27 +84,29 @@ private void SelectRegion()
public async void StartRecording(TaskSettings TaskSettings)
{
if (TaskSettings.CaptureSettings.RunScreencastCLI)
if (TaskSettings.SafeCaptureSettings.RunScreencastCLI)
{
if (!Program.Settings.VideoEncoders.IsValidIndex(TaskSettings.CaptureSettings.VideoEncoderSelected))
if (!Program.Settings.VideoEncoders.IsValidIndex(TaskSettings.SafeCaptureSettings.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())
else if (!Program.Settings.VideoEncoders[TaskSettings.SafeCaptureSettings.VideoEncoderSelected].IsValid())
{
MessageBox.Show("CLI video encoder file does not exist: " + Program.Settings.VideoEncoders[TaskSettings.CaptureSettings.VideoEncoderSelected].Path,
MessageBox.Show("CLI video encoder file does not exist: " + Program.Settings.VideoEncoders[TaskSettings.SafeCaptureSettings.VideoEncoderSelected].Path,
Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Warning);
return;
}
}
if (TaskSettings.CaptureSettings.ScreenRecordOutput == ScreenRecordOutput.FFmpeg && !File.Exists(TaskSettings.CaptureSettings.FFmpegOptions.CLIPath))
if (TaskSettings.SafeCaptureSettings.ScreenRecordOutput == ScreenRecordOutput.FFmpeg && !File.Exists(TaskSettings.SafeCaptureSettings.FFmpegOptions.CLIPath))
{
if (MessageBox.Show(TaskSettings.CaptureSettings.FFmpegOptions.CLIPath + " 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 (MessageBox.Show(TaskSettings.SafeCaptureSettings.FFmpegOptions.CLIPath + " does not exist." + Environment.NewLine + Environment.NewLine + "Would you like to automatically download it?",
Application.ProductName + " - Missing ffmpeg.exe", MessageBoxButtons.YesNo, MessageBoxIcon.Warning) == System.Windows.Forms.DialogResult.Yes)
{
using (FFmpegOptionsForm form = new FFmpegOptionsForm(TaskSettings.CaptureSettings.FFmpegOptions))
TaskSettings.SafeCaptureSettings.FFmpegOptions.CLIPath = Path.Combine(Program.ToolsFolder, "ffmpeg.exe");
using (FFmpegOptionsForm form = new FFmpegOptionsForm(TaskSettings.SafeCaptureSettings.FFmpegOptions))
{
if (form.DownloadFFmpeg(false) == DialogResult.Cancel)
{
@ -119,7 +121,7 @@ public async void StartRecording(TaskSettings TaskSettings)
}
SelectRegion();
Screenshot.CaptureCursor = TaskSettings.CaptureSettings.ShowCursor;
Screenshot.CaptureCursor = TaskSettings.SafeCaptureSettings.ShowCursor;
if (IsRecording || CaptureRectangle.IsEmpty || screenRecorder != null)
{
@ -141,13 +143,13 @@ public async void StartRecording(TaskSettings TaskSettings)
await TaskEx.Run(() =>
{
if (TaskSettings.CaptureSettings.ScreenRecordOutput == ScreenRecordOutput.AVI)
if (TaskSettings.SafeCaptureSettings.ScreenRecordOutput == ScreenRecordOutput.AVI)
{
path = Path.Combine(TaskSettings.CaptureFolder, TaskHelpers.GetFilename(TaskSettings, "avi"));
}
else if (TaskSettings.CaptureSettings.ScreenRecordOutput == ScreenRecordOutput.FFmpeg)
else if (TaskSettings.SafeCaptureSettings.ScreenRecordOutput == ScreenRecordOutput.FFmpeg)
{
path = Path.Combine(TaskSettings.CaptureFolder, TaskHelpers.GetFilename(TaskSettings, TaskSettings.CaptureSettings.FFmpegOptions.Extension));
path = Path.Combine(TaskSettings.CaptureFolder, TaskHelpers.GetFilename(TaskSettings, TaskSettings.SafeCaptureSettings.FFmpegOptions.Extension));
}
else
{
@ -157,17 +159,17 @@ await TaskEx.Run(() =>
ScreencastOptions options = new ScreencastOptions()
{
CaptureArea = CaptureRectangle,
FPS = TaskSettings.CaptureSettings.ScreenRecordFPS,
FPS = TaskSettings.SafeCaptureSettings.ScreenRecordFPS,
OutputPath = path,
Duration = TaskSettings.CaptureSettings.ScreenRecordFixedDuration ? TaskSettings.CaptureSettings.ScreenRecordDuration : 0,
AVI = TaskSettings.CaptureSettings.AVIOptions,
FFmpeg = TaskSettings.CaptureSettings.FFmpegOptions,
DrawCursor = TaskSettings.CaptureSettings.ShowCursor
Duration = TaskSettings.SafeCaptureSettings.ScreenRecordFixedDuration ? TaskSettings.SafeCaptureSettings.ScreenRecordDuration : 0,
AVI = TaskSettings.SafeCaptureSettings.AVIOptions,
FFmpeg = TaskSettings.SafeCaptureSettings.FFmpegOptions,
DrawCursor = TaskSettings.SafeCaptureSettings.ShowCursor
};
screenRecorder = new ScreenRecorder(options, CaptureRectangle, TaskSettings.CaptureSettings.ScreenRecordOutput);
screenRecorder = new ScreenRecorder(options, CaptureRectangle, TaskSettings.SafeCaptureSettings.ScreenRecordOutput);
int delay = (int)(TaskSettings.CaptureSettings.ScreenRecordStartDelay * 1000);
int delay = (int)(TaskSettings.SafeCaptureSettings.ScreenRecordStartDelay * 1000);
if (delay > 0)
{
@ -190,9 +192,9 @@ await TaskEx.Run(() =>
{
string sourceFilePath = path;
if (TaskSettings.CaptureSettings.ScreenRecordOutput == ScreenRecordOutput.GIF)
if (TaskSettings.SafeCaptureSettings.ScreenRecordOutput == ScreenRecordOutput.GIF)
{
if (TaskSettings.CaptureSettings.RunScreencastCLI)
if (TaskSettings.SafeCaptureSettings.RunScreencastCLI)
{
sourceFilePath = Path.ChangeExtension(Program.ScreenRecorderCacheFilePath, "gif");
}
@ -200,12 +202,12 @@ await TaskEx.Run(() =>
{
sourceFilePath = path = Path.Combine(TaskSettings.CaptureFolder, TaskHelpers.GetFilename(TaskSettings, "gif"));
}
screenRecorder.SaveAsGIF(sourceFilePath, TaskSettings.ImageSettings.ImageGIFQuality);
screenRecorder.SaveAsGIF(sourceFilePath, TaskSettings.SafeImageSettings.ImageGIFQuality);
}
if (TaskSettings.CaptureSettings.RunScreencastCLI)
if (TaskSettings.SafeCaptureSettings.RunScreencastCLI)
{
VideoEncoder encoder = Program.Settings.VideoEncoders[TaskSettings.CaptureSettings.VideoEncoderSelected];
VideoEncoder encoder = Program.Settings.VideoEncoders[TaskSettings.SafeCaptureSettings.VideoEncoderSelected];
path = Path.Combine(TaskSettings.CaptureFolder, TaskHelpers.GetFilename(TaskSettings, encoder.OutputExtension));
screenRecorder.EncodeUsingCommandLine(encoder, sourceFilePath, path);
}
@ -216,7 +218,7 @@ await TaskEx.Run(() =>
{
if (screenRecorder != null)
{
if (TaskSettings.CaptureSettings.RunScreencastCLI &&
if (TaskSettings.SafeCaptureSettings.RunScreencastCLI &&
!string.IsNullOrEmpty(screenRecorder.CachePath) && File.Exists(screenRecorder.CachePath))
{
File.Delete(screenRecorder.CachePath);
@ -234,13 +236,13 @@ await TaskEx.Run(() =>
if (!string.IsNullOrEmpty(path) && File.Exists(path))
{
if (TaskSettings.AfterCaptureJob.HasFlag(AfterCaptureTasks.UploadImageToHost))
if (TaskSettings.SafeAfterTasks.AfterCaptureJob.HasFlag(AfterCaptureTasks.UploadImageToHost))
{
UploadManager.UploadFile(path, TaskSettings);
}
else
{
if (TaskSettings.AfterCaptureJob.HasFlag(AfterCaptureTasks.CopyFilePathToClipboard))
if (TaskSettings.SafeAfterTasks.AfterCaptureJob.HasFlag(AfterCaptureTasks.CopyFilePathToClipboard))
{
ClipboardHelpers.CopyText(path);
}

32
ShareX/Forms/TaskSettingsForm.Designer.cs generated
View file

@ -163,6 +163,7 @@ private void InitializeComponent()
this.tpAdvanced = new System.Windows.Forms.TabPage();
this.pgTaskSettings = new System.Windows.Forms.PropertyGrid();
this.chkUseDefaultAdvancedSettings = new System.Windows.Forms.CheckBox();
this.ttTaskSettings = new System.Windows.Forms.ToolTip(this.components);
this.tcHotkeySettings.SuspendLayout();
this.tpTask.SuspendLayout();
this.cmsDestinations.SuspendLayout();
@ -214,9 +215,9 @@ private void InitializeComponent()
this.cbUseDefaultAfterCaptureSettings.AutoSize = true;
this.cbUseDefaultAfterCaptureSettings.Location = new System.Drawing.Point(6, 70);
this.cbUseDefaultAfterCaptureSettings.Name = "cbUseDefaultAfterCaptureSettings";
this.cbUseDefaultAfterCaptureSettings.Size = new System.Drawing.Size(193, 17);
this.cbUseDefaultAfterCaptureSettings.Size = new System.Drawing.Size(222, 17);
this.cbUseDefaultAfterCaptureSettings.TabIndex = 3;
this.cbUseDefaultAfterCaptureSettings.Text = "Use default \"After capture\" settings";
this.cbUseDefaultAfterCaptureSettings.Text = "Use main window \"After capture\" settings";
this.cbUseDefaultAfterCaptureSettings.UseVisualStyleBackColor = true;
this.cbUseDefaultAfterCaptureSettings.CheckedChanged += new System.EventHandler(this.cbUseDefaultAfterCaptureSettings_CheckedChanged);
//
@ -225,9 +226,9 @@ private void InitializeComponent()
this.cbUseDefaultAfterUploadSettings.AutoSize = true;
this.cbUseDefaultAfterUploadSettings.Location = new System.Drawing.Point(6, 126);
this.cbUseDefaultAfterUploadSettings.Name = "cbUseDefaultAfterUploadSettings";
this.cbUseDefaultAfterUploadSettings.Size = new System.Drawing.Size(189, 17);
this.cbUseDefaultAfterUploadSettings.Size = new System.Drawing.Size(218, 17);
this.cbUseDefaultAfterUploadSettings.TabIndex = 5;
this.cbUseDefaultAfterUploadSettings.Text = "Use default \"After upload\" settings";
this.cbUseDefaultAfterUploadSettings.Text = "Use main window \"After upload\" settings";
this.cbUseDefaultAfterUploadSettings.UseVisualStyleBackColor = true;
this.cbUseDefaultAfterUploadSettings.CheckedChanged += new System.EventHandler(this.cbUseDefaultAfterUploadSettings_CheckedChanged);
//
@ -236,9 +237,9 @@ private void InitializeComponent()
this.cbUseDefaultDestinationSettings.AutoSize = true;
this.cbUseDefaultDestinationSettings.Location = new System.Drawing.Point(6, 182);
this.cbUseDefaultDestinationSettings.Name = "cbUseDefaultDestinationSettings";
this.cbUseDefaultDestinationSettings.Size = new System.Drawing.Size(185, 17);
this.cbUseDefaultDestinationSettings.Size = new System.Drawing.Size(214, 17);
this.cbUseDefaultDestinationSettings.TabIndex = 7;
this.cbUseDefaultDestinationSettings.Text = "Use default \"Destination\" settings";
this.cbUseDefaultDestinationSettings.Text = "Use main window \"Destination\" settings";
this.cbUseDefaultDestinationSettings.UseVisualStyleBackColor = true;
this.cbUseDefaultDestinationSettings.CheckedChanged += new System.EventHandler(this.cbUseDefaultDestinationSettings_CheckedChanged);
//
@ -532,7 +533,7 @@ private void InitializeComponent()
this.chkUseDefaultGeneralSettings.Padding = new System.Windows.Forms.Padding(5);
this.chkUseDefaultGeneralSettings.Size = new System.Drawing.Size(544, 27);
this.chkUseDefaultGeneralSettings.TabIndex = 20;
this.chkUseDefaultGeneralSettings.Text = "Use default general settings";
this.chkUseDefaultGeneralSettings.Text = "Use general settings in main window task settings";
this.chkUseDefaultGeneralSettings.UseVisualStyleBackColor = true;
this.chkUseDefaultGeneralSettings.CheckedChanged += new System.EventHandler(this.chkUseDefaultGeneralSettings_CheckedChanged);
//
@ -924,7 +925,7 @@ private void InitializeComponent()
this.chkUseDefaultImageSettings.Padding = new System.Windows.Forms.Padding(5);
this.chkUseDefaultImageSettings.Size = new System.Drawing.Size(544, 27);
this.chkUseDefaultImageSettings.TabIndex = 0;
this.chkUseDefaultImageSettings.Text = "Use default image settings";
this.chkUseDefaultImageSettings.Text = "Use image settings in main window task settings";
this.chkUseDefaultImageSettings.UseVisualStyleBackColor = true;
this.chkUseDefaultImageSettings.CheckedChanged += new System.EventHandler(this.chkUseDefaultImageSettings_CheckedChanged);
//
@ -1149,10 +1150,10 @@ private void InitializeComponent()
this.lblScreenRecorderCLI.TabIndex = 13;
this.lblScreenRecorderCLI.Text = "CLI:";
//
// btnScreenRecorderAVIOptions
// btnScreenRecorderOptions
//
this.btnScreenRecorderOptions.Location = new System.Drawing.Point(320, 11);
this.btnScreenRecorderOptions.Name = "btnScreenRecorderAVIOptions";
this.btnScreenRecorderOptions.Name = "btnScreenRecorderOptions";
this.btnScreenRecorderOptions.Size = new System.Drawing.Size(64, 23);
this.btnScreenRecorderOptions.TabIndex = 12;
this.btnScreenRecorderOptions.Text = "Options...";
@ -1317,7 +1318,7 @@ private void InitializeComponent()
this.chkUseDefaultCaptureSettings.Padding = new System.Windows.Forms.Padding(5);
this.chkUseDefaultCaptureSettings.Size = new System.Drawing.Size(544, 27);
this.chkUseDefaultCaptureSettings.TabIndex = 0;
this.chkUseDefaultCaptureSettings.Text = "Use default capture settings";
this.chkUseDefaultCaptureSettings.Text = "Use capture settings in main window task settings";
this.chkUseDefaultCaptureSettings.UseVisualStyleBackColor = true;
this.chkUseDefaultCaptureSettings.CheckedChanged += new System.EventHandler(this.chkUseDefaultCaptureSettings_CheckedChanged);
//
@ -1419,7 +1420,7 @@ private void InitializeComponent()
this.chkUseDefaultActions.Padding = new System.Windows.Forms.Padding(5);
this.chkUseDefaultActions.Size = new System.Drawing.Size(544, 27);
this.chkUseDefaultActions.TabIndex = 0;
this.chkUseDefaultActions.Text = "Use default actions";
this.chkUseDefaultActions.Text = "Use actions in main window task settings";
this.chkUseDefaultActions.UseVisualStyleBackColor = true;
this.chkUseDefaultActions.CheckedChanged += new System.EventHandler(this.chkUseDefaultActions_CheckedChanged);
//
@ -1669,7 +1670,7 @@ private void InitializeComponent()
this.chkUseDefaultUploadSettings.Padding = new System.Windows.Forms.Padding(5);
this.chkUseDefaultUploadSettings.Size = new System.Drawing.Size(544, 27);
this.chkUseDefaultUploadSettings.TabIndex = 0;
this.chkUseDefaultUploadSettings.Text = "Use default upload settings";
this.chkUseDefaultUploadSettings.Text = "Use upload settings in main window task settings";
this.chkUseDefaultUploadSettings.UseVisualStyleBackColor = true;
this.chkUseDefaultUploadSettings.CheckedChanged += new System.EventHandler(this.chkUseDefaultUploadSettings_CheckedChanged);
//
@ -1706,7 +1707,7 @@ private void InitializeComponent()
this.chkUseDefaultIndexerSettings.Padding = new System.Windows.Forms.Padding(5);
this.chkUseDefaultIndexerSettings.Size = new System.Drawing.Size(544, 27);
this.chkUseDefaultIndexerSettings.TabIndex = 1;
this.chkUseDefaultIndexerSettings.Text = "Use default indexer settings";
this.chkUseDefaultIndexerSettings.Text = "Use indexer settings in main window task settings";
this.chkUseDefaultIndexerSettings.UseVisualStyleBackColor = true;
this.chkUseDefaultIndexerSettings.CheckedChanged += new System.EventHandler(this.chkUseDefaultIndexerSettings_CheckedChanged);
//
@ -1743,7 +1744,7 @@ private void InitializeComponent()
this.chkUseDefaultAdvancedSettings.Padding = new System.Windows.Forms.Padding(5);
this.chkUseDefaultAdvancedSettings.Size = new System.Drawing.Size(544, 27);
this.chkUseDefaultAdvancedSettings.TabIndex = 0;
this.chkUseDefaultAdvancedSettings.Text = "Use default advanced settings";
this.chkUseDefaultAdvancedSettings.Text = "Use advanced settings in main window task settings";
this.chkUseDefaultAdvancedSettings.UseVisualStyleBackColor = true;
this.chkUseDefaultAdvancedSettings.CheckedChanged += new System.EventHandler(this.chkUseDefaultAdvancedSettings_CheckedChanged);
//
@ -1953,6 +1954,7 @@ private void InitializeComponent()
private System.Windows.Forms.Label lblScreenRecorderCLI;
private System.Windows.Forms.CheckBox chkRunScreencastCLI;
private System.Windows.Forms.CheckBox chkClipboardUploadContents;
private System.Windows.Forms.ToolTip ttTaskSettings;

407
ShareX/Forms/TaskSettingsForm.cs
View file

@ -78,101 +78,7 @@ public TaskSettingsForm(TaskSettings hotkeySetting, bool isDefault = false)
}
AddEnumItemsContextMenu<HotkeyType>(x => TaskSettings.Job = x, cmsTask);
AddMultiEnumItemsContextMenu<AfterCaptureTasks>(x => TaskSettings.AfterCaptureJob = TaskSettings.AfterCaptureJob.Swap(x), cmsAfterCapture);
AddMultiEnumItemsContextMenu<AfterUploadTasks>(x => TaskSettings.AfterUploadJob = TaskSettings.AfterUploadJob.Swap(x), cmsAfterUpload);
AddEnumItems<ImageDestination>(x => TaskSettings.ImageDestination = x, tsmiImageUploaders);
tsmiImageFileUploaders = (ToolStripDropDownItem)tsmiImageUploaders.DropDownItems[tsmiImageUploaders.DropDownItems.Count - 1];
AddEnumItems<FileDestination>(x => TaskSettings.ImageFileDestination = x, tsmiImageFileUploaders);
AddEnumItems<TextDestination>(x => TaskSettings.TextDestination = x, tsmiTextUploaders);
tsmiTextFileUploaders = (ToolStripDropDownItem)tsmiTextUploaders.DropDownItems[tsmiTextUploaders.DropDownItems.Count - 1];
AddEnumItems<FileDestination>(x => TaskSettings.TextFileDestination = x, tsmiTextFileUploaders);
AddEnumItems<FileDestination>(x => TaskSettings.FileDestination = x, tsmiFileUploaders);
AddEnumItems<UrlShortenerType>(x => TaskSettings.URLShortenerDestination = x, tsmiURLShorteners);
AddEnumItems<SocialNetworkingService>(x => TaskSettings.SocialNetworkingServiceDestination = x, tsmiSocialServices);
SetEnumCheckedContextMenu(TaskSettings.Job, cmsTask);
SetMultiEnumCheckedContextMenu(TaskSettings.AfterCaptureJob, cmsAfterCapture);
SetMultiEnumCheckedContextMenu(TaskSettings.AfterUploadJob, cmsAfterUpload);
SetEnumChecked(TaskSettings.ImageDestination, tsmiImageUploaders);
SetEnumChecked(TaskSettings.ImageFileDestination, tsmiImageFileUploaders);
SetEnumChecked(TaskSettings.TextDestination, tsmiTextUploaders);
SetEnumChecked(TaskSettings.TextFileDestination, tsmiTextFileUploaders);
SetEnumChecked(TaskSettings.FileDestination, tsmiFileUploaders);
SetEnumChecked(TaskSettings.URLShortenerDestination, tsmiURLShorteners);
SetEnumChecked(TaskSettings.SocialNetworkingServiceDestination, tsmiSocialServices);
// FTP
if (Program.UploadersConfig != null && Program.UploadersConfig.FTPAccountList.Count > 1)
{
chkOverrideFTP.Checked = TaskSettings.OverrideFTP;
cboFTPaccounts.Items.Clear();
cboFTPaccounts.Items.AddRange(Program.UploadersConfig.FTPAccountList.ToArray());
cboFTPaccounts.SelectedIndex = TaskSettings.FTPIndex.BetweenOrDefault(0, Program.UploadersConfig.FTPAccountList.Count - 1);
}
UpdateDestinationStates();
UpdateUploaderMenuNames();
// General
cbPlaySoundAfterCapture.Checked = TaskSettings.GeneralSettings.PlaySoundAfterCapture;
cbShowAfterCaptureTasksForm.Checked = TaskSettings.GeneralSettings.ShowAfterCaptureTasksForm;
cbPlaySoundAfterUpload.Checked = TaskSettings.GeneralSettings.PlaySoundAfterUpload;
chkShowAfterUploadForm.Checked = TaskSettings.GeneralSettings.ShowAfterUploadForm;
cboPopUpNotification.Items.Clear();
cboPopUpNotification.Items.AddRange(Helpers.GetEnumDescriptions<PopUpNotificationType>());
cboPopUpNotification.SelectedIndex = (int)TaskSettings.GeneralSettings.PopUpNotification;
cbHistorySave.Checked = TaskSettings.GeneralSettings.SaveHistory;
// Image - General
cbImageFormat.SelectedIndex = (int)TaskSettings.ImageSettings.ImageFormat;
nudImageJPEGQuality.Value = TaskSettings.ImageSettings.ImageJPEGQuality;
cbImageGIFQuality.SelectedIndex = (int)TaskSettings.ImageSettings.ImageGIFQuality;
nudUseImageFormat2After.Value = TaskSettings.ImageSettings.ImageSizeLimit;
cbImageFormat2.SelectedIndex = (int)TaskSettings.ImageSettings.ImageFormat2;
cbImageFileExist.Items.Clear();
cbImageFileExist.Items.AddRange(Helpers.GetEnumDescriptions<FileExistAction>());
cbImageFileExist.SelectedIndex = (int)TaskSettings.ImageSettings.FileExistAction;
// Image - Effects
chkShowImageEffectsWindowAfterCapture.Checked = TaskSettings.ImageSettings.ShowImageEffectsWindowAfterCapture;
cbImageEffectOnlyRegionCapture.Checked = TaskSettings.ImageSettings.ImageEffectOnlyRegionCapture;
// Image - Thumbnail
nudThumbnailWidth.Value = TaskSettings.ImageSettings.ThumbnailWidth;
nudThumbnailHeight.Value = TaskSettings.ImageSettings.ThumbnailHeight;
txtThumbnailName.Text = TaskSettings.ImageSettings.ThumbnailName;
lblThumbnailNamePreview.Text = "ImageName" + TaskSettings.ImageSettings.ThumbnailName + ".jpg";
cbThumbnailIfSmaller.Checked = TaskSettings.ImageSettings.ThumbnailCheckSize;
// Capture
cbShowCursor.Checked = TaskSettings.CaptureSettings.ShowCursor;
cbCaptureTransparent.Checked = TaskSettings.CaptureSettings.CaptureTransparent;
cbCaptureShadow.Enabled = TaskSettings.CaptureSettings.CaptureTransparent;
cbCaptureShadow.Checked = TaskSettings.CaptureSettings.CaptureShadow;
nudCaptureShadowOffset.Value = TaskSettings.CaptureSettings.CaptureShadowOffset;
cbCaptureClientArea.Checked = TaskSettings.CaptureSettings.CaptureClientArea;
cbScreenshotDelay.Checked = TaskSettings.CaptureSettings.IsDelayScreenshot;
nudScreenshotDelay.Value = TaskSettings.CaptureSettings.DelayScreenshot;
cbCaptureAutoHideTaskbar.Checked = TaskSettings.CaptureSettings.CaptureAutoHideTaskbar;
if (TaskSettings.CaptureSettings.SurfaceOptions == null) TaskSettings.CaptureSettings.SurfaceOptions = new SurfaceOptions();
pgShapesCapture.SelectedObject = TaskSettings.CaptureSettings.SurfaceOptions;
// Capture / Screen recorder
cbScreenRecorderOutput.Items.AddRange(Helpers.GetEnumDescriptions<ScreenRecordOutput>());
cbScreenRecorderOutput.SelectedIndex = (int)TaskSettings.CaptureSettings.ScreenRecordOutput;
chkRunScreencastCLI.Checked = TaskSettings.CaptureSettings.RunScreencastCLI;
UpdateVideoEncoders();
nudScreenRecorderFPS.Value = TaskSettings.CaptureSettings.ScreenRecordFPS;
cbScreenRecorderFixedDuration.Checked = TaskSettings.CaptureSettings.ScreenRecordFixedDuration;
nudScreenRecorderDuration.Enabled = TaskSettings.CaptureSettings.ScreenRecordFixedDuration;
nudScreenRecorderDuration.Value = (decimal)TaskSettings.CaptureSettings.ScreenRecordDuration;
nudScreenRecorderStartDelay.Value = (decimal)TaskSettings.CaptureSettings.ScreenRecordStartDelay;
// Actions
TaskHelpers.AddDefaultExternalPrograms(TaskSettings);
TaskSettings.ExternalPrograms.ForEach(x => AddFileAction(x));
// Watch folders
cbWatchFolderEnabled.Checked = TaskSettings.WatchFolderEnabled;
@ -189,24 +95,6 @@ public TaskSettingsForm(TaskSettings hotkeySetting, bool isDefault = false)
}
}
// Upload / Name pattern
txtNameFormatPattern.Text = TaskSettings.UploadSettings.NameFormatPattern;
txtNameFormatPatternActiveWindow.Text = TaskSettings.UploadSettings.NameFormatPatternActiveWindow;
NameParser.CreateCodesMenu(txtNameFormatPattern, ReplacementVariables.n);
NameParser.CreateCodesMenu(txtNameFormatPatternActiveWindow, ReplacementVariables.n);
cbFileUploadUseNamePattern.Checked = TaskSettings.UploadSettings.FileUploadUseNamePattern;
// Upload / Clipboard upload
chkClipboardUploadContents.Checked = TaskSettings.UploadSettings.ClipboardUploadURLContents;
cbClipboardUploadAutoDetectURL.Checked = TaskSettings.UploadSettings.ClipboardUploadShortenURL;
cbClipboardUploadAutoIndexFolder.Checked = TaskSettings.UploadSettings.ClipboardUploadAutoIndexFolder;
// Indexer
pgIndexerConfig.SelectedObject = TaskSettings.IndexerSettings;
// Advanced
pgTaskSettings.SelectedObject = TaskSettings.AdvancedSettings;
UpdateDefaultSettingVisibility();
loaded = true;
}
@ -217,7 +105,7 @@ private void UpdateVideoEncoders()
if (Program.Settings.VideoEncoders.Count > 0)
{
Program.Settings.VideoEncoders.ForEach(x => cboEncoder.Items.Add(x));
cboEncoder.SelectedIndex = TaskSettings.CaptureSettings.VideoEncoderSelected.BetweenOrDefault(0, Program.Settings.VideoEncoders.Count - 1);
cboEncoder.SelectedIndex = TaskSettings.SafeCaptureSettings.VideoEncoderSelected.BetweenOrDefault(0, Program.Settings.VideoEncoders.Count - 1);
}
else if (!cboEncoder.Items.Contains(ConfigureEncoder))
{
@ -237,6 +125,129 @@ private void UpdateDefaultSettingVisibility()
pgIndexerConfig.Enabled = !TaskSettings.UseDefaultIndexerSettings;
pgTaskSettings.Enabled = !TaskSettings.UseDefaultAdvancedSettings;
}
// Core
AddMultiEnumItemsContextMenu<AfterCaptureTasks>(x => TaskSettings.SafeAfterTasks.AfterCaptureJob = TaskSettings.SafeAfterTasks.AfterCaptureJob.Swap(x), cmsAfterCapture);
AddMultiEnumItemsContextMenu<AfterUploadTasks>(x => TaskSettings.SafeAfterTasks.AfterUploadJob = TaskSettings.SafeAfterTasks.AfterUploadJob.Swap(x), cmsAfterUpload);
AddEnumItems<ImageDestination>(x => TaskSettings.SafeDestinations.ImageDestination = x, tsmiImageUploaders);
tsmiImageFileUploaders = (ToolStripDropDownItem)tsmiImageUploaders.DropDownItems[tsmiImageUploaders.DropDownItems.Count - 1];
AddEnumItems<FileDestination>(x => TaskSettings.SafeDestinations.ImageFileDestination = x, tsmiImageFileUploaders);
AddEnumItems<TextDestination>(x => TaskSettings.SafeDestinations.TextDestination = x, tsmiTextUploaders);
tsmiTextFileUploaders = (ToolStripDropDownItem)tsmiTextUploaders.DropDownItems[tsmiTextUploaders.DropDownItems.Count - 1];
AddEnumItems<FileDestination>(x => TaskSettings.SafeDestinations.TextFileDestination = x, tsmiTextFileUploaders);
AddEnumItems<FileDestination>(x => TaskSettings.SafeDestinations.FileDestination = x, tsmiFileUploaders);
AddEnumItems<UrlShortenerType>(x => TaskSettings.SafeDestinations.URLShortenerDestination = x, tsmiURLShorteners);
AddEnumItems<SocialNetworkingService>(x => TaskSettings.SafeDestinations.SocialNetworkingServiceDestination = x, tsmiSocialServices);
// Core - After capture and After upload
SetMultiEnumCheckedContextMenu(TaskSettings.SafeAfterTasks.AfterCaptureJob, cmsAfterCapture);
SetMultiEnumCheckedContextMenu(TaskSettings.SafeAfterTasks.AfterUploadJob, cmsAfterUpload);
// Core - Destinations
SetEnumChecked(TaskSettings.SafeDestinations.ImageDestination, tsmiImageUploaders);
SetEnumChecked(TaskSettings.SafeDestinations.ImageFileDestination, tsmiImageFileUploaders);
SetEnumChecked(TaskSettings.SafeDestinations.TextDestination, tsmiTextUploaders);
SetEnumChecked(TaskSettings.SafeDestinations.TextFileDestination, tsmiTextFileUploaders);
SetEnumChecked(TaskSettings.SafeDestinations.FileDestination, tsmiFileUploaders);
SetEnumChecked(TaskSettings.SafeDestinations.URLShortenerDestination, tsmiURLShorteners);
SetEnumChecked(TaskSettings.SafeDestinations.SocialNetworkingServiceDestination, tsmiSocialServices);
// Core - FTP
if (Program.UploadersConfig != null && Program.UploadersConfig.FTPAccountList.Count > 1)
{
chkOverrideFTP.Checked = TaskSettings.SafeDestinations.OverrideFTP;
cboFTPaccounts.Items.Clear();
cboFTPaccounts.Items.AddRange(Program.UploadersConfig.FTPAccountList.ToArray());
cboFTPaccounts.SelectedIndex = TaskSettings.SafeDestinations.FTPIndex.BetweenOrDefault(0, Program.UploadersConfig.FTPAccountList.Count - 1);
}
btnAfterCapture.Enabled = !TaskSettings.UseDefaultAfterCaptureJob;
btnAfterUpload.Enabled = !TaskSettings.UseDefaultAfterUploadJob;
btnDestinations.Enabled = !TaskSettings.UseDefaultDestinations;
UpdateDestinationStates();
UpdateCoreMenuNames();
// General
cbPlaySoundAfterCapture.Checked = TaskSettings.SafeGeneralSettings.PlaySoundAfterCapture;
cbShowAfterCaptureTasksForm.Checked = TaskSettings.SafeGeneralSettings.ShowAfterCaptureTasksForm;
cbPlaySoundAfterUpload.Checked = TaskSettings.SafeGeneralSettings.PlaySoundAfterUpload;
chkShowAfterUploadForm.Checked = TaskSettings.SafeGeneralSettings.ShowAfterUploadForm;
cboPopUpNotification.Items.Clear();
cboPopUpNotification.Items.AddRange(Helpers.GetEnumDescriptions<PopUpNotificationType>());
cboPopUpNotification.SelectedIndex = (int)TaskSettings.SafeGeneralSettings.PopUpNotification;
cbHistorySave.Checked = TaskSettings.SafeGeneralSettings.SaveHistory;
// Image - General
cbImageFormat.SelectedIndex = (int)TaskSettings.SafeImageSettings.ImageFormat;
nudImageJPEGQuality.Value = TaskSettings.SafeImageSettings.ImageJPEGQuality;
cbImageGIFQuality.SelectedIndex = (int)TaskSettings.SafeImageSettings.ImageGIFQuality;
nudUseImageFormat2After.Value = TaskSettings.SafeImageSettings.ImageSizeLimit;
cbImageFormat2.SelectedIndex = (int)TaskSettings.SafeImageSettings.ImageFormat2;
cbImageFileExist.Items.Clear();
cbImageFileExist.Items.AddRange(Helpers.GetEnumDescriptions<FileExistAction>());
cbImageFileExist.SelectedIndex = (int)TaskSettings.SafeImageSettings.FileExistAction;
// Image - Effects
chkShowImageEffectsWindowAfterCapture.Checked = TaskSettings.SafeImageSettings.ShowImageEffectsWindowAfterCapture;
cbImageEffectOnlyRegionCapture.Checked = TaskSettings.SafeImageSettings.ImageEffectOnlyRegionCapture;
// Image - Thumbnail
nudThumbnailWidth.Value = TaskSettings.SafeImageSettings.ThumbnailWidth;
nudThumbnailHeight.Value = TaskSettings.SafeImageSettings.ThumbnailHeight;
txtThumbnailName.Text = TaskSettings.SafeImageSettings.ThumbnailName;
lblThumbnailNamePreview.Text = "ImageName" + TaskSettings.SafeImageSettings.ThumbnailName + ".jpg";
cbThumbnailIfSmaller.Checked = TaskSettings.SafeImageSettings.ThumbnailCheckSize;
// Capture
cbShowCursor.Checked = TaskSettings.SafeCaptureSettings.ShowCursor;
cbCaptureTransparent.Checked = TaskSettings.SafeCaptureSettings.CaptureTransparent;
cbCaptureShadow.Enabled = TaskSettings.SafeCaptureSettings.CaptureTransparent;
cbCaptureShadow.Checked = TaskSettings.SafeCaptureSettings.CaptureShadow;
nudCaptureShadowOffset.Value = TaskSettings.SafeCaptureSettings.CaptureShadowOffset;
cbCaptureClientArea.Checked = TaskSettings.SafeCaptureSettings.CaptureClientArea;
cbScreenshotDelay.Checked = TaskSettings.SafeCaptureSettings.IsDelayScreenshot;
nudScreenshotDelay.Value = TaskSettings.SafeCaptureSettings.DelayScreenshot;
cbCaptureAutoHideTaskbar.Checked = TaskSettings.SafeCaptureSettings.CaptureAutoHideTaskbar;
if (TaskSettings.SafeCaptureSettings.SurfaceOptions == null) TaskSettings.SafeCaptureSettings.SurfaceOptions = new SurfaceOptions();
pgShapesCapture.SelectedObject = TaskSettings.SafeCaptureSettings.SurfaceOptions;
// Capture / Screen recorder
cbScreenRecorderOutput.Items.Clear();
cbScreenRecorderOutput.Items.AddRange(Helpers.GetEnumDescriptions<ScreenRecordOutput>());
cbScreenRecorderOutput.SelectedIndex = (int)TaskSettings.SafeCaptureSettings.ScreenRecordOutput;
chkRunScreencastCLI.Checked = TaskSettings.SafeCaptureSettings.RunScreencastCLI;
UpdateVideoEncoders();
nudScreenRecorderFPS.Value = TaskSettings.SafeCaptureSettings.ScreenRecordFPS;
cbScreenRecorderFixedDuration.Checked = TaskSettings.SafeCaptureSettings.ScreenRecordFixedDuration;
nudScreenRecorderDuration.Enabled = TaskSettings.SafeCaptureSettings.ScreenRecordFixedDuration;
nudScreenRecorderDuration.Value = (decimal)TaskSettings.SafeCaptureSettings.ScreenRecordDuration;
nudScreenRecorderStartDelay.Value = (decimal)TaskSettings.SafeCaptureSettings.ScreenRecordStartDelay;
// Actions
TaskHelpers.AddDefaultExternalPrograms(TaskSettings);
lvActions.Clear();
TaskSettings.SafeActions.ForEach(x => AddFileAction(x));
// Upload / Name pattern
txtNameFormatPattern.Text = TaskSettings.SafeUploadSettings.NameFormatPattern;
txtNameFormatPatternActiveWindow.Text = TaskSettings.SafeUploadSettings.NameFormatPatternActiveWindow;
NameParser.CreateCodesMenu(txtNameFormatPattern, ReplacementVariables.n);
NameParser.CreateCodesMenu(txtNameFormatPatternActiveWindow, ReplacementVariables.n);
cbFileUploadUseNamePattern.Checked = TaskSettings.SafeUploadSettings.FileUploadUseNamePattern;
// Upload / Clipboard upload
chkClipboardUploadContents.Checked = TaskSettings.SafeUploadSettings.ClipboardUploadURLContents;
cbClipboardUploadAutoDetectURL.Checked = TaskSettings.SafeUploadSettings.ClipboardUploadShortenURL;
cbClipboardUploadAutoIndexFolder.Checked = TaskSettings.SafeUploadSettings.ClipboardUploadAutoIndexFolder;
// Indexer
pgIndexerConfig.SelectedObject = TaskSettings.SafeIndexerSettings;
// Advanced
pgTaskSettings.SelectedObject = TaskSettings.SafeAdvancedSettings;
}
private void TaskSettingsForm_Resize(object sender, EventArgs e)
@ -257,7 +268,7 @@ private void UpdateDestinationStates()
EnableDisableToolStripMenuItems<FileDestination>(tsmiFileUploaders);
EnableDisableToolStripMenuItems<UrlShortenerType>(tsmiURLShorteners);
EnableDisableToolStripMenuItems<SocialNetworkingService>(tsmiSocialServices);
chkOverrideFTP.Visible = cboFTPaccounts.Visible = Program.UploadersConfig.FTPAccountList.Count > 1;
chkOverrideFTP.Enabled = cboFTPaccounts.Enabled = Program.UploadersConfig.FTPAccountList.Count > 1;
}
}
@ -267,6 +278,8 @@ private void AddEnumItemsContextMenu<T>(Action<T> selectedEnum, params ToolStrip
foreach (ToolStripDropDown parent in parents)
{
parent.Items.Clear();
for (int i = 0; i < enums.Length; i++)
{
ToolStripMenuItem tsmi = new ToolStripMenuItem(enums[i]);
@ -286,7 +299,7 @@ private void AddEnumItemsContextMenu<T>(Action<T> selectedEnum, params ToolStrip
selectedEnum((T)Enum.ToObject(typeof(T), index));
UpdateUploaderMenuNames();
UpdateCoreMenuNames();
};
parent.Items.Add(tsmi);
@ -310,6 +323,8 @@ private void AddMultiEnumItemsContextMenu<T>(Action<T> selectedEnum, params Tool
foreach (ToolStripDropDown parent in parents)
{
parent.Items.Clear();
for (int i = 0; i < enums.Length; i++)
{
ToolStripMenuItem tsmi = new ToolStripMenuItem(enums[i]);
@ -326,7 +341,7 @@ private void AddMultiEnumItemsContextMenu<T>(Action<T> selectedEnum, params Tool
selectedEnum((T)Enum.ToObject(typeof(T), 1 << index));
UpdateUploaderMenuNames();
UpdateCoreMenuNames();
};
parent.Items.Add(tsmi);
@ -352,6 +367,8 @@ private void AddEnumItems<T>(Action<T> selectedEnum, params ToolStripDropDownIte
foreach (ToolStripDropDownItem parent in parents)
{
parent.DropDown.Items.Clear();
for (int i = 0; i < enums.Length; i++)
{
ToolStripMenuItem tsmi = new ToolStripMenuItem(enums[i]);
@ -371,7 +388,7 @@ private void AddEnumItems<T>(Action<T> selectedEnum, params ToolStripDropDownIte
selectedEnum((T)Enum.ToObject(typeof(T), index));
UpdateUploaderMenuNames();
UpdateCoreMenuNames();
};
parent.DropDownItems.Add(tsmi);
@ -400,29 +417,31 @@ private void EnableDisableToolStripMenuItems<T>(params ToolStripDropDownItem[] p
}
}
private void UpdateUploaderMenuNames()
private void UpdateCoreMenuNames()
{
btnTask.Text = "Task: " + TaskSettings.Job.GetDescription();
btnAfterCapture.Text = "After capture: " + string.Join(", ", TaskSettings.AfterCaptureJob.GetFlags<AfterCaptureTasks>().
btnAfterCapture.Text = "After capture: " + string.Join(", ", TaskSettings.SafeAfterTasks.AfterCaptureJob.GetFlags<AfterCaptureTasks>().
Select(x => x.GetDescription()).ToArray());
btnAfterUpload.Text = "After upload: " + string.Join(", ", TaskSettings.AfterUploadJob.GetFlags<AfterUploadTasks>().
btnAfterUpload.Text = "After upload: " + string.Join(", ", TaskSettings.SafeAfterTasks.AfterUploadJob.GetFlags<AfterUploadTasks>().
Select(x => x.GetDescription()).ToArray());
string imageUploader = TaskSettings.ImageDestination == ImageDestination.FileUploader ?
TaskSettings.ImageFileDestination.GetDescription() : TaskSettings.ImageDestination.GetDescription();
string imageUploader = TaskSettings.SafeDestinations.ImageDestination == ImageDestination.FileUploader ?
TaskSettings.SafeDestinations.ImageFileDestination.GetDescription() : TaskSettings.SafeDestinations.ImageDestination.GetDescription();
tsmiImageUploaders.Text = "Image uploader: " + imageUploader;
string textUploader = TaskSettings.TextDestination == TextDestination.FileUploader ?
TaskSettings.TextFileDestination.GetDescription() : TaskSettings.TextDestination.GetDescription();
string textUploader = TaskSettings.SafeDestinations.TextDestination == TextDestination.FileUploader ?
TaskSettings.SafeDestinations.TextFileDestination.GetDescription() : TaskSettings.SafeDestinations.TextDestination.GetDescription();
tsmiTextUploaders.Text = "Text uploader: " + textUploader;
tsmiFileUploaders.Text = "File uploader: " + TaskSettings.FileDestination.GetDescription();
tsmiFileUploaders.Text = "File uploader: " + TaskSettings.SafeDestinations.FileDestination.GetDescription();
tsmiURLShorteners.Text = "URL shortener: " + TaskSettings.URLShortenerDestination.GetDescription();
tsmiURLShorteners.Text = "URL shortener: " + TaskSettings.SafeDestinations.URLShortenerDestination.GetDescription();
tsmiSocialServices.Text = "Social networking service: " + TaskSettings.SocialNetworkingServiceDestination.GetDescription();
tsmiSocialServices.Text = "Social networking service: " + TaskSettings.SafeDestinations.SocialNetworkingServiceDestination.GetDescription();
ttTaskSettings.SetToolTip(btnDestinations, TaskSettings.SafeDestinations.ToString());
}
private void tbDescription_TextChanged(object sender, EventArgs e)
@ -433,30 +452,30 @@ private void tbDescription_TextChanged(object sender, EventArgs e)
private void cbUseDefaultAfterCaptureSettings_CheckedChanged(object sender, EventArgs e)
{
TaskSettings.UseDefaultAfterCaptureJob = cbUseDefaultAfterCaptureSettings.Checked;
btnAfterCapture.Enabled = !TaskSettings.UseDefaultAfterCaptureJob;
UpdateDefaultSettingVisibility();
}
private void cbUseDefaultAfterUploadSettings_CheckedChanged(object sender, EventArgs e)
{
TaskSettings.UseDefaultAfterUploadJob = cbUseDefaultAfterUploadSettings.Checked;
btnAfterUpload.Enabled = !TaskSettings.UseDefaultAfterUploadJob;
UpdateDefaultSettingVisibility();
}
private void cbUseDefaultDestinationSettings_CheckedChanged(object sender, EventArgs e)
{
TaskSettings.UseDefaultDestinations = cbUseDefaultDestinationSettings.Checked;
btnDestinations.Enabled = !TaskSettings.UseDefaultDestinations;
UpdateDefaultSettingVisibility();
}
private void chkOverrideFTP_CheckedChanged(object sender, EventArgs e)
{
TaskSettings.OverrideFTP = chkOverrideFTP.Checked;
cboFTPaccounts.Enabled = TaskSettings.OverrideFTP;
TaskSettings.SafeDestinations.OverrideFTP = chkOverrideFTP.Checked;
cboFTPaccounts.Enabled = TaskSettings.SafeDestinations.OverrideFTP;
}
private void cboFTPaccounts_SelectedIndexChanged(object sender, EventArgs e)
{
TaskSettings.FTPIndex = cboFTPaccounts.SelectedIndex;
TaskSettings.SafeDestinations.FTPIndex = cboFTPaccounts.SelectedIndex;
}
#endregion Task
@ -471,32 +490,32 @@ private void chkUseDefaultGeneralSettings_CheckedChanged(object sender, EventArg
private void cbPlaySoundAfterCapture_CheckedChanged(object sender, EventArgs e)
{
TaskSettings.GeneralSettings.PlaySoundAfterCapture = cbPlaySoundAfterCapture.Checked;
TaskSettings.SafeGeneralSettings.PlaySoundAfterCapture = cbPlaySoundAfterCapture.Checked;
}
private void cbShowAfterCaptureTasksForm_CheckedChanged(object sender, EventArgs e)
{
TaskSettings.GeneralSettings.ShowAfterCaptureTasksForm = cbShowAfterCaptureTasksForm.Checked;
TaskSettings.SafeGeneralSettings.ShowAfterCaptureTasksForm = cbShowAfterCaptureTasksForm.Checked;
}
private void cbPlaySoundAfterUpload_CheckedChanged(object sender, EventArgs e)
{
TaskSettings.GeneralSettings.PlaySoundAfterUpload = cbPlaySoundAfterUpload.Checked;
TaskSettings.SafeGeneralSettings.PlaySoundAfterUpload = cbPlaySoundAfterUpload.Checked;
}
private void chkShowAfterUploadForm_CheckedChanged(object sender, EventArgs e)
{
TaskSettings.GeneralSettings.ShowAfterUploadForm = chkShowAfterUploadForm.Checked;
TaskSettings.SafeGeneralSettings.ShowAfterUploadForm = chkShowAfterUploadForm.Checked;
}
private void cboPopUpNotification_SelectedIndexChanged(object sender, EventArgs e)
{
TaskSettings.GeneralSettings.PopUpNotification = (PopUpNotificationType)cboPopUpNotification.SelectedIndex;
TaskSettings.SafeGeneralSettings.PopUpNotification = (PopUpNotificationType)cboPopUpNotification.SelectedIndex;
}
private void cbHistorySave_CheckedChanged(object sender, EventArgs e)
{
TaskSettings.GeneralSettings.SaveHistory = cbHistorySave.Checked;
TaskSettings.SafeGeneralSettings.SaveHistory = cbHistorySave.Checked;
}
#endregion General
@ -511,37 +530,37 @@ private void chkUseDefaultImageSettings_CheckedChanged(object sender, EventArgs
private void cbImageFormat_SelectedIndexChanged(object sender, EventArgs e)
{
TaskSettings.ImageSettings.ImageFormat = (EImageFormat)cbImageFormat.SelectedIndex;
TaskSettings.SafeImageSettings.ImageFormat = (EImageFormat)cbImageFormat.SelectedIndex;
}
private void cbImageGIFQuality_SelectedIndexChanged(object sender, EventArgs e)
{
TaskSettings.ImageSettings.ImageGIFQuality = (GIFQuality)cbImageGIFQuality.SelectedIndex;
TaskSettings.SafeImageSettings.ImageGIFQuality = (GIFQuality)cbImageGIFQuality.SelectedIndex;
}
private void cbImageFormat2_SelectedIndexChanged(object sender, EventArgs e)
{
TaskSettings.ImageSettings.ImageFormat2 = (EImageFormat)cbImageFormat2.SelectedIndex;
TaskSettings.SafeImageSettings.ImageFormat2 = (EImageFormat)cbImageFormat2.SelectedIndex;
}
private void nudImageJPEGQuality_ValueChanged(object sender, EventArgs e)
{
TaskSettings.ImageSettings.ImageJPEGQuality = (int)nudImageJPEGQuality.Value;
TaskSettings.SafeImageSettings.ImageJPEGQuality = (int)nudImageJPEGQuality.Value;
}
private void nudUseImageFormat2After_ValueChanged(object sender, EventArgs e)
{
TaskSettings.ImageSettings.ImageSizeLimit = (int)nudUseImageFormat2After.Value;
TaskSettings.SafeImageSettings.ImageSizeLimit = (int)nudUseImageFormat2After.Value;
}
private void cbImageFileExist_SelectedIndexChanged(object sender, EventArgs e)
{
TaskSettings.ImageSettings.FileExistAction = (FileExistAction)cbImageFileExist.SelectedIndex;
TaskSettings.SafeImageSettings.FileExistAction = (FileExistAction)cbImageFileExist.SelectedIndex;
}
private void btnWatermarkSettings_Click(object sender, EventArgs e)
{
using (WatermarkForm watermarkForm = new WatermarkForm(TaskSettings.ImageSettings.WatermarkConfig) { Icon = Icon })
using (WatermarkForm watermarkForm = new WatermarkForm(TaskSettings.SafeImageSettings.WatermarkConfig) { Icon = Icon })
{
watermarkForm.ShowDialog();
}
@ -549,44 +568,44 @@ private void btnWatermarkSettings_Click(object sender, EventArgs e)
private void cbImageEffectOnlyRegionCapture_CheckedChanged(object sender, EventArgs e)
{
TaskSettings.ImageSettings.ImageEffectOnlyRegionCapture = cbImageEffectOnlyRegionCapture.Checked;
TaskSettings.SafeImageSettings.ImageEffectOnlyRegionCapture = cbImageEffectOnlyRegionCapture.Checked;
}
private void chkShowImageEffectsWindowAfterCapture_CheckedChanged(object sender, EventArgs e)
{
TaskSettings.ImageSettings.ShowImageEffectsWindowAfterCapture = chkShowImageEffectsWindowAfterCapture.Checked;
TaskSettings.SafeImageSettings.ShowImageEffectsWindowAfterCapture = chkShowImageEffectsWindowAfterCapture.Checked;
}
private void btnImageEffects_Click(object sender, EventArgs e)
{
using (ImageEffectsForm imageEffectsForm = new ImageEffectsForm(ShareXResources.Logo, TaskSettings.ImageSettings.ImageEffects))
using (ImageEffectsForm imageEffectsForm = new ImageEffectsForm(ShareXResources.Logo, TaskSettings.SafeImageSettings.ImageEffects))
{
if (imageEffectsForm.ShowDialog() == DialogResult.OK)
{
TaskSettings.ImageSettings.ImageEffects = imageEffectsForm.Effects;
TaskSettings.SafeImageSettings.ImageEffects = imageEffectsForm.Effects;
}
}
}
private void nudThumbnailWidth_ValueChanged(object sender, EventArgs e)
{
TaskSettings.ImageSettings.ThumbnailWidth = (int)nudThumbnailWidth.Value;
TaskSettings.SafeImageSettings.ThumbnailWidth = (int)nudThumbnailWidth.Value;
}
private void nudThumbnailHeight_ValueChanged(object sender, EventArgs e)
{
TaskSettings.ImageSettings.ThumbnailHeight = (int)nudThumbnailHeight.Value;
TaskSettings.SafeImageSettings.ThumbnailHeight = (int)nudThumbnailHeight.Value;
}
private void txtThumbnailName_TextChanged(object sender, EventArgs e)
{
TaskSettings.ImageSettings.ThumbnailName = txtThumbnailName.Text;
lblThumbnailNamePreview.Text = "ImageName" + TaskSettings.ImageSettings.ThumbnailName + ".jpg";
TaskSettings.SafeImageSettings.ThumbnailName = txtThumbnailName.Text;
lblThumbnailNamePreview.Text = "ImageName" + TaskSettings.SafeImageSettings.ThumbnailName + ".jpg";
}
private void cbThumbnailIfSmaller_CheckedChanged(object sender, EventArgs e)
{
TaskSettings.ImageSettings.ThumbnailCheckSize = cbThumbnailIfSmaller.Checked;
TaskSettings.SafeImageSettings.ThumbnailCheckSize = cbThumbnailIfSmaller.Checked;
}
#endregion Image
@ -601,43 +620,43 @@ private void chkUseDefaultCaptureSettings_CheckedChanged(object sender, EventArg
private void cbCaptureAutoHideTaskbar_CheckedChanged(object sender, EventArgs e)
{
TaskSettings.CaptureSettings.CaptureAutoHideTaskbar = cbCaptureAutoHideTaskbar.Checked;
TaskSettings.SafeCaptureSettings.CaptureAutoHideTaskbar = cbCaptureAutoHideTaskbar.Checked;
}
private void nudScreenshotDelay_ValueChanged(object sender, EventArgs e)
{
TaskSettings.CaptureSettings.DelayScreenshot = nudScreenshotDelay.Value;
TaskSettings.SafeCaptureSettings.DelayScreenshot = nudScreenshotDelay.Value;
}
private void cbScreenshotDelay_CheckedChanged(object sender, EventArgs e)
{
TaskSettings.CaptureSettings.IsDelayScreenshot = cbScreenshotDelay.Checked;
TaskSettings.SafeCaptureSettings.IsDelayScreenshot = cbScreenshotDelay.Checked;
}
private void nudCaptureShadowOffset_ValueChanged(object sender, EventArgs e)
{
TaskSettings.CaptureSettings.CaptureShadowOffset = (int)nudCaptureShadowOffset.Value;
TaskSettings.SafeCaptureSettings.CaptureShadowOffset = (int)nudCaptureShadowOffset.Value;
}
private void cbCaptureClientArea_CheckedChanged(object sender, EventArgs e)
{
TaskSettings.CaptureSettings.CaptureClientArea = cbCaptureClientArea.Checked;
TaskSettings.SafeCaptureSettings.CaptureClientArea = cbCaptureClientArea.Checked;
}
private void cbCaptureShadow_CheckedChanged(object sender, EventArgs e)
{
TaskSettings.CaptureSettings.CaptureShadow = cbCaptureShadow.Checked;
TaskSettings.SafeCaptureSettings.CaptureShadow = cbCaptureShadow.Checked;
}
private void cbShowCursor_CheckedChanged(object sender, EventArgs e)
{
TaskSettings.CaptureSettings.ShowCursor = cbShowCursor.Checked;
TaskSettings.SafeCaptureSettings.ShowCursor = cbShowCursor.Checked;
}
private void cbCaptureTransparent_CheckedChanged(object sender, EventArgs e)
{
TaskSettings.CaptureSettings.CaptureTransparent = cbCaptureTransparent.Checked;
cbCaptureShadow.Enabled = TaskSettings.CaptureSettings.CaptureTransparent;
TaskSettings.SafeCaptureSettings.CaptureTransparent = cbCaptureTransparent.Checked;
cbCaptureShadow.Enabled = TaskSettings.SafeCaptureSettings.CaptureTransparent;
}
#endregion Capture
@ -646,9 +665,9 @@ private void cbCaptureTransparent_CheckedChanged(object sender, EventArgs e)
private void cbScreenRecorderOutput_SelectedIndexChanged(object sender, EventArgs e)
{
TaskSettings.CaptureSettings.ScreenRecordOutput = (ScreenRecordOutput)cbScreenRecorderOutput.SelectedIndex;
btnScreenRecorderOptions.Enabled = TaskSettings.CaptureSettings.ScreenRecordOutput == ScreenRecordOutput.AVI ||
TaskSettings.CaptureSettings.ScreenRecordOutput == ScreenRecordOutput.FFmpeg;
TaskSettings.SafeCaptureSettings.ScreenRecordOutput = (ScreenRecordOutput)cbScreenRecorderOutput.SelectedIndex;
btnScreenRecorderOptions.Enabled = TaskSettings.SafeCaptureSettings.ScreenRecordOutput == ScreenRecordOutput.AVI ||
TaskSettings.SafeCaptureSettings.ScreenRecordOutput == ScreenRecordOutput.FFmpeg;
btnEncoderConfig.Enabled = cboEncoder.Enabled = chkRunScreencastCLI.Enabled && chkRunScreencastCLI.Checked;
}
@ -656,16 +675,16 @@ private void btnScreenRecorderOptions_Click(object sender, EventArgs e)
{
ScreencastOptions options = new ScreencastOptions
{
AVI = TaskSettings.CaptureSettings.AVIOptions,
FFmpeg = TaskSettings.CaptureSettings.FFmpegOptions,
AVI = TaskSettings.SafeCaptureSettings.AVIOptions,
FFmpeg = TaskSettings.SafeCaptureSettings.FFmpegOptions,
ShowAVIOptionsDialog = true,
FPS = TaskSettings.CaptureSettings.ScreenRecordFPS,
FPS = TaskSettings.SafeCaptureSettings.ScreenRecordFPS,
OutputPath = Path.Combine(TaskSettings.CaptureFolder, TaskHelpers.GetFilename(TaskSettings, "avi")),
ParentWindow = this.Handle,
CaptureArea = new Rectangle(0, 0, 100, 100)
};
switch (TaskSettings.CaptureSettings.ScreenRecordOutput)
switch (TaskSettings.SafeCaptureSettings.ScreenRecordOutput)
{
case ScreenRecordOutput.AVI:
@ -674,12 +693,12 @@ private void btnScreenRecorderOptions_Click(object sender, EventArgs e)
// Ugly workaround for show AVI compression dialog
using (AVICache aviCache = new AVICache(options))
{
TaskSettings.CaptureSettings.AVIOptions.CompressOptions = options.AVI.CompressOptions;
TaskSettings.SafeCaptureSettings.AVIOptions.CompressOptions = options.AVI.CompressOptions;
}
}
catch (Exception ex)
{
TaskSettings.CaptureSettings.AVIOptions.CompressOptions = new AVICOMPRESSOPTIONS();
TaskSettings.SafeCaptureSettings.AVIOptions.CompressOptions = new AVICOMPRESSOPTIONS();
MessageBox.Show(ex.ToString(), Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
break;
@ -694,7 +713,7 @@ private void btnScreenRecorderOptions_Click(object sender, EventArgs e)
private void cboEncoder_SelectedIndexChanged(object sender, EventArgs e)
{
TaskSettings.CaptureSettings.VideoEncoderSelected = cboEncoder.SelectedIndex;
TaskSettings.SafeCaptureSettings.VideoEncoderSelected = cboEncoder.SelectedIndex;
}
private void btnEncoderConfig_Click(object sender, EventArgs e)
@ -709,28 +728,28 @@ private void btnEncoderConfig_Click(object sender, EventArgs e)
private void nudScreenRecorderFPS_ValueChanged(object sender, EventArgs e)
{
TaskSettings.CaptureSettings.ScreenRecordFPS = (int)nudScreenRecorderFPS.Value;
TaskSettings.SafeCaptureSettings.ScreenRecordFPS = (int)nudScreenRecorderFPS.Value;
}
private void cbScreenRecorderFixedDuration_CheckedChanged(object sender, EventArgs e)
{
TaskSettings.CaptureSettings.ScreenRecordFixedDuration = cbScreenRecorderFixedDuration.Checked;
nudScreenRecorderDuration.Enabled = TaskSettings.CaptureSettings.ScreenRecordFixedDuration;
TaskSettings.SafeCaptureSettings.ScreenRecordFixedDuration = cbScreenRecorderFixedDuration.Checked;
nudScreenRecorderDuration.Enabled = TaskSettings.SafeCaptureSettings.ScreenRecordFixedDuration;
}
private void chkRunScreencastCLI_CheckedChanged(object sender, EventArgs e)
{
TaskSettings.CaptureSettings.RunScreencastCLI = btnEncoderConfig.Enabled = cboEncoder.Enabled = chkRunScreencastCLI.Checked;
TaskSettings.SafeCaptureSettings.RunScreencastCLI = btnEncoderConfig.Enabled = cboEncoder.Enabled = chkRunScreencastCLI.Checked;
}
private void nudScreenRecorderDuration_ValueChanged(object sender, EventArgs e)
{
TaskSettings.CaptureSettings.ScreenRecordDuration = (float)nudScreenRecorderDuration.Value;
TaskSettings.SafeCaptureSettings.ScreenRecordDuration = (float)nudScreenRecorderDuration.Value;
}
private void nudScreenRecorderStartDelay_ValueChanged(object sender, EventArgs e)
{
TaskSettings.CaptureSettings.ScreenRecordStartDelay = (float)nudScreenRecorderStartDelay.Value;
TaskSettings.SafeCaptureSettings.ScreenRecordStartDelay = (float)nudScreenRecorderStartDelay.Value;
}
#endregion Screen recorder
@ -751,7 +770,7 @@ private void btnActionsAdd_Click(object sender, EventArgs e)
{
ExternalProgram fileAction = form.FileAction;
fileAction.IsActive = true;
TaskSettings.ExternalPrograms.Add(fileAction);
TaskSettings.SafeActions.Add(fileAction);
AddFileAction(fileAction);
}
}
@ -793,7 +812,7 @@ private void btnActionsRemove_Click(object sender, EventArgs e)
ListViewItem lvi = lvActions.SelectedItems[0];
ExternalProgram fileAction = lvi.Tag as ExternalProgram;
TaskSettings.ExternalPrograms.Remove(fileAction);
TaskSettings.SafeActions.Remove(fileAction);
lvActions.Items.Remove(lvi);
}
}
@ -888,21 +907,21 @@ private void chkUseDefaultUploadSettings_CheckedChanged(object sender, EventArgs
private void cbFileUploadUseNamePattern_CheckedChanged(object sender, EventArgs e)
{
TaskSettings.UploadSettings.FileUploadUseNamePattern = cbFileUploadUseNamePattern.Checked;
TaskSettings.SafeUploadSettings.FileUploadUseNamePattern = cbFileUploadUseNamePattern.Checked;
}
private void txtNameFormatPatternActiveWindow_TextChanged(object sender, EventArgs e)
{
TaskSettings.UploadSettings.NameFormatPatternActiveWindow = txtNameFormatPatternActiveWindow.Text;
TaskSettings.SafeUploadSettings.NameFormatPatternActiveWindow = txtNameFormatPatternActiveWindow.Text;
NameParser nameParser = new NameParser(NameParserType.FileName)
{
AutoIncrementNumber = Program.Settings.NameParserAutoIncrementNumber,
WindowText = Text,
ProcessName = "ShareX",
MaxNameLength = TaskSettings.AdvancedSettings.NamePatternMaxLength,
MaxTitleLength = TaskSettings.AdvancedSettings.NamePatternMaxTitleLength
MaxNameLength = TaskSettings.SafeAdvancedSettings.NamePatternMaxLength,
MaxTitleLength = TaskSettings.SafeAdvancedSettings.NamePatternMaxTitleLength
};
lblNameFormatPatternPreviewActiveWindow.Text = "Preview: " + nameParser.Parse(TaskSettings.UploadSettings.NameFormatPatternActiveWindow);
lblNameFormatPatternPreviewActiveWindow.Text = "Preview: " + nameParser.Parse(TaskSettings.SafeUploadSettings.NameFormatPatternActiveWindow);
}
private void btnResetAutoIncrementNumber_Click(object sender, EventArgs e)
@ -912,29 +931,29 @@ private void btnResetAutoIncrementNumber_Click(object sender, EventArgs e)
private void txtNameFormatPattern_TextChanged(object sender, EventArgs e)
{
TaskSettings.UploadSettings.NameFormatPattern = txtNameFormatPattern.Text;
TaskSettings.SafeUploadSettings.NameFormatPattern = txtNameFormatPattern.Text;
NameParser nameParser = new NameParser(NameParserType.FileName)
{
AutoIncrementNumber = Program.Settings.NameParserAutoIncrementNumber,
MaxNameLength = TaskSettings.AdvancedSettings.NamePatternMaxLength,
MaxTitleLength = TaskSettings.AdvancedSettings.NamePatternMaxTitleLength
MaxNameLength = TaskSettings.SafeAdvancedSettings.NamePatternMaxLength,
MaxTitleLength = TaskSettings.SafeAdvancedSettings.NamePatternMaxTitleLength
};
lblNameFormatPatternPreview.Text = "Preview: " + nameParser.Parse(TaskSettings.UploadSettings.NameFormatPattern);
lblNameFormatPatternPreview.Text = "Preview: " + nameParser.Parse(TaskSettings.SafeUploadSettings.NameFormatPattern);
}
private void chkClipboardUploadContents_CheckedChanged(object sender, EventArgs e)
{
TaskSettings.UploadSettings.ClipboardUploadURLContents = chkClipboardUploadContents.Checked;
TaskSettings.SafeUploadSettings.ClipboardUploadURLContents = chkClipboardUploadContents.Checked;
}
private void cbClipboardUploadAutoDetectURL_CheckedChanged(object sender, EventArgs e)
{
TaskSettings.UploadSettings.ClipboardUploadShortenURL = cbClipboardUploadAutoDetectURL.Checked;
TaskSettings.SafeUploadSettings.ClipboardUploadShortenURL = cbClipboardUploadAutoDetectURL.Checked;
}
private void cbClipboardUploadAutoIndexFolder_CheckedChanged(object sender, EventArgs e)
{
TaskSettings.UploadSettings.ClipboardUploadAutoIndexFolder = cbClipboardUploadAutoIndexFolder.Checked;
TaskSettings.SafeUploadSettings.ClipboardUploadAutoIndexFolder = cbClipboardUploadAutoIndexFolder.Checked;
}
#endregion Upload

3
ShareX/Forms/TaskSettingsForm.resx
View file

@ -129,4 +129,7 @@
<metadata name="cmsDestinations.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
<value>396, 17</value>
</metadata>
<metadata name="ttTaskSettings.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
<value>537, 17</value>
</metadata>
</root>

38
ShareX/Forms/UploadTestForm.cs
View file

@ -105,9 +105,12 @@ public UploadTestForm()
lvi = new ListViewItem(uploader.GetDescription());
TaskSettings defaultTaskSettings = TaskSettings.GetDefaultTaskSettings();
UploadTask task = UploadTask.CreateImageUploaderTask((Image)TestImage.Clone(), defaultTaskSettings);
task.Info.TaskSettings.ImageDestination = uploader;
TaskSettings taskSettings = TaskSettings.GetDefaultTaskSettings();
taskSettings.UseDefaultImageSettings = false;
taskSettings.SafeImageSettings.FileExistAction = FileExistAction.Cancel;
taskSettings.UseDefaultDestinations = false;
taskSettings.SafeDestinations.ImageDestination = uploader;
UploadTask task = UploadTask.CreateImageUploaderTask((Image)TestImage.Clone(), taskSettings);
lvi.Tag = task;
lvi.Group = imageUploadersGroup;
@ -124,9 +127,12 @@ public UploadTestForm()
lvi = new ListViewItem(uploader.GetDescription());
TaskSettings defaultTaskSettings = TaskSettings.GetDefaultTaskSettings();
UploadTask task = UploadTask.CreateTextUploaderTask(TestText, defaultTaskSettings);
task.Info.TaskSettings.TextDestination = uploader;
TaskSettings taskSettings = TaskSettings.GetDefaultTaskSettings();
taskSettings.UseDefaultImageSettings = false;
taskSettings.SafeImageSettings.FileExistAction = FileExistAction.Cancel;
taskSettings.UseDefaultDestinations = false;
taskSettings.SafeDestinations.TextDestination = uploader;
UploadTask task = UploadTask.CreateTextUploaderTask(TestText, taskSettings);
lvi.Tag = task;
lvi.Group = textUploadersGroup;
@ -145,10 +151,13 @@ public UploadTestForm()
lvi = new ListViewItem(uploader.GetDescription());
TaskSettings defaultTaskSettings = TaskSettings.GetDefaultTaskSettings();
UploadTask task = UploadTask.CreateImageUploaderTask((Image)TestImage.Clone(), defaultTaskSettings);
task.Info.TaskSettings.ImageDestination = ImageDestination.FileUploader;
task.Info.TaskSettings.FileDestination = uploader;
TaskSettings taskSettings = TaskSettings.GetDefaultTaskSettings();
taskSettings.UseDefaultImageSettings = false;
taskSettings.SafeImageSettings.FileExistAction = FileExistAction.Cancel;
taskSettings.UseDefaultDestinations = false;
taskSettings.SafeDestinations.ImageDestination = ImageDestination.FileUploader;
taskSettings.SafeDestinations.ImageFileDestination = uploader;
UploadTask task = UploadTask.CreateImageUploaderTask((Image)TestImage.Clone(), taskSettings);
lvi.Tag = task;
lvi.Group = fileUploadersGroup;
@ -159,9 +168,12 @@ public UploadTestForm()
{
lvi = new ListViewItem(uploader.GetDescription());
TaskSettings defaultTaskSettings = TaskSettings.GetDefaultTaskSettings();
UploadTask task = UploadTask.CreateURLShortenerTask(TestURL, defaultTaskSettings);
task.Info.TaskSettings.URLShortenerDestination = uploader;
TaskSettings taskSettings = TaskSettings.GetDefaultTaskSettings();
taskSettings.UseDefaultImageSettings = false;
taskSettings.SafeImageSettings.FileExistAction = FileExistAction.Cancel;
taskSettings.UseDefaultDestinations = false;
taskSettings.SafeDestinations.URLShortenerDestination = uploader;
UploadTask task = UploadTask.CreateURLShortenerTask(TestURL, taskSettings);
lvi.Tag = task;
lvi.Group = urlShortenersGroup;

28
ShareX/Program.cs
View file

@ -355,6 +355,7 @@ public static void LoadProgramSettings()
{
Settings = ApplicationConfig.Load(ApplicationConfigFilePath);
DefaultTaskSettings = Settings.DefaultTaskSettings;
MigrateTaskSettings(DefaultTaskSettings);
}
public static void LoadUploadersConfig()
@ -365,6 +366,33 @@ public static void LoadUploadersConfig()
public static void LoadHotkeySettings()
{
HotkeysConfig = HotkeysConfig.Load(HotkeysConfigFilePath);
if (HotkeysConfig != null && HotkeysConfig.Hotkeys != null)
{
HotkeysConfig.Hotkeys.ForEach(x => MigrateTaskSettings(x.TaskSettings));
}
}
public static void MigrateTaskSettings(TaskSettings taskSettings)
{
if (!taskSettings.SettingsMigrated)
{
taskSettings.SafeAfterTasks.AfterCaptureJob = taskSettings.AfterCaptureJob;
taskSettings.SafeAfterTasks.AfterUploadJob = taskSettings.AfterUploadJob;
taskSettings.TaskDestinations.ImageDestination = taskSettings.ImageDestination;
taskSettings.TaskDestinations.ImageFileDestination = taskSettings.ImageFileDestination;
taskSettings.TaskDestinations.FileDestination = taskSettings.FileDestination;
taskSettings.TaskDestinations.TextDestination = taskSettings.TextDestination;
taskSettings.TaskDestinations.TextFileDestination = taskSettings.TextFileDestination;
taskSettings.TaskDestinations.URLShortenerDestination = taskSettings.URLShortenerDestination;
taskSettings.TaskDestinations.SocialNetworkingServiceDestination = taskSettings.SocialNetworkingServiceDestination;
taskSettings.TaskDestinations.OverrideFTP = taskSettings.OverrideFTP;
taskSettings.TaskDestinations.FTPIndex = taskSettings.FTPIndex;
taskSettings.SettingsMigrated = true;
}
}
public static void SaveSettings()

70
ShareX/TaskHelpers.cs
View file

@ -46,26 +46,26 @@ public static class TaskHelpers
public static ImageData PrepareImage(Image img, TaskSettings taskSettings)
{
ImageData imageData = new ImageData();
imageData.ImageFormat = taskSettings.ImageSettings.ImageFormat;
imageData.ImageFormat = taskSettings.SafeImageSettings.ImageFormat;
if (taskSettings.ImageSettings.ImageFormat == EImageFormat.JPEG)
if (taskSettings.SafeImageSettings.ImageFormat == EImageFormat.JPEG)
{
img = ImageHelpers.FillBackground(img, Color.White);
}
imageData.ImageStream = SaveImage(img, taskSettings.ImageSettings.ImageFormat, taskSettings);
imageData.ImageStream = SaveImage(img, taskSettings.SafeImageSettings.ImageFormat, taskSettings);
int sizeLimit = taskSettings.ImageSettings.ImageSizeLimit * 1000;
int sizeLimit = taskSettings.SafeImageSettings.ImageSizeLimit * 1000;
if (taskSettings.ImageSettings.ImageFormat != taskSettings.ImageSettings.ImageFormat2 && sizeLimit > 0 && imageData.ImageStream.Length > sizeLimit)
if (taskSettings.SafeImageSettings.ImageFormat != taskSettings.SafeImageSettings.ImageFormat2 && sizeLimit > 0 && imageData.ImageStream.Length > sizeLimit)
{
if (taskSettings.ImageSettings.ImageFormat2 == EImageFormat.JPEG)
if (taskSettings.SafeImageSettings.ImageFormat2 == EImageFormat.JPEG)
{
img = ImageHelpers.FillBackground(img, Color.White);
}
imageData.ImageStream = SaveImage(img, taskSettings.ImageSettings.ImageFormat2, taskSettings);
imageData.ImageFormat = taskSettings.ImageSettings.ImageFormat2;
imageData.ImageStream = SaveImage(img, taskSettings.SafeImageSettings.ImageFormat2, taskSettings);
imageData.ImageFormat = taskSettings.SafeImageSettings.ImageFormat2;
}
return imageData;
@ -73,10 +73,10 @@ public static ImageData PrepareImage(Image img, TaskSettings taskSettings)
public static string CreateThumbnail(Image img, string folder, string filename, TaskSettings taskSettings)
{
if ((taskSettings.ImageSettings.ThumbnailWidth > 0 || taskSettings.ImageSettings.ThumbnailHeight > 0) && (!taskSettings.ImageSettings.ThumbnailCheckSize ||
(img.Width > taskSettings.ImageSettings.ThumbnailWidth && img.Height > taskSettings.ImageSettings.ThumbnailHeight)))
if ((taskSettings.SafeImageSettings.ThumbnailWidth > 0 || taskSettings.SafeImageSettings.ThumbnailHeight > 0) && (!taskSettings.SafeImageSettings.ThumbnailCheckSize ||
(img.Width > taskSettings.SafeImageSettings.ThumbnailWidth && img.Height > taskSettings.SafeImageSettings.ThumbnailHeight)))
{
string thumbnailFileName = Path.GetFileNameWithoutExtension(filename) + taskSettings.ImageSettings.ThumbnailName + ".jpg";
string thumbnailFileName = Path.GetFileNameWithoutExtension(filename) + taskSettings.SafeImageSettings.ThumbnailName + ".jpg";
string thumbnailFilePath = TaskHelpers.CheckFilePath(folder, thumbnailFileName, taskSettings);
if (!string.IsNullOrEmpty(thumbnailFilePath))
@ -88,8 +88,8 @@ public static string CreateThumbnail(Image img, string folder, string filename,
thumbImage = (Image)img.Clone();
thumbImage = new Resize
{
Width = taskSettings.ImageSettings.ThumbnailWidth,
Height = taskSettings.ImageSettings.ThumbnailHeight
Width = taskSettings.SafeImageSettings.ThumbnailWidth,
Height = taskSettings.SafeImageSettings.ThumbnailHeight
}.Apply(thumbImage);
thumbImage = ImageHelpers.FillBackground(thumbImage, Color.White);
thumbImage.SaveJPG(thumbnailFilePath, 90);
@ -118,10 +118,10 @@ public static MemoryStream SaveImage(Image img, EImageFormat imageFormat, TaskSe
img.Save(stream, ImageFormat.Png);
break;
case EImageFormat.JPEG:
img.SaveJPG(stream, taskSettings.ImageSettings.ImageJPEGQuality);
img.SaveJPG(stream, taskSettings.SafeImageSettings.ImageJPEGQuality);
break;
case EImageFormat.GIF:
img.SaveGIF(stream, taskSettings.ImageSettings.ImageGIFQuality);
img.SaveGIF(stream, taskSettings.SafeImageSettings.ImageGIFQuality);
break;
case EImageFormat.BMP:
img.Save(stream, ImageFormat.Bmp);
@ -139,11 +139,11 @@ public static string GetFilename(TaskSettings taskSettings, string extension = "
NameParser nameParser = new NameParser(NameParserType.FileName)
{
AutoIncrementNumber = Program.Settings.NameParserAutoIncrementNumber,
MaxNameLength = taskSettings.AdvancedSettings.NamePatternMaxLength,
MaxTitleLength = taskSettings.AdvancedSettings.NamePatternMaxTitleLength
MaxNameLength = taskSettings.SafeAdvancedSettings.NamePatternMaxLength,
MaxTitleLength = taskSettings.SafeAdvancedSettings.NamePatternMaxTitleLength
};
string filename = nameParser.Parse(taskSettings.UploadSettings.NameFormatPattern);
string filename = nameParser.Parse(taskSettings.SafeUploadSettings.NameFormatPattern);
if (!string.IsNullOrEmpty(extension))
{
@ -163,8 +163,8 @@ public static string GetImageFilename(TaskSettings taskSettings, Image image)
{
Picture = image,
AutoIncrementNumber = Program.Settings.NameParserAutoIncrementNumber,
MaxNameLength = taskSettings.AdvancedSettings.NamePatternMaxLength,
MaxTitleLength = taskSettings.AdvancedSettings.NamePatternMaxTitleLength
MaxNameLength = taskSettings.SafeAdvancedSettings.NamePatternMaxLength,
MaxTitleLength = taskSettings.SafeAdvancedSettings.NamePatternMaxTitleLength
};
ImageTag imageTag = image.Tag as ImageTag;
@ -177,11 +177,11 @@ public static string GetImageFilename(TaskSettings taskSettings, Image image)
if (string.IsNullOrEmpty(nameParser.WindowText))
{
filename = nameParser.Parse(taskSettings.UploadSettings.NameFormatPattern) + ".bmp";
filename = nameParser.Parse(taskSettings.SafeUploadSettings.NameFormatPattern) + ".bmp";
}
else
{
filename = nameParser.Parse(taskSettings.UploadSettings.NameFormatPatternActiveWindow) + ".bmp";
filename = nameParser.Parse(taskSettings.SafeUploadSettings.NameFormatPatternActiveWindow) + ".bmp";
}
Program.Settings.NameParserAutoIncrementNumber = nameParser.AutoIncrementNumber;
@ -191,7 +191,7 @@ public static string GetImageFilename(TaskSettings taskSettings, Image image)
public static void ShowResultNotifications(string notificationText, TaskSettings taskSettings, string filePath)
{
if (!taskSettings.AdvancedSettings.DisableNotifications)
if (!taskSettings.SafeAdvancedSettings.DisableNotifications)
{
if (!string.IsNullOrEmpty(notificationText))
{
@ -207,13 +207,13 @@ public static void ShowResultNotifications(string notificationText, TaskSettings
case PopUpNotificationType.ToastNotification:
NotificationFormConfig toastConfig = new NotificationFormConfig()
{
Action = taskSettings.AdvancedSettings.ToastWindowClickAction,
Action = taskSettings.SafeAdvancedSettings.ToastWindowClickAction,
FilePath = filePath,
Text = "ShareX - Task completed\r\n" + notificationText,
URL = notificationText
};
NotificationForm.Show((int)(taskSettings.AdvancedSettings.ToastWindowDuration * 1000), taskSettings.AdvancedSettings.ToastWindowPlacement,
taskSettings.AdvancedSettings.ToastWindowSize, toastConfig);
NotificationForm.Show((int)(taskSettings.SafeAdvancedSettings.ToastWindowDuration * 1000), taskSettings.SafeAdvancedSettings.ToastWindowPlacement,
taskSettings.SafeAdvancedSettings.ToastWindowSize, toastConfig);
break;
}
}
@ -246,20 +246,20 @@ public static Image AnnotateImage(Image img, string imgPath)
public static Image AddImageEffects(Image img, TaskSettings taskSettings)
{
if (taskSettings.ImageSettings.ShowImageEffectsWindowAfterCapture)
if (taskSettings.SafeImageSettings.ShowImageEffectsWindowAfterCapture)
{
using (ImageEffectsForm imageEffectsForm = new ImageEffectsForm(img, taskSettings.ImageSettings.ImageEffects))
using (ImageEffectsForm imageEffectsForm = new ImageEffectsForm(img, taskSettings.SafeImageSettings.ImageEffects))
{
if (imageEffectsForm.ShowDialog() == DialogResult.OK)
{
taskSettings.ImageSettings.ImageEffects = imageEffectsForm.Effects;
taskSettings.SafeImageSettings.ImageEffects = imageEffectsForm.Effects;
}
}
}
using (img)
{
return ImageEffectManager.ApplyEffects(img, taskSettings.ImageSettings.ImageEffects);
return ImageEffectManager.ApplyEffects(img, taskSettings.SafeImageSettings.ImageEffects);
}
}
@ -280,26 +280,26 @@ public static void AddDefaultExternalPrograms(TaskSettings taskSettings)
private static void AddExternalProgramFromFile(TaskSettings taskSettings, string name, string filename, string args = "")
{
if (!taskSettings.ExternalPrograms.Exists(x => x.Name == name))
if (!taskSettings.SafeActions.Exists(x => x.Name == name))
{
if (File.Exists(filename))
{
DebugHelper.WriteLine("Found program: " + filename);
taskSettings.ExternalPrograms.Add(new ExternalProgram(name, filename, args));
taskSettings.SafeActions.Add(new ExternalProgram(name, filename, args));
}
}
}
private static void AddExternalProgramFromRegistry(TaskSettings taskSettings, string name, string filename)
{
if (!taskSettings.ExternalPrograms.Exists(x => x.Name == name))
if (!taskSettings.SafeActions.Exists(x => x.Name == name))
{
ExternalProgram externalProgram = RegistryHelpers.FindProgram(name, filename);
if (externalProgram != null)
{
taskSettings.ExternalPrograms.Add(externalProgram);
taskSettings.SafeActions.Add(externalProgram);
}
}
}
@ -416,7 +416,7 @@ public static string CheckFilePath(string folder, string filename, TaskSettings
if (File.Exists(filepath))
{
switch (taskSettings.ImageSettings.FileExistAction)
switch (taskSettings.SafeImageSettings.FileExistAction)
{
case FileExistAction.Ask:
using (FileExistForm form = new FileExistForm(filepath))

18
ShareX/TaskInfo.cs
View file

@ -43,7 +43,7 @@ public bool IsUploadJob
{
get
{
return Job != TaskJob.ImageJob || TaskSettings.AfterCaptureJob.HasFlag(AfterCaptureTasks.UploadImageToHost);
return Job != TaskJob.ImageJob || TaskSettings.SafeAfterTasks.AfterCaptureJob.HasFlag(AfterCaptureTasks.UploadImageToHost);
}
}
@ -72,8 +72,8 @@ public EDataType UploadDestination
{
get
{
if ((DataType == EDataType.Image && TaskSettings.ImageDestination == ImageDestination.FileUploader) ||
(DataType == EDataType.Text && TaskSettings.TextDestination == TextDestination.FileUploader))
if ((DataType == EDataType.Image && TaskSettings.SafeDestinations.ImageDestination == ImageDestination.FileUploader) ||
(DataType == EDataType.Text && TaskSettings.SafeDestinations.TextDestination == TextDestination.FileUploader))
{
return EDataType.File;
}
@ -89,22 +89,22 @@ public string UploaderHost
switch (UploadDestination)
{
case EDataType.Image:
return TaskSettings.ImageDestination.GetDescription();
return TaskSettings.SafeDestinations.ImageDestination.GetDescription();
case EDataType.Text:
return TaskSettings.TextDestination.GetDescription();
return TaskSettings.SafeDestinations.TextDestination.GetDescription();
case EDataType.File:
switch (DataType)
{
case EDataType.Image:
return TaskSettings.ImageFileDestination.GetDescription();
return TaskSettings.SafeDestinations.ImageFileDestination.GetDescription();
case EDataType.Text:
return TaskSettings.TextFileDestination.GetDescription();
return TaskSettings.SafeDestinations.TextFileDestination.GetDescription();
default:
case EDataType.File:
return TaskSettings.FileDestination.GetDescription();
return TaskSettings.SafeDestinations.FileDestination.GetDescription();
}
case EDataType.URL:
return TaskSettings.URLShortenerDestination.GetDescription();
return TaskSettings.SafeDestinations.URLShortenerDestination.GetDescription();
}
return string.Empty;

6
ShareX/TaskManager.cs
View file

@ -299,16 +299,16 @@ private static void task_UploadCompleted(UploadTask task)
HistoryManager.AddHistoryItemAsync(Program.HistoryFilePath, info.GetHistoryItem());
}
if (!info.TaskSettings.AdvancedSettings.DisableNotifications)
if (!info.TaskSettings.SafeAdvancedSettings.DisableNotifications)
{
if (task.Info.TaskSettings.GeneralSettings.PlaySoundAfterUpload)
{
SystemSounds.Exclamation.Play();
}
if (!string.IsNullOrEmpty(info.TaskSettings.AdvancedSettings.BalloonTipContentFormat))
if (!string.IsNullOrEmpty(info.TaskSettings.SafeAdvancedSettings.BalloonTipContentFormat))
{
result = new UploadInfoParser().Parse(info, info.TaskSettings.AdvancedSettings.BalloonTipContentFormat);
result = new UploadInfoParser().Parse(info, info.TaskSettings.SafeAdvancedSettings.BalloonTipContentFormat);
}
TaskHelpers.ShowResultNotifications(result, info.TaskSettings, info.FilePath);

136
ShareX/TaskSettings.cs
View file

@ -33,22 +33,31 @@ You should have received a copy of the GNU General Public License
using System.ComponentModel;
using System.Drawing;
using System.Drawing.Design;
using System.Text;
using UploadersLib;
namespace ShareX
{
public class TaskSettings
{
public bool SettingsMigrated = false;
public string Description = string.Empty;
public HotkeyType Job = HotkeyType.None;
public bool UseDefaultAfterCaptureJob = true;
public AfterCaptureTasks AfterCaptureJob = AfterCaptureTasks.CopyImageToClipboard | AfterCaptureTasks.SaveImageToFile | AfterCaptureTasks.UploadImageToHost;
public bool UseDefaultAfterUploadJob = true;
public TaskSettingsAfterTasks TaskSettingsAfterTasks = new TaskSettingsAfterTasks();
#region Deprecated - See TaskSettingsAfterTasks - these settings will be removed at v8.10.0
public AfterCaptureTasks AfterCaptureJob = AfterCaptureTasks.CopyImageToClipboard | AfterCaptureTasks.SaveImageToFile | AfterCaptureTasks.UploadImageToHost;
public AfterUploadTasks AfterUploadJob = AfterUploadTasks.CopyURLToClipboard;
public bool UseDefaultDestinations = true;
#endregion Deprecated - See TaskSettingsAfterTasks - these settings will be removed at v8.10.0
#region Deprecated - See DestinationSettings - these settings will be removed at v8.10.0
public ImageDestination ImageDestination = ImageDestination.Imgur;
public FileDestination ImageFileDestination = FileDestination.Dropbox;
public TextDestination TextDestination = TextDestination.Pastebin;
@ -59,6 +68,11 @@ public class TaskSettings
public bool OverrideFTP = false;
public int FTPIndex = 0;
#endregion Deprecated - See DestinationSettings - these settings will be removed at v8.10.0
public bool UseDefaultDestinations = true;
public TaskSettingsDestinations TaskDestinations = new TaskSettingsDestinations();
public bool UseDefaultGeneralSettings = true;
public TaskSettingsGeneral GeneralSettings = new TaskSettingsGeneral();
@ -113,6 +127,87 @@ public static TaskSettings GetDefaultTaskSettings()
return taskSettings;
}
public TaskSettingsAfterTasks SafeAfterTasks
{
get
{
return UseDefaultAfterCaptureJob && Program.DefaultTaskSettings != null ?
Program.DefaultTaskSettings.TaskSettingsAfterTasks : TaskSettingsAfterTasks;
}
}
public TaskSettingsDestinations SafeDestinations
{
get
{
return UseDefaultDestinations && Program.DefaultTaskSettings != null ?
Program.DefaultTaskSettings.TaskDestinations : TaskDestinations;
}
}
public TaskSettingsGeneral SafeGeneralSettings
{
get
{
return UseDefaultGeneralSettings && Program.DefaultTaskSettings != null ?
Program.DefaultTaskSettings.GeneralSettings : GeneralSettings;
}
}
public TaskSettingsImage SafeImageSettings
{
get
{
return UseDefaultImageSettings && Program.DefaultTaskSettings != null ?
Program.DefaultTaskSettings.ImageSettings : ImageSettings;
}
}
public TaskSettingsCapture SafeCaptureSettings
{
get
{
return UseDefaultCaptureSettings && Program.DefaultTaskSettings != null ?
Program.DefaultTaskSettings.CaptureSettings : CaptureSettings;
}
}
public List<ExternalProgram> SafeActions
{
get
{
return UseDefaultActions && Program.DefaultTaskSettings != null ?
Program.DefaultTaskSettings.ExternalPrograms : ExternalPrograms;
}
}
public TaskSettingsUpload SafeUploadSettings
{
get
{
return UseDefaultUploadSettings && Program.DefaultTaskSettings != null ?
Program.DefaultTaskSettings.UploadSettings : UploadSettings;
}
}
public IndexerSettings SafeIndexerSettings
{
get
{
return UseDefaultIndexerSettings && Program.DefaultTaskSettings != null ?
Program.DefaultTaskSettings.IndexerSettings : IndexerSettings;
}
}
public TaskSettingsAdvanced SafeAdvancedSettings
{
get
{
return UseDefaultAdvancedSettings && Program.DefaultTaskSettings != null ?
Program.DefaultTaskSettings.AdvancedSettings : AdvancedSettings;
}
}
public static TaskSettings GetSafeTaskSettings(TaskSettings taskSettings)
{
TaskSettings taskSettingsCopy;
@ -149,6 +244,11 @@ private void SetDefaultSettings()
AfterUploadJob = defaultTaskSettings.AfterUploadJob;
}
if (UseDefaultDestinations)
{
TaskDestinations = defaultTaskSettings.TaskDestinations;
}
if (UseDefaultDestinations)
{
ImageDestination = defaultTaskSettings.ImageDestination;
@ -209,6 +309,36 @@ public string CaptureFolder
}
}
public class TaskSettingsAfterTasks
{
public AfterCaptureTasks AfterCaptureJob = AfterCaptureTasks.CopyImageToClipboard | AfterCaptureTasks.SaveImageToFile | AfterCaptureTasks.UploadImageToHost;
public AfterUploadTasks AfterUploadJob = AfterUploadTasks.CopyURLToClipboard;
}
public class TaskSettingsDestinations
{
public ImageDestination ImageDestination = ImageDestination.Imgur;
public FileDestination ImageFileDestination = FileDestination.Dropbox;
public TextDestination TextDestination = TextDestination.Pastebin;
public FileDestination TextFileDestination = FileDestination.Dropbox;
public FileDestination FileDestination = FileDestination.Dropbox;
public UrlShortenerType URLShortenerDestination = UrlShortenerType.BITLY;
public SocialNetworkingService SocialNetworkingServiceDestination = SocialNetworkingService.Twitter;
public bool OverrideFTP = false;
public int FTPIndex = 0;
public override string ToString()
{
StringBuilder sb = new StringBuilder();
sb.AppendLine("Image destination: " + ((ImageDestination == UploadersLib.ImageDestination.FileUploader) ? ImageFileDestination.GetDescription() : ImageDestination.GetDescription()));
sb.AppendLine("Text destination: " + ((TextDestination == UploadersLib.TextDestination.FileUploader) ? TextFileDestination.GetDescription() : TextDestination.GetDescription()));
sb.AppendLine("File destination: " + FileDestination.GetDescription());
sb.AppendLine("URL shortener: " + URLShortenerDestination.GetDescription());
sb.AppendLine("Social network: " + SocialNetworkingServiceDestination.GetDescription());
return sb.ToString();
}
}
public class TaskSettingsGeneral
{
public bool PlaySoundAfterCapture = true;

8
ShareX/UploadManager.cs
View file

@ -153,9 +153,9 @@ public static void ClipboardUpload(TaskSettings taskSettings = null)
if (img != null)
{
if (!taskSettings.AdvancedSettings.ProcessImagesDuringClipboardUpload)
if (!taskSettings.SafeAdvancedSettings.ProcessImagesDuringClipboardUpload)
{
taskSettings.AfterCaptureJob = AfterCaptureTasks.UploadImageToHost;
taskSettings.SafeAfterTasks.AfterCaptureJob = AfterCaptureTasks.UploadImageToHost;
}
RunImageTask(img, taskSettings);
@ -279,7 +279,7 @@ public static void RunImageTask(Image img, AfterCaptureTasks imageJob = AfterCap
{
TaskSettings taskSettings = TaskSettings.GetDefaultTaskSettings();
taskSettings.UseDefaultAfterCaptureJob = false;
taskSettings.AfterCaptureJob = imageJob;
taskSettings.SafeAfterTasks.AfterCaptureJob = imageJob;
RunImageTask(img, taskSettings);
}
@ -291,7 +291,7 @@ public static void UploadImage(Image img, ImageDestination imageDestination)
{
TaskSettings taskSettings = TaskSettings.GetDefaultTaskSettings();
taskSettings.UseDefaultDestinations = false;
taskSettings.ImageDestination = imageDestination;
taskSettings.SafeDestinations.ImageDestination = imageDestination;
RunImageTask(img, taskSettings);
}

88
ShareX/UploadTask.cs
View file

@ -101,13 +101,13 @@ public static UploadTask CreateFileUploaderTask(string filePath, TaskSettings ta
task.Info.DataType = dataType;
task.Info.FilePath = filePath;
if (task.Info.TaskSettings.UploadSettings.FileUploadUseNamePattern)
if (task.Info.TaskSettings.SafeUploadSettings.FileUploadUseNamePattern)
{
string ext = Path.GetExtension(task.Info.FilePath);
task.Info.FileName = TaskHelpers.GetFilename(task.Info.TaskSettings, ext);
}
if (task.Info.TaskSettings.AdvancedSettings.ProcessImagesDuringFileUpload && dataType == EDataType.Image)
if (task.Info.TaskSettings.SafeAdvancedSettings.ProcessImagesDuringFileUpload && dataType == EDataType.Image)
{
task.Info.Job = TaskJob.ImageJob;
task.tempImage = ImageHelpers.LoadImage(filePath);
@ -137,7 +137,7 @@ public static UploadTask CreateTextUploaderTask(string text, TaskSettings taskSe
UploadTask task = new UploadTask(taskSettings);
task.Info.Job = TaskJob.TextUpload;
task.Info.DataType = EDataType.Text;
task.Info.FileName = TaskHelpers.GetFilename(taskSettings, taskSettings.AdvancedSettings.TextFileExtension);
task.Info.FileName = TaskHelpers.GetFilename(taskSettings, taskSettings.SafeAdvancedSettings.TextFileExtension);
task.tempText = text;
return task;
}
@ -230,7 +230,7 @@ private void ThreadDoWork()
MessageBoxButtons.YesNo, MessageBoxIcon.Warning) == DialogResult.No)
{
Program.Settings.ShowUploadWarning = false;
Program.DefaultTaskSettings.AfterCaptureJob = Program.DefaultTaskSettings.AfterCaptureJob.Remove(AfterCaptureTasks.UploadImageToHost);
Program.DefaultTaskSettings.SafeAfterTasks.AfterCaptureJob = Program.DefaultTaskSettings.SafeAfterTasks.AfterCaptureJob.Remove(AfterCaptureTasks.UploadImageToHost);
RequestSettingUpdate = true;
Stop();
}
@ -298,11 +298,11 @@ private bool DoUpload(int retry = 0)
{
if (Program.Settings.UseSecondaryUploaders)
{
Info.TaskSettings.ImageDestination = Program.Settings.SecondaryImageUploaders[retry - 1];
Info.TaskSettings.ImageFileDestination = Program.Settings.SecondaryFileUploaders[retry - 1];
Info.TaskSettings.TextDestination = Program.Settings.SecondaryTextUploaders[retry - 1];
Info.TaskSettings.TextFileDestination = Program.Settings.SecondaryFileUploaders[retry - 1];
Info.TaskSettings.FileDestination = Program.Settings.SecondaryFileUploaders[retry - 1];
Info.TaskSettings.SafeDestinations.ImageDestination = Program.Settings.SecondaryImageUploaders[retry - 1];
Info.TaskSettings.SafeDestinations.ImageFileDestination = Program.Settings.SecondaryFileUploaders[retry - 1];
Info.TaskSettings.SafeDestinations.TextDestination = Program.Settings.SecondaryTextUploaders[retry - 1];
Info.TaskSettings.SafeDestinations.TextFileDestination = Program.Settings.SecondaryFileUploaders[retry - 1];
Info.TaskSettings.SafeDestinations.FileDestination = Program.Settings.SecondaryFileUploaders[retry - 1];
}
else
{
@ -365,28 +365,28 @@ private void DoThreadJob()
private void DoAfterCaptureJobs()
{
if (Info.TaskSettings.AfterCaptureJob.HasFlag(AfterCaptureTasks.AddImageEffects))
if (Info.TaskSettings.SafeAfterTasks.AfterCaptureJob.HasFlag(AfterCaptureTasks.AddImageEffects))
{
tempImage = TaskHelpers.AddImageEffects(tempImage, Info.TaskSettings);
}
if (Info.TaskSettings.AfterCaptureJob.HasFlag(AfterCaptureTasks.AddWatermark) && Info.TaskSettings.ImageSettings.WatermarkConfig != null)
if (Info.TaskSettings.SafeAfterTasks.AfterCaptureJob.HasFlag(AfterCaptureTasks.AddWatermark) && Info.TaskSettings.SafeImageSettings.WatermarkConfig != null)
{
Info.TaskSettings.ImageSettings.WatermarkConfig.Apply(tempImage);
Info.TaskSettings.SafeImageSettings.WatermarkConfig.Apply(tempImage);
}
if (Info.TaskSettings.AfterCaptureJob.HasFlag(AfterCaptureTasks.AnnotateImage))
if (Info.TaskSettings.SafeAfterTasks.AfterCaptureJob.HasFlag(AfterCaptureTasks.AnnotateImage))
{
tempImage = TaskHelpers.AnnotateImage(tempImage, Info.FileName);
}
if (Info.TaskSettings.AfterCaptureJob.HasFlag(AfterCaptureTasks.CopyImageToClipboard))
if (Info.TaskSettings.SafeAfterTasks.AfterCaptureJob.HasFlag(AfterCaptureTasks.CopyImageToClipboard))
{
ClipboardHelpers.CopyImage(tempImage);
DebugHelper.WriteLine("CopyImageToClipboard");
}
if (Info.TaskSettings.AfterCaptureJob.HasFlag(AfterCaptureTasks.SendImageToPrinter))
if (Info.TaskSettings.SafeAfterTasks.AfterCaptureJob.HasFlag(AfterCaptureTasks.SendImageToPrinter))
{
if (Program.Settings.DontShowPrintSettingsDialog)
{
@ -405,7 +405,7 @@ private void DoAfterCaptureJobs()
}
}
if (Info.TaskSettings.AfterCaptureJob.HasFlagAny(AfterCaptureTasks.SaveImageToFile, AfterCaptureTasks.SaveImageToFileWithDialog,
if (Info.TaskSettings.SafeAfterTasks.AfterCaptureJob.HasFlagAny(AfterCaptureTasks.SaveImageToFile, AfterCaptureTasks.SaveImageToFileWithDialog,
AfterCaptureTasks.UploadImageToHost))
{
using (tempImage)
@ -414,7 +414,7 @@ private void DoAfterCaptureJobs()
Data = imageData.ImageStream;
Info.FileName = Path.ChangeExtension(Info.FileName, imageData.ImageFormat.GetDescription());
if (Info.TaskSettings.AfterCaptureJob.HasFlag(AfterCaptureTasks.SaveImageToFile))
if (Info.TaskSettings.SafeAfterTasks.AfterCaptureJob.HasFlag(AfterCaptureTasks.SaveImageToFile))
{
string filePath = TaskHelpers.CheckFilePath(Info.TaskSettings.CaptureFolder, Info.FileName, Info.TaskSettings);
@ -426,7 +426,7 @@ private void DoAfterCaptureJobs()
}
}
if (Info.TaskSettings.AfterCaptureJob.HasFlag(AfterCaptureTasks.SaveImageToFileWithDialog))
if (Info.TaskSettings.SafeAfterTasks.AfterCaptureJob.HasFlag(AfterCaptureTasks.SaveImageToFileWithDialog))
{
using (SaveFileDialog sfd = new SaveFileDialog())
{
@ -451,7 +451,7 @@ private void DoAfterCaptureJobs()
}
}
if (Info.TaskSettings.AfterCaptureJob.HasFlag(AfterCaptureTasks.SaveThumbnailImageToFile))
if (Info.TaskSettings.SafeAfterTasks.AfterCaptureJob.HasFlag(AfterCaptureTasks.SaveThumbnailImageToFile))
{
string thumbnailFilename, thumbnailFolder;
@ -474,20 +474,20 @@ private void DoAfterCaptureJobs()
}
}
if (Info.TaskSettings.AfterCaptureJob.HasFlag(AfterCaptureTasks.CopyFileToClipboard) && !string.IsNullOrEmpty(Info.FilePath) &&
if (Info.TaskSettings.SafeAfterTasks.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))
else if (Info.TaskSettings.SafeAfterTasks.AfterCaptureJob.HasFlag(AfterCaptureTasks.CopyFilePathToClipboard) && !string.IsNullOrEmpty(Info.FilePath))
{
ClipboardHelpers.CopyText(Info.FilePath);
}
if (Info.TaskSettings.AfterCaptureJob.HasFlag(AfterCaptureTasks.PerformActions) && Info.TaskSettings.ExternalPrograms != null &&
if (Info.TaskSettings.SafeAfterTasks.AfterCaptureJob.HasFlag(AfterCaptureTasks.PerformActions) && Info.TaskSettings.SafeActions != null &&
!string.IsNullOrEmpty(Info.FilePath) && File.Exists(Info.FilePath))
{
var actions = Info.TaskSettings.ExternalPrograms.Where(x => x.IsActive);
var actions = Info.TaskSettings.SafeActions.Where(x => x.IsActive);
if (actions.Count() > 0)
{
@ -512,8 +512,8 @@ private void DoAfterUploadJobs()
{
try
{
if (Info.TaskSettings.AfterUploadJob.HasFlag(AfterUploadTasks.UseURLShortener) || Info.Job == TaskJob.ShortenURL ||
(Info.TaskSettings.AdvancedSettings.AutoShortenURLLength > 0 && Info.Result.URL.Length > Info.TaskSettings.AdvancedSettings.AutoShortenURLLength))
if (Info.TaskSettings.SafeAfterTasks.AfterUploadJob.HasFlag(AfterUploadTasks.UseURLShortener) || Info.Job == TaskJob.ShortenURL ||
(Info.TaskSettings.SafeAdvancedSettings.AutoShortenURLLength > 0 && Info.Result.URL.Length > Info.TaskSettings.SafeAdvancedSettings.AutoShortenURLLength))
{
UploadResult result = ShortenURL(Info.Result.URL);
@ -523,7 +523,7 @@ private void DoAfterUploadJobs()
}
}
if (Info.TaskSettings.AfterUploadJob.HasFlag(AfterUploadTasks.ShareURLToSocialNetworkingService))
if (Info.TaskSettings.SafeAfterTasks.AfterUploadJob.HasFlag(AfterUploadTasks.ShareURLToSocialNetworkingService))
{
OAuthInfo twitterOAuth = Program.UploadersConfig.TwitterOAuthInfoList.ReturnIfValidIndex(Program.UploadersConfig.TwitterSelectedAccount);
@ -538,7 +538,7 @@ private void DoAfterUploadJobs()
}
}
if (Info.TaskSettings.AfterUploadJob.HasFlag(AfterUploadTasks.SendURLWithEmail))
if (Info.TaskSettings.SafeAfterTasks.AfterUploadJob.HasFlag(AfterUploadTasks.SendURLWithEmail))
{
using (EmailForm emailForm = new EmailForm(Program.UploadersConfig.EmailRememberLastTo ? Program.UploadersConfig.EmailLastTo : string.Empty,
Program.UploadersConfig.EmailDefaultSubject, Info.Result.ToString()))
@ -565,13 +565,13 @@ private void DoAfterUploadJobs()
}
}
if (Info.TaskSettings.AfterUploadJob.HasFlag(AfterUploadTasks.CopyURLToClipboard))
if (Info.TaskSettings.SafeAfterTasks.AfterUploadJob.HasFlag(AfterUploadTasks.CopyURLToClipboard))
{
string txt;
if (!string.IsNullOrEmpty(Info.TaskSettings.AdvancedSettings.ClipboardContentFormat))
if (!string.IsNullOrEmpty(Info.TaskSettings.SafeAdvancedSettings.ClipboardContentFormat))
{
txt = new UploadInfoParser().Parse(Info, Info.TaskSettings.AdvancedSettings.ClipboardContentFormat);
txt = new UploadInfoParser().Parse(Info, Info.TaskSettings.SafeAdvancedSettings.ClipboardContentFormat);
}
else
{
@ -596,11 +596,11 @@ public UploadResult UploadImage(Stream stream, string fileName)
{
ImageUploader imageUploader = null;
switch (Info.TaskSettings.ImageDestination)
switch (Info.TaskSettings.SafeDestinations.ImageDestination)
{
case ImageDestination.ImageShack:
Program.UploadersConfig.ImageShackSettings.ThumbnailWidth = Info.TaskSettings.AdvancedSettings.ThumbnailPreferredWidth;
Program.UploadersConfig.ImageShackSettings.ThumbnailHeight = Info.TaskSettings.AdvancedSettings.ThumbnailPreferredHeight;
Program.UploadersConfig.ImageShackSettings.ThumbnailWidth = Info.TaskSettings.SafeAdvancedSettings.ThumbnailPreferredWidth;
Program.UploadersConfig.ImageShackSettings.ThumbnailHeight = Info.TaskSettings.SafeAdvancedSettings.ThumbnailPreferredHeight;
imageUploader = new ImageShackUploader(APIKeys.ImageShackKey, Program.UploadersConfig.ImageShackSettings);
break;
case ImageDestination.TinyPic:
@ -679,27 +679,27 @@ public UploadResult UploadText(Stream stream, string fileName)
{
TextUploader textUploader = null;
switch (Info.TaskSettings.TextDestination)
switch (Info.TaskSettings.SafeDestinations.TextDestination)
{
case TextDestination.Pastebin:
PastebinSettings settings = Program.UploadersConfig.PastebinSettings;
if (string.IsNullOrEmpty(settings.TextFormat))
{
settings.TextFormat = Info.TaskSettings.AdvancedSettings.TextFormat;
settings.TextFormat = Info.TaskSettings.SafeAdvancedSettings.TextFormat;
}
textUploader = new Pastebin(APIKeys.PastebinKey, settings);
break;
case TextDestination.PastebinCA:
textUploader = new Pastebin_ca(APIKeys.PastebinCaKey, new PastebinCaSettings { TextFormat = Info.TaskSettings.AdvancedSettings.TextFormat });
textUploader = new Pastebin_ca(APIKeys.PastebinCaKey, new PastebinCaSettings { TextFormat = Info.TaskSettings.SafeAdvancedSettings.TextFormat });
break;
case TextDestination.Paste2:
textUploader = new Paste2(new Paste2Settings { TextFormat = Info.TaskSettings.AdvancedSettings.TextFormat });
textUploader = new Paste2(new Paste2Settings { TextFormat = Info.TaskSettings.SafeAdvancedSettings.TextFormat });
break;
case TextDestination.Slexy:
textUploader = new Slexy(new SlexySettings { TextFormat = Info.TaskSettings.AdvancedSettings.TextFormat });
textUploader = new Slexy(new SlexySettings { TextFormat = Info.TaskSettings.SafeAdvancedSettings.TextFormat });
break;
case TextDestination.Pastee:
textUploader = new Pastee { Lexer = Info.TaskSettings.AdvancedSettings.TextFormat };
textUploader = new Pastee { Lexer = Info.TaskSettings.SafeAdvancedSettings.TextFormat };
break;
case TextDestination.Paste_ee:
textUploader = new Paste_ee(Program.UploadersConfig.Paste_eeUserAPIKey);
@ -741,14 +741,14 @@ public UploadResult UploadFile(Stream stream, string fileName)
switch (Info.DataType)
{
case EDataType.Image:
fileDestination = Info.TaskSettings.ImageFileDestination;
fileDestination = Info.TaskSettings.SafeDestinations.ImageFileDestination;
break;
case EDataType.Text:
fileDestination = Info.TaskSettings.TextFileDestination;
fileDestination = Info.TaskSettings.SafeDestinations.TextFileDestination;
break;
default:
case EDataType.File:
fileDestination = Info.TaskSettings.FileDestination;
fileDestination = Info.TaskSettings.SafeDestinations.FileDestination;
break;
}
@ -818,7 +818,7 @@ public UploadResult UploadFile(Stream stream, string fileName)
}
break;
case FileDestination.FTP:
int index = Info.TaskSettings.OverrideFTP ? Info.TaskSettings.FTPIndex.BetweenOrDefault(0, Program.UploadersConfig.FTPAccountList.Count - 1) : Program.UploadersConfig.GetFTPIndex(Info.DataType);
int index = Info.TaskSettings.SafeDestinations.OverrideFTP ? Info.TaskSettings.SafeDestinations.FTPIndex.BetweenOrDefault(0, Program.UploadersConfig.FTPAccountList.Count - 1) : Program.UploadersConfig.GetFTPIndex(Info.DataType);
FTPAccount account = Program.UploadersConfig.FTPAccountList.ReturnIfValidIndex(index);
@ -901,7 +901,7 @@ public UploadResult ShortenURL(string url)
{
URLShortener urlShortener = null;
switch (Info.TaskSettings.URLShortenerDestination)
switch (Info.TaskSettings.SafeDestinations.URLShortenerDestination)
{
case UrlShortenerType.BITLY:
if (Program.UploadersConfig.BitlyOAuth2Info == null)