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 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; }