Changeset 101417 in vbox

Timestamp:

Oct 11, 2023 4:17:18 PM (19 months ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

159466

Message:

FE/Qt: bugref:10513: Large rework for UIAdvancedSettingsDialog; This one directed to replace tree-widget selector with new tree-view selector having own item representation delegate.

Location:

trunk/src/VBox/Frontends/VirtualBox

Files:

• Makefile.kmk (modified) (1 diff)
• src/settings/UIAdvancedSettingsDialog.cpp (modified) (4 diffs)
• src/settings/UISettingsSelector.cpp (modified) (6 diffs)
• src/settings/UISettingsSelector.h (modified) (8 diffs)

trunk/src/VBox/Frontends/VirtualBox/Makefile.kmk

@@ -1083 +1083 @@
         src/notificationcenter/UINotificationCenter.cpp \
         src/settings/UIAdvancedSettingsDialog.cpp \
+        src/settings/UISettingsSelector.cpp \
         src/settings/editors/UIBaseMemoryEditor.cpp \
         src/settings/editors/UIBootOrderEditor.cpp \

trunk/src/VBox/Frontends/VirtualBox/src/settings/UIAdvancedSettingsDialog.cpp

@@ -940 +940 @@
 #else /* !VBOX_GUI_WITH_TOOLBAR_SETTINGS */
 
+    /* Make sure there is a serious spacing between selector and pages: */
+    m_pLayoutMain->setColumnMinimumWidth(1, 20);
+
     /* Prepare classical tree-view selector: */
-    m_pSelector = new UISettingsSelectorTreeWidget(centralWidget());
+    m_pSelector = new UISettingsSelectorTreeView(centralWidget());
     if (m_pSelector)
     {
-        m_pLayoutMain->addWidget(m_pSelector->widget(), 0, 0, 2, 1);
+        m_pLayoutMain->addWidget(m_pSelector->widget(), 1, 0);
         m_pSelector->widget()->setFocus();
     }
@@ -954 +957 @@
         connect(m_pEditorFilter, &UIFilterEditor::sigTextChanged,
                 this, &UIAdvancedSettingsDialog::sltHandleFilterTextChanged);
-        m_pLayoutMain->addWidget(m_pEditorFilter, 0, 1);
+        m_pLayoutMain->addWidget(m_pEditorFilter, 0, 2);
     }
 #endif /* !VBOX_GUI_WITH_TOOLBAR_SETTINGS */
@@ -994 +997 @@
 
         /* Add scroll-area into main layout: */
-        m_pLayoutMain->addWidget(m_pScrollArea, 1, 1);
+        m_pLayoutMain->addWidget(m_pScrollArea, 1, 2);
     }
 }
@@ -1055 +1058 @@
 
         /* Add button-box into main layout: */
-        m_pLayoutMain->addWidget(m_pButtonBox, 2, 0, 1, 2);
+        m_pLayoutMain->addWidget(m_pButtonBox, 2, 0, 1, 3);
     }
 }

trunk/src/VBox/Frontends/VirtualBox/src/settings/UISettingsSelector.cpp

@@ -27 +27 @@
 
 /* Qt includes: */
+#include <QAbstractItemModel>
 #include <QAccessibleWidget>
 #include <QAction>
 #include <QActionGroup>
 #include <QHeaderView>
+#include <QItemDelegate>
 #include <QLayout>
+#include <QPainter>
 #include <QTabWidget>
 #include <QToolButton>
@@ -37 +40 @@
 /* GUI includes: */
 #include "QITabWidget.h"
+#include "QITreeView.h"
 #include "QITreeWidget.h"
 #include "UISettingsSelector.h"
 #include "UIIconPool.h"
+#include "UIImageTools.h"
 #include "UISettingsPage.h"
 #include "QIToolBar.h"
@@ -102 +107 @@
     /** Returns corresponding toolbar button. */
     QToolButton *button() const { return qobject_cast<QToolButton*>(widget()); }
