/// <summary>
 /// Get an ICapture object, so the plugin can modify this
 /// </summary>
 /// <returns></returns>
 public ICapture GetCapture(Image imageToCapture)
 {
     Capture capture = new Capture(imageToCapture);
     capture.CaptureDetails = new CaptureDetails();
     capture.CaptureDetails.CaptureMode = CaptureMode.Import;
     capture.CaptureDetails.Title = "Imported";
     return capture;
 }
Пример #2
0
 /// <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;
     if (capture.CaptureDetails != null)
     {
         ((Bitmap)capture.Image).SetResolution(capture.CaptureDetails.DpiX, capture.CaptureDetails.DpiY);
     }
     if (capture.Image == null)
     {
         return null;
     }
     return capture;
 }
Пример #3
0
        void Contextmenu_window_Click(object sender, EventArgs e)
        {
            ToolStripMenuItem clickedItem = (ToolStripMenuItem)sender;
             try
             {
            WindowDetails windowToCapture = (WindowDetails)clickedItem.Tag;
            ICapture capture = new Capture();
            using (Graphics graphics = Graphics.FromHwnd(this.Handle))
            {
               capture.CaptureDetails.DpiX = graphics.DpiY;
               capture.CaptureDetails.DpiY = graphics.DpiY;
            }
            windowToCapture.Restore();
            windowToCapture = CaptureForm.SelectCaptureWindow(windowToCapture);
            if (windowToCapture != null)
            {
               capture = CaptureForm.CaptureWindow(windowToCapture, capture, coreConf.WindowCaptureMode);
               this.Activate();
               WindowDetails.ToForeground(this.Handle);
               if (capture != null && capture.Image != null)
               {
                  surface.AddBitmapContainer((Bitmap)capture.Image, 100, 100);
               }
            }

            if (capture != null)
            {
               capture.Dispose();
            }
             }
             catch (Exception exception)
             {
            LOG.Error(exception);
             }
        }
Пример #4
0
        public static Image AnnotateImage(Image img, bool allowSave, string configPath, Action<Image> clipboardCopyRequested, Action<Image> imageUploadRequested)
        {
            if (!IniConfig.isInitialized)
            {
                IniConfig.AllowSave = allowSave;
                IniConfig.Init(configPath);
            }

            using (Image cloneImage = (Image)img.Clone())
            using (ICapture capture = new Capture { Image = cloneImage })
            using (Surface surface = new Surface(capture))
            using (ImageEditorForm editor = new ImageEditorForm(surface, true))
            {
                editor.ClipboardCopyRequested += clipboardCopyRequested;
                editor.ImageUploadRequested += imageUploadRequested;

                if (editor.ShowDialog() == DialogResult.OK)
                {
                    using (img)
                    {
                        return editor.GetImageForExport();
                    }
                }
            }

            return img;
        }
Пример #5
0
        /// <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;
        }
Пример #6
0
 /// <summary>
 /// Make Capture with specified destinations
 /// </summary>
 /// <param name="mode">CaptureMode</param>
 /// <param name="captureMouseCursor">bool false if the mouse should not be captured, true if the configuration should be checked</param>
 /// <param name="captureDestinations">List<CaptureDestination> with destinations</param>
 public void MakeCapture(CaptureMode mode, bool captureMouseCursor, List<CaptureDestination> captureDestinations)
 {
     Capture passingCapture = new Capture();
      passingCapture.CaptureDetails.CaptureDestinations = captureDestinations;
      MakeCapture(mode, captureMouseCursor, passingCapture);
 }
        /// <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;
        }
Пример #8
0
 /// <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);
 }
Пример #9
0
 /// <summary>
 /// Make Capture with default destinations
 /// </summary>
 /// <param name="mode">CaptureMode</param>
 /// <param name="captureMouseCursor">bool false if the mouse should not be captured, true if the configuration should be checked</param>
 public void MakeCapture(CaptureMode mode, bool captureMouseCursor, CaptureHandler captureHandler)
 {
     Capture passingCapture = new Capture();
      passingCapture.CaptureDetails.CaptureHandler = captureHandler;
      MakeCapture(mode, captureMouseCursor, passingCapture);
 }
