path: root/src/waveform/renderers/waveformrendermark.cpp

#include <QDomNode>
#include <QPainter>
#include <QPainterPath>

#include "waveform/renderers/waveformrendermark.h"

#include "control/controlproxy.h"
#include "engine/controls/cuecontrol.h"
#include "track/track.h"
#include "util/color/color.h"
#include "waveform/renderers/waveformwidgetrenderer.h"
#include "waveform/waveform.h"
#include "widget/wskincolor.h"
#include "widget/wwidget.h"
#include "widget/wimagestore.h"
#include "util/painterscope.h"

namespace {
    const int kMaxCueLabelLength = 23;
}

WaveformRenderMark::WaveformRenderMark(
        WaveformWidgetRenderer* waveformWidgetRenderer) :
    WaveformRendererAbstract(waveformWidgetRenderer) {
}

void WaveformRenderMark::setup(const QDomNode& node, const SkinContext& context) {
    WaveformSignalColors signalColors = *m_waveformRenderer->getWaveformSignalColors();
    m_marks.setup(m_waveformRenderer->getGroup(), node, context, signalColors);
}

void WaveformRenderMark::draw(QPainter* painter, QPaintEvent* /*event*/) {
    PainterScope PainterScope(painter);

    /*
    //DEBUG
    for (int i = 0; i < m_markPoints.size(); i++) {
        if (m_waveformWidget->getTrackSamples())
            painter->drawText(40*i,12+12*(i%3),QString::number(m_markPoints[i]->get() / (double)m_waveformWidget->getTrackSamples()));
    }
    */

    painter->setWorldMatrixEnabled(false);

    for (auto& pMark: m_marks) {
        if (!pMark->isValid())
            continue;

        if (pMark->hasVisible() && !pMark->isVisible()) {
            continue;
        }

        // Generate image on first paint can't be done in setup since we need
        // render widget to be resized yet ...
        if (pMark->m_image.isNull()) {
            generateMarkImage(pMark);
        }

        double samplePosition = pMark->getSamplePosition();
        if (samplePosition != -1.0) {
            double currentMarkPoint =
                    m_waveformRenderer->transformSamplePositionInRendererWorld(samplePosition);

            if (m_waveformRenderer->getOrientation() == Qt::Horizontal) {
                // NOTE: vRince I guess image width is odd to display the center on the exact line !
                // external image should respect that ...
                const int markHalfWidth = pMark->m_image.width() / 2.0
                        / m_waveformRenderer->getDevicePixelRatio();

                // Check if the current point need to be displayed
                if (currentMarkPoint > -markHalfWidth && currentMarkPoint < m_waveformRenderer->getWidth() + markHalfWidth) {
                    painter->drawImage(QPoint(currentMarkPoint - markHalfWidth, 0), pMark->m_image);
                }
            } else {
                const int markHalfHeight = pMark->m_image.height() / 2.0;

                if (currentMarkPoint > -markHalfHeight && currentMarkPoint < m_waveformRenderer->getHeight() + markHalfHeight) {
                    painter->drawImage(QPoint(0,currentMarkPoint - markHalfHeight), pMark->m_image);
                }
            }
        }
    }
}

void WaveformRenderMark::onResize() {
    // Delete all marks' images. New images will be created on next paint.
    for (const auto& pMark: m_marks) {
    	pMark->m_image = QImage();
    }
}

void WaveformRenderMark::onSetTrack() {
    slotCuesUpdated();

    TrackPointer trackInfo = m_waveformRenderer->getTrackInfo();
    if (!trackInfo) {
        return;
    }
    connect(trackInfo.get(),
            &Track::cuesUpdated,
            this,
            &WaveformRenderMark::slotCuesUpdated);
}

void WaveformRenderMark::slotCuesUpdated() {
    TrackPointer trackInfo = m_waveformRenderer->getTrackInfo();
    if (!trackInfo){
        return;
    }

    QList<CuePointer> loadedCues = trackInfo->getCuePoints();
    for (const CuePointer pCue: loadedCues) {
        int hotCue = pCue->getHotCue();
        if (hotCue == Cue::kNoHotCue) {
            continue;
        }

        // Here we assume no two cues can have the same hotcue assigned,
        // because WaveformMarkSet stores one mark for each hotcue.
        WaveformMarkPointer pMark = m_marks.getHotCueMark(hotCue);
        if (pMark.isNull()) {
            continue;
        }

        QString newLabel = pCue->getLabel();
        QColor newColor = mixxx::RgbColor::toQColor(pCue->getColor());
        if (pMark->m_text.isNull() || newLabel != pMark->m_text ||
                !pMark->fillColor().isValid() || newColor != pMark->fillColor()) {
            pMark->m_text = newLabel;
            pMark->setBaseColor(newColor);
            generateMarkImage(pMark);
        }
    }
}

void WaveformRenderMark::generateMarkImage(WaveformMarkPointer pMark) {
    // Load the pixmap from file -- takes precedence over text.
    if (!pMark->m_pixmapPath.isEmpty()) {
        QString path = pMark->m_pixmapPath;
        QImage image = *WImageStore::getImage(path, scaleFactor());
        //QImage image = QImage(path);
        // If loading the image didn't fail, then we're done. Otherwise fall
        // through and render a label.
        if (!image.isNull()) {
            pMark->m_image = image.convertToFormat(QImage::Format_ARGB32_Premultiplied);
            //WImageStore::correctImageColors(&pMark->m_image);
            return;
        }
    }

    QPainter painter;

    // Determine mark text.
    QString label = pMark->m_text;
    if (pMark->getHotCue() >= 0) {
        if (!label.isEmpty()) {
            label.prepend(": ");
        }
        label.prepend(QString::number(pMark->getHotCue() + 1));
        if (label.size() > kMaxCueLabelLength) {
            label = label.left(kMaxCueLabelLength - 3) + "...";
        }
    }

    //QFont font("Bitstream Vera Sans");
    //QFont font("Helvetica");
    QFont font; // Uses the application default
    font.setPointSizeF(10 * scaleFactor());
    font.setStretch(100);
    font.setWeight(75);

    QFontMetrics metrics(font);

    //fixed margin ...
    QRect wordRect = metrics.tightBoundingRect(label);
    const int marginX = 1;
    const int marginY = 1;
    wordRect.moveTop(marginX + 1);
    wordRect.moveLeft(marginY + 1);
    wordRect.setHeight(wordRect.height() + (wordRect.height() % 2));
    wordRect.setWidth(wordRect.width() + (wordRect.width()) % 2);
    //even wordrect to have an even Image >> draw the line in the middle !

    int labelRectWidth = wordRect.width() + 2 * marginX + 4;
    int labelRectHeight = wordRect.height() + 2 * marginY + 4;

    QRectF labelRect(0, 0, (float)labelRectWidth, (float)labelRectHeight);

    int width;
    int height;

    if (m_waveformRenderer->getOrientation() == Qt::Horizontal) {
        width = 2 * labelRectWidth + 1;
        height = m_waveformRenderer->getHeight();
    } else {
        width = m_waveformRenderer->getWidth();
        height = 2 * labelRectHeight + 1;
    }

    pMark->m_image = QImage(width * m_waveformRenderer->getDevicePixelRatio(),
            height * m_waveformRenderer->getDevicePixelRatio(),
            QImage::Format_ARGB32_Premultiplied);
    pMark->m_image.setDevicePixelRatio(m_waveformRenderer->getDevicePixelRatio());

    Qt::Alignment markAlignH = pMark->m_align & Qt::AlignHorizontal_Mask;
    Qt::Alignment markAlignV = pMark->m_align & Qt::AlignVertical_Mask;

    if (markAlignH == Qt::AlignHCenter) {
        labelRect.moveLeft((width - labelRectWidth) / 2);
    } else if (markAlignH == Qt::AlignRight) {
        labelRect.moveRight(width - 1);
    }

    if (markAlignV == Qt::AlignVCenter) {
        labelRect.moveTop((height - labelRectHeight) / 2);
    } else if (markAlignV == Qt::AlignBottom) {
        labelRect.moveBottom(height - 1);
    }

    // Fill with transparent pixels
    pMark->m_image.fill(QColor(0, 0, 0, 0).rgba());

    painter.begin(&pMark->m_image);
    painter.setRenderHint(QPainter::TextAntialiasing);

    painter.setWorldMatrixEnabled(false);

    // Draw marker lines
    if (m_waveformRenderer->getOrientation() == Qt::Horizontal) {
        int middle = width / 2;
        if (markAlignH == Qt::AlignHCenter) {
            if (labelRect.top() > 0) {
                painter.setPen(pMark->fillColor());
                painter.drawLine(middle, 0,