musicspectrumwidget.cpp

Go to the documentation of this file.

#include "musicspectrumwidget.h"
#include "ui_musicspectrumwidget.h"
#include "musicqmmputils.h"
#include "musicformats.h"
#include "musictoastlabel.h"
#include "musicwidgetheaders.h"
#include "musictopareawidget.h"
#include "musicfileutils.h"

#include <QPluginLoader>

#include <qmmp/florid.h>
#include <qmmp/visualfactory.h>
#include <qmmp/lightfactory.h>
#include <qmmp/soundcore.h>

static constexpr const char *LIGHT_WAVEFORM_MODULE = "lightwaveform";
static constexpr const char *LIGHT_SPECTROGRAM_MODULE = "lightspectrogram";

MusicSpectrumWidget::MusicSpectrumWidget(QWidget *parent)
    : MusicAbstractMoveResizePlainWidget(parent),
      m_ui(new Ui::MusicSpectrumWidget),
      m_spectrumLayout(nullptr)
{
    m_ui->setupUi(this);
    setMinimumSize(750, 650);
    setAttribute(Qt::WA_DeleteOnClose);
    setBackgroundLabel(m_ui->background);

    setStyleSheet(TTK::UI::MenuStyle02);

    m_ui->topTitleCloseButton->setIcon(QIcon(":/functions/btn_close_hover"));
    m_ui->topTitleCloseButton->setStyleSheet(TTK::UI::ToolButtonStyle04);
    m_ui->topTitleCloseButton->setCursor(QCursor(Qt::PointingHandCursor));
    m_ui->topTitleCloseButton->setToolTip(tr("Close"));
    connect(m_ui->topTitleCloseButton, SIGNAL(clicked()), SLOT(close()));

    m_ui->mainViewWidget->setStyleSheet(TTK::UI::TabWidgetStyle01);

    m_ui->localFileButton->setStyleSheet(TTK::UI::PushButtonStyle04);
    m_ui->localFileButton->setCursor(QCursor(Qt::PointingHandCursor));
    m_ui->openFileButton->setStyleSheet(TTK::UI::PushButtonStyle04);
    m_ui->openFileButton->setCursor(QCursor(Qt::PointingHandCursor));

    m_ui->spectrumNormalLayoutButton->setStyleSheet(TTK::UI::ToolButtonStyle05);
    m_ui->spectrumPlusLayoutButton->setStyleSheet(TTK::UI::ToolButtonStyle05);
    m_ui->spectrumWaveLayoutButton->setStyleSheet(TTK::UI::ToolButtonStyle05);
    m_ui->spectrumFlowLayoutButton->setStyleSheet(TTK::UI::ToolButtonStyle05);
    m_ui->spectrumFloridLayoutButton->setStyleSheet(TTK::UI::ToolButtonStyle05);

#ifdef Q_OS_UNIX
    m_ui->spectrumNormalLayoutButton->setFocusPolicy(Qt::NoFocus);
    m_ui->spectrumPlusLayoutButton->setFocusPolicy(Qt::NoFocus);
    m_ui->spectrumWaveLayoutButton->setFocusPolicy(Qt::NoFocus);
    m_ui->spectrumFlowLayoutButton->setFocusPolicy(Qt::NoFocus);
    m_ui->spectrumFloridLayoutButton->setFocusPolicy(Qt::NoFocus);
    m_ui->localFileButton->setFocusPolicy(Qt::NoFocus);
    m_ui->openFileButton->setFocusPolicy(Qt::NoFocus);
#endif
    // Objects Mouse tracking
    setObjectsTracking({m_ui->background});

    connect(m_ui->localFileButton, SIGNAL(clicked()), SLOT(localFileButtonClicked()));
    connect(m_ui->openFileButton, SIGNAL(clicked()), SLOT(openFileButtonClicked()));
    connect(m_ui->spectrumNormalLayoutButton, SIGNAL(stateChanged(bool&,QString)), SLOT(spectrumNormalTypeChanged(bool&,QString)));
    connect(m_ui->spectrumPlusLayoutButton, SIGNAL(stateChanged(bool&,QString)), SLOT(spectrumPlusTypeChanged(bool&,QString)));
    connect(m_ui->spectrumWaveLayoutButton, SIGNAL(stateChanged(bool&,QString)), SLOT(spectrumWaveTypeChanged(bool&,QString)));
    connect(m_ui->spectrumFlowLayoutButton, SIGNAL(stateChanged(bool&,QString)), SLOT(spectrumFlowTypeChanged(bool&,QString)));
    connect(m_ui->spectrumFloridLayoutButton, SIGNAL(stateChanged(bool&,QString)), SLOT(spectrumFloridTypeChanged(bool&,QString)));
}

MusicSpectrumWidget::~MusicSpectrumWidget()
{
    TTK_REMOVE_SINGLE_WIDGET(this);
    for(const Data &data : qAsConst(m_spectrums))
    {
        TTK::TTKQmmp::setVisualEnabled(data.m_module, false, this);
    }
    delete m_ui;
}

void MusicSpectrumWidget::spectrumNormalTypeChanged(bool &state, const QString &name)
{
    createSpectrumWidget(Data::Module::Normal, state, name, m_ui->spectrumNormalAreaLayout);
}

void MusicSpectrumWidget::spectrumPlusTypeChanged(bool &state, const QString &name)
{
    createSpectrumWidget(Data::Module::Plus, state, name, m_ui->spectrumPlusAreaLayout);
}

void MusicSpectrumWidget::spectrumWaveTypeChanged(bool &state, const QString &name)
{
    if(name == LIGHT_WAVEFORM_MODULE)
    {
        createLightWidget(Data::Module::Light, state, name, m_ui->spectrumWaveAreaLayout);
    }
    else
    {
        createSpectrumWidget(Data::Module::Wave, state, name, m_ui->spectrumWaveAreaLayout);
    }
}

void MusicSpectrumWidget::spectrumFlowTypeChanged(bool &state, const QString &name)
{
    createFlowWidget(Data::Module::Flow, state, name, m_ui->spectrumFlowAreaLayout);
}

void MusicSpectrumWidget::spectrumFloridTypeChanged(bool &state, const QString &name)
{
    createFloridWidget(Data::Module::Florid, state, name, m_ui->spectrumFloridAreaLayout);
}

void MusicSpectrumWidget::localFileButtonClicked()
{
    bool state = true;
    createLightWidget(Data::Module::Light, state, LIGHT_SPECTROGRAM_MODULE, m_ui->spectrumLightAreaLayout);
}

void MusicSpectrumWidget::openFileButtonClicked()
{
    const QString &path = TTK::File::getOpenFileName(this, MusicFormats::supportSpekInputFormats());
    if(!path.isEmpty())
    {
        bool state = true;
        createLightWidget(Data::Module::Light, state, LIGHT_SPECTROGRAM_MODULE, m_ui->spectrumLightAreaLayout, path);
    }
}

void MusicSpectrumWidget::fullscreenByUser(QWidget *widget, bool state)
{
    if(state)
    {
        QWidget *parent = TTKObjectCast(QWidget*, widget->parent());
        if(parent)
        {
            m_spectrumLayout = parent->layout();
            widget->setParent(nullptr);
            widget->setWindowFlags(Qt::Window | Qt::FramelessWindowHint | Qt::WindowStaysOnTopHint);
            widget->showFullScreen();
        }
    }
    else
    {
        if(m_spectrumLayout)
        {
#ifdef Q_OS_WIN
            widget->showNormal();
            widget->setWindowFlags(Qt::Window);
            m_spectrumLayout->addWidget(widget);
#else
            Data spem;
            for(int i = 0; i < m_spectrums.count(); ++i)
            {
                if(m_spectrums[i].m_object == widget)
                {
                    spem = m_spectrums.takeAt(i);
                    break;
                }
            }

            if(spem.m_module.isEmpty())
            {
                return;
            }

            TTK::TTKQmmp::setVisualEnabled(spem.m_module, false, this);

            bool state = true;
            switch(spem.m_type)
            {
                case Data::Module::Normal:
                {
                    createSpectrumWidget(Data::Module::Normal, state, spem.m_module, m_spectrumLayout);
                    break;
                }
                case Data::Module::Plus:
                {
                    createSpectrumWidget(Data::Module::Plus, state, spem.m_module, m_spectrumLayout);
                    break;
                }
                case Data::Module::Wave:
                {
                    createSpectrumWidget(Data::Module::Wave, state, spem.m_module, m_spectrumLayout);
                    break;
                }
                case Data::Module::Flow:
                {
                    m_lastFlowName.clear();
                    createFlowWidget(Data::Module::Flow, state, spem.m_module, m_spectrumLayout);
                    break;
                }
                case Data::Module::Florid:
                {
                    m_lastFloridName.clear();
                    createFloridWidget(Data::Module::Florid, state, spem.m_module, m_spectrumLayout);
                    break;
                }
                case Data::Module::Light:
                {
                    createLightWidget(Data::Module::Light, state, spem.m_module, m_spectrumLayout);
                    break;
                }
                default: break;
            }
#endif
        }
    }
}

void MusicSpectrumWidget::mouseDoubleClickEvent(QMouseEvent *event)
{
    MusicAbstractMoveResizePlainWidget::mouseDoubleClickEvent(event);
    if(event->buttons() == Qt::LeftButton)
    {
        isMaximized() ? showNormal() : showMaximized();
    }
}

void MusicSpectrumWidget::createSpectrumWidget(Data::Module spectrum, bool &state, const QString &name, QLayout *layout)
{
    if(state)
    {
        const int before = Visual::visuals()->count();
        TTK::TTKQmmp::setVisualEnabled(name, true, this);
        const QList<Visual*> *vs = Visual::visuals();
        if(before == vs->count())
        {
            showMessageBoxWidget();
            state = false;
            return;
        }

        if(!vs->isEmpty())
        {
            Data spem;
            spem.m_module = name;
            spem.m_object = vs->last();
            spem.m_type = spectrum;
            m_spectrums << spem;
            layout->addWidget(spem.m_object);
            spem.m_object->setStyleSheet(TTK::UI::MenuStyle02);

            connect(spem.m_object, SIGNAL(fullscreenByUser(QWidget*,bool)), SLOT(fullscreenByUser(QWidget*,bool)));
        }
        else
        {
            showMessageBoxWidget();
            state = false;
        }
    }
    else
    {
        const int index = findSpectrumWidget(name);
        if(index != -1)
        {
            const Data &data = m_spectrums.takeAt(index);
            layout->removeWidget(data.m_object);
            TTK::TTKQmmp::setVisualEnabled(name, false, this);
        }
    }
}

void MusicSpectrumWidget::createFlowWidget(Data::Module spectrum, bool &state, const QString &name, QLayout *layout)
{
    createModuleWidget(spectrum, state, name, layout, false);
}

void MusicSpectrumWidget::createFloridWidget(Data::Module spectrum, bool &state, const QString &name, QLayout *layout)
{
    createModuleWidget(spectrum, state, name, layout, true);
}

void MusicSpectrumWidget::createModuleWidget(Data::Module spectrum, bool &state, const QString &name, QLayout *layout, bool florid)
{
    QString *module = florid ? &m_lastFloridName : &m_lastFlowName;
    if(*module == name)
    {
        state = true;
        return;
    }

    const int index = findSpectrumWidget(*module);
    if(index != -1)
    {
        const Data &data = m_spectrums.takeAt(index);
        layout->removeWidget(data.m_object);
        TTK::TTKQmmp::setVisualEnabled(*module, false, this);
    }

    if(!state)
    {
        module->clear();
        return;
    }

    const int before = Visual::visuals()->count();
    TTK::TTKQmmp::setVisualEnabled(name, true, this);
    const QList<Visual*> *vs = Visual::visuals();
    if(before == vs->count())
    {
        showMessageBoxWidget();
        state = false;
        return;
    }

    if(!vs->isEmpty())
    {
        *module = name;
        Data spem;
        spem.m_module = name;
        spem.m_object = vs->last();
        spem.m_type = spectrum;
        m_spectrums << spem;
        layout->addWidget(spem.m_object);
        spem.m_object->setStyleSheet(TTK::UI::MenuStyle02);

        if(florid)
        {
            TTKObjectCast(Florid*, spem.m_object)->setImage(MusicTopAreaWidget::instance()->originImage());
            connect(MusicTopAreaWidget::instance(), SIGNAL(originImageChanged(QImage)), spem.m_object, SLOT(setImage(QImage)));
        }
        connect(spem.m_object, SIGNAL(fullscreenByUser(QWidget*,bool)), SLOT(fullscreenByUser(QWidget*,bool)));
    }
    else
    {
        showMessageBoxWidget();
        state = false;
    }
}

void MusicSpectrumWidget::createLightWidget(Data::Module spectrum, bool &state, const QString &name, QLayout *layout, const QString &url)
{
    if(state)
    {
        if(findSpectrumWidget(name) == -1)
        {
            QPluginLoader loader;
            loader.setFileName(TTK::TTKQmmp::pluginPath("Light", name));
            QObject *obj = loader.instance();
            LightFactory *factory = nullptr;
            if(obj && (factory = TTKObjectCast(LightFactory*, obj)))
            {
                Data spem;
                spem.m_module = name;
                spem.m_object = factory->create(this);
                spem.m_type = spectrum;
                m_spectrums << spem;
                layout->addWidget(spem.m_object);
            }
        }

        const int index = findSpectrumWidget(name);
        if(index == -1)
        {
            return;
        }

        Light *light = TTKObjectCast(Light*, m_spectrums[index].m_object);
        if(!light)
        {
            return;
        }

        const QString &path = url.isEmpty() ? SoundCore::instance()->path() : url;
        if(LIGHT_WAVEFORM_MODULE == name)
        {
            light->open(path);
        }
        else if(LIGHT_SPECTROGRAM_MODULE == name)
        {
            const QString &suffix = TTK_FILE_SUFFIX(QFileInfo(path));
            for(QString &filter : MusicFormats::supportSpekInputFilterFormats())
            {
                if(filter.remove(0, 2) == suffix)   // remove *.
                {
                    light->open(path);
                    return;
                }
            }

            MusicToastLabel::popup(tr("Unsupported file format"));
        }
    }
    else
    {
        const int index = findSpectrumWidget(name);
        if(index != -1)
        {
            const Data &data = m_spectrums.takeAt(index);
            layout->removeWidget(data.m_object);
            delete data.m_object;
        }
    }
}

int MusicSpectrumWidget::findSpectrumWidget(const QString &name)
{
    if(name.isEmpty())
    {
        return -1;
    }

    for(int i = 0; i < m_spectrums.count(); ++i)
    {
        if(m_spectrums[i].m_module.contains(name))
        {
            return i;
        }
    }

    return -1;
}

void MusicSpectrumWidget::showMessageBoxWidget()
{
    MusicToastLabel::popup(tr("Spectrum init error"));
}