controller Class Reference

Frontend coordinator for streams, lines, templates, and events. More...

#include <frontend/include/helpers/controller.hpp>

Inheritance diagram for controller:

Collaboration diagram for controller:

Classes
struct	tpl_line
	Stored template geometry (percentage coordinates). More...

Public Slots
void	handle_add_file (const QString &path, const QString &name, bool loop)
	Handler for adding a file stream from UI.
void	handle_add_local (const QString &source, const QString &name)
	Handler for adding a local capture device from UI.
void	handle_add_url (const QString &url, const QString &name)
	Handler for adding a network URL stream from UI.
void	handle_detect_local_sources ()
	Handler for detecting available local sources.
void	handle_show_stream_changed (const QString &name, bool show)
	Handler for stream visibility toggles in UI.
void	handle_backend_event (const QString &text)
	Append a textual message to the "active log" in settings.
void	on_gui_frame (const QString &stream_name, const QImage &image)
	Slot receiving GUI frames from stream tiles.

Public Member Functions
	controller (yodau::backend::stream_manager *mgr, settings_panel *panel, board *zone, QObject *parent=nullptr)
	Construct a controller.
void	init_from_backend ()
	Populate settings UI from backend at startup.

Private Slots
void	on_active_stream_selected (const QString &name)
	Handler for selecting an active stream in settings.
void	on_active_edit_mode_changed (bool drawing_new)
	Handler for toggling active edit mode.
void	on_active_line_params_changed (const QString &name, const QColor &color, bool closed)
	Handler for changes to "new line" draft parameters.
void	on_active_line_save_requested (const QString &name, bool closed)
	Handler for saving a newly drawn draft line.
void	on_active_template_selected (const QString &template_name)
	Handler for selecting a template while in template mode.
void	on_active_template_color_changed (const QColor &color)
	Handler for changing template preview color.
void	on_active_template_add_requested (const QString &template_name, const QColor &color)
	Handler for adding the selected template to the active stream.
void	on_active_line_undo_requested ()
	Handler for undoing last draft point.
void	on_active_labels_enabled_changed (bool on)
	Handler for toggling persistent label visibility in active view.

Private Member Functions
void	setup_settings_connections ()
	Connect settings_panel signals to controller slots.
void	setup_grid_connections ()
	Connect grid_view signals to controller handlers.
void	handle_add_stream_common (const QString &source, const QString &name, const QString &type, bool loop)
	shared implementation for add-stream commands.
void	register_stream_in_ui (const QString &final_name, const QString &source_desc)
	Add newly created backend stream into UI structures.
void	handle_enlarge_requested (const QString &name)
	Handle focus/enlarge requests from grid tiles.
void	handle_back_to_grid ()
	Return to grid mode (clear active stream).
void	handle_thumb_activate (const QString &name)
	Convenience alias for activating a thumbnail stream.
stream_cell *	active_cell_checked (const QString &fail_prefix)
	Get active cell or log a failure.
void	sync_active_persistent ()
	Sync persistent line overlays and template candidates for active stream.
void	apply_template_preview (const QString &template_name)
	Apply a template preview into the active cell draft.
void	log_active (const QString &msg) const
	Append a message to the active log (if settings exists).
void	apply_added_line (stream_cell *cell, const QString &final_name, const std::vector< QPointF > &pts, bool closed)
	Apply effects of a newly added line to UI and state.
void	sync_active_cell_lines () const
	Push per-stream persistent lines into the active UI cell.
QSet< QString >	used_template_names_for_stream (const QString &stream) const
	Collect template names already used by a stream.
QStringList	template_candidates_excluding (const QSet< QString > &used) const
	List templates not present in a given used set.
void	update_repaint_caps ()
	Update repaint interval caps for all visible tiles.
void	update_analysis_caps ()
	Update backend analysis interval based on visible tile count.
void	on_backend_event (const yodau::backend::event &e)
	Handle a single backend event (GUI-thread safe).
void	on_backend_events (const std::vector< yodau::backend::event > &evs)
	Handle a batch of backend events.
stream_cell *	tile_for_stream_name (const QString &name) const
	Resolve a tile widget for a given stream name.
yodau::backend::frame	frame_from_image (const QImage &image) const
	Convert a QImage into backend frame.

Static Private Member Functions
static QString	now_ts ()
	Current wall-clock timestamp as human-readable string.
static QString	points_str_from_pct (const std::vector< QPointF > &pts)
	Convert draft points to backend format string.
static int	repaint_interval_for_count (int n)
	Choose repaint interval given number of visible streams.

Private Attributes
yodau::backend::stream_manager *	stream_mgr { nullptr }
	Backend stream manager (non-owning).
settings_panel *	settings { nullptr }
	Settings panel (non-owning).
board *	main_zone { nullptr }
	Main board/zone widget (non-owning).
grid_view *	grid { nullptr }
	Grid view extracted from board (non-owning).
QString	active_name
	Name of currently active stream (empty if none).
bool	drawing_new_mode { true }
	True if active edit mode is "draw new line".
bool	active_labels_enabled { true }
	Whether labels are enabled in active cell.
QString	draft_line_name
	Draft line name being edited.
QColor	draft_line_color { Qt::red }
	Draft line preview color.
bool	draft_line_closed { false }
	Draft line closed flag.
QMap< QString, tpl_line >	templates
	Template registry keyed by template name.
QMap< QString, std::vector< stream_cell::line_instance > >	per_stream_lines
	Per-stream persistent line instances keyed by stream name.
QMap< QString, QUrl >	stream_sources
	Remembered stream sources (as QUrl) keyed by stream name.
QMap< QString, bool >	stream_loops
	Remembered stream loop flags keyed by stream name.
int	active_interval_ms { 33 }
	Repaint interval for active (focused) stream in ms.
int	idle_interval_ms { 66 }
	Repaint interval for idle grid streams in ms.

Detailed Description