+};
+
+
+/** QITreeViewItem subclass used as selector tree-view item. */
+class UISelectorTreeViewItem : public QITreeViewItem
+{
+    Q_OBJECT;
+
+public:
+
+    /** Constructs selector item passing @a pParent to the base-class.
+      * This is constructor for root-item only. */
+    UISelectorTreeViewItem(QITreeView *pParent);
+    /** Constructs selector item passing @a pParentItem to the base-class.
+      * This is constructor for rest of items we need.
+      * @param  iID      Brings the item ID.
+      * @param  icon     Brings the item icon.
+      * @param  strLink  Brings the item link. */
+    UISelectorTreeViewItem(UISelectorTreeViewItem *pParentItem,
+                           int iID,
+                           const QIcon &icon,
+                           const QString &strLink);
+
+    /** Returns item ID. */
+    int id() const { return m_iID; }
+    /** Returns item icon. */
+    QIcon icon() const { return m_icon; }
+    /** Returns item link. */
+    QString link() const { return m_strLink; }
+
+    /** Returns item text. */
+    virtual QString text() const RT_OVERRIDE { return m_strText; }
+    /** Defines item @a strText. */
+    virtual void setText(const QString &strText) { m_strText = strText; }
+
+    /** Returns the number of children. */
+    virtual int childCount() const RT_OVERRIDE { return m_children.size(); }
+    /** Returns the child item with @a iIndex. */
+    virtual UISelectorTreeViewItem *childItem(int iIndex) const RT_OVERRIDE { return m_children.at(iIndex); }
+
+    /** Adds @a pChild to this item. */
+    void addChild(UISelectorTreeViewItem *pChild) { m_children << pChild; }
+    /** Assigns @a children for this item. */
+    void setChildren(const QList<UISelectorTreeViewItem*> &children) { m_children = children; }
+    /** Returns position for the passed @a pChild. */
+    int posOfChild(UISelectorTreeViewItem *pChild) const { return m_children.indexOf(pChild); }
+
+    /** Searches for the child with @a iID specified. */
+    UISelectorTreeViewItem *childItemById(int iID) const;
+    /** Searches for the child with @a strLink specified. */
+    UISelectorTreeViewItem *childItemByLink(const QString &strLink) const;
+
+private:
+
+    /** Holds the item ID. */
+    int      m_iID;
+    /** Holds the item icon. */
+    QIcon    m_icon;
+    /** Holds the item link. */
+    QString  m_strLink;
+    /** Holds the item text. */
+    QString  m_strText;
+
+    /** Holds the list of children. */
+    QList<UISelectorTreeViewItem*>  m_children;
+};
+
+
+/** QItemDelegate subclass used as selector tree-view item delegate. */
+class UISelectorDelegate : public QItemDelegate
+{
+    Q_OBJECT;
+
+public:
+
+    /** Constructs selector item delegate passing @a pParent to the base-class. */
+    UISelectorDelegate(QObject *pParent);
+
+private:
+
+    /** Paints @a index item with specified @a option using specified @a pPainter. */
+    void paint(QPainter *pPainter, const QStyleOptionViewItem &option, const QModelIndex &index) const;
+};
+
+
+/** QAbstractItemModel subclass used as selector model. */
+class UISelectorModel : public QAbstractItemModel
+{
+    Q_OBJECT;
+
+public:
+
+    /** Data roles. */
+    enum DataRole
+    {
+        R_Margin = Qt::UserRole + 1,
+        R_Spacing,
+        R_IconSize,
+
+        R_ItemId,
+        R_ItemPixmap,
+        R_ItemPixmapRect,
+        R_ItemName,
+        R_ItemNamePoint,
+    };
+
+    /** Constructs selector model passing @a pParent to the base-class. */
+    UISelectorModel(QITreeView *pParent);
+    /** Destructs selector model. */
+    virtual ~UISelectorModel() RT_OVERRIDE;
+
+    /** Returns row count for the passed @a parentIndex. */
+    virtual int rowCount(const QModelIndex &parentIndex = QModelIndex()) const RT_OVERRIDE;
+    /** Returns column count for the passed @a parentIndex. */
+    virtual int columnCount(const QModelIndex &parentIndex = QModelIndex()) const RT_OVERRIDE;
+
+    /** Returns parent item of @a specifiedIndex item. */
+    virtual QModelIndex parent(const QModelIndex &specifiedIndex) const RT_OVERRIDE;
+    /** Returns item specified by @a iRow, @a iColum and @a parentIndex. */
+    virtual QModelIndex index(int iRow, int iColumn, const QModelIndex &parentIndex = QModelIndex()) const RT_OVERRIDE;
+    /** Returns root item. */
+    QModelIndex root() const;
+
+    /** Returns model data for @a specifiedIndex and @a iRole. */
+    virtual QVariant data(const QModelIndex &specifiedIndex, int iRole) const RT_OVERRIDE;
+    /** Defines model data for @a specifiedIndex and @a iRole as @a value. */
+    virtual bool setData(const QModelIndex &specifiedIndex, const QVariant &value, int iRole) RT_OVERRIDE;
+
+    /** Adds item with certain @a strId. */
+    QModelIndex addItem(int iID, const QIcon &icon, const QString &strLink);
+    /** Deletes item with certain @a iID. */
+    void delItem(int iID);
+
+    /** Returns item with certain @a iID. */
+    QModelIndex findItem(int iID);
+    /** Returns item with certain @a strLink. */
+    QModelIndex findItem(const QString &strLink);
+
+    /** Sorts the contents of model by @a iColumn and @a enmOrder. */
+    virtual void sort(int iColumn = 0, Qt::SortOrder enmOrder = Qt::AscendingOrder) RT_OVERRIDE;
+
+private:
+
+    /** Returns model flags for @a specifiedIndex. */
+    virtual Qt::ItemFlags flags(const QModelIndex &specifiedIndex) const RT_OVERRIDE;
+
+    /** Returns a pointer to item containing within @a specifiedIndex. */
+    static UISelectorTreeViewItem *indexToItem(const QModelIndex &specifiedIndex);
+
+    /** Holds the parent tree-view reference. */
+    QITreeView *m_pParentTree;
+
+    /** Holds the root item instance. */
+    UISelectorTreeViewItem *m_pRootItem;
+};
+
+
+/** QITreeView extension used as selector tree-view. */
+class UISelectorTreeView : public QITreeView
+{
+    Q_OBJECT;
+
+public:
+
+    /** Constructs selector tree-view passing @a pParent to the base-class. */
+    UISelectorTreeView(QWidget *pParent);
+
+    /** Calculates widget minimum size-hint. */
+    virtual QSize minimumSizeHint() const RT_OVERRIDE;
+    /** Calculates widget size-hint. */
+    virtual QSize sizeHint() const RT_OVERRIDE;
+
+private:
+
+    /** Prepares all. */
+    void prepare();
 };
 
