GUI: Rename methods in ApplicationList

danmar · danmar · commit 24ce4292f26b · 2017-07-28T05:18:43.000+02:00
diff --git a/gui/applicationlist.cpp b/gui/applicationlist.cpp
@@ -36,10 +36,10 @@ ApplicationList::ApplicationList(QObject *parent) :
 
 ApplicationList::~ApplicationList()
 {
-    Clear();
+    clear();
 }
 
-bool ApplicationList::LoadSettings()
+bool ApplicationList::loadSettings()
 {
     QSettings settings;
     QStringList names = settings.value(SETTINGS_APPLICATION_NAMES, QStringList()).toStringList();
@@ -64,18 +64,18 @@ bool ApplicationList::LoadSettings()
             app.setName("gedit");
             app.setPath("/usr/bin/gedit");
             app.setParameters("+(line) (file)");
-            AddApplication(app);
+            addApplication(app);
             defapp = 0;
         }
-        CheckAndAddApplication("/usr/bin/geany","geany","+(line) (file)");
-        CheckAndAddApplication("/usr/bin/qtcreator","Qt Creator","-client (file):(line)");
+        checkAndAddApplication("/usr/bin/geany","geany","+(line) (file)");
+        checkAndAddApplication("/usr/bin/qtcreator","Qt Creator","-client (file):(line)");
         // use as default for kde environments
         if (QFileInfo("/usr/bin/kate").isExecutable()) {
             Application app;
             app.setName("kate");
             app.setPath("/usr/bin/kate");
             app.setParameters("-l(line) (file)");
-            AddApplication(app);
+            addApplication(app);
             defapp = 0;
         }
 #else
@@ -86,7 +86,7 @@ bool ApplicationList::LoadSettings()
     } else if (names.size() == paths.size()) {
         for (int i = 0; i < names.size(); i++) {
             const Application app(names[i], paths[i], params[i]);
-            AddApplication(app);
+            addApplication(app);
         }
     }
 
@@ -100,15 +100,15 @@ bool ApplicationList::LoadSettings()
     return succeeded;
 }
 