Пример #10
0
 // This is also an ICapture Interface implementation
 public void HandleCapture(Capture capture)
 {
     this.capture = capture;
      HandleCapture();
 }
Пример #11
0
 /// <summary>
 /// Make Capture with default destinations
 /// </summary>
 /// <param name="mode">CaptureMode</param>
 /// <param name="captureMouseCursor">bool false if the mouse should not be captured, true if the configuration should be checked</param>
 public void MakeCapture(CaptureMode mode, bool captureMouseCursor)
 {
     Capture passingCapture = new Capture();
      MakeCapture(mode, captureMouseCursor, passingCapture);
 }
Пример #12
0
 /// <summary>
 /// Process a bitmap like it was captured
 /// </summary>
 /// <param name="bitmap">The bitmap to process</param>
 public void HandleCapture(Bitmap bitmap)
 {
     Capture capture = new Capture(bitmap);
      HandleCapture(capture);
 }
Пример #13
0
        /// <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.ClientRectangle;
             if (windowToCapture.Iconic)
             {
            // Restore the window making sure it's visible!
            windowToCapture.Restore();
             }

             // When Vista & DWM (Aero) enabled
             bool dwmEnabled = DWM.isDWMEnabled();

             // 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 (windowCaptureMode == WindowCaptureMode.Auto)
             {
            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 GDI
            windowCaptureMode = WindowCaptureMode.GDI;
            // Take DWM if enabled
            if (dwmEnabled)
            {
               windowCaptureMode = WindowCaptureMode.Aero;
            }
             }
             else if (windowCaptureMode == WindowCaptureMode.Aero || windowCaptureMode == WindowCaptureMode.AeroTransparent)
             {
            if (!dwmEnabled)
            {
               windowCaptureMode = WindowCaptureMode.GDI;
            }
             }
             LOG.DebugFormat("Capturing window with mode {0}", windowCaptureMode);
             switch (windowCaptureMode)
             {
            case WindowCaptureMode.GDI:
               // GDI
               captureForWindow = windowToCapture.CaptureWindow(captureForWindow);
               break;
            case WindowCaptureMode.Aero:
            case WindowCaptureMode.AeroTransparent:
               // DWM
               captureForWindow = windowToCapture.CaptureDWMWindow(captureForWindow, windowCaptureMode);
               break;
            case WindowCaptureMode.Screen:
            default:
               // Screen capture
               windowRectangle.Intersect(captureForWindow.ScreenBounds);
               try
               {
                  captureForWindow = WindowCapture.CaptureRectangle(captureForWindow, windowRectangle);
               }
               catch (Exception e)
               {
                  LOG.Error("Problem capturing", e);
                  return null;
               }
               break;
             }
             captureForWindow.CaptureDetails.Title = windowToCapture.Text;
             ((Bitmap)captureForWindow.Image).SetResolution(captureForWindow.CaptureDetails.DpiX, captureForWindow.CaptureDetails.DpiY);
             return captureForWindow;
        }
        private void Contextmenu_window_Click(object sender, EventArgs e)
        {
            ToolStripMenuItem clickedItem = (ToolStripMenuItem)sender;
            try
            {
                WindowDetails windowToCapture = (WindowDetails)clickedItem.Tag;
                ICapture capture = new Capture();
                using (Graphics graphics = Graphics.FromHwnd(this.Handle))
                {
                    capture.CaptureDetails.DpiX = graphics.DpiY;
                    capture.CaptureDetails.DpiY = graphics.DpiY;
                }
                windowToCapture.Restore();
                windowToCapture = CaptureHelper.SelectCaptureWindow(windowToCapture);
                if (windowToCapture != null)
                {
                    capture = CaptureHelper.CaptureWindow(windowToCapture, capture, coreConf.WindowCaptureMode);
                    this.Activate();
                    WindowDetails.ToForeground(this.Handle);
                    if (capture != null && capture.Image != null)
                    {
                        bool addShadow = false;
                        if (addShadow)
                        {
                            Point offset = new Point(6, 6);
                            using (Bitmap shadowImage = ImageHelper.CreateShadow(capture.Image, 1f, 7, offset, PixelFormat.Format32bppArgb))
                            {
                                surface.AddBitmapContainer(shadowImage, 100, 100);
                            }
                        }
                        else
                        {
                            surface.AddBitmapContainer((Bitmap)capture.Image, 100, 100);
                        }
                    }
                }

                if (capture != null)
                {
                    capture.Dispose();
                }
            }
            catch (Exception exception)
            {
                LOG.Error(exception);
            }
        }