Frontend coordinator for streams, lines, templates, and events.

Responsibilities:

• Initialize settings UI from current backend state.
• Add/remove/show streams in the grid view.
• Manage "active" stream state (focused view and edit mode).
• Convert GUI frames to backend frames and push them for analysis.
• Receive backend events and reflect them visually:
  • motion events -> transient bubbles,
  • tripwire events -> line highlight w/ hit position.
• Maintain in-memory line templates and per-stream line instances.
• Adapt repaint and analysis throttling based on number of visible streams.

Threading:

• Backend events may arrive from worker threads. on_backend_event re-dispatches to the GUI thread when needed using Qt queued invocation.
• All other slots are expected to be called from the GUI thread.

Definition at line 59 of file controller.hpp.

Constructor & Destructor Documentation

controller()

controller::controller ( yodau::backend::stream_manager * mgr, settings_panel * panel, board * zone, QObject * parent = nullptr )

explicit

Construct a controller.

The controller does not take ownership of passed pointers; they must stay alive for the lifetime of this object.

On construction it:

• initializes state from backend,
• installs backend hooks (frame processor, batch event sink, etc.),
• configures initial UI candidates,
• sets up settings/grid signal connections.

Parameters

mgr	Backend stream manager (may be null; controller becomes inert).
panel	Settings panel for stream/line/forms (may be null).
zone	Main board widget (may be null).
parent	QObject parent.

Definition at line 25 of file controller.cpp.

    : QObject(parent)
    , stream_mgr(mgr)
    , settings(panel)
    , main_zone(zone)
    , grid(zone ? zone->grid_mode() : nullptr) {
 
    init_from_backend();
 
    if (stream_mgr) {
        stream_mgr->set_analysis_interval_ms(66);
#ifdef YODAU_OPENCV
        stream_mgr->set_frame_processor(
            yodau::backend::opencv_motion_processor
        );
#else
        stream_mgr->set_frame_processor([](const yodau::backend::stream& s,
                                           const yodau::backend::frame& f) {
            Q_UNUSED(s);
            Q_UNUSED(f);
            return std::vector<yodau::backend::event> {};
        });
#endif
        stream_mgr->set_event_batch_sink(
            [this](const std::vector<yodau::backend::event>& evs) {
                on_backend_events(evs);
            }
        );
    }
 
    if (settings && grid) {
        settings->set_active_candidates(grid->stream_names());
        settings->set_active_current(QString());
    }
 
    setup_settings_connections();
    setup_grid_connections();
}

References grid, board::grid_mode(), init_from_backend(), main_zone, settings, setup_grid_connections(), setup_settings_connections(), and stream_mgr.

Here is the call graph for this function:

Member Function Documentation

active_cell_checked()

stream_cell * controller::active_cell_checked ( const QString & fail_prefix )

private

Get active cell or log a failure.

Parameters

fail_prefix

Prefix for log messages when lookup fails.

Returns

Active stream cell, or nullptr.

Definition at line 613 of file controller.cpp.

                                                                       {
    if (!stream_mgr || !main_zone || active_name.isEmpty()) {
        if (settings) {
            settings->append_active_log(
                QString("%1 failed: no active stream").arg(fail_prefix)
            );
        }
        return nullptr;
    }
 
    auto* cell = main_zone->active_cell();
    if (!cell) {
        if (settings) {
            settings->append_active_log(
                QString("%1 failed: active cell not found").arg(fail_prefix)
            );
        }
        return nullptr;
    }
 
    return cell;
}

References board::active_cell(), main_zone, and settings.

Here is the call graph for this function:

apply_added_line()

void controller::apply_added_line ( stream_cell * cell, const QString & final_name, const std::vector< QPointF > & pts, bool closed )

private

Apply effects of a newly added line to UI and state.

Adds persistent line instance, registers as template, connects to backend, resets draft form, and refreshes template candidates.

Parameters

cell	Active cell.
final_name	Backend-resolved line name.
pts	Draft points.
closed	Closed flag.

Definition at line 695 of file controller.cpp.

  {
    stream_cell::line_instance inst;
    inst.template_name = final_name;
    inst.color = draft_line_color;
    inst.closed = closed;
    inst.pts_pct = pts;
 
    per_stream_lines[active_name].push_back(inst);
    cell->add_persistent_line(inst);
 
    templates[final_name] = tpl_line { pts, closed };
 
    stream_mgr->set_line(active_name.toStdString(), final_name.toStdString());
 
    cell->clear_draft();
    cell->set_draft_params(QString(), QColor(Qt::red), false);
 
    draft_line_name.clear();
    draft_line_color = Qt::red;
    draft_line_closed = false;
 
    if (settings) {
        settings->reset_active_line_form();
        settings->add_template_candidate(final_name);
        settings->reset_active_template_form();
    }
 
    log_active(
        QString("line added: %1 (%2 points)").arg(final_name).arg(pts.size())
    );
 
    sync_active_persistent();
}

References stream_cell::clear_draft(), draft_line_closed, settings_panel::reset_active_line_form(), settings_panel::reset_active_template_form(), settings, and sync_active_persistent().

Here is the call graph for this function:

apply_template_preview()

void controller::apply_template_preview ( const QString & template_name )

private

Apply a template preview into the active cell draft.

Clears existing draft, loads template points, and applies preview color.

Parameters

template_name

Template to preview.

Definition at line 654 of file controller.cpp.

                                                                    {
    if (!main_zone) {
        return;
    }
    auto* cell = main_zone->active_cell();
    if (!cell) {
        return;
    }
 
    cell->clear_draft();
 
    if (template_name.isEmpty() || !templates.contains(template_name)) {
        return;
    }
 
    const auto tpl = templates.value(template_name);
 
    QColor c = Qt::red;
    if (settings) {
        c = settings->active_template_preview_color();
    }
 
    cell->set_draft_params(template_name, c, tpl.closed);
    cell->set_draft_points_pct(tpl.pts_pct);
}

