LoweBowe/MuseScore
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
MuseScore/libmscore/note.cpp

2958 lines
117 KiB
C++
Raw Normal View History

Initial commit
2012-05-26 14:26:10 +02:00
//=============================================================================
// MuseScore
// Music Composition & Notation
//
changes in rendermidi implementation
2012-11-19 09:29:46 +01:00
// Copyright (C) 2002-2012 Werner Schweer
Initial commit
2012-05-26 14:26:10 +02:00
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2
// as published by the Free Software Foundation and appearing in
// the file LICENCE.GPL
//=============================================================================
some layout optimizations/claenups
2015-02-19 10:28:25 +01:00
Initial commit
2012-05-26 14:26:10 +02:00
/**
\file
Implementation of classes Note and ShadowNote.
*/
#include <assert.h>
#include "note.h"
#include "score.h"
#include "chord.h"
#include "sym.h"
#include "xml.h"
#include "slur.h"
updates&fixes for tie editing
2013-08-22 12:18:14 +02:00
#include "tie.h"
Initial commit
2012-05-26 14:26:10 +02:00
#include "text.h"
#include "clef.h"
#include "staff.h"
#include "pitchspelling.h"
#include "arpeggio.h"
#include "tremolo.h"
#include "utils.h"
#include "image.h"
#include "system.h"
#include "tuplet.h"
#include "articulation.h"
#include "drumset.h"
#include "segment.h"
#include "measure.h"
#include "undo.h"
#include "part.h"
#include "stafftype.h"
Finish renaming of Tablature class to StringData Renames also the files hoding the class itself: - libmscore/tablature.cpp => stringdata.cpp - libmscore/tablature.h => stringdata.h No actual change in the code, only updated references to stringdata.h in #include's.
2013-12-05 21:37:28 +01:00
#include "stringdata.h"
Initial commit
2012-05-26 14:26:10 +02:00
#include "fret.h"
#include "harmony.h"
#include "fingering.h"
#include "bend.h"
#include "accidental.h"
#include "page.h"
#include "icon.h"
#include "notedot.h"
implement textline with note anchors
2012-09-12 16:19:03 +02:00
#include "spanner.h"
Enforced default gliss. for TAB (straight line, no text) when it is dropped on the note, no longer altering it during layout/drawing
2012-12-11 20:37:35 +01:00
#include "glissando.h"
Framework for bagpipe palette
2013-08-01 22:24:36 +02:00
#include "bagpembell.h"
enable double click on palette to add hairpins
2014-12-16 18:07:51 +01:00
#include "hairpin.h"
fix #122551 Text line: inability to delete or change the 'Begin' text
2016-08-30 14:03:26 +02:00
#include "textline.h"
Initial commit
2012-05-26 14:26:10 +02:00
add namespace Ms
2013-05-13 18:49:17 +02:00
namespace Ms {
Initial commit
2012-05-26 14:26:10 +02:00
//---------------------------------------------------------
// noteHeads
Fix #100396: change "note heads" to "noteheads" See http://music.stackexchange.com/questions/42722/notehead-or-note-head (also correct "fo" to "for" in comment)
2016-05-03 01:21:42 +02:00
// notehead groups
Initial commit
2012-05-26 14:26:10 +02:00
//---------------------------------------------------------
move NoteHeadType to NoteHead::Type needed to make it available to the plugin framework
2014-06-25 22:01:26 +02:00
static const SymId noteHeads[2][int(NoteHead::Group::HEAD_GROUPS)][int(NoteHead::Type::HEAD_TYPES)] = {
A proposal for aligning note heads to SMUFL conventions. It should re-enable all the note head functionality as per ver. 1.3, with most (all?) equal results. - No new glyph added to font(s) - Existing mscore glyphs have been matched to SMUFL note head symbols: -- partly on similarity of shape -- partly on similarity of semantics (in particular most of the noteDo..., noteRe..., ... heads) - The dropped HEAD_BREVIS_ALT note head group have been re-instated (dropping it was a regression from 1.3) - fonts/mscore/glyphnames.json has been updated - fonts/mscore/metadata.json has NOT been updated (I have not understood its contents) It may be improved incrementally, should the need arise.
2013-11-15 11:18:16 +01:00
{ // down stem
cleanups for articulations
2016-09-30 18:07:19 +02:00
{ SymId::noteheadWhole, SymId::noteheadHalf, SymId::noteheadBlack, SymId::noteheadDoubleWhole },
Add more noteheads and staff type for dynamic noteheads (shapes, notenames, etc...)
2016-10-22 20:16:42 +02:00
{ SymId::noteheadXWhole, SymId::noteheadXHalf, SymId::noteheadXBlack, SymId::noteheadXDoubleWhole },
{ SymId::noteheadPlusWhole, SymId::noteheadPlusHalf, SymId::noteheadPlusBlack, SymId::noteheadPlusDoubleWhole },
cleanups for articulations
2016-09-30 18:07:19 +02:00
{ SymId::noteheadCircleXWhole, SymId::noteheadCircleXHalf, SymId::noteheadCircleX, SymId::noteheadCircleXDoubleWhole},
Add more noteheads and staff type for dynamic noteheads (shapes, notenames, etc...)
2016-10-22 20:16:42 +02:00
{ SymId::noteheadWholeWithX, SymId::noteheadHalfWithX, SymId::noteheadVoidWithX, SymId::noteheadDoubleWholeWithX},
{ SymId::noteheadTriangleUpWhole, SymId::noteheadTriangleUpHalf, SymId::noteheadTriangleUpBlack, SymId::noteheadTriangleUpDoubleWhole },
{ SymId::noteheadTriangleDownWhole, SymId::noteheadTriangleDownHalf, SymId::noteheadTriangleDownBlack, SymId::noteheadTriangleDownDoubleWhole },
{ SymId::noteheadSlashedWhole1, SymId::noteheadSlashedHalf1, SymId::noteheadSlashedBlack1, SymId::noteheadSlashedDoubleWhole1 },
{ SymId::noteheadSlashedWhole2, SymId::noteheadSlashedHalf2, SymId::noteheadSlashedBlack2, SymId::noteheadSlashedDoubleWhole2 },
{ SymId::noteheadDiamondWhole, SymId::noteheadDiamondHalf, SymId::noteheadDiamondBlack, SymId::noteheadDiamondDoubleWhole },
{ SymId::noteheadDiamondWholeOld, SymId::noteheadDiamondHalfOld, SymId::noteheadDiamondBlackOld, SymId::noteheadDiamondDoubleWholeOld },
{ SymId::noteheadCircledWhole, SymId::noteheadCircledHalf, SymId::noteheadCircledBlack, SymId::noteheadCircledDoubleWhole },
{ SymId::noteheadCircledWholeLarge, SymId::noteheadCircledHalfLarge, SymId::noteheadCircledBlackLarge, SymId::noteheadCircledDoubleWholeLarge },
{ SymId::noteheadLargeArrowUpWhole, SymId::noteheadLargeArrowUpHalf, SymId::noteheadLargeArrowUpBlack, SymId::noteheadLargeArrowUpDoubleWhole },
cleanups for articulations
2016-09-30 18:07:19 +02:00
{ SymId::noteheadWhole, SymId::noteheadHalf, SymId::noteheadBlack, SymId::noteheadDoubleWholeSquare },
rename Xml() -> XmlWriter()
2016-11-19 11:51:21 +01:00
Add more noteheads and staff type for dynamic noteheads (shapes, notenames, etc...)
2016-10-22 20:16:42 +02:00
{ SymId::noteheadSlashWhiteWhole, SymId::noteheadSlashWhiteHalf, SymId::noteheadSlashHorizontalEnds, SymId::noteheadSlashWhiteWhole},
rename Xml() -> XmlWriter()
2016-11-19 11:51:21 +01:00
Add more noteheads and staff type for dynamic noteheads (shapes, notenames, etc...)
2016-10-22 20:16:42 +02:00
{ SymId::noteShapeRoundWhite, SymId::noteShapeRoundWhite, SymId::noteShapeRoundBlack, SymId::noteShapeRoundDoubleWhole },
{ SymId::noteShapeSquareWhite, SymId::noteShapeSquareWhite, SymId::noteShapeSquareBlack, SymId::noteShapeSquareDoubleWhole },
{ SymId::noteShapeTriangleRightWhite, SymId::noteShapeTriangleRightWhite, SymId::noteShapeTriangleRightBlack, SymId::noteShapeTriangleRightDoubleWhole },
{ SymId::noteShapeDiamondWhite, SymId::noteShapeDiamondWhite, SymId::noteShapeDiamondBlack, SymId::noteShapeDiamondDoubleWhole },
{ SymId::noteShapeTriangleUpWhite, SymId::noteShapeTriangleUpWhite, SymId::noteShapeTriangleUpBlack, SymId::noteShapeTriangleUpDoubleWhole },
{ SymId::noteShapeMoonWhite, SymId::noteShapeMoonWhite, SymId::noteShapeMoonBlack, SymId::noteShapeMoonDoubleWhole },
{ SymId::noteShapeTriangleRoundWhite, SymId::noteShapeTriangleRoundWhite, SymId::noteShapeTriangleRoundBlack, SymId::noteShapeTriangleRoundDoubleWhole },
rename Xml() -> XmlWriter()
2016-11-19 11:51:21 +01:00
Add more noteheads and staff type for dynamic noteheads (shapes, notenames, etc...)
2016-10-22 20:16:42 +02:00
{ SymId::noteShapeKeystoneWhite, SymId::noteShapeKeystoneWhite, SymId::noteShapeKeystoneBlack, SymId::noteShapeKeystoneDoubleWhole },
{ SymId::noteShapeQuarterMoonWhite, SymId::noteShapeQuarterMoonWhite, SymId::noteShapeQuarterMoonBlack, SymId::noteShapeQuarterMoonDoubleWhole },
{ SymId::noteShapeIsoscelesTriangleWhite, SymId::noteShapeIsoscelesTriangleWhite, SymId::noteShapeIsoscelesTriangleBlack, SymId::noteShapeIsoscelesTriangleDoubleWhole },
{ SymId::noteShapeMoonLeftWhite, SymId::noteShapeMoonLeftWhite, SymId::noteShapeMoonLeftBlack, SymId::noteShapeMoonLeftDoubleWhole },
{ SymId::noteShapeArrowheadLeftWhite, SymId::noteShapeArrowheadLeftWhite, SymId::noteShapeArrowheadLeftBlack, SymId::noteShapeArrowheadLeftDoubleWhole },
{ SymId::noteShapeTriangleRoundLeftWhite, SymId::noteShapeTriangleRoundLeftWhite, SymId::noteShapeTriangleRoundLeftBlack, SymId::noteShapeTriangleRoundLeftDoubleWhole },
rename Xml() -> XmlWriter()
2016-11-19 11:51:21 +01:00
Add more noteheads and staff type for dynamic noteheads (shapes, notenames, etc...)
2016-10-22 20:16:42 +02:00
{ SymId::noteDoWhole, SymId::noteDoHalf, SymId::noteDoBlack, SymId::noSym },
{ SymId::noteReWhole, SymId::noteReHalf, SymId::noteReBlack, SymId::noSym },
{ SymId::noteMiWhole, SymId::noteMiHalf, SymId::noteMiBlack, SymId::noSym },
{ SymId::noteFaWhole, SymId::noteFaHalf, SymId::noteFaBlack, SymId::noSym },
{ SymId::noteSoWhole, SymId::noteSoHalf, SymId::noteSoBlack, SymId::noSym },
{ SymId::noteLaWhole, SymId::noteLaHalf, SymId::noteLaBlack, SymId::noSym },
{ SymId::noteTiWhole, SymId::noteTiHalf, SymId::noteTiBlack, SymId::noSym },
{ SymId::noteSiWhole, SymId::noteSiHalf, SymId::noteSiBlack, SymId::noSym },
rename Xml() -> XmlWriter()
2016-11-19 11:51:21 +01:00
Add more noteheads and staff type for dynamic noteheads (shapes, notenames, etc...)
2016-10-22 20:16:42 +02:00
{ SymId::noteASharpWhole, SymId::noteASharpHalf, SymId::noteASharpBlack, SymId::noSym },
{ SymId::noteAWhole, SymId::noteAHalf, SymId::noteABlack, SymId::noSym },
{ SymId::noteAFlatWhole, SymId::noteAFlatHalf, SymId::noteAFlatBlack, SymId::noSym },
{ SymId::noteBSharpWhole, SymId::noteBSharpHalf, SymId::noteBSharpBlack, SymId::noSym },
{ SymId::noteBWhole, SymId::noteBHalf, SymId::noteBBlack, SymId::noSym },
{ SymId::noteBFlatWhole, SymId::noteBFlatHalf, SymId::noteBFlatBlack, SymId::noSym },
{ SymId::noteCSharpWhole, SymId::noteCSharpHalf, SymId::noteCSharpBlack, SymId::noSym },
{ SymId::noteCWhole, SymId::noteCHalf, SymId::noteCBlack, SymId::noSym },
{ SymId::noteCFlatWhole, SymId::noteCFlatHalf, SymId::noteCFlatBlack, SymId::noSym },
{ SymId::noteDSharpWhole, SymId::noteDSharpHalf, SymId::noteDSharpBlack, SymId::noSym },
{ SymId::noteDWhole, SymId::noteDHalf, SymId::noteDBlack, SymId::noSym },
{ SymId::noteDFlatWhole, SymId::noteDFlatHalf, SymId::noteDFlatBlack, SymId::noSym },
{ SymId::noteESharpWhole, SymId::noteESharpHalf, SymId::noteESharpBlack, SymId::noSym },
{ SymId::noteEWhole, SymId::noteEHalf, SymId::noteEBlack, SymId::noSym },
{ SymId::noteEFlatWhole, SymId::noteEFlatHalf, SymId::noteEFlatBlack, SymId::noSym },
{ SymId::noteFSharpWhole, SymId::noteFSharpHalf, SymId::noteFSharpBlack, SymId::noSym },
{ SymId::noteFWhole, SymId::noteFHalf, SymId::noteFBlack, SymId::noSym },
{ SymId::noteFFlatWhole, SymId::noteFFlatHalf, SymId::noteFFlatBlack, SymId::noSym },
{ SymId::noteGSharpWhole, SymId::noteGSharpHalf, SymId::noteGSharpBlack, SymId::noSym },
{ SymId::noteGWhole, SymId::noteGHalf, SymId::noteGBlack, SymId::noSym },
{ SymId::noteGFlatWhole, SymId::noteGFlatHalf, SymId::noteGFlatBlack, SymId::noSym },
{ SymId::noteHWhole, SymId::noteHHalf, SymId::noteHBlack, SymId::noSym },
{ SymId::noteHSharpWhole, SymId::noteHSharpHalf, SymId::noteHSharpBlack, SymId::noSym }
A proposal for aligning note heads to SMUFL conventions. It should re-enable all the note head functionality as per ver. 1.3, with most (all?) equal results. - No new glyph added to font(s) - Existing mscore glyphs have been matched to SMUFL note head symbols: -- partly on similarity of shape -- partly on similarity of semantics (in particular most of the noteDo..., noteRe..., ... heads) - The dropped HEAD_BREVIS_ALT note head group have been re-instated (dropping it was a regression from 1.3) - fonts/mscore/glyphnames.json has been updated - fonts/mscore/metadata.json has NOT been updated (I have not understood its contents) It may be improved incrementally, should the need arise.
2013-11-15 11:18:16 +01:00
},
{ // up stem
cleanups for articulations
2016-09-30 18:07:19 +02:00
{ SymId::noteheadWhole, SymId::noteheadHalf, SymId::noteheadBlack, SymId::noteheadDoubleWhole },
Add more noteheads and staff type for dynamic noteheads (shapes, notenames, etc...)
2016-10-22 20:16:42 +02:00
{ SymId::noteheadXWhole, SymId::noteheadXHalf, SymId::noteheadXBlack, SymId::noteheadXDoubleWhole },
{ SymId::noteheadPlusWhole, SymId::noteheadPlusHalf, SymId::noteheadPlusBlack, SymId::noteheadPlusDoubleWhole },
cleanups for articulations
2016-09-30 18:07:19 +02:00
{ SymId::noteheadCircleXWhole, SymId::noteheadCircleXHalf, SymId::noteheadCircleX, SymId::noteheadCircleXDoubleWhole},
Add more noteheads and staff type for dynamic noteheads (shapes, notenames, etc...)
2016-10-22 20:16:42 +02:00
{ SymId::noteheadWholeWithX, SymId::noteheadHalfWithX, SymId::noteheadVoidWithX, SymId::noteheadDoubleWholeWithX},
{ SymId::noteheadTriangleUpWhole, SymId::noteheadTriangleUpHalf, SymId::noteheadTriangleUpBlack, SymId::noteheadTriangleUpDoubleWhole },
{ SymId::noteheadTriangleDownWhole, SymId::noteheadTriangleDownHalf, SymId::noteheadTriangleDownBlack, SymId::noteheadTriangleDownDoubleWhole },
{ SymId::noteheadSlashedWhole1, SymId::noteheadSlashedHalf1, SymId::noteheadSlashedBlack1, SymId::noteheadSlashedDoubleWhole1 },
{ SymId::noteheadSlashedWhole2, SymId::noteheadSlashedHalf2, SymId::noteheadSlashedBlack2, SymId::noteheadSlashedDoubleWhole2 },
{ SymId::noteheadDiamondWhole, SymId::noteheadDiamondHalf, SymId::noteheadDiamondBlack, SymId::noteheadDiamondDoubleWhole },
{ SymId::noteheadDiamondWholeOld, SymId::noteheadDiamondHalfOld, SymId::noteheadDiamondBlackOld, SymId::noteheadDiamondDoubleWholeOld },
{ SymId::noteheadCircledWhole, SymId::noteheadCircledHalf, SymId::noteheadCircledBlack, SymId::noteheadCircledDoubleWhole },
{ SymId::noteheadCircledWholeLarge, SymId::noteheadCircledHalfLarge, SymId::noteheadCircledBlackLarge, SymId::noteheadCircledDoubleWholeLarge },
// different from down, find source?
{ SymId::noteheadLargeArrowDownWhole, SymId::noteheadLargeArrowDownHalf, SymId::noteheadLargeArrowDownBlack, SymId::noteheadLargeArrowDownDoubleWhole },
cleanups for articulations
2016-09-30 18:07:19 +02:00
{ SymId::noteheadWhole, SymId::noteheadHalf, SymId::noteheadBlack, SymId::noteheadDoubleWholeSquare },
rename Xml() -> XmlWriter()
2016-11-19 11:51:21 +01:00
Add more noteheads and staff type for dynamic noteheads (shapes, notenames, etc...)
2016-10-22 20:16:42 +02:00
{ SymId::noteheadSlashWhiteWhole, SymId::noteheadSlashWhiteHalf, SymId::noteheadSlashHorizontalEnds, SymId::noteheadSlashWhiteDoubleWhole},
rename Xml() -> XmlWriter()
2016-11-19 11:51:21 +01:00
Add more noteheads and staff type for dynamic noteheads (shapes, notenames, etc...)
2016-10-22 20:16:42 +02:00
{ SymId::noteShapeRoundWhite, SymId::noteShapeRoundWhite, SymId::noteShapeRoundBlack, SymId::noteShapeRoundDoubleWhole },
{ SymId::noteShapeSquareWhite, SymId::noteShapeSquareWhite, SymId::noteShapeSquareBlack, SymId::noteShapeSquareDoubleWhole },
// different from down
{ SymId::noteShapeTriangleLeftWhite, SymId::noteShapeTriangleLeftWhite, SymId::noteShapeTriangleLeftBlack, SymId::noteShapeTriangleLeftDoubleWhole },
{ SymId::noteShapeDiamondWhite, SymId::noteShapeDiamondWhite, SymId::noteShapeDiamondBlack, SymId::noteShapeDiamondDoubleWhole },
{ SymId::noteShapeTriangleUpWhite, SymId::noteShapeTriangleUpWhite, SymId::noteShapeTriangleUpBlack, SymId::noteShapeTriangleUpDoubleWhole },
{ SymId::noteShapeMoonWhite, SymId::noteShapeMoonWhite, SymId::noteShapeMoonBlack, SymId::noteShapeMoonDoubleWhole },
{ SymId::noteShapeTriangleRoundWhite, SymId::noteShapeTriangleRoundWhite, SymId::noteShapeTriangleRoundBlack, SymId::noteShapeTriangleRoundDoubleWhole },
rename Xml() -> XmlWriter()
2016-11-19 11:51:21 +01:00
Add more noteheads and staff type for dynamic noteheads (shapes, notenames, etc...)
2016-10-22 20:16:42 +02:00
{ SymId::noteShapeKeystoneWhite, SymId::noteShapeKeystoneWhite, SymId::noteShapeKeystoneBlack, SymId::noteShapeKeystoneDoubleWhole },
{ SymId::noteShapeQuarterMoonWhite, SymId::noteShapeQuarterMoonWhite, SymId::noteShapeQuarterMoonBlack, SymId::noteShapeQuarterMoonDoubleWhole },
{ SymId::noteShapeIsoscelesTriangleWhite, SymId::noteShapeIsoscelesTriangleWhite, SymId::noteShapeIsoscelesTriangleBlack, SymId::noteShapeIsoscelesTriangleDoubleWhole },
{ SymId::noteShapeMoonLeftWhite, SymId::noteShapeMoonLeftWhite, SymId::noteShapeMoonLeftBlack, SymId::noteShapeMoonLeftDoubleWhole },
{ SymId::noteShapeArrowheadLeftWhite, SymId::noteShapeArrowheadLeftWhite, SymId::noteShapeArrowheadLeftBlack, SymId::noteShapeArrowheadLeftDoubleWhole },
{ SymId::noteShapeTriangleRoundLeftWhite, SymId::noteShapeTriangleRoundLeftWhite, SymId::noteShapeTriangleRoundLeftBlack, SymId::noteShapeTriangleRoundLeftDoubleWhole },
rename Xml() -> XmlWriter()
2016-11-19 11:51:21 +01:00
Add more noteheads and staff type for dynamic noteheads (shapes, notenames, etc...)
2016-10-22 20:16:42 +02:00
{ SymId::noteDoWhole, SymId::noteDoHalf, SymId::noteDoBlack, SymId::noSym },
{ SymId::noteReWhole, SymId::noteReHalf, SymId::noteReBlack, SymId::noSym },
{ SymId::noteMiWhole, SymId::noteMiHalf, SymId::noteMiBlack, SymId::noSym },
{ SymId::noteFaWhole, SymId::noteFaHalf, SymId::noteFaBlack, SymId::noSym },
{ SymId::noteSoWhole, SymId::noteSoHalf, SymId::noteSoBlack, SymId::noSym },
{ SymId::noteLaWhole, SymId::noteLaHalf, SymId::noteLaBlack, SymId::noSym },
{ SymId::noteTiWhole, SymId::noteTiHalf, SymId::noteTiBlack, SymId::noSym },
{ SymId::noteSiWhole, SymId::noteSiHalf, SymId::noteSiBlack, SymId::noSym },
rename Xml() -> XmlWriter()
2016-11-19 11:51:21 +01:00
Add more noteheads and staff type for dynamic noteheads (shapes, notenames, etc...)
2016-10-22 20:16:42 +02:00
{ SymId::noteASharpWhole, SymId::noteASharpHalf, SymId::noteASharpBlack, SymId::noSym },
{ SymId::noteAWhole, SymId::noteAHalf, SymId::noteABlack, SymId::noSym },
{ SymId::noteAFlatWhole, SymId::noteAFlatHalf, SymId::noteAFlatBlack, SymId::noSym },
{ SymId::noteBSharpWhole, SymId::noteBSharpHalf, SymId::noteBSharpBlack, SymId::noSym },
{ SymId::noteBWhole, SymId::noteBHalf, SymId::noteBBlack, SymId::noSym },
{ SymId::noteBFlatWhole, SymId::noteBFlatHalf, SymId::noteBFlatBlack, SymId::noSym },
{ SymId::noteCSharpWhole, SymId::noteCSharpHalf, SymId::noteCSharpBlack, SymId::noSym },
{ SymId::noteCWhole, SymId::noteCHalf, SymId::noteCBlack, SymId::noSym },
{ SymId::noteCFlatWhole, SymId::noteCFlatHalf, SymId::noteCFlatBlack, SymId::noSym },
{ SymId::noteDSharpWhole, SymId::noteDSharpHalf, SymId::noteDSharpBlack, SymId::noSym },
{ SymId::noteDWhole, SymId::noteDHalf, SymId::noteDBlack, SymId::noSym },
{ SymId::noteDFlatWhole, SymId::noteDFlatHalf, SymId::noteDFlatBlack, SymId::noSym },
{ SymId::noteESharpWhole, SymId::noteESharpHalf, SymId::noteESharpBlack, SymId::noSym },
{ SymId::noteEWhole, SymId::noteEHalf, SymId::noteEBlack, SymId::noSym },
{ SymId::noteEFlatWhole, SymId::noteEFlatHalf, SymId::noteEFlatBlack, SymId::noSym },
{ SymId::noteFSharpWhole, SymId::noteFSharpHalf, SymId::noteFSharpBlack, SymId::noSym },
{ SymId::noteFWhole, SymId::noteFHalf, SymId::noteFBlack, SymId::noSym },
{ SymId::noteFFlatWhole, SymId::noteFFlatHalf, SymId::noteFFlatBlack, SymId::noSym },
{ SymId::noteGSharpWhole, SymId::noteGSharpHalf, SymId::noteGSharpBlack, SymId::noSym },
{ SymId::noteGWhole, SymId::noteGHalf, SymId::noteGBlack, SymId::noSym },
{ SymId::noteGFlatWhole, SymId::noteGFlatHalf, SymId::noteGFlatBlack, SymId::noSym },
{ SymId::noteHWhole, SymId::noteHHalf, SymId::noteHBlack, SymId::noSym },
{ SymId::noteHSharpWhole, SymId::noteHSharpHalf, SymId::noteHSharpBlack, SymId::noSym }
rename Xml() -> XmlWriter()
2016-11-19 11:51:21 +01:00
A proposal for aligning note heads to SMUFL conventions. It should re-enable all the note head functionality as per ver. 1.3, with most (all?) equal results. - No new glyph added to font(s) - Existing mscore glyphs have been matched to SMUFL note head symbols: -- partly on similarity of shape -- partly on similarity of semantics (in particular most of the noteDo..., noteRe..., ... heads) - The dropped HEAD_BREVIS_ALT note head group have been re-instated (dropping it was a regression from 1.3) - fonts/mscore/glyphnames.json has been updated - fonts/mscore/metadata.json has NOT been updated (I have not understood its contents) It may be improved incrementally, should the need arise.
2013-11-15 11:18:16 +01:00
}
};
Initial commit
2012-05-26 14:26:10 +02:00
Change storage of notehead type and group in notes
2016-10-18 09:21:54 +02:00
struct NoteHeadName {
const char* name;
const char* username;
};
fix #29546: translate noteheadnames in inspector too
2014-08-13 11:22:21 +02:00
// same order as NoteHead::Group
Change storage of notehead type and group in notes
2016-10-18 09:21:54 +02:00
static NoteHeadName noteHeadGroupNames[] = {
Add more noteheads and staff type for dynamic noteheads (shapes, notenames, etc...)
2016-10-22 20:16:42 +02:00
{"normal", QT_TRANSLATE_NOOP("noteheadnames", "Normal") },
{"cross", QT_TRANSLATE_NOOP("noteheadnames", "Cross") },
{"plus", QT_TRANSLATE_NOOP("noteheadnames", "Plus") },
{"xcircle", QT_TRANSLATE_NOOP("noteheadnames", "XCircle") },
{"withx", QT_TRANSLATE_NOOP("noteheadnames", "With X") },
{"triangle-up", QT_TRANSLATE_NOOP("noteheadnames", "Triangle Up") },
{"triangle-down", QT_TRANSLATE_NOOP("noteheadnames", "Triangle Down") },
fix #147196: Minimum width of Inspector has increased significantly esp. note and ambitus inspector, due to these long names for note head groups
2016-11-29 17:02:18 +01:00
{"slashed1", QT_TRANSLATE_NOOP("noteheadnames", "Slashed (Forwards)") },
{"slashed2", QT_TRANSLATE_NOOP("noteheadnames", "Slashed (Backwards)") },
Add more noteheads and staff type for dynamic noteheads (shapes, notenames, etc...)
2016-10-22 20:16:42 +02:00
{"diamond", QT_TRANSLATE_NOOP("noteheadnames", "Diamond") },
{"diamond-old", QT_TRANSLATE_NOOP("noteheadnames", "Diamond (Old)") },
{"circled", QT_TRANSLATE_NOOP("noteheadnames", "Circled") },
{"circled-large", QT_TRANSLATE_NOOP("noteheadnames", "Circled Large") },
{"large-arrow", QT_TRANSLATE_NOOP("noteheadnames", "Large Arrow") },
{"altbrevis", QT_TRANSLATE_NOOP("noteheadnames", "Alt. Brevis") },
rename Xml() -> XmlWriter()
2016-11-19 11:51:21 +01:00
Change storage of notehead type and group in notes
2016-10-18 09:21:54 +02:00
{"slash", QT_TRANSLATE_NOOP("noteheadnames", "Slash") },
rename Xml() -> XmlWriter()
2016-11-19 11:51:21 +01:00
Add more noteheads and staff type for dynamic noteheads (shapes, notenames, etc...)
2016-10-22 20:16:42 +02:00
// shape notes
{"sol", QT_TRANSLATE_NOOP("noteheadnames", "Sol") },
{"la", QT_TRANSLATE_NOOP("noteheadnames", "La") },
{"fa", QT_TRANSLATE_NOOP("noteheadnames", "Fa") },
{"mi", QT_TRANSLATE_NOOP("noteheadnames", "Mi") },
Change storage of notehead type and group in notes
2016-10-18 09:21:54 +02:00
{"do", QT_TRANSLATE_NOOP("noteheadnames", "Do") },
{"re", QT_TRANSLATE_NOOP("noteheadnames", "Re") },
{"ti", QT_TRANSLATE_NOOP("noteheadnames", "Ti") },
rename Xml() -> XmlWriter()
2016-11-19 11:51:21 +01:00
Add more noteheads and staff type for dynamic noteheads (shapes, notenames, etc...)
2016-10-22 20:16:42 +02:00
// not exposed
{"do-walker", QT_TRANSLATE_NOOP("noteheadnames", "Do (Walker)") },
{"re-walker", QT_TRANSLATE_NOOP("noteheadnames", "Re (Walker)") },
{"ti-walker", QT_TRANSLATE_NOOP("noteheadnames", "Ti (Walker)") },
{"do-funk", QT_TRANSLATE_NOOP("noteheadnames", "Do (Funk)") },
{"re-funk", QT_TRANSLATE_NOOP("noteheadnames", "Re (Funk)") },
{"ti-funk", QT_TRANSLATE_NOOP("noteheadnames", "Ti (Funk)") },
rename Xml() -> XmlWriter()
2016-11-19 11:51:21 +01:00
Add more noteheads and staff type for dynamic noteheads (shapes, notenames, etc...)
2016-10-22 20:16:42 +02:00
// note name
{"do-name", QT_TRANSLATE_NOOP("noteheadnames", "Do (Name)") },
{"re-name", QT_TRANSLATE_NOOP("noteheadnames", "Re (Name)") },
{"mi-name", QT_TRANSLATE_NOOP("noteheadnames", "Mi (Name)") },
{"fa-name", QT_TRANSLATE_NOOP("noteheadnames", "Fa (Name)") },
{"sol-name", QT_TRANSLATE_NOOP("noteheadnames", "Sol (Name)") },
{"la-name", QT_TRANSLATE_NOOP("noteheadnames", "La (Name)") },
{"ti-name", QT_TRANSLATE_NOOP("noteheadnames", "Ti (Name)") },
{"si-name", QT_TRANSLATE_NOOP("noteheadnames", "Si (Name)") },
rename Xml() -> XmlWriter()
2016-11-19 11:51:21 +01:00
Add more noteheads and staff type for dynamic noteheads (shapes, notenames, etc...)
2016-10-22 20:16:42 +02:00
{"a-sharp-name", QT_TRANSLATE_NOOP("noteheadnames", "A Sharp (Name)") },
{"a-name", QT_TRANSLATE_NOOP("noteheadnames", "A (Name)") },
{"a-flat-name", QT_TRANSLATE_NOOP("noteheadnames", "A Flat (Name)") },
{"b-sharp-name", QT_TRANSLATE_NOOP("noteheadnames", "B Sharp (Name)") },
{"b-name", QT_TRANSLATE_NOOP("noteheadnames", "B (Name)") },
{"b-flat-name", QT_TRANSLATE_NOOP("noteheadnames", "B Flat (Name)") },
{"c-sharp-name", QT_TRANSLATE_NOOP("noteheadnames", "C Sharp (Name)") },
{"c-name", QT_TRANSLATE_NOOP("noteheadnames", "C (Name)") },
{"c-flat-name", QT_TRANSLATE_NOOP("noteheadnames", "C Flat (Name)") },
{"d-sharp-name", QT_TRANSLATE_NOOP("noteheadnames", "D Sharp (Name)") },
{"d-name", QT_TRANSLATE_NOOP("noteheadnames", "D (Name)") },
{"d-flat-name", QT_TRANSLATE_NOOP("noteheadnames", "D Flat (Name)") },
{"e-sharp-name", QT_TRANSLATE_NOOP("noteheadnames", "E Sharp (Name)") },
{"e-name", QT_TRANSLATE_NOOP("noteheadnames", "E (Name)") },
{"e-flat-name", QT_TRANSLATE_NOOP("noteheadnames", "E Flat (Name)") },
{"f-sharp-name", QT_TRANSLATE_NOOP("noteheadnames", "F Sharp (Name)") },
{"f-name", QT_TRANSLATE_NOOP("noteheadnames", "F (Name)") },
{"f-flat-name", QT_TRANSLATE_NOOP("noteheadnames", "F Flat (Name)") },
{"g-sharp-name", QT_TRANSLATE_NOOP("noteheadnames", "G Sharp (Name)") },
{"g-name", QT_TRANSLATE_NOOP("noteheadnames", "G (Name)") },
{"g-flat-name", QT_TRANSLATE_NOOP("noteheadnames", "G Flat (Name)") },
{"h-name", QT_TRANSLATE_NOOP("noteheadnames", "H (Name)") },
{"h-sharp-name", QT_TRANSLATE_NOOP("noteheadnames", "H Sharp (Name)") }
Change storage of notehead type and group in notes
2016-10-18 09:21:54 +02:00
};
// same order as NoteHead::Type
static NoteHeadName noteHeadTypeNames[] = {
{"auto", QT_TRANSLATE_NOOP("noteheadnames", "Auto") },
{"whole", QT_TRANSLATE_NOOP("noteheadnames", "Whole") },
{"half", QT_TRANSLATE_NOOP("noteheadnames", "Half") },
{"quarter", QT_TRANSLATE_NOOP("noteheadnames", "Quarter") },
{"breve", QT_TRANSLATE_NOOP("noteheadnames", "Breve") },
cleanups for articulations
2016-09-30 18:07:19 +02:00
};
Moved note head names from inspector.ui to note.h
2014-07-22 14:26:24 +02:00
Change storage of notehead type and group in notes
2016-10-18 09:21:54 +02:00
//---------------------------------------------------------
// group2userName
//---------------------------------------------------------
QString NoteHead::group2userName(NoteHead::Group group)
{
return qApp->translate("noteheadnames", noteHeadGroupNames[int(group)].username);
}
//---------------------------------------------------------
// type2userName
//---------------------------------------------------------
QString NoteHead::type2userName(NoteHead::Type type)
{
return qApp->translate("noteheadnames", noteHeadTypeNames[int(type) + 1].username);
}
//---------------------------------------------------------
// group2name
//---------------------------------------------------------
QString NoteHead::group2name(NoteHead::Group group)
{
return noteHeadGroupNames[int(group)].name;
}
//---------------------------------------------------------
// type2name
//---------------------------------------------------------
QString NoteHead::type2name(NoteHead::Type type)
{
return noteHeadTypeNames[int(type) + 1].name;
}
//---------------------------------------------------------
// name2group
//---------------------------------------------------------
NoteHead::Group NoteHead::name2group(QString s)
{
for (int i = 0; i < int(NoteHead::Group::HEAD_GROUPS); ++i) {
if (noteHeadGroupNames[i].name == s)
return NoteHead::Group(i);
}
return NoteHead::Group::HEAD_NORMAL;
}
//---------------------------------------------------------
// name2type
//---------------------------------------------------------
NoteHead::Type NoteHead::name2type(QString s)
{
for (int i = 0; i <= int(NoteHead::Type::HEAD_TYPES); ++i) {
if (noteHeadTypeNames[i].name == s)
return NoteHead::Type(i - 1);
}
return NoteHead::Type::HEAD_AUTO;
}
Initial commit
2012-05-26 14:26:10 +02:00
//---------------------------------------------------------
hide noteHeads array
2013-11-25 15:42:40 +01:00
// noteHead
Initial commit
2012-05-26 14:26:10 +02:00
//---------------------------------------------------------
Add more noteheads and staff type for dynamic noteheads (shapes, notenames, etc...)
2016-10-22 20:16:42 +02:00
SymId Note::noteHead(int direction, NoteHead::Group group, NoteHead::Type t)
{
return noteHeads[direction][int(group)][int(t)];
}
SymId Note::noteHead(int direction, NoteHead::Group group, NoteHead::Type t, int tpc, Key key, NoteHeadScheme scheme)
hide noteHeads array
2013-11-25 15:42:40 +01:00
{
Add more noteheads and staff type for dynamic noteheads (shapes, notenames, etc...)
2016-10-22 20:16:42 +02:00
// shortcut
if (scheme == NoteHeadScheme::HEAD_NORMAL)
return noteHeads[direction][int(group)][int(t)];
// other schemes
if (scheme == NoteHeadScheme::HEAD_PITCHNAME || scheme == NoteHeadScheme::HEAD_PITCHNAME_GERMAN) {
if (tpc == Tpc::TPC_A)
group = NoteHead::Group::HEAD_A;
else if (tpc == Tpc::TPC_B) {
if (scheme == NoteHeadScheme::HEAD_PITCHNAME_GERMAN)
group = NoteHead::Group::HEAD_H;
else
group = NoteHead::Group::HEAD_B;
}
else if (tpc == Tpc::TPC_C)
group = NoteHead::Group::HEAD_C;
else if (tpc == Tpc::TPC_D)
group = NoteHead::Group::HEAD_D;
else if (tpc == Tpc::TPC_E)
group = NoteHead::Group::HEAD_E;
else if (tpc == Tpc::TPC_F)
group = NoteHead::Group::HEAD_F;
else if (tpc == Tpc::TPC_G)
group = NoteHead::Group::HEAD_G;
else if (tpc == Tpc::TPC_A_S)
group = NoteHead::Group::HEAD_A_SHARP;
else if (tpc == Tpc::TPC_B_S)
if (scheme == NoteHeadScheme::HEAD_PITCHNAME_GERMAN)
group = NoteHead::Group::HEAD_H_SHARP;
else
group = NoteHead::Group::HEAD_B_SHARP;
else if (tpc == Tpc::TPC_C_S)
group = NoteHead::Group::HEAD_C_SHARP;
else if (tpc == Tpc::TPC_D_S)
group = NoteHead::Group::HEAD_D_SHARP;
else if (tpc == Tpc::TPC_E_S)
group = NoteHead::Group::HEAD_E_SHARP;
else if (tpc == Tpc::TPC_F_S)
group = NoteHead::Group::HEAD_F_SHARP;
else if (tpc == Tpc::TPC_G_S)
group = NoteHead::Group::HEAD_G_SHARP;
else if (tpc == Tpc::TPC_A_B)
group = NoteHead::Group::HEAD_A_FLAT;
else if (tpc == Tpc::TPC_B_B)
if (scheme == NoteHeadScheme::HEAD_PITCHNAME_GERMAN)
group = NoteHead::Group::HEAD_B;
else
group = NoteHead::Group::HEAD_B_FLAT;
else if (tpc == Tpc::TPC_C_B)
group = NoteHead::Group::HEAD_C_FLAT;
else if (tpc == Tpc::TPC_D_B)
group = NoteHead::Group::HEAD_D_FLAT;
else if (tpc == Tpc::TPC_E_B)
group = NoteHead::Group::HEAD_E_FLAT;
else if (tpc == Tpc::TPC_F_B)
group = NoteHead::Group::HEAD_F_FLAT;
else if (tpc == Tpc::TPC_G_B)
group = NoteHead::Group::HEAD_G_FLAT;
}
else if (scheme == NoteHeadScheme::HEAD_SHAPE_NOTE_4) {
int degree = tpc2degree(tpc, key);
switch (degree) {
case 0:
case 3:
group = NoteHead::Group::HEAD_FA; break;
case 1:
case 4:
group = NoteHead::Group::HEAD_SOL; break;
case 2:
case 5:
group = NoteHead::Group::HEAD_LA; break;
case 6:
group = NoteHead::Group::HEAD_MI; break;
}
}
else if (scheme == NoteHeadScheme::HEAD_SHAPE_NOTE_7_AIKIN
|| scheme == NoteHeadScheme::HEAD_SHAPE_NOTE_7_FUNK
|| scheme == NoteHeadScheme::HEAD_SHAPE_NOTE_7_WALKER) {
int degree = tpc2degree(tpc, key);
switch (degree) {
case 0:
if (scheme == NoteHeadScheme::HEAD_SHAPE_NOTE_7_AIKIN)
group = NoteHead::Group::HEAD_DO;
else if (scheme == NoteHeadScheme::HEAD_SHAPE_NOTE_7_FUNK)
group = NoteHead::Group::HEAD_DO_FUNK;
else if (scheme == NoteHeadScheme::HEAD_SHAPE_NOTE_7_WALKER)
group = NoteHead::Group::HEAD_DO_WALKER;
break;
case 1:
if (scheme == NoteHeadScheme::HEAD_SHAPE_NOTE_7_AIKIN)
group = NoteHead::Group::HEAD_RE;
else if (scheme == NoteHeadScheme::HEAD_SHAPE_NOTE_7_FUNK)
group = NoteHead::Group::HEAD_RE_FUNK;
else if (scheme == NoteHeadScheme::HEAD_SHAPE_NOTE_7_WALKER)
group = NoteHead::Group::HEAD_RE_WALKER;
break;
case 2:
group = NoteHead::Group::HEAD_MI; break;
case 3:
group = NoteHead::Group::HEAD_FA; break;
case 4:
group = NoteHead::Group::HEAD_SOL; break;
case 5:
group = NoteHead::Group::HEAD_LA; break;
case 6:
if (scheme == NoteHeadScheme::HEAD_SHAPE_NOTE_7_AIKIN)
group = NoteHead::Group::HEAD_TI;
else if (scheme == NoteHeadScheme::HEAD_SHAPE_NOTE_7_FUNK)
group = NoteHead::Group::HEAD_TI_FUNK;
else if (scheme == NoteHeadScheme::HEAD_SHAPE_NOTE_7_WALKER)
group = NoteHead::Group::HEAD_TI_WALKER;
break;
}
}
else if (scheme == NoteHeadScheme::HEAD_SOLFEGE) {
int degree = tpc2degree(tpc, key);
switch (degree) {
case 0:
group = NoteHead::Group::HEAD_DO_NAME; break;
case 1:
group = NoteHead::Group::HEAD_RE_NAME; break;
case 2:
group = NoteHead::Group::HEAD_MI_NAME; break;
case 3:
group = NoteHead::Group::HEAD_FA_NAME; break;
case 4:
group = NoteHead::Group::HEAD_SOL_NAME; break;
case 5:
group = NoteHead::Group::HEAD_LA_NAME; break;
case 6:
group = NoteHead::Group::HEAD_TI_NAME; break;
}
}
else if (scheme == NoteHeadScheme::HEAD_SOLFEGE_FIXED) {
QString stepName = tpc2stepName(tpc);
if (stepName == "C")
group = NoteHead::Group::HEAD_DO_NAME;
else if (stepName == "D")
group = NoteHead::Group::HEAD_RE_NAME;
else if (stepName == "E")
group = NoteHead::Group::HEAD_MI_NAME;
else if (stepName == "F")
group = NoteHead::Group::HEAD_FA_NAME;
else if (stepName == "G")
group = NoteHead::Group::HEAD_SOL_NAME;
else if (stepName == "A")
group = NoteHead::Group::HEAD_LA_NAME;
else if (stepName == "B")
group = NoteHead::Group::HEAD_SI_NAME;
}
return noteHeads[direction][int(group)][int(t)];
hide noteHeads array
2013-11-25 15:42:40 +01:00
};
Initial commit
2012-05-26 14:26:10 +02:00
add ScoreFont to Symbol class; extend master palette symbols dialog; misc cleanups
2013-11-25 15:02:23 +01:00
//---------------------------------------------------------
// headGroup
Change storage of notehead type and group in notes
2016-10-18 09:21:54 +02:00
// used only when dropping a notehead from the palette
// they are either half note, either double whole
add ScoreFont to Symbol class; extend master palette symbols dialog; misc cleanups
2013-11-25 15:02:23 +01:00
//---------------------------------------------------------
move NoteHeadGroup to NoteHead::Group needed to make it available to the plugin framework
2014-06-25 21:18:26 +02:00
NoteHead::Group NoteHead::headGroup() const
add ScoreFont to Symbol class; extend master palette symbols dialog; misc cleanups
2013-11-25 15:02:23 +01:00
{
move NoteHeadGroup to NoteHead::Group needed to make it available to the plugin framework
2014-06-25 21:18:26 +02:00
Group group = Group::HEAD_INVALID;
Add more noteheads and staff type for dynamic noteheads (shapes, notenames, etc...)
2016-10-22 20:16:42 +02:00
for (int i = 0; i < int(Group::HEAD_DO_WALKER); ++i) {
add ScoreFont to Symbol class; extend master palette symbols dialog; misc cleanups
2013-11-25 15:02:23 +01:00
if (noteHeads[0][i][1] == _sym || noteHeads[0][i][3] == _sym) {
move NoteHeadGroup to NoteHead::Group needed to make it available to the plugin framework
2014-06-25 21:18:26 +02:00
group = (Group)i;
add ScoreFont to Symbol class; extend master palette symbols dialog; misc cleanups
2013-11-25 15:02:23 +01:00
break;
}
}
return group;
}
Initial commit
2012-05-26 14:26:10 +02:00
//---------------------------------------------------------
// Note
//---------------------------------------------------------
Note::Note(Score* s)
: Element(s)
{
improve enum ElementFlag more work needed to convert it into a class, same issue as with ArticulationShowIn.
2014-05-22 10:10:58 +02:00
setFlags(ElementFlag::MOVABLE | ElementFlag::SELECTABLE);
changes in rendermidi implementation
2012-11-19 09:29:46 +01:00
_playEvents.append(NoteEvent()); // add default play event
Add more noteheads and staff type for dynamic noteheads (shapes, notenames, etc...)
2016-10-22 20:16:42 +02:00
_cachedNoteheadSym = SymId::noSym;
_cachedSymNull = SymId::noSym;
Initial commit
2012-05-26 14:26:10 +02:00
}
Note::~Note()
{
delete _accidental;
changes in rendermidi implementation
2012-11-19 09:29:46 +01:00
qDeleteAll(_el);
Initial commit
2012-05-26 14:26:10 +02:00
delete _tieFor;
some layout optimizations/claenups
2015-02-19 10:28:25 +01:00
qDeleteAll(_dots);
Initial commit
2012-05-26 14:26:10 +02:00
}
link note attached elements for parts
2014-07-10 18:59:44 +02:00
Note::Note(const Note& n, bool link)
Initial commit
2012-05-26 14:26:10 +02:00
: Element(n)
{
link note attached elements for parts
2014-07-10 18:59:44 +02:00
if (link)
fix undo of linked staff addition when part is present
2016-03-24 08:29:17 +01:00
score()->undo(new Link(const_cast<Note*>(&n), this));
Initial commit
2012-05-26 14:26:10 +02:00
_subchannel = n._subchannel;
_line = n._line;
_fret = n._fret;
_string = n._string;
_fretConflict = n._fretConflict;
_ghost = n._ghost;
dragMode = n.dragMode;
_pitch = n._pitch;
implement separate tpc values for transposed view
2014-04-09 09:40:25 +02:00
_tpc[0] = n._tpc[0];
_tpc[1] = n._tpc[1];
fix #29421
2014-08-13 16:36:09 +02:00
_dotsHidden = n._dotsHidden;
Initial commit
2012-05-26 14:26:10 +02:00
_hidden = n._hidden;
add play property for note; fix slur editing
2013-08-23 13:55:54 +02:00
_play = n._play;
Initial commit
2012-05-26 14:26:10 +02:00
_tuning = n._tuning;
_veloType = n._veloType;
_veloOffset = n._veloOffset;
_headGroup = n._headGroup;
_headType = n._headType;
_mirror = n._mirror;
_userMirror = n._userMirror;
_small = n._small;
manually merge PR #797 and PR#808
2014-04-02 20:31:37 +02:00
_userDotPosition = n._userDotPosition;
fix #8924: native support for slash notation
2014-11-15 21:28:16 +01:00
_fixed = n._fixed;
_fixedLine = n._fixedLine;
Initial commit
2012-05-26 14:26:10 +02:00
_accidental = 0;
replace some qt container with hand crafted single linked list
2013-01-03 16:56:56 +01:00
Initial commit
2012-05-26 14:26:10 +02:00
if (n._accidental)
add(new Accidental(*(n._accidental)));
link note attached elements for parts
2014-07-10 18:59:44 +02:00
// types in _el: SYMBOL, IMAGE, FINGERING, TEXT, BEND
for (Element* e : n._el) {
fingering layout update; fixed layout bugs
2017-01-19 16:06:40 +01:00
if (e->isFingering() && staff()->isTabStaff(tick())) // tablature has no fingering
continue;
link note attached elements for parts
2014-07-10 18:59:44 +02:00
Element* ce = e->clone();
add(ce);
if (link)
fix undo of linked staff addition when part is present
2016-03-24 08:29:17 +01:00
score()->undo(new Link(const_cast<Element*>(e), ce));
link note attached elements for parts
2014-07-10 18:59:44 +02:00
}
cleanups
2013-03-25 16:27:20 +01:00
changes in rendermidi implementation
2012-11-19 09:29:46 +01:00
_playEvents = n._playEvents;
Initial commit
2012-05-26 14:26:10 +02:00
if (n._tieFor) {
_tieFor = new Tie(*n._tieFor);
_tieFor->setStartNote(this);
_tieFor->setEndNote(0);
}
else
_tieFor = 0;
_tieBack = 0;
Layout reorganization
2016-01-04 14:48:58 +01:00
for (NoteDot* dot : n._dots)
add(new NoteDot(*dot));
Initial commit
2012-05-26 14:26:10 +02:00
_lineOffset = n._lineOffset;
sequencer update
2013-02-20 17:53:15 +01:00
_mark = n._mark;
Initial commit
2012-05-26 14:26:10 +02:00
}
implement separate tpc values for transposed view
2014-04-09 09:40:25 +02:00
//---------------------------------------------------------
// concertPitchIdx
//---------------------------------------------------------
inline int Note::concertPitchIdx() const
{
return concertPitch() ? 0 : 1;
}
Initial commit
2012-05-26 14:26:10 +02:00
//---------------------------------------------------------
// setPitch
//---------------------------------------------------------
void Note::setPitch(int val)
{
bug fixes for concert pitch switch
2014-04-09 16:09:21 +02:00
Q_ASSERT(val >= 0 && val <= 127);
if (_pitch != val) {
_pitch = val;
cleanup for score dirty status
2015-01-30 17:03:51 +01:00
score()->setPlaylistDirty();
Initial commit
2012-05-26 14:26:10 +02:00
}
}
implement separate tpc values for transposed view
2014-04-09 09:40:25 +02:00
void Note::setPitch(int pitch, int tpc1, int tpc2)
Initial commit
2012-05-26 14:26:10 +02:00
{
fix last commit
2014-04-09 11:11:02 +02:00
Q_ASSERT(tpcIsValid(tpc1));
Q_ASSERT(tpcIsValid(tpc2));
implement separate tpc values for transposed view
2014-04-09 09:40:25 +02:00
_tpc[0] = tpc1;
_tpc[1] = tpc2;
fix last commit
2014-04-09 11:11:02 +02:00
setPitch(pitch);
Initial commit
2012-05-26 14:26:10 +02:00
}
make setTpc() and setPitch() for note in plugin undoable
2012-07-16 20:21:31 +02:00
//---------------------------------------------------------
// undoSetPitch
//---------------------------------------------------------
void Note::undoSetPitch(int p)
{
inspector updates; misc. cleanups
2016-06-09 09:26:13 +02:00
undoChangeProperty(P_ID::PITCH, p);
make setTpc() and setPitch() for note in plugin undoable
2012-07-16 20:21:31 +02:00
}
fixes for transposing instruments
2014-04-10 13:13:37 +02:00
//---------------------------------------------------------
// tpc1default
//---------------------------------------------------------
int Note::tpc1default(int p) const
{
stronger typing for key
2014-06-20 17:07:22 +02:00
Key key = Key::C;
fixes for transposing instruments
2014-04-10 13:13:37 +02:00
if (staff() && chord()) {
fix #9352: instrument change transposition
2015-09-21 02:13:22 +02:00
int tick = chord()->tick();
key = staff()->key(tick);
fixes for transposing instruments
2014-04-10 13:13:37 +02:00
if (!concertPitch()) {
fix #9352: instrument change transposition
2015-09-21 02:13:22 +02:00
Interval interval = part()->instrument(tick)->transpose();
fixes for transposing instruments
2014-04-10 13:13:37 +02:00
if (!interval.isZero()) {
interval.flip();
key = transposeKey(key, interval);
}
}
}
convert unnamed enum into enum class Prefer
2014-05-23 21:14:22 +02:00
return pitch2tpc(p, key, Prefer::NEAREST);
fixes for transposing instruments
2014-04-10 13:13:37 +02:00
}
//---------------------------------------------------------
// tpc2default
//---------------------------------------------------------
int Note::tpc2default(int p) const
{
stronger typing for key
2014-06-20 17:07:22 +02:00
Key key = Key::C;
fixes for transposing instruments
2014-04-10 13:13:37 +02:00
if (staff() && chord()) {
fix #9352: instrument change transposition
2015-09-21 02:13:22 +02:00
int tick = chord()->tick();
key = staff()->key(tick);
fixes for transposing instruments
2014-04-10 13:13:37 +02:00
if (concertPitch()) {
fix #9352: instrument change transposition
2015-09-21 02:13:22 +02:00
Interval interval = part()->instrument(tick)->transpose();
fixes for transposing instruments
2014-04-10 13:13:37 +02:00
if (!interval.isZero())
key = transposeKey(key, interval);
}
}
convert unnamed enum into enum class Prefer
2014-05-23 21:14:22 +02:00
return pitch2tpc(p - transposition(), key, Prefer::NEAREST);
fixes for transposing instruments
2014-04-10 13:13:37 +02:00
}
Initial commit
2012-05-26 14:26:10 +02:00
//---------------------------------------------------------
// setTpcFromPitch
//---------------------------------------------------------
void Note::setTpcFromPitch()
{
fix mtest
2015-01-17 23:32:14 +01:00
// works best if note is already added to score, otherwise we can't determine transposition or key
fix #9352: instrument change transposition
2015-09-21 02:13:22 +02:00
int tick = chord() ? chord()->tick() : -1;
Interval v = staff() ? part()->instrument(tick)->transpose() : Interval();
stronger typing for key
2014-06-20 17:07:22 +02:00
Key key = (staff() && chord()) ? staff()->key(chord()->tick()) : Key::C;
fix #44526: wrong spelling of grace note for transposing instrument
2015-01-17 17:38:51 +01:00
// convert key to concert pitch
if (!concertPitch() && !v.isZero())
key = transposeKey(key, v);
// set concert pitch tpc
convert unnamed enum into enum class Prefer
2014-05-23 21:14:22 +02:00
_tpc[0] = pitch2tpc(_pitch, key, Prefer::NEAREST);
fix #44526: wrong spelling of grace note for transposing instrument
2015-01-17 17:38:51 +01:00
// set transposed tpc
if (v.isZero())
_tpc[1] = _tpc[0];
else {
v.flip();
_tpc[1] = Ms::transposeTpc(_tpc[0], v, true);
}
fix last commit
2014-04-09 11:11:02 +02:00
Q_ASSERT(tpcIsValid(_tpc[0]));
Q_ASSERT(tpcIsValid(_tpc[1]));
Initial commit
2012-05-26 14:26:10 +02:00
}
//---------------------------------------------------------
// setTpc
//---------------------------------------------------------
void Note::setTpc(int v)
{
first fix for #18099
2014-04-02 18:11:56 +02:00
if (!tpcIsValid(v))
remove some unneeded '\n' and also fix a typo
2014-06-05 20:58:05 +02:00
qFatal("Note::setTpc: bad tpc %d", v);
implement separate tpc values for transposed view
2014-04-09 09:40:25 +02:00
_tpc[concertPitchIdx()] = v;
Initial commit
2012-05-26 14:26:10 +02:00
}
make setTpc() and setPitch() for note in plugin undoable
2012-07-16 20:21:31 +02:00
//---------------------------------------------------------
// undoSetTpc
implement separate tpc values for transposed view
2014-04-09 09:40:25 +02:00
// change the current tpc
make setTpc() and setPitch() for note in plugin undoable
2012-07-16 20:21:31 +02:00
//---------------------------------------------------------
implement separate tpc values for transposed view
2014-04-09 09:40:25 +02:00
void Note::undoSetTpc(int v)
make setTpc() and setPitch() for note in plugin undoable
2012-07-16 20:21:31 +02:00
{
implement separate tpc values for transposed view
2014-04-09 09:40:25 +02:00
if (concertPitch()) {
if (v != tpc1())
convert enum P_ID into enum class
2014-05-26 18:18:01 +02:00
undoChangeProperty(P_ID::TPC1, v);
implement separate tpc values for transposed view
2014-04-09 09:40:25 +02:00
}
else {
if (v != tpc2())
convert enum P_ID into enum class
2014-05-26 18:18:01 +02:00
undoChangeProperty(P_ID::TPC2, v);
implement separate tpc values for transposed view
2014-04-09 09:40:25 +02:00
}
}
//---------------------------------------------------------
// tpc
//---------------------------------------------------------
int Note::tpc() const
{
return _tpc[concertPitchIdx()];
make setTpc() and setPitch() for note in plugin undoable
2012-07-16 20:21:31 +02:00
}
some layout optimizations/claenups
2015-02-19 10:28:25 +01:00
//---------------------------------------------------------
// tpcUserName
//---------------------------------------------------------
code cleanups
2016-02-04 17:06:32 +01:00
QString Note::tpcUserName(bool explicitAccidental) const
Score accessibility system. Provides screen-reader feedback for the selected element.
2014-07-10 14:13:37 +02:00
{
add ability to turn off automatic capitalization of chord symbols
2014-12-17 18:15:26 +01:00
QString pitchName = tpc2name(tpc(), NoteSpellingType::STANDARD, NoteCaseType::AUTO, explicitAccidental);
fix #36621: display middle C as C4
2014-10-13 23:32:53 +02:00
QString octaveName = QString::number((pitch() / 12) - 1);
return pitchName + (explicitAccidental ? " " : "") + octaveName;
Score accessibility system. Provides screen-reader feedback for the selected element.
2014-07-10 14:13:37 +02:00
}
fix #25411
2014-04-23 11:08:51 +02:00
//---------------------------------------------------------
// transposeTpc
// return transposed tpc
// If in concertPitch mode return tpc for transposed view
// else return tpc for concert pitch view.
//---------------------------------------------------------
int Note::transposeTpc(int tpc)
{
fix #9352: instrument change transposition
2015-09-21 02:13:22 +02:00
int tick = chord() ? chord()->tick() : -1;
Interval v = part()->instrument(tick)->transpose();
fix #25411
2014-04-23 11:08:51 +02:00
if (v.isZero())
return tpc;
if (concertPitch()) {
v.flip();
fix #41766: use double sharp/flat where appropriate when transposing
2014-12-20 00:27:06 +01:00
return Ms::transposeTpc(tpc, v, true);
fix #25411
2014-04-23 11:08:51 +02:00
}
else
fix #41766: use double sharp/flat where appropriate when transposing
2014-12-20 00:27:06 +01:00
return Ms::transposeTpc(tpc, v, true);
fix #25411
2014-04-23 11:08:51 +02:00
}
Initial commit
2012-05-26 14:26:10 +02:00
//---------------------------------------------------------
// noteHead
//---------------------------------------------------------
smufl integration, part I
2013-11-06 15:58:05 +01:00
SymId Note::noteHead() const
Initial commit
2012-05-26 14:26:10 +02:00
{
add ScoreFont to Symbol class; extend master palette symbols dialog; misc cleanups
2013-11-25 15:02:23 +01:00
int up;
move NoteHeadType to NoteHead::Type needed to make it available to the plugin framework
2014-06-25 22:01:26 +02:00
NoteHead::Type ht;
Initial commit
2012-05-26 14:26:10 +02:00
if (chord()) {
A proposal for aligning note heads to SMUFL conventions. It should re-enable all the note head functionality as per ver. 1.3, with most (all?) equal results. - No new glyph added to font(s) - Existing mscore glyphs have been matched to SMUFL note head symbols: -- partly on similarity of shape -- partly on similarity of semantics (in particular most of the noteDo..., noteRe..., ... heads) - The dropped HEAD_BREVIS_ALT note head group have been re-instated (dropping it was a regression from 1.3) - fonts/mscore/glyphnames.json has been updated - fonts/mscore/metadata.json has NOT been updated (I have not understood its contents) It may be improved incrementally, should the need arise.
2013-11-15 11:18:16 +01:00
up = chord()->up();
Initial commit
2012-05-26 14:26:10 +02:00
ht = chord()->durationType().headType();
}
low level optimizations
2013-01-02 20:13:58 +01:00
else {
A proposal for aligning note heads to SMUFL conventions. It should re-enable all the note head functionality as per ver. 1.3, with most (all?) equal results. - No new glyph added to font(s) - Existing mscore glyphs have been matched to SMUFL note head symbols: -- partly on similarity of shape -- partly on similarity of semantics (in particular most of the noteDo..., noteRe..., ... heads) - The dropped HEAD_BREVIS_ALT note head group have been re-instated (dropping it was a regression from 1.3) - fonts/mscore/glyphnames.json has been updated - fonts/mscore/metadata.json has NOT been updated (I have not understood its contents) It may be improved incrementally, should the need arise.
2013-11-15 11:18:16 +01:00
up = 1;
move NoteHeadType to NoteHead::Type needed to make it available to the plugin framework
2014-06-25 22:01:26 +02:00
ht = NoteHead::Type::HEAD_QUARTER;
Initial commit
2012-05-26 14:26:10 +02:00
}
move NoteHeadType to NoteHead::Type needed to make it available to the plugin framework
2014-06-25 22:01:26 +02:00
if (_headType != NoteHead::Type::HEAD_AUTO)
check for bad note head types
2013-01-28 21:45:36 +01:00
ht = _headType;
Add more noteheads and staff type for dynamic noteheads (shapes, notenames, etc...)
2016-10-22 20:16:42 +02:00
Key key = Key::C;
NoteHeadScheme scheme = NoteHeadScheme::HEAD_NORMAL;
impl. staff type changes
2016-12-18 14:31:13 +01:00
if (chord() && chord()->staff()){
int tick = chord()->tick();
if (tick >= 0) {
key = chord()->staff()->key(tick);
scheme = chord()->staff()->staffType(tick)->noteHeadScheme();
}
Add more noteheads and staff type for dynamic noteheads (shapes, notenames, etc...)
2016-10-22 20:16:42 +02:00
}
SymId t = noteHead(up, _headGroup, ht, tpc(), key, scheme);
smufl integration, part I
2013-11-06 15:58:05 +01:00
if (t == SymId::noSym) {
Fix #100396: change "note heads" to "noteheads" See http://music.stackexchange.com/questions/42722/notehead-or-note-head (also correct "fo" to "for" in comment)
2016-05-03 01:21:42 +02:00
qDebug("invalid notehead %d/%d", int(_headGroup), int(ht));
move NoteHeadGroup to NoteHead::Group needed to make it available to the plugin framework
2014-06-25 21:18:26 +02:00
t = noteHead(up, NoteHead::Group::HEAD_NORMAL, ht);
check for bad note head types
2013-01-28 21:45:36 +01:00
}
return t;
Initial commit
2012-05-26 14:26:10 +02:00
}
//---------------------------------------------------------
// headWidth
Fix #19374 Wide (two-digit) numbers in TAB collide; fixed
2012-12-26 21:03:00 +01:00
//
Fix #100396: change "note heads" to "noteheads" See http://music.stackexchange.com/questions/42722/notehead-or-note-head (also correct "fo" to "for" in comment)
2016-05-03 01:21:42 +02:00
// returns the width of the notehead symbol
Fix #19374 Wide (two-digit) numbers in TAB collide; fixed
2012-12-26 21:03:00 +01:00
// or the width of the string representation of the fret mark
Initial commit
2012-05-26 14:26:10 +02:00
//---------------------------------------------------------
qreal Note::headWidth() const
{
smufl integration: articulation 2
2013-11-11 15:11:28 +01:00
return symWidth(noteHead());
Initial commit
2012-05-26 14:26:10 +02:00
}
some layout optimizations/claenups
2015-02-19 10:28:25 +01:00
//---------------------------------------------------------
// tabHeadWidth
//---------------------------------------------------------
remove stafftype subclasses
2014-04-28 18:38:50 +02:00
qreal Note::tabHeadWidth(StaffType* tab) const
Fix #19374 Wide (two-digit) numbers in TAB collide; fixed
2012-12-26 21:03:00 +01:00
{
qreal val;
if (tab && _fret != FRET_NONE && _string != STRING_NONE) {
fix #123466: Fret marks almost unreadable in Tabs
2016-09-04 12:00:01 +02:00
QFont f = tab->fretFont();
f.setPointSizeF(tab->fretFontSize());
QFontMetricsF fm(f, MScore::paintDevice());
fix #8924: native support for slash notation
2014-11-15 21:28:16 +01:00
QString s;
if (fixed())
s = "/";
else
TAB: Support for input and display of bass string notations Supports 'standard' configuration for bass string notations in historic tablatures (lutes and other plucked instruments, as well as viols), both of the French and of the Italian style. This should fill the last 'big hole' in historic TAB support. Bass strings (or bourdons) are extra strings in addition to the 6 'standard' strings, which are not represented by tab lines and were indicated by other typograhic devices in historic sources. Among the innumerable variations shown in sources, this implementation supports the following styles, chosen to be general enough to suit the majority of cases, without requiring new parameters in the TAB style dialogue box: - French: the first 4 bass courses are indicated by a fret mark in the 'seventh' TAB position (below bottom string) with 0, 1, 2 or 3 slashes prefixed; other bass courses are indicated, also in the 'seventh' TAB position, by the string number (from 4 on) and cannot contain a fret mark (as they didn't in historic sources). - Italian: the first 2 bass courses are indicated by a fret mark in the 'seventh' TAB position (abover top string) with 1 or 2 'ledger lines' underneath; other bass courses are indicated, also in the 'seventh' TAB position, by the string number (from 9 on) and cannot contain a fret mark (as they didn't in historic sources). Rhythm marks above these indication are raised to leave room for them. Both styles do not blindly assume that French style is top-to-bottom and Italian is 'upside-down' -- as historic sources are -- but adapt to the actual string order of the TAB. The choice between the two styles depends on the TAB using numbers or letters for the fret marks. The implementation does not try to detect if the TAB is really of a historic style and applies either bass string notation whenever more strings are used than there are TAB lines. If this proves unsuitable to modern usage, some better heuristics can probably be found. For a discussion and some screen shots, see: https://musescore.org/en/node/67261 **Note entry** During TAB note entry, if the instruments has more strings than the TAB has lines, the string cursor can be moved outside of the TAB body, one position below for 'top-to-bottom' TAB's and one position above for 'upside-down' TAB's. Further up or down movements add, to the 'blue cursor rectangle', markers indicating which is the actual target string (the cursor does not actually move), equal to the marks a note in that string will receive (slashes, ledger lines or string ordinal, according to the style and the string); during input the user will then receive the same info as when reading entered notes. Other Notes: - the `InputStatus::_string` variable, holding the current target TAB string in TAB note entry, changed meaning from the __visual__ string index to the __physical__ string index: this allows a better containment of the peculiarities of the individual TAB styles within the `StaffStyle` class, leaving other classes somehow freer of concern about TAB visual order and other peculiarities. As this variable is only used with TAB's, this change should not affect other functions. - Some calculation for rhythm symbols have been moved from `TabDurationSymbol::draw()` to `TabDurationSymbol::layout()`, hopefully speeding up the drawing process. - In fonts for historic styles, '10' has been replaced by 'X' both in fret numbers and in string ordinals, as this is more common in historic sources. Currently, this is not configurable; an additional style parameter could be added in future, if there will be enough request for it.
2015-07-06 17:40:02 +02:00
s = tab->fretString(_fret, _string, _ghost);
fix #123466: Fret marks almost unreadable in Tabs
2016-09-04 12:00:01 +02:00
val = fm.width(s) * magS();
fix grace note stem layout
2013-05-23 16:58:22 +02:00
}
Fix #19374 Wide (two-digit) numbers in TAB collide; fixed
2012-12-26 21:03:00 +01:00
else
Separated Note::tabHeadWidth() and Note::tabHeadHeight() methods for TAB's from generic Note::headWidth() and Note::headHeight()
2012-12-28 00:30:46 +01:00
val = headWidth();
Fix #19374 Wide (two-digit) numbers in TAB collide; fixed
2012-12-26 21:03:00 +01:00
return val;
Initial commit
2012-05-26 14:26:10 +02:00
}
//---------------------------------------------------------
// headHeight
Fix #19374 Wide (two-digit) numbers in TAB collide; fixed
2012-12-26 21:03:00 +01:00
//
Fix #100396: change "note heads" to "noteheads" See http://music.stackexchange.com/questions/42722/notehead-or-note-head (also correct "fo" to "for" in comment)
2016-05-03 01:21:42 +02:00
// returns the height of the notehead symbol
Fix #19374 Wide (two-digit) numbers in TAB collide; fixed
2012-12-26 21:03:00 +01:00
// or the height of the string representation of the fret mark
Initial commit
2012-05-26 14:26:10 +02:00
//---------------------------------------------------------
qreal Note::headHeight() const
{
smufl integration: articulation 2
2013-11-11 15:11:28 +01:00
return symHeight(noteHead());
Initial commit
2012-05-26 14:26:10 +02:00
}
remove stafftype subclasses
2014-04-28 18:38:50 +02:00
//---------------------------------------------------------
// tabHeadHeight
//---------------------------------------------------------
qreal Note::tabHeadHeight(StaffType* tab) const
Fix #19374 Wide (two-digit) numbers in TAB collide; fixed
2012-12-26 21:03:00 +01:00
{
some layout optimizations/claenups
2015-02-19 10:28:25 +01:00
if (tab && _fret != FRET_NONE && _string != STRING_NONE)
Fix #19374 Wide (two-digit) numbers in TAB collide; fixed
2012-12-26 21:03:00 +01:00
return tab->fretBoxH() * magS();
return headHeight();
}
fix stem layout; some optimizations
2013-01-02 09:29:17 +01:00
//---------------------------------------------------------
fix #59766: Stems do not align with DO and TI note head
2015-06-03 10:23:01 +02:00
// stemDownNW
fix stem layout; some optimizations
2013-01-02 09:29:17 +01:00
//---------------------------------------------------------
fix #59766: Stems do not align with DO and TI note head
2015-06-03 10:23:01 +02:00
QPointF Note::stemDownNW() const
fix stem layout; some optimizations
2013-01-02 09:29:17 +01:00
{
fix #59766: Stems do not align with DO and TI note head
2015-06-03 10:23:01 +02:00
return symStemDownNW(noteHead());
}
//---------------------------------------------------------
// stemUpSE
//---------------------------------------------------------
QPointF Note::stemUpSE() const
{
return symStemUpSE(noteHead());
fix stem layout; some optimizations
2013-01-02 09:29:17 +01:00
}
Initial commit
2012-05-26 14:26:10 +02:00
//---------------------------------------------------------
// playTicks
extend tie functionality
2013-05-12 12:43:22 +02:00
/// Return total tick len of tied notes
Initial commit
2012-05-26 14:26:10 +02:00
//---------------------------------------------------------
int Note::playTicks() const
{
fix #26531: Hang on up/down of note tied to itself
2015-01-28 15:20:33 +01:00
int stick = firstTiedNote()->chord()->tick();
const Note* note = lastTiedNote();
extend tie functionality
2013-05-12 12:43:22 +02:00
return note->chord()->tick() + note->chord()->actualTicks() - stick;
Initial commit
2012-05-26 14:26:10 +02:00
}
implement textline with note anchors
2012-09-12 16:19:03 +02:00
//---------------------------------------------------------
// addSpanner
//---------------------------------------------------------
void Note::addSpanner(Spanner* l)
{
preparations for new compatibility implementation
2016-09-13 09:39:50 +02:00
Element* e = l->endElement();
if (e && e->isNote()) {
Note* note = toNote(e);
note->addSpannerBack(l);
if (l->isGlissando())
note->chord()->setEndsGlissando(true);
Glissando as a multi-segment line. - Implemented as a sub-class of `SLine`. - Anchor type changed from CHORD to NOTE: allows to attach glissando start and end points to individual notes, rather than generically to chords (with note within the chord chosen by the program). - The Glissando element is now stored in the `Note::_spannerFor` list. - `Chord::_glissando` has been removed and replaced by a `bool _endsGlissando`, recording whether the chord is at the end of glissando (as gliss.-end chords require more space if mid-measure or system-initial). - Debugger UI for `Chord` updated accordingly. - Glissando in now save into score file as a spanner, within the initial note, and with appropriate `&lt;endSpanner&gt;` tag in the Glissando ending note. - Existing scores with the old Glissando file format are correctly read back. Notes: - MusicXML import/export of the new Glissando implementation NOT IMPLEMENTED. - This version can read scores from older versions, but older versions **cannot read** scored from this version (they do not expect a &lt;Glissando&gt; tag within a Note). Does this require a NEW FILE VERSION NUMBER? - This implementation would allow rather easily to move the start and end anchors around (as for slurs) to override the note/chord chosen by the program when the glissando is initially created; but the UI for this is not implemented yet.
2014-12-13 17:40:39 +01:00
}
replace some qt container with hand crafted single linked list
2013-01-03 16:56:56 +01:00
addSpannerFor(l);
implement textline with note anchors
2012-09-12 16:19:03 +02:00
}
//---------------------------------------------------------
// removeSpanner
//---------------------------------------------------------
void Note::removeSpanner(Spanner* l)
{
Glissando as a multi-segment line. - Implemented as a sub-class of `SLine`. - Anchor type changed from CHORD to NOTE: allows to attach glissando start and end points to individual notes, rather than generically to chords (with note within the chord chosen by the program). - The Glissando element is now stored in the `Note::_spannerFor` list. - `Chord::_glissando` has been removed and replaced by a `bool _endsGlissando`, recording whether the chord is at the end of glissando (as gliss.-end chords require more space if mid-measure or system-initial). - Debugger UI for `Chord` updated accordingly. - Glissando in now save into score file as a spanner, within the initial note, and with appropriate `&lt;endSpanner&gt;` tag in the Glissando ending note. - Existing scores with the old Glissando file format are correctly read back. Notes: - MusicXML import/export of the new Glissando implementation NOT IMPLEMENTED. - This version can read scores from older versions, but older versions **cannot read** scored from this version (they do not expect a &lt;Glissando&gt; tag within a Note). Does this require a NEW FILE VERSION NUMBER? - This implementation would allow rather easily to move the start and end anchors around (as for slurs) to override the note/chord chosen by the program when the glissando is initially created; but the UI for this is not implemented yet.
2014-12-13 17:40:39 +01:00
Note* e = static_cast<Note*>(l->endElement());
preparations for new compatibility implementation
2016-09-13 09:39:50 +02:00
if (e && e->isNote()) {
Glissando as a multi-segment line. - Implemented as a sub-class of `SLine`. - Anchor type changed from CHORD to NOTE: allows to attach glissando start and end points to individual notes, rather than generically to chords (with note within the chord chosen by the program). - The Glissando element is now stored in the `Note::_spannerFor` list. - `Chord::_glissando` has been removed and replaced by a `bool _endsGlissando`, recording whether the chord is at the end of glissando (as gliss.-end chords require more space if mid-measure or system-initial). - Debugger UI for `Chord` updated accordingly. - Glissando in now save into score file as a spanner, within the initial note, and with appropriate `&lt;endSpanner&gt;` tag in the Glissando ending note. - Existing scores with the old Glissando file format are correctly read back. Notes: - MusicXML import/export of the new Glissando implementation NOT IMPLEMENTED. - This version can read scores from older versions, but older versions **cannot read** scored from this version (they do not expect a &lt;Glissando&gt; tag within a Note). Does this require a NEW FILE VERSION NUMBER? - This implementation would allow rather easily to move the start and end anchors around (as for slurs) to override the note/chord chosen by the program when the glissando is initially created; but the UI for this is not implemented yet.
2014-12-13 17:40:39 +01:00
if (!e->removeSpannerBack(l)) {
qDebug("Note::removeSpanner(%p): cannot remove spannerBack %s %p", this, l->name(), l);
// abort();
}
preparations for new compatibility implementation
2016-09-13 09:39:50 +02:00
if (l->isGlissando())
Fixes #19155, #22861 (duplicate of the former) and #23100. __References__: Issues: https://musescore.org/en/node/19155 https://musescore.org/en/node/22861 https://musescore.org/en/node/23100 __Description__: Allows to change the start and end note to which a glissando is anchored after it has been entered. Either anchor can be changed independently. The user interface follows the current working of other 'snappable' lines. Once either the start or end grip is selected: - `[Shift]+[Left]` snaps the anchor to the previous chord, defaulting to its top note. - `[Shift]+[Right]` snaps to the next chord, defaulting to its top note. - `[Shift]+[Up]` snaps to the note above (possibly in a chord, voice or staff above the current one). - `[Shift]+[Down]` snaps to the note below (possibly in a chord, voice or staff below the current one). This permits to set the anchor points of a glissando to any note in the score, allowing several glissandi between the notes of the same two chords and other complex configurations (glissandi skipping intermediate chords, start and end notes in different voices or staves, and so on). It is possible to move the anchor to a different staff of the same instrument, but not to a different instrument; also, it is not possible to 'cross' a change of instrument in the same staff. __Known limitations__: - The `[Shift]+[Up]` and `[Shift]+[Down]` use the same note-finding functions as the `[Alt]+[Up]` and `[Alt]+[Down]`actions which move the selection cursor to the above and below note, even across voices or staves. Occasionally, in particular if the note immediately above or below is not time-aligned, the algorithm has little expected results; however, the behaviour is already known to the user. Improving the algorithm would benefit both uses. __Notes__: - Most of the added infrastructure is not specific to glissando but to any spanner anchored to notes, then it should also add after-the-fact "snap to" note support to note-anchored text line. - When moving an anchor, the algorithm usually prefers a note in the same voice/staff of the old note if it exists; if there is none, it tries other voices of the same staff. - The change of anchor is undoable. - The fix corrects the management of the `Chord::_endsGlissando` flag, taking into account that a chord can be the ending point of several glissandi and removing one of them not necessarily means the chord no longer ends a glissando (another glissando may still exists). - The fix also improved the rendering of the glissando wavy line, with better alignment with anchor notes and, with glissando text, better text-line spacing.
2015-08-06 11:11:16 +02:00
e->chord()->updateEndsGlissando();
implement textline with note anchors
2012-09-12 16:19:03 +02:00
}
replace some qt container with hand crafted single linked list
2013-01-03 16:56:56 +01:00
if (!removeSpannerFor(l)) {
qDebug("Note(%p): cannot remove spannerFor %s %p", this, l->name(), l);
implement textline with note anchors
2012-09-12 16:19:03 +02:00
// abort();
}
}
Initial commit
2012-05-26 14:26:10 +02:00
//---------------------------------------------------------
// add
//---------------------------------------------------------
void Note::add(Element* e)
{
fix #21861: note dot disappears if unison with two voices and a single dotted voice
2014-02-22 11:19:44 +01:00
e->setParent(this);
rename useTablature() -> isTabStaff(); more cleanups
2012-08-16 11:09:36 +02:00
e->setTrack(track());
Initial commit
2012-05-26 14:26:10 +02:00
switch(e->type()) {
move Element::type() to ScoreElement
2017-01-18 14:16:33 +01:00
case ElementType::NOTEDOT:
preparations for new compatibility implementation
2016-09-13 09:39:50 +02:00
_dots.append(toNoteDot(e));
Initial commit
2012-05-26 14:26:10 +02:00
break;
move Element::type() to ScoreElement
2017-01-18 14:16:33 +01:00
case ElementType::SYMBOL:
case ElementType::IMAGE:
case ElementType::FINGERING:
case ElementType::TEXT:
case ElementType::BEND:
cleanups
2013-03-25 16:27:20 +01:00
_el.push_back(e);
Initial commit
2012-05-26 14:26:10 +02:00
break;
move Element::type() to ScoreElement
2017-01-18 14:16:33 +01:00
case ElementType::TIE:
Initial commit
2012-05-26 14:26:10 +02:00
{
preparations for new compatibility implementation
2016-09-13 09:39:50 +02:00
Tie* tie = toTie(e);
whitespace cleanup
2014-05-30 13:35:44 +02:00
tie->setStartNote(this);
Initial commit
2012-05-26 14:26:10 +02:00
tie->setTrack(track());
whitespace cleanup
2014-05-30 13:35:44 +02:00
setTieFor(tie);
Initial commit
2012-05-26 14:26:10 +02:00
if (tie->endNote())
tie->endNote()->setTieBack(tie);
small low level optimizations
2013-01-30 17:50:01 +01:00
int n = tie->spannerSegments().size();
for (int i = 0; i < n; ++i) {
SpannerSegment* ss = tie->spannerSegments().at(i);
Initial commit
2012-05-26 14:26:10 +02:00
if (ss->system())
ss->system()->add(ss);
}
}
break;
move Element::type() to ScoreElement
2017-01-18 14:16:33 +01:00
case ElementType::ACCIDENTAL:
preparations for new compatibility implementation
2016-09-13 09:39:50 +02:00
_accidental = toAccidental(e);
Initial commit
2012-05-26 14:26:10 +02:00
break;
move Element::type() to ScoreElement
2017-01-18 14:16:33 +01:00
case ElementType::TEXTLINE:
case ElementType::GLISSANDO:
implement textline with note anchors
2012-09-12 16:19:03 +02:00
addSpanner(static_cast<Spanner*>(e));
break;
Initial commit
2012-05-26 14:26:10 +02:00
default:
eliminating needless \n in qDebug() calls searching for 'qDebug.*\\n\'
2014-03-25 13:33:47 +01:00
qDebug("Note::add() not impl. %s", e->name());
Initial commit
2012-05-26 14:26:10 +02:00
break;
}
framework for partial relayout
2016-03-02 13:20:19 +01:00
score()->setLayout(tick());
Initial commit
2012-05-26 14:26:10 +02:00
}
//---------------------------------------------------------
// remove
//---------------------------------------------------------
void Note::remove(Element* e)
{
switch(e->type()) {
move Element::type() to ScoreElement
2017-01-18 14:16:33 +01:00
case ElementType::NOTEDOT:
Layout reorganization
2016-01-04 14:48:58 +01:00
_dots.takeLast();
Initial commit
2012-05-26 14:26:10 +02:00
break;
move Element::type() to ScoreElement
2017-01-18 14:16:33 +01:00
case ElementType::TEXT:
case ElementType::SYMBOL:
case ElementType::IMAGE:
case ElementType::FINGERING:
case ElementType::BEND:
Initial commit
2012-05-26 14:26:10 +02:00
if (!_el.remove(e))
eliminating needless \n in qDebug() calls searching for 'qDebug.*\\n\'
2014-03-25 13:33:47 +01:00
qDebug("Note::remove(): cannot find %s", e->name());
Initial commit
2012-05-26 14:26:10 +02:00
break;
move Element::type() to ScoreElement
2017-01-18 14:16:33 +01:00
case ElementType::TIE:
Initial commit
2012-05-26 14:26:10 +02:00
{
preparations for new compatibility implementation
2016-09-13 09:39:50 +02:00
Tie* tie = toTie(e);
Initial commit
2012-05-26 14:26:10 +02:00
setTieFor(0);
fix #45601 changing note value can lead to missing accidentals; simplify layout()
2015-02-17 20:22:24 +01:00
if (tie->endNote())
Initial commit
2012-05-26 14:26:10 +02:00
tie->endNote()->setTieBack(0);
fix #48811 Redo Paste does not restore ties
2015-02-26 11:02:11 +01:00
for (SpannerSegment* ss : tie->spannerSegments()) {
Initial commit
2012-05-26 14:26:10 +02:00
Q_ASSERT(ss->spanner() == tie);
if (ss->system())
ss->system()->remove(ss);
}
}
break;
move Element::type() to ScoreElement
2017-01-18 14:16:33 +01:00
case ElementType::ACCIDENTAL:
Initial commit
2012-05-26 14:26:10 +02:00
_accidental = 0;
break;
move Element::type() to ScoreElement
2017-01-18 14:16:33 +01:00
case ElementType::TEXTLINE:
case ElementType::GLISSANDO:
implement textline with note anchors
2012-09-12 16:19:03 +02:00
removeSpanner(static_cast<Spanner*>(e));
break;
Initial commit
2012-05-26 14:26:10 +02:00
default:
eliminating needless \n in qDebug() calls searching for 'qDebug.*\\n\'
2014-03-25 13:33:47 +01:00
qDebug("Note::remove() not impl. %s", e->name());
Initial commit
2012-05-26 14:26:10 +02:00
break;
}
framework for partial relayout
2016-03-02 13:20:19 +01:00
score()->setLayout(tick());
Initial commit
2012-05-26 14:26:10 +02:00
}
Add more noteheads and staff type for dynamic noteheads (shapes, notenames, etc...)
2016-10-22 20:16:42 +02:00
//---------------------------------------------------------
// isNoteName
//---------------------------------------------------------
bool Note::isNoteName() const
{
fix #141561: crash when you try to notate with any percussion
2016-11-24 12:09:38 +01:00
if (chord() && chord()->staff()) {
change StaffType interface
2016-12-13 13:16:17 +01:00
NoteHeadScheme s = chord()->staff()->staffType(tick())->noteHeadScheme();
Add more noteheads and staff type for dynamic noteheads (shapes, notenames, etc...)
2016-10-22 20:16:42 +02:00
return s == NoteHeadScheme::HEAD_PITCHNAME || s == NoteHeadScheme::HEAD_PITCHNAME_GERMAN || s == NoteHeadScheme::HEAD_SOLFEGE || s == NoteHeadScheme::HEAD_SOLFEGE_FIXED;
}
return false;
}
Initial commit
2012-05-26 14:26:10 +02:00
//---------------------------------------------------------
// draw
//---------------------------------------------------------
void Note::draw(QPainter* painter) const
{
fix #16853: Note nudge is cancelled on redraw
2012-06-09 10:50:51 +02:00
if (_hidden)
return;
sequencer update
2013-02-20 17:53:15 +01:00
fix changing note head color
2013-03-07 21:00:22 +01:00
QColor c(curColor());
sequencer update
2013-02-20 17:53:15 +01:00
painter->setPen(c);
change StaffType interface
2016-12-13 13:16:17 +01:00
bool tablature = staff() && staff()->isTabStaff(chord()->tick());
Updated note.cpp, stafftype.cpp/.h and tab sample to use tab font style configuration
2012-08-17 00:33:38 +02:00
// tablature
fix #16853: Note nudge is cancelled on redraw
2012-06-09 10:50:51 +02:00
if (tablature) {
change StaffType interface
2016-12-13 13:16:17 +01:00
StaffType* tab = staff()->staffType(tick());
Fix #71931 - TAB: Option to show or hide back-tied notes __References__: - issue https://musescore.org/en/node/71931#comment-341166 - forum thread https://musescore.org/en/node/71886 Adds an option to the TAB staff type config. dlg box controlling whether back-tied notes are shown or not. Should maintain backward compatibility, as the value of this new staff type parameter is by default set to `~_slashStyle`, which was the original rule for this detail. Should also support forward compatibility, as the new staff type tag in score files would be simply ignored by older versions.
2015-08-25 08:11:01 +02:00
if (tieBack() && !tab->showBackTied()) // skip back-tied notes if not shown
Fix calc. of TAB symbols bbox Fix drawing of broken stems Improve kerning of multi-digit numbers
2012-09-21 18:31:31 +02:00
return;
fix #8924: native support for slash notation
2014-11-15 21:28:16 +01:00
QString s;
if (fixed())
s = "/";
else
TAB: Support for input and display of bass string notations Supports 'standard' configuration for bass string notations in historic tablatures (lutes and other plucked instruments, as well as viols), both of the French and of the Italian style. This should fill the last 'big hole' in historic TAB support. Bass strings (or bourdons) are extra strings in addition to the 6 'standard' strings, which are not represented by tab lines and were indicated by other typograhic devices in historic sources. Among the innumerable variations shown in sources, this implementation supports the following styles, chosen to be general enough to suit the majority of cases, without requiring new parameters in the TAB style dialogue box: - French: the first 4 bass courses are indicated by a fret mark in the 'seventh' TAB position (below bottom string) with 0, 1, 2 or 3 slashes prefixed; other bass courses are indicated, also in the 'seventh' TAB position, by the string number (from 4 on) and cannot contain a fret mark (as they didn't in historic sources). - Italian: the first 2 bass courses are indicated by a fret mark in the 'seventh' TAB position (abover top string) with 1 or 2 'ledger lines' underneath; other bass courses are indicated, also in the 'seventh' TAB position, by the string number (from 9 on) and cannot contain a fret mark (as they didn't in historic sources). Rhythm marks above these indication are raised to leave room for them. Both styles do not blindly assume that French style is top-to-bottom and Italian is 'upside-down' -- as historic sources are -- but adapt to the actual string order of the TAB. The choice between the two styles depends on the TAB using numbers or letters for the fret marks. The implementation does not try to detect if the TAB is really of a historic style and applies either bass string notation whenever more strings are used than there are TAB lines. If this proves unsuitable to modern usage, some better heuristics can probably be found. For a discussion and some screen shots, see: https://musescore.org/en/node/67261 **Note entry** During TAB note entry, if the instruments has more strings than the TAB has lines, the string cursor can be moved outside of the TAB body, one position below for 'top-to-bottom' TAB's and one position above for 'upside-down' TAB's. Further up or down movements add, to the 'blue cursor rectangle', markers indicating which is the actual target string (the cursor does not actually move), equal to the marks a note in that string will receive (slashes, ledger lines or string ordinal, according to the style and the string); during input the user will then receive the same info as when reading entered notes. Other Notes: - the `InputStatus::_string` variable, holding the current target TAB string in TAB note entry, changed meaning from the __visual__ string index to the __physical__ string index: this allows a better containment of the peculiarities of the individual TAB styles within the `StaffStyle` class, leaving other classes somehow freer of concern about TAB visual order and other peculiarities. As this variable is only used with TAB's, this change should not affect other functions. - Some calculation for rhythm symbols have been moved from `TabDurationSymbol::draw()` to `TabDurationSymbol::layout()`, hopefully speeding up the drawing process. - In fonts for historic styles, '10' has been replaced by 'X' both in fret numbers and in string ordinals, as this is more common in historic sources. Currently, this is not configurable; an additional style parameter could be added in future, if there will be enough request for it.
2015-07-06 17:40:02 +02:00
s = tab->fretString(_fret, _string, _ghost);
fix #16853: Note nudge is cancelled on redraw
2012-06-09 10:50:51 +02:00
TAB: Support for input and display of bass string notations Supports 'standard' configuration for bass string notations in historic tablatures (lutes and other plucked instruments, as well as viols), both of the French and of the Italian style. This should fill the last 'big hole' in historic TAB support. Bass strings (or bourdons) are extra strings in addition to the 6 'standard' strings, which are not represented by tab lines and were indicated by other typograhic devices in historic sources. Among the innumerable variations shown in sources, this implementation supports the following styles, chosen to be general enough to suit the majority of cases, without requiring new parameters in the TAB style dialogue box: - French: the first 4 bass courses are indicated by a fret mark in the 'seventh' TAB position (below bottom string) with 0, 1, 2 or 3 slashes prefixed; other bass courses are indicated, also in the 'seventh' TAB position, by the string number (from 4 on) and cannot contain a fret mark (as they didn't in historic sources). - Italian: the first 2 bass courses are indicated by a fret mark in the 'seventh' TAB position (abover top string) with 1 or 2 'ledger lines' underneath; other bass courses are indicated, also in the 'seventh' TAB position, by the string number (from 9 on) and cannot contain a fret mark (as they didn't in historic sources). Rhythm marks above these indication are raised to leave room for them. Both styles do not blindly assume that French style is top-to-bottom and Italian is 'upside-down' -- as historic sources are -- but adapt to the actual string order of the TAB. The choice between the two styles depends on the TAB using numbers or letters for the fret marks. The implementation does not try to detect if the TAB is really of a historic style and applies either bass string notation whenever more strings are used than there are TAB lines. If this proves unsuitable to modern usage, some better heuristics can probably be found. For a discussion and some screen shots, see: https://musescore.org/en/node/67261 **Note entry** During TAB note entry, if the instruments has more strings than the TAB has lines, the string cursor can be moved outside of the TAB body, one position below for 'top-to-bottom' TAB's and one position above for 'upside-down' TAB's. Further up or down movements add, to the 'blue cursor rectangle', markers indicating which is the actual target string (the cursor does not actually move), equal to the marks a note in that string will receive (slashes, ledger lines or string ordinal, according to the style and the string); during input the user will then receive the same info as when reading entered notes. Other Notes: - the `InputStatus::_string` variable, holding the current target TAB string in TAB note entry, changed meaning from the __visual__ string index to the __physical__ string index: this allows a better containment of the peculiarities of the individual TAB styles within the `StaffStyle` class, leaving other classes somehow freer of concern about TAB visual order and other peculiarities. As this variable is only used with TAB's, this change should not affect other functions. - Some calculation for rhythm symbols have been moved from `TabDurationSymbol::draw()` to `TabDurationSymbol::layout()`, hopefully speeding up the drawing process. - In fonts for historic styles, '10' has been replaced by 'X' both in fret numbers and in string ordinals, as this is more common in historic sources. Currently, this is not configurable; an additional style parameter could be added in future, if there will be enough request for it.
2015-07-06 17:40:02 +02:00
// draw background, if required (to hide a segment of string line or to show a fretting conflict)
fix #16853: Note nudge is cancelled on redraw
2012-06-09 10:50:51 +02:00
if (!tab->linesThrough() || fretConflict()) {
Fix calc. of TAB symbols bbox Fix drawing of broken stems Improve kerning of multi-digit numbers
2012-09-21 18:31:31 +02:00
qreal d = spatium() * .1;
fix #24580: Incorrect masking of fret mark
2014-08-07 17:39:31 +02:00
QRectF bb = QRectF(bbox().x()-d, tab->fretMaskY()*magS(), bbox().width() + 2*d, tab->fretMaskH()*magS());
fix #16853: Note nudge is cancelled on redraw
2012-06-09 10:50:51 +02:00
// we do not know which viewer did this draw() call
// so update all:
cross beam fixes
2016-03-19 11:41:38 +01:00
for (MuseScoreView* view : score()->getViewer())
fix #16853: Note nudge is cancelled on redraw
2012-06-09 10:50:51 +02:00
view->drawBackground(painter, bb);
fix #60651: Fret conflict shouldn't be exported to PDF or printed
2015-05-15 00:06:18 +02:00
if (fretConflict() && !score()->printing()) { //on fret conflict, draw on red background
fix #16853: Note nudge is cancelled on redraw
2012-06-09 10:50:51 +02:00
painter->save();
painter->setPen(Qt::red);
painter->setBrush(QBrush(QColor(Qt::red)));
painter->drawRect(bb);
painter->restore();
Initial commit
2012-05-26 14:26:10 +02:00
}
}
fix #123466: Fret marks almost unreadable in Tabs
2016-09-04 12:00:01 +02:00
QFont f(tab->fretFont());
fix #142166: Font-size of tablature fretmarks too small
2016-11-24 15:02:27 +01:00
f.setPointSizeF(f.pointSizeF() * spatium() * MScore::pixelRatio / SPATIUM20);
fix #123466: Fret marks almost unreadable in Tabs
2016-09-04 12:00:01 +02:00
painter->setFont(f);
fix changing note head color
2013-03-07 21:00:22 +01:00
painter->setPen(c);
fix #16853: Note nudge is cancelled on redraw
2012-06-09 10:50:51 +02:00
painter->drawText(QPointF(bbox().x(), tab->fretFontYOffset()), s);
}
Updated note.cpp, stafftype.cpp/.h and tab sample to use tab font style configuration
2012-08-17 00:33:38 +02:00
// NOT tablature
else {
merge
2013-05-12 12:51:42 +02:00
// skip drawing, if second note of a cross-measure value
convert unnamed enum to enum class CrossMeasure
2014-05-21 15:41:23 +02:00
if (chord()->crossMeasure() == CrossMeasure::SECOND)
merge
2013-05-12 12:51:42 +02:00
return;
fix #16853: Note nudge is cancelled on redraw
2012-06-09 10:50:51 +02:00
// warn if pitch extends usable range of instrument
Fix #100396: change "note heads" to "noteheads" See http://music.stackexchange.com/questions/42722/notehead-or-note-head (also correct "fo" to "for" in comment)
2016-05-03 01:21:42 +02:00
// by coloring the notehead
fix #16853: Note nudge is cancelled on redraw
2012-06-09 10:50:51 +02:00
if (chord() && chord()->segment() && staff() && !selected()
&& !score()->printing() && MScore::warnPitchRange) {
fix #9352: instrument change transposition
2015-09-21 02:13:22 +02:00
const Instrument* in = part()->instrument(chord()->tick());
fix #16853: Note nudge is cancelled on redraw
2012-06-09 10:50:51 +02:00
int i = ppitch();
if (i < in->minPitchP() || i > in->maxPitchP())
painter->setPen(Qt::red);
else if (i < in->minPitchA() || i > in->maxPitchA())
painter->setPen(Qt::darkYellow);
Initial commit
2012-05-26 14:26:10 +02:00
}
Add more noteheads and staff type for dynamic noteheads (shapes, notenames, etc...)
2016-10-22 20:16:42 +02:00
// draw blank notehead to avoid staff and ledger lines
if (_cachedSymNull != SymId::noSym) {
painter->save();
painter->setPen(Qt::white);
drawSymbol(_cachedSymNull, painter);
painter->restore();
}
drawSymbol(_cachedNoteheadSym, painter);
Initial commit
2012-05-26 14:26:10 +02:00
}
}
//--------------------------------------------------
// Note::write
//---------------------------------------------------------
rename Xml() -> XmlWriter()
2016-11-19 11:51:21 +01:00
void Note::write(XmlWriter& xml) const
Initial commit
2012-05-26 14:26:10 +02:00
{
xml.stag("Note");
Element::writeProperties(xml);
if (_accidental)
_accidental->write(xml);
_el.write(xml);
Layout reorganization
2016-01-04 14:48:58 +01:00
for (NoteDot* dot : _dots) {
if (!dot->userOff().isNull() || !dot->visible() || dot->color() != Qt::black || dot->visible() != visible()) {
dot->write(xml);
break;
Initial commit
2012-05-26 14:26:10 +02:00
}
}
remove id from spanner class
2014-07-21 13:24:21 +02:00
if (_tieFor)
Initial commit
2012-05-26 14:26:10 +02:00
_tieFor->write(xml);
remove id from spanner class
2014-07-21 13:24:21 +02:00
if (_tieBack) {
int id = xml.spannerId(_tieBack);
xml.tagE(QString("endSpanner id=\"%1\"").arg(id));
allow ties to connect to note in same or different voice
2013-08-21 11:59:41 +02:00
}
code cleanups & speed optimizations
2016-02-06 22:03:43 +01:00
if ((chord() == 0 || chord()->playEventType() != PlayEventType::Auto) && !_playEvents.empty()) {
fix pianoroll editor; editing event ontime and length
2014-03-28 16:29:55 +01:00
xml.stag("Events");
cross beam fixes
2016-03-19 11:41:38 +01:00
for (const NoteEvent& e : _playEvents)
fix pianoroll editor; editing event ontime and length
2014-03-28 16:29:55 +01:00
e.write(xml);
xml.etag();
Initial commit
2012-05-26 14:26:10 +02:00
}
note.cpp: small write optimization
2016-11-25 11:46:28 +01:00
for (P_ID id : { P_ID::PITCH, P_ID::TPC1, P_ID::TPC2, P_ID::SMALL, P_ID::MIRROR_HEAD, P_ID::DOT_POSITION,
P_ID::HEAD_GROUP, P_ID::VELO_OFFSET, P_ID::PLAY, P_ID::TUNING, P_ID::FRET, P_ID::STRING,
P_ID::GHOST, P_ID::HEAD_TYPE, P_ID::VELO_TYPE, P_ID::FIXED, P_ID::FIXED_LINE
}) {
writeProperty(xml, id);
}
property implementation rollback
2012-08-10 17:01:35 +02:00
cross beam fixes
2016-03-19 11:41:38 +01:00
for (Spanner* e : _spannerFor)
implement textline with note anchors
2012-09-12 16:19:03 +02:00
e->write(xml);
cross beam fixes
2016-03-19 11:41:38 +01:00
for (Spanner* e : _spannerBack)
remove id from spanner class
2014-07-21 13:24:21 +02:00
xml.tagE(QString("endSpanner id=\"%1\"").arg(xml.spannerId(e)));
replace some qt container with hand crafted single linked list
2013-01-03 16:56:56 +01:00
Initial commit
2012-05-26 14:26:10 +02:00
xml.etag();
}
//---------------------------------------------------------
// Note::read
//---------------------------------------------------------
use QXmlStreamReader for xml parsing
2013-01-11 18:10:18 +01:00
void Note::read(XmlReader& e)
Initial commit
2012-05-26 14:26:10 +02:00
{
change accidental file format
2016-09-22 12:02:27 +02:00
setTpc1(Tpc::TPC_INVALID);
setTpc2(Tpc::TPC_INVALID);
some regression fixes, code cleanups
2016-02-04 11:27:47 +01:00
use QXmlStreamReader for xml parsing
2013-01-11 18:10:18 +01:00
while (e.readNextStartElement()) {
change accidental file format
2016-09-22 12:02:27 +02:00
if (readProperties(e))
Initial commit
2012-05-26 14:26:10 +02:00
;
else
use QXmlStreamReader for xml parsing
2013-01-11 18:10:18 +01:00
e.unknown();
Initial commit
2012-05-26 14:26:10 +02:00
}
// ensure sane values:
avoid use of a reserved keyword for a function name even when it is inline
2014-05-12 12:52:13 +02:00
_pitch = limit(_pitch, 0, 127);
implement separate tpc values for transposed view
2014-04-09 09:40:25 +02:00
fix #25231
2014-04-14 13:16:46 +02:00
if (!tpcIsValid(_tpc[0]) && !tpcIsValid(_tpc[1])) {
stronger typing for key
2014-06-20 17:07:22 +02:00
Key key = (staff() && chord()) ? staff()->key(chord()->tick()) : Key::C;
fix #25945
2014-06-05 11:37:21 +02:00
int tpc = pitch2tpc(_pitch, key, Prefer::NEAREST);
fix #25231
2014-04-14 13:16:46 +02:00
if (concertPitch())
_tpc[0] = tpc;
else
_tpc[1] = tpc;
}
if (!(tpcIsValid(_tpc[0]) && tpcIsValid(_tpc[1]))) {
fix #9352: instrument change transposition
2015-09-21 02:13:22 +02:00
int tick = chord() ? chord()->tick() : -1;
Interval v = staff() ? part()->instrument(tick)->transpose() : Interval();
fix #25231
2014-04-14 13:16:46 +02:00
if (tpcIsValid(_tpc[0])) {
v.flip();
if (v.isZero())
implement separate tpc values for transposed view
2014-04-09 09:40:25 +02:00
_tpc[1] = _tpc[0];
else
fix #41766: use double sharp/flat where appropriate when transposing
2014-12-20 00:27:06 +01:00
_tpc[1] = Ms::transposeTpc(_tpc[0], v, true);
fix #25231
2014-04-14 13:16:46 +02:00
}
else {
if (v.isZero())
_tpc[0] = _tpc[1];
else
fix #41766: use double sharp/flat where appropriate when transposing
2014-12-20 00:27:06 +01:00
_tpc[0] = Ms::transposeTpc(_tpc[1], v, true);
implement separate tpc values for transposed view
2014-04-09 09:40:25 +02:00
}
}
Layout reorganization
2016-01-04 14:48:58 +01:00
fix #9352: instrument change transposition
2015-09-21 02:13:22 +02:00
// check consistency of pitch, tpc1, tpc2, and transposition
// see note in InstrumentChange::read() about a known case of tpc corruption produced in 2.0.x
// but since there are other causes of tpc corruption (eg, https://musescore.org/en/node/74746)
// including perhaps some we don't know about yet,
// we will attempt to fix some problems here regardless of version
Layout reorganization
2016-01-04 14:48:58 +01:00
if (!e.pasteMode() && !MScore::testMode) {
fix #9352: instrument change transposition
2015-09-21 02:13:22 +02:00
int tpc1Pitch = (tpc2pitch(_tpc[0]) + 12) % 12;
int tpc2Pitch = (tpc2pitch(_tpc[1]) + 12) % 12;
int concertPitch = _pitch % 12;
if (tpc1Pitch != concertPitch) {
qDebug("bad tpc1 - concertPitch = %d, tpc1 = %d", concertPitch, tpc1Pitch);
_pitch += tpc1Pitch - concertPitch;
}
fix #85956: drum note altered by arrow changes pitch on reload
2015-11-04 16:22:24 +01:00
Interval v = staff()->part()->instrument(e.tick())->transpose();
int transposedPitch = (_pitch - v.chromatic) % 12;
if (tpc2Pitch != transposedPitch) {
qDebug("bad tpc2 - transposedPitch = %d, tpc2 = %d", transposedPitch, tpc2Pitch);
change accidental file format
2016-09-22 12:02:27 +02:00
}
}
}
//---------------------------------------------------------
// readProperties
//---------------------------------------------------------
bool Note::readProperties(XmlReader& e)
{
const QStringRef& tag(e.name());
if (tag == "pitch")
_pitch = e.readInt();
else if (tag == "tpc") {
_tpc[0] = e.readInt();
_tpc[1] = _tpc[0];
}
else if (tag == "track") // for performance
setTrack(e.readInt());
else if (tag == "Accidental") {
Accidental* a = new Accidental(score());
a->setTrack(track());
a->read(e);
add(a);
}
else if (tag == "Tie") {
Tie* tie = new Tie(score());
tie->setParent(this);
tie->setTrack(track());
tie->read(e);
tie->setStartNote(this);
_tieFor = tie;
}
else if (tag == "tpc2")
_tpc[1] = e.readInt();
else if (tag == "small")
setSmall(e.readInt());
else if (tag == "mirror")
setProperty(P_ID::MIRROR_HEAD, Ms::getProperty(P_ID::MIRROR_HEAD, e));
else if (tag == "dotPosition")
setProperty(P_ID::DOT_POSITION, Ms::getProperty(P_ID::DOT_POSITION, e));
else if (tag == "fixed")
setFixed(e.readBool());
else if (tag == "fixedLine")
setFixedLine(e.readInt());
else if (tag == "head")
setProperty(P_ID::HEAD_GROUP, Ms::getProperty(P_ID::HEAD_GROUP, e));
else if (tag == "velocity")
setVeloOffset(e.readInt());
else if (tag == "play")
setPlay(e.readInt());
else if (tag == "tuning")
setTuning(e.readDouble());
else if (tag == "fret")
setFret(e.readInt());
else if (tag == "string")
setString(e.readInt());
else if (tag == "ghost")
setGhost(e.readInt());
else if (tag == "headType")
Change storage of notehead type and group in notes
2016-10-18 09:21:54 +02:00
setProperty(P_ID::HEAD_TYPE, Ms::getProperty(P_ID::HEAD_TYPE, e));
change accidental file format
2016-09-22 12:02:27 +02:00
else if (tag == "veloType")
setProperty(P_ID::VELO_TYPE, Ms::getProperty(P_ID::VELO_TYPE, e));
else if (tag == "line")
_line = e.readInt();
else if (tag == "Fingering") {
Fingering* f = new Fingering(score());
f->read(e);
add(f);
}
else if (tag == "Symbol") {
Symbol* s = new Symbol(score());
s->setTrack(track());
s->read(e);
add(s);
}
else if (tag == "Image") {
if (MScore::noImages)
e.skipCurrentElement();
else {
Image* image = new Image(score());
image->setTrack(track());
image->read(e);
add(image);
}
}
else if (tag == "Bend") {
Bend* b = new Bend(score());
b->setTrack(track());
b->read(e);
add(b);
}
else if (tag == "NoteDot") {
NoteDot* dot = new NoteDot(score());
dot->read(e);
add(dot);
}
else if (tag == "Events") {
_playEvents.clear(); // remove default event
while (e.readNextStartElement()) {
const QStringRef& tag(e.name());
if (tag == "Event") {
NoteEvent ne;
ne.read(e);
_playEvents.append(ne);
}
else
e.unknown();
}
if (chord())
chord()->setPlayEventType(PlayEventType::User);
}
else if (tag == "endSpanner") {
int id = e.intAttribute("id");
Spanner* sp = e.findSpanner(id);
if (sp) {
sp->setEndElement(this);
if (sp->isTie())
_tieBack = toTie(sp);
else {
if (sp->isGlissando() && parent() && parent()->isChord())
toChord(parent())->setEndsGlissando(true);
addSpannerBack(sp);
fix #9352: instrument change transposition
2015-09-21 02:13:22 +02:00
}
change accidental file format
2016-09-22 12:02:27 +02:00
e.removeSpanner(sp);
}
else {
// End of a spanner whose start element will appear later;
// may happen for cross-staff spanner from a lower to a higher staff
// (for instance a glissando from bass to treble staff of piano).
// Create a place-holder spanner with end data
// (a TextLine is used only because both Spanner or SLine are abstract,
// the actual class does not matter, as long as it is derived from Spanner)
int id = e.intAttribute("id", -1);
if (id != -1 &&
// DISABLE if pasting into a staff with linked staves
// because the glissando is not properly cloned into the linked staves
(!e.pasteMode() || !staff()->linkedStaves() || staff()->linkedStaves()->empty())) {
Spanner* placeholder = new TextLine(score());
placeholder->setAnchor(Spanner::Anchor::NOTE);
placeholder->setEndElement(this);
placeholder->setTrack2(track());
placeholder->setTick(0);
placeholder->setTick2(e.tick());
e.addSpanner(id, placeholder);
}
}
e.readNext();
}
else if (tag == "TextLine"
|| tag == "Glissando") {
Spanner* sp = static_cast<Spanner*>(Element::name2Element(tag, score()));
// check this is not a lower-to-higher cross-staff spanner we already got
int id = e.intAttribute("id");
Spanner* placeholder = e.findSpanner(id);
if (placeholder) {
// if it is, fill end data from place-holder
sp->setAnchor(Spanner::Anchor::NOTE); // make sure we can set a Note as end element
sp->setEndElement(placeholder->endElement());
sp->setTrack2(placeholder->track2());
sp->setTick(e.tick()); // make sure tick2 will be correct
sp->setTick2(placeholder->tick2());
static_cast<Note*>(placeholder->endElement())->addSpannerBack(sp);
// remove no longer needed place-holder before reading the new spanner,
// as reading it also adds it to XML reader list of spanners,
// which would overwrite the place-holder
e.removeSpanner(placeholder);
delete placeholder;
}
sp->setTrack(track());
sp->read(e);
// DISABLE pasting of glissandi into staves with other lionked staves
// because the glissando is not properly cloned into the linked staves
if (e.pasteMode() && staff()->linkedStaves() && !staff()->linkedStaves()->empty()) {
e.removeSpanner(sp); // read() added the element to the XMLReader: remove it
delete sp;
}
else {
sp->setAnchor(Spanner::Anchor::NOTE);
sp->setStartElement(this);
sp->setTick(e.tick());
addSpannerFor(sp);
sp->setParent(this);
fix #9352: instrument change transposition
2015-09-21 02:13:22 +02:00
}
}
change accidental file format
2016-09-22 12:02:27 +02:00
else if (tag == "offset")
Element::readProperties(e);
else if (Element::readProperties(e))
;
else
return false;
return true;
Initial commit
2012-05-26 14:26:10 +02:00
}
fix #167336: staff scaling doesn't work
2017-02-08 15:34:53 +01:00
//---------------------------------------------------------
// transposition
//---------------------------------------------------------
int Note::transposition() const
{
int tick = chord() ? chord()->tick() : -1;
return staff() ? part()->instrument(tick)->transpose().chromatic : 0;
}
Initial commit
2012-05-26 14:26:10 +02:00
//---------------------------------------------------------
// drag
//---------------------------------------------------------
move anchor while dragging dynamics
2013-10-22 12:05:31 +02:00
QRectF Note::drag(EditData* data)
Initial commit
2012-05-26 14:26:10 +02:00
{
change StaffType interface
2016-12-13 13:16:17 +01:00
if (staff()->isDrumStaff(tick()))
do not allow drum note dragging
2013-03-22 18:30:05 +01:00
return QRect();
fix #167336: staff scaling doesn't work
2017-02-08 15:34:53 +01:00
// dragMode = true;
Initial commit
2012-05-26 14:26:10 +02:00
QRectF bb(chord()->bbox());
qreal _spatium = spatium();
change StaffType interface
2016-12-13 13:16:17 +01:00
bool tab = staff()->isTabStaff(chord()->tick());
qreal step = _spatium * (tab ? staff()->staffType(tick())->lineDistance().val() : 0.5);
remove many setLayoutAll() calls; cleanups
2016-06-14 10:32:34 +02:00
_lineOffset = lrint(data->delta.y() / step);
fix #167336: staff scaling doesn't work
2017-02-08 15:34:53 +01:00
remove many setLayoutAll() calls; cleanups
2016-06-14 10:32:34 +02:00
triggerLayout();
Initial commit
2012-05-26 14:26:10 +02:00
return bb.translated(chord()->pagePos());
}
//---------------------------------------------------------
// endDrag
//---------------------------------------------------------
void Note::endDrag()
{
use ottava shape for system distance calculation
2016-06-16 11:20:22 +02:00
dragMode = false;
Initial commit
2012-05-26 14:26:10 +02:00
if (_lineOffset == 0)
return;
fix #47141 Wrong results ion lined staves (Tab and standard) when dragging notes with mouse
2015-02-12 11:41:39 +01:00
fix #167336: staff scaling doesn't work
2017-02-08 15:34:53 +01:00
Staff* staff = score()->staff(chord()->vStaffIdx());
TAB: Make tabs aware of staff transpositions. Feature has been requested and discussed at length in the forum thread: http://musescore.org/en/node/31016 To implement this, the fret-to-pitch relation has been made dependent of the staff, as each staff may have an individual transposition value in addition to the string data. And -- in addition -- on tick, in preparation of dealing with ottavas and capos.
2015-02-13 01:09:01 +01:00
int tick = chord()->tick();
fix #47141 Wrong results ion lined staves (Tab and standard) when dragging notes with mouse
2015-02-12 11:41:39 +01:00
change StaffType interface
2016-12-13 13:16:17 +01:00
if (staff->isTabStaff(tick)) {
fix #47141 Wrong results ion lined staves (Tab and standard) when dragging notes with mouse
2015-02-12 11:41:39 +01:00
// on TABLATURE staves, dragging a note keeps same pitch on a different string (if possible)
// determine new string of dragged note (if tablature is upside down, invert _lineOffset)
Fix #29426 - TAB: dragging a note to another string does not affect notes tied to it See issue http://musescore.org/en/node/29426
2015-02-25 13:30:22 +01:00
// and fret for the same pitch on the new string
code cleanups; rename instr() to instrument()
2015-03-13 11:16:43 +01:00
const StringData* strData = staff->part()->instrument()->stringData();
change StaffType interface
2016-12-13 13:16:17 +01:00
int nString = _string + (staff->staffType(tick)->upsideDown() ? -_lineOffset : _lineOffset);
Fix #29426 - TAB: dragging a note to another string does not affect notes tied to it See issue http://musescore.org/en/node/29426
2015-02-25 13:30:22 +01:00
int nFret = strData->fret(_pitch, nString, staff, tick);
fix #47141 Wrong results ion lined staves (Tab and standard) when dragging notes with mouse
2015-02-12 11:41:39 +01:00
if (nFret < 0) // no fret?
return; // no party!
Fix #29426 - TAB: dragging a note to another string does not affect notes tied to it See issue http://musescore.org/en/node/29426
2015-02-25 13:30:22 +01:00
// move the note together with all notes tied to it
for (Note* nn : tiedNotes()) {
bool refret = false;
if (nn->fret() != nFret) {
nn->undoChangeProperty(P_ID::FRET, nFret);
refret = true;
}
if (nn->string() != nString) {
nn->undoChangeProperty(P_ID::STRING, nString);
refret = true;
}
if (refret)
strData->fretChords(nn->chord());
}
fix #47141 Wrong results ion lined staves (Tab and standard) when dragging notes with mouse
2015-02-12 11:41:39 +01:00
}
else {
// on PITCHED / PERCUSSION staves, dragging a note changes the note pitch
// determine new pitch of dragged note
fix #167336: staff scaling doesn't work
2017-02-08 15:34:53 +01:00
Key key = staff->key(tick);
int nPitch = line2pitch(_line + _lineOffset, staff->clef(tick), key);
fix #47141 Wrong results ion lined staves (Tab and standard) when dragging notes with mouse
2015-02-12 11:41:39 +01:00
if (!concertPitch()) {
fix #9352: instrument change transposition
2015-09-21 02:13:22 +02:00
Interval interval = staff->part()->instrument(tick)->transpose();
fix #47141 Wrong results ion lined staves (Tab and standard) when dragging notes with mouse
2015-02-12 11:41:39 +01:00
nPitch += interval.chromatic;
fix #27646
2014-07-15 11:01:24 +02:00
}
fix #47141 Wrong results ion lined staves (Tab and standard) when dragging notes with mouse
2015-02-12 11:41:39 +01:00
int tpc1 = pitch2tpc(nPitch, key, Prefer::NEAREST);
int tpc2 = pitch2tpc(nPitch - transposition(), key, Prefer::NEAREST);
// undefined for non-tablature staves
for (Note* nn : tiedNotes()) {
misc. updates
2016-09-03 17:45:59 +02:00
// score()->undoChangePitch(nn, nPitch, tpc1, tpc2);
nn->undoChangeProperty(P_ID::PITCH, nPitch);
nn->undoChangeProperty(P_ID::TPC1, tpc1);
nn->undoChangeProperty(P_ID::TPC2, tpc2);
implement separate tpc values for transposed view
2014-04-09 09:40:25 +02:00
}
Initial commit
2012-05-26 14:26:10 +02:00
}
when dragging notes with mouse, update links
2015-02-09 16:28:57 +01:00
_lineOffset = 0;
convert enum SelectType into enum class
2014-05-27 10:34:08 +02:00
score()->select(this, SelectType::SINGLE, 0);
Initial commit
2012-05-26 14:26:10 +02:00
}
//---------------------------------------------------------
// acceptDrop
//---------------------------------------------------------
fix #29431
2014-08-13 21:01:21 +02:00
bool Note::acceptDrop(const DropData& data) const
Initial commit
2012-05-26 14:26:10 +02:00
{
fix #29431
2014-08-13 21:01:21 +02:00
Element* e = data.element;
move Element::type() to ScoreElement
2017-01-18 14:16:33 +01:00
ElementType type = e->type();
if (type == ElementType::GLISSANDO) {
Glissando type isn't properly replaced
2015-02-25 11:43:55 +01:00
for (auto e : _spannerFor)
move Element::type() to ScoreElement
2017-01-18 14:16:33 +01:00
if (e->type() == ElementType::GLISSANDO) {
Glissando type isn't properly replaced
2015-02-25 11:43:55 +01:00
return false;
}
return true;
}
fingering layout update; fixed layout bugs
2017-01-19 16:06:40 +01:00
bool isTablature = staff()->isTabStaff(tick());
move Element::type() to ScoreElement
2017-01-18 14:16:33 +01:00
return (type == ElementType::ARTICULATION
|| type == ElementType::CHORDLINE
|| type == ElementType::TEXT
|| type == ElementType::REHEARSAL_MARK
fingering layout update; fixed layout bugs
2017-01-19 16:06:40 +01:00
|| (type == ElementType::FINGERING && !isTablature)
move Element::type() to ScoreElement
2017-01-18 14:16:33 +01:00
|| type == ElementType::ACCIDENTAL
|| type == ElementType::BREATH
|| type == ElementType::ARPEGGIO
|| type == ElementType::NOTEHEAD
|| type == ElementType::NOTE
|| type == ElementType::TREMOLO
|| type == ElementType::STAFF_STATE
|| type == ElementType::INSTRUMENT_CHANGE
|| type == ElementType::IMAGE
|| type == ElementType::CHORD
|| type == ElementType::HARMONY
|| type == ElementType::DYNAMIC
|| (type == ElementType::ICON && toIcon(e)->iconType() == IconType::ACCIACCATURA)
|| (type == ElementType::ICON && toIcon(e)->iconType() == IconType::APPOGGIATURA)
|| (type == ElementType::ICON && toIcon(e)->iconType() == IconType::GRACE4)
|| (type == ElementType::ICON && toIcon(e)->iconType() == IconType::GRACE16)
|| (type == ElementType::ICON && toIcon(e)->iconType() == IconType::GRACE32)
|| (type == ElementType::ICON && toIcon(e)->iconType() == IconType::GRACE8_AFTER)
|| (type == ElementType::ICON && toIcon(e)->iconType() == IconType::GRACE16_AFTER)
|| (type == ElementType::ICON && toIcon(e)->iconType() == IconType::GRACE32_AFTER)
|| (noteType() == NoteType::NORMAL && type == ElementType::BAGPIPE_EMBELLISHMENT)
|| (type == ElementType::ICON && toIcon(e)->iconType() == IconType::SBEAM)
|| (type == ElementType::ICON && toIcon(e)->iconType() == IconType::MBEAM)
|| (type == ElementType::ICON && toIcon(e)->iconType() == IconType::NBEAM)
|| (type == ElementType::ICON && toIcon(e)->iconType() == IconType::BEAM32)
|| (type == ElementType::ICON && toIcon(e)->iconType() == IconType::BEAM64)
|| (type == ElementType::ICON && toIcon(e)->iconType() == IconType::AUTOBEAM)
Plural of parenthesis is parentheses
2017-01-31 19:30:49 +01:00
|| (type == ElementType::ICON && toIcon(e)->iconType() == IconType::PARENTHESES)
move Element::type() to ScoreElement
2017-01-18 14:16:33 +01:00
|| (type == ElementType::SYMBOL)
|| (type == ElementType::CLEF)
|| (type == ElementType::KEYSIG)
|| (type == ElementType::TIMESIG)
|| (type == ElementType::BAR_LINE)
|| (type == ElementType::SLUR)
|| (type == ElementType::HAIRPIN)
|| (type == ElementType::STAFF_TEXT)
more complete SystemText impl.
2017-01-23 10:54:57 +01:00
|| (type == ElementType::SYSTEM_TEXT)
move Element::type() to ScoreElement
2017-01-18 14:16:33 +01:00
|| (type == ElementType::TEMPO_TEXT)
|| (type == ElementType::BEND)
|| (type == ElementType::TREMOLOBAR)
|| (type == ElementType::FRET_DIAGRAM)
|| (type == ElementType::FIGURED_BASS)
|| (type == ElementType::LYRICS));
Initial commit
2012-05-26 14:26:10 +02:00
}
//---------------------------------------------------------
// drop
//---------------------------------------------------------
Element* Note::drop(const DropData& data)
{
Element* e = data.element;
fingering layout update; fixed layout bugs
2017-01-19 16:06:40 +01:00
bool isTablature = staff()->isTabStaff(tick());
Initial commit
2012-05-26 14:26:10 +02:00
Chord* ch = chord();
fingering layout update; fixed layout bugs
2017-01-19 16:06:40 +01:00
Initial commit
2012-05-26 14:26:10 +02:00
switch(e->type()) {
move Element::type() to ScoreElement
2017-01-18 14:16:33 +01:00
case ElementType::REHEARSAL_MARK:
Initial commit
2012-05-26 14:26:10 +02:00
return ch->drop(data);
move Element::type() to ScoreElement
2017-01-18 14:16:33 +01:00
case ElementType::SYMBOL:
case ElementType::IMAGE:
update style of dropped text
2012-10-25 16:21:07 +02:00
e->setParent(this);
score()->undoAddElement(e);
return e;
move Element::type() to ScoreElement
2017-01-18 14:16:33 +01:00
case ElementType::FINGERING:
fingering layout update; fixed layout bugs
2017-01-19 16:06:40 +01:00
if (!isTablature) {
e->setParent(this);
score()->undoAddElement(e);
return e;
}
else
delete e;
return 0;
Initial commit
2012-05-26 14:26:10 +02:00
move Element::type() to ScoreElement
2017-01-18 14:16:33 +01:00
case ElementType::SLUR:
Initial commit
2012-05-26 14:26:10 +02:00
delete e;
data.view->cmdAddSlur(this, 0);
return 0;
move Element::type() to ScoreElement
2017-01-18 14:16:33 +01:00
case ElementType::HAIRPIN:
enable double click on palette to add hairpins
2014-12-16 18:07:51 +01:00
{
autoplacement for hairpins, pedal lines
2016-07-15 14:05:51 +02:00
Hairpin* hairpin = toHairpin(e);
update hairpin; fix drag of lines to staff > 1
2016-09-22 17:28:44 +02:00
data.view->cmdAddHairpin(hairpin->hairpinType());
enable double click on palette to add hairpins
2014-12-16 18:07:51 +01:00
delete e;
}
return 0;
move Element::type() to ScoreElement
2017-01-18 14:16:33 +01:00
case ElementType::LYRICS:
Fix the crash when (copying/cutting and) pasting a single lyrics to a single note.
2013-10-05 17:04:41 +02:00
e->setParent(ch);
e->setTrack(track());
Initial commit
2012-05-26 14:26:10 +02:00
score()->undoAddElement(e);
return e;
move Element::type() to ScoreElement
2017-01-18 14:16:33 +01:00
case ElementType::ACCIDENTAL:
replace all subtype()/setSubtype() Element methods
2013-03-05 20:23:59 +01:00
score()->changeAccidental(this, static_cast<Accidental*>(e)->accidentalType());
Initial commit
2012-05-26 14:26:10 +02:00
break;
move Element::type() to ScoreElement
2017-01-18 14:16:33 +01:00
case ElementType::BEND:
preparations for new compatibility implementation
2016-09-13 09:39:50 +02:00
e->setParent(this);
e->setTrack(track());
score()->undoAddElement(e);
Initial commit
2012-05-26 14:26:10 +02:00
return e;
move Element::type() to ScoreElement
2017-01-18 14:16:33 +01:00
case ElementType::NOTEHEAD:
Initial commit
2012-05-26 14:26:10 +02:00
{
preparations for new compatibility implementation
2016-09-13 09:39:50 +02:00
NoteHead* s = toNoteHead(e);
move NoteHeadGroup to NoteHead::Group needed to make it available to the plugin framework
2014-06-25 21:18:26 +02:00
NoteHead::Group group = s->headGroup();
if (group == NoteHead::Group::HEAD_INVALID) {
Fix #100396: change "note heads" to "noteheads" See http://music.stackexchange.com/questions/42722/notehead-or-note-head (also correct "fo" to "for" in comment)
2016-05-03 01:21:42 +02:00
qDebug("unknown notehead");
move NoteHeadGroup to NoteHead::Group needed to make it available to the plugin framework
2014-06-25 21:18:26 +02:00
group = NoteHead::Group::HEAD_NORMAL;
Initial commit
2012-05-26 14:26:10 +02:00
}
delete s;
if (group != _headGroup) {
if (links()) {
cross beam fixes
2016-03-19 11:41:38 +01:00
for (ScoreElement* e : *links()) {
inspector updates; misc. cleanups
2016-06-09 09:26:13 +02:00
e->undoChangeProperty(P_ID::HEAD_GROUP, int(group));
Initial commit
2012-05-26 14:26:10 +02:00
Note* note = static_cast<Note*>(e);
change StaffType interface
2016-12-13 13:16:17 +01:00
if (note->staff() && note->staff()->isTabStaff(ch->tick()) && group == NoteHead::Group::HEAD_CROSS)
inspector updates; misc. cleanups
2016-06-09 09:26:13 +02:00
e->undoChangeProperty(P_ID::GHOST, true);
Initial commit
2012-05-26 14:26:10 +02:00
}
}
small optimizations
2016-11-07 09:59:06 +01:00
else {
inspector updates; misc. cleanups
2016-06-09 09:26:13 +02:00
undoChangeProperty(P_ID::HEAD_GROUP, int(group));
small optimizations
2016-11-07 09:59:06 +01:00
}
Initial commit
2012-05-26 14:26:10 +02:00
}
}
break;
move Element::type() to ScoreElement
2017-01-18 14:16:33 +01:00
case ElementType::ICON:
Initial commit
2012-05-26 14:26:10 +02:00
{
preparations for new compatibility implementation
2016-09-13 09:39:50 +02:00
switch (toIcon(e)->iconType()) {
convert unnamed enum into enum class IconType and change to a better sentinel for end of list. Also move the Q_DECLARE_METATYPE(Ms::ValueType) nearer to its definition. This should conclude the work on the enums in libmsore/mscore.h.
2014-05-30 10:14:57 +02:00
case IconType::ACCIACCATURA:
convert enum NoteType into enum class
2014-05-27 10:35:28 +02:00
score()->setGraceNote(ch, pitch(), NoteType::ACCIACCATURA, MScore::division/2);
Initial commit
2012-05-26 14:26:10 +02:00
break;
convert unnamed enum into enum class IconType and change to a better sentinel for end of list. Also move the Q_DECLARE_METATYPE(Ms::ValueType) nearer to its definition. This should conclude the work on the enums in libmsore/mscore.h.
2014-05-30 10:14:57 +02:00
case IconType::APPOGGIATURA:
convert enum NoteType into enum class
2014-05-27 10:35:28 +02:00
score()->setGraceNote(ch, pitch(), NoteType::APPOGGIATURA, MScore::division/2);
Initial commit
2012-05-26 14:26:10 +02:00
break;
convert unnamed enum into enum class IconType and change to a better sentinel for end of list. Also move the Q_DECLARE_METATYPE(Ms::ValueType) nearer to its definition. This should conclude the work on the enums in libmsore/mscore.h.
2014-05-30 10:14:57 +02:00
case IconType::GRACE4:
convert enum NoteType into enum class
2014-05-27 10:35:28 +02:00
score()->setGraceNote(ch, pitch(), NoteType::GRACE4, MScore::division);
Initial commit
2012-05-26 14:26:10 +02:00
break;
convert unnamed enum into enum class IconType and change to a better sentinel for end of list. Also move the Q_DECLARE_METATYPE(Ms::ValueType) nearer to its definition. This should conclude the work on the enums in libmsore/mscore.h.
2014-05-30 10:14:57 +02:00
case IconType::GRACE16:
convert enum NoteType into enum class
2014-05-27 10:35:28 +02:00
score()->setGraceNote(ch, pitch(), NoteType::GRACE16, MScore::division/4);
Initial commit
2012-05-26 14:26:10 +02:00
break;
convert unnamed enum into enum class IconType and change to a better sentinel for end of list. Also move the Q_DECLARE_METATYPE(Ms::ValueType) nearer to its definition. This should conclude the work on the enums in libmsore/mscore.h.
2014-05-30 10:14:57 +02:00
case IconType::GRACE32:
convert enum NoteType into enum class
2014-05-27 10:35:28 +02:00
score()->setGraceNote(ch, pitch(), NoteType::GRACE32, MScore::division/8);
fix #24951: grace notes after enabled
2014-04-23 18:07:38 +02:00
break;
convert unnamed enum into enum class IconType and change to a better sentinel for end of list. Also move the Q_DECLARE_METATYPE(Ms::ValueType) nearer to its definition. This should conclude the work on the enums in libmsore/mscore.h.
2014-05-30 10:14:57 +02:00
case IconType::GRACE8_AFTER:
convert enum NoteType into enum class
2014-05-27 10:35:28 +02:00
score()->setGraceNote(ch, pitch(), NoteType::GRACE8_AFTER, MScore::division/2);
fix #24951: grace notes after enabled
2014-04-23 18:07:38 +02:00
break;
convert unnamed enum into enum class IconType and change to a better sentinel for end of list. Also move the Q_DECLARE_METATYPE(Ms::ValueType) nearer to its definition. This should conclude the work on the enums in libmsore/mscore.h.
2014-05-30 10:14:57 +02:00
case IconType::GRACE16_AFTER:
convert enum NoteType into enum class
2014-05-27 10:35:28 +02:00
score()->setGraceNote(ch, pitch(), NoteType::GRACE16_AFTER, MScore::division/4);
fix #24951: grace notes after enabled
2014-04-23 18:07:38 +02:00
break;
convert unnamed enum into enum class IconType and change to a better sentinel for end of list. Also move the Q_DECLARE_METATYPE(Ms::ValueType) nearer to its definition. This should conclude the work on the enums in libmsore/mscore.h.
2014-05-30 10:14:57 +02:00
case IconType::GRACE32_AFTER:
convert enum NoteType into enum class
2014-05-27 10:35:28 +02:00
score()->setGraceNote(ch, pitch(), NoteType::GRACE32_AFTER, MScore::division/8);
Initial commit
2012-05-26 14:26:10 +02:00
break;
convert unnamed enum into enum class IconType and change to a better sentinel for end of list. Also move the Q_DECLARE_METATYPE(Ms::ValueType) nearer to its definition. This should conclude the work on the enums in libmsore/mscore.h.
2014-05-30 10:14:57 +02:00
case IconType::SBEAM:
case IconType::MBEAM:
case IconType::NBEAM:
case IconType::BEAM32:
case IconType::BEAM64:
case IconType::AUTOBEAM:
Initial commit
2012-05-26 14:26:10 +02:00
return ch->drop(data);
break;
Plural of parenthesis is parentheses
2017-01-31 19:30:49 +01:00
case IconType::PARENTHESES:
addParentheses();
fix #21235 add bracket symbol to notehead master palette
2013-05-27 11:28:20 +02:00
break;
convert unnamed enum into enum class IconType and change to a better sentinel for end of list. Also move the Q_DECLARE_METATYPE(Ms::ValueType) nearer to its definition. This should conclude the work on the enums in libmsore/mscore.h.
2014-05-30 10:14:57 +02:00
default:
break;
Initial commit
2012-05-26 14:26:10 +02:00
}
}
delete e;
break;
allow ties to connect to note in same or different voice
2013-08-21 11:59:41 +02:00
move Element::type() to ScoreElement
2017-01-18 14:16:33 +01:00
case ElementType::BAGPIPE_EMBELLISHMENT:
Framework for bagpipe palette
2013-08-01 22:24:36 +02:00
{
Initial implementation bagpipe palette
2013-08-04 10:35:46 +02:00
BagpipeEmbellishment* b = static_cast<BagpipeEmbellishment*>(e);
noteList nl = b->getNoteList();
// add grace notes in reverse order, as setGraceNote adds a grace note
// before the current note
for (int i = nl.size() - 1; i >= 0; --i) {
int p = BagpipeEmbellishment::BagpipeNoteInfoList[nl.at(i)].pitch;
convert enum NoteType into enum class
2014-05-27 10:35:28 +02:00
score()->setGraceNote(ch, p, NoteType::GRACE32, MScore::division/8);
Framework for bagpipe palette
2013-08-01 22:24:36 +02:00
}
}
delete e;
break;
Initial commit
2012-05-26 14:26:10 +02:00
move Element::type() to ScoreElement
2017-01-18 14:16:33 +01:00
case ElementType::NOTE:
Initial commit
2012-05-26 14:26:10 +02:00
{
Chord* ch = chord();
convert enum NoteType into enum class
2014-05-27 10:35:28 +02:00
if (ch->noteType() != NoteType::NORMAL) {
Initial commit
2012-05-26 14:26:10 +02:00
delete e;
return 0;
}
fix #5098: tpc corruption on copy of note
2015-12-03 16:32:03 +01:00
// calculate correct transposed tpc
preparations for new compatibility implementation
2016-09-13 09:39:50 +02:00
Note* n = toNote(e);
fix #5098: tpc corruption on copy of note
2015-12-03 16:32:03 +01:00
Interval v = part()->instrument(ch->tick())->transpose();
v.flip();
n->setTpc2(Ms::transposeTpc(n->tpc1(), v, true));
// replace this note with new note
n->setParent(ch);
Initial commit
2012-05-26 14:26:10 +02:00
score()->undoRemoveElement(this);
fix #5098: tpc corruption on copy of note
2015-12-03 16:32:03 +01:00
score()->undoAddElement(n);
Initial commit
2012-05-26 14:26:10 +02:00
}
break;
move Element::type() to ScoreElement
2017-01-18 14:16:33 +01:00
case ElementType::GLISSANDO:
Initial commit
2012-05-26 14:26:10 +02:00
{
Glissando type isn't properly replaced
2015-02-25 11:43:55 +01:00
for (auto e : _spannerFor) {
move Element::type() to ScoreElement
2017-01-18 14:16:33 +01:00
if (e->type() == ElementType::GLISSANDO) {
fix typo
2015-02-25 19:53:10 +01:00
qDebug("there is already a glissando");
Glissando type isn't properly replaced
2015-02-25 11:43:55 +01:00
delete e;
return 0;
}
}
Glissando as a multi-segment line. - Implemented as a sub-class of `SLine`. - Anchor type changed from CHORD to NOTE: allows to attach glissando start and end points to individual notes, rather than generically to chords (with note within the chord chosen by the program). - The Glissando element is now stored in the `Note::_spannerFor` list. - `Chord::_glissando` has been removed and replaced by a `bool _endsGlissando`, recording whether the chord is at the end of glissando (as gliss.-end chords require more space if mid-measure or system-initial). - Debugger UI for `Chord` updated accordingly. - Glissando in now save into score file as a spanner, within the initial note, and with appropriate `&lt;endSpanner&gt;` tag in the Glissando ending note. - Existing scores with the old Glissando file format are correctly read back. Notes: - MusicXML import/export of the new Glissando implementation NOT IMPLEMENTED. - This version can read scores from older versions, but older versions **cannot read** scored from this version (they do not expect a &lt;Glissando&gt; tag within a Note). Does this require a NEW FILE VERSION NUMBER? - This implementation would allow rather easily to move the start and end anchors around (as for slurs) to override the note/chord chosen by the program when the glissando is initially created; but the UI for this is not implemented yet.
2014-12-13 17:40:39 +01:00
// this is the glissando initial note, look for a suitable final note
Note* finalNote = Glissando::guessFinalNote(chord());
change StaffType interface
2016-12-13 13:16:17 +01:00
if (finalNote) {
Glissando as a multi-segment line. - Implemented as a sub-class of `SLine`. - Anchor type changed from CHORD to NOTE: allows to attach glissando start and end points to individual notes, rather than generically to chords (with note within the chord chosen by the program). - The Glissando element is now stored in the `Note::_spannerFor` list. - `Chord::_glissando` has been removed and replaced by a `bool _endsGlissando`, recording whether the chord is at the end of glissando (as gliss.-end chords require more space if mid-measure or system-initial). - Debugger UI for `Chord` updated accordingly. - Glissando in now save into score file as a spanner, within the initial note, and with appropriate `&lt;endSpanner&gt;` tag in the Glissando ending note. - Existing scores with the old Glissando file format are correctly read back. Notes: - MusicXML import/export of the new Glissando implementation NOT IMPLEMENTED. - This version can read scores from older versions, but older versions **cannot read** scored from this version (they do not expect a &lt;Glissando&gt; tag within a Note). Does this require a NEW FILE VERSION NUMBER? - This implementation would allow rather easily to move the start and end anchors around (as for slurs) to override the note/chord chosen by the program when the glissando is initially created; but the UI for this is not implemented yet.
2014-12-13 17:40:39 +01:00
// init glissando data
preparations for new compatibility implementation
2016-09-13 09:39:50 +02:00
Glissando* gliss = toGlissando(e);
Glissando as a multi-segment line. - Implemented as a sub-class of `SLine`. - Anchor type changed from CHORD to NOTE: allows to attach glissando start and end points to individual notes, rather than generically to chords (with note within the chord chosen by the program). - The Glissando element is now stored in the `Note::_spannerFor` list. - `Chord::_glissando` has been removed and replaced by a `bool _endsGlissando`, recording whether the chord is at the end of glissando (as gliss.-end chords require more space if mid-measure or system-initial). - Debugger UI for `Chord` updated accordingly. - Glissando in now save into score file as a spanner, within the initial note, and with appropriate `&lt;endSpanner&gt;` tag in the Glissando ending note. - Existing scores with the old Glissando file format are correctly read back. Notes: - MusicXML import/export of the new Glissando implementation NOT IMPLEMENTED. - This version can read scores from older versions, but older versions **cannot read** scored from this version (they do not expect a &lt;Glissando&gt; tag within a Note). Does this require a NEW FILE VERSION NUMBER? - This implementation would allow rather easily to move the start and end anchors around (as for slurs) to override the note/chord chosen by the program when the glissando is initially created; but the UI for this is not implemented yet.
2014-12-13 17:40:39 +01:00
gliss->setAnchor(Spanner::Anchor::NOTE);
gliss->setStartElement(this);
gliss->setEndElement(finalNote);
gliss->setTick(ch->tick());
gliss->setTick2(finalNote->chord()->tick());
gliss->setTrack(track());
gliss->setTrack2(finalNote->track());
// in TAB, use straight line with no text
change StaffType interface
2016-12-13 13:16:17 +01:00
if (staff()->isTabStaff(finalNote->chord()->tick())) {
Glissando as a multi-segment line. - Implemented as a sub-class of `SLine`. - Anchor type changed from CHORD to NOTE: allows to attach glissando start and end points to individual notes, rather than generically to chords (with note within the chord chosen by the program). - The Glissando element is now stored in the `Note::_spannerFor` list. - `Chord::_glissando` has been removed and replaced by a `bool _endsGlissando`, recording whether the chord is at the end of glissando (as gliss.-end chords require more space if mid-measure or system-initial). - Debugger UI for `Chord` updated accordingly. - Glissando in now save into score file as a spanner, within the initial note, and with appropriate `&lt;endSpanner&gt;` tag in the Glissando ending note. - Existing scores with the old Glissando file format are correctly read back. Notes: - MusicXML import/export of the new Glissando implementation NOT IMPLEMENTED. - This version can read scores from older versions, but older versions **cannot read** scored from this version (they do not expect a &lt;Glissando&gt; tag within a Note). Does this require a NEW FILE VERSION NUMBER? - This implementation would allow rather easily to move the start and end anchors around (as for slurs) to override the note/chord chosen by the program when the glissando is initially created; but the UI for this is not implemented yet.
2014-12-13 17:40:39 +01:00
gliss->setGlissandoType(Glissando::Type::STRAIGHT);
gliss->setShowText(false);
}
gliss->setParent(this);
score()->undoAddElement(e);
Initial commit
2012-05-26 14:26:10 +02:00
}
Glissando as a multi-segment line. - Implemented as a sub-class of `SLine`. - Anchor type changed from CHORD to NOTE: allows to attach glissando start and end points to individual notes, rather than generically to chords (with note within the chord chosen by the program). - The Glissando element is now stored in the `Note::_spannerFor` list. - `Chord::_glissando` has been removed and replaced by a `bool _endsGlissando`, recording whether the chord is at the end of glissando (as gliss.-end chords require more space if mid-measure or system-initial). - Debugger UI for `Chord` updated accordingly. - Glissando in now save into score file as a spanner, within the initial note, and with appropriate `&lt;endSpanner&gt;` tag in the Glissando ending note. - Existing scores with the old Glissando file format are correctly read back. Notes: - MusicXML import/export of the new Glissando implementation NOT IMPLEMENTED. - This version can read scores from older versions, but older versions **cannot read** scored from this version (they do not expect a &lt;Glissando&gt; tag within a Note). Does this require a NEW FILE VERSION NUMBER? - This implementation would allow rather easily to move the start and end anchors around (as for slurs) to override the note/chord chosen by the program when the glissando is initially created; but the UI for this is not implemented yet.
2014-12-13 17:40:39 +01:00
else {
eliminating needless \n in qDebug() calls searching for 'qDebug.*\\n\'
2014-03-25 13:33:47 +01:00
qDebug("no segment for second note of glissando found");
Initial commit
2012-05-26 14:26:10 +02:00
delete e;
return 0;
}
}
break;
move Element::type() to ScoreElement
2017-01-18 14:16:33 +01:00
case ElementType::CHORD:
Initial commit
2012-05-26 14:26:10 +02:00
{
preparations for new compatibility implementation
2016-09-13 09:39:50 +02:00
Chord* c = toChord(e);
Initial commit
2012-05-26 14:26:10 +02:00
Note* n = c->upNote();
framework for partial relayout
2016-03-02 13:20:19 +01:00
Direction dir = c->stemDirection();
low level optimizations
2013-01-02 20:13:58 +01:00
int t = (staff2track(staffIdx()) + n->voice());
convert enum SelectType into enum class
2014-05-27 10:34:08 +02:00
score()->select(0, SelectType::SINGLE, 0);
Initial commit
2012-05-26 14:26:10 +02:00
NoteVal nval;
nval.pitch = n->pitch();
nval.headGroup = n->headGroup();
Segment* seg = score()->setNoteRest(chord()->segment(), t, nval,
score()->inputState().duration().fraction(), dir);
preparations for new compatibility implementation
2016-09-13 09:39:50 +02:00
ChordRest* cr = toChordRest(seg->element(t));
Initial commit
2012-05-26 14:26:10 +02:00
if (cr)
score()->nextInputPos(cr, true);
delete e;
}
break;
default:
return ch->drop(data);
}
return 0;
}
fix accidental parenthesis in palette by using an icon, it's the same than the note one, added a shortcut to add bracket around note and accidental
2014-07-18 00:11:00 +02:00
//---------------------------------------------------------
Plural of parenthesis is parentheses
2017-01-31 19:30:49 +01:00
// addParentheses
fix accidental parenthesis in palette by using an icon, it's the same than the note one, added a shortcut to add bracket around note and accidental
2014-07-18 00:11:00 +02:00
//---------------------------------------------------------
fix #27811
2014-07-18 18:38:14 +02:00
Plural of parenthesis is parentheses
2017-01-31 19:30:49 +01:00
void Note::addParentheses()
fix accidental parenthesis in palette by using an icon, it's the same than the note one, added a shortcut to add bracket around note and accidental
2014-07-18 00:11:00 +02:00
{
Symbol* s = new Symbol(score());
s->setSym(SymId::noteheadParenthesisLeft);
s->setParent(this);
score()->undoAddElement(s);
s = new Symbol(score());
s->setSym(SymId::noteheadParenthesisRight);
s->setParent(this);
score()->undoAddElement(s);
}
fix #27811
2014-07-18 18:38:14 +02:00
manually merge PR #797 and PR#808
2014-04-02 20:31:37 +02:00
//---------------------------------------------------------
fix #22883: glitches with size / distance settings
2014-08-10 19:39:52 +02:00
// setDotY
manually merge PR #797 and PR#808
2014-04-02 20:31:37 +02:00
//---------------------------------------------------------
framework for partial relayout
2016-03-02 13:20:19 +01:00
void Note::setDotY(Direction pos)
manually merge PR #797 and PR#808
2014-04-02 20:31:37 +02:00
{
bool onLine = false;
qreal y = 0;
change StaffType interface
2016-12-13 13:16:17 +01:00
if (staff()->isTabStaff(chord()->tick())) {
manually merge PR #797 and PR#808
2014-04-02 20:31:37 +02:00
// with TAB's, dotPosX is not set:
// get dot X from width of fret text and use TAB default spacing
change StaffType interface
2016-12-13 13:16:17 +01:00
StaffType* tab = staff()->staffType(tick());
manually merge PR #797 and PR#808
2014-04-02 20:31:37 +02:00
if (tab->stemThrough() ) {
// if fret mark on lines, use standard processing
if (tab->onLines())
onLine = true;
else
// if fret marks above lines, raise the dots by half line distance
y = -0.5;
}
// if stems beside staff, do nothing
else
return;
}
else
onLine = !(line() & 1);
bool oddVoice = voice() & 1;
if (onLine) {
// displace dots by half spatium up or down according to voice
framework for partial relayout
2016-03-02 13:20:19 +01:00
if (pos == Direction::AUTO)
manually merge PR #797 and PR#808
2014-04-02 20:31:37 +02:00
y = oddVoice ? 0.5 : -0.5;
framework for partial relayout
2016-03-02 13:20:19 +01:00
else if (pos == Direction::UP)
manually merge PR #797 and PR#808
2014-04-02 20:31:37 +02:00
y = -0.5;
else
y = 0.5;
}
else {
framework for partial relayout
2016-03-02 13:20:19 +01:00
if (pos == Direction::UP && !oddVoice)
manually merge PR #797 and PR#808
2014-04-02 20:31:37 +02:00
y -= 1.0;
framework for partial relayout
2016-03-02 13:20:19 +01:00
else if (pos == Direction::DOWN && oddVoice)
manually merge PR #797 and PR#808
2014-04-02 20:31:37 +02:00
y += 1.0;
}
change StaffType interface
2016-12-13 13:16:17 +01:00
y *= spatium() * staff()->lineDistance(tick());
manually merge PR #797 and PR#808
2014-04-02 20:31:37 +02:00
// apply to dots
Layout reorganization
2016-01-04 14:48:58 +01:00
int cdots = chord()->dots();
int ndots = _dots.size();
int n = cdots - ndots;
for (int i = 0; i < n; ++i) {
NoteDot* dot = new NoteDot(score());
dot->setParent(this);
dot->setTrack(track()); // needed to know the staff it belongs to (and detect tablature)
dot->setVisible(visible());
score()->undoAddElement(dot);
}
if (n < 0) {
for (int i = 0; i < -n; ++i)
score()->undoRemoveElement(_dots.back());
manually merge PR #797 and PR#808
2014-04-02 20:31:37 +02:00
}
fix note dot layout after editing
2016-05-12 16:51:42 +02:00
for (NoteDot* dot : _dots) {
dot->layout();
dot->rypos() = y;
}
manually merge PR #797 and PR#808
2014-04-02 20:31:37 +02:00
}
Initial commit
2012-05-26 14:26:10 +02:00
//---------------------------------------------------------
// layout
//---------------------------------------------------------
void Note::layout()
{
change StaffType interface
2016-12-13 13:16:17 +01:00
bool useTablature = staff() && staff()->isTabStaff(chord()->tick());
Initial commit
2012-05-26 14:26:10 +02:00
if (useTablature) {
change StaffType interface
2016-12-13 13:16:17 +01:00
StaffType* tab = staff()->staffType(tick());
Initial commit
2012-05-26 14:26:10 +02:00
qreal mags = magS();
Separated Note::tabHeadWidth() and Note::tabHeadHeight() methods for TAB's from generic Note::headWidth() and Note::headHeight()
2012-12-28 00:30:46 +01:00
qreal w = tabHeadWidth(tab);
Fix #19923: TAB digits not centered on stem
2013-02-04 23:28:24 +01:00
bbox().setRect(0.0, tab->fretBoxY() * mags, w, tab->fretBoxH() * mags);
Initial commit
2012-05-26 14:26:10 +02:00
}
layout changes
2012-08-01 18:00:27 +02:00
else {
Add more noteheads and staff type for dynamic noteheads (shapes, notenames, etc...)
2016-10-22 20:16:42 +02:00
SymId nh = noteHead();
_cachedNoteheadSym = nh;
if (isNoteName()) {
_cachedSymNull = SymId::noteEmptyBlack;
NoteHead::Type ht = _headType == NoteHead::Type::HEAD_AUTO ? chord()->durationType().headType() : _headType;
if (ht == NoteHead::Type::HEAD_WHOLE)
_cachedSymNull = SymId::noteEmptyWhole;
else if (ht == NoteHead::Type::HEAD_HALF)
_cachedSymNull = SymId::noteEmptyHalf;
}
else
_cachedSymNull = SymId::noSym;
setbbox(symBbox(nh));
TAB: make "Stem through staves" option more similar to regular pitch layout.
2013-03-09 09:58:43 +01:00
}
Initial commit
2012-05-26 14:26:10 +02:00
}
//---------------------------------------------------------
// layout2
// called after final position of note is set
//---------------------------------------------------------
void Note::layout2()
{
fix #66241: note offset not preserved for tab
2015-06-22 20:42:22 +02:00
// for standard staves this is done in Score::layoutChords3()
fix #25803: account for user offset during chord layout
2014-05-21 00:43:28 +02:00
// so that the results are available there
barline changes, part-1
2016-12-23 12:05:18 +01:00
change StaffType interface
2016-12-13 13:16:17 +01:00
if (staff()->isTabStaff(chord()->tick()))
fix #66241: note offset not preserved for tab
2015-06-22 20:42:22 +02:00
adjustReadPos();
Initial commit
2012-05-26 14:26:10 +02:00
int dots = chord()->dots();
if (dots) {
tweaks for chord offsets (small, dots)
2014-08-11 06:57:11 +02:00
qreal d = score()->point(score()->styleS(StyleIdx::dotNoteDistance)) * mag();
qreal dd = score()->point(score()->styleS(StyleIdx::dotDotDistance)) * mag();
Initial commit
2012-05-26 14:26:10 +02:00
qreal x = chord()->dotPosX() - pos().x() - chord()->pos().x();
TAB: fix cases of wrong positions of augm. dots with "Stems through staves" option
2013-03-23 11:36:04 +01:00
// if TAB and stems through staff
change StaffType interface
2016-12-13 13:16:17 +01:00
if (staff()->isTabStaff(chord()->tick())) {
StaffType* tab = staff()->staffType(tick());
fix #64861: Linked tablature fret with dot doesn't display bracket
2015-06-11 21:49:55 +02:00
if (tab->stemThrough()) {
// with TAB's, dot Y is not calculated during layoutChords3(),
// as layoutChords3() is not even called for TAB's;
// setDotY() actually also manages creation/deletion of NoteDot's
framework for partial relayout
2016-03-02 13:20:19 +01:00
setDotY(Direction::AUTO);
fix #64861: Linked tablature fret with dot doesn't display bracket
2015-06-11 21:49:55 +02:00
// use TAB default note-to-dot spacing
dd = STAFFTYPE_TAB_DEFAULTDOTDIST_X * spatium();
d = dd * 0.5;
}
TAB: fix cases of wrong positions of augm. dots with "Stems through staves" option
2013-03-23 11:36:04 +01:00
}
more regression fixes & cleaups
2016-02-06 11:41:16 +01:00
// apply to dots
qreal xx = x + d;
for (NoteDot* dot : _dots) {
dot->rxpos() = xx;
dot->adjustReadPos();
xx += dd;
Initial commit
2012-05-26 14:26:10 +02:00
}
}
TAB: fix cases of wrong positions of augm. dots with "Stems through staves" option
2013-03-23 11:36:04 +01:00
// layout elements attached to note
cleanups
2013-03-25 16:27:20 +01:00
for (Element* e : _el) {
Initial commit
2012-05-26 14:26:10 +02:00
if (!score()->tagIsValid(e->tag()))
continue;
e->setMag(mag());
preparations for new compatibility implementation
2016-09-13 09:39:50 +02:00
if (e->isSymbol()) {
fix #21410: Notehead brackets collide with fret number
2013-06-03 14:53:50 +02:00
qreal w = headWidth();
preparations for new compatibility implementation
2016-09-13 09:39:50 +02:00
Symbol* sym = toSymbol(e);
fix #26586
2014-07-15 15:05:36 +02:00
QPointF rp = e->readPos();
e->layout();
fix note parenthesis SMuFL way, use proper accidental parenthesis from SMuFL font
2014-11-25 18:01:41 +01:00
if (sym->sym() == SymId::noteheadParenthesisRight) {
change StaffType interface
2016-12-13 13:16:17 +01:00
if (staff()->isTabStaff(chord()->tick())) {
StaffType* tab = staff()->staffType(tick());
fix note parenthesis SMuFL way, use proper accidental parenthesis from SMuFL font
2014-11-25 18:01:41 +01:00
w = tabHeadWidth(tab);
}
e->rxpos() += w;
}
else if (sym->sym() == SymId::noteheadParenthesisLeft) {
e->rxpos() -= symWidth(SymId::noteheadParenthesisLeft);
}
if (sym->sym() == SymId::noteheadParenthesisLeft || sym->sym() == SymId::noteheadParenthesisRight) {
// adjustReadPos() was called too early in layout(), adjust:
if (!rp.isNull()) {
e->setUserOff(QPointF());
e->setReadPos(rp);
e->adjustReadPos();
}
fix #26586
2014-07-15 15:05:36 +02:00
}
fix #21410: Notehead brackets collide with fret number
2013-06-03 14:53:50 +02:00
}
fix #26586
2014-07-15 15:05:36 +02:00
else
e->layout();
Initial commit
2012-05-26 14:26:10 +02:00
}
}
//---------------------------------------------------------
// dotIsUp
//---------------------------------------------------------
bool Note::dotIsUp() const
{
code cleanups & speed optimizations
2016-02-06 22:03:43 +01:00
if (_dots.empty())
Initial commit
2012-05-26 14:26:10 +02:00
return true;
framework for partial relayout
2016-03-02 13:20:19 +01:00
if (_userDotPosition == Direction::AUTO)
allow dot flip for notes on spaces
2014-04-02 22:37:13 +02:00
return _dots[0]->y() < spatium() * .1;
else
framework for partial relayout
2016-03-02 13:20:19 +01:00
return (_userDotPosition == Direction::UP);
Initial commit
2012-05-26 14:26:10 +02:00
}
fix layout regression: wrong stem direction
2015-02-17 22:17:22 +01:00
//---------------------------------------------------------
// updateAccidental
// set _accidental and _line depending on tpc
//---------------------------------------------------------
void Note::updateAccidental(AccidentalState* as)
{
int relLine = absStep(tpc(), epitch());
// don't touch accidentals that don't concern tpc such as
// quarter tones
fix read114 test for accidentals, remove old unused accidentals and replace by naturals. Order accidentals like SMuFL. Add a couple more accidentals.
2016-09-29 01:18:02 +02:00
if (!(_accidental && Accidental::isMicrotonal(_accidental->accidentalType()))) {
fix layout regression: wrong stem direction
2015-02-17 22:17:22 +01:00
// calculate accidental
move enums Accidental::Role and ::Type
2015-04-02 10:33:53 +02:00
AccidentalType acci = AccidentalType::NONE;
fix layout regression: wrong stem direction
2015-02-17 22:17:22 +01:00
AccidentalVal accVal = tpc2alter(tpc());
fix #81731: Crash when repeatedly pressing Shift+A
2016-01-21 14:33:32 +01:00
bool error = false;
AccidentalVal relLineAccVal = as->accidentalVal(relLine, error);
if (error)
return;
if ((accVal != relLineAccVal) || hidden() || as->tieContext(relLine)) {
fix layout regression: wrong stem direction
2015-02-17 22:17:22 +01:00
as->setAccidentalVal(relLine, accVal, _tieBack != 0);
fix #54501: Tied enharmonics incorrectly notated
2016-04-18 05:22:32 +02:00
acci = Accidental::value2subtype(accVal);
Fix regression where there are multiple tied notes with the same accidental
2016-05-15 05:45:46 +02:00
// if previous tied note has same tpc, don't show accidental
if (_tieBack && _tieBack->startNote()->tpc1() == tpc1())
move enums Accidental::Role and ::Type
2015-04-02 10:33:53 +02:00
acci = AccidentalType::NONE;
fix #54501: Tied enharmonics incorrectly notated
2016-04-18 05:22:32 +02:00
else if (acci == AccidentalType::NONE)
acci = AccidentalType::NATURAL;
fix layout regression: wrong stem direction
2015-02-17 22:17:22 +01:00
}
fix #54501: Tied enharmonics incorrectly notated
2016-04-18 05:22:32 +02:00
if (acci != AccidentalType::NONE && !_hidden) {
fix layout regression: wrong stem direction
2015-02-17 22:17:22 +01:00
if (_accidental == 0) {
Accidental* a = new Accidental(score());
a->setParent(this);
a->setAccidentalType(acci);
score()->undoAddElement(a);
}
else if (_accidental->accidentalType() != acci) {
Accidental* a = _accidental->clone();
a->setParent(this);
a->setAccidentalType(acci);
score()->undoChangeElement(_accidental, a);
}
}
else {
if (_accidental) {
// remove this if it was AUTO:
move enums Accidental::Role and ::Type
2015-04-02 10:33:53 +02:00
if (_accidental->role() == AccidentalRole::AUTO)
fix layout regression: wrong stem direction
2015-02-17 22:17:22 +01:00
score()->undoRemoveElement(_accidental);
else {
// keep it, but update type if needed
acci = Accidental::value2subtype(accVal);
move enums Accidental::Role and ::Type
2015-04-02 10:33:53 +02:00
if (acci == AccidentalType::NONE)
acci = AccidentalType::NATURAL;
fix layout regression: wrong stem direction
2015-02-17 22:17:22 +01:00
if (_accidental->accidentalType() != acci) {
Accidental* a = _accidental->clone();
a->setParent(this);
a->setAccidentalType(acci);
score()->undoChangeElement(_accidental, a);
}
}
}
}
}
else {
// microtonal accidentals playback as naturals
// in 1.X, they had no effect on accidental state of measure
// ultimetely, they should probably get their own state
// for now, at least change state to natural, so subsequent notes playback as might be expected
// this is an incompatible change, but better to break it for 2.0 than wait until later
as->setAccidentalVal(relLine, AccidentalVal::NATURAL, _tieBack != 0);
}
updateRelLine(relLine, true);
}
Initial commit
2012-05-26 14:26:10 +02:00
//---------------------------------------------------------
// noteType
//---------------------------------------------------------
NoteType Note::noteType() const
{
return chord()->noteType();
}
Score accessibility system. Provides screen-reader feedback for the selected element.
2014-07-10 14:13:37 +02:00
//---------------------------------------------------------
// noteTypeUserName
//---------------------------------------------------------
code cleanups
2016-02-04 17:06:32 +01:00
QString Note::noteTypeUserName() const
Score accessibility system. Provides screen-reader feedback for the selected element.
2014-07-10 14:13:37 +02:00
{
switch (noteType()) {
case NoteType::ACCIACCATURA:
replace Q_OBJECT with Q_GADGET for all Element based classes
2017-02-17 15:09:28 +01:00
return QObject::tr("Acciaccatura");
Score accessibility system. Provides screen-reader feedback for the selected element.
2014-07-10 14:13:37 +02:00
case NoteType::APPOGGIATURA:
replace Q_OBJECT with Q_GADGET for all Element based classes
2017-02-17 15:09:28 +01:00
return QObject::tr("Appoggiatura");
Score accessibility system. Provides screen-reader feedback for the selected element.
2014-07-10 14:13:37 +02:00
case NoteType::GRACE8_AFTER:
case NoteType::GRACE16_AFTER:
case NoteType::GRACE32_AFTER:
replace Q_OBJECT with Q_GADGET for all Element based classes
2017-02-17 15:09:28 +01:00
return QObject::tr("Grace note after");
Score accessibility system. Provides screen-reader feedback for the selected element.
2014-07-10 14:13:37 +02:00
case NoteType::GRACE4:
case NoteType::GRACE16:
fix #30071
2014-08-20 09:50:42 +02:00
case NoteType::GRACE32:
replace Q_OBJECT with Q_GADGET for all Element based classes
2017-02-17 15:09:28 +01:00
return QObject::tr("Grace note before");
Score accessibility system. Provides screen-reader feedback for the selected element.
2014-07-10 14:13:37 +02:00
default:
replace Q_OBJECT with Q_GADGET for all Element based classes
2017-02-17 15:09:28 +01:00
return QObject::tr("Note");
Score accessibility system. Provides screen-reader feedback for the selected element.
2014-07-10 14:13:37 +02:00
}
}
Initial commit
2012-05-26 14:26:10 +02:00
//---------------------------------------------------------
// scanElements
//---------------------------------------------------------
void Note::scanElements(void* data, void (*func)(void*, Element*), bool all)
{
func(data, this);
// tie segments are collected from System
change StaffType interface
2016-12-13 13:16:17 +01:00
// if (_tieFor && !staff()->isTabStaff(chord->tick())) // no ties in tablature
Initial commit
2012-05-26 14:26:10 +02:00
// _tieFor->scanElements(data, func, all);
cleanups
2013-03-25 16:27:20 +01:00
for (Element* e : _el) {
Initial commit
2012-05-26 14:26:10 +02:00
if (score()->tagIsValid(e->tag()))
e->scanElements(data, func, all);
}
regression: fix note line
2013-07-04 13:40:25 +02:00
for (Spanner* sp : _spannerFor)
sp->scanElements(data, func, all);
fix selection of note anchord TextLine segments
2012-09-17 10:43:59 +02:00
Initial commit
2012-05-26 14:26:10 +02:00
if (!dragMode && _accidental)
func(data, _accidental);
fix 106366: <Select all similar element> is broken
2016-04-20 10:45:51 +02:00
for (NoteDot* dot : _dots)
func(data, dot);
Initial commit
2012-05-26 14:26:10 +02:00
}
//---------------------------------------------------------
// setTrack
//---------------------------------------------------------
void Note::setTrack(int val)
{
Element::setTrack(val);
if (_tieFor) {
_tieFor->setTrack(val);
cross beam fixes
2016-03-19 11:41:38 +01:00
for (SpannerSegment* seg : _tieFor->spannerSegments())
Initial commit
2012-05-26 14:26:10 +02:00
seg->setTrack(val);
}
fix #49751: Crash when removing stave with glissando
2015-03-05 18:57:48 +01:00
for (Spanner* s : _spannerFor) {
s->setTrack(val);
}
for (Spanner* s : _spannerBack) {
s->setTrack2(val);
}
cross beam fixes
2016-03-19 11:41:38 +01:00
for (Element* e : _el)
Initial commit
2012-05-26 14:26:10 +02:00
e->setTrack(val);
if (_accidental)
_accidental->setTrack(val);
if (!chord()) // if note is dragged with shift+ctrl
return;
Layout reorganization
2016-01-04 14:48:58 +01:00
for (NoteDot* dot : _dots)
dot->setTrack(val);
Initial commit
2012-05-26 14:26:10 +02:00
}
//---------------------------------------------------------
rename toDefault() to reset()
2012-11-19 10:08:15 +01:00
// reset
Initial commit
2012-05-26 14:26:10 +02:00
//---------------------------------------------------------
rename toDefault() to reset()
2012-11-19 10:08:15 +01:00
void Note::reset()
Initial commit
2012-05-26 14:26:10 +02:00
{
inspector updates; misc. cleanups
2016-06-09 09:26:13 +02:00
undoChangeProperty(P_ID::USER_OFF, QPointF());
chord()->undoChangeProperty(P_ID::USER_OFF, QPointF());
chord()->undoChangeProperty(P_ID::STEM_DIRECTION, Direction(Direction::AUTO));
Initial commit
2012-05-26 14:26:10 +02:00
}
//---------------------------------------------------------
fix #21221
2013-05-28 15:42:02 +02:00
// mag
Initial commit
2012-05-26 14:26:10 +02:00
//---------------------------------------------------------
fix #21221
2013-05-28 15:42:02 +02:00
qreal Note::mag() const
Initial commit
2012-05-26 14:26:10 +02:00
{
fix #21221
2013-05-28 15:42:02 +02:00
qreal m = chord()->mag();
if (_small)
convert enum StyleIdx into enum class
2014-05-26 15:31:36 +02:00
m *= score()->styleD(StyleIdx::smallNoteMag);
fix #21221
2013-05-28 15:42:02 +02:00
return m;
Initial commit
2012-05-26 14:26:10 +02:00
}
fix stem layout; some optimizations
2013-01-02 09:29:17 +01:00
//---------------------------------------------------------
// setSmall
//---------------------------------------------------------
void Note::setSmall(bool val)
{
_small = val;
}
some layout optimizations/claenups
2015-02-19 10:28:25 +01:00
//---------------------------------------------------------
// line
//---------------------------------------------------------
fix #8924: native support for slash notation
2014-11-15 21:28:16 +01:00
int Note::line() const
{
if (_fixed)
return _fixedLine;
else
return _line + _lineOffset;
}
Initial commit
2012-05-26 14:26:10 +02:00
//---------------------------------------------------------
// setString
//---------------------------------------------------------
void Note::setString(int val)
{
_string = val;
rypos() = _string * spatium() * 1.5;
}
//---------------------------------------------------------
// setHeadGroup
//---------------------------------------------------------
move NoteHeadGroup to NoteHead::Group needed to make it available to the plugin framework
2014-06-25 21:18:26 +02:00
void Note::setHeadGroup(NoteHead::Group val)
Initial commit
2012-05-26 14:26:10 +02:00
{
move NoteHeadGroup to NoteHead::Group needed to make it available to the plugin framework
2014-06-25 21:18:26 +02:00
Q_ASSERT(int(val) >= 0 && int(val) < int(NoteHead::Group::HEAD_GROUPS));
Initial commit
2012-05-26 14:26:10 +02:00
_headGroup = val;
}
//---------------------------------------------------------
// ppitch
// playback pitch
//---------------------------------------------------------
int Note::ppitch() const
{
implement separate tpc values for transposed view
2014-04-09 09:40:25 +02:00
return _pitch + staff()->pitchOffset(chord()->segment()->tick());
first fix for #18099
2014-04-02 18:11:56 +02:00
}
//---------------------------------------------------------
// epitch
// effective pitch
// honours transposing instruments
//---------------------------------------------------------
int Note::epitch() const
{
implement separate tpc values for transposed view
2014-04-09 09:40:25 +02:00
return _pitch - (concertPitch() ? 0 : transposition());
Initial commit
2012-05-26 14:26:10 +02:00
}
//---------------------------------------------------------
// customizeVelocity
// Input is the global velocity determined by dynamic
// signs and crescende/decrescendo etc.
// Returns the actual play velocity for this note
// modified by veloOffset
//---------------------------------------------------------
int Note::customizeVelocity(int velo) const
{
use char for some enums
2014-05-07 18:09:01 +02:00
if (veloType() == ValueType::OFFSET_VAL)
Initial commit
2012-05-26 14:26:10 +02:00
velo = velo + (velo * veloOffset()) / 100;
use char for some enums
2014-05-07 18:09:01 +02:00
else if (veloType() == ValueType::USER_VAL)
Initial commit
2012-05-26 14:26:10 +02:00
velo = veloOffset();
avoid use of a reserved keyword for a function name even when it is inline
2014-05-12 12:52:13 +02:00
return limit(velo, 1, 127);
Initial commit
2012-05-26 14:26:10 +02:00
}
//---------------------------------------------------------
// endEdit
//---------------------------------------------------------
void Note::endEdit()
{
Chord* ch = chord();
if (ch->notes().size() == 1) {
inspector updates; misc. cleanups
2016-06-09 09:26:13 +02:00
ch->undoChangeProperty(P_ID::USER_OFF, ch->userOff() + userOff());
Initial commit
2012-05-26 14:26:10 +02:00
setUserOff(QPointF());
remove many setLayoutAll() calls; cleanups
2016-06-14 10:32:34 +02:00
triggerLayout();
Initial commit
2012-05-26 14:26:10 +02:00
}
}
bug fixes for concert pitch switch
2014-04-09 16:09:21 +02:00
//---------------------------------------------------------
// updateRelLine
// calculate the real note line depending on clef,
// _line is the absolute line
//---------------------------------------------------------
Note::updateAccidental() no longer removes ACC_USER accidentals
2013-03-10 14:10:09 +01:00
fix #25434
2014-04-22 17:02:03 +02:00
void Note::updateRelLine(int relLine, bool undoable)
bug fixes for concert pitch switch
2014-04-09 16:09:21 +02:00
{
barline changes, part-1
2016-12-23 12:05:18 +01:00
if (!staff())
return;
int idx = staffIdx() + chord()->staffMove();
Staff* stf = score()->staff(idx);
StaffType* st = stf->staffType(tick());
if (chord()->staffMove()) {
fix #30011: crash on delete of staff with cross staff note
2014-11-27 01:47:03 +01:00
// check that destination staff makes sense (might have been deleted)
barline changes, part-1
2016-12-23 12:05:18 +01:00
idx += chord()->staffMove();
code cleanups; rename instr() to instrument()
2015-03-13 11:16:43 +01:00
int minStaff = part()->startTrack() / VOICES;
int maxStaff = part()->endTrack() / VOICES;
barline changes, part-1
2016-12-23 12:05:18 +01:00
if (idx < minStaff || idx >= maxStaff || st->group() != staff()->staffType(tick())->group())
fix #30011: crash on delete of staff with cross staff note
2014-11-27 01:47:03 +01:00
chord()->undoChangeProperty(P_ID::STAFF_MOVE, 0);
}
fix #30071
2014-08-20 09:50:42 +02:00
barline changes, part-1
2016-12-23 12:05:18 +01:00
ClefType clef = stf->clef(chord()->tick());
misc. updates to layout
2016-03-18 09:29:16 +01:00
int line = relStep(relLine, clef);
Layout reorganization
2016-01-04 14:48:58 +01:00
barline changes, part-1
2016-12-23 12:05:18 +01:00
if (undoable && _line != INVALID_LINE)
undoChangeProperty(P_ID::LINE, line);
else
setLine(line);
int off = st->stepOffset();
qreal ld = st->lineDistance().val();
rypos() = (_line + off * 2.0) * spatium() * .5 * ld;
Initial commit
2012-05-26 14:26:10 +02:00
}
//---------------------------------------------------------
// updateLine
//---------------------------------------------------------
void Note::updateLine()
{
fix #25434
2014-04-22 17:02:03 +02:00
int relLine = absStep(tpc(), epitch());
updateRelLine(relLine, false);
Initial commit
2012-05-26 14:26:10 +02:00
}
//---------------------------------------------------------
// setNval
fix #33366
2014-09-22 14:31:28 +02:00
// set note properties from NoteVal
Initial commit
2012-05-26 14:26:10 +02:00
//---------------------------------------------------------
fix #41511: bad tpc1 for notes entered in keys other than C
2014-12-15 23:08:33 +01:00
void Note::setNval(const NoteVal& nval, int tick)
Initial commit
2012-05-26 14:26:10 +02:00
{
setPitch(nval.pitch);
fix #25600
2014-06-26 11:41:18 +02:00
_fret = nval.fret;
_string = nval.string;
fix #33366
2014-09-22 14:31:28 +02:00
_tpc[0] = nval.tpc1;
_tpc[1] = nval.tpc2;
fix #9352: instrument change transposition
2015-09-21 02:13:22 +02:00
if (tick == -1 && chord())
tick = chord()->tick();
Interval v = part()->instrument(tick)->transpose();
fix #33366
2014-09-22 14:31:28 +02:00
if (nval.tpc1 == Tpc::TPC_INVALID) {
fix #41511: bad tpc1 for notes entered in keys other than C
2014-12-15 23:08:33 +01:00
Key key = staff()->key(tick);
fix #44186: tpc calculated in wrong key with transposing instruments
2015-01-12 23:40:22 +01:00
if (!concertPitch() && !v.isZero())
key = transposeKey(key, v);
convert unnamed enum into enum class Prefer
2014-05-23 21:14:22 +02:00
_tpc[0] = pitch2tpc(nval.pitch, key, Prefer::NEAREST);
fix #33366
2014-09-22 14:31:28 +02:00
}
if (nval.tpc2 == Tpc::TPC_INVALID) {
fix #25340
2014-04-17 12:32:10 +02:00
if (v.isZero())
_tpc[1] = _tpc[0];
else {
v.flip();
fix #41766: use double sharp/flat where appropriate when transposing
2014-12-20 00:27:06 +01:00
_tpc[1] = Ms::transposeTpc(_tpc[0], v, true);
fix #25340
2014-04-17 12:32:10 +02:00
}
fix 25360
2014-04-11 14:50:53 +02:00
}
move NoteHeadGroup to NoteHead::Group needed to make it available to the plugin framework
2014-06-25 21:18:26 +02:00
_headGroup = NoteHead::Group(nval.headGroup);
Initial commit
2012-05-26 14:26:10 +02:00
}
property implementation rollback
2012-08-10 17:01:35 +02:00
//---------------------------------------------------------
// getProperty
//---------------------------------------------------------
QVariant Note::getProperty(P_ID propertyId) const
{
fix note dot layout after editing
2016-05-12 16:51:42 +02:00
switch (propertyId) {
convert enum P_ID into enum class
2014-05-26 18:18:01 +02:00
case P_ID::PITCH:
property implementation rollback
2012-08-10 17:01:35 +02:00
return pitch();
convert enum P_ID into enum class
2014-05-26 18:18:01 +02:00
case P_ID::TPC1:
implement separate tpc values for transposed view
2014-04-09 09:40:25 +02:00
return _tpc[0];
convert enum P_ID into enum class
2014-05-26 18:18:01 +02:00
case P_ID::TPC2:
implement separate tpc values for transposed view
2014-04-09 09:40:25 +02:00
return _tpc[1];
convert enum P_ID into enum class
2014-05-26 18:18:01 +02:00
case P_ID::SMALL:
property implementation rollback
2012-08-10 17:01:35 +02:00
return small();
convert enum P_ID into enum class
2014-05-26 18:18:01 +02:00
case P_ID::MIRROR_HEAD:
use char for some enums
2014-05-07 18:09:01 +02:00
return int(userMirror());
convert enum P_ID into enum class
2014-05-26 18:18:01 +02:00
case P_ID::DOT_POSITION:
fix Direction property conversion to QVariant
2016-05-12 15:39:49 +02:00
return userDotPosition();
convert enum P_ID into enum class
2014-05-26 18:18:01 +02:00
case P_ID::HEAD_GROUP:
add ScoreFont to Symbol class; extend master palette symbols dialog; misc cleanups
2013-11-25 15:02:23 +01:00
return int(headGroup());
convert enum P_ID into enum class
2014-05-26 18:18:01 +02:00
case P_ID::VELO_OFFSET:
property implementation rollback
2012-08-10 17:01:35 +02:00
return veloOffset();
convert enum P_ID into enum class
2014-05-26 18:18:01 +02:00
case P_ID::TUNING:
property implementation rollback
2012-08-10 17:01:35 +02:00
return tuning();
convert enum P_ID into enum class
2014-05-26 18:18:01 +02:00
case P_ID::FRET:
property implementation rollback
2012-08-10 17:01:35 +02:00
return fret();
convert enum P_ID into enum class
2014-05-26 18:18:01 +02:00
case P_ID::STRING:
property implementation rollback
2012-08-10 17:01:35 +02:00
return string();
convert enum P_ID into enum class
2014-05-26 18:18:01 +02:00
case P_ID::GHOST:
property implementation rollback
2012-08-10 17:01:35 +02:00
return ghost();
convert enum P_ID into enum class
2014-05-26 18:18:01 +02:00
case P_ID::HEAD_TYPE:
add ScoreFont to Symbol class; extend master palette symbols dialog; misc cleanups
2013-11-25 15:02:23 +01:00
return int(headType());
convert enum P_ID into enum class
2014-05-26 18:18:01 +02:00
case P_ID::VELO_TYPE:
use char for some enums
2014-05-07 18:09:01 +02:00
return int(veloType());
convert enum P_ID into enum class
2014-05-26 18:18:01 +02:00
case P_ID::PLAY:
add play property for note; fix slur editing
2013-08-23 13:55:54 +02:00
return play();
convert enum P_ID into enum class
2014-05-26 18:18:01 +02:00
case P_ID::LINE:
fix #25434
2014-04-22 17:02:03 +02:00
return _line;
fix #8924: native support for slash notation
2014-11-15 21:28:16 +01:00
case P_ID::FIXED:
return fixed();
case P_ID::FIXED_LINE:
return fixedLine();
property implementation rollback
2012-08-10 17:01:35 +02:00
default:
break;
}
return Element::getProperty(propertyId);
}
//---------------------------------------------------------
// setProperty
//---------------------------------------------------------
bool Note::setProperty(P_ID propertyId, const QVariant& v)
{
fix for mtest
2015-01-05 15:15:48 +01:00
Measure* m = chord() ? chord()->measure() : nullptr;
property implementation rollback
2012-08-10 17:01:35 +02:00
switch(propertyId) {
convert enum P_ID into enum class
2014-05-26 18:18:01 +02:00
case P_ID::PITCH:
property implementation rollback
2012-08-10 17:01:35 +02:00
setPitch(v.toInt());
cleanup for score dirty status
2015-01-30 17:03:51 +01:00
score()->setPlaylistDirty();
property implementation rollback
2012-08-10 17:01:35 +02:00
break;
convert enum P_ID into enum class
2014-05-26 18:18:01 +02:00
case P_ID::TPC1:
implement separate tpc values for transposed view
2014-04-09 09:40:25 +02:00
_tpc[0] = v.toInt();
break;
convert enum P_ID into enum class
2014-05-26 18:18:01 +02:00
case P_ID::TPC2:
implement separate tpc values for transposed view
2014-04-09 09:40:25 +02:00
_tpc[1] = v.toInt();
fix #25434
2014-04-22 17:02:03 +02:00
break;
convert enum P_ID into enum class
2014-05-26 18:18:01 +02:00
case P_ID::LINE:
Layout reorganization
2016-01-04 14:48:58 +01:00
setLine(v.toInt());
property implementation rollback
2012-08-10 17:01:35 +02:00
break;
convert enum P_ID into enum class
2014-05-26 18:18:01 +02:00
case P_ID::SMALL:
property implementation rollback
2012-08-10 17:01:35 +02:00
setSmall(v.toBool());
break;
convert enum P_ID into enum class
2014-05-26 18:18:01 +02:00
case P_ID::MIRROR_HEAD:
move Direction and DirectionH into MScore needed to make them available to the plugin framework
2014-06-26 10:53:57 +02:00
setUserMirror(MScore::DirectionH(v.toInt()));
property implementation rollback
2012-08-10 17:01:35 +02:00
break;
convert enum P_ID into enum class
2014-05-26 18:18:01 +02:00
case P_ID::DOT_POSITION:
framework for partial relayout
2016-03-02 13:20:19 +01:00
setUserDotPosition(v.value<Direction>());
fix note dot layout after editing
2016-05-12 16:51:42 +02:00
score()->setLayout(tick());
return true;
convert enum P_ID into enum class
2014-05-26 18:18:01 +02:00
case P_ID::HEAD_GROUP:
move NoteHeadGroup to NoteHead::Group needed to make it available to the plugin framework
2014-06-25 21:18:26 +02:00
setHeadGroup(NoteHead::Group(v.toInt()));
property implementation rollback
2012-08-10 17:01:35 +02:00
break;
convert enum P_ID into enum class
2014-05-26 18:18:01 +02:00
case P_ID::VELO_OFFSET:
property implementation rollback
2012-08-10 17:01:35 +02:00
setVeloOffset(v.toInt());
cleanup for score dirty status
2015-01-30 17:03:51 +01:00
score()->setPlaylistDirty();
property implementation rollback
2012-08-10 17:01:35 +02:00
break;
convert enum P_ID into enum class
2014-05-26 18:18:01 +02:00
case P_ID::TUNING:
property implementation rollback
2012-08-10 17:01:35 +02:00
setTuning(v.toDouble());
cleanup for score dirty status
2015-01-30 17:03:51 +01:00
score()->setPlaylistDirty();
property implementation rollback
2012-08-10 17:01:35 +02:00
break;
convert enum P_ID into enum class
2014-05-26 18:18:01 +02:00
case P_ID::FRET:
property implementation rollback
2012-08-10 17:01:35 +02:00
setFret(v.toInt());
break;
convert enum P_ID into enum class
2014-05-26 18:18:01 +02:00
case P_ID::STRING:
property implementation rollback
2012-08-10 17:01:35 +02:00
setString(v.toInt());
break;
convert enum P_ID into enum class
2014-05-26 18:18:01 +02:00
case P_ID::GHOST:
property implementation rollback
2012-08-10 17:01:35 +02:00
setGhost(v.toBool());
break;
convert enum P_ID into enum class
2014-05-26 18:18:01 +02:00
case P_ID::HEAD_TYPE:
move NoteHeadType to NoteHead::Type needed to make it available to the plugin framework
2014-06-25 22:01:26 +02:00
setHeadType(NoteHead::Type(v.toInt()));
property implementation rollback
2012-08-10 17:01:35 +02:00
break;
convert enum P_ID into enum class
2014-05-26 18:18:01 +02:00
case P_ID::VELO_TYPE:
use char for some enums
2014-05-07 18:09:01 +02:00
setVeloType(ValueType(v.toInt()));
cleanup for score dirty status
2015-01-30 17:03:51 +01:00
score()->setPlaylistDirty();
property implementation rollback
2012-08-10 17:01:35 +02:00
break;
convert enum P_ID into enum class
2014-05-26 18:18:01 +02:00
case P_ID::VISIBLE: { // P_ID::VISIBLE requires reflecting property on dots
Allows to turn on/off visibility of note dot separately from note head visibility
2012-12-05 13:44:30 +01:00
setVisible(v.toBool());
int dots = chord()->dots();
for (int i = 0; i < dots; ++i) {
if (_dots[i])
_dots[i]->setVisible(visible());
}
fix #9355: only offset rests / flip stems if multivoice visible
2015-01-26 22:58:46 +01:00
if (m)
m->checkMultiVoices(chord()->staffIdx());
Allows to turn on/off visibility of note dot separately from note head visibility
2012-12-05 13:44:30 +01:00
break;
}
convert enum P_ID into enum class
2014-05-26 18:18:01 +02:00
case P_ID::PLAY:
add play property for note; fix slur editing
2013-08-23 13:55:54 +02:00
setPlay(v.toBool());
cleanup for score dirty status
2015-01-30 17:03:51 +01:00
score()->setPlaylistDirty();
add play property for note; fix slur editing
2013-08-23 13:55:54 +02:00
break;
fix #8924: native support for slash notation
2014-11-15 21:28:16 +01:00
case P_ID::FIXED:
setFixed(v.toBool());
break;
case P_ID::FIXED_LINE:
setFixedLine(v.toInt());
break;
property implementation rollback
2012-08-10 17:01:35 +02:00
default:
if (!Element::setProperty(propertyId, v))
return false;
break;
}
speed up some commands; cleanups
2016-06-03 10:17:06 +02:00
score()->setLayout(tick());
property implementation rollback
2012-08-10 17:01:35 +02:00
return true;
}
extend property implementation
2012-08-12 11:44:36 +02:00
//---------------------------------------------------------
// undoSetFret
//---------------------------------------------------------
void Note::undoSetFret(int val)
{
convert enum P_ID into enum class
2014-05-26 18:18:01 +02:00
undoChangeProperty(P_ID::FRET, val);
extend property implementation
2012-08-12 11:44:36 +02:00
}
//---------------------------------------------------------
// undoSetString
//---------------------------------------------------------
void Note::undoSetString(int val)
{
convert enum P_ID into enum class
2014-05-26 18:18:01 +02:00
undoChangeProperty(P_ID::STRING, val);
extend property implementation
2012-08-12 11:44:36 +02:00
}
//---------------------------------------------------------
// undoSetGhost
//---------------------------------------------------------
void Note::undoSetGhost(bool val)
{
convert enum P_ID into enum class
2014-05-26 18:18:01 +02:00
undoChangeProperty(P_ID::GHOST, val);
extend property implementation
2012-08-12 11:44:36 +02:00
}
//---------------------------------------------------------
// undoSetSmall
//---------------------------------------------------------
void Note::undoSetSmall(bool val)
{
convert enum P_ID into enum class
2014-05-26 18:18:01 +02:00
undoChangeProperty(P_ID::SMALL, val);
extend property implementation
2012-08-12 11:44:36 +02:00
}
add play property for note; fix slur editing
2013-08-23 13:55:54 +02:00
//---------------------------------------------------------
// undoSetPlay
//---------------------------------------------------------
void Note::undoSetPlay(bool val)
{
convert enum P_ID into enum class
2014-05-26 18:18:01 +02:00
undoChangeProperty(P_ID::PLAY, val);
add play property for note; fix slur editing
2013-08-23 13:55:54 +02:00
}
extend property implementation
2012-08-12 11:44:36 +02:00
//---------------------------------------------------------
// undoSetTuning
//---------------------------------------------------------
void Note::undoSetTuning(qreal val)
{
convert enum P_ID into enum class
2014-05-26 18:18:01 +02:00
undoChangeProperty(P_ID::TUNING, val);
extend property implementation
2012-08-12 11:44:36 +02:00
}
//---------------------------------------------------------
// undoSetVeloType
//---------------------------------------------------------
use char for some enums
2014-05-07 18:09:01 +02:00
void Note::undoSetVeloType(ValueType val)
extend property implementation
2012-08-12 11:44:36 +02:00
{
convert enum P_ID into enum class
2014-05-26 18:18:01 +02:00
undoChangeProperty(P_ID::VELO_TYPE, int(val));
extend property implementation
2012-08-12 11:44:36 +02:00
}
//---------------------------------------------------------
// undoSetVeloOffset
//---------------------------------------------------------
void Note::undoSetVeloOffset(int val)
{
convert enum P_ID into enum class
2014-05-26 18:18:01 +02:00
undoChangeProperty(P_ID::VELO_OFFSET, val);
extend property implementation
2012-08-12 11:44:36 +02:00
}
//---------------------------------------------------------
// undoSetUserMirror
//---------------------------------------------------------
move Direction and DirectionH into MScore needed to make them available to the plugin framework
2014-06-26 10:53:57 +02:00
void Note::undoSetUserMirror(MScore::DirectionH val)
extend property implementation
2012-08-12 11:44:36 +02:00
{
convert enum P_ID into enum class
2014-05-26 18:18:01 +02:00
undoChangeProperty(P_ID::MIRROR_HEAD, int(val));
extend property implementation
2012-08-12 11:44:36 +02:00
}
//---------------------------------------------------------
manually merge PR #797 and PR#808
2014-04-02 20:31:37 +02:00
// undoSetUserDotPosition
extend property implementation
2012-08-12 11:44:36 +02:00
//---------------------------------------------------------
framework for partial relayout
2016-03-02 13:20:19 +01:00
void Note::undoSetUserDotPosition(Direction val)
extend property implementation
2012-08-12 11:44:36 +02:00
{
fix note dot layout after editing
2016-05-12 16:51:42 +02:00
undoChangeProperty(P_ID::DOT_POSITION, val);
extend property implementation
2012-08-12 11:44:36 +02:00
}
//---------------------------------------------------------
// undoSetHeadGroup
//---------------------------------------------------------
move NoteHeadGroup to NoteHead::Group needed to make it available to the plugin framework
2014-06-25 21:18:26 +02:00
void Note::undoSetHeadGroup(NoteHead::Group val)
extend property implementation
2012-08-12 11:44:36 +02:00
{
convert enum P_ID into enum class
2014-05-26 18:18:01 +02:00
undoChangeProperty(P_ID::HEAD_GROUP, int(val));
extend property implementation
2012-08-12 11:44:36 +02:00
}
check for bad note head types
2013-01-28 21:45:36 +01:00
//---------------------------------------------------------
// setHeadType
//---------------------------------------------------------
move NoteHeadType to NoteHead::Type needed to make it available to the plugin framework
2014-06-25 22:01:26 +02:00
void Note::setHeadType(NoteHead::Type t)
check for bad note head types
2013-01-28 21:45:36 +01:00
{
_headType = t;
}
extend property implementation
2012-08-12 11:44:36 +02:00
//---------------------------------------------------------
// undoSetHeadType
//---------------------------------------------------------
move NoteHeadType to NoteHead::Type needed to make it available to the plugin framework
2014-06-25 22:01:26 +02:00
void Note::undoSetHeadType(NoteHead::Type val)
extend property implementation
2012-08-12 11:44:36 +02:00
{
convert enum P_ID into enum class
2014-05-26 18:18:01 +02:00
undoChangeProperty(P_ID::HEAD_TYPE, int(val));
extend property implementation
2012-08-12 11:44:36 +02:00
}
property implementation rollback
2012-08-10 17:01:35 +02:00
//---------------------------------------------------------
// propertyDefault
//---------------------------------------------------------
QVariant Note::propertyDefault(P_ID propertyId) const
{
switch(propertyId) {
convert enum P_ID into enum class
2014-05-26 18:18:01 +02:00
case P_ID::GHOST:
case P_ID::SMALL:
property implementation rollback
2012-08-10 17:01:35 +02:00
return false;
convert enum P_ID into enum class
2014-05-26 18:18:01 +02:00
case P_ID::MIRROR_HEAD:
move Direction and DirectionH into MScore needed to make them available to the plugin framework
2014-06-26 10:53:57 +02:00
return int(MScore::DirectionH::AUTO);
convert enum P_ID into enum class
2014-05-26 18:18:01 +02:00
case P_ID::DOT_POSITION:
fix Direction property conversion to QVariant
2016-05-12 15:39:49 +02:00
return Direction(Direction::AUTO);
convert enum P_ID into enum class
2014-05-26 18:18:01 +02:00
case P_ID::HEAD_GROUP:
move NoteHeadGroup to NoteHead::Group needed to make it available to the plugin framework
2014-06-25 21:18:26 +02:00
return int(NoteHead::Group::HEAD_NORMAL);
convert enum P_ID into enum class
2014-05-26 18:18:01 +02:00
case P_ID::VELO_OFFSET:
property implementation rollback
2012-08-10 17:01:35 +02:00
return 0;
convert enum P_ID into enum class
2014-05-26 18:18:01 +02:00
case P_ID::TUNING:
property implementation rollback
2012-08-10 17:01:35 +02:00
return 0.0;
convert enum P_ID into enum class
2014-05-26 18:18:01 +02:00
case P_ID::FRET:
case P_ID::STRING:
property implementation rollback
2012-08-10 17:01:35 +02:00
return -1;
convert enum P_ID into enum class
2014-05-26 18:18:01 +02:00
case P_ID::HEAD_TYPE:
move NoteHeadType to NoteHead::Type needed to make it available to the plugin framework
2014-06-25 22:01:26 +02:00
return int(NoteHead::Type::HEAD_AUTO);
convert enum P_ID into enum class
2014-05-26 18:18:01 +02:00
case P_ID::VELO_TYPE:
use char for some enums
2014-05-07 18:09:01 +02:00
return int (ValueType::OFFSET_VAL);
convert enum P_ID into enum class
2014-05-26 18:18:01 +02:00
case P_ID::PLAY:
add play property for note; fix slur editing
2013-08-23 13:55:54 +02:00
return true;
fix #8924: native support for slash notation
2014-11-15 21:28:16 +01:00
case P_ID::FIXED:
return false;
case P_ID::FIXED_LINE:
return 0;
note.cpp: small write optimization
2016-11-25 11:46:28 +01:00
case P_ID::TPC2:
return getProperty(P_ID::TPC1);
property implementation rollback
2012-08-10 17:01:35 +02:00
default:
break;
}
moved property Placement to Element; change musicxml import/export to use Placement property
2012-10-31 14:21:13 +01:00
return Element::propertyDefault(propertyId);
property implementation rollback
2012-08-10 17:01:35 +02:00
}
changes in rendermidi implementation
2012-11-19 09:29:46 +01:00
//---------------------------------------------------------
// setOnTimeOffset
//---------------------------------------------------------
implement separate tpc values for transposed view
2014-04-09 09:40:25 +02:00
void Note::setOnTimeOffset(int val)
changes in rendermidi implementation
2012-11-19 09:29:46 +01:00
{
implement separate tpc values for transposed view
2014-04-09 09:40:25 +02:00
_playEvents[0].setOntime(val);
import ontime and offtime offset from 1.3 scores
2014-04-23 15:07:37 +02:00
chord()->setPlayEventType(PlayEventType::User);
changes in rendermidi implementation
2012-11-19 09:29:46 +01:00
}
//---------------------------------------------------------
// setOffTimeOffset
//---------------------------------------------------------
implement separate tpc values for transposed view
2014-04-09 09:40:25 +02:00
void Note::setOffTimeOffset(int val)
changes in rendermidi implementation
2012-11-19 09:29:46 +01:00
{
implement separate tpc values for transposed view
2014-04-09 09:40:25 +02:00
_playEvents[0].setLen(val - _playEvents[0].ontime());
import ontime and offtime offset from 1.3 scores
2014-04-23 15:07:37 +02:00
chord()->setPlayEventType(PlayEventType::User);
changes in rendermidi implementation
2012-11-19 09:29:46 +01:00
}
low level optimizations
2013-01-02 20:13:58 +01:00
replace some qt container with hand crafted single linked list
2013-01-03 16:56:56 +01:00
//---------------------------------------------------------
refactoring spanner, part I
2013-06-10 11:03:34 +02:00
// setScore
replace some qt container with hand crafted single linked list
2013-01-03 16:56:56 +01:00
//---------------------------------------------------------
refactoring spanner, part I
2013-06-10 11:03:34 +02:00
void Note::setScore(Score* s)
replace some qt container with hand crafted single linked list
2013-01-03 16:56:56 +01:00
{
refactoring spanner, part I
2013-06-10 11:03:34 +02:00
Element::setScore(s);
if (_tieFor)
_tieFor->setScore(s);
fix #98756: Scaling of symbols in part set to scaling of full score
2016-02-19 10:23:23 +01:00
if (_accidental)
_accidental->setScore(s);
for (Element* el : _el)
el->setScore(s);
replace some qt container with hand crafted single linked list
2013-01-03 16:56:56 +01:00
}
fix #25600
2014-06-26 11:41:18 +02:00
Score accessibility system. Provides screen-reader feedback for the selected element.
2014-07-10 14:13:37 +02:00
//---------------------------------------------------------
// accessibleInfo
//---------------------------------------------------------
code cleanups
2016-02-04 17:06:32 +01:00
QString Note::accessibleInfo() const
Score accessibility system. Provides screen-reader feedback for the selected element.
2014-07-10 14:13:37 +02:00
{
QString duration = chord()->durationUserName();
replace Q_OBJECT with Q_GADGET for all Element based classes
2017-02-17 15:09:28 +01:00
QString voice = QObject::tr("Voice: %1").arg(QString::number(track() % VOICES + 1));
fix #39621: accessible info for drum and slash notation
2014-11-21 01:15:36 +01:00
QString pitchName;
fix #55436
2015-04-12 10:17:00 +02:00
const Drumset* drumset = part()->instrument()->drumset();
fix #39621: accessible info for drum and slash notation
2014-11-21 01:15:36 +01:00
if (fixed() && headGroup() == NoteHead::Group::HEAD_SLASH)
replace Q_OBJECT with Q_GADGET for all Element based classes
2017-02-17 15:09:28 +01:00
pitchName = chord()->noStem() ? QObject::tr("Beat Slash") : QObject::tr("Rhythm Slash");
change StaffType interface
2016-12-13 13:16:17 +01:00
else if (staff()->isDrumStaff(tick()) && drumset)
fix #55436
2015-04-12 10:17:00 +02:00
pitchName = qApp->translate("drumset", drumset->name(pitch()).toUtf8().constData());
fix #39621: accessible info for drum and slash notation
2014-11-21 01:15:36 +01:00
else
pitchName = tpcUserName(false);
replace Q_OBJECT with Q_GADGET for all Element based classes
2017-02-17 15:09:28 +01:00
return QObject::tr("%1; Pitch: %2; Duration: %3%4").arg(noteTypeUserName()).arg(pitchName).arg(duration).arg((chord()->isGrace() ? "" : QString("; %1").arg(voice)));
Score accessibility system. Provides screen-reader feedback for the selected element.
2014-07-10 14:13:37 +02:00
}
//---------------------------------------------------------
// screenReaderInfo
//---------------------------------------------------------
code cleanups
2016-02-04 17:06:32 +01:00
QString Note::screenReaderInfo() const
Score accessibility system. Provides screen-reader feedback for the selected element.
2014-07-10 14:13:37 +02:00
{
QString duration = chord()->durationUserName();
replace Q_OBJECT with Q_GADGET for all Element based classes
2017-02-17 15:09:28 +01:00
QString voice = QObject::tr("Voice: %1").arg(QString::number(track() % VOICES + 1));
fix #39621: accessible info for drum and slash notation
2014-11-21 01:15:36 +01:00
QString pitchName;
fix #55436
2015-04-12 10:17:00 +02:00
const Drumset* drumset = part()->instrument()->drumset();
fix #39621: accessible info for drum and slash notation
2014-11-21 01:15:36 +01:00
if (fixed() && headGroup() == NoteHead::Group::HEAD_SLASH)
replace Q_OBJECT with Q_GADGET for all Element based classes
2017-02-17 15:09:28 +01:00
pitchName = chord()->noStem() ? QObject::tr("Beat Slash") : QObject::tr("Rhythm Slash");
change StaffType interface
2016-12-13 13:16:17 +01:00
else if (staff()->isDrumStaff(tick()) && drumset)
fix #55436
2015-04-12 10:17:00 +02:00
pitchName = qApp->translate("drumset", drumset->name(pitch()).toUtf8().constData());
fix #39621: accessible info for drum and slash notation
2014-11-21 01:15:36 +01:00
else
pitchName = tpcUserName(true);
return QString("%1 %2 %3%4").arg(noteTypeUserName()).arg(pitchName).arg(duration).arg((chord()->isGrace() ? "" : QString("; %1").arg(voice)));
Score accessibility system. Provides screen-reader feedback for the selected element.
2014-07-10 14:13:37 +02:00
}
//---------------------------------------------------------
// accessibleExtraInfo
//---------------------------------------------------------
code cleanups
2016-02-04 17:06:32 +01:00
QString Note::accessibleExtraInfo() const
Score accessibility system. Provides screen-reader feedback for the selected element.
2014-07-10 14:13:37 +02:00
{
QString rez = "";
if (accidental()) {
fix 30281 Fix readability Optimize string allocation modified: libmscore/accidental.cpp modified: libmscore/ambitus.cpp modified: libmscore/articulation.cpp modified: libmscore/barline.cpp modified: libmscore/chord.cpp modified: libmscore/chordline.cpp modified: libmscore/chordrest.cpp modified: libmscore/dynamic.cpp modified: libmscore/fingering.cpp modified: libmscore/hairpin.cpp modified: libmscore/harmony.cpp modified: libmscore/jump.cpp modified: libmscore/keysig.cpp modified: libmscore/marker.cpp modified: libmscore/measure.cpp modified: libmscore/note.cpp modified: libmscore/ottava.cpp modified: libmscore/rest.cpp modified: libmscore/score.h modified: libmscore/tempotext.cpp modified: libmscore/text.cpp modified: libmscore/timesig.cpp modified: libmscore/tremolo.cpp modified: libmscore/trill.cpp modified: libmscore/volta.cpp modified: mscore/scoreaccessibility.cpp
2014-08-21 18:32:52 +02:00
rez = QString("%1 %2").arg(rez).arg(accidental()->screenReaderInfo());
Score accessibility system. Provides screen-reader feedback for the selected element.
2014-07-10 14:13:37 +02:00
}
code cleanups & speed optimizations
2016-02-06 22:03:43 +01:00
if (!el().empty()) {
cross beam fixes
2016-03-19 11:41:38 +01:00
for (Element* e : el()) {
Use Selection filter to filter screenreader extra info.
2015-02-03 01:55:37 +01:00
if (!score()->selectionFilter().canSelect(e)) continue;
fix 30281 Fix readability Optimize string allocation modified: libmscore/accidental.cpp modified: libmscore/ambitus.cpp modified: libmscore/articulation.cpp modified: libmscore/barline.cpp modified: libmscore/chord.cpp modified: libmscore/chordline.cpp modified: libmscore/chordrest.cpp modified: libmscore/dynamic.cpp modified: libmscore/fingering.cpp modified: libmscore/hairpin.cpp modified: libmscore/harmony.cpp modified: libmscore/jump.cpp modified: libmscore/keysig.cpp modified: libmscore/marker.cpp modified: libmscore/measure.cpp modified: libmscore/note.cpp modified: libmscore/ottava.cpp modified: libmscore/rest.cpp modified: libmscore/score.h modified: libmscore/tempotext.cpp modified: libmscore/text.cpp modified: libmscore/timesig.cpp modified: libmscore/tremolo.cpp modified: libmscore/trill.cpp modified: libmscore/volta.cpp modified: mscore/scoreaccessibility.cpp
2014-08-21 18:32:52 +02:00
rez = QString("%1 %2").arg(rez).arg(e->screenReaderInfo());
Score accessibility system. Provides screen-reader feedback for the selected element.
2014-07-10 14:13:37 +02:00
}
}
if (tieFor())
replace Q_OBJECT with Q_GADGET for all Element based classes
2017-02-17 15:09:28 +01:00
rez = QObject::tr("%1 Start of %2").arg(rez).arg(tieFor()->screenReaderInfo());
Score accessibility system. Provides screen-reader feedback for the selected element.
2014-07-10 14:13:37 +02:00
if (tieBack())
replace Q_OBJECT with Q_GADGET for all Element based classes
2017-02-17 15:09:28 +01:00
rez = QObject::tr("%1 End of %2").arg(rez).arg(tieBack()->screenReaderInfo());
Score accessibility system. Provides screen-reader feedback for the selected element.
2014-07-10 14:13:37 +02:00
code cleanups & speed optimizations
2016-02-06 22:03:43 +01:00
if (!spannerFor().empty()) {
cross beam fixes
2016-03-19 11:41:38 +01:00
for (Spanner* s : spannerFor()) {
if (!score()->selectionFilter().canSelect(s))
continue;
replace Q_OBJECT with Q_GADGET for all Element based classes
2017-02-17 15:09:28 +01:00
rez = QObject::tr("%1 Start of %2").arg(rez).arg(s->screenReaderInfo());
Score accessibility system. Provides screen-reader feedback for the selected element.
2014-07-10 14:13:37 +02:00
}
}
code cleanups & speed optimizations
2016-02-06 22:03:43 +01:00
if (!spannerBack().empty()) {
cross beam fixes
2016-03-19 11:41:38 +01:00
for (Spanner* s : spannerBack()) {
if (!score()->selectionFilter().canSelect(s))
continue;
replace Q_OBJECT with Q_GADGET for all Element based classes
2017-02-17 15:09:28 +01:00
rez = QObject::tr("%1 End of %2").arg(rez).arg(s->screenReaderInfo());
Score accessibility system. Provides screen-reader feedback for the selected element.
2014-07-10 14:13:37 +02:00
}
}
fix 30281 Fix readability Optimize string allocation modified: libmscore/accidental.cpp modified: libmscore/ambitus.cpp modified: libmscore/articulation.cpp modified: libmscore/barline.cpp modified: libmscore/chord.cpp modified: libmscore/chordline.cpp modified: libmscore/chordrest.cpp modified: libmscore/dynamic.cpp modified: libmscore/fingering.cpp modified: libmscore/hairpin.cpp modified: libmscore/harmony.cpp modified: libmscore/jump.cpp modified: libmscore/keysig.cpp modified: libmscore/marker.cpp modified: libmscore/measure.cpp modified: libmscore/note.cpp modified: libmscore/ottava.cpp modified: libmscore/rest.cpp modified: libmscore/score.h modified: libmscore/tempotext.cpp modified: libmscore/text.cpp modified: libmscore/timesig.cpp modified: libmscore/tremolo.cpp modified: libmscore/trill.cpp modified: libmscore/volta.cpp modified: mscore/scoreaccessibility.cpp
2014-08-21 18:32:52 +02:00
rez = QString("%1 %2").arg(rez).arg(chord()->accessibleExtraInfo());
Score accessibility system. Provides screen-reader feedback for the selected element.
2014-07-10 14:13:37 +02:00
return rez;
}
fix #25600
2014-06-26 11:41:18 +02:00
//---------------------------------------------------------
// noteVal
//---------------------------------------------------------
NoteVal Note::noteVal() const
{
NoteVal nval;
nval.pitch = pitch();
fix #33366
2014-09-22 14:31:28 +02:00
nval.tpc1 = tpc1();
nval.tpc2 = tpc2();
fix #25600
2014-06-26 11:41:18 +02:00
nval.fret = fret();
nval.string = string();
nval.headGroup = headGroup();
return nval;
}
Fix #27201 - PLUGINS: methods returning pntrs to QObject lead to crash. For details, including an analysis of the problem, see http://musescore.org/en/node/27201 This fix only covers `Q_INVOKABLE` methods in the `Note` class; there are probably more of them on other classes.
2014-07-04 11:38:41 +02:00
//---------------------------------------------------------
expose note dots to plugin, read only
2015-03-19 10:39:18 +01:00
// qmlDotsCount
do no send link of dots to plugins, just number
2014-12-18 18:02:44 +01:00
// returns number of dots for plugins
Fix #27201 - PLUGINS: methods returning pntrs to QObject lead to crash. For details, including an analysis of the problem, see http://musescore.org/en/node/27201 This fix only covers `Q_INVOKABLE` methods in the `Note` class; there are probably more of them on other classes.
2014-07-04 11:38:41 +02:00
//---------------------------------------------------------
more regression fixes & cleaups
2016-02-06 11:41:16 +01:00
expose note dots to plugin, read only
2015-03-19 10:39:18 +01:00
int Note::qmlDotsCount()
Fix #27201 - PLUGINS: methods returning pntrs to QObject lead to crash. For details, including an analysis of the problem, see http://musescore.org/en/node/27201 This fix only covers `Q_INVOKABLE` methods in the `Note` class; there are probably more of them on other classes.
2014-07-04 11:38:41 +02:00
{
more regression fixes & cleaups
2016-02-06 11:41:16 +01:00
return _dots.size();
Fix #27201 - PLUGINS: methods returning pntrs to QObject lead to crash. For details, including an analysis of the problem, see http://musescore.org/en/node/27201 This fix only covers `Q_INVOKABLE` methods in the `Note` class; there are probably more of them on other classes.
2014-07-04 11:38:41 +02:00
}
some layout optimizations/claenups
2015-02-19 10:28:25 +01:00
//---------------------------------------------------------
// subtypeName
//---------------------------------------------------------
Added subtype for note - notehead group
2014-07-17 15:07:12 +02:00
QString Note::subtypeName() const
{
Change storage of notehead type and group in notes
2016-10-18 09:21:54 +02:00
return NoteHead::group2userName(_headGroup);
Added subtype for note - notehead group
2014-07-17 15:07:12 +02:00
}
Added 4 new navigation commands: - next element - previous element - first element - last element
2014-06-20 22:48:34 +02:00
//---------------------------------------------------------
// nextElement
//---------------------------------------------------------
Element* Note::nextElement()
{
if (chord()->isGrace())
return Element::nextElement();
code cleanups & speed optimizations
2016-02-06 22:03:43 +01:00
const std::vector<Note*>& notes = chord()->notes();
if (this == notes.front())
Added 4 new navigation commands: - next element - previous element - first element - last element
2014-06-20 22:48:34 +02:00
return chord()->nextElement();
code cleanups & speed optimizations
2016-02-06 22:03:43 +01:00
auto i = std::find(notes.begin(), notes.end(), this);
return *(i-1);
Added 4 new navigation commands: - next element - previous element - first element - last element
2014-06-20 22:48:34 +02:00
}
fix #26531: Hang on up/down of note tied to itself
2015-01-28 15:20:33 +01:00
//---------------------------------------------------------
// prevElement
//---------------------------------------------------------
Added 4 new navigation commands: - next element - previous element - first element - last element
2014-06-20 22:48:34 +02:00
Element* Note::prevElement()
{
if (chord()->isGrace())
return Element::prevElement();
code cleanups & speed optimizations
2016-02-06 22:03:43 +01:00
const std::vector<Note*>& notes = chord()->notes();
if (this == notes.back())
Added 4 new navigation commands: - next element - previous element - first element - last element
2014-06-20 22:48:34 +02:00
return chord()->prevElement();
code cleanups & speed optimizations
2016-02-06 22:03:43 +01:00
auto i = std::find(notes.begin(), notes.end(), this);
return *++i;
Added 4 new navigation commands: - next element - previous element - first element - last element
2014-06-20 22:48:34 +02:00
}
fix #26531: Hang on up/down of note tied to itself
2015-01-28 15:20:33 +01:00
//---------------------------------------------------------
// lastTiedNote
//---------------------------------------------------------
Note* Note::lastTiedNote() const
{
cross beam fixes
2016-03-19 11:41:38 +01:00
std::vector<Note*> notes;
fix #26531: Hang on up/down of note tied to itself
2015-01-28 15:20:33 +01:00
Note* note = const_cast<Note*>(this);
cross beam fixes
2016-03-19 11:41:38 +01:00
notes.push_back(note);
fix #26531: Hang on up/down of note tied to itself
2015-01-28 15:20:33 +01:00
while (note->tieFor()) {
cross beam fixes
2016-03-19 11:41:38 +01:00
if (std::find(notes.begin(), notes.end(), note->tieFor()->endNote()) != notes.end())
fix #26531: Hang on up/down of note tied to itself
2015-01-28 15:20:33 +01:00
break;
fix #175341: [GP6] Crash on a file involving arpeggios, ties and capo feature
2017-02-20 17:16:24 +01:00
if (!note->tieFor()->endNote())
break;
fix #26531: Hang on up/down of note tied to itself
2015-01-28 15:20:33 +01:00
note = note->tieFor()->endNote();
cross beam fixes
2016-03-19 11:41:38 +01:00
notes.push_back(note);
fix #26531: Hang on up/down of note tied to itself
2015-01-28 15:20:33 +01:00
}
return note;
}
//---------------------------------------------------------
// firstTiedNote
// if note has ties, return last note in chain
// - handle recursion in connected notes
//---------------------------------------------------------
Note* Note::firstTiedNote() const
{
preparations for new compatibility implementation
2016-09-13 09:39:50 +02:00
std::vector<const Note*> notes;
const Note* note = this;
cross beam fixes
2016-03-19 11:41:38 +01:00
notes.push_back(note);
fix #26531: Hang on up/down of note tied to itself
2015-01-28 15:20:33 +01:00
while (note->tieBack()) {
cross beam fixes
2016-03-19 11:41:38 +01:00
if (std::find(notes.begin(), notes.end(), note->tieBack()->startNote()) != notes.end())
fix #26531: Hang on up/down of note tied to itself
2015-01-28 15:20:33 +01:00
break;
note = note->tieBack()->startNote();
cross beam fixes
2016-03-19 11:41:38 +01:00
notes.push_back(note);
fix #26531: Hang on up/down of note tied to itself
2015-01-28 15:20:33 +01:00
}
preparations for new compatibility implementation
2016-09-13 09:39:50 +02:00
return const_cast<Note*>(note);
fix #26531: Hang on up/down of note tied to itself
2015-01-28 15:20:33 +01:00
}
//---------------------------------------------------------
// tiedNotes
//---------------------------------------------------------
cross beam fixes
2016-03-19 11:41:38 +01:00
std::vector<Note*> Note::tiedNotes() const
fix #26531: Hang on up/down of note tied to itself
2015-01-28 15:20:33 +01:00
{
cross beam fixes
2016-03-19 11:41:38 +01:00
std::vector<Note*> notes;
fix #26531: Hang on up/down of note tied to itself
2015-01-28 15:20:33 +01:00
Note* note = firstTiedNote();
cross beam fixes
2016-03-19 11:41:38 +01:00
notes.push_back(note);
fix #26531: Hang on up/down of note tied to itself
2015-01-28 15:20:33 +01:00
while (note->tieFor()) {
cross beam fixes
2016-03-19 11:41:38 +01:00
if (std::find(notes.begin(), notes.end(), note->tieFor()->endNote()) != notes.end())
fix #26531: Hang on up/down of note tied to itself
2015-01-28 15:20:33 +01:00
break;
note = note->tieFor()->endNote();
cross beam fixes
2016-03-19 11:41:38 +01:00
notes.push_back(note);
fix #26531: Hang on up/down of note tied to itself
2015-01-28 15:20:33 +01:00
}
return notes;
}
add tests for scripting interface
2015-04-03 18:23:51 +02:00
//---------------------------------------------------------
// accidentalType
//---------------------------------------------------------
AccidentalType Note::accidentalType() const
{
return _accidental ? _accidental->accidentalType() : AccidentalType::NONE;
}
//---------------------------------------------------------
// setAccidentalType
//---------------------------------------------------------
void Note::setAccidentalType(AccidentalType type)
{
specialize MasterScore() from Score()
2016-03-10 10:41:31 +01:00
if (score())
score()->changeAccidental(this, type);
add tests for scripting interface
2015-04-03 18:23:51 +02:00
}
Layout reorganization
2016-01-04 14:48:58 +01:00
//---------------------------------------------------------
// shape
//---------------------------------------------------------
Shape Note::shape() const
{
Shape shape;
more regression fixes & cleaups
2016-02-06 11:41:16 +01:00
shape.add(symBbox(noteHead()));
Layout reorganization
2016-01-04 14:48:58 +01:00
for (NoteDot* dot : _dots)
more regression fixes & cleaups
2016-02-06 11:41:16 +01:00
shape.add(symBbox(SymId::augmentationDot).translated(dot->pos()));
Layout reorganization
2016-01-04 14:48:58 +01:00
if (_accidental)
more regression fixes & cleaups
2016-02-06 11:41:16 +01:00
shape.add(_accidental->bbox().translated(_accidental->pos()));
return element Shape in element coordinates
2016-12-29 16:42:10 +01:00
return shape;
Layout reorganization
2016-01-04 14:48:58 +01:00
}
add tests for scripting interface
2015-04-03 18:23:51 +02:00
Fix #27201 - PLUGINS: methods returning pntrs to QObject lead to crash. For details, including an analysis of the problem, see http://musescore.org/en/node/27201 This fix only covers `Q_INVOKABLE` methods in the `Note` class; there are probably more of them on other classes.
2014-07-04 11:38:41 +02:00
}
Reference in a new issue Copy permalink