Line data    Source code

       1              : /*
       2              :  * SPDX-License-Identifier: GPL-3.0-only
       3              :  * MuseScore-Studio-CLA-applies
       4              :  *
       5              :  * MuseScore Studio
       6              :  * Music Composition & Notation
       7              :  *
       8              :  * Copyright (C) 2021 MuseScore Limited and others
       9              :  *
      10              :  * This program is free software: you can redistribute it and/or modify
      11              :  * it under the terms of the GNU General Public License version 3 as
      12              :  * published by the Free Software Foundation.
      13              :  *
      14              :  * This program is distributed in the hope that it will be useful,
      15              :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      16              :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      17              :  * GNU General Public License for more details.
      18              :  *
      19              :  * You should have received a copy of the GNU General Public License
      20              :  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
      21              :  */
      22              : #pragma once
      23              : 
      24              : #include "slur.h"
      25              : #include "textbase.h"
      26              : 
      27              : namespace mu::engraving {
      28              : class HammerOnPullOffText final : public TextBase
      29              : {
      30           69 :     OBJECT_ALLOCATOR(engraving, HammerOnPullOffText)
      31              :     DECLARE_CLASSOF(ElementType::HAMMER_ON_PULL_OFF_TEXT)
      32              : 
      33              : public:
      34              :     HammerOnPullOffText(HammerOnPullOffSegment* parent = nullptr);
      35              :     HammerOnPullOffText(const HammerOnPullOffText& h);
      36            0 :     HammerOnPullOffText* clone() const override { return new HammerOnPullOffText(*this); }
      37              : 
      38            0 :     bool isEditAllowed(EditData&) const override { return false; }
      39              : 
      40            0 :     HammerOnPullOffSegment* hopoSegment() const { return toHammerOnPullOffSegment(ownershipParent()); }
      41              : 
      42           75 :     Chord* startChord() const { return m_startChord; }
      43           75 :     Chord* endChord() const { return m_endChord; }
      44           75 :     void setStartChord(Chord* c) { m_startChord = c; }
      45           75 :     void setEndChord(Chord* c) { m_endChord = c; }
      46              : 
      47              :     std::vector<LineF> dragAnchorLines() const override;
      48              : 
      49              :     bool isUserModified() const override;
      50            0 :     bool isValid() const { return m_isValid; }
      51           75 :     void setIsValid(bool v) { m_isValid = v; }
      52          128 :     bool isHammerOn() const { return m_isHammerOn; }
      53           75 :     void setIsHammerOn(bool v) { m_isHammerOn = v; }
      54              : 
      55              :     Color curColor(const rendering::PaintOptions& opt) const override;
      56              : 
      57              :     PropertyValue propertyDefault(Pid id) const override;
      58              : 
      59           75 :     bool positionRelativeToNoteheadRest() const override { return false; }
      60              : 
      61              : private:
      62              :     Chord* m_startChord = nullptr;
      63              :     Chord* m_endChord = nullptr;
      64              :     bool m_isValid = true;
      65              :     bool m_isHammerOn = true;
      66              : };
      67              : 
      68              : class HammerOnPullOffSegment final : public SlurSegment
      69              : {
      70          109 :     OBJECT_ALLOCATOR(engraving, HammerOnPullOffSegment)
      71              :     DECLARE_CLASSOF(ElementType::HAMMER_ON_PULL_OFF_SEGMENT)
      72              : 
      73              : public:
      74              :     HammerOnPullOffSegment(HammerOnPullOff* sp);
      75              :     HammerOnPullOffSegment(const HammerOnPullOffSegment& other);
      76              : 
      77            0 :     HammerOnPullOffSegment* clone() const override { return new HammerOnPullOffSegment(*this); }
      78              : 
      79          122 :     HammerOnPullOff* hammerOnPullOff() const { return toHammerOnPullOff(spanner()); }
      80              : 
      81              :     Color curColor(const rendering::PaintOptions& opt) const override;
      82              : 
      83              :     void scanElements(std::function<void(EngravingItem*)> func) override;
      84              : 
      85              :     void setTrack(track_idx_t idx) override;
      86              :     void setSelected(bool f) override;
      87              : 
      88              :     void updateHopoText();
      89            4 :     void addHopoText(HammerOnPullOffText* t) { m_hopoText.push_back(t); }
      90          601 :     const std::vector<HammerOnPullOffText*>& hopoText() const { return m_hopoText; }
      91              : 
      92              :     bool isUserModified() const override;
      93              :     bool isValid() const;
      94              : 
      95              :     void reset() override;
      96              : 
      97              : private:
      98              :     struct HopoTextRegion {
      99              :         Chord* startChord = nullptr;
     100              :         Chord* endChord = nullptr;
     101              :         bool isHammerOn = true;
     102              :         bool isValid = true;
     103              :     };
     104              : 
     105              :     std::vector<HopoTextRegion> computeHopoTextRegions(Chord* startChord, Chord* endChord);
     106              :     void resolveStartEndNotes(Note** startNote, Note** endNote, Chord* startChord, Chord* endChord, bool isTabStaff);
     107              : 
     108              :     std::vector<HammerOnPullOffText*> m_hopoText;
     109              : };
     110              : 
     111              : class HammerOnPullOff final : public Slur
     112              : {
     113          109 :     OBJECT_ALLOCATOR(engraving, HammerOnPullOff)
     114         1399 :     DECLARE_CLASSOF(ElementType::HAMMER_ON_PULL_OFF)
     115              : 
     116              : public:
     117            5 :     HammerOnPullOff* clone() const override { return new HammerOnPullOff(*this); }
     118           57 :     SlurTieSegment* newSlurTieSegment() override { return new HammerOnPullOffSegment(this); }
     119              : 
     120              :     friend class Factory;
     121              : 
     122              :     HammerOnPullOff(DummyParentOr<EngravingItem> parent);
     123              :     HammerOnPullOff(const HammerOnPullOff&);
     124              : };
     125              : } // namespace mu::engraving