mirror of
https://github.com/GoldenCheetah/GoldenCheetah.git
synced 2026-02-16 17:39:58 +00:00
2250 lines
74 KiB
C++
2250 lines
74 KiB
C++
/*
|
|
* Copyright (c) 2009 Mark Liversedge (liversedge@gmail.com)
|
|
*
|
|
* 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; either version 2 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 for
|
|
* more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along
|
|
* with this program; if not, write to the Free Software Foundation, Inc., 51
|
|
* Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*/
|
|
|
|
#include "TrainSidebar.h"
|
|
#include "MainWindow.h"
|
|
#include "Context.h"
|
|
#include "Athlete.h"
|
|
#include "Settings.h"
|
|
#include "Colors.h"
|
|
#include "Units.h"
|
|
#include "DeviceTypes.h"
|
|
#include "DeviceConfiguration.h"
|
|
#include "RideImportWizard.h"
|
|
#include <QApplication>
|
|
#include <QtGui>
|
|
#include <QRegExp>
|
|
#include <QStyle>
|
|
#include <QStyleFactory>
|
|
#include <QScrollBar>
|
|
|
|
#include <QEvent>
|
|
#include <QInputEvent>
|
|
#include <QKeyEvent>
|
|
|
|
// Three current realtime device types supported are:
|
|
#include "RealtimeController.h"
|
|
#include "ComputrainerController.h"
|
|
#if QT_VERSION >= 0x050000
|
|
#include "MonarkController.h"
|
|
#include "KettlerController.h"
|
|
#endif
|
|
#include "ANTlocalController.h"
|
|
#include "NullController.h"
|
|
#ifdef QT_BLUETOOTH_LIB
|
|
#include "BT40Controller.h"
|
|
#endif
|
|
#ifdef GC_HAVE_LIBUSB
|
|
#include "FortiusController.h"
|
|
#endif
|
|
|
|
// Media selection helper
|
|
#ifndef Q_OS_MAC
|
|
#include "VideoWindow.h"
|
|
#endif
|
|
|
|
#ifdef Q_OS_MAC
|
|
#include "QtMacVideoWindow.h"
|
|
#include <CoreServices/CoreServices.h>
|
|
#include <QStyle>
|
|
#include <QStyleFactory>
|
|
#endif
|
|
|
|
#ifdef WIN32
|
|
#include "windows.h"
|
|
#endif
|
|
|
|
#include <cmath> // isnan and isinf
|
|
#include "TrainDB.h"
|
|
#include "Library.h"
|
|
|
|
TrainSidebar::TrainSidebar(Context *context) : GcWindow(context), context(context)
|
|
{
|
|
QWidget *c = new QWidget;
|
|
//c->setContentsMargins(0,0,0,0); // bit of space is useful
|
|
QVBoxLayout *cl = new QVBoxLayout(c);
|
|
setControls(c);
|
|
autoConnect = false;
|
|
|
|
cl->setSpacing(0);
|
|
cl->setContentsMargins(0,0,0,0);
|
|
|
|
// don't set the source for telemetry
|
|
lastAppliedIntensity = 100;
|
|
bpmTelemetry = wattsTelemetry = kphTelemetry = rpmTelemetry = -1;
|
|
|
|
#if !defined GC_VIDEO_NONE
|
|
videoModel = new QSqlTableModel(this, trainDB->connection());
|
|
videoModel->setTable("videos");
|
|
videoModel->setEditStrategy(QSqlTableModel::OnManualSubmit);
|
|
videoModel->select();
|
|
while (videoModel->canFetchMore(QModelIndex())) videoModel->fetchMore(QModelIndex());
|
|
|
|
vsortModel = new QSortFilterProxyModel(this);
|
|
vsortModel->setSourceModel(videoModel);
|
|
vsortModel->setDynamicSortFilter(true);
|
|
vsortModel->sort(1, Qt::AscendingOrder); //filename order
|
|
|
|
mediaTree = new QTreeView;
|
|
mediaTree->setModel(vsortModel);
|
|
|
|
// hide unwanted columns and header
|
|
for(int i=0; i<mediaTree->header()->count(); i++)
|
|
mediaTree->setColumnHidden(i, true);
|
|
mediaTree->setColumnHidden(1, false); // show filename
|
|
mediaTree->header()->hide();
|
|
|
|
mediaTree->setSortingEnabled(false);
|
|
mediaTree->setAlternatingRowColors(false);
|
|
mediaTree->setEditTriggers(QAbstractItemView::NoEditTriggers); // read-only
|
|
mediaTree->expandAll();
|
|
mediaTree->header()->setCascadingSectionResizes(true); // easier to resize this way
|
|
mediaTree->setContextMenuPolicy(Qt::CustomContextMenu);
|
|
mediaTree->header()->setStretchLastSection(true);
|
|
mediaTree->header()->setMinimumSectionSize(0);
|
|
mediaTree->header()->setFocusPolicy(Qt::NoFocus);
|
|
mediaTree->setFrameStyle(QFrame::NoFrame);
|
|
#ifdef Q_OS_MAC
|
|
mediaTree->header()->setSortIndicatorShown(false); // blue looks nasty
|
|
mediaTree->setAttribute(Qt::WA_MacShowFocusRect, 0);
|
|
#endif
|
|
#ifdef Q_OS_WIN
|
|
QStyle *cde = QStyleFactory::create(OS_STYLE);
|
|
mediaTree->verticalScrollBar()->setStyle(cde);
|
|
#endif
|
|
|
|
|
|
#ifdef GC_HAVE_VLC // RLV currently only support for VLC
|
|
videosyncModel = new QSqlTableModel(this, trainDB->connection());
|
|
videosyncModel->setTable("videosyncs");
|
|
videosyncModel->setEditStrategy(QSqlTableModel::OnManualSubmit);
|
|
videosyncModel->select();
|
|
while (videosyncModel->canFetchMore(QModelIndex())) videosyncModel->fetchMore(QModelIndex());
|
|
|
|
vssortModel = new QSortFilterProxyModel(this);
|
|
vssortModel->setSourceModel(videosyncModel);
|
|
vssortModel->setDynamicSortFilter(true);
|
|
vssortModel->sort(1, Qt::AscendingOrder); //filename order
|
|
|
|
videosyncTree = new QTreeView;
|
|
videosyncTree->setModel(vssortModel);
|
|
|
|
// hide unwanted columns and header
|
|
for(int i=0; i<videosyncTree->header()->count(); i++)
|
|
videosyncTree->setColumnHidden(i, true);
|
|
videosyncTree->setColumnHidden(1, false); // show filename
|
|
videosyncTree->header()->hide();
|
|
|
|
videosyncTree->setSortingEnabled(false);
|
|
videosyncTree->setAlternatingRowColors(false);
|
|
videosyncTree->setEditTriggers(QAbstractItemView::NoEditTriggers); // read-only
|
|
videosyncTree->expandAll();
|
|
videosyncTree->header()->setCascadingSectionResizes(true); // easier to resize this way
|
|
videosyncTree->setContextMenuPolicy(Qt::CustomContextMenu);
|
|
videosyncTree->header()->setStretchLastSection(true);
|
|
videosyncTree->header()->setMinimumSectionSize(0);
|
|
videosyncTree->header()->setFocusPolicy(Qt::NoFocus);
|
|
videosyncTree->setFrameStyle(QFrame::NoFrame);
|
|
#ifdef Q_OS_MAC
|
|
videosyncTree->header()->setSortIndicatorShown(false); // blue looks nasty
|
|
videosyncTree->setAttribute(Qt::WA_MacShowFocusRect, 0);
|
|
#endif
|
|
#ifdef Q_OS_WIN
|
|
QStyle *cdevideosync = QStyleFactory::create(OS_STYLE);
|
|
videosyncTree->verticalScrollBar()->setStyle(cdevideosync);
|
|
#endif
|
|
|
|
#endif //GC_HAVE_VLC
|
|
|
|
#endif //GC_VIDEO_NONE
|
|
|
|
deviceTree = new QTreeWidget;
|
|
deviceTree->setFrameStyle(QFrame::NoFrame);
|
|
if (appsettings->value(this, TRAIN_MULTI, false).toBool() == true)
|
|
deviceTree->setSelectionMode(QAbstractItemView::MultiSelection);
|
|
else
|
|
deviceTree->setSelectionMode(QAbstractItemView::SingleSelection);
|
|
deviceTree->setColumnCount(1);
|
|
deviceTree->header()->hide();
|
|
deviceTree->setAlternatingRowColors (false);
|
|
deviceTree->setIndentation(5);
|
|
deviceTree->expandItem(deviceTree->invisibleRootItem());
|
|
deviceTree->setContextMenuPolicy(Qt::CustomContextMenu);
|
|
#ifdef Q_OS_WIN
|
|
QStyle *xde = QStyleFactory::create(OS_STYLE);
|
|
deviceTree->verticalScrollBar()->setStyle(xde);
|
|
#endif
|
|
|
|
workoutModel = new QSqlTableModel(this, trainDB->connection());
|
|
workoutModel->setTable("workouts");
|
|
workoutModel->setEditStrategy(QSqlTableModel::OnManualSubmit);
|
|
workoutModel->select();
|
|
while (workoutModel->canFetchMore(QModelIndex())) workoutModel->fetchMore(QModelIndex());
|
|
|
|
sortModel = new QSortFilterProxyModel(this);
|
|
sortModel->setSourceModel(workoutModel);
|
|
sortModel->setDynamicSortFilter(true);
|
|
sortModel->sort(1, Qt::AscendingOrder); //filename order
|
|
|
|
workoutTree = new QTreeView;
|
|
workoutTree->setModel(sortModel);
|
|
|
|
// hide unwanted columns and header
|
|
for(int i=0; i<workoutTree->header()->count(); i++)
|
|
workoutTree->setColumnHidden(i, true);
|
|
workoutTree->setColumnHidden(1, false); // show filename
|
|
workoutTree->header()->hide();
|
|
workoutTree->setFrameStyle(QFrame::NoFrame);
|
|
workoutTree->setAlternatingRowColors(false);
|
|
workoutTree->setEditTriggers(QAbstractItemView::NoEditTriggers); // read-only
|
|
workoutTree->setSelectionMode(QAbstractItemView::ExtendedSelection);
|
|
workoutTree->expandAll();
|
|
workoutTree->header()->setCascadingSectionResizes(true); // easier to resize this way
|
|
workoutTree->setContextMenuPolicy(Qt::CustomContextMenu);
|
|
workoutTree->header()->setStretchLastSection(true);
|
|
workoutTree->header()->setMinimumSectionSize(0);
|
|
workoutTree->header()->setFocusPolicy(Qt::NoFocus);
|
|
workoutTree->setFrameStyle(QFrame::NoFrame);
|
|
#ifdef Q_OS_MAC
|
|
workoutTree->header()->setSortIndicatorShown(false); // blue looks nasty
|
|
workoutTree->setAttribute(Qt::WA_MacShowFocusRect, 0);
|
|
#endif
|
|
#ifdef Q_OS_WIN
|
|
xde = QStyleFactory::create(OS_STYLE);
|
|
workoutTree->verticalScrollBar()->setStyle(xde);
|
|
#endif
|
|
|
|
connect(context, SIGNAL(newLap()), this, SLOT(resetLapTimer()));
|
|
connect(context, SIGNAL(viewChanged(int)), this, SLOT(viewChanged(int)));
|
|
|
|
// not used but kept in case re-instated in the future
|
|
recordSelector = new QCheckBox(this);
|
|
recordSelector->setText(tr("Save workout data"));
|
|
recordSelector->setChecked(true);
|
|
recordSelector->hide(); // we don't let users change this for now
|
|
|
|
trainSplitter = new GcSplitter(Qt::Vertical);
|
|
trainSplitter->setContentsMargins(0,0,0,0);
|
|
deviceItem = new GcSplitterItem(tr("Devices"), iconFromPNG(":images/sidebar/power.png"), this);
|
|
|
|
// devices splitter actions
|
|
QAction *moreDeviceAct = new QAction(iconFromPNG(":images/sidebar/extra.png"), tr("Menu"), this);
|
|
deviceItem->addAction(moreDeviceAct);
|
|
connect(moreDeviceAct, SIGNAL(triggered(void)), this, SLOT(devicePopup(void)));
|
|
|
|
workoutItem = new GcSplitterItem(tr("Workouts"), iconFromPNG(":images/sidebar/folder.png"), this);
|
|
QAction *moreWorkoutAct = new QAction(iconFromPNG(":images/sidebar/extra.png"), tr("Menu"), this);
|
|
workoutItem->addAction(moreWorkoutAct);
|
|
connect(moreWorkoutAct, SIGNAL(triggered(void)), this, SLOT(workoutPopup(void)));
|
|
|
|
deviceItem->addWidget(deviceTree);
|
|
trainSplitter->addWidget(deviceItem);
|
|
workoutItem->addWidget(workoutTree);
|
|
trainSplitter->addWidget(workoutItem);
|
|
cl->addWidget(trainSplitter);
|
|
|
|
|
|
#if !defined GC_VIDEO_NONE
|
|
mediaItem = new GcSplitterItem(tr("Media"), iconFromPNG(":images/sidebar/movie.png"), this);
|
|
QAction *moreMediaAct = new QAction(iconFromPNG(":images/sidebar/extra.png"), tr("Menu"), this);
|
|
mediaItem->addAction(moreMediaAct);
|
|
connect(moreMediaAct, SIGNAL(triggered(void)), this, SLOT(mediaPopup(void)));
|
|
mediaItem->addWidget(mediaTree);
|
|
trainSplitter->addWidget(mediaItem);
|
|
|
|
#ifdef GC_HAVE_VLC // RLV currently only support for VLC
|
|
videosyncItem = new GcSplitterItem(tr("VideoSync"), iconFromPNG(":images/sidebar/sync.png"), this);
|
|
QAction *moreVideoSyncAct = new QAction(iconFromPNG(":images/sidebar/extra.png"), tr("Menu"), this);
|
|
videosyncItem->addAction(moreVideoSyncAct);
|
|
connect(moreVideoSyncAct, SIGNAL(triggered(void)), this, SLOT(videosyncPopup(void)));
|
|
videosyncItem->addWidget(videosyncTree);
|
|
trainSplitter->addWidget(videosyncItem);
|
|
#endif //GC_HAVE_VLC
|
|
#endif //GC_VIDEO_NONE
|
|
trainSplitter->prepare(context->athlete->cyclist, "train");
|
|
|
|
#ifdef Q_OS_MAC
|
|
// get rid of annoying focus rectangle for sidebar components
|
|
#if !defined GC_VIDEO_NONE
|
|
mediaTree->setAttribute(Qt::WA_MacShowFocusRect, 0);
|
|
#if defined GC_HAVE_VLC // not on OSX at present
|
|
videosyncTree->setAttribute(Qt::WA_MacShowFocusRect, 0);
|
|
#endif
|
|
#endif
|
|
workoutTree->setAttribute(Qt::WA_MacShowFocusRect, 0);
|
|
deviceTree->setAttribute(Qt::WA_MacShowFocusRect, 0);
|
|
#endif
|
|
|
|
// handle config changes
|
|
connect(deviceTree,SIGNAL(itemSelectionChanged()), this, SLOT(deviceTreeWidgetSelectionChanged()));
|
|
connect(deviceTree,SIGNAL(customContextMenuRequested(const QPoint &)), this, SLOT(deviceTreeMenuPopup(const QPoint &)));
|
|
|
|
#if !defined GC_VIDEO_NONE
|
|
connect(mediaTree->selectionModel(), SIGNAL(selectionChanged(QItemSelection, QItemSelection)),
|
|
this, SLOT(mediaTreeWidgetSelectionChanged()));
|
|
connect(context, SIGNAL(selectMedia(QString)), this, SLOT(selectVideo(QString)));
|
|
#ifdef GC_HAVE_VLC // RLV currently only support for VLC
|
|
connect(videosyncTree->selectionModel(), SIGNAL(selectionChanged(QItemSelection, QItemSelection)),
|
|
this, SLOT(videosyncTreeWidgetSelectionChanged()));
|
|
connect(context, SIGNAL(selectVideoSync(QString)), this, SLOT(selectVideoSync(QString)));
|
|
#endif //GC_HAVE_VLC
|
|
#endif //GC_VIDEO_NONE
|
|
connect(context, SIGNAL(configChanged(qint32)), this, SLOT(configChanged(qint32)));
|
|
connect(context, SIGNAL(selectWorkout(QString)), this, SLOT(selectWorkout(QString)));
|
|
connect(trainDB, SIGNAL(dataChanged()), this, SLOT(refresh()));
|
|
|
|
connect(workoutTree->selectionModel(), SIGNAL(selectionChanged(QItemSelection, QItemSelection)), this, SLOT(workoutTreeWidgetSelectionChanged()));
|
|
|
|
//XXX ??? main = parent;
|
|
ergFile = NULL;
|
|
videosyncFile = NULL;
|
|
calibrating = false;
|
|
|
|
// Remote control support
|
|
remote = new RemoteControl;
|
|
|
|
// now the GUI is setup lets sort our control variables
|
|
gui_timer = new QTimer(this);
|
|
disk_timer = new QTimer(this);
|
|
load_timer = new QTimer(this);
|
|
|
|
session_time = QTime();
|
|
session_elapsed_msec = 0;
|
|
lap_time = QTime();
|
|
lap_elapsed_msec = 0;
|
|
|
|
recordFile = NULL;
|
|
status = 0;
|
|
setStatusFlags(RT_MODE_ERGO); // ergo mode by default
|
|
mode = ERG;
|
|
pendingConfigChange = false;
|
|
|
|
displayWorkoutLap = displayLap = 0;
|
|
pwrcount = 0;
|
|
cadcount = 0;
|
|
hrcount = 0;
|
|
spdcount = 0;
|
|
lodcount = 0;
|
|
wbalr = wbal = 0;
|
|
load_msecs = total_msecs = lap_msecs = 0;
|
|
displayWorkoutDistance = displayDistance = displayPower = displayHeartRate =
|
|
displaySpeed = displayCadence = slope = load = 0;
|
|
displayLRBalance = displayLTE = displayRTE = displayLPS = displayRPS = 0;
|
|
|
|
connect(gui_timer, SIGNAL(timeout()), this, SLOT(guiUpdate()));
|
|
connect(disk_timer, SIGNAL(timeout()), this, SLOT(diskUpdate()));
|
|
connect(load_timer, SIGNAL(timeout()), this, SLOT(loadUpdate()));
|
|
|
|
configChanged(CONFIG_APPEARANCE | CONFIG_DEVICES | CONFIG_ZONES); // will reset the workout tree
|
|
setLabels();
|
|
|
|
// capture keyboard events so we can control during
|
|
// a workout using basic keyboard controls
|
|
context->mainWindow->installEventFilter(this);
|
|
|
|
#ifndef Q_OS_MAC
|
|
//toolbarButtons->hide();
|
|
#endif
|
|
|
|
}
|
|
|
|
void
|
|
TrainSidebar::refresh()
|
|
{
|
|
int row;
|
|
|
|
#if !defined GC_VIDEO_NONE
|
|
// remember selection
|
|
row = mediaTree->currentIndex().row();
|
|
QString videoPath = mediaTree->model()->data(mediaTree->model()->index(row,0)).toString();
|
|
|
|
#ifdef GC_HAVE_VLC // RLV currently only support for VLC
|
|
// refresh data
|
|
videoModel->select();
|
|
while (videoModel->canFetchMore(QModelIndex())) videoModel->fetchMore(QModelIndex());
|
|
#endif
|
|
|
|
// restore selection
|
|
selectVideo(videoPath);
|
|
|
|
#ifdef GC_HAVE_VLC // RLV currently only support for VLC
|
|
// remember selection
|
|
row = videosyncTree->currentIndex().row();
|
|
QString videosyncPath = videosyncTree->model()->data(videosyncTree->model()->index(row,0)).toString();
|
|
|
|
// refresh data
|
|
videosyncModel->select();
|
|
while (videosyncModel->canFetchMore(QModelIndex())) videosyncModel->fetchMore(QModelIndex());
|
|
|
|
// restore selection
|
|
selectVideoSync(videosyncPath);
|
|
#endif // GC_HAVE_VLC
|
|
|
|
#endif // GC_VIDEO_NONE
|
|
|
|
row = workoutTree->currentIndex().row();
|
|
QString workoutPath = workoutTree->model()->data(workoutTree->model()->index(row,0)).toString();
|
|
|
|
workoutModel->select();
|
|
while (workoutModel->canFetchMore(QModelIndex())) workoutModel->fetchMore(QModelIndex());
|
|
|
|
// restore selection
|
|
selectWorkout(workoutPath);
|
|
}
|
|
|
|
void
|
|
TrainSidebar::workoutPopup()
|
|
{
|
|
// OK - we are working with a specific event..
|
|
QMenu menu(workoutTree);
|
|
QAction *import = new QAction(tr("Import Workout from File"), workoutTree);
|
|
QAction *download = new QAction(tr("Get Workouts from ErgDB"), workoutTree);
|
|
QAction *wizard = new QAction(tr("Create Workout via Wizard"), workoutTree);
|
|
QAction *scan = new QAction(tr("Scan for Workouts"), workoutTree);
|
|
|
|
menu.addAction(import);
|
|
menu.addAction(download);
|
|
menu.addAction(wizard);
|
|
menu.addAction(scan);
|
|
|
|
|
|
// we can delete too
|
|
int delNumber = 0;
|
|
|
|
QModelIndexList list = workoutTree->selectionModel()->selectedRows();
|
|
foreach (QModelIndex index, list)
|
|
{
|
|
QModelIndex target = sortModel->mapToSource(index);
|
|
|
|
QString filename = workoutModel->data(workoutModel->index(target.row(), 0), Qt::DisplayRole).toString();
|
|
if (QFileInfo(filename).exists()) {
|
|
delNumber++;
|
|
}
|
|
}
|
|
|
|
if (delNumber > 0) {
|
|
QAction *del = new QAction(tr("Delete selected Workout"), workoutTree);
|
|
|
|
if (delNumber > 1) {
|
|
del->setText(QString(tr("Delete %1 selected Workouts")).arg(delNumber));
|
|
}
|
|
menu.addAction(del);
|
|
connect(del, SIGNAL(triggered(void)), this, SLOT(deleteWorkouts(void)));
|
|
}
|
|
|
|
// connect menu to functions
|
|
connect(import, SIGNAL(triggered(void)), context->mainWindow, SLOT(importWorkout(void)));
|
|
connect(wizard, SIGNAL(triggered(void)), context->mainWindow, SLOT(showWorkoutWizard(void)));
|
|
connect(download, SIGNAL(triggered(void)), context->mainWindow, SLOT(downloadErgDB(void)));
|
|
connect(scan, SIGNAL(triggered(void)), context->mainWindow, SLOT(manageLibrary(void)));
|
|
|
|
// execute the menu
|
|
menu.exec(trainSplitter->mapToGlobal(QPoint(workoutItem->pos().x()+workoutItem->width()-20,
|
|
workoutItem->pos().y())));
|
|
}
|
|
|
|
bool
|
|
TrainSidebar::eventFilter(QObject *, QEvent *event)
|
|
{
|
|
// do not allow to close the Window when active
|
|
if (event->type() == QEvent::Close) {
|
|
if (status & RT_RUNNING) {
|
|
QMessageBox::warning(this, tr("Train mode active"), tr("Please stop the train mode before closing the window or application."));
|
|
event->ignore();
|
|
return true;
|
|
} else if (gui_timer->isActive()) {
|
|
// we just disconnecting before allowing the window to close
|
|
Disconnect();
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// only when we are recording !
|
|
if (status & RT_RECORDING) {
|
|
|
|
if (event->type() == QEvent::KeyPress) {
|
|
|
|
// we care about cmd / ctrl
|
|
Qt::KeyboardModifiers kmod = static_cast<QInputEvent*>(event)->modifiers();
|
|
bool ctrl = (kmod & Qt::ControlModifier) != 0;
|
|
Q_UNUSED(ctrl);
|
|
|
|
// what was pressed
|
|
int key =static_cast<QKeyEvent*>(event)->key();
|
|
|
|
//
|
|
// We can process the keyboard event here
|
|
// and call any training method
|
|
//
|
|
// KEY FUNCTION
|
|
// Start() - will pause/unpause if running
|
|
// Stop() - will end workout
|
|
// Pause() - pause only
|
|
// UnPause() - unpause
|
|
// FFwd() - nip forward
|
|
// Rewind() - nip back
|
|
// newLap() - new lap marker
|
|
//
|
|
switch(key) {
|
|
|
|
//XXX TODO
|
|
|
|
default:
|
|
break;
|
|
|
|
}
|
|
return true; // we listen to 'em all
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void
|
|
TrainSidebar::mediaPopup()
|
|
{
|
|
// OK - we are working with a specific event..
|
|
QMenu menu(mediaTree);
|
|
QAction *import = new QAction(tr("Import Video from File"), mediaTree);
|
|
QAction *scan = new QAction(tr("Scan for Videos"), mediaTree);
|
|
|
|
menu.addAction(import);
|
|
menu.addAction(scan);
|
|
|
|
// connect menu to functions
|
|
connect(import, SIGNAL(triggered(void)), context->mainWindow, SLOT(importWorkout(void)));
|
|
connect(scan, SIGNAL(triggered(void)), context->mainWindow, SLOT(manageLibrary(void)));
|
|
|
|
QModelIndex current = mediaTree->currentIndex();
|
|
QModelIndex target = vsortModel->mapToSource(current);
|
|
QString filename = videoModel->data(videoModel->index(target.row(), 0), Qt::DisplayRole).toString();
|
|
if (QFileInfo(filename).exists()) {
|
|
QAction *del = new QAction(tr("Remove reference to selected video"), workoutTree);
|
|
menu.addAction(del);
|
|
connect(del, SIGNAL(triggered(void)), this, SLOT(deleteVideos(void)));
|
|
}
|
|
|
|
// execute the menu
|
|
menu.exec(trainSplitter->mapToGlobal(QPoint(mediaItem->pos().x()+mediaItem->width()-20,
|
|
mediaItem->pos().y())));
|
|
}
|
|
|
|
void
|
|
TrainSidebar::videosyncPopup()
|
|
{
|
|
// OK - we are working with a specific event..
|
|
QMenu menu(videosyncTree);
|
|
QAction *import = new QAction(tr("Import VideoSync from File"), videosyncTree);
|
|
QAction *scan = new QAction(tr("Scan for VideoSyncs"), videosyncTree);
|
|
|
|
menu.addAction(import);
|
|
menu.addAction(scan);
|
|
|
|
// connect menu to functions
|
|
connect(import, SIGNAL(triggered(void)), context->mainWindow, SLOT(importWorkout(void)));
|
|
connect(scan, SIGNAL(triggered(void)), context->mainWindow, SLOT(manageLibrary(void)));
|
|
|
|
QModelIndex current = videosyncTree->currentIndex();
|
|
QModelIndex target = vssortModel->mapToSource(current);
|
|
QString filename = videosyncModel->data(videosyncModel->index(target.row(), 0), Qt::DisplayRole).toString();
|
|
if (QFileInfo(filename).exists()) {
|
|
QAction *del = new QAction(tr("Delete selected VideoSync"), workoutTree);
|
|
menu.addAction(del);
|
|
connect(del, SIGNAL(triggered(void)), this, SLOT(deleteVideoSyncs(void)));
|
|
}
|
|
|
|
// execute the menu
|
|
menu.exec(trainSplitter->mapToGlobal(QPoint(videosyncItem->pos().x()+videosyncItem->width()-20,
|
|
videosyncItem->pos().y())));
|
|
}
|
|
|
|
void
|
|
TrainSidebar::configChanged(qint32)
|
|
{
|
|
// do not refresh if workout running, defer to end of workout
|
|
if (status&RT_RUNNING) {
|
|
pendingConfigChange = true;
|
|
return;
|
|
}
|
|
|
|
// auto connect is off by default
|
|
autoConnect = appsettings->value(this, TRAIN_AUTOCONNECT, false).toBool();
|
|
|
|
setProperty("color", GColor(CTRAINPLOTBACKGROUND));
|
|
#if !defined GC_VIDEO_NONE
|
|
mediaTree->setStyleSheet(GCColor::stylesheet());
|
|
#ifdef GC_HAVE_VLC // RLV currently only support for VLC
|
|
videosyncTree->setStyleSheet(GCColor::stylesheet());
|
|
#endif
|
|
#endif
|
|
workoutTree->setStyleSheet(GCColor::stylesheet());
|
|
deviceTree->setStyleSheet(GCColor::stylesheet());
|
|
|
|
// DEVICES
|
|
|
|
// Disconnect any running telemetry before manipulating device list
|
|
Disconnect();
|
|
|
|
// zap whats there
|
|
QList<QTreeWidgetItem *> devices = deviceTree->invisibleRootItem()->takeChildren();
|
|
for (int i=0; i<devices.count(); i++) delete devices.at(i);
|
|
|
|
if (appsettings->value(this, TRAIN_MULTI, false).toBool() == true)
|
|
deviceTree->setSelectionMode(QAbstractItemView::MultiSelection);
|
|
else
|
|
deviceTree->setSelectionMode(QAbstractItemView::SingleSelection);
|
|
|
|
// wipe whatever is there
|
|
foreach(DeviceConfiguration x, Devices) delete x.controller;
|
|
Devices.clear();
|
|
|
|
DeviceConfigurations all;
|
|
Devices = all.getList();
|
|
for (int i=0; i<Devices.count(); i++) {
|
|
|
|
// add to the selection tree
|
|
QTreeWidgetItem *device = new QTreeWidgetItem(deviceTree->invisibleRootItem(), i);
|
|
device->setText(0, Devices.at(i).name);
|
|
|
|
// Create the controllers for each device
|
|
// we can call upon each of these when we need
|
|
// to interact with the device
|
|
if (Devices.at(i).type == DEV_CT) {
|
|
Devices[i].controller = new ComputrainerController(this, &Devices[i]);
|
|
#if QT_VERSION >= 0x050000
|
|
} else if (Devices.at(i).type == DEV_MONARK) {
|
|
Devices[i].controller = new MonarkController(this, &Devices[i]);
|
|
} else if (Devices.at(i).type == DEV_KETTLER) {
|
|
Devices[i].controller = new KettlerController(this, &Devices[i]);
|
|
#endif
|
|
#ifdef GC_HAVE_LIBUSB
|
|
} else if (Devices.at(i).type == DEV_FORTIUS) {
|
|
Devices[i].controller = new FortiusController(this, &Devices[i]);
|
|
#endif
|
|
} else if (Devices.at(i).type == DEV_NULL) {
|
|
Devices[i].controller = new NullController(this, &Devices[i]);
|
|
} else if (Devices.at(i).type == DEV_ANTLOCAL) {
|
|
Devices[i].controller = new ANTlocalController(this, &Devices[i]);
|
|
// connect slot for receiving remote control commands
|
|
connect(Devices[i].controller, SIGNAL(remoteControl(uint16_t)), this, SLOT(remoteControl(uint16_t)));
|
|
#ifdef QT_BLUETOOTH_LIB
|
|
} else if (Devices.at(i).type == DEV_BT40) {
|
|
Devices[i].controller = new BT40Controller(this, &Devices[i]);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
// select the first device
|
|
if (Devices.count()) {
|
|
deviceTree->setCurrentItem(deviceTree->invisibleRootItem()->child(0));
|
|
}
|
|
// And select default workout to Ergo
|
|
QModelIndex firstWorkout = sortModel->index(0, 0, QModelIndex());
|
|
workoutTree->setCurrentIndex(firstWorkout);
|
|
|
|
// Re-read ANT remote control command mappings
|
|
remote->readConfig();
|
|
|
|
// Athlete
|
|
FTP=285; // default to 285 if zones are not set
|
|
WPRIME = 20000;
|
|
|
|
int range = context->athlete->zones(false)->whichRange(QDate::currentDate());
|
|
if (range != -1) {
|
|
FTP = context->athlete->zones(false)->getCP(range);
|
|
WPRIME = context->athlete->zones(false)->getWprime(range);
|
|
}
|
|
}
|
|
|
|
/*----------------------------------------------------------------------
|
|
* Device Selected
|
|
*--------------------------------------------------------------------*/
|
|
void
|
|
TrainSidebar::deviceTreeWidgetSelectionChanged()
|
|
{
|
|
//qDebug() << "TrainSidebar::deviceTreeWidgetSelectionChanged()";
|
|
|
|
bpmTelemetry = wattsTelemetry = kphTelemetry = rpmTelemetry = -1;
|
|
deviceSelected();
|
|
|
|
if (status&RT_CONNECTED) Disconnect(); // disconnect first
|
|
if (autoConnect) Connect(); // re-connect
|
|
}
|
|
|
|
int
|
|
TrainSidebar::selectedDeviceNumber()
|
|
{
|
|
if (deviceTree->selectedItems().isEmpty()) return -1;
|
|
|
|
QTreeWidgetItem *selected = deviceTree->selectedItems().first();
|
|
|
|
if (selected->type() == HEAD_TYPE) return -1;
|
|
else return selected->type();
|
|
}
|
|
|
|
QList<int>
|
|
TrainSidebar::devices()
|
|
{
|
|
QList<int> returning;
|
|
foreach(QTreeWidgetItem *item, deviceTree->selectedItems())
|
|
if (item->type() != HEAD_TYPE)
|
|
returning << item->type();
|
|
|
|
return returning;
|
|
}
|
|
|
|
/*----------------------------------------------------------------------
|
|
* Workout Selected
|
|
*--------------------------------------------------------------------*/
|
|
void
|
|
TrainSidebar::workoutTreeWidgetSelectionChanged()
|
|
{
|
|
QModelIndex current = workoutTree->currentIndex();
|
|
QModelIndex target = sortModel->mapToSource(current);
|
|
QString filename = workoutModel->data(workoutModel->index(target.row(), 0), Qt::DisplayRole).toString();
|
|
|
|
// wip away the current selected workout once we've told everyone
|
|
// since they might be editing it and want to save changes first (!!)
|
|
ErgFile *prior = ergFile;
|
|
|
|
if (filename == "") {
|
|
|
|
// an empty workout
|
|
context->notifyErgFileSelected(NULL);
|
|
|
|
// clean last
|
|
if (prior) delete prior;
|
|
|
|
return;
|
|
}
|
|
|
|
// is it the auto mode?
|
|
int index = target.row();
|
|
if (index == 0) {
|
|
// ergo mode
|
|
context->notifyErgFileSelected(NULL);
|
|
ergFile=NULL;
|
|
mode = ERG;
|
|
setLabels();
|
|
clearStatusFlags(RT_WORKOUT);
|
|
//ergPlot->setVisible(false);
|
|
} else if (index == 1) {
|
|
// slope mode
|
|
context->notifyErgFileSelected(NULL);
|
|
ergFile=NULL;
|
|
mode = CRS;
|
|
setLabels();
|
|
clearStatusFlags(RT_WORKOUT);
|
|
//ergPlot->setVisible(false);
|
|
} else {
|
|
// workout mode
|
|
ergFile = new ErgFile(filename, mode, context);
|
|
mode = ergFile->mode;
|
|
|
|
if (ergFile->isValid()) {
|
|
|
|
setStatusFlags(RT_WORKOUT);
|
|
|
|
// success! we have a load file
|
|
// setup the course profile in the
|
|
// display!
|
|
context->notifyErgFileSelected(ergFile);
|
|
adjustIntensity(100);
|
|
setLabels();
|
|
} else {
|
|
|
|
// couldn't parse fall back to ERG mode
|
|
delete ergFile;
|
|
ergFile = NULL;
|
|
context->notifyErgFileSelected(NULL);
|
|
removeInvalidWorkout();
|
|
mode = ERG;
|
|
clearStatusFlags(RT_WORKOUT);
|
|
setLabels();
|
|
}
|
|
}
|
|
|
|
// set the device to the right mode
|
|
if (mode == ERG || mode == MRC) {
|
|
setStatusFlags(RT_MODE_ERGO);
|
|
clearStatusFlags(RT_MODE_SPIN);
|
|
|
|
// update every active device
|
|
foreach(int dev, activeDevices) Devices[dev].controller->setMode(RT_MODE_ERGO);
|
|
|
|
} else { // SLOPE MODE
|
|
setStatusFlags(RT_MODE_SPIN);
|
|
clearStatusFlags(RT_MODE_ERGO);
|
|
|
|
// update every active device
|
|
foreach(int dev, activeDevices) Devices[dev].controller->setMode(RT_MODE_SPIN);
|
|
}
|
|
|
|
// clean last
|
|
if (prior) delete prior;
|
|
|
|
}
|
|
|
|
QStringList
|
|
TrainSidebar::listWorkoutFiles(const QDir &dir) const
|
|
{
|
|
QStringList filters;
|
|
filters << "*.erg";
|
|
filters << "*.mrc";
|
|
filters << "*.crs";
|
|
filters << "*.pgmf";
|
|
|
|
return dir.entryList(filters, QDir::Files, QDir::Name);
|
|
}
|
|
|
|
void
|
|
TrainSidebar::deleteVideos()
|
|
{
|
|
QModelIndex current = mediaTree->currentIndex();
|
|
QModelIndex target = vsortModel->mapToSource(current);
|
|
QString filename = videoModel->data(videoModel->index(target.row(), 0), Qt::DisplayRole).toString();
|
|
|
|
if (QFileInfo(filename).exists()) {
|
|
// are you sure?
|
|
QMessageBox msgBox;
|
|
msgBox.setText(tr("Are you sure you want to remove the reference to this video?"));
|
|
msgBox.setInformativeText(filename);
|
|
QPushButton *deleteButton = msgBox.addButton(tr("Remove"),QMessageBox::YesRole);
|
|
msgBox.setStandardButtons(QMessageBox::Cancel);
|
|
msgBox.setDefaultButton(QMessageBox::Cancel);
|
|
msgBox.setIcon(QMessageBox::Critical);
|
|
msgBox.exec();
|
|
|
|
if(msgBox.clickedButton() != deleteButton) return;
|
|
|
|
// delete from disk
|
|
//XXX QFile(filename).remove(); // lets not for now..
|
|
|
|
// remove any reference (from drag and drop)
|
|
Library *l = Library::findLibrary("Media Library");
|
|
if (l) l->removeRef(context, filename);
|
|
|
|
// delete from DB
|
|
trainDB->startLUW();
|
|
trainDB->deleteVideo(filename);
|
|
trainDB->endLUW();
|
|
}
|
|
}
|
|
|
|
|
|
void
|
|
TrainSidebar::deleteVideoSyncs()
|
|
{
|
|
QModelIndex current = videosyncTree->currentIndex();
|
|
QModelIndex target = vssortModel->mapToSource(current);
|
|
QString filename = videosyncModel->data(videosyncModel->index(target.row(), 0), Qt::DisplayRole).toString();
|
|
|
|
if (QFileInfo(filename).exists()) {
|
|
// are you sure?
|
|
QMessageBox msgBox;
|
|
msgBox.setText(tr("Are you sure you want to delete this VideoSync?"));
|
|
msgBox.setInformativeText(filename);
|
|
QPushButton *deleteButton = msgBox.addButton(tr("Delete"),QMessageBox::YesRole);
|
|
msgBox.setStandardButtons(QMessageBox::Cancel);
|
|
msgBox.setDefaultButton(QMessageBox::Cancel);
|
|
msgBox.setIcon(QMessageBox::Critical);
|
|
msgBox.exec();
|
|
|
|
if(msgBox.clickedButton() != deleteButton) return;
|
|
|
|
// delete from disk
|
|
QFile(filename).remove();
|
|
|
|
// delete from DB
|
|
trainDB->startLUW();
|
|
trainDB->deleteVideoSync(filename);
|
|
trainDB->endLUW();
|
|
}
|
|
}
|
|
|
|
void
|
|
TrainSidebar::removeInvalidVideoSync()
|
|
{
|
|
QModelIndex current = videosyncTree->currentIndex();
|
|
QModelIndex target = vssortModel->mapToSource(current);
|
|
QString filename = videosyncModel->data(videosyncModel->index(target.row(), 0), Qt::DisplayRole).toString();
|
|
QMessageBox msgBox;
|
|
msgBox.setText(tr("The VideoSync file is either not valid or not existing and will be removed from the library."));
|
|
msgBox.setInformativeText(filename);
|
|
QPushButton *removeButton = msgBox.addButton(tr("Remove"),QMessageBox::YesRole);
|
|
msgBox.setStandardButtons(QMessageBox::Cancel);
|
|
msgBox.setDefaultButton(removeButton);
|
|
msgBox.setIcon(QMessageBox::Critical);
|
|
msgBox.exec();
|
|
|
|
if(msgBox.clickedButton() != removeButton) return;
|
|
|
|
// delete from DB
|
|
trainDB->startLUW();
|
|
trainDB->deleteVideoSync(filename);
|
|
trainDB->endLUW();
|
|
|
|
}
|
|
|
|
void
|
|
TrainSidebar::deleteWorkouts()
|
|
{
|
|
QStringList nameList;
|
|
QModelIndexList list = workoutTree->selectionModel()->selectedRows();
|
|
foreach (QModelIndex index, list) {
|
|
QModelIndex target = sortModel->mapToSource(index);
|
|
QString filename = workoutModel->data(workoutModel->index(target.row(), 0), Qt::DisplayRole).toString();
|
|
if (QFileInfo(filename).exists()) {
|
|
nameList.append(filename);
|
|
}
|
|
}
|
|
|
|
if (nameList.count()>0) {
|
|
// are you sure?
|
|
QMessageBox msgBox;
|
|
if (nameList.count()==1) {
|
|
msgBox.setText(tr("Are you sure you want to delete this Workout?"));
|
|
}
|
|
else {
|
|
msgBox.setText(QString(tr("Are you sure you want to delete this %1 workouts?")).arg(nameList.count()));
|
|
}
|
|
QString info;
|
|
for (int i=0;i<nameList.count() && i<21;i++) {
|
|
info += nameList.at(i)+"\n";
|
|
if (i == 20) {
|
|
info += "...\n";
|
|
}
|
|
}
|
|
msgBox.setInformativeText(info);
|
|
QPushButton *deleteButton = msgBox.addButton(tr("Delete"),QMessageBox::YesRole);
|
|
msgBox.setStandardButtons(QMessageBox::Cancel);
|
|
msgBox.setDefaultButton(QMessageBox::Cancel);
|
|
msgBox.setIcon(QMessageBox::Critical);
|
|
msgBox.exec();
|
|
|
|
if(msgBox.clickedButton() != deleteButton) return;
|
|
|
|
foreach (QString filename, nameList) {
|
|
if (QFileInfo(filename).exists()) {
|
|
// delete from disk
|
|
QFile(filename).remove();
|
|
// delete from DB
|
|
trainDB->startLUW();
|
|
trainDB->deleteWorkout(filename);
|
|
trainDB->endLUW();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
TrainSidebar::removeInvalidWorkout()
|
|
{
|
|
QModelIndex current = workoutTree->currentIndex();
|
|
QModelIndex target = sortModel->mapToSource(current);
|
|
QString filename = workoutModel->data(workoutModel->index(target.row(), 0), Qt::DisplayRole).toString();
|
|
|
|
QMessageBox msgBox;
|
|
msgBox.setText(tr("The Workout file is either not valid or not existing and will be removed from the library."));
|
|
msgBox.setInformativeText(filename);
|
|
QPushButton *removeButton = msgBox.addButton(tr("Remove"),QMessageBox::YesRole);
|
|
msgBox.setStandardButtons(QMessageBox::Cancel);
|
|
msgBox.setDefaultButton(removeButton);
|
|
msgBox.setIcon(QMessageBox::Critical);
|
|
msgBox.exec();
|
|
|
|
if(msgBox.clickedButton() != removeButton) return;
|
|
|
|
// delete from DB
|
|
trainDB->startLUW();
|
|
trainDB->deleteWorkout(filename);
|
|
trainDB->endLUW();
|
|
|
|
}
|
|
|
|
void
|
|
TrainSidebar::mediaTreeWidgetSelectionChanged()
|
|
{
|
|
|
|
QModelIndex current = mediaTree->currentIndex();
|
|
QModelIndex target = vsortModel->mapToSource(current);
|
|
QString filename = videoModel->data(videoModel->index(target.row(), 0), Qt::DisplayRole).toString();
|
|
context->notifyMediaSelected(filename);
|
|
}
|
|
|
|
void
|
|
TrainSidebar::videosyncTreeWidgetSelectionChanged()
|
|
{
|
|
|
|
QModelIndex current = videosyncTree->currentIndex();
|
|
QModelIndex target = vssortModel->mapToSource(current);
|
|
QString filename = videosyncModel->data(videosyncModel->index(target.row(), 0), Qt::DisplayRole).toString();
|
|
|
|
// wip away the current selected videosync
|
|
if (videosyncFile) {
|
|
delete videosyncFile;
|
|
videosyncFile = NULL;
|
|
}
|
|
|
|
if (filename == "") {
|
|
context->notifyVideoSyncFileSelected(NULL);
|
|
return;
|
|
}
|
|
|
|
// is "None" selected?
|
|
int index = target.row();
|
|
if (index == 0) {
|
|
// None menu entry
|
|
context->notifyVideoSyncFileSelected(NULL);
|
|
} else {
|
|
videosyncFile = new VideoSyncFile(filename, mode, context);
|
|
if (videosyncFile->isValid()) {
|
|
context->notifyVideoSyncFileSelected(videosyncFile);
|
|
} else {
|
|
delete videosyncFile;
|
|
videosyncFile = NULL;
|
|
context->notifyVideoSyncFileSelected(NULL);
|
|
removeInvalidVideoSync();
|
|
}
|
|
}
|
|
}
|
|
|
|
/*--------------------------------------------------------------------------------
|
|
* Was realtime window, now local and manages controller and chart updates etc
|
|
*------------------------------------------------------------------------------*/
|
|
|
|
void TrainSidebar::Start() // when start button is pressed
|
|
{
|
|
if (status&RT_PAUSED) {
|
|
|
|
qDebug() << "unpause...";
|
|
|
|
// UN PAUSE!
|
|
session_time.start();
|
|
lap_time.start();
|
|
clearStatusFlags(RT_PAUSED);
|
|
//foreach(int dev, activeDevices) Devices[dev].controller->restart();
|
|
//gui_timer->start(REFRESHRATE);
|
|
if (status & RT_RECORDING) disk_timer->start(SAMPLERATE);
|
|
load_period.restart();
|
|
if (status & RT_WORKOUT) load_timer->start(LOADRATE);
|
|
|
|
#if !defined GC_VIDEO_NONE
|
|
mediaTree->setEnabled(false);
|
|
#ifdef GC_HAVE_VLC // RLV currently only support for VLC
|
|
videosyncTree->setEnabled(false);
|
|
#endif
|
|
#endif
|
|
|
|
// tell the world
|
|
context->notifyUnPause();
|
|
|
|
} else if (status&RT_RUNNING) {
|
|
|
|
qDebug() << "pause...";
|
|
|
|
// Pause!
|
|
session_elapsed_msec += session_time.elapsed();
|
|
lap_elapsed_msec += lap_time.elapsed();
|
|
setStatusFlags(RT_PAUSED);
|
|
//foreach(int dev, activeDevices) Devices[dev].controller->pause();
|
|
//gui_timer->stop();
|
|
if (status & RT_RECORDING) disk_timer->stop();
|
|
if (status & RT_WORKOUT) load_timer->stop();
|
|
load_msecs += load_period.restart();
|
|
|
|
#if !defined GC_VIDEO_NONE
|
|
// enable media tree so we can change movie - mid workout
|
|
mediaTree->setEnabled(true);
|
|
#ifdef GC_HAVE_VLC // RLV currently only support for VLC
|
|
videosyncTree->setEnabled(true);
|
|
#endif
|
|
#endif
|
|
|
|
// tell the world
|
|
context->notifyPause();
|
|
|
|
} else if (status&RT_CONNECTED) {
|
|
|
|
qDebug() << "start...";
|
|
|
|
#ifdef WIN32
|
|
// disable the screen saver on Windows
|
|
SetThreadExecutionState(ES_DISPLAY_REQUIRED | ES_CONTINUOUS);
|
|
#endif
|
|
|
|
// Stop users from selecting different devices
|
|
// media or workouts whilst a workout is in progress
|
|
#if !defined GC_VIDEO_NONE
|
|
mediaTree->setEnabled(false);
|
|
#ifdef GC_HAVE_VLC // RLV currently only support for VLC
|
|
videosyncTree->setEnabled(false);
|
|
#endif
|
|
#endif
|
|
workoutTree->setEnabled(false);
|
|
deviceTree->setEnabled(false);
|
|
|
|
// START!
|
|
load = 100;
|
|
slope = 0.0;
|
|
|
|
if (mode == ERG || mode == MRC) {
|
|
setStatusFlags(RT_MODE_ERGO);
|
|
clearStatusFlags(RT_MODE_SPIN);
|
|
foreach(int dev, activeDevices) Devices[dev].controller->setMode(RT_MODE_ERGO);
|
|
} else { // SLOPE MODE
|
|
setStatusFlags(RT_MODE_SPIN);
|
|
clearStatusFlags(RT_MODE_ERGO);
|
|
foreach(int dev, activeDevices) Devices[dev].controller->setMode(RT_MODE_SPIN);
|
|
}
|
|
|
|
// tell the world
|
|
context->notifyStart();
|
|
|
|
// we're away!
|
|
setStatusFlags(RT_RUNNING);
|
|
|
|
// tell the world
|
|
context->notifyStart();
|
|
|
|
load_period.restart();
|
|
session_time.start();
|
|
session_elapsed_msec = 0;
|
|
lap_time.start();
|
|
lap_elapsed_msec = 0;
|
|
wbalr = 0;
|
|
wbal = WPRIME;
|
|
calibrating = false;
|
|
|
|
if (status & RT_WORKOUT) {
|
|
load_timer->start(LOADRATE); // start recording
|
|
}
|
|
|
|
if (recordSelector->isChecked()) {
|
|
setStatusFlags(RT_RECORDING);
|
|
}
|
|
|
|
if (status & RT_RECORDING) {
|
|
QDateTime now = QDateTime::currentDateTime();
|
|
|
|
// setup file
|
|
QString filename = now.toString(QString("yyyy_MM_dd_hh_mm_ss")) + QString(".csv");
|
|
|
|
if (!context->athlete->home->records().exists())
|
|
context->athlete->home->createAllSubdirs();
|
|
|
|
QString fulltarget = context->athlete->home->records().canonicalPath() + "/" + filename;
|
|
|
|
if (recordFile) delete recordFile;
|
|
recordFile = new QFile(fulltarget);
|
|
if (!recordFile->open(QFile::WriteOnly | QFile::Truncate)) {
|
|
clearStatusFlags(RT_RECORDING);
|
|
} else {
|
|
|
|
// CSV File header
|
|
|
|
QTextStream recordFileStream(recordFile);
|
|
recordFileStream << "secs, cad, hr, km, kph, nm, watts, alt, lon, lat, headwind, slope, temp, interval, lrbalance, lte, rte, lps, rps, smo2, thb, o2hb, hhb\n";
|
|
|
|
disk_timer->start(SAMPLERATE); // start screen
|
|
}
|
|
}
|
|
gui_timer->start(REFRESHRATE); // start recording
|
|
|
|
}
|
|
}
|
|
|
|
void TrainSidebar::Pause() // pause capture to recalibrate
|
|
{
|
|
// we're not running fool!
|
|
if ((status&RT_RUNNING) == 0) return;
|
|
|
|
if (status&RT_PAUSED) {
|
|
|
|
session_time.start();
|
|
lap_time.start();
|
|
clearStatusFlags(RT_PAUSED);
|
|
foreach(int dev, activeDevices) Devices[dev].controller->restart();
|
|
gui_timer->start(REFRESHRATE);
|
|
if (status & RT_RECORDING) disk_timer->start(SAMPLERATE);
|
|
load_period.restart();
|
|
if (status & RT_WORKOUT) load_timer->start(LOADRATE);
|
|
|
|
#if !defined GC_VIDEO_NONE
|
|
mediaTree->setEnabled(false);
|
|
#ifdef GC_HAVE_VLC // RLV currently only support for VLC
|
|
videosyncTree->setEnabled(false);
|
|
#endif
|
|
#endif
|
|
|
|
// tell the world
|
|
context->notifyUnPause();
|
|
|
|
} else {
|
|
|
|
session_elapsed_msec += session_time.elapsed();
|
|
lap_elapsed_msec += lap_time.elapsed();
|
|
foreach(int dev, activeDevices) Devices[dev].controller->pause();
|
|
setStatusFlags(RT_PAUSED);
|
|
gui_timer->stop();
|
|
if (status & RT_RECORDING) disk_timer->stop();
|
|
if (status & RT_WORKOUT) load_timer->stop();
|
|
load_msecs += load_period.restart();
|
|
|
|
// enable media tree so we can change movie
|
|
#if !defined GC_VIDEO_NONE
|
|
mediaTree->setEnabled(true);
|
|
#ifdef GC_HAVE_VLC // RLV currently only support for VLC
|
|
videosyncTree->setEnabled(true);
|
|
#endif
|
|
#endif
|
|
|
|
// tell the world
|
|
context->notifyPause();
|
|
}
|
|
}
|
|
|
|
void TrainSidebar::Stop(int deviceStatus) // when stop button is pressed
|
|
{
|
|
if ((status&RT_RUNNING) == 0) return;
|
|
|
|
// re-enable the screen saver on Windows
|
|
#ifdef WIN32
|
|
SetThreadExecutionState(ES_CONTINUOUS);
|
|
#endif
|
|
|
|
clearStatusFlags(RT_RUNNING|RT_PAUSED);
|
|
|
|
// Stop users from selecting different devices
|
|
// media or workouts whilst a workout is in progress
|
|
#if !defined GC_VIDEO_NONE
|
|
mediaTree->setEnabled(true);
|
|
#ifdef GC_HAVE_VLC // RLV currently only support for VLC
|
|
videosyncTree->setEnabled(true);
|
|
#endif
|
|
#endif
|
|
workoutTree->setEnabled(true);
|
|
deviceTree->setEnabled(true);
|
|
|
|
calibrating = false;
|
|
|
|
load = 0;
|
|
slope = 0.0;
|
|
|
|
QDateTime now = QDateTime::currentDateTime();
|
|
|
|
if (status & RT_RECORDING) {
|
|
disk_timer->stop();
|
|
|
|
// close and reset File
|
|
recordFile->close();
|
|
|
|
if(deviceStatus == DEVICE_ERROR)
|
|
{
|
|
recordFile->remove();
|
|
}
|
|
else {
|
|
// add to the view - using basename ONLY
|
|
QString name;
|
|
name = recordFile->fileName();
|
|
|
|
QList<QString> list;
|
|
list.append(name);
|
|
|
|
RideImportWizard *dialog = new RideImportWizard (list, context);
|
|
dialog->process(); // do it!
|
|
}
|
|
}
|
|
|
|
if (status & RT_WORKOUT) {
|
|
load_timer->stop();
|
|
load_msecs = 0;
|
|
}
|
|
|
|
// get back to normal after it may have been adusted by the user
|
|
//lastAppliedIntensity=100;
|
|
adjustIntensity(100);
|
|
if (context->currentErgFile()) context->currentErgFile()->reload();
|
|
context->notifySetNow(load_msecs);
|
|
|
|
|
|
// tell the world
|
|
context->notifyStop();
|
|
|
|
// if a config change was requested while workout was running, action it now
|
|
if (pendingConfigChange) {
|
|
pendingConfigChange = false;
|
|
configChanged(CONFIG_APPEARANCE | CONFIG_DEVICES | CONFIG_ZONES);
|
|
}
|
|
|
|
// Re-enable gui elements
|
|
// reset counters etc
|
|
pwrcount = 0;
|
|
cadcount = 0;
|
|
hrcount = 0;
|
|
spdcount = 0;
|
|
lodcount = 0;
|
|
displayWorkoutLap = displayLap =0;
|
|
wbalr = 0;
|
|
wbal = WPRIME;
|
|
session_elapsed_msec = 0;
|
|
session_time.restart();
|
|
lap_elapsed_msec = 0;
|
|
lap_time.restart();
|
|
displayWorkoutDistance = displayDistance = 0;
|
|
guiUpdate();
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
// Called by push devices (e.g. ANT+)
|
|
void TrainSidebar::updateData(RealtimeData &rtData)
|
|
{
|
|
displayPower = rtData.getWatts();
|
|
displayCadence = rtData.getCadence();
|
|
displayHeartRate = rtData.getHr();
|
|
displaySpeed = rtData.getSpeed();
|
|
load = rtData.getLoad();
|
|
displayLRBalance = rtData.getLRBalance();
|
|
displayLTE = rtData.getLTE();
|
|
displayRTE = rtData.getRTE();
|
|
displayLPS = rtData.getLPS();
|
|
displayRPS = rtData.getRPS();
|
|
// Gradient not supported
|
|
return;
|
|
}
|
|
|
|
void TrainSidebar::toggleConnect()
|
|
{
|
|
if (status&RT_CONNECTED)
|
|
Disconnect();
|
|
else
|
|
Connect();
|
|
}
|
|
|
|
void TrainSidebar::Connect()
|
|
{
|
|
//qDebug() << "current tab:" << context->tab->currentView();
|
|
|
|
// only try and connect if we are in train view..
|
|
// fixme: these values are hard-coded throughout
|
|
if (!(context->tab->currentView() == 3)) return;
|
|
|
|
if (status&RT_CONNECTED) return; // already connected
|
|
|
|
qDebug() << "connecting..";
|
|
|
|
// if we have selected multiple devices lets
|
|
// configure the series we collect from each one
|
|
if (deviceTree->selectedItems().count() > 1) {
|
|
MultiDeviceDialog *multisetup = new MultiDeviceDialog(context, this);
|
|
if (multisetup->exec() == false) {
|
|
return;
|
|
}
|
|
} else if (deviceTree->selectedItems().count() == 1) {
|
|
bpmTelemetry = wattsTelemetry = kphTelemetry = rpmTelemetry =
|
|
deviceTree->selectedItems().first()->type();
|
|
} else {
|
|
return;
|
|
}
|
|
|
|
activeDevices = devices();
|
|
|
|
foreach(int dev, activeDevices) Devices[dev].controller->start();
|
|
setStatusFlags(RT_CONNECTED);
|
|
gui_timer->start(REFRESHRATE);
|
|
}
|
|
|
|
void TrainSidebar::Disconnect()
|
|
{
|
|
// don't try to disconnect if running or not connected
|
|
if ((status&RT_RUNNING) || ((status&RT_CONNECTED) == 0)) return;
|
|
|
|
static QIcon connectedIcon(":images/oxygen/power-on.png");
|
|
static QIcon disconnectedIcon(":images/oxygen/power-off.png");
|
|
|
|
qDebug() << "disconnecting..";
|
|
|
|
foreach(int dev, activeDevices) Devices[dev].controller->stop();
|
|
clearStatusFlags(RT_CONNECTED);
|
|
|
|
gui_timer->stop();
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// SCREEN UPDATE FUNCTIONS
|
|
//----------------------------------------------------------------------
|
|
|
|
void TrainSidebar::guiUpdate() // refreshes the telemetry
|
|
{
|
|
RealtimeData rtData;
|
|
rtData.setLap(displayLap + displayWorkoutLap); // user laps + predefined workout lap
|
|
rtData.mode = mode;
|
|
|
|
// On a Mac prevent the screensaver from kicking in
|
|
// this is apparently the 'supported' mechanism for
|
|
// disabling the screen saver on a Mac instead of
|
|
// temporarily adjusting/disabling the user preferences
|
|
// for screen saving and power management. Makes sense.
|
|
#ifdef Q_OS_MAC
|
|
UpdateSystemActivity(OverallAct);
|
|
#endif
|
|
|
|
// get latest telemetry from devices
|
|
if ((status&RT_RUNNING) || (status&RT_CONNECTED)) {
|
|
if(calibrating) {
|
|
foreach(int dev, activeDevices) { // Do for Computrainers only. Need to check with other devices
|
|
RealtimeData local = rtData;
|
|
if (Devices[dev].type == DEV_CT)
|
|
Devices[dev].controller->getRealtimeData(local); // See if the F3 button has been pressed
|
|
}
|
|
// and exit. Nothing else to do until we finish calibrating
|
|
return;
|
|
} else {
|
|
rtData.setLoad(load); // always set load..
|
|
rtData.setSlope(slope); // always set load..
|
|
|
|
// fetch the right data from each device...
|
|
foreach(int dev, activeDevices) {
|
|
|
|
RealtimeData local = rtData;
|
|
Devices[dev].controller->getRealtimeData(local);
|
|
|
|
// get spinscan data from a computrainer?
|
|
if (Devices[dev].type == DEV_CT) {
|
|
memcpy((uint8_t*)rtData.spinScan, (uint8_t*)local.spinScan, 24);
|
|
rtData.setLoad(local.getLoad()); // and get load in case it was adjusted
|
|
rtData.setSlope(local.getSlope()); // and get slope in case it was adjusted
|
|
// to within defined limits
|
|
}
|
|
|
|
if (Devices[dev].type == DEV_FORTIUS) {
|
|
rtData.setLoad(local.getLoad()); // and get load in case it was adjusted
|
|
rtData.setSlope(local.getSlope()); // and get slope in case it was adjusted
|
|
// to within defined limits
|
|
}
|
|
|
|
if (Devices[dev].type == DEV_ANTLOCAL || Devices[dev].type == DEV_NULL) {
|
|
rtData.setHb(local.getSmO2(), local.gettHb()); //only moxy data from ant and robot devices right now
|
|
}
|
|
|
|
// what are we getting from this one?
|
|
if (dev == bpmTelemetry) rtData.setHr(local.getHr());
|
|
if (dev == rpmTelemetry) rtData.setCadence(local.getCadence());
|
|
if (dev == kphTelemetry) {
|
|
rtData.setSpeed(local.getSpeed());
|
|
rtData.setDistance(local.getDistance());
|
|
}
|
|
if (dev == wattsTelemetry) {
|
|
rtData.setWatts(local.getWatts());
|
|
rtData.setAltWatts(local.getAltWatts());
|
|
rtData.setLRBalance(local.getLRBalance());
|
|
rtData.setLTE(local.getLTE());
|
|
rtData.setRTE(local.getRTE());
|
|
rtData.setLPS(local.getLPS());
|
|
rtData.setRPS(local.getRPS());
|
|
}
|
|
if (local.getTrainerStatusAvailable())
|
|
{
|
|
rtData.setTrainerStatusAvailable(true);
|
|
rtData.setTrainerReady(local.getTrainerReady());
|
|
rtData.setTrainerRunning(local.getTrainerRunning());
|
|
rtData.setTrainerCalibRequired(local.getTrainerCalibRequired());
|
|
rtData.setTrainerConfigRequired(local.getTrainerConfigRequired());
|
|
rtData.setTrainerBrakeFault(local.getTrainerBrakeFault());
|
|
}
|
|
}
|
|
|
|
// only update time & distance if actively running (not just connected, and not running but paused)
|
|
if ((status&RT_RUNNING) && ((status&RT_PAUSED) == 0)) {
|
|
// Distance assumes current speed for the last second. from km/h to km/sec
|
|
displayDistance += displaySpeed / (5 * 3600); // assumes 200ms refreshrate
|
|
|
|
if (!(status&RT_MODE_ERGO) && (context->currentVideoSyncFile()))
|
|
{
|
|
displayWorkoutDistance = context->currentVideoSyncFile()->km + context->currentVideoSyncFile()->manualOffset;
|
|
// TODO : graphs to be shown at seek position
|
|
}
|
|
else
|
|
displayWorkoutDistance += displaySpeed / (5 * 3600); // assumes 200ms refreshrate
|
|
rtData.setDistance(displayDistance);
|
|
|
|
// time
|
|
total_msecs = session_elapsed_msec + session_time.elapsed();
|
|
lap_msecs = lap_elapsed_msec + lap_time.elapsed();
|
|
|
|
rtData.setMsecs(total_msecs);
|
|
rtData.setLapMsecs(lap_msecs);
|
|
|
|
long lapTimeRemaining;
|
|
if (ergFile) lapTimeRemaining = ergFile->nextLap(load_msecs) - load_msecs;
|
|
else lapTimeRemaining = 0;
|
|
|
|
if(lapTimeRemaining < 0) {
|
|
if (ergFile) lapTimeRemaining = ergFile->Duration - load_msecs;
|
|
if(lapTimeRemaining < 0)
|
|
lapTimeRemaining = 0;
|
|
}
|
|
rtData.setLapMsecsRemaining(lapTimeRemaining);
|
|
} else {
|
|
rtData.setDistance(displayDistance);
|
|
rtData.setMsecs(session_elapsed_msec);
|
|
rtData.setLapMsecs(lap_elapsed_msec);
|
|
}
|
|
|
|
// local stuff ...
|
|
displayPower = rtData.getWatts();
|
|
displayCadence = rtData.getCadence();
|
|
displayHeartRate = rtData.getHr();
|
|
displaySpeed = rtData.getSpeed();
|
|
load = rtData.getLoad();
|
|
slope = rtData.getSlope();
|
|
displayLRBalance = rtData.getLRBalance();
|
|
displayLTE = rtData.getLTE();
|
|
displayRTE = rtData.getRTE();
|
|
displayLPS = rtData.getLPS();
|
|
displayRPS = rtData.getRPS();
|
|
|
|
// virtual speed
|
|
double crr = 0.004f; // typical for asphalt surfaces
|
|
double g = 9.81; // g constant 9.81 m/s
|
|
double weight = appsettings->cvalue(context->athlete->cyclist, GC_WEIGHT, 0.0).toDouble();
|
|
double m = weight ? weight + 8 : 83; // default to 75kg weight, plus 8kg bike
|
|
double sl = slope / 100; // 10% = 0.1
|
|
double ad = 1.226f; // default air density at sea level
|
|
double cdA = 0.5f; // typical
|
|
double pw = rtData.getWatts();
|
|
|
|
// algorithm supplied by Tom Compton
|
|
// from www.AnalyticCycling.com
|
|
// 3.6 * ... converts from meters per second to kph
|
|
double vs = 3.6f * (
|
|
(-2*pow(2,0.3333333333333333)*(crr*m + g*m*sl)) /
|
|
pow(54*pow(ad,2)*pow(cdA,2)*pw +
|
|
sqrt(2916*pow(ad,4)*pow(cdA,4)*pow(pw,2) +
|
|
864*pow(ad,3)*pow(cdA,3)*pow(crr*m +
|
|
g*m*sl,3)),0.3333333333333333) +
|
|
pow(54*pow(ad,2)*pow(cdA,2)*pw +
|
|
sqrt(2916*pow(ad,4)*pow(cdA,4)*pow(pw,2) +
|
|
864*pow(ad,3)*pow(cdA,3)*pow(crr*m +
|
|
g*m*sl,3)),0.3333333333333333)/
|
|
(3.*pow(2,0.3333333333333333)*ad*cdA));
|
|
|
|
// just in case...
|
|
if (std::isnan(vs) || std::isinf(vs)) vs = 0.00f;
|
|
rtData.setVirtualSpeed(vs);
|
|
|
|
// W'bal on the fly
|
|
// using Dave Waterworth's reformulation
|
|
double TAU = appsettings->cvalue(context->athlete->cyclist, GC_WBALTAU, 300).toInt();
|
|
|
|
// any watts expended in last 200msec?
|
|
double JOULES = double(rtData.getWatts() - FTP) / 5.00f;
|
|
if (JOULES < 0) JOULES = 0;
|
|
|
|
// running total of replenishment
|
|
wbalr += JOULES * exp((total_msecs/1000.00f) / TAU);
|
|
wbal = WPRIME - (wbalr * exp((-total_msecs/1000.00f) / TAU));
|
|
|
|
rtData.setWbal(wbal);
|
|
|
|
// go update the displays...
|
|
context->notifyTelemetryUpdate(rtData); // signal everyone to update telemetry
|
|
|
|
// set now to current time when not using a workout
|
|
// but limit to almost every second (account for
|
|
// slight timing errors of 100ms or so)
|
|
|
|
// Do some rounding to the hundreds because as time goes by, rtData.getMsecs() drifts just below and then it does not pass the mod 1000 < 100 test
|
|
// For example: msecs = 42199. Mod 1000 = 199 versus msecs = 42000. Mod 1000 = 0
|
|
// With this, it will now call tick just about every second
|
|
long rmsecs = round((rtData.getMsecs() + 99) / 100) * 100;
|
|
// Test for <= 100ms
|
|
if (!(status&RT_WORKOUT) && ((rmsecs % 1000) <= 100)) {
|
|
context->notifySetNow(rtData.getMsecs());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// can be called from the controller - when user presses "Lap" button
|
|
void TrainSidebar::newLap()
|
|
{
|
|
qDebug() << "running:" << (status&RT_RUNNING) << "paused:" << (status&RT_PAUSED);
|
|
|
|
if ((status&RT_RUNNING) && ((status&RT_PAUSED) == 0)) {
|
|
displayLap++;
|
|
|
|
pwrcount = 0;
|
|
cadcount = 0;
|
|
hrcount = 0;
|
|
spdcount = 0;
|
|
|
|
context->notifyNewLap();
|
|
}
|
|
}
|
|
|
|
void TrainSidebar::resetLapTimer()
|
|
{
|
|
lap_time.restart();
|
|
lap_elapsed_msec = 0;
|
|
}
|
|
|
|
// can be called from the controller
|
|
void TrainSidebar::nextDisplayMode()
|
|
{
|
|
}
|
|
|
|
void TrainSidebar::warnnoConfig()
|
|
{
|
|
QMessageBox::warning(this, tr("No Devices Configured"), tr("Please configure a device in Preferences."));
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// DISK UPDATE FUNCTIONS
|
|
//----------------------------------------------------------------------
|
|
void TrainSidebar::diskUpdate()
|
|
{
|
|
int secs;
|
|
|
|
long torq = 0, altitude = 0;
|
|
QTextStream recordFileStream(recordFile);
|
|
|
|
if (calibrating) return;
|
|
|
|
// convert from milliseconds to secondes
|
|
total_msecs = session_elapsed_msec + session_time.elapsed();
|
|
secs = total_msecs;
|
|
secs /= 1000.0;
|
|
|
|
// GoldenCheetah CVS Format "secs, cad, hr, km, kph, nm, watts, alt, lon, lat, headwind, slope, temp, interval, lrbalance, lte, rte, lps, rps, smo2, thb, o2hb, hhb\n";
|
|
|
|
recordFileStream << secs
|
|
<< "," << displayCadence
|
|
<< "," << displayHeartRate
|
|
<< "," << displayDistance
|
|
<< "," << displaySpeed
|
|
<< "," << torq
|
|
<< "," << displayPower
|
|
<< "," << altitude
|
|
<< "," // lon
|
|
<< "," // lat
|
|
<< "," // headwind
|
|
<< "," // slope
|
|
<< "," // temp
|
|
<< "," << (displayLap + displayWorkoutLap)
|
|
<< "," << displayLRBalance
|
|
<< "," << displayLTE
|
|
<< "," << displayRTE
|
|
<< "," << displayLPS
|
|
<< "," << displayRPS
|
|
<< "," // smo2
|
|
<< "," // thb
|
|
<< "," // o2hb
|
|
<< "," // hhb\n
|
|
|
|
<< "," << "\n";
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// WORKOUT MODE
|
|
//----------------------------------------------------------------------
|
|
|
|
void TrainSidebar::loadUpdate()
|
|
{
|
|
int curLap;
|
|
|
|
// we hold our horses whilst calibration is taking place...
|
|
if (calibrating) return;
|
|
|
|
// the period between loadUpdate calls is not constant, and not exactly LOADRATE,
|
|
// therefore, use a QTime timer to measure the load period
|
|
load_msecs += load_period.restart();
|
|
|
|
if (status&RT_MODE_ERGO) {
|
|
load = ergFile->wattsAt(load_msecs, curLap);
|
|
|
|
if(displayWorkoutLap != curLap)
|
|
{
|
|
context->notifyNewLap();
|
|
}
|
|
displayWorkoutLap = curLap;
|
|
|
|
// we got to the end!
|
|
if (load == -100) {
|
|
Stop(DEVICE_OK);
|
|
} else {
|
|
foreach(int dev, activeDevices) Devices[dev].controller->setLoad(load);
|
|
context->notifySetNow(load_msecs);
|
|
}
|
|
} else {
|
|
slope = ergFile->gradientAt(displayWorkoutDistance*1000, curLap);
|
|
|
|
if(displayWorkoutLap != curLap)
|
|
{
|
|
context->notifyNewLap();
|
|
}
|
|
displayWorkoutLap = curLap;
|
|
|
|
// we got to the end!
|
|
if (slope == -100) {
|
|
Stop(DEVICE_OK);
|
|
} else {
|
|
foreach(int dev, activeDevices) Devices[dev].controller->setGradient(slope);
|
|
context->notifySetNow(displayWorkoutDistance * 1000);
|
|
}
|
|
}
|
|
}
|
|
|
|
void TrainSidebar::Calibrate()
|
|
{
|
|
static QProgressDialog *bar=NULL;
|
|
|
|
// toggle calibration
|
|
if (calibrating) {
|
|
bar->reset(); // will hide...
|
|
|
|
// restart gui etc
|
|
session_time.start();
|
|
lap_time.start();
|
|
load_period.restart();
|
|
if (status & RT_WORKOUT) load_timer->start(LOADRATE);
|
|
if (status & RT_RECORDING) disk_timer->start(SAMPLERATE);
|
|
context->notifyUnPause(); // get video started again, amongst other things
|
|
|
|
// back to ergo/slope mode and restore load/gradient
|
|
if (status&RT_MODE_ERGO) {
|
|
|
|
foreach(int dev, activeDevices) {
|
|
Devices[dev].controller->setMode(RT_MODE_ERGO);
|
|
Devices[dev].controller->setLoad(load);
|
|
}
|
|
} else {
|
|
|
|
foreach(int dev, activeDevices) {
|
|
Devices[dev].controller->setMode(RT_MODE_SPIN);
|
|
Devices[dev].controller->setGradient(slope);
|
|
}
|
|
}
|
|
|
|
} else {
|
|
|
|
if (bar == NULL) {
|
|
QString title = tr("Calibrating...\nPress F3 on Controller when done.");
|
|
bar = new QProgressDialog(title, tr("Done"), 0, 0, this);
|
|
bar->setWindowModality(Qt::WindowModal);
|
|
bar->setMinimumDuration(0);
|
|
bar->setAutoClose(true); // hide when reset
|
|
connect(bar, SIGNAL(canceled()), this, SLOT(Calibrate()));
|
|
}
|
|
bar->show();
|
|
|
|
// pause gui/load, streaming and recording
|
|
// but keep the gui ticking so we get realtime telemetry to detect the F3 keypad =button press
|
|
session_elapsed_msec += session_time.elapsed();
|
|
lap_elapsed_msec += lap_time.elapsed();
|
|
|
|
if (status & RT_RECORDING) disk_timer->stop();
|
|
if (status & RT_WORKOUT) load_timer->stop();
|
|
load_msecs += load_period.restart();
|
|
|
|
context->notifyPause(); // get video started again, amongst other things
|
|
|
|
// only do this for computrainers!
|
|
foreach(int dev, activeDevices)
|
|
if (Devices[dev].type == DEV_CT)
|
|
Devices[dev].controller->setMode(RT_MODE_CALIBRATE);
|
|
}
|
|
calibrating = !calibrating;
|
|
}
|
|
|
|
void TrainSidebar::FFwd()
|
|
{
|
|
if (((status&RT_RUNNING) == 0) || (status&RT_PAUSED)) return;
|
|
|
|
if (status&RT_MODE_ERGO) {
|
|
load_msecs += 10000; // jump forward 10 seconds
|
|
context->notifySeek(load_msecs);
|
|
}
|
|
else if (context->currentVideoSyncFile())
|
|
{
|
|
context->notifySeek(+1); // in case of video with RLV file synchronisation just ask to go forward
|
|
}
|
|
else displayWorkoutDistance += 1; // jump forward a kilometer in the workout
|
|
}
|
|
|
|
void TrainSidebar::Rewind()
|
|
{
|
|
if (((status&RT_RUNNING) == 0) || (status&RT_PAUSED)) return;
|
|
|
|
if (status&RT_MODE_ERGO) {
|
|
load_msecs -=10000; // jump back 10 seconds
|
|
if (load_msecs < 0) load_msecs = 0;
|
|
context->notifySeek(load_msecs);
|
|
}
|
|
else if (context->currentVideoSyncFile())
|
|
{
|
|
context->notifySeek(-1); // in case of video with RLV file synchronisation just ask to go backward
|
|
}
|
|
else {
|
|
displayWorkoutDistance -=1; // jump back a kilometer
|
|
if (displayWorkoutDistance < 0) displayWorkoutDistance = 0;
|
|
}
|
|
}
|
|
|
|
|
|
// jump to next Lap marker (if there is one?)
|
|
void TrainSidebar::FFwdLap()
|
|
{
|
|
if (((status&RT_RUNNING) == 0) || (status&RT_PAUSED)) return;
|
|
|
|
double lapmarker;
|
|
|
|
if (status&RT_MODE_ERGO) {
|
|
lapmarker = ergFile->nextLap(load_msecs);
|
|
if (lapmarker != -1) load_msecs = lapmarker; // jump forward to lapmarker
|
|
context->notifySeek(load_msecs);
|
|
} else {
|
|
lapmarker = ergFile->nextLap(displayWorkoutDistance*1000);
|
|
if (lapmarker != -1) displayWorkoutDistance = lapmarker/1000; // jump forward to lapmarker
|
|
}
|
|
}
|
|
|
|
// higher load/gradient
|
|
void TrainSidebar::Higher()
|
|
{
|
|
if ((status&RT_CONNECTED) == 0) return;
|
|
|
|
if (context->currentErgFile()) {
|
|
// adjust the workout IF
|
|
adjustIntensity(lastAppliedIntensity+5);
|
|
|
|
} else {
|
|
if (status&RT_MODE_ERGO) load += 5;
|
|
else slope += 0.1;
|
|
|
|
if (load >1500) load = 1500;
|
|
if (slope >15) slope = 15;
|
|
|
|
if (status&RT_MODE_ERGO)
|
|
foreach(int dev, activeDevices) Devices[dev].controller->setLoad(load);
|
|
else
|
|
foreach(int dev, activeDevices) Devices[dev].controller->setGradient(slope);
|
|
}
|
|
}
|
|
|
|
// lower load/gradient
|
|
void TrainSidebar::Lower()
|
|
{
|
|
if ((status&RT_CONNECTED) == 0) return;
|
|
|
|
if (context->currentErgFile()) {
|
|
// adjust the workout IF
|
|
adjustIntensity(lastAppliedIntensity-5);
|
|
|
|
} else {
|
|
|
|
if (status&RT_MODE_ERGO) load -= 5;
|
|
else slope -= 0.1;
|
|
|
|
if (load <0) load = 0;
|
|
if (slope <-10) slope = -10;
|
|
|
|
if (status&RT_MODE_ERGO)
|
|
foreach(int dev, activeDevices) Devices[dev].controller->setLoad(load);
|
|
else
|
|
foreach(int dev, activeDevices) Devices[dev].controller->setGradient(slope);
|
|
}
|
|
}
|
|
|
|
void TrainSidebar::setLabels()
|
|
{
|
|
/* should this be kept, or removed? Currently these are always hidden.
|
|
if (context->currentErgFile()) {
|
|
|
|
if (context->currentErgFile()->format == CRS) {
|
|
|
|
stress->setText(QString("Elevation %1").arg(context->currentErgFile()->ELE, 0, 'f', 0));
|
|
intensity->setText(QString("Grade %1 %").arg(context->currentErgFile()->GRADE, 0, 'f', 1));
|
|
|
|
} else {
|
|
|
|
stress->setText(QString("TSS %1").arg(context->currentErgFile()->TSS, 0, 'f', 0));
|
|
intensity->setText(QString("IF %1").arg(context->currentErgFile()->IF, 0, 'f', 3));
|
|
}
|
|
|
|
} else {
|
|
stress->setText("");
|
|
intensity->setText("");
|
|
}
|
|
*/
|
|
}
|
|
|
|
void TrainSidebar::adjustIntensity(int value)
|
|
{
|
|
if (value == lastAppliedIntensity)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (!context->currentErgFile()) return; // no workout selected
|
|
|
|
// block signals temporarily
|
|
context->mainWindow->blockSignals(true);
|
|
|
|
// work through the ergFile from NOW
|
|
// adjusting back from last setting
|
|
// and increasing to new intensity setting
|
|
|
|
double from = double(lastAppliedIntensity) / 100.00;
|
|
double to = double(value) / 100.00;
|
|
lastAppliedIntensity = value;
|
|
|
|
long starttime = context->getNow();
|
|
|
|
bool insertedNow = context->getNow() ? false : true; // don't add if at start
|
|
|
|
// what about gradient courses?
|
|
ErgFilePoint last;
|
|
for(int i = 0; i < context->currentErgFile()->Points.count(); i++) {
|
|
|
|
if (context->currentErgFile()->Points.at(i).x >= starttime) {
|
|
|
|
if (insertedNow == false) {
|
|
|
|
if (i) {
|
|
// add a point to adjust from
|
|
ErgFilePoint add;
|
|
add.x = context->getNow();
|
|
add.val = last.val / from * to;
|
|
|
|
// recalibrate altitude if gradient changing
|
|
if (context->currentErgFile()->format == CRS) add.y = last.y + ((add.x-last.x) * (add.val/100));
|
|
else add.y = add.val;
|
|
|
|
context->currentErgFile()->Points.insert(i, add);
|
|
|
|
last = add;
|
|
i++; // move on to next point (i.e. where we were!)
|
|
|
|
}
|
|
insertedNow = true;
|
|
}
|
|
|
|
ErgFilePoint *p = &context->currentErgFile()->Points[i];
|
|
|
|
// recalibrate altitude if in CRS mode
|
|
p->val = p->val / from * to;
|
|
if (context->currentErgFile()->format == CRS) {
|
|
if (i) p->y = last.y + ((p->x-last.x) * (last.val/100));
|
|
}
|
|
else p->y = p->val;
|
|
}
|
|
|
|
// remember last
|
|
last = context->currentErgFile()->Points.at(i);
|
|
}
|
|
|
|
// recalculate metrics
|
|
context->currentErgFile()->calculateMetrics();
|
|
setLabels();
|
|
|
|
// unblock signals now we are done
|
|
context->mainWindow->blockSignals(false);
|
|
|
|
// force replot
|
|
context->notifySetNow(context->getNow());
|
|
|
|
emit intensityChanged(lastAppliedIntensity);
|
|
}
|
|
|
|
MultiDeviceDialog::MultiDeviceDialog(Context *, TrainSidebar *traintool) : traintool(traintool)
|
|
{
|
|
setAttribute(Qt::WA_DeleteOnClose);
|
|
setWindowFlags(windowFlags() | Qt::WindowStaysOnTopHint);
|
|
setWindowTitle(tr("Multiple Device Configuration"));
|
|
|
|
QVBoxLayout *main = new QVBoxLayout(this);
|
|
QFormLayout *mainLayout = new QFormLayout;
|
|
main->addLayout(mainLayout);
|
|
|
|
bpmSelect = new QComboBox(this);
|
|
mainLayout->addRow(new QLabel("Heartrate", this), bpmSelect);
|
|
|
|
wattsSelect = new QComboBox(this);
|
|
mainLayout->addRow(new QLabel("Power", this), wattsSelect);
|
|
|
|
rpmSelect = new QComboBox(this);
|
|
mainLayout->addRow(new QLabel("Cadence", this), rpmSelect);
|
|
|
|
kphSelect = new QComboBox(this);
|
|
mainLayout->addRow(new QLabel("Speed", this), kphSelect);
|
|
|
|
// update the device selections for the drop downs
|
|
foreach(QTreeWidgetItem *selected, traintool->deviceTree->selectedItems()) {
|
|
if (selected->type() == HEAD_TYPE) continue;
|
|
|
|
bpmSelect->addItem(selected->text(0), selected->type());
|
|
wattsSelect->addItem(selected->text(0), selected->type());
|
|
rpmSelect->addItem(selected->text(0), selected->type());
|
|
kphSelect->addItem(selected->text(0), selected->type());
|
|
}
|
|
|
|
bpmSelect->addItem("None", -1);
|
|
wattsSelect->addItem("None", -1);
|
|
rpmSelect->addItem("None", -1);
|
|
kphSelect->addItem("None", -1);
|
|
|
|
// set to the current values (if set)
|
|
if (traintool->bpmTelemetry != -1) {
|
|
int index = bpmSelect->findData(traintool->bpmTelemetry);
|
|
if (index >=0) bpmSelect->setCurrentIndex(index);
|
|
}
|
|
if (traintool->wattsTelemetry != -1) {
|
|
int index = wattsSelect->findData(traintool->wattsTelemetry);
|
|
if (index >=0) wattsSelect->setCurrentIndex(index);
|
|
}
|
|
if (traintool->rpmTelemetry != -1) {
|
|
int index = rpmSelect->findData(traintool->rpmTelemetry);
|
|
if (index >=0) rpmSelect->setCurrentIndex(index);
|
|
}
|
|
if (traintool->kphTelemetry != -1) {
|
|
int index = kphSelect->findData(traintool->kphTelemetry);
|
|
if (index >=0) kphSelect->setCurrentIndex(index);
|
|
}
|
|
|
|
QHBoxLayout *buttons = new QHBoxLayout;
|
|
buttons->addStretch();
|
|
main->addLayout(buttons);
|
|
|
|
cancelButton = new QPushButton("Cancel", this);
|
|
buttons->addWidget(cancelButton);
|
|
|
|
applyButton = new QPushButton("Apply", this);
|
|
buttons->addWidget(applyButton);
|
|
|
|
connect(cancelButton, SIGNAL(clicked()), this, SLOT(cancelClicked()));
|
|
connect(applyButton, SIGNAL(clicked()), this, SLOT(applyClicked()));
|
|
}
|
|
|
|
void
|
|
MultiDeviceDialog::applyClicked()
|
|
{
|
|
traintool->rpmTelemetry = rpmSelect->itemData(rpmSelect->currentIndex()).toInt();
|
|
traintool->bpmTelemetry = bpmSelect->itemData(bpmSelect->currentIndex()).toInt();
|
|
traintool->wattsTelemetry = wattsSelect->itemData(wattsSelect->currentIndex()).toInt();
|
|
traintool->kphTelemetry = kphSelect->itemData(kphSelect->currentIndex()).toInt();
|
|
accept();
|
|
}
|
|
|
|
void
|
|
MultiDeviceDialog::cancelClicked()
|
|
{
|
|
reject();
|
|
}
|
|
|
|
void
|
|
TrainSidebar::devicePopup()
|
|
{
|
|
// OK - we are working with a specific event..
|
|
QMenu menu(deviceTree);
|
|
|
|
QAction *addDevice = new QAction(tr("Add Device"), deviceTree);
|
|
connect(addDevice, SIGNAL(triggered(void)), context->mainWindow, SLOT(addDevice()));
|
|
menu.addAction(addDevice);
|
|
|
|
if (deviceTree->selectedItems().size() == 1) {
|
|
QAction *delDevice = new QAction(tr("Delete Device"), deviceTree);
|
|
connect(delDevice, SIGNAL(triggered(void)), this, SLOT(deleteDevice()));
|
|
menu.addAction(delDevice);
|
|
}
|
|
|
|
// execute the menu
|
|
menu.exec(trainSplitter->mapToGlobal(QPoint(deviceItem->pos().x()+deviceItem->width()-20,
|
|
deviceItem->pos().y())));
|
|
}
|
|
void
|
|
TrainSidebar::deviceTreeMenuPopup(const QPoint &pos)
|
|
{
|
|
QMenu menu(deviceTree);
|
|
QAction *addDevice = new QAction(tr("Add Device"), deviceTree);
|
|
connect(addDevice, SIGNAL(triggered(void)), context->mainWindow, SLOT(addDevice()));
|
|
menu.addAction(addDevice);
|
|
|
|
if (deviceTree->selectedItems().size() == 1) {
|
|
QAction *delDevice = new QAction(tr("Delete Device"), deviceTree);
|
|
connect(delDevice, SIGNAL(triggered(void)), this, SLOT(deleteDevice()));
|
|
menu.addAction(delDevice);
|
|
}
|
|
|
|
menu.exec(deviceTree->mapToGlobal(pos));
|
|
}
|
|
|
|
void
|
|
TrainSidebar::deleteDevice()
|
|
{
|
|
// get the configuration
|
|
DeviceConfigurations all;
|
|
QList<DeviceConfiguration>list = all.getList();
|
|
|
|
// Delete the selected device
|
|
QTreeWidgetItem *selected = deviceTree->selectedItems().first();
|
|
int index = deviceTree->invisibleRootItem()->indexOfChild(selected);
|
|
|
|
if (index < 0 || index > list.size()) return;
|
|
|
|
// make sure they really mean this!
|
|
QMessageBox msgBox;
|
|
msgBox.setText(tr("Are you sure you want to delete this device?"));
|
|
msgBox.setInformativeText(list[index].name);
|
|
QPushButton *deleteButton = msgBox.addButton(tr("Delete"),QMessageBox::YesRole);
|
|
msgBox.setStandardButtons(QMessageBox::Cancel);
|
|
msgBox.setDefaultButton(QMessageBox::Cancel);
|
|
msgBox.setIcon(QMessageBox::Critical);
|
|
msgBox.exec();
|
|
|
|
if(msgBox.clickedButton() != deleteButton) return;
|
|
|
|
// find this one and delete it
|
|
list.removeAt(index);
|
|
all.writeConfig(list);
|
|
|
|
// tell everyone
|
|
context->notifyConfigChanged(CONFIG_DEVICES);
|
|
}
|
|
|
|
// we have been told to select this video (usually because
|
|
// the user just dragndropped it in)
|
|
void
|
|
TrainSidebar::selectVideo(QString fullpath)
|
|
{
|
|
// look at each entry in the top workoutTree
|
|
for (int i=0; i<mediaTree->model()->rowCount(); i++) {
|
|
QString path = mediaTree->model()->data(mediaTree->model()->index(i,0)).toString();
|
|
if (path == fullpath) {
|
|
mediaTree->setCurrentIndex(mediaTree->model()->index(i,0));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
TrainSidebar::selectVideoSync(QString fullpath)
|
|
{
|
|
// look at each entry in the top videosyncTree
|
|
for (int i=0; i<videosyncTree->model()->rowCount(); i++) {
|
|
QString path = videosyncTree->model()->data(videosyncTree->model()->index(i,0)).toString();
|
|
if (path == fullpath) {
|
|
videosyncTree->setCurrentIndex(videosyncTree->model()->index(i,0));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// we have been told to select this workout (usually because
|
|
// the user just dragndropped it in)
|
|
void
|
|
TrainSidebar::selectWorkout(QString fullpath)
|
|
{
|
|
// look at each entry in the top workoutTree
|
|
for (int i=0; i<workoutTree->model()->rowCount(); i++) {
|
|
QString path = workoutTree->model()->data(workoutTree->model()->index(i,0)).toString();
|
|
if (path == fullpath) {
|
|
workoutTree->setCurrentIndex(workoutTree->model()->index(i,0));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// got a remote control command
|
|
void
|
|
TrainSidebar::remoteControl(uint16_t command)
|
|
{
|
|
//qDebug() << "TrainSidebar::remoteControl()" << command;
|
|
|
|
switch(command){
|
|
|
|
case GC_REMOTE_CMD_START:
|
|
this->Start();
|
|
break;
|
|
|
|
case GC_REMOTE_CMD_STOP:
|
|
this->Stop();
|
|
break;
|
|
|
|
case GC_REMOTE_CMD_LAP:
|
|
this->newLap();
|
|
break;
|
|
|
|
case GC_REMOTE_CMD_HIGHER:
|
|
this->Higher();
|
|
break;
|
|
|
|
case GC_REMOTE_CMD_LOWER:
|
|
this->Lower();
|
|
break;
|
|
|
|
case GC_REMOTE_CMD_CALIBRATE:
|
|
this->Calibrate();
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
// connect/disconnect automatically when view changes
|
|
void
|
|
TrainSidebar::viewChanged(int index)
|
|
{
|
|
//qDebug() << "view has changed to:" << index;
|
|
if (!autoConnect) return;
|
|
|
|
// fixme: value hard-coded throughout
|
|
if (index == 3) {
|
|
//train view
|
|
if ((status&RT_CONNECTED) == 0) {
|
|
Connect();
|
|
}
|
|
} else {
|
|
// other view
|
|
if ((status&RT_CONNECTED) && (status&RT_RUNNING) == 0) {
|
|
Disconnect();
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
void TrainSidebar::setStatusFlags(int flags)
|
|
{
|
|
status |= flags;
|
|
context->isRunning = (status&RT_RUNNING);
|
|
context->isPaused = (status&RT_PAUSED);
|
|
|
|
emit statusChanged(status);
|
|
}
|
|
|
|
void TrainSidebar::clearStatusFlags(int flags)
|
|
{
|
|
status &=~flags;
|
|
context->isRunning = (status&RT_RUNNING);
|
|
context->isPaused = (status&RT_PAUSED);
|
|
|
|
emit statusChanged(status);
|
|
}
|