@@ -207 +388 @@
 
 /*********************************************************************************************************************************
+*   Class UISelectorTreeViewItem implementation.                                                                                 *
+*********************************************************************************************************************************/
+
+UISelectorTreeViewItem::UISelectorTreeViewItem(QITreeView *pParent)
+    : QITreeViewItem(pParent)
+{
+}
+
+UISelectorTreeViewItem::UISelectorTreeViewItem(UISelectorTreeViewItem *pParentItem,
+                                               int iID,
+                                               const QIcon &icon,
+                                               const QString &strLink)
+    : QITreeViewItem(pParentItem)
+    , m_iID(iID)
+    , m_icon(icon)
+    , m_strLink(strLink)
+{
+    if (pParentItem)
+        pParentItem->addChild(this);
+}
+
+UISelectorTreeViewItem *UISelectorTreeViewItem::childItemById(int iID) const
+{
+    for (int i = 0; i < childCount(); ++i)
+        if (UISelectorTreeViewItem *pItem = childItem(i))
+            if (pItem->id() == iID)
+                return pItem;
+    return 0;
+}
+
+UISelectorTreeViewItem *UISelectorTreeViewItem::childItemByLink(const QString &strLink) const
+{
+    for (int i = 0; i < childCount(); ++i)
+        if (UISelectorTreeViewItem *pItem = childItem(i))
+            if (pItem->link() == strLink)
+                return pItem;
+    return 0;
+}
+
+
+/*********************************************************************************************************************************
+*   Class UISelectorDelegate implementation.                                                                                     *
+*********************************************************************************************************************************/
+
+UISelectorDelegate::UISelectorDelegate(QObject *pParent)
+    : QItemDelegate(pParent)
+{
+}
+
+void UISelectorDelegate::paint(QPainter *pPainter, const QStyleOptionViewItem &option, const QModelIndex &index) const
+{
+    /* Sanity checks: */
+    AssertPtrReturnVoid(pPainter);
+    AssertReturnVoid(index.isValid());
+
+    /* Acquire model: */
+    const UISelectorModel *pModel = qobject_cast<const UISelectorModel*>(index.model());
+
+    /* Acquire item properties: */
+    const QPalette palette = QGuiApplication::palette();
+    const QRect itemRectangle = option.rect;
+    const QStyle::State enmState = option.state;
+    const bool fChosen = enmState & QStyle::State_Selected;
+
+    /* Draw background: */
+    QColor backColor;
+    if (fChosen)
+    {
+        /* Prepare painter path: */
+        QPainterPath painterPath;
+        painterPath.lineTo(itemRectangle.width() - itemRectangle.height(), 0);
+        painterPath.lineTo(itemRectangle.width(),                          itemRectangle.height());
+        painterPath.lineTo(0,                                              itemRectangle.height());
+        painterPath.closeSubpath();
+        painterPath.translate(itemRectangle.topLeft());
+
+        /* Prepare painting gradient: */
+        backColor = palette.color(QPalette::Active, QPalette::Highlight);
+        const QColor bcTone1 = backColor.lighter(100);
+        const QColor bcTone2 = backColor.lighter(120);
+        QLinearGradient grad(itemRectangle.topLeft(), itemRectangle.bottomRight());
+        grad.setColorAt(0, bcTone1);
+        grad.setColorAt(1, bcTone2);
+
+        /* Paint fancy shape: */
+        pPainter->save();
+        pPainter->setClipPath(painterPath);
+        pPainter->setPen(backColor);
+        pPainter->fillRect(itemRectangle, grad);
+        pPainter->restore();
+    }
+    else
+    {
+        /* Just init painting color: */
+        backColor = palette.color(QPalette::Active, QPalette::Window);
+    }
+
+    /* Draw icon: */
+    const QRect itemPixmapRect = pModel->data(index, UISelectorModel::R_ItemPixmapRect).toRect();
+    const QPixmap itemPixmap = pModel->data(index, UISelectorModel::R_ItemPixmap).value<QPixmap>();
+    pPainter->save();
+    pPainter->translate(itemRectangle.topLeft());
+    pPainter->drawPixmap(itemPixmapRect, itemPixmap);
+    pPainter->restore();
+
+    /* Draw name: */
+    const QColor foreground = suitableForegroundColor(palette, backColor);
+    const QFont font = pModel->data(index, Qt::FontRole).value<QFont>();
+    const QPoint namePoint = pModel->data(index, UISelectorModel::R_ItemNamePoint).toPoint();
+    const QString strName = pModel->data(index, UISelectorModel::R_ItemName).toString();
+    pPainter->save();
+    pPainter->translate(itemRectangle.topLeft());
+    pPainter->setPen(foreground);
+    pPainter->setFont(font);
+    pPainter->drawText(namePoint, strName);
+    pPainter->restore();
+}
+
+
+/*********************************************************************************************************************************
+*   Class UISelectorModel implementation.                                                                                        *
+*********************************************************************************************************************************/
+
+UISelectorModel::UISelectorModel(QITreeView *pParentTree)
+    : QAbstractItemModel(pParentTree)
+    , m_pParentTree(pParentTree)
+    , m_pRootItem(new UISelectorTreeViewItem(pParentTree))
+{
+}
+
+UISelectorModel::~UISelectorModel()
+{
+    delete m_pRootItem;
+}
+
+int UISelectorModel::rowCount(const QModelIndex &parentIndex) const
+{
+    UISelectorTreeViewItem *pParentItem = indexToItem(parentIndex);
+    return pParentItem ? pParentItem->childCount() : 1 /* root item */;
+}
+
+int UISelectorModel::columnCount(const QModelIndex & /* parentIndex */) const
+{
+    return 1;
+}
+
+QModelIndex UISelectorModel::parent(const QModelIndex &specifiedIndex) const
+{
+    if (!specifiedIndex.isValid())
+        return QModelIndex();
+
+    UISelectorTreeViewItem *pItem = indexToItem(specifiedIndex);
+    UISelectorTreeViewItem *pParentOfItem =
+        pItem ? qobject_cast<UISelectorTreeViewItem*>(pItem->parentItem()) : 0;
+    UISelectorTreeViewItem *pParentOfParent =
+        pParentOfItem ? qobject_cast<UISelectorTreeViewItem*>(pParentOfItem->parentItem()) : 0;
+    const int iParentPosition = pParentOfParent ? pParentOfParent->posOfChild(pParentOfItem) : 0;
+
+    return pParentOfItem ? createIndex(iParentPosition, 0, pParentOfItem) : QModelIndex();
+}
+
+QModelIndex UISelectorModel::index(int iRow, int iColumn, const QModelIndex &parentIndex) const
+{
+    if (!hasIndex(iRow, iColumn, parentIndex))
+        return QModelIndex();
+
+    UISelectorTreeViewItem *pItem = !parentIndex.isValid()
+                                  ? m_pRootItem
+                                  : indexToItem(parentIndex)->childItem(iRow);
+
+    return pItem ? createIndex(iRow, iColumn, pItem) : QModelIndex();
+}
+
+QModelIndex UISelectorModel::root() const
+{
+    return index(0, 0);
+}
+
+QVariant UISelectorModel::data(const QModelIndex &specifiedIndex, int iRole) const
+{
+    if (!specifiedIndex.isValid())
+        return QVariant();
+
+    switch (iRole)
+    {
+        /* Basic Attributes: */
+        case Qt::FontRole:
+        {
+            QFont font = m_pParentTree->font();
+            font.setBold(true);
+            return font;
+        }
+        case Qt::SizeHintRole:
+        {
+            const QFontMetrics fm(data(specifiedIndex, Qt::FontRole).value<QFont>());
+            const int iMargin = data(specifiedIndex, R_Margin).toInt();
+            const int iSpacing = data(specifiedIndex, R_Spacing).toInt();
+            const int iIconSize = data(specifiedIndex, R_IconSize).toInt();
+            const QString strName = data(specifiedIndex, R_ItemName).toString();
+            const int iMinimumContentWidth = iIconSize /* icon width */
+                                           + iSpacing
+                                           + fm.horizontalAdvance(strName) /* name width */;
+            const int iMinimumContentHeight = qMax(fm.height() /* font height */,
+                                                   iIconSize /* icon height */);
+            const int iMinimumWidth = iMinimumContentWidth + iMargin * 2;
+            const int iMinimumHeight = iMinimumContentHeight + iMargin * 2;
+            return QSize(iMinimumWidth, iMinimumHeight);
+        }
+
+        /* Advanced Attributes: */
+        case R_Margin:
+        {
+            return QApplication::style()->pixelMetric(QStyle::PM_LayoutLeftMargin) / 1.5;
+        }
+        case R_Spacing:
+        {
+            return QApplication::style()->pixelMetric(QStyle::PM_LayoutHorizontalSpacing) * 2;
+        }
+        case R_IconSize:
+        {
+            return QApplication::style()->pixelMetric(QStyle::PM_SmallIconSize) * 1.5;
+        }
+        case R_ItemId:
+        {
+            if (UISelectorTreeViewItem *pItem = indexToItem(specifiedIndex))
+                return pItem->id();
+            return QUuid();
+        }
+        case R_ItemPixmap:
+        {
+            if (UISelectorTreeViewItem *pItem = indexToItem(specifiedIndex))
+            {
+                const QIcon icon = pItem->icon();
+                const int iIconSize = data(specifiedIndex, R_IconSize).toInt();
+                return icon.pixmap(m_pParentTree->windowHandle(), QSize(iIconSize, iIconSize));
+            }
+            return QPixmap();
+        }
+        case R_ItemPixmapRect:
+        {
+            const int iMargin = data(specifiedIndex, R_Margin).toInt();
+            const int iWidth = data(specifiedIndex, R_IconSize).toInt();
+            return QRect(iMargin, iMargin, iWidth, iWidth);
+        }
+        case R_ItemName:
+        {
+            if (UISelectorTreeViewItem *pItem = indexToItem(specifiedIndex))
+                return pItem->text();
+            return QString();
+        }
+        case R_ItemNamePoint:
+        {
+            const int iMargin = data(specifiedIndex, R_Margin).toInt();
+            const int iSpacing = data(specifiedIndex, R_Spacing).toInt();
+            const int iIconSize = data(specifiedIndex, R_IconSize).toInt();
+            const QFontMetrics fm(data(specifiedIndex, Qt::FontRole).value<QFont>());
+            const QSize sizeHint = data(specifiedIndex, Qt::SizeHintRole).toSize();
+            return QPoint(iMargin + iIconSize + iSpacing,
+                          sizeHint.height() / 2 + fm.ascent() / 2 - 1 /* base line */);
+        }
+
+        default:
+            break;
+    }
+
+    return QVariant();
+}
+
+bool UISelectorModel::setData(const QModelIndex &specifiedIndex, const QVariant &aValue, int iRole)
+{
+    if (!specifiedIndex.isValid())
+        return QAbstractItemModel::setData(specifiedIndex, aValue, iRole);
+
+    switch (iRole)
+    {
+        /* Advanced Attributes: */
+        case R_ItemName:
+        {
+            if (UISelectorTreeViewItem *pItem = indexToItem(specifiedIndex))
+            {
+                pItem->setText(aValue.toString());
+                emit dataChanged(specifiedIndex, specifiedIndex);
+                return true;
+            }
+            return false;
+        }
+
+        default:
+            break;
+    }
+
+    return false;
+}
+
+QModelIndex UISelectorModel::addItem(int iID, const QIcon &icon, const QString &strLink)
+{
+    beginInsertRows(root(), m_pRootItem->childCount(), m_pRootItem->childCount());
+    new UISelectorTreeViewItem(m_pRootItem, iID, icon, strLink);
+    endInsertRows();
+    return index(m_pRootItem->childCount() - 1, 0, root());
+}
+
+void UISelectorModel::delItem(int iID)
+{
+    if (UISelectorTreeViewItem *pItem = m_pRootItem->childItemById(iID))
+    {
+        const int iItemPosition = m_pRootItem->posOfChild(pItem);
+        beginRemoveRows(root(), iItemPosition, iItemPosition);
+        delete pItem;
+        endRemoveRows();
+    }
+}
+
+QModelIndex UISelectorModel::findItem(int iID)
+{
+    UISelectorTreeViewItem *pItem = m_pRootItem->childItemById(iID);
+    if (!pItem)
+        return QModelIndex();
+
+    const int iItemPosition = m_pRootItem->posOfChild(pItem);
+    return pItem ? createIndex(iItemPosition, 0, pItem) : QModelIndex();
+}
+
+QModelIndex UISelectorModel::findItem(const QString &strLink)
+{
+    UISelectorTreeViewItem *pItem = m_pRootItem->childItemByLink(strLink);
+    if (!pItem)
+        return QModelIndex();
+
+    const int iItemPosition = m_pRootItem->posOfChild(pItem);
+    return pItem ? createIndex(iItemPosition, 0, pItem) : QModelIndex();
+}
+
+void UISelectorModel::sort(int /* iColumn */, Qt::SortOrder enmOrder)
+{
+    /* Prepare empty list for sorted items: */
+    QList<UISelectorTreeViewItem*> sortedItems;
+
+    /* For each of items: */
+    const int iItemCount = m_pRootItem->childCount();
+    for (int iItemPos = 0; iItemPos < iItemCount; ++iItemPos)
+    {
+        /* Get iterated item/id: */
+        UISelectorTreeViewItem *pItem = m_pRootItem->childItem(iItemPos);
+        const int iID = pItem->id();
+
+        /* Gather suitable position in the list of sorted items: */
+        int iInsertPosition = 0;
+        for (; iInsertPosition < sortedItems.size(); ++iInsertPosition)
+        {
+            /* Get sorted item/id: */
+            UISelectorTreeViewItem *pSortedItem = sortedItems.at(iInsertPosition);
+            const int iSortedID = pSortedItem->id();
+
+            /* Apply sorting rule: */
+            if (   ((enmOrder == Qt::AscendingOrder) && (iID < iSortedID))
+                || ((enmOrder == Qt::DescendingOrder) && (iID > iSortedID)))
+                break;
+        }
+
+        /* Insert iterated item into sorted position: */
+        sortedItems.insert(iInsertPosition, pItem);
+    }
+
+    /* Update corresponding model-indexes: */
+    m_pRootItem->setChildren(sortedItems);
+    beginMoveRows(root(), 0, iItemCount - 1, root(), 0);
+    endMoveRows();
+}
+
+Qt::ItemFlags UISelectorModel::flags(const QModelIndex &specifiedIndex) const
+{
+    return !specifiedIndex.isValid() ? QAbstractItemModel::flags(specifiedIndex)
+                                     : Qt::ItemIsEnabled | Qt::ItemIsSelectable;
+}
+
+/* static */
+UISelectorTreeViewItem *UISelectorModel::indexToItem(const QModelIndex &specifiedIndex)
+{
+    if (!specifiedIndex.isValid())
+        return 0;
+    return static_cast<UISelectorTreeViewItem*>(specifiedIndex.internalPointer());
+}
+
+
+/*********************************************************************************************************************************
+*   Class UISelectorTreeView implementation.                                                                                     *
+*********************************************************************************************************************************/
+
+UISelectorTreeView::UISelectorTreeView(QWidget *pParent)
+    : QITreeView(pParent)
+{
+    prepare();
+}
+
+QSize UISelectorTreeView::minimumSizeHint() const
+{
+    /* Sanity check: */
+    UISelectorModel *pModel = qobject_cast<UISelectorModel*>(model());
+    AssertPtrReturn(pModel, QITreeView::minimumSizeHint());
+
+    /* Calculate largest column width: */
+    int iMaximumColumnWidth = 0;
+    int iCumulativeColumnHeight = 0;
+    for (int i = 0; i < pModel->rowCount(pModel->root()); ++i)
+    {
+        const QModelIndex iteratedIndex = pModel->index(i, 0, pModel->root());
+        const QSize sizeHint = pModel->data(iteratedIndex, Qt::SizeHintRole).toSize();
+        const int iHeightHint = sizeHint.height();
+        iMaximumColumnWidth = qMax(iMaximumColumnWidth, sizeHint.width() + iHeightHint /* to get the fancy shape */);
+        iCumulativeColumnHeight += iHeightHint;
+    }
+
+    /* Return selector size-hint: */
+    return QSize(iMaximumColumnWidth, iCumulativeColumnHeight);
+}
+
+QSize UISelectorTreeView::sizeHint() const
+{
+    // WORKAROUND:
+    // By default QTreeView uses own size-hint
+    // which we don't like and want to ignore:
+    return minimumSizeHint();
+}
+
+void UISelectorTreeView::prepare()
+{
+    /* Configure tree-view: */
+    setFrameShape(QFrame::NoFrame);
+    viewport()->setAutoFillBackground(false);
+    setContextMenuPolicy(Qt::PreventContextMenu);
+    setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
+    setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
+    setSizePolicy(QSizePolicy::Minimum, QSizePolicy::MinimumExpanding);
+
+    /* Prepare selector delegate: */
+    UISelectorDelegate *pDelegate = new UISelectorDelegate(this);
+    if (pDelegate)
+        setItemDelegate(pDelegate);
+}
+
+
+/*********************************************************************************************************************************
 *   Class UISettingsSelector implementation.                                                                                     *
 *********************************************************************************************************************************/
