Деки на C++ с использованием Qt


Я работаю на программное обеспечение деки для настольные игры аудио-погружение в C++ с использованием Qt. Программа состоит из 2 вкладок, которые предоставляет игра мастер набор отдельных звуков или сцены должны быть оплачена на данный момент в игре.

Игра мастер может выбрать аудио для воспроизведения и аудио, встроенные в файл ресурсов с Qt. Кроме того, принимая почти 1,5 ГБ оперативной памяти (что есть неправильно), в общем программа работает нормально, дело в том что за последние 2 недели я чувствую, что я не с помощью C++ и Qt, как они должны. Я просто притворяется.

Я пытаюсь придумать с C++ 11, 14 и 17, а также "Qt в сторону" стандартов код (поэтому я вынужден создать так много указателей: компилятор жалуется, когда я не зделаешь...) но это не так просто, как хотелось бы, чтобы это было. Я хочу, чтобы мой код, чтобы быть более элегантным, более выразительным, более подробного и эффективным при работе.

Если кто может потратить время и указать, где мое слабое место в целом и каким должен быть мой мыслительный процесс при написании кода, который будет большим подспорьем. Если это не правильное место, чтобы задать для проверки кода, как это, я уверен, что вы сможете указать мне на правильное направление.

.про

QT       += core gui multimedia

greaterThan(QT_MAJOR_VERSION, 4): QT += widgets

TARGET = SoundBoard
TEMPLATE = app

CONFIG += resources_big

RC_ICONS = Codex_book.ico

DEFINES += QT_DEPRECATED_WARNINGS

SOURCES += \
        main.cpp \
        widget.cpp \
    customlistwidget.cpp \
    customlistwidgetitem.cpp \
    customtabwidget.cpp \
    player.cpp \
    scene.cpp

HEADERS += \
        widget.h \
    customlistwidget.h \
    customlistwidgetitem.h \
    customtabwidget.h \
    player.h \
    scene.h

FORMS += \
        widget.ui \
    player.ui \
    scene.ui \
    player.ui

RESOURCES += \
    src.qrc

Заголовки:

customlistwidget.ч

#ifndef CUSTOMLISTWIDGET_H
#define CUSTOMLISTWIDGET_H

#include <QListWidget>
#include <QVector>

#include "customlistwidgetitem.h"

class CustomListWidget : public QListWidget{
    Q_OBJECT
public:
    CustomListWidget(QWidget *parent = nullptr);

    void addCustomItem(CustomListWidgetItem*);

public slots:
    void setItemPressed(QListWidgetItem*);
    void emitCustomItem(QListWidgetItem*);

signals:
    void customItem(CustomListWidgetItem*);

protected:
    void startDrag(Qt::DropActions supportedActions);

private:
    QVector<CustomListWidgetItem*> list;
    QListWidgetItem *itemToBeSet;
};

#endif // CUSTOMLISTWIDGET_H

customlistwidgetitem.ч

#ifndef CUSTOMLISTWIDGETITEM_H
#define CUSTOMLISTWIDGETITEM_H

#include <QListWidgetItem>
#include <QFileInfo>

class CustomListWidgetItem : public QListWidgetItem{
public:
    CustomListWidgetItem(QFileInfo, QIcon, QListWidget *parent = nullptr);
    ~CustomListWidgetItem();

    QFileInfo getFileInfo();

private:
    QFileInfo fileInfo;
};

#endif // CUSTOMLISTWIDGETITEM_H

customtabwidget.ч

#ifndef CUSTOMTABWIDGET_H
#define CUSTOMTABWIDGET_H

#include <QTabWidget>
#include <QWidget>

#include <QHBoxLayout>
#include <QVBoxLayout>
#include <QGridLayout>

#include <QScrollArea>

#include <QPushButton>

#include <QVector>

#include <QDragEnterEvent>
#include <QDragLeaveEvent>
#include <QMoveEvent>
#include <QDropEvent>

#include "scene.h"
#include "player.h"
#include "customlistwidgetitem.h"

class CustomTabWidget : public QTabWidget{
    Q_OBJECT

public:
    CustomTabWidget(QWidget *parent = nullptr);

    void setSoundLayout();
    void setSceneLayout();

protected:
    void dragEnterEvent(QDragEnterEvent *event);
    void dragLeaveEvent(QDragLeaveEvent *event);
    void dragMoveEvent(QDragMoveEvent *event);
    void dropEvent(QDropEvent*);

public slots:
    void addScene(bool);
    void stopAllScenes(bool);
    void removeScene(Scene*);
    void removeAllScenes(bool);


    void addSound(bool);
    void stopAllSounds(bool);
    void removeSound(Player*);
    void removeAllSounds(bool);

    void addDefaultSound(CustomListWidgetItem*);

private:
    void appendSound(QStringList &, int);
    void appendScene(QString);

    QVector<Scene*> scenes;
    QVector<Player*> players;

    QGridLayout *soundGrid;
    QGridLayout *sceneGrid;

    QWidget *soundPanel;
    QWidget *scenePanel;

    QHBoxLayout *soundPanelLayout;
    QHBoxLayout *scenePanelLayout;

    QHBoxLayout *hSoundLayout;
    QVBoxLayout *vSoundLayout;

    QHBoxLayout *hSceneLayout;
    QVBoxLayout *vSceneLayout;

    int soundCol;
    int soundRow;

    int sceneCol;
    int sceneRow;

    QPushButton *addSoundButton;
    QPushButton *removeAllSoundsButton;
    QPushButton *stopAllSoundsButton;

    QPushButton *addSceneButton;
    QPushButton *removeAllScenesButton;
    QPushButton *stopAllScenesButton;

