[DevTools] Allowed to take a screenshot of the currently selected control.

src/Avalonia.Diagnostics/Diagnostics/Convetions.cs

@@ -0,0 +1,46 @@
+using System;
+using System.Reflection;
+using Avalonia.Controls;
+using Avalonia.VisualTree;
+
+namespace Avalonia.Diagnostics
+{
+    static class Convetions
+    {
+        public static string DefaultScreenshotRoot =>
+             System.IO.Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyPictures, Environment.SpecialFolderOption.Create),
+                "ScreenShot");
+
+        /// <summary>
+        /// Return the path of the screenshot folder according to the rules indicated in issue <see href="https://github.com/AvaloniaUI/Avalonia/issues/4743">GH-4743</see>
+        /// </summary>
+        /// <param name="control"></param>
+        /// <returns>full file path</returns>
+        public static Func<IControl, string,string> DefaultScreenshotFileNameConvention = (control,screenshotRoot)  =>
+        {
+            IVisual root = control.VisualRoot is null
+             ? control
+             : control.VisualRoot ?? control.GetVisualRoot();
+            var rootType = root.GetType();
+            var windowName = rootType.Name;
+            if (root is IControl rc && !string.IsNullOrWhiteSpace(rc.Name))
+            {
+                windowName = rc.Name;
+            }
+
+            var assembly = Assembly.GetExecutingAssembly();
+            var appName = Application.Current?.Name
+                ?? assembly.GetCustomAttribute<AssemblyProductAttribute>()?.Product
+                ?? assembly.GetName().Name;
+            var appVerions = assembly.GetCustomAttribute<AssemblyInformationalVersionAttribute>().InformationalVersion
+                ?? assembly.GetCustomAttribute<AssemblyVersionAttribute>().Version;
+            var folder = System.IO.Path.Combine(screenshotRoot
+                , appName
+                , appVerions
+                , windowName);
+
+            return System.IO.Path.Combine(folder
+                                , $"{DateTime.Now:yyyyMMddhhmmssfff}.png");
+        };
+    }
+}

src/Avalonia.Diagnostics/Diagnostics/DevTools.cs

@@ -10,7 +10,8 @@ namespace Avalonia.Diagnostics
 {
     public static class DevTools
     {
-        private static readonly Dictionary<TopLevel, Window> s_open = new Dictionary<TopLevel, Window>();
+        private static readonly Dictionary<TopLevel, MainWindow> s_open = 
+            new Dictionary<TopLevel, MainWindow>();
 
         public static IDisposable Attach(TopLevel root, KeyGesture gesture)
         {
@@ -53,6 +54,8 @@ public static IDisposable Open(TopLevel root, DevToolsOptions options)
                     Height = options.Size.Height,
                 };
 
+                window.SetOptions(options);
+
                 window.Closed += DevToolsClosed;
                 s_open.Add(root, window);
 

src/Avalonia.Diagnostics/Diagnostics/DevToolsOptions.cs

@@ -1,4 +1,5 @@
-using Avalonia.Input;
+using System;
+using Avalonia.Input;
 
 namespace Avalonia.Diagnostics
 {
@@ -22,5 +23,18 @@ public class DevToolsOptions
         /// Gets or sets the initial size of the DevTools window. The default value is 1280x720.
         /// </summary>
         public Size Size { get; set; } = new Size(1280, 720);
+
+
+        /// <summary>
+        /// Get or sets the root folder where screeshot well be stored.
+        /// The default root folder is MyPictures/ScreenShot.
+        /// </summary>
+        public string? ScreenshotRoot { get; set; }
+
+        /// <summary>
+        /// Get or sets conventin for screenshot fileName.
+        ///For known default screen shot file name convection see <see href="https://github.com/AvaloniaUI/Avalonia/issues/4743">GH-4743</see>.
+        /// </summary>
+        public Func<Avalonia.Controls.IControl, string, string>? ScreenshotFileNameConvention { get; set; }
     }
 }

src/Avalonia.Diagnostics/Diagnostics/ViewModels/MainViewModel.cs

@@ -1,9 +1,13 @@
 using System;
 using System.ComponentModel;
-
+using System.Reactive.Linq;
+using System.Reflection;
+using System.Threading.Tasks;
 using Avalonia.Controls;
+using Avalonia.Controls.Shapes;
 using Avalonia.Diagnostics.Models;
 using Avalonia.Input;
+using Avalonia.Metadata;
 using Avalonia.Threading;
 
 namespace Avalonia.Diagnostics.ViewModels
@@ -22,6 +26,9 @@ internal class MainViewModel : ViewModelBase, IDisposable
         private bool _shouldVisualizeMarginPadding = true;
         private bool _shouldVisualizeDirtyRects;
         private bool _showFpsOverlay;
+        private IDisposable _selectedNodeChanged;
+        private string _screenshotRoot;
+        private Func<IControl, string, string> _getScreenshotFileName;
 
 #nullable disable
         // Remove "nullable disable" after MemberNotNull will work on our CI.
@@ -46,7 +53,7 @@ public bool ShouldVisualizeMarginPadding
             get => _shouldVisualizeMarginPadding;
             set => RaiseAndSetIfChanged(ref _shouldVisualizeMarginPadding, value);
         }
-        
+
         public bool ShouldVisualizeDirtyRects
         {
             get => _shouldVisualizeDirtyRects;
@@ -90,27 +97,43 @@ public ViewModelBase Content
             // [MemberNotNull(nameof(_content))]
             private set
             {
-                if (_content is TreePageViewModel oldTree &&
-                    value is TreePageViewModel newTree &&
-                    oldTree?.SelectedNode?.Visual is IControl control)
+                TreePageViewModel oldTree = _content as TreePageViewModel;
+                TreePageViewModel newTree = value as TreePageViewModel;
+                if (oldTree != null)
                 {
-                    // HACK: We want to select the currently selected control in the new tree, but
-                    // to select nested nodes in TreeView, currently the TreeView has to be able to
-                    // expand the parent nodes. Because at this point the TreeView isn't visible,
-                    // this will fail unless we schedule the selection to run after layout.
-                    DispatcherTimer.RunOnce(
-                        () =>
-                        {
-                            try
+                    _selectedNodeChanged?.Dispose();
+                    _selectedNodeChanged = null;
+                }
+
+                if (newTree != null)
+                {
+                    if (oldTree != null &&
+                        oldTree?.SelectedNode?.Visual is IControl control)
+                    {
+                        // HACK: We want to select the currently selected control in the new tree, but
+                        // to select nested nodes in TreeView, currently the TreeView has to be able to
+                        // expand the parent nodes. Because at this point the TreeView isn't visible,
+                        // this will fail unless we schedule the selection to run after layout.
+                        DispatcherTimer.RunOnce(
+                            () =>
                             {
-                                newTree.SelectControl(control);
-                            }
-                            catch { }
-                        },
-                        TimeSpan.FromMilliseconds(0),
-                        DispatcherPriority.ApplicationIdle);
+                                try
+                                {
+                                    newTree.SelectControl(control);
+                                }
+                                catch { }
+                            },
+                            TimeSpan.FromMilliseconds(0),
+                            DispatcherPriority.ApplicationIdle);
+                    }
+                    _selectedNodeChanged = Observable
+                        .FromEventPattern<PropertyChangedEventHandler, PropertyChangedEventArgs>(
+                            x => newTree.PropertyChanged += x,
+                            x => newTree.PropertyChanged -= x
+                        ).Subscribe(arg => RaisePropertyChanged(nameof(TreePageViewModel.SelectedNode)));
                 }
 
+
                 RaiseAndSetIfChanged(ref _content, value);
             }
         }
@@ -181,6 +204,7 @@ public void Dispose()
         {
             KeyboardDevice.Instance.PropertyChanged -= KeyboardPropertyChanged;
             _pointerOverSubscription.Dispose();
+            _selectedNodeChanged?.Dispose();
             _logicalTree.Dispose();
             _visualTree.Dispose();
             _root.Renderer.DrawDirtyRects = false;
@@ -213,5 +237,60 @@ public void RequestTreeNavigateTo(IControl control, bool isVisualTree)
                 tree.SelectControl(control);
             }
         }
+
+        [DependsOn(nameof(TreePageViewModel.SelectedNode))]
+        [DependsOn(nameof(Content))]
+        bool CanShot(object? paramter)
+        {
+            return Content is TreePageViewModel tree
+                && tree.SelectedNode != null
+                && tree.SelectedNode.Visual != null
+                && tree.SelectedNode.Visual.VisualRoot != null;
+        }
+
+        void Shot(object? parameter)
+        {
+            // This is a workaround because MethodToCommand does not support the asynchronous method.
+            Task.Factory.StartNew(arg =>
+                {
+                    if (arg is IControl control)
+                    {
+                        try
+                        {
+                            var filePath = _getScreenshotFileName(control, _screenshotRoot);
+                            var folder = System.IO.Path.GetDirectoryName(filePath);
+                            if (System.IO.Directory.Exists(folder) == false)
+                            {
+                                System.IO.Directory.CreateDirectory(folder);
+                            }
+
+                            var output = new System.IO.FileStream(filePath, System.IO.FileMode.Create);
+                            Dispatcher.UIThread.Post(() =>
+                                {
+                                    control.RenderTo(output);
+                                    output.Dispose();
+                                }
+                            );
+
+                        }
+                        catch (Exception ex)
+                        {
+                            System.Diagnostics.Debug.WriteLine(ex.Message);
+                            //TODO: Notify error
+                        }
+
+                    }
+                }, (Content as TreePageViewModel)?.SelectedNode?.Visual);
+        }
+
+        public void SetOptions(DevToolsOptions options)
+        {
+            _screenshotRoot = string.IsNullOrWhiteSpace(options.ScreenshotRoot)
+                ? Convetions.DefaultScreenshotRoot
+                : options.ScreenshotRoot!;
+
+            _getScreenshotFileName = options.ScreenshotFileNameConvention
+                ?? Convetions.DefaultScreenshotFileNameConvention;
+        }
     }
 }

