◆ node_graph_manager()

InspectResult & MayaFlux::Portal::Forma::Inspector::node_graph_manager	(	Surface &	surface,
		LayoutCursor &	cursor,
		float	x_min = `-0.95F`,
		float	x_max = `0.95F`,
		float	row_h = `0.05F`
	)

Inspect the full NodeGraphManager state across all active tokens.

Emits one collapsible per active Nodes::ProcessingToken. Each token expands per-channel children, each of which recursively calls node() for every node registered to that channel. Networks for the token are appended after the channel children, showing topology, output mode, node count, enabled state, and registered channels.

Persistent: the first call builds the result against surface and cursor and stores it statically. Subsequent calls return the same result regardless of the supplied surface and cursor; the original window remains the render target. To display on a different surface, the process must be restarted.

Definition at line 262 of file NodeQuery.cpp.

{
    if (s_node_graph_result) {
        return *s_node_graph_result;
    }
 
    const auto tokens = m_ngm.get_active_tokens();
 
    const std::string root_label = "NodeGraphManager ["
        + std::to_string(tokens.size()) + " token"
        + (tokens.size() == 1 ? "" : "s") + "]";
 
    auto& ngm = m_ngm;
    std::vector<ValueSpec> root_values {
        ValueSpec {
            .label = "tokens",
            .reader = [&ngm] { return std::to_string(ngm.get_active_tokens().size()); },
        },
    };
 
    const auto dims = row_pixel_dims(surface.window(), x_min, x_max, row_h);
    auto hbuf = make_row_buffer(surface.window(), root_label, dims);
    std::vector<RowBuffer> rbufs;
    rbufs.reserve(root_values.size());
    for (const auto& spec : root_values)
        rbufs.push_back(make_row_buffer(surface.window(), spec.label, dims));
 
    auto root_group = make_value_group(root_values, std::move(hbuf), rbufs,
        surface, cursor, x_min, x_max, row_h, false);
 
    InspectResult& result = s_node_graph_result.emplace();
    result.group = std::move(root_group);
 
    for (const auto tok : tokens) {
        const std::string tok_label = std::string(Reflect::enum_to_string(tok));
        const bool multichannel = tok == Nodes::ProcessingToken::AUDIO_RATE;
        auto channels = m_ngm.get_all_channels(tok);
        if (multichannel)
            std::ranges::sort(channels);
 
        std::vector<ValueSpec> tok_values {
            ValueSpec {
                .label = "nodes",
                .reader = [&ngm, tok] { return std::to_string(ngm.get_node_count(tok)); },
            },
            ValueSpec {
                .label = "networks",
                .reader = [&ngm, tok] { return std::to_string(ngm.get_network_count(tok)); },
            },
        };
 
        const auto tok_dims = row_pixel_dims(surface.window(), x_min + k_inspect_indent, x_max, row_h);
        auto tok_hbuf = make_row_buffer(surface.window(), tok_label, tok_dims);
        std::vector<RowBuffer> tok_rbufs;
        tok_rbufs.reserve(tok_values.size());
        for (const auto& spec : tok_values)
            tok_rbufs.push_back(make_row_buffer(surface.window(), spec.label, tok_dims));
 
        auto tok_group = make_value_group(tok_values, std::move(tok_hbuf), tok_rbufs,
            surface, cursor, x_min + k_inspect_indent, x_max, row_h, false);
 
        InspectResult tok_result;
        tok_result.group = std::move(tok_group);
        surface.layer().relate(result.group.header.header_id, tok_result.group.header.header_id);
 
        // ----- Networks section -----
        {
            const auto net_dims = row_pixel_dims(surface.window(), x_min + 2.F * k_inspect_indent, x_max, row_h);
            auto net_hbuf = make_row_buffer(surface.window(), "Networks", net_dims);
            auto net_group = make_value_group({}, std::move(net_hbuf), {},
                surface, cursor, x_min + 2.F * k_inspect_indent, x_max, row_h, false);
 
            InspectResult net_section;
            net_section.group = std::move(net_group);
            surface.layer().relate(tok_result.group.header.header_id, net_section.group.header.header_id);
 
            if (multichannel) {
                for (const auto ch : channels) {
                    const auto ch_dims = row_pixel_dims(surface.window(), x_min + 3.F * k_inspect_indent, x_max, row_h);
                    auto ch_hbuf = make_row_buffer(surface.window(), "ch " + std::to_string(ch), ch_dims);
                    auto ch_group = make_value_group({}, std::move(ch_hbuf), {},
                        surface, cursor, x_min + 3.F * k_inspect_indent, x_max, row_h, false);
 
                    InspectResult ch_result;
                    ch_result.group = std::move(ch_group);
                    surface.layer().relate(net_section.group.header.header_id, ch_result.group.header.header_id);
 
                    for (const auto& net : m_ngm.get_networks(tok, ch)) {
                        if (!net)
                            continue;
                        auto nr = node_network(net, surface, cursor, x_min, x_max, row_h, 4);
                        surface.layer().relate(ch_result.group.header.header_id, nr.group.header.header_id);
                        ch_result.children.push_back(std::move(nr));
                    }
 
                    net_section.children.push_back(std::move(ch_result));
                }
            } else {
                for (const auto& net : m_ngm.get_networks(tok, 0)) {
                    if (!net)
                        continue;
                    auto nr = node_network(net, surface, cursor, x_min, x_max, row_h, 3);
                    surface.layer().relate(net_section.group.header.header_id, nr.group.header.header_id);
                    net_section.children.push_back(std::move(nr));
                }
            }
 
            tok_result.children.push_back(std::move(net_section));
        }
 
        // ----- Nodes section -----
        {
            const auto nodes_dims = row_pixel_dims(surface.window(), x_min + 2.F * k_inspect_indent, x_max, row_h);
            auto nodes_hbuf = make_row_buffer(surface.window(), "Nodes", nodes_dims);
            auto nodes_group = make_value_group({}, std::move(nodes_hbuf), {},
                surface, cursor, x_min + 2.F * k_inspect_indent, x_max, row_h, false);
 
            InspectResult nodes_section;
            nodes_section.group = std::move(nodes_group);
            surface.layer().relate(tok_result.group.header.header_id, nodes_section.group.header.header_id);
 
            if (multichannel) {
                for (const auto ch : channels) {
                    auto rn = root_node(tok, ch, surface, cursor, x_min, x_max, row_h, 3);
                    surface.layer().relate(nodes_section.group.header.header_id, rn.group.header.header_id);
                    nodes_section.children.push_back(std::move(rn));
                }
            } else {
                auto rn = root_node(tok, 0, surface, cursor, x_min, x_max, row_h, 3);
                surface.layer().relate(nodes_section.group.header.header_id, rn.group.header.header_id);
                nodes_section.children.push_back(std::move(rn));
            }
 
            tok_result.children.push_back(std::move(nodes_section));
        }
 
        result.children.push_back(std::move(tok_result));
    }
 
    return result;
}

Here is the call graph for this function: