Function MakeDocument_

IntelPresentMon/Core/source/kernel/Overlay.cpp:40–102

    namespace
    {
        auto MakeDocument_(
            gfx::Graphics& gfx,
            const OverlaySpec& spec,
            MetricPackMapper& mapper,
            pmon::MetricFetcherFactory& fetcherFactory,
            std::shared_ptr<TextElement>& captureIndicator)
        {
            auto pRoot = FlexElement::Make({}, { "doc" });
            std::shared_ptr<gfx::lay::Element> pReadoutContainer;

            for (const auto& w : spec.widgets) {
                try {
                    if (auto pGraphSpec = std::get_if<GraphSpec>(&w)) {
                        auto packsData = pGraphSpec->metrics |
                            std::views::transform([&](const GraphMetricSpec& gms) {
                                auto metInfo = fetcherFactory.GetMetricInfo(gms.metric);
                                return std::make_shared<GraphLinePack>(GraphLinePack{
                                    .data = mapper[gms.metric].graphData,
                                    .axisAffinity = gms.axisAffinity,
                                    .label = std::move(metInfo.fullName),
                                    .units = std::move(metInfo.unitLabel),
                                });
                            }) | rn::to<std::vector>();
                        pRoot->AddChild(GraphElement::Make(
                            pGraphSpec->type, std::move(packsData), { pGraphSpec->tag }
                        ));
                        pReadoutContainer.reset();
                    }
                    else if (auto pReadoutSpec = std::get_if<ReadoutSpec>(&w)) {
                        if (!pReadoutContainer) {
                            pReadoutContainer = gfx::lay::FlexElement::Make({}, { "readout-container" });
                            pRoot->AddChild(pReadoutContainer);
                        }

                        auto metInfo = fetcherFactory.GetMetricInfo(pReadoutSpec->metric);
                        pReadoutContainer->AddChild(gfx::lay::ReadoutElement::Make(
                            metInfo.isNonNumeric, std::move(metInfo.fullName), std::move(metInfo.unitLabel),
                            mapper[pReadoutSpec->metric].textData.get(), { pReadoutSpec->tag }
                        ));
                    }
                    else {
                        throw Except<OverlayDocumentException>("Bad widget variant");
                    }
                }
                catch (...) {
                    pmlog_warn("Failed building a widget into document");
                }
            }

            // capture state indicator
            pRoot->AddChild(FlexElement::Make(
                {
                    TextElement::Make(L"Capture Status:", {"label"}),
                    captureIndicator = TextElement::Make(L"-------------------", {"value"}),
                },
                { "cap" }
            ));