Port to StandardPaths

Author: wengxt

CMakeLists.txt

@@ -11,7 +11,6 @@ include(GNUInstallDirs)
 include(ECMUninstallTarget)
 
 option(ENABLE_QT "Enable Qt for GUI configuration" On)
-option(USE_QT6 "Build against Qt6" On)
 
 find_package(PkgConfig REQUIRED)
 find_package(Fcitx5Core ${REQUIRED_FCITX_VERSION} REQUIRED)
@@ -22,14 +21,9 @@ pkg_check_modules(JSonGlib IMPORTED_TARGET "json-glib-1.0" REQUIRED)
 pkg_check_modules(GObject2 IMPORTED_TARGET "gobject-2.0" REQUIRED)
 
 if (ENABLE_QT)
-if (USE_QT6)
     set(QT_MAJOR_VERSION 6)
     find_package(Qt6 REQUIRED COMPONENTS Core Gui Widgets)
-else()
-    set(QT_MAJOR_VERSION 5)
-    find_package(Qt5 5.7 REQUIRED COMPONENTS Core Gui Widgets)
-endif()
-find_package(Fcitx5Qt${QT_MAJOR_VERSION}WidgetsAddons REQUIRED)
+    find_package(Fcitx5Qt${QT_MAJOR_VERSION}WidgetsAddons REQUIRED)
 endif ()
 
 if (NOT SKK_DEFAULT_PATH)

gui/adddictdialog.cpp

@@ -7,10 +7,17 @@
 
 #include "adddictdialog.h"
 #include "config.h"
+#include <QDialog>
+#include <QDir>
 #include <QFileDialog>
+#include <QFileInfo>
+#include <QMap>
+#include <QPushButton>
+#include <QString>
+#include <QWidget>
 #include <array>
 #include <fcitx-utils/i18n.h>
-#include <fcitx-utils/standardpath.h>
+#include <fcitx-utils/standardpaths.h>
 #include <fcitx-utils/stringutils.h>
 
 #define FCITX_CONFIG_DIR_STR "$FCITX_CONFIG_DIR"
