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

Timestamp:

May 4, 2016 1:23:50 PM (9 years ago)

Author:

vboxsync

Message:

FE/Qt: ​​​​​​​​​bugref:6769: Rework/cleanup file-path selector widget (part 04): Coding-style.

Location:

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

Files:

• UIFilePathSelector.cpp (modified) (13 diffs)
• UIFilePathSelector.h (modified) (5 diffs)

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

@@ -53 +53 @@
 
 /** Returns first position of difference between passed strings. */
-static int differFrom (const QString &aS1, const QString &aS2)
-{
-    if (aS1 == aS2)
+static int differFrom(const QString &str1, const QString &str2)
+{
+    if (str1 == str2)
         return -1;
 
-    int minLength = qMin (aS1.size(), aS2.size());
-    int index = 0;
-    for (index = 0; index < minLength ; ++ index)
-        if (aS1 [index] != aS2 [index])
-            break;
-    return index;
-}
-
-UIFilePathSelector::UIFilePathSelector (QWidget *aParent)
-    : QIWithRetranslateUI<QComboBox> (aParent)
-    , mCopyAction (new QAction (this))
-    , mMode (Mode_Folder)
-    , mHomeDir (QDir::current().absolutePath())
-    , mIsEditable (true)
-    , mIsEditableMode (false)
-    , mIsMouseAwaited (false)
-    , mModified (false)
-{
-    /* Populate items */
-    insertItem (PathId, "");
-    insertItem (SelectId, "");
-    insertItem (ResetId, "");
-
-    /* Attaching known icons */
+    int iMinLength = qMin(str1.size(), str2.size());
+    int iIndex = 0;
+    for (iIndex = 0; iIndex < iMinLength; ++iIndex)
+        if (str1[iIndex] != str2[iIndex])
+            break;
+    return iIndex;
+}
+
+UIFilePathSelector::UIFilePathSelector(QWidget *pParent /* = 0 */)
+    : QIWithRetranslateUI<QComboBox>(pParent)
+    , m_pCopyAction(new QAction(this))
+    , m_enmMode(Mode_Folder)
+    , m_strHomeDir(QDir::current().absolutePath())
+    , m_fEditable(true)
+    , m_fEditableMode(false)
+    , m_fMouseAwaited(false)
+    , m_fModified(false)
+{
+    /* Populate items: */
+    insertItem(PathId, "");
+    insertItem(SelectId, "");
+    insertItem(ResetId, "");
+
+    /* Attaching known icons: */
     setItemIcon(SelectId, UIIconPool::iconSet(":/select_file_16px.png"));
     setItemIcon(ResetId, UIIconPool::iconSet(":/eraser_16px.png"));
 
-    /* Setup context menu */
-    addAction (mCopyAction);
-    mCopyAction->setShortcut (QKeySequence (QKeySequence::Copy));
-    mCopyAction->setShortcutContext (Qt::WidgetShortcut);
-
-    /* Initial Setup */
-    setInsertPolicy (QComboBox::NoInsert);
-    setContextMenuPolicy (Qt::ActionsContextMenu);
-    setMinimumWidth (200);
-
-    /* Setup connections */
-    connect (this, SIGNAL (activated (int)), this, SLOT (onActivated (int)));
-    connect (mCopyAction, SIGNAL (triggered (bool)), this, SLOT (copyToClipboard()));
-
-    /* Editable by default */
-    setEditable (true);
-
-    /* Applying language settings */
+    /* Setup context menu: */
+    addAction(m_pCopyAction);
+    m_pCopyAction->setShortcut(QKeySequence(QKeySequence::Copy));
+    m_pCopyAction->setShortcutContext(Qt::WidgetShortcut);
+
+    /* Initial setup: */
+    setInsertPolicy(QComboBox::NoInsert);
+    setContextMenuPolicy(Qt::ActionsContextMenu);
+    setMinimumWidth(200);
+
+    /* Setup connections: */
+    connect(this, SIGNAL(activated(int)), this, SLOT(onActivated(int)));
+    connect(m_pCopyAction, SIGNAL(triggered(bool)), this, SLOT(copyToClipboard()));
+
+    /* Editable by default: */
+    setEditable(true);
+
+    /* Applying language settings: */
     retranslateUi();
 }
@@ -110 +110 @@
 }
 
