stream_cell Class Reference

Widget representing one video stream cell in the frontend. More...

#include <frontend/include/widgets/stream_cell.hpp>

Inheritance diagram for stream_cell:

Collaboration diagram for stream_cell:

Classes
struct	line_instance
	Instance of a persistent (saved) line to be rendered on the stream. More...
struct	event_instance
	Instance of a transient visual event marker. More...
struct	hit_info
	Hit info attached to a line highlight. More...

Signals
void	request_close (const QString &name)
	Emitted when the user requests closing this stream cell.
void	request_focus (const QString &name)
	Emitted when the user requests focusing/enlarging this cell.
void	frame_ready (const QString &stream_name, const QImage &image)
	Emitted whenever a new frame image becomes available.

Public Member Functions
	stream_cell (const QString &name, QWidget *parent=nullptr)
	Construct a stream cell.
const QString &	get_name () const
	Get logical name of this stream cell.
bool	is_active () const
	Check whether this cell is currently active (focused).
std::vector< QPointF >	draft_points_pct () const
	Get current draft polyline points (percentage coordinates).
bool	draft_closed () const
	Get whether current draft line is closed.
QString	draft_name () const
	Get current draft line name.
QColor	draft_color () const
	Get current draft line color.
bool	is_draft_preview () const
	Check whether the draft is in preview-only mode.
void	set_active (bool val)
	Set active (focused) state.
void	set_drawing_enabled (bool on)
	Enable or disable interactive drawing on this cell.
void	set_draft_params (const QString &name, const QColor &color, bool closed)
	Set draft line parameters (name, color, closed flag).
void	set_draft_points_pct (const std::vector< QPointF > &pts)
	Replace current draft points (percentage coordinates).
void	clear_draft ()
	Clear all draft data (points, hover point, preview flag).
void	set_persistent_lines (const std::vector< line_instance > &lines)
	Replace all persistent lines.
void	add_persistent_line (const line_instance &line)
	Append a persistent line to the list.
void	clear_persistent_lines ()
	Remove all persistent lines.
void	set_draft_preview (bool on)
	Enable or disable draft preview mode.
void	set_labels_enabled (bool on)
	Enable or disable rendering of persistent line labels.
void	set_source (const QUrl &source)
	Set media player source.
void	set_loop (bool on)
	Enable or disable looping for file-based playback.
void	set_camera_id (const QByteArray &id)
	Switch to camera input by device id.
void	add_event (const QPointF &pos_pct, const QColor &color)
	Add a transient event marker.
void	set_repaint_interval_ms (int ms)
	Set minimum repaint interval for video frame updates.
void	highlight_line (const QString &line_name)
	Highlight a persistent line by name.
void	highlight_line_at (const QString &line_name, const QPointF &pos_pct)
	Highlight a line and record a hit position for spatial falloff.

Protected Member Functions
void	paintEvent (QPaintEvent *event) override
	Paint handler.
void	mousePressEvent (QMouseEvent *event) override
	Mouse press handler for drawing draft points.
void	mouseMoveEvent (QMouseEvent *event) override
	Mouse move handler for hover updates while drawing.
void	leaveEvent (QEvent *event) override
	Leave handler to clear hover state.
void	keyPressEvent (QKeyEvent *event) override
	Key press handler for draft undo.

Private Slots
void	on_frame_changed (const QVideoFrame &frame)
	Slot called when the video sink receives a new frame.
void	on_media_status_changed (QMediaPlayer::MediaStatus status)
	Slot called on media status changes.
void	on_player_error (QMediaPlayer::Error error, const QString &error_string)
	Slot called when media player errors occur.
void	on_camera_error (QCamera::Error error)
	Slot called on camera errors.

Private Member Functions
void	build_ui ()
	Build child UI widgets (buttons, sink/player connections).
void	update_icon ()
	Update focus button icon/tooltip based on active state.
void	draw_poly_with_points (QPainter &p, const std::vector< QPointF > &pts_pct, const QColor &color, bool closed, Qt::PenStyle style, qreal width) const
	Draw a polyline/polygon with point markers.
void	draw_persistent (QPainter &p) const
	Draw all persistent lines and their labels/highlights.
void	draw_draft (QPainter &p) const
	Draw the draft line (if any).
void	draw_hover_point (QPainter &p) const
	Draw hover point indicator (if any).
void	draw_hover_coords (QPainter &p) const
	Draw hover coordinate text (if enabled).
void	draw_preview_segment (QPainter &p) const
	Draw preview segment from last draft point to hover point.
void	draw_stream_name (QPainter &p) const
	Draw stream name overlay at top-left.
QPointF	label_pos_px (const line_instance &l) const
	Compute label anchor position for a line in pixel coordinates.
QPointF	to_pct (const QPointF &pos_px) const
	Convert pixel position to percentage coordinates.
QPointF	to_px (const QPointF &pos_pct) const
	Convert percentage coordinates to pixel position.
void	draw_events (QPainter &p)
	Draw transient events and prune expired ones.

Private Attributes
QString	name
	Logical stream name.
QPushButton *	close_btn { nullptr }
	UI close button (top-right).
QPushButton *	focus_btn { nullptr }
	UI focus/enlarge button (top-right).
QLabel *	name_label { nullptr }
	Optional name label (unused in current implementation).
bool	active { false }
	Whether the cell is focused/active.
bool	drawing_enabled { false }
	Whether interactive drawing is enabled.
bool	draft_preview { false }
	Whether draft line is shown in preview mode.
bool	labels_enabled { true }
	Whether persistent line labels are shown when active.
QString	draft_line_name
	Draft line name.
QColor	draft_line_color { Qt::red }
	Draft line color.
bool	draft_line_closed { false }
	Draft line closed flag.
std::vector< QPointF >	draft_line_points_pct
	Draft polyline points in percentage coordinates.
std::optional< QPointF >	hover_point_pct
	Current hover position in percentage coordinates.
std::vector< line_instance >	persistent_lines
	Persisted lines to render.
QMediaPlayer *	player { nullptr }
	Media player for file/URL sources.
QVideoSink *	sink { nullptr }
	Video sink feeding decoded frames into the widget.
QImage	last_frame
	Most recent received frame as an image.
bool	loop_enabled { true }
	Whether playback looping is enabled.
QString	last_error
	Last error string to display when no frame is available.
QCamera *	camera { nullptr }
	Active camera (if using live input).
QMediaCaptureSession *	session { nullptr }
	Capture session binding camera to sink.
QByteArray	camera_id
	Selected camera id.
QVector< event_instance >	events
	Transient events currently displayed.
QElapsedTimer	repaint_timer
	Timer throttling repaint frequency.
int	repaint_interval_ms { 66 }
	Minimum repaint interval in ms.
QHash< QString, QDateTime >	line_highlights
	Line highlight timestamps by line name.
int	line_highlight_ttl_ms { 2500 }
	Highlight time-to-live in ms.
QHash< QString, hit_info >	line_hits
	Optional hit positions per line name.

Detailed Description

Widget representing one video stream cell in the frontend.

A stream cell is a self-contained view of a video source that can be:

• inactive (thumbnail in a grid),
• active (focused/enlarged and optionally editable).

Coordinate system:

• All geometry overlays (draft and persistent lines, events) are stored in percentage coordinates:
  • x,y in range [0.0; 100.0]
  • (0,0) is top-left of the widget
  • (100,100) is bottom-right of the widget

Interaction:

• When drawing is enabled and the cell is active:
  • Left click adds a draft point at cursor position.
  • Mouse move updates hover position (preview segment).
  • Backspace / Ctrl+Z removes last draft point.

Rendering:

• Video frame fills the widget area.
• Persistent lines are drawn solid, with optional labels.
• Draft line is drawn dashed.
• Hover point/coords and preview segments are shown while drawing.
• Recent events are drawn as fading circles.
• Line highlights (by name and optional hit point) animate for a short TTL.

Definition at line 75 of file stream_cell.hpp.

Constructor & Destructor Documentation

stream_cell()

stream_cell::stream_cell ( const QString & name, QWidget * parent = nullptr )

explicit

Construct a stream cell.

Parameters

name	Logical stream name displayed in the widget.
parent	Optional parent widget.

Definition at line 18 of file stream_cell.cpp.

    : QWidget(parent)
    , name(name)
    , close_btn(nullptr)
    , focus_btn(nullptr)
    , name_label(nullptr)
    , player(nullptr)
    , sink(nullptr)
    , camera(nullptr)
    , session(nullptr) {
    build_ui();
    setFocusPolicy(Qt::StrongFocus);
    setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
    repaint_timer.start();
}

References build_ui(), close_btn, focus_btn, and name_label.

Here is the call graph for this function:

Member Function Documentation

add_event()

void stream_cell::add_event	(	const QPointF &	pos_pct,
		const QColor &	color )

Add a transient event marker.

Parameters

pos_pct	Event position in percentage coordinates.
color	Event color.

Definition at line 183 of file stream_cell.cpp.

                                                                       {
    event_instance e;
    e.pos_pct = pos_pct;
    e.color = color;
    e.ts = QDateTime::currentDateTime();
 
    events.push_back(e);
    update();
}

add_persistent_line()

void stream_cell::add_persistent_line

(

const line_instance &

line

)

Append a persistent line to the list.

Parameters

line	Line instance to add.

Definition at line 100 of file stream_cell.cpp.

                                                               {
    persistent_lines.push_back(line);
    update();
}

build_ui()

void stream_cell::build_ui ( )

private

Build child UI widgets (buttons, sink/player connections).

Definition at line 329 of file stream_cell.cpp.

                           {
    const auto root = new QVBoxLayout(this);
    root->setContentsMargins(6, 6, 6, 6);
    root->setSpacing(6);
 
    const auto top_row = new QHBoxLayout();
    top_row->setContentsMargins(0, 0, 0, 0);
    top_row->setSpacing(4);
 
    top_row->addStretch();
 
    focus_btn = new QPushButton(this);
    focus_btn->setFixedSize(24, 24);
    focus_btn->setIconSize(QSize(16, 16));
    focus_btn->setFlat(true);
    focus_btn->setFocusPolicy(Qt::NoFocus);
    update_icon();
    top_row->addWidget(focus_btn);
 
    close_btn = new QPushButton(this);
    close_btn->setFixedSize(24, 24);
    close_btn->setIconSize(QSize(16, 16));
    close_btn->setToolTip(tr("close"));
    close_btn->setFlat(true);
    close_btn->setFocusPolicy(Qt::NoFocus);
 
#if defined(KC_KDE)
    close_btn->setIcon(
        icon_loader::themed(
            { "window-close", "dialog-close", "edit-delete" },
            QStyle::SP_TitleBarCloseButton
        )
    );
#else
    close_btn->setIcon(
        icon_loader::themed(
            { "window-close", "dialog-close" }, QStyle::SP_TitleBarCloseButton
        )
    );
#endif
    top_row->addWidget(close_btn);
    root->addLayout(top_row);
    root->addStretch(1);
 
    sink = new QVideoSink(this);
    connect(
        sink, &QVideoSink::videoFrameChanged, this,
        &stream_cell::on_frame_changed
    );
 
    player = new QMediaPlayer(this);
    player->setVideoOutput(sink);
    // player->setSource(QUrl::fromLocalFile("/home/yarro/Pictures/kino/1080.mp4"));
    // player->play();
 
    connect(close_btn, &QPushButton::clicked, this, [this]() {
        emit request_close(name);
    });
    connect(focus_btn, &QPushButton::clicked, this, [this]() {
        emit request_focus(name);
    });
    connect(
        player, &QMediaPlayer::mediaStatusChanged, this,
        &stream_cell::on_media_status_changed
    );
    connect(
        player, &QMediaPlayer::errorOccurred, this,
        &stream_cell::on_player_error
    );
}

