VirtualBox

Changeset 44365 in vbox


Ignore:
Timestamp:
Jan 25, 2013 10:24:45 AM (12 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
83334
Message:

Main: change API. Interface IMedium was touched. Handling enumeration MediumVariant was changed. PR5434.

Location:
trunk/src/VBox
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageDisk.cpp

    r44039 r44365  
    373373    {
    374374        ComPtr<IProgress> progress;
     375        com::SafeArray<MediumVariant_T> l_variants(sizeof(MediumVariant_T)*8);
     376
     377        for (unsigned int i = 0; i < l_variants.size(); ++i)
     378        {
     379            MediumVariant_T temp = DiskVariant;
     380            l_variants [i] = (temp & (1<<i));
     381        }
     382
    375383        if (fBase)
    376             CHECK_ERROR(hardDisk, CreateBaseStorage(size, DiskVariant, progress.asOutParam()));
     384            CHECK_ERROR(hardDisk, CreateBaseStorage(size, ComSafeArrayAsInParam(l_variants), progress.asOutParam()));
    377385        else
    378             CHECK_ERROR(parentHardDisk, CreateDiffStorage(hardDisk, DiskVariant, progress.asOutParam()));
     386            CHECK_ERROR(parentHardDisk, CreateDiffStorage(hardDisk, ComSafeArrayAsInParam(l_variants), progress.asOutParam()));
    379387        if (SUCCEEDED(rc) && progress)
    380388        {
    … …  
    677685
    678686        ComPtr<IProgress> progress;
    679         CHECK_ERROR_BREAK(srcDisk, CloneTo(dstDisk, DiskVariant, NULL, progress.asOutParam()));
     687        com::SafeArray<MediumVariant_T> l_variants(sizeof(MediumVariant_T)*8);
     688
     689        for (unsigned int i = 0; i < l_variants.size(); ++i)
     690        {
     691            MediumVariant_T temp = DiskVariant;
     692            l_variants [i] = (temp & (1<<i));
     693        }
     694
     695        CHECK_ERROR_BREAK(srcDisk, CloneTo(dstDisk, ComSafeArrayAsInParam(l_variants), NULL, progress.asOutParam()));
    680696
    681697        rc = showProgress(progress);
    … …  
    10011017        hardDisk->COMGETTER(Format)(format.asOutParam());
    10021018        RTPrintf("Storage format:       %ls\n", format.raw());
    1003         ULONG variant;
    1004         hardDisk->COMGETTER(Variant)(&variant);
     1019
     1020        com::SafeArray<MediumVariant_T> safeArray_variant;
     1021
     1022        hardDisk->COMGETTER(Variant)(ComSafeArrayAsOutParam(safeArray_variant));
     1023        ULONG variant=0;
     1024        for (size_t i = 0; i < safeArray_variant.size(); i++)
     1025            variant |= safeArray_variant[i];
     1026
    10051027        const char *variantStr = "unknown";
    10061028        switch (variant & ~(MediumVariant_Fixed | MediumVariant_Diff))

  • trunk/src/VBox/Frontends/VirtualBox/src/medium/UIMedium.cpp

    r44113 r44365  
    142142        mHardDiskFormat = mMedium.GetFormat();
    143143        mHardDiskType = vboxGlobal().mediumTypeString (mMedium);
    144         mStorageDetails = gpConverter->toString((KMediumVariant)mMedium.GetVariant());
     144
     145        QVector<KMediumVariant> mediumVariants_QVector = mMedium.GetVariant();
     146        qlonglong mediumVariants_qlonglong = 0;
     147        for (int i = 0; i < mediumVariants_QVector.size(); i++)
     148            mediumVariants_qlonglong |= mediumVariants_QVector[i];
     149
     150        mStorageDetails = gpConverter->toString((KMediumVariant)mediumVariants_qlonglong);
    145151        mIsReadOnly = mMedium.GetReadOnly();
    146152

  • trunk/src/VBox/Frontends/VirtualBox/src/wizards/clonevd/UIWizardCloneVD.cpp

    r41587 r44365  
    7171    }
    7272
     73    QVector<KMediumVariant> l_variants(sizeof(uVariant)*8);
     74
     75    for (int i = 0; i < l_variants.size(); ++i)
     76    {
     77        qulonglong temp = uVariant;
     78        l_variants [i] = (KMediumVariant)(temp & (1<<i));
     79    }
     80
    7381    /* Copy existing virtual-disk to the new virtual-disk: */
    74     progress = sourceVirtualDisk.CloneTo(virtualDisk, uVariant, CMedium());
     82    progress = sourceVirtualDisk.CloneTo(virtualDisk, l_variants, CMedium());
    7583    if (!virtualDisk.isOk())
    7684    {

  • trunk/src/VBox/Frontends/VirtualBox/src/wizards/newvd/UIWizardNewVD.cpp

    r41615 r44365  
    7474    }
    7575
     76    QVector<KMediumVariant> l_variants(sizeof(qulonglong)*8);
     77
     78    for (int i = 0; i < l_variants.size(); ++i)
     79    {
     80        qulonglong temp = uVariant;
     81        l_variants [i] = (KMediumVariant)(temp & (1<<i));
     82    }
     83
    7684    /* Create base storage for the new hard disk: */
    77     progress = virtualDisk.CreateBaseStorage(uSize, uVariant);
     85    progress = virtualDisk.CreateBaseStorage(uSize, l_variants);
     86
    7887    if (!virtualDisk.isOk())
    7988    {

  • trunk/src/VBox/Main/idl/VirtualBox.xidl

    r44340 r44365  
    1203912039  <interface
    1204012040    name="IMedium" extends="$unknown"
    12041     uuid="29989373-b111-4654-8493-2e1176cba890"
     12041    uuid="86fd6208-4c8c-40c2-a4e3-f6b47ac6ef07"
    1204212042    wsmap="managed"
    1204312043    >
    … …  
    1224412244    </attribute>
    1224512245
    12246     <attribute name="variant" type="unsigned long" readonly="yes">
     12246    <attribute name="variant" type="MediumVariant" safearray="yes" readonly="yes">
    1224712247      <desc>
    1224812248        Returns the storage format variant information for this medium
    … …  
    1295512955        <desc>Maximum logical size of the medium in bytes.</desc>
    1295612956      </param>
    12957       <param name="variant" type="unsigned long" dir="in">
     12957      <param name="variant" type="MediumVariant" safearray="yes" dir="in">
    1295812958        <desc>Exact image variant which should be created (as a combination of
    1295912959          <link to="MediumVariant" /> flags).</desc>
    … …  
    1303813038        <desc>Target medium.</desc>
    1303913039      </param>
    13040       <param name="variant" type="unsigned long" dir="in">
     13040      <param name="variant" type="MediumVariant" safearray="yes" dir="in">
    1304113041        <desc>Exact image variant which should be created (as a combination of
    1304213042          <link to="MediumVariant" /> flags).</desc>
    … …  
    1316613166        <desc>Target medium.</desc>
    1316713167      </param>
    13168       <param name="variant" type="unsigned long" dir="in">
     13168      <param name="variant" type="MediumVariant" safearray="yes" dir="in">
    1316913169        <desc>Exact image variant which should be created (as a combination of
    1317013170          <link to="MediumVariant" /> flags).</desc>
    … …  
    1321513215    <desc>Target medium.</desc>
    1321613216    </param>
    13217     <param name="variant" type="unsigned long" dir="in">
    13218     <desc>Exact image variant which should be created (as a combination of
    13219     <link to="MediumVariant" /> flags).</desc>
     13217    <param name="variant" type="MediumVariant" safearray="yes" dir="in">
     13218    <desc><link to="MediumVariant" /> flags).</desc>
    1322013219    </param>
    1322113220    <param name="progress" type="IProgress" dir="return">

  • trunk/src/VBox/Main/include/MediumImpl.h

    r42551 r44365  
    104104    STDMETHOD(COMSETTER(Description))(IN_BSTR aDescription);
    105105    STDMETHOD(COMGETTER(State))(MediumState_T *aState);
    106     STDMETHOD(COMGETTER(Variant))(ULONG *aVariant);
     106    STDMETHOD(COMGETTER(Variant))(ComSafeArrayOut(MediumVariant_T, aVariant));
    107107    STDMETHOD(COMGETTER(Location))(BSTR *aLocation);
    108108    STDMETHOD(COMSETTER(Location))(IN_BSTR aLocation);
    … …  
    145145                             ComSafeArrayIn(IN_BSTR, aValues));
    146146    STDMETHOD(CreateBaseStorage)(LONG64 aLogicalSize,
    147                                  ULONG aVariant,
     147                                 ComSafeArrayIn(MediumVariant_T, aVariant),
    148148                                 IProgress **aProgress);
    149149    STDMETHOD(DeleteStorage)(IProgress **aProgress);
    150150    STDMETHOD(CreateDiffStorage)(IMedium *aTarget,
    151                                  ULONG aVariant,
     151                                 ComSafeArrayIn(MediumVariant_T, aVariant),
    152152                                 IProgress **aProgress);
    153153    STDMETHOD(MergeTo)(IMedium *aTarget, IProgress **aProgress);
    154     STDMETHOD(CloneTo)(IMedium *aTarget, ULONG aVariant,
     154    STDMETHOD(CloneTo)(IMedium *aTarget, ComSafeArrayIn(MediumVariant_T, aVariant),
    155155                        IMedium *aParent, IProgress **aProgress);
    156     STDMETHOD(CloneToBase)(IMedium *aTarget, ULONG aVariant,
     156    STDMETHOD(CloneToBase)(IMedium *aTarget, ComSafeArrayIn(MediumVariant_T, aVariant),
    157157                           IProgress **aProgress);
    158158    STDMETHOD(Compact)(IProgress **aProgress);

  • trunk/src/VBox/Main/src-server/ApplianceImplImport.cpp

    r44039 r44365  
    18701870    if (strSourceOVF.isEmpty())
    18711871    {
     1872        com::SafeArray<MediumVariant_T>  mediumVariant;
     1873        mediumVariant.push_back(MediumVariant_Standard);
    18721874        /* Create a dynamic growing disk image with the given capacity. */
    1873         rc = pTargetHD->CreateBaseStorage(di.iCapacity / _1M, MediumVariant_Standard, ComPtr<IProgress>(pProgress).asOutParam());
     1875        rc = pTargetHD->CreateBaseStorage(di.iCapacity / _1M, ComSafeArrayAsInParam(mediumVariant), ComPtr<IProgress>(pProgress).asOutParam());
    18741876        if (FAILED(rc)) throw rc;
    18751877

  • trunk/src/VBox/Main/src-server/MachineImplCloneVM.cpp

    r44091 r44365  
    10971097                        p->mParent->getDefaultHardDiskFormat(strDefaultFormat);
    10981098                        Bstr bstrSrcFormat(strDefaultFormat);
     1099
    10991100                        ULONG srcVar = MediumVariant_Standard;
     1101                        com::SafeArray <MediumVariant_T> mediumVariant;
     1102
    11001103                        /* Is the source file based? */
    11011104                        if ((uSrcCaps & MediumFormatCapabilities_File) == MediumFormatCapabilities_File)
    … …  
    11051108                            rc = pMedium->COMGETTER(Format)(bstrSrcFormat.asOutParam());
    11061109                            if (FAILED(rc)) throw rc;
    1107                             rc = pMedium->COMGETTER(Variant)(&srcVar);
     1110
     1111                            rc = pMedium->COMGETTER(Variant)(ComSafeArrayAsOutParam(mediumVariant));
    11081112                            if (FAILED(rc)) throw rc;
     1113                            else
     1114                            {
     1115                                for (size_t i = 0; i < mediumVariant.size(); i++)
     1116                                    srcVar |= mediumVariant[i];
     1117                            }
    11091118                        }
    11101119

  • trunk/src/VBox/Main/src-server/MediumImpl.cpp

    r44320 r44365  
    15321532}
    15331533
    1534 STDMETHODIMP Medium::COMGETTER(Variant)(ULONG *aVariant)
    1535 {
    1536     CheckComArgOutPointerValid(aVariant);
     1534STDMETHODIMP Medium::COMGETTER(Variant)(ComSafeArrayOut(MediumVariant_T, aVariant))
     1535{
     1536    CheckComArgOutSafeArrayPointerValid(aVariant);
    15371537
    15381538    AutoCaller autoCaller(this);
    … …  
    15401540
    15411541    AutoReadLock alock(this COMMA_LOCKVAL_SRC_POS);
    1542     *aVariant = m->variant;
     1542
     1543    SafeArray<MediumVariant_T> variants(sizeof(MediumVariant_T)*8);
     1544
     1545    for (unsigned int i = 0; i < variants.size(); ++i)
     1546    {
     1547        MediumVariant_T temp = m->variant;
     1548        variants [i] = (temp & (1<<i));
     1549    }
     1550
     1551    variants.detachTo(ComSafeArrayOutArg(aVariant));
    15431552
    15441553    return S_OK;
    15451554}
    1546 
    15471555
    15481556STDMETHODIMP Medium::COMGETTER(Location)(BSTR *aLocation)
    … …  
    24932501
    24942502STDMETHODIMP Medium::CreateBaseStorage(LONG64 aLogicalSize,
    2495                                        ULONG aVariant,
     2503                                       ComSafeArrayIn(MediumVariant_T, aVariant),
    24962504                                       IProgress **aProgress)
    24972505{
     2506    CheckComArgSafeArrayNotNull(aVariant);
    24982507    CheckComArgOutPointerValid(aProgress);
    24992508    if (aLogicalSize < 0)
    … …  
    25112520        AutoWriteLock alock(this COMMA_LOCKVAL_SRC_POS);
    25122521
    2513         aVariant = (MediumVariant_T)((unsigned)aVariant & (unsigned)~MediumVariant_Diff);
    2514         if (    !(aVariant & MediumVariant_Fixed)
     2522        ULONG mediumVariantFlags = 0;
     2523
     2524        if (aVariant)
     2525        {
     2526            com::SafeArray<MediumVariant_T> variants(ComSafeArrayInArg(aVariant));
     2527            for (size_t i = 0; i < variants.size(); i++)
     2528                mediumVariantFlags |= variants[i];
     2529        }
     2530
     2531        mediumVariantFlags &= ((unsigned)~MediumVariant_Diff);
     2532
     2533        if (    !(mediumVariantFlags & MediumVariant_Fixed)
    25152534            &&  !(m->formatObj->getCapabilities() & MediumFormatCapabilities_CreateDynamic))
    25162535            throw setError(VBOX_E_NOT_SUPPORTED,
    25172536                           tr("Medium format '%s' does not support dynamic storage creation"),
    25182537                           m->strFormat.c_str());
    2519         if (    (aVariant & MediumVariant_Fixed)
     2538
     2539        if (    (mediumVariantFlags & MediumVariant_Fixed)
    25202540            &&  !(m->formatObj->getCapabilities() & MediumFormatCapabilities_CreateDynamic))
    25212541            throw setError(VBOX_E_NOT_SUPPORTED,
    … …  
    25292549        rc = pProgress->init(m->pVirtualBox,
    25302550                             static_cast<IMedium*>(this),
    2531                              (aVariant & MediumVariant_Fixed)
     2551                             (mediumVariantFlags & MediumVariant_Fixed)
    25322552                               ? BstrFmt(tr("Creating fixed medium storage unit '%s'"), m->strLocationFull.c_str()).raw()
    25332553                               : BstrFmt(tr("Creating dynamic medium storage unit '%s'"), m->strLocationFull.c_str()).raw(),
    … …  
    25382558        /* setup task object to carry out the operation asynchronously */
    25392559        pTask = new Medium::CreateBaseTask(this, pProgress, aLogicalSize,
    2540                                            (MediumVariant_T)aVariant);
     2560                                           (MediumVariant_T)mediumVariantFlags);
     2561                                           //(MediumVariant_T)aVariant);
    25412562        rc = pTask->rc();
    25422563        AssertComRC(rc);
    … …  
    25822603
    25832604STDMETHODIMP Medium::CreateDiffStorage(IMedium *aTarget,
    2584                                        ULONG aVariant,
    2585                                        IProgress **aProgress)
     2605                                         ComSafeArrayIn(MediumVariant_T, aVariant),
     2606                                         IProgress **aProgress)
    25862607{
    25872608    CheckComArgNotNull(aTarget);
    25882609    CheckComArgOutPointerValid(aProgress);
     2610    CheckComArgSafeArrayNotNull(aVariant);
    25892611
    25902612    AutoCaller autoCaller(this);
    … …  
    26492671    ComObjPtr <Progress> pProgress;
    26502672
    2651     rc = createDiffStorage(diff, (MediumVariant_T)aVariant, pMediumLockList,
     2673    ULONG mediumVariantFlags = 0;
     2674
     2675    if (aVariant)
     2676    {
     2677        com::SafeArray<MediumVariant_T> variants(ComSafeArrayInArg(aVariant));
     2678        for (size_t i = 0; i < variants.size(); i++)
     2679            mediumVariantFlags |= variants[i];
     2680    }
     2681
     2682    rc = createDiffStorage(diff, (MediumVariant_T)mediumVariantFlags, pMediumLockList,
    26522683                           &pProgress, false /* aWait */);
    26532684    if (FAILED(rc))
    … …  
    26942725
    26952726STDMETHODIMP Medium::CloneToBase(IMedium   *aTarget,
    2696                                  ULONG     aVariant,
    2697                                  IProgress **aProgress)
     2727                                  ComSafeArrayIn(MediumVariant_T, aVariant),
     2728                                  IProgress **aProgress)
    26982729{
    26992730     int rc = S_OK;
    27002731     CheckComArgNotNull(aTarget);
    27012732     CheckComArgOutPointerValid(aProgress);
    2702      rc =  CloneTo(aTarget, aVariant, NULL, aProgress);
     2733     CheckComArgSafeArrayNotNull(aVariant);
     2734
     2735     com::SafeArray<MediumVariant_T> variants(ComSafeArrayInArg(aVariant));
     2736
     2737     rc =  CloneTo(aTarget, ComSafeArrayAsInParam(variants), NULL, aProgress);
    27032738     return rc;
    27042739}
    27052740
    27062741STDMETHODIMP Medium::CloneTo(IMedium *aTarget,
    2707                              ULONG aVariant,
     2742                             ComSafeArrayIn(MediumVariant_T, aVariant),
    27082743                             IMedium *aParent,
    27092744                             IProgress **aProgress)
    … …  
    27112746    CheckComArgNotNull(aTarget);
    27122747    CheckComArgOutPointerValid(aProgress);
     2748    CheckComArgSafeArrayNotNull(aVariant);
     2749
    27132750    ComAssertRet(aTarget != this, E_INVALIDARG);
    27142751
    … …  
    28082845        }
    28092846
     2847        ULONG mediumVariantFlags = 0;
     2848
     2849        if (aVariant)
     2850        {
     2851            com::SafeArray<MediumVariant_T> variants(ComSafeArrayInArg(aVariant));
     2852            for (size_t i = 0; i < variants.size(); i++)
     2853                mediumVariantFlags |= variants[i];
     2854        }
     2855
    28102856        /* setup task object to carry out the operation asynchronously */
    28112857        pTask = new Medium::CloneTask(this, pProgress, pTarget,
    2812                                       (MediumVariant_T)aVariant,
     2858                                      (MediumVariant_T)mediumVariantFlags,
    28132859                                      pParent, UINT32_MAX, UINT32_MAX,
    28142860                                      pSourceMediumLockList, pTargetMediumLockList);
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