Пример #15
0
        public static Image AnnotateImage(Image img, string imgPath, bool allowSave, string configPath,
            Action<Image> clipboardCopyRequested,
            Action<Image> imageUploadRequested,
            Action<Image, string> imageSaveRequested,
            Func<Image, string, string> imageSaveAsRequested,
            Action<Image> printImageRequested)
        {
            if (!IniConfig.isInitialized)
            {
                IniConfig.AllowSave = allowSave;
                IniConfig.Init(configPath);
            }

            using (Image cloneImage = img != null ? (Image)img.Clone() : LoadImage(imgPath))
            using (ICapture capture = new Capture { Image = cloneImage })
            using (Surface surface = new Surface(capture))
            using (ImageEditorForm editor = new ImageEditorForm(surface, true))
            {
                editor.IsTaskWork = img != null;
                editor.SetImagePath(imgPath);
                editor.ClipboardCopyRequested += clipboardCopyRequested;
                editor.ImageUploadRequested += imageUploadRequested;
                editor.ImageSaveRequested += imageSaveRequested;
                editor.ImageSaveAsRequested += imageSaveAsRequested;
                editor.PrintImageRequested += printImageRequested;

                DialogResult result = editor.ShowDialog();

                if (result == DialogResult.OK && editor.IsTaskWork)
                {
                    using (img)
                    {
                        return editor.GetImageForExport();
                    }
                }

                if (result == DialogResult.Abort)
                {
                    return null;
                }
            }

            return img;
        }
Пример #16
0
 /// <summary>
 /// Make Capture with file name
 /// </summary>
 /// <param name="filename">List<CaptureDestination> with destinations</param>
 public void MakeCapture(string filename)
 {
     Capture passingCapture = new Capture();
      passingCapture.CaptureDetails.Filename = filename;
      MakeCapture(CaptureMode.File, false, passingCapture);
 }
Пример #17
0
		/// <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 CaptureRectangleFromDesktopScreen(ICapture capture, Rectangle captureBounds) {
			if (capture == null) {
				capture = new Capture();
			}
			capture.Image = CaptureRectangle(captureBounds);
			capture.Location = captureBounds.Location;
			return capture.Image == null ? null : capture;
		}