References close_btn, focus_btn, and update_icon().

Referenced by stream_cell().

Here is the call graph for this function:

Here is the caller graph for this function:

clear_draft()

void stream_cell::clear_draft

(

)

Clear all draft data (points, hover point, preview flag).

Definition at line 86 of file stream_cell.cpp.

                              {
    draft_line_points_pct.clear();
    hover_point_pct.reset();
    draft_preview = false;
    update();
}

References draft_preview.

Referenced by controller::apply_added_line(), controller::apply_template_preview(), controller::on_active_edit_mode_changed(), controller::on_active_stream_selected(), and set_active().

Here is the caller graph for this function:

clear_persistent_lines()

void stream_cell::clear_persistent_lines

(

)

Remove all persistent lines.

Definition at line 105 of file stream_cell.cpp.

                                         {
    persistent_lines.clear();
    update();
}

draft_closed()

bool stream_cell::draft_closed ( ) const

nodiscard

Get whether current draft line is closed.

Returns

true if draft is closed.

Definition at line 42 of file stream_cell.cpp.

{ return draft_line_closed; }

References draft_line_closed.

draft_color()

QColor stream_cell::draft_color ( ) const

nodiscard

Get current draft line color.

Returns

Draft color.

Definition at line 46 of file stream_cell.cpp.

{ return draft_line_color; }

draft_name()

QString stream_cell::draft_name ( ) const

nodiscard

Get current draft line name.

Returns

Draft name, may be empty.

Definition at line 44 of file stream_cell.cpp.

{ return draft_line_name; }

draft_points_pct()

std::vector< QPointF > stream_cell::draft_points_pct ( ) const

nodiscard

Get current draft polyline points (percentage coordinates).

Returns

Copy of draft points.

Definition at line 38 of file stream_cell.cpp.

                                                       {
    return draft_line_points_pct;
}

draw_draft()

void stream_cell::draw_draft ( QPainter & p ) const

private

Draw the draft line (if any).

Definition at line 573 of file stream_cell.cpp.

                                              {
    if (draft_line_points_pct.empty()) {
        return;
    }
 
    draw_poly_with_points(
        p, draft_line_points_pct, draft_line_color, draft_line_closed,
        Qt::DashLine, 2.0
    );
}

Referenced by paintEvent().

Here is the caller graph for this function:

draw_events()

void stream_cell::draw_events ( QPainter & p )

private

Draw transient events and prune expired ones.

Definition at line 673 of file stream_cell.cpp.

                                         {
    const auto now = QDateTime::currentDateTime();
    const int ttl_ms = 2000;
 
    const QRect r = rect();
    const double w = static_cast<double>(r.width());
    const double h = static_cast<double>(r.height());
    const double base = std::min(w, h);
    const double radius = base * 0.015;
 
    QVector<event_instance> alive;
    alive.reserve(events.size());
 
    for (const auto& e : events) {
        const int age = static_cast<int>(e.ts.msecsTo(now));
        if (age >= ttl_ms) {
            continue;
        }
 
        alive.push_back(e);
 
        const double k = 1.0 - static_cast<double>(age) / ttl_ms;
        int a = static_cast<int>(120.0 * k);
        if (a < 0) {
            a = 0;
        }
 
        QColor c = e.color;
        c.setAlpha(a);
 
        const double x = r.left() + w * (e.pos_pct.x() / 100.0);
        const double y = r.top() + h * (e.pos_pct.y() / 100.0);
 
        p.setPen(Qt::NoPen);
        p.setBrush(c);
        p.drawEllipse(QPointF(x, y), radius, radius);
    }
 
    events = std::move(alive);
}

Referenced by paintEvent().

Here is the caller graph for this function:

draw_hover_coords()

void stream_cell::draw_hover_coords ( QPainter & p ) const

private

Draw hover coordinate text (if enabled).

Definition at line 597 of file stream_cell.cpp.

                                                     {
    if (!(hover_point_pct.has_value() && drawing_enabled && active)) {
        return;
    }
 
    const auto& hp = *hover_point_pct;
    QString txt
        = QString("x=%1  y=%2").arg(hp.x(), 0, 'f', 1).arg(hp.y(), 0, 'f', 1);
 
    QRect r = rect().adjusted(6, 6, -6, -6);
    p.setPen(palette().color(QPalette::Text));
    p.drawText(r, Qt::AlignLeft | Qt::AlignBottom, txt);
}

Referenced by paintEvent().

Here is the caller graph for this function:

draw_hover_point()

void stream_cell::draw_hover_point ( QPainter & p ) const

private

Draw hover point indicator (if any).

Definition at line 584 of file stream_cell.cpp.

                                                    {
    if (!hover_point_pct.has_value()) {
        return;
    }
 
    QPen hpen(draft_line_color);
    hpen.setWidthF(1.0);
    hpen.setStyle(Qt::DashLine);
    p.setPen(hpen);
 
    p.drawEllipse(to_px(*hover_point_pct), 4.0, 4.0);
}

Referenced by paintEvent().

Here is the caller graph for this function:

