//=============================================================================
//  MuseScore
//  Music Composition & Notation
//
//  Copyright (C) 2004-2011 Werner Schweer
//
//  This program is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License version 2
//  as published by the Free Software Foundation and appearing in
//  the file LICENCE.GPL
//=============================================================================
 
#ifndef __XML_H__
#define __XML_H__
 
#include "stafftype.h"
#include "interval.h"
#include "element.h"
#include "select.h"
 
namespace Ms {
 
enum class PlaceText : char;
enum class ClefType : signed char;
class Spanner;
class Beam;
class Tuplet;
class Measure;
class LinkedElements;
 
//---------------------------------------------------------
//   SpannerValues
//---------------------------------------------------------
 
struct SpannerValues {
      int spannerId;
      int tick2;
      int track2;
      };
 
//---------------------------------------------------------
//   XmlReader
//---------------------------------------------------------
 
class XmlReader : public QXmlStreamReader {
      Score* _score;
      QString docName;  // used for error reporting
 
      // Score read context (for read optimizations):
      int _tick             { 0       };
      int _tickOffset       { 0       };
      int _track            { 0       };
      int _trackOffset      { 0       };
      bool _pasteMode       { false   };        // modifies read behaviour on paste operation
      Measure* _lastMeasure { 0       };
      QHash<int, Beam*>    _beams;
      QHash<int, Tuplet*>  _tuplets;
 
      QList<SpannerValues> _spannerValues;
      QList<std::pair<int,Spanner*>> _spanner;
      QList<StaffType> _staffTypes;
 
      void htmlToString(int level, QString*);
      Interval _transpose;
      QMap<int, LinkedElements*> _elinks;
      QMultiMap<int, int> _tracks;
 
   public:
      XmlReader(Score* s, QFile* f) : QXmlStreamReader(f), _score(s), docName(f->fileName()) {}
      XmlReader(Score* s, const QByteArray& d, const QString& st = QString()) : QXmlStreamReader(d), _score(s), docName(st)  {}
      XmlReader(Score* s, QIODevice* d, const QString& st = QString()) : QXmlStreamReader(d), _score(s), docName(st) {}
      XmlReader(Score* s, const QString& d, const QString& st = QString()) : QXmlStreamReader(d), _score(s), docName(st) {}
 
      bool hasAccidental;                     // used for userAccidental backward compatibility
      void unknown();
 
      // attribute helper routines:
      QString attribute(const char* s) const { return attributes().value(s).toString(); }
      QString attribute(const char* s, const QString&) const;
      int intAttribute(const char* s) const;
      int intAttribute(const char* s, int _default) const;
      double doubleAttribute(const char* s) const;
      double doubleAttribute(const char* s, double _default) const;
      bool hasAttribute(const char* s) const;
 
      // helper routines based on readElementText():
      int readInt()         { return readElementText().toInt();      }
      int readInt(bool* ok) { return readElementText().toInt(ok);    }
      int readIntHex()      { return readElementText().toInt(0, 16); }
      double readDouble()   { return readElementText().toDouble();   }
      double readDouble(double min, double max);
      bool readBool();
      QPointF readPoint();
      QSizeF readSize();
      QRectF readRect();
      QColor readColor();
      Fraction readFraction();
      QString readXml();
 
      void setDocName(const QString& s) { docName = s; }
      QString getDocName() const        { return docName; }
 
      int tick()  const            { return _tick + _tickOffset;  }
      void initTick(int val)       { _tick = val;       }
      void incTick(int val)        { _tick += val;      }
      void setTickOffset(int val)  { _tickOffset = val; }
      int track() const            { return _track + _trackOffset;     }
      void setTrackOffset(int val) { _trackOffset = val;   }
      int trackOffset() const      { return _trackOffset;   }
      void setTrack(int val)       { _track = val;      }
      bool pasteMode() const       { return _pasteMode; }
      void setPasteMode(bool v)    { _pasteMode = v;    }
 
      void addBeam(Beam* s);
      Beam* findBeam(int id) const { return _beams.value(id);   }
 
      void addTuplet(Tuplet* s);
      Tuplet* findTuplet(int id) const { return _tuplets.value(id); }
      QHash<int, Tuplet*>& tuplets()   { return _tuplets; }
 
      void setLastMeasure(Measure* m) { _lastMeasure = m;    }
      Measure* lastMeasure() const    { return _lastMeasure; }
 
      void removeSpanner(const Spanner*);
      void addSpanner(int id, Spanner*);
      Spanner* findSpanner(int id);
      int spannerId(const Spanner*);      // returns spanner id, allocates new one if none exists
 
      void addSpannerValues(const SpannerValues& sv) { _spannerValues.append(sv); }
      const SpannerValues* spannerValues(int id) const;
      QList<StaffType>& staffType()     { return _staffTypes; }
      Interval transpose() const        { return _transpose; }
      void setTransposeChromatic(int v) { _transpose.chromatic = v; }
      void setTransposeDiatonic(int v)  { _transpose.diatonic = v; }
 
      QMap<int, LinkedElements*>& linkIds() { return _elinks;     }
      QMultiMap<int, int>& tracks()         { return _tracks;     }
 
      void checkTuplets();
      };
 
//---------------------------------------------------------
//   XmlWriter
//---------------------------------------------------------
 
class XmlWriter : public QTextStream {
      static const int BS = 2048;
 
      Score* _score;
      QList<QString> stack;
      QList<std::pair<int,const Spanner*>> _spanner;
      SelectionFilter _filter;
 
      int _spannerId      = { 1 };
      int _curTick        = { 0 };       // used to optimize output
      int _curTrack       = { -1 };
      int _tickDiff       = { 0 };
      int _trackDiff      = { 0 };       // saved track is curTrack-trackDiff
 
      bool _clipboardmode = { false };   // used to modify write() behaviour
      bool _excerptmode   = { false };   // true when writing a part
      bool _writeOmr      = { true };    // false if writing into *.msc file
      int _tupletId       = { 1 };
      int _beamId         = { 1 };
 
      void putLevel();
 
   public:
      XmlWriter(Score*);
      XmlWriter(Score* s, QIODevice* dev);
 
      int spannerId() const         { return _spannerId; }
      int curTick() const           { return _curTick; }
      int curTrack() const          { return _curTrack; }
      int tickDiff() const          { return _tickDiff; }
      int trackDiff() const         { return _trackDiff; }
 
      bool clipboardmode() const    { return _clipboardmode; }
      bool excerptmode() const      { return _excerptmode;   }
      bool writeOmr() const         { return _writeOmr;   }
      int nextTupletId()            { return _tupletId++;   }
      int nextBeamId()              { return _beamId++; }
 
      void setClipboardmode(bool v) { _clipboardmode = v; }
      void setExcerptmode(bool v)   { _excerptmode = v;   }
      void setWriteOmr(bool v)      { _writeOmr = v;      }
      void setTupletId(int v)       { _tupletId = v;      }
      void setBeamId(int v)         { _beamId = v;        }
      void setSpannerId(int v)      { _spannerId = v; }
      void setCurTick(int v)        { _curTick   = v; }
      void setCurTrack(int v)       { _curTrack  = v; }
      void setTickDiff(int v)       { _tickDiff  = v; }
      void setTrackDiff(int v)      { _trackDiff = v; }
 
      void incCurTick(int v)        { _curTick += v; }
 
      int addSpanner(const Spanner*);     // returns allocated id
      const Spanner* findSpanner(int id);
      int spannerId(const Spanner*);      // returns spanner id, allocates new one if none exists
 
      void sTag(const char* name, Spatium sp) { XmlWriter::tag(name, QVariant(sp.val())); }
      void pTag(const char* name, PlaceText);
 
      void header();
 
      void stag(const QString&);
      void etag();
 
      void tagE(const QString&);
      void tagE(const char* format, ...);
      void ntag(const char* name);
      void netag(const char* name);
 
      void tag(P_ID id, void* data, void* defaultVal);
      void tag(P_ID id, QVariant data, QVariant defaultData = QVariant());
      void tag(const char* name, QVariant data, QVariant defaultData = QVariant());
      void tag(const QString&, QVariant data);
      void tag(const char* name, const char* s)    { tag(name, QVariant(s)); }
      void tag(const char* name, const QString& s) { tag(name, QVariant(s)); }
      void tag(const char* name, const QWidget*);
 
      void writeXml(const QString&, QString s);
      void dump(int len, const unsigned char* p);
 
      void setFilter(SelectionFilter f) { _filter = f; }
      bool canWrite(const Element*) const;
      bool canWriteVoice(int track) const;
 
      static QString xmlString(const QString&);
      static QString xmlString(ushort c);
      };
 
extern PlaceText readPlacement(XmlReader&);
extern QString docName;
 
}     // namespace Ms
#endif
 

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

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

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

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