private static byte[] GetPngImage(FrameworkElement element)
{
var size = new Size(double.PositiveInfinity, double.PositiveInfinity);
element.Measure(size);
element.Arrange(new Rect(element.DesiredSize));
var renderTarget =
new RenderTargetBitmap((int)element.RenderSize.Width,
(int)element.RenderSize.Height,
96, 96,
PixelFormats.Pbgra32);
var sourceBrush = new VisualBrush(element);
var drawingVisual = new DrawingVisual();
using (DrawingContext drawingContext = drawingVisual.RenderOpen())
{
drawingContext.DrawRectangle(
sourceBrush, null, new Rect(
new Point(0, 0),
new Point(element.RenderSize.Width,
element.RenderSize.Height)));
}
renderTarget.Render(drawingVisual);
var pngEncoder = new PngBitmapEncoder();
pngEncoder.Frames.Add(BitmapFrame.Create(renderTarget));
using (var outputStream = new MemoryStream())
{
pngEncoder.Save(outputStream);
return outputStream.ToArray();
}
}
public static void RealizeFrameworkElement(FrameworkElement fe) {
var size = new Size(double.MaxValue, double.MaxValue);
if (fe.Width > 0 && fe.Height > 0) size = new Size(fe.Width, fe.Height);
fe.Measure(size);
fe.Arrange(new Rect(new Point(), fe.DesiredSize));
fe.UpdateLayout();
}
public static Visual Print(Visual v, bool canReturn = false)
{
try
{
System.Windows.FrameworkElement e = v as System.Windows.FrameworkElement;
if (e == null)
{
return(null);
}
PrintDialog pd = new PrintDialog();
bool?determiner = true;
if (!canReturn)
{
determiner = pd.ShowDialog();
}
if ((bool)determiner)
{
//store original scale
Transform originalScale = e.LayoutTransform;
//get selected printer capabilities
System.Printing.PrintCapabilities capabilities = pd.PrintQueue.GetPrintCapabilities(pd.PrintTicket);
//get scale of the print wrt to screen of WPF visual
//double x = capabilities.PageImageableArea.ExtentWidth / e.ActualWidth;
//double y = capabilities.PageImageableArea.ExtentHeight / e.ActualHeight;
double scale = Math.Min(capabilities.PageImageableArea.ExtentWidth / e.ActualWidth, capabilities.PageImageableArea.ExtentHeight / e.ActualHeight);
//Transform the Visual to scale
e.LayoutTransform = new ScaleTransform(scale, scale);
// e.LayoutTransform = new ScaleTransform(x, y);
//get the size of the printer page
System.Windows.Size sz = new System.Windows.Size(capabilities.PageImageableArea.ExtentWidth, capabilities.PageImageableArea.ExtentHeight);
//update the layout of the visual to the printer page size.
e.Measure(sz);
e.Arrange(new System.Windows.Rect(new System.Windows.Point(capabilities.PageImageableArea.OriginWidth, capabilities.PageImageableArea.OriginHeight), sz));
//now print the visual to printer to fit on the one page.
if (!canReturn)
{
pd.PrintVisual(v, "My Print");
//apply the original transform.
e.LayoutTransform = originalScale;
MessageBox.Show("Printing SuccessFul", "Operation Successful", MessageBoxButton.OK, MessageBoxImage.Information);
}
}
if (canReturn)
{
return(v);
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
return(null);
}
/// <summary>
/// Calls the Arrange function on child canvas elements
/// </summary>
/// <param name="xamlObject">The xaml object.</param>
private static void ArrangeCanvasElements(FrameworkElement xamlObject)
{
if (xamlObject is Canvas)
xamlObject.Arrange(new Rect());
LogicalTreeHelper
.GetChildren(xamlObject)
.Cast<FrameworkElement>()
.ForEach(ArrangeCanvasElements);
}
private void DoWithElementAtSize(FrameworkElement element, Size size, Action action)
{
Transform transform = element.LayoutTransform;
element.LayoutTransform = null;
element.Measure(size);
element.Arrange(new Rect(size));
action();
element.LayoutTransform = transform;
}
private static void Print(Visual v)
{
System.Windows.FrameworkElement e = v as System.Windows.FrameworkElement;
if (e == null)
{
return;
}
PrintDialog pd = new PrintDialog();
if (pd.ShowDialog() == true)
{
//store original scale
Transform originalScale = e.LayoutTransform;
//get selected printer capabilities
System.Printing.PrintCapabilities capabilities = pd.PrintQueue.GetPrintCapabilities(pd.PrintTicket);
//get scale of the print wrt to screen of WPF visual
if (capabilities.PageImageableArea == null)
{
return;
}
double scale = Math.Min(
capabilities.PageImageableArea.ExtentWidth / e.ActualWidth,
capabilities.PageImageableArea.ExtentHeight / e.ActualHeight);
//Transform the Visual to scale
e.LayoutTransform = new ScaleTransform(scale, scale);
//get the size of the printer page
System.Windows.Size sz = new System.Windows.Size(
capabilities.PageImageableArea.ExtentWidth, capabilities.PageImageableArea.ExtentHeight);
//update the layout of the visual to the printer page size.
e.Measure(sz);
e.Arrange(
new System.Windows.Rect(
new System.Windows.Point(
capabilities.PageImageableArea.OriginWidth, capabilities.PageImageableArea.OriginHeight),
sz));
//now print the visual to printer to fit on the one page.
pd.PrintVisual(v, "My Print");
//apply the original transform.
e.LayoutTransform = originalScale;
}
}
protected virtual void InvalidatePosition(FrameworkElement child)
{
if (viewport == null) return;
var transform = GetTransform(availableSize);
Size elementSize = GetElementSize(child, AvailableSize, transform);
child.Measure(elementSize);
Rect bounds = GetElementScreenBounds(transform, child);
if (!bounds.IsNaN())
{
child.Arrange(bounds);
}
}
public static ImageSource ToImageSource(FrameworkElement obj)
{
Transform transform = obj.LayoutTransform;
Thickness margin = obj.Margin;
obj.Margin = new Thickness(0, 0, margin.Right - margin.Left, margin.Bottom - margin.Top);
Size size = new Size(obj.ActualWidth, obj.ActualHeight);
obj.Measure(size);
obj.Arrange(new Rect(size));
RenderTargetBitmap bmp = new RenderTargetBitmap((int)obj.ActualWidth, (int)obj.ActualHeight, 96, 96, PixelFormats.Pbgra32);
bmp.Render(obj);
obj.LayoutTransform = transform;
obj.Margin = margin;
return bmp;
}
public WpfVisual(FrameworkElement element, int defaultWidth = BadgeCaps.Width, int defaultHeight = BadgeCaps.Height, bool dither = false, bool enableBlend = false)
{
Element = element;
Element.Measure(new Size(defaultWidth, defaultHeight));
Element.Arrange(new Rect(0, 0, defaultWidth, defaultHeight));
ClipWidth = (int)Math.Ceiling(Element.ActualWidth);
ClipHeight = (int)Math.Ceiling(Element.ActualHeight);
Dither = dither;
EnableBlend = enableBlend;
m_cachedIntermediate = new BadgeRenderTarget(ClipWidth, ClipHeight);
m_renderTarget = new RenderTargetBitmap(ClipWidth, ClipHeight, 96, 96, PixelFormats.Pbgra32);
Update(0); // To avoid remeasuring on a background thread
UpdateCachedImage();
}
public static void XAMLToBitmap(FrameworkElement element, string fileName)
{
try
{
element.RenderTransform = new ScaleTransform(0.1, 0.1);
element.Measure(new Size((int)element.Width, (int)element.Height));
element.Arrange(new Rect(new Size((int)element.Width, (int)element.Height)));
var renderTargetBitmap = new RenderTargetBitmap((int)element.ActualWidth / 10, (int)element.ActualHeight / 10, 96d, 96d, PixelFormats.Pbgra32);
renderTargetBitmap.Render(element);
using (FileStream fileStream = new FileStream(fileName, FileMode.Create))
{
var bmpBitmapEncoder = new BmpBitmapEncoder();
bmpBitmapEncoder.Frames.Add(BitmapFrame.Create(renderTargetBitmap));
bmpBitmapEncoder.Save(fileStream);
}
}
catch { }
}
/// <summary>
/// Creates <seealso cref="WriteableBitmap"/> from a <seealso cref="FrameworkElement"/> to
/// </summary>
/// <remarks>This is an extension method provided by <seealso cref="FrameworkElementEx"/></remarks>
public static WriteableBitmap CreateBitmap(FrameworkElement element, bool isElementInVisualTree = false)
{
WriteableBitmap bitmap = null;
if (!isElementInVisualTree)
{
element.Measure(new Size(double.PositiveInfinity, double.PositiveInfinity));
element.Arrange(new Rect(new Point(0, 0), element.DesiredSize));
}
var width = (int)Math.Ceiling(element.ActualWidth);
var height = (int)Math.Ceiling(element.ActualHeight);
width = width == 0 ? 1 : width;
height = height == 0 ? 1 : height;
var rtbmp = new RenderTargetBitmap(width, height, 96, 96, PixelFormats.Default);
rtbmp.Render(element);
bitmap = new WriteableBitmap(rtbmp);
return(bitmap);
}
internal void BeginGrandchildAnimation( FrameworkElement grandchild, Rect currentRect, Rect placementRect )
{
bool isDone = true;
object placementArgs;
ChildState state = new ChildState( currentRect );
AnimationPanel.SetChildState( grandchild, state );
state.Type = AnimationType.Switch;
state.BeginTimeStamp = DateTime.Now;
state.TargetPlacement = placementRect;
state.Animator = this.GetEffectiveAnimator( AnimationType.Template );
if( state.Animator != null && !state.TargetPlacement.IsEmpty )
{
AnimationRate rate = this.GetEffectiveAnimationRate( AnimationType.Template );
state.CurrentPlacement = state.Animator.GetInitialChildPlacement( grandchild, state.CurrentPlacement, state.TargetPlacement, this, ref rate, out placementArgs, out isDone );
state.AnimationRate = rate;
state.PlacementArgs = placementArgs;
}
state.IsAnimating = !isDone;
grandchild.Arrange( state.IsAnimating ? state.CurrentPlacement : state.TargetPlacement );
if( state.IsAnimating )
{
_animatingGrandchildren.Add( grandchild );
this.AnimatingChildCount++;
}
else
{
state.CurrentPlacement = state.TargetPlacement;
}
}
protected override void InvalidatePosition(FrameworkElement child)
{
invalidatePositionCalls++;
if (viewport == null) return;
if (child.Visibility != Visibility.Visible)
return;
var transform = viewport.Transform;
Size elementSize = GetElementSize(child, AvailableSize, transform);
child.Measure(elementSize);
Rect bounds = GetElementScreenBounds(transform, child);
child.Arrange(bounds);
var viewportBounds = Viewport2D.GetContentBounds(this);
if (!viewportBounds.IsEmpty)
overallViewportBounds = viewportBounds;
UniteWithBounds(transform, bounds);
if (!InBatchAdd)
{
Viewport2D.SetContentBounds(this, overallViewportBounds);
ContentBoundsChanged.Raise(this);
}
}
public static BitmapImage GenerateImage(FrameworkElement pFE, int pWidth, int pHeight)
{;
pFE.Width = pWidth;
pFE.Height = pHeight;
System.Windows.Size theTargetSize = new System.Windows.Size(pWidth, pHeight);
pFE.Measure(new System.Windows.Size(double.PositiveInfinity, double.PositiveInfinity));
pFE.Arrange(new Rect(theTargetSize));
// to affect the changes in the UI, you must call this method at the end to apply the new changes
pFE.UpdateLayout();
pFE.InvalidateMeasure();
pFE.InvalidateArrange();
pFE.InvalidateVisual();
var imgEncoder = new PngBitmapEncoder();
imgEncoder.Interlace = PngInterlaceOption.Off;
RenderTargetBitmap bmpSource = new RenderTargetBitmap((int)pWidth, (int)pHeight, 96, 96, PixelFormats.Pbgra32);
bmpSource.Render(pFE);
imgEncoder.Frames.Add(BitmapFrame.Create(bmpSource));
BitmapImage result = new BitmapImage();
using (var stream = new MemoryStream())
{
imgEncoder.Save(stream);
stream.Seek(0, SeekOrigin.Begin);
result.BeginInit();
// According to MSDN, "The default OnDemand cache option retains access to the stream until the image is needed."
// Force the bitmap to load right now so we can dispose the stream.
result.CacheOption = BitmapCacheOption.OnLoad;
result.StreamSource = stream;
result.EndInit();
// result.Freeze();
}
return result;
}
public void AddVisualToCanvas(FrameworkElement visual, Body body)
{
if (body != null)
{
new BodyVisualHelper(visual, body);
}
//hasn't been rendered yet, so needs to work out it's size
if (visual.ActualWidth == 0 && visual.ActualHeight == 0)
{
Debug.Assert(ActualWidth != 0 && ActualHeight != 0);
visual.Arrange(new Rect(0, 0, ActualWidth, ActualHeight));
}
Children.Add(visual);
visual.IsHitTestVisible = true;
}
/// <summary>
/// Method for safe printing all on one page
/// </summary>
/// <param name="v">Visual to be printed</param>
/// <param name="page">Page to be printed</param>
private void Print(Visual v, int page)
{
System.Windows.FrameworkElement e = v as System.Windows.FrameworkElement;
if (e == null)
{
return;
}
PrintDialog pd = new PrintDialog();
// mandate specific page
pd.UserPageRangeEnabled = false;
pd.PageRange = new PageRange(page);
// set to id maker
try
{
pd.PrintQueue = new System.Printing.PrintQueue(new System.Printing.PrintServer(), Properties.Settings.Default.PrinterName);
}
catch (Exception ex)
{
#if DEBUG
MessageBox.Show("Exception caught during printer choosing.\r\n\r\n" +
ex.Message +
"\r\nCurrent printer in Properties.Resources: " +
Properties.Settings.Default.PrinterName + ".",
"Exception",
MessageBoxButton.OK,
MessageBoxImage.Error);
#else
MessageBoxResult exRes = MessageBox.Show("Ensure your " +
Properties.Settings.Default.PrinterName +
" is plugged in and ready." +
"\r\n\r\nPrint to another printer?",
"Error printing.",
MessageBoxButton.OKCancel,
MessageBoxImage.Error,
MessageBoxResult.Cancel);
switch (exRes)
{
case MessageBoxResult.OK:
break;
case MessageBoxResult.Cancel:
return;
}
#endif
}
if (pd.ShowDialog().Value)
{
//store original scale
Transform originalScale = e.LayoutTransform;
//get selected printer capabilities
System.Printing.PrintCapabilities capabilities = pd.PrintQueue.GetPrintCapabilities(pd.PrintTicket);
//get scale of the print wrt to screen of WPF visual
double scale = Math.Min(capabilities.PageImageableArea.ExtentWidth / e.ActualWidth, capabilities.PageImageableArea.ExtentHeight /
e.ActualHeight);
//Transform the Visual to scale
e.LayoutTransform = new ScaleTransform(scale, scale);
//get the size of the printer page
System.Windows.Size sz = new System.Windows.Size(capabilities.PageImageableArea.ExtentWidth, capabilities.PageImageableArea.ExtentHeight);
//update the layout of the visual to the printer page size.
e.Measure(sz);
e.Arrange(new System.Windows.Rect(new System.Windows.Point(capabilities.PageImageableArea.OriginWidth, capabilities.PageImageableArea.OriginHeight), sz));
//now print the visual to printer to fit on the one page.
pd.PrintVisual(v, "My Print");
//apply the original transform.
e.LayoutTransform = originalScale;
}
}
/// <summary>
/// This tells a visual to render itself to a wpf bitmap. From there, you can get the bytes (colors), or run it through a converter
/// to save as jpg, bmp files.
/// </summary>
/// <remarks>
/// This fixes an issue where the rendered image is blank:
/// http://blogs.msdn.com/b/jaimer/archive/2009/07/03/rendertargetbitmap-tips.aspx
/// </remarks>
public static BitmapSource RenderControl(FrameworkElement visual, int width, int height, bool isInVisualTree)
{
if (!isInVisualTree)
{
// If the visual isn't part of the visual tree, then it needs to be forced to finish its layout
visual.Width = width;
visual.Height = height;
visual.Measure(new Size(width, height)); // I thought these two statements would be expensive, but profiling shows it's mostly all on Render
visual.Arrange(new Rect(0, 0, width, height));
}
RenderTargetBitmap retVal = new RenderTargetBitmap(width, height, DPI, DPI, PixelFormats.Pbgra32);
DrawingVisual dv = new DrawingVisual();
using (DrawingContext ctx = dv.RenderOpen())
{
VisualBrush vb = new VisualBrush(visual);
ctx.DrawRectangle(vb, null, new Rect(new Point(0, 0), new Point(width, height)));
}
retVal.Render(dv); // profiling shows this is the biggest hit
return retVal;
}
/// <summary>
/// Recalculate the size of a FrameworkElement
/// </summary>
/// <param name="element">The FrameworkElement to recalculate the size for</param>
public static void RecalculateSize(FrameworkElement element)
{
element.Measure(new Size(Double.PositiveInfinity, Double.PositiveInfinity));
element.Arrange(new Rect(element.DesiredSize));
}
private static void PrepareForExport(FrameworkElement element)
{
if (element.ActualWidth == 0 && element.ActualHeight == 0)
{
double width = element.Width > 0 ? element.Width : 500;
double height = element.Height > 0 ? element.Height : 300;
element.Measure(Size.Empty);
element.Measure(new Size(width, height));
element.Arrange(new Rect(0, 0, width, height));
element.UpdateLayout();
}
}
public RenderTargetBitmap SaveControl(FrameworkElement Target)
{
FrameworkElement Parent = Target.Parent as FrameworkElement;
double ParentWidth, ParentHeight;
if (Parent == null)
{
ParentWidth = 1000;
ParentHeight = 1000;
Canvas ParentCanvas = new Canvas();
ParentCanvas.Children.Add(Target);
Parent = ParentCanvas;
}
else
{
ParentWidth = Parent.ActualWidth;
ParentHeight = Parent.ActualHeight;
}
Target.Measure(new Size(ParentWidth, ParentHeight));
Target.Arrange(new Rect(0, 0, ParentWidth, ParentHeight));
Target.Measure(new Size(Target.ActualWidth, Target.ActualHeight));
Target.Arrange(new Rect(0, 0, Target.ActualWidth, Target.ActualHeight));
Rect Rect = Target.TransformToVisual(Parent).TransformBounds(new Rect(0, 0, Target.ActualWidth, Target.ActualHeight));
Target.Arrange(new Rect(-Rect.Left, -Rect.Top, Target.ActualWidth, Target.ActualHeight));
RenderTargetBitmap r = new RenderTargetBitmap((int)Rect.Width, (int)Rect.Height, 96.0, 96.0, PixelFormats.Pbgra32);
r.Render(Target);
return r;
}
public void AddVisualToCanvas(FrameworkElement visual, Body body)
{
if (body != null)
new BodyVisualHelper(visual, body);
//hasn't been rendered yet, so needs to work out it's size
if (visual.ActualWidth.Equals(0) && visual.ActualHeight.Equals(0))
{
visual.Arrange(new Rect(0, 0, ActualWidth, ActualHeight));
}
Children.Add(visual);
visual.IsHitTestVisible = true;
}
/// <summary>
/// The modify position.
/// </summary>
/// <param name="fe">
/// The fe.
/// </param>
private static void ModifyPosition(FrameworkElement fe)
{
var fs = new Size(
fe.ActualWidth + fe.Margin.Left + fe.Margin.Right, fe.ActualHeight + fe.Margin.Top + fe.Margin.Bottom);
fe.Measure(fs);
fe.Arrange(new Rect(-fe.Margin.Left, -fe.Margin.Top, fs.Width, fs.Height));
}
public ImageSource ToImageSource(FrameworkElement obj)
{
// Save current canvas transform
Transform transform = obj.LayoutTransform;
// fix margin offset as well
Thickness margin = obj.Margin;
obj.Margin = new Thickness(0, 0,
margin.Right - margin.Left, margin.Bottom - margin.Top);
// Get the size of canvas
Size size = new Size(obj.ActualWidth, obj.ActualHeight);
// force control to Update
obj.Measure(size);
obj.Arrange(new Rect(size));
RenderTargetBitmap bmp = new RenderTargetBitmap(
(int)obj.ActualWidth, (int)obj.ActualHeight, 96, 96, PixelFormats.Pbgra32);
bmp.Render(obj);
// return values as they were before
obj.LayoutTransform = transform;
obj.Margin = margin;
return bmp;
}
/// <summary>
/// Convert any control to a PngBitmapEncoder
/// </summary>
/// <param name="controlToConvert">The control to convert to an ImageSource</param>
/// <returns>The returned ImageSource of the controlToConvert</returns>
private static PngBitmapEncoder GetEncoderOfControl(FrameworkElement controlToConvert)
{
// save current canvas transform
Transform transform = controlToConvert.LayoutTransform;
// get size of control
var sizeOfControl = new Size(controlToConvert.Width, controlToConvert.Height);
if (!sizeOfControl.Height.Equals(double.NaN) && !sizeOfControl.Width.Equals(double.NaN))
{
// measure and arrange the control
controlToConvert.Measure(sizeOfControl);
// arrange the surface
controlToConvert.Arrange(new Rect(sizeOfControl));
}
else
{
sizeOfControl = new Size(1, 1);
}
// craete and render surface and push bitmap to it
var renderBitmap = new RenderTargetBitmap((Int32)sizeOfControl.Width, (Int32)sizeOfControl.Height, 96d,
96d, PixelFormats.Pbgra32);
// now render surface to bitmap
renderBitmap.Render(controlToConvert);
// encode png data.
//todo: investigate the best format for our needs
var pngEncoder = new PngBitmapEncoder();
// puch rendered bitmap into it
pngEncoder.Frames.Add(BitmapFrame.Create(renderBitmap));
// return encoder
return pngEncoder;
}
/// <summary>
/// Convert any control to a PngBitmapEncoder
/// </summary>
/// <param name="controlToConvert"> The control to convert to an ImageSource </param>
/// <returns> The returned ImageSource of the controlToConvert </returns>
/// <see cref="http://www.dreamincode.net/code/snippet4326.htm" />
public static PngBitmapEncoder GetImageFromControl(FrameworkElement controlToConvert)
{
// get size of control
var sizeOfControl = new System.Windows.Size(controlToConvert.ActualWidth, controlToConvert.ActualHeight);
// measure and arrange the control
controlToConvert.Measure(sizeOfControl);
// arrange the surface
controlToConvert.Arrange(new Rect(sizeOfControl));
// craete and render surface and push bitmap to it
var renderBitmap = new RenderTargetBitmap((Int32)sizeOfControl.Width, (Int32)sizeOfControl.Height, 96d, 96d, PixelFormats.Pbgra32);
// now render surface to bitmap
renderBitmap.Render(controlToConvert);
// encode png data
var pngEncoder = new PngBitmapEncoder();
// puch rendered bitmap into it
pngEncoder.Frames.Add(BitmapFrame.Create(renderBitmap));
//pngEncoder.Metadata = new BitmapMetadata("png") {
// ApplicationName = "Marvelous",
// DateTaken = DateTime.Now.ToString(CultureInfo.InvariantCulture),
// Subject = "Casual Loop Analysis using Marvel",
// Title = "Marvelous screenshot",
// Author = new ReadOnlyCollection<string>(new List<string> {
// Properties.Settings.Default.UserName
// })
// };
// return encoder
return pngEncoder;
}
public static BitmapSource SaveImageSource(FrameworkElement obj, int width, int height)
{
// Save current canvas transform
obj.LayoutTransform = null;
obj.Width = width;
obj.Height = height;
obj.UpdateLayout();
obj.UpdateLayout();
// fix margin offset as well
Thickness margin = obj.Margin;
obj.Margin = new Thickness(0, 0,
margin.Right - margin.Left, margin.Bottom - margin.Top);
// Get the size of canvas
Size size = new Size(width, height);
// force control to Update
obj.Measure(size);
obj.Arrange(new Rect(size));
RenderTargetBitmap bmp = new RenderTargetBitmap(
width, height, 96, 96, PixelFormats.Pbgra32);
bmp.Render(obj);
//// return values as they were before
//obj.LayoutTransform = transform;
//obj.Margin = margin;
obj = null;
return bmp;
}
/// <summary>
/// Convert a FrameworkElement to BitmapImage.
/// </summary>
/// <param name="element">FrameworkElement</param>
/// <param name="outerSize">Target outer size</param>
/// <returns>BitmapImage of FrameworkElement</returns>
/// <remarks>A FrameworkElement instantiated by UI thread cannot be accessed by sub thread.
/// So, there is not much merit in making asynchronous version.</remarks>
internal static BitmapImage ConvertFrameworkElementToBitmapImage(FrameworkElement element, Size outerSize)
{
if (Double.IsNaN(element.Width) || (element.Width <= 0) ||
Double.IsNaN(element.Height) || (element.Height <= 0))
throw new ArgumentException("The element is invalid.", "element");
try
{
element.Arrange(new Rect(new Size(element.Width, element.Height))); // This is necessary to render a image.
var target = (Visual)element;
var targetSize = new Size(element.Width, element.Height);
if (outerSize != Size.Empty)
{
targetSize = GetSizeUniform(element.Width, element.Height, outerSize);
var dv = new DrawingVisual()
{
Transform = new ScaleTransform(
targetSize.Width / element.Width,
targetSize.Height / element.Height),
};
using (var dc = dv.RenderOpen())
{
dc.DrawRectangle(new VisualBrush(element), null, new Rect(new Size(element.Width, element.Height)));
}
target = dv;
}
//source.Arrange(new Rect(targetSize)); // This is necessary to render a image.
var rtb = new RenderTargetBitmap(
(int)targetSize.Width, (int)targetSize.Height,
96, 96,
PixelFormats.Pbgra32);
rtb.Render(target);
using (var ms = new MemoryStream())
{
var encoder = new PngBitmapEncoder(); // PNG format is for transparent color.
encoder.Frames.Add(BitmapFrame.Create(rtb));
encoder.Save(ms);
return ConvertStreamToBitmapImage(ms);
}
}
catch (Exception ex)
{
Debug.WriteLine("Failed to convert a FrameworkElement to BitmapImage. {0}", ex);
throw;
}
}
private Stream RenderImage(FrameworkElement c)
{
c.Measure(new Size(c.Width, Double.IsNaN(c.Height) ? 9999 : c.Height));
c.Arrange(new Rect(c.DesiredSize));
RenderTargetBitmap renderBitmap = new RenderTargetBitmap((int)c.ActualWidth,
(int)c.ActualHeight, 96, 96, PixelFormats.Pbgra32);
renderBitmap.Render(c);
//DrawingVisual visual = new DrawingVisual();
//using (DrawingContext context = visual.RenderOpen()) {
// VisualBrush brush = new VisualBrush(c);
// context.DrawRectangle(brush, null, new Rect(c.RenderSize));
//}
//visual.Transform = new ScaleTransform(width / c.ActualWidth, height / c.ActualHeight);
//renderBitmap.Render(visual);
var stream = new MemoryStream();
var encoder = new PngBitmapEncoder();
encoder.Frames.Add(BitmapFrame.Create(renderBitmap));
encoder.Save(stream);
return stream;
}
public static void Print(FrameworkElement visual)
{
PrintDialog dialog = new PrintDialog();
if (dialog.ShowDialog() == true)
{
System.Printing.PrintCapabilities capabilities = dialog.PrintQueue.GetPrintCapabilities(dialog.PrintTicket);
double scale = Math.Min(capabilities.PageImageableArea.ExtentWidth / visual.ActualWidth, capabilities.PageImageableArea.ExtentHeight / visual.ActualHeight);
Transform originalTransform = visual.LayoutTransform;
visual.LayoutTransform = new ScaleTransform(scale, scale);
Size sz = new Size(capabilities.PageImageableArea.ExtentWidth, capabilities.PageImageableArea.ExtentHeight);
visual.Measure(sz);
visual.Arrange(new Rect(new Point(capabilities.PageImageableArea.OriginWidth, capabilities.PageImageableArea.OriginHeight), sz));
dialog.PrintVisual(visual, "Chart");
visual.LayoutTransform = originalTransform;
}
}
