VirtualBox

Changeset 22173 in vbox for trunk/src/VBox/Frontends


Ignore:
Timestamp:
Aug 11, 2009 3:38:59 PM (15 years ago)
Author:
vboxsync
Message:

Main: the big XML settings rework. Move XML reading/writing out of interface implementation code into separate layer so it can handle individual settings versions in the future.

Location:
trunk/src/VBox/Frontends
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/VBox/Frontends/VBoxManage/VBoxInternalManage.cpp

    r21806 r22173  
    474474    HRESULT hrc = NewUniqueKey(machine, "VBoxInternal/DBGF/loadsyms", KeyStr);
    475475    if (SUCCEEDED(hrc))
    476         hrc = SetString(machine, "VBoxInternal/DBGF/loadsyms", KeyStr, "Filename", pszFilename);
     476        hrc = SetString(machine, "VBoxInternal/DBGF/loadsyms", KeyStr.c_str(), "Filename", pszFilename);
    477477    if (SUCCEEDED(hrc) && argc >= 3)
    478         hrc = SetInt64(machine, "VBoxInternal/DBGF/loadsyms", KeyStr, "Delta", offDelta);
     478        hrc = SetInt64(machine, "VBoxInternal/DBGF/loadsyms", KeyStr.c_str(), "Delta", offDelta);
    479479    if (SUCCEEDED(hrc) && argc >= 4)
    480         hrc = SetString(machine, "VBoxInternal/DBGF/loadsyms", KeyStr, "Module", pszModule);
     480        hrc = SetString(machine, "VBoxInternal/DBGF/loadsyms", KeyStr.c_str(), "Module", pszModule);
    481481    if (SUCCEEDED(hrc) && argc >= 5)
    482         hrc = SetUInt64(machine, "VBoxInternal/DBGF/loadsyms", KeyStr, "ModuleAddress", ModuleAddress);
     482        hrc = SetUInt64(machine, "VBoxInternal/DBGF/loadsyms", KeyStr.c_str(), "ModuleAddress", ModuleAddress);
    483483    if (SUCCEEDED(hrc) && argc >= 6)
    484         hrc = SetUInt64(machine, "VBoxInternal/DBGF/loadsyms", KeyStr, "ModuleSize", ModuleSize);
     484        hrc = SetUInt64(machine, "VBoxInternal/DBGF/loadsyms", KeyStr.c_str(), "ModuleSize", ModuleSize);
    485485
    486486    return FAILED(hrc);
  • trunk/src/VBox/Frontends/VBoxManage/VBoxManage.cpp

    r21769 r22173  
    12671267        if (!strcmp(a->argv[1], "enumerate"))
    12681268        {
    1269             Bstr extraDataKey;
    1270 
    1271             do
    1272             {
    1273                 Bstr nextExtraDataKey;
    1274                 Bstr nextExtraDataValue;
    1275                 HRESULT rcEnum = a->virtualBox->GetNextExtraDataKey(extraDataKey, nextExtraDataKey.asOutParam(),
    1276                                                                     nextExtraDataValue.asOutParam());
    1277                 extraDataKey = nextExtraDataKey;
    1278 
    1279                 if (SUCCEEDED(rcEnum) && !extraDataKey.isEmpty())
    1280                     RTPrintf("Key: %lS, Value: %lS\n", nextExtraDataKey.raw(), nextExtraDataValue.raw());
    1281             } while (!extraDataKey.isEmpty());
     1269            SafeArray<BSTR> aKeys;
     1270            CHECK_ERROR(a->virtualBox, GetExtraDataKeys(ComSafeArrayAsOutParam(aKeys)));
     1271
     1272            for (size_t i = 0;
     1273                 i < aKeys.size();
     1274                 ++i)
     1275            {
     1276                Bstr bstrKey(aKeys[i]);
     1277                Bstr bstrValue;
     1278                CHECK_ERROR(a->virtualBox, GetExtraData(bstrKey, bstrValue.asOutParam()));
     1279
     1280                RTPrintf("Key: %lS, Value: %lS\n", bstrKey.raw(), bstrValue.raw());
     1281            }
    12821282        }
    12831283        else
     
    13061306            if (!strcmp(a->argv[1], "enumerate"))
    13071307            {
    1308                 Bstr extraDataKey;
    1309 
    1310                 do
    1311                 {
    1312                     Bstr nextExtraDataKey;
    1313                     Bstr nextExtraDataValue;
    1314                     HRESULT rcEnum = machine->GetNextExtraDataKey(extraDataKey, nextExtraDataKey.asOutParam(),
    1315                                                                   nextExtraDataValue.asOutParam());
    1316                     extraDataKey = nextExtraDataKey;
    1317 
    1318                     if (SUCCEEDED(rcEnum) && !extraDataKey.isEmpty())
    1319                     {
    1320                         RTPrintf("Key: %lS, Value: %lS\n", nextExtraDataKey.raw(), nextExtraDataValue.raw());
    1321                     }
    1322                 } while (!extraDataKey.isEmpty());
     1308                SafeArray<BSTR> aKeys;
     1309                CHECK_ERROR(machine, GetExtraDataKeys(ComSafeArrayAsOutParam(aKeys)));
     1310
     1311                for (size_t i = 0;
     1312                    i < aKeys.size();
     1313                    ++i)
     1314                {
     1315                    Bstr bstrKey(aKeys[i]);
     1316                    Bstr bstrValue;
     1317                    CHECK_ERROR(machine, GetExtraData(bstrKey, bstrValue.asOutParam()));
     1318
     1319                    RTPrintf("Key: %lS, Value: %lS\n", bstrKey.raw(), bstrValue.raw());
     1320                }
    13231321            }
    13241322            else
     
    16971695#endif /* !VBOX_ONLY_DOCS */
    16981696
    1699 enum ConvertSettings
    1700 {
    1701     ConvertSettings_No      = 0,
    1702     ConvertSettings_Yes     = 1,
    1703     ConvertSettings_Backup  = 2,
    1704     ConvertSettings_Ignore  = 3,
    1705 };
    1706 
    1707 #ifndef VBOX_ONLY_DOCS
    1708 /**
    1709  * Checks if any of the settings files were auto-converted and informs the
    1710  * user if so.
    1711  *
    1712  * @return @false if the program should terminate and @true otherwise.
    1713  */
    1714 static bool checkForAutoConvertedSettings (ComPtr<IVirtualBox> virtualBox,
    1715                                            ComPtr<ISession> session,
    1716                                            ConvertSettings fConvertSettings)
    1717 {
    1718     /* return early if nothing to do */
    1719     if (fConvertSettings == ConvertSettings_Ignore)
    1720         return true;
    1721 
    1722     HRESULT rc;
    1723 
    1724     do
    1725     {
    1726         Bstr formatVersion;
    1727         CHECK_ERROR_BREAK(virtualBox, COMGETTER(SettingsFormatVersion) (formatVersion.asOutParam()));
    1728 
    1729         bool isGlobalConverted = false;
    1730         std::list <ComPtr <IMachine> > cvtMachines;
    1731         std::list <Utf8Str> fileList;
    1732         Bstr version;
    1733         Bstr filePath;
    1734 
    1735         com::SafeIfaceArray <IMachine> machines;
    1736         CHECK_ERROR_BREAK(virtualBox, COMGETTER(Machines)(ComSafeArrayAsOutParam (machines)));
    1737 
    1738         for (size_t i = 0; i < machines.size(); ++ i)
    1739         {
    1740             BOOL accessible;
    1741             CHECK_ERROR_BREAK(machines[i], COMGETTER(Accessible) (&accessible));
    1742             if (!accessible)
    1743                 continue;
    1744 
    1745             CHECK_ERROR_BREAK(machines[i], COMGETTER(SettingsFileVersion) (version.asOutParam()));
    1746 
    1747             if (version != formatVersion)
    1748             {
    1749                 cvtMachines.push_back (machines [i]);
    1750                 Bstr filePath;
    1751                 CHECK_ERROR_BREAK(machines[i], COMGETTER(SettingsFilePath) (filePath.asOutParam()));
    1752                 fileList.push_back (Utf8StrFmt ("%ls  (%ls)", filePath.raw(),
    1753                                                 version.raw()));
    1754             }
    1755         }
    1756 
    1757         if (FAILED(rc))
    1758             break;
    1759 
    1760         CHECK_ERROR_BREAK(virtualBox, COMGETTER(SettingsFileVersion) (version.asOutParam()));
    1761         if (version != formatVersion)
    1762         {
    1763             isGlobalConverted = true;
    1764             CHECK_ERROR_BREAK(virtualBox, COMGETTER(SettingsFilePath) (filePath.asOutParam()));
    1765             fileList.push_back (Utf8StrFmt ("%ls  (%ls)", filePath.raw(),
    1766                                             version.raw()));
    1767         }
    1768 
    1769         if (fileList.size() > 0)
    1770         {
    1771             switch (fConvertSettings)
    1772             {
    1773                 case ConvertSettings_No:
    1774                 {
    1775                     RTPrintf (
    1776 "WARNING! The following VirtualBox settings files have been automatically\n"
    1777 "converted to the new settings file format version '%ls':\n"
    1778 "\n",
    1779                               formatVersion.raw());
    1780 
    1781                     for (std::list <Utf8Str>::const_iterator f = fileList.begin();
    1782                          f != fileList.end(); ++ f)
    1783                         RTPrintf ("  %S\n", (*f).raw());
    1784                     RTPrintf (
    1785 "\n"
    1786 "The current command was aborted to prevent overwriting the above settings\n"
    1787 "files with the results of the auto-conversion without your permission.\n"
    1788 "Please put one of the following command line switches to the beginning of\n"
    1789 "the VBoxManage command line and repeat the command:\n"
    1790 "\n"
    1791 "  --convertSettings       - to save all auto-converted files (it will not\n"
    1792 "                            be possible to use these settings files with an\n"
    1793 "                            older version of VirtualBox in the future);\n"
    1794 "  --convertSettingsBackup - to create backup copies of the settings files in\n"
    1795 "                            the old format before saving them in the new format;\n"
    1796 "  --convertSettingsIgnore - to not save the auto-converted settings files.\n"
    1797 "\n"
    1798 "Note that if you use --convertSettingsIgnore, the auto-converted settings files\n"
    1799 "will be implicitly saved in the new format anyway once you change a setting or\n"
    1800 "start a virtual machine, but NO backup copies will be created in this case.\n");
    1801                     return false;
    1802                 }
    1803                 case ConvertSettings_Yes:
    1804                 case ConvertSettings_Backup:
    1805                 {
    1806                     break;
    1807                 }
    1808                 default:
    1809                     AssertFailedReturn (false);
    1810             }
    1811 
    1812             for (std::list <ComPtr <IMachine> >::const_iterator m = cvtMachines.begin();
    1813                  m != cvtMachines.end(); ++ m)
    1814             {
    1815                 Bstr id;
    1816                 CHECK_ERROR_BREAK((*m), COMGETTER(Id) (id.asOutParam()));
    1817 
    1818                 /* open a session for the VM */
    1819                 CHECK_ERROR_BREAK (virtualBox, OpenSession (session, id));
    1820 
    1821                 ComPtr <IMachine> sm;
    1822                 CHECK_ERROR_BREAK(session, COMGETTER(Machine) (sm.asOutParam()));
    1823 
    1824                 Bstr bakFileName;
    1825                 if (fConvertSettings == ConvertSettings_Backup)
    1826                     CHECK_ERROR (sm, SaveSettingsWithBackup (bakFileName.asOutParam()));
    1827                 else
    1828                     CHECK_ERROR (sm, SaveSettings());
    1829 
    1830                 session->Close();
    1831 
    1832                 if (FAILED(rc))
    1833                     break;
    1834             }
    1835 
    1836             if (FAILED(rc))
    1837                 break;
    1838 
    1839             if (isGlobalConverted)
    1840             {
    1841                 Bstr bakFileName;
    1842                 if (fConvertSettings == ConvertSettings_Backup)
    1843                     CHECK_ERROR (virtualBox, SaveSettingsWithBackup (bakFileName.asOutParam()));
    1844                 else
    1845                     CHECK_ERROR (virtualBox, SaveSettings());
    1846             }
    1847 
    1848             if (FAILED(rc))
    1849                 break;
    1850         }
    1851     }
    1852     while (0);
    1853 
    1854     return SUCCEEDED (rc);
    1855 }
    1856 #endif /* !VBOX_ONLY_DOCS */
    1857 
    18581697// main
    18591698///////////////////////////////////////////////////////////////////////////////
     
    18711710    int  iCmdArg;
    18721711
    1873     ConvertSettings fConvertSettings = ConvertSettings_No;
    1874 
    18751712    /* global options */
    18761713    for (int i = 1; i < argc || argc <= iCmd; i++)
     
    19121749            iCmd++;
    19131750        }
    1914         else if (   !strcmp(argv[i], "--convertSettings")
    1915                  || !strcmp(argv[i], "-convertSettings"))
    1916         {
    1917             fConvertSettings = ConvertSettings_Yes;
    1918             iCmd++;
    1919         }
    1920         else if (   !strcmp(argv[i], "--convertSettingsBackup")
    1921                  || !strcmp(argv[i], "-convertSettingsBackup"))
    1922         {
    1923             fConvertSettings = ConvertSettings_Backup;
    1924             iCmd++;
    1925         }
    1926         else if (   !strcmp(argv[i], "--convertSettingsIgnore")
    1927                  || !strcmp(argv[i], "-convertSettingsIgnore"))
    1928         {
    1929             fConvertSettings = ConvertSettings_Ignore;
    1930             iCmd++;
    1931         }
    19321751        else
    19331752        {
     
    20131832    NS_GetMainEventQ(getter_AddRefs(eventQ));
    20141833#endif
    2015 
    2016     if (!checkForAutoConvertedSettings (virtualBox, session, fConvertSettings))
    2017         break;
    20181834
    20191835#ifdef USE_XPCOM_QUEUE
  • trunk/src/VBox/Frontends/VBoxManage/VBoxManageDisk.cpp

    r21806 r22173  
    616616        {
    617617            char szFilenameAbs[RTPATH_MAX] = "";
    618             int vrc = RTPathAbs(Utf8Str(src), szFilenameAbs, sizeof(szFilenameAbs));
     618            int vrc = RTPathAbs(Utf8Str(src).c_str(), szFilenameAbs, sizeof(szFilenameAbs));
    619619            if (RT_FAILURE(vrc))
    620620            {
     
    650650                {
    651651                    char szFilenameAbs[RTPATH_MAX] = "";
    652                     int vrc = RTPathAbs(Utf8Str(dst), szFilenameAbs, sizeof(szFilenameAbs));
     652                    int vrc = RTPathAbs(Utf8Str(dst).c_str(), szFilenameAbs, sizeof(szFilenameAbs));
    653653                    if (RT_FAILURE(vrc))
    654654                    {
  • trunk/src/VBox/Frontends/VBoxSDL/VBoxSDL.cpp

    r21520 r22173  
    771771}
    772772#endif /* VBOXSDL_WITH_X11 */
    773 
    774 enum ConvertSettings
    775 {
    776     ConvertSettings_No      = 0,
    777     ConvertSettings_Yes     = 1,
    778     ConvertSettings_Backup  = 2,
    779     ConvertSettings_Ignore  = 3,
    780 };
    781 
    782 /**
    783  * Checks if any of the settings files were auto-converted and informs the
    784  * user if so.
    785  *
    786  * @return @false if the program should terminate and @true otherwise.
    787  *
    788  * @note The function is taken from VBoxManage.cpp almost unchanged (except the
    789  *       help text).
    790  */
    791 static bool checkForAutoConvertedSettings (ComPtr<IVirtualBox> virtualBox,
    792                                            ComPtr<ISession> session,
    793                                            ConvertSettings fConvertSettings)
    794 {
    795     /* return early if nothing to do */
    796     if (fConvertSettings == ConvertSettings_Ignore)
    797         return true;
    798 
    799     HRESULT rc;
    800 
    801     do
    802     {
    803         Bstr formatVersion;
    804         CHECK_ERROR_BREAK(virtualBox, COMGETTER(SettingsFormatVersion) (formatVersion.asOutParam()));
    805 
    806         bool isGlobalConverted = false;
    807         std::list <ComPtr <IMachine> > cvtMachines;
    808         std::list <Utf8Str> fileList;
    809         Bstr version;
    810         Bstr filePath;
    811 
    812         com::SafeIfaceArray <IMachine> machines;
    813         CHECK_ERROR_BREAK(virtualBox, COMGETTER(Machines)(ComSafeArrayAsOutParam (machines)));
    814 
    815         for (size_t i = 0; i < machines.size(); ++ i)
    816         {
    817             BOOL accessible;
    818             CHECK_ERROR_BREAK(machines[i], COMGETTER(Accessible) (&accessible));
    819             if (!accessible)
    820                 continue;
    821 
    822             CHECK_ERROR_BREAK(machines[i], COMGETTER(SettingsFileVersion) (version.asOutParam()));
    823 
    824             if (version != formatVersion)
    825             {
    826                 cvtMachines.push_back (machines[i]);
    827                 Bstr filePath;
    828                 CHECK_ERROR_BREAK(machines[i], COMGETTER(SettingsFilePath) (filePath.asOutParam()));
    829                 fileList.push_back (Utf8StrFmt ("%ls  (%ls)", filePath.raw(),
    830                                                 version.raw()));
    831             }
    832         }
    833 
    834         if (FAILED(rc))
    835             break;
    836 
    837         CHECK_ERROR_BREAK(virtualBox, COMGETTER(SettingsFileVersion) (version.asOutParam()));
    838         if (version != formatVersion)
    839         {
    840             isGlobalConverted = true;
    841             CHECK_ERROR_BREAK(virtualBox, COMGETTER(SettingsFilePath) (filePath.asOutParam()));
    842             fileList.push_back (Utf8StrFmt ("%ls  (%ls)", filePath.raw(),
    843                                             version.raw()));
    844         }
    845 
    846         if (fileList.size() > 0)
    847         {
    848             switch (fConvertSettings)
    849             {
    850                 case ConvertSettings_No:
    851                 {
    852                     RTPrintf (
    853 "WARNING! The following VirtualBox settings files have been automatically\n"
    854 "converted to the new settings file format version '%ls':\n"
    855 "\n",
    856                               formatVersion.raw());
    857 
    858                     for (std::list <Utf8Str>::const_iterator f = fileList.begin();
    859                          f != fileList.end(); ++ f)
    860                         RTPrintf ("  %S\n", (*f).raw());
    861                     RTPrintf (
    862 "\n"
    863 "The current command was aborted to prevent overwriting the above settings\n"
    864 "files with the results of the auto-conversion without your permission.\n"
    865 "Please add one of the following command line switches to the VBoxSDL command\n"
    866 "line and repeat the command:\n"
    867 "\n"
    868 "  --convertSettings       - to save all auto-converted files (it will not\n"
    869 "                            be possible to use these settings files with an\n"
    870 "                            older version of VirtualBox in the future);\n"
    871 "  --convertSettingsBackup - to create backup copies of the settings files in\n"
    872 "                            the old format before saving them in the new format;\n"
    873 "  --convertSettingsIgnore - to not save the auto-converted settings files.\n"
    874 "\n"
    875 "Note that if you use --convertSettingsIgnore, the auto-converted settings files\n"
    876 "will be implicitly saved in the new format anyway once you change a setting or\n"
    877 "start a virtual machine, but NO backup copies will be created in this case.\n");
    878                     return false;
    879                 }
    880                 case ConvertSettings_Yes:
    881                 case ConvertSettings_Backup:
    882                 {
    883                     break;
    884                 }
    885                 default:
    886                     AssertFailedReturn (false);
    887             }
    888 
    889             for (std::list <ComPtr <IMachine> >::const_iterator m = cvtMachines.begin();
    890                  m != cvtMachines.end(); ++ m)
    891             {
    892                 Bstr id;
    893                 CHECK_ERROR_BREAK((*m), COMGETTER(Id) (id.asOutParam()));
    894 
    895                 /* open a session for the VM */
    896                 CHECK_ERROR_BREAK (virtualBox, OpenSession (session, id));
    897 
    898                 ComPtr <IMachine> sm;
    899                 CHECK_ERROR_BREAK(session, COMGETTER(Machine) (sm.asOutParam()));
    900 
    901                 Bstr bakFileName;
    902                 if (fConvertSettings == ConvertSettings_Backup)
    903                     CHECK_ERROR (sm, SaveSettingsWithBackup (bakFileName.asOutParam()));
    904                 else
    905                     CHECK_ERROR (sm, SaveSettings());
    906 
    907                 session->Close();
    908 
    909                 if (FAILED(rc))
    910                     break;
    911             }
    912 
    913             if (FAILED(rc))
    914                 break;
    915 
    916             if (isGlobalConverted)
    917             {
    918                 Bstr bakFileName;
    919                 if (fConvertSettings == ConvertSettings_Backup)
    920                     CHECK_ERROR (virtualBox, SaveSettingsWithBackup (bakFileName.asOutParam()));
    921                 else
    922                     CHECK_ERROR (virtualBox, SaveSettings());
    923             }
    924 
    925             if (FAILED(rc))
    926                 break;
    927         }
    928     }
    929     while (0);
    930 
    931     return SUCCEEDED (rc);
    932 }
    933773
    934774/** entry point */
     
    11841024    sysInfo->COMGETTER (NetworkAdapterCount) (&NetworkAdapterCount);
    11851025
    1186     ConvertSettings fConvertSettings = ConvertSettings_No;
    1187 
    11881026    // command line argument parsing stuff
    11891027    for (int curArg = 1; curArg < argc; curArg++)
     
    16021440            gHostKeyMod = atoi(argv[curArg]);
    16031441        }
    1604         else if (   !strcmp(argv[curArg], "--convertSettings")
    1605                  || !strcmp(argv[curArg], "-convertSettings"))
    1606             fConvertSettings = ConvertSettings_Yes;
    1607         else if (   !strcmp(argv[curArg], "--convertSettingsBackup")
    1608                  || !strcmp(argv[curArg], "-convertSettingsBackup"))
    1609             fConvertSettings = ConvertSettings_Backup;
    1610         else if (   !strcmp(argv[curArg], "--convertSettingsIgnore")
    1611                  || !strcmp(argv[curArg], "-convertSettingsIgnore"))
    1612             fConvertSettings = ConvertSettings_Ignore;
    16131442        /* just show the help screen */
    16141443        else
     
    16231452    }
    16241453    if (FAILED (rc))
    1625         break;
    1626 
    1627     if (!checkForAutoConvertedSettings (virtualBox, session, fConvertSettings))
    16281454        break;
    16291455
  • trunk/src/VBox/Frontends/VirtualBox/include/VBoxGlobal.h

    r22157 r22173  
    610610#endif
    611611
    612     bool checkForSettingsAutoConversion (bool aAfterRefresh = false);
    613 
    614     bool checkForSettingsAutoConversionAfterRefresh() { return checkForSettingsAutoConversion (true); }
    615 
    616612    CSession openSession (const QString &aId, bool aExisting = false);
    617613
  • trunk/src/VBox/Frontends/VirtualBox/src/VBoxGlobal.cpp

    r22157 r22173  
    21112111
    21122112/**
    2113  * Checks if any of the settings files were auto-converted and informs the user
    2114  * if so. Returns @c false if the user select to exit the application.
    2115  *
    2116  * @param aAfterRefresh @c true to suppress the first simple dialog aExit
    2117  *                      button. Used when calling after the VM refresh.
    2118  */
    2119 bool VBoxGlobal::checkForSettingsAutoConversion (bool aAfterRefresh /* = false */)
    2120 {
    2121     QString currentVersion = mVBox.GetSettingsFormatVersion();
    2122     QList <CMachine> machines;
    2123     bool isGlobalToBeConverted = false;
    2124     QString fileList;
    2125     int maxIndex = 0;
    2126 
    2127     /* Check if VM files need to be converted */
    2128     CMachineVector vec = mVBox.GetMachines();
    2129     for (CMachineVector::ConstIterator m = vec.begin(); m != vec.end(); ++ m)
    2130     {
    2131         if (!m->GetAccessible())
    2132             continue;
    2133 
    2134         QString version = m->GetSettingsFileVersion();
    2135         if (version != currentVersion)
    2136         {
    2137             ++ maxIndex;
    2138             machines.append (*m);
    2139             fileList += QString ("<tr><td><nobr>%1</nobr></td><td>&nbsp;&nbsp;</td>"
    2140                                  "</td><td><nobr><i>%2</i></nobr></td></tr>")
    2141                 .arg (m->GetSettingsFilePath())
    2142                 .arg (version);
    2143         }
    2144     }
    2145 
    2146     /* Check if global file need to be converted */
    2147     if (!aAfterRefresh)
    2148     {
    2149         QString version = mVBox.GetSettingsFileVersion();
    2150         if (version != currentVersion)
    2151         {
    2152             ++ maxIndex;
    2153             isGlobalToBeConverted = true;
    2154             fileList += QString ("<tr><td><nobr>%1</nobr></td><td>&nbsp;&nbsp;</td>"
    2155                                  "</td><td><nobr><i>%2</i></nobr></td></tr>")
    2156                 .arg (mVBox.GetSettingsFilePath())
    2157                 .arg (version);
    2158         }
    2159     }
    2160 
    2161     if (!fileList.isNull())
    2162     {
    2163         fileList = QString ("<table cellspacing=0 cellpadding=0>%1</table>")
    2164                             .arg (fileList);
    2165 
    2166         /* Asking the user about he wants to convert the
    2167          * configuration files or leave it as already is. */
    2168         if (vboxProblem().warnAboutSettingsAutoConversion (
    2169             fileList, aAfterRefresh) == QIMessageBox::Cancel)
    2170             return false;
    2171 
    2172         /* Composing progress dialog */
    2173         QProgressDialog dlg (mainWindow());
    2174         dlg.setCancelButton (0);
    2175         dlg.setWindowModality (Qt::WindowModal);
    2176         dlg.setMinimum (0);
    2177         dlg.setMaximum (maxIndex);
    2178         dlg.setMinimumDuration (2000);
    2179         dlg.setAutoReset (false);
    2180 
    2181         /* Converting VM configuration files */
    2182         foreach (CMachine m, machines)
    2183         {
    2184             dlg.setValue (machines.indexOf (m));
    2185             dlg.setLabelText (tr ("Converting file... (%1/%2)")
    2186                               .arg (machines.indexOf (m) + 1).arg (maxIndex));
    2187 
    2188             CSession session = openSession (m.GetId());
    2189             if (!session.isNull())
    2190             {
    2191                 CMachine sm = session.GetMachine();
    2192                 sm.SaveSettingsWithBackup();
    2193                 if (!sm.isOk())
    2194                     vboxProblem().cannotSaveMachineSettings (sm);
    2195                 session.Close();
    2196             }
    2197         }
    2198 
    2199         /* Converting global configuration file */
    2200         if (isGlobalToBeConverted)
    2201         {
    2202             dlg.setValue (machines.size());
    2203             dlg.setLabelText (tr ("Converting file... (%1/%2)")
    2204                               .arg (machines.size() + 1).arg (maxIndex));
    2205 
    2206             mVBox.SaveSettingsWithBackup();
    2207             if (!mVBox.isOk())
    2208                 vboxProblem().cannotSaveGlobalSettings (mVBox);
    2209         }
    2210 
    2211         dlg.setValue (maxIndex);
    2212         dlg.setLabelText (tr ("Conversion finished!"));
    2213     }
    2214 
    2215     return true;
    2216 }
    2217 
    2218 /**
    22192113 *  Opens a direct session for a machine with the given ID.
    22202114 *  This method does user-friendly error handling (display error messages, etc.).
     
    44844378
    44854379    retranslateUi();
    4486 
    4487     /* Note: the settings conversion check must be done before anything else
    4488      * that may unconditionally overwrite settings files in the new format (like
    4489      * SetExtraData()). But after loading the proper the language. */
    4490     if (!checkForSettingsAutoConversion())
    4491         return;
    44924380
    44934381#ifdef VBOX_GUI_WITH_SYSTRAY
  • trunk/src/VBox/Frontends/VirtualBox/src/VBoxSelectorWnd.cpp

    r21833 r22173  
    11151115                   true /* aDescription */);
    11161116
    1117     if (!oldAccessible && item->accessible() &&
    1118         !vboxGlobal().checkForSettingsAutoConversionAfterRefresh())
     1117    if (!oldAccessible && item->accessible())
    11191118        fileExit();
    11201119}
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