/// <summary>
/// This method will capture the current Cursor by using User32 Code
/// </summary>
/// <returns>A IElement with the Mouse Cursor as Image in it.</returns>
public static bool TryGetCurrentCursor(out BitmapSource bitmapSource, out NativePoint location)
{
bitmapSource = null;
location = NativePoint.Empty;
var cursorInfo = CursorInfo.Create();
if (!NativeCursorMethods.GetCursorInfo(ref cursorInfo))
{
return(false);
}
if (cursorInfo.Flags != CursorInfoFlags.Showing)
{
return(false);
}
using (var safeIcon = NativeIconMethods.CopyIcon(cursorInfo.CursorHandle))
{
if (!NativeIconMethods.GetIconInfo(safeIcon, out var iconInfo))
{
return(false);
}
using (iconInfo.BitmaskBitmapHandle)
using (iconInfo.ColorBitmapHandle)
{
var cursorLocation = User32Api.GetCursorLocation();
bitmapSource = Imaging.CreateBitmapSourceFromHIcon(safeIcon.DangerousGetHandle(), Int32Rect.Empty, BitmapSizeOptions.FromEmptyOptions());
location = new NativePoint(cursorLocation.X - iconInfo.Hotspot.X, cursorLocation.Y - iconInfo.Hotspot.Y);
}
}
return(true);
}
/// <summary>
/// Called from Surface (the parent) if a mouse move is made while drawing
/// </summary>
/// <returns>true if the surface doesn't need to handle the event</returns>
public override bool HandleMouseMove(int mouseX, int mouseY)
{
NativePoint previousPoint = capturePoints[capturePoints.Count - 1];
if (GeometryHelper.Distance2D(previousPoint.X, previousPoint.Y, mouseX, mouseY) >= 2 * EditorConfig.FreehandSensitivity)
{
capturePoints.Add(new NativePoint(mouseX, mouseY));
}
if (GeometryHelper.Distance2D(lastMouse.X, lastMouse.Y, mouseX, mouseY) < EditorConfig.FreehandSensitivity)
{
return(true);
}
//path.AddCurve(new NativePoint[]{lastMouse, new NativePoint(mouseX, mouseY)});
lastMouse = new NativePoint(mouseX, mouseY);
lock (_freehandPathLock)
{
freehandPath.AddLine(lastMouse, new NativePoint(mouseX, mouseY));
// Only re-calculate the bounds & redraw when we added something to the path
NativeRectFloat rect = freehandPath.GetBounds();
myBounds = rect.Round();
}
Invalidate();
return(true);
}
protected override void OnMouseDown(MouseEventArgs e)
{
// ...
var wParam = HitTestOnMouseDown();
// ...
if (wParam != HitTestValues.NOWHERE)
{
// ...
NativeMethods.ReleaseCapture();
// ...
var location = new NativePoint {
X = (short)MousePosition.X, Y = (short)MousePosition.Y
};
var button = SystemInformation.MouseButtonsSwapped
? (int)WindowMessages.WM_NCRBUTTONDOWN
: (int)WindowMessages.WM_NCLBUTTONDOWN;
// ...
var lParam = (ushort)location.X | (location.Y << 16);
NativeMethods.SendMessage(Parent.Handle, button, (int)wParam, lParam);
}
// ...
base.OnMouseDown(e);
}
/// <summary>
/// Sets the specified peek (live preview) bitmap for the specified
/// window. This is typically done in response to a DWM message.
/// </summary>
/// <param name="hwnd">The window handle.</param>
/// <param name="bitmap">The thumbnail bitmap.</param>
/// <param name="offset">The client area offset at which to display
/// the specified bitmap. The rest of the parent window will be
/// displayed as "remembered" by the DWM.</param>
/// <param name="displayFrame">Whether to display a standard window
/// frame around the bitmap.</param>
internal static void SetPeekBitmap(IntPtr hwnd, IntPtr bitmap, System.Drawing.Point offset, bool displayFrame)
{
var nativePoint = new NativePoint(offset.X, offset.Y);
int rc = DwmSetIconicLivePreviewBitmap(
hwnd,
bitmap,
ref nativePoint,
displayFrame ? DisplayFrame : (uint)0);
if (rc != 0)
{
Exception e = Marshal.GetExceptionForHR(rc);
if (e is ArgumentException)
{
// Ignore argument exception as it's not really recommended to be throwing
// exception when rendering the peek bitmap. If it's some other kind of exception,
// then throw it.
}
else
{
throw e;
}
}
}
public override bool Contains(int x, int y)
{
if (base.Contains(x, y))
{
return(true);
}
var clickedPoint = new NativePoint(x, y);
if (Status != EditStatus.UNDRAWN)
{
var lineThickness = GetFieldValueAsInt(FieldTypes.LINE_THICKNESS);
var lineColor = GetFieldValueAsColor(FieldTypes.LINE_COLOR);
using (var pen = new Pen(lineColor, lineThickness))
{
using (var bubblePath = CreateBubble(lineThickness))
{
bubblePath.Widen(pen);
if (bubblePath.IsVisible(clickedPoint))
{
return(true);
}
}
using (var tailPath = CreateTail())
{
tailPath.Widen(pen);
if (tailPath.IsVisible(clickedPoint))
{
return(true);
}
}
}
}
return(false);
}
private void SetValuesOnSerializing(StreamingContext context)
{
if (TargetAdorner != null)
{
_storedTargetGripperLocation = TargetAdorner.Location;
}
}
protected virtual bool Current()
{
System.IntPtr hwnd;
if (!GetActiveWindow(out hwnd))
{
return(false);
}
NativeRect rect;
if (!GetClientRect(hwnd, out rect))
{
Debug.LogError("Failed to Get Client Rect");
return(false);
}
var point = new NativePoint()
{
x = rect.left, y = rect.top
};
if (!ClientToScreen(hwnd, ref point))
{
Debug.LogError("Failed to convert client to screen");
return(false);
}
data.x = point.x;
data.y = point.y;
data.width = rect.right - rect.left;
data.height = rect.bottom - rect.top;
return(true);
}
/// <summary>
/// Go to the previous "page"
/// </summary>
/// <returns>bool if this worked</returns>
public bool Previous()
{
var result = false;
var hasScrollInfo = TryRetrievePosition(out var scrollInfoBefore);
switch (ScrollMode)
{
case ScrollModes.KeyboardPageUpDown:
result = KeyboardInputGenerator.KeyPresses(VirtualKeyCode.Prior) == 2;
break;
case ScrollModes.WindowsMessage:
result = SendScrollMessage(ScrollBarCommands.SB_PAGEUP);
break;
case ScrollModes.AbsoluteWindowMessage:
if (!hasScrollInfo)
{
return(false);
}
// Calculate previous position, clone the scrollInfoBefore
var scrollInfoForPrevious = scrollInfoBefore;
scrollInfoForPrevious.Position = Math.Max(scrollInfoBefore.Minimum, scrollInfoBefore.Position - (int)scrollInfoBefore.PageSize);
result = ApplyPosition(ref scrollInfoForPrevious);
break;
case ScrollModes.MouseWheel:
var bounds = ScrollingWindow.GetInfo().Bounds;
var middlePoint = new NativePoint(bounds.X + bounds.Width / 2, bounds.Y + bounds.Height / 2);
result = MouseInputGenerator.MoveMouseWheel(WheelDelta, middlePoint) == 1;
break;
}
return(result);
}
/// <summary>
/// The mouse move handler of the capture form
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OnMouseMove(object sender, MouseEventArgs e)
{
var cursorLocation = User32Api.GetCursorLocation();
var relativeCursorPosition = WindowCapture.GetLocationRelativeToScreenBounds(cursorLocation);
// Make sure the mouse coordinates are fixed, e.g. when pressing shift
_mouseMovePos = FixMouseCoordinates(relativeCursorPosition);
}
internal Point(IntPtr nativePtr)
{
using (var native = new NativePoint(nativePtr))
{
this._X = native.X;
this._Y = native.Y;
}
}
/// <summary>
/// Called from Surface (the _parent) when the drawing begins (mouse-down)
/// </summary>
/// <returns>true if the surface doesn't need to handle the event</returns>
public override bool HandleMouseDown(int mouseX, int mouseY)
{
if (TargetAdorner == null)
{
_initialGripperPoint = new NativePoint(mouseX, mouseY);
InitAdorner(Color.Green, new NativePoint(mouseX, mouseY));
}
return(base.HandleMouseDown(mouseX, mouseY));
}
/// <summary>
/// Unscale the supplied NativePoint according to the supplied dpi
/// </summary>
/// <param name="size">NativePoint to unscale</param>
/// <param name="dpi">current dpi, normal is 96.</param>
/// <param name="scaleModifier">A function which can modify the scale factor</param>
/// <returns>NativePoint unscaled</returns>
public static NativePoint UnscaleWithDpi(NativePoint size, uint dpi, Func <double, double> scaleModifier = null)
{
var dpiUnscaleFactor = DpiUnscaleFactor(dpi);
if (scaleModifier != null)
{
dpiUnscaleFactor = scaleModifier(dpiUnscaleFactor);
}
return(new NativePoint((int)(dpiUnscaleFactor * size.X), (int)(dpiUnscaleFactor * size.Y)));
}
/// <summary>Creates a new instance of the Message struct</summary>
/// <param name="windowHandle">Window handle</param>
/// <param name="msg">Message</param>
/// <param name="wparam">WParam</param>
/// <param name="lparam">LParam</param>
/// <param name="time">Time</param>
/// <param name="point">Point</param>
internal Message(IntPtr windowHandle, uint msg, IntPtr wparam, IntPtr lparam, int time, NativePoint point)
: this()
{
this.windowHandle = windowHandle;
this.msg = msg;
this.wparam = wparam;
this.lparam = lparam;
this.time = time;
this.point = point;
}
/// <summary>
/// The coordinates need to be mapped from 0-65535 where 0 is left and 65535 is right
/// </summary>
/// <param name="location">NativePoint</param>
/// <returns>NativePoint</returns>
private static NativePoint RemapLocation(NativePoint location)
{
var bounds = DisplayInfo.ScreenBounds;
if (bounds.Width * bounds.Height == 0)
{
return(location);
}
return(new NativePoint(location.X * (65535 / bounds.Width), location.Y * (65535 / bounds.Height)));
}
/// <summary>
/// Creates a new instance of the Message struct
/// </summary>
/// <param name="windowHandle">Window handle</param>
/// <param name="msg">Message</param>
/// <param name="wparam">WParam</param>
/// <param name="lparam">LParam</param>
/// <param name="time">Time</param>
/// <param name="point">Point</param>
internal Message(IntPtr windowHandle, uint msg, IntPtr wparam, IntPtr lparam, int time, NativePoint point)
: this()
{
this.windowHandle = windowHandle;
this.msg = msg;
this.wparam = wparam;
this.lparam = lparam;
this.time = time;
this.point = point;
}
/// <summary>
///
/// </summary>
/// <param name="bitmap">
///
/// </param>
/// <param name="opacity">
/// Specifies an alpha transparency value to be used on the entire source
/// bitmap. The SourceConstantAlpha value is combined with any per-pixel
/// alpha values in the source bitmap. The value ranges from 0 to 255. If
/// you set SourceConstantAlpha to 0, it is assumed that your image is
/// transparent. When you only want to use per-pixel alpha values, set
/// the SourceConstantAlpha value to 255 (opaque).
/// </param>
public void SelectBitmap(Bitmap bitmap, int opacity)
{
// Does this bitmap contain an alpha channel?
if (bitmap.PixelFormat != PixelFormat.Format32bppArgb)
{
throw new ApplicationException("The bitmap must be 32bpp with alpha-channel.");
}
// Get device contexts
IntPtr screenDc = GetDC(IntPtr.Zero);
IntPtr memDc = CreateCompatibleDC(screenDc);
IntPtr hBitmap = IntPtr.Zero;
IntPtr hOldBitmap = IntPtr.Zero;
try {
// Get handle to the new bitmap and select it into the current
// device context.
hBitmap = bitmap.GetHbitmap(Color.FromArgb(0));
hOldBitmap = SelectObject(memDc, hBitmap);
// Set parameters for layered window update.
NativeSize newSize = new NativeSize(bitmap.Width, bitmap.Height);
NativePoint sourceLocation = new NativePoint(0, 0);
NativePoint newLocation = new NativePoint(this.Left, this.Top);
BLENDFUNCTION blend = new BLENDFUNCTION();
blend.BlendOp = AC_SRC_OVER;
blend.BlendFlags = 0;
blend.SourceConstantAlpha = (byte)opacity;
blend.AlphaFormat = AC_SRC_ALPHA;
// Update the window.
UpdateLayeredWindow(
this.Handle, // Handle to the layered window
screenDc, // Handle to the screen DC
ref newLocation, // New screen position of the layered window
ref newSize, // New size of the layered window
memDc, // Handle to the layered window surface DC
ref sourceLocation, // Location of the layer in the DC
0, // Color key of the layered window
ref blend, // Transparency of the layered window
ULW_ALPHA // Use blend as the blend function
);
}
finally {
// Release device context.
ReleaseDC(IntPtr.Zero, screenDc);
if (hBitmap != IntPtr.Zero)
{
SelectObject(memDc, hOldBitmap);
DeleteObject(hBitmap);
}
DeleteDC(memDc);
}
}
internal static System.Drawing.Size GetNonClientArea(IntPtr hwnd) {
var c = new NativePoint();
TabbedThumbnailNativeMethods.ClientToScreen(hwnd, ref c);
var r = new NativeRect();
TabbedThumbnailNativeMethods.GetWindowRect(hwnd, ref r);
return new System.Drawing.Size(c.X - r.Left, c.Y - r.Top);
}
public LocationPool()
{
var screenBounds = DisplayInfo.AllDisplayInfos[0].Bounds;
var pipNativeSize = new NativeSize(screenBounds.Width / 5, screenBounds.Height / 5);
for (int i = 0; i < 5; i++)
{
var pipLocation = new NativePoint(screenBounds.Width - pipNativeSize.Width, i * pipNativeSize.Height);
var currentSize = new NativeRect(pipLocation, pipNativeSize);
_availableLocations.Add(currentSize);
}
}
internal Point(IntPtr ptr, bool isEnabledDispose = true)
{
if (ptr == IntPtr.Zero)
{
throw new ArgumentException("Can not pass IntPtr.Zero", nameof(ptr));
}
using (var native = new NativePoint(ptr, isEnabledDispose))
{
this._X = native.X;
this._Y = native.Y;
}
}
/// <summary>
/// Create a MouseInput struct for a mouse move
/// </summary>
/// <param name="location">Where is the click located</param>
/// <param name="timestamp">The time stamp for the event</param>
/// <returns>MouseInput</returns>
public static MouseInput MouseMove(NativePoint location, uint timestamp = 0)
{
location = RemapLocation(location);
var bounds = DisplayInfo.GetAllScreenBounds();
return(new MouseInput
{
dx = location.X * (65535 / bounds.Width),
dy = location.Y * (65535 / bounds.Height),
Timestamp = timestamp,
MouseEventFlags = MouseMoveMouseEventFlags
});
}
/// <summary>
/// This creates the capture form
/// </summary>
/// <param name="capture">ICapture</param>
/// <param name="windows">IList of IInteropWindow</param>
public CaptureForm(ICapture capture, IList <IInteropWindow> windows)
{
if (_currentForm != null)
{
Log.Warn().WriteLine("Found currentForm, Closing already opened CaptureForm");
_currentForm.Close();
_currentForm = null;
Application.DoEvents();
}
_currentForm = this;
// Enable the AnimatingForm
EnableAnimation = true;
// clean up
FormClosed += ClosedHandler;
_capture = capture;
_windows = windows;
UsedCaptureMode = capture.CaptureDetails.CaptureMode;
//
// The InitializeComponent() call is required for Windows Forms designer support.
//
InitializeComponent();
Text = "Greenshot capture form";
// Unregister at close
FormClosing += ClosingHandler;
// set cursor location
_cursorPos = WindowCapture.GetCursorLocationRelativeToScreenBounds();
// Initialize the animations, the window capture zooms out from the cursor to the window under the cursor
if (UsedCaptureMode == CaptureMode.Window)
{
_windowAnimator = new RectangleAnimator(new NativeRect(_cursorPos, NativeSize.Empty), _captureRect, FramesForMillis(700), EasingTypes.Quintic, EasingModes.EaseOut);
}
// Set the zoomer animation
InitializeZoomer(Conf.ZoomerEnabled);
SuspendLayout();
Bounds = capture.ScreenBounds;
ResumeLayout();
// Fix missing focus
ToFront = true;
TopMost = true;
}
/// <summary>
/// Create a MouseInput struct for a mouse move
/// </summary>
/// <param name="location">Where is the click located</param>
/// <param name="timestamp">The time stamp for the event</param>
/// <returns>MouseInput</returns>
public static MouseInput MouseMove(NativePoint location, uint?timestamp = null)
{
location = RemapLocation(location);
var bounds = DisplayInfo.ScreenBounds;
var messageTime = timestamp ?? (uint)Environment.TickCount;
return(new MouseInput
{
dx = location.X * (65535 / bounds.Width),
dy = location.Y * (65535 / bounds.Height),
Timestamp = messageTime,
MouseEventFlags = MouseMoveMouseEventFlags
});
}
/// <summary>
/// Checks if the Zoom area can move there where it wants to go, change direction if not.
/// </summary>
/// <param name="pos">preferred destination location for the zoom area</param>
/// <param name="allowZoomOverCaptureRect">
/// false to try to find a location which is neither out of screen bounds nor
/// intersects with the selected rectangle
/// </param>
private void VerifyZoomAnimation(NativePoint pos, bool allowZoomOverCaptureRect)
{
var screenBounds = DisplayInfo.GetBounds(MousePosition);
// convert to be relative to top left corner of all screen bounds
screenBounds = screenBounds.MoveTo(WindowCapture.GetLocationRelativeToScreenBounds(screenBounds.Location));
var relativeZoomSize = Math.Min(screenBounds.Width, screenBounds.Height) / 5;
// Make sure the final size is a plural of 4, this makes it look better
relativeZoomSize = relativeZoomSize - relativeZoomSize % 4;
var zoomSize = new NativeSize(relativeZoomSize, relativeZoomSize);
var zoomOffset = new NativePoint(20, 20);
var targetRectangle = _zoomAnimator.Final.Offset(pos);
if (screenBounds.Contains(targetRectangle) && (allowZoomOverCaptureRect || !_captureRect.IntersectsWith(targetRectangle)))
{
return;
}
var destinationLocation = NativePoint.Empty;
var tl = new NativeRect(pos.X - (zoomOffset.X + zoomSize.Width), pos.Y - (zoomOffset.Y + zoomSize.Height), zoomSize.Width, zoomSize.Height);
var tr = new NativeRect(pos.X + zoomOffset.X, pos.Y - (zoomOffset.Y + zoomSize.Height), zoomSize.Width, zoomSize.Height);
var bl = new NativeRect(pos.X - (zoomOffset.X + zoomSize.Width), pos.Y + zoomOffset.Y, zoomSize.Width, zoomSize.Height);
var br = new NativeRect(pos.X + zoomOffset.X, pos.Y + zoomOffset.Y, zoomSize.Width, zoomSize.Height);
if (screenBounds.Contains(br) && (allowZoomOverCaptureRect || !_captureRect.IntersectsWith(br)))
{
destinationLocation = new NativePoint(zoomOffset.X, zoomOffset.Y);
}
else if (screenBounds.Contains(bl) && (allowZoomOverCaptureRect || !_captureRect.IntersectsWith(bl)))
{
destinationLocation = new NativePoint(-zoomOffset.X - zoomSize.Width, zoomOffset.Y);
}
else if (screenBounds.Contains(tr) && (allowZoomOverCaptureRect || !_captureRect.IntersectsWith(tr)))
{
destinationLocation = new NativePoint(zoomOffset.X, -zoomOffset.Y - zoomSize.Width);
}
else if (screenBounds.Contains(tl) && (allowZoomOverCaptureRect || !_captureRect.IntersectsWith(tl)))
{
destinationLocation = new NativePoint(-zoomOffset.X - zoomSize.Width, -zoomOffset.Y - zoomSize.Width);
}
if (destinationLocation == NativePoint.Empty && !allowZoomOverCaptureRect)
{
VerifyZoomAnimation(pos, true);
}
else
{
_zoomAnimator.ChangeDestination(new NativeRect(destinationLocation, zoomSize));
}
}
static public cScreen FromPoint(NativePoint p)
{
foreach (var cs in cScreen.screens)
{
if (cs != null && cs.Bounds.Width > 250)
{
if (p.X >= cs.Bounds.Left && p.X <= cs.Bounds.Right)
{
return(cs);
}
}
}
return(null);
}
internal static System.Drawing.Point GetParentOffsetOfChild(IntPtr hwnd, IntPtr hwndParent) {
var childScreenCoord = new NativePoint();
TabbedThumbnailNativeMethods.ClientToScreen(hwnd, ref childScreenCoord);
var parentScreenCoord = new NativePoint();
TabbedThumbnailNativeMethods.ClientToScreen(hwndParent, ref parentScreenCoord);
System.Drawing.Point offset = new System.Drawing.Point(
childScreenCoord.X - parentScreenCoord.X,
childScreenCoord.Y - parentScreenCoord.Y);
return offset;
}
/// <summary>
/// Implementation like <a href="https://msdn.microsoft.com/en-us/library/6d7ws9s4(v=vs.110).aspx">Screen.GetBounds</a>
/// </summary>
/// <param name="point"></param>
/// <returns></returns>
public static NativeRect GetBounds(NativePoint point)
{
DisplayInfo returnValue = null;
foreach (var display in AllDisplayInfos)
{
if (display.IsPrimary && returnValue == null)
{
returnValue = display;
}
if (display.Bounds.Contains(point))
{
returnValue = display;
}
}
return(returnValue?.Bounds ?? NativeRect.Empty);
}
/// <summary>
/// This method is called on a DrawableContainers when:
/// 1) The capture on the surface is modified in such a way, that the elements would not be placed correctly.
/// 2) Currently not implemented: an element needs to be moved, scaled or rotated.
/// This basis implementation makes sure the coordinates of the element, including the TargetGripper, is correctly
/// rotated/scaled/translated.
/// But this implementation doesn't take care of any changes to the content!!
/// </summary>
/// <param name="matrix"></param>
public virtual void Transform(Matrix matrix)
{
if (matrix == null)
{
return;
}
var topLeft = new NativePoint(Left, Top);
var bottomRight = new NativePoint(Left + Width, Top + Height);
Point[] points = { topLeft, bottomRight };
matrix.TransformPoints(points);
Left = points[0].X;
Top = points[0].Y;
Width = points[1].X - points[0].X;
Height = points[1].Y - points[0].Y;
}
/// <summary>
/// Create an animation for the zoomer, depending on if it's active or not.
/// </summary>
private void InitializeZoomer(bool isOn)
{
if (isOn)
{
var screenBounds = DisplayInfo.GetBounds(MousePosition);
var zoomerSize = CalculateZoomSize(screenBounds);
var initialPosition = new NativePoint(20, 20);
// Initialize the zoom with an initial position
_zoomAnimator = new RectangleAnimator(new NativeRect(initialPosition, NativeSize.Empty), new NativeRect(initialPosition, zoomerSize), FramesForMillis(1000), EasingTypes.Quintic, EasingModes.EaseOut);
VerifyZoomAnimation(_cursorPos, false);
}
else
{
_zoomAnimator?.ChangeDestination(new NativeRect(NativePoint.Empty, NativeSize.Empty), FramesForMillis(1000));
}
}
private DocumentContainer(IHTMLWindow2 frameWindow, IInteropWindow contentWindow, DocumentContainer parent)
{
var document2 = GetDocumentFromWindow(frameWindow);
try
{
Log.Debug().WriteLine("frameWindow.name {0}", frameWindow.name);
Name = frameWindow.name;
}
catch
{
// Ignore
}
try
{
Log.Debug().WriteLine("document2.url {0}", document2.url);
}
catch
{
// Ignore
}
try
{
Log.Debug().WriteLine("document2.title {0}", document2.title);
}
catch
{
// Ignore
}
Parent = parent;
// Calculate startLocation for the frames
var window2 = document2.parentWindow;
var window3 = (IHTMLWindow3)window2;
NativePoint contentWindowLocation = contentWindow.GetInfo().Bounds.Location;
var x = window3.screenLeft - contentWindowLocation.X;
var y = window3.screenTop - contentWindowLocation.Y;
// Release IHTMLWindow 2+3 com objects
ReleaseCom(window2);
ReleaseCom(window3);
_startLocation = new NativePoint(x, y);
Init(document2, contentWindow);
}
/// <summary>
/// This creates the capture form
/// </summary>
/// <param name="coreConfiguration">ICoreConfiguration</param>
/// <param name="capture">ICapture</param>
/// <param name="windows">IList of IInteropWindow</param>
public CaptureForm(ICoreConfiguration coreConfiguration, ICapture capture, IList <IInteropWindow> windows) : base(coreConfiguration, null)
{
_coreConfiguration = coreConfiguration;
_isZoomerTransparent = _coreConfiguration.ZoomerOpacity < 1;
ManualLanguageApply = true;
ManualStoreFields = true;
// Enable the AnimatingForm
EnableAnimation = true;
_capture = capture;
_windows = windows;
UsedCaptureMode = capture.CaptureDetails.CaptureMode;
//
// The InitializeComponent() call is required for Windows Forms designer support.
//
InitializeComponent();
Text = "Greenshot capture form";
// Log at close
if (Log.IsDebugEnabled())
{
FormClosing += (s, e) => Log.Debug().WriteLine("Closing captureform");
}
// set cursor location
_cursorPos = _mouseMovePos = WindowCapture.GetCursorLocationRelativeToScreenBounds();
// Initialize the animations, the window capture zooms out from the cursor to the window under the cursor
if (UsedCaptureMode == CaptureMode.Window)
{
_windowAnimator = new RectangleAnimator(new NativeRect(_cursorPos, NativeSize.Empty), _captureRect, FramesForMillis(700), EasingTypes.Quintic, EasingModes.EaseOut);
}
// Set the zoomer animation
InitializeZoomer(_coreConfiguration.ZoomerEnabled);
Bounds = capture.ScreenBounds;
// Fix missing focus
ToFront = true;
TopMost = true;
}
private void Test_NativePoint_TypeConverter()
{
var nativePoint = new NativePoint(123, 456);
var typeConverter = TypeDescriptor.GetConverter(typeof(NativePoint));
Assert.NotNull(typeConverter);
var stringRepresentation = typeConverter.ConvertToInvariantString(nativePoint);
Assert.Equal("123,456", stringRepresentation);
var nativePointResult = (NativePoint?)typeConverter.ConvertFromInvariantString(stringRepresentation);
Assert.True(nativePointResult.HasValue);
if (nativePointResult.HasValue)
{
Assert.Equal(nativePoint, nativePointResult.Value);
}
}
/// <summary>
/// Corrent the frame locations with the information
/// </summary>
/// <param name="frameElement"></param>
private void CorrectFrameLocations(IHTMLElement frameElement)
{
long x = 0;
long y = 0;
var element = frameElement;
IHTMLElement oldElement = null;
do
{
x += element.offsetLeft;
y += element.offsetTop;
element = element.offsetParent;
// Release element, but prevent the frameElement to be released
if (oldElement != null)
{
ReleaseCom(oldElement);
}
oldElement = element;
} while (element != null);
var elementLocation = new NativePoint((int)x, (int)y);
var element2 = (IHTMLElement2)frameElement;
var rec = element2.getBoundingClientRect();
var elementBoundingLocation = new NativePoint(rec.left, rec.top);
// Release IHTMLRect
ReleaseCom(rec);
Log.Debug().WriteLine("Looking for iframe to correct at {0}", elementBoundingLocation);
foreach (var foundFrame in Frames)
{
var frameLocation = foundFrame.SourceLocation;
if (frameLocation.Equals(elementBoundingLocation))
{
// Match found, correcting location
Log.Debug().WriteLine("Correcting frame from {0} to {1}", frameLocation, elementLocation);
foundFrame.SourceLocation = elementLocation;
foundFrame.DestinationLocation = elementLocation;
}
else
{
Log.Debug().WriteLine("{0} != {1}", frameLocation, elementBoundingLocation);
}
}
}
/// <summary>
/// Get a location where this window would be visible
/// * if none is found return false, formLocation = the original location
/// * if something is found, return true and formLocation = new location
/// </summary>
/// <param name="interopWindow">IInteropWindow, the window to find a location for</param>
/// <param name="formLocation">NativePoint with the location where the window will fit</param>
/// <returns>true if a location if found, and the formLocation is also set</returns>
public static bool GetVisibleLocation(this IInteropWindow interopWindow, out NativePoint formLocation)
{
bool doesWindowFit = false;
var windowRectangle = interopWindow.GetInfo().Bounds;
// assume own location
formLocation = windowRectangle.Location;
var primaryDisplay = DisplayInfo.AllDisplayInfos.First(x => x.IsPrimary);
using (var workingArea = new Region(primaryDisplay.Bounds))
{
// Create a region with the screens working area
foreach (var display in DisplayInfo.AllDisplayInfos)
{
if (!display.IsPrimary)
{
workingArea.Union(display.Bounds);
}
}
// If the formLocation is not inside the visible area
if (!workingArea.AreRectangleCornersVisisble(windowRectangle))
{
// If none found we find the biggest screen
foreach (var display in DisplayInfo.AllDisplayInfos)
{
var newWindowRectangle = new Rectangle(display.WorkingArea.Location, windowRectangle.Size);
if (!workingArea.AreRectangleCornersVisisble(newWindowRectangle))
{
continue;
}
formLocation = display.Bounds.Location;
doesWindowFit = true;
break;
}
}
else
{
doesWindowFit = true;
}
}
return(doesWindowFit);
}
public static extern int ScreenToClient(IntPtr hWnd, ref NativePoint pt);
public static extern int DwmSetIconicLivePreviewBitmap(
IntPtr hwnd,
IntPtr hbitmap,
ref NativePoint ptClient,
uint flags);
public static extern bool GetCursorPos(ref NativePoint point);
