ASS: Update constructors of the ass classes and structs

src/Ass/Char.cc

 #include "Char.h"
+#include "Syl.h"
 
-Char::Char(const Char& old) :
-    char_(old.char_),
-    dur(old.dur),
-    line(old.line)
+Char::Char(Syl *const syl, const QChar)
+    : parentSyl(syl), parentLine(syl->parentLine)
 {
 }

src/Ass/Char.h

@@ -2,22 +2,25 @@
 #define VIVY_ASS_CHAR_H
 
 #include "Style.h"
-#include <cstdint>
 #include <QChar>
+#include <QtGlobal>
 
 class Line;
+class Syl;
 
 class Char {
 private:
-    QChar char_;
-    uint64_t dur;
+    QChar content;
+    quint64 dur{0};
 
-    Line *line;
+public:
+    Line *const parentLine;
+    Syl *const parentSyl;
 
 public:
     // Copy constructor
-    explicit Char(const Char&);
-    explicit Char(const QChar);
+    explicit Char(const Char&) = default;
+    explicit Char(Syl *const, const QChar);
 
     Char& operator=(const Char&) = delete;
     ~Char() noexcept = default;

src/Ass/Line.cc

 #include "Line.h"
 
-Line::Line(){
-}
-
-Line::Line(const Line& old) :
-    start(old.start),
-    end(old.end),
-    syls(old.syls)
+Line::Line(const QString&)
 {
 }

src/Ass/Line.h

@@ -2,20 +2,21 @@
 #define VIVY_ASS_LINE_H
 
 #include <QString>
-#include <cstdint>
+#include <QtGlobal>
 #include "Style.h"
 #include "Syl.h"
 
 class Line {
 private:
-    uint64_t start, end;
+    quint64 start{0};
+    quint64 end{0};
 
-    QVector<Syl> syls;
+    QVector<Syl> content{};
 
 public:
-    explicit Line();
-    explicit Line(const Line&);
-    explicit Line(QString);
+    explicit Line() = default;
+    explicit Line(const Line&) = default;
+    explicit Line(const QString&);
     Line& operator=(const Line&) = delete;
 
     ~Line() noexcept = default;

src/Ass/Style.cc

 #include "Style.h"
 
-Style::Style(const Style& old) :
-    styleName(old.styleName),
-    fontName(old.fontName),
-    fontSize(old.fontSize),
-    primaryColor(old.primaryColor),
-    secondaryColor(old.secondaryColor),
-    outlineColor(old.outlineColor),
-    backColor(old.backColor),
-    bold(old.bold),
-    italic(old.italic),
-    underline(old.underline),
-    strikeOut(old.strikeOut),
-    scaleX(old.scaleX),
-    scaleY(old.scaleY),
-    spacing(old.spacing),
-    angle(old.angle),
-    borderStyle(old.borderStyle),
-    alignment(old.alignment),
-    marginL(old.marginL),
-    marginR(old.marginR),
-    marginV(old.marginV),
-    encoding(old.encoding)
+Style::Style(const QString&)
 {
 }

src/Ass/Style.h

@@ -3,14 +3,16 @@
 
 #include <QString>
 #include <QVector>
-#include <cstdint>
+#include <QtGlobal>
 
 // class or struct, that is the question
 struct Color {
-    uint8_t a, r, g, b;
+    union {
+        quint8 a, r, g, b;
+        quint32 argb;
+    };
 
-    Color();
-    Color(const QString);
+    static Color fromString(const QString);
 };
 
 class Style {
@@ -21,18 +23,18 @@ private:
 
     Color primaryColor, secondaryColor, outlineColor, backColor;
 
-    bool bold, italic, underline, strikeOut;
+    bool bold{false}, italic{false}, underline{false}, strikeOut{false};
 
-    float scaleX, scaleY;
-    float spacing, angle, borderStyle;
+    float scaleX{0.0}, scaleY{0.0};
+    float spacing{0.0}, angle{0.0}, borderStyle{0.0};
 
-    int alignment, marginL, marginR, marginV;
+    int alignment{2}, marginL{0}, marginR{0}, marginV{0};
     int encoding;
 
 public:
     // Should grab and copy a user-changeable default style
-    explicit Style();
-    explicit Style(const Style&);
+    explicit Style() = delete;
+    explicit Style(const Style&) = default;
     explicit Style(const QString&);
 
     Style& operator=(const Style&) = delete;

src/Ass/Syl.cc

 #include "Syl.h"
 
-Syl::Syl(const Syl& old) :
-    chars(old.chars),
-    dur(old.dur),
-    line(old.line)
+Syl::Syl(Line *const line, const QString&)
+    : parentLine(line)
 {
 }

src/Ass/Syl.h

@@ -9,14 +9,15 @@ class Line;
 
 class Syl {
 private:
-    QVector<Char> chars;
-    uint64_t dur;
+    QVector<Char> content;
+    quint64 dur{0};
 
-    Line *line;
+public:
+    Line *const parentLine;
 
 public:
-    explicit Syl(const Syl&);
-    explicit Syl(const QString);
+    explicit Syl(const Syl&) = default;
+    explicit Syl(Line *const, const QString&);
 
     Syl& operator=(const Syl&) = delete;
     ~Syl() noexcept = default;