add: files

Author: TimurIsk

src/Ex1/iplot.h

@@ -0,0 +1,17 @@
+#ifndef IPLOT_H
+#define IPLOT_H
+
+#include <QWidget>
+
+class IPlotRandomWidget : public QWidget
+{
+public:
+    IPlotRandomWidget(QWidget *parent)
+        :QWidget(parent){}
+
+    //virtual ~IPlotRandomWidget(){}
+    virtual void addPoint(double y) = 0;
+    virtual void clear() = 0 ;
+};
+
+#endif // IPLOT_H

src/Ex1/plotrandomwidget.cpp

@@ -0,0 +1,51 @@
+#include "plotrandomwidget.h"
+
+PlotRandomWidget::PlotRandomWidget(QWidget* parent)
+    :IPlotRandomWidget (parent)
+{
+    QChartView *chartView = new QChartView(&_chart);
+    _chart.addSeries(&_series);
+
+    QValueAxis *axisX = new QValueAxis;
+    axisX->setRange(0, _xDefaultAxsisMaximum);
+    QValueAxis *axisY = new QValueAxis;
+    axisY->setRange(0, 4);
+    //_chart.addAxis(axisX, Qt::AlignBottom);
+    //_chart.addAxis(axisY, Qt::AlignLeft);
+    _chart.setAxisX(axisX, &_series);
+    _chart.setAxisY(axisY, &_series);
+    _chart.legend()->hide();
+
+    QHBoxLayout *mainLayout = new QHBoxLayout(parent);
+    mainLayout->addWidget(chartView);
+}
+
+void PlotRandomWidget::addPoint(double y)
+{
+    _series.append(_xCurrent, y);
+    //если текущее значение по оси X стало больше, чем Xscale перерисуем шкалу
+    if(_xCurrent >= _xCurrentAxsisMaximum)
+    {
+        _xCurrentAxsisMaximum = _xCurrent + _xDefaultAxsisMaximum;
+        rescaleAxsisX(_xCurrentAxsisMaximum);
+    }
+
+    const double xStep = 1;
+    _xCurrent +=xStep;
+}
+
+void PlotRandomWidget::clear()
+{
+    _series.clear();
+    _xCurrent = 0;
+
+
+    _xCurrentAxsisMaximum = _xDefaultAxsisMaximum;
+    rescaleAxsisX(_xCurrentAxsisMaximum);
+
+}
+
+void PlotRandomWidget::rescaleAxsisX(double value)
+{
+     _chart.axisX()->setRange(0., value);
+}

src/Ex1/plotrandomwidget.h

@@ -0,0 +1,27 @@
+#ifndef PLOTRANDOMWIDGET_H
+#define PLOTRANDOMWIDGET_H
+
+#include "iplot.h"
+#include <QtCharts>
+#include <QWidget>
+
+
+class PlotRandomWidget: public IPlotRandomWidget
+{
+public:
+    PlotRandomWidget(QWidget* parent);
+    void addPoint(double y) override;
+    void clear() override;
+
+private:
+    void rescaleAxsisX(double value);
+
+    QtCharts::QLineSeries _series;
+    QtCharts::QChart _chart;
+
+    double _xCurrent = 0;
+    const double _xDefaultAxsisMaximum = 100;
+    double _xCurrentAxsisMaximum = _xDefaultAxsisMaximum;
+};
+
+#endif // PLOTRANDOMWIDGET_H

src/Ex1/plotrandomworker.cpp

@@ -0,0 +1,32 @@
+#include "plotrandomworker.h"
+#include <QThread>
+#include <QRandomGenerator>
+#include "random"
+
+PlotRandomWorker::PlotRandomWorker(QPointer<IPlotRandomWidget> plot)
+    :_plot(plot)
+{
+
+}
+
+void PlotRandomWorker::run()
+{
+    forever
+    {
+        if (QThread::currentThread()->isInterruptionRequested())
+            return;
+
+        if(!_plot.isNull())
+            _plot->addPoint(generateRandom());
+
+        QThread::msleep(100);
+    }
+}
+
+
+double PlotRandomWorker::generateRandom()
+{
+
+    std::uniform_real_distribution<> dist(1, 2.5);
+    return dist(*QRandomGenerator::global());
+}