src/Avalonia.Diagnostics/Diagnostics/Views/MainView.xaml

@@ -65,6 +65,8 @@
             BorderBrush="{DynamicResource ThemeControlMidBrush}"
             BorderThickness="0,1,0,0">
       <StackPanel Spacing="4" Orientation="Horizontal">
+        <TextBlock>Hold F8 to take a screenshot.</TextBlock>
+        <Separator Width="8"/>
         <TextBlock>Hold Ctrl+Shift over a control to inspect.</TextBlock>
         <Separator Width="8"/>
         <TextBlock>Focused:</TextBlock>

src/Avalonia.Diagnostics/Diagnostics/Views/MainWindow.xaml

@@ -18,6 +18,8 @@
     <StyleInclude Source="avares://Avalonia.Diagnostics/Diagnostics/Controls/ThicknessEditor.axaml" />
     <StyleInclude Source="avares://Avalonia.Diagnostics/Diagnostics/Controls/FilterTextBox.axaml" />
   </Window.Styles>
-
+  <Window.KeyBindings>
+    <KeyBinding Gesture="F8" Command="{Binding Shot}"/>
+  </Window.KeyBindings>
   <views:MainView/>
 </Window>

src/Avalonia.Diagnostics/Diagnostics/Views/MainWindow.xaml.cs

@@ -115,5 +115,8 @@ private void RawKeyDown(RawKeyEventArgs e)
         }
 
         private void RootClosed(object? sender, EventArgs e) => Close();
+
+        public void SetOptions(DevToolsOptions options) =>
+            (DataContext as MainViewModel)?.SetOptions(options);
     }
 }

src/Avalonia.Diagnostics/Diagnostics/VisualExtensions.cs

@@ -0,0 +1,63 @@
+using System.IO;
+using Avalonia.Controls;
+using Avalonia.Media.Imaging;
+using Avalonia.VisualTree;
+
+namespace Avalonia.Diagnostics
+{
+    static class VisualExtensions
+    {
+        /// <summary>
+        /// Rendered control to stream
+        /// </summary>
+        /// <param name="source">the control I want to render in the stream</param>
+        /// <param name="destination">destination destina</param>
+        /// <param name="dpi">(optional) dpi quality default 96</param>
+        public static void RenderTo(this IControl source, Stream destination, double dpi = 96)
+        {
+            var rect = source.Bounds;
+            var pixelSize = new PixelSize((int)rect.Width, (int)rect.Height);
+            var dpiVector = new Vector(dpi, dpi);
+
+            // get Visual root
+            var root = (source.VisualRoot 
+                ?? source.GetVisualRoot())
+                as IControl;
+
+            // Backup current vaules
+            var oldgeometry = root.Clip;
+            var oldClipToBounds = root.ClipToBounds;
+            var oldRenderTransformOrigin = root.RenderTransformOrigin;
+            var oldrenderTransform = root.RenderTransform;
+
+            try
+            {
+                // Translate coordinate clinet to root
+                var top = source.TranslatePoint(new Point(0,0), root);
+                var bottomRight = source.TranslatePoint(rect.BottomRight, root);
+
+                // Set clip region
+                var clipRegion = new Media.RectangleGeometry(new Rect(top.Value, bottomRight.Value));
+                root.ClipToBounds = true;
+                root.Clip = clipRegion;
+                // Traslate origin
+                root.RenderTransformOrigin = new RelativePoint(top.Value, RelativeUnit.Absolute);
+                root.RenderTransform = new Media.TranslateTransform(-top.Value.X, -top.Value.Y);
+                using (var bitmap = new RenderTargetBitmap(pixelSize, dpiVector))
+                {
+                    bitmap.Render(root);
+                    bitmap.Save(destination);
+                }
+
+            }
+            finally
+            {
+                // Restore current vaules
+                root.ClipToBounds = oldClipToBounds;
+                root.Clip = oldgeometry;
+                root.RenderTransformOrigin = oldRenderTransformOrigin;
+                root.RenderTransform = oldrenderTransform;
+            }
+        }
+    }
+}