test_sdk/gui/config/gtl_gui_config_widget_player.cpp

#include "gtl_gui_config_widget_player.h"
#include "ui_gtl_gui_config_widget_player.h"

#include "gui/gtl_gui_chart_widget.h"
#include "gui/player/gtl_gui_player_resampling_dialog.h"

#include <QFileDialog>
#include <QSettings>

namespace gtl
{
    namespace gui
    {
        namespace config
        {
            widget_player::widget_player(QWidget *parent)
                : QWidget(parent)
                , ui(new Ui::config_widget_player)
                , _files(this)
                , _selection(&_files)
                , _player(NULL)

            {
                ui->setupUi(this);

                ui->play->setEnabled(false);

                QHBoxLayout* layout = new QHBoxLayout(ui->progress);
                layout->setContentsMargins(0, 0, 0, 0);
                layout->addWidget(ui->time);
                ui->progress->setLayout(layout);


                _files.setNameFilterDisables(false);
                _files.setNameFilters(QStringList() << "*.gtr" << "*.wav");
                _files.setFilter(QDir::Files | QDir::AllDirs | QDir::NoDotAndDotDot);
                ui->files->setModel(&_files);
                ui->files->setSelectionModel(&_selection);

                connect(&_selection, &QItemSelectionModel::currentChanged, this, &widget_player::selection_changed);

                ui->files->setRootIndex(_files.setRootPath(""));
                ui->files->setSortingEnabled(true);
                ui->files->header()->setSectionsClickable(true);
                ui->files->header()->setSortIndicatorShown(true);
                ui->files->header()->setSortIndicator(0, Qt::SortOrder::AscendingOrder);

                connect(ui->play, &QAbstractButton::clicked, this, &widget_player::play);
                connect(ui->cyclic, &QAbstractButton::clicked, this, &widget_player::set_cyclic);

                _chart = new player::chart(this);
                chart_widget *chart_widget_ = new chart_widget(_chart, this);
                ui->verticalLayout->insertWidget(0, chart_widget_);

                connect(&_timer, &QTimer::timeout, this, &widget_player::update_state);

                _timer.start(100);

                connect(ui->save_as_button, &QAbstractButton::clicked, this, &widget_player::save_as);

                ui->path->setClearButtonEnabled(true);
                ui->path->setPlaceholderText("Root dir ...");

                connect(ui->select_path_button, &QAbstractButton::clicked, this, &widget_player::select_path);
                connect(ui->path, &QLineEdit::textChanged, this, &widget_player::set_path);

                QSettings settings;
                ui->splitter->restoreState(settings.value("player/splitter").toByteArray());
                QList<QVariant> columns_width = settings.value("player/view/columns").toList();
                for(int i = 0; i < qMin(columns_width.count(), _files.columnCount()); i++)
                    ui->files->setColumnWidth(i, columns_width[i].toInt());

            }

            widget_player::~widget_player()
            {
                QSettings settings;

                settings.setValue("player/splitter", QVariant(ui->splitter->saveState()));
                QList<QVariant> columns_width;
                for(int i = 0; i < _files.columnCount(); i++)
                    columns_width.push_back(ui->files->columnWidth(i));
                settings.setValue("player/view/columns", QVariant(columns_width));


                delete ui;
            }

            void widget_player::set_player(gtl::device *node)
            {

                if(_player)
                {
                    _to_save = false;
                    save_player_state();
                    disconnect(_player, NULL, this, NULL);
                }

                _to_save = true;

                _player = node;

                ui->cyclic->setChecked(_player->get_parameter(2).toBool());

                connect(_player, &gtl::device::stopped, this, &widget_player::player_stopped);

                ui->files->clearSelection();

                QModelIndex index;
                if(_player)
                    index = _files.index(node->id());

                _selection.setCurrentIndex(index, QItemSelectionModel::Select);

                ui->path->setText(QSettings().value("player/root_path/" + get_player_uuid()).toString());

            }

            void widget_player::save_player_state()
            {
                if(_player)
                {
                    QDomDocument state_doc;
                    QDomElement player_element = state_doc.createElement("root");
                    state_doc.appendChild(player_element);
                    _player->save_childs(player_element);
                    QFile file(_player->id() + ".conf");
                    if(file.open(QFile::WriteOnly))
                    {
                        file.write(state_doc.toByteArray());
                        file.close();
                    }
                }
            }

            QString widget_player::get_player_uuid() const
            {
                if(_player == nullptr)
                    return "";

                return _player->get_parameter(7).toString();
            }

            void widget_player::selection_changed(const QModelIndex &current, const QModelIndex &previous)
            {
                QString path = _files.filePath(current);

                if(_player)
                {
                    if(_to_save)
                        save_player_state();


                    _player->start(path, -1);
                    qreal total_time = _player->get_parameter(0).toDouble();

                    ui->play->setEnabled(total_time != 0);
                    ui->cyclic->setEnabled(total_time != 0);
                    ui->progress->setMaximum(qRound(total_time*1000));

                    QFile file(path + ".conf");
                    if(file.open(QFile::ReadOnly))
                    {
                        QDomDocument state_doc;
                        state_doc.setContent(&file);
                        file.close();

                        _player->load_childs(state_doc.firstChildElement("root"));
                    }
                }



                _chart->set_file(path);

                ui->play->setChecked(false);
            }

            void widget_player::play(bool value)
            {
                if(value)
                {
                    _chart->save_ranges();
                    _player->start(_files.filePath(ui->files->currentIndex()), 0);
                    ui->progress->setMaximum(qRound(_player->get_parameter(0).toDouble()*1000));
                }
                else
                    _player->stop();
            }

            void widget_player::set_cyclic(bool value)
            {
                _player->set_parameter(2, value);
            }

            void widget_player::save_as()
            {
                gtl::gui::player::resampling_dialog* save_as_dialog = new gtl::gui::player::resampling_dialog(_player->id(), this);

                save_as_dialog->exec();

                delete save_as_dialog;
            }

            void widget_player::player_stopped()
            {
                qDebug() << "player stopped";
                ui->play->setChecked(false);
            }

            void widget_player::update_state()
            {
                if(_player)
                {
                    qreal time = _player->get_parameter(1).toDouble();
                    ui->time->setText(QString::number(time, 'f', 3) + "/" + QString::number(ui->progress->maximum()/1000.0, 'f', 3));
                    ui->progress->setValue(qRound(time*1000));
                    _chart->set_position(_player->get_parameter(6).toDouble());
                }
                else
                {
                    ui->time->setText("");
                }
            }

            void widget_player::select_path()
            {
                QString path = QFileDialog::getExistingDirectory(this, tr("Select root path"), ui->path->text());
                if(path.isEmpty())
                    return;

                ui->path->setText(path);
            }

            void widget_player::set_path(QString path)
            {
                QString current_path = _files.filePath(ui->files->currentIndex()).toLower();
                ui->files->setRootIndex(_files.index(path));
                QSettings().setValue("player/root_path/" + get_player_uuid(), path);
                if(!current_path.contains(path.toLower()))
                {
                    ui->files->setCurrentIndex(ui->files->rootIndex());
                }
            }
        }
    }
}