References board::active_cell(), stream_cell::clear_draft(), main_zone, and settings.

Here is the call graph for this function:

frame_from_image()

yodau::backend::frame controller::frame_from_image ( const QImage & image ) const

private

Convert a QImage into backend frame.

Ensures RGB888 format and fills yodau::backend::frame fields.

Parameters

image

GUI image.

Returns

Backend frame copy.

Definition at line 834 of file controller.cpp.

                                                                        {
    QImage img = image;
 
    if (img.format() != QImage::Format_RGB888) {
        img = img.convertToFormat(QImage::Format_RGB888);
    }
 
    yodau::backend::frame f;
    f.width = img.width();
    f.height = img.height();
    f.stride = static_cast<int>(img.bytesPerLine());
    f.format = yodau::backend::pixel_format::rgb24;
    f.ts = std::chrono::steady_clock::now();
 
    const auto* ptr = img.constBits();
    const int bytes = static_cast<int>(img.sizeInBytes());
    if (ptr && bytes > 0) {
        f.data.assign(ptr, ptr + bytes);
    }
 
    return f;
}

References yodau::backend::frame::format, yodau::backend::frame::height, yodau::backend::rgb24, yodau::backend::frame::stride, and yodau::backend::frame::width.

handle_add_file

void controller::handle_add_file ( const QString & path, const QString & name, bool loop )

slot

Handler for adding a file stream from UI.

Delegates to handle_add_stream_common with type "file".

Parameters

path	Local filesystem path to media.
name	Optional desired stream name.
loop	Whether playback should loop at end-of-file.

Definition at line 106 of file controller.cpp.

  {
    handle_add_stream_common(path, name, "file", loop);
}

handle_add_local

void controller::handle_add_local ( const QString & source, const QString & name )

slot

Handler for adding a local capture device from UI.

Delegates to handle_add_stream_common with type "local".

Parameters

source	Device path/id (e.g., "/dev/video0").
name	Optional desired stream name.

Definition at line 112 of file controller.cpp.

                                                                            {
    handle_add_stream_common(source, name, "local", true);
}

handle_add_stream_common()

void controller::handle_add_stream_common ( const QString & source, const QString & name, const QString & type, bool loop )

private

shared implementation for add-stream commands.

Performs validation (for urls), adds stream to backend, stores its source/loop flags, logs to UI, and registers in settings.

Parameters

source	Path/URL/device.
name	Optional desired name.
type	Type string passed to backend ("file","local","url").
loop	Loop flag.

Definition at line 507 of file controller.cpp.

  {
    if (!stream_mgr || !settings) {
        return;
    }
 
    const auto ts = now_ts();
 
    if (type == "url") {
        const QUrl url(source);
        const auto scheme = url.scheme().toLower();
 
        if (!url.isValid() || scheme.isEmpty()) {
            settings->append_add_log(
                QString("[%1] error: invalid url '%2'").arg(ts, source)
            );
            return;
        }
 
        if (scheme != "rtsp" && scheme != "http" && scheme != "https") {
            settings->append_add_log(
                QString("[%1] error: unsupported url scheme '%2'")
                    .arg(ts, scheme)
            );
            return;
        }
    }
 
    try {
        const auto& s = stream_mgr->add_stream(
            source.toStdString(), name.toStdString(), type.toStdString(), loop
        );
 
        const auto final_name = QString::fromStdString(s.get_name());
        const auto source_desc = QString("%1:%2").arg(type, source);
 
        QUrl url;
        if (type == "file" || type == "local") {
            url = QUrl::fromLocalFile(source);
        } else {
            url = QUrl(source);
        }
        stream_sources[final_name] = url;
        stream_loops[final_name] = loop;
 
        settings->append_add_log(
            QString("[%1] ok: added %2 as %3").arg(ts, source_desc, final_name)
        );
 
        register_stream_in_ui(final_name, source_desc);
    } catch (const std::exception& e) {
        settings->append_add_log(
            QString("[%1] error: add %2 failed: %3").arg(ts, type, e.what())
        );
    }
}

References settings, and stream_mgr.

handle_add_url

void controller::handle_add_url ( const QString & url, const QString & name )

slot

Handler for adding a network URL stream from UI.

Validates scheme and delegates to handle_add_stream_common with type "url".

Parameters

url	Stream URL (rtsp/http/https).
name	Optional desired stream name.

Definition at line 116 of file controller.cpp.

                                                                       {
    handle_add_stream_common(url, name, "url", true);
}

handle_back_to_grid()

void controller::handle_back_to_grid ( )

private

Return to grid mode (clear active stream).

Definition at line 601 of file controller.cpp.

                                     {
    on_active_stream_selected(QString());
 
    if (settings) {
        settings->set_active_current(QString());
    }
}

References settings.

Referenced by handle_enlarge_requested().

Here is the caller graph for this function:

handle_backend_event

void controller::handle_backend_event ( const QString & text )

slot

Append a textual message to the "active log" in settings.

Used for general backend/UI status messages.

Parameters

text	Message to append.

Definition at line 200 of file controller.cpp.

                                                         {
    if (settings) {
        settings->append_active_log(text);
    }
}

References settings.

handle_detect_local_sources

void controller::handle_detect_local_sources ( )

slot

Handler for detecting available local sources.

Invokes backend local discovery and updates the UI list of local sources.

Definition at line 120 of file controller.cpp.

                                             {
    if (!stream_mgr || !settings) {
        return;
    }
 
    const auto ts = now_ts();
    stream_mgr->refresh_local_streams();
 
    QStringList locals;
    const auto backend_names = stream_mgr->stream_names();
    for (const auto& n : backend_names) {
        const auto qn = QString::fromStdString(n);
        if (qn.startsWith("video")) {
            locals << qn;
        }
    }
 
    settings->set_local_sources(locals);
    settings->append_add_log(
        QString("[%1] ok: detected %2 local sources").arg(ts).arg(locals.size())
    );
 
    const auto cams = QMediaDevices::videoInputs();
    // for (int i = 0; i < cams.size(); ++i) {
    //     const auto& c = cams[i];
    // }
}

