all: some m_d -> d style

Change-Id: Iac1f12980bf47666007817cfb2c64a6d1e9b780e
Reviewed-on: http://codereview.qt-project.org/4477
Reviewed-by: hjk <qthjk@ovi.com>

1 files changed, 104 insertions, 104 deletions

diff --git a/src/libs/utils/newclasswidget.cpp b/src/libs/utils/newclasswidget.cpp
index 3f8e82dcc2..205a8ae2e7 100644
--- a/src/libs/utils/newclasswidget.cpp
+++ b/src/libs/utils/newclasswidget.cpp
@@ -91,72 +91,72 @@ NewClassWidgetPrivate:: NewClassWidgetPrivate() :
 // --------------------- NewClassWidget
 NewClassWidget::NewClassWidget(QWidget *parent) :
     QWidget(parent),
-    m_d(new NewClassWidgetPrivate)
+    d(new NewClassWidgetPrivate)
 {
-    m_d->m_ui.setupUi(this);
+    d->m_ui.setupUi(this);
 
-    m_d->m_ui.baseClassComboBox->setEditable(false);
+    d->m_ui.baseClassComboBox->setEditable(false);
 
-    connect(m_d->m_ui.classLineEdit, SIGNAL(updateFileName(QString)),
+    connect(d->m_ui.classLineEdit, SIGNAL(updateFileName(QString)),
             this, SLOT(slotUpdateFileNames(QString)));
-    connect(m_d->m_ui.classLineEdit, SIGNAL(textEdited(QString)),
+    connect(d->m_ui.classLineEdit, SIGNAL(textEdited(QString)),
             this, SLOT(classNameEdited()));
-    connect(m_d->m_ui.baseClassComboBox, SIGNAL(currentIndexChanged(int)),
+    connect(d->m_ui.baseClassComboBox, SIGNAL(currentIndexChanged(int)),
             this, SLOT(suggestClassNameFromBase()));
-    connect(m_d->m_ui.baseClassComboBox, SIGNAL(editTextChanged(QString)),
+    connect(d->m_ui.baseClassComboBox, SIGNAL(editTextChanged(QString)),
             this, SLOT(slotValidChanged()));
-    connect(m_d->m_ui.classLineEdit, SIGNAL(validChanged()),
+    connect(d->m_ui.classLineEdit, SIGNAL(validChanged()),
             this, SLOT(slotValidChanged()));
-    connect(m_d->m_ui.headerFileLineEdit, SIGNAL(validChanged()),
+    connect(d->m_ui.headerFileLineEdit, SIGNAL(validChanged()),
             this, SLOT(slotValidChanged()));
-    connect(m_d->m_ui.sourceFileLineEdit, SIGNAL(validChanged()),
+    connect(d->m_ui.sourceFileLineEdit, SIGNAL(validChanged()),
             this, SLOT(slotValidChanged()));
-    connect(m_d->m_ui.formFileLineEdit, SIGNAL(validChanged()),
+    connect(d->m_ui.formFileLineEdit, SIGNAL(validChanged()),
             this, SLOT(slotValidChanged()));
-    connect(m_d->m_ui.pathChooser, SIGNAL(validChanged()),
+    connect(d->m_ui.pathChooser, SIGNAL(validChanged()),
             this, SLOT(slotValidChanged()));
-    connect(m_d->m_ui.generateFormCheckBox, SIGNAL(toggled(bool)),
+    connect(d->m_ui.generateFormCheckBox, SIGNAL(toggled(bool)),
             this, SLOT(slotValidChanged()));
 
-    connect(m_d->m_ui.classLineEdit, SIGNAL(validReturnPressed()),
+    connect(d->m_ui.classLineEdit, SIGNAL(validReturnPressed()),
             this, SLOT(slotActivated()));
-    connect(m_d->m_ui.headerFileLineEdit, SIGNAL(validReturnPressed()),
+    connect(d->m_ui.headerFileLineEdit, SIGNAL(validReturnPressed()),
             this, SLOT(slotActivated()));
-    connect(m_d->m_ui.sourceFileLineEdit, SIGNAL(validReturnPressed()),
+    connect(d->m_ui.sourceFileLineEdit, SIGNAL(validReturnPressed()),
             this, SLOT(slotActivated()));
-    connect(m_d->m_ui.formFileLineEdit, SIGNAL(validReturnPressed()),
+    connect(d->m_ui.formFileLineEdit, SIGNAL(validReturnPressed()),
             this, SLOT(slotActivated()));
-    connect(m_d->m_ui.formFileLineEdit, SIGNAL(validReturnPressed()),
+    connect(d->m_ui.formFileLineEdit, SIGNAL(validReturnPressed()),
             this, SLOT(slotActivated()));
-    connect(m_d->m_ui.pathChooser, SIGNAL(returnPressed()),
+    connect(d->m_ui.pathChooser, SIGNAL(returnPressed()),
              this, SLOT(slotActivated()));
 
-    connect(m_d->m_ui.generateFormCheckBox, SIGNAL(stateChanged(int)),
+    connect(d->m_ui.generateFormCheckBox, SIGNAL(stateChanged(int)),
             this, SLOT(slotFormInputChecked()));
-    connect(m_d->m_ui.baseClassComboBox, SIGNAL(editTextChanged(QString)),
+    connect(d->m_ui.baseClassComboBox, SIGNAL(editTextChanged(QString)),
             this, SLOT(slotBaseClassEdited(QString)));
-    m_d->m_ui.generateFormCheckBox->setChecked(true);
+    d->m_ui.generateFormCheckBox->setChecked(true);
     setFormInputCheckable(false, true);
     setClassType(NoClassType);
 }
 
 NewClassWidget::~NewClassWidget()
 {
-    delete m_d;
+    delete d;
 }
 
 void NewClassWidget::classNameEdited()
 {
     if (debugNewClassWidget)
-        qDebug() << Q_FUNC_INFO << m_d->m_headerExtension << m_d->m_sourceExtension;
-    m_d->m_classEdited = true;
+        qDebug() << Q_FUNC_INFO << d->m_headerExtension << d->m_sourceExtension;
+    d->m_classEdited = true;
 }
 
 void NewClassWidget::suggestClassNameFromBase()
 {
     if (debugNewClassWidget)
-        qDebug() << Q_FUNC_INFO << m_d->m_headerExtension << m_d->m_sourceExtension;
-    if (m_d->m_classEdited)
+        qDebug() << Q_FUNC_INFO << d->m_headerExtension << d->m_sourceExtension;
+    if (d->m_classEdited)
         return;
     // Suggest a class unless edited ("QMainWindow"->"MainWindow")
     QString base = baseClassName();
@@ -169,50 +169,50 @@ void NewClassWidget::suggestClassNameFromBase()
 QStringList NewClassWidget::baseClassChoices() const
 {
     QStringList rc;
-    const int count = m_d->m_ui.baseClassComboBox->count();
+    const int count = d->m_ui.baseClassComboBox->count();
     for (int i = 0; i <  count; i++)
-        rc.push_back(m_d->m_ui.baseClassComboBox->itemText(i));
+        rc.push_back(d->m_ui.baseClassComboBox->itemText(i));
     return rc;
 }
 
 void NewClassWidget::setBaseClassChoices(const QStringList &choices)
 {
-    m_d->m_ui.baseClassComboBox->clear();
-    m_d->m_ui.baseClassComboBox->addItems(choices);
+    d->m_ui.baseClassComboBox->clear();
+    d->m_ui.baseClassComboBox->addItems(choices);
 }
 
 void NewClassWidget::setBaseClassInputVisible(bool visible)
 {
-    m_d->m_baseClassInputVisible = visible;
-    m_d->m_ui.baseClassLabel->setVisible(visible);
-    m_d->m_ui.baseClassComboBox->setVisible(visible);
+    d->m_baseClassInputVisible = visible;
+    d->m_ui.baseClassLabel->setVisible(visible);
+    d->m_ui.baseClassComboBox->setVisible(visible);
 }
 
 void NewClassWidget::setBaseClassEditable(bool editable)
 {
-    m_d->m_ui.baseClassComboBox->setEditable(editable);
+    d->m_ui.baseClassComboBox->setEditable(editable);
 }
 
 bool NewClassWidget::isBaseClassInputVisible() const
 {
-    return  m_d->m_baseClassInputVisible;
+    return  d->m_baseClassInputVisible;
 }
 
 bool NewClassWidget::isBaseClassEditable() const
 {
-    return  m_d->m_ui.baseClassComboBox->isEditable();
+    return  d->m_ui.baseClassComboBox->isEditable();
 }
 
 void NewClassWidget::setFormInputVisible(bool visible)
 {
-    m_d->m_formInputVisible = visible;
-    m_d->m_ui.formLabel->setVisible(visible);
-    m_d->m_ui.formFileLineEdit->setVisible(visible);
+    d->m_formInputVisible = visible;
+    d->m_ui.formLabel->setVisible(visible);
+    d->m_ui.formFileLineEdit->setVisible(visible);
 }
 
 bool NewClassWidget::isFormInputVisible() const
 {
-    return m_d->m_formInputVisible;
+    return d->m_formInputVisible;
 }
 
 void NewClassWidget::setFormInputCheckable(bool checkable)
@@ -222,188 +222,188 @@ void NewClassWidget::setFormInputCheckable(bool checkable)
 
 void NewClassWidget::setFormInputCheckable(bool checkable, bool force)
 {
-    if (!force && checkable == m_d->m_formInputCheckable)
+    if (!force && checkable == d->m_formInputCheckable)
         return;
-    m_d->m_formInputCheckable = checkable;
-    m_d->m_ui.generateFormLabel->setVisible(checkable);
-    m_d->m_ui.generateFormCheckBox->setVisible(checkable);
+    d->m_formInputCheckable = checkable;
+    d->m_ui.generateFormLabel->setVisible(checkable);
+    d->m_ui.generateFormCheckBox->setVisible(checkable);
 }
 
 void NewClassWidget::setFormInputChecked(bool v)
 {
-    m_d->m_ui.generateFormCheckBox->setChecked(v);
+    d->m_ui.generateFormCheckBox->setChecked(v);
 }
 
 bool NewClassWidget::formInputCheckable() const
 {
-    return m_d->m_formInputCheckable;
+    return d->m_formInputCheckable;
 }
 
 bool NewClassWidget::formInputChecked() const
 {
-    return m_d->m_ui.generateFormCheckBox->isChecked();
+    return d->m_ui.generateFormCheckBox->isChecked();
 }
 
 void NewClassWidget::slotFormInputChecked()
 {
     const bool checked = formInputChecked();
-    m_d->m_ui.formLabel->setEnabled(checked);
-    m_d->m_ui.formFileLineEdit->setEnabled(checked);
+    d->m_ui.formLabel->setEnabled(checked);
+    d->m_ui.formFileLineEdit->setEnabled(checked);
 }
 
 void NewClassWidget::setPathInputVisible(bool visible)
 {
-    m_d->m_pathInputVisible = visible;
-    m_d->m_ui.pathLabel->setVisible(visible);
-    m_d->m_ui.pathChooser->setVisible(visible);
+    d->m_pathInputVisible = visible;
+    d->m_ui.pathLabel->setVisible(visible);
+    d->m_ui.pathChooser->setVisible(visible);
 }
 
 bool NewClassWidget::isPathInputVisible() const
 {
-    return m_d->m_pathInputVisible;
+    return d->m_pathInputVisible;
 }
 
 void NewClassWidget::setClassName(const QString &suggestedName)
 {
     if (debugNewClassWidget)
-        qDebug() << Q_FUNC_INFO << suggestedName << m_d->m_headerExtension << m_d->m_sourceExtension;
-    m_d->m_ui.classLineEdit->setText(ClassNameValidatingLineEdit::createClassName(suggestedName));
+        qDebug() << Q_FUNC_INFO << suggestedName << d->m_headerExtension << d->m_sourceExtension;
+    d->m_ui.classLineEdit->setText(ClassNameValidatingLineEdit::createClassName(suggestedName));
 }
 
 QString NewClassWidget::className() const
 {
-    return m_d->m_ui.classLineEdit->text();
+    return d->m_ui.classLineEdit->text();
 }
 
 QString NewClassWidget::baseClassName() const
 {
-    return m_d->m_ui.baseClassComboBox->currentText();
+    return d->m_ui.baseClassComboBox->currentText();
 }
 
 void NewClassWidget::setBaseClassName(const QString &c)
 {
-    const int index = m_d->m_ui.baseClassComboBox->findText(c);
+    const int index = d->m_ui.baseClassComboBox->findText(c);
     if (index != -1) {
-        m_d->m_ui.baseClassComboBox->setCurrentIndex(index);
+        d->m_ui.baseClassComboBox->setCurrentIndex(index);
         suggestClassNameFromBase();
     }
 }
 
 QString NewClassWidget::sourceFileName() const
 {
-    return m_d->m_ui.sourceFileLineEdit->text();
+    return d->m_ui.sourceFileLineEdit->text();
 }
 
 QString NewClassWidget::headerFileName() const
 {
-    return m_d->m_ui.headerFileLineEdit->text();
+    return d->m_ui.headerFileLineEdit->text();
 }
 
 QString NewClassWidget::formFileName() const
 {
-    return m_d->m_ui.formFileLineEdit->text();
+    return d->m_ui.formFileLineEdit->text();
 }
 
 QString NewClassWidget::path() const
 {
-    return m_d->m_ui.pathChooser->path();
+    return d->m_ui.pathChooser->path();
 }
 
 void NewClassWidget::setPath(const QString &path)
 {
-     m_d->m_ui.pathChooser->setPath(path);
+     d->m_ui.pathChooser->setPath(path);
 }
 
 bool NewClassWidget::namespacesEnabled() const
 {
-    return  m_d->m_ui.classLineEdit->namespacesEnabled();
+    return  d->m_ui.classLineEdit->namespacesEnabled();
 }
 
 void NewClassWidget::setNamespacesEnabled(bool b)
 {
-    m_d->m_ui.classLineEdit->setNamespacesEnabled(b);
+    d->m_ui.classLineEdit->setNamespacesEnabled(b);
 }
 
 QString NewClassWidget::sourceExtension() const
 {
-    return m_d->m_sourceExtension;
+    return d->m_sourceExtension;
 }
 
 void NewClassWidget::setSourceExtension(const QString &e)
 {
     if (debugNewClassWidget)
         qDebug() << Q_FUNC_INFO << e;
-    m_d->m_sourceExtension = fixSuffix(e);
+    d->m_sourceExtension = fixSuffix(e);
 }
 
 QString NewClassWidget::headerExtension() const
 {
-    return m_d->m_headerExtension;
+    return d->m_headerExtension;
 }
 
 void NewClassWidget::setHeaderExtension(const QString &e)
 {
     if (debugNewClassWidget)
         qDebug() << Q_FUNC_INFO << e;
-    m_d->m_headerExtension = fixSuffix(e);
+    d->m_headerExtension = fixSuffix(e);
 }
 
 QString NewClassWidget::formExtension() const
 {
-    return m_d->m_formExtension;
+    return d->m_formExtension;
 }
 
 void NewClassWidget::setFormExtension(const QString &e)
 {
     if (debugNewClassWidget)
         qDebug() << Q_FUNC_INFO << e;
-    m_d->m_formExtension = fixSuffix(e);
+    d->m_formExtension = fixSuffix(e);
 }
 
 bool NewClassWidget::allowDirectories() const
 {
-    return m_d->m_ui.headerFileLineEdit->allowDirectories();
+    return d->m_ui.headerFileLineEdit->allowDirectories();
 }
 
 void NewClassWidget::setAllowDirectories(bool v)
 {
     // We keep all in sync
     if (allowDirectories() != v) {
-        m_d->m_ui.sourceFileLineEdit->setAllowDirectories(v);
-        m_d->m_ui.headerFileLineEdit->setAllowDirectories(v);
-        m_d->m_ui.formFileLineEdit->setAllowDirectories(v);
+        d->m_ui.sourceFileLineEdit->setAllowDirectories(v);
+        d->m_ui.headerFileLineEdit->setAllowDirectories(v);
+        d->m_ui.formFileLineEdit->setAllowDirectories(v);
     }
 }
 
 bool NewClassWidget::lowerCaseFiles() const
 {
-    return m_d->m_ui.classLineEdit->lowerCaseFileName();
+    return d->m_ui.classLineEdit->lowerCaseFileName();
 }
 
 void NewClassWidget::setLowerCaseFiles(bool v)
 {
-    m_d->m_ui.classLineEdit->setLowerCaseFileName(v);
+    d->m_ui.classLineEdit->setLowerCaseFileName(v);
 }
 
 NewClassWidget::ClassType NewClassWidget::classType() const
 {
-    return static_cast<ClassType>(m_d->m_ui.classTypeComboBox->currentIndex());
+    return static_cast<ClassType>(d->m_ui.classTypeComboBox->currentIndex());
 }
 
 void NewClassWidget::setClassType(ClassType ct)
 {
-    m_d->m_ui.classTypeComboBox->setCurrentIndex(ct);
+    d->m_ui.classTypeComboBox->setCurrentIndex(ct);
 }
 
 bool NewClassWidget::isClassTypeComboVisible() const
 {
-    return m_d->m_ui.classTypeLabel->isVisible();
+    return d->m_ui.classTypeLabel->isVisible();
 }
 
 void NewClassWidget::setClassTypeComboVisible(bool v)
 {
-    m_d->m_ui.classTypeLabel->setVisible(v);
-    m_d->m_ui.classTypeComboBox->setVisible(v);
+    d->m_ui.classTypeLabel->setVisible(v);
+    d->m_ui.classTypeComboBox->setVisible(v);
 }
 
 // Guess suitable type information with some smartness
@@ -437,24 +437,24 @@ void NewClassWidget::slotBaseClassEdited(const QString &baseClass)
 void NewClassWidget::slotValidChanged()
 {
     const bool newValid = isValid();
-    if (newValid != m_d->m_valid) {
-        m_d->m_valid = newValid;
+    if (newValid != d->m_valid) {
+        d->m_valid = newValid;
         emit validChanged();
     }
 }
 
 bool NewClassWidget::isValid(QString *error) const
 {
-    if (!m_d->m_ui.classLineEdit->isValid()) {
+    if (!d->m_ui.classLineEdit->isValid()) {
         if (error)
-            *error = m_d->m_ui.classLineEdit->errorMessage();
+            *error = d->m_ui.classLineEdit->errorMessage();
         return false;
     }
 
     if (isBaseClassInputVisible() && isBaseClassEditable()) {
         // TODO: Should this be a ClassNameValidatingComboBox?
         QRegExp classNameValidator(QLatin1String("[a-zA-Z_][a-zA-Z0-9_]*(::[a-zA-Z_][a-zA-Z0-9_]*)*"));
-        const QString baseClass = m_d->m_ui.baseClassComboBox->currentText().trimmed();
+        const QString baseClass = d->m_ui.baseClassComboBox->currentText().trimmed();
         if (!baseClass.isEmpty() && !classNameValidator.exactMatch(baseClass)) {
             if (error)
                 *error = tr("Invalid base class name");
@@ -462,31 +462,31 @@ bool NewClassWidget::isValid(QString *error) const
         }
     }
 
-    if (!m_d->m_ui.headerFileLineEdit->isValid()) {
+    if (!d->m_ui.headerFileLineEdit->isValid()) {
         if (error)
-            *error = tr("Invalid header file name: '%1'").arg(m_d->m_ui.headerFileLineEdit->errorMessage());
+            *error = tr("Invalid header file name: '%1'").arg(d->m_ui.headerFileLineEdit->errorMessage());
         return false;
     }
 
-    if (!m_d->m_ui.sourceFileLineEdit->isValid()) {
+    if (!d->m_ui.sourceFileLineEdit->isValid()) {
         if (error)
-            *error = tr("Invalid source file name: '%1'").arg(m_d->m_ui.sourceFileLineEdit->errorMessage());
+            *error = tr("Invalid source file name: '%1'").arg(d->m_ui.sourceFileLineEdit->errorMessage());
         return false;
     }
 
     if (isFormInputVisible() &&
-        (!m_d->m_formInputCheckable || m_d->m_ui.generateFormCheckBox->isChecked())) {
-        if (!m_d->m_ui.formFileLineEdit->isValid()) {
+        (!d->m_formInputCheckable || d->m_ui.generateFormCheckBox->isChecked())) {
+        if (!d->m_ui.formFileLineEdit->isValid()) {
             if (error)
-                *error = tr("Invalid form file name: '%1'").arg(m_d->m_ui.formFileLineEdit->errorMessage());
+                *error = tr("Invalid form file name: '%1'").arg(d->m_ui.formFileLineEdit->errorMessage());
             return false;
         }
     }
 
     if (isPathInputVisible()) {
-        if (!m_d->m_ui.pathChooser->isValid()) {
+        if (!d->m_ui.pathChooser->isValid()) {
             if (error)
-                *error =  m_d->m_ui.pathChooser->errorMessage();
+                *error =  d->m_ui.pathChooser->errorMessage();
             return false;
         }
     }
@@ -495,22 +495,22 @@ bool NewClassWidget::isValid(QString *error) const
 
 void NewClassWidget::triggerUpdateFileNames()
 {
-    m_d->m_ui.classLineEdit->triggerChanged();
+    d->m_ui.classLineEdit->triggerChanged();
 }
 
 void NewClassWidget::slotUpdateFileNames(const QString &baseName)
 {
     if (debugNewClassWidget)
-        qDebug() << Q_FUNC_INFO << baseName << m_d->m_headerExtension << m_d->m_sourceExtension;
+        qDebug() << Q_FUNC_INFO << baseName << d->m_headerExtension << d->m_sourceExtension;
     const QChar dot = QLatin1Char('.');
-    m_d->m_ui.sourceFileLineEdit->setText(baseName + dot + m_d->m_sourceExtension);
-    m_d->m_ui.headerFileLineEdit->setText(baseName + dot + m_d->m_headerExtension);
-    m_d->m_ui.formFileLineEdit->setText(baseName + dot + m_d->m_formExtension);
+    d->m_ui.sourceFileLineEdit->setText(baseName + dot + d->m_sourceExtension);
+    d->m_ui.headerFileLineEdit->setText(baseName + dot + d->m_headerExtension);
+    d->m_ui.formFileLineEdit->setText(baseName + dot + d->m_formExtension);
 }
 
 void NewClassWidget::slotActivated()
 {
-    if (m_d->m_valid)
+    if (d->m_valid)
         emit activated();
 }