///////////////////////////////////////////////////////////////////////////////////
// Copyright (C) 2022 Jon Beniston, M7RCE //
// Copyright (C) 2020 Edouard Griffiths, F4EXB //
// //
// 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 "feature/featureuiset.h"
#include "gui/basicfeaturesettingsdialog.h"
#include "gui/flowlayout.h"
#include "gui/scidoublespinbox.h"
#include "gui/dialogpositioner.h"
#include "ui_remotecontrolgui.h"
#include "remotecontrol.h"
#include "remotecontrolgui.h"
#include "remotecontrolsettingsdialog.h"
RemoteControlGUI* RemoteControlGUI::create(PluginAPI* pluginAPI, FeatureUISet *featureUISet, Feature *feature)
{
RemoteControlGUI* gui = new RemoteControlGUI(pluginAPI, featureUISet, feature);
return gui;
}
void RemoteControlGUI::destroy()
{
delete this;
}
void RemoteControlGUI::resetToDefaults()
{
m_settings.resetToDefaults();
displaySettings();
applySettings(true);
}
QByteArray RemoteControlGUI::serialize() const
{
return m_settings.serialize();
}
bool RemoteControlGUI::deserialize(const QByteArray& data)
{
if (m_settings.deserialize(data))
{
m_feature->setWorkspaceIndex(m_settings.m_workspaceIndex);
displaySettings();
applySettings(true);
on_update_clicked();
return true;
}
else
{
resetToDefaults();
return false;
}
}
bool RemoteControlGUI::handleMessage(const Message& message)
{
if (RemoteControl::MsgConfigureRemoteControl::match(message))
{
qDebug("RemoteControlGUI::handleMessage: RemoteControl::MsgConfigureRemoteControl");
const RemoteControl::MsgConfigureRemoteControl& cfg = (RemoteControl::MsgConfigureRemoteControl&) message;
m_settings = cfg.getSettings();
blockApplySettings(true);
displaySettings();
blockApplySettings(false);
return true;
}
else if (RemoteControl::MsgDeviceStatus::match(message))
{
const RemoteControl::MsgDeviceStatus& msg = (RemoteControl::MsgDeviceStatus&) message;
deviceUpdated(msg.getProtocol(), msg.getDeviceId(), msg.getStatus());
return true;
}
else if (RemoteControl::MsgDeviceError::match(message))
{
const RemoteControl::MsgDeviceError& msg = (RemoteControl::MsgDeviceError&) message;
QMessageBox::critical(this, "Remote Control Error", msg.getErrorMessage());
return true;
}
else if (RemoteControl::MsgDeviceUnavailable::match(message))
{
const RemoteControl::MsgDeviceUnavailable& msg = (RemoteControl::MsgDeviceUnavailable&) message;
deviceUnavailable(msg.getProtocol(), msg.getDeviceId());
return true;
}
return false;
}
void RemoteControlGUI::handleInputMessages()
{
Message* message;
while ((message = getInputMessageQueue()->pop()))
{
if (handleMessage(*message)) {
delete message;
}
}
}
void RemoteControlGUI::onWidgetRolled(QWidget* widget, bool rollDown)
{
(void) widget;
(void) rollDown;
getRollupContents()->saveState(m_rollupState);
applySettings();
}
RemoteControlGUI::RemoteControlGUI(PluginAPI* pluginAPI, FeatureUISet *featureUISet, Feature *feature, QWidget* parent) :
FeatureGUI(parent),
ui(new Ui::RemoteControlGUI),
m_pluginAPI(pluginAPI),
m_featureUISet(featureUISet),
m_doApplySettings(true)
{
m_feature = feature;
setAttribute(Qt::WA_DeleteOnClose, true);
m_helpURL = "plugins/feature/remotecontrol/readme.md";
RollupContents *rollupContents = getRollupContents();
ui->setupUi(rollupContents);
rollupContents->arrangeRollups();
connect(rollupContents, SIGNAL(widgetRolled(QWidget*,bool)), this, SLOT(onWidgetRolled(QWidget*,bool)));
ui->startStop->setStyleSheet("QToolButton { background-color : blue; }"
"QToolButton:checked { background-color : green; }"
"QToolButton:disabled { background-color : gray; }");
m_startStopIcon.addFile(":/play.png", QSize(16, 16), QIcon::Normal, QIcon::Off);
m_startStopIcon.addFile(":/stop.png", QSize(16, 16), QIcon::Normal, QIcon::On);
m_remoteControl = reinterpret_cast<RemoteControl*>(feature);
m_remoteControl->setMessageQueueToGUI(&m_inputMessageQueue);
m_settings.setRollupState(&m_rollupState);
connect(this, SIGNAL(customContextMenuRequested(const QPoint &)), this, SLOT(onMenuDialogCalled(const QPoint &)));
connect(getInputMessageQueue(), SIGNAL(messageEnqueued()), this, SLOT(handleInputMessages()));
displaySettings();
applySettings(true);
makeUIConnections();
}
RemoteControlGUI::~RemoteControlGUI()
{
qDeleteAll(m_deviceGUIs);
m_deviceGUIs.clear();
delete ui;
}
void RemoteControlGUI::setWorkspaceIndex(int index)
{
m_settings.m_workspaceIndex = index;
m_feature->setWorkspaceIndex(index);
}
void RemoteControlGUI::blockApplySettings(bool block)
{
m_doApplySettings = !block;
}
void RemoteControlGUI::displaySettings()
{
setTitleColor(m_settings.m_rgbColor);
setWindowTitle(m_settings.m_title);
setTitle(m_settings.m_title);
createGUI();
blockApplySettings(true);
getRollupContents()->restoreState(m_rollupState);
blockApplySettings(false);
getRollupContents()->arrangeRollups();
}
void RemoteControlGUI::onMenuDialogCalled(const QPoint &p)
{
if (m_contextMenuType == ContextMenuChannelSettings)
{
BasicFeatureSettingsDialog dialog(this);
dialog.setTitle(m_settings.m_title);
dialog.setUseReverseAPI(m_settings.m_useReverseAPI);
dialog.setReverseAPIAddress(m_settings.m_reverseAPIAddress);
dialog.setReverseAPIPort(m_settings.m_reverseAPIPort);
dialog.setReverseAPIFeatureSetIndex(m_settings.m_reverseAPIFeatureSetIndex);
dialog.setReverseAPIFeatureIndex(m_settings.m_reverseAPIFeatureIndex);
dialog.setDefaultTitle(m_displayedName);
dialog.move(p);
new DialogPositioner(&dialog, false);
dialog.exec();
m_settings.m_title = dialog.getTitle();
m_settings.m_useReverseAPI = dialog.useReverseAPI();
m_settings.m_reverseAPIAddress = dialog.getReverseAPIAddress();
m_settings.m_reverseAPIPort = dialog.getReverseAPIPort();
m_settings.m_reverseAPIFeatureSetIndex = dialog.getReverseAPIFeatureSetIndex();
m_settings.m_reverseAPIFeatureIndex = dialog.getReverseAPIFeatureIndex();
setTitle(m_settings.m_title);
setTitleColor(m_settings.m_rgbColor);
applySettings();
}
resetContextMenuType();
}
void RemoteControlGUI::createControls(RemoteControlDeviceGUI *gui, QBoxLayout *vBox, FlowLayout *flow, int &widgetCnt)
{
// Create buttons to control the device
QGridLayout *controlsGrid = nullptr;
if (gui->m_rcDevice->m_verticalControls)
{
controlsGrid = new QGridLayout();
vBox->addLayout(controlsGrid);
}
else if (!flow)
{
flow = new FlowLayout(2, 6, 6);
vBox->addItem(flow);
}
int row = 0;
for (auto const &control : gui->m_rcDevice->m_controls)
{
if (!gui->m_rcDevice->m_verticalControls && (widgetCnt > 0))
{
QFrame *line = new QFrame();
line->setFrameShape(QFrame::VLine);
line->setFrameShadow(QFrame::Sunken);
flow->addWidget(line);
}
DeviceDiscoverer::ControlInfo *info = gui->m_rcDevice->m_info.getControl(control.m_id);
if (!info)
{
qDebug() << "RemoteControlGUI::createControls: Info missing for " << control.m_id;
continue;
}
if (!control.m_labelLeft.isEmpty())
{
QLabel *controlLabelLeft = new QLabel(control.m_labelLeft);
if (gui->m_rcDevice->m_verticalControls)
{
controlsGrid->addWidget(controlLabelLeft, row, 0);
controlsGrid->setColumnStretch(row, 0);
}
else
{
flow->addWidget(controlLabelLeft);
}
}
QList<QWidget *> widgets;
QWidget *widget = nullptr;
switch (info->m_type)
{
case DeviceDiscoverer::BOOL:
{
ButtonSwitch *button = new ButtonSwitch();
button->setToolTip("Start/stop " + info->m_name);
button->setIcon(m_startStopIcon);
button->setStyleSheet("QToolButton { background-color : blue; }"
"QToolButton:checked { background-color : green; }"
"QToolButton:disabled { background-color : gray; }");
connect(button, &ButtonSwitch::toggled,
[=] (bool toggled)
{
RemoteControl::MsgDeviceSetState *message = RemoteControl::MsgDeviceSetState::create(gui->m_rcDevice->m_protocol,
gui->m_rcDevice->m_info.m_id,
control.m_id,
toggled);
m_remoteControl->getInputMessageQueue()->push(message);
}
);
widgets.append(button);
widget = button;
}
break;
case DeviceDiscoverer::INT:
{
QSpinBox *spinBox = new QSpinBox();
spinBox->setToolTip("Set value for " + info->m_name);
spinBox->setMinimum((int)info->m_min);
spinBox->setMaximum((int)info->m_max);
connect(spinBox, static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged),
[=] (int value)
{
RemoteControl::MsgDeviceSetState *message = RemoteControl::MsgDeviceSetState::create(gui->m_rcDevice->m_protocol,
gui->m_rcDevice->m_info.m_id,
control.m_id,
value);
m_remoteControl->getInputMessageQueue()->push(message);
}
);
widgets.append(spinBox);
widget = spinBox;
}
break;
case DeviceDiscoverer::FLOAT:
{
switch (info->m_widgetType)
{
case DeviceDiscoverer::SPIN_BOX:
{
QDoubleSpinBox *spinBox = new SciDoubleSpinBox();
spinBox->setToolTip("Set value for " + info->m_name);
spinBox->setMinimum(info->m_min);
spinBox->setMaximum(info->m_max);
spinBox->setDecimals(info->m_precision);
connect(spinBox, static_cast<void (QDoubleSpinBox::*)(double)>(&QDoubleSpinBox::valueChanged),
[=] (double value)
{
RemoteControl::MsgDeviceSetState *message = RemoteControl::MsgDeviceSetState::create(gui->m_rcDevice->m_protocol,
gui->m_rcDevice->m_info.m_id,
control.m_id,
(float)value * info->m_scale);
m_remoteControl->getInputMessageQueue()->push(message);
}
);
widgets.append(spinBox);
widget = spinBox;
}
break;
case DeviceDiscoverer::DIAL:
{
widget = new QWidget();
QHBoxLayout *layout = new QHBoxLayout();
layout->setContentsMargins(0, 0, 0, 0);
widget->setLayout(layout);
QDial *dial = new QDial();
dial->setMaximumSize(24, 24);
dial->setToolTip("Set value for " + info->m_name);
dial->setMinimum(info->m_min);
dial->setMaximum(info->m_max);
connect(dial, static_cast<void (QDial::*)(int)>(&QDial::valueChanged),
[=] (int value)
{
RemoteControl::MsgDeviceSetState *message = RemoteControl::MsgDeviceSetState::create(gui->m_rcDevice->m_protocol,
gui->m_rcDevice->m_info.m_id,
control.m_id,
((float)value) * info->m_scale);
m_remoteControl->getInputMessageQueue()->push(message);
}
);
widgets.append(dial);
layout->addWidget(dial);
QLabel *label = new QLabel(QString::number(dial->value()));
label->setToolTip("Value for " + info->m_name);
widgets.append(label);
layout->addWidget(label);
}
break;
case DeviceDiscoverer::SLIDER:
{
widget = new QWidget();
QHBoxLayout *layout = new QHBoxLayout();
layout->setContentsMargins(0, 0, 0, 0);
widget->setLayout(layout);
QSlider *slider = new QSlider(Qt::Horizontal);
slider->setToolTip("Set value for " + info->m_name);
slider->setMinimum(info->m_min);
slider->setMaximum(info->m_max);
connect(slider, static_cast<void (QSlider::*)(int)>(&QSlider::valueChanged),
[=] (int value)
{
RemoteControl::MsgDeviceSetState *message = RemoteControl::MsgDeviceSetState::create(gui->m_rcDevice->m_protocol,
gui->m_rcDevice->m_info.m_id,
control.m_id,
((float)value) * info->m_scale);
m_remoteControl->getInputMessageQueue()->push(message);
}
);
widgets.append(slider);
layout->addWidget(slider);
QLabel *label = new QLabel(QString::number(slider->value()));
label->setToolTip("Value for " + info->m_name);
widgets.append(label);
layout->addWidget(label);
}
break;
}
}
break;
case DeviceDiscoverer::STRING:
{
QLineEdit *lineEdit = new QLineEdit();
lineEdit->setToolTip("Set value for " + info->m_name);
connect(lineEdit, &QLineEdit::editingFinished,
[=] ()
{
QString text = lineEdit->text();
RemoteControl::MsgDeviceSetState *message = RemoteControl::MsgDeviceSetState::create(gui->m_rcDevice->m_protocol,
gui->m_rcDevice->m_info.m_id,
control.m_id,
text);
m_remoteControl->getInputMessageQueue()->push(message);
}
);
widgets.append(lineEdit);
widget = lineEdit;
}
break;
case DeviceDiscoverer::LIST:
{
QComboBox *combo = new QComboBox();
combo->setToolTip("Set value for " + info->m_name);
combo->insertItems(0, info->m_values);
connect(combo, &QComboBox::currentTextChanged,
[=] (const QString &text)
{
RemoteControl::MsgDeviceSetState *message = RemoteControl::MsgDeviceSetState::create(gui->m_rcDevice->m_protocol,
gui->m_rcDevice->m_info.m_id,
control.m_id,
text);
m_remoteControl->getInputMessageQueue()->push(message);
}
);
widgets.append(combo);
widget = combo;
}
break;
case DeviceDiscoverer::BUTTON:
{
QString label = info->m_name;
if (info->m_values.size() > 0) {
label = info->m_values[0];
}
QToolButton *button = new QToolButton();
button->setText(label);
button->setToolTip("Trigger " + info->m_name);
connect(button, &QToolButton::clicked,
[=] (bool checked)
{
(void) checked;
RemoteControl::MsgDeviceSetState *message = RemoteControl::MsgDeviceSetState::create(gui->m_rcDevice->m_protocol,
gui->m_rcDevice->m_info.m_id,
control.m_id,
1);
m_remoteControl->getInputMessageQueue()->push(message);
}
);
widgets.append(button);
widget = button;
}
break;
default:
qDebug() << "RemoteControlGUI::createControls: Unexpected type for control.";
break;
}
gui->m_controls.insert(control.m_id, widgets);
if (gui->m_rcDevice->m_verticalControls) {
controlsGrid->addWidget(widget, row, 1);
} else {
flow->addWidget(widget);
}
if (!control.m_labelRight.isEmpty())
{
QLabel *controlLabelRight = new QLabel(control.m_labelRight);
if (gui->m_rcDevice->m_verticalControls)
{
controlsGrid->addWidget(controlLabelRight, row, 2);
controlsGrid->setColumnStretch(row, 2);
}
else
{
flow->addWidget(controlLabelRight);
}
}
widgetCnt++;
row++;
}
}
void RemoteControlGUI::createChart(RemoteControlDeviceGUI *gui, QVBoxLayout *vBox, const QString &id, const QString &units)
{
if (gui->m_chart == nullptr)
{
// Create a chart to plot the sensor data
gui->m_chart = new QChart();
gui->m_chart->setTitle("");
gui->m_chart->legend()->hide();
gui->m_chart->layout()->setContentsMargins(0, 0, 0, 0);
gui->m_chart->setMargins(QMargins(1, 1, 1, 1));
gui->m_chart->setTheme(QChart::ChartThemeDark);
QLineSeries *series = new QLineSeries();
gui->m_series.insert(id, series);
QLineSeries *onePointSeries = new QLineSeries();
gui->m_onePointSeries.insert(id, onePointSeries);
gui->m_chart->addSeries(series);
QValueAxis *yAxis = new QValueAxis();
QDateTimeAxis *xAxis = new QDateTimeAxis();
xAxis->setFormat(QString("hh:mm:ss"));
yAxis->setTitleText(units);
gui->m_chart->addAxis(xAxis, Qt::AlignBottom);
gui->m_chart->addAxis(yAxis, Qt::AlignLeft);
series->attachAxis(xAxis);
series->attachAxis(yAxis);
gui->m_chartView = new QChartView();
gui->m_chartView->setChart(gui->m_chart);
if (m_settings.m_chartHeightFixed)
{
gui->m_chartView->setMinimumSize(300, m_settings.m_chartHeightPixels);
gui->m_chartView->setMaximumSize(16777215, m_settings.m_chartHeightPixels);
gui->m_chartView->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
}
else
{
gui->m_chartView->setMinimumSize(300, 130); // 130 is enough to display axis labels
gui->m_chartView->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
gui->m_chartView->setSceneRect(0, 0, 300, 130); // This determines m_chartView->sizeHint() - default is 640x480, which is a bit big
}
QBoxLayout *chartLayout = new QVBoxLayout();
gui->m_chartView->setLayout(chartLayout);
vBox->addWidget(gui->m_chartView);
}
else
{
// Add new series
QLineSeries *series = new QLineSeries();
gui->m_series.insert(id, series);
QLineSeries *onePointSeries = new QLineSeries();
gui->m_onePointSeries.insert(id, onePointSeries);
gui->m_chart->addSeries(series);
if (!gui->m_rcDevice->m_commonYAxis)
{
// Use per series Y axis
QValueAxis *yAxis = new QValueAxis();
yAxis->setTitleText(units);
gui->m_chart->addAxis(yAxis, Qt::AlignRight);
series->attachAxis(yAxis);
}
else
{
// Use common y axis
QAbstractAxis *yAxis = gui->m_chart->axes(Qt::Vertical)[0];
// Only display units if all the same
if (yAxis->titleText() != units) {
yAxis->setTitleText("");
}
series->attachAxis(yAxis);
}
series->attachAxis(gui->m_chart->axes(Qt::Horizontal)[0]);
}
}
void RemoteControlGUI::createSensors(RemoteControlDeviceGUI *gui, QVBoxLayout *vBox, FlowLayout *flow, int &widgetCnt, bool &hasCharts)
{
// Table doesn't seem to expand in a QHBoxLayout, so we have to use a GridLayout
QGridLayout *grid = nullptr;
QTableWidget *table = nullptr;
if (gui->m_rcDevice->m_verticalSensors)
{
grid = new QGridLayout();
grid->setColumnStretch(0, 1);
vBox->addLayout(grid);
table = new QTableWidget(gui->m_rcDevice->m_sensors.size(), 3);
table->verticalHeader()->setVisible(false);
table->horizontalHeader()->setVisible(false);
table->horizontalHeader()->setSectionResizeMode(0, QHeaderView::ResizeToContents);
table->horizontalHeader()->setSectionResizeMode(1, QHeaderView::Stretch);
table->horizontalHeader()->setSectionResizeMode(2, QHeaderView::ResizeToContents);
table->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Minimum);
table->setSizeAdjustPolicy(QAbstractScrollArea::AdjustToContents); // Needed so table->sizeHint matches minimumSize set below
}
else if (!flow)
{
flow = new FlowLayout(2, 6, 6);
vBox->addItem(flow);
}
int row = 0;
bool hasUnits = false;
for (auto const &sensor : gui->m_rcDevice->m_sensors)
{
// For vertical layout, we use a table
// For horizontal, we use HBox of labels separated with bars
if (gui->m_rcDevice->m_verticalSensors)
{
if (!sensor.m_labelLeft.isEmpty())
{
QTableWidgetItem *sensorLabel = new QTableWidgetItem(sensor.m_labelLeft);
sensorLabel->setFlags(Qt::ItemIsEnabled);
table->setItem(row, COL_LABEL, sensorLabel);
}
QTableWidgetItem *valueItem = new QTableWidgetItem("-");
table->setItem(row, COL_VALUE, valueItem);
valueItem->setTextAlignment(Qt::AlignRight | Qt::AlignVCenter);
valueItem->setFlags(Qt::ItemIsEnabled);
if (!sensor.m_labelRight.isEmpty())
{
QTableWidgetItem *unitsItem = new QTableWidgetItem(sensor.m_labelRight);
unitsItem->setFlags(Qt::ItemIsEnabled);
table->setItem(row, COL_UNITS, unitsItem);
hasUnits = true;
}
gui->m_sensorValueItems.insert(sensor.m_id, valueItem);
grid->addWidget(table, 0, 0);
}
else
{
if (widgetCnt > 0)
{
QFrame *line = new QFrame();
line->setFrameShape(QFrame::VLine);
line->setFrameShadow(QFrame::Sunken);
flow->addWidget(line);
}
if (!sensor.m_labelLeft.isEmpty())
{
QLabel *sensorLabel = new QLabel(sensor.m_labelLeft);
flow->addWidget(sensorLabel);
}
QLabel *sensorValue = new QLabel("-");
flow->addWidget(sensorValue);
if (!sensor.m_labelRight.isEmpty())
{
QLabel *sensorUnits = new QLabel(sensor.m_labelRight);
flow->addWidget(sensorUnits);
}
gui->m_sensorValueLabels.insert(sensor.m_id, sensorValue);
}
if (sensor.m_plot)
{
createChart(gui, vBox, sensor.m_id, sensor.m_labelRight);
hasCharts = true;
}
widgetCnt++;
row++;
}
if (table)
{
table->resizeColumnToContents(COL_LABEL);
if (hasUnits) {
table->resizeColumnToContents(COL_UNITS);
} else {
table->hideColumn(COL_UNITS);
}
int tableWidth = 0;
for (int i = 0; i < table->columnCount(); i++){
tableWidth += table->columnWidth(i);
}
int tableHeight = 0;
for (int i = 0; i < table->rowCount(); i++){
tableHeight += table->rowHeight(i);
}
table->setMinimumWidth(tableWidth);
table->setMinimumHeight(tableHeight+2);
}
}
RemoteControlGUI::RemoteControlDeviceGUI *RemoteControlGUI::createDeviceGUI(RemoteControlDevice *rcDevice)
{
// Create the UI for the device
RemoteControlDeviceGUI *gui = new RemoteControlDeviceGUI(rcDevice);
bool hasCharts = false;
gui->m_container = new QWidget(getRollupContents());
gui->m_container->setWindowTitle(gui->m_rcDevice->m_label);
bool vertical = gui->m_rcDevice->m_verticalControls || gui->m_rcDevice->m_verticalSensors;
QVBoxLayout *vBox = new QVBoxLayout();
vBox->setContentsMargins(2, 2, 2, 2);
FlowLayout *flow = nullptr;
if (!vertical)
{
flow = new FlowLayout(2, 6, 6);
vBox->addItem(flow);
}
int widgetCnt = 0;
// Create buttons to control the device
createControls(gui, vBox, flow, widgetCnt);
if (gui->m_rcDevice->m_verticalControls) {
widgetCnt = 0;
}
// Create widgets to display the sensor label and its value
createSensors(gui, vBox, flow, widgetCnt, hasCharts);
gui->m_container->setLayout(vBox);
if (hasCharts && !m_settings.m_chartHeightFixed) {
gui->m_container->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
}
gui->m_container->show();
return gui;
}
void RemoteControlGUI::createGUI()
{
// Delete existing elements
for (auto gui : m_deviceGUIs)
{
delete gui->m_container;
gui->m_container = nullptr;
}
qDeleteAll(m_deviceGUIs);
m_deviceGUIs.clear();
// Create new GUIs for each device
bool expanding = false;
for (auto device : m_settings.m_devices)
{
RemoteControlDeviceGUI *gui = createDeviceGUI(device);
m_deviceGUIs.append(gui);
if (gui->m_container->sizePolicy().verticalPolicy() == QSizePolicy::Expanding) {
expanding = true;
}
}
if (expanding)
{
getRollupContents()->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
}
else
{
getRollupContents()->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
}
// FIXME: Why are these three steps needed to get the window
// to resize to the newly added widgets?
getRollupContents()->arrangeRollups(); // Recalc rollup size
layout()->activate(); // Get QMdiSubWindow to recalc its sizeHint
resize(sizeHint());
// Need to do it twice when FlowLayout is used!
getRollupContents()->arrangeRollups();
layout()->activate();
resize(sizeHint());
}
void RemoteControlGUI::on_startStop_toggled(bool checked)
{
if (m_doApplySettings)
{
RemoteControl::MsgStartStop *message = RemoteControl::MsgStartStop::create(checked);
m_remoteControl->getInputMessageQueue()->push(message);
}
}
void RemoteControlGUI::on_update_clicked()
{
RemoteControl::MsgDeviceGetState *message = RemoteControl::MsgDeviceGetState::create();
m_remoteControl->getInputMessageQueue()->push(message);
}
void RemoteControlGUI::on_settings_clicked()
{
// Display settings dialog
RemoteControlSettingsDialog dialog(&m_settings);
if (dialog.exec() == QDialog::Accepted)
{
createGUI();
applySettings();
on_update_clicked();
}
}
void RemoteControlGUI::on_clearData_clicked()
{
// Clear data in all charts
for (auto deviceGUI : m_deviceGUIs)
{
for (auto series : deviceGUI->m_series) {
series->clear();
}
for (auto series : deviceGUI->m_onePointSeries) {
series->clear();
}
}
}
// Update a control widget with latest state value
void RemoteControlGUI::updateControl(QWidget *widget, const DeviceDiscoverer::ControlInfo *controlInfo, const QString &key, const QVariant &value)
{
if (ButtonSwitch *button = qobject_cast<ButtonSwitch *>(widget))
{
if ((QMetaType::Type)value.type() == QMetaType::QString)
{
if (value.toString() == "unavailable")
{
button->setStyleSheet("QToolButton { background-color : gray; }"
"QToolButton:checked { background-color : gray; }"
"QToolButton:disabled { background-color : gray; }");
}
else if (value.toString() == "error")
{
button->setStyleSheet("QToolButton { background-color : red; }"
"QToolButton:checked { background-color : red; }"
"QToolButton:disabled { background-color : red; }");
}
else
{
qDebug() << "RemoteControlGUI::updateControl: String value for button " << key << value;
}
}
else
{
int state = value.toInt();
int prev = button->blockSignals(true);
button->setChecked(state != 0);
button->blockSignals(prev);
button->setStyleSheet("QToolButton { background-color : blue; }"
"QToolButton:checked { background-color : green; }"
"QToolButton:disabled { background-color : gray; }");
}
}
else if (QSpinBox *spinBox = qobject_cast<QSpinBox *>(widget))
{
int prev = spinBox->blockSignals(true);
if (value.toString() == "unavailable")
{
spinBox->setStyleSheet("QSpinBox { background-color : gray; }");
}
else if (value.toString() == "error")
{
spinBox->setStyleSheet("QSpinBox { background-color : red; }");
}
else
{
int state = value.toInt();
bool outOfRange = (state < spinBox->minimum()) || (state > spinBox->maximum());
spinBox->setValue(state);
if (outOfRange) {
spinBox->setStyleSheet("QSpinBox { background-color : red; }");
} else {
spinBox->setStyleSheet("");
}
}
spinBox->blockSignals(prev);
}
else if (QDoubleSpinBox *spinBox = qobject_cast<QDoubleSpinBox *>(widget))
{
int prev = spinBox->blockSignals(true);
if (value.toString() == "unavailable")
{
spinBox->setStyleSheet("QDoubleSpinBox { background-color : gray; }");
}
else if (value.toString() == "error")
{
spinBox->setStyleSheet("QDoubleSpinBox { background-color : red; }");
}
else
{
double state = value.toDouble();
if (controlInfo) {
state = state / controlInfo->m_scale;
}
bool outOfRange = (state < spinBox->minimum()) || (state > spinBox->maximum());
spinBox->setValue(state);
if (outOfRange) {
spinBox->setStyleSheet("QDoubleSpinBox { background-color : red; }");
} else {
spinBox->setStyleSheet("");
}
}
spinBox->blockSignals(prev);
}
else if (QDial *dial = qobject_cast<QDial *>(widget))
{
int prev = dial->blockSignals(true);
if (value.toString() == "unavailable")
{
dial->setStyleSheet("QDial { background-color : gray; }");
}
else if (value.toString() == "error")
{
dial->setStyleSheet("QDial { background-color : red; }");
}
else
{
double state = value.toDouble();
if (controlInfo) {
state = state / controlInfo->m_scale;
}
bool outOfRange = (state < dial->minimum()) || (state > dial->maximum());
dial->setValue(state);
if (outOfRange) {
dial->setStyleSheet("QDial { background-color : red; }");
} else {
dial->setStyleSheet("");
}
}
dial->blockSignals(prev);
}
else if (QSlider *slider = qobject_cast<QSlider *>(widget))
{
int prev = slider->blockSignals(true);
if (value.toString() == "unavailable")
{
slider->setStyleSheet("QSlider { background-color : gray; }");
}
else if (value.toString() == "error")
{
slider->setStyleSheet("QSlider { background-color : red; }");
}
else
{
double state = value.toDouble();
if (controlInfo) {
state = state / controlInfo->m_scale;
}
bool outOfRange = (state < slider->minimum()) || (state > slider->maximum());
slider->setValue(state);
if (outOfRange) {
slider->setStyleSheet("QSlider { background-color : red; }");
} else {
slider->setStyleSheet("");
}
}
slider->blockSignals(prev);
}
else if (QComboBox *comboBox = qobject_cast<QComboBox *>(widget))
{
int prev = comboBox->blockSignals(true);
QString string = value.toString();
int index = comboBox->findText(string);
if (index != -1)
{
comboBox->setCurrentIndex(index);
comboBox->setStyleSheet("");
}
else
{
comboBox->setStyleSheet("QComboBox { background-color : red; }");
}
comboBox->blockSignals(prev);
}
else if (QLineEdit *lineEdit = qobject_cast<QLineEdit *>(widget))
{
lineEdit->setText(value.toString());
}
else if (QLabel *label = qobject_cast<QLabel *>(widget))
{
label->setText(value.toString());
}
else
{
qDebug() << "RemoteControlGUI::updateControl: Unexpected widget type";
}
}
void RemoteControlGUI::updateChart(RemoteControlDeviceGUI *deviceGUI, const QString &key, const QVariant &value)
{
// Format the value for display
bool ok = false;
double d = value.toDouble(&ok);
bool iOk = false;
int iValue = value.toInt(&iOk);
QString formattedValue;
RemoteControlSensor *sensor = deviceGUI->m_rcDevice->getSensor(key);
QString format = sensor->m_format.trimmed();
if (format.contains("%s"))
{
formattedValue = QString::asprintf(format.toUtf8(), value.toString().toUtf8().data());
}
else if (format.contains("%d") || format.contains("%u") || format.contains("%x") || format.contains("%X"))
{
formattedValue = QString::asprintf(format.toUtf8(), value.toInt());
}
else if (((QMetaType::Type)value.type() == QMetaType::Double) || ((QMetaType::Type)value.type() == QMetaType::Float))
{
if (format.isEmpty()) {
format = "%.1f";
}
formattedValue = QString::asprintf(format.toUtf8(), value.toDouble());
}
else if (iOk)
{
formattedValue = QString::asprintf("%d", iValue);
}
else
{
formattedValue = value.toString();
}
// Update sensor value widget to display the latest value
if (deviceGUI->m_sensorValueLabels.contains(key)) {
deviceGUI->m_sensorValueLabels.value(key)->setText(formattedValue);
} else {
deviceGUI->m_sensorValueItems.value(key)->setText(formattedValue);
}
// Plot value on chart
if (deviceGUI->m_series.contains(key))
{
QLineSeries *onePointSeries = deviceGUI->m_onePointSeries.value(key);
QLineSeries *series = deviceGUI->m_series.value(key);
QDateTime dt = QDateTime::currentDateTime();
if (ok)
{
// Charts aren't displayed properly if series has only one point,
// so we save the first point in an additional series: onePointSeries
if (onePointSeries->count() == 0)
{
onePointSeries->append(dt.toMSecsSinceEpoch(), d);
}
else
{
if (series->count() == 0) {
series->append(onePointSeries->at(0));
}
series->append(dt.toMSecsSinceEpoch(), d);
QList<QAbstractAxis *> axes = deviceGUI->m_chart->axes(Qt::Horizontal, series);
QDateTimeAxis *dtAxis = (QDateTimeAxis *)axes[0];
QDateTime start = QDateTime::fromMSecsSinceEpoch(series->at(0).x());
QDateTime end = QDateTime::fromMSecsSinceEpoch(series->at(series->count() - 1).x());
if (start.date() == end.date())
{
if (start.secsTo(end) < 60*5) {
dtAxis->setFormat(QString("hh:mm:ss"));
} else {
dtAxis->setFormat(QString("hh:mm"));
}
}
else
{
dtAxis->setFormat(QString("%1 hh:mm").arg(QLocale::system().dateFormat(QLocale::ShortFormat)));
}
dtAxis->setRange(start, end);
axes = deviceGUI->m_chart->axes(Qt::Vertical, series);
QValueAxis *yAxis = (QValueAxis *)axes[0];
if (series->count() == 2)
{
double y1 = series->at(0).y();
double y2 = series->at(1).y();
double yMin = std::min(y1, y2);
double yMax = std::max(y1, y2);
double min = (yMin >= 0.0) ? yMin * 0.9 : yMin * 1.1;
double max = (yMax >= 0.0) ? yMax * 1.1 : yMax * 0.9;
yAxis->setRange(min, max);
}
else
{
double min = (d >= 0.0) ? d * 0.9 : d * 1.1;
double max = (d >= 0.0) ? d * 1.1 : d * 0.9;
if (min < yAxis->min()) {
yAxis->setMin(min);
}
if (max > yAxis->max()) {
yAxis->setMax(max);
}
}
}
}
else
{
qDebug() << "RemoteControlGUI::deviceUpdated: Error converting " << key << value;
}
}
}
void RemoteControlGUI::deviceUpdated(const QString &protocol, const QString &deviceId, const QHash<QString, QVariant> &status)
{
for (auto deviceGUI : m_deviceGUIs)
{
if ( (protocol == deviceGUI->m_rcDevice->m_protocol)
&& (deviceId == deviceGUI->m_rcDevice->m_info.m_id))
{
deviceGUI->m_container->setEnabled(true);
QHashIterator<QString, QVariant> itr(status);
while (itr.hasNext())
{
itr.next();
QString key = itr.key();
QVariant value = itr.value();
if (deviceGUI->m_controls.contains(key))
{
// Update control(s) to display latest state
QList<QWidget *> widgets = deviceGUI->m_controls.value(key);
DeviceDiscoverer::ControlInfo *control = deviceGUI->m_rcDevice->m_info.getControl(key);
for (auto widget : widgets) {
updateControl(widget, control, key, value);
}
}
else if (deviceGUI->m_sensorValueLabels.contains(key) || deviceGUI->m_sensorValueItems.contains(key))
{
// Plot on chart
updateChart(deviceGUI, key, value);
}
else
{
qDebug() << "RemoteControlGUI::deviceUpdated: Unexpected status key " << key << value;
}
}
}
}
}
void RemoteControlGUI::deviceUnavailable(const QString &protocol, const QString &deviceId)
{
for (auto deviceGUI : m_deviceGUIs)
{
if ( (protocol == deviceGUI->m_rcDevice->m_protocol)
&& (deviceId == deviceGUI->m_rcDevice->m_info.m_id))
{
deviceGUI->m_container->setEnabled(false);
}
}
}
void RemoteControlGUI::applySettings(bool force)
{
if (m_doApplySettings)
{
RemoteControl::MsgConfigureRemoteControl* message = RemoteControl::MsgConfigureRemoteControl::create(m_settings, force);
m_remoteControl->getInputMessageQueue()->push(message);
}
}
void RemoteControlGUI::makeUIConnections()
{
QObject::connect(ui->startStop, &ButtonSwitch::toggled, this, &RemoteControlGUI::on_startStop_toggled);
QObject::connect(ui->update, &QToolButton::clicked, this, &RemoteControlGUI::on_update_clicked);
QObject::connect(ui->settings, &QToolButton::clicked, this, &RemoteControlGUI::on_settings_clicked);
QObject::connect(ui->clearData, &QToolButton::clicked, this, &RemoteControlGUI::on_clearData_clicked);
}