src/Ex1/plotrandomworker.h

@@ -0,0 +1,21 @@
+#ifndef PLOTRANDOMWORKER_H
+#define PLOTRANDOMWORKER_H
+
+#include <QThread>
+#include <QPointer>
+#include "iplot.h"
+
+class PlotRandomWorker : public QThread
+{
+     Q_OBJECT
+
+public:
+    PlotRandomWorker(QPointer<IPlotRandomWidget> plot);
+    void run() override;
+
+private:
+    static double generateRandom();
+    QPointer<IPlotRandomWidget> _plot;
+};
+
+#endif // PLOTRANDOMWORKER_H

src/Ex1/threadexercises.cpp

@@ -0,0 +1,51 @@
+#include "threadexercises.h"
+#include <QDebug>
+#include "plotrandomwidget.h"
+#include "plotrandomworker.h"
+
+ThreadExercises::ThreadExercises(ThreadExercisesWidgets widgets, QObject *parent)
+    :QObject(parent)
+{
+    plot =new PlotRandomWidget(widgets.groupBox);
+
+    connect(widgets.playButton, &QPushButton::clicked, this, &ThreadExercises::play);
+    connect(widgets.pauseButton, &QPushButton::clicked, this, &ThreadExercises::pause);
+    connect(widgets.stopButton, &QPushButton::clicked, this, &ThreadExercises::stop);
+
+}
+
+ThreadExercises::~ThreadExercises()
+{
+    if(!worker.isNull())
+    {
+        worker->requestInterruption();
+        worker->wait();
+    }
+    qDebug()<<"ThreadExercises will be deleted";
+}
+
+void ThreadExercises::play()
+{
+    if(!worker.isNull())
+        return;
+
+    worker = new PlotRandomWorker(plot);
+    connect(worker, &PlotRandomWorker::finished, worker, &QObject::deleteLater);
+    worker->start();
+}
+
+void ThreadExercises::pause()
+{
+    if(worker.isNull())
+        return;
+
+    worker->requestInterruption();
+}
+
+void ThreadExercises::stop()
+{
+    if(!worker.isNull())
+        pause();
+
+    plot->clear();
+}

src/Ex1/threadexercises.h

@@ -0,0 +1,38 @@
+#ifndef THREADEXERCISES_H
+#define THREADEXERCISES_H
+
+#include <QObject>
+#include <QPushButton>
+#include <QGroupBox>
+#include <QPointer>
+#include "iplot.h"
+#include "plotrandomworker.h"
+
+
+struct ThreadExercisesWidgets
+{
+    QPushButton* playButton = nullptr;
+    QPushButton* pauseButton = nullptr;
+    QPushButton* stopButton = nullptr;
+    QGroupBox* groupBox = nullptr;
+};
+
+class ThreadExercises: public QObject
+{
+    Q_OBJECT
+
+public:
+    ThreadExercises(ThreadExercisesWidgets widgets, QObject *parent = nullptr);
+    ~ThreadExercises();
+
+private:
+    QPointer<IPlotRandomWidget> plot = nullptr;
+    QPointer<PlotRandomWorker> worker = nullptr;
+
+private slots:
+    void play();
+    void pause();
+    void stop();
+};
+
+#endif // THREADEXERCISES_H

src/Ex2/comboboxdelegate.cpp

