You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
789 lines
28 KiB
789 lines
28 KiB
/////////////////////////////////////////////////////////////////////////////////// |
|
// Copyright (C) 2026 Jon Beniston, M7RCE <jon@beniston.com> // |
|
// Some code by AI // |
|
// // |
|
// This program is free software; you can redistribute it and/or modify // |
|
// it under the terms of the GNU General Public License as published by // |
|
// the Free Software Foundation as version 3 of the License, or // |
|
// (at your option) any later version. // |
|
// // |
|
// This program is distributed in the hope that it will be useful, // |
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of // |
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // |
|
// GNU General Public License V3 for more details. // |
|
// // |
|
// You should have received a copy of the GNU General Public License // |
|
// along with this program. If not, see <http://www.gnu.org/licenses/>. // |
|
/////////////////////////////////////////////////////////////////////////////////// |
|
|
|
#include <algorithm> |
|
#include <utility> |
|
|
|
#include <QCheckBox> |
|
#include <QComboBox> |
|
#include <QDateTime> |
|
#include <QHBoxLayout> |
|
#include <QHeaderView> |
|
#include <QLabel> |
|
#include <QListWidget> |
|
#include <QMenu> |
|
#include <QToolButton> |
|
#include <QSplitter> |
|
#include <QTabWidget> |
|
#include <QTableWidget> |
|
#include <QTextBrowser> |
|
#include <QVBoxLayout> |
|
|
|
#include "dtv/dtvepggrid.h" |
|
#include "dtv/dtvepgdialog.h" |
|
|
|
DTVEPGDialog::DTVEPGDialog(DTVGuide *guide, DTVRecordingSchedule *schedule, QWidget *parent) : |
|
QDialog(parent), |
|
m_schedule(schedule), |
|
m_epg(guide), |
|
m_currentService(0) |
|
{ |
|
setWindowTitle("Programme Guide"); |
|
resize(960, 640); |
|
|
|
m_services = new QListWidget(); |
|
m_services->setToolTip("Services by channel number. Those in italics are on other multiplexes, so are played by retuning, and those\n" |
|
"greyed are on multiplexes whose frequency isn't known. Double-click to play."); |
|
m_services->setMinimumWidth(220); |
|
|
|
m_day = new QComboBox(); |
|
m_day->setToolTip("Day of the schedule"); |
|
m_otherMultiplexes = new QCheckBox("Other multiplexes"); |
|
m_otherMultiplexes->setToolTip("List services on other multiplexes of the network too"); |
|
m_otherMultiplexes->setChecked(true); |
|
m_status = new QLabel(); |
|
m_scheduled = new QToolButton(); |
|
m_scheduled->setText("Scheduled"); |
|
m_scheduled->setToolTip("Programmes to record. Select one to cancel its recording"); |
|
m_scheduled->setPopupMode(QToolButton::InstantPopup); |
|
m_scheduled->setMenu(new QMenu(m_scheduled)); |
|
connect(m_scheduled->menu(), &QMenu::aboutToShow, this, &DTVEPGDialog::scheduledMenu); |
|
|
|
m_events = new QTableWidget(0, 4); |
|
m_events->setHorizontalHeaderLabels({"Time", "Title", "Genre", "Info"}); |
|
m_events->horizontalHeader()->setSectionResizeMode(0, QHeaderView::ResizeToContents); |
|
m_events->horizontalHeader()->setSectionResizeMode(1, QHeaderView::Stretch); |
|
m_events->horizontalHeader()->setSectionResizeMode(2, QHeaderView::ResizeToContents); |
|
m_events->horizontalHeader()->setSectionResizeMode(3, QHeaderView::ResizeToContents); |
|
m_events->verticalHeader()->setVisible(false); |
|
m_events->setSelectionBehavior(QAbstractItemView::SelectRows); |
|
m_events->setSelectionMode(QAbstractItemView::SingleSelection); |
|
m_events->setEditTriggers(QAbstractItemView::NoEditTriggers); |
|
m_events->setToolTip("Info: REC to be recorded, HD, S subtitles, AD audio description, and the minimum age from the parental rating.\n" |
|
"Double-click to play the service. Right-click to record"); |
|
m_events->setContextMenuPolicy(Qt::CustomContextMenu); |
|
connect(m_events, &QTableWidget::customContextMenuRequested, this, &DTVEPGDialog::eventMenu); |
|
|
|
m_description = new QTextBrowser(); |
|
m_description->setMaximumHeight(160); |
|
|
|
m_grid = new DTVEPGGrid(); |
|
m_grid->setToolTip(""); |
|
m_grid->setScheduled([this](int networkId, int serviceId, int eventId) { return m_schedule->isScheduled(networkId, serviceId, eventId); }); |
|
|
|
QHBoxLayout *controls = new QHBoxLayout(); |
|
controls->addWidget(m_day); |
|
controls->addWidget(m_otherMultiplexes); |
|
controls->addStretch(1); |
|
controls->addWidget(m_status); |
|
controls->addWidget(m_scheduled); |
|
|
|
QSplitter *splitter = new QSplitter(Qt::Horizontal); |
|
splitter->addWidget(m_services); |
|
splitter->addWidget(m_events); |
|
splitter->setStretchFactor(1, 1); |
|
|
|
m_views = new QTabWidget(); |
|
m_views->addTab(splitter, "List"); |
|
m_views->addTab(m_grid, "Grid"); |
|
m_views->setTabToolTip(0, "Services, and the schedule of the one selected"); |
|
m_views->setTabToolTip(1, "Every service's programmes by time. Double-click or Enter to play, right-click to record. " |
|
"Arrow keys move between programmes"); |
|
|
|
QVBoxLayout *layout = new QVBoxLayout(this); |
|
layout->addLayout(controls); |
|
layout->addWidget(m_views, 1); |
|
layout->addWidget(m_description); |
|
|
|
connect(m_services, &QListWidget::currentRowChanged, this, [this](int) { |
|
const ListedService *service = currentService(); |
|
m_currentService = service ? service->m_serviceId : m_currentService; |
|
refreshEvents(); |
|
}); |
|
connect(m_services, &QListWidget::itemDoubleClicked, this, [this](QListWidgetItem *) { |
|
const ListedService *service = currentService(); |
|
|
|
if (service) { |
|
play(*service); |
|
} |
|
}); |
|
connect(m_day, QOverload<int>::of(&QComboBox::currentIndexChanged), this, [this](int) { |
|
refreshEvents(); |
|
showDay(); |
|
}); |
|
connect(m_otherMultiplexes, &QCheckBox::toggled, this, [this](bool) { refreshServices(); }); |
|
connect(m_events, &QTableWidget::currentCellChanged, this, [this](int, int, int, int) { showDescription(); }); |
|
connect(m_events, &QTableWidget::cellDoubleClicked, this, [this](int, int) { |
|
const ListedService *service = currentService(); |
|
|
|
if (service) { |
|
play(*service); |
|
} |
|
}); |
|
connect(m_views, &QTabWidget::currentChanged, this, [this](int index) { |
|
if (index == 1) |
|
{ |
|
refreshGrid(); |
|
showDay(); |
|
} |
|
else |
|
{ |
|
showDescription(); |
|
} |
|
}); |
|
connect(m_grid, &DTVEPGGrid::eventSelected, this, [this](int row, int event) { |
|
m_description->setHtml(describe(m_grid->row(row).m_events[event], m_grid->row(row).m_networkId)); |
|
}); |
|
connect(m_grid, &DTVEPGGrid::eventActivated, this, [this](int row, int) { |
|
ListedService service; |
|
|
|
if (gridService(row, service)) { |
|
play(service); |
|
} |
|
}); |
|
connect(m_grid, &DTVEPGGrid::eventMenuRequested, this, [this](int row, int event, const QPoint& globalPosition) { |
|
ListedService service; |
|
|
|
// The event's copied: the menu's event loop may rebuild the grid |
|
if (gridService(row, service) && (event >= 0) && (event < (int) m_grid->row(row).m_events.size())) { |
|
showEventMenu(service, m_grid->row(row).m_events[event], globalPosition); |
|
} |
|
}); |
|
connect(&m_timer, &QTimer::timeout, this, &DTVEPGDialog::refresh); |
|
m_timer.start(10000); // The guide arrives over minutes |
|
|
|
refresh(); |
|
} |
|
|
|
qint64 DTVEPGDialog::now() const |
|
{ |
|
const qint64 t = m_epg->getTime(); |
|
return t > 0 ? t : QDateTime::currentSecsSinceEpoch(); |
|
} |
|
|
|
void DTVEPGDialog::setCurrentService(int serviceId) |
|
{ |
|
m_currentService = serviceId; |
|
|
|
for (int i = 0; i < (int) m_listed.size(); i++) |
|
{ |
|
if (m_listed[i].m_actual && (m_listed[i].m_serviceId == serviceId)) |
|
{ |
|
m_services->setCurrentRow(i); |
|
return; |
|
} |
|
} |
|
} |
|
|
|
const DTVEPGDialog::ListedService *DTVEPGDialog::currentService() const |
|
{ |
|
const int row = m_services->currentRow(); |
|
return (row >= 0) && (row < (int) m_listed.size()) ? &m_listed[row] : nullptr; |
|
} |
|
|
|
// A row of the grid's service, from the services it was built from. False if they've changed since |
|
bool DTVEPGDialog::gridService(int row, ListedService& service) const |
|
{ |
|
if ((row < 0) || (row >= m_grid->rowCount()) || (row >= (int) m_gridServices.size())) { |
|
return false; |
|
} |
|
|
|
const DTVEPGGrid::Row& r = m_grid->row(row); |
|
const DTVGuide::Service& s = m_gridServices[row]; |
|
|
|
if ((r.m_networkId != s.m_networkId) || (r.m_serviceId != s.m_serviceId)) { |
|
return false; |
|
} |
|
|
|
service = {r.m_networkId, r.m_serviceId, r.m_actual, s.m_frequency, s.m_multiplexKnown}; |
|
return true; |
|
} |
|
|
|
void DTVEPGDialog::refresh() |
|
{ |
|
refreshDays(); |
|
refreshServices(); |
|
} |
|
|
|
// Today and the next 7 days, local time |
|
void DTVEPGDialog::refreshDays() |
|
{ |
|
const QDate today = QDateTime::fromSecsSinceEpoch(now()).toLocalTime().date(); |
|
|
|
if ((m_day->count() > 0) && (m_day->itemData(0).toDate() == today)) { |
|
return; |
|
} |
|
|
|
const int index = std::max(0, m_day->currentIndex()); |
|
m_day->blockSignals(true); |
|
m_day->clear(); |
|
|
|
for (int d = 0; d < 8; d++) |
|
{ |
|
const QDate date = today.addDays(d); |
|
m_day->addItem(d == 0 ? QString("Today") : d == 1 ? QString("Tomorrow") : date.toString("dddd d MMMM"), date); |
|
} |
|
|
|
m_day->setCurrentIndex(std::min(index, m_day->count() - 1)); |
|
m_day->blockSignals(false); |
|
} |
|
|
|
void DTVEPGDialog::refreshServices() |
|
{ |
|
const quint64 revision = m_epg->getRevision(); |
|
const bool others = m_otherMultiplexes->isChecked(); |
|
|
|
if ((revision == m_servicesRevision) && (others == m_servicesOthers)) |
|
{ |
|
refreshEvents(); |
|
refreshGrid(); |
|
return; |
|
} |
|
|
|
m_servicesRevision = revision; |
|
m_servicesOthers = others; |
|
std::vector<DTVGuide::Service> services = m_epg->getServices(); |
|
|
|
services.erase(std::remove_if(services.begin(), services.end(), [others](const DTVGuide::Service& s) { |
|
return s.m_name.isEmpty() || !s.m_visible || (!others && !s.m_actual); |
|
}), services.end()); |
|
std::sort(services.begin(), services.end(), [](const DTVGuide::Service& a, const DTVGuide::Service& b) { |
|
if ((a.m_channel != b.m_channel) || (a.m_minorChannel != b.m_minorChannel)) { |
|
return a.channelBefore(b); |
|
} |
|
|
|
return a.m_name < b.m_name; |
|
}); |
|
|
|
QString key = QString::number(others); |
|
|
|
for (const auto& s : services) { |
|
key += QString("|%1/%2/%3/%4/%5/%6/%7").arg(s.m_networkId).arg(s.m_serviceId).arg(s.channelText()).arg(s.m_actual).arg(s.m_name) |
|
.arg(s.m_frequency).arg(s.m_multiplexKnown); |
|
} |
|
|
|
m_gridServices = services; |
|
|
|
m_status->setText(QString("%1 services, %2 programmes").arg(services.size()).arg(m_epg->getEventCount())); |
|
|
|
if (key == m_servicesKey) |
|
{ |
|
refreshEvents(); |
|
refreshGrid(); |
|
return; |
|
} |
|
|
|
m_servicesKey = key; |
|
|
|
// Keep the selection, or select the service playing |
|
const ListedService *selected = currentService(); |
|
const int selectedNetwork = selected ? selected->m_networkId : -1; |
|
const int selectedService = selected ? selected->m_serviceId : m_currentService; |
|
|
|
m_services->blockSignals(true); |
|
m_services->clear(); |
|
m_listed.clear(); |
|
int row = -1; |
|
|
|
for (const auto& s : services) |
|
{ |
|
QListWidgetItem *item = new QListWidgetItem(s.m_channel >= 0 ? QString("%1 %2").arg(s.channelText()).arg(s.m_name) : s.m_name); |
|
|
|
if (!s.m_actual) |
|
{ |
|
QFont font = item->font(); |
|
font.setItalic(true); |
|
item->setFont(font); |
|
|
|
if (s.m_frequency > 0) |
|
{ |
|
item->setToolTip(QString("On another multiplex, at %1 MHz: double-click to tune to it").arg(s.m_frequency / 1e6, 0, 'f', 3)); |
|
} |
|
else if (s.m_multiplexKnown) |
|
{ |
|
item->setToolTip("On another multiplex, whose frequency isn't known: double-click to search the UHF channels for it"); |
|
} |
|
else |
|
{ |
|
item->setForeground(palette().color(QPalette::Disabled, QPalette::Text)); |
|
item->setToolTip("On another region's multiplex"); |
|
} |
|
} |
|
|
|
m_services->addItem(item); |
|
m_listed.push_back({s.m_networkId, s.m_serviceId, s.m_actual, s.m_frequency, s.m_multiplexKnown}); |
|
|
|
if ((s.m_serviceId == selectedService) && ((selectedNetwork < 0) ? s.m_actual : (s.m_networkId == selectedNetwork))) { |
|
row = (int) m_listed.size() - 1; |
|
} |
|
} |
|
|
|
if (row >= 0) { |
|
m_services->setCurrentRow(row); |
|
} |
|
|
|
m_services->blockSignals(false); |
|
refreshEvents(); |
|
refreshGrid(); |
|
} |
|
|
|
// Every listed service's programmes, if the grid is shown, rebuilt if they've changed |
|
void DTVEPGDialog::refreshGrid() |
|
{ |
|
if (m_views->currentIndex() != 1) { |
|
return; |
|
} |
|
|
|
const qint64 t = now(); |
|
const qint64 start = t - 3600 - (t % 1800); |
|
const quint64 revision = m_epg->getRevision(); |
|
const QString schedule = scheduleSignature(); |
|
|
|
if (!m_gridKey.isEmpty() && (revision == m_gridRevision) && (m_servicesOthers == m_gridOthers) && (start == m_gridStart) |
|
&& (schedule == m_gridSchedule)) |
|
{ |
|
m_grid->setNow(t); |
|
return; |
|
} |
|
|
|
const bool scheduleChanged = schedule != m_gridSchedule; |
|
m_gridRevision = revision; |
|
m_gridOthers = m_servicesOthers; |
|
m_gridStart = start; |
|
m_gridSchedule = schedule; |
|
|
|
// The rows, and each one's service's revision, which changes with its programmes: a big network's programmes are |
|
// only fetched if one has. Those to be recorded are marked as drawn, so only the schedule changing matters |
|
std::vector<std::pair<int, int>> ids; |
|
ids.reserve(m_gridServices.size()); |
|
QString key = QString::number(start); |
|
|
|
for (const auto& s : m_gridServices) |
|
{ |
|
ids.emplace_back(s.m_networkId, s.m_serviceId); |
|
key += QString("|%1/%2/%3/%4").arg(s.m_networkId).arg(s.m_serviceId).arg(s.m_name) |
|
.arg(s.m_actual || (s.m_frequency > 0) || s.m_multiplexKnown); |
|
} |
|
|
|
const std::vector<quint64> revisions = m_epg->getServiceRevisions(ids); |
|
|
|
if (!scheduleChanged && (key == m_gridKey) && (revisions == m_gridServiceRevisions)) |
|
{ |
|
m_grid->setNow(t); |
|
return; |
|
} |
|
|
|
std::vector<std::vector<DTVGuide::Event>> events = m_epg->getEvents(ids); |
|
std::vector<DTVEPGGrid::Row> rows; |
|
rows.reserve(m_gridServices.size()); |
|
|
|
for (size_t i = 0; i < m_gridServices.size(); i++) |
|
{ |
|
const DTVGuide::Service& s = m_gridServices[i]; |
|
DTVEPGGrid::Row row; |
|
row.m_networkId = s.m_networkId; |
|
row.m_serviceId = s.m_serviceId; |
|
row.m_name = s.m_name; |
|
row.m_channel = s.channelText(); |
|
row.m_actual = s.m_actual; |
|
row.m_tunable = s.m_actual || (s.m_frequency > 0) || s.m_multiplexKnown; |
|
row.m_events = std::move(events[i]); |
|
rows.push_back(row); |
|
} |
|
|
|
const bool first = m_gridKey.isEmpty(); |
|
m_gridKey = key; |
|
m_gridServiceRevisions = revisions; |
|
m_grid->setRows(rows, start, t); |
|
|
|
if (first) |
|
{ |
|
m_grid->scrollToTime(t - 1800); |
|
const ListedService *service = currentService(); |
|
|
|
if (service) { |
|
m_grid->scrollToService(service->m_networkId, service->m_serviceId); |
|
} |
|
} |
|
} |
|
|
|
// The grid goes to the start of the day chosen, or now for today |
|
void DTVEPGDialog::showDay() |
|
{ |
|
if (m_views->currentIndex() != 1) { |
|
return; |
|
} |
|
|
|
const QDate date = m_day->currentData().toDate(); |
|
const qint64 t = now(); |
|
const qint64 dayStart = QDateTime(date, QTime(0, 0)).toSecsSinceEpoch(); |
|
m_grid->scrollToTime(m_day->currentIndex() == 0 ? t - 1800 : dayStart); |
|
} |
|
|
|
void DTVEPGDialog::play(ListedService service) |
|
{ |
|
if (service.tunable()) { |
|
emit serviceSelected(service.m_networkId, service.m_serviceId); |
|
} |
|
} |
|
|
|
void DTVEPGDialog::refreshEvents() |
|
{ |
|
const ListedService *service = currentService(); |
|
|
|
if (!service) |
|
{ |
|
m_events->setRowCount(0); |
|
m_shown.clear(); |
|
m_eventsKey.clear(); |
|
m_description->clear(); |
|
return; |
|
} |
|
|
|
const QDate date = m_day->currentData().toDate(); |
|
const qint64 dayStart = QDateTime(date, QTime(0, 0)).toSecsSinceEpoch(); |
|
const qint64 dayEnd = QDateTime(date.addDays(1), QTime(0, 0)).toSecsSinceEpoch(); |
|
const qint64 t = now(); |
|
std::vector<DTVGuide::Event> events = m_epg->getEvents(service->m_networkId, service->m_serviceId); |
|
events.erase(std::remove_if(events.begin(), events.end(), [dayStart, dayEnd](const DTVGuide::Event& e) { |
|
return (e.m_start >= dayEnd) || (e.end() <= dayStart); |
|
}), events.end()); |
|
|
|
// Rebuilt only if the programmes, or the one on now, have changed |
|
QString key = QString("%1/%2/%3").arg(service->m_networkId).arg(service->m_serviceId).arg(date.toString(Qt::ISODate)); |
|
|
|
for (const auto& e : events) { |
|
key += QString("|%1/%2/%3/%4/%5").arg(e.m_eventId).arg(e.m_start).arg((e.m_start <= t) && (t < e.end())).arg(e.m_title) |
|
.arg(m_schedule->isScheduled(service->m_networkId, service->m_serviceId, e.m_eventId)); |
|
} |
|
|
|
if (key == m_eventsKey) { |
|
return; |
|
} |
|
|
|
m_eventsKey = key; |
|
const int previousRow = m_events->currentRow(); |
|
const int previousId = (previousRow >= 0) && (previousRow < (int) m_shown.size()) ? m_shown[previousRow].m_eventId : -1; |
|
m_events->setRowCount(0); |
|
m_shown.clear(); |
|
int nowRow = -1; |
|
int selectRow = -1; |
|
|
|
for (const auto& e : events) |
|
{ |
|
|
|
const int row = (int) m_shown.size(); |
|
m_shown.push_back(e); |
|
m_events->insertRow(row); |
|
const QDateTime start = QDateTime::fromSecsSinceEpoch(e.m_start).toLocalTime(); |
|
const QDateTime end = QDateTime::fromSecsSinceEpoch(e.end()).toLocalTime(); |
|
QStringList info; |
|
const bool scheduled = m_schedule->isScheduled(service->m_networkId, service->m_serviceId, e.m_eventId); |
|
|
|
if (scheduled) { |
|
info.append("REC"); |
|
} |
|
|
|
if (e.m_hd) { |
|
info.append("HD"); |
|
} |
|
|
|
if (e.m_subtitles) { |
|
info.append("S"); |
|
} |
|
|
|
if (e.m_audioDescription) { |
|
info.append("AD"); |
|
} |
|
|
|
if (e.m_minimumAge > 0) { |
|
info.append(QString("%1+").arg(e.m_minimumAge)); |
|
} |
|
|
|
QTableWidgetItem *items[4] = { |
|
new QTableWidgetItem(QString("%1 - %2").arg(start.toString("hh:mm")).arg(end.toString("hh:mm"))), |
|
new QTableWidgetItem(e.m_title), |
|
new QTableWidgetItem(m_epg->genreName(e.m_genre, service->m_networkId)), |
|
new QTableWidgetItem(info.join(' ')) |
|
}; |
|
const bool onNow = (e.m_start <= t) && (t < e.end()); |
|
|
|
for (int c = 0; c < 4; c++) |
|
{ |
|
if (onNow) |
|
{ |
|
QFont font = items[c]->font(); |
|
font.setBold(true); |
|
items[c]->setFont(font); |
|
} |
|
|
|
items[c]->setToolTip(e.m_text); |
|
|
|
if (scheduled) { |
|
items[c]->setForeground(Qt::red); |
|
} |
|
m_events->setItem(row, c, items[c]); |
|
} |
|
|
|
if (onNow) { |
|
nowRow = row; |
|
} |
|
|
|
if (e.m_eventId == previousId) { |
|
selectRow = row; |
|
} |
|
} |
|
|
|
// The programme selected before, else the one on now |
|
selectRow = selectRow >= 0 ? selectRow : nowRow; |
|
|
|
if (selectRow >= 0) |
|
{ |
|
m_events->setCurrentCell(selectRow, 0); |
|
m_events->scrollToItem(m_events->item(selectRow, 0), QAbstractItemView::PositionAtTop); |
|
} |
|
|
|
showDescription(); |
|
} |
|
|
|
QString DTVEPGDialog::describe(const DTVGuide::Event& e, int networkId) const |
|
{ |
|
const QDateTime start = QDateTime::fromSecsSinceEpoch(e.m_start).toLocalTime(); |
|
const QDateTime end = QDateTime::fromSecsSinceEpoch(e.end()).toLocalTime(); |
|
QString html = QString("<b>%1</b><br>%2 %3 - %4 (%5 min)") |
|
.arg(e.m_title.toHtmlEscaped()) |
|
.arg(start.toString("dddd d MMMM")) |
|
.arg(start.toString("hh:mm")) |
|
.arg(end.toString("hh:mm")) |
|
.arg(e.m_duration / 60); |
|
const QString genre = m_epg->genreName(e.m_genre, networkId); |
|
|
|
if (!genre.isEmpty()) { |
|
html += " " + genre.toHtmlEscaped(); |
|
} |
|
|
|
if (!e.m_guidance.isEmpty()) { |
|
html += "<br><i>" + e.m_guidance.toHtmlEscaped() + "</i>"; |
|
} |
|
|
|
DTVGuide::Service linked; |
|
|
|
if (linkedService(e, linked)) { |
|
html += "<br>Also on " + linked.m_name.toHtmlEscaped(); |
|
} |
|
|
|
if (!e.m_text.isEmpty()) { |
|
html += "<p>" + e.m_text.toHtmlEscaped().replace('\n', "<br>") + "</p>"; |
|
} |
|
|
|
return html; |
|
} |
|
|
|
bool DTVEPGDialog::linkedService(const DTVGuide::Event& event, DTVGuide::Service& service) const |
|
{ |
|
return (event.m_linkServiceId >= 0) && m_epg->getService(event.m_linkNetworkId, event.m_linkServiceId, service) |
|
&& !service.m_name.isEmpty() && (service.m_actual || service.m_multiplexKnown); |
|
} |
|
|
|
// The programmes to be recorded, which the grid marks |
|
QString DTVEPGDialog::scheduleSignature() const |
|
{ |
|
QString signature; |
|
|
|
for (const auto& r : m_schedule->getScheduledRecordings()) { |
|
signature += QString("%1/%2/%3|").arg(r.m_networkId).arg(r.m_serviceId).arg(r.m_eventId); |
|
} |
|
|
|
return signature; |
|
} |
|
|
|
void DTVEPGDialog::showDescription() |
|
{ |
|
if (m_views->currentIndex() != 0) { |
|
return; // The grid shows its selection's |
|
} |
|
|
|
const int row = m_events->currentRow(); |
|
const ListedService *service = currentService(); |
|
|
|
if ((row < 0) || (row >= (int) m_shown.size()) || !service) { |
|
m_description->clear(); |
|
} else { |
|
m_description->setHtml(describe(m_shown[row], service->m_networkId)); |
|
} |
|
} |
|
|
|
void DTVEPGDialog::eventMenu(const QPoint& position) |
|
{ |
|
const int row = m_events->rowAt(position.y()); |
|
const ListedService *service = currentService(); |
|
|
|
if ((row < 0) || (row >= (int) m_shown.size()) || !service) { |
|
return; |
|
} |
|
|
|
showEventMenu(*service, m_shown[row], m_events->viewport()->mapToGlobal(position)); // Copied |
|
} |
|
|
|
// Play the service, retuning if it's on another multiplex (searching for it if its frequency isn't known), or the |
|
// service the programme is also on, as in HD. Record a programme, or cancel its recording: only those of services that |
|
// can be received, that haven't ended. The service and event are copies, as what they're from (the list, the table |
|
// and the grid) can be rebuilt while the menu's open |
|
void DTVEPGDialog::showEventMenu(ListedService service, DTVGuide::Event event, const QPoint& globalPosition) |
|
{ |
|
const bool scheduled = m_schedule->isScheduled(service.m_networkId, service.m_serviceId, event.m_eventId); |
|
QMenu menu(this); |
|
menu.setToolTipsVisible(true); |
|
QAction *playAction = menu.addAction(service.m_actual ? QString("Play") |
|
: service.m_frequency > 0 ? QString("Tune to %1 MHz and play").arg(service.m_frequency / 1e6, 0, 'f', 3) |
|
: service.m_multiplexKnown ? QString("Search for its multiplex and play") |
|
: QString("Play (on another region's multiplex)")); |
|
playAction->setEnabled(service.tunable()); |
|
DTVGuide::Service linked; |
|
QAction *linkedAction = nullptr; |
|
|
|
if (linkedService(event, linked)) |
|
{ |
|
linkedAction = menu.addAction(QString("Watch on %1").arg(linked.m_name)); |
|
linkedAction->setToolTip(linked.m_actual ? QString() : linked.m_frequency > 0 |
|
? QString("Tunes to %1 MHz").arg(linked.m_frequency / 1e6, 0, 'f', 3) : QString("Searches the UHF channels for its multiplex")); |
|
} |
|
|
|
QAction *recordAction = menu.addAction(scheduled ? "Cancel recording" : "Record"); |
|
// A service on another multiplex: recordable if scheduled recordings may retune to it |
|
const bool reachable = service.m_actual || (m_schedule->recordRetune() && service.tunable()); |
|
|
|
if (!scheduled && !reachable) |
|
{ |
|
recordAction->setEnabled(false); |
|
recordAction->setText("Record (on another multiplex: allow retuning from the Record button's menu)"); |
|
} |
|
else if (!scheduled && (event.end() <= now())) |
|
{ |
|
recordAction->setEnabled(false); |
|
} |
|
|
|
// Its series, by its series CRID |
|
QAction *seriesAction = nullptr; |
|
const bool series = !event.m_seriesCrid.isEmpty() && m_schedule->isSeriesScheduled(service.m_networkId, service.m_serviceId, event.m_eventId); |
|
|
|
if (!event.m_seriesCrid.isEmpty()) |
|
{ |
|
seriesAction = menu.addAction(series ? "Cancel series recording" : "Record series"); |
|
seriesAction->setToolTip("Every programme of the series on this service, each once (not repeats)"); |
|
} |
|
|
|
// Not refreshed while the menu's open (its event loop runs the timer) |
|
const bool refreshing = m_timer.isActive(); |
|
m_timer.stop(); |
|
QAction *chosen = menu.exec(globalPosition); |
|
|
|
if (refreshing) { |
|
m_timer.start(); |
|
} |
|
|
|
if (seriesAction && (chosen == seriesAction)) |
|
{ |
|
if (series) { |
|
m_schedule->cancelSeries(service.m_networkId, service.m_serviceId, event.m_eventId); |
|
} else { |
|
m_schedule->scheduleSeries(service.m_networkId, service.m_serviceId, event.m_eventId); |
|
} |
|
|
|
m_eventsKey.clear(); |
|
refreshEvents(); |
|
refreshGrid(); |
|
return; |
|
} |
|
|
|
if (chosen == playAction) |
|
{ |
|
play(service); |
|
return; |
|
} |
|
|
|
if (linkedAction && (chosen == linkedAction)) |
|
{ |
|
emit serviceSelected(linked.m_networkId, linked.m_serviceId); |
|
return; |
|
} |
|
|
|
if (chosen != recordAction) { |
|
return; |
|
} |
|
|
|
if (scheduled) { |
|
m_schedule->cancelScheduledRecording(service.m_networkId, service.m_serviceId, event.m_eventId); |
|
} else { |
|
m_schedule->scheduleRecording(service.m_networkId, service.m_serviceId, event.m_eventId); |
|
} |
|
|
|
m_eventsKey.clear(); |
|
refreshEvents(); |
|
refreshGrid(); |
|
} |
|
|
|
// The programmes to record, in time order: selecting one cancels it |
|
void DTVEPGDialog::scheduledMenu() |
|
{ |
|
QMenu *menu = m_scheduled->menu(); |
|
menu->clear(); |
|
QList<DTVScheduledRecording> schedule = m_schedule->getScheduledRecordings(); |
|
std::sort(schedule.begin(), schedule.end(), [](const DTVScheduledRecording& a, const DTVScheduledRecording& b) { |
|
return a.m_start < b.m_start; |
|
}); |
|
const QList<DTVSeriesRecording> series = m_schedule->getSeriesRecordings(); |
|
|
|
if (schedule.isEmpty() && series.isEmpty()) |
|
{ |
|
menu->addAction("None")->setEnabled(false); |
|
return; |
|
} |
|
|
|
// The series recorded, then the programmes |
|
for (const auto& s : series) |
|
{ |
|
QAction *action = menu->addAction(QString("Cancel series: %1 %2").arg(s.m_serviceName).arg(s.m_title)); |
|
const int networkId = s.m_networkId, serviceId = s.m_serviceId; |
|
const QString crid = s.m_seriesCrid; |
|
connect(action, &QAction::triggered, this, [this, networkId, serviceId, crid]() { |
|
m_schedule->cancelSeries(networkId, serviceId, crid); |
|
m_eventsKey.clear(); |
|
refreshEvents(); |
|
refreshGrid(); |
|
}); |
|
} |
|
|
|
if (!series.isEmpty() && !schedule.isEmpty()) { |
|
menu->addSeparator(); |
|
} |
|
|
|
for (const auto& r : schedule) |
|
{ |
|
const QDateTime start = QDateTime::fromSecsSinceEpoch(r.m_start).toLocalTime(); |
|
QAction *action = menu->addAction(QString("Cancel: %1 - %2 %3 - %4").arg(start.toString("ddd d MMM hh:mm")) |
|
.arg(QDateTime::fromSecsSinceEpoch(r.end()).toLocalTime().toString("hh:mm")).arg(r.m_serviceName).arg(r.m_title)); |
|
const int networkId = r.m_networkId, serviceId = r.m_serviceId, eventId = r.m_eventId; |
|
connect(action, &QAction::triggered, this, [this, networkId, serviceId, eventId]() { |
|
m_schedule->cancelScheduledRecording(networkId, serviceId, eventId); |
|
m_eventsKey.clear(); |
|
refreshEvents(); |
|
refreshGrid(); |
|
}); |
|
} |
|
}
|
|
|