public void CaptureScreenshot(CaptureType captureType, TaskSettings taskSettings = null, bool autoHideForm = true) { if (taskSettings == null) taskSettings = TaskSettings.GetDefaultTaskSettings(); switch (captureType) { case CaptureType.Screen: DoCapture(Screenshot.CaptureFullscreen, CaptureType.Screen, taskSettings, autoHideForm); break; case CaptureType.ActiveWindow: CaptureActiveWindow(taskSettings, autoHideForm); break; case CaptureType.ActiveMonitor: DoCapture(Screenshot.CaptureActiveMonitor, CaptureType.ActiveMonitor, taskSettings, autoHideForm); break; case CaptureType.Rectangle: case CaptureType.RectangleWindow: case CaptureType.RoundedRectangle: case CaptureType.Ellipse: case CaptureType.Triangle: case CaptureType.Diamond: case CaptureType.Polygon: case CaptureType.Freehand: CaptureRegion(captureType, taskSettings, autoHideForm); break; case CaptureType.LastRegion: CaptureLastRegion(taskSettings, autoHideForm); break; } }
public HotkeySettings(HotkeyType job, Keys hotkey = Keys.None) : this() { TaskSettings = TaskSettings.GetDefaultTaskSettings(); TaskSettings.Job = job; HotkeyInfo = new HotkeyInfo(hotkey); }
public static void CaptureScreenshot(CaptureType captureType, TaskSettings taskSettings = null, bool autoHideForm = true) { if (taskSettings == null) taskSettings = TaskSettings.GetDefaultTaskSettings(); switch (captureType) { case CaptureType.Fullscreen: DoCapture(TaskHelpers.GetScreenshot(taskSettings).CaptureFullscreen, CaptureType.Fullscreen, taskSettings, autoHideForm); break; case CaptureType.ActiveWindow: CaptureActiveWindow(taskSettings, autoHideForm); break; case CaptureType.ActiveMonitor: DoCapture(TaskHelpers.GetScreenshot(taskSettings).CaptureActiveMonitor, CaptureType.ActiveMonitor, taskSettings, autoHideForm); break; case CaptureType.Region: CaptureRegion(taskSettings, autoHideForm); break; case CaptureType.CustomRegion: CaptureCustomRegion(taskSettings, autoHideForm); break; case CaptureType.LastRegion: CaptureLastRegion(taskSettings, autoHideForm); break; } }
public static void ClipboardUpload(TaskSettings taskSettings = null) { if (taskSettings == null) taskSettings = TaskSettings.GetDefaultTaskSettings(); if (Clipboard.ContainsImage()) { Image img = Clipboard.GetImage(); 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 (taskSettings.UploadSettings.ClipboardUploadAutoDetectURL && Helpers.IsValidURLRegex(text)) { ShortenURL(text.Trim(), taskSettings); } else { UploadText(text, taskSettings); } } }
public ScreenColorPicker(TaskSettings taskSettings) { if (taskSettings != null) { surfaceOptions = taskSettings.CaptureSettings.SurfaceOptions; } else { surfaceOptions = new SurfaceOptions(); } InitializeComponent(); colorPicker.DrawCrosshair = true; colorTimer.Tick += colorTimer_Tick; UpdateControls(true); foreach (Control control in Controls) { if (control is NumericUpDown || control is TextBox) { control.DoubleClick += CopyToClipboard; } } }
public override void Capture(CaptureType captureType, TaskSettings taskSettings, bool autoHideForm = true) { DoCapture(() => { Image img; string activeWindowTitle = NativeMethods.GetForegroundWindowText(); string activeProcessName = null; using (Process process = NativeMethods.GetForegroundWindowProcess()) { if (process != null) { activeProcessName = process.ProcessName; } } if (taskSettings.CaptureSettings.CaptureTransparent && !taskSettings.CaptureSettings.CaptureClientArea) { img = Screenshot.CaptureActiveWindowTransparent(); } else { img = Screenshot.CaptureActiveWindow(); } img.Tag = new ImageTag { ActiveWindowTitle = activeWindowTitle, ActiveProcessName = activeProcessName }; return img; }, CaptureType.ActiveWindow, taskSettings, autoHideForm); }
private static Image ResizeImage(TaskSettings taskSettings, Image img, ImageScaleType scaleType) { float width = 0, height = 0; switch (scaleType) { case ImageScaleType.Percentage: width = img.Width * (taskSettings.ImageSettings.ImageScalePercentageWidth / 100f); height = img.Height * (taskSettings.ImageSettings.ImageScalePercentageHeight / 100f); break; case ImageScaleType.Width: width = taskSettings.ImageSettings.ImageScaleToWidth; height = taskSettings.ImageSettings.ImageKeepAspectRatio ? img.Height * (width / img.Width) : img.Height; break; case ImageScaleType.Height: height = taskSettings.ImageSettings.ImageScaleToHeight; width = taskSettings.ImageSettings.ImageKeepAspectRatio ? img.Width * (height / img.Height) : img.Width; break; case ImageScaleType.Specific: width = taskSettings.ImageSettings.ImageScaleSpecificWidth; height = taskSettings.ImageSettings.ImageScaleSpecificHeight; break; } if (width > 0 && height > 0) { return CaptureHelpers.ResizeImage(img, (int)width, (int)height, taskSettings.ImageSettings.ImageUseSmoothScaling); } return img; }
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 HotkeySettings(HotkeyType job, Keys hotkey = Keys.None) : this() { TaskSettings = TaskSettings.GetDefaultTaskSettings(); TaskSettings.Job = job; TaskSettings.Description = job.GetDescription(); HotkeyInfo = new HotkeyInfo { Hotkey = hotkey }; }
private void SelectRegion(TaskSettings taskSettings) { Rectangle rect; if (TaskHelper.SelectRegion(taskSettings, out rect) && !rect.IsEmpty) { CaptureRectangle = Helpers.EvenRectangleSize(rect); } }
public static UploadTask CreateDataUploaderTask(EDataType dataType, Stream stream, string fileName, TaskSettings taskSettings) { UploadTask task = new UploadTask(taskSettings); task.Info.Job = TaskJob.DataUpload; task.Info.DataType = dataType; task.Info.FileName = fileName; task.Data = stream; return task; }
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; } } UploadText(text, taskSettings, true); } } }
public override void Capture(CaptureType captureType, TaskSettings taskSettings, bool autoHideForm = true) { DoCapture(() => { Rectangle regionBounds = taskSettings.CaptureSettings.CaptureCustomRegion; Image img = Screenshot.CaptureRectangle(regionBounds); return img; }, CaptureType.CustomRegion, taskSettings, autoHideForm); }
public AfterCaptureForm(string filePath, TaskSettings taskSettings) : this(taskSettings) { if (Helpers.IsImageFile(filePath)) { pbImage.LoadImageFromFileAsync(filePath); } FileName = Path.GetFileNameWithoutExtension(filePath); txtFileName.Text = FileName; }
public TaskInfo(TaskSettings taskSettings) { if (taskSettings == null) { taskSettings = TaskSettings.GetDefaultTaskSettings(); } TaskSettings = taskSettings; Result = new UploadResult(); }
public AfterCaptureForm(Image img, TaskSettings taskSettings) : this(taskSettings) { if (img != null) { pbImage.LoadImage(img); btnCopy.Enabled = true; } FileName = TaskHelpers.GetFilename(TaskSettings, null, img); txtFileName.Text = FileName; }
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 void StartStopRecording(ScreenRecordOutput outputType, ScreenRecordStartMethod startMethod, TaskSettings taskSettings) { if (IsRecording) { if (recordForm != null && !recordForm.IsDisposed) { recordForm.StartStopRecording(); } } else { StartRecording(outputType, taskSettings, startMethod); } }
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 void UploadFile(string[] files, TaskSettings taskSettings = null) { if (taskSettings == null) taskSettings = TaskSettings.GetDefaultTaskSettings(); if (files != null && files.Length > 0) { if (files.Length <= 10 || IsUploadConfirmed(files.Length)) { foreach (string file in files) { UploadFile(file, taskSettings); } } } }
public AfterCaptureForm(Image img, TaskSettings taskSettings) { InitializeComponent(); Icon = ShareXResources.Icon; 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); pbImage.LoadImage(img); }
private AfterCaptureForm(TaskSettings taskSettings) { TaskSettings = taskSettings; InitializeComponent(); Icon = ShareXResources.Icon; ImageList imageList = new ImageList { ColorDepth = ColorDepth.Depth32Bit }; imageList.Images.Add(Resources.checkbox_uncheck); imageList.Images.Add(Resources.checkbox_check); lvAfterCaptureTasks.SmallImageList = imageList; lvAfterUploadTasks.SmallImageList = imageList; ucBeforeUpload.InitCapture(TaskSettings); AddAfterCaptureItems(TaskSettings.AfterCaptureJob); AddAfterUploadItems(TaskSettings.AfterUploadJob); }
public static void UploadFile(string filePath, TaskSettings taskSettings = null) { if (taskSettings == null) taskSettings = TaskSettings.GetDefaultTaskSettings(); if (!string.IsNullOrEmpty(filePath)) { if (File.Exists(filePath)) { UploadTask task = UploadTask.CreateFileUploaderTask(filePath, taskSettings); TaskManager.Start(task); } else if (Directory.Exists(filePath)) { string[] files = Directory.GetFiles(filePath, "*.*", SearchOption.AllDirectories); UploadFile(files, taskSettings); } } }
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); } }
private void ActiveWindowRegion(TaskSettings taskSettings) { IntPtr handle = NativeMethods.GetForegroundWindow(); if (handle.ToInt32() > 0) { if (taskSettings.CaptureSettings.CaptureClientArea) { captureRectangle = NativeMethods.GetClientRect(handle); } else { captureRectangle = CaptureHelpers.GetWindowRectangle(handle); } } else { SelectRegion(); } }
public static void ClipboardUploadMainWindow(TaskSettings taskSettings = null) { if (taskSettings == null) taskSettings = TaskSettings.GetDefaultTaskSettings(); if (Program.Settings.ShowClipboardContentViewer) { using (ClipboardContentViewer ccv = new ClipboardContentViewer(true)) { if (ccv.ShowDialog() == DialogResult.OK && !ccv.IsClipboardEmpty) { ClipboardUpload(taskSettings); } Program.Settings.ShowClipboardContentViewer = !ccv.DontShowThisWindow; } } else { ClipboardUpload(taskSettings); } }
public static void DoCapture(ScreenCaptureDelegate capture, CaptureType captureType, TaskSettings taskSettings = null, bool autoHideForm = true) { if (taskSettings == null) taskSettings = TaskSettings.GetDefaultTaskSettings(); if (taskSettings.CaptureSettings.IsDelayScreenshot && taskSettings.CaptureSettings.DelayScreenshot > 0) { TaskEx.Run(() => { int sleep = (int)(taskSettings.CaptureSettings.DelayScreenshot * 1000); Thread.Sleep(sleep); }, () => { DoCaptureWork(capture, captureType, taskSettings, autoHideForm); }); } else { DoCaptureWork(capture, captureType, taskSettings, autoHideForm); } }
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; }
protected void AfterCapture(Image img, CaptureType captureType, TaskSettings taskSettings) { if (img != null) { if (taskSettings.GeneralSettings.PlaySoundAfterCapture) { TaskHelpers.PlayCaptureSound(taskSettings); } if (taskSettings.ImageSettings.ImageEffectOnlyRegionCapture && !IsRegionCapture(captureType)) { taskSettings.AfterCaptureJob = taskSettings.AfterCaptureJob.Remove(AfterCaptureTasks.AddImageEffects); } string customFileName; if (TaskHelpers.ShowAfterCaptureForm(taskSettings, out customFileName, img)) { UploadManager.RunImageTask(img, taskSettings, customFileName); } } }
private void btnRegion_Click(object sender, EventArgs e) { TaskSettings taskSettings = TaskSettings.GetDefaultTaskSettings(); SelectRegion(taskSettings); }
private void SetDefaultSettings() { if (Program.DefaultTaskSettings != null) { TaskSettings defaultTaskSettings = Program.DefaultTaskSettings.Copy(); if (UseDefaultAfterCaptureJob) { AfterCaptureJob = defaultTaskSettings.AfterCaptureJob; } if (UseDefaultAfterUploadJob) { AfterUploadJob = defaultTaskSettings.AfterUploadJob; } if (UseDefaultDestinations) { ImageDestination = defaultTaskSettings.ImageDestination; ImageFileDestination = defaultTaskSettings.ImageFileDestination; TextDestination = defaultTaskSettings.TextDestination; TextFileDestination = defaultTaskSettings.TextFileDestination; FileDestination = defaultTaskSettings.FileDestination; URLShortenerDestination = defaultTaskSettings.URLShortenerDestination; URLSharingServiceDestination = defaultTaskSettings.URLSharingServiceDestination; } if (UseDefaultGeneralSettings) { GeneralSettings = defaultTaskSettings.GeneralSettings; } if (UseDefaultImageSettings) { ImageSettings = defaultTaskSettings.ImageSettings; } if (UseDefaultCaptureSettings) { CaptureSettings = defaultTaskSettings.CaptureSettings; } if (UseDefaultUploadSettings) { UploadSettings = defaultTaskSettings.UploadSettings; } if (UseDefaultActions) { ExternalPrograms = defaultTaskSettings.ExternalPrograms; } if (UseDefaultToolsSettings) { ToolsSettings = defaultTaskSettings.ToolsSettings; } if (UseDefaultAdvancedSettings) { AdvancedSettings = defaultTaskSettings.AdvancedSettings; } } }
public void StartRecording(TaskSettings taskSettings) { 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_, "ShareX", 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, "ShareX", MessageBoxButtons.OK, MessageBoxIcon.Warning); return; } } if (taskSettings.CaptureSettings.ScreenRecordOutput == ScreenRecordOutput.FFmpeg) { 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), "ShareX - " + Resources.ScreenRecordForm_StartRecording_Missing + " ffmpeg.exe", MessageBoxButtons.YesNo, MessageBoxIcon.Warning) == DialogResult.Yes) { if (FFmpegHelper.DownloadFFmpeg(false, DownloaderForm_InstallRequested) == DialogResult.OK) { Program.DefaultTaskSettings.CaptureSettings.FFmpegOptions.CLIPath = taskSettings.TaskSettingsReference.CaptureSettings.FFmpegOptions.CLIPath = taskSettings.CaptureSettings.FFmpegOptions.CLIPath = Path.Combine(Program.ToolsFolder, "ffmpeg.exe"); } } else { return; } } if (!taskSettings.CaptureSettings.FFmpegOptions.IsSourceSelected) { MessageBox.Show(Resources.ScreenRecordForm_StartRecording_FFmpeg_video_and_audio_source_both_can_t_be__None__, "ShareX - " + Resources.ScreenRecordForm_StartRecording_FFmpeg_error, MessageBoxButtons.OK, MessageBoxIcon.Warning); return; } } Rectangle captureRectangle; TaskHelpers.SelectRegion(out captureRectangle); captureRectangle = CaptureHelpers.EvenRectangleSize(captureRectangle); if (IsRecording || !captureRectangle.IsValid() || screenRecorder != null) { return; } IsRecording = true; Screenshot.CaptureCursor = taskSettings.CaptureSettings.ShowCursor; TrayIcon.Text = "ShareX - " + Resources.ScreenRecordForm_StartRecording_Waiting___; TrayIcon.Icon = Resources.control_record_yellow.ToIcon(); TrayIcon.Visible = true; string path = ""; float duration = taskSettings.CaptureSettings.ScreenRecordFixedDuration ? taskSettings.CaptureSettings.ScreenRecordDuration : 0; regionForm = ScreenRegionForm.Show(captureRectangle, StopRecording, duration); regionForm.RecordResetEvent = new ManualResetEvent(false); TaskEx.Run(() => { try { if (taskSettings.CaptureSettings.ScreenRecordAutoDisableAero) { dwmManager = new DWMManager(); dwmManager.AutoDisable(); } if (taskSettings.CaptureSettings.ScreenRecordOutput == ScreenRecordOutput.AVI) { path = Path.Combine(taskSettings.CaptureFolder, TaskHelpers.GetFilename(taskSettings, "avi")); } else if (taskSettings.CaptureSettings.ScreenRecordOutput == ScreenRecordOutput.FFmpeg) { path = Path.Combine(taskSettings.CaptureFolder, TaskHelpers.GetFilename(taskSettings, taskSettings.CaptureSettings.FFmpegOptions.Extension)); } else { path = Program.ScreenRecorderCacheFilePath; } ScreencastOptions options = new ScreencastOptions() { FFmpeg = taskSettings.CaptureSettings.FFmpegOptions, AVI = taskSettings.CaptureSettings.AVIOptions, ScreenRecordFPS = taskSettings.CaptureSettings.ScreenRecordFPS, GIFFPS = taskSettings.CaptureSettings.GIFFPS, Duration = duration, OutputPath = path, CaptureArea = captureRectangle, DrawCursor = taskSettings.CaptureSettings.ShowCursor }; screenRecorder = new ScreenRecorder(options, captureRectangle, taskSettings.CaptureSettings.ScreenRecordOutput); if (regionForm != null && regionForm.RecordResetEvent != null) { TrayIcon.Text = "ShareX - " + Resources.ScreenRecordForm_StartRecording_Click_tray_icon_to_start_recording_; if (taskSettings.CaptureSettings.ScreenRecordAutoStart) { int delay = (int)(taskSettings.CaptureSettings.ScreenRecordStartDelay * 1000); if (delay > 0) { regionForm.RecordResetEvent.WaitOne(delay); } } else { regionForm.RecordResetEvent.WaitOne(); } if (regionForm.AbortRequested) { abortRequested = true; } } if (!abortRequested) { TrayIcon.Text = "ShareX - " + Resources.ScreenRecordForm_StartRecording_Click_tray_icon_to_stop_recording_; TrayIcon.Icon = Resources.control_record.ToIcon(); if (regionForm != null) { this.InvokeSafe(() => regionForm.StartTimer()); } screenRecorder.StartRecording(); if (regionForm != null && regionForm.AbortRequested) { abortRequested = true; } } } finally { if (dwmManager != null) { dwmManager.Dispose(); dwmManager = null; } if (regionForm != null) { if (regionForm.RecordResetEvent != null) { regionForm.RecordResetEvent.Dispose(); } this.InvokeSafe(() => regionForm.Close()); regionForm = null; } } try { if (!abortRequested && screenRecorder != null) { TrayIcon.Text = "ShareX - " + Resources.ScreenRecordForm_StartRecording_Encoding___; TrayIcon.Icon = Resources.camcorder_pencil.ToIcon(); string sourceFilePath = path; if (taskSettings.CaptureSettings.ScreenRecordOutput == ScreenRecordOutput.GIF) { if (taskSettings.CaptureSettings.RunScreencastCLI) { sourceFilePath = Path.ChangeExtension(Program.ScreenRecorderCacheFilePath, "gif"); } else { sourceFilePath = path = Path.Combine(taskSettings.CaptureFolder, TaskHelpers.GetFilename(taskSettings, "gif")); } screenRecorder.SaveAsGIF(sourceFilePath, taskSettings.ImageSettings.ImageGIFQuality); } if (taskSettings.CaptureSettings.RunScreencastCLI) { VideoEncoder encoder = Program.Settings.VideoEncoders[taskSettings.CaptureSettings.VideoEncoderSelected]; path = Path.Combine(taskSettings.CaptureFolder, TaskHelpers.GetFilename(taskSettings, encoder.OutputExtension)); screenRecorder.EncodeUsingCommandLine(encoder, sourceFilePath, path); } } } finally { if (screenRecorder != null) { if (taskSettings.CaptureSettings.RunScreencastCLI && !string.IsNullOrEmpty(screenRecorder.CachePath) && File.Exists(screenRecorder.CachePath)) { File.Delete(screenRecorder.CachePath); } screenRecorder.Dispose(); screenRecorder = null; if (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)) { UploadTask task = UploadTask.CreateFileJobTask(path, taskSettings); TaskManager.Start(task); } abortRequested = false; IsRecording = false; }); }
public static void DoScreenRecordingGIF() { TaskSettings taskSettings = TaskSettings.GetDefaultTaskSettings(); StartScreenRecording(ScreenRecordOutput.GIF, taskSettings); }
private static void ProcessClipboardContentViewerDialog(ClipboardContentViewer ccv, TaskSettings taskSettings = null) { if (taskSettings == null) { taskSettings = TaskSettings.GetDefaultTaskSettings(); } if (ccv.ShowDialog() == DialogResult.OK && ccv.IsClipboardContentValid) { if (ccv.ClipboardContentType != EClipboardContentType.Default) { ClipboardUploadCached(ccv, taskSettings); } else { ClipboardUpload(taskSettings); } } else if (ccv.ClipboardContentType == EClipboardContentType.Image) { ((Image)ccv.ClipboardContent).Dispose(); } }
public static void UploadImage(Bitmap bmp, ImageDestination imageDestination, FileDestination imageFileDestination, TaskSettings taskSettings = null) { if (bmp != null) { if (taskSettings == null) { taskSettings = TaskSettings.GetDefaultTaskSettings(); } if (taskSettings.IsSafeTaskSettings) { taskSettings.UseDefaultAfterCaptureJob = false; taskSettings.AfterCaptureJob = AfterCaptureTasks.UploadImageToHost; taskSettings.UseDefaultDestinations = false; taskSettings.ImageDestination = imageDestination; taskSettings.ImageFileDestination = imageFileDestination; } RunImageTask(bmp, taskSettings); } }
private static string ProcessTwoPassEncoding(string input, TaskMetadata metadata, TaskSettings taskSettings, bool deleteInputFile = true) { string screenshotsFolder = TaskHelpers.GetScreenshotsFolder(taskSettings, metadata); string fileName = TaskHelpers.GetFileName(taskSettings, taskSettings.CaptureSettings.FFmpegOptions.Extension, metadata); string output = Path.Combine(screenshotsFolder, fileName); try { if (taskSettings.CaptureSettings.FFmpegOptions.VideoCodec == FFmpegVideoCodec.gif) { screenRecorder.FFmpegEncodeAsGIF(input, output); } else { screenRecorder.FFmpegEncodeVideo(input, output); } } finally { if (deleteInputFile && !input.Equals(output, StringComparison.InvariantCultureIgnoreCase) && File.Exists(input)) { File.Delete(input); } } return(output); }
private void DoCaptureWork(ScreenCaptureDelegate capture, CaptureType captureType, TaskSettings taskSettings, bool autoHideForm = true) { if (autoHideForm) { Hide(); Thread.Sleep(250); } Image img = null; 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; img = capture(); } catch (Exception ex) { DebugHelper.WriteException(ex); } finally { if (autoHideForm) { this.ShowActivate(); } AfterCapture(img, captureType, taskSettings); } }
private void DoCapture(ScreenCaptureDelegate capture, CaptureType captureType, TaskSettings taskSettings = null, bool autoHideForm = true) { if (taskSettings == null) { taskSettings = TaskSettings.GetDefaultTaskSettings(); } if (taskSettings.CaptureSettings.IsDelayScreenshot && taskSettings.CaptureSettings.DelayScreenshot > 0) { TaskEx.Run(() => { int sleep = (int)(taskSettings.CaptureSettings.DelayScreenshot * 1000); Thread.Sleep(sleep); }, () => { DoCaptureWork(capture, captureType, taskSettings, autoHideForm); }); } else { DoCaptureWork(capture, captureType, taskSettings, autoHideForm); } }
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).ForceActivate(); }
public static void StartScreenRecording(ScreenRecordOutput outputType, ScreenRecordStartMethod startMethod, TaskSettings taskSettings = null) { if (taskSettings == null) { taskSettings = TaskSettings.GetDefaultTaskSettings(); } ScreenRecordManager.StartStopRecording(outputType, startMethod, taskSettings); }
public static MemoryStream SaveImage(Image img, EImageFormat imageFormat, TaskSettings taskSettings) { return(SaveImage(img, imageFormat, taskSettings.ImageSettings.ImageJPEGQuality, taskSettings.ImageSettings.ImageGIFQuality)); }
private void CaptureRegion(CaptureType captureType, TaskSettings taskSettings, bool autoHideForm = true) { Surface surface; switch (captureType) { default: case CaptureType.Rectangle: surface = new RectangleRegion(); break; case CaptureType.RectangleWindow: RectangleRegion rectangleRegion = new RectangleRegion(); rectangleRegion.AreaManager.WindowCaptureMode = true; surface = rectangleRegion; break; case CaptureType.RoundedRectangle: surface = new RoundedRectangleRegion(); break; case CaptureType.Ellipse: surface = new EllipseRegion(); break; case CaptureType.Triangle: surface = new TriangleRegion(); break; case CaptureType.Diamond: surface = new DiamondRegion(); break; case CaptureType.Polygon: surface = new PolygonRegion(); break; case CaptureType.Freehand: surface = new FreeHandRegion(); break; } DoCapture(() => { Image img = null; Image screenshot = Screenshot.CaptureFullscreen(); try { surface.Config = taskSettings.CaptureSettings.SurfaceOptions; surface.SurfaceImage = screenshot; surface.Prepare(); surface.ShowDialog(); if (surface.Result == SurfaceResult.Region) { img = surface.GetRegionImage(); screenshot.Dispose(); } else if (surface.Result == SurfaceResult.Fullscreen) { img = screenshot; } if (img != null) { isLightCapture = false; } } finally { surface.Dispose(); } return(img); }, captureType, taskSettings, autoHideForm); }
private static void StartRecording(ScreenRecordOutput outputType, TaskSettings taskSettings, ScreenRecordStartMethod startMethod = ScreenRecordStartMethod.Region) { if (outputType == ScreenRecordOutput.FFmpeg && taskSettings.CaptureSettings.FFmpegOptions.VideoCodec == FFmpegVideoCodec.gif) { outputType = ScreenRecordOutput.GIF; } if (outputType == ScreenRecordOutput.FFmpeg) { DebugHelper.WriteLine("Starting screen recording. Video encoder: \"{0}\", Audio encoder: \"{1}\", FPS: {2}", taskSettings.CaptureSettings.FFmpegOptions.VideoCodec.GetDescription(), taskSettings.CaptureSettings.FFmpegOptions.AudioCodec.GetDescription(), taskSettings.CaptureSettings.ScreenRecordFPS); } else { DebugHelper.WriteLine("Starting screen recording. FPS: {0}", taskSettings.CaptureSettings.GIFFPS); } 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_, "ShareX", 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, "ShareX", MessageBoxButtons.OK, MessageBoxIcon.Warning); return; } } if (outputType == ScreenRecordOutput.GIF) { taskSettings.CaptureSettings.FFmpegOptions.VideoCodec = FFmpegVideoCodec.gif; taskSettings.CaptureSettings.FFmpegOptions.UseCustomCommands = false; } 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__, "ShareX - " + Resources.ScreenRecordForm_StartRecording_FFmpeg_error, MessageBoxButtons.OK, MessageBoxIcon.Warning); return; } Rectangle captureRectangle = Rectangle.Empty; switch (startMethod) { case ScreenRecordStartMethod.Region: RegionCaptureTasks.GetRectangleRegion(out captureRectangle, taskSettings.CaptureSettings.SurfaceOptions); break; case ScreenRecordStartMethod.ActiveWindow: if (taskSettings.CaptureSettings.CaptureClientArea) { captureRectangle = CaptureHelpers.GetActiveWindowClientRectangle(); } else { captureRectangle = CaptureHelpers.GetActiveWindowRectangle(); } break; case ScreenRecordStartMethod.CustomRegion: captureRectangle = taskSettings.CaptureSettings.CaptureCustomRegion; 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; string path = ""; bool abortRequested = false; float duration = taskSettings.CaptureSettings.ScreenRecordFixedDuration ? taskSettings.CaptureSettings.ScreenRecordDuration : 0; recordForm = new ScreenRecordForm(captureRectangle, startMethod == ScreenRecordStartMethod.Region, duration); recordForm.StopRequested += StopRecording; recordForm.Show(); TaskEx.Run(() => { try { string filename = TaskHelpers.GetFilename(taskSettings, taskSettings.CaptureSettings.FFmpegOptions.Extension); path = TaskHelpers.CheckFilePath(taskSettings.CaptureFolder, filename, taskSettings); if (string.IsNullOrEmpty(path)) { abortRequested = true; } if (!abortRequested) { recordForm.ChangeState(ScreenRecordState.BeforeStart); if (taskSettings.CaptureSettings.ScreenRecordAutoStart) { int delay = (int)(taskSettings.CaptureSettings.ScreenRecordStartDelay * 1000); if (delay > 0) { recordForm.InvokeSafe(() => recordForm.StartCountdown(delay)); recordForm.RecordResetEvent.WaitOne(delay); } } else { recordForm.RecordResetEvent.WaitOne(); } if (recordForm.AbortRequested) { abortRequested = true; } if (!abortRequested) { 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 }; Screenshot screenshot = TaskHelpers.GetScreenshot(taskSettings); screenshot.CaptureCursor = taskSettings.CaptureSettings.ScreenRecordShowCursor; screenRecorder = new ScreenRecorder(ScreenRecordOutput.FFmpeg, options, screenshot, captureRectangle); screenRecorder.RecordingStarted += () => recordForm.ChangeState(ScreenRecordState.AfterRecordingStart); recordForm.ChangeState(ScreenRecordState.AfterStart); screenRecorder.StartRecording(); if (recordForm.AbortRequested) { abortRequested = true; } } } } catch (Exception e) { DebugHelper.WriteException(e); } try { if (!abortRequested && screenRecorder != null && File.Exists(path)) { recordForm.ChangeState(ScreenRecordState.AfterStop); string sourceFilePath = path; if (outputType == ScreenRecordOutput.GIF) { path = Path.Combine(taskSettings.CaptureFolder, TaskHelpers.GetFilename(taskSettings, "gif")); screenRecorder.FFmpegEncodeAsGIF(sourceFilePath, path); } if (taskSettings.CaptureSettings.RunScreencastCLI) { VideoEncoder encoder = Program.Settings.VideoEncoders[taskSettings.CaptureSettings.VideoEncoderSelected]; path = Path.Combine(taskSettings.CaptureFolder, TaskHelpers.GetFilename(taskSettings, encoder.OutputExtension)); screenRecorder.EncodeUsingCommandLine(encoder, sourceFilePath, path); } } } finally { if (recordForm != null) { recordForm.InvokeSafe(() => { recordForm.Close(); recordForm.Dispose(); recordForm = null; }); } if (screenRecorder != null) { if ((outputType == ScreenRecordOutput.GIF || taskSettings.CaptureSettings.RunScreencastCLI) && !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); } } } }, () => { string customFileName; if (!abortRequested && !string.IsNullOrEmpty(path) && File.Exists(path) && TaskHelpers.ShowAfterCaptureForm(taskSettings, out customFileName, null, path)) { if (!string.IsNullOrEmpty(customFileName)) { string currentFilename = Path.GetFileNameWithoutExtension(path); string ext = Path.GetExtension(path); if (!currentFilename.Equals(customFileName, StringComparison.InvariantCultureIgnoreCase)) { path = Helpers.RenameFile(path, customFileName + ext); } } WorkerTask task = WorkerTask.CreateFileJobTask(path, taskSettings, customFileName); TaskManager.Start(task); } abortRequested = false; IsRecording = false; }); }
public static void DownloadAndUploadFile(string url, TaskSettings taskSettings = null) { DownloadFile(url, true, taskSettings); }
public static void RunImageTask(Bitmap bmp, TaskSettings taskSettings, bool skipQuickTaskMenu = false, bool skipAfterCaptureWindow = false) { TaskMetadata metadata = new TaskMetadata(bmp); RunImageTask(metadata, taskSettings, skipQuickTaskMenu, skipAfterCaptureWindow); }
public static void DownloadFile(string url, TaskSettings taskSettings = null) { DownloadFile(url, false, taskSettings); }
private WorkerTask(TaskSettings taskSettings) { Status = TaskStatus.InQueue; Info = new TaskInfo(taskSettings); }
private static void StartRecording(ScreenRecordOutput outputType, TaskSettings taskSettings, ScreenRecordStartMethod startMethod = ScreenRecordStartMethod.Region) { if (outputType == ScreenRecordOutput.GIF) { taskSettings.CaptureSettings.FFmpegOptions.VideoCodec = FFmpegVideoCodec.gif; } if (taskSettings.CaptureSettings.FFmpegOptions.IsAnimatedImage) { taskSettings.CaptureSettings.ScreenRecordTwoPassEncoding = true; } int fps; if (taskSettings.CaptureSettings.FFmpegOptions.VideoCodec == FFmpegVideoCodec.gif) { fps = taskSettings.CaptureSettings.GIFFPS; } else { fps = taskSettings.CaptureSettings.ScreenRecordFPS; } DebugHelper.WriteLine("Starting screen recording. Video encoder: \"{0}\", Audio encoder: \"{1}\", FPS: {2}", taskSettings.CaptureSettings.FFmpegOptions.VideoCodec.GetDescription(), taskSettings.CaptureSettings.FFmpegOptions.AudioCodec.GetDescription(), fps); 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__, "ShareX - " + Resources.ScreenRecordForm_StartRecording_FFmpeg_error, MessageBoxButtons.OK, MessageBoxIcon.Warning); return; } Rectangle captureRectangle = Rectangle.Empty; switch (startMethod) { case ScreenRecordStartMethod.Region: if (taskSettings.CaptureSettings.ScreenRecordTransparentRegion) { RegionCaptureTasks.GetRectangleRegionTransparent(out captureRectangle); } else { RegionCaptureTasks.GetRectangleRegion(out captureRectangle, taskSettings.CaptureSettings.SurfaceOptions); } break; case ScreenRecordStartMethod.ActiveWindow: if (taskSettings.CaptureSettings.CaptureClientArea) { captureRectangle = CaptureHelpers.GetActiveWindowClientRectangle(); } else { captureRectangle = CaptureHelpers.GetActiveWindowRectangle(); } break; case ScreenRecordStartMethod.CustomRegion: captureRectangle = taskSettings.CaptureSettings.CaptureCustomRegion; break; case ScreenRecordStartMethod.LastRegion: captureRectangle = Program.Settings.ScreenRecordRegion; break; } Rectangle screenRectangle = CaptureHelpers.GetScreenBounds(); captureRectangle = Rectangle.Intersect(captureRectangle, screenRectangle); if (taskSettings.CaptureSettings.FFmpegOptions.IsEvenSizeRequired) { captureRectangle = CaptureHelpers.EvenRectangleSize(captureRectangle); } if (IsRecording || !captureRectangle.IsValid() || screenRecorder != null) { return; } Program.Settings.ScreenRecordRegion = captureRectangle; IsRecording = true; string path = ""; bool abortRequested = false; float duration = taskSettings.CaptureSettings.ScreenRecordFixedDuration ? taskSettings.CaptureSettings.ScreenRecordDuration : 0; recordForm = new ScreenRecordForm(captureRectangle, taskSettings, startMethod == ScreenRecordStartMethod.Region, duration); recordForm.StopRequested += StopRecording; recordForm.Show(); Task.Run(() => { try { string extension; if (taskSettings.CaptureSettings.ScreenRecordTwoPassEncoding) { extension = "mp4"; } else { extension = taskSettings.CaptureSettings.FFmpegOptions.Extension; } string filename = TaskHelpers.GetFilename(taskSettings, extension); path = TaskHelpers.HandleExistsFile(taskSettings.GetScreenshotsFolder(), filename, taskSettings); if (string.IsNullOrEmpty(path)) { abortRequested = true; } if (!abortRequested) { recordForm.ChangeState(ScreenRecordState.BeforeStart); if (taskSettings.CaptureSettings.ScreenRecordAutoStart) { int delay = (int)(taskSettings.CaptureSettings.ScreenRecordStartDelay * 1000); if (delay > 0) { recordForm.InvokeSafe(() => recordForm.StartCountdown(delay)); recordForm.RecordResetEvent.WaitOne(delay); } } else { recordForm.RecordResetEvent.WaitOne(); } if (recordForm.IsAbortRequested) { abortRequested = true; } if (!abortRequested) { ScreencastOptions options = new ScreencastOptions() { IsRecording = true, IsLossless = taskSettings.CaptureSettings.ScreenRecordTwoPassEncoding, FFmpeg = taskSettings.CaptureSettings.FFmpegOptions, FPS = fps, Duration = duration, OutputPath = path, CaptureArea = captureRectangle, DrawCursor = taskSettings.CaptureSettings.ScreenRecordShowCursor }; Screenshot screenshot = TaskHelpers.GetScreenshot(taskSettings); screenshot.CaptureCursor = taskSettings.CaptureSettings.ScreenRecordShowCursor; screenRecorder = new ScreenRecorder(ScreenRecordOutput.FFmpeg, options, screenshot, captureRectangle); screenRecorder.RecordingStarted += ScreenRecorder_RecordingStarted; screenRecorder.EncodingProgressChanged += ScreenRecorder_EncodingProgressChanged; recordForm.ChangeState(ScreenRecordState.AfterStart); screenRecorder.StartRecording(); if (recordForm.IsAbortRequested) { abortRequested = true; } } } } catch (Exception e) { DebugHelper.WriteException(e); } if (taskSettings.CaptureSettings.ScreenRecordTwoPassEncoding && !abortRequested && screenRecorder != null && File.Exists(path)) { recordForm.ChangeState(ScreenRecordState.Encoding); path = ProcessTwoPassEncoding(path, taskSettings); } if (recordForm != null) { recordForm.InvokeSafe(() => { recordForm.Close(); recordForm.Dispose(); recordForm = null; }); } if (screenRecorder != null) { screenRecorder.Dispose(); screenRecorder = null; if (abortRequested && !string.IsNullOrEmpty(path) && File.Exists(path)) { File.Delete(path); } } }).ContinueInCurrentContext(() => { string customFileName; if (!abortRequested && !string.IsNullOrEmpty(path) && File.Exists(path) && TaskHelpers.ShowAfterCaptureForm(taskSettings, out customFileName, null, path)) { if (!string.IsNullOrEmpty(customFileName)) { string currentFilename = Path.GetFileNameWithoutExtension(path); string ext = Path.GetExtension(path); if (!currentFilename.Equals(customFileName, StringComparison.InvariantCultureIgnoreCase)) { path = Helpers.RenameFile(path, customFileName + ext); } } WorkerTask task = WorkerTask.CreateFileJobTask(path, taskSettings, customFileName); TaskManager.Start(task); } abortRequested = false; IsRecording = false; }); }
public static void ClipboardUpload(TaskSettings taskSettings = null) { if (taskSettings == null) { taskSettings = TaskSettings.GetDefaultTaskSettings(); } if (Clipboard.ContainsImage()) { Image img = ClipboardHelpers.GetImage(); if (img != null) { if (!taskSettings.AdvancedSettings.ProcessImagesDuringClipboardUpload) { taskSettings.AfterCaptureJob = AfterCaptureTasks.UploadImageToHost; } RunImageTask(img, taskSettings); } } else if (Clipboard.ContainsText()) { string text = Clipboard.GetText(); if (!string.IsNullOrEmpty(text)) { string url = text.Trim(); if (URLHelpers.IsValidURL(url)) { if (taskSettings.UploadSettings.ClipboardUploadURLContents) { DownloadAndUploadFile(url, taskSettings); return; } if (taskSettings.UploadSettings.ClipboardUploadShortenURL) { ShortenURL(url, taskSettings); return; } if (taskSettings.UploadSettings.ClipboardUploadShareURL) { ShareURL(url, taskSettings); return; } } if (taskSettings.UploadSettings.ClipboardUploadAutoIndexFolder && text.Length <= 260 && Directory.Exists(text)) { IndexFolder(text, taskSettings); } else { UploadText(text, taskSettings, true); } } } else if (Clipboard.ContainsFileDropList()) { string[] files = Clipboard.GetFileDropList().OfType <string>().ToArray(); if (files.Length > 0) { UploadFile(files, taskSettings); } } }
public static void RunImageTask(Image img, TaskSettings taskSettings, bool skipQuickTaskMenu = false, bool skipAfterCaptureWindow = false) { ImageInfo imageInfo = new ImageInfo(img); RunImageTask(imageInfo, taskSettings, skipQuickTaskMenu, skipAfterCaptureWindow); }
public UploadTestForm() { InitializeComponent(); Icon = Resources.ShareX_Icon; if (TestImage == null) { TestImage = Resources.ShareX_Logo; } if (string.IsNullOrEmpty(TestText)) { TestText = Program.ApplicationName + " text upload test"; } if (string.IsNullOrEmpty(TestURL)) { TestURL = Links.URL_WEBSITE; } ListViewItem lvi; ListViewGroup imageUploadersGroup = new ListViewGroup("Image Uploaders", HorizontalAlignment.Left); ListViewGroup textUploadersGroup = new ListViewGroup("Text Uploaders", HorizontalAlignment.Left); ListViewGroup fileUploadersGroup = new ListViewGroup("File Uploaders", HorizontalAlignment.Left); ListViewGroup urlShortenersGroup = new ListViewGroup("URL Shorteners", HorizontalAlignment.Left); lvUploaders.Groups.AddRange(new[] { imageUploadersGroup, textUploadersGroup, fileUploadersGroup, urlShortenersGroup }); TaskSettings defaultTaskSettings = TaskSettings.GetDefaultTaskSettings(); foreach (ImageDestination uploader in Enum.GetValues(typeof(ImageDestination))) { switch (uploader) { case ImageDestination.Twitsnaps: // Not possible to upload without post Twitter case ImageDestination.FileUploader: // We are going to test this in File Uploader tests continue; } lvi = new ListViewItem(uploader.GetDescription()); UploadTask task = UploadTask.CreateImageUploaderTask((Image)TestImage.Clone(), defaultTaskSettings); task.Info.TaskSettings.ImageDestination = uploader; lvi.Tag = task; lvi.Group = imageUploadersGroup; lvUploaders.Items.Add(lvi); } foreach (TextDestination uploader in Enum.GetValues(typeof(TextDestination))) { switch (uploader) { case TextDestination.FileUploader: continue; } lvi = new ListViewItem(uploader.GetDescription()); UploadTask task = UploadTask.CreateTextUploaderTask(TestText, defaultTaskSettings); task.Info.TaskSettings.TextDestination = uploader; lvi.Tag = task; lvi.Group = textUploadersGroup; lvUploaders.Items.Add(lvi); } foreach (FileDestination uploader in Enum.GetValues(typeof(FileDestination))) { switch (uploader) { case FileDestination.CustomFileUploader: case FileDestination.SharedFolder: case FileDestination.Email: continue; } lvi = new ListViewItem(uploader.GetDescription()); UploadTask task = UploadTask.CreateImageUploaderTask((Image)TestImage.Clone(), defaultTaskSettings); task.Info.TaskSettings.ImageDestination = ImageDestination.FileUploader; task.Info.TaskSettings.FileDestination = uploader; lvi.Tag = task; lvi.Group = fileUploadersGroup; lvUploaders.Items.Add(lvi); } foreach (UrlShortenerType uploader in Enum.GetValues(typeof(UrlShortenerType))) { lvi = new ListViewItem(uploader.GetDescription()); UploadTask task = UploadTask.CreateURLShortenerTask(TestURL, defaultTaskSettings); task.Info.TaskSettings.URLShortenerDestination = uploader; lvi.Tag = task; lvi.Group = urlShortenersGroup; lvUploaders.Items.Add(lvi); } PrepareListItems(); }
public static bool SelectRegion(out Rectangle rect, TaskSettings taskSettings) { return(Surface.SelectRegion(out rect, taskSettings.CaptureSettings.SurfaceOptions)); }
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); }
protected abstract ImageInfo Execute(TaskSettings taskSettings);
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 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); }
private void HandleTask(TaskSettings taskSettings) { TaskSettings safeTaskSettings = TaskSettings.GetSafeTaskSettings(taskSettings); switch (safeTaskSettings.Job) { case HotkeyType.StopUploads: TaskManager.StopAllTasks(); break; case HotkeyType.ClipboardUpload: UploadManager.ClipboardUpload(safeTaskSettings); break; case HotkeyType.ClipboardUploadWithContentViewer: UploadManager.ClipboardUploadWithContentViewer(safeTaskSettings); break; case HotkeyType.FileUpload: UploadManager.UploadFile(safeTaskSettings); break; case HotkeyType.DragDropUpload: TaskHelpers.OpenDropWindow(); break; case HotkeyType.PrintScreen: CaptureScreenshot(CaptureType.Screen, safeTaskSettings, false); break; case HotkeyType.ActiveWindow: CaptureScreenshot(CaptureType.ActiveWindow, safeTaskSettings, false); break; case HotkeyType.ActiveMonitor: CaptureScreenshot(CaptureType.ActiveMonitor, safeTaskSettings, false); break; case HotkeyType.RectangleRegion: CaptureScreenshot(CaptureType.Rectangle, safeTaskSettings, false); break; case HotkeyType.WindowRectangle: CaptureScreenshot(CaptureType.RectangleWindow, safeTaskSettings, false); break; case HotkeyType.RectangleLight: CaptureLightRectangle(safeTaskSettings, false); break; case HotkeyType.RoundedRectangleRegion: CaptureScreenshot(CaptureType.RoundedRectangle, safeTaskSettings, false); break; case HotkeyType.EllipseRegion: CaptureScreenshot(CaptureType.Ellipse, safeTaskSettings, false); break; case HotkeyType.TriangleRegion: CaptureScreenshot(CaptureType.Triangle, safeTaskSettings, false); break; case HotkeyType.DiamondRegion: CaptureScreenshot(CaptureType.Diamond, safeTaskSettings, false); break; case HotkeyType.PolygonRegion: CaptureScreenshot(CaptureType.Polygon, safeTaskSettings, false); break; case HotkeyType.FreeHandRegion: CaptureScreenshot(CaptureType.Freehand, safeTaskSettings, false); break; case HotkeyType.LastRegion: CaptureScreenshot(CaptureType.LastRegion, safeTaskSettings, false); break; case HotkeyType.ScreenRecorder: TaskHelpers.DoScreenRecorder(safeTaskSettings); break; case HotkeyType.AutoCapture: TaskHelpers.OpenAutoCapture(); break; case HotkeyType.ScreenColorPicker: TaskHelpers.OpenScreenColorPicker(safeTaskSettings); break; case HotkeyType.Ruler: TaskHelpers.OpenRuler(); break; case HotkeyType.FTPClient: TaskHelpers.OpenFTPClient(); break; case HotkeyType.HashCheck: TaskHelpers.OpenHashCheck(); break; case HotkeyType.IndexFolder: TaskHelpers.OpenIndexFolder(); break; case HotkeyType.ImageEffects: TaskHelpers.OpenImageEffects(); break; case HotkeyType.QRCode: TaskHelpers.OpenQRCode(); break; } }
public TaskSettingsForm(TaskSettings hotkeySetting, bool isDefault = false) { InitializeComponent(); Icon = ShareXResources.Icon; TaskSettings = hotkeySetting; IsDefault = isDefault; if (IsDefault) { tcTaskSettings.TabPages.Remove(tpTask); chkUseDefaultGeneralSettings.Visible = chkUseDefaultImageSettings.Visible = chkUseDefaultCaptureSettings.Visible = chkUseDefaultActions.Visible = chkUseDefaultUploadSettings.Visible = chkUseDefaultIndexerSettings.Visible = chkUseDefaultAdvancedSettings.Visible = false; } else { tbDescription.Text = TaskSettings.Description ?? string.Empty; cbUseDefaultAfterCaptureSettings.Checked = TaskSettings.UseDefaultAfterCaptureJob; cbUseDefaultAfterUploadSettings.Checked = TaskSettings.UseDefaultAfterUploadJob; cbUseDefaultDestinationSettings.Checked = TaskSettings.UseDefaultDestinations; chkUseDefaultGeneralSettings.Checked = TaskSettings.UseDefaultGeneralSettings; chkUseDefaultImageSettings.Checked = TaskSettings.UseDefaultImageSettings; chkUseDefaultCaptureSettings.Checked = TaskSettings.UseDefaultCaptureSettings; chkUseDefaultActions.Checked = TaskSettings.UseDefaultActions; chkUseDefaultUploadSettings.Checked = TaskSettings.UseDefaultUploadSettings; chkUseDefaultIndexerSettings.Checked = TaskSettings.UseDefaultIndexerSettings; chkUseDefaultAdvancedSettings.Checked = TaskSettings.UseDefaultAdvancedSettings; } UpdateWindowTitle(); AddEnumItemsContextMenu <HotkeyType>(x => { TaskSettings.Job = x; UpdateWindowTitle(); }, cmsTask); AddMultiEnumItemsContextMenu <AfterCaptureTasks>(x => TaskSettings.AfterCaptureJob = TaskSettings.AfterCaptureJob.Swap(x), cmsAfterCapture); AddMultiEnumItemsContextMenu <AfterUploadTasks>(x => TaskSettings.AfterUploadJob = TaskSettings.AfterUploadJob.Swap(x), cmsAfterUpload); // Destinations -> Image uploader AddEnumItems <ImageDestination>(x => { TaskSettings.ImageDestination = x; // if click on "folder" with file destinations then set ImageFileDestination and check it if (x == ImageDestination.FileUploader) { SetEnumChecked(TaskSettings.ImageFileDestination, tsmiImageFileUploaders); } else // if click not on "folder" with destinations then uncheck file destinations { MainForm.Uncheck(tsmiImageFileUploaders); } }, tsmiImageUploaders); tsmiImageFileUploaders = (ToolStripDropDownItem)tsmiImageUploaders.DropDownItems[tsmiImageUploaders.DropDownItems.Count - 1]; AddEnumItems <FileDestination>(x => { TaskSettings.ImageFileDestination = x; tsmiImageFileUploaders.PerformClick(); }, tsmiImageFileUploaders); // Destinations -> Text uploader AddEnumItems <TextDestination>(x => { TaskSettings.TextDestination = x; // if click on "folder" with file destinations then set TextFileDestination and check it if (x == TextDestination.FileUploader) { SetEnumChecked(TaskSettings.TextFileDestination, tsmiTextFileUploaders); } else // if click not on "folder" with destinations then uncheck file destinations { MainForm.Uncheck(tsmiTextFileUploaders); } }, tsmiTextUploaders); tsmiTextFileUploaders = (ToolStripDropDownItem)tsmiTextUploaders.DropDownItems[tsmiTextUploaders.DropDownItems.Count - 1]; AddEnumItems <FileDestination>(x => { TaskSettings.TextFileDestination = x; tsmiTextFileUploaders.PerformClick(); }, tsmiTextFileUploaders); // Destinations -> File uploader AddEnumItems <FileDestination>(x => TaskSettings.FileDestination = x, tsmiFileUploaders); AddEnumItems <UrlShortenerType>(x => TaskSettings.URLShortenerDestination = x, tsmiURLShorteners); AddEnumItems <URLSharingServices>(x => TaskSettings.URLSharingServiceDestination = x, tsmiURLSharingServices); SetEnumCheckedContextMenu(TaskSettings.Job, cmsTask); SetMultiEnumCheckedContextMenu(TaskSettings.AfterCaptureJob, cmsAfterCapture); SetMultiEnumCheckedContextMenu(TaskSettings.AfterUploadJob, cmsAfterUpload); SetEnumChecked(TaskSettings.ImageDestination, tsmiImageUploaders); MainForm.SetImageFileDestinationChecked(TaskSettings.ImageDestination, TaskSettings.ImageFileDestination, tsmiImageFileUploaders); SetEnumChecked(TaskSettings.TextDestination, tsmiTextUploaders); MainForm.SetTextFileDestinationChecked(TaskSettings.TextDestination, TaskSettings.TextFileDestination, tsmiTextFileUploaders); SetEnumChecked(TaskSettings.FileDestination, tsmiFileUploaders); SetEnumChecked(TaskSettings.URLShortenerDestination, tsmiURLShorteners); SetEnumChecked(TaskSettings.URLSharingServiceDestination, tsmiURLSharingServices); if (Program.UploadersConfig != null) { // FTP if (Program.UploadersConfig.FTPAccountList.Count > 0) { 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); } // Custom uploader if (Program.UploadersConfig.CustomUploadersList.Count > 0) { chkOverrideCustomUploader.Checked = TaskSettings.OverrideCustomUploader; cbOverrideCustomUploader.Items.Clear(); cbOverrideCustomUploader.Items.AddRange(Program.UploadersConfig.CustomUploadersList.ToArray()); cbOverrideCustomUploader.SelectedIndex = TaskSettings.CustomUploaderIndex.BetweenOrDefault(0, Program.UploadersConfig.CustomUploadersList.Count - 1); } } UpdateDestinationStates(); UpdateUploaderMenuNames(); // General cbPlaySoundAfterCapture.Checked = TaskSettings.GeneralSettings.PlaySoundAfterCapture; cbShowAfterCaptureTasksForm.Checked = TaskSettings.GeneralSettings.ShowAfterCaptureTasksForm; chkShowBeforeUploadForm.Checked = TaskSettings.GeneralSettings.ShowBeforeUploadForm; cbPlaySoundAfterUpload.Checked = TaskSettings.GeneralSettings.PlaySoundAfterUpload; chkShowAfterUploadForm.Checked = TaskSettings.GeneralSettings.ShowAfterUploadForm; cboPopUpNotification.Items.Clear(); cboPopUpNotification.Items.AddRange(Helpers.GetLocalizedEnumDescriptions <PopUpNotificationType>()); cboPopUpNotification.SelectedIndex = (int)TaskSettings.GeneralSettings.PopUpNotification; cbHistorySave.Checked = TaskSettings.GeneralSettings.SaveHistory; // Image - General cbImageFormat.Items.AddRange(Enum.GetNames(typeof(EImageFormat))); cbImageFormat.SelectedIndex = (int)TaskSettings.ImageSettings.ImageFormat; nudImageJPEGQuality.Value = TaskSettings.ImageSettings.ImageJPEGQuality; cbImageGIFQuality.Items.AddRange(Helpers.GetLocalizedEnumDescriptions <GIFQuality>()); cbImageGIFQuality.SelectedIndex = (int)TaskSettings.ImageSettings.ImageGIFQuality; nudUseImageFormat2After.Value = TaskSettings.ImageSettings.ImageSizeLimit; cbImageFormat2.Items.AddRange(Enum.GetNames(typeof(EImageFormat))); cbImageFormat2.SelectedIndex = (int)TaskSettings.ImageSettings.ImageFormat2; cbImageFileExist.Items.Clear(); cbImageFileExist.Items.AddRange(Helpers.GetLocalizedEnumDescriptions <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; // Capture / Region capture if (TaskSettings.CaptureSettings.SurfaceOptions == null) { TaskSettings.CaptureSettings.SurfaceOptions = new SurfaceOptions(); } pgRegionCapture.SelectedObject = TaskSettings.CaptureSettings.SurfaceOptions; // Capture / Rectangle annotate if (TaskSettings.CaptureSettings.RectangleAnnotateOptions == null) { TaskSettings.CaptureSettings.RectangleAnnotateOptions = new RectangleAnnotateOptions(); } pgRectangleAnnotate.SelectedObject = TaskSettings.CaptureSettings.RectangleAnnotateOptions; // Capture / Screen recorder chkRunScreencastCLI.Checked = cboEncoder.Enabled = btnEncoderConfig.Enabled = TaskSettings.CaptureSettings.RunScreencastCLI; UpdateVideoEncoders(); nudScreenRecordFPS.Value = TaskSettings.CaptureSettings.ScreenRecordFPS.Between((int)nudScreenRecordFPS.Minimum, (int)nudScreenRecordFPS.Maximum); nudGIFFPS.Value = TaskSettings.CaptureSettings.GIFFPS.Between((int)nudGIFFPS.Minimum, (int)nudGIFFPS.Maximum); cbScreenRecorderFixedDuration.Checked = nudScreenRecorderDuration.Enabled = TaskSettings.CaptureSettings.ScreenRecordFixedDuration; nudScreenRecorderDuration.Value = (decimal)TaskSettings.CaptureSettings.ScreenRecordDuration; chkScreenRecordAutoStart.Checked = nudScreenRecorderStartDelay.Enabled = TaskSettings.CaptureSettings.ScreenRecordAutoStart; nudScreenRecorderStartDelay.Value = (decimal)TaskSettings.CaptureSettings.ScreenRecordStartDelay; cbScreenRecordAutoDisableAero.Checked = TaskSettings.CaptureSettings.ScreenRecordAutoDisableAero; // Actions TaskHelpers.AddDefaultExternalPrograms(TaskSettings); TaskSettings.ExternalPrograms.ForEach(AddFileAction); // Watch folders cbWatchFolderEnabled.Checked = TaskSettings.WatchFolderEnabled; if (TaskSettings.WatchFolderList == null) { TaskSettings.WatchFolderList = new List <WatchFolderSettings>(); } else { foreach (WatchFolderSettings watchFolder in TaskSettings.WatchFolderList) { AddWatchFolder(watchFolder); } } // Upload / Name pattern txtNameFormatPattern.Text = TaskSettings.UploadSettings.NameFormatPattern; txtNameFormatPatternActiveWindow.Text = TaskSettings.UploadSettings.NameFormatPatternActiveWindow; CodeMenu.Create <ReplCodeMenuEntry>(txtNameFormatPattern, ReplCodeMenuEntry.n, ReplCodeMenuEntry.t, ReplCodeMenuEntry.pn); CodeMenu.Create <ReplCodeMenuEntry>(txtNameFormatPatternActiveWindow, ReplCodeMenuEntry.n); cbFileUploadUseNamePattern.Checked = TaskSettings.UploadSettings.FileUploadUseNamePattern; // Upload / Clipboard upload chkClipboardUploadURLContents.Checked = TaskSettings.UploadSettings.ClipboardUploadURLContents; cbClipboardUploadShortenURL.Checked = TaskSettings.UploadSettings.ClipboardUploadShortenURL; cbClipboardUploadShareURL.Checked = TaskSettings.UploadSettings.ClipboardUploadShareURL; cbClipboardUploadAutoIndexFolder.Checked = TaskSettings.UploadSettings.ClipboardUploadAutoIndexFolder; // Indexer pgIndexerConfig.SelectedObject = TaskSettings.IndexerSettings; // Advanced pgTaskSettings.SelectedObject = TaskSettings.AdvancedSettings; tttvMain.MainTabControl = tcTaskSettings; UpdateDefaultSettingVisibility(); loaded = true; }