Initial implementation of the ToolkitSampleButtonAttribute

CommunityToolkit.App.Shared/Renderers/ToolkitSampleRenderer.xaml

@@ -2,9 +2,11 @@
 <Page x:Class="CommunityToolkit.App.Shared.Renderers.ToolkitSampleRenderer"
       xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
       xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+      xmlns:converters="using:CommunityToolkit.WinUI.Converters"
       xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
       xmlns:local="using:CommunityToolkit.App.Shared"
       xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+      xmlns:metadata="using:CommunityToolkit.Tooling.SampleGen.Metadata"
       xmlns:muxc="using:Microsoft.UI.Xaml.Controls"
       xmlns:not_win="http://uno.ui/not_win"
       xmlns:renderer="using:CommunityToolkit.App.Shared.Renderers"
@@ -14,6 +16,10 @@
       Loaded="ToolkitSampleRenderer_Loaded"
       mc:Ignorable="d wasm not_win">
 
+    <Page.Resources>
+        <converters:CollectionVisibilityConverter x:Key="CollectionVisibilityConverter" />
+    </Page.Resources>
+
     <Grid CornerRadius="0">
         <Grid.RowDefinitions>
             <RowDefinition Height="*" />
@@ -49,7 +55,7 @@
                         <AdaptiveTrigger MinWindowWidth="0" />
                     </VisualState.StateTriggers>
                     <VisualState.Setters>
-                        <Setter Target="OptionsPanel.(Grid.Row)" Value="1" />
+                        <Setter Target="OptionsPanel.(Grid.Row)" Value="2" />
                         <Setter Target="OptionsPanel.(Grid.Column)" Value="0" />
                         <Setter Target="OptionsPanel.BorderThickness" Value="0,1,0,0" />
                         <Setter Target="FixedOptionsBar.BorderThickness" Value="0" />
@@ -76,6 +82,7 @@
               BorderThickness="1,1,1,1"
               CornerRadius="8">
             <Grid.RowDefinitions>
+                <RowDefinition Height="Auto" />
                 <RowDefinition Height="*" />
                 <RowDefinition Height="Auto" />
                 <RowDefinition Height="Auto" />
@@ -85,7 +92,32 @@
                 <ColumnDefinition Width="Auto" />
             </Grid.ColumnDefinitions>
 
+            <ScrollViewer x:Name="CommandsPanel"
+                          Grid.Row="0"
+                          Grid.Column="0"
+                          Padding="8"
+                          Visibility="{x:Bind Metadata.SampleButtons, Mode=OneWay, Converter={StaticResource CollectionVisibilityConverter}}">
+                <ItemsControl x:Name="CommandsControl"
+                              ItemsSource="{x:Bind Metadata.SampleButtons, Mode=OneWay}">
+                    <ItemsControl.ItemTemplate>
+                        <DataTemplate x:DataType="metadata:ToolkitSampleButtonCommand">
+                            <Button Command="{x:Bind (metadata:ToolkitSampleButtonCommand), Mode=OneWay}"
+                                    Content="{x:Bind Title, Mode=OneWay}" />
+                        </DataTemplate>
+                    </ItemsControl.ItemTemplate>
+                    <ItemsControl.ItemsPanel>
+                        <ItemsPanelTemplate>
+                            <StackPanel HorizontalAlignment="Left"
+                                        VerticalAlignment="Center"
+                                        Orientation="Horizontal"
+                                        Spacing="8" />
+                        </ItemsPanelTemplate>
+                    </ItemsControl.ItemsPanel>
+                </ItemsControl>
+            </ScrollViewer>
+
             <Grid x:Name="OptionsPanel"
+                  Grid.RowSpan="2"
                   Grid.Column="1"
                   VerticalAlignment="Stretch"
                   Background="{ThemeResource LayerFillColorDefaultBrush}"
@@ -178,6 +210,7 @@
             </Grid>
 
             <Grid x:Name="ContentPageHolder"
+                  Grid.Row="1"
                   Background="{ThemeResource CardBackgroundFillColorSecondaryBrush}">
                 <!--  A solidbackground we enable when toggling themes. WinUI uses a lot of translucent brushes and might look weird  -->
                 <Border x:Name="ThemeBG"
@@ -196,7 +229,7 @@
             </Grid>
 
             <muxc:Expander x:Name="SourcecodeExpander"
