Add experimental feature for font list command

schemas/JSON/settings/settings.schema.0.2.json

@@ -287,6 +287,11 @@
           "description": "Enable support for the configure export command",
           "type": "boolean",
           "default": false
+        },
+        "Font": {
+          "description": "Enable support for managing Font",
+          "type": "boolean",
+          "default":  false
         }
       }
     }

src/AppInstallerCLICore/AppInstallerCLICore.vcxproj

@@ -364,6 +364,7 @@
     <ClInclude Include="Commands\ErrorCommand.h" />
     <ClInclude Include="Commands\ExperimentalCommand.h" />
     <ClInclude Include="Commands\ExportCommand.h" />
+    <ClInclude Include="Commands\FontCommand.h" />
     <ClInclude Include="Commands\ImportCommand.h" />
     <ClInclude Include="Commands\FeaturesCommand.h" />
     <ClInclude Include="Commands\HashCommand.h" />
@@ -410,6 +411,7 @@
     <ClInclude Include="Workflows\CompletionFlow.h" />
     <ClInclude Include="Workflows\DependencyNodeProcessor.h" />
     <ClInclude Include="Workflows\DownloadFlow.h" />
+    <ClInclude Include="Workflows\FontFlow.h" />
     <ClInclude Include="Workflows\ImportExportFlow.h" />
     <ClInclude Include="Workflows\MsiInstallFlow.h" />
     <ClInclude Include="Workflows\MSStoreInstallerHandler.h" />
@@ -441,6 +443,7 @@
     <ClCompile Include="Commands\DebugCommand.cpp" />
     <ClCompile Include="Commands\DownloadCommand.cpp" />
     <ClCompile Include="Commands\ErrorCommand.cpp" />
+    <ClCompile Include="Commands\FontCommand.cpp" />
     <ClCompile Include="Commands\ImportCommand.cpp" />
     <ClCompile Include="Commands\PinCommand.cpp" />
     <ClCompile Include="Commands\RepairCommand.cpp" />
@@ -490,6 +493,7 @@
     <ClCompile Include="Workflows\CompletionFlow.cpp" />
     <ClCompile Include="Workflows\DependencyNodeProcessor.cpp" />
     <ClCompile Include="Workflows\DownloadFlow.cpp" />
+    <ClCompile Include="Workflows\FontFlow.cpp" />
     <ClCompile Include="Workflows\ImportExportFlow.cpp" />
     <ClCompile Include="Workflows\MsiInstallFlow.cpp" />
     <ClCompile Include="Workflows\MSStoreInstallerHandler.cpp" />

src/AppInstallerCLICore/AppInstallerCLICore.vcxproj.filters

@@ -260,6 +260,12 @@
     <ClInclude Include="Sixel.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="Commands\FontCommand.h">
+      <Filter>Commands</Filter>
+    </ClInclude>
+    <ClInclude Include="Workflows\FontFlow.h">
+      <Filter>Workflows</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="pch.cpp">
@@ -490,6 +496,12 @@
     <ClCompile Include="Sixel.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="Commands\FontCommand.cpp">
+      <Filter>Commands</Filter>
+    </ClCompile>
+    <ClCompile Include="Workflows\FontFlow.cpp">
+      <Filter>Workflows</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <None Include="PropertySheet.props" />

src/AppInstallerCLICore/Argument.cpp

@@ -198,6 +198,10 @@ namespace AppInstaller::CLI
         case Execution::Args::Type::IgnoreResumeLimit:
             return { type, "ignore-resume-limit"_liv, ArgTypeCategory::None };
 
+        // Font command
+        case Execution::Args::Type::FamilyName:
+            return { type, "family-name"_liv, ArgTypeCategory::None };
+
         // Configuration commands
         case Execution::Args::Type::ConfigurationFile:
             return { type, "file"_liv, 'f', ArgTypeCategory::ConfigurationSetChoice, ArgTypeExclusiveSet::ConfigurationSetChoice };
@@ -430,6 +434,8 @@ namespace AppInstaller::CLI
             return Argument{ type, Resource::String::ProxyArgumentDescription, ArgumentType::Standard, TogglePolicy::Policy::ProxyCommandLineOptions, BoolAdminSetting::ProxyCommandLineOptions };
         case Args::Type::NoProxy:
             return Argument{ type, Resource::String::NoProxyArgumentDescription, ArgumentType::Flag, TogglePolicy::Policy::ProxyCommandLineOptions, BoolAdminSetting::ProxyCommandLineOptions };
+        case Args::Type::FamilyName:
+            return Argument{ type, Resource::String::FontFamilyNameArgumentDescription, ArgumentType::Standard, false };
         default:
             THROW_HR(E_UNEXPECTED);
         }

src/AppInstallerCLICore/Commands/FontCommand.cpp

@@ -0,0 +1,86 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+#include "pch.h"
+#include "FontCommand.h"
+#include "Workflows/CompletionFlow.h"
+#include "Workflows/WorkflowBase.h"
+#include "Workflows/FontFlow.h"
+#include "Resources.h"
+
+namespace AppInstaller::CLI
+{
+    using namespace AppInstaller::CLI::Execution;
+    using namespace AppInstaller::CLI::Workflow;
+    using namespace AppInstaller::Utility::literals;
+    using namespace std::string_view_literals;
+
+    Utility::LocIndView s_FontCommand_HelpLink = "https://aka.ms/winget-command-help"_liv;
+
+    std::vector<std::unique_ptr<Command>> FontCommand::GetCommands() const
+    {
+        return InitializeFromMoveOnly<std::vector<std::unique_ptr<Command>>>({
+            std::make_unique<FontListCommand>(FullName()),
+        });
+    }
+
+    Resource::LocString FontCommand::ShortDescription() const
+    {
+        return { Resource::String::FontCommandShortDescription };
+    }
+
+    Resource::LocString FontCommand::LongDescription() const
+    {
+        return { Resource::String::FontCommandLongDescription };
+    }
+
+    Utility::LocIndView FontCommand::HelpLink() const
+    {
+        return s_FontCommand_HelpLink;
+    }
+
+    void FontCommand::ExecuteInternal(Execution::Context& context) const
+    {
+        OutputHelp(context.Reporter);
+    }
+
+    std::vector<Argument> FontListCommand::GetArguments() const
+    {
+        return {
+            Argument::ForType(Args::Type::FamilyName),
+            Argument::ForType(Args::Type::Moniker),
+            Argument::ForType(Args::Type::Source),
+            Argument::ForType(Args::Type::Tag),
+            Argument::ForType(Args::Type::Exact),
+            Argument::ForType(Args::Type::AuthenticationMode),
+            Argument::ForType(Args::Type::AuthenticationAccount),
+            Argument::ForType(Args::Type::AcceptSourceAgreements),
+        };
+    }
+
+    Resource::LocString FontListCommand::ShortDescription() const
+    {
+        return { Resource::String::FontListCommandShortDescription };
+    }
+
+    Resource::LocString FontListCommand::LongDescription() const
+    {
+        return { Resource::String::FontListCommandLongDescription };
+    }
+
+    void FontListCommand::Complete(Execution::Context& context, Args::Type valueType) const
+    {
+        UNREFERENCED_PARAMETER(valueType);
+        context.Reporter.Error() << Resource::String::PendingWorkError << std::endl;
+        THROW_HR(E_NOTIMPL);
+    }
+
+    Utility::LocIndView FontListCommand::HelpLink() const
+    {
+        return s_FontCommand_HelpLink;
+    }
+
+    void FontListCommand::ExecuteInternal(Execution::Context& context) const
+    {
+        context << Workflow::ReportInstalledFontsResult;
+    }
+}

src/AppInstallerCLICore/Commands/FontCommand.h