    QScrollArea *scrollSound;
    QScrollArea *scrollScene;

    QWidget *soundScroll;
    QWidget *sceneScroll;
};

#endif // CUSTOMTABWIDGET_H

плеер.ч

#ifndef PLAYER_H
#define PLAYER_H

#include <QWidget>
#include <QMediaPlayer>
#include <QMediaPlaylist>
#include <QCheckBox>
#include <QPushButton>

namespace Ui {
    class Player;
}

class Player : public QWidget{
    Q_OBJECT

public:
    explicit Player(QWidget *parent = 0);
    ~Player();

    void setTitle(QString);
    void setIconState(QString);

    QMediaPlaylist *getPlaylist();    
    QMediaPlayer *getPlayer();
    QCheckBox* getLoopButton();
    QPushButton* getPlayStopButton();
    float getSliderValue();

public slots:
    void playStopButton(bool);
    void soundEnd(QMediaPlayer::State);
    void loop(bool);
    void emitThisPlayer(bool);

signals:
    void thisPlayer(Player*);
    void stateChanged(QMediaPlayer::State);
    void sliderValueChanged(int);

private:
    Ui::Player *ui;

    QMediaPlayer *mPlayer;
    QMediaPlaylist *mPlaylist;

    float volume;
};

#endif // PLAYER_H

сцены.ч

#ifndef SCENE_H
#define SCENE_H

#include <QWidget>
#include <QPushButton>
#include <QGridLayout>

#include <QDragEnterEvent>
#include <QDragLeaveEvent>
#include <QMoveEvent>
#include <QDropEvent>

#include "player.h"
#include "customlistwidget.h"

namespace Ui {
    class Scene;
}

class Scene;

class  Editor : public QWidget{
    Q_OBJECT

public:
    explicit Editor(Scene *parent = 0);
     ~Editor();

    void addDefaultSound(CustomListWidgetItem*);

protected:
    void dragEnterEvent(QDragEnterEvent *event);
    void dragLeaveEvent(QDragLeaveEvent *event);
    void dragMoveEvent(QDragMoveEvent *event);
    void dropEvent(QDropEvent*);

    void resizeEvent(QResizeEvent *evt);
    void closeEvent(QCloseEvent *event);

signals:
    void hidden(bool);

private:
    Scene *scene;
};

class Scene : public QWidget{
    Q_OBJECT

public:
    explicit Scene(QWidget *parent = 0);
    ~Scene();        

    void appendSound(QStringList, int);

    int getCol();
    void setCol(int);

    int getRow();
    void setRow(int);

    void setTitle(QString);
    QPushButton *getPlayStopButton();

public slots:
    void emitThisScene(bool);
    void showEditor(bool);
    void playStop(bool);
    void loopScene(bool);
    void playerStateChanged(QMediaPlayer::State);
    void soundEnd();
    void masterVolume(int);
    void setMasterVolume(int);

    void addSound(bool);
    void stopAllSounds(bool);
    void removeSound(Player *player);
    void removeAllSounds(bool);

signals:
    void thisScene(Scene*);

private:
    void setEditorLayout();    

    Ui::Scene *ui;
    QVector<Player*> players;

    Editor *editor;

    QPushButton *add;
    QPushButton *stopAll;
    QPushButton *removeAll;
    QPushButton *editorPS;

    QGridLayout *grid;
    QWidget *panel;

    QHBoxLayout *h;
    QVBoxLayout *v;

    QHBoxLayout *panelLayout;

    int col;
    int row;

    int stoppedCounter;
};

#endif // SCENE_H

виджет.ч

#ifndef WIDGET_H
#define WIDGET_H

#include <QWidget>

namespace Ui {
    class Widget;
}

class Widget : public QWidget{
    Q_OBJECT

public:
    explicit Widget(QWidget *parent = 0);
    ~Widget();

private:
    Ui::Widget *ui;
};

#endif // WIDGET_H

Источники:

customlistwidget.cpp

#include "customlistwidget.h"

#include <QMouseEvent>

#include <QMimeData>
#include <QDrag>

#include <QList>
#include <QUrl>

#include <QByteArray>

#include <QDebug>

CustomListWidget::CustomListWidget(QWidget *parent) : QListWidget(parent){

    setMouseTracking(true);

    setDragEnabled(true);
    setDragDropMode(QListWidget::DragOnly);

    connect(this, &CustomListWidget::itemEntered, this, &CustomListWidget::setItemPressed);
    connect(this, &CustomListWidget::itemClicked, this, &CustomListWidget::setItemPressed);
    connect(this, &CustomListWidget::itemDoubleClicked, this, &CustomListWidget::emitCustomItem);
    itemToBeSet = nullptr;

    setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Minimum);
}

void CustomListWidget::addCustomItem(CustomListWidgetItem *customItem){
    list.push_back(customItem);
    qDebug() << "Custom Item Added: " << list.size() << endl;
    QListWidgetItem *item = new QListWidgetItem(this);
    item->setText(customItem->text());
    item->setIcon(customItem->icon());
}

void CustomListWidget::setItemPressed(QListWidgetItem *item){
    itemToBeSet = item;
    qDebug() << "set" << endl;
}

void CustomListWidget::emitCustomItem(QListWidgetItem *item){
    for(int i = 0; i < list.size(); ++i){
        if(item->text() == list.at(i)->getFileInfo().baseName()){
            emit customItem(list.at(i));
        }
    }
}