@@ -0,0 +1,36 @@
+#include "comboboxdelegate.h"
+#include "customcell.h"
+#include <QComboBox>
+
+ComboBoxDelegate::ComboBoxDelegate(const QList<CustomCell*>& cells, QObject *parent)
+    :QStyledItemDelegate(parent),
+     _cells(cells)
+{
+
+}
+
+QWidget *ComboBoxDelegate::createEditor(QWidget *parent, const QStyleOptionViewItem &option, const QModelIndex &index) const
+{
+    QComboBox* combobox = new QComboBox(parent);
+    combobox->setEditable(false);
+    return combobox;
+}
+
+void ComboBoxDelegate::setEditorData(QWidget *editor, const QModelIndex &index) const
+{
+    QComboBox* combobox = static_cast<QComboBox* >(editor);
+    for(const auto& cell: _cells)
+        combobox->addItem(cell->getName());
+
+}
+
+void ComboBoxDelegate::setModelData(QWidget *editor, QAbstractItemModel *model, const QModelIndex &index) const
+{
+    QComboBox* combobox = static_cast<QComboBox* >(editor);
+    model->setData(index, combobox->currentText());
+}
+
+void ComboBoxDelegate::updateEditorGeometry(QWidget *editor, const QStyleOptionViewItem &option, const QModelIndex &index) const
+{
+     editor->setGeometry(option.rect);
+}

src/Ex2/comboboxdelegate.h

@@ -0,0 +1,23 @@
+#ifndef COMBOBOXDELEGATE_H
+#define COMBOBOXDELEGATE_H
+
+#include <QObject>
+#include <QStyledItemDelegate>
+
+class CustomCell;
+
+class ComboBoxDelegate: public QStyledItemDelegate
+{
+public:
+    ComboBoxDelegate(const QList<CustomCell*>& cells, QObject* parent = nullptr);
+
+    QWidget *createEditor(QWidget *parent, const QStyleOptionViewItem &option, const QModelIndex &index) const override;
+    void setEditorData(QWidget *editor, const QModelIndex &index) const override;
+    void setModelData(QWidget *editor, QAbstractItemModel *model, const QModelIndex &index) const override;
+    void updateEditorGeometry(QWidget *editor, const QStyleOptionViewItem &option, const QModelIndex &index) const override;
+
+private:
+    QList<CustomCell*> _cells;
+};
+
+#endif // COMBOBOXDELEGATE_H

src/Ex2/customcell.cpp

@@ -0,0 +1,80 @@
+#include "customcell.h"
+
+CustomCell::CustomCell(const QUuid& id,const QString& name, QObject *parent)
+    :QObject(parent),
+      _id(id),
+      _name(name)
+{
+
+}
+
+QUuid CustomCell::getId() const
+{
+    return _id;
+}
+
+QString CustomCell::getName() const
+{
+    return _name;
+}
+
+void CustomCell::setId(const QUuid& id)
+{
+    _id = id;
+}
+
+void CustomCell::setName(const QString& name)
+{
+    _name = name;
+}
+
+
+CustomRow::CustomRow(const QUuid &id, CustomCell *xCell, CustomCell *yCell, CustomCell *zCell, QObject *parent)
+    :QObject(parent),
+     _id(id),
+     _xCell(xCell),
+     _yCell(yCell),
+     _zCell(zCell)
+{
+
+}
+
+QUuid CustomRow::getId() const
+{
+    return _id;
+}
+
+CustomCell *CustomRow::getCellX()
+{
+    return _xCell;
+}
+
+CustomCell *CustomRow::getCellY()
+{
+    return _yCell;
+}
+
+CustomCell *CustomRow::getCellZ()
+{
+    return _zCell;
+}
+
+void CustomRow::setId(const QUuid &id)
+{
+    _id = id;
+}
+
+void CustomRow::setCellX(CustomCell *xCell)
+{
+    _xCell = xCell;
+}
+
+void CustomRow::setCellY(CustomCell *yCell)
+{
+    _yCell = yCell;
+}
+
+void CustomRow::setCellZ(CustomCell *zCell)
+{
+    _zCell = zCell;
+}