VirtualBox

Changeset 75636 in vbox


Ignore:
Timestamp:
Nov 21, 2018 10:45:27 AM (6 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
126814
Message:

FE/Qt: bugref:9289: Details pane context menu initial implementation.

Location:
trunk/src/VBox/Frontends/VirtualBox/src/manager/details
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Frontends/VirtualBox/src/manager/details/UIDetailsModel.cpp

    r75608 r75636  
    2525# include <QGraphicsSceneContextMenuEvent>
    2626# include <QGraphicsView>
     27# include <QHBoxLayout>
     28# include <QListWidget>
    2729# include <QMenu>
    2830# include <QMetaEnum>
    … …  
    3537# include "UIDetailsElement.h"
    3638# include "UIExtraDataManager.h"
     39# include "UIIconPool.h"
    3740# include "VBoxGlobal.h"
    3841
    3942#endif /* !VBOX_WITH_PRECOMPILED_HEADERS */
     43
     44
     45/*********************************************************************************************************************************
     46*   Class UIDetailsContextMenu implementation.                                                                                   *
     47*********************************************************************************************************************************/
     48
     49UIDetailsContextMenu::UIDetailsContextMenu(UIDetailsModel *pModel)
     50    : QIWithRetranslateUI2<QWidget>(0, Qt::Popup)
     51    , m_pModel(pModel)
     52    , m_pListWidgetCategories(0)
     53    , m_pListWidgetOptions(0)
     54{
     55    prepare();
     56}
     57
     58void UIDetailsContextMenu::updateCategoryStates()
     59{
     60    /* Enumerate all the category items: */
     61    for (int i = 0; i < m_pListWidgetCategories->count(); ++i)
     62    {
     63        QListWidgetItem *pCategoryItem = m_pListWidgetCategories->item(i);
     64        if (pCategoryItem)
     65        {
     66            /* Apply check-state on per-enum basis: */
     67            const DetailsElementType enmCategoryType = pCategoryItem->data(DataField_Type).value<DetailsElementType>();
     68            pCategoryItem->setCheckState(m_pModel->categories().contains(enmCategoryType) ? Qt::Checked : Qt::Unchecked);
     69        }
     70    }
     71}
     72
     73void UIDetailsContextMenu::updateOptionStates(DetailsElementType enmRequiredCategoryType /* = DetailsElementType_Invalid */)
     74{
     75    /* First make sure we really have category item selected: */
     76    QListWidgetItem *pCategoryItem = m_pListWidgetCategories->currentItem();
     77    if (!pCategoryItem)
     78        return;
     79
     80    /* Then acquire category type and check if it is suitable: */
     81    const DetailsElementType enmCategoryType = pCategoryItem->data(DataField_Type).value<DetailsElementType>();
     82    if (enmRequiredCategoryType == DetailsElementType_Invalid)
     83        enmRequiredCategoryType = enmCategoryType;
     84    if (enmCategoryType != enmRequiredCategoryType)
     85        return;
     86
     87    /* Handle known category types: */
     88    switch (enmRequiredCategoryType)
     89    {
     90        case DetailsElementType_General:
     91        {
     92            /* Enumerate all the option items: */
     93            for (int i = 0; i < m_pListWidgetOptions->count(); ++i)
     94            {
     95                QListWidgetItem *pOptionItem = m_pListWidgetOptions->item(i);
     96                if (pOptionItem)
     97                {
     98                    /* Apply check-state on per-enum basis: */
     99                    const UIExtraDataMetaDefs::DetailsElementOptionTypeGeneral enmOptionType =
     100                        pOptionItem->data(DataField_Type).value<UIExtraDataMetaDefs::DetailsElementOptionTypeGeneral>();
     101                    pOptionItem->setCheckState(m_pModel->optionsGeneral() & enmOptionType ? Qt::Checked : Qt::Unchecked);
     102                }
     103            }
     104            break;
     105        }
     106        case DetailsElementType_System:
     107        {
     108            /* Enumerate all the option items: */
     109            for (int i = 0; i < m_pListWidgetOptions->count(); ++i)
     110            {
     111                QListWidgetItem *pOptionItem = m_pListWidgetOptions->item(i);
     112                if (pOptionItem)
     113                {
     114                    /* Apply check-state on per-enum basis: */
     115                    const UIExtraDataMetaDefs::DetailsElementOptionTypeSystem enmOptionType =
     116                        pOptionItem->data(DataField_Type).value<UIExtraDataMetaDefs::DetailsElementOptionTypeSystem>();
     117                    pOptionItem->setCheckState(m_pModel->optionsSystem() & enmOptionType ? Qt::Checked : Qt::Unchecked);
     118                }
     119            }
     120            break;
     121        }
     122        case DetailsElementType_Display:
     123        {
     124            /* Enumerate all the option items: */
     125            for (int i = 0; i < m_pListWidgetOptions->count(); ++i)
     126            {
     127                QListWidgetItem *pOptionItem = m_pListWidgetOptions->item(i);
     128                if (pOptionItem)
     129                {
     130                    /* Apply check-state on per-enum basis: */
     131                    const UIExtraDataMetaDefs::DetailsElementOptionTypeDisplay enmOptionType =
     132                        pOptionItem->data(DataField_Type).value<UIExtraDataMetaDefs::DetailsElementOptionTypeDisplay>();
     133                    pOptionItem->setCheckState(m_pModel->optionsDisplay() & enmOptionType ? Qt::Checked : Qt::Unchecked);
     134                }
     135            }
     136            break;
     137        }
     138        case DetailsElementType_Storage:
     139        {
     140            /* Enumerate all the option items: */
     141            for (int i = 0; i < m_pListWidgetOptions->count(); ++i)
     142            {
     143                QListWidgetItem *pOptionItem = m_pListWidgetOptions->item(i);
     144                if (pOptionItem)
     145                {
     146                    /* Apply check-state on per-enum basis: */
     147                    const UIExtraDataMetaDefs::DetailsElementOptionTypeStorage enmOptionType =
     148                        pOptionItem->data(DataField_Type).value<UIExtraDataMetaDefs::DetailsElementOptionTypeStorage>();
     149                    pOptionItem->setCheckState(m_pModel->optionsStorage() & enmOptionType ? Qt::Checked : Qt::Unchecked);
     150                }
     151            }
     152            break;
     153        }
     154        case DetailsElementType_Audio:
     155        {
     156            /* Enumerate all the option items: */
     157            for (int i = 0; i < m_pListWidgetOptions->count(); ++i)
     158            {
     159                QListWidgetItem *pOptionItem = m_pListWidgetOptions->item(i);
     160                if (pOptionItem)
     161                {
     162                    /* Apply check-state on per-enum basis: */
     163                    const UIExtraDataMetaDefs::DetailsElementOptionTypeAudio enmOptionType =
     164                        pOptionItem->data(DataField_Type).value<UIExtraDataMetaDefs::DetailsElementOptionTypeAudio>();
     165                    pOptionItem->setCheckState(m_pModel->optionsAudio() & enmOptionType ? Qt::Checked : Qt::Unchecked);
     166                }
     167            }
     168            break;
     169        }
     170        case DetailsElementType_Network:
     171        {
     172            /* Enumerate all the option items: */
     173            for (int i = 0; i < m_pListWidgetOptions->count(); ++i)
     174            {
     175                QListWidgetItem *pOptionItem = m_pListWidgetOptions->item(i);
     176                if (pOptionItem)
     177                {
     178                    /* Apply check-state on per-enum basis: */
     179                    const UIExtraDataMetaDefs::DetailsElementOptionTypeNetwork enmOptionType =
     180                        pOptionItem->data(DataField_Type).value<UIExtraDataMetaDefs::DetailsElementOptionTypeNetwork>();
     181                    pOptionItem->setCheckState(m_pModel->optionsNetwork() & enmOptionType ? Qt::Checked : Qt::Unchecked);
     182                }
     183            }
     184            break;
     185        }
     186        case DetailsElementType_Serial:
     187        {
     188            /* Enumerate all the option items: */
     189            for (int i = 0; i < m_pListWidgetOptions->count(); ++i)
     190            {
     191                QListWidgetItem *pOptionItem = m_pListWidgetOptions->item(i);
     192                if (pOptionItem)
     193                {
     194                    /* Apply check-state on per-enum basis: */
     195                    const UIExtraDataMetaDefs::DetailsElementOptionTypeSerial enmOptionType =
     196                        pOptionItem->data(DataField_Type).value<UIExtraDataMetaDefs::DetailsElementOptionTypeSerial>();
     197                    pOptionItem->setCheckState(m_pModel->optionsSerial() & enmOptionType ? Qt::Checked : Qt::Unchecked);
     198                }
     199            }
     200            break;
     201        }
     202        case DetailsElementType_USB:
     203        {
     204            /* Enumerate all the option items: */
     205            for (int i = 0; i < m_pListWidgetOptions->count(); ++i)
     206            {
     207                QListWidgetItem *pOptionItem = m_pListWidgetOptions->item(i);
     208                if (pOptionItem)
     209                {
     210                    /* Apply check-state on per-enum basis: */
     211                    const UIExtraDataMetaDefs::DetailsElementOptionTypeUsb enmOptionType =
     212                        pOptionItem->data(DataField_Type).value<UIExtraDataMetaDefs::DetailsElementOptionTypeUsb>();
     213                    pOptionItem->setCheckState(m_pModel->optionsUsb() & enmOptionType ? Qt::Checked : Qt::Unchecked);
     214                }
     215            }
     216            break;
     217        }
     218        case DetailsElementType_SF:
     219        {
     220            /* Enumerate all the option items: */
     221            for (int i = 0; i < m_pListWidgetOptions->count(); ++i)
     222            {
     223                QListWidgetItem *pOptionItem = m_pListWidgetOptions->item(i);
     224                if (pOptionItem)
     225                {
     226                    /* Apply check-state on per-enum basis: */
     227                    const UIExtraDataMetaDefs::DetailsElementOptionTypeSharedFolders enmOptionType =
     228                        pOptionItem->data(DataField_Type).value<UIExtraDataMetaDefs::DetailsElementOptionTypeSharedFolders>();
     229                    pOptionItem->setCheckState(m_pModel->optionsSharedFolders() & enmOptionType ? Qt::Checked : Qt::Unchecked);
     230                }
     231            }
     232            break;
     233        }
     234        case DetailsElementType_UI:
     235        {
     236            /* Enumerate all the option items: */
     237            for (int i = 0; i < m_pListWidgetOptions->count(); ++i)
     238            {
     239                QListWidgetItem *pOptionItem = m_pListWidgetOptions->item(i);
     240                if (pOptionItem)
     241                {
     242                    /* Apply check-state on per-enum basis: */
     243                    const UIExtraDataMetaDefs::DetailsElementOptionTypeUserInterface enmOptionType =
     244                        pOptionItem->data(DataField_Type).value<UIExtraDataMetaDefs::DetailsElementOptionTypeUserInterface>();
     245                    pOptionItem->setCheckState(m_pModel->optionsUserInterface() & enmOptionType ? Qt::Checked : Qt::Unchecked);
     246                }
     247            }
     248            break;
     249        }
     250        case DetailsElementType_Description:
     251        {
     252            /* Enumerate all the option items: */
     253            for (int i = 0; i < m_pListWidgetOptions->count(); ++i)
     254            {
     255                QListWidgetItem *pOptionItem = m_pListWidgetOptions->item(i);
     256                if (pOptionItem)
     257                {
     258                    /* Apply check-state on per-enum basis: */
     259                    const UIExtraDataMetaDefs::DetailsElementOptionTypeDescription enmOptionType =
     260                        pOptionItem->data(DataField_Type).value<UIExtraDataMetaDefs::DetailsElementOptionTypeDescription>();
     261                    pOptionItem->setCheckState(m_pModel->optionsDescription() & enmOptionType ? Qt::Checked : Qt::Unchecked);
     262                }
     263            }
     264            break;
     265        }
     266        default:
     267            break;
     268    }
     269}
     270
     271void UIDetailsContextMenu::retranslateUi()
     272{
     273    retranslateCategories();
     274    retranslateOptions();
     275    adjustListWidgets();
     276}
     277
     278void UIDetailsContextMenu::retranslateCategories()
     279{
     280    /* Enumerate all the category items: */
     281    for (int i = 0; i < m_pListWidgetCategories->count(); ++i)
     282    {
     283        QListWidgetItem *pCategoryItem = m_pListWidgetCategories->item(i);
     284        if (pCategoryItem)
     285        {
     286            /* We can translate this thing on per-enum basis: */
     287            const DetailsElementType enmCategoryType = pCategoryItem->data(DataField_Type).value<DetailsElementType>();
     288            pCategoryItem->setText(gpConverter->toString(enmCategoryType));
     289        }
     290    }
     291}
     292
     293void UIDetailsContextMenu::retranslateOptions()
     294{
     295    /* Acquire currently selected category item: */
     296    QListWidgetItem *pCategoryItem = m_pListWidgetCategories->currentItem();
     297    if (!pCategoryItem)
     298        return;
     299
     300    /* Populate currently selected category options: */
     301    const DetailsElementType enmCategoryType = pCategoryItem->data(DataField_Type).value<DetailsElementType>();
     302    switch (enmCategoryType)
     303    {
     304        case DetailsElementType_General:
     305        {
     306            /* Enumerate all the option items: */
     307            for (int i = 0; i < m_pListWidgetOptions->count(); ++i)
     308            {
     309                QListWidgetItem *pOptionItem = m_pListWidgetOptions->item(i);
     310                if (pOptionItem)
     311                {
     312                    /* We can translate this thing on per-enum basis: */
     313                    const UIExtraDataMetaDefs::DetailsElementOptionTypeGeneral enmOptionType =
     314                        pOptionItem->data(DataField_Type).value<UIExtraDataMetaDefs::DetailsElementOptionTypeGeneral>();
     315                    pOptionItem->setText(gpConverter->toString(enmOptionType));
     316                }
     317            }
     318            break;
     319        }
     320        case DetailsElementType_System:
     321        {
     322            /* Enumerate all the option items: */
     323            for (int i = 0; i < m_pListWidgetOptions->count(); ++i)
     324            {
     325                QListWidgetItem *pOptionItem = m_pListWidgetOptions->item(i);
     326                if (pOptionItem)
     327                {
     328                    /* We can translate this thing on per-enum basis: */
     329                    const UIExtraDataMetaDefs::DetailsElementOptionTypeSystem enmOptionType =
     330                        pOptionItem->data(DataField_Type).value<UIExtraDataMetaDefs::DetailsElementOptionTypeSystem>();
     331                    pOptionItem->setText(gpConverter->toString(enmOptionType));
     332                }
     333            }
     334            break;
     335        }
     336        case DetailsElementType_Display:
     337        {
     338            /* Enumerate all the option items: */
     339            for (int i = 0; i < m_pListWidgetOptions->count(); ++i)
     340            {
     341                QListWidgetItem *pOptionItem = m_pListWidgetOptions->item(i);
     342                if (pOptionItem)
     343                {
     344                    /* We can translate this thing on per-enum basis: */
     345                    const UIExtraDataMetaDefs::DetailsElementOptionTypeDisplay enmOptionType =
     346                        pOptionItem->data(DataField_Type).value<UIExtraDataMetaDefs::DetailsElementOptionTypeDisplay>();
     347                    pOptionItem->setText(gpConverter->toString(enmOptionType));
     348                }
     349            }
     350            break;
     351        }
     352        case DetailsElementType_Storage:
     353        {
     354            /* Enumerate all the option items: */
     355            for (int i = 0; i < m_pListWidgetOptions->count(); ++i)
     356            {
     357                QListWidgetItem *pOptionItem = m_pListWidgetOptions->item(i);
     358                if (pOptionItem)
     359                {
     360                    /* We can translate this thing on per-enum basis: */
     361                    const UIExtraDataMetaDefs::DetailsElementOptionTypeStorage enmOptionType =
     362                        pOptionItem->data(DataField_Type).value<UIExtraDataMetaDefs::DetailsElementOptionTypeStorage>();
     363                    pOptionItem->setText(gpConverter->toString(enmOptionType));
     364                }
     365            }
     366            break;
     367        }
     368        case DetailsElementType_Audio:
     369        {
     370            /* Enumerate all the option items: */
     371            for (int i = 0; i < m_pListWidgetOptions->count(); ++i)
     372            {
     373                QListWidgetItem *pOptionItem = m_pListWidgetOptions->item(i);
     374                if (pOptionItem)
     375                {
     376                    /* We can translate this thing on per-enum basis: */
     377                    const UIExtraDataMetaDefs::DetailsElementOptionTypeAudio enmOptionType =
     378                        pOptionItem->data(DataField_Type).value<UIExtraDataMetaDefs::DetailsElementOptionTypeAudio>();
     379                    pOptionItem->setText(gpConverter->toString(enmOptionType));
     380                }
     381            }
     382            break;
     383        }
     384        case DetailsElementType_Network:
     385        {
     386            /* Enumerate all the option items: */
     387            for (int i = 0; i < m_pListWidgetOptions->count(); ++i)
     388            {
     389                QListWidgetItem *pOptionItem = m_pListWidgetOptions->item(i);
     390                if (pOptionItem)
     391                {
     392                    /* We can translate this thing on per-enum basis: */
     393                    const UIExtraDataMetaDefs::DetailsElementOptionTypeNetwork enmOptionType =
     394                        pOptionItem->data(DataField_Type).value<UIExtraDataMetaDefs::DetailsElementOptionTypeNetwork>();
     395                    pOptionItem->setText(gpConverter->toString(enmOptionType));
     396                }
     397            }
     398            break;
     399        }
     400        case DetailsElementType_Serial:
     401        {
     402            /* Enumerate all the option items: */
     403            for (int i = 0; i < m_pListWidgetOptions->count(); ++i)
     404            {
     405                QListWidgetItem *pOptionItem = m_pListWidgetOptions->item(i);
     406                if (pOptionItem)
     407                {
     408                    /* We can translate this thing on per-enum basis: */
     409                    const UIExtraDataMetaDefs::DetailsElementOptionTypeSerial enmOptionType =
     410                        pOptionItem->data(DataField_Type).value<UIExtraDataMetaDefs::DetailsElementOptionTypeSerial>();
     411                    pOptionItem->setText(gpConverter->toString(enmOptionType));
     412                }
     413            }
     414            break;
     415        }
     416        case DetailsElementType_USB:
     417        {
     418            /* Enumerate all the option items: */
     419            for (int i = 0; i < m_pListWidgetOptions->count(); ++i)
     420            {
     421                QListWidgetItem *pOptionItem = m_pListWidgetOptions->item(i);
     422                if (pOptionItem)
     423                {
     424                    /* We can translate this thing on per-enum basis: */
     425                    const UIExtraDataMetaDefs::DetailsElementOptionTypeUsb enmOptionType =
     426                        pOptionItem->data(DataField_Type).value<UIExtraDataMetaDefs::DetailsElementOptionTypeUsb>();
     427                    pOptionItem->setText(gpConverter->toString(enmOptionType));
     428                }
     429            }
     430            break;
     431        }
     432        case DetailsElementType_SF:
     433        {
     434            /* Enumerate all the option items: */
     435            for (int i = 0; i < m_pListWidgetOptions->count(); ++i)
     436            {
     437                QListWidgetItem *pOptionItem = m_pListWidgetOptions->item(i);
     438                if (pOptionItem)
     439                {
     440                    /* We can translate this thing on per-enum basis: */
     441                    const UIExtraDataMetaDefs::DetailsElementOptionTypeSharedFolders enmOptionType =
     442                        pOptionItem->data(DataField_Type).value<UIExtraDataMetaDefs::DetailsElementOptionTypeSharedFolders>();
     443                    pOptionItem->setText(gpConverter->toString(enmOptionType));
     444                }
     445            }
     446            break;
     447        }
     448        case DetailsElementType_UI:
     449        {
     450            /* Enumerate all the option items: */
     451            for (int i = 0; i < m_pListWidgetOptions->count(); ++i)
     452            {
     453                QListWidgetItem *pOptionItem = m_pListWidgetOptions->item(i);
     454                if (pOptionItem)
     455                {
     456                    /* We can translate this thing on per-enum basis: */
     457                    const UIExtraDataMetaDefs::DetailsElementOptionTypeUserInterface enmOptionType =
     458                        pOptionItem->data(DataField_Type).value<UIExtraDataMetaDefs::DetailsElementOptionTypeUserInterface>();
     459                    pOptionItem->setText(gpConverter->toString(enmOptionType));
     460                }
     461            }
     462            break;
     463        }
     464        case DetailsElementType_Description:
     465        {
     466            /* Enumerate all the option items: */
     467            for (int i = 0; i < m_pListWidgetOptions->count(); ++i)
     468            {
     469                QListWidgetItem *pOptionItem = m_pListWidgetOptions->item(i);
     470                if (pOptionItem)
     471                {
     472                    /* We can translate this thing on per-enum basis: */
     473                    const UIExtraDataMetaDefs::DetailsElementOptionTypeDescription enmOptionType =
     474                        pOptionItem->data(DataField_Type).value<UIExtraDataMetaDefs::DetailsElementOptionTypeDescription>();
     475                    pOptionItem->setText(gpConverter->toString(enmOptionType));
     476                }
     477            }
     478            break;
     479        }
     480        default:
     481            break;
     482    }
     483}
     484
     485void UIDetailsContextMenu::sltCategoryItemEntered(QListWidgetItem *pItem)
     486{
     487    /* Choose hovered item as current one: */
     488    m_pListWidgetCategories->setCurrentItem(pItem);
     489}
     490
     491void UIDetailsContextMenu::sltCategoryItemClicked(QListWidgetItem *pItem)
     492{
     493    /* Notify listeners: */
     494    const DetailsElementType enmCategoryType = pItem->data(DataField_Type).value<DetailsElementType>();
     495
     496    /* Toggle element visibility status: */
     497    QMap<DetailsElementType, bool> categories = m_pModel->categories();
     498    if (categories.contains(enmCategoryType))
     499        categories.remove(enmCategoryType);
     500    else
     501        categories[enmCategoryType] = true;
     502    m_pModel->setCategories(categories);
     503}
     504
     505void UIDetailsContextMenu::sltCategoryItemChanged(QListWidgetItem *, QListWidgetItem *)
     506{
     507    /* Update options list: */
     508    populateOptions();
     509    updateOptionStates();
     510    retranslateOptions();
     511}
     512
     513void UIDetailsContextMenu::sltOptionItemEntered(QListWidgetItem *pItem)
     514{
     515    /* Choose hovered item as current one: */
     516    m_pListWidgetOptions->setCurrentItem(pItem);
     517}
     518
     519void UIDetailsContextMenu::sltOptionItemClicked(QListWidgetItem *pItem)
     520{
     521    /* First make sure we really have category item selected: */
     522    QListWidgetItem *pCategoryItem = m_pListWidgetCategories->currentItem();
     523    if (!pCategoryItem)
     524        return;
     525
     526    /* Then acquire category type: */
     527    const DetailsElementType enmCategoryType = pCategoryItem->data(DataField_Type).value<DetailsElementType>();
     528
     529    /* Handle known category types: */
     530    switch (enmCategoryType)
     531    {
     532        case DetailsElementType_General:
     533        {
     534            /* Toggle element visibility status: */
     535            const UIExtraDataMetaDefs::DetailsElementOptionTypeGeneral enmOptionType =
     536                pItem->data(DataField_Type).value<UIExtraDataMetaDefs::DetailsElementOptionTypeGeneral>();
     537            m_pModel->setOptionsGeneral(static_cast<UIExtraDataMetaDefs::DetailsElementOptionTypeGeneral>(m_pModel->optionsGeneral() ^ enmOptionType));
     538            break;
     539        }
     540        case DetailsElementType_System:
     541        {
     542            /* Toggle element visibility status: */
     543            const UIExtraDataMetaDefs::DetailsElementOptionTypeSystem enmOptionType =
     544                pItem->data(DataField_Type).value<UIExtraDataMetaDefs::DetailsElementOptionTypeSystem>();
     545            m_pModel->setOptionsSystem(static_cast<UIExtraDataMetaDefs::DetailsElementOptionTypeSystem>(m_pModel->optionsSystem() ^ enmOptionType));
     546            break;
     547        }
     548        case DetailsElementType_Display:
     549        {
     550            /* Toggle element visibility status: */
     551            const UIExtraDataMetaDefs::DetailsElementOptionTypeDisplay enmOptionType =
     552                pItem->data(DataField_Type).value<UIExtraDataMetaDefs::DetailsElementOptionTypeDisplay>();
     553            m_pModel->setOptionsDisplay(static_cast<UIExtraDataMetaDefs::DetailsElementOptionTypeDisplay>(m_pModel->optionsDisplay() ^ enmOptionType));
     554            break;
     555        }
     556        case DetailsElementType_Storage:
     557        {
     558            /* Toggle element visibility status: */
     559            const UIExtraDataMetaDefs::DetailsElementOptionTypeStorage enmOptionType =
     560                pItem->data(DataField_Type).value<UIExtraDataMetaDefs::DetailsElementOptionTypeStorage>();
     561            m_pModel->setOptionsStorage(static_cast<UIExtraDataMetaDefs::DetailsElementOptionTypeStorage>(m_pModel->optionsStorage() ^ enmOptionType));
     562            break;
     563        }
     564        case DetailsElementType_Audio:
     565        {
     566            /* Toggle element visibility status: */
     567            const UIExtraDataMetaDefs::DetailsElementOptionTypeAudio enmOptionType =
     568                pItem->data(DataField_Type).value<UIExtraDataMetaDefs::DetailsElementOptionTypeAudio>();
     569            m_pModel->setOptionsAudio(static_cast<UIExtraDataMetaDefs::DetailsElementOptionTypeAudio>(m_pModel->optionsAudio() ^ enmOptionType));
     570            break;
     571        }
     572        case DetailsElementType_Network:
     573        {
     574            /* Toggle element visibility status: */
     575            const UIExtraDataMetaDefs::DetailsElementOptionTypeNetwork enmOptionType =
     576                pItem->data(DataField_Type).value<UIExtraDataMetaDefs::DetailsElementOptionTypeNetwork>();
     577            m_pModel->setOptionsNetwork(static_cast<UIExtraDataMetaDefs::DetailsElementOptionTypeNetwork>(m_pModel->optionsNetwork() ^ enmOptionType));
     578            break;
     579        }
     580        case DetailsElementType_Serial:
     581        {
     582            /* Toggle element visibility status: */
     583            const UIExtraDataMetaDefs::DetailsElementOptionTypeSerial enmOptionType =
     584                pItem->data(DataField_Type).value<UIExtraDataMetaDefs::DetailsElementOptionTypeSerial>();
     585            m_pModel->setOptionsSerial(static_cast<UIExtraDataMetaDefs::DetailsElementOptionTypeSerial>(m_pModel->optionsSerial() ^ enmOptionType));
     586            break;
     587        }
     588        case DetailsElementType_USB:
     589        {
     590            /* Toggle element visibility status: */
     591            const UIExtraDataMetaDefs::DetailsElementOptionTypeUsb enmOptionType =
     592                pItem->data(DataField_Type).value<UIExtraDataMetaDefs::DetailsElementOptionTypeUsb>();
     593            m_pModel->setOptionsUsb(static_cast<UIExtraDataMetaDefs::DetailsElementOptionTypeUsb>(m_pModel->optionsUsb() ^ enmOptionType));
     594            break;
     595        }
     596        case DetailsElementType_SF:
     597        {
     598            /* Toggle element visibility status: */
     599            const UIExtraDataMetaDefs::DetailsElementOptionTypeSharedFolders enmOptionType =
     600                pItem->data(DataField_Type).value<UIExtraDataMetaDefs::DetailsElementOptionTypeSharedFolders>();
     601            m_pModel->setOptionsSharedFolders(static_cast<UIExtraDataMetaDefs::DetailsElementOptionTypeSharedFolders>(m_pModel->optionsSharedFolders() ^ enmOptionType));
     602            break;
     603        }
     604        case DetailsElementType_UI:
     605        {
     606            /* Toggle element visibility status: */
     607            const UIExtraDataMetaDefs::DetailsElementOptionTypeUserInterface enmOptionType =
     608                pItem->data(DataField_Type).value<UIExtraDataMetaDefs::DetailsElementOptionTypeUserInterface>();
     609            m_pModel->setOptionsUserInterface(static_cast<UIExtraDataMetaDefs::DetailsElementOptionTypeUserInterface>(m_pModel->optionsUserInterface() ^ enmOptionType));
     610            break;
     611        }
     612        case DetailsElementType_Description:
     613        {
     614            /* Toggle element visibility status: */
     615            const UIExtraDataMetaDefs::DetailsElementOptionTypeDescription enmOptionType =
     616                pItem->data(DataField_Type).value<UIExtraDataMetaDefs::DetailsElementOptionTypeDescription>();
     617            m_pModel->setOptionsDescription(static_cast<UIExtraDataMetaDefs::DetailsElementOptionTypeDescription>(m_pModel->optionsDescription() ^ enmOptionType));
     618            break;
     619        }
     620        default:
     621            break;
     622    }
     623}
     624
     625void UIDetailsContextMenu::prepare()
     626{
     627    /* Create main layout: */
     628    QHBoxLayout *pMainLayout = new QHBoxLayout(this);
     629    if (pMainLayout)
     630    {
     631        pMainLayout->setContentsMargins(0, 0, 0, 0);
     632        pMainLayout->setSpacing(1);
     633
     634        /* Create list of categories: */
     635        m_pListWidgetCategories = new QListWidget(this);
     636        if (m_pListWidgetCategories)
     637        {
     638            m_pListWidgetCategories->setMouseTracking(true);
     639            m_pListWidgetCategories->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Fixed);
     640            connect(m_pListWidgetCategories, &QListWidget::itemEntered,
     641                    this, &UIDetailsContextMenu::sltCategoryItemEntered);
     642            connect(m_pListWidgetCategories, &QListWidget::itemClicked,
     643                    this, &UIDetailsContextMenu::sltCategoryItemClicked);
     644            connect(m_pListWidgetCategories, &QListWidget::currentItemChanged,
     645                    this, &UIDetailsContextMenu::sltCategoryItemChanged);
     646            pMainLayout->addWidget(m_pListWidgetCategories);
     647        }
     648
     649        /* Create list of options: */
     650        m_pListWidgetOptions = new QListWidget(this);
     651        if (m_pListWidgetOptions)
     652        {
     653            m_pListWidgetOptions->setMouseTracking(true);
     654            m_pListWidgetOptions->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Fixed);
     655            connect(m_pListWidgetOptions, &QListWidget::itemEntered,
     656                    this, &UIDetailsContextMenu::sltOptionItemEntered);
     657            connect(m_pListWidgetOptions, &QListWidget::itemClicked,
     658                    this, &UIDetailsContextMenu::sltOptionItemClicked);
     659            pMainLayout->addWidget(m_pListWidgetOptions);
     660        }
     661    }
     662
     663    /* Prepare lists: */
     664    populateCategories();
     665    populateOptions();
     666    /* Apply language settings: */
     667    retranslateUi();
     668}
     669
     670void UIDetailsContextMenu::populateCategories()
     671{
     672    /* Clear category list initially: */
     673    m_pListWidgetCategories->clear();
     674
     675    /* Enumerate all the known categories: */
     676    for (int i = DetailsElementType_Invalid + 1; i < DetailsElementType_Max; ++i)
     677    {
     678        /* Prepare current category type: */
     679        const DetailsElementType enmCategoryType = static_cast<DetailsElementType>(i);
     680        /* And create list-widget item of it: */
     681        QListWidgetItem *pCategoryItem = createCategoryItem(gpConverter->toIcon(enmCategoryType));
     682        if (pCategoryItem)
     683        {
     684            pCategoryItem->setData(DataField_Type, QVariant::fromValue(enmCategoryType));
     685            pCategoryItem->setCheckState(Qt::Unchecked);
     686        }
     687    }
     688}
     689
     690void UIDetailsContextMenu::populateOptions()
     691{
     692    /* Clear option list initially: */
     693    m_pListWidgetOptions->clear();
     694
     695    /* Acquire currently selected category item: */
     696    QListWidgetItem *pCategoryItem = m_pListWidgetCategories->currentItem();
     697    if (!pCategoryItem)
     698        return;
     699
     700    /* We will use that one for all the options fetching: */
     701    const QMetaObject &smo = UIExtraDataMetaDefs::staticMetaObject;
     702
     703    /* Populate currently selected category options: */
     704    const DetailsElementType enmCategoryType = pCategoryItem->data(DataField_Type).value<DetailsElementType>();
     705    switch (enmCategoryType)
     706    {
     707        case DetailsElementType_General:
     708        {
     709            /* Enumerate all the known options: */
     710            const int iEnumIndex = smo.indexOfEnumerator("DetailsElementOptionTypeGeneral");
     711            const QMetaEnum metaEnum = smo.enumerator(iEnumIndex);
     712            for (int iKeyIndex = 0; iKeyIndex < metaEnum.keyCount(); ++iKeyIndex)
     713            {
     714                /* Prepare current option type: */
     715                const UIExtraDataMetaDefs::DetailsElementOptionTypeGeneral enmOptionType =
     716                    static_cast<UIExtraDataMetaDefs::DetailsElementOptionTypeGeneral>(metaEnum.keyToValue(metaEnum.key(iKeyIndex)));
     717                /* Skip invalid and default types: */
     718                if (   enmOptionType == UIExtraDataMetaDefs::DetailsElementOptionTypeGeneral_Invalid
     719                    || enmOptionType == UIExtraDataMetaDefs::DetailsElementOptionTypeGeneral_Default)
     720                    continue;
     721                /* And create list-widget item of it: */
     722                QListWidgetItem *pOptionItem = createOptionItem();
     723                if (pOptionItem)
     724                {
     725                    pOptionItem->setData(DataField_Type, enmOptionType);
     726                    pOptionItem->setData(DataField_Name, gpConverter->toInternalString(enmOptionType));
     727                    pOptionItem->setCheckState(Qt::Unchecked);
     728                }
     729            }
     730            break;
     731        }
     732        case DetailsElementType_System:
     733        {
     734            /* Enumerate all the known options: */
     735            const int iEnumIndex = smo.indexOfEnumerator("DetailsElementOptionTypeSystem");
     736            const QMetaEnum metaEnum = smo.enumerator(iEnumIndex);
     737            for (int iKeyIndex = 0; iKeyIndex < metaEnum.keyCount(); ++iKeyIndex)
     738            {
     739                /* Prepare current option type: */
     740                const UIExtraDataMetaDefs::DetailsElementOptionTypeSystem enmOptionType =
     741                    static_cast<UIExtraDataMetaDefs::DetailsElementOptionTypeSystem>(metaEnum.keyToValue(metaEnum.key(iKeyIndex)));
     742                /* Skip invalid and default types: */
     743                if (   enmOptionType == UIExtraDataMetaDefs::DetailsElementOptionTypeSystem_Invalid
     744                    || enmOptionType == UIExtraDataMetaDefs::DetailsElementOptionTypeSystem_Default)
     745                    continue;
     746                /* And create list-widget item of it: */
     747                QListWidgetItem *pOptionItem = createOptionItem();
     748                if (pOptionItem)
     749                {
     750                    pOptionItem->setData(DataField_Type, QVariant::fromValue(enmOptionType));
     751                    pOptionItem->setData(DataField_Name, gpConverter->toInternalString(enmOptionType));
     752                    pOptionItem->setCheckState(Qt::Unchecked);
     753                }
     754            }
     755            break;
     756        }
     757        case DetailsElementType_Display:
     758        {
     759            /* Enumerate all the known options: */
     760            const int iEnumIndex = smo.indexOfEnumerator("DetailsElementOptionTypeDisplay");
     761            const QMetaEnum metaEnum = smo.enumerator(iEnumIndex);
     762            for (int iKeyIndex = 0; iKeyIndex < metaEnum.keyCount(); ++iKeyIndex)
     763            {
     764                /* Prepare current option type: */
     765                const UIExtraDataMetaDefs::DetailsElementOptionTypeDisplay enmOptionType =
     766                    static_cast<UIExtraDataMetaDefs::DetailsElementOptionTypeDisplay>(metaEnum.keyToValue(metaEnum.key(iKeyIndex)));
     767                /* Skip invalid and default types: */
     768                if (   enmOptionType == UIExtraDataMetaDefs::DetailsElementOptionTypeDisplay_Invalid
     769                    || enmOptionType == UIExtraDataMetaDefs::DetailsElementOptionTypeDisplay_Default)
     770                    continue;
     771                /* And create list-widget item of it: */
     772                QListWidgetItem *pOptionItem = createOptionItem();
     773                if (pOptionItem)
     774                {
     775                    pOptionItem->setData(DataField_Type, QVariant::fromValue(enmOptionType));
     776                    pOptionItem->setData(DataField_Name, gpConverter->toInternalString(enmOptionType));
     777                    pOptionItem->setCheckState(Qt::Unchecked);
     778                }
     779            }
     780            break;
     781        }
     782        case DetailsElementType_Storage:
     783        {
     784            /* Enumerate all the known options: */
     785            const int iEnumIndex = smo.indexOfEnumerator("DetailsElementOptionTypeStorage");
     786            const QMetaEnum metaEnum = smo.enumerator(iEnumIndex);
     787            for (int iKeyIndex = 0; iKeyIndex < metaEnum.keyCount(); ++iKeyIndex)
     788            {
     789                /* Prepare current option type: */
     790                const UIExtraDataMetaDefs::DetailsElementOptionTypeStorage enmOptionType =
     791                    static_cast<UIExtraDataMetaDefs::DetailsElementOptionTypeStorage>(metaEnum.keyToValue(metaEnum.key(iKeyIndex)));
     792                /* Skip invalid and default types: */
     793                if (   enmOptionType == UIExtraDataMetaDefs::DetailsElementOptionTypeStorage_Invalid
     794                    || enmOptionType == UIExtraDataMetaDefs::DetailsElementOptionTypeStorage_Default)
     795                    continue;
     796                /* And create list-widget item of it: */
     797                QListWidgetItem *pOptionItem = createOptionItem();
     798                if (pOptionItem)
     799                {
     800                    pOptionItem->setData(DataField_Type, QVariant::fromValue(enmOptionType));
     801                    pOptionItem->setData(DataField_Name, gpConverter->toInternalString(enmOptionType));
     802                    pOptionItem->setCheckState(Qt::Unchecked);
     803                }
     804            }
     805            break;
     806        }
     807        case DetailsElementType_Audio:
     808        {
     809            /* Enumerate all the known options: */
     810            const int iEnumIndex = smo.indexOfEnumerator("DetailsElementOptionTypeAudio");
     811            const QMetaEnum metaEnum = smo.enumerator(iEnumIndex);
     812            for (int iKeyIndex = 0; iKeyIndex < metaEnum.keyCount(); ++iKeyIndex)
     813            {
     814                /* Prepare current option type: */
     815                const UIExtraDataMetaDefs::DetailsElementOptionTypeAudio enmOptionType =
     816                    static_cast<UIExtraDataMetaDefs::DetailsElementOptionTypeAudio>(metaEnum.keyToValue(metaEnum.key(iKeyIndex)));
     817                /* Skip invalid and default types: */
     818                if (   enmOptionType == UIExtraDataMetaDefs::DetailsElementOptionTypeAudio_Invalid
     819                    || enmOptionType == UIExtraDataMetaDefs::DetailsElementOptionTypeAudio_Default)
     820                    continue;
     821                /* And create list-widget item of it: */
     822                QListWidgetItem *pOptionItem = createOptionItem();
     823                if (pOptionItem)
     824                {
     825                    pOptionItem->setData(DataField_Type, QVariant::fromValue(enmOptionType));
     826                    pOptionItem->setData(DataField_Name, gpConverter->toInternalString(enmOptionType));
     827                    pOptionItem->setCheckState(Qt::Unchecked);
     828                }
     829            }
     830            break;
     831        }
     832        case DetailsElementType_Network:
     833        {
     834            /* Enumerate all the known options: */
     835            const int iEnumIndex = smo.indexOfEnumerator("DetailsElementOptionTypeNetwork");
     836            const QMetaEnum metaEnum = smo.enumerator(iEnumIndex);
     837            for (int iKeyIndex = 0; iKeyIndex < metaEnum.keyCount(); ++iKeyIndex)
     838            {
     839                /* Prepare current option type: */
     840                const UIExtraDataMetaDefs::DetailsElementOptionTypeNetwork enmOptionType =
     841                    static_cast<UIExtraDataMetaDefs::DetailsElementOptionTypeNetwork>(metaEnum.keyToValue(metaEnum.key(iKeyIndex)));
     842                /* Skip invalid and default types: */
     843                if (   enmOptionType == UIExtraDataMetaDefs::DetailsElementOptionTypeNetwork_Invalid
     844                    || enmOptionType == UIExtraDataMetaDefs::DetailsElementOptionTypeNetwork_Default)
     845                    continue;
     846                /* And create list-widget item of it: */
     847                QListWidgetItem *pOptionItem = createOptionItem();
     848                if (pOptionItem)
     849                {
     850                    pOptionItem->setData(DataField_Type, QVariant::fromValue(enmOptionType));
     851                    pOptionItem->setData(DataField_Name, gpConverter->toInternalString(enmOptionType));
     852                    pOptionItem->setCheckState(Qt::Unchecked);
     853                }
     854            }
     855            break;
     856        }
     857        case DetailsElementType_Serial:
     858        {
     859            /* Enumerate all the known options: */
     860            const int iEnumIndex = smo.indexOfEnumerator("DetailsElementOptionTypeSerial");
     861            const QMetaEnum metaEnum = smo.enumerator(iEnumIndex);
     862            for (int iKeyIndex = 0; iKeyIndex < metaEnum.keyCount(); ++iKeyIndex)
     863            {
     864                /* Prepare current option type: */
     865                const UIExtraDataMetaDefs::DetailsElementOptionTypeSerial enmOptionType =
     866                    static_cast<UIExtraDataMetaDefs::DetailsElementOptionTypeSerial>(metaEnum.keyToValue(metaEnum.key(iKeyIndex)));
     867                /* Skip invalid and default types: */
     868                if (   enmOptionType == UIExtraDataMetaDefs::DetailsElementOptionTypeSerial_Invalid
     869                    || enmOptionType == UIExtraDataMetaDefs::DetailsElementOptionTypeSerial_Default)
     870                    continue;
     871                /* And create list-widget item of it: */
     872                QListWidgetItem *pOptionItem = createOptionItem();
     873                if (pOptionItem)
     874                {
     875                    pOptionItem->setData(DataField_Type, QVariant::fromValue(enmOptionType));
     876                    pOptionItem->setData(DataField_Name, gpConverter->toInternalString(enmOptionType));
     877                    pOptionItem->setCheckState(Qt::Unchecked);
     878                }
     879            }
     880            break;
     881        }
     882        case DetailsElementType_USB:
     883        {
     884            /* Enumerate all the known options: */
     885            const int iEnumIndex = smo.indexOfEnumerator("DetailsElementOptionTypeUsb");
     886            const QMetaEnum metaEnum = smo.enumerator(iEnumIndex);
     887            for (int iKeyIndex = 0; iKeyIndex < metaEnum.keyCount(); ++iKeyIndex)
     888            {
     889                /* Prepare current option type: */
     890                const UIExtraDataMetaDefs::DetailsElementOptionTypeUsb enmOptionType =
     891                    static_cast<UIExtraDataMetaDefs::DetailsElementOptionTypeUsb>(metaEnum.keyToValue(metaEnum.key(iKeyIndex)));
     892                /* Skip invalid and default types: */
     893                if (   enmOptionType == UIExtraDataMetaDefs::DetailsElementOptionTypeUsb_Invalid
     894                    || enmOptionType == UIExtraDataMetaDefs::DetailsElementOptionTypeUsb_Default)
     895                    continue;
     896                /* And create list-widget item of it: */
     897                QListWidgetItem *pOptionItem = createOptionItem();
     898                if (pOptionItem)
     899                {
     900                    pOptionItem->setData(DataField_Type, QVariant::fromValue(enmOptionType));
     901                    pOptionItem->setData(DataField_Name, gpConverter->toInternalString(enmOptionType));
     902                    pOptionItem->setCheckState(Qt::Unchecked);
     903                }
     904            }
     905            break;
     906        }
     907        case DetailsElementType_SF:
     908        {
     909            /* Enumerate all the known options: */
     910            const int iEnumIndex = smo.indexOfEnumerator("DetailsElementOptionTypeSharedFolders");
     911            const QMetaEnum metaEnum = smo.enumerator(iEnumIndex);
     912            for (int iKeyIndex = 0; iKeyIndex < metaEnum.keyCount(); ++iKeyIndex)
     913            {
     914                /* Prepare current option type: */
     915                const UIExtraDataMetaDefs::DetailsElementOptionTypeSharedFolders enmOptionType =
     916                    static_cast<UIExtraDataMetaDefs::DetailsElementOptionTypeSharedFolders>(metaEnum.keyToValue(metaEnum.key(iKeyIndex)));
     917                /* Skip invalid and default types: */
     918                if (   enmOptionType == UIExtraDataMetaDefs::DetailsElementOptionTypeSharedFolders_Invalid
     919                    || enmOptionType == UIExtraDataMetaDefs::DetailsElementOptionTypeSharedFolders_Default)
     920                    continue;
     921                /* And create list-widget item of it: */
     922                QListWidgetItem *pOptionItem = createOptionItem();
     923                if (pOptionItem)
     924                {
     925                    pOptionItem->setData(DataField_Type, QVariant::fromValue(enmOptionType));
     926                    pOptionItem->setData(DataField_Name, gpConverter->toInternalString(enmOptionType));
     927                    pOptionItem->setCheckState(Qt::Unchecked);
     928                }
     929            }
     930            break;
     931        }
     932        case DetailsElementType_UI:
     933        {
     934            /* Enumerate all the known options: */
     935            const int iEnumIndex = smo.indexOfEnumerator("DetailsElementOptionTypeUserInterface");
     936            const QMetaEnum metaEnum = smo.enumerator(iEnumIndex);
     937            for (int iKeyIndex = 0; iKeyIndex < metaEnum.keyCount(); ++iKeyIndex)
     938            {
     939                /* Prepare current option type: */
     940                const UIExtraDataMetaDefs::DetailsElementOptionTypeUserInterface enmOptionType =
     941                    static_cast<UIExtraDataMetaDefs::DetailsElementOptionTypeUserInterface>(metaEnum.keyToValue(metaEnum.key(iKeyIndex)));
     942                /* Skip invalid and default types: */
     943                if (   enmOptionType == UIExtraDataMetaDefs::DetailsElementOptionTypeUserInterface_Invalid
     944                    || enmOptionType == UIExtraDataMetaDefs::DetailsElementOptionTypeUserInterface_Default)
     945                    continue;
     946                /* And create list-widget item of it: */
     947                QListWidgetItem *pOptionItem = createOptionItem();
     948                if (pOptionItem)
     949                {
     950                    pOptionItem->setData(DataField_Type, QVariant::fromValue(enmOptionType));
     951                    pOptionItem->setData(DataField_Name, gpConverter->toInternalString(enmOptionType));
     952                    pOptionItem->setCheckState(Qt::Unchecked);
     953                }
     954            }
     955            break;
     956        }
     957        case DetailsElementType_Description:
     958        {
     959            /* Enumerate all the known options: */
     960            const int iEnumIndex = smo.indexOfEnumerator("DetailsElementOptionTypeDescription");
     961            const QMetaEnum metaEnum = smo.enumerator(iEnumIndex);
     962            for (int iKeyIndex = 0; iKeyIndex < metaEnum.keyCount(); ++iKeyIndex)
     963            {
     964                /* Prepare current option type: */
     965                const UIExtraDataMetaDefs::DetailsElementOptionTypeDescription enmOptionType =
     966                    static_cast<UIExtraDataMetaDefs::DetailsElementOptionTypeDescription>(metaEnum.keyToValue(metaEnum.key(iKeyIndex)));
     967                /* Skip invalid and default types: */
     968                if (   enmOptionType == UIExtraDataMetaDefs::DetailsElementOptionTypeGeneral_Invalid
     969                    || enmOptionType == UIExtraDataMetaDefs::DetailsElementOptionTypeGeneral_Default)
     970                    continue;
     971                /* And create list-widget item of it: */
     972                QListWidgetItem *pOptionItem = createOptionItem();
     973                if (pOptionItem)
     974                {
     975                    pOptionItem->setData(DataField_Type, QVariant::fromValue(enmOptionType));
     976                    pOptionItem->setData(DataField_Name, gpConverter->toInternalString(enmOptionType));
     977                    pOptionItem->setCheckState(Qt::Unchecked);
     978                }
     979            }
     980            break;
     981        }
     982        default:
     983            break;
     984    }
     985}
     986
     987void UIDetailsContextMenu::adjustListWidgets()
     988{
     989    /* Include frame width: */
     990    int iW = 2 * m_pListWidgetCategories->frameWidth();
     991    int iH = iW;
     992
     993    /* Include size hints: */
     994    iW += m_pListWidgetCategories->sizeHintForColumn(0);
     995    iH += m_pListWidgetCategories->sizeHintForRow(0) * m_pListWidgetCategories->count();
     996
     997    /* Category list size is constant, options list size is vague: */
     998    m_pListWidgetCategories->setFixedSize(QSize(iW, iH));
     999    m_pListWidgetOptions->setFixedSize(QSize(iW * 1.5, iH));
     1000}
     1001
     1002QListWidgetItem *UIDetailsContextMenu::createCategoryItem(const QIcon &icon)
     1003{
     1004    QListWidgetItem *pItem = new QListWidgetItem(icon, QString(), m_pListWidgetCategories);
     1005    if (pItem)
     1006        m_pListWidgetCategories->addItem(pItem);
     1007    return pItem;
     1008}
     1009
     1010QListWidgetItem *UIDetailsContextMenu::createOptionItem()
     1011{
     1012    QListWidgetItem *pItem = new QListWidgetItem(QString(), m_pListWidgetOptions);
     1013    if (pItem)
     1014        m_pListWidgetOptions->addItem(pItem);
     1015    return pItem;
     1016}
    401017
    411018
    … …  
    501027    , m_pRoot(0)
    511028    , m_pAnimationCallback(0)
     1029    , m_pContextMenu(0)
    521030{
    531031    prepare();
    … …  
    1041082    m_categories = categories;
    1051083    m_pRoot->rebuildGroup();
     1084    m_pContextMenu->updateCategoryStates();
    1061085}
    1071086
    … …  
    1101089    m_fOptionsGeneral = fOptionsGeneral;
    1111090    m_pRoot->rebuildGroup();
     1091    m_pContextMenu->updateOptionStates(DetailsElementType_General);
    1121092}
    1131093
    … …  
    1161096    m_fOptionsSystem = fOptionsSystem;
    1171097    m_pRoot->rebuildGroup();
     1098    m_pContextMenu->updateOptionStates(DetailsElementType_System);
    1181099}
    1191100
    … …  
    1221103    m_fOptionsDisplay = fOptionsDisplay;
    1231104    m_pRoot->rebuildGroup();
     1105    m_pContextMenu->updateOptionStates(DetailsElementType_Display);
    1241106}
    1251107
    … …  
    1281110    m_fOptionsStorage = fOptionsStorage;
    1291111    m_pRoot->rebuildGroup();
     1112    m_pContextMenu->updateOptionStates(DetailsElementType_Storage);
    1301113}
    1311114
    … …  
    1341117    m_fOptionsAudio = fOptionsAudio;
    1351118    m_pRoot->rebuildGroup();
     1119    m_pContextMenu->updateOptionStates(DetailsElementType_Audio);
    1361120}
    1371121
    … …  
    1401124    m_fOptionsNetwork = fOptionsNetwork;
    1411125    m_pRoot->rebuildGroup();
     1126    m_pContextMenu->updateOptionStates(DetailsElementType_Network);
    1421127}
    1431128
    … …  
    1461131    m_fOptionsSerial = fOptionsSerial;
    1471132    m_pRoot->rebuildGroup();
     1133    m_pContextMenu->updateOptionStates(DetailsElementType_Serial);
    1481134}
    1491135
    … …  
    1521138    m_fOptionsUsb = fOptionsUsb;
    1531139    m_pRoot->rebuildGroup();
     1140    m_pContextMenu->updateOptionStates(DetailsElementType_USB);
    1541141}
    1551142
    … …  
    1581145    m_fOptionsSharedFolders = fOptionsSharedFolders;
    1591146    m_pRoot->rebuildGroup();
     1147    m_pContextMenu->updateOptionStates(DetailsElementType_SF);
    1601148}
    1611149
    … …  
    1641152    m_fOptionsUserInterface = fOptionsUserInterface;
    1651153    m_pRoot->rebuildGroup();
     1154    m_pContextMenu->updateOptionStates(DetailsElementType_UI);
    1661155}
    1671156
    … …  
    1701159    m_fOptionsDescription = fOptionsDescription;
    1711160    m_pRoot->rebuildGroup();
     1161    m_pContextMenu->updateOptionStates(DetailsElementType_Description);
    1721162}
    1731163
    … …  
    1951185{
    1961186    loadDetailsCategories();
     1187    m_pContextMenu->updateCategoryStates();
    1971188    m_pRoot->rebuildGroup();
    1981189}
    … …  
    2011192{
    2021193    loadDetailsOptions(enmType);
     1194    m_pContextMenu->updateOptionStates(enmType);
    2031195    m_pRoot->rebuildGroup();
    2041196}
    … …  
    2761268}
    2771269
    278 void UIDetailsModel::sltElementTypeToggled()
    279 {
    280     /* Which item was toggled? */
    281     QAction *pAction = qobject_cast<QAction*>(sender());
    282     DetailsElementType enmType = pAction->data().value<DetailsElementType>();
    283 
    284     /* Toggle element visibility status: */
    285     if (m_categories.contains(enmType))
    286         m_categories.remove(enmType);
    287     else
    288         m_categories[enmType] = true;
    289 
    290     /* Rebuild group: */
    291     m_pRoot->rebuildGroup();
    292 }
    293 
    2941270void UIDetailsModel::prepare()
    2951271{
    … …  
    2971273    prepareScene();
    2981274    prepareRoot();
     1275    prepareContextMenu();
    2991276    loadSettings();
    3001277}
    … …  
    3121289}
    3131290
     1291void UIDetailsModel::prepareContextMenu()
     1292{
     1293    m_pContextMenu = new UIDetailsContextMenu(this);
     1294}
     1295
    3141296void UIDetailsModel::loadSettings()
    3151297{
    … …  
    3211303{
    3221304    m_categories = gEDataManager->selectorWindowDetailsElements();
     1305    m_pContextMenu->updateCategoryStates();
    3231306}
    3241307
    … …  
    4801463            m_fOptionsDescription = UIExtraDataMetaDefs::DetailsElementOptionTypeDescription_Default;
    4811464    }
     1465
     1466    m_pContextMenu->updateOptionStates();
    4821467}
    4831468
    … …  
    9401925}
    9411926
     1927void UIDetailsModel::cleanupContextMenu()
     1928{
     1929    delete m_pContextMenu;
     1930    m_pContextMenu = 0;
     1931}
     1932
    9421933void UIDetailsModel::cleanupRoot()
    9431934{
    … …  
    9561947    /* Cleanup things: */
    9571948    saveSettings();
     1949    cleanupContextMenu();
    9581950    cleanupRoot();
    9591951    cleanupScene();
    … …  
    9671959            return false;
    9681960
    969     /* Prepare context-menu: */
    970     QMenu contextMenu;
    971     /* Enumerate elements settings: */
    972     for (int iType = DetailsElementType_General; iType <= DetailsElementType_Description; ++iType)
    973     {
    974         const DetailsElementType enmCurrentElementType = (DetailsElementType)iType;
    975         QAction *pAction = contextMenu.addAction(gpConverter->toString(enmCurrentElementType), this, SLOT(sltElementTypeToggled()));
    976         pAction->setCheckable(true);
    977         pAction->setChecked(m_categories.contains(enmCurrentElementType));
    978         pAction->setData(QVariant::fromValue(enmCurrentElementType));
    979     }
    980     /* Exec context-menu: */
    981     contextMenu.exec(pEvent->screenPos());
     1961    /* Adjust the menu then show it: */
     1962    m_pContextMenu->resize(m_pContextMenu->minimumSizeHint());
     1963    m_pContextMenu->move(pEvent->screenPos());
     1964    m_pContextMenu->show();
    9821965
    9831966    /* Filter: */

  • trunk/src/VBox/Frontends/VirtualBox/src/manager/details/UIDetailsModel.h

    r75607 r75636  
    2626
    2727/* GUI includes: */
     28#include "QIWithRetranslateUI.h"
    2829#include "UIExtraDataDefs.h"
    2930
    … …  
    3637class QGraphicsSceneContextMenuEvent;
    3738class QGraphicsView;
     39class QListWidget;
     40class QListWidgetItem;
    3841class UIVirtualMachineItem;
    3942class UIDetails;
    … …  
    4245class UIDetailsGroup;
    4346class UIDetailsItem;
     47class UIDetailsModel;
     48
     49
     50/** QWidget subclass used as Details pane context menu. */
     51class UIDetailsContextMenu : public QIWithRetranslateUI2<QWidget>
     52{
     53    Q_OBJECT;
     54
     55public:
     56
     57    /** Context menu data fields. */
     58    enum DataField
     59    {
     60        DataField_Type = Qt::UserRole + 1,
     61        DataField_Name = Qt::UserRole + 2,
     62    };
     63
     64    /** Constructs context-menu.
     65      * @param  pModel  Brings model object reference. */
     66    UIDetailsContextMenu(UIDetailsModel *pModel);
     67
     68    /** Updates category check-states. */
     69    void updateCategoryStates();
     70    /** Updates option check-states for certain @a enmRequiredCategoryType. */
     71    void updateOptionStates(DetailsElementType enmRequiredCategoryType = DetailsElementType_Invalid);
     72
     73protected:
     74
     75    /** Handles translation event. */
     76    virtual void retranslateUi() /* override */;
     77
     78    /** Handles translation event for categories list. */
     79    void retranslateCategories();
     80    /** Handles translation event for options list. */
     81    void retranslateOptions();
     82
     83private slots:
     84
     85    /** Handles signal about category list-widget @a pItem hovered. */
     86    void sltCategoryItemEntered(QListWidgetItem *pItem);
     87    /** Handles signal about category list-widget @a pItem clicked. */
     88    void sltCategoryItemClicked(QListWidgetItem *pItem);
     89    /** Handles signal about current category list-widget @a pItem hovered. */
     90    void sltCategoryItemChanged(QListWidgetItem *pCurrent, QListWidgetItem *pPrevious);
     91
     92    /** Handles signal about option list-widget @a pItem hovered. */
     93    void sltOptionItemEntered(QListWidgetItem *pItem);
     94    /** Handles signal about option list-widget @a pItem clicked. */
     95    void sltOptionItemClicked(QListWidgetItem *pItem);
     96
     97private:
     98
     99    /** Prepares all. */
     100    void prepare();
     101
     102    /** (Re)populates categories. */
     103    void populateCategories();
     104    /** (Re)populates options. */
     105    void populateOptions();
     106
     107    /** Adjusts both list widgets. */
     108    void adjustListWidgets();
     109
     110    /** Creates category list item with specified @a icon. */
     111    QListWidgetItem *createCategoryItem(const QIcon &icon);
     112    /** Creates option list item. */
     113    QListWidgetItem *createOptionItem();
     114
     115    /** Holds the model reference. */
     116    UIDetailsModel *m_pModel;
     117
     118    /** Holds the categories list instance. */
     119    QListWidget *m_pListWidgetCategories;
     120    /** Holds the options list instance. */
     121    QListWidget *m_pListWidgetOptions;
     122};
    44123
    45124
    … …  
    178257    /** Handles sigal about details element of certain @a enmType toggling finished, making element @a fToggled. */
    179258    void sltToggleAnimationFinished(DetailsElementType type, bool fToggled);
    180 
    181     /** Handles request about toggling visibility. */
    182     void sltElementTypeToggled();
    183259
    184260private:
    … …  
    192268        /** Prepares root. */
    193269        void prepareRoot();
     270        /** Prepares context-menu. */
     271        void prepareContextMenu();
    194272        /** Loads settings. */
    195273        void loadSettings();
    … …  
    206284        /** Saves settings. */
    207285        void saveSettings();
     286        /** Cleanups context-menu. */
     287        void cleanupContextMenu();
    208288        /** Cleanups root. */
    209289        void cleanupRoot();
    … …  
    252332    /** Holds the options for Description element. */
    253333    UIExtraDataMetaDefs::DetailsElementOptionTypeDescription    m_fOptionsDescription;
     334
     335    /** Holds the context-menu instance. */
     336    UIDetailsContextMenu *m_pContextMenu;
    254337};
    255338
Note: See TracChangeset for help on using the changeset viewer.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette