resolve naming conflicts to 'backtrack'

udpate

src/config/CMakeLists.txt

@@ -17,5 +17,5 @@ target_sources(
         styleoverride.cpp
         uicoloreditor.cpp
         visualseditor.cpp
-        backtrackingimpl.cpp
+        backtrackconf.cpp
 )

src/config/backtrackingimpl.cpp → src/config/backtrackconf.cpp

@@ -1,15 +1,15 @@
-#include "backtrackingimpl.h"
+#include "backtrackconf.h"
 
 #include "abstractlogger.h"
 
-#include <QLabel>
 #include <QVBoxLayout>
 #include <QtCore/qstandardpaths.h>
 #include <QtCore/qstring.h>
 #include <QtWidgets/qboxlayout.h>
 #include <QtWidgets/qcheckbox.h>
 #include <QtWidgets/qfiledialog.h>
 #include <QtWidgets/qgroupbox.h>
+#include <QtWidgets/qlabel.h>
 #include <QtWidgets/qlayoutitem.h>
 #include <QtWidgets/qlineedit.h>
 #include <QtWidgets/qmessagebox.h>
@@ -20,58 +20,57 @@
 #include <cacheutils.h>
 #include <confighandler.h>
 
-namespace btk {
-class BackTrackerConfigPrivate
+class BacktrackConfigPrivate
 {
-    friend class BackTrackerConfigGroup;
+    friend class BacktrackConfigGroup;
     constexpr static int limits_max = 200;
     constexpr static int limits_min = 0;
 
 public:
-    QCheckBox* enableBackTrackerCheckBox;
-    QLineEdit* backTrackerPath;
+    QCheckBox* enableCheckBox;
+    QLineEdit* cachePath;
     QPushButton* choosePathBtn;
-    QPushButton* rollbackBtn;
+    QPushButton* setCachePath2DefaultBtn;
     QSpinBox* cacheNumbersSpinBox;
 };
 
-BackTrackerConfigGroup::BackTrackerConfigGroup(QWidget* parent)
+BacktrackConfigGroup::BacktrackConfigGroup(QWidget* parent)
   : QGroupBox(tr("BackTracking"), parent)
-  , p(new BackTrackerConfigPrivate)
+  , p(new BacktrackConfigPrivate)
+  , m_configHandler(ConfigHandler::getInstance())
 {
     init();
 }
-BackTrackerConfigGroup::~BackTrackerConfigGroup()
+BacktrackConfigGroup::~BacktrackConfigGroup()
 {
-    delete p;
     p = nullptr;
 }
-void BackTrackerConfigGroup::init()
+void BacktrackConfigGroup::init()
 {
-    p->enableBackTrackerCheckBox = new QCheckBox(tr("enable"), this);
-    p->enableBackTrackerCheckBox->setToolTip(tr("If enable the backtraking"));
-    p->enableBackTrackerCheckBox->setChecked(
-      ConfigHandler().backtrackingEnable());
-    connect(p->enableBackTrackerCheckBox,
+    p->enableCheckBox = new QCheckBox(tr("enable"), this);
+    p->enableCheckBox->setToolTip(tr("If enable the backtraking"));
+    p->enableCheckBox->setChecked(ConfigHandler().backtrackEnable());
+    connect(p->enableCheckBox,
             &QCheckBox::clicked,
             this,
-            &BackTrackerConfigGroup::setEnable);
+            &BacktrackConfigGroup::setEnable);
     setFlat(true);
     auto* vboxLayout = new QVBoxLayout();
     setLayout(vboxLayout);
 
     auto* firstHBoxLayout = new QHBoxLayout();
     vboxLayout->addLayout(firstHBoxLayout);
-    firstHBoxLayout->addWidget(p->enableBackTrackerCheckBox);
+    firstHBoxLayout->addWidget(p->enableCheckBox);
 
     auto* spinboxLabel = new QLabel(tr("cache size"));
     spinboxLabel->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Expanding);
 
     p->cacheNumbersSpinBox = new QSpinBox();
-    p->cacheNumbersSpinBox->setValue(ConfigHandler().backtrackingCacheLimits());
+    p->cacheNumbersSpinBox->setValue(
+      m_configHandler->backtrackCacheLimits());
     p->cacheNumbersSpinBox->setFixedWidth(50);
-    p->cacheNumbersSpinBox->setMinimum(BackTrackerConfigPrivate::limits_min);
-    p->cacheNumbersSpinBox->setMaximum(BackTrackerConfigPrivate::limits_max);
+    p->cacheNumbersSpinBox->setMinimum(BacktrackConfigPrivate::limits_min);
+    p->cacheNumbersSpinBox->setMaximum(BacktrackConfigPrivate::limits_max);
 
     connect(p->cacheNumbersSpinBox,
             &QSpinBox::textChanged,
@@ -86,51 +85,52 @@ void BackTrackerConfigGroup::init()
     auto* choosePathLayout = new QHBoxLayout();
     vboxLayout->addLayout(choosePathLayout);
 
-    p->backTrackerPath = new QLineEdit();
-    p->backTrackerPath->setReadOnly(true);
-    p->backTrackerPath->setPlaceholderText(
+    p->cachePath = new QLineEdit();
+    p->cachePath->setReadOnly(true);
+    p->cachePath->setPlaceholderText(
       tr("choose your path to save backtracking cache"));
-    p->backTrackerPath->setToolTip(
+    p->cachePath->setToolTip(
       tr("choose your path to save backtracking cache\ndefaults to: %1")
         .arg(getCachePath()));
-    p->backTrackerPath->setStyleSheet(R"(
+    p->cachePath->setStyleSheet(R"(
     border-right-width: 0px;
     )");
 
-    choosePathLayout->addWidget(p->backTrackerPath);
+    choosePathLayout->addWidget(p->cachePath);
 
-    p->rollbackBtn = new QPushButton(tr("↩️"));
-    p->rollbackBtn->setFixedWidth(20);
-    p->rollbackBtn->setToolTip(tr("set path to default"));
-    p->rollbackBtn->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Preferred);
-    p->rollbackBtn->setStyleSheet(QString(R"(
+    p->setCachePath2DefaultBtn = new QPushButton(tr("↩️"));
+    p->setCachePath2DefaultBtn->setFixedWidth(20);
+    p->setCachePath2DefaultBtn->setToolTip(tr("set path to default"));
+    p->setCachePath2DefaultBtn->setSizePolicy(QSizePolicy::Fixed,
+                                              QSizePolicy::Preferred);
+    p->setCachePath2DefaultBtn->setStyleSheet(QString(R"(
    QPushButton{
          margin-right: 14px;
         // margin-top: 0px;
         // margin-bottom: 0px;
         border-width: 0px;
    }
     )"));
-    connect(p->rollbackBtn,
+    connect(p->setCachePath2DefaultBtn,
             &QPushButton::clicked,
             this,
-            &BackTrackerConfigGroup::pathRollBack);
-    choosePathLayout->addWidget(p->rollbackBtn);
+            &BacktrackConfigGroup::setPath2Default);
+    choosePathLayout->addWidget(p->setCachePath2DefaultBtn);
     choosePathLayout->setSpacing(0);
 
     p->choosePathBtn = new QPushButton(tr("Change.."));
     choosePathLayout->addWidget(p->choosePathBtn);
     connect(p->choosePathBtn,
             &QPushButton::clicked,
             this,
-            &BackTrackerConfigGroup::browseFolder);
+            &BacktrackConfigGroup::browseFolder);
 
-    if (ConfigHandler().backtrackingCachePath().isEmpty()) {
-        ConfigHandler().setBacktrackingCachePath(getCachePath());
+    if (ConfigHandler::getInstance()->backtrackCachePath().isEmpty()) {
+        ConfigHandler::getInstance()->setBacktrackCachePath(getCachePath());
     }
-    p->backTrackerPath->setText(ConfigHandler().backtrackingCachePath());
+    p->cachePath->setText(ConfigHandler::getInstance()->backtrackCachePath());
 }
-QString BackTrackerConfigGroup::chooseFolder(const QString& defaultPath)
+QString BacktrackConfigGroup::chooseFolder(const QString& defaultPath)
 {
     QString path = defaultPath;
     if (defaultPath.isEmpty()) {
@@ -153,32 +153,31 @@ QString BackTrackerConfigGroup::chooseFolder(const QString& defaultPath)
 
     return path;
 }
-void BackTrackerConfigGroup::browseFolder()
+void BacktrackConfigGroup::browseFolder()
 {
-    auto targetFolder = chooseFolder(ConfigHandler().backtrackingCachePath());
+    auto targetFolder = chooseFolder(ConfigHandler().backtrackCachePath());
     if (targetFolder.isEmpty()) {
         AbstractLogger::error()
           << "backtracking: cache folder path you choose is empty";
         return;
     }
-    p->backTrackerPath->setText(targetFolder);
-    ConfigHandler().setBacktrackingCachePath(targetFolder);
+    p->cachePath->setText(targetFolder);
+    ConfigHandler().setBacktrackCachePath(targetFolder);
 }
-void BackTrackerConfigGroup::setEnable(bool value)
+void BacktrackConfigGroup::setEnable(bool value)
 {
-    ConfigHandler().setBacktrackingEnable(value);
+    m_configHandler->setBacktrackEnable(value);
 }
-void BackTrackerConfigGroup::pathRollBack()
+void BacktrackConfigGroup::setPath2Default()
 {
-    ConfigHandler().setBacktrackingCachePath(getCachePath());
-    p->backTrackerPath->setText(getCachePath());
+    m_configHandler->setBacktrackCachePath(getCachePath());
+    p->cachePath->setText(getCachePath());
 }
-void BackTrackerConfigGroup::setCacheLimits(int val)
+void BacktrackConfigGroup::setCacheLimits(int val)
 {
-    if (val > BackTrackerConfigPrivate::limits_max ||
-        val < BackTrackerConfigPrivate::limits_min) {
+    if (val > BacktrackConfigPrivate::limits_max ||
+        val < BacktrackConfigPrivate::limits_min) {
         return;
     }
-    ConfigHandler().setBacktrackingCacheLimits(val);
-}
-} // btk
+    m_configHandler->setBacktrackCacheLimits(val);
+}

src/config/backtrackingimpl.h → src/config/backtrackconf.h

@@ -17,26 +17,24 @@ class QLabel;
 class QLineEdit;
 class QSpinBox;
 class QComboBox;
-namespace btk {
 
-class BackTrackerConfigPrivate;
-class BackTrackerConfigGroup : public QGroupBox
+class BacktrackConfigGroup : public QGroupBox
 {
     Q_OBJECT
 public:
-    explicit BackTrackerConfigGroup(QWidget* parent = nullptr);
-    ~BackTrackerConfigGroup() override;
+    explicit BacktrackConfigGroup(QWidget* parent = nullptr);
+    ~BacktrackConfigGroup() override;
 
 private:
-    BackTrackerConfigPrivate* p;
+    std::unique_ptr<class BacktrackConfigPrivate> p;
     void init();
     QString chooseFolder(const QString& defaultPath);
+    class ConfigHandler* m_configHandler;
 public slots:
     void browseFolder();
     void setEnable(bool value);
-    void pathRollBack();
+    void setPath2Default();
     void setCacheLimits(int val);
 };
-} // btk
 
 #endif // BACKTRACKINGIMPL_H

src/config/generalconf.cpp

@@ -1,9 +1,9 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 // SPDX-FileCopyrightText: 2017-2019 Alejandro Sirgo Rica & Contributors
 #include "generalconf.h"
-#include "backtrackingimpl.h"
-#include "src/core/flameshot.h"
-#include "src/utils/confighandler.h"
+#include "backtrackconf.h"
+#include "confighandler.h"
+#include "flameshot.h"
 #include <QCheckBox>
 #include <QComboBox>
 #include <QFile>
@@ -50,7 +50,7 @@ GeneralConf::GeneralConf(QWidget* parent)
     initUseJpgForClipboard();
     initCopyOnDoubleClick();
     initSaveAfterCopy();
-    initBackTrackerSettings();
+    initBacktrackConfig();
     initCopyPathAfterSave();
     initCopyAndCloseAfterUpload();
     initUploadWithoutConfirmation();
@@ -800,9 +800,9 @@ void GeneralConf::initJpegQuality()
             this,
             &GeneralConf::setJpegQuality);
 }
-void GeneralConf::initBackTrackerSettings()
+void GeneralConf::initBacktrackConfig()
 {
-    m_backTrackingConfig = new btk::BackTrackerConfigGroup(this);
+    m_backTrackingConfig = new BacktrackConfigGroup(this);
     m_layout->addWidget(m_backTrackingConfig);
 }
 

src/config/generalconf.h

@@ -13,9 +13,9 @@ class QLabel;
 class QLineEdit;
 class QSpinBox;
 class QComboBox;
-namespace btk {
-class BackTrackerConfigGroup;
-}
+
+class BacktrackConfigGroup;
+
 class GeneralConf : public QWidget
 {
     Q_OBJECT
@@ -95,7 +95,7 @@ private slots:
     void initShowSelectionGeometry();
     void initJpegQuality();
 
-    void initBackTrackerSettings();
+    void initBacktrackConfig();
 
     void _updateComponents(bool allowEmptySavePath);
 
@@ -141,5 +141,5 @@ private slots:
     QSpinBox* m_xywhTimeout;
     QSpinBox* m_jpegQuality;
 
-    btk::BackTrackerConfigGroup* m_backTrackingConfig;
+    BacktrackConfigGroup* m_backTrackingConfig;
 };

src/utils/CMakeLists.txt

@@ -8,7 +8,7 @@ target_sources(
           valuehandler.h
           request.h
           strfparse.h
-          capturehistoryutils.h
+        backtrackutils.h
 )
 
 target_sources(
@@ -28,7 +28,7 @@ target_sources(
           history.cpp
           strfparse.cpp
           request.cpp
-          capturehistoryutils.cpp
+        backtrackutils.cpp
 )
 
 IF (WIN32)