@@ -286 +910 @@
         }
     return pResult;
+}
+
+
+/*********************************************************************************************************************************
+*   Class UISettingsSelectorTreeView implementation.                                                                             *
+*********************************************************************************************************************************/
+
+UISettingsSelectorTreeView::UISettingsSelectorTreeView(QWidget *pParent /* = 0 */)
+    : UISettingsSelector(pParent)
+    , m_pTreeView(0)
+    , m_pModel(0)
+{
+    prepare();
+}
+
+UISettingsSelectorTreeView::~UISettingsSelectorTreeView()
+{
+    cleanup();
+}
+
+QWidget *UISettingsSelectorTreeView::widget() const
+{
+    return m_pTreeView;
+}
+
+QWidget *UISettingsSelectorTreeView::addItem(const QString & /* strBigIcon */,
+                                             const QString &strMediumIcon ,
+                                             const QString & /* strSmallIcon */,
+                                             int iID,
+                                             const QString &strLink,
+                                             UISettingsPage *pPage /* = 0 */,
+                                             int iParentID /* = -1 */)
+{
+    QWidget *pResult = 0;
+    if (pPage)
+    {
+        /* Adjust page a bit: */
+        pPage->setContentsMargins(0, 0, 0, 0);
+        if (pPage->layout())
+            pPage->layout()->setContentsMargins(0, 0, 0, 0);
+        pResult = pPage;
+
+        /* Add selector-item object: */
+        const QIcon icon = UIIconPool::iconSet(strMediumIcon);
+        UISelectorItem *pItem = new UISelectorItem(icon, iID, strLink, pPage, iParentID);
+        if (pItem)
+            m_list.append(pItem);
+
+        /* Add model-item: */
+        m_pModel->addItem(iID, pItem->icon(), strLink);
+    }
+    return pResult;
+}
+
+void UISettingsSelectorTreeView::setItemText(int iID, const QString &strText)
+{
+    /* Call to base-class: */
+    UISettingsSelector::setItemText(iID, strText);
+
+    /* Look for the tree-view item to assign the text: */
+    QModelIndex specifiedIndex = m_pModel->findItem(iID);
+    if (specifiedIndex.isValid())
+        m_pModel->setData(specifiedIndex, strText, UISelectorModel::R_ItemName);
+}
+
+QString UISettingsSelectorTreeView::itemText(int iID) const
+{
+    QString strResult;
+    if (UISelectorItem *pItem = findItem(iID))
+        strResult = pItem->text();
+    return strResult;
+}
+
+int UISettingsSelectorTreeView::currentId() const
+{
+    int iID = -1;
+    const QModelIndex currentIndex = m_pTreeView->currentIndex();
+    if (currentIndex.isValid())
+        iID = m_pModel->data(currentIndex, UISelectorModel::R_ItemId).toString().toInt();
+    return iID;
+}
+
+int UISettingsSelectorTreeView::linkToId(const QString &strLink) const
+{
+    int iID = -1;
+    const QModelIndex specifiedIndex = m_pModel->findItem(strLink);
+    if (specifiedIndex.isValid())
+        iID = m_pModel->data(specifiedIndex, UISelectorModel::R_ItemId).toString().toInt();
+    return iID;
+}
+
+void UISettingsSelectorTreeView::selectById(int iID)
+{
+    const QModelIndex specifiedIndex = m_pModel->findItem(iID);
+    if (specifiedIndex.isValid())
+        m_pTreeView->setCurrentIndex(specifiedIndex);
+}
+
+void UISettingsSelectorTreeView::sltHandleCurrentChanged(const QModelIndex &currentIndex,
+                                                         const QModelIndex & /* previousIndex */)
+{
+    if (currentIndex.isValid())
+    {
+        const int iID = m_pModel->data(currentIndex, UISelectorModel::R_ItemId).toString().toInt();
+        Assert(iID >= 0);
+        emit sigCategoryChanged(iID);
+    }
+}
+
+void UISettingsSelectorTreeView::prepare()
+{
+    /* Prepare the tree-widget: */
+    m_pTreeView = new UISelectorTreeView(qobject_cast<QWidget*>(parent()));
+    if (m_pTreeView)
+    {
+        /* Prepare the model: */
+        m_pModel = new UISelectorModel(m_pTreeView);
+        if (m_pModel)
+        {
+            m_pTreeView->setModel(m_pModel);
+            m_pTreeView->setRootIndex(m_pModel->root());
+        }
+
+        /* Setup connections: */
+        connect(m_pTreeView, &QITreeView::currentItemChanged,
+                this, &UISettingsSelectorTreeView::sltHandleCurrentChanged);
+    }
+}
+
+void UISettingsSelectorTreeView::cleanup()
+{
+    /* Cleanup the model: */
+    delete m_pModel;
+    m_pModel = 0;
+    /* Cleanup the tree-view: */
+    delete m_pTreeView;
+    m_pTreeView = 0;
 }
 
