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 Size UpdateAndMeasure(FrameworkElement element) { element.LayoutTransform = ChildRenderTransform; element.UpdateLayout(); element.Measure(new Size(BodySize.Width, double.PositiveInfinity)); return element.DesiredSize; }
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); }
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 bool TryAdd(FrameworkElement control) { control.Measure(new Size(Width, Height)); Children.Add(control); var sizeAfterControlHasBeenAdded = MeasureOverride(new Size(Width, Height)); // If the new size is larger than the WrapPanel remove the control and return false if (sizeAfterControlHasBeenAdded.Width > Width || sizeAfterControlHasBeenAdded.Height > Height) { Children.Remove(control); return false; } return true; }
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); }
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); } }
/// <summary> /// Calculates visual size /// </summary> /// <param name="visual">Visual as FrameworkElement</param> /// <returns>Visual size</returns> public static Size CalculateVisualSize(FrameworkElement visual) { Size retVal = new Size(0,0); if (visual != null) { visual.Measure(new Size(Double.MaxValue, Double.MaxValue)); retVal = visual.DesiredSize; } return retVal; }
/// <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)); }
/// <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> /// The modify position back. /// </summary> /// <param name="fe"> /// The fe. /// </param> private static void ModifyPositionBack(FrameworkElement fe) { fe.Measure(new Size()); }
/// <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; }
partial void InitializeBusyIndicator() { if (BusyIndicator != null) { return; } BusyIndicator = CreateBusyIndicator(); BusyIndicator.DataContext = _busyIndicatorDataContext; _containerPopup = new Popup(); _containerPopup.VerticalAlignment = VerticalAlignment.Center; _containerPopup.HorizontalAlignment = HorizontalAlignment.Center; _containerPopup.Child = BusyIndicator; _containerPopup.LayoutUpdated += (sender, e) => { if (Application.Current == null) { return; } // 1 is the default old behavior but since we set both horizontal and vertical offset, we might // be causing a "Layout cycle" _skipLayoutUpdateCount++; if (_skipLayoutUpdateCount < 2) { return; } _skipLayoutUpdateCount = 0; var parent = _parent.Target as FrameworkElement; if (parent == null) { return; } try { if (parent.ActualHeight == 0.0d && parent.ActualWidth == 0.0d) { Hide(); return; } var transform = parent.TransformToVisual(Application.Current.RootVisual); var offset = transform.Transform(new Point(0, 0)); double parentTop = offset.Y; double parentLeft = offset.X; // Allow fallback to root (Host.Content) double parentWidth = Application.Current.Host.Content.ActualWidth; double parentHeight = Application.Current.Host.Content.ActualHeight; if (_parent != null) { parentWidth = (parent.ActualWidth > 0) ? parent.ActualWidth : parentWidth; parentHeight = (parent.ActualHeight > 0) ? parent.ActualHeight : parentHeight; } BusyIndicator.Measure(new System.Windows.Size(parentWidth, parentHeight)); var busyIndicatorSize = BusyIndicator.DesiredSize; double indicatorWidth = (busyIndicatorSize.Width > 0) ? busyIndicatorSize.Width : DefaultBusyIndicatorWidth; double indicatorHeight = (busyIndicatorSize.Height > 0) ? busyIndicatorSize.Height : DefaultBusyIndicatorHeight; _containerPopup.HorizontalOffset = parentLeft + ((parentWidth / 2) - (indicatorWidth / 2)); _containerPopup.VerticalOffset = parentTop + ((parentHeight / 2) - (indicatorHeight / 2)); } catch (Exception) { // Ignore } }; return; }
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 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; }
public static void SetClip(FrameworkElement element) { element.Measure(new Size(double.PositiveInfinity, double.PositiveInfinity)); element.Clip = new RectangleGeometry { Rect = new Rect(0, 0, element.ActualWidth, element.ActualHeight) }; }
public static void animateExpand(FrameworkElement elem) { if (elem.ActualHeight < 20) { elem.Height = double.NaN; //auto height elem.Visibility = Visibility.Visible; elem.Measure(new Size(2000,2000)); double height = (elem.DesiredSize.Height > 0) ? elem.DesiredSize.Height : elem.ActualHeight; DoubleAnimation pAnimation = createDoubleAnimation(height, 1000, false); elem.Height = 0; elem.Visibility = Visibility.Visible; pAnimation.FillBehavior = FillBehavior.Stop; pAnimation.Completed += delegate(object sender, EventArgs pEvent) { elem.Height = Double.NaN; //elem.BeginAnimation(FrameworkElement., null); }; //pAnimation.Freeze(); elem.BeginAnimation(FrameworkElement.HeightProperty, pAnimation, HandoffBehavior.SnapshotAndReplace); } }
/// <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> /// Measures the height of an element /// </summary> /// <param name="element"></param> /// <returns></returns> private double MeasureHeight(FrameworkElement element) { if (element == null) throw new ArgumentNullException("element"); element.Measure(this.PageSize); return element.DesiredSize.Height; }
public void DisplayViewInSplitPanel(string url, NavigationParameters parameter) { Action operation = () => { var uri = new Uri(url, UriKind.Relative); _loadedEdgePanel = (FrameworkElement)Application.LoadComponent(uri); _loadedEdgePanel.Loaded += (sender, evt) => SplitterPanelLoaded(sender, evt, parameter); _splitWindowContent.Children.Clear(); var contains = _splitWindowContent.Children.Contains(_loadedEdgePanel); _splitWindowContent.Children.Add(_loadedEdgePanel); // Force the metro window to calculate the size of the user control. _loadedEdgePanel.Measure(new Size(double.PositiveInfinity, double.PositiveInfinity)); _splitWindowContent.Measure(new Size(double.PositiveInfinity, double.PositiveInfinity)); _splitWindow.Measure(new Size(double.PositiveInfinity, double.PositiveInfinity)); DisplayEdgePanel(); }; if (_isEdgePanelOpen) { HideEdgePanel(operation); } else { operation(); } }
/// <summary> /// Measures the height of an element /// </summary> /// <param name="element"></param> /// <returns></returns> private double MeasureHeight(FrameworkElement element) { if (element == null) throw new ArgumentNullException("element"); double width = this.PageSize.Width - (this.PageMargin.Left + this.PageMargin.Right); double height = this.PageSize.Height - (this.PageMargin.Top + this.PageMargin.Bottom); element.Measure(new Size(width, height)); return element.DesiredSize.Height; }
private static bool TryPlacePopup(Windows.Popup popup, FrameworkElement parent, FrameworkElement placementParent, FrameworkElement placementChild, PopupOrientation orientation) { var availableWidth = placementParent.ActualWidth; var availableHeight = placementParent.ActualHeight; SetActualOrientation(popup, orientation); placementChild.Measure(new Size(availableWidth, availableHeight)); var requiredWidth = placementChild.DesiredSize.Width; var requiredHeight = placementChild.DesiredSize.Height; var placementTarget = GetPlacementTarget(popup) ?? parent; var parentTransform = placementTarget.TransformToVisual(parent); var popupLocation = parentTransform.Transform(new Point(0, 0)); switch (orientation.Placement) { case PopupPlacement.Top: popupLocation.Y -= requiredHeight; break; case PopupPlacement.Bottom: popupLocation.Y += placementTarget.ActualHeight; break; case PopupPlacement.Left: popupLocation.X -= requiredWidth; break; case PopupPlacement.Right: popupLocation.X += placementTarget.ActualWidth; break; } if (orientation.Placement == PopupPlacement.Top || orientation.Placement == PopupPlacement.Bottom) { switch (orientation.HorizontalAlignment) { case PopupHorizontalAlignment.RightCenter: popupLocation.X += ((placementTarget.ActualWidth / 2) - requiredWidth); break; case PopupHorizontalAlignment.Center: popupLocation.X += ((placementTarget.ActualWidth - requiredWidth) / 2); break; case PopupHorizontalAlignment.LeftCenter: popupLocation.X += (placementTarget.ActualWidth / 2); break; case PopupHorizontalAlignment.Right: popupLocation.X += (placementTarget.ActualWidth - requiredWidth); break; } } if (orientation.Placement == PopupPlacement.Left || orientation.Placement == PopupPlacement.Right) { switch (orientation.VerticalAlignment) { case PopupVerticalAlignment.BottomCenter: popupLocation.Y += ((placementTarget.ActualHeight / 2) - requiredHeight); break; case PopupVerticalAlignment.Center: popupLocation.Y += ((placementTarget.ActualHeight - requiredHeight) / 2); break; case PopupVerticalAlignment.TopCenter: popupLocation.Y += (placementTarget.ActualHeight / 2); break; case PopupVerticalAlignment.Bottom: popupLocation.Y += (placementTarget.ActualHeight - requiredHeight); break; } } var popupLocationRelativeToPlacementParent = popupLocation; if (parent != placementParent) { var placementParentTransform = placementTarget.TransformToVisual(placementParent); popupLocationRelativeToPlacementParent = placementParentTransform.Transform(popupLocation); } if (popupLocationRelativeToPlacementParent.X < 0 || popupLocationRelativeToPlacementParent.Y < 0 || (popupLocationRelativeToPlacementParent.X + requiredWidth) > availableWidth || (popupLocationRelativeToPlacementParent.Y + requiredHeight) > availableHeight) { // not enough room return false; } popup.HorizontalOffset = popupLocation.X; popup.VerticalOffset = popupLocation.Y; return true; }
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; }
private static Size GetDesiredSize(FrameworkElement cell, Size maxSize) { double width = cell.Width; double height = cell.Height; cell.Width = double.NaN; cell.Height = double.NaN; cell.Measure(maxSize); Size desiredSize = cell.DesiredSize; cell.Width = width; cell.Height = height; return desiredSize; }
public static void AskToPrint( FrameworkElement ctrl , string printJobDesc = "Scaled Visual") { PrintDialog print = new PrintDialog(); if (print.ShowDialog() != true) return; PrintCapabilities capabilities = print.PrintQueue.GetPrintCapabilities(print.PrintTicket); double scale = Math.Min(capabilities.PageImageableArea.ExtentWidth / ctrl.ActualWidth, capabilities.PageImageableArea.ExtentHeight / ctrl.ActualHeight); //Transform oldTransform = ctrl.LayoutTransform; ctrl.LayoutTransform = new ScaleTransform(scale, scale); //Size oldSize = new Size(ctrl.ActualWidth, ctrl.ActualHeight); Size sz = new Size(capabilities.PageImageableArea.ExtentWidth, capabilities.PageImageableArea.ExtentHeight); ctrl.Measure(sz); ((UIElement)ctrl).Arrange(new Rect(new Point(capabilities.PageImageableArea.OriginWidth, capabilities.PageImageableArea.OriginHeight), sz)); ctrl.Focus(); print.PrintVisual(ctrl, printJobDesc); //ctrl.LayoutTransform = oldTransform; //ctrl.Measure(oldSize); //((UIElement)ctrl).Arrange(new Rect(new Point(0, 0), // oldSize)); }
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; } }