draw_persistent()

void stream_cell::draw_persistent ( QPainter & p ) const

private

Draw all persistent lines and their labels/highlights.

Definition at line 471 of file stream_cell.cpp.

                                                   {
    const auto now = QDateTime::currentDateTime();
 
    for (const auto& l : persistent_lines) {
        const auto key = l.template_name.trimmed();
 
        if (!key.isEmpty() && line_highlights.contains(key)) {
            const int age = static_cast<int>(line_highlights[key].msecsTo(now));
            if (age < line_highlight_ttl_ms) {
                double ktime
                    = 1.0 - static_cast<double>(age) / line_highlight_ttl_ms;
                if (ktime < 0.0) {
                    ktime = 0.0;
                }
 
                const double falloff_pct = 30.0;
                const double base_w = 2.0;
                const double peak_w = 22.0;
 
                bool has_hit = false;
                QPointF hit_pct;
 
                if (line_hits.contains(key)) {
                    const auto& h = line_hits[key];
                    const int hit_age = static_cast<int>(h.ts.msecsTo(now));
                    if (hit_age < line_highlight_ttl_ms) {
                        has_hit = true;
                        hit_pct = h.pos_pct;
                    }
                }
 
                if (!has_hit) {
                    QColor hc = l.color;
                    int a = static_cast<int>(255.0 * ktime);
                    if (a < 0) {
                        a = 0;
                    }
                    hc.setAlpha(a);
 
                    const double w = base_w + (peak_w - base_w) * ktime;
 
                    draw_poly_with_points(
                        p, l.pts_pct, hc, l.closed, Qt::SolidLine, w
                    );
                } else {
                    for (size_t i = 1; i < l.pts_pct.size(); ++i) {
                        const QPointF a_pct = l.pts_pct[i - 1];
                        const QPointF b_pct = l.pts_pct[i];
 
                        const QPointF mid = (a_pct + b_pct) * 0.5;
                        const double dx = mid.x() - hit_pct.x();
                        const double dy = mid.y() - hit_pct.y();
                        double dist = std::sqrt(dx * dx + dy * dy);
 
                        double kspace = 1.0 - dist / falloff_pct;
                        if (kspace < 0.0) {
                            kspace = 0.0;
                        }
 
                        kspace = kspace * kspace;
 
                        const double k = ktime * kspace;
                        if (k <= 0.0) {
                            continue;
                        }
 
                        QColor hc = l.color;
                        int a = static_cast<int>(255.0 * k);
                        if (a < 0) {
                            a = 0;
                        }
                        hc.setAlpha(a);
 
                        const double w = base_w + (peak_w - base_w) * k;
 
                        std::vector<QPointF> seg { a_pct, b_pct };
                        draw_poly_with_points(
                            p, seg, hc, false, Qt::SolidLine, w
                        );
                    }
                }
            }
        }
 
        draw_poly_with_points(
            p, l.pts_pct, l.color, l.closed, Qt::SolidLine, 2.0
        );
 
        if (!(active && labels_enabled)) {
            continue;
        }
 
        const auto text = key;
        if (text.isEmpty()) {
            continue;
        }
 
        p.setPen(l.color);
        p.drawText(label_pos_px(l), text);
    }
}

Referenced by paintEvent().

Here is the caller graph for this function:

draw_poly_with_points()

void stream_cell::draw_poly_with_points ( QPainter & p, const std::vector< QPointF > & pts_pct, const QColor & color, bool closed, Qt::PenStyle style, qreal width ) const

private

Draw a polyline/polygon with point markers.

Points are given in percentage coordinates and projected to widget space.

Parameters

p	Painter to draw with.
pts_pct	Points in percentage coordinates.
color	Stroke color.
closed	Whether to draw polygon instead of polyline.
style	Pen style.
width	Pen width in pixels.

Definition at line 441 of file stream_cell.cpp.

        {
    if (pts_pct.size() < 2) {
        return;
    }
 
    QPen pen(color);
    pen.setWidthF(width);
    pen.setStyle(style);
    p.setPen(pen);
 
    QPolygonF poly;
    poly.reserve(static_cast<int>(pts_pct.size()));
    for (const auto& pt_pct : pts_pct) {
        poly << to_px(pt_pct);
    }
 
    if (closed && poly.size() >= 3) {
        p.drawPolygon(poly);
    } else {
        p.drawPolyline(poly);
    }
 
    for (const auto& pt_px : poly) {
        p.drawEllipse(pt_px, 3.0, 3.0);
    }
}

draw_preview_segment()

void stream_cell::draw_preview_segment ( QPainter & p ) const

private

Draw preview segment from last draft point to hover point.

Definition at line 611 of file stream_cell.cpp.

                                                        {
    if (!(drawing_enabled && active && hover_point_pct.has_value()
          && !draft_line_points_pct.empty())) {
        return;
    }
 
    QPen pen(draft_line_color);
    pen.setWidthF(1.5);
    pen.setStyle(Qt::DashLine);
    p.setPen(pen);
 
    const QPointF last_px = to_px(draft_line_points_pct.back());
    const QPointF hover_px = to_px(*hover_point_pct);
 
    p.drawLine(last_px, hover_px);
 
    if (draft_line_closed && draft_line_points_pct.size() >= 2) {
        const QPointF first_px = to_px(draft_line_points_pct.front());
        p.drawLine(hover_px, first_px);
    }
}

Referenced by paintEvent().

Here is the caller graph for this function:

draw_stream_name()

void stream_cell::draw_stream_name ( QPainter & p ) const

private

Draw stream name overlay at top-left.

