VirtualBox

Changeset 50196 in vbox for trunk/src/VBox/Main


Ignore:
Timestamp:
Jan 23, 2014 6:15:23 PM (11 years ago)
Author:
vboxsync
Message:

Main: s/Vbox/VBox/g s/VB/VBox/g

Location:
trunk/src/VBox/Main
Files:
12 edited

Legend:

Unmodified
Added
Removed

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

    r50174 r50196  
    11/* $Id$ */
    2 
    32/** @file
    4  *
    53 * VirtualBox COM class implementation
    64 */
    … …  
    253251    Utf8Str strRef;                         // reference number (hard disk controllers only)
    254252    Utf8Str strOvf;                         // original OVF value (type-dependent)
    255     Utf8Str strVboxSuggested;               // configuration value (type-dependent); original value suggested by interpret()
    256     Utf8Str strVboxCurrent;                 // configuration value (type-dependent); current value, either from interpret() or setFinalValue()
     253    Utf8Str strVBoxSuggested;               // configuration value (type-dependent); original value suggested by interpret()
     254    Utf8Str strVBoxCurrent;                 // configuration value (type-dependent); current value, either from interpret() or setFinalValue()
    257255    Utf8Str strExtraConfigSuggested;        // extra configuration key=value strings (type-dependent); original value suggested by interpret()
    258256    Utf8Str strExtraConfigCurrent;          // extra configuration key=value strings (type-dependent); current value, either from interpret() or setFinalValue()
    … …  
    280278                    const Utf8Str &strRef,
    281279                    const Utf8Str &aOvfValue,
    282                     const Utf8Str &aVboxValue,
     280                    const Utf8Str &aVBoxValue,
    283281                    uint32_t ulSizeMB = 0,
    284282                    const Utf8Str &strExtraConfig = "");
    … …  
    287285    const VirtualSystemDescriptionEntry* i_findControllerFromID(uint32_t id);
    288286
    289     void i_importVboxMachineXML(const xml::ElementNode &elmMachine);
     287    void i_importVBoxMachineXML(const xml::ElementNode &elmMachine);
    290288    const settings::MachineConfigFile* i_getMachineConfig() const;
    291289
    … …  
    325323};
    326324
    327 #endif // ____H_APPLIANCEIMPL
     325#endif // !____H_APPLIANCEIMPL
    328326/* vi: set tabstop=4 shiftwidth=4 expandtab: */

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

    r49749 r50196  
    11/** @file
    2  *
    32 * VirtualBox Appliance private data definitions
    43 */

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

    r47117 r50196  
    8585
    8686int NetIfList(std::list <ComObjPtr<HostNetworkInterface> > &list);
    87 int NetIfEnableStaticIpConfig(VirtualBox *pVbox, HostNetworkInterface * pIf, ULONG aOldIp, ULONG aNewIp, ULONG aMask);
    88 int NetIfEnableStaticIpConfigV6(VirtualBox *pVbox, HostNetworkInterface * pIf, IN_BSTR aOldIPV6Address, IN_BSTR aIPV6Address, ULONG aIPV6MaskPrefixLength);
    89 int NetIfEnableDynamicIpConfig(VirtualBox *pVbox, HostNetworkInterface * pIf);
    90 int NetIfCreateHostOnlyNetworkInterface (VirtualBox *pVbox, IHostNetworkInterface **aHostNetworkInterface, IProgress **aProgress, const char *pcszName = NULL);
    91 int NetIfRemoveHostOnlyNetworkInterface (VirtualBox *pVbox, IN_GUID aId, IProgress **aProgress);
     87int NetIfEnableStaticIpConfig(VirtualBox *pVBox, HostNetworkInterface * pIf, ULONG aOldIp, ULONG aNewIp, ULONG aMask);
     88int NetIfEnableStaticIpConfigV6(VirtualBox *pVBox, HostNetworkInterface * pIf, IN_BSTR aOldIPV6Address, IN_BSTR aIPV6Address, ULONG aIPV6MaskPrefixLength);
     89int NetIfEnableDynamicIpConfig(VirtualBox *pVBox, HostNetworkInterface * pIf);
     90int NetIfCreateHostOnlyNetworkInterface (VirtualBox *pVBox, IHostNetworkInterface **aHostNetworkInterface, IProgress **aProgress, const char *pcszName = NULL);
     91int NetIfRemoveHostOnlyNetworkInterface (VirtualBox *pVBox, IN_GUID aId, IProgress **aProgress);
    9292int NetIfGetConfig(HostNetworkInterface * pIf, NETIFINFO *);
    9393int NetIfGetConfigByName(PNETIFINFO pInfo);
    9494int NetIfGetState(const char *pcszIfName, NETIFSTATUS *penmState);
    9595int NetIfGetLinkSpeed(const char *pcszIfName, uint32_t *puMbits);
    96 int NetIfDhcpRediscover(VirtualBox *pVbox, HostNetworkInterface * pIf);
     96int NetIfDhcpRediscover(VirtualBox *pVBox, HostNetworkInterface * pIf);
    9797int NetIfAdpCtlOut(const char * pcszName, const char * pcszCmd, char *pszBuffer, size_t cBufSize);
    9898

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

    r49029 r50196  
    253253    RTCString strFormat;              // value from DiskSection/Disk/@format
    254254                // typically http://www.vmware.com/interfaces/specifications/vmdk.html#streamOptimized
    255     RTCString uuidVbox;      // optional; if the file was exported by VirtualBox >= 3.2,
     255    RTCString uuidVBox;      // optional; if the file was exported by VirtualBox >= 3.2,
    256256                                    // then this has the UUID with which the disk was registered
    257257
    … …  
    555555    CIMOSType_T         cimos;
    556556    RTCString    strCimosDesc;           // readable description of the cimos type in the case of cimos = 0/1/102
    557     RTCString    strTypeVbox;            // optional type from @vbox:ostype attribute (VirtualBox 4.0 or higher)
     557    RTCString    strTypeVBox;            // optional type from @vbox:ostype attribute (VirtualBox 4.0 or higher)
    558558
    559559    RTCString    strVirtualSystemType;   // generic hardware description; OVF says this can be something like "vmx-4" or "xen";
    … …  
    589589    RTCString    strVendorUrl;           // product info if any; receives contents of VirtualSystem/ProductSection/VendorUrl
    590590
    591     const xml::ElementNode                      // pointer to <vbox:Machine> element under <VirtualSystem> element or NULL if not present
    592                         *pelmVboxMachine;
     591    const xml::ElementNode *pelmVBoxMachine; // pointer to <vbox:Machine> element under <VirtualSystem> element or NULL if not present
    593592
    594593    VirtualSystem()
    … …  
    599598          fHasCdromDrive(false),
    600599          fHasUsbController(false),
    601           pelmVboxMachine(NULL)
     600          pelmVBoxMachine(NULL)
    602601    {
    603602    }

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

    r49951 r50196  
    11/* $Id$ */
    22/** @file
    3  *
    43 * IAppliance and IVirtualSystem COM class implementations.
    54 */
    … …  
    13221321        aRefs[i] = vsde.strRef;
    13231322        aOVFValues[i] = vsde.strOvf;
    1324         aVBoxValues[i] = vsde.strVboxCurrent;
     1323        aVBoxValues[i] = vsde.strVBoxCurrent;
    13251324        aExtraConfigValues[i] = vsde.strExtraConfigCurrent;
    13261325    }
    … …  
    13561355        aRefs[i] = vsde->strRef;
    13571356        aOVFValues[i] = vsde->strOvf;
    1358         aVBoxValues[i] = vsde->strVboxCurrent;
     1357        aVBoxValues[i] = vsde->strVBoxCurrent;
    13591358        aExtraConfigValues[i] = vsde->strExtraConfigCurrent;
    13601359    }
    … …  
    13891388            case VirtualSystemDescriptionValueType_Reference: aValues[i]  = vsde->strRef; break;
    13901389            case VirtualSystemDescriptionValueType_Original: aValues[i]  = vsde->strOvf; break;
    1391             case VirtualSystemDescriptionValueType_Auto: aValues[i]  = vsde->strVboxCurrent; break;
     1390            case VirtualSystemDescriptionValueType_Auto: aValues[i]  = vsde->strVBoxCurrent; break;
    13921391            case VirtualSystemDescriptionValueType_ExtraConfig: aValues[i] = vsde->strExtraConfigCurrent; break;
    13931392        }
    … …  
    14251424        if (aEnabled[i])
    14261425        {
    1427             vsde.strVboxCurrent = aVBoxValues[i];
     1426            vsde.strVBoxCurrent = aVBoxValues[i];
    14281427            vsde.strExtraConfigCurrent = aExtraConfigValues[i];
    14291428        }
    … …  
    14611460                                          const Utf8Str &strRef,
    14621461                                          const Utf8Str &aOvfValue,
    1463                                           const Utf8Str &aVboxValue,
     1462                                          const Utf8Str &aVBoxValue,
    14641463                                          uint32_t ulSizeMB,
    14651464                                          const Utf8Str &strExtraConfig /*= ""*/)
    … …  
    14701469    vsde.strRef = strRef;
    14711470    vsde.strOvf = aOvfValue;
    1472     vsde.strVboxSuggested           // remember original value
    1473         = vsde.strVboxCurrent       // and set current value which can be overridden by setFinalValues()
    1474         = aVboxValue;
     1471    vsde.strVBoxSuggested           // remember original value
     1472        = vsde.strVBoxCurrent       // and set current value which can be overridden by setFinalValues()
     1473        = aVBoxValue;
    14751474    vsde.strExtraConfigSuggested
    14761475        = vsde.strExtraConfigCurrent
    … …  
    15621561 *                  DOM tree.
    15631562 */
    1564 void VirtualSystemDescription::i_importVboxMachineXML(const xml::ElementNode &elmMachine)
     1563void VirtualSystemDescription::i_importVBoxMachineXML(const xml::ElementNode &elmMachine)
    15651564{
    15661565    settings::MachineConfigFile *pConfig = NULL;
    … …  
    15841583
    15851584/**
    1586  * Returns the machine config created by importVboxMachineXML() or NULL if there's none.
     1585 * Returns the machine config created by importVBoxMachineXML() or NULL if there's none.
    15871586 * @return
    15881587 */

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

    r49951 r50196  
    11/* $Id$ */
    22/** @file
    3  *
    43 * IAppliance and IVirtualSystem COM class implementations.
    54 */
    … …  
    212211        if (!pIDEController.isNull())
    213212        {
    214             Utf8Str strVbox;
     213            Utf8Str strVBox;
    215214            StorageControllerType_T ctlr;
    216215            rc = pIDEController->COMGETTER(ControllerType)(&ctlr);
    … …  
    218217            switch(ctlr)
    219218            {
    220                 case StorageControllerType_PIIX3: strVbox = "PIIX3"; break;
    221                 case StorageControllerType_PIIX4: strVbox = "PIIX4"; break;
    222                 case StorageControllerType_ICH6: strVbox = "ICH6"; break;
     219                case StorageControllerType_PIIX3: strVBox = "PIIX3"; break;
     220                case StorageControllerType_PIIX4: strVBox = "PIIX4"; break;
     221                case StorageControllerType_ICH6: strVBox = "ICH6"; break;
    223222            }
    224223
    225             if (strVbox.length())
     224            if (strVBox.length())
    226225            {
    227226                lIDEControllerPrimaryIndex = (int32_t)pNewDesc->m->maDescriptions.size();
    228227                pNewDesc->i_addEntry(VirtualSystemDescriptionType_HardDiskControllerIDE,
    229228                                     Utf8StrFmt("%d", lIDEControllerPrimaryIndex),        // strRef
    230                                      strVbox,     // aOvfValue
    231                                      strVbox);    // aVboxValue
     229                                     strVBox,     // aOvfValue
     230                                     strVBox);    // aVBoxValue
    232231                lIDEControllerSecondaryIndex = lIDEControllerPrimaryIndex + 1;
    233232                pNewDesc->i_addEntry(VirtualSystemDescriptionType_HardDiskControllerIDE,
    234233                                     Utf8StrFmt("%d", lIDEControllerSecondaryIndex),
    235                                      strVbox,
    236                                      strVbox);
     234                                     strVBox,
     235                                     strVBox);
    237236            }
    238237        }
    … …  
    241240        if (!pSATAController.isNull())
    242241        {
    243             Utf8Str strVbox = "AHCI";
     242            Utf8Str strVBox = "AHCI";
    244243            lSATAControllerIndex = (int32_t)pNewDesc->m->maDescriptions.size();
    245244            pNewDesc->i_addEntry(VirtualSystemDescriptionType_HardDiskControllerSATA,
    246245                                 Utf8StrFmt("%d", lSATAControllerIndex),
    247                                  strVbox,
    248                                  strVbox);
     246                                 strVBox,
     247                                 strVBox);
    249248        }
    250249
    … …  
    256255            if (SUCCEEDED(rc))
    257256            {
    258                 Utf8Str strVbox = "LsiLogic";       // the default in VBox
     257                Utf8Str strVBox = "LsiLogic";       // the default in VBox
    259258                switch(ctlr)
    260259                {
    261                     case StorageControllerType_LsiLogic: strVbox = "LsiLogic"; break;
    262                     case StorageControllerType_BusLogic: strVbox = "BusLogic"; break;
     260                    case StorageControllerType_LsiLogic: strVBox = "LsiLogic"; break;
     261                    case StorageControllerType_BusLogic: strVBox = "BusLogic"; break;
    263262                }
    264263                lSCSIControllerIndex = (int32_t)pNewDesc->m->maDescriptions.size();
    265264                pNewDesc->i_addEntry(VirtualSystemDescriptionType_HardDiskControllerSCSI,
    266265                                     Utf8StrFmt("%d", lSCSIControllerIndex),
    267                                      strVbox,
    268                                      strVbox);
     266                                     strVBox,
     267                                     strVBox);
    269268            }
    270269            else
    … …  
    276275            // VirtualBox considers the SAS controller a class of its own but in OVF
    277276            // it should be a SCSI controller
    278             Utf8Str strVbox = "LsiLogicSas";
     277            Utf8Str strVBox = "LsiLogicSas";
    279278            lSCSIControllerIndex = (int32_t)pNewDesc->m->maDescriptions.size();
    280279            pNewDesc->i_addEntry(VirtualSystemDescriptionType_HardDiskControllerSAS,
    281280                                 Utf8StrFmt("%d", lSCSIControllerIndex),
    282                                  strVbox,
    283                                  strVbox);
     281                                 strVBox,
     282                                 strVBox);
    284283        }
    285284
    … …  
    885884
    886885        // source path: where the VBox image is
    887         const Utf8Str &strSrcFilePath = pDiskEntry->strVboxCurrent;
     886        const Utf8Str &strSrcFilePath = pDiskEntry->strVBoxCurrent;
    888887        Bstr bstrSrcFilePath(strSrcFilePath);
    889888
    … …  
    10491048    if (!llName.size())
    10501049        throw setError(VBOX_E_NOT_SUPPORTED, tr("Missing VM name"));
    1051     Utf8Str &strVMName = llName.back()->strVboxCurrent;
     1050    Utf8Str &strVMName = llName.back()->strVBoxCurrent;
    10521051    pelmVirtualSystem->setAttribute("ovf:id", strVMName);
    10531052
    … …  
    10581057    std::list<VirtualSystemDescriptionEntry*> llVendorUrl = vsdescThis->i_findByType(VirtualSystemDescriptionType_VendorUrl);
    10591058    std::list<VirtualSystemDescriptionEntry*> llVersion = vsdescThis->i_findByType(VirtualSystemDescriptionType_Version);
    1060     bool fProduct = llProduct.size() && !llProduct.back()->strVboxCurrent.isEmpty();
    1061     bool fProductUrl = llProductUrl.size() && !llProductUrl.back()->strVboxCurrent.isEmpty();
    1062     bool fVendor = llVendor.size() && !llVendor.back()->strVboxCurrent.isEmpty();
    1063     bool fVendorUrl = llVendorUrl.size() && !llVendorUrl.back()->strVboxCurrent.isEmpty();
    1064     bool fVersion = llVersion.size() && !llVersion.back()->strVboxCurrent.isEmpty();
     1059    bool fProduct = llProduct.size() && !llProduct.back()->strVBoxCurrent.isEmpty();
     1060    bool fProductUrl = llProductUrl.size() && !llProductUrl.back()->strVBoxCurrent.isEmpty();
     1061    bool fVendor = llVendor.size() && !llVendor.back()->strVBoxCurrent.isEmpty();
     1062    bool fVendorUrl = llVendorUrl.size() && !llVendorUrl.back()->strVBoxCurrent.isEmpty();
     1063    bool fVersion = llVersion.size() && !llVersion.back()->strVBoxCurrent.isEmpty();
    10651064    if (fProduct ||
    10661065        fProductUrl ||
    … …  
    10891088        pelmAnnotationSection->createChild("Info")->addContent("Meta-information about the installed software");
    10901089        if (fProduct)
    1091             pelmAnnotationSection->createChild("Product")->addContent(llProduct.back()->strVboxCurrent);
     1090            pelmAnnotationSection->createChild("Product")->addContent(llProduct.back()->strVBoxCurrent);
    10921091        if (fVendor)
    1093             pelmAnnotationSection->createChild("Vendor")->addContent(llVendor.back()->strVboxCurrent);
     1092            pelmAnnotationSection->createChild("Vendor")->addContent(llVendor.back()->strVBoxCurrent);
    10941093        if (fVersion)
    1095             pelmAnnotationSection->createChild("Version")->addContent(llVersion.back()->strVboxCurrent);
     1094            pelmAnnotationSection->createChild("Version")->addContent(llVersion.back()->strVBoxCurrent);
    10961095        if (fProductUrl)
    1097             pelmAnnotationSection->createChild("ProductUrl")->addContent(llProductUrl.back()->strVboxCurrent);
     1096            pelmAnnotationSection->createChild("ProductUrl")->addContent(llProductUrl.back()->strVBoxCurrent);
    10981097        if (fVendorUrl)
    1099             pelmAnnotationSection->createChild("VendorUrl")->addContent(llVendorUrl.back()->strVboxCurrent);
     1098            pelmAnnotationSection->createChild("VendorUrl")->addContent(llVendorUrl.back()->strVBoxCurrent);
    11001099    }
    11011100
    … …  
    11031102    std::list<VirtualSystemDescriptionEntry*> llDescription = vsdescThis->i_findByType(VirtualSystemDescriptionType_Description);
    11041103    if (llDescription.size() &&
    1105         !llDescription.back()->strVboxCurrent.isEmpty())
     1104        !llDescription.back()->strVBoxCurrent.isEmpty())
    11061105    {
    11071106        /*  <Section ovf:required="false" xsi:type="ovf:AnnotationSection_Type">
    … …  
    11201119
    11211120        pelmAnnotationSection->createChild("Info")->addContent("A human-readable annotation");
    1122         pelmAnnotationSection->createChild("Annotation")->addContent(llDescription.back()->strVboxCurrent);
     1121        pelmAnnotationSection->createChild("Annotation")->addContent(llDescription.back()->strVBoxCurrent);
    11231122    }
    11241123
    … …  
    11261125    std::list<VirtualSystemDescriptionEntry*> llLicense = vsdescThis->i_findByType(VirtualSystemDescriptionType_License);
    11271126    if (llLicense.size() &&
    1128         !llLicense.back()->strVboxCurrent.isEmpty())
     1127        !llLicense.back()->strVBoxCurrent.isEmpty())
    11291128    {
    11301129        /* <EulaSection>
    … …  
    11421141
    11431142        pelmEulaSection->createChild("Info")->addContent("License agreement for the virtual system");
    1144         pelmEulaSection->createChild("License")->addContent(llLicense.back()->strVboxCurrent);
     1143        pelmEulaSection->createChild("License")->addContent(llLicense.back()->strVBoxCurrent);
    11451144    }
    11461145
    … …  
    11711170    xml::ElementNode *pelmVBoxOSType = pelmOperatingSystemSection->createChild("vbox:OSType");
    11721171    pelmVBoxOSType->setAttribute("ovf:required", "false");
    1173     pelmVBoxOSType->addContent(pvsdeOS->strVboxCurrent);
     1172    pelmVBoxOSType->addContent(pvsdeOS->strVBoxCurrent);
    11741173
    11751174    // <VirtualHardwareSection ovf:id="hw1" ovf:transport="iso">
    … …  
    12411240            const VirtualSystemDescriptionEntry &desc = *itD;
    12421241
    1243             LogFlowFunc(("Loop %u: handling description entry ulIndex=%u, type=%s, strRef=%s, strOvf=%s, strVbox=%s, strExtraConfig=%s\n",
     1242            LogFlowFunc(("Loop %u: handling description entry ulIndex=%u, type=%s, strRef=%s, strOvf=%s, strVBox=%s, strExtraConfig=%s\n",
    12441243                         uLoop,
    12451244                         desc.ulIndex,
    … …  
    12521251                         desc.strRef.c_str(),
    12531252                         desc.strOvf.c_str(),
    1254                          desc.strVboxCurrent.c_str(),
     1253                         desc.strVBoxCurrent.c_str(),
    12551254                         desc.strExtraConfigCurrent.c_str()));
    12561255
    … …  
    12951294                        strDescription = "Number of virtual CPUs";
    12961295                        type = ovf::ResourceType_Processor; // 3
    1297                         desc.strVboxCurrent.toInt(uTemp);
     1296                        desc.strVBoxCurrent.toInt(uTemp);
    12981297                        lVirtualQuantity = (int32_t)uTemp;
    12991298                        strCaption = Utf8StrFmt("%d virtual CPU", lVirtualQuantity);     // without this ovftool won't eat the item
    … …  
    13151314                        strDescription = "Memory Size";
    13161315                        type = ovf::ResourceType_Memory; // 4
    1317                         desc.strVboxCurrent.toInt(uTemp);
     1316                        desc.strVBoxCurrent.toInt(uTemp);
    13181317                        lVirtualQuantity = (int32_t)(uTemp / _1M);
    13191318                        strAllocationUnits = "MegaBytes";
    … …  
    13351334                        strDescription = "IDE Controller";
    13361335                        type = ovf::ResourceType_IDEController; // 5
    1337                         strResourceSubType = desc.strVboxCurrent;
     1336                        strResourceSubType = desc.strVBoxCurrent;
    13381337
    13391338                        if (!lIDEPrimaryControllerIndex)
    … …  
    13811380                        lBusNumber = 0;
    13821381
    1383                         if (    desc.strVboxCurrent.isEmpty()      // AHCI is the default in VirtualBox
    1384                              || (!desc.strVboxCurrent.compare("ahci", Utf8Str::CaseInsensitive))
     1382                        if (    desc.strVBoxCurrent.isEmpty()      // AHCI is the default in VirtualBox
     1383                             || (!desc.strVBoxCurrent.compare("ahci", Utf8Str::CaseInsensitive))
    13851384                           )
    13861385                            strResourceSubType = "AHCI";
    13871386                        else
    13881387                            throw setError(VBOX_E_NOT_SUPPORTED,
    1389                                             tr("Invalid config string \"%s\" in SATA controller"), desc.strVboxCurrent.c_str());
     1388                                            tr("Invalid config string \"%s\" in SATA controller"), desc.strVBoxCurrent.c_str());
    13901389
    13911390                        // remember this ID
    … …  
    14171416                        lBusNumber = 0;
    14181417
    1419                         if (    desc.strVboxCurrent.isEmpty()      // LsiLogic is the default in VirtualBox
    1420                              || (!desc.strVboxCurrent.compare("lsilogic", Utf8Str::CaseInsensitive))
     1418                        if (    desc.strVBoxCurrent.isEmpty()      // LsiLogic is the default in VirtualBox
     1419                             || (!desc.strVBoxCurrent.compare("lsilogic", Utf8Str::CaseInsensitive))
    14211420                            )
    14221421                            strResourceSubType = "lsilogic";
    1423                         else if (!desc.strVboxCurrent.compare("buslogic", Utf8Str::CaseInsensitive))
     1422                        else if (!desc.strVBoxCurrent.compare("buslogic", Utf8Str::CaseInsensitive))
    14241423                            strResourceSubType = "buslogic";
    1425                         else if (!desc.strVboxCurrent.compare("lsilogicsas", Utf8Str::CaseInsensitive))
     1424                        else if (!desc.strVBoxCurrent.compare("lsilogicsas", Utf8Str::CaseInsensitive))
    14261425                            strResourceSubType = "lsilogicsas";
    14271426                        else
    14281427                            throw setError(VBOX_E_NOT_SUPPORTED,
    1429                                             tr("Invalid config string \"%s\" in SCSI/SAS controller"), desc.strVboxCurrent.c_str());
     1428                                            tr("Invalid config string \"%s\" in SCSI/SAS controller"), desc.strVBoxCurrent.c_str());
    14301429
    14311430                        // remember this ID
    … …  
    15191518
    15201519                        //skip empty Medium. There are no information to add into section <References> or <DiskSection>
    1521                         if (desc.strVboxCurrent.isNotEmpty())
     1520                        if (desc.strVBoxCurrent.isNotEmpty())
    15221521                        {
    15231522                            // the following references the "<Disks>" XML block
    … …  
    15771576                            * PCNet32 for our PCNet types & E1000 for the
    15781577                            * E1000 cards. */
    1579                         switch (desc.strVboxCurrent.toInt32())
     1578                        switch (desc.strVBoxCurrent.toInt32())
    15801579                        {
    15811580                            case NetworkAdapterType_Am79C970A:
    … …  
    18311830        // write the machine config to the vbox:Machine element
    18321831        pConfig->buildMachineXML(*pelmVBoxMachine,
    1833                                    settings::MachineConfigFile::BuildMachineXML_WriteVboxVersionAttribute
     1832                                   settings::MachineConfigFile::BuildMachineXML_WriteVBoxVersionAttribute
    18341833                                 /*| settings::MachineConfigFile::BuildMachineXML_SkipRemovableMedia*/
    18351834                                 | settings::MachineConfigFile::BuildMachineXML_SuppressSavedState,
    … …  
    20762075
    20772076            // source path: where the VBox image is
    2078             const Utf8Str &strSrcFilePath = pDiskEntry->strVboxCurrent;
     2077            const Utf8Str &strSrcFilePath = pDiskEntry->strVBoxCurrent;
    20792078
    20802079            //skip empty Medium. In common, It's may be empty CD/DVD

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

    r50195 r50196  
    11/* $Id$ */
    22/** @file
    3  *
    43 * IAppliance and IVirtualSystem COM class implementations.
    54 */
    … …  
    155154            // if the virtual system in OVF had a <vbox:Machine> element, have the
    156155            // VirtualBox settings code parse that XML now
    157             if (vsysThis.pelmVboxMachine)
    158                 pNewDesc->i_importVboxMachineXML(*vsysThis.pelmVboxMachine);
     156            if (vsysThis.pelmVBoxMachine)
     157                pNewDesc->i_importVBoxMachineXML(*vsysThis.pelmVBoxMachine);
    159158
    160159            // Guest OS type
    … …  
    163162            Utf8StrFmt strCIMOSType("%RU32", (uint32_t)vsysThis.cimos);
    164163            // 1) If there is a <vbox:Machine>, then use the type from there.
    165             if (   vsysThis.pelmVboxMachine
     164            if (   vsysThis.pelmVBoxMachine
    166165                && pNewDesc->m->pConfig->machineUserData.strOsType.isNotEmpty()
    167166               )
    168167                strOsTypeVBox = pNewDesc->m->pConfig->machineUserData.strOsType;
    169168            // 2) Otherwise, if there is OperatingSystemSection/vbox:OSType, use that one.
    170             else if (vsysThis.strTypeVbox.isNotEmpty())      // OVFReader has found vbox:OSType
    171                 strOsTypeVBox = vsysThis.strTypeVbox;
     169            else if (vsysThis.strTypeVBox.isNotEmpty())      // OVFReader has found vbox:OSType
     170                strOsTypeVBox = vsysThis.strTypeVBox;
    172171            // 3) Otherwise, make a best guess what the vbox type is from the OVF (CIM) OS type.
    173172            else
    … …  
    181180            Utf8Str nameVBox;
    182181            /* If there is a <vbox:Machine>, we always prefer the setting from there. */
    183             if (   vsysThis.pelmVboxMachine
     182            if (   vsysThis.pelmVBoxMachine
    184183                && pNewDesc->m->pConfig->machineUserData.strName.isNotEmpty())
    185184                nameVBox = pNewDesc->m->pConfig->machineUserData.strName;
    … …  
    264263            ULONG cpuCountVBox;
    265264            /* If there is a <vbox:Machine>, we always prefer the setting from there. */
    266             if (   vsysThis.pelmVboxMachine
     265            if (   vsysThis.pelmVBoxMachine
    267266                && pNewDesc->m->pConfig->hardwareMachine.cCPUs)
    268267                cpuCountVBox = pNewDesc->m->pConfig->hardwareMachine.cCPUs;
    … …  
    287286            uint64_t ullMemSizeVBox;
    288287            /* If there is a <vbox:Machine>, we always prefer the setting from there. */
    289             if (   vsysThis.pelmVboxMachine
     288            if (   vsysThis.pelmVBoxMachine
    290289                && pNewDesc->m->pConfig->hardwareMachine.ulMemorySizeMB)
    291290                ullMemSizeVBox = pNewDesc->m->pConfig->hardwareMachine.ulMemorySizeMB;
    … …  
    322321            Utf8Str strSoundCardOrig;
    323322            /* If there is a <vbox:Machine>, we always prefer the setting from there. */
    324             if (   vsysThis.pelmVboxMachine
     323            if (   vsysThis.pelmVBoxMachine
    325324                && pNewDesc->m->pConfig->hardwareMachine.audioAdapter.fEnabled)
    326325            {
    … …  
    344343            /* USB Controller */
    345344            /* If there is a <vbox:Machine>, we always prefer the setting from there. */
    346             if (   (   vsysThis.pelmVboxMachine
     345            if (   (   vsysThis.pelmVBoxMachine
    347346                    && pNewDesc->m->pConfig->hardwareMachine.usbSettings.llUSBControllers.size() > 0)
    348347                || vsysThis.fHasUsbController)
    … …  
    352351            /* Network Controller */
    353352            /* If there is a <vbox:Machine>, we always prefer the setting from there. */
    354             if (vsysThis.pelmVboxMachine)
     353            if (vsysThis.pelmVBoxMachine)
    355354            {
    356355                uint32_t maxNetworkAdapters = Global::getMaxNetworkAdapters(pNewDesc->m->pConfig->hardwareMachine.chipsetType);
    … …  
    464463            bool fFloppy = false;
    465464            bool fDVD = false;
    466             if (vsysThis.pelmVboxMachine)
     465            if (vsysThis.pelmVBoxMachine)
    467466            {
    468467                settings::StorageControllersList &llControllers = pNewDesc->m->pConfig->storageMachine.llStorageControllers;
    … …  
    528527                                                 strControllerID,         // strRef
    529528                                                 hdc.strControllerType,   // aOvfValue
    530                                                  strType);                // aVboxValue
     529                                                 strType);                // aVBoxValue
    531530                        }
    532531                        else
    … …  
    15651564        /*
    15661565         * Restoring original UUID from OVF description file.
    1567          * During import VB creates new UUIDs for imported images and
     1566         * During import VBox creates new UUIDs for imported images and
    15681567         * assigns them to the images. In case of failure we have to restore
    15691568         * the original UUIDs because those new UUIDs are obsolete now and
    … …  
    17991798        /*
    18001799         * Restoring original UUID from OVF description file.
    1801          * During import VB creates new UUIDs for imported images and
     1800         * During import VBox creates new UUIDs for imported images and
    18021801         * assigns them to the images. In case of failure we have to restore
    18031802         * the original UUIDs because those new UUIDs are obsolete now and
    … …  
    26892688            const VirtualSystemDescriptionEntry* pvsys = *nwIt;
    26902689
    2691             const Utf8Str &nwTypeVBox = pvsys->strVboxCurrent;
     2690            const Utf8Str &nwTypeVBox = pvsys->strVBoxCurrent;
    26922691            uint32_t tt1 = RTStrToUInt32(nwTypeVBox.c_str());
    26932692            ComPtr<INetworkAdapter> pNetworkAdapter;
    … …  
    28232822        if (FAILED(rc)) throw rc;
    28242823
    2825         const char *pcszIDEType = vsdeHDCIDE.front()->strVboxCurrent.c_str();
     2824        const char *pcszIDEType = vsdeHDCIDE.front()->strVBoxCurrent.c_str();
    28262825        if (!strcmp(pcszIDEType, "PIIX3"))
    28272826            rc = pController->COMSETTER(ControllerType)(StorageControllerType_PIIX3);
    … …  
    28452844    {
    28462845        ComPtr<IStorageController> pController;
    2847         const Utf8Str &hdcVBox = vsdeHDCSATA.front()->strVboxCurrent;
     2846        const Utf8Str &hdcVBox = vsdeHDCSATA.front()->strVBoxCurrent;
    28482847        if (hdcVBox == "AHCI")
    28492848        {
    … …  
    28702869        StorageBus_T busType = StorageBus_SCSI;
    28712870        StorageControllerType_T controllerType;
    2872         const Utf8Str &hdcVBox = vsdeHDCSCSI.front()->strVboxCurrent;
     2871        const Utf8Str &hdcVBox = vsdeHDCSCSI.front()->strVBoxCurrent;
    28732872        if (hdcVBox == "LsiLogic")
    28742873            controllerType = StorageControllerType_LsiLogic;
    … …  
    31563155                                    /*
    31573156                                     * in this case it's an error because something wrong with OVF description file.
    3158                                      * May be VB imports OVA package with wrong file sequence inside the archive.
     3157                                     * May be VBox imports OVA package with wrong file sequence inside the archive.
    31593158                                     */
    31603159                                    throw setError(E_FAIL,
    … …  
    31943193                ComObjPtr<Medium> pTargetHD;
    31953194
    3196                 Utf8Str savedVboxCurrent = vsdeTargetHD->strVboxCurrent;
     3195                Utf8Str savedVBoxCurrent = vsdeTargetHD->strVBoxCurrent;
    31973196
    31983197                i_importOneDiskImage(diCurrent,
    3199                                      &vsdeTargetHD->strVboxCurrent,
     3198                                     &vsdeTargetHD->strVBoxCurrent,
    32003199                                     pTargetHD,
    32013200                                     stack,
    … …  
    32233222
    32243223                Log(("Attaching disk %s to port %d on device %d\n",
    3225                 vsdeTargetHD->strVboxCurrent.c_str(), mhda.lControllerPort, mhda.lDevice));
     3224                vsdeTargetHD->strVBoxCurrent.c_str(), mhda.lControllerPort, mhda.lDevice));
    32263225
    32273226                ComObjPtr<MediumFormat> mediumFormat;
    … …  
    32413240                    ComPtr<IMedium> dvdImage(pTargetHD);
    32423241
    3243                     rc = mVirtualBox->OpenMedium(Bstr(vsdeTargetHD->strVboxCurrent).raw(),
     3242                    rc = mVirtualBox->OpenMedium(Bstr(vsdeTargetHD->strVBoxCurrent).raw(),
    32443243                                                 DeviceType_DVD,
    32453244                                                 AccessMode_ReadWrite,
    … …  
    32773276
    32783277                /* restore */
    3279                 vsdeTargetHD->strVboxCurrent = savedVboxCurrent;
     3278                vsdeTargetHD->strVBoxCurrent = savedVBoxCurrent;
    32803279
    32813280                ++cImportedDisks;
    … …  
    34593458                    {
    34603459                        it1->fEnabled = true;
    3461                         it1->type = (NetworkAdapterType_T)vsdeNW->strVboxCurrent.toUInt32();
     3460                        it1->type = (NetworkAdapterType_T)vsdeNW->strVBoxCurrent.toUInt32();
    34623461                        break;
    34633462                    }
    … …  
    36473646                        /*
    36483647                         * in this case it's an error because something wrong with OVF description file.
    3649                          * May be VB imports OVA package with wrong file sequence inside the archive.
     3648                         * May be VBox imports OVA package with wrong file sequence inside the archive.
    36503649                         */
    36513650                        throw setError(E_FAIL,
    … …  
    37183717                    {
    37193718                        const ovf::DiskImage &di = itDiskImage->second;
    3720                         d.uuid = Guid(di.uuidVbox);
     3719                        d.uuid = Guid(di.uuidVBox);
    37213720                    }
    37223721                    ++avsdeHDsIt;
    … …  
    37263725                strUuid = d.uuid.toString();
    37273726
    3728                 if (diCurrent.uuidVbox != strUuid)
     3727                if (diCurrent.uuidVBox != strUuid)
    37293728                {
    37303729                    continue;
    … …  
    37343733                 * step 3: import disk
    37353734                 */
    3736                 Utf8Str savedVboxCurrent = vsdeTargetHD->strVboxCurrent;
     3735                Utf8Str savedVBoxCurrent = vsdeTargetHD->strVBoxCurrent;
    37373736                ComObjPtr<Medium> pTargetHD;
    37383737                i_importOneDiskImage(diCurrent,
    3739                                      &vsdeTargetHD->strVboxCurrent,
     3738                                     &vsdeTargetHD->strVBoxCurrent,
    37403739                                     pTargetHD,
    37413740                                     stack,
    … …  
    37613760                    ComPtr<IMedium> dvdImage(pTargetHD);
    37623761
    3763                     rc = mVirtualBox->OpenMedium(Bstr(vsdeTargetHD->strVboxCurrent).raw(),
     3762                    rc = mVirtualBox->OpenMedium(Bstr(vsdeTargetHD->strVBoxCurrent).raw(),
    37643763                                                 DeviceType_DVD,
    37653764                                                 AccessMode_ReadWrite,
    … …  
    37833782
    37843783                /* restore */
    3785                 vsdeTargetHD->strVboxCurrent = savedVboxCurrent;
     3784                vsdeTargetHD->strVBoxCurrent = savedVBoxCurrent;
    37863785
    37873786                /*
    … …  
    38993898            throw setError(VBOX_E_FILE_ERROR,
    39003899                           tr("Missing VM name"));
    3901         stack.strNameVBox = vsdeName.front()->strVboxCurrent;
     3900        stack.strNameVBox = vsdeName.front()->strVBoxCurrent;
    39023901
    39033902        // have VirtualBox suggest where the filename would be placed so we can
    … …  
    39213920            throw setError(VBOX_E_FILE_ERROR,
    39223921                           tr("Missing guest OS type"));
    3923         stack.strOsTypeVBox = vsdeOS.front()->strVboxCurrent;
     3922        stack.strOsTypeVBox = vsdeOS.front()->strVBoxCurrent;
    39243923
    39253924        // CPU count
    … …  
    39283927            throw setError(VBOX_E_FILE_ERROR, tr("CPU count missing"));
    39293928
    3930         stack.cCPUs = vsdeCPU.front()->strVboxCurrent.toUInt32();
     3929        stack.cCPUs = vsdeCPU.front()->strVBoxCurrent.toUInt32();
    39313930        // We need HWVirt & IO-APIC if more than one CPU is requested
    39323931        if (stack.cCPUs > 1)
    … …  
    39403939        if (vsdeRAM.size() != 1)
    39413940            throw setError(VBOX_E_FILE_ERROR, tr("RAM size missing"));
    3942         stack.ulMemorySizeMB = (ULONG)vsdeRAM.front()->strVboxCurrent.toUInt64();
     3941        stack.ulMemorySizeMB = (ULONG)vsdeRAM.front()->strVBoxCurrent.toUInt64();
    39433942
    39443943#ifdef VBOX_WITH_USB
    … …  
    39533952        /* @todo: we support one audio adapter only */
    39543953        if (vsdeAudioAdapter.size() > 0)
    3955             stack.strAudioAdapter = vsdeAudioAdapter.front()->strVboxCurrent;
     3954            stack.strAudioAdapter = vsdeAudioAdapter.front()->strVBoxCurrent;
    39563955
    39573956        // for the description of the new machine, always use the OVF entry, the user may have changed it in the import config
    39583957        std::list<VirtualSystemDescriptionEntry*> vsdeDescription = vsdescThis->i_findByType(VirtualSystemDescriptionType_Description);
    39593958        if (vsdeDescription.size())
    3960             stack.strDescription = vsdeDescription.front()->strVboxCurrent;
     3959            stack.strDescription = vsdeDescription.front()->strVBoxCurrent;
    39613960
    39623961        // import vbox:machine or OVF now

  • trunk/src/VBox/Main/src-server/generic/NetIf-generic.cpp

    r50174 r50196  
    364364}
    365365
    366 int NetIfDhcpRediscover(VirtualBox * /* pVbox */, HostNetworkInterface * /* pIf */)
     366int NetIfDhcpRediscover(VirtualBox * /* pVBox */, HostNetworkInterface * /* pIf */)
    367367{
    368368    return VERR_NOT_IMPLEMENTED;

  • trunk/src/VBox/Main/src-server/os2/NetIf-os2.cpp

    r44529 r50196  
    3434}
    3535
    36 int NetIfEnableStaticIpConfig(VirtualBox *pVbox, HostNetworkInterface * pIf, ULONG ip, ULONG mask)
     36int NetIfEnableStaticIpConfig(VirtualBox *pVBox, HostNetworkInterface * pIf, ULONG ip, ULONG mask)
    3737{
    3838    return VERR_NOT_IMPLEMENTED;
    3939}
    4040
    41 int NetIfEnableStaticIpConfigV6(VirtualBox *pVbox, HostNetworkInterface * pIf, IN_BSTR aIPV6Address, ULONG aIPV6MaskPrefixLength)
     41int NetIfEnableStaticIpConfigV6(VirtualBox *pVBox, HostNetworkInterface * pIf, IN_BSTR aIPV6Address, ULONG aIPV6MaskPrefixLength)
    4242{
    4343    return VERR_NOT_IMPLEMENTED;
    4444}
    4545
    46 int NetIfEnableDynamicIpConfig(VirtualBox *pVbox, HostNetworkInterface * pIf)
     46int NetIfEnableDynamicIpConfig(VirtualBox *pVBox, HostNetworkInterface * pIf)
    4747{
    4848    return VERR_NOT_IMPLEMENTED;
    … …  
    5050
    5151
    52 int NetIfDhcpRediscover(VirtualBox *pVbox, HostNetworkInterface * pIf)
     52int NetIfDhcpRediscover(VirtualBox *pVBox, HostNetworkInterface * pIf)
    5353{
    5454    return VERR_NOT_IMPLEMENTED;
    5555}
     56

  • trunk/src/VBox/Main/testcase/tstOVF.cpp

    r50117 r50196  
    116116        com::SafeArray<BSTR> aRefs;
    117117        com::SafeArray<BSTR> aOvfValues;
    118         com::SafeArray<BSTR> aVboxValues;
     118        com::SafeArray<BSTR> aVBoxValues;
    119119        com::SafeArray<BSTR> aExtraConfigValues;
    120120        rc = pVSys->GetDescription(ComSafeArrayAsOutParam(aTypes),
    121121                                   ComSafeArrayAsOutParam(aRefs),
    122122                                   ComSafeArrayAsOutParam(aOvfValues),
    123                                    ComSafeArrayAsOutParam(aVboxValues),
     123                                   ComSafeArrayAsOutParam(aVBoxValues),
    124124                                   ComSafeArrayAsOutParam(aExtraConfigValues));
    125125        if (FAILED(rc)) throw MyError(rc, "VirtualSystemDescription::GetDescription() failed\n");
    … …  
    226226                     u, u2, t, pcszType,
    227227                     aOvfValues[u2],
    228                      aVboxValues[u2],
     228                     aVBoxValues[u2],
    229229                     aExtraConfigValues[u2]);
    230230        }

  • trunk/src/VBox/Main/xml/Settings.cpp

    r49983 r50196  
    51255125 *      (when called from OVF).
    51265126 *
    5127  *  --  BuildMachineXML_WriteVboxVersionAttribute: If set, add a settingsVersion
     5127 *  --  BuildMachineXML_WriteVBoxVersionAttribute: If set, add a settingsVersion
    51285128 *      attribute to the machine tag with the vbox settings version. This is for
    51295129 *      the OVF export case in which we don't have the settings version set in
    … …  
    51495149                                        std::list<xml::ElementNode*> *pllElementsWithUuidAttributes)
    51505150{
    5151     if (fl & BuildMachineXML_WriteVboxVersionAttribute)
     5151    if (fl & BuildMachineXML_WriteVBoxVersionAttribute)
    51525152        // add settings version attribute to machine element
    51535153        setVersionAttribute(elmMachine);
    … …  
    58235823                          MachineConfigFile::BuildMachineXML_IncludeSnapshots
    58245824                        | MachineConfigFile::BuildMachineXML_MediaRegistry,
    5825                             // but not BuildMachineXML_WriteVboxVersionAttribute
     5825                            // but not BuildMachineXML_WriteVBoxVersionAttribute
    58265826                        NULL); /* pllElementsWithUuidAttributes */
    58275827

  • trunk/src/VBox/Main/xml/ovfreader.cpp

    r50148 r50196  
    227227
    228228            // optional vbox:uuid attribute (if OVF was exported by VirtualBox != 3.2)
    229             pelmDisk->getAttributeValue("uuid", d.uuidVbox, "vbox");
     229            pelmDisk->getAttributeValue("uuid", d.uuidVBox, "vbox");
    230230
    231231            const char *pcszFileRef;
    … …  
    331331    // peek under the <VirtualSystem> node whether we have a <vbox:Machine> node;
    332332    // that case case, the caller can completely ignore the OVF but only load the VBox machine XML
    333     vsys.pelmVboxMachine = pelmVirtualSystem->findChildElementNS("vbox", "Machine");
     333    vsys.pelmVBoxMachine = pelmVirtualSystem->findChildElementNS("vbox", "Machine");
    334334
    335335    // now look for real OVF
    … …  
    809809            if ((pelmVBoxOSType = pelmThis->findChildElementNS("vbox",            // namespace
    810810                                                               "OSType")))        // element name
    811                 vsys.strTypeVbox = pelmVBoxOSType->getValue();
     811                vsys.strTypeVBox = pelmVBoxOSType->getValue();
    812812        }
    813813        else if (    (!strcmp(pcszElemName, "AnnotationSection"))
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