@@ -731 +1492 @@
 
 }
+
+
+#include "UISettingsSelector.moc"

trunk/src/VBox/Frontends/VirtualBox/src/settings/UISettingsSelector.h

@@ -47 +47 @@
 class UISelectorActionItem;
 class UISelectorItem;
+class UISelectorModel;
+class UISelectorTreeView;
 class UISettingsPage;
 class QIToolBar;
@@ -129 +131 @@
 /** UISettingsSelector subclass providing settings dialog
   * with the means to switch between settings pages.
-  * This one represented as tree-widget. */
-class SHARED_LIBRARY_STUFF UISettingsSelectorTreeWidget : public UISettingsSelector
+  * This one represented as tree-view. */
+class SHARED_LIBRARY_STUFF UISettingsSelectorTreeView : public UISettingsSelector
 {
     Q_OBJECT;
@@ -137 +139 @@
 
     /** Constructs settings selector passing @a pParent to the base-class. */
-    UISettingsSelectorTreeWidget(QWidget *pParent = 0);
+    UISettingsSelectorTreeView(QWidget *pParent);
     /** Destructs settings selector. */
-    virtual ~UISettingsSelectorTreeWidget() RT_OVERRIDE;
+    virtual ~UISettingsSelectorTreeView() RT_OVERRIDE;
 
     /** Returns the widget selector operates on. */
@@ -169 +171 @@
     virtual void selectById(int iID) RT_OVERRIDE;
 
-    /** Performs selector polishing. */
-    virtual void polish() RT_OVERRIDE;
-
 private slots:
 
     /** Handles selector section change from @a pPrevItem to @a pItem. */
-    void sltSettingsGroupChanged(QTreeWidgetItem *pItem, QTreeWidgetItem *pPrevItem);
+    void sltHandleCurrentChanged(const QModelIndex &current, const QModelIndex &previous);
 
 private:
@@ -181 +180 @@
     /** Prepares all. */
     void prepare();
-
-    /** Returns page path for passed @a strMatch. */
-    QString pagePath(const QString &strMatch) const;
-    /** Find item within the passed @a pView and @a iColumn matching @a strMatch. */
-    QTreeWidgetItem *findItem(QTreeWidget *pView, const QString &strMatch, int iColumn) const;
-    /** Performs @a iID to QString serialization. */
-    QString idToString(int iID) const;
-
-    /** Forges the full path for passed @a pItem. */
-    static QString path(const QTreeWidgetItem *pItem);
-
-    /** Holds the tree-widget instance. */
-    QITreeWidget *m_pTreeWidget;
+    /** Cleanups all. */
+    void cleanup();
+
+    /** Holds the tree-view instance. */
+    UISelectorTreeView *m_pTreeView;
+    /** Holds the tree-view instance. */
+    UISelectorModel    *m_pModel;
 };
 
