public Size UpdateAndMeasure(FrameworkElement element) { element.LayoutTransform = ChildRenderTransform; element.UpdateLayout(); element.Measure(new Size(BodySize.Width, double.PositiveInfinity)); return element.DesiredSize; }
public void CenterScrollViewer(FrameworkElement controlToCenter = null) { if (controlToCenter == null) { HorizontalOffset = lessonContainerComponent.ScrollableWidth/2.0; VerticalOffset = lessonContainerComponent.ScrollableWidth/2.0; return; } controlToCenter.UpdateLayout(); if (controlToCenter.ActualWidth < lessonContainerComponent.ViewportWidth) { // Horizontal center the content of the scrollviewer HorizontalOffset = (lessonContainerComponent.ScrollableWidth - controlToCenter.Margin.Right)/2.0; } else { // Left center the content of the scrollviewer (with 25px left-margin) HorizontalOffset = ((drawingAreaComponent.ActualWidth - controlToCenter.ActualWidth - controlToCenter.Margin.Right)/2.0) - 25; } if (controlToCenter.ActualHeight < lessonContainerComponent.ViewportHeight) { // Vertical center the content of the scrollviewer VerticalOffset = (lessonContainerComponent.ScrollableHeight - controlToCenter.Margin.Right)/2.0; } else { // Top center the content of the scrollviewer (with 25px top-margin) VerticalOffset = ((drawingAreaComponent.ActualHeight - controlToCenter.ActualHeight - controlToCenter.Margin.Right)/2.0) - 25; } }
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(); }
private static void ForceRenderIfElementIsInsideAHiddenListView(FrameworkElement element) { //need this condition to force rendering for items that are non visual that we've been swapping //in and out of the hidden ListView. if (element is ListViewItem) { if (element.ActualWidth == 0.0 || element.ActualHeight == 0.0) { element.UpdateLayout(); } } }
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; }
public static void OpenParentRibbonGroupDropDownSync(FrameworkElement fe, bool templateApplied) { if (!templateApplied) { // Apply template if not yet applied. fe.ApplyTemplate(); } // Get the Parent RibbonGroup and open its dropdown if needed. RibbonGroup ribbonGroup = TreeHelper.FindAncestor(fe, delegate(DependencyObject element) { return (element is RibbonGroup); }) as RibbonGroup; if (ribbonGroup == null) { ribbonGroup = TreeHelper.FindLogicalAncestor<RibbonGroup>(fe); } if (ribbonGroup != null && ribbonGroup.IsCollapsed && !ribbonGroup.IsDropDownOpen) { ribbonGroup.IsDropDownOpen = true; fe.UpdateLayout(); } }
public static Stream CopyFrameworkElementToStream(FrameworkElement copyTarget, double width, double height, BitmapEncoder enc, Stream outStream, double? dpi) { if (copyTarget == null) return outStream; // Store the Frameworks current layout transform, as this will be restored later Transform storedTransform = copyTarget.LayoutTransform; // Set the layout transform to unity to get the nominal width and height copyTarget.LayoutTransform = new ScaleTransform(1, 1); copyTarget.UpdateLayout(); double baseHeight = copyTarget.ActualHeight; double baseWidth = copyTarget.ActualWidth; // Now scale the layout to fit the bitmap copyTarget.LayoutTransform = new ScaleTransform(baseWidth/width, baseHeight/height); copyTarget.UpdateLayout(); // Render to a Bitmap Source, the DPI is changed for the // render target as a way of scaling the FrameworkElement var rtb = new RenderTargetBitmap( (int) width, (int) height, 96d*width/baseWidth, 96d*height/baseHeight, PixelFormats.Default); rtb.Render(copyTarget); // Convert from a WinFX Bitmap Source to a Win32 Bitamp if (dpi == null) { enc.Frames.Add(BitmapFrame.Create(rtb)); } else { // Change the DPI var brush = new ImageBrush(BitmapFrame.Create(rtb)); var rtbDpi = new RenderTargetBitmap( (int) width, // PixelWidth (int) height, // PixelHeight (double) dpi, // DpiX (double) dpi, // DpiY PixelFormats.Default); var drawVisual = new DrawingVisual(); using (DrawingContext dc = drawVisual.RenderOpen()) { dc.DrawRectangle(brush, null, new Rect(0, 0, rtbDpi.Width, rtbDpi.Height)); } rtbDpi.Render(drawVisual); enc.Frames.Add(BitmapFrame.Create(rtbDpi)); } enc.Save(outStream); // Restore the Framework Element to it's previous state copyTarget.LayoutTransform = storedTransform; copyTarget.UpdateLayout(); return outStream; }
/// <summary> /// Note RenderTargetBitmap has a huge memory leak that was fixed in .NET 4.0 /// but only if you reference Winforms. /// </summary> /// <param name="copyTarget"></param> /// <param name="width"></param> /// <param name="height"></param> /// <param name="enc"></param> /// <param name="outStream"></param> /// <param name="dpi"></param> /// <returns></returns> public static Stream CopyFrameworkElementToStreamNew(FrameworkElement copyTarget, double width, double height, BitmapEncoder enc, Stream outStream, double dpi) { // Store the Frameworks current layout transform, as this will be restored later Transform storedLayoutTransform = copyTarget.LayoutTransform; Transform storedRenderTransform = copyTarget.RenderTransform; double scale = dpi / 96.0; width *= scale; height *= scale; copyTarget.RenderTransform = new ScaleTransform(scale, scale); // Set the layout transform to unity to get the nominal width and height copyTarget.LayoutTransform = new ScaleTransform(1, 1); copyTarget.UpdateLayout(); RenderTargetBitmap rtb; copyTarget.LayoutTransform = new ScaleTransform(1.0 / scale, 1.0 / scale); copyTarget.UpdateLayout(); // Render to a Bitmap Source, note that the DPI is changed for the // render target as a way of scaling the FrameworkElement rtb = new RenderTargetBitmap( (int)width, (int)height, dpi, dpi, PixelFormats.Default); rtb.Render(copyTarget); // Convert from a WinFX Bitmap Source to a Win32 Bitamp enc.Frames.Add(BitmapFrame.Create(rtb)); enc.Save(outStream); // Restore the Framework Element to it's previous state copyTarget.LayoutTransform = storedLayoutTransform; copyTarget.RenderTransform = storedRenderTransform; copyTarget.UpdateLayout(); return outStream; }
/// <summary> /// Copies a framework element to a bitmap stored in a memory stream /// </summary> /// <param name="copyTarget"></param> /// <param name="width"></param> /// <param name="height"></param> /// <param name="enc"></param> /// <param name="str"></param> /// <returns></returns> public static void CopyFrameworkElementToStream(FrameworkElement copyTarget, double width, double height, BitmapEncoder enc, Stream str) { // Store the Frameworks current layout transform, as this will be restored later Transform storedTransform = copyTarget.LayoutTransform; // Set the layout transform to unity to get the nominal width and height copyTarget.LayoutTransform = new ScaleTransform(1, 1); copyTarget.UpdateLayout(); double baseHeight = copyTarget.ActualHeight; double baseWidth = copyTarget.ActualWidth; // Now scale the layout to fit the bitmap copyTarget.LayoutTransform = new ScaleTransform(baseWidth / width, baseHeight / height); copyTarget.UpdateLayout(); // Render to a Bitmap Source, note that the DPI is changed for the // render target as a way of scaling the FrameworkElement RenderTargetBitmap rtb = new RenderTargetBitmap( (int)width, (int)height, 96d * width / baseWidth, 96d * height / baseHeight, PixelFormats.Default); rtb.Render(copyTarget); // Convert from a WPF Bitmap Source to a Win32 Bitamp enc.Frames.Add(BitmapFrame.Create(rtb)); enc.Save(str); // Restore the Framework Element to it's previous state copyTarget.LayoutTransform = storedTransform; copyTarget.UpdateLayout(); }
private void AttachTreeControlToParent(FrameworkElement control, FrameworkElement parent) { if(parent != null) { Line line = new Line() { StrokeThickness = 2.5, Stroke = Brushes.Black, SnapsToDevicePixels = true }; line.SetValue(RenderOptions.EdgeModeProperty, EdgeMode.Aliased); m_canvas_messageTree.Children.Add(line); parent.LayoutUpdated += (x, y) => { line.Y1 = Canvas.GetTop(parent) + parent.ActualHeight; line.X1 = Canvas.GetLeft(parent) + (parent.ActualWidth / 2); }; parent.UpdateLayout(); control.LayoutUpdated += (x, y) => { line.Y2 = Canvas.GetTop(control); line.X2 = Canvas.GetLeft(control) + (control.ActualWidth / 2); }; control.UpdateLayout(); } }
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(); } }
static void SetBlackImage(FrameworkElement element) { if (element is Panel) { var shapes = ((Panel)element).Children.OfType<System.Windows.Shapes.Shape>(); var blackBrush = new SolidColorBrush(Colors.Black); foreach (var shape in shapes) { shape.Fill = blackBrush; } element.UpdateLayout(); } }
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; }
private bool BringIntoViewScrollingCell( Cell cell, FrameworkElement container, RequestBringIntoViewEventArgs e ) { Debug.Assert( cell != null ); Debug.Assert( container != null ); // The cell must be measured/arranged for the BringIntoView to correctly reacts if( this.ForceScrollingCellToLayout( cell ) ) { container.UpdateLayout(); } var fixedWidth = this.GetFixedWidth(); var scrollingPanel = this.ScrollingCellsDecorator; var scrollingArea = new Rect( scrollingPanel.TranslatePoint( FixedCellPanel.EmptyPoint, this ), new Size( this.ParentScrollViewer.ViewportWidth - fixedWidth, scrollingPanel.ActualHeight ) ); var cellArea = new Rect( cell.TranslatePoint( FixedCellPanel.EmptyPoint, this ), new Size( cell.ParentColumn.ActualWidth, cell.ActualHeight ) ); // The cell is larger than the scrolling area. if( cellArea.Width > scrollingArea.Width ) { var targetObject = e.TargetObject as UIElement; var targetRect = e.TargetRect; // Try to narrow the area within the cell that we clearly want to bring into view. if( ( targetObject != null ) && ( targetObject != cell || !targetRect.IsEmpty ) ) { Debug.Assert( targetObject.IsDescendantOf( cell ) ); if( targetRect.IsEmpty ) { targetRect = new Rect( new Point( 0d, 0d ), targetObject.RenderSize ); } if( targetRect.Width <= scrollingArea.Width ) { var offset = targetObject.TranslatePoint( FixedCellPanel.EmptyPoint, cell ); var location = cellArea.Location; location.Offset( offset.X, offset.Y ); cellArea.Location = location; cellArea.Size = targetRect.Size; } } } if( ( cellArea.Left <= scrollingArea.Left ) && ( cellArea.Right >= scrollingArea.Right ) ) { // Ensure to bring the container into view vertically. container.BringIntoView(); } else if( cellArea.Left < scrollingArea.Left ) { // The ScrollViewer's extent width includes the fixed section. We must offset the target area or the cell // will come into view under the fixed panel. cellArea.X -= fixedWidth; this.BringIntoView( cellArea ); } else if( cellArea.Right > scrollingArea.Right ) { this.BringIntoView( cellArea ); } // The cell is fully visible. else { // Ensure to bring the container into view vertically. container.BringIntoView(); } return true; }
public void CallUpdateLayout(FrameworkElement el) { el.UpdateLayout(); }
private FrameworkElement SetInitialPosition(FrameworkElement control) { FrameworkElement lastControl = m_canvas_messageTree.Children.OfType<UserControl>().LastOrDefault(); double top = 0.0, left = 0.0; if(lastControl != null) { lastControl.UpdateLayout(); top = Canvas.GetTop(lastControl) + lastControl.ActualHeight + 50.0; left = Canvas.GetLeft(lastControl); } Canvas.SetTop(control, top); Canvas.SetLeft(control, left); control.UpdateLayout(); return control; }
internal void BeginEdit(FrameworkElement editingElement, RoutedEventArgs e) { // This call is to ensure that the tree and its bindings have resolved // before we proceed to code that relies on the tree being ready. if (editingElement != null) { editingElement.UpdateLayout(); object originalValue = PrepareCellForEdit(editingElement, e); SetOriginalValue(editingElement, originalValue); } }
void animate(FrameworkElement fm, double ms) { TranslateTransform trans = new TranslateTransform(); trans.X = 0; double maxHeight = 0; if (PlacementTarget != null) { OverlayAdornerDecorator overlayDecorator = OverlayAdornerDecorator.FindOverlayAdornerDecorator(PlacementTarget); if (overlayDecorator!= null) maxHeight = overlayDecorator.ActualHeight; } if (!Double.IsNaN(MaxHeight) && !Double.IsInfinity(MaxHeight)) { maxHeight = MaxHeight; } if (Placement == PlacementMode.Top) { trans.Y = maxHeight; } else { trans.Y = -maxHeight; } DoubleAnimation openAnimation = new DoubleAnimation(); openAnimation.Duration = TimeSpan.FromMilliseconds(ms * 0.5); openAnimation.To = 0; openAnimation.DecelerationRatio = 0.3; openAnimation.FillBehavior = FillBehavior.HoldEnd; // need to update because the glass Control needs the background before we start the animation fm.UpdateLayout(); fm.RenderTransform = trans; this.UpdatePlacement(fm.DesiredSize); trans.BeginAnimation(TranslateTransform.YProperty, openAnimation); }