From a0f3f7de07da006799cdbff86251ee7f8d29a739 Mon Sep 17 00:00:00 2001
From: Phil Taylor <phil@m0vse.uk>
Date: Sun, 2 Apr 2023 20:07:13 +0100
Subject: [PATCH] More work, tidying and improving stablity

---
 controllersetup.cpp | 582 ++++++++++++++++++-------------
 controllersetup.h   |  46 ++-
 usbcontroller.cpp   | 833 +++++++++++++++++++++++---------------------
 usbcontroller.h     |  47 ++-
 wfmain.cpp          | 128 ++++---
 wfmain.h            |   7 +-
 wfviewtypes.h       |   2 +-
 7 files changed, 920 insertions(+), 725 deletions(-)

diff --git a/controllersetup.cpp b/controllersetup.cpp
index 8390868..6b267f5 100644
--- a/controllersetup.cpp
+++ b/controllersetup.cpp
@@ -17,6 +17,9 @@ controllerSetup::controllerSetup(QWidget* parent) :
 
 controllerSetup::~controllerSetup()
 {
+    qInfo(logUsbControl()) << "Deleting controllerSetup() window";
+    delete noControllersText;
+    delete updateDialog;
     delete ui;
 }
 
@@ -32,17 +35,20 @@ void controllerSetup::on_tabWidget_currentChanged(int index)
         updateDialog->hide();
 }
 
-
-void controllerSetup::init()
+void controllerSetup::init(usbDevMap* dev, QVector<BUTTON>* but, QVector<KNOB>* kb, QVector<COMMAND>* cmd, QMutex* mut)
 {
+    // Store pointers to all current settings
+    devices = dev;
+    buttons = but;
+    knobs = kb;
+    commands = cmd;
+    mutex = mut;
 
     updateDialog = new QDialog(this);
     // Not sure if I like it Frameless or not?
     updateDialog->setWindowFlags(Qt::FramelessWindowHint | Qt::Dialog);
 
-    QGridLayout* udLayout = new QGridLayout;
-    updateDialog->setLayout(udLayout);
-    updateDialog->setBaseSize(1, 1);
+    QGridLayout* udLayout = new QGridLayout(updateDialog);
 
     onLabel = new QLabel("On");
     udLayout->addWidget(onLabel,0,0);
@@ -85,6 +91,30 @@ void controllerSetup::init()
 
     updateDialog->hide();
 
+    onEvent->clear();
+    offEvent->clear();
+    knobEvent->clear();
+
+    for (COMMAND& c : *commands) {
+        if (c.cmdType == commandButton || c.cmdType == commandAny) {
+            if (c.command == cmdSeparator) {
+                onEvent->insertSeparator(onEvent->count());
+                offEvent->insertSeparator(offEvent->count());
+
+            } else {
+                onEvent->addItem(c.text, c.index);
+                offEvent->addItem(c.text, c.index);
+            }
+        }
+        else if (c.cmdType == commandKnob || c.cmdType == commandAny) {
+            if (c.command == cmdSeparator) {
+                knobEvent->insertSeparator(knobEvent->count());
+            } else {
+                knobEvent->addItem(c.text, c.index);
+            }
+        }
+    }
+
     connect(offEvent, SIGNAL(currentIndexChanged(int)), this, SLOT(offEventIndexChanged(int)));
     connect(onEvent, SIGNAL(currentIndexChanged(int)), this, SLOT(onEventIndexChanged(int)));
     connect(knobEvent, SIGNAL(currentIndexChanged(int)), this, SLOT(knobEventIndexChanged(int)));
@@ -103,17 +133,18 @@ void controllerSetup::mousePressed(controllerScene* scene, QPoint p)
         
     QPoint gp = this->mapToGlobal(p);
 
+
     // Did the user click on a button?
-    auto b = std::find_if(buttons->begin(), buttons->end(), [p, this](BUTTON& b)
+    auto but = std::find_if(buttons->begin(), buttons->end(), [p, this](BUTTON& b)
     { return (b.parent != Q_NULLPTR && b.pos.contains(p) && b.page == b.parent->currentPage && ui->tabWidget->currentWidget()->objectName() == b.path ); });
 
-    if (b != buttons->end())
+    if (but != buttons->end())
     {
-        currentButton = b;
+        currentButton = but;
         currentKnob = Q_NULLPTR;
         qDebug() << "Button" << currentButton->num << "On Event" << currentButton->onCommand->text << "Off Event" << currentButton->offCommand->text;
 
-        updateDialog->setWindowTitle(QString("Update button %0").arg(b->num));
+        updateDialog->setWindowTitle(QString("Update button %0").arg(but->num));
 
         onEvent->blockSignals(true);
         onEvent->setCurrentIndex(onEvent->findData(currentButton->onCommand->index));
@@ -166,16 +197,16 @@ void controllerSetup::mousePressed(controllerScene* scene, QPoint p)
         updateDialog->raise();
     } else {
         // It wasn't a button so was it a knob?
-        auto k = std::find_if(knobs->begin(), knobs->end(), [p, this](KNOB& k)
+        auto kb = std::find_if(knobs->begin(), knobs->end(), [p, this](KNOB& k)
         { return (k.parent != Q_NULLPTR && k.pos.contains(p) && k.page == k.parent->currentPage && ui->tabWidget->currentWidget()->objectName() == k.path ); });
 
-        if (k != knobs->end())
+        if (kb != knobs->end())
         {
-            currentKnob = k;
+            currentKnob = kb;
             currentButton = Q_NULLPTR;
             qDebug() << "Knob" << currentKnob->num << "Event" << currentKnob->command->text;
 
-            updateDialog->setWindowTitle(QString("Update knob %0").arg(k->num));
+            updateDialog->setWindowTitle(QString("Update knob %0").arg(kb->num));
 
             knobEvent->blockSignals(true);
             knobEvent->setCurrentIndex(knobEvent->findData(currentKnob->command->index));
@@ -213,9 +244,7 @@ void controllerSetup::onEventIndexChanged(int index) {
     // If command is changed, delete current command and deep copy the new command
     if (currentButton != Q_NULLPTR && onEvent->currentData().toInt() < commands->size()) {
         QMutexLocker locker(mutex);
-        if (currentButton->onCommand)
-            delete currentButton->onCommand;
-        currentButton->onCommand = new COMMAND(commands->at(onEvent->currentData().toInt()));
+        currentButton->onCommand = &commands->at(onEvent->currentData().toInt());
         currentButton->onText->setPlainText(currentButton->onCommand->text);
         currentButton->onText->setPos(currentButton->pos.center().x() - currentButton->onText->boundingRect().width() / 2,
             (currentButton->pos.center().y() - currentButton->onText->boundingRect().height() / 2)-6);
@@ -230,9 +259,7 @@ void controllerSetup::offEventIndexChanged(int index) {
     // If command is changed, delete current command and deep copy the new command
     if (currentButton != Q_NULLPTR && offEvent->currentData().toInt() < commands->size()) {
         QMutexLocker locker(mutex);
-        if (currentButton->offCommand)
-            delete currentButton->offCommand;
-        currentButton->offCommand = new COMMAND(commands->at(offEvent->currentData().toInt()));
+        currentButton->offCommand = &commands->at(offEvent->currentData().toInt());
         currentButton->offText->setPlainText(currentButton->offCommand->text);
         currentButton->offText->setPos(currentButton->pos.center().x() - currentButton->offText->boundingRect().width() / 2,
             (currentButton->pos.center().y() - currentButton->offText->boundingRect().height() / 2)+6);
@@ -248,7 +275,7 @@ void controllerSetup::knobEventIndexChanged(int index) {
         QMutexLocker locker(mutex);
         if (currentKnob->command)
             delete currentKnob->command;
-        currentKnob->command = new COMMAND(commands->at(knobEvent->currentData().toInt()));
+        currentKnob->command = &commands->at(knobEvent->currentData().toInt());
         currentKnob->text->setPlainText(currentKnob->command->text);
         currentKnob->text->setPos(currentKnob->pos.center().x() - currentKnob->text->boundingRect().width() / 2,
             (currentKnob->pos.center().y() - currentKnob->text->boundingRect().height() / 2));
@@ -312,28 +339,108 @@ void controllerSetup::latchStateChanged(int state)
     }
 }
 
+void controllerSetup::deleteMyWidget(QWidget* widget) {
+    QLayout *layout = widget->layout();
+    if (widget->layout())
+    {
+        QLayoutItem* child;
+        while (nullptr != (child = layout->takeAt(0)))
+        {
+            if (child->layout())
+            {
+                QLayoutItem* child2;
+
+                while (nullptr != (child2 = child->layout()->takeAt(0)))
+                {
+                    if (child2->widget())
+                    {
+                        deleteMyWidget(child2->widget());
+                    }
+                    delete child2;
+                    child2 = Q_NULLPTR;
+                }
+            }
+            else if (child->widget())
+            {
+                deleteMyWidget(child->widget());
+            }
+            delete child;
+            child = Q_NULLPTR;
+        }
+    }
+    delete widget;
+}
+
 void controllerSetup::removeDevice(USBDEVICE* dev)
 {
     QMutexLocker locker(mutex);
 
-    int remove = -1;
+    /* We need to manually delete everything that has been created for this tab */
+    auto tab = tabs.find(dev->path);
+    if (tab == tabs.end())
+    {
+        qWarning(logUsbControl()) << "Cannot find tabContent for deleted tab" << dev->path;
+        return;
+    }
 
-    for (int i = 0; i < ui->tabWidget->count(); i++) {
-        auto widget = ui->tabWidget->widget(i);
-        if (widget->objectName() == dev->path) {
-            qInfo(logUsbControl()) << "Removing child widgets for" << dev->product;
-            qDeleteAll(widget->findChildren<QWidget *>("", Qt::FindDirectChildrenOnly));
-            remove = i;
-            //break;
+    for (auto b = buttons->begin();b != buttons->end(); b++)
+    {
+        if (b->parent == dev && b->page == dev->currentPage)
+        {
+            if (b->onText != Q_NULLPTR) {
+                tab.value()->scene->removeItem(b->onText);
+                delete b->onText;
+                b->onText = Q_NULLPTR;
+                b->onCommand = Q_NULLPTR;
+            }
+            if (b->offText != Q_NULLPTR) {
+                tab.value()->scene->removeItem(b->offText);
+                delete b->offText;
+                b->offText = Q_NULLPTR;
+                b->offCommand = Q_NULLPTR;
+            }
+            if (b->icon != Q_NULLPTR) {
+                delete b->icon;
+                b->icon=Q_NULLPTR;
+            }
         }
     }
 
-    if (remove != -1) {
-        qInfo(logUsbControl()) << "Removing tab" << dev->product;
-        //auto widget = ui->tabWidget->widget(remove);
-        ui->tabWidget->removeTab(remove);
-        //widget->deleteLater();
+    for (auto k = knobs->begin();k != knobs->end(); k++)
+    {
+        if (k->parent == dev && k->page == dev->currentPage)
+        {
+            if (k->text != Q_NULLPTR) {
+                tab.value()->scene->removeItem(k->text);
+                delete k->text;
+                k->text = Q_NULLPTR;
+                k->command = Q_NULLPTR;
+            }
+        }
     }
+
+
+    qDebug(logUsbControl()) << "Removing tab content" << dev->product;
+
+    if (tab.value()->bgImage != Q_NULLPTR) {
+        tab.value()->scene->removeItem(tab.value()->bgImage);
+        delete tab.value()->bgImage;
+    }
+    delete tab.value()->scene;
+
+    // Find the tab within the tabWidget
+    for (int i = 0; i < ui->tabWidget->count(); i++) {
+        auto widget = ui->tabWidget->widget(i);
+        if (widget->objectName() == dev->path) {
+            ui->tabWidget->removeTab(i);
+            break;
+        }
+    }
+
+    delete tab.value();
+    tabs.remove(dev->path);
+
+    // Hide the tabWidget if no tabs exist
     if (ui->tabWidget->count() == 0)
     {
         ui->tabWidget->hide();
@@ -342,13 +449,8 @@ void controllerSetup::removeDevice(USBDEVICE* dev)
     }
 }
 
-void controllerSetup::newDevice(USBDEVICE* dev, CONTROLLER* cntrl, QVector<BUTTON>* but, QVector<KNOB>* kb, QVector<COMMAND>* cmd, QMutex* mut)
+void controllerSetup::newDevice(USBDEVICE* dev)
 {
-    buttons = but;
-    knobs = kb;
-    commands = cmd;
-    mutex = mut;
-
     QMutexLocker locker(mutex);
 
     for (int i=0; i<ui->tabWidget->count();i++) {
@@ -359,262 +461,215 @@ void controllerSetup::newDevice(USBDEVICE* dev, CONTROLLER* cntrl, QVector<BUTTO
         }
     }
 
+    auto tab = tabs.find(dev->path);
+    if (tab != tabs.end())
+    {
+        qInfo(logUsbControl()) <<"Tab content for " << dev->product << "("<< dev->path << ") Already exists!";
+        return;
+    }
+
+
     qDebug(logUsbControl()) << "Adding new tab for" << dev->product;
     noControllersText->hide();
 
-    QWidget* tab = new QWidget();
-    tab->setObjectName(dev->path);
+    tabContent* c = new tabContent();
 
-    ui->tabWidget->addTab(tab,dev->product);
-    ui->tabWidget->show();
+    c->tab.setObjectName(dev->path);
+    ui->tabWidget->addTab(&c->tab,dev->product);
+    c->tab.setLayout(&c->mainLayout);
+    c->mainLayout.addLayout(&c->topLayout);
+    c->mainLayout.addWidget(&c->widget);
 
-    QVBoxLayout* mainlayout = new QVBoxLayout();
-    mainlayout->setContentsMargins(0,0,0,0);
-    tab->setLayout(mainlayout);
+    c->widget.setLayout(&c->layout);
+    c->layout.addLayout(&c->sensLayout);
 
 
-    QHBoxLayout* toplayout = new QHBoxLayout();
-    mainlayout->addLayout(toplayout);
-    toplayout->setContentsMargins(0,0,0,0);
+    c->topLayout.addWidget(&c->disabled);
+    c->disabled.setText("Disable");
+    connect(&c->disabled, qOverload<bool>(&QCheckBox::clicked),
+        [dev,this,c](bool checked) { this->disableClicked(dev,checked,&c->widget); });
+    c->disabled.setChecked(dev->disabled);
 
-    QWidget* widget = new QWidget();
-    mainlayout->addWidget(widget);
-    QVBoxLayout* layout = new QVBoxLayout(widget);
-    layout->setContentsMargins(0,0,0,0);
-
-    QCheckBox* disabled = new QCheckBox();
-    disabled->setText("Disable");
-    toplayout->addWidget(disabled);
-    dev->message = new QLabel();
     if (dev->connected) {
-        dev->message->setStyleSheet("QLabel { color : green; }");
-        dev->message->setText("Connected");
+        c->message.setStyleSheet("QLabel { color : green; }");
+        c->message.setText("Connected");
     } else {
-        dev->message->setStyleSheet("QLabel { color : red; }");
-        dev->message->setText("Not Connected");
+        c->message.setStyleSheet("QLabel { color : red; }");
+        c->message.setText("Not Connected");
     }
 
-    toplayout->addWidget(dev->message);
-    dev->message->setAlignment(Qt::AlignRight);
+    c->topLayout.addWidget(&c->message);
+    c->message.setAlignment(Qt::AlignRight);
 
-    connect(disabled, qOverload<bool>(&QCheckBox::clicked),
-        [dev,this,widget](bool checked) { this->disableClicked(dev,checked,widget); });
+    c->layout.addWidget(&c->view);
 
-    disabled->setChecked(dev->disabled);
+    c->page.setObjectName("Page SpinBox");
+    c->page.setValue(1);
+    c->page.setMinimum(1);
+    c->page.setMaximum(dev->pages);
+    c->page.setToolTip("Select current page to edit");
+    c->layout.addWidget(&c->page,0,Qt::AlignBottom | Qt::AlignRight);
+    dev->pageSpin = &c->page;
 
-    QGraphicsView *view = new QGraphicsView();
-    layout->addWidget(view);
-
-    QSpinBox *page = new QSpinBox();
-    page->setValue(1);
-    page->setMinimum(1);
-    page->setMaximum(dev->pages);
-    page->setToolTip("Select current page to edit");
-    layout->addWidget(page,0,Qt::AlignBottom | Qt::AlignRight);
-    dev->pageSpin = page;
-
-
-    QHBoxLayout* senslayout = new QHBoxLayout();
-    layout->addLayout(senslayout);
-    QLabel* senslabel = new QLabel("Sensitivity");
-    senslayout->addWidget(senslabel);
-    QSlider *sens = new QSlider();
-    sens->setMinimum(1);
-    sens->setMaximum(21);
-    sens->setOrientation(Qt::Horizontal);
-    sens->setInvertedAppearance(true);
-    senslayout->addWidget(sens);
-    sens->setValue(cntrl->sensitivity);
-    connect(sens, &QSlider::valueChanged,
+    c->sensLayout.addWidget(&c->sensLabel);
+    c->sens.setMinimum(1);
+    c->sens.setMaximum(21);
+    c->sens.setOrientation(Qt::Horizontal);
+    c->sens.setInvertedAppearance(true);
+    c->sensLayout.addWidget(&c->sens);
+    c->sens.setValue(dev->sensitivity);
+    connect(&c->sens, &QSlider::valueChanged,
         [dev,this](int val) { this->sensitivityMoved(dev,val); });
 
-    QImage image;
-
     switch (dev->type.model) {
         case shuttleXpress:
-            image.load(":/resources/shuttlexpress.png");
+            c->image.load(":/resources/shuttlexpress.png");
             break;
         case shuttlePro2:
-            image.load(":/resources/shuttlepro.png");
+            c->image.load(":/resources/shuttlepro.png");
             break;
         case RC28:
-            image.load(":/resources/rc28.png");
+            c->image.load(":/resources/rc28.png");
             break;
         case xBoxGamepad:
-            image.load(":/resources/xbox.png");
+            c->image.load(":/resources/xbox.png");
             break;
         case eCoderPlus:
-            image.load(":/resources/ecoder.png");
+            c->image.load(":/resources/ecoder.png");
             break;
         case QuickKeys:
-            image.load(":/resources/quickkeys.png");
+            c->image.load(":/resources/quickkeys.png");
             break;
         case StreamDeckOriginal:
         case StreamDeckOriginalV2:
         case StreamDeckOriginalMK2:
-            image.load(":/resources/streamdeck.png");
+            c->image.load(":/resources/streamdeck.png");
             break;
         case StreamDeckMini:
         case StreamDeckMiniV2:
-            image.load(":/resources/streamdeckmini.png");
+            c->image.load(":/resources/streamdeckmini.png");
             break;
         case StreamDeckXL:
         case StreamDeckXLV2:
-            image.load(":/resources/streamdeckxl.png");
+            c->image.load(":/resources/streamdeckxl.png");
             break;
         case StreamDeckPlus:
-            image.load(":/resources/streamdeckplus.png");
+            c->image.load(":/resources/streamdeckplus.png");
             break;
-        default:
-            //ui->graphicsView->setSceneRect(scene->itemsBoundingRect());
+        case StreamDeckPedal:
+            c->image.load(":/resources/streamdeckpedal.png");
+            break;
+            default:
             this->adjustSize();
             break;
     }
 
-    QGraphicsItem* bgImage = new QGraphicsPixmapItem(QPixmap::fromImage(image));
-    view->setMinimumSize(bgImage->boundingRect().width() + 2, bgImage->boundingRect().height() + 2);
+    c->bgImage = new QGraphicsPixmapItem(QPixmap::fromImage(c->image));
+    c->view.setMinimumSize(c->bgImage->boundingRect().width() + 2, c->bgImage->boundingRect().height() + 2);
+
+    ui->tabWidget->show();
+
 
     // This command causes the window to disappear in Linux?
 #if !defined(Q_OS_LINUX)
-    this->setMinimumSize(bgImage->boundingRect().width() + 2, bgImage->boundingRect().height() + 250);
+    this->setMinimumSize(c->bgImage->boundingRect().width() + 2, c->bgImage->boundingRect().height() + 250);
 #endif
 
-    controllerScene * scene = new controllerScene();
-    dev->scene = scene;
-    view->setScene(scene);
-    connect(scene, SIGNAL(mousePressed(controllerScene*,QPoint)), this, SLOT(mousePressed(controllerScene*,QPoint)));
-    scene->addItem(bgImage);
+    c->scene = new controllerScene();
+    c->view.setScene(c->scene);
+    connect(c->scene, SIGNAL(mousePressed(controllerScene*,QPoint)), this, SLOT(mousePressed(controllerScene*,QPoint)));
+    c->scene->addItem(c->bgImage);
 
+    c->layout.addLayout(&c->grid);
 
-    QGridLayout* grid = new QGridLayout();
-    layout->addLayout(grid);
-
-    QLabel* brightlabel = new QLabel("Brightness");
-    grid->addWidget(brightlabel,0,0);
-    QComboBox *brightness = new QComboBox();
-    brightness->addItem("Off");
-    brightness->addItem("Low");
-    brightness->addItem("Medium");
-    brightness->addItem("High");
-    brightness->setCurrentIndex(cntrl->brightness);
-    grid->addWidget(brightness,1,0);
-    connect(brightness, qOverload<int>(&QComboBox::currentIndexChanged),
+    c->grid.addWidget(&c->brightLabel,0,0);
+    c->brightness.addItem("Off");
+    c->brightness.addItem("Low");
+    c->brightness.addItem("Medium");
+    c->brightness.addItem("High");
+    c->brightness.setCurrentIndex(dev->brightness);
+    c->grid.addWidget(&c->brightness,1,0);
+    connect(&c->brightness, qOverload<int>(&QComboBox::currentIndexChanged),
         [dev,this](int index) { this->brightnessChanged(dev,index); });
 
-    QLabel* speedlabel = new QLabel("Speed");
-    grid->addWidget(speedlabel,0,1);
-    QComboBox *speed = new QComboBox();
-    speed->addItem("Fastest");
-    speed->addItem("Faster");
-    speed->addItem("Normal");
-    speed->addItem("Slower");
-    speed->addItem("Slowest");
-    speed->setCurrentIndex(cntrl->speed);
-    grid->addWidget(speed,1,1);
-    connect(speed, qOverload<int>(&QComboBox::currentIndexChanged),
+    c->grid.addWidget(&c->speedLabel,0,1);
+    c->speed.setObjectName("Speed");
+    c->speed.addItem("Fastest");
+    c->speed.addItem("Faster");
+    c->speed.addItem("Normal");
+    c->speed.addItem("Slower");
+    c->speed.addItem("Slowest");
+    c->speed.setCurrentIndex(dev->speed);
+    c->grid.addWidget(&c->speed,1,1);
+    connect(&c->speed, qOverload<int>(&QComboBox::currentIndexChanged),
         [dev,this](int index) { this->speedChanged(dev,index); });
 
-    QLabel* orientlabel = new QLabel("Orientation");
-    grid->addWidget(orientlabel,0,2);
-    QComboBox *orientation = new QComboBox();
-    orientation->addItem("Rotate 0");
-    orientation->addItem("Rotate 90");
-    orientation->addItem("Rotate 180");
-    orientation->addItem("Rotate 270");
-    orientation->setCurrentIndex(cntrl->orientation);
-    grid->addWidget(orientation,1,2);
-    connect(orientation, qOverload<int>(&QComboBox::currentIndexChanged),
+    c->grid.addWidget(&c->orientLabel,0,2);
+    c->orientation.addItem("Rotate 0");
+    c->orientation.addItem("Rotate 90");
+    c->orientation.addItem("Rotate 180");
+    c->orientation.addItem("Rotate 270");
+    c->orientation.setCurrentIndex(dev->orientation);
+    c->grid.addWidget(&c->orientation,1,2);
+    connect(&c->orientation, qOverload<int>(&QComboBox::currentIndexChanged),
         [dev,this](int index) { this->orientationChanged(dev,index); });
 
-    QLabel* colorlabel = new QLabel("Color");
-    grid->addWidget(colorlabel,0,3);
-    QPushButton* color = new QPushButton("Select");
-    grid->addWidget(color,1,3);
-    connect(color, &QPushButton::clicked,
-        [dev,this]() { this->colorPicker(dev); });
+    c->color.setText("Color");
+    c->grid.addWidget(&c->colorLabel,0,3);
+    c->color.setStyleSheet(QString("background-color: %1").arg(dev->color.name(QColor::HexArgb)));
+    c->grid.addWidget(&c->color,1,3);
+    connect(&c->color, &QPushButton::clicked,
+        [dev,c,this]() { this->colorPicker(dev,&c->color,dev->color); });
 
-    QLabel* timeoutlabel = new QLabel("Timeout");
-    grid->addWidget(timeoutlabel,0,4);
-    QSpinBox *timeout = new QSpinBox();
-    timeout->setValue(cntrl->timeout);
-    grid->addWidget(timeout,1,4);
-    connect(timeout, qOverload<int>(&QSpinBox::valueChanged),
+    c->timeoutLabel.setText("Timeout");
+    c->grid.addWidget(&c->timeoutLabel,0,4);
+    c->timeout.setValue(dev->timeout);
+    c->grid.addWidget(&c->timeout,1,4);
+    connect(&c->timeout, qOverload<int>(&QSpinBox::valueChanged),
         [dev,this](int index) { this->timeoutChanged(dev,index); });
 
-    QLabel* pageslabel = new QLabel("Pages");
-    grid->addWidget(pageslabel,0,5);
-    QSpinBox *pages = new QSpinBox();
-    pages->setValue(dev->pages);
-    pages->setMinimum(1);
-    grid->addWidget(pages,1,5);
-    connect(pages, qOverload<int>(&QSpinBox::valueChanged),
+    c->pagesLabel.setText("Pages");
+    c->grid.addWidget(&c->pagesLabel,0,5);
+    c->pages.setValue(dev->pages);
+    c->pages.setMinimum(1);
+    c->grid.addWidget(&c->pages,1,5);
+    connect(&c->pages, qOverload<int>(&QSpinBox::valueChanged),
         [dev,this](int index) { this->pagesChanged(dev,index); });
+
     for (int i=0;i<6;i++)
-        grid->setColumnStretch(i,1);
+        c->grid.setColumnStretch(i,1);
 
-    QLabel *helpText = new QLabel();
-    helpText->setText("<p><b>Button configuration:</b> Right-click on each button to configure it.</p>");
-    helpText->setAlignment(Qt::AlignCenter);
-    layout->addWidget(helpText);
+    c->helpText.setText("<p><b>Button configuration:</b> Right-click on each button to configure it.</p>");
+    c->helpText.setAlignment(Qt::AlignCenter);
+    c->layout.addWidget(&c->helpText);
 
-    onEvent->blockSignals(true);
-    offEvent->blockSignals(true);
-    knobEvent->blockSignals(true);
 
-    onEvent->clear();
-    offEvent->clear();
-    knobEvent->clear();
-
-    for (COMMAND& c : *commands) {
-        if (c.cmdType == commandButton || c.text == "None") {
-            if (c.command == cmdSeparator) {
-                onEvent->insertSeparator(onEvent->count());
-                offEvent->insertSeparator(offEvent->count());
-
-            } else {
-                onEvent->addItem(c.text, c.index);
-                offEvent->addItem(c.text, c.index);
-            }
-        }
-        else if (c.cmdType == commandKnob || c.text == "None") {
-            if (c.command == cmdSeparator) {
-                knobEvent->insertSeparator(knobEvent->count());
-            } else {
-                knobEvent->addItem(c.text, c.index);
-            }
-        }
-    }
-
-    onEvent->blockSignals(false);
-    offEvent->blockSignals(false);
-    knobEvent->blockSignals(false);
-
-    locker.unlock();
-    pageChanged(dev,1);
-    locker.relock();
-
-    view->setSceneRect(scene->itemsBoundingRect());
-
-    // Add comboboxes to scene after everything else.
+    c->view.setSceneRect(c->scene->itemsBoundingRect());
 
     // Attach pageChanged() here so we have access to all necessary vars
-    connect(page, qOverload<int>(&QSpinBox::valueChanged),
+    connect(&c->page, qOverload<int>(&QSpinBox::valueChanged),
         [dev, this](int index) { this->pageChanged(dev, index); });
 
 
     this->adjustSize();
 
     numTabs++;
+    tabs.insert(dev->path,c);
 
     dev->uiCreated = true;
 
     // Finally update the device with the default values
-    emit sendRequest(dev,usbFeatureType::featureSensitivity,cntrl->sensitivity);
-    emit sendRequest(dev,usbFeatureType::featureBrightness,cntrl->brightness);
-    emit sendRequest(dev,usbFeatureType::featureOrientation,cntrl->orientation);
-    emit sendRequest(dev,usbFeatureType::featureSpeed,cntrl->speed);
-    emit sendRequest(dev,usbFeatureType::featureTimeout,cntrl->timeout);
-    emit sendRequest(dev,usbFeatureType::featureColor,1,cntrl->color.name(QColor::HexArgb));
+    emit sendRequest(dev,usbFeatureType::featureSensitivity,dev->sensitivity);
+    emit sendRequest(dev,usbFeatureType::featureBrightness,dev->brightness);
+    emit sendRequest(dev,usbFeatureType::featureOrientation,dev->orientation);
+    emit sendRequest(dev,usbFeatureType::featureSpeed,dev->speed);
+    emit sendRequest(dev,usbFeatureType::featureTimeout,dev->timeout);
+    emit sendRequest(dev,usbFeatureType::featureColor,0,dev->color.name(QColor::HexArgb));
+
+    locker.unlock();
+
+    // pageChanged will update the buttons/knobs for the tab
+    pageChanged(dev,1);
 
 }
 
@@ -639,19 +694,18 @@ void controllerSetup::speedChanged(USBDEVICE* dev, int index)
     emit sendRequest(dev,usbFeatureType::featureSpeed,index);
 }
 
-void controllerSetup::colorPicker(USBDEVICE* dev)
+void controllerSetup::colorPicker(USBDEVICE* dev, QPushButton* btn, QColor current)
 {
     QColorDialog::ColorDialogOptions options;
     options.setFlag(QColorDialog::ShowAlphaChannel, false);
     options.setFlag(QColorDialog::DontUseNativeDialog, false);
-    QColor selColor = QColorDialog::getColor(initialColor, this, "Select Color", options);
+    QColor selColor = QColorDialog::getColor(current, this, "Select Color", options);
 
-    if(!selColor.isValid())
+    if(selColor.isValid())
     {
-        selColor = initialColor;
+        btn->setStyleSheet(QString("background-color: %1").arg(selColor.name(QColor::HexArgb)));
+        emit sendRequest(dev,usbFeatureType::featureColor,0,selColor.name(QColor::HexArgb));
     }
-    initialColor = selColor;
-    emit sendRequest(dev,usbFeatureType::featureColor,1,selColor.name(QColor::HexArgb));
 }
 
 void controllerSetup::timeoutChanged(USBDEVICE* dev, int val)
@@ -668,8 +722,14 @@ void controllerSetup::pagesChanged(USBDEVICE* dev, int val)
 
 void controllerSetup::pageChanged(USBDEVICE* dev, int val)
 {
-    if (dev->currentPage == val) // We haven't changed page!
+
+    auto tab = tabs.find(dev->path);
+    if (tab == tabs.end())
+    {
+        qWarning(logUsbControl()) << "Cannot find tabContent while changing page" << dev->path;
         return;
+    }
+
 
     if (val > dev->pages)
         val=1;
@@ -692,12 +752,12 @@ void controllerSetup::pageChanged(USBDEVICE* dev, int val)
             if (b->page == lastPage)
             {
                 if (b->onText != Q_NULLPTR) {
-                    dev->scene->removeItem(b->onText);
+                    tab.value()->scene->removeItem(b->onText);
                     delete b->onText;
                     b->onText = Q_NULLPTR;
                 }
                 if (b->offText != Q_NULLPTR) {
-                    dev->scene->removeItem(b->offText);
+                    tab.value()->scene->removeItem(b->offText);
                     delete b->offText;
                     b->offText = Q_NULLPTR;
                 }
@@ -706,14 +766,14 @@ void controllerSetup::pageChanged(USBDEVICE* dev, int val)
             {
                 b->onText = new QGraphicsTextItem(b->onCommand->text);
                 b->onText->setDefaultTextColor(b->textColour);
-                dev->scene->addItem(b->onText);
+                tab.value()->scene->addItem(b->onText);
                 b->onText->setPos(b->pos.center().x() - b->onText->boundingRect().width() / 2,
                     (b->pos.center().y() - b->onText->boundingRect().height() / 2) - 6);
                 emit sendRequest(dev,usbFeatureType::featureButton,b->num,b->onCommand->text,b->icon,&b->backgroundOn);
 
                 b->offText = new QGraphicsTextItem(b->offCommand->text);
                 b->offText->setDefaultTextColor(b->textColour);
-                dev->scene->addItem(b->offText);
+                tab.value()->scene->addItem(b->offText);
                 b->offText->setPos(b->pos.center().x() - b->offText->boundingRect().width() / 2,
                     (b->pos.center().y() - b->onText->boundingRect().height() / 2) + 6);
             }
@@ -727,7 +787,7 @@ void controllerSetup::pageChanged(USBDEVICE* dev, int val)
             if (k->page == lastPage)
             {
                 if (k->text) {
-                    dev->scene->removeItem(k->text);
+                    tab.value()->scene->removeItem(k->text);
                     delete k->text;
                     k->text = Q_NULLPTR;
                 }
@@ -736,7 +796,7 @@ void controllerSetup::pageChanged(USBDEVICE* dev, int val)
             {
                 k->text = new QGraphicsTextItem(k->command->text);
                 k->text->setDefaultTextColor(k->textColour);
-                dev->scene->addItem(k->text);
+                tab.value()->scene->addItem(k->text);
                 k->text->setPos(k->pos.center().x() - k->text->boundingRect().width() / 2,
                     (k->pos.center().y() - k->text->boundingRect().height() / 2));
             }
@@ -748,7 +808,9 @@ void controllerSetup::disableClicked(USBDEVICE* dev, bool clicked, QWidget* widg
 {
     // Disable checkbox has been clicked
     emit programDisable(dev, clicked);
+
     widget->setEnabled(!clicked);
+
 }
 
 void controllerSetup::setConnected(USBDEVICE* dev)
@@ -756,15 +818,16 @@ void controllerSetup::setConnected(USBDEVICE* dev)
     QMutexLocker locker(mutex);
 
 
-    if (dev->uiCreated)
+    auto tab = tabs.find(dev->path);
+    if (tab != tabs.end())
     {
         if (dev->connected)
         {
-           dev->message->setStyleSheet("QLabel { color : green; }");
-           dev->message->setText("Connected");
+           tab.value()->message.setStyleSheet("QLabel { color : green; }");
+           tab.value()->message.setText("Connected");
         } else {
-           dev->message->setStyleSheet("QLabel { color : red; }");
-           dev->message->setText("Not Connected");
+           tab.value()->message.setStyleSheet("QLabel { color : red; }");
+           tab.value()->message.setText("Not Connected");
         }
     }
 }
@@ -773,17 +836,60 @@ void controllerSetup::on_backupButton_clicked()
 {
     QString file = QFileDialog::getSaveFileName(this,"Select Backup Filename",".","Backup Files (*.ini)");
     if (!file.isEmpty()) {
-        QFileInfo info = QFileInfo(file);
-        emit backup(file, ui->tabWidget->currentWidget()->objectName());
+        QString path = ui->tabWidget->currentWidget()->objectName();
+        emit backup(file, path);
     }
 }
 
 void controllerSetup::on_restoreButton_clicked()
 {
+    QMutexLocker locker(mutex);
+
     QString file = QFileDialog::getOpenFileName(this,"Select Backup Filename",".","Backup Files (*.ini)");
     if (!file.isEmpty()) {
-        QFileInfo info = QFileInfo(file);
-        emit restore(file, ui->tabWidget->currentWidget()->objectName());
+        QString path = ui->tabWidget->currentWidget()->objectName();
+
+        auto devIt = devices->find(path);
+        if (devIt==devices->end())
+        {
+            qWarning(logUsbControl) << "on_restoreButton_clicked() Cannot find existing controller, aborting!";
+            return;
+        }
+        auto dev = &devIt.value();
+
+        QSettings* settings = new QSettings(file, QSettings::Format::IniFormat);
+        QString version = settings->value("Version", "").toString();
+        settings->beginGroup("Controller");
+        QString model = settings->value("Model","").toString();
+        delete settings;
+
+        if (model != dev->product) {
+            QMessageBox msgBox;
+            msgBox.setText("Stored controller does not match");
+            msgBox.setInformativeText(QString("Backup: %0 \nCurrent: %1\n\nThis will probably not work!").
+                           arg(model).arg(dev->product));
+            msgBox.setStandardButtons(QMessageBox::Ok | QMessageBox::Cancel);
+            msgBox.setDefaultButton(QMessageBox::Cancel);
+            int ret= msgBox.exec();
+            if (ret == QMessageBox::Cancel) {
+                return;
+            }
+        }
+        if (version != QString(WFVIEW_VERSION))
+        {
+            QMessageBox msgBox;
+            msgBox.setText("Version mismatch");
+            msgBox.setInformativeText(QString("Backup was from a different version of wfview\nBackup: %0 \nCurrent: %1\n\nPlease verify compatibility").
+                           arg(version).arg(QString(WFVIEW_VERSION)));
+            msgBox.setStandardButtons(QMessageBox::Ok | QMessageBox::Cancel);
+            msgBox.setDefaultButton(QMessageBox::Cancel);
+            int ret= msgBox.exec();
+            if (ret == QMessageBox::Cancel) {
+                return;
+            }
+        }
+
+        emit restore(file, path);
     }
 }
 
diff --git a/controllersetup.h b/controllersetup.h
index 2bb28bd..d1bbb4a 100644
--- a/controllersetup.h
+++ b/controllersetup.h
@@ -21,6 +21,7 @@
 #include <QCheckBox>
 #include <QFileDialog>
 #include <QMessageBox>
+#include <QLayoutItem>
 
 #include <QDebug>
 #include <QObject>
@@ -54,6 +55,40 @@ protected:
 };
 
 
+struct tabContent {
+    QWidget tab;
+    QVBoxLayout mainLayout;
+    QHBoxLayout topLayout;
+    QWidget widget;
+    QVBoxLayout layout;
+    QCheckBox disabled;
+    QLabel message;
+    QGraphicsView view;
+    QSpinBox page;
+    QHBoxLayout sensLayout;
+    QLabel sensLabel;
+    QSlider sens;
+    QImage image;
+    QGraphicsItem* bgImage = Q_NULLPTR;
+    controllerScene* scene = Q_NULLPTR;
+    QGridLayout grid;
+    QLabel brightLabel;
+    QComboBox brightness;
+    QLabel speedLabel;
+    QComboBox speed;
+    QLabel orientLabel;
+    QComboBox orientation;
+    QLabel colorLabel;
+    QPushButton color;
+    QLabel timeoutLabel;
+    QSpinBox timeout;
+    QLabel pagesLabel;
+    QSpinBox pages;
+    QLabel helpText;
+};
+
+
+
 namespace Ui {
     class controllerSetup;
 }
@@ -67,6 +102,7 @@ public:
     ~controllerSetup();
 
 signals:
+    void started();
     void sendRequest(USBDEVICE* dev, usbFeatureType request, quint8 val=0, QString text="", QImage* img=Q_NULLPTR, QColor* color=Q_NULLPTR);
     void programDisable(USBDEVICE* dev, bool disable);
     void programPages(USBDEVICE* dev, int pages);
@@ -74,8 +110,8 @@ signals:
     void restore(QString file, QString path);
 
 public slots:
-    void init();
-    void newDevice(USBDEVICE* dev, CONTROLLER* cntrl, QVector<BUTTON>* but, QVector<KNOB>* kb, QVector<COMMAND>* cmd, QMutex* mut);
+    void init(usbDevMap* dev, QVector<BUTTON>* but, QVector<KNOB>* kb, QVector<COMMAND>* cmd, QMutex* mut);
+    void newDevice(USBDEVICE* dev);
     void removeDevice(USBDEVICE* dev);
     void mousePressed(controllerScene *scene,QPoint p);
     void onEventIndexChanged(int index);
@@ -85,7 +121,7 @@ public slots:
     void brightnessChanged(USBDEVICE* dev, int index);
     void orientationChanged(USBDEVICE* dev, int index);
     void speedChanged(USBDEVICE* dev, int index);
-    void colorPicker(USBDEVICE* dev);
+    void colorPicker(USBDEVICE* dev, QPushButton* btn, QColor color);
     void buttonOnColorClicked();
     void buttonOffColorClicked();
     void buttonIconClicked();
@@ -103,6 +139,7 @@ public slots:
 
 private:
 
+    void deleteMyWidget(QWidget *);
     usbDeviceType type = usbNone;
     Ui::controllerSetup* ui;
     QGraphicsTextItem* textItem;
@@ -111,8 +148,8 @@ private:
     QVector<BUTTON>* buttons;
     QVector<KNOB>* knobs;
     QVector<COMMAND>* commands;
+    usbDevMap* devices;
 
-    usbMap* controllers;
     BUTTON* currentButton = Q_NULLPTR;
     KNOB* currentKnob = Q_NULLPTR;
 
@@ -137,6 +174,7 @@ private:
     QLabel* noControllersText;
 
     int numTabs=0;
+    QMap<QString,tabContent*> tabs;
 
     // Below are used for each tab:
     /*
diff --git a/usbcontroller.cpp b/usbcontroller.cpp
index 4ffe279..071d6fe 100644
--- a/usbcontroller.cpp
+++ b/usbcontroller.cpp
@@ -39,18 +39,20 @@ usbController::usbController()
 usbController::~usbController()
 {
     qInfo(logUsbControl) << "Ending usbController()";
-    
-    for (USBDEVICE &dev: usbDevices)
+    auto devIt = devices->begin();
+    while (devIt != devices->end())
     {
-        if (dev.handle) {
-            sendRequest(&dev,usbFeatureType::featureOverlay,60,"Goodbye from wfview");
+        auto dev = &devIt.value();
+        if (dev->handle) {
+            sendRequest(dev,usbFeatureType::featureOverlay,60,"Goodbye from wfview");
 
-            if (dev.type.model == RC28) {
+            if (dev->type.model == RC28) {
                 ledControl(false, 3);
             }
-            emit removeDevice(&dev);
-            hid_close(dev.handle);
+            emit removeDevice(dev);
+            hid_close(dev->handle);
         }
+        ++devIt;
     }
     
     hid_exit();
@@ -63,20 +65,19 @@ usbController::~usbController()
 #endif
 }
 
-void usbController::init(QMutex* mut,usbMap* prefs ,QVector<BUTTON>* buts,QVector<KNOB>* knobs)
+void usbController::init(QMutex* mut,usbDevMap* devs ,QVector<BUTTON>* buts,QVector<KNOB>* knobs)
 {
     mutex = mut;
-    this->controllers = prefs;
+    this->devices = devs;
     this->buttonList = buts;
     this->knobList = knobs;
     
-    emit initUI();
+    emit initUI(this->devices, this->buttonList, this->knobList,&this->commands,this->mutex);
     
     QMutexLocker locker(mutex);
     
     // We need to make sure that all buttons/knobs have a command assigned, this is a fairly expensive operation
     // Perform a deep copy of the command to ensure that each controller is using a unique copy of the command.
-
     
 #ifdef HID_API_VERSION_MAJOR
     if (HID_API_VERSION == HID_API_MAKE_VERSION(hid_version()->major, hid_version()->minor, hid_version()->patch)) {
@@ -152,16 +153,16 @@ void usbController::run()
             USBDEVICE newDev;
             if (gamepad->name() == "Microsoft X-Box 360 pad 0")
             {
-                newdev.type.model = xBoxGamepad;
+                newdev->type.model = xBoxGamepad;
             }
             else {
-                newdev.type.model = unknownGamepad;
+                newdev->type.model = unknownGamepad;
             }
             
-            newDev.product = gamepad->name();
-            newDev.path = gamepad->name();
+            newdev->product = gamepad->name();
+            newdev->path = gamepad->name();
             // Is this a new device? If so add it to usbDevices
-            // auto p = std::find_if(usbDevices.begin(),usbDevices.end(),[newDev](const USBDEVICE& dev) {return dev.path == newDev.path; });
+            // auto p = std::find_if(usbDevices.begin(),usbDevices.end(),[newDev](const USBDEVICE& dev) {return dev->path == newdev->path; });
             //if (p == usbDevices.end()) {
             //    usbDevices.append(newDev);
             //}
@@ -250,9 +251,17 @@ void usbController::run()
                 controllers->insert(gamepad->name(),CONTROLLER());
             }
             
-            newDev.connected=true;
-            usbDevices.insert(newDev.path,newDev);
-            emit newDevice(&newDev, &(*controllers)[gamepad->name()], buttonList, knobList, &commands, mutex); // Let the UI know we have a new controller
+            newdev->connected=true;
+            usbDevices.insert(newdev->path,newDev);
+            auto cntrlIt = controllers->find(newdev->path);
+            if (cntrlIt != controllers->end())
+            {
+                qWarning(logUsbControl()) << "Cannot find controller, something bad has happened...";
+                return;
+            }
+            CONTROLLER* cntrl = &cntrlIt.value();
+
+            emit newDevice(&newDev); // Let the UI know we have a new controller
         }
     }
     else if (!gamepad->isConnected()) {
@@ -263,23 +272,23 @@ void usbController::run()
     
     
 //#if (QT_VERSION < QT_VERSION_CHECK(6,0,0))
-    auto it = usbDevices.begin();
-    while (it != usbDevices.end())
+/*    auto it = devices->begin();
+    while (it != devices->end())
     {
         if (it.value().remove)
         {
             qInfo(logUsbControl()) << "Device has been removed, deleting from known devices" << it.value().product;
-            it = usbDevices.erase(it);
+            it = devices->erase(it);
         }
         else
         {
             ++it;
         }
-    }
+    } */
 //#else
     // Remove any devices from the list that are not connected (doesn't work on QT5!)
 //    usbDevices.erase(std::remove_if(usbDevices.begin(), usbDevices.end(), [](const USBDEVICE& dev)
-//        { if (dev.remove) qInfo(logUsbControl()) << "Removing device" << dev.product; return (dev.remove); }),usbDevices.end());
+//        { if (dev->remove) qInfo(logUsbControl()) << "Removing device" << dev->product; return (dev->remove); }),usbDevices.end());
 //#endif
     struct hid_device_info* devs;
     devs = hid_enumerate(0x0, 0x0);
@@ -288,169 +297,188 @@ void usbController::run()
         auto i = std::find_if(knownDevices.begin(), knownDevices.end(), [this,devs](const USBTYPE& d)
         { return ((devs->vendor_id == d.manufacturerId) && (devs->product_id == d.productId)
                         && (d.usage == 0x00 || devs->usage == d.usage)
-                        && (d.usagePage == 0x00 || devs->usage_page == d.usagePage)
-                        && (!this->usbDevices.contains(QString::fromLocal8Bit(devs->path))));});
+                        && (d.usagePage == 0x00 || devs->usage_page == d.usagePage));});
 
         if (i != knownDevices.end())
         {
-            USBDEVICE newDev(*i);
-            newDev.manufacturer = QString::fromWCharArray(devs->manufacturer_string);
-            newDev.product = QString::fromWCharArray(devs->product_string);
-            if (newDev.product.isEmpty())
+            auto it = devices->find(QString::fromLocal8Bit(devs->path));
+            if (it == devices->end())
             {
-                newDev.product = "<Not Detected>";
+                USBDEVICE newDev(*i);
+                newDev.manufacturer = QString::fromWCharArray(devs->manufacturer_string);
+                newDev.product = QString::fromWCharArray(devs->product_string);
+                if (newDev.product.isEmpty())
+                {
+                  newDev.product = "<Not Detected>";
+                }
+                newDev.serial = QString::fromWCharArray(devs->serial_number);
+                newDev.path = QString::fromLocal8Bit(devs->path);
+                newDev.deviceId = QString("0x%1").arg(newDev.type.productId, 4, 16, QChar('0'));
+                newDev.detected = true;
+                qDebug(logUsbControl()) << "New device detected" << newDev.product;
+                devices->insert(newDev.path,newDev);
+            } else if (!it->detected){
+                // This is a known device
+                auto dev = &it.value();
+                dev->type = *i;
+                dev->manufacturer = QString::fromWCharArray(devs->manufacturer_string);
+                dev->product = QString::fromWCharArray(devs->product_string);
+                if (dev->product.isEmpty())
+                {
+                  dev->product = "<Not Detected>";
+                }
+                dev->serial = QString::fromWCharArray(devs->serial_number);
+                dev->deviceId = QString("0x%1").arg(dev->type.productId, 4, 16, QChar('0'));
+                dev->detected = true;
+                qDebug(logUsbControl()) << "Known device detected" << dev->product;
             }
-            newDev.serial = QString::fromWCharArray(devs->serial_number);
-            newDev.path = QString::fromLocal8Bit(devs->path);
-            newDev.deviceId = QString("0x%1").arg(newDev.type.productId, 4, 16, QChar('0'));
-            qDebug(logUsbControl()) << "New device detected" << newDev.product;
-            usbDevices.insert(newDev.path,newDev);
         }
         devs = devs->next;
     }
     
     hid_free_enumeration(devs);
     
-    for (USBDEVICE &dev: usbDevices) {
-        
-        dev.disabled = (*controllers)[dev.path].disabled;
-        dev.pages = (*controllers)[dev.path].pages;
-        if (!dev.disabled && !dev.connected && !dev.path.isEmpty()) {
+    for (auto devIt = devices->begin(); devIt != devices->end(); devIt++)
+    {
+        auto dev = &devIt.value();
+
+        if (dev->detected && !dev->disabled && !dev->connected && !dev->path.isEmpty()) {
+                        
+            qInfo(logUsbControl()) << QString("Attempting to connect to %0").arg(dev->product);
+            dev->handle = hid_open_path(dev->path.toLocal8Bit());
             
-            if (!controllers->contains(dev.path)) {
-                controllers->insert(dev.path,CONTROLLER(&dev));
-            } else {
-                (*controllers)[dev.path].dev = &dev;
-            }
-            
-            qInfo(logUsbControl()) << QString("Attempting to connect to %0").arg(dev.product);
-            dev.handle = hid_open_path(dev.path.toLocal8Bit());
-            
-            if (dev.handle)
+            if (dev->handle)
             {
-                qInfo(logUsbControl()) << QString("Connected to device: %0 from %1 S/N %2").arg(dev.product).arg(dev.manufacturer).arg(dev.serial);
-                hid_set_nonblocking(dev.handle, 1);
+                qInfo(logUsbControl()) << QString("Connected to device: %0 from %1 S/N %2").arg(dev->product).arg(dev->manufacturer).arg(dev->serial);
+                hid_set_nonblocking(dev->handle, 1);
                 devicesConnected++;
-                dev.connected=true;
+                dev->connected=true;
 
                 locker.unlock(); // Unlock the mutex so other devices can use it
 
-                if (dev.type.model == RC28)
+                if (dev->type.model == RC28)
                 {
                     ledControl(false, 0);
                     ledControl(false, 1);
                     ledControl(false, 2);
                     ledControl(true, 3);
                 }
-                else if (dev.type.model == QuickKeys)
+                else if (dev->type.model == QuickKeys)
                 {
-                    sendRequest(&dev,usbFeatureType::featureEventsA);
-                    sendRequest(&dev,usbFeatureType::featureEventsB);
+                    sendRequest(dev,usbFeatureType::featureEventsA);
+                    sendRequest(dev,usbFeatureType::featureEventsB);
                 }
 
-                sendRequest(&dev,usbFeatureType::featureSerial);
-                sendRequest(&dev,usbFeatureType::featureFirmware);
-                sendRequest(&dev,usbFeatureType::featureResetKeys);
-                //sendRequest(&dev,usbFeatureType::featureReset);
-                sendRequest(&dev,usbFeatureType::featureOverlay,5,"Hello from wfview");
+                sendRequest(dev,usbFeatureType::featureSerial);
+                sendRequest(dev,usbFeatureType::featureFirmware);
+                sendRequest(dev,usbFeatureType::featureResetKeys);
+                sendRequest(dev,usbFeatureType::featureOverlay,5,"Hello from wfview");
                 locker.relock(); // Take the mutex back.
             }
-            else if (!dev.uiCreated)
+            else if (!dev->uiCreated)
             {
                 // This should only get displayed once if we fail to connect to a device
                 qInfo(logUsbControl()) << QString("Error connecting to  %0: %1")
-                                          .arg(dev.product)
-                                          .arg(QString::fromWCharArray(hid_error(dev.handle)));
+                                          .arg(dev->product)
+                                          .arg(QString::fromWCharArray(hid_error(dev->handle)));
             }
             
-            if (!dev.uiCreated)
+            if (!dev->uiCreated)
             {
-                for (int i=0;i<dev.type.knobs;i++)
+                for (int i=0;i<dev->type.knobs;i++)
                 {
-                    dev.knobValues.append(KNOBVALUE());
+                    dev->knobValues.append(KNOBVALUE());
                 }
 
                 // Find our defaults/knobs/buttons for this controller:
                 // First see if we have any stored and add them to the list if not.
                 
-                auto bti = std::find_if(buttonList->begin(), buttonList->end(), [dev](const BUTTON& b)
-                { return (b.path == dev.path); });
-                if (bti == buttonList->end())
+                if (dev->type.buttons > 0)
                 {
-                    // List doesn't contain any buttons for this device so add all existing buttons to the end of buttonList
-                    qInfo(logUsbControl()) << "No stored buttons found, loading defaults";
-                    for (auto but=defaultButtons.begin();but!=defaultButtons.end();but++)
+                    auto bti = std::find_if(buttonList->begin(), buttonList->end(), [dev](const BUTTON& b)
+                    { return (b.path == dev->path); });
+                    if (bti == buttonList->end())
                     {
-                        if (but->dev == dev.type.model)
+                        // List doesn't contain any buttons for this device so add all existing buttons to the end of buttonList
+                        qInfo(logUsbControl()) << "No stored buttons found, loading defaults";
+                        for (auto but=defaultButtons.begin();but!=defaultButtons.end();but++)
                         {
-                            but->path = dev.path;
-                            buttonList->append(BUTTON(*but));
+                            if (but->dev == dev->type.model)
+                            {
+                                but->path = dev->path;
+                                buttonList->append(BUTTON(*but));
+                            }
                         }
+                    } else {
+                        qInfo(logUsbControl()) << "Found stored buttons for this device, loading.";
                     }
-                } else {
-                    qInfo(logUsbControl()) << "Found buttons for this device, loading.";
-                }
 
-                // We need to set the parent device for all buttons belonging to this device!
-                for (auto but = buttonList->begin(); but != buttonList->end(); but++)
-                {
-                    if (but->path == dev.path)
+                    // We need to set the parent device for all buttons belonging to this device!
+                    for (auto but = buttonList->begin(); but != buttonList->end(); but++)
                     {
-                        auto bon = std::find_if(commands.begin(), commands.end(), [but](const COMMAND& c) { return (c.text == but->on); });
-                        if (bon != commands.end())
-                            but->onCommand = new COMMAND(*bon);
-                        else
-                            qWarning(logUsbControl()) << "On Command" << but->on << "not found";
+                        if (but->path == dev->path)
+                        {
+                            auto bon = std::find_if(commands.begin(), commands.end(), [but](const COMMAND& c) { return (c.text == but->on); });
+                            if (bon != commands.end())
+                                but->onCommand = bon;
+                            else
+                                qWarning(logUsbControl()) << "On Command" << but->on << "not found";
 
-                        auto boff = std::find_if(commands.begin(), commands.end(), [but](const COMMAND& c) { return (c.text == but->off); });
-                        if (boff != commands.end())
-                            but->offCommand = new COMMAND(*boff);
-                        else
-                            qWarning(logUsbControl()) << "Off Command" << but->off << "not found";
+                            auto boff = std::find_if(commands.begin(), commands.end(), [but](const COMMAND& c) { return (c.text == but->off); });
+                            if (boff != commands.end())
+                                but->offCommand = boff;
+                            else
+                                qWarning(logUsbControl()) << "Off Command" << but->off << "not found";
 
-                        but->parent = &dev;
-                    }
-                }
-
-                
-                auto kbi = std::find_if(knobList->begin(), knobList->end(), [dev](const KNOB& k)
-                { return (k.path == dev.path); });
-                if (kbi == knobList->end())
-                {
-                    qInfo(logUsbControl()) << "No stored knobs found, loading defaults";
-                    for (auto kb = defaultKnobs.begin();kb != defaultKnobs.end(); kb++)
-                    {
-                        if (kb->dev == dev.type.model) {
-                            kb->path = dev.path;
-                            knobList->append(KNOB(*kb));
+                            but->parent = dev;
                         }
                     }
                 }
 
-                for (auto kb = knobList->begin(); kb != knobList->end(); kb++)
+                if (dev->type.knobs > 0)
                 {
-                    if (kb->path == dev.path)
+                    auto kbi = std::find_if(knobList->begin(), knobList->end(), [dev](const KNOB& k)
+                    { return (k.path == dev->path); });
+                    if (kbi == knobList->end())
                     {
-                        auto k = std::find_if(commands.begin(), commands.end(), [kb](const COMMAND& c) { return (c.text == kb->cmd); });
-                        if (k != commands.end())
-                            kb->command = new COMMAND(*k);
-                        else
-                            qWarning(logUsbControl()) << "Knob Command" << kb->cmd << "not found";
+                        qInfo(logUsbControl()) << "No stored knobs found, loading defaults";
+                        for (auto kb = defaultKnobs.begin();kb != defaultKnobs.end(); kb++)
+                        {
+                            if (kb->dev == dev->type.model) {
+                                kb->path = dev->path;
+                                knobList->append(KNOB(*kb));
+                            }
+                        }
+                    } else {
+                        qInfo(logUsbControl()) << "Found stored knobs for this device, loading.";
+                    }
 
-                        kb->parent = &dev;
-                        if (kb->page == 1)
-                            dev.knobValues[kb->num].name = kb->cmd;
+                    for (auto kb = knobList->begin(); kb != knobList->end(); kb++)
+                    {
+                        if (kb->path == dev->path)
+                        {
+                            auto k = std::find_if(commands.begin(), commands.end(), [kb](const COMMAND& c) { return (c.text == kb->cmd); });
+                            if (k != commands.end())
+                                kb->command = k;
+                            else
+                                qWarning(logUsbControl()) << "Knob Command" << kb->cmd << "not found";
+
+                            kb->parent = dev;
+                            if (kb->page == 1)
+                                dev->knobValues[kb->num].name = kb->cmd;
+                        }
                     }
                 }
-
                 // Let the UI know we have a new controller
-                emit newDevice(&dev, &(*controllers)[dev.path],buttonList, knobList, &commands, mutex);
+                emit newDevice(dev);
 
+            } else {
+                emit setConnected(dev);
             }
         }
-        else if (dev.uiCreated)
+        else if (dev->uiCreated)
         {
-            emit setConnected(&dev);
+            emit setConnected(dev);
         }
     }
     
@@ -474,33 +502,39 @@ void usbController::run()
 void usbController::runTimer()
 {
     QMutexLocker locker(mutex);
-    
-    for (USBDEVICE &dev: usbDevices)
+
+    for (auto devIt = devices->begin(); devIt != devices->end(); devIt++)
     {
-        if (dev.disabled || !dev.connected || !dev.handle) {
+        auto dev = &devIt.value();
+
+        if (dev->disabled || !dev->detected || !dev->connected || !dev->handle) {
+            // This device isn't currently connected.
             continue;
         }
-        
+
         int res=1;
         
         while (res > 0) {
             quint32 tempButtons = 0;
             QByteArray data(HIDDATALENGTH, 0x0);
-            res = hid_read(dev.handle, (unsigned char*)data.data(), HIDDATALENGTH);
+            res = hid_read(dev->handle, (unsigned char*)data.data(), HIDDATALENGTH);
             if (res < 0)
             {
-                qInfo(logUsbControl()) << "USB Device disconnected" << dev.product;
-                emit removeDevice(&dev);
-                hid_close(dev.handle);
-                dev.handle = NULL;
-                dev.connected = false;
-                dev.remove = true;
+                qInfo(logUsbControl()) << "USB Device disconnected" << dev->product;
+                hid_close(dev->handle);
+                dev->handle = NULL;
+                dev->detected = false;
+                dev->connected = false;
+                dev->detected = false;
+                dev->remove = true;
+                dev->uiCreated = false;
                 devicesConnected--;
+                emit removeDevice(dev);
                 QTimer::singleShot(250, this, SLOT(run())); // Cleanup
                 break;
             }
 
-            if (res == 5 && (dev.type.model == shuttleXpress || dev.type.model == shuttlePro2))
+            if (res == 5 && (dev->type.model == shuttleXpress || dev->type.model == shuttlePro2))
             {
                 tempButtons = ((quint8)data[4] << 8) | ((quint8)data[3] & 0xff);
                 unsigned char tempJogpos = (unsigned char)data[1];
@@ -525,18 +559,18 @@ void usbController::runTimer()
                     0000000000000001 = button0
                 */
 
-                if (tempJogpos == dev.jogpos + 1 || (tempJogpos == 0 && dev.jogpos == 0xff))
+                if (tempJogpos == dev->jogpos + 1 || (tempJogpos == 0 && dev->jogpos == 0xff))
                 {
-                    dev.knobValues[0].value++;
+                    dev->knobValues[0].value++;
                 }
-                else if (tempJogpos != dev.jogpos) {
-                    dev.knobValues[0].value--;
+                else if (tempJogpos != dev->jogpos) {
+                    dev->knobValues[0].value--;
                 }
 
-                dev.jogpos = tempJogpos;
-                dev.shutpos = tempShutpos;
+                dev->jogpos = tempJogpos;
+                dev->shutpos = tempShutpos;
             }
-            else if ((res > 31) && dev.type.model == RC28)
+            else if ((res > 31) && dev->type.model == RC28)
             {
                 // This is a response from the Icom RC28
                 if ((unsigned char)data[0] == 0x02) {
@@ -551,33 +585,33 @@ void usbController::runTimer()
                     {
                         if ((unsigned char)data[3] == 0x01)
                         {
-                            dev.knobValues[0].value = dev.knobValues[0].value + data[1];
+                            dev->knobValues[0].value = dev->knobValues[0].value + data[1];
                         }
                         else if ((unsigned char)data[3] == 0x02)
                         {
-                            dev.knobValues[0].value = dev.knobValues[0].value - data[1];
+                            dev->knobValues[0].value = dev->knobValues[0].value - data[1];
                         }
                     }
                 }
             }
-            else if (res > 15 && dev.type.model == eCoderPlus && (quint8)data[0] == 0xff) {
+            else if (res > 15 && dev->type.model == eCoderPlus && (quint8)data[0] == 0xff) {
                 tempButtons = ((quint8)data[3] << 16) | ((quint8)data[2] << 8) | ((quint8)data[1] & 0xff);
                 quint32 tempKnobs = ((quint8)data[16] << 24) | ((quint8)data[15] << 16) | ((quint8)data[14] << 8) | ((quint8)data[13]  & 0xff);
                 
-                for (unsigned char i = 0; i < dev.knobValues.size(); i++)
+                for (unsigned char i = 0; i < dev->knobValues.size(); i++)
                 {
-                    if (dev.knobs != tempKnobs) {
+                    if (dev->knobs != tempKnobs) {
                         // One of the knobs has moved
                         for (unsigned char i = 0; i < 4; i++) {
-                            if ((tempKnobs >> (i * 8) & 0xff) != (dev.knobs >> (i * 8) & 0xff)) {
-                                dev.knobValues[i].value = dev.knobValues[i].value + (qint8)((dev.knobs >> (i * 8)) & 0xff);
+                            if ((tempKnobs >> (i * 8) & 0xff) != (dev->knobs >> (i * 8) & 0xff)) {
+                                dev->knobValues[i].value = dev->knobValues[i].value + (qint8)((dev->knobs >> (i * 8)) & 0xff);
                             }
                         }
-                        dev.knobs = tempKnobs;
+                        dev->knobs = tempKnobs;
                     }
                 }
             }
-            else if (res > 5 && dev.type.model == QuickKeys && (quint8)data[0] == 0x02) {
+            else if (res > 5 && dev->type.model == QuickKeys && (quint8)data[0] == 0x02) {
 
                 if ((quint8)data[1] == 0xf0) {
                     
@@ -585,10 +619,10 @@ void usbController::runTimer()
                     tempButtons = (data[3] << 8) | (data[2] & 0xff);
 
                     if (data[7] & 0x01) {
-                        dev.knobValues[0].value++;
+                        dev->knobValues[0].value++;
                     }
                     else if (data[7] & 0x02) {
-                        dev.knobValues[0].value--;
+                        dev->knobValues[0].value--;
                     }
                     
                 }
@@ -600,18 +634,18 @@ void usbController::runTimer()
                 }
             }
             // Is it any model of StreamDeck?
-            else if (res>=dev.type.buttons && dev.type.model != usbNone)
+            else if (res>=dev->type.buttons && dev->type.model != usbNone)
             {
                 // Main buttons
                 if ((quint8)data[1] == 0x00)
                 {
-                    for (int i=dev.type.buttons-dev.type.knobs;i>0;i--) {
+                    for (int i=dev->type.buttons-dev->type.knobs;i>0;i--) {
                         tempButtons |= ((quint8)data[i+3] & 0x01) << (i-1);
                     }
                 }
 
                 // Knobs and secondary buttons
-                if (dev.type.model == StreamDeckPlus) {
+                if (dev->type.model == StreamDeckPlus) {
                     if ((quint8)data[1] == 0x03 && (quint8)data[2] == 0x05)
                     {
                         // Knob action!
@@ -619,16 +653,16 @@ void usbController::runTimer()
                         {
                         case 0x00:
                             // Knob button
-                            for (int i=dev.type.buttons;i>7;i--)
+                            for (int i=dev->type.buttons;i>7;i--)
                             {
                                 tempButtons |= ((quint8)data[i-4] & 0x01) << (i-1);
                             }
                             break;
                         case 0x01:
                             // Knob moved
-                            for (int i=0;i<dev.type.knobs;i++)
+                            for (int i=0;i<dev->type.knobs;i++)
                             {
-                                dev.knobValues[i].value += (qint8)data[i+5];
+                                dev->knobValues[i].value += (qint8)data[i+5];
                             }
                             break;
                         }
@@ -663,62 +697,62 @@ void usbController::runTimer()
 
             // Step through all buttons and emit ones that have been pressed.
             // Only do it if actual data has been received.
-            if (res > 0 && dev.buttons != tempButtons)
+            if (res > 0 && dev->buttons != tempButtons)
             {
                 qDebug(logUsbControl()) << "Got Buttons:" << QString::number(tempButtons,2);
                 // Step through all buttons and emit ones that have been pressed.
-                for (unsigned char i = 0; i <dev.type.buttons; i++)
+                for (unsigned char i = 0; i <dev->type.buttons; i++)
                 {
                     auto but = std::find_if(buttonList->begin(), buttonList->end(), [dev, i](const BUTTON& b)
-                    { return (b.path == dev.path && b.page == dev.currentPage && b.num == i); });
+                    { return (b.path == dev->path && b.page == dev->currentPage && b.num == i); });
                     if (but != buttonList->end()) {
-                        if ((!but->isOn) && ((tempButtons >> i & 1) && !(dev.buttons >> i & 1)))
+                        if ((!but->isOn) && ((tempButtons >> i & 1) && !(dev->buttons >> i & 1)))
                         {
                             qDebug(logUsbControl()) << QString("On Button event for button %0: %1").arg(but->num).arg(but->onCommand->text);
                             if (but->onCommand->command == cmdPageUp)
-                                emit changePage(&dev, dev.currentPage+1);
+                                emit changePage(dev, dev->currentPage+1);
                             else if (but->onCommand->command == cmdPageDown)
-                                emit changePage(&dev, dev.currentPage-1);
+                                emit changePage(dev, dev->currentPage-1);
                             else if (but->onCommand->command == cmdLCDSpectrum)
-                                (*controllers)[dev.path].lcd = cmdLCDSpectrum;
+                                dev->lcd = cmdLCDSpectrum;
                             else if (but->onCommand->command == cmdLCDWaterfall)
-                                (*controllers)[dev.path].lcd = cmdLCDWaterfall;
+                                dev->lcd = cmdLCDWaterfall;
                             else {
                                 emit button(but->onCommand);
                             }
                             // Change the button text to reflect the off Button
                             if (but->offCommand->index != 0) {
                                 locker.unlock();
-                                sendRequest(&dev,usbFeatureType::featureButton,i,but->offCommand->text,but->icon,&but->backgroundOff);
+                                sendRequest(dev,usbFeatureType::featureButton,i,but->offCommand->text,but->icon,&but->backgroundOff);
                                 locker.relock();
                             }
                             but->isOn=true;
                         }
-                        else if ((but->toggle && but->isOn) && ((tempButtons >> i & 1) && !(dev.buttons >> i & 1)))
+                        else if ((but->toggle && but->isOn) && ((tempButtons >> i & 1) && !(dev->buttons >> i & 1)))
                         {
                             qDebug(logUsbControl()) << QString("Off Button (toggle) event for button %0: %1").arg(but->num).arg(but->onCommand->text);
                             if (but->offCommand->command == cmdPageUp)
-                                emit changePage(&dev, dev.currentPage+1);
+                                emit changePage(dev, dev->currentPage+1);
                             else if (but->offCommand->command == cmdPageDown)
-                                emit changePage(&dev, dev.currentPage-1);
+                                emit changePage(dev, dev->currentPage-1);
                             else if (but->offCommand->command == cmdLCDSpectrum)
-                                (*controllers)[dev.path].lcd = cmdLCDSpectrum;
+                                dev->lcd = cmdLCDSpectrum;
                             else if (but->offCommand->command == cmdLCDWaterfall)
-                                (*controllers)[dev.path].lcd = cmdLCDWaterfall;
+                                dev->lcd = cmdLCDWaterfall;
                             else {
                                 emit button(but->offCommand);
                             }
                             locker.unlock();
-                            sendRequest(&dev,usbFeatureType::featureButton,i,but->onCommand->text,but->icon,&but->backgroundOn);
+                            sendRequest(dev,usbFeatureType::featureButton,i,but->onCommand->text,but->icon,&but->backgroundOn);
                             locker.relock();
                             but->isOn=false;
                         }
-                        else if ((!but->toggle && but->isOn) && ((dev.buttons >> i & 1) && !(tempButtons >> i & 1)))
+                        else if ((!but->toggle && but->isOn) && ((dev->buttons >> i & 1) && !(tempButtons >> i & 1)))
                         {
                             if (but->offCommand->command == cmdLCDSpectrum)
-                                (*controllers)[dev.path].lcd = cmdLCDSpectrum;
+                                dev->lcd = cmdLCDSpectrum;
                             else if (but->offCommand->command == cmdLCDWaterfall)
-                                (*controllers)[dev.path].lcd = cmdLCDWaterfall;
+                                dev->lcd = cmdLCDWaterfall;
                             else
                             {
                                 qDebug(logUsbControl()) << QString("Off Button event for button %0: %1").arg(but->num).arg(but->offCommand->text);
@@ -726,69 +760,69 @@ void usbController::runTimer()
                             }
                             // Change the button text to reflect the on Button
                             locker.unlock();
-                            sendRequest(&dev,usbFeatureType::featureButton,i,but->onCommand->text,but->icon,&but->backgroundOn);
+                            sendRequest(dev,usbFeatureType::featureButton,i,but->onCommand->text,but->icon,&but->backgroundOn);
                             locker.relock();
                             but->isOn=false;
                         }
                     }
                 }
-                dev.buttons = tempButtons;
+                dev->buttons = tempButtons;
             }
 
             // As the knobs can move very fast, only send every 100ms so the rig isn't overwhelmed
-            if (dev.lastusbController.msecsTo(QTime::currentTime()) >= 100 || dev.lastusbController > QTime::currentTime())
+            if (dev->lastusbController.msecsTo(QTime::currentTime()) >= 100 || dev->lastusbController > QTime::currentTime())
             {
-                if (dev.type.model == shuttleXpress || dev.type.model == shuttlePro2)
+                if (dev->type.model == shuttleXpress || dev->type.model == shuttlePro2)
                 {
-                    if (dev.shutpos > 0  && dev.shutpos < 0x08)
+                    if (dev->shutpos > 0  && dev->shutpos < 0x08)
                     {
-                        dev.shutMult = dev.shutpos;
-                        emit doShuttle(true, dev.shutMult);
-                        qDebug(logUsbControl()) << "Shuttle PLUS" << dev.shutMult;
+                        dev->shutMult = dev->shutpos;
+                        emit doShuttle(true, dev->shutMult);
+                        qDebug(logUsbControl()) << "Shuttle PLUS" << dev->shutMult;
                         
                     }
-                    else if (dev.shutpos > 0xEF) {
-                        dev.shutMult = abs(dev.shutpos - 0xff) + 1;
-                        emit doShuttle(false, dev.shutMult);
-                        qDebug(logUsbControl()) << "Shuttle MINUS" << dev.shutMult;
+                    else if (dev->shutpos > 0xEF) {
+                        dev->shutMult = abs(dev->shutpos - 0xff) + 1;
+                        emit doShuttle(false, dev->shutMult);
+                        qDebug(logUsbControl()) << "Shuttle MINUS" << dev->shutMult;
                     }
                 }
                 
-                for (unsigned char i = 0; i < dev.knobValues.size(); i++)
+                for (unsigned char i = 0; i < dev->knobValues.size(); i++)
                 {
                     auto kb = std::find_if(knobList->begin(), knobList->end(), [dev, i](const KNOB& k)
-                    { return (k.command && k.path == dev.path && k.page == dev.currentPage && k.num == i && dev.knobValues[i].value != dev.knobValues[i].previous); });
+                    { return (k.command && k.path == dev->path && k.page == dev->currentPage && k.num == i && dev->knobValues[i].value != dev->knobValues[i].previous); });
 
                     if (kb != knobList->end()) {
                         // sendCommand mustn't be deleted so we ensure it stays in-scope by declaring it private (we will only ever send one command).
                         sendCommand = *kb->command;
                         if (sendCommand.command != cmdSetFreq) {
-                            int tempVal = dev.knobValues[i].value * dev.sensitivity;
+                            int tempVal = dev->knobValues[i].value * dev->sensitivity;
                             tempVal = qMin(qMax(tempVal,0),255);
                             sendCommand.suffix = quint8(tempVal);
-                            dev.knobValues[i].value=tempVal/dev.sensitivity; // This ensures that dial can't go outside 0-255
+                            dev->knobValues[i].value=tempVal/dev->sensitivity; // This ensures that dial can't go outside 0-255
                             locker.unlock();
-                            dev.knobValues[i].name = kb->command->text;
-                            sendRequest(&dev,usbFeatureType::featureGraph,i,"");
+                            dev->knobValues[i].name = kb->command->text;
+                            sendRequest(dev,usbFeatureType::featureGraph,i,"");
                             locker.relock();
                         }
                         else
                         {
-                            sendCommand.value = dev.knobValues[i].value/dev.sensitivity;
+                            sendCommand.value = dev->knobValues[i].value/dev->sensitivity;
                         }
                         
                         emit button(&sendCommand);
 
                         if (sendCommand.command == cmdSetFreq) {
-                            dev.knobValues[i].value = 0;
+                            dev->knobValues[i].value = 0;
                         }
-                        dev.knobValues[i].previous=dev.knobValues[i].value;
+                        dev->knobValues[i].previous=dev->knobValues[i].value;
                     }
                 }
                 
-                dev.lastusbController = QTime::currentTime();
+                dev->lastusbController = QTime::currentTime();
             }
-            
+
         }
     }
     
@@ -801,18 +835,17 @@ void usbController::runTimer()
 void usbController::receivePTTStatus(bool on) {
     static QColor lastColour = currentColour;
     static bool ptt;
-    QMutexLocker locker(mutex);
 
-    for (USBDEVICE &dev: usbDevices) {
-        locker.unlock();
+    for (auto devIt = devices->begin(); devIt != devices->end(); devIt++)
+    {
+        auto dev = &devIt.value();
         if (on && !ptt) {
             lastColour = currentColour;
-            sendRequest(&dev,usbFeatureType::featureColor,0,QColor(255,0,0).name(QColor::HexArgb));
+            sendRequest(dev,usbFeatureType::featureColor,0,QColor(255,0,0).name(QColor::HexArgb));
         }
         else {
-            sendRequest(&dev,usbFeatureType::featureColor,0,lastColour.name(QColor::HexArgb));
+            sendRequest(dev,usbFeatureType::featureColor,0,lastColour.name(QColor::HexArgb));
         }
-        locker.relock();
     }
 
     ptt = on;
@@ -821,9 +854,10 @@ void usbController::receivePTTStatus(bool on) {
 void usbController::sendToLCD(QImage* img)
 {
 
-    for (USBDEVICE &dev: usbDevices)
+    for (auto devIt = devices->begin(); devIt != devices->end(); devIt++)
     {
-        sendRequest(&dev,usbFeatureType::featureLCD,0,"",img);
+        auto dev = &devIt.value();
+        sendRequest(dev,usbFeatureType::featureLCD,0,"",img);
     }
 }
 
@@ -838,8 +872,10 @@ void usbController::ledControl(bool on, unsigned char num)
     
     QMutexLocker locker(mutex);
 
-    for (USBDEVICE &dev: usbDevices) {
-        if (dev.connected && dev.type.model == RC28) {
+    for (auto devIt = devices->begin(); devIt != devices->end(); devIt++)
+    {
+        auto dev = &devIt.value();
+        if (dev->connected && dev->type.model == RC28) {
             QByteArray data(3, 0x0);
             data[1] = 0x01;
             static unsigned char ledNum = 0x07;
@@ -850,10 +886,10 @@ void usbController::ledControl(bool on, unsigned char num)
             
             data[2] = ledNum;
             
-            int res = hid_write(dev.handle, (const unsigned char*)data.constData(), data.size());
+            int res = hid_write(dev->handle, (const unsigned char*)data.constData(), data.size());
             
             if (res < 0) {
-                qDebug(logUsbControl()) << "Unable to write(), Error:" << hid_error(dev.handle);
+                qDebug(logUsbControl()) << "Unable to write(), Error:" << hid_error(dev->handle);
                 return;
             }            
         }
@@ -883,7 +919,6 @@ void usbController::sendRequest(USBDEVICE *dev, usbFeatureType feature, quint8 v
     if (feature == usbFeatureType::featureSensitivity)
     {
         dev->sensitivity=val;
-        (*controllers)[dev->path].sensitivity = val;
         return;
     }
 
@@ -920,12 +955,12 @@ void usbController::sendRequest(USBDEVICE *dev, usbFeatureType feature, quint8 v
             data[2] = (qint8)0x0a;
             data[3] = (qint8)0x01;
             data[4] = val;
-            (*controllers)[dev->path].brightness = val;
+            dev->brightness = val;
             break;
         case usbFeatureType::featureOrientation:
             data[1] = (qint8)0xb1;
             data[2] = (qint8)val+1;
-            (*controllers)[dev->path].orientation = val;
+            dev->orientation = val;
             break;
         case usbFeatureType::featureSpeed:
             data[1] = (qint8)0xb4;
@@ -933,7 +968,7 @@ void usbController::sendRequest(USBDEVICE *dev, usbFeatureType feature, quint8 v
             data[3] = (qint8)0x01;
             data[4] = (qint8)0x01;
             data[5] = val+1;
-            (*controllers)[dev->path].speed = val;
+            dev->speed = val;
             break;
         case usbFeatureType::featureColor: {
             QColor col;
@@ -946,7 +981,7 @@ void usbController::sendRequest(USBDEVICE *dev, usbFeatureType feature, quint8 v
             data[8] = (qint8)col.blue();
             if (val) {
                currentColour = col;
-               (*controllers)[dev->path].color=currentColour;
+               dev->color=currentColour;
             }
             break;
         }
@@ -968,7 +1003,7 @@ void usbController::sendRequest(USBDEVICE *dev, usbFeatureType feature, quint8 v
             data[2] = (qint8)0x08;
             data[3] = (qint8)0x01;
             data[4] = val;
-            (*controllers)[dev->path].timeout = val;
+            dev->timeout = val;
             break;
         default:
             // Command not supported by this device so return.
@@ -1044,17 +1079,10 @@ void usbController::sendRequest(USBDEVICE *dev, usbFeatureType feature, quint8 v
                 data[2] = val*33; // Stream Deck brightness is in %
             }
             res = hid_send_feature_report(dev->handle, (const unsigned char*)data.constData(), data.size());
-            (*controllers)[dev->path].brightness = val;
+            dev->brightness = val;
             break;
         case usbFeatureType::featureSensitivity:
             dev->sensitivity=val;
-            (*controllers)[dev->path].sensitivity = val;
-            break;
-        case usbFeatureType::featureColor:
-            if (val) {
-                currentColour.setNamedColor(text);
-                (*controllers)[dev->path].color=currentColour;
-            }
             break;
         case usbFeatureType::featureGraph:
         {
@@ -1064,11 +1092,11 @@ void usbController::sendRequest(USBDEVICE *dev, usbFeatureType feature, quint8 v
                 image.fill(Qt::black);
                 QPainter paint(&image);
                 int x=qMin(190,(dev->knobValues[val].value * dev->sensitivity) * 190 / 255);
-                int perc=qMin(100,(dev->knobValues[val].value * dev->sensitivity) * 100 / 255);
-                paint.fillRect((200*val)+5,80,x,20, Qt::darkGreen);
+                paint.fillRect(5,5,x,20, Qt::darkGreen);
                 paint.setFont(QFont("times",10));
                 paint.setPen(Qt::white);
-                paint.drawText((200*val)+5,80,190,20, Qt::AlignCenter | Qt::AlignVCenter, QString("%0 %1%").arg(dev->knobValues[val].name).arg(perc));
+                int perc=qMin(100,(dev->knobValues[val].value * dev->sensitivity) * 100 / 255);
+                paint.drawText(5,5,190,20, Qt::AlignCenter | Qt::AlignVCenter, QString("%0 %1%").arg(dev->knobValues[val].name).arg(perc));
 
                 data2.clear();
                 QBuffer buffer(&data2);
@@ -1108,6 +1136,9 @@ void usbController::sendRequest(USBDEVICE *dev, usbFeatureType feature, quint8 v
             break;
 
         }
+        case usbFeatureType::featureColor:
+            dev->color.setNamedColor(text);
+            // Fall through
         case usbFeatureType::featureOverlay:
         {
             if (dev->type.model == usbDeviceType::StreamDeckPlus)
@@ -1116,11 +1147,11 @@ void usbController::sendRequest(USBDEVICE *dev, usbFeatureType feature, quint8 v
                 QPainter paint(&image);
                 if (val) {
                     paint.setFont(QFont("times",16));
-                    paint.fillRect(image.rect(), (*controllers)[dev->path].color);
+                    paint.fillRect(image.rect(), dev->color);
                     paint.drawText(image.rect(),Qt::AlignCenter | Qt::AlignVCenter, text);
                     QTimer::singleShot(val*1000, this, [=]() { sendRequest(dev,usbFeatureType::featureOverlay); });
                 } else {
-                    paint.fillRect(image.rect(), (*controllers)[dev->path].color);
+                    paint.fillRect(image.rect(), dev->color);
                 }
                 QBuffer buffer(&data2);
                 image.save(&buffer, "JPG");
@@ -1196,7 +1227,7 @@ void usbController::sendRequest(USBDEVICE *dev, usbFeatureType feature, quint8 v
                     if (color != Q_NULLPTR)
                         butImage.fill(*color);
                     else
-                        butImage.fill((*controllers)[dev->path].color);
+                        butImage.fill(dev->color);
 
                     QPainter butPaint(&butImage);
 
@@ -1294,8 +1325,7 @@ void usbController::sendRequest(USBDEVICE *dev, usbFeatureType feature, quint8 v
 void usbController::programDisable(USBDEVICE* dev, bool disabled)
 {
     dev->disabled = disabled;
-    (*controllers)[dev->path].disabled = disabled;
-    
+
     if (disabled)
     {
         // Disconnect the device:
@@ -1303,16 +1333,20 @@ void usbController::programDisable(USBDEVICE* dev, bool disabled)
             qInfo(logUsbControl()) << "Disconnecting device:" << dev->product;
             sendRequest(dev,usbFeatureType::featureOverlay,60,"Goodbye from wfview");
 
-            QMutexLocker locker(mutex);
-
             if (dev->type.model == RC28) {
                 ledControl(false, 3);
             }
+
+            QMutexLocker locker(mutex);
+
             hid_close(dev->handle);
             dev->connected=false;
             dev->handle=NULL;
         }
+    } else {
+        qInfo(logUsbControl()) << "Enabling device:" << dev->product;
     }
+    QTimer::singleShot(250, this, SLOT(run())); // Call run disconnect/reconnect after 250ms
 }
 
 
@@ -1584,22 +1618,25 @@ void usbController::loadCommands()
     commands.clear();
     int num = 0;
     // Important commands at the top!
-    commands.append(COMMAND(num++, "None", commandButton, cmdNone, 0x0));
-    commands.append(COMMAND(num++, "PTT On", commandButton, cmdSetPTT, 0x1));
-    commands.append(COMMAND(num++, "PTT Off", commandButton, cmdSetPTT, 0x0));
-    commands.append(COMMAND(num++, "PTT Toggle", commandButton, cmdPTTToggle, 0x0));
-    commands.append(COMMAND(num++, "VFOA", commandKnob, cmdSetFreq, 0x0));
-    commands.append(COMMAND(num++, "VFOB", commandKnob, cmdSetFreq, 0x1));
-    commands.append(COMMAND(num++, "Span/Step", commandKnob, cmdSeparator, 0x0));
-    commands.append(COMMAND(num++, "Tune", commandButton, cmdStartATU, 0x0));
-    commands.append(COMMAND(num++, "Span/Step", commandButton, cmdSeparator, 0x0));
-    commands.append(COMMAND(num++, "Step+", commandButton, cmdSetStepUp, 0x0));
-    commands.append(COMMAND(num++, "Step-", commandButton, cmdSetStepDown, 0x0));
-    commands.append(COMMAND(num++, "Span+", commandButton, cmdSetSpanUp, 0x0));
-    commands.append(COMMAND(num++, "Span-", commandButton, cmdSetSpanDown, 0x0));
-    commands.append(COMMAND(num++, "Modes", commandButton, cmdSeparator, 0x0));
-    commands.append(COMMAND(num++, "Mode+", commandButton, cmdSetModeUp, 0x0));
-    commands.append(COMMAND(num++, "Mode-", commandButton, cmdSetModeDown, 0x0));
+    commands.append(COMMAND(num++, "None", commandAny, cmdNone, (quint8)0x0));
+    commands.append(COMMAND(num++, "PTT On", commandButton, cmdSetPTT, (quint8)0x1));
+    commands.append(COMMAND(num++, "PTT Off", commandButton, cmdSetPTT, (quint8)0x0));
+    commands.append(COMMAND(num++, "Freq Down", commandButton, cmdSetFreq, (int)-1));
+    commands.append(COMMAND(num++, "Freq Up", commandButton, cmdSetFreq, (int)1));
+    commands.append(COMMAND(num++, "PTT Off", commandButton, cmdSetPTT, (quint8)0x0));
+    commands.append(COMMAND(num++, "PTT Toggle", commandButton, cmdPTTToggle, (quint8)0x0));
+    commands.append(COMMAND(num++, "VFOA", commandKnob, cmdSetFreq, (quint8)0x0));
+    commands.append(COMMAND(num++, "VFOB", commandKnob, cmdSetFreq, (quint8)0x1));
+    commands.append(COMMAND(num++, "Span/Step", commandKnob, cmdSeparator, (quint8)0x0));
+    commands.append(COMMAND(num++, "Tune", commandButton, cmdStartATU, (quint8)0x0));
+    commands.append(COMMAND(num++, "Span/Step", commandButton, cmdSeparator, (quint8)0x0));
+    commands.append(COMMAND(num++, "Step+", commandButton, cmdSetStepUp, (quint8)0x0));
+    commands.append(COMMAND(num++, "Step-", commandButton, cmdSetStepDown, (quint8)0x0));
+    commands.append(COMMAND(num++, "Span+", commandButton, cmdSetSpanUp, (quint8)0x0));
+    commands.append(COMMAND(num++, "Span-", commandButton, cmdSetSpanDown, (quint8)0x0));
+    commands.append(COMMAND(num++, "Modes", commandButton, cmdSeparator, (quint8)0x0));
+    commands.append(COMMAND(num++, "Mode+", commandButton, cmdSetModeUp, (quint8)0x0));
+    commands.append(COMMAND(num++, "Mode-", commandButton, cmdSetModeDown, (quint8)0x0));
     commands.append(COMMAND(num++, "Mode LSB", commandButton, cmdSetMode, modeLSB));
     commands.append(COMMAND(num++, "Mode USB", commandButton, cmdSetMode, modeUSB));
     commands.append(COMMAND(num++, "Mode LSBD", commandButton, cmdSetMode, modeLSB_D));
@@ -1614,9 +1651,9 @@ void usbController::loadCommands()
     commands.append(COMMAND(num++, "Mode PSKR", commandButton, cmdSetMode, modePSK_R));
     commands.append(COMMAND(num++, "Mode DV", commandButton, cmdSetMode, modeDV));
     commands.append(COMMAND(num++, "Mode DD", commandButton, cmdSetMode, modeDD));
-    commands.append(COMMAND(num++, "Bands", commandButton, cmdSeparator, 0x0));
-    commands.append(COMMAND(num++, "Band+", commandButton, cmdSetBandUp, 0x0));
-    commands.append(COMMAND(num++, "Band-", commandButton, cmdSetBandDown, 0x0));
+    commands.append(COMMAND(num++, "Bands", commandButton, cmdSeparator, (quint8)0x0));
+    commands.append(COMMAND(num++, "Band+", commandButton, cmdSetBandUp, (quint8)0x0));
+    commands.append(COMMAND(num++, "Band-", commandButton, cmdSetBandDown, (quint8)0x0));
     commands.append(COMMAND(num++, "Band 23cm", commandButton, cmdGetBandStackReg, band23cm));
     commands.append(COMMAND(num++, "Band 70cm", commandButton, cmdGetBandStackReg, band70cm));
     commands.append(COMMAND(num++, "Band 2m", commandButton, cmdGetBandStackReg, band2m));
@@ -1637,47 +1674,47 @@ void usbController::loadCommands()
     commands.append(COMMAND(num++, "Band 630m", commandButton, cmdGetBandStackReg, band630m));
     commands.append(COMMAND(num++, "Band 2200m", commandButton, cmdGetBandStackReg, band2200m));
     commands.append(COMMAND(num++, "Band GEN", commandButton, cmdGetBandStackReg, bandGen));
-    commands.append(COMMAND(num++, "NB/NR", commandButton, cmdSeparator, 0x0));
-    commands.append(COMMAND(num++, "NR On", commandButton, cmdSetNR, 0x01));
-    commands.append(COMMAND(num++, "NR Off", commandButton, cmdSetNR, 0x0));
-    commands.append(COMMAND(num++, "NB On", commandButton, cmdSetNB, 0x01));
-    commands.append(COMMAND(num++, "NB Off", commandButton, cmdSetNB, 0x0));
-    commands.append(COMMAND(num++, "Moni On", commandButton, cmdSetMonitor, 0x01));
-    commands.append(COMMAND(num++, "Moni Off", commandButton, cmdSetMonitor, 0x0));
-    commands.append(COMMAND(num++, "Comp On", commandButton, cmdSetComp, 0x01));
-    commands.append(COMMAND(num++, "Comp Off", commandButton, cmdSetComp, 0x0));
-    commands.append(COMMAND(num++, "Vox On", commandButton, cmdSetVox, 0x01));
-    commands.append(COMMAND(num++, "Vox Off", commandButton, cmdSetVox, 0x0));
-    commands.append(COMMAND(num++, "Split", commandButton, cmdNone, 0x0));
-    commands.append(COMMAND(num++, "Split On", commandButton, cmdSetQuickSplit, 0x01));
-    commands.append(COMMAND(num++, "Split Off", commandButton, cmdSetQuickSplit, 0x0));
-    commands.append(COMMAND(num++, "Swap VFO", commandButton, cmdVFOSwap, 0x0));
-    commands.append(COMMAND(num++, "Scope", commandButton, cmdNone, 0x0));
-    commands.append(COMMAND(num++, "Spectrum", commandButton, cmdLCDSpectrum, 0x0));
-    commands.append(COMMAND(num++, "Waterfall", commandButton, cmdLCDWaterfall, 0x0));
-    commands.append(COMMAND(num++, "Pages", commandButton, cmdSeparator, 0x0));
-    commands.append(COMMAND(num++, "Page Down", commandButton, cmdPageDown, 0x0));
-    commands.append(COMMAND(num++, "Page Up", commandButton, cmdPageUp, 0x0));
+    commands.append(COMMAND(num++, "NB/NR", commandButton, cmdSeparator, (quint8)0x0));
+    commands.append(COMMAND(num++, "NR On", commandButton, cmdSetNR, (quint8)0x01));
+    commands.append(COMMAND(num++, "NR Off", commandButton, cmdSetNR, (quint8)0x0));
+    commands.append(COMMAND(num++, "NB On", commandButton, cmdSetNB, (quint8)0x01));
+    commands.append(COMMAND(num++, "NB Off", commandButton, cmdSetNB, (quint8)0x0));
+    commands.append(COMMAND(num++, "Moni On", commandButton, cmdSetMonitor, (quint8)0x01));
+    commands.append(COMMAND(num++, "Moni Off", commandButton, cmdSetMonitor, (quint8)0x0));
+    commands.append(COMMAND(num++, "Comp On", commandButton, cmdSetComp, (quint8)0x01));
+    commands.append(COMMAND(num++, "Comp Off", commandButton, cmdSetComp, (quint8)0x0));
+    commands.append(COMMAND(num++, "Vox On", commandButton, cmdSetVox, (quint8)0x01));
+    commands.append(COMMAND(num++, "Vox Off", commandButton, cmdSetVox, (quint8)0x0));
+    commands.append(COMMAND(num++, "Split", commandButton, cmdNone, (quint8)0x0));
+    commands.append(COMMAND(num++, "Split On", commandButton, cmdSetQuickSplit, (quint8)0x01));
+    commands.append(COMMAND(num++, "Split Off", commandButton, cmdSetQuickSplit, (quint8)0x0));
+    commands.append(COMMAND(num++, "Swap VFO", commandButton, cmdVFOSwap, (quint8)0x0));
+    commands.append(COMMAND(num++, "Scope", commandButton, cmdNone, (quint8)0x0));
+    commands.append(COMMAND(num++, "Spectrum", commandButton, cmdLCDSpectrum, (quint8)0x0));
+    commands.append(COMMAND(num++, "Waterfall", commandButton, cmdLCDWaterfall, (quint8)0x0));
+    commands.append(COMMAND(num++, "Pages", commandButton, cmdSeparator, (quint8)0x0));
+    commands.append(COMMAND(num++, "Page Down", commandButton, cmdPageDown, (quint8)0x0));
+    commands.append(COMMAND(num++, "Page Up", commandButton, cmdPageUp, (quint8)0x0));
 
-    commands.append(COMMAND(num++, "AF Gain", commandKnob, cmdSetAfGain, cmdGetAfGain, 0xff));
-    commands.append(COMMAND(num++, "RF Gain", commandKnob, cmdSetRxRfGain, cmdGetRxGain,  0xff));
-    commands.append(COMMAND(num++, "TX Power", commandKnob, cmdSetTxPower, cmdGetTxPower, 0xff));
-    commands.append(COMMAND(num++, "Mic Gain", commandKnob, cmdSetMicGain, cmdGetMicGain, 0xff));
-    commands.append(COMMAND(num++, "Mod Level", commandKnob, cmdSetModLevel, cmdNone, 0xff));
-    commands.append(COMMAND(num++, "Squelch", commandKnob, cmdSetSql, cmdGetSql, 0xff));
-    commands.append(COMMAND(num++, "Monitor", commandKnob, cmdSetMonitorGain, cmdGetMonitorGain, 0xff));
-    commands.append(COMMAND(num++, "Compressor", commandKnob, cmdSetCompLevel, cmdGetCompLevel, 0xff));
-    commands.append(COMMAND(num++, "Vox Level", commandKnob, cmdSetVoxGain, cmdGetVoxGain, 0xff));
-    commands.append(COMMAND(num++, "Anti-Vox", commandKnob, cmdSetAntiVoxGain, cmdGetAntiVoxGain, 0xff));
-    commands.append(COMMAND(num++, "NB Level", commandKnob, cmdSetNBLevel, cmdGetNBLevel, 0xff));
-    commands.append(COMMAND(num++, "NR Level", commandKnob, cmdSetNRLevel, cmdGetNRLevel, 0xff));
-    commands.append(COMMAND(num++, "Span/Step", commandKnob, cmdSeparator, 0x0));
-    commands.append(COMMAND(num++, "IF Shift", commandKnob, cmdSetIFShift, cmdGetIFShift, 0xff));
-    commands.append(COMMAND(num++, "In PBT", commandKnob, cmdSetTPBFInner, cmdGetTPBFInner, 0xff));
-    commands.append(COMMAND(num++, "Out PBT", commandKnob, cmdSetTPBFOuter, cmdGetTPBFOuter, 0xff));
-    commands.append(COMMAND(num++, "Span/Step", commandKnob, cmdSeparator, 0x0));
-    commands.append(COMMAND(num++, "CW Pitch", commandKnob, cmdSetCwPitch, cmdGetCwPitch, 0xff));
-    commands.append(COMMAND(num++, "CW Speed", commandKnob, cmdSetKeySpeed, cmdGetKeySpeed, 0xff));
+    commands.append(COMMAND(num++, "AF Gain", commandKnob, cmdSetAfGain, cmdGetAfGain, (quint8)0xff));
+    commands.append(COMMAND(num++, "RF Gain", commandKnob, cmdSetRxRfGain, cmdGetRxGain,  (quint8)0xff));
+    commands.append(COMMAND(num++, "TX Power", commandKnob, cmdSetTxPower, cmdGetTxPower, (quint8)0xff));
+    commands.append(COMMAND(num++, "Mic Gain", commandKnob, cmdSetMicGain, cmdGetMicGain, (quint8)0xff));
+    commands.append(COMMAND(num++, "Mod Level", commandKnob, cmdSetModLevel, cmdNone, (quint8)0xff));
+    commands.append(COMMAND(num++, "Squelch", commandKnob, cmdSetSql, cmdGetSql, (quint8)0xff));
+    commands.append(COMMAND(num++, "Monitor", commandKnob, cmdSetMonitorGain, cmdGetMonitorGain, (quint8)0xff));
+    commands.append(COMMAND(num++, "Compressor", commandKnob, cmdSetCompLevel, cmdGetCompLevel, (quint8)0xff));
+    commands.append(COMMAND(num++, "Vox Level", commandKnob, cmdSetVoxGain, cmdGetVoxGain, (quint8)0xff));
+    commands.append(COMMAND(num++, "Anti-Vox", commandKnob, cmdSetAntiVoxGain, cmdGetAntiVoxGain, (quint8)0xff));
+    commands.append(COMMAND(num++, "NB Level", commandKnob, cmdSetNBLevel, cmdGetNBLevel, (quint8)0xff));
+    commands.append(COMMAND(num++, "NR Level", commandKnob, cmdSetNRLevel, cmdGetNRLevel, (quint8)0xff));
+    commands.append(COMMAND(num++, "Span/Step", commandKnob, cmdSeparator, (quint8)0x0));
+    commands.append(COMMAND(num++, "IF Shift", commandKnob, cmdSetIFShift, cmdGetIFShift, (quint8)0xff));
+    commands.append(COMMAND(num++, "In PBT", commandKnob, cmdSetTPBFInner, cmdGetTPBFInner, (quint8)0xff));
+    commands.append(COMMAND(num++, "Out PBT", commandKnob, cmdSetTPBFOuter, cmdGetTPBFOuter, (quint8)0xff));
+    commands.append(COMMAND(num++, "Span/Step", commandKnob, cmdSeparator, (quint8)0x0));
+    commands.append(COMMAND(num++, "CW Pitch", commandKnob, cmdSetCwPitch, cmdGetCwPitch, (quint8)0xff));
+    commands.append(COMMAND(num++, "CW Speed", commandKnob, cmdSetKeySpeed, cmdGetKeySpeed, (quint8)0xff));
 }
 
 
@@ -1688,33 +1725,11 @@ void usbController::programPages(USBDEVICE* dev, int val)
     if (dev->pages > val) {
         qInfo(logUsbControl()) << "Removing unused pages from " << dev->product;
         // Remove unneded pages
-#if (QT_VERSION < QT_VERSION_CHECK(6,0,0))
-        auto bt = buttonList->begin();
-        while (bt != buttonList->end())
-        {
-            if (bt->devicePath == dev->path && bt->page > val) {
-                delete bt->onCommand;
-                delete bt->offCommand;
-                bt = buttonList->erase(bt);
-            }
-            else
-                ++bt;
-        }
-        auto kb = knobList->begin();
-        while (kb != knobList->end())
-        {
-            if (kb->devicePath == dev->path && kb->page > val) {
-                delete kb->command;
-                kb = knobList->erase(kb);
-            } else
-                ++kb;
-        }
-#else
+
         buttonList->erase(std::remove_if(buttonList->begin(), buttonList->end(), [val](auto bt) {
             return (bt.page>val); }),buttonList->end());
         knobList->erase(std::remove_if(knobList->begin(), knobList->end(), [val](auto kb) {
             return (kb.page>val); }),knobList->end());
-#endif
     }
     else if (dev->pages < val)
     {
@@ -1755,7 +1770,6 @@ void usbController::programPages(USBDEVICE* dev, int val)
         }
     }
     dev->pages = val;
-    (*controllers)[dev->path].pages = val;
 }
 
 
@@ -1813,8 +1827,10 @@ void usbController::receiveLevel(cmds cmd, unsigned char level)
     // Update knob if relevant, step through all devices
     QMutexLocker locker(mutex);
 
-    for (auto dev = usbDevices.begin(); dev != usbDevices.end(); dev++)
+    for (auto devIt = devices->begin(); devIt != devices->end(); devIt++)
     {
+        auto dev = &devIt.value();
+
         auto kb = std::find_if(knobList->begin(), knobList->end(), [dev, cmd](const KNOB& k)
         { return (k.command && dev->connected && k.path == dev->path && k.page == dev->currentPage && k.command->getCommand == cmd);});
         if (kb != knobList->end() && kb->num < dev->knobValues.size()) {
@@ -1823,6 +1839,7 @@ void usbController::receiveLevel(cmds cmd, unsigned char level)
             dev->knobValues[kb->num].value = level/dev->sensitivity;
             dev->knobValues[kb->num].previous = level/dev->sensitivity;
         }
+        ++devIt;
     }
 }
 
@@ -1831,105 +1848,128 @@ void usbController::backupController(QString file, QString path)
     QSettings settings = QSettings(file, QSettings::Format::IniFormat);
 
     qInfo(logUsbControl()) << "Backup of" << path << "to" << file;
+
+    settings.setValue("Version", QString(WFVIEW_VERSION));
     settings.beginGroup("Controller");
     QMutexLocker locker(mutex);
 
-    CONTROLLER cntrl = (*controllers)[path];
-    settings.setValue("Disabled", cntrl.disabled);
-    settings.setValue("Sensitivity", cntrl.sensitivity);
-    settings.setValue("Brightness", cntrl.brightness);
-    settings.setValue("Orientation", cntrl.orientation);
-    settings.setValue("Speed", cntrl.speed);
-    settings.setValue("Timeout", cntrl.timeout);
-    settings.setValue("Pages", cntrl.pages);
-    settings.setValue("Color", cntrl.color.name(QColor::HexArgb));
-    settings.setValue("LCD", cntrl.lcd);
-
-    int n=0;
-    settings.beginWriteArray("Buttons");
-    for (auto b = buttonList->begin(); b != buttonList->end(); b++)
+    auto devIt = devices->find(file);
+    if (devIt==devices->end())
     {
-        if (b->path == path)
+        qWarning(logUsbControl) << "Cannot find existing device in backupController(), aborting!";
+        return;
+    }
+    else
+    {
+        auto dev = &devIt.value();
+        settings.setValue("Model",dev->product);
+        settings.setValue("Disabled", dev->disabled);
+        settings.setValue("Sensitivity", dev->sensitivity);
+        settings.setValue("Brightness", dev->brightness);
+        settings.setValue("Orientation", dev->orientation);
+        settings.setValue("Speed", dev->speed);
+        settings.setValue("Timeout", dev->timeout);
+        settings.setValue("Pages", dev->pages);
+        settings.setValue("Color", dev->color.name(QColor::HexArgb));
+        settings.setValue("LCD", dev->lcd);
+
+        int n=0;
+        settings.beginWriteArray("Buttons");
+        for (auto b = buttonList->begin(); b != buttonList->end(); b++)
         {
-            settings.setArrayIndex(n);
-            settings.setValue("Page", b->page);
-            settings.setValue("Dev", b->dev);
-            settings.setValue("Num", b->num);
-            settings.setValue("Name", b->name);
-            settings.setValue("Left", b->pos.left());
-            settings.setValue("Top", b->pos.top());
-            settings.setValue("Width", b->pos.width());
-            settings.setValue("Height", b->pos.height());
-            settings.setValue("Colour", b->textColour.name(QColor::HexArgb));
-            settings.setValue("BackgroundOn", b->backgroundOn.name(QColor::HexArgb));
-            settings.setValue("BackgroundOff", b->backgroundOff.name(QColor::HexArgb));
-            if (b->icon != Q_NULLPTR) {
-                settings.setValue("Icon", *b->icon);
-                settings.setValue("IconName", b->iconName);
+            if (b->path == path)
+            {
+                settings.setArrayIndex(n);
+                settings.setValue("Page", b->page);
+                settings.setValue("Dev", b->dev);
+                settings.setValue("Num", b->num);
+                settings.setValue("Name", b->name);
+                settings.setValue("Left", b->pos.left());
+                settings.setValue("Top", b->pos.top());
+                settings.setValue("Width", b->pos.width());
+                settings.setValue("Height", b->pos.height());
+                settings.setValue("Colour", b->textColour.name(QColor::HexArgb));
+                settings.setValue("BackgroundOn", b->backgroundOn.name(QColor::HexArgb));
+                settings.setValue("BackgroundOff", b->backgroundOff.name(QColor::HexArgb));
+                if (b->icon != Q_NULLPTR) {
+                    settings.setValue("Icon", *b->icon);
+                    settings.setValue("IconName", b->iconName);
+                }
+                settings.setValue("Toggle", b->toggle);
+
+                if (b->onCommand != Q_NULLPTR)
+                    settings.setValue("OnCommand", b->onCommand->text);
+                if (b->offCommand != Q_NULLPTR)
+                    settings.setValue("OffCommand", b->offCommand->text);
+                ++n;
             }
-            settings.setValue("Toggle", b->toggle);
-
-            if (b->onCommand != Q_NULLPTR)
-                settings.setValue("OnCommand", b->onCommand->text);
-            if (b->offCommand != Q_NULLPTR)
-                settings.setValue("OffCommand", b->offCommand->text);
-            ++n;
         }
-    }
-    settings.endArray();
+        settings.endArray();
 
-    n = 0;
-    settings.beginWriteArray("Knobs");
-    for (auto k = knobList->begin(); k != knobList->end(); k++)
-    {
-        if (k->path == path)
+        n = 0;
+        settings.beginWriteArray("Knobs");
+        for (auto k = knobList->begin(); k != knobList->end(); k++)
         {
-            settings.setArrayIndex(n);
-            settings.setValue("Page", k->page);
-            settings.setValue("Dev", k->dev);
-            settings.setValue("Num", k->num);
-            settings.setValue("Left", k->pos.left());
-            settings.setValue("Top", k->pos.top());
-            settings.setValue("Width", k->pos.width());
-            settings.setValue("Height", k->pos.height());
-            settings.setValue("Colour", k->textColour.name());
-            if (k->command != Q_NULLPTR)
-                settings.setValue("Command", k->command->text);
-            ++n;
+            if (k->path == path)
+            {
+                settings.setArrayIndex(n);
+                settings.setValue("Page", k->page);
+                settings.setValue("Dev", k->dev);
+                settings.setValue("Num", k->num);
+                settings.setValue("Left", k->pos.left());
+                settings.setValue("Top", k->pos.top());
+                settings.setValue("Width", k->pos.width());
+                settings.setValue("Height", k->pos.height());
+                settings.setValue("Colour", k->textColour.name());
+                if (k->command != Q_NULLPTR)
+                    settings.setValue("Command", k->command->text);
+                ++n;
+            }
         }
-    }
 
-    settings.endArray();
-    settings.endGroup();
-    settings.sync();
+        settings.endArray();
+        settings.endGroup();
+        settings.sync();
+    }
 }
 
 void usbController::restoreController(QString file, QString path)
 {
-    CONTROLLER cntrl = (*controllers)[path];
-    USBDEVICE* dev = &usbDevices[path];
+
+    auto devIt = devices->find(path);
+    if (devIt==devices->end())
+    {
+        qWarning(logUsbControl) << "Cannot find existing device in restoreController(), aborting!";
+        return;
+    }
+
+    // If we are here, we have a valid device
+    auto dev = &devIt.value();
+
     QSettings settings = QSettings(file, QSettings::Format::IniFormat);
 
     qInfo(logUsbControl()) << "Restore of" << path << "from" << file;
     settings.beginGroup("Controller");
+
+    // Signal UI to remove existing device.
     emit removeDevice(dev);
 
     QMutexLocker locker(mutex);
 
-    // Remove buttons/knobs
+    dev->disabled = settings.value("Disabled", false).toBool();
+    dev->sensitivity = settings.value("Sensitivity", 1).toInt();
+    dev->pages = settings.value("Pages", 1).toInt();
+    dev->brightness = (quint8)settings.value("Brightness", 2).toInt();
+    dev->orientation = (quint8)settings.value("Orientation", 2).toInt();
+    dev->speed = (quint8)settings.value("Speed", 2).toInt();
+    dev->timeout = (quint8)settings.value("Timeout", 30).toInt();
+    dev->color.setNamedColor(settings.value("Color", QColor(Qt::white).name(QColor::HexArgb)).toString());
+    dev->lcd = (cmds)settings.value("LCD",0).toInt();
+
+    // Remove old buttons
     buttonList->erase(std::remove_if(buttonList->begin(), buttonList->end(), [path](const BUTTON& b)
         { return (b.path == path); }),buttonList->end());
 
-    cntrl.disabled = settings.value("Disabled", false).toBool();
-    cntrl.sensitivity = settings.value("Sensitivity", 1).toInt();
-    cntrl.pages = settings.value("Pages", 1).toInt();
-    cntrl.brightness = (quint8)settings.value("Brightness", 2).toInt();
-    cntrl.orientation = (quint8)settings.value("Orientation", 2).toInt();
-    cntrl.speed = (quint8)settings.value("Speed", 2).toInt();
-    cntrl.timeout = (quint8)settings.value("Timeout", 30).toInt();
-    cntrl.color.setNamedColor(settings.value("Color", QColor(Qt::white).name(QColor::HexArgb)).toString());
-    cntrl.lcd = (cmds)settings.value("LCD",0).toInt();
-
     int numButtons = settings.beginReadArray("Buttons");
     if (numButtons == 0) {
         settings.endArray();
@@ -1964,6 +2004,8 @@ void usbController::restoreController(QString file, QString path)
         settings.endArray();
     }
 
+
+    // Remove old knobs
     knobList->erase(std::remove_if(knobList->begin(), knobList->end(), [path](const KNOB& k)
         { return (k.path == path); }),knobList->end());
 
@@ -1997,14 +2039,13 @@ void usbController::restoreController(QString file, QString path)
     settings.sync();
 
     qInfo(logUsbControl()) << "Disconnecting device" << dev->product;
-    emit removeDevice(dev);
     hid_close(dev->handle);
     dev->handle = NULL;
     dev->connected = false;
     dev->remove = true;
     dev->uiCreated = false;
     devicesConnected--;
-    QTimer::singleShot(250, this, SLOT(run()));
+    QTimer::singleShot(250, this, SLOT(run())); // Call run to cleanup connectons after 250ms
 }
 
 #endif
diff --git a/usbcontroller.h b/usbcontroller.h
index cb83067..03df507 100644
--- a/usbcontroller.h
+++ b/usbcontroller.h
@@ -23,6 +23,8 @@
 #include <QImageWriter>
 #include <QBuffer>
 #include <QSettings>
+#include <QMessageBox>
+
 
 
 #if defined(USB_CONTROLLER) && QT_VERSION < QT_VERSION_CHECK(6,0,0)
@@ -94,12 +96,19 @@ struct KNOBVALUE {
 struct USBDEVICE {
     USBDEVICE() {}
     USBDEVICE(USBTYPE type) : type(type) {}
-
     USBTYPE type;
+    bool detected = false;
     bool remove = false;
     bool connected = false;
     bool uiCreated = false;
     bool disabled = false;
+    quint8 speed=2;
+    quint8 timeout=30;
+    quint8 brightness=2;
+    quint8 orientation=0;
+    QColor color=Qt::darkGray;
+    cmds lcd=cmdNone;
+
     hid_device* handle = NULL;
     QString product = "";
     QString manufacturer = "";
@@ -129,6 +138,8 @@ struct USBDEVICE {
 
 struct COMMAND {
     COMMAND() {}
+    COMMAND(int index, QString text, usbCommandType cmdType, int command, int value) :
+        index(index), text(text), cmdType(cmdType), command(command), value(value) {}
     COMMAND(int index, QString text, usbCommandType cmdType, int command, unsigned char suffix) :
         index(index), text(text), cmdType(cmdType), command(command), suffix(suffix) {}
     COMMAND(int index, QString text, usbCommandType cmdType, int command, int getCommand, unsigned char suffix) :
@@ -158,7 +169,7 @@ struct BUTTON {
         dev(dev), num(-1), name(name), pos(pos), textColour(textColour), onCommand(on), offCommand(off), on(onCommand->text), off(offCommand->text) {}
 
     usbDeviceType dev;
-    USBDEVICE* parent;
+    USBDEVICE* parent = Q_NULLPTR;
     int page=1;
     int num;
     QString name;
@@ -167,7 +178,7 @@ struct BUTTON {
     const COMMAND* onCommand = Q_NULLPTR;
     const COMMAND* offCommand = Q_NULLPTR;
     QGraphicsTextItem* onText = Q_NULLPTR;
-    QGraphicsTextItem* offText;
+    QGraphicsTextItem* offText = Q_NULLPTR;
     QString on;
     QString off;
     QString path;
@@ -187,7 +198,7 @@ struct KNOB {
         dev(dev), num(num), name(""), pos(pos), textColour(textColour), command(command), cmd(command->text) {}
 
     usbDeviceType dev;
-    USBDEVICE* parent;
+    USBDEVICE* parent = Q_NULLPTR;
     int page=1;
     int num;
     QString name;
@@ -200,23 +211,7 @@ struct KNOB {
 };
 
 
-struct CONTROLLER {
-    CONTROLLER() {}
-    CONTROLLER(USBDEVICE* dev) : dev(dev) {}
-    bool disabled=false;
-    int sensitivity=1;
-    quint8 speed=2;
-    quint8 timeout=30;
-    quint8 brightness=2;
-    quint8 orientation=0;
-    QColor color=Qt::white;
-    int pages=1;
-    cmds lcd=cmdNone;
-    USBDEVICE* dev = Q_NULLPTR;
-};
-
-
-typedef QMap<QString,CONTROLLER> usbMap;
+typedef QMap<QString,USBDEVICE> usbDevMap;
 
 
 #if defined(USB_CONTROLLER)
@@ -230,7 +225,7 @@ public:
     bool hotPlugEvent(const QByteArray & eventType, void * message, long * result);
 
 public slots:
-    void init(QMutex* mut,usbMap* prefs ,QVector<BUTTON>* buts,QVector<KNOB>* knobs);
+    void init(QMutex* mut,usbDevMap* prefs ,QVector<BUTTON>* buts,QVector<KNOB>* knobs);
     void run();
     void runTimer();
     void ledControl(bool on, unsigned char num);
@@ -251,8 +246,8 @@ signals:
     void doShuttle(bool plus, quint8 level);
     void setBand(int band);
     void button(const COMMAND* cmd);
-    void initUI();
-    void newDevice(USBDEVICE* dev, CONTROLLER* cntrl, QVector<BUTTON>* but, QVector<KNOB>* kb, QVector<COMMAND>* cmd, QMutex* mut);
+    void initUI(usbDevMap* devs, QVector<BUTTON>* but, QVector<KNOB>* kb, QVector<COMMAND>* cmd, QMutex* mut);
+    void newDevice(USBDEVICE* dev);
     void removeDevice(USBDEVICE* dev);
     void setConnected(USBDEVICE* dev);
     void changePage(USBDEVICE* dev, int page);
@@ -273,8 +268,8 @@ private:
     QVector<KNOB> defaultKnobs;
     QVector<USBTYPE> knownDevices;
     QVector<COMMAND> commands;
-    QMap<QString,USBDEVICE> usbDevices;
-    usbMap *controllers;
+    usbDevMap* devices;
+
 #if (QT_VERSION < QT_VERSION_CHECK(6,0,0))
     QGamepad* gamepad=Q_NULLPTR;
 #endif
diff --git a/wfmain.cpp b/wfmain.cpp
index 1f3b90d..4c608de 100644
--- a/wfmain.cpp
+++ b/wfmain.cpp
@@ -49,7 +49,6 @@ wfmain::wfmain(const QString settingsFile, const QString logFile, bool debugMode
     sat = new satelliteSetup();
     trxadj = new transceiverAdjustments();
     cw = new cwSender();
-    shut = new controllerSetup();
     abtBox = new aboutbox();
     selRad = new selectRadio();
 
@@ -76,7 +75,6 @@ wfmain::wfmain(const QString settingsFile, const QString logFile, bool debugMode
     qRegisterMetaType<QVector<BUTTON>*>();
     qRegisterMetaType<QVector<KNOB>*>();
     qRegisterMetaType<QVector<COMMAND>*>();
-    qRegisterMetaType<const CONTROLLER*>();
     qRegisterMetaType<const COMMAND*>();
     qRegisterMetaType<const USBDEVICE*>();
     qRegisterMetaType<QList<radio_cap_packet>>();
@@ -351,9 +349,9 @@ void wfmain::rigConnections()
 
     connect(this, SIGNAL(getVox()), rig, SLOT(getVox()));
     connect(this, SIGNAL(getMonitor()), rig, SLOT(getMonitor()));
-    connect(this, SIGNAL(getComp()), rig, SLOT(getComp()));
-    connect(this, SIGNAL(getNB()), rig, SLOT(getNB()));
-    connect(this, SIGNAL(getNR()), rig, SLOT(getNR()));
+    connect(this, SIGNAL(getCompressor()), rig, SLOT(getCompressor()));
+    connect(this, SIGNAL(getNb()), rig, SLOT(getNb()));
+    connect(this, SIGNAL(getNb()), rig, SLOT(getNr()));
 
     connect(this, SIGNAL(selectVFO(vfo_t)), rig, SLOT(selectVFO(vfo_t)));
     connect(this, SIGNAL(sendVFOSwap()), rig, SLOT(exchangeVFOs()));
@@ -509,7 +507,7 @@ void wfmain::rigConnections()
 
     connect(this, SIGNAL(setVox(bool)), rig, SLOT(setVox(bool)));
     connect(this, SIGNAL(setMonitor(bool)), rig, SLOT(setMonitor(bool)));
-    connect(this, SIGNAL(setComp(bool)), rig, SLOT(setComp(bool)));
+    connect(this, SIGNAL(setCompressor(bool)), rig, SLOT(setCompressor(bool)));
     connect(this, SIGNAL(setNb(bool)), rig, SLOT(setNb(bool)));
     connect(this, SIGNAL(setNr(bool)), rig, SLOT(setNr(bool)));
 
@@ -531,7 +529,7 @@ void wfmain::rigConnections()
     connect(this, SIGNAL(getPassband()), rig, SLOT(getPassband()));
     connect(this, SIGNAL(getMonitorGain()), rig, SLOT(getMonitorGain()));
     connect(this, SIGNAL(getVoxGain()), rig, SLOT(getVoxGain()));
-    connect(this, SIGNAL(getAntiVoxGain()), rig, SLOT(getAntVoxGain()));
+    connect(this, SIGNAL(getAntiVoxGain()), rig, SLOT(getAntiVoxGain()));
     connect(this, SIGNAL(getNBLevel()), rig, SLOT(getNBLevel()));
     connect(this, SIGNAL(getNRLevel()), rig, SLOT(getNRLevel()));
     connect(this, SIGNAL(getCompLevel()), rig, SLOT(getCompLevel()));
@@ -1697,6 +1695,10 @@ void wfmain::setupKeyShortcuts()
 void wfmain::setupUsbControllerDevice()
 {
 #if defined (USB_CONTROLLER)
+
+    if (usbWindow == Q_NULLPTR) {
+        usbWindow = new controllerSetup();
+    }
     usbControllerDev = new usbController();
     usbControllerThread = new QThread(this);
     usbControllerDev->moveToThread(usbControllerThread);
@@ -1706,23 +1708,23 @@ void wfmain::setupUsbControllerDevice()
     connect(usbControllerDev, SIGNAL(doShuttle(bool,unsigned char)), this, SLOT(doShuttle(bool,unsigned char)));
     connect(usbControllerDev, SIGNAL(button(const COMMAND*)), this, SLOT(buttonControl(const COMMAND*)));
     connect(usbControllerDev, SIGNAL(setBand(int)), this, SLOT(setBand(int)));
-    connect(usbControllerDev, SIGNAL(removeDevice(USBDEVICE*)), shut, SLOT(removeDevice(USBDEVICE*)));
-    connect(usbControllerDev, SIGNAL(initUI()), shut, SLOT(init()));
-    connect(usbControllerDev, SIGNAL(changePage(USBDEVICE*, int)), shut, SLOT(pageChanged(USBDEVICE*, int)));
-    connect(usbControllerDev, SIGNAL(setConnected(USBDEVICE*)), shut, SLOT(setConnected(USBDEVICE*)));
-    connect(usbControllerDev, SIGNAL(newDevice(USBDEVICE*, CONTROLLER *, QVector<BUTTON>*, QVector<KNOB>*, QVector<COMMAND>*, QMutex*)), shut, SLOT(newDevice(USBDEVICE *,CONTROLLER *, QVector<BUTTON>*, QVector<KNOB>*, QVector<COMMAND>*,QMutex*)));
+    connect(usbControllerDev, SIGNAL(removeDevice(USBDEVICE*)), usbWindow, SLOT(removeDevice(USBDEVICE*)));
+    connect(usbControllerDev, SIGNAL(initUI(usbDevMap*, QVector<BUTTON>*, QVector<KNOB>*, QVector<COMMAND>*, QMutex*)), usbWindow, SLOT(init(usbDevMap*, QVector<BUTTON>*, QVector<KNOB>*, QVector<COMMAND>*, QMutex*)));
+    connect(usbControllerDev, SIGNAL(changePage(USBDEVICE*, int)), usbWindow, SLOT(pageChanged(USBDEVICE*, int)));
+    connect(usbControllerDev, SIGNAL(setConnected(USBDEVICE*)), usbWindow, SLOT(setConnected(USBDEVICE*)));
+    connect(usbControllerDev, SIGNAL(newDevice(USBDEVICE*)), usbWindow, SLOT(newDevice(USBDEVICE *)));
     usbControllerThread->start(QThread::LowestPriority);
     
-    connect(shut, SIGNAL(sendRequest(USBDEVICE*, usbFeatureType, quint8, QString, QImage*, QColor *)), usbControllerDev, SLOT(sendRequest(USBDEVICE*, usbFeatureType, quint8, QString, QImage*, QColor *)));
+    connect(usbWindow, SIGNAL(sendRequest(USBDEVICE*, usbFeatureType, quint8, QString, QImage*, QColor *)), usbControllerDev, SLOT(sendRequest(USBDEVICE*, usbFeatureType, quint8, QString, QImage*, QColor *)));
     connect(this, SIGNAL(sendControllerRequest(USBDEVICE*, usbFeatureType, quint8, QString, QImage*, QColor *)), usbControllerDev, SLOT(sendRequest(USBDEVICE*, usbFeatureType, quint8, QString, QImage*, QColor *)));
-    connect(shut, SIGNAL(programPages(USBDEVICE*, int)), usbControllerDev, SLOT(programPages(USBDEVICE*, int)));
-    connect(shut, SIGNAL(programDisable(USBDEVICE*, bool)), usbControllerDev, SLOT(programDisable(USBDEVICE*, bool)));
+    connect(usbWindow, SIGNAL(programPages(USBDEVICE*, int)), usbControllerDev, SLOT(programPages(USBDEVICE*, int)));
+    connect(usbWindow, SIGNAL(programDisable(USBDEVICE*, bool)), usbControllerDev, SLOT(programDisable(USBDEVICE*, bool)));
     connect(this, SIGNAL(setPTT(bool)), usbControllerDev, SLOT(receivePTTStatus(bool)));
     connect(this, SIGNAL(sendLevel(cmds, unsigned char)), usbControllerDev, SLOT(receiveLevel(cmds, unsigned char)));
-    connect(this, SIGNAL(initUsbController(QMutex*,usbMap*,QVector<BUTTON>*,QVector<KNOB>*)), usbControllerDev, SLOT(init(QMutex*,usbMap*,QVector<BUTTON>*,QVector<KNOB>*)));
+    connect(this, SIGNAL(initUsbController(QMutex*,usbDevMap*,QVector<BUTTON>*,QVector<KNOB>*)), usbControllerDev, SLOT(init(QMutex*,usbDevMap*,QVector<BUTTON>*,QVector<KNOB>*)));
     connect(this, SIGNAL(usbHotplug()), usbControllerDev, SLOT(run()));
-    connect(shut, SIGNAL(backup(QString, QString)), usbControllerDev, SLOT(backupController(QString, QString)));
-    connect(shut, SIGNAL(restore(QString, QString)), usbControllerDev, SLOT(restoreController(QString, QString)));
+    connect(usbWindow, SIGNAL(backup(QString, QString)), usbControllerDev, SLOT(backupController(QString, QString)));
+    connect(usbWindow, SIGNAL(restore(QString, QString)), usbControllerDev, SLOT(restoreController(QString, QString)));
 
 #endif
 }
@@ -2515,12 +2517,12 @@ void wfmain::loadSettings()
         settings->endArray();
     }
     else {
-        usbControllers.clear();
+        usbDevices.clear();
         for (int nc = 0; nc < numControllers; nc++)
         {
             settings->setArrayIndex(nc);
-            CONTROLLER tempPrefs;
-            QString tempPath = settings->value("Path", "").toString();
+            USBDEVICE tempPrefs;
+            tempPrefs.path = settings->value("Path", "").toString();
             tempPrefs.disabled = settings->value("Disabled", false).toBool();
             tempPrefs.sensitivity = settings->value("Sensitivity", 1).toInt();
             tempPrefs.pages = settings->value("Pages", 1).toInt();
@@ -2531,8 +2533,8 @@ void wfmain::loadSettings()
             tempPrefs.color.setNamedColor(settings->value("Color", QColor(Qt::white).name(QColor::HexArgb)).toString());
             tempPrefs.lcd = (cmds)settings->value("LCD",0).toInt();
 
-            if (!tempPath.isEmpty()) {
-                usbControllers.insert(tempPath,tempPrefs);
+            if (!tempPrefs.path.isEmpty()) {
+                usbDevices.insert(tempPrefs.path,tempPrefs);
             }
         }
         settings->endArray();
@@ -2550,6 +2552,13 @@ void wfmain::loadSettings()
             BUTTON butt;
             butt.path = settings->value("Path", "").toString();
             butt.page = settings->value("Page", 1).toInt();
+            auto it = usbDevices.find(butt.path);
+            if (it==usbDevices.end())
+            {
+                qWarning(logUsbControl) << "Cannot find existing device while creating button, aborting!";
+                continue;
+            }
+            butt.parent = &it.value();
             butt.dev = (usbDeviceType)settings->value("Dev", 0).toInt();
             butt.num = settings->value("Num", 0).toInt();
             butt.name = settings->value("Name", "").toString();
@@ -2584,6 +2593,13 @@ void wfmain::loadSettings()
             settings->setArrayIndex(nk);
             KNOB kb;
             kb.path = settings->value("Path", "").toString();
+            auto it = usbDevices.find(kb.path);
+            if (it==usbDevices.end())
+            {
+                qWarning(logUsbControl) << "Cannot find existing device while creating knob, aborting!";
+                continue;
+            }
+            kb.parent = &it.value();
             kb.page = settings->value("Page", 1).toInt();
             kb.dev = (usbDeviceType)settings->value("Dev", 0).toInt();
             kb.num = settings->value("Num", 0).toInt();
@@ -2606,7 +2622,7 @@ void wfmain::loadSettings()
     if (prefs.enableUSBControllers) {
         // Setup USB Controller
         setupUsbControllerDevice();
-        emit initUsbController(&usbMutex,&usbControllers,&usbButtons,&usbKnobs);
+        emit initUsbController(&usbMutex,&usbDevices,&usbButtons,&usbKnobs);
     }
 
 
@@ -3020,23 +3036,25 @@ void wfmain::saveSettings()
     settings->beginWriteArray("Controllers");
     int nc=0;
 
-    usbMap::const_iterator i = usbControllers.constBegin();
-    while (i != usbControllers.constEnd())
+    auto it = usbDevices.begin();
+    while (it != usbDevices.end())
     {
+        auto dev = &it.value();
         settings->setArrayIndex(nc);
 
-        settings->setValue("Path", i.key());
-        settings->setValue("Disabled", i.value().disabled);
-        settings->setValue("Sensitivity", i.value().sensitivity);
-        settings->setValue("Brightness", i.value().brightness);
-        settings->setValue("Orientation", i.value().orientation);
-        settings->setValue("Speed", i.value().speed);
-        settings->setValue("Timeout", i.value().timeout);
-        settings->setValue("Pages", i.value().pages);
-        settings->setValue("Color", i.value().color.name(QColor::HexArgb));
-        settings->setValue("LCD", i.value().lcd);
+        settings->setValue("Model", dev->product);
+        settings->setValue("Path", dev->path);
+        settings->setValue("Disabled", dev->disabled);
+        settings->setValue("Sensitivity", dev->sensitivity);
+        settings->setValue("Brightness", dev->brightness);
+        settings->setValue("Orientation", dev->orientation);
+        settings->setValue("Speed", dev->speed);
+        settings->setValue("Timeout", dev->timeout);
+        settings->setValue("Pages", dev->pages);
+        settings->setValue("Color", dev->color.name(QColor::HexArgb));
+        settings->setValue("LCD", dev->lcd);
 
-        ++i;
+        ++it;
         ++nc;
     }
     settings->endArray();
@@ -5376,20 +5394,18 @@ void wfmain::receiveSpectrumData(QByteArray spectrum, double startFreq, double e
 
 #if defined (USB_CONTROLLER)
             // Send to USB Controllers if requested
-            usbMap::const_iterator i = usbControllers.constBegin();
-            while (i != usbControllers.constEnd())
+            auto i = usbDevices.begin();
+            while (i != usbDevices.end())
             {
-                if (i.value().dev != Q_NULLPTR && i.value().dev->connected
-                        && i.value().dev->type.model == usbDeviceType::StreamDeckPlus && i.value().lcd == cmdLCDWaterfall )
+                if (i.value().connected && i.value().type.model == usbDeviceType::StreamDeckPlus && i.value().lcd == cmdLCDWaterfall )
                 {
                     lcdImage = wf->toPixmap().toImage();
-                    emit sendControllerRequest(i.value().dev, usbFeatureType::featureLCD, 0, "", &lcdImage);
+                    emit sendControllerRequest(&i.value(), usbFeatureType::featureLCD, 0, "", &lcdImage);
                 }
-                else if (i.value().dev != Q_NULLPTR && i.value().dev->connected
-                        && i.value().dev->type.model == usbDeviceType::StreamDeckPlus && i.value().lcd == cmdLCDSpectrum)
+                else if (i.value().connected && i.value().type.model == usbDeviceType::StreamDeckPlus && i.value().lcd == cmdLCDSpectrum)
                 {
                     lcdImage = plot->toPixmap().toImage();
-                    emit sendControllerRequest(i.value().dev, usbFeatureType::featureLCD, 0, "", &lcdImage);
+                    emit sendControllerRequest(&i.value(), usbFeatureType::featureLCD, 0, "", &lcdImage);
                 }
                  ++i;
             }
@@ -9389,16 +9405,16 @@ void wfmain::on_enableUsbChk_clicked(bool checked)
         usbControllerThread->wait();
         usbControllerThread = Q_NULLPTR;
     }
+
     if (checked) {
         // Setup USB Controller
         setupUsbControllerDevice();
-        emit initUsbController(&usbMutex,&usbControllers,&usbButtons,&usbKnobs);
+        emit initUsbController(&usbMutex,&usbDevices,&usbButtons,&usbKnobs);
     }
     else {
-        if (shut != Q_NULLPTR) {
-            if (shut->isVisible()) {
-                shut->hide();
-            }
+        if (usbWindow != Q_NULLPTR) {
+            delete usbWindow;
+            usbWindow = Q_NULLPTR;
         }
     }
 #endif
@@ -9406,14 +9422,14 @@ void wfmain::on_enableUsbChk_clicked(bool checked)
 
 void wfmain::on_usbControllerBtn_clicked()
 {
-    if (shut != Q_NULLPTR) {
-        if (shut->isVisible()) {
-            shut->hide();
+    if (usbWindow != Q_NULLPTR) {
+        if (usbWindow->isVisible()) {
+            usbWindow->hide();
         }
         else {
             qInfo(logUsbControl()) << "Showing USB Controller window";
-            shut->show();
-            shut->raise();
+            usbWindow->show();
+            usbWindow->raise();
         }
     }
 }
@@ -9432,7 +9448,7 @@ void wfmain::on_usbControllersResetBtn_clicked()
 
         usbButtons.clear();
         usbKnobs.clear();
-        usbControllers.clear();
+        usbDevices.clear();
 
         if (enabled) on_enableUsbChk_clicked(true); // Force connect of USB controllers
     }
diff --git a/wfmain.h b/wfmain.h
index 08bcfa0..a6651ff 100644
--- a/wfmain.h
+++ b/wfmain.h
@@ -266,7 +266,7 @@ signals:
     void openShuttle();
     void requestRigState();
     void stateUpdated();
-    void initUsbController(QMutex* mutex,usbMap* prefs ,QVector<BUTTON>* buts,QVector<KNOB>* knobs);
+    void initUsbController(QMutex* mutex,usbDevMap* devs ,QVector<BUTTON>* buts,QVector<KNOB>* knobs);
     void setClusterUdpPort(int port);
     void setClusterEnableUdp(bool udp);
     void setClusterEnableTcp(bool tcp);
@@ -1142,7 +1142,7 @@ private:
     satelliteSetup *sat;
     transceiverAdjustments *trxadj;
     cwSender *cw;
-    controllerSetup* shut;
+    controllerSetup* usbWindow = Q_NULLPTR;
     aboutbox *abtBox;
     selectRadio *selRad;
     loggingWindow *logWindow;
@@ -1193,7 +1193,7 @@ private:
     QString typeName;
     QVector<BUTTON> usbButtons;
     QVector<KNOB> usbKnobs;
-    usbMap usbControllers;
+    usbDevMap usbDevices;
     QMutex usbMutex;
 #endif
 
@@ -1232,7 +1232,6 @@ Q_DECLARE_METATYPE(rigstate*)
 Q_DECLARE_METATYPE(QVector <BUTTON>*)
 Q_DECLARE_METATYPE(QVector <KNOB>*)
 Q_DECLARE_METATYPE(QVector <COMMAND>*)
-Q_DECLARE_METATYPE(const CONTROLLER*)
 Q_DECLARE_METATYPE(const COMMAND*)
 Q_DECLARE_METATYPE(const USBDEVICE*)
 Q_DECLARE_METATYPE(codecType)
diff --git a/wfviewtypes.h b/wfviewtypes.h
index bea5fd8..eb03db2 100644
--- a/wfviewtypes.h
+++ b/wfviewtypes.h
@@ -205,7 +205,7 @@ enum usbDeviceType { usbNone = 0, shuttleXpress, shuttlePro2,
                      StreamDeckOriginalMK2,StreamDeckXL,StreamDeckXLV2,StreamDeckPedal, StreamDeckPlus
                    };
 
-enum usbCommandType{ commandButton, commandKnob };
+enum usbCommandType{ commandButton, commandKnob, commandAny };
 enum usbFeatureType { featureReset,featureResetKeys, featureEventsA, featureEventsB, featureFirmware, featureSerial, featureButton, featureSensitivity, featureBrightness,
                       featureOrientation, featureSpeed, featureColor, featureOverlay, featureTimeout, featureLCD, featureGraph };