MuseScore/mscore/drumview.cpp

//=============================================================================
//  MusE Score
//  Linux Music Score Editor
//
//  Copyright (C) 2010 Werner Schweer and others
//
//  This program is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License version 2.
//
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program; if not, write to the Free Software
//  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
//=============================================================================

#include "drumview.h"
#include "libmscore/staff.h"
#include "piano.h"
#include "libmscore/measure.h"
#include "libmscore/chord.h"
#include "libmscore/score.h"
#include "libmscore/note.h"
#include "libmscore/slur.h"
#include "libmscore/segment.h"

namespace Ms {
static const int MAP_OFFSET = 480;

//---------------------------------------------------------
//   pitch2y
//---------------------------------------------------------

static int pitch2y(int pitch)
{
    static int tt[] = {
        12, 19, 25, 32, 38, 51, 58, 64, 71, 77, 84, 90
    };
    int y = (75 * keyHeight) - (tt[pitch % 12] + (7 * keyHeight) * (pitch / 12));
    if (y < 0) {
        y = 0;
    }
    return y;
}

//---------------------------------------------------------
//   DrumItem
//---------------------------------------------------------

DrumItem::DrumItem(Note* n)
    : QGraphicsPolygonItem(), _note(n)
{
    setFlags(flags() | QGraphicsItem::ItemIsSelectable);
    int pitch = _note->pitch();
    QPolygonF p;
    double h2 = keyHeight / 2;
    p << QPointF(0, -h2) << QPointF(h2, 0.0) << QPointF(0.0, h2) << QPointF(-h2, 0.0);
    setPolygon(p);
    setBrush(QBrush());
    setSelected(_note->selected());
    setData(0, QVariant::fromValue<void*>(_note));

    setPos(_note->chord()->tick().ticks() + 480, pitch2y(pitch) + keyHeight / 4);
    setFlag(QGraphicsItem::ItemIgnoresTransformations, true);
}

//---------------------------------------------------------
//   paint
//---------------------------------------------------------

void DrumItem::paint(QPainter* painter, const QStyleOptionGraphicsItem*, QWidget*)
{
//      Chord* chord = note->chord();
    int x1       = 0;   // note->onTimeOffset() + note->onTimeUserOffset();
    painter->setPen(pen());
    painter->setBrush(isSelected() ? Qt::yellow : Qt::blue);
    painter->drawPolygon(polygon().translated(x1, 0.0));
}

//---------------------------------------------------------
//   pix2pos
//---------------------------------------------------------

Pos DrumView::pix2pos(int x) const
{
    x -= MAP_OFFSET;
    if (x < 0) {
        x = 0;
    }
    return Pos(staff->score()->tempomap(), staff->score()->sigmap(), x, _timeType);
}

//---------------------------------------------------------
//   pos2pix
//---------------------------------------------------------

int DrumView::pos2pix(const Pos& p) const
{
    return p.time(_timeType) + MAP_OFFSET;
}

//---------------------------------------------------------
//   drawBackground
//---------------------------------------------------------

void DrumView::drawBackground(QPainter* p, const QRectF& r)
{
    if (staff == 0) {
        return;
    }
    Score* _score = staff->score();

    QRectF r1;
    r1.setCoords(-1000000.0, 0.0, 480.0, 1000000.0);
    QRectF r2;
    r2.setCoords(ticks + 480, 0.0, 1000000.0, 1000000.0);
    QColor bg(0x71, 0x8d, 0xbe);

    p->fillRect(r, bg);
    if (r.intersects(r1)) {
        p->fillRect(r.intersected(r1), bg.darker(150));
    }
    if (r.intersects(r2)) {
        p->fillRect(r.intersected(r2), bg.darker(150));
    }

    //
    // draw horizontal grid lines
    //
    qreal y1 = r.y();
    qreal y2 = y1 + r.height();
    qreal kh = 13.0;
    qreal x1 = r.x();
    qreal x2 = x1 + r.width();

    int key = floor(y1 / 75);
    qreal y = key * kh;

    for (; key < 75; ++key, y += kh) {
        if (y < y1) {
            continue;
        }
        if (y > y2) {
            break;
        }
        p->setPen(QPen((key % 7) == 5 ? Qt::lightGray : Qt::gray));
        p->drawLine(QLineF(x1, y, x2, y));
    }

    //
    // draw vertical grid lines
    //
    static const int mag[7] = {
        1, 1, 2, 5, 10, 20, 50
    };

    Pos pos1 = pix2pos(x1);
    Pos pos2 = pix2pos(x2);

    //---------------------------------------------------
    //    draw raster
    //---------------------------------------------------

    int bar1, bar2, beat, tick;
    pos1.mbt(&bar1, &beat, &tick);
    pos2.mbt(&bar2, &beat, &tick);

    int mi = mag[magStep < 0 ? 0 : magStep];

    bar1 = (bar1 / mi) * mi;             // round down
    if (bar1 && mi >= 2) {
        bar1 -= 1;
    }
    bar2 = ((bar2 + mi - 1) / mi) * mi;   // round up

    for (int bar = bar1; bar <= bar2;) {
        Pos stick(_score->tempomap(), _score->sigmap(), bar, 0, 0);
        if (magStep > 0) {
            double x = double(pos2pix(stick));
            if (x > 0) {
                p->setPen(Qt::lightGray);
                p->drawLine(x, y1, x, y2);
            } else {
                p->setPen(Qt::black);
                p->drawLine(x, y1, x, y1);
            }
        } else {
            int z = stick.timesig().timesig().numerator();
            for (int b = 0; b < z; b++) {
                if (magStep == 0) {
                    Pos xx(_score->tempomap(), _score->sigmap(), bar, b, 0);
                    int xp = pos2pix(xx);
                    if (xp < 0) {
                        continue;
                    }
                    if (xp > 0) {
                        p->setPen(b == 0 ? Qt::lightGray : Qt::gray);
                        p->drawLine(xp, y1, xp, y2);
                    } else {
                        p->setPen(Qt::black);
                        p->drawLine(xp, y1, xp, y2);
                    }
                } else {
                    int k;
                    if (magStep == -1) {
                        k = 2;
                    } else if (magStep == -2) {
                        k = 4;
                    } else if (magStep == -3) {
                        k = 8;
                    } else if (magStep == -4) {
                        k = 16;
                    } else {
                        k = 32;
                    }

                    int n = (MScore::division * 4) / stick.timesig().timesig().denominator();
                    for (int i = 0; i < k; ++i) {
                        Pos xx(_score->tempomap(), _score->sigmap(), bar, b, (n * i) / k);
                        int xp = pos2pix(xx);
                        if (xp < 0) {
                            continue;
                        }
                        if (xp > 0) {
                            p->setPen(i == 0 && b == 0 ? Qt::lightGray : Qt::gray);
                            p->drawLine(xp, y1, xp, y2);
                        } else {
                            p->setPen(Qt::black);
                            p->drawLine(xp, y1, xp, y2);
                        }
                    }
                }
            }
        }
        if (bar == 0 && mi >= 2) {
            bar += (mi - 1);
        } else {
            bar += mi;
        }
    }
}

//---------------------------------------------------------
//   DrumView
//---------------------------------------------------------

DrumView::DrumView()
    : QGraphicsView()
{
    setScene(new QGraphicsScene);
    setTransformationAnchor(QGraphicsView::AnchorUnderMouse);
    setResizeAnchor(QGraphicsView::AnchorUnderMouse);
    setMouseTracking(true);
    setRubberBandSelectionMode(Qt::IntersectsItemBoundingRect);
    setDragMode(QGraphicsView::RubberBandDrag);
    _timeType = TType::TICKS;
    magStep   = 0;
}

//---------------------------------------------------------
//   setStaff
//---------------------------------------------------------

void DrumView::setStaff(Staff* s, Pos* l)
{
    static const QColor lcColors[3] = { Qt::red, Qt::blue, Qt::blue };

    staff    = s;
    _locator = l;
    pos.setContext(s->score()->tempomap(), s->score()->sigmap());

    scene()->blockSignals(true);

    scene()->clear();
    for (int i = 0; i < 3; ++i) {
        locatorLines[i] = new QGraphicsLineItem(QLineF(0.0, 0.0, 0.0, keyHeight * 75.0 * 5));
        QPen pen(lcColors[i]);
        pen.setWidth(2);
        locatorLines[i]->setPen(pen);
        locatorLines[i]->setZValue(1000 + i);         // set stacking order
        locatorLines[i]->setFlag(QGraphicsItem::ItemIgnoresTransformations, true);
        scene()->addItem(locatorLines[i]);
    }

    int staffIdx = staff->idx();
    int startTrack = staffIdx * VOICES;
    int endTrack   = startTrack + VOICES;
    for (Segment* seg = staff->score()->firstSegment(SegmentType::All); seg; seg = seg->next1()) {
        for (int track = startTrack; track < endTrack; ++track) {
            Element* e = seg->element(track);
            if (e == 0 || e->type() != ElementType::CHORD) {
                continue;
            }
            Chord* chord = static_cast<Chord*>(e);
            foreach (Note* n, chord->notes()) {
                if (n->tieBack()) {
                    continue;
                }
                scene()->addItem(new DrumItem(n));
            }
        }
    }
    scene()->blockSignals(false);

    Measure* lm = staff->score()->lastMeasure();
    ticks       = (lm->tick() + lm->ticks()).ticks();
    scene()->setSceneRect(0.0, 0.0, double(ticks + 960), keyHeight * 75);

    for (int i = 0; i < 3; ++i) {
        moveLocator(i);
    }
    //
    // move to something interesting
    //
    QList<QGraphicsItem*> items = scene()->selectedItems();
    QRectF boundingRect;
    foreach (QGraphicsItem* item, items) {
        Note* note = static_cast<Note*>(item->data(0).value<void*>());
        if (note) {
            boundingRect |= item->mapToScene(item->boundingRect()).boundingRect();
        }
    }
    centerOn(boundingRect.center());
}

//---------------------------------------------------------
//   moveLocator
//---------------------------------------------------------

void DrumView::moveLocator(int i)
{
    if (_locator[i].valid()) {
        locatorLines[i]->setVisible(true);
        qreal x = qreal(pos2pix(_locator[i]));
        locatorLines[i]->setPos(QPointF(x, 0.0));
    } else {
        locatorLines[i]->setVisible(false);
    }
}

//---------------------------------------------------------
//   wheelEvent
//---------------------------------------------------------

void DrumView::wheelEvent(QWheelEvent* event)
{
    int step = event->angleDelta().y() / 120;
    double xmag = transform().m11();
    double ymag = transform().m22();

    if (event->modifiers() == Qt::ControlModifier) {
        if (step > 0) {
            for (int i = 0; i < step; ++i) {
                if (xmag > 10.0) {
                    break;
                }
                scale(1.1, 1.0);
                xmag *= 1.1;
            }
        } else {
            for (int i = 0; i < -step; ++i) {
                if (xmag < 0.001) {
                    break;
                }
                scale(.9, 1.0);
                xmag *= .9;
            }
        }
        emit magChanged(xmag, ymag);

        int tpix  = (480 * 4) * xmag;
        magStep = -5;
        if (tpix <= 4000) {
            magStep = -4;
        }
        if (tpix <= 2000) {
            magStep = -3;
        }
        if (tpix <= 1000) {
            magStep = -2;
        }
        if (tpix <= 500) {
            magStep = -1;
        }
        if (tpix <= 128) {
            magStep = 0;
        }
        if (tpix <= 64) {
            magStep = 1;
        }
        if (tpix <= 32) {
            magStep = 2;
        }
        if (tpix <= 16) {
            magStep = 3;
        }
        if (tpix <= 8) {
            magStep = 4;
        }
        if (tpix <= 4) {
            magStep = 5;
        }
        if (tpix <= 2) {
            magStep = 6;
        }

        //
        // if xpos <= 0, then the scene is centered
        // there is no scroll bar anymore sending
        // change signals, so we have to do it here:
        //
        double xpos = -(mapFromScene(QPointF()).x());
        if (xpos <= 0) {
            emit xposChanged(xpos);
        }
    } else if (event->modifiers() == Qt::ShiftModifier) {
        QWheelEvent we(event->position(), event->globalPosition(), event->pixelDelta(), event->angleDelta(),
                       event->buttons(), event->modifiers(), event->phase(), event->inverted(), event->source());
        QGraphicsView::wheelEvent(&we);
    } else if (event->modifiers() == 0) {
        QGraphicsView::wheelEvent(event);
    } else if (event->modifiers() == (Qt::ShiftModifier | Qt::ControlModifier)) {
        if (step > 0) {
            for (int i = 0; i < step; ++i) {
                if (ymag > 3.0) {
                    break;
                }
                scale(1.0, 1.1);
                ymag *= 1.1;
            }
        } else {
            for (int i = 0; i < -step; ++i) {
                if (ymag < 0.4) {
                    break;
                }
                scale(1.0, .9);
                ymag *= .9;
            }
        }
        emit magChanged(xmag, ymag);
    }
}

//---------------------------------------------------------
//   y2pitch
//---------------------------------------------------------

int DrumView::y2pitch(int y) const
{
    int pitch;
    const int total = (10 * 7 + 5) * keyHeight;         // 75 Ganztonschritte
    y = total - y;
    int oct = (y / (7 * keyHeight)) * 12;
    static const char kt[] = {
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        1, 1, 1, 1, 1, 1, 1,
        2, 2, 2, 2, 2, 2,
        3, 3, 3, 3, 3, 3, 3,
        4, 4, 4, 4, 4, 4, 4, 4, 4,
        5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
        6, 6, 6, 6, 6, 6, 6,
        7, 7, 7, 7, 7, 7,
        8, 8, 8, 8, 8, 8, 8,
        9, 9, 9, 9, 9, 9,
        10, 10, 10, 10, 10, 10, 10,
        11, 11, 11, 11, 11, 11, 11, 11, 11, 11
    };
    pitch = kt[y % 91] + oct;
    if (pitch < 0 || pitch > 127) {
        pitch = -1;
    }
    return pitch;
}

//---------------------------------------------------------
//   mouseMoveEvent
//---------------------------------------------------------

void DrumView::mouseMoveEvent(QMouseEvent* event)
{
    QPointF p(mapToScene(event->pos()));
    int pitch = y2pitch(int(p.y()));
    emit pitchChanged(pitch);
    int tick = int(p.x()) - 480;
    if (tick < 0) {
        tick = 0;
        pos.setTick(tick);
        pos.setInvalid();
    } else {
        pos.setTick(tick);
    }
    emit posChanged(pos);
    QGraphicsView::mouseMoveEvent(event);
}

//---------------------------------------------------------
//   leaveEvent
//---------------------------------------------------------

void DrumView::leaveEvent(QEvent* event)
{
    emit pitchChanged(-1);
    pos.setInvalid();
    emit posChanged(pos);
    QGraphicsView::leaveEvent(event);
}

//---------------------------------------------------------
//   ensureVisible
//---------------------------------------------------------

void DrumView::ensureVisible(int tick)
{
    tick += MAP_OFFSET;
    QPointF pt = mapToScene(0, height() / 2);
    QGraphicsView::ensureVisible(qreal(tick), pt.y(), 240.0, 1.0);
}
}