From b0e2a2821ef89f27557cc3d04425802a743301ec Mon Sep 17 00:00:00 2001 From: Gordon Lam <73506701+yeelam-gordon@users.noreply.github.com> Date: Thu, 25 Dec 2025 17:03:33 +0800 Subject: [PATCH 1/3] Migrate main's readme to experimental branch (#581) * Sync README.md from main * Add 1.8 and 1.7 as part of readme.md --- README.md | 52 ++++++++++++++++++++++++++++++---------------------- 1 file changed, 30 insertions(+), 22 deletions(-) diff --git a/README.md b/README.md index db6a2db1c..bc82a6b70 100644 --- a/README.md +++ b/README.md @@ -1,8 +1,11 @@ -# Windows App SDK Samples +

+ + Windows App SDK Banner + +

-This repository hosts samples for the [Windows App SDK](https://github.com/microsoft/WindowsAppSDK). Samples for various features shipping in the Windows App SDK will be added to this repository. For more information about the Windows App SDK, visit the [Windows App SDK Documentation](https://docs.microsoft.com/windows/apps/windows-app-sdk/). To learn more about the Windows App SDK design or to contribute to the project, make feature proposals, or start discussions, visit the [Windows App SDK GitHub page](https://github.com/microsoft/WindowsAppSDK). +

Windows App SDK samples

-## List of samples This repository hosts samples for the [Windows App SDK](https://github.com/microsoft/WindowsAppSDK). Samples for various features shipping in the Windows App SDK will be added to this repository. For more information about the Windows App SDK, visit the [Windows App SDK documentation](https://docs.microsoft.com/windows/apps/windows-app-sdk/). To learn more about the Windows App SDK design or to contribute to the project, make feature proposals, or start discussions, visit the [Windows App SDK GitHub page](https://github.com/microsoft/WindowsAppSDK). @@ -30,28 +33,33 @@ This repository hosts samples for the [Windows App SDK](https://github.com/micro #### Data and Files - [Resource Management](Samples/ResourceManagement): These samples demonstrates app resource management using the MRT Core APIs. -#### Deployment +### Deployment - [Deployment Manager](Samples/DeploymentManager): This sample demonstrates how to initialize and access deployment information for the Windows App SDK runtime. - [Installer](Samples/Installer): This sample demonstrates how to launch the Windows App SDK installer without a console window. - [Unpackaged](Samples/Unpackaged): These samples demonstrate auto-initialization with the Windows App SDK package from non-MSIX (unpackaged) application. -#### Dynamic Dependencies +### Dynamic Dependencies - [DirectX](DynamicDependenciesSample/DynamicDependencies): This sample demonstrates how to use the Dynamic Dependencies API to dynamically load the DirectX Runtime MSIX framework package. -#### Graphics +### Graphics +- [Mica](Samples/Mica): These samples demonstrate how to use the Mica material in different apps and frameworks. - [Text Rendering](Samples/TextRendering): This sample is a gallery of the DWriteCore APIs demonstrating text rendering. -#### Notifications +### Islands +- [Islands](Samples/Islands): This sample shows how to add a WinAppSDK island with Xaml content to a Win32 app. + +### Notifications - [Push Notifications](Samples/Notifications/Push): This is a sample app that showcases Push Notifications. - [App Notifications](Samples/Notifications/App): This is a sample app that showcases App Notifications. -#### Runtime Components +### Runtime Components - [Custom Controls](Samples/CustomControls): This sample shows how to author a Windows Runtime Component in C# with custom WinUI controls. -#### User Interface and Input +### User Interface and Input + - [Windowing](Samples/Windowing): This sample demonstrates how to manage app windows using the Windowing APIs. -- [Windows Input and Composition Gallery](https://github.com/microsoft/WindowsCompositionSamples): This collection of samples showcases Microsoft.UI.Composition and Microsoft.UI.Input APIs. -- [WinUI 3 Gallery](https://github.com/microsoft/WinUI-Gallery/): This is a sample app that showcases all of the WinUI 3 controls in action. +- [Windows Composition, Input and SceneGraph](Samples/SceneGraph): This collection of samples showcases Microsoft.UI.Composition, Microsoft.UI.Input and SceneGraph APIs. +- [WinUI 3 Gallery](https://github.com/microsoft/WinUI-Gallery): This is a sample app that showcases all of the WinUI 3 controls in action. ### Widgets - [Widgets](Samples/Widgets): These samples demonstrate how to author Windows Widgets with the Windows App SDK. @@ -64,38 +72,38 @@ Thes Windows App SDK samples have the following system requirements: - [Visual Studio 2022](https://visualstudio.microsoft.com/downloads/) or Visual Studio 2019 version 16.9 or later, with the following workloads and components: - - Universal Windows Platform development + - Windows application development - .NET Desktop Development (needed even if you're only building C++ Win32 apps) - Desktop development with C++ (needed even if you're only building .NET apps) - Windows SDK version 2004 (build 19041) or later. This is installed with Visual Studio by default. -- Building .NET C# samples with Windows App SDK 1.1 also requires one of the following .NET SDK versions or later: - - 6.0.202 - - 6.0.104 - - 5.0.407 - - 5.0.213 - Refer to the docs on [system requirements](https://docs.microsoft.com/windows/apps/windows-app-sdk/system-requirements) and [tools for Windows app development](https://docs.microsoft.com/windows/apps/windows-app-sdk/set-up-your-development-environment) for a detalied list of requirements for developing apps with the Windows App SDK. -## Using the samples +## 🚀 Using the samples To use the samples with Git, clone the WindowsAppSDK-Samples repository by running `git clone https://github.com/microsoft/WindowsAppSDK-Samples.git` from a command prompt. You can then navigate to the directory of a sample and open the solution file in Visual Studio. The easiest way to use these samples without Git is to download the ZIP file. Select *Download ZIP* from the download dropdown, unzip the entire archive and open the samples in Visual Studio. -### Samples versioning +## 📄 Samples versioning The samples will be updated with GA releases of the Windows App SDK. The `main` branch includes the latest samples, which may also include experimental or preview features. Specific release branches are named `release/x.y` and contain samples that reference the corresponding GA version of the Windows App SDK. This repository currently includes the following release branches: +- [release/experimental](https://github.com/microsoft/WindowsAppSDK-Samples/tree/release/experimental) +- [release/1.8](https://github.com/microsoft/WindowsAppSDK-Samples/tree/release/1.8-stable) +- [release/1.7](https://github.com/microsoft/WindowsAppSDK-Samples/tree/release/1.7-stable) +- [release/1.6](https://github.com/microsoft/WindowsAppSDK-Samples/tree/release/1.6-stable) +- [release/1.5](https://github.com/microsoft/WindowsAppSDK-Samples/tree/release/1.5-stable) +- [release/1.1](https://github.com/microsoft/WindowsAppSDK-Samples/tree/release/1.1) - [release/1.0](https://github.com/microsoft/WindowsAppSDK-Samples/tree/release/1.0) - [release/0.8](https://github.com/microsoft/WindowsAppSDK-Samples/tree/release/0.8) - [release/0.5](https://github.com/microsoft/WindowsAppSDK-Samples/tree/release/0.5) -## Contributing +## 🏆 Contributing These samples are provided by feature teams and we welcome your input on issues and suggestions for new samples. We encourage you to [file a new issue](https://github.com/microsoft/WindowsAppSDK-Samples/issues/new) for any feedback or questions! -Sample authors should follow the [samples guidelines](docs/samples-guidelines.md) to begin developing their samples. For WinUI-based Windows App SDK samples, use the [sample templates](Templates/README.md). The VSIX file is available for download in the Github releases page [here](https://github.com/microsoft/WindowsAppSDK-Samples/releases). +Sample authors should follow the [samples guidelines](docs/samples-guidelines.md) to begin developing their samples. For WinUI-based Windows App SDK samples, use the [sample templates](Templates/README.md). The VSIX file is available for download in the GitHub releases page [here](https://github.com/microsoft/WindowsAppSDK-Samples/releases). This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/). For more information, see the Code of Conduct FAQ or contact opencode@microsoft.com with any additional questions or comments. From cb610366408f4c67ef910007a2074431e5b79fd2 Mon Sep 17 00:00:00 2001 From: Gordon Lam <73506701+yeelam-gordon@users.noreply.github.com> Date: Mon, 12 Jan 2026 13:49:20 +0800 Subject: [PATCH 2/3] Add AI Contributor Guidelines and Prompts for GitHub Copilot Integration (#583) * Add comprehensive guidelines and prompts for GitHub Copilot integration - Introduced a new instruction file for creating high-quality prompt files for GitHub Copilot, detailing frontmatter requirements, file naming conventions, body structure, and quality assurance. - Created prompts for generating commit titles, pull request summaries, and issue fixes, ensuring adherence to WindowsAppSDK-Samples conventions. - Developed a review prompt for GitHub issues, including scoring and generating implementation plans. - Implemented a detailed review prompt for pull requests, outlining a structured review process with incremental review capabilities and smart filtering. - Added an AI Contributor Guide for Windows App SDK Samples, covering build, run, verify processes, project structure, style enforcement, and copyright headers. * fix(build): improve sample path validation in Get-Solutions function * chore(vscode): add settings and tasks configuration for GitHub Copilot * refactor(review): enhance incremental review detection and update workflow * Update .github/prompts/create-pr-summary.prompt.md Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> * Update AGENTS.md Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> * Update .github/instructions/instructions.instructions.md Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> --------- Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> --- .github/copilot-instructions.md | 83 +- .github/instructions/agents.instructions.md | 791 ++++++++++++++++++ .../azure-devops-pipelines.instructions.md | 228 +++++ .github/instructions/csharp.instructions.md | 79 ++ .../instructions/instructions.instructions.md | 256 ++++++ .../instructions/powershell.instructions.md | 394 +++++++++ .github/instructions/prompt.instructions.md | 88 ++ .github/prompts/create-commit-title.prompt.md | 50 ++ .github/prompts/create-pr-summary.prompt.md | 25 + .github/prompts/fix-issue.prompt.md | 68 ++ .github/prompts/review-issue.prompt.md | 160 ++++ .github/prompts/review-pr.prompt.md | 184 ++++ .gitignore | 3 - .vscode/settings.json | 17 + .vscode/tasks.json | 70 ++ AGENTS.md | 73 ++ build.ps1 | 31 +- 17 files changed, 2551 insertions(+), 49 deletions(-) create mode 100644 .github/instructions/agents.instructions.md create mode 100644 .github/instructions/azure-devops-pipelines.instructions.md create mode 100644 .github/instructions/csharp.instructions.md create mode 100644 .github/instructions/instructions.instructions.md create mode 100644 .github/instructions/powershell.instructions.md create mode 100644 .github/instructions/prompt.instructions.md create mode 100644 .github/prompts/create-commit-title.prompt.md create mode 100644 .github/prompts/create-pr-summary.prompt.md create mode 100644 .github/prompts/fix-issue.prompt.md create mode 100644 .github/prompts/review-issue.prompt.md create mode 100644 .github/prompts/review-pr.prompt.md create mode 100644 .vscode/settings.json create mode 100644 .vscode/tasks.json create mode 100644 AGENTS.md diff --git a/.github/copilot-instructions.md b/.github/copilot-instructions.md index ec2bf49ba..a2346ef1e 100644 --- a/.github/copilot-instructions.md +++ b/.github/copilot-instructions.md @@ -1,44 +1,41 @@ -# GitHub Copilot Instructions (WindowsAppSDK-Samples) - -Read scripts first; improve their headers instead of duplicating detail here. - -## Build -Use only `build.ps1` / `build.cmd`. Read `build.ps1` before invoking. It auto: detects platform, picks solutions (current dir > selected sample > all), initializes VS DevShell, restores via local nuget, emits `.binlog` per solution. Do NOT hand-roll msbuild/nuget restore logic. - -## Versions -Run `UpdateVersions.ps1` only after reading it. Get the WinAppSDK version string from: https://www.nuget.org/packages/Microsoft.WindowsAppSdk/ (stable/preview/servicing) and pass as `-WinAppSDKVersion`. - -## Coding Guidelines -- Small, focused diffs; no mass reformatting; ensure SOLID principles. -- Preserve APIs, encoding, line endings, relative paths. -- PowerShell: approved verbs; each new script has Synopsis/Description/Parameters/Examples header. -- C#/C++: follow existing style; lean headers; forward declare where practical; keep samples illustrative. -- Minimal necessary comments; avoid noise. Centralize user strings for localization. -- Never log secrets or absolute external paths. - -## Language style rules -- Always enforce repo analyzers: root `.editorconfig` plus any `stylecop.json`. -- C# code follows StyleCop.Analyzers and Microsoft.CodeAnalysis.NetAnalyzers. -- C++ code honors `.clang-format` plus `.clang-tidy` (modernize/cppcoreguidelines/readability). -- Markdown files wrap at 80 characters and use ATX headers with fenced code blocks that include language tags. -- YAML files indent two spaces and add comments for complex settings while keeping keys clear. -- PowerShell scripts use Verb-Noun names and prefer single-quoted literals while documenting parameters and satisfying PSScriptAnalyzer. - -## PR Guidance -- One intent per PR. Update script README/header if behavior changes. -- Provide summary: what / why / validation. -- Run a targeted build (e.g. `pwsh -File build.ps1 -Sample AppLifecycle`). -- For version bumps: inspect at least one changed project file. -- No new warnings/errors or large cosmetic churn. - -## Design Docs (Large / Cross-Sample) -Before broad edits create `DESIGN-.md`: -- Single sample: `Samples//DESIGN-.md` -- Multi-sample/shared: repo root. -Include: Problem, Goals/Non-Goals, Affected Areas, Approach, Risks, Validation Plan. Reference doc in PR. - -## When Unsure -Draft a design doc or WIP PR summarizing assumptions—don't guess. - --- -Keep this file lean; source-of-truth for behavior lives in script headers. \ No newline at end of file +description: 'Windows App SDK Samples AI contributor guidance' +--- + +# Windows App SDK Samples – Copilot Instructions + +Concise guidance for AI contributions to Windows App SDK Samples. For complete details, see [AGENTS.md](../AGENTS.md). + +## Quick Reference + +- **Build**: `build.ps1` / `build.cmd` (supports `-Sample ` for targeted builds) +- **Run**: Test on x64, x86, ARM64 in Debug and Release +- **Verify**: Run WACK on Release builds +- **Exit code 0 = success** – do not proceed if build fails + +## Key Rules + +- Samples should be **complete but simple** – demonstrate correct API usage +- Follow **scenario-based design** – one scenario per API usage pattern +- Support all platforms: x64, x86, ARM64 (Debug and Release) +- Minimum OS: Windows 10 version 1809 (build 17763) +- Include copyright headers; build clean with no warnings + +## Style Enforcement + +- **C#**: Follow `.editorconfig` at repo root +- **C++**: Use C++/WinRT; check `Samples/WindowsML/` for `.clang-format` + +## When to Ask for Clarification + +- Ambiguous sample requirements after reviewing docs +- Cross-feature impact unclear +- API usage patterns not well documented + +## Detailed Documentation + +- [AGENTS.md](../AGENTS.md) – Full AI contributor guide +- [Samples Guidelines](../docs/samples-guidelines.md) – Complete guidelines and checklist +- [Contributing](../CONTRIBUTING.md) – Contribution requirements +- [PR Template](../docs/pull_request_template.md) – Pull request checklist +- [Windows App SDK Docs](https://docs.microsoft.com/windows/apps/windows-app-sdk/) – Official documentation diff --git a/.github/instructions/agents.instructions.md b/.github/instructions/agents.instructions.md new file mode 100644 index 000000000..8d602c881 --- /dev/null +++ b/.github/instructions/agents.instructions.md @@ -0,0 +1,791 @@ +--- +description: 'Guidelines for creating custom agent files for GitHub Copilot' +applyTo: '**/*.agent.md' +--- + +# Custom Agent File Guidelines + +Instructions for creating effective and maintainable custom agent files that provide specialized expertise for specific development tasks in GitHub Copilot. + +## Project Context + +- Target audience: Developers creating custom agents for GitHub Copilot +- File format: Markdown with YAML frontmatter +- File naming convention: lowercase with hyphens (e.g., `test-specialist.agent.md`) +- Location: `.github/agents/` directory (repository-level) or `agents/` directory (organization/enterprise-level) +- Purpose: Define specialized agents with tailored expertise, tools, and instructions for specific tasks +- Official documentation: https://docs.github.com/en/copilot/how-tos/use-copilot-agents/coding-agent/create-custom-agents + +## Required Frontmatter + +Every agent file must include YAML frontmatter with the following fields: + +```yaml +--- +description: 'Brief description of the agent purpose and capabilities' +name: 'Agent Display Name' +tools: ['read', 'edit', 'search'] +model: 'Claude Sonnet 4.5' +target: 'vscode' +infer: true +--- +``` + +### Core Frontmatter Properties + +#### **description** (REQUIRED) +- Single-quoted string, clearly stating the agent's purpose and domain expertise +- Should be concise (50-150 characters) and actionable +- Example: `'Focuses on test coverage, quality, and testing best practices'` + +#### **name** (OPTIONAL) +- Display name for the agent in the UI +- If omitted, defaults to filename (without `.md` or `.agent.md`) +- Use title case and be descriptive +- Example: `'Testing Specialist'` + +#### **tools** (OPTIONAL) +- List of tool names or aliases the agent can use +- Supports comma-separated string or YAML array format +- If omitted, agent has access to all available tools +- See "Tool Configuration" section below for details + +#### **model** (STRONGLY RECOMMENDED) +- Specifies which AI model the agent should use +- Supported in VS Code, JetBrains IDEs, Eclipse, and Xcode +- Example: `'Claude Sonnet 4.5'`, `'gpt-4'`, `'gpt-4o'` +- Choose based on agent complexity and required capabilities + +#### **target** (OPTIONAL) +- Specifies target environment: `'vscode'` or `'github-copilot'` +- If omitted, agent is available in both environments +- Use when agent has environment-specific features + +#### **infer** (OPTIONAL) +- Boolean controlling whether Copilot can automatically use this agent based on context +- Default: `true` if omitted +- Set to `false` to require manual agent selection + +#### **metadata** (OPTIONAL, GitHub.com only) +- Object with name-value pairs for agent annotation +- Example: `metadata: { category: 'testing', version: '1.0' }` +- Not supported in VS Code + +#### **mcp-servers** (OPTIONAL, Organization/Enterprise only) +- Configure MCP servers available only to this agent +- Only supported for organization/enterprise level agents +- See "MCP Server Configuration" section below + +## Tool Configuration + +### Tool Specification Strategies + +**Enable all tools** (default): +```yaml +# Omit tools property entirely, or use: +tools: ['*'] +``` + +**Enable specific tools**: +```yaml +tools: ['read', 'edit', 'search', 'execute'] +``` + +**Enable MCP server tools**: +```yaml +tools: ['read', 'edit', 'github/*', 'playwright/navigate'] +``` + +**Disable all tools**: +```yaml +tools: [] +``` + +### Standard Tool Aliases + +All aliases are case-insensitive: + +| Alias | Alternative Names | Category | Description | +|-------|------------------|----------|-------------| +| `execute` | shell, Bash, powershell | Shell execution | Execute commands in appropriate shell | +| `read` | Read, NotebookRead, view | File reading | Read file contents | +| `edit` | Edit, MultiEdit, Write, NotebookEdit | File editing | Edit and modify files | +| `search` | Grep, Glob, search | Code search | Search for files or text in files | +| `agent` | custom-agent, Task | Agent invocation | Invoke other custom agents | +| `web` | WebSearch, WebFetch | Web access | Fetch web content and search | +| `todo` | TodoWrite | Task management | Create and manage task lists (VS Code only) | + +### Built-in MCP Server Tools + +**GitHub MCP Server**: +```yaml +tools: ['github/*'] # All GitHub tools +tools: ['github/get_file_contents', 'github/search_repositories'] # Specific tools +``` +- All read-only tools available by default +- Token scoped to source repository + +**Playwright MCP Server**: +```yaml +tools: ['playwright/*'] # All Playwright tools +tools: ['playwright/navigate', 'playwright/screenshot'] # Specific tools +``` +- Configured to access localhost only +- Useful for browser automation and testing + +### Tool Selection Best Practices + +- **Principle of Least Privilege**: Only enable tools necessary for the agent's purpose +- **Security**: Limit `execute` access unless explicitly required +- **Focus**: Fewer tools = clearer agent purpose and better performance +- **Documentation**: Comment why specific tools are required for complex configurations + +## Sub-Agent Invocation (Agent Orchestration) + +Agents can invoke other agents using `runSubagent` to orchestrate multi-step workflows. + +### How It Works + +Include `agent` in tools list to enable sub-agent invocation: + +```yaml +tools: ['read', 'edit', 'search', 'agent'] +``` + +Then invoke other agents with `runSubagent`: + +```javascript +const result = await runSubagent({ + description: 'What this step does', + prompt: `You are the [Specialist] specialist. + +Context: +- Parameter: ${parameterValue} +- Input: ${inputPath} +- Output: ${outputPath} + +Task: +1. Do the specific work +2. Write results to output location +3. Return summary of completion` +}); +``` + +### Basic Pattern + +Structure each sub-agent call with: + +1. **description**: Clear one-line purpose of the sub-agent invocation +2. **prompt**: Detailed instructions with substituted variables + +The prompt should include: +- Who the sub-agent is (specialist role) +- What context it needs (parameters, paths) +- What to do (concrete tasks) +- Where to write output +- What to return (summary) + +### Example: Multi-Step Processing + +```javascript +// Step 1: Process data +const processing = await runSubagent({ + description: 'Transform raw input data', + prompt: `You are the Data Processor specialist. + +Project: ${projectName} +Input: ${basePath}/raw/ +Output: ${basePath}/processed/ + +Task: +1. Read all files from input directory +2. Apply transformations +3. Write processed files to output +4. Create summary: ${basePath}/processed/summary.md + +Return: Number of files processed and any issues found` +}); + +// Step 2: Analyze (depends on Step 1) +const analysis = await runSubagent({ + description: 'Analyze processed data', + prompt: `You are the Data Analyst specialist. + +Project: ${projectName} +Input: ${basePath}/processed/ +Output: ${basePath}/analysis/ + +Task: +1. Read processed files from input +2. Generate analysis report +3. Write to: ${basePath}/analysis/report.md + +Return: Key findings and identified patterns` +}); +``` + +### Key Points + +- **Pass variables in prompts**: Use `${variableName}` for all dynamic values +- **Keep prompts focused**: Clear, specific tasks for each sub-agent +- **Return summaries**: Each sub-agent should report what it accomplished +- **Sequential execution**: Use `await` to maintain order when steps depend on each other +- **Error handling**: Check results before proceeding to dependent steps + +### ⚠️ Tool Availability Requirement + +**Critical**: If a sub-agent requires specific tools (e.g., `edit`, `execute`, `search`), the orchestrator must include those tools in its own `tools` list. Sub-agents cannot access tools that aren't available to their parent orchestrator. + +**Example**: +```yaml +# If your sub-agents need to edit files, execute commands, or search code +tools: ['read', 'edit', 'search', 'execute', 'agent'] +``` + +The orchestrator's tool permissions act as a ceiling for all invoked sub-agents. Plan your tool list carefully to ensure all sub-agents have the tools they need. + +### ⚠️ Important Limitation + +**Sub-agent orchestration is NOT suitable for large-scale data processing.** Avoid using `runSubagent` when: +- Processing hundreds or thousands of files +- Handling large datasets +- Performing bulk transformations on big codebases +- Orchestrating more than 5-10 sequential steps + +Each sub-agent call adds latency and context overhead. For high-volume processing, implement logic directly in a single agent instead. Use orchestration only for coordinating specialized tasks on focused, manageable datasets. + +## Agent Prompt Structure + +The markdown content below the frontmatter defines the agent's behavior, expertise, and instructions. Well-structured prompts typically include: + +1. **Agent Identity and Role**: Who the agent is and its primary role +2. **Core Responsibilities**: What specific tasks the agent performs +3. **Approach and Methodology**: How the agent works to accomplish tasks +4. **Guidelines and Constraints**: What to do/avoid and quality standards +5. **Output Expectations**: Expected output format and quality + +### Prompt Writing Best Practices + +- **Be Specific and Direct**: Use imperative mood ("Analyze", "Generate"); avoid vague terms +- **Define Boundaries**: Clearly state scope limits and constraints +- **Include Context**: Explain domain expertise and reference relevant frameworks +- **Focus on Behavior**: Describe how the agent should think and work +- **Use Structured Format**: Headers, bullets, and lists make prompts scannable + +## Variable Definition and Extraction + +Agents can define dynamic parameters to extract values from user input and use them throughout the agent's behavior and sub-agent communications. This enables flexible, context-aware agents that adapt to user-provided data. + +### When to Use Variables + +**Use variables when**: +- Agent behavior depends on user input +- Need to pass dynamic values to sub-agents +- Want to make agents reusable across different contexts +- Require parameterized workflows +- Need to track or reference user-provided context + +**Examples**: +- Extract project name from user prompt +- Capture certification name for pipeline processing +- Identify file paths or directories +- Extract configuration options +- Parse feature names or module identifiers + +### Variable Declaration Pattern + +Define variables section early in the agent prompt to document expected parameters: + +```markdown +# Agent Name + +## Dynamic Parameters + +- **Parameter Name**: Description and usage +- **Another Parameter**: How it's extracted and used + +## Your Mission + +Process [PARAMETER_NAME] to accomplish [task]. +``` + +### Variable Extraction Methods + +#### 1. **Explicit User Input** +Ask the user to provide the variable if not detected in the prompt: + +```markdown +## Your Mission + +Process the project by analyzing your codebase. + +### Step 1: Identify Project +If no project name is provided, **ASK THE USER** for: +- Project name or identifier +- Base path or directory location +- Configuration type (if applicable) + +Use this information to contextualize all subsequent tasks. +``` + +#### 2. **Implicit Extraction from Prompt** +Automatically extract variables from the user's natural language input: + +```javascript +// Example: Extract certification name from user input +const userInput = "Process My Certification"; + +// Extract key information +const certificationName = extractCertificationName(userInput); +// Result: "My Certification" + +const basePath = `certifications/${certificationName}`; +// Result: "certifications/My Certification" +``` + +#### 3. **Contextual Variable Resolution** +Use file context or workspace information to derive variables: + +```markdown +## Variable Resolution Strategy + +1. **From User Prompt**: First, look for explicit mentions in user input +2. **From File Context**: Check current file name or path +3. **From Workspace**: Use workspace folder or active project +4. **From Settings**: Reference configuration files +5. **Ask User**: If all else fails, request missing information +``` + +### Using Variables in Agent Prompts + +#### Variable Substitution in Instructions + +Use template variables in agent prompts to make them dynamic: + +```markdown +# Agent Name + +## Dynamic Parameters +- **Project Name**: ${projectName} +- **Base Path**: ${basePath} +- **Output Directory**: ${outputDir} + +## Your Mission + +Process the **${projectName}** project located at `${basePath}`. + +## Process Steps + +1. Read input from: `${basePath}/input/` +2. Process files according to project configuration +3. Write results to: `${outputDir}/` +4. Generate summary report + +## Quality Standards + +- Maintain project-specific coding standards for **${projectName}** +- Follow directory structure: `${basePath}/[structure]` +``` + +#### Passing Variables to Sub-Agents + +When invoking a sub-agent, pass all context through template variables in the prompt: + +```javascript +// Extract and prepare variables +const basePath = `projects/${projectName}`; +const inputPath = `${basePath}/src/`; +const outputPath = `${basePath}/docs/`; + +// Pass to sub-agent with all variables substituted +const result = await runSubagent({ + description: 'Generate project documentation', + prompt: `You are the Documentation specialist. + +Project: ${projectName} +Input: ${inputPath} +Output: ${outputPath} + +Task: +1. Read source files from ${inputPath} +2. Generate comprehensive documentation +3. Write to ${outputPath}/index.md +4. Include code examples and usage guides + +Return: Summary of documentation generated (file count, word count)` +}); +``` + +The sub-agent receives all necessary context embedded in the prompt. Variables are resolved before sending the prompt, so the sub-agent works with concrete paths and values, not variable placeholders. + +### Real-World Example: Code Review Orchestrator + +Example of a simple orchestrator that validates code through multiple specialized agents: + +```javascript +async function reviewCodePipeline(repositoryName, prNumber) { + const basePath = `projects/${repositoryName}/pr-${prNumber}`; + + // Step 1: Security Review + const security = await runSubagent({ + description: 'Scan for security vulnerabilities', + prompt: `You are the Security Reviewer specialist. + +Repository: ${repositoryName} +PR: ${prNumber} +Code: ${basePath}/changes/ + +Task: +1. Scan code for OWASP Top 10 vulnerabilities +2. Check for injection attacks, auth flaws +3. Write findings to ${basePath}/security-review.md + +Return: List of critical, high, and medium issues found` + }); + + // Step 2: Test Coverage Check + const coverage = await runSubagent({ + description: 'Verify test coverage for changes', + prompt: `You are the Test Coverage specialist. + +Repository: ${repositoryName} +PR: ${prNumber} +Changes: ${basePath}/changes/ + +Task: +1. Analyze code coverage for modified files +2. Identify untested critical paths +3. Write report to ${basePath}/coverage-report.md + +Return: Current coverage percentage and gaps` + }); + + // Step 3: Aggregate Results + const finalReport = await runSubagent({ + description: 'Compile all review findings', + prompt: `You are the Review Aggregator specialist. + +Repository: ${repositoryName} +Reports: ${basePath}/*.md + +Task: +1. Read all review reports from ${basePath}/ +2. Synthesize findings into single report +3. Determine overall verdict (APPROVE/NEEDS_FIXES/BLOCK) +4. Write to ${basePath}/final-review.md + +Return: Final verdict and executive summary` + }); + + return finalReport; +} +``` + +This pattern applies to any orchestration scenario: extract variables, call sub-agents with clear context, await results. + + +### Variable Best Practices + +#### 1. **Clear Documentation** +Always document what variables are expected: + +```markdown +## Required Variables +- **projectName**: The name of the project (string, required) +- **basePath**: Root directory for project files (path, required) + +## Optional Variables +- **mode**: Processing mode - quick/standard/detailed (enum, default: standard) +- **outputFormat**: Output format - markdown/json/html (enum, default: markdown) + +## Derived Variables +- **outputDir**: Automatically set to ${basePath}/output +- **logFile**: Automatically set to ${basePath}/.log.md +``` + +#### 2. **Consistent Naming** +Use consistent variable naming conventions: + +```javascript +// Good: Clear, descriptive naming +const variables = { + projectName, // What project to work on + basePath, // Where project files are located + outputDirectory, // Where to save results + processingMode, // How to process (detail level) + configurationPath // Where config files are +}; + +// Avoid: Ambiguous or inconsistent +const bad_variables = { + name, // Too generic + path, // Unclear which path + mode, // Too short + config // Too vague +}; +``` + +#### 3. **Validation and Constraints** +Document valid values and constraints: + +```markdown +## Variable Constraints + +**projectName**: +- Type: string (alphanumeric, hyphens, underscores allowed) +- Length: 1-100 characters +- Required: yes +- Pattern: `/^[a-zA-Z0-9_-]+$/` + +**processingMode**: +- Type: enum +- Valid values: "quick" (< 5min), "standard" (5-15min), "detailed" (15+ min) +- Default: "standard" +- Required: no +``` + +## MCP Server Configuration (Organization/Enterprise Only) + +MCP servers extend agent capabilities with additional tools. Only supported for organization and enterprise-level agents. + +### Configuration Format + +```yaml +--- +name: my-custom-agent +description: 'Agent with MCP integration' +tools: ['read', 'edit', 'custom-mcp/tool-1'] +mcp-servers: + custom-mcp: + type: 'local' + command: 'some-command' + args: ['--arg1', '--arg2'] + tools: ["*"] + env: + ENV_VAR_NAME: ${{ secrets.API_KEY }} +--- +``` + +### MCP Server Properties + +- **type**: Server type (`'local'` or `'stdio'`) +- **command**: Command to start the MCP server +- **args**: Array of command arguments +- **tools**: Tools to enable from this server (`["*"]` for all) +- **env**: Environment variables (supports secrets) + +### Environment Variables and Secrets + +Secrets must be configured in repository settings under "copilot" environment. + +**Supported syntax**: +```yaml +env: + # Environment variable only + VAR_NAME: COPILOT_MCP_ENV_VAR_VALUE + + # Variable with header + VAR_NAME: $COPILOT_MCP_ENV_VAR_VALUE + VAR_NAME: ${COPILOT_MCP_ENV_VAR_VALUE} + + # GitHub Actions-style (YAML only) + VAR_NAME: ${{ secrets.COPILOT_MCP_ENV_VAR_VALUE }} + VAR_NAME: ${{ var.COPILOT_MCP_ENV_VAR_VALUE }} +``` + +## File Organization and Naming + +### Repository-Level Agents +- Location: `.github/agents/` +- Scope: Available only in the specific repository +- Access: Uses repository-configured MCP servers + +### Organization/Enterprise-Level Agents +- Location: `.github-private/agents/` (then move to `agents/` root) +- Scope: Available across all repositories in org/enterprise +- Access: Can configure dedicated MCP servers + +### Naming Conventions +- Use lowercase with hyphens: `test-specialist.agent.md` +- Name should reflect agent purpose +- Filename becomes default agent name (if `name` not specified) +- Allowed characters: `.`, `-`, `_`, `a-z`, `A-Z`, `0-9` + +## Agent Processing and Behavior + +### Versioning +- Based on Git commit SHAs for the agent file +- Create branches/tags for different agent versions +- Instantiated using latest version for repository/branch +- PR interactions use same agent version for consistency + +### Name Conflicts +Priority (highest to lowest): +1. Repository-level agent +2. Organization-level agent +3. Enterprise-level agent + +Lower-level configurations override higher-level ones with the same name. + +### Tool Processing +- `tools` list filters available tools (built-in and MCP) +- No tools specified = all tools enabled +- Empty list (`[]`) = all tools disabled +- Specific list = only those tools enabled +- Unrecognized tool names are ignored (allows environment-specific tools) + +### MCP Server Processing Order +1. Out-of-the-box MCP servers (e.g., GitHub MCP) +2. Custom agent MCP configuration (org/enterprise only) +3. Repository-level MCP configurations + +Each level can override settings from previous levels. + +## Agent Creation Checklist + +### Frontmatter +- [ ] `description` field present and descriptive (50-150 chars) +- [ ] `description` wrapped in single quotes +- [ ] `name` specified (optional but recommended) +- [ ] `tools` configured appropriately (or intentionally omitted) +- [ ] `model` specified for optimal performance +- [ ] `target` set if environment-specific +- [ ] `infer` set to `false` if manual selection required + +### Prompt Content +- [ ] Clear agent identity and role defined +- [ ] Core responsibilities listed explicitly +- [ ] Approach and methodology explained +- [ ] Guidelines and constraints specified +- [ ] Output expectations documented +- [ ] Examples provided where helpful +- [ ] Instructions are specific and actionable +- [ ] Scope and boundaries clearly defined +- [ ] Total content under 30,000 characters + +### File Structure +- [ ] Filename follows lowercase-with-hyphens convention +- [ ] File placed in correct directory (`.github/agents/` or `agents/`) +- [ ] Filename uses only allowed characters +- [ ] File extension is `.agent.md` + +### Quality Assurance +- [ ] Agent purpose is unique and not duplicative +- [ ] Tools are minimal and necessary +- [ ] Instructions are clear and unambiguous +- [ ] Agent has been tested with representative tasks +- [ ] Documentation references are current +- [ ] Security considerations addressed (if applicable) + +## Common Agent Patterns + +### Testing Specialist +**Purpose**: Focus on test coverage and quality +**Tools**: All tools (for comprehensive test creation) +**Approach**: Analyze, identify gaps, write tests, avoid production code changes + +### Implementation Planner +**Purpose**: Create detailed technical plans and specifications +**Tools**: Limited to `['read', 'search', 'edit']` +**Approach**: Analyze requirements, create documentation, avoid implementation + +### Code Reviewer +**Purpose**: Review code quality and provide feedback +**Tools**: `['read', 'search']` only +**Approach**: Analyze, suggest improvements, no direct modifications + +### Refactoring Specialist +**Purpose**: Improve code structure and maintainability +**Tools**: `['read', 'search', 'edit']` +**Approach**: Analyze patterns, propose refactorings, implement safely + +### Security Auditor +**Purpose**: Identify security issues and vulnerabilities +**Tools**: `['read', 'search', 'web']` +**Approach**: Scan code, check against OWASP, report findings + +## Common Mistakes to Avoid + +### Frontmatter Errors +- ❌ Missing `description` field +- ❌ Description not wrapped in quotes +- ❌ Invalid tool names without checking documentation +- ❌ Incorrect YAML syntax (indentation, quotes) + +### Tool Configuration Issues +- ❌ Granting excessive tool access unnecessarily +- ❌ Missing required tools for agent's purpose +- ❌ Not using tool aliases consistently +- ❌ Forgetting MCP server namespace (`server-name/tool`) + +### Prompt Content Problems +- ❌ Vague, ambiguous instructions +- ❌ Conflicting or contradictory guidelines +- ❌ Lack of clear scope definition +- ❌ Missing output expectations +- ❌ Overly verbose instructions (exceeding character limits) +- ❌ No examples or context for complex tasks + +### Organizational Issues +- ❌ Filename doesn't reflect agent purpose +- ❌ Wrong directory (confusing repo vs org level) +- ❌ Using spaces or special characters in filename +- ❌ Duplicate agent names causing conflicts + +## Testing and Validation + +### Manual Testing +1. Create the agent file with proper frontmatter +2. Reload VS Code or refresh GitHub.com +3. Select the agent from the dropdown in Copilot Chat +4. Test with representative user queries +5. Verify tool access works as expected +6. Confirm output meets expectations + +### Integration Testing +- Test agent with different file types in scope +- Verify MCP server connectivity (if configured) +- Check agent behavior with missing context +- Test error handling and edge cases +- Validate agent switching and handoffs + +### Quality Checks +- Run through agent creation checklist +- Review against common mistakes list +- Compare with example agents in repository +- Get peer review for complex agents +- Document any special configuration needs + +## Additional Resources + +### Official Documentation +- [Creating Custom Agents](https://docs.github.com/en/copilot/how-tos/use-copilot-agents/coding-agent/create-custom-agents) +- [Custom Agents Configuration](https://docs.github.com/en/copilot/reference/custom-agents-configuration) +- [Custom Agents in VS Code](https://code.visualstudio.com/docs/copilot/customization/custom-agents) +- [MCP Integration](https://docs.github.com/en/copilot/how-tos/use-copilot-agents/coding-agent/extend-coding-agent-with-mcp) + +### Community Resources +- [Awesome Copilot Agents Collection](https://github.com/github/awesome-copilot/tree/main/agents) +- [Customization Library Examples](https://docs.github.com/en/copilot/tutorials/customization-library/custom-agents) +- [Your First Custom Agent Tutorial](https://docs.github.com/en/copilot/tutorials/customization-library/custom-agents/your-first-custom-agent) + +### Related Files +- [Prompt Files Guidelines](./prompt.instructions.md) - For creating prompt files +- [Instructions Guidelines](./instructions.instructions.md) - For creating instruction files + +## Version Compatibility Notes + +### GitHub.com (Coding Agent) +- ✅ Fully supports all standard frontmatter properties +- ✅ Repository and org/enterprise level agents +- ✅ MCP server configuration (org/enterprise) +- ❌ Does not support `model`, `argument-hint`, `handoffs` properties + +### VS Code / JetBrains / Eclipse / Xcode +- ✅ Supports `model` property for AI model selection +- ✅ Supports `argument-hint` and `handoffs` properties +- ✅ User profile and workspace-level agents +- ❌ Cannot configure MCP servers at repository level +- ⚠️ Some properties may behave differently + +When creating agents for multiple environments, focus on common properties and test in all target environments. Use `target` property to create environment-specific agents when necessary. diff --git a/.github/instructions/azure-devops-pipelines.instructions.md b/.github/instructions/azure-devops-pipelines.instructions.md new file mode 100644 index 000000000..de366c0a6 --- /dev/null +++ b/.github/instructions/azure-devops-pipelines.instructions.md @@ -0,0 +1,228 @@ +--- +description: 'Best practices for Azure DevOps Pipeline YAML files' +applyTo: '**/azure-pipelines.yml, **/azure-pipelines*.yml, **/*.pipeline.yml, **/SamplesCI-*.yml, **/WindowsAppSDK-*.yml' +--- + +# Azure DevOps Pipeline YAML Best Practices + +Guidelines for creating maintainable, secure, and efficient Azure DevOps pipelines in WindowsAppSDK-Samples. + +## General Guidelines + +- Use YAML syntax consistently with proper indentation (2 spaces) +- Always include meaningful names and display names for pipelines, stages, jobs, and steps +- Implement proper error handling and conditional execution +- Use variables and parameters to make pipelines reusable and maintainable +- Follow the principle of least privilege for service connections and permissions +- Include comprehensive logging and diagnostics for troubleshooting + +## Pipeline Structure + +- Organize complex pipelines using stages for better visualization and control +- Use jobs to group related steps and enable parallel execution when possible +- Implement proper dependencies between stages and jobs +- Use templates for reusable pipeline components +- Keep pipeline files focused and modular - split large pipelines into multiple files + +## Build Best Practices + +- Use specific agent pool versions and VM images for consistency +- Cache dependencies (npm, NuGet, Maven, etc.) to improve build performance +- Implement proper artifact management with meaningful names and retention policies +- Use build variables for version numbers and build metadata +- Include code quality gates (lint checks, testing, security scans) +- Ensure builds are reproducible and environment-independent + +## Testing Integration + +- Run unit tests as part of the build process +- Publish test results in standard formats (JUnit, VSTest, etc.) +- Include code coverage reporting and quality gates +- Implement integration and end-to-end tests in appropriate stages +- Use test impact analysis when available to optimize test execution +- Fail fast on test failures to provide quick feedback + +## Security Considerations + +- Use Azure Key Vault for sensitive configuration and secrets +- Implement proper secret management with variable groups +- Use service connections with minimal required permissions +- Enable security scans (dependency vulnerabilities, static analysis) +- Implement approval gates for production deployments +- Use managed identities when possible instead of service principals + +## Deployment Strategies + +- Implement proper environment promotion (dev → staging → production) +- Use deployment jobs with proper environment targeting +- Implement blue-green or canary deployment strategies when appropriate +- Include rollback mechanisms and health checks +- Use infrastructure as code (ARM, Bicep, Terraform) for consistent deployments +- Implement proper configuration management per environment + +## Variable and Parameter Management + +- Use variable groups for shared configuration across pipelines +- Implement runtime parameters for flexible pipeline execution +- Use conditional variables based on branches or environments +- Secure sensitive variables and mark them as secrets +- Document variable purposes and expected values +- Use variable templates for complex variable logic + +## Performance Optimization + +- Use parallel jobs and matrix strategies when appropriate +- Implement proper caching strategies for dependencies and build outputs +- Use shallow clone for Git operations when full history isn't needed +- Optimize Docker image builds with multi-stage builds and layer caching +- Monitor pipeline performance and optimize bottlenecks +- Use pipeline resource triggers efficiently + +## Monitoring and Observability + +- Include comprehensive logging throughout the pipeline +- Use Azure Monitor and Application Insights for deployment tracking +- Implement proper notification strategies for failures and successes +- Include deployment health checks and automated rollback triggers +- Use pipeline analytics to identify improvement opportunities +- Document pipeline behavior and troubleshooting steps + +## Template and Reusability + +- Create pipeline templates for common patterns +- Use extends templates for complete pipeline inheritance +- Implement step templates for reusable task sequences +- Use variable templates for complex variable logic +- Version templates appropriately for stability +- Document template parameters and usage examples + +## Branch and Trigger Strategy + +- Implement appropriate triggers for different branch types +- Use path filters to trigger builds only when relevant files change +- Configure proper CI/CD triggers for main/master branches +- Use pull request triggers for code validation +- Implement scheduled triggers for maintenance tasks +- Consider resource triggers for multi-repository scenarios + +## Example Structure + +```yaml +# azure-pipelines.yml +trigger: + branches: + include: + - main + - develop + paths: + exclude: + - docs/* + - README.md + +variables: + - group: shared-variables + - name: buildConfiguration + value: 'Release' + +stages: + - stage: Build + displayName: 'Build and Test' + jobs: + - job: Build + displayName: 'Build Application' + pool: + vmImage: 'ubuntu-latest' + steps: + - task: UseDotNet@2 + displayName: 'Use .NET SDK' + inputs: + version: '8.x' + + - task: DotNetCoreCLI@2 + displayName: 'Restore dependencies' + inputs: + command: 'restore' + projects: '**/*.csproj' + + - task: DotNetCoreCLI@2 + displayName: 'Build application' + inputs: + command: 'build' + projects: '**/*.csproj' + arguments: '--configuration $(buildConfiguration) --no-restore' + + - stage: Deploy + displayName: 'Deploy to Staging' + dependsOn: Build + condition: and(succeeded(), eq(variables['Build.SourceBranch'], 'refs/heads/main')) + jobs: + - deployment: DeployToStaging + displayName: 'Deploy to Staging Environment' + environment: 'staging' + strategy: + runOnce: + deploy: + steps: + - download: current + displayName: 'Download drop artifact' + artifact: drop + - task: AzureWebApp@1 + displayName: 'Deploy to Azure Web App' + inputs: + azureSubscription: 'staging-service-connection' + appType: 'webApp' + appName: 'myapp-staging' + package: '$(Pipeline.Workspace)/drop/**/*.zip' +``` + +## Common Anti-Patterns to Avoid + +- Hardcoding sensitive values directly in YAML files +- Using overly broad triggers that cause unnecessary builds +- Mixing build and deployment logic in a single stage +- Not implementing proper error handling and cleanup +- Using deprecated task versions without upgrade plans +- Creating monolithic pipelines that are difficult to maintain +- Not using proper naming conventions for clarity +- Ignoring pipeline security best practices + +## WindowsAppSDK-Samples Specific Patterns + +### Feature-Specific CI Pipelines + +Each feature in the Samples repo should have its own CI pipeline. Create a new pipeline file named `SamplesCI-.yml` at the repository root: + +```yaml +# SamplesCI-.yml +name: $(BuildDefinitionName)_$(date:yyMM).$(date:dd)$(rev:rrr) +stages: +- template: WindowsAppSDK-SamplesCI.yml + parameters: + FeatureDirectory: "" +``` + +### Adding Features to SamplesCI-All.yml + +When onboarding a new feature, add it to the `FeatureAreas` parameter in `SamplesCI-All.yml` to include it in comprehensive builds. + +### Pipeline Setup Requirements + +1. **Triggers**: Configure pull request validation with path filters for your feature directory +2. **Branch Filters**: Include `refs/heads/main` +3. **Path Filters**: Include `Samples/` +4. **Fork Builds**: Enable "Build pull requests from forks of this repository" +5. **Comments**: Require team member's comment before building PRs + +### Build Configurations + +Samples should build for all supported configurations: +- Platforms: x64, x86, ARM64 +- Configurations: Debug, Release +- Minimum Windows version: Windows 10 version 1809 (build 17763) + +### Status Check Integration + +Add your pipeline to branch protection rules at: +`https://github.com/microsoft/WindowsAppSDK-Samples/settings/branches` + +Ensure the full `SamplesCI-` check is added, not individual job configurations. diff --git a/.github/instructions/csharp.instructions.md b/.github/instructions/csharp.instructions.md new file mode 100644 index 000000000..a93658bf2 --- /dev/null +++ b/.github/instructions/csharp.instructions.md @@ -0,0 +1,79 @@ +--- +description: 'Guidelines for C# Windows App SDK samples' +applyTo: '**/*.cs' +--- + +# C# Windows App SDK Development + +Guidelines for writing C# samples that demonstrate Windows App SDK features. + +## C# Instructions + +- Use C# language features appropriate for the target .NET version in the sample +- Write clear and concise comments explaining API usage patterns +- Focus on demonstrating Windows App SDK APIs, not general application architecture + +## General Instructions + +- Keep samples **complete but simple** – demonstrate correct API usage without excessive abstraction +- Follow **scenario-based design** – each scenario covers one way of using the API +- Handle edge cases with clear exception handling +- Comment on why certain Windows App SDK patterns are used + +## Naming Conventions + +- Follow PascalCase for component names, method names, and public members +- Use camelCase for private fields and local variables +- Prefix interface names with "I" (e.g., IWindowService) + +## Formatting + +- Apply code-formatting style defined in `.editorconfig` at repo root +- Prefer file-scoped namespace declarations +- Insert a newline before the opening curly brace (Allman style) +- Use pattern matching and switch expressions where they improve clarity +- Use `nameof` instead of string literals when referring to member names + +## Code Analysis + +- All code must pass **StyleCop.Analyzers** rules without warnings +- All code must pass **Microsoft.CodeAnalysis.NetAnalyzers** (CA rules) without warnings +- Suppress warnings only with justification comments when absolutely necessary +- Common rules to follow: + - [StyleCop.Analyzers rules](https://github.com/DotNetAnalyzers/StyleCopAnalyzers/blob/master/DOCUMENTATION.md) + - [Code quality rules (CA)](https://learn.microsoft.com/dotnet/fundamentals/code-analysis/quality-rules/) + - [Code style rules (IDE)](https://learn.microsoft.com/dotnet/fundamentals/code-analysis/style-rules/) + +## Nullable Reference Types + +- Declare variables non-nullable, and check for `null` at entry points +- Always use `is null` or `is not null` instead of `== null` or `!= null` +- Trust the C# null annotations and don't add null checks when the type system says a value cannot be null + +## Windows App SDK Patterns + +### App Lifecycle and Activation + +- Demonstrate proper activation handling (file, protocol, launch) +- Show single-instance patterns using `AppInstance` +- Handle restart and state persistence scenarios + +### WinUI 3 and XAML + +- Use x:Bind for data binding where possible +- Demonstrate proper resource management and theming +- Show Window and navigation patterns + +### Packaging and Deployment + +- Support both packaged (MSIX) and unpackaged scenarios where applicable +- Use `WindowsPackageType` appropriately in project files +- Demonstrate self-contained deployment patterns when relevant + +## Copyright Headers + +All C# files must include: +```csharp +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. +``` diff --git a/.github/instructions/instructions.instructions.md b/.github/instructions/instructions.instructions.md new file mode 100644 index 000000000..107c1cf2c --- /dev/null +++ b/.github/instructions/instructions.instructions.md @@ -0,0 +1,256 @@ +--- +description: 'Guidelines for creating high-quality custom instruction files for GitHub Copilot' +applyTo: '**/*.instructions.md' +--- + +# Custom Instructions File Guidelines + +Instructions for creating effective and maintainable custom instruction files that guide GitHub Copilot in generating domain-specific code and following project conventions. + +## Project Context + +- Target audience: Developers and GitHub Copilot working with domain-specific code +- File format: Markdown with YAML frontmatter +- File naming convention: filename stem in lowercase-with-hyphens plus the `.instructions.md` suffix (e.g., stem `react-best-practices` → `react-best-practices.instructions.md`) +- Location: `.github/instructions/` directory +- Purpose: Provide context-aware guidance for code generation, review, and documentation + +## Required Frontmatter + +Every instruction file must include YAML frontmatter with the following fields: + +```yaml +--- +description: 'Brief description of the instruction purpose and scope' +applyTo: 'glob pattern for target files (e.g., **/*.ts, **/*.py)' +--- +``` + +### Frontmatter Guidelines + +- **description**: Single-quoted string, 1-500 characters, clearly stating the purpose +- **applyTo**: Glob pattern(s) specifying which files these instructions apply to + - Single pattern: `'**/*.ts'` + - Multiple patterns: `'**/*.ts, **/*.tsx, **/*.js'` + - Specific files: `'src/**/*.py'` + - All files: `'**'` + +## File Structure + +A well-structured instruction file should include the following sections: + +### 1. Title and Overview + +- Clear, descriptive title using `#` heading +- Brief introduction explaining the purpose and scope +- Optional: Project context section with key technologies and versions + +### 2. Core Sections + +Organize content into logical sections based on the domain: + +- **General Instructions**: High-level guidelines and principles +- **Best Practices**: Recommended patterns and approaches +- **Code Standards**: Naming conventions, formatting, style rules +- **Architecture/Structure**: Project organization and design patterns +- **Common Patterns**: Frequently used implementations +- **Security**: Security considerations (if applicable) +- **Performance**: Optimization guidelines (if applicable) +- **Testing**: Testing standards and approaches (if applicable) + +### 3. Examples and Code Snippets + +Provide concrete examples with clear labels: + +```markdown +### Good Example +\`\`\`language +// Recommended approach +code example here +\`\`\` + +### Bad Example +\`\`\`language +// Avoid this pattern +code example here +\`\`\` +``` + +### 4. Validation and Verification (Optional but Recommended) + +- Build commands to verify code +- Lint checks and formatting tools +- Testing requirements +- Verification steps + +## Content Guidelines + +### Writing Style + +- Use clear, concise language +- Write in imperative mood ("Use", "Implement", "Avoid") +- Be specific and actionable +- Avoid ambiguous terms like "should", "might", "possibly" +- Use bullet points and lists for readability +- Keep sections focused and scannable + +### Best Practices + +- **Be Specific**: Provide concrete examples rather than abstract concepts +- **Show Why**: Explain the reasoning behind recommendations when it adds value +- **Use Tables**: For comparing options, listing rules, or showing patterns +- **Include Examples**: Real code snippets are more effective than descriptions +- **Stay Current**: Reference current versions and best practices +- **Link Resources**: Include official documentation and authoritative sources + +### Common Patterns to Include + +1. **Naming Conventions**: How to name variables, functions, classes, files +2. **Code Organization**: File structure, module organization, import order +3. **Error Handling**: Preferred error handling patterns +4. **Dependencies**: How to manage and document dependencies +5. **Comments and Documentation**: When and how to document code +6. **Version Information**: Target language/framework versions + +## Patterns to Follow + +### Bullet Points and Lists + +```markdown +## Security Best Practices + +- Always validate user input before processing +- Use parameterized queries to prevent SQL injection +- Store secrets in environment variables, never in code +- Implement proper authentication and authorization +- Enable HTTPS for all production endpoints +``` + +### Tables for Structured Information + +```markdown +## Common Issues + +| Issue | Solution | Example | +| ---------------- | ------------------- | ----------------------------- | +| Magic numbers | Use named constants | `const MAX_RETRIES = 3` | +| Deep nesting | Extract functions | Refactor nested if statements | +| Hardcoded values | Use configuration | Store API URLs in config | +``` + +### Code Comparison + +```markdown +### Good Example - Using TypeScript interfaces +\`\`\`typescript +interface User { + id: string; + name: string; + email: string; +} + +function getUser(id: string): User { + // Implementation +} +\`\`\` + +### Bad Example - Using any type +\`\`\`typescript +function getUser(id: any): any { + // Loses type safety +} +\`\`\` +``` + +### Conditional Guidance + +```markdown +## Framework Selection + +- **For small projects**: Use Minimal API approach +- **For large projects**: Use controller-based architecture with clear separation +- **For microservices**: Consider domain-driven design patterns +``` + +## Patterns to Avoid + +- **Overly verbose explanations**: Keep it concise and scannable +- **Outdated information**: Always reference current versions and practices +- **Ambiguous guidelines**: Be specific about what to do or avoid +- **Missing examples**: Abstract rules without concrete code examples +- **Contradictory advice**: Ensure consistency throughout the file +- **Copy-paste from documentation**: Add value by distilling and providing context + +## Testing Your Instructions + +Before finalizing instruction files: + +1. **Test with Copilot**: Try the instructions with actual prompts in VS Code +2. **Verify Examples**: Ensure code examples are correct and run without errors +3. **Check Glob Patterns**: Confirm `applyTo` patterns match intended files + +## Example Structure + +Here's a minimal example structure for a new instruction file: + +```markdown +--- +description: 'Brief description of purpose' +applyTo: '**/*.ext' +--- + +# Technology Name Development + +Brief introduction and context. + +## General Instructions + +- High-level guideline 1 +- High-level guideline 2 + +## Best Practices + +- Specific practice 1 +- Specific practice 2 + +## Code Standards + +### Naming Conventions +- Rule 1 +- Rule 2 + +### File Organization +- Structure 1 +- Structure 2 + +## Common Patterns + +### Pattern 1 +Description and example + +\`\`\`language +code example +\`\`\` + +### Pattern 2 +Description and example + +## Validation + +- Build command: `command to verify` +- Lint checks: `command to lint` +- Testing: `command to test` +``` + +## Maintenance + +- Review instructions when dependencies or frameworks are updated +- Update examples to reflect current best practices +- Remove outdated patterns or deprecated features +- Add new patterns as they emerge in the community +- Keep glob patterns accurate as project structure evolves + +## Additional Resources + +- [Custom Instructions Documentation](https://code.visualstudio.com/docs/copilot/customization/custom-instructions) +- [Awesome Copilot Instructions](https://github.com/github/awesome-copilot/tree/main/instructions) diff --git a/.github/instructions/powershell.instructions.md b/.github/instructions/powershell.instructions.md new file mode 100644 index 000000000..97dbfb50a --- /dev/null +++ b/.github/instructions/powershell.instructions.md @@ -0,0 +1,394 @@ +--- +applyTo: '**/*.ps1,**/*.psm1' +description: 'PowerShell cmdlet and scripting best practices based on Microsoft guidelines' +--- + +# PowerShell Cmdlet Development Guidelines + +This guide provides PowerShell-specific instructions to help GitHub Copilot generate idiomatic, +safe, and maintainable scripts. It aligns with Microsoft’s PowerShell cmdlet development guidelines. +## Strict Mode and Exit Code Requirements + +**All scripts must enforce strict mode and proper exit codes:** + +```powershell +Set-StrictMode -Version 2.0 +$ErrorActionPreference = 'Stop' + +# Script logic here... + +# Exit with appropriate code +exit 0 # Success +# exit 1 # Failure +``` + +### Strict Mode Rules + +- **Always use `Set-StrictMode -Version 2.0`** at the top of every script +- This catches common errors: uninitialized variables, non-existent properties, function calls like methods +- Combined with `$ErrorActionPreference = 'Stop'` for fail-fast behavior + +### Exit Code Requirements + +- **Exit 0** for successful completion +- **Exit non-zero** (typically 1) for any failure +- Use `try/catch/finally` with explicit exit codes: + +```powershell +try { + # Main script logic + exit 0 +} catch { + Write-Error "Script failed: $_" + exit 1 +} +``` + +- For CI/build scripts, ensure the exit code reflects the actual success/failure state +- Never silently swallow errors that should fail the build +## Naming Conventions + +- **Verb-Noun Format:** + - Use approved PowerShell verbs (Get-Verb) + - Use singular nouns + - PascalCase for both verb and noun + - Avoid special characters and spaces + +- **Parameter Names:** + - Use PascalCase + - Choose clear, descriptive names + - Use singular form unless always multiple + - Follow PowerShell standard names + +- **Variable Names:** + - Use PascalCase for public variables + - Use camelCase for private variables + - Avoid abbreviations + - Use meaningful names + +- **Alias Avoidance:** + - Use full cmdlet names + - Avoid using aliases in scripts (e.g., use Get-ChildItem instead of gci) + - Document any custom aliases + - Use full parameter names + +### Example + +```powershell +function Get-UserProfile { + [CmdletBinding()] + param( + [Parameter(Mandatory)] + [string]$Username, + + [Parameter()] + [ValidateSet('Basic', 'Detailed')] + [string]$ProfileType = 'Basic' + ) + + process { + # Logic here + } +} +``` + +## Parameter Design + +- **Standard Parameters:** + - Use common parameter names (`Path`, `Name`, `Force`) + - Follow built-in cmdlet conventions + - Use aliases for specialized terms + - Document parameter purpose + +- **Parameter Names:** + - Use singular form unless always multiple + - Choose clear, descriptive names + - Follow PowerShell conventions + - Use PascalCase formatting + +- **Type Selection:** + - Use common .NET types + - Implement proper validation + - Consider ValidateSet for limited options + - Enable tab completion where possible + +- **Switch Parameters:** + - Use [switch] for boolean flags + - Avoid $true/$false parameters + - Default to $false when omitted + - Use clear action names + +### Example + +```powershell +function Set-ResourceConfiguration { + [CmdletBinding()] + param( + [Parameter(Mandatory)] + [string]$Name, + + [Parameter()] + [ValidateSet('Dev', 'Test', 'Prod')] + [string]$Environment = 'Dev', + + [Parameter()] + [switch]$Force, + + [Parameter()] + [ValidateNotNullOrEmpty()] + [string[]]$Tags + ) + + process { + # Logic here + } +} +``` + +## Pipeline and Output + +- **Pipeline Input:** + - Use `ValueFromPipeline` for direct object input + - Use `ValueFromPipelineByPropertyName` for property mapping + - Implement Begin/Process/End blocks for pipeline handling + - Document pipeline input requirements + +- **Output Objects:** + - Return rich objects, not formatted text + - Use PSCustomObject for structured data + - Avoid Write-Host for data output + - Enable downstream cmdlet processing + +- **Pipeline Streaming:** + - Output one object at a time + - Use process block for streaming + - Avoid collecting large arrays + - Enable immediate processing + +- **PassThru Pattern:** + - Default to no output for action cmdlets + - Implement `-PassThru` switch for object return + - Return modified/created object with `-PassThru` + - Use verbose/warning for status updates + +### Example + +```powershell +function Update-ResourceStatus { + [CmdletBinding()] + param( + [Parameter(Mandatory, ValueFromPipeline, ValueFromPipelineByPropertyName)] + [string]$Name, + + [Parameter(Mandatory)] + [ValidateSet('Active', 'Inactive', 'Maintenance')] + [string]$Status, + + [Parameter()] + [switch]$PassThru + ) + + begin { + Write-Verbose 'Starting resource status update process' + $timestamp = Get-Date + } + + process { + # Process each resource individually + Write-Verbose "Processing resource: $Name" + + $resource = [PSCustomObject]@{ + Name = $Name + Status = $Status + LastUpdated = $timestamp + UpdatedBy = $env:USERNAME + } + + # Only output if PassThru is specified + if ($PassThru.IsPresent) { + Write-Output $resource + } + } + + end { + Write-Verbose 'Resource status update process completed' + } +} +``` + +## Error Handling and Safety + +- **ShouldProcess Implementation:** + - Use `[CmdletBinding(SupportsShouldProcess = $true)]` + - Set appropriate `ConfirmImpact` level + - Call `$PSCmdlet.ShouldProcess()` for system changes + - Use `ShouldContinue()` for additional confirmations + +- **Message Streams:** + - `Write-Verbose` for operational details with `-Verbose` + - `Write-Warning` for warning conditions + - `Write-Error` for non-terminating errors + - `throw` for terminating errors + - Avoid `Write-Host` except for user interface text + +- **Error Handling Pattern:** + - Use try/catch blocks for error management + - Set appropriate ErrorAction preferences + - Return meaningful error messages + - Use ErrorVariable when needed + - Include proper terminating vs non-terminating error handling + - In advanced functions with `[CmdletBinding()]`, prefer `$PSCmdlet.WriteError()` over `Write-Error` + - In advanced functions with `[CmdletBinding()]`, prefer `$PSCmdlet.ThrowTerminatingError()` over `throw` + - Construct proper ErrorRecord objects with category, target, and exception details + +- **Non-Interactive Design:** + - Accept input via parameters + - Avoid `Read-Host` in scripts + - Support automation scenarios + - Document all required inputs + +### Example + +```powershell +function Remove-UserAccount { + [CmdletBinding(SupportsShouldProcess = $true, ConfirmImpact = 'High')] + param( + [Parameter(Mandatory, ValueFromPipeline)] + [ValidateNotNullOrEmpty()] + [string]$Username, + + [Parameter()] + [switch]$Force + ) + + begin { + Write-Verbose 'Starting user account removal process' + $ErrorActionPreference = 'Stop' + } + + process { + try { + # Validation + if (-not (Test-UserExists -Username $Username)) { + $errorRecord = [System.Management.Automation.ErrorRecord]::new( + [System.Exception]::new("User account '$Username' not found"), + 'UserNotFound', + [System.Management.Automation.ErrorCategory]::ObjectNotFound, + $Username + ) + $PSCmdlet.WriteError($errorRecord) + return + } + + # Confirmation + $shouldProcessMessage = "Remove user account '$Username'" + if ($Force -or $PSCmdlet.ShouldProcess($Username, $shouldProcessMessage)) { + Write-Verbose "Removing user account: $Username" + + # Main operation + Remove-ADUser -Identity $Username -ErrorAction Stop + Write-Warning "User account '$Username' has been removed" + } + } catch [Microsoft.ActiveDirectory.Management.ADException] { + $errorRecord = [System.Management.Automation.ErrorRecord]::new( + $_.Exception, + 'ActiveDirectoryError', + [System.Management.Automation.ErrorCategory]::NotSpecified, + $Username + ) + $PSCmdlet.ThrowTerminatingError($errorRecord) + } catch { + $errorRecord = [System.Management.Automation.ErrorRecord]::new( + $_.Exception, + 'UnexpectedError', + [System.Management.Automation.ErrorCategory]::NotSpecified, + $Username + ) + $PSCmdlet.ThrowTerminatingError($errorRecord) + } + } + + end { + Write-Verbose 'User account removal process completed' + } +} +``` + +## Documentation and Style + +- **Comment-Based Help:** Include comment-based help for any public-facing function or cmdlet. Inside the function, add a `<# ... #>` help comment with at least: + - `.SYNOPSIS` Brief description + - `.DESCRIPTION` Detailed explanation + - `.EXAMPLE` sections with practical usage + - `.PARAMETER` descriptions + - `.OUTPUTS` Type of output returned + - `.NOTES` Additional information + +- **Consistent Formatting:** + - Follow consistent PowerShell style + - Use proper indentation (4 spaces recommended) + - Opening braces on same line as statement + - Closing braces on new line + - Use line breaks after pipeline operators + - PascalCase for function and parameter names + - Avoid unnecessary whitespace + +- **Pipeline Support:** + - Implement Begin/Process/End blocks for pipeline functions + - Use ValueFromPipeline where appropriate + - Support pipeline input by property name + - Return proper objects, not formatted text + +- **Avoid Aliases:** Use full cmdlet names and parameters + - Avoid using aliases in scripts (e.g., use Get-ChildItem instead of gci); aliases are acceptable for interactive shell use. + - Use `Where-Object` instead of `?` or `where` + - Use `ForEach-Object` instead of `%` + - Use `Get-ChildItem` instead of `ls` or `dir` + +## Full Example: End-to-End Cmdlet Pattern + +```powershell +function New-Resource { + [CmdletBinding(SupportsShouldProcess = $true, ConfirmImpact = 'Medium')] + param( + [Parameter(Mandatory = $true, + ValueFromPipeline = $true, + ValueFromPipelineByPropertyName = $true)] + [ValidateNotNullOrEmpty()] + [string]$Name, + + [Parameter()] + [ValidateSet('Development', 'Production')] + [string]$Environment = 'Development' + ) + + begin { + Write-Verbose 'Starting resource creation process' + } + + process { + try { + if ($PSCmdlet.ShouldProcess($Name, 'Create new resource')) { + # Resource creation logic here + Write-Output ([PSCustomObject]@{ + Name = $Name + Environment = $Environment + Created = Get-Date + }) + } + } catch { + $errorRecord = [System.Management.Automation.ErrorRecord]::new( + $_.Exception, + 'ResourceCreationFailed', + [System.Management.Automation.ErrorCategory]::NotSpecified, + $Name + ) + $PSCmdlet.ThrowTerminatingError($errorRecord) + } + } + + end { + Write-Verbose 'Completed resource creation process' + } +} +``` diff --git a/.github/instructions/prompt.instructions.md b/.github/instructions/prompt.instructions.md new file mode 100644 index 000000000..a232edb97 --- /dev/null +++ b/.github/instructions/prompt.instructions.md @@ -0,0 +1,88 @@ +--- +description: 'Guidelines for creating high-quality prompt files for GitHub Copilot' +applyTo: '**/*.prompt.md' +--- + +# Copilot Prompt Files Guidelines + +Instructions for creating effective and maintainable prompt files that guide GitHub Copilot in delivering consistent, high-quality outcomes across any repository. + +## Scope and Principles +- Target audience: maintainers and contributors authoring reusable prompts for Copilot Chat. +- Goals: predictable behaviour, clear expectations, minimal permissions, and portability across repositories. +- Primary references: VS Code documentation on prompt files and organization-specific conventions. + +## Frontmatter Requirements + +Every prompt file should include YAML frontmatter with the following fields: + +### Required/Recommended Fields + +| Field | Required | Description | +|-------|----------|-------------| +| `description` | Recommended | A short description of the prompt (single sentence, actionable outcome) | +| `name` | Optional | The name shown after typing `/` in chat. Defaults to filename if not specified | +| `agent` | Recommended | The agent to use: `ask`, `edit`, `agent`, or a custom agent name. Defaults to current agent | +| `model` | Optional | The language model to use. Defaults to currently selected model | +| `tools` | Optional | List of tool/tool set names available for this prompt | +| `argument-hint` | Optional | Hint text shown in chat input to guide user interaction | + +### Guidelines + +- Use consistent quoting (single quotes recommended) and keep one field per line for readability and version control clarity +- If `tools` are specified and current agent is `ask` or `edit`, the default agent becomes `agent` +- Preserve any additional metadata (`language`, `tags`, `visibility`, etc.) required by your organization + +## File Naming and Placement +- Use kebab-case filenames ending with `.prompt.md` and store them under `.github/prompts/` unless your workspace standard specifies another directory. +- Provide a short filename that communicates the action (for example, `generate-readme.prompt.md` rather than `prompt1.prompt.md`). + +## Body Structure +- Start with an `#` level heading that matches the prompt intent so it surfaces well in Quick Pick search. +- Organize content with predictable sections. Recommended baseline: `Mission` or `Primary Directive`, `Scope & Preconditions`, `Inputs`, `Workflow` (step-by-step), `Output Expectations`, and `Quality Assurance`. +- Adjust section names to fit the domain, but retain the logical flow: why → context → inputs → actions → outputs → validation. +- Reference related prompts or instruction files using relative links to aid discoverability. + +## Input and Context Handling +- Use `${input:variableName[:placeholder]}` for required values and explain when the user must supply them. Provide defaults or alternatives where possible. +- Call out contextual variables such as `${selection}`, `${file}`, `${workspaceFolder}` only when they are essential, and describe how Copilot should interpret them. +- Document how to proceed when mandatory context is missing (for example, “Request the file path and stop if it remains undefined”). + +## Tool and Permission Guidance +- Limit `tools` to the smallest set that enables the task. List them in the preferred execution order when the sequence matters. +- If the prompt inherits tools from a chat mode, mention that relationship and state any critical tool behaviours or side effects. +- Warn about destructive operations (file creation, edits, terminal commands) and include guard rails or confirmation steps in the workflow. + +## Instruction Tone and Style +- Write in direct, imperative sentences targeted at Copilot (for example, “Analyze”, “Generate”, “Summarize”). +- Keep sentences short and unambiguous, following Google Developer Documentation translation best practices to support localization. +- Avoid idioms, humor, or culturally specific references; favor neutral, inclusive language. + +## Output Definition +- Specify the format, structure, and location of expected results (for example, “Create an architecture decision record file using the template below, such as `docs/architecture-decisions/record-XXXX.md`). +- Include success criteria and failure triggers so Copilot knows when to halt or retry. +- Provide validation steps—manual checks, automated commands, or acceptance criteria lists—that reviewers can execute after running the prompt. + +## Examples and Reusable Assets +- Embed Good/Bad examples or scaffolds (Markdown templates, JSON stubs) that the prompt should produce or follow. +- Maintain reference tables (capabilities, status codes, role descriptions) inline to keep the prompt self-contained. Update these tables when upstream resources change. +- Link to authoritative documentation instead of duplicating lengthy guidance. + +## Quality Assurance Checklist +- [ ] Frontmatter fields are complete, accurate, and least-privilege. +- [ ] Inputs include placeholders, default behaviours, and fallbacks. +- [ ] Workflow covers preparation, execution, and post-processing without gaps. +- [ ] Output expectations include formatting and storage details. +- [ ] Validation steps are actionable (commands, diff checks, review prompts). +- [ ] Security, compliance, and privacy policies referenced by the prompt are current. +- [ ] Prompt executes successfully in VS Code (`Chat: Run Prompt`) using representative scenarios. + +## Maintenance Guidance +- Version-control prompts alongside the code they affect; update them when dependencies, tooling, or review processes change. +- Review prompts periodically to ensure tool lists, model requirements, and linked documents remain valid. +- Coordinate with other repositories: when a prompt proves broadly useful, extract common guidance into instruction files or shared prompt packs. + +## Additional Resources +- [Prompt Files Documentation](https://code.visualstudio.com/docs/copilot/customization/prompt-files#_prompt-file-format) +- [Awesome Copilot Prompt Files](https://github.com/github/awesome-copilot/tree/main/prompts) +- [Tool Configuration](https://code.visualstudio.com/docs/copilot/chat/chat-agent-mode#_agent-mode-tools) diff --git a/.github/prompts/create-commit-title.prompt.md b/.github/prompts/create-commit-title.prompt.md new file mode 100644 index 000000000..bfdf81ba1 --- /dev/null +++ b/.github/prompts/create-commit-title.prompt.md @@ -0,0 +1,50 @@ +--- +agent: 'agent' +model: 'GPT-5.1-Codex-Max' +description: 'Generate an 80-character git commit title for the local diff' +--- + +# Generate Commit Title + +## Purpose +Provide a single-line, ready-to-paste git commit title (<= 80 characters) that reflects the most important local changes since `HEAD`. + +## Input to collect +- Run exactly one command to view the local diff: + ```@terminal + git diff HEAD + ``` + +## How to decide the title +1. From the diff, find the dominant area (e.g., `Samples/AppLifecycle/*`, `docs/**`) and the change type (new sample, bug fix, docs update, config tweak). +2. Draft an imperative, plain-ASCII title that: + - Mentions the primary feature/sample when obvious (e.g., `AppLifecycle:` or `Docs:`) + - Stays within 80 characters and has no trailing punctuation + +## Final output +- Reply with only the commit title on a single line—no extra text. + +## PR title convention (when asked) +Use Conventional Commits style: + +`(): ` + +**Allowed types** +- feat, fix, docs, refactor, perf, test, build, ci, chore, sample + +**Scope rules** +- Use a short, WindowsAppSDK-Samples-focused scope (one word preferred). Common scopes: + - Core: `docs`, `build`, `ci`, `templates`, `repo` + - Features: `applifecycle`, `activation`, `instancing`, `restart`, `notifications`, `push`, `app-notifications`, `windowing`, `widgets`, `mica`, `textrendering`, `resourcemanagement`, `deployment`, `installer`, `unpackaged`, `islands`, `composition`, `input`, `customcontrols`, `backgroundtask`, `scenegraph`, `photoeditor`, `windowsai`, `windowsml` +- If unclear, pick the closest feature or sample area; omit only if unavoidable + +**Summary rules** +- Imperative, present tense (“add”, “update”, “remove”, “fix”) +- Keep it <= 72 characters when possible; be specific, avoid “misc changes” + +**Examples** +- `feat(applifecycle): add activation sample for file type associations` +- `fix(notifications): correct push notification channel registration` +- `docs(windowing): document presenter configuration options` +- `build(ci): add SamplesCI pipeline for new feature` +- `sample(widgets): add weather widget implementation` diff --git a/.github/prompts/create-pr-summary.prompt.md b/.github/prompts/create-pr-summary.prompt.md new file mode 100644 index 000000000..20201c477 --- /dev/null +++ b/.github/prompts/create-pr-summary.prompt.md @@ -0,0 +1,25 @@ +--- +agent: 'agent' +model: 'GPT-5.1-Codex-Max' +description: 'Generate a WindowsAppSDK-Samples-ready pull request description from the local diff' +--- + +# Generate PR Summary + +**Goal:** Produce a ready-to-paste PR title and description that follows WindowsAppSDK-Samples conventions by comparing the current branch against a user-selected target branch. + +**Repo guardrails:** +- Treat `docs/pull_request_template.md` as the single source of truth; load it at runtime instead of embedding hardcoded content in this prompt. +- Preserve section order from the template but only surface checklist lines that are relevant for the detected changes, filling them with `[x]`/`[ ]` as appropriate. +- Cite touched paths with inline backticks, matching the guidance in `.github/copilot-instructions.md`. +- Call out build/test validation explicitly: state which platforms (x64, x86, ARM64) and configurations (Debug, Release) were tested, or why testing was not applicable. + +**Workflow:** +1. Determine the target branch from user context; default to `main` when no branch is supplied. +2. Run `git status --short` once to surface uncommitted files that may influence the summary. +3. Run `git diff ...HEAD` a single time to review the detailed changes. Only when confidence stays low dig deeper with focused calls such as `git diff ...HEAD -- `. +4. From the diff, capture impacted areas (features, samples), key file changes, behavioral risks, and noteworthy edge cases. +5. Confirm validation: list builds and tests executed with results, or state why they were skipped in line with repo guidance. +6. Load `docs/pull_request_template.md`, mirror its section order, and populate it with the gathered facts. Include only relevant checklist entries, marking them `[x]/[ ]` and noting any intentional omissions as "N/A". +7. Present the filled template inside a fenced ```markdown code block with no extra commentary so it is ready to paste into a PR, clearly flagging any placeholders that still need user input. +8. Prepend the PR title above the filled template. Construct the PR title using the same Conventional Commit type/scope rules defined for commit titles in `.github/prompts/create-commit-title.prompt.md` (this repo intentionally applies the commit-title convention to PR titles); pick the dominant component from the diff and keep the title concise and imperative. diff --git a/.github/prompts/fix-issue.prompt.md b/.github/prompts/fix-issue.prompt.md new file mode 100644 index 000000000..cd4b154e1 --- /dev/null +++ b/.github/prompts/fix-issue.prompt.md @@ -0,0 +1,68 @@ +--- +agent: 'agent' +model: 'GPT-5.1-Codex-Max' +description: 'Execute the fix for a GitHub issue using the previously generated implementation plan' +--- + +# Fix GitHub Issue + +## Dependencies +Source review prompt (for generating the implementation plan if missing): +- .github/prompts/review-issue.prompt.md + +Required plan file (single source of truth): +- Generated Files/issueReview/{{issue_number}}/implementation-plan.md + +## Dependency Handling +1) If `implementation-plan.md` exists → proceed. +2) If missing → run the review prompt: + - Invoke: `.github/prompts/review-issue.prompt.md` + - Pass: `issue_number={{issue_number}}` + - Then re-check for `implementation-plan.md`. +3) If still missing → stop and generate: + - `Generated Files/issueFix/{{issue_number}}/manual-steps.md` containing: + “implementation-plan.md not found; please run .github/prompts/review-issue.prompt.md for #{{issue_number}}.” + +# GOAL +For **#{{issue_number}}**: +- Use implementation-plan.md as the single authority. +- Apply code and test changes directly in the repository. +- Produce a PR-ready description. + +# OUTPUT FILES +1) Generated Files/issueFix/{{issue_number}}/pr-description.md +2) Generated Files/issueFix/{{issue_number}}/manual-steps.md # only if human interaction or external setup is required + +# EXECUTION RULES +1) Read implementation-plan.md and execute: + - Layers & Files → edit/create as listed + - Pattern Choices → follow repository conventions + - Fundamentals (perf, security, compatibility, accessibility) + - Logging & Exceptions + - Telemetry (only if explicitly included in the plan) + - Risks & Mitigations + - Tests to Add +2) Locate affected files via `rg` or `git grep`. +3) Add/update tests to enforce the fixed behavior. +4) If any ambiguity exists, add: +// TODO(Human input needed): +5) Verify locally: build & tests run successfully. + +# PR DESCRIPTION +Generate the PR description by invoking `.github/prompts/create-pr-summary.prompt.md`. +Append `Closes #{{issue_number}}` to the generated description. +Save the result to `Generated Files/issueFix/{{issue_number}}/pr-description.md`. + +# manual-steps.md (only if needed) +- List required human actions: secrets, config, approvals, missing info, or code comments requiring human decisions. + +# IMPORTANT +- Apply code and tests directly; do not produce patch files. +- Follow implementation-plan.md as the source of truth. +- Insert comments for human review where a decision or input is required. +- Use repository conventions and deterministic, minimal changes. + +# FINALIZE +- Write pr-description.md +- Write manual-steps.md only if needed +- Print concise success message or note items requiring human interaction diff --git a/.github/prompts/review-issue.prompt.md b/.github/prompts/review-issue.prompt.md new file mode 100644 index 000000000..769823fd3 --- /dev/null +++ b/.github/prompts/review-issue.prompt.md @@ -0,0 +1,160 @@ +--- +agent: 'agent' +model: 'GPT-5.1-Codex-Max' +description: 'Review a GitHub issue, score it (0-100), and generate an implementation plan' +--- + +# Review GitHub Issue + +## Goal +For **#{{issue_number}}** produce: +1) `Generated Files/issueReview/{{issue_number}}/overview.md` +2) `Generated Files/issueReview/{{issue_number}}/implementation-plan.md` + +## Inputs +Figure out required inputs {{issue_number}} from the invocation context; if anything is missing, ask for the value or note it as a gap. + +# CONTEXT (brief) +Ground evidence using `gh issue view {{issue_number}} --json number,title,body,author,createdAt,updatedAt,state,labels,milestone,reactions,comments,linkedPullRequests`, and download images to better understand the issue context. +Locate source code in the current workspace; feel free to use `rg`/`git grep`. Link related issues and PRs. + +# OVERVIEW.MD +## Summary +Issue, state, milestone, labels. **Signals**: 👍/❤️/👎, comment count, last activity, linked PRs. + +## At-a-Glance Score Table +Present all ratings in a compact table for quick scanning: + +| Dimension | Score | Assessment | Key Drivers | +|-----------|-------|------------|-------------| +| **A) Business Importance** | X/100 | Low/Medium/High | Top 2 factors with scores | +| **B) Community Excitement** | X/100 | Low/Medium/High | Top 2 factors with scores | +| **C) Technical Feasibility** | X/100 | Low/Medium/High | Top 2 factors with scores | +| **D) Requirement Clarity** | X/100 | Low/Medium/High | Top 2 factors with scores | +| **Overall Priority** | X/100 | Low/Medium/High/Critical | Average or weighted summary | +| **Effort Estimate** | X days (T-shirt) | XS/S/M/L/XL/XXL/Epic | Type: bug/feature/chore | +| **Similar Issues Found** | X open, Y closed | — | Quick reference to related work | +| **Potential Assignees** | @username, @username | — | Top contributors to module | + +**Assessment bands**: 0-25 Low, 26-50 Medium, 51-75 High, 76-100 Critical + +## Ratings (0–100) — add evidence & short rationale +### A) Business Importance +- Labels (priority/security/regression): **≤35** +- Milestone/roadmap: **≤25** +- Customer/contract impact: **≤20** +- Unblocks/platform leverage: **≤20** +### B) Community Excitement +- 👍+❤️ normalized: **≤45** +- Comment volume & unique participants: **≤25** +- Recent activity (≤30d): **≤15** +- Duplicates/related issues: **≤15** +### C) Technical Feasibility +- Contained surface/clear seams: **≤30** +- Existing patterns/utilities: **≤25** +- Risk (perf/sec/compat) manageable: **≤25** +- Testability & CI support: **≤20** +### D) Requirement Clarity +- Behavior/repro/constraints: **≤60** +- Non-functionals (perf/sec/i18n/a11y): **≤25** +- Decision owners/acceptance signals: **≤15** + +## Effort +Days + **T-shirt** (XS 0.5–1d, S 1–2, M 2–4, L 4–7, XL 7–14, XXL 14–30, Epic >30). +Type/level: bug/feature/chore/docs/refactor/test-only; severity/value tier. + +## Suggested Actions +Provide actionable recommendations for issue triage and assignment: + +### A) Requirement Clarification (if Clarity score <50) +**When Requirement Clarity (Dimension D) is Medium or Low:** +- Identify specific gaps in issue description: missing repro steps, unclear expected behavior, undefined acceptance criteria, missing non-functional requirements +- Draft 3-5 clarifying questions to post as issue comment +- Suggest additional information needed: screenshots, logs, environment details, OS version, Windows App SDK version, Visual Studio version, error messages +- If behavior is ambiguous, propose 2-3 interpretation scenarios and ask reporter to confirm +- Example questions: + - "Can you provide exact steps to reproduce this issue?" + - "What is the expected behavior vs. what you're actually seeing?" + - "Does this happen on Windows 10, 11, or both?" + - "Can you attach a screenshot or screen recording?" + +### B) Correct Label Suggestions +- Analyze issue type, sample area, and severity to suggest missing or incorrect labels +- Recommend labels from: `bug`, `enhancement`, `documentation`, `question`, `duplicate`, `needs-triage`, `needs-author-feedback`, `sample-`, etc. +- If Requirement Clarity is low (<50), add `needs-author-feedback` label +- If current labels are incorrect or incomplete, provide specific label changes with rationale + +### C) Find Similar Issues & Past Fixes +- Search for similar issues using `gh issue list --search "keywords" --state all --json number,title,state,closedAt` +- Identify patterns: duplicate issues, related bugs, or similar feature requests +- For closed issues, find linked PRs that fixed them: check `linkedPullRequests` in issue data +- Provide 3-5 examples of similar issues with format: `# - (closed by PR #<pr>)` or `(still open)` + +### D) Identify Subject Matter Experts +- Use git blame/log to find who fixed similar issues in the past +- Search for PR authors who touched relevant files: `git log --all --format='%aN' -- <file_paths> | sort | uniq -c | sort -rn | head -5` +- Check issue/PR history for frequent contributors to the affected module +- Suggest 2-3 potential assignees with context: `@<username> - <reason>` (e.g., "fixed similar sample issue in #12345", "maintains AppLifecycle samples") + +### E) Semantic Search for Related Work +- Use semantic_search tool to find similar issues, code patterns, or past discussions +- Search queries should include: issue keywords, module names, error messages, feature descriptions +- Cross-reference semantic results with GitHub issue search for comprehensive coverage + +**Output format for Suggested Actions section in overview.md:** +```markdown +## Suggested Actions + +### Clarifying Questions (if Clarity <50) +Post these questions as issue comment to gather missing information: +1. <question> +2. <question> +3. <question> + +**Recommended label**: `Needs-Author-Feedback` + +### Label Recommendations +- Add: `<label>` - <reason> +- Remove: `<label>` - <reason> +- Current labels are appropriate ✓ + +### Similar Issues Found +1. #<number> - <title> (<state>, closed by PR #<pr> on <date>) +2. #<number> - <title> (<state>) +... + +### Potential Assignees +- @<username> - <reason> +- @<username> - <reason> + +### Related Code/Discussions +- <semantic search findings> +``` + +# IMPLEMENTATION-PLAN.MD +1) **Problem Framing** — restate problem; current vs expected; scope boundaries. +2) **Layers & Files** — layers (UI/domain/data/infra/build). For each, list **files/dirs to modify** and **new files** (exact paths + why). Prefer repo patterns; cite examples/PRs. +3) **Pattern Choices** — reuse existing; if new, justify trade-offs & transition. +4) **Fundamentals** (brief plan or N/A + reason): +- Performance (hot paths, allocs, caching/streaming) +- Security (validation, authN/Z, secrets, SSRF/XSS/CSRF) +- G11N/L10N (resources, number/date, pluralization) +- Compatibility (public APIs, formats, OS/runtime/toolchain) +- Extensibility (DI seams, options/flags, plugin points) +- Accessibility (roles, labels, focus, keyboard, contrast) +- SOLID & repo conventions (naming, folders, dependency direction) +5) **Logging & Exception Handling** +- Where to log; levels; structured fields; correlation/traces. +- What to catch vs rethrow; retries/backoff; user-visible errors. +- **Privacy**: never log secrets/PII; redaction policy. +6) **Telemetry (optional — business metrics only)** +- Events/metrics (name, when, props); success signal; privacy/sampling; dashboards/alerts. +7) **Risks & Mitigations** — flags/canary/shadow-write/config guards. +8) **Task Breakdown (agent-ready)** — table (leave a blank line before the header so Markdown renders correctly): + +| Task | Intent | Files/Areas | Steps | Tests (brief) | Owner (Agent/Human) | Human interaction needed? (why) | +|---|---|---|---|---|---|---| + +9) **Tests to Add (only)** +- **Unit**: targets, cases (success/edge/error), mocks/fixtures, path, notes. +- **UI** (if applicable): flows, locator strategy, env/data/flags, path, flake mitigation. \ No newline at end of file diff --git a/.github/prompts/review-pr.prompt.md b/.github/prompts/review-pr.prompt.md new file mode 100644 index 000000000..0fa2fa114 --- /dev/null +++ b/.github/prompts/review-pr.prompt.md @@ -0,0 +1,184 @@ +--- +agent: 'agent' +model: 'GPT-5.1-Codex-Max' +description: 'Perform a comprehensive PR review with per-step Markdown and machine-readable outputs' +--- + +# Review Pull Request + +**Goal**: Given `{{pr_number}}`, run a *one-topic-per-step* review. Write files to `Generated Files/prReview/{{pr_number}}/` (replace `{{pr_number}}` with the integer). Emit machine‑readable blocks for a GitHub MCP to post review comments. + +## PR selection +Resolve the target PR using these fallbacks in order: +1. Parse the invocation text for an explicit identifier (first integer following patterns such as a leading hash and digits or the text `PR:` followed by digits). +2. If no PR is found yet, locate the newest `Generated Files/prReview/_batch/batch-overview-*.md` file (highest timestamp in filename, fallback newest mtime) and take the first entry in its `## PRs` list whose review folder is missing `00-OVERVIEW.md` or contains `__error.flag`. +3. If the batch file has no pending PRs, query assignments with `gh pr list --assignee @me --state open --json number,updatedAt --limit 20` and pick the most recently updated PR that does not already have a completed review folder. +4. If still unknown, run `gh pr view --json number` in the current branch and use that result when it is unambiguous. +5. If every step above fails, prompt the user for a PR number before proceeding. + +## Fetch PR data with `gh` +- `gh pr view {{pr_number}} --json number,baseRefName,headRefName,baseRefOid,headRefOid,changedFiles,files` +- `gh api repos/:owner/:repo/pulls/{{pr_number}}/files?per_page=250` # patches for line mapping + +### Incremental review workflow +1. **Check for existing review**: Read `Generated Files/prReview/{{pr_number}}/00-OVERVIEW.md` +2. **Extract state**: Parse `Last reviewed SHA:` from review metadata section +3. **Detect changes**: Compare last reviewed SHA with current PR head using `gh api repos/:owner/:repo/compare/{{last_sha}}...{{head_sha}} --jq '.commits | length, .files[].filename'` +4. **Analyze result**: + - If force-push detected (last SHA not in history) → Full review needed + - If commits added since last review → Review only changed files + - If no changes → Skip review (update iteration history with "No changes since last review") +5. **Apply smart filtering**: Use the file patterns in smart step filtering table to skip irrelevant steps +6. **Update metadata**: After completing review, save current `headRefOid` as `Last reviewed SHA:` in `00-OVERVIEW.md` + +## Output files +Folder: `Generated Files/prReview/{{pr_number}}/` +Files: `00-OVERVIEW.md`, `01-functionality.md`, `02-compatibility.md`, `03-performance.md`, `04-accessibility.md`, `05-security.md`, `06-localization.md`, `07-globalization.md`, `08-extensibility.md`, `09-solid-design.md`, `10-repo-patterns.md`, `11-docs-automation.md`, `12-code-comments.md`, `13-copilot-guidance.md` *(only if guidance md exists).* +- **Write-after-step rule:** Immediately after completing each TODO step, persist that step's markdown file before proceeding to the next. Generate `00-OVERVIEW.md` only after every step file has been refreshed for the current run. + +## Iteration management +- Determine the current review iteration by reading `00-OVERVIEW.md` (look for `Review iteration:`). If missing, assume iteration `1`. +- Extract the last reviewed SHA from `00-OVERVIEW.md` (look for `Last reviewed SHA:` in the review metadata section). If missing, this is iteration 1. +- **Incremental review detection**: + 1. Use `gh api repos/:owner/:repo/compare/{{last_sha}}...{{head_sha}}` to get delta analysis. + 2. Check if `last_sha` exists in the commit history; if not (force-push), do a full review. + 3. If incremental, review only the files listed in the compare response and apply smart step filtering (see below). +- Increment the iteration for each review run and propagate the new value to all step files and the overview. +- Preserve prior iteration notes by keeping/expanding an `## Iteration history` section in each markdown file, appending the newest summary under `### Iteration <N>`. +- Summaries should capture key deltas since the previous iteration so reruns can pick up context quickly. +- **After review completion**, update `Last reviewed SHA:` in `00-OVERVIEW.md` with the current `headRefOid` and update the timestamp. + +### Smart step filtering (incremental reviews only) +When performing incremental review, skip steps that are irrelevant based on changed file types: + +| File pattern | Required steps | Skippable steps | +| --- | --- | --- | +| `**/*.cs`, `**/*.cpp`, `**/*.h` | Functionality, Compatibility, Performance, Security, SOLID, Repo patterns, Code comments | (depends on files) | +| `**/*.resx`, `**/Resources/*.xaml` | Localization, Globalization | Most others | +| `**/*.md` (docs) | Docs & automation | Most others (unless copilot guidance) | +| `**/*copilot*.md`, `.github/prompts/*.md` | Copilot guidance, Docs & automation | Most others | +| `**/*.csproj`, `**/*.vcxproj`, `**/packages.config` | Compatibility, Security, Repo patterns | Localization, Globalization, Accessibility | +| `**/UI/**`, `**/*View.xaml` | Accessibility, Localization | Performance (unless perf-sensitive controls) | + +**Default**: If uncertain or files span multiple categories, run all applicable steps. When in doubt, be conservative and review more rather than less. + +## TODO steps (one concern each) +1) Functionality — Does the implementation correctly follows SDK patterns? +2) Compatibility — Windows 10 1809+, x64/x86/ARM64, Debug/Release configurations +3) Performance — No unnecessary allocations or blocking operations +4) Accessibility — Follows [accessibility checklist](https://docs.microsoft.com/windows/apps/design/accessibility/accessibility-checklist) +5) Security — No hardcoded secrets, proper input validation +6) Localization — Resources properly externalized where applicable +7) Globalization — Culture-aware formatting where applicable +8) Extensibility — Clear patterns for developers to adapt +9) SOLID principles — Clean, maintainable SDK code +10) Repo patterns — Follows [Coding-Guidelines.md](docs/Coding-Guidelines.md) conventions +11) Docs & automation — Documentation updated, CI pipeline configured +12) Code comments — Appropriate copyright headers, helpful inline comments +13) Copilot guidance (conditional): if changed folders contain `*copilot*.md` or `.github/prompts/*.md`, review diffs **against** that guidance and write `13-copilot-guidance.md` (omit if none). + +## Per-step file template (use verbatim) +```md +# <STEP TITLE> +**PR:** (populate with PR identifier) — Base:<baseRefName> Head:<headRefName> +**Review iteration:** ITERATION + +## Iteration history +- Maintain subsections titled `### Iteration N` in reverse chronological order (append the latest at the top) with 2–4 bullet highlights. + +### Iteration ITERATION +- <Latest key point 1> +- <Latest key point 2> + +## Checks executed +- List the concrete checks for *this step only* (5–10 bullets). + +## Findings +(If none, write **None**. Defaults have one or more blocks:) + +```mcp-review-comment +{"file":"relative/path.ext","start_line":123,"end_line":125,"severity":"high|medium|low|info","tags":["<step-slug>","pr-tag-here"],"related_files":["optional/other/file1"],"body":"Problem → Why it matters → Concrete fix. If spans multiple files, name them here."} +``` +Use the second tag to encode the PR number. + +``` +## Overview file (`00-OVERVIEW.md`) template +```md +# PR Review Overview — (populate with PR identifier) +**Review iteration:** ITERATION +**Changed files:** <n> | **High severity issues:** <count> + +## Review metadata +**Last reviewed SHA:** <headRefOid from gh pr view> +**Last review timestamp:** <ISO8601 timestamp> +**Review mode:** <Full|Incremental (N files changed since iteration X)> +**Base ref:** <baseRefName> +**Head ref:** <headRefName> + +## Step results +Write lines like: `01 Functionality — <OK|Issues|Skipped> (see 01-functionality.md)` … through step 13. +Mark steps as "Skipped" when using incremental review smart filtering. + +## Iteration history +- Maintain subsections titled `### Iteration N` mirroring the per-step convention with concise deltas and cross-links to the relevant step files. +- For incremental reviews, list the specific files that changed and which commits were added. +``` + +## Line numbers & multi‑file issues +- Map head‑side lines from `patch` hunks (`@@ -a,b +c,d @@` → new lines `+c..+c+d-1`). +- For cross‑file issues: set the primary `"file"`, list others in `"related_files"`, and name them in `"body"`. + +## Posting (for MCP) +- Parse all ```mcp-review-comment``` blocks across step files and post as PR review comments. +- If posting isn’t available, still write all files. + +## Constraint +Read/analyze only; don't modify code. Keep comments small, specific, and fix‑oriented. + +## Scratch cache for large PRs + +Create a local scratch workspace to progressively summarize diffs and reload state across runs. + +### Paths +- Root: `Generated Files/prReview/{{pr_number}}/__tmp/` +- Files: + - `index.jsonl` — append-only JSON Lines index of artifacts. + - `todo-queue.json` — pending items (files/chunks/steps). + - `rollup-<step>-v<N>.md` — iterative per-step aggregates. + - `file-<hash>.txt` — optional saved chunk text (when needed). + +### JSON schema (per line in `index.jsonl`) +```json +{"type":"chunk|summary|issue|crosslink", + "path":"relative/file.ext","chunk_id":"f-12","step":"functionality|compatibility|...", + "base_sha":"...", "head_sha":"...", "range":[start,end], "version":1, + "notes":"short text or key:value map", "created_utc":"ISO8601"} +``` + +### Phases (stateful; resume-safe) +0. **Discover** PR + SHAs: `gh pr view <PR> --json baseRefName,headRefName,baseRefOid,headRefOid,files`. +1. **Chunk** each changed file (head): split into ~300–600 LOC or ~4k chars; stable `chunk_id` = hash(path+start). + - Save `chunk` records. Optionally write `file-<hash>.txt` for expensive chunks. +2. **Summarize** per chunk: intent, APIs, risks per TODO step; emit `summary` records (≤600 tokens each). +3. **Issues**: convert findings to machine-readable blocks and emit `issue` records (later rendered to step MD). +4. **Rollups**: build/update `rollup-<step>-v<N>.md` from `summary`+`issue`. Keep prior versions. +5. **Finalize**: write per-step files + `00-OVERVIEW.md` from rollups. Post comments via MCP if available. + +### Re-use & token limits +- Always **reload** `index.jsonl` first; skip chunks with same `head_sha` and `range`. +- **Incremental review optimization**: When comparing SHAs returns a subset of changed files, load only chunks from those files. Reuse existing chunks/summaries for unchanged files. +- Prefer re-summarizing only changed chunks; merge chunk summaries → file summaries → step rollups. +- When context is tight, load only the minimal chunk text (or its saved `file-<hash>.txt`) needed for a comment. + +### Original vs diff +- Fetch base content when needed: prefer `git show <baseRefName>:<path>`; fallback `gh api repos/:owner/:repo/contents/<path>?ref=<base_sha>` (base64). +- Use patch hunks from `gh api .../pulls/<PR>/files` to compute **head** line numbers. + +### Queue-driven loop +- Seed `todo-queue.json` with all changed files. +- Process: chunk → summarize → detect issues → roll up. +- Append to `index.jsonl` after each step; never rewrite previous lines (append-only). + +### Hygiene +- `__tmp/` is implementation detail; do not include in final artifacts. +- It is safe to delete to force a clean pass; the next run rebuilds it. \ No newline at end of file diff --git a/.gitignore b/.gitignore index 04e537eaa..258022156 100644 --- a/.gitignore +++ b/.gitignore @@ -39,9 +39,6 @@ Samples/WindowsML/Resources/obj/ # Uncomment if you have tasks that create the project's static files in wwwroot #wwwroot/ -# Visual Studio code -.vscode/ - # Visual Studio 2017 auto generated files Generated\ Files/ diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 000000000..868a34ff8 --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,17 @@ +{ + "github.copilot.chat.reviewSelection.instructions": [ + { + "file": ".github/prompts/review-pr.prompt.md" + } + ], + "github.copilot.chat.commitMessageGeneration.instructions": [ + { + "file": ".github/prompts/create-commit-title.prompt.md" + } + ], + "github.copilot.chat.pullRequestDescriptionGeneration.instructions": [ + { + "file": ".github/prompts/create-pr-summary.prompt.md" + } + ] +} \ No newline at end of file diff --git a/.vscode/tasks.json b/.vscode/tasks.json new file mode 100644 index 000000000..ca2870584 --- /dev/null +++ b/.vscode/tasks.json @@ -0,0 +1,70 @@ +{ + "version": "2.0.0", + + "inputs": [ + { + "id": "config", + "type": "pickString", + "description": "Configuration", + "options": ["Debug", "Release"], + "default": "Release" + }, + { + "id": "platform", + "type": "pickString", + "description": "Platform (auto = detect host)", + "options": ["auto", "x64", "x86", "arm64"], + "default": "auto" + } + ], + + "tasks": [ + { + "label": "Build: Current file's sample (default)", + "type": "shell", + "command": "pwsh", + "args": [ + "-NoProfile", + "-ExecutionPolicy", + "Bypass", + "-File", + "${workspaceFolder}\\build.ps1", + "-Platform", + "${input:platform}", + "-Configuration", + "${input:config}", + "-Sample", + "${fileDirname}" + ], + "group": { "kind": "build", "isDefault": true }, + "presentation": { + "reveal": "always", + "panel": "dedicated", + "clear": true + }, + "problemMatcher": "$msCompile" + }, + { + "label": "Build: All samples", + "type": "shell", + "command": "pwsh", + "args": [ + "-NoProfile", + "-ExecutionPolicy", + "Bypass", + "-File", + "${workspaceFolder}\\build.ps1", + "-Platform", + "${input:platform}", + "-Configuration", + "${input:config}" + ], + "presentation": { + "reveal": "always", + "panel": "dedicated", + "clear": true + }, + "problemMatcher": "$msCompile" + } + ] +} diff --git a/AGENTS.md b/AGENTS.md new file mode 100644 index 000000000..145128617 --- /dev/null +++ b/AGENTS.md @@ -0,0 +1,73 @@ +# Windows App SDK Samples – AI Contributor Guide + +Comprehensive guidance for AI contributions to Windows App SDK Samples. + +## Quick Reference + +- **Build**: Use `build.ps1` or `build.cmd` at repo root (auto-detects platform, supports `-Sample <name>` for targeted builds) +- **Run**: Deploy and test samples on Desktop (x64, x86, ARM64) in Debug and Release configurations +- **Verify**: Run Windows App Certification Kit (WACK) on Release builds +- **Exit code 0 = success** – do not proceed if build fails + +### Build Examples +```powershell +./build.ps1 # Build all samples (auto-detect platform) +./build.ps1 -Sample AppLifecycle # Build only AppLifecycle sample +./build.ps1 -Platform arm64 -Configuration Debug # Specific platform and config +``` + +## Key Rules + +- Samples should be **complete but simple** – demonstrate correct API usage without excessive abstraction +- Follow **scenario-based design** – each scenario covers one way of using the API +- Support all platforms: x64, x86, ARM64 in both Debug and Release +- Set minimum supported OS version to Windows 10 version 1809 (build 17763) +- Include copyright headers in all source files +- Build clean with no warnings or errors + +## Project Structure + +Samples follow this organization: +``` +\Samples + \<FeatureName> + \<Language>-<UI Framework> +``` + +- **FeatureName**: Use simple English name (e.g., `TextRendering` not `DWriteCore`) +- **Language**: `cs` | `cpp` +- **UI Framework (C#)**: `winui` | `wpf` | `winforms` | `console` +- **UI Framework (C++)**: `winui` | `win32` | `console` | `directx` + +## Style Enforcement + +- **C#**: Follow `.editorconfig` at repo root (4-space indent, Allman braces, UTF-8 BOM) +- **C++**: Use C++/WinRT for new samples; some samples include `.clang-format` (check `Samples/WindowsML/`) +- **XAML**: Use consistent formatting + +## Copyright Headers + +For C#/C++/IDL files: +```csharp +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. +``` + +For XAML files: +```xml +<!-- Copyright (c) Microsoft Corporation. + Licensed under the MIT License. --> +``` + +## When to Ask for Clarification + +- Ambiguous sample requirements after reviewing docs +- Cross-feature impact unclear +- API usage patterns not well documented + +## Detailed Documentation + +- [Samples Guidelines](/docs/samples-guidelines.md) – Complete guidelines and checklist +- [Contributing](CONTRIBUTING.md) – Contribution requirements +- [PR Template](docs/pull_request_template.md) – Pull request checklist +- [Windows App SDK Docs](https://docs.microsoft.com/windows/apps/windows-app-sdk/) – Official documentation diff --git a/build.ps1 b/build.ps1 index 39ebffbd8..b28831298 100644 --- a/build.ps1 +++ b/build.ps1 @@ -100,9 +100,34 @@ function Get-Solutions { param([string]$SampleFilter) $targetRoot = $null; $solutions = @() if (-not [string]::IsNullOrWhiteSpace($SampleFilter)) { - $targetRoot = Join-Path $samplesRoot $SampleFilter - if (-not (Test-Path $targetRoot)) { Write-Error "Sample path not found: $targetRoot"; exit 1 } - $solutions = Get-ChildItem -Path $targetRoot -Filter *.sln -Recurse | Sort-Object FullName + # Check if input is an existing path + if (Test-Path $SampleFilter) { + $resolvedPath = (Resolve-Path $SampleFilter).Path + $samplesRootResolved = (Resolve-Path $samplesRoot).Path + # Reject paths outside samplesRoot + if (-not $resolvedPath.StartsWith($samplesRootResolved, [System.StringComparison]::OrdinalIgnoreCase)) { + Write-Error "Path must be under Samples root: $samplesRootResolved"; exit 1 + } + $probeDir = if (Test-Path $resolvedPath -PathType Container) { $resolvedPath } else { Split-Path -Parent $resolvedPath } + # Walk up to find .sln, stop at samplesRoot + while ($probeDir -and $probeDir.StartsWith($samplesRootResolved, [System.StringComparison]::OrdinalIgnoreCase)) { + $localSolutions = Get-ChildItem -Path $probeDir -Filter *.sln -File -ErrorAction SilentlyContinue | Sort-Object FullName + if ($localSolutions -and $localSolutions.Count -gt 0) { + Write-Host "Detected $($localSolutions.Count) solution(s) at: $probeDir" -ForegroundColor Yellow + return $localSolutions + } + $parent = Split-Path -Parent $probeDir + if ([string]::IsNullOrWhiteSpace($parent) -or $parent -eq $probeDir) { break } + $probeDir = $parent + } + Write-Warning "No solution found walking up from: $SampleFilter (stopped at Samples root)" + } + else { + # Treat as sample name; join with samplesRoot + $targetRoot = Join-Path $samplesRoot $SampleFilter + if (-not (Test-Path $targetRoot)) { Write-Error "Sample path not found: $targetRoot"; exit 1 } + $solutions = Get-ChildItem -Path $targetRoot -Filter *.sln -Recurse | Sort-Object FullName + } } else { $currentDir = Get-Location From 55da07ec6e7c4f54a8e9e85e9b3ea5d0e0575982 Mon Sep 17 00:00:00 2001 From: Hemant Kumar <74819547+Hemantxk@users.noreply.github.com> Date: Wed, 21 Jan 2026 13:58:06 +0530 Subject: [PATCH 3/3] Adding C++ Custom predicate sample for WinUI3 (#585) --- .../ConditionalPredicate/cpp-winui/App.xaml | 21 ++ .../cpp-winui/App.xaml.cpp | 38 +++ .../ConditionalPredicate/cpp-winui/App.xaml.h | 19 ++ .../cpp-winui/Assets/SplashScreen.png | Bin 0 -> 78102 bytes .../cpp-winui/Assets/Square150x150Logo.png | Bin 0 -> 10887 bytes .../cpp-winui/Assets/Square44x44Logo.png | Bin 0 -> 2793 bytes .../cpp-winui/Assets/Wide310x150Logo.png | Bin 0 -> 11204 bytes .../cpp-winui/Assets/logo.png | Bin 0 -> 3138 bytes .../cpp-winui/Assets/windows-sdk.ico | Bin 0 -> 2150 bytes .../cpp-winui/ConditionalXamlPredicate.sln | 43 +++ .../ConditionalXamlPredicate.vcxproj | 260 ++++++++++++++++++ .../ConditionalXamlPredicate.vcxproj.filters | 62 +++++ .../cpp-winui/MainPage.xaml | 29 ++ .../cpp-winui/MainPage.xaml.cpp | 156 +++++++++++ .../cpp-winui/MainPage.xaml.h | 33 +++ .../cpp-winui/MainWindow.xaml | 13 + .../cpp-winui/MainWindow.xaml.cpp | 89 ++++++ .../cpp-winui/MainWindow.xaml.h | 29 ++ .../cpp-winui/MyCustomPredicate.cpp | 30 ++ .../cpp-winui/MyCustomPredicate.h | 21 ++ .../cpp-winui/Package.appxmanifest | 47 ++++ .../cpp-winui/Project.idl | 56 ++++ .../cpp-winui/SampleConfiguration.cpp | 25 ++ .../cpp-winui/SampleConfiguration.h | 15 + .../Scenario1_LoadConditionalControls.xaml | 66 +++++ ...Scenario1_LoadConditionalControls.xaml.cpp | 26 ++ .../Scenario1_LoadConditionalControls.xaml.h | 23 ++ .../Scenario2_ConditionalArguments.xaml | 77 ++++++ .../Scenario2_ConditionalArguments.xaml.cpp | 24 ++ .../Scenario2_ConditionalArguments.xaml.h | 21 ++ .../cpp-winui/SettingsPage.xaml | 40 +++ .../cpp-winui/SettingsPage.xaml.cpp | 51 ++++ .../cpp-winui/SettingsPage.xaml.h | 23 ++ .../cpp-winui/Styles.xaml | 132 +++++++++ .../cpp-winui/app.manifest | 15 + .../cpp-winui/packages.config | 17 ++ .../ConditionalPredicate/cpp-winui/pch.cpp | 4 + .../ConditionalPredicate/cpp-winui/pch.h | 33 +++ 38 files changed, 1538 insertions(+) create mode 100644 Samples/WinUI/ConditionalPredicate/cpp-winui/App.xaml create mode 100644 Samples/WinUI/ConditionalPredicate/cpp-winui/App.xaml.cpp create mode 100644 Samples/WinUI/ConditionalPredicate/cpp-winui/App.xaml.h create mode 100644 Samples/WinUI/ConditionalPredicate/cpp-winui/Assets/SplashScreen.png create mode 100644 Samples/WinUI/ConditionalPredicate/cpp-winui/Assets/Square150x150Logo.png create mode 100644 Samples/WinUI/ConditionalPredicate/cpp-winui/Assets/Square44x44Logo.png create mode 100644 Samples/WinUI/ConditionalPredicate/cpp-winui/Assets/Wide310x150Logo.png create mode 100644 Samples/WinUI/ConditionalPredicate/cpp-winui/Assets/logo.png create mode 100644 Samples/WinUI/ConditionalPredicate/cpp-winui/Assets/windows-sdk.ico create mode 100644 Samples/WinUI/ConditionalPredicate/cpp-winui/ConditionalXamlPredicate.sln create mode 100644 Samples/WinUI/ConditionalPredicate/cpp-winui/ConditionalXamlPredicate.vcxproj create mode 100644 Samples/WinUI/ConditionalPredicate/cpp-winui/ConditionalXamlPredicate.vcxproj.filters create mode 100644 Samples/WinUI/ConditionalPredicate/cpp-winui/MainPage.xaml create mode 100644 Samples/WinUI/ConditionalPredicate/cpp-winui/MainPage.xaml.cpp create mode 100644 Samples/WinUI/ConditionalPredicate/cpp-winui/MainPage.xaml.h create mode 100644 Samples/WinUI/ConditionalPredicate/cpp-winui/MainWindow.xaml create mode 100644 Samples/WinUI/ConditionalPredicate/cpp-winui/MainWindow.xaml.cpp create mode 100644 Samples/WinUI/ConditionalPredicate/cpp-winui/MainWindow.xaml.h create mode 100644 Samples/WinUI/ConditionalPredicate/cpp-winui/MyCustomPredicate.cpp create mode 100644 Samples/WinUI/ConditionalPredicate/cpp-winui/MyCustomPredicate.h create mode 100644 Samples/WinUI/ConditionalPredicate/cpp-winui/Package.appxmanifest create mode 100644 Samples/WinUI/ConditionalPredicate/cpp-winui/Project.idl create mode 100644 Samples/WinUI/ConditionalPredicate/cpp-winui/SampleConfiguration.cpp create mode 100644 Samples/WinUI/ConditionalPredicate/cpp-winui/SampleConfiguration.h create mode 100644 Samples/WinUI/ConditionalPredicate/cpp-winui/Scenario1_LoadConditionalControls.xaml create mode 100644 Samples/WinUI/ConditionalPredicate/cpp-winui/Scenario1_LoadConditionalControls.xaml.cpp create mode 100644 Samples/WinUI/ConditionalPredicate/cpp-winui/Scenario1_LoadConditionalControls.xaml.h create mode 100644 Samples/WinUI/ConditionalPredicate/cpp-winui/Scenario2_ConditionalArguments.xaml create mode 100644 Samples/WinUI/ConditionalPredicate/cpp-winui/Scenario2_ConditionalArguments.xaml.cpp create mode 100644 Samples/WinUI/ConditionalPredicate/cpp-winui/Scenario2_ConditionalArguments.xaml.h create mode 100644 Samples/WinUI/ConditionalPredicate/cpp-winui/SettingsPage.xaml create mode 100644 Samples/WinUI/ConditionalPredicate/cpp-winui/SettingsPage.xaml.cpp create mode 100644 Samples/WinUI/ConditionalPredicate/cpp-winui/SettingsPage.xaml.h create mode 100644 Samples/WinUI/ConditionalPredicate/cpp-winui/Styles.xaml create mode 100644 Samples/WinUI/ConditionalPredicate/cpp-winui/app.manifest create mode 100644 Samples/WinUI/ConditionalPredicate/cpp-winui/packages.config create mode 100644 Samples/WinUI/ConditionalPredicate/cpp-winui/pch.cpp create mode 100644 Samples/WinUI/ConditionalPredicate/cpp-winui/pch.h diff --git a/Samples/WinUI/ConditionalPredicate/cpp-winui/App.xaml b/Samples/WinUI/ConditionalPredicate/cpp-winui/App.xaml new file mode 100644 index 000000000..4b0f0bd3f --- /dev/null +++ b/Samples/WinUI/ConditionalPredicate/cpp-winui/App.xaml @@ -0,0 +1,21 @@ +<!-- Copyright (c) Microsoft Corporation. + Licensed under the MIT License. --> +<Application + x:Class="ConditionalXamlPredicate.App" + xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" + xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" + xmlns:local="using:ConditionalXamlPredicate"> + + <Application.Resources> + <!-- Application-specific resources --> + <ResourceDictionary> + <ResourceDictionary.MergedDictionaries> + <!-- + Styles that define common aspects of the platform look and feel + Required by Visual Studio project and item templates + --> + <ResourceDictionary Source="ms-appx:///Styles.xaml"/> + </ResourceDictionary.MergedDictionaries> + </ResourceDictionary> + </Application.Resources> +</Application> diff --git a/Samples/WinUI/ConditionalPredicate/cpp-winui/App.xaml.cpp b/Samples/WinUI/ConditionalPredicate/cpp-winui/App.xaml.cpp new file mode 100644 index 000000000..9f809deba --- /dev/null +++ b/Samples/WinUI/ConditionalPredicate/cpp-winui/App.xaml.cpp @@ -0,0 +1,38 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +#include "pch.h" + +#include "App.xaml.h" +#include "MainWindow.xaml.h" + +namespace winrt +{ + using namespace Windows::Foundation; + using namespace Microsoft::UI::Xaml; +} + +namespace winrt::ConditionalXamlPredicate::implementation +{ + App::App() + { + InitializeComponent(); + +#if defined _DEBUG && !defined DISABLE_XAML_GENERATED_BREAK_ON_UNHANDLED_EXCEPTION + UnhandledException([](winrt::IInspectable const&, winrt::UnhandledExceptionEventArgs const& e) + { + if (IsDebuggerPresent()) + { + auto errorMessage = e.Message(); + __debugbreak(); + } + }); +#endif + } + + void App::OnLaunched(winrt::LaunchActivatedEventArgs const&) + { + window = winrt::make<MainWindow>(); + window.Activate(); + } +} diff --git a/Samples/WinUI/ConditionalPredicate/cpp-winui/App.xaml.h b/Samples/WinUI/ConditionalPredicate/cpp-winui/App.xaml.h new file mode 100644 index 000000000..eb9add034 --- /dev/null +++ b/Samples/WinUI/ConditionalPredicate/cpp-winui/App.xaml.h @@ -0,0 +1,19 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +#pragma once +#include "App.xaml.g.h" +#include "pch.h" + +namespace winrt::ConditionalXamlPredicate::implementation +{ + struct App : AppT<App> + { + App(); + + void OnLaunched(Microsoft::UI::Xaml::LaunchActivatedEventArgs const&); + + private: + Microsoft::UI::Xaml::Window window{ nullptr }; + }; +} diff --git a/Samples/WinUI/ConditionalPredicate/cpp-winui/Assets/SplashScreen.png b/Samples/WinUI/ConditionalPredicate/cpp-winui/Assets/SplashScreen.png new file mode 100644 index 0000000000000000000000000000000000000000..18482131803409efae8c534cb796c1760d49091a GIT binary patch literal 78102 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 b`TL2Jk%i~9tzesT_e!s1l%-3-#sU8We6uZs literal 0 HcmV?d00001 diff --git a/Samples/WinUI/ConditionalPredicate/cpp-winui/Assets/Square150x150Logo.png b/Samples/WinUI/ConditionalPredicate/cpp-winui/Assets/Square150x150Logo.png new file mode 100644 index 0000000000000000000000000000000000000000..a50c703794a15dc3edab79525d08a5d07ce3ce60 GIT binary patch literal 10887 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�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 literal 0 HcmV?d00001 diff --git a/Samples/WinUI/ConditionalPredicate/cpp-winui/Assets/Square44x44Logo.png b/Samples/WinUI/ConditionalPredicate/cpp-winui/Assets/Square44x44Logo.png new file mode 100644 index 0000000000000000000000000000000000000000..844b60c201cf8c1eb46866ac5bee1def5e5e6a24 GIT binary patch literal 2793 zcmV<F3KsQ=P)<h;3K|Lk000e1NJLTq001li001lq1^@s69)wx}00001b5ch_0Itp) z=>Px#1ZP1_K>z@;j|==^1poj532;bRa{vGi!T<mc!T}X1N`L?W3VumMK~#9!%#ei< z12GT-PZx$7g8eu6q@06}9*2Kt)(o<7JD)2U-2Oqxtj}MAd{%;-fly&GXrfLcSVq5$ zb_t6%xO}fn^90Z^)n@Coo&oOXiv*Csljshp;~GA@$E}+>L_Y8OlLH}`sc_081ZbEJ z7BWvKS=kSli;(G==x{ny_sB;Dr2|;%0W$+1gQbrJ-RxGjJ+9Mgn*op3%mK)9waw$d zB**q?dm1~_cYJNz_-w6h8{d9~%fedMwmCN29G~V<4wLM;Z%x<scBNW1|EecW-X{<L zZz7AN!vujA7opod&?F)4&2#n*m29TOg~0r5Gt2VDGFATn>VwCsaM1$+*8aAY%dXu_ zS8X@8CL8vsa^ZYzk|4_sY}p~p#4HM}b_>@Ao&0H&liSuuamWT+f|t<bt|d@yqpI0~ z-KJbv|H^Vjq!qoWa!EY?XWwzzd7!zP`>wu(+Ux|Lf<$jinL=rp7Ndtt?P;oXjo!X8 z8P(uI!0B`l40tIN%V@few9Miyr!|cx3EHZv@wIkgt8F22GRxJLwcKeR<Cb6*msRAN zHF;WVB@|_8iztdhEaJuIv9rG2&z0Ri8f$~Xq5uKEm$sH#3dItdR%RtoJU;)Q#jRG_ zOL;6a2_{`Z-s!rBL~uP<dY;8<Z^q(iLn$00m6kc!52Z!M@Om7qYmadMO$}VT-pQ3~ z?QCvQXj^*~8a5mbE3GY6^!1-0mCj-q2AC9oW5Ie3Qd^};tf_D1>RTQm-PnyM8e|qL zy)!ER(Dti@Im+=tAMbryX84qw!Ev3LRF3oG5b%1aibt86Nuui-HBl=zyNw^+S4)jI zi)0DlZ@rJKrM0r{;;F~}hIilJNiJVpRb^3vfxw?-6dR|Tw^FrkBM)t;qA_6Q)0277 zT<myr7eD)FIMfg7v`l^2L!zRvBFi**ebjrrtc?U&=XD`D46fSj<%bW}6ARl>EG~R) z58`RK9*;kQSDK_eeTcU{=`&GgF)Sb*#pDF)cn|$&r}^wemN$kn=(#M<{>LHy?FE@k z)<Dw)r6Q&%+*Vyjn=im@zJTJiQwsaAba$az-Td?Gr<q9`=%oURyAelh3kEX6^`0iK zd+<+b@90>Plo*&FS3(sFV;C4}l9HO@*s)^_efB1kZ#+e6=m_&s(sfb=jad&AvPBF< z!W9XyY12kRu{gs+BRH%@++GKr%{~-gH`dTaLfM&_8L}A_m)A#odpjR}@FB%w(KLR= z+O$8<DGX?88g=w2*@1oJP7R_Ja+pCamkIh^oK9x(cs+Et)}zRh7(6>WjYUzp;gT?s zuorvuQn1C*b)AzZPVn^8Pm|B(Xj`*};o(6>N5_^M5(36Ng;#`9S)-*PMr%VonXHOd z%rTWnVCZGK+w5Gn(TA+qu}3b&;)+o!7Kub6?Ap1Lr~l{aiYJCD#|n5nE~ckvga?+} zIAm4<e;~qrH(kxysaZ~(oj}(N6h+2vvr-jO1W}SC8O7$qq9{0>PV9C&-~Img2!}(w z_uhM)J9~!jeB&-|ylyL2o7J3Hn{tVjLntwl$S^rILAk79cRIM@`dhf=nkKp$C1gp$ z7Fv(RRXx{8#7o5Eaen^~{}7kc$;8AYrDBF(`u+{va8)NZtFolB(rQB@oypKUFpPnY z!)jy8)-7Cm`4$}0Z()&C9R6y&Ykq*FI9Z5jG>WRK?AWmrt(4=M%bL0AQa}B}2~M2J zfUziHTDgTKSr$oDES5;6^H{AG3Yj$h+x~}LM-sg7g_CUH>qu4~CJ^^FH8qL2-L|`z zZQFL^c3JuD?=}z(*-b6G>ZEIFsHLN+o_IJ!v8<i%Y+<5)7m0IYe0a>@{%`#<>o#3# zM)-wg4<9~EQ*$$IZEIM!uA9VUmZn&arn(UAH7Sk`=1FEX48y#<tw`aSWSWzeBuh-s z;`g`+c-?s2F1-E#u6R2?{Ka2q<K``b<jg_SG$8<mLV-*=!|3QJlarHF*Hj}ZF4UQ0 z)Q2-P#5Hd0E;2Q3U{z#Ns)42(2&_Ja5$;T9bEGO#-`Kz{cizLzciu}~UEMroh5Ln7 zr>Cbmu>U}1J%z*J5T4n&V+Y5N9mis|vSa5FF7KSiZBubbDp#~=tgVt!^A;vDGKG@9 zDhmtvJvP?2x`+m>xSTHTxcgpiz4LB7Uats)ih>l1Mat!}*d8Ar=b5LU=Edh<;EOM| zv18jdCa0#k=DKS+cP>FB9AW=~<7{os5_9K~3q`D@5)o^G&VWXHP@$yTnaCOxHGTOC zd);>GtK9tL?jYB7SCp<dxMXdJt=Bz(Kib3`^7%Z;WRi3$&D(Fk&A<K2zp#7PE)fE= zv$JA7kw|dst+$cQX4$iQH^U=iq_PTEv}#yOMaY$r@@0H_kw!<JpYut?-EIy~uAoYI zTnd{zy|mZc3Ahn#%oPYQbYgbFOu{MJZ%@y0o~>B6x3`yEWq&?wHk+WJ1O0s*IdVj_ z^^f<fJn@zTH7z0KG=$_eta*bvxxm%IJnQ1F<tZ#nlIUa|4Gx?Ro9JSO#mQq&5AxBc zyHT?$bFf$}OixXbNF<n;m=JNiusk)lG_$8-_0K>1oN}pzA=<sp)1M^yt2ce5a!&Ld z6mmBD(_x+(j`7rxo8j5Q(jnn?+4$<6ZT#xP)ilSzDCNoJO8obSX+Argq>#_k(bY*! zO^t}*oT}1Ov1;$}9*!P8x{%z6?N}@>;#pXJ{y76i6D3^k042%8u5*6=t4HFU{tUg7 zIkJVaxrMD3nXu1FO~gh=lb7aN2QH@tWQB7{ga7(C&l|gv0LY4hXuapl*1+JPAUk{a z?FBHUj|UGPBsn{a8A_VY6CWk{l~+{$=A#*Qji$x1ML)#ZtqOHf2lrnS<=4N~z~(L= z<L64eyF1BKuTAsLo>@`aLZJ|M-F27Xx0QCyi4!N7nV#W`&p&5$WE69Nq3ervGck+K z7t5wB&h*PqJZPh<-hphjVzViv^9GZ%1x_V$WYrRefvC6l+<Py-^eey2(BPo3v_-M- z(n~M#{=4rY+<oC;9>Z>@opUpJhEC@hIH59jCd*Vs;o|=la1pPqt*zA6*7EpckBM>? z4oCR+fBjd|>9nZ@rA0njN#@6vM=vLnIVMwO@<mO!2lH+xl<e#86Unt>`wk2YN~O|@ zzpa{2kyb$9b=_EQkEU2Ch^{s=JS>tf7z(jmNUR((tB2@Xx*_62D1G+y8Je4$OqrTt zvTv9sojDBikXRW3N~Tic`$Q}n6-hXL;sjS-brq4y{z90}f)@!17M(S(UTYc}8*#au zoIZ705FLNOPjyu_LxV#YhK?B)Pb_n#4U@9AQV7@kd_JsJs~|R&un?0?kH;hS1rNT! zkXjlV^Ob>ZbN|pP+ww~C!K5NB7se`bFFXH_kX%t#0mQLI1e1Lh_vEtvBpLI?<e2`Y zL1iRKGfzm<{rSgq^K*+2dR{cKUit;*ju{nbfL#Xi^B!cFh`4FNfVzS4rD$Kuyn9*1 vEBg6?%Rte9yx5+50rQubv#cf|49oul1QFNDzy?aC00000NkvXXu0mjfbJ}2r literal 0 HcmV?d00001 diff --git a/Samples/WinUI/ConditionalPredicate/cpp-winui/Assets/Wide310x150Logo.png b/Samples/WinUI/ConditionalPredicate/cpp-winui/Assets/Wide310x150Logo.png new file mode 100644 index 0000000000000000000000000000000000000000..b5d5f2c429602ab269e2d581cfb7937e281822e2 GIT binary patch literal 11204 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 bR~Z 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 WwDLL`=mUcOt0oOr5U&t32>3tVaPEr$ literal 0 HcmV?d00001 diff --git a/Samples/WinUI/ConditionalPredicate/cpp-winui/Assets/logo.png b/Samples/WinUI/ConditionalPredicate/cpp-winui/Assets/logo.png new file mode 100644 index 0000000000000000000000000000000000000000..fd2293e7bd8621a23122c5d65ddcba9ed2dd8f45 GIT binary patch literal 3138 zcmV-I488M-P)<h;3K|Lk000e1NJLTq001%o001%w1^@s69zTe&00001b5ch_0Itp) z=>Px#1ZP1_K>z@;j|==^1poj532;bRa{vGi!vFvd!vV){sAK>D3)e|RK~#9!)RP4Y z15pe_Behdh?|-|xeSrytsTbXWx4VDifv=mz@**PMU}>WW#NXhRJlU0vl;hU8<KMVp zjUE0?8Y9^5pd@Bt>w}a?%tfi0zxC}<boMvCSJ+J;qe3@0apF4&dvFVAV=M)^X(s#( zO}^6zexYKN#Nnibfv^XjFre~Y%6u0~@g!@U($<Hhk~kVJ47M^TX`(V`4$yUN`5*rr zT>FMEcH5|aO|7x@G`4NeRAW8ccJ*x4b{oD14cg?|=bq`>gJyN*tYjwr<9l`1-uK}9 z^KWn4gdW~xR&nLqP!)y$uMklS1Ndqj_}}3`uTxQzand(xbhd>iWebwg_<6sKacl(L z$ea{Kq481=^*>OVxwxJ=#q-FRRlIY|Oa_wixS=<TW5&T)L@J$Depl;Y;j%)^lFnu2 zpJ!>oGP0_IHZ_aiW8;4c(qx=vaorSsnn|VFsxaHBQ14Mlr$QWkYZZ?-bYr#_p(zfE z6>!I5?7K6-%dZYj-n0zh^?C>df{6bbm>y#s%Qji&E0WH~Rh@Y&-irU{e??Ku)Eo@q zR$R2$OssPs<9n7D__%2cADY`QOmDIh*Ut|qCY41CW}sy<hUZBbYfr)9`t?-1jbe11 zEiGjGy3rL0t-pt=Ma!6LS&ud65@cHgvb7dlW)Its=5acZVge8kSY4h&GM%Na%*p$g z<TJHcA*1AQdN>3?ZjP4~OJ?!P>wAgE69^bc-w2A|>-}|DQCKADnBHth8a_pruZ%mF zexGA<B`wZ}k<&ex3%(1(x1wi)#Nu{#9L_Qx{9Xt1rWf+jcUSP?r5+YHT4*ZGQd=m| zF#j^Ntd84drKzEu%};M5ozcdYx<NFP&JVw`Ec1~|zk)h#9(_3#lzGjB<4Fz<MEUcS zA5kQ~Oekbw{qqjC?o){+o%9Z*2!`W~Mni2Ss>Mpz$sR0bmC}5btfcaV50z5ki=m}c zm^}65&iE>4LRq{%Kfhi5J=Sk}ZPFoKXhhd_`cwx4Q<gKo!pCQtJmlMCUha;fOSzof z_6FZtXXo`jI(<VrQbeMv&`n<;iXzLDx!jam9h7)nG@t#{+pQ$68Y}0y`P${><mXsG z*HK+H6tw&b+3d#UcB95S(MI<1?CTwdIb}RZ=jV~o;VlpxU`KC+mwFOx?1&?48P?ys zlXcfAL}MENLRyh1QdHhsR7Rc0$6zdm4w&+M47;tE=FTFRQMu}&ZcYcYWReNAbQ<^6 z&mhSv*=$yPaM!ZzBde*YtwkRvVTxblIfO>UKvqMJ2g%4Lb{{xG=j%@}^!Q&19N)wF zNNO7Kw9cSSLyBvtszPrn!OZCmG)|u>%<JHxBNXMTC}uO$D(z$?FRtp3kjZ3_Wtn(9 zj;@2*YNx(_8k;w666B2h0|S!MScT%q{#WU~;}>+_y^6t?9wZSs%~;TNos;1RHj9bY zaFE_en3m~N$;QLzl7z)<rqJu8^<)^oTS1Z)ta%Ni2<W`@;)`tFw3%o$N@G(KD^@H= zA4mGeS~;hY{|Z)%N>-P+C_k6xnle)9G~J!;bhfo3=^3tgtCz*Iy-2cz$u|qLr<Qa& zjizaomzVRcZ+w&8yLM6EP){luXV=c%V`^o*gvew|_uhdJGaJfz`{Ijvddohd@uYYV z39wkq^bPBRgsx>#%q}tRa5w}Jm&?UhzxFk@Z`;O)KlmYTyX{VX@cnP#cDu$gt+9_M zMWm*>nk(M@c3#|ZfT7_LvRNHjl0_0UsVXyTOaOw6YAXN`=H>BtkR*vqF1>`g7ta+D zZFqPXn^ofJ4OdcIU1GTEVO;%A0?A~O7xuJ~j0XY8>N*~uk4r!MWj^%QLdx>9;(;xB zEtuRjV^-O#)~vzlbONw()3bP;GFPs<ocXgWCrm<`td9gkA&wqzMOI`I$u!la7tykG zIgJgK#E#yCqAFNDMY!s|f+U+53vRbt5ZbnND}8-~<oHZ1zPOx~b1dvSI6(hU3<+aM zll2ivK6h#$7!#6r+O71T?Bc*vf8mW|8V|naAm;ldl4{2QA{>{Nmi}A1f4XKPJ#QYv z>2kB`tL1pzW+P2ZK5ETsoXWJyQVMhZ!od^CBvy-snNzDsM8gc7I>sF@#rWLUen8`_ zc^DxUi*fMaL8_~(sjRA^uC9*8=4Q5RJIK=6PW*l!6*<GazCTGSr7;@P_^s~5p{go1 zWfx($T8YII%x$bC981t22=J{R{fhef`mu75&>q0h&=C9g?Z<33<8(QNc8ZFMc<{cv z`21VC@cUe36MYPI_jB3mFeBlNh<L_5`{W^_(fgLS;4G@*YhV95c87zp5C{Z>Pnb+5 z@yTQ|Y}&YyTW`LF{{DXca^>GdmUm|Nv-(RO(9>k1BgBR?3=WxC`$&d89Z?|=0BH=< zniSkFC*S|^Px#O!mtr!T|0RBqq|v4%GJAJ-H@Dq#E3K_37#bX6#>|;4TfUq}AAUq6 z$6zqX{sYIkWN{otk0YlOSV-Yf<E*UKIUR8`6oo`8^KUXL|0OQUwb3%oPBfv>bt=ic zMayWMH5VjlbW{@|S&?Ot^;5|tZ@m5nSN`p9gwM|X3qHS}2OoY&6ptk(r3?-XGH@nE zXSYgiVFD?cfkXx+rQwzn{BmiO-X;gP?)LIxdz45b{U4c@u<e3eCxw0!Kf26=nG~s5 zjI5@SKmXh0*I&YDghC-k0s$l>cJA20{rBBR>xmPLh1>7ElM`p>+S}XNxPCo}M1qCQ zF8=!I6qZaJ5*j2m@hc^==t-TCu#2q&KGtrFBQtRbyYxC0S{mKhtulHxi)yi;_)B>7 z*%M;^97H)Hw9wVran_V>F(hHP+l8}7qY)l^<PkvvV9UV>e_U@P8di`JqS6+>By@-= zIMXSbtWlZ^?Ee`NRZ);-iRNl6ifR(MM77%a)7{<N_t2A^>N~~xnS1!m8P1&j3=9k! z=7A|wr_k2g%C%QtBb*<^yb#R8uLk(VMmHmIC)tFK9+!y5ZR`mZ@cR=5T-oa2#BgHb z&OWU+pEciT=90x$JT_f4OW90@2Vaiz+@7E)SJIg@3l}aF5ey)iNO1Vb5#H?VV%N@{ zV6c=^QBlcLPd-IB93Hbk>>5mAbNF%F?YtTF@k+mk+YV%SwIf9PNP<`@gFMmDDoZ*( zmxR!Sq6lql-ld(D*a#pX!lyLK+1uLNktK<}d-njwmFteP{xdi*fP}G0U;n}xzW8vG z&p#UC&##>3cz<McV`c2@`93SNYHZ~BRO)IASlUu3oH`wg5DCY)>#5VMe`WArej$?M zZFk(x^cgcm*zM`<rK7!rj*j-TQR+%@?gaXAL#>T>o{Ry`gwpJ8OHi0=XI2%A3`aQF z7UTBKLwx>s9X$T>fFSX&!td9sRtXa6REqYFPNAJtI>kMA-7QFrhN0xg8Iz1_En|(; z7TcIpYh_n^n!$iZB$hHP4?gh053*{_YGLEQUH2P4_KA;^Oe9&mW)1CaZTxRQ#sDKx znfqTJp|v|A)~^gm2pl+YK!n*}{o<EAv3WCFw`>u;xDg4XEn%acT_68EV<M*mQ6>nH zxs$0BufFmM0587qA|9_t1c`}m0*>F-8k~2bx7)PLxytm|(W9bw&&kdGU)fgR0ud38 zojq3|3PQa-Jycay8aG4ZZ?sSRybDDn5{WP}Jc8fnI~VoN46}U23Iw?cYzs)n^W&d) zp@`_fu3bC%<DdUTSy>qXk3RAU{+t{>`?=2|N%HuMZsX1y%w6by<lw<W4D=5WPb5Tb z6$k{x;#(vV6~|%&$JklN-4pqHwPt|>AP7KFTkn5U7q-$3-(1N?ch}3ohMD6V;y;BZ zaR`%#;!74~CO{rQss{NyO5QYV&nr?p^QB_4QRe&xH&OtOB!BT2nkVKw0Tm1zR_s{o zt%y#m19x(xl~M2RApKOuTz8E;b-W^zJ3N5Q10?DQ<gR6iEdiP7{G8!DszxP2nn${U c6mq4~p_OiV(WeU%n*aa+07*qoM6N<$f-c(+fB*mh literal 0 HcmV?d00001 diff --git a/Samples/WinUI/ConditionalPredicate/cpp-winui/Assets/windows-sdk.ico b/Samples/WinUI/ConditionalPredicate/cpp-winui/Assets/windows-sdk.ico new file mode 100644 index 0000000000000000000000000000000000000000..3ad20c7c20d851f63914db0972d0ceb608e3aebd GIT binary patch literal 2150 zcmeH|Jqp4=5QQfQY9SUDRsj_(>^*>ug_TH3Z{R8P6t=O}$}`w|1!HBKN=W1SX3Z|a zY|O62&V(;-b~4P{pFoH_+<u2}^=Z*0>LMBe9}IzqJYP|R=+u586L<(A{`_bU&Ra@= zsEDNOtSa)+^Zol(c6M@49rtsE^CZBk&!iwW);jvt(EA2h%lwSB7Jj^*EbNmVe~NRp z7Jk`v@SN|!c73^8N55sdHrDJsOtG=n(a+S^DQDpqTCBy^GqmtCeGlA!59&bwyEsnS zLAgeawSMV0P5aHEW7UIWFiYPBQ0=2)Ra>O0&Y<jh0Q?QA{p5ei5d_>1nxnucMqUz; Z7r%3*fy_O`MXDNeo#;(s(E^)w`~)@M5;Fh* literal 0 HcmV?d00001 diff --git a/Samples/WinUI/ConditionalPredicate/cpp-winui/ConditionalXamlPredicate.sln b/Samples/WinUI/ConditionalPredicate/cpp-winui/ConditionalXamlPredicate.sln new file mode 100644 index 000000000..d29f2b3ba --- /dev/null +++ b/Samples/WinUI/ConditionalPredicate/cpp-winui/ConditionalXamlPredicate.sln @@ -0,0 +1,43 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 17 +VisualStudioVersion = 17.14.36811.4 d17.14 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "ConditionalXamlPredicate", "ConditionalXamlPredicate.vcxproj", "{E5E59AF9-6F16-4D82-9C7B-AF97DB681432}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|arm64 = Debug|arm64 + Debug|x64 = Debug|x64 + Debug|x86 = Debug|x86 + Release|arm64 = Release|arm64 + Release|x64 = Release|x64 + Release|x86 = Release|x86 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {E5E59AF9-6F16-4D82-9C7B-AF97DB681432}.Debug|arm64.ActiveCfg = Debug|arm64 + {E5E59AF9-6F16-4D82-9C7B-AF97DB681432}.Debug|arm64.Build.0 = Debug|arm64 + {E5E59AF9-6F16-4D82-9C7B-AF97DB681432}.Debug|arm64.Deploy.0 = Debug|arm64 + {E5E59AF9-6F16-4D82-9C7B-AF97DB681432}.Debug|x64.ActiveCfg = Debug|x64 + {E5E59AF9-6F16-4D82-9C7B-AF97DB681432}.Debug|x64.Build.0 = Debug|x64 + {E5E59AF9-6F16-4D82-9C7B-AF97DB681432}.Debug|x64.Deploy.0 = Debug|x64 + {E5E59AF9-6F16-4D82-9C7B-AF97DB681432}.Debug|x86.ActiveCfg = Debug|Win32 + {E5E59AF9-6F16-4D82-9C7B-AF97DB681432}.Debug|x86.Build.0 = Debug|Win32 + {E5E59AF9-6F16-4D82-9C7B-AF97DB681432}.Debug|x86.Deploy.0 = Debug|Win32 + {E5E59AF9-6F16-4D82-9C7B-AF97DB681432}.Release|arm64.ActiveCfg = Release|arm64 + {E5E59AF9-6F16-4D82-9C7B-AF97DB681432}.Release|arm64.Build.0 = Release|arm64 + {E5E59AF9-6F16-4D82-9C7B-AF97DB681432}.Release|arm64.Deploy.0 = Release|arm64 + {E5E59AF9-6F16-4D82-9C7B-AF97DB681432}.Release|x64.ActiveCfg = Release|x64 + {E5E59AF9-6F16-4D82-9C7B-AF97DB681432}.Release|x64.Build.0 = Release|x64 + {E5E59AF9-6F16-4D82-9C7B-AF97DB681432}.Release|x64.Deploy.0 = Release|x64 + {E5E59AF9-6F16-4D82-9C7B-AF97DB681432}.Release|x86.ActiveCfg = Release|Win32 + {E5E59AF9-6F16-4D82-9C7B-AF97DB681432}.Release|x86.Build.0 = Release|Win32 + {E5E59AF9-6F16-4D82-9C7B-AF97DB681432}.Release|x86.Deploy.0 = Release|Win32 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {A3F7F7C0-FD0C-4383-9341-D8E5A148B18E} + EndGlobalSection +EndGlobal diff --git a/Samples/WinUI/ConditionalPredicate/cpp-winui/ConditionalXamlPredicate.vcxproj b/Samples/WinUI/ConditionalPredicate/cpp-winui/ConditionalXamlPredicate.vcxproj new file mode 100644 index 000000000..fdf0b029a --- /dev/null +++ b/Samples/WinUI/ConditionalPredicate/cpp-winui/ConditionalXamlPredicate.vcxproj @@ -0,0 +1,260 @@ +<?xml version="1.0" encoding="utf-8"?> +<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> + <Import Project="packages\Microsoft.WindowsAppSDK.2.0.0-experimental4\build\native\Microsoft.WindowsAppSDK.props" Condition="Exists('packages\Microsoft.WindowsAppSDK.2.0.0-experimental4\build\native\Microsoft.WindowsAppSDK.props')" /> + <Import Project="packages\Microsoft.WindowsAppSDK.WinUI.2.0.4-experimental\build\native\Microsoft.WindowsAppSDK.WinUI.props" Condition="Exists('packages\Microsoft.WindowsAppSDK.WinUI.2.0.4-experimental\build\native\Microsoft.WindowsAppSDK.WinUI.props')" /> + <Import Project="packages\Microsoft.WindowsAppSDK.Widgets.2.0.3-experimental\build\native\Microsoft.WindowsAppSDK.Widgets.props" Condition="Exists('packages\Microsoft.WindowsAppSDK.Widgets.2.0.3-experimental\build\native\Microsoft.WindowsAppSDK.Widgets.props')" /> + <Import Project="packages\Microsoft.WindowsAppSDK.Runtime.2.0.0-experimental4\build\native\Microsoft.WindowsAppSDK.Runtime.props" Condition="Exists('packages\Microsoft.WindowsAppSDK.Runtime.2.0.0-experimental4\build\native\Microsoft.WindowsAppSDK.Runtime.props')" /> + <Import Project="packages\Microsoft.WindowsAppSDK.ML.2.0.169-experimental\build\native\Microsoft.WindowsAppSDK.ML.props" Condition="Exists('packages\Microsoft.WindowsAppSDK.ML.2.0.169-experimental\build\native\Microsoft.WindowsAppSDK.ML.props')" /> + <Import Project="packages\Microsoft.WindowsAppSDK.AI.2.0.130-experimental\build\native\Microsoft.WindowsAppSDK.AI.props" Condition="Exists('packages\Microsoft.WindowsAppSDK.AI.2.0.130-experimental\build\native\Microsoft.WindowsAppSDK.AI.props')" /> + <Import Project="packages\Microsoft.WindowsAppSDK.Foundation.2.0.11-experimental\build\native\Microsoft.WindowsAppSDK.Foundation.props" Condition="Exists('packages\Microsoft.WindowsAppSDK.Foundation.2.0.11-experimental\build\native\Microsoft.WindowsAppSDK.Foundation.props')" /> + <Import Project="packages\Microsoft.WindowsAppSDK.InteractiveExperiences.2.0.5-experimental\build\native\Microsoft.WindowsAppSDK.InteractiveExperiences.props" Condition="Exists('packages\Microsoft.WindowsAppSDK.InteractiveExperiences.2.0.5-experimental\build\native\Microsoft.WindowsAppSDK.InteractiveExperiences.props')" /> + <Import Project="packages\Microsoft.WindowsAppSDK.DWrite.2.0.1-experimental\build\Microsoft.WindowsAppSDK.DWrite.props" Condition="Exists('packages\Microsoft.WindowsAppSDK.DWrite.2.0.1-experimental\build\Microsoft.WindowsAppSDK.DWrite.props')" /> + <Import Project="packages\Microsoft.WindowsAppSDK.Base.2.0.1-experimental\build\native\Microsoft.WindowsAppSDK.Base.props" Condition="Exists('packages\Microsoft.WindowsAppSDK.Base.2.0.1-experimental\build\native\Microsoft.WindowsAppSDK.Base.props')" /> + <Import Project="packages\Microsoft.Windows.SDK.BuildTools.MSIX.1.7.20250829.1\build\Microsoft.Windows.SDK.BuildTools.MSIX.props" Condition="Exists('packages\Microsoft.Windows.SDK.BuildTools.MSIX.1.7.20250829.1\build\Microsoft.Windows.SDK.BuildTools.MSIX.props')" /> + <Import Project="packages\Microsoft.Windows.SDK.BuildTools.10.0.26100.4654\build\Microsoft.Windows.SDK.BuildTools.props" Condition="Exists('packages\Microsoft.Windows.SDK.BuildTools.10.0.26100.4654\build\Microsoft.Windows.SDK.BuildTools.props')" /> + <Import Project="packages\Microsoft.Windows.CppWinRT.2.0.210922.5\build\native\Microsoft.Windows.CppWinRT.props" Condition="Exists('packages\Microsoft.Windows.CppWinRT.2.0.210922.5\build\native\Microsoft.Windows.CppWinRT.props')" /> + <PropertyGroup Label="Globals"> + <CppWinRTOptimized>true</CppWinRTOptimized> + <CppWinRTRootNamespaceAutoMerge>true</CppWinRTRootNamespaceAutoMerge> + <MinimalCoreWin>true</MinimalCoreWin> + <ProjectGuid>{e5e59af9-6f16-4d82-9c7b-af97db681432}</ProjectGuid> + <ProjectName>ConditionalXamlPredicate</ProjectName> + <RootNamespace>ConditionalXamlPredicate</RootNamespace> + <!-- + $(TargetName) should be same as $(RootNamespace) so that the produced binaries (.exe/.pri/etc.) + have a name that matches the .winmd + --> + <TargetName>$(RootNamespace)</TargetName> + <DefaultLanguage>en-US</DefaultLanguage> + <MinimumVisualStudioVersion>16.0</MinimumVisualStudioVersion> + <AppContainerApplication>false</AppContainerApplication> + <AppxPackage>true</AppxPackage> + <ApplicationType>Windows Store</ApplicationType> + <ApplicationTypeRevision>10.0</ApplicationTypeRevision> + <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion> + <WindowsTargetPlatformMinVersion>10.0.19041.0</WindowsTargetPlatformMinVersion> + <UseWinUI>true</UseWinUI> + <EnablePreviewMsixTooling>true</EnablePreviewMsixTooling> + </PropertyGroup> + <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" /> + <ItemGroup Label="ProjectConfigurations"> + <ProjectConfiguration Include="Debug|Win32"> + <Configuration>Debug</Configuration> + <Platform>Win32</Platform> + </ProjectConfiguration> + <ProjectConfiguration Include="Debug|x64"> + <Configuration>Debug</Configuration> + <Platform>x64</Platform> + </ProjectConfiguration> + <ProjectConfiguration Include="Debug|arm64"> + <Configuration>Debug</Configuration> + <Platform>arm64</Platform> + </ProjectConfiguration> + <ProjectConfiguration Include="Release|Win32"> + <Configuration>Release</Configuration> + <Platform>Win32</Platform> + </ProjectConfiguration> + <ProjectConfiguration Include="Release|x64"> + <Configuration>Release</Configuration> + <Platform>x64</Platform> + </ProjectConfiguration> + <ProjectConfiguration Include="Release|arm64"> + <Configuration>Release</Configuration> + <Platform>arm64</Platform> + </ProjectConfiguration> + </ItemGroup> + <PropertyGroup Label="Configuration"> + <ConfigurationType>Application</ConfigurationType> + <PlatformToolset>v143</PlatformToolset> + <CharacterSet>Unicode</CharacterSet> + <DesktopCompatible>true</DesktopCompatible> + </PropertyGroup> + <PropertyGroup Condition="'$(Configuration)'=='Debug'" Label="Configuration"> + <UseDebugLibraries>true</UseDebugLibraries> + <LinkIncremental>true</LinkIncremental> + </PropertyGroup> + <PropertyGroup Condition="'$(Configuration)'=='Release'" Label="Configuration"> + <UseDebugLibraries>false</UseDebugLibraries> + <WholeProgramOptimization>true</WholeProgramOptimization> + <LinkIncremental>false</LinkIncremental> + </PropertyGroup> + <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" /> + <ImportGroup Label="ExtensionSettings"> + </ImportGroup> + <ImportGroup Label="PropertySheets"> + <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" /> + </ImportGroup> + <ItemDefinitionGroup> + <ClCompile> + <PrecompiledHeader>Use</PrecompiledHeader> + <PrecompiledHeaderFile>pch.h</PrecompiledHeaderFile> + <PrecompiledHeaderOutputFile>$(IntDir)pch.pch</PrecompiledHeaderOutputFile> + <WarningLevel>Level4</WarningLevel> + <AdditionalOptions>%(AdditionalOptions) /bigobj</AdditionalOptions> + </ClCompile> + </ItemDefinitionGroup> + <ItemDefinitionGroup Condition="'$(Configuration)'=='Debug'"> + <ClCompile> + <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions> + </ClCompile> + </ItemDefinitionGroup> + <ItemDefinitionGroup Condition="'$(Configuration)'=='Release'"> + <ClCompile> + <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions> + </ClCompile> + <Link> + <EnableCOMDATFolding>true</EnableCOMDATFolding> + <OptimizeReferences>true</OptimizeReferences> + </Link> + </ItemDefinitionGroup> + <ItemGroup> + <Manifest Include="app.manifest" /> + </ItemGroup> + <ItemGroup> + <ClInclude Include="MainPage.xaml.h"> + <DependentUpon>MainPage.xaml</DependentUpon> + <SubType>Code</SubType> + </ClInclude> + <ClInclude Include="MyCustomPredicate.h" /> + <ClInclude Include="pch.h" /> + <ClInclude Include="App.xaml.h"> + <DependentUpon>App.xaml</DependentUpon> + </ClInclude> + <ClInclude Include="MainWindow.xaml.h"> + <DependentUpon>MainWindow.xaml</DependentUpon> + </ClInclude> + <ClInclude Include="SampleConfiguration.h" /> + <ClInclude Include="Scenario1_LoadConditionalControls.xaml.h"> + <DependentUpon>Scenario1_LoadConditionalControls.xaml</DependentUpon> + <SubType>Code</SubType> + </ClInclude> + <ClInclude Include="Scenario2_ConditionalArguments.xaml.h"> + <DependentUpon>Scenario2_ConditionalArguments.xaml</DependentUpon> + <SubType>Code</SubType> + </ClInclude> + <ClInclude Include="SettingsPage.xaml.h"> + <DependentUpon>SettingsPage.xaml</DependentUpon> + <SubType>Code</SubType> + </ClInclude> + </ItemGroup> + <ItemGroup> + <ApplicationDefinition Include="App.xaml" /> + <Page Include="MainPage.xaml"> + <SubType>Designer</SubType> + </Page> + <Page Include="MainWindow.xaml" /> + <Page Include="Scenario1_LoadConditionalControls.xaml"> + <SubType>Designer</SubType> + </Page> + <Page Include="Scenario2_ConditionalArguments.xaml"> + <SubType>Designer</SubType> + </Page> + <Page Include="SettingsPage.xaml"> + <SubType>Designer</SubType> + </Page> + <Page Include="Styles.xaml"> + <SubType>Designer</SubType> + </Page> + </ItemGroup> + <ItemGroup> + <ClCompile Include="MainPage.xaml.cpp"> + <DependentUpon>MainPage.xaml</DependentUpon> + <SubType>Code</SubType> + </ClCompile> + <ClCompile Include="MyCustomPredicate.cpp" /> + <ClCompile Include="pch.cpp"> + <PrecompiledHeader>Create</PrecompiledHeader> + </ClCompile> + <ClCompile Include="App.xaml.cpp"> + <DependentUpon>App.xaml</DependentUpon> + </ClCompile> + <ClCompile Include="MainWindow.xaml.cpp"> + <DependentUpon>MainWindow.xaml</DependentUpon> + </ClCompile> + <ClCompile Include="$(GeneratedFilesDir)module.g.cpp" /> + <ClCompile Include="SampleConfiguration.cpp" /> + <ClCompile Include="Scenario1_LoadConditionalControls.xaml.cpp"> + <DependentUpon>Scenario1_LoadConditionalControls.xaml</DependentUpon> + <SubType>Code</SubType> + </ClCompile> + <ClCompile Include="Scenario2_ConditionalArguments.xaml.cpp"> + <DependentUpon>Scenario2_ConditionalArguments.xaml</DependentUpon> + <SubType>Code</SubType> + </ClCompile> + <ClCompile Include="SettingsPage.xaml.cpp"> + <DependentUpon>SettingsPage.xaml</DependentUpon> + <SubType>Code</SubType> + </ClCompile> + </ItemGroup> + <ItemGroup> + <Midl Include="Project.idl"> + <SubType>Code</SubType> + </Midl> + </ItemGroup> + <ItemGroup> + <Image Include="Assets\SplashScreen.png" /> + <Image Include="Assets\Square150x150Logo.png" /> + <Image Include="Assets\Square44x44Logo.png" /> + <Image Include="Assets\Wide310x150Logo.png" /> + <Image Include="Assets\logo.png" /> + <Image Include="Assets\windows-sdk.ico" /> + </ItemGroup> + <!-- Defining the "Msix" ProjectCapability here allows the Single-project MSIX Packaging + Tools extension to be activated for this project even if the Windows App SDK Nuget + package has not yet been restored --> + <ItemGroup Condition="'$(DisableMsixProjectCapabilityAddedByProject)'!='true' and '$(EnablePreviewMsixTooling)'=='true'"> + <ProjectCapability Include="Msix" /> + </ItemGroup> + <ItemGroup> + <None Include="packages.config" /> + </ItemGroup> + <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" /> + <ImportGroup Label="ExtensionTargets"> + <Import Project="packages\Microsoft.Windows.CppWinRT.2.0.210922.5\build\native\Microsoft.Windows.CppWinRT.targets" Condition="Exists('packages\Microsoft.Windows.CppWinRT.2.0.210922.5\build\native\Microsoft.Windows.CppWinRT.targets')" /> + <Import Project="packages\Microsoft.Web.WebView2.1.0.3405.78\build\native\Microsoft.Web.WebView2.targets" Condition="Exists('packages\Microsoft.Web.WebView2.1.0.3405.78\build\native\Microsoft.Web.WebView2.targets')" /> + <Import Project="packages\Microsoft.Windows.SDK.BuildTools.10.0.26100.4654\build\Microsoft.Windows.SDK.BuildTools.targets" Condition="Exists('packages\Microsoft.Windows.SDK.BuildTools.10.0.26100.4654\build\Microsoft.Windows.SDK.BuildTools.targets')" /> + <Import Project="packages\Microsoft.Windows.SDK.BuildTools.MSIX.1.7.20250829.1\build\Microsoft.Windows.SDK.BuildTools.MSIX.targets" Condition="Exists('packages\Microsoft.Windows.SDK.BuildTools.MSIX.1.7.20250829.1\build\Microsoft.Windows.SDK.BuildTools.MSIX.targets')" /> + <Import Project="packages\Microsoft.WindowsAppSDK.Base.2.0.1-experimental\build\native\Microsoft.WindowsAppSDK.Base.targets" Condition="Exists('packages\Microsoft.WindowsAppSDK.Base.2.0.1-experimental\build\native\Microsoft.WindowsAppSDK.Base.targets')" /> + <Import Project="packages\Microsoft.WindowsAppSDK.DWrite.2.0.1-experimental\build\Microsoft.WindowsAppSDK.DWrite.targets" Condition="Exists('packages\Microsoft.WindowsAppSDK.DWrite.2.0.1-experimental\build\Microsoft.WindowsAppSDK.DWrite.targets')" /> + <Import Project="packages\Microsoft.WindowsAppSDK.InteractiveExperiences.2.0.5-experimental\build\native\Microsoft.WindowsAppSDK.InteractiveExperiences.targets" Condition="Exists('packages\Microsoft.WindowsAppSDK.InteractiveExperiences.2.0.5-experimental\build\native\Microsoft.WindowsAppSDK.InteractiveExperiences.targets')" /> + <Import Project="packages\Microsoft.WindowsAppSDK.Foundation.2.0.11-experimental\build\native\Microsoft.WindowsAppSDK.Foundation.targets" Condition="Exists('packages\Microsoft.WindowsAppSDK.Foundation.2.0.11-experimental\build\native\Microsoft.WindowsAppSDK.Foundation.targets')" /> + <Import Project="packages\Microsoft.WindowsAppSDK.AI.2.0.130-experimental\build\native\Microsoft.WindowsAppSDK.AI.targets" Condition="Exists('packages\Microsoft.WindowsAppSDK.AI.2.0.130-experimental\build\native\Microsoft.WindowsAppSDK.AI.targets')" /> + <Import Project="packages\Microsoft.WindowsAppSDK.ML.2.0.169-experimental\build\native\Microsoft.WindowsAppSDK.ML.targets" Condition="Exists('packages\Microsoft.WindowsAppSDK.ML.2.0.169-experimental\build\native\Microsoft.WindowsAppSDK.ML.targets')" /> + <Import Project="packages\Microsoft.WindowsAppSDK.Runtime.2.0.0-experimental4\build\native\Microsoft.WindowsAppSDK.Runtime.targets" Condition="Exists('packages\Microsoft.WindowsAppSDK.Runtime.2.0.0-experimental4\build\native\Microsoft.WindowsAppSDK.Runtime.targets')" /> + <Import Project="packages\Microsoft.WindowsAppSDK.Widgets.2.0.3-experimental\build\native\Microsoft.WindowsAppSDK.Widgets.targets" Condition="Exists('packages\Microsoft.WindowsAppSDK.Widgets.2.0.3-experimental\build\native\Microsoft.WindowsAppSDK.Widgets.targets')" /> + <Import Project="packages\Microsoft.WindowsAppSDK.WinUI.2.0.4-experimental\build\native\Microsoft.WindowsAppSDK.WinUI.targets" Condition="Exists('packages\Microsoft.WindowsAppSDK.WinUI.2.0.4-experimental\build\native\Microsoft.WindowsAppSDK.WinUI.targets')" /> + <Import Project="packages\Microsoft.WindowsAppSDK.2.0.0-experimental4\build\native\Microsoft.WindowsAppSDK.targets" Condition="Exists('packages\Microsoft.WindowsAppSDK.2.0.0-experimental4\build\native\Microsoft.WindowsAppSDK.targets')" /> + </ImportGroup> + <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild"> + <PropertyGroup> + <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them. For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText> + </PropertyGroup> + <Error Condition="!Exists('packages\Microsoft.Windows.CppWinRT.2.0.210922.5\build\native\Microsoft.Windows.CppWinRT.props')" Text="$([System.String]::Format('$(ErrorText)', 'packages\Microsoft.Windows.CppWinRT.2.0.210922.5\build\native\Microsoft.Windows.CppWinRT.props'))" /> + <Error Condition="!Exists('packages\Microsoft.Windows.CppWinRT.2.0.210922.5\build\native\Microsoft.Windows.CppWinRT.targets')" Text="$([System.String]::Format('$(ErrorText)', 'packages\Microsoft.Windows.CppWinRT.2.0.210922.5\build\native\Microsoft.Windows.CppWinRT.targets'))" /> + <Error Condition="!Exists('packages\Microsoft.Web.WebView2.1.0.3405.78\build\native\Microsoft.Web.WebView2.targets')" Text="$([System.String]::Format('$(ErrorText)', 'packages\Microsoft.Web.WebView2.1.0.3405.78\build\native\Microsoft.Web.WebView2.targets'))" /> + <Error Condition="!Exists('packages\Microsoft.Windows.SDK.BuildTools.10.0.26100.4654\build\Microsoft.Windows.SDK.BuildTools.props')" Text="$([System.String]::Format('$(ErrorText)', 'packages\Microsoft.Windows.SDK.BuildTools.10.0.26100.4654\build\Microsoft.Windows.SDK.BuildTools.props'))" /> + <Error Condition="!Exists('packages\Microsoft.Windows.SDK.BuildTools.10.0.26100.4654\build\Microsoft.Windows.SDK.BuildTools.targets')" Text="$([System.String]::Format('$(ErrorText)', 'packages\Microsoft.Windows.SDK.BuildTools.10.0.26100.4654\build\Microsoft.Windows.SDK.BuildTools.targets'))" /> + <Error Condition="!Exists('packages\Microsoft.Windows.SDK.BuildTools.MSIX.1.7.20250829.1\build\Microsoft.Windows.SDK.BuildTools.MSIX.props')" Text="$([System.String]::Format('$(ErrorText)', 'packages\Microsoft.Windows.SDK.BuildTools.MSIX.1.7.20250829.1\build\Microsoft.Windows.SDK.BuildTools.MSIX.props'))" /> + <Error Condition="!Exists('packages\Microsoft.Windows.SDK.BuildTools.MSIX.1.7.20250829.1\build\Microsoft.Windows.SDK.BuildTools.MSIX.targets')" Text="$([System.String]::Format('$(ErrorText)', 'packages\Microsoft.Windows.SDK.BuildTools.MSIX.1.7.20250829.1\build\Microsoft.Windows.SDK.BuildTools.MSIX.targets'))" /> + <Error Condition="!Exists('packages\Microsoft.WindowsAppSDK.Base.2.0.1-experimental\build\native\Microsoft.WindowsAppSDK.Base.props')" Text="$([System.String]::Format('$(ErrorText)', 'packages\Microsoft.WindowsAppSDK.Base.2.0.1-experimental\build\native\Microsoft.WindowsAppSDK.Base.props'))" /> + <Error Condition="!Exists('packages\Microsoft.WindowsAppSDK.Base.2.0.1-experimental\build\native\Microsoft.WindowsAppSDK.Base.targets')" Text="$([System.String]::Format('$(ErrorText)', 'packages\Microsoft.WindowsAppSDK.Base.2.0.1-experimental\build\native\Microsoft.WindowsAppSDK.Base.targets'))" /> + <Error Condition="!Exists('packages\Microsoft.WindowsAppSDK.DWrite.2.0.1-experimental\build\Microsoft.WindowsAppSDK.DWrite.props')" Text="$([System.String]::Format('$(ErrorText)', 'packages\Microsoft.WindowsAppSDK.DWrite.2.0.1-experimental\build\Microsoft.WindowsAppSDK.DWrite.props'))" /> + <Error Condition="!Exists('packages\Microsoft.WindowsAppSDK.DWrite.2.0.1-experimental\build\Microsoft.WindowsAppSDK.DWrite.targets')" Text="$([System.String]::Format('$(ErrorText)', 'packages\Microsoft.WindowsAppSDK.DWrite.2.0.1-experimental\build\Microsoft.WindowsAppSDK.DWrite.targets'))" /> + <Error Condition="!Exists('packages\Microsoft.WindowsAppSDK.InteractiveExperiences.2.0.5-experimental\build\native\Microsoft.WindowsAppSDK.InteractiveExperiences.props')" Text="$([System.String]::Format('$(ErrorText)', 'packages\Microsoft.WindowsAppSDK.InteractiveExperiences.2.0.5-experimental\build\native\Microsoft.WindowsAppSDK.InteractiveExperiences.props'))" /> + <Error Condition="!Exists('packages\Microsoft.WindowsAppSDK.InteractiveExperiences.2.0.5-experimental\build\native\Microsoft.WindowsAppSDK.InteractiveExperiences.targets')" Text="$([System.String]::Format('$(ErrorText)', 'packages\Microsoft.WindowsAppSDK.InteractiveExperiences.2.0.5-experimental\build\native\Microsoft.WindowsAppSDK.InteractiveExperiences.targets'))" /> + <Error Condition="!Exists('packages\Microsoft.WindowsAppSDK.Foundation.2.0.11-experimental\build\native\Microsoft.WindowsAppSDK.Foundation.props')" Text="$([System.String]::Format('$(ErrorText)', 'packages\Microsoft.WindowsAppSDK.Foundation.2.0.11-experimental\build\native\Microsoft.WindowsAppSDK.Foundation.props'))" /> + <Error Condition="!Exists('packages\Microsoft.WindowsAppSDK.Foundation.2.0.11-experimental\build\native\Microsoft.WindowsAppSDK.Foundation.targets')" Text="$([System.String]::Format('$(ErrorText)', 'packages\Microsoft.WindowsAppSDK.Foundation.2.0.11-experimental\build\native\Microsoft.WindowsAppSDK.Foundation.targets'))" /> + <Error Condition="!Exists('packages\Microsoft.WindowsAppSDK.AI.2.0.130-experimental\build\native\Microsoft.WindowsAppSDK.AI.props')" Text="$([System.String]::Format('$(ErrorText)', 'packages\Microsoft.WindowsAppSDK.AI.2.0.130-experimental\build\native\Microsoft.WindowsAppSDK.AI.props'))" /> + <Error Condition="!Exists('packages\Microsoft.WindowsAppSDK.AI.2.0.130-experimental\build\native\Microsoft.WindowsAppSDK.AI.targets')" Text="$([System.String]::Format('$(ErrorText)', 'packages\Microsoft.WindowsAppSDK.AI.2.0.130-experimental\build\native\Microsoft.WindowsAppSDK.AI.targets'))" /> + <Error Condition="!Exists('packages\Microsoft.WindowsAppSDK.ML.2.0.169-experimental\build\native\Microsoft.WindowsAppSDK.ML.props')" Text="$([System.String]::Format('$(ErrorText)', 'packages\Microsoft.WindowsAppSDK.ML.2.0.169-experimental\build\native\Microsoft.WindowsAppSDK.ML.props'))" /> + <Error Condition="!Exists('packages\Microsoft.WindowsAppSDK.ML.2.0.169-experimental\build\native\Microsoft.WindowsAppSDK.ML.targets')" Text="$([System.String]::Format('$(ErrorText)', 'packages\Microsoft.WindowsAppSDK.ML.2.0.169-experimental\build\native\Microsoft.WindowsAppSDK.ML.targets'))" /> + <Error Condition="!Exists('packages\Microsoft.WindowsAppSDK.Runtime.2.0.0-experimental4\build\native\Microsoft.WindowsAppSDK.Runtime.props')" Text="$([System.String]::Format('$(ErrorText)', 'packages\Microsoft.WindowsAppSDK.Runtime.2.0.0-experimental4\build\native\Microsoft.WindowsAppSDK.Runtime.props'))" /> + <Error Condition="!Exists('packages\Microsoft.WindowsAppSDK.Runtime.2.0.0-experimental4\build\native\Microsoft.WindowsAppSDK.Runtime.targets')" Text="$([System.String]::Format('$(ErrorText)', 'packages\Microsoft.WindowsAppSDK.Runtime.2.0.0-experimental4\build\native\Microsoft.WindowsAppSDK.Runtime.targets'))" /> + <Error Condition="!Exists('packages\Microsoft.WindowsAppSDK.Widgets.2.0.3-experimental\build\native\Microsoft.WindowsAppSDK.Widgets.props')" Text="$([System.String]::Format('$(ErrorText)', 'packages\Microsoft.WindowsAppSDK.Widgets.2.0.3-experimental\build\native\Microsoft.WindowsAppSDK.Widgets.props'))" /> + <Error Condition="!Exists('packages\Microsoft.WindowsAppSDK.Widgets.2.0.3-experimental\build\native\Microsoft.WindowsAppSDK.Widgets.targets')" Text="$([System.String]::Format('$(ErrorText)', 'packages\Microsoft.WindowsAppSDK.Widgets.2.0.3-experimental\build\native\Microsoft.WindowsAppSDK.Widgets.targets'))" /> + <Error Condition="!Exists('packages\Microsoft.WindowsAppSDK.WinUI.2.0.4-experimental\build\native\Microsoft.WindowsAppSDK.WinUI.props')" Text="$([System.String]::Format('$(ErrorText)', 'packages\Microsoft.WindowsAppSDK.WinUI.2.0.4-experimental\build\native\Microsoft.WindowsAppSDK.WinUI.props'))" /> + <Error Condition="!Exists('packages\Microsoft.WindowsAppSDK.WinUI.2.0.4-experimental\build\native\Microsoft.WindowsAppSDK.WinUI.targets')" Text="$([System.String]::Format('$(ErrorText)', 'packages\Microsoft.WindowsAppSDK.WinUI.2.0.4-experimental\build\native\Microsoft.WindowsAppSDK.WinUI.targets'))" /> + <Error Condition="!Exists('packages\Microsoft.WindowsAppSDK.2.0.0-experimental4\build\native\Microsoft.WindowsAppSDK.props')" Text="$([System.String]::Format('$(ErrorText)', 'packages\Microsoft.WindowsAppSDK.2.0.0-experimental4\build\native\Microsoft.WindowsAppSDK.props'))" /> + <Error Condition="!Exists('packages\Microsoft.WindowsAppSDK.2.0.0-experimental4\build\native\Microsoft.WindowsAppSDK.targets')" Text="$([System.String]::Format('$(ErrorText)', 'packages\Microsoft.WindowsAppSDK.2.0.0-experimental4\build\native\Microsoft.WindowsAppSDK.targets'))" /> + </Target> +</Project> \ No newline at end of file diff --git a/Samples/WinUI/ConditionalPredicate/cpp-winui/ConditionalXamlPredicate.vcxproj.filters b/Samples/WinUI/ConditionalPredicate/cpp-winui/ConditionalXamlPredicate.vcxproj.filters new file mode 100644 index 000000000..a034c65c9 --- /dev/null +++ b/Samples/WinUI/ConditionalPredicate/cpp-winui/ConditionalXamlPredicate.vcxproj.filters @@ -0,0 +1,62 @@ +<?xml version="1.0" encoding="utf-8"?> +<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> + <ItemGroup> + <ApplicationDefinition Include="App.xaml" /> + </ItemGroup> + <ItemGroup> + <Page Include="MainWindow.xaml" /> + <Page Include="MainPage.xaml" /> + <Page Include="SettingsPage.xaml" /> + <Page Include="Scenario1_LoadConditionalControls.xaml" /> + <Page Include="Styles.xaml" /> + <Page Include="Scenario2_ConditionalArguments.xaml" /> + </ItemGroup> + <ItemGroup> + <Midl Include="Project.idl" /> + </ItemGroup> + <ItemGroup> + <ClCompile Include="pch.cpp" /> + <ClCompile Include="$(GeneratedFilesDir)module.g.cpp" /> + <ClCompile Include="SampleConfiguration.cpp" /> + <ClCompile Include="MyCustomPredicate.cpp" /> + </ItemGroup> + <ItemGroup> + <ClInclude Include="pch.h" /> + <ClInclude Include="SampleConfiguration.h" /> + <ClInclude Include="MyCustomPredicate.h" /> + </ItemGroup> + <ItemGroup> + <Image Include="Assets\Wide310x150Logo.png"> + <Filter>Assets</Filter> + </Image> + <Image Include="Assets\logo.png"> + <Filter>Assets</Filter> + </Image> + <Image Include="Assets\Square150x150Logo.png"> + <Filter>Assets</Filter> + </Image> + <Image Include="Assets\Square44x44Logo.png"> + <Filter>Assets</Filter> + </Image> + <Image Include="Assets\SplashScreen.png"> + <Filter>Assets</Filter> + </Image> + <Image Include="Assets\windows-sdk.ico"> + <Filter>Assets</Filter> + </Image> + </ItemGroup> + <ItemGroup> + <Filter Include="Assets"> + <UniqueIdentifier>{$guid1}</UniqueIdentifier> + </Filter> + </ItemGroup> + <ItemGroup> + <Manifest Include="app.manifest" /> + </ItemGroup> + <ItemGroup> + <None Include="packages.config" /> + </ItemGroup> + <ItemGroup> + <AppxManifest Include="Package.appxmanifest" /> + </ItemGroup> +</Project> \ No newline at end of file diff --git a/Samples/WinUI/ConditionalPredicate/cpp-winui/MainPage.xaml b/Samples/WinUI/ConditionalPredicate/cpp-winui/MainPage.xaml new file mode 100644 index 000000000..4f541755b --- /dev/null +++ b/Samples/WinUI/ConditionalPredicate/cpp-winui/MainPage.xaml @@ -0,0 +1,29 @@ +<!-- Copyright (c) Microsoft Corporation. + Licensed under the MIT License. --> +<Page + x:Class="ConditionalXamlPredicate.MainPage" + xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" + xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" + xmlns:local="using:ConditionalXamlPredicate" + xmlns:d="http://schemas.microsoft.com/expression/blend/2008" + xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" + mc:Ignorable="d"> + + <Grid Background="{ThemeResource ApplicationPageBackgroundThemeBrush}"> + <NavigationView x:Name="NavView" + Loaded="NavView_Loaded" + ItemInvoked="NavView_ItemInvoked" + BackRequested="NavView_BackRequested"> + <NavigationView.MenuItems> + <NavigationViewItemHeader x:Name="MainPagesHeader" Content="Scenarios"/> + </NavigationView.MenuItems> + + <Grid RowDefinitions="*,Auto"> + <ScrollViewer> + <Frame Padding="50" x:Name="ContentFrame" Navigated="ContentFrame_Navigated" /> + </ScrollViewer> + <InfoBar x:Name="infoBar" Grid.Row="1" /> + </Grid> + </NavigationView> + </Grid> +</Page> diff --git a/Samples/WinUI/ConditionalPredicate/cpp-winui/MainPage.xaml.cpp b/Samples/WinUI/ConditionalPredicate/cpp-winui/MainPage.xaml.cpp new file mode 100644 index 000000000..5039ceb0f --- /dev/null +++ b/Samples/WinUI/ConditionalPredicate/cpp-winui/MainPage.xaml.cpp @@ -0,0 +1,156 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +#include "pch.h" +#include "MainPage.xaml.h" +#if __has_include("MainPage.g.cpp") +#include "MainPage.g.cpp" +#endif + +namespace winrt +{ + using namespace Microsoft::UI::Xaml; + using namespace Microsoft::UI::Xaml::Controls; + using namespace Microsoft::UI::Xaml::Media; + using namespace Microsoft::UI::Xaml::Media::Animation; + using namespace Microsoft::UI::Xaml::Navigation; + using namespace Windows::UI::Xaml::Interop; +} + +namespace winrt::ConditionalXamlPredicate::implementation +{ + ConditionalXamlPredicate::MainPage MainPage::current{ nullptr }; + + MainPage::MainPage() + { + InitializeComponent(); + MainPage::current = *this; + } + + void MainPage::NotifyUser(hstring const& strMessage, InfoBarSeverity const& severity) + { + // If called from the UI thread, then update immediately. + // Otherwise, schedule a task on the UI thread to perform the update. + if (this->DispatcherQueue().HasThreadAccess()) + { + UpdateStatus(strMessage, severity); + } + else + { + DispatcherQueue().TryEnqueue([strongThis = get_strong(), this, strMessage, severity] + { UpdateStatus(strMessage, severity); }); + } + } + + void MainPage::UpdateStatus(hstring const& strMessage, InfoBarSeverity severity) + { + infoBar().Message(strMessage); + infoBar().IsOpen(!strMessage.empty()); + infoBar().Severity(severity); + } + + void MainPage::NavView_Loaded(IInspectable const&, RoutedEventArgs const&) + { + for (auto&& s : Scenarios()) + { + FontIcon fontIcon{}; + fontIcon.FontFamily(winrt::FontFamily(L"Segoe MDL2 Assets")); + fontIcon.Glyph(L"\uE82D"); + + NavigationViewItem navViewItem{}; + navViewItem.Content(box_value(s.Title)); + navViewItem.Tag(box_value(s.ClassName)); + navViewItem.Icon(fontIcon); + NavView().MenuItems().Append(navViewItem); + } + + // NavView doesn't load any page by default, so load home page. + NavView().SelectedItem(NavView().MenuItems().GetAt(0)); + + // If navigation occurs on SelectionChanged, this isn't needed. + // Because we use ItemInvoked to navigate, we need to call Navigate + // here to load the home page. + if (Scenarios().Size() > 0) + { + NavView_Navigate(Scenarios().GetAt(0).ClassName, nullptr); + } + } + + + void MainPage::NavView_ItemInvoked(NavigationView const&, NavigationViewItemInvokedEventArgs const& args) + { + if (args.IsSettingsInvoked() == true) + { + hstring xamltypename = winrt::xaml_typename<SettingsPage>().Name; + NavView_Navigate(xamltypename, args.RecommendedNavigationTransitionInfo()); + } + else if (args.InvokedItemContainer() != nullptr) + { + auto navItemTag = winrt::unbox_value<hstring>(args.InvokedItemContainer().Tag()); + if (navItemTag != L"") + { + NavView_Navigate(navItemTag, args.RecommendedNavigationTransitionInfo()); + } + } + } + + void MainPage::NavView_Navigate(hstring navItemTag, NavigationTransitionInfo const&) + { + TypeName pageType; + + if (navItemTag == winrt::xaml_typename<SettingsPage>().Name) + { + pageType = winrt::xaml_typename<SettingsPage>(); + } + else + { + pageType.Name = navItemTag; + pageType.Kind = TypeKind::Metadata; + } + + // Get the page type before navigation so you can prevent duplicate + // entries in the backstack. + TypeName prePageType = ContentFrame().CurrentSourcePageType(); + + // Only navigate if the selected page isn't currently loaded. + if (prePageType.Name != pageType.Name) + { + DrillInNavigationTransitionInfo drillIn; + ContentFrame().Navigate(pageType, nullptr, drillIn); + } + } + + void MainPage::NavView_BackRequested(NavigationView const&, NavigationViewBackRequestedEventArgs const&) + { + if (ContentFrame().CanGoBack()) + { + ContentFrame().GoBack(); + } + } + + void MainPage::ContentFrame_Navigated(IInspectable const&, NavigationEventArgs const& e) + { + NavView().IsBackEnabled(ContentFrame().CanGoBack()); + + if (ContentFrame().SourcePageType().Name == winrt::xaml_typename<SettingsPage>().Name) + { + // SettingsItem is not part of NavView.MenuItems, and doesn't have a Tag. + NavView().SelectedItem((NavView().SettingsItem().as<NavigationViewItem>())); + NavView().Header(winrt::box_value(L"Settings")); + } + else + { + for (auto&& item : NavView().MenuItems()) + { + auto navViewItem = item.try_as<NavigationViewItem>(); + if (navViewItem != nullptr && + winrt::unbox_value<hstring>(navViewItem.Tag()) == e.SourcePageType().Name) + { + NavView().SelectedItem(navViewItem); + NavView().Header(navViewItem.Content()); + break; + } + } + } + } +} diff --git a/Samples/WinUI/ConditionalPredicate/cpp-winui/MainPage.xaml.h b/Samples/WinUI/ConditionalPredicate/cpp-winui/MainPage.xaml.h new file mode 100644 index 000000000..fe10bd1a3 --- /dev/null +++ b/Samples/WinUI/ConditionalPredicate/cpp-winui/MainPage.xaml.h @@ -0,0 +1,33 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +#pragma once +#include "MainPage.g.h" + +namespace winrt::ConditionalXamlPredicate::implementation +{ + struct MainPage : MainPageT<MainPage> + { + MainPage(); + static ConditionalXamlPredicate::MainPage Current() { return current; } + static Windows::Foundation::Collections::IVector<ConditionalXamlPredicate::Scenario> Scenarios() { return scenariosInner; } + void NotifyUser(hstring const& strMessage, Microsoft::UI::Xaml::Controls::InfoBarSeverity const& severity); + void UpdateStatus(hstring const& strMessage, Microsoft::UI::Xaml::Controls::InfoBarSeverity severity); + void NavView_Loaded(Windows::Foundation::IInspectable const& sender, Microsoft::UI::Xaml::RoutedEventArgs const& e); + void NavView_ItemInvoked(Microsoft::UI::Xaml::Controls::NavigationView const& sender, Microsoft::UI::Xaml::Controls::NavigationViewItemInvokedEventArgs const& args); + void NavView_Navigate(hstring navItemTag, Microsoft::UI::Xaml::Media::Animation::NavigationTransitionInfo const& transitionInfo); + void NavView_BackRequested(Microsoft::UI::Xaml::Controls::NavigationView const& sender, Microsoft::UI::Xaml::Controls::NavigationViewBackRequestedEventArgs const& args); + void ContentFrame_Navigated(Windows::Foundation::IInspectable const& sender, Microsoft::UI::Xaml::Navigation::NavigationEventArgs const& e); + + private: + static Windows::Foundation::Collections::IVector<Scenario> scenariosInner; + static ConditionalXamlPredicate::MainPage current; + }; +} + +namespace winrt::ConditionalXamlPredicate::factory_implementation +{ + struct MainPage : MainPageT<MainPage, implementation::MainPage> + { + }; +} diff --git a/Samples/WinUI/ConditionalPredicate/cpp-winui/MainWindow.xaml b/Samples/WinUI/ConditionalPredicate/cpp-winui/MainWindow.xaml new file mode 100644 index 000000000..92988d0ca --- /dev/null +++ b/Samples/WinUI/ConditionalPredicate/cpp-winui/MainWindow.xaml @@ -0,0 +1,13 @@ +<!-- Copyright (c) Microsoft Corporation. + Licensed under the MIT License. --> +<Window + x:Class="ConditionalXamlPredicate.MainWindow" + xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" + xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" + xmlns:local="using:ConditionalXamlPredicate" + xmlns:d="http://schemas.microsoft.com/expression/blend/2008" + xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" + mc:Ignorable="d"> + + <local:MainPage/> +</Window> diff --git a/Samples/WinUI/ConditionalPredicate/cpp-winui/MainWindow.xaml.cpp b/Samples/WinUI/ConditionalPredicate/cpp-winui/MainWindow.xaml.cpp new file mode 100644 index 000000000..0170484b9 --- /dev/null +++ b/Samples/WinUI/ConditionalPredicate/cpp-winui/MainWindow.xaml.cpp @@ -0,0 +1,89 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +#include "pch.h" +#include "MainWindow.xaml.h" +#if __has_include("MainWindow.g.cpp") +#include "MainWindow.g.cpp" + +#include "microsoft.ui.xaml.window.h" +#include "SampleConfiguration.h" +#endif + +namespace winrt +{ + using namespace Microsoft::UI::Xaml; +} + +namespace winrt::ConditionalXamlPredicate::implementation +{ + MainWindow::MainWindow() + { + InitializeComponent(); + + Title(winrt::ConditionalXamlPredicate::SampleConfig::FeatureName); + + HWND hwnd = GetWindowHandle(); + LoadIcon(hwnd, L"windows-sdk.ico"); + SetWindowSize(hwnd, 1050, 800); + PlacementCenterWindowInMonitorWin32(hwnd); + } + + HWND MainWindow::GetWindowHandle() + { + if (_hwnd == nullptr) + { + Window window = *this; + window.as<IWindowNative>()->get_WindowHandle(&_hwnd); + } + return _hwnd; + } + + void MainWindow::LoadIcon(HWND hwnd, wchar_t const* iconPath) + { + HANDLE hSmallIcon = LoadImageW(nullptr, iconPath, IMAGE_ICON, + GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON), + LR_LOADFROMFILE | LR_SHARED); + SendMessageW(hwnd, WM_SETICON, ICON_SMALL, reinterpret_cast<LPARAM>(hSmallIcon)); + + HANDLE hBigIcon = LoadImageW(nullptr, iconPath, IMAGE_ICON, + GetSystemMetrics(SM_CXICON), GetSystemMetrics(SM_CYICON), + LR_LOADFROMFILE | LR_SHARED); + SendMessageW(hwnd, WM_SETICON, ICON_BIG, reinterpret_cast<LPARAM>(hBigIcon)); + } + + void MainWindow::SetWindowSize(HWND hwnd, int width, int height) + { + // Win32 uses pixels and WinUI 3 uses effective pixels, so you should apply the DPI scale factor + const UINT dpi = GetDpiForWindow(hwnd); + const float scalingFactor = static_cast<float>(dpi) / 96; + const int widthScaled = static_cast<int>(width * scalingFactor); + const int heightScaled = static_cast<int>(height * scalingFactor); + + SetWindowPos(hwnd, nullptr, 0, 0, widthScaled, heightScaled, SWP_NOMOVE | SWP_NOZORDER); + } + + void MainWindow::PlacementCenterWindowInMonitorWin32(HWND hwnd) + { + RECT windowMontiorRectToAdjust; + GetWindowRect(hwnd, &windowMontiorRectToAdjust); + ClipOrCenterRectToMonitorWin32(windowMontiorRectToAdjust); + SetWindowPos(hwnd, nullptr, windowMontiorRectToAdjust.left, + windowMontiorRectToAdjust.top, 0, 0, SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE); + } + + void MainWindow::ClipOrCenterRectToMonitorWin32(RECT& adjustedWindowRect) + { + MONITORINFO mi{ sizeof(mi) }; + GetMonitorInfoW(MonitorFromRect(&adjustedWindowRect, MONITOR_DEFAULTTONEAREST), &mi); + + const auto& rcWork = mi.rcWork; + const int w = adjustedWindowRect.right - adjustedWindowRect.left; + const int h = adjustedWindowRect.bottom - adjustedWindowRect.top; + + adjustedWindowRect.left = rcWork.left + (rcWork.right - rcWork.left - w) / 2; + adjustedWindowRect.top = rcWork.top + (rcWork.bottom - rcWork.top - h) / 2; + adjustedWindowRect.right = adjustedWindowRect.left + w; + adjustedWindowRect.bottom = adjustedWindowRect.top + h; + } +} diff --git a/Samples/WinUI/ConditionalPredicate/cpp-winui/MainWindow.xaml.h b/Samples/WinUI/ConditionalPredicate/cpp-winui/MainWindow.xaml.h new file mode 100644 index 000000000..8d897ab87 --- /dev/null +++ b/Samples/WinUI/ConditionalPredicate/cpp-winui/MainWindow.xaml.h @@ -0,0 +1,29 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +#pragma once +#include "MainWindow.g.h" +#include "pch.h" + +namespace winrt::ConditionalXamlPredicate::implementation +{ + struct MainWindow : MainWindowT<MainWindow> + { + MainWindow(); + + private: + HWND _hwnd{ nullptr }; + void SetWindowSize(HWND hwnd, const int width, const int height); + HWND GetWindowHandle(); + void LoadIcon(HWND hwnd, wchar_t const* iconName); + void ClipOrCenterRectToMonitorWin32(RECT& rc); + void PlacementCenterWindowInMonitorWin32(HWND hwnd); + }; +} + +namespace winrt::ConditionalXamlPredicate::factory_implementation +{ + struct MainWindow : MainWindowT<MainWindow, implementation::MainWindow> + { + }; +} diff --git a/Samples/WinUI/ConditionalPredicate/cpp-winui/MyCustomPredicate.cpp b/Samples/WinUI/ConditionalPredicate/cpp-winui/MyCustomPredicate.cpp new file mode 100644 index 000000000..1a9424efa --- /dev/null +++ b/Samples/WinUI/ConditionalPredicate/cpp-winui/MyCustomPredicate.cpp @@ -0,0 +1,30 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +#include "pch.h" +#include "MyCustomPredicate.h" +#include "MyCustomPredicate.g.cpp" + +namespace winrt::ConditionalXamlPredicate::implementation +{ + bool MyCustomPredicate::Evaluate(winrt::Windows::Foundation::Collections::IVectorView<hstring> const& arguments) + { + auto argsCount = arguments.Size(); + if (argsCount >= 2) + { + hstring firstArg = arguments.GetAt(0); + hstring secondArg = arguments.GetAt(1); + if (firstArg == L"FeatureABC") + { + // For demo purpose, return true if second argument is "true", false otherwise + return secondArg == L"true"; + } + else if (firstArg == L"FeatureXYZ") + { + // Marking FeatureXYZ as disabled + return secondArg == L"false"; + } + } + throw hresult_not_implemented(); + } +} diff --git a/Samples/WinUI/ConditionalPredicate/cpp-winui/MyCustomPredicate.h b/Samples/WinUI/ConditionalPredicate/cpp-winui/MyCustomPredicate.h new file mode 100644 index 000000000..8eb90ce85 --- /dev/null +++ b/Samples/WinUI/ConditionalPredicate/cpp-winui/MyCustomPredicate.h @@ -0,0 +1,21 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +#pragma once +#include "MyCustomPredicate.g.h" + +namespace winrt::ConditionalXamlPredicate::implementation +{ + struct MyCustomPredicate : MyCustomPredicateT<MyCustomPredicate> + { + MyCustomPredicate() = default; + + bool Evaluate(winrt::Windows::Foundation::Collections::IVectorView<hstring> const& arguments); + }; +} +namespace winrt::ConditionalXamlPredicate::factory_implementation +{ + struct MyCustomPredicate : MyCustomPredicateT<MyCustomPredicate, implementation::MyCustomPredicate> + { + }; +} \ No newline at end of file diff --git a/Samples/WinUI/ConditionalPredicate/cpp-winui/Package.appxmanifest b/Samples/WinUI/ConditionalPredicate/cpp-winui/Package.appxmanifest new file mode 100644 index 000000000..aec4b383e --- /dev/null +++ b/Samples/WinUI/ConditionalPredicate/cpp-winui/Package.appxmanifest @@ -0,0 +1,47 @@ +<?xml version="1.0" encoding="utf-8"?> + +<Package + xmlns="http://schemas.microsoft.com/appx/manifest/foundation/windows10" + xmlns:uap="http://schemas.microsoft.com/appx/manifest/uap/windows10" + xmlns:rescap="http://schemas.microsoft.com/appx/manifest/foundation/windows10/restrictedcapabilities" + IgnorableNamespaces="uap rescap"> + + <Identity + Name="055cd150-3243-4ad5-a957-dfd0af1d3b05" + Publisher="CN=Microsoft Corporation" + Version="1.0.0.0" /> + + <Properties> + <DisplayName>ConditionalXamlPredicate</DisplayName> + <PublisherDisplayName>Microsoft Corporation</PublisherDisplayName> + <Logo>Assets\logo.png</Logo> + </Properties> + + <Dependencies> + <TargetDeviceFamily Name="Windows.Universal" MinVersion="10.0.17763.0" MaxVersionTested="10.0.19041.0" /> + <TargetDeviceFamily Name="Windows.Desktop" MinVersion="10.0.17763.0" MaxVersionTested="10.0.19041.0" /> + </Dependencies> + + <Resources> + <Resource Language="x-generate"/> + </Resources> + + <Applications> + <Application Id="App" + Executable="$targetnametoken$.exe" + EntryPoint="$targetentrypoint$"> + <uap:VisualElements + DisplayName="ConditionalXamlPredicate Windows App SDK C++ WinUI Sample" + Description="ConditionalXamlPredicate Windows App SDK C++ WinUI Sample" + BackgroundColor="transparent" + Square150x150Logo="Assets\Square150x150Logo.png" Square44x44Logo="Assets\Square44x44Logo.png"> + <uap:DefaultTile Wide310x150Logo="Assets\Wide310x150Logo.png" /> + <uap:SplashScreen Image="Assets\SplashScreen.png" /> + </uap:VisualElements> + </Application> + </Applications> + + <Capabilities> + <rescap:Capability Name="runFullTrust" /> + </Capabilities> +</Package> diff --git a/Samples/WinUI/ConditionalPredicate/cpp-winui/Project.idl b/Samples/WinUI/ConditionalPredicate/cpp-winui/Project.idl new file mode 100644 index 000000000..7b5886e10 --- /dev/null +++ b/Samples/WinUI/ConditionalPredicate/cpp-winui/Project.idl @@ -0,0 +1,56 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +namespace ConditionalXamlPredicate +{ + /* The following code is scenario/feature-specific IDL. + Samples authors should modify these runtime classes as appropriate. */ + + [default_interface] + runtimeclass Scenario1_LoadConditionalControls : Microsoft.UI.Xaml.Controls.Page + { + Scenario1_LoadConditionalControls(); + } + + [default_interface] + runtimeclass Scenario2_ConditionalArguments : Microsoft.UI.Xaml.Controls.Page + { + Scenario2_ConditionalArguments(); + } + + [default_interface] + [bindable] + runtimeclass MyCustomPredicate : Microsoft.UI.Xaml.DependencyObject, Microsoft.UI.Xaml.Markup.IXamlPredicate + { + MyCustomPredicate(); + } + + /* The following code is template-specific IDL. + These runtime classes are the same across all C++/WinRT WinUI samples. */ + + runtimeclass MainPage : Microsoft.UI.Xaml.Controls.Page + { + MainPage(); + static MainPage Current(); + void NotifyUser(String strMessage, Microsoft.UI.Xaml.Controls.InfoBarSeverity severity); + } + + // To use Scenario in a winrt::Windows::Foundation::Collections::IVector<Scenario>, Scenario should be a WinRT type + struct Scenario + { + String Title; + String ClassName; + }; + + [default_interface] + runtimeclass MainWindow : Microsoft.UI.Xaml.Window + { + MainWindow(); + } + + [default_interface] + runtimeclass SettingsPage : Microsoft.UI.Xaml.Controls.Page + { + SettingsPage(); + } +} diff --git a/Samples/WinUI/ConditionalPredicate/cpp-winui/SampleConfiguration.cpp b/Samples/WinUI/ConditionalPredicate/cpp-winui/SampleConfiguration.cpp new file mode 100644 index 000000000..bbfac3b24 --- /dev/null +++ b/Samples/WinUI/ConditionalPredicate/cpp-winui/SampleConfiguration.cpp @@ -0,0 +1,25 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +#pragma once +#include "pch.h" +#include "SampleConfiguration.h" +#include "MainPage.xaml.h" + +namespace winrt +{ + using namespace Microsoft::UI::Xaml; + using namespace Windows::Foundation::Collections; +} + +namespace winrt::ConditionalXamlPredicate +{ + IVector<Scenario> implementation::MainPage::scenariosInner = single_threaded_observable_vector<Scenario>( + { + Scenario{ L"Load Conditional Controls", hstring(name_of<ConditionalXamlPredicate::Scenario1_LoadConditionalControls>())}, + Scenario{ L"Conditional Arguments", hstring(name_of<ConditionalXamlPredicate::Scenario2_ConditionalArguments>())}, + }); + + hstring SampleConfig::FeatureName{ L"ConditionalXamlPredicate" }; + ElementTheme SampleConfig::CurrentTheme{ ElementTheme::Default }; +} diff --git a/Samples/WinUI/ConditionalPredicate/cpp-winui/SampleConfiguration.h b/Samples/WinUI/ConditionalPredicate/cpp-winui/SampleConfiguration.h new file mode 100644 index 000000000..c770b0715 --- /dev/null +++ b/Samples/WinUI/ConditionalPredicate/cpp-winui/SampleConfiguration.h @@ -0,0 +1,15 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +#pragma once +#include "pch.h" + +namespace winrt::ConditionalXamlPredicate +{ + struct SampleConfig + { + public: + static hstring FeatureName; + static Microsoft::UI::Xaml::ElementTheme CurrentTheme; + }; +} diff --git a/Samples/WinUI/ConditionalPredicate/cpp-winui/Scenario1_LoadConditionalControls.xaml b/Samples/WinUI/ConditionalPredicate/cpp-winui/Scenario1_LoadConditionalControls.xaml new file mode 100644 index 000000000..6370aa890 --- /dev/null +++ b/Samples/WinUI/ConditionalPredicate/cpp-winui/Scenario1_LoadConditionalControls.xaml @@ -0,0 +1,66 @@ +<!-- Copyright (c) Microsoft Corporation. + Licensed under the MIT License. --> +<Page + x:Class="ConditionalXamlPredicate.Scenario1_LoadConditionalControls" + xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" + xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" + xmlns:local="using:ConditionalXamlPredicate" + xmlns:d="http://schemas.microsoft.com/expression/blend/2008" + xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" + xmlns:featureABCEnabled="http://schemas.microsoft.com/winfx/2006/xaml/presentation?local:MyCustomPredicate(FeatureABC,true)" + xmlns:featureABCDisabled="http://schemas.microsoft.com/winfx/2006/xaml/presentation?local:MyCustomPredicate(FeatureABC,false)" + xmlns:featureXYZEnabled="http://schemas.microsoft.com/winfx/2006/xaml/presentation?local:MyCustomPredicate(FeatureXYZ,true)" + xmlns:featureXYZDisabled="http://schemas.microsoft.com/winfx/2006/xaml/presentation?local:MyCustomPredicate(FeatureXYZ,false)" + mc:Ignorable="d"> + + <Grid RowDefinitions="*,Auto"> + <ScrollViewer Background="{ThemeResource ApplicationPageBackgroundThemeBrush}"> + <StackPanel Spacing="10" Margin="10,10,10,10"> + <TextBlock Text="Description:" Style="{StaticResource SampleHeaderTextStyle}"/> + <TextBlock Style="{StaticResource ScenarioDescriptionTextStyle}" TextWrapping="Wrap"> + This scenario demonstrates conditional XAML loading using custom predicates. + Controls below are conditionally loaded based on the FeatureABC flag. + </TextBlock> + + <!-- Controls visible when FeatureABC is ENABLED --> + <featureABCEnabled:TextBlock Text="FeatureABC is ENABLED" + Foreground="Green" FontWeight="Bold"/> + <featureABCEnabled:Button Content="ABC Feature Action" /> + + <!-- Controls visible when FeatureABC is DISABLED --> + <featureABCDisabled:TextBlock Text="FeatureABC is DISABLED" + Foreground="Red" FontWeight="Bold"/> + <featureABCDisabled:Button Content="ABC Fallback Action" /> + + <!-- Controls visible when FeatureXYZ is ENABLED --> + <featureXYZEnabled:TextBlock Text="FeatureXYZ is ENABLED" + Foreground="Blue" FontWeight="Bold"/> + <featureXYZEnabled:Button Content="XYZ Feature Action" /> + + <!-- Controls visible when FeatureXYZ is DISABLED --> + <featureXYZDisabled:TextBlock Text="FeatureXYZ is DISABLED" + Foreground="Gray" FontWeight="Bold"/> + <featureXYZDisabled:Button Content="XYZ Fallback Action" /> + + <!-- Nested example: Parent always visible, children conditional --> + <Border BorderBrush="Gray" BorderThickness="1" Padding="10" Margin="0,10,0,0"> + <StackPanel Spacing="5"> + <TextBlock Text="Nested Controls Demo" FontWeight="Bold"/> + + <!-- Parent control under FeatureABC, with nested children under FeatureXYZ --> + <featureABCEnabled:StackPanel Margin="10,0,0,0"> + <TextBlock Text="ABC is enabled (parent)" Foreground="Green"/> + + <!-- Nested children: only loaded if ABC is enabled AND XYZ condition met --> + <featureXYZEnabled:TextBlock Text=" - XYZ is also enabled (child)" Foreground="Blue" Margin="10,0,0,0"/> + <featureXYZDisabled:TextBlock Text=" - XYZ is disabled (child)" Foreground="Gray" Margin="10,0,0,0"/> + </featureABCEnabled:StackPanel> + + <featureABCDisabled:TextBlock Text="ABC is disabled" Foreground="Red" Margin="10,0,0,0"/> + </StackPanel> + </Border> + + </StackPanel> + </ScrollViewer> + </Grid> +</Page> diff --git a/Samples/WinUI/ConditionalPredicate/cpp-winui/Scenario1_LoadConditionalControls.xaml.cpp b/Samples/WinUI/ConditionalPredicate/cpp-winui/Scenario1_LoadConditionalControls.xaml.cpp new file mode 100644 index 000000000..a14525e2d --- /dev/null +++ b/Samples/WinUI/ConditionalPredicate/cpp-winui/Scenario1_LoadConditionalControls.xaml.cpp @@ -0,0 +1,26 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +#include "pch.h" +#include "Scenario1_LoadConditionalControls.xaml.h" +#if __has_include("Scenario1_LoadConditionalControls.g.cpp") +#include "Scenario1_LoadConditionalControls.g.cpp" +#endif + +namespace winrt +{ + using namespace Microsoft::UI::Xaml; + using namespace Microsoft::UI::Xaml::Controls; + using namespace Windows::Foundation; +} + +namespace winrt::ConditionalXamlPredicate::implementation +{ + MainPage Scenario1_LoadConditionalControls::rootPage{ nullptr }; + + Scenario1_LoadConditionalControls::Scenario1_LoadConditionalControls() + { + InitializeComponent(); + Scenario1_LoadConditionalControls::rootPage = MainPage::Current(); + } +} diff --git a/Samples/WinUI/ConditionalPredicate/cpp-winui/Scenario1_LoadConditionalControls.xaml.h b/Samples/WinUI/ConditionalPredicate/cpp-winui/Scenario1_LoadConditionalControls.xaml.h new file mode 100644 index 000000000..7aea1ca0e --- /dev/null +++ b/Samples/WinUI/ConditionalPredicate/cpp-winui/Scenario1_LoadConditionalControls.xaml.h @@ -0,0 +1,23 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +#pragma once + +#include "Scenario1_LoadConditionalControls.g.h" + +namespace winrt::ConditionalXamlPredicate::implementation +{ + struct Scenario1_LoadConditionalControls : Scenario1_LoadConditionalControlsT<Scenario1_LoadConditionalControls> + { + Scenario1_LoadConditionalControls(); + private: + static ConditionalXamlPredicate::MainPage rootPage; + }; +} + +namespace winrt::ConditionalXamlPredicate::factory_implementation +{ + struct Scenario1_LoadConditionalControls : Scenario1_LoadConditionalControlsT<Scenario1_LoadConditionalControls, implementation::Scenario1_LoadConditionalControls> + { + }; +} diff --git a/Samples/WinUI/ConditionalPredicate/cpp-winui/Scenario2_ConditionalArguments.xaml b/Samples/WinUI/ConditionalPredicate/cpp-winui/Scenario2_ConditionalArguments.xaml new file mode 100644 index 000000000..c69c02cd3 --- /dev/null +++ b/Samples/WinUI/ConditionalPredicate/cpp-winui/Scenario2_ConditionalArguments.xaml @@ -0,0 +1,77 @@ +<!-- Copyright (c) Microsoft Corporation. + Licensed under the MIT License. --> +<Page + x:Class="ConditionalXamlPredicate.Scenario2_ConditionalArguments" + xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" + xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" + xmlns:local="using:ConditionalXamlPredicate" + xmlns:d="http://schemas.microsoft.com/expression/blend/2008" + xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" + xmlns:featureABCEnabled="http://schemas.microsoft.com/winfx/2006/xaml/presentation?local:MyCustomPredicate(FeatureABC,true)" + xmlns:featureABCDisabled="http://schemas.microsoft.com/winfx/2006/xaml/presentation?local:MyCustomPredicate(FeatureABC,false)" + xmlns:featureXYZEnabled="http://schemas.microsoft.com/winfx/2006/xaml/presentation?local:MyCustomPredicate(FeatureXYZ,true)" + xmlns:featureXYZDisabled="http://schemas.microsoft.com/winfx/2006/xaml/presentation?local:MyCustomPredicate(FeatureXYZ,false)" + mc:Ignorable="d"> + + <Grid> + <ScrollViewer Background="{ThemeResource ApplicationPageBackgroundThemeBrush}"> + <StackPanel Spacing="10" Margin="10,10,10,10"> + <TextBlock Text="Description:" Style="{StaticResource ScenarioHeaderTextStyle}"/> + <TextBlock Style="{StaticResource ScenarioDescriptionTextStyle}" TextWrapping="Wrap"> + This scenario demonstrates conditional XAML on property level. + The same control can have different property values based on feature flags. + </TextBlock> + + <!-- FeatureABC: Conditional Foreground property --> + <TextBlock Text="This text color depends on FeatureABC" + featureABCEnabled:Foreground="Green" + featureABCDisabled:Foreground="Red"/> + + <!-- FeatureABC: Conditional Background property --> + <Border Padding="10" + featureABCEnabled:Background="LightGreen" + featureABCDisabled:Background="LightCoral"> + <TextBlock Text="Border background depends on FeatureABC"/> + </Border> + + <!-- FeatureXYZ: Conditional Foreground property --> + <TextBlock Text="This text color depends on FeatureXYZ" + featureXYZEnabled:Foreground="Blue" + featureXYZDisabled:Foreground="Gray"/> + + <!-- FeatureXYZ: Conditional Background property --> + <Border Padding="10" + featureXYZEnabled:Background="LightBlue" + featureXYZDisabled:Background="LightGray"> + <TextBlock Text="Border background depends on FeatureXYZ"/> + </Border> + + <!-- Multiple properties on same control with FeatureABC --> + <Button Content="Button styled by FeatureABC" + featureABCEnabled:Background="DarkGreen" + featureABCEnabled:Foreground="White" + featureABCDisabled:Background="DarkRed" + featureABCDisabled:Foreground="Yellow"/> + + <!-- Multiple properties on same control with FeatureXYZ --> + <Button Content="Button styled by FeatureXYZ" + featureXYZEnabled:Background="DarkBlue" + featureXYZEnabled:Foreground="White" + featureXYZDisabled:Background="DarkGray" + featureXYZDisabled:Foreground="Black"/> + + <!-- Mixed: Different properties controlled by different features --> + <Border Padding="10" BorderThickness="2" + featureABCEnabled:Background="LightGreen" + featureABCDisabled:Background="LightCoral" + featureXYZEnabled:BorderBrush="Blue" + featureXYZDisabled:BorderBrush="Gray"> + <TextBlock Text="Background by FeatureABC, Border by FeatureXYZ" + featureABCEnabled:Foreground="DarkGreen" + featureABCDisabled:Foreground="DarkRed"/> + </Border> + + </StackPanel> + </ScrollViewer> + </Grid> +</Page> diff --git a/Samples/WinUI/ConditionalPredicate/cpp-winui/Scenario2_ConditionalArguments.xaml.cpp b/Samples/WinUI/ConditionalPredicate/cpp-winui/Scenario2_ConditionalArguments.xaml.cpp new file mode 100644 index 000000000..6eca0da9a --- /dev/null +++ b/Samples/WinUI/ConditionalPredicate/cpp-winui/Scenario2_ConditionalArguments.xaml.cpp @@ -0,0 +1,24 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +#include "pch.h" +#include "Scenario2_ConditionalArguments.xaml.h" +#if __has_include("Scenario2_ConditionalArguments.g.cpp") +#include "Scenario2_ConditionalArguments.g.cpp" +#endif + +namespace winrt +{ + using namespace Microsoft::UI::Xaml; +} + +// To learn more about WinUI, the WinUI project structure, +// and more about our project templates, see: http://aka.ms/winui-project-info. + +namespace winrt::ConditionalXamlPredicate::implementation +{ + Scenario2_ConditionalArguments::Scenario2_ConditionalArguments() + { + InitializeComponent(); + } +} diff --git a/Samples/WinUI/ConditionalPredicate/cpp-winui/Scenario2_ConditionalArguments.xaml.h b/Samples/WinUI/ConditionalPredicate/cpp-winui/Scenario2_ConditionalArguments.xaml.h new file mode 100644 index 000000000..d960d5774 --- /dev/null +++ b/Samples/WinUI/ConditionalPredicate/cpp-winui/Scenario2_ConditionalArguments.xaml.h @@ -0,0 +1,21 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +#pragma once + +#include "Scenario2_ConditionalArguments.g.h" + +namespace winrt::ConditionalXamlPredicate::implementation +{ + struct Scenario2_ConditionalArguments : Scenario2_ConditionalArgumentsT<Scenario2_ConditionalArguments> + { + Scenario2_ConditionalArguments(); + }; +} + +namespace winrt::ConditionalXamlPredicate::factory_implementation +{ + struct Scenario2_ConditionalArguments : Scenario2_ConditionalArgumentsT<Scenario2_ConditionalArguments, implementation::Scenario2_ConditionalArguments> + { + }; +} diff --git a/Samples/WinUI/ConditionalPredicate/cpp-winui/SettingsPage.xaml b/Samples/WinUI/ConditionalPredicate/cpp-winui/SettingsPage.xaml new file mode 100644 index 000000000..cb9e29920 --- /dev/null +++ b/Samples/WinUI/ConditionalPredicate/cpp-winui/SettingsPage.xaml @@ -0,0 +1,40 @@ +<!-- Copyright (c) Microsoft Corporation. + Licensed under the MIT License. --> +<Page + x:Class="ConditionalXamlPredicate.SettingsPage" + xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" + xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" + xmlns:local="using:ConditionalXamlPredicate" + xmlns:d="http://schemas.microsoft.com/expression/blend/2008" + xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" + mc:Ignorable="d"> + + <Grid RowDefinitions="*,Auto"> + <ScrollViewer Background="{ThemeResource ApplicationPageBackgroundThemeBrush}"> + <StackPanel Spacing="10" Margin="10,10,10,10" > + <TextBlock Text="Theme Mode" Style="{StaticResource SampleHeaderTextStyle}"/> + <StackPanel x:Name="themePanel"> + <RadioButton Checked="OnThemeRadioButtonChecked" Content="Light"> + <RadioButton.Tag> + <ElementTheme>Light</ElementTheme> + </RadioButton.Tag> + </RadioButton> + <RadioButton Checked="OnThemeRadioButtonChecked" Content="Dark"> + <RadioButton.Tag> + <ElementTheme>Dark</ElementTheme> + </RadioButton.Tag> + </RadioButton> + <RadioButton Checked="OnThemeRadioButtonChecked" Content="System Default"> + <RadioButton.Tag> + <ElementTheme>Default</ElementTheme> + </RadioButton.Tag> + </RadioButton> + </StackPanel> + </StackPanel> + </ScrollViewer> + + <StackPanel Spacing="10" Margin="10,10,10,10" Orientation="Vertical" VerticalAlignment="Bottom" Grid.Row="0"> + <TextBlock Text="© Microsoft Corporation. All rights reserved." Style="{StaticResource CopyrightTextStyle}" TextWrapping="Wrap"/> + </StackPanel> + </Grid> +</Page> diff --git a/Samples/WinUI/ConditionalPredicate/cpp-winui/SettingsPage.xaml.cpp b/Samples/WinUI/ConditionalPredicate/cpp-winui/SettingsPage.xaml.cpp new file mode 100644 index 000000000..feb994928 --- /dev/null +++ b/Samples/WinUI/ConditionalPredicate/cpp-winui/SettingsPage.xaml.cpp @@ -0,0 +1,51 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +#include "pch.h" +#include "SettingsPage.xaml.h" +#if __has_include("SettingsPage.g.cpp") +#include "SettingsPage.g.cpp" +#endif +#include <SampleConfiguration.h> + +namespace winrt +{ + using namespace Microsoft::UI::Xaml; + using namespace Microsoft::UI::Xaml::Controls; + using namespace Microsoft::UI::Xaml::Navigation; + using namespace Windows::Foundation; +} + +namespace winrt::ConditionalXamlPredicate::implementation +{ + SettingsPage::SettingsPage() + { + InitializeComponent(); + } + + void SettingsPage::OnNavigatedTo(NavigationEventArgs const&) + { + for (UIElement&& c : themePanel().Children()) + { + auto tag = c.as<RadioButton>().Tag().as<ElementTheme>(); + if (tag == SampleConfig::CurrentTheme) + { + auto radioButton = c.as<RadioButton>(); + radioButton.IsChecked(true); + } + } + } + + void SettingsPage::OnThemeRadioButtonChecked(IInspectable const& sender, RoutedEventArgs const&) + { + auto radiobutton = sender.as<RadioButton>(); + auto selectedTheme = unbox_value<ElementTheme>(radiobutton.Tag()); + + auto content = MainPage::Current().Content().as<Grid>(); + if (content != nullptr) + { + content.RequestedTheme(selectedTheme); + SampleConfig::CurrentTheme = content.RequestedTheme(); + } + } +} diff --git a/Samples/WinUI/ConditionalPredicate/cpp-winui/SettingsPage.xaml.h b/Samples/WinUI/ConditionalPredicate/cpp-winui/SettingsPage.xaml.h new file mode 100644 index 000000000..783997c91 --- /dev/null +++ b/Samples/WinUI/ConditionalPredicate/cpp-winui/SettingsPage.xaml.h @@ -0,0 +1,23 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +#pragma once + +#include "SettingsPage.g.h" + +namespace winrt::ConditionalXamlPredicate::implementation +{ + struct SettingsPage : SettingsPageT<SettingsPage> + { + SettingsPage(); + void OnNavigatedTo(Microsoft::UI::Xaml::Navigation::NavigationEventArgs const& e); + void OnThemeRadioButtonChecked(winrt::Windows::Foundation::IInspectable const& sender, winrt::Microsoft::UI::Xaml::RoutedEventArgs const& e); + }; +} + +namespace winrt::ConditionalXamlPredicate::factory_implementation +{ + struct SettingsPage : SettingsPageT<SettingsPage, implementation::SettingsPage> + { + }; +} diff --git a/Samples/WinUI/ConditionalPredicate/cpp-winui/Styles.xaml b/Samples/WinUI/ConditionalPredicate/cpp-winui/Styles.xaml new file mode 100644 index 000000000..5c9e0ec2e --- /dev/null +++ b/Samples/WinUI/ConditionalPredicate/cpp-winui/Styles.xaml @@ -0,0 +1,132 @@ +<!-- Copyright (c) Microsoft Corporation. + Licensed under the MIT License. --> +<ResourceDictionary + xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" + xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" + xmlns:local="using:ConditionalXamlPredicate"> + + <ResourceDictionary.MergedDictionaries> + <XamlControlsResources xmlns="using:Microsoft.UI.Xaml.Controls" /> + <!-- Other merged dictionaries here --> + </ResourceDictionary.MergedDictionaries> + <!-- Other app resources here --> + + <Style x:Key="SymbolButton" TargetType="ToggleButton"> + <Setter Property="FontSize" Value="16" /> + <Setter Property="FontFamily" Value="{StaticResource SymbolThemeFontFamily}" /> + <Setter Property="MinHeight" Value="48" /> + <Setter Property="MinWidth" Value="48" /> + <Setter Property="Margin" Value="0,4,0,0" /> + <Setter Property="Padding" Value="0" /> + <Setter Property="HorizontalAlignment" Value="Left" /> + <Setter Property="VerticalAlignment" Value="Top" /> + <Setter Property="HorizontalContentAlignment" Value="Center" /> + <Setter Property="VerticalContentAlignment" Value="Center" /> + <Setter Property="Background" Value="Transparent" /> + <Setter Property="Foreground" Value="{ThemeResource SystemControlForegroundBaseHighBrush}" /> + <Setter Property="Content" Value="" /> + <Setter Property="AutomationProperties.Name" Value="Menu" /> + <Setter Property="UseSystemFocusVisuals" Value="True" /> + <Setter Property="Template"> + <Setter.Value> + <ControlTemplate TargetType="ToggleButton"> + <Grid x:Name="LayoutRoot" + Background="{TemplateBinding Background}"> + <VisualStateManager.VisualStateGroups> + <VisualStateGroup x:Name="CommonStates"> + <VisualState x:Name="Normal" /> + <VisualState x:Name="PointerOver"> + <Storyboard> + <ObjectAnimationUsingKeyFrames Storyboard.TargetName="LayoutRoot" Storyboard.TargetProperty="(Grid.Background)"> + <DiscreteObjectKeyFrame KeyTime="0" Value="{ThemeResource SystemControlHighlightListLowBrush}"/> + </ObjectAnimationUsingKeyFrames> + <ObjectAnimationUsingKeyFrames Storyboard.TargetName="ContentPresenter" Storyboard.TargetProperty="Foreground"> + <DiscreteObjectKeyFrame KeyTime="0" Value="{ThemeResource SystemControlHighlightAltBaseHighBrush}"/> + </ObjectAnimationUsingKeyFrames> + </Storyboard> + </VisualState> + <VisualState x:Name="Pressed"> + <Storyboard> + <ObjectAnimationUsingKeyFrames Storyboard.TargetName="LayoutRoot" Storyboard.TargetProperty="(Grid.Background)"> + <DiscreteObjectKeyFrame KeyTime="0" Value="{ThemeResource SystemControlHighlightListMediumBrush}"/> + </ObjectAnimationUsingKeyFrames> + <ObjectAnimationUsingKeyFrames Storyboard.TargetName="ContentPresenter" Storyboard.TargetProperty="Foreground"> + <DiscreteObjectKeyFrame KeyTime="0" Value="{ThemeResource SystemControlHighlightAltBaseHighBrush}"/> + </ObjectAnimationUsingKeyFrames> + </Storyboard> + </VisualState> + <VisualState x:Name="Disabled"> + <Storyboard> + <ObjectAnimationUsingKeyFrames Storyboard.TargetName="ContentPresenter" Storyboard.TargetProperty="(TextBlock.Foreground)"> + <DiscreteObjectKeyFrame KeyTime="0" Value="{ThemeResource SystemControlDisabledBaseLowBrush}"/> + </ObjectAnimationUsingKeyFrames> + </Storyboard> + </VisualState> + <VisualState x:Name="Checked"/> + <VisualState x:Name="CheckedPointerOver"> + <Storyboard> + <ObjectAnimationUsingKeyFrames Storyboard.TargetName="LayoutRoot" Storyboard.TargetProperty="(Grid.Background)"> + <DiscreteObjectKeyFrame KeyTime="0" Value="{ThemeResource SystemControlHighlightListLowBrush}"/> + </ObjectAnimationUsingKeyFrames> + <ObjectAnimationUsingKeyFrames Storyboard.TargetName="ContentPresenter" Storyboard.TargetProperty="Foreground"> + <DiscreteObjectKeyFrame KeyTime="0" Value="{ThemeResource SystemControlHighlightAltBaseHighBrush}"/> + </ObjectAnimationUsingKeyFrames> + </Storyboard> + </VisualState> + <VisualState x:Name="CheckedPressed"> + <Storyboard> + <ObjectAnimationUsingKeyFrames Storyboard.TargetName="LayoutRoot" Storyboard.TargetProperty="(Grid.Background)"> + <DiscreteObjectKeyFrame KeyTime="0" Value="{ThemeResource SystemControlHighlightListMediumBrush}"/> + </ObjectAnimationUsingKeyFrames> + <ObjectAnimationUsingKeyFrames Storyboard.TargetName="ContentPresenter" Storyboard.TargetProperty="Foreground"> + <DiscreteObjectKeyFrame KeyTime="0" Value="{ThemeResource SystemControlHighlightAltBaseHighBrush}"/> + </ObjectAnimationUsingKeyFrames> + </Storyboard> + </VisualState> + <VisualState x:Name="CheckedDisabled"> + <Storyboard> + <ObjectAnimationUsingKeyFrames Storyboard.TargetName="ContentPresenter" Storyboard.TargetProperty="(TextBlock.Foreground)"> + <DiscreteObjectKeyFrame KeyTime="0" Value="{ThemeResource SystemControlDisabledBaseLowBrush}"/> + </ObjectAnimationUsingKeyFrames> + </Storyboard> + </VisualState> + </VisualStateGroup> + </VisualStateManager.VisualStateGroups> + <ContentPresenter x:Name="ContentPresenter" + Content="{TemplateBinding Content}" + Margin="{TemplateBinding Padding}" + HorizontalAlignment="{TemplateBinding HorizontalContentAlignment}" + VerticalAlignment="{TemplateBinding VerticalContentAlignment}" + AutomationProperties.AccessibilityView="Raw" /> + </Grid> + </ControlTemplate> + </Setter.Value> + </Setter> + </Style> + + <Style x:Key="BasicTextStyle" TargetType="TextBlock" BasedOn="{StaticResource BodyTextBlockStyle}"> + <Setter Property="Margin" Value="0,0,0,12"/> + </Style> + + <Style x:Key="TagLineTextStyle" TargetType="TextBlock" BasedOn="{StaticResource BodyTextBlockStyle}"> + </Style> + + <Style x:Key="SampleHeaderTextStyle" TargetType="TextBlock" BasedOn="{StaticResource TitleTextBlockStyle}"> + <Setter Property="FontSize" Value="28"/> + </Style> + + <Style x:Key="CopyrightTextStyle" TargetType="TextBlock" BasedOn="{StaticResource BaseTextBlockStyle}"> + <Setter Property="FontWeight" Value="Normal"/> + </Style> + + <Style x:Key="ScenarioHeaderTextStyle" TargetType="TextBlock" BasedOn="{StaticResource TitleTextBlockStyle}"> + </Style> + + <Style x:Key="ScenarioDescriptionTextStyle" TargetType="TextBlock" BasedOn="{StaticResource BodyTextBlockStyle}"> + </Style> + + <Style x:Key="BaseMessageStyle" TargetType="TextBlock" BasedOn="{StaticResource BodyTextBlockStyle}"> + <Setter Property="Margin" Value="0,0,0,5"/> + </Style> + +</ResourceDictionary> diff --git a/Samples/WinUI/ConditionalPredicate/cpp-winui/app.manifest b/Samples/WinUI/ConditionalPredicate/cpp-winui/app.manifest new file mode 100644 index 000000000..5d159b22b --- /dev/null +++ b/Samples/WinUI/ConditionalPredicate/cpp-winui/app.manifest @@ -0,0 +1,15 @@ +<?xml version="1.0" encoding="utf-8"?> +<assembly manifestVersion="1.0" xmlns="urn:schemas-microsoft-com:asm.v1"> + <assemblyIdentity version="1.0.0.0" name="ConditionalXamlPredicate.app"/> + + <application xmlns="urn:schemas-microsoft-com:asm.v3"> + <windowsSettings> + <!-- The combination of below two tags have the following effect: + 1) Per-Monitor for >= Windows 10 Anniversary Update + 2) System < Windows 10 Anniversary Update + --> + <dpiAware xmlns="http://schemas.microsoft.com/SMI/2005/WindowsSettings">true/PM</dpiAware> + <dpiAwareness xmlns="http://schemas.microsoft.com/SMI/2016/WindowsSettings">PerMonitorV2, PerMonitor</dpiAwareness> + </windowsSettings> + </application> +</assembly> diff --git a/Samples/WinUI/ConditionalPredicate/cpp-winui/packages.config b/Samples/WinUI/ConditionalPredicate/cpp-winui/packages.config new file mode 100644 index 000000000..ba6704f1e --- /dev/null +++ b/Samples/WinUI/ConditionalPredicate/cpp-winui/packages.config @@ -0,0 +1,17 @@ +<?xml version="1.0" encoding="utf-8"?> +<packages> + <package id="Microsoft.Web.WebView2" version="1.0.3405.78" targetFramework="native" /> + <package id="Microsoft.Windows.CppWinRT" version="2.0.210922.5" targetFramework="native" /> + <package id="Microsoft.Windows.SDK.BuildTools" version="10.0.26100.4654" targetFramework="native" /> + <package id="Microsoft.Windows.SDK.BuildTools.MSIX" version="1.7.20250829.1" targetFramework="native" developmentDependency="true" /> + <package id="Microsoft.WindowsAppSDK" version="2.0.0-experimental4" targetFramework="native" /> + <package id="Microsoft.WindowsAppSDK.AI" version="2.0.130-experimental" targetFramework="native" /> + <package id="Microsoft.WindowsAppSDK.Base" version="2.0.1-experimental" targetFramework="native" /> + <package id="Microsoft.WindowsAppSDK.DWrite" version="2.0.1-experimental" targetFramework="native" /> + <package id="Microsoft.WindowsAppSDK.Foundation" version="2.0.11-experimental" targetFramework="native" /> + <package id="Microsoft.WindowsAppSDK.InteractiveExperiences" version="2.0.5-experimental" targetFramework="native" /> + <package id="Microsoft.WindowsAppSDK.ML" version="2.0.169-experimental" targetFramework="native" /> + <package id="Microsoft.WindowsAppSDK.Runtime" version="2.0.0-experimental4" targetFramework="native" /> + <package id="Microsoft.WindowsAppSDK.Widgets" version="2.0.3-experimental" targetFramework="native" /> + <package id="Microsoft.WindowsAppSDK.WinUI" version="2.0.4-experimental" targetFramework="native" /> +</packages> \ No newline at end of file diff --git a/Samples/WinUI/ConditionalPredicate/cpp-winui/pch.cpp b/Samples/WinUI/ConditionalPredicate/cpp-winui/pch.cpp new file mode 100644 index 000000000..40e691ba7 --- /dev/null +++ b/Samples/WinUI/ConditionalPredicate/cpp-winui/pch.cpp @@ -0,0 +1,4 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +#include "pch.h" diff --git a/Samples/WinUI/ConditionalPredicate/cpp-winui/pch.h b/Samples/WinUI/ConditionalPredicate/cpp-winui/pch.h new file mode 100644 index 000000000..d84dd7c10 --- /dev/null +++ b/Samples/WinUI/ConditionalPredicate/cpp-winui/pch.h @@ -0,0 +1,33 @@ +// Copyright (c) Microsoft Corporation. +// Licensed under the MIT License. + +#pragma once +#include <windows.h> +#include <unknwn.h> +#include <restrictederrorinfo.h> +#include <hstring.h> + +// Undefine GetCurrentTime macro to prevent +// conflict with Storyboard::GetCurrentTime +#undef GetCurrentTime + +#include <winrt/Windows.Foundation.h> +#include <winrt/Windows.Foundation.Collections.h> +#include <winrt/Windows.ApplicationModel.Activation.h> +#include <winrt/Windows.UI.Xaml.Interop.h> //For using xaml_typename + +#include <winrt/Microsoft.UI.Composition.h> +#include <winrt/Microsoft.UI.Xaml.h> +#include <winrt/Microsoft.UI.Xaml.Controls.h> +#include <winrt/Microsoft.UI.Xaml.Media.Animation.h> +#include <winrt/Microsoft.UI.Xaml.Controls.Primitives.h> +#include <winrt/Microsoft.UI.Xaml.Data.h> +#include <winrt/Microsoft.UI.Xaml.Interop.h> +#include <winrt/Microsoft.UI.Xaml.Markup.h> +#include <winrt/Microsoft.UI.Xaml.Media.h> +#include <winrt/Microsoft.UI.Xaml.Navigation.h> +#include <winrt/Microsoft.UI.Xaml.Shapes.h> +#include <winrt/Microsoft.UI.Dispatching.h> +#include <winrt/Windows.UI.Core.h> + +#include "MyCustomPredicate.h"