References settings, and stream_mgr.

Referenced by main_window::main_window().

Here is the caller graph for this function:

handle_enlarge_requested()

void controller::handle_enlarge_requested ( const QString & name )

private

Handle focus/enlarge requests from grid tiles.

Toggles active view for the given stream.

Definition at line 584 of file controller.cpp.

                                                             {
    if (name.isEmpty()) {
        return;
    }
 
    if (!active_name.isEmpty() && active_name == name) {
        handle_back_to_grid();
        return;
    }
 
    on_active_stream_selected(name);
 
    if (settings) {
        settings->set_active_current(name);
    }
}

References handle_back_to_grid(), and settings.

Here is the call graph for this function:

handle_show_stream_changed

void controller::handle_show_stream_changed ( const QString & name, bool show )

slot

Handler for stream visibility toggles in UI.

When show is true:

• adds stream tile to grid,
• configures its source/loop based on backend stream type,
• installs persistent line overlays,
• connects tile frame_ready to on_gui_frame.

When false:

• removes tile from grid,
• also clears active view if this stream was active.

Updates repaint + analysis caps after change.

Parameters

name	Stream name.
show	Whether to show or hide it.

Definition at line 148 of file controller.cpp.

  {
    if (!grid) {
        return;
    }
 
    if (show) {
        grid->add_stream(name);
        if (auto* tile = grid->peek_stream_cell(name)) {
            connect(
                tile, &stream_cell::frame_ready, this,
                &controller::on_gui_frame, Qt::UniqueConnection
            );
            tile->set_persistent_lines(per_stream_lines.value(name));
 
            const auto s = stream_mgr->find_stream(name.toStdString());
            if (s) {
                tile->set_loop(s->is_looping());
                const auto path = QString::fromStdString(s->get_path());
                const auto type = s->get_type();
 
                if (type == yodau::backend::stream_type::local) {
                    tile->set_camera_id(path.toUtf8());
                } else if (type == yodau::backend::stream_type::file) {
                    tile->set_source(QUrl::fromLocalFile(path));
                } else {
                    tile->set_source(QUrl(path));
                }
            }
        }
    } else {
        grid->remove_stream(name);
        if (!active_name.isEmpty() && active_name == name && main_zone) {
            if (auto* cell = main_zone->take_active_cell()) {
                cell->deleteLater();
            }
            active_name.clear();
            if (settings) {
                settings->set_active_current(QString());
            }
        }
    }
 
    if (settings) {
        settings->set_active_candidates(grid->stream_names());
    }
 
    update_repaint_caps();
    update_analysis_caps();
}

References grid_view::add_stream(), yodau::backend::file, grid, yodau::backend::local, main_zone, grid_view::peek_stream_cell(), grid_view::remove_stream(), stream_cell::set_loop(), settings, stream_mgr, board::take_active_cell(), update_analysis_caps(), and update_repaint_caps().

Here is the call graph for this function:

handle_thumb_activate()

void controller::handle_thumb_activate ( const QString & name )

private

Convenience alias for activating a thumbnail stream.

Definition at line 609 of file controller.cpp.

                                                          {
    handle_enlarge_requested(name);
}

init_from_backend()

void controller::init_from_backend

(

)

Populate settings UI from backend at startup.

Reads stream list from backend, adds them to settings panel, and registers them as existing names to prevent duplicates.

Safe to call multiple times; it will re-add current backend streams.

Definition at line 77 of file controller.cpp.

                                   {
    if (!stream_mgr || !settings) {
        return;
    }
 
    QSet<QString> names;
 
    const auto backend_names = stream_mgr->stream_names();
    for (auto& n : backend_names) {
        const auto qname = QString::fromStdString(n);
        names.insert(qname);
 
        QString desc = str_label("<unknown>");
        const auto s = stream_mgr->find_stream(n);
        if (s) {
            // const auto t = s->get_type();
            const auto path = QString::fromStdString(s->get_path());
            const auto type = QString::fromStdString(
                yodau::backend::stream::type_name(s->get_type())
            );
            desc = QString("%1:%2").arg(type, path);
        }
 
        settings->add_stream_entry(qname, desc);
    }
 
    settings->set_existing_names(names);
}

References settings, and stream_mgr.

Referenced by controller().

Here is the caller graph for this function:

log_active()

void controller::log_active ( const QString & msg ) const

private

Append a message to the active log (if settings exists).

Definition at line 680 of file controller.cpp.

                                                    {
    if (settings) {
        settings->append_active_log(msg);
    }
}

References settings.

now_ts()

QString controller::now_ts ( )

staticprivate

Current wall-clock timestamp as human-readable string.

Used for log messages.

Returns

Timestamp like "HH:mm:ss".

Definition at line 580 of file controller.cpp.

                           {
    return QDateTime::currentDateTime().toString("HH:mm:ss");
}

on_active_edit_mode_changed

void controller::on_active_edit_mode_changed ( bool drawing_new )

privateslot

Handler for toggling active edit mode.

When drawing_new is true, user draws a new line. Otherwise user previews/templates existing lines.

Parameters

drawing_new

New edit mode flag.

Definition at line 239 of file controller.cpp.

                                                             {
    drawing_new_mode = drawing_new;
 
    if (!main_zone) {
        return;
    }
 
    if (auto* cell = main_zone->active_cell()) {
        cell->clear_draft();
        cell->set_drawing_enabled(drawing_new);
 
        if (drawing_new) {
            cell->set_draft_params(
                draft_line_name, draft_line_color, draft_line_closed
            );
        } else if (settings) {
            apply_template_preview(settings->active_template_current());
        }
    }
 
    if (settings) {
        settings->append_active_log(
            QString("edit mode: %1")
                .arg(drawing_new ? "draw new" : "use template")
        );
    }
}