-void UIFilePathSelector::setMode (Mode aMode)
-{
-    mMode = aMode;
+void UIFilePathSelector::setMode(Mode enmMode)
+{
+    m_enmMode = enmMode;
 }
 
 UIFilePathSelector::Mode UIFilePathSelector::mode() const
 {
-    return mMode;
-}
-
-void UIFilePathSelector::setEditable (bool aOn)
-{
-    mIsEditable = aOn;
-
-    if (mIsEditable)
-    {
-        QComboBox::setEditable (true);
-        Assert (lineEdit());
-        connect (lineEdit(), SIGNAL (textEdited (const QString &)),
-                 this, SLOT (onTextEdited (const QString &)));
-
-        /* Installing necessary event filters */
-        lineEdit()->installEventFilter (this);
+    return m_enmMode;
+}
+
+void UIFilePathSelector::setEditable(bool fEditable)
+{
+    m_fEditable = fEditable;
+
+    if (m_fEditable)
+    {
+        QComboBox::setEditable(true);
+        Assert(lineEdit());
+        connect(lineEdit(), SIGNAL(textEdited(const QString &)),
+                this, SLOT(onTextEdited(const QString &)));
+
+        /* Installing necessary event filters: */
+        lineEdit()->installEventFilter(this);
     }
     else
@@ -138 +138 @@
         if (lineEdit())
         {
-            /* Installing necessary event filters */
-            lineEdit()->installEventFilter (this);
-            disconnect (lineEdit(), SIGNAL (textEdited (const QString &)),
-                        this, SLOT (onTextEdited (const QString &)));
-        }
-        QComboBox::setEditable (false);
+            /* Installing necessary event filters: */
+            lineEdit()->installEventFilter(this);
+            disconnect(lineEdit(), SIGNAL(textEdited(const QString &)),
+                       this, SLOT(onTextEdited(const QString &)));
+        }
+        QComboBox::setEditable(false);
     }
 }