Definition at line 633 of file stream_cell.cpp.

                                                    {
    if (name.isEmpty()) {
        return;
    }
 
    QRect r = rect().adjusted(6, 6, -6, -6);
    p.setPen(palette().color(QPalette::Text));
    p.drawText(r, Qt::AlignLeft | Qt::AlignTop, name);
}

Referenced by paintEvent().

Here is the caller graph for this function:

frame_ready

void stream_cell::frame_ready ( const QString & stream_name, const QImage & image )

signal

Emitted whenever a new frame image becomes available.

Useful for forwarding frames to backend processing or snapshots.

Parameters

stream_name	Name of the stream.
image	Converted QImage representing the latest frame.

get_name()

const QString & stream_cell::get_name ( ) const

nodiscard

Get logical name of this stream cell.

Returns

Reference to stored name.

Definition at line 34 of file stream_cell.cpp.

{ return name; }

Referenced by board::set_active_stream().

Here is the caller graph for this function:

highlight_line()

void stream_cell::highlight_line

(

const QString &

line_name

)

Highlight a persistent line by name.

Triggers a temporal highlight animation (thicker/alpha pulse).

Parameters

line_name

Name of the line to highlight.

Definition at line 200 of file stream_cell.cpp.

                                                         {
    if (line_name.isEmpty()) {
        return;
    }
    line_highlights[line_name] = QDateTime::currentDateTime();
    update();
}

highlight_line_at()

void stream_cell::highlight_line_at	(	const QString &	line_name,
		const QPointF &	pos_pct )

Highlight a line and record a hit position for spatial falloff.

The highlight animation will concentrate around pos_pct if the line supports segment-wise highlighting.

Parameters

line_name	Name of the line to highlight.
pos_pct	Hit position in percentage coordinates.

Definition at line 208 of file stream_cell.cpp.

  {
    if (line_name.isEmpty()) {
        return;
    }
 
    hit_info h;
    h.pos_pct = pos_pct;
    h.ts = QDateTime::currentDateTime();
    line_hits[line_name] = h;
    line_highlights[line_name] = h.ts;
    update();
}

is_active()

bool stream_cell::is_active

(

)

const

Check whether this cell is currently active (focused).

Returns

true if active.

Definition at line 36 of file stream_cell.cpp.

{ return active; }

References active.

is_draft_preview()

bool stream_cell::is_draft_preview

(

)

const

Check whether the draft is in preview-only mode.

Preview mode means draft is shown but not necessarily editable.

Definition at line 48 of file stream_cell.cpp.

{ return draft_preview; }

References draft_preview.

keyPressEvent()

void stream_cell::keyPressEvent ( QKeyEvent * event )

overrideprotected

Key press handler for draft undo.

Definition at line 305 of file stream_cell.cpp.

                                                {
    if (!(drawing_enabled && active)) {
        QWidget::keyPressEvent(event);
        return;
    }
 
    const bool undo_key = (event->key() == Qt::Key_Backspace)
        || (event->key() == Qt::Key_Z
            && (event->modifiers() & Qt::ControlModifier));
 
    if (!undo_key) {
        QWidget::keyPressEvent(event);
        return;
    }
 
    if (!draft_line_points_pct.empty()) {
        draft_line_points_pct.pop_back();
        hover_point_pct.reset();
        update();
    }
 
    event->accept();
}

References active, and drawing_enabled.

label_pos_px()

QPointF stream_cell::label_pos_px ( const line_instance & l ) const

private

Compute label anchor position for a line in pixel coordinates.

Uses first or last point depending on closed flag.

Definition at line 643 of file stream_cell.cpp.

                                                              {
    if (l.pts_pct.empty()) {
        return {};
    }
 
    const QPointF anchor_pct = l.closed ? l.pts_pct.back() : l.pts_pct.front();
    const QPointF anchor_px = to_px(anchor_pct);
    return { anchor_px.x() + 6.0, anchor_px.y() + 14.0 };
}

leaveEvent()

void stream_cell::leaveEvent ( QEvent * event )

overrideprotected

Leave handler to clear hover state.

Definition at line 299 of file stream_cell.cpp.

                                          {
    hover_point_pct.reset();
    update();
    QWidget::leaveEvent(event);
}

mouseMoveEvent()

void stream_cell::mouseMoveEvent ( QMouseEvent * event )

overrideprotected

Mouse move handler for hover updates while drawing.

Definition at line 288 of file stream_cell.cpp.

                                                   {
    if (!drawing_enabled || !active) {
        QWidget::mouseMoveEvent(event);
        return;
    }
 
    hover_point_pct = to_pct(event->pos());
    update();
    event->accept();
}

References active, and drawing_enabled.

mousePressEvent()

void stream_cell::mousePressEvent ( QMouseEvent * event )

overrideprotected

Mouse press handler for drawing draft points.

Definition at line 265 of file stream_cell.cpp.

                                                    {
    if (!drawing_enabled || !active) {
        QWidget::mousePressEvent(event);
        return;
    }
 
    auto* child = childAt(event->pos());
    if (child == close_btn || child == focus_btn) {
        QWidget::mousePressEvent(event);
        return;
    }
 
    if (event->button() == Qt::LeftButton) {
        setFocus();
        draft_line_points_pct.push_back(to_pct(event->pos()));
        update();
        event->accept();
        return;
    }
 
    QWidget::mousePressEvent(event);
}

References active, close_btn, drawing_enabled, and focus_btn.

on_camera_error

void stream_cell::on_camera_error ( QCamera::Error error )

privateslot

Slot called on camera errors.

Stores camera error string and triggers a repaint.

Definition at line 768 of file stream_cell.cpp.

                                                          {
    Q_UNUSED(error);
 
    if (!camera) {
        return;
    }
 
    last_error = camera->errorString();
    update();
}