-                           Grid.Row="2"
+                           Grid.Row="3"
                            Grid.ColumnSpan="3"
                            MinHeight="0"
                            Margin="0,-1,0,0"

CommunityToolkit.App.Shared/Renderers/ToolkitSampleRenderer.xaml.cs

@@ -181,6 +181,15 @@ private async Task LoadData()
 
         var sampleControlInstance = (UIElement)Metadata.SampleControlFactory();
 
+        // Bind button commands to the sample instance so they can invoke methods via reflection.
+        if (Metadata.SampleButtons is not null)
+        {
+            foreach (var button in Metadata.SampleButtons)
+            {
+                button.BindToInstance(sampleControlInstance);
+            }
+        }
+
         // Custom control-based sample options.
         if (Metadata.SampleOptionsPaneType is not null && Metadata.SampleOptionsPaneFactory is not null)
         {

CommunityToolkit.Tooling.SampleGen.Tests/ToolkitSampleGeneratedPaneTests.cs

@@ -101,7 +101,7 @@ public static class ToolkitSampleRegistry
         {
             public static System.Collections.Generic.Dictionary<string, CommunityToolkit.Tooling.SampleGen.Metadata.ToolkitSampleMetadata> Listing
             { get; } = new() {
-                ["Sample"] = new CommunityToolkit.Tooling.SampleGen.Metadata.ToolkitSampleMetadata("Sample", "Test Sample", "", typeof(MyApp.Sample), () => new MyApp.Sample(), null, null, new CommunityToolkit.Tooling.SampleGen.Metadata.IGeneratedToolkitSampleOptionViewModel[] { new CommunityToolkit.Tooling.SampleGen.Metadata.ToolkitSampleNumericOptionMetadataViewModel(name: "TextSize", initial: 12, min: 8, max: 48, step: 2, showAsNumberBox: false, title: "FontSize") })
+                ["Sample"] = new CommunityToolkit.Tooling.SampleGen.Metadata.ToolkitSampleMetadata("Sample", "Test Sample", "", typeof(MyApp.Sample), () => new MyApp.Sample(), null, null, new CommunityToolkit.Tooling.SampleGen.Metadata.IGeneratedToolkitSampleOptionViewModel[] { new CommunityToolkit.Tooling.SampleGen.Metadata.ToolkitSampleNumericOptionMetadataViewModel(name: "TextSize", initial: 12, min: 8, max: 48, step: 2, showAsNumberBox: false, title: "FontSize") }, null)
             };
         }
         """, "Unexpected code generated");

CommunityToolkit.Tooling.SampleGen.Tests/ToolkitSampleMetadataTests.Buttons.cs

@@ -0,0 +1,258 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using CommunityToolkit.Tooling.SampleGen.Diagnostics;
+using CommunityToolkit.Tooling.SampleGen.Tests.Helpers;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using System.Collections.Immutable;
+using System.ComponentModel.DataAnnotations;
+
+namespace CommunityToolkit.Tooling.SampleGen.Tests;
+
+public partial class ToolkitSampleMetadataTests
+{
+    [TestMethod]
+    public void SampleButtonAttributeOnNonSample()
+    {
+        var source = """
+            using System.ComponentModel;
+            using CommunityToolkit.Tooling.SampleGen;
+            using CommunityToolkit.Tooling.SampleGen.Attributes;
+
+            namespace MyApp
+            {
+                public partial class Sample : Windows.UI.Xaml.Controls.UserControl
+                {
+                    [ToolkitSampleButton(Title = "Click Me")]
+                    private void OnButtonClick()
+                    {
+                    }
+                }
+            }
+
+            namespace Windows.UI.Xaml.Controls
+            {
+                public class UserControl { }
+            }
+            """;
+
+        var result = source.RunSourceGenerator<ToolkitSampleMetadataGenerator>(SAMPLE_ASM_NAME);
+
+        result.AssertDiagnosticsAre(DiagnosticDescriptors.SampleButtonAttributeOnNonSample);
+        result.AssertNoCompilationErrors();
+    }
+
+    [TestMethod]
+    public void SampleButtonAttributeValid()
+    {
+        var source = """
+            using System.ComponentModel;
+            using CommunityToolkit.Tooling.SampleGen;
+            using CommunityToolkit.Tooling.SampleGen.Attributes;
+
+            namespace MyApp
+            {
+                [ToolkitSample(id: nameof(Sample), "Test Sample", description: "")]
+                public partial class Sample : Windows.UI.Xaml.Controls.UserControl
+                {
+                    [ToolkitSampleButton(Title = "Click Me")]
+                    private void OnButtonClick()
+                    {
+                    }
+                }
+            }
+
+            namespace Windows.UI.Xaml.Controls
+            {
+                public class UserControl { }
+            }
+            """;
+
+        var result = source.RunSourceGenerator<ToolkitSampleMetadataGenerator>(SAMPLE_ASM_NAME);
+
+        result.AssertDiagnosticsAre(DiagnosticDescriptors.SampleNotReferencedInMarkdown);
+        result.AssertNoCompilationErrors();
+    }
+
+    [TestMethod]
+    public void SampleButtonAttributeMultipleButtons()
+    {
+        var source = """
+            using System.ComponentModel;
+            using CommunityToolkit.Tooling.SampleGen;
+            using CommunityToolkit.Tooling.SampleGen.Attributes;
+
+            namespace MyApp
+            {
+                [ToolkitSample(id: nameof(Sample), "Test Sample", description: "")]
+                public partial class Sample : Windows.UI.Xaml.Controls.UserControl
+                {
+                    [ToolkitSampleButton(Title = "Add Item")]
+                    private void AddItemClick()
+                    {
+                    }
+
+                    [ToolkitSampleButton(Title = "Clear Items")]
+                    private void ClearItemsClick()
+                    {
+                    }
+                }
+            }
+
+            namespace Windows.UI.Xaml.Controls
+            {
+                public class UserControl { }
+            }
+            """;
+
+        var result = source.RunSourceGenerator<ToolkitSampleMetadataGenerator>(SAMPLE_ASM_NAME);
+
+        result.AssertDiagnosticsAre(DiagnosticDescriptors.SampleNotReferencedInMarkdown);
+        result.AssertNoCompilationErrors();
+    }
+
+    [TestMethod]
+    public void SampleButtonCommand_GeneratedRegistryExecutesMethod()
+    {
+        // The sample registry is designed to be declared in the sample project,
+        // and generated in the project head. To test end-to-end execution of the
+        // generated button commands, we replicate this setup, verify the generated
+        // registry source, then execute the same command against a matching instance.
+        var sampleSource = """
+            using System.ComponentModel;
+            using CommunityToolkit.Tooling.SampleGen;
+            using CommunityToolkit.Tooling.SampleGen.Attributes;
+
+            namespace MyApp
+            {
+                [ToolkitSample(id: nameof(Sample), "Test Sample", description: "")]
+                public partial class Sample : Windows.UI.Xaml.Controls.UserControl
+                {
+                    public int Counter { get; set; }
+
+                    public Sample()
+                    {
+                    }
+
+                    [ToolkitSampleButton(Title = "Increment")]
+                    private void IncrementCounter()
+                    {
+                        Counter++;
+                    }
+                }
+            }
+
+            namespace Windows.UI.Xaml.Controls
+            {
+                public class UserControl { }
+            }
+            """;
+
+        // Compile sample project as a metadata reference for the generator
+        var sampleProjectAssembly = sampleSource.ToSyntaxTree()
+            .CreateCompilation("MyApp.Samples")
+            .ToMetadataReference();
+
+        // Create application head that references the sample project
+        var headCompilation = string.Empty
+            .ToSyntaxTree()
+            .CreateCompilation("MyApp.Head")
+            .AddReferences(sampleProjectAssembly);
+
+        // Run source generator to produce the registry
+        var result = headCompilation.RunSourceGenerator<ToolkitSampleMetadataGenerator>();
+
+        result.AssertDiagnosticsAre();
+        result.AssertNoCompilationErrors();
+
+        // Verify the generated registry contains the expected button command
+        var registrySource = result.Compilation.GetFileContentsByName("ToolkitSampleRegistry.g.cs");
+        StringAssert.Contains(registrySource, @"new CommunityToolkit.Tooling.SampleGen.Metadata.ToolkitSampleButtonCommand(""Increment"", ""IncrementCounter"")");
+
+        // Now verify the generated command mechanism works end-to-end
+        // by creating the same command the registry would and binding it to an instance
+        var testInstance = new SampleButtonCommandTestTarget();
+        Assert.AreEqual(0, testInstance.Counter);
+
+        var button = new Metadata.ToolkitSampleButtonCommand("Increment", "IncrementCounter");
+        button.BindToInstance(testInstance);
+
+        Assert.AreEqual("Increment", button.Title);
+        Assert.AreEqual("IncrementCounter", button.MethodName);
+        Assert.IsTrue(button.CanExecute(null!));
+
+        // Execute and verify the counter was incremented
+        button.Execute(null!);
+        Assert.AreEqual(1, testInstance.Counter);
+
+        button.Execute(null!);
+        Assert.AreEqual(2, testInstance.Counter);
+    }
+
+    [TestMethod]
+    public void SampleButtonCommand_AssemblyAttributeBridge()
+    {
+        // Verifies that the sample project emits assembly-level ToolkitSampleButtonDataAttribute
+        // and that the head project can read them to populate button commands in the registry.
+        // This tests the mechanism that bridges private method visibility across PE references.
+        var sampleSource = """
+            using System.ComponentModel;
+            using CommunityToolkit.Tooling.SampleGen;
+            using CommunityToolkit.Tooling.SampleGen.Attributes;
+
+            namespace MyApp
+            {
+                [ToolkitSample(id: nameof(Sample), "Test Sample", description: "")]
+                public partial class Sample : Windows.UI.Xaml.Controls.UserControl
+                {
+                    [ToolkitSampleButton(Title = "Increment")]
+                    private void IncrementCounter()
+                    {
+                    }
+                }
+            }
+
+            namespace Windows.UI.Xaml.Controls
+            {
+                public class UserControl { }
+            }
+            """;
+
+        // Step 1: Run the generator on the sample project to produce assembly-level button attributes
+        var sampleResult = sampleSource.RunSourceGenerator<ToolkitSampleMetadataGenerator>(SAMPLE_ASM_NAME);
+        sampleResult.AssertNoCompilationErrors();
+
+        // Verify the sample project generated the assembly-level button metadata
+        var buttonMetadataSource = sampleResult.Compilation.GetFileContentsByName("ToolkitSampleButtonMetadata.g.cs");
+        StringAssert.Contains(buttonMetadataSource, @"ToolkitSampleButtonDataAttribute(""MyApp.Sample"", ""IncrementCounter"", ""Increment"")");
+
+        // Step 2: Compile the sample project WITH the generated source and create a reference
+        var sampleWithGenerated = sampleResult.Compilation.ToMetadataReference();
+
+        // Step 3: Run the generator on the head project
+        var headCompilation = string.Empty
+            .ToSyntaxTree()
+            .CreateCompilation("MyApp.Head")
+            .AddReferences(sampleWithGenerated);
+
+        var headResult = headCompilation.RunSourceGenerator<ToolkitSampleMetadataGenerator>();
+
+        headResult.AssertDiagnosticsAre();
+        headResult.AssertNoCompilationErrors();
+
+        // Verify the head project's registry includes the button command
+        var registrySource = headResult.Compilation.GetFileContentsByName("ToolkitSampleRegistry.g.cs");
+        StringAssert.Contains(registrySource, @"new CommunityToolkit.Tooling.SampleGen.Metadata.ToolkitSampleButtonCommand(""Increment"", ""IncrementCounter"")");
+    }
+}
+
+/// <summary>
+/// Mirrors the generated sample class structure for testing <see cref="Metadata.ToolkitSampleButtonCommand"/> execution.
+/// </summary>
+internal class SampleButtonCommandTestTarget
+{
+    public int Counter { get; set; }
+
+    private void IncrementCounter() => Counter++;
+}

CommunityToolkit.Tooling.SampleGen/Attributes/ToolkitSampleButtonAttribute.cs

@@ -0,0 +1,20 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace CommunityToolkit.Tooling.SampleGen.Attributes;
+
+[AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
+public class ToolkitSampleButtonAttribute : Attribute
+{
+    /// <summary>
+    /// The title to display on the button.
+    /// </summary>
+    public string? Title { get; set; }
+
+    /// <summary>
+    /// The name of the method this attribute is attached to.
+    /// Set during source generation.
+    /// </summary>
+    public string? MethodName { get; set; }
+}