diff --git a/src/controllers/controllerinputmappingtablemodel.cpp b/src/controllers/controllerinputmappingtablemodel.cpp
index a4eb8e64fa5..5ae6670c0ac 100644
--- a/src/controllers/controllerinputmappingtablemodel.cpp
+++ b/src/controllers/controllerinputmappingtablemodel.cpp
@@ -196,7 +196,7 @@ QVariant ControllerInputMappingTableModel::data(const QModelIndex& index,
             case MIDI_COLUMN_OPTIONS:
                 // UserRole is used for sorting.
                 if (role == Qt::UserRole) {
-                    return mapping.options.all;
+                    return QVariant(mapping.options);
                 }
                 return QVariant::fromValue(mapping.options);
             case MIDI_COLUMN_ACTION:
diff --git a/src/controllers/delegates/controldelegate.cpp b/src/controllers/delegates/controldelegate.cpp
index 16e09daf5f4..fe9c971db7c 100644
--- a/src/controllers/delegates/controldelegate.cpp
+++ b/src/controllers/delegates/controldelegate.cpp
@@ -34,7 +34,7 @@ void ControlDelegate::paint(QPainter* painter,
         QModelIndex optionsColumn = index.sibling(index.row(),
                                                   m_iMidiOptionsColumn);
         MidiOptions options = optionsColumn.data().value<MidiOptions>();
-        m_bIsIndexScript = options.script;
+        m_bIsIndexScript = options.testFlag(MidiOption::Script);
     }
 
     QStyledItemDelegate::paint(painter, option, index);
diff --git a/src/controllers/delegates/midioptionsdelegate.cpp b/src/controllers/delegates/midioptionsdelegate.cpp
index 30a53e0ec92..8e10fa017b4 100644
--- a/src/controllers/delegates/midioptionsdelegate.cpp
+++ b/src/controllers/delegates/midioptionsdelegate.cpp
@@ -8,6 +8,28 @@
 #include "controllers/midi/midiutils.h"
 #include "moc_midioptionsdelegate.cpp"
 
+namespace {
+
+const QList<MidiOption> kMidiOptions = {
+        MidiOption::None,
+        MidiOption::Invert,
+        MidiOption::Rot64,
+        MidiOption::Rot64Invert,
+        MidiOption::Rot64Fast,
+        MidiOption::Diff,
+        MidiOption::Button,
+        MidiOption::Switch,
+        MidiOption::Spread64,
+        MidiOption::HercJog,
+        MidiOption::SelectKnob,
+        MidiOption::SoftTakeover,
+        MidiOption::Script,
+        MidiOption::FourteenBitMSB,
+        MidiOption::FourteenBitLSB,
+};
+
+}
+
 MidiOptionsDelegate::MidiOptionsDelegate(QObject* pParent)
         : QStyledItemDelegate(pParent) {
 }
@@ -23,27 +45,9 @@ QWidget* MidiOptionsDelegate::createEditor(QWidget* parent,
     Q_UNUSED(index);
     QComboBox* pComboBox = new QComboBox(parent);
 
-    QList<MidiOption> choices;
-    choices.append(MIDI_OPTION_NONE);
-    choices.append(MIDI_OPTION_INVERT);
-    choices.append(MIDI_OPTION_ROT64);
-    choices.append(MIDI_OPTION_ROT64_INV);
-    choices.append(MIDI_OPTION_ROT64_FAST);
-    choices.append(MIDI_OPTION_DIFF);
-    choices.append(MIDI_OPTION_BUTTON);
-    choices.append(MIDI_OPTION_SWITCH);
-    choices.append(MIDI_OPTION_SPREAD64);
-    choices.append(MIDI_OPTION_HERC_JOG);
-    choices.append(MIDI_OPTION_SELECTKNOB);
-    choices.append(MIDI_OPTION_SOFT_TAKEOVER);
-    choices.append(MIDI_OPTION_SCRIPT);
-    choices.append(MIDI_OPTION_14BIT_MSB);
-    choices.append(MIDI_OPTION_14BIT_LSB);
-
-    for (int i = 0; i < choices.size(); ++i) {
-        MidiOption choice = choices.at(i);
+    for (const MidiOption choice : kMidiOptions) {
         pComboBox->addItem(MidiUtils::midiOptionToTranslatedString(choice),
-                           choice);
+                static_cast<uint16_t>(choice));
     }
 
     return pComboBox;
@@ -54,12 +58,10 @@ QString MidiOptionsDelegate::displayText(const QVariant& value,
     Q_UNUSED(locale);
     MidiOptions options = value.value<MidiOptions>();
     QStringList optionStrs;
-    MidiOption option = static_cast<MidiOption>(1);
-    while (option < MIDI_OPTION_MASK) {
-        if (options.all & option) {
+    for (const MidiOption option : kMidiOptions) {
+        if (options.testFlag(option)) {
             optionStrs.append(MidiUtils::midiOptionToTranslatedString(option));
         }
-        option = static_cast<MidiOption>(option << 1);
     }
     return optionStrs.join(", ");
 }
@@ -73,7 +75,7 @@ void MidiOptionsDelegate::setEditorData(QWidget* editor,
         return;
     }
     for (int i = 0; i < pComboBox->count(); ++i) {
-        if (pComboBox->itemData(i).toInt() & options.all) {
+        if (MidiOptions(pComboBox->itemData(i).toInt()) & options) {
             pComboBox->setCurrentIndex(i);
             return;
         }
@@ -88,6 +90,6 @@ void MidiOptionsDelegate::setModelData(QWidget* editor,
     if (pComboBox == nullptr) {
         return;
     }
-    options.all = pComboBox->itemData(pComboBox->currentIndex()).toInt();
+    options = MidiOptions(pComboBox->itemData(pComboBox->currentIndex()).toInt());
     model->setData(index, QVariant::fromValue(options), Qt::EditRole);
 }
diff --git a/src/controllers/dlgcontrollerlearning.cpp b/src/controllers/dlgcontrollerlearning.cpp
index 478c6882f81..e59140fae54 100644
--- a/src/controllers/dlgcontrollerlearning.cpp
+++ b/src/controllers/dlgcontrollerlearning.cpp
@@ -364,26 +364,32 @@ void DlgControllerLearning::slotTimerExpired() {
     foreach (const MidiInputMapping& mapping, m_mappings) {
         MidiOpCode opCode = MidiUtils::opCodeFromStatus(mapping.key.status);
         bool twoBytes = MidiUtils::isMessageTwoBytes(opCode);
-        QString mappingStr = twoBytes ? QString("Status: 0x%1 Control: 0x%2 Options: 0x%03")
-                .arg(QString::number(mapping.key.status, 16).toUpper(),
-                     QString::number(mapping.key.control, 16).toUpper()
-                     .rightJustified(2, '0'),
-                     QString::number(mapping.options.all, 16).toUpper()
-                     .rightJustified(2, '0')) :
-                QString("0x%1 0x%2")
-                .arg(QString::number(mapping.key.status, 16).toUpper(),
-                     QString::number(mapping.options.all, 16).toUpper()
-                     .rightJustified(2, '0'));
+        QString mappingStr = twoBytes
+                ? QString("Status: 0x%1 Control: 0x%2 Options: 0x%03")
+                          .arg(QString::number(mapping.key.status, 16)
+                                          .toUpper(),
+                                  QString::number(mapping.key.control, 16)
+                                          .toUpper()
+                                          .rightJustified(2, '0'),
+                                  QString::number(mapping.options, 16)
+                                          .toUpper()
+                                          .rightJustified(2, '0'))
+                : QString("0x%1 0x%2")
+                          .arg(QString::number(mapping.key.status, 16)
+                                          .toUpper(),
+                                  QString::number(mapping.options, 16)
+                                          .toUpper()
+                                          .rightJustified(2, '0'));
 
         // Set the debug string and "Advanced MIDI Options" group using the
         // first mapping.
         if (first) {
             midiControl = mappingStr;
             MidiOptions options = mapping.options;
-            midiOptionInvert->setChecked(options.invert);
-            midiOptionSelectKnob->setChecked(options.selectknob);
-            midiOptionSoftTakeover->setChecked(options.soft_takeover);
-            midiOptionSwitchMode->setChecked(options.sw);
+            midiOptionInvert->setChecked(options.testFlag(MidiOption::Invert));
+            midiOptionSelectKnob->setChecked(options.testFlag(MidiOption::SelectKnob));
+            midiOptionSoftTakeover->setChecked(options.testFlag(MidiOption::SoftTakeover));
+            midiOptionSwitchMode->setChecked(options.testFlag(MidiOption::Switch));
             first = false;
         }
 
@@ -417,10 +423,10 @@ void DlgControllerLearning::slotMidiOptionsChanged() {
     for (MidiInputMappings::iterator it = m_mappings.begin();
          it != m_mappings.end(); ++it) {
         MidiOptions& options = it->options;
-        options.sw = midiOptionSwitchMode->isChecked();
-        options.soft_takeover = midiOptionSoftTakeover->isChecked();
-        options.invert = midiOptionInvert->isChecked();
-        options.selectknob = midiOptionSelectKnob->isChecked();
+        options.setFlag(MidiOption::Switch, midiOptionSwitchMode->isChecked());
+        options.setFlag(MidiOption::SoftTakeover, midiOptionSoftTakeover->isChecked());
+        options.setFlag(MidiOption::Invert, midiOptionInvert->isChecked());
+        options.setFlag(MidiOption::SelectKnob, midiOptionSelectKnob->isChecked());
     }
 
     emit learnTemporaryInputMappings(m_mappings);
diff --git a/src/controllers/learningutils.cpp b/src/controllers/learningutils.cpp
index 4f99fcfe0d2..1719bd51db5 100644
--- a/src/controllers/learningutils.cpp
+++ b/src/controllers/learningutils.cpp
@@ -173,7 +173,7 @@ MidiInputMappings LearningUtils::guessMidiInputMappings(
         // - VCI-400 vinyl toggle button (NOTE_ON)
         // - Korg nanoKontrol switches (CC)
         MidiOptions options;
-        options.sw = true;
+        options.setFlag(MidiOption::Switch);
 
         MidiKey note_on;
         // The predicate ensures only NOTE_ON or CC messages can trigger this
@@ -198,7 +198,7 @@ MidiInputMappings LearningUtils::guessMidiInputMappings(
         // though it is called 'selectknob' it is actually only two's complement
         // processing).
         MidiOptions options;
-        options.selectknob = true;
+        options.setFlag(MidiOption::SelectKnob);
         MidiKey knob;
         knob.status = MidiUtils::statusFromOpCodeAndChannel(
                 MidiOpCode::ControlChange, *stats.channels.begin());
@@ -208,7 +208,7 @@ MidiInputMappings LearningUtils::guessMidiInputMappings(
         // A "spread 64" ticker, where 0x40 is zero, positive jog values are
         // 0x41 and above, and negative jog values are 0x3F and below.
         MidiOptions options;
-        options.spread64 = true;
+        options.setFlag(MidiOption::Spread64);
 
         MidiKey knob;
         knob.status = MidiUtils::statusFromOpCodeAndChannel(
@@ -290,7 +290,7 @@ MidiInputMappings LearningUtils::guessMidiInputMappings(
                 MidiOpCode::ControlChange, *stats.channels.begin());
         msb.control = msb_control;
         MidiOptions msb_option;
-        msb_option.fourteen_bit_msb = true;
+        msb_option.setFlag(MidiOption::FourteenBitMSB);
         mappings.append(MidiInputMapping(msb, msb_option, control));
 
         MidiKey lsb;
@@ -298,7 +298,7 @@ MidiInputMappings LearningUtils::guessMidiInputMappings(
                 MidiOpCode::ControlChange, *stats.channels.begin());
         lsb.control = lsb_control;
         MidiOptions lsb_option;
-        lsb_option.fourteen_bit_lsb = true;
+        lsb_option.setFlag(MidiOption::FourteenBitLSB);
         mappings.append(MidiInputMapping(lsb, lsb_option, control));
     }
 
diff --git a/src/controllers/midi/legacymidicontrollermappingfilehandler.cpp b/src/controllers/midi/legacymidicontrollermappingfilehandler.cpp
index 08bec039ae9..e0fcea473cf 100644
--- a/src/controllers/midi/legacymidicontrollermappingfilehandler.cpp
+++ b/src/controllers/midi/legacymidicontrollermappingfilehandler.cpp
@@ -68,35 +68,35 @@ LegacyMidiControllerMappingFileHandler::load(const QDomElement& root,
 
             // "normal" is no options
             if (strMidiOption == QLatin1String("invert")) {
-                options.invert = true;
+                options.setFlag(MidiOption::Invert);
             } else if (strMidiOption == QLatin1String("rot64")) {
-                options.rot64 = true;
+                options.setFlag(MidiOption::Rot64);
             } else if (strMidiOption == QLatin1String("rot64inv")) {
-                options.rot64_inv = true;
+                options.setFlag(MidiOption::Rot64Invert);
             } else if (strMidiOption == QLatin1String("rot64fast")) {
-                options.rot64_fast = true;
+                options.setFlag(MidiOption::Rot64Fast);
             } else if (strMidiOption == QLatin1String("diff")) {
-                options.diff = true;
+                options.setFlag(MidiOption::Diff);
             } else if (strMidiOption == QLatin1String("button")) {
-                options.button = true;
+                options.setFlag(MidiOption::Button);
             } else if (strMidiOption == QLatin1String("switch")) {
-                options.sw = true;
+                options.setFlag(MidiOption::Switch);
             } else if (strMidiOption == QLatin1String("hercjog")) {
-                options.herc_jog = true;
+                options.setFlag(MidiOption::HercJog);
             } else if (strMidiOption == QLatin1String("hercjogfast")) {
-                options.herc_jog_fast = true;
+                options.setFlag(MidiOption::HercJogFast);
             } else if (strMidiOption == QLatin1String("spread64")) {
-                options.spread64 = true;
+                options.setFlag(MidiOption::Spread64);
             } else if (strMidiOption == QLatin1String("selectknob")) {
-                options.selectknob = true;
+                options.setFlag(MidiOption::SelectKnob);
             } else if (strMidiOption == QLatin1String("soft-takeover")) {
-                options.soft_takeover = true;
+                options.setFlag(MidiOption::SoftTakeover);
             } else if (strMidiOption == QLatin1String("script-binding")) {
-                options.script = true;
+                options.setFlag(MidiOption::Script);
             } else if (strMidiOption == QLatin1String("fourteen-bit-msb")) {
-                options.fourteen_bit_msb = true;
+                options.setFlag(MidiOption::FourteenBitMSB);
             } else if (strMidiOption == QLatin1String("fourteen-bit-lsb")) {
-                options.fourteen_bit_lsb = true;
+                options.setFlag(MidiOption::FourteenBitLSB);
             }
 
             optionsNode = optionsNode.nextSiblingElement();
@@ -294,67 +294,67 @@ QDomElement LegacyMidiControllerMappingFileHandler::inputMappingToXML(
     QDomElement optionsNode = doc->createElement("options");
 
     // "normal" is no options
-    if (mapping.options.all == 0) {
+    if (!mapping.options) {
         QDomElement singleOption = doc->createElement("normal");
         optionsNode.appendChild(singleOption);
     } else {
-        if (mapping.options.invert) {
+        if (mapping.options.testFlag(MidiOption::Invert)) {
             QDomElement singleOption = doc->createElement("invert");
             optionsNode.appendChild(singleOption);
         }
-        if (mapping.options.rot64) {
+        if (mapping.options.testFlag(MidiOption::Rot64)) {
             QDomElement singleOption = doc->createElement("rot64");
             optionsNode.appendChild(singleOption);
         }
-        if (mapping.options.rot64_inv) {
+        if (mapping.options.testFlag(MidiOption::Rot64Invert)) {
             QDomElement singleOption = doc->createElement("rot64inv");
             optionsNode.appendChild(singleOption);
         }
-        if (mapping.options.rot64_fast) {
+        if (mapping.options.testFlag(MidiOption::Rot64Fast)) {
             QDomElement singleOption = doc->createElement("rot64fast");
             optionsNode.appendChild(singleOption);
         }
-        if (mapping.options.diff) {
+        if (mapping.options.testFlag(MidiOption::Diff)) {
             QDomElement singleOption = doc->createElement("diff");
             optionsNode.appendChild(singleOption);
         }
-        if (mapping.options.button) {
+        if (mapping.options.testFlag(MidiOption::Button)) {
             QDomElement singleOption = doc->createElement("button");
             optionsNode.appendChild(singleOption);
         }
-        if (mapping.options.sw) {
+        if (mapping.options.testFlag(MidiOption::Switch)) {
             QDomElement singleOption = doc->createElement("switch");
             optionsNode.appendChild(singleOption);
         }
-        if (mapping.options.herc_jog) {
+        if (mapping.options.testFlag(MidiOption::HercJog)) {
             QDomElement singleOption = doc->createElement("hercjog");
             optionsNode.appendChild(singleOption);
         }
-        if (mapping.options.herc_jog_fast) {
+        if (mapping.options.testFlag(MidiOption::HercJogFast)) {
             QDomElement singleOption = doc->createElement("hercjogfast");
             optionsNode.appendChild(singleOption);
         }
-        if (mapping.options.spread64) {
+        if (mapping.options.testFlag(MidiOption::Spread64)) {
             QDomElement singleOption = doc->createElement("spread64");
             optionsNode.appendChild(singleOption);
         }
-        if (mapping.options.selectknob) {
+        if (mapping.options.testFlag(MidiOption::SelectKnob)) {
             QDomElement singleOption = doc->createElement("selectknob");
             optionsNode.appendChild(singleOption);
         }
-        if (mapping.options.soft_takeover) {
+        if (mapping.options.testFlag(MidiOption::SoftTakeover)) {
             QDomElement singleOption = doc->createElement("soft-takeover");
             optionsNode.appendChild(singleOption);
         }
-        if (mapping.options.script) {
+        if (mapping.options.testFlag(MidiOption::Script)) {
             QDomElement singleOption = doc->createElement("script-binding");
             optionsNode.appendChild(singleOption);
         }
-        if (mapping.options.fourteen_bit_msb) {
+        if (mapping.options.testFlag(MidiOption::FourteenBitMSB)) {
             QDomElement singleOption = doc->createElement("fourteen-bit-msb");
             optionsNode.appendChild(singleOption);
         }
-        if (mapping.options.fourteen_bit_lsb) {
+        if (mapping.options.testFlag(MidiOption::FourteenBitLSB)) {
             QDomElement singleOption = doc->createElement("fourteen-bit-lsb");
             optionsNode.appendChild(singleOption);
         }
diff --git a/src/controllers/midi/midicontroller.cpp b/src/controllers/midi/midicontroller.cpp
index a7a9af64260..265717f2e21 100644
--- a/src/controllers/midi/midicontroller.cpp
+++ b/src/controllers/midi/midicontroller.cpp
@@ -256,7 +256,7 @@ void MidiController::processInputMapping(const MidiInputMapping& mapping,
     unsigned char channel = MidiUtils::channelFromStatus(status);
     MidiOpCode opCode = MidiUtils::opCodeFromStatus(status);
 
-    if (mapping.options.script) {
+    if (mapping.options.testFlag(MidiOption::Script)) {
         ControllerScriptEngineLegacy* pEngine = getScriptEngine();
         if (pEngine == nullptr) {
             return;
@@ -284,9 +284,8 @@ void MidiController::processInputMapping(const MidiInputMapping& mapping,
 
     double newValue = value;
 
-
-    bool mapping_is_14bit = mapping.options.fourteen_bit_msb ||
-            mapping.options.fourteen_bit_lsb;
+    bool mapping_is_14bit = mapping.options.testFlag(MidiOption::FourteenBitMSB) ||
+            mapping.options.testFlag(MidiOption::FourteenBitLSB);
     if (!mapping_is_14bit && !m_fourteen_bit_queued_mappings.isEmpty()) {
         qWarning() << "MidiController was waiting for the MSB/LSB of a 14-bit"
                    << "message but the next message received was not mapped as 14-bit."
@@ -294,15 +293,20 @@ void MidiController::processInputMapping(const MidiInputMapping& mapping,
         m_fourteen_bit_queued_mappings.clear();
     }
 
-    //qDebug() << "MIDI Options" << QString::number(mapping.options.all, 2).rightJustified(16,'0');
+    //qDebug() << "MIDI Options" << QString::number(mapping.options, 2).rightJustified(16,'0');
 
     if (mapping_is_14bit) {
         bool found = false;
         for (auto it = m_fourteen_bit_queued_mappings.begin();
              it != m_fourteen_bit_queued_mappings.end(); ++it) {
             if (it->first.control == mapping.control) {
-                if ((it->first.options.fourteen_bit_lsb && mapping.options.fourteen_bit_lsb) ||
-                    (it->first.options.fourteen_bit_msb && mapping.options.fourteen_bit_msb)) {
+                if ((it->first.options.testFlag(MidiOption::FourteenBitLSB) &&
+                            mapping.options.testFlag(
+                                    MidiOption::FourteenBitLSB)) ||
+                        (it->first.options.testFlag(
+                                 MidiOption::FourteenBitMSB) &&
+                                mapping.options.testFlag(
+                                        MidiOption::FourteenBitMSB))) {
                     qWarning() << "MidiController: 14-bit MIDI mapping has mis-matched LSB/MSB options."
                                << "Ignoring both messages.";
                     m_fourteen_bit_queued_mappings.erase(it);
@@ -310,12 +314,12 @@ void MidiController::processInputMapping(const MidiInputMapping& mapping,
                 }
 
                 int iValue = 0;
-                if (mapping.options.fourteen_bit_msb) {
+                if (mapping.options.testFlag(MidiOption::FourteenBitMSB)) {
                     iValue = (value << 7) | it->second;
                     // qDebug() << "MSB" << value
                     //          << "LSB" << it->second
                     //          << "Joint:" << iValue;
-                } else if (mapping.options.fourteen_bit_lsb) {
+                } else if (mapping.options.testFlag(MidiOption::FourteenBitLSB)) {
                     iValue = (it->second << 7) | value;
                     // qDebug() << "MSB" << it->second
                     //          << "LSB" << value
@@ -364,11 +368,12 @@ void MidiController::processInputMapping(const MidiInputMapping& mapping,
 
     // ControlPushButton ControlObjects only accept NOTE_ON, so if the midi
     // mapping is <button> we override the Midi 'status' appropriately.
-    if (mapping.options.button || mapping.options.sw) {
+    if (mapping.options.testFlag(MidiOption::Button) ||
+            mapping.options.testFlag(MidiOption::Switch)) {
         opCode = MidiOpCode::NoteOn;
     }
 
-    if (mapping.options.soft_takeover) {
+    if (mapping.options.testFlag(MidiOption::SoftTakeover)) {
         // This is the only place to enable it if it isn't already.
         m_st.enable(pCO);
         if (m_st.ignore(pCO, pCO->getParameterForMidi(newValue))) {
@@ -383,15 +388,15 @@ double MidiController::computeValue(
     double tempval = 0.;
     double diff = 0.;
 
-    if (options.all == 0) {
+    if (!options) {
         return newmidivalue;
     }
 
-    if (options.invert) {
+    if (options.testFlag(MidiOption::Invert)) {
         return 127. - newmidivalue;
     }
 
-    if (options.rot64 || options.rot64_inv) {
+    if (options.testFlag(MidiOption::Rot64) || options.testFlag(MidiOption::Rot64Invert)) {
         tempval = prevmidivalue;
         diff = newmidivalue - 64.;
         if (diff == -1 || diff == 1) {
@@ -399,7 +404,7 @@ double MidiController::computeValue(
         } else {
             diff += (diff > 0 ? -1 : +1);
         }
-        if (options.rot64) {
+        if (options.testFlag(MidiOption::Rot64)) {
             tempval += diff;
         } else {
             tempval -= diff;
@@ -407,7 +412,7 @@ double MidiController::computeValue(
         return (tempval < 0. ? 0. : (tempval > 127. ? 127.0 : tempval));
     }
 
-    if (options.rot64_fast) {
+    if (options.testFlag(MidiOption::Rot64Fast)) {
         tempval = prevmidivalue;
         diff = newmidivalue - 64.;
         diff *= 1.5;
@@ -415,7 +420,7 @@ double MidiController::computeValue(
         return (tempval < 0. ? 0. : (tempval > 127. ? 127.0 : tempval));
     }
 
-    if (options.diff) {
+    if (options.testFlag(MidiOption::Diff)) {
         //Interpret 7-bit signed value using two's compliment.
         if (newmidivalue >= 64.) {
             newmidivalue = newmidivalue - 128.;
@@ -427,7 +432,7 @@ double MidiController::computeValue(
         newmidivalue = prevmidivalue + newmidivalue;
     }
 
-    if (options.selectknob) {
+    if (options.testFlag(MidiOption::SelectKnob)) {
         //Interpret 7-bit signed value using two's compliment.
         if (newmidivalue >= 64.) {
             newmidivalue = newmidivalue - 128.;
@@ -438,15 +443,15 @@ double MidiController::computeValue(
         //Since this is a selection knob, we do not want to inherit previous values.
     }
 
-    if (options.button) {
+    if (options.testFlag(MidiOption::Button)) {
         newmidivalue = newmidivalue != 0;
     }
 
-    if (options.sw) {
+    if (options.testFlag(MidiOption::Switch)) {
         newmidivalue = 1;
     }
 
-    if (options.spread64) {
+    if (options.testFlag(MidiOption::Spread64)) {
         //qDebug() << "MIDI_OPT_SPREAD64";
         // BJW: Spread64: Distance away from centre point (aka "relative CC")
         // Uses a similar non-linear scaling formula as ControlTTRotary::getValueFromWidget()
@@ -462,7 +467,7 @@ double MidiController::computeValue(
         //qDebug() << "Spread64: in " << distance << "  out " << newmidivalue;
     }
 
-    if (options.herc_jog) {
+    if (options.testFlag(MidiOption::HercJog)) {
         if (newmidivalue > 64.) {
             newmidivalue -= 128.;
         }
@@ -470,7 +475,7 @@ double MidiController::computeValue(
         //if (_prevmidivalue != 0.0) { qDebug() << "AAAAAAAAAAAA" << prevmidivalue; }
     }
 
-    if (options.herc_jog_fast) {
+    if (options.testFlag(MidiOption::HercJogFast)) {
         if (newmidivalue > 64.) {
             newmidivalue -= 128.;
         }
@@ -511,7 +516,7 @@ void MidiController::processInputMapping(const MidiInputMapping& mapping,
                                          const QByteArray& data,
                                          mixxx::Duration timestamp) {
     // Custom script handler
-    if (mapping.options.script) {
+    if (mapping.options.testFlag(MidiOption::Script)) {
         ControllerScriptEngineLegacy* pEngine = getScriptEngine();
         if (pEngine == nullptr) {
             return;
diff --git a/src/controllers/midi/midimessage.h b/src/controllers/midi/midimessage.h
index 5bae12783f8..6b6f1dc2402 100644
--- a/src/controllers/midi/midimessage.h
+++ b/src/controllers/midi/midimessage.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#include <QFlags>
 #include <QList>
 #include <QMetaType>
 #include <QPair>
@@ -99,61 +100,36 @@ uint qHash(MidiOpCode key, uint seed);
 typedef unsigned int    uint32_t;
 typedef unsigned short  uint16_t;
 
-typedef enum {
-    MIDI_OPTION_NONE          = 0x0000,
-    MIDI_OPTION_INVERT        = 0x0001,
-    MIDI_OPTION_ROT64         = 0x0002,
-    MIDI_OPTION_ROT64_INV     = 0x0004,
-    MIDI_OPTION_ROT64_FAST    = 0x0008,
-    MIDI_OPTION_DIFF          = 0x0010,
-    MIDI_OPTION_BUTTON        = 0x0020,
-    MIDI_OPTION_SWITCH        = 0x0040,
-    MIDI_OPTION_SPREAD64      = 0x0080,
-    MIDI_OPTION_HERC_JOG      = 0x0100,
-    MIDI_OPTION_SELECTKNOB    = 0x0200,
-    MIDI_OPTION_SOFT_TAKEOVER = 0x0400,
-    MIDI_OPTION_SCRIPT        = 0x0800,
-    MIDI_OPTION_14BIT_MSB     = 0x1000,
-    MIDI_OPTION_14BIT_LSB     = 0x2000,
-    // Should mask all bits used.
-    MIDI_OPTION_MASK          = 0xFFFF,
-} MidiOption;
-
-struct MidiOptions {
-    MidiOptions()
-            : all(0) {
-    }
-
-    bool operator==(const MidiOptions& other) const {
-        return all == other.all;
-    }
-
-    union
-    {
-        uint32_t    all;
-        struct
-        {
-            bool invert        : 1;
-            bool rot64         : 1;
-            bool rot64_inv     : 1;
-            bool rot64_fast    : 1;
-            bool diff          : 1;
-            bool button        : 1;    // Button Down (!=00) and Button Up (00) events happen together
-            bool sw            : 1;    // button down (!=00) and button up (00) events happen separately
-            bool spread64      : 1;    // accelerated difference from 64
-            bool herc_jog      : 1;    // generic Hercules range correction 0x01 -> +1; 0x7f -> -1
-            bool selectknob    : 1;    // relative knob which can be turned forever and outputs a signed value
-            bool soft_takeover : 1;    // prevents sudden changes when hardware position differs from software value
-            bool script        : 1;    // maps a MIDI control to a custom MixxxScript function
-            // the message supplies the MSB of a 14-bit message
-            bool fourteen_bit_msb : 1;
-            // the message supplies the LSB of a 14-bit message
-            bool fourteen_bit_lsb : 1;
-            bool herc_jog_fast    : 1;  // generic Hercules range correction 0x01 -> +5; 0x7f -> -5
-            // 19 more available for future expansion
-        };
-    };
+enum class MidiOption : uint16_t {
+    None = 0x0000,
+    Invert = 0x0001,
+    Rot64 = 0x0002,
+    Rot64Invert = 0x0004,
+    Rot64Fast = 0x0008,
+    Diff = 0x0010,
+    /// Button Down (!=00) and Button Up (00) events happen together
+    Button = 0x0020,
+    /// Button Down (!=00) and Button Up (00) events happen separately
+    Switch = 0x0040,
+    /// Accelerated Difference from 64
+    Spread64 = 0x0080,
+    /// Generic Hercules Range Correction (0x01 -> +1; 0x7f -> -1)
+    HercJog = 0x0100,
+    /// Relative Knob which can be turned forever and outputs a signed value
+    SelectKnob = 0x0200,
+    /// Prevents Sudden Changes when hardware position differs from software value
+    SoftTakeover = 0x0400,
+    /// Maps a MIDI control to a custom JavaScript function
+    Script = 0x0800,
+    /// Nessage supplies the LSB of a 14-bit message
+    FourteenBitLSB = 0x1000,
+    /// Nessage supplies the MSB of a 14-bit message
+    FourteenBitMSB = 0x2000,
+    /// Generic Hercules Range Correction (0x01 -> +5; 0x7f -> -5)
+    HercJogFast = 0x4000,
 };
+Q_DECLARE_FLAGS(MidiOptions, MidiOption);
+Q_DECLARE_OPERATORS_FOR_FLAGS(MidiOptions);
 Q_DECLARE_METATYPE(MidiOptions);
 
 struct MidiOutput {
diff --git a/src/controllers/midi/midiutils.cpp b/src/controllers/midi/midiutils.cpp
index b3edd7b6e55..73f999f902d 100644
--- a/src/controllers/midi/midiutils.cpp
+++ b/src/controllers/midi/midiutils.cpp
@@ -27,39 +27,39 @@ QString MidiUtils::formatByteAsHex(unsigned char value) {
 // static
 QString MidiUtils::midiOptionToTranslatedString(MidiOption option) {
     switch (option) {
-        case MIDI_OPTION_NONE:
-            return QObject::tr("Normal");
-        case MIDI_OPTION_INVERT:
-            return QObject::tr("Invert");
-        case MIDI_OPTION_ROT64:
-            return QObject::tr("Rot64");
-        case MIDI_OPTION_ROT64_INV:
-            return QObject::tr("Rot64Inv");
-        case MIDI_OPTION_ROT64_FAST:
-            return QObject::tr("Rot64Fast");
-        case MIDI_OPTION_DIFF:
-            return QObject::tr("Diff");
-        case MIDI_OPTION_BUTTON:
-            return QObject::tr("Button");
-        case MIDI_OPTION_SWITCH:
-            return QObject::tr("Switch");
-        case MIDI_OPTION_SPREAD64:
-            return QObject::tr("Spread64");
-        case MIDI_OPTION_HERC_JOG:
-            return QObject::tr("HercJog");
-        case MIDI_OPTION_SELECTKNOB:
-            return QObject::tr("SelectKnob");
-        case MIDI_OPTION_SOFT_TAKEOVER:
-            return QObject::tr("SoftTakeover");
-        case MIDI_OPTION_SCRIPT:
-            return QObject::tr("Script");
-        case MIDI_OPTION_14BIT_LSB:
-            return QObject::tr("14-bit (LSB)");
-        case MIDI_OPTION_14BIT_MSB:
-            return QObject::tr("14-bit (MSB)");
-        default:
-            return QObject::tr("Unknown (0x%1)")
-                    .arg(option, 4, 16, QLatin1Char('0'));
+    case MidiOption::None:
+        return QObject::tr("Normal");
+    case MidiOption::Invert:
+        return QObject::tr("Invert");
+    case MidiOption::Rot64:
+        return QObject::tr("Rot64");
+    case MidiOption::Rot64Invert:
+        return QObject::tr("Rot64Inv");
+    case MidiOption::Rot64Fast:
+        return QObject::tr("Rot64Fast");
+    case MidiOption::Diff:
+        return QObject::tr("Diff");
+    case MidiOption::Button:
+        return QObject::tr("Button");
+    case MidiOption::Switch:
+        return QObject::tr("Switch");
+    case MidiOption::Spread64:
+        return QObject::tr("Spread64");
+    case MidiOption::HercJog:
+        return QObject::tr("HercJog");
+    case MidiOption::SelectKnob:
+        return QObject::tr("SelectKnob");
+    case MidiOption::SoftTakeover:
+        return QObject::tr("SoftTakeover");
+    case MidiOption::Script:
+        return QObject::tr("Script");
+    case MidiOption::FourteenBitLSB:
+        return QObject::tr("14-bit (LSB)");
+    case MidiOption::FourteenBitMSB:
+        return QObject::tr("14-bit (MSB)");
+    default:
+        return QObject::tr("Unknown (0x%1)")
+                .arg(static_cast<uint16_t>(option), 4, 16, QLatin1Char('0'));
     }
 }
 
diff --git a/src/test/learningutilstest.cpp b/src/test/learningutilstest.cpp
index 9910f596ef3..e40cdbb3d19 100644
--- a/src/test/learningutilstest.cpp
+++ b/src/test/learningutilstest.cpp
@@ -7,7 +7,7 @@
 #include "util/memory.h"
 
 std::ostream& operator<<(std::ostream& stream, const MidiInputMapping& mapping) {
-    stream << mapping.key.key << mapping.options.all;
+    stream << mapping.key.key << static_cast<uint16_t>(mapping.options);
     return stream;
 }
 
@@ -219,7 +219,7 @@ TEST_F(LearningUtilsTest, CC14BitKnob_MSBFirst) {
 
     ASSERT_EQ(2, mappings.size());
     MidiOptions lsb_option;
-    lsb_option.fourteen_bit_lsb = true;
+    lsb_option.setFlag(MidiOption::FourteenBitLSB);
     EXPECT_TRUE(containsMapping(mappings,
             MidiInputMapping(MidiKey(MidiUtils::statusFromOpCodeAndChannel(
                                              MidiOpCode::ControlChange, 0x01),
@@ -227,7 +227,7 @@ TEST_F(LearningUtilsTest, CC14BitKnob_MSBFirst) {
                     lsb_option,
                     control)));
     MidiOptions msb_option;
-    msb_option.fourteen_bit_msb = true;
+    msb_option.setFlag(MidiOption::FourteenBitMSB);
     EXPECT_TRUE(containsMapping(mappings,
             MidiInputMapping(MidiKey(MidiUtils::statusFromOpCodeAndChannel(
                                              MidiOpCode::ControlChange, 0x01),
@@ -272,7 +272,7 @@ TEST_F(LearningUtilsTest, CC14BitKnob_LSBFirst) {
 
     ASSERT_EQ(2, mappings.size());
     MidiOptions lsb_option;
-    lsb_option.fourteen_bit_lsb = true;
+    lsb_option.setFlag(MidiOption::FourteenBitLSB);
     EXPECT_TRUE(containsMapping(mappings,
             MidiInputMapping(MidiKey(MidiUtils::statusFromOpCodeAndChannel(
                                              MidiOpCode::ControlChange, 0x01),
@@ -280,7 +280,7 @@ TEST_F(LearningUtilsTest, CC14BitKnob_LSBFirst) {
                     lsb_option,
                     control)));
     MidiOptions msb_option;
-    msb_option.fourteen_bit_msb = true;
+    msb_option.setFlag(MidiOption::FourteenBitMSB);
     EXPECT_TRUE(containsMapping(mappings,
             MidiInputMapping(MidiKey(MidiUtils::statusFromOpCodeAndChannel(
                                              MidiOpCode::ControlChange, 0x01),
@@ -303,7 +303,7 @@ TEST_F(LearningUtilsTest, CC7BitKnob_ConfusableForCC7BitTicker_Zeroes) {
             LearningUtils::guessMidiInputMappings(control, m_messages);
 
     MidiOptions options;
-    options.selectknob = true;
+    options.setFlag(MidiOption::SelectKnob);
     ASSERT_EQ(1, mappings.size());
     EXPECT_EQ(MidiInputMapping(MidiKey(MidiUtils::statusFromOpCodeAndChannel(
                                                MidiOpCode::ControlChange, 0x01),
@@ -494,7 +494,7 @@ TEST_F(LearningUtilsTest, CC7BitTicker) {
 
     ASSERT_EQ(1, mappings.size());
     MidiOptions options;
-    options.selectknob = true;
+    options.setFlag(MidiOption::SelectKnob);
     EXPECT_EQ(MidiInputMapping(MidiKey(MidiUtils::statusFromOpCodeAndChannel(
                                                MidiOpCode::ControlChange, 0x01),
                                        0x10),
@@ -522,7 +522,7 @@ TEST_F(LearningUtilsTest, Spread64Ticker) {
 
     ASSERT_EQ(1, mappings.size());
     MidiOptions options;
-    options.spread64 = true;
+    options.setFlag(MidiOption::Spread64);
     EXPECT_EQ(MidiInputMapping(MidiKey(MidiUtils::statusFromOpCodeAndChannel(
                                                MidiOpCode::ControlChange, 0x01),
                                        0x10),
@@ -548,7 +548,7 @@ TEST_F(LearningUtilsTest, CC7BitTicker_SingleDirection) {
     addMessage(MidiOpCode::ControlChange, 0x01, 0x10, 0x01);
 
     MidiOptions options;
-    options.selectknob = true;
+    options.setFlag(MidiOption::SelectKnob);
 
     ConfigKey control("[Test]", "SomeControl");
     MidiInputMappings mappings =
@@ -594,7 +594,7 @@ TEST_F(LearningUtilsTest, SingleMessageSwitchMode_NoteOn) {
 
     ASSERT_EQ(1, mappings.size());
     MidiOptions options;
-    options.sw = true;
+    options.setFlag(MidiOption::Switch);
     EXPECT_EQ(MidiInputMapping(MidiKey(MidiUtils::statusFromOpCodeAndChannel(
                                                MidiOpCode::NoteOn, 0x01),
                                        0x10),
@@ -633,7 +633,7 @@ TEST_F(LearningUtilsTest, SingleMessageSwitchMode_CC) {
 
     ASSERT_EQ(1, mappings.size());
     MidiOptions options;
-    options.sw = true;
+    options.setFlag(MidiOption::Switch);
     EXPECT_EQ(MidiInputMapping(MidiKey(MidiUtils::statusFromOpCodeAndChannel(
                                                MidiOpCode::ControlChange, 0x01),
                                        0x10),
diff --git a/src/test/midicontrollertest.cpp b/src/test/midicontrollertest.cpp
index 3aefa07d8dd..7a8e701dc0f 100644
--- a/src/test/midicontrollertest.cpp
+++ b/src/test/midicontrollertest.cpp
@@ -126,7 +126,7 @@ TEST_F(MidiControllerTest, ReceiveMessage_PushButtonCO_ToggleOnOff_ButtonMidiOpt
     unsigned char control = 0x10;
 
     MidiOptions options;
-    options.button = true;
+    options.setFlag(MidiOption::Button);
 
     addMapping(MidiInputMapping(MidiKey(MidiUtils::statusFromOpCodeAndChannel(
                                                 MidiOpCode::NoteOn, channel),
@@ -163,7 +163,7 @@ TEST_F(MidiControllerTest, ReceiveMessage_PushButtonCO_ToggleOnOff_SwitchMidiOpt
     unsigned char control = 0x10;
 
     MidiOptions options;
-    options.sw = true;
+    options.setFlag(MidiOption::Switch);
 
     addMapping(MidiInputMapping(MidiKey(MidiUtils::statusFromOpCodeAndChannel(
                                                 MidiOpCode::NoteOn, channel),
@@ -314,7 +314,7 @@ TEST_F(MidiControllerTest, ReceiveMessage_ToggleCO_ToggleOnOff_ButtonMidiOption)
     unsigned char control = 0x10;
 
     MidiOptions options;
-    options.button = true;
+    options.setFlag(MidiOption::Button);
 
     addMapping(MidiInputMapping(MidiKey(MidiUtils::statusFromOpCodeAndChannel(
                                                 MidiOpCode::NoteOn, channel),
@@ -354,7 +354,7 @@ TEST_F(MidiControllerTest, ReceiveMessage_ToggleCO_ToggleOnOff_SwitchMidiOption)
     unsigned char control = 0x10;
 
     MidiOptions options;
-    options.sw = true;
+    options.setFlag(MidiOption::Switch);
 
     addMapping(MidiInputMapping(MidiKey(MidiUtils::statusFromOpCodeAndChannel(
                                                 MidiOpCode::NoteOn, channel),
@@ -476,10 +476,10 @@ TEST_F(MidiControllerTest, ReceiveMessage_PotMeterCO_14BitCC) {
     unsigned char msb_control = 0x11;
 
     MidiOptions lsb;
-    lsb.fourteen_bit_lsb = true;
+    lsb.setFlag(MidiOption::FourteenBitLSB);
 
     MidiOptions msb;
-    msb.fourteen_bit_msb = true;
+    msb.setFlag(MidiOption::FourteenBitMSB);
 
     addMapping(MidiInputMapping(
             MidiKey(MidiUtils::statusFromOpCodeAndChannel(