//=============================================================================
//  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
 

V730 Not all members of a class are initialized inside the constructor. Consider inspecting: form, line, oct.

V730 Not all members of a class are initialized inside the constructor. Consider inspecting: signature.

V730 Not all members of a class are initialized inside the constructor. Consider inspecting: numerator, log2Denom, allaBreve.

V730 Not all members of a class are initialized inside the constructor. Consider inspecting: _type, _barMode.

V730 Not all members of a class are initialized inside the constructor. Consider inspecting: width, yxRatio, height.

V730 Not all members of a class are initialized inside the constructor. Consider inspecting: b.

V730 Not all members of a class are initialized inside the constructor. Consider inspecting: lineWidth.

V730 Not all members of a class are initialized inside the constructor. Consider inspecting: lineWidth.

V730 Not all members of a class are initialized inside the constructor. Consider inspecting: radius, bFilled.

V730 Not all members of a class are initialized inside the constructor. Consider inspecting: bFilled, lineWidth.

V730 Not all members of a class are initialized inside the constructor. Consider inspecting: waveLen, adapt.

V730 Not all members of a class are initialized inside the constructor. Consider inspecting: x0, x1, y.

V730 Not all members of a class are initialized inside the constructor. Consider inspecting: flags, strings.

V730 Not all members of a class are initialized inside the constructor. Consider inspecting: orientation, number.