Changeset 55476 in vbox for trunk/src/VBox/Frontends/VirtualBox

Timestamp:

Apr 28, 2015 10:04:46 AM (10 years ago)

Author:

vboxsync

Message:

FE/Qt: 7720: Initial implementation for rich-text support of the details-pane elements.

Location:

trunk/src/VBox/Frontends/VirtualBox/src/widgets/graphics

Files:

• UIGraphicsTextPane.cpp (modified) (3 diffs)
• UIGraphicsTextPane.h (modified) (2 diffs)

trunk/src/VBox/Frontends/VirtualBox/src/widgets/graphics/UIGraphicsTextPane.cpp

@@ -21 +21 @@
 
 /* Qt includes: */
+# include <QStack>
+# include <QPainter>
 # include <QApplication>
-# include <QPainter>
+# include <QFontMetrics>
+# include <QGraphicsSceneHoverEvent>
 
 /* GUI includes: */
 # include "UIGraphicsTextPane.h"
 
+/* Other VBox includes: */
+# include "iprt/assert.h"
+
 #endif /* !VBOX_WITH_PRECOMPILED_HEADERS */
-
-#include <QFontMetrics>
-#include <QGraphicsSceneHoverEvent>
-#include <QTextLayout>
-
 
 UIGraphicsTextPane::UIGraphicsTextPane(QIGraphicsWidget *pParent, QPaintDevice *pPaintDevice)
@@ -362 +363 @@
     QFontMetrics fm(font, pPaintDevice);
     int iLeading = fm.leading();
-    QString strModifiedText(strText);
-    QList<QTextLayout::FormatRange> formatRangeList;
-
-    /* Handle bold sub-strings: */
-    QRegExp boldRegExp("<b>([\\s\\S]+)</b>");
-    boldRegExp.setMinimal(true);
-    while (boldRegExp.indexIn(strModifiedText) != -1)
-    {
-        /* Prepare format: */
-        QTextLayout::FormatRange formatRange;
-        QFont font = formatRange.format.font();
-        font.setBold(true);
-        formatRange.format.setFont(font);
-        formatRange.start = boldRegExp.pos(0);
-        formatRange.length = boldRegExp.cap(1).size();
-        /* Add format range to list: */
-        formatRangeList << formatRange;
-        /* Replace sub-string: */
-        strModifiedText.replace(boldRegExp.cap(0), boldRegExp.cap(1));
-    }
-
-    /* Handle anchored sub-strings: */
-    QRegExp anchoredRegExp("<a href=([^>]+)>([^<>]+)</a>");
-    anchoredRegExp.setMinimal(true);
-    while (anchoredRegExp.indexIn(strModifiedText) != -1)
-    {
-        /* Prepare format: */
-        QTextLayout::FormatRange formatRange;
-        formatRange.format.setAnchor(true);
-        formatRange.format.setAnchorHref(anchoredRegExp.cap(1));
-        if (formatRange.format.anchorHref() == strHoveredAnchor)
-            formatRange.format.setForeground(qApp->palette().color(QPalette::Link));
-        formatRange.start = anchoredRegExp.pos(0);
-        formatRange.length = anchoredRegExp.cap(2).size();
-        /* Add format range to list: */
-        formatRangeList << formatRange;
-        /* Replace sub-string: */
-        strModifiedText.replace(anchoredRegExp.cap(0), anchoredRegExp.cap(2));
-    }
+
+    /* Parse incoming string with UIRichTextString capabilities: */
+    //printf("Text: {%s}\n", strText.toAscii().constData());
+    UIRichTextString ms(strText);
+    ms.setHoveredAnchor(strHoveredAnchor);
 
     /* Create layout; */
-    QTextLayout *pTextLayout = new QTextLayout(strModifiedText, font, pPaintDevice);
-    pTextLayout->setAdditionalFormats(formatRangeList);
+    QTextLayout *pTextLayout = new QTextLayout(ms.toString(), font, pPaintDevice);
+    pTextLayout->setAdditionalFormats(ms.formatRanges());
 
     /* Configure layout: */
