regtools: completely rework qeditor, improve soc desc library and tools

The graphical editor can now display and editor description files.
The library has been improved to provide more useful function.
The XML format has been slightly changed: only one soc is allowed per file
(this is was already de facto the case since <soc> was the root tag).
Also introduce a DTD to validate the files.

Change-Id: If70ba35b6dc0242bdb87411cf4baee9597798aac

1 files changed, 126 insertions, 408 deletions

diff --git a/utils/regtools/qeditor/regtab.cpp b/utils/regtools/qeditor/regtab.cpp
index 4cd4e7b283..568d859c0e 100644
--- a/utils/regtools/qeditor/regtab.cpp
+++ b/utils/regtools/qeditor/regtab.cpp
@@ -1,406 +1,75 @@
 #include "regtab.h"
 
-#include <QSplitter>
-#include <QVBoxLayout>
-#include <QAbstractListModel>
-#include <QMessageBox>
 #include <QSizePolicy>
-#include <QHBoxLayout>
 #include <QStringBuilder>
-#include <QLabel>
-#include <QGridLayout>
-#include <QTableWidget>
-#include <QHeaderView>
 #include <QFileDialog>
 #include <QDebug>
 #include <QStyle>
 #include "backend.h"
 #include "analyser.h"
+#include "regdisplaypanel.h"
 
-/**
- * SocFieldValidator
- */
-
-SocFieldValidator::SocFieldValidator(QObject *parent)
-    :QValidator(parent)
-{
-    m_field.first_bit = 0;
-    m_field.last_bit = 31;
-}
-
-SocFieldValidator::SocFieldValidator(const soc_reg_field_t& field, QObject *parent)
-    :QValidator(parent), m_field(field)
-{
-}
-
-void SocFieldValidator::fixup(QString& input) const
-{
-    input = input.trimmed();
-}
-
-QValidator::State SocFieldValidator::validate(QString& input, int& pos) const
-{
-    (void) pos;
-    soc_word_t val;
-    State state = parse(input, val);
-    return state;
-}
-
-QValidator::State SocFieldValidator::parse(const QString& input, soc_word_t& val) const
-{
-    // the empty string is all alwats intermediate
-    if(input.size() == 0)
-        return Intermediate;
-    // first check named values
-    State state = Invalid;
-    foreach(const soc_reg_field_value_t& value, m_field.value)
-    {
-        QString name = QString::fromLocal8Bit(value.name.c_str());
-        // cannot be a substring if too long or empty
-        if(input.size() > name.size())
-            continue;
-        // check equal string
-        if(input == name)
-        {
-            state = Acceptable;
-            val = value.value;
-            break;
-        }
-        // check substring
-        if(name.startsWith(input))
-            state = Intermediate;
-    }
-    // early return for exact match
-    if(state == Acceptable)
-        return state;
-    // do a few special cases for convenience
-    if(input.compare("0x", Qt::CaseInsensitive) == 0 ||
-            input.compare("0b", Qt::CaseInsensitive) == 0)
-        return Intermediate;
-    // try by parsing
-    unsigned basis, pos;
-    if(input.size() >= 2 && input.startsWith("0x", Qt::CaseInsensitive))
-    {
-        basis = 16;
-        pos = 2;
-    }
-    else if(input.size() >= 2 && input.startsWith("0b", Qt::CaseInsensitive))
-    {
-        basis = 2;
-        pos = 2;
-    }
-    else if(input.size() >= 2 && input.startsWith("0"))
-    {
-        basis = 8;
-        pos = 1;
-    }
-    else
-    {
-        basis = 10;
-        pos = 0;
-    }
-    bool ok = false;
-    unsigned long v = input.mid(pos).toULong(&ok, basis);
-    // if not ok, return result of name parsing
-    if(!ok)
-        return state;
-    // if ok, check if it fits in the number of bits
-    unsigned nr_bits = m_field.last_bit - m_field.first_bit + 1;
-    unsigned long max = nr_bits == 32 ? 0xffffffff : (1 << nr_bits) - 1;
-    if(v <= max)
-    {
-        val = v;
-        return Acceptable;
-    }
-
-    return state;
-}
-
-/**
- * RegLineEdit
- */
-RegLineEdit::RegLineEdit(QWidget *parent)
-    :QWidget(parent)
+namespace
 {
-    m_layout = new QHBoxLayout(this);
-    m_button = new QToolButton(this);
-    m_button->setCursor(Qt::ArrowCursor);
-    m_button->setStyleSheet("QToolButton { font-weight: bold; color: white; background: black; }");
-    m_button->setPopupMode(QToolButton::InstantPopup);
-    m_edit = new QLineEdit(this);
-    m_layout->addWidget(m_button);
-    m_layout->addWidget(m_edit);
-    m_menu = new QMenu(this);
-    connect(m_menu->addAction("Write"), SIGNAL(triggered()), this, SLOT(OnWriteAct()));
-    connect(m_menu->addAction("Set"), SIGNAL(triggered()), this, SLOT(OnSetAct()));
-    connect(m_menu->addAction("Clear"), SIGNAL(triggered()), this, SLOT(OnClearAct()));
-    connect(m_menu->addAction("Toggle"), SIGNAL(triggered()), this, SLOT(OnToggleAct()));
-    EnableSCT(false);
-    SetReadOnly(false);
-    ShowMode(true);
-    SetMode(Write);
-}
 