void CustomListWidget::startDrag(Qt::DropActions supportedActions){
    (void)supportedActions;
    QList<QUrl> url;

    QByteArray ba;

    QDrag *drag = new QDrag(this);
    QMimeData *mimeData = new QMimeData;

    if(itemToBeSet){
        for(int i = 0; i < list.size(); ++i){
            if(itemToBeSet->text() == list.at(i)->text()){
                ba.append(list.at(i)->getFileInfo().absoluteFilePath());
            }
        }
    }

    mimeData->setData("FileInfo", ba);

    drag->setMimeData(mimeData);
    drag->exec();
}

customlistwidgetitem.cpp

#include "customlistwidgetitem.h"

#include <QDebug>

CustomListWidgetItem::CustomListWidgetItem(QFileInfo infoFile, QIcon icon, QListWidget *parent)
    : QListWidgetItem(parent){

    fileInfo = infoFile;

    setText(infoFile.baseName());
    setIcon(icon);
}

CustomListWidgetItem::~CustomListWidgetItem(){
    delete &fileInfo;
}

QFileInfo CustomListWidgetItem::getFileInfo(){
    return fileInfo;
}

customtabwidget.cpp

#include "customtabwidget.h"

#include "customlistwidget.h"

#include <QMimeData>

#include <QFileDialog>
#include <QInputDialog>

CustomTabWidget::CustomTabWidget(QWidget *parent) : QTabWidget(parent){

    scrollSound = new QScrollArea(this);
    soundScroll = new QWidget(scrollSound);
    soundScroll->setStyleSheet("background-image: url(:/images/Listen.png");

    scrollSound->setWidgetResizable(true);
    soundScroll->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding);
    setSoundLayout();

    scrollScene = new QScrollArea(this);
    sceneScroll = new QWidget(scrollScene);
    scrollScene->setWidgetResizable(true);
    sceneScroll->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding);
    setSceneLayout();

    scrollSound->setWidget(soundScroll);
    scrollScene->setWidget(sceneScroll);

    addTab(scrollSound, "Sounds");
    addTab(scrollScene, "Ambience");

    setAcceptDrops(true);

    connect(addSoundButton, &QPushButton::clicked, this, &CustomTabWidget::addSound);
    connect(stopAllSoundsButton, &QPushButton::clicked, this, &CustomTabWidget::stopAllSounds);
    connect(removeAllSoundsButton, &QPushButton::clicked, this, &CustomTabWidget::removeAllSounds);

    connect(addSceneButton, &QPushButton::clicked, this, &CustomTabWidget::addScene);
    connect(stopAllScenesButton, &QPushButton::clicked, this, &CustomTabWidget::stopAllScenes);
    connect(removeAllScenesButton, &QPushButton::clicked, this, &CustomTabWidget::removeAllScenes);
}

void CustomTabWidget::setSoundLayout(){
    CustomListWidget *listWidget = new CustomListWidget;

    QVector<QString> paths = {":/Sounds/Age of Sail/", ":/Sounds/Combat (Future)/", ":/Sounds/Combat (Medieval)/",
                             ":/Sounds/Dark Forest/", ":/Sounds/Death House", ":/Sounds/Deep Six", ":/Sounds/Dungeon",
                             ":/Sounds/Future City", ":/Sounds/House on the Hill", ":/Sounds/Jungle Planet",
                             ":/Sounds/Monster Pack", ":/Sounds/Olde Towne", ":/Sounds/Starship", ":/Sounds/True West",
                             ":Sounds/Wasteland"};

    for(int i = 0; i < paths.size(); ++i){
        QDir dir(paths.at(i));
        QFileInfoList fileList = dir.entryInfoList(QDir::Files, QDir::Name);
        for(int j = 0; j < fileList.size(); ++j){
            listWidget->addCustomItem(new CustomListWidgetItem(fileList.at(j), QIcon(":/icons/music.png")));
            qDebug() << fileList.at(j).absoluteFilePath();
        }
    }

    connect(listWidget, &CustomListWidget::customItem, this, &CustomTabWidget::addDefaultSound);

    soundCol = 0;
    soundRow = 0;

    addSoundButton = new QPushButton;
    stopAllSoundsButton = new QPushButton;
    removeAllSoundsButton = new QPushButton;

    addSoundButton->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
    addSoundButton->setStyleSheet("background-color: transparent;");
    addSoundButton->setIcon(QIcon(QPixmap(":icons/add.png")));
    addSoundButton->setIconSize(QSize(38, 38));
    addSoundButton->setToolTip("Add Mp3 Track");
    addSoundButton->setToolTipDuration(1000);

    stopAllSoundsButton->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
    stopAllSoundsButton->setStyleSheet("background-color: transparent;");
    stopAllSoundsButton->setIcon(QIcon(QPixmap(":icons/stopAll.png")));
    stopAllSoundsButton->setIconSize(QSize(38, 38));
    stopAllSoundsButton->setToolTip("Stop All Tracks");
    stopAllSoundsButton->setToolTipDuration(1000);

    removeAllSoundsButton->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
    removeAllSoundsButton->setStyleSheet("background-color: transparent;");
    removeAllSoundsButton->setIcon(QIcon(QPixmap(":icons/closeAll.png")));
    removeAllSoundsButton->setIconSize(QSize(38, 38));
    removeAllSoundsButton->setToolTip("Remove All Tracks");
    removeAllSoundsButton->setToolTipDuration(1000);

    soundPanel = new QWidget;
    soundPanelLayout = new QHBoxLayout;

    soundGrid = new QGridLayout;

    hSoundLayout = new QHBoxLayout;
    vSoundLayout = new QVBoxLayout;

    soundPanelLayout->addWidget(addSoundButton);
    soundPanelLayout->addWidget(stopAllSoundsButton);
    soundPanelLayout->addWidget(removeAllSoundsButton);
    soundPanelLayout->addStretch(1);

    soundPanel->setLayout(soundPanelLayout);

    hSoundLayout->addLayout(soundGrid);
    hSoundLayout->addStretch(1);

    vSoundLayout->addWidget(soundPanel);
    vSoundLayout->addLayout(hSoundLayout);
    vSoundLayout->addStretch(1);

    QWidget *gridwidget = new QWidget;
    gridwidget->setLayout(vSoundLayout);

    QHBoxLayout *finalLayout = new QHBoxLayout;
    finalLayout->addWidget(listWidget);
    finalLayout->addWidget(gridwidget);

    soundScroll->setLayout(finalLayout);
}

