Changeset 103362 in vbox for trunk/src

Timestamp:

Feb 14, 2024 4:50:56 PM (12 months ago)

Author:

vboxsync

Message:

FE/Qt: bugref:10450: Get rid of QRegExp which is a part of Qt5 legacy API; This is necessary to get rid of Qt5 support lib.

Location:

trunk/src/VBox/Frontends/VirtualBox/src

Files:

• converter/UIConverterBackendGlobal.cpp (modified) (3 diffs)
• extensions/QILabel.cpp (modified) (2 diffs)
• extensions/QILabel.h (modified) (2 diffs)
• extensions/QIMessageBox.cpp (modified) (2 diffs)
• extradata/UIExtraDataManager.cpp (modified) (3 diffs)
• globals/UITranslator.cpp (modified) (6 diffs)
• manager/UIVirtualBoxManager.cpp (modified) (3 diffs)
• manager/chooser/UIChooserAbstractModel.cpp (modified) (8 diffs)
• networkmanager/UINetworkManager.cpp (modified) (5 diffs)
• objects/UIRichTextString.cpp (modified) (3 diffs)
• runtime/UIMachineLogic.cpp (modified) (1 diff)
• runtime/UISession.cpp (modified) (3 diffs)
• settings/editors/UILanguageSettingsEditor.cpp (modified) (3 diffs)
• settings/editors/UISharedFoldersEditor.cpp (modified) (2 diffs)
• settings/editors/UIUSBFiltersEditor.cpp (modified) (2 diffs)
• settings/machine/UIMachineSettingsUSB.cpp (modified) (1 diff)
• snapshots/UISnapshotPane.cpp (modified) (2 diffs)
• widgets/UIApplianceEditorWidget.cpp (modified) (3 diffs)
• widgets/UIFilePathSelector.cpp (modified) (2 diffs)
• widgets/UIPortForwardingTable.cpp (modified) (2 diffs)

trunk/src/VBox/Frontends/VirtualBox/src/converter/UIConverterBackendGlobal.cpp

@@ -29 +29 @@
 #include <QApplication>
 #include <QHash>
-#include <QRegExp>
 #include <QRegularExpression>
 
@@ -312 +311 @@
     /* Search for a template index strStorageSlot corresponds to: */
     int iIndex = -1;