-void RegLineEdit::SetReadOnly(bool ro)
+enum
 {
-    m_edit->setReadOnly(ro);
-    m_readonly = ro;
-    ShowMode(!ro);
-}
+    RegTreeDevType = QTreeWidgetItem::UserType,
+    RegTreeRegType
+};
 
-void RegLineEdit::EnableSCT(bool en)
+class DevTreeItem : public QTreeWidgetItem
 {
-    m_has_sct = en;
-    if(!m_has_sct)
-    {
-        m_button->setMenu(0);
-        SetMode(Write);
-    }
-    else
-        m_button->setMenu(m_menu);
-}
-
-RegLineEdit::~RegLineEdit()
-{
-}
+public:
+    DevTreeItem(const QString& string, const SocDevRef& ref)
+        :QTreeWidgetItem(QStringList(string), RegTreeDevType), m_ref(ref) {}
 
-QLineEdit *RegLineEdit::GetLineEdit()
-{
-    return m_edit;
-}
+    const SocDevRef& GetRef() { return m_ref; }
+private:
+    SocDevRef m_ref;
+};
 
-void RegLineEdit::ShowMode(bool show)
+class RegTreeItem : public QTreeWidgetItem
 {
-    if(show)
-        m_button->show();
-    else
-        m_button->hide();
-}
+public:
+    RegTreeItem(const QString& string, const SocRegRef& ref)
+        :QTreeWidgetItem(QStringList(string), RegTreeRegType), m_ref(ref) {}
 
-void RegLineEdit::OnWriteAct()
-{
-    SetMode(Write);
-}
-
-void RegLineEdit::OnSetAct()
-{
-    SetMode(Set);
-}
-
-void RegLineEdit::OnClearAct()
-{
-    SetMode(Clear);
-}
-
-void RegLineEdit::OnToggleAct()
-{
-    SetMode(Toggle);
-}
-
-void RegLineEdit::SetMode(EditMode mode)
-{
-    m_mode = mode;
-    switch(m_mode)
-    {
-        case Write: m_button->setText("WR"); break;
-        case Set: m_button->setText("SET"); break;
-        case Clear: m_button->setText("CLR"); break;
-        case Toggle: m_button->setText("TOG"); break;
-        default: break;
-    }
-}
+    const SocRegRef& GetRef() { return m_ref; }
+private:
+    SocRegRef m_ref;
+};
 
-RegLineEdit::EditMode RegLineEdit::GetMode()
-{
-    return m_mode;
 }
 
 /**
- * RegDisplayPanel
+ * EmptyRegTabPanel
  */