void CustomTabWidget::setSceneLayout(){
    sceneCol = 0;
    sceneRow = 0;

    addSceneButton = new QPushButton;
    stopAllScenesButton = new QPushButton;
    removeAllScenesButton = new QPushButton;

    addSceneButton->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
    addSceneButton->setStyleSheet("background-color: transparent;");
    addSceneButton->setIcon(QIcon(QPixmap(":icons/scene.png")));
    addSceneButton->setIconSize(QSize(38, 38));
    addSceneButton->setToolTip("Add Mp3 Track");
    addSceneButton->setToolTipDuration(1000);

    stopAllScenesButton->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
    stopAllScenesButton->setStyleSheet("background-color: transparent;");
    stopAllScenesButton->setIcon(QIcon(QPixmap(":icons/stopAll.png")));
    stopAllScenesButton->setIconSize(QSize(38, 38));
    stopAllScenesButton->setToolTip("Stop All Tracks");
    stopAllScenesButton->setToolTipDuration(1000);

    removeAllScenesButton->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
    removeAllScenesButton->setStyleSheet("background-color: transparent;");
    removeAllScenesButton->setIcon(QIcon(QPixmap(":icons/closeAll.png")));
    removeAllScenesButton->setIconSize(QSize(38, 38));
    removeAllScenesButton->setToolTip("Remove All Tracks");
    removeAllScenesButton->setToolTipDuration(1000);

    sceneGrid = new QGridLayout;
    scenePanel = new QWidget;
    scenePanelLayout = new QHBoxLayout;
    hSceneLayout = new QHBoxLayout;
    vSceneLayout = new QVBoxLayout;
    sceneScroll->setLayout(vSceneLayout);

    scenePanelLayout->addWidget(addSceneButton);
    scenePanelLayout->addWidget(stopAllScenesButton);
    scenePanelLayout->addWidget(removeAllScenesButton);

    scenePanelLayout->addStretch(1);

    scenePanel->setLayout(scenePanelLayout);

    hSceneLayout->addLayout(sceneGrid);
    hSceneLayout->addStretch(1);

    vSceneLayout->addWidget(scenePanel);
    vSceneLayout->addLayout(hSceneLayout);
    vSceneLayout->addStretch(1);
}

void CustomTabWidget::dragEnterEvent(QDragEnterEvent *event){
    event->acceptProposedAction();
}

void CustomTabWidget::dragLeaveEvent(QDragLeaveEvent *event){
    event->accept();
}

void CustomTabWidget::dragMoveEvent(QDragMoveEvent *event){
    event->acceptProposedAction();
}

void CustomTabWidget::dropEvent(QDropEvent *event){
    QStringList list;
    list.append("qrc" + event->mimeData()->data("FileInfo"));

    if(soundCol < 3){
        appendSound(list, 0);
        ++soundCol;
    } else{
        soundCol = 0;
        soundRow++;
        appendSound(list, 0);
        ++soundCol;
    }
}

void CustomTabWidget::addSound(bool checked){
    (void)checked;

    QFileDialog fileDialog;
    QStringList fileList = fileDialog.getOpenFileNames
            (this, "Open MP3", QDir::currentPath(), "MP3 files (*.mp3)");

    if(!fileList.isEmpty()){
        for(int i = 0; i < fileList.size(); ++i){
            if(soundCol < 3){
                appendSound(fileList, i);
                ++soundCol;
            } else{
                soundCol = 0;
                soundRow++;
                appendSound(fileList, i);
                ++soundCol;
            }
        }
    } else{
        return;
    }
}

void CustomTabWidget::removeSound(Player *player){
    players.removeAll(player);
    player->~Player();

    soundGrid->~QGridLayout();
    soundGrid = new QGridLayout;
    hSoundLayout->insertLayout(hSoundLayout->count() - 1, soundGrid);

    soundRow = 0;
    soundCol = 0;
    int counter = 0;
    while(counter < players.size()){
        if(soundCol < 3){
            soundGrid->addWidget(players.at(counter), soundRow, soundCol);
            ++soundCol;
        } else{
            soundCol = 0;
            ++soundRow;
            soundGrid->addWidget(players.at(counter), soundRow, soundCol);
            ++soundCol;
        }
        ++counter;
    }
}

void CustomTabWidget::removeAllSounds(bool checked){
    (void)checked;
    for(int i = 0; i < players.size(); ++i){
        players.at(i)->~Player();
    }
    players.clear();
    soundCol = 0;
    soundRow = 0;
}

void CustomTabWidget::addDefaultSound(CustomListWidgetItem *item){

    QString path = "qrc" + item->getFileInfo().absoluteFilePath();

    QStringList list;
    list.append(path);

    qDebug() << list << endl;

    if(soundCol < 3){
        appendSound(list, 0);
        ++soundCol;
    } else{
        soundCol = 0;
        soundRow++;
        appendSound(list, 0);
        ++soundCol;
    }
}

