VirtualBox

Ignore:
Timestamp:
Sep 27, 2019 12:20:46 PM (6 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
133653
Message:

FE/Qt: bugref:9582: VM settings / Storage page: Merge ControllerType directly into ControllerItem.

Location:
trunk/src/VBox/Frontends/VirtualBox/src/settings/machine
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Frontends/VirtualBox/src/settings/machine/UIMachineSettingsStorage.cpp

    r81047 r81050  
    381381
    382382
    383 /* Controller Type */
    384 ControllerType::ControllerType (KStorageBus aBusType, KStorageControllerType aCtrType)
    385     : mBusType (aBusType)
    386     , mCtrType (aCtrType)
    387 {
     383/* Abstract Item */
     384AbstractItem::AbstractItem(QITreeView *pParent)
     385    : QITreeViewItem(pParent)
     386    , m_pParentItem(0)
     387    , mId(QUuid::createUuid())
     388{
     389    if (m_pParentItem)
     390        m_pParentItem->addChild(this);
     391}
     392
     393AbstractItem::AbstractItem(AbstractItem *pParentItem)
     394    : QITreeViewItem(pParentItem)
     395    , m_pParentItem(pParentItem)
     396    , mId(QUuid::createUuid())
     397{
     398    if (m_pParentItem)
     399        m_pParentItem->addChild(this);
     400}
     401
     402AbstractItem::~AbstractItem()
     403{
     404    if (m_pParentItem)
     405        m_pParentItem->delChild(this);
     406}
     407
     408AbstractItem* AbstractItem::parent() const
     409{
     410    return m_pParentItem;
     411}
     412
     413QUuid AbstractItem::id() const
     414{
     415    return mId;
     416}
     417
     418QUuid AbstractItem::machineId() const
     419{
     420    return mMachineId;
     421}
     422
     423void AbstractItem::setMachineId (const QUuid &uMachineId)
     424{
     425    mMachineId = uMachineId;
     426}
     427
     428
     429/* Root Item */
     430RootItem::RootItem(QITreeView *pParent)
     431    : AbstractItem(pParent)
     432{
     433}
     434
     435RootItem::~RootItem()
     436{
     437    while (!mControllers.isEmpty())
     438        delete mControllers.first();
     439}
     440
     441ULONG RootItem::childCount (KStorageBus aBus) const
     442{
     443    ULONG result = 0;
     444    foreach (AbstractItem *item, mControllers)
     445    {
     446        ControllerItem *ctrItem = qobject_cast<ControllerItem*>(item);
     447        if (ctrItem->ctrBusType() == aBus)
     448            ++ result;
     449    }
     450    return result;
     451}
     452
     453AbstractItem::ItemType RootItem::rtti() const
     454{
     455    return Type_RootItem;
     456}
     457
     458AbstractItem* RootItem::childItem (int aIndex) const
     459{
     460    return mControllers [aIndex];
     461}
     462
     463AbstractItem* RootItem::childItemById (const QUuid &uId) const
     464{
     465    for (int i = 0; i < childCount(); ++ i)
     466        if (mControllers [i]->id() == uId)
     467            return mControllers [i];
     468    return 0;
     469}
     470
     471int RootItem::posOfChild (AbstractItem *aItem) const
     472{
     473    return mControllers.indexOf (aItem);
     474}
     475
     476int RootItem::childCount() const
     477{
     478    return mControllers.size();
     479}
     480
     481QString RootItem::text() const
     482{
     483    return QString();
     484}
     485
     486QString RootItem::tip() const
     487{
     488    return QString();
     489}
     490
     491QPixmap RootItem::pixmap (ItemState /* aState */)
     492{
     493    return QPixmap();
     494}
     495
     496void RootItem::addChild (AbstractItem *aItem)
     497{
     498    mControllers << aItem;
     499}
     500
     501void RootItem::delChild (AbstractItem *aItem)
     502{
     503    mControllers.removeAll (aItem);
     504}
     505
     506
     507/* Controller Item */
     508ControllerItem::ControllerItem (AbstractItem *aParent, const QString &aName,
     509                                KStorageBus aBusType, KStorageControllerType aControllerType)
     510    : AbstractItem (aParent)
     511    , mBusType (aBusType)
     512    , mCtrType (aControllerType)
     513    , mOldCtrName (aName)
     514    , mCtrName (aName)
     515    , mPortCount (0)
     516    , mUseIoCache (false)
     517{
     518    /* Check for proper parent type */
     519    AssertMsg(m_pParentItem->rtti() == AbstractItem::Type_RootItem, ("Incorrect parent type!\n"));
     520
    388521    AssertMsg (mBusType != KStorageBus_Null, ("Wrong Bus Type {%d}!\n", mBusType));
    389522    AssertMsg (mCtrType != KStorageControllerType_Null, ("Wrong Controller Type {%d}!\n", mCtrType));
    … …  
    392525    updateTypeInfo();
    393526    updatePixmaps();
    394 }
    395 
    396 KStorageBus ControllerType::busType() const
     527
     528    mUseIoCache = uiCommon().virtualBox().GetSystemProperties().GetDefaultIoCacheSettingForStorageController (aControllerType);
     529}
     530
     531ControllerItem::~ControllerItem()
     532{
     533    while (!mAttachments.isEmpty())
     534        delete mAttachments.first();
     535}
     536
     537KStorageBus ControllerItem::ctrBusType() const
    397538{
    398539    return mBusType;
    399540}
    400541
    401 ControllerBusList ControllerType::busTypes() const
     542ControllerBusList ControllerItem::ctrBusTypes() const
    402543{
    403544    return m_buses;
    404545}
    405546
    406 KStorageControllerType ControllerType::ctrType() const
     547QString ControllerItem::oldCtrName() const
     548{
     549    return mOldCtrName;
     550}
     551
     552QString ControllerItem::ctrName() const
     553{
     554    return mCtrName;
     555}
     556
     557KStorageControllerType ControllerItem::ctrType() const
    407558{
    408559    return mCtrType;
    409560}
    410561
    411 ControllerTypeList ControllerType::ctrTypes() const
     562ControllerTypeList ControllerItem::ctrTypes() const
    412563{
    413564    return m_types;
    414565}
    415566
    416 PixmapType ControllerType::pixmap(ItemState aState) const
    417 {
    418     return m_pixmaps.at(aState);
    419 }
    420 
    421 void ControllerType::setCtrBusType(KStorageBus enmCtrBusType)
     567uint ControllerItem::portCount()
     568{
     569    /* Recalculate actual port count: */
     570    for (int i = 0; i < mAttachments.size(); ++i)
     571    {
     572        AttachmentItem *pItem = qobject_cast<AttachmentItem*>(mAttachments.at(i));
     573        if (mPortCount < (uint)pItem->attSlot().port + 1)
     574            mPortCount = (uint)pItem->attSlot().port + 1;
     575    }
     576    return mPortCount;
     577}
     578
     579uint ControllerItem::maxPortCount()
     580{
     581    return (uint)uiCommon().virtualBox().GetSystemProperties().GetMaxPortCountForStorageBus(ctrBusType());
     582}
     583
     584bool ControllerItem::ctrUseIoCache() const
     585{
     586    return mUseIoCache;
     587}
     588
     589void ControllerItem::setCtrBusType(KStorageBus enmCtrBusType)
    422590{
    423591    mBusType = enmCtrBusType;
    … …  
    428596}
    429597
    430 void ControllerType::setCtrType (KStorageControllerType aCtrType)
     598void ControllerItem::setCtrName (const QString &aCtrName)
     599{
     600    mCtrName = aCtrName;
     601}
     602
     603void ControllerItem::setCtrType (KStorageControllerType aCtrType)
    431604{
    432605    mCtrType = aCtrType;
    433606}
    434607
    435 DeviceTypeList ControllerType::deviceTypeList() const
    436 {
    437     return uiCommon().virtualBox().GetSystemProperties().GetDeviceTypesForStorageBus (mBusType).toList();
    438 }
    439 
    440 void ControllerType::updateBusInfo()
     608void ControllerItem::setPortCount (uint aPortCount)
     609{
     610    /* Limit maximum port count: */
     611    mPortCount = qMin(aPortCount, (uint)uiCommon().virtualBox().GetSystemProperties().GetMaxPortCountForStorageBus(ctrBusType()));
     612}
     613
     614void ControllerItem::setCtrUseIoCache (bool aUseIoCache)
     615{
     616    mUseIoCache = aUseIoCache;
     617}
     618
     619SlotsList ControllerItem::ctrAllSlots() const
     620{
     621    SlotsList allSlots;
     622    CSystemProperties sp = uiCommon().virtualBox().GetSystemProperties();
     623    for (ULONG i = 0; i < sp.GetMaxPortCountForStorageBus (ctrBusType()); ++ i)
     624        for (ULONG j = 0; j < sp.GetMaxDevicesPerPortForStorageBus (ctrBusType()); ++ j)
     625            allSlots << StorageSlot (ctrBusType(), i, j);
     626    return allSlots;
     627}
     628
     629SlotsList ControllerItem::ctrUsedSlots() const
     630{
     631    SlotsList usedSlots;
     632    for (int i = 0; i < mAttachments.size(); ++ i)
     633        usedSlots << qobject_cast<AttachmentItem*>(mAttachments.at(i))->attSlot();
     634    return usedSlots;
     635}
     636
     637DeviceTypeList ControllerItem::ctrDeviceTypeList() const
     638{
     639     return uiCommon().virtualBox().GetSystemProperties().GetDeviceTypesForStorageBus (mBusType).toList();
     640}
     641
     642QList<QUuid> ControllerItem::attachmentIDs(KDeviceType enmType /* = KDeviceType_Null */) const
     643{
     644    QList<QUuid> ids;
     645    foreach (AbstractItem *pItem, mAttachments)
     646    {
     647        AttachmentItem *pItemAttachment = qobject_cast<AttachmentItem*>(pItem);
     648        if (   enmType == KDeviceType_Null
     649            || pItemAttachment->attDeviceType() == enmType)
     650            ids << pItem->id();
     651    }
     652    return ids;
     653}
     654
     655AbstractItem::ItemType ControllerItem::rtti() const
     656{
     657    return Type_ControllerItem;
     658}
     659
     660AbstractItem* ControllerItem::childItem (int aIndex) const
     661{
     662    return mAttachments [aIndex];
     663}
     664
     665AbstractItem* ControllerItem::childItemById (const QUuid &uId) const
     666{
     667    for (int i = 0; i < childCount(); ++ i)
     668        if (mAttachments [i]->id() == uId)
     669            return mAttachments [i];
     670    return 0;
     671}
     672
     673int ControllerItem::posOfChild (AbstractItem *aItem) const
     674{
     675    return mAttachments.indexOf (aItem);
     676}
     677
     678int ControllerItem::childCount() const
     679{
     680    return mAttachments.size();
     681}
     682
     683QString ControllerItem::text() const
     684{
     685    return UIMachineSettingsStorage::tr("Controller: %1").arg(ctrName());
     686}
     687
     688QString ControllerItem::tip() const
     689{
     690    return UIMachineSettingsStorage::tr ("<nobr><b>%1</b></nobr><br>"
     691                                 "<nobr>Bus:&nbsp;&nbsp;%2</nobr><br>"
     692                                 "<nobr>Type:&nbsp;&nbsp;%3</nobr>")
     693                                 .arg (mCtrName)
     694                                 .arg (gpConverter->toString (ctrBusType()))
     695                                 .arg (gpConverter->toString (ctrType()));
     696}
     697
     698QPixmap ControllerItem::pixmap (ItemState aState)
     699{
     700    return iconPool()->pixmap(m_pixmaps.at(aState));
     701}
     702
     703void ControllerItem::addChild (AbstractItem *aItem)
     704{
     705    mAttachments << aItem;
     706}
     707
     708void ControllerItem::delChild (AbstractItem *aItem)
     709{
     710    mAttachments.removeAll (aItem);
     711}
     712
     713void ControllerItem::updateBusInfo()
    441714{
    442715    m_buses.clear();
    … …  
    465738}
    466739
    467 void ControllerType::updateTypeInfo()
     740void ControllerItem::updateTypeInfo()
    468741{
    469742    m_types.clear();
    … …  
    503776}
    504777
    505 void ControllerType::updatePixmaps()
     778void ControllerItem::updatePixmaps()
    506779{
    507780    m_pixmaps.clear();
    … …  
    524797        AssertMsg(m_pixmaps[i] != InvalidPixmap, ("Invalid item state pixmap!\n"));
    525798    }
    526 }
    527 
    528 
    529 /* Abstract Item */
    530 AbstractItem::AbstractItem(QITreeView *pParent)
    531     : QITreeViewItem(pParent)
    532     , m_pParentItem(0)
    533     , mId(QUuid::createUuid())
    534 {
    535     if (m_pParentItem)
    536         m_pParentItem->addChild(this);
    537 }
    538 
    539 AbstractItem::AbstractItem(AbstractItem *pParentItem)
    540     : QITreeViewItem(pParentItem)
    541     , m_pParentItem(pParentItem)
    542     , mId(QUuid::createUuid())
    543 {
    544     if (m_pParentItem)
    545         m_pParentItem->addChild(this);
    546 }
    547 
    548 AbstractItem::~AbstractItem()
    549 {
    550     if (m_pParentItem)
    551         m_pParentItem->delChild(this);
    552 }
    553 
    554 AbstractItem* AbstractItem::parent() const
    555 {
    556     return m_pParentItem;
    557 }
    558 
    559 QUuid AbstractItem::id() const
    560 {
    561     return mId;
    562 }
    563 
    564 QUuid AbstractItem::machineId() const
    565 {
    566     return mMachineId;
    567 }
    568 
    569 void AbstractItem::setMachineId (const QUuid &uMachineId)
    570 {
    571     mMachineId = uMachineId;
    572 }
    573 
    574 
    575 /* Root Item */
    576 RootItem::RootItem(QITreeView *pParent)
    577     : AbstractItem(pParent)
    578 {
    579 }
    580 
    581 RootItem::~RootItem()
    582 {
    583     while (!mControllers.isEmpty())
    584         delete mControllers.first();
    585 }
    586 
    587 ULONG RootItem::childCount (KStorageBus aBus) const
    588 {
    589     ULONG result = 0;
    590     foreach (AbstractItem *item, mControllers)
    591     {
    592         ControllerItem *ctrItem = qobject_cast<ControllerItem*>(item);
    593         if (ctrItem->ctrBusType() == aBus)
    594             ++ result;
    595     }
    596     return result;
    597 }
    598 
    599 AbstractItem::ItemType RootItem::rtti() const
    600 {
    601     return Type_RootItem;
    602 }
    603 
    604 AbstractItem* RootItem::childItem (int aIndex) const
    605 {
    606     return mControllers [aIndex];
    607 }
    608 
    609 AbstractItem* RootItem::childItemById (const QUuid &uId) const
    610 {
    611     for (int i = 0; i < childCount(); ++ i)
    612         if (mControllers [i]->id() == uId)
    613             return mControllers [i];
    614     return 0;
    615 }
    616 
    617 int RootItem::posOfChild (AbstractItem *aItem) const
    618 {
    619     return mControllers.indexOf (aItem);
    620 }
    621 
    622 int RootItem::childCount() const
    623 {
    624     return mControllers.size();
    625 }
    626 
    627 QString RootItem::text() const
    628 {
    629     return QString();
    630 }
    631 
    632 QString RootItem::tip() const
    633 {
    634     return QString();
    635 }
    636 
    637 QPixmap RootItem::pixmap (ItemState /* aState */)
    638 {
    639     return QPixmap();
    640 }
    641 
    642 void RootItem::addChild (AbstractItem *aItem)
    643 {
    644     mControllers << aItem;
    645 }
    646 
    647 void RootItem::delChild (AbstractItem *aItem)
    648 {
    649     mControllers.removeAll (aItem);
    650 }
    651 
    652 
    653 /* Controller Item */
    654 ControllerItem::ControllerItem (AbstractItem *aParent, const QString &aName,
    655                                 KStorageBus aBusType, KStorageControllerType aControllerType)
    656     : AbstractItem (aParent)
    657     , mOldCtrName (aName)
    658     , mCtrName (aName)
    659     , mCtrType (0)
    660     , mPortCount (0)
    661     , mUseIoCache (false)
    662 {
    663     /* Check for proper parent type */
    664     AssertMsg(m_pParentItem->rtti() == AbstractItem::Type_RootItem, ("Incorrect parent type!\n"));
    665 
    666     /* Select default type */
    667     switch (aBusType)
    668     {
    669         case KStorageBus_IDE:
    670             mCtrType = new ControllerType(KStorageBus_IDE, aControllerType);
    671             break;
    672         case KStorageBus_SATA:
    673             mCtrType = new ControllerType(KStorageBus_SATA, aControllerType);
    674             break;
    675         case KStorageBus_SCSI:
    676             mCtrType = new ControllerType(KStorageBus_SCSI, aControllerType);
    677             break;
    678         case KStorageBus_Floppy:
    679             mCtrType = new ControllerType(KStorageBus_Floppy, aControllerType);
    680             break;
    681         case KStorageBus_SAS:
    682             mCtrType = new ControllerType(KStorageBus_SAS, aControllerType);
    683             break;
    684         case KStorageBus_USB:
    685             mCtrType = new ControllerType(KStorageBus_USB, aControllerType);
    686             break;
    687         case KStorageBus_PCIe:
    688             mCtrType = new ControllerType(KStorageBus_PCIe, aControllerType);
    689             break;
    690         case KStorageBus_VirtioSCSI:
    691             mCtrType = new ControllerType(KStorageBus_VirtioSCSI, aControllerType);
    692             break;
    693 
    694         default:
    695             AssertMsgFailed (("Wrong Controller Type {%d}!\n", aBusType));
    696             break;
    697     }
    698 
    699     mUseIoCache = uiCommon().virtualBox().GetSystemProperties().GetDefaultIoCacheSettingForStorageController (aControllerType);
    700 }
    701 
    702 ControllerItem::~ControllerItem()
    703 {
    704     delete mCtrType;
    705     while (!mAttachments.isEmpty())
    706         delete mAttachments.first();
    707 }
    708 
    709 KStorageBus ControllerItem::ctrBusType() const
    710 {
    711     return mCtrType->busType();
    712 }
    713 
    714 ControllerBusList ControllerItem::ctrBusTypes() const
    715 {
    716     return mCtrType->busTypes();
    717 }
    718 
    719 QString ControllerItem::oldCtrName() const
    720 {
    721     return mOldCtrName;
    722 }
    723 
    724 QString ControllerItem::ctrName() const
    725 {
    726     return mCtrName;
    727 }
    728 
    729 KStorageControllerType ControllerItem::ctrType() const
    730 {
    731     return mCtrType->ctrType();
    732 }
    733 
    734 ControllerTypeList ControllerItem::ctrTypes() const
    735 {
    736     return mCtrType->ctrTypes();
    737 }
    738 
    739 uint ControllerItem::portCount()
    740 {
    741     /* Recalculate actual port count: */
    742     for (int i = 0; i < mAttachments.size(); ++i)
    743     {
    744         AttachmentItem *pItem = qobject_cast<AttachmentItem*>(mAttachments.at(i));
    745         if (mPortCount < (uint)pItem->attSlot().port + 1)
    746             mPortCount = (uint)pItem->attSlot().port + 1;
    747     }
    748     return mPortCount;
    749 }
    750 
    751 uint ControllerItem::maxPortCount()
    752 {
    753     return (uint)uiCommon().virtualBox().GetSystemProperties().GetMaxPortCountForStorageBus(ctrBusType());
    754 }
    755 
    756 bool ControllerItem::ctrUseIoCache() const
    757 {
    758     return mUseIoCache;
    759 }
    760 
    761 void ControllerItem::setCtrBusType(KStorageBus enmCtrBusType)
    762 {
    763     mCtrType->setCtrBusType(enmCtrBusType);
    764 }
    765 
    766 void ControllerItem::setCtrName (const QString &aCtrName)
    767 {
    768     mCtrName = aCtrName;
    769 }
    770 
    771 void ControllerItem::setCtrType (KStorageControllerType aCtrType)
    772 {
    773     mCtrType->setCtrType (aCtrType);
    774 }
    775 
    776 void ControllerItem::setPortCount (uint aPortCount)
    777 {
    778     /* Limit maximum port count: */
    779     mPortCount = qMin(aPortCount, (uint)uiCommon().virtualBox().GetSystemProperties().GetMaxPortCountForStorageBus(ctrBusType()));
    780 }
    781 
    782 void ControllerItem::setCtrUseIoCache (bool aUseIoCache)
    783 {
    784     mUseIoCache = aUseIoCache;
    785 }
    786 
    787 SlotsList ControllerItem::ctrAllSlots() const
    788 {
    789     SlotsList allSlots;
    790     CSystemProperties sp = uiCommon().virtualBox().GetSystemProperties();
    791     for (ULONG i = 0; i < sp.GetMaxPortCountForStorageBus (mCtrType->busType()); ++ i)
    792         for (ULONG j = 0; j < sp.GetMaxDevicesPerPortForStorageBus (mCtrType->busType()); ++ j)
    793             allSlots << StorageSlot (mCtrType->busType(), i, j);
    794     return allSlots;
    795 }
    796 
    797 SlotsList ControllerItem::ctrUsedSlots() const
    798 {
    799     SlotsList usedSlots;
    800     for (int i = 0; i < mAttachments.size(); ++ i)
    801         usedSlots << qobject_cast<AttachmentItem*>(mAttachments.at(i))->attSlot();
    802     return usedSlots;
    803 }
    804 
    805 DeviceTypeList ControllerItem::ctrDeviceTypeList() const
    806 {
    807      return mCtrType->deviceTypeList();
    808 }
    809 
    810 QList<QUuid> ControllerItem::attachmentIDs(KDeviceType enmType /* = KDeviceType_Null */) const
    811 {
    812     QList<QUuid> ids;
    813     foreach (AbstractItem *pItem, mAttachments)
    814     {
    815         AttachmentItem *pItemAttachment = qobject_cast<AttachmentItem*>(pItem);
    816         if (   enmType == KDeviceType_Null
    817             || pItemAttachment->attDeviceType() == enmType)
    818             ids << pItem->id();
    819     }
    820     return ids;
    821 }
    822 
    823 AbstractItem::ItemType ControllerItem::rtti() const
    824 {
    825     return Type_ControllerItem;
    826 }
    827 
    828 AbstractItem* ControllerItem::childItem (int aIndex) const
    829 {
    830     return mAttachments [aIndex];
    831 }
    832 
    833 AbstractItem* ControllerItem::childItemById (const QUuid &uId) const
    834 {
    835     for (int i = 0; i < childCount(); ++ i)
    836         if (mAttachments [i]->id() == uId)
    837             return mAttachments [i];
    838     return 0;
    839 }
    840 
    841 int ControllerItem::posOfChild (AbstractItem *aItem) const
    842 {
    843     return mAttachments.indexOf (aItem);
    844 }
    845 
    846 int ControllerItem::childCount() const
    847 {
    848     return mAttachments.size();
    849 }
    850 
    851 QString ControllerItem::text() const
    852 {
    853     return UIMachineSettingsStorage::tr("Controller: %1").arg(ctrName());
    854 }
    855 
    856 QString ControllerItem::tip() const
    857 {
    858     return UIMachineSettingsStorage::tr ("<nobr><b>%1</b></nobr><br>"
    859                                  "<nobr>Bus:&nbsp;&nbsp;%2</nobr><br>"
    860                                  "<nobr>Type:&nbsp;&nbsp;%3</nobr>")
    861                                  .arg (mCtrName)
    862                                  .arg (gpConverter->toString (mCtrType->busType()))
    863                                  .arg (gpConverter->toString (mCtrType->ctrType()));
    864 }
    865 
    866 QPixmap ControllerItem::pixmap (ItemState aState)
    867 {
    868     return iconPool()->pixmap(mCtrType->pixmap(aState));
    869 }
    870 
    871 void ControllerItem::addChild (AbstractItem *aItem)
    872 {
    873     mAttachments << aItem;
    874 }
    875 
    876 void ControllerItem::delChild (AbstractItem *aItem)
    877 {
    878     mAttachments.removeAll (aItem);
    879799}
    880800

  • trunk/src/VBox/Frontends/VirtualBox/src/settings/machine/UIMachineSettingsStorage.h

    r81047 r81050  
    150150};
    151151
    152 /* Controller Type */
    153 class SHARED_LIBRARY_STUFF ControllerType
    154 {
    155 public:
    156 
    157     ControllerType (KStorageBus aBusType, KStorageControllerType aCtrType);
    158     virtual ~ControllerType() {}
    159 
    160     KStorageBus busType() const;
    161     ControllerBusList busTypes() const;
    162     KStorageControllerType ctrType() const;
    163     ControllerTypeList ctrTypes() const;
    164     PixmapType pixmap(ItemState aState) const;
    165 
    166     void setCtrBusType(KStorageBus enmCtrBusType);
    167     void setCtrType (KStorageControllerType aCtrType);
    168 
    169     DeviceTypeList deviceTypeList() const;
    170 
    171 private:
    172 
    173     void updateBusInfo();
    174     void updateTypeInfo();
    175     void updatePixmaps();
    176 
    177     KStorageBus mBusType;
    178     KStorageControllerType mCtrType;
    179 
    180     ControllerBusList   m_buses;
    181     ControllerTypeList  m_types;
    182     QList<PixmapType>   m_pixmaps;
    183 };
    184 
    185152/* Abstract Item */
    186153class SHARED_LIBRARY_STUFF AbstractItem : public QITreeViewItem
    … …  
    303270    void delChild (AbstractItem *aItem);
    304271
     272    void updateBusInfo();
     273    void updateTypeInfo();
     274    void updatePixmaps();
     275
     276    KStorageBus mBusType;
     277    KStorageControllerType mCtrType;
     278
     279    ControllerBusList m_buses;
     280    ControllerTypeList m_types;
     281    QList<PixmapType> m_pixmaps;
     282
    305283    QString mOldCtrName;
    306284    QString mCtrName;
    307     ControllerType *mCtrType;
    308285    uint mPortCount;
    309286    bool mUseIoCache;
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