-void ApplicationList::SaveSettings() const
+void ApplicationList::saveSettings() const
 {
     QSettings settings;
     QStringList names;
     QStringList paths;
     QStringList params;
 
-    for (int i = 0; i < GetApplicationCount(); i++) {
-        const Application& app = GetApplication(i);
+    for (int i = 0; i < getApplicationCount(); i++) {
+        const Application& app = getApplication(i);
         names << app.getName();
         paths << app.getPath();
         params << app.getParameters();
@@ -120,12 +120,12 @@ void ApplicationList::SaveSettings() const
     settings.setValue(SETTINGS_APPLICATION_DEFAULT, mDefaultApplicationIndex);
 }
 
-int ApplicationList::GetApplicationCount() const
+int ApplicationList::getApplicationCount() const
 {
     return mApplications.size();
 }
 
-Application& ApplicationList::GetApplication(const int index)
+Application& ApplicationList::getApplication(const int index)
 {
     if (index >= 0 && index < mApplications.size()) {
         return mApplications[index];
@@ -135,7 +135,7 @@ Application& ApplicationList::GetApplication(const int index)
     return dummy;
 }
 
-const Application& ApplicationList::GetApplication(const int index) const
+const Application& ApplicationList::getApplication(const int index) const
 {
     if (index >= 0 && index < mApplications.size()) {
         return mApplications[index];
@@ -145,60 +145,60 @@ const Application& ApplicationList::GetApplication(const int index) const
     return dummy;
 }
 
-void ApplicationList::AddApplication(const Application &app)
+void ApplicationList::addApplication(const Application &app)
 {
     if (app.getName().isEmpty() || app.getPath().isEmpty()) {
         return;
     }
     mApplications << app;
 }
 
-void ApplicationList::RemoveApplication(const int index)
+void ApplicationList::removeApplication(const int index)
 {
     mApplications.removeAt(index);
 }
 
-void ApplicationList::SetDefault(const int index)
+void ApplicationList::setDefault(const int index)
 {
     if (index < mApplications.size() && index >= 0) {
         mDefaultApplicationIndex = index;
     }
 }
 
-void ApplicationList::Copy(const ApplicationList *list)
+void ApplicationList::copy(const ApplicationList *list)
 {
     if (!list) {
         return;
     }
 
-    Clear();
-    for (int i = 0; i < list->GetApplicationCount(); i++) {
-        const Application& app = list->GetApplication(i);
-        AddApplication(app);
+    clear();
+    for (int i = 0; i < list->getApplicationCount(); i++) {
+        const Application& app = list->getApplication(i);
+        addApplication(app);
     }
-    mDefaultApplicationIndex = list->GetDefaultApplication();
+    mDefaultApplicationIndex = list->getDefaultApplication();
 }
 
-void ApplicationList::Clear()
+void ApplicationList::clear()
 {
     mApplications.clear();
     mDefaultApplicationIndex = -1;
 }
 
-bool ApplicationList::CheckAndAddApplication(QString appPath, QString name, QString parameters)
+bool ApplicationList::checkAndAddApplication(QString appPath, QString name, QString parameters)
 {
     if (QFileInfo(appPath).exists() && QFileInfo(appPath).isExecutable()) {
         Application app;
         app.setName(name);
         app.setPath("\"" + appPath + "\"");
         app.setParameters(parameters);
-        AddApplication(app);
+        addApplication(app);
         return true;
     }
     return false;
 }
 
-bool ApplicationList::FindDefaultWindowsEditor()
+bool ApplicationList::findDefaultWindowsEditor()
 {
     bool foundOne = false;
 #ifdef WIN64 // As long as we do support 32-bit XP, we cannot be sure that the environment variable "ProgramFiles(x86)" exists
@@ -209,24 +209,24 @@ bool ApplicationList::FindDefaultWindowsEditor()
     const QString appPathx64(getenv("ProgramW6432"));
     const QString windowsPath(getenv("windir"));
 
-    if (CheckAndAddApplication(appPathx86 + "\\Notepad++\\notepad++.exe", "Notepad++", "-n(line) (file)"))
+    if (checkAndAddApplication(appPathx86 + "\\Notepad++\\notepad++.exe", "Notepad++", "-n(line) (file)"))
         foundOne = true;
-    else if (CheckAndAddApplication(appPathx64 + "\\Notepad++\\notepad++.exe", "Notepad++", "-n(line) (file)"))
+    else if (checkAndAddApplication(appPathx64 + "\\Notepad++\\notepad++.exe", "Notepad++", "-n(line) (file)"))
         foundOne = true;
 
-    if (CheckAndAddApplication(appPathx86 + "\\Notepad2\\Notepad2.exe", "Notepad2", "/g (line) (file)"))
+    if (checkAndAddApplication(appPathx86 + "\\Notepad2\\Notepad2.exe", "Notepad2", "/g (line) (file)"))
         foundOne = true;
-    else if (CheckAndAddApplication(appPathx64 + "\\Notepad2\\Notepad2.exe", "Notepad2", "/g (line) (file)"))
+    else if (checkAndAddApplication(appPathx64 + "\\Notepad2\\Notepad2.exe", "Notepad2", "/g (line) (file)"))
         foundOne = true;
 
-    if (CheckAndAddApplication(windowsPath + "\\system32\\notepad.exe", "Notepad", "(file)"))
+    if (checkAndAddApplication(windowsPath + "\\system32\\notepad.exe", "Notepad", "(file)"))
         foundOne = true;
 
     QString regPath = "HKEY_CLASSES_ROOT\\Applications\\QtProject.QtCreator.pro\\shell\\Open\\command";
     QSettings registry(regPath, QSettings::NativeFormat);
     QString qtCreatorRegistry = registry.value("Default", QString()).toString();
     QString qtCreatorPath = qtCreatorRegistry.left(qtCreatorRegistry.indexOf(".exe") + 4);
-    if (!qtCreatorRegistry.isEmpty() && CheckAndAddApplication(qtCreatorPath, "Qt Creator", "-client (file):(line)")) {
+    if (!qtCreatorRegistry.isEmpty() && checkAndAddApplication(qtCreatorPath, "Qt Creator", "-client (file):(line)")) {
         foundOne = true;
     }
     return foundOne;
diff --git a/gui/applicationlist.h b/gui/applicationlist.h
@@ -43,33 +43,33 @@ class ApplicationList : public QObject {
     *  application list. Most probably because of older version settings need
     *  to be upgraded.
     */
-    bool LoadSettings();
+    bool loadSettings();
 
     /**
     * @brief Save all applications
     */
-    void SaveSettings() const;
+    void saveSettings() const;
 
     /**
     * @brief Get the amount of applications in the list
     * @return The count of applications
     */
-    int GetApplicationCount() const;
+    int getApplicationCount() const;
 
     /**
     * @brief Get specific application's name
     *
     * @param index Index of the application whose name to get
     * @return Name of the application
     */
-    const Application& GetApplication(const int index) const;
-    Application& GetApplication(const int index);
+    const Application& getApplication(const int index) const;
+    Application& getApplication(const int index);
 
     /**
     * @brief Return the default application.
     * @return Index of the default application.
     */
-    int GetDefaultApplication() const {
+    int getDefaultApplication() const {
         return mDefaultApplicationIndex;
     }
 
@@ -78,45 +78,45 @@ class ApplicationList : public QObject {
     *
     * @param app Application to add.
     */
-    void AddApplication(const Application &app);
+    void addApplication(const Application &app);
 
     /**
     * @brief Remove an application from the list
     *
     * @param index Index of the application to remove.
     */
-    void RemoveApplication(const int index);
+    void removeApplication(const int index);
 
     /**
     * @brief Set application as default application.
     * @param index Index of the application to make the default one
     */
-    void SetDefault(const int index);
+    void setDefault(const int index);
 
     /**
     * @brief Remove all applications from this list and copy all applications from
     * list given as a parameter.
     * @param list Copying source
     */
-    void Copy(const ApplicationList *list);
+    void copy(const ApplicationList *list);
 
 protected:
 
     /**
     * @brief Clear the list
     *
     */
-    void Clear();
+    void clear();
 
     /**
     * @brief Find editor used by default in Windows.
     * Check if Notepad++ is installed and use it. If not, use Notepad.
     */
-    bool FindDefaultWindowsEditor();
+    bool findDefaultWindowsEditor();
 
 private:
 
-    bool CheckAndAddApplication(QString appPath, QString name, QString parameters);
+    bool checkAndAddApplication(QString appPath, QString name, QString parameters);
 
     /**
     * @brief List of applications
diff --git a/gui/mainwindow.cpp b/gui/mainwindow.cpp
@@ -298,7 +298,7 @@ void MainWindow::LoadSettings()
     else
         mUI.mActionAutoDetectLanguage->setChecked(true);
 
-    bool succeeded = mApplications->LoadSettings();
+    bool succeeded = mApplications->loadSettings();
     if (!succeeded) {
         const QString msg = tr("There was a problem with loading the editor application settings.\n\n"
                                "This is probably because the settings were changed between the Cppcheck versions. "
@@ -349,7 +349,7 @@ void MainWindow::SaveSettings() const
     else
         mSettings->setValue(SETTINGS_ENFORCED_LANGUAGE, Settings::None);
 
-    mApplications->SaveSettings();
+    mApplications->saveSettings();
 
     mSettings->setValue(SETTINGS_LANGUAGE, mTranslation->GetCurrentLanguage());
     mUI.mResults->SaveSettings(mSettings);
diff --git a/gui/resultstree.cpp b/gui/resultstree.cpp
@@ -530,12 +530,12 @@ void ResultsTree::contextMenuEvent(QContextMenuEvent * e)
         //member variables
         QSignalMapper *signalMapper = new QSignalMapper(this);
 
-        if (mContextItem && mApplications->GetApplicationCount() > 0 && mContextItem->parent()) {
+        if (mContextItem && mApplications->getApplicationCount() > 0 && mContextItem->parent()) {
             //Create an action for the application
-            int defaultApplicationIndex = mApplications->GetDefaultApplication();
+            int defaultApplicationIndex = mApplications->getDefaultApplication();
             if (defaultApplicationIndex < 0)
                 defaultApplicationIndex = 0;
-            const Application& app = mApplications->GetApplication(defaultApplicationIndex);
+            const Application& app = mApplications->getApplication(defaultApplicationIndex);
             QAction *start = new QAction(app.getName(), &menu);
             if (multipleSelection)
                 start->setDisabled(true);
@@ -558,7 +558,7 @@ void ResultsTree::contextMenuEvent(QContextMenuEvent * e)
 
         // Add menuitems to copy full path/filename to clipboard
         if (mContextItem) {
-            if (mApplications->GetApplicationCount() > 0) {
+            if (mApplications->getApplicationCount() > 0) {
                 menu.addSeparator();
             }
 
@@ -609,7 +609,7 @@ void ResultsTree::contextMenuEvent(QContextMenuEvent * e)
         index = indexAt(e->pos());
         if (index.isValid()) {
             mContextItem = mModel.itemFromIndex(index);
-            if (mContextItem && mApplications->GetApplicationCount() > 0 && mContextItem->parent()) {
+            if (mContextItem && mApplications->getApplicationCount() > 0 && mContextItem->parent()) {
                 //Disconnect all signals
                 for (int i = 0; i < actions.size(); i++) {
 
@@ -628,7 +628,7 @@ void ResultsTree::contextMenuEvent(QContextMenuEvent * e)
 void ResultsTree::StartApplication(QStandardItem *target, int application)
 {
     //If there are no applications specified, tell the user about it
-    if (mApplications->GetApplicationCount() == 0) {
+    if (mApplications->getApplicationCount() == 0) {
         QMessageBox msg(QMessageBox::Critical,
                         tr("Cppcheck"),
                         tr("No editor application configured.\n\n"
@@ -640,7 +640,7 @@ void ResultsTree::StartApplication(QStandardItem *target, int application)
     }
 
     if (application == -1)
-        application = mApplications->GetDefaultApplication();
+        application = mApplications->getDefaultApplication();
 
     if (application == -1) {
         QMessageBox msg(QMessageBox::Critical,
@@ -654,7 +654,7 @@ void ResultsTree::StartApplication(QStandardItem *target, int application)
 
     }
 
-    if (target && application >= 0 && application < mApplications->GetApplicationCount() && target->parent()) {
+    if (target && application >= 0 && application < mApplications->getApplicationCount() && target->parent()) {
         // Make sure we are working with the first column
         if (target->column() != 0)
             target = target->parent()->child(target->row(), 0);
@@ -694,7 +694,7 @@ void ResultsTree::StartApplication(QStandardItem *target, int application)
             file.append("\"");
         }
 
-        const Application& app = mApplications->GetApplication(application);
+        const Application& app = mApplications->getApplication(application);
         QString params = app.getParameters();
         params.replace("(file)", file, Qt::CaseInsensitive);
 
diff --git a/gui/settingsdialog.cpp b/gui/settingsdialog.cpp

Original file line number	Diff line number	Diff line change
`@@ -36,10 +36,10 @@ ApplicationList::ApplicationList(QObject *parent) :`
`36`	`36`
`37`	`37`	`ApplicationList::~ApplicationList()`
`38`	`38`	`{`
`39`		`- Clear();`
	`39`	`+ clear();`
`40`	`40`	`}`
`41`	`41`
`42`		`-bool ApplicationList::LoadSettings()`
	`42`	`+bool ApplicationList::loadSettings()`
`43`	`43`	`{`
`44`	`44`	`QSettings settings;`
`45`	`45`	`QStringList names = settings.value(SETTINGS_APPLICATION_NAMES, QStringList()).toStringList();`
`@@ -64,18 +64,18 @@ bool ApplicationList::LoadSettings()`
`64`	`64`	`app.setName("gedit");`
`65`	`65`	`app.setPath("/usr/bin/gedit");`
`66`	`66`	`app.setParameters("+(line) (file)");`
`67`		`- AddApplication(app);`
	`67`	`+ addApplication(app);`
`68`	`68`	`defapp = 0;`
`69`	`69`	`}`
`70`		`- CheckAndAddApplication("/usr/bin/geany","geany","+(line) (file)");`
`71`		`- CheckAndAddApplication("/usr/bin/qtcreator","Qt Creator","-client (file):(line)");`
	`70`	`+ checkAndAddApplication("/usr/bin/geany","geany","+(line) (file)");`
	`71`	`+ checkAndAddApplication("/usr/bin/qtcreator","Qt Creator","-client (file):(line)");`
`72`	`72`	`// use as default for kde environments`
`73`	`73`	`if (QFileInfo("/usr/bin/kate").isExecutable()) {`
`74`	`74`	`Application app;`
`75`	`75`	`app.setName("kate");`
`76`	`76`	`app.setPath("/usr/bin/kate");`
`77`	`77`	`app.setParameters("-l(line) (file)");`
`78`		`- AddApplication(app);`
	`78`	`+ addApplication(app);`
`79`	`79`	`defapp = 0;`
`80`	`80`	`}`
`81`	`81`	`#else`
`@@ -86,7 +86,7 @@ bool ApplicationList::LoadSettings()`
`86`	`86`	`} else if (names.size() == paths.size()) {`
`87`	`87`	`for (int i = 0; i < names.size(); i++) {`
`88`	`88`	`const Application app(names[i], paths[i], params[i]);`
`89`		`- AddApplication(app);`
	`89`	`+ addApplication(app);`
`90`	`90`	`}`
`91`	`91`	`}`
`92`	`92`
`@@ -100,15 +100,15 @@ bool ApplicationList::LoadSettings()`
`100`	`100`	`return succeeded;`
`101`	`101`	`}`
`102`	`102`
`103`		`-void ApplicationList::SaveSettings() const`
	`103`	`+void ApplicationList::saveSettings() const`
`104`	`104`	`{`
`105`	`105`	`QSettings settings;`
`106`	`106`	`QStringList names;`
`107`	`107`	`QStringList paths;`
`108`	`108`	`QStringList params;`
`109`	`109`
`110`		`- for (int i = 0; i < GetApplicationCount(); i++) {`
`111`		`- const Application& app = GetApplication(i);`
	`110`	`+ for (int i = 0; i < getApplicationCount(); i++) {`
	`111`	`+ const Application& app = getApplication(i);`
`112`	`112`	`names << app.getName();`
`113`	`113`	`paths << app.getPath();`
`114`	`114`	`params << app.getParameters();`
`@@ -120,12 +120,12 @@ void ApplicationList::SaveSettings() const`
`120`	`120`	`settings.setValue(SETTINGS_APPLICATION_DEFAULT, mDefaultApplicationIndex);`
`121`	`121`	`}`
`122`	`122`
`123`		`-int ApplicationList::GetApplicationCount() const`
	`123`	`+int ApplicationList::getApplicationCount() const`
`124`	`124`	`{`
`125`	`125`	`return mApplications.size();`
`126`	`126`	`}`
`127`	`127`
`128`		`-Application& ApplicationList::GetApplication(const int index)`
	`128`	`+Application& ApplicationList::getApplication(const int index)`
`129`	`129`	`{`
`130`	`130`	`if (index >= 0 && index < mApplications.size()) {`
`131`	`131`	`return mApplications[index];`
`@@ -135,7 +135,7 @@ Application& ApplicationList::GetApplication(const int index)`
`135`	`135`	`return dummy;`
`136`	`136`	`}`
`137`	`137`
`138`		`-const Application& ApplicationList::GetApplication(const int index) const`
	`138`	`+const Application& ApplicationList::getApplication(const int index) const`
`139`	`139`	`{`
`140`	`140`	`if (index >= 0 && index < mApplications.size()) {`
`141`	`141`	`return mApplications[index];`
`@@ -145,60 +145,60 @@ const Application& ApplicationList::GetApplication(const int index) const`
`145`	`145`	`return dummy;`
`146`	`146`	`}`
`147`	`147`
`148`		`-void ApplicationList::AddApplication(const Application &app)`
	`148`	`+void ApplicationList::addApplication(const Application &app)`
`149`	`149`	`{`
`150`	`150`	`if (app.getName().isEmpty() \|\| app.getPath().isEmpty()) {`
`151`	`151`	`return;`
`152`	`152`	`}`
`153`	`153`	`mApplications << app;`
`154`	`154`	`}`
`155`	`155`
`156`		`-void ApplicationList::RemoveApplication(const int index)`
	`156`	`+void ApplicationList::removeApplication(const int index)`
`157`	`157`	`{`
`158`	`158`	`mApplications.removeAt(index);`
`159`	`159`	`}`
`160`	`160`
`161`		`-void ApplicationList::SetDefault(const int index)`
	`161`	`+void ApplicationList::setDefault(const int index)`
`162`	`162`	`{`
`163`	`163`	`if (index < mApplications.size() && index >= 0) {`
`164`	`164`	`mDefaultApplicationIndex = index;`
`165`	`165`	`}`
`166`	`166`	`}`
`167`	`167`
`168`		`-void ApplicationList::Copy(const ApplicationList *list)`
	`168`	`+void ApplicationList::copy(const ApplicationList *list)`
`169`	`169`	`{`
`170`	`170`	`if (!list) {`
`171`	`171`	`return;`
`172`	`172`	`}`
`173`	`173`
`174`		`- Clear();`
`175`		`- for (int i = 0; i < list->GetApplicationCount(); i++) {`
`176`		`- const Application& app = list->GetApplication(i);`
`177`		`- AddApplication(app);`
	`174`	`+ clear();`
	`175`	`+ for (int i = 0; i < list->getApplicationCount(); i++) {`
	`176`	`+ const Application& app = list->getApplication(i);`
	`177`	`+ addApplication(app);`
`178`	`178`	`}`
`179`		`- mDefaultApplicationIndex = list->GetDefaultApplication();`
	`179`	`+ mDefaultApplicationIndex = list->getDefaultApplication();`
`180`	`180`	`}`
`181`	`181`
`182`		`-void ApplicationList::Clear()`
	`182`	`+void ApplicationList::clear()`
`183`	`183`	`{`
`184`	`184`	`mApplications.clear();`
`185`	`185`	`mDefaultApplicationIndex = -1;`
`186`	`186`	`}`
`187`	`187`
`188`		`-bool ApplicationList::CheckAndAddApplication(QString appPath, QString name, QString parameters)`
	`188`	`+bool ApplicationList::checkAndAddApplication(QString appPath, QString name, QString parameters)`
`189`	`189`	`{`
`190`	`190`	`if (QFileInfo(appPath).exists() && QFileInfo(appPath).isExecutable()) {`
`191`	`191`	`Application app;`
`192`	`192`	`app.setName(name);`
`193`	`193`	`app.setPath("\"" + appPath + "\"");`
`194`	`194`	`app.setParameters(parameters);`
`195`		`- AddApplication(app);`
	`195`	`+ addApplication(app);`
`196`	`196`	`return true;`
`197`	`197`	`}`
`198`	`198`	`return false;`
`199`	`199`	`}`
`200`	`200`
`201`		`-bool ApplicationList::FindDefaultWindowsEditor()`
	`201`	`+bool ApplicationList::findDefaultWindowsEditor()`
`202`	`202`	`{`
`203`	`203`	`bool foundOne = false;`
`204`	`204`	`#ifdef WIN64 // As long as we do support 32-bit XP, we cannot be sure that the environment variable "ProgramFiles(x86)" exists`
`@@ -209,24 +209,24 @@ bool ApplicationList::FindDefaultWindowsEditor()`
`209`	`209`	`const QString appPathx64(getenv("ProgramW6432"));`
`210`	`210`	`const QString windowsPath(getenv("windir"));`
`211`	`211`
`212`		`- if (CheckAndAddApplication(appPathx86 + "\\Notepad++\\notepad++.exe", "Notepad++", "-n(line) (file)"))`
	`212`	`+ if (checkAndAddApplication(appPathx86 + "\\Notepad++\\notepad++.exe", "Notepad++", "-n(line) (file)"))`
`213`	`213`	`foundOne = true;`
`214`		`- else if (CheckAndAddApplication(appPathx64 + "\\Notepad++\\notepad++.exe", "Notepad++", "-n(line) (file)"))`
	`214`	`+ else if (checkAndAddApplication(appPathx64 + "\\Notepad++\\notepad++.exe", "Notepad++", "-n(line) (file)"))`
`215`	`215`	`foundOne = true;`
`216`	`216`
`217`		`- if (CheckAndAddApplication(appPathx86 + "\\Notepad2\\Notepad2.exe", "Notepad2", "/g (line) (file)"))`
	`217`	`+ if (checkAndAddApplication(appPathx86 + "\\Notepad2\\Notepad2.exe", "Notepad2", "/g (line) (file)"))`
`218`	`218`	`foundOne = true;`
`219`		`- else if (CheckAndAddApplication(appPathx64 + "\\Notepad2\\Notepad2.exe", "Notepad2", "/g (line) (file)"))`
	`219`	`+ else if (checkAndAddApplication(appPathx64 + "\\Notepad2\\Notepad2.exe", "Notepad2", "/g (line) (file)"))`
`220`	`220`	`foundOne = true;`
`221`	`221`
`222`		`- if (CheckAndAddApplication(windowsPath + "\\system32\\notepad.exe", "Notepad", "(file)"))`
	`222`	`+ if (checkAndAddApplication(windowsPath + "\\system32\\notepad.exe", "Notepad", "(file)"))`
`223`	`223`	`foundOne = true;`
`224`	`224`
`225`	`225`	`QString regPath = "HKEY_CLASSES_ROOT\\Applications\\QtProject.QtCreator.pro\\shell\\Open\\command";`
`226`	`226`	`QSettings registry(regPath, QSettings::NativeFormat);`
`227`	`227`	`QString qtCreatorRegistry = registry.value("Default", QString()).toString();`
`228`	`228`	`QString qtCreatorPath = qtCreatorRegistry.left(qtCreatorRegistry.indexOf(".exe") + 4);`
`229`		`- if (!qtCreatorRegistry.isEmpty() && CheckAndAddApplication(qtCreatorPath, "Qt Creator", "-client (file):(line)")) {`
	`229`	`+ if (!qtCreatorRegistry.isEmpty() && checkAndAddApplication(qtCreatorPath, "Qt Creator", "-client (file):(line)")) {`
`230`	`230`	`foundOne = true;`
`231`	`231`	`}`
`232`	`232`	`return foundOne;`