void CustomTabWidget::stopAllSounds(bool checked){
    (void)checked;
    for(int i = 0; i < players.size(); ++i){
        players.at(i)->getPlayer()->stop();
    }
}

void CustomTabWidget::addScene(bool checked){
    (void)checked;

    bool ok;
    QString title = QInputDialog::getText(this, "Scene Title",
                                               "Title: ", QLineEdit::Normal,
                                               "", &ok);
    if (ok && !title.isEmpty()){
        if(sceneCol < 5){
            appendScene(title);
            ++sceneCol;
        } else{
            sceneCol = 0;
            ++sceneRow;
            appendScene(title);
            ++sceneCol;
        }
    } else{
        return;
    }
}

void CustomTabWidget::stopAllScenes(bool checked){
    (void)checked;
    for(int i = 0; i < scenes.size(); ++i){
        if(scenes.at(i)->getPlayStopButton()->isChecked()){
            scenes.at(i)->playStop(false);
            scenes.at(i)->getPlayStopButton()->setChecked(false);
//            scenes.at(i)->getPlayStopButton()->click();
        }
    }
}

void CustomTabWidget::removeScene(Scene *scene){
    scenes.removeAll(scene);
    scene->~Scene();

    sceneGrid->~QGridLayout();
    sceneGrid = new QGridLayout;
    hSceneLayout->insertLayout(hSceneLayout->count() - 1, sceneGrid);

    sceneRow = 0;
    sceneCol = 0;
    int counter = 0;
    while(counter < scenes.size()){
        if(sceneCol < 5){
            sceneGrid->addWidget(scenes.at(counter), sceneRow, sceneCol);
            ++sceneCol;
        } else{
            sceneCol = 0;
            ++sceneRow;
            sceneGrid->addWidget(scenes.at(counter), sceneRow, sceneCol);
            ++sceneCol;
        }
        ++counter;
    }
}

void CustomTabWidget::removeAllScenes(bool checked){
    (void)checked;

    for(int i = 0; i < scenes.size(); ++i){
        scenes.at(i)->~Scene();
    }
    scenes.clear();
    sceneCol = 0;
    sceneRow = 0;
}

void CustomTabWidget::appendSound(QStringList &list, int i){
    players.append(new Player(this));
    connect(players.at(players.size() - 1), &Player::thisPlayer, this, &CustomTabWidget::removeSound);
    qDebug() << players.size() << endl;
    players.at(players.size() - 1)->getPlaylist()->addMedia(QUrl(list.at(i)));
    QString file = list.at(i);
    qDebug() << file << endl;
    file.remove(0, file.lastIndexOf('/') + 1);
    file.chop(4);
    players.at(players.size() - 1)->setTitle(file);
    soundGrid->addWidget(players.at(players.size() - 1), soundRow, soundCol);
}

void CustomTabWidget::appendScene(QString title){
    Scene *scene = new Scene;
    connect(scene, &Scene::thisScene, this, &CustomTabWidget::removeScene);
    scenes.append(scene);
    scene->setTitle(title);
    sceneGrid->addWidget(scene, sceneRow, sceneCol);
}

main.cpp

#include "widget.h"
#include <QApplication>

int main(int argc, char *argv[]){
    QApplication a(argc, argv);
    Widget w;
    w.show();

    return a.exec();
}

player.cpp

#include "player.h"
#include "ui_player.h"

#include <QPainter>

Player::Player(QWidget *parent) : QWidget(parent),
    ui(new Ui::Player){
    ui->setupUi(this);

     ui->playStopButton->setCheckable(true);
     ui->playStopButton->setToolTip("Play / Stop");
     ui->playStopButton->setToolTipDuration(500);

     ui->volumeSlider->setValue(50);
     ui->volumeSlider->setToolTip("volume");
     ui->volumeSlider->setToolTipDuration(500);

     ui->deleteButton->setToolTip("Delete");
     ui->deleteButton->setToolTipDuration(500);


     mPlayer = new QMediaPlayer(this);
     mPlaylist = new QMediaPlaylist(this);
     mPlaylist->setPlaybackMode(QMediaPlaylist::CurrentItemOnce);
     mPlayer->setPlaylist(mPlaylist);
     mPlayer->setVolume(ui->volumeSlider->value());

     connect(ui->playStopButton, &QPushButton::clicked, this, &Player::playStopButton);
     connect(ui->deleteButton, &QPushButton::clicked, this, &Player::emitThisPlayer);
     connect(mPlayer, &QMediaPlayer::stateChanged, this, &Player::soundEnd);
     connect(ui->loopCheckBox, &QCheckBox::clicked, this, &Player::loop);
     connect(ui->volumeSlider, &QSlider::valueChanged, mPlayer, &QMediaPlayer::setVolume);
     connect(ui->volumeSlider, &QSlider::valueChanged, this, &Player::sliderValueChanged);

     QFont font;
     font.setBold(true);
     font.setFamily("Arial");
     font.setPointSize(10);
     ui->titleLabel->setFont(font);

//     QColor color = QColor(Qt::white);
//     QPalette palette = ui->titleLabel->palette();
//     palette.setColor(QPalette::WindowText, color);
//     ui->titleLabel->setPalette(palette);

     ui->playStopButton->setStyleSheet("background-color: transparent;");
     setIconState("play");
     ui->playStopButton->setIconSize(QSize(28, 28));

     ui->deleteButton->setStyleSheet("background-color: transparent;");
     ui->deleteButton->setIcon(QIcon(QPixmap(":/icons/minus.png")));
     ui->deleteButton->setIconSize(QSize(28, 28));

     setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding);
}

Player::~Player(){
    delete ui;
}

void Player::loop(bool checked){
    if(checked){
        mPlaylist->setPlaybackMode(QMediaPlaylist::CurrentItemInLoop);
    } else{
        mPlaylist->setPlaybackMode(QMediaPlaylist::CurrentItemOnce);
    }
}

void Player::soundEnd(QMediaPlayer::State state){
    if(state == QMediaPlayer::State::StoppedState){
        setIconState("play");
        ui->playStopButton->setChecked(false);
    }
}

void Player::playStopButton(bool checked){
    if(checked){
        setIconState("stop");
        mPlayer->play();
    } else{
        setIconState("play");
        if(mPlayer->state() == QMediaPlayer::State::PlayingState){
            mPlayer->stop();
        } else{
            return;
        }
    }
}

void Player::setTitle(QString title){
    ui->titleLabel->setText(title);
}

void Player::setIconState(QString str){
    ui->playStopButton->setIcon(QIcon(QPixmap(":/icons/" +  str  + ".png")));
}

float Player::getSliderValue(){
    return (float)ui->volumeSlider->value();
}

QPushButton* Player::getPlayStopButton(){
    return ui->playStopButton;
}

QCheckBox* Player::getLoopButton(){
    return ui->loopCheckBox;
}

QMediaPlayer *Player::getPlayer(){
    return mPlayer;
}

QMediaPlaylist *Player::getPlaylist(){
    return mPlaylist;
}

void Player::emitThisPlayer(bool checked){
    (void)checked;
    emit thisPlayer(this);
}

scene.cpp

#include "scene.h"
#include "ui_scene.h"

#include <QFileDialog>
#include <QCloseEvent>

#include <QStringList>
#include <QMimeData>

Scene::Scene(QWidget *parent) : QWidget(parent),
    ui(new Ui::Scene){
    ui->setupUi(this);

    stoppedCounter = 0;

    setEditorLayout();

    ui->playStopButton->setCheckable(true);
    ui->playStopButton->setToolTip("Play / Stop");
    ui->playStopButton->setToolTipDuration(500);

    ui->volumeSlider->setToolTip("volume");
    ui->volumeSlider->setToolTipDuration(500);
    ui->volumeSlider->setValue(50);

    ui->deleteButton->setToolTip("Delete Scene");
    ui->deleteButton->setToolTipDuration(500);

    connect(ui->playStopButton, &QPushButton::clicked, this, &Scene::playStop);
    connect(ui->editorButton, &QPushButton::clicked, this, &Scene::showEditor);
    connect(ui->deleteButton, &QPushButton::clicked, this, &Scene::emitThisScene);
    connect(ui->loopCheckBox, &QCheckBox::clicked, this, &Scene::loopScene);
    connect(ui->volumeSlider, &QSlider::valueChanged, this, &Scene::masterVolume);

    connect(add, &QPushButton::clicked, this, &Scene::addSound);
    connect(stopAll, &QPushButton::clicked, this, &Scene::stopAllSounds);
    connect(removeAll, &QPushButton::clicked, this, &Scene::removeAllSounds);
    connect(editorPS, &QPushButton::clicked, this, &Scene::playStop);
//    connect(editor, &Editor::hidden, this, &Scene::playStop);

    QFont font;
    font.setBold(true);
    font.setFamily("Arial");
    font.setPointSize(10);
    ui->titleLabel->setFont(font);

//    QColor color = QColor(Qt::white);
//    QPalette palette = ui->titleLabel->palette();
//    palette.setColor(QPalette::WindowText, color);
//    ui->titleLabel->setPalette(palette);

    ui->playStopButton->setStyleSheet("background-color: transparent;");
    ui->playStopButton->setIcon(QIcon(QPixmap(":/icons/play.png")));
    ui->playStopButton->setIconSize(QSize(28, 28));

    ui->editorButton->setStyleSheet("background-color: transparent;");
    ui->editorButton->setIcon(QIcon(QPixmap(":/icons/settings.png")));
    ui->editorButton->setIconSize(QSize(28, 28));

    ui->deleteButton->setStyleSheet("background-color: transparent;");
    ui->deleteButton->setIcon(QIcon(QPixmap(":/icons/minus.png")));
    ui->deleteButton->setIconSize(QSize(28, 28));

    setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::MinimumExpanding);
}

Scene::~Scene(){
    delete ui;
}

void Editor::dragEnterEvent(QDragEnterEvent *event){
    event->acceptProposedAction();
}

void Editor::dragLeaveEvent(QDragLeaveEvent *event){
    event->accept();
}

void Editor::dragMoveEvent(QDragMoveEvent *event){
    event->acceptProposedAction();
}

void Editor::dropEvent(QDropEvent *event){

    QStringList list;
    list.append("qrc" + event->mimeData()->data("FileInfo"));

    if(scene->getCol() < 3){
        scene->appendSound(list, 0);
        scene->setCol(scene->getCol() + 1);
    } else{
        scene->setCol(0);
        scene->setRow(scene->getRow() + 1);
        scene->appendSound(list, 0);
        scene->setCol(scene->getCol() + 1);
    }
}

void Editor::addDefaultSound(CustomListWidgetItem *item){

    QString path = "qrc" + item->getFileInfo().absoluteFilePath();

    QStringList list;
    list.append(path);

    qDebug() << list << endl;

    if(scene->getCol() < 3){
        scene->appendSound(list, 0);
        scene->setCol(scene->getCol() + 1);
    } else{
        scene->setCol(0);
        scene->setRow(scene->getRow() + 1);
        scene->appendSound(list, 0);
        scene->setCol(scene->getCol() + 1);
    }
}

int Scene::getCol(){
    return col;
}

