>();
+
+ // Loop for the , <link>, <description> and all the other tags
+ for (int i = 0; i < nodeChannel.ChildNodes.Count; i++) {
+ // If it is the item tag, then it has children tags which we will add as items to the ListView
+
+ if (nodeChannel.ChildNodes[i].Name == "item") {
+ XmlNode nodeItem = nodeChannel.ChildNodes[i];
+ string sfLink = nodeItem["link"].InnerText;
+ string pubdate = nodeItem["pubDate"].InnerText;
+ try {
+ Match match= Regex.Match(Uri.UnescapeDataString(sfLink), @"^http.*sourceforge.*\/projects\/([^\/]+)\/files\/([^\/]+)\/([^\/]+)\/(.+)\/download$");
+ if (match.Success) {
+ string project = match.Groups[1].Value;
+ string subdir = match.Groups[2].Value;
+ string type = match.Groups[3].Value;
+ string file = match.Groups[4].Value;
+ // !!! Change this to the mirror !!!
+ string mirror = "kent";
+ string directLink = Uri.EscapeUriString("http://"+mirror+".dl.sourceforge.net/project/"+project+"/"+subdir+"/"+type+"/"+file);
+ Dictionary<string, SourceforgeFile> filesForType;
+ if (rssFiles.ContainsKey(type)) {
+ filesForType = rssFiles[type];
+ } else {
+ filesForType = new Dictionary<string, SourceforgeFile>();
+ rssFiles.Add(type, filesForType);
+ }
+ SourceforgeFile rssFile = new SourceforgeFile(file, pubdate, sfLink, directLink);
+ if (file.EndsWith(".exe") ||file.EndsWith(".zip")) {
+ string version = Regex.Replace(file, ".*[a-zA-Z]-", "");
+ version = Regex.Replace(version, ".exe$", "");
+ version = Regex.Replace(version, ".zip$", "");
+ if (version.Trim().Length > 0) {
+ version = version.Replace('-','.');
+ version = version.Replace(',','.');
+ try {
+ rssFile.Version = new Version(version);
+ } catch (Exception) {
+ LOG.DebugFormat("Found invalid version {0} in file {1}", version, file);
+ }
+ }
+ }
+ if (type.Equals("Translations")) {
+ string culture = Regex.Replace(file, @"[a-zA-Z]+-(..-..)\.(xml|html)", "$1");
+ CultureInfo cultureInfo = new CultureInfo(culture);
+ rssFile.Language = cultureInfo.NativeName;
+ }
+ filesForType.Add(file, rssFile);
+ }
+ } catch (Exception ex) {
+ LOG.WarnFormat("Couldn't read RSS entry for: {0}", nodeChannel["title"].InnerText);
+ LOG.Warn("Reason: ", ex);
+ }
+ }
+ }
+
+ return rssFiles;
+ }
+ }
+}
diff --git a/Greenshot/Helpers/WindowCapture.cs b/Greenshot/Helpers/WindowCapture.cs
new file mode 100644
index 000000000..b4fa7c799
--- /dev/null
+++ b/Greenshot/Helpers/WindowCapture.cs
@@ -0,0 +1,543 @@
+/*
+ * Greenshot - a free and open source screenshot tool
+ * Copyright (C) 2007-2011 Thomas Braun, Jens Klingen, Robin Krom
+ *
+ * For more information see: http://getgreenshot.org/
+ * The Greenshot project is hosted on Sourceforge: http://sourceforge.net/projects/greenshot/
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 1 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Drawing;
+using System.Drawing.Imaging;
+using System.IO;
+using System.Reflection;
+using System.Runtime.InteropServices;
+using System.Windows.Forms;
+
+using Greenshot;
+using Greenshot.Configuration;
+using Greenshot.Plugin;
+using Greenshot.UnmanagedHelpers;
+
+namespace Greenshot.Helpers {
+ /// <summary>
+ /// This Class is used to pass details about the capture around.
+ /// The time the Capture was taken and the Title of the window (or a region of) that is captured
+ /// </summary>
+ public class CaptureDetails : ICaptureDetails {
+ private string title;
+ public string Title {
+ get {return title;}
+ set {title = value;}
+ }
+
+ private string filename;
+ public string Filename {
+ get {return filename;}
+ set {filename = value;}
+ }
+
+ private DateTime dateTime;
+ public DateTime DateTime {
+ get {return dateTime;}
+ set {dateTime = value;}
+ }
+
+ private float dpiX;
+ public float DpiX {
+ get {
+ return dpiX;
+ }
+ set {
+ dpiX = value;
+ }
+ }
+
+ private float dpiY;
+ public float DpiY {
+ get {
+ return dpiY;
+ }
+ set {
+ dpiY = value;
+ }
+ }
+ private Dictionary<string, string> metaData = new Dictionary<string, string>();
+ public Dictionary<string, string> MetaData {
+ get {return metaData;}
+ }
+
+ public void AddMetaData(string key, string value) {
+ if (metaData.ContainsKey(key)) {
+ metaData[key] = value;
+ } else {
+ metaData.Add(key, value);
+ }
+ }
+
+ private CaptureMode captureMode;
+ public CaptureMode CaptureMode {
+ get {return captureMode;}
+ set {captureMode = value;}
+ }
+
+ private List<CaptureDestination> captureDestinations = new List<CaptureDestination>();
+ public List<CaptureDestination> CaptureDestinations {
+ get {return captureDestinations;}
+ set {captureDestinations = value;}
+ }
+
+ private CaptureHandler captureHandler;
+ public CaptureHandler CaptureHandler {
+ get {return captureHandler;}
+ set {captureHandler = value;}
+ }
+
+ public void ClearDestinations() {
+ captureDestinations.Clear();
+ }
+
+ public void RemoveDestination(CaptureDestination captureDestination) {
+ if (!captureDestinations.Contains(captureDestination)) {
+ captureDestinations.Remove(captureDestination);
+ }
+ }
+
+ public void AddDestination(CaptureDestination captureDestination) {
+ if (!captureDestinations.Contains(captureDestination)) {
+ captureDestinations.Add(captureDestination);
+ }
+ }
+
+ public CaptureDetails() {
+ dateTime = DateTime.Now;
+ }
+
+
+ }
+
+ /// <summary>
+ /// This class is used to pass an instance of the "Capture" around
+ /// Having the Bitmap, eventually the Windows Title and cursor all together.
+ /// </summary>
+ public class Capture : IDisposable, ICapture {
+ private static log4net.ILog LOG = log4net.LogManager.GetLogger(typeof(Capture));
+
+ private Rectangle screenBounds;
+ /// <summary>
+ /// Get/Set the Screenbounds
+ /// </summary>
+ public Rectangle ScreenBounds {
+ get {return screenBounds;}
+ set {screenBounds = value;}
+ }
+
+ private Image image;
+ /// <summary>
+ /// Get/Set the Image
+ /// </summary>
+ public Image Image {
+ get {return image;}
+ set {
+ if (image != null) {
+ image.Dispose();
+ }
+ image = value;
+ if (value != null) {
+ if (value.PixelFormat.Equals(PixelFormat.Format8bppIndexed) || value.PixelFormat.Equals(PixelFormat.Format1bppIndexed) || value.PixelFormat.Equals(PixelFormat.Format4bppIndexed)) {
+ LOG.Debug("Converting Bitmap to PixelFormat.Format32bppArgb as we don't support: " + value.PixelFormat);
+ try {
+ // Default Bitmap PixelFormat is Format32bppArgb
+ this.image = new Bitmap(value);
+ } finally {
+ // Always dispose, even when a exception occured
+ value.Dispose();
+ }
+ }
+ LOG.Debug("Image is set with the following specifications: " + image.Width + "," + image.Height + " - " + image.PixelFormat);
+ } else {
+ LOG.Debug("Image is removed.");
+ }
+ }
+ }
+
+ public void NullImage() {
+ image = null;
+ }
+
+ private Icon cursor;
+ /// <summary>
+ /// Get/Set the image for the Cursor
+ /// </summary>
+ public Icon Cursor {
+ get {return cursor;}
+ set {
+ if (cursor != null) {
+ cursor.Dispose();
+ }
+ cursor = (Icon)value.Clone();
+ }
+ }
+
+ private bool cursorVisible = false;
+ /// <summary>
+ /// Set if the cursor is visible
+ /// </summary>
+ public bool CursorVisible {
+ get {return cursorVisible;}
+ set {cursorVisible = value;}
+ }
+
+ private Point cursorLocation = Point.Empty;
+ /// <summary>
+ /// Get/Set the CursorLocation
+ /// </summary>
+ public Point CursorLocation {
+ get {return cursorLocation;}
+ set {cursorLocation = value;}
+ }
+
+ private Point location = Point.Empty;
+ /// <summary>
+ /// Get/set the Location
+ /// </summary>
+ public Point Location {
+ get {return location;}
+ set {location = value;}
+ }
+
+ private CaptureDetails captureDetails;
+ /// <summary>
+ /// Get/set the CaptureDetails
+ /// </summary>
+ public ICaptureDetails CaptureDetails {
+ get {return captureDetails;}
+ set {captureDetails = (CaptureDetails)value;}
+ }
+
+ /// <summary>
+ /// Default Constructor
+ /// </summary>
+ public Capture() {
+ screenBounds = WindowCapture.GetScreenBounds();
+ captureDetails = new CaptureDetails();
+ }
+
+ /// <summary>
+ /// Constructor with Image
+ /// Note: the supplied bitmap can be disposed immediately or when constructor is called.
+ /// </summary>
+ /// <param name="newImage">Image</param>
+ public Capture(Image newImage) : this() {
+ this.Image = newImage;
+ }
+
+ /// <summary>
+ /// Destructor
+ /// </summary>
+ ~Capture() {
+ Dispose(false);
+ }
+
+ /// <summary>
+ /// The public accessible Dispose
+ /// Will call the GarbageCollector to SuppressFinalize, preventing being cleaned twice
+ /// </summary>
+ public void Dispose() {
+ Dispose(true);
+ GC.SuppressFinalize(this);
+ }
+
+ /// <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) {
+ if (image != null) {
+ image.Dispose();
+ }
+ if (cursor != null) {
+ cursor.Dispose();
+ }
+ }
+ image = null;
+ cursor = null;
+ }
+
+ /// <summary>
+ /// Crops the capture to the specified rectangle (with Bitmap coordinates!)
+ /// </summary>
+ /// <param name="cropRectangle">Rectangle with bitmap coordinates</param>
+ public bool Crop(Rectangle cropRectangle) {
+ LOG.Debug("Cropping to: " + cropRectangle.ToString());
+ if (ImageHelper.Crop(ref image, ref cropRectangle)) {
+ location = cropRectangle.Location;
+ // Change mouse location according to the cropRegtangle (including screenbounds) offset
+ MoveMouseLocation(-cropRectangle.Location.X, -cropRectangle.Location.Y);
+ return true;
+ }
+ return false;
+ }
+
+ /// <summary>
+ /// Apply a translate to the mouse location.
+ /// e.g. needed for crop
+ /// </summary>
+ /// <param name="x">x coordinates to move the mouse</param>
+ /// <param name="y">y coordinates to move the mouse</param>
+ public void MoveMouseLocation(int x, int y) {
+ cursorLocation.Offset(x, y);
+ }
+ }
+
+ /// <summary>
+ /// The Window Capture code
+ /// </summary>
+ public class WindowCapture {
+ private static readonly log4net.ILog LOG = log4net.LogManager.GetLogger(typeof(WindowCapture));
+
+ private WindowCapture() {
+ }
+
+ /// <summary>
+ /// Get the bounds of all screens combined.
+ /// </summary>
+ /// <returns>A Rectangle of the bounds of the entire display area.</returns>
+ public static Rectangle GetScreenBounds() {
+ int left = 0, top = 0, bottom = 0, right = 0;
+ foreach (Screen screen in Screen.AllScreens) {
+ left = Math.Min(left, screen.Bounds.X);
+ top = Math.Min(top, screen.Bounds.Y);
+ int screenAbsRight = screen.Bounds.X + screen.Bounds.Width;
+ int screenAbsBottom = screen.Bounds.Y + screen.Bounds.Height;
+ right = Math.Max(right, screenAbsRight);
+ bottom = Math.Max(bottom, screenAbsBottom);
+ }
+ return new Rectangle(left, top, (right + Math.Abs(left)), (bottom + Math.Abs(top)));
+ }
+
+ /// <summary>
+ /// Retrieves the cursor location safely, accounting for DPI settings in Vista/Windows 7
+ /// <returns>Point with cursor location</returns>
+ public static Point GetCursorLocation() {
+ if (Environment.OSVersion.Version.Major >= 6) {
+ POINT cursorLocation;
+ if (User32.GetPhysicalCursorPos(out cursorLocation)) {
+ return new Point(cursorLocation.X, cursorLocation.Y);
+ } else {
+ Win32Error error = Win32.GetLastErrorCode();
+ LOG.ErrorFormat("Error retrieving PhysicalCursorPos : {0}", Win32.GetMessage(error));
+ }
+ }
+ return new Point(Cursor.Position.X, Cursor.Position.Y);
+ }
+
+ /// <summary>
+ /// This method will capture the current Cursor by using User32 Code
+ /// </summary>
+ /// <returns>A Capture Object with the Mouse Cursor information in it.</returns>
+ public static ICapture CaptureCursor(ICapture capture) {
+ LOG.Debug("Capturing the mouse cursor.");
+ if (capture == null) {
+ capture = new Capture();
+ }
+ int x,y;
+ IntPtr hicon;
+ CursorInfo cursorInfo = new CursorInfo();
+ IconInfo iconInfo;
+ cursorInfo.cbSize = Marshal.SizeOf(cursorInfo);
+ if (User32.GetCursorInfo(out cursorInfo)) {
+ if (cursorInfo.flags == User32.CURSOR_SHOWING) {
+ hicon = User32.CopyIcon(cursorInfo.hCursor);
+ if (User32.GetIconInfo(hicon, out iconInfo)) {
+ Point cursorLocation = GetCursorLocation();
+ // Allign cursor location to Bitmap coordinates (instead of Screen coordinates)
+ x = cursorLocation.X - iconInfo.xHotspot - capture.ScreenBounds.X;
+ y = cursorLocation.Y - iconInfo.yHotspot - capture.ScreenBounds.Y;
+ // Set the location
+ capture.CursorLocation = new Point(x, y);
+
+ using (Icon icon = Icon.FromHandle(hicon)) {
+ capture.Cursor = icon;
+ }
+
+ if (iconInfo.hbmMask != IntPtr.Zero) {
+ GDI32.DeleteObject(iconInfo.hbmMask);
+ }
+ if (iconInfo.hbmColor != IntPtr.Zero) {
+ GDI32.DeleteObject(iconInfo.hbmColor);
+ }
+ }
+ User32.DestroyIcon(hicon);
+ }
+ }
+ return capture;
+ }
+
+ /// <summary>
+ /// This method will call the CaptureRectangle with the screenbounds, therefor Capturing the whole screen.
+ /// </summary>
+ /// <returns>A Capture Object with the Screen as an Image</returns>
+ public static ICapture CaptureScreen(ICapture capture) {
+ if (capture == null) {
+ capture = new Capture();
+ }
+ return CaptureRectangle(capture, capture.ScreenBounds);
+ }
+
+ /// <summary>
+ /// Helper method to create an exception that might explain what is wrong while capturing
+ /// </summary>
+ /// <param name="method">string with current method</param>
+ /// <param name="capture">ICapture</param>
+ /// <param name="captureBounds">Rectangle of what we want to capture</param>
+ /// <returns></returns>
+ private static Exception CreateCaptureException(string method, Rectangle captureBounds) {
+ Exception exceptionToThrow = User32.CreateWin32Exception(method);
+ if (captureBounds != Rectangle.Empty) {
+ exceptionToThrow.Data.Add("Height", captureBounds.Height);
+ exceptionToThrow.Data.Add("Width", captureBounds.Width);
+ }
+ return exceptionToThrow;
+ }
+
+ /// <summary>
+ /// This method will use User32 code to capture the specified captureBounds from the screen
+ /// </summary>
+ /// <param name="capture">ICapture where the captured Bitmap will be stored</param>
+ /// <param name="captureBounds">Rectangle with the bounds to capture</param>
+ /// <returns>A Capture Object with a part of the Screen as an Image</returns>
+ public static ICapture CaptureRectangle(ICapture capture, Rectangle captureBounds) {
+ if (capture == null) {
+ capture = new Capture();
+ }
+ capture.Image = CaptureRectangle(captureBounds);
+ capture.Location = captureBounds.Location;
+ ((Bitmap)capture.Image).SetResolution(capture.CaptureDetails.DpiX, capture.CaptureDetails.DpiY);
+ if (capture.Image == null) {
+ return null;
+ }
+ return capture;
+ }
+
+ /// <summary>
+ /// This method will use User32 code to capture the specified captureBounds from the screen
+ /// </summary>
+ /// <param name="captureBounds">Rectangle with the bounds to capture</param>
+ /// <returns>Bitmap which is captured from the screen at the location specified by the captureBounds</returns>
+ public static Bitmap CaptureRectangle(Rectangle captureBounds) {
+ Bitmap returnBitmap = null;
+ if (captureBounds.Height <= 0 || captureBounds.Width <= 0) {
+ LOG.Warn("Nothing to capture, ignoring!");
+ return null;
+ } else {
+ LOG.Debug("CaptureRectangle Called!");
+ }
+
+ // .NET GDI+ Solution, according to some post this has a GDI+ leak...
+ // See http://connect.microsoft.com/VisualStudio/feedback/details/344752/gdi-object-leak-when-calling-graphics-copyfromscreen
+ // Bitmap capturedBitmap = new Bitmap(captureBounds.Width, captureBounds.Height);
+ // using (Graphics graphics = Graphics.FromImage(capturedBitmap)) {
+ // graphics.CopyFromScreen(captureBounds.Location, Point.Empty, captureBounds.Size, CopyPixelOperation.CaptureBlt);
+ // }
+ // capture.Image = capturedBitmap;
+ // capture.Location = captureBounds.Location;
+
+ // "P/Invoke" Solution for capturing the screen
+ IntPtr hWndDesktop = User32.GetDesktopWindow();
+ // get te hDC of the target window
+ IntPtr hDCDesktop = User32.GetWindowDC(hWndDesktop);
+
+ // Make sure the last error is set to 0
+ Win32.SetLastError(0);
+
+ // create a device context we can copy to
+ IntPtr hDCDest = GDI32.CreateCompatibleDC(hDCDesktop);
+ // Check if the device context is there, if not throw an error with as much info as possible!
+ if (hDCDest == IntPtr.Zero) {
+ // Get Exception before the error is lost
+ Exception exceptionToThrow = CreateCaptureException("CreateCompatibleDC", captureBounds);
+ // Cleanup
+ User32.ReleaseDC(hWndDesktop, hDCDesktop);
+ // throw exception
+ throw exceptionToThrow;
+ }
+
+ // Create BitmapInfoHeader for CreateDIBSection
+ BitmapInfoHeader bmi = new BitmapInfoHeader(captureBounds.Width, captureBounds.Height, 24);
+
+ // Make sure the last error is set to 0
+ Win32.SetLastError(0);
+
+ // create a bitmap we can copy it to, using GetDeviceCaps to get the width/height
+ IntPtr bits0; // not used for our purposes. It returns a pointer to the raw bits that make up the bitmap.
+ IntPtr hDIBSection = GDI32.CreateDIBSection(hDCDesktop, ref bmi, BitmapInfoHeader.DIB_RGB_COLORS, out bits0, IntPtr.Zero, 0);
+
+ if (hDIBSection == IntPtr.Zero) {
+ // Get Exception before the error is lost
+ Exception exceptionToThrow = CreateCaptureException("CreateDIBSection", captureBounds);
+ exceptionToThrow.Data.Add("hdcDest", hDCDest.ToInt32());
+ exceptionToThrow.Data.Add("hdcSrc", hDCDesktop.ToInt32());
+
+ // clean up
+ GDI32.DeleteDC(hDCDest);
+ User32.ReleaseDC(hWndDesktop, hDCDesktop);
+
+ // Throw so people can report the problem
+ throw exceptionToThrow;
+ } else {
+ // select the bitmap object and store the old handle
+ IntPtr hOldObject = GDI32.SelectObject(hDCDest, hDIBSection);
+
+ // bitblt over (make copy)
+ GDI32.BitBlt(hDCDest, 0, 0, captureBounds.Width, captureBounds.Height, hDCDesktop, captureBounds.X, captureBounds.Y, CopyPixelOperation.SourceCopy | CopyPixelOperation.CaptureBlt);
+
+ // restore selection (old handle)
+ GDI32.SelectObject(hDCDest, hOldObject);
+ // clean up
+ GDI32.DeleteDC(hDCDest);
+ User32.ReleaseDC(hWndDesktop, hDCDesktop);
+
+ // get a .NET image object for it
+ // A suggestion for the "A generic error occurred in GDI+." E_FAIL/080004005 error is to re-try...
+ bool success = false;
+ ExternalException exception = null;
+ for(int i = 0; i < 3; i++) {
+ try {
+ // assign image to Capture, the image will be disposed there..
+ returnBitmap = Bitmap.FromHbitmap(hDIBSection);
+ success = true;
+ break;
+ } catch (ExternalException ee) {
+ LOG.Warn("Problem getting bitmap at try " + i + " : ", ee);
+ exception = ee;
+ }
+ }
+ if (!success) {
+ LOG.Error("Still couldn't create Bitmap!");
+ throw exception;
+ }
+ // free up the Bitmap object
+ GDI32.DeleteObject(hDIBSection);
+
+ }
+ return returnBitmap;
+ }
+ }
+}
diff --git a/Greenshot/Helpers/WindowsHelper.cs b/Greenshot/Helpers/WindowsHelper.cs
new file mode 100644
index 000000000..631c09a8c
--- /dev/null
+++ b/Greenshot/Helpers/WindowsHelper.cs
@@ -0,0 +1,1137 @@
+/*
+ * Greenshot - a free and open source screenshot tool
+ * Copyright (C) 2007-2011 Thomas Braun, Jens Klingen, Robin Krom
+ *
+ * For more information see: http://getgreenshot.org/
+ * The Greenshot project is hosted on Sourceforge: http://sourceforge.net/projects/greenshot/
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 1 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Drawing;
+using System.Drawing.Imaging;
+using System.IO;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Text.RegularExpressions;
+using System.Threading;
+using System.Windows.Forms;
+
+using Greenshot.Configuration;
+using Greenshot.Drawing;
+using Greenshot.Plugin;
+using Greenshot.UnmanagedHelpers;
+using GreenshotPlugin.Core;
+
+/// <summary>
+/// Code for handling with "windows"
+/// Main code is taken from vbAccelerator, location:
+/// http://www.vbaccelerator.com/home/NET/Code/Libraries/Windows/Enumerating_Windows/article.asp
+/// but a lot of changes/enhancements were made to adapt it for Greenshot.
+/// </summary>
+namespace Greenshot.Helpers {
+ #region EnumWindows
+ /// <summary>
+ /// EnumWindows wrapper for .NET
+ /// </summary>
+ public class WindowsEnumerator {
+ #region Member Variables
+ private List<WindowDetails> items = null;
+ #endregion
+
+ /// <summary>
+ /// Returns the collection of windows returned by
+ /// GetWindows
+ /// </summary>
+ public List<WindowDetails> Items {
+ get {
+ return this.items;
+ }
+ }
+
+ /// <summary>
+ /// Gets all top level windows on the system.
+ /// </summary>
+ public void GetWindows() {
+ this.items = new List<WindowDetails>();
+ User32.EnumWindows(new EnumWindowsProc(this.WindowEnum), 0);
+ }
+
+ /// <summary>
+ /// Gets all child windows of the specified window
+ /// </summary>
+ /// <param name="hWndParent">Window Handle to get children for</param>
+ public void GetWindows(WindowDetails parent) {
+ if (parent != null) {
+ GetWindows(parent.Handle);
+ } else {
+ GetWindows(IntPtr.Zero);
+ }
+ }
+
+ /// <summary>
+ /// Gets all child windows of the specified window
+ /// </summary>
+ /// <param name="hWndParent">Window Handle to get children for</param>
+ public void GetWindows(IntPtr hWndParent) {
+ this.items = new List<WindowDetails>();
+ User32.EnumChildWindows(hWndParent, new EnumWindowsProc(this.WindowEnum), 0);
+ if (!IntPtr.Zero.Equals(hWndParent)) {
+ WindowDetails parent = new WindowDetails(hWndParent);
+ foreach(WindowDetails window in items) {
+ window.Text = parent.Text;
+ }
+ }
+ }
+
+ #region EnumWindows callback
+ /// <summary>
+ /// The enum Windows callback.
+ /// </summary>
+ /// <param name="hWnd">Window Handle</param>
+ /// <param name="lParam">Application defined value</param>
+ /// <returns>1 to continue enumeration, 0 to stop</returns>
+ private int WindowEnum(IntPtr hWnd, int lParam) {
+ if (this.OnWindowEnum(hWnd)) {
+ return 1;
+ } else {
+ return 0;
+ }
+ }
+ #endregion
+
+ /// <summary>
+ /// Called whenever a new window is about to be added
+ /// by the Window enumeration called from GetWindows.
+ /// If overriding this function, return true to continue
+ /// enumeration or false to stop. If you do not call
+ /// the base implementation the Items collection will
+ /// be empty.
+ /// </summary>
+ /// <param name="hWnd">Window handle to add</param>
+ /// <returns>True to continue enumeration, False to stop</returns>
+ protected virtual bool OnWindowEnum(IntPtr hWnd) {
+ items.Add( new WindowDetails(hWnd));
+ return true;
+ }
+
+ #region Constructor, Dispose
+ public WindowsEnumerator() {
+ // nothing to do
+ }
+ #endregion
+ }
+ #endregion EnumWindows
+
+ /// <summary>
+ #region WindowDetails
+ /// <summary>
+ /// Provides details about a Window returned by the
+ /// enumeration
+ /// </summary>
+ public class WindowDetails : IEquatable<WindowDetails>{
+ private static log4net.ILog LOG = log4net.LogManager.GetLogger(typeof(WindowDetails));
+ private static Dictionary<string, List<string>> classnameTree = new Dictionary<string, List<string>>();
+ private static CoreConfiguration conf = IniConfig.GetIniSection<CoreConfiguration>();
+ private static ILanguage lang = Language.GetInstance();
+
+ private List<WindowDetails> childWindows = null;
+ private WindowDetails parent = null;
+
+ /// <summary>
+ /// The window handle.
+ /// </summary>
+ private IntPtr hWnd = IntPtr.Zero;
+
+ /// <summary>
+ /// To allow items to be compared, the hash code
+ /// is set to the Window handle, so two EnumWindowsItem
+ /// objects for the same Window will be equal.
+ /// </summary>
+ /// <returns>The Window Handle for this window</returns>
+ public override int GetHashCode() {
+ return Handle.ToInt32();
+ }
+
+ public override bool Equals(object right) {
+ return this.Equals(right as WindowDetails);
+ }
+
+ public bool Equals(WindowDetails other) {
+ if (Object.ReferenceEquals(other, null)) {
+ return false;
+ }
+
+ if (Object.ReferenceEquals(this, other)) {
+ return true;
+ }
+
+ if (this.GetType() != other.GetType()){
+ return false;
+ }
+ return other.Handle == Handle;
+ }
+
+ public bool HasChildren {
+ get {
+ return (childWindows != null) && (childWindows.Count > 0);
+ }
+ }
+
+ public List<WindowDetails> Children {
+ get {
+ if (childWindows == null) {
+ GetChildren();
+ }
+ return childWindows;
+ }
+ }
+
+ /// <summary>
+ /// Retrieve all windows with a certain title or classname
+ /// </summary>
+ /// <param name="titlePattern">The regexp to look for in the title</param>
+ /// <param name="classnamePattern">The regexp to look for in the classname</param>
+ /// <returns>List<WindowDetails> with all the found windows</returns>
+ private static List<WindowDetails> FindWindow(List<WindowDetails> windows, string titlePattern, string classnamePattern) {
+ List<WindowDetails> foundWindows = new List<WindowDetails>();
+ Regex titleRegexp = null;
+ Regex classnameRegexp = null;
+
+ if (titlePattern != null && titlePattern.Trim().Length > 0) {
+ titleRegexp = new Regex(titlePattern);
+ }
+ if (classnamePattern != null && classnamePattern.Trim().Length > 0) {
+ classnameRegexp = new Regex(classnamePattern);
+ }
+
+ foreach(WindowDetails window in windows) {
+ if (titleRegexp != null && titleRegexp.IsMatch(window.Text)) {
+ foundWindows.Add(window);
+ } else if (classnameRegexp != null && classnameRegexp.IsMatch(window.ClassName)) {
+ foundWindows.Add(window);
+ }
+ }
+ return foundWindows;;
+ }
+
+ /// <summary>
+ /// Retrieve the child with mathing classname
+ /// </summary>
+ public WindowDetails GetChild(string childClassname) {
+ foreach(WindowDetails child in Children) {
+ if (childClassname.Equals(child.ClassName)) {
+ return child;
+ }
+ }
+ return null;
+ }
+
+ /// <summary>
+ /// Get the parent of the current window
+ /// </summary>
+ /// <returns>WindowDetails of the parent, or null if none</returns>
+ public WindowDetails GetParent() {
+ if (parent == null) {
+ IntPtr parenthWnd = User32.GetParent(Handle);
+ if (parenthWnd != IntPtr.Zero) {
+ parent = new WindowDetails(parenthWnd);
+ }
+
+ }
+ return parent;
+ }
+
+ /// <summary>
+ /// Retrieve all the children, this only stores the children internally, use the "Children" property for the value
+ /// </summary>
+ public void GetChildren() {
+ childWindows = new List<WindowDetails>();
+ WindowsEnumerator windowsEnumerator = new WindowsEnumerator();
+ windowsEnumerator.GetWindows(hWnd);
+ foreach(WindowDetails childWindow in windowsEnumerator.Items) {
+ // Copy "Parent title"
+ if (childWindow.Text != null && childWindow.Text.Trim().Length == 0) {
+ childWindow.Text = Text;
+ }
+ childWindow.parent = this;
+ childWindows.Add(childWindow);
+ }
+ }
+
+ /// <summary>
+ /// Retrieve children with a certain title or classname
+ /// </summary>
+ /// <param name="titlePattern">The regexp to look for in the title</param>
+ /// <param name="classnamePattern">The regexp to look for in the classname</param>
+ /// <returns>List<WindowDetails> with all the found windows, or an emptry list</returns>
+ public List<WindowDetails> FindChildren(string titlePattern, string classnamePattern) {
+ return FindWindow(Children, titlePattern, classnamePattern);
+ }
+
+ /// <summary>
+ /// Recursing helper method for the FindPath
+ /// </summary>
+ /// <param name="classnames">List<string> with classnames</param>
+ /// <param name="index">The index in the list to look for</param>
+ /// <returns>WindowDetails if a match was found</returns>
+ private WindowDetails FindPath(List<string> classnames, int index) {
+ WindowDetails resultWindow = null;
+ List<WindowDetails> foundWindows = FindChildren(null, classnames[index]);
+ if (index == classnames.Count - 1) {
+ if (foundWindows.Count > 0) {
+ resultWindow = foundWindows[0];
+ }
+ } else {
+ foreach(WindowDetails foundWindow in foundWindows) {
+ resultWindow = foundWindow.FindPath(classnames, index+1);
+ if (resultWindow != null) {
+ break;
+ }
+ }
+ }
+ return resultWindow;
+ }
+
+ /// <summary>
+ /// This method will find the child window according to a path of classnames.
+ /// Usually used for finding a certain "content" window like for the IE Browser
+ /// </summary>
+ /// <param name="classnames">List<string> with classname "path"</param>
+ /// <param name="allowSkip">true allows the search to skip a classname of the path</param>
+ /// <returns>WindowDetails if found</returns>
+ public WindowDetails FindPath(List<string> classnames, bool allowSkip) {
+ int index = 0;
+ WindowDetails resultWindow = FindPath(classnames, index++);
+ if (resultWindow == null && allowSkip) {
+ while(resultWindow == null && index < classnames.Count) {
+ resultWindow = FindPath(classnames, index);
+ }
+ }
+ return resultWindow;
+ }
+
+ /// <summary>
+ /// Deep scan for a certain classname pattern
+ /// </summary>
+ /// <param name="classnamePattern">Classname regexp pattern</param>
+ /// <returns>The first WindowDetails found</returns>
+ public static WindowDetails DeepScan(WindowDetails windowDetails, Regex classnamePattern) {
+ if (classnamePattern.IsMatch(windowDetails.ClassName)) {
+ return windowDetails;
+ }
+ // First loop through this level
+ foreach(WindowDetails child in windowDetails.Children) {
+ if (classnamePattern.IsMatch(child.ClassName)) {
+ return child;
+ }
+ }
+ // Go into all children
+ foreach(WindowDetails child in windowDetails.Children) {
+ WindowDetails deepWindow = DeepScan(child, classnamePattern);
+ if (deepWindow != null) {
+ return deepWindow;
+ }
+ }
+ return null;
+ }
+
+ /// <summary>
+ /// GetWindow
+ /// </summary>
+ /// <param name="gwCommand">The GetWindowCommand to use</param>
+ /// <returns>null if nothing found, otherwise the WindowDetails instance of the "child"</returns>
+ public WindowDetails GetWindow(GetWindowCommand gwCommand) {
+ IntPtr tmphWnd = User32.GetWindow(Handle, gwCommand);
+ WindowDetails windowDetails = new WindowDetails(tmphWnd);
+ windowDetails.parent = this;
+ return windowDetails;
+ }
+
+ /// <summary>
+ /// Gets the window's handle
+ /// </summary>
+ public IntPtr Handle {
+ get {
+ return this.hWnd;
+ }
+ }
+
+ private string text = null;
+ /// <summary>
+ /// Gets the window's title (caption)
+ /// </summary>
+ public string Text {
+ set {
+ text = value;
+ }
+ get {
+ if (text == null) {
+ StringBuilder title = new StringBuilder(260, 260);
+ User32.GetWindowText(this.hWnd, title, title.Capacity);
+ text = title.ToString();
+ }
+ return text;
+ }
+ }
+
+ private string className = null;
+ /// <summary>
+ /// Gets the window's class name.
+ /// </summary>
+ public string ClassName {
+ get {
+ if (className == null) {
+ StringBuilder classNameBuilder = new StringBuilder(260, 260);
+ User32.GetClassName(this.hWnd, classNameBuilder, classNameBuilder.Capacity);
+ className = classNameBuilder.ToString();
+ }
+ return className;
+ }
+ }
+
+ /// <summary>
+ /// Gets/Sets whether the window is iconic (mimimised) or not.
+ /// </summary>
+ public bool Iconic {
+ get {
+ return User32.IsIconic(this.hWnd) || Location.X <= -32000;
+ }
+ set {
+ User32.SendMessage(
+ this.hWnd,
+ User32.WM_SYSCOMMAND,
+ (IntPtr)User32.SC_MINIMIZE,
+ IntPtr.Zero);
+ }
+ }
+
+ /// <summary>
+ /// Gets/Sets whether the window is maximised or not.
+ /// </summary>
+ public bool Maximised {
+ get {
+ return User32.IsZoomed(this.hWnd);
+ }
+ set {
+ User32.SendMessage(
+ this.hWnd,
+ User32.WM_SYSCOMMAND,
+ (IntPtr)User32.SC_MAXIMIZE,
+ IntPtr.Zero);
+ }
+ }
+
+ /// <summary>
+ /// Gets whether the window is visible.
+ /// </summary>
+ public bool Visible {
+ get {
+ return User32.IsWindowVisible(this.hWnd);
+ }
+ }
+
+ public IntPtr ProcessId {
+ get {
+ IntPtr processId;
+ User32.GetWindowThreadProcessId(Handle, out processId);
+ return processId;
+ }
+ }
+
+ /// <summary>
+ /// Gets the bounding rectangle of the window
+ /// </summary>
+ public Rectangle ClientRectangle {
+ get {
+ Rectangle clientRect = Rectangle.Empty;
+
+ if (parent == null && DWM.isDWMEnabled()) {
+ GetExtendedFrameBounds(out clientRect);
+ }
+ if (clientRect.IsEmpty) {
+ GetClientRect(out clientRect);
+ }
+
+ if (this.Maximised) {
+ Size size = Size.Empty;
+ GetBorderSize(out size);
+ return new Rectangle(clientRect.X + size.Width, clientRect.Y + size.Height, clientRect.Width - (2 * size.Width), clientRect.Height - (2 * size.Height));
+ }
+ return clientRect;
+ }
+ }
+
+ /// <summary>
+ /// Gets the location of the window relative to the screen.
+ /// </summary>
+ public Point Location {
+ get {
+ Rectangle tmpRectangle = ClientRectangle;
+ return new Point(tmpRectangle.Left, tmpRectangle.Top);
+ }
+ }
+
+ /// <summary>
+ /// Gets the size of the window.
+ /// </summary>
+ public Size Size {
+ get {
+ Rectangle tmpRectangle = ClientRectangle;
+ return new Size(tmpRectangle.Right - tmpRectangle.Left, tmpRectangle.Bottom - tmpRectangle.Top);
+ }
+ }
+
+ /// <summary>
+ /// Restores and Brings the window to the front,
+ /// assuming it is a visible application window.
+ /// </summary>
+ public void Restore() {
+ if (Iconic) {
+ User32.SendMessage(this.hWnd, User32.WM_SYSCOMMAND, (IntPtr)User32.SC_RESTORE, IntPtr.Zero);
+ }
+ User32.BringWindowToTop(this.hWnd);
+ User32.SetForegroundWindow(this.hWnd);
+ // Make sure windows has time to perform the action
+ Thread.Sleep(100);
+ }
+
+ public WindowStyleFlags WindowStyle {
+ get {
+ return (WindowStyleFlags)User32.GetWindowLong(this.hWnd, User32.GWL_STYLE);
+ }
+ }
+
+ public WindowPlacement GetWindowPlacement() {
+ WindowPlacement placement = WindowPlacement.Default;
+ User32.GetWindowPlacement(this.Handle, ref placement);
+ return placement;
+ }
+
+ public void SetWindowPlacement(WindowPlacement placement) {
+ User32.SetWindowPlacement(this.Handle, ref placement);
+ }
+
+ public ExtendedWindowStyleFlags ExtendedWindowStyle {
+ get {
+ return (ExtendedWindowStyleFlags)User32.GetWindowLong(this.hWnd, User32.GWL_EXSTYLE);
+ }
+ }
+
+ /// <summary>
+ /// Capture Window with GDI+
+ /// </summary>
+ /// <param name="capture">The capture to fill</param>
+ /// <returns>ICapture</returns>
+ public ICapture CaptureWindow(ICapture capture) {
+ if (capture == null) {
+ capture = new Capture();
+ }
+ capture.Image = PrintWindow();
+ capture.Location = Location;
+ return capture;
+ }
+
+ /// <summary>
+ /// Capture DWM Window
+ /// </summary>
+ /// <param name="capture"></param>
+ /// <returns></returns>
+ public ICapture CaptureDWMWindow(ICapture capture, WindowCaptureMode windowCaptureMode) {
+ if (capture == null) {
+ capture = new Capture();
+ }
+
+ // Prepare the form to copy from
+ using (Form tempForm = new Form()) {
+ tempForm.ShowInTaskbar = false;
+ tempForm.FormBorderStyle = FormBorderStyle.None;
+ tempForm.TopMost = true;
+ // Transparent would give an error here
+ if (windowCaptureMode == WindowCaptureMode.Aero) {
+ Color formColor = conf.DWMBackgroundColor;
+ // Remove transparency, this will break the capturing
+ formColor = Color.FromArgb(255, formColor.R, formColor.G, formColor.B);
+ tempForm.BackColor = formColor;
+ } else {
+ // Make sure the user sees transparent when going into the color picker
+ conf.DWMBackgroundColor = Color.Transparent;
+ // Use white, later black to capture transparent
+ tempForm.BackColor = Color.White;
+ }
+
+ // Register the Thumbnail
+ IntPtr thumbnailHandle;
+ DWM.DwmRegisterThumbnail(tempForm.Handle, Handle, out thumbnailHandle);
+
+ // Get the original size
+ SIZE sourceSize;
+ DWM.DwmQueryThumbnailSourceSize(thumbnailHandle, out sourceSize);
+
+ if (sourceSize.cx <= 0 || sourceSize.cy <= 0) {
+ return null;
+ }
+
+ // Calculate the location of the temp form
+ Point formLocation;
+ Rectangle windowRectangle;
+ Size borderSize = new Size();
+ // Get the Location/size with DWM (should work, as we are making a DWM Capture)
+ if (!GetExtendedFrameBounds(out windowRectangle)) {
+ // Fallback
+ GetClientRect(out windowRectangle);
+ }
+
+ if (!Maximised) {
+ Screen displayScreen = null;
+
+ // Find the screen where the window is in
+ foreach(Screen screen in Screen.AllScreens) {
+ if (screen.WorkingArea.Contains(windowRectangle)) {
+ displayScreen = screen;
+ }
+ }
+ // If none found we check which screen it will fit...
+ if (displayScreen == null) {
+ foreach(Screen screen in Screen.AllScreens) {
+ if (displayScreen == null || (screen.Bounds.Width >= displayScreen.Bounds.Width && screen.Bounds.Height >= displayScreen.Bounds.Height)) {
+ displayScreen = screen;
+ }
+ }
+ // Found one?
+ if (displayScreen != null) {
+ formLocation = new Point(displayScreen.Bounds.X, displayScreen.Bounds.Y);
+ } else {
+ // No, just use the primary screen
+ formLocation = new Point(Screen.PrimaryScreen.Bounds.X, Screen.PrimaryScreen.Bounds.Y);
+ }
+ } else {
+ // The window actually fits, so while capturing create the copy over the original
+ formLocation = new Point(windowRectangle.X, windowRectangle.Y);
+ }
+ } else {
+ //GetClientRect(out windowRectangle);
+ GetBorderSize(out borderSize);
+ formLocation = new Point(windowRectangle.X, windowRectangle.Y);
+ }
+
+ tempForm.Location = formLocation;
+ tempForm.Size = sourceSize.ToSize();
+ // Make sure the to be captured window is active, important for the close/resize buttons
+ this.Restore();
+
+ // Prepare the displaying of the Thumbnail
+ DWM_THUMBNAIL_PROPERTIES props = new DWM_THUMBNAIL_PROPERTIES();
+ props.Opacity = (byte)255;
+ props.Visible = true;
+ props.Destination = new RECT(0, 0, sourceSize.cx, sourceSize.cy);
+ DWM.DwmUpdateThumbnailProperties(thumbnailHandle, ref props);
+ tempForm.Show();
+
+ // Wait, to make sure everything is visible
+ Thread.Sleep(250);
+
+ // Prepare rectangle to capture from the screen.
+ Rectangle captureRectangle = new Rectangle(formLocation.X, formLocation.Y, sourceSize.cx, sourceSize.cy);
+ if (Maximised) {
+ // Correct capture size for maximized window by offsetting the X,Y with the border size
+ captureRectangle.X += borderSize.Width;
+ captureRectangle.Y += borderSize.Height;
+ // and subtrackting the border from the size (2 times, as we move right/down for the capture without resizing)
+ captureRectangle.Width -= 2 * borderSize.Width;
+ captureRectangle.Height -= 2 * borderSize.Height;
+ }
+
+ // Destination bitmap for the capture
+ Bitmap capturedBitmap = null;
+ // Check if we make a transparent capture
+ if (windowCaptureMode == WindowCaptureMode.AeroTransparent) {
+ try {
+ this.FreezeWindow();
+ using (Bitmap whiteBitmap = WindowCapture.CaptureRectangle(captureRectangle)) {
+ // Apply a white color
+ tempForm.BackColor = Color.Black;
+ // Refresh the form, otherwise the color doesn't show.
+ tempForm.Refresh();
+ using (Bitmap blackBitmap = WindowCapture.CaptureRectangle(captureRectangle)) {
+ capturedBitmap = ApplyTransparency(blackBitmap, whiteBitmap);
+ }
+ }
+ } catch (Exception e) {
+ LOG.Debug("Exception: ", e);
+ // Some problem occured, cleanup and make a normal capture
+ if (capturedBitmap != null) {
+ capturedBitmap.Dispose();
+ capturedBitmap = null;
+ }
+ } finally {
+ // Make sure to ALWAYS unfreeze!!
+ this.UnfreezeWindow();
+ }
+ }
+ // If no capture up till now, create a normal capture.
+ if (capturedBitmap == null) {
+ // Capture from the screen
+ capturedBitmap = WindowCapture.CaptureRectangle(captureRectangle);
+ }
+ // Unregister (cleanup), as we are finished we don't need the form or the thumbnail anymore
+ DWM.DwmUnregisterThumbnail(thumbnailHandle);
+ tempForm.Close();
+
+ capture.Image = capturedBitmap;
+ // Make sure the capture location is the location of the window, not the copy
+ capture.Location = Location;
+ }
+
+ return capture;
+ }
+
+ /// <summary>
+ /// Apply transparency by comparing a transparent capture with a black and white background
+ /// A "Math.min" makes sure there is no overflow, but this could cause the picture to have shifted colors.
+ /// The pictures should have been taken without differency, exect for the colors.
+ /// </summary>
+ /// <param name="blackBitmap">Bitmap with the black image</param>
+ /// <param name="whiteBitmap">Bitmap with the black image</param>
+ /// <returns>Bitmap with transparency</returns>
+ private Bitmap ApplyTransparency(Bitmap blackBitmap, Bitmap whiteBitmap) {
+ Bitmap returnBitmap = new Bitmap(blackBitmap.Width, blackBitmap.Height, PixelFormat.Format32bppArgb);
+ using (BitmapBuffer blackBuffer = new BitmapBuffer(blackBitmap, false)) {
+ blackBuffer.Lock();
+ using (BitmapBuffer whiteBuffer = new BitmapBuffer(whiteBitmap, false)) {
+ whiteBuffer.Lock();
+ using (BitmapBuffer targetBuffer = new BitmapBuffer(returnBitmap, false)) {
+ targetBuffer.Lock();
+ for(int y=0; y<blackBuffer.Height;y++) {
+ for(int x=0; x<blackBuffer.Width;x++) {
+ Color c0 = blackBuffer.GetColorAt(x,y);
+ Color c1 = whiteBuffer.GetColorAt(x,y);
+ // Calculate alpha as double in range 0-1
+ double alpha = (c0.R - c1.R + 255) / 255d;
+ if (alpha == 1) {
+ // Alpha == 1 means no change!
+ targetBuffer.SetColorAt(x, y, c0);
+ } else if (alpha == 0) {
+ // Complete transparency, use transparent pixel
+ targetBuffer.SetColorAt(x, y, Color.Transparent);
+ } else {
+ // Calculate original color
+ byte originalAlpha = (byte)Math.Min(255, alpha * 255);
+ //LOG.DebugFormat("Alpha {0} & c0 {1} & c1 {2}", alpha, c0, c1);
+ byte originalRed = (byte)Math.Min(255, c0.R / alpha);
+ byte originalGreen = (byte)Math.Min(255, c0.G / alpha);
+ byte originalBlue = (byte)Math.Min(255, c0.B / alpha);
+ Color originalColor = Color.FromArgb(originalAlpha, originalRed, originalGreen, originalBlue);
+ //Color originalColor = Color.FromArgb(originalAlpha, originalRed, c0.G, c0.B);
+ targetBuffer.SetColorAt(x, y, originalColor);
+ }
+ }
+ }
+ }
+ }
+ }
+ return returnBitmap;
+ }
+
+ /// <summary>
+ /// Helper method to get the window size for DWM Windows
+ /// </summary>
+ /// <param name="rectangle">out Rectangle</param>
+ /// <returns>bool true if it worked</returns>
+ private bool GetExtendedFrameBounds(out Rectangle rectangle) {
+ RECT rect;
+ int result = DWM.DwmGetWindowAttribute(Handle, (int)DWMWINDOWATTRIBUTE.DWMWA_EXTENDED_FRAME_BOUNDS, out rect, Marshal.SizeOf(typeof(RECT)));
+ if (result >= 0) {
+ rectangle = rect.ToRectangle();
+ return true;
+ }
+ rectangle = Rectangle.Empty;
+ return false;
+ }
+
+ /// <summary>
+ /// Helper method to get the window size for GDI Windows
+ /// </summary>
+ /// <param name="rectangle">out Rectangle</param>
+ /// <returns>bool true if it worked</returns>
+ private bool GetClientRect(out Rectangle rectangle) {
+ WindowInfo windowInfo = new WindowInfo();
+ // Get the Window Info for this window
+ bool result = User32.GetWindowInfo(Handle, ref windowInfo);
+ if (result) {
+ rectangle = windowInfo.rcWindow.ToRectangle();
+ } else {
+ rectangle = Rectangle.Empty;
+ }
+ return result;
+ }
+
+ /// <summary>
+ /// Helper method to get the Border size for GDI Windows
+ /// </summary>
+ /// <param name="rectangle">out Rectangle</param>
+ /// <returns>bool true if it worked</returns>
+ private bool GetBorderSize(out Size size) {
+ WindowInfo windowInfo = new WindowInfo();
+ // Get the Window Info for this window
+ bool result = User32.GetWindowInfo(Handle, ref windowInfo);
+ if (result) {
+ size = new Size((int)windowInfo.cxWindowBorders, (int)windowInfo.cyWindowBorders);
+ } else {
+ size = Size.Empty;
+ }
+ return result;
+ }
+
+ /// <summary>
+ /// Set the window as foreground window
+ /// </summary>
+ public static void ToForeground(IntPtr handle) {
+ User32.SetForegroundWindow(handle);
+ }
+
+ /// <summary>
+ /// Set the window as foreground window
+ /// </summary>
+ public void ToForeground() {
+ ToForeground(this.Handle);
+ }
+
+ /// <summary>
+ /// Get the region for a window
+ /// </summary>
+ private Region GetRegion() {
+ IntPtr windowRegionPtr = GDI32.CreateRectRgn(0,0,0,0);
+ RegionResult result = User32.GetWindowRgn(Handle, windowRegionPtr);
+ if (result != RegionResult.REGION_ERROR && result != RegionResult.REGION_NULLREGION) {
+ return Region.FromHrgn(windowRegionPtr);
+ }
+ return null;
+ }
+
+ /// <summary>
+ /// PrintWindow but with VScroll loop
+ /// </summary>
+ /// <returns>Image with all the scroll contents</returns>
+ public Image PrintWithVScroll() {
+ SCROLLINFO scrollinfo = new SCROLLINFO();
+ scrollinfo.cbSize = Marshal.SizeOf( scrollinfo );
+ scrollinfo.fMask = (int) ScrollInfoMask.SIF_ALL;
+ User32.GetScrollInfo(Handle, (int) ScrollBarDirection.SB_VERT, ref scrollinfo );
+
+ LOG.DebugFormat("nMax {0}", scrollinfo.nMax);
+ LOG.DebugFormat("nMin {0}", scrollinfo.nMin);
+ LOG.DebugFormat("nPage {0}", scrollinfo.nPage);
+ LOG.DebugFormat("nPos {0}", scrollinfo.nPos);
+ LOG.DebugFormat("nTrackPos {0}", scrollinfo.nTrackPos);
+
+ Rectangle clientRectangle = ClientRectangle;
+ int pages = ((scrollinfo.nMax+1) / scrollinfo.nPage);
+ int width = clientRectangle.Width;
+ int height = clientRectangle.Height * pages;
+ Bitmap returnBitmap = new Bitmap(width, height, PixelFormat.Format32bppArgb);
+ using (Graphics graphicsTarget = Graphics.FromImage(returnBitmap)) {
+ for(int page=0; page<pages; page++) {
+ VScroll(page * scrollinfo.nPage);
+ Thread.Sleep(200);
+ using (Image printedWindow = PrintWindow()) {
+ if (printedWindow != null) {
+ graphicsTarget.DrawImage(printedWindow, new Point(0, clientRectangle.Height * page));
+ graphicsTarget.Flush();
+ }
+ }
+ }
+ }
+ return returnBitmap;
+ }
+
+ /// <summary>
+ /// Does the window have a HScrollbar?
+ /// </summary>
+ /// <returns>true if a HScrollbar is available</returns>
+ public bool hasHScroll() {
+ return (WindowStyle & WindowStyleFlags.WS_HSCROLL) == WindowStyleFlags.WS_HSCROLL;
+ }
+
+ /// <summary>
+ /// Does the window have a VScrollbar?
+ /// </summary>
+ /// <returns>true if a VScrollbar is available</returns>
+ public bool hasVScroll() {
+ return (WindowStyle & WindowStyleFlags.WS_VSCROLL) == WindowStyleFlags.WS_VSCROLL;
+ }
+
+ /// <summary>
+ /// Scroll the window to the hpos location
+ /// </summary>
+ /// <param name="hpos"></param>
+ public void HScroll(int hpos) {
+ User32.SetScrollPos(Handle, Orientation.Horizontal, hpos, true);
+ User32.PostMessage(Handle, (int)WindowsMessages.WM_HSCROLL, (int)ScrollbarCommand.SB_THUMBPOSITION + (hpos<<16), 0);
+ }
+
+ /// <summary>
+ /// Scroll the window to the vpos location
+ /// </summary>
+ /// <param name="vpos"></param>
+ public void VScroll(int vpos) {
+ User32.SetScrollPos(Handle, Orientation.Vertical, vpos, true);
+ User32.PostMessage(Handle, (int)WindowsMessages.WM_VSCROLL, (int)ScrollbarCommand.SB_THUMBPOSITION + (vpos<<16), 0);
+ }
+
+ /// <summary>
+ /// Freezes the process belonging to the window
+ /// Warning: Use only if no other way!!
+ /// </summary>
+ private void FreezeWindow() {
+ Process proc = Process.GetProcessById(this.ProcessId.ToInt32());
+
+ if (proc.ProcessName == string.Empty){
+ return;
+ }
+ if (proc.ProcessName.ToLower().Contains("greenshot")) {
+ LOG.DebugFormat("Not freezing ourselves, process was: {0}", proc.ProcessName);
+ return;
+ }
+ LOG.DebugFormat("Freezing process: {0}", proc.ProcessName);
+
+ foreach (ProcessThread pT in proc.Threads) {
+ IntPtr pOpenThread = Kernel32.OpenThread(ThreadAccess.SUSPEND_RESUME, false, (uint)pT.Id);
+
+ if (pOpenThread == IntPtr.Zero) {
+ break;
+ }
+
+ Kernel32.SuspendThread(pOpenThread);
+ }
+ }
+
+ /// <summary>
+ /// Unfreeze the process belonging to the window
+ /// </summary>
+ public void UnfreezeWindow() {
+ Process proc = Process.GetProcessById(this.ProcessId.ToInt32());
+
+ if (proc.ProcessName == string.Empty) {
+ return;
+ }
+ if (proc.ProcessName.ToLower().Contains("greenshot")) {
+ LOG.DebugFormat("Not unfreezing ourselves, process was: {0}", proc.ProcessName);
+ return;
+ }
+ LOG.DebugFormat("Unfreezing process: {0}", proc.ProcessName);
+
+ foreach (ProcessThread pT in proc.Threads) {
+ IntPtr pOpenThread = Kernel32.OpenThread(ThreadAccess.SUSPEND_RESUME, false, (uint)pT.Id);
+
+ if (pOpenThread == IntPtr.Zero) {
+ break;
+ }
+
+ Kernel32.ResumeThread(pOpenThread);
+ }
+ }
+
+ /// <summary>
+ /// Return an Image representating the Window!
+ /// As GDI+ draws it, it will be without Aero borders!
+ /// </summary>
+ public Image PrintWindow() {
+ Rectangle clientRect = Rectangle.Empty;
+ GetClientRect(out clientRect);
+
+ // Start the capture
+ bool printSucceeded = true;
+ Region region = GetRegion();
+ PixelFormat pixelFormat = PixelFormat.Format24bppRgb;
+ // Only use 32 bpp ARGB when the window has a region
+ if (region != null) {
+ pixelFormat = PixelFormat.Format32bppArgb;
+ }
+ Image returnImage = new Bitmap(clientRect.Width, clientRect.Height, pixelFormat);
+ using (Graphics graphics = Graphics.FromImage(returnImage)) {
+ IntPtr hDCDest = graphics.GetHdc();
+ printSucceeded = User32.PrintWindow(Handle, hDCDest, 0x0);
+ graphics.ReleaseHdc(hDCDest);
+
+ // Apply the region "transparency"
+ if (region != null && !region.IsEmpty(graphics)) {
+ graphics.ExcludeClip(region);
+ graphics.Clear(Color.Transparent);
+ }
+
+ graphics.Flush();
+ }
+
+ // Return null if error
+ if (!printSucceeded) {
+ LOG.Debug("Error??");
+ returnImage.Dispose();
+ return null;
+ }
+ if (this.Maximised) {
+ LOG.Debug("Correcting for maximalization");
+ Size size = Size.Empty;
+ GetBorderSize(out size);
+ Rectangle borderRectangle = new Rectangle(size.Width, size.Height, clientRect.Width - (2 * size.Width), clientRect.Height - (2 * size.Height));
+ ImageHelper.Crop(ref returnImage, ref borderRectangle);
+ }
+ return returnImage;
+ }
+
+ /// <summary>
+ /// Constructs a new instance of this class for
+ /// the specified Window Handle.
+ /// </summary>
+ /// <param name="hWnd">The Window Handle</param>
+ public WindowDetails(IntPtr hWnd) {
+ this.hWnd = hWnd;
+ }
+
+ /// <summary>
+ /// Gets an instance of the current active foreground window
+ /// </summary>
+ /// <returns>WindowDetails of the current window</returns>
+ public static WindowDetails GetActiveWindow() {
+ IntPtr hWnd = User32.GetForegroundWindow();
+ if (hWnd != null && hWnd != IntPtr.Zero) {
+ return new WindowDetails(hWnd);
+ }
+ return null;
+ }
+
+ /// <summary>
+ /// Gets the Destop window
+ /// </summary>
+ /// <returns>WindowDetails for the destop window</returns>
+ public static WindowDetails GetDesktopWindow() {
+ return new WindowDetails(User32.GetDesktopWindow());
+ }
+
+ /// <summary>
+ /// Get all the top level windows
+ /// </summary>
+ /// <returns>List<WindowDetails> with all the top level windows</returns>
+ public static List<WindowDetails> GetAllWindows() {
+ return GetAllWindows(null);
+ }
+
+ /// <summary>
+ /// Get all the top level windows, with matching classname
+ /// </summary>
+ /// <returns>List<WindowDetails> with all the top level windows</returns>
+ public static List<WindowDetails> GetAllWindows(string classname) {
+ List<WindowDetails> windows = new List<WindowDetails>();
+ WindowsEnumerator windowsEnumerator = new WindowsEnumerator();
+ windowsEnumerator.GetWindows();
+ foreach(WindowDetails window in windowsEnumerator.Items) {
+ if (classname == null || window.ClassName.Equals(classname)) {
+ windows.Add(window);
+ }
+ }
+ return windows;
+ }
+
+ /// <summary>
+ /// Get all the visible top level windows
+ /// </summary>
+ /// <returns>List<WindowDetails> with all the visible top level windows</returns>
+ public static List<WindowDetails> GetVisibleWindows() {
+ List<WindowDetails> windows = new List<WindowDetails>();
+ List<WindowDetails> allWindows = WindowDetails.GetAllWindows();
+ foreach(WindowDetails window in allWindows) {
+ // Ignore windows without title
+ if (window.Text.Length == 0) {
+ continue;
+ }
+ // Ignore invisible
+ if (!window.Visible) {
+ continue;
+ }
+ // Ignore some classes
+ List<string> ignoreClasses = new List<string>(new string[] {"Progman", "XLMAIN", "Button"}); //"MS-SDIa"
+ if (ignoreClasses.Contains(window.ClassName)) {
+ continue;
+ }
+ // Ignore us
+ if (window.Text.Equals(lang.GetString(LangKey.application_title))) {
+ continue;
+ }
+ // Windows without size
+ Size windowSize = window.ClientRectangle.Size;
+ if (windowSize.Width == 0 || windowSize.Height == 0) {
+ continue;
+ }
+ windows.Add(window);
+ }
+ return windows;
+ }
+
+ /// <summary>
+ /// Find a window belonging to the same process as the supplied window.
+ /// </summary>
+ /// <param name="windowToLinkTo"></param>
+ /// <returns></returns>
+ public static WindowDetails GetLinkedWindow(WindowDetails windowToLinkTo) {
+ IntPtr processIdSelectedWindow = windowToLinkTo.ProcessId;
+ foreach(WindowDetails window in WindowDetails.GetAllWindows()) {
+ // Ignore windows without title
+ if (window.Text.Length == 0) {
+ continue;
+ }
+ // Ignore invisible
+ if (!window.Visible) {
+ continue;
+ }
+ if (window.Handle == windowToLinkTo.Handle) {
+ continue;
+ }
+ if (window.Iconic) {
+ continue;
+ }
+
+ // Windows without size
+ Size windowSize = window.ClientRectangle.Size;
+ if (windowSize.Width == 0 || windowSize.Height == 0) {
+ continue;
+ }
+
+ if (window.ProcessId == processIdSelectedWindow) {
+ LOG.InfoFormat("Found window {0} belonging to same process as the window {1}", window.Text, windowToLinkTo.Text);
+ return window;
+ }
+ }
+ return null;
+ }
+
+ /// <summary>
+ /// Helper method to "active" all windows that are not in the supplied list.
+ /// One should preferably call "GetVisibleWindows" for the oldWindows.
+ /// </summary>
+ /// <param name="oldWindows">List<WindowDetails> with old windows</param>
+ public static void ActiveNewerWindows(List<WindowDetails> oldWindows) {
+ List<WindowDetails> windowsAfter = WindowDetails.GetVisibleWindows();
+ foreach(WindowDetails window in windowsAfter) {
+ if (!oldWindows.Contains(window)) {
+ window.ToForeground();
+ }
+ }
+ }
+ }
+ #endregion
+}
diff --git a/Greenshot/Language.cs b/Greenshot/Language.cs
new file mode 100644
index 000000000..ccead6ad4
--- /dev/null
+++ b/Greenshot/Language.cs
@@ -0,0 +1,39 @@
+
+using System;
+using System.Resources;
+using System.Globalization;
+using System.Threading;
+using Greenshot.Configuration;
+using System.Diagnostics;
+
+
+namespace Greenshot
+{
+ /// <summary>
+ /// Description of Language.
+ /// </summary>
+ public class Language
+ {
+ private ResourceManager rm;
+ private static Language uniqueInstance;
+ private Language() {
+ rm = new ResourceManager("Greenshot.UI", System.Reflection.Assembly.GetExecutingAssembly());
+ SetLanguage(AppConfig.GetInstance().Ui_Language);
+ }
+
+ public static Language GetInstance() {
+ if(uniqueInstance == null) {
+ uniqueInstance = new Language();
+ }
+ return uniqueInstance;
+
+ }
+ public void SetLanguage(string cultureInfo) {
+ Thread.CurrentThread.CurrentUICulture = new CultureInfo(cultureInfo);
+ }
+ public string GetString(string id) {
+ string s = rm.GetString(id);
+ return (s != null) ? s : "string ###"+id+"### not found";
+ }
+ }
+}
diff --git a/Greenshot/Languages/help-de-DE.html b/Greenshot/Languages/help-de-DE.html
new file mode 100644
index 000000000..238491793
--- /dev/null
+++ b/Greenshot/Languages/help-de-DE.html
@@ -0,0 +1,355 @@
+
+<html>
+ <head>
+ <title>Greenshot Hilfe
+
+
+
+
+ Greenshot Hilfe
+
+ Version 0.8
+
+ Inhalt
+
+ - Erstellung eines Screenshots
+
+ - Bereich abfotografieren
+ - Zuletzt gewhlten Bereich abfotografieren
+ - Fenster abfotografieren
+ - Kompletten Bildschirm abfotografieren
+
+
+ - Verwendung des Bildeditors
+
+ - Formen zeichnen
+ - Text hinzufgen
+ - Hervorheben
+ - Unkenntlich machen
+ - Screenshot zuschneiden
+ - Elemente wiederverwenden
+ - Screenshot exportieren
+
+ - Der Einstellungen-Dialog
+
+ - Allgemeine Einstellungen
+ - Ausgabeeinstellungen
+ - Druckereinstellungen
+
+ - Wollen Sie Greenshot untersttzen?
+
+ - Spenden
+ - Weitersagen
+ - bersetzen
+
+
+
+
+ Erstellung eines Screenshots
+
+ Zum Erstellen eines Screenshots knnen Sie entweder die Drucken-Taste
+ verwenden oder sie klicken das Greenshot-Icon im Systray mit der rechten Maustaste.
+ Es gibt verschiedene Optionen bei der Erstellung eines Screenshots:
+
+
+
+ Bereich abfotografieren Drucken
+
+ Im Bereichsmodus knnen sie einen Bildschirmbereich auswhlen, der abfotografiert
+ werden soll.
+ Nach dem Starten des Bereichsmodus sehen Sie ein Fadenkreuz, das die Position
+ des Mousecursors auf dem Bildschirm anzeigt. Klicken und halten sie die linke
+ Maustaste an der Stelle, wo eine der Ecken Ihres Screenshots liegen soll.
+ Halten Sie die Maustaste gedrckt, whrend sie die Maus bewegen, um das Rechteck
+ zu markieren, von dem ein Screenshot erstellt werden soll. Wenn das grne Rechteck
+ den Bereich bedeckt, den Sie aufnehmen wollen, lassen sie die Maustaste los.
+
+
+ Mit Hilfe der Leertaste knnen sie vom Bereichsmodus in den
+ Fenstermodus wechseln (und umgekehrt).
+
+
+ Wenn Sie einen exakten Bereich abfotografieren, ist es eventuell einfacher, zuerst
+ einen etwas greren Bereich abzufotografieren und den Screenshot anschlieend mit
+ Hilfe des Bildeditors zuzuschneiden.
+
+
+
+ Zuletzt gewhlten Bereich abfotografieren Shift + Drucken
+
+ Wenn Sie vorher einen Bereich oder ein
+ Fenster abfotografiert haben, knnen Sie mit Hilfe
+ dieser Option den gleichen Bereich noch einmal abfotografieren.
+
+
+
+ Fenster abfotografieren Alt + Drucken
+
+ Erstellt einen Screenshot des momentan aktiven Fensters.
+
+
+ Im Einstellungen-Dialog knnen Sie einstellen, dass nicht
+ sofort das aktive Fenster abfotografiert werden soll, sondern stattdessen der
+ interaktive Modus gestartet wird. Wenn diese Option ausgewhlt ist, knnen Sie
+ ein Fenster auswhlen, indem Sie darauf klicken (wie beim
+ Bereichsmodus hebt Greenshot auch hier den Bereich
+ hervor, der abfotografiert werden wird).
+ Wenn Sie ein Kind-Fenster abfotografieren wollen (z.B. einen Browser-Viewport (ohne
+ Symbolleisten usw. oder einen einzelnen Frame einer Webseite mit Framesets) ziehen
+ Sie den Mauszeiger auf ds Fenster und drcken Sie die Bild ab-Taste.
+ Anschlieend knnen Sie Kind-Elemente des Fensters durch anklicken auswhlen.
+
+
+
+ Kompletten Bildschirm abfotografieren Strg + Drucken
+
+ Erstellt einen Screenhot vom gesamten Bildschirm.
+
+
+
+ Verwendung des Bildeditors
+
+ Greenshot bietet Ihnen einen einfaches Bildbearbeitungswerkzeug mit praktischen
+ Mglichkeiten; ein Screenshot kann beispielsweise mit Anmerkungen und Formen
+ ergnzt werden. Es ist auch mglich, Teile des Screenshots hervorzuheben oder
+ unkenntlich zu machen.
+
+
+ Sie knnen Greenshots Bildeditor nicht nur fr Screenshorts verwenden. Sie
+ knnen auch Bilder aus Dateien oder aus der Zwischenablage zur Bearbeitung
+ ffnen. Klicken Sie einfach mit der rechten Maustaste auf das Greenshot-Icon im
+ Systray und whlen Sie Bild aus Datei ffnen bzw. Bild aus
+ Zwischenablage ffnen.
+
+
+ Standardmig wird der Bildbearbeiter immer geffnet, wenn ein Screenshot
+ gemacht wird. Wenn Sie den Bildbearbeiter nicht verwenden wollen, knnen
+ Sie dies in den Einstellungen deaktivieren.
+
+
+
+
+ Formen zeichnen
+
+ Whlen Sie eines der Form-Zeichnen-Werkzeuge aus der Werkzeugliste auf der linken
+ Seite des Bildeditors oder aus dem Men Objekt. Zur schnelleren
+ Bedienung ist jedem Werkzeug ein Buchstabe zugeordnet.
+ Folgende Formen sind verfgbar: Rechteck R, Ellipse E,
+ Linie L und Pfeil A.
+ Klicken Sie die linke Maustaste, halten Sie diese gedrckt und bewegen Sie die Maus,
+ um den Position und Gre der Form zu bestimmen. Lassen Sie die Maustaste los,
+ wenn Sie fertig sind.
+
+
+ Sie knnen bereits gemalte Formen verschieben oder ihre Gre ndern. Whlen Sie
+ hierzu das Auswahlwerkzeug ESC aus der Werkzeugleiste.
+ Jede Element-Art hat auerdem bestimmte Einstellungen, mit denen das Aussehen des
+ Elements verndert werden kann (z.B. Linienstrke, Rahmenfarbe, Hintergrundfarbe).
+ Sie knnen diese Einstellungen fr ein bereits gezeichnetes Element ndern, wenn
+ es ausgewhlt ist. Sie knnen die Einstellungen aber auch vor dem Zeichnen eines
+ Elements anpassen, direkt nach der Auswahl eines Zeichnen-Werkzeugs.
+
+
+ Sie knnen mehrere Elemente gleichzeitig zur Bearbeitung auswhlen. Halten Sie
+ hierzu die Shift-Taste gedrckt, whrend Sie die Elemente anklicken.
+
+
+
Text hinzufgen
+
+ Das Textwerkzeug T wird hnlich verwendet wie die
+ Formen-Werkzeuge.
+ Zeichnen Sie einfach ein Textelement in der gewnschten Gre und geben Sie
+ den gewnschten Text ein.
+ Durch Doppelklicken knnen Sie den Text eines bestehenden Textelements bearbeiten.
+
+
+
+ Hervorheben
+
+ Nach der Auswahl des Hervorhebungs-Werkzeugs H knnen Sie den hervorzuhebenden
+ Bereich whlen, gehen Sie hierzu vor wie beim Zeichnen von Formen.
+ Sie habe verschiedene Mglichkeiten der Hervorhebung, whlen Sie ein durch Klicken
+ der Schaltflche links in der Symbolleiste ber dem Screenshot:
+
+
+ - Textmarker: hinterlegt den Bereich mit einer Farbe ihrer Wahl
+ - Bereich hervorheben: alles auerhalb des Bereichs wird weichgezeichnet*
+ und leicht verdunkelt
+ - Graustufen: alles auerhalb des Bereichs wird in Graustufen dargestellt
+ - Magnify: der Bereich wird vergrert dargestellt
+
+
+
+ Unkenntlich machen
+
+ Wenn ein Screenshot Daten enthlt, die nicht weitergegeben werden sollen (z.B. Kontodaten,
+ Namen, Passwrter oder Gesichter auf Bildern), ist es sinnvoll diese unkenntlich zu machen.
+ Das Unkenntlich-machen-Werkzeug O wird verwendet wie das
+ Hervorheben-Werkzeug.
+ Folgende Mglichkeiten stehen zur Verfgung:
+
+
+ - Verpixeln: im Bereich werden die Pixel vergrert
+ - Weichzeichnen*: der Bereich wird weichgezeichnet
+
+
+
+ * Je nach Leistung Ihres Computers kann die Verwendung von Weichnzeichner-Effekten
+ Greenshots Bildeditor verlangsamen. Wenn Sie merken, dass der Bildeditor zu langsam
+ reagiert sobald ein Weichzeichner verwendet wird, reduzieren Sie den Wert
+ Vorschauqualit in der Symbolleiste oder stellen Sie einen kleineren
+ Weichzeichner-Radius ein.
+ Sollte die Reaktionsgeschwindigkeit dann immer noch unzufriedenstellend sein, sollten
+ Sie dem Verpixeln-Werkzeug den Vorzug geben.
+
+
+
+ Screenshot zuschneiden
+
+ Wenn Sie nur einen Teil des Screenshots bentigen, knnen Sie das Zuschneiden-Werkzeug
+ C verwenden, um den Screenshot auf die gewnschte Gre zuzuschneiden.
+ Whlen Sie das Zuschneiden-Werkzeug, zeichnen Sie dann ein Rechteck ber den Bereich
+ des Screenshots, den Sie behalten wollen. Sie knnen die Gre des ausgewhlten
+ Bereichs ndern, wie bei jedem anderen Element.
+ Wenn Sie mit Ihrer Auswahl zufrieden sind, klicken Sie die Besttigen-Schaltflche in
+ der Symbolleiste oder drcken Sie die Enter-Taste. Sie knnen den Vorgang
+ abbrechen, indem Sie die Abbrechen-Schaltflche klicken oder ESC drcken.
+
+
+
+ Elemente wiederverwenden
+
+ Wenn Sie regelmig die gleichen oder hnliche Elemente in Ihren Screenshots
+ verwenden (z.B. ein Textfeld, in dem Browsertyp und -version angegeben sind, oder
+ Verpixelung des gleichen Elements auf mehreren Screenshots) knnen Sie diese
+ Elemente wiederverwenden.
+ Whlen Sie Objekte in Datei speichern aus dem Objekt-Men um
+ die aktuellen Elemente zur spteren Wiederverwendung zu speichern. Objekte
+ aus Datei laden fgt die Elemente dann zu einem anderen Screenshot hinzu.
+
+
+
+ Screenshot exportieren
+
+ Nach der Bearbeitung des Screenshots knnen Sie das Ergebnis auf verschiedene
+ Arten exportieren, je nach Bedarf. Alle Export-Optionen sind ber das Datei-
+ Men, die obere Symbolleiste oder ber Tastaturkrzel verfgbar:
+
+
+ - Speichern Strg + S: speichert die Grafik in eine Datei (wenn es bereits gespeichert wurde, ansonsten wird der Dialog Speichern unter... angezeigt
+ - Speichern unter... Strg + Shift + S: ffnet einen Dialog, in dem Sie Verzeichnis, Dateiname und Grafikformat fr die zu speichernde Grafik whlen knnen
+ - Grafik in Zwichenablage kopieren Strg + Shift + C: legt eine Kopie der Grafik in der Zwischenablage ab, so dass sie direkt in andere Programme eingefgt werden kann
+ - Drucken... Strg + P: sendet die Grafik an einen Drucker
+ - E-Mail Strg + E: ffnet eine neue Nachricht in Ihrem Standard-E-Mail-Programm und hngt die Grafik als Datei an
+
+
+ Nach dem Speichern einer Grafik im Bildeditor knnen Sie mit der rechten Maustaste auf
+ die Statusleiste am unteren Rand des Editor-Fensters klicken, um entweder den Dateipfad
+ zu ffnen.
+
+
+
+
+ Der Einstellungen-Dialog
+
+
+ Allgemeine Einstellungen
+
+ - Sprache: Die Sprache, in der Sie Greenshot verwenden mchten.
+ Hier knnen Sie weitere Sprachen fr Greenshot herunterladen.
+ - Globale Tastenkombinationen aktivieren: Wenn diese Optionen aktiviert ist, kann Greenshot mit der Drucken-Taste verwendet werden.
+ - Greenshot mit Windows starten: Das Programm wird automatisch gestartet wenn das System hochfhrt.
+ - Blitzlicht anzeigen: Visuelles Feedback beim Erstellen eines Screenshots
+ - Kamera-Klang abspielen: Hrbares feedback beim Erstellen eines Screenshots
+ - Mauszeiger mit abfotografieren: Wenn diese Option aktiviert ist, wird der Mauszeiger abfotografiert. Der Zeiger wird im Editor als eigenes Element eingefgt, so dass Sie ihn anschlieend noch verschieben oder lschen knnen.
+ - Fenster interaktiv abfotografieren: Anstatt sofort das aktive Fenster abzufotografieren, knnen Sie im
+ interaktivem Modus ein Fenster auswhlen. Es ist auch mglich, Kind-Fenster abzufotografieren, siehe Fenster abfotografieren.
+
+
+
+ Ausgabeeinstellungen
+
+ - Screenshot Ziel: Sie knnen ein oder mehrere Mglichkeiten whlen, was mit dem Screenshot direkt nach der Erstellung geschehen soll.
+ - Bevorzugte Ausgabedatei-Einstellungen: Verzeichnis und Dateiname, die verwendet werden sollten wenn Screenshots direkt gespeichert werden, bzw. die vorgeschlagen werden sollen, wenn mit dem Speichern-unter-Dialog gespeichert wird. Klicken Sie die ?-Schaltflche um zu erfahren, welche Platzhalter fr das Dateiname-Muster verwendet werden knnen.
+ - JPEG-Einstellungen: Qualittsstufe fr den Export von JPEG-Dateien
+
+
+
+ Druckereinstellungen
+
+ - Ausdruck auf Seitengre verkleinern: Verkleinert die Grafik, wenn sie zu gro fr das Papierformat ist.
+ - Ausdruck auf Seitengre vergrern: Vergrert die Grafik, wenn sie kleiner als das Papierformat ist.
+ - Drehung des Ausdrucks an das Seitenformat anpassen: Dreht eine Querformat-Grafik fr den Ausdruck um 90°.
+
+
+
+
+ Wollen Sie Greenshot untersttzen?
+
+
+ Wir bentigen momentan keine Hilfe bei der Entwicklung von Greenshot. Es gibt aber
+ unterschiedliche Mglichkeiten, wenn Sie Greenshot und das Entwickler-Team
+ untersttzen wollen.
+ Vielen Dank im Voraus :)
+
+
+
+ Spenden
+
+ Wir stecken sehr viel Arbeit in Greenshot oder verbringen einige Zeit damit, ein
+ gutes Programm kostenlos und open source zur Verfgung zu stellen. Wenn Sie
+ merken, dass Greenshot Ihnen hilft, produktiver zu sein, wenn es Ihnen (oder
+ Ihrer Firma) viel Zeit und Geld spart, oder wenn Sie einfach Greenshot und die
+ Open-Source-Idee mgen: bitte ziehen Sie in Betracht, unserem Aufwand etwas
+ Anerkennung durch eine Spende zukommen zu lassen.
+ Bitte werfen Sie einen Blick auf unsere Webseite, um zu sehen, wie Sie das
+ Greenshot Entwicker-Team untersttzen knnen:
+ http://getgreenshot.org/support/
+
+
+
+ Weitersagen
+
+ Wenn Sie Greenshot mgen, sagen Sie es weiter: erzhlen Sie Ihren Freunden und Kollegen
+ von Greenshot. Und Ihren Followern :)
+ Bewerten Sie Greenshot auf Software-Portalen oder verlinken Sie unsere Webseite von
+ Ihrem Blog oder Ihrer eigenen Webseite.
+
+
+
+ bersetzen
+
+ Gibt es Greenshot noch nicht in Ihrer bevorzugten Sprache? Wenn Sie sich in der
+ Lage fhlen, ein Programm zu bersetzen, sind Sie herzlich eingeladen.
+ Wenn Sie registrierter Nutzer bei sourceforge.net sind, knnen Sie bersetzungen
+ hier hochladen.
+ Bitte stellen Sie vorher sicher, dass keine bersetzung fr Ihre Sprache auf unserer
+ Download-Seite existiert. Prfen Sie auch hier, ob
+ evtl. eine bersetzung in Arbeit oder in Vorbereitung ist.
+ Bitte bedenken Sie, dass wir eine berstzung nur auf unserer Download-Seite zur
+ Verfgung stellen werden, wenn Sie ber ein sourceforge.net Benutzerkonto bereit gestellt
+ wurde. Da wir hchstwahrscheinlich nicht in der Lage sein werden, Ihre bersetzung
+ zu verstehen, ist es gut, wenn andere sourceforge Nutzer Sie kontaktieren knnen,
+ um Verbesserungen vorzuschlagen oder die bersetzung fr eine nachfolgende Greenshot-Version
+ zu erweitern.
+
+
+
+
+
+