Support number notation jianpu

src/engraving/dom/chord.cpp

@@ -1073,7 +1073,8 @@ bool Chord::shouldHaveStem() const
            && !(durationType().type() == DurationType::V_HALF && staffType && staffType->isTabStaff()
                 && staffType->minimStyle() == TablatureMinimStyle::NONE)
            && !(measure() && measure()->stemless(staffIdx()))
-           && !(staffType && staffType->isTabStaff() && staffType->stemless());
+           && !(staffType && staffType->isTabStaff() && staffType->stemless())
+           && !(staff && staff->isJianpuStaff(tick()));
 }
 
 bool Chord::shouldHaveHook() const

src/engraving/dom/chordrest.cpp

@@ -32,6 +32,7 @@
 #include "breath.h"
 #include "chord.h"
 #include "clef.h"
+#include "durationline.h"
 #include "factory.h"
 #include "figuredbass.h"
 #include "harmony.h"
@@ -134,6 +135,7 @@ ChordRest::~ChordRest()
 {
     muse::DeleteAll(m_lyrics);
     muse::DeleteAll(m_el);
+    muse::DeleteAll(m_durationLines);
     delete m_tabDur;
 
     if (m_beam) {
@@ -876,6 +878,9 @@ void ChordRest::processSiblings(std::function<void(EngravingItem*)> func)
     for (EngravingItem* e : m_el) {
         func(e);
     }
+    for (DurationLine* dl : m_durationLines) {
+        func(dl);
+    }
 }
 
 //---------------------------------------------------------
@@ -1099,6 +1104,9 @@ void ChordRest::scanElements(std::function<void(EngravingItem*)> func)
     if (m_tabDur) {
         func(m_tabDur);
     }
+    for (DurationLine* dl : m_durationLines) {
+        func(dl);
+    }
 }
 
 //---------------------------------------------------------
@@ -1366,4 +1374,19 @@ bool ChordRest::hasPrecedingJumpItem() const
 
     return !precedingRepeatMeasures.empty();
 }
+
+void ChordRest::resizeDurationLinesTo(size_t newSize)
+{
+    while (m_durationLines.size() < newSize) {
+        DurationLine* dl = new DurationLine(this);
+        dl->setOwnershipParent(this);
+        dl->setTrack(track());
+        m_durationLines.push_back(dl);
+    }
+
+    while (m_durationLines.size() > newSize) {
+        delete m_durationLines.back();
+        m_durationLines.pop_back();
+    }
+}
 }

src/engraving/dom/chordrest.h

@@ -40,6 +40,7 @@ enum class CrossMeasure : signed char {
 class Articulation;
 class BeamBase;
 class BeamSegment;
+class DurationLine;
 class Lyrics;
 class Measure;
 class Score;
@@ -121,6 +122,10 @@ class ChordRest : public DurationElement
 
     String durationUserName() const;
 
+    const std::vector<DurationLine*>& durationLines() const { return m_durationLines; }
+    std::vector<DurationLine*>& durationLines() { return m_durationLines; }
+    void resizeDurationLinesTo(size_t newSize);
+
     void setTrack(track_idx_t val) override;
 
     const std::vector<Lyrics*>& lyrics() const { return m_lyrics; }
@@ -228,5 +233,7 @@ class ChordRest : public DurationElement
     TDuration m_durationType;
     int m_staffMove = 0; // -1, 0, +1, used for crossbeaming
     int m_storedStaffMove = 0; // used to remember and re-apply staff move if needed
+
+    std::vector<DurationLine*> m_durationLines;
 };
 }

src/engraving/dom/dom.cmake