Пример #18
0
        /// <summary>
        /// Perform Actions after capturing image/text/file objects
        /// </summary>
        public void PerformActions()
        {
            foreach (Software app in Engine.ConfigUI.ConfigActions.ActionsApps)
            {
                if (app.Enabled)
                {
                    if (IsValidActionImage(app) && app.Name == Engine.zImageAnnotator)
                    {
                        try
                        {
                            // Compatibility fixes
                            string LANGUAGE_PATH = Path.Combine(Application.StartupPath, @"Languages");
                            if (!Directory.Exists(LANGUAGE_PATH))
                                Directory.CreateDirectory(LANGUAGE_PATH);
                            if (Greenshot.MainForm.instance == null)
                                Greenshot.MainForm.Start(new string[0]);

                            CoreConfiguration coreConfiguration = IniConfig.GetIniSection<CoreConfiguration>();
                            coreConfiguration.OutputFileFilenamePattern = "${title}";
                            coreConfiguration.OutputFilePath = Engine.ImagesDir;

                            ICapture capture = new GreenshotPlugin.Core.Capture();
                            capture.Image = TempImage;
                            capture.CaptureDetails.Filename = Info.LocalFilePath;
                            capture.CaptureDetails.Title =
                                Path.GetFileNameWithoutExtension(capture.CaptureDetails.Filename);
                            capture.CaptureDetails.AddMetaData("file", capture.CaptureDetails.Filename);
                            capture.CaptureDetails.AddMetaData("source", "file");

                            var surface = new Greenshot.Drawing.Surface(capture);

                            var editor = new Greenshot.ImageEditorForm(surface,
                                                             WorkflowConfig.DestConfig.Outputs.Contains(
                                                                 OutputEnum.LocalDisk)) { Icon = Resources.zss_tray };
                            editor.SetImagePath(Info.LocalFilePath);
                            editor.Visible = false;
                            editor.ShowDialog();
                            TempImage = editor.GetImageForExport();
                        }
                        catch (Exception ex)
                        {
                            DebugHelper.WriteException(ex, "ImageEdit");
                        }
                    }
                    else if (IsValidActionImage(app) && app.Name == Engine.zImageEffects)
                    {
                        var effects = new ImageEffects.ImageEffectsGUI(TempImage);
                        effects.ShowDialog();
                        TempImage = effects.GetImageForExport();
                    }
                    else if (File.Exists(app.Path))
                    {
                        if (IsValidActionOCR(app))
                        {
                            app.OpenFile(OCRFilePath);
                            OCRText = File.ReadAllText(OCRFilePath);
                        }
                        else if (IsValidActionText(app))
                        {
                            app.OpenFile(Info.LocalFilePath);
                            TempText = File.ReadAllText(TempText);
                        }
                        else if (IsValidActionImage(app))
                        {
                            WriteImage(TempImage);
                            app.OpenFile(Info.LocalFilePath);
                        }
                        else if (IsValidActionFile(app))
                        {
                            app.OpenFile(Info.LocalFilePath);
                        }
                    }
                    DebugHelper.WriteLine(string.Format("Performed Actions using {0}.", app.Name));
                }
            }
        }
Пример #19
0
		/// <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);
		}
Пример #20
0
		/// <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();
			}
			Image capturedImage = null;
			// If the CaptureHandler has a handle use this, otherwise use the CaptureRectangle here
			if (CaptureHandler.CaptureScreenRectangle != null) {
				try {
					capturedImage = CaptureHandler.CaptureScreenRectangle(captureBounds);
				} catch {
				}
			}
			// If no capture, use the normal screen capture
			if  (capturedImage == null) {
				capturedImage = CaptureRectangle(captureBounds);
			}
			capture.Image = capturedImage;
			capture.Location = captureBounds.Location;
			return capture.Image == null ? null : capture;
		}
Пример #21
-2
		/// <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;
			CursorInfo cursorInfo = new CursorInfo(); 
			IconInfo iconInfo;
			cursorInfo.cbSize = Marshal.SizeOf(cursorInfo);
			if (User32.GetCursorInfo(out cursorInfo)) {
				if (cursorInfo.flags == User32.CURSOR_SHOWING) { 
					using (SafeIconHandle safeIcon = User32.CopyIcon(cursorInfo.hCursor)) {
						if (User32.GetIconInfo(safeIcon, out iconInfo)) {
							Point cursorLocation = User32.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(safeIcon.DangerousGetHandle())) {
								capture.Cursor = icon;
							}
	
							if (iconInfo.hbmMask != IntPtr.Zero) {
								DeleteObject(iconInfo.hbmMask);
							}
							if (iconInfo.hbmColor != IntPtr.Zero) {
								DeleteObject(iconInfo.hbmColor);
							}
						}
					}
				}
			}
			return capture;
		}