LoweBowe/MuseScore
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

clearing enum type Align

Browse source
This commit is contained in:
Igor Korsukov 2021-11-19 18:01:53 +02:00
parent d4d6ab5b4a
commit 2d3c33cf6b
11 changed files with 146 additions and 76 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/engraving/infrastructure/draw/geometry.h
View file

@ -138,7 +138,7 @@ inline QPointF operator+(const QPointF& p1, const PointF& p2) { return QPointF(p
// ====================================
// PairF
// ====================================
class PairF : public std::pair<qreal, qreal> // P_TYPE::PAIR_REAL
class PairF : public std::pair<qreal, qreal>
{
public:
PairF() = default;

1
src/engraving/libmscore/textlinebase.h
View file

@ -29,7 +29,6 @@
#include "property.h"
namespace Ms {
enum class Align : char;
class TextLineBase;
class EngravingItem;
class Text;

44
src/engraving/libmscore/types.h
View file

@ -570,47 +570,6 @@ enum class Tid {
///.\}
};
//---------------------------------------------------------
/// Align
/// Because the Align enum has Top = 0 and Left = 0,
/// align() & Align::Top will always return false.
/// @warning Do not use if (align() & Align::Top) { doSomething(); }
/// because doSomething() will never be executed!
/// use this instead:
/// `if ((static_cast<char>(align()) & static_cast<char>(Align::VMASK)) == Align::Top) { doSomething(); }`
/// Same applies to Align::Left.
//---------------------------------------------------------
enum class Align : char {
///.\{
LEFT = 0,
RIGHT = 1,
HCENTER = 2,
TOP = 0,
BOTTOM = 4,
VCENTER = 8,
BASELINE = 16,
CENTER = Align::HCENTER | Align::VCENTER,
HMASK = Align::LEFT | Align::RIGHT | Align::HCENTER,
VMASK = Align::TOP | Align::BOTTOM | Align::VCENTER | Align::BASELINE
///.\}
};
constexpr Align operator|(Align a1, Align a2)
{
return static_cast<Align>(static_cast<char>(a1) | static_cast<char>(a2));
}
constexpr bool operator&(Align a1, Align a2)
{
return static_cast<char>(a1) & static_cast<char>(a2);
}
constexpr Align operator~(Align a)
{
return static_cast<Align>(~static_cast<char>(a));
}
//---------------------------------------------------------
// FontStyle
//---------------------------------------------------------
@ -722,7 +681,6 @@ Q_ENUM_NS(Placement);
Q_ENUM_NS(HPlacement);
Q_ENUM_NS(SegmentType);
Q_ENUM_NS(Tid);
Q_ENUM_NS(Align);
Q_ENUM_NS(NoteType);
Q_ENUM_NS(PlayEventType);
Q_ENUM_NS(AccidentalType);
@ -742,8 +700,6 @@ extern const char* toString(Direction);
extern QString toUserString(Direction);
} // namespace Ms
Q_DECLARE_METATYPE(Ms::Align);
Q_DECLARE_METATYPE(Ms::Direction);
Q_DECLARE_METATYPE(Ms::NoteType);

19
src/engraving/property/propertyvalue.cpp
View file

@ -83,7 +83,7 @@ PropertyValue::PropertyValue(const draw::Color& v)
{
}
PropertyValue::PropertyValue(Ms::Align v)
PropertyValue::PropertyValue(Align v)
: m_type(P_TYPE::ALIGN), m_val(v)
{
}
@ -221,8 +221,8 @@ QVariant PropertyValue::toQVariant() const
case P_TYPE::PAIR_REAL: return QVariant::fromValue(value<PairF>().toQPairF());
// draw
case P_TYPE::COLOR: return value<draw::Color>().toQColor();
case P_TYPE::ALIGN: return QVariant::fromValue(value<Ms::Align>());
case P_TYPE::COLOR: return value<draw::Color>().toQColor();
case P_TYPE::ALIGN: return QVariant::fromValue(int(value<Align>()));
case P_TYPE::PLACEMENT: return static_cast<int>(value<Ms::Placement>());
case P_TYPE::HPLACEMENT: return static_cast<int>(value<Ms::HPlacement>());
case P_TYPE::DIRECTION: return QVariant::fromValue(value<Ms::Direction>());
@ -252,13 +252,13 @@ PropertyValue PropertyValue::fromQVariant(const QVariant& v, P_TYPE type)
case P_TYPE::UNDEFINED: // try by QVariant type
break;
// base
// Base
case P_TYPE::BOOL: return PropertyValue(v.toBool());
case P_TYPE::INT: return PropertyValue(v.toInt());
case P_TYPE::REAL: return PropertyValue(v.toReal());
case P_TYPE::STRING: return PropertyValue(v.toString());
// geometry
// Geometry
case P_TYPE::POINT: return PropertyValue(PointF::fromQPointF(v.value<QPointF>()));
case P_TYPE::SIZE: return PropertyValue(SizeF::fromQSizeF(v.value<QSizeF>()));
case P_TYPE::PATH: {
@ -270,9 +270,11 @@ PropertyValue PropertyValue::fromQVariant(const QVariant& v, P_TYPE type)
case P_TYPE::MILIMETRE: return PropertyValue(Milimetre(v.toReal()));
case P_TYPE::PAIR_REAL: return PropertyValue(PairF::fromQPairF(v.value<QPair<qreal, qreal> >()));
// draw
// Draw
case P_TYPE::COLOR: return PropertyValue(Color::fromQColor(v.value<QColor>()));
case P_TYPE::ALIGN: return PropertyValue(Ms::Align(v.toInt()));
// Layout
case P_TYPE::ALIGN: return PropertyValue(Align(v.toInt()));
case P_TYPE::PLACEMENT: return PropertyValue(Ms::Placement(v.toInt()));
case P_TYPE::HPLACEMENT: return PropertyValue(Ms::HPlacement(v.toInt()));
case P_TYPE::DIRECTION: return PropertyValue(Ms::Direction(v.toInt()));
@ -317,9 +319,6 @@ PropertyValue PropertyValue::fromQVariant(const QVariant& v, P_TYPE type)
if (strcmp(type, "Ms::Direction") == 0) {
return PropertyValue(v.value<Ms::Direction>());
}
if (strcmp(type, "Ms::Align") == 0) {
return PropertyValue(v.value<Ms::Align>());
}
if (strcmp(type, "mu::draw::Color") == 0) {
return PropertyValue(v.value<draw::Color>());
}

36
src/engraving/property/propertyvalue.h
View file

@ -49,13 +49,13 @@ class TDuration;
namespace mu::engraving {
enum class P_TYPE {
UNDEFINED = 0,
// base
// Base
BOOL, // bool
INT, // int
REAL, // qreal
STRING, // QString
// geometry
// Geometry
POINT, // point units, value saved as mm or spatium depending on EngravingItem->sizeIsSpatiumDependent()
SIZE,
PATH, // mu::PainterPath
@ -64,8 +64,10 @@ enum class P_TYPE {
MILIMETRE,
PAIR_REAL,
// draw
COLOR, // Color
// Draw
COLOR, // Color
// Layout
ALIGN,
PLACEMENT, // ABOVE or BELOW
HPLACEMENT, // LEFT, CENTER or RIGHT
@ -113,14 +115,14 @@ class PropertyValue
public:
PropertyValue();
// base
// Base
PropertyValue(bool v);
PropertyValue(int v);
PropertyValue(qreal v);
PropertyValue(const char* v);
PropertyValue(const QString& v);
// geometry
// Geometry
PropertyValue(const PointF& v);
PropertyValue(const SizeF& v);
PropertyValue(const PainterPath& v);
@ -130,9 +132,11 @@ public:
PropertyValue(const PairF& v)
: m_type(P_TYPE::PAIR_REAL), m_val(v) {}
// draw
// Draw
PropertyValue(const draw::Color& v);
PropertyValue(Ms::Align v);
// Layout
PropertyValue(Align v);
PropertyValue(Ms::HPlacement v);
PropertyValue(Ms::Placement v)
: m_type(P_TYPE::PLACEMENT), m_val(v) {}
@ -182,7 +186,7 @@ public:
//! HACK Temporary hack for enum to int
if constexpr (std::is_same<T, int>::value) {
switch (m_type) {
case P_TYPE::ALIGN: return static_cast<int>(value<Ms::Align>());
case P_TYPE::ALIGN: return static_cast<int>(value<Align>());
case P_TYPE::HPLACEMENT: return static_cast<int>(value<Ms::HPlacement>());
case P_TYPE::PLACEMENT: return static_cast<int>(value<Ms::Placement>());
case P_TYPE::DIRECTION: return static_cast<int>(value<Ms::Direction>());
@ -266,7 +270,6 @@ public:
qreal toReal() const { return value<qreal>(); }
double toDouble() const { return value<qreal>(); }
QString toString() const { return value<QString>(); }
Ms::Align toAlign() const { return value<Ms::Align>(); }
Ms::Direction toDirection() const { return value<Ms::Direction>(); }
const Ms::Groups& toGroups() const;
@ -285,12 +288,17 @@ public:
private:
P_TYPE m_type = P_TYPE::UNDEFINED;
std::variant<
//base
// Base
bool, int, qreal, QString,
// geometry
// Geometry
PointF, SizeF, PainterPath, Spatium, Milimetre, PairF,
// draw
draw::Color, Ms::Align, Ms::HPlacement, Ms::Placement, Ms::Direction,
// Draw
Color,
// Layout
Align, Ms::HPlacement, Ms::Placement, Ms::Direction,
// time
Ms::Fraction,

4
src/engraving/style/style.cpp
View file

@ -350,9 +350,9 @@ void MStyle::save(XmlWriter& xml, bool optimize)
} else if (P_TYPE::DIRECTION == type) {
xml.tag(st.name(), int(value(idx).toDirection()));
} else if (P_TYPE::ALIGN == type) {
Align a = value(idx).toAlign();
Align a = value(idx).value<Align>();
// Don't write if it's the default value
if (optimize && a == Align(st.defaultValue().toInt())) {
if (optimize && a == st.defaultValue().value<Align>()) {
continue;
}
QString horizontal = "left";

51
src/engraving/types/types.h
View file

@ -51,7 +51,56 @@ using ScaleF = mu::ScaleF; // P_TYPE::SCALE
// Milimetre (dimension.h) // P_TYPE::MILIMETRE
using PairF = mu::PairF; // P_TYPE::PAIR_REAL
using Color = draw::Color;
// --- Draw ---
using Color = draw::Color; // P_TYPE::COLOR
// --- Layout ---
//---------------------------------------------------------
/// Align
/// Because the Align enum has Top = 0 and Left = 0,
/// align() & Align::Top will always return false.
/// @warning Do not use if (align() & Align::Top) { doSomething(); }
/// because doSomething() will never be executed!
/// use this instead:
/// `if ((static_cast<char>(align()) & static_cast<char>(Align::VMASK)) == Align::Top) { doSomething(); }`
/// Same applies to Align::Left.
//---------------------------------------------------------
enum class Align : char { // P_TYPE::ALIGN
///.\{
LEFT = 0,
RIGHT = 1,
HCENTER = 2,
TOP = 0,
BOTTOM = 4,
VCENTER = 8,
BASELINE = 16,
CENTER = Align::HCENTER | Align::VCENTER,
HMASK = Align::LEFT | Align::RIGHT | Align::HCENTER,
VMASK = Align::TOP | Align::BOTTOM | Align::VCENTER | Align::BASELINE
///.\}
};
constexpr Align operator|(Align a1, Align a2)
{
return static_cast<Align>(static_cast<char>(a1) | static_cast<char>(a2));
}
constexpr bool operator&(Align a1, Align a2)
{
return static_cast<char>(a1) & static_cast<char>(a2);
}
constexpr Align operator~(Align a)
{
return static_cast<Align>(~static_cast<char>(a));
}
}
//! NOTE compat
namespace Ms {
using Align = mu::engraving::Align;
}
#endif // MU_ENGRAVING_TYPES_H

2
src/notation/view/widgets/editstyle.cpp
View file

@ -736,7 +736,7 @@ EditStyle::EditStyle(QWidget* parent)
resetTextStyle(Ms::Pid::ALIGN);
});
connect(textStyleAlign, &AlignSelect::alignChanged, [=]() {
textStyleValueChanged(Ms::Pid::ALIGN, QVariant::fromValue(textStyleAlign->align()));
textStyleValueChanged(Ms::Pid::ALIGN, QVariant::fromValue(int(textStyleAlign->align())));
});
// offset

1
src/plugins/CMakeLists.txt
View file

@ -41,6 +41,7 @@ set(MODULE_SRC
${CMAKE_CURRENT_LIST_DIR}/internal/pluginsconfiguration.h
${CMAKE_CURRENT_LIST_DIR}/internal/pluginsservice.cpp
${CMAKE_CURRENT_LIST_DIR}/internal/pluginsservice.h
${CMAKE_CURRENT_LIST_DIR}/api/apitypes.h
${CMAKE_CURRENT_LIST_DIR}/api/cursor.cpp
${CMAKE_CURRENT_LIST_DIR}/api/cursor.h
${CMAKE_CURRENT_LIST_DIR}/api/elements.cpp

56
src/plugins/api/apitypes.h Normal file
View file

@ -0,0 +1,56 @@
/*
* SPDX-License-Identifier: GPL-3.0-only
* MuseScore-CLA-applies
*
* MuseScore
* Music Composition & Notation
*
* Copyright (C) 2021 MuseScore BVBA and others
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 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_PLUGINS_APITYPES_H
#define MU_PLUGINS_APITYPES_H
#include <QObject>
#include "engraving/types/types.h"
namespace Ms::PluginAPI {
Q_NAMESPACE
enum class Align : char {
LEFT = char(mu::engraving::Align::LEFT),
RIGHT = char(mu::engraving::Align::RIGHT),
HCENTER = char(mu::engraving::Align::HCENTER),
TOP = char(mu::engraving::Align::TOP),
BOTTOM = char(mu::engraving::Align::BOTTOM),
VCENTER = char(mu::engraving::Align::VCENTER),
BASELINE = char(mu::engraving::Align::BASELINE),
CENTER = Align::HCENTER | Align::VCENTER,
HMASK = Align::LEFT | Align::RIGHT | Align::HCENTER,
VMASK = Align::TOP | Align::BOTTOM | Align::VCENTER | Align::BASELINE
};
Q_ENUM_NS(Align);
//! HACK to force the build system to run moc on this file
class Mops : public QObject
{
Q_GADGET
};
}
Q_DECLARE_METATYPE(Ms::PluginAPI::Align);
#endif // MU_PLUGINS_APITYPES_H

6
src/plugins/api/qmlpluginapi.h
View file

@ -36,6 +36,8 @@
#include "context/iglobalcontext.h"
#include "modularity/ioc.h"
#include "apitypes.h"
namespace Ms {
class EngravingItem;
class MScore;
@ -114,7 +116,7 @@ class PluginAPI : public Ms::QmlPlugin
// Should be initialized in qmlpluginapi.cpp
/// Contains Ms::ElementType enumeration values
DECLARE_API_ENUM(EngravingItem, elementTypeEnum, Ms::ElementType)
DECLARE_API_ENUM(EngravingItem, elementTypeEnum, Ms::ElementType)
/// Contains Ms::AccidentalType enumeration values
DECLARE_API_ENUM(Accidental, accidentalTypeEnum, Ms::AccidentalType)
/// Contains Ms::Beam::Mode enumeration values
@ -152,7 +154,7 @@ class PluginAPI : public Ms::QmlPlugin
DECLARE_API_ENUM(Tid, tidEnum, Ms::Tid)
/// Contains Ms::Align enumeration values
/// \since MuseScore 3.3
DECLARE_API_ENUM(Align, alignEnum, Ms::Align)
DECLARE_API_ENUM(Align, alignEnum, Ms::PluginAPI::Align)
/// Contains Ms::NoteType enumeration values
/// \since MuseScore 3.2.1
DECLARE_API_ENUM(NoteType, noteTypeEnum, Ms::NoteType)