-    QRegExp regExp;
+    QRegularExpression re;
+    QRegularExpressionMatch mt;
     for (int i = 0; i < templates.size(); ++i)
     {
-        regExp = QRegExp(i >= 0 && i <= 3 ? templates.value(i) : templates.value(i).arg("(\\d+)"));
-        if (regExp.indexIn(strStorageSlot) != -1)
+        re.setPattern(i >= 0 && i <= 3 ? templates.value(i) : templates.value(i).arg("(\\d+)"));
+        mt = re.match(strStorageSlot);
+        if (mt.hasMatch())
         {
             iIndex = i;
@@ -382 +383 @@
                 break;
             const int iMaxPort = uiCommon().virtualBox().GetPlatformProperties(KPlatformArchitecture_x86).GetMaxPortCountForStorageBus(result.bus);
-            const LONG iPort = regExp.cap(1).toInt();
+            const LONG iPort = mt.captured(1).toInt();
             const LONG iDevice = 0;
             if (iPort < 0 || iPort > iMaxPort)

trunk/src/VBox/Frontends/VirtualBox/src/extensions/QILabel.cpp

@@ -51 +51 @@
 /* static */
 const QRegularExpression QILabel::s_regExpCopy = QRegularExpression("<[^>]*>");
-QRegExp QILabel::s_regExpElide = QRegExp("(<compact\\s+elipsis=\"(start|middle|end)\"?>([^<]*)</compact>)");
+const QRegularExpression QILabel::s_regExpElide = QRegularExpression("(<compact\\s+elipsis=\"(start|middle|end)\"?>([^<]*)</compact>)");
 
 QILabel::QILabel(QWidget *pParent /* = 0 */, Qt::WindowFlags enmFlags /* = Qt::WindowFlags() */)
@@ -323 +323 @@
     {
         /* Search for the compact tag: */
-        if (s_regExpElide.indexIn(strLine) > -1)
+        const QRegularExpressionMatch mt = s_regExpElide.match(strLine);
+        if (mt.hasMatch())
         {
             /* USe the untouchable text to work on: */
             const QString strWork = strLine;
             /* Grep out the necessary info of the regexp: */
-            const QString strCompact   = s_regExpElide.cap(1);
-            const QString strElideMode = s_regExpElide.cap(2);
-            const QString strElide     = s_regExpElide.cap(3);
+            const QString strCompact   = mt.captured(1);
+            const QString strElideMode = mt.captured(2);
+            const QString strElide     = mt.captured(3);
             /* Remove the whole compact tag (also the text): */
             const QString strFlat = removeHtmlTags(QString(strWork).remove(strCompact));

trunk/src/VBox/Frontends/VirtualBox/src/extensions/QILabel.h

@@ -39 +39 @@
 #include <QLabel>
 #include <QRegularExpression>
-#include <QRegExp>
 
 /* GUI includes: */
@@ -142 +141 @@
     static const QRegularExpression s_regExpCopy;
     /** Holds text-elide reg-exp. */
-    static QRegExp                  s_regExpElide;
+    static const QRegularExpression s_regExpElide;
 };
 

trunk/src/VBox/Frontends/VirtualBox/src/extensions/QIMessageBox.cpp

@@ -33 +33 @@
 #include <QMimeData>
 #include <QPushButton>
-#include <QRegExp>
 #include <QRegularExpression>
 #include <QStyle>
@@ -413 +412 @@
     // characters with ellipsiss using the following template:
     // "[50 first symbols]...[50 last symbols]"
-    QRegExp re("[a-zA-Z0-9]{101,}");
-    int iPosition = re.indexIn(strText);
+    const QRegularExpression re("[a-zA-Z0-9]{101,}");
+    QRegularExpressionMatch mt = re.match(strText);
+    int iPosition = mt.capturedStart();
     bool fChangeAllowed = iPosition != -1;
     while (fChangeAllowed)
     {
         QString strNewText = strText;
-        const QString strFound = re.cap(0);
+        const QString strFound = mt.captured();
         strNewText.replace(iPosition, strFound.size(), strFound.left(50) + "..." + strFound.right(50));
         fChangeAllowed = fChangeAllowed && strText != strNewText;
         strText = strNewText;
-        iPosition = re.indexIn(strText);
+        mt = re.match(strText);
+        iPosition = mt.capturedStart();
         fChangeAllowed = fChangeAllowed && iPosition != -1;
     }

trunk/src/VBox/Frontends/VirtualBox/src/extradata/UIExtraDataManager.cpp

@@ -30 +30 @@
 #include <QMetaEnum>
 #include <QMutex>
-#include <QRegExp>
 #include <QRegularExpression>
 #include <QRegularExpressionValidator>
@@ -3157 +3156 @@
     /* Gather a list of keys matching required expression: */
     QStringList result;
-    QRegExp re(QString("^%1/([^/]+)$").arg(GUI_CloudConsoleManager_Application));
+    const QRegularExpression re(QString("^%1/([^/]+)$").arg(GUI_CloudConsoleManager_Application));
     foreach (const QString &strKey, m_data.value(GlobalID).keys())
-        if (re.indexIn(strKey) != -1)
-            result << re.cap(1);
+    {
+        const QRegularExpressionMatch mt = re.match(strKey);
+        if (mt.hasMatch())
+            result << mt.captured(1);
+    }
     return result;
 }
@@ -3168 +3170 @@
     /* Gather a list of keys matching required expression: */
     QStringList result;
-    QRegExp re(QString("^%1/%2/([^/]+)$").arg(GUI_CloudConsoleManager_Application, strId));
+    const QRegularExpression re(QString("^%1/%2/([^/]+)$").arg(GUI_CloudConsoleManager_Application, strId));
     foreach (const QString &strKey, m_data.value(GlobalID).keys())
-        if (re.indexIn(strKey) != -1)
-            result << re.cap(1);
+    {
+        const QRegularExpressionMatch mt = re.match(strKey);
+        if (mt.hasMatch())
+            result << mt.captured(1);
+    }
     return result;
 }

trunk/src/VBox/Frontends/VirtualBox/src/globals/UITranslator.cpp

@@ -30 +30 @@
 #include <QDir>
 #include <QKeySequence>
-#include <QRegExp>
 #include <QRegularExpression>
 #ifdef Q_OS_UNIX
@@ -111 +110 @@
     if (!strEffectiveLangId.isEmpty() && strEffectiveLangId != vboxBuiltInLanguageName())
     {
-        QRegExp regExp(vboxLanguageIdRegExp());
-        int iPos = regExp.indexIn(strEffectiveLangId);
+        const QRegularExpression re(vboxLanguageIdRegExp());
+        const QRegularExpressionMatch mt = re.match(strEffectiveLangId);
         /* The language ID should match the regexp completely: */
-        AssertReturnVoid(iPos == 0);
-
-        QString strStrippedLangId = regExp.cap(2);
+        AssertReturnVoid(mt.capturedStart() == 0);
+
+        QString strStrippedLangId = mt.captured(2);
 
         if (nlsDir.exists(vboxLanguageFileBase() + strEffectiveLangId + vboxLanguageFileExtension()))
@@ -394 +393 @@
 {
     /* Text should be in form of B|KB|MB|GB|TB|PB. */
-    QRegExp regexp(sizeRegexp());
-    int iPos = regexp.indexIn(strText);
-    if (iPos != -1)
-    {
-        QString strInteger = regexp.cap(1);
+    const QRegularExpression re(sizeRegexp());
+    const QRegularExpressionMatch mt = re.match(strText);
+    if (mt.hasMatch())
+    {
+        QString strInteger = mt.captured(1);
         QString strHundred;
-        QString strSuff = regexp.cap(2);
+        QString strSuff = mt.captured(2);
         if (strInteger.isEmpty())
         {
-            strInteger = regexp.cap(3);
-            strHundred = regexp.cap(4);
-            strSuff = regexp.cap(5);
+            strInteger = mt.captured(3);
+            strHundred = mt.captured(4);
+            strSuff = mt.captured(5);
         }
 
@@ -439 +438 @@
 {
     /* Text should be in form of B|KB|MB|GB|TB|PB. */
-    QRegExp regexp(sizeRegexp());
-    int iPos = regexp.indexIn(strText);
-    if (iPos != -1)
-    {
-        QString strInteger = regexp.cap(1);
-        QString strSuff = regexp.cap(2);
+    const QRegularExpression re(sizeRegexp());
+    const QRegularExpressionMatch mt = re.match(strText);
+    if (mt.hasMatch())
+    {
+        QString strInteger = mt.captured(1);
+        QString strSuff = mt.captured(2);
         if (strInteger.isEmpty())
         {
-            strInteger = regexp.cap(3);
-            strSuff = regexp.cap(5);
+            strInteger = mt.captured(3);
+            strSuff = mt.captured(5);
         }
 
@@ -475 +474 @@
 {
     /* Text should be in form of B|KB|MB|GB|TB|PB. */
-    QRegExp regexp(sizeRegexp());
-    int iPos = regexp.indexIn(strText);
-    if (iPos != -1)
-    {
-        QString strInteger = regexp.cap(1);
-        QString strSuff = regexp.cap(2);
+    const QRegularExpression re(sizeRegexp());
+    const QRegularExpressionMatch mt = re.match(strText);
+    if (mt.hasMatch())
+    {
+        QString strInteger = mt.captured(1);
+        QString strSuff = mt.captured(2);
         if (strInteger.isEmpty())
         {
-            strInteger = regexp.cap(3);
-            strSuff = regexp.cap(5);
+            strInteger = mt.captured(3);
+            strSuff = mt.captured(5);
         }
 
@@ -756 +755 @@
      * removed from the string. */
 
-    QRegExp accel("\\(&[a-zA-Z]\\)");
-    int iPos = accel.indexIn(strText);
+    const QRegularExpression re("\\(&[a-zA-Z]\\)");
+    const QRegularExpressionMatch mt = re.match(strText);
+    int iPos = mt.capturedStart();
     if (iPos >= 0)
-        strText.remove(iPos, accel.cap().length());
+        strText.remove(iPos, mt.capturedLength());
     else
     {

trunk/src/VBox/Frontends/VirtualBox/src/manager/UIVirtualBoxManager.cpp

@@ -42 +42 @@
 #include <QWindow>
 #ifndef VBOX_WS_WIN
-# include <QRegExp>
+# include <QRegularExpression>
 #endif
 
@@ -3049 +3049 @@
     /* Parse argument string: */
     QStringList arguments;
-    QRegExp re("(\"[^\"]+\")|('[^']+')|([^\\s\"']+)");
+    const QRegularExpression re("(\"[^\"]+\")|('[^']+')|([^\\s\"']+)");
     int iPosition = 0;
-    int iIndex = re.indexIn(strArguments, iPosition);
+    QRegularExpressionMatch mt = re.match(strArguments, iPosition);
+    int iIndex = mt.capturedStart();
     while (iIndex != -1)
     {
         /* Get what's the sequence we have: */
-        const QString strCap0 = re.cap(0);
+        const QString strCap0 = mt.captured(0);
         /* Get what's the double-quoted sequence we have: */
-        const QString strCap1 = re.cap(1);
+        const QString strCap1 = mt.captured(1);
         /* Get what's the single-quoted sequence we have: */
-        const QString strCap2 = re.cap(2);
+        const QString strCap2 = mt.captured(2);
         /* Get what's the unquoted sequence we have: */
-        const QString strCap3 = re.cap(3);
+        const QString strCap3 = mt.captured(3);
 
         /* If new sequence starts where previous ended
@@ -3103 +3104 @@
         iPosition = iIndex + strCap0.size();
         /* Search for a next sequence: */
-        iIndex = re.indexIn(strArguments, iPosition);
+        mt = re.match(strArguments, iPosition);
+        iIndex = mt.capturedStart();
     }
 

trunk/src/VBox/Frontends/VirtualBox/src/manager/chooser/UIChooserAbstractModel.cpp

@@ -27 +27 @@
 
 /* Qt includes: */
-#include <QRegExp>
 #include <QRegularExpression>
 #include <QThread>
@@ -471 +470 @@
     const QString strShortTemplate = strMinimumName;
     const QString strFullTemplate = strShortTemplate + QString(" (\\d+)");
-    const QRegExp shortRegExp(strShortTemplate);
-    const QRegExp fullRegExp(strFullTemplate);
+    const QRegularExpression shortRegExp(strShortTemplate);
+    const QRegularExpression fullRegExp(strFullTemplate);
 
     /* Search for the maximum index: */
@@ -478 +477 @@
     foreach (const QString &strName, groupNames)
     {
-        if (shortRegExp.exactMatch(strName))
+        const QRegularExpressionMatch mtShort = shortRegExp.match(strName);
+        const QRegularExpressionMatch mtFull = fullRegExp.match(strName);
+        if (mtShort.hasMatch())
             iMinimumPossibleNumber = qMax(iMinimumPossibleNumber, 2);
-        else if (fullRegExp.exactMatch(strName))
-            iMinimumPossibleNumber = qMax(iMinimumPossibleNumber, fullRegExp.cap(1).toInt() + 1);
+        else if (mtFull.hasMatch())
+            iMinimumPossibleNumber = qMax(iMinimumPossibleNumber, mtFull.captured(1).toInt() + 1);
     }
 
@@ -654 +655 @@
 {
     /* Compose RE for profile: */
-    QRegExp re("^/[^/]+/[^/]+$");
+    const QRegularExpression re("^/[^/]+/[^/]+$");
     /* Check whether keys match profile RE: */
     foreach (const UICloudEntityKey &key, m_cloudEntityKeysBeingUpdated)
     {
-        const int iIndex = re.indexIn(key.toString());
-        if (iIndex != -1)
+        const QRegularExpressionMatch mt = re.match(key.toString());
+        if (mt.hasMatch())
             return true;
     }
@@ -1463 +1464 @@
     const QString strNodeOptionOpened = optionToString(UIChooserNodeDataOptionType_GroupOpened);
     const QString strDefinitionTemplate = QString("%1(\\S)*=%2").arg(strNodePrefix, strName);
-    const QRegExp definitionRegExp(strDefinitionTemplate);
+    const QRegularExpression re(strDefinitionTemplate);
     /* For each the group definition: */
     foreach (const QString &strDefinition, definitions)
     {
         /* Check if this is required definition: */
-        if (definitionRegExp.indexIn(strDefinition) == 0)
+        const QRegularExpressionMatch mt = re.match(strDefinition);
+        if (mt.capturedStart() == 0)
         {
             /* Get group descriptor: */
-            const QString strDescriptor(definitionRegExp.cap(1));
+            const QString strDescriptor = mt.captured(1);
             if (strDescriptor.contains(strNodeOptionOpened))
                 return true;
@@ -1494 +1496 @@
     const QString strNodeValueDefault = valueToString(UIChooserNodeDataValueType_GlobalDefault);
     const QString strDefinitionTemplate = QString("%1(\\S)*=%2").arg(strNodePrefix, strNodeValueDefault);
-    const QRegExp definitionRegExp(strDefinitionTemplate);
+    const QRegularExpression re(strDefinitionTemplate);
     /* For each the group definition: */
     foreach (const QString &strDefinition, definitions)
     {
         /* Check if this is required definition: */
-        if (definitionRegExp.indexIn(strDefinition) == 0)
+        const QRegularExpressionMatch mt = re.match(strDefinition);
+        if (mt.capturedStart() == 0)
         {
             /* Get group descriptor: */
-            const QString strDescriptor(definitionRegExp.cap(1));
+            const QString strDescriptor = mt.captured(1);
             if (strDescriptor.contains(strNodeOptionFavorite))
                 return true;
@@ -1646 +1649 @@
             return -1;
     }
-    QRegExp definitionRegExpShort(strDefinitionTemplateShort);
-    QRegExp definitionRegExpFull(strDefinitionTemplateFull);
+    const QRegularExpression definitionRegExpShort(strDefinitionTemplateShort);
+    const QRegularExpression definitionRegExpFull(strDefinitionTemplateFull);
 
     /* For each the definition: */
@@ -1654 +1657 @@
     {
         /* Check if this definition is of required type: */
-        if (definitionRegExpShort.indexIn(strDefinition) == 0)
+        const QRegularExpressionMatch mtShort = definitionRegExpShort.match(strDefinition);
+        if (mtShort.capturedStart() == 0)
         {
             ++iDefinitionIndex;
             /* Check if this definition is exactly what we need: */
-            if (definitionRegExpFull.indexIn(strDefinition) == 0)
+            const QRegularExpressionMatch mtFull = definitionRegExpFull.match(strDefinition);
+            if (mtFull.capturedStart() == 0)
                 return iDefinitionIndex;
         }

trunk/src/VBox/Frontends/VirtualBox/src/networkmanager/UINetworkManager.cpp

@@ -30 +30 @@
 #include <QMenuBar>
 #include <QPushButton>
-#include <QRegExp>
+#include <QRegularExpression>
 #include <QVBoxLayout>
 
@@ -525 +525 @@
     QMap<int, bool> presence;
     const QString strNameTemplate("HostNetwork%1");
-    const QRegExp regExp(strNameTemplate.arg("([\\d]*)"));
+    const QRegularExpression re(strNameTemplate.arg("([\\d]*)"));
     foreach (const QString &strName, names)
-        if (regExp.indexIn(strName) != -1)
-            presence[regExp.cap(1).toInt()] = true;
+    {
+        const QRegularExpressionMatch mt = re.match(strName);
+        if (mt.hasMatch())
+            presence[mt.captured(1).toInt()] = true;
+    }
     /* Search for a minimum index: */
     int iMinimumIndex = 0;
@@ -780 +783 @@
     QMap<int, bool> presence;
     const QString strNameTemplate("NatNetwork%1");
-    const QRegExp regExp(strNameTemplate.arg("([\\d]*)"));
+    const QRegularExpression re(strNameTemplate.arg("([\\d]*)"));
     foreach (const QString &strName, names)
-        if (regExp.indexIn(strName) != -1)
-            presence[regExp.cap(1).toInt()] = true;
+    {
+        const QRegularExpressionMatch mt = re.match(strName);
+        if (mt.hasMatch())
+            presence[mt.captured(1).toInt()] = true;
+    }
     /* Search for a minimum index: */
     int iMinimumIndex = 0;
@@ -919 +925 @@
     QMap<int, bool> presence;
     const QString strNameTemplate("CloudNetwork%1");
-    const QRegExp regExp(strNameTemplate.arg("([\\d]*)"));
+    const QRegularExpression re(strNameTemplate.arg("([\\d]*)"));
     foreach (const QString &strName, names)
-        if (regExp.indexIn(strName) != -1)
-            presence[regExp.cap(1).toInt()] = true;
+    {
+        const QRegularExpressionMatch mt = re.match(strName);
+        if (mt.hasMatch())
+            presence[mt.captured(1).toInt()] = true;
+    }
     /* Search for a minimum index: */
     int iMinimumIndex = 0;
@@ -2257 +2266 @@
             strIPv6Rule.replace(':', ',');
             /* But replace ',' back with ':' for addresses: */
-            QRegExp re("\\[[0-9a-fA-F,]*,[0-9a-fA-F,]*\\]");
-            re.setMinimal(true);
-            while (re.indexIn(strIPv6Rule) != -1)
+            QRegularExpression re("\\[[0-9a-fA-F,]*,[0-9a-fA-F,]*\\]");
+            re.setPatternOptions(QRegularExpression::InvertedGreedinessOption);
+            QRegularExpressionMatch mt = re.match(strIPv6Rule);
+            while (mt.hasMatch())
             {
-                QString strCapOld = re.cap(0);
+                QString strCapOld = mt.captured();
                 QString strCapNew = strCapOld;
                 strCapNew.replace(',', ':');
                 strIPv6Rule.replace(strCapOld, strCapNew);
+                mt = re.match(strIPv6Rule);
             }
             /* Parse rules: */

trunk/src/VBox/Frontends/VirtualBox/src/objects/UIRichTextString.cpp

@@ -29 +29 @@
 #include <QApplication>
 #include <QPalette>
-#include <QRegExp>
+#include <QRegularExpression>
 
 /* GUI includes: */
@@ -145 +145 @@
                 const QString strFullPattern = composeFullPattern(strPattern, strPattern, iMaxLevel);
                 //printf("  Full pattern: %s\n", strFullPattern.toUtf8().constData());
-                QRegExp regExp(strFullPattern);
-                regExp.setMinimal(true);
-                const int iPosition = regExp.indexIn(m_strString);
+                QRegularExpression re(strFullPattern);
+                re.setPatternOptions(QRegularExpression::InvertedGreedinessOption);
+                const QRegularExpressionMatch mt = re.match(m_strString);
+                const int iPosition = mt.capturedStart();
                 AssertReturnVoid(iPosition != -1);
-                if (iPosition != -1)
-                {
-                    /* Cut the found string: */
-                    m_strString.remove(iPosition, regExp.cap(0).size());
-                    /* And paste that string as our child: */
-                    const bool fPatterHasMeta = s_doPatternHasMeta.value(enmPattern);
-                    const QString strSubString = !fPatterHasMeta ? regExp.cap(1) : regExp.cap(2);
-                    const QString strSubMeta   = !fPatterHasMeta ? QString()     : regExp.cap(1);
-                    m_strings.insert(iPosition, new UIRichTextString(strSubString, enmPattern, strSubMeta));
-                }
+                /* Cut the found string: */
+                m_strString.remove(iPosition, mt.capturedLength());
+                /* And paste that string as our child: */
+                const bool fPatterHasMeta = s_doPatternHasMeta.value(enmPattern);
+                const QString strSubString = !fPatterHasMeta ? mt.captured(1) : mt.captured(2);
+                const QString strSubMeta   = !fPatterHasMeta ? QString()      : mt.captured(1);
+                m_strings.insert(iPosition, new UIRichTextString(strSubString, enmPattern, strSubMeta));
             }
         }
@@ -189 +187 @@
                                         const QString &strCurrentPattern, int iCurrentLevel /* = 0 */)
 {
-    QRegExp regExp(strCurrentPattern.arg(s_strAny));
-    regExp.setMinimal(true);
-    if (regExp.indexIn(strString) != -1)
+    QRegularExpression re(strCurrentPattern.arg(s_strAny));
+    re.setPatternOptions(QRegularExpression::InvertedGreedinessOption);
+    const QRegularExpressionMatch mt = re.match(strString);
+    if (mt.hasMatch())
         return searchForMaxLevel(strString, strPattern,
                                  strCurrentPattern.arg(s_strAny + strPattern + s_strAny),

trunk/src/VBox/Frontends/VirtualBox/src/runtime/UIMachineLogic.cpp

@@ -33 +33 @@
 #include <QImageWriter>
 #include <QPainter>
-#include <QRegExp>
 #include <QRegularExpression>
 #include <QTimer>

trunk/src/VBox/Frontends/VirtualBox/src/runtime/UISession.cpp

@@ -28 +28 @@
 /* Qt includes: */
 #include <QApplication>
-#include <QRegExp>
+#include <QRegularExpression>
 #include <QWidget>
 
@@ -2935 +2935 @@
     bool fSuccess = true;
     ulong uMaxIndex = 0;
-    QRegExp regExp(QString("^") + strNameTemplate.arg("([0-9]+)") + QString("$"));
+    const QRegularExpression re(QString("^") + strNameTemplate.arg("([0-9]+)") + QString("$"));
     if (!comSnapshot.isNull())
     {
@@ -2945 +2945 @@
         else
         {
-            const int iPos = regExp.indexIn(strName);
-            if (iPos != -1)
-                uMaxIndex = regExp.cap(1).toULong() > uMaxIndex ? regExp.cap(1).toULong() : uMaxIndex;
+            const QRegularExpressionMatch mt = re.match(strName);
+            if (mt.hasMatch())
+            {
+                const ulong uFoundIndex = mt.captured(1).toULong();
+                uMaxIndex = uFoundIndex > uMaxIndex ? uFoundIndex : uMaxIndex;
+            }
             /* Traversing all the snapshot children: */
             QVector<CSnapshot> comSnapshotChildren = comSnapshot.GetChildren();

trunk/src/VBox/Frontends/VirtualBox/src/settings/editors/UILanguageSettingsEditor.cpp

@@ -30 +30 @@
 #include <QHeaderView>
 #include <QPainter>
-#include <QRegExp>
+#include <QRegularExpression>
 #include <QTranslator>
 #include <QVBoxLayout>
@@ -387 +387 @@
     {
         QString strFileName = *it;
-        QRegExp regExp(UITranslator::vboxLanguageFileBase() + UITranslator::vboxLanguageIdRegExp());
-        int iPos = regExp.indexIn(strFileName);
-        if (iPos == -1)
+        const QRegularExpression re(UITranslator::vboxLanguageFileBase() + UITranslator::vboxLanguageIdRegExp());
+        const QRegularExpressionMatch mt = re.match(strFileName);
+        if (!mt.hasMatch())
             continue;
 
         /* Skip any English version, cause this is extra handled: */
-        QString strLanguage = regExp.cap(2);
+        QString strLanguage = mt.captured(2);
         if (strLanguage.toLower() == "en")
             continue;
@@ -401 +401 @@
             continue;
 
-        new UILanguageItem(m_pTreeWidget, translator, regExp.cap(1));
+        new UILanguageItem(m_pTreeWidget, translator, mt.captured(1));
     }
 

trunk/src/VBox/Frontends/VirtualBox/src/settings/editors/UISharedFoldersEditor.cpp

@@ -29 +29 @@
 #include <QHeaderView>
 #include <QMenu>
-#include <QRegExp>
+#include <QRegularExpression>
 #include <QTimer>
 #include <QVBoxLayout>
@@ -232 +232 @@
                 case FormatType_EllipsisFile:
                 {
-                    const QRegExp regExp("([\\\\/][^\\\\^/]+[\\\\/]?$)");
-                    const int iNewFinish = regExp.indexIn(strOneString);
+                    const QRegularExpression re("([\\\\/][^\\\\^/]+[\\\\/]?$)");
+                    const QRegularExpressionMatch mt = re.match(strOneString);
+                    const int iNewFinish = mt.capturedStart();
                     if (iNewFinish != -1)
                         iFinish = iNewFinish;

trunk/src/VBox/Frontends/VirtualBox/src/settings/editors/UIUSBFiltersEditor.cpp

@@ -29 +29 @@
 #include <QHeaderView>
 #include <QMenu>
-#include <QRegExp>
+#include <QRegularExpression>
 #include <QToolTip>
 #include <QVBoxLayout>
@@ -353 +353 @@
     /* Search for the max available filter index: */
     int iMaxFilterIndex = 0;
-    const QRegExp regExp(QString("^") + m_strTrUSBFilterName.arg("([0-9]+)") + QString("$"));
+    const QRegularExpression re(QString("^") + m_strTrUSBFilterName.arg("([0-9]+)") + QString("$"));
     QTreeWidgetItemIterator iterator(m_pTreeWidget);
     while (*iterator)
     {
         const QString filterName = (*iterator)->text(0);
-        const int pos = regExp.indexIn(filterName);
-        if (pos != -1)
-            iMaxFilterIndex = regExp.cap(1).toInt() > iMaxFilterIndex ?
-                              regExp.cap(1).toInt() : iMaxFilterIndex;
+        const QRegularExpressionMatch mt = re.match(filterName);
+        if (mt.hasMatch())
+        {
+            const int iFoundIndex = mt.captured(1).toInt();
+            iMaxFilterIndex = iFoundIndex > iMaxFilterIndex
+                            ? iFoundIndex : iMaxFilterIndex;
+        }
         ++iterator;
     }

trunk/src/VBox/Frontends/VirtualBox/src/settings/machine/UIMachineSettingsUSB.cpp

@@ -34 +34 @@
 #include <QMenu>
 #include <QRadioButton>
-#include <QRegExp>
 #include <QSpacerItem>
 #include <QVBoxLayout>

trunk/src/VBox/Frontends/VirtualBox/src/snapshots/UISnapshotPane.cpp

@@ -35 +35 @@
 #include <QPointer>
 #include <QReadWriteLock>
-#include <QRegExp>
+#include <QRegularExpression>
 #include <QScrollBar>
 #include <QTimer>
@@ -1665 +1665 @@
     int iMaximumIndex = 0;
     const QString strNameTemplate = tr("Snapshot %1");
-    const QRegExp reName(QString("^") + strNameTemplate.arg("([0-9]+)") + QString("$"));
+    const QRegularExpression re(QString("^") + strNameTemplate.arg("([0-9]+)") + QString("$"));
     QTreeWidgetItemIterator iterator(m_pSnapshotTree);
     while (*iterator)
     {
         const QString strName = static_cast<UISnapshotItem*>(*iterator)->name();
-        const int iPosition = reName.indexIn(strName);
-        if (iPosition != -1)
-            iMaximumIndex = reName.cap(1).toInt() > iMaximumIndex
-                          ? reName.cap(1).toInt()
-                          : iMaximumIndex;
+        const QRegularExpressionMatch mt = re.match(strName);
+        if (mt.hasMatch())
+        {
+            const int iFoundIndex = mt.captured(1).toInt();
+            iMaximumIndex = iFoundIndex > iMaximumIndex
+                          ? iFoundIndex : iMaximumIndex;
+        }
         ++iterator;
     }

trunk/src/VBox/Frontends/VirtualBox/src/widgets/UIApplianceEditorWidget.cpp

@@ -33 +33 @@
 #include <QLabel>
 #include <QLineEdit>
-#include <QRegExp>
+#include <QRegularExpression>
 #include <QSpinBox>
 #include <QTextEdit>
@@ -1375 +1375 @@
             }
         }
-        QRegExp rx("controller=(\\d+);?");
+        const QRegularExpression re("controller=(\\d+);?");
         /* Now process the hard disk images */
         for (int iHDIndex = 0; iHDIndex < hdIndexes.size(); ++iHDIndex)
@@ -1381 +1381 @@
             int i = hdIndexes[iHDIndex];
             QString ecnf = extraConfigValues[i];
-            if (rx.indexIn(ecnf) != -1)
+            const QRegularExpressionMatch mt = re.match(ecnf);
+            if (mt.hasMatch())
             {
                 /* Get the controller */
-                UIVirtualHardwareItem *pControllerItem = controllerMap[rx.cap(1).toInt()];
+                UIVirtualHardwareItem *pControllerItem = controllerMap[mt.captured(1).toInt()];
                 if (pControllerItem)
                 {

trunk/src/VBox/Frontends/VirtualBox/src/widgets/UIFilePathSelector.cpp

@@ -34 +34 @@
 #include <QHBoxLayout>
 #include <QLineEdit>
+#include <QRegularExpression>
 #ifdef VBOX_WS_WIN
 # include <QListView>
 #endif
-#include <QRegExp>
 
 /* GUI includes: */
@@ -520 +520 @@
 
             /* Selecting remove position: */
-            QRegExp regExp("([\\\\/][^\\\\^/]+[\\\\/]?$)");
-            int iNewFinish = regExp.indexIn(strFullText);
+            const QRegularExpression re("([\\\\/][^\\\\^/]+[\\\\/]?$)");
+            const QRegularExpressionMatch mt = re.match(strFullText);
+            const int iNewFinish = mt.capturedStart();
             if (iNewFinish != -1)
                 iFinish = iNewFinish;

trunk/src/VBox/Frontends/VirtualBox/src/widgets/UIPortForwardingTable.cpp

@@ -34 +34 @@
 #include <QLineEdit>
 #include <QMenu>
-#include <QRegExp>
+#include <QRegularExpression>
 #include <QSpinBox>
 #include <QStyledItemDelegate>
@@ -592 +592 @@
     uint uMaxIndex = 0;
     QString strTemplate("Rule %1");
-    QRegExp regExp(strTemplate.arg("(\\d+)"));
+    const QRegularExpression re(strTemplate.arg("(\\d+)"));
     for (int i = 0; i < m_dataList.size(); ++i)
-        if (regExp.indexIn(m_dataList[i]->name()) > -1)
-            uMaxIndex = regExp.cap(1).toUInt() > uMaxIndex ? regExp.cap(1).toUInt() : uMaxIndex;
+    {
+        const QRegularExpressionMatch mt = re.match(m_dataList[i]->name());
+        if (mt.hasMatch())
+        {
+            const uint uFoundIndex = mt.captured(1).toUInt();
+            uMaxIndex = uFoundIndex > uMaxIndex ? uFoundIndex : uMaxIndex;
+        }
+    }
     /* If index is valid => copy data: */
     if (index.isValid())