source: branches/HeuristicLab.Problems.GrammaticalOptimization/DynamicDataDisplay/Common/Auxiliary/ScreenshotHelper.cs @ 13792

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows.Media.Imaging;
using System.Windows;
using System.Windows.Media;
using System.IO;
using System.Diagnostics;
using System.Windows.Threading;
using System.Windows.Shapes;

namespace Microsoft.Research.DynamicDataDisplay.Common.Auxiliary
{
  internal static class ScreenshotHelper
  {
    /// <summary>Gets the encoder by extension</summary>
    /// <param name="extension">The extension</param>
    /// <returns>BitmapEncoder object</returns>
    internal static BitmapEncoder GetEncoderByExtension(string extension)
    {
      switch (extension)
      {
        case "bmp":
          return new BmpBitmapEncoder();
        case "jpg":
          return new JpegBitmapEncoder();
        case "gif":
          return new GifBitmapEncoder();
        case "png":
          return new PngBitmapEncoder();
        case "tiff":
          return new TiffBitmapEncoder();
        case "wmp":
          return new WmpBitmapEncoder();
        default:
          throw new ArgumentException(Strings.Exceptions.CannotDetermineImageTypeByExtension, "extension");
      }
    }

    /// <summary>Creates the screenshot of entire plotter element</summary>
    /// <returns></returns>
    internal static BitmapSource CreateScreenshot(UIElement uiElement, Int32Rect screenshotSource)
    {
      Window window = Window.GetWindow(uiElement);
      if (window == null)
      {
        return CreateElementScreenshot(uiElement);
      }
      Size size = window.RenderSize;

      //double dpiCoeff = 32 / SystemParameters.CursorWidth;
      //int dpi = (int)(dpiCoeff * 96);
      double dpiCoeff = 1;
      int dpi = 96;

      RenderTargetBitmap bmp = new RenderTargetBitmap(
        (int)(size.Width * dpiCoeff), (int)(size.Height * dpiCoeff),
        dpi, dpi, PixelFormats.Default);

      // white background
      Rectangle whiteRect = new Rectangle { Width = size.Width, Height = size.Height, Fill = Brushes.White };
      whiteRect.Measure(size);
      whiteRect.Arrange(new Rect(size));
      bmp.Render(whiteRect);
      // the very element
      bmp.Render(uiElement);

      CroppedBitmap croppedBmp = new CroppedBitmap(bmp, screenshotSource);
      return croppedBmp;
    }

    private static BitmapSource CreateElementScreenshot(UIElement uiElement)
    {
      bool measureValid = uiElement.IsMeasureValid;

      if (!measureValid)
      {
        double width = 300;
        double height = 300;

        FrameworkElement frElement = uiElement as FrameworkElement;
        if (frElement != null)
        {
          if (!Double.IsNaN(frElement.Width))
            width = frElement.Width;
          if (!Double.IsNaN(frElement.Height))
            height = frElement.Height;
        }

        Size size = new Size(width, height);
        uiElement.Measure(size);
        uiElement.Arrange(new Rect(size));
      }

      RenderTargetBitmap bmp = new RenderTargetBitmap(
        (int)uiElement.RenderSize.Width, (int)uiElement.RenderSize.Height,
        96, 96, PixelFormats.Default);

      // this is waiting for dispatcher to perform measure, arrange and render passes
      uiElement.Dispatcher.Invoke(((Action)(() => { })), DispatcherPriority.Background);

      Size elementSize = uiElement.DesiredSize;
      // white background
      Rectangle whiteRect = new Rectangle { Width = elementSize.Width, Height = elementSize.Height, Fill = Brushes.White };
      whiteRect.Measure(elementSize);
      whiteRect.Arrange(new Rect(elementSize));
      bmp.Render(whiteRect);

      bmp.Render(uiElement);

      return bmp;
    }

    private static Dictionary<BitmapSource, string> pendingBitmaps = new Dictionary<BitmapSource, string>();

    internal static void SaveBitmapToStream(BitmapSource bitmap, Stream stream, string fileExtension)
    {
      if (bitmap == null)
        throw new ArgumentNullException("bitmap");
      if (stream == null)
        throw new ArgumentNullException("stream");
      if (String.IsNullOrEmpty(fileExtension))
        throw new ArgumentException(Strings.Exceptions.ExtensionCannotBeNullOrEmpty, fileExtension);

      BitmapEncoder encoder = ScreenshotHelper.GetEncoderByExtension(fileExtension);
      encoder.Frames.Add(BitmapFrame.Create(bitmap, null, new BitmapMetadata(fileExtension.Trim('.')), null));
      encoder.Save(stream);
    }

    internal static void SaveBitmapToFile(BitmapSource bitmap, string filePath)
    {
      if (String.IsNullOrEmpty(filePath))
        throw new ArgumentException(Strings.Exceptions.FilePathCannotbeNullOrEmpty, "filePath");

      if (bitmap.IsDownloading)
      {
        pendingBitmaps[bitmap] = filePath;
        bitmap.DownloadCompleted += OnBitmapDownloadCompleted;
        return;
      }

      string dirPath = System.IO.Path.GetDirectoryName(filePath);
      if (!String.IsNullOrEmpty(dirPath) && !Directory.Exists(dirPath))
      {
        Directory.CreateDirectory(dirPath);
      }

      bool fileExistedBefore = File.Exists(filePath);
      try
      {
        using (FileStream fs = new FileStream(filePath, FileMode.Create, FileAccess.Write))
        {
          string extension = System.IO.Path.GetExtension(filePath).TrimStart('.');
          SaveBitmapToStream(bitmap, fs, extension);
        }
      }
      catch (ArgumentException)
      {
        if (!fileExistedBefore && File.Exists(filePath))
        {
          try
          {
            File.Delete(filePath);
          }
          catch { }
        }
      }
      catch (IOException exc)
      {
        Debug.WriteLine("Exception while saving bitmap to file: " + exc.Message);
      }
    }

    public static void SaveStreamToFile(Stream stream, string filePath)
    {
      string dirPath = System.IO.Path.GetDirectoryName(filePath);
      if (!String.IsNullOrEmpty(dirPath) && !Directory.Exists(dirPath))
      {
        Directory.CreateDirectory(dirPath);
      }

      using (FileStream fs = new FileStream(filePath, FileMode.Create, FileAccess.Write))
      {
        string extension = System.IO.Path.GetExtension(filePath).TrimStart('.');
        if (stream.CanSeek)
          stream.Seek(0, SeekOrigin.Begin);

        stream.CopyTo(fs);
      }

      stream.Dispose();
    }

    private static void OnBitmapDownloadCompleted(object sender, EventArgs e)
    {
      BitmapSource bmp = (BitmapSource)sender;
      bmp.DownloadCompleted -= OnBitmapDownloadCompleted;
      string filePath = pendingBitmaps[bmp];
      pendingBitmaps.Remove(bmp);

      SaveBitmapToFile(bmp, filePath);
    }
  }
}