diff --git a/CoH_BSC_Editor.pro b/CoH_BSC_Editor.pro
new file mode 100644
index 0000000..d8a0d05
--- /dev/null
+++ b/CoH_BSC_Editor.pro
@@ -0,0 +1,67 @@
+#-------------------------------------------------
+#
+# Project created by QtCreator 2019-08-05T12:25:36
+#
+#-------------------------------------------------
+
+QT       += core gui
+
+greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
+
+TARGET = BSCWorks
+TEMPLATE = app
+
+# The following define makes your compiler emit warnings if you use
+# any feature of Qt which has been marked as deprecated (the exact warnings
+# depend on your compiler). Please consult the documentation of the
+# deprecated API in order to know how to port your code away from it.
+DEFINES += QT_DEPRECATED_WARNINGS
+
+# You can also make your code fail to compile if you use deprecated APIs.
+# In order to do so, uncomment the following line.
+# You can also select to disable deprecated APIs only up to a certain version of Qt.
+#DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000    # disables all the APIs deprecated before Qt 6.0.0
+
+CONFIG += c++17
+QMAKE_CXXFLAGS += /std:c++17
+
+SOURCES += \
+    src/bsc.cpp \
+    src/main.cpp \
+    src/mainwindow.cpp \
+    src/smc.cpp \
+    src/smf.cpp \
+    src/wav.cpp
+
+HEADERS += \
+    resources.rc \
+    src/bsc.h \
+    src/mainwindow.h \
+    src/smc.h \
+    src/smf.h \
+    src/version.h \
+    src/wav.h
+
+FORMS += \
+    src/mainwindow.ui
+
+# Default rules for deployment.
+qnx: target.path = /tmp/$${TARGET}/bin
+else: unix:!android: target.path = /opt/$${TARGET}/bin
+!isEmpty(target.path): INSTALLS += target
+
+RESOURCES += \
+    resources.qrc
+
+RC_FILE = resources.rc
+
+win32:CONFIG(release, debug|release): LIBS += -L$$PWD/lib/ -lqxtended_static_0_0_1_0_Qt_5_12_3
+else:win32:CONFIG(debug, debug|release): LIBS += -L$$PWD/lib/ -lqxtended_static_0_0_1_0_Qt_5_12_3d
+
+INCLUDEPATH += $$PWD/include
+DEPENDPATH += $$PWD/include
+
+win32-g++:CONFIG(release, debug|release): PRE_TARGETDEPS += $$PWD/lib/libqxtended_static_0_0_1_0_Qt_5_12_3.a
+else:win32-g++:CONFIG(debug, debug|release): PRE_TARGETDEPS += $$PWD/lib/libqxtended_static_0_0_1_0_Qt_5_12_3d.a
+else:win32:!win32-g++:CONFIG(release, debug|release): PRE_TARGETDEPS += $$PWD/lib/qxtended_static_0_0_1_0_Qt_5_12_3.lib
+else:win32:!win32-g++:CONFIG(debug, debug|release): PRE_TARGETDEPS += $$PWD/lib/qxtended_static_0_0_1_0_Qt_5_12_3d.lib
diff --git a/include/Windows_c++17_compat.h b/include/Windows_c++17_compat.h
new file mode 100644
index 0000000..92ecc88
--- /dev/null
+++ b/include/Windows_c++17_compat.h
@@ -0,0 +1,36 @@
+/* ----------------- C++17 Compatible Windows.h Header ------------------ */
+/* In C++ 17 the type std::byte was added to act as a formal method
+ * to store raw, uninterpreted data so that the practice of using
+ * "unsigned char" would no longer be required and the "char" type
+ * would finally be used exclusively for the storage of 8-bit
+ * characters. This was a beneficial addition, but unfortunately
+ * caused compatability issues with the windows SDK (at least as of
+ * Windows 10 SDK 10.0.17763.132); the ancient header "rpcndr.h" that
+ * is part of "Windows.h" contains:
+ *
+ * typedef unsigned char byte;
+ *
+ * which adds a definition of "byte" to the global namespace instead
+ * of a Windows SDK specific namespace as it should have been. This
+ * clashes with "byte" and makes the type ambiguous when utilizing
+ * "using namespace std;". This can be worked around by only including
+ * the poritions of the Windows SDK that are required for a project
+ * instead of including "Windows.h" directly or stricly avoiding the
+ * use of "using namespace std;".
+ *
+ * If neither of these options are practical, this file can be substituted
+ * for "Windows.h" instead. This header uses a macro to change "byte" to
+ * "WIN_BYTE" during the inclusion of "Windows.h" only so that the Windows
+ * SDK still compiles correctly but no longer clashes with std::byte.
+ *
+ * - oblivioncth
+ */
+
+#ifndef WINDOWS_C17_COMPAT_H
+#define WINDOWS_C17_COMPAT_H
+
+#define byte WIN_BYTE
+#include "Windows.h"
+#undef byte
+
+#endif // WINDOWS_C17_COMPAT_H
diff --git a/include/qx-io.h b/include/qx-io.h
new file mode 100644
index 0000000..c1acd9a
--- /dev/null
+++ b/include/qx-io.h
@@ -0,0 +1,141 @@
+#ifndef QXIO_H
+#define QXIO_H
+
+#include <QString>
+#include <QList>
+#include <QFile>
+#include <QDir>
+#include <QCryptographicHash>
+#include <QTextStream>
+
+namespace Qx
+{
+//-Classes--------------------------------------------------------------------------------------------------
+class IO
+{
+//-Inner Class Forward Declarations---------------------------------------------------------------------------------------
+public:
+    class IOOpReport;
+    class TextPos;
+//-Class Types------------------------------------------------------------------------------------------------------
+public:
+    enum IOOpType { IO_OP_READ, IO_OP_WRITE, IO_OP_ENUMERATE, IO_OP_INSPECT };
+    enum IOOpResultType { IO_SUCCESS, IO_ERR_UNKNOWN, IO_ERR_ACCESS_DENIED, IO_ERR_NOT_A_FILE, IO_ERR_NOT_A_DIR, IO_ERR_OUT_OF_RES,
+                          IO_ERR_READ, IO_ERR_WRITE, IO_ERR_FATAL, IO_ERR_OPEN, IO_ERR_ABORT,
+                          IO_ERR_TIMEOUT, IO_ERR_REMOVE, IO_ERR_RENAME, IO_ERR_REPOSITION,
+                          IO_ERR_RESIZE, IO_ERR_COPY, IO_ERR_FILE_DNE, IO_ERR_DIR_DNE,
+                          IO_ERR_FILE_EXISTS, IO_ERR_CANT_MAKE_DIR, IO_ERR_FILE_SIZE_MISMATCH, IO_ERR_CURSOR_OOB};
+    enum IOOpTargetType { IO_FILE, IO_DIR };
+
+//-Class Variables-------------------------------------------------------------------------------------------------
+public:
+    static inline QString ENDL = "\r\n"; //NOTE: Currently this is windows only
+
+    //- Class Functions-------------------------------------------------------------------------------------------------------------
+    private:
+        static IOOpResultType parsedOpen(QFile& file, QIODevice::OpenMode openMode);
+        static IOOpResultType translateQFileDeviceError(QFileDevice::FileError fileError);
+        static IOOpResultType translateQTextStreamStatus(QTextStream::Status fileStatus);
+        static IOOpResultType fileCheck(QFile& file);
+        static IOOpResultType directoryCheck(QDir& dir);
+
+    public:
+    // General:
+        static bool fileIsEmpty(QFile& file);
+        static bool fileIsEmpty(QFile& file, IOOpReport& reportBuffer);
+    // Text Based:
+        static IOOpReport findStringInFile(TextPos& returnBuffer, QFile& textFile, const QString& query, int hitsToSkip = 0);
+        static IOOpReport readTextFromFile(QString& returnBuffer, QFile& textFile, TextPos textPos, int characters = -1);
+        static IOOpReport readTextRangeFromFile(QString& returnBuffer, QFile& textFile, TextPos startPos, TextPos endPos = TextPos(-1,-1));
+        static IOOpReport readAllTextFromFile(QString& returnBuffer, QFile& textFile);
+        static IOOpReport readAllTextFromFileByLine(QStringList& returnBuffer, QFile &textFile, int startLine, int endLine = -1);
+        static IOOpReport writeStringAsFile(QFile &textFile, const QString& text, bool overwriteIfExist = false, bool createDirs = true);
+    // Directory Based:
+        static IOOpReport getDirFileList(QStringList& returnBuffer, QDir directory, bool includeSubdirectories = false, QStringList extFilter = QStringList());
+        static bool dirContainsFiles(QDir directory, bool includeSubdirectories = false);
+        static bool dirContainsFiles(QDir directory, IOOpReport& reportBuffer, bool includeSubdirectories = false);
+    // Integrity Based
+        static IOOpReport calculateFileChecksum(QByteArray& returnBuffer, QFile& file, QCryptographicHash::Algorithm hashAlgorithm);
+    // Raw Based
+        static IOOpReport readAllBytesFromFile(QByteArray& returnBuffer, QFile &file);
+        static IOOpReport readBytesFromFile(QByteArray& returnBuffer, QFile &file, long long start, long long end = -1);
+        static IOOpReport writeBytesAsFile(QFile &file, const QByteArray &byteArray, bool overwriteIfExist = false, bool createDirs = true);
+
+//-Inner Classes--------------------------------------------------------------------------------------------
+public:
+    class IOOpReport
+    {
+    //-Class Members----------------------------------------------------------------------------------------------------
+    public:
+        static const inline QStringList TARGET_TYPES  = {"file", "directory"};
+        static const inline QString SUCCESS_TEMPLATE = "Succesfully %1  ""%3""";
+        static const inline QString ERROR_TEMPLATE = "Error while %1 ""%3""";
+        static const inline QStringList SUCCESS_VERBS = {"read", "wrote", "enumerated", "inspecting"};
+        static const inline QStringList ERROR_VERBS = {"reading", "writing", "enumerating", "inspecting"};
+        static const inline QStringList ERROR_INFO = {"An unknown error has occured.", "Access denied.", "Target is not a file.", "Target is not a directory.", "Out of resources.",
+                                                      "General read error.", "General write error.", "A fatal error has occured.", "Could not open file.", "The opperation was aborted.",
+                                                      "Request timed out.", "The file could not be removed.", "The file could not be renamed.", "The file could not be moved.",
+                                                      "The file could not be resized.", "The file could not be copied.", "File does not exist.", "Directory does not exist.",
+                                                      "The file already exists.", "The directory could not be created.", "File size mismatch.", "File data cursor has gone out of bounds."};
+
+    //-Instance Members-------------------------------------------------------------------------------------------------
+    private:
+        IOOpType mOperation;
+        IOOpResultType mResult;
+        IOOpTargetType mTargetType;
+        QString mTarget = QString();
+        QString mOutcome = QString();
+        QString mOutcomeInfo = QString();
+    //-Constructor-------------------------------------------------------------------------------------------------------
+    public:
+        IOOpReport();
+        IOOpReport(IOOpType op, IOOpResultType res, QFile& tar);
+        IOOpReport(IOOpType op, IOOpResultType res, QDir& tar);
+
+    //-Instance Functions----------------------------------------------------------------------------------------------
+    public:
+        IOOpType getOperation() const;
+        IOOpResultType getResult() const;
+        IOOpTargetType getTargetType() const;
+        QString getTarget() const;
+        QString getOutcome() const;
+        QString getOutcomeInfo() const;
+        bool wasSuccessful() const;
+    private:
+        void parseOutcome();
+    };
+
+    class TextPos {
+    //-Class Types------------------------------------------------------------------------------------------------------
+    public:
+        static const TextPos START;
+        static const TextPos END;
+    //-Instance Variables------------------------------------------------------------------------------------------------
+    private:
+      int mLineNum;
+      int mCharNum;
+    //-Constructor-------------------------------------------------------------------------------------------------------
+    public:
+      TextPos();
+      TextPos(int lineNum, int charNum);
+
+    //-Instance Functions------------------------------------------------------------------------------------------------
+    public:
+      int getLineNum();
+      int getCharNum();
+      void setLineNum(int lineNum);
+      void setCharNum(int charNum);
+      void setNull();
+      bool isNull();
+
+      bool operator== (const TextPos &otherTextPos);
+      bool operator!= (const TextPos &otherTextPos);
+      bool operator> (const TextPos &otherTextPos);
+      bool operator>= (const TextPos &otherTextPos);
+      bool operator< (const TextPos &otherTextPos);
+      bool operator<= (const TextPos &otherTextPos);
+    };
+};
+}
+
+#endif // IO_H
diff --git a/include/qx.h b/include/qx.h
new file mode 100644
index 0000000..cd3dcbf
--- /dev/null
+++ b/include/qx.h
@@ -0,0 +1,462 @@
+#ifndef QX_H
+#define QX_H
+
+//#define REQUIRES(...) std::enable_if_t<__VA_ARGS__> // enable_if Macro; allows REQUIRES(std::is_arithmetic_v<T>) for example
+//TODO: Possibly remove this
+
+#include <QHash>
+#include <QCryptographicHash>
+#include <QRegularExpression>
+#include <QtEndian>
+#include <QWidget>
+
+namespace Qx
+{
+//-Class Forward Declarations---------------------------------------------------------------------------------------------
+template <typename T, std::enable_if_t<std::is_arithmetic_v<T>, int> = 0>
+class NII;
+
+class Endian;
+
+//-Traits-------------------------------------------------------------------------------------------------------
+template <class T, template <class...> class Template>
+struct is_specialization : std::false_type {};
+
+template <template <class...> class Template, class... Args>
+struct is_specialization<Template<Args...>, Template> : std::true_type {};
+
+//-Functions----------------------------------------------------------------------------------------------------
+template <typename T>
+struct typeIdentifier {typedef T type; }; // Forces compiler to deduce the type of T from only one argument so that implicit conversions can be used for the others
+
+template<typename T> //FIXME: Template is not type limited!
+T rangeToLength(T start, T end)
+{
+    // Returns the length from start to end including start, primarily for support of NII (Negative Is Infinity)
+    T length = end - start;
+    length++;
+    return length;
+}
+
+template<typename T, std::enable_if_t<std::is_arithmetic_v<T>, int> = 0>
+static bool isOdd(T num) { return num % 2; }
+
+template<typename T, std::enable_if_t<std::is_arithmetic_v<T>, int> = 0>
+static bool isEven(T num) { return !isOdd(num); }
+
+//int testFunction()
+//{
+//    NII<long> temp(5);
+//    NII<long> temptwo(4);
+
+//    std::vector<int> var;
+
+//    bool check = is_specialization<std::vector<int>, std::vector>::value;
+//   NII<long> test = rangeToLength(temp,temptwo);
+
+//   //return rangeToLength(3,4);
+
+
+
+//    return 10;
+//}
+
+//-Classes------------------------------------------------------------------------------------------------------
+class Endian
+{
+//-Class Types----------------------------------------------------------------------------------------------
+public:
+    enum Endianness{LE,BE};
+};
+
+class Array
+{
+//-Class Functions----------------------------------------------------------------------------------------------
+public:
+    template <typename T, int N>
+    static constexpr int constDim(T(&)[N]) { return N; } // Allows using the size of a const array at runtime
+
+    template <typename T, int N>
+    static int indexOf(T(&array) [N], typename typeIdentifier<T>::type query)
+    {
+        for(int i = 0; i < N; i++)
+            if(array[i] == query)
+                return i;
+
+        return -1;
+    }
+
+    template<typename T, int N>
+    static T maxOf(T(&array) [N])
+    {
+       T max = array[0];
+
+       for(int i = 1; i < N; i++)
+           if(array[i] > max)
+               max = array[i];
+
+       return max;
+    }
+
+    template<typename T, int N>
+    static T minOf(T(&array) [N])
+    {
+        T min = array[0];
+
+        for(int i = 1; i < N; i++)
+            if(array[i] < min)
+                min = array[i];
+
+        return min;
+    }
+
+    template<typename T, int N>
+    static T mostFrequent(T(&array) [N])
+    {
+        // Load all array elements into a hash
+        QHash<T,int> hash;
+        for(int i = 0; i < N; i++)
+            hash[array[i]]++;
+
+        // Determine greatest frequency
+        int maxFreq = 0;
+        T maxFreqVal = array[0]; // Assume first value is most frequent to start
+        QHashIterator<T,int> i(hash);
+
+        while(i.hasNext())
+        {
+            i.next();
+            if(maxFreq < i.value())
+            {
+                maxFreqVal = i.key();
+                maxFreq = i.value();
+            }
+        }
+
+         return maxFreqVal;
+    }
+};
+
+class ByteArray
+{
+//-Class Functions----------------------------------------------------------------------------------------------
+public:
+    template<typename T, std::enable_if_t<std::is_integral_v<T>, int> = 0>
+    static QByteArray RAWFromPrimitive(T primitive, Endian::Endianness endianness = Endian::LE)
+    {
+        QByteArray rawBytes;
+
+        if(typeid(T) == typeid(bool))
+            rawBytes.append(static_cast<char>(static_cast<int>(primitive))); // Ensures true -> 0x01 and false -> 0x00
+        else
+        {
+            for(int i = 0; i != sizeof(T); ++i)
+            {
+                #pragma warning( push )          // Disable "Unsafe mix of type 'bool' and 'int' warning because the
+                #pragma warning( disable : 4805) // function will never reach this point when bool is used
+                if(endianness == Endian::LE)
+                    rawBytes.append(static_cast<char>(((primitive & (0xFF << (i*8))) >> (i*8))));
+                else
+                    rawBytes.prepend(static_cast<char>(((primitive & (0xFF << (i*8))) >> (i*8))));
+                #pragma warning( pop )
+            }
+        }
+
+        return rawBytes;
+    }
+
+    template<typename T, std::enable_if_t<std::is_floating_point_v<T>, int> = 0>
+    static QByteArray RAWFromPrimitive(T primitive, Endian::Endianness endianness = Endian::LE)
+    {
+        QByteArray rawBytes;
+
+        if(typeid(T) == typeid(float))
+        {
+            int* temp = reinterpret_cast<int*>(&primitive);
+            int intStandIn = (*temp);
+
+            for(uint8_t i = 0; i != sizeof(float); ++i)
+            {
+                if(endianness == Endian::LE)
+                    rawBytes.append(static_cast<char>(((intStandIn & (0xFF << (i*8))) >> (i*8))));
+                else
+                    rawBytes.prepend(static_cast<char>(((intStandIn & (0xFF << (i*8))) >> (i*8))));
+            }
+        }
+
+        if(typeid(T) == typeid(double))
+        {
+            long* temp = reinterpret_cast<long*>(&primitive);
+            long intStandIn = (*temp);
+
+            for(uint8_t i = 0; i != sizeof(double); ++i)
+            {
+                if(endianness == Endian::LE)
+                    rawBytes.append(static_cast<char>(((intStandIn & (0xFF << (i*8))) >> (i*8))));
+                else
+                    rawBytes.prepend(static_cast<char>(((intStandIn & (0xFF << (i*8))) >> (i*8))));
+            }
+        }
+
+        return rawBytes;
+    }
+
+    template<typename T, std::enable_if_t<std::is_fundamental_v<T>, int> = 0>
+    static T RAWToPrimitive(QByteArray ba, Endian::Endianness endianness = Endian::LE)
+    {
+        static_assert(std::numeric_limits<float>::is_iec559, "Only supports IEC 559 (IEEE 754) float"); // For floats
+        assert((ba.size() >= 2 && ba.size() <= 8 && isEven(ba.size())) || ba.size() == 1);
+
+        if(sizeof(T) == 1)
+        {
+            quint8 temp;
+
+            if(endianness == Endian::BE)
+                 temp = qFromBigEndian<quint8>(ba);
+            else if(endianness == Endian::LE)
+                 temp = qFromLittleEndian<quint8>(ba);
+
+            T* out = reinterpret_cast<T*>(&temp);
+            return(*out);
+        }
+        else if(sizeof(T) == 2)
+        {
+            quint16 temp;
+
+            if(endianness == Endian::BE)
+                 temp = qFromBigEndian<quint16>(ba);
+            else if(endianness == Endian::LE)
+                 temp = qFromLittleEndian<quint16>(ba);
+
+            T* out = reinterpret_cast<T*>(&temp);
+            return(*out);
+        }
+        else if(sizeof(T) == 4)
+        {
+            quint32 temp;
+
+            if(endianness ==Endian::BE)
+                 temp = qFromBigEndian<quint32>(ba);
+            else if(endianness == Endian::LE)
+                 temp = qFromLittleEndian<quint32>(ba);
+
+            T* out = reinterpret_cast<T*>(&temp);
+            return(*out);
+        }
+        else if(sizeof(T) == 8)
+        {
+            quint64 temp;
+
+            if(endianness == Endian::BE)
+                 temp = qFromBigEndian<quint64>(ba);
+            else if(endianness == Endian::LE)
+                 temp = qFromLittleEndian<quint64>(ba);
+
+            T* out = reinterpret_cast<T*>(&temp);
+            return(*out);
+        }
+    }
+
+    static QByteArray RAWFromString(QString str);
+    static QByteArray RAWFromStringHex(QString str);
+};
+
+class Char
+{
+//-Class Functions----------------------------------------------------------------------------------------------
+public:
+    static bool isHexNumber(QChar hexNum);
+};
+
+class Integrity
+{
+//-Class Functions---------------------------------------------------------------------------------------------
+public:
+    static QByteArray generateChecksum(QByteArray &data, QCryptographicHash::Algorithm hashAlgorithm);
+};
+
+template <typename T, std::enable_if_t<std::is_arithmetic_v<T>, int>>
+//template <typename T>
+class NII // Negative Is Infinity - Wrapper class (0 is minimum)
+{
+//-Class Members-------------------------------------------------------------------------------------------------
+public:
+    static const T INF = -1;
+    static const T NULL_VAL = -2;
+
+//-Instance Members----------------------------------------------------------------------------------------------
+private:
+    T mValue;
+
+//-Constructor----------------------------------------------------------------------------------------------
+public:
+    NII() { mValue = NULL_VAL; }
+    NII(T value, bool boundAtZero = false) : mValue(forceBounds(value, boundAtZero)) { }
+
+//-Class Functions----------------------------------------------------------------------------------------------
+private:
+    T forceBounds(T checkValue, bool boundAtZero)
+    {
+        if(boundAtZero && checkValue < 0)
+            return 0;
+        else if(checkValue < 0 )
+            return -1;
+
+        return checkValue;
+    }
+//-Instance Functions----------------------------------------------------------------------------------------------
+public:
+    bool operator==(const NII& otherNII) const { return mValue = otherNII.mValue; }
+    bool operator!=(const NII& otherNII) const { return !(*this == otherNII); }
+    bool operator<(const NII& otherNII) const { return (!this->isInf() && otherNII.isInf()) || (!this->isInf() && (this->mValue < otherNII.mValue)); }
+    bool operator<=(const NII& otherNII) const { return !(*this > otherNII); }
+    bool operator>(const NII& otherNII) const { return otherNII < *this; }
+    bool operator>=(const NII& otherNII) const { return !(*this < otherNII); }
+    NII operator-(const NII& otherNII)
+    {
+        if(otherNII.isInf())
+            return NII(0);
+        else if(this->isInf())
+            return NII(INF);
+        else
+            return forceBounds(this->mValue - otherNII.mValue, true);
+    }
+    NII operator+(const NII& otherNII)
+    {
+        if(otherNII.isInf() || this->isInf())
+            return NII(INF);
+        else
+            return forceBounds(this->mValue + otherNII.mValue, true);
+    }
+    NII operator/(const NII& otherNII)
+    {
+        if(otherNII.isInf())
+            return NII(0);
+        else if(this->isInf())
+            return NII(INF);
+        else
+            return forceBounds(this->mValue/otherNII.mValue, true);
+    }
+    NII operator*(const NII& otherNII)
+    {
+        if(otherNII.isInf() || this->isInf())
+            return NII(INF);
+        else
+            return forceBounds(this->mValue*otherNII.mValue, true);
+    }
+    NII& operator++()
+    {
+        if(!this->isInf())
+            this->mValue++;
+
+        return *this;
+    }
+    NII operator++(int)
+    {
+        NII val = (*this);
+        this->operator++();
+        return val;
+    }
+    NII& operator--()
+    {
+        this->mValue = forceBounds(this->mValue - 1, true);
+        return *this;
+    }
+    NII operator--(int)
+    {
+        NII val = (*this);
+        this->operator--();
+        return val;
+    }
+
+    void setInf() { mValue = INF; }
+    void setNull() { mValue = NULL_VAL; }
+    bool isInf() const { return mValue == INF; }
+    T value() const { return mValue; }
+};
+
+class List
+{
+//-Class Functions----------------------------------------------------------------------------------------------
+public:
+    template<typename T>
+    static QList<T>* getSubListThatContains(T element, QList<QList<T>*> listOfLists)
+    {
+        // Returns pointer to the first list that contains "element". Returns nullptr if none
+        for(QList<T>* currentList : listOfLists)
+           if(currentList->contains(element))
+               return currentList;
+
+        return nullptr;
+    }
+
+    static QWidgetList objectListToWidgetList(QObjectList list);
+};
+
+class MMRB
+{
+//-Class Variables---------------------------------------------------------------------------------------------
+private:
+    //static inline const QString MMRB_FORMAT = "%1.%2.%3.%4";
+
+//-Member Variables--------------------------------------------------------------------------------------------
+private:
+    int mMajor;
+    int mMinor;
+    int mRevision;
+    int mBuild;
+
+//-Constructor-------------------------------------------------------------------------------------------------
+public:
+    MMRB();
+    MMRB(int major, int minor, int revision, int build);
+
+//-Member Functions--------------------------------------------------------------------------------------------
+public:
+    bool operator== (const MMRB &otherMMRB);
+    bool operator!= (const MMRB &otherMMRB);
+    bool operator> (const MMRB &otherMMRB);
+    bool operator>= (const MMRB &otherMMRB);
+    bool operator< (const MMRB &otherMMRB);
+    bool operator<= (const MMRB &otherMMRB);
+
+    QString toString();
+    int getMajorVer();
+    int getMinorVer();
+    int getRevisionVer();
+    int getBuildVer();
+    bool isNull();
+private:
+
+//-Class Functions---------------------------------------------------------------------------------------------
+public:
+    static MMRB fromString(QString string);
+};
+
+class RegEx
+{
+//-Class Variables---------------------------------------------------------------------------------------------
+public:
+    static inline const QRegularExpression hexOnly =  QRegularExpression("^[0-9A-F]+$", QRegularExpression::CaseInsensitiveOption);
+    static inline const QRegularExpression nonHexOnly = QRegularExpression("[^a-fA-F0-9 -]", QRegularExpression::CaseInsensitiveOption);
+    static inline const QRegularExpression numbersOnly = QRegularExpression("\\d*", QRegularExpression::CaseInsensitiveOption); // a digit (\d)
+    static inline const QRegularExpression alphanumericOnly = QRegularExpression("^[a-zA-Z0-9]*$", QRegularExpression::CaseInsensitiveOption);
+    static inline const QRegularExpression lettersOnly = QRegularExpression("^[a-zA-Z]+$", QRegularExpression::CaseInsensitiveOption);
+};
+
+class String
+{
+//-Class Functions----------------------------------------------------------------------------------------------
+public:
+    static bool isOnlyNumbers(QString checkStr);
+    static bool isValidMMRB(QString version);
+    static bool isHexNumber(QString hexNum);
+    static bool isValidChecksum(QString checksum, QCryptographicHash::Algorithm hashAlgorithm);
+    static QString fromByteArray(QByteArray data);
+    static QString fromByteArrayHex(QByteArray data);
+    static QString fromByteArrayHex(QByteArray data, QChar separator, Endian::Endianness endianness);
+    static QString stripToHexOnly(QString string);
+};
+
+}
+#endif // QX_H
diff --git a/lib/qxtended_static_0_0_1_0_Qt_5_12_3.lib b/lib/qxtended_static_0_0_1_0_Qt_5_12_3.lib
new file mode 100644
index 0000000..45011c4
Binary files /dev/null and b/lib/qxtended_static_0_0_1_0_Qt_5_12_3.lib differ
diff --git a/lib/qxtended_static_0_0_1_0_Qt_5_12_3d.lib b/lib/qxtended_static_0_0_1_0_Qt_5_12_3d.lib
new file mode 100644
index 0000000..fc270c3
Binary files /dev/null and b/lib/qxtended_static_0_0_1_0_Qt_5_12_3d.lib differ
diff --git a/res/About.png b/res/About.png
new file mode 100644
index 0000000..e6b4343
Binary files /dev/null and b/res/About.png differ
diff --git a/res/Batch_SMF_to_WAV.png b/res/Batch_SMF_to_WAV.png
new file mode 100644
index 0000000..65c8d8f
Binary files /dev/null and b/res/Batch_SMF_to_WAV.png differ
diff --git a/res/Batch_WAV_to_SMF.png b/res/Batch_WAV_to_SMF.png
new file mode 100644
index 0000000..e42f3c1
Binary files /dev/null and b/res/Batch_WAV_to_SMF.png differ
diff --git a/res/Close.png b/res/Close.png
new file mode 100644
index 0000000..51ac278
Binary files /dev/null and b/res/Close.png differ
diff --git a/res/Convert_SMF_to_WAV.png b/res/Convert_SMF_to_WAV.png
new file mode 100644
index 0000000..38ace26
Binary files /dev/null and b/res/Convert_SMF_to_WAV.png differ
diff --git a/res/Convert_WAV_to_SMF.png b/res/Convert_WAV_to_SMF.png
new file mode 100644
index 0000000..7ed0c53
Binary files /dev/null and b/res/Convert_WAV_to_SMF.png differ
diff --git a/res/Copy_Disabled.png b/res/Copy_Disabled.png
new file mode 100644
index 0000000..0fb1592
Binary files /dev/null and b/res/Copy_Disabled.png differ
diff --git a/res/Copy_Enabled.png b/res/Copy_Enabled.png
new file mode 100644
index 0000000..8ed64fc
Binary files /dev/null and b/res/Copy_Enabled.png differ
diff --git a/res/Exit.png b/res/Exit.png
new file mode 100644
index 0000000..490b084
Binary files /dev/null and b/res/Exit.png differ
diff --git a/res/Minus_Disabled.png b/res/Minus_Disabled.png
new file mode 100644
index 0000000..3bc79cf
Binary files /dev/null and b/res/Minus_Disabled.png differ
diff --git a/res/Minus_Enabled.png b/res/Minus_Enabled.png
new file mode 100644
index 0000000..ccfbde2
Binary files /dev/null and b/res/Minus_Enabled.png differ
diff --git a/res/New.png b/res/New.png
new file mode 100644
index 0000000..fdbfd9b
Binary files /dev/null and b/res/New.png differ
diff --git a/res/New_Cache.png b/res/New_Cache.png
new file mode 100644
index 0000000..717f825
Binary files /dev/null and b/res/New_Cache.png differ
diff --git a/res/Open.png b/res/Open.png
new file mode 100644
index 0000000..c4bfb61
Binary files /dev/null and b/res/Open.png differ
diff --git a/res/Plus_Disabled.png b/res/Plus_Disabled.png
new file mode 100644
index 0000000..f1aaadf
Binary files /dev/null and b/res/Plus_Disabled.png differ
diff --git a/res/Plus_Enabled.png b/res/Plus_Enabled.png
new file mode 100644
index 0000000..e6bd95a
Binary files /dev/null and b/res/Plus_Enabled.png differ
diff --git a/res/Save.png b/res/Save.png
new file mode 100644
index 0000000..33dbe6f
Binary files /dev/null and b/res/Save.png differ
diff --git a/res/Save_as.png b/res/Save_as.png
new file mode 100644
index 0000000..56e6f1f
Binary files /dev/null and b/res/Save_as.png differ
diff --git a/res/Update_Cash.png b/res/Update_Cash.png
new file mode 100644
index 0000000..b98ac58
Binary files /dev/null and b/res/Update_Cash.png differ
diff --git a/res/bscworks.ico b/res/bscworks.ico
new file mode 100644
index 0000000..2830596
Binary files /dev/null and b/res/bscworks.ico differ
diff --git a/resources.qrc b/resources.qrc
new file mode 100644
index 0000000..24991f4
--- /dev/null
+++ b/resources.qrc
@@ -0,0 +1,24 @@
+<RCC>
+    <qresource prefix="/">
+        <file>res/Plus_Enabled.png</file>
+        <file>res/Plus_Disabled.png</file>
+        <file>res/Minus_Enabled.png</file>
+        <file>res/Minus_Disabled.png</file>
+        <file>res/Copy_Disabled.png</file>
+        <file>res/Copy_Enabled.png</file>
+        <file>res/New.png</file>
+        <file>res/Open.png</file>
+        <file>res/Save.png</file>
+        <file>res/Save_as.png</file>
+        <file>res/Close.png</file>
+        <file>res/Exit.png</file>
+        <file>res/Batch_SMF_to_WAV.png</file>
+        <file>res/Batch_WAV_to_SMF.png</file>
+        <file>res/Convert_SMF_to_WAV.png</file>
+        <file>res/Convert_WAV_to_SMF.png</file>
+        <file>res/About.png</file>
+        <file>res/New_Cache.png</file>
+        <file>res/Update_Cash.png</file>
+    </qresource>
+    <qresource prefix="/res" lang="English"/>
+</RCC>
diff --git a/resources.rc b/resources.rc
new file mode 100644
index 0000000..8ae9c11
--- /dev/null
+++ b/resources.rc
@@ -0,0 +1,31 @@
+IDI_ICON1               ICON    DISCARDABLE     "res/bscworks.ico"
+
+#include "include\Windows_c++17_compat.h"
+#include "src\version.h"
+
+VS_VERSION_INFO VERSIONINFO
+FILEVERSION     VER_FILEVERSION
+PRODUCTVERSION  VER_PRODUCTVERSION
+BEGIN
+    BLOCK "StringFileInfo"
+    BEGIN
+        BLOCK "040904E4"
+        BEGIN
+            VALUE "CompanyName",        VER_COMPANYNAME_STR
+            VALUE "FileDescription",    VER_FILEDESCRIPTION_STR
+            VALUE "FileVersion",        VER_FILEVERSION_STR
+            VALUE "InternalName",       VER_INTERNALNAME_STR
+            VALUE "LegalCopyright",     VER_LEGALCOPYRIGHT_STR
+            VALUE "LegalTrademarks1",   VER_LEGALTRADEMARKS1_STR
+            VALUE "LegalTrademarks2",   VER_LEGALTRADEMARKS2_STR
+            VALUE "OriginalFilename",   VER_ORIGINALFILENAME_STR
+            VALUE "ProductName",        VER_PRODUCTNAME_STR
+            VALUE "ProductVersion",     VER_PRODUCTVERSION_STR
+        END
+    END
+
+    BLOCK "VarFileInfo"
+    BEGIN
+        VALUE "Translation", 0x409, 1252
+    END
+END
diff --git a/src/bsc.cpp b/src/bsc.cpp
new file mode 100644
index 0000000..1b4086f
--- /dev/null
+++ b/src/bsc.cpp
@@ -0,0 +1,761 @@
+#include "bsc.h"
+#include <QtEndian>
+#include <QObject>
+#include <assert.h>
+#include <QVector>
+#include <functional>
+#include "qx.h"
+
+//===============================================================================================================
+// BSC
+//===============================================================================================================
+
+//-Constructor------------------------------------------------------------------------------------------------
+//Public:
+
+BSC::BSC(QByteArray rawData)
+    : mFileDataF(rawData)
+{
+    separateData();
+    interpretData();
+}
+
+BSC::BSC()
+{
+    // Initialize default vars
+    mDataCursor = 0;
+
+    // Full Data
+    mFileDataF = "";
+
+    // Segmented Raw Data
+    mTweenerR = "";
+    mFormatVerR = "";
+    mPlaylistCountR = "";
+
+    // Segmented Interpreted Data
+    mTweenerI = "00 00 00 00 00";
+    mFormatVerI = FORMAT_TAG_DEFAULT;
+    mPlaylistCountI = PLAYLIST_COUNT_DEFAULT;
+}
+
+//-Class Functions------------------------------------------------------------------------------------------------
+//Public:
+bool BSC::fileIsValidBSC(QFile& possibleBSC, Qx::IO::IOOpReport& reportBuffer)
+{
+    QByteArray headerSection;
+    reportBuffer = Qx::IO::readBytesFromFile(headerSection, possibleBSC, 0, 12);
+
+    return reportBuffer.wasSuccessful() &&
+           Qx::String::fromByteArray(headerSection.left(4)) == BSC::EA_SHARK_SIG && Qx::String::fromByteArray(headerSection.mid(9, 4)) == BSC::BSC_SIG;
+}
+
+//-Instance Functions------------------------------------------------------------------------------------------------
+//Public:
+QString BSC::getInterpretedTweener() const { return mTweenerI; }
+uint32_t BSC::getInterpretedFormatVer() const { return mFormatVerI; }
+uint8_t BSC::getInterpretedPlayListCount() const { return static_cast<uint8_t>(mPlaylists.length()); }
+QList<BSC::Playlist> BSC::getPlaylistsV() const { return mPlaylists; }
+QList<BSC::Playlist>& BSC::getPlaylistsR() { return mPlaylists; }
+bool BSC::hasPlaylists() const { return mPlaylists.length() > 0; }
+int BSC::totalPlaylistCount()
+{
+    int totalCount = 0;
+
+    for(int i = 0; i < mPlaylists.length(); i++)
+    {
+        totalCount++;
+        totalCount += recursiveSubPlaylistCounter(mPlaylists[i]);
+    }
+
+    return totalCount;
+}
+
+QByteArray BSC::rebuildRawFile()
+{
+    // Recursive Lambda for sub-playlists
+    std::function<void(BSC::Playlist& parentPlaylist)> recursiveSubPlaylistDeinterpriation;
+    recursiveSubPlaylistDeinterpriation = [&recursiveSubPlaylistDeinterpriation](BSC::Playlist& parentPlaylist)->void
+    {
+        for(int i = 0; i <parentPlaylist.subPlaylistCount(); i++)
+        {
+            parentPlaylist.getSubPlaylistsR()[i].deinterpretData();
+            for(int j = 0; j <parentPlaylist.getSubPlaylistsR()[i].soundContainerCount(); j++)
+                parentPlaylist.getSubPlaylistsR()[i].getSoundContainersR()[j].deinterpretData();
+
+            recursiveSubPlaylistDeinterpriation(parentPlaylist.getSubPlaylistsR()[i]);
+        }
+    };
+
+    // Dump all interpreted data back to raw
+    deinterpretData();
+    for(int i = 0; i < mPlaylists.length(); i++)
+    {
+        // Top level playlist
+        mPlaylists[i].deinterpretData();
+        for(int j = 0; j < mPlaylists[i].soundContainerCount(); j++)
+            mPlaylists[i].getSoundContainersR()[j].deinterpretData();
+
+        // Sub playlists
+        recursiveSubPlaylistDeinterpriation(mPlaylists[i]);
+    }
+
+    // Re-join separated data
+    QByteArray rebuiltFile = Qx::ByteArray::RAWFromString(EA_SHARK_SIG);
+    rebuiltFile += mTweenerR;
+    rebuiltFile += Qx::ByteArray::RAWFromString(BSC_SIG);
+    rebuiltFile += mFormatVerR;
+    rebuiltFile += mPlaylistCountR;
+
+    for(int i = 0; i < mPlaylists.length(); i++)
+        rebuiltFile += mPlaylists[i].getRestitchedData();
+
+    return rebuiltFile;
+}
+
+//Private:
+void BSC::separateData()
+{
+    mDataCursor = 0x00; // Start of data
+
+    mDataCursor += L_FORMAT_TAG_1; // Move to tweener start
+        mTweenerR = mFileDataF.mid(mDataCursor,L_TWEENER);
+    mDataCursor += L_TWEENER + L_FORMAT_TAG_2; // Move to format ver start
+        mFormatVerR = mFileDataF.mid(mDataCursor,L_FORMAT_VER);
+    mDataCursor += L_FORMAT_VER; // Move to playlist count start
+        mPlaylistCountR = mFileDataF.mid(mDataCursor,L_PLAYLIST_COUNT);
+    mDataCursor += L_PLAYLIST_COUNT; // Move to first playlist mode name length start
+
+    // Create Playlists in order to continue sequential movement of the data cursor
+    for(int i = 0; i < qFromLittleEndian<qint8>(mPlaylistCountR); i++)
+        mPlaylists.append(Playlist(mDataCursor, mFileDataF, false));
+}
+
+void BSC::interpretData()
+{
+    mTweenerI = Qx::String::fromByteArrayHex(mTweenerR,TWEENER_BYTE_SEP, Qx::Endian::LE);
+    mFormatVerI = qFromLittleEndian<quint32>(mFormatVerR);
+    mPlaylistCountI = qFromLittleEndian<quint8>(mPlaylistCountR);
+}
+
+void BSC::deinterpretData()
+{
+    mTweenerR = Qx::ByteArray::RAWFromStringHex(mTweenerI.remove(TWEENER_BYTE_SEP));
+    mFormatVerR = Qx::ByteArray::RAWFromPrimitive(mFormatVerI, Qx::Endian::LE);
+    mPlaylistCountR = Qx::ByteArray::RAWFromPrimitive(static_cast<uint8_t>(mPlaylists.length()), Qx::Endian::LE);
+}
+
+int BSC::recursiveSubPlaylistCounter(BSC::Playlist& parentPlaylist)
+{
+    int subCount = 0;
+
+    for (int i = 0; i < parentPlaylist.subPlaylistCount(); i++)
+    {
+        subCount++;
+        subCount += recursiveSubPlaylistCounter(parentPlaylist.getSubPlaylistsR()[i]);
+    }
+
+    return subCount;
+}
+
+//===============================================================================================================
+// PLAYLIST
+//===============================================================================================================
+
+//-Constructor------------------------------------------------------------------------------------------------
+//Public:
+
+BSC::Playlist::Playlist(int &parentDataCursor, QByteArray &parentRawData, bool subPlaylist)
+    : mSubPlaylist(subPlaylist)
+{
+    separateData(parentDataCursor, parentRawData);
+    interpretData();
+}
+
+BSC::Playlist::Playlist(bool subPlaylist)
+{
+    defaultInitialization();
+    mSubPlaylist = subPlaylist;
+}
+
+BSC::Playlist::Playlist() { defaultInitialization(); }
+
+//-Instance Functions------------------------------------------------------------------------------------------------
+//Public:
+bool BSC::Playlist::getInitialTreeExpansion() const { return mInitiallyExpandedInTree; }
+BSC::Playlist::PlaybackMode BSC::Playlist::getInterpretedPlaybackMode() const { return mPlaybackModeI; }
+uint32_t BSC::Playlist::getInterpretedMaxInstances() const { return mMaxInstancesI; }
+uint32_t BSC::Playlist::getInterpretedPolyphony() const { return mPolyphonyI; }
+uint32_t BSC::Playlist::getInterpretedMinRepeatTime() const { return mMinRepeatTimeI; }
+uint32_t BSC::Playlist::getInterpretedMaxRepeatTime() const { return mMaxRepeatTimeI; }
+uint32_t BSC::Playlist::getInterpretedMinRepeatCount() const { return mMinRepeatCountI; }
+uint32_t BSC::Playlist::getInterpretedMaxRepeatCount() const { return mMaxRepeatCountI; }
+uint32_t BSC::Playlist::getInterpretedRandomPlaylistWeight() const { return mRandomPlaylistWeightI; }
+float BSC::Playlist::getInterpretedLength() const { return mLengthI; }
+float BSC::Playlist::getInterpretedReleaseTime() const { return mReleaseTimeI; }
+QStringList BSC::Playlist::getInterpretedEffectBehaviorsV() const { return mEffectBehaviorsI; }
+QStringList& BSC::Playlist::getInterpretedEffectBehaviorsR() { return mEffectBehaviorsI; }
+bool BSC::Playlist::getInterpretedOverrideParentBehaviors() const { return mOverrideParentBehaviorsI; }
+BSC::Playlist::Emitter BSC::Playlist::getInterpretedEmitter() const { return mEmitterI; }
+QList<BSC::SoundContainer> BSC::Playlist::getSoundContainersV() const { return mSoundContainers; }
+QList<BSC::SoundContainer>& BSC::Playlist::getSoundContainersR() { return mSoundContainers; }
+QList<BSC::Playlist> BSC::Playlist::getSubPlaylistsV() const { return mSubPlaylists; }
+QList<BSC::Playlist>& BSC::Playlist::getSubPlaylistsR() { return mSubPlaylists; }
+bool BSC::Playlist::hasSoundContainers() const { return mSoundContainers.length() > 0; }
+bool BSC::Playlist::hasSubPlaylists() const { return mSubPlaylists.length() > 0; }
+bool BSC::Playlist::hasEffectBehaviors() const { return mEffectBehaviorsI.length() > 0; }
+int BSC::Playlist::soundContainerCount() const { return mSoundContainers.length(); }
+int BSC::Playlist::subPlaylistCount() const { return mSubPlaylists.length(); }
+int BSC::Playlist::effectBehaviorCount() const { return mEffectBehaviorsI.length(); }
+
+void BSC::Playlist::setInitialTreeExpansion(bool expanded) { mInitiallyExpandedInTree = expanded; }
+void BSC::Playlist::setInterpretedPlaybackMode(BSC::Playlist::PlaybackMode playbackMode) { mPlaybackModeI = playbackMode; }
+void BSC::Playlist::setInterpretedMaxInstances(uint32_t maxInstances) { mMaxInstancesI = maxInstances; }
+void BSC::Playlist::setInterpretedPolyphony(uint32_t polphony) { mPolyphonyI = polphony; }
+void BSC::Playlist::setInterpretedMinRepeatTime(uint32_t minRepeatTime) { mMinRepeatTimeI = minRepeatTime; }
+void BSC::Playlist::setInterpretedMaxRepeatTime(uint32_t maxRepeatTime) { mMaxRepeatTimeI = maxRepeatTime; }
+void BSC::Playlist::setInterpretedMinRepeatCount(uint32_t minRpeatCount) { mMinRepeatCountI = minRpeatCount; }
+void BSC::Playlist::setInterpretedMaxRepeatCount(uint32_t maxRepeatCount) { mMaxRepeatCountI = maxRepeatCount; }
+void BSC::Playlist::setInterpretedRandomPlaylistWeight(uint32_t randomPlaylistWeight) { mRandomPlaylistWeightI = randomPlaylistWeight; }
+void BSC::Playlist::setInterpretedLength(float length) { mLengthI = length; }
+void BSC::Playlist::setInterpretedReleaseTime(float releaseTime) { mReleaseTimeI = releaseTime; }
+void BSC::Playlist::setInterpretedOverrideParentBehaviors(bool overrideParentBehaviors) { mOverrideParentBehaviorsI = overrideParentBehaviors; }
+void BSC::Playlist::setInterpretedEmitter(BSC::Playlist::Emitter emitter) { mEmitterI = emitter; }
+
+void BSC::Playlist::addInterpretedEffectBehavior(QString effectBehavior, int index)
+{
+    if(index == -1)
+        mEffectBehaviorsI.append(effectBehavior);
+    else
+        mEffectBehaviorsI.insert(index, effectBehavior);
+}
+void BSC::Playlist::removeInterpretedEffectBehavior(int index) { mEffectBehaviorsI.removeAt(index); }
+void BSC::Playlist::copyInterpretedEffectBehavior(int indexFrom, int indexTo) { mEffectBehaviorsI.insert(indexTo, mEffectBehaviorsI.value(indexFrom)); }
+void BSC::Playlist::moveInterpretedEffectBehavior(int indexFrom, int indexTo) { mEffectBehaviorsI.move(indexFrom, indexTo); }
+void BSC::Playlist::addSoundContainer(SoundContainer container, int index)
+{
+    if(index == -1)
+        mSoundContainers.append(container);
+    else
+        mSoundContainers.insert(index, container);
+}
+void BSC::Playlist::removeSoundContainer(int index) { mSoundContainers.removeAt(index); }
+void BSC::Playlist::copySoundContainer(int indexFrom, int indexTo) { mSoundContainers.insert(indexTo, mSoundContainers.value(indexFrom)); }
+void BSC::Playlist::moveSoundContainer(int indexFrom, int indexTo) { mSoundContainers.move(indexFrom, indexTo); }
+
+void BSC::Playlist::deinterpretData()
+{
+    mPlaybackModeR = enumPBModeToRaw(mPlaybackModeI);
+    mMaxInstancesR = Qx::ByteArray::RAWFromPrimitive(mMaxInstancesI, Qx::Endian::LE);
+    mPolyphonyR = Qx::ByteArray::RAWFromPrimitive(mPolyphonyI, Qx::Endian::LE);
+    mMinRepeatTimeR = Qx::ByteArray::RAWFromPrimitive(mMinRepeatTimeI, Qx::Endian::LE);
+    mMaxRepeatTimeR = Qx::ByteArray::RAWFromPrimitive(mMaxRepeatTimeI, Qx::Endian::LE);
+    mMinRepeatCountR = Qx::ByteArray::RAWFromPrimitive(mMinRepeatCountI, Qx::Endian::LE);
+    mMaxRepeatCountR = Qx::ByteArray::RAWFromPrimitive(mMaxRepeatCountI, Qx::Endian::LE);
+    mRandomPlaylistWeightR = Qx::ByteArray::RAWFromPrimitive(mRandomPlaylistWeightI, Qx::Endian::LE);
+    mLengthR = Qx::ByteArray::RAWFromPrimitive(mLengthI, Qx::Endian::LE);
+    mReleaseTimeR = Qx::ByteArray::RAWFromPrimitive(mReleaseTimeI, Qx::Endian::LE);
+
+    mEffectBehaviorsR.clear();
+    for (int i = 0; i < mEffectBehaviorsI.length(); i++)
+        mEffectBehaviorsR.append(Qx::ByteArray::RAWFromString(mEffectBehaviorsI.value(i)));
+
+    mOverrideParentBehaviorsR = Qx::ByteArray::RAWFromPrimitive(mOverrideParentBehaviorsI);
+    mEmitterR = enumEmitterToRaw(mEmitterI);
+}
+
+QByteArray BSC::Playlist::getRestitchedData()
+{
+    QByteArray stitchedChunk;
+
+    stitchedChunk = Qx::ByteArray::RAWFromPrimitive(mPlaybackModeR.length(), Qx::Endian::LE);
+    stitchedChunk += mPlaybackModeR;
+    stitchedChunk += mMaxInstancesR;
+    stitchedChunk += mPolyphonyR;
+    stitchedChunk += mMinRepeatTimeR;
+    stitchedChunk += mMaxRepeatTimeR;
+    stitchedChunk += mMinRepeatCountR;
+    stitchedChunk += mMaxRepeatCountR;
+    stitchedChunk += mRandomPlaylistWeightR;
+    stitchedChunk += mLengthR;
+    stitchedChunk += mReleaseTimeR;
+    stitchedChunk += Qx::ByteArray::RAWFromPrimitive(mEffectBehaviorsR.length(), Qx::Endian::LE);
+
+    for(int i = 0; i < mEffectBehaviorsR.length(); i++)
+    {
+        stitchedChunk += Qx::ByteArray::RAWFromPrimitive(mEffectBehaviorsR[i].length(), Qx::Endian::LE);
+        stitchedChunk += mEffectBehaviorsR.value(i);
+    }
+
+    stitchedChunk += mOverrideParentBehaviorsR;
+    stitchedChunk += Qx::ByteArray::RAWFromPrimitive(mEmitterR.length(), Qx::Endian::LE);
+    stitchedChunk += mEmitterR;
+    stitchedChunk += Qx::ByteArray::RAWFromPrimitive(mSoundContainers.length(), Qx::Endian::LE);
+
+    for(int i = 0; i < mSoundContainers.length(); i++)
+    {
+        stitchedChunk += Qx::ByteArray::RAWFromPrimitive(i, Qx::Endian::LE);
+        stitchedChunk += mSoundContainers[i].getRestitchedData();
+    }
+
+    stitchedChunk += Qx::ByteArray::RAWFromPrimitive(mSubPlaylists.length(), Qx::Endian::LE);
+
+    for(int i = 0; i < mSubPlaylists.length(); i++)
+    {
+        stitchedChunk += Qx::ByteArray::RAWFromPrimitive(i, Qx::Endian::LE); //Sub-playlist index
+        stitchedChunk += mSubPlaylists[i].getRestitchedData();
+    }
+
+    return stitchedChunk;
+}
+
+//Private:
+void BSC::Playlist::defaultInitialization()
+{
+    // Initialize the only variables needed for a new playlist entry
+
+    mSubPlaylist = false;
+    mPlaybackModeI = BSC::Playlist::PlaybackMode::Normal;
+    mMaxInstancesI = 0;
+    mPolyphonyI = 1;
+    mMinRepeatTimeI = 0;
+    mMaxRepeatTimeI = 0;
+    mMinRepeatCountI = 0;
+    mMaxRepeatCountI = 0;
+    mRandomPlaylistWeightI = 50;
+    mLengthI = 0;
+    mReleaseTimeI = 0;
+    mOverrideParentBehaviorsI = false;
+    mEmitterI = BSC::Playlist::Emitter::None;
+}
+
+void BSC::Playlist::separateData(int &dataCursor, QByteArray &rawData)
+{
+    // Temporary backend only data
+    uint32_t pbModeNameLengthB;
+    uint32_t ebNum;
+    uint32_t ebNameLength;
+    uint32_t emitterNameLength;
+    uint32_t scNum;
+    uint32_t spNum;
+
+    // Data cursor starts on container index (or playback mode name) from parent BSC
+    if(mSubPlaylist)
+    {
+            mPlaylistIndexR =rawData.mid(dataCursor,L_SUB_PL_INDEX);
+        dataCursor += L_SUB_PL_INDEX; // Move to playback mode name length start
+    }
+
+        pbModeNameLengthB = qFromLittleEndian<quint8>(rawData.mid(dataCursor,L_PB_MODE_LEN));
+    dataCursor += L_PB_MODE_LEN; // Move to playback mode name length start
+        mPlaybackModeR = rawData.mid(dataCursor,int(pbModeNameLengthB));
+    dataCursor += pbModeNameLengthB; // Move to max instances start
+        mMaxInstancesR = rawData.mid(dataCursor,L_MAX_INST);
+    dataCursor += L_MAX_INST; // Move to polyphony start
+        mPolyphonyR = rawData.mid(dataCursor,L_POLYHONY);
+    dataCursor += L_POLYHONY; // Move to min repeat time start
+        mMinRepeatTimeR = rawData.mid(dataCursor,L_MIN_RT);
+    dataCursor += L_MIN_RT; // Move to max repeat time start
+        mMaxRepeatTimeR = rawData.mid(dataCursor,L_MAX_RT);
+    dataCursor += L_MAX_RT; // Move to min repeat count start
+        mMinRepeatCountR = rawData.mid(dataCursor,L_MIN_RC);
+    dataCursor += L_MIN_RC; // Move to max repeat count start
+        mMaxRepeatCountR = rawData.mid(dataCursor,L_MAX_RC);
+    dataCursor += L_MAX_RC; // Move to random weight start
+        mRandomPlaylistWeightR = rawData.mid(dataCursor,L_RAND_PLYLST_WEIGHT);
+    dataCursor += L_RAND_PLYLST_WEIGHT; // Move to length start
+        mLengthR = rawData.mid(dataCursor,L_LENGTH);
+    dataCursor += L_LENGTH; // Move to release time start
+        mReleaseTimeR = rawData.mid(dataCursor,L_RELEASE_TIME);
+    dataCursor += L_RELEASE_TIME; // Move to number of effect behaviors
+        ebNum = qFromLittleEndian<quint32>(rawData.mid(dataCursor,L_EFF_BEH_NUM));
+    dataCursor += L_EFF_BEH_NUM; // Move to first effect behavior name length byte
+
+    for(int i = 0; i < int(ebNum); i++)
+    {
+            ebNameLength = qFromLittleEndian<quint32>(rawData.mid(dataCursor,L_EFF_BEH_NAME_LEN));
+        dataCursor += L_EFF_BEH_NAME_LEN; // Move to first character of effect behavior name
+            mEffectBehaviorsR.append(rawData.mid(dataCursor,int(ebNameLength)));
+        dataCursor += ebNameLength; // Move to first byte after name
+    }
+
+        mOverrideParentBehaviorsR = rawData.mid(dataCursor,L_OVERRIDE_PB);
+    dataCursor += L_OVERRIDE_PB; // Move to emitter name length start
+        emitterNameLength = qFromLittleEndian<quint32>(rawData.mid(dataCursor,L_EMITTER_NAME_LEN));
+    dataCursor += L_EMITTER_NAME_LEN; // Move to emitter name start
+        mEmitterR = rawData.mid(dataCursor,int(emitterNameLength));
+    dataCursor += emitterNameLength; // Move to number of sound containers start
+        scNum = qFromLittleEndian<quint32>(rawData.mid(dataCursor,L_SND_CNTR_NUM));
+    dataCursor += L_SND_CNTR_NUM; // Move to first sound container index start
+
+    // Create SoundContainers in order to continue sequential movement of the data cursor
+    for(int i = 0; i < int(scNum); i++)
+        mSoundContainers.append(SoundContainer(dataCursor, rawData, i == int(scNum) - 1));
+
+        spNum = qFromLittleEndian<quint32>(rawData.mid(dataCursor,L_SUB_PLYLST_COUNT));
+    dataCursor += L_SUB_PLYLST_COUNT; // Move to beggining of sub-playlist
+
+    // Create Sub-playlists in order to continue sequential movement of the data cursor
+    for(int i = 0; i < int(spNum); i++)
+        mSubPlaylists.append(Playlist(dataCursor, rawData, true));
+}
+
+void BSC::Playlist::interpretData()
+{
+//    if(mSubPlaylist)
+//        mPlaylistIndexI = qFromLittleEndian<qint32>(mPlaylistIndexR); // Not needed, index can be infered from list index when writing
+    mPlaybackModeI = rawPBModeToEnum(mPlaybackModeR);
+    //mMaxInstancesI = qFromLittleEndian<quint32>(mMaxInstancesR);
+    mMaxInstancesI = Qx::ByteArray::RAWToPrimitive<uint32_t>(mMaxInstancesR, Qx::Endian::LE);
+    mPolyphonyI = qFromLittleEndian<quint32>(mPolyphonyR);
+    mMinRepeatTimeI = qFromLittleEndian<quint32>(mMinRepeatTimeR);
+    mMaxRepeatTimeI = qFromLittleEndian<quint32>(mMaxRepeatTimeR);
+    mMinRepeatCountI = qFromLittleEndian<quint32>(mMinRepeatCountR);
+    mMaxRepeatCountI = qFromLittleEndian<quint32>(mMaxRepeatCountR);
+    mRandomPlaylistWeightI = qFromLittleEndian<quint32>(mRandomPlaylistWeightR);
+    mLengthI = Qx::ByteArray::RAWToPrimitive<float>(mLengthR, Qx::Endian::LE);
+    mReleaseTimeI = Qx::ByteArray::RAWToPrimitive<float>(mLengthR, Qx::Endian::LE);
+
+    for (int i = 0; i < mEffectBehaviorsR.length(); i++)
+        mEffectBehaviorsI.append(mEffectBehaviorsR.value(i));
+
+    mOverrideParentBehaviorsI = Qx::ByteArray::RAWToPrimitive<bool>(mOverrideParentBehaviorsR);
+    mEmitterI = rawEmitterToEnum(mEmitterR);
+}
+
+BSC::Playlist::PlaybackMode BSC::Playlist::rawPBModeToEnum(QByteArray rawPBMode)
+{
+    QString modeName = rawPBMode;
+    int index = PLAYBACK_MODE_STRINGS.indexOf(modeName);
+
+    if(index == -1)
+        return PlaybackMode::Invalid_PBM;
+    else
+        return static_cast<PlaybackMode>(index);
+}
+
+QByteArray BSC::Playlist::enumPBModeToRaw(BSC::Playlist::PlaybackMode enumPBMode) { return Qx::ByteArray::RAWFromString(PLAYBACK_MODE_STRINGS.value(static_cast<int>(enumPBMode))); }
+
+BSC::Playlist::Emitter BSC::Playlist::rawEmitterToEnum(QByteArray rawEmitter)
+{
+    QString emitter = rawEmitter;
+    int index = EMITTER_STRINGS.indexOf(emitter);
+
+    if(index == -1)
+        return Emitter::Invalid_E;
+    else
+        return static_cast<Emitter>(index);
+}
+
+QByteArray BSC::Playlist::enumEmitterToRaw(Emitter enumEmitter) { return Qx::ByteArray::RAWFromString(EMITTER_STRINGS.value(static_cast<int>(enumEmitter))); }
+
+
+//===============================================================================================================
+// SOUND CONTAINER
+//===============================================================================================================
+
+//-Constructor------------------------------------------------------------------------------------------------
+//Public:
+
+BSC::SoundContainer::SoundContainer(int &parentDataCursor, QByteArray &parentRawData, bool lastSCInPL)
+{
+    separateData(parentDataCursor, parentRawData, lastSCInPL);
+    interpretData();
+}
+
+BSC::SoundContainer::SoundContainer()
+{
+    // Initialize the only variables that are needed for a new blank sound container
+    mVoiceGroupFrontI = BSC::SoundContainer::VOICE_GROUP_FRONT_STRINGS.value(0);
+    mVoiceGroupBackI = BSC::SoundContainer::VOICE_GROUP_BACK_STRINGS[0].value(0);
+    mIs3DI = false;
+    mIsLoopedI = false;
+    mUsingSpeedVolumeTriggerI = false;
+    mRandomWeightI = 50;
+    mAmplitudeFactorI = 0;
+    mDopplerRatioI = 0;
+    mPlaybackFrequenceI = 0;
+    mStartI = 0;
+    mEndI = 0;
+    mMaskSampleI = 0;
+    mLinkedFilesI = QStringList();
+    mEffectContainerCountI = 0;
+    mEffectContainerDataI = QString();
+}
+
+//-Instance Functions------------------------------------------------------------------------------------------------
+//Public:
+//int BSC::SoundContainer::getInterpretedContainerIndex() const { return mContainerIndexI; }
+QString BSC::SoundContainer::getInterpretedVoiceGroupFront() const { return mVoiceGroupFrontI; }
+QString BSC::SoundContainer::getInterpretedVoiceGroupBack() const { return mVoiceGroupBackI; }
+bool BSC::SoundContainer::getInterpretedIs3D() const { return mIs3DI; }
+bool BSC::SoundContainer::getInterpretedIsLooped() const { return mIsLoopedI; }
+bool BSC::SoundContainer::getInterpretedUsingSpeedVolumeTrigger() const { return mUsingSpeedVolumeTriggerI; }
+uint32_t BSC::SoundContainer::getInterpretedRandomWeight() const { return mRandomWeightI; }
+float BSC::SoundContainer::getInterpretedAmplitudeFactor() const { return mAmplitudeFactorI; }
+float BSC::SoundContainer::getInterpretedDopplerRatio() const { return mDopplerRatioI; }
+float BSC::SoundContainer::getInterpretedPlaybackFrequence() const { return mPlaybackFrequenceI; }
+float BSC::SoundContainer::getInterpretedStart() const { return mStartI; }
+float BSC::SoundContainer::getInterpretedEnd() const { return mEndI; }
+float BSC::SoundContainer::getInterpretedMaskSample() const { return mMaskSampleI; }
+QStringList BSC::SoundContainer::getInterpretedLinkedFilesV() const { return mLinkedFilesI; }
+QStringList& BSC::SoundContainer::getInterpretedLinkedFilesR() { return mLinkedFilesI; }
+uint32_t BSC::SoundContainer::getInterpretedEffectContainerCount() const { return mEffectContainerCountI; }
+QString BSC::SoundContainer::getInterpretedEffectContainerData() const { return mEffectContainerDataI; }
+bool BSC::SoundContainer::hasLinkedFiles() const { return mLinkedFilesI.length() > 0; }
+int BSC::SoundContainer::linkedFileCount() const { return mLinkedFilesI.length(); }
+
+void BSC::SoundContainer::setInterpretedVoiceGroupFront(QString voiceGroup) { mVoiceGroupFrontI = voiceGroup; }
+void BSC::SoundContainer::setInterpretedVoiceGroupBack(QString voiceGroup) { mVoiceGroupBackI = voiceGroup; }
+void BSC::SoundContainer::setInterpretedIs3D(bool is3D) { mIs3DI = is3D; }
+void BSC::SoundContainer::setInterpretedIsLooped(bool isLopped) { mIsLoopedI = isLopped; }
+void BSC::SoundContainer::setInterpretedUsingSpeedVolumeTrigger(bool usingSpeedVolumeTrigger) { mUsingSpeedVolumeTriggerI = usingSpeedVolumeTrigger; }
+void BSC::SoundContainer::setInterpretedRandomWeight(uint32_t randomWeight) { mRandomWeightI = randomWeight; }
+void BSC::SoundContainer::setInterpretedAmplitudeFactor(float amplitudeFactor) { mAmplitudeFactorI = amplitudeFactor; }
+void BSC::SoundContainer::setInterpretedDopplerRatio(float dopplerRatio) { mDopplerRatioI = dopplerRatio; }
+void BSC::SoundContainer::setInterpretedPlaybackFrequence(float playbackFrequence) { mPlaybackFrequenceI = playbackFrequence; }
+void BSC::SoundContainer::setInterpretedStart(float start) { mStartI = start; }
+void BSC::SoundContainer::setInterpretedEnd(float end) { mEndI = end; }
+void BSC::SoundContainer::setInterpretedMaskSample(float maskSample) { mMaskSampleI = maskSample; }
+void BSC::SoundContainer::setInterpretedEffectContainerCount(uint32_t effectContainerCount) { mEffectContainerCountI = effectContainerCount; }
+void BSC::SoundContainer::setInterpretedEffectContainerData(QString effectContainerData) { mEffectContainerDataI = effectContainerData; }
+
+void BSC::SoundContainer::addInterpretedLinkedFile(QString linkedFile, int index)
+{
+    if(index == -1)
+        mLinkedFilesI.append(linkedFile);
+    else
+        mLinkedFilesI.insert(index, linkedFile);
+}
+void BSC::SoundContainer::removeInterpretedLinkedFile(int index) { mLinkedFilesI.removeAt(index); }
+void BSC::SoundContainer::copyInterpretedLinkedFile(int indexFrom, int indexTo) { mLinkedFilesI.insert(indexTo, mLinkedFilesI.value(indexFrom)); }
+void BSC::SoundContainer::moveInterpretedLinkedFile(int indexFrom, int indexTo) { mLinkedFilesI.move(indexFrom, indexTo); }
+
+void BSC::SoundContainer::deinterpretData()
+{
+    // Voice Group
+    mVoiceGroupR = Qx::ByteArray::RAWFromString((mVoiceGroupFrontI + VOICE_GROU_SEP + mVoiceGroupBackI));
+
+    // Others
+    mIs3DR = Qx::ByteArray::RAWFromPrimitive(mIs3DI);
+    mIsLoopedR = Qx::ByteArray::RAWFromPrimitive(mIsLoopedI);
+    mUsingSpeedVolumeTriggerR = Qx::ByteArray::RAWFromPrimitive(mUsingSpeedVolumeTriggerI);
+    mRandomWeightR = Qx::ByteArray::RAWFromPrimitive(mRandomWeightI, Qx::Endian::LE);
+    mAmplitudeFactorR = Qx::ByteArray::RAWFromPrimitive(mAmplitudeFactorI, Qx::Endian::LE);
+    mDopplerRatioR = Qx::ByteArray::RAWFromPrimitive(mDopplerRatioI, Qx::Endian::LE);
+    mPlaybackFrequenceR = Qx::ByteArray::RAWFromPrimitive(mPlaybackFrequenceI, Qx::Endian::LE);
+    mStartR = Qx::ByteArray::RAWFromPrimitive(mStartI, Qx::Endian::LE);
+    mEndR = Qx::ByteArray::RAWFromPrimitive(mEndI, Qx::Endian::LE);
+    mMaskSampleR = Qx::ByteArray::RAWFromPrimitive(mMaskSampleI, Qx::Endian::LE);
+
+    mLinkedFilesR.clear();
+    for(int i = 0; i < mLinkedFilesI.length(); i++)
+        mLinkedFilesR.append(Qx::ByteArray::RAWFromString(mLinkedFilesI.value(i)));
+
+    mEffectContainerCountR = Qx::ByteArray::RAWFromPrimitive(mEffectContainerCountI, Qx::Endian::LE);
+    mEffectContainerDataR = Qx::ByteArray::RAWFromString(mEffectContainerDataI);
+}
+
+QByteArray BSC::SoundContainer::getRestitchedData()
+{
+    QByteArray stitchedChunk;
+
+    stitchedChunk += Qx::ByteArray::RAWFromPrimitive(mVoiceGroupR.length(), Qx::Endian::LE);
+    stitchedChunk += mVoiceGroupR;
+    stitchedChunk += mIs3DR;
+    stitchedChunk += mIsLoopedR;
+    stitchedChunk += mUsingSpeedVolumeTriggerR;
+    stitchedChunk += mRandomWeightR;
+    stitchedChunk += mAmplitudeFactorR;
+    stitchedChunk += mDopplerRatioR;
+    stitchedChunk += mPlaybackFrequenceR;
+    stitchedChunk += mStartR;
+    stitchedChunk += mEndR;
+    stitchedChunk += mMaskSampleR;
+    stitchedChunk += Qx::ByteArray::RAWFromPrimitive(static_cast<uint8_t>(mLinkedFilesR.length()), Qx::Endian::LE);
+
+    for(int i = 0; i < mLinkedFilesR.length(); i++)
+    {
+        stitchedChunk += Qx::ByteArray::RAWFromPrimitive(mLinkedFilesR[i].length(), Qx::Endian::LE);
+        stitchedChunk += mLinkedFilesR.value(i);
+    }
+
+    stitchedChunk += mEffectContainerCountR;
+
+    if(mEffectContainerCountI > 0)
+        stitchedChunk += mEffectContainerDataR;
+
+    return stitchedChunk;
+}
+
+//Private:
+void BSC::SoundContainer::separateData(int &dataCursor, QByteArray &rawData, bool lastSCInPL)
+{
+    // Temporary backend only data
+    int vgNameLength;
+    int lfNum;
+    int lfNameLength;
+
+    // Data cursor starts on container index from parent playlist
+        mContainerIndexR = rawData.mid(dataCursor,L_CNTR_INDEX);
+    dataCursor += L_CNTR_INDEX; // Move to voice group name length start
+        vgNameLength = qFromLittleEndian<qint32>(rawData.mid(dataCursor,L_VOICE_GRP_NAM_LEN));
+    dataCursor += L_VOICE_GRP_NAM_LEN; // Move to voice group name start
+        mVoiceGroupR = rawData.mid(dataCursor,vgNameLength);
+    dataCursor += vgNameLength; // Move to is 3d start
+        mIs3DR = rawData.mid(dataCursor,L_IS_3D);
+    dataCursor += L_IS_3D; // Move to is looped start
+        mIsLoopedR = rawData.mid(dataCursor,L_IS_LOOPED);
+    dataCursor += L_IS_LOOPED; // Move to using speed/volume trigger start
+        mUsingSpeedVolumeTriggerR = rawData.mid(dataCursor,L_USE_SV_TRIG);
+    dataCursor += L_USE_SV_TRIG; // Move to random weight start
+        mRandomWeightR = rawData.mid(dataCursor,L_RAND_WEIGHT);
+    dataCursor += L_RAND_WEIGHT; // Move to amplitude factor start
+        mAmplitudeFactorR = rawData.mid(dataCursor,L_AMP_FACTOR);
+    dataCursor += L_AMP_FACTOR; // Move to doppler ratio start
+        mDopplerRatioR = rawData.mid(dataCursor,L_DOP_RATIO);
+    dataCursor += L_DOP_RATIO; // Move to playback frequence start
+        mPlaybackFrequenceR = rawData.mid(dataCursor,L_PLAY_FREQ);
+    dataCursor += L_PLAY_FREQ; // Move to start start
+        mStartR = rawData.mid(dataCursor,L_START);
+    dataCursor += L_START; // Move to end start
+        mEndR = rawData.mid(dataCursor,L_END);
+    dataCursor += L_END; // Move to mask sample start;
+        mMaskSampleR = rawData.mid(dataCursor,L_MSK_SAMP);
+    dataCursor += L_MSK_SAMP; // Move to number of linked file num start
+        lfNum = qFromLittleEndian<qint8>(rawData.mid(dataCursor,L_LNKD_FILE_NUM));
+    dataCursor += L_LNKD_FILE_NUM; // Move to first linked file name length byte
+
+    for(int i = 0; i < lfNum; i++)
+    {
+            lfNameLength = qFromLittleEndian<qint32>(rawData.mid(dataCursor,L_LNKD_FILE_NAM_LEN));
+        dataCursor += L_LNKD_FILE_NAM_LEN; // Move to first character of linked file name
+            mLinkedFilesR.append(rawData.mid(dataCursor,lfNameLength));
+        dataCursor += lfNameLength; // Move to first byte after name
+    }
+
+        mEffectContainerCountR = rawData.mid(dataCursor,L_EFF_CONT_NUM);
+    dataCursor += L_EFF_CONT_NUM; // Move to next byte after effect container number
+
+    // Import raw effect contianer data if present
+    if(qFromLittleEndian<quint32>(mEffectContainerCountR) > 0)
+    {
+        int effectContainerEnd;
+
+        // Get effect container data based on next sound container OR next playlist or EOF
+        if(!lastSCInPL)
+            effectContainerEnd = findEffectContainerEndMidSC(rawData, dataCursor);
+        else
+            effectContainerEnd = findEffectContainerEndLastSC(rawData, dataCursor);
+
+        mEffectContainerDataR = rawData.mid(dataCursor, Qx::rangeToLength(dataCursor, effectContainerEnd));
+
+        // Move cursor to next sound container
+        dataCursor = effectContainerEnd + 1;
+    }
+}
+
+void BSC::SoundContainer::interpretData()
+{
+    // mContainerIndexI = qFromLittleEndian<qint32>(mContainerIndexR); // Not needed, index can be infered from list index when writing
+
+    // Voice Group
+    QString wholeString = Qx::String::fromByteArray(mVoiceGroupR);
+    int sepPos = wholeString.indexOf(VOICE_GROU_SEP);
+    mVoiceGroupFrontI = wholeString.left(sepPos);
+    mVoiceGroupBackI = wholeString.mid(sepPos + VOICE_GROU_SEP.length());
+
+    // Others
+    mIs3DI = Qx::ByteArray::RAWToPrimitive<bool>(mIs3DR);
+    mIsLoopedI = Qx::ByteArray::RAWToPrimitive<bool>(mIsLoopedR);
+    mUsingSpeedVolumeTriggerI = Qx::ByteArray::RAWToPrimitive<bool>(mIsLoopedR);
+    mRandomWeightI = qFromLittleEndian<quint32>(mRandomWeightR);
+    mAmplitudeFactorI = Qx::ByteArray::RAWToPrimitive<float>(mAmplitudeFactorR, Qx::Endian::LE);
+    mDopplerRatioI = Qx::ByteArray::RAWToPrimitive<float>(mDopplerRatioR, Qx::Endian::LE);
+    mPlaybackFrequenceI = Qx::ByteArray::RAWToPrimitive<float>(mPlaybackFrequenceR, Qx::Endian::LE);
+    mStartI = Qx::ByteArray::RAWToPrimitive<float>(mStartR, Qx::Endian::LE);
+    mEndI = Qx::ByteArray::RAWToPrimitive<float>(mEndR, Qx::Endian::LE);
+    mMaskSampleI = Qx::ByteArray::RAWToPrimitive<float>(mMaskSampleR, Qx::Endian::LE);
+
+    for (int i = 0; i < mLinkedFilesR.length(); i++)
+        mLinkedFilesI.append(mLinkedFilesR.value(i));
+
+    mEffectContainerCountI = qFromLittleEndian<quint32>(mEffectContainerCountR);
+    mEffectContainerDataI = Qx::String::fromByteArray(mEffectContainerDataR);
+}
+
+BSC::SoundContainer::ReasonableSCType BSC::SoundContainer::determineReasonableSCDataType(QByteArray rawVal)
+{
+    assert(rawVal.size() == 4); // Data must be 32-bit (4 bytes)
+    uint32_t dataAsInt = qFromLittleEndian<quint32>(rawVal);
+
+    if(dataAsInt <= BSC::SoundContainer::RES_SC_INT_CUTOFF)
+        return RES_INT;
+    else
+        return RES_FLOAT;
+}
+
+int BSC::SoundContainer::findEffectContainerEndMidSC(QByteArray &fullData, int startOffset)
+{
+    QVector<int> voiceGroupHits;
+
+    // Search for next sound container by finding the next voice group
+    for(int i = 0; i < BSC::SoundContainer::VOICE_GROUP_FRONT_STRINGS.length(); i++)
+        voiceGroupHits.append(fullData.indexOf(BSC::SoundContainer::VOICE_GROUP_FRONT_STRINGS.value(i),startOffset));
+
+    // Remove misses
+    voiceGroupHits.removeAll(-1);
+
+    assert(!voiceGroupHits.isEmpty()); // If no voice group is found this function shouldn't have been called
+
+    int firstIndex = *std::min_element(voiceGroupHits.begin(), voiceGroupHits.end()); // Iterates over vector using std::iterator and dereferences the index pointer to get value
+
+    // Walk backwards to get effect container end
+    return firstIndex - L_VOICE_GRP_NAM_LEN - L_CNTR_INDEX - 0x01;
+}
+
+int BSC::SoundContainer::findEffectContainerEndLastSC(QByteArray &fullData, int startOffset)
+{
+    QVector<int> modeNameHits;
+
+    // Search for next playlist by finding the next voice group
+    for(int i = 0; i < BSC::Playlist::PLAYBACK_MODE_STRINGS.length(); i++)
+        modeNameHits.append(fullData.indexOf(BSC::Playlist::PLAYBACK_MODE_STRINGS.value(i),startOffset));
+
+    // Remove misses
+    modeNameHits.removeAll(-1);
+
+    int firstIndex = *std::min_element(modeNameHits.begin(), modeNameHits.end()); // Iterates over vector using std::iterator and dereferences the index pointer to get value
+
+    // All Possible Situations:
+    // Situation A - End of playlist that has sub playlists
+    // Situation B - End of playlist that has no sub playlists, sub playlist is next
+    // Situation C - End of playlist that has no sub playlists, top level playlist is next
+    // Situation D - End of any playlist that has no sub playlists and is last playlist
+
+
+    // Determine the current situation and calculate effect container end from there
+    if(modeNameHits.isEmpty()) // No Mode Name Found = Situation D
+        return (fullData.length() - 0x01) - BSC::Playlist::L_SUB_PLYLST_COUNT;
+    else
+    {
+        // Walk back to first byte of mode name length
+        int modeNameLengthOffset = firstIndex - BSC::Playlist::L_PB_MODE_LEN;
+
+        // Get the two values before playback mode name length (luckily all involved values are exactly 4 bytes long)
+        QByteArray prevVal = fullData.mid(firstIndex - BSC::Playlist::L_PB_MODE_LEN - 0x04, 0x04);
+        QByteArray secondPrevVal = fullData.mid(firstIndex - BSC::Playlist::L_PB_MODE_LEN - 0x08, 0x04);
+
+        if(qFromLittleEndian<quint32>(prevVal) == 0x00)
+        {
+           if(determineReasonableSCDataType(secondPrevVal) == RES_INT && qFromLittleEndian<quint32>(secondPrevVal) > 0x00) // Situation A
+               return modeNameLengthOffset - BSC::Playlist::L_SUB_PL_INDEX - BSC::Playlist::L_SUB_PLYLST_COUNT - 0x01; // Extra -1 to go to end of EC from start of sub-playlist count
+           else // Situation C
+               return modeNameLengthOffset - BSC::Playlist::L_SUB_PLYLST_COUNT - 0x01; // Extra -1 to go to end of EC from start of sub-playlist count
+        }
+        else // Situation B
+            return modeNameLengthOffset - BSC::Playlist::L_SUB_PL_INDEX - BSC::Playlist::L_SUB_PLYLST_COUNT - 0x01; // Extra -1 to go to end of EC from start of sub-playlist count
+    }
+}
+
+
diff --git a/src/bsc.h b/src/bsc.h
new file mode 100644
index 0000000..93aa313
--- /dev/null
+++ b/src/bsc.h
@@ -0,0 +1,404 @@
+#ifndef BSC_H
+#define BSC_H
+#include <QByteArray>
+#include <QFile>
+#include <QStringList>
+#include "qx.h"
+#include "qx-io.h"
+
+class BSC
+{
+//-Inner Class Forward Declarations---------------------------------------------------------------------------------------
+public:
+    class Playlist;
+    class SoundContainer;
+
+//-Class Variables
+public:
+    static inline const QString FILE_EXT = "bsc";
+    static inline const QChar TWEENER_BYTE_SEP = ' ';
+    static inline const QString EA_SHARK_SIG = "easb";
+    static inline const QString BSC_SIG = "sbhs";
+
+    static inline const QString TWEENER_DEFAULT = "00" + QString(TWEENER_BYTE_SEP) + "00" + QString(TWEENER_BYTE_SEP) + "00"
+                                                + QString(TWEENER_BYTE_SEP) + "00" + QString(TWEENER_BYTE_SEP) + "00";
+    static const uint32_t FORMAT_TAG_DEFAULT = 14;
+    static const uint8_t PLAYLIST_COUNT_DEFAULT = 0;
+
+    static const int L_FORMAT_TAG_1 = 0x04; // easb
+    static const int L_FORMAT_TAG_2 = 0x04; // sbhs
+    static const int L_TWEENER = 0x05;
+    static const int L_FORMAT_VER = 0x04;
+    static const int L_PLAYLIST_COUNT = 0x01;
+
+//-Instance Variables--------------------------------------------------------------------------------------------
+private:
+    // Raw Index Cursor
+    int mDataCursor;
+
+    // Full Data
+    QByteArray mFileDataF;
+
+    // Segmented Raw Data
+    QByteArray mTweenerR;
+    QByteArray mFormatVerR;
+    QByteArray mPlaylistCountR;
+
+    // Segmented Interpreted Data
+    QString mTweenerI;
+    uint32_t mFormatVerI;
+    uint8_t mPlaylistCountI;
+
+    // Segmented Sub-section Data
+    QList<Playlist> mPlaylists;
+
+//-Constructor-------------------------------------------------------------------------------------------------
+public:
+    BSC(QByteArray rawData);
+    BSC();
+
+//-Class Functions------------------------------------------------------------------------------------------------------
+public:
+    static bool fileIsValidBSC(QFile& possibleBSC, Qx::IO::IOOpReport& reportBuffer);
+
+private:
+
+//-Instance Functions---------------------------------------------------------------------------------------------------
+public:
+    QString getInterpretedTweener() const;
+    uint32_t getInterpretedFormatVer() const;
+    uint8_t getInterpretedPlayListCount() const;
+    QList<Playlist> getPlaylistsV() const;
+    QList<Playlist>& getPlaylistsR();
+    bool hasPlaylists() const;
+    int playlistCount() const;
+    int totalPlaylistCount();
+
+    void addInterpretedEffectBehavior(QString effectBehavior, int index = -1);
+    void removeInterpretedEffectBehavior(int index);
+    void copyInterpretedEffectBehavior(int indexFrom, int indexTo);
+    void moveInterpretedEffectBehavior(int indexFrom, int indexTo);
+
+    QByteArray rebuildRawFile();
+
+private:
+    void separateData();
+    void interpretData();
+    void deinterpretData();
+    int recursiveSubPlaylistCounter(BSC::Playlist& parentPlaylist);
+
+//-Inner Classes---------------------------------------------------------------------------------------
+public:
+
+    class Playlist
+    {
+        //-Class Types------------------------------------------------------------------------------------------------------
+        public:
+            enum PlaybackMode {Normal, Random, RandomPlaylist, Sequential, Invalid_PBM};
+            enum Emitter {None, AlliedArtilleryTinitus, Arty_Tinitus, Authie_Planes, Bergetiger_Recovery, BigGun, BuildingAwareness, Causeway_Marsh,
+                          Causeway_Music_Mixer, Decoy_Arty_Fire, DLC_BC_Mute, DLC_M02_Tiger_Mute, DLC_SP_Rulz, DLC_Tiger_Fire, DLC_Tiger_Trouble,
+                          DLC_Under_Fire, DLC_VBB_Tiger_Mute, Engine_Rev_Gate, M01_MG42Volume, M01_SurfVolume, M02_GunsVolume, M02_InlandVolume,
+                          OceanWater, P47_shot_down, RainSurface_Canvas, RainSurface_Cement, RainSurface_Foliage, RainSurface_Metal, RainSurface_Shingle,
+                          RainSurface_Stone, RainSurface_Tin, RainSurface_Vehicle, RainSurface_Water, RainSurface_Wood, ReverbLarge, ReverbMedium, SFXRadio,
+                          SFXRadio_Combat, SIR_Field, SIR_Forest, SIR_Narrow, SIR_Wide, SP_MP_overlap_control, StingerDuck, TankMixer, Tank_BG_radio, Tank_Shock,
+                          Tiger_Radio_Fuzz, Tiger_Reload,Tinitus, TownVerb, UltraDecryption_Unmute, Vehicle_Gear_Shift, Vehicle_Rev, WaterCanal, Weapons,
+                          Invalid_E};
+
+        //-Class Variables
+        public:
+            static inline const QStringList PLAYBACK_MODE_STRINGS {"Normal", "Random", "RandomPlaylist", "Sequential"};
+            static inline const QStringList MAX_INSTANCES_STRINGS {"Infinite", "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine", "Ten"};
+            static inline const QStringList POLYPHONY_STRINGS {"One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine", "Ten"};
+            static inline const QStringList EMITTER_STRINGS {"<none>", "AlliedArtilleryTinitus", "Arty_Tinitus", "Authie_Planes", "Bergetiger_Recovery", "BigGun",
+                                                            "BuildingAwareness", "Causeway_Marsh", "Causeway_Music_Mixer", "Decoy_Arty_Fire", "DLC_BC_Mute",
+                                                            "DLC_M02_Tiger_Mute", "DLC_SP_Rulz", "DLC_Tiger_Fire", "DLC_Tiger_Trouble", "DLC_Under_Fire",
+                                                            "DLC_VBB_Tiger_Mute", "Engine_Rev_Gate", "M01_MG42Volume", "M01_SurfVolume", "M02_GunsVolume",
+                                                            "M02_InlandVolume", "OceanWater", "P47_shot_down", "RainSurface_Canvas", "RainSurface_Cement",
+                                                            "RainSurface_Foliage", "RainSurface_Metal", "RainSurface_Shingle", "RainSurface_Stone", "RainSurface_Tin",
+                                                            "RainSurface_Vehicle", "RainSurface_Water", "RainSurface_Wood", "ReverbLarge", "ReverbMedium", "SFXRadio",
+                                                            "SFXRadio_Combat", "SIR_Field", "SIR_Forest", "SIR_Narrow", "SIR_Wide", "SP_MP_overlap_control",
+                                                            "StingerDuck", "TankMixer", "Tank_BG_radio", "Tank_Shock", "Tiger_Radio_Fuzz", "Tiger_Reload,Tinitus",
+                                                            "TownVerb", "UltraDecryption_Unmute", "Vehicle_Gear_Shift", "Vehicle_Rev", "WaterCanal", "Weapons"};
+
+            static inline const QString EFFECT_BEHAVIOR_DEFAULT = "[NEW EFFECT BEHAVIOR]";
+            static inline const QString PLAYLIST_INDEX_SEP = " - ";
+            static inline const QString ROOT_INDEX_LABEL = "Root Playlist" + PLAYLIST_INDEX_SEP + "%1"; // Cannot be changed without changing PlaylistItemMap!
+            static inline const QString SUB_INDEX_LABEL = "Sub-Playlist" + PLAYLIST_INDEX_SEP + "%1"; // Cannot be changed without changing PlaylistItemMap!
+            static inline const QString SUB_INDEX_LABEL_SEP = ":";
+
+            static const int L_SUB_PL_INDEX = 0x04;
+            static const int L_PB_MODE_LEN = 0x04;
+            static const int L_MAX_INST = 0x04;
+            static const int L_POLYHONY = 0x04;
+            static const int L_MIN_RT = 0x04;
+            static const int L_MAX_RT = 0x04;
+            static const int L_MIN_RC = 0x04;
+            static const int L_MAX_RC = 0x04;
+            static const int L_RAND_PLYLST_WEIGHT = 0x04;
+            static const int L_LENGTH = 0x04;
+            static const int L_RELEASE_TIME = 0x04;
+            static const int L_EFF_BEH_NUM = 0x04;
+            static const int L_EFF_BEH_NAME_LEN = 0x04;
+            static const int L_OVERRIDE_PB = 0x01;
+            static const int L_EMITTER_NAME_LEN = 0x04;
+            static const int L_SND_CNTR_NUM = 0x04;
+            static const int L_SUB_PLYLST_COUNT = 0x04;
+
+        //-Instance Variables--------------------------------------------------------------------------------------------
+        private:
+            // UI Flags For QTreeWidget
+            bool mInitiallyExpandedInTree = false;
+
+            // Instance details
+            bool mSubPlaylist;
+
+            // Segmented Raw Data
+            QByteArray mPlaylistIndexR; // Only used for sub-playlists
+            QByteArray mPlaybackModeR;
+            QByteArray mMaxInstancesR;
+            QByteArray mPolyphonyR;
+            QByteArray mMinRepeatTimeR;
+            QByteArray mMaxRepeatTimeR;
+            QByteArray mMinRepeatCountR;
+            QByteArray mMaxRepeatCountR;
+            QByteArray mRandomPlaylistWeightR; // May only be present for Random Playlist mode
+            QByteArray mLengthR;
+            QByteArray mReleaseTimeR;
+            QByteArrayList mEffectBehaviorsR;
+            QByteArray mOverrideParentBehaviorsR;
+            QByteArray mEmitterR;
+
+            // Segmented Interpreted Data
+            //int mPlaylistIndexI; // Not needed, index can be infered from list index when writing
+            PlaybackMode mPlaybackModeI;
+            uint32_t mMaxInstancesI;
+            uint32_t mPolyphonyI;
+            uint32_t mMinRepeatTimeI;
+            uint32_t mMaxRepeatTimeI;
+            uint32_t mMinRepeatCountI;
+            uint32_t mMaxRepeatCountI;
+            uint32_t mRandomPlaylistWeightI; // May only be present for Random Playlist mode
+            float mLengthI;
+            float mReleaseTimeI;
+            QStringList mEffectBehaviorsI;
+            bool mOverrideParentBehaviorsI;
+            Emitter mEmitterI;
+
+            // Segmented Sub-section Data
+            QList<SoundContainer> mSoundContainers;
+            QList<Playlist> mSubPlaylists;
+
+        //-Constructor-------------------------------------------------------------------------------------------------
+        public:
+            Playlist(int &parentDataCursor, QByteArray &parentRawData, bool subPlaylist);
+            Playlist(bool subPlaylist);
+            Playlist();
+
+        //-Class Functions------------------------------------------------------------------------------------------------------
+        public:
+
+        //-Instance Functions---------------------------------------------------------------------------------------------------
+        public:
+            bool getInitialTreeExpansion() const;
+            PlaybackMode getInterpretedPlaybackMode() const;
+            uint32_t getInterpretedMaxInstances() const;
+            uint32_t getInterpretedPolyphony() const;
+            uint32_t getInterpretedMinRepeatTime() const;
+            uint32_t getInterpretedMaxRepeatTime() const;
+            uint32_t getInterpretedMinRepeatCount() const;
+            uint32_t getInterpretedMaxRepeatCount() const;
+            uint32_t getInterpretedRandomPlaylistWeight() const;
+            float getInterpretedLength() const;
+            float getInterpretedReleaseTime() const;
+            QStringList getInterpretedEffectBehaviorsV() const;
+            QStringList& getInterpretedEffectBehaviorsR();
+            bool getInterpretedOverrideParentBehaviors() const;
+            Emitter getInterpretedEmitter() const;
+            QList<SoundContainer> getSoundContainersV() const;
+            QList<SoundContainer>& getSoundContainersR();
+            QList<Playlist> getSubPlaylistsV() const;
+            QList<Playlist>& getSubPlaylistsR();
+            bool hasSoundContainers() const;
+            bool hasSubPlaylists() const;
+            bool hasEffectBehaviors() const;
+            int soundContainerCount() const;
+            int subPlaylistCount() const;
+            int effectBehaviorCount() const;
+
+            void setInitialTreeExpansion(bool expanded);
+            void setInterpretedPlaybackMode(PlaybackMode playbackMode);
+            void setInterpretedMaxInstances(uint32_t maxInstances);
+            void setInterpretedPolyphony(uint32_t polphony);
+            void setInterpretedMinRepeatTime(uint32_t minRepeatTime);
+            void setInterpretedMaxRepeatTime(uint32_t maxRepeatTime);
+            void setInterpretedMinRepeatCount(uint32_t minRpeatCount);
+            void setInterpretedMaxRepeatCount(uint32_t maxRepeatCount);
+            void setInterpretedRandomPlaylistWeight(uint32_t randomPlaylistWeight);
+            void setInterpretedLength(float length);
+            void setInterpretedReleaseTime(float releaseTime);
+            void setInterpretedOverrideParentBehaviors(bool overrideParentBehaviors);
+            void setInterpretedEmitter(Emitter emitter);
+
+            void addInterpretedEffectBehavior(QString effectBehavior, int index = -1);
+            void removeInterpretedEffectBehavior(int index);
+            void copyInterpretedEffectBehavior(int indexFrom, int indexTo);
+            void moveInterpretedEffectBehavior(int indexFrom, int indexTo);
+            void addSoundContainer(SoundContainer container, int index = -1);
+            void removeSoundContainer(int index);
+            void copySoundContainer(int indexFrom, int indexTo);
+            void moveSoundContainer(int indexFrom, int indexTo);
+
+            void deinterpretData();
+            QByteArray getRestitchedData();
+
+        private:
+            void defaultInitialization();
+            void separateData(int &dataCursor, QByteArray &rawData);
+            void interpretData();
+            PlaybackMode rawPBModeToEnum(QByteArray rawPBMode);
+            QByteArray enumPBModeToRaw(PlaybackMode enumPBMode);
+            Emitter rawEmitterToEnum(QByteArray rawEmitter);
+            QByteArray enumEmitterToRaw(Emitter enumEmitter);
+    };
+
+
+    class SoundContainer
+    {
+    //-Class Types------------------------------------------------------------------------------------------------------
+    public:
+        enum ReasonableSCType { RES_INT, RES_FLOAT };
+
+    //-Class Variables
+    public:
+        static inline const QStringList VOICE_GROUP_FRONT_STRINGS {"Default", "Ambience", "Foley", "Hits", "Vehicles", "Weapon"};
+        static inline const QList<QStringList> VOICE_GROUP_BACK_STRINGS
+        {
+            {"Default"},
+            {"Ambience_Hi", "Ambience_Lo"},
+            {"BuildingFoley", "Footfalls", "GunFoley", "SpecialFX", "VehicleFoley"},
+            {"BigHits", "Explosions", "LittleHits", "MediumHits"},
+            {"Engines", "Engines_LoPriority", "FOWEngines", "VehicleDestroys"},
+            {"MGBelts", "MGsHeavy", "MGsSmall", "WeaponsHeavy", "WeaponsMedium", "WeaponsSmall"}
+        };
+
+        static inline const QString LINKED_FILE_DEFAULT = "[NEW FILE LINK]";
+        static inline const QString INDEX_LABEL = "Container - %1";
+
+        static inline const QString VOICE_GROU_SEP = "::";
+
+        static const int RES_SC_INT_CUTOFF = 0xFF; // 16-bit limit - Int: 65,535 Float: 9.18340948595269E-41 // Extremely high for an int in the context of this program,
+                                                   // but extremely low for a float in the context of this program, so this is a good dividing line
+
+        static const int L_CNTR_INDEX = 0x04;
+        static const int L_VOICE_GRP_NAM_LEN = 0x04;
+        static const int L_IS_3D = 0x01;
+        static const int L_IS_LOOPED = 0x01;
+        static const int L_USE_SV_TRIG = 0x01;
+        static const int L_RAND_WEIGHT = 0x04;
+        static const int L_AMP_FACTOR = 0x04;
+        static const int L_DOP_RATIO = 0x04;
+        static const int L_PLAY_FREQ = 0x04;
+        static const int L_START = 0x04;
+        static const int L_END = 0x04;
+        static const int L_MSK_SAMP = 0x04;
+        static const int L_LNKD_FILE_NUM = 0x01;
+        static const int L_LNKD_FILE_NAM_LEN = 0x04;
+        static const int L_EFF_CONT_NUM = 0x04;
+
+    //-Instance Variables--------------------------------------------------------------------------------------------
+    private:
+        // Segmented Raw Data
+        QByteArray mContainerIndexR;
+        QByteArray mVoiceGroupR;
+        QByteArray mIs3DR;
+        QByteArray mIsLoopedR;
+        QByteArray mUsingSpeedVolumeTriggerR;
+        QByteArray mRandomWeightR;
+        QByteArray mAmplitudeFactorR;
+        QByteArray mDopplerRatioR;
+        QByteArray mPlaybackFrequenceR;
+        QByteArray mStartR;
+        QByteArray mEndR;
+        QByteArray mMaskSampleR;
+        QByteArrayList mLinkedFilesR;
+        QByteArray mEffectContainerCountR;
+        QByteArray mEffectContainerDataR;
+
+        // Segmented Interpreted Data
+        // int mContainerIndexI; // Not needed, index can be infered from list index when writing
+        QString mVoiceGroupFrontI;
+        QString mVoiceGroupBackI;
+        bool mIs3DI;
+        bool mIsLoopedI;
+        bool mUsingSpeedVolumeTriggerI;
+        uint32_t mRandomWeightI;
+        float mAmplitudeFactorI;
+        float mDopplerRatioI;
+        float mPlaybackFrequenceI;
+        float mStartI;
+        float mEndI;
+        float mMaskSampleI;
+        QStringList mLinkedFilesI;
+        uint32_t mEffectContainerCountI;
+        QString mEffectContainerDataI;
+
+    //-Constructor-------------------------------------------------------------------------------------------------
+    public:
+        SoundContainer(int &parentDataCursor, QByteArray &parentRawData, bool lastSCInPL);
+        SoundContainer();
+
+    //-Instance Functions---------------------------------------------------------------------------------------------------
+    public:
+        //int getInterpretedContainerIndex() const; // Not needed, index can be infered from list index when writing
+        QString getInterpretedVoiceGroupFront() const;
+        QString getInterpretedVoiceGroupBack() const;
+        bool getInterpretedIs3D() const;
+        bool getInterpretedIsLooped() const;
+        bool getInterpretedUsingSpeedVolumeTrigger() const;
+        uint32_t getInterpretedRandomWeight() const;
+        float getInterpretedAmplitudeFactor() const;
+        float getInterpretedDopplerRatio() const;
+        float getInterpretedPlaybackFrequence() const;
+        float getInterpretedStart() const;
+        float getInterpretedEnd() const;
+        float getInterpretedMaskSample() const;
+        QStringList getInterpretedLinkedFilesV() const;
+        QStringList& getInterpretedLinkedFilesR();
+        uint32_t getInterpretedEffectContainerCount() const;
+        QString getInterpretedEffectContainerData() const;
+        bool hasLinkedFiles() const;
+        int linkedFileCount() const;
+
+        void setInterpretedVoiceGroupFront(QString voiceGroup);
+        void setInterpretedVoiceGroupBack(QString voiceGroup);
+        void setInterpretedIs3D(bool is3D);
+        void setInterpretedIsLooped(bool isLopped);
+        void setInterpretedUsingSpeedVolumeTrigger(bool usingSpeedVolumeTrigger);
+        void setInterpretedRandomWeight(uint32_t randomWeight);
+        void setInterpretedAmplitudeFactor(float amplitudeFactor);
+        void setInterpretedDopplerRatio(float dopplerRatio);
+        void setInterpretedPlaybackFrequence(float playbackFrequence);
+        void setInterpretedStart(float start);
+        void setInterpretedEnd(float end);
+        void setInterpretedMaskSample(float maskSample);
+        void setInterpretedEffectContainerCount(uint32_t effectContainerCount);
+        void setInterpretedEffectContainerData(QString effectContainerData);
+
+        void addInterpretedLinkedFile(QString linkedFile, int index = -1);
+        void removeInterpretedLinkedFile(int index);
+        void copyInterpretedLinkedFile(int indexFrom, int indexTo);
+        void moveInterpretedLinkedFile(int indexFrom, int indexTo);
+
+        void deinterpretData();
+        QByteArray getRestitchedData();
+
+    private:
+        void separateData(int &dataCursor, QByteArray &rawData, bool lastSCInPL);
+        void interpretData();
+        ReasonableSCType determineReasonableSCDataType(QByteArray rawVal);
+        int findEffectContainerEndMidSC(QByteArray &fullData, int startOffset);
+        int findEffectContainerEndLastSC(QByteArray &fullData, int startOffset);
+    };
+};
+
+#endif // BSC_H
diff --git a/src/main.cpp b/src/main.cpp
new file mode 100644
index 0000000..8c53efd
--- /dev/null
+++ b/src/main.cpp
@@ -0,0 +1,12 @@
+#include "mainwindow.h"
+#include <QApplication>
+#include <QDebug>
+
+int main(int argc, char *argv[])
+{
+    QApplication a(argc, argv);
+    MainWindow w;
+    w.show();
+
+    return a.exec();
+}
diff --git a/src/mainwindow.cpp b/src/mainwindow.cpp
new file mode 100644
index 0000000..7d22d57
--- /dev/null
+++ b/src/mainwindow.cpp
@@ -0,0 +1,2448 @@
+#include "mainwindow.h"
+#include "ui_mainwindow.h"
+#include <QMessageBox>
+#include <QtEndian>
+#include <QDebug>
+#include <QScrollBar>
+#include <QFileDialog>
+#include <QStatusBar>
+#include <QProgressDialog>
+#include <QMimeData>
+
+//===============================================================================================================
+// MAIN WINDOW
+//===============================================================================================================
+
+//-Constructor---------------------------------------------------------------------------------------------------
+MainWindow::MainWindow(QWidget *parent) :
+    QMainWindow(parent),
+    ui(new Ui::MainWindow)
+{
+    // Initialize UI
+    ui->setupUi(this);
+    QApplication::setApplicationName(VER_PRODUCTNAME_STR);
+    setWindowTitle(VER_PRODUCTNAME_STR);
+    setAcceptDrops(true);
+    initializeForms();
+    initializeWidgetEnableConditionMap();
+    initializeEnableWidgetGroups();
+    mSlotsEnabled = true;
+}
+
+//-Destructor----------------------------------------------------------------------------------------------------
+MainWindow::~MainWindow() { delete ui; }
+
+//-Instance Functions--------------------------------------------------------------------------------------------
+//Private:
+void MainWindow::initializeForms()
+{
+    // Populate constant input widget data
+    ui->comboBox_playbackMode->addItems(BSC::Playlist::PLAYBACK_MODE_STRINGS);
+    //ui->comboBox_playbackMode->setLayoutDirection(Qt::RightToLeft);
+    ui->comboBox_maxInst->addItems(BSC::Playlist::MAX_INSTANCES_STRINGS);
+    ui->comboBox_poly->addItems(BSC::Playlist::POLYPHONY_STRINGS);
+    ui->comboBox_emitter->addItems(BSC::Playlist::EMITTER_STRINGS);
+    ui->treeWidget_playlists->setSelectionMode(QAbstractItemView::SelectionMode::SingleSelection);
+    ui->comboBox_voiceGroupFront->addItems(BSC::SoundContainer::VOICE_GROUP_FRONT_STRINGS);
+    ui->lineEdit_effectContainerCount->setValidator( new QIntValidator(0, 999, ui->lineEdit_effectContainerCount) ); // Limit count line edit to numbers only
+    ui->treeWidget_playlists->setColumnCount(1);
+
+    // Link plain text scroll bars
+    connect(ui->plainTextEdit_effectContainerDataRaw->verticalScrollBar(), &QScrollBar::sliderMoved,
+            ui->plainTextEdit_effectContainerDataString->verticalScrollBar(), &QScrollBar::setValue);
+    connect(ui->plainTextEdit_effectContainerDataString->verticalScrollBar(), &QScrollBar::sliderMoved,
+            ui->plainTextEdit_effectContainerDataRaw->verticalScrollBar(), &QScrollBar::setValue);
+
+    // Set table properties
+    ui->tableWidget_linkedFiles->setColumnCount(1);
+    ui->tableWidget_linkedFiles->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
+
+    // Disable window resizing
+    this->setFixedSize(QSize(this->width(), this->height()));
+    this->setMaximumSize(QSize(this->width(), this->height()));
+    this->setMinimumSize(QSize(this->width(), this->height()));
+    this->setWindowFlags(this->windowFlags() | Qt::MSWindowsFixedSizeDialogHint); // Forces resize grip to not show (WINDOWS DEPENDENT)
+
+    // Install event filter for QPlainTextEdito
+    ui->plainTextEdit_effectContainerDataRaw->installEventFilter(this);
+
+    // Initially hide widgets
+    updatePrimaryWidgetStates();
+}
+
+void MainWindow::initializeWidgetEnableConditionMap()
+{
+    // Populate hashmap of ui element enable conditions
+    mWidgetEnableConditionMap.insert(ui->checkBox_3D, [&]()->bool{ return mBSCPtr->hasPlaylists() && getSelectedPlaylist()->hasSoundContainers();});
+    mWidgetEnableConditionMap.insert(ui->checkBox_loop, [&]()->bool{ return mBSCPtr->hasPlaylists() && getSelectedPlaylist()->hasSoundContainers();});
+    mWidgetEnableConditionMap.insert(ui->checkBox_speedVolumeTrigger, [&]()->bool{ return mBSCPtr->hasPlaylists() && getSelectedPlaylist()->hasSoundContainers();});
+    mWidgetEnableConditionMap.insert(ui->checkBox_effectContainerDataEdit, [&]()->bool{ return mBSCPtr->hasPlaylists() && getSelectedPlaylist()->hasSoundContainers();});
+    mWidgetEnableConditionMap.insert(ui->checkBox_parentBehaviorOverride, [&]()->bool{ return mBSCPtr->hasPlaylists();});
+    mWidgetEnableConditionMap.insert(ui->comboBox_emitter, [&]()->bool{ return mBSCPtr->hasPlaylists();});
+    mWidgetEnableConditionMap.insert(ui->comboBox_maxInst, [&]()->bool{ return mBSCPtr->hasPlaylists();});
+    mWidgetEnableConditionMap.insert(ui->comboBox_playbackMode, [&]()->bool{ return mBSCPtr->hasPlaylists();});
+    mWidgetEnableConditionMap.insert(ui->comboBox_poly, [&]()->bool{ return mBSCPtr->hasPlaylists();});
+    mWidgetEnableConditionMap.insert(ui->comboBox_soundContainer, [&]()->bool{ return mBSCPtr->hasPlaylists() && getSelectedPlaylist()->hasSoundContainers();});
+    mWidgetEnableConditionMap.insert(ui->comboBox_voiceGroupFront, [&]()->bool{ return mBSCPtr->hasPlaylists() && getSelectedPlaylist()->hasSoundContainers();});
+    mWidgetEnableConditionMap.insert(ui->comboBox_voiceGroupBack, [&]()->bool{ return mBSCPtr->hasPlaylists() && getSelectedPlaylist()->hasSoundContainers();});
+    mWidgetEnableConditionMap.insert(ui->doubleSpinBox_amplitudeFactor, [&]()->bool{ return mBSCPtr->hasPlaylists() && getSelectedPlaylist()->hasSoundContainers();});
+    mWidgetEnableConditionMap.insert(ui->doubleSpinBox_dopplerRatio, [&]()->bool{ return mBSCPtr->hasPlaylists() && getSelectedPlaylist()->hasSoundContainers();});
+    mWidgetEnableConditionMap.insert(ui->doubleSpinBox_end, [&]()->bool{ return mBSCPtr->hasPlaylists() && getSelectedPlaylist()->hasSoundContainers();});
+    mWidgetEnableConditionMap.insert(ui->doubleSpinBox_length, [&]()->bool{ return mBSCPtr->hasPlaylists();});
+    mWidgetEnableConditionMap.insert(ui->doubleSpinBox_maskSample, [&]()->bool{ return mBSCPtr->hasPlaylists() && getSelectedPlaylist()->hasSoundContainers();});
+    mWidgetEnableConditionMap.insert(ui->doubleSpinBox_playbackFrequence, [&]()->bool{ return mBSCPtr->hasPlaylists() && getSelectedPlaylist()->hasSoundContainers();});
+    mWidgetEnableConditionMap.insert(ui->doubleSpinBox_releaseTime, [&]()->bool{ return mBSCPtr->hasPlaylists();});
+    mWidgetEnableConditionMap.insert(ui->doubleSpinBox_start, [&]()->bool{ return mBSCPtr->hasPlaylists() && getSelectedPlaylist()->hasSoundContainers();});
+    mWidgetEnableConditionMap.insert(ui->lineEdit_tweener, [&]()->bool{ return true;});
+    mWidgetEnableConditionMap.insert(ui->lineEdit_formatVer, [&]()->bool{ return true;});
+    mWidgetEnableConditionMap.insert(ui->lineEdit_playlistCount, [&]()->bool{ return true;});
+    mWidgetEnableConditionMap.insert(ui->lineEdit_effectContainerCount, [&]()->bool{ return mBSCPtr->hasPlaylists() && getSelectedPlaylist()->hasSoundContainers();});
+    mWidgetEnableConditionMap.insert(ui->plainTextEdit_effectContainerDataRaw, [&]()->bool{ return (mBSCPtr->hasPlaylists() && getSelectedPlaylist()->hasSoundContainers() &&
+                                                                                            getSelectedSoundContainer()->getInterpretedEffectContainerCount() > 0);});
+    mWidgetEnableConditionMap.insert(ui->plainTextEdit_effectContainerDataString, [&]()->bool{ return (mBSCPtr->hasPlaylists() && getSelectedPlaylist()->hasSoundContainers() &&
+                                                                                               getSelectedSoundContainer()->getInterpretedEffectContainerCount() > 0);});
+    mWidgetEnableConditionMap.insert(ui->spinBox_randomPlaylistWeight, [&]()->bool{ return mBSCPtr->hasPlaylists();});
+    mWidgetEnableConditionMap.insert(ui->spinBox_randomWeight, [&]()->bool{ return mBSCPtr->hasPlaylists() && getSelectedPlaylist()->hasSoundContainers();});
+    mWidgetEnableConditionMap.insert(ui->spinBox_repeatCountMax, [&]()->bool{ return mBSCPtr->hasPlaylists();});
+    mWidgetEnableConditionMap.insert(ui->spinBox_repeatCountMin, [&]()->bool{ return mBSCPtr->hasPlaylists();});
+    mWidgetEnableConditionMap.insert(ui->spinBox_repeatTimeMax, [&]()->bool{ return mBSCPtr->hasPlaylists();});
+    mWidgetEnableConditionMap.insert(ui->spinBox_repeatTimeMin, [&]()->bool{ return mBSCPtr->hasPlaylists();});
+    mWidgetEnableConditionMap.insert(ui->tableWidget_effectBehaviors, [&]()->bool{ return mBSCPtr->hasPlaylists()  && getSelectedPlaylist()->hasEffectBehaviors();});
+    mWidgetEnableConditionMap.insert(ui->tableWidget_linkedFiles, [&]()->bool{ return mBSCPtr->hasPlaylists() && getSelectedPlaylist()->hasSoundContainers() &&
+                                                                               getSelectedSoundContainer()->hasLinkedFiles();});
+    mWidgetEnableConditionMap.insert(ui->toolButton_effectBehaviorsAdd, [&]()->bool{ return mBSCPtr->hasPlaylists();});
+    mWidgetEnableConditionMap.insert(ui->toolButton_effectBehaviorsCopy, [&]()->bool{ return mBSCPtr->hasPlaylists() && getSelectedPlaylist()->hasEffectBehaviors() &&
+                                                                                      ui->tableWidget_effectBehaviors->currentRow() > -1;});
+    mWidgetEnableConditionMap.insert(ui->toolButton_effectBehaviorsDown, [&]()->bool{ return mBSCPtr->hasPlaylists() && getSelectedPlaylist()->hasEffectBehaviors() &&
+                                                                                      ui->tableWidget_effectBehaviors->currentRow() > -1 &&
+                                                                                      ui->tableWidget_effectBehaviors->currentRow() < getSelectedPlaylist()->effectBehaviorCount() - 1;});
+    mWidgetEnableConditionMap.insert(ui->toolButton_effectBehaviorsRemove, [&]()->bool{ return mBSCPtr->hasPlaylists() && getSelectedPlaylist()->hasEffectBehaviors() &&
+                                                                                        ui->tableWidget_effectBehaviors->currentRow() > -1;});
+    mWidgetEnableConditionMap.insert(ui->toolButton_effectBehaviorsUp, [&]()->bool{ return mBSCPtr->hasPlaylists() && getSelectedPlaylist()->hasEffectBehaviors() &&
+                                                                                    ui->tableWidget_effectBehaviors->currentRow() > 0;});
+    mWidgetEnableConditionMap.insert(ui->toolButton_linkedFilesAdd, [&]()->bool{ return mBSCPtr->hasPlaylists() && getSelectedPlaylist()->hasSoundContainers();});
+    mWidgetEnableConditionMap.insert(ui->toolButton_linkedFilesCopy, [&]()->bool{ return mBSCPtr->hasPlaylists() && getSelectedPlaylist()->hasSoundContainers() &&
+                                                                                  getSelectedSoundContainer()->hasLinkedFiles() &&
+                                                                                   ui->tableWidget_linkedFiles->currentRow() > -1;});
+    mWidgetEnableConditionMap.insert(ui->toolButton_linkedFilesDown, [&]()->bool{ return mBSCPtr->hasPlaylists() && getSelectedPlaylist()->hasSoundContainers() &&
+                                                                                  getSelectedSoundContainer()->hasLinkedFiles() &&
+                                                                                  ui->tableWidget_linkedFiles->currentRow() > -1 &&
+                                                                                  ui->tableWidget_linkedFiles->currentRow() < getSelectedSoundContainer()->linkedFileCount() - 1;});
+    mWidgetEnableConditionMap.insert(ui->toolButton_linkedFilesRemove, [&]()->bool{ return mBSCPtr->hasPlaylists() && getSelectedPlaylist()->hasSoundContainers() &&
+                                                                                    getSelectedSoundContainer()->hasLinkedFiles() &&
+                                                                                    ui->tableWidget_linkedFiles->currentRow() > -1;});
+    mWidgetEnableConditionMap.insert(ui->toolButton_linkedFilesUp, [&]()->bool{ return mBSCPtr->hasPlaylists() && getSelectedPlaylist()->hasSoundContainers() &&
+                                                                                getSelectedSoundContainer()->hasLinkedFiles() &&
+                                                                                ui->tableWidget_linkedFiles->currentRow() > 0;});
+    mWidgetEnableConditionMap.insert(ui->toolButton_playlistsAdd, [&]()->bool{ return true;});
+    mWidgetEnableConditionMap.insert(ui->toolButton_playlistsCopy, [&]()->bool{ return mBSCPtr->hasPlaylists() && ui->treeWidget_playlists->currentItem() != nullptr;});
+    mWidgetEnableConditionMap.insert(ui->toolButton_playlistsDown, [&]()->bool{ return mBSCPtr->hasPlaylists() && ui->treeWidget_playlists->currentItem() != nullptr &&
+                                                                                PlaylistItemMap(ui->treeWidget_playlists->currentItem(), mBSCPtr.get()).getTargetIndex() <
+                                                                                PlaylistItemMap(ui->treeWidget_playlists->currentItem(), mBSCPtr.get()).getTargetPlaylistList()->length() - 1;});
+    mWidgetEnableConditionMap.insert(ui->toolButton_playlistsIn, [&]()->bool{ return mBSCPtr->hasPlaylists() && ui->treeWidget_playlists->currentItem() != nullptr &&
+                                                                              PlaylistItemMap(ui->treeWidget_playlists->currentItem(), mBSCPtr.get()).getTargetIndex() > 0;});
+    mWidgetEnableConditionMap.insert(ui->toolButton_playlistsOut, [&]()->bool{ return mBSCPtr->hasPlaylists() && ui->treeWidget_playlists->currentItem() != nullptr &&
+                                                                               !PlaylistItemMap(ui->treeWidget_playlists->currentItem(), mBSCPtr.get()).targetIsTopLevel();});
+    mWidgetEnableConditionMap.insert(ui->toolButton_playlistsRemove, [&]()->bool{ return mBSCPtr->hasPlaylists() && ui->treeWidget_playlists->currentItem() != nullptr;});
+    mWidgetEnableConditionMap.insert(ui->toolButton_playlistsUp, [&]()->bool{ return mBSCPtr->hasPlaylists() && ui->treeWidget_playlists->currentItem() != nullptr &&
+                                                                              PlaylistItemMap(ui->treeWidget_playlists->currentItem(), mBSCPtr.get()).getTargetIndex() > 0;});
+    mWidgetEnableConditionMap.insert(ui->toolButton_soundContainerAdd, [&]()->bool{ return mBSCPtr->hasPlaylists();});
+    mWidgetEnableConditionMap.insert(ui->toolButton_soundContainerCopy, [&]()->bool{ return mBSCPtr->hasPlaylists() && getSelectedPlaylist()->hasSoundContainers() &&
+                                                                                     ui->comboBox_soundContainer->currentIndex() > -1;});
+    mWidgetEnableConditionMap.insert(ui->toolButton_soundContainerDown, [&]()->bool{ return mBSCPtr->hasPlaylists() && getSelectedPlaylist()->hasSoundContainers() &&
+                                                                                     ui->comboBox_soundContainer->currentIndex() > -1 &&
+                                                                                     ui->comboBox_soundContainer->currentIndex() < getSelectedPlaylist()->soundContainerCount() - 1;});
+    mWidgetEnableConditionMap.insert(ui->toolButton_soundContainerRemove, [&]()->bool{ return mBSCPtr->hasPlaylists() && getSelectedPlaylist()->hasSoundContainers() &&
+                                                                                       ui->comboBox_soundContainer->currentIndex() > -1;});
+    mWidgetEnableConditionMap.insert(ui->toolButton_soundContainerUp, [&]()->bool{ return mBSCPtr->hasPlaylists() && getSelectedPlaylist()->hasSoundContainers() &&
+                                                                                   ui->comboBox_soundContainer->currentIndex() > 0;});
+    mWidgetEnableConditionMap.insert(ui->treeWidget_playlists, [&]()->bool{ return mBSCPtr->hasPlaylists();});
+    mWidgetEnableConditionMap.insert(ui->label_voiceGroup, [&]()->bool{ return mBSCPtr->hasPlaylists() && getSelectedPlaylist()->hasSoundContainers();});
+    mWidgetEnableConditionMap.insert(ui->label_voiceGroupSep, [&]()->bool{ return mBSCPtr->hasPlaylists() && getSelectedPlaylist()->hasSoundContainers();});
+    mWidgetEnableConditionMap.insert(ui->label_randomWeight, [&]()->bool{ return mBSCPtr->hasPlaylists() && getSelectedPlaylist()->hasSoundContainers();});
+    mWidgetEnableConditionMap.insert(ui->label_amplitudeFactor, [&]()->bool{ return mBSCPtr->hasPlaylists() && getSelectedPlaylist()->hasSoundContainers();});
+    mWidgetEnableConditionMap.insert(ui->label_start, [&]()->bool{ return mBSCPtr->hasPlaylists() && getSelectedPlaylist()->hasSoundContainers();});
+    mWidgetEnableConditionMap.insert(ui->label_playbackFrequence, [&]()->bool{ return mBSCPtr->hasPlaylists() && getSelectedPlaylist()->hasSoundContainers();});
+    mWidgetEnableConditionMap.insert(ui->label_dopplerRatio, [&]()->bool{ return mBSCPtr->hasPlaylists() && getSelectedPlaylist()->hasSoundContainers();});
+    mWidgetEnableConditionMap.insert(ui->label_end, [&]()->bool{ return mBSCPtr->hasPlaylists() && getSelectedPlaylist()->hasSoundContainers();});
+    mWidgetEnableConditionMap.insert(ui->label_maskSample, [&]()->bool{ return mBSCPtr->hasPlaylists() && getSelectedPlaylist()->hasSoundContainers();});
+    mWidgetEnableConditionMap.insert(ui->label_effectContainerCount, [&]()->bool{ return mBSCPtr->hasPlaylists() && getSelectedPlaylist()->hasSoundContainers();});
+    mWidgetEnableConditionMap.insert(ui->label_linkedFiles, [&]()->bool{ return mBSCPtr->hasPlaylists() && getSelectedPlaylist()->hasSoundContainers() &&
+                                                                         getSelectedSoundContainer()->hasLinkedFiles();});
+    mWidgetEnableConditionMap.insert(ui->label_effectContainerDataRaw, [&]()->bool{ return (mBSCPtr->hasPlaylists() && getSelectedPlaylist()->hasSoundContainers() &&
+                                                                                    getSelectedSoundContainer()->getInterpretedEffectContainerCount() > 0);});
+    mWidgetEnableConditionMap.insert(ui->label_effectContainerDataString, [&]()->bool{ return (mBSCPtr->hasPlaylists() && getSelectedPlaylist()->hasSoundContainers() &&
+                                                                                       getSelectedSoundContainer()->getInterpretedEffectContainerCount() > 0);});
+}
+
+void MainWindow::initializeEnableWidgetGroups()
+{
+    mEnableGroupTopLevel.append(ui->lineEdit_tweener);
+    mEnableGroupTopLevel.append(ui->lineEdit_formatVer);
+    mEnableGroupTopLevel.append(ui->lineEdit_playlistCount);
+
+    mEnableGroupPlaylistSel.append(ui->treeWidget_playlists);
+    mEnableGroupPlaylistSel.append(ui->toolButton_playlistsAdd);
+    mEnableGroupPlaylistSel.append(ui->toolButton_playlistsRemove);
+    mEnableGroupPlaylistSel.append(ui->toolButton_playlistsCopy);
+    mEnableGroupPlaylistSel.append(ui->toolButton_playlistsOut);
+    mEnableGroupPlaylistSel.append(ui->toolButton_playlistsIn);
+    mEnableGroupPlaylistSel.append(ui->toolButton_playlistsUp);
+    mEnableGroupPlaylistSel.append(ui->toolButton_playlistsDown);
+
+    mEnableGroupPlaylistSet.append(ui->comboBox_playbackMode);
+    mEnableGroupPlaylistSet.append(ui->comboBox_maxInst);
+    mEnableGroupPlaylistSet.append(ui->comboBox_poly);
+    mEnableGroupPlaylistSet.append(ui->spinBox_repeatTimeMin);
+    mEnableGroupPlaylistSet.append(ui->spinBox_repeatTimeMax);
+    mEnableGroupPlaylistSet.append(ui->spinBox_repeatCountMin);
+    mEnableGroupPlaylistSet.append(ui->spinBox_repeatCountMax);
+    mEnableGroupPlaylistSet.append(ui->spinBox_randomPlaylistWeight);
+    mEnableGroupPlaylistSet.append(ui->doubleSpinBox_length);
+    mEnableGroupPlaylistSet.append(ui->doubleSpinBox_releaseTime);
+
+    mEnableGroupEffectBeh.append(ui->tableWidget_effectBehaviors);
+    mEnableGroupEffectBeh.append(ui->toolButton_effectBehaviorsAdd);
+    mEnableGroupEffectBeh.append(ui->toolButton_effectBehaviorsRemove);
+    mEnableGroupEffectBeh.append(ui->toolButton_effectBehaviorsCopy);
+    mEnableGroupEffectBeh.append(ui->toolButton_effectBehaviorsUp);
+    mEnableGroupEffectBeh.append(ui->toolButton_effectBehaviorsDown);
+    mEnableGroupEffectBeh.append(ui->checkBox_parentBehaviorOverride);
+    mEnableGroupEffectBeh.append(ui->comboBox_emitter);
+
+    mEnableGroupSoundCon.append(ui->comboBox_soundContainer);
+    mEnableGroupSoundCon.append(ui->toolButton_soundContainerAdd);
+    mEnableGroupSoundCon.append(ui->toolButton_soundContainerRemove);
+    mEnableGroupSoundCon.append(ui->toolButton_soundContainerCopy);
+    mEnableGroupSoundCon.append(ui->toolButton_soundContainerUp);
+    mEnableGroupSoundCon.append(ui->toolButton_soundContainerDown);
+    mEnableGroupSoundCon.append(ui->comboBox_voiceGroupFront);
+    mEnableGroupSoundCon.append(ui->comboBox_voiceGroupBack);
+    mEnableGroupSoundCon.append(ui->checkBox_3D);
+    mEnableGroupSoundCon.append(ui->checkBox_loop);
+    mEnableGroupSoundCon.append(ui->checkBox_speedVolumeTrigger);
+    mEnableGroupSoundCon.append(ui->spinBox_randomWeight);
+    mEnableGroupSoundCon.append(ui->doubleSpinBox_amplitudeFactor);
+    mEnableGroupSoundCon.append(ui->doubleSpinBox_dopplerRatio);
+    mEnableGroupSoundCon.append(ui->doubleSpinBox_start);
+    mEnableGroupSoundCon.append(ui->doubleSpinBox_end);
+    mEnableGroupSoundCon.append(ui->doubleSpinBox_playbackFrequence);
+    mEnableGroupSoundCon.append(ui->doubleSpinBox_maskSample);
+    mEnableGroupSoundCon.append(ui->lineEdit_effectContainerCount);
+    mEnableGroupSoundCon.append(ui->checkBox_effectContainerDataEdit);
+    mEnableGroupSoundCon.append(ui->tableWidget_linkedFiles);
+    mEnableGroupSoundCon.append(ui->toolButton_linkedFilesAdd);
+    mEnableGroupSoundCon.append(ui->toolButton_linkedFilesRemove);
+    mEnableGroupSoundCon.append(ui->toolButton_linkedFilesCopy);
+    mEnableGroupSoundCon.append(ui->toolButton_linkedFilesUp);
+    mEnableGroupSoundCon.append(ui->toolButton_linkedFilesDown);
+    mEnableGroupSoundCon.append(ui->plainTextEdit_effectContainerDataRaw);
+    mEnableGroupSoundCon.append(ui->plainTextEdit_effectContainerDataString);
+
+    mEnableGroupSoundCon.append(ui->label_voiceGroup);
+    mEnableGroupSoundCon.append(ui->label_voiceGroupSep);
+    mEnableGroupSoundCon.append(ui->label_randomWeight);
+    mEnableGroupSoundCon.append(ui->label_amplitudeFactor);
+    mEnableGroupSoundCon.append(ui->label_start);
+    mEnableGroupSoundCon.append(ui->label_playbackFrequence);
+    mEnableGroupSoundCon.append(ui->label_dopplerRatio);
+    mEnableGroupSoundCon.append(ui->toolButton_linkedFilesUp);
+    mEnableGroupSoundCon.append(ui->label_end);
+    mEnableGroupSoundCon.append(ui->label_maskSample);
+    mEnableGroupSoundCon.append(ui->label_effectContainerCount);
+    mEnableGroupSoundCon.append(ui->label_linkedFiles);
+    mEnableGroupSoundCon.append(ui->label_effectContainerDataRaw);
+    mEnableGroupSoundCon.append(ui->label_effectContainerDataString);
+}
+
+void MainWindow::updatePrimaryWidgetStates()
+{
+    if(mFileOpen)
+    {
+        // Reveal everything and hide instructions
+        QList<QGroupBox*> allUIGroups = ui->centralWidget->findChildren<QGroupBox*>();
+        for(QGroupBox* gb : allUIGroups)
+            gb->show();
+
+        ui->label_instructions->hide();
+
+        // Enable all file menu actions that had been disabled
+        if(!mAllChangesSaved)
+            ui->actionSave->setEnabled(true);
+        ui->actionSave_As->setEnabled(true);
+        ui->actionClose->setEnabled(true);
+    }
+    else
+    {
+        // Hide everything except for the start instructions
+        QList<QGroupBox*> allUIGroups = ui->centralWidget->findChildren<QGroupBox*>();
+        for(QGroupBox* gb : allUIGroups)
+            gb->hide();
+
+        ui->label_instructions->show();
+
+        // Disable all file menu options except for New, Open, and Exit
+        ui->actionSave->setEnabled(false);
+        ui->actionSave_As->setEnabled(false);
+        ui->actionClose->setEnabled(false);
+    }
+}
+
+void MainWindow::updateSecondaryWidgetStates(QWidgetList widgetsToUpdate)
+{
+    for(QWidget* currentWidget : widgetsToUpdate)
+        currentWidget->setEnabled(mWidgetEnableConditionMap.value(currentWidget)());
+}
+
+void MainWindow::recursivePlaylistEnumerator(QTreeWidgetItem* parentTreeItem, BSC::Playlist &parentPlaylist, QString parentIndexMarker)
+{
+    for (int i = 0; i < parentPlaylist.getSubPlaylistsV().length(); i++)
+    {
+        // Update root index marker
+        QString childIndexMarker = parentIndexMarker + BSC::Playlist::SUB_INDEX_LABEL_SEP + QString::number(i);
+
+        // Create and configure child item
+        QTreeWidgetItem* childTreeItem = new QTreeWidgetItem;
+        childTreeItem->setText(0, BSC::Playlist::SUB_INDEX_LABEL.arg(childIndexMarker));
+
+        // Restore enable state
+        childTreeItem->setExpanded(parentPlaylist.getSubPlaylistsV()[i].getInitialTreeExpansion());
+
+        // Add child to parent
+        parentTreeItem->addChild(childTreeItem);
+
+        // Process any children of this child playlist
+        recursivePlaylistEnumerator(childTreeItem, parentPlaylist.getSubPlaylistsR()[i], childIndexMarker);
+    }
+}
+
+void MainWindow::updateBSCTopLevel()
+{
+    // Tweener
+    ui->lineEdit_tweener->setText(mBSCPtr->getInterpretedTweener());
+
+    // Format Version
+    ui->lineEdit_formatVer->setText(QString::number(mBSCPtr->getInterpretedFormatVer()));
+
+    // Playlist Count
+    ui->lineEdit_playlistCount->setText(QString::number(mBSCPtr->getInterpretedPlayListCount()));
+
+    // Playlist Select
+    updatePlaylists();
+}
+
+void MainWindow::updatePlaylists()
+{
+    // Clear playlist tree
+    mSlotsEnabled = false;
+    ui->treeWidget_playlists->clear();
+    mSlotsEnabled = true;
+
+    // Populate playlist tree
+
+    for(int i = 0; i < mBSCPtr->getInterpretedPlayListCount(); i++)
+    {
+        // Create root item
+        QTreeWidgetItem* rootTreeItem = new QTreeWidgetItem(ui->treeWidget_playlists);
+
+        // Create Initial Index Marker
+        QString rootIndexMarker = QString::number(i);
+
+        // Set root item details
+        rootTreeItem->setText(0, BSC::Playlist::ROOT_INDEX_LABEL.arg(rootIndexMarker));
+
+        // Restore enable state
+        rootTreeItem->setExpanded(mBSCPtr->getPlaylistsV()[i].getInitialTreeExpansion());
+
+        // Process sub-playlists
+        recursivePlaylistEnumerator(rootTreeItem, mBSCPtr->getPlaylistsR()[i], rootIndexMarker);
+    }
+
+    updateSecondaryWidgetStates(mEnableGroupTopLevel + mEnableGroupPlaylistSel);
+}
+
+void MainWindow::updateEntirePlaylist()
+{
+   if(mBSCPtr->hasPlaylists())
+   {
+       // Refill combo boxes if thery were previously cleared
+       if(ui->comboBox_playbackMode->count() == 0)
+           ui->comboBox_playbackMode->addItems(BSC::Playlist::PLAYBACK_MODE_STRINGS);
+       if(ui->comboBox_maxInst->count() == 0)
+           ui->comboBox_maxInst->addItems(BSC::Playlist::MAX_INSTANCES_STRINGS);
+       if(ui->comboBox_poly->count() == 0)
+           ui->comboBox_poly->addItems(BSC::Playlist::POLYPHONY_STRINGS);
+       if(ui->comboBox_emitter->count() == 0)
+           ui->comboBox_emitter->addItems(BSC::Playlist::EMITTER_STRINGS);
+
+       // Playback Mode
+       ui->comboBox_playbackMode->setCurrentIndex(static_cast<int>(getSelectedPlaylist()->getInterpretedPlaybackMode()));
+
+       // Max Instances
+       ui->comboBox_maxInst->setCurrentIndex(int(getSelectedPlaylist()->getInterpretedMaxInstances()));
+
+       // Polyphony
+       ui->comboBox_poly->setCurrentIndex(int(getSelectedPlaylist()->getInterpretedPolyphony() - 1)); // Index 0 is "One" so need to subtract 1 to get correct index
+
+       // Integer Spinner Data
+       ui->spinBox_repeatTimeMin->setValue(int(getSelectedPlaylist()->getInterpretedMinRepeatTime()));
+       ui->spinBox_repeatTimeMax->setValue(int(getSelectedPlaylist()->getInterpretedMaxRepeatTime()));
+       ui->spinBox_repeatCountMin->setValue(int(getSelectedPlaylist()->getInterpretedMinRepeatCount()));
+       ui->spinBox_repeatCountMax->setValue(int(getSelectedPlaylist()->getInterpretedMaxRepeatTime()));
+       ui->spinBox_randomPlaylistWeight->setValue(int(getSelectedPlaylist()->getInterpretedRandomPlaylistWeight()));
+
+       // Double Spinner Data
+       ui->doubleSpinBox_length->setValue(double(getSelectedPlaylist()->getInterpretedLength()));
+       ui->doubleSpinBox_releaseTime->setValue(double(getSelectedPlaylist()->getInterpretedReleaseTime()));
+
+       // Effect Behaviors
+       updateEffectBehaviors();
+       ui->checkBox_parentBehaviorOverride->setChecked(getSelectedPlaylist()->getInterpretedOverrideParentBehaviors());
+       ui->comboBox_emitter->setCurrentIndex(static_cast<int>(getSelectedPlaylist()->getInterpretedEmitter()));
+
+   }
+   else
+   {
+       // Clear
+       mSlotsEnabled = false;
+       ui->comboBox_playbackMode->clear();
+       ui->comboBox_maxInst->clear();
+       ui->comboBox_poly->clear();
+       ui->spinBox_repeatTimeMin->clear();
+       ui->spinBox_repeatTimeMax->clear();
+       ui->spinBox_repeatCountMin->clear();
+       ui->spinBox_repeatCountMax->clear();
+       ui->spinBox_randomPlaylistWeight->clear();
+       ui->doubleSpinBox_length->clear();
+       ui->doubleSpinBox_releaseTime->clear();
+       ui->checkBox_parentBehaviorOverride->setChecked(false);
+       ui->comboBox_emitter->clear();
+       updateEffectBehaviors();
+       mSlotsEnabled = false;
+   }
+
+    //  Sound Containers
+    updateSoundContainers();
+    ui->comboBox_soundContainer->setCurrentIndex(0); // Pre-select first container (comboBox slot SHOULD handle calling updateSoundContainerGroup()
+    updateSoundContainerGroup(); // Combo box signal "currentIndexChanged" is not emitted if the index did not actually change which means that by the
+                                 // the time the above line fires the index is already set to 0 and therefore it may be unecessary. Additionally, this
+                                 // means that "updateSoundContainerGroup" is not called since the corresponding slot isn't triggered either so it must
+                                 // be called manually here.
+
+    // Update widget states
+    updateSecondaryWidgetStates(mEnableGroupPlaylistSet + mEnableGroupEffectBeh + mEnableGroupSoundCon);
+}
+
+void MainWindow::updateEffectBehaviors()
+{
+    //Clear table widget
+    ui->tableWidget_effectBehaviors->clear();
+
+    if(mBSCPtr->hasPlaylists())
+    {
+        ui->tableWidget_effectBehaviors->setRowCount(getSelectedPlaylist()->getInterpretedEffectBehaviorsV().length());
+
+        for(int i = 0; i < getSelectedPlaylist()->getInterpretedEffectBehaviorsV().length(); i++)
+        {
+            QTableWidgetItem *effectBehaviorItem = new QTableWidgetItem(getSelectedPlaylist()->getInterpretedEffectBehaviorsR()[i]);
+            ui->tableWidget_effectBehaviors->setItem(i,0, effectBehaviorItem);
+        }
+    }
+    else
+        ui->tableWidget_effectBehaviors->setRowCount(0);
+}
+
+void MainWindow::updateSoundContainers()
+{
+    mAlteringSoundContainerBoxEntries = true; // Prevents out of bounds exception due to "comboBox_currentIndexChanged" getting called from "addItem"
+                                              // since the sound group combo box index isn't set till after this function completes
+
+    // Clear combo box
+    ui->comboBox_soundContainer->clear();
+
+    if(mBSCPtr->hasPlaylists())
+    {
+        // Update combo box
+        for(int i = 0; i < getSelectedPlaylist()->soundContainerCount(); i++)
+            ui->comboBox_soundContainer->addItem(BSC::SoundContainer::INDEX_LABEL.arg(i));
+    }
+
+    mAlteringSoundContainerBoxEntries = false;
+}
+
+void MainWindow::updateSoundContainerGroup()
+{
+    if(mBSCPtr->hasPlaylists() && getSelectedPlaylist()->hasSoundContainers())
+    {
+        // Voice Group
+        int frontIndex = BSC::SoundContainer::VOICE_GROUP_FRONT_STRINGS.indexOf(getSelectedSoundContainer()->getInterpretedVoiceGroupFront());
+
+        // Refill front combo box if it was previously cleared
+        if(ui->comboBox_voiceGroupFront->count() == 0)
+            ui->comboBox_voiceGroupFront->addItems(BSC::SoundContainer::VOICE_GROUP_FRONT_STRINGS);
+
+        ui->comboBox_voiceGroupFront->setCurrentIndex(frontIndex);
+        updateVoiceGroupBack(frontIndex);
+
+        // Effect Containers
+        ui->lineEdit_effectContainerCount->setText(QString::number(getSelectedSoundContainer()->getInterpretedEffectContainerCount()));
+        ui->checkBox_effectContainerDataEdit->setChecked(false);
+
+        bool slotsEnabled = mSlotsEnabled;
+        mSlotsEnabled = false;
+        if(getSelectedSoundContainer()->getInterpretedEffectContainerCount() > 0)
+        {
+            ui->plainTextEdit_effectContainerDataRaw->setPlainText(Qx::String::fromByteArrayHex(
+                                                                   Qx::ByteArray::RAWFromString(getSelectedSoundContainer()->getInterpretedEffectContainerData()))
+                                                                   .toUpper());
+            ui->plainTextEdit_effectContainerDataString->setPlainText(getSelectedSoundContainer()->getInterpretedEffectContainerData());
+        }
+        else
+        {
+            ui->plainTextEdit_effectContainerDataRaw->clear();
+            ui->plainTextEdit_effectContainerDataString->clear();
+        }
+        mSlotsEnabled = slotsEnabled;
+
+        // Others
+        ui->checkBox_3D->setChecked(getSelectedSoundContainer()->getInterpretedIs3D());
+        ui->checkBox_loop->setChecked(getSelectedSoundContainer()->getInterpretedIsLooped());
+        ui->checkBox_speedVolumeTrigger->setChecked(getSelectedSoundContainer()->getInterpretedUsingSpeedVolumeTrigger());
+        ui->spinBox_randomWeight->setValue(int(getSelectedSoundContainer()->getInterpretedRandomWeight()));
+        ui->doubleSpinBox_amplitudeFactor->setValue(double(getSelectedSoundContainer()->getInterpretedAmplitudeFactor()));
+        ui->doubleSpinBox_dopplerRatio->setValue(double(getSelectedSoundContainer()->getInterpretedDopplerRatio()));
+        ui->doubleSpinBox_playbackFrequence->setValue(double(getSelectedSoundContainer()->getInterpretedPlaybackFrequence()));
+        ui->doubleSpinBox_start->setValue(double(getSelectedSoundContainer()->getInterpretedStart()));
+        ui->doubleSpinBox_end->setValue(double(getSelectedSoundContainer()->getInterpretedEnd()));
+        ui->doubleSpinBox_maskSample->setValue(double(getSelectedSoundContainer()->getInterpretedMaskSample()));
+    }
+    else
+    {
+        // Clear all widgets
+        mSlotsEnabled = false;
+        ui->comboBox_voiceGroupFront->clear();
+        ui->comboBox_voiceGroupBack->clear();
+        ui->lineEdit_effectContainerCount->clear();
+        ui->checkBox_effectContainerDataEdit->setChecked(false);
+        ui->plainTextEdit_effectContainerDataRaw->clear();
+        ui->plainTextEdit_effectContainerDataString->clear();
+        ui->checkBox_3D->setChecked(false);
+        ui->checkBox_loop->setChecked(false);
+        ui->checkBox_speedVolumeTrigger->setChecked(false);
+        ui->spinBox_randomWeight->clear();
+        ui->doubleSpinBox_amplitudeFactor->clear();
+        ui->doubleSpinBox_dopplerRatio->clear();
+        ui->doubleSpinBox_playbackFrequence->clear();
+        ui->doubleSpinBox_start->clear();
+        ui->doubleSpinBox_end->clear();
+        ui->doubleSpinBox_maskSample->clear();
+        mSlotsEnabled = true;
+    }
+
+    updateLinkedFiles();
+}
+
+void MainWindow::updateVoiceGroupBack(int frontIndex)
+{
+    bool slotsEnabled = mSlotsEnabled;
+    mSlotsEnabled = false;
+    ui->comboBox_voiceGroupBack->clear();
+    ui->comboBox_voiceGroupBack->addItems(BSC::SoundContainer::VOICE_GROUP_BACK_STRINGS[frontIndex]);
+    ui->comboBox_voiceGroupBack->setCurrentIndex(BSC::SoundContainer::VOICE_GROUP_BACK_STRINGS[frontIndex].indexOf(getSelectedSoundContainer()->getInterpretedVoiceGroupBack()));
+    mSlotsEnabled = slotsEnabled;
+}
+
+void MainWindow::updateLinkedFiles()
+{
+    // Clear table
+    ui->tableWidget_linkedFiles->clear();
+
+    // Update table
+    if(mBSCPtr->hasPlaylists() && getSelectedPlaylist()->hasSoundContainers())
+    {
+        ui->tableWidget_linkedFiles->setRowCount(getSelectedSoundContainer()->getInterpretedLinkedFilesV().length());
+
+        for(int i = 0; i < getSelectedSoundContainer()->getInterpretedLinkedFilesV().length(); i++)
+        {
+            QTableWidgetItem* linkedFileItem = new QTableWidgetItem(getSelectedSoundContainer()->getInterpretedLinkedFilesV().value(i));
+            ui->tableWidget_linkedFiles->setItem(i,0, linkedFileItem);
+        }
+
+        // Fit long text
+        //ui->tableWidget_linkedFiles->resizeRowsToContents();
+    }
+    else
+        ui->tableWidget_linkedFiles->setRowCount(0);
+}
+
+void MainWindow::setChangesSavedState(bool changesSaved)
+{
+    mAllChangesSaved = changesSaved;
+    ui->actionSave->setEnabled(!changesSaved); // Disables save button when all changes are saved
+}
+
+bool MainWindow::saveChangesPrompt(bool exit)
+{
+    // Ask user to save
+    QMessageBox saveChanges;
+    saveChanges.setText(MSG_SAVE_PROMPT_TXT);
+    if(exit)
+        saveChanges.setInformativeText(MSG_SAVE_PROMPT_EXIT_INFO_TXT);
+    else
+        saveChanges.setInformativeText(MSG_SAVE_PROMPT_ELSE_INFO_TXT);
+    saveChanges.setStandardButtons(QMessageBox::Yes | QMessageBox::No | QMessageBox::Cancel);
+    saveChanges.setDefaultButton(QMessageBox::Yes);
+    QApplication::beep();
+    int choice = saveChanges.exec();
+
+    if(choice == QMessageBox::Yes)
+    {
+        ui->actionSave->trigger();
+        return mAllChangesSaved; // Ensures that whatever triggered this function is canceled if they user backs out of a "Save As" prompt (if file hasn't been saved before)
+    }
+    else if(choice == QMessageBox::No)
+        return true;
+    else
+        return false;
+}
+
+void MainWindow::openBSCFile(QFile& bscFile)
+{
+    // Make sure file is valid
+    Qx::IO::IOOpReport openReport;
+    bool fileIsValid = BSC::fileIsValidBSC(bscFile, openReport);
+
+    if(openReport.wasSuccessful())
+    {
+        if(fileIsValid)
+        {
+            QByteArray fullFile;
+            openReport = Qx::IO::readAllBytesFromFile(fullFile, bscFile);
+
+            if(openReport.wasSuccessful())
+            {
+                mCurrentFileName = bscFile.fileName();
+                mCurrentFileDir = QDir(bscFile.fileName()).absolutePath();
+                mFileOpen = true;
+                mBSCPtr = std::make_unique<BSC>(fullFile);
+                updateBSCTopLevel();
+                updatePrimaryWidgetStates();
+                if(mBSCPtr->hasPlaylists())
+                    ui->treeWidget_playlists->setCurrentItem(ui->treeWidget_playlists->topLevelItem(0));
+
+                setChangesSavedState(true);
+            }
+            else
+                execIOReport(openReport);
+        }
+        else
+            QMessageBox::critical(this, MENU_OPEN_TITLE, MSG_OPEN_FILE_INVALID.arg(QDir::toNativeSeparators(bscFile.fileName())),
+                                                                                   QMessageBox::Ok, QMessageBox::Ok);
+    }
+    else
+        execIOReport(openReport);
+}
+
+BSC::Playlist* MainWindow::getSelectedPlaylist() const
+{
+    MainWindow::PlaylistItemMap selectedItemMap = PlaylistItemMap(ui->treeWidget_playlists->currentItem(), mBSCPtr.get());
+    return selectedItemMap.getTargetPlaylist();
+}
+
+BSC::SoundContainer* MainWindow::getSelectedSoundContainer() const { return &getSelectedPlaylist()->getSoundContainersR()[ui->comboBox_soundContainer->currentIndex()]; }
+
+void MainWindow::storeTreeItemExpandedStates() const
+{
+    // Recursive Lambda for sub-playlists
+    std::function<void(QTreeWidgetItem* parentItem, BSC* bsc)> recursiveSubPlaylistExpansionStore;
+    recursiveSubPlaylistExpansionStore = [&recursiveSubPlaylistExpansionStore](QTreeWidgetItem* parentItem, BSC* bsc)->void
+    {
+        for(int i = 0; i < parentItem->childCount(); i++)
+        {
+            QTreeWidgetItem* currentItem = parentItem->child(i);
+            PlaylistItemMap(currentItem, bsc).getTargetPlaylist()->setInitialTreeExpansion(currentItem->isExpanded());
+            recursiveSubPlaylistExpansionStore(currentItem, bsc);
+        }
+    };
+
+    for(int i = 0; i < ui->treeWidget_playlists->topLevelItemCount(); i++)
+    {
+        // Top level QTreeWidgetItems
+        QTreeWidgetItem* currentItem = ui->treeWidget_playlists->topLevelItem(i);
+        PlaylistItemMap(currentItem, mBSCPtr.get()).getTargetPlaylist()->setInitialTreeExpansion(currentItem->isExpanded());
+
+        // Sub playlists
+        recursiveSubPlaylistExpansionStore(currentItem, mBSCPtr.get());
+    }
+}
+
+void MainWindow::cacheSubRoutine(bool existing)
+{
+    QString cachePath;
+    if(existing)
+        cachePath = QFileDialog::getOpenFileName(this, MENU_CACHE_OPEN_TITLE, QDir::currentPath(), MENU_CACHE_FILE_FILTER);
+    else
+        cachePath = QFileDialog::getSaveFileName(this, MENU_CACHE_NEW_TITLE, QDir::currentPath(), MENU_CACHE_FILE_FILTER);
+
+    if(cachePath != "")
+    {
+        QFile cacheFile(cachePath);
+
+        SMC cache = SMC();
+
+        if(existing)
+        {
+            QByteArray cacheData;
+            Qx::IO::IOOpReport openReport = Qx::IO::readAllBytesFromFile(cacheData, cacheFile);
+
+            if(openReport.wasSuccessful())
+                cache = SMC(cacheData);
+            else
+            {
+                execIOReport(openReport);
+                return;
+            }
+        }
+
+        if(existing && !cache.isValidCache())
+            QMessageBox::critical(this, QApplication::applicationName(), MSG_CACHE_INVALID.arg(QDir::toNativeSeparators(cachePath)),
+                                  QMessageBox::Ok, QMessageBox::Ok);
+        else
+        {
+            if(existing && cache.getInterpretedCacheListR().removeDuplicates())
+            {
+                QApplication::beep();
+                QMessageBox::information(this, QApplication::applicationName(), MSG_CACHE_HAS_DUPES, QMessageBox::Ok, QMessageBox::Ok);
+            }
+
+            QString scanFolderPath = QFileDialog::getExistingDirectory(this, MENU_CACHE_FOLDER_TITLE, cachePath);
+            QDir scanFolderDir(scanFolderPath);
+
+            if(scanFolderPath != "")
+            {
+                int originalLength = cache.getInterpretedCacheListV().length();
+                bool includeSubFolders = QMessageBox::question(this, QApplication::applicationName(),
+                                                               MSG_CACHE_FOLDER_SUB_PROMPT,
+                                                               QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes) == QMessageBox::Yes;
+
+                QStringList bscList;
+                Qx::IO::IOOpReport folderScanReport = Qx::IO::getDirFileList(bscList, scanFolderDir, includeSubFolders, {BSC::FILE_EXT});
+
+                if(folderScanReport.wasSuccessful())
+                {
+                    QStringList invalidBSCPaths;
+                    QStringList invalidReasons;
+
+                    for(int i = 0; i < bscList.length(); i++)
+                    {
+                        QString currentFileName = QFileInfo(bscList.value(i)).baseName();
+
+                        if(!currentFileName.contains(' '))
+                        {
+                            QFile currentBSCFile(bscList.value(i));
+                            Qx::IO::IOOpReport currentOpenReport;
+                            bool currentFileIsValid = BSC::fileIsValidBSC(currentBSCFile, currentOpenReport);
+
+                            if(currentOpenReport.wasSuccessful() && currentFileIsValid)
+                            {
+                                if(!cache.getInterpretedCacheListR().contains(currentFileName, Qt::CaseInsensitive))
+                                    cache.getInterpretedCacheListR().append(currentFileName);
+                            }
+                            else if(!currentOpenReport.wasSuccessful())
+                            {
+                                invalidBSCPaths.append(currentFileName);
+                                invalidReasons.append(currentOpenReport.getOutcomeInfo());
+                            }
+                            else
+                            {
+                                invalidBSCPaths.append(currentFileName);
+                                invalidReasons.append(MSG_CACHE_INV_FILES_CAT_BAD);
+                            }
+                        }
+                        else
+                        {
+                            invalidBSCPaths.append(currentFileName);
+                            invalidReasons.append(MSG_CACHE_INV_FILES_CAT_SPACE);
+                        }
+                    }
+
+                    cache.deinterpretData();
+                    Qx::IO::IOOpReport writeReport = Qx::IO::writeBytesAsFile(cacheFile, cache.rebuildRawFile(), true);
+
+                    QMessageBox cacheStatus;
+                    cacheStatus.setStandardButtons(QMessageBox::Ok);
+                    cacheStatus.setDefaultButton(QMessageBox::Ok);
+                    cacheStatus.setIcon(QMessageBox::Information);
+
+                    if(!writeReport.wasSuccessful())
+                    {
+                        execIOReport(writeReport);
+
+                        cacheStatus.setIcon(QMessageBox::Critical);
+                        cacheStatus.setText(MSG_CACHE_FAIL.arg(QDir::toNativeSeparators(cachePath)));
+                    }
+                    else if(existing)
+                    {
+                        if(cache.getInterpretedCacheListV().length() == originalLength)
+                            cacheStatus.setText(MSG_CACHE_UP_TO_DATE);
+                        else if(cache.getInterpretedCacheListV().length() == originalLength + bscList.length())
+                            cacheStatus.setText(MSG_CACHE_UPDATED_TXT);
+                        else if(cache.getInterpretedCacheListV().length() > originalLength && cache.getInterpretedCacheListV().length() < originalLength + bscList.length())
+                        {
+                            cacheStatus.setText(MSG_CACHE_UPDATED_TXT);
+                            cacheStatus.setInformativeText(MSG_CACHE_UPDATED_INFO_TXT);
+                        }
+                        else
+                            throw std::out_of_range("Updated Speechmanager Cache entry count is unexpected!");
+                    }
+                    else
+                        cacheStatus.setText(MSG_CACHE_NEW_SUCCESS_TXT);
+
+                    if(invalidBSCPaths.count() > 0)
+                    {
+                        QString invalidReport = MSG_CACHE_INV_FILES_DETAILS;
+                        QString infoText = cacheStatus.informativeText();
+
+                        for(int i = 0; i < invalidBSCPaths.count(); i++)
+                            invalidReport += "\n- " + invalidBSCPaths.value(i) + " " + invalidReasons.value(i);
+
+                        cacheStatus.setIcon(QMessageBox::Warning);
+                        if(infoText != "")
+                            infoText += " ";
+                        cacheStatus.setInformativeText(infoText + MSG_CACHE_INV_FILES_INFO);
+                        cacheStatus.setDetailedText(invalidReport);
+                    }
+
+                    QApplication::beep();
+                    cacheStatus.exec();
+                }
+                else
+                    execIOReport(folderScanReport);
+            }
+        }
+    }
+}
+
+void MainWindow::execIOReport(Qx::IO::IOOpReport ioReport)
+{
+    QMessageBox ioMessage;
+    ioMessage.setStandardButtons(QMessageBox::Ok);
+    ioMessage.setDefaultButton(QMessageBox::Ok);
+    ioMessage.setText(ioReport.getOutcome());
+
+    if(ioReport.wasSuccessful())
+        ioMessage.setIcon(QMessageBox::Information);
+    else
+    {
+        ioMessage.setIcon(QMessageBox::Critical);
+        ioMessage.setInformativeText(ioReport.getOutcomeInfo());
+    }
+
+    if(ioReport.wasSuccessful())
+        QApplication::beep();
+
+    ioMessage.exec();
+}
+
+//-Overrides-----------------------------------------------------------------------------------------------------
+void MainWindow::closeEvent (QCloseEvent *event)
+{
+    bool closeApp = true;
+
+    //Close app
+    if(mFileOpen && !mAllChangesSaved)
+        closeApp = saveChangesPrompt(true);
+
+    if(closeApp)
+        event->accept();
+    else
+        event->ignore();
+}
+
+bool MainWindow::eventFilter(QObject *target, QEvent *event)
+{
+    if(target == ui->plainTextEdit_effectContainerDataRaw)
+    {
+        if(event->type() == QEvent::KeyPress)
+        {
+            QKeyEvent* keyEvent = static_cast<QKeyEvent*>(event);
+
+            if(!(keyEvent->modifiers() & Qt::ControlModifier) && !(keyEvent->modifiers() & Qt::AltModifier) &&
+               !(keyEvent->key() == Qt::Key_Backspace) && !(keyEvent->key() == Qt::Key_Delete) &&
+               !(keyEvent->key() == Qt::Key_Up) && !(keyEvent->key() == Qt::Key_Down) &&
+                !(keyEvent->key() == Qt::Key_Left) && !(keyEvent->key() == Qt::Key_Right)) // Don't filter shortcuts, del, or arrows
+            {
+                if (Qx::String::isHexNumber(keyEvent->text()))
+                {
+                    // Prevent unecessary processing in TextEdit slot
+                    mEffConRawInputGuaranteedValid = true;
+
+                    if(!(keyEvent->modifiers() & Qt::ShiftModifier))
+                    {
+                        // Force capitalize input
+                        QApplication::sendEvent(target, new QKeyEvent(QEvent::KeyPress, keyEvent->key(), keyEvent->modifiers() | Qt::ShiftModifier, keyEvent->text().toUpper()));
+                        QApplication::sendEvent(target, new QKeyEvent(QEvent::KeyRelease, keyEvent->key(), keyEvent->modifiers() | Qt::ShiftModifier, keyEvent->text().toUpper()));
+
+                        return true; // Consume event
+                    }
+                    // else - Let keyevent through
+                }
+                else
+                    return true; //Block non-hexadecimal numbers
+            }
+            else if(keyEvent->key() & Qt::Key_Backspace || keyEvent->key() & Qt::Key_Delete)
+                mEffConRawInputGuaranteedValid = true;
+        }
+    }
+
+    return QMainWindow::eventFilter(target, event); // Pass the event through its normal path
+}
+
+void MainWindow::dragEnterEvent(QDragEnterEvent* event)
+{
+    // Only accept single BSC drops
+    if(event->mimeData()->urls().length() == 1 && event->mimeData()->urls().value(0).isLocalFile())
+    {
+        QString filePath = event->mimeData()->urls().value(0).toLocalFile();
+        if(QFileInfo(filePath).suffix() == BSC::FILE_EXT)
+            event->acceptProposedAction();
+    }
+}
+
+void MainWindow::dropEvent(QDropEvent* event)
+{
+    bool openFile = true;
+
+    if(mFileOpen && !mAllChangesSaved)
+        openFile = saveChangesPrompt(false);
+
+    if(openFile)
+    {
+        QFile fileToOpen(event->mimeData()->urls().value(0).toLocalFile());
+        openBSCFile(fileToOpen);
+    }
+}
+
+//-Slots---------------------------------------------------------------------------------------------------------
+//Private:
+
+void MainWindow::all_on_menuAction_triggered()
+{
+    // Get the object that called this slot
+    QAction *senderAction = qobject_cast<QAction *>(sender());
+
+    // Ensure the signal that trigged this slot belongs to the above class by checking for null pointer
+    if(senderAction == nullptr)
+        throw "Pointer conversion to tree widget failed";
+
+    // Menu "File"
+    if(senderAction == ui->actionSave_As)
+    {
+        QString saveAsPath = QFileDialog::getSaveFileName(this, tr(MENU_SAVE_AS_TITLE.toStdString().c_str()), mCurrentFileDir,
+                                                          tr(MENU_FILE_FILTER.toStdString().c_str()));
+
+        if(saveAsPath != "")
+        {
+            QFile saveAsFile(saveAsPath);
+            Qx::IO::IOOpReport saveReport = Qx::IO::writeBytesAsFile(saveAsFile, mBSCPtr->rebuildRawFile(), true);
+            if(saveReport.wasSuccessful())
+            {
+                QApplication::beep();
+                QMessageBox::information(this, MENU_SAVE_AS_TITLE, MSG_SAVE_SUCCESS.arg(QDir::toNativeSeparators(saveAsPath)),
+                                         QMessageBox::Ok, QMessageBox::Ok);
+                mCurrentFileDir = QDir(saveAsPath).absolutePath();
+                mCurrentFileName = saveAsFile.fileName();
+                setChangesSavedState(true);
+            }
+            else
+            {
+                execIOReport(saveReport);
+                QMessageBox::critical(this, MENU_SAVE_AS_TITLE, MSG_SAVE_FAIL.arg(QDir::toNativeSeparators(saveAsPath)), QMessageBox::Ok, QMessageBox::Ok);
+            }
+
+        }
+    }
+    else if(senderAction == ui->actionSave)
+    {
+        if(mCurrentFileName == "")
+            ui->actionSave_As->trigger();
+        else
+        {
+            QString savePath = mCurrentFileDir + mCurrentFileName;
+            QFile saveFile(savePath);
+            Qx::IO::IOOpReport saveReport = Qx::IO::writeBytesAsFile(saveFile, mBSCPtr->rebuildRawFile(), true);
+            if(saveReport.wasSuccessful())
+            {
+                QApplication::beep();
+                QMessageBox::information(this, MENU_SAVE_TITLE, MSG_SAVE_SUCCESS.arg(QDir::toNativeSeparators(savePath)),
+                                         QMessageBox::Ok, QMessageBox::Ok);
+                setChangesSavedState(true);
+            }
+            else
+            {
+                execIOReport(saveReport);
+                QMessageBox::critical(this, MENU_SAVE_AS_TITLE, MSG_SAVE_FAIL.arg(QDir::toNativeSeparators(savePath)),
+                                      QMessageBox::Ok, QMessageBox::Ok);
+            }
+
+        }
+    }
+    else if(senderAction == ui->actionNew)
+    {
+        bool makeNew = true;
+
+        if(mFileOpen && !mAllChangesSaved)
+            makeNew = saveChangesPrompt(false);
+
+        if(makeNew)
+        {
+            mCurrentFileName = "";
+            mFileOpen = true;
+            mBSCPtr = std::make_unique<BSC>();
+            updateBSCTopLevel();
+            updatePrimaryWidgetStates();
+            updateSecondaryWidgetStates(mEnableGroupTopLevel + mEnableGroupPlaylistSel + mEnableGroupPlaylistSet + mEnableGroupEffectBeh + mEnableGroupSoundCon);
+            updateEntirePlaylist();
+            setChangesSavedState(false);
+        }
+    }
+    else if(senderAction == ui->actionOpen)
+    {
+        bool openFile = true;
+
+        if(mFileOpen && !mAllChangesSaved)
+            openFile = saveChangesPrompt(false);
+
+        if(openFile)
+        {
+            QString openFilePath = QFileDialog::getOpenFileName(this, MENU_OPEN_TITLE, mCurrentFileDir, MENU_FILE_FILTER);
+
+            if(openFilePath != "")
+            {
+                QFile fileToOpen(openFilePath);
+                openBSCFile(fileToOpen);
+            }
+        }
+    }
+    else if(senderAction == ui->actionClose)
+    {
+        bool closeFile = true;
+
+        if(mFileOpen && !mAllChangesSaved)
+            closeFile = saveChangesPrompt(false);
+
+        if(closeFile)
+        {
+            mCurrentFileName = "";
+            mFileOpen = false;
+            updateBSCTopLevel();
+            updatePrimaryWidgetStates();
+            mBSCPtr.reset(); // Deletes ptr contents
+        }
+    }
+    else if(senderAction == ui->actionExit)
+    {
+        bool closeApp = true;
+
+        //Close app
+        if(mFileOpen && !mAllChangesSaved)
+            closeApp = saveChangesPrompt(true);
+
+        if(closeApp)
+            QApplication::quit();
+    }
+
+    // Menu "Tools"
+    else if (senderAction == ui->actionBuild_New_Speechmanager_Cache)
+    {
+        cacheSubRoutine(false);
+    }
+    else if(senderAction == ui->actionUpdate_Speechmanager_Cache)
+    {
+       cacheSubRoutine(true);
+    }
+    else if(senderAction == ui->actionConvert_SMF_WAV)
+    {
+        QString smfPath = QFileDialog::getOpenFileName(this, MENU_CONV_SMF_IN_TITLE, QDir::currentPath(), MENU_SMF_FILE_FILTER);
+
+        if(smfPath != "")
+        {
+            QFile smfFile(smfPath);
+            Qx::IO::IOOpReport openReport;
+            bool smfIsValid = SMF::fileIsValidSMF(smfFile, openReport);
+
+            if(openReport.wasSuccessful())
+            {
+                if(smfIsValid)
+                {
+                    QString wavPath = QFileDialog::getSaveFileName(this, MENU_CONV_SMF_OUT_TITLE, QDir::currentPath(), MENU_WAV_FILE_FILTER);
+
+                    if(wavPath != "")
+                    {
+                        QByteArray smfData;
+                        Qx::IO::IOOpReport smfRead = Qx::IO::readAllBytesFromFile(smfData, smfFile);
+
+                        if(smfRead.wasSuccessful())
+                        {
+                            SMF smfIn(smfData);
+                            QFile wavFile(wavPath);
+
+                            Qx::IO::IOOpReport writeReport = Qx::IO::writeBytesAsFile(wavFile, smfIn.toWAV().getFullData(), true);
+                            if(writeReport.wasSuccessful())
+                            {
+                                QApplication::beep();
+                                QMessageBox::information(this, QApplication::applicationName(), MSG_CONV_SMF_SUCCESS, QMessageBox::Ok, QMessageBox::Ok);
+                            }
+                            else
+                            {
+                                execIOReport(writeReport);
+                                QMessageBox::critical(this, QApplication::applicationName(), MSG_CONV_SMF_FAIL.arg(QDir::toNativeSeparators(wavPath)), QMessageBox::Ok, QMessageBox::Ok);
+                            }
+                        }
+                        else
+                            execIOReport(smfRead);
+                    }
+                }
+                else
+                    QMessageBox::critical(this, QApplication::applicationName(), MSG_CONV_SMF_INVALID.arg(QDir::toNativeSeparators(smfPath)), QMessageBox::Ok, QMessageBox::Ok);
+            }
+            else
+                execIOReport(openReport);
+        }
+    }
+    else if(senderAction == ui->actionConvert_WAV_SMF)
+    {
+        QString wavPath = QFileDialog::getOpenFileName(this, MENU_CONV_WAV_IN_TITLE, QDir::currentPath(), MENU_WAV_FILE_FILTER);
+
+        if(wavPath != "")
+        {
+            QFile wavFile(wavPath);
+            Qx::IO::IOOpReport wavRead;
+            bool fileIsValid = WAV::fileIsValidWAV(wavFile, wavRead);
+
+            if(wavRead.wasSuccessful())
+            {
+                if(fileIsValid)
+                {
+                    QString smfPath = QFileDialog::getSaveFileName(this, MENU_CONV_WAV_OUT_TITLE, QDir::currentPath(), MENU_SMF_FILE_FILTER);
+
+                    if(smfPath != "")
+                    {
+                        QByteArray wavData;
+                        wavRead = Qx::IO::readAllBytesFromFile(wavData, wavFile);
+
+                        if(wavRead.wasSuccessful())
+                        {
+                            WAV wavIn(wavData);
+                            QFile smfFile(smfPath);
+
+                            Qx::IO::IOOpReport writeReport = Qx::IO::writeBytesAsFile(smfFile, wavIn.toSMF().getFullData(), true);
+                            if(writeReport.wasSuccessful())
+                                QMessageBox::information(this, QApplication::applicationName(), MSG_CONV_WAV_SUCCESS, QMessageBox::Ok, QMessageBox::Ok);
+                            else
+                            {
+                                execIOReport(writeReport);
+                                QMessageBox::critical(this, QApplication::applicationName(), MSG_CONV_WAV_FAIL.arg(QDir::toNativeSeparators(wavPath)), QMessageBox::Ok, QMessageBox::Ok);
+                            }
+                        }
+                        else
+                            execIOReport(wavRead);
+                    }
+                }
+                else
+                    QMessageBox::critical(this, QApplication::applicationName(), MSG_CONV_WAV_INVALID.arg(QDir::toNativeSeparators(wavPath)), QMessageBox::Ok, QMessageBox::Ok);
+            }
+            else
+                execIOReport(wavRead);
+        }
+    }
+    else if(senderAction == ui->actionBatch_SMF_WAV)
+    {
+        QString smfFolderPath = QFileDialog::getExistingDirectory(this, MENU_BATCH_SMF_IN_TITLE, QDir::currentPath());
+
+        if(smfFolderPath != "")
+        {
+            bool includeSubFolders = QMessageBox::question(this, QApplication::applicationName(),
+                                                                                MSG_BATCH_SMF_SUB_PROMPT,
+                                                                                QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes) == QMessageBox::Yes;
+
+            QString wavFolderPath = QFileDialog::getExistingDirectory(this, MENU_BATCH_SMF_OUT_TITLE, QDir::currentPath());
+
+            if(wavFolderPath != "")
+            {
+                QDir smfFolder(smfFolderPath);
+                QStringList smfList;
+                Qx::IO::IOOpReport dirRead = Qx::IO::getDirFileList(smfList, smfFolder, includeSubFolders, {SMF::FILE_EXT});
+
+                if(dirRead.wasSuccessful())
+                {
+                    QStringList failedConvList;
+                    QStringList failedReasonList;
+
+                    bool showOverwritePrompt = true;
+                    bool overwriteExisting = false;
+                    bool aborted = false;
+
+                    int filesProcessed = 0;
+
+                    QProgressDialog conversionProgress(MSG_BATCH_SMF_IN_PROGRESS, MSG_BATCH_ALL_ABORT, 0, smfList.length(), this);
+                    conversionProgress.setWindowModality(Qt::WindowModal);
+
+                    for(int i = 0; i < smfList.length(); i++)
+                    {
+                        conversionProgress.setValue(i);
+
+                        if(conversionProgress.wasCanceled())
+                        {
+                            aborted = true;
+                            filesProcessed = i;
+                            break;
+                        }
+
+                        QFile currentFile(smfList.value(i));
+                        Qx::IO::IOOpReport smfRead;
+                        bool fileIsValid = SMF::fileIsValidSMF(currentFile, smfRead);
+
+                        if(smfRead.wasSuccessful())
+                        {
+                            if(fileIsValid)
+                            {
+                                QByteArray smfData;
+                                smfRead = Qx::IO::readAllBytesFromFile(smfData, currentFile);
+
+                                if(smfRead.wasSuccessful())
+                                {
+                                    SMF currentSMF(smfData);
+                                    QString wavOutPath = smfList.value(i).remove(smfFolderPath).prepend(wavFolderPath);
+                                    wavOutPath = wavOutPath.left(wavOutPath.length() - 3).append(WAV::FILE_EXT);
+                                    QFile wavOut(wavOutPath);
+
+                                    if(wavOut.exists() && QFileInfo(wavOut).isFile() && showOverwritePrompt)
+                                    {
+                                        int overwriteChoice = QMessageBox::question(this, QApplication::applicationName(), MSG_BATCH_ALL_FILE_EXST.arg(QDir::toNativeSeparators(wavOutPath)),
+                                                                                    QMessageBox::Yes | QMessageBox::YesToAll | QMessageBox::No | QMessageBox::NoToAll, QMessageBox::No);
+
+                                        switch(overwriteChoice)
+                                        {
+                                            case QMessageBox::YesToAll:
+                                                showOverwritePrompt = false;
+                                                [[fallthrough]];
+                                            case QMessageBox::Yes:
+                                                overwriteExisting = true;
+                                            break;
+
+                                            case QMessageBox::NoToAll:
+                                                showOverwritePrompt = false;
+                                                [[fallthrough]];
+                                            case QMessageBox::No:
+                                                overwriteExisting = false;
+                                        }
+                                    }
+
+                                    Qx::IO::IOOpReport writeReport = Qx::IO::writeBytesAsFile(wavOut, currentSMF.toWAV().getFullData(), overwriteExisting);
+                                    if(!writeReport.wasSuccessful())
+                                    {
+                                        failedConvList.append(smfList.value(i));
+                                        failedReasonList.append(writeReport.getOutcomeInfo());
+                                    }
+                                }
+                                else
+                                {
+                                    failedConvList.append(smfList.value(i));
+                                    failedReasonList.append(smfRead.getOutcomeInfo());
+                                }
+                            }
+                            else
+                            {
+                                failedConvList.append(smfList.value(i));
+                                failedReasonList.append(MSG_BATCH_SMF_INV_FILES_CAT_BAD);
+                            }
+                        }
+                        else
+                        {
+                            failedConvList.append(smfList.value(i));
+                            failedReasonList.append(smfRead.getOutcomeInfo());
+                        }
+                    }
+                    conversionProgress.setValue(smfList.length()); // Finish progress dialog
+
+                    QMessageBox batchResult;
+                    batchResult.setIcon(QMessageBox::Information);
+                    batchResult.setStandardButtons(QMessageBox::Ok);
+                    batchResult.setDefaultButton(QMessageBox::Ok);
+
+                    if(smfList.isEmpty())
+                    {
+                        batchResult.setIcon(QMessageBox::Critical);
+                        batchResult.setText(MSG_BATCH_SMF_NO_FILES);
+                    }
+                    else if(smfList.length() == failedConvList.length())
+                    {
+                        batchResult.setIcon(QMessageBox::Critical);
+                        batchResult.setText(MSG_BATCH_SMF_NO_VALID_FILES_TXT.arg(QDir::toNativeSeparators(smfFolderPath)));
+                        batchResult.setInformativeText(MSG_BATCH_SMF_NO_VALID_FILES_INFO);
+
+                        QString details = MSG_BATCH_SMF_INV_FILES_DETAILS + "\n";
+
+                        for(int i = 0; i < failedConvList.length(); i ++)
+                            details.append("\n- " + failedConvList.value(i) + " " + failedReasonList.value(i));
+
+                        batchResult.setDetailedText(details);
+                    }
+                    else if(aborted)
+                    {
+                        batchResult.setIcon(QMessageBox::Warning);
+                        batchResult.setText(MSG_BATCH_ALL_ABORT);
+                        batchResult.setInformativeText(MSG_BATCH_ALL_ABORTED_INFO.arg(filesProcessed).arg(smfList.length()));
+                    }
+                    else if(!failedConvList.isEmpty())
+                    {
+                        batchResult.setIcon(QMessageBox::Warning);
+                        batchResult.setText(MSG_BATCH_SMF_SUCCESS_TXT);
+                        batchResult.setInformativeText(MSG_BATCH_SMF_INV_FILES_INFO);
+
+                        QString details = MSG_BATCH_SMF_INV_FILES_DETAILS + "\n";
+
+                        for(int i = 0; i < failedConvList.length(); i ++)
+                            details.append("\n- " + failedConvList.value(i) + " " + failedReasonList.value(i));
+
+                        batchResult.setDetailedText(details);
+                    }
+                    else
+                        batchResult.setText(MSG_BATCH_SMF_SUCCESS_TXT);
+
+                    QApplication::beep();
+                    batchResult.exec();
+                }
+                else
+                    execIOReport(dirRead);
+            }
+        }
+    }
+    else if(senderAction == ui->actionBatch_WAV_SMF)
+    {
+        QString wavFolderPath = QFileDialog::getExistingDirectory(this, MENU_BATCH_WAV_IN_TITLE, QDir::currentPath());
+
+        if(wavFolderPath != "")
+        {
+            bool includeSubFolders = QMessageBox::question(this, QApplication::applicationName(),
+                                                                                MSG_BATCH_WAV_SUB_PROMPT,
+                                                                                QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes) == QMessageBox::Yes;
+
+            QString smfFolderPath = QFileDialog::getExistingDirectory(this, MENU_BATCH_WAV_OUT_TITLE, QDir::currentPath());
+
+            if(wavFolderPath != "")
+            {
+                QDir wavFolder(wavFolderPath);
+                QStringList wavList;
+                Qx::IO::IOOpReport dirRead = Qx::IO::getDirFileList(wavList, wavFolder, includeSubFolders, {WAV::FILE_EXT});
+
+                if(dirRead.wasSuccessful())
+                {
+                    QStringList failedConvList;
+                    QStringList failedReasonList;
+
+                    bool showOverwritePrompt = true;
+                    bool overwriteExisting = false;
+                    bool aborted = false;
+
+                    int filesProcessed = 0;
+
+                    QProgressDialog conversionProgress(MSG_BATCH_WAV_IN_PROGRESS, MSG_BATCH_ALL_ABORT, 0, wavList.length(), this);
+                    conversionProgress.setWindowModality(Qt::WindowModal);
+
+                    for(int i = 0; i < wavList.length(); i++)
+                    {
+                        conversionProgress.setValue(i);
+
+                        if(conversionProgress.wasCanceled())
+                        {
+                            aborted = true;
+                            filesProcessed = i;
+                            break;
+                        }
+
+                        QFile currentFile(wavList.value(i));
+                        Qx::IO::IOOpReport wavRead;
+                        bool fileIsValid = WAV::fileIsValidWAV(currentFile, wavRead);
+
+                        if(wavRead.wasSuccessful())
+                        {
+                            if(fileIsValid)
+                            {
+                                QByteArray wavData;
+                                wavRead = Qx::IO::readAllBytesFromFile(wavData, currentFile);
+
+                                if(wavRead.wasSuccessful())
+                                {
+                                    WAV currentWAV(wavData);
+                                    QString smfOutPath = wavList.value(i).remove(wavFolderPath).prepend(smfFolderPath);
+                                    smfOutPath = smfOutPath.left(smfOutPath.length() - 3).append(WAV::FILE_EXT);
+
+                                    QFile smfOut(smfOutPath);
+
+                                    if(smfOut.exists() && QFileInfo(smfOut).isFile() && showOverwritePrompt)
+                                    {
+                                        int overwriteChoice = QMessageBox::question(this, QApplication::applicationName(), MSG_BATCH_ALL_FILE_EXST.arg(QDir::toNativeSeparators(smfOutPath)),
+                                                                                    QMessageBox::Yes | QMessageBox::YesToAll | QMessageBox::No | QMessageBox::NoToAll, QMessageBox::No);
+
+                                        switch(overwriteChoice)
+                                        {
+                                            case QMessageBox::YesToAll:
+                                                showOverwritePrompt = false;
+                                                [[fallthrough]];
+                                            case QMessageBox::Yes:
+                                                overwriteExisting = true;
+                                            break;
+
+                                            case QMessageBox::NoToAll:
+                                                showOverwritePrompt = false;
+                                                [[fallthrough]];
+                                            case QMessageBox::No:
+                                                overwriteExisting = false;
+                                        }
+                                    }
+
+                                    Qx::IO::IOOpReport writeReport = Qx::IO::writeBytesAsFile(smfOut, currentWAV.toSMF().getFullData(), overwriteExisting);
+
+                                    if(!writeReport.wasSuccessful())
+                                    {
+                                        failedConvList.append(wavList.value(i));
+                                        failedReasonList.append(writeReport.getOutcomeInfo());
+                                    }
+                                }
+                                else
+                                {
+                                    failedConvList.append(wavList.value(i));
+                                    failedReasonList.append(wavRead.getOutcomeInfo());
+                                }
+                            }
+                            else
+                            {
+                                failedConvList.append(wavList.value(i));
+                                failedReasonList.append(MSG_BATCH_WAV_INV_FILES_CAT_BAD);
+                            }
+                        }
+                        else
+                        {
+                            failedConvList.append(wavList.value(i));
+                            failedReasonList.append(wavRead.getOutcomeInfo());
+                        }
+                    }
+                    conversionProgress.setValue(wavList.length()); // Finish progress dialog
+
+                    QMessageBox batchResult;
+                    batchResult.setIcon(QMessageBox::Information);
+                    batchResult.setStandardButtons(QMessageBox::Ok);
+                    batchResult.setDefaultButton(QMessageBox::Ok);
+
+                    if(wavList.isEmpty())
+                    {
+                        batchResult.setIcon(QMessageBox::Critical);
+                        batchResult.setText(MSG_BATCH_WAV_NO_FILES);
+                    }
+                    else if(wavList.length() == failedConvList.length())
+                    {
+                        batchResult.setIcon(QMessageBox::Critical);
+                        batchResult.setText(MSG_BATCH_WAV_NO_VALID_FILES_TXT.arg(QDir::toNativeSeparators(wavFolderPath)));
+                        batchResult.setInformativeText(MSG_BATCH_WAV_NO_VALID_FILES_INFO);
+
+                        QString details = MSG_BATCH_WAV_INV_FILES_DETAILS + "\n";
+
+                        for(int i = 0; i < failedConvList.length(); i ++)
+                            details.append("\n- " + failedConvList.value(i) + " " + failedReasonList.value(i));
+
+                        batchResult.setDetailedText(details);
+                    }
+                    else if(aborted)
+                    {
+                        batchResult.setIcon(QMessageBox::Warning);
+                        batchResult.setText(MSG_BATCH_ALL_ABORTED_TXT);
+                        batchResult.setInformativeText(MSG_BATCH_ALL_ABORTED_INFO.arg(filesProcessed).arg(wavList.length()));
+                    }
+                    else if(!failedConvList.isEmpty())
+                    {
+                        batchResult.setIcon(QMessageBox::Warning);
+                        batchResult.setText(MSG_BATCH_WAV_SUCCESS_TXT);
+                        batchResult.setInformativeText(MSG_BATCH_WAV_INV_FILES_INFO);
+
+                        QString details = MSG_BATCH_WAV_INV_FILES_DETAILS + "\n";
+
+                        for(int i = 0; i < failedConvList.length(); i ++)
+                            details.append("\n- " + failedConvList.value(i) + " " + failedReasonList.value(i));
+
+                        batchResult.setDetailedText(details);
+                    }
+                    else
+                        batchResult.setText(MSG_BATCH_WAV_SUCCESS_TXT);
+
+                    QApplication::beep();
+                    batchResult.exec();
+                }
+                else
+                    execIOReport(dirRead);
+            }
+        }
+    }
+
+    // Menu "Help"
+    else if(senderAction == ui->actionAbout)
+    {
+        QMessageBox aboutDiag;
+        aboutDiag.setText(MSG_ABOUT_TXT);
+        aboutDiag.setInformativeText(MSG_ABOUT_INFO_TXT);
+        aboutDiag.setIcon(QMessageBox::Information);
+        aboutDiag.setStandardButtons(QMessageBox::Ok);
+        aboutDiag.setDefaultButton(QMessageBox::Ok);
+        aboutDiag.exec();
+    }
+}
+
+void MainWindow::all_on_treeWidget_currentItemChanged()
+{
+    if(mSlotsEnabled)
+    {
+        // Get the object that called this slot
+        QTreeWidget *senderTreeWidget = qobject_cast<QTreeWidget *>(sender());
+
+        // Ensure the signal that trigged this slot belongs to the above class by checking for null pointer
+        if(senderTreeWidget == nullptr)
+            throw "Pointer conversion to tree widget failed";
+
+        if(senderTreeWidget == ui->treeWidget_playlists)
+        {
+            updateSecondaryWidgetStates(mEnableGroupPlaylistSel);
+            updateEntirePlaylist();
+        }
+    }
+}
+
+void MainWindow::all_on_tableWidget_itemChanged(QTableWidgetItem* item)
+{
+    if(mSlotsEnabled)
+    {
+        // Get the object that called this slot
+        QTableWidget *senderTableWidget = qobject_cast<QTableWidget *>(sender());
+
+        // Ensure the signal thateff trigged this slot belongs to the above class by checking for null pointer
+        if(senderTableWidget == nullptr)
+            throw "Pointer conversion to tree widget failed";
+
+        if(senderTableWidget == ui->tableWidget_linkedFiles)
+        {
+            QString newLinkedFile = item->text();
+            if(getSelectedSoundContainer()->getInterpretedLinkedFilesV()[item->row()] != newLinkedFile)
+            {
+                getSelectedSoundContainer()->getInterpretedLinkedFilesR()[item->row()] = newLinkedFile;
+                setChangesSavedState(false);
+            }
+        }
+        else if (senderTableWidget == ui->tableWidget_effectBehaviors)
+        {
+            QString newEffectBehavior = item->text();
+            if(getSelectedPlaylist()->getInterpretedEffectBehaviorsV()[item->row()] != newEffectBehavior)
+            {
+                getSelectedPlaylist()->getInterpretedEffectBehaviorsR()[item->row()] = newEffectBehavior;
+                setChangesSavedState(false);
+            }
+        }
+    }
+}
+
+void MainWindow::all_on_tableWidget_currentItemChanged()
+{
+    if(mSlotsEnabled)
+    {
+        // Get the object that called this slot
+        QTableWidget *senderTableWidget = qobject_cast<QTableWidget *>(sender());
+
+        // Ensure the signal that trigged this slot belongs to the above class by checking for null pointer
+        if(senderTableWidget == nullptr)
+            throw "Pointer conversion to tree widget failed";
+
+        if(senderTableWidget == ui->tableWidget_effectBehaviors)
+            updateSecondaryWidgetStates(mEnableGroupEffectBeh);
+        else if (senderTableWidget == ui->tableWidget_linkedFiles)
+            updateSecondaryWidgetStates(mEnableGroupSoundCon);
+    }
+}
+
+void MainWindow::all_on_linedEdit_textEdited()
+{
+    if(mSlotsEnabled)
+    {
+        // Get the object that called this slot
+        QLineEdit *senderLineEdit = qobject_cast<QLineEdit *>(sender());
+
+        // Ensure the signal that trigged this slot belongs to the above class by checking for null pointer
+        if(senderLineEdit == nullptr)
+            throw "Pointer conversion to line edit failed";
+
+        // Grab new text
+        QString newText = senderLineEdit->text();
+
+        if(senderLineEdit == ui->lineEdit_effectContainerCount)
+        {
+            if(getSelectedSoundContainer()->getInterpretedEffectContainerCount() != uint32_t(newText.toInt()))
+            {
+                getSelectedSoundContainer()->setInterpretedEffectContainerCount(uint32_t(newText.toInt()));
+                setChangesSavedState(false);
+            }
+        }
+
+        // Refresh Enabled States
+        updateSecondaryWidgetStates({ui->plainTextEdit_effectContainerDataRaw, ui->label_effectContainerDataRaw,
+                                     ui->plainTextEdit_effectContainerDataString, ui->label_effectContainerDataString});
+    }
+}
+
+void MainWindow::all_on_comboBox_currentIndexChanged(int newIndex)
+{
+    if(mSlotsEnabled)
+    {
+        // Get the object that called this slot
+        QComboBox *senderComboBox = qobject_cast<QComboBox *>(sender());
+
+        // Ensure the signal that trigged this slot belongs to the above class by checking for null pointer
+        if(senderComboBox == nullptr)
+            throw "Pointer conversion to combo box failed";
+
+        if(senderComboBox == ui->comboBox_playbackMode)
+        {
+            BSC::Playlist::PlaybackMode newPlaybackMode = static_cast<BSC::Playlist::PlaybackMode>(newIndex);
+            if(getSelectedPlaylist()->getInterpretedPlaybackMode() != newPlaybackMode)
+            {
+                getSelectedPlaylist()->setInterpretedPlaybackMode(newPlaybackMode);
+                setChangesSavedState(false);
+            }
+        }
+        else if(senderComboBox == ui->comboBox_maxInst)
+        {
+            uint32_t newMaxInstances = uint32_t(newIndex);
+            if(getSelectedPlaylist()->getInterpretedMaxInstances() != newMaxInstances)
+            {
+                getSelectedPlaylist()->setInterpretedMaxInstances(newMaxInstances);
+                setChangesSavedState(false);
+            }
+        }
+        else if(senderComboBox == ui->comboBox_poly)
+        {
+            uint32_t newPolyphony = uint32_t(newIndex + 1);
+            if(getSelectedPlaylist()->getInterpretedPolyphony() != newPolyphony) // Index 0 is "One" so need to add 1 to get true value
+            {
+                getSelectedPlaylist()->setInterpretedPolyphony(newPolyphony);
+                setChangesSavedState(false);
+            }
+        }
+        else if(senderComboBox == ui->comboBox_emitter)
+        {
+            BSC::Playlist::Emitter newEmitter = static_cast<BSC::Playlist::Emitter>(newIndex);
+            if(getSelectedPlaylist()->getInterpretedEmitter() != newEmitter)
+            {
+                getSelectedPlaylist()->setInterpretedEmitter(static_cast<BSC::Playlist::Emitter>(newIndex));
+                setChangesSavedState(false);
+            }
+
+        }
+        else if(senderComboBox == ui->comboBox_soundContainer)
+        {
+            if(!mAlteringSoundContainerBoxEntries)
+            {
+                updateSoundContainerGroup();
+
+                // Refresh Enabled States
+                updateSecondaryWidgetStates(mEnableGroupSoundCon);
+            }
+        }
+        else if(senderComboBox == ui->comboBox_voiceGroupFront)
+        {
+            QString newVoiceGroupFront = BSC::SoundContainer::VOICE_GROUP_FRONT_STRINGS.value(ui->comboBox_voiceGroupFront->currentIndex());
+            QString newVoiceGroupBack = BSC::SoundContainer::VOICE_GROUP_BACK_STRINGS[ui->comboBox_voiceGroupFront->currentIndex()].value(0);
+
+            if(getSelectedSoundContainer()->getInterpretedVoiceGroupFront() != newVoiceGroupFront)
+            {
+                getSelectedSoundContainer()->setInterpretedVoiceGroupFront(newVoiceGroupFront);
+                getSelectedSoundContainer()->setInterpretedVoiceGroupBack(newVoiceGroupBack); // First corresponding back value
+                updateVoiceGroupBack(ui->comboBox_voiceGroupFront->currentIndex());
+                setChangesSavedState(false);
+            }
+        }
+        else if(senderComboBox == ui->comboBox_voiceGroupBack)
+        {
+            QString newVoiceGroupBack = BSC::SoundContainer::VOICE_GROUP_BACK_STRINGS[ui->comboBox_voiceGroupFront->currentIndex()].value(ui->comboBox_voiceGroupBack->currentIndex());
+
+            if(getSelectedSoundContainer()->getInterpretedVoiceGroupBack() != newVoiceGroupBack)
+            {
+                getSelectedSoundContainer()->setInterpretedVoiceGroupBack(newVoiceGroupBack);
+                setChangesSavedState(false);
+            }
+        }
+    }
+}
+
+void MainWindow::all_on_spinBox_valueChanged(int newValue)
+{
+    if(mSlotsEnabled)
+    {
+        // Get the object that called this slot
+        QSpinBox *senderSpinBox = qobject_cast<QSpinBox *>(sender());
+
+        // Ensure the signal that trigged this slot belongs to the above class by checking for null pointer
+        if(senderSpinBox == nullptr)
+            throw "Pointer conversion to spin box failed";
+
+        if(senderSpinBox == ui->spinBox_repeatTimeMin)
+        {
+            uint32_t newRepeatTimeMin = uint32_t(newValue);
+            if(getSelectedPlaylist()->getInterpretedMinRepeatTime() != newRepeatTimeMin)
+            {
+                getSelectedPlaylist()->setInterpretedMinRepeatTime(newRepeatTimeMin);
+                setChangesSavedState(false);
+            }
+        }
+        else if(senderSpinBox == ui->spinBox_repeatTimeMax)
+        {
+            uint32_t newRepeatTimeMax = uint32_t(newValue);
+            if(getSelectedPlaylist()->getInterpretedMaxRepeatTime() != newRepeatTimeMax)
+            {
+                getSelectedPlaylist()->setInterpretedMaxRepeatTime(newRepeatTimeMax);
+                setChangesSavedState(false);
+            }
+        }
+        else if(senderSpinBox == ui->spinBox_repeatCountMin)
+        {
+            uint32_t newRepeatCountMin = uint32_t(newValue);
+            if(getSelectedPlaylist()->getInterpretedMinRepeatCount() != newRepeatCountMin)
+            {
+                getSelectedPlaylist()->setInterpretedMinRepeatCount(newRepeatCountMin);
+                setChangesSavedState(false);
+            }
+        }
+        else if(senderSpinBox == ui->spinBox_repeatCountMax)
+        {
+            uint32_t newRepeatCountMax = uint32_t(newValue);
+            if(getSelectedPlaylist()->getInterpretedMaxRepeatCount() != newRepeatCountMax)
+            {
+                getSelectedPlaylist()->setInterpretedMaxRepeatCount(newRepeatCountMax);
+                setChangesSavedState(false);
+            }
+        }
+        else if(senderSpinBox == ui->spinBox_randomPlaylistWeight)
+        {
+            uint32_t newRandomPlalistWeight = uint32_t(newValue);
+            if(getSelectedPlaylist()->getInterpretedRandomPlaylistWeight() != newRandomPlalistWeight)
+            {
+                getSelectedPlaylist()->setInterpretedRandomPlaylistWeight(newRandomPlalistWeight);
+                setChangesSavedState(false);
+            }
+        }
+        else if(senderSpinBox == ui->spinBox_randomWeight)
+        {
+            uint32_t newRandomWeight = uint32_t(newValue);
+            if(getSelectedSoundContainer()->getInterpretedRandomWeight() != newRandomWeight)
+            {
+                getSelectedSoundContainer()->setInterpretedRandomWeight(newRandomWeight);
+                setChangesSavedState(false);
+            }
+        }
+    }
+}
+
+void MainWindow::all_on_doubleSpinBox_valueChanged(double newValue)
+{
+    if(mSlotsEnabled)
+    {
+        // Get the object that called this slot
+        QDoubleSpinBox *senderDoubleSpinBox = qobject_cast<QDoubleSpinBox *>(sender());
+
+        // Ensure the signal that trigged this slot belongs to the above class by checking for null pointer
+        if(senderDoubleSpinBox == nullptr)
+            throw "Pointer conversion to double spin box failed";
+
+        // Since floats in this editor are only ever read, written, and changed incrementally (no floating-point math is performed)
+        // comparing floats directly in this context is safe and ==/!= related warning can be ignored. There is conversion between
+        // double and float but this is always performed using the same method and with values inder the 32-bit float limit and
+        // therefore gives consistant results, so it is also a non-issue. std::equal_to is used for float comparisons so that this
+        // warning is effectively supressed (the warning has no ID so its impossible to supress directly)
+
+        if(senderDoubleSpinBox == ui->doubleSpinBox_length)
+        {
+            float newLength = float(newValue);
+            if(!std::equal_to<float>()(getSelectedPlaylist()->getInterpretedLength(), newLength))
+            {
+                getSelectedPlaylist()->setInterpretedLength(float(newValue));
+                float test1 = 2;
+                float test2 = 3;
+                std::equal_to<float>()(test1, test2);
+            }
+        }
+        else if(senderDoubleSpinBox == ui->doubleSpinBox_releaseTime)
+        {
+            float newReleaseTime = float(newValue);
+            if(!std::equal_to<float>()(getSelectedPlaylist()->getInterpretedReleaseTime(), newReleaseTime))
+            {
+                getSelectedPlaylist()->setInterpretedReleaseTime(newReleaseTime);
+                setChangesSavedState(false);
+            }
+        }
+        else if(senderDoubleSpinBox == ui->doubleSpinBox_amplitudeFactor)
+        {
+            float newAmplitudeFactor = float(newValue);
+            if(!std::equal_to<float>()(getSelectedSoundContainer()->getInterpretedAmplitudeFactor(), newAmplitudeFactor))
+            {
+                getSelectedSoundContainer()->setInterpretedAmplitudeFactor(newAmplitudeFactor);
+                setChangesSavedState(false);
+            }
+        }
+        else if(senderDoubleSpinBox == ui->doubleSpinBox_dopplerRatio)
+        {
+            float newDopplerRatio = float(newValue);
+            if(!std::equal_to<float>()(getSelectedSoundContainer()->getInterpretedDopplerRatio(), newDopplerRatio))
+            {
+                getSelectedSoundContainer()->setInterpretedDopplerRatio(newDopplerRatio);
+                setChangesSavedState(false);
+            }
+        }
+        else if(senderDoubleSpinBox == ui->doubleSpinBox_playbackFrequence)
+        {
+            float newPlaybackFrequence = float(newValue);
+            if(!std::equal_to<float>()(getSelectedSoundContainer()->getInterpretedPlaybackFrequence(), newPlaybackFrequence))
+            {
+                getSelectedSoundContainer()->setInterpretedPlaybackFrequence(newPlaybackFrequence);
+                setChangesSavedState(false);
+            }
+        }
+        else if(senderDoubleSpinBox == ui->doubleSpinBox_start)
+        {
+            float newStart = float(newValue);
+            if(!std::equal_to<float>()(getSelectedSoundContainer()->getInterpretedStart(), newStart))
+            {
+                getSelectedSoundContainer()->setInterpretedStart(newStart);
+                setChangesSavedState(false);
+            }
+        }
+        else if(senderDoubleSpinBox == ui->doubleSpinBox_end)
+        {
+            float newEnd = float(newValue);
+            if(!std::equal_to<float>()(getSelectedSoundContainer()->getInterpretedEnd(), newEnd))
+            {
+                getSelectedSoundContainer()->setInterpretedEnd(newEnd);
+                setChangesSavedState(false);
+            }
+        }
+        else if(senderDoubleSpinBox == ui->doubleSpinBox_maskSample)
+        {
+            float newMaskSample = float(newValue);
+            if(!std::equal_to<float>()(getSelectedSoundContainer()->getInterpretedMaskSample(), newMaskSample))
+            {
+                getSelectedSoundContainer()->setInterpretedMaskSample(newMaskSample);
+                setChangesSavedState(false);
+            }
+        }
+    }
+}
+
+void MainWindow::all_on_checkBox_stateChanged(int newState)
+{
+    if(mSlotsEnabled)
+    {
+        // Get the object that called this slot
+        QCheckBox *senderCheckBox = qobject_cast<QCheckBox *>(sender());
+
+        // Ensure the signal that trigged this slot belongs to the above class by checking for null pointer
+        if(senderCheckBox == nullptr)
+            throw "Pointer conversion to check box failed";
+
+        if(senderCheckBox == ui->checkBox_parentBehaviorOverride)
+        {
+            bool newParentBehaviorOverride = newState;
+            if(getSelectedPlaylist()->getInterpretedOverrideParentBehaviors() != newParentBehaviorOverride)
+            {
+                getSelectedPlaylist()->setInterpretedOverrideParentBehaviors(newParentBehaviorOverride);
+                setChangesSavedState(false);
+            }
+        }
+        else if(senderCheckBox == ui->checkBox_3D)
+        {
+            bool new3D = newState;
+            if(getSelectedSoundContainer()->getInterpretedIs3D() != new3D)
+            {
+                getSelectedSoundContainer()->setInterpretedIs3D(new3D);
+                setChangesSavedState(false);
+            }
+        }
+        else if(senderCheckBox == ui->checkBox_loop)
+        {
+            bool newLoop = newState;
+            if(getSelectedSoundContainer()->getInterpretedIsLooped() != newLoop)
+            {
+                getSelectedSoundContainer()->setInterpretedIsLooped(newLoop);
+                setChangesSavedState(false);
+            }
+        }
+        else if(senderCheckBox == ui->checkBox_speedVolumeTrigger)
+        {
+            bool newSpeedVolumeTrigger = newState;
+            if(getSelectedSoundContainer()->getInterpretedUsingSpeedVolumeTrigger() != newSpeedVolumeTrigger)
+            {
+                getSelectedSoundContainer()->setInterpretedUsingSpeedVolumeTrigger(newSpeedVolumeTrigger);
+                setChangesSavedState(false);
+            }
+        }
+        else if(senderCheckBox == ui->checkBox_effectContainerDataEdit)
+        {
+            if(!mGaveEffectContainerWarning)
+            {
+                QMessageBox effConWarning;
+                effConWarning.setIcon(QMessageBox::Warning);
+                effConWarning.setText(MSG_EFF_CON_EDIT_WARN_TXT);
+                effConWarning.setInformativeText(MSG_EFF_CON_EDIT_WARN_INFO_TXT);
+                effConWarning.setStandardButtons(QMessageBox::Ok);
+                effConWarning.setDefaultButton(QMessageBox::Ok);
+                QApplication::beep();
+                effConWarning.exec();
+
+                mGaveEffectContainerWarning = true;
+            }
+
+            ui->lineEdit_effectContainerCount->setReadOnly(!newState);
+            ui->plainTextEdit_effectContainerDataRaw->setReadOnly(!newState);
+            ui->plainTextEdit_effectContainerDataString->setReadOnly(!newState);
+        }
+    }
+}
+
+void MainWindow::all_on_toolButton_clicked()
+{
+    if(mSlotsEnabled)
+    {
+        // Get the object that called this slot
+        QToolButton *senderToolbutton = qobject_cast<QToolButton *>(sender());
+
+        // Ensure the signal that trigged this slot belongs to the above class by checking for null pointer
+        if(senderToolbutton == nullptr)
+            throw "Pointer conversion to tool button failed";
+
+        // Playlists
+        if(senderToolbutton == ui->toolButton_playlistsAdd)
+        {
+            // Save TreeWidgetExpanded states
+            storeTreeItemExpandedStates();
+
+            if(ui->treeWidget_playlists->currentItem() == nullptr)
+            {
+                mBSCPtr->getPlaylistsR().append(BSC::Playlist(false));
+                updatePlaylists();
+                ui->treeWidget_playlists->setCurrentItem(ui->treeWidget_playlists->topLevelItem(ui->treeWidget_playlists->topLevelItemCount() - 1));
+
+            }
+            else
+            {
+                PlaylistItemMap selectedItemMap = PlaylistItemMap(ui->treeWidget_playlists->currentItem(), mBSCPtr.get());
+                selectedItemMap.getTargetPlaylistList()->insert(selectedItemMap.getTargetIndex() + 1, BSC::Playlist(!selectedItemMap.targetIsTopLevel()));
+                updatePlaylists();
+                ui->treeWidget_playlists->setCurrentItem(PlaylistItemMap::getItemRelativeToMap(ui->treeWidget_playlists, selectedItemMap, selectedItemMap.targetDepth(),
+                                                                                               selectedItemMap.getTargetIndex() + 1));
+            }
+        }
+        else if(senderToolbutton == ui->toolButton_playlistsRemove)
+        {
+            assert(ui->treeWidget_playlists->currentItem() != nullptr); // The remove button should be inactive/disabled if nothing is selected
+
+            // Save TreeWidgetExpanded states
+            storeTreeItemExpandedStates();
+
+            PlaylistItemMap selectedItemMap = PlaylistItemMap(ui->treeWidget_playlists->currentItem(), mBSCPtr.get());
+            selectedItemMap.getTargetPlaylistList()->removeAt(selectedItemMap.getTargetIndex());
+            updatePlaylists();
+
+            if(mBSCPtr->hasPlaylists())
+            {
+                if(selectedItemMap.targetIsTopLevel())
+                    ui->treeWidget_playlists->setCurrentItem(PlaylistItemMap::getItemRelativeToMap(ui->treeWidget_playlists, selectedItemMap, 0, selectedItemMap.getTargetIndex() - 1));
+                else if(selectedItemMap.getTargetParentPlaylist()->subPlaylistCount() == 0)
+                    ui->treeWidget_playlists->setCurrentItem(PlaylistItemMap::getItemRelativeToMap(ui->treeWidget_playlists, selectedItemMap, selectedItemMap.targetDepth() - 1,
+                                                                                                   selectedItemMap.getTargetParentIndex()));
+                else
+                    ui->treeWidget_playlists->setCurrentItem(PlaylistItemMap::getItemRelativeToMap(ui->treeWidget_playlists, selectedItemMap, selectedItemMap.targetDepth(),
+                                                                                                   selectedItemMap.getTargetIndex() - 1));
+            }
+            else
+                updateEntirePlaylist();
+
+             ui->lineEdit_playlistCount->setText(QString::number(mBSCPtr->getPlaylistsV().length())); // Updates playlist count in ui
+        }
+        else if(senderToolbutton == ui->toolButton_playlistsCopy)
+        {
+            assert(ui->treeWidget_playlists->currentItem() != nullptr); // The copy button should be inactive/disabled if nothing is selected
+
+            // Save TreeWidgetExpanded states
+            storeTreeItemExpandedStates();
+
+            PlaylistItemMap selectedItemMap = PlaylistItemMap(ui->treeWidget_playlists->currentItem(), mBSCPtr.get());
+            selectedItemMap.getTargetPlaylistList()->insert(selectedItemMap.getTargetIndex() + 1, *selectedItemMap.getTargetPlaylist()); // Dereferrence pointer so copy is made
+            updatePlaylists();
+
+            ui->treeWidget_playlists->setCurrentItem(PlaylistItemMap::getItemRelativeToMap(ui->treeWidget_playlists, selectedItemMap, selectedItemMap.targetDepth(),
+                                                                                           selectedItemMap.getTargetIndex() + 1));
+
+             ui->lineEdit_playlistCount->setText(QString::number(mBSCPtr->getPlaylistsV().length())); // Updates playlist count in ui
+        }
+        else if(senderToolbutton == ui->toolButton_playlistsOut)
+        {
+            assert(ui->treeWidget_playlists->currentItem() != nullptr || !ui->treeWidget_playlists->currentItem()->parent()); // The out button should be inactive/disabled if nothing
+                                                                                                                              // is selected or selection is a top level
+            // Save TreeWidgetExpanded states
+            storeTreeItemExpandedStates();
+
+            PlaylistItemMap selectedItemMap = PlaylistItemMap(ui->treeWidget_playlists->currentItem(), mBSCPtr.get());
+
+            selectedItemMap.getTargetParentPlaylistList()->insert(selectedItemMap.getTargetParentIndex() + 1, *selectedItemMap.getTargetPlaylist()); // Dereferrence pointer so copy is made
+            selectedItemMap.getTargetPlaylistList()->removeAt(selectedItemMap.getTargetIndex()); // Delete original playlist
+            updatePlaylists();
+
+            ui->treeWidget_playlists->setCurrentItem(PlaylistItemMap::getItemRelativeToMap(ui->treeWidget_playlists, selectedItemMap, selectedItemMap.targetDepth() - 1,
+                                                                                           selectedItemMap.getTargetIndex() + 1));
+        }
+        else if(senderToolbutton == ui->toolButton_playlistsIn)
+        {
+            assert(ui->treeWidget_playlists->currentItem() != nullptr); // The in button should be inactive/disabled if nothing is selected
+
+            // Save TreeWidgetExpanded states
+            storeTreeItemExpandedStates();
+
+            PlaylistItemMap selectedItemMap = PlaylistItemMap(ui->treeWidget_playlists->currentItem(), mBSCPtr.get());
+
+            assert(selectedItemMap.getTargetIndex() > 0); // The in button should be inactive/disabled if the selection has nothing above it
+
+            // Simply using "[]" here returns a nullptr (must have to do with being a list of pointers) so "operator[]()" must be used instead
+            selectedItemMap.getTargetPlaylistList()->operator[](selectedItemMap.getTargetIndex() - 1).getSubPlaylistsR().append((*selectedItemMap.getTargetPlaylist()));
+            selectedItemMap.getTargetPlaylistList()->removeAt(selectedItemMap.getTargetIndex()); // Delete original playlist
+            updatePlaylists();
+
+            // Item playlist went into
+            QTreeWidgetItem* aboveItem = PlaylistItemMap::getItemRelativeToMap(ui->treeWidget_playlists, selectedItemMap, selectedItemMap.targetDepth(),
+                                                                     selectedItemMap.getTargetIndex() - 1);
+
+            // Selec the child that the playlist now is
+            ui->treeWidget_playlists->setCurrentItem(aboveItem->child(aboveItem->childCount() - 1));
+        }
+        else if(senderToolbutton == ui->toolButton_playlistsUp)
+        {
+            assert(ui->treeWidget_playlists->currentItem() != nullptr); // The move up button should be inactive/disabled if nothing is selected
+
+            // Save TreeWidgetExpanded states
+            storeTreeItemExpandedStates();
+
+            PlaylistItemMap selectedItemMap = PlaylistItemMap(ui->treeWidget_playlists->currentItem(), mBSCPtr.get());
+
+            assert(selectedItemMap.getTargetIndex() > 0); // The move up button should be inactive/disabled if the selected item if the top entry
+
+            selectedItemMap.getTargetPlaylistList()->move(selectedItemMap.getTargetIndex(), selectedItemMap.getTargetIndex() - 1);
+            updatePlaylists();
+
+            ui->treeWidget_playlists->setCurrentItem(PlaylistItemMap::getItemRelativeToMap(ui->treeWidget_playlists, selectedItemMap, selectedItemMap.targetDepth(),
+                                                                                           selectedItemMap.getTargetIndex() - 1));
+        }
+        else if(senderToolbutton == ui->toolButton_playlistsDown)
+        {
+            assert(ui->treeWidget_playlists->currentItem() != nullptr); // The move down button should be inactive/disabled if nothing is selected
+
+            // Save TreeWidgetExpanded states
+            storeTreeItemExpandedStates();
+
+            PlaylistItemMap selectedItemMap = PlaylistItemMap(ui->treeWidget_playlists->currentItem(), mBSCPtr.get());
+
+            assert(selectedItemMap.getTargetIndex() < selectedItemMap.getTargetPlaylistList()->length() - 1); // The move down button should be inactive/disabled if the
+                                                                                                              // selected item if the bottom entry
+            selectedItemMap.getTargetPlaylistList()->move(selectedItemMap.getTargetIndex(), selectedItemMap.getTargetIndex() + 1);
+            updatePlaylists();
+
+            ui->treeWidget_playlists->setCurrentItem(PlaylistItemMap::getItemRelativeToMap(ui->treeWidget_playlists, selectedItemMap, selectedItemMap.targetDepth(),
+                                                                                           selectedItemMap.getTargetIndex() + 1));
+        }
+
+        // Effect Behaviors
+        else if(senderToolbutton == ui->toolButton_effectBehaviorsAdd)
+        {
+            int selectedIndex = ui->tableWidget_effectBehaviors->currentRow();
+
+            if(selectedIndex < 0)
+            {
+                getSelectedPlaylist()->addInterpretedEffectBehavior(BSC::Playlist::EFFECT_BEHAVIOR_DEFAULT);
+                updateEffectBehaviors();
+                ui->tableWidget_effectBehaviors->setCurrentCell(getSelectedPlaylist()->getInterpretedEffectBehaviorsV().length() - 1, 0);
+
+            }
+            else
+            {
+                getSelectedPlaylist()->addInterpretedEffectBehavior(BSC::Playlist::EFFECT_BEHAVIOR_DEFAULT, selectedIndex + 1);
+                updateEffectBehaviors();
+                ui->tableWidget_effectBehaviors->setCurrentCell(selectedIndex + 1, 0);
+            }
+        }
+        else if(senderToolbutton == ui->toolButton_effectBehaviorsRemove)
+        {
+            int selectedIndex = ui->tableWidget_effectBehaviors->currentRow();
+            assert(selectedIndex > -1); // The remove button should be inactive/disabled if nothing is selected
+
+            getSelectedPlaylist()->removeInterpretedEffectBehavior(selectedIndex);
+            updateEffectBehaviors();
+            if(ui->tableWidget_effectBehaviors->rowCount() > 0)
+                ui->tableWidget_effectBehaviors->setCurrentCell(selectedIndex - 1, 0);
+        }
+        else if(senderToolbutton == ui->toolButton_effectBehaviorsCopy)
+        {
+            int selectedIndex = ui->tableWidget_effectBehaviors->currentRow();
+            assert(selectedIndex > -1); // The copy button should be inactive/disabled if nothing is selected
+
+            getSelectedPlaylist()->copyInterpretedEffectBehavior(selectedIndex, selectedIndex + 1);
+            updateEffectBehaviors();
+            ui->tableWidget_effectBehaviors->setCurrentCell(selectedIndex + 1, 0);
+        }
+        else if(senderToolbutton == ui->toolButton_effectBehaviorsUp)
+        {
+            int selectedIndex = ui->tableWidget_effectBehaviors->currentRow();
+            assert(selectedIndex > 0); // The move up button should be inactive/disabled if nothing is selected or the selected item if the top entry
+
+            getSelectedPlaylist()->moveInterpretedEffectBehavior(selectedIndex, selectedIndex - 1);
+            updateEffectBehaviors();
+            ui->tableWidget_effectBehaviors->setCurrentCell(selectedIndex - 1, 0);
+        }
+        else if(senderToolbutton == ui->toolButton_effectBehaviorsDown)
+        {
+            int selectedIndex = ui->tableWidget_effectBehaviors->currentRow();
+            assert(selectedIndex > -1 && selectedIndex < ui->tableWidget_effectBehaviors->rowCount() - 1); // The move down button should be inactive/disabled
+                                                                                                        // if nothing is selected or the selected item if the bottom entry
+            getSelectedPlaylist()->moveInterpretedEffectBehavior(selectedIndex, selectedIndex + 1);
+            updateEffectBehaviors();
+            ui->tableWidget_effectBehaviors->setCurrentCell(selectedIndex + 1, 0);
+        }
+
+        // Sound Containers
+        else if(senderToolbutton == ui->toolButton_soundContainerAdd)
+        {
+            int selectedIndex = ui->comboBox_soundContainer->currentIndex();
+            if(selectedIndex < 0)
+            {
+                getSelectedPlaylist()->addSoundContainer(BSC::SoundContainer());
+                updateSoundContainers();
+                ui->comboBox_soundContainer->setCurrentIndex(getSelectedPlaylist()->soundContainerCount() - 1);
+
+            }
+            else
+            {
+                getSelectedPlaylist()->addSoundContainer(BSC::SoundContainer(), selectedIndex + 1);
+                updateSoundContainers();
+                ui->comboBox_soundContainer->setCurrentIndex(selectedIndex + 1);
+            }
+
+            updateSoundContainerGroup(); // Must call manually to ensure update since the above may have moved the selected index
+                                         // to the desired index so using "setCurrentIndex()" on the same index won't trigger the corresponding slot
+        }
+        else if(senderToolbutton == ui->toolButton_soundContainerRemove)
+        {
+            int selectedIndex = ui->comboBox_soundContainer->currentIndex();
+            assert(selectedIndex > -1); // The remove button should be inactive/disabled if nothing is selected
+
+            getSelectedPlaylist()->removeSoundContainer(selectedIndex);
+            updateSoundContainers();
+            if(ui->comboBox_soundContainer->count() > 0)
+                ui->comboBox_soundContainer->setCurrentIndex(selectedIndex - 1);
+
+            updateSoundContainerGroup(); // Must call manually to ensure update since the above may have moved the selected index
+                                         // to the desired index so using "setCurrentIndex()" on the same index won't trigger the corresponding slot
+        }
+        else if(senderToolbutton == ui->toolButton_soundContainerCopy)
+        {
+            int selectedIndex = ui->comboBox_soundContainer->currentIndex();
+            assert(selectedIndex > -1); // The copy button should be inactive/disabled if nothing is selected
+
+            getSelectedPlaylist()->copySoundContainer(selectedIndex, selectedIndex + 1);
+            updateSoundContainers();
+            ui->comboBox_soundContainer->setCurrentIndex(selectedIndex + 1);
+
+            updateSoundContainerGroup(); // Must call manually to ensure update since the above may have moved the selected index
+                                         // to the desired index so using "setCurrentIndex()" on the same index won't trigger the corresponding slot
+
+        }
+        else if(senderToolbutton == ui->toolButton_soundContainerUp)
+        {
+            int selectedIndex = ui->comboBox_soundContainer->currentIndex();
+            assert(selectedIndex > 0); // The move up button should be inactive/disabled if nothing is selected or the selected item if the top entry
+
+            getSelectedPlaylist()->moveSoundContainer(selectedIndex, selectedIndex - 1);
+            updateSoundContainers();
+            ui->comboBox_soundContainer->setCurrentIndex(selectedIndex - 1);
+
+            updateSoundContainerGroup(); // Must call manually to ensure update since the above may have moved the selected index
+                                         // to the desired index so using "setCurrentIndex()" on the same index won't trigger the corresponding slot
+        }
+        else if(senderToolbutton == ui->toolButton_soundContainerDown)
+        {
+            int selectedIndex = ui->comboBox_soundContainer->currentIndex();
+            assert(selectedIndex > -1 && selectedIndex <= ui->comboBox_soundContainer->count() - 1); // The move down button should be inactive/disabled
+                                                                                                        // if nothing is selected or the selected item if the bottom entry
+            getSelectedPlaylist()->moveSoundContainer(selectedIndex, selectedIndex + 1);
+            updateSoundContainers();
+            ui->comboBox_soundContainer->setCurrentIndex(selectedIndex + 1);
+
+            updateSoundContainerGroup(); // Must call manually to ensure update since the above may have moved the selected index
+                                         // to the desired index so using "setCurrentIndex()" on the same index won't trigger the corresponding slot
+        }
+
+        // Linked Files
+        else if(senderToolbutton == ui->toolButton_linkedFilesAdd)
+        {
+            BSC::SoundContainer* currentSoundContainer = getSelectedSoundContainer();
+            int selectedIndex = ui->tableWidget_linkedFiles->currentRow();
+
+            if(selectedIndex < 0)
+            {
+                currentSoundContainer->addInterpretedLinkedFile(BSC::SoundContainer::LINKED_FILE_DEFAULT);
+                updateLinkedFiles();
+                ui->tableWidget_linkedFiles->setCurrentCell(currentSoundContainer->getInterpretedLinkedFilesV().length() - 1, 0);
+
+            }
+            else
+            {
+                currentSoundContainer->addInterpretedLinkedFile(BSC::SoundContainer::LINKED_FILE_DEFAULT, selectedIndex + 1);
+                updateLinkedFiles();
+                ui->tableWidget_linkedFiles->setCurrentCell(selectedIndex + 1, 0);
+            }
+        }
+        else if(senderToolbutton == ui->toolButton_linkedFilesRemove)
+        {
+            BSC::SoundContainer* currentSoundContainer = getSelectedSoundContainer();
+            int selectedIndex = ui->tableWidget_linkedFiles->currentRow();
+            assert(selectedIndex > -1); // The remove button should be inactive/disabled if nothing is selected
+
+            currentSoundContainer->removeInterpretedLinkedFile(selectedIndex);
+            updateLinkedFiles();
+            if(ui->tableWidget_linkedFiles->rowCount() > 0)
+                ui->tableWidget_linkedFiles->setCurrentCell(selectedIndex - 1, 0);
+        }
+        else if(senderToolbutton == ui->toolButton_linkedFilesCopy)
+        {
+            BSC::SoundContainer* currentSoundContainer = getSelectedSoundContainer();
+            int selectedIndex = ui->tableWidget_linkedFiles->currentRow();
+            assert(selectedIndex > -1); // The copy button should be inactive/disabled if nothing is selected
+
+            currentSoundContainer->copyInterpretedLinkedFile(selectedIndex, selectedIndex + 1);
+            updateLinkedFiles();
+            ui->tableWidget_linkedFiles->setCurrentCell(selectedIndex + 1, 0);
+        }
+        else if(senderToolbutton == ui->toolButton_linkedFilesUp)
+        {
+            BSC::SoundContainer* currentSoundContainer = getSelectedSoundContainer();
+            int selectedIndex = ui->tableWidget_linkedFiles->currentRow();
+            assert(selectedIndex > 0); // The move up button should be inactive/disabled if nothing is selected or the selected item if the top entry
+
+            currentSoundContainer->moveInterpretedLinkedFile(selectedIndex, selectedIndex - 1);
+            updateLinkedFiles();
+            ui->tableWidget_linkedFiles->setCurrentCell(selectedIndex - 1, 0);
+        }
+        else if(senderToolbutton == ui->toolButton_linkedFilesDown)
+        {
+            BSC::SoundContainer* currentSoundContainer = getSelectedSoundContainer();
+            int selectedIndex = ui->tableWidget_linkedFiles->currentRow();
+            assert(selectedIndex > -1 && selectedIndex <= ui->tableWidget_linkedFiles->rowCount() - 1); // The move down button should be inactive/disabled
+                                                                                                        // if nothing is selected or the selected item if the bottom entry
+            currentSoundContainer->moveInterpretedLinkedFile(selectedIndex, selectedIndex + 1);
+            updateLinkedFiles();
+            ui->tableWidget_linkedFiles->setCurrentCell(selectedIndex + 1, 0);
+        }
+
+        // Update enable states
+        updateSecondaryWidgetStates((*Qx::List::getSubListThatContains(qobject_cast<QWidget*>(senderToolbutton),
+                                                                          {&mEnableGroupSoundCon, &mEnableGroupTopLevel, &mEnableGroupEffectBeh,
+                                                                           &mEnableGroupPlaylistSel, &mEnableGroupPlaylistSet})));
+
+        // Update save check
+        setChangesSavedState(false); // All toolButton actions change the file in someway
+    }   
+}
+
+void MainWindow::all_on_plainTextEdit_textChanged()
+{
+    if(mSlotsEnabled)
+    {
+        // Get the object that called this slot
+        QPlainTextEdit *senderPlainTextEdit = qobject_cast<QPlainTextEdit *>(sender());
+
+        // Ensure the signal that trigged this slot belongs to the above class by checking for null pointer
+        if(senderPlainTextEdit == nullptr)
+            throw "Pointer conversion to plain text edit failed";
+
+        // Get new text
+        QString newText = senderPlainTextEdit->toPlainText();
+
+        if(senderPlainTextEdit == ui->plainTextEdit_effectContainerDataRaw)
+        {
+            if(!mECLoopProtection)
+            {
+                if(mEffConRawInputGuaranteedValid)
+                {
+                    mECLoopProtection = true;
+
+                    QByteArray dataRaw = Qx::ByteArray::RAWFromStringHex(newText);
+                    QString dataText = Qx::String::fromByteArray(dataRaw);
+
+                    if(getSelectedSoundContainer()->getInterpretedEffectContainerData() != dataText)
+                    {
+                        getSelectedSoundContainer()->setInterpretedEffectContainerData(dataText);
+                        setChangesSavedState(false);
+                    }
+                    ui->plainTextEdit_effectContainerDataString->setPlainText(dataText);
+
+                    // Push cursor to end
+                    ui->plainTextEdit_effectContainerDataRaw->moveCursor(QTextCursor::End);
+
+                    mEffConRawInputGuaranteedValid = false; // Clear valid flag
+                }
+                else
+                {
+                    // Ensure input is valid
+                    mEffConRawInputGuaranteedValid = true;
+                    senderPlainTextEdit->setPlainText(Qx::String::stripToHexOnly(newText).toUpper());
+                }
+            }
+
+            mECLoopProtection = false;
+        }
+        else if(senderPlainTextEdit == ui->plainTextEdit_effectContainerDataString)
+        {
+            if(!mECLoopProtection)
+            {
+                mECLoopProtection = true;
+                QByteArray dataRaw = Qx::ByteArray::RAWFromString(newText);
+                QString dataText = dataRaw.toHex().toUpper();
+
+                if(getSelectedSoundContainer()->getInterpretedEffectContainerData() != dataText)
+                {
+                    getSelectedSoundContainer()->setInterpretedEffectContainerData(newText);
+                    setChangesSavedState(false);
+                }
+                ui->plainTextEdit_effectContainerDataRaw->setPlainText(dataText);
+            }
+
+            mECLoopProtection = false;
+        }
+    }
+}
+
+//===============================================================================================================
+// PLAYLIST ITEM MAP
+//===============================================================================================================
+
+//-Constructor---------------------------------------------------------------------------------------------------
+MainWindow::PlaylistItemMap::PlaylistItemMap(const QTreeWidgetItem* treeItem, BSC* headBSC)
+    : mOriginalTreeItem(treeItem)
+{
+    // Index code to unravel
+    QString indexCode = treeItem->text(0).mid(treeItem->text(0).indexOf(BSC::Playlist::PLAYLIST_INDEX_SEP) + BSC::Playlist::PLAYLIST_INDEX_SEP.length());
+
+    // Number of segments
+    int segments = indexCode.count(BSC::Playlist::SUB_INDEX_LABEL_SEP) + 1;
+
+    assert(segments > 0);
+
+    // Unravel
+    if(segments == 1)
+    {
+        mIndexPath.append(indexCode.toInt());
+        mPlaylistPath.append(&headBSC->getPlaylistsR()[indexCode.toInt()]);
+        mPlaylistListPath.append(&headBSC->getPlaylistsR());
+    }
+    else
+    {
+        // Step through first segment
+        int end = indexCode.indexOf(BSC::Playlist::SUB_INDEX_LABEL_SEP);
+        mIndexPath.append(indexCode.left(end).toInt());
+        mPlaylistListPath.append(&headBSC->getPlaylistsR());
+        mPlaylistPath.append(&headBSC->getPlaylistsR()[indexCode.left(end).toInt()]);
+
+        // Step through middle segments
+        for(int i = 1; i < segments - 1; i++)
+        {
+            int start = end + 1;
+            end = indexCode.indexOf(BSC::Playlist::SUB_INDEX_LABEL_SEP, start);
+            mIndexPath.append(indexCode.mid(start, end - start).toInt());
+            mPlaylistListPath.append(&mPlaylistPath.last()->getSubPlaylistsR());
+            mPlaylistPath.append(&mPlaylistPath.last()->getSubPlaylistsR()[indexCode.mid(start, end - start).toInt()]);
+        }
+
+        // Step through last segment
+        mIndexPath.append(indexCode.mid(end + 1).toInt());
+        mPlaylistListPath.append((&mPlaylistPath.last()->getSubPlaylistsR()));
+        mPlaylistPath.append(&mPlaylistPath.last()->getSubPlaylistsR()[indexCode.mid(end + 1).toInt()]);
+    }
+}
+
+//-Class Functions--------------------------------------------------------------------------------------------
+//Public:
+QTreeWidgetItem* MainWindow::PlaylistItemMap::getItemRelativeToMap(QTreeWidget* treeWidget, const PlaylistItemMap itemMap, int depth, int target)
+{
+    assert(depth >= 0);
+
+    // Tree item to return
+    QTreeWidgetItem* relativeItem;
+
+    if(depth == 0)
+        relativeItem = treeWidget->topLevelItem(target);
+    else
+    {
+        // Get top level item
+        relativeItem = treeWidget->topLevelItem(itemMap.getTopLevelIndex());
+
+        // Iterate through middle children
+        for(int i = 1; i < depth; i++)
+            relativeItem = relativeItem->child(itemMap.getIndexAtLevel(i));
+
+        // Get target
+        relativeItem = relativeItem->child(target);
+    }
+
+    return relativeItem;
+}
+
+//-Instance Functions--------------------------------------------------------------------------------------------
+//Public:
+const QTreeWidgetItem* MainWindow::PlaylistItemMap::getOriginalTreeItem() const { return mOriginalTreeItem; }
+int MainWindow::PlaylistItemMap::getIndexAtLevel(int level) const { return mIndexPath.value(level); }
+BSC::Playlist* MainWindow::PlaylistItemMap::getPlaylistAtLevel(int level) const { return mPlaylistPath.value(level); }
+QList<BSC::Playlist>* MainWindow::PlaylistItemMap::getPlaylistListAtLevel(int level) const { return mPlaylistListPath.value(level); }
+int MainWindow::PlaylistItemMap::getTopLevelIndex() const { return mIndexPath.first(); }
+BSC::Playlist* MainWindow::PlaylistItemMap::getTopLeveLPlaylist() const { return mPlaylistPath.first(); }
+QList<BSC::Playlist>* MainWindow::PlaylistItemMap::getTopLevelPlaylistList() const { return mPlaylistListPath.first(); }
+int MainWindow::PlaylistItemMap::getTargetIndex() const { return mIndexPath.last(); }
+BSC::Playlist* MainWindow::PlaylistItemMap::getTargetPlaylist() const { return mPlaylistPath.last(); }
+QList<BSC::Playlist>* MainWindow::PlaylistItemMap::getTargetPlaylistList() const { return mPlaylistListPath.last(); }
+
+int MainWindow::PlaylistItemMap::getTargetParentIndex() const
+{
+    if(mIndexPath.length() < 2)
+        return -1;
+    else
+        return mIndexPath.value(mIndexPath.length() - 2);
+}
+
+BSC::Playlist* MainWindow::PlaylistItemMap::getTargetParentPlaylist() const
+{
+    if(mIndexPath.length() < 2)
+        return nullptr;
+    else
+        return mPlaylistPath.value(mPlaylistPath.length() - 2);
+}
+
+QList<BSC::Playlist>* MainWindow::PlaylistItemMap::getTargetParentPlaylistList() const
+{
+    if(mPlaylistListPath.length() < 2)
+        return nullptr;
+    else
+        return mPlaylistListPath.value(mPlaylistListPath.length() - 2);
+}
+
+bool MainWindow::PlaylistItemMap::targetIsTopLevel() const { return mIndexPath.length() == 1; }
+int MainWindow::PlaylistItemMap::targetDepth() const { return mIndexPath.length() - 1; }
+int MainWindow::PlaylistItemMap::length() const { return mIndexPath.length(); }
diff --git a/src/mainwindow.h b/src/mainwindow.h
new file mode 100644
index 0000000..f2bc43f
--- /dev/null
+++ b/src/mainwindow.h
@@ -0,0 +1,224 @@
+#ifndef MAINWINDOW_H
+#define MAINWINDOW_H
+
+#include "bsc.h"
+#include "smc.h"
+#include "smf.h"
+#include "wav.h"
+
+#include <QMainWindow>
+#include <QTreeWidget>
+#include <QTableWidget>
+#include <QDir>
+#include "version.h"
+
+namespace Ui {
+class MainWindow;
+}
+
+class MainWindow : public QMainWindow
+{
+    Q_OBJECT // Required for classes that use Qt elements
+
+//-Class Variables----------------------------------------------------------------------------------------------
+private:
+    static inline const QString MENU_FILE_FILTER = "Burnt Sound Container (*." + BSC::FILE_EXT + ")";
+    static inline const QString MENU_SAVE_AS_TITLE = "Save As";
+    static inline const QString MENU_SAVE_TITLE = "Save";
+    static inline const QString MENU_OPEN_TITLE = "Open";
+    static inline const QString MSG_SAVE_SUCCESS = "File ""%1"" was saved successfully.";
+    static inline const QString MSG_SAVE_FAIL = "Error saving ""%1""!";
+    static inline const QString MSG_SAVE_PROMPT_TXT = "The currently open file has unsaved changes.";
+    static inline const QString MSG_SAVE_PROMPT_EXIT_INFO_TXT = "Do you want to save the file before exiting?";
+    static inline const QString MSG_SAVE_PROMPT_ELSE_INFO_TXT = "Do you want to save the file before proceeding?";
+    static inline const QString MSG_OPEN_FILE_INVALID = """%1"" is not a valid BSC!";
+    static inline const QString MSG_EFF_CON_EDIT_WARN_TXT = "Caution! Editing the Effect Container region of Sound Containers directly can render the Entire "
+                                                        "BSC inoperable if performed incorrectly. Only edit this section if you know what you're doing.";
+    static inline const QString MSG_EFF_CON_EDIT_WARN_INFO_TXT = "Effect Container count must be 1 or greater before any data can be changed.";
+
+    static inline const QString MENU_CACHE_FILE_FILTER = "Speechmanager Cache (*." + SMC::FILE_EXT + ")";
+    static inline const QString MENU_CACHE_OPEN_TITLE = "Select Speechmanager Cache";
+    static inline const QString MENU_CACHE_FOLDER_TITLE = "Select folder to scan for BSC files";
+    static inline const QString MSG_CACHE_INVALID = """%1"" is not a valid Speechmanager Cache!";
+    static inline const QString MSG_CACHE_HAS_DUPES = "The selected Speechmanager contains duplicate entries that will be removed if you proceed. These entries are redundant"
+                                                      " and keeping them serves no purpose.";
+    static inline const QString MSG_CACHE_FOLDER_SUB_PROMPT = "Include sub-directories?";
+    static inline const QString MSG_CACHE_UPDATED_TXT = "The selected Speechmanager Cache was updated succesfully.";
+    static inline const QString MSG_CACHE_UPDATED_INFO_TXT = "Some detected files were already present in the cache and were skipped.";
+    static inline const QString MSG_CACHE_UP_TO_DATE = "The selected cache is already up-to-date with this directory. No changes were necessary.";
+    static inline const QString MSG_CACHE_FAIL = "Error writting ""%1""";
+    static inline const QString MSG_CACHE_INV_FILES_INFO = "Some files were skipped because they did not appear to be valid BSCs. See details below.";
+    static inline const QString MSG_CACHE_INV_FILES_DETAILS = "The following files appeared to be invalid and were skipped:";
+    static inline const QString MSG_CACHE_INV_FILES_CAT_BAD = "(Invalid data)";
+    static inline const QString MSG_CACHE_INV_FILES_CAT_SPACE = "(Space in filename)";
+
+    static inline const QString MENU_CACHE_NEW_TITLE = "Enter Speechmanager Cache Destina;tion";
+    static inline const QString MSG_CACHE_NEW_SUCCESS_TXT = "The Speechmanager Cache was created successfully.";
+
+    static inline const QString MENU_SMF_FILE_FILTER = "SMF Audio (*." + SMF::FILE_EXT + ")";
+    static inline const QString MENU_WAV_FILE_FILTER = "WAVE Audio (*." + WAV::FILE_EXT + ")";
+
+    static inline const QString MENU_CONV_SMF_IN_TITLE = "Select SMF to convert";
+    static inline const QString MENU_CONV_SMF_OUT_TITLE = "Enter output WAV destination";
+    static inline const QString MSG_CONV_SMF_INVALID = """%1"" is not a valid SMF file!";
+    static inline const QString MSG_CONV_SMF_SUCCESS = "Conversion completed successfully.";
+    static inline const QString MSG_CONV_SMF_FAIL = "Error writting ""%1""";
+
+    static inline const QString MENU_CONV_WAV_IN_TITLE = "Select WAV to convert";
+    static inline const QString MENU_CONV_WAV_OUT_TITLE = "Enter output SMF destination";
+    static inline const QString MSG_CONV_WAV_INVALID = """%1"" is not a valid WAVE file!";
+    static inline const QString MSG_CONV_WAV_SUCCESS = "Conversion completed successfully.";
+    static inline const QString MSG_CONV_WAV_FAIL = "Error writting ""%1""";
+
+    static inline const QString MSG_BATCH_ALL_FILE_EXST = """%1"" already exists. Do you want to overwrite this file?";
+    static inline const QString MSG_BATCH_ALL_ABORT = "Abort Conversion";
+    static inline const QString MSG_BATCH_ALL_ABORTED_TXT = "Batch conversion aborted by user.";
+    static inline const QString MSG_BATCH_ALL_ABORTED_INFO = "%1/%2 files were processed.";
+
+    static inline const QString MENU_BATCH_SMF_IN_TITLE = "Select folder to scan for SMF files";
+    static inline const QString MENU_BATCH_SMF_OUT_TITLE = "Select output folder";
+    static inline const QString MSG_BATCH_SMF_SUB_PROMPT = "Include sub-directories?";
+    static inline const QString MSG_BATCH_SMF_NO_FILES = "No SMF files found in %1";
+    static inline const QString MSG_BATCH_SMF_NO_VALID_FILES_TXT = "No valid/convertable SMF files found in %1";
+    static inline const QString MSG_BATCH_SMF_NO_VALID_FILES_INFO = "All present SMF files are corrupt, or experienced IO errors during conversion!";
+    static inline const QString MSG_BATCH_SMF_SUCCESS_TXT = "Batch SMF conversion completed successfully.";
+    static inline const QString MSG_BATCH_SMF_INV_FILES_INFO = "Some files were skipped due to read/write issues. See details below";
+    static inline const QString MSG_BATCH_SMF_INV_FILES_DETAILS  = "The following files were skipped:";
+    static inline const QString MSG_BATCH_SMF_INV_FILES_CAT_BAD = "(Invalid data)";
+    static inline const QString MSG_BATCH_SMF_IN_PROGRESS = "Converting SMF files to WAV...";
+
+    static inline const QString MENU_BATCH_WAV_IN_TITLE = "Select folder to scan for WAV files";
+    static inline const QString MENU_BATCH_WAV_OUT_TITLE = "Select output folder";
+    static inline const QString MSG_BATCH_WAV_SUB_PROMPT = "Include sub-directories?";
+    static inline const QString MSG_BATCH_WAV_NO_FILES = "No WAV files found in %1";
+    static inline const QString MSG_BATCH_WAV_NO_VALID_FILES_TXT = "No valid/convertable WAV files found in %1";
+    static inline const QString MSG_BATCH_WAV_NO_VALID_FILES_INFO = "All present WAV files are corrupt, or experienced IO errors during conversion!";
+    static inline const QString MSG_BATCH_WAV_SUCCESS_TXT = "Batch WAV conversion completed successfully.";
+    static inline const QString MSG_BATCH_WAV_INV_FILES_INFO = "Some files were skipped due to read/write issues. See details below";
+    static inline const QString MSG_BATCH_WAV_INV_FILES_DETAILS = "The following files were skipped:";
+    static inline const QString MSG_BATCH_WAV_INV_FILES_CAT_BAD = "(Invalid data)";
+    static inline const QString MSG_BATCH_WAV_IN_PROGRESS = "Converting WAV files to SMF...";
+
+    static inline const QString MSG_ABOUT_TXT = "BSCWorks " + QString::fromStdString(VER_PRODUCTVERSION_STR) + " @oblivioncth";
+    static inline const QString MSG_ABOUT_INFO_TXT = "Distrubted under the GNU General Public License V3.0. See " + QString::fromStdString(VER_COMPANYDOMAIN_STR) + "/BSCWorks for more information.";
+
+//-Instance Variables--------------------------------------------------------------------------------------------
+private:
+    Ui::MainWindow *ui; 
+    QHash<QWidget*,std::function<bool(void)>> mWidgetEnableConditionMap;
+    QHash<QTreeWidgetItem, bool> mTreeWidgetItemExpandedState;
+    std::unique_ptr<BSC> mBSCPtr;
+    bool mSlotsEnabled = false;
+    bool mECLoopProtection = false;
+    bool mAlteringSoundContainerBoxEntries = false;
+    bool mFileOpen = false;
+    bool mAllChangesSaved = true;
+    bool mGaveEffectContainerWarning = false;
+    QString mCurrentFileDir = QDir::currentPath();
+    QString mCurrentFileName = "";
+
+    //UI Enable Groups
+    QWidgetList mEnableGroupTopLevel;
+    QWidgetList mEnableGroupPlaylistSel;
+    QWidgetList mEnableGroupPlaylistSet;
+    QWidgetList mEnableGroupEffectBeh;
+    QWidgetList mEnableGroupSoundCon;
+
+    // Slot flags
+    bool mEffConRawInputGuaranteedValid = false;
+
+//-Constructor---------------------------------------------------------------------------------------------------
+public:
+    explicit MainWindow(QWidget *parent = nullptr);
+
+//-Destructor----------------------------------------------------------------------------------------------------
+public:
+    ~MainWindow();
+
+//-Instance Functions--------------------------------------------------------------------------------------------
+private:
+    void initializeForms();
+    void initializeWidgetEnableConditionMap();
+    void initializeEnableWidgetGroups();
+    void updatePrimaryWidgetStates();
+    void updateSecondaryWidgetStates(QWidgetList widgetsToUpdate);
+    void recursivePlaylistEnumerator(QTreeWidgetItem* parentTreeItem, BSC::Playlist &parentPlaylist, QString parentIndexMarker); // Only reads playlists so a copy is fine (2nd arg)
+    void updateBSCTopLevel();
+    void updatePlaylists();
+    void updateEntirePlaylist();
+    void updateEffectBehaviors();
+    void updateSoundContainers();
+    void updateSoundContainerGroup();
+    void updateVoiceGroupBack(int frontIndex);
+    void updateLinkedFiles();
+    void setChangesSavedState(bool changesSaved);
+    bool saveChangesPrompt(bool exit);
+    void openBSCFile(QFile& bscFile);
+    BSC::Playlist* getSelectedPlaylist() const;
+    BSC::SoundContainer* getSelectedSoundContainer() const;
+    void storeTreeItemExpandedStates() const;
+    void cacheSubRoutine(bool existing);
+    void execIOReport(Qx::IO::IOOpReport ioReport);
+
+//-Overrides----------------------------------------------------------------------------------------------------
+private:
+    void closeEvent (QCloseEvent* event);
+    bool eventFilter(QObject* target, QEvent* event);
+    void dragEnterEvent(QDragEnterEvent* event);
+    void dropEvent(QDropEvent* event);
+
+//-Slots---------------------------------------------------------------------------------------------------------
+private slots: // Start with "all" to avoid Qt calling "connectSlotsByName" on these slots (slots that start with "on_")
+    void all_on_menuAction_triggered();
+    void all_on_treeWidget_currentItemChanged();
+    void all_on_tableWidget_itemChanged(QTableWidgetItem* item);
+    void all_on_tableWidget_currentItemChanged();
+    void all_on_linedEdit_textEdited();
+    void all_on_comboBox_currentIndexChanged(int newIndex);
+    void all_on_spinBox_valueChanged(int newValue);
+    void all_on_doubleSpinBox_valueChanged(double newValue);
+    void all_on_checkBox_stateChanged(int newState);
+    void all_on_toolButton_clicked();
+    void all_on_plainTextEdit_textChanged();
+
+//-Inner Classes---------------------------------------------------------------------------------------
+private:
+    class PlaylistItemMap
+    {
+        //-Instance Variables--------------------------------------------------------------------------------------------
+        private:
+            const QTreeWidgetItem* mOriginalTreeItem;
+            QVector<int> mIndexPath;
+            QList<BSC::Playlist*> mPlaylistPath;
+            QList<QList<BSC::Playlist>*> mPlaylistListPath;
+
+        //-Constructor---------------------------------------------------------------------------------------------------
+        public:
+            PlaylistItemMap(const QTreeWidgetItem* treeItem, BSC* headBSC);
+
+        //-Class Functions-----------------------------------------------------------------------------------------------
+        public:
+            static QTreeWidgetItem* getItemRelativeToMap(QTreeWidget* treeWidget, const PlaylistItemMap itemMap, int depth, int target);
+
+        //-Instance Functions--------------------------------------------------------------------------------------------
+        public:
+            const QTreeWidgetItem* getOriginalTreeItem() const;
+            int getIndexAtLevel(int level) const;
+            BSC::Playlist* getPlaylistAtLevel(int level) const;
+            QList<BSC::Playlist>* getPlaylistListAtLevel(int level) const;
+            int getTopLevelIndex() const;
+            BSC::Playlist* getTopLeveLPlaylist() const;
+            QList<BSC::Playlist>* getTopLevelPlaylistList() const;
+            int getTargetIndex() const;
+            BSC::Playlist* getTargetPlaylist() const;
+            QList<BSC::Playlist>* getTargetPlaylistList() const;
+            int getTargetParentIndex() const;
+            BSC::Playlist* getTargetParentPlaylist() const;
+            QList<BSC::Playlist>* getTargetParentPlaylistList() const;
+            int targetDepth() const;
+            bool targetIsTopLevel() const;
+            int length() const;
+    };
+};
+
+#endif // MAINWINDOW_H
diff --git a/src/mainwindow.ui b/src/mainwindow.ui
new file mode 100644
index 0000000..b446b5a
--- /dev/null
+++ b/src/mainwindow.ui
@@ -0,0 +1,2954 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>MainWindow</class>
+ <widget class="QMainWindow" name="MainWindow">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>958</width>
+    <height>843</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>MainWindow</string>
+  </property>
+  <widget class="QWidget" name="centralWidget">
+   <widget class="QGroupBox" name="groupBox_mainInfo">
+    <property name="geometry">
+     <rect>
+      <x>10</x>
+      <y>10</y>
+      <width>301</width>
+      <height>111</height>
+     </rect>
+    </property>
+    <property name="title">
+     <string>Top Level Info</string>
+    </property>
+    <layout class="QGridLayout" name="gridLayout">
+     <item row="1" column="0">
+      <widget class="QLabel" name="label_formatVer">
+       <property name="text">
+        <string>Format Version: </string>
+       </property>
+      </widget>
+     </item>
+     <item row="0" column="0">
+      <widget class="QLabel" name="label_tweener">
+       <property name="frameShape">
+        <enum>QFrame::NoFrame</enum>
+       </property>
+       <property name="text">
+        <string>0x04 - 0x08:</string>
+       </property>
+      </widget>
+     </item>
+     <item row="2" column="0">
+      <widget class="QLabel" name="label_playlistCount">
+       <property name="text">
+        <string>Playlist Count:</string>
+       </property>
+      </widget>
+     </item>
+     <item row="2" column="1">
+      <widget class="QLineEdit" name="lineEdit_playlistCount">
+       <property name="sizePolicy">
+        <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
+         <horstretch>0</horstretch>
+         <verstretch>0</verstretch>
+        </sizepolicy>
+       </property>
+       <property name="alignment">
+        <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+       </property>
+       <property name="readOnly">
+        <bool>true</bool>
+       </property>
+      </widget>
+     </item>
+     <item row="1" column="1">
+      <widget class="QLineEdit" name="lineEdit_formatVer">
+       <property name="sizePolicy">
+        <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
+         <horstretch>0</horstretch>
+         <verstretch>0</verstretch>
+        </sizepolicy>
+       </property>
+       <property name="alignment">
+        <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+       </property>
+       <property name="readOnly">
+        <bool>true</bool>
+       </property>
+      </widget>
+     </item>
+     <item row="0" column="1">
+      <widget class="QLineEdit" name="lineEdit_tweener">
+       <property name="sizePolicy">
+        <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
+         <horstretch>0</horstretch>
+         <verstretch>0</verstretch>
+        </sizepolicy>
+       </property>
+       <property name="alignment">
+        <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+       </property>
+       <property name="readOnly">
+        <bool>true</bool>
+       </property>
+      </widget>
+     </item>
+    </layout>
+   </widget>
+   <widget class="QGroupBox" name="groupBox_playlistSel">
+    <property name="geometry">
+     <rect>
+      <x>10</x>
+      <y>130</y>
+      <width>301</width>
+      <height>311</height>
+     </rect>
+    </property>
+    <property name="title">
+     <string>Playlist Select</string>
+    </property>
+    <widget class="QTreeWidget" name="treeWidget_playlists">
+     <property name="geometry">
+      <rect>
+       <x>10</x>
+       <y>20</y>
+       <width>241</width>
+       <height>271</height>
+      </rect>
+     </property>
+     <attribute name="headerVisible">
+      <bool>false</bool>
+     </attribute>
+     <column>
+      <property name="text">
+       <string notr="true">1</string>
+      </property>
+     </column>
+    </widget>
+    <widget class="QToolButton" name="toolButton_playlistsRemove">
+     <property name="enabled">
+      <bool>true</bool>
+     </property>
+     <property name="geometry">
+      <rect>
+       <x>260</x>
+       <y>60</y>
+       <width>31</width>
+       <height>31</height>
+      </rect>
+     </property>
+     <property name="toolTip">
+      <string>Remove Playlist</string>
+     </property>
+     <property name="text">
+      <string>...</string>
+     </property>
+     <property name="icon">
+      <iconset>
+       <normalon>:/res/Minus_Enabled.png</normalon>
+      </iconset>
+     </property>
+     <property name="toolButtonStyle">
+      <enum>Qt::ToolButtonIconOnly</enum>
+     </property>
+     <property name="arrowType">
+      <enum>Qt::NoArrow</enum>
+     </property>
+    </widget>
+    <widget class="QToolButton" name="toolButton_playlistsUp">
+     <property name="enabled">
+      <bool>true</bool>
+     </property>
+     <property name="geometry">
+      <rect>
+       <x>260</x>
+       <y>220</y>
+       <width>31</width>
+       <height>31</height>
+      </rect>
+     </property>
+     <property name="toolTip">
+      <string>Move Playlist Up</string>
+     </property>
+     <property name="text">
+      <string>...</string>
+     </property>
+     <property name="toolButtonStyle">
+      <enum>Qt::ToolButtonIconOnly</enum>
+     </property>
+     <property name="arrowType">
+      <enum>Qt::UpArrow</enum>
+     </property>
+    </widget>
+    <widget class="QToolButton" name="toolButton_playlistsDown">
+     <property name="enabled">
+      <bool>true</bool>
+     </property>
+     <property name="geometry">
+      <rect>
+       <x>260</x>
+       <y>260</y>
+       <width>31</width>
+       <height>31</height>
+      </rect>
+     </property>
+     <property name="toolTip">
+      <string>Move Playlist Down</string>
+     </property>
+     <property name="text">
+      <string>...</string>
+     </property>
+     <property name="toolButtonStyle">
+      <enum>Qt::ToolButtonIconOnly</enum>
+     </property>
+     <property name="arrowType">
+      <enum>Qt::DownArrow</enum>
+     </property>
+    </widget>
+    <widget class="QToolButton" name="toolButton_playlistsAdd">
+     <property name="enabled">
+      <bool>true</bool>
+     </property>
+     <property name="geometry">
+      <rect>
+       <x>260</x>
+       <y>20</y>
+       <width>31</width>
+       <height>31</height>
+      </rect>
+     </property>
+     <property name="toolTip">
+      <string>Add New Playlist</string>
+     </property>
+     <property name="text">
+      <string>...</string>
+     </property>
+     <property name="icon">
+      <iconset>
+       <normalon>:/res/Plus_Enabled.png</normalon>
+      </iconset>
+     </property>
+     <property name="toolButtonStyle">
+      <enum>Qt::ToolButtonIconOnly</enum>
+     </property>
+     <property name="arrowType">
+      <enum>Qt::NoArrow</enum>
+     </property>
+    </widget>
+    <widget class="QToolButton" name="toolButton_playlistsOut">
+     <property name="enabled">
+      <bool>true</bool>
+     </property>
+     <property name="geometry">
+      <rect>
+       <x>260</x>
+       <y>140</y>
+       <width>31</width>
+       <height>31</height>
+      </rect>
+     </property>
+     <property name="toolTip">
+      <string>Pop Playlist Up One Level</string>
+     </property>
+     <property name="text">
+      <string>...</string>
+     </property>
+     <property name="toolButtonStyle">
+      <enum>Qt::ToolButtonIconOnly</enum>
+     </property>
+     <property name="arrowType">
+      <enum>Qt::LeftArrow</enum>
+     </property>
+    </widget>
+    <widget class="QToolButton" name="toolButton_playlistsIn">
+     <property name="enabled">
+      <bool>true</bool>
+     </property>
+     <property name="geometry">
+      <rect>
+       <x>260</x>
+       <y>180</y>
+       <width>31</width>
+       <height>31</height>
+      </rect>
+     </property>
+     <property name="toolTip">
+      <string>Push Playlist Down One Level</string>
+     </property>
+     <property name="text">
+      <string>...</string>
+     </property>
+     <property name="toolButtonStyle">
+      <enum>Qt::ToolButtonIconOnly</enum>
+     </property>
+     <property name="arrowType">
+      <enum>Qt::RightArrow</enum>
+     </property>
+    </widget>
+    <widget class="QToolButton" name="toolButton_playlistsCopy">
+     <property name="enabled">
+      <bool>true</bool>
+     </property>
+     <property name="geometry">
+      <rect>
+       <x>260</x>
+       <y>100</y>
+       <width>31</width>
+       <height>31</height>
+      </rect>
+     </property>
+     <property name="toolTip">
+      <string>Duplicate Playlist</string>
+     </property>
+     <property name="text">
+      <string>...</string>
+     </property>
+     <property name="icon">
+      <iconset resource="../resources.qrc">
+       <normaloff>:/res/Copy_Enabled.png</normaloff>:/res/Copy_Enabled.png</iconset>
+     </property>
+     <property name="toolButtonStyle">
+      <enum>Qt::ToolButtonIconOnly</enum>
+     </property>
+     <property name="arrowType">
+      <enum>Qt::NoArrow</enum>
+     </property>
+    </widget>
+   </widget>
+   <widget class="QGroupBox" name="groupBox_playlistSet">
+    <property name="geometry">
+     <rect>
+      <x>10</x>
+      <y>450</y>
+      <width>301</width>
+      <height>321</height>
+     </rect>
+    </property>
+    <property name="title">
+     <string>Playlist Settings</string>
+    </property>
+    <widget class="QLabel" name="label_playbackMode">
+     <property name="geometry">
+      <rect>
+       <x>10</x>
+       <y>20</y>
+       <width>81</width>
+       <height>21</height>
+      </rect>
+     </property>
+     <property name="frameShape">
+      <enum>QFrame::NoFrame</enum>
+     </property>
+     <property name="text">
+      <string>Playback Mode:</string>
+     </property>
+    </widget>
+    <widget class="QComboBox" name="comboBox_playbackMode">
+     <property name="enabled">
+      <bool>true</bool>
+     </property>
+     <property name="geometry">
+      <rect>
+       <x>180</x>
+       <y>20</y>
+       <width>111</width>
+       <height>22</height>
+      </rect>
+     </property>
+     <property name="editable">
+      <bool>false</bool>
+     </property>
+    </widget>
+    <widget class="QLabel" name="label_maxInst">
+     <property name="geometry">
+      <rect>
+       <x>10</x>
+       <y>50</y>
+       <width>81</width>
+       <height>21</height>
+      </rect>
+     </property>
+     <property name="frameShape">
+      <enum>QFrame::NoFrame</enum>
+     </property>
+     <property name="text">
+      <string>Max Instances:</string>
+     </property>
+    </widget>
+    <widget class="QComboBox" name="comboBox_maxInst">
+     <property name="enabled">
+      <bool>true</bool>
+     </property>
+     <property name="geometry">
+      <rect>
+       <x>180</x>
+       <y>50</y>
+       <width>111</width>
+       <height>22</height>
+      </rect>
+     </property>
+     <property name="editable">
+      <bool>false</bool>
+     </property>
+    </widget>
+    <widget class="QComboBox" name="comboBox_poly">
+     <property name="enabled">
+      <bool>true</bool>
+     </property>
+     <property name="geometry">
+      <rect>
+       <x>180</x>
+       <y>80</y>
+       <width>111</width>
+       <height>22</height>
+      </rect>
+     </property>
+     <property name="editable">
+      <bool>false</bool>
+     </property>
+    </widget>
+    <widget class="QLabel" name="label_poly">
+     <property name="geometry">
+      <rect>
+       <x>10</x>
+       <y>80</y>
+       <width>81</width>
+       <height>21</height>
+      </rect>
+     </property>
+     <property name="frameShape">
+      <enum>QFrame::NoFrame</enum>
+     </property>
+     <property name="text">
+      <string>Polyphony:</string>
+     </property>
+    </widget>
+    <widget class="QLabel" name="label_repeatTimeMin">
+     <property name="geometry">
+      <rect>
+       <x>10</x>
+       <y>110</y>
+       <width>161</width>
+       <height>21</height>
+      </rect>
+     </property>
+     <property name="text">
+      <string>Repeat Time Min (ms) (0 = Inf.):</string>
+     </property>
+    </widget>
+    <widget class="QLabel" name="label_repeatTimeMax">
+     <property name="geometry">
+      <rect>
+       <x>10</x>
+       <y>140</y>
+       <width>161</width>
+       <height>21</height>
+      </rect>
+     </property>
+     <property name="text">
+      <string>Repeat Time Max (ms) (0 = Inf.):</string>
+     </property>
+    </widget>
+    <widget class="QLabel" name="label_repeatCountMin">
+     <property name="geometry">
+      <rect>
+       <x>10</x>
+       <y>170</y>
+       <width>161</width>
+       <height>21</height>
+      </rect>
+     </property>
+     <property name="text">
+      <string>Repeat Count Min (0 = Inf.):</string>
+     </property>
+    </widget>
+    <widget class="QLabel" name="label_repeatCountMax">
+     <property name="geometry">
+      <rect>
+       <x>10</x>
+       <y>200</y>
+       <width>161</width>
+       <height>21</height>
+      </rect>
+     </property>
+     <property name="text">
+      <string>Repeat Count Max (0 = Inf.):</string>
+     </property>
+    </widget>
+    <widget class="QSpinBox" name="spinBox_repeatTimeMin">
+     <property name="geometry">
+      <rect>
+       <x>231</x>
+       <y>110</y>
+       <width>61</width>
+       <height>22</height>
+      </rect>
+     </property>
+     <property name="alignment">
+      <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+     </property>
+     <property name="maximum">
+      <number>999999999</number>
+     </property>
+    </widget>
+    <widget class="QSpinBox" name="spinBox_repeatTimeMax">
+     <property name="geometry">
+      <rect>
+       <x>230</x>
+       <y>140</y>
+       <width>61</width>
+       <height>22</height>
+      </rect>
+     </property>
+     <property name="alignment">
+      <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+     </property>
+     <property name="maximum">
+      <number>999999999</number>
+     </property>
+    </widget>
+    <widget class="QSpinBox" name="spinBox_repeatCountMin">
+     <property name="geometry">
+      <rect>
+       <x>230</x>
+       <y>170</y>
+       <width>61</width>
+       <height>22</height>
+      </rect>
+     </property>
+     <property name="alignment">
+      <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+     </property>
+     <property name="maximum">
+      <number>999999999</number>
+     </property>
+    </widget>
+    <widget class="QSpinBox" name="spinBox_repeatCountMax">
+     <property name="geometry">
+      <rect>
+       <x>230</x>
+       <y>200</y>
+       <width>61</width>
+       <height>22</height>
+      </rect>
+     </property>
+     <property name="alignment">
+      <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+     </property>
+     <property name="maximum">
+      <number>999999999</number>
+     </property>
+    </widget>
+    <widget class="QSpinBox" name="spinBox_randomPlaylistWeight">
+     <property name="geometry">
+      <rect>
+       <x>230</x>
+       <y>230</y>
+       <width>61</width>
+       <height>22</height>
+      </rect>
+     </property>
+     <property name="alignment">
+      <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+     </property>
+     <property name="maximum">
+      <number>999999999</number>
+     </property>
+    </widget>
+    <widget class="QLabel" name="label_randomPlaylistWeight">
+     <property name="geometry">
+      <rect>
+       <x>10</x>
+       <y>230</y>
+       <width>201</width>
+       <height>21</height>
+      </rect>
+     </property>
+     <property name="text">
+      <string>Weight (RandomPlaylist Mode) [1 - 100]:</string>
+     </property>
+    </widget>
+    <widget class="QLabel" name="label_length">
+     <property name="geometry">
+      <rect>
+       <x>10</x>
+       <y>260</y>
+       <width>161</width>
+       <height>21</height>
+      </rect>
+     </property>
+     <property name="text">
+      <string>Length (ms) (0 = normal):</string>
+     </property>
+    </widget>
+    <widget class="QDoubleSpinBox" name="doubleSpinBox_length">
+     <property name="geometry">
+      <rect>
+       <x>230</x>
+       <y>260</y>
+       <width>61</width>
+       <height>22</height>
+      </rect>
+     </property>
+     <property name="alignment">
+      <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+     </property>
+     <property name="maximum">
+      <double>339999999999999996123846586046231871488.000000000000000</double>
+     </property>
+    </widget>
+    <widget class="QDoubleSpinBox" name="doubleSpinBox_releaseTime">
+     <property name="geometry">
+      <rect>
+       <x>230</x>
+       <y>290</y>
+       <width>61</width>
+       <height>22</height>
+      </rect>
+     </property>
+     <property name="alignment">
+      <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+     </property>
+     <property name="maximum">
+      <double>339999999999999996123846586046231871488.000000000000000</double>
+     </property>
+    </widget>
+    <widget class="QLabel" name="label_releaseTime">
+     <property name="geometry">
+      <rect>
+       <x>10</x>
+       <y>290</y>
+       <width>161</width>
+       <height>21</height>
+      </rect>
+     </property>
+     <property name="text">
+      <string>Release Time (s) (0 = Off):</string>
+     </property>
+    </widget>
+   </widget>
+   <widget class="QGroupBox" name="groupBox_effectBehaviors">
+    <property name="geometry">
+     <rect>
+      <x>325</x>
+      <y>10</y>
+      <width>621</width>
+      <height>231</height>
+     </rect>
+    </property>
+    <property name="title">
+     <string>Effect Behaviors</string>
+    </property>
+    <widget class="QTableWidget" name="tableWidget_effectBehaviors">
+     <property name="geometry">
+      <rect>
+       <x>10</x>
+       <y>20</y>
+       <width>331</width>
+       <height>192</height>
+      </rect>
+     </property>
+     <property name="frameShadow">
+      <enum>QFrame::Sunken</enum>
+     </property>
+     <property name="selectionBehavior">
+      <enum>QAbstractItemView::SelectRows</enum>
+     </property>
+     <property name="cornerButtonEnabled">
+      <bool>false</bool>
+     </property>
+     <property name="columnCount">
+      <number>1</number>
+     </property>
+     <attribute name="horizontalHeaderVisible">
+      <bool>false</bool>
+     </attribute>
+     <attribute name="horizontalHeaderStretchLastSection">
+      <bool>true</bool>
+     </attribute>
+     <column/>
+    </widget>
+    <widget class="QToolButton" name="toolButton_effectBehaviorsAdd">
+     <property name="geometry">
+      <rect>
+       <x>350</x>
+       <y>20</y>
+       <width>31</width>
+       <height>31</height>
+      </rect>
+     </property>
+     <property name="toolTip">
+      <string>Add New Effect Behaior</string>
+     </property>
+     <property name="text">
+      <string>...</string>
+     </property>
+     <property name="icon">
+      <iconset>
+       <normalon>:/res/Plus_Enabled.png</normalon>
+      </iconset>
+     </property>
+     <property name="toolButtonStyle">
+      <enum>Qt::ToolButtonIconOnly</enum>
+     </property>
+     <property name="arrowType">
+      <enum>Qt::NoArrow</enum>
+     </property>
+    </widget>
+    <widget class="QToolButton" name="toolButton_effectBehaviorsRemove">
+     <property name="geometry">
+      <rect>
+       <x>350</x>
+       <y>60</y>
+       <width>31</width>
+       <height>31</height>
+      </rect>
+     </property>
+     <property name="toolTip">
+      <string>Remove Effect Behavior</string>
+     </property>
+     <property name="text">
+      <string>...</string>
+     </property>
+     <property name="icon">
+      <iconset>
+       <normalon>:/res/Minus_Enabled.png</normalon>
+      </iconset>
+     </property>
+     <property name="toolButtonStyle">
+      <enum>Qt::ToolButtonIconOnly</enum>
+     </property>
+     <property name="arrowType">
+      <enum>Qt::NoArrow</enum>
+     </property>
+    </widget>
+    <widget class="QToolButton" name="toolButton_effectBehaviorsDown">
+     <property name="geometry">
+      <rect>
+       <x>350</x>
+       <y>180</y>
+       <width>31</width>
+       <height>31</height>
+      </rect>
+     </property>
+     <property name="toolTip">
+      <string>Move Effect Behavior Down</string>
+     </property>
+     <property name="text">
+      <string>...</string>
+     </property>
+     <property name="toolButtonStyle">
+      <enum>Qt::ToolButtonIconOnly</enum>
+     </property>
+     <property name="arrowType">
+      <enum>Qt::DownArrow</enum>
+     </property>
+    </widget>
+    <widget class="QToolButton" name="toolButton_effectBehaviorsUp">
+     <property name="geometry">
+      <rect>
+       <x>350</x>
+       <y>140</y>
+       <width>31</width>
+       <height>31</height>
+      </rect>
+     </property>
+     <property name="toolTip">
+      <string>Move Effect Behavior Up</string>
+     </property>
+     <property name="text">
+      <string>...</string>
+     </property>
+     <property name="toolButtonStyle">
+      <enum>Qt::ToolButtonIconOnly</enum>
+     </property>
+     <property name="arrowType">
+      <enum>Qt::UpArrow</enum>
+     </property>
+    </widget>
+    <widget class="QCheckBox" name="checkBox_parentBehaviorOverride">
+     <property name="geometry">
+      <rect>
+       <x>410</x>
+       <y>20</y>
+       <width>151</width>
+       <height>21</height>
+      </rect>
+     </property>
+     <property name="layoutDirection">
+      <enum>Qt::RightToLeft</enum>
+     </property>
+     <property name="text">
+      <string> Override parent behaviors</string>
+     </property>
+    </widget>
+    <widget class="QLabel" name="label_emitter">
+     <property name="geometry">
+      <rect>
+       <x>410</x>
+       <y>50</y>
+       <width>51</width>
+       <height>20</height>
+      </rect>
+     </property>
+     <property name="text">
+      <string>  Emitter</string>
+     </property>
+    </widget>
+    <widget class="QComboBox" name="comboBox_emitter">
+     <property name="geometry">
+      <rect>
+       <x>460</x>
+       <y>50</y>
+       <width>141</width>
+       <height>22</height>
+      </rect>
+     </property>
+    </widget>
+    <widget class="QToolButton" name="toolButton_effectBehaviorsCopy">
+     <property name="enabled">
+      <bool>true</bool>
+     </property>
+     <property name="geometry">
+      <rect>
+       <x>350</x>
+       <y>100</y>
+       <width>31</width>
+       <height>31</height>
+      </rect>
+     </property>
+     <property name="toolTip">
+      <string>Duplicate Effect Behavior</string>
+     </property>
+     <property name="text">
+      <string>...</string>
+     </property>
+     <property name="icon">
+      <iconset resource="../resources.qrc">
+       <normaloff>:/res/Copy_Enabled.png</normaloff>:/res/Copy_Enabled.png</iconset>
+     </property>
+     <property name="toolButtonStyle">
+      <enum>Qt::ToolButtonIconOnly</enum>
+     </property>
+     <property name="arrowType">
+      <enum>Qt::NoArrow</enum>
+     </property>
+    </widget>
+   </widget>
+   <widget class="QGroupBox" name="groupBox_soundContainers">
+    <property name="geometry">
+     <rect>
+      <x>325</x>
+      <y>250</y>
+      <width>621</width>
+      <height>521</height>
+     </rect>
+    </property>
+    <property name="title">
+     <string>Sound Containers</string>
+    </property>
+    <widget class="QTableWidget" name="tableWidget_linkedFiles">
+     <property name="geometry">
+      <rect>
+       <x>360</x>
+       <y>40</y>
+       <width>211</width>
+       <height>191</height>
+      </rect>
+     </property>
+     <property name="sizePolicy">
+      <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
+       <horstretch>0</horstretch>
+       <verstretch>0</verstretch>
+      </sizepolicy>
+     </property>
+     <property name="frameShadow">
+      <enum>QFrame::Sunken</enum>
+     </property>
+     <property name="selectionBehavior">
+      <enum>QAbstractItemView::SelectRows</enum>
+     </property>
+     <property name="textElideMode">
+      <enum>Qt::ElideMiddle</enum>
+     </property>
+     <property name="cornerButtonEnabled">
+      <bool>false</bool>
+     </property>
+     <attribute name="horizontalHeaderVisible">
+      <bool>false</bool>
+     </attribute>
+    </widget>
+    <widget class="QToolButton" name="toolButton_linkedFilesAdd">
+     <property name="geometry">
+      <rect>
+       <x>580</x>
+       <y>40</y>
+       <width>31</width>
+       <height>31</height>
+      </rect>
+     </property>
+     <property name="toolTip">
+      <string>Add New Linked File</string>
+     </property>
+     <property name="text">
+      <string>...</string>
+     </property>
+     <property name="icon">
+      <iconset>
+       <normalon>:/res/Plus_Enabled.png</normalon>
+      </iconset>
+     </property>
+     <property name="toolButtonStyle">
+      <enum>Qt::ToolButtonIconOnly</enum>
+     </property>
+     <property name="arrowType">
+      <enum>Qt::NoArrow</enum>
+     </property>
+    </widget>
+    <widget class="QToolButton" name="toolButton_linkedFilesRemove">
+     <property name="geometry">
+      <rect>
+       <x>580</x>
+       <y>80</y>
+       <width>31</width>
+       <height>31</height>
+      </rect>
+     </property>
+     <property name="toolTip">
+      <string>Remove Linked File</string>
+     </property>
+     <property name="text">
+      <string>...</string>
+     </property>
+     <property name="icon">
+      <iconset>
+       <normalon>:/res/Minus_Enabled.png</normalon>
+      </iconset>
+     </property>
+     <property name="toolButtonStyle">
+      <enum>Qt::ToolButtonIconOnly</enum>
+     </property>
+     <property name="arrowType">
+      <enum>Qt::NoArrow</enum>
+     </property>
+    </widget>
+    <widget class="QToolButton" name="toolButton_linkedFilesDown">
+     <property name="geometry">
+      <rect>
+       <x>580</x>
+       <y>200</y>
+       <width>31</width>
+       <height>31</height>
+      </rect>
+     </property>
+     <property name="toolTip">
+      <string>Move Linked File Down</string>
+     </property>
+     <property name="text">
+      <string>...</string>
+     </property>
+     <property name="toolButtonStyle">
+      <enum>Qt::ToolButtonIconOnly</enum>
+     </property>
+     <property name="arrowType">
+      <enum>Qt::DownArrow</enum>
+     </property>
+    </widget>
+    <widget class="QToolButton" name="toolButton_linkedFilesUp">
+     <property name="geometry">
+      <rect>
+       <x>580</x>
+       <y>160</y>
+       <width>31</width>
+       <height>31</height>
+      </rect>
+     </property>
+     <property name="toolTip">
+      <string>Move Linked File Up</string>
+     </property>
+     <property name="text">
+      <string>...</string>
+     </property>
+     <property name="toolButtonStyle">
+      <enum>Qt::ToolButtonIconOnly</enum>
+     </property>
+     <property name="arrowType">
+      <enum>Qt::UpArrow</enum>
+     </property>
+    </widget>
+    <widget class="QComboBox" name="comboBox_soundContainer">
+     <property name="geometry">
+      <rect>
+       <x>10</x>
+       <y>20</y>
+       <width>121</width>
+       <height>22</height>
+      </rect>
+     </property>
+    </widget>
+    <widget class="QLabel" name="label_voiceGroup">
+     <property name="geometry">
+      <rect>
+       <x>10</x>
+       <y>60</y>
+       <width>61</width>
+       <height>21</height>
+      </rect>
+     </property>
+     <property name="text">
+      <string>Voice Group:</string>
+     </property>
+    </widget>
+    <widget class="QCheckBox" name="checkBox_3D">
+     <property name="geometry">
+      <rect>
+       <x>9</x>
+       <y>90</y>
+       <width>31</width>
+       <height>21</height>
+      </rect>
+     </property>
+     <property name="layoutDirection">
+      <enum>Qt::LeftToRight</enum>
+     </property>
+     <property name="text">
+      <string>3D</string>
+     </property>
+    </widget>
+    <widget class="QCheckBox" name="checkBox_loop">
+     <property name="geometry">
+      <rect>
+       <x>60</x>
+       <y>90</y>
+       <width>41</width>
+       <height>21</height>
+      </rect>
+     </property>
+     <property name="layoutDirection">
+      <enum>Qt::LeftToRight</enum>
+     </property>
+     <property name="text">
+      <string>Loop</string>
+     </property>
+    </widget>
+    <widget class="QCheckBox" name="checkBox_speedVolumeTrigger">
+     <property name="geometry">
+      <rect>
+       <x>120</x>
+       <y>90</y>
+       <width>131</width>
+       <height>21</height>
+      </rect>
+     </property>
+     <property name="layoutDirection">
+      <enum>Qt::LeftToRight</enum>
+     </property>
+     <property name="text">
+      <string>Speed/Volume Trigger</string>
+     </property>
+    </widget>
+    <widget class="QLabel" name="label_randomWeight">
+     <property name="geometry">
+      <rect>
+       <x>10</x>
+       <y>120</y>
+       <width>161</width>
+       <height>16</height>
+      </rect>
+     </property>
+     <property name="text">
+      <string>Weight (Random Mode) [1 - 100]:</string>
+     </property>
+    </widget>
+    <widget class="QSpinBox" name="spinBox_randomWeight">
+     <property name="geometry">
+      <rect>
+       <x>270</x>
+       <y>120</y>
+       <width>61</width>
+       <height>22</height>
+      </rect>
+     </property>
+     <property name="alignment">
+      <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+     </property>
+    </widget>
+    <widget class="QLabel" name="label_amplitudeFactor">
+     <property name="geometry">
+      <rect>
+       <x>10</x>
+       <y>150</y>
+       <width>101</width>
+       <height>21</height>
+      </rect>
+     </property>
+     <property name="text">
+      <string>Amplitude Factor:</string>
+     </property>
+    </widget>
+    <widget class="QDoubleSpinBox" name="doubleSpinBox_amplitudeFactor">
+     <property name="geometry">
+      <rect>
+       <x>110</x>
+       <y>150</y>
+       <width>62</width>
+       <height>22</height>
+      </rect>
+     </property>
+     <property name="layoutDirection">
+      <enum>Qt::LeftToRight</enum>
+     </property>
+     <property name="alignment">
+      <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+     </property>
+     <property name="maximum">
+      <double>339999999999999996123846586046231871488.000000000000000</double>
+     </property>
+    </widget>
+    <widget class="QDoubleSpinBox" name="doubleSpinBox_dopplerRatio">
+     <property name="geometry">
+      <rect>
+       <x>270</x>
+       <y>150</y>
+       <width>62</width>
+       <height>22</height>
+      </rect>
+     </property>
+     <property name="layoutDirection">
+      <enum>Qt::LeftToRight</enum>
+     </property>
+     <property name="alignment">
+      <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+     </property>
+     <property name="maximum">
+      <double>339999999999999996123846586046231871488.000000000000000</double>
+     </property>
+    </widget>
+    <widget class="QLabel" name="label_dopplerRatio">
+     <property name="geometry">
+      <rect>
+       <x>190</x>
+       <y>150</y>
+       <width>71</width>
+       <height>21</height>
+      </rect>
+     </property>
+     <property name="text">
+      <string>Doppler Ratio:</string>
+     </property>
+    </widget>
+    <widget class="QLabel" name="label_playbackFrequence">
+     <property name="geometry">
+      <rect>
+       <x>10</x>
+       <y>210</y>
+       <width>101</width>
+       <height>21</height>
+      </rect>
+     </property>
+     <property name="text">
+      <string>Playback Frequence:</string>
+     </property>
+    </widget>
+    <widget class="QDoubleSpinBox" name="doubleSpinBox_playbackFrequence">
+     <property name="geometry">
+      <rect>
+       <x>110</x>
+       <y>210</y>
+       <width>62</width>
+       <height>22</height>
+      </rect>
+     </property>
+     <property name="layoutDirection">
+      <enum>Qt::LeftToRight</enum>
+     </property>
+     <property name="alignment">
+      <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+     </property>
+     <property name="maximum">
+      <double>339999999999999996123846586046231871488.000000000000000</double>
+     </property>
+    </widget>
+    <widget class="QLabel" name="label_start">
+     <property name="geometry">
+      <rect>
+       <x>10</x>
+       <y>180</y>
+       <width>51</width>
+       <height>21</height>
+      </rect>
+     </property>
+     <property name="text">
+      <string>Start:</string>
+     </property>
+    </widget>
+    <widget class="QDoubleSpinBox" name="doubleSpinBox_start">
+     <property name="geometry">
+      <rect>
+       <x>110</x>
+       <y>180</y>
+       <width>62</width>
+       <height>22</height>
+      </rect>
+     </property>
+     <property name="layoutDirection">
+      <enum>Qt::LeftToRight</enum>
+     </property>
+     <property name="alignment">
+      <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+     </property>
+     <property name="maximum">
+      <double>339999999999999996123846586046231871488.000000000000000</double>
+     </property>
+    </widget>
+    <widget class="QDoubleSpinBox" name="doubleSpinBox_end">
+     <property name="geometry">
+      <rect>
+       <x>270</x>
+       <y>180</y>
+       <width>62</width>
+       <height>22</height>
+      </rect>
+     </property>
+     <property name="layoutDirection">
+      <enum>Qt::LeftToRight</enum>
+     </property>
+     <property name="alignment">
+      <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+     </property>
+     <property name="maximum">
+      <double>339999999999999996123846586046231871488.000000000000000</double>
+     </property>
+    </widget>
+    <widget class="QLabel" name="label_end">
+     <property name="geometry">
+      <rect>
+       <x>190</x>
+       <y>180</y>
+       <width>61</width>
+       <height>21</height>
+      </rect>
+     </property>
+     <property name="text">
+      <string>End:</string>
+     </property>
+    </widget>
+    <widget class="QDoubleSpinBox" name="doubleSpinBox_maskSample">
+     <property name="geometry">
+      <rect>
+       <x>270</x>
+       <y>210</y>
+       <width>62</width>
+       <height>22</height>
+      </rect>
+     </property>
+     <property name="layoutDirection">
+      <enum>Qt::LeftToRight</enum>
+     </property>
+     <property name="alignment">
+      <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+     </property>
+     <property name="maximum">
+      <double>339999999999999996123846586046231871488.000000000000000</double>
+     </property>
+    </widget>
+    <widget class="QLabel" name="label_maskSample">
+     <property name="geometry">
+      <rect>
+       <x>190</x>
+       <y>210</y>
+       <width>71</width>
+       <height>21</height>
+      </rect>
+     </property>
+     <property name="text">
+      <string>Mask Sample:</string>
+     </property>
+    </widget>
+    <widget class="QLabel" name="label_linkedFiles">
+     <property name="geometry">
+      <rect>
+       <x>360</x>
+       <y>20</y>
+       <width>61</width>
+       <height>16</height>
+      </rect>
+     </property>
+     <property name="text">
+      <string>Linked Files:</string>
+     </property>
+    </widget>
+    <widget class="QToolButton" name="toolButton_soundContainerAdd">
+     <property name="geometry">
+      <rect>
+       <x>140</x>
+       <y>20</y>
+       <width>31</width>
+       <height>31</height>
+      </rect>
+     </property>
+     <property name="toolTip">
+      <string>Add New Sound Container</string>
+     </property>
+     <property name="text">
+      <string>...</string>
+     </property>
+     <property name="icon">
+      <iconset>
+       <normalon>:/res/Plus_Enabled.png</normalon>
+      </iconset>
+     </property>
+     <property name="toolButtonStyle">
+      <enum>Qt::ToolButtonIconOnly</enum>
+     </property>
+     <property name="arrowType">
+      <enum>Qt::NoArrow</enum>
+     </property>
+    </widget>
+    <widget class="QToolButton" name="toolButton_soundContainerRemove">
+     <property name="geometry">
+      <rect>
+       <x>180</x>
+       <y>20</y>
+       <width>31</width>
+       <height>31</height>
+      </rect>
+     </property>
+     <property name="toolTip">
+      <string>Remove Sound Container</string>
+     </property>
+     <property name="text">
+      <string>...</string>
+     </property>
+     <property name="icon">
+      <iconset>
+       <normalon>:/res/Minus_Enabled.png</normalon>
+      </iconset>
+     </property>
+     <property name="toolButtonStyle">
+      <enum>Qt::ToolButtonIconOnly</enum>
+     </property>
+     <property name="arrowType">
+      <enum>Qt::NoArrow</enum>
+     </property>
+    </widget>
+    <widget class="QToolButton" name="toolButton_soundContainerUp">
+     <property name="geometry">
+      <rect>
+       <x>260</x>
+       <y>20</y>
+       <width>31</width>
+       <height>31</height>
+      </rect>
+     </property>
+     <property name="toolTip">
+      <string>Move Sound Container Up</string>
+     </property>
+     <property name="text">
+      <string>...</string>
+     </property>
+     <property name="toolButtonStyle">
+      <enum>Qt::ToolButtonIconOnly</enum>
+     </property>
+     <property name="arrowType">
+      <enum>Qt::UpArrow</enum>
+     </property>
+    </widget>
+    <widget class="QToolButton" name="toolButton_soundContainerDown">
+     <property name="geometry">
+      <rect>
+       <x>300</x>
+       <y>20</y>
+       <width>31</width>
+       <height>31</height>
+      </rect>
+     </property>
+     <property name="toolTip">
+      <string>Move Sound Container Down</string>
+     </property>
+     <property name="text">
+      <string>...</string>
+     </property>
+     <property name="toolButtonStyle">
+      <enum>Qt::ToolButtonIconOnly</enum>
+     </property>
+     <property name="arrowType">
+      <enum>Qt::DownArrow</enum>
+     </property>
+    </widget>
+    <widget class="QToolButton" name="toolButton_linkedFilesCopy">
+     <property name="enabled">
+      <bool>true</bool>
+     </property>
+     <property name="geometry">
+      <rect>
+       <x>580</x>
+       <y>120</y>
+       <width>31</width>
+       <height>31</height>
+      </rect>
+     </property>
+     <property name="toolTip">
+      <string>Duplicate Linked File</string>
+     </property>
+     <property name="text">
+      <string>...</string>
+     </property>
+     <property name="icon">
+      <iconset resource="../resources.qrc">
+       <normaloff>:/res/Copy_Enabled.png</normaloff>:/res/Copy_Enabled.png</iconset>
+     </property>
+     <property name="toolButtonStyle">
+      <enum>Qt::ToolButtonIconOnly</enum>
+     </property>
+     <property name="arrowType">
+      <enum>Qt::NoArrow</enum>
+     </property>
+    </widget>
+    <widget class="QToolButton" name="toolButton_soundContainerCopy">
+     <property name="enabled">
+      <bool>true</bool>
+     </property>
+     <property name="geometry">
+      <rect>
+       <x>220</x>
+       <y>20</y>
+       <width>31</width>
+       <height>31</height>
+      </rect>
+     </property>
+     <property name="toolTip">
+      <string>Duplicate Sound Container</string>
+     </property>
+     <property name="text">
+      <string>...</string>
+     </property>
+     <property name="icon">
+      <iconset resource="../resources.qrc">
+       <normaloff>:/res/Copy_Enabled.png</normaloff>:/res/Copy_Enabled.png</iconset>
+     </property>
+     <property name="toolButtonStyle">
+      <enum>Qt::ToolButtonIconOnly</enum>
+     </property>
+     <property name="arrowType">
+      <enum>Qt::NoArrow</enum>
+     </property>
+    </widget>
+    <widget class="QComboBox" name="comboBox_voiceGroupFront">
+     <property name="geometry">
+      <rect>
+       <x>90</x>
+       <y>60</y>
+       <width>111</width>
+       <height>22</height>
+      </rect>
+     </property>
+    </widget>
+    <widget class="QComboBox" name="comboBox_voiceGroupBack">
+     <property name="geometry">
+      <rect>
+       <x>220</x>
+       <y>60</y>
+       <width>111</width>
+       <height>22</height>
+      </rect>
+     </property>
+    </widget>
+    <widget class="QLabel" name="label_voiceGroupSep">
+     <property name="geometry">
+      <rect>
+       <x>200</x>
+       <y>60</y>
+       <width>21</width>
+       <height>21</height>
+      </rect>
+     </property>
+     <property name="font">
+      <font>
+       <pointsize>12</pointsize>
+       <weight>50</weight>
+       <bold>false</bold>
+      </font>
+     </property>
+     <property name="text">
+      <string>::</string>
+     </property>
+     <property name="alignment">
+      <set>Qt::AlignCenter</set>
+     </property>
+    </widget>
+    <widget class="QPlainTextEdit" name="plainTextEdit_effectContainerDataRaw">
+     <property name="geometry">
+      <rect>
+       <x>20</x>
+       <y>320</y>
+       <width>271</width>
+       <height>191</height>
+      </rect>
+     </property>
+     <property name="font">
+      <font>
+       <pointsize>11</pointsize>
+      </font>
+     </property>
+     <property name="readOnly">
+      <bool>true</bool>
+     </property>
+    </widget>
+    <widget class="QLabel" name="label_effectContainerCount">
+     <property name="geometry">
+      <rect>
+       <x>10</x>
+       <y>260</y>
+       <width>141</width>
+       <height>16</height>
+      </rect>
+     </property>
+     <property name="text">
+      <string>Effect Container Count:</string>
+     </property>
+    </widget>
+    <widget class="QLineEdit" name="lineEdit_effectContainerCount">
+     <property name="geometry">
+      <rect>
+       <x>140</x>
+       <y>260</y>
+       <width>51</width>
+       <height>21</height>
+      </rect>
+     </property>
+     <property name="alignment">
+      <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+     </property>
+     <property name="readOnly">
+      <bool>true</bool>
+     </property>
+    </widget>
+    <widget class="QCheckBox" name="checkBox_effectContainerDataEdit">
+     <property name="geometry">
+      <rect>
+       <x>220</x>
+       <y>260</y>
+       <width>141</width>
+       <height>21</height>
+      </rect>
+     </property>
+     <property name="text">
+      <string>Enable Editing (Caution!)</string>
+     </property>
+    </widget>
+    <widget class="QLabel" name="label_effectContainerDataRaw">
+     <property name="geometry">
+      <rect>
+       <x>20</x>
+       <y>300</y>
+       <width>141</width>
+       <height>16</height>
+      </rect>
+     </property>
+     <property name="text">
+      <string>Effect Container Data RAW</string>
+     </property>
+    </widget>
+    <widget class="QLabel" name="label_effectContainerDataString">
+     <property name="geometry">
+      <rect>
+       <x>330</x>
+       <y>300</y>
+       <width>151</width>
+       <height>16</height>
+      </rect>
+     </property>
+     <property name="text">
+      <string>Effect Container Data ASCII</string>
+     </property>
+    </widget>
+    <widget class="QPlainTextEdit" name="plainTextEdit_effectContainerDataString">
+     <property name="geometry">
+      <rect>
+       <x>330</x>
+       <y>320</y>
+       <width>271</width>
+       <height>191</height>
+      </rect>
+     </property>
+     <property name="font">
+      <font>
+       <pointsize>11</pointsize>
+      </font>
+     </property>
+     <property name="readOnly">
+      <bool>true</bool>
+     </property>
+    </widget>
+   </widget>
+   <widget class="QLabel" name="label_instructions">
+    <property name="enabled">
+     <bool>true</bool>
+    </property>
+    <property name="geometry">
+     <rect>
+      <x>208</x>
+      <y>380</y>
+      <width>542</width>
+      <height>51</height>
+     </rect>
+    </property>
+    <property name="font">
+     <font>
+      <pointsize>13</pointsize>
+      <italic>true</italic>
+     </font>
+    </property>
+    <property name="text">
+     <string>Use the File Menu/Toolbar to open an exsiting file or create a new one.
+Alternatively, simply drag-and-drop a BSC into this window.</string>
+    </property>
+    <property name="alignment">
+     <set>Qt::AlignCenter</set>
+    </property>
+   </widget>
+  </widget>
+  <widget class="QMenuBar" name="menuBar">
+   <property name="geometry">
+    <rect>
+     <x>0</x>
+     <y>0</y>
+     <width>958</width>
+     <height>21</height>
+    </rect>
+   </property>
+   <widget class="QMenu" name="menuFile">
+    <property name="title">
+     <string>File</string>
+    </property>
+    <addaction name="actionNew"/>
+    <addaction name="actionOpen"/>
+    <addaction name="separator"/>
+    <addaction name="actionSave"/>
+    <addaction name="actionSave_As"/>
+    <addaction name="separator"/>
+    <addaction name="actionClose"/>
+    <addaction name="separator"/>
+    <addaction name="actionExit"/>
+   </widget>
+   <widget class="QMenu" name="menuTools">
+    <property name="title">
+     <string>Tools</string>
+    </property>
+    <addaction name="actionBuild_New_Speechmanager_Cache"/>
+    <addaction name="actionUpdate_Speechmanager_Cache"/>
+    <addaction name="separator"/>
+    <addaction name="actionConvert_SMF_WAV"/>
+    <addaction name="actionConvert_WAV_SMF"/>
+    <addaction name="separator"/>
+    <addaction name="actionBatch_SMF_WAV"/>
+    <addaction name="actionBatch_WAV_SMF"/>
+   </widget>
+   <widget class="QMenu" name="menuHelp">
+    <property name="title">
+     <string>Help</string>
+    </property>
+    <addaction name="actionAbout"/>
+   </widget>
+   <addaction name="menuFile"/>
+   <addaction name="menuTools"/>
+   <addaction name="menuHelp"/>
+  </widget>
+  <widget class="QToolBar" name="mainToolBar">
+   <property name="movable">
+    <bool>false</bool>
+   </property>
+   <property name="iconSize">
+    <size>
+     <width>28</width>
+     <height>28</height>
+    </size>
+   </property>
+   <attribute name="toolBarArea">
+    <enum>TopToolBarArea</enum>
+   </attribute>
+   <attribute name="toolBarBreak">
+    <bool>false</bool>
+   </attribute>
+   <addaction name="actionNew"/>
+   <addaction name="actionOpen"/>
+   <addaction name="actionSave"/>
+   <addaction name="actionSave_As"/>
+   <addaction name="separator"/>
+   <addaction name="actionBuild_New_Speechmanager_Cache"/>
+   <addaction name="actionUpdate_Speechmanager_Cache"/>
+   <addaction name="separator"/>
+   <addaction name="actionConvert_SMF_WAV"/>
+   <addaction name="actionConvert_WAV_SMF"/>
+   <addaction name="actionBatch_SMF_WAV"/>
+   <addaction name="actionBatch_WAV_SMF"/>
+  </widget>
+  <action name="actionSave_As">
+   <property name="icon">
+    <iconset resource="../resources.qrc">
+     <normaloff>:/res/Save_as.png</normaloff>:/res/Save_as.png</iconset>
+   </property>
+   <property name="text">
+    <string>Save As</string>
+   </property>
+   <property name="shortcut">
+    <string>Ctrl+Shift+S</string>
+   </property>
+  </action>
+  <action name="actionSave">
+   <property name="icon">
+    <iconset resource="../resources.qrc">
+     <normaloff>:/res/Save.png</normaloff>:/res/Save.png</iconset>
+   </property>
+   <property name="text">
+    <string>Save</string>
+   </property>
+   <property name="shortcut">
+    <string>Ctrl+S</string>
+   </property>
+  </action>
+  <action name="actionNew">
+   <property name="icon">
+    <iconset resource="../resources.qrc">
+     <normaloff>:/res/New.png</normaloff>:/res/New.png</iconset>
+   </property>
+   <property name="text">
+    <string>New</string>
+   </property>
+   <property name="shortcut">
+    <string>Ctrl+N</string>
+   </property>
+  </action>
+  <action name="actionOpen">
+   <property name="icon">
+    <iconset resource="../resources.qrc">
+     <normaloff>:/res/Open.png</normaloff>:/res/Open.png</iconset>
+   </property>
+   <property name="text">
+    <string>Open</string>
+   </property>
+   <property name="shortcut">
+    <string>Ctrl+O</string>
+   </property>
+  </action>
+  <action name="actionClose">
+   <property name="icon">
+    <iconset resource="../resources.qrc">
+     <normaloff>:/res/Close.png</normaloff>:/res/Close.png</iconset>
+   </property>
+   <property name="text">
+    <string>Close</string>
+   </property>
+   <property name="shortcut">
+    <string>Ctrl+W</string>
+   </property>
+  </action>
+  <action name="actionExit">
+   <property name="icon">
+    <iconset resource="../resources.qrc">
+     <normaloff>:/res/Exit.png</normaloff>:/res/Exit.png</iconset>
+   </property>
+   <property name="text">
+    <string>Exit</string>
+   </property>
+   <property name="shortcut">
+    <string>Ctrl+Q</string>
+   </property>
+  </action>
+  <action name="actionUpdate_Speechmanager_Cache">
+   <property name="icon">
+    <iconset resource="../resources.qrc">
+     <normaloff>:/res/Update_Cash.png</normaloff>:/res/Update_Cash.png</iconset>
+   </property>
+   <property name="text">
+    <string>Update Speechmanager Cache</string>
+   </property>
+   <property name="shortcut">
+    <string>Ctrl+U</string>
+   </property>
+  </action>
+  <action name="actionAbout">
+   <property name="icon">
+    <iconset resource="../resources.qrc">
+     <normaloff>:/res/About.png</normaloff>:/res/About.png</iconset>
+   </property>
+   <property name="text">
+    <string>About</string>
+   </property>
+  </action>
+  <action name="actionBuild_New_Speechmanager_Cache">
+   <property name="icon">
+    <iconset resource="../resources.qrc">
+     <normaloff>:/res/New_Cache.png</normaloff>:/res/New_Cache.png</iconset>
+   </property>
+   <property name="text">
+    <string>Build New Speechmanager Cache</string>
+   </property>
+   <property name="shortcut">
+    <string>Ctrl+B</string>
+   </property>
+  </action>
+  <action name="actionConvert_SMF_WAV">
+   <property name="icon">
+    <iconset resource="../resources.qrc">
+     <normaloff>:/res/Convert_SMF_to_WAV.png</normaloff>:/res/Convert_SMF_to_WAV.png</iconset>
+   </property>
+   <property name="text">
+    <string>Convert SMF -&gt; WAV</string>
+   </property>
+   <property name="shortcut">
+    <string>Ctrl+W</string>
+   </property>
+  </action>
+  <action name="actionConvert_WAV_SMF">
+   <property name="icon">
+    <iconset resource="../resources.qrc">
+     <normaloff>:/res/Convert_WAV_to_SMF.png</normaloff>:/res/Convert_WAV_to_SMF.png</iconset>
+   </property>
+   <property name="text">
+    <string>Convert WAV -&gt; SMF</string>
+   </property>
+   <property name="shortcut">
+    <string>Ctrl+M</string>
+   </property>
+  </action>
+  <action name="actionBatch_SMF_WAV">
+   <property name="icon">
+    <iconset resource="../resources.qrc">
+     <normaloff>:/res/Batch_SMF_to_WAV.png</normaloff>:/res/Batch_SMF_to_WAV.png</iconset>
+   </property>
+   <property name="text">
+    <string>Batch SMF -&gt; WAV</string>
+   </property>
+   <property name="shortcut">
+    <string>Ctrl+Shift+W</string>
+   </property>
+  </action>
+  <action name="actionBatch_WAV_SMF">
+   <property name="icon">
+    <iconset resource="../resources.qrc">
+     <normaloff>:/res/Batch_WAV_to_SMF.png</normaloff>:/res/Batch_WAV_to_SMF.png</iconset>
+   </property>
+   <property name="text">
+    <string>Batch WAV -&gt; SMF</string>
+   </property>
+   <property name="shortcut">
+    <string>Ctrl+Shift+M</string>
+   </property>
+  </action>
+ </widget>
+ <layoutdefault spacing="6" margin="11"/>
+ <resources>
+  <include location="../resources.qrc"/>
+ </resources>
+ <connections>
+  <connection>
+   <sender>comboBox_playbackMode</sender>
+   <signal>currentIndexChanged(int)</signal>
+   <receiver>MainWindow</receiver>
+   <slot>all_on_comboBox_currentIndexChanged(int)</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>265</x>
+     <y>393</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>444</x>
+     <y>358</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>comboBox_maxInst</sender>
+   <signal>currentIndexChanged(int)</signal>
+   <receiver>MainWindow</receiver>
+   <slot>all_on_comboBox_currentIndexChanged(int)</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>265</x>
+     <y>423</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>444</x>
+     <y>358</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>comboBox_poly</sender>
+   <signal>currentIndexChanged(int)</signal>
+   <receiver>MainWindow</receiver>
+   <slot>all_on_comboBox_currentIndexChanged(int)</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>265</x>
+     <y>453</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>444</x>
+     <y>358</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>comboBox_emitter</sender>
+   <signal>currentIndexChanged(int)</signal>
+   <receiver>MainWindow</receiver>
+   <slot>all_on_comboBox_currentIndexChanged(int)</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>480</x>
+     <y>303</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>444</x>
+     <y>358</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>spinBox_repeatTimeMin</sender>
+   <signal>valueChanged(int)</signal>
+   <receiver>MainWindow</receiver>
+   <slot>all_on_spinBox_valueChanged(int)</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>291</x>
+     <y>483</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>444</x>
+     <y>358</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>spinBox_repeatTimeMax</sender>
+   <signal>valueChanged(int)</signal>
+   <receiver>MainWindow</receiver>
+   <slot>all_on_spinBox_valueChanged(int)</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>290</x>
+     <y>513</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>444</x>
+     <y>358</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>spinBox_repeatCountMin</sender>
+   <signal>valueChanged(int)</signal>
+   <receiver>MainWindow</receiver>
+   <slot>all_on_spinBox_valueChanged(int)</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>290</x>
+     <y>543</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>444</x>
+     <y>358</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>spinBox_repeatCountMax</sender>
+   <signal>valueChanged(int)</signal>
+   <receiver>MainWindow</receiver>
+   <slot>all_on_spinBox_valueChanged(int)</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>290</x>
+     <y>573</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>444</x>
+     <y>358</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>spinBox_randomPlaylistWeight</sender>
+   <signal>valueChanged(int)</signal>
+   <receiver>MainWindow</receiver>
+   <slot>all_on_spinBox_valueChanged(int)</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>290</x>
+     <y>603</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>444</x>
+     <y>358</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>doubleSpinBox_length</sender>
+   <signal>valueChanged(double)</signal>
+   <receiver>MainWindow</receiver>
+   <slot>all_on_doubleSpinBox_valueChanged(double)</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>290</x>
+     <y>633</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>444</x>
+     <y>358</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>doubleSpinBox_releaseTime</sender>
+   <signal>valueChanged(double)</signal>
+   <receiver>MainWindow</receiver>
+   <slot>all_on_doubleSpinBox_valueChanged(double)</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>290</x>
+     <y>663</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>444</x>
+     <y>358</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>checkBox_parentBehaviorOverride</sender>
+   <signal>stateChanged(int)</signal>
+   <receiver>MainWindow</receiver>
+   <slot>all_on_checkBox_stateChanged(int)</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>435</x>
+     <y>273</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>444</x>
+     <y>358</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>toolButton_playlistsAdd</sender>
+   <signal>clicked()</signal>
+   <receiver>MainWindow</receiver>
+   <slot>all_on_toolButton_clicked()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>305</x>
+     <y>198</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>470</x>
+     <y>395</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>toolButton_playlistsRemove</sender>
+   <signal>clicked()</signal>
+   <receiver>MainWindow</receiver>
+   <slot>all_on_toolButton_clicked()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>305</x>
+     <y>238</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>470</x>
+     <y>395</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>toolButton_playlistsOut</sender>
+   <signal>clicked()</signal>
+   <receiver>MainWindow</receiver>
+   <slot>all_on_toolButton_clicked()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>305</x>
+     <y>278</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>470</x>
+     <y>395</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>toolButton_playlistsIn</sender>
+   <signal>clicked()</signal>
+   <receiver>MainWindow</receiver>
+   <slot>all_on_toolButton_clicked()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>305</x>
+     <y>318</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>470</x>
+     <y>395</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>toolButton_playlistsUp</sender>
+   <signal>clicked()</signal>
+   <receiver>MainWindow</receiver>
+   <slot>all_on_toolButton_clicked()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>305</x>
+     <y>358</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>470</x>
+     <y>395</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>toolButton_playlistsDown</sender>
+   <signal>clicked()</signal>
+   <receiver>MainWindow</receiver>
+   <slot>all_on_toolButton_clicked()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>305</x>
+     <y>398</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>470</x>
+     <y>395</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>toolButton_effectBehaviorsAdd</sender>
+   <signal>clicked()</signal>
+   <receiver>MainWindow</receiver>
+   <slot>all_on_toolButton_clicked()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>625</x>
+     <y>78</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>470</x>
+     <y>395</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>toolButton_effectBehaviorsRemove</sender>
+   <signal>clicked()</signal>
+   <receiver>MainWindow</receiver>
+   <slot>all_on_toolButton_clicked()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>625</x>
+     <y>118</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>470</x>
+     <y>395</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>toolButton_effectBehaviorsUp</sender>
+   <signal>clicked()</signal>
+   <receiver>MainWindow</receiver>
+   <slot>all_on_toolButton_clicked()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>625</x>
+     <y>198</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>470</x>
+     <y>395</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>toolButton_effectBehaviorsDown</sender>
+   <signal>clicked()</signal>
+   <receiver>MainWindow</receiver>
+   <slot>all_on_toolButton_clicked()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>625</x>
+     <y>238</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>470</x>
+     <y>395</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>checkBox_speedVolumeTrigger</sender>
+   <signal>stateChanged(int)</signal>
+   <receiver>MainWindow</receiver>
+   <slot>all_on_checkBox_stateChanged(int)</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>535</x>
+     <y>443</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>444</x>
+     <y>358</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>toolButton_linkedFilesDown</sender>
+   <signal>clicked()</signal>
+   <receiver>MainWindow</receiver>
+   <slot>all_on_toolButton_clicked()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>855</x>
+     <y>578</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>470</x>
+     <y>395</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>toolButton_linkedFilesAdd</sender>
+   <signal>clicked()</signal>
+   <receiver>MainWindow</receiver>
+   <slot>all_on_toolButton_clicked()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>855</x>
+     <y>398</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>470</x>
+     <y>395</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>toolButton_linkedFilesUp</sender>
+   <signal>clicked()</signal>
+   <receiver>MainWindow</receiver>
+   <slot>all_on_toolButton_clicked()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>855</x>
+     <y>538</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>470</x>
+     <y>395</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>doubleSpinBox_start</sender>
+   <signal>valueChanged(double)</signal>
+   <receiver>MainWindow</receiver>
+   <slot>all_on_doubleSpinBox_valueChanged(double)</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>560</x>
+     <y>593</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>444</x>
+     <y>358</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>checkBox_loop</sender>
+   <signal>stateChanged(int)</signal>
+   <receiver>MainWindow</receiver>
+   <slot>all_on_checkBox_stateChanged(int)</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>430</x>
+     <y>443</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>444</x>
+     <y>358</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>toolButton_linkedFilesRemove</sender>
+   <signal>clicked()</signal>
+   <receiver>MainWindow</receiver>
+   <slot>all_on_toolButton_clicked()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>855</x>
+     <y>438</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>470</x>
+     <y>395</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>doubleSpinBox_playbackFrequence</sender>
+   <signal>valueChanged(double)</signal>
+   <receiver>MainWindow</receiver>
+   <slot>all_on_doubleSpinBox_valueChanged(double)</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>560</x>
+     <y>563</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>444</x>
+     <y>358</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>comboBox_soundContainer</sender>
+   <signal>currentIndexChanged(int)</signal>
+   <receiver>MainWindow</receiver>
+   <slot>all_on_comboBox_currentIndexChanged(int)</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>420</x>
+     <y>373</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>444</x>
+     <y>358</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>doubleSpinBox_dopplerRatio</sender>
+   <signal>valueChanged(double)</signal>
+   <receiver>MainWindow</receiver>
+   <slot>all_on_doubleSpinBox_valueChanged(double)</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>560</x>
+     <y>533</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>444</x>
+     <y>358</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>checkBox_3D</sender>
+   <signal>stateChanged(int)</signal>
+   <receiver>MainWindow</receiver>
+   <slot>all_on_checkBox_stateChanged(int)</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>374</x>
+     <y>443</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>444</x>
+     <y>358</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>toolButton_soundContainerUp</sender>
+   <signal>clicked()</signal>
+   <receiver>MainWindow</receiver>
+   <slot>all_on_toolButton_clicked()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>585</x>
+     <y>378</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>470</x>
+     <y>395</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>toolButton_soundContainerRemove</sender>
+   <signal>clicked()</signal>
+   <receiver>MainWindow</receiver>
+   <slot>all_on_toolButton_clicked()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>545</x>
+     <y>378</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>470</x>
+     <y>395</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>toolButton_soundContainerDown</sender>
+   <signal>clicked()</signal>
+   <receiver>MainWindow</receiver>
+   <slot>all_on_toolButton_clicked()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>625</x>
+     <y>378</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>470</x>
+     <y>395</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>doubleSpinBox_amplitudeFactor</sender>
+   <signal>valueChanged(double)</signal>
+   <receiver>MainWindow</receiver>
+   <slot>all_on_doubleSpinBox_valueChanged(double)</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>560</x>
+     <y>503</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>444</x>
+     <y>358</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>doubleSpinBox_end</sender>
+   <signal>valueChanged(double)</signal>
+   <receiver>MainWindow</receiver>
+   <slot>all_on_doubleSpinBox_valueChanged(double)</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>560</x>
+     <y>623</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>444</x>
+     <y>358</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>spinBox_randomWeight</sender>
+   <signal>valueChanged(int)</signal>
+   <receiver>MainWindow</receiver>
+   <slot>all_on_spinBox_valueChanged(int)</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>560</x>
+     <y>473</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>444</x>
+     <y>358</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>toolButton_soundContainerAdd</sender>
+   <signal>clicked()</signal>
+   <receiver>MainWindow</receiver>
+   <slot>all_on_toolButton_clicked()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>505</x>
+     <y>378</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>470</x>
+     <y>395</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>doubleSpinBox_maskSample</sender>
+   <signal>valueChanged(double)</signal>
+   <receiver>MainWindow</receiver>
+   <slot>all_on_doubleSpinBox_valueChanged(double)</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>560</x>
+     <y>653</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>444</x>
+     <y>358</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>toolButton_effectBehaviorsCopy</sender>
+   <signal>clicked()</signal>
+   <receiver>MainWindow</receiver>
+   <slot>all_on_toolButton_clicked()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>625</x>
+     <y>158</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>470</x>
+     <y>421</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>toolButton_linkedFilesCopy</sender>
+   <signal>clicked()</signal>
+   <receiver>MainWindow</receiver>
+   <slot>all_on_toolButton_clicked()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>895</x>
+     <y>528</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>470</x>
+     <y>421</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>toolButton_playlistsCopy</sender>
+   <signal>clicked()</signal>
+   <receiver>MainWindow</receiver>
+   <slot>all_on_toolButton_clicked()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>305</x>
+     <y>278</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>470</x>
+     <y>421</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>treeWidget_playlists</sender>
+   <signal>currentItemChanged(QTreeWidgetItem*,QTreeWidgetItem*)</signal>
+   <receiver>MainWindow</receiver>
+   <slot>all_on_treeWidget_currentItemChanged()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>147</x>
+     <y>318</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>470</x>
+     <y>421</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>lineEdit_effectContainerCount</sender>
+   <signal>textEdited(QString)</signal>
+   <receiver>MainWindow</receiver>
+   <slot>all_on_linedEdit_textEdited()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>515</x>
+     <y>553</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>470</x>
+     <y>415</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>plainTextEdit_effectContainerDataRaw</sender>
+   <signal>textChanged()</signal>
+   <receiver>MainWindow</receiver>
+   <slot>all_on_plainTextEdit_textChanged()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>495</x>
+     <y>698</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>470</x>
+     <y>415</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>plainTextEdit_effectContainerDataString</sender>
+   <signal>textChanged()</signal>
+   <receiver>MainWindow</receiver>
+   <slot>all_on_plainTextEdit_textChanged()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>775</x>
+     <y>698</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>470</x>
+     <y>415</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>checkBox_effectContainerDataEdit</sender>
+   <signal>stateChanged(int)</signal>
+   <receiver>MainWindow</receiver>
+   <slot>all_on_checkBox_stateChanged(int)</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>640</x>
+     <y>553</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>470</x>
+     <y>415</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>comboBox_voiceGroupFront</sender>
+   <signal>currentIndexChanged(int)</signal>
+   <receiver>MainWindow</receiver>
+   <slot>all_on_comboBox_currentIndexChanged(int)</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>495</x>
+     <y>353</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>470</x>
+     <y>415</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>comboBox_voiceGroupBack</sender>
+   <signal>currentIndexChanged(int)</signal>
+   <receiver>MainWindow</receiver>
+   <slot>all_on_comboBox_currentIndexChanged(int)</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>625</x>
+     <y>353</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>470</x>
+     <y>415</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>actionSave_As</sender>
+   <signal>triggered(bool)</signal>
+   <receiver>MainWindow</receiver>
+   <slot>all_on_menuAction_triggered()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>-1</x>
+     <y>-1</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>470</x>
+     <y>415</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>actionSave</sender>
+   <signal>triggered(bool)</signal>
+   <receiver>MainWindow</receiver>
+   <slot>all_on_menuAction_triggered()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>-1</x>
+     <y>-1</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>470</x>
+     <y>415</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>actionNew</sender>
+   <signal>triggered(bool)</signal>
+   <receiver>MainWindow</receiver>
+   <slot>all_on_menuAction_triggered()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>-1</x>
+     <y>-1</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>469</x>
+     <y>411</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>actionOpen</sender>
+   <signal>triggered(bool)</signal>
+   <receiver>MainWindow</receiver>
+   <slot>all_on_menuAction_triggered()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>-1</x>
+     <y>-1</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>469</x>
+     <y>411</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>actionExit</sender>
+   <signal>triggered(bool)</signal>
+   <receiver>MainWindow</receiver>
+   <slot>all_on_menuAction_triggered()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>-1</x>
+     <y>-1</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>469</x>
+     <y>411</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>tableWidget_effectBehaviors</sender>
+   <signal>itemChanged(QTableWidgetItem*)</signal>
+   <receiver>MainWindow</receiver>
+   <slot>all_on_tableWidget_itemChanged(QTableWidgetItem*)</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>480</x>
+     <y>158</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>469</x>
+     <y>411</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>tableWidget_linkedFiles</sender>
+   <signal>itemChanged(QTableWidgetItem*)</signal>
+   <receiver>MainWindow</receiver>
+   <slot>all_on_tableWidget_itemChanged(QTableWidgetItem*)</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>790</x>
+     <y>418</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>469</x>
+     <y>411</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>tableWidget_effectBehaviors</sender>
+   <signal>currentItemChanged(QTableWidgetItem*,QTableWidgetItem*)</signal>
+   <receiver>MainWindow</receiver>
+   <slot>all_on_tableWidget_currentItemChanged()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>480</x>
+     <y>158</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>469</x>
+     <y>411</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>tableWidget_linkedFiles</sender>
+   <signal>currentItemChanged(QTableWidgetItem*,QTableWidgetItem*)</signal>
+   <receiver>MainWindow</receiver>
+   <slot>all_on_tableWidget_currentItemChanged()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>790</x>
+     <y>418</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>469</x>
+     <y>411</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>actionUpdate_Speechmanager_Cache</sender>
+   <signal>triggered(bool)</signal>
+   <receiver>MainWindow</receiver>
+   <slot>all_on_menuAction_triggered()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>-1</x>
+     <y>-1</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>469</x>
+     <y>411</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>actionBatch_WAV_SMF</sender>
+   <signal>triggered(bool)</signal>
+   <receiver>MainWindow</receiver>
+   <slot>all_on_menuAction_triggered()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>-1</x>
+     <y>-1</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>469</x>
+     <y>411</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>actionBuild_New_Speechmanager_Cache</sender>
+   <signal>triggered(bool)</signal>
+   <receiver>MainWindow</receiver>
+   <slot>all_on_menuAction_triggered()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>-1</x>
+     <y>-1</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>478</x>
+     <y>409</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>actionClose</sender>
+   <signal>triggered(bool)</signal>
+   <receiver>MainWindow</receiver>
+   <slot>all_on_menuAction_triggered()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>-1</x>
+     <y>-1</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>478</x>
+     <y>409</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>actionConvert_SMF_WAV</sender>
+   <signal>triggered(bool)</signal>
+   <receiver>MainWindow</receiver>
+   <slot>all_on_menuAction_triggered()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>-1</x>
+     <y>-1</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>478</x>
+     <y>409</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>actionConvert_WAV_SMF</sender>
+   <signal>triggered(bool)</signal>
+   <receiver>MainWindow</receiver>
+   <slot>all_on_menuAction_triggered()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>-1</x>
+     <y>-1</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>478</x>
+     <y>409</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>actionBatch_SMF_WAV</sender>
+   <signal>triggered(bool)</signal>
+   <receiver>MainWindow</receiver>
+   <slot>all_on_menuAction_triggered()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>-1</x>
+     <y>-1</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>478</x>
+     <y>409</y>
+    </hint>
+   </hints>
+  </connection>
+  <connection>
+   <sender>actionAbout</sender>
+   <signal>triggered(bool)</signal>
+   <receiver>MainWindow</receiver>
+   <slot>all_on_menuAction_triggered()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>-1</x>
+     <y>-1</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>478</x>
+     <y>409</y>
+    </hint>
+   </hints>
+  </connection>
+ </connections>
+ <slots>
+  <slot>all_on_linedEdit_textEdited()</slot>
+  <slot>all_on_comboBox_currentIndexChanged(int)</slot>
+  <slot>all_on_spinBox_valueChanged(int)</slot>
+  <slot>all_on_doubleSpinBox_valueChanged(double)</slot>
+  <slot>all_on_checkBox_stateChanged(int)</slot>
+  <slot>all_on_toolButton_clicked()</slot>
+  <slot>all_on_treeWidget_currentItemChanged()</slot>
+  <slot>all_on_plainTextEdit_textChanged()</slot>
+  <slot>all_on_menuAction_triggered()</slot>
+  <slot>all_on_tableWidget_itemChanged(QTableWidgetItem*)</slot>
+  <slot>all_on_tableWidget_currentItemChanged()</slot>
+ </slots>
+</ui>
diff --git a/src/smc.cpp b/src/smc.cpp
new file mode 100644
index 0000000..c7310c9
--- /dev/null
+++ b/src/smc.cpp
@@ -0,0 +1,98 @@
+#include "smc.h"
+#include "qx.h"
+#include <QtEndian>
+
+//===============================================================================================================
+// SMC
+//===============================================================================================================
+
+//-Constructor------------------------------------------------------------------------------------------------
+//Public:
+
+SMC::SMC(QByteArray rawData)
+    : mFileDataF(rawData)
+{
+    mValidFile = separateData();
+    if(mValidFile)
+        interpretData();
+}
+
+SMC::SMC()
+{
+    mValidFile = true;
+}
+
+//-Instance Functions------------------------------------------------------------------------------------------------
+//Public:
+QStringList& SMC::getInterpretedCacheListR() { return mCacheListI; }
+QStringList SMC::getInterpretedCacheListV() { return mCacheListI; }
+bool SMC::isValidCache() { return mValidFile; }
+
+void SMC::deinterpretData()
+{
+    mCacheListR.clear();
+
+    for (int i = 0; i< mCacheListI.length(); i++)
+        mCacheListR.append(Qx::ByteArray::RAWFromString(mCacheListI.value(i)));
+}
+
+QByteArray SMC::rebuildRawFile()
+{
+    QByteArray rawFile;
+
+    for (int i = 0; i < mCacheListR.length(); i++)
+    {
+        // Add entry length then entry
+        rawFile.append(Qx::ByteArray::RAWFromPrimitive(uint32_t(mCacheListR.value(i).length()), Qx::Endian::LE));
+        rawFile.append(mCacheListR.value(i));
+    }
+
+    return rawFile;
+}
+
+//Private:
+bool SMC::separateData()
+{
+    bool fileIsValid = true;
+    mDataCursor = 0x00; // Start of data
+
+    while(mDataCursor != mFileDataF.length() && fileIsValid)
+    {
+        // Get length of next entry
+        uint32_t nextEntryLength = qFromLittleEndian<quint32>(mFileDataF.mid(mDataCursor, L_ENTRY_LEN));
+
+        // Advance to start of next entry
+        mDataCursor += L_ENTRY_LEN;
+
+        // Get next entry
+        QByteArray nextEntry = mFileDataF.mid(mDataCursor, int(nextEntryLength));
+
+        // Ensure file validity
+        if(!rawEntryIsValid(nextEntry))
+            return false;
+        else
+            mCacheListR.append(nextEntry);
+
+        // Advance to start of the next size bytes
+        mDataCursor += nextEntryLength;
+    }
+
+    return true;
+}
+
+void SMC::interpretData()
+{
+    for (int i = 0; i< mCacheListR.length(); i++)
+        mCacheListI.append(Qx::String::fromByteArray(mCacheListR.value(i)));
+}
+
+bool SMC::rawEntryIsValid(QByteArray entry)
+{
+    for(int i = 0; i < entry.length(); i++)
+    {
+        if(entry.at(i) < ENTRY_VALID_ASCII_MIN || entry.at(i) > ENTRY_VALID_ASCII_MAX )
+            return false;
+    }
+
+    return true;
+}
diff --git a/src/smc.h b/src/smc.h
new file mode 100644
index 0000000..b85b3c3
--- /dev/null
+++ b/src/smc.h
@@ -0,0 +1,58 @@
+#ifndef SMC_H
+#define SMC_H
+
+#include <QByteArray>
+#include <QByteArrayList>
+
+class SMC
+{
+//-Class Variables-----------------------------------------------------------------------------------------------
+public:
+    static inline const QString FILE_EXT = "cache";
+
+    static const int L_ENTRY_LEN = 0x04;
+
+    static const int ENTRY_VALID_ASCII_MIN = 0x21;
+    static const int ENTRY_VALID_ASCII_MAX = 0x7E;
+
+//-Instance Variables--------------------------------------------------------------------------------------------
+private:
+    // Raw Index Cursor
+    int mDataCursor;
+
+    // Full Data
+    QByteArray mFileDataF;
+
+    // Segmented Raw Data
+    QByteArrayList mCacheListR;
+
+    // Segmented Interpreted Data
+    QStringList mCacheListI;
+
+    // File Validity
+    bool mValidFile;
+
+//-Constructor-------------------------------------------------------------------------------------------------
+public:
+    SMC(QByteArray rawData);
+    SMC();
+
+//-Class Functions------------------------------------------------------------------------------------------------------
+public:
+
+//-Instance Functions---------------------------------------------------------------------------------------------------
+public:
+    QStringList& getInterpretedCacheListR();
+    QStringList getInterpretedCacheListV();
+    bool isValidCache();
+
+    void deinterpretData();
+    QByteArray rebuildRawFile();
+
+private:
+    bool separateData();
+    void interpretData();
+    bool rawEntryIsValid(QByteArray entry);
+};
+
+#endif // SMC_H
diff --git a/src/smf.cpp b/src/smf.cpp
new file mode 100644
index 0000000..bb15cfd
--- /dev/null
+++ b/src/smf.cpp
@@ -0,0 +1,44 @@
+#include "smf.h"
+#include "qx.h"
+
+//===============================================================================================================
+// SMC
+//===============================================================================================================
+
+//-Constructor------------------------------------------------------------------------------------------------
+//Public:
+SMF::SMF(QByteArray rawData)
+    : mFileDataF(rawData) {}
+
+//-Class Functions------------------------------------------------------------------------------------------------
+//Public:
+bool SMF::fileIsValidSMF(QFile &possibleSMF, Qx::IO::IOOpReport& reportBuffer)
+{
+    // Get header region
+    QByteArray headers;
+    reportBuffer = Qx::IO::readBytesFromFile(headers, possibleSMF, 0x00, 0x1B);
+
+    if(!reportBuffer.wasSuccessful())
+        return false;
+    else
+    {
+        long long fullFileSize = QFileInfo(possibleSMF).size();
+
+        QByteArray smfSigRegion = headers.left(L_SMF_SIG);
+        QByteArray smfByteSigRegion = headers.mid(L_SMF_SIG, L_SMF_BYTE_SIG);
+        QByteArray riffSigRegion = headers.mid(L_SMF_SIG + L_SMF_BYTE_SIG, L_RIFF_SIG);
+        QByteArray riffSizeRegion = headers.mid(L_SMF_SIG + L_SMF_BYTE_SIG + L_RIFF_SIG, L_RIFF_LEN);
+        QByteArray wavSigRegion = headers.mid(L_SMF_SIG + L_SMF_BYTE_SIG + L_RIFF_SIG + L_RIFF_LEN, L_WAV_SIG);
+        QByteArray formatSigRegion = headers.mid(L_SMF_SIG + L_SMF_BYTE_SIG + L_RIFF_SIG + L_RIFF_LEN + L_WAV_SIG, L_FORMAT_SIG);
+
+        return smfSigRegion == SMF_SIG && smfByteSigRegion == QByteArray(SMF_BYTE_SIG, 8) && riffSigRegion == RIFF_SIG && wavSigRegion == WAV_SIG && formatSigRegion == FORMAT_SIG &&
+               Qx::ByteArray::RAWToPrimitive<uint32_t>(riffSizeRegion, Qx::Endian::LE) == fullFileSize - 0x14;
+    }
+}
+
+//-Instance Functions------------------------------------------------------------------------------------------------
+//Public:
+QByteArray SMF::getFullData() { return mFileDataF; }
+WAV SMF::toWAV() { return WAV(mFileDataF.mid(L_SMF_SIG + L_SMF_BYTE_SIG)); }
+
+//Private:
diff --git a/src/smf.h b/src/smf.h
new file mode 100644
index 0000000..a1e21a6
--- /dev/null
+++ b/src/smf.h
@@ -0,0 +1,59 @@
+#ifndef SMF_H
+#define SMF_H
+
+#include <QFile>
+#include "wav.h"
+#include "qx-io.h"
+
+
+//-Related Class Forward Declarations----------------------------------------------------------------------------
+class WAV;
+
+class SMF
+{
+//-Class Variables-----------------------------------------------------------------------------------------------
+public:
+    static inline const QString FILE_EXT = "smf";
+    static inline const QString SMF_SIG = "fssm";
+
+
+    static inline const char SMF_BYTE_SIG[] = {0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00};  //This appears to actually be two back-to-back,
+    // 32-bit, little-endian values of 1 that may be some kind of count, but no SMF files seem to have different values than 1,1. Initialized
+    // using char[] because QByteArray seems to be bugged when using "inline" with null (0x00) characters as part of the array
+
+    static inline const QString RIFF_SIG = "RIFF";
+    static inline const QString WAV_SIG = "WAVE";
+    static inline const QString FORMAT_SIG = "fmt ";
+
+    static const int L_SMF_SIG = 0x04;
+    static const int L_SMF_BYTE_SIG = 0x08;
+    static const int L_RIFF_SIG = 0x04;
+    static const int L_RIFF_LEN = 0x04;
+    static const int L_WAV_SIG = 0x04;
+    static const int L_FORMAT_SIG = 0x04;
+
+
+//-Instance Variables--------------------------------------------------------------------------------------------
+private:
+    // Full Data
+    QByteArray mFileDataF;
+
+//-Constructor-------------------------------------------------------------------------------------------------
+public:
+    SMF(QByteArray rawData);
+
+//-Class Functions------------------------------------------------------------------------------------------------------
+public:
+    static bool fileIsValidSMF(QFile& possibleSMF, Qx::IO::IOOpReport& reportBuffer);
+
+private:
+
+//-Instance Functions---------------------------------------------------------------------------------------------------
+public:
+    QByteArray getFullData();
+    WAV toWAV();
+
+private:
+};
+
+#endif // SMF_H
diff --git a/src/version.h b/src/version.h
new file mode 100644
index 0000000..b01aaff
--- /dev/null
+++ b/src/version.h
@@ -0,0 +1,21 @@
+#ifndef VERSION_H
+#define VERSION_H
+
+#define VER_FILEVERSION             0,1,0,0
+#define VER_FILEVERSION_STR         "0.1.0.0"
+
+#define VER_PRODUCTVERSION          0,1,0,0
+#define VER_PRODUCTVERSION_STR      "0.1.0.0"
+
+#define VER_COMPANYNAME_STR         "Obby Apps"
+#define VER_FILEDESCRIPTION_STR     "BSCWorks (CoH:v14)"
+#define VER_INTERNALNAME_STR        "CoH: BSC Editor"
+#define VER_LEGALCOPYRIGHT_STR      "Copyright © 2019 Obby Apps"
+#define VER_LEGALTRADEMARKS1_STR    "All Rights Reserved"
+#define VER_LEGALTRADEMARKS2_STR    "GNU GPL V3"
+#define VER_ORIGINALFILENAME_STR    "BSCWorks.exe"
+#define VER_PRODUCTNAME_STR         "BSCWorks"
+
+#define VER_COMPANYDOMAIN_STR       "https://github.com/oblivioncth"
+
+#endif // VERSION_H
diff --git a/src/wav.cpp b/src/wav.cpp
new file mode 100644
index 0000000..28c412b
--- /dev/null
+++ b/src/wav.cpp
@@ -0,0 +1,45 @@
+#include "wav.h"
+#include "qx.h"
+#include "qx-io.h"
+
+//===============================================================================================================
+// WAV
+//===============================================================================================================
+
+//-Constructor------------------------------------------------------------------------------------------------
+//Public:
+WAV::WAV(QByteArray rawData)
+    : mFileDataF(rawData) {}
+
+//-Class Functions------------------------------------------------------------------------------------------------
+//Public:
+bool WAV::fileIsValidWAV(QFile &possibleWAV, Qx::IO::IOOpReport reportBuffer)
+{
+    QByteArray headers;
+    reportBuffer = Qx::IO::readBytesFromFile(headers, possibleWAV, 0x00, 0x1B);
+
+    if(!reportBuffer.wasSuccessful())
+        return false;
+    else
+    {
+        // Get header region
+        QByteArray headers;
+        reportBuffer = Qx::IO::readBytesFromFile(headers, possibleWAV, 0x00, 0x0F);
+        long long fullFileSize = QFileInfo(possibleWAV).size();
+
+        QByteArray riffSigRegion = headers.left(L_RIFF_SIG);
+        QByteArray riffSizeRegion = headers.mid(L_RIFF_SIG, L_RIFF_LEN);
+        QByteArray wavSigRegion = headers.mid(L_RIFF_SIG + L_RIFF_LEN, L_WAV_SIG);
+        QByteArray formatSigRegion = headers.mid(L_RIFF_SIG + L_RIFF_LEN + L_WAV_SIG, L_FORMAT_SIG);
+
+        return riffSigRegion == RIFF_SIG && wavSigRegion == WAV_SIG && formatSigRegion == FORMAT_SIG &&
+               Qx::ByteArray::RAWToPrimitive<uint32_t>(riffSizeRegion, Qx::Endian::LE) == fullFileSize - 0x08;
+    }
+}
+
+//-Instance Functions------------------------------------------------------------------------------------------------
+//Public:
+SMF WAV::toSMF() { return SMF(Qx::ByteArray::RAWFromString(SMF::SMF_SIG) + QByteArray(SMF::SMF_BYTE_SIG, 8) + mFileDataF); }
+QByteArray WAV::getFullData() { return mFileDataF; }
+
+//Private:
diff --git a/src/wav.h b/src/wav.h
new file mode 100644
index 0000000..a59336d
--- /dev/null
+++ b/src/wav.h
@@ -0,0 +1,47 @@
+#ifndef WAV_H
+#define WAV_H
+
+#include <QFile>
+#include "smf.h"
+#include "qx-io.h"
+
+//-Related Class Forward Declarations----------------------------------------------------------------------------
+class SMF;
+
+class WAV
+{
+//-Class Variables-----------------------------------------------------------------------------------------------
+public:
+    static inline const QString FILE_EXT = "wav";
+    static inline const QString RIFF_SIG = "RIFF";
+    static inline const QString WAV_SIG = "WAVE";
+    static inline const QString FORMAT_SIG = "fmt ";
+
+    static const int L_RIFF_SIG = 0x04;
+    static const int L_RIFF_LEN = 0x04;
+    static const int L_WAV_SIG = 0x04;
+    static const int L_FORMAT_SIG = 0x04;
+
+//-Instance Variables--------------------------------------------------------------------------------------------
+private:
+    QByteArray mFileDataF;
+
+//-Constructor-------------------------------------------------------------------------------------------------
+public:
+    WAV(QByteArray rawData);
+
+//-Class Functions------------------------------------------------------------------------------------------------------
+public:
+    static bool fileIsValidWAV(QFile& possibleWAV, Qx::IO::IOOpReport reportBuffer);
+
+private:
+
+//-Instance Functions---------------------------------------------------------------------------------------------------
+public:
+    QByteArray getFullData();
+    SMF toSMF();
+
+private:
+};
+
+#endif // WAV_H