@@ -149 +149 @@
 bool UIFilePathSelector::isEditable() const
 {
-    return mIsEditable;
-}
-
-void UIFilePathSelector::setResetEnabled (bool aEnabled)
-{
-    if (!aEnabled && count() - 1 == ResetId)
-        removeItem (ResetId);
-    else if (aEnabled && count() - 1 == ResetId - 1)
-    {
-        insertItem (ResetId, "");
+    return m_fEditable;
+}
+
+void UIFilePathSelector::setResetEnabled(bool fEnabled)
+{
+    if (!fEnabled && count() - 1 == ResetId)
+        removeItem(ResetId);
+    else if (fEnabled && count() - 1 == ResetId - 1)
+    {
+        insertItem(ResetId, "");
         setItemIcon(ResetId, UIIconPool::iconSet(":/eraser_16px.png"));
     }
@@ -171 +171 @@
 void UIFilePathSelector::resetModified()
 {
-    mModified = false;
+    m_fModified = false;
 }
 
 bool UIFilePathSelector::isModified() const
 {
-    return mModified;
-}
-
-void UIFilePathSelector::setFileDialogTitle (const QString& aTitle)
-{
-    mFileDialogTitle = aTitle;
+    return m_fModified;
+}
+
+void UIFilePathSelector::setFileDialogTitle(const QString& strTitle)
+{
+    m_strFileDialogTitle = strTitle;
 }
 
 QString UIFilePathSelector::fileDialogTitle() const
 {
-    return mFileDialogTitle;
-}
-
-void UIFilePathSelector::setFileFilters (const QString& aFilters)
-{
-    mFileFilters = aFilters;
-}
-
-QString UIFilePathSelector::fileFilters() const
-{
-    return mFileFilters;
-}
-
-void UIFilePathSelector::setDefaultSaveExt (const QString &aExt)
-{
-    mDefaultSaveExt = aExt;
-}
-
-QString UIFilePathSelector::defaultSaveExt() const
-{
-    return mDefaultSaveExt;
+    return m_strFileDialogTitle;
+}
+
+void UIFilePathSelector::setFileDialogFilters(const QString& strFilters)
+{
+    m_strFileDialogFilters = strFilters;
+}
+
+QString UIFilePathSelector::fileDialogFilters() const
+{
+    return m_strFileDialogFilters;
+}
+
+void UIFilePathSelector::setFileDialogDefaultSaveExtension(const QString &strDefaultSaveExtension)
+{
+    m_strFileDialogDefaultSaveExtension = strDefaultSaveExtension;
+}
+
+QString UIFilePathSelector::fileDialogDefaultSaveExtension() const
+{
+    return m_strFileDialogDefaultSaveExtension;
 }
 
@@ -216 +216 @@
 QString UIFilePathSelector::path() const
 {
-    return mPath;
-}
-
-void UIFilePathSelector::setPath (const QString &aPath, bool aRefreshText /* = true */)
-{
-    mPath = aPath.isEmpty() ? QString::null :
-            QDir::toNativeSeparators (aPath);
-    if (aRefreshText)
+    return m_strPath;
+}
+
+void UIFilePathSelector::setPath(const QString &strPath, bool fRefreshText /* = true */)
+{
+    m_strPath = strPath.isEmpty() ? QString::null :
+            QDir::toNativeSeparators(strPath);
+    if (fRefreshText)
         refreshText();
 }
 
-void UIFilePathSelector::setHomeDir (const QString &aHomeDir)
-{
-    mHomeDir = aHomeDir;
-}
-
-void UIFilePathSelector::resizeEvent (QResizeEvent *aEvent)
-{
-    QIWithRetranslateUI<QComboBox>::resizeEvent (aEvent);
+void UIFilePathSelector::setHomeDir(const QString &strHomeDir)
+{
+    m_strHomeDir = strHomeDir;
+}
+
+void UIFilePathSelector::resizeEvent(QResizeEvent *pEvent)
+{
+    QIWithRetranslateUI<QComboBox>::resizeEvent(pEvent);
     refreshText();
 }
 
-void UIFilePathSelector::focusInEvent (QFocusEvent *aEvent)
+void UIFilePathSelector::focusInEvent(QFocusEvent *pEvent)
 {
     if (isPathSelected())
     {
-        if (mIsEditable)
-            mIsEditableMode = true;
-        if (aEvent->reason() == Qt::MouseFocusReason)
-            mIsMouseAwaited = true;
+        if (m_fEditable)
+            m_fEditableMode = true;
+        if (pEvent->reason() == Qt::MouseFocusReason)
+            m_fMouseAwaited = true;
         else
             refreshText();
     }
-    QIWithRetranslateUI<QComboBox>::focusInEvent (aEvent);
-}
-
-void UIFilePathSelector::focusOutEvent (QFocusEvent *aEvent)
+    QIWithRetranslateUI<QComboBox>::focusInEvent(pEvent);
+}
+
+void UIFilePathSelector::focusOutEvent(QFocusEvent *pEvent)
 {
     if (isPathSelected())
     {
-        mIsEditableMode = false;
+        m_fEditableMode = false;
         refreshText();
     }
-    QIWithRetranslateUI<QComboBox>::focusOutEvent (aEvent);
-}
-
-bool UIFilePathSelector::eventFilter (QObject *aObj, QEvent *aEv)
-{
-    if (mIsMouseAwaited && (aEv->type() == QEvent::MouseButtonPress))
-        QTimer::singleShot (0, this, SLOT (refreshText()));
-
-    return QIWithRetranslateUI<QComboBox>::eventFilter (aObj, aEv);
+    QIWithRetranslateUI<QComboBox>::focusOutEvent(pEvent);
+}
+
+bool UIFilePathSelector::eventFilter(QObject *pObject, QEvent *pEvent)
+{
+    if (m_fMouseAwaited && (pEvent->type() == QEvent::MouseButtonPress))
+        QTimer::singleShot(0, this, SLOT(refreshText()));
+
+    return QIWithRetranslateUI<QComboBox>::eventFilter(pObject, pEvent);
 }
 
@@ -275 +275 @@
     if (isResetEnabled())
     {
-        mNoneStr = tr ("<reset to default>");
-        mNoneTip = tr ("The actual default path value will be displayed after "
-                       "accepting the changes and opening this window again.");
+        m_strNoneText = tr("<reset to default>");
+        m_strNoneToolTip = tr("The actual default path value will be displayed after "
+                              "accepting the changes and opening this window again.");
     }
     else
     {
-        mNoneStr = tr ("<not selected>");
-        mNoneTip = tr ("Please use the <b>Other...</b> item from the drop-down "
-                       "list to select a path.");
-    }
-
-    /* Retranslate 'path' item */
-    if (mPath.isNull())
-    {
-        setItemText (PathId, mNoneStr);
-        setItemData (PathId, mNoneTip, Qt::ToolTipRole);
-        setToolTip (mNoneTip);
-    }
-
-    /* Retranslate 'select' item */
-    setItemText (SelectId, tr ("Other..."));
-
-    /* Retranslate 'reset' item */
+        m_strNoneText = tr("<not selected>");
+        m_strNoneToolTip = tr("Please use the <b>Other...</b> item from the drop-down "
+                              "list to select a path.");
+    }
+
+    /* Retranslate 'path' item: */
+    if (m_strPath.isNull())
+    {
+        setItemText(PathId, m_strNoneText);
+        setItemData(PathId, m_strNoneToolTip, Qt::ToolTipRole);
+        setToolTip(m_strNoneToolTip);
+    }
+
+    /* Retranslate 'select' item: */
+    setItemText(SelectId, tr("Other..."));
+
+    /* Retranslate 'reset' item: */
     if (count() - 1 == ResetId)
-        setItemText (ResetId, tr ("Reset"));
-
-    /* Set tooltips of the above two items based on the mode */
-    switch (mMode)
+        setItemText(ResetId, tr("Reset"));
+
+    /* Set tooltips of the above two items based on the mode: */
+    switch (m_enmMode)
     {
         case Mode_Folder:
-            setItemData (SelectId,
-                         tr ("Displays a window to select a different folder."),
-                         Qt::ToolTipRole);
-            setItemData (ResetId,
-                         tr ("Resets the folder path to the default value."),
-                         Qt::ToolTipRole);
+            setItemData(SelectId,
+                        tr("Displays a window to select a different folder."),
+                        Qt::ToolTipRole);
+            setItemData(ResetId,
+                        tr("Resets the folder path to the default value."),
+                        Qt::ToolTipRole);
             break;
         case Mode_File_Open:
         case Mode_File_Save:
-            setItemData (SelectId,
-                         tr ("Displays a window to select a different file."),
-                         Qt::ToolTipRole);
-            setItemData (ResetId,
-                         tr ("Resets the file path to the default value."),
-                         Qt::ToolTipRole);
+            setItemData(SelectId,
+                        tr("Displays a window to select a different file."),
+                        Qt::ToolTipRole);
+            setItemData(ResetId,
+                        tr("Resets the file path to the default value."),
+                        Qt::ToolTipRole);
             break;
         default:
@@ -325 +325 @@
     }
 
-    /* Retranslate copy action */
-    mCopyAction->setText (tr ("&Copy"));
-}
-
-void UIFilePathSelector::onActivated (int aIndex)
-{
-    switch (aIndex)
+    /* Retranslate copy action: */
+    m_pCopyAction->setText(tr("&Copy"));
+}
+
+void UIFilePathSelector::onActivated(int iIndex)
+{
+    switch (iIndex)
     {
         case SelectId:
@@ -340 +340 @@
         case ResetId:
         {
-            changePath (QString::null);
+            changePath(QString::null);
             break;
         }
@@ -346 +346 @@
             break;
     }
-    setCurrentIndex (PathId);
+    setCurrentIndex(PathId);
     setFocus();
 }
 
