private void btnFullscreen_Click(object sender, EventArgs e)
{
UpdateRegion(CaptureHelpers.GetScreenBounds());
}
public void StartRecording(ScreenRecordOutput outputType, TaskSettings taskSettings, bool skipRegionSelection = false)
{
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_,
"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.GIFEncoding == ScreenRecordGIFEncoding.FFmpeg)
{
outputType = ScreenRecordOutput.FFmpeg;
taskSettings.CaptureSettings.FFmpegOptions.VideoCodec = FFmpegVideoCodec.gif;
}
if (outputType == 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 (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;
}
}
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;
if (skipRegionSelection)
{
captureRectangle = Program.Settings.ScreenRecordRegion;
}
else
{
TaskHelpers.SelectRegion(out captureRectangle, taskSettings);
captureRectangle = CaptureHelpers.EvenRectangleSize(captureRectangle);
}
if (IsRecording || !captureRectangle.IsValid() || screenRecorder != null)
{
return;
}
Program.Settings.ScreenRecordRegion = captureRectangle;
IsRecording = true;
Screenshot.CaptureCursor = taskSettings.CaptureSettings.ShowCursor;
string trayText = "ShareX - " + Resources.ScreenRecordForm_StartRecording_Waiting___;
TrayIcon.Text = trayText.Truncate(63);
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 (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.ShowCursor
};
screenRecorder = new ScreenRecorder(outputType, options, captureRectangle);
if (regionForm != null && regionForm.RecordResetEvent != null)
{
trayText = "ShareX - " + Resources.ScreenRecordForm_StartRecording_Click_tray_icon_to_start_recording_;
TrayIcon.Text = trayText.Truncate(63);
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)
{
trayText = "ShareX - " + Resources.ScreenRecordForm_StartRecording_Click_tray_icon_to_stop_recording_;
TrayIcon.Text = trayText.Truncate(63);
TrayIcon.Icon = Resources.control_record.ToIcon();
if (regionForm != null)
{
regionForm.InvokeSafe(() => regionForm.StartTimer());
}
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 = "ShareX - " + Resources.ScreenRecordForm_StartRecording_Encoding___;
TrayIcon.Icon = Resources.camcorder_pencil.ToIcon();
if (outputType == ScreenRecordOutput.GIF)
{
path = Path.Combine(taskSettings.CaptureFolder, TaskHelpers.GetFilename(taskSettings, "gif"));
screenRecorder.EncodingProgressChanged += progress => TrayIcon.Text = string.Format("ShareX - {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))
{
UploadTask task = UploadTask.CreateFileJobTask(path, taskSettings);
TaskManager.Start(task);
}
abortRequested = false;
IsRecording = false;
});
}
private void UpdateColor(int x, int y)
{
UpdateColor(x, y, CaptureHelpers.GetPixelColor(x, y));
}
public static Image CaptureWindowTransparent(IntPtr handle)
{
if (handle.ToInt32() > 0)
{
Rectangle rect = CaptureHelpers.GetWindowRectangle(handle);
if (CaptureShadow && !NativeMethods.IsZoomed(handle) && NativeMethods.IsDWMEnabled())
{
rect.Inflate(ShadowOffset, ShadowOffset);
rect.Intersect(CaptureHelpers.GetScreenBounds());
}
Bitmap whiteBackground = null, blackBackground = null, whiteBackground2 = null;
CursorData cursor = null;
bool isTransparent = false, isTaskbarHide = false;
try
{
if (AutoHideTaskbar)
{
isTaskbarHide = NativeMethods.SetTaskbarVisibilityIfIntersect(false, rect);
}
if (CaptureCursor)
{
try
{
cursor = new CursorData();
}
catch (Exception e)
{
DebugHelper.WriteException(e, "Cursor capture failed.");
}
}
using (Form form = new Form())
{
form.BackColor = Color.White;
form.FormBorderStyle = FormBorderStyle.None;
form.ShowInTaskbar = false;
NativeMethods.ShowWindow(form.Handle, (int)WindowShowStyle.ShowNormalNoActivate);
if (!NativeMethods.SetWindowPos(form.Handle, handle, rect.X, rect.Y, rect.Width, rect.Height, NativeMethods.SWP_NOACTIVATE))
{
form.Close();
DebugHelper.WriteLine("Transparent capture failed. Reason: SetWindowPos fail.");
return(CaptureWindow(handle));
}
Thread.Sleep(10);
Application.DoEvents();
whiteBackground = (Bitmap)CaptureRectangleNative(rect);
form.BackColor = Color.Black;
Application.DoEvents();
blackBackground = (Bitmap)CaptureRectangleNative(rect);
form.BackColor = Color.White;
Application.DoEvents();
whiteBackground2 = (Bitmap)CaptureRectangleNative(rect);
form.Close();
}
Bitmap transparentImage;
if (ImageHelpers.IsImagesEqual(whiteBackground, whiteBackground2))
{
transparentImage = CreateTransparentImage(whiteBackground, blackBackground);
isTransparent = true;
}
else
{
DebugHelper.WriteLine("Transparent capture failed. Reason: Images not equal.");
transparentImage = whiteBackground2;
}
if (cursor != null && cursor.IsVisible)
{
Point cursorOffset = CaptureHelpers.ScreenToClient(rect.Location);
cursor.DrawCursorToImage(transparentImage, cursorOffset);
}
if (isTransparent)
{
transparentImage = TrimTransparent(transparentImage);
if (!CaptureShadow)
{
TrimShadow(transparentImage);
}
}
return(transparentImage);
}
finally
{
if (isTaskbarHide)
{
NativeMethods.SetTaskbarVisibility(true);
}
if (whiteBackground != null)
{
whiteBackground.Dispose();
}
if (blackBackground != null)
{
blackBackground.Dispose();
}
if (isTransparent && whiteBackground2 != null)
{
whiteBackground2.Dispose();
}
if (cursor != null)
{
cursor.Dispose();
}
}
}
return(null);
}
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:
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.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.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 += () => recordForm.ChangeState(ScreenRecordState.AfterRecordingStart);
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;
});
}
private void DrawMagnifier(Graphics g)
{
Point mousePos = InputManager.MousePosition0Based;
Rectangle currentScreenRect0Based = CaptureHelpers.ScreenToClient(Screen.FromPoint(InputManager.MousePosition).Bounds);
int offsetX = 10, offsetY = 10, infoTextOffset = 0, infoTextPadding = 3;
Rectangle infoTextRect = Rectangle.Empty;
string infoText = string.Empty;
if (Config.ShowInfo)
{
infoTextOffset = 10;
CurrentPosition = InputManager.MousePosition;
infoText = GetInfoText();
Size textSize = g.MeasureString(infoText, infoFont).ToSize();
infoTextRect.Size = new Size(textSize.Width + infoTextPadding * 2, textSize.Height + infoTextPadding * 2);
}
using (Bitmap magnifier = Magnifier(SurfaceImage, mousePos, Config.MagnifierPixelCount, Config.MagnifierPixelCount, Config.MagnifierPixelSize))
{
int x = mousePos.X + offsetX;
if (x + magnifier.Width > currentScreenRect0Based.Right)
{
x = mousePos.X - offsetX - magnifier.Width;
}
int y = mousePos.Y + offsetY;
if (y + magnifier.Height + infoTextOffset + infoTextRect.Height > currentScreenRect0Based.Bottom)
{
y = mousePos.Y - offsetY - magnifier.Height - infoTextOffset - infoTextRect.Height;
}
if (Config.ShowInfo)
{
infoTextRect.Location = new Point(x + (magnifier.Width / 2) - (infoTextRect.Width / 2), y + magnifier.Height + infoTextOffset);
DrawInfoText(g, infoText, infoTextRect, infoTextPadding);
}
g.SetHighQuality();
using (TextureBrush brush = new TextureBrush(magnifier))
{
brush.TranslateTransform(x, y);
if (Config.UseSquareMagnifier)
{
g.FillRectangle(brush, x, y, magnifier.Width, magnifier.Height);
g.DrawRectangleProper(Pens.White, x - 1, y - 1, magnifier.Width + 2, magnifier.Height + 2);
g.DrawRectangleProper(Pens.Black, x, y, magnifier.Width, magnifier.Height);
}
else
{
g.FillEllipse(brush, x, y, magnifier.Width, magnifier.Height);
g.DrawEllipse(Pens.White, x - 1, y - 1, magnifier.Width + 2, magnifier.Height + 2);
g.DrawEllipse(Pens.Black, x, y, magnifier.Width, magnifier.Height);
}
}
}
}
public virtual void OnNodeUpdate()
{
for (int i = 0; i < 8; i++)
{
ResizeNode node = Manager.ResizeNodes[i];
if (node.IsDragging)
{
Manager.IsResizing = true;
if (!InputManager.IsBeforeMouseDown(MouseButtons.Left))
{
tempNodePos = node.Position;
tempStartPos = Rectangle.Location;
tempEndPos = new Point(Rectangle.X + Rectangle.Width - 1, Rectangle.Y + Rectangle.Height - 1);
}
Point pos = InputManager.MousePosition0Based;
Point startPos = tempStartPos;
Point endPos = tempEndPos;
NodePosition nodePosition = (NodePosition)i;
int x = pos.X - tempNodePos.X;
switch (nodePosition)
{
case NodePosition.TopLeft:
case NodePosition.Left:
case NodePosition.BottomLeft:
startPos.X += x;
break;
case NodePosition.TopRight:
case NodePosition.Right:
case NodePosition.BottomRight:
endPos.X += x;
break;
}
int y = pos.Y - tempNodePos.Y;
switch (nodePosition)
{
case NodePosition.TopLeft:
case NodePosition.Top:
case NodePosition.TopRight:
startPos.Y += y;
break;
case NodePosition.BottomLeft:
case NodePosition.Bottom:
case NodePosition.BottomRight:
endPos.Y += y;
break;
}
Rectangle = CaptureHelpers.CreateRectangle(startPos, endPos);
}
}
}
private void DrawFPS(Graphics g, int offset)
{
Rectangle screenBounds = CaptureHelpers.GetActiveScreenBounds0Based();
g.DrawTextWithShadow(FPS.ToString(), screenBounds.Location.Add(offset), infoFontBig, Brushes.White, Brushes.Black, new Point(0, 1));
}
private void DrawCursorGraphics(Graphics g)
{
Point mousePos = InputManager.MousePosition0Based;
Rectangle currentScreenRect0Based = CaptureHelpers.GetActiveScreenBounds0Based();
int cursorOffsetX = 10, cursorOffsetY = 10, itemGap = 10, itemCount = 0;
Size totalSize = Size.Empty;
int magnifierPosition = 0;
Bitmap magnifier = null;
if (Config.ShowMagnifier)
{
if (itemCount > 0)
{
totalSize.Height += itemGap;
}
magnifierPosition = totalSize.Height;
magnifier = Magnifier(Image, mousePos, Config.MagnifierPixelCount, Config.MagnifierPixelCount, Config.MagnifierPixelSize);
totalSize.Width = Math.Max(totalSize.Width, magnifier.Width);
totalSize.Height += magnifier.Height;
itemCount++;
}
int infoTextPadding = 3;
int infoTextPosition = 0;
Rectangle infoTextRect = Rectangle.Empty;
string infoText = "";
if (Config.ShowInfo)
{
if (itemCount > 0)
{
totalSize.Height += itemGap;
}
infoTextPosition = totalSize.Height;
CurrentPosition = InputManager.MousePosition;
infoText = GetInfoText();
Size textSize = g.MeasureString(infoText, infoFont).ToSize();
infoTextRect.Size = new Size(textSize.Width + infoTextPadding * 2, textSize.Height + infoTextPadding * 2);
totalSize.Width = Math.Max(totalSize.Width, infoTextRect.Width);
totalSize.Height += infoTextRect.Height;
itemCount++;
}
int x = mousePos.X + cursorOffsetX;
if (x + totalSize.Width > currentScreenRect0Based.Right)
{
x = mousePos.X - cursorOffsetX - totalSize.Width;
}
int y = mousePos.Y + cursorOffsetY;
if (y + totalSize.Height > currentScreenRect0Based.Bottom)
{
y = mousePos.Y - cursorOffsetY - totalSize.Height;
}
if (Config.ShowMagnifier)
{
using (GraphicsQualityManager quality = new GraphicsQualityManager(g))
using (TextureBrush brush = new TextureBrush(magnifier))
{
brush.TranslateTransform(x, y + magnifierPosition);
if (Config.UseSquareMagnifier)
{
g.FillRectangle(brush, x, y + magnifierPosition, magnifier.Width, magnifier.Height);
g.DrawRectangleProper(Pens.White, x - 1, y + magnifierPosition - 1, magnifier.Width + 2, magnifier.Height + 2);
g.DrawRectangleProper(Pens.Black, x, y + magnifierPosition, magnifier.Width, magnifier.Height);
}
else
{
g.FillEllipse(brush, x, y + magnifierPosition, magnifier.Width, magnifier.Height);
g.DrawEllipse(Pens.White, x - 1, y + magnifierPosition - 1, magnifier.Width + 2 - 1, magnifier.Height + 2 - 1);
g.DrawEllipse(Pens.Black, x, y + magnifierPosition, magnifier.Width - 1, magnifier.Height - 1);
}
}
}
if (Config.ShowInfo)
{
infoTextRect.Location = new Point(x + (totalSize.Width / 2) - (infoTextRect.Width / 2), y + infoTextPosition);
DrawInfoText(g, infoText, infoTextRect, infoFont, infoTextPadding);
}
}
public Image GetResultImage()
{
if (Mode == RegionCaptureMode.Editor)
{
foreach (BaseShape shape in ShapeManager.Shapes)
{
shape.Move(-ImageRectangle.X, -ImageRectangle.Y);
}
Image img = GetOutputImage();
foreach (BaseShape shape in ShapeManager.Shapes)
{
shape.Move(ImageRectangle.X, ImageRectangle.Y);
}
return(img);
}
else if (Result == RegionResult.Region || Result == RegionResult.LastRegion)
{
GraphicsPath gp;
if (Result == RegionResult.LastRegion)
{
gp = LastRegionFillPath;
}
else
{
gp = regionFillPath;
}
using (Image img = GetOutputImage())
{
return(RegionCaptureTasks.ApplyRegionPathToImage(img, gp));
}
}
else if (Result == RegionResult.Fullscreen)
{
return(GetOutputImage());
}
else if (Result == RegionResult.Monitor)
{
Screen[] screens = Screen.AllScreens;
if (MonitorIndex < screens.Length)
{
Screen screen = screens[MonitorIndex];
Rectangle screenRect = CaptureHelpers.ScreenToClient(screen.Bounds);
using (Image img = GetOutputImage())
{
return(ImageHelpers.CropImage(img, screenRect));
}
}
}
else if (Result == RegionResult.ActiveMonitor)
{
Rectangle activeScreenRect = CaptureHelpers.GetActiveScreenBounds0Based();
using (Image img = GetOutputImage())
{
return(ImageHelpers.CropImage(img, activeScreenRect));
}
}
return(null);
}
// Must be called before show form
public void Prepare(Image img)
{
Image = img;
if (Mode == RegionCaptureMode.Editor)
{
Rectangle rect = CaptureHelpers.GetActiveScreenBounds0Based();
if (Image.Width > rect.Width || Image.Height > rect.Height)
{
rect = ScreenRectangle0Based;
}
ImageRectangle = new Rectangle(rect.X + rect.Width / 2 - Image.Width / 2, rect.Y + rect.Height / 2 - Image.Height / 2, Image.Width, Image.Height);
using (Image background = ImageHelpers.DrawCheckers(ScreenRectangle0Based.Width, ScreenRectangle0Based.Height))
using (Graphics g = Graphics.FromImage(background))
{
g.DrawImage(Image, ImageRectangle);
backgroundBrush = new TextureBrush(background)
{
WrapMode = WrapMode.Clamp
};
}
}
else if (Config.UseDimming)
{
using (Bitmap darkBackground = (Bitmap)Image.Clone())
using (Graphics g = Graphics.FromImage(darkBackground))
using (Brush brush = new SolidBrush(Color.FromArgb(30, Color.Black)))
{
g.FillRectangle(brush, 0, 0, darkBackground.Width, darkBackground.Height);
backgroundBrush = new TextureBrush(darkBackground)
{
WrapMode = WrapMode.Clamp
};
}
backgroundHighlightBrush = new TextureBrush(Image)
{
WrapMode = WrapMode.Clamp
};
}
else
{
backgroundBrush = new TextureBrush(Image)
{
WrapMode = WrapMode.Clamp
};
}
ShapeManager = new ShapeManager(this);
ShapeManager.WindowCaptureMode = Config.DetectWindows;
ShapeManager.IncludeControls = Config.DetectControls;
if (Mode == RegionCaptureMode.OneClick || ShapeManager.WindowCaptureMode)
{
IntPtr handle = Handle;
TaskEx.Run(() =>
{
WindowsRectangleList wla = new WindowsRectangleList();
wla.IgnoreHandle = handle;
wla.IncludeChildWindows = ShapeManager.IncludeControls;
ShapeManager.Windows = wla.GetWindowInfoListAsync(5000);
});
}
if (Config.UseCustomInfoText || Mode == RegionCaptureMode.ScreenColorPicker)
{
bmpBackgroundImage = new Bitmap(Image);
}
}
public CompanionCubesForm()
{
StartPosition = FormStartPosition.Manual;
Bounds = CaptureHelpers.GetScreenWorkingArea();
Shown += CompanionCubesForm_Shown;
}
/// <summary>
/// Crop shot or Selected Window captures
/// </summary>
/// <param name="myImage">Fullscreen image</param>
/// <param name="windowMode">True = Selected window, False = Crop shot</param>
public Crop(Image myImage, bool windowMode)
{
InitializeComponent();
selectedWindowMode = windowMode;
bmpClean = new Bitmap(myImage);
bmpBackground = new Bitmap(bmpClean);
bmpRegion = new Bitmap(bmpClean);
Bounds = CaptureHelpers.GetScreenBounds();
this.CursorPos = this.PointToClient(Cursor.Position);
rectIntersect.Size = new Size(Bounds.Width - 1, Bounds.Height - 1);
SetStyle(ControlStyles.OptimizedDoubleBuffer | ControlStyles.UserPaint | ControlStyles.AllPaintingInWmPaint, true);
CalculateBoundaryFromMousePosition();
timer.Tick += new EventHandler(TimerTick);
windowCheck.Tick += new EventHandler(WindowCheckTick);
if (selectedWindowMode)
{
captureObjects = Engine.ConfigUI.SelectedWindowCaptureObjects;
myRectangle = new DynamicRectangle(CaptureType.SELECTED_WINDOW);
WindowsListAdvanced wla = new WindowsListAdvanced();
wla.IgnoreWindows.Add(Handle);
wla.IncludeChildWindows = captureObjects;
windows = wla.GetWindowsRectangleList();
}
else
{
myRectangle = new DynamicRectangle(CaptureType.CROP);
if (Engine.ConfigUI.UseHardwareCursor)
{
Cursor = Cursors.Cross;
}
else
{
Cursor.Hide();
}
}
using (Graphics gBackground = Graphics.FromImage(bmpBackground))
using (Graphics gRegion = Graphics.FromImage(bmpRegion))
{
gBackground.SmoothingMode = SmoothingMode.HighQuality;
gRegion.SmoothingMode = SmoothingMode.HighQuality;
if ((selectedWindowMode && Engine.ConfigUI.SelectedWindowRegionStyles == RegionStyles.REGION_TRANSPARENT) ||
(!selectedWindowMode && Engine.ConfigUI.CropRegionStyles == RegionStyles.REGION_TRANSPARENT))
{ // If Region Transparent
gRegion.FillRectangle(new SolidBrush(Color.FromArgb(Engine.ConfigUI.RegionTransparentValue, Color.White)),
new Rectangle(0, 0, bmpRegion.Width, bmpRegion.Height));
}
else if ((selectedWindowMode && Engine.ConfigUI.SelectedWindowRegionStyles == RegionStyles.REGION_BRIGHTNESS) ||
(!selectedWindowMode && Engine.ConfigUI.CropRegionStyles == RegionStyles.REGION_BRIGHTNESS))
{ // If Region Brightness
ImageAttributes imgattr = new ImageAttributes();
imgattr.SetColorMatrix(ColorMatrices.BrightnessFilter(Engine.ConfigUI.RegionBrightnessValue));
gRegion.DrawImage(bmpClean, new Rectangle(0, 0, bmpRegion.Width, bmpRegion.Height), 0, 0,
bmpRegion.Width, bmpRegion.Height, GraphicsUnit.Pixel, imgattr);
}
else if ((selectedWindowMode && Engine.ConfigUI.SelectedWindowRegionStyles == RegionStyles.BACKGROUND_REGION_TRANSPARENT) ||
(!selectedWindowMode && Engine.ConfigUI.CropRegionStyles == RegionStyles.BACKGROUND_REGION_TRANSPARENT))
{ // If Background Region Transparent
gBackground.FillRectangle(new SolidBrush(Color.FromArgb(Engine.ConfigUI.BackgroundRegionTransparentValue, Color.White)),
new Rectangle(0, 0, bmpBackground.Width, bmpBackground.Height));
}
else if ((selectedWindowMode && Engine.ConfigUI.SelectedWindowRegionStyles == RegionStyles.BACKGROUND_REGION_BRIGHTNESS) ||
(!selectedWindowMode && Engine.ConfigUI.CropRegionStyles == RegionStyles.BACKGROUND_REGION_BRIGHTNESS))
{ // If Background Region Brightness
ImageAttributes imgattr = new ImageAttributes();
imgattr.SetColorMatrix(ColorMatrices.BrightnessFilter(Engine.ConfigUI.BackgroundRegionBrightnessValue));
gBackground.DrawImage(bmpClean, new Rectangle(0, 0, bmpBackground.Width, bmpBackground.Height), 0, 0,
bmpBackground.Width, bmpBackground.Height, GraphicsUnit.Pixel, imgattr);
}
else if ((selectedWindowMode && Engine.ConfigUI.SelectedWindowRegionStyles == RegionStyles.BACKGROUND_REGION_GRAYSCALE) ||
(!selectedWindowMode && Engine.ConfigUI.CropRegionStyles == RegionStyles.BACKGROUND_REGION_GRAYSCALE))
{ // If Background Region Grayscale
ImageAttributes imgattr = new ImageAttributes();
imgattr.SetColorMatrix(ColorMatrices.GrayscaleFilter());
gBackground.DrawImage(bmpClean, new Rectangle(0, 0, bmpBackground.Width, bmpBackground.Height), 0, 0,
bmpBackground.Width, bmpBackground.Height, GraphicsUnit.Pixel, imgattr);
}
}
brushClean = new TextureBrush(bmpClean);
brushBackground = new TextureBrush(bmpBackground);
brushRegion = new TextureBrush(bmpRegion);
}
public void Update()
{
BaseShape shape = shapeManager.CurrentShape;
if (shape != null && Visible && nodes != null)
{
if (InputManager.IsMouseDown(MouseButtons.Left))
{
if (shape.NodeType == NodeType.Rectangle)
{
for (int i = 0; i < 8; i++)
{
if (nodes[i].IsDragging)
{
IsResizing = true;
if (!InputManager.IsBeforeMouseDown(MouseButtons.Left))
{
tempRect = shape.Rectangle;
}
NodePosition nodePosition = (NodePosition)i;
int x = InputManager.MouseVelocity.X;
switch (nodePosition)
{
case NodePosition.TopLeft:
case NodePosition.Left:
case NodePosition.BottomLeft:
tempRect.X += x;
tempRect.Width -= x;
break;
case NodePosition.TopRight:
case NodePosition.Right:
case NodePosition.BottomRight:
tempRect.Width += x;
break;
}
int y = InputManager.MouseVelocity.Y;
switch (nodePosition)
{
case NodePosition.TopLeft:
case NodePosition.Top:
case NodePosition.TopRight:
tempRect.Y += y;
tempRect.Height -= y;
break;
case NodePosition.BottomLeft:
case NodePosition.Bottom:
case NodePosition.BottomRight:
tempRect.Height += y;
break;
}
shape.Rectangle = CaptureHelpers.FixRectangle(tempRect);
break;
}
}
}
else if (shape.NodeType == NodeType.Line)
{
if (nodes[(int)NodePosition.TopLeft].IsDragging)
{
IsResizing = true;
shape.StartPosition = new Point(InputManager.MousePosition0Based.X, InputManager.MousePosition0Based.Y);
}
else if (nodes[(int)NodePosition.BottomRight].IsDragging)
{
IsResizing = true;
shape.EndPosition = new Point(InputManager.MousePosition0Based.X, InputManager.MousePosition0Based.Y);
}
}
}
else
{
IsResizing = false;
}
UpdateNodePositions();
}
}
public void Update()
{
if (Visible && nodes != null)
{
if (InputManager.IsMouseDown(MouseButtons.Left))
{
for (int i = 0; i < 8; i++)
{
if (nodes[i].IsDragging)
{
IsResizing = true;
if (!InputManager.IsBeforeMouseDown(MouseButtons.Left))
{
tempRect = areaManager.CurrentArea;
}
NodePosition nodePosition = (NodePosition)i;
int x = InputManager.MouseVelocity.X;
switch (nodePosition)
{
case NodePosition.TopLeft:
case NodePosition.Left:
case NodePosition.BottomLeft:
tempRect.X += x;
tempRect.Width -= x;
break;
case NodePosition.TopRight:
case NodePosition.Right:
case NodePosition.BottomRight:
tempRect.Width += x;
break;
}
int y = InputManager.MouseVelocity.Y;
switch (nodePosition)
{
case NodePosition.TopLeft:
case NodePosition.Top:
case NodePosition.TopRight:
tempRect.Y += y;
tempRect.Height -= y;
break;
case NodePosition.BottomLeft:
case NodePosition.Bottom:
case NodePosition.BottomRight:
tempRect.Height += y;
break;
}
areaManager.CurrentArea = CaptureHelpers.FixRectangle(tempRect);
break;
}
}
}
else
{
IsResizing = false;
}
UpdateNodePositions();
}
}
private void timer_Tick(object sender, EventArgs e)
{
CurrentMousePosition = CaptureHelpers.GetCursorPosition();
SelectionRectangle = CaptureHelpers.CreateRectangle(positionOnClick.X, positionOnClick.Y, CurrentMousePosition.X, CurrentMousePosition.Y);
Refresh();
}
protected override void Draw(Graphics g)
{
if (AreaManager.IsCreating && AreaManager.IsSnapResizing)
{
foreach (Size size in Config.SnapSizes)
{
Rectangle snapRect = CaptureHelpers.CalculateNewRectangle(AreaManager.PositionOnClick, AreaManager.CurrentPosition, size);
g.DrawRectangleProper(markerPen, snapRect);
}
}
List <RegionInfo> areas = AreaManager.ValidAreas.ToList();
bool drawAreaExist = areas.Count > 0;
if (AreaManager.IsCurrentHoverAreaValid && areas.All(area => area.Area != AreaManager.CurrentHoverArea))
{
areas.Add(AreaManager.GetRegionInfo(AreaManager.CurrentHoverArea));
}
if (areas.Count > 0)
{
UpdateRegionPath();
if (drawAreaExist)
{
if (Config.UseDimming)
{
using (Region region = new Region(regionDrawPath))
{
g.Clip = region;
g.FillRectangle(lightBackgroundBrush, ScreenRectangle0Based);
g.ResetClip();
}
}
using (Pen blinkBorderPen = new Pen(colorBlinkAnimation.GetColor()))
{
g.DrawPath(blinkBorderPen, regionDrawPath);
}
/*
* if (areas.Count > 1)
* {
* Rectangle totalArea = AreaManager.CombineAreas();
* g.DrawCrossRectangle(borderPen, totalArea, 15);
*
* if (Config.ShowInfo)
* {
* ImageHelpers.DrawTextWithOutline(g, string.Format("X: {0} / Y: {1} / W: {2} / H: {3}", totalArea.X, totalArea.Y,
* totalArea.Width, totalArea.Height), new PointF(totalArea.X + 5, totalArea.Y - 25), textFont, Color.White, Color.Black);
* }
* }
*/
}
if (AreaManager.IsCurrentHoverAreaValid)
{
using (GraphicsPath hoverDrawPath = new GraphicsPath {
FillMode = FillMode.Winding
})
{
AddShapePath(hoverDrawPath, AreaManager.GetRegionInfo(AreaManager.CurrentHoverArea), -1);
g.DrawPath(borderPen, hoverDrawPath);
g.DrawPath(borderDotPen, hoverDrawPath);
}
}
if (AreaManager.IsCurrentAreaValid)
{
g.DrawRectangleProper(borderPen, AreaManager.CurrentArea);
g.DrawRectangleProper(borderDotPen, AreaManager.CurrentArea);
DrawObjects(g);
if (RulerMode)
{
DrawRuler(g, AreaManager.CurrentArea, borderPen, 5, 10);
DrawRuler(g, AreaManager.CurrentArea, borderPen, 15, 100);
Point centerPos = new Point(AreaManager.CurrentArea.X + AreaManager.CurrentArea.Width / 2, AreaManager.CurrentArea.Y + AreaManager.CurrentArea.Height / 2);
int markSize = 10;
g.DrawLine(borderPen, centerPos.X, centerPos.Y - markSize, centerPos.X, centerPos.Y + markSize);
g.DrawLine(borderPen, centerPos.X - markSize, centerPos.Y, centerPos.X + markSize, centerPos.Y);
}
}
if (Config.ShowInfo)
{
foreach (RegionInfo regionInfo in areas)
{
if (regionInfo.Area.IsValid())
{
string areaText = GetAreaText(regionInfo.Area);
DrawAreaText(g, areaText, regionInfo.Area);
}
}
}
}
if (Config.ShowTips)
{
DrawTips(g, 10, 10);
}
if (Config.ShowMagnifier)
{
DrawMagnifier(g);
}
if (Config.ShowCrosshair)
{
DrawCrosshair(g);
}
}
private void ZScreen_Load(object sender, EventArgs e)
{
Engine.zHandle = Handle;
#region Window Size/Location
if (Engine.ConfigApp.WindowLocation.IsEmpty)
{
Engine.ConfigApp.WindowLocation = Location;
}
if (Engine.ConfigApp.WindowSize.IsEmpty)
{
Engine.ConfigApp.WindowSize = Size;
}
if (Engine.ConfigApp.SaveFormSizePosition)
{
Rectangle screenRect = CaptureHelpers.GetScreenBounds();
screenRect.Inflate(-100, -100);
if (
screenRect.IntersectsWith(new Rectangle(Engine.ConfigApp.WindowLocation, Engine.ConfigApp.WindowSize)))
{
Size = Engine.ConfigApp.WindowSize;
Location = Engine.ConfigApp.WindowLocation;
}
}
#endregion Window Size/Location
#region Window Show/Hide
bool bHideWindow = false;
if (Engine.ConfigApp.ShowMainWindow)
{
if (Engine.ConfigApp.WindowState == FormWindowState.Maximized)
{
WindowState = FormWindowState.Maximized;
}
else
{
WindowState = FormWindowState.Normal;
}
ShowInTaskbar = Engine.ConfigApp.ShowInTaskbar;
}
else if (Engine.ConfigApp.ShowInTaskbar &&
Engine.ConfigApp.WindowButtonActionClose == WindowButtonAction.MinimizeToTaskbar)
{
WindowState = FormWindowState.Minimized;
}
else
{
bHideWindow = true;
}
if (Engine.ConfigApp.Windows7TaskbarIntegration && Engine.HasWindows7)
{
ZScreen_Windows7onlyTasks();
}
if (bHideWindow)
{
Hide(); // this should happen after windows 7 taskbar integration
}
#endregion Window Show/Hide
LoggerTimer timer = Engine.EngineLogger.StartTimer(new StackFrame().GetMethod().Name + " started");
ZScreen_Preconfig();
mDebug = new ZScreenDebugHelper();
mDebug.GetDebugInfo += debug_GetDebugInfo;
SetToolTip(nudScreenshotDelay);
new RichTextBoxMenu(rtbDebugLog, true);
new RichTextBoxMenu(rtbStats, true);
if (Engine.IsMultiInstance)
{
niTray.ShowBalloonTip(2000, Engine.GetProductName(),
string.Format("Another instance of {0} is already running...",
Application.ProductName), ToolTipIcon.Warning);
niTray.BalloonTipClicked += niTray2_BalloonTipClicked;
}
timer.WriteLineTime(new StackFrame().GetMethod().Name + " finished");
Application.Idle += Application_Idle;
}
private void btnFullscreen_Click(object sender, EventArgs e)
{
Program.Settings.AutoCaptureRegion = CaptureHelpers.GetScreenBounds();
UpdateRegion();
}
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;
}
Rectangle screenRectangle = CaptureHelpers.GetScreenBounds();
captureRectangle = Rectangle.Intersect(captureRectangle, screenRectangle);
if (outputType != ScreenRecordOutput.GIF)
{
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.IsAbortRequested)
{
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.IsAbortRequested)
{
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, Program.ToolsFolder);
}
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;
});
}
private static void Task_TaskCompleted(WorkerTask task)
{
try
{
task.KeepImage = false;
if (task != null)
{
if (task.RequestSettingUpdate)
{
Program.MainForm.UpdateCheckStates();
}
TaskInfo info = task.Info;
if (info != null && info.Result != null)
{
TaskThumbnailPanel panel = TaskThumbnailView.FindPanel(task);
if (panel != null)
{
panel.UpdateStatus();
panel.ProgressVisible = false;
}
ListViewItem lvi = TaskListView.FindItem(task);
if (task.Status == TaskStatus.Stopped)
{
DebugHelper.WriteLine($"Task stopped. Filename: {info.FileName}");
if (lvi != null)
{
lvi.Text = info.FileName;
lvi.SubItems[1].Text = info.Status;
lvi.ImageIndex = 2;
}
}
else if (task.Status == TaskStatus.Failed)
{
string errors = string.Join("\r\n\r\n", info.Result.Errors.ToArray());
DebugHelper.WriteLine($"Task failed. Filename: {info.FileName}, Errors:\r\n{errors}");
if (lvi != null)
{
lvi.SubItems[1].Text = info.Status;
lvi.SubItems[6].Text = "";
lvi.ImageIndex = 1;
}
if (!info.TaskSettings.AdvancedSettings.DisableNotifications)
{
if (info.TaskSettings.GeneralSettings.PlaySoundAfterUpload)
{
TaskHelpers.PlayErrorSound(info.TaskSettings);
}
if (info.TaskSettings.GeneralSettings.PopUpNotification != PopUpNotificationType.None && !string.IsNullOrEmpty(errors) &&
(!info.TaskSettings.AdvancedSettings.DisableNotificationsOnFullscreen || !CaptureHelpers.IsActiveWindowFullscreen()))
{
TaskHelpers.ShowBalloonTip(errors, ToolTipIcon.Error, 5000, "ShareX - " + Resources.TaskManager_task_UploadCompleted_Error);
}
}
}
else
{
DebugHelper.WriteLine($"Task completed. Filename: {info.FileName}, Duration: {(long)info.TaskDuration.TotalMilliseconds} ms");
string result = info.Result.ToString();
if (string.IsNullOrEmpty(result) && !string.IsNullOrEmpty(info.FilePath))
{
result = info.FilePath;
}
if (lvi != null)
{
lvi.Text = info.FileName;
lvi.SubItems[1].Text = info.Status;
lvi.ImageIndex = 2;
if (!string.IsNullOrEmpty(result))
{
lvi.SubItems[6].Text = result;
}
}
if (!task.StopRequested && !string.IsNullOrEmpty(result))
{
if (Program.Settings.HistorySaveTasks && (!Program.Settings.HistoryCheckURL ||
(!string.IsNullOrEmpty(info.Result.URL) || !string.IsNullOrEmpty(info.Result.ShortenedURL))))
{
HistoryItem historyItem = info.GetHistoryItem();
AppendHistoryItemAsync(historyItem);
}
RecentManager.Add(task);
if (!info.TaskSettings.AdvancedSettings.DisableNotifications && info.Job != TaskJob.ShareURL)
{
if (info.TaskSettings.GeneralSettings.PlaySoundAfterUpload)
{
TaskHelpers.PlayTaskCompleteSound(info.TaskSettings);
}
if (!string.IsNullOrEmpty(info.TaskSettings.AdvancedSettings.BalloonTipContentFormat))
{
result = new UploadInfoParser().Parse(info, info.TaskSettings.AdvancedSettings.BalloonTipContentFormat);
}
if (!string.IsNullOrEmpty(result) &&
(!info.TaskSettings.AdvancedSettings.DisableNotificationsOnFullscreen || !CaptureHelpers.IsActiveWindowFullscreen()))
{
switch (info.TaskSettings.GeneralSettings.PopUpNotification)
{
case PopUpNotificationType.BalloonTip:
BalloonTipAction action = new BalloonTipAction()
{
ClickAction = BalloonTipClickAction.OpenURL,
Text = result
};
TaskHelpers.ShowBalloonTip(result, ToolTipIcon.Info, 5000,
"ShareX - " + Resources.TaskManager_task_UploadCompleted_ShareX___Task_completed, action);
break;
case PopUpNotificationType.ToastNotification:
task.KeepImage = true;
NotificationFormConfig toastConfig = new NotificationFormConfig()
{
LeftClickAction = info.TaskSettings.AdvancedSettings.ToastWindowClickAction,
RightClickAction = info.TaskSettings.AdvancedSettings.ToastWindowRightClickAction,
MiddleClickAction = info.TaskSettings.AdvancedSettings.ToastWindowMiddleClickAction,
FilePath = info.FilePath,
Image = task.Image,
Text = "ShareX - " + Resources.TaskManager_task_UploadCompleted_ShareX___Task_completed + "\r\n" + result,
URL = result
};
NotificationForm.Show((int)(info.TaskSettings.AdvancedSettings.ToastWindowDuration * 1000),
(int)(info.TaskSettings.AdvancedSettings.ToastWindowFadeDuration * 1000),
info.TaskSettings.AdvancedSettings.ToastWindowPlacement,
info.TaskSettings.AdvancedSettings.ToastWindowSize, toastConfig);
break;
}
if (info.TaskSettings.AfterUploadJob.HasFlag(AfterUploadTasks.ShowAfterUploadWindow) && info.IsUploadJob)
{
AfterUploadForm dlg = new AfterUploadForm(info);
NativeMethods.ShowWindow(dlg.Handle, (int)WindowShowStyle.ShowNoActivate);
}
}
}
}
}
if (lvi != null)
{
lvi.EnsureVisible();
if (Program.Settings.AutoSelectLastCompletedTask)
{
TaskListView.ListViewControl.SelectSingle(lvi);
}
}
}
}
}
finally
{
if (!IsBusy && Program.CLI.IsCommandExist("AutoClose"))
{
Application.Exit();
}
else
{
StartTasks();
UpdateProgressUI();
if (Program.Settings.SaveSettingsAfterTaskCompleted && !IsBusy)
{
SettingManager.SaveAllSettingsAsync();
}
}
}
}
public Image CaptureActiveMonitor()
{
Rectangle bounds = CaptureHelpers.GetActiveScreenBounds();
return(CaptureRectangle(bounds));
}
public void StartRecording(TaskSettings taskSettings)
{
if (taskSettings.CaptureSettings.RunScreencastCLI)
{
if (!Program.Settings.VideoEncoders.IsValidIndex(taskSettings.CaptureSettings.VideoEncoderSelected))
{
MessageBox.Show("There is no valid CLI video encoder selected.", Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Warning);
return;
}
else if (!Program.Settings.VideoEncoders[taskSettings.CaptureSettings.VideoEncoderSelected].IsValid())
{
MessageBox.Show("CLI video encoder file does not exist: " + Program.Settings.VideoEncoders[taskSettings.CaptureSettings.VideoEncoderSelected].Path,
Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Warning);
return;
}
}
if (taskSettings.CaptureSettings.ScreenRecordOutput == ScreenRecordOutput.FFmpeg && !File.Exists(taskSettings.CaptureSettings.FFmpegOptions.CLIPath))
{
string ffmpegText = string.IsNullOrEmpty(taskSettings.CaptureSettings.FFmpegOptions.CLIPath) ? "ffmpeg.exe" : taskSettings.CaptureSettings.FFmpegOptions.CLIPath;
if (MessageBox.Show(ffmpegText + " does not exist." + Environment.NewLine + Environment.NewLine + "Would you like to automatically download it?",
Application.ProductName + " - Missing ffmpeg.exe", MessageBoxButtons.YesNo, MessageBoxIcon.Warning) == DialogResult.Yes)
{
if (FFmpegHelper.DownloadFFmpeg(false, DownloaderForm_InstallRequested) == DialogResult.OK)
{
Program.DefaultTaskSettings.CaptureSettings.FFmpegOptions.CLIPath = taskSettings.TaskSettingsReference.CaptureSettings.FFmpegOptions.CLIPath =
taskSettings.CaptureSettings.FFmpegOptions.CLIPath = Path.Combine(Program.ToolsFolder, "ffmpeg.exe");
}
}
else
{
return;
}
}
if (taskSettings.AdvancedSettings.ScreenRecorderUseActiveWindow)
{
ActiveWindowRegion(taskSettings);
}
else
{
SelectRegion();
}
captureRectangle = CaptureHelpers.EvenRectangleSize(captureRectangle);
if (IsRecording || !captureRectangle.IsValid() || screenRecorder != null)
{
return;
}
IsRecording = true;
Screenshot.CaptureCursor = taskSettings.CaptureSettings.ShowCursor;
TrayIcon.Text = "ShareX - 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);
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);
int delay = (int)(taskSettings.CaptureSettings.ScreenRecordStartDelay * 1000);
if (delay > 0)
{
Thread.Sleep(delay);
}
TrayIcon.Text = "ShareX - Click tray icon to stop recording.";
TrayIcon.Icon = Resources.control_record.ToIcon();
if (regionForm != null)
{
this.InvokeSafe(() => regionForm.StartTimer());
}
screenRecorder.StartRecording();
}
finally
{
if (dwmManager != null)
{
dwmManager.Dispose();
dwmManager = null;
}
if (regionForm != null)
{
this.InvokeSafe(() => regionForm.Close());
}
}
try
{
if (screenRecorder != null)
{
TrayIcon.Text = "ShareX - 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 (TrayIcon.Visible)
{
TrayIcon.Visible = false;
}
IsRecording = false;
if (!string.IsNullOrEmpty(path) && File.Exists(path) && TaskHelpers.ShowAfterCaptureForm(taskSettings))
{
UploadTask task = UploadTask.CreateFileJobTask(path, taskSettings);
TaskManager.Start(task);
}
});
}
public Image CaptureFullscreen()
{
Rectangle bounds = CaptureHelpers.GetScreenBounds();
return(CaptureRectangle(bounds));
}
private void CreateToolbar()
{
menuForm = new Form()
{
AutoScaleDimensions = new SizeF(6F, 13F),
AutoScaleMode = AutoScaleMode.Font,
AutoSize = true,
AutoSizeMode = AutoSizeMode.GrowAndShrink,
ClientSize = new Size(759, 509),
FormBorderStyle = FormBorderStyle.None,
Location = new Point(200, 200),
ShowInTaskbar = false,
StartPosition = FormStartPosition.Manual,
Text = "ShareX - Region capture menu",
TopMost = true
};
menuForm.Shown += MenuForm_Shown;
menuForm.KeyDown += MenuForm_KeyDown;
menuForm.KeyUp += MenuForm_KeyUp;
menuForm.LocationChanged += MenuForm_LocationChanged;
menuForm.SuspendLayout();
tsMain = new ToolStripEx()
{
AutoSize = true,
CanOverflow = false,
ClickThrough = true,
Dock = DockStyle.None,
GripStyle = ToolStripGripStyle.Hidden,
Location = new Point(0, 0),
MinimumSize = new Size(10, 30),
Padding = new Padding(0, 1, 0, 0),
Renderer = new CustomToolStripProfessionalRenderer(),
TabIndex = 0,
ShowItemToolTips = false
};
tsMain.MouseLeave += TsMain_MouseLeave;
tsMain.SuspendLayout();
// https://www.medo64.com/2014/01/scaling-toolstrip-with-dpi/
using (Graphics g = menuForm.CreateGraphics())
{
double scale = Math.Max(g.DpiX, g.DpiY) / 96.0;
double newScale = ((int)Math.Floor(scale * 100) / 25 * 25) / 100.0;
if (newScale > 1)
{
int newWidth = (int)(tsMain.ImageScalingSize.Width * newScale);
int newHeight = (int)(tsMain.ImageScalingSize.Height * newScale);
tsMain.ImageScalingSize = new Size(newWidth, newHeight);
}
}
menuForm.Controls.Add(tsMain);
tslDragLeft = new ToolStripLabel()
{
DisplayStyle = ToolStripItemDisplayStyle.Image,
Image = Resources.ui_radio_button_uncheck,
Margin = new Padding(2, 0, 2, 0),
Padding = new Padding(2)
};
tsMain.Items.Add(tslDragLeft);
if (form.IsEditorMode)
{
#region Editor mode
ToolStripButton tsbCompleteEdit = new ToolStripButton();
if (form.Mode == RegionCaptureMode.Editor)
{
tsbCompleteEdit.Text = Resources.ShapeManager_CreateToolbar_RunAfterCaptureTasks;
}
else
{
tsbCompleteEdit.Text = Resources.ShapeManager_CreateToolbar_ApplyChangesContinueTaskEnter;
}
tsbCompleteEdit.DisplayStyle = ToolStripItemDisplayStyle.Image;
tsbCompleteEdit.Image = Resources.tick;
tsbCompleteEdit.MouseDown += (sender, e) => form.Close(RegionResult.AnnotateRunAfterCaptureTasks);
tsMain.Items.Add(tsbCompleteEdit);
if (form.Mode == RegionCaptureMode.TaskEditor)
{
ToolStripButton tsbClose = new ToolStripButton(Resources.ShapeManager_CreateToolbar_ContinueTaskSpaceOrRightClick);
tsbClose.DisplayStyle = ToolStripItemDisplayStyle.Image;
tsbClose.Image = Resources.control;
tsbClose.MouseDown += (sender, e) => form.Close(RegionResult.AnnotateContinueTask);
tsMain.Items.Add(tsbClose);
ToolStripButton tsbCloseCancel = new ToolStripButton(Resources.ShapeManager_CreateToolbar_CancelTaskEsc);
tsbCloseCancel.DisplayStyle = ToolStripItemDisplayStyle.Image;
tsbCloseCancel.Image = Resources.cross;
tsbCloseCancel.MouseDown += (sender, e) => form.Close(RegionResult.AnnotateCancelTask);
tsMain.Items.Add(tsbCloseCancel);
}
if (form.Mode == RegionCaptureMode.TaskEditor)
{
tsMain.Items.Add(new ToolStripSeparator());
}
ToolStripButton tsbSaveImage = new ToolStripButton(Resources.ShapeManager_CreateToolbar_SaveImage);
tsbSaveImage.DisplayStyle = ToolStripItemDisplayStyle.Image;
tsbSaveImage.Enabled = File.Exists(form.ImageFilePath);
tsbSaveImage.Image = Resources.disk_black;
tsbSaveImage.MouseDown += (sender, e) => form.Close(RegionResult.AnnotateSaveImage);
tsMain.Items.Add(tsbSaveImage);
ToolStripButton tsbSaveImageAs = new ToolStripButton(Resources.ShapeManager_CreateToolbar_SaveImageAs);
tsbSaveImageAs.DisplayStyle = ToolStripItemDisplayStyle.Image;
tsbSaveImageAs.Image = Resources.disks_black;
tsbSaveImageAs.MouseDown += (sender, e) => form.Close(RegionResult.AnnotateSaveImageAs);
tsMain.Items.Add(tsbSaveImageAs);
ToolStripButton tsbCopyImage = new ToolStripButton(Resources.ShapeManager_CreateToolbar_CopyImageToClipboard);
tsbCopyImage.DisplayStyle = ToolStripItemDisplayStyle.Image;
tsbCopyImage.Image = Resources.clipboard;
tsbCopyImage.MouseDown += (sender, e) => form.Close(RegionResult.AnnotateCopyImage);
tsMain.Items.Add(tsbCopyImage);
ToolStripButton tsbUploadImage = new ToolStripButton(Resources.ShapeManager_CreateToolbar_UploadImage);
tsbUploadImage.DisplayStyle = ToolStripItemDisplayStyle.Image;
tsbUploadImage.Image = Resources.drive_globe;
tsbUploadImage.MouseDown += (sender, e) => form.Close(RegionResult.AnnotateUploadImage);
tsMain.Items.Add(tsbUploadImage);
ToolStripButton tsbPrintImage = new ToolStripButton(Resources.ShapeManager_CreateToolbar_PrintImage);
tsbPrintImage.DisplayStyle = ToolStripItemDisplayStyle.Image;
tsbPrintImage.Image = Resources.printer;
tsbPrintImage.MouseDown += (sender, e) => form.Close(RegionResult.AnnotatePrintImage);
tsMain.Items.Add(tsbPrintImage);
tsMain.Items.Add(new ToolStripSeparator());
#endregion Editor mode
}
#region Tools
foreach (ShapeType shapeType in Helpers.GetEnums <ShapeType>())
{
if (form.IsEditorMode)
{
if (IsShapeTypeRegion(shapeType))
{
continue;
}
}
else if (shapeType == ShapeType.DrawingRectangle)
{
tsMain.Items.Add(new ToolStripSeparator());
}
else if (shapeType == ShapeType.DrawingCrop)
{
continue;
}
ToolStripButton tsbShapeType = new ToolStripButton(shapeType.GetLocalizedDescription());
tsbShapeType.DisplayStyle = ToolStripItemDisplayStyle.Image;
Image img = null;
switch (shapeType)
{
case ShapeType.RegionRectangle:
img = Resources.layer_shape_region;
break;
case ShapeType.RegionEllipse:
img = Resources.layer_shape_ellipse_region;
break;
case ShapeType.RegionFreehand:
img = Resources.layer_shape_polygon;
break;
case ShapeType.DrawingRectangle:
img = Resources.layer_shape;
break;
case ShapeType.DrawingEllipse:
img = Resources.layer_shape_ellipse;
break;
case ShapeType.DrawingFreehand:
img = Resources.pencil;
break;
case ShapeType.DrawingLine:
img = Resources.layer_shape_line;
break;
case ShapeType.DrawingArrow:
img = Resources.layer_shape_arrow;
break;
case ShapeType.DrawingTextOutline:
img = Resources.edit_outline;
break;
case ShapeType.DrawingTextBackground:
img = Resources.edit_shade;
break;
case ShapeType.DrawingSpeechBalloon:
img = Resources.balloon_box_left;
break;
case ShapeType.DrawingStep:
img = Resources.counter_reset;
break;
case ShapeType.DrawingImage:
img = Resources.folder_open_image;
break;
case ShapeType.DrawingImageScreen:
img = Resources.monitor_image;
break;
case ShapeType.DrawingCursor:
img = Resources.cursor;
break;
case ShapeType.EffectBlur:
img = Resources.layer_shade;
break;
case ShapeType.EffectPixelate:
img = Resources.grid;
break;
case ShapeType.EffectHighlight:
img = Resources.highlighter_text;
break;
case ShapeType.DrawingCrop:
img = Resources.image_crop;
break;
}
tsbShapeType.Image = img;
tsbShapeType.Checked = shapeType == CurrentShapeType;
tsbShapeType.Tag = shapeType;
tsbShapeType.MouseDown += (sender, e) =>
{
tsbShapeType.RadioCheck();
CurrentShapeType = shapeType;
};
tsMain.Items.Add(tsbShapeType);
}
#endregion Tools
#region Shape options
tsMain.Items.Add(new ToolStripSeparator());
tsbBorderColor = new ToolStripButton(Resources.ShapeManager_CreateContextMenu_Border_color___);
tsbBorderColor.DisplayStyle = ToolStripItemDisplayStyle.Image;
tsbBorderColor.Click += (sender, e) =>
{
PauseForm();
ShapeType shapeType = CurrentShapeType;
Color borderColor;
if (shapeType == ShapeType.DrawingTextBackground || shapeType == ShapeType.DrawingSpeechBalloon)
{
borderColor = AnnotationOptions.TextBorderColor;
}
else if (shapeType == ShapeType.DrawingTextOutline)
{
borderColor = AnnotationOptions.TextOutlineBorderColor;
}
else if (shapeType == ShapeType.DrawingStep)
{
borderColor = AnnotationOptions.StepBorderColor;
}
else
{
borderColor = AnnotationOptions.BorderColor;
}
if (ColorPickerForm.PickColor(borderColor, out Color newColor))
{
if (shapeType == ShapeType.DrawingTextBackground || shapeType == ShapeType.DrawingSpeechBalloon)
{
AnnotationOptions.TextBorderColor = newColor;
}
else if (shapeType == ShapeType.DrawingTextOutline)
{
AnnotationOptions.TextOutlineBorderColor = newColor;
}
else if (shapeType == ShapeType.DrawingStep)
{
AnnotationOptions.StepBorderColor = newColor;
}
else
{
AnnotationOptions.BorderColor = newColor;
}
UpdateMenu();
UpdateCurrentShape();
}
ResumeForm();
};
tsMain.Items.Add(tsbBorderColor);
tsbFillColor = new ToolStripButton(Resources.ShapeManager_CreateContextMenu_Fill_color___);
tsbFillColor.DisplayStyle = ToolStripItemDisplayStyle.Image;
tsbFillColor.Click += (sender, e) =>
{
PauseForm();
ShapeType shapeType = CurrentShapeType;
Color fillColor;
if (shapeType == ShapeType.DrawingTextBackground || shapeType == ShapeType.DrawingSpeechBalloon)
{
fillColor = AnnotationOptions.TextFillColor;
}
else if (shapeType == ShapeType.DrawingStep)
{
fillColor = AnnotationOptions.StepFillColor;
}
else
{
fillColor = AnnotationOptions.FillColor;
}
if (ColorPickerForm.PickColor(fillColor, out Color newColor))
{
if (shapeType == ShapeType.DrawingTextBackground || shapeType == ShapeType.DrawingSpeechBalloon)
{
AnnotationOptions.TextFillColor = newColor;
}
else if (shapeType == ShapeType.DrawingStep)
{
AnnotationOptions.StepFillColor = newColor;
}
else
{
AnnotationOptions.FillColor = newColor;
}
UpdateMenu();
UpdateCurrentShape();
}
ResumeForm();
};
tsMain.Items.Add(tsbFillColor);
tsbHighlightColor = new ToolStripButton(Resources.ShapeManager_CreateContextMenu_Highlight_color___);
tsbHighlightColor.DisplayStyle = ToolStripItemDisplayStyle.Image;
tsbHighlightColor.Click += (sender, e) =>
{
PauseForm();
if (ColorPickerForm.PickColor(AnnotationOptions.HighlightColor, out Color newColor))
{
AnnotationOptions.HighlightColor = newColor;
UpdateMenu();
UpdateCurrentShape();
}
ResumeForm();
};
tsMain.Items.Add(tsbHighlightColor);
tsddbShapeOptions = new ToolStripDropDownButton(Resources.ShapeManager_CreateToolbar_ShapeOptions);
tsddbShapeOptions.DisplayStyle = ToolStripItemDisplayStyle.Image;
tsddbShapeOptions.Image = Resources.layer__pencil;
tsMain.Items.Add(tsddbShapeOptions);
tslnudBorderSize = new ToolStripLabeledNumericUpDown(Resources.ShapeManager_CreateContextMenu_Border_size_);
tslnudBorderSize.Content.Minimum = 0;
tslnudBorderSize.Content.Maximum = 20;
tslnudBorderSize.Content.ValueChanged = (sender, e) =>
{
ShapeType shapeType = CurrentShapeType;
int borderSize = (int)tslnudBorderSize.Content.Value;
if (shapeType == ShapeType.DrawingTextBackground || shapeType == ShapeType.DrawingSpeechBalloon)
{
AnnotationOptions.TextBorderSize = borderSize;
}
else if (shapeType == ShapeType.DrawingTextOutline)
{
AnnotationOptions.TextOutlineBorderSize = borderSize;
}
else if (shapeType == ShapeType.DrawingStep)
{
AnnotationOptions.StepBorderSize = borderSize;
}
else
{
AnnotationOptions.BorderSize = borderSize;
}
UpdateCurrentShape();
};
tsddbShapeOptions.DropDownItems.Add(tslnudBorderSize);
tslnudCornerRadius = new ToolStripLabeledNumericUpDown(Resources.ShapeManager_CreateContextMenu_Corner_radius_);
tslnudCornerRadius.Content.Minimum = 0;
tslnudCornerRadius.Content.Maximum = 150;
tslnudCornerRadius.Content.ValueChanged = (sender, e) =>
{
ShapeType shapeType = CurrentShapeType;
if (shapeType == ShapeType.RegionRectangle)
{
AnnotationOptions.RegionCornerRadius = (int)tslnudCornerRadius.Content.Value;
}
else if (shapeType == ShapeType.DrawingRectangle || shapeType == ShapeType.DrawingTextBackground)
{
AnnotationOptions.DrawingCornerRadius = (int)tslnudCornerRadius.Content.Value;
}
UpdateCurrentShape();
};
tsddbShapeOptions.DropDownItems.Add(tslnudCornerRadius);
tslnudBlurRadius = new ToolStripLabeledNumericUpDown(Resources.ShapeManager_CreateContextMenu_Blur_radius_);
tslnudBlurRadius.Content.Minimum = 3;
tslnudBlurRadius.Content.Maximum = 199;
tslnudBlurRadius.Content.Increment = 2;
tslnudBlurRadius.Content.ValueChanged = (sender, e) =>
{
AnnotationOptions.BlurRadius = (int)tslnudBlurRadius.Content.Value;
UpdateCurrentShape();
};
tsddbShapeOptions.DropDownItems.Add(tslnudBlurRadius);
tslnudPixelateSize = new ToolStripLabeledNumericUpDown(Resources.ShapeManager_CreateContextMenu_Pixel_size_);
tslnudPixelateSize.Content.Minimum = 2;
tslnudPixelateSize.Content.Maximum = 10000;
tslnudPixelateSize.Content.ValueChanged = (sender, e) =>
{
AnnotationOptions.PixelateSize = (int)tslnudPixelateSize.Content.Value;
UpdateCurrentShape();
};
tsddbShapeOptions.DropDownItems.Add(tslnudPixelateSize);
tslnudCenterPoints = new ToolStripLabeledNumericUpDown("Center points:");
tslnudCenterPoints.Content.Minimum = 0;
tslnudCenterPoints.Content.Maximum = LineDrawingShape.MaximumCenterPointCount;
tslnudCenterPoints.Content.ValueChanged = (sender, e) =>
{
AnnotationOptions.LineCenterPointCount = (int)tslnudCenterPoints.Content.Value;
UpdateCurrentShape();
};
tsddbShapeOptions.DropDownItems.Add(tslnudCenterPoints);
tsmiArrowHeadsBothSide = new ToolStripMenuItem("Arrows on both ends");
tsmiArrowHeadsBothSide.CheckOnClick = true;
tsmiArrowHeadsBothSide.Click += (sender, e) =>
{
AnnotationOptions.ArrowHeadsBothSide = tsmiArrowHeadsBothSide.Checked;
UpdateCurrentShape();
};
tsddbShapeOptions.DropDownItems.Add(tsmiArrowHeadsBothSide);
tsmiShadow = new ToolStripMenuItem(Resources.ShapeManager_CreateToolbar_DropShadow);
tsmiShadow.Checked = true;
tsmiShadow.CheckOnClick = true;
tsmiShadow.Click += (sender, e) =>
{
AnnotationOptions.Shadow = tsmiShadow.Checked;
UpdateCurrentShape();
};
tsddbShapeOptions.DropDownItems.Add(tsmiShadow);
// In dropdown menu if only last item is visible then menu opens at 0, 0 position on first open, so need to add dummy item to solve this weird bug...
tsddbShapeOptions.DropDownItems.Add(new ToolStripSeparator()
{
Visible = false
});
#endregion Shape options
#region Edit
ToolStripDropDownButton tsddbEdit = new ToolStripDropDownButton(Resources.ShapeManager_CreateToolbar_Edit);
tsddbEdit.DisplayStyle = ToolStripItemDisplayStyle.Image;
tsddbEdit.Image = Resources.wrench_screwdriver;
tsMain.Items.Add(tsddbEdit);
tsmiUndo = new ToolStripMenuItem(Resources.ShapeManager_CreateToolbar_Undo);
tsmiUndo.Image = Resources.arrow_circle_225_left;
tsmiUndo.ShortcutKeyDisplayString = "Ctrl+Z";
tsmiUndo.MouseDown += (sender, e) => UndoShape();
tsddbEdit.DropDownItems.Add(tsmiUndo);
tsddbEdit.DropDownItems.Add(new ToolStripSeparator());
tsmiDelete = new ToolStripMenuItem(Resources.ShapeManager_CreateToolbar_Delete);
tsmiDelete.Image = Resources.layer__minus;
tsmiDelete.ShortcutKeyDisplayString = "Del";
tsmiDelete.MouseDown += (sender, e) => DeleteCurrentShape();
tsddbEdit.DropDownItems.Add(tsmiDelete);
tsmiDeleteAll = new ToolStripMenuItem(Resources.ShapeManager_CreateToolbar_DeleteAll);
tsmiDeleteAll.Image = Resources.eraser;
tsmiDeleteAll.ShortcutKeyDisplayString = "Shift+Del";
tsmiDeleteAll.MouseDown += (sender, e) => DeleteAllShapes();
tsddbEdit.DropDownItems.Add(tsmiDeleteAll);
tsddbEdit.DropDownItems.Add(new ToolStripSeparator());
tsmiMoveTop = new ToolStripMenuItem(Resources.ShapeManager_CreateToolbar_BringToFront);
tsmiMoveTop.Image = Resources.layers_stack_arrange;
tsmiMoveTop.ShortcutKeyDisplayString = "Home";
tsmiMoveTop.MouseDown += (sender, e) => MoveCurrentShapeTop();
tsddbEdit.DropDownItems.Add(tsmiMoveTop);
tsmiMoveUp = new ToolStripMenuItem(Resources.ShapeManager_CreateToolbar_BringForward);
tsmiMoveUp.Image = Resources.layers_arrange;
tsmiMoveUp.ShortcutKeyDisplayString = "Page up";
tsmiMoveUp.MouseDown += (sender, e) => MoveCurrentShapeUp();
tsddbEdit.DropDownItems.Add(tsmiMoveUp);
tsmiMoveDown = new ToolStripMenuItem(Resources.ShapeManager_CreateToolbar_SendBackward);
tsmiMoveDown.Image = Resources.layers_arrange_back;
tsmiMoveDown.ShortcutKeyDisplayString = "Page down";
tsmiMoveDown.MouseDown += (sender, e) => MoveCurrentShapeDown();
tsddbEdit.DropDownItems.Add(tsmiMoveDown);
tsmiMoveBottom = new ToolStripMenuItem(Resources.ShapeManager_CreateToolbar_SendToBack);
tsmiMoveBottom.Image = Resources.layers_stack_arrange_back;
tsmiMoveBottom.ShortcutKeyDisplayString = "End";
tsmiMoveBottom.MouseDown += (sender, e) => MoveCurrentShapeBottom();
tsddbEdit.DropDownItems.Add(tsmiMoveBottom);
#endregion Edit
if (!form.IsEditorMode)
{
tsMain.Items.Add(new ToolStripSeparator());
#region Capture
ToolStripDropDownButton tsddbCapture = new ToolStripDropDownButton(Resources.ShapeManager_CreateContextMenu_Capture);
tsddbCapture.DisplayStyle = ToolStripItemDisplayStyle.Image;
tsddbCapture.Image = Resources.camera;
tsMain.Items.Add(tsddbCapture);
tsmiRegionCapture = new ToolStripMenuItem(Resources.ShapeManager_CreateToolbar_CaptureRegions);
tsmiRegionCapture.Image = Resources.layer;
tsmiRegionCapture.ShortcutKeyDisplayString = "Enter";
tsmiRegionCapture.MouseDown += (sender, e) =>
{
form.UpdateRegionPath();
form.Close(RegionResult.Region);
};
tsddbCapture.DropDownItems.Add(tsmiRegionCapture);
if (RegionCaptureForm.LastRegionFillPath != null)
{
ToolStripMenuItem tsmiLastRegionCapture = new ToolStripMenuItem(Resources.ShapeManager_CreateToolbar_LastRegion);
tsmiLastRegionCapture.Image = Resources.layers;
tsmiLastRegionCapture.MouseDown += (sender, e) => form.Close(RegionResult.LastRegion);
tsddbCapture.DropDownItems.Add(tsmiLastRegionCapture);
}
ToolStripMenuItem tsmiFullscreenCapture = new ToolStripMenuItem(Resources.ShapeManager_CreateContextMenu_Capture_fullscreen);
tsmiFullscreenCapture.Image = Resources.layer_fullscreen;
tsmiFullscreenCapture.ShortcutKeyDisplayString = "Space";
tsmiFullscreenCapture.MouseDown += (sender, e) => form.Close(RegionResult.Fullscreen);
tsddbCapture.DropDownItems.Add(tsmiFullscreenCapture);
ToolStripMenuItem tsmiActiveMonitorCapture = new ToolStripMenuItem(Resources.ShapeManager_CreateContextMenu_Capture_active_monitor);
tsmiActiveMonitorCapture.Image = Resources.monitor;
tsmiActiveMonitorCapture.ShortcutKeyDisplayString = "~";
tsmiActiveMonitorCapture.MouseDown += (sender, e) => form.Close(RegionResult.ActiveMonitor);
tsddbCapture.DropDownItems.Add(tsmiActiveMonitorCapture);
ToolStripMenuItem tsmiMonitorCapture = new ToolStripMenuItem(Resources.ShapeManager_CreateContextMenu_Capture_monitor);
tsmiMonitorCapture.HideImageMargin();
tsmiMonitorCapture.Image = Resources.monitor_window;
tsddbCapture.DropDownItems.Add(tsmiMonitorCapture);
Screen[] screens = Screen.AllScreens;
for (int i = 0; i < screens.Length; i++)
{
Screen screen = screens[i];
ToolStripMenuItem tsmi = new ToolStripMenuItem($"{screen.Bounds.Width}x{screen.Bounds.Height}");
tsmi.ShortcutKeyDisplayString = (i + 1).ToString();
int index = i;
tsmi.MouseDown += (sender, e) =>
{
form.MonitorIndex = index;
form.Close(RegionResult.Monitor);
};
tsmiMonitorCapture.DropDownItems.Add(tsmi);
}
#endregion Capture
#region Options
ToolStripDropDownButton tsddbOptions = new ToolStripDropDownButton(Resources.ShapeManager_CreateContextMenu_Options);
tsddbOptions.DisplayStyle = ToolStripItemDisplayStyle.Image;
tsddbOptions.Image = Resources.gear;
tsMain.Items.Add(tsddbOptions);
tsmiQuickCrop = new ToolStripMenuItem(Resources.ShapeManager_CreateContextMenu_Multi_region_mode);
tsmiQuickCrop.Checked = !Config.QuickCrop;
tsmiQuickCrop.CheckOnClick = true;
tsmiQuickCrop.ShortcutKeyDisplayString = "Q";
tsmiQuickCrop.Click += (sender, e) => Config.QuickCrop = !tsmiQuickCrop.Checked;
tsddbOptions.DropDownItems.Add(tsmiQuickCrop);
tsmiTips = new ToolStripMenuItem(Resources.ShapeManager_CreateContextMenu_Show_tips);
tsmiTips.Checked = Config.ShowHotkeys;
tsmiTips.CheckOnClick = true;
tsmiTips.ShortcutKeyDisplayString = "F1";
tsmiTips.Click += (sender, e) => Config.ShowHotkeys = tsmiTips.Checked;
tsddbOptions.DropDownItems.Add(tsmiTips);
ToolStripMenuItem tsmiShowInfo = new ToolStripMenuItem(Resources.ShapeManager_CreateContextMenu_Show_position_and_size_info);
tsmiShowInfo.Checked = Config.ShowInfo;
tsmiShowInfo.CheckOnClick = true;
tsmiShowInfo.Click += (sender, e) => Config.ShowInfo = tsmiShowInfo.Checked;
tsddbOptions.DropDownItems.Add(tsmiShowInfo);
ToolStripMenuItem tsmiShowMagnifier = new ToolStripMenuItem(Resources.ShapeManager_CreateContextMenu_Show_magnifier);
tsmiShowMagnifier.Checked = Config.ShowMagnifier;
tsmiShowMagnifier.CheckOnClick = true;
tsmiShowMagnifier.Click += (sender, e) => Config.ShowMagnifier = tsmiShowMagnifier.Checked;
tsddbOptions.DropDownItems.Add(tsmiShowMagnifier);
ToolStripMenuItem tsmiUseSquareMagnifier = new ToolStripMenuItem(Resources.ShapeManager_CreateContextMenu_Square_shape_magnifier);
tsmiUseSquareMagnifier.Checked = Config.UseSquareMagnifier;
tsmiUseSquareMagnifier.CheckOnClick = true;
tsmiUseSquareMagnifier.Click += (sender, e) => Config.UseSquareMagnifier = tsmiUseSquareMagnifier.Checked;
tsddbOptions.DropDownItems.Add(tsmiUseSquareMagnifier);
ToolStripLabeledNumericUpDown tslnudMagnifierPixelCount = new ToolStripLabeledNumericUpDown(Resources.ShapeManager_CreateContextMenu_Magnifier_pixel_count_);
tslnudMagnifierPixelCount.Content.Minimum = RegionCaptureOptions.MagnifierPixelCountMinimum;
tslnudMagnifierPixelCount.Content.Maximum = RegionCaptureOptions.MagnifierPixelCountMaximum;
tslnudMagnifierPixelCount.Content.Increment = 2;
tslnudMagnifierPixelCount.Content.Value = Config.MagnifierPixelCount;
tslnudMagnifierPixelCount.Content.ValueChanged = (sender, e) => Config.MagnifierPixelCount = (int)tslnudMagnifierPixelCount.Content.Value;
tsddbOptions.DropDownItems.Add(tslnudMagnifierPixelCount);
ToolStripLabeledNumericUpDown tslnudMagnifierPixelSize = new ToolStripLabeledNumericUpDown(Resources.ShapeManager_CreateContextMenu_Magnifier_pixel_size_);
tslnudMagnifierPixelSize.Content.Minimum = RegionCaptureOptions.MagnifierPixelSizeMinimum;
tslnudMagnifierPixelSize.Content.Maximum = RegionCaptureOptions.MagnifierPixelSizeMaximum;
tslnudMagnifierPixelSize.Content.Value = Config.MagnifierPixelSize;
tslnudMagnifierPixelSize.Content.ValueChanged = (sender, e) => Config.MagnifierPixelSize = (int)tslnudMagnifierPixelSize.Content.Value;
tsddbOptions.DropDownItems.Add(tslnudMagnifierPixelSize);
ToolStripMenuItem tsmiShowCrosshair = new ToolStripMenuItem(Resources.ShapeManager_CreateContextMenu_Show_screen_wide_crosshair);
tsmiShowCrosshair.Checked = Config.ShowCrosshair;
tsmiShowCrosshair.CheckOnClick = true;
tsmiShowCrosshair.Click += (sender, e) => Config.ShowCrosshair = tsmiShowCrosshair.Checked;
tsddbOptions.DropDownItems.Add(tsmiShowCrosshair);
ToolStripMenuItem tsmiEnableAnimations = new ToolStripMenuItem(Resources.ShapeManager_CreateContextMenu_EnableAnimations);
tsmiEnableAnimations.Checked = Config.EnableAnimations;
tsmiEnableAnimations.CheckOnClick = true;
tsmiEnableAnimations.Click += (sender, e) => Config.EnableAnimations = tsmiEnableAnimations.Checked;
tsddbOptions.DropDownItems.Add(tsmiEnableAnimations);
ToolStripMenuItem tsmiFixedSize = new ToolStripMenuItem(Resources.ShapeManager_CreateContextMenu_Fixed_size_region_mode);
tsmiFixedSize.Checked = Config.IsFixedSize;
tsmiFixedSize.CheckOnClick = true;
tsmiFixedSize.Click += (sender, e) => Config.IsFixedSize = tsmiFixedSize.Checked;
tsddbOptions.DropDownItems.Add(tsmiFixedSize);
ToolStripDoubleLabeledNumericUpDown tslnudFixedSize = new ToolStripDoubleLabeledNumericUpDown(Resources.ShapeManager_CreateContextMenu_Width_,
Resources.ShapeManager_CreateContextMenu_Height_);
tslnudFixedSize.Content.Minimum = 10;
tslnudFixedSize.Content.Maximum = 10000;
tslnudFixedSize.Content.Increment = 10;
tslnudFixedSize.Content.Value = Config.FixedSize.Width;
tslnudFixedSize.Content.Value2 = Config.FixedSize.Height;
tslnudFixedSize.Content.ValueChanged = (sender, e) => Config.FixedSize = new Size((int)tslnudFixedSize.Content.Value, (int)tslnudFixedSize.Content.Value2);
tsddbOptions.DropDownItems.Add(tslnudFixedSize);
ToolStripMenuItem tsmiShowFPS = new ToolStripMenuItem(Resources.ShapeManager_CreateContextMenu_Show_FPS);
tsmiShowFPS.Checked = Config.ShowFPS;
tsmiShowFPS.CheckOnClick = true;
tsmiShowFPS.Click += (sender, e) => Config.ShowFPS = tsmiShowFPS.Checked;
tsddbOptions.DropDownItems.Add(tsmiShowFPS);
ToolStripMenuItem tsmiRememberMenuState = new ToolStripMenuItem(Resources.ShapeManager_CreateContextMenu_RememberMenuState);
tsmiRememberMenuState.Checked = Config.RememberMenuState;
tsmiRememberMenuState.CheckOnClick = true;
tsmiRememberMenuState.Click += (sender, e) => Config.RememberMenuState = tsmiRememberMenuState.Checked;
tsddbOptions.DropDownItems.Add(tsmiRememberMenuState);
#endregion Options
}
ToolStripLabel tslDragRight = new ToolStripLabel()
{
Alignment = ToolStripItemAlignment.Right,
DisplayStyle = ToolStripItemDisplayStyle.Image,
Image = Resources.ui_radio_button_uncheck,
Margin = new Padding(0, 0, 2, 0),
Padding = new Padding(2)
};
tsMain.Items.Add(tslDragRight);
tslDragLeft.MouseDown += TslDrag_MouseDown;
tslDragRight.MouseDown += TslDrag_MouseDown;
tslDragLeft.MouseEnter += TslDrag_MouseEnter;
tslDragRight.MouseEnter += TslDrag_MouseEnter;
tslDragLeft.MouseLeave += TslDrag_MouseLeave;
tslDragRight.MouseLeave += TslDrag_MouseLeave;
foreach (ToolStripItem tsi in tsMain.Items.OfType <ToolStripItem>())
{
if (!string.IsNullOrEmpty(tsi.Text))
{
tsi.MouseEnter += (sender, e) =>
{
Point pos = CaptureHelpers.ScreenToClient(menuForm.PointToScreen(tsi.Bounds.Location));
pos.Y += tsi.Height + 8;
MenuTextAnimation.Text = tsi.Text;
MenuTextAnimation.Position = pos;
MenuTextAnimation.Start();
};
tsi.MouseLeave += TsMain_MouseLeave;
}
}
tsMain.ResumeLayout(false);
tsMain.PerformLayout();
menuForm.ResumeLayout(false);
menuForm.Show(form);
UpdateMenu();
CurrentShapeChanged += shape => UpdateMenu();
CurrentShapeTypeChanged += shapeType => UpdateMenu();
ShapeCreated += shape => UpdateMenu();
ConfigureMenuState();
form.Activate();
}
protected override void Draw(Graphics g)
{
// Draw snap rectangles
if (ShapeManager.IsCreating && ShapeManager.IsSnapResizing)
{
BaseShape shape = ShapeManager.CurrentShape;
if (shape != null)
{
foreach (Size size in Config.SnapSizes)
{
Rectangle snapRect = CaptureHelpers.CalculateNewRectangle(shape.StartPosition, shape.EndPosition, size);
g.DrawRectangleProper(markerPen, snapRect);
}
}
}
List <BaseShape> areas = ShapeManager.ValidRegions.ToList();
if (areas.Count > 0)
{
// Create graphics path from all regions
UpdateRegionPath();
// If background is dimmed then draw non dimmed background to region selections
if (Config.UseDimming)
{
using (Region region = new Region(regionDrawPath))
{
g.Clip = region;
g.FillRectangle(lightBackgroundBrush, ScreenRectangle0Based);
g.ResetClip();
}
}
// Blink borders of all regions slightly to make non active regions to be visible in both dark and light backgrounds
using (Pen blinkBorderPen = new Pen(colorBlinkAnimation.GetColor()))
{
g.DrawPath(blinkBorderPen, regionDrawPath);
}
}
// Draw effect shapes
foreach (BaseEffectShape effectShape in ShapeManager.EffectShapes)
{
effectShape.OnDraw(g);
}
ShapeManager.OrderStepShapes();
// Draw drawing shapes
foreach (BaseDrawingShape drawingShape in ShapeManager.DrawingShapes)
{
drawingShape.OnDraw(g);
}
// Draw animated rectangle on hover area
if (ShapeManager.IsCurrentHoverAreaValid)
{
using (GraphicsPath hoverDrawPath = new GraphicsPath {
FillMode = FillMode.Winding
})
{
ShapeManager.CreateShape(ShapeManager.CurrentHoverRectangle).AddShapePath(hoverDrawPath, -1);
g.DrawPath(borderPen, hoverDrawPath);
g.DrawPath(borderDotPen, hoverDrawPath);
}
}
// Draw animated rectangle on selection area
if (ShapeManager.IsCurrentShapeTypeRegion && ShapeManager.IsCurrentRectangleValid)
{
g.DrawRectangleProper(borderPen, ShapeManager.CurrentRectangle);
g.DrawRectangleProper(borderDotPen, ShapeManager.CurrentRectangle);
if (Mode == RectangleRegionMode.Ruler)
{
DrawRuler(g, ShapeManager.CurrentRectangle, borderPen, 5, 10);
DrawRuler(g, ShapeManager.CurrentRectangle, borderPen, 15, 100);
Point centerPos = new Point(ShapeManager.CurrentRectangle.X + ShapeManager.CurrentRectangle.Width / 2, ShapeManager.CurrentRectangle.Y + ShapeManager.CurrentRectangle.Height / 2);
int markSize = 10;
g.DrawLine(borderPen, centerPos.X, centerPos.Y - markSize, centerPos.X, centerPos.Y + markSize);
g.DrawLine(borderPen, centerPos.X - markSize, centerPos.Y, centerPos.X + markSize, centerPos.Y);
}
}
// Draw all regions rectangle info
if (Config.ShowInfo)
{
// Add hover area to list so rectangle info can be shown
if (ShapeManager.IsCurrentShapeTypeRegion && ShapeManager.IsCurrentHoverAreaValid && areas.All(area => area.Rectangle != ShapeManager.CurrentHoverRectangle))
{
BaseShape shape = ShapeManager.CreateShape(ShapeManager.CurrentHoverRectangle);
areas.Add(shape);
}
foreach (BaseShape regionInfo in areas)
{
if (regionInfo.Rectangle.IsValid())
{
string areaText = GetAreaText(regionInfo.Rectangle);
DrawAreaText(g, areaText, regionInfo.Rectangle);
}
}
}
// Draw resize nodes
DrawObjects(g);
// Draw F1 tips
if (Config.ShowTips)
{
DrawTips(g);
}
if (Mode == RectangleRegionMode.Annotation)
{
if (Config.ShowMenuTip)
{
// Draw right click menu tip
DrawMenuTip(g);
}
else
{
// If current shape changed then draw it temporary
DrawCurrentShapeText(g);
}
}
// Draw magnifier
if (Config.ShowMagnifier)
{
DrawMagnifier(g);
}
// Draw screen wide crosshair
if (Config.ShowCrosshair)
{
DrawCrosshair(g);
}
}
public void ShowMenu()
{
ContextMenuStrip cms = new ContextMenuStrip()
{
Font = new Font("Arial", 10f),
AutoClose = false
};
cms.KeyUp += (sender, e) =>
{
if (e.KeyCode == Keys.Escape)
{
cms.Close();
}
};
ToolStripMenuItem tsmiContinue = new ToolStripMenuItem(Resources.QuickTaskMenu_ShowMenu_Continue);
tsmiContinue.Image = Resources.control;
tsmiContinue.Click += (sender, e) =>
{
cms.Close();
OnTaskInfoSelected(null);
};
cms.Items.Add(tsmiContinue);
cms.Items.Add(new ToolStripSeparator());
if (Program.Settings != null && Program.Settings.QuickTaskPresets != null && Program.Settings.QuickTaskPresets.Count > 0)
{
foreach (QuickTaskInfo taskInfo in Program.Settings.QuickTaskPresets)
{
if (taskInfo.IsValid)
{
ToolStripMenuItem tsmi = new ToolStripMenuItem {
Text = taskInfo.ToString().Replace("&", "&&"), Tag = taskInfo
};
tsmi.Image = FindSuitableIcon(taskInfo);
tsmi.Click += (sender, e) =>
{
QuickTaskInfo selectedTaskInfo = ((ToolStripMenuItem)sender).Tag as QuickTaskInfo;
cms.Close();
OnTaskInfoSelected(selectedTaskInfo);
};
cms.Items.Add(tsmi);
}
else
{
cms.Items.Add(new ToolStripSeparator());
}
}
cms.Items[0].Select();
cms.Items.Add(new ToolStripSeparator());
}
ToolStripMenuItem tsmiEdit = new ToolStripMenuItem(Resources.QuickTaskMenu_ShowMenu_Edit_this_menu___);
tsmiEdit.Image = Resources.pencil;
tsmiEdit.Click += (sender, e) =>
{
cms.Close();
new QuickTaskMenuEditorForm().ShowDialog();
};
cms.Items.Add(tsmiEdit);
cms.Items.Add(new ToolStripSeparator());
ToolStripMenuItem tsmiCancel = new ToolStripMenuItem(Resources.QuickTaskMenu_ShowMenu_Cancel);
tsmiCancel.Image = Resources.cross;
tsmiCancel.Click += (sender, e) => cms.Close();
cms.Items.Add(tsmiCancel);
if (ShareXResources.UseCustomTheme)
{
ShareXResources.ApplyCustomThemeToContextMenuStrip(cms);
}
Point cursorPosition = CaptureHelpers.GetCursorPosition();
cursorPosition.Offset(-10, -10);
cms.Show(cursorPosition);
cms.Focus();
}
public void Update()
{
Buttons = Control.MouseButtons;
Position = Control.MousePosition;
ZeroBasedPosition = CaptureHelpers.ScreenToClient(Position);
}
private void colorTimer_Tick(object sender, EventArgs e)
{
Point position = CaptureHelpers.GetCursorPosition();
UpdateColor(position.X, position.Y);
}
/// <summary>Captures a screenshot of a window using the Windows DWM</summary>
/// <param name="handle">handle of the window to capture</param>
/// <returns>the captured window image with or without cursor</returns>
public static Image CaptureWithDWM(Workflow wfdwm, IntPtr handle)
{
DebugHelper.WriteLine("Capturing with DWM");
Image windowImageDwm = null;
Bitmap redBGImage = null;
Rectangle windowRect = CaptureHelpers.GetWindowRectangle(handle);
if (windowRect.Width == 0)
{
System.Threading.Thread.Sleep(250);
windowRect = CaptureHelpers.GetWindowRectangle(handle); // try again
}
if (windowRect.Width > 0 && NativeMethods.IsDWMEnabled())
{
if (wfdwm.ActiveWindowDwmUseCustomBackground)
{
windowImageDwm = CaptureWindowWithDWM(handle, windowRect, out redBGImage, wfdwm.ActiveWindowDwmBackColor);
}
else if (wfdwm.ActiveWindowClearBackground)
{
windowImageDwm = CaptureWindowWithDWM(handle, windowRect, out redBGImage, Color.White);
}
}
if (windowImageDwm == null)
{
DebugHelper.WriteLine("Standard capture (no transparency)");
windowImageDwm = Screenshot.CaptureRectangleNative(windowRect);
}
Image result = RemoveCorners(handle, windowImageDwm, redBGImage, windowRect);
if (result != null)
{
windowImageDwm = result;
}
if (wfdwm.ActiveWindowIncludeShadows)
{
// Draw shadow manually to be able to have shadows in every case
windowImageDwm = HelpersLib.GraphicsHelper.Core.AddBorderShadow((Bitmap)windowImageDwm, true);
if (wfdwm.DrawCursor)
{
Point shadowOffset = HelpersLib.GraphicsHelper.Core.ShadowOffset;
#if DEBUG
DebugHelper.WriteLine("Fixed cursor position (before): " + windowRect.ToString());
#endif
windowRect.X -= shadowOffset.X;
windowRect.Y -= shadowOffset.Y;
#if DEBUG
DebugHelper.WriteLine("Fixed cursor position (after): " + windowRect.ToString());
#endif
}
}
if (wfdwm.DrawCursor)
{
CaptureHelpers.DrawCursorToImage(windowImageDwm, windowRect.Location);
}
return(windowImageDwm);
}