@@ -475 +442 @@
 }
 
+
+const QString UIRichTextString::m_sstrAny = QString("[\\s\\S]*");
+const QMap<UIRichTextString::Type, QString> UIRichTextString::m_sPatterns = populatePatterns();
+const QMap<UIRichTextString::Type, bool> UIRichTextString::m_sPatternHasMeta = populatePatternHasMeta();
+
+UIRichTextString::UIRichTextString(Type type /* = Type_None */)
+    : m_type(type)
+    , m_strString(QString())
+    , m_strStringMeta(QString())
+{
+}
+
+UIRichTextString::UIRichTextString(const QString &strString, Type type /* = Type_None */, const QString &strStringMeta /* = QString() */)
+    : m_type(type)
+    , m_strString(strString)
+    , m_strStringMeta(strStringMeta)
+{
+    //printf("Creating new UIRichTextString with string=\"%s\" and string-meta=\"%s\"\n",
+    //       m_strString.toAscii().constData(), m_strStringMeta.toAscii().constData());
+    parse();
+}
+
+UIRichTextString::~UIRichTextString()
+{
+    /* Erase the map: */
+    qDeleteAll(m_strings.begin(), m_strings.end());
+    m_strings.clear();
+}
+
+QString UIRichTextString::toString() const
+{
+    /* Add own string first: */
+    QString strString = m_strString;
+    /* Add all the strings of children finally: */
+    foreach (const int &iPosition, m_strings.keys())
+        strString.insert(iPosition, m_strings.value(iPosition)->toString());
+    /* Return result: */
+    return strString;
+}
+
+QList<QTextLayout::FormatRange> UIRichTextString::formatRanges(int iShift /* = 0 */) const
+{
+    /* Prepare format range list: */
+    QList<QTextLayout::FormatRange> ranges;
+    /* Add own format range first: */
+    QTextLayout::FormatRange range;
+    range.start = iShift;
+    range.length = toString().size();
+    range.format = textCharFormat(m_type);
+    /* Enable anchor if present: */
+    if (!m_strAnchor.isNull())
+    {
+        range.format.setAnchorHref(m_strAnchor);
+        /* Highlight anchor if hovered: */
+        if (range.format.anchorHref() == m_strHoveredAnchor)
+            range.format.setForeground(qApp->palette().color(QPalette::Link));
+    }
+    ranges.append(range);
+    /* Add all the format ranges of children finally: */
+    foreach (const int &iPosition, m_strings.keys())
+        ranges.append(m_strings.value(iPosition)->formatRanges(iShift + iPosition));
+    /* Return result: */
+    return ranges;
+}
+
+void UIRichTextString::setHoveredAnchor(const QString &strHoveredAnchor)
+{
+    /* Define own hovered anchor first: */
+    m_strHoveredAnchor = strHoveredAnchor;
+    /* Propagate hovered anchor to children finally: */
+    foreach (const int &iPosition, m_strings.keys())
+        m_strings.value(iPosition)->setHoveredAnchor(m_strHoveredAnchor);
+}
+
+void UIRichTextString::parse()
+{
+    /* Assign the meta to anchor directly for now,
+     * will do a separate parsing when there will
+     * be more than one type of meta: */
+    if (!m_strStringMeta.isNull())
+        m_strAnchor = m_strStringMeta;
+
+    /* Parse the passed QString with all the known patterns: */
+    foreach (const Type &enmPattern, m_sPatterns.keys())
+    {
+        /* Get the current pattern: */
+        const QString strPattern = m_sPatterns.value(enmPattern);
+
+        /* Recursively parse the string: */
+        int iMaxLevel = 0;
+        do
+        {
+            /* Search for the maximum level of the current pattern: */
+            iMaxLevel = searchForMaxLevel(m_strString, strPattern, strPattern);
+            //printf(" Maximum level for the pattern \"%s\" is %d.\n",
+            //       strPattern.toAscii().constData(), iMaxLevel);
+            /* If current pattern of at least level 1 is found: */
+            if (iMaxLevel > 0)
+            {
+                /* Compose full pattern of the corresponding level: */
+                const QString strFullPattern = composeFullPattern(strPattern, strPattern, iMaxLevel);
+                //printf("  Full pattern: %s\n", strFullPattern.toAscii().constData());
+                QRegExp regExp(strFullPattern);
+                regExp.setMinimal(true);
+                const int iPosition = regExp.indexIn(m_strString);
+                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 = m_sPatternHasMeta.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));
+                }
+            }
+        }
+        while (iMaxLevel > 0);
+    }
+}
+
+/* static */
+QMap<UIRichTextString::Type, QString> UIRichTextString::populatePatterns()
+{
+    QMap<Type, QString> patterns;
+    patterns.insert(Type_Anchor, QString("<a href=([^>]+)>(%1)</a>"));
+    patterns.insert(Type_Bold,   QString("<b>(%1)</b>"));
+    patterns.insert(Type_Italic, QString("<i>(%1)</i>"));
+    return patterns;
+}
+
+/* static */
+QMap<UIRichTextString::Type, bool> UIRichTextString::populatePatternHasMeta()
+{
+    QMap<Type, bool> patternHasMeta;
+    patternHasMeta.insert(Type_Anchor, true);
+    patternHasMeta.insert(Type_Bold,   false);
+    patternHasMeta.insert(Type_Italic, false);
+    return patternHasMeta;
+}
+
+/* static */
+int UIRichTextString::searchForMaxLevel(const QString &strString, const QString &strPattern,
+                                        const QString &strCurrentPattern, int iCurrentLevel /* = 0 */)
+{
+    QRegExp regExp(strCurrentPattern.arg(m_sstrAny));
+    regExp.setMinimal(true);
+    if (regExp.indexIn(strString) != -1)
+        return searchForMaxLevel(strString, strPattern,
+                                 strCurrentPattern.arg(m_sstrAny + strPattern + m_sstrAny),
+                                 iCurrentLevel + 1);
+    return iCurrentLevel;
+}
+
+/* static */
+QString UIRichTextString::composeFullPattern(const QString &strPattern,
+                                             const QString &strCurrentPattern, int iCurrentLevel)
+{
+    if (iCurrentLevel > 1)
+        return composeFullPattern(strPattern,
+                                  strCurrentPattern.arg(m_sstrAny + strPattern + m_sstrAny),
+                                  iCurrentLevel - 1);
+    return strCurrentPattern.arg(m_sstrAny);
+}
+
+/* static */
+QTextCharFormat UIRichTextString::textCharFormat(Type type)
+{
+    QTextCharFormat format;
+    switch (type)
+    {
+        case Type_Anchor:
+        {
+            format.setAnchor(true);
+            break;
+        }
+        case Type_Bold:
+        {
+            QFont font = format.font();
+            font.setBold(true);
+            format.setFont(font);
+            break;
+        }
+        case Type_Italic:
+        {
+            QFont font = format.font();
+            font.setItalic(true);
+            format.setFont(font);
+            break;
+        }
+    }
+    return format;
+}
+