-void UIFilePathSelector::onTextEdited (const QString &aPath)
-{
-    changePath (aPath, false /* refresh text? */);
+void UIFilePathSelector::onTextEdited(const QString &strPath)
+{
+    changePath(strPath, false /* refresh text? */);
 }
 
 void UIFilePathSelector::copyToClipboard()
 {
-    QString text (fullPath());
+    QString text(fullPath());
     /* Copy the current text to the selection and global clipboard. */
     if (QApplication::clipboard()->supportsSelection())
-        QApplication::clipboard()->setText (text, QClipboard::Selection);
-    QApplication::clipboard()->setText (text, QClipboard::Clipboard);
-}
-
-void UIFilePathSelector::changePath (const QString &aPath,
-                                             bool aRefreshText /* = true */)
-{
-    QString oldPath = mPath;
-    setPath (aPath, aRefreshText);
-    if (!mModified && mPath != oldPath)
-        mModified = true;
-    emit pathChanged (aPath);
+        QApplication::clipboard()->setText(text, QClipboard::Selection);
+    QApplication::clipboard()->setText(text, QClipboard::Clipboard);
+}
+
+void UIFilePathSelector::changePath(const QString &strPath,
+                                    bool fRefreshText /* = true */)
+{
+    const QString strOldPath = m_strPath;
+    setPath(strPath, fRefreshText);
+    if (!m_fModified && m_strPath != strOldPath)
+        m_fModified = true;
+    emit pathChanged(strPath);
 }
 
@@ -377 +377 @@
 {
     /* Preparing initial directory. */
-    QString initDir = mPath.isNull() ? mHomeDir :
-        QIFileDialog::getFirstExistingDir (mPath);
-    if (initDir.isNull())
-        initDir = mHomeDir;
-
-    QString selPath;
-    switch (mMode)
+    QString strInitDir = m_strPath.isNull() ? m_strHomeDir :
+                         QIFileDialog::getFirstExistingDir(m_strPath);
+    if (strInitDir.isNull())
+        strInitDir = m_strHomeDir;
+
+    QString strSelPath;
+    switch (m_enmMode)
     {
         case Mode_File_Open:
-            selPath = QIFileDialog::getOpenFileName (initDir, mFileFilters, parentWidget(), mFileDialogTitle); break;
+            strSelPath = QIFileDialog::getOpenFileName(strInitDir, m_strFileDialogFilters, parentWidget(), m_strFileDialogTitle); break;
         case Mode_File_Save:
-            {
-                selPath = QIFileDialog::getSaveFileName (initDir, mFileFilters, parentWidget(), mFileDialogTitle);
-                if (!selPath.isEmpty() && QFileInfo (selPath).suffix().isEmpty())
-                    selPath = QString ("%1.%2").arg (selPath).arg (mDefaultSaveExt);
-                break;
-            }
+        {
+            strSelPath = QIFileDialog::getSaveFileName(strInitDir, m_strFileDialogFilters, parentWidget(), m_strFileDialogTitle);
+            if (!strSelPath.isEmpty() && QFileInfo(strSelPath).suffix().isEmpty())
+                strSelPath = QString("%1.%2").arg(strSelPath).arg(m_strFileDialogDefaultSaveExtension);
+            break;
+        }
         case Mode_Folder:
-            selPath = QIFileDialog::getExistingDirectory (initDir, parentWidget(), mFileDialogTitle); break;
-    }
-
-    if (selPath.isNull())
+            strSelPath = QIFileDialog::getExistingDirectory(strInitDir, parentWidget(), m_strFileDialogTitle); break;
+    }
+
+    if (strSelPath.isNull())
         return;
 
-    selPath.remove (QRegExp ("[\\\\/]$"));
-    changePath (selPath);
+    strSelPath.remove(QRegExp("[\\\\/]$"));
+    changePath(strSelPath);
 }
 
 QIcon UIFilePathSelector::defaultIcon() const
 {
-    if (mMode == Mode_Folder)
+    if (m_enmMode == Mode_Folder)
         return vboxGlobal().icon(QFileIconProvider::Folder);
     else
@@ -413 +413 @@
 }
 