@@ -52,10 +59,10 @@ void AddDictDialog::browseClicked() {
                                             info.path());
     } else {
         constexpr char configDir[] = FCITX_CONFIG_DIR_STR "/";
-        auto fcitxBasePath = stringutils::joinPath(
-            StandardPath::global().userDirectory(StandardPath::Type::PkgData));
+        auto fcitxBasePath =
+            StandardPaths::global().userDirectory(StandardPathsType::PkgData);
         QString basePath =
-            QDir::cleanPath(QString::fromLocal8Bit(fcitxBasePath.data()));
+            QDir::cleanPath(QString::fromStdString(fcitxBasePath.string()));
         if (path.isEmpty()) {
             path = basePath;
         } else if (path.startsWith(configDir)) {

gui/dictmodel.cpp

@@ -6,12 +6,19 @@
  */
 
 #include "dictmodel.h"
+#include <QAbstractListModel>
 #include <QFile>
+#include <QIODevice>
+#include <QMap>
+#include <QObject>
 #include <QSet>
+#include <QString>
 #include <QStringList>
+#include <QVariant>
+#include <Qt>
 #include <QtGlobal>
-#include <fcitx-utils/standardpath.h>
-#include <fcntl.h>
+#include <fcitx-utils/standardpaths.h>
+
 namespace fcitx {
 
 DictModel::DictModel(QObject *parent) : QAbstractListModel(parent) {
@@ -23,17 +30,16 @@ DictModel::DictModel(QObject *parent) : QAbstractListModel(parent) {
 DictModel::~DictModel() {}
 
 void DictModel::defaults() {
-    auto path =
-        StandardPath::global().fcitxPath("pkgdatadir", "kkc/dictionary_list");
-    QFile f(path.data());
+    auto path = StandardPaths::fcitxPath("pkgdatadir", "kkc/dictionary_list");
+    QFile f(path);
     if (f.open(QIODevice::ReadOnly)) {
         load(f);
     }
 }
 
 void DictModel::load() {
-    auto file = StandardPath::global().open(StandardPath::Type::PkgData,
-                                            "kkc/dictionary_list", O_RDONLY);
+    auto file = StandardPaths::global().open(StandardPathsType::PkgData,
+                                             "kkc/dictionary_list");
     if (file.fd() < 0) {
         return;
     }
@@ -60,7 +66,7 @@ void DictModel::load(QFile &file) {
 
         bool failed = false;
         QMap<QString, QString> dict;
-        Q_FOREACH (const QString &item, items) {
+        for (const QString &item : items) {
             if (!item.contains('=')) {
                 failed = true;
                 break;
@@ -83,18 +89,18 @@ void DictModel::load(QFile &file) {
 }
 
 bool DictModel::save() {
-    return StandardPath::global().safeSave(
-        StandardPath::Type::PkgData, "kkc/dictionary_list", [this](int fd) {
+    return StandardPaths::global().safeSave(
+        StandardPathsType::PkgData, "kkc/dictionary_list", [this](int fd) {
             QFile tempFile;
             if (!tempFile.open(fd, QIODevice::WriteOnly)) {
                 return false;
             }
 
-            typedef QMap<QString, QString> DictType;
+            using DictType = QMap<QString, QString>;
 
-            Q_FOREACH (const DictType &dict, dicts_) {
+            for (const DictType &dict : dicts_) {
                 bool first = true;
-                Q_FOREACH (const QString &key, dict.keys()) {
+                for (const QString &key : dict.keys()) {
                     if (first) {
                         first = false;
                     } else {
@@ -135,28 +141,26 @@ bool DictModel::removeRows(int row, int count, const QModelIndex &parent) {
 
 QVariant DictModel::data(const QModelIndex &index, int role) const {
     if (!index.isValid()) {
-        return QVariant();
+        return {};
     }
 
     if (index.row() >= dicts_.size() || index.column() != 0) {
-        return QVariant();
+        return {};
     }
 
     switch (role) {
     case Qt::DisplayRole:
         return dicts_[index.row()]["file"];
+    default:
+        return {};
     }
-    return QVariant();
+    return {};
 }
 
 bool DictModel::moveUp(const QModelIndex &currentIndex) {
     if (currentIndex.row() > 0 && currentIndex.row() < dicts_.size()) {
         beginResetModel();
-#if (QT_VERSION < QT_VERSION_CHECK(5, 13, 0))
-        dicts_.swap(currentIndex.row() - 1, currentIndex.row());
-#else
         dicts_.swapItemsAt(currentIndex.row() - 1, currentIndex.row());
-#endif
         endResetModel();
         return true;
     }
@@ -166,11 +170,7 @@ bool DictModel::moveUp(const QModelIndex &currentIndex) {
 bool DictModel::moveDown(const QModelIndex &currentIndex) {
     if (currentIndex.row() >= 0 && currentIndex.row() + 1 < dicts_.size()) {
         beginResetModel();
-#if (QT_VERSION < QT_VERSION_CHECK(5, 13, 0))
-        dicts_.swap(currentIndex.row() + 1, currentIndex.row());
-#else
         dicts_.swapItemsAt(currentIndex.row() + 1, currentIndex.row());
-#endif
         endResetModel();
         return true;
     }

gui/shortcutmodel.cpp

@@ -7,10 +7,16 @@
 
 #include "shortcutmodel.h"
 #include "common.h"
+#include <QAbstractTableModel>
+#include <QObject>
+#include <QVariant>
+#include <Qt>
 #include <fcitx-utils/i18n.h>
-#include <fcitx-utils/standardpath.h>
+#include <fcitx-utils/standardpaths.h>
 #include <fcitx-utils/stringutils.h>
+#include <glib.h>
 #include <libkkc/libkkc.h>
+#include <utility>
 
 namespace fcitx {
 
@@ -34,11 +40,11 @@ const char *modeName[] = {
 
 QVariant ShortcutModel::data(const QModelIndex &index, int role) const {
     if (!index.isValid()) {
-        return QVariant();
+        return {};
     }
 
     if (index.row() >= entries_.size() || index.column() >= 3) {
-        return QVariant();
+        return {};
     }
 
     switch (role) {
@@ -50,10 +56,14 @@ QVariant ShortcutModel::data(const QModelIndex &index, int role) const {
             return entries_[index.row()].keyString();
         case 2:
             return entries_[index.row()].label();
+        default:
+            break;
         }
-        return QVariant();
+        break;
+    default:
+        break;
     }
-    return QVariant();
+    return {};
 }
 
 QVariant ShortcutModel::headerData(int section, Qt::Orientation orientation,
@@ -71,7 +81,12 @@ QVariant ShortcutModel::headerData(int section, Qt::Orientation orientation,
             return _("Key");
         case 2:
             return _("Function");
+        default:
+            break;
         }
+        break;
+    default:
+        break;
     }
     return QAbstractItemModel::headerData(section, orientation, role);
 }
@@ -90,12 +105,12 @@ void ShortcutModel::load(const QString &name) {
             return;
         }
 
-        std::string basePath = stringutils::joinPath(
-            StandardPath::global().userDirectory(StandardPath::Type::PkgData),
-            "kkc/rules");
+        const auto basePath =
+            StandardPaths::global().userDirectory(StandardPathsType::PkgData) /
+            "kkc/rules";
 
-        auto userRule = makeGObjectUnique(
-            kkc_user_rule_new(ruleMeta, basePath.data(), "fcitx-kkc", nullptr));
+        auto userRule = makeGObjectUnique(kkc_user_rule_new(
+            ruleMeta, basePath.string().c_str(), "fcitx-kkc", nullptr));
         if (!userRule) {
             break;
         }
@@ -191,6 +206,6 @@ void ShortcutModel::setNeedSave(bool needSave) {
     }
 }
 
-bool ShortcutModel::needSave() { return needSave_; }
+bool ShortcutModel::needSave() const { return needSave_; }
 
 } // namespace fcitx

gui/shortcutmodel.h

@@ -9,17 +9,25 @@
 
 #include "common.h"
 #include <QAbstractTableModel>
+#include <QList>
+#include <QObject>
+#include <QString>
+#include <QVariant>
+#include <Qt>
+#include <glib-object.h>
+#include <glib.h>
 #include <libkkc/libkkc.h>
-#include <memory>
+#include <utility>
 
 namespace fcitx {
 
 class ShortcutEntry {
 public:
-    ShortcutEntry(const QString &command, KkcKeyEvent *event,
-                  const QString &label, KkcInputMode mode)
-        : command_(command), event_(KKC_KEY_EVENT(g_object_ref(event))),
-          label_(label), mode_(mode) {
+    ShortcutEntry(QString command, KkcKeyEvent *event, QString label,
+                  KkcInputMode mode)
+        : command_(std::move(command)),
+          event_(KKC_KEY_EVENT(g_object_ref(event))), label_(std::move(label)),
+          mode_(mode) {
         gchar *keystr = kkc_key_event_to_string(event_.get());
         keyString_ = QString::fromUtf8(keystr);
         g_free(keystr);
@@ -72,13 +80,13 @@ class ShortcutModel : public QAbstractTableModel {
     void remove(const QModelIndex &index);
     void load(const QString &name);
     void save();
-    bool needSave();
+    bool needSave() const;
 
 Q_SIGNALS:
     void needSaveChanged(bool needSave);
 
 private:
-    void setNeedSave(bool arg1);
+    void setNeedSave(bool needSave);
 
 private:
     QList<ShortcutEntry> entries_;

gui/shortcutwidget.cpp

@@ -13,7 +13,7 @@
 #include <QFile>
 #include <QMessageBox>
 #include <fcitx-utils/i18n.h>
-#include <fcitx-utils/standardpath.h>
+#include <fcitx-utils/standardpaths.h>
 #include <fcntl.h>
 
 namespace fcitx {

src/kkc.cpp

@@ -22,7 +22,7 @@
 #include <fcitx-utils/log.h>
 #include <fcitx-utils/macros.h>
 #include <fcitx-utils/misc.h>
-#include <fcitx-utils/standardpath.h>
+#include <fcitx-utils/standardpaths.h>
 #include <fcitx-utils/stringutils.h>
 #include <fcitx-utils/textformatflags.h>
 #include <fcitx/action.h>
@@ -390,12 +390,12 @@ KkcEngine::KkcEngine(Instance *instance)
 #endif
     kkc_init();
 
-    fs::makePath(stringutils::joinPath(
-        StandardPath::global().userDirectory(StandardPath::Type::PkgData),
-        "kkc/dictionary"));
-    fs::makePath(stringutils::joinPath(
-        StandardPath::global().userDirectory(StandardPath::Type::PkgData),
-        "kkc/rules"));
+    fs::makePath(
+        StandardPaths::global().userDirectory(StandardPathsType::PkgData) /
+        "kkc/dictionary");
+    fs::makePath(
+        StandardPaths::global().userDirectory(StandardPathsType::PkgData) /
+        "kkc/rules");
 
     // We can only create kkc object here after we called kkc_init().
     model_.reset(kkc_language_model_load("sorted3", NULL));
@@ -590,8 +590,8 @@ void KkcEngine::updateInputMode(InputContext *ic) { modeAction_->update(ic); }
 
 void KkcEngine::loadDictionary() {
     kkc_dictionary_list_clear(dictionaries_.get());
-    auto file = StandardPath::global().open(StandardPath::Type::PkgData,
-                                            "kkc/dictionary_list", O_RDONLY);
+    auto file = StandardPaths::global().open(StandardPathsType::PkgData,
+                                             "kkc/dictionary_list");
     if (!file.isValid()) {
         return;
     }
@@ -650,10 +650,9 @@ void KkcEngine::loadDictionary() {
             constexpr auto len = sizeof(configDir) - 1;
             std::string realpath = path;
             if (stringutils::startsWith(path, "$FCITX_CONFIG_DIR/")) {
-                realpath =
-                    stringutils::joinPath(StandardPath::global().userDirectory(
-                                              StandardPath::Type::PkgData),
-                                          path.substr(len));
+                realpath = StandardPaths::global().userDirectory(
+                               StandardPathsType::PkgData) /
+                           path.substr(len);
             }
 
             auto userdict = makeGObjectUnique(reinterpret_cast<KkcDictionary *>(
@@ -675,11 +674,11 @@ void KkcEngine::loadRule() {
     if (!meta) {
         return;
     }
-    std::string basePath = stringutils::joinPath(
-        StandardPath::global().userDirectory(StandardPath::Type::PkgData),
-        "kkc/rules");
+    const auto basePath =
+        StandardPaths::global().userDirectory(StandardPathsType::PkgData) /
+        "kkc/rules";
     userRule_.reset(
-        kkc_user_rule_new(meta, basePath.c_str(), "fcitx-kkc", NULL));
+        kkc_user_rule_new(meta, basePath.string().c_str(), "fcitx-kkc", NULL));
 }
 
 std::string KkcEngine::subMode(const InputMethodEntry & /*entry*/,