VirtualBox

Changeset 66458 in vbox for trunk


Ignore:
Timestamp:
Apr 6, 2017 10:55:03 AM (8 years ago)
Author:
vboxsync
Message:

FE/Qt: Machine settings: USB page: Proper loading, caching, saving (2nd iteration, s.a. r114368).

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/VBox/Frontends/VirtualBox/src/settings/machine/UIMachineSettingsUSB.cpp

    r66455 r66458  
    160160
    161161
    162 /**
    163  *  USB popup menu class.
    164  *  This class provides the list of USB devices attached to the host.
    165  */
     162/** Machine settings: USB Filter popup menu. */
    166163class VBoxUSBMenu : public QMenu
    167164{
     
    368365    m_pCache->clear();
    369366
    370     /* Prepare initial USB data: */
    371     UIDataSettingsMachineUSB initialUsbData;
    372 
    373     /* Gather USB values: */
    374     initialUsbData.m_fUSBEnabled = !m_machine.GetUSBControllers().isEmpty();
    375     initialUsbData.m_USBControllerType = m_machine.GetUSBControllerCountByType(KUSBControllerType_XHCI) > 0 ? KUSBControllerType_XHCI :
    376                                          m_machine.GetUSBControllerCountByType(KUSBControllerType_EHCI) > 0 ? KUSBControllerType_EHCI :
    377                                          m_machine.GetUSBControllerCountByType(KUSBControllerType_OHCI) > 0 ? KUSBControllerType_OHCI :
    378                                          KUSBControllerType_Null;
    379 
    380     /* Check if controller is valid: */
    381     const CUSBDeviceFilters &filtersObject = m_machine.GetUSBDeviceFilters();
    382     if (!filtersObject.isNull())
    383     {
    384         /* For each USB filter: */
    385         const CUSBDeviceFilterVector &filters = filtersObject.GetDeviceFilters();
     367    /* Prepare old USB data: */
     368    UIDataSettingsMachineUSB oldUsbData;
     369
     370    /* Gather old USB data: */
     371    oldUsbData.m_fUSBEnabled = !m_machine.GetUSBControllers().isEmpty();
     372    oldUsbData.m_USBControllerType = m_machine.GetUSBControllerCountByType(KUSBControllerType_XHCI) > 0 ? KUSBControllerType_XHCI :
     373                                     m_machine.GetUSBControllerCountByType(KUSBControllerType_EHCI) > 0 ? KUSBControllerType_EHCI :
     374                                     m_machine.GetUSBControllerCountByType(KUSBControllerType_OHCI) > 0 ? KUSBControllerType_OHCI :
     375                                     KUSBControllerType_Null;
     376
     377    /* Check whether controller is valid: */
     378    const CUSBDeviceFilters &comFiltersObject = m_machine.GetUSBDeviceFilters();
     379    if (!comFiltersObject.isNull())
     380    {
     381        /* For each filter: */
     382        const CUSBDeviceFilterVector &filters = comFiltersObject.GetDeviceFilters();
    386383        for (int iFilterIndex = 0; iFilterIndex < filters.size(); ++iFilterIndex)
    387384        {
    388             /* Prepare USB filter data: */
    389             UIDataSettingsMachineUSBFilter initialUsbFilterData;
    390 
    391             /* Check if filter is valid: */
     385            /* Prepare old filter data: */
     386            UIDataSettingsMachineUSBFilter oldFilterData;
     387
     388            /* Check whether filter is valid: */
    392389            const CUSBDeviceFilter &filter = filters.at(iFilterIndex);
    393390            if (!filter.isNull())
    394391            {
    395                 /* Gather USB filter values: */
    396                 initialUsbFilterData.m_fActive = filter.GetActive();
    397                 initialUsbFilterData.m_strName = filter.GetName();
    398                 initialUsbFilterData.m_strVendorId = filter.GetVendorId();
    399                 initialUsbFilterData.m_strProductId = filter.GetProductId();
    400                 initialUsbFilterData.m_strRevision = filter.GetRevision();
    401                 initialUsbFilterData.m_strManufacturer = filter.GetManufacturer();
    402                 initialUsbFilterData.m_strProduct = filter.GetProduct();
    403                 initialUsbFilterData.m_strSerialNumber = filter.GetSerialNumber();
    404                 initialUsbFilterData.m_strPort = filter.GetPort();
    405                 initialUsbFilterData.m_strRemote = filter.GetRemote();
     392                /* Gather old filter data: */
     393                oldFilterData.m_fActive = filter.GetActive();
     394                oldFilterData.m_strName = filter.GetName();
     395                oldFilterData.m_strVendorId = filter.GetVendorId();
     396                oldFilterData.m_strProductId = filter.GetProductId();
     397                oldFilterData.m_strRevision = filter.GetRevision();
     398                oldFilterData.m_strManufacturer = filter.GetManufacturer();
     399                oldFilterData.m_strProduct = filter.GetProduct();
     400                oldFilterData.m_strSerialNumber = filter.GetSerialNumber();
     401                oldFilterData.m_strPort = filter.GetPort();
     402                oldFilterData.m_strRemote = filter.GetRemote();
    406403            }
    407404
    408             /* Cache initial USB filter data: */
    409             m_pCache->child(iFilterIndex).cacheInitialData(initialUsbFilterData);
    410         }
    411     }
    412 
    413     /* Cache initial USB data: */
    414     m_pCache->cacheInitialData(initialUsbData);
     405            /* Cache old filter data: */
     406            m_pCache->child(iFilterIndex).cacheInitialData(oldFilterData);
     407        }
     408    }
     409
     410    /* Cache old USB data: */
     411    m_pCache->cacheInitialData(oldUsbData);
    415412
    416413    /* Upload machine to data: */
     
    423420    mTwFilters->clear();
    424421
    425     /* Get USB data from cache: */
    426     const UIDataSettingsMachineUSB &usbData = m_pCache->base();
    427 
    428     /* Load USB data to page: */
    429     mGbUSB->setChecked(usbData.m_fUSBEnabled);
    430     switch (usbData.m_USBControllerType)
     422    /* Get old USB data from the cache: */
     423    const UIDataSettingsMachineUSB &oldUsbData = m_pCache->base();
     424
     425    /* Load old USB data to the page: */
     426    mGbUSB->setChecked(oldUsbData.m_fUSBEnabled);
     427    switch (oldUsbData.m_USBControllerType)
    431428    {
    432429        default:
     
    436433    }
    437434
    438     /* For each USB filter => load it to the page: */
     435    /* For each filter => load it to the page: */
    439436    for (int iFilterIndex = 0; iFilterIndex < m_pCache->childCount(); ++iFilterIndex)
    440437        addUSBFilterItem(m_pCache->child(iFilterIndex).base(), false /* its new? */);
     
    442439    /* Choose first filter as current: */
    443440    mTwFilters->setCurrentItem(mTwFilters->topLevelItem(0));
    444 
    445     /* Update page: */
    446441    sltHandleUsbAdapterToggle(mGbUSB->isChecked());
    447442
     
    455450void UIMachineSettingsUSB::putToCache()
    456451{
    457     /* Prepare current USB data: */
    458     UIDataSettingsMachineUSB currentUsbData;
    459 
    460     /* Gather current USB data: */
    461     currentUsbData.m_fUSBEnabled = mGbUSB->isChecked();
    462     if (!currentUsbData.m_fUSBEnabled)
    463         currentUsbData.m_USBControllerType = KUSBControllerType_Null;
     452    /* Prepare new USB data: */
     453    UIDataSettingsMachineUSB newUsbData;
     454
     455    /* Gather new USB data: */
     456    newUsbData.m_fUSBEnabled = mGbUSB->isChecked();
     457    if (!newUsbData.m_fUSBEnabled)
     458        newUsbData.m_USBControllerType = KUSBControllerType_Null;
    464459    else
    465460    {
    466461        if (mRbUSB1->isChecked())
    467             currentUsbData.m_USBControllerType = KUSBControllerType_OHCI;
     462            newUsbData.m_USBControllerType = KUSBControllerType_OHCI;
    468463        else if (mRbUSB2->isChecked())
    469             currentUsbData.m_USBControllerType = KUSBControllerType_EHCI;
     464            newUsbData.m_USBControllerType = KUSBControllerType_EHCI;
    470465        else if (mRbUSB3->isChecked())
    471             currentUsbData.m_USBControllerType = KUSBControllerType_XHCI;
    472     }
    473 
    474     /* For each USB filter => cache current USB filter data: */
     466            newUsbData.m_USBControllerType = KUSBControllerType_XHCI;
     467    }
     468
     469    /* For each filter: */
    475470    QTreeWidgetItem *pMainRootItem = mTwFilters->invisibleRootItem();
    476471    for (int iFilterIndex = 0; iFilterIndex < pMainRootItem->childCount(); ++iFilterIndex)
    477         m_pCache->child(iFilterIndex).cacheCurrentData(*static_cast<UIUSBFilterItem*>(pMainRootItem->child(iFilterIndex)));
    478 
    479     /* Cache current USB data: */
    480     m_pCache->cacheCurrentData(currentUsbData);
     472    {
     473        /* Get and cache new filter item: */
     474        const UIUSBFilterItem *pItem = static_cast<UIUSBFilterItem*>(pMainRootItem->child(iFilterIndex));
     475        m_pCache->child(iFilterIndex).cacheCurrentData(*pItem);
     476    }
     477
     478    /* Cache new USB data: */
     479    m_pCache->cacheCurrentData(newUsbData);
    481480}
    482481
     
    486485    UISettingsPageMachine::fetchData(data);
    487486
    488     /* Check if USB data was changed: */
    489     if (m_pCache->wasChanged())
    490     {
    491         /* Check if controller is valid: */
    492         CUSBDeviceFilters filtersObject = m_machine.GetUSBDeviceFilters();
    493         if (!filtersObject.isNull())
    494         {
    495             /* Get USB data from cache: */
    496             const UIDataSettingsMachineUSB &usbData = m_pCache->data();
    497             /* Store USB data: */
    498             if (isMachineOffline())
     487    /* Make sure machine is in valid mode & USB data was changed: */
     488    if (isMachineInValidMode() && m_pCache->wasChanged())
     489    {
     490        /* Get old USB data from the cache: */
     491        const UIDataSettingsMachineUSB &oldUsbData = m_pCache->base();
     492        /* Get new USB data from the cache: */
     493        const UIDataSettingsMachineUSB &newUsbData = m_pCache->data();
     494
     495        /* Store USB data: */
     496        if (isMachineOffline() && newUsbData != oldUsbData)
     497        {
     498            /* Removing USB controllers: */
     499            if (!newUsbData.m_fUSBEnabled)
    499500            {
     501                /* Get current USB controllers: */
     502                const CUSBControllerVector &controllers = m_machine.GetUSBControllers();
     503                for (int iControllerIndex = 0; iControllerIndex < controllers.size(); ++iControllerIndex)
     504                {
     505                    /* Get current USB controller: */
     506                    const CUSBController &controller = controllers.at(iControllerIndex);
     507                    /* Remove current USB controller: */
     508                    m_machine.RemoveUSBController(controller.GetName());
     509                }
     510            }
     511
     512            else
     513
     514            /* Creating/replacing USB controller: */
     515            if (newUsbData.m_fUSBEnabled)
     516            {
     517                /* Get each controller count: */
    500518                const ULONG cOhciCtls = m_machine.GetUSBControllerCountByType(KUSBControllerType_OHCI);
    501519                const ULONG cEhciCtls = m_machine.GetUSBControllerCountByType(KUSBControllerType_EHCI);
    502520                const ULONG cXhciCtls = m_machine.GetUSBControllerCountByType(KUSBControllerType_XHCI);
    503521
    504                 /* Removing USB controllers: */
    505                 if (!usbData.m_fUSBEnabled)
     522                /* For requested controller type: */
     523                switch (newUsbData.m_USBControllerType)
    506524                {
    507                     if (cXhciCtls || cEhciCtls || cOhciCtls)
    508                         foreach (const CUSBController &controller, m_machine.GetUSBControllers())
    509                             m_machine.RemoveUSBController(controller.GetName());
    510                 }
    511                 /* Creating/replacing USB controllers: */
    512                 else
    513                 {
    514                     switch (usbData.m_USBControllerType)
     525                    case KUSBControllerType_OHCI:
    515526                    {
    516                         case KUSBControllerType_OHCI:
     527                        /* Remove excessive controllers: */
     528                        if (cXhciCtls || cEhciCtls)
    517529                        {
    518                             if (cXhciCtls || cEhciCtls)
     530                            /* Get current USB controllers: */
     531                            const CUSBControllerVector &controllers = m_machine.GetUSBControllers();
     532                            for (int iControllerIndex = 0; iControllerIndex < controllers.size(); ++iControllerIndex)
    519533                            {
    520                                 foreach (const CUSBController &controller, m_machine.GetUSBControllers())
    521                                 {
    522                                     const KUSBControllerType enmType = controller.GetType();
    523                                     if (enmType == KUSBControllerType_XHCI || enmType == KUSBControllerType_EHCI)
    524                                         m_machine.RemoveUSBController(controller.GetName());
    525                                 }
     534                                /* Get current USB controller: */
     535                                const CUSBController &controller = controllers.at(iControllerIndex);
     536                                const KUSBControllerType enmType = controller.GetType();
     537                                /* Remove required USB controller: */
     538                                if (   enmType == KUSBControllerType_XHCI
     539                                    || enmType == KUSBControllerType_EHCI)
     540                                    m_machine.RemoveUSBController(controller.GetName());
    526541                            }
    527                             if (!cOhciCtls)
    528                                 m_machine.AddUSBController("OHCI", KUSBControllerType_OHCI);
    529                             break;
    530542                        }
    531                         case KUSBControllerType_EHCI:
     543
     544                        /* Add required controller: */
     545                        if (!cOhciCtls)
     546                            m_machine.AddUSBController("OHCI", KUSBControllerType_OHCI);
     547
     548                        break;
     549                    }
     550                    case KUSBControllerType_EHCI:
     551                    {
     552                        /* Remove excessive controllers: */
     553                        if (cXhciCtls)
    532554                        {
    533                             if (cXhciCtls)
     555                            /* Get current USB controllers: */
     556                            const CUSBControllerVector &controllers = m_machine.GetUSBControllers();
     557                            for (int iControllerIndex = 0; iControllerIndex < controllers.size(); ++iControllerIndex)
    534558                            {
    535                                 foreach (const CUSBController &controller, m_machine.GetUSBControllers())
    536                                 {
    537                                     const KUSBControllerType enmType = controller.GetType();
    538                                     if (enmType == KUSBControllerType_XHCI)
    539                                         m_machine.RemoveUSBController(controller.GetName());
    540                                 }
     559                                /* Get current USB controller: */
     560                                const CUSBController &controller = controllers.at(iControllerIndex);
     561                                const KUSBControllerType enmType = controller.GetType();
     562                                /* Remove required USB controller: */
     563                                if (enmType == KUSBControllerType_XHCI)
     564                                    m_machine.RemoveUSBController(controller.GetName());
    541565                            }
    542                             if (!cOhciCtls)
    543                                 m_machine.AddUSBController("OHCI", KUSBControllerType_OHCI);
    544                             if (!cEhciCtls)
    545                                 m_machine.AddUSBController("EHCI", KUSBControllerType_EHCI);
    546                             break;
    547566                        }
    548                         case KUSBControllerType_XHCI:
     567
     568                        /* Add required controllers: */
     569                        if (!cOhciCtls)
     570                            m_machine.AddUSBController("OHCI", KUSBControllerType_OHCI);
     571                        if (!cEhciCtls)
     572                            m_machine.AddUSBController("EHCI", KUSBControllerType_EHCI);
     573
     574                        break;
     575                    }
     576                    case KUSBControllerType_XHCI:
     577                    {
     578                        /* Remove excessive controllers: */
     579                        if (cEhciCtls || cOhciCtls)
    549580                        {
    550                             if (cEhciCtls || cOhciCtls)
     581                            /* Get current USB controllers: */
     582                            const CUSBControllerVector &controllers = m_machine.GetUSBControllers();
     583                            for (int iControllerIndex = 0; iControllerIndex < controllers.size(); ++iControllerIndex)
    551584                            {
    552                                 foreach (const CUSBController &controller, m_machine.GetUSBControllers())
    553                                 {
    554                                     const KUSBControllerType enmType = controller.GetType();
    555                                     if (enmType == KUSBControllerType_EHCI || enmType == KUSBControllerType_OHCI)
    556                                         m_machine.RemoveUSBController(controller.GetName());
    557                                 }
     585                                /* Get current USB controller: */
     586                                const CUSBController &controller = controllers.at(iControllerIndex);
     587                                const KUSBControllerType enmType = controller.GetType();
     588                                /* Remove required USB controller: */
     589                                if (   enmType == KUSBControllerType_EHCI
     590                                    || enmType == KUSBControllerType_OHCI)
     591                                    m_machine.RemoveUSBController(controller.GetName());
    558592                            }
    559                             if (!cXhciCtls)
    560                                 m_machine.AddUSBController("xHCI", KUSBControllerType_XHCI);
    561                             break;
    562593                        }
    563                         default:
    564                             break;
     594
     595                        /* Add required controller: */
     596                        if (!cXhciCtls)
     597                            m_machine.AddUSBController("xHCI", KUSBControllerType_XHCI);
     598
     599                        break;
    565600                    }
     601                    default:
     602                        break;
    566603                }
    567604            }
    568             /* Store USB filters data: */
    569             if (isMachineInValidMode())
     605        }
     606
     607        /* Store USB filters data: */
     608        CUSBDeviceFilters filtersObject = m_machine.GetUSBDeviceFilters();
     609        /* Check if controller is valid: */
     610        if (!filtersObject.isNull())
     611        {
     612            /* For each USB filter data set: */
     613            int iOperationPosition = 0;
     614            for (int iFilterIndex = 0; iFilterIndex < m_pCache->childCount(); ++iFilterIndex)
    570615            {
    571                 /* For each USB filter data set: */
    572                 int iOperationPosition = 0;
    573                 for (int iFilterIndex = 0; iFilterIndex < m_pCache->childCount(); ++iFilterIndex)
     616                /* Check if USB filter data was changed: */
     617                const UISettingsCacheMachineUSBFilter &filterCache = m_pCache->child(iFilterIndex);
     618                if (filterCache.wasChanged())
    574619                {
    575                     /* Check if USB filter data really changed: */
    576                     const UISettingsCacheMachineUSBFilter &usbFilterCache = m_pCache->child(iFilterIndex);
    577                     if (usbFilterCache.wasChanged())
     620                    /* If filter was removed or updated: */
     621                    if (filterCache.wasRemoved() || filterCache.wasUpdated())
    578622                    {
    579                         /* If filter was removed or updated: */
    580                         if (usbFilterCache.wasRemoved() || usbFilterCache.wasUpdated())
     623                        /* Remove current USB filter: */
     624                        filtersObject.RemoveDeviceFilter(iOperationPosition);
     625                        if (filtersObject.isOk() && filterCache.wasRemoved())
     626                            --iOperationPosition;
     627                    }
     628
     629                    /* If filter was created or updated: */
     630                    if (filterCache.wasCreated() || filterCache.wasUpdated())
     631                    {
     632                        /* Get new filter data from the cache: */
     633                        const UIDataSettingsMachineUSBFilter &newFilterData = filterCache.data();
     634
     635                        /* Store USB filter data: */
     636                        CUSBDeviceFilter filter = filtersObject.CreateDeviceFilter(newFilterData.m_strName);
     637                        if (!filter.isNull())
    581638                        {
    582                             filtersObject.RemoveDeviceFilter(iOperationPosition);
    583                             if (usbFilterCache.wasRemoved())
    584                                 --iOperationPosition;
    585                         }
    586 
    587                         /* If filter was created or updated: */
    588                         if (usbFilterCache.wasCreated() || usbFilterCache.wasUpdated())
    589                         {
    590                             /* Get USB filter data from the cache: */
    591                             const UIDataSettingsMachineUSBFilter &usbFilterData = usbFilterCache.data();
    592                             /* Store USB filter data: */
    593                             CUSBDeviceFilter filter = filtersObject.CreateDeviceFilter(usbFilterData.m_strName);
    594                             filter.SetActive(usbFilterData.m_fActive);
    595                             filter.SetVendorId(usbFilterData.m_strVendorId);
    596                             filter.SetProductId(usbFilterData.m_strProductId);
    597                             filter.SetRevision(usbFilterData.m_strRevision);
    598                             filter.SetManufacturer(usbFilterData.m_strManufacturer);
    599                             filter.SetProduct(usbFilterData.m_strProduct);
    600                             filter.SetSerialNumber(usbFilterData.m_strSerialNumber);
    601                             filter.SetPort(usbFilterData.m_strPort);
    602                             filter.SetRemote(usbFilterData.m_strRemote);
     639                            /* Set whether filter is active: */
     640                            filter.SetActive(newFilterData.m_fActive);
     641                            /* Set filter Vendor ID: */
     642                            filter.SetVendorId(newFilterData.m_strVendorId);
     643                            /* Set filter Product ID: */
     644                            filter.SetProductId(newFilterData.m_strProductId);
     645                            /* Set filter revision: */
     646                            filter.SetRevision(newFilterData.m_strRevision);
     647                            /* Set filter manufacturer: */
     648                            filter.SetManufacturer(newFilterData.m_strManufacturer);
     649                            /* Set filter product: */
     650                            filter.SetProduct(newFilterData.m_strProduct);
     651                            /* Set filter serial number: */
     652                            filter.SetSerialNumber(newFilterData.m_strSerialNumber);
     653                            /* Set filter port: */
     654                            filter.SetPort(newFilterData.m_strPort);
     655                            /* Set filter remote mode: */
     656                            filter.SetRemote(newFilterData.m_strRemote);
     657
     658                            /* Insert filter onto corresponding position: */
    603659                            filtersObject.InsertDeviceFilter(iOperationPosition, filter);
    604660                        }
    605661                    }
    606 
    607                     /* Advance operation position: */
    608                     ++iOperationPosition;
    609662                }
     663                /* Advance operation position: */
     664                ++iOperationPosition;
    610665            }
    611666        }
     
    782837
    783838    /* Prepare new USB filter data: */
    784     UIDataSettingsMachineUSBFilter usbFilterData;
    785     usbFilterData.m_fActive = true;
    786     usbFilterData.m_strName = m_strTrUSBFilterName.arg(iMaxFilterIndex + 1);
    787     usbFilterData.m_fHostUSBDevice = false;
     839    UIDataSettingsMachineUSBFilter filterData;
     840    filterData.m_fActive = true;
     841    filterData.m_strName = m_strTrUSBFilterName.arg(iMaxFilterIndex + 1);
     842    filterData.m_fHostUSBDevice = false;
    788843
    789844    /* Add new USB filter item: */
    790     addUSBFilterItem(usbFilterData, true /* its new? */);
     845    addUSBFilterItem(filterData, true /* its new? */);
    791846
    792847    /* Revalidate: */
     
    807862
    808863    /* Prepare new USB filter data: */
    809     UIDataSettingsMachineUSBFilter usbFilterData;
    810     usbFilterData.m_fActive = true;
    811     usbFilterData.m_strName = vboxGlobal().details(usb);
    812     usbFilterData.m_fHostUSBDevice = false;
    813     usbFilterData.m_strVendorId = QString().sprintf("%04hX", usb.GetVendorId());
    814     usbFilterData.m_strProductId = QString().sprintf("%04hX", usb.GetProductId());
    815     usbFilterData.m_strRevision = QString().sprintf("%04hX", usb.GetRevision());
     864    UIDataSettingsMachineUSBFilter filterData;
     865    filterData.m_fActive = true;
     866    filterData.m_strName = vboxGlobal().details(usb);
     867    filterData.m_fHostUSBDevice = false;
     868    filterData.m_strVendorId = QString().sprintf("%04hX", usb.GetVendorId());
     869    filterData.m_strProductId = QString().sprintf("%04hX", usb.GetProductId());
     870    filterData.m_strRevision = QString().sprintf("%04hX", usb.GetRevision());
    816871    /* The port property depends on the host computer rather than on the USB
    817872     * device itself; for this reason only a few people will want to use it
     
    819874     * will not match the filter in this case. */
    820875#if 0
    821     usbFilterData.m_strPort = QString().sprintf("%04hX", usb.GetPort());
     876    filterData.m_strPort = QString().sprintf("%04hX", usb.GetPort());
    822877#endif
    823     usbFilterData.m_strManufacturer = usb.GetManufacturer();
    824     usbFilterData.m_strProduct = usb.GetProduct();
    825     usbFilterData.m_strSerialNumber = usb.GetSerialNumber();
    826     usbFilterData.m_strRemote = QString::number(usb.GetRemote());
     878    filterData.m_strManufacturer = usb.GetManufacturer();
     879    filterData.m_strProduct = usb.GetProduct();
     880    filterData.m_strSerialNumber = usb.GetSerialNumber();
     881    filterData.m_strRemote = QString::number(usb.GetRemote());
    827882
    828883    /* Add new USB filter item: */
    829     addUSBFilterItem(usbFilterData, true /* its new? */);
     884    addUSBFilterItem(filterData, true /* its new? */);
    830885
    831886    /* Revalidate: */
     
    860915    if (dlgFilterDetails.exec() == QDialog::Accepted)
    861916    {
    862         pItem->m_strName = dlgFilterDetails.mLeName->text().isEmpty() ? QString::null : dlgFilterDetails.mLeName->text();
    863         pItem->m_strVendorId = dlgFilterDetails.mLeVendorID->text().isEmpty() ? QString::null : dlgFilterDetails.mLeVendorID->text();
    864         pItem->m_strProductId = dlgFilterDetails.mLeProductID->text().isEmpty() ? QString::null : dlgFilterDetails.mLeProductID->text();
    865         pItem->m_strRevision = dlgFilterDetails.mLeRevision->text().isEmpty() ? QString::null : dlgFilterDetails.mLeRevision->text();
    866         pItem->m_strManufacturer = dlgFilterDetails.mLeManufacturer->text().isEmpty() ? QString::null : dlgFilterDetails.mLeManufacturer->text();
    867         pItem->m_strProduct = dlgFilterDetails.mLeProduct->text().isEmpty() ? QString::null : dlgFilterDetails.mLeProduct->text();
    868         pItem->m_strSerialNumber = dlgFilterDetails.mLeSerialNo->text().isEmpty() ? QString::null : dlgFilterDetails.mLeSerialNo->text();
    869         pItem->m_strPort = dlgFilterDetails.mLePort->text().isEmpty() ? QString::null : dlgFilterDetails.mLePort->text();
     917        /* Update edited tree-widget item: */
     918        pItem->m_strName = dlgFilterDetails.mLeName->text().isEmpty() ? QString() : dlgFilterDetails.mLeName->text();
     919        pItem->m_strVendorId = dlgFilterDetails.mLeVendorID->text().isEmpty() ? QString() : dlgFilterDetails.mLeVendorID->text();
     920        pItem->m_strProductId = dlgFilterDetails.mLeProductID->text().isEmpty() ? QString() : dlgFilterDetails.mLeProductID->text();
     921        pItem->m_strRevision = dlgFilterDetails.mLeRevision->text().isEmpty() ? QString() : dlgFilterDetails.mLeRevision->text();
     922        pItem->m_strManufacturer = dlgFilterDetails.mLeManufacturer->text().isEmpty() ? QString() : dlgFilterDetails.mLeManufacturer->text();
     923        pItem->m_strProduct = dlgFilterDetails.mLeProduct->text().isEmpty() ? QString() : dlgFilterDetails.mLeProduct->text();
     924        pItem->m_strSerialNumber = dlgFilterDetails.mLeSerialNo->text().isEmpty() ? QString() : dlgFilterDetails.mLeSerialNo->text();
     925        pItem->m_strPort = dlgFilterDetails.mLePort->text().isEmpty() ? QString() : dlgFilterDetails.mLePort->text();
    870926        switch (dlgFilterDetails.mCbRemote->currentIndex())
    871927        {
     
    885941    AssertPtrReturnVoid(pItem);
    886942
    887     /* Delete corresponding items: */
     943    /* Delete corresponding item: */
    888944    delete pItem;
    889945
Note: See TracChangeset for help on using the changeset viewer.

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