-QString UIFilePathSelector::fullPath (bool aAbsolute /* = true */) const
-{
-    if (mPath.isNull())
-        return mPath;
-
-    QString result;
-    switch (mMode)
+QString UIFilePathSelector::fullPath(bool fAbsolute /* = true */) const
+{
+    if (m_strPath.isNull())
+        return m_strPath;
+
+    QString strResult;
+    switch (m_enmMode)
     {
         case Mode_Folder:
-            result = aAbsolute ? QDir (mPath).absolutePath() :
-                                 QDir (mPath).path();
+            strResult = fAbsolute ? QDir(m_strPath).absolutePath() :
+                                    QDir(m_strPath).path();
             break;
         case Mode_File_Open:
         case Mode_File_Save:
-            result = aAbsolute ? QFileInfo (mPath).absoluteFilePath() :
-                                 QFileInfo (mPath).filePath();
+            strResult = fAbsolute ? QFileInfo(m_strPath).absoluteFilePath() :
+                                    QFileInfo(m_strPath).filePath();
             break;
         default:
             AssertFailedBreak();
     }
-    return QDir::toNativeSeparators (result);
-}
-
-QString UIFilePathSelector::shrinkText (int aWidth) const
-{
-    QString fullText (fullPath (false));
-    if (fullText.isEmpty())
-        return fullText;
-
-    int oldSize = fontMetrics().width (fullText);
-    int indentSize = fontMetrics().width ("x...x");
-
-    /* Compress text */
-    int start = 0;
-    int finish = 0;
-    int position = 0;
-    int textWidth = 0;
+    return QDir::toNativeSeparators(strResult);
+}
+
+QString UIFilePathSelector::shrinkText(int iWidth) const
+{
+    QString strFullText(fullPath(false));
+    if (strFullText.isEmpty())
+        return strFullText;
+
+    int iOldSize = fontMetrics().width(strFullText);
+    int iIndentSize = fontMetrics().width("x...x");
+
+    /* Compress text: */
+    int iStart = 0;
+    int iFinish = 0;
+    int iPosition = 0;
+    int iTextWidth = 0;
     do {
-        textWidth = fontMetrics().width (fullText);
-        if (textWidth + indentSize > aWidth)
-        {
-            start = 0;
-            finish = fullText.length();
-
-            /* Selecting remove position */
-            QRegExp regExp ("([\\\\/][^\\\\^/]+[\\\\/]?$)");
-            int newFinish = regExp.indexIn (fullText);
-            if (newFinish != -1)
-                finish = newFinish;
-            position = (finish - start) / 2;
-
-            if (position == finish)
+        iTextWidth = fontMetrics().width(strFullText);
+        if (iTextWidth + iIndentSize > iWidth)
+        {
+            iStart = 0;
+            iFinish = strFullText.length();
+
+            /* Selecting remove position: */
+            QRegExp regExp("([\\\\/][^\\\\^/]+[\\\\/]?$)");
+            int iNewFinish = regExp.indexIn(strFullText);
+            if (iNewFinish != -1)
+                iFinish = iNewFinish;
+            iPosition = (iFinish - iStart) / 2;
+
+            if (iPosition == iFinish)
                break;
 
-            fullText.remove (position, 1);
-        }
-    } while (textWidth + indentSize > aWidth);
-
-    fullText.insert (position, "...");
-    int newSize = fontMetrics().width (fullText);
-
-    return newSize < oldSize ? fullText : fullPath (false);
+            strFullText.remove(iPosition, 1);
+        }
+    } while (iTextWidth + iIndentSize > iWidth);
+
+    strFullText.insert(iPosition, "...");
+    int newSize = fontMetrics().width(strFullText);
+
+    return newSize < iOldSize ? strFullText : fullPath(false);
 }
 
 void UIFilePathSelector::refreshText()
 {
-    if (mIsEditable && mIsEditableMode)
-    {
-        /* Cursor positioning variables */
-        int curPos = -1;
-        int diffPos = -1;
-        int fromRight = -1;
-
-        if (mIsMouseAwaited)
-        {
-            /* Store the cursor position */
-            curPos = lineEdit()->cursorPosition();
-            diffPos = differFrom (lineEdit()->text(), mPath);
-            fromRight = lineEdit()->text().size() - curPos;
+    if (m_fEditable && m_fEditableMode)
+    {
+        /* Cursor positioning variables: */
+        int iCurPos = -1;
+        int iDiffPos = -1;
+        int iFromRight = -1;
+
+        if (m_fMouseAwaited)
+        {
+            /* Store the cursor position: */
+            iCurPos = lineEdit()->cursorPosition();
+            iDiffPos = differFrom(lineEdit()->text(), m_strPath);
+            iFromRight = lineEdit()->text().size() - iCurPos;
         }
 
@@ -497 +497 @@
          * and text have be corresponding real stored path
          * which can be absolute or relative. */
-        if (lineEdit()->text() != mPath)
-            setItemText (PathId, mPath);
-        setItemIcon (PathId, QIcon());
-        setToolTip (mMode == Mode_Folder ?
-            tr ("Holds the folder path.") :
-            tr ("Holds the file path."));
-
-        if (mIsMouseAwaited)
-        {
-            mIsMouseAwaited = false;
-
-            /* Restore the position to the right of dots */
-            if (diffPos != -1 && curPos >= diffPos + 3)
-                lineEdit()->setCursorPosition (lineEdit()->text().size() -
-                                               fromRight);
-            /* Restore the position to the center of text */
-            else if (diffPos != -1 && curPos > diffPos)
-                lineEdit()->setCursorPosition (lineEdit()->text().size() / 2);
-            /* Restore the position to the left of dots */
+        if (lineEdit()->text() != m_strPath)
+            setItemText(PathId, m_strPath);
+        setItemIcon(PathId, QIcon());
+        setToolTip(m_enmMode == Mode_Folder ?
+                   tr("Holds the folder path.") :
+                   tr("Holds the file path."));
+
+        if (m_fMouseAwaited)
+        {
+            m_fMouseAwaited = false;
+
+            /* Restore the position to the right of dots: */
+            if (iDiffPos != -1 && iCurPos >= iDiffPos + 3)
+                lineEdit()->setCursorPosition(lineEdit()->text().size() -
+                                              iFromRight);
+            /* Restore the position to the center of text: */
+            else if (iDiffPos != -1 && iCurPos > iDiffPos)
+                lineEdit()->setCursorPosition(lineEdit()->text().size() / 2);
+            /* Restore the position to the left of dots: */
             else
-                lineEdit()->setCursorPosition (curPos);
-        }
-    }
-    else if (mPath.isNull())
+                lineEdit()->setCursorPosition(iCurPos);
+        }
+    }
+    else if (m_strPath.isNull())
     {
         /* If we are not in editable mode and no path is
          * stored here - show the translated 'none' string. */
-        if (itemText (PathId) != mNoneStr)
-        {
-            setItemText (PathId, mNoneStr);
-            setItemIcon (PathId, QIcon());
-            setItemData (PathId, mNoneTip, Qt::ToolTipRole);
-            setToolTip (mNoneTip);
+        if (itemText(PathId) != m_strNoneText)
+        {
+            setItemText(PathId, m_strNoneText);
+            setItemIcon(PathId, QIcon());
+            setItemData(PathId, m_strNoneToolTip, Qt::ToolTipRole);
+            setToolTip(m_strNoneToolTip);
         }
     }
     else
     {
-        /* Compress text in combobox */
+        /* Compress text in combobox: */
         QStyleOptionComboBox options;
-        options.initFrom (this);
-        QRect rect = QApplication::style()->subControlRect (
+        options.initFrom(this);
+        QRect rect = QApplication::style()->subControlRect(
             QStyle::CC_ComboBox, &options, QStyle::SC_ComboBoxEditField);
-        setItemText (PathId, shrinkText (rect.width() - iconSize().width()));
-
-        /* Attach corresponding icon */
-        setItemIcon (PathId, QFileInfo (mPath).exists() ?
-                             vboxGlobal().icon(QFileInfo (mPath)) :
-                             defaultIcon());
-
-        /* Set the tooltip */
-        setToolTip (fullPath());
-        setItemData (PathId, toolTip(), Qt::ToolTipRole);
-    }
-}
-
+        setItemText(PathId, shrinkText(rect.width() - iconSize().width()));
+
+        /* Attach corresponding icon: */
+        setItemIcon(PathId, QFileInfo(m_strPath).exists() ?
+                            vboxGlobal().icon(QFileInfo(m_strPath)) :
+                            defaultIcon());
+
+        /* Set the tooltip: */
+        setToolTip(fullPath());
+        setItemData(PathId, toolTip(), Qt::ToolTipRole);
+    }
+}
+

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

@@ -49 +49 @@
     };
 
