public static void CaptureIe(bool captureMouse, WindowDetails windowToCapture)
{
using (CaptureHelper captureHelper = new CaptureHelper(CaptureMode.IE, captureMouse)) {
captureHelper.SelectedCaptureWindow = windowToCapture;
captureHelper.MakeCapture();
}
}
/// <summary>
/// Show the thumbnail of the supplied window above (or under) the parent Control
/// </summary>
/// <param name="window">WindowDetails</param>
/// <param name="parentControl">Control</param>
public void ShowThumbnail(WindowDetails window, Control parentControl) {
UnregisterThumbnail();
DWM.DwmRegisterThumbnail(Handle, window.Handle, out thumbnailHandle);
if (thumbnailHandle != IntPtr.Zero) {
SIZE sourceSize;
DWM.DwmQueryThumbnailSourceSize(thumbnailHandle, out sourceSize);
int thumbnailHeight = 200;
int thumbnailWidth = (int)(thumbnailHeight * ((float)sourceSize.width / (float)sourceSize.height));
if (parentControl != null && thumbnailWidth > parentControl.Width) {
thumbnailWidth = parentControl.Width;
thumbnailHeight = (int)(thumbnailWidth * ((float)sourceSize.height / (float)sourceSize.width));
}
Width = thumbnailWidth;
Height = thumbnailHeight;
// Prepare the displaying of the Thumbnail
DWM_THUMBNAIL_PROPERTIES props = new DWM_THUMBNAIL_PROPERTIES();
props.Opacity = (byte)255;
props.Visible = true;
props.SourceClientAreaOnly = false;
props.Destination = new RECT(0, 0, thumbnailWidth, thumbnailHeight);
DWM.DwmUpdateThumbnailProperties(thumbnailHandle, ref props);
if (parentControl != null) {
AlignToControl(parentControl);
}
if (!Visible) {
Show();
}
// Make sure it's on "top"!
if (parentControl != null) {
User32.SetWindowPos(Handle, parentControl.Handle, 0, 0, 0, 0, WindowPos.SWP_NOMOVE | WindowPos.SWP_NOSIZE | WindowPos.SWP_NOACTIVATE);
}
}
}
static OutlookDestination()
{
if (EmailConfigHelper.HasOutlook())
{
isActiveFlag = true;
}
exePath = PluginUtils.GetExePath("OUTLOOK.EXE");
if (exePath != null && File.Exists(exePath))
{
applicationIcon = PluginUtils.GetExeIcon(exePath, 0);
WindowDetails.AddProcessToExcludeFromFreeze("outlook");
if (conf.OutlookAllowExportInMeetings)
{
meetingIcon = PluginUtils.GetExeIcon(exePath, 2);
}
}
else
{
exePath = null;
}
if (exePath == null)
{
isActiveFlag = false;
}
}
public static void CaptureWindow(WindowDetails windowToCapture)
{
CaptureHelper captureHelper = new CaptureHelper(CaptureMode.ActiveWindow);
captureHelper.SelectedCaptureWindow = windowToCapture;
captureHelper.MakeCapture();
}
/// <summary>
/// Capture the actual page (document)
/// </summary>
/// <param name="documentContainer">The document wrapped in a container</param>
/// <returns>Bitmap with the page content as an image</returns>
private static Bitmap capturePage(DocumentContainer documentContainer, ICapture capture, Size pageSize)
{
WindowDetails contentWindowDetails = documentContainer.ContentWindow;
//Create a target bitmap to draw into with the calculated page size
Bitmap returnBitmap = new Bitmap(pageSize.Width, pageSize.Height, PixelFormat.Format24bppRgb);
using (Graphics graphicsTarget = Graphics.FromImage(returnBitmap)) {
// Clear the target with the backgroundcolor
Color clearColor = documentContainer.BackgroundColor;
LOG.DebugFormat("Clear color: {0}", clearColor);
graphicsTarget.Clear(clearColor);
// Get the base document & draw it
drawDocument(documentContainer, contentWindowDetails, graphicsTarget);
// Loop over the frames and clear their source area so we don't see any artefacts
foreach (DocumentContainer frameDocument in documentContainer.Frames)
{
using (Brush brush = new SolidBrush(clearColor)) {
graphicsTarget.FillRectangle(brush, frameDocument.SourceRectangle);
}
}
// Loop over the frames and capture their content
foreach (DocumentContainer frameDocument in documentContainer.Frames)
{
drawDocument(frameDocument, contentWindowDetails, graphicsTarget);
}
}
return(returnBitmap);
}
private DocumentContainer(IHTMLWindow2 frameWindow, WindowDetails contentWindow, DocumentContainer parent)
{
//IWebBrowser2 webBrowser2 = frame as IWebBrowser2;
//IHTMLDocument2 document2 = webBrowser2.Document as IHTMLDocument2;
IHTMLDocument2 document2 = GetDocumentFromWindow(frameWindow);
try {
LOG.DebugFormat("frameWindow.name {0}", frameWindow.name);
name = frameWindow.name;
} catch {
}
try {
LOG.DebugFormat("document2.url {0}", document2.url);
} catch {
}
try {
LOG.DebugFormat("document2.title {0}", document2.title);
} catch {
}
this.parent = parent;
// Calculate startLocation for the frames
IHTMLWindow2 window2 = document2.parentWindow;
IHTMLWindow3 window3 = (IHTMLWindow3)window2;
Point contentWindowLocation = contentWindow.WindowRectangle.Location;
int x = window3.screenLeft - contentWindowLocation.X;
int y = window3.screenTop - contentWindowLocation.Y;
// Release IHTMLWindow 2+3 com objects
releaseCom(window2);
releaseCom(window3);
startLocation = new Point(x, y);
Init(document2, contentWindow);
}
/// <summary>
/// Insert image from supplied tmp file into the give excel workbook
/// </summary>
/// <param name="workbookName"></param>
/// <param name="tmpFile"></param>
/// <param name="imageSize"></param>
public static void InsertIntoExistingWorkbook(string workbookName, string tmpFile, Size imageSize)
{
using (IExcelApplication excelApplication = GetExcelApplication()) {
if (excelApplication == null)
{
return;
}
using (IWorkbooks workbooks = excelApplication.Workbooks) {
for (int i = 1; i <= workbooks.Count; i++)
{
using (IWorkbook workbook = workbooks[i]) {
if (workbook != null && workbook.Name.StartsWith(workbookName))
{
InsertIntoExistingWorkbook(workbook, tmpFile, imageSize);
}
}
}
}
int hWnd = excelApplication.Hwnd;
if (hWnd > 0)
{
WindowDetails.ToForeground(new IntPtr(hWnd));
}
}
}
/// <summary>
/// Find the DirectUI window for MSAA (Accessible)
/// </summary>
/// <param name="browserWindowDetails">The browser WindowDetails</param>
/// <returns>WindowDetails for the DirectUI window</returns>
public static WindowDetails GetDirectUI(WindowDetails browserWindowDetails)
{
if (browserWindowDetails == null)
{
return(null);
}
WindowDetails tmpWD = browserWindowDetails;
// Since IE 9 the TabBandClass is less deep!
if (IEVersion() < 9)
{
tmpWD = tmpWD.GetChild("CommandBarClass");
if (tmpWD != null)
{
tmpWD = tmpWD.GetChild("ReBarWindow32");
}
}
if (tmpWD != null)
{
tmpWD = tmpWD.GetChild("TabBandClass");
}
if (tmpWD != null)
{
tmpWD = tmpWD.GetChild("DirectUIHWND");
}
return(tmpWD);
}
/// <summary>
/// Return an IEnumerable with the currently opened IE urls
/// </summary>
/// <returns></returns>
public static IEnumerable <string> GetIEUrls()
{
List <string> urls = new List <string>();
// Find the IE window
foreach (WindowDetails ieWindow in WindowDetails.GetAllWindows("IEFrame"))
{
WindowDetails directUIWD = GetDirectUI(ieWindow);
if (directUIWD != null)
{
Accessible ieAccessible = new Accessible(directUIWD.Handle);
List <string> ieUrls = ieAccessible.IETabUrls;
if (ieUrls != null && ieUrls.Count > 0)
{
foreach (string url in ieUrls)
{
if (!urls.Contains(url))
{
urls.Add(url);
}
}
}
}
}
return(urls);
}
/// <summary>
/// Handle the WinEvent
/// </summary>
/// <param name="hWinEventHook">The Hook IntPtr</param>
/// <param name="eventType">Event Type to handle, enum WinEvent</param>
/// <param name="hwnd">Window handle which caused the event</param>
/// <param name="idObject">Object ID, enum EventObjects</param>
/// <param name="idChild">Child ID of the window</param>
/// <param name="dwEventThread">Thread which generated the ID</param>
/// <param name="dwmsEventTime"></param>
private static void WinEventProc(IntPtr hWinEventHook, WinEvent eventType, IntPtr hwnd, EventObjects idObject, int idChild, uint dwEventThread, uint dwmsEventTime)
{
// Check if it's an event generated by a Window
if (hwnd == IntPtr.Zero || idObject != EventObjects.OBJID_WINDOW)
{
// Other events do not interest us.
return;
}
String classname = null;
// Check if the event was generated by the OLE Event Thread, which causes a lot of create/destroy
if (oleEventThread != 0 && dwEventThread == oleEventThread)
{
return;
}
// Only get the classname when it's not a destroy (classname is not available)
if (eventType == WinEvent.EVENT_OBJECT_CREATE)
{
classname = WindowDetails.GetClassName(hwnd);
// Make sure the OleMainThreadWndClass events are ignored.
if (oleEventThread == 0)
{
if (classname == "OleMainThreadWndClass")
{
oleEventThread = dwEventThread;
return;
}
}
}
LOG.DebugFormat("eventType={0},hwnd={1},classname={4},idObject={2},idChild={3},dwEventThread={5}", eventType, hwnd, idObject, idChild, classname, dwEventThread);
}
public ImageEditorForm(ISurface iSurface, bool outputMade)
{
editorList.Add(this);
//
// The InitializeComponent() call is required for Windows Forms designer support.
//
ManualLanguageApply = true;
InitializeComponent();
Shown += delegate
{
// Make sure the editor is placed on the same location as the last editor was on close
WindowDetails thisForm = new WindowDetails(Handle);
thisForm.WindowPlacement = editorConfiguration.GetEditorPlacement();
};
// init surface
Surface = iSurface;
// Intial "saved" flag for asking if the image needs to be save
surface.Modified = !outputMade;
updateUI();
// Workaround: As the cursor is (mostly) selected on the surface a funny artifact is visible, this fixes it.
//hideToolstripItems();
}
/// <summary>
/// Simple check if IE is running
/// </summary>
/// <returns>bool</returns>
public static bool IsIERunning()
{
foreach (WindowDetails shellWindow in WindowDetails.GetAllWindows("IEFrame"))
{
return(true);
}
return(false);
}
/// <summary>
/// Make sure the form is visible, if this is wanted
/// </summary>
/// <param name="e">EventArgs</param>
protected override void OnShown(EventArgs e)
{
base.OnShown(e);
if (ToFront)
{
WindowDetails.ToForeground(Handle);
}
}
/// <summary>
/// Gets a list of all IE Windows & tabs with the captions of the instances
/// </summary>
/// <returns>List<KeyValuePair<WindowDetails, string>></returns>
public static List <KeyValuePair <WindowDetails, string> > GetBrowserTabs()
{
List <IntPtr> ieHandleList = new List <IntPtr>();
Dictionary <WindowDetails, List <string> > browserWindows = new Dictionary <WindowDetails, List <string> >();
// Find the IE windows
foreach (WindowDetails ieWindow in GetIEWindows())
{
try {
if (!ieHandleList.Contains(ieWindow.Handle))
{
if ("IEFrame".Equals(ieWindow.ClassName))
{
WindowDetails directUIWD = IEHelper.GetDirectUI(ieWindow);
if (directUIWD != null)
{
Accessible accessible = new Accessible(directUIWD.Handle);
browserWindows.Add(ieWindow, accessible.IETabCaptions);
}
}
else if (configuration.WindowClassesToCheckForIE != null && configuration.WindowClassesToCheckForIE.Contains(ieWindow.ClassName))
{
List <string> singleWindowText = new List <string>();
try {
IHTMLDocument2 document2 = getHTMLDocument(ieWindow);
string title = document2.title;
Marshal.ReleaseComObject(document2);
if (string.IsNullOrEmpty(title))
{
singleWindowText.Add(ieWindow.Text);
}
else
{
singleWindowText.Add(ieWindow.Text + " - " + title);
}
} catch {
singleWindowText.Add(ieWindow.Text);
}
browserWindows.Add(ieWindow, singleWindowText);
}
ieHandleList.Add(ieWindow.Handle);
}
} catch (Exception) {
LOG.Warn("Can't get Info from " + ieWindow.ClassName);
}
}
List <KeyValuePair <WindowDetails, string> > returnList = new List <KeyValuePair <WindowDetails, string> >();
foreach (WindowDetails windowDetails in browserWindows.Keys)
{
foreach (string tab in browserWindows[windowDetails])
{
returnList.Add(new KeyValuePair <WindowDetails, string>(windowDetails, tab));
}
}
return(returnList);
}
/// <summary>
/// Does the supplied window have a IE part?
/// </summary>
/// <param name="someWindow"></param>
/// <returns></returns>
public static bool IsIEWindow(WindowDetails someWindow) {
if ("IEFrame".Equals(someWindow.ClassName)) {
return true;
}
if (configuration.WindowClassesToCheckForIE != null && configuration.WindowClassesToCheckForIE.Contains(someWindow.ClassName)) {
return someWindow.GetChild("Internet Explorer_Server") != null;
}
return false;
}
private BugReportForm()
{
//
// The InitializeComponent() call is required for Windows Forms designer support.
//
InitializeComponent();
this.Icon = GreenshotPlugin.Core.GreenshotResources.getGreenshotIcon();
WindowDetails.ToForeground(this.Handle);
}
private BugReportForm()
{
//
// The InitializeComponent() call is required for Windows Forms designer support.
//
InitializeComponent();
lang = Language.GetInstance();
UpdateUI();
WindowDetails.ToForeground(this.Handle);
}
public SpyFormHandler(IntPtr incomingHandler)
{
InstanceCounter.Instance.Increment();
_spyHandler = incomingHandler;
window = new WindowDetails(_spyHandler);
pen = new Pen(Settings.Default.DefaultColor);
InitializeComponent();
}
// Helper method to activate a certain IE Tab
public static void ActivateIETab(WindowDetails ieWindowDetails, int tabIndex)
{
WindowDetails directUIWindowDetails = IEHelper.GetDirectUI(ieWindowDetails);
// Bring window to the front
ieWindowDetails.Restore();
// Get accessible
Accessible ieAccessible = new Accessible(directUIWindowDetails.Handle);
// Activate Tab
ieAccessible.ActivateIETab(tabIndex);
}
private void FindProcessToolStripMenuItem_DropDownClosed(object sender, EventArgs e)
{
UnregisterThumbnail();
if (oldWindow != null)
{
window = new WindowDetails(oldWindow.Handle);
ShowThumbnail();
}
}
private void CaptureWithFeedback()
{
using (CaptureForm captureForm = new CaptureForm(capture, windows))
{
DialogResult result = captureForm.ShowDialog();
if (result == DialogResult.OK)
{
selectedCaptureWindow = captureForm.SelectedCaptureWindow;
captureRect = captureForm.CaptureRectangle;
// Get title
if (selectedCaptureWindow != null)
{
capture.CaptureDetails.Title = selectedCaptureWindow.Text;
}
// Experimental code
if (capture.CaptureDetails.CaptureMode == CaptureMode.Video)
{
if (captureForm.UsedCaptureMode == CaptureMode.Window)
{
screenCapture = new ScreenCaptureHelper(selectedCaptureWindow);
}
else if (captureForm.UsedCaptureMode == CaptureMode.Region)
{
screenCapture = new ScreenCaptureHelper(captureRect);
}
if (screenCapture != null)
{
screenCapture.RecordMouse = capture.CursorVisible;
if (screenCapture.Start(25))
{
return;
}
// User clicked cancel or a problem occured
screenCapture.Stop();
screenCapture = null;
return;
}
}
if (captureRect.Height > 0 && captureRect.Width > 0)
{
if (windowDetailsThread != null)
{
windowDetailsThread.Join();
}
// Take the captureRect, this already is specified as bitmap coordinates
capture.Crop(captureRect);
// save for re-capturing later and show recapture context menu option
RuntimeConfig.LastCapturedRegion = captureRect;
HandleCapture();
}
}
}
}
public static IEnumerable <string> GetBrowserUrls()
{
// FireFox
foreach (WindowDetails window in WindowDetails.GetAllWindows("MozillaWindowClass"))
{
if (window.Text.Length == 0)
{
continue;
}
AutomationElement currentElement = AutomationElement.FromHandle(window.Handle);
Condition conditionCustom = new AndCondition(new PropertyCondition(AutomationElement.ControlTypeProperty, ControlType.Custom), new PropertyCondition(AutomationElement.IsOffscreenProperty, false));
for (int i = 5; i > 0 && currentElement != null; i--)
{
currentElement = currentElement.FindFirst(TreeScope.Children, conditionCustom);
}
if (currentElement == null)
{
continue;
}
Condition conditionDocument = new AndCondition(new PropertyCondition(AutomationElement.ControlTypeProperty, ControlType.Document), new PropertyCondition(AutomationElement.IsOffscreenProperty, false));
AutomationElement docElement = currentElement.FindFirst(TreeScope.Children, conditionDocument);
if (docElement == null)
{
continue;
}
foreach (AutomationPattern pattern in docElement.GetSupportedPatterns())
{
if (pattern.ProgrammaticName != "ValuePatternIdentifiers.Pattern")
{
continue;
}
string url = (docElement.GetCurrentPattern(pattern) as ValuePattern).Current.Value.ToString();
if (!string.IsNullOrEmpty(url))
{
yield return(url);
break;
}
}
}
foreach (WindowDetails window in WindowDetails.GetAllWindows("MozillaWindowClass"))
{
if (window.Text.Length == 0)
{
continue;
}
AutomationElement currentElement = AutomationElement.FromHandle(window.Handle);
}
foreach (string url in IEHelper.GetIEUrls())
{
yield return(url);
}
}
/// <summary>
/// This creates the capture form
/// </summary>
/// <param name="capture"></param>
/// <param name="windows"></param>
public CaptureForm(ICapture capture, List <WindowDetails> windows)
{
if (_currentForm != null)
{
LOG.Debug("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;
_captureMode = capture.CaptureDetails.CaptureMode;
//
// The InitializeComponent() call is required for Windows Forms designer support.
//
InitializeComponent();
// Only double-buffer when we are not in a TerminalServerSession
DoubleBuffered = !isTerminalServerSession;
Text = "Greenshot capture form";
// Make sure we never capture the captureform
WindowDetails.RegisterIgnoreHandle(Handle);
// 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 (_captureMode == CaptureMode.Window)
{
_windowAnimator = new RectangleAnimator(new Rectangle(_cursorPos, Size.Empty), _captureRect, FramesForMillis(700), EasingType.Quintic, EasingMode.EaseOut);
}
// Set the zoomer animation
InitializeZoomer(Conf.ZoomerEnabled);
SuspendLayout();
Bounds = capture.ScreenBounds;
ResumeLayout();
// Fix missing focus
WindowDetails.ToForeground(Handle);
TopMost = true;
}
static ExcelDestination()
{
ExePath = PluginUtils.GetExePath("EXCEL.EXE");
if (ExePath != null && File.Exists(ExePath))
{
WindowDetails.AddProcessToExcludeFromFreeze("excel");
}
else
{
ExePath = null;
}
}
// Helper method to activate a certain IE Tab
public static void ActivateIETab(WindowDetails ieWindowDetails, int tabIndex)
{
WindowDetails directUIWindowDetails = GetDirectUI(ieWindowDetails);
// Bring window to the front
ieWindowDetails.Restore();
// Get accessible
Accessible ieAccessible = new Accessible(directUIWindowDetails.Handle);
// Activate Tab
ieAccessible.ActivateIETab(tabIndex);
}
static PowerpointDestination()
{
exePath = PluginUtils.GetExePath("POWERPNT.EXE");
if (exePath != null && File.Exists(exePath))
{
WindowDetails.AddProcessToExcludeFromFreeze("powerpnt");
}
else
{
exePath = null;
}
}
static OneNoteDestination()
{
exePath = PluginUtils.GetExePath("ONENOTE.EXE");
if (exePath != null && File.Exists(exePath))
{
WindowDetails.AddProcessToExcludeFromFreeze("onenote");
}
else
{
exePath = null;
}
}
/// <summary>
/// Does the supplied window have a IE part?
/// </summary>
/// <param name="someWindow"></param>
/// <returns></returns>
public static bool IsIEWindow(WindowDetails someWindow)
{
if ("IEFrame".Equals(someWindow.ClassName))
{
return(true);
}
if (configuration.WindowClassesToCheckForIE != null && configuration.WindowClassesToCheckForIE.Contains(someWindow.ClassName))
{
return(someWindow.GetChild("Internet Explorer_Server") != null);
}
return(false);
}
/// <summary>
/// Return true if the supplied window has a sub-window which covers more than the supplied percentage
/// </summary>
/// <param name="someWindow">WindowDetails to check</param>
/// <param name="minimumPercentage">min percentage</param>
/// <returns></returns>
public static bool IsMostlyIEWindow(WindowDetails someWindow, int minimumPercentage) {
WindowDetails ieWindow = someWindow.GetChild("Internet Explorer_Server");
if (ieWindow != null) {
Rectangle wholeClient = someWindow.ClientRectangle;
Rectangle partClient = ieWindow.ClientRectangle;
int percentage = (int)(100*((float)(partClient.Width * partClient.Height)) / ((float)(wholeClient.Width * wholeClient.Height)));
LOG.InfoFormat("Window {0}, ie part {1}, percentage {2}", wholeClient, partClient, percentage);
if (percentage > minimumPercentage) {
return true;
}
}
return false;
}
// The bulk of the clean-up code is implemented in Dispose(bool)
/// <summary>
/// This Dispose is called from the Dispose and the Destructor.
/// When disposing==true all non-managed resources should be freed too!
/// </summary>
/// <param name="disposing"></param>
protected virtual void Dispose(bool disposing) {
if (disposing) {
// Cleanup
}
// Unfortunately we can't dispose the capture, this might still be used somewhere else.
_windows = null;
_selectedCaptureWindow = null;
_capture = null;
// Empty working set after capturing
if (conf.MinimizeWorkingSetSize) {
PsAPI.EmptyWorkingSet();
}
}
private void ShowThumbnailOnEnter(object sender, EventArgs e)
{
ToolStripMenuItem toolStripMenuItem = sender as ToolStripMenuItem;
if (toolStripMenuItem != null)
{
window = toolStripMenuItem.Tag as WindowDetails;
handler = window.Handle;
ShowThumbnail();
}
}
static ExcelDestination()
{
exePath = PluginUtils.GetExePath("EXCEL.EXE");
if (exePath != null && File.Exists(exePath))
{
applicationIcon = PluginUtils.GetExeIcon(exePath, 0);
workbookIcon = PluginUtils.GetExeIcon(exePath, 1);
WindowDetails.AddProcessToExcludeFromFreeze("excel");
}
else
{
exePath = null;
}
}
/// <summary>
/// Helper Method for creating an Email with Image Attachment
/// </summary>
/// <param name="image">The image to send</param>
/// <param name="captureDetails">ICaptureDetails</param>
public static void SendImage(ISurface surface, ICaptureDetails captureDetails)
{
string tmpFile = ImageOutput.SaveNamedTmpFile(surface, captureDetails, new SurfaceOutputSettings());
if (tmpFile != null)
{
// Store the list of currently active windows, so we can make sure we show the email window later!
List <WindowDetails> windowsBefore = WindowDetails.GetVisibleWindows();
// Fallback to MAPI
// Send the email
SendImage(tmpFile, captureDetails);
WindowDetails.ActiveNewerWindows(windowsBefore);
}
}
void Contextmenu_window_Click(object sender, EventArgs e)
{
ToolStripMenuItem clickedItem = (ToolStripMenuItem)sender;
try
{
WindowDetails windowToCapture = (WindowDetails)clickedItem.Tag;
captureForm.MakeCapture(windowToCapture);
}
catch (Exception exception)
{
LOG.Error(exception);
}
}
/// <summary>
/// Return an IEnumerable with the currently opened IE urls
/// </summary>
/// <returns></returns>
public static IEnumerable <string> GetIEUrls()
{
// Find the IE window
foreach (WindowDetails ieWindow in WindowDetails.GetAllWindows("IEFrame"))
{
WindowDetails directUIWD = GetDirectUI(ieWindow);
if (directUIWD != null)
{
Accessible ieAccessible = new Accessible(directUIWD.Handle);
foreach (string url in ieAccessible.IETabUrls)
{
yield return(url);
}
}
}
}
public OAuthLoginForm(string browserTitle, Size size, string authorizationLink, string callbackUrl)
{
this.callbackUrl = callbackUrl;
InitializeComponent();
this.ClientSize = size;
this.Icon = GreenshotPlugin.Core.GreenshotResources.getGreenshotIcon();
this.Text = browserTitle;
this.addressTextBox.Text = authorizationLink;
// The script errors are suppressed by using the ExtendedWebBrowser
browser.ScriptErrorsSuppressed = false;
browser.DocumentCompleted += new WebBrowserDocumentCompletedEventHandler(browser_DocumentCompleted);
browser.Navigate(new Uri(authorizationLink));
WindowDetails.ToForeground(this.Handle);
}
/// <summary>
/// Find the DirectUI window for MSAA (Accessible)
/// </summary>
/// <param name="browserWindowDetails">The browser WindowDetails</param>
/// <returns>WindowDetails for the DirectUI window</returns>
public static WindowDetails GetDirectUI(WindowDetails browserWindowDetails)
{
WindowDetails tmpWD = browserWindowDetails;
// Since IE 9 the TabBandClass is less deep!
if (IEHelper.IEVersion() < 9) {
tmpWD = tmpWD.GetChild("CommandBarClass");
if (tmpWD != null) {
tmpWD = tmpWD.GetChild("ReBarWindow32");
}
}
if (tmpWD != null) {
tmpWD = tmpWD.GetChild("TabBandClass");
}
if (tmpWD != null) {
tmpWD = tmpWD.GetChild("DirectUIHWND");
}
return tmpWD;
}
private DocumentContainer(IHTMLWindow2 frameWindow, WindowDetails contentWindow, DocumentContainer parent)
{
//IWebBrowser2 webBrowser2 = frame as IWebBrowser2;
//IHTMLDocument2 document2 = webBrowser2.Document as IHTMLDocument2;
IHTMLDocument2 document2 = GetDocumentFromWindow(frameWindow);
try {
LOG.DebugFormat("frameWindow.name {0}", frameWindow.name);
} catch {
}
try {
LOG.DebugFormat("document2.url {0}",document2.url);
} catch {
}
try {
LOG.DebugFormat("document2.title {0}", document2.title);
} catch {
}
this.parent = parent;
// Calculate startLocation for the frames
IHTMLWindow3 window3 = (IHTMLWindow3)document2.parentWindow;
// IHTMLElement element = window2.document.body;
// long x = 0;
// long y = 0;
// do {
// x += element.offsetLeft;
// y += element.offsetTop;
// element = element.offsetParent;
// } while (element != null);
// startLocation = new Point((int)x, (int)y);
Point contentWindowLocation = contentWindow.ClientRectangle.Location;
int x = window3.screenLeft - contentWindowLocation.X;
int y = window3.screenTop - contentWindowLocation.Y;
startLocation = new Point(x, y);
Init(document2, contentWindow);
}
private DocumentContainer(IHTMLWindow2 frameWindow, WindowDetails contentWindow, DocumentContainer parent) {
//IWebBrowser2 webBrowser2 = frame as IWebBrowser2;
//IHTMLDocument2 document2 = webBrowser2.Document as IHTMLDocument2;
IHTMLDocument2 document2 = GetDocumentFromWindow(frameWindow);
try {
LOG.DebugFormat("frameWindow.name {0}", frameWindow.name);
name = frameWindow.name;
} catch {
}
try {
LOG.DebugFormat("document2.url {0}",document2.url);
} catch {
}
try {
LOG.DebugFormat("document2.title {0}", document2.title);
} catch {
}
this.parent = parent;
// Calculate startLocation for the frames
IHTMLWindow2 window2 = document2.parentWindow;
IHTMLWindow3 window3 = (IHTMLWindow3)window2;
Point contentWindowLocation = contentWindow.WindowRectangle.Location;
int x = window3.screenLeft - contentWindowLocation.X;
int y = window3.screenTop - contentWindowLocation.Y;
// Release IHTMLWindow 2+3 com objects
releaseCom(window2);
releaseCom(window3);
startLocation = new Point(x, y);
Init(document2, contentWindow);
}
public ImageEditorForm(Surface surface, bool outputMade)
{
//
// The InitializeComponent() call is required for Windows Forms designer support.
//
InitializeComponent();
System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(ImageEditorForm));
Image backgroundForTransparency = (Image)resources.GetObject("checkerboard.Image");
surface.TransparencyBackgroundBrush = new TextureBrush(backgroundForTransparency, WrapMode.Tile);
// Make sure Double-buffer is enabled
SetStyle(ControlStyles.DoubleBuffer | ControlStyles.AllPaintingInWmPaint | ControlStyles.UserPaint, true);
// Intial "saved" flag for asking if the image needs to be save
surface.Modified = !outputMade;
// resizing the panel is futile, since it is docked. however, it seems
// to fix the bug (?) with the vscrollbar not being able to shrink to
// a smaller size than the initial panel size (as set by the forms designer)
panel1.Height = 10;
// init surface
this.surface = surface;
surface.TabStop = false;
surface.MovingElementChanged += delegate { refreshEditorControls(); };
surface.DrawingModeChanged += new SurfaceDrawingModeEventHandler(surface_DrawingModeChanged);
surface.SurfaceSizeChanged += new SurfaceSizeChangeEventHandler(SurfaceSizeChanged);
this.fontFamilyComboBox.PropertyChanged += new PropertyChangedEventHandler(FontPropertyChanged);
surface.FieldAggregator.FieldChanged += new FieldChangedEventHandler(FieldAggregatorFieldChanged);
obfuscateModeButton.DropDownItemClicked += FilterPresetDropDownItemClicked;
highlightModeButton.DropDownItemClicked += FilterPresetDropDownItemClicked;
panel1.Controls.Add(surface);
lang = Language.GetInstance();
// Make sure the editor is placed on the same location as the last editor was on close
WindowDetails thisForm = new WindowDetails(this.Handle);
thisForm.SetWindowPlacement(editorConfiguration.GetEditorPlacement());
SurfaceSizeChanged(this.Surface);
updateUI();
IniConfig.IniChanged += new FileSystemEventHandler(ReloadConfiguration);
bindFieldControls();
refreshEditorControls();
// Workaround: As the cursor is (mostly) selected on the surface a funny artifact is visible, this fixes it.
hideToolstripItems();
toolbarButtons = new ToolStripButton[] { btnCursor, btnRect, btnEllipse, btnText, btnLine, btnArrow, btnFreehand, btnHighlight, btnObfuscate, btnCrop };
//toolbarDropDownButtons = new ToolStripDropDownButton[]{btnBlur, btnPixeliate, btnTextHighlighter, btnAreaHighlighter, btnMagnifier};
PluginHelper.instance.CreateImageEditorOpenEvent(this);
pluginToolStripMenuItem.Visible = pluginToolStripMenuItem.DropDownItems.Count > 0;
emailToolStripMenuItem.Enabled = EmailConfigHelper.HasMAPI() || EmailConfigHelper.HasOutlook();
// Workaround: for the MouseWheel event which doesn't get to the panel
this.MouseWheel += new MouseEventHandler(PanelMouseWheel);
}
/// <summary>
/// Helper method which will retrieve the IHTMLDocument2 for the supplied window,
/// or return the first if none is supplied.
/// </summary>
/// <param name="browserWindowDetails">The WindowDetails to get the IHTMLDocument2 for</param>
/// <param name="document2">Ref to the IHTMLDocument2 to return</param>
/// <returns>The WindowDetails to which the IHTMLDocument2 belongs</returns>
private static DocumentContainer GetDocument(WindowDetails activeWindow)
{
DocumentContainer returnDocumentContainer = null;
WindowDetails returnWindow = null;
IHTMLDocument2 returnDocument2 = null;
// alternative if no match
WindowDetails alternativeReturnWindow = null;
IHTMLDocument2 alternativeReturnDocument2 = null;
// Find the IE window
foreach (WindowDetails ieWindow in WindowDetails.GetAllWindows("IEFrame")) {
LOG.DebugFormat("Processing {0} - {1}", ieWindow.ClassName, ieWindow.Text);
Accessible ieAccessible = null;
WindowDetails directUIWD = IEHelper.GetDirectUI(ieWindow);
if (directUIWD != null) {
ieAccessible = new Accessible(directUIWD.Handle);
}
if (ieAccessible == null) {
LOG.InfoFormat("Active Window is {0}", activeWindow.Text);
if (!ieWindow.Equals(activeWindow)) {
LOG.WarnFormat("No ieAccessible for {0}", ieWindow.Text);
continue;
}
LOG.DebugFormat("No ieAccessible, but the active window is an IE window: {0}, ", ieWindow.Text);
}
try {
// Get the Document
IHTMLDocument2 document2 = null;
uint windowMessage = User32.RegisterWindowMessage("WM_HTML_GETOBJECT");
if (windowMessage == 0) {
LOG.WarnFormat("Couldn't register WM_HTML_GETOBJECT");
continue;
}
WindowDetails ieServer= ieWindow.GetChild("Internet Explorer_Server");
if (ieServer == null) {
LOG.WarnFormat("No Internet Explorer_Server for {0}", ieWindow.Text);
continue;
}
LOG.DebugFormat("Trying WM_HTML_GETOBJECT on {0}", ieServer.ClassName);
UIntPtr response;
User32.SendMessageTimeout(ieServer.Handle, windowMessage, IntPtr.Zero, IntPtr.Zero, SendMessageTimeoutFlags.SMTO_NORMAL, 1000, out response);
if (response != UIntPtr.Zero) {
document2 = (IHTMLDocument2)Accessible.ObjectFromLresult(response, typeof(IHTMLDocument).GUID, IntPtr.Zero);
if (document2 == null) {
LOG.Error("No IHTMLDocument2 found");
continue;
}
} else {
LOG.Error("No answer on WM_HTML_GETOBJECT.");
continue;
}
// Get the content window handle for the shellWindow.Document
IOleWindow oleWindow = (IOleWindow)document2;
IntPtr contentWindowHandle = IntPtr.Zero;
if (oleWindow != null) {
oleWindow.GetWindow(out contentWindowHandle);
}
if (contentWindowHandle != IntPtr.Zero) {
// Get the HTMLDocument to check the hasFocus
// See: http://social.msdn.microsoft.com/Forums/en-US/vbgeneral/thread/60c6c95d-377c-4bf4-860d-390840fce31c/
IHTMLDocument4 document4 = (IHTMLDocument4)document2;
if (document4.hasFocus()) {
LOG.DebugFormat("Matched focused document: {0}", document2.title);
// Look no further, we got what we wanted!
returnDocument2 = document2;
returnWindow = new WindowDetails(contentWindowHandle);
break;
}
try {
if (ieWindow.Equals(activeWindow)) {
returnDocument2 = document2;
returnWindow = new WindowDetails(contentWindowHandle);
break;
} else if (ieAccessible != null && returnWindow == null && document2.title.Equals(ieAccessible.IEActiveTabCaption) ) {
LOG.DebugFormat("Title: {0}", document2.title);
returnDocument2 = document2;
returnWindow = new WindowDetails(contentWindowHandle);
} else {
alternativeReturnDocument2 = document2;
alternativeReturnWindow = new WindowDetails(contentWindowHandle);
}
} catch (Exception) {
alternativeReturnDocument2 = document2;
alternativeReturnWindow = new WindowDetails(contentWindowHandle);
}
}
} catch (Exception e) {
LOG.Error(e);
LOG.DebugFormat("Major problem: Problem retrieving Document from {0}", ieWindow.Text);
}
}
// check if we have something to return
if (returnWindow != null) {
// As it doesn't have focus, make sure it's active
returnWindow.Restore();
returnWindow.GetParent();
// Create the container
returnDocumentContainer = new DocumentContainer(returnDocument2, returnWindow);
}
if (returnDocumentContainer == null && alternativeReturnDocument2 != null) {
// As it doesn't have focus, make sure it's active
alternativeReturnWindow.Restore();
alternativeReturnWindow.GetParent();
// Create the container
returnDocumentContainer = new DocumentContainer(alternativeReturnDocument2, alternativeReturnWindow);
}
return returnDocumentContainer;
}
/// <summary>
/// Private helper method for the constructors
/// </summary>
/// <param name="document2">IHTMLDocument2</param>
/// <param name="contentWindow">WindowDetails</param>
private void Init(IHTMLDocument2 document2, WindowDetails contentWindow)
{
this.document2 = document2;
this.contentWindow = contentWindow;
this.document3 = document2 as IHTMLDocument3;
// Check what access method is needed for the document
IHTMLDocument5 document5 = (IHTMLDocument5)document2;
//compatibility mode affects how height is computed
if ((document3.documentElement != null) && (!document5.compatMode.Equals("BackCompat"))) {
isDTD = true;
} else {
isDTD = false;
}
Rectangle clientRectangle = contentWindow.WindowRectangle;
try {
IHTMLWindow3 window3 = (IHTMLWindow3)document2.parentWindow;
IHTMLWindow2 window2 = (IHTMLWindow2)document2.parentWindow;
IHTMLScreen2 screen2 = (IHTMLScreen2)window2.screen;
IHTMLScreen screen = window2.screen;
if (parent != null) {
// Copy parent values
zoomLevelX = parent.zoomLevelX;
zoomLevelY = parent.zoomLevelY;
viewportRectangle = parent.viewportRectangle;
} else {
//DisableScrollbars(document2);
// Calculate zoom level
zoomLevelX = (double)screen2.deviceXDPI/(double)screen2.logicalXDPI;
zoomLevelY = (double)screen2.deviceYDPI/(double)screen2.logicalYDPI;
// Calculate the viewport rectangle, needed if there is a frame around the html window
LOG.DebugFormat("Screen {0}x{1}", ScaleX(screen.width), ScaleY(screen.height));
LOG.DebugFormat("Screen location {0},{1}", window3.screenLeft, window3.screenTop);
LOG.DebugFormat("Window rectangle {0}", clientRectangle);
LOG.DebugFormat("Client size {0}x{1}", ClientWidth, ClientHeight);
int diffX = clientRectangle.Width - ClientWidth;
int diffY = clientRectangle.Height - ClientHeight;
// If there is a border around the inner window, the diff == 4
// If there is a border AND a scrollbar the diff == 20
if ((diffX == 4 || diffX >= 20) && (diffY == 4 || diffY >= 20)) {
Point viewportOffset = new Point(2, 2);
Size viewportSize = new Size(ClientWidth, ClientHeight);
viewportRectangle = new Rectangle(viewportOffset, viewportSize);
LOG.DebugFormat("viewportRect {0}", viewportRectangle);
}
}
LOG.DebugFormat("Zoomlevel {0}, {1}", zoomLevelX, zoomLevelY);
} catch (Exception e) {
LOG.Warn("Can't get certain properties for documents, using default. due to: ", e);
}
LOG.DebugFormat("Calculated location {0} for {1}", startLocation, document2.title);
sourceLocation = new Point(ScaleX((int)startLocation.X), ScaleY((int)startLocation.Y));
destinationLocation = new Point(ScaleX((int)startLocation.X), ScaleY((int)startLocation.Y));
try {
if (name == null) {
name = document2.title;
}
} catch {
}
try {
url = document2.url;
} catch {
}
if (parent != null) {
return;
}
IHTMLFramesCollection2 frameCollection = (IHTMLFramesCollection2)document2.frames;
for(int frame = 0; frame < frameCollection.length; frame++) {
IHTMLWindow2 frameWindow = frameCollection.item(frame);
try {
DocumentContainer frameData = new DocumentContainer(frameWindow, contentWindow, this);
// check if frame is hidden
if (!frameData.isHidden) {
LOG.DebugFormat("Creating DocumentContainer for Frame {0} found in window with rectangle {1}", frameData.name, frameData.SourceRectangle);
frames.Add(frameData);
} else {
LOG.DebugFormat("Skipping frame {0}", frameData.Name);
}
} catch (Exception e) {
LOG.Warn("Problem while trying to get information from a frame, skipping the frame!", e);
}
}
// Correct iframe locations
foreach (IHTMLElement frameElement in document3.getElementsByTagName("IFRAME")){
try {
CorrectFrameLocations(frameElement);
} catch (Exception e) {
LOG.Warn("Problem while trying to get information from an iframe, skipping the frame!", e);
}
}
}
public DocumentContainer(IHTMLDocument2 document2, WindowDetails contentWindow)
{
Init(document2, contentWindow);
LOG.DebugFormat("Creating DocumentContainer for Document {0} found in window with rectangle {1}", name, SourceRectangle);
}
public ImageEditorForm(ISurface iSurface, bool outputMade)
{
EditorList.Add(this);
InitializeComponent();
if (EditorConfiguration.MatchSizeToCapture)
{
RECT lastPosition = EditorConfiguration.GetEditorPlacement().NormalPosition;
this.StartPosition = FormStartPosition.Manual;
this.Location = new Point(lastPosition.Left, lastPosition.Top);
}
else
{
Load += delegate
{
//Make sure the editor is placed on the same location as the last editor was on close
WindowDetails thisForm = new WindowDetails(Handle)
{
WindowPlacement = EditorConfiguration.GetEditorPlacement()
};
};
}
// init surface
Surface = iSurface;
// Intial "saved" flag for asking if the image needs to be save
_surface.Modified = !outputMade;
UpdateUi();
// Workaround: As the cursor is (mostly) selected on the surface a funny artifact is visible, this fixes it.
//HideToolstripItems();
}
private void CaptureWithFeedback()
{
// The following, to be precise the HideApp, causes the app to close as described in BUG-1620
// Added check for metro (Modern UI) apps, which might be maximized and cover the screen.
//foreach(WindowDetails app in WindowDetails.GetMetroApps()) {
// if (app.Maximised) {
// app.HideApp();
// }
//}
using (CaptureForm captureForm = new CaptureForm(_capture, _windows)) {
DialogResult result = captureForm.ShowDialog();
if (result == DialogResult.OK) {
_selectedCaptureWindow = captureForm.SelectedCaptureWindow;
_captureRect = captureForm.CaptureRectangle;
// Get title
if (_selectedCaptureWindow != null) {
_capture.CaptureDetails.Title = _selectedCaptureWindow.Text;
}
if (_captureRect.Height > 0 && _captureRect.Width > 0) {
// Take the captureRect, this already is specified as bitmap coordinates
_capture.Crop(_captureRect);
// save for re-capturing later and show recapture context menu option
// Important here is that the location needs to be offsetted back to screen coordinates!
Rectangle tmpRectangle = _captureRect;
tmpRectangle.Offset(_capture.ScreenBounds.Location.X, _capture.ScreenBounds.Location.Y);
conf.LastCapturedRegion = tmpRectangle;
HandleCapture();
}
}
}
}
public static void CaptureWindow(WindowDetails windowToCapture)
{
using (CaptureHelper captureHelper = new CaptureHelper(CaptureMode.ActiveWindow)) {
captureHelper.SelectedCaptureWindow = windowToCapture;
captureHelper.MakeCapture();
}
}
void CaptureFormKeyDown(object sender, KeyEventArgs e)
{
// Check fixmode
if (e.KeyCode == Keys.ShiftKey) {
if (fixMode == FixMode.None) {
fixMode = FixMode.Initiated;
return;
}
}
if (e.KeyCode == Keys.Escape) {
DialogResult = DialogResult.Cancel;
} else if (e.KeyCode == Keys.M) {
// Toggle mouse cursor
capture.CursorVisible = !capture.CursorVisible;
pictureBox.Invalidate();
} else if (e.KeyCode == Keys.V && conf.isExperimentalFeatureEnabled("Video")) {
capture.CaptureDetails.CaptureMode = CaptureMode.Video;
pictureBox.Invalidate();
} else if (e.KeyCode == Keys.Space) {
switch (captureMode) {
case CaptureMode.Region:
captureMode = CaptureMode.Window;
break;
case CaptureMode.Window:
captureMode = CaptureMode.Region;
break;
}
pictureBox.Invalidate();
selectedCaptureWindow = null;
PictureBoxMouseMove(this, new MouseEventArgs(MouseButtons.None, 0, Cursor.Position.X, Cursor.Position.Y, 0));
} else if (e.KeyCode == Keys.Return && captureMode == CaptureMode.Window) {
DialogResult = DialogResult.OK;
}
}
/// <summary>
/// Handle the key down event
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
void CaptureFormKeyDown(object sender, KeyEventArgs e) {
int step = _isCtrlPressed ? 10 : 1;
switch (e.KeyCode) {
case Keys.Up:
Cursor.Position = new Point(Cursor.Position.X, Cursor.Position.Y - step);
break;
case Keys.Down:
Cursor.Position = new Point(Cursor.Position.X, Cursor.Position.Y + step);
break;
case Keys.Left:
Cursor.Position = new Point(Cursor.Position.X - step, Cursor.Position.Y);
break;
case Keys.Right:
Cursor.Position = new Point(Cursor.Position.X + step, Cursor.Position.Y);
break;
case Keys.ShiftKey:
// Fixmode
if (_fixMode == FixMode.None) {
_fixMode = FixMode.Initiated;
}
break;
case Keys.ControlKey:
_isCtrlPressed = true;
break;
case Keys.Escape:
// Cancel
DialogResult = DialogResult.Cancel;
break;
case Keys.M:
// Toggle mouse cursor
_capture.CursorVisible = !_capture.CursorVisible;
Invalidate();
break;
//// TODO: Enable when the screen capture code works reliable
//case Keys.V:
// // Video
// if (capture.CaptureDetails.CaptureMode != CaptureMode.Video) {
// capture.CaptureDetails.CaptureMode = CaptureMode.Video;
// } else {
// capture.CaptureDetails.CaptureMode = captureMode;
// }
// Invalidate();
// break;
case Keys.Z:
if (_captureMode == CaptureMode.Region) {
// Toggle zoom
Conf.ZoomerEnabled = !Conf.ZoomerEnabled;
InitializeZoomer(Conf.ZoomerEnabled);
Invalidate();
}
break;
case Keys.Space:
// Toggle capture mode
switch (_captureMode) {
case CaptureMode.Region:
// Set the window capture mode
_captureMode = CaptureMode.Window;
// "Fade out" Zoom
InitializeZoomer(false);
// "Fade in" window
_windowAnimator = new RectangleAnimator(new Rectangle(_cursorPos, Size.Empty), _captureRect, FramesForMillis(700), EasingType.Quintic, EasingMode.EaseOut);
_captureRect = Rectangle.Empty;
Invalidate();
break;
case CaptureMode.Window:
// Set the region capture mode
_captureMode = CaptureMode.Region;
// "Fade out" window
_windowAnimator.ChangeDestination(new Rectangle(_cursorPos, Size.Empty), FramesForMillis(700));
// Fade in zoom
InitializeZoomer(Conf.ZoomerEnabled);
_captureRect = Rectangle.Empty;
Invalidate();
break;
}
_selectedCaptureWindow = null;
OnMouseMove(this, new MouseEventArgs(MouseButtons.None, 0, Cursor.Position.X, Cursor.Position.Y, 0));
break;
case Keys.Return:
// Confirm
if (_captureMode == CaptureMode.Window) {
DialogResult = DialogResult.OK;
} else if (!_mouseDown) {
HandleMouseDown();
} else if (_mouseDown) {
HandleMouseUp();
}
break;
}
}
/// <summary>
/// update the frame, this only invalidates
/// </summary>
protected override void Animate() {
Point lastPos = _cursorPos;
_cursorPos = _mouseMovePos;
if (_selectedCaptureWindow != null && lastPos.Equals(_cursorPos) && !isAnimating(_zoomAnimator) && !isAnimating(_windowAnimator)) {
return;
}
WindowDetails lastWindow = _selectedCaptureWindow;
bool horizontalMove = false;
bool verticalMove = false;
if (lastPos.X != _cursorPos.X) {
horizontalMove = true;
}
if (lastPos.Y != _cursorPos.Y) {
verticalMove = true;
}
if (_captureMode == CaptureMode.Region && _mouseDown) {
_captureRect = GuiRectangle.GetGuiRectangle(_cursorPos.X, _cursorPos.Y, _mX - _cursorPos.X, _mY - _cursorPos.Y);
}
// Iterate over the found windows and check if the current location is inside a window
Point cursorPosition = Cursor.Position;
_selectedCaptureWindow = null;
lock (_windows) {
foreach (WindowDetails window in _windows) {
if (window.Contains(cursorPosition)) {
// Only go over the children if we are in window mode
if (CaptureMode.Window == _captureMode) {
_selectedCaptureWindow = window.FindChildUnderPoint(cursorPosition);
} else {
_selectedCaptureWindow = window;
}
break;
}
}
}
if (_selectedCaptureWindow != null && !_selectedCaptureWindow.Equals(lastWindow)) {
_capture.CaptureDetails.Title = _selectedCaptureWindow.Text;
_capture.CaptureDetails.AddMetaData("windowtitle", _selectedCaptureWindow.Text);
if (_captureMode == CaptureMode.Window) {
// Here we want to capture the window which is under the mouse
_captureRect = _selectedCaptureWindow.WindowRectangle;
// As the ClientRectangle is not in Bitmap coordinates, we need to correct.
_captureRect.Offset(-_capture.ScreenBounds.Location.X, -_capture.ScreenBounds.Location.Y);
}
}
Rectangle invalidateRectangle;
if (_mouseDown && (_captureMode != CaptureMode.Window)) {
int x1 = Math.Min(_mX, lastPos.X);
int x2 = Math.Max(_mX, lastPos.X);
int y1 = Math.Min(_mY, lastPos.Y);
int y2 = Math.Max(_mY, lastPos.Y);
x1= Math.Min(x1, _cursorPos.X);
x2= Math.Max(x2, _cursorPos.X);
y1= Math.Min(y1, _cursorPos.Y);
y2= Math.Max(y2, _cursorPos.Y);
// Safety correction
x2 += 2;
y2 += 2;
// Here we correct for text-size
// Calculate the size
int textForWidth = Math.Max(Math.Abs(_mX - _cursorPos.X), Math.Abs(_mX - lastPos.X));
int textForHeight = Math.Max(Math.Abs(_mY - _cursorPos.Y), Math.Abs(_mY - lastPos.Y));
using (Font rulerFont = new Font(FontFamily.GenericSansSerif, 8)) {
Size measureWidth = TextRenderer.MeasureText(textForWidth.ToString(CultureInfo.InvariantCulture), rulerFont);
x1 -= measureWidth.Width + 15;
Size measureHeight = TextRenderer.MeasureText(textForHeight.ToString(CultureInfo.InvariantCulture), rulerFont);
y1 -= measureHeight.Height + 10;
}
invalidateRectangle = new Rectangle(x1,y1, x2-x1, y2-y1);
Invalidate(invalidateRectangle);
} else if (_captureMode != CaptureMode.Window) {
if (!isTerminalServerSession) {
Rectangle allScreenBounds = WindowCapture.GetScreenBounds();
allScreenBounds.Location = WindowCapture.GetLocationRelativeToScreenBounds(allScreenBounds.Location);
if (verticalMove) {
// Before
invalidateRectangle = GuiRectangle.GetGuiRectangle(allScreenBounds.Left, lastPos.Y - 2, Width + 2, 45);
Invalidate(invalidateRectangle);
// After
invalidateRectangle = GuiRectangle.GetGuiRectangle(allScreenBounds.Left, _cursorPos.Y - 2, Width + 2, 45);
Invalidate(invalidateRectangle);
}
if (horizontalMove) {
// Before
invalidateRectangle = GuiRectangle.GetGuiRectangle(lastPos.X - 2, allScreenBounds.Top, 75, Height + 2);
Invalidate(invalidateRectangle);
// After
invalidateRectangle = GuiRectangle.GetGuiRectangle(_cursorPos.X - 2, allScreenBounds.Top, 75, Height + 2);
Invalidate(invalidateRectangle);
}
}
} else {
if (_selectedCaptureWindow != null && !_selectedCaptureWindow.Equals(lastWindow)) {
// Window changes, make new animation from current to target
_windowAnimator.ChangeDestination(_captureRect, FramesForMillis(700));
}
}
// always animate the Window area through to the last frame, so we see the fade-in/out untill the end
// Using a safety "offset" to make sure the text is invalidated too
const int safetySize = 30;
// Check if the
if (isAnimating(_windowAnimator)) {
invalidateRectangle = _windowAnimator.Current;
invalidateRectangle.Inflate(safetySize, safetySize);
Invalidate(invalidateRectangle);
invalidateRectangle = _windowAnimator.Next();
invalidateRectangle.Inflate(safetySize, safetySize);
Invalidate(invalidateRectangle);
// Check if this was the last of the windows animations in the normal region capture.
if (_captureMode != CaptureMode.Window && !isAnimating(_windowAnimator)) {
Invalidate();
}
}
if (_zoomAnimator != null && (isAnimating(_zoomAnimator) || _captureMode != CaptureMode.Window)) {
// Make sure we invalidate the old zoom area
invalidateRectangle = _zoomAnimator.Current;
invalidateRectangle.Offset(lastPos);
Invalidate(invalidateRectangle);
// Only verify if we are really showing the zoom, not the outgoing animation
if (Conf.ZoomerEnabled && _captureMode != CaptureMode.Window) {
VerifyZoomAnimation(_cursorPos, false);
}
// The following logic is not needed, next always returns the current if there are no frames left
// but it makes more sense if we want to change something in the logic
if (isAnimating(_zoomAnimator)) {
invalidateRectangle = _zoomAnimator.Next();
} else {
invalidateRectangle = _zoomAnimator.Current;
}
invalidateRectangle.Offset(_cursorPos);
Invalidate(invalidateRectangle);
}
// Force update "now"
Update();
}
public ScreenCaptureHelper(WindowDetails recordingWindow)
{
this.recordingWindow = recordingWindow;
}
/// <summary>
/// Capture the supplied Window
/// </summary>
/// <param name="windowToCapture">Window to capture</param>
/// <param name="captureForWindow">The capture to store the details</param>
/// <param name="windowCaptureMode">What WindowCaptureMode to use</param>
/// <returns></returns>
public static ICapture CaptureWindow(WindowDetails windowToCapture, ICapture captureForWindow, WindowCaptureMode windowCaptureMode)
{
if (captureForWindow == null) {
captureForWindow = new Capture();
}
Rectangle windowRectangle = windowToCapture.WindowRectangle;
// When Vista & DWM (Aero) enabled
bool dwmEnabled = DWM.isDWMEnabled();
// get process name to be able to exclude certain processes from certain capture modes
using (Process process = windowToCapture.Process) {
bool isAutoMode = windowCaptureMode == WindowCaptureMode.Auto;
// For WindowCaptureMode.Auto we check:
// 1) Is window IE, use IE Capture
// 2) Is Windows >= Vista & DWM enabled: use DWM
// 3) Otherwise use GDI (Screen might be also okay but might lose content)
if (isAutoMode) {
if (conf.IECapture && IECaptureHelper.IsIEWindow(windowToCapture)) {
try {
ICapture ieCapture = IECaptureHelper.CaptureIE(captureForWindow, windowToCapture);
if (ieCapture != null) {
return ieCapture;
}
} catch (Exception ex) {
LOG.WarnFormat("Problem capturing IE, skipping to normal capture. Exception message was: {0}", ex.Message);
}
}
// Take default screen
windowCaptureMode = WindowCaptureMode.Screen;
// Change to GDI, if allowed
if (!windowToCapture.isMetroApp && WindowCapture.IsGdiAllowed(process)) {
if (!dwmEnabled && isWPF(process)) {
// do not use GDI, as DWM is not enabled and the application uses PresentationFramework.dll -> isWPF
LOG.InfoFormat("Not using GDI for windows of process {0}, as the process uses WPF", process.ProcessName);
} else {
windowCaptureMode = WindowCaptureMode.GDI;
}
}
// Change to DWM, if enabled and allowed
if (dwmEnabled) {
if (windowToCapture.isMetroApp || WindowCapture.IsDwmAllowed(process)) {
windowCaptureMode = WindowCaptureMode.Aero;
}
}
} else if (windowCaptureMode == WindowCaptureMode.Aero || windowCaptureMode == WindowCaptureMode.AeroTransparent) {
if (!dwmEnabled || (!windowToCapture.isMetroApp && !WindowCapture.IsDwmAllowed(process))) {
// Take default screen
windowCaptureMode = WindowCaptureMode.Screen;
// Change to GDI, if allowed
if (WindowCapture.IsGdiAllowed(process)) {
windowCaptureMode = WindowCaptureMode.GDI;
}
}
} else if (windowCaptureMode == WindowCaptureMode.GDI && !WindowCapture.IsGdiAllowed(process)) {
// GDI not allowed, take screen
windowCaptureMode = WindowCaptureMode.Screen;
}
LOG.InfoFormat("Capturing window with mode {0}", windowCaptureMode);
bool captureTaken = false;
windowRectangle.Intersect(captureForWindow.ScreenBounds);
// Try to capture
while (!captureTaken) {
ICapture tmpCapture = null;
switch (windowCaptureMode) {
case WindowCaptureMode.GDI:
if (WindowCapture.IsGdiAllowed(process)) {
if (windowToCapture.Iconic) {
// Restore the window making sure it's visible!
windowToCapture.Restore();
} else {
windowToCapture.ToForeground();
}
tmpCapture = windowToCapture.CaptureGDIWindow(captureForWindow);
if (tmpCapture != null) {
// check if GDI capture any good, by comparing it with the screen content
int blackCountGDI = ImageHelper.CountColor(tmpCapture.Image, Color.Black, false);
int GDIPixels = tmpCapture.Image.Width * tmpCapture.Image.Height;
int blackPercentageGDI = (blackCountGDI * 100) / GDIPixels;
if (blackPercentageGDI >= 1) {
int screenPixels = windowRectangle.Width * windowRectangle.Height;
using (ICapture screenCapture = new Capture()) {
screenCapture.CaptureDetails = captureForWindow.CaptureDetails;
if (WindowCapture.CaptureRectangleFromDesktopScreen(screenCapture, windowRectangle) != null) {
int blackCountScreen = ImageHelper.CountColor(screenCapture.Image, Color.Black, false);
int blackPercentageScreen = (blackCountScreen * 100) / screenPixels;
if (screenPixels == GDIPixels) {
// "easy compare", both have the same size
// If GDI has more black, use the screen capture.
if (blackPercentageGDI > blackPercentageScreen) {
LOG.Debug("Using screen capture, as GDI had additional black.");
// changeing the image will automatically dispose the previous
tmpCapture.Image = screenCapture.Image;
// Make sure it's not disposed, else the picture is gone!
screenCapture.NullImage();
}
} else if (screenPixels < GDIPixels) {
// Screen capture is cropped, window is outside of screen
if (blackPercentageGDI > 50 && blackPercentageGDI > blackPercentageScreen) {
LOG.Debug("Using screen capture, as GDI had additional black.");
// changeing the image will automatically dispose the previous
tmpCapture.Image = screenCapture.Image;
// Make sure it's not disposed, else the picture is gone!
screenCapture.NullImage();
}
} else {
// Use the GDI capture by doing nothing
LOG.Debug("This should not happen, how can there be more screen as GDI pixels?");
}
}
}
}
}
}
if (tmpCapture != null) {
captureForWindow = tmpCapture;
captureTaken = true;
} else {
// A problem, try Screen
windowCaptureMode = WindowCaptureMode.Screen;
}
break;
case WindowCaptureMode.Aero:
case WindowCaptureMode.AeroTransparent:
if (windowToCapture.isMetroApp || WindowCapture.IsDwmAllowed(process)) {
tmpCapture = windowToCapture.CaptureDWMWindow(captureForWindow, windowCaptureMode, isAutoMode);
}
if (tmpCapture != null) {
captureForWindow = tmpCapture;
captureTaken = true;
} else {
// A problem, try GDI
windowCaptureMode = WindowCaptureMode.GDI;
}
break;
default:
// Screen capture
if (windowToCapture.Iconic) {
// Restore the window making sure it's visible!
windowToCapture.Restore();
} else {
windowToCapture.ToForeground();
}
try {
captureForWindow = WindowCapture.CaptureRectangleFromDesktopScreen(captureForWindow, windowRectangle);
captureTaken = true;
} catch (Exception e) {
LOG.Error("Problem capturing", e);
return null;
}
break;
}
}
}
if (captureForWindow != null) {
if (windowToCapture != null) {
captureForWindow.CaptureDetails.Title = windowToCapture.Text;
}
}
return captureForWindow;
}
/// <summary>
/// Make Capture with specified destinations
/// </summary>
private void MakeCapture()
{
Thread retrieveWindowDetailsThread = null;
// This fixes a problem when a balloon is still visible and a capture needs to be taken
// forcefully removes the balloon!
if (!conf.HideTrayicon) {
MainForm.Instance.NotifyIcon.Visible = false;
MainForm.Instance.NotifyIcon.Visible = true;
}
LOG.Debug(String.Format("Capturing with mode {0} and using Cursor {1}", _captureMode, _captureMouseCursor));
_capture.CaptureDetails.CaptureMode = _captureMode;
// Get the windows details in a seperate thread, only for those captures that have a Feedback
// As currently the "elements" aren't used, we don't need them yet
switch (_captureMode) {
case CaptureMode.Region:
// Check if a region is pre-supplied!
if (Rectangle.Empty.Equals(_captureRect)) {
retrieveWindowDetailsThread = PrepareForCaptureWithFeedback();
}
break;
case CaptureMode.Window:
retrieveWindowDetailsThread = PrepareForCaptureWithFeedback();
break;
}
// Add destinations if no-one passed a handler
if (_capture.CaptureDetails.CaptureDestinations == null || _capture.CaptureDetails.CaptureDestinations.Count == 0) {
AddConfiguredDestination();
}
// Delay for the Context menu
if (conf.CaptureDelay > 0) {
Thread.Sleep(conf.CaptureDelay);
} else {
conf.CaptureDelay = 0;
}
// Capture Mousecursor if we are not loading from file or clipboard, only show when needed
if (_captureMode != CaptureMode.File && _captureMode != CaptureMode.Clipboard) {
_capture = WindowCapture.CaptureCursor(_capture);
if (_captureMouseCursor) {
_capture.CursorVisible = conf.CaptureMousepointer;
} else {
_capture.CursorVisible = false;
}
}
switch(_captureMode) {
case CaptureMode.Window:
_capture = WindowCapture.CaptureScreen(_capture);
_capture.CaptureDetails.AddMetaData("source", "Screen");
SetDPI();
CaptureWithFeedback();
break;
case CaptureMode.ActiveWindow:
if (CaptureActiveWindow()) {
// Capture worked, offset mouse according to screen bounds and capture location
_capture.MoveMouseLocation(_capture.ScreenBounds.Location.X-_capture.Location.X, _capture.ScreenBounds.Location.Y-_capture.Location.Y);
_capture.CaptureDetails.AddMetaData("source", "Window");
} else {
_captureMode = CaptureMode.FullScreen;
_capture = WindowCapture.CaptureScreen(_capture);
_capture.CaptureDetails.AddMetaData("source", "Screen");
_capture.CaptureDetails.Title = "Screen";
}
SetDPI();
HandleCapture();
break;
case CaptureMode.IE:
if (IECaptureHelper.CaptureIE(_capture, SelectedCaptureWindow) != null) {
_capture.CaptureDetails.AddMetaData("source", "Internet Explorer");
SetDPI();
HandleCapture();
}
break;
case CaptureMode.FullScreen:
// Check how we need to capture the screen
bool captureTaken = false;
switch (_screenCaptureMode) {
case ScreenCaptureMode.Auto:
Point mouseLocation = User32.GetCursorLocation();
foreach (Screen screen in Screen.AllScreens) {
if (screen.Bounds.Contains(mouseLocation)) {
_capture = WindowCapture.CaptureRectangle(_capture, screen.Bounds);
captureTaken = true;
break;
}
}
break;
case ScreenCaptureMode.Fixed:
if (conf.ScreenToCapture > 0 && conf.ScreenToCapture <= Screen.AllScreens.Length) {
_capture = WindowCapture.CaptureRectangle(_capture, Screen.AllScreens[conf.ScreenToCapture].Bounds);
captureTaken = true;
}
break;
case ScreenCaptureMode.FullScreen:
// Do nothing, we take the fullscreen capture automatically
break;
}
if (!captureTaken) {
_capture = WindowCapture.CaptureScreen(_capture);
}
SetDPI();
HandleCapture();
break;
case CaptureMode.Clipboard:
Image clipboardImage = ClipboardHelper.GetImage();
if (clipboardImage != null) {
if (_capture != null) {
_capture.Image = clipboardImage;
} else {
_capture = new Capture(clipboardImage);
}
_capture.CaptureDetails.Title = "Clipboard";
_capture.CaptureDetails.AddMetaData("source", "Clipboard");
// Force Editor, keep picker
if (_capture.CaptureDetails.HasDestination(PickerDestination.DESIGNATION)) {
_capture.CaptureDetails.ClearDestinations();
_capture.CaptureDetails.AddDestination(DestinationHelper.GetDestination(EditorDestination.DESIGNATION));
_capture.CaptureDetails.AddDestination(DestinationHelper.GetDestination(PickerDestination.DESIGNATION));
} else {
_capture.CaptureDetails.ClearDestinations();
_capture.CaptureDetails.AddDestination(DestinationHelper.GetDestination(EditorDestination.DESIGNATION));
}
HandleCapture();
} else {
MessageBox.Show(Language.GetString("clipboard_noimage"));
}
break;
case CaptureMode.File:
Image fileImage = null;
string filename = _capture.CaptureDetails.Filename;
if (!string.IsNullOrEmpty(filename)) {
try {
if (filename.ToLower().EndsWith("." + OutputFormat.greenshot)) {
ISurface surface = new Surface();
surface = ImageOutput.LoadGreenshotSurface(filename, surface);
surface.CaptureDetails = _capture.CaptureDetails;
DestinationHelper.GetDestination(EditorDestination.DESIGNATION).ExportCapture(true, surface, _capture.CaptureDetails);
break;
}
} catch (Exception e) {
LOG.Error(e.Message, e);
MessageBox.Show(Language.GetFormattedString(LangKey.error_openfile, filename));
}
try {
fileImage = ImageHelper.LoadImage(filename);
} catch (Exception e) {
LOG.Error(e.Message, e);
MessageBox.Show(Language.GetFormattedString(LangKey.error_openfile, filename));
}
}
if (fileImage != null) {
_capture.CaptureDetails.Title = Path.GetFileNameWithoutExtension(filename);
_capture.CaptureDetails.AddMetaData("file", filename);
_capture.CaptureDetails.AddMetaData("source", "file");
if (_capture != null) {
_capture.Image = fileImage;
} else {
_capture = new Capture(fileImage);
}
// Force Editor, keep picker, this is currently the only usefull destination
if (_capture.CaptureDetails.HasDestination(PickerDestination.DESIGNATION)) {
_capture.CaptureDetails.ClearDestinations();
_capture.CaptureDetails.AddDestination(DestinationHelper.GetDestination(EditorDestination.DESIGNATION));
_capture.CaptureDetails.AddDestination(DestinationHelper.GetDestination(PickerDestination.DESIGNATION));
} else {
_capture.CaptureDetails.ClearDestinations();
_capture.CaptureDetails.AddDestination(DestinationHelper.GetDestination(EditorDestination.DESIGNATION));
}
HandleCapture();
}
break;
case CaptureMode.LastRegion:
if (!conf.LastCapturedRegion.IsEmpty) {
_capture = WindowCapture.CaptureRectangle(_capture, conf.LastCapturedRegion);
// TODO: Reactive / check if the elements code is activated
//if (windowDetailsThread != null) {
// windowDetailsThread.Join();
//}
// Set capture title, fixing bug #3569703
foreach (WindowDetails window in WindowDetails.GetVisibleWindows()) {
Point estimatedLocation = new Point(conf.LastCapturedRegion.X + (conf.LastCapturedRegion.Width / 2), conf.LastCapturedRegion.Y + (conf.LastCapturedRegion.Height / 2));
if (window.Contains(estimatedLocation)) {
_selectedCaptureWindow = window;
_capture.CaptureDetails.Title = _selectedCaptureWindow.Text;
break;
}
}
// Move cursor, fixing bug #3569703
_capture.MoveMouseLocation(_capture.ScreenBounds.Location.X - _capture.Location.X, _capture.ScreenBounds.Location.Y - _capture.Location.Y);
//capture.MoveElements(capture.ScreenBounds.Location.X - capture.Location.X, capture.ScreenBounds.Location.Y - capture.Location.Y);
_capture.CaptureDetails.AddMetaData("source", "screen");
SetDPI();
HandleCapture();
}
break;
case CaptureMode.Region:
// Check if a region is pre-supplied!
if (Rectangle.Empty.Equals(_captureRect)) {
_capture = WindowCapture.CaptureScreen(_capture);
_capture.CaptureDetails.AddMetaData("source", "screen");
SetDPI();
CaptureWithFeedback();
} else {
_capture = WindowCapture.CaptureRectangle(_capture, _captureRect);
_capture.CaptureDetails.AddMetaData("source", "screen");
SetDPI();
HandleCapture();
}
break;
default:
LOG.Warn("Unknown capture mode: " + _captureMode);
break;
}
// Wait for thread, otherwise we can't dipose the CaptureHelper
if (retrieveWindowDetailsThread != null) {
retrieveWindowDetailsThread.Join();
}
if (_capture != null) {
LOG.Debug("Disposing capture");
_capture.Dispose();
}
}
/// <summary>
/// This method takes the actual capture of the document (frame)
/// </summary>
/// <param name="frameDocument"></param>
/// <param name="contentWindowDetails">Needed for referencing the location of the frame</param>
/// <returns>Bitmap with the capture</returns>
private static void drawDocument(DocumentContainer documentContainer, WindowDetails contentWindowDetails, Graphics graphicsTarget)
{
documentContainer.setAttribute("scroll", 1);
//Get Browser Window Width & Height
int pageWidth = documentContainer.ScrollWidth;
int pageHeight = documentContainer.ScrollHeight;
if (pageWidth * pageHeight == 0) {
LOG.WarnFormat("Empty page for DocumentContainer {0}: {1}", documentContainer.Name, documentContainer.Url);
return;
}
//Get Screen Width & Height (this is better as the WindowDetails.ClientRectangle as the real visible parts are there!
int viewportWidth = documentContainer.ClientWidth;
int viewportHeight = documentContainer.ClientHeight;
if (viewportWidth * viewportHeight == 0) {
LOG.WarnFormat("Empty viewport for DocumentContainer {0}: {1}", documentContainer.Name, documentContainer.Url);
return;
}
// Store the current location so we can set the browser back and use it for the mouse cursor
int startLeft = documentContainer.ScrollLeft;
int startTop = documentContainer.ScrollTop;
LOG.DebugFormat("Capturing {4} with total size {0},{1} displayed with size {2},{3}", pageWidth, pageHeight, viewportWidth, viewportHeight, documentContainer.Name);
// Variable used for looping horizontally
int horizontalPage = 0;
// The location of the browser, used as the destination into the bitmap target
Point targetOffset = new Point();
// Loop of the pages and make a copy of the visible viewport
while ((horizontalPage * viewportWidth) < pageWidth) {
// Scroll to location
documentContainer.ScrollLeft = viewportWidth * horizontalPage;
targetOffset.X = documentContainer.ScrollLeft;
// Variable used for looping vertically
int verticalPage = 0;
while ((verticalPage * viewportHeight) < pageHeight) {
// Scroll to location
documentContainer.ScrollTop = viewportHeight * verticalPage;
//Shoot visible window
targetOffset.Y = documentContainer.ScrollTop;
// Draw the captured fragment to the target, but "crop" the scrollbars etc while capturing
Size viewPortSize = new Size(viewportWidth, viewportHeight);
Rectangle clientRectangle = new Rectangle(documentContainer.SourceLocation, viewPortSize);
Image fragment = contentWindowDetails.PrintWindow();
if (fragment != null) {
LOG.DebugFormat("Captured fragment size: {0}x{1}", fragment.Width, fragment.Height);
try {
// cut all junk, due to IE "border" we need to remove some parts
Rectangle viewportRect = documentContainer.ViewportRectangle;
if (!viewportRect.IsEmpty) {
LOG.DebugFormat("Cropping to viewport: {0}", viewportRect);
ImageHelper.Crop(ref fragment, ref viewportRect);
}
LOG.DebugFormat("Cropping to clientRectangle: {0}", clientRectangle);
// Crop to clientRectangle
if (ImageHelper.Crop(ref fragment, ref clientRectangle)) {
Point targetLocation = new Point(documentContainer.DestinationLocation.X, documentContainer.DestinationLocation.Y);
LOG.DebugFormat("Fragment targetLocation is {0}", targetLocation);
targetLocation.Offset(targetOffset);
LOG.DebugFormat("After offsetting the fragment targetLocation is {0}", targetLocation);
LOG.DebugFormat("Drawing fragment of size {0} to {1}", fragment.Size, targetLocation);
graphicsTarget.DrawImage(fragment, targetLocation);
graphicsTarget.Flush();
} else {
// somehow we are capturing nothing!?
LOG.WarnFormat("Crop of {0} failed?", documentContainer.Name);
break;
}
} finally {
fragment.Dispose();
}
} else {
LOG.WarnFormat("Capture of {0} failed!", documentContainer.Name);
}
verticalPage++;
}
horizontalPage++;
}
// Return to where we were
documentContainer.ScrollLeft = startLeft;
documentContainer.ScrollTop = startTop;
}
void PictureBoxMouseMove(object sender, MouseEventArgs e)
{
Point lastPos = new Point(cursorPos.X, cursorPos.Y);
cursorPos = WindowCapture.GetCursorLocation();
// Make sure the mouse coordinates are fixed, when pressing shift
cursorPos = FixMouseCoordinates(cursorPos);
// As the cursorPos is not in Bitmap coordinates, we need to correct.
cursorPos.Offset(-capture.ScreenBounds.Location.X, -capture.ScreenBounds.Location.Y);
Rectangle lastCaptureRect = new Rectangle(captureRect.Location, captureRect.Size);
WindowDetails lastWindow = selectedCaptureWindow;
bool horizontalMove = false;
bool verticalMove = false;
if (lastPos.X != cursorPos.X) {
horizontalMove = true;
}
if (lastPos.Y != cursorPos.Y) {
verticalMove = true;
}
if (captureMode == CaptureMode.Region && mouseDown) {
captureRect = GuiRectangle.GetGuiRectangle(cursorPos.X, cursorPos.Y, mX - cursorPos.X, mY - cursorPos.Y);
}
// Iterate over the found windows and check if the current location is inside a window
Point cursorPosition = Cursor.Position;
selectedCaptureWindow = null;
lock (windows) {
foreach (WindowDetails window in windows) {
if (window.Contains(cursorPosition)) {
// Only go over the children if we are in window mode
if (CaptureMode.Window == captureMode) {
selectedCaptureWindow = window.FindChildUnderPoint(cursorPosition);
} else {
selectedCaptureWindow = window;
}
break;
}
}
}
if (selectedCaptureWindow != null && !selectedCaptureWindow.Equals(lastWindow)) {
capture.CaptureDetails.Title = selectedCaptureWindow.Text;
capture.CaptureDetails.AddMetaData("windowtitle", selectedCaptureWindow.Text);
if (captureMode == CaptureMode.Window) {
// Here we want to capture the window which is under the mouse
captureRect = selectedCaptureWindow.WindowRectangle;
// As the ClientRectangle is not in Bitmap coordinates, we need to correct.
captureRect.Offset(-capture.ScreenBounds.Location.X, -capture.ScreenBounds.Location.Y);
}
}
if (mouseDown && (CaptureMode.Window != captureMode)) {
int x1 = Math.Min(mX, lastPos.X);
int x2 = Math.Max(mX, lastPos.X);
int y1 = Math.Min(mY, lastPos.Y);
int y2 = Math.Max(mY, lastPos.Y);
x1= Math.Min(x1, cursorPos.X);
x2= Math.Max(x2, cursorPos.X);
y1= Math.Min(y1, cursorPos.Y);
y2= Math.Max(y2, cursorPos.Y);
// Safety correction
x2 += 2;
y2 += 2;
// Here we correct for text-size
// Calculate the size
int textForWidth = Math.Max(Math.Abs(mX - cursorPos.X), Math.Abs(mX - lastPos.X));
int textForHeight = Math.Max(Math.Abs(mY - cursorPos.Y), Math.Abs(mY - lastPos.Y));
using (Font rulerFont = new Font(FontFamily.GenericSansSerif, 8)) {
Size measureWidth = TextRenderer.MeasureText(textForWidth.ToString(), rulerFont);
x1 -= measureWidth.Width + 15;
Size measureHeight = TextRenderer.MeasureText(textForHeight.ToString(), rulerFont);
y1 -= measureWidth.Height + 10;
}
Rectangle invalidateRectangle = new Rectangle(x1,y1, x2-x1, y2-y1);
pictureBox.Invalidate(invalidateRectangle);
} else {
if (captureMode == CaptureMode.Window) {
if (selectedCaptureWindow != null && !selectedCaptureWindow.Equals(lastWindow)) {
// Using a 50 Pixel offset to the left, top, to make sure the text is invalidated too
const int SAFETY_SIZE = 50;
Rectangle invalidateRectangle = new Rectangle(lastCaptureRect.Location, lastCaptureRect.Size);
invalidateRectangle.X -= SAFETY_SIZE/2;
invalidateRectangle.Y -= SAFETY_SIZE/2;
invalidateRectangle.Width += SAFETY_SIZE;
invalidateRectangle.Height += SAFETY_SIZE;
pictureBox.Invalidate(invalidateRectangle);
invalidateRectangle = new Rectangle(captureRect.Location, captureRect.Size);
invalidateRectangle.X -= SAFETY_SIZE/2;
invalidateRectangle.Y -= SAFETY_SIZE/2;
invalidateRectangle.Width += SAFETY_SIZE;
invalidateRectangle.Height += SAFETY_SIZE;
pictureBox.Invalidate(invalidateRectangle);
}
} else {
if (!conf.OptimizeForRDP) {
if (verticalMove) {
Rectangle before = GuiRectangle.GetGuiRectangle(0, lastPos.Y - 2, this.Width+2, 45);
Rectangle after = GuiRectangle.GetGuiRectangle(0, cursorPos.Y - 2, this.Width+2, 45);
pictureBox.Invalidate(before);
pictureBox.Invalidate(after);
}
if (horizontalMove) {
Rectangle before = GuiRectangle.GetGuiRectangle(lastPos.X - 2, 0, 75, this.Height+2);
Rectangle after = GuiRectangle.GetGuiRectangle(cursorPos.X -2, 0, 75, this.Height+2);
pictureBox.Invalidate(before);
pictureBox.Invalidate(after);
}
}
}
}
}
public ImageEditorForm(ISurface iSurface, bool outputMade)
{
EditorList.Add(this);
InitializeComponent();
if (EditorConfiguration.MatchSizeToCapture)
{
RECT lastPosition = EditorConfiguration.GetEditorPlacement().NormalPosition;
WindowPlacement wp = new WindowDetails(Handle).WindowPlacement;
wp.NormalPosition.Top = lastPosition.Top;
wp.NormalPosition.Left = lastPosition.Left;
// don't actually show window now (it is done later)
wp.ShowCmd = ShowWindowCommand.Hide;
this.StartPosition = FormStartPosition.Manual;
WindowDetails thisForm = new WindowDetails(Handle)
{
WindowPlacement = wp
};
// Once image is loaded into window, size and position window
Load += delegate
{
Rectangle workingArea = Screen.FromControl(this).WorkingArea;
WindowPlacement windowPlacement = new WindowDetails(Handle).WindowPlacement;
if (EditorConfiguration.MaximizeWhenLargeImage)
{
if ((windowPlacement.NormalPosition.Width > workingArea.Width) || (windowPlacement.NormalPosition.Height > workingArea.Height))
{
windowPlacement.ShowCmd = ShowWindowCommand.Maximize;
}
}
if (windowPlacement.NormalPosition.Right > workingArea.Right)
{
int toMoveLeft = windowPlacement.NormalPosition.Right - workingArea.Right;
if (windowPlacement.NormalPosition.Left - toMoveLeft < 0)
toMoveLeft = windowPlacement.NormalPosition.Left;
windowPlacement.NormalPosition.Left -= toMoveLeft;
windowPlacement.NormalPosition.Right -= toMoveLeft;
}
if (windowPlacement.NormalPosition.Bottom > workingArea.Bottom)
{
int toMoveUp = windowPlacement.NormalPosition.Bottom - workingArea.Bottom;
if (windowPlacement.NormalPosition.Top - toMoveUp < 0)
toMoveUp = windowPlacement.NormalPosition.Top;
windowPlacement.NormalPosition.Top -= toMoveUp;
windowPlacement.NormalPosition.Bottom -= toMoveUp;
}
WindowDetails thisForm1 = new WindowDetails(Handle) { WindowPlacement = windowPlacement };
};
}
else
{
Load += delegate
{
//Make sure the editor is placed on the same location as the last editor was on close
WindowDetails thisForm = new WindowDetails(Handle)
{
WindowPlacement = EditorConfiguration.GetEditorPlacement()
};
};
}
// init surface
Surface = iSurface;
// Intial "saved" flag for asking if the image needs to be save
_surface.Modified = !outputMade;
UpdateUi();
// Workaround: As the cursor is (mostly) selected on the surface a funny artifact is visible, this fixes it.
//HideToolstripItems();
}
public static void CaptureIE(bool captureMouse, WindowDetails windowToCapture)
{
using (CaptureHelper captureHelper = new CaptureHelper(CaptureMode.IE, captureMouse)) {
captureHelper.SelectedCaptureWindow = windowToCapture;
captureHelper.MakeCapture();
}
}
/// <summary>
/// Select the window to capture, this has logic which takes care of certain special applications
/// like TOAD or Excel
/// </summary>
/// <param name="windowToCapture">WindowDetails with the target Window</param>
/// <returns>WindowDetails with the target Window OR a replacement</returns>
public static WindowDetails SelectCaptureWindow(WindowDetails windowToCapture)
{
Rectangle windowRectangle = windowToCapture.WindowRectangle;
if (windowRectangle.Width == 0 || windowRectangle.Height == 0) {
LOG.WarnFormat("Window {0} has nothing to capture, using workaround to find other window of same process.", windowToCapture.Text);
// Trying workaround, the size 0 arrises with e.g. Toad.exe, has a different Window when minimized
WindowDetails linkedWindow = WindowDetails.GetLinkedWindow(windowToCapture);
if (linkedWindow != null) {
windowRectangle = linkedWindow.WindowRectangle;
windowToCapture = linkedWindow;
} else {
return null;
}
}
return windowToCapture;
}
void CaptureFormKeyDown(object sender, KeyEventArgs e)
{
if (MouseHelper.CheckKeyDownForFixing(e.KeyCode))
{
return;
}
if (e.KeyCode == Keys.Escape)
{
StopCapturing(true);
}
else if (e.KeyCode == Keys.M)
{
// Toggle mouse cursor
capture.CursorVisible = !capture.CursorVisible;
pictureBox.Invalidate();
}
else if (e.KeyCode == Keys.V)
{
capture.CaptureDetails.CaptureMode = CaptureMode.Video;
pictureBox.Invalidate();
}
else if (e.KeyCode == Keys.Space)
{
switch (captureMode)
{
case CaptureMode.Region:
captureMode = CaptureMode.Window;
break;
case CaptureMode.Window:
captureMode = CaptureMode.Region;
break;
}
pictureBox.Invalidate();
selectedCaptureWindow = null;
PictureBoxMouseMove(this, new MouseEventArgs(MouseButtons.None, 0, Cursor.Position.X, Cursor.Position.Y, 0));
}
else if (e.KeyCode == Keys.Return && captureMode == CaptureMode.Window)
{
finishCaptureWithFeedback();
}
}
private bool CaptureActiveWindow()
{
bool presupplied = false;
LOG.Debug("CaptureActiveWindow");
if (_selectedCaptureWindow != null) {
LOG.Debug("Using supplied window");
presupplied = true;
} else {
_selectedCaptureWindow = WindowDetails.GetActiveWindow();
if (_selectedCaptureWindow != null) {
LOG.DebugFormat("Capturing window: {0} with {1}", _selectedCaptureWindow.Text, _selectedCaptureWindow.WindowRectangle);
}
}
if (_selectedCaptureWindow == null || (!presupplied && _selectedCaptureWindow.Iconic)) {
LOG.Warn("No window to capture!");
// Nothing to capture, code up in the stack will capture the full screen
return false;
}
if (!presupplied && _selectedCaptureWindow != null && _selectedCaptureWindow.Iconic) {
// Restore the window making sure it's visible!
// This is done mainly for a screen capture, but some applications like Excel and TOAD have weird behaviour!
_selectedCaptureWindow.Restore();
}
_selectedCaptureWindow = SelectCaptureWindow(_selectedCaptureWindow);
if (_selectedCaptureWindow == null) {
LOG.Warn("No window to capture, after SelectCaptureWindow!");
// Nothing to capture, code up in the stack will capture the full screen
return false;
}
// Fix for Bug #3430560
conf.LastCapturedRegion = _selectedCaptureWindow.WindowRectangle;
bool returnValue = CaptureWindow(_selectedCaptureWindow, _capture, conf.WindowCaptureMode) != null;
return returnValue;
}
/// <summary>
/// Make capture of window
/// </summary>
/// <param name="window">WindowDetails of the window to capture</param>
/// <param name="captureMouseCursor">bool false if the mouse should not be captured, true if the configuration should be checked</param>
public void MakeCapture(WindowDetails window, CaptureHandler captureHandler)
{
Capture passingCapture = new Capture();
passingCapture.CaptureDetails.CaptureHandler = captureHandler;
selectedCaptureWindow = window;
MakeCapture(CaptureMode.ActiveWindow, false, passingCapture);
}