References board::active_cell(), stream_cell::clear_draft(), drawing_new_mode, main_zone, stream_cell::set_drawing_enabled(), and settings.

Referenced by setup_settings_connections().

Here is the call graph for this function:

Here is the caller graph for this function:

on_active_labels_enabled_changed

void controller::on_active_labels_enabled_changed ( bool on )

privateslot

Handler for toggling persistent label visibility in active view.

Parameters

on	True to enable labels.

Definition at line 427 of file controller.cpp.

                                                         {
    active_labels_enabled = on;
 
    if (!main_zone) {
        return;
    }
 
    if (auto* cell = main_zone->active_cell()) {
        cell->set_labels_enabled(active_labels_enabled);
    }
}

References board::active_cell(), active_labels_enabled, main_zone, and stream_cell::set_labels_enabled().

Referenced by setup_settings_connections().

Here is the call graph for this function:

Here is the caller graph for this function:

on_active_line_params_changed

void controller::on_active_line_params_changed ( const QString & name, const QColor & color, bool closed )

privateslot

Handler for changes to "new line" draft parameters.

Stores parameters locally and applies them to active cell draft.

Parameters

name	Draft line name.
color	Draft line color.
closed	Draft closed flag.

Definition at line 267 of file controller.cpp.

  {
    draft_line_name = name;
    draft_line_color = color;
    draft_line_closed = closed;
 
    if (main_zone) {
        if (auto* cell = main_zone->active_cell()) {
            cell->set_draft_params(
                draft_line_name, draft_line_color, draft_line_closed
            );
        }
    }
 
    if (settings) {
        settings->append_active_log(
            QString("active line params: name='%1' color=%2 closed=%3")
                .arg(draft_line_name)
                .arg(draft_line_color.name())
                .arg(draft_line_closed ? "true" : "false")
        );
    }
}

References board::active_cell(), draft_line_closed, main_zone, and settings.

Here is the call graph for this function:

on_active_line_save_requested

void controller::on_active_line_save_requested ( const QString & name, bool closed )

privateslot

Handler for saving a newly drawn draft line.

Reads draft points from active cell, converts to string, adds line to backend, connects it to the active stream, and updates UI state.

Parameters

name	Desired line name (may be auto-resolved by backend).
closed	Whether line is closed.

Definition at line 292 of file controller.cpp.

  {
    log_active(QString("save click: name='%1' closed=%2 active='%3'")
                   .arg(name)
                   .arg(closed ? "true" : "false")
                   .arg(active_name));
 
    auto* cell = active_cell_checked("add line");
    if (!cell) {
        return;
    }
 
    const auto pts = cell->draft_points_pct();
    if (pts.size() < 2) {
        log_active("add line failed: need at least 2 points");
        return;
    }
 
    const auto points_str = points_str_from_pct(pts);
    log_active(QString("points_str = %1").arg(points_str));
 
    try {
        const auto lp = stream_mgr->add_line(
            points_str.toStdString(), closed, name.toStdString()
        );
 
        const auto final_name = QString::fromStdString(lp->name);
        apply_added_line(cell, final_name, pts, closed);
    } catch (const std::exception& e) {
        log_active(QString("add line failed: %1").arg(e.what()));
    }
}

References stream_mgr.

on_active_line_undo_requested

void controller::on_active_line_undo_requested ( )

privateslot

Handler for undoing last draft point.

Removes last draft vertex from active cell.

Definition at line 408 of file controller.cpp.

                                               {
    if (!main_zone) {
        return;
    }
 
    auto* cell = main_zone->active_cell();
    if (!cell) {
        return;
    }
 
    auto pts = cell->draft_points_pct();
    if (pts.empty()) {
        return;
    }
 
    pts.pop_back();
    cell->set_draft_points_pct(pts);
}

References board::active_cell(), and main_zone.

Referenced by setup_settings_connections().

Here is the call graph for this function:

Here is the caller graph for this function:

on_active_stream_selected

void controller::on_active_stream_selected ( const QString & name )

privateslot

Handler for selecting an active stream in settings.

Moves the stream cell into the active container (or clears active view), applies edit mode settings, and refreshes persistent lines/templates.

Parameters

name	Stream name to activate, or empty to deactivate.

Definition at line 206 of file controller.cpp.

                                                              {
    if (!main_zone) {
        return;
    }
 
    active_name = name;
 
    if (name.isEmpty()) {
        main_zone->clear_active();
    } else {
        main_zone->set_active_stream(name);
    }
 
    if (auto* cell = main_zone->active_cell()) {
        cell->set_labels_enabled(active_labels_enabled);
 
        cell->clear_draft();
        cell->set_drawing_enabled(drawing_new_mode);
 
        if (drawing_new_mode) {
            cell->set_draft_params(
                draft_line_name, draft_line_color, draft_line_closed
            );
        } else if (settings) {
            apply_template_preview(settings->active_template_current());
        }
    }
 
    sync_active_persistent();
    update_repaint_caps();
    update_analysis_caps();
}

References board::active_cell(), active_labels_enabled, board::clear_active(), stream_cell::clear_draft(), drawing_new_mode, main_zone, board::set_active_stream(), stream_cell::set_drawing_enabled(), stream_cell::set_labels_enabled(), settings, sync_active_persistent(), update_analysis_caps(), and update_repaint_caps().

Here is the call graph for this function:

on_active_template_add_requested

void controller::on_active_template_add_requested ( const QString & template_name, const QColor & color )

privateslot

Handler for adding the selected template to the active stream.

Connects backend line, adds a persistent line instance to UI, and resets template form.

Parameters

template_name	Template to add.
color	Color to render this instance in the active stream.