-    /** Constructs file-path selector passing @a aParent to QComboBox base-class. */
-    UIFilePathSelector (QWidget *aParent);
+    /** Constructs file-path selector passing @a pParent to QComboBox base-class. */
+    UIFilePathSelector(QWidget *pParent = 0);
     /** Destructs file-path selector. */
-   ~UIFilePathSelector();
+    ~UIFilePathSelector();
 
-    /** Defines the @a aMode to operate in. */
-    void setMode (Mode aMode);
+    /** Defines the @a enmMode to operate in. */
+    void setMode(Mode enmMode);
     /** Returns the mode to operate in. */
     Mode mode() const;
 
-    /** Defines whether the possibility to edit the path is @a aOn. */
-    void setEditable (bool aOn);
+    /** Defines whether the path is @a fEditable. */
+    void setEditable(bool fEditable);
     /** Returns whether the path is editable. */
     bool isEditable() const;
 
-    /** Defines whether the reseting to defauilt path is @a aEnabled. */
-    void setResetEnabled (bool aEnabled);
+    /** Defines whether the reseting to defauilt path is @a fEnabled. */
+    void setResetEnabled(bool fEnabled);
     /** Returns whether the reseting to defauilt path is enabled. */
-    bool isResetEnabled () const;
+    bool isResetEnabled() const;
 