@@ -199 +192 @@
 /** UISettingsSelector subclass providing settings dialog
   * with the means to switch between settings pages.
-  * This one represented as tool-bar. */
-class SHARED_LIBRARY_STUFF UISettingsSelectorToolBar : public UISettingsSelector
+  * This one represented as tree-widget. */
+class SHARED_LIBRARY_STUFF UISettingsSelectorTreeWidget : public UISettingsSelector
 {
     Q_OBJECT;
@@ -207 +200 @@
 
     /** Constructs settings selector passing @a pParent to the base-class. */
-    UISettingsSelectorToolBar(QWidget *pParent = 0);
+    UISettingsSelectorTreeWidget(QWidget *pParent = 0);
     /** Destructs settings selector. */
-    virtual ~UISettingsSelectorToolBar() RT_OVERRIDE;
+    virtual ~UISettingsSelectorTreeWidget() RT_OVERRIDE;
 
     /** Returns the widget selector operates on. */
@@ -236 +229 @@
     virtual int linkToId(const QString &strLink) const RT_OVERRIDE;
 
+    /** Make the section with @a iID current. */
+    virtual void selectById(int iID) RT_OVERRIDE;
+
+    /** Performs selector polishing. */
+    virtual void polish() RT_OVERRIDE;
+
+private slots:
+
+    /** Handles selector section change from @a pPrevItem to @a pItem. */
+    void sltSettingsGroupChanged(QTreeWidgetItem *pItem, QTreeWidgetItem *pPrevItem);
+
+private:
+
+    /** Prepares all. */
+    void prepare();
+
+    /** Returns page path for passed @a strMatch. */
+    QString pagePath(const QString &strMatch) const;
+    /** Find item within the passed @a pView and @a iColumn matching @a strMatch. */
+    QTreeWidgetItem *findItem(QTreeWidget *pView, const QString &strMatch, int iColumn) const;
+    /** Performs @a iID to QString serialization. */
+    QString idToString(int iID) const;
+
+    /** Forges the full path for passed @a pItem. */
+    static QString path(const QTreeWidgetItem *pItem);
+
+    /** Holds the tree-widget instance. */
+    QITreeWidget *m_pTreeWidget;
+};
+
+
+/** UISettingsSelector subclass providing settings dialog
+  * with the means to switch between settings pages.
+  * This one represented as tool-bar. */
+class SHARED_LIBRARY_STUFF UISettingsSelectorToolBar : public UISettingsSelector
+{
+    Q_OBJECT;
+
+public:
+
+    /** Constructs settings selector passing @a pParent to the base-class. */
+    UISettingsSelectorToolBar(QWidget *pParent = 0);
+    /** Destructs settings selector. */
+    virtual ~UISettingsSelectorToolBar() RT_OVERRIDE;
+
+    /** Returns the widget selector operates on. */
+    virtual QWidget *widget() const RT_OVERRIDE;
+
+    /** Adds a new selector item.
+      * @param  strBigIcon     Brings the big icon reference.
+      * @param  strMediumIcon  Brings the medium icon reference.
+      * @param  strSmallIcon   Brings the small icon reference.
+      * @param  iID            Brings the selector section ID.
+      * @param  strLink        Brings the selector section link.
+      * @param  pPage          Brings the selector section page reference.
+      * @param  iParentID      Brings the parent section ID or -1 if there is no parent. */
+    virtual QWidget *addItem(const QString &strBigIcon, const QString &strMediumIcon, const QString &strSmallIcon,
+                             int iID, const QString &strLink, UISettingsPage *pPage = 0, int iParentID = -1) RT_OVERRIDE;
+
+    /** Defines the @a strText for section with @a iID. */
+    virtual void setItemText(int iID, const QString &strText) RT_OVERRIDE;
+    /** Returns the text for section with @a iID. */
+    virtual QString itemText(int iID) const RT_OVERRIDE;
+
+    /** Returns the current selector ID. */
+    virtual int currentId() const RT_OVERRIDE;
+
+    /** Returns the section ID for passed @a strLink. */
+    virtual int linkToId(const QString &strLink) const RT_OVERRIDE;
+
     /** Returns the section page for passed @a iID. */
     virtual QWidget *idToPage(int iID) const RT_OVERRIDE;