@@ -0,0 +1,40 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+#pragma once
+#include "Command.h"
+#include <winget/UserSettings.h>
+
+namespace AppInstaller::CLI
+{
+    struct FontCommand final : public Command
+    {
+        FontCommand(std::string_view parent) : Command("font", {} /* aliases */, parent, Settings::ExperimentalFeature::Feature::Font) {}
+
+        std::vector<std::unique_ptr<Command>> GetCommands() const override;
+
+        Resource::LocString ShortDescription() const override;
+        Resource::LocString LongDescription() const override;
+
+        Utility::LocIndView HelpLink() const override;
+
+    protected:
+        void ExecuteInternal(Execution::Context& context) const override;
+    };
+
+    struct FontListCommand final : public Command
+    {
+        FontListCommand(std::string_view parent) : Command("list", parent) {}
+
+        std::vector<Argument> GetArguments() const override;
+
+        Resource::LocString ShortDescription() const override;
+        Resource::LocString LongDescription() const override;
+
+        void Complete(Execution::Context& context, Execution::Args::Type valueType) const override;
+
+        Utility::LocIndView HelpLink() const override;
+
+    protected:
+        void ExecuteInternal(Execution::Context& context) const override;
+    };
+}

src/AppInstallerCLICore/Commands/RootCommand.cpp

@@ -15,6 +15,7 @@
 #include "ValidateCommand.h"
 #include "SettingsCommand.h"
 #include "FeaturesCommand.h"
+#include "FontCommand.h"
 #include "ExperimentalCommand.h"
 #include "CompleteCommand.h"
 #include "ExportCommand.h"
@@ -194,6 +195,7 @@ namespace AppInstaller::CLI
             std::make_unique<ErrorCommand>(FullName()),
             std::make_unique<ResumeCommand>(FullName()),
             std::make_unique<RepairCommand>(FullName()),
+            std::make_unique<FontCommand>(FullName()),
 #if _DEBUG
             std::make_unique<DebugCommand>(FullName()),
 #endif

src/AppInstallerCLICore/ExecutionArgs.h

@@ -121,6 +121,9 @@ namespace AppInstaller::CLI::Execution
             ResumeId,
             IgnoreResumeLimit,
 
+            // Font Command
+            FamilyName,
+
             // Configuration
             ConfigurationFile,
             ConfigurationAcceptWarning,

src/AppInstallerCLICore/Resources.h

@@ -248,6 +248,15 @@ namespace AppInstaller::CLI::Resource
         WINGET_DEFINE_RESOURCE_STRINGID(FileNotFound);
         WINGET_DEFINE_RESOURCE_STRINGID(FilesRemainInInstallDirectory);
         WINGET_DEFINE_RESOURCE_STRINGID(FlagContainAdjoinedError);
+        WINGET_DEFINE_RESOURCE_STRINGID(FontCommandLongDescription);
+        WINGET_DEFINE_RESOURCE_STRINGID(FontCommandShortDescription);
+        WINGET_DEFINE_RESOURCE_STRINGID(FontFaceCount);
+        WINGET_DEFINE_RESOURCE_STRINGID(FontFace);
+        WINGET_DEFINE_RESOURCE_STRINGID(FontFamily);
+        WINGET_DEFINE_RESOURCE_STRINGID(FontFamilyNameArgumentDescription);
+        WINGET_DEFINE_RESOURCE_STRINGID(FontFilePaths);
+        WINGET_DEFINE_RESOURCE_STRINGID(FontListCommandLongDescription);
+        WINGET_DEFINE_RESOURCE_STRINGID(FontListCommandShortDescription);
         WINGET_DEFINE_RESOURCE_STRINGID(ForceArgumentDescription);
         WINGET_DEFINE_RESOURCE_STRINGID(GatedVersionArgumentDescription);
         WINGET_DEFINE_RESOURCE_STRINGID(GetManifestResultVersionNotFound);
@@ -403,6 +412,7 @@ namespace AppInstaller::CLI::Resource
         WINGET_DEFINE_RESOURCE_STRINGID(NoAdminRepairForUserScopePackage);
         WINGET_DEFINE_RESOURCE_STRINGID(NoApplicableInstallers);
         WINGET_DEFINE_RESOURCE_STRINGID(NoExperimentalFeaturesMessage);
+        WINGET_DEFINE_RESOURCE_STRINGID(NoInstalledFontFound);
         WINGET_DEFINE_RESOURCE_STRINGID(NoInstalledPackageFound);
         WINGET_DEFINE_RESOURCE_STRINGID(NoPackageFound);
         WINGET_DEFINE_RESOURCE_STRINGID(NoPackageSelectionArgumentProvided);

src/AppInstallerCLICore/Workflows/FontFlow.cpp

@@ -0,0 +1,118 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+#include "pch.h"
+#include "FontFlow.h"
+#include "TableOutput.h"
+#include <winget/Fonts.h>
+
+namespace AppInstaller::CLI::Workflow
+{
+    using namespace AppInstaller::CLI::Execution;
+
+    namespace
+    {
+        struct InstalledFontFamiliesTableLine
+        {
+            InstalledFontFamiliesTableLine(Utility::LocIndString familyName, int faceCount)
+                : FamilyName(familyName), FaceCount(faceCount) {}
+
+            Utility::LocIndString FamilyName;
+            int FaceCount;
+        };
+
+        struct InstalledFontFacesTableLine
+        {
+            InstalledFontFacesTableLine(Utility::LocIndString faceName, Utility::LocIndString familyName, std::filesystem::path filePath)
+                : FaceName(faceName), FamilyName(familyName), FilePath(filePath) {}
+
+            Utility::LocIndString FaceName;
+            Utility::LocIndString FamilyName;
+            std::filesystem::path FilePath;
+        };
+
+        void OutputInstalledFontFamiliesTable(Execution::Context& context, const std::vector<InstalledFontFamiliesTableLine>& lines)
+        {
+            Execution::TableOutput<2> table(context.Reporter, { Resource::String::FontFamily, Resource::String::FontFaceCount });
+
+            for (const auto& line : lines)
+            {
+                table.OutputLine({ line.FamilyName, std::to_string(line.FaceCount) });
+            }
+
+            table.Complete();
+        }
+
+        void OutputInstalledFontFacesTable(Execution::Context& context, const std::vector<InstalledFontFacesTableLine>& lines)
+        {
+            Execution::TableOutput<3> table(context.Reporter, { Resource::String::FontFace, Resource::String::FontFamily, Resource::String::FontFilePaths });
+
+            for (const auto& line : lines)
+            {
+                table.OutputLine({ line.FaceName, line.FamilyName, line.FilePath.u8string() });
+            }
+
+            table.Complete();
+        }
+    }
+
+    void ReportInstalledFontsResult(Execution::Context& context)
+    {
+        if (context.Args.Contains(Args::Type::FamilyName))
+        {
+            // TODO: Utilize font index for better searching capabitility.
+            const auto& familyNameArg = context.Args.GetArg(Args::Type::FamilyName);
+            const auto& fontFamily = AppInstaller::Fonts::GetInstalledFontFamily(AppInstaller::Utility::ConvertToUTF16(familyNameArg));
+
+            if (!fontFamily.has_value())
+            {
+                context.Reporter.Info() << Resource::String::NoInstalledFontFound << std::endl;
+                return;
+            }
+
+            const auto& familyName = Utility::LocIndString(Utility::ConvertToUTF8(fontFamily->Name));
+            std::vector<InstalledFontFacesTableLine> lines;
+
+            for (const auto& fontFace : fontFamily->Faces)
+            {
+                bool isFirstLine = true;
+                for (const auto& filePath : fontFace.FilePaths)
+                {
+                    if (isFirstLine)
+                    {
+                        InstalledFontFacesTableLine line(
+                            Utility::LocIndString(Utility::ToLower(Utility::ConvertToUTF8(fontFace.Name))),
+                            familyName,
+                            filePath.u8string()
+                        );
+                        isFirstLine = false;
+                        lines.push_back(std::move(line));
+                    }
+                    else
+                    {
+                        InstalledFontFacesTableLine line({}, {}, filePath.u8string());
+                        lines.push_back(std::move(line));
+                    }
+                }
+            }
+
+            OutputInstalledFontFacesTable(context, lines);
+        }
+        else
+        {
+            const auto& fontFamilies = AppInstaller::Fonts::GetInstalledFontFamilies();
+            std::vector<InstalledFontFamiliesTableLine> lines;
+
+            for (const auto& fontFamily : fontFamilies)
+            {
+                InstalledFontFamiliesTableLine line(
+                    Utility::LocIndString(Utility::ConvertToUTF8(fontFamily.Name)),
+                    static_cast<int>(fontFamily.Faces.size())
+                );
+
+                lines.push_back(std::move(line));
+            }
+
+            OutputInstalledFontFamiliesTable(context, lines);
+        }
+    }
+}