void Scene::setCol(int i){
    col = i;
}

int Scene::getRow(){
    return row;
}

void Scene::setRow(int i){
    row = i;
}

Editor::Editor(Scene *parent) : QWidget(parent){
    scene = parent;
}

void Editor::resizeEvent(QResizeEvent *evt){
    QPixmap bkgnd(":/images/library wizard.jpg");
    bkgnd = bkgnd.scaled(size(), Qt::IgnoreAspectRatio);
    QPalette p = palette(); //copy current, not create new
    p.setBrush(QPalette::Background, bkgnd);
    setPalette(p);

    QWidget::resizeEvent(evt); //call base implementation
}

void Editor::closeEvent(QCloseEvent *event){
    event->ignore();
    scene->stopAllSounds(true);
    this->hide();

//    emit hidden(false);
}

Editor::~Editor(){

}

void Scene::masterVolume(int i){
    for(int j = 0; j < players.size(); ++j){
        players.at(j)->getPlayer()->setVolume((players.at(j)->getSliderValue() / 100) * i);
    }
}

void Scene::setMasterVolume(int i){
    (void)i;
    masterVolume(ui->volumeSlider->value());
}

void Scene::soundEnd(){
    qDebug() << endl << "soundEnd() Emitido";
    if(stoppedCounter == 0){
        qDebug() << "Scene play/stop Button checked false" << endl;
        ui->playStopButton->setIcon(QIcon(QPixmap(":/icons/play.png")));
        ui->playStopButton->setChecked(false);

        editorPS->setIcon(QIcon(QPixmap(":/icons/play.png")));
        editorPS->setChecked(false);
    }
}

void Scene::playerStateChanged(QMediaPlayer::State state){
    qDebug() << endl <<  "Player stateChanged() Emited!";
    if(state == QMediaPlayer::State::PlayingState){
        ++stoppedCounter;
        qDebug() << "Counter ++: " << stoppedCounter << endl;
    } else{
        --stoppedCounter;
        qDebug() << "Counter --: " << stoppedCounter << endl;
    }
    soundEnd();
}

void Scene::loopScene(bool checked){
    for(int i = 0; i < players.size(); ++i){
        players.at(i)->getLoopButton()->setChecked(checked);
        players.at(i)->loop(checked);
    }
}

void Scene::playStop(bool checked){
    if(checked){
        ui->playStopButton->setIcon(QIcon(QPixmap(":/icons/stop.png")));
        ui->playStopButton->setChecked(checked);
        editorPS->setIcon(QIcon(QPixmap(":/icons/stop.png")));
        editorPS->setChecked(checked);

        /* Si hay alguien tocando lo para */
        for(int i = 0; i < players.size(); ++i){
            if(players.at(i)->getPlayer()->state() == QMediaPlayer::PlayingState){
                players.at(i)->playStopButton(false);
                players.at(i)->getPlayStopButton()->setChecked(false);
            }
        }

        /* Los toca todos */
        for(int i = 0; i < players.size(); ++i){
            players.at(i)->playStopButton(checked);
            players.at(i)->getPlayStopButton()->setChecked(checked);
        }
    } else{
        ui->playStopButton->setIcon(QIcon(QPixmap(":/icons/play.png")));
        ui->playStopButton->setChecked(checked);
        editorPS->setIcon(QIcon(QPixmap(":/icons/play.png")));
        editorPS->setChecked(checked);

        /* Si hay alguien tocando lo para */
        for(int i = 0; i < players.size(); ++i){
            if(players.at(i)->getPlayer()->state() == QMediaPlayer::PlayingState){
                players.at(i)->playStopButton(checked);
                players.at(i)->getPlayStopButton()->setChecked(checked);
            }
        }
    }
}

void Scene::removeAllSounds(bool checked){
    (void)checked;

    for(int i = 0; i < players.size(); ++i){        
        players.at(i)->~Player();
    }
    players.clear();
    col = 0;
    row = 0;
    stoppedCounter = 0;
}

void Scene::removeSound(Player *player){
    players.removeAll(player);

    if(player->getPlayer()->PlayingState == QMediaPlayer::PlayingState){
        --stoppedCounter;
    }

    player->~Player();

    grid->~QGridLayout();
    grid = new QGridLayout;
    h->insertLayout(h->count() - 1, grid);

    row = 0;
    col = 0;
    int counter = 0;
    while(counter < players.size()){
        if(col < 3){
            grid->addWidget(players.at(counter), row, col);
            ++col;
        } else{
            col = 0;
            ++row;
            grid->addWidget(players.at(counter), row, col);
            ++col;
        }
        ++counter;
    }    
    soundEnd();
}

void Scene::addSound(bool checked){
    (void)checked;

    QFileDialog fileDialog;
    QStringList fileList = fileDialog.getOpenFileNames
            (this, "Open MP3", QDir::currentPath(), "MP3 files (*.mp3)");

    if(!fileList.isEmpty()){
        for(int i = 0; i < fileList.size(); ++i){
            if(col < 3){
                appendSound(fileList, i);
                ++col;
            } else{
                col = 0;
                row++;
                appendSound(fileList, i);
                ++col;
            }
        }
    } else{
        return;
    }
}

void Scene::stopAllSounds(bool checked){
    (void)checked;
    for(int i = 0; i < players.size(); ++i){
        players.at(i)->getPlayer()->stop();
    }
}

void Scene::setEditorLayout(){
    col = 0;
    row = 0;

    CustomListWidget *listWidget = new CustomListWidget;

    QVector<QString> paths = {":/Sounds/Age of Sail/", ":/Sounds/Combat (Future)/", ":/Sounds/Combat (Medieval)/",
                              ":/Sounds/Dark Forest/", ":/Sounds/Death House", ":/Sounds/Deep Six", ":/Sounds/Dungeon",
                              ":/Sounds/Future City", ":/Sounds/House on the Hill", ":/Sounds/Jungle Planet",
                              ":/Sounds/Monster Pack", ":/Sounds/Olde Towne", ":/Sounds/Starship", ":/Sounds/True West",
                              ":Sounds/Wasteland"};

    for(int i = 0; i < paths.size(); ++i){
        QDir dir(paths.at(i));
        QFileInfoList fileList = dir.entryInfoList(QDir::Files, QDir::Name);
        for(int j = 0; j < fileList.size(); ++j){
            listWidget->addCustomItem(new CustomListWidgetItem(fileList.at(j), QIcon(":/icons/music.png")));
            qDebug() << fileList.at(j).absoluteFilePath();
        }
    }

    editor = new Editor(this);
//    editor->setScene(this);
    editor->setWindowFlags(Qt::Window);
    editor->setWindowModality(Qt::WindowModal);
    editor->setAcceptDrops(true);

    connect(listWidget, &CustomListWidget::customItem, editor, &Editor::addDefaultSound);

    panel = new QWidget;

    add = new QPushButton;
    stopAll = new QPushButton;
    removeAll = new QPushButton;
    editorPS = new QPushButton;
    editorPS->setCheckable(true);

    add->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
    add->setStyleSheet("background-color: transparent;");
    add->setIcon(QIcon(QPixmap(":icons/add.png")));
    add->setIconSize(QSize(38, 38));
    add->setToolTip("Add Mp3 Sound");
    add->setToolTipDuration(500);

    stopAll->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
    stopAll->setStyleSheet("background-color: transparent;");
    stopAll->setIcon(QIcon(QPixmap(":icons/stopAll.png")));
    stopAll->setIconSize(QSize(38, 38));
    stopAll->setToolTip("Stop All Sounds");
    stopAll->setToolTipDuration(500);

    removeAll->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
    removeAll->setStyleSheet("background-color: transparent;");
    removeAll->setIcon(QIcon(QPixmap(":icons/closeAll.png")));
    removeAll->setIconSize(QSize(38, 38));
    removeAll->setToolTip("Remove All Sounds");
    removeAll->setToolTipDuration(500);

    editorPS->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed);
    editorPS->setStyleSheet("background-color: transparent;");
    editorPS->setIcon(QIcon(QPixmap(":/icons/play.png")));
    editorPS->setIconSize(QSize(28, 28));
    editorPS->setToolTip("Play / Stop All Sounds");
    editorPS->setToolTipDuration(500);

    grid = new QGridLayout;
    panelLayout = new QHBoxLayout;
    h = new QHBoxLayout;
    v = new QVBoxLayout;

    panelLayout->addWidget(add);
    panelLayout->addWidget(stopAll);
    panelLayout->addWidget(removeAll);
    panelLayout->addWidget(editorPS);
    panelLayout->addStretch(1);

    panel->setLayout(panelLayout);

    h->addLayout(grid);
    h->addStretch(1);

    v->addWidget(panel);
    v->addLayout(h);
    v->addStretch(1);

    QWidget *gridwidget = new QWidget;
    gridwidget->setLayout(v);

    QHBoxLayout *finalLayout = new QHBoxLayout;
    finalLayout->addWidget(listWidget);
    finalLayout->addWidget(gridwidget);

    editor->setLayout(finalLayout);
}

void Scene::showEditor(bool checked){
    (void)checked;

    editor->setWindowTitle("Ambience Editor: " + ui->titleLabel->text());
    editor->resize(400, 300);
    editor->show();
}

void Scene::emitThisScene(bool checked){
    (void)checked;
    emit thisScene(this);
}

void Scene::setTitle(QString title){
    ui->titleLabel->setText(title);
}

QPushButton* Scene::getPlayStopButton(){
    return ui->playStopButton;
}

void Scene::appendSound(QStringList list, int i){
    players.append(new Player(this));
    connect(players.at(players.size() - 1), &Player::thisPlayer, this, &Scene::removeSound);
    connect(players.at(players.size() - 1), &Player::sliderValueChanged, this, &Scene::setMasterVolume);

    /* La conexion garantiza que si no hay ningun sonido en loop dentro del editor, el boton
     * de play de la Scene cambie de estado */

    connect(players.at(players.size() - 1)->getPlayer(), &QMediaPlayer::stateChanged,
            this, &Scene::playerStateChanged);

    qDebug() << players.size() << endl;
    players.at(players.size() - 1)->getPlaylist()->addMedia(QUrl(list.at(i)));
    QString file = list.at(i);
    file.remove(0, file.lastIndexOf('/') + 1);
    file.chop(4);
    players.at(players.size() - 1)->setTitle(file);
    grid->addWidget(players.at(players.size() - 1), row, col);
}

widget.cpp

#include "widget.h"
#include "ui_widget.h"

#include "customtabwidget.h"

#include <QHBoxLayout>

#include <QDir>
#include <QFileInfoList>

Widget::Widget(QWidget *parent) : QWidget(parent),
    ui(new Ui::Widget){
    ui->setupUi(this);

    QHBoxLayout *layout = new QHBoxLayout(this);

    CustomTabWidget *tabWidget = new CustomTabWidget;

    layout->addWidget(tabWidget);

    this->setWindowTitle("TableTop SoundBoard v2.0");
    this->resize(800, 600);
}

Widget::~Widget(){
    delete ui;
}


169
4
задан 7 апреля 2018 в 03:04 Источник Поделиться
Комментарии