@@ -82,6 +82,8 @@ set(DOM_SRC
     ${CMAKE_CURRENT_LIST_DIR}/dummyparent.h
     ${CMAKE_CURRENT_LIST_DIR}/durationelement.cpp
     ${CMAKE_CURRENT_LIST_DIR}/durationelement.h
+    ${CMAKE_CURRENT_LIST_DIR}/durationline.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/durationline.h
     ${CMAKE_CURRENT_LIST_DIR}/durationtype.cpp
     ${CMAKE_CURRENT_LIST_DIR}/durationtype.h
     ${CMAKE_CURRENT_LIST_DIR}/dynamic.cpp
@@ -209,6 +211,8 @@ set(DOM_SRC
     ${CMAKE_CURRENT_LIST_DIR}/noteline.cpp
     ${CMAKE_CURRENT_LIST_DIR}/noteline.h
     ${CMAKE_CURRENT_LIST_DIR}/notifier.h
+    ${CMAKE_CURRENT_LIST_DIR}/octavedot.cpp
+    ${CMAKE_CURRENT_LIST_DIR}/octavedot.h
     ${CMAKE_CURRENT_LIST_DIR}/ornament.cpp
     ${CMAKE_CURRENT_LIST_DIR}/ornament.h
     ${CMAKE_CURRENT_LIST_DIR}/ottava.cpp

src/engraving/dom/durationline.cpp

@@ -0,0 +1,109 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0-only
+ * MuseScore-Studio-CLA-applies
+ *
+ * MuseScore Studio
+ * Music Composition & Notation
+ *
+ * Copyright (C) 2021 MuseScore Limited
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "durationline.h"
+
+#include "chord.h"
+#include "measure.h"
+#include "rest.h"
+#include "staff.h"
+#include "system.h"
+
+#include "log.h"
+
+using namespace mu;
+
+namespace mu::engraving {
+//---------------------------------------------------------
+//   DurationLine
+//---------------------------------------------------------
+
+DurationLine::DurationLine(DummyParentOr<ChordRest> parent)
+    : EngravingItem(ElementType::DURATION_LINE, parent)
+{
+    setSelectable(false);
+}
+
+//---------------------------------------------------------
+//   pagePos
+//---------------------------------------------------------
+
+PointF DurationLine::pagePos() const
+{
+    if (ChordRest* chordRest = this->chordRest()) {
+        if (Measure* measure = chordRest->measure()) {
+            if (System* system = measure->system()) {
+                if (system->staves().size() > staffIdx()) {
+                    if (SysStaff* staff = system->staff(staffIdx())) {
+                        double yp = y() + staff->y() + system->y();
+                        return PointF(pageX(), yp);
+                    }
+                }
+            }
+        }
+    }
+
+    return EngravingItem::pagePos();
+}
+
+//---------------------------------------------------------
+//   spatiumChanged
+//---------------------------------------------------------
+
+void DurationLine::spatiumChanged(double oldValue, double newValue)
+{
+    if (oldValue != 0.0) {
+        m_len = (m_len / oldValue) * newValue;
+    }
+}
+
+//---------------------------------------------------------
+//   mag
+//---------------------------------------------------------
+
+double DurationLine::mag() const
+{
+    auto* parent = ownershipParent();
+    if (parent && parent->isRest()) {
+        return toRest(parent)->mag();
+    }
+    if (parent && parent->isChord()) {
+        return toChord(parent)->mag();
+    }
+    const Staff* st = staff();
+    return st ? st->staffMag(this) : 1.0;
+}
+
+//---------------------------------------------------------
+//   chord
+//---------------------------------------------------------
+
+ChordRest* DurationLine::chordRest() const
+{
+    auto* parent = ownershipParent();
+    if (parent && parent->isChordRest()) {
+        return toChordRest(parent);
+    } else {
+        return nullptr;
+    }
+}
+}

src/engraving/dom/durationline.h

@@ -0,0 +1,69 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0-only
+ * MuseScore-Studio-CLA-applies
+ *
+ * MuseScore Studio
+ * Music Composition & Notation
+ *
+ * Copyright (C) 2021 MuseScore Limited
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef MU_ENGRAVING_DURATIONLINE_H
+#define MU_ENGRAVING_DURATIONLINE_H
+
+#include "engravingitem.h"
+
+namespace mu::engraving {
+//---------------------------------------------------------
+//    @@ DurationLine
+///     Graphic representation of a duration line.
+//!
+//!    parent:     ChordRest
+//!    x-origin:   Chord
+//!    y-origin:   SStaff
+//---------------------------------------------------------
+
+class DurationLine final : public EngravingItem
+{
+    OBJECT_ALLOCATOR(engraving, DurationLine)
+    DECLARE_CLASSOF(ElementType::DURATION_LINE)
+
+public:
+    DurationLine(DummyParentOr<ChordRest>);
+    ~DurationLine() override = default;
+    DurationLine& operator=(const DurationLine&) = delete;
+
+    DurationLine* clone() const override { return new DurationLine(*this); }
+
+    PointF pagePos() const override;        ///< position in page coordinates
+    ChordRest* chordRest() const;
+    double mag() const;
+
+    double len() const { return m_len; }
+    void setLen(double v) { m_len = v; }
+
+    void spatiumChanged(double /*oldValue*/, double /*newValue*/) override;
+
+    struct LayoutData : public EngravingItem::LayoutData {
+        double lineWidth = 0.0;
+    };
+    DECLARE_LAYOUTDATA_METHODS(DurationLine);
+
+private:
+
+    double m_len = 0.0;
+};
+} // namespace mu::engraving
+#endif

src/engraving/dom/durationtype.cpp

@@ -823,4 +823,71 @@ bool TDuration::isValid(Fraction f)
     t.truncateToFraction(f, 4);
     return t.isValid() && (t.fraction() - f).numerator() == 0;
 }
+
+//---------------------------------------------------------
+//   augmentation lines - number of Line to lengthen duration
+//
+//   The undotted duration uses base - 1 lines. Each dot adds half
+//   the line count represented by the preceding duration value.
+//---------------------------------------------------------
+int TDuration::augmentationLines() const
+{
+    auto getLinesByDots = [this](int base){
+        int lines = base - 1;
+        int dots = this->dots();
+        while (dots > 0)
+        {
+            base /= 2;
+            lines += base;
+            dots--;
+        }
+        return lines;
+    };
+
+    switch (m_val) {
+    case DurationType::V_LONG:
+        return getLinesByDots(16);
+    case DurationType::V_BREVE:
+        return getLinesByDots(8);
+    case DurationType::V_WHOLE:
+        return getLinesByDots(4);
+    case DurationType::V_HALF:
+        return getLinesByDots(2);
+    default:
+        return 0;
+    }
+}
+
+//---------------------------------------------------------
+//   diminution lines - number of Line to halve duration
+//---------------------------------------------------------
+int TDuration::diminutionLines() const
+{
+    switch (m_val) {
+    case DurationType::V_LONG:
+    case DurationType::V_BREVE:
+    case DurationType::V_WHOLE:
+    case DurationType::V_HALF:
+    case DurationType::V_QUARTER:
+        return 0;
+    case DurationType::V_EIGHTH:
+        return 1;
+    case DurationType::V_16TH:
+        return 2;
+    case DurationType::V_32ND:
+        return 3;
+    case DurationType::V_64TH:
+        return 4;
+    case DurationType::V_128TH:
+        return 5;
+    case DurationType::V_256TH:
+        return 6;
+    case DurationType::V_512TH:
+        return 7;
+    case DurationType::V_1024TH:
+        return 8;
+    default:
+        return 0;
+    }
+}
 }

src/engraving/dom/durationtype.h

@@ -83,6 +83,9 @@ class TDuration
     Fraction fraction() const;
     static bool isValid(Fraction f);
 
+    int augmentationLines() const;
+    int diminutionLines() const;
+
 private:
     void shiftType(int nSteps, bool stepDotted = false);
     void truncateToFraction(const Fraction& l, int maxDots);

src/engraving/dom/engravingitem.cpp

@@ -469,6 +469,12 @@ bool EngravingItem::onTabStaff() const
     return stt ? stt->isTabStaff() : false;
 }
 
+bool EngravingItem::isJianpuStaff() const
+{
+    const Staff* st = staff();
+    return st ? st->isJianpuStaff(tick()) : false;
+}
+
 bool EngravingItem::hasGrips() const
 {
     return gripsCount() > 0;

src/engraving/dom/engravingitem.h

@@ -340,6 +340,7 @@ class EngravingItem : public EngravingObject
     bool hasStaff() const;
     const StaffType* staffType() const;
     bool onTabStaff() const;
+    bool isJianpuStaff() const;
     Part* part() const;
     Part* originPart() const; // Delegates to an origin part for items in shared parts