trunk/src/VBox/Frontends/VirtualBox/src/widgets/graphics/UIGraphicsTextPane.h

@@ -19 +19 @@
 #define ___UIGraphicsTextPane_h___
 
+/* Qt includes: */
+#include <QTextLayout>
+
 /* GUI includes: */
 #include "QIGraphicsWidget.h"
-
-/* Forward declarations: */
-class QTextLayout;
 
 /* Typedefs: */
@@ -130 +130 @@
 };
 
+/** Rich text string implementation which parses the passed QString
+  * and holds it as the tree of the formatted rich text blocks.
+  * @todo: To be moved into separate files. */
+class UIRichTextString
+{
+public:
+
+    /** Rich text block types. */
+    enum Type
+    {
+        Type_None,
+        Type_Anchor,
+        Type_Bold,
+        Type_Italic,
+    };
+
+    /** Default (empty) constructor. */
+    UIRichTextString(Type type = Type_None);
+
+    /** Constructor taking passed QString.
+      * @param strString     holds the QString being parsed and held as tree of rich text blocks,
+      * @param type          holds the type of <i>this</i> rich text block,
+      * @param strStringMeta holds the QString containing meta data describing <i>this</i> rich text block. */
+    UIRichTextString(const QString &strString, Type type = Type_None, const QString &strStringMeta = QString());
+
+    /** Destructor. */
+    ~UIRichTextString();
+
+    /** Returns the QString representation. */
+    QString toString() const;
+
+    /** Returns the list of existing format ranges appropriate for QTextLayout.
+      * @param iShift holds the shift of <i>this</i> rich text block accordig to it's parent. */
+    QList<QTextLayout::FormatRange> formatRanges(int iShift = 0) const;
+
+    /** Defines the hovered anchor for <i>this</i> rich text block. */
+    void setHoveredAnchor(const QString &strHoveredAnchor);
+
+private:
+
+    /** Parses the string. */
+    void parse();
+
+    /** Used to populate const static map of known patterns.
+      * @note Keep it sync with the method below - #populatePatternHasMeta(). */
+    static QMap<Type, QString> populatePatterns();
+    /** Used to populate const static map of meta flags for the known patterns.
+      * @note Keep it sync with the method above - #populatePatterns(). */
+    static QMap<Type, bool> populatePatternHasMeta();
+
+    /** Recursively searching for the maximum level of the passed pattern.
+      * @param strString         holds the string to check for the current (recursively advanced) pattern in,
+      * @param strPattern        holds the etalon pattern to recursively advance the current pattern with,
+      * @param strCurrentPattern holds the current (recursively advanced) pattern to check for the presence of,
+      * @param iCurrentLevel     holds the current level of the recursively advanced pattern. */
+    static int searchForMaxLevel(const QString &strString, const QString &strPattern,
+                                 const QString &strCurrentPattern, int iCurrentLevel = 0);
+
+    /** Recursively composing the pattern of the maximum level.
+      * @param strPattern        holds the etalon pattern to recursively update the current pattern with,
+      * @param strCurrentPattern holds the current (recursively advanced) pattern,
+      * @param iCurrentLevel     holds the amount of the levels left to recursively advance current pattern. */
+    static QString composeFullPattern(const QString &strPattern,
+                                      const QString &strCurrentPattern, int iCurrentLevel);
+
+    /** Composes the QTextCharFormat correpoding to passed @a type. */
+    static QTextCharFormat textCharFormat(Type type);
+
+    /** Holds the type of <i>this</i> rich text block. */
+    Type m_type;
+    /** Holds the string of <i>this</i> rich text block. */
+    QString m_strString;
+    /** Holds the string meta data of <i>this</i> rich text block. */
+    QString m_strStringMeta;
+    /** Holds the children of <i>this</i> rich text block. */
+    QMap<int, UIRichTextString*> m_strings;
+
+    /** Holds the anchor of <i>this</i> rich text block. */
+    QString m_strAnchor;
+    /** Holds the anchor to highlight in <i>this</i> rich text block and in it's children. */
+    QString m_strHoveredAnchor;
+
+    /** Holds the 'any' string pattern. */
+    static const QString m_sstrAny;
+    /** Holds the map of known patterns. */
+    static const QMap<Type, QString> m_sPatterns;
+    /** Holds the map of meta flags for the known patterns. */
+    static const QMap<Type, bool> m_sPatternHasMeta;
+};
+
 #endif /* !___UIGraphicsTextPane_h___ */
+