Definition at line 351 of file controller.cpp.

  {
    auto* cell = active_cell_checked("add template");
    if (!cell) {
        return;
    }
 
    if (!templates.contains(template_name)) {
        if (settings) {
            settings->append_active_log(
                QString("add template failed: unknown template '%1'")
                    .arg(template_name)
            );
        }
        return;
    }
 
    const auto tpl = templates.value(template_name);
 
    try {
        stream_mgr->set_line(
            active_name.toStdString(), template_name.toStdString()
        );
    } catch (const std::exception& e) {
        if (settings) {
            settings->append_active_log(
                QString("add template failed: %1").arg(e.what())
            );
        }
        return;
    }
 
    stream_cell::line_instance inst;
    inst.template_name = template_name;
    inst.color = color;
    inst.closed = tpl.closed;
    inst.pts_pct = tpl.pts_pct;
 
    per_stream_lines[active_name].push_back(inst);
    cell->add_persistent_line(inst);
 
    if (settings) {
        settings->append_active_log(
            QString("template added to active: %1").arg(template_name)
        );
    }
 
    cell->clear_draft();
 
    if (settings) {
        settings->reset_active_template_form();
    }
 
    sync_active_persistent();
}

References settings_panel::reset_active_template_form(), settings, and sync_active_persistent().

Here is the call graph for this function:

on_active_template_color_changed

void controller::on_active_template_color_changed ( const QColor & color )

privateslot

Handler for changing template preview color.

Reapplies template preview with new color (template mode only).

Parameters

color

New preview color.

Definition at line 333 of file controller.cpp.

                                                                     {
    Q_UNUSED(color);
 
    if (drawing_new_mode) {
        return;
    }
    if (!settings) {
        return;
    }
 
    const auto t = settings->active_template_current();
    if (t.isEmpty()) {
        return;
    }
 
    apply_template_preview(t);
}

References drawing_new_mode, and settings.

on_active_template_selected

void controller::on_active_template_selected ( const QString & template_name )

privateslot

Handler for selecting a template while in template mode.

Preview is applied to active cell draft.

Parameters

template_name

Template name.

Definition at line 326 of file controller.cpp.

                                                                         {
    if (drawing_new_mode) {
        return;
    }
    apply_template_preview(template_name);
}

References drawing_new_mode.

on_backend_event()

void controller::on_backend_event ( const yodau::backend::event & e )

private

Handle a single backend event (GUI-thread safe).

Definition at line 866 of file controller.cpp.

                                                            {
    if (QThread::currentThread() != thread()) {
        const auto copy = e;
        QMetaObject::invokeMethod(
            this, [this, copy]() { on_backend_event(copy); },
            Qt::QueuedConnection
        );
        return;
    }
 
    const auto name = QString::fromStdString(e.stream_name);
    auto* tile = tile_for_stream_name(name);
    if (!tile) {
        return;
    }
 
    if (!e.pos_pct.has_value()) {
        return;
    }
 
    if (e.kind == yodau::backend::event_kind::tripwire) {
        if (!e.line_name.empty()) {
            const auto ln = QString::fromStdString(e.line_name);
            const auto& p = *e.pos_pct;
            tile->highlight_line_at(ln, QPointF(p.x, p.y));
        }
    }
 
    const auto& p = *e.pos_pct;
    tile->add_event(QPointF(p.x, p.y), Qt::gray);
}

References yodau::backend::event::kind, yodau::backend::event::line_name, and yodau::backend::tripwire.

on_backend_events()

void controller::on_backend_events ( const std::vector< yodau::backend::event > & evs )

private

Handle a batch of backend events.

Definition at line 794 of file controller.cpp.

  {
    for (const auto& e : evs) {
        on_backend_event(e);
    }
}

on_gui_frame

void controller::on_gui_frame ( const QString & stream_name, const QImage & image )

slot

Slot receiving GUI frames from stream tiles.

Converts a QImage to backend yodau::backend::frame and pushes it to the backend for analysis.

Parameters

stream_name	Stream name.
image	Latest frame from GUI.

Definition at line 857 of file controller.cpp.

                                                                             {
    if (!stream_mgr) {
        return;
    }
 
    auto f = frame_from_image(image);
    stream_mgr->push_frame(stream_name.toStdString(), std::move(f));
}

References stream_mgr.

points_str_from_pct()

QString controller::points_str_from_pct ( const std::vector< QPointF > & pts )

staticprivate

Convert draft points to backend format string.

Output is parsable by backend yodau::backend::parse_points.

Parameters

pts	Percentage points.

Returns

String like "(x,y); (x,y); ...".

Definition at line 686 of file controller.cpp.

                                                                     {
    QStringList parts;
    parts.reserve(static_cast<int>(pts.size()));
    for (const auto& p : pts) {
        parts << QString("(%1,%2)").arg(p.x(), 0, 'f', 3).arg(p.y(), 0, 'f', 3);
    }
    return parts.join("; ");
}

register_stream_in_ui()

void controller::register_stream_in_ui ( const QString & final_name, const QString & source_desc )

private

Add newly created backend stream into UI structures.

Updates settings entries and refreshes repaint/analysis caps.

Parameters

final_name	Actual backend name used for stream.
source_desc	Human-readable source description.

Definition at line 565 of file controller.cpp.

  {
    if (!settings) {
        return;
    }
 
    settings->add_existing_name(final_name);
    settings->add_stream_entry(final_name, source_desc);
    settings->clear_add_inputs();
 
    update_repaint_caps();
    update_analysis_caps();
}

References settings_panel::clear_add_inputs(), settings, update_analysis_caps(), and update_repaint_caps().

Here is the call graph for this function:

repaint_interval_for_count()

int controller::repaint_interval_for_count ( int n )

staticprivate

Choose repaint interval given number of visible streams.

Parameters

n	Visible stream count.

Returns

Interval in ms.

