public static void AddDefaultExternalPrograms(TaskSettings taskSettings)
{
if (taskSettings.ExternalPrograms == null)
{
taskSettings.ExternalPrograms = new List<ExternalProgram>();
}
AddExternalProgramFromRegistry(taskSettings, "Paint", "mspaint.exe");
AddExternalProgramFromRegistry(taskSettings, "Paint.NET", "PaintDotNet.exe");
AddExternalProgramFromRegistry(taskSettings, "Adobe Photoshop", "Photoshop.exe");
AddExternalProgramFromRegistry(taskSettings, "IrfanView", "i_view32.exe");
AddExternalProgramFromRegistry(taskSettings, "XnView", "xnview.exe");
AddExternalProgramFromFile(taskSettings, "OptiPNG", "optipng.exe");
}
public static Image AddImageEffects(Image img, TaskSettings taskSettings)
{
if (taskSettings.ImageSettings.ShowImageEffectsWindowAfterCapture)
{
using (ImageEffectsForm imageEffectsForm = new ImageEffectsForm(img, taskSettings.ImageSettings.ImageEffects))
{
if (imageEffectsForm.ShowDialog() == DialogResult.OK)
{
taskSettings.ImageSettings.ImageEffects = imageEffectsForm.Effects;
}
}
}
using (img)
{
return ImageEffectManager.ApplyEffects(img, taskSettings.ImageSettings.ImageEffects);
}
}
public AfterCaptureForm(Image img, TaskSettings taskSettings)
{
InitializeComponent();
ImageList imageList = new ImageList { ColorDepth = ColorDepth.Depth32Bit };
imageList.Images.Add(Resources.checkbox_uncheck);
imageList.Images.Add(Resources.checkbox_check);
lvAfterCaptureTasks.SmallImageList = imageList;
ucBeforeUpload.InitCapture(taskSettings);
AfterCaptureTasks = taskSettings.AfterCaptureJob;
AddAfterCaptureItems(AfterCaptureTasks);
btnCopy.Visible = img != null;
if (img != null)
{
pbImage.LoadImage(img);
}
}
public void AddWatchFolder(WatchFolderSettings watchFolderSetting, TaskSettings taskSettings)
{
if (!IsExist(watchFolderSetting))
{
if (!taskSettings.WatchFolderList.Contains(watchFolderSetting))
{
taskSettings.WatchFolderList.Add(watchFolderSetting);
}
WatchFolder watchFolder = new WatchFolder { Settings = watchFolderSetting, TaskSettings = taskSettings };
watchFolder.FileWatcherTrigger += path =>
{
TaskSettings taskSettingsCopy = TaskSettings.GetSafeTaskSettings(taskSettings);
UploadManager.UploadFile(path, taskSettingsCopy);
};
WatchFolders.Add(watchFolder);
if (taskSettings.WatchFolderEnabled)
{
watchFolder.Enable();
}
}
}
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,
CustomTimeZone = taskSettings.UploadSettings.UseCustomTimeZone ? taskSettings.UploadSettings.CustomTimeZone : null
};
string filename = nameParser.Parse(taskSettings.UploadSettings.NameFormatPattern);
if (!string.IsNullOrEmpty(extension))
{
filename += "." + extension.TrimStart('.');
}
Program.Settings.NameParserAutoIncrementNumber = nameParser.AutoIncrementNumber;
return filename;
}
public void StartRecording(ScreenRecordOutput outputType, TaskSettings taskSettings, ScreenRecordStartMethod startMethod = ScreenRecordStartMethod.Region)
{
string debugText;
if (outputType == ScreenRecordOutput.FFmpeg)
{
debugText = string.Format("Starting FFmpeg recording. Video encoder: \"{0}\", Audio encoder: \"{1}\", FPS: {2}",
taskSettings.CaptureSettings.FFmpegOptions.VideoCodec.GetDescription(), taskSettings.CaptureSettings.FFmpegOptions.AudioCodec.GetDescription(),
taskSettings.CaptureSettings.ScreenRecordFPS);
}
else
{
debugText = string.Format("Starting Animated GIF recording. GIF encoding: \"{0}\", FPS: {1}",
taskSettings.CaptureSettings.GIFEncoding.GetDescription(), taskSettings.CaptureSettings.GIFFPS);
}
DebugHelper.WriteLine(debugText);
if (taskSettings.CaptureSettings.RunScreencastCLI)
{
if (!Program.Settings.VideoEncoders.IsValidIndex(taskSettings.CaptureSettings.VideoEncoderSelected))
{
MessageBox.Show(Resources.ScreenRecordForm_StartRecording_There_is_no_valid_CLI_video_encoder_selected_,
"ShareXYZ", MessageBoxButtons.OK, MessageBoxIcon.Warning);
return;
}
if (!Program.Settings.VideoEncoders[taskSettings.CaptureSettings.VideoEncoderSelected].IsValid())
{
MessageBox.Show(Resources.ScreenRecordForm_StartRecording_CLI_video_encoder_file_does_not_exist__ +
Program.Settings.VideoEncoders[taskSettings.CaptureSettings.VideoEncoderSelected].Path,
"ShareXYZ", MessageBoxButtons.OK, MessageBoxIcon.Warning);
return;
}
}
if (outputType == ScreenRecordOutput.GIF && taskSettings.CaptureSettings.GIFEncoding == ScreenRecordGIFEncoding.FFmpeg)
{
outputType = ScreenRecordOutput.FFmpeg;
taskSettings.CaptureSettings.FFmpegOptions.VideoCodec = FFmpegVideoCodec.gif;
taskSettings.CaptureSettings.FFmpegOptions.UseCustomCommands = false;
}
if (outputType == ScreenRecordOutput.FFmpeg)
{
if (!TaskHelpers.CheckFFmpeg(taskSettings))
{
return;
}
if (!taskSettings.CaptureSettings.FFmpegOptions.IsSourceSelected)
{
MessageBox.Show(Resources.ScreenRecordForm_StartRecording_FFmpeg_video_and_audio_source_both_can_t_be__None__,
"ShareXYZ - " + Resources.ScreenRecordForm_StartRecording_FFmpeg_error, MessageBoxButtons.OK, MessageBoxIcon.Warning);
return;
}
}
Rectangle captureRectangle = Rectangle.Empty;
switch (startMethod)
{
case ScreenRecordStartMethod.Region:
TaskHelpers.SelectRegion(out captureRectangle, taskSettings);
break;
case ScreenRecordStartMethod.ActiveWindow:
if (taskSettings.CaptureSettings.CaptureClientArea)
{
captureRectangle = CaptureHelpers.GetActiveWindowClientRectangle();
}
else
{
captureRectangle = CaptureHelpers.GetActiveWindowRectangle();
}
break;
case ScreenRecordStartMethod.LastRegion:
captureRectangle = Program.Settings.ScreenRecordRegion;
break;
}
captureRectangle = CaptureHelpers.EvenRectangleSize(captureRectangle);
if (IsRecording || !captureRectangle.IsValid() || screenRecorder != null)
{
return;
}
Program.Settings.ScreenRecordRegion = captureRectangle;
IsRecording = true;
Screenshot.CaptureCursor = taskSettings.CaptureSettings.ScreenRecordShowCursor;
string trayText = "ShareXYZ - " + Resources.ScreenRecordForm_StartRecording_Waiting___;
TrayIcon.Text = trayText.Truncate(63);
TrayIcon.Icon = Resources.control_record_yellow.ToIcon();
cmsMain.Enabled = false;
TrayIcon.Visible = true;
string path = "";
float duration = taskSettings.CaptureSettings.ScreenRecordFixedDuration ? taskSettings.CaptureSettings.ScreenRecordDuration : 0;
regionForm = ScreenRegionForm.Show(captureRectangle, StopRecording, startMethod == ScreenRecordStartMethod.Region, duration);
regionForm.RecordResetEvent = new ManualResetEvent(false);
TaskEx.Run(() =>
{
try
{
if (outputType == ScreenRecordOutput.FFmpeg)
{
path = Path.Combine(taskSettings.CaptureFolder, TaskHelpers.GetFilename(taskSettings, taskSettings.CaptureSettings.FFmpegOptions.Extension));
}
else
{
path = Program.ScreenRecorderCacheFilePath;
}
ScreencastOptions options = new ScreencastOptions()
{
FFmpeg = taskSettings.CaptureSettings.FFmpegOptions,
ScreenRecordFPS = taskSettings.CaptureSettings.ScreenRecordFPS,
GIFFPS = taskSettings.CaptureSettings.GIFFPS,
Duration = duration,
OutputPath = path,
CaptureArea = captureRectangle,
DrawCursor = taskSettings.CaptureSettings.ScreenRecordShowCursor
};
screenRecorder = new ScreenRecorder(outputType, options, captureRectangle);
if (regionForm != null && regionForm.RecordResetEvent != null)
{
trayText = "ShareXYZ - " + Resources.ScreenRecordForm_StartRecording_Click_tray_icon_to_start_recording_;
TrayIcon.Text = trayText.Truncate(63);
this.InvokeSafe(() =>
{
tsmiStart.Text = Resources.AutoCaptureForm_Execute_Start;
cmsMain.Enabled = true;
});
if (taskSettings.CaptureSettings.ScreenRecordAutoStart)
{
int delay = (int)(taskSettings.CaptureSettings.ScreenRecordStartDelay * 1000);
if (delay > 0)
{
regionForm.InvokeSafe(() => regionForm.StartCountdown(delay));
regionForm.RecordResetEvent.WaitOne(delay);
}
}
else
{
regionForm.RecordResetEvent.WaitOne();
}
if (regionForm.AbortRequested)
{
abortRequested = true;
}
}
if (!abortRequested)
{
trayText = "ShareXYZ - " + Resources.ScreenRecordForm_StartRecording_Click_tray_icon_to_stop_recording_;
TrayIcon.Text = trayText.Truncate(63);
TrayIcon.Icon = Resources.control_record.ToIcon();
this.InvokeSafe(() =>
{
tsmiStart.Text = Resources.AutoCaptureForm_Execute_Stop;
});
if (regionForm != null)
{
regionForm.InvokeSafe(() => regionForm.StartRecordingTimer(duration > 0, duration));
}
screenRecorder.StartRecording();
if (regionForm != null && regionForm.AbortRequested)
{
abortRequested = true;
}
}
}
catch (Exception e)
{
DebugHelper.WriteException(e);
}
finally
{
if (regionForm != null)
{
if (regionForm.RecordResetEvent != null)
{
regionForm.RecordResetEvent.Dispose();
}
regionForm.InvokeSafe(() => regionForm.Close());
regionForm = null;
}
}
try
{
if (!abortRequested && screenRecorder != null)
{
TrayIcon.Text = "ShareXYZ - " + Resources.ScreenRecordForm_StartRecording_Encoding___;
TrayIcon.Icon = Resources.camcorder_pencil.ToIcon();
this.InvokeSafe(() =>
{
cmsMain.Enabled = false;
});
if (outputType == ScreenRecordOutput.GIF)
{
path = Path.Combine(taskSettings.CaptureFolder, TaskHelpers.GetFilename(taskSettings, "gif"));
screenRecorder.EncodingProgressChanged += progress => TrayIcon.Text = string.Format("ShareXYZ - {0} ({1}%)", Resources.ScreenRecordForm_StartRecording_Encoding___, progress);
GIFQuality gifQuality = taskSettings.CaptureSettings.GIFEncoding == ScreenRecordGIFEncoding.OctreeQuantizer ? GIFQuality.Bit8 : GIFQuality.Default;
screenRecorder.SaveAsGIF(path, gifQuality);
}
else if (outputType == ScreenRecordOutput.FFmpeg && taskSettings.CaptureSettings.FFmpegOptions.VideoCodec == FFmpegVideoCodec.gif)
{
path = Path.Combine(taskSettings.CaptureFolder, TaskHelpers.GetFilename(taskSettings, "gif"));
screenRecorder.FFmpegEncodeAsGIF(path);
}
if (taskSettings.CaptureSettings.RunScreencastCLI)
{
VideoEncoder encoder = Program.Settings.VideoEncoders[taskSettings.CaptureSettings.VideoEncoderSelected];
string sourceFilePath = path;
path = Path.Combine(taskSettings.CaptureFolder, TaskHelpers.GetFilename(taskSettings, encoder.OutputExtension));
screenRecorder.EncodeUsingCommandLine(encoder, sourceFilePath, path);
}
}
}
finally
{
if (screenRecorder != null)
{
if ((outputType == ScreenRecordOutput.GIF || taskSettings.CaptureSettings.RunScreencastCLI ||
(outputType == ScreenRecordOutput.FFmpeg && taskSettings.CaptureSettings.FFmpegOptions.VideoCodec == FFmpegVideoCodec.gif)) &&
!string.IsNullOrEmpty(screenRecorder.CachePath) && File.Exists(screenRecorder.CachePath))
{
File.Delete(screenRecorder.CachePath);
}
screenRecorder.Dispose();
screenRecorder = null;
if (abortRequested && !string.IsNullOrEmpty(path) && File.Exists(path))
{
File.Delete(path);
}
}
}
},
() =>
{
if (TrayIcon.Visible)
{
TrayIcon.Visible = false;
}
if (!abortRequested && !string.IsNullOrEmpty(path) && File.Exists(path) && TaskHelpers.ShowAfterCaptureForm(taskSettings))
{
WorkerTask task = WorkerTask.CreateFileJobTask(path, taskSettings);
TaskManager.Start(task);
}
abortRequested = false;
IsRecording = false;
});
}
public static void OpenVideoThumbnailer(TaskSettings taskSettings = null)
{
if (taskSettings == null) taskSettings = TaskSettings.GetDefaultTaskSettings();
if (!CheckFFmpeg(taskSettings))
{
return;
}
taskSettings.ToolsSettings.VideoThumbnailOptions.DefaultOutputDirectory = taskSettings.CaptureFolder;
VideoThumbnailerForm thumbnailerForm = new VideoThumbnailerForm(taskSettings.CaptureSettings.FFmpegOptions.CLIPath, taskSettings.ToolsSettingsReference.VideoThumbnailOptions);
thumbnailerForm.ThumbnailsTaken += thumbnails =>
{
if (taskSettings.ToolsSettingsReference.VideoThumbnailOptions.UploadThumbnails)
{
foreach (VideoThumbnailInfo thumbnailInfo in thumbnails)
{
UploadManager.UploadFile(thumbnailInfo.Filepath, taskSettings);
}
}
};
thumbnailerForm.Show();
}
public static WorkerTask CreateURLShortenerTask(string url, TaskSettings taskSettings)
{
WorkerTask task = new WorkerTask(taskSettings);
task.Info.Job = TaskJob.ShortenURL;
task.Info.DataType = EDataType.URL;
task.Info.FileName = string.Format(Resources.UploadTask_CreateURLShortenerTask_Shorten_URL___0__, taskSettings.URLShortenerDestination.GetLocalizedDescription());
task.Info.Result.URL = url;
return task;
}
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)))
{
string thumbnailFileName = Path.GetFileNameWithoutExtension(filename) + taskSettings.ImageSettings.ThumbnailName + ".jpg";
string thumbnailFilePath = CheckFilePath(folder, thumbnailFileName, taskSettings);
if (!string.IsNullOrEmpty(thumbnailFilePath))
{
Image thumbImage = null;
try
{
thumbImage = (Image)img.Clone();
thumbImage = new Resize
{
Width = taskSettings.ImageSettings.ThumbnailWidth,
Height = taskSettings.ImageSettings.ThumbnailHeight
}.Apply(thumbImage);
thumbImage = ImageHelpers.FillBackground(thumbImage, Color.White);
thumbImage.SaveJPG(thumbnailFilePath, 90);
return(thumbnailFilePath);
}
catch (Exception e)
{
DebugHelper.WriteException(e);
}
finally
{
if (thumbImage != null)
{
thumbImage.Dispose();
}
}
}
}
return(null);
}
public static string GetImageFilename(TaskSettings taskSettings, Image image)
{
string filename;
NameParser nameParser = new NameParser(NameParserType.FileName)
{
Picture = image,
AutoIncrementNumber = Program.Settings.NameParserAutoIncrementNumber,
MaxNameLength = taskSettings.AdvancedSettings.NamePatternMaxLength,
MaxTitleLength = taskSettings.AdvancedSettings.NamePatternMaxTitleLength,
CustomTimeZone = taskSettings.UploadSettings.UseCustomTimeZone ? taskSettings.UploadSettings.CustomTimeZone : null
};
ImageTag imageTag = image.Tag as ImageTag;
if (imageTag != null)
{
nameParser.WindowText = imageTag.ActiveWindowTitle;
nameParser.ProcessName = imageTag.ActiveProcessName;
}
if (string.IsNullOrEmpty(nameParser.WindowText))
{
filename = nameParser.Parse(taskSettings.UploadSettings.NameFormatPattern) + ".bmp";
}
else
{
filename = nameParser.Parse(taskSettings.UploadSettings.NameFormatPatternActiveWindow) + ".bmp";
}
Program.Settings.NameParserAutoIncrementNumber = nameParser.AutoIncrementNumber;
return filename;
}
public static bool SelectRegion(out Rectangle rect, TaskSettings taskSettings)
{
using (RectangleRegion surface = new RectangleRegion())
{
surface.Config = taskSettings.CaptureSettings.SurfaceOptions;
surface.Config.ShowTips = false;
surface.Config.QuickCrop = true;
surface.Config.ForceWindowCapture = true;
surface.Prepare();
surface.ShowDialog();
if (surface.Result == SurfaceResult.Region)
{
if (surface.AreaManager.IsCurrentAreaValid)
{
rect = CaptureHelpers.ClientToScreen(surface.AreaManager.CurrentArea);
return true;
}
}
else if (surface.Result == SurfaceResult.Fullscreen)
{
rect = CaptureHelpers.GetScreenBounds();
return true;
}
else if (surface.Result == SurfaceResult.Monitor)
{
Screen[] screens = Screen.AllScreens;
if (surface.MonitorIndex < screens.Length)
{
Screen screen = screens[surface.MonitorIndex];
rect = screen.Bounds;
return true;
}
}
else if (surface.Result == SurfaceResult.ActiveMonitor)
{
rect = CaptureHelpers.GetActiveScreenBounds();
return true;
}
}
rect = Rectangle.Empty;
return false;
}
public static void OpenDropWindow(TaskSettings taskSettings = null)
{
DropForm.GetInstance(Program.Settings.DropSize, Program.Settings.DropOffset, Program.Settings.DropAlignment, Program.Settings.DropOpacity,
Program.Settings.DropHoverOpacity, taskSettings).ShowActivate();
}
public static void OpenDropWindow(TaskSettings taskSettings = null)
{
DropForm.GetInstance(Program.Settings.DropSize, Program.Settings.DropOffset, Program.Settings.DropAlignment, Program.Settings.DropOpacity,
Program.Settings.DropHoverOpacity, taskSettings).ShowActivate();
}
public static MemoryStream SaveImage(Image img, EImageFormat imageFormat, TaskSettings taskSettings)
{
MemoryStream stream = new MemoryStream();
switch (imageFormat)
{
case EImageFormat.PNG:
img.Save(stream, ImageFormat.Png);
break;
case EImageFormat.JPEG:
img.SaveJPG(stream, taskSettings.ImageSettings.ImageJPEGQuality);
break;
case EImageFormat.GIF:
img.SaveGIF(stream, taskSettings.ImageSettings.ImageGIFQuality);
break;
case EImageFormat.BMP:
img.Save(stream, ImageFormat.Bmp);
break;
case EImageFormat.TIFF:
img.Save(stream, ImageFormat.Tiff);
break;
}
return stream;
}
public static ImageData PrepareImage(Image img, TaskSettings taskSettings)
{
ImageData imageData = new ImageData();
imageData.ImageFormat = taskSettings.ImageSettings.ImageFormat;
if (taskSettings.ImageSettings.ImageFormat == EImageFormat.JPEG)
{
img = ImageHelpers.FillBackground(img, Color.White);
}
imageData.ImageStream = SaveImage(img, taskSettings.ImageSettings.ImageFormat, taskSettings);
int sizeLimit = taskSettings.ImageSettings.ImageSizeLimit * 1000;
if (taskSettings.ImageSettings.ImageFormat != taskSettings.ImageSettings.ImageFormat2 && sizeLimit > 0 && imageData.ImageStream.Length > sizeLimit)
{
if (taskSettings.ImageSettings.ImageFormat2 == EImageFormat.JPEG)
{
img = ImageHelpers.FillBackground(img, Color.White);
}
imageData.ImageStream = SaveImage(img, taskSettings.ImageSettings.ImageFormat2, taskSettings);
imageData.ImageFormat = taskSettings.ImageSettings.ImageFormat2;
}
return imageData;
}
public static void PlayTaskCompleteSound(TaskSettings taskSettings)
{
if (taskSettings == null) taskSettings = TaskSettings.GetDefaultTaskSettings();
if (taskSettings.AdvancedSettings.UseCustomTaskCompletedSound && !string.IsNullOrEmpty(taskSettings.AdvancedSettings.CustomTaskCompletedSoundPath))
{
Helpers.PlaySoundAsync(taskSettings.AdvancedSettings.CustomTaskCompletedSoundPath);
}
else
{
Helpers.PlaySoundAsync(Resources.TaskCompletedSound);
}
}
public static void OpenWebpageCapture(TaskSettings taskSettings = null)
{
if (taskSettings == null) taskSettings = TaskSettings.GetDefaultTaskSettings();
WebpageCaptureForm webpageCaptureForm = new WebpageCaptureForm();
webpageCaptureForm.OnImageUploadRequested += img => UploadManager.RunImageTask(img, taskSettings);
webpageCaptureForm.OnImageCopyRequested += img =>
{
using (img)
{
ClipboardHelpers.CopyImage(img);
}
};
webpageCaptureForm.Show();
}
private void SetDestinations(bool isActive, EDataType dataType, object destination, TaskSettings taskSettings)
{
if (!isActive)
{
return;
}
switch (dataType)
{
case EDataType.Image:
if (destination is ImageDestination)
{
taskSettings.ImageDestination = (ImageDestination)destination;
}
else if (destination is FileDestination)
{
taskSettings.ImageDestination = ImageDestination.FileUploader;
taskSettings.ImageFileDestination = (FileDestination)destination;
}
break;
case EDataType.Text:
if (destination is TextDestination)
{
taskSettings.TextDestination = (TextDestination)destination;
}
else if (destination is FileDestination)
{
taskSettings.TextDestination = TextDestination.FileUploader;
taskSettings.TextFileDestination = (FileDestination)destination;
}
break;
case EDataType.File:
if (destination is FileDestination)
{
taskSettings.ImageDestination = ImageDestination.FileUploader;
taskSettings.TextDestination = TextDestination.FileUploader;
taskSettings.ImageFileDestination = taskSettings.TextFileDestination = taskSettings.FileDestination = (FileDestination)destination;
}
break;
case EDataType.URL:
if (destination is UrlShortenerType)
{
taskSettings.URLShortenerDestination = (UrlShortenerType)destination;
}
break;
}
}
public static bool ShowAfterCaptureForm(TaskSettings taskSettings, Image img = null)
{
if (taskSettings.GeneralSettings.ShowAfterCaptureTasksForm)
{
using (AfterCaptureForm afterCaptureForm = new AfterCaptureForm(img, taskSettings))
{
afterCaptureForm.ShowDialog();
switch (afterCaptureForm.Result)
{
case AfterCaptureFormResult.Continue:
taskSettings.AfterCaptureJob = afterCaptureForm.AfterCaptureTasks;
break;
case AfterCaptureFormResult.Copy:
taskSettings.AfterCaptureJob = AfterCaptureTasks.CopyImageToClipboard;
break;
case AfterCaptureFormResult.Cancel:
if (img != null) img.Dispose();
return false;
}
}
}
return true;
}
public static void ClipboardUpload(TaskSettings taskSettings = null)
{
if (taskSettings == null)
{
taskSettings = TaskSettings.GetDefaultTaskSettings();
}
if (Clipboard.ContainsImage())
{
Image img = Clipboard.GetImage();
if (img != null)
{
if (!taskSettings.AdvancedSettings.ProcessImagesDuringClipboardUpload)
{
taskSettings.AfterCaptureJob = AfterCaptureTasks.UploadImageToHost;
}
RunImageTask(img, taskSettings);
}
}
else if (Clipboard.ContainsFileDropList())
{
string[] files = Clipboard.GetFileDropList().Cast <string>().ToArray();
UploadFile(files, taskSettings);
}
else if (Clipboard.ContainsText())
{
string text = Clipboard.GetText();
if (!string.IsNullOrEmpty(text))
{
string url = text.Trim();
if (URLHelpers.IsValidURLRegex(url))
{
if (taskSettings.UploadSettings.ClipboardUploadURLContents)
{
DownloadAndUploadFile(url, taskSettings);
return;
}
if (taskSettings.UploadSettings.ClipboardUploadShortenURL)
{
ShortenURL(url, taskSettings);
return;
}
if (taskSettings.UploadSettings.ClipboardUploadShareURL)
{
ShareURL(url, taskSettings);
return;
}
}
if (taskSettings.UploadSettings.ClipboardUploadAutoIndexFolder && text.Length <= 260 && Directory.Exists(text))
{
IndexFolder(text, taskSettings);
}
else
{
UploadText(text, taskSettings, true);
}
}
}
}
public static WorkerTask CreateDataUploaderTask(EDataType dataType, Stream stream, string fileName, TaskSettings taskSettings)
{
WorkerTask task = new WorkerTask(taskSettings);
task.Info.Job = TaskJob.DataUpload;
task.Info.DataType = dataType;
task.Info.FileName = fileName;
task.Data = stream;
return task;
}
public static void StartScreenRecording(ScreenRecordOutput outputType, ScreenRecordStartMethod startMethod, TaskSettings taskSettings = null)
{
if (taskSettings == null)
{
taskSettings = TaskSettings.GetDefaultTaskSettings();
}
ScreenRecordForm form = ScreenRecordForm.Instance;
if (form.IsRecording)
{
form.StartStopRecording();
}
else
{
form.StartRecording(outputType, taskSettings, startMethod);
}
}
public static WorkerTask CreateFileJobTask(string filePath, TaskSettings taskSettings)
{
WorkerTask task = new WorkerTask(taskSettings);
task.Info.FilePath = filePath;
task.Info.DataType = TaskHelpers.FindDataType(task.Info.FilePath, taskSettings);
if (task.Info.TaskSettings.UploadSettings.FileUploadUseNamePattern)
{
string ext = Path.GetExtension(task.Info.FilePath);
task.Info.FileName = TaskHelpers.GetFilename(task.Info.TaskSettings, ext);
}
task.Info.Job = TaskJob.Job;
if (task.Info.IsUploadJob && !task.LoadFileStream())
{
return null;
}
return task;
}
public static DropForm GetInstance(int size, int offset, ContentAlignment alignment, int opacity, int hoverOpacity, TaskSettings taskSettings = null)
{
if (instance == null || instance.IsDisposed)
{
instance = new DropForm(size, offset, alignment, opacity, hoverOpacity);
}
instance.taskSettings = taskSettings;
return instance;
}
public static WorkerTask CreateImageUploaderTask(Image image, TaskSettings taskSettings)
{
WorkerTask task = new WorkerTask(taskSettings);
task.Info.Job = TaskJob.Job;
task.Info.DataType = EDataType.Image;
task.Info.FileName = TaskHelpers.GetImageFilename(taskSettings, image);
task.tempImage = image;
return task;
}
public static void StartScreenRecording(ScreenRecordOutput outputType, ScreenRecordStartMethod startMethod, TaskSettings taskSettings = null)
{
if (taskSettings == null) taskSettings = TaskSettings.GetDefaultTaskSettings();
ScreenRecordForm form = ScreenRecordForm.Instance;
if (form.IsRecording)
{
form.StartStopRecording();
}
else
{
form.StartRecording(outputType, taskSettings, startMethod);
}
}
public static void OpenScreenColorPicker(TaskSettings taskSettings = null)
{
if (taskSettings == null) taskSettings = TaskSettings.GetDefaultTaskSettings();
PointInfo pointInfo = SelectPointColor();
if (pointInfo != null)
{
string text = taskSettings.AdvancedSettings.ScreenColorPickerFormat;
text = text.Replace("$r", pointInfo.Color.R.ToString(), StringComparison.InvariantCultureIgnoreCase).
Replace("$g", pointInfo.Color.G.ToString(), StringComparison.InvariantCultureIgnoreCase).
Replace("$b", pointInfo.Color.B.ToString(), StringComparison.InvariantCultureIgnoreCase).
Replace("$hex", ColorHelpers.ColorToHex(pointInfo.Color), StringComparison.InvariantCultureIgnoreCase).
Replace("$x", pointInfo.Position.X.ToString(), StringComparison.InvariantCultureIgnoreCase).
Replace("$y", pointInfo.Position.Y.ToString(), StringComparison.InvariantCultureIgnoreCase);
ClipboardHelpers.CopyText(text);
if (Program.MainForm.niTray.Visible)
{
Program.MainForm.niTray.Tag = null;
Program.MainForm.niTray.ShowBalloonTip(3000, "ShareXYZ", string.Format(Resources.TaskHelpers_OpenQuickScreenColorPicker_Copied_to_clipboard___0_, text), ToolTipIcon.Info);
}
}
}
public static WorkerTask CreateDownloadUploadTask(string url, TaskSettings taskSettings)
{
WorkerTask task = new WorkerTask(taskSettings);
task.Info.Job = TaskJob.DownloadUpload;
task.Info.DataType = TaskHelpers.FindDataType(url, taskSettings);
string filename = URLHelpers.URLDecode(url, 10);
filename = URLHelpers.GetFileName(filename);
filename = Helpers.GetValidFileName(filename);
if (string.IsNullOrEmpty(filename))
{
return null;
}
task.Info.FileName = filename;
task.Info.Result.URL = url;
return task;
}
private static void AddExternalProgramFromFile(TaskSettings taskSettings, string name, string filename, string args = "")
{
if (!taskSettings.ExternalPrograms.Exists(x => x.Name == name))
{
if (File.Exists(filename))
{
DebugHelper.WriteLine("Found program: " + filename);
taskSettings.ExternalPrograms.Add(new ExternalProgram(name, filename, args));
}
}
}
public static WorkerTask CreateFileUploaderTask(string filePath, TaskSettings taskSettings)
{
WorkerTask task = new WorkerTask(taskSettings);
task.Info.FilePath = filePath;
task.Info.DataType = TaskHelpers.FindDataType(task.Info.FilePath, taskSettings);
if (task.Info.TaskSettings.UploadSettings.FileUploadUseNamePattern)
{
string ext = Path.GetExtension(task.Info.FilePath);
task.Info.FileName = TaskHelpers.GetFilename(task.Info.TaskSettings, ext);
}
if (task.Info.TaskSettings.AdvancedSettings.ProcessImagesDuringFileUpload && task.Info.DataType == EDataType.Image)
{
task.Info.Job = TaskJob.Job;
task.tempImage = ImageHelpers.LoadImage(task.Info.FilePath);
}
else
{
task.Info.Job = TaskJob.FileUpload;
if (!task.LoadFileStream())
{
return null;
}
}
return task;
}
private static void AddExternalProgramFromRegistry(TaskSettings taskSettings, string name, string filename)
{
if (!taskSettings.ExternalPrograms.Exists(x => x.Name == name))
{
ExternalProgram externalProgram = RegistryHelpers.FindProgram(name, filename);
if (externalProgram != null)
{
taskSettings.ExternalPrograms.Add(externalProgram);
}
}
}
public static WorkerTask CreateTextUploaderTask(string text, TaskSettings taskSettings)
{
WorkerTask task = new WorkerTask(taskSettings);
task.Info.Job = TaskJob.TextUpload;
task.Info.DataType = EDataType.Text;
task.Info.FileName = TaskHelpers.GetFilename(taskSettings, taskSettings.AdvancedSettings.TextFileExtension);
task.tempText = text;
return task;
}
public static bool CheckFFmpeg(TaskSettings taskSettings)
{
if (!File.Exists(taskSettings.CaptureSettings.FFmpegOptions.CLIPath))
{
string ffmpegText = string.IsNullOrEmpty(taskSettings.CaptureSettings.FFmpegOptions.CLIPath) ? "ffmpeg.exe" : taskSettings.CaptureSettings.FFmpegOptions.CLIPath;
if (MessageBox.Show(string.Format(Resources.ScreenRecordForm_StartRecording_does_not_exist, ffmpegText),
"ShareXYZ - " + Resources.ScreenRecordForm_StartRecording_Missing + " ffmpeg.exe", MessageBoxButtons.YesNo, MessageBoxIcon.Warning) == DialogResult.Yes)
{
if (FFmpegDownloader.DownloadFFmpeg(false, DownloaderForm_InstallRequested) == DialogResult.OK)
{
Program.DefaultTaskSettings.CaptureSettings.FFmpegOptions.CLIPath = taskSettings.TaskSettingsReference.CaptureSettings.FFmpegOptions.CLIPath =
taskSettings.CaptureSettings.FFmpegOptions.CLIPath = Path.Combine(Program.ToolsFolder, "ffmpeg.exe");
}
}
else
{
return false;
}
}
return true;
}
private WorkerTask(TaskSettings taskSettings)
{
Status = TaskStatus.InQueue;
Info = new TaskInfo(taskSettings);
}
public static EDataType FindDataType(string filePath, TaskSettings taskSettings)
{
string ext = Helpers.GetFilenameExtension(filePath);
if (!string.IsNullOrEmpty(ext))
{
if (taskSettings.AdvancedSettings.ImageExtensions.Any(x => ext.Equals(x, StringComparison.InvariantCultureIgnoreCase)))
{
return EDataType.Image;
}
if (taskSettings.AdvancedSettings.TextExtensions.Any(x => ext.Equals(x, StringComparison.InvariantCultureIgnoreCase)))
{
return EDataType.Text;
}
}
return EDataType.File;
}
