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 keeps it on this Inspector. Subsequent calls return the same result regardless of the supplied surface and cursor; the original window remains the render target. destroy() releases it, and the next call builds afresh.

Definition at line 265 of file NodeQuery.cpp.

{
    if (m_node_graph_result) {
        return *m_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<EntrySpec> root_entrys {
        EntrySpec {
            .label = "tokens",
            .reader = [&ngm] { return std::to_string(ngm.get_active_tokens().size()); },
        },
    };
 
    auto hbuf = make_header_buffer(surface.window());
    auto rbufs = make_row_buffers(surface.window(), root_entrys.size());
 
    auto root_group = make_entry_group(root_entrys, root_label, std::move(hbuf), rbufs,
        surface, cursor, x_min, x_max, row_h, false);
 
    InspectResult& result = m_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<EntrySpec> tok_entrys {
            EntrySpec {
                .label = "nodes",
                .reader = [&ngm, tok] { return std::to_string(ngm.get_node_count(tok)); },
            },
            EntrySpec {
                .label = "networks",
                .reader = [&ngm, tok] { return std::to_string(ngm.get_network_count(tok)); },
            },
        };
 
        auto tok_hbuf = make_header_buffer(surface.window());
        auto tok_rbufs = make_row_buffers(surface.window(), tok_entrys.size());
 
        auto tok_group = make_entry_group(tok_entrys, tok_label, 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 -----
        {
            auto net_hbuf = make_header_buffer(surface.window());
            auto net_group = make_entry_group({}, "Networks", 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) {
                    auto ch_hbuf = make_header_buffer(surface.window());
                    auto ch_group = make_entry_group({}, "ch " + std::to_string(ch), 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 -----
        {
            auto nodes_hbuf = make_header_buffer(surface.window());
            auto nodes_group = make_entry_group({}, "Nodes", 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;
}

References MayaFlux::Nodes::AUDIO_RATE, channels, MayaFlux::Portal::Forma::InspectResult::children, MayaFlux::Reflect::enum_to_string(), MayaFlux::Nodes::NodeGraphManager::get_active_tokens(), MayaFlux::Nodes::NodeGraphManager::get_all_channels(), MayaFlux::Nodes::NodeGraphManager::get_networks(), MayaFlux::Portal::Forma::InspectResult::group, MayaFlux::Portal::Forma::EntryGroup::header, MayaFlux::Portal::Forma::Collapsible::header_id, MayaFlux::Portal::Forma::k_inspect_indent, MayaFlux::Portal::Forma::EntrySpec::label, MayaFlux::Portal::Forma::Surface::layer(), m_ngm, m_node_graph_result, MayaFlux::Portal::Forma::make_entry_group(), make_header_buffer(), make_row_buffers(), node_network(), MayaFlux::Portal::Forma::Layer::relate(), root_node(), and MayaFlux::Portal::Forma::Surface::window().

Referenced by MayaFlux::Portal::Forma::inspect_node_graph().

Here is the call graph for this function:

Here is the caller graph for this function: