linedstaff.cpp

LINUX下的混音软件

/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */

/*
    Rosegarden
    A MIDI and audio sequencer and musical notation editor.
 
    This program is Copyright 2000-2007
        Guillaume Laurent   <[e-mail]>,
        Chris Cannam        <[e-mail]>,
        Richard Bown        <[e-mail]>
 
    The moral rights of Guillaume Laurent, Chris Cannam, and Richard
    Bown to claim authorship of this work have been asserted.
 
    Other copyrights also apply to some parts of this work.  Please
    see the AUTHORS file and individual file headers for details.
 
    This program is free software; you can redistribute it and/or
    modify it under the terms of the GNU General Public License as
    published by the Free Software Foundation; either version 2 of the
    License, or (at your option) any later version.  See the file
    COPYING included with this distribution for more information.
*/


#include "LinedStaff.h"

#include "misc/Debug.h"
#include "base/Event.h"
#include "base/LayoutEngine.h"
#include "base/NotationTypes.h"
#include "base/Profiler.h"
#include "base/Segment.h"
#include "base/SnapGrid.h"
#include "base/Staff.h"
#include "base/ViewElement.h"
#include "GUIPalette.h"
#include "BarLine.h"
#include <qcanvas.h>
#include <qcolor.h>
#include <qfont.h>
#include <qfontmetrics.h>
#include <qpen.h>
#include <qrect.h>
#include <qstring.h>
#include <algorithm>


namespace Rosegarden
{

// width of pointer
//
const int pointerWidth = 3;


LinedStaff::LinedStaff(QCanvas *canvas, Segment *segment,
                       SnapGrid *snapGrid, int id,
                       int resolution, int lineThickness) :
    Staff(*segment),
    m_canvas(canvas),
    m_snapGrid(snapGrid),
    m_id(id),
    m_x(0.0),
    m_y(0),
    m_margin(0.0),
    m_titleHeight(0),
    m_resolution(resolution),
    m_lineThickness(lineThickness),
    m_pageMode(LinearMode),
    m_pageWidth(2000.0),  // fairly arbitrary, but we need something non-zero
    m_rowsPerPage(0),
    m_rowSpacing(0),
    m_connectingLineLength(0),
    m_startLayoutX(0),
    m_endLayoutX(0),
    m_current(false),
    m_pointer(new QCanvasLine(canvas)),
    m_insertCursor(new QCanvasLine(canvas)),
    m_insertCursorTime(segment->getStartTime()),
    m_insertCursorTimeValid(false)
{
    initCursors();
}

LinedStaff::LinedStaff(QCanvas *canvas, Segment *segment,
                       SnapGrid *snapGrid,
                       int id, int resolution, int lineThickness,
                       double pageWidth, int rowsPerPage, int rowSpacing) :
    Staff(*segment),
    m_canvas(canvas),
    m_snapGrid(snapGrid),
    m_id(id),
    m_x(0.0),
    m_y(0),
    m_margin(0.0),
    m_titleHeight(0),
    m_resolution(resolution),
    m_lineThickness(lineThickness),
    m_pageMode(rowsPerPage ? MultiPageMode : ContinuousPageMode),
    m_pageWidth(pageWidth),
    m_rowsPerPage(rowsPerPage),
    m_rowSpacing(rowSpacing),
    m_connectingLineLength(0),
    m_startLayoutX(0),
    m_endLayoutX(0),
    m_current(false),
    m_pointer(new QCanvasLine(canvas)),
    m_insertCursor(new QCanvasLine(canvas)),
    m_insertCursorTime(segment->getStartTime()),
    m_insertCursorTimeValid(false)
{
    initCursors();
}

LinedStaff::LinedStaff(QCanvas *canvas, Segment *segment,
                       SnapGrid *snapGrid,
                       int id, int resolution, int lineThickness,
                       PageMode pageMode, double pageWidth, int rowsPerPage,
                       int rowSpacing) :
    Staff(*segment),
    m_canvas(canvas),
    m_snapGrid(snapGrid),
    m_id(id),
    m_x(0.0),
    m_y(0),
    m_margin(0.0),
    m_titleHeight(0),
    m_resolution(resolution),
    m_lineThickness(lineThickness),
    m_pageMode(pageMode),
    m_pageWidth(pageWidth),
    m_rowsPerPage(rowsPerPage),
    m_rowSpacing(rowSpacing),
    m_connectingLineLength(0),
    m_startLayoutX(0),
    m_endLayoutX(0),
    m_current(false),
    m_pointer(new QCanvasLine(canvas)),
    m_insertCursor(new QCanvasLine(canvas)),
    m_insertCursorTime(segment->getStartTime()),
    m_insertCursorTimeValid(false)
{
    initCursors();
}

LinedStaff::~LinedStaff()
{
    /*!!! No, the canvas items are all deleted by the canvas on destruction.
     
        deleteBars();
        for (int i = 0; i < (int)m_staffLines.size(); ++i) clearStaffLineRow(i);
    */
}

void
LinedStaff::initCursors()
{
    QPen pen(GUIPalette::getColour(GUIPalette::Pointer));
    pen.setWidth(pointerWidth);

    m_pointer->setPen(pen);
    m_pointer->setBrush(GUIPalette::getColour(GUIPalette::Pointer));

    pen.setColor(GUIPalette::getColour(GUIPalette::InsertCursor));

    m_insertCursor->setPen(pen);
    m_insertCursor->setBrush(GUIPalette::getColour(GUIPalette::InsertCursor));
}

void
LinedStaff::setResolution(int resolution)
{
    m_resolution = resolution;
}

void
LinedStaff::setLineThickness(int lineThickness)
{
    m_lineThickness = lineThickness;
}

void
LinedStaff::setPageMode(PageMode pageMode)
{
    m_pageMode = pageMode;
}

void
LinedStaff::setPageWidth(double pageWidth)
{
    m_pageWidth = pageWidth;
}

void
LinedStaff::setRowsPerPage(int rowsPerPage)
{
    m_rowsPerPage = rowsPerPage;
}

void
LinedStaff::setRowSpacing(int rowSpacing)
{
    m_rowSpacing = rowSpacing;
}

void
LinedStaff::setConnectingLineLength(int connectingLineLength)
{
    m_connectingLineLength = connectingLineLength;
}

int
LinedStaff::getId() const
{
    return m_id;
}

void
LinedStaff::setX(double x)
{
    m_x = x;
}

double
LinedStaff::getX() const
{
    return m_x;
}

void
LinedStaff::setY(int y)
{
    m_y = y;
}

int
LinedStaff::getY() const
{
    return m_y;
}

void
LinedStaff::setMargin(double margin)
{
    m_margin = margin;
}

double
LinedStaff::getMargin() const
{
    if (m_pageMode != MultiPageMode)
        return 0;
    return m_margin;
}

void
LinedStaff::setTitleHeight(int titleHeight)
{
    m_titleHeight = titleHeight;
}

int
LinedStaff::getTitleHeight() const
{
    return m_titleHeight;
}

double
LinedStaff::getTotalWidth() const
{
    switch (m_pageMode) {

    case ContinuousPageMode:
        return getCanvasXForRightOfRow(getRowForLayoutX(m_endLayoutX)) - m_x;

    case MultiPageMode:
        return getCanvasXForRightOfRow(getRowForLayoutX(m_endLayoutX)) + m_margin - m_x;

    case LinearMode:
    default:
        return getCanvasXForLayoutX(m_endLayoutX) - m_x;
    }
}

int
LinedStaff::getTotalHeight() const
{
    switch (m_pageMode) {

    case ContinuousPageMode:
        return getCanvasYForTopOfStaff(getRowForLayoutX(m_endLayoutX)) +
               getHeightOfRow() - m_y;

    case MultiPageMode:
        return getCanvasYForTopOfStaff(m_rowsPerPage - 1) +
               getHeightOfRow() - m_y;

    case LinearMode:
    default:
        return getCanvasYForTopOfStaff(0) + getHeightOfRow() - m_y;
    }
}

int
LinedStaff::getHeightOfRow() const
{
    return getTopLineOffset() + getLegerLineCount() * getLineSpacing()
           + getBarLineHeight() + m_lineThickness;
}

bool
LinedStaff::containsCanvasCoords(double x, int y) const
{
    switch (m_pageMode) {

    case ContinuousPageMode:

        for (int row = getRowForLayoutX(m_startLayoutX);
                row <= getRowForLayoutX(m_endLayoutX); ++row) {
            if (y >= getCanvasYForTopOfStaff(row) &&
                    y < getCanvasYForTopOfStaff(row) + getHeightOfRow()) {
                return true;
            }
        }

        return false;

    case MultiPageMode:

        for (int row = getRowForLayoutX(m_startLayoutX);
                row <= getRowForLayoutX(m_endLayoutX); ++row) {
            if (y >= getCanvasYForTopOfStaff(row) &&
                    y < getCanvasYForTopOfStaff(row) + getHeightOfRow() &&
                    x >= getCanvasXForLeftOfRow(row) &&
                    x <= getCanvasXForRightOfRow(row)) {
                return true;
            }
        }

        return false;

    case LinearMode:
    default:

        return (y >= getCanvasYForTopOfStaff() &&
                y < getCanvasYForTopOfStaff() + getHeightOfRow());
    }
}

int
LinedStaff::getCanvasYForHeight(int h, double baseX, int baseY) const
{
    int y;

    //    NOTATION_DEBUG << "LinedStaff::getCanvasYForHeight(" << h << "," << baseY
    //		   << ")" << endl;

    if (baseX < 0)
        baseX = getX() + getMargin();

    if (baseY >= 0) {
        y = getCanvasYForTopLine(getRowForCanvasCoords(baseX, baseY));
    } else {
        y = getCanvasYForTopLine();
    }

    y += getLayoutYForHeight(h);

    return y;
}

int
LinedStaff::getLayoutYForHeight(int h) const
{
    int y = ((getTopLineHeight() - h) * getLineSpacing()) / getHeightPerLine();
    if (h < getTopLineHeight() && (h % getHeightPerLine() != 0))
        ++y;

    return y;
}

int
LinedStaff::getHeightAtCanvasCoords(double x, int y) const
{
    //!!! the lazy route: approximate, then get the right value
    // by calling getCanvasYForHeight a few times... ugh

    //    RG_DEBUG << "\nNotationStaff::heightOfYCoord: y = " << y
    //                         << ", getTopLineOffset() = " << getTopLineOffset()
    //                         << ", getLineSpacing() = " << m_npf->getLineSpacing()
    //                         << endl;

    if (x < 0)
        x = getX() + getMargin();

    int row = getRowForCanvasCoords(x, y);
    int ph = (y - getCanvasYForTopLine(row)) * getHeightPerLine() /
             getLineSpacing();
    ph = getTopLineHeight() - ph;

    int i;
    int mi = -2;
    int md = getLineSpacing() * 2;

    int testi = -2;