Definition at line 802 of file controller.cpp.

                                                      {
    if (n <= 2) {
        return 33;
    }
 
    if (n <= 4) {
        return 66;
    }
 
    if (n <= 9) {
        return 100;
    }
 
    return 166;
}

Referenced by update_analysis_caps(), and update_repaint_caps().

Here is the caller graph for this function:

setup_grid_connections()

void controller::setup_grid_connections ( )

private

Connect grid_view signals to controller handlers.

Definition at line 490 of file controller.cpp.

                                        {
    if (!grid) {
        return;
    }
 
    connect(grid, &grid_view::stream_closed, this, [this](const QString& name) {
        if (settings) {
            settings->set_stream_checked(name, false);
        }
    });
 
    connect(
        grid, &grid_view::stream_enlarge, this,
        &controller::handle_enlarge_requested
    );
}

References grid, grid_view::grid_view(), and grid_view::stream_enlarge().

Referenced by controller().

Here is the call graph for this function:

Here is the caller graph for this function:

setup_settings_connections()

void controller::setup_settings_connections ( )

private

Connect settings_panel signals to controller slots.

Definition at line 439 of file controller.cpp.

                                            {
    if (!settings || !main_zone) {
        return;
    }
 
    connect(
        settings, &settings_panel::active_stream_selected, this,
        &controller::on_active_stream_selected
    );
 
    connect(
        settings, &settings_panel::active_edit_mode_changed, this,
        &controller::on_active_edit_mode_changed
    );
 
    connect(
        settings, &settings_panel::active_line_params_changed, this,
        &controller::on_active_line_params_changed
    );
 
    connect(
        settings, &settings_panel::active_line_save_requested, this,
        &controller::on_active_line_save_requested
    );
 
    connect(
        settings, &settings_panel::active_template_add_requested, this,
        &controller::on_active_template_add_requested
    );
 
    connect(
        settings, &settings_panel::active_template_selected, this,
        &controller::on_active_template_selected
    );
 
    connect(
        settings, &settings_panel::active_template_color_changed, this,
        &controller::on_active_template_color_changed
    );
 
    connect(
        settings, &settings_panel::active_line_undo_requested, this,
        &controller::on_active_line_undo_requested
    );
 
    connect(
        settings, &settings_panel::active_labels_enabled_changed, this,
        &controller::on_active_labels_enabled_changed
    );
}

References settings_panel::active_edit_mode_changed(), settings_panel::active_labels_enabled_changed(), settings_panel::active_line_undo_requested(), main_zone, on_active_edit_mode_changed(), on_active_labels_enabled_changed(), on_active_line_undo_requested(), per_stream_lines, settings, and settings_panel::settings_panel().

Referenced by controller().

Here is the call graph for this function:

Here is the caller graph for this function:

sync_active_cell_lines()

void controller::sync_active_cell_lines ( ) const

private

Push per-stream persistent lines into the active UI cell.

Definition at line 732 of file controller.cpp.

                                              {
    if (!main_zone) {
        return;
    }
 
    if (auto* cell = main_zone->active_cell()) {
        cell->set_persistent_lines(per_stream_lines.value(active_name));
    }
}

References board::active_cell(), and main_zone.

Referenced by sync_active_persistent().

Here is the call graph for this function:

Here is the caller graph for this function:

sync_active_persistent()

void controller::sync_active_persistent ( )

private

Sync persistent line overlays and template candidates for active stream.

Definition at line 636 of file controller.cpp.

                                        {
    if (!main_zone || active_name.isEmpty()) {
        if (settings) {
            settings->set_template_candidates({});
        }
        return;
    }
 
    sync_active_cell_lines();
 
    if (!settings) {
        return;
    }
 
    const auto used = used_template_names_for_stream(active_name);
    settings->set_template_candidates(template_candidates_excluding(used));
}

References settings, and sync_active_cell_lines().

Referenced by apply_added_line(), on_active_stream_selected(), and on_active_template_add_requested().

Here is the call graph for this function:

Here is the caller graph for this function:

template_candidates_excluding()

QStringList controller::template_candidates_excluding ( const QSet< QString > & used ) const

private

List templates not present in a given used set.

Parameters

used	Already used names.

Returns

Candidate list.

Definition at line 758 of file controller.cpp.

                                                                         {
    QStringList candidates;
    candidates.reserve(templates.size());
 
    for (auto it = templates.begin(); it != templates.end(); ++it) {
        const QString name = it.key();
        if (!used.contains(name)) {
            candidates << name;
        }
    }
 
    return candidates;
}

tile_for_stream_name()

stream_cell * controller::tile_for_stream_name ( const QString & name ) const

private

Resolve a tile widget for a given stream name.

Prefers active cell if it matches name, otherwise looks in grid.

Parameters

name	Stream name.

Returns

Stream cell pointer or nullptr.

Definition at line 818 of file controller.cpp.

                                                                       {
    if (main_zone && !active_name.isEmpty() && active_name == name) {
        if (auto* cell = main_zone->active_cell()) {
            return cell;
        }
    }
 
    if (grid) {
        if (auto* tile = grid->peek_stream_cell(name)) {
            return tile;
        }
    }
 
    return nullptr;
}

References board::active_cell(), grid, main_zone, and grid_view::peek_stream_cell().

Here is the call graph for this function:

update_analysis_caps()

void controller::update_analysis_caps ( )

private

Update backend analysis interval based on visible tile count.

Definition at line 67 of file controller.cpp.

                                      {
    if (!stream_mgr || !grid) {
        return;
    }
 
    const int n = static_cast<int>(grid->stream_names().size());
    const int interval = repaint_interval_for_count(n);
    stream_mgr->set_analysis_interval_ms(interval);
}

References grid, repaint_interval_for_count(), and stream_mgr.

Referenced by handle_show_stream_changed(), on_active_stream_selected(), and register_stream_in_ui().

Here is the call graph for this function:

Here is the caller graph for this function:

