MuseScore/mscore/capella.h
2016-09-16 12:07:58 +02:00

736 lines
20 KiB
C++

//=============================================================================
// MuseScore
// Linux Music Score Editor
// $Id: capella.h 3833 2011-01-04 13:55:40Z wschweer $
//
// Copyright (C) 2009-2013 Werner Schweer 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 2.
//
// 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, write to the Free Software
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
//=============================================================================
#ifndef __CAPELLA_H__
#define __CAPELLA_H__
#include "globals.h"
#include "libmscore/xml.h"
namespace Ms {
enum class TIMESTEP : char { D1, D2, D4, D8, D16, D32, D64, D128, D256, D_BREVE };
#if 0
static const char* timeNames[] = { "1/1", "1/2", "1/4", "1/8", "1/16", "1/32", "1/64",
"1/128", "1/256", "breve" };
#endif
class Capella;
enum class ClefType : signed char;
enum class CapellaNoteObjectType : char {
REST, CHORD, CLEF, KEY, METER, EXPL_BARLINE, IMPL_BARLINE,
PAGE_BKGR
};
enum class BeamMode : unsigned char { AUTO, FORCE, SPLIT };
//---------------------------------------------------------
// CapellaObj
//---------------------------------------------------------
class CapellaObj {
protected:
Capella* cap;
public:
CapellaObj(Capella* c) { cap = c; }
};
//---------------------------------------------------------
// NoteObj
//---------------------------------------------------------
class NoteObj {
CapellaNoteObjectType _type;
public:
NoteObj(CapellaNoteObjectType t) { _type = t; }
CapellaNoteObjectType type() const { return _type; }
};
enum class Form : char {
G, C, F, PERCUSSION,
FORM_NULL, CLEF_UNCHANGED
};
enum class ClefLine : char {
L5, L4, L3, L2, L1
};
enum class Oct : char {
OCT_ALTA, OCT_NULL, OCT_BASSA
};
//---------------------------------------------------------
// CapClef
//---------------------------------------------------------
class CapClef : public NoteObj, public CapellaObj {
Form form;
public:
CapClef(Capella* c) : NoteObj(CapellaNoteObjectType::CLEF), CapellaObj(c) {}
void read();
void readCapx(XmlReader& e);
const char* name() {
static const char* formName[] = { "G", "C", "F", "=", " ", "*" };
return formName[int(form)];
}
ClefType clef() const;
ClefLine line;
Oct oct;
static ClefType clefType(Form, ClefLine, Oct);
};
//---------------------------------------------------------
// CapKey
//---------------------------------------------------------
class CapKey : public NoteObj, public CapellaObj {
public:
CapKey(Capella* c) : NoteObj(CapellaNoteObjectType::KEY), CapellaObj(c) {}
void read();
void readCapx(XmlReader& e);
int signature; // -7 - +7
};
//---------------------------------------------------------
// CapMeter
//---------------------------------------------------------
class CapMeter : public NoteObj, public CapellaObj {
public:
unsigned char numerator;
int log2Denom;
bool allaBreve;
CapMeter(Capella* c) : NoteObj(CapellaNoteObjectType::METER), CapellaObj(c) {}
void read();
void readCapx(XmlReader& e);
};
//---------------------------------------------------------
// CapExplicitBarline
//---------------------------------------------------------
class CapExplicitBarline : public NoteObj, public CapellaObj {
BarLineType _type;
int _barMode; // 0 = auto, 1 = nur Zeilen, 2 = durchgezogen
public:
CapExplicitBarline(Capella* c) : NoteObj(CapellaNoteObjectType::EXPL_BARLINE), CapellaObj(c) {}
void read();
void readCapx(XmlReader& e);
BarLineType type() const { return _type; }
int barMode() const { return _barMode; }
};
//---------------------------------------------------------
// CapVoice
//---------------------------------------------------------
struct CapVoice {
uchar y0Lyrics;
uchar dyLyrics;
QFont lyricsFont;
unsigned char stemDir;
QList<NoteObj*> objects;
int voiceNo;
};
//---------------------------------------------------------
// CapStaff
//---------------------------------------------------------
struct CapStaff {
uchar numerator; // default time signature
int log2Denom;
bool allaBreve;
uchar iLayout;
int topDistX;
int btmDistX;
QColor color;
QList<CapVoice*> voices;
};
//---------------------------------------------------------
// struct CapStaffLayout
//---------------------------------------------------------
struct CapStaffLayout {
uchar barlineMode;
uchar noteLines;
bool bSmall;
int topDist;
int btmDist;
int groupDist;
uchar barlineFrom;
uchar barlineTo;
Form form;
ClefLine line;
Oct oct; // clef
// Schlagzeuginformation
bool bPercussion; // use drum channel
bool bSoundMapIn;
bool bSoundMapOut;
char soundMapIn[128]; // Tabelle für MIDI-Töne iMin...iMin+n-1
char soundMapOut[128]; // Tabelle für MIDI-Töne iMin...iMin+n-1
int sound, volume, transp;
QString descr;
QString name;
QString abbrev;
QString intermediateName;
QString intermediateAbbrev;
};
//---------------------------------------------------------
// CapSystem
//---------------------------------------------------------
struct CapSystem {
int nAddBarCount;
bool bBarCountReset;
unsigned char explLeftIndent; // < 0 --> Einrückung gemäß Stimmenbezeichnungen
// >= --> explizite Einrückung
BeamMode beamMode;
unsigned tempo;
QColor color; // fuer Systemklammern
bool bJustified; // Randausgleich (Blocksatz)
bool bPageBreak; // nach dem System neue Seite anfangen
int instrNotation; // 0 = keine Instrumentenbezeichnung
// 1 = abgekürzt, 2 = vollständig
QList<CapStaff*> staves;
};
//---------------------------------------------------------
// BasicDrawObj
//---------------------------------------------------------
enum class CapellaType : unsigned char { GROUP, TRANSPOSABLE, METAFILE, SIMPLE_TEXT, TEXT, RECT_ELLIPSE,
LINE, POLYGON, WAVY_LINE, SLUR, NOTE_LINES, WEDGE, VOLTA,
BRACKET, GUITAR, TRILL
};
class BasicDrawObj : public CapellaObj {
public:
unsigned char modeX, modeY, distY, flags;
int nRefNote;
int nNotes;
bool background;
int pageRange;
CapellaType type;
BasicDrawObj(CapellaType t, Capella* c)
: CapellaObj(c), modeX(0), modeY(0), distY(0), flags(0),
nRefNote(0), nNotes(0), background(0), pageRange(0), type(t) {}
void read();
void readCapx(XmlReader& e);
};
//---------------------------------------------------------
// BasicRectObj
//---------------------------------------------------------
class BasicRectObj : public BasicDrawObj {
public:
BasicRectObj(CapellaType t, Capella* c) : BasicDrawObj(t, c) {}
void read();
QPointF relPos;
int width;
int yxRatio;
int height;
};
//---------------------------------------------------------
// GroupObj
//---------------------------------------------------------
class GroupObj : public BasicDrawObj {
public:
GroupObj(Capella* c) : BasicDrawObj(CapellaType::GROUP, c) {}
void read();
QPointF relPos;
QList<BasicDrawObj*> objects;
};
//---------------------------------------------------------
// TransposableObj
//---------------------------------------------------------
class TransposableObj : public BasicDrawObj {
public:
TransposableObj(Capella* c) : BasicDrawObj(CapellaType::TRANSPOSABLE, c) {}
void read();
QPointF relPos;
char b;
QList<BasicDrawObj*> variants;
};
//---------------------------------------------------------
// MetafileObj
//---------------------------------------------------------
class MetafileObj : public BasicRectObj {
public:
MetafileObj(Capella* c) : BasicRectObj(CapellaType::METAFILE, c) {}
void read();
};
//---------------------------------------------------------
// LineObj
//---------------------------------------------------------
class LineObj : public BasicDrawObj {
public:
LineObj(Capella* c) : BasicDrawObj(CapellaType::LINE, c) {}
LineObj(CapellaType t, Capella* c) : BasicDrawObj(t, c) {}
void read();
QPointF pt1, pt2;
QColor color;
char lineWidth;
};
//---------------------------------------------------------
// RectEllipseObj
//---------------------------------------------------------
class RectEllipseObj : public LineObj { // special
public:
RectEllipseObj(Capella* c) : LineObj(CapellaType::RECT_ELLIPSE, c) {}
void read();
int radius;
bool bFilled;
QColor clrFill;
};
//---------------------------------------------------------
// PolygonObj
//---------------------------------------------------------
class PolygonObj : public BasicDrawObj {
public:
PolygonObj(Capella* c) : BasicDrawObj(CapellaType::POLYGON, c) {}
void read();
bool bFilled;
unsigned lineWidth;
QColor clrFill;
QColor clrLine;
};
//---------------------------------------------------------
// WavyLineObj
//---------------------------------------------------------
class WavyLineObj : public LineObj {
public:
WavyLineObj(Capella* c) : LineObj(CapellaType::WAVY_LINE, c) {}
void read();
unsigned waveLen;
bool adapt;
};
//---------------------------------------------------------
// NotelinesObj
//---------------------------------------------------------
class NotelinesObj : public BasicDrawObj {
public:
NotelinesObj(Capella* c) : BasicDrawObj(CapellaType::NOTE_LINES, c) {}
void read();
int x0, x1, y;
QColor color;
};
//---------------------------------------------------------
// VoltaObj
//---------------------------------------------------------
class VoltaObj : public BasicDrawObj {
public:
VoltaObj(Capella* c)
: BasicDrawObj(CapellaType::VOLTA, c), x0(0), x1(0), y(0),
bLeft(false), bRight(false), bDotted(false),
allNumbers(false), from(0), to(0) {}
void read();
void readCapx(XmlReader& e);
int x0, x1, y;
QColor color;
bool bLeft;
bool bRight;
bool bDotted;
bool allNumbers;
int from, to;
};
//---------------------------------------------------------
// GuitarObj
//---------------------------------------------------------
class GuitarObj : public BasicDrawObj {
public:
GuitarObj(Capella* c) : BasicDrawObj(CapellaType::GUITAR, c) {}
void read();
QPointF relPos;
QColor color;
short flags;
int strings; // 8 Saiten in 8 Halbbytes
};
//---------------------------------------------------------
// TrillObj
//---------------------------------------------------------
class TrillObj : public BasicDrawObj {
public:
TrillObj(Capella* c) : BasicDrawObj(CapellaType::TRILL, c), x0(0),
x1(0), y(0), trillSign(true) {}
void read();
void readCapx(XmlReader& e);
int x0, x1, y;
QColor color;
bool trillSign;
};
//---------------------------------------------------------
// SlurObj
//---------------------------------------------------------
class SlurObj : public BasicDrawObj {
QPointF bezierPoint[4]; // note default constructor inits to (0, 0)
QColor color; // note default constructor inits to invalid
public:
SlurObj(Capella* c)
: BasicDrawObj(CapellaType::SLUR, c), color(Qt::black), nEnd(0), nMid(0), nDotDist(0), nDotWidth(0) {}
void read();
void readCapx(XmlReader& e);
unsigned char nEnd, nMid, nDotDist, nDotWidth;
};
//---------------------------------------------------------
// TextObj
//---------------------------------------------------------
class TextObj : public BasicRectObj {
public:
TextObj(Capella* c) : BasicRectObj(CapellaType::TEXT, c) {}
~TextObj() {}
void read();
QString text;
};
//---------------------------------------------------------
// SimpleTextObj
//---------------------------------------------------------
class SimpleTextObj : public BasicDrawObj {
QString _text;
QPointF relPos;
unsigned char align;
QFont _font;
public:
SimpleTextObj(Capella* c)
: BasicDrawObj(CapellaType::SIMPLE_TEXT, c), relPos(0, 0), align(0) {}
void read();
void readCapx(XmlReader& e);
QString text() const { return _text; }
QFont font() const { return _font; }
QPointF pos() const { return relPos; }
unsigned char textalign() const { return align; }
};
//---------------------------------------------------------
// BracketObj
//---------------------------------------------------------
class BracketObj : public LineObj {
public:
BracketObj(Capella* c) : LineObj(CapellaType::BRACKET, c) {}
void read();
char orientation, number;
};
//---------------------------------------------------------
// WedgeObj
//---------------------------------------------------------
class WedgeObj : public LineObj {
public:
WedgeObj(Capella* c) : LineObj(CapellaType::WEDGE, c), height(32),
decresc(false) {}
void read();
void readCapx(XmlReader& e);
int height;
bool decresc;
};
//---------------------------------------------------------
// BasicDurationalObj
//---------------------------------------------------------
class BasicDurationalObj : public CapellaObj {
public:
int nDots;
bool noDuration;
bool postGrace;
bool bSmall;
bool notBlack;
QColor color;
TIMESTEP t;
int horizontalShift;
int count; // tuplet
bool tripartite;
bool isProlonging;
public:
BasicDurationalObj(Capella* c) : CapellaObj(c) {}
void read();
void readCapx(XmlReader& e, unsigned int& fullm);
void readCapxDisplay(XmlReader& e);
void readCapxObjectArray(XmlReader& e);
int ticks() const;
bool invisible;
QList<BasicDrawObj*> objects;
};
//---------------------------------------------------------
// Verse
//---------------------------------------------------------
struct Verse {
bool leftAlign;
bool extender;
bool hyphen;
int num;
QString verseNumber;
QString text;
};
struct CNote {
signed char pitch;
int explAlteration; // 1 force, 2 suppress
int headType;
int alteration;
int silent;
};
//---------------------------------------------------------
// ChordObj
//---------------------------------------------------------
class ChordObj : public BasicDurationalObj, public NoteObj {
public:
enum class StemDir : signed char { DOWN = -1, AUTO = 0, UP = 1, NONE = 3 };
BeamMode beamMode;
signed char notationStave;
char dStemLength;
unsigned char nTremoloBars;
unsigned articulation;
bool leftTie;
bool rightTie;
char beamShift;
char beamSlope;
public:
ChordObj(Capella*);
void read();
void readCapx(XmlReader& e);
void readCapxLyrics(XmlReader& e);
void readCapxNotes(XmlReader& e);
void readCapxStem(XmlReader& e);
void readCapxArticulation(XmlReader& e);
QList<Verse> verse;
QList<CNote> notes;
StemDir stemDir;
};
//---------------------------------------------------------
// RestObj
//---------------------------------------------------------
class RestObj : public BasicDurationalObj, public NoteObj {
bool bVerticalCentered;
int vertShift;
public:
RestObj(Capella*);
void read();
void readCapx(XmlReader& e);
unsigned fullMeasures; // >0, multi measure rest (counting measures)
};
//---------------------------------------------------------
// CapFont
//---------------------------------------------------------
struct CapFont {
QString face;
};
//---------------------------------------------------------
// CapBracket
//---------------------------------------------------------
struct CapBracket {
int from, to;
bool curly;
};
//---------------------------------------------------------
// Capella
//---------------------------------------------------------
class Capella {
static const char* errmsg[];
int curPos;
QFile* f;
char* author;
char* keywords;
char* comment;
unsigned char beamRelMin0;
unsigned char beamRelMin1;
unsigned char beamRelMax0;
unsigned char beamRelMax1;
unsigned nRel; // presentation parameter
unsigned nAbs;
bool bUseRealSize;
bool bAllowCompression;
bool bPrintLandscape;
bool bShowBarCount; // Taktnumerierung zeigen
unsigned char barNumberFrame; // 0=kein, 1=Rechteck, 2=Ellipse
unsigned char nBarDistX;
unsigned char nBarDistY;
// LogFont barNumFont;
unsigned nFirstPage; // Versatz fuer Seitenzaehlung
unsigned leftPageMargins; // Seitenraender
unsigned topPageMargins;
unsigned rightPageMargins;
unsigned btmPageMargins;
QList<QFont> fonts;
QList<CapStaffLayout*> _staffLayouts; // staff layout
int interDist;
unsigned char txtAlign; // Stimmenbezeichnungen 0=links, 1=zentriert, 2=rechts
unsigned char adjustVert; // 0=nein, 1=außer letzte Seite, 3=alle Seiten
bool redundantKeys;
bool modernDoubleNote;
bool bSystemSeparators;
int nUnnamed;
QFont namesFont;
void readVoice(CapStaff*, int);
void readStaff(CapSystem*);
void readSystem();
protected:
void readStaveLayout(CapStaffLayout*, int);
void readLayout();
public:
enum class Error : char { CAP_NO_ERROR, BAD_SIG, CAP_EOF, BAD_VOICE_SIG,
BAD_STAFF_SIG, BAD_SYSTEM_SIG
};
Capella();
~Capella();
void read(QFile*);
QString error(Error n) const { return QString(errmsg[int(n)]); }
unsigned char readByte();
char readChar();
QColor readColor();
int readInt();
int readLong();
short readWord();
int readDWord();
unsigned readUnsigned();
char* readString();
QString readQString();
void readExtra();
QList<BasicDrawObj*> readDrawObjectArray();
bool read(void* p, qint64 len);
QFont readFont();
QPointF readPoint();
QList<CapSystem*> systems;
QList<CapBracket> brackets;
ChordObj* backgroundChord;
CapStaffLayout* staffLayout(int idx) { return _staffLayouts[idx]; }
const QList<CapStaffLayout*>& staffLayouts() const { return _staffLayouts; }
double smallLineDist; // spatium unit in metric mm
double normalLineDist;
int topDist;
// capx support
private:
void readCapxVoice(XmlReader& e, CapStaff*, int);
void readCapxStaff(XmlReader& e, CapSystem*, int);
void readCapxSystem(XmlReader& e);
void capxSystems(XmlReader& e);
void readCapxStaveLayout(XmlReader& e, CapStaffLayout*, int);
void capxLayoutStaves(XmlReader& e);
void capxLayout(XmlReader& e);
void initCapxLayout();
public:
void readCapx(XmlReader& e);
QList<BasicDrawObj*> readCapxDrawObjectArray(XmlReader& e);
};
} // namespace Ms
#endif