-    /** Defines the file-dialog @a aTitle. */
-    void setFileDialogTitle (const QString& aTitle);
+    /** Defines the file-dialog @a strTitle. */
+    void setFileDialogTitle(const QString &strTitle);
     /** Returns the file-dialog title. */
     QString fileDialogTitle() const;
 
-    /** Defines the file-dialog @a aFilters. */
-    void setFileFilters (const QString& aFilters);
+    /** Defines the file-dialog @a strFilters. */
+    void setFileDialogFilters(const QString &strFilters);
     /** Returns the file-dialog filters. */
-    QString fileFilters() const;
+    QString fileDialogFilters() const;
 
-    /** Defines the file-dialog default save @a aExt. */
-    void setDefaultSaveExt (const QString &aExt);
+    /** Defines the file-dialog @a strDefaultSaveExtension. */
+    void setFileDialogDefaultSaveExtension(const QString &strDefaultSaveExtension);
     /** Returns the file-dialog default save extension. */
-    QString defaultSaveExt() const;
+    QString fileDialogDefaultSaveExtension() const;
 
     /** Resets path modified state to false. */
@@ -96 +96 @@
 signals:
 
-    /** Notify listeners about path changed. */
-    void pathChanged (const QString &);
+    /** Notify listeners about @a strPath changed. */
+    void pathChanged(const QString &strPath);
 
 public slots:
 
