Merge branch 'main' into user/niels9001/more-options

niels9001 · niels9001 · commit 1aaa8a835dcb · 2023-01-20T17:25:21.000+01:00
diff --git a/CommunityToolkit.Labs.Shared/Pages/Shell.xaml b/CommunityToolkit.Labs.Shared/Pages/Shell.xaml
@@ -1,4 +1,4 @@
-﻿<!--  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.  -->
+<!--  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.  -->
 <Page x:Class="CommunityToolkit.Labs.Shared.Pages.Shell"
       xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
       xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
diff --git a/CommunityToolkit.Labs.Shared/Renderers/ToolkitSampleRenderer.xaml b/CommunityToolkit.Labs.Shared/Renderers/ToolkitSampleRenderer.xaml
diff --git a/CommunityToolkit.Labs.Shared/Renderers/ToolkitSampleRenderer.xaml.cs b/CommunityToolkit.Labs.Shared/Renderers/ToolkitSampleRenderer.xaml.cs
@@ -156,13 +156,12 @@ private async Task LoadData()
         CSharpCode = await GetMetadataFileContents(Metadata, "xaml.cs");
 
         var sampleControlInstance = (UIElement)Metadata.SampleControlFactory();
-       
+
         // Custom control-based sample options.
         if (Metadata.SampleOptionsPaneType is not null && Metadata.SampleOptionsPaneFactory is not null)
         {
             SampleOptionsPaneInstance = (UIElement)Metadata.SampleOptionsPaneFactory(sampleControlInstance);
         }
-
         // Source generater-based sample options
         else if (sampleControlInstance is IToolkitSampleGeneratedOptionPropertyContainer propertyContainer)
         {
@@ -175,6 +174,10 @@ private async Task LoadData()
                 SampleOptions = propertyContainer.GeneratedPropertyMetadata
             };
         }
+        else
+        {
+            OptionsScrollViewer.Visibility = Visibility.Collapsed;
+        }
 
         // Generated options must be assigned before attempting to render the control,
         // else some platforms will nullref from XAML but not properly ignore the exception when binding to generated properties.
diff --git a/CommunityToolkit.Labs.Shared/Styles/Buttons.xaml b/CommunityToolkit.Labs.Shared/Styles/Buttons.xaml
@@ -348,9 +348,5 @@
         <!--<Setter Property="Foreground" Value="{ThemeResource TextFillColorSecondaryBrush}" />-->
     </Style>
 
-    <Style x:Key="SmallAppBarButtonStyle"
-           BasedOn="{StaticResource DefaultAppBarButtonStyle}"
-           TargetType="AppBarButton">
-        <Setter Property="Width" Value="36" />
-    </Style>
+
 </ResourceDictionary>