on_frame_changed

void stream_cell::on_frame_changed ( const QVideoFrame & frame )

privateslot

Slot called when the video sink receives a new frame.

Converts the frame to QImage, emits frame_ready, and schedules repaint respecting repaint_interval_ms.

Definition at line 714 of file stream_cell.cpp.

                                                           {
    if (!frame.isValid()) {
        return;
    }
 
    QVideoFrame copy(frame);
    if (!copy.map(QVideoFrame::ReadOnly)) {
        return;
    }
 
    last_frame = copy.toImage();
    copy.unmap();
 
    emit frame_ready(name, last_frame);
 
    if (!repaint_timer.isValid()) {
        repaint_timer.start();
        update();
        return;
    }
 
    if (repaint_timer.elapsed() < repaint_interval_ms) {
        return;
    }
 
    repaint_timer.restart();
    update();
}

on_media_status_changed

void stream_cell::on_media_status_changed ( QMediaPlayer::MediaStatus status )

privateslot

Slot called on media status changes.

Used to implement looping on end-of-media when enabled.

Definition at line 743 of file stream_cell.cpp.

  {
    if (!loop_enabled) {
        return;
    }
    if (status != QMediaPlayer::EndOfMedia) {
        return;
    }
    if (!player) {
        return;
    }
 
    player->setPosition(0);
    player->play();
}

References loop_enabled.

on_player_error

void stream_cell::on_player_error ( QMediaPlayer::Error error, const QString & error_string )

privateslot

Slot called when media player errors occur.

Stores the error string and triggers a repaint.

Definition at line 760 of file stream_cell.cpp.

  {
    Q_UNUSED(error);
    last_error = error_string;
    update();
}

paintEvent()

void stream_cell::paintEvent ( QPaintEvent * event )

overrideprotected

Paint handler.

Draws:

• widget background,
• last video frame or "no signal" message,
• stream name,
• events, lines, draft and hover overlays.

Definition at line 223 of file stream_cell.cpp.

                                               {
    Q_UNUSED(event);
 
    QStyleOption opt;
    opt.initFrom(this);
 
    QPainter p(this);
    style()->drawPrimitive(QStyle::PE_Widget, &opt, &p, this);
 
    if (!last_frame.isNull()) {
        p.drawImage(rect(), last_frame);
    } else {
        const QString txt = last_error.isEmpty() ? "no signal" : last_error;
        const QRect r = rect().adjusted(6, 6, -6, -6);
        p.setPen(palette().color(QPalette::Text));
        p.drawText(r, Qt::AlignCenter, txt);
    }
 
    draw_stream_name(p);
 
    p.drawRect(rect().adjusted(0, 0, -1, -1));
    p.setRenderHint(QPainter::Antialiasing, true);
 
    const auto now = QDateTime::currentDateTime();
 
    for (auto it = line_highlights.begin(); it != line_highlights.end();) {
        const int age = static_cast<int>(it.value().msecsTo(now));
        if (age >= line_highlight_ttl_ms) {
            it = line_highlights.erase(it);
        } else {
            ++it;
        }
    }
 
    draw_events(p);
    draw_persistent(p);
    draw_draft(p);
    draw_hover_point(p);
    draw_hover_coords(p);
    draw_preview_segment(p);
}

References draw_draft(), draw_events(), draw_hover_coords(), draw_hover_point(), draw_persistent(), draw_preview_segment(), draw_stream_name(), and line_highlight_ttl_ms.

Here is the call graph for this function:

request_close

void stream_cell::request_close ( const QString & name )

signal

Emitted when the user requests closing this stream cell.

Typically triggered by clicking the close button.

Parameters

name	Stream cell name.

request_focus

void stream_cell::request_focus ( const QString & name )

signal

Emitted when the user requests focusing/enlarging this cell.

Typically triggered by clicking the focus button.

Parameters

name	Stream cell name.

set_active()

void stream_cell::set_active

(

bool

val

)

Set active (focused) state.

Deactivating a cell automatically disables drawing and clears draft.

Parameters

val	New active state.

Definition at line 50 of file stream_cell.cpp.

                                           {
    if (active == val) {
        return;
    }
    active = val;
    if (!active) {
        set_drawing_enabled(false);
        clear_draft();
    }
    update_icon();
    update();
}

References active, clear_draft(), set_drawing_enabled(), and update_icon().

Referenced by board::clear_active(), board::set_active_stream(), and board::take_active_cell().

Here is the call graph for this function:

Here is the caller graph for this function:

set_camera_id()

void stream_cell::set_camera_id

(

const QByteArray &

id

)

Switch to camera input by device id.

Stops any previous player/camera, creates capture session if needed, finds a matching camera device by id, and starts capture.

Parameters

id	Camera device id returned by Qt multimedia.

Definition at line 137 of file stream_cell.cpp.

                                                    {
    camera_id = id;
 
    last_error.clear();
    last_frame = QImage();
 
    if (player) {
        player->stop();
    }
 
    if (camera) {
        camera->stop();
        camera->deleteLater();
        camera = nullptr;
    }
 
    if (!session) {
        session = new QMediaCaptureSession(this);
        session->setVideoSink(sink);
    }
 
    QCameraDevice device;
    const auto cams = QMediaDevices::videoInputs();
    for (const auto& c : cams) {
        if (c.id() == id) {
            device = c;
            break;
        }
    }
 
    if (device.isNull()) {
        last_error = tr("camera not found");
        update();
        return;
    }
 
    camera = new QCamera(device, this);
    session->setCamera(camera);
 
    connect(
        camera, &QCamera::errorOccurred, this, &stream_cell::on_camera_error
    );
 
    camera->start();
}