-    /** Defines the @a aPath and @a aRefreshText after that. */
-    void setPath (const QString &aPath, bool aRefreshText = true);
+    /** Defines the @a strPath and @a fRefreshText after that. */
+    void setPath(const QString &strPath, bool fRefreshText = true);
 
-    /** Defines the @a aHomeDir. */
-    void setHomeDir (const QString &aHomeDir);
+    /** Defines the @a strHomeDir. */
+    void setHomeDir(const QString &strHomeDir);
 
 protected:
 
-    /** Handles resize @a aEvent. */
-    void resizeEvent (QResizeEvent *aEvent);
+    /** Handles resize @a pEvent. */
+    void resizeEvent(QResizeEvent *pEvent);
 
-    /** Handles focus-in @a aEvent. */
-    void focusInEvent (QFocusEvent *aEvent);
-    /** Handles focus-out @a aEvent. */
-    void focusOutEvent (QFocusEvent *aEvent);
+    /** Handles focus-in @a pEvent. */
+    void focusInEvent(QFocusEvent *pEvent);
+    /** Handles focus-out @a pEvent. */
+    void focusOutEvent(QFocusEvent *pEvent);
 
-    /** Preprocesses every @a aEv sent to @a aObj. */
-    bool eventFilter (QObject *aObj, QEvent *aEv);
+    /** Preprocesses every @a pEvent sent to @a pObject. */
+    bool eventFilter(QObject *pObject, QEvent *pEvent);
 
     /** Handles translation event. */
@@ -125 +125 @@
 private slots:
 
-    /** Handles combo-box activation. */
-    void onActivated (int aIndex);
+    /** Handles combo-box @a iIndex activation. */
+    void onActivated(int iIndex);
 
-    /** Handles combo-box text editing. */
-    void onTextEdited (const QString &aPath);
+    /** Handles combo-box @a strText editing. */
+    void onTextEdited(const QString &strText);
 
     /** Handles combo-box text copying. */
@@ -139 +139 @@
 private:
 
-    /** Provokes change to @a aPath and @a aRefreshText after that. */
-    void changePath (const QString &aPath, bool aRefreshText = true);
+    /** Provokes change to @a strPath and @a fRefreshText after that. */
+    void changePath(const QString &strPath, bool fRefreshText = true);
 
     /** Call for file-dialog to choose path. */
@@ -148 +148 @@
     QIcon defaultIcon() const;
 
-    /** Returns full path @a aAbsolute if necessary. */
-    QString fullPath (bool aAbsolute = true) const;
+    /** Returns full path @a fAbsolute if necessary. */
+    QString fullPath(bool fAbsolute = true) const;
 
-    /** Shrinks the reflected text to @a aWidth pixels. */
-    QString shrinkText (int aWidth) const;
+    /** Shrinks the reflected text to @a iWidth pixels. */
+    QString shrinkText(int iWidth) const;
 
     /** Holds the copy action instance. */
-    QAction *mCopyAction;
+    QAction *m_pCopyAction;
 
     /** Holds the mode to operate in. */
-    Mode mMode;
+    Mode     m_enmMode;
 
     /** Holds the path. */
-    QString mPath;
-    /** Holds the home directory. */
-    QString mHomeDir;
+    QString  m_strPath;
+    /** Holds the home dir. */
+    QString  m_strHomeDir;
 
     /** Holds the file-dialog filters. */
-    QString mFileFilters;
+    QString  m_strFileDialogFilters;
     /** Holds the file-dialog default save extension. */
-    QString mDefaultSaveExt;
+    QString  m_strFileDialogDefaultSaveExtension;
     /** Holds the file-dialog title. */
-    QString mFileDialogTitle;
+    QString  m_strFileDialogTitle;
 
     /** Holds the cached text for empty path. */
-    QString mNoneStr;
+    QString  m_strNoneText;
     /** Holds the cached tool-tip for empty path. */
-    QString mNoneTip;
+    QString  m_strNoneToolTip;
 
     /** Holds whether the path is editable. */
-    bool mIsEditable;
+    bool     m_fEditable;
 
     /** Holds whether we are in editable mode. */
-    bool mIsEditableMode;
+    bool     m_fEditableMode;
     /** Holds whether we are expecting mouse events. */
-    bool mIsMouseAwaited;
+    bool     m_fMouseAwaited;
 
     /** Holds whether the path is modified. */
-    bool mModified;
+    bool     m_fModified;
 };