/// <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;
if (windowToCapture.Iconic)
{
// Restore the window making sure it's visible!
windowToCapture.Restore();
}
// When Vista & DWM (Aero) enabled
bool dwmEnabled = DWM.isDWMEnabled();
// get process name to be able to exclude certain processes from certain capture modes
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 && windowToCapture.ClassName == "IEFrame")
{
try
{
ICapture ieCapture = IECaptureHelper.CaptureIE(captureForWindow);
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 (conf.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 (conf.isDWMAllowed(process))
{
windowCaptureMode = WindowCaptureMode.Aero;
}
}
}
else if (windowCaptureMode == WindowCaptureMode.Aero || windowCaptureMode == WindowCaptureMode.AeroTransparent)
{
if (!dwmEnabled || !conf.isDWMAllowed(process))
{
// Take default screen
windowCaptureMode = WindowCaptureMode.Screen;
// Change to GDI, if allowed
if (conf.isGDIAllowed(process))
{
windowCaptureMode = WindowCaptureMode.GDI;
}
}
}
else if (windowCaptureMode == WindowCaptureMode.GDI && !conf.isGDIAllowed(process))
{
// GDI not allowed, take screen
windowCaptureMode = WindowCaptureMode.Screen;
}
LOG.InfoFormat("Capturing window with mode {0}", windowCaptureMode);
bool captureTaken = false;
// Try to capture
while (!captureTaken)
{
if (windowCaptureMode == WindowCaptureMode.GDI)
{
ICapture tmpCapture = null;
if (conf.isGDIAllowed(process))
{
tmpCapture = windowToCapture.CaptureWindow(captureForWindow);
}
if (tmpCapture != null)
{
captureForWindow = tmpCapture;
captureTaken = true;
}
else
{
// A problem, try Screen
windowCaptureMode = WindowCaptureMode.Screen;
}
}
else if (windowCaptureMode == WindowCaptureMode.Aero || windowCaptureMode == WindowCaptureMode.AeroTransparent)
{
ICapture tmpCapture = null;
if (conf.isDWMAllowed(process))
{
tmpCapture = windowToCapture.CaptureDWMWindow(captureForWindow, windowCaptureMode, isAutoMode);
}
if (tmpCapture != null)
{
captureForWindow = tmpCapture;
captureTaken = true;
}
else
{
// A problem, try GDI
windowCaptureMode = WindowCaptureMode.GDI;
}
}
else
{
// Screen capture
windowRectangle.Intersect(captureForWindow.ScreenBounds);
try
{
captureForWindow = WindowCapture.CaptureRectangle(captureForWindow, windowRectangle);
captureTaken = true;
}
catch (Exception e)
{
LOG.Error("Problem capturing", e);
return(null);
}
}
}
if (captureForWindow != null && windowToCapture != null)
{
captureForWindow.CaptureDetails.Title = windowToCapture.Text;
((Bitmap)captureForWindow.Image).SetResolution(captureForWindow.CaptureDetails.DpiX, captureForWindow.CaptureDetails.DpiY);
}
return(captureForWindow);
}
/// <summary>
/// Make Capture with specified destinations
/// </summary>
private void MakeCapture()
{
// Experimental code
if (screenCapture != null)
{
screenCapture.Stop();
screenCapture = null;
return;
}
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
windowDetailsThread = PrepareForCaptureWithFeedback();
// Add destinations if no-one passed a handler
if (capture.CaptureDetails.CaptureDestinations == null || capture.CaptureDetails.CaptureDestinations.Count == 0)
{
AddConfiguredDestination();
}
// Workaround for proble with DPI retrieval, the FromHwnd activates the window...
WindowDetails previouslyActiveWindow = WindowDetails.GetActiveWindow();
// Workaround for changed DPI settings in Windows 7
using (Graphics graphics = Graphics.FromHwnd(MainForm.instance.Handle))
{
capture.CaptureDetails.DpiX = graphics.DpiX;
capture.CaptureDetails.DpiY = graphics.DpiY;
}
if (previouslyActiveWindow != null)
{
// Set previouslyActiveWindow as foreground window
previouslyActiveWindow.ToForeground();
}
// Delay for the Context menu
if (conf.CaptureDelay > 0)
{
System.Threading.Thread.Sleep(conf.CaptureDelay);
}
else
{
conf.CaptureDelay = 0;
}
// Allways capture Mousecursor, only show when needed
capture = WindowCapture.CaptureCursor(capture);
capture.CursorVisible = false;
// Check if needed
if (captureMouseCursor && captureMode != CaptureMode.Clipboard && captureMode != CaptureMode.File)
{
capture.CursorVisible = conf.CaptureMousepointer;
}
switch (captureMode)
{
case CaptureMode.Window:
capture = WindowCapture.CaptureScreen(capture);
capture.CaptureDetails.AddMetaData("source", "Screen");
CaptureWithFeedback();
break;
case CaptureMode.ActiveWindow:
if (CaptureActiveWindow())
{
if (windowDetailsThread != null)
{
windowDetailsThread.Join();
}
// 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.MoveElements(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";
}
HandleCapture();
break;
case CaptureMode.IE:
if (IECaptureHelper.CaptureIE(capture) != null)
{
capture.CaptureDetails.AddMetaData("source", "Internet Explorer");
HandleCapture();
}
break;
case CaptureMode.FullScreen:
// Check how we need to capture the screen
bool captureTaken = false;
switch (screenCaptureMode)
{
case ScreenCaptureMode.Auto:
Point mouseLocation = WindowCapture.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);
}
HandleCapture();
break;
case CaptureMode.Clipboard:
Image clipboardImage = null;
string text = "Clipboard";
if (ClipboardHelper.ContainsImage())
{
clipboardImage = ClipboardHelper.GetImage();
}
if (clipboardImage != null)
{
if (capture != null)
{
capture.Image = clipboardImage;
}
else
{
capture = new Capture(clipboardImage);
}
string title = ClipboardHelper.GetText();
if (title == null || title.Trim().Length == 0)
{
title = "Clipboard";
}
capture.CaptureDetails.Title = title;
capture.CaptureDetails.AddMetaData("source", "Clipboard");
// Force Editor, keep picker
if (capture.CaptureDetails.HasDestination(Destinations.PickerDestination.DESIGNATION))
{
capture.CaptureDetails.ClearDestinations();
capture.CaptureDetails.AddDestination(DestinationHelper.GetDestination(Destinations.EditorDestination.DESIGNATION));
capture.CaptureDetails.AddDestination(DestinationHelper.GetDestination(Destinations.PickerDestination.DESIGNATION));
}
else
{
capture.CaptureDetails.ClearDestinations();
capture.CaptureDetails.AddDestination(DestinationHelper.GetDestination(Destinations.EditorDestination.DESIGNATION));
}
HandleCapture();
}
else
{
MessageBox.Show("Couldn't create bitmap from : " + text);
}
break;
case CaptureMode.File:
Bitmap fileBitmap = null;
string filename = capture.CaptureDetails.Filename;
if (!string.IsNullOrEmpty(filename))
{
try
{
fileBitmap = ImageHelper.LoadBitmap(filename);
}
catch (Exception e)
{
LOG.Error(e.Message, e);
MessageBox.Show(Language.GetFormattedString(LangKey.error_openfile, filename));
}
}
if (fileBitmap != null)
{
capture.CaptureDetails.Title = Path.GetFileNameWithoutExtension(filename);
capture.CaptureDetails.AddMetaData("file", filename);
capture.CaptureDetails.AddMetaData("source", "file");
if (capture != null)
{
capture.Image = fileBitmap;
}
else
{
capture = new Capture(fileBitmap);
}
// 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 (!RuntimeConfig.LastCapturedRegion.IsEmpty)
{
capture = WindowCapture.CaptureRectangle(capture, RuntimeConfig.LastCapturedRegion);
if (windowDetailsThread != null)
{
windowDetailsThread.Join();
}
capture.CaptureDetails.AddMetaData("source", "screen");
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");
CaptureWithFeedback();
}
else
{
capture = WindowCapture.CaptureRectangle(capture, captureRect);
capture.CaptureDetails.AddMetaData("source", "screen");
HandleCapture();
}
break;
case CaptureMode.Video:
capture = WindowCapture.CaptureScreen(capture);
// Set the capturemode to be window
captureMode = CaptureMode.Window;
capture.CaptureDetails.AddMetaData("source", "Video");
CaptureWithFeedback();
break;
default:
LOG.Warn("Unknown capture mode: " + captureMode);
break;
}
if (windowDetailsThread != null)
{
windowDetailsThread.Join();
}
if (capture != null)
{
LOG.Debug("Disposing capture");
capture.Dispose();
}
}