update_repaint_caps()

void controller::update_repaint_caps ( )

private

Update repaint interval caps for all visible tiles.

Definition at line 772 of file controller.cpp.

                                     {
    if (!grid) {
        return;
    }
 
    const auto names = grid->stream_names();
    const int n = static_cast<int>(names.size());
    const int interval = repaint_interval_for_count(n);
 
    for (const auto& name : names) {
        if (auto* tile = grid->peek_stream_cell(name)) {
            tile->set_repaint_interval_ms(interval);
        }
    }
 
    if (!active_name.isEmpty()) {
        if (auto* cell = grid->peek_stream_cell(active_name)) {
            cell->set_repaint_interval_ms(active_interval_ms);
        }
    }
}

References active_interval_ms, grid, and repaint_interval_for_count().

Referenced by handle_show_stream_changed(), on_active_stream_selected(), and register_stream_in_ui().

Here is the call graph for this function:

Here is the caller graph for this function:

used_template_names_for_stream()

QSet< QString > controller::used_template_names_for_stream ( const QString & stream ) const

private

Collect template names already used by a stream.

Parameters

stream

Stream name.

Returns

Set of used template names.

Definition at line 743 of file controller.cpp.

                                                                      {
    QSet<QString> used;
 
    const auto current_lines = per_stream_lines.value(stream);
    for (const auto& inst : current_lines) {
        const auto tn = inst.template_name.trimmed();
        if (!tn.isEmpty()) {
            used.insert(tn);
        }
    }
 
    return used;
}

Member Data Documentation

active_interval_ms

int controller::active_interval_ms { 33 }

private

Repaint interval for active (focused) stream in ms.

Definition at line 523 of file controller.hpp.

{ 33 };

Referenced by update_repaint_caps().

active_labels_enabled

bool controller::active_labels_enabled { true }

private

Whether labels are enabled in active cell.

Definition at line 482 of file controller.hpp.

{ true };

Referenced by on_active_labels_enabled_changed(), and on_active_stream_selected().

active_name

QString controller::active_name

private

Name of currently active stream (empty if none).

Definition at line 476 of file controller.hpp.

draft_line_closed

bool controller::draft_line_closed { false }

private

Draft line closed flag.

Definition at line 491 of file controller.hpp.

{ false };

Referenced by apply_added_line(), and on_active_line_params_changed().

draft_line_color

QColor controller::draft_line_color { Qt::red }

private

Draft line preview color.

Definition at line 488 of file controller.hpp.

{ Qt::red };

draft_line_name

QString controller::draft_line_name

private

Draft line name being edited.

Definition at line 485 of file controller.hpp.

drawing_new_mode

bool controller::drawing_new_mode { true }

private

True if active edit mode is "draw new line".

Definition at line 479 of file controller.hpp.

{ true };

Referenced by on_active_edit_mode_changed(), on_active_stream_selected(), on_active_template_color_changed(), and on_active_template_selected().

grid

grid_view* controller::grid { nullptr }

private

Grid view extracted from board (non-owning).

Definition at line 471 of file controller.hpp.

{ nullptr };

Referenced by controller(), handle_show_stream_changed(), setup_grid_connections(), tile_for_stream_name(), update_analysis_caps(), and update_repaint_caps().

idle_interval_ms

int controller::idle_interval_ms { 66 }

private

Repaint interval for idle grid streams in ms.

Definition at line 526 of file controller.hpp.

{ 66 };

main_zone

board* controller::main_zone { nullptr }

private

Main board/zone widget (non-owning).

Definition at line 468 of file controller.hpp.

{ nullptr };

Referenced by active_cell_checked(), apply_template_preview(), controller(), handle_show_stream_changed(), on_active_edit_mode_changed(), on_active_labels_enabled_changed(), on_active_line_params_changed(), on_active_line_undo_requested(), on_active_stream_selected(), setup_settings_connections(), sync_active_cell_lines(), and tile_for_stream_name().

per_stream_lines

QMap<QString, std::vector<stream_cell::line_instance> > controller::per_stream_lines

private

Per-stream persistent line instances keyed by stream name.

Each instance carries its own color and closed flag for rendering.

Definition at line 514 of file controller.hpp.

Referenced by main_window::main_window(), and setup_settings_connections().

settings

settings_panel* controller::settings { nullptr }

private

Settings panel (non-owning).

Definition at line 465 of file controller.hpp.

{ nullptr };

Referenced by active_cell_checked(), apply_added_line(), apply_template_preview(), controller(), handle_add_stream_common(), handle_back_to_grid(), handle_backend_event(), handle_detect_local_sources(), handle_enlarge_requested(), handle_show_stream_changed(), init_from_backend(), log_active(), on_active_edit_mode_changed(), on_active_line_params_changed(), on_active_stream_selected(), on_active_template_add_requested(), on_active_template_color_changed(), register_stream_in_ui(), setup_settings_connections(), and sync_active_persistent().

stream_loops

QMap<QString, bool> controller::stream_loops

private

Remembered stream loop flags keyed by stream name.

Definition at line 520 of file controller.hpp.

stream_mgr

yodau::backend::stream_manager* controller::stream_mgr { nullptr }

private

Backend stream manager (non-owning).

Definition at line 462 of file controller.hpp.

{ nullptr };

Referenced by controller(), handle_add_stream_common(), handle_detect_local_sources(), handle_show_stream_changed(), init_from_backend(), on_active_line_save_requested(), on_gui_frame(), and update_analysis_caps().

stream_sources

QMap<QString, QUrl> controller::stream_sources

private

Remembered stream sources (as QUrl) keyed by stream name.

Definition at line 517 of file controller.hpp.

templates

QMap<QString, tpl_line> controller::templates

private

Template registry keyed by template name.

Definition at line 507 of file controller.hpp.

---

The documentation for this class was generated from the following files:

• controller.hpp
• controller.cpp