diff --git a/GenerateVSCodeLaunchConfig.ps1 b/GenerateVSCodeLaunchConfig.ps1
@@ -0,0 +1,62 @@
+Param (    
+    [Parameter(HelpMessage = "Disables suppressing changes to the ./.vscode/launch.json file in git, allowing changes to be committed.")] 
+    [switch]$allowGitChanges = $false
+)
+
+function CreateVsCodeLaunchConfigJson {
+  param (
+    [string]$projectName
+  )
+
+  return "{
+    `"name`": `"$projectName`",
+    `"type`": `"coreclr`",
+    `"request`": `"launch`",
+    `"program`": `"dotnet`",
+    `"args`": [
+      `"run`",
+      `"build`",
+      `"/r`",
+      `"/p:UnoSourceGeneratorUseGenerationHost=true`",
+      `"/p:UnoSourceGeneratorUseGenerationController=false`",
+      `"/p:UnoRemoteControlPort=443`",
+      `"--project=`$`{workspaceFolder`}/labs/$projectName/samples/$projectName.Wasm/$projectName.Wasm.csproj`"
+    ],
+    `"presentation`": {
+      `"group`": `"2`"
+    },
+    `"cwd`": `"`$`{workspaceFolder`}/labs/$projectName/samples/$projectName.Wasm`"
+  }";
+}
+
+$launchConfigJson = Get-Content -Path "$PSScriptRoot/../.vscode/launch.json" -ErrorAction Stop;
+$launchConfig = $launchConfigJson | ConvertFrom-Json;
+
+# Remove all non-generated configurations
+$originalConfigurations = $launchConfig.configurations;
+$launchConfig.configurations = @();
+$launchConfig.configurations += $originalConfigurations[0];
+$launchConfig.configurations += $originalConfigurations[1];
+
+foreach ($wasmProjectPath in Get-ChildItem -Recurse -Path "$PSScriptRoot/../*/*/samples/*.Wasm/*.Wasm.csproj") {
+  $projectName = [System.IO.Path]::GetFileNameWithoutExtension($wasmProjectPath) -Replace ".Wasm", "";
+  Write-Host "Generating VSCode launch config for $projectName";
+
+  $configJson = CreateVsCodeLaunchConfigJson $projectName;
+  $config = $configJson | ConvertFrom-Json;
+
+  $launchConfig.configurations += $config;
+}
+
+if ($allowGitChanges.IsPresent) {
+  Write-Warning "Changes to the default launch.json can now be committed. Run this command again without the -allowGitChanges flag to disable committing further changes.";
+  git update-index --no-assume-unchanged $PSScriptRoot/../.vscode/launch.json
+}
+else {
+  Write-Output "Changes to the default launch.json are now suppressed. To switch branches, run git reset --hard with a clean working tree. Include the -allowGitChanges flag to enable committing changes.";
+  git update-index --assume-unchanged $PSScriptRoot/../.vscode/launch.json
+}
+
+# Save
+Set-Content -Path "$PSScriptRoot/../.vscode/launch.json" -Value ($launchConfig | ConvertTo-Json -Depth 9);
+Write-Output "Saved VSCode launch configs to $(Resolve-Path $PSScriptRoot/../.vscode/launch.json)";
diff --git a/Labs.Head.WinAppSdk.props b/Labs.Head.WinAppSdk.props
@@ -18,8 +18,8 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.WindowsAppSDK" Version="1.0.3" />
-    <PackageReference Include="Microsoft.Windows.SDK.BuildTools" Version="10.0.22000.194" />
+    <PackageReference Include="Microsoft.WindowsAppSDK" Version="1.2.221209.1" />
+    <PackageReference Include="Microsoft.Windows.SDK.BuildTools" Version="10.0.22621.755" />
     <Manifest Include="$(ApplicationManifest)" />
   </ItemGroup>
 
diff --git a/Labs.Head.props b/Labs.Head.props
@@ -29,6 +29,8 @@
     <IsAllExperimentHead Condition="$(MSBuildProjectName.StartsWith('CommunityToolkit.Labs.')) == 'true'">true</IsAllExperimentHead>
     <IsProjectTemplateHead Condition="$(MSBuildProjectName.StartsWith('ProjectTemplate')) == 'true'">true</IsProjectTemplateHead>
     <IsSingleExperimentHead Condition="'$(IsAllExperimentHead)' != 'true' AND '$(IsProjectTemplateHead)' != 'true'">true</IsSingleExperimentHead>
+    
+		<DefineConstants Condition="$(IsAllExperimentHead) == 'true'">$(DefineConstants);LABS_ALL_SAMPLES</DefineConstants>
   </PropertyGroup>
 
   <!-- See https://github.com/CommunityToolkit/Labs-Windows/issues/142 -->
diff --git a/Labs.SampleRefs.props.template b/Labs.SampleRefs.props.template
diff --git a/MultiTarget/Defaults.props b/MultiTarget/Defaults.props
@@ -0,0 +1,5 @@
+<Project>
+    <PropertyGroup>
+        <MultiTarget>uwp;wasdk;wpf;wasm;linuxgtk;macos;ios;android;</MultiTarget>
+    </PropertyGroup>
+</Project>
diff --git a/MultiTarget/GenerateAllProjectReferences.ps1 b/MultiTarget/GenerateAllProjectReferences.ps1
@@ -0,0 +1,46 @@
+Param (
+  [Parameter(HelpMessage = "The directory where props files for discovered projects should be saved.")]
+  [string]$projectPropsOutputDir = "$PSScriptRoot/Generated"
+)
+
+$preWorkingDir = $pwd;
+Set-Location $PSScriptRoot;
+
+# Delete and recreate output folder.
+Remove-Item -Path $projectPropsOutputDir -Recurse -Force -ErrorAction SilentlyContinue | Out-Null;
+New-Item -ItemType Directory -Force -Path $projectPropsOutputDir -ErrorAction SilentlyContinue | Out-Null;
+
+# Discover projects in provided paths
+foreach ($projectPath in Get-ChildItem -Directory -Depth 0 -Path "$PSScriptRoot/../../labs/") {
+  # Normalize project path
+  $projectName = $projectPath.Name;
+
+  # Folder layout is expected to match the Community Toolkit.
+  # Uses the <MultiTarget> values from the source library project as the fallback for the sample project.
+  # This behavior also implemented in MultiTarget.props for TargetFramework evaluation. 
+  $srcPath = Resolve-Path "$($projectPath.FullName)\src";
+  $srcProjectPath = Get-ChildItem -File "$srcPath\*.csproj";
+
+  $samplePath = Resolve-Path "$($projectPath.FullName)\samples\$projectName.Samples";
+  $sampleProjectPath = Get-ChildItem -File "$samplePath\*.csproj";
+
+  if ($srcProjectPath.Length -eq 0) {
+    Write-Error "Could not locate source csproj for $projectName";
+    exit(-1);
+  }
+
+  if ($sampleProjectPath.Length -eq 0) {
+    Write-Error "Could not locate sample csproj for $projectName";
+    exit(-1);
+  }
+
+  # Generate <ProjectReference>s for sample project
+  # Use source project MultiTarget as first fallback.
+  & $PSScriptRoot\GenerateMultiTargetAwareProjectReferenceProps.ps1 -projectPath $sampleProjectPath -outputPath "$projectPropsOutputDir/$($sampleProjectPath.BaseName).props" -multiTargetFallbackPropsPath @("$srcPath/MultiTarget.props", "$samplePath/MultiTarget.props", "$PSScriptRoot/Defaults.props");
+
+  # Generate <ProjectReference>s for src project
+  & $PSScriptRoot\GenerateMultiTargetAwareProjectReferenceProps.ps1 -projectPath $srcProjectPath -outputPath "$projectPropsOutputDir/$($srcProjectPath.BaseName).props" -multiTargetFallbackPropsPath @("$srcPath/MultiTarget.props", "$PSScriptRoot/Defaults.props");
+}
+
+
+Set-Location $preWorkingDir;
diff --git a/MultiTarget/GenerateMultiTargetAwareProjectReferenceProps.ps1 b/MultiTarget/GenerateMultiTargetAwareProjectReferenceProps.ps1
@@ -0,0 +1,84 @@
+Param (    
+    [Parameter(HelpMessage = "The full path of the csproj to generated references to.", Mandatory = $true)] 
+    [string]$projectPath,
+
+    [Parameter(HelpMessage = "A path to a .props file where generated content should be saved to.", Mandatory = $true)] 
+    [string]$outputPath,
+
+    [Parameter(HelpMessage = "The path to the template used to generate the props file.")] 
+    [string]$templatePath = "$PSScriptRoot/MultiTargetAwareProjectReference.props.template",
+
+    [Parameter(HelpMessage = "The path to the props file that contains the default MultiTarget values.")] 
+    [string[]]$multiTargetFallbackPropsPath = @("$PSScriptRoot/Defaults.props"),
+
+    [Parameter(HelpMessage = "The placeholder text to replace when inserting the project file name into the template.")] 
+    [string]$projectFileNamePlaceholder = "[ProjectFileName]",
+
+    [Parameter(HelpMessage = "The placeholder text to replace when inserting the project path into the template.")] 
+    [string]$projectRootPlaceholder = "[ProjectRoot]"
+)
+
+$preWorkingDir = $pwd;
+Set-Location $PSScriptRoot;
+
+$relativeProjectPath = Invoke-Expression -C "(Resolve-Path -Relative -Path $projectPath)";
+$templateContents = Get-Content -Path $templatePath;
+
+Set-Location $preWorkingDir;
+
+# Insert csproj file name.
+$csprojFileName = [System.IO.Path]::GetFileName($relativeProjectPath);
+$templateContents = $templateContents -replace [regex]::escape($projectFileNamePlaceholder), $csprojFileName;
+
+# Insert project directory
+$relativeProjectDirectory = [System.IO.Path]::GetDirectoryName($relativeProjectPath);
+$templateContents = $templateContents -replace [regex]::escape($projectRootPlaceholder), "$relativeProjectDirectory";
+
+function LoadMultiTargetsFrom([string] $path) {
+    $fileContents = "";
+
+    # If file does not exist
+    if ($false -eq (Test-Path -Path $path -PathType Leaf)) {
+        # Load first available default
+        foreach ($fallbackPath in $multiTargetFallbackPropsPath) {
+            if (Test-Path $fallbackPath) {
+                $fileContents = Get-Content $fallbackPath -ErrorAction Stop;
+                break;
+            }
+        }
+    }
+    else {
+        # Load requested file
+        $fileContents = Get-Content $path -ErrorAction Stop;
+    }
+
+    # Parse file contents
+    $regex = Select-String -Pattern '<MultiTarget>(.+?)<\/MultiTarget>' -InputObject $fileContents;
+
+    if ($null -eq $regex -or $null -eq $regex.Matches -or $null -eq $regex.Matches.Groups -or $regex.Matches.Groups.Length -lt 2) {
+        Write-Error "Couldn't get MultiTarget property from $path";
+        exit(-1);
+    }
+
+    return $regex.Matches.Groups[1].Value;
+}
+
+# Load multitarget preferences for project
+$multiTargets = LoadMultiTargetsFrom("$([System.IO.Path]::GetDirectoryName($projectPath))\MultiTarget.props");
+
+$templateContents = $templateContents -replace [regex]::escape("[IntendedTargets]"), $multiTargets;
+
+$multiTargets = $multiTargets.Split(';');
+Write-Host "Generating project references for $([System.IO.Path]::GetFileNameWithoutExtension($csprojFileName)): $($multiTargets -Join ', ')"
+
+$templateContents = $templateContents -replace [regex]::escape("[CanTargetWasm]"), "'$($multiTargets.Contains("wasm").ToString().ToLower())'";
+$templateContents = $templateContents -replace [regex]::escape("[CanTargetUwp]"), "'$($multiTargets.Contains("uwp").ToString().ToLower())'";
+$templateContents = $templateContents -replace [regex]::escape("[CanTargetWasdk]"), "'$($multiTargets.Contains("wasdk").ToString().ToLower())'";
+$templateContents = $templateContents -replace [regex]::escape("[CanTargetWpf]"), "'$($multiTargets.Contains("wpf").ToString().ToLower())'";
+$templateContents = $templateContents -replace [regex]::escape("[CanTargetLinuxGtk]"), "'$($multiTargets.Contains("linuxgtk").ToString().ToLower())'";
+$templateContents = $templateContents -replace [regex]::escape("[CanTargetMacOS]"), "'$($multiTargets.Contains("macos").ToString().ToLower())'";
+$templateContents = $templateContents -replace [regex]::escape("[CanTargetiOS]"), "'$($multiTargets.Contains("ios").ToString().ToLower())'";
+$templateContents = $templateContents -replace [regex]::escape("[CanTargetDroid]"), "'$($multiTargets.Contains("android").ToString().ToLower())'";
+
+# Save to disk
+Set-Content -Path $outputPath -Value $templateContents;
diff --git a/MultiTarget/MultiTarget.props b/MultiTarget/MultiTarget.props
@@ -1,19 +1,31 @@
 <Project>
   <PropertyGroup>
-    <!--
-      TargetFramework for WasmLibTargetFramework, WpfLibTargetFramework, and LinuxLibTargetFramework all use the same value.
+    <MultiTargetIsSampleProject Condition="$(MSBuildProjectName.EndsWith('.Samples')) == 'true'">true</MultiTargetIsSampleProject>
+  </PropertyGroup>
+
+  <Import Project="$(MSBuildProjectDirectory)\MultiTarget.props" Condition="Exists('$(MSBuildProjectDirectory)\MultiTarget.props') AND '$(MultiTarget)' == ''" />
 
-      This can't be removed during the evaluation phase without breaking things, so we omit them entirely
-      and use the value directly.
+  <!-- If in a sample project, pull the MultiTarget settings from the source project. -->
+  <!-- This behavior is also implemented in GeneratedAllProjectReferences.ps1 for <ProjectReference> generation. -->
+  <Import Project="../../src/MultiTarget.props" Condition="$(MultiTargetIsSampleProject) == 'true' AND !Exists('$(MSBuildProjectDirectory)\MultiTarget.props') AND Exists('../../src/MultiTarget.props') AND '$(MultiTarget)' == ''" />
+  
+  <Import Project="$(MSBuildThisFileDirectory)\Defaults.props" Condition="'$(MultiTarget)' == ''" />
+
+  <PropertyGroup>
+    <!--
+      MultiTarget is a custom property that indicates which target a project is designed to be built for / run on.
+      Used to create project references, generate solution files, enable/disable TargetFrameworks, and build nuget packages.
     -->
-    <TargetFrameworks>
-      $(NetStandardCommonTargetFramework);
-      $(UwpTargetFramework);
-      $(WinAppSdkTargetFramework);
-      $(MacOSLibTargetFramework);
-      $(iOSLibTargetFramework);
-      $(AndroidLibTargetFramework);
-    </TargetFrameworks>
+    <TargetFrameworks Condition="$(MultiTarget.Contains('uwp')) == 'true'">$(TargetFrameworks);$(UwpTargetFramework)</TargetFrameworks>
+    <TargetFrameworks Condition="$(MultiTarget.Contains('wasdk')) == 'true'">$(TargetFrameworks);$(WinAppSdkTargetFramework)</TargetFrameworks>
+    <!--
+      TargetFrameworks for WasmLibTargetFramework, WpfLibTargetFramework, and LinuxLibTargetFramework all use the same value.
+      Duplicate values can't be removed during the evaluation phase without breaking things, so we use the value directly.
+    -->
+    <TargetFrameworks Condition="$(MultiTarget.Contains('wasm')) == 'true' OR $(MultiTarget.Contains('wpf')) == 'true' OR $(MultiTarget.Contains('linuxgtk')) == 'true'">$(TargetFrameworks);$(NetStandardCommonTargetFramework)</TargetFrameworks>
+    <TargetFrameworks Condition="$(MultiTarget.Contains('macos')) == 'true'">$(TargetFrameworks);$(MacOSLibTargetFramework)</TargetFrameworks>
+    <TargetFrameworks Condition="$(MultiTarget.Contains('ios')) == 'true'">$(TargetFrameworks);$(iOSLibTargetFramework)</TargetFrameworks>
+    <TargetFrameworks Condition="$(MultiTarget.Contains('android')) == 'true'">$(TargetFrameworks);$(AndroidLibTargetFramework)</TargetFrameworks>
 
     <EnableWindowsTargeting>true</EnableWindowsTargeting>
     <GenerateLibraryLayout>true</GenerateLibraryLayout>
@@ -25,13 +37,15 @@
     <TargetPlatformMinVersion>10.0.17763.0</TargetPlatformMinVersion>
     <TargetPlatformVersion>10.0.19041.0</TargetPlatformVersion>
   </PropertyGroup>
+
   <PropertyGroup>
     <!-- These suppressions are for references between generated assemblies and that VS can keep in the Error List once resolved -->
     <NoWarn>WMC1006;CS8034;</NoWarn>
   </PropertyGroup>
+
   <ItemGroup>
     <PackageReference Condition="'$(TargetFramework)' == '$(UwpTargetFramework)'" Include="Microsoft.UI.Xaml" Version="2.7.0" />
-    <PackageReference Condition="'$(TargetFramework)' == '$(WinAppSdkTargetFramework)'" Include="Microsoft.WindowsAppSDK" Version="1.0.3" />
+    <PackageReference Condition="'$(TargetFramework)' == '$(WinAppSdkTargetFramework)'" Include="Microsoft.WindowsAppSDK" Version="1.2.221209.1" />
   </ItemGroup>
 
   <ItemGroup>
@@ -46,6 +60,7 @@
     </Compile>
     <UpToDateCheckInput Include="**\*.xaml" Exclude="bin\**\*.xaml;obj\**\*.xaml" />
   </ItemGroup>
+
   <ItemGroup>
     <None Remove="obj\bin\**" />
     <Page Remove="obj\bin\**" />
diff --git a/MultiTarget/MultiTargetAwareProjectReference.props.template b/MultiTarget/MultiTargetAwareProjectReference.props.template
@@ -0,0 +1,25 @@
+<!-- 
+	This file was generated by a tool.
+	Adds a ProjectReference only if the referenced project indicates it can target the referencing project. 
+ -->
+<Project>
+	<!-- Before importing, check that the imported project works on the current framework -->
+	<!-- Condition must be on a <When> statement for this to work in Visual Studio. https://stackoverflow.com/a/16557059 -->
+	<Choose>
+		<!-- [IntendedTargets] -->
+		<When Condition="($(IsWasm) == 'true' AND [CanTargetWasm] == 'true') OR
+							($(IsUwp) == 'true' AND [CanTargetUwp] == 'true') OR
+							($(IsWinAppSdk) == 'true' AND [CanTargetWasdk] == 'true') OR
+							($(IsWpf) == 'true' AND [CanTargetWpf] == 'true') OR
+							($(IsGtk) == 'true' AND [CanTargetLinuxGtk] == 'true') OR
+							($(IsMacOS) == 'true' AND [CanTargetMacOS] == 'true') OR
+							($(IsiOS) == 'true' AND [CanTargetiOS] == 'true') OR
+							($(IsDroid) == 'true' AND [CanTargetDroid] == 'true')">
+			<ItemGroup>
+				<ProjectReference Include="[ProjectRoot]\[ProjectFileName]" />
+			</ItemGroup>
+		</When>
+		<Otherwise>
+		</Otherwise>
+	</Choose>
+</Project>
diff --git a/MultiTarget/ReadMe.md b/MultiTarget/ReadMe.md
diff --git a/SampleProjectConfig.props b/SampleProjectConfig.props
diff --git a/Scripts/UseUnoWinUI.ps1 b/Scripts/UseUnoWinUI.ps1

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-<!-- 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. -->`
	`1`	`+<!-- 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. -->`
`2`	`2`	`<Page x:Class="CommunityToolkit.Labs.Shared.Pages.Shell"`
`3`	`3`	`xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"`
`4`	`4`	`xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"`
Original file line number	Diff line number	Diff line change
`@@ -156,13 +156,12 @@ private async Task LoadData()`
`156`	`156`	`CSharpCode = await GetMetadataFileContents(Metadata, "xaml.cs");`
`157`	`157`
`158`	`158`	`var sampleControlInstance = (UIElement)Metadata.SampleControlFactory();`
`159`		`-`
	`159`	`+`
`160`	`160`	`// Custom control-based sample options.`
`161`	`161`	`if (Metadata.SampleOptionsPaneType is not null && Metadata.SampleOptionsPaneFactory is not null)`
`162`	`162`	`{`
`163`	`163`	`SampleOptionsPaneInstance = (UIElement)Metadata.SampleOptionsPaneFactory(sampleControlInstance);`
`164`	`164`	`}`
`165`		`-`
`166`	`165`	`// Source generater-based sample options`
`167`	`166`	`else if (sampleControlInstance is IToolkitSampleGeneratedOptionPropertyContainer propertyContainer)`
`168`	`167`	`{`
`@@ -175,6 +174,10 @@ private async Task LoadData()`
`175`	`174`	`SampleOptions = propertyContainer.GeneratedPropertyMetadata`
`176`	`175`	`};`
`177`	`176`	`}`
	`177`	`+ else`
	`178`	`+ {`
	`179`	`+ OptionsScrollViewer.Visibility = Visibility.Collapsed;`
	`180`	`+ }`
`178`	`181`
`179`	`182`	`// Generated options must be assigned before attempting to render the control,`
`180`	`183`	`// else some platforms will nullref from XAML but not properly ignore the exception when binding to generated properties.`