set_draft_params()

void stream_cell::set_draft_params	(	const QString &	name,
		const QColor &	color,
		bool	closed )

Set draft line parameters (name, color, closed flag).

Does not modify draft points.

Parameters

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

Definition at line 72 of file stream_cell.cpp.

  {
    draft_line_name = n;
    draft_line_color = color;
    draft_line_closed = closed;
    update();
}

References draft_line_closed.

set_draft_points_pct()

void stream_cell::set_draft_points_pct

(

const std::vector< QPointF > &

pts

)

Replace current draft points (percentage coordinates).

Parameters

pts	New draft points.

Definition at line 81 of file stream_cell.cpp.

                                                                    {
    draft_line_points_pct = pts;
    update();
}

set_draft_preview()

void stream_cell::set_draft_preview

(

bool

on

)

Enable or disable draft preview mode.

Parameters

on	True to enable preview.

Definition at line 110 of file stream_cell.cpp.

                                                 {
    draft_preview = on;
    update();
}

References draft_preview.

set_drawing_enabled()

void stream_cell::set_drawing_enabled

(

bool

on

)

Enable or disable interactive drawing on this cell.

Enabling drawing also enables mouse tracking to receive hover updates.

Parameters

on	True to enable drawing.

Definition at line 63 of file stream_cell.cpp.

                                                   {
    drawing_enabled = on;
    if (!on) {
        hover_point_pct.reset();
    }
    setMouseTracking(drawing_enabled);
    update();
}

References drawing_enabled.

Referenced by controller::on_active_edit_mode_changed(), controller::on_active_stream_selected(), and set_active().

Here is the caller graph for this function:

set_labels_enabled()

void stream_cell::set_labels_enabled

(

bool

on

)

Enable or disable rendering of persistent line labels.

Labels are only shown when the cell is active.

Parameters

on	True to enable labels.

Definition at line 115 of file stream_cell.cpp.

                                                  {
    if (labels_enabled == on) {
        return;
    }
    labels_enabled = on;
    update();
}

References labels_enabled.

Referenced by controller::on_active_labels_enabled_changed(), and controller::on_active_stream_selected().

Here is the caller graph for this function:

set_loop()

void stream_cell::set_loop

(

bool

on

)

Enable or disable looping for file-based playback.

Parameters

on	True to loop on end-of-media.

Definition at line 135 of file stream_cell.cpp.

{ loop_enabled = on; }

References loop_enabled.

Referenced by controller::handle_show_stream_changed().

Here is the caller graph for this function:

set_persistent_lines()

void stream_cell::set_persistent_lines

(

const std::vector< line_instance > &

lines

)

Replace all persistent lines.

Parameters

lines

New list of persistent line instances.

Definition at line 93 of file stream_cell.cpp.

  {
    persistent_lines = lines;
    update();
}

set_repaint_interval_ms()

void stream_cell::set_repaint_interval_ms

(

int

ms

)

Set minimum repaint interval for video frame updates.

Frames arriving faster than this interval will be coalesced.

Parameters

ms	Interval in milliseconds (> 0).

Definition at line 193 of file stream_cell.cpp.

                                                      {
    if (ms <= 0) {
        return;
    }
    repaint_interval_ms = ms;
}

References repaint_interval_ms.

set_source()

void stream_cell::set_source

(

const QUrl &

source

)

Set media player source.

If a media player is available, switches it to source and starts playback.

Parameters

source

URL of local file or network stream.

Definition at line 123 of file stream_cell.cpp.

                                               {
    if (!player) {
        return;
    }
 
    last_error.clear();
    last_frame = QImage();
 
    player->setSource(source);
    player->play();
}

to_pct()

QPointF stream_cell::to_pct ( const QPointF & pos_px ) const

private

Convert pixel position to percentage coordinates.

Definition at line 653 of file stream_cell.cpp.

                                                       {
    if (width() <= 0 || height() <= 0) {
        return {};
    }
 
    float x
        = static_cast<float>(pos_px.x()) / static_cast<float>(width()) * 100.0f;
    float y = static_cast<float>(pos_px.y()) / static_cast<float>(height())
        * 100.0f;
 
    x = std::clamp(x, 0.f, 100.f);
    y = std::clamp(y, 0.f, 100.f);
 
    return { x, y };
}

to_px()

QPointF stream_cell::to_px ( const QPointF & pos_pct ) const

private

Convert percentage coordinates to pixel position.

Definition at line 669 of file stream_cell.cpp.

                                                       {
    return { pos_pct.x() / 100.0 * width(), pos_pct.y() / 100.0 * height() };
}

update_icon()

void stream_cell::update_icon ( )

private

Update focus button icon/tooltip based on active state.

Definition at line 400 of file stream_cell.cpp.

                              {
    if (!focus_btn) {
        return;
    }
    if (active) {
        focus_btn->setToolTip(tr("shrink"));
#if defined(KC_KDE)
        focus_btn->setIcon(
            icon_loader::themed(
                { "view-restore", "window-restore", "transform-scale" },
                QStyle::SP_TitleBarNormalButton
            )
        );
#else
        focus_btn->setIcon(
            icon_loader::themed(
                { "view-restore", "window-restore" },
                QStyle::SP_TitleBarNormalButton
            )
        );
#endif
    } else {
        focus_btn->setToolTip(tr("enlarge"));
#if defined(KC_KDE)
        focus_btn->setIcon(
            icon_loader::themed(
                { "view-fullscreen", "window-maximize", "transform-scale" },
                QStyle::SP_TitleBarMaxButton
            )
        );
#else
        focus_btn->setIcon(
            icon_loader::themed(
                { "view-fullscreen", "fullscreen", "window-maximize" },
                QStyle::SP_TitleBarMaxButton
            )
        );
#endif
    }
}