-
-RegDisplayPanel::RegDisplayPanel(QWidget *parent, IoBackend *io_backend, const SocRegRef& reg_ref)
-    :QGroupBox(parent), m_io_backend(io_backend), m_reg(reg_ref)
+EmptyRegTabPanel::EmptyRegTabPanel(QWidget *parent)
+    :QWidget(parent)
 {
-    bool read_only = m_io_backend->IsReadOnly();
-
-    QVBoxLayout *right_layout = new QVBoxLayout;
-
-    const soc_dev_addr_t& dev_addr = m_reg.GetDevAddr();
-    const soc_reg_t& reg = m_reg.GetReg();
-    const soc_reg_addr_t& reg_addr = m_reg.GetRegAddr();
-
-    QString reg_name;
-    reg_name.sprintf("HW_%s_%s", dev_addr.name.c_str(), reg_addr.name.c_str());
-    QStringList names;
-    QVector< soc_addr_t > addresses;
-    names.append(reg_name);
-    addresses.append(reg_addr.addr);
-    if(reg.flags & REG_HAS_SCT)
-    {
-        names.append(reg_name + "_SET");
-        names.append(reg_name + "_CLR");
-        names.append(reg_name + "_TOG");
-        addresses.append(reg_addr.addr + 4);
-        addresses.append(reg_addr.addr + 8);
-        addresses.append(reg_addr.addr + 12);
-    }
-
-    QString str;
-    str += "<table align=left>";
-    for(int i = 0; i < names.size(); i++)
-        str += "<tr><td><b>" + names[i] + "</b></td></tr>";
-    str += "</table>";
-    QLabel *label_names = new QLabel;
-    label_names->setTextFormat(Qt::RichText);
-    label_names->setText(str);
-
-    QString str_addr;
-    str_addr += "<table align=left>";
-    for(int i = 0; i < names.size(); i++)
-        str_addr += "<tr><td><b>" + QString().sprintf("0x%03x", addresses[i]) + "</b></td></tr>";
-    str_addr += "</table>";
-    QLabel *label_addr = new QLabel;
-    label_addr->setTextFormat(Qt::RichText);
-    label_addr->setText(str_addr);
-
-    QHBoxLayout *top_layout = new QHBoxLayout;
-    top_layout->addStretch();
-    top_layout->addWidget(label_names);
-    top_layout->addWidget(label_addr);
-    top_layout->addStretch();
-
-    soc_word_t value;
-    BackendHelper helper(m_io_backend, m_reg);
-    bool has_value = helper.ReadRegister(dev_addr.name.c_str(), reg_addr.name.c_str(), value);
-
-    QHBoxLayout *raw_val_layout = 0;
-    if(has_value)
-    {
-        QLabel *raw_val_name = new QLabel;
-        raw_val_name->setText("Raw value:");
-        m_raw_val_edit = new RegLineEdit;
-        m_raw_val_edit->SetReadOnly(read_only);
-        m_raw_val_edit->GetLineEdit()->setText(QString().sprintf("0x%08x", value));
-        m_raw_val_edit->GetLineEdit()->setAlignment(Qt::AlignHCenter | Qt::AlignVCenter);
-        m_raw_val_edit->GetLineEdit()->setValidator(new SocFieldValidator(m_raw_val_edit));
-        m_raw_val_edit->EnableSCT(!!(reg.flags & REG_HAS_SCT));
-        connect(m_raw_val_edit->GetLineEdit(), SIGNAL(returnPressed()), this, SLOT(OnRawRegValueReturnPressed()));
-        raw_val_layout = new QHBoxLayout;
-        raw_val_layout->addStretch();
-        raw_val_layout->addWidget(raw_val_name);
-        raw_val_layout->addWidget(m_raw_val_edit);
-        raw_val_layout->addStretch();
-    }
-    else
-        m_raw_val_edit = 0;
-
-    QTableWidget *value_table = new QTableWidget;
-    value_table->setRowCount(reg.field.size());
-    value_table->setColumnCount(4);
-    int row = 0;
-    foreach(const soc_reg_field_t& field, reg.field)
-    {
-        QString bits_str;
-        if(field.first_bit == field.last_bit)
-            bits_str.sprintf("%d", field.first_bit);
-        else
-            bits_str.sprintf("%d:%d", field.last_bit, field.first_bit);
-        QTableWidgetItem *item = new QTableWidgetItem(bits_str);
-        item->setTextAlignment(Qt::AlignVCenter | Qt::AlignHCenter);
-        item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
-        value_table->setItem(row, 0, item);
-        item = new QTableWidgetItem(QString(field.name.c_str()));
-        item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
-        value_table->setItem(row, 1, item);
-        item = new QTableWidgetItem();
-        if(has_value)
-        {
-            soc_word_t v = (value & field.bitmask()) >> field.first_bit;
-            QString value_name;
-            foreach(const soc_reg_field_value_t& rval, field.value)
-                if(v == rval.value)
-                    value_name = rval.name.c_str();
-            const char *fmt = "%lu";
-            // heuristic
-            if((field.last_bit - field.first_bit + 1) > 16)
-                fmt = "0x%lx";
-            item->setText(QString().sprintf(fmt, (unsigned long)v));
-            item->setTextAlignment(Qt::AlignVCenter | Qt::AlignHCenter);
-
-            if(value_name.size() != 0)
-            {
-                QTableWidgetItem *t = new QTableWidgetItem(value_name);
-                t->setTextAlignment(Qt::AlignVCenter | Qt::AlignHCenter);
-                t->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
-                value_table->setItem(row, 3, t);
-            }
-        }
-        item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
-        value_table->setItem(row, 2, item);
-        row++;
-    }
-    value_table->setHorizontalHeaderItem(0, new QTableWidgetItem("Bits"));
-    value_table->setHorizontalHeaderItem(1, new QTableWidgetItem("Name"));
-    value_table->setHorizontalHeaderItem(2, new QTableWidgetItem("Value"));
-    value_table->setHorizontalHeaderItem(3, new QTableWidgetItem("Meaning"));
-    value_table->verticalHeader()->setVisible(false);
-    value_table->resizeColumnsToContents();
-    value_table->horizontalHeader()->setStretchLastSection(true);
-    value_table->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
-
-    right_layout->addLayout(top_layout);
-    if(raw_val_layout)
-        right_layout->addLayout(raw_val_layout);
-    //right_layout->addWidget(bits_label);
-    right_layout->addWidget(value_table);
-    //right_layout->addStretch();
-
-    setTitle("Register Description");
-    setLayout(right_layout);
-    AllowWrite(false);
+    QVBoxLayout *l = new QVBoxLayout;
+    l->addStretch();
+    setLayout(l);
 }
 
-void RegDisplayPanel::AllowWrite(bool en)
+void EmptyRegTabPanel::AllowWrite(bool en)
 {
-    m_allow_write = en;
-    if(m_raw_val_edit)
-        m_raw_val_edit->SetReadOnly(m_io_backend->IsReadOnly() || !m_allow_write);
+    Q_UNUSED(en);
 }
 
-IoBackend::WriteMode RegDisplayPanel::EditModeToWriteMode(RegLineEdit::EditMode mode)
+QWidget *EmptyRegTabPanel::GetWidget()
 {
-    switch(mode)
-    {
-        case RegLineEdit::Write: return IoBackend::Write;
-        case RegLineEdit::Set: return IoBackend::Set;
-        case RegLineEdit::Clear: return IoBackend::Clear;
-        case RegLineEdit::Toggle: return IoBackend::Toggle;
-        default: return IoBackend::Write;
-    }
+    return this;
 }
 
-void RegDisplayPanel::OnRawRegValueReturnPressed()
-{
-    soc_word_t val;
-    QLineEdit *edit = m_raw_val_edit->GetLineEdit();
-    const SocFieldValidator *validator = dynamic_cast< const SocFieldValidator *>(edit->validator());
-    QValidator::State state = validator->parse(edit->text(), val);
-    if(state != QValidator::Acceptable)
-        return;
-    IoBackend::WriteMode mode = EditModeToWriteMode(m_raw_val_edit->GetMode());
-    BackendHelper helper(m_io_backend, m_reg);
-    helper.WriteRegister(m_reg.GetDevAddr().name.c_str(), m_reg.GetRegAddr().name.c_str(),
-        val, mode);
-    // FIXME: we should notify the UI to read value back because it has changed
-}
 
 /**
  * RegTab
  */
 
-RegTab::RegTab(Backend *backend)
-    :m_backend(backend)
+RegTab::RegTab(Backend *backend, QWidget *parent)
+    :QSplitter(parent), m_backend(backend)
 {
     QWidget *left = new QWidget;
     this->addWidget(left);
@@ -432,7 +101,7 @@ RegTab::RegTab(Backend *backend)
     QGroupBox *data_sel_group = new QGroupBox("Data selection");
     QHBoxLayout *data_sel_layout = new QHBoxLayout;
     m_data_selector = new QComboBox;
-    m_data_selector->addItem(QIcon::fromTheme("face-sad"), "None", QVariant(DataSelNothing));
+    m_data_selector->addItem(QIcon::fromTheme("text-x-generic"), "Explore", QVariant(DataSelNothing));
     m_data_selector->addItem(QIcon::fromTheme("document-open"), "File...", QVariant(DataSelFile));
 #ifdef HAVE_HWSTUB
     m_data_selector->addItem(QIcon::fromTheme("multimedia-player"), "Device...", QVariant(DataSelDevice));
@@ -446,7 +115,8 @@ RegTab::RegTab(Backend *backend)
     data_sel_reload->setIcon(QIcon::fromTheme("view-refresh"));
     data_sel_reload->setToolTip("Reload data");
     data_sel_layout->addWidget(m_data_selector);
-    data_sel_layout->addWidget(m_data_sel_edit);
+    data_sel_layout->addWidget(m_data_sel_edit, 1);
+    data_sel_layout->addStretch(0);
 #ifdef HAVE_HWSTUB
     m_dev_selector = new QComboBox;
     data_sel_layout->addWidget(m_dev_selector, 1);
@@ -457,12 +127,9 @@ RegTab::RegTab(Backend *backend)
     data_sel_group->setLayout(data_sel_layout);
     m_data_soc_label->setFrameStyle(QFrame::StyledPanel | QFrame::Raised);
 
-    m_right_panel->addWidget(data_sel_group);
-    m_right_content = new QWidget;
-    QVBoxLayout *l = new QVBoxLayout;
-    l->addStretch();
-    m_right_content->setLayout(l);
-    m_right_panel->addWidget(m_right_content);
+    m_right_panel->addWidget(data_sel_group, 0);
+    m_right_content = 0;
+    SetPanel(new EmptyRegTabPanel);
     QWidget *w = new QWidget;
     w->setLayout(m_right_panel);
     this->addWidget(w);
@@ -470,21 +137,17 @@ RegTab::RegTab(Backend *backend)
 
     m_io_backend = m_backend->CreateDummyIoBackend();
 
-    connect(m_soc_selector, SIGNAL(currentIndexChanged(const QString&)),
-        this, SLOT(OnSocChanged(const QString&)));
+    connect(m_soc_selector, SIGNAL(currentIndexChanged(int)),
+        this, SLOT(OnSocChanged(int)));
     connect(m_backend, SIGNAL(OnSocListChanged()), this, SLOT(OnSocListChanged()));
     connect(m_reg_tree, SIGNAL(currentItemChanged(QTreeWidgetItem*, QTreeWidgetItem*)),
         this, SLOT(OnRegItemChanged(QTreeWidgetItem*, QTreeWidgetItem*)));
-    connect(m_reg_tree, SIGNAL(itemClicked(QTreeWidgetItem *, int)), this,
-        SLOT(OnRegItemClicked(QTreeWidgetItem *, int)));
     connect(m_data_selector, SIGNAL(activated(int)),
         this, SLOT(OnDataSelChanged(int)));
     connect(m_data_soc_label, SIGNAL(linkActivated(const QString&)), this,
         SLOT(OnDataSocActivated(const QString&)));
     connect(m_analysers_list, SIGNAL(currentItemChanged(QListWidgetItem *, QListWidgetItem *)),
         this, SLOT(OnAnalyserChanged(QListWidgetItem *, QListWidgetItem *)));
-    connect(m_analysers_list, SIGNAL(itemClicked(QListWidgetItem *)), this,
-        SLOT(OnAnalyserClicked(QListWidgetItem *)));
 #ifdef HAVE_HWSTUB
     connect(m_dev_selector, SIGNAL(currentIndexChanged(int)),
         this, SLOT(OnDevChanged(int)));
@@ -492,14 +155,22 @@ RegTab::RegTab(Backend *backend)
     connect(m_readonly_check, SIGNAL(clicked(bool)), this, SLOT(OnReadOnlyClicked(bool)));
 
     OnSocListChanged();
-    OnDataSelChanged(DataSelNothing);
+    OnDataSelChanged(0);
 }
 
 RegTab::~RegTab()
 {
+#ifdef HAVE_HWSTUB
+    ClearDevList();
+#endif
     delete m_io_backend;
 }
 
+bool RegTab::Quit()
+{
+    return true;
+}
+
 void RegTab::SetDataSocName(const QString& socname)
 {
     if(socname.size() != 0)
@@ -533,9 +204,10 @@ void RegTab::OnDataSelChanged(int index)
 #ifdef HAVE_HWSTUB
         m_dev_selector->hide();
 #endif
+        m_readonly_check->show();
         QFileDialog *fd = new QFileDialog(m_data_selector);
         fd->setFilter("Textual files (*.txt);;All files (*)");
-        fd->setDirectory(Settings::Get()->value("regtab/loaddatadir", QDir::currentPath()).toString());
+        fd->setDirectory(Settings::Get()->value("loaddatadir", QDir::currentPath()).toString());
         if(fd->exec())
         {
             QStringList filenames = fd->selectedFiles();
@@ -545,13 +217,14 @@ void RegTab::OnDataSelChanged(int index)
             SetDataSocName(m_io_backend->GetSocName());
             OnDataSocActivated(m_io_backend->GetSocName());
         }
-        Settings::Get()->setValue("regtab/loaddatadir", fd->directory().absolutePath());
+        Settings::Get()->setValue("loaddatadir", fd->directory().absolutePath());
         SetReadOnlyIndicator();
     }
 #ifdef HAVE_HWSTUB
     else if(var == DataSelDevice)
     {
         m_data_sel_edit->hide();
+        m_readonly_check->show();
         m_dev_selector->show();
         OnDevListChanged();
     }
@@ -562,13 +235,31 @@ void RegTab::OnDataSelChanged(int index)
 #ifdef HAVE_HWSTUB
         m_dev_selector->hide();
 #endif
+        m_readonly_check->hide();
+
         delete m_io_backend;
         m_io_backend = m_backend->CreateDummyIoBackend();
+        m_readonly_check->setCheckState(Qt::Checked);
         SetDataSocName("");
+        UpdateSocFilename();
     }
     OnDataChanged();
 }
 
+void RegTab::UpdateSocFilename()
+{
+    int index = m_data_selector->currentIndex();
+    if(index == -1)
+        return;
+    if(m_data_selector->itemData(index) != DataSelNothing)
+        return;
+    index = m_soc_selector->currentIndex();
+    if(index == -1)
+        return;
+    SocRef ref = m_soc_selector->itemData(index).value< SocRef >();
+    m_data_sel_edit->setText(ref.GetSocFile()->GetFilename());
+}
+
 void RegTab::SetReadOnlyIndicator()
 {
     if(m_io_backend->IsReadOnly())
@@ -582,23 +273,30 @@ void RegTab::OnDataChanged()
 
 void RegTab::OnRegItemChanged(QTreeWidgetItem *current, QTreeWidgetItem *previous)
 {
-    (void) previous;
+    Q_UNUSED(previous);
     OnRegItemClicked(current, 0);
 }
 
 void RegTab::OnRegItemClicked(QTreeWidgetItem *current, int col)
 {
-    (void) col;
-    if(current == 0 || current->type() != RegTreeRegType)
+    Q_UNUSED(col);
+    if(current == 0)
         return;
-    RegTreeItem *item = dynamic_cast< RegTreeItem * >(current);
-
-    DisplayRegister(item->GetRef());
+    if(current->type() == RegTreeRegType)
+    {
+        RegTreeItem *item = dynamic_cast< RegTreeItem * >(current);
+        DisplayRegister(item->GetRef());
+    }
+    else if(current->type() == RegTreeDevType)
+    {
+        DevTreeItem *item = dynamic_cast< DevTreeItem * >(current);
+        DisplayDevice(item->GetRef());
+    }
 }
 
 void RegTab::OnAnalyserChanged(QListWidgetItem *current, QListWidgetItem *previous)
 {
-    (void) previous;
+    Q_UNUSED(previous);
     OnAnalyserClicked(current);
 }
 
@@ -606,33 +304,44 @@ void RegTab::OnAnalyserClicked(QListWidgetItem *current)
 {
     if(current == 0)
         return;
-    delete m_right_content;
     AnalyserFactory *ana = AnalyserFactory::GetAnalyserByName(current->text());
-    m_right_content = ana->Create(m_cur_soc, m_io_backend)->GetWidget();
-    m_right_panel->addWidget(m_right_content, 1);
+    SetPanel(ana->Create(m_cur_soc, m_io_backend));
 }
 
 void RegTab::DisplayRegister(const SocRegRef& ref)
 {
+    SetPanel(new RegDisplayPanel(this, m_io_backend, ref));
+}
+
+void RegTab::DisplayDevice(const SocDevRef& ref)
+{
+    SetPanel(new DevDisplayPanel(this, ref));
+}
+
+void RegTab::SetPanel(RegTabPanel *panel)
+{
     delete m_right_content;
-    RegDisplayPanel *panel = new RegDisplayPanel(this, m_io_backend, ref);
-    panel->AllowWrite(m_readonly_check->checkState() == Qt::Unchecked);
     m_right_content = panel;
-    m_right_panel->addWidget(m_right_content);
+    m_right_content->AllowWrite(m_readonly_check->checkState() == Qt::Unchecked);
+    m_right_panel->addWidget(m_right_content->GetWidget(), 1);
 }
 
 void RegTab::OnSocListChanged()
 {
     m_soc_selector->clear();
-    QStringList socs = m_backend->GetSocNameList();
+    QList< SocRef > socs = m_backend->GetSocList();
     for(int i = 0; i < socs.size(); i++)
-        m_soc_selector->addItem(socs[i]);
+    {
+        QVariant v;
+        v.setValue(socs[i]);
+        m_soc_selector->addItem(QString::fromStdString(socs[i].GetSoc().name), v);
+    }
 }
 
 #ifdef HAVE_HWSTUB
 void RegTab::OnDevListChanged()
 {
-    m_dev_selector->clear();
+    ClearDevList();
     QList< HWStubDevice* > list = m_hwstub_helper.GetDevList();
     foreach(HWStubDevice *dev, list)
     {
@@ -659,10 +368,21 @@ void RegTab::OnDevChanged(int index)
     OnDataSocActivated(m_io_backend->GetSocName());
     OnDataChanged();
 }
+
+void RegTab::ClearDevList()
+{
+    while(m_dev_selector->count() > 0)
+    {
+        HWStubDevice *dev = reinterpret_cast< HWStubDevice* >(m_dev_selector->itemData(0).value< void* >());
+        delete dev;
+        m_dev_selector->removeItem(0);
+    }
+}
 #endif
 
-void RegTab::FillDevSubTree(DevTreeItem *item)
+void RegTab::FillDevSubTree(QTreeWidgetItem *_item)
 {
+    DevTreeItem *item = dynamic_cast< DevTreeItem* >(_item);
     const soc_dev_t& dev = item->GetRef().GetDev();
     for(size_t i = 0; i < dev.reg.size(); i++)
     {
@@ -697,23 +417,21 @@ void RegTab::FillAnalyserList()
     m_analysers_list->addItems(AnalyserFactory::GetAnalysersForSoc(m_cur_soc.GetSoc().name.c_str()));
 }
 
-void RegTab::OnSocChanged(const QString& soc)
+void RegTab::OnSocChanged(int index)
 {
-    m_reg_tree->clear();
-    if(!m_backend->GetSocByName(soc, m_cur_soc))
+    if(index == -1)
         return;
+    m_reg_tree->clear();
+    m_cur_soc = m_soc_selector->itemData(index).value< SocRef >();
     FillRegTree();
     FillAnalyserList();
+    UpdateSocFilename();
 }
 
 void RegTab::OnReadOnlyClicked(bool checked)
 {
     if(m_io_backend->IsReadOnly())
         return SetReadOnlyIndicator();
-    if(m_right_content == 0)
-        return;
-    RegDisplayPanel *panel = dynamic_cast< RegDisplayPanel* >(m_right_content);
-    if(panel == 0)
-        return;
-    panel->AllowWrite(!checked);
+    m_right_content->AllowWrite(!checked);
+    UpdateSocFilename();
 }