From 6c01b76b9c74197eee62a35505cc68540b4d9a15 Mon Sep 17 00:00:00 2001 From: JPaehr Date: Thu, 6 Dec 2018 23:09:26 +0100 Subject: [PATCH] added first part of evaluation realised in Cpp --- CMakeLists.txt | 8 + evaluation.cpp | 23 +++ evaluation.h | 25 +++ evaluation.ui | 35 ++++ mainwindow.cpp | 8 + mainwindow.h | 35 ++-- mainwindow.ui | 11 +- result.cpp | 471 ++++++++++++++++++++++++++++++++++++++++++++ result.h | 44 +++++ result.ui | 35 ++++ resultmodel.cpp | 65 ++++++ resultmodel.h | 33 ++++ windowssettings.cpp | 73 +++---- windowssettings.ui | 64 +++++- 14 files changed, 875 insertions(+), 55 deletions(-) create mode 100644 evaluation.cpp create mode 100644 evaluation.h create mode 100644 evaluation.ui create mode 100644 result.cpp create mode 100644 result.h create mode 100644 result.ui create mode 100644 resultmodel.cpp create mode 100644 resultmodel.h diff --git a/CMakeLists.txt b/CMakeLists.txt index 9ca0047..95c60eb 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -18,6 +18,9 @@ set(CMAKE_AUTOMOC ON) # Create code from a list of Qt designer ui files set(CMAKE_AUTOUIC ON) +# uncomment for ATMega based version (needs usb library) +#add_definitions(-DATMEGA) + # Find the QtWidgets library find_package(Qt5Widgets CONFIG REQUIRED) @@ -38,12 +41,17 @@ set(helloworld_SRCS training.cpp timemodel.cpp qvectorhelper.cpp + resultmodel.cpp + result.cpp + evaluation.cpp mainwindow.ui windowrace.ui windowssettings.ui windowrennliste.ui training.ui + result.ui + evaluation.ui ) # Tell CMake to create the helloworld executable add_executable(Rennbahn ${helloworld_SRCS}) diff --git a/evaluation.cpp b/evaluation.cpp new file mode 100644 index 0000000..0efd254 --- /dev/null +++ b/evaluation.cpp @@ -0,0 +1,23 @@ +#include "evaluation.h" +#include "result.h" +#include "ui_evaluation.h" +#include + +Evaluation::Evaluation(DataBase * db, QWidget * parent) + : QWidget(parent), ui(new Ui::Evaluation) { + ui->setupUi(this); + this->db = db; + QStringListModel * model = new QStringListModel(); + QStringList list; + list << "datum 1" + << "datum 2" + << "datum 3"; + model->setStringList(list); + this->ui->lVEvaluation->setModel(model); + this->interfaceResult = new Result(this->db); + this->interfaceResult->show(); +} + +Evaluation::~Evaluation() { + delete ui; +} diff --git a/evaluation.h b/evaluation.h new file mode 100644 index 0000000..72dd90a --- /dev/null +++ b/evaluation.h @@ -0,0 +1,25 @@ +#ifndef EVALUATION_H +#define EVALUATION_H + +#include "database.h" +#include "result.h" +#include + +namespace Ui { +class Evaluation; +} + +class Evaluation : public QWidget { + Q_OBJECT + + public: + explicit Evaluation(DataBase * db, QWidget * parent = nullptr); + ~Evaluation(); + + private: + Ui::Evaluation * ui; + Result * interfaceResult; + DataBase * db; +}; + +#endif // EVALUATION_H diff --git a/evaluation.ui b/evaluation.ui new file mode 100644 index 0000000..3c0c9bc --- /dev/null +++ b/evaluation.ui @@ -0,0 +1,35 @@ + + + Evaluation + + + + 0 + 0 + 598 + 457 + + + + Form + + + + + + + + + + + + + Schließen + + + + + + + + diff --git a/mainwindow.cpp b/mainwindow.cpp index 0faa1f2..8f96ee3 100644 --- a/mainwindow.cpp +++ b/mainwindow.cpp @@ -30,6 +30,9 @@ MainWindow::MainWindow(QWidget * parent) QObject::connect(this->ui->pBTraining, SIGNAL(clicked()), this, SLOT(WindowTraining())); + QObject::connect(this->ui->pBEvaluation, SIGNAL(clicked()), this, + SLOT(WindowEvaluation())); + QShortcut * startTraining = new QShortcut(QKeySequence("Ctrl+t"), this); QShortcut * startRennen = new QShortcut(QKeySequence("Ctrl+r"), this); @@ -69,3 +72,8 @@ void MainWindow::WindowRennen() { this->interfaceRace->setWindowRennliste(this->interfaceRennliste); this->interfaceRennliste->setWindowRace(this->interfaceRace); } + +void MainWindow::WindowEvaluation() { + this->interfaceEvaluation = new Evaluation(this->db); + this->interfaceEvaluation->show(); +} diff --git a/mainwindow.h b/mainwindow.h index 44060c7..947c393 100644 --- a/mainwindow.h +++ b/mainwindow.h @@ -4,41 +4,40 @@ #include //#include "mainwindow2.h" +#include "evaluation.h" #include "hardwaresetup.h" +#include "training.h" #include "windowrace.h" -#include "windowssettings.h" #include "windowrennliste.h" #include "windowrennliste2.h" -#include "training.h" +#include "windowssettings.h" namespace Ui { class MainWindow; } -class MainWindow : public QMainWindow -{ +class MainWindow : public QMainWindow { Q_OBJECT -public: - explicit MainWindow(QWidget *parent = 0); + public: + explicit MainWindow(QWidget * parent = 0); ~MainWindow(); - - -public slots: + public slots: void NewWindowSettings(); void WindowRennen(); void WindowTraining(); + void WindowEvaluation(); - -private: - Training *interfaceTraining; - void closeEvent(QCloseEvent *event); - DataBase *db; - Ui::MainWindow *ui; - WindowRace *interfaceRace; - WindowsSettings *interfaceSettings; - WindowRennliste *interfaceRennliste; + private: + Training * interfaceTraining; + void closeEvent(QCloseEvent * event); + DataBase * db; + Ui::MainWindow * ui; + WindowRace * interfaceRace; + WindowsSettings * interfaceSettings; + WindowRennliste * interfaceRennliste; + Evaluation * interfaceEvaluation; }; #endif // MAINWINDOW_H diff --git a/mainwindow.ui b/mainwindow.ui index be1d214..45ee4f7 100644 --- a/mainwindow.ui +++ b/mainwindow.ui @@ -16,7 +16,7 @@ - + @@ -38,6 +38,13 @@ + + + + Auswertung + + + @@ -48,7 +55,7 @@ 0 0 512 - 20 + 24 diff --git a/result.cpp b/result.cpp new file mode 100644 index 0000000..f15285f --- /dev/null +++ b/result.cpp @@ -0,0 +1,471 @@ +#include "result.h" +#include "ui_result.h" +#include +#include +#include +#include // setprecision +#include +#include +#include +#include +#include + +using std::cout; +using std::endl; +using std::string; +using std::vector; + +Result::Result(DataBase * db, QWidget * parent) + : QWidget(parent), ui(new Ui::Result) { + ui->setupUi(this); + this->db = db; + + // prepare dummy data + vector header; + // dummy for now + this->rennid = 39; + + // test data + header.push_back("Spalte 1"); + header.push_back("Spalte 2"); + vector> data; + vector subData; + subData.push_back(1); + subData.push_back(2); + data.push_back(subData); + data.push_back(subData); + + this->ui->tWResult->resizeColumnsToContents(); + this->ui->tWResult->horizontalHeader()->setStretchLastSection(true); + this->ui->tWResult->verticalHeader()->setVisible(true); + // this->model->setHeaderData(0, Qt::Horizontal, "Test"); + + // connects + // this->ui->pbClose->clicked() + + std::stringstream statement; + statement << "select date from rennen where id like " + << boost::lexical_cast(rennid); + + try { + QString renndatum = this->db->getData2(statement.str(), 1).at(0).at(0); + this->setWindowTitle(renndatum); + } catch (std::exception & e) { + Q_UNUSED(e); + cout << "Renndatum konnt aus Datenbank nicht gelesen werden" << endl; + } + // clear stringstream + statement.str(std::string()); + statement << "select minimumroundtime from rennen where id like " + << boost::lexical_cast(rennid); + + try { + this->minimumTime = + this->db->getData2(statement.str(), 1).at(0).at(0).toInt(); + + } catch (std::exception & e) { + Q_UNUSED(e); + cout << "Minimalzeit pro Runde konnte aus Datenbank nicht gelesen " + "werden." + << endl; + } + + vector Fahrernamen; + for (size_t i = 0; i < this->getFahrerIds(this->rennid).size(); i++) { + Fahrernamen.push_back( + this->getFahrerName(this->getFahrerIds(this->rennid).at(i))); + } + + vector AutoIds = this->getAutoIds(this->rennid); + + this->ui->tWResult->setRowCount(static_cast(AutoIds.size()) * 2 + 4); + this->ui->tWResult->setColumnCount(static_cast(Fahrernamen.size()) + + 4); + + int row = 0; + int col = 0; + this->ui->tWResult->setItem(row, col, new QTableWidgetItem("Auto")); + row += 0; + col += 1; + + this->ui->tWResult->setItem(row, col, new QTableWidgetItem("Bahn")); + col += 1; + for (string fahrername : Fahrernamen) { + this->ui->tWResult->setItem( + row, col, new QTableWidgetItem(QString::fromStdString(fahrername))); + col += 1; + } + this->ui->tWResult->setItem(row, col, + new QTableWidgetItem("Durchschnitt Auto")); + col += 1; + this->ui->tWResult->setItem( + row, col, new QTableWidgetItem("Durchschnitt Auto gesamt")); + this->ui->tWResult->resizeColumnsToContents(); + row = 1; + col = 1; + + for (size_t i = 0; i <= AutoIds.size(); i++) { + this->ui->tWResult->setItem(row, col, new QTableWidgetItem("Shell")); + row += 1; + this->ui->tWResult->setItem(row, col, new QTableWidgetItem("Dea")); + row += 1; + } + + vector AutoNamen; + for (size_t i = 0; i < AutoIds.size(); i++) { + AutoNamen.push_back(this->getAutoName(AutoIds.at(i))); + } + col = 0; + row = 1; + + for (string autoname : AutoNamen) { + this->ui->tWResult->setItem( + row, col, new QTableWidgetItem(QString::fromStdString(autoname))); + row += 2; + } + this->ui->tWResult->setItem(row, col, + new QTableWidgetItem("Durchschnitt Person")); + row += 2; + this->ui->tWResult->setItem( + row, col, new QTableWidgetItem("Durchschnitt Person ges")); + + row = 1; + col = 2; + vector> zeiten; + vector subZeiten; + + for (int fahrer : this->getFahrerIds(this->rennid)) { + + for (int car : this->getAutoIds(this->rennid)) { + int shellmin = this->getMinimum(fahrer, 1, this->rennid, car, + this->minimumTime); + int deamin = this->getMinimum(fahrer, 2, this->rennid, car, + this->minimumTime); + + subZeiten.push_back(static_cast(shellmin) / 1000); + subZeiten.push_back(static_cast(deamin) / 1000); + + this->ui->tWResult->setItem( + row, col, + new QTableWidgetItem(QString::fromStdString( + this->myRound(static_cast(shellmin) / 1000, 3)))); + row += 1; + this->ui->tWResult->setItem( + row, col, + new QTableWidgetItem(QString::fromStdString( + this->myRound(static_cast(deamin) / 1000, 3)))); + row += 1; + } + zeiten.push_back(subZeiten); + subZeiten.clear(); + + col += 1; + row = 1; + } + + // Durchschnitt Fahrer Shell und Dea + row = static_cast(AutoNamen.size()) * 2 + 1; + col = 2; + for (size_t i = 0; i < Fahrernamen.size(); i++) { + vector shellListe; + vector dealiste; + for (size_t k = 0; k < zeiten.at(i).size(); k++) { + if (k % 2 == 0) { + shellListe.push_back(zeiten.at(i).at(k)); + } + else { + dealiste.push_back(zeiten.at(i).at(k)); + } + } + this->ui->tWResult->setItem( + row, col, + new QTableWidgetItem(QString::fromStdString( + this->myRound(this->meanVal(shellListe), 3)))); + row += 1; + this->ui->tWResult->setItem( + row, col, + new QTableWidgetItem(QString::fromStdString( + this->myRound(this->meanVal(dealiste), 3)))); + row -= 1; + col += 1; + shellListe.clear(); + dealiste.clear(); + } + + // Durchschnitt Auto Shell und Dea + col = static_cast(Fahrernamen.size()) + 2; + row = 1; + vector durschnittAuto; + for (size_t i = 0; i < AutoIds.size() * 2; i++) { //*2 weil 2 Bahnen + + for (size_t k = 0; k < Fahrernamen.size(); k++) { + durschnittAuto.push_back(zeiten.at(k).at(i)); + } + this->ui->tWResult->setItem( + row, col, + new QTableWidgetItem(QString::fromStdString( + this->myRound(this->meanVal(durschnittAuto), 3)))); + row += 1; + durschnittAuto.clear(); + } + + // Durchschnitt Fahrer ges + row = static_cast(AutoIds.size()) * 2 + 3; + col = 2; + for (size_t i = 0; i < Fahrernamen.size(); i++) { + this->ui->tWResult->setItem( + row, col, + new QTableWidgetItem(QString::fromStdString( + this->myRound(this->meanVal(zeiten.at(i)), 3)))); + col += 1; + } + + // Durchschnitt Auto ges + col = static_cast(Fahrernamen.size()) + 3; + row = 1; + for (size_t i = 0; i < AutoIds.size() * 2; i++) { //*2 weil 2 Bahnen + if (i % 2 == 0) { + vector durschnittAuto; + for (size_t k = 0; k < Fahrernamen.size(); k++) { + durschnittAuto.push_back(zeiten.at(k).at(i)); + durschnittAuto.push_back(zeiten.at(k).at(i + 1)); + } + this->ui->tWResult->setItem( + row, col, + new QTableWidgetItem(QString::fromStdString( + this->myRound(this->meanVal(durschnittAuto), 3)))); + row += 2; + durschnittAuto.clear(); + } + } + + // Minimum durchschnitt markieren + row = static_cast(AutoIds.size()) * 2 + 3; + col = 2; + vector avgList; + for (size_t i = 0; i < Fahrernamen.size(); i++) { + QString value = this->ui->tWResult->item(row, col)->text(); + avgList.push_back(value.toFloat()); + + col += 1; + } + row = static_cast(AutoIds.size()) * 2 + 3; + col = 2; + for (size_t i = 0; i < Fahrernamen.size(); i++) { + + if (this->myMin(avgList) == + this->ui->tWResult->item(row, col)->text().toFloat()) { + this->ui->tWResult->item(row, col)->setBackground( + QColor(118, 238, 0)); + } + col += 1; + } + + // minimum abs markieren + // minimum finden + vector temp; + for (size_t i = 0; i < zeiten.size(); i++) { + temp.push_back(this->myMin(zeiten.at(i))); + } + float minimum = this->myMin(temp); + col = 2; + row = 1; + for (size_t i = 0; i < Fahrernamen.size(); i++) { + for (size_t k = 0; k < AutoIds.size() * 2; k++) { + + // self.tWRennergebnis.item(row + k, col + + // i).setBackground(QtGui.QColor(255, 215, 0)) + if (this->ui->tWResult->item(row + k, col + i)->text().toFloat() == + minimum) { + this->ui->tWResult + ->item(row + static_cast(k), col + static_cast(i)) + ->setBackground(QColor(255, 215, 0)); + } + } + } + this->ui->tWResult->resizeColumnsToContents(); + this->ui->tWResult->horizontalHeader()->setStretchLastSection(true); +} + +Result::~Result() { + cout << "result closed" << endl; +} + +template T Result::myMin(vector vec) { + T min; + if (vec.size() > 0) { + min = vec.at(0); + } + else { + return 9999; + } + for (T minItr : vec) { + if (min > minItr) { + min = minItr; + } + } + return min; +} + +template double Result::meanVal(vector vec) { + T sum = std::accumulate(vec.begin(), vec.end(), 0.0); + double mean = static_cast(sum) / vec.size(); + return mean; +} + +string Result::myRound(double x, int d = 0) { + std::stringstream stream; + stream << std::fixed << std::setprecision(d) << x; + return stream.str(); +} +void Result::closeWindow() { + this->close(); +} + +vector Result::getFahrerIds(int rennid) { + std::stringstream statement; + statement << "select id_fahrer from zeiten where id_rennen like " + << boost::lexical_cast(rennid) << " group by id_fahrer"; + + vector vecToRet; + try { + vector> ret = this->db->getData2(statement.str(), 1); + for (size_t i = 0; i < ret.size(); i++) { + string strValue = ret.at(i).at(0).toStdString(); + vecToRet.push_back(boost::lexical_cast(strValue)); + } + return vecToRet; + } catch (std::exception & e) { + Q_UNUSED(e); + cout << "FahrerIds konnten nicht aus Datenbank gelesen " + "werden." + << endl; + } + return vecToRet; +} + +vector Result::getAutoIds(int rennid) { + std::stringstream statement; + statement << "select id_auto from zeiten where id_rennen like " + << boost::lexical_cast(rennid) << " group by id_auto"; + vector> ret = this->db->getData2(statement.str(), 1); + + vector vecToRet; + try { + vector> ret = this->db->getData2(statement.str(), 1); + for (size_t i = 0; i < ret.size(); i++) { + string strValue = ret.at(i).at(0).toStdString(); + vecToRet.push_back(boost::lexical_cast(strValue)); + } + return vecToRet; + } catch (std::exception & e) { + Q_UNUSED(e); + cout << "AutoIds konnten nicht aus Datenbank gelesen werden." << endl; + } + return vecToRet; +} + +int Result::getMinimum(int fahrerId, int bahnId, int rennId, int autoid, + int minTime) { + std::stringstream statement; + statement << "select zeit from Zeiten where id_rennen like " + << boost::lexical_cast(rennId) << " and id_fahrer like " + << boost::lexical_cast(fahrerId) << " and id_auto like " + << boost::lexical_cast(autoid) << " and id_bahn like " + << boost::lexical_cast(bahnId); + + try { + vector> res = this->db->getData2(statement.str(), 1); + // filter impossible values + vector validTimes; + for (size_t i = 0; i < res.size(); i++) { + int timeToCompare = res.at(i).at(0).toInt(); + if (timeToCompare >= minTime) { + validTimes.push_back(timeToCompare); + } + } + if (validTimes.size() > 0) { + std::vector::iterator result = + std::min_element(validTimes.begin(), validTimes.end()); + return *result; + } + else { + return 9999; + } + + } catch (std::exception & e) { + Q_UNUSED(e); + cout << "Minimalzeit konnte aus Datenbank nicht gelesen " + "werden." + << endl; + } + return 9999; +} + +float Result::getMean(int fahrerid, int bahnid, int rennid) { + vector autoids = this->getAutoIds(rennid); + vector avg; + + for (int car : autoids) { + avg.push_back( + this->getMinimum(fahrerid, bahnid, rennid, car, this->minimumTime)); + } + int sum = std::accumulate(avg.begin(), avg.end(), 0); + float floatAvg = 9999; + if (avg.size() > 0) { + floatAvg = static_cast(sum) / static_cast(avg.size()); + cout << "avg:" << floatAvg << endl; + return floatAvg; + } + return 9999; +} +string Result::getFahrerName(int id) { + std::stringstream statement; + statement << "select name from fahrer where id like " + << boost::lexical_cast(id); + vector> result = this->db->getData2(statement.str(), 1); + if (result.size() > 0) { + try { + return result.at(0).at(0).toStdString(); + + } catch (std::exception & e) { + Q_UNUSED(e); + cout << "Fehler beim Lesen vom Fahrernamen." << endl; + return "Leer"; + } + } + return "Leer"; +} + +string Result::getAutoName(int id) { + std::stringstream statement; + statement << "select date from Rennen where id like " + << boost::lexical_cast(this->rennid); + string renndatum; + try { + QString qstrRenndatum = + this->db->getData2(statement.str(), 1).at(0).at(0); + renndatum = qstrRenndatum.toStdString(); + + } catch (std::exception & e) { + Q_UNUSED(e); + cout << "Renndatum konnte nicht gelesen werden." << endl; + return "nix"; + } + + try { + // clear stringstream + statement.str(std::string()); + statement << "select name from Autokonfiguration where " + "id_auto like " + << boost::lexical_cast(id) << " and seit < '" + << renndatum << "' order by seit DESC limit 1"; + + QString name = this->db->getData2(statement.str(), 1).at(0).at(0); + return name.toStdString(); + } catch (std::exception & e) { + Q_UNUSED(e); + } + + return "name"; +} diff --git a/result.h b/result.h new file mode 100644 index 0000000..78bee4f --- /dev/null +++ b/result.h @@ -0,0 +1,44 @@ +#ifndef RESULT_H +#define RESULT_H + +#include "database.h" +#include "resultmodel.h" +#include +#include +#include + +using std::string; +using std::vector; + +namespace Ui { +class Result; +} + +class Result : public QWidget { + Q_OBJECT + + public: + explicit Result(DataBase * db, QWidget * parent = nullptr); + ~Result(); + public slots: + void closeWindow(); + + private: + vector getFahrerIds(int rennid); + vector getAutoIds(int rennid); + int getMinimum(int fahrerId, int bahnId, int rennId, int autoid, + int minZeit); + float getMean(int fahrerid, int bahnid, int rennid); + string getFahrerName(int id); + string getAutoName(int id); + string myRound(double, int); + template double meanVal(vector vec); + template T myMin(vector vec); + Ui::Result * ui; + ResultModel * model; + DataBase * db; + int rennid; + int minimumTime; +}; + +#endif // RESULT_H diff --git a/result.ui b/result.ui new file mode 100644 index 0000000..e649493 --- /dev/null +++ b/result.ui @@ -0,0 +1,35 @@ + + + Result + + + + 0 + 0 + 617 + 494 + + + + Form + + + + + + + + + + + Schließen + + + + + + + + + + diff --git a/resultmodel.cpp b/resultmodel.cpp new file mode 100644 index 0000000..92d12e4 --- /dev/null +++ b/resultmodel.cpp @@ -0,0 +1,65 @@ +#include "resultmodel.h" +#include +#include + +using std::cout; +using std::endl; +using std::string; +using std::vector; + +ResultModel::ResultModel(vector> inputData, vector header, + QObject * parent) + : QAbstractTableModel(parent) { + this->inputData = inputData; + this->headers = header; +} + +QVariant ResultModel::headerData(int section, Qt::Orientation orientation, + int role) const { + if (role == Qt::DisplayRole) { + if (orientation == Qt::Horizontal) { + if (section < static_cast(this->headers.size())) { + + unsigned long index = static_cast(section); + string strToReturn = this->headers.at(index); + QString qStrToReturn = QString::fromStdString(strToReturn); + + return qStrToReturn; + } + else { + return QVariant(); + } + } + } + return QVariant(); +} + +int ResultModel::rowCount(const QModelIndex & parent) const { + Q_UNUSED(parent); + return static_cast(this->inputData.size()); +} + +int ResultModel::columnCount(const QModelIndex & parent) const { + Q_UNUSED(parent); + if (this->inputData.size() > 0) { + return static_cast(this->inputData.at(0).size()); + } + else { + return 0; + } +} + +QVariant ResultModel::data(const QModelIndex & index, int role) const { + try { + if (role == Qt::EditRole || role == Qt::DisplayRole) { + unsigned long row = static_cast(index.row()); + unsigned long col = static_cast(index.column()); + int value = this->inputData.at(row).at(col); + + return QString::fromStdString(boost::lexical_cast(value)); + } + } catch (std::exception & e) { + Q_UNUSED(e); + } + return QVariant(); +} diff --git a/resultmodel.h b/resultmodel.h new file mode 100644 index 0000000..b9a2e22 --- /dev/null +++ b/resultmodel.h @@ -0,0 +1,33 @@ +#ifndef RESULTMODEL_H +#define RESULTMODEL_H + +#include +#include +#include + +using std::vector; +using std::string; + +class ResultModel : public QAbstractTableModel +{ + Q_OBJECT + +public: + explicit ResultModel(vector> inputData, + vector header, QObject *parent = nullptr); + + // Header: + QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const override; + + // Basic functionality: + int rowCount(const QModelIndex &parent = QModelIndex()) const override; + int columnCount(const QModelIndex &parent = QModelIndex()) const override; + + QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override; + +private: + std::vector> inputData; + std::vector headers; +}; + +#endif // RESULTMODEL_H diff --git a/windowssettings.cpp b/windowssettings.cpp index 14f4d01..e879546 100644 --- a/windowssettings.cpp +++ b/windowssettings.cpp @@ -49,44 +49,51 @@ WindowsSettings::WindowsSettings(DataBase * db, QWidget * parent) "from Strecke where id_bahn like 1 order by seit DESC limit 1"; vector> res; - res = db->getData(statement, 6); - ui->lEShellGeraden->setText(res[0][0]); - ui->lEShellKurvenAussen->setText(res[0][1]); - ui->lEShellKurvenInnen->setText(res[0][2]); - ui->lEShellSteilkurveInnen->setText(res[0][3]); - ui->lEShellSteilkurveaussen->setText(res[0][4]); + try { + res = db->getData(statement, 6); + ui->lEShellGeraden->setText(res.at(0).at(0)); + ui->lEShellKurvenAussen->setText(res.at(0).at(1)); + ui->lEShellKurvenInnen->setText(res.at(0).at(2)); + ui->lEShellSteilkurveInnen->setText(res.at(0).at(3)); + ui->lEShellSteilkurveaussen->setText(res.at(0).at(4)); - // Dea prepare - statement = "select geraden, kurven_aussen, " - "kurven_innen, steilkurve_innen, steilkurve_aussen, seit " - "from Strecke where id_bahn like 2 order by seit DESC limit 1"; + // Dea prepare + statement = + "select geraden, kurven_aussen, " + "kurven_innen, steilkurve_innen, steilkurve_aussen, seit " + "from Strecke where id_bahn like 2 order by seit DESC limit 1"; - res = db->getData(statement, 6); - ui->lEDeaGeraden->setText(res[0][0]); - ui->lEDeaKurvenAussen->setText(res[0][1]); - ui->lEDeaKurvenInnen->setText(res[0][2]); - ui->lEDeaSteilkurveInnen->setText(res[0][3]); - ui->lEDeaSteilkurveAussen->setText(res[0][4]); + res = db->getData(statement, 6); + ui->lEDeaGeraden->setText(res.at(0).at(0)); + ui->lEDeaKurvenAussen->setText(res.at(0).at(1)); + ui->lEDeaKurvenInnen->setText(res.at(0).at(2)); + ui->lEDeaSteilkurveInnen->setText(res.at(0).at(3)); + ui->lEDeaSteilkurveAussen->setText(res.at(0).at(4)); - // duration prepare - statement = "select dauer, mindestrundendauer, minsec1, minsec2, minsec3 " - "from renndauer"; - res = db->getData(statement, 5); - this->ui->leRenndauer->setText(res[0][0]); - this->ui->lEMinTimeSec1->setText(res[0][2]); - this->ui->lEMinTimeSec2->setText(res[0][3]); - this->ui->lEMinTimeSec3->setText(res[0][4]); + // duration prepare + statement = + "select dauer, mindestrundendauer, minsec1, minsec2, minsec3 " + "from renndauer"; + res = db->getData(statement, 5); + this->ui->leRenndauer->setText(res.at(0).at(0)); + this->ui->lEMinTimeSec1->setText(res.at(0).at(2)); + this->ui->lEMinTimeSec2->setText(res.at(0).at(3)); + this->ui->lEMinTimeSec3->setText(res.at(0).at(4)); - // changed -> not reasonable - // int minLapTime = res[0][2].toInt() + res[0][3].toInt() + - // res[0][4].toInt(); - this->ui->lEMinRundenzeit->setText(res[0][1]); + // changed -> not reasonable + // int minLapTime = res[0][2].toInt() + res[0][3].toInt() + + // res[0][4].toInt(); + this->ui->lEMinRundenzeit->setText(res.at(0).at(1)); - statement = - "SELECT id, minimumroundtime FROM rennen order by id DESC limit 1"; - res = this->db->getData(statement, 2); - this->rennId = res[0][0].toInt(); - this->ui->lEMinRundenzeitAktRennen->setText(res[0][1]); + statement = + "SELECT id, minimumroundtime FROM rennen order by id DESC limit 1"; + res = this->db->getData(statement, 2); + this->rennId = res[0][0].toInt(); + this->ui->lEMinRundenzeitAktRennen->setText(res.at(0).at(1)); + + } catch (std::exception & e) { + cout << "missing database :(" << endl; + } } void WindowsSettings::repaintMinLapTime() { int minlapTime = 0; diff --git a/windowssettings.ui b/windowssettings.ui index 4a5bf18..6409489 100644 --- a/windowssettings.ui +++ b/windowssettings.ui @@ -17,8 +17,11 @@ + + <html><head/><body><p>Rennliste Erstellen</p></body></html> + - 0 + 3 @@ -381,6 +384,63 @@ + + + Rennliste Erstellen + + + + + + + + + + Fahrer + + + + + + + + + + + + Autos + + + + + + + + + + + + + + + + Abbrechen + + + + + + + Liste Erstellen und Schließen + + + + + + + + + @@ -391,7 +451,7 @@ 0 0 800 - 22 + 24