References active, and focus_btn.

Referenced by build_ui(), and set_active().

Here is the caller graph for this function:

Member Data Documentation

active

bool stream_cell::active { false }

private

Whether the cell is focused/active.

Definition at line 465 of file stream_cell.hpp.

{ false };

Referenced by is_active(), keyPressEvent(), mouseMoveEvent(), mousePressEvent(), set_active(), and update_icon().

camera

QCamera* stream_cell::camera { nullptr }

private

Active camera (if using live input).

Definition at line 500 of file stream_cell.hpp.

{ nullptr };

camera_id

QByteArray stream_cell::camera_id

private

Selected camera id.

Definition at line 504 of file stream_cell.hpp.

close_btn

QPushButton* stream_cell::close_btn { nullptr }

private

UI close button (top-right).

Definition at line 458 of file stream_cell.hpp.

{ nullptr };

Referenced by build_ui(), mousePressEvent(), and stream_cell().

draft_line_closed

bool stream_cell::draft_line_closed { false }

private

Draft line closed flag.

Definition at line 479 of file stream_cell.hpp.

{ false };

Referenced by draft_closed(), and set_draft_params().

draft_line_color

QColor stream_cell::draft_line_color { Qt::red }

private

Draft line color.

Definition at line 477 of file stream_cell.hpp.

{ Qt::red };

draft_line_name

QString stream_cell::draft_line_name

private

Draft line name.

Definition at line 475 of file stream_cell.hpp.

draft_line_points_pct

std::vector<QPointF> stream_cell::draft_line_points_pct

private

Draft polyline points in percentage coordinates.

Definition at line 481 of file stream_cell.hpp.

draft_preview

bool stream_cell::draft_preview { false }

private

Whether draft line is shown in preview mode.

Definition at line 470 of file stream_cell.hpp.

{ false };

Referenced by clear_draft(), is_draft_preview(), and set_draft_preview().

drawing_enabled

bool stream_cell::drawing_enabled { false }

private

Whether interactive drawing is enabled.

Definition at line 468 of file stream_cell.hpp.

{ false };

Referenced by keyPressEvent(), mouseMoveEvent(), mousePressEvent(), and set_drawing_enabled().

events

QVector<event_instance> stream_cell::events

private

Transient events currently displayed.

Definition at line 507 of file stream_cell.hpp.

focus_btn

QPushButton* stream_cell::focus_btn { nullptr }

private

UI focus/enlarge button (top-right).

Definition at line 460 of file stream_cell.hpp.

{ nullptr };

Referenced by build_ui(), mousePressEvent(), stream_cell(), and update_icon().

hover_point_pct

std::optional<QPointF> stream_cell::hover_point_pct

private

Current hover position in percentage coordinates.

Definition at line 483 of file stream_cell.hpp.

labels_enabled

bool stream_cell::labels_enabled { true }

private

Whether persistent line labels are shown when active.

Definition at line 472 of file stream_cell.hpp.

{ true };

Referenced by set_labels_enabled().

last_error

QString stream_cell::last_error

private

Last error string to display when no frame is available.

Definition at line 497 of file stream_cell.hpp.

last_frame

QImage stream_cell::last_frame

private

Most recent received frame as an image.

Definition at line 493 of file stream_cell.hpp.

line_highlight_ttl_ms

int stream_cell::line_highlight_ttl_ms { 2500 }

private

Highlight time-to-live in ms.

Definition at line 522 of file stream_cell.hpp.

{ 2500 };

Referenced by paintEvent().

line_highlights

QHash<QString, QDateTime> stream_cell::line_highlights

private

Line highlight timestamps by line name.

Used to animate highlight effects for a fixed TTL.

Definition at line 519 of file stream_cell.hpp.

line_hits

QHash<QString, hit_info> stream_cell::line_hits

private

Optional hit positions per line name.

Definition at line 537 of file stream_cell.hpp.

loop_enabled

bool stream_cell::loop_enabled { true }

private

Whether playback looping is enabled.

Definition at line 495 of file stream_cell.hpp.

{ true };

Referenced by on_media_status_changed(), and set_loop().

name

QString stream_cell::name

private

Logical stream name.

Definition at line 455 of file stream_cell.hpp.

name_label

QLabel* stream_cell::name_label { nullptr }

private

Optional name label (unused in current implementation).

Definition at line 462 of file stream_cell.hpp.

{ nullptr };

Referenced by stream_cell().

persistent_lines

std::vector<line_instance> stream_cell::persistent_lines

private

Persisted lines to render.

Definition at line 486 of file stream_cell.hpp.

player

QMediaPlayer* stream_cell::player { nullptr }

private

Media player for file/URL sources.

Definition at line 489 of file stream_cell.hpp.

{ nullptr };

repaint_interval_ms

int stream_cell::repaint_interval_ms { 66 }

private

Minimum repaint interval in ms.

Definition at line 512 of file stream_cell.hpp.

{ 66 };

Referenced by set_repaint_interval_ms().

repaint_timer

QElapsedTimer stream_cell::repaint_timer

private

Timer throttling repaint frequency.

Definition at line 510 of file stream_cell.hpp.

session

QMediaCaptureSession* stream_cell::session { nullptr }

private

Capture session binding camera to sink.

Definition at line 502 of file stream_cell.hpp.

{ nullptr };

sink

QVideoSink* stream_cell::sink { nullptr }

private

Video sink feeding decoded frames into the widget.

Definition at line 491 of file stream_cell.hpp.

{ nullptr };

---

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

• stream_cell.hpp
• stream_cell.cpp