676 lines
23 KiB
C++
676 lines
23 KiB
C++
#include "windowrace.h"
|
|
#include "qvectorhelper.h"
|
|
#include "timemodel.h"
|
|
#include "ui_windowrace.h"
|
|
#include "unistd.h"
|
|
#include <QKeySequence>
|
|
#include <QObject>
|
|
#include <QShortcut>
|
|
#include <iostream>
|
|
#include <sstream>
|
|
#include <string>
|
|
|
|
using std::cout;
|
|
using std::endl;
|
|
using std::string;
|
|
using std::vector;
|
|
|
|
WindowRace::WindowRace(DataBase * db, QWidget * parent)
|
|
: QMainWindow(parent), ui(new Ui::WindowRace) {
|
|
ui->setupUi(this);
|
|
this->ui->pBNextRace->setEnabled(false);
|
|
this->finished = false;
|
|
|
|
this->wRennlisteSeted = false;
|
|
|
|
this->db = db;
|
|
|
|
vector<vector<QString>> res;
|
|
res = db->getData("select dauer from renndauer", 1);
|
|
this->fahrzeit = res[0][0].toInt();
|
|
|
|
string statement =
|
|
"select minimumroundtime from rennen order by id DESC limit 1";
|
|
res = db->getData(statement, 1);
|
|
this->minimumTime = res[0][0].toInt();
|
|
|
|
// fill minSecTimes vector
|
|
statement = "select minsec1, minsec2, minsec3, mindestRundenDauer from "
|
|
"renndauer order by id "
|
|
"DESC limit 1";
|
|
// cout << statement << endl;
|
|
res = db->getData(statement, 4);
|
|
this->minSecTime.append(res[0][0].toInt());
|
|
this->minSecTime.append(res[0][1].toInt());
|
|
this->minSecTime.append(res[0][2].toInt());
|
|
this->minSecTime.append(res[0][3].toInt());
|
|
|
|
QVectorHelper::minSec1 = this->minSecTime.at(0);
|
|
QVectorHelper::minSec2 = this->minSecTime.at(1);
|
|
QVectorHelper::minSec3 = this->minSecTime.at(2);
|
|
QVectorHelper::minTrackTime = this->minSecTime.at(3);
|
|
// cout << "Track time minimum:" << QVectorHelper::minTrackTime << endl;
|
|
|
|
firstTimeDea = true;
|
|
firstTimeShell = true;
|
|
started = false;
|
|
countdownValue = this->fahrzeit;
|
|
countdown = new Countdown;
|
|
|
|
startAmpelThread = new Ampel;
|
|
ampelCounter = 0;
|
|
|
|
ui->pBStart->setFocus();
|
|
|
|
paused = false;
|
|
|
|
Hardware = new HardwareSetup;
|
|
Hardware->start();
|
|
|
|
QObject::connect(Hardware, SIGNAL(Dea(int, int)), this,
|
|
SLOT(deaSlot(int, int)));
|
|
QObject::connect(Hardware, SIGNAL(Shell(int, int)), this,
|
|
SLOT(shellSlot(int, int)));
|
|
QObject::connect(ui->pBStart, SIGNAL(clicked()), this, SLOT(go()));
|
|
QObject::connect(countdown, SIGNAL(CountdownUpdate()), this,
|
|
SLOT(countdownUpdate()));
|
|
QObject::connect(startAmpelThread, SIGNAL(ampelUpdate()), this,
|
|
SLOT(ampelSlot()));
|
|
QObject::connect(startAmpelThread, SIGNAL(ampelUpdate()), this,
|
|
SLOT(laufcheck()));
|
|
QObject::connect(ui->pBBreak, SIGNAL(clicked()), this,
|
|
SLOT(breakCounter()));
|
|
QObject::connect(this->ui->pBNextRace, SIGNAL(clicked()), this,
|
|
SLOT(prepareNextRace()));
|
|
QObject::connect(this->ui->pBStop, SIGNAL(clicked()), this,
|
|
SLOT(stopClicked()));
|
|
|
|
ui->lCountdown->setText(timeWrapper(countdownValue));
|
|
|
|
// Ampelsetup
|
|
ui->WAmpel15->hide();
|
|
ui->WAmpel25->hide();
|
|
ui->hW15->setVisible(true);
|
|
ui->hW25->setVisible(true);
|
|
ui->WAmpel14->hide();
|
|
ui->WAmpel24->hide();
|
|
ui->hW14->setVisible(true);
|
|
ui->hW24->setVisible(true);
|
|
ui->WAmpel13->hide();
|
|
ui->WAmpel23->hide();
|
|
ui->hW13->setVisible(true);
|
|
ui->hW23->setVisible(true);
|
|
ui->WAmpel12->hide();
|
|
ui->WAmpel22->hide();
|
|
ui->hW12->setVisible(true);
|
|
ui->hw22->setVisible(true);
|
|
ui->WAmpel11->hide();
|
|
ui->WAmpel21->hide();
|
|
ui->hW11->setVisible(true);
|
|
ui->hW21->setVisible(true);
|
|
|
|
vector<vector<QString>> fahrer, autos, rennid, tableData;
|
|
statement = "select id_rennen from aktrennen group by id_rennen order by "
|
|
"id_rennen DESC limit 1";
|
|
rennid = this->db->getData(statement, 1);
|
|
this->renn_id = rennid[0][0].toInt();
|
|
statement = "select fahrershellid, autoshellid, fahrerdeaid, autodeaid "
|
|
"from aktrennen where id_rennen like " +
|
|
rennid[0][0].toStdString() + " limit 1";
|
|
|
|
tableData = db->getData2(statement, 4);
|
|
|
|
statement = "select name from fahrer where id like " +
|
|
tableData[0][0].toStdString();
|
|
fahrer = this->db->getData2(statement, 1);
|
|
|
|
statement = "select name from AutoKonfiguration where id_auto like " +
|
|
tableData[0][1].toStdString() + " order by seit DESC";
|
|
autos = this->db->getData2(statement, 1);
|
|
|
|
this->ui->gbShell->setTitle("Shell, " + fahrer[0][0] + ", " + autos[0][0]);
|
|
|
|
statement = "select name from fahrer where id like " +
|
|
tableData[0][2].toStdString();
|
|
fahrer = this->db->getData2(statement, 1);
|
|
|
|
statement = "select name from AutoKonfiguration where id_auto like " +
|
|
tableData[0][3].toStdString() + " order by seit DESC";
|
|
autos = this->db->getData2(statement, 1);
|
|
|
|
this->ui->gbDea->setTitle("Dea, " + fahrer[0][0] + ", " + autos[0][0]);
|
|
|
|
this->shellDriverId = tableData[0][0].toInt();
|
|
this->shellCarId = tableData[0][1].toInt();
|
|
this->deaDriverId = tableData[0][2].toInt();
|
|
this->deaCarId = tableData[0][3].toInt();
|
|
|
|
// progressbar
|
|
this->ui->pbTime->setMaximum(this->fahrzeit);
|
|
this->ui->pbTime->setMinimum(0);
|
|
this->ui->pbTime->setTextVisible(false);
|
|
this->ui->pbTime->setStyleSheet("QProgressBar::chunk { color: #05B8CC;}");
|
|
this->ui->pbTime->setValue(0);
|
|
|
|
QKeySequence ks(Qt::Key_Return); // btw, this is numpad enter
|
|
QShortcut * keyReturn = new QShortcut(ks, this);
|
|
QObject::connect(keyReturn, SIGNAL(activated()), this, SLOT(ReturnPress()));
|
|
|
|
// QObject::connect(shortcut, SIGNAL(activated()), this, SLOT(close()));
|
|
}
|
|
|
|
void WindowRace::ReturnPress() {
|
|
// cout << "Return pressed" << endl;
|
|
if (this->ui->pBNextRace->isEnabled()) {
|
|
this->prepareNextRace();
|
|
if (this->wRennlisteSeted) {
|
|
this->wRennliste->changeSelection();
|
|
}
|
|
else {
|
|
cout << "Problem with racelist" << endl;
|
|
}
|
|
}
|
|
else {
|
|
if (started) {
|
|
this->breakCounter();
|
|
}
|
|
else {
|
|
this->go();
|
|
}
|
|
}
|
|
}
|
|
|
|
void WindowRace::prepareNextRace() {
|
|
this->firstTimeShell = true;
|
|
this->firstTimeDea = true;
|
|
|
|
// this->ui->lWShellTime->clear();
|
|
// this->ui->lWDeaTime->clear();
|
|
|
|
this->ui->lBestZeitDea->setText("∞");
|
|
this->ui->lBestZeitShell->setText("∞");
|
|
this->ui->lCurRoundTimeShell->setText("∞");
|
|
this->ui->lCurRoundDea->setText("∞");
|
|
|
|
this->ui->lBridgeShell->setText("∞");
|
|
this->ui->lStraightShell->setText("∞");
|
|
this->ui->lCurvesShell->setText("∞");
|
|
this->ui->lDeltaShellTop->setText("∞");
|
|
|
|
this->ui->lBridgeDea->setText("∞");
|
|
this->ui->lStraightDea->setText("∞");
|
|
this->ui->lCurvesDea->setText("∞");
|
|
this->ui->lDeltaDeaTop->setText("∞");
|
|
|
|
this->VecShell.clear();
|
|
this->VecDea.clear();
|
|
|
|
// clear tableview shell
|
|
timeModelShell = new TimeModel(VecShell, minSecTime);
|
|
ui->lWShellTime->setModel(timeModelShell);
|
|
|
|
// clear tableview dea
|
|
timeModelDea = new TimeModel(VecDea, minSecTime);
|
|
ui->lWDeaTime->setModel(timeModelDea);
|
|
|
|
this->finished = false;
|
|
this->paused = false;
|
|
this->started = false;
|
|
this->countdownValue = this->fahrzeit;
|
|
this->ampelCounter = 0;
|
|
this->startAmpelThread->terminate();
|
|
this->countdown->terminate();
|
|
this->ui->pBNextRace->setEnabled(false);
|
|
this->ui->lCountdown->setText(timeWrapper(countdownValue));
|
|
|
|
// progressbar
|
|
this->ui->pbTime->setStyleSheet("QProgressBar::chunk { color: #05B8CC;}");
|
|
this->ui->pbTime->setValue(0);
|
|
|
|
// countdown
|
|
this->ui->lCountdown->setStyleSheet("QLabel { color: black; }");
|
|
|
|
// Ampel Setup
|
|
ui->WAmpel15->hide();
|
|
ui->WAmpel25->hide();
|
|
ui->hW15->setVisible(true);
|
|
ui->hW25->setVisible(true);
|
|
ui->WAmpel14->hide();
|
|
ui->WAmpel24->hide();
|
|
ui->hW14->setVisible(true);
|
|
ui->hW24->setVisible(true);
|
|
ui->WAmpel13->hide();
|
|
ui->WAmpel23->hide();
|
|
ui->hW13->setVisible(true);
|
|
ui->hW23->setVisible(true);
|
|
ui->WAmpel12->hide();
|
|
ui->WAmpel22->hide();
|
|
ui->hW12->setVisible(true);
|
|
ui->hw22->setVisible(true);
|
|
ui->WAmpel11->hide();
|
|
ui->WAmpel21->hide();
|
|
ui->hW11->setVisible(true);
|
|
ui->hW21->setVisible(true);
|
|
}
|
|
void WindowRace::setDriverAndCar(vector<QString> vec) {
|
|
this->ui->gbShell->setTitle("Shell, " + vec[0] + ", " + vec[1]);
|
|
this->ui->gbDea->setTitle("Dea, " + vec[2] + ", " + vec[3]);
|
|
}
|
|
void WindowRace::stopClicked() {
|
|
this->prepareNextRace();
|
|
}
|
|
|
|
void WindowRace::setWindowRennliste(WindowRennliste * ptrInstance) {
|
|
|
|
this->wRennliste = ptrInstance;
|
|
this->wRennlisteSeted = true;
|
|
QObject::connect(this->ui->pBNextRace, SIGNAL(clicked()), this->wRennliste,
|
|
SLOT(changeSelection()));
|
|
}
|
|
void WindowRace::setDriverAndCarId(vector<QString> vec) {
|
|
this->shellDriverId = vec[0].toInt();
|
|
this->shellCarId = vec[1].toInt();
|
|
this->deaDriverId = vec[2].toInt();
|
|
this->deaCarId = vec[3].toInt();
|
|
}
|
|
void WindowRace::closeEvent(QCloseEvent * event) {
|
|
countdown->setStop();
|
|
|
|
QMessageBox msgBox;
|
|
msgBox.setText("Wirklich schliessen?");
|
|
msgBox.setInformativeText("");
|
|
msgBox.setStandardButtons(QMessageBox::Yes | QMessageBox::No);
|
|
msgBox.setDefaultButton(QMessageBox::No);
|
|
int ret = msgBox.exec();
|
|
|
|
switch (ret) {
|
|
case QMessageBox::No:
|
|
event->ignore();
|
|
break;
|
|
case QMessageBox::Yes:
|
|
this->wRennliste->schliessen();
|
|
this->Hardware->setStop();
|
|
event->accept();
|
|
break;
|
|
default:
|
|
// should never be reached
|
|
break;
|
|
}
|
|
}
|
|
|
|
void WindowRace::breakCounter() {
|
|
if (!paused) {
|
|
paused = true;
|
|
ui->pBBreak->setText("Weiter");
|
|
}
|
|
else {
|
|
ui->pBBreak->setText("Pause");
|
|
paused = false;
|
|
}
|
|
}
|
|
|
|
void WindowRace::laufcheck() {
|
|
// std::cout << "thread lauft noch" << std::endl;
|
|
}
|
|
|
|
QString WindowRace::timeWrapper(long zahl) {
|
|
|
|
long min = zahl / 60;
|
|
int sec = zahl % 60;
|
|
QString sec_q;
|
|
if (sec < 10) {
|
|
sec_q = "0" + QString::number(sec);
|
|
}
|
|
else {
|
|
sec_q = QString::number(sec);
|
|
}
|
|
QString min_q = QString::number(min);
|
|
return min_q + ":" + sec_q;
|
|
}
|
|
|
|
void WindowRace::countdownUpdate() {
|
|
if (!paused) {
|
|
countdownValue -= 1;
|
|
if (countdownValue <= 15) {
|
|
this->ui->lCountdown->setStyleSheet("QLabel { color: red; }");
|
|
this->ui->pbTime->setStyleSheet(
|
|
"QProgressBar::chunk { background-color: orange; }");
|
|
// this->ui->pbTime->
|
|
}
|
|
if (countdownValue <= -1) {
|
|
this->finished = true;
|
|
this->wRennliste->setBesttime(QVectorHelper::getMin(VecShell),
|
|
QVectorHelper::getMin(this->VecDea));
|
|
this->ui->pBNextRace->setEnabled(true);
|
|
}
|
|
else {
|
|
ui->lCountdown->setText(timeWrapper(countdownValue));
|
|
this->ui->pbTime->setValue(this->fahrzeit -
|
|
static_cast<int>(countdownValue));
|
|
}
|
|
}
|
|
}
|
|
|
|
WindowRace::~WindowRace() {
|
|
this->startAmpelThread->setStop();
|
|
this->countdown->setStop();
|
|
this->Hardware->setStop();
|
|
usleep(1000010); // eine Sekunde
|
|
|
|
delete this->countdown;
|
|
delete this->Hardware;
|
|
delete this->startAmpelThread;
|
|
|
|
// delete this->db;
|
|
|
|
delete ui;
|
|
}
|
|
void WindowRace::shellSlot(int time, int sector) {
|
|
if (started && !paused && !this->finished) {
|
|
if (firstTimeShell) {
|
|
firstTimeShell = false;
|
|
// counterShell.start();
|
|
}
|
|
else {
|
|
// long zeit = counterShell.getTime();
|
|
QVector<int> test;
|
|
switch (sector) {
|
|
case 1:
|
|
VecShell.append(QVector<int>());
|
|
VecShell.last().append(time);
|
|
|
|
// update tableview
|
|
|
|
test.append(1);
|
|
test.append(2);
|
|
test.append(3);
|
|
this->timeModelShell =
|
|
new TimeModel(VecShell, minSecTime, test, this);
|
|
// this->ui->lWShellTime->setModel(this->timeModelShell);
|
|
ui->lWShellTime->setModel(this->timeModelShell);
|
|
|
|
this->ui->lBridgeShell->setText(QString::number(
|
|
static_cast<double>(QVectorHelper::getMinSec1(VecShell)) /
|
|
1000));
|
|
break;
|
|
|
|
case 2:
|
|
if (VecShell.size() > 0) {
|
|
if (VecShell.last().size() == 1) {
|
|
VecShell.last().append(time);
|
|
}
|
|
// update tableview
|
|
|
|
test.append(1);
|
|
test.append(2);
|
|
test.append(3);
|
|
this->timeModelShell =
|
|
new TimeModel(VecShell, minSecTime, test, this);
|
|
// timeModelShell = new
|
|
// TimeModel(VecShell, this);
|
|
this->ui->lWShellTime->setModel(timeModelShell);
|
|
this->ui->lStraightShell->setText(QString::number(
|
|
static_cast<double>(
|
|
QVectorHelper::getMinSec2(VecShell)) /
|
|
1000));
|
|
}
|
|
break;
|
|
case 3:
|
|
if (VecShell.size() > 0) {
|
|
if (VecShell.last().size() == 2) {
|
|
VecShell.last().append(time);
|
|
VecShell.last().append(
|
|
QVectorHelper::getCurTime(VecShell.last()));
|
|
|
|
if (QVectorHelper::getCurTime(VecShell.last()) <=
|
|
QVectorHelper::getMin(VecShell)) {
|
|
ui->lBestZeitShell->setText(QString::number(
|
|
static_cast<double>(
|
|
QVectorHelper::getMin(VecShell)) /
|
|
1000));
|
|
}
|
|
ui->lCurRoundTimeShell->setText(QString::number(
|
|
static_cast<double>(
|
|
QVectorHelper::getCurTime(VecShell.last())) /
|
|
1000));
|
|
|
|
// update tableview
|
|
|
|
test.append(1);
|
|
test.append(2);
|
|
test.append(3);
|
|
this->timeModelShell =
|
|
new TimeModel(VecShell, minSecTime, test, this);
|
|
// timeModelShell = new
|
|
// TimeModel(VecShell, this);
|
|
this->ui->lWShellTime->setModel(timeModelShell);
|
|
|
|
this->ui->lCurvesShell->setText(QString::number(
|
|
static_cast<double>(
|
|
QVectorHelper::getMinSec3(VecShell)) /
|
|
1000));
|
|
theoreticalMinShell = 9999;
|
|
theoreticalMinShell =
|
|
QVectorHelper::getMinSec1(VecShell) +
|
|
QVectorHelper::getMinSec2(VecShell) +
|
|
QVectorHelper::getMinSec3(VecShell);
|
|
deltaShell = QVectorHelper::getMin(VecShell) -
|
|
theoreticalMinShell;
|
|
this->ui->lDeltaShellTop->setText(QString::number(
|
|
static_cast<double>(deltaShell) / 1000));
|
|
|
|
if (VecShell.size() > 0) {
|
|
int zeit =
|
|
QVectorHelper::getCurTime(VecShell.last());
|
|
QString statement =
|
|
"insert into Zeiten (id_rennen, id_fahrer, "
|
|
"id_auto, id_bahn, zeit) values (" +
|
|
QString::number(this->renn_id) + ", " +
|
|
QString::number(this->shellDriverId) + ", " +
|
|
QString::number(this->shellCarId) + ", 1, " +
|
|
QString::number(zeit) + ")";
|
|
// cout << statement.toStdString() << endl;
|
|
|
|
this->db->setData(statement.toStdString());
|
|
}
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
if (sector == 3) {
|
|
}
|
|
|
|
ui->lWShellTime->scrollToBottom();
|
|
}
|
|
}
|
|
ui->lWShellTime->scrollToBottom();
|
|
ui->lWShellTime->horizontalHeader()->setSectionResizeMode(
|
|
QHeaderView::Stretch);
|
|
}
|
|
void WindowRace::deaSlot(int time, int sector) {
|
|
if (started && !paused && !this->finished) {
|
|
if (firstTimeDea) {
|
|
firstTimeDea = false;
|
|
counterDea.start();
|
|
}
|
|
else {
|
|
|
|
switch (sector) {
|
|
case 1:
|
|
VecDea.push_back(QVector<int>());
|
|
VecDea.last().push_back(time);
|
|
cout << "Dea Sektor 1" << endl;
|
|
timeModelDea = new TimeModel(VecDea, minSecTime, this);
|
|
this->ui->lWDeaTime->setModel(timeModelDea);
|
|
|
|
this->ui->lBridgeDea->setText(QString::number(
|
|
static_cast<double>(QVectorHelper::getMinSec1(VecDea)) /
|
|
1000));
|
|
|
|
break;
|
|
case 2:
|
|
if (VecDea.size() > 0) {
|
|
if (VecDea.last().size() == 1) {
|
|
cout << time << sector << endl;
|
|
VecDea[VecDea.size() - 1].push_back(time);
|
|
timeModelDea = new TimeModel(VecDea, minSecTime, this);
|
|
this->ui->lWDeaTime->setModel(timeModelDea);
|
|
this->ui->lStraightDea->setText(QString::number(
|
|
static_cast<double>(
|
|
QVectorHelper::getMinSec2(VecDea)) /
|
|
1000));
|
|
}
|
|
else {
|
|
// VecDea[VecDea.size()-1].append(9999);
|
|
}
|
|
}
|
|
break;
|
|
case 3:
|
|
if (VecDea.size() > 0) {
|
|
// cout << "Time sec 3: " << time << endl;
|
|
if (VecDea.last().size() == 2) {
|
|
// cout << time << sector <<
|
|
// endl;
|
|
VecDea.last().push_back(time);
|
|
|
|
// add sum to vector
|
|
VecDea.last().push_back(
|
|
QVectorHelper::getCurTime(VecDea.last()));
|
|
|
|
timeModelDea = new TimeModel(VecDea, minSecTime, this);
|
|
this->ui->lWDeaTime->setModel(timeModelDea);
|
|
}
|
|
|
|
// best time on widget
|
|
cout << "cur time: "
|
|
<< QVectorHelper::getCurTime(VecDea.last()) << endl;
|
|
cout << "min time: " << QVectorHelper::getMin(VecDea)
|
|
<< endl;
|
|
if (QVectorHelper::getCurTime(VecDea.last()) <=
|
|
QVectorHelper::getMin(VecDea)) {
|
|
ui->lBestZeitDea->setText(QString::number(
|
|
static_cast<double>(QVectorHelper::getMin(VecDea)) /
|
|
1000));
|
|
}
|
|
ui->lCurRoundDea->setText(QString::number(
|
|
static_cast<double>(
|
|
QVectorHelper::getCurTime(VecDea.last())) /
|
|
1000));
|
|
}
|
|
|
|
this->ui->lCurvesDea->setText(QString::number(
|
|
static_cast<double>(QVectorHelper::getMinSec3(VecDea)) /
|
|
1000));
|
|
theoreticalMinDea = 9999;
|
|
theoreticalMinDea = QVectorHelper::getMinSec1(VecDea) +
|
|
QVectorHelper::getMinSec2(VecDea) +
|
|
QVectorHelper::getMinSec3(VecDea);
|
|
deltaDea = QVectorHelper::getMin(VecDea) - theoreticalMinDea;
|
|
this->ui->lDeltaDeaTop->setText(
|
|
QString::number(static_cast<double>(deltaDea) / 1000));
|
|
if (VecDea.size() > 0) {
|
|
int zeit = QVectorHelper::getCurTime(VecDea.last());
|
|
QString statement =
|
|
"insert into Zeiten (id_rennen, id_fahrer, "
|
|
"id_auto, id_bahn, zeit) values (" +
|
|
QString::number(this->renn_id) + ", " +
|
|
QString::number(this->deaDriverId) + ", " +
|
|
QString::number(this->deaCarId) + ", 2, " +
|
|
QString::number(zeit) + ")";
|
|
// cout << statement.toStdString() << endl;
|
|
this->db->setData(statement.toStdString());
|
|
ui->lWDeaTime->scrollToBottom();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
ui->lWDeaTime->scrollToBottom();
|
|
ui->lWDeaTime->horizontalHeader()->setSectionResizeMode(
|
|
QHeaderView::Stretch);
|
|
}
|
|
|
|
long WindowRace::getMinimum(std::vector<long> a) {
|
|
long minimum = -1;
|
|
for (unsigned int i = 0; i < a.size(); i++) {
|
|
if (minimum < 0) {
|
|
if (a[i] >= this->minimumTime) {
|
|
minimum = a[i];
|
|
}
|
|
}
|
|
else {
|
|
if (a[i] < minimum && a[i] >= this->minimumTime) {
|
|
minimum = a[i];
|
|
}
|
|
}
|
|
}
|
|
return minimum;
|
|
}
|
|
void WindowRace::ampelSlot() {
|
|
if (ampelCounter == 5) {
|
|
ui->WAmpel15->hide();
|
|
ui->WAmpel25->hide();
|
|
ui->hW15->setVisible(true);
|
|
ui->hW25->setVisible(true);
|
|
ui->WAmpel14->hide();
|
|
ui->WAmpel24->hide();
|
|
ui->hW14->setVisible(true);
|
|
ui->hW24->setVisible(true);
|
|
ui->WAmpel13->hide();
|
|
ui->WAmpel23->hide();
|
|
ui->hW13->setVisible(true);
|
|
ui->hW23->setVisible(true);
|
|
ui->WAmpel12->hide();
|
|
ui->WAmpel22->hide();
|
|
ui->hW12->setVisible(true);
|
|
ui->hw22->setVisible(true);
|
|
ui->WAmpel11->hide();
|
|
ui->WAmpel21->hide();
|
|
ui->hW11->setVisible(true);
|
|
ui->hW21->setVisible(true);
|
|
startAmpelThread->terminate();
|
|
started = true;
|
|
countdown->start();
|
|
}
|
|
if (ampelCounter == 4) {
|
|
ampelCounter = 5;
|
|
ui->WAmpel15->setVisible(true);
|
|
ui->WAmpel25->setVisible(true);
|
|
ui->hW15->hide();
|
|
ui->hW25->hide();
|
|
}
|
|
if (ampelCounter == 3) {
|
|
ampelCounter = 4;
|
|
ui->WAmpel14->setVisible(true);
|
|
ui->WAmpel24->setVisible(true);
|
|
ui->hW14->hide();
|
|
ui->hW24->hide();
|
|
}
|
|
if (ampelCounter == 2) {
|
|
ampelCounter = 3;
|
|
ui->WAmpel13->setVisible(true);
|
|
ui->WAmpel23->setVisible(true);
|
|
ui->hW13->hide();
|
|
ui->hW23->hide();
|
|
}
|
|
if (ampelCounter == 1) {
|
|
ampelCounter = 2;
|
|
ui->WAmpel12->setVisible(true);
|
|
ui->WAmpel22->setVisible(true);
|
|
ui->hW12->hide();
|
|
ui->hw22->hide();
|
|
}
|
|
if (ampelCounter == 0) {
|
|
ampelCounter = 1;
|
|
ui->WAmpel11->setVisible(true);
|
|
ui->WAmpel21->setVisible(true);
|
|
ui->hW11->hide();
|
|
ui->hW21->hide();
|
|
}
|
|
}
|
|
|
|
void WindowRace::go() {
|
|
startAmpelThread->start();
|
|
}
|