Add support for Indic numerals and punctuation marks

* Added config options to enable/disable Indic numerals and punctuation marks
* Clean up and refactor code

#11

.gitignore

@@ -12,6 +12,7 @@ builddir/
 CMakeFiles/
 meson_options.txt
 meson.options
+CMakeLists.txt.user
 
 compile_commands.json
 .cache/

src/varnam_candidate.cpp

@@ -8,17 +8,17 @@ namespace fcitx {
 
 VarnamCandidateWord::VarnamCandidateWord(VarnamEngine *engine, const char *text,
                                          int index)
-    : CandidateWord(Text(std::move(text))), engine_(engine), index_(index) {}
+    : CandidateWord(Text(std::move(text))), m_engine(engine), m_index(index) {}
 
 void VarnamCandidateWord::select(InputContext *inputContext) const {
-  auto state = inputContext->propertyFor(engine_->factory());
-  state->selectCandidate(index_);
+  auto state = inputContext->propertyFor(m_engine->factory());
+  state->selectCandidate(m_index);
 }
 
 VarnamCandidateList::VarnamCandidateList(VarnamEngine *engine, InputContext *ic)
-    : engine_(engine), ic_(ic) {
+    : m_engine(engine), m_ic(ic) {
   const VarnamEngineConfig *config =
-      static_cast<const VarnamEngineConfig *>(engine_->getConfig());
+      static_cast<const VarnamEngineConfig *>(m_engine->getConfig());
   CandidateLayoutHint layout;
   if (!config) {
     VARNAM_WARN() << "Invalid configuration";
@@ -36,7 +36,7 @@ void VarnamCandidateList::prev() {
     setPage(currentPage());
     setCursorPositionAfterPaging(CursorPositionAfterPaging::ResetToFirst);
   }
-  ic_->updateUserInterface(UserInterfaceComponent::InputPanel);
+  m_ic->updateUserInterface(UserInterfaceComponent::InputPanel);
 }
 
 void VarnamCandidateList::next() {
@@ -45,33 +45,33 @@ void VarnamCandidateList::next() {
     setPage(currentPage());
     setGlobalCursorIndex(pageSize() * currentPage() - (pageSize() - 1));
   }
-  ic_->updateUserInterface(UserInterfaceComponent::InputPanel);
+  m_ic->updateUserInterface(UserInterfaceComponent::InputPanel);
 }
 
 bool VarnamCandidateList::usedNextBefore() const { return true; }
 
 void VarnamCandidateList::prevCandidate() {
   CommonCandidateList::prevCandidate();
-  auto state = ic_->propertyFor(engine_->factory());
+  auto state = m_ic->propertyFor(m_engine->factory());
   int index = globalCursorIndex();
   if (index >= pageSize() && (currentPage() > 0)) {
     setPage(currentPage());
   }
   setGlobalCursorIndex(index);
   state->selectCandidate(cursorIndex());
-  ic_->updateUserInterface(UserInterfaceComponent::InputPanel);
+  m_ic->updateUserInterface(UserInterfaceComponent::InputPanel);
 }
 
 void VarnamCandidateList::nextCandidate() {
   CommonCandidateList::nextCandidate();
-  auto state = ic_->propertyFor(engine_->factory());
+  auto state = m_ic->propertyFor(m_engine->factory());
   int index = globalCursorIndex();
   if (index >= pageSize() && (currentPage() < totalPages())) {
     setPage(currentPage());
   }
   setGlobalCursorIndex(index);
   state->selectCandidate(cursorIndex());
-  ic_->updateUserInterface(UserInterfaceComponent::InputPanel);
+  m_ic->updateUserInterface(UserInterfaceComponent::InputPanel);
 }
 
 } // namespace fcitx

src/varnam_candidate.h

@@ -10,8 +10,8 @@ namespace fcitx {
 
 class VarnamCandidateWord : public CandidateWord {
 private:
-  VarnamEngine *engine_;
-  int index_;
+  VarnamEngine *m_engine;
+  int m_index;
 
 public:
   VarnamCandidateWord(VarnamEngine *engine, const char *text, int index);
@@ -21,8 +21,8 @@ class VarnamCandidateWord : public CandidateWord {
 
 class VarnamCandidateList : public CommonCandidateList {
 private:
-  VarnamEngine *engine_;
-  InputContext *ic_;
+  VarnamEngine *m_engine;
+  InputContext *m_ic;
 
 public:
   VarnamCandidateList(VarnamEngine *engine, InputContext *ic);

src/varnam_config.h

@@ -31,6 +31,16 @@ FCITX_CONFIGURATION(
     // Enable Learning Words on commit
     Option<bool> shouldLearnWords{this, "Learn Words", _("Learn New Words"),
                                   true};
+
+    // Enable Indic Numbers
+    Option<bool> enableIndicNumbers{this, "EnableIndicNumbers", _("Enable Indic Numbers"),
+                                    false};
+
+
+    // Enable Indic Numbers
+    Option<bool> enablePunctuation{this, "enablePunctuation", _("Enable Indic Punctuation Marks"),
+                                    false};
+
     // Strictly Follow Schema
     Option<bool> strictlyFollowScheme{
         this, "Strictly Follow Scheme",

src/varnam_engine.cpp

@@ -13,15 +13,16 @@ extern "C" {
 namespace fcitx {
 
 VarnamEngine::VarnamEngine(Instance *instance)
-    : instance_(instance),
-      factory_([this](InputContext &ic) { return new VarnamState(this, ic); }) {
-  instance->inputContextManager().registerProperty("varnamState", &factory_);
+    : m_instance(instance), m_factory([this](InputContext &ic) {
+        return new VarnamState(this, ic);
+      }) {
+  instance->inputContextManager().registerProperty("varnamState", &m_factory);
 }
 
 VarnamEngine::~VarnamEngine() {
-  factory_.unregister();
-  if (varnam_handle > 0) {
-    int rv = varnam_close(varnam_handle);
+  m_factory.unregister();
+  if (m_varnam_handle > 0) {
+    int rv = varnam_close(m_varnam_handle);
     if (rv != VARNAM_SUCCESS) {
       VARNAM_WARN() << "Failed to close Varnam instance";
     }
@@ -36,21 +37,23 @@ void VarnamEngine::activate(const InputMethodEntry &entry,
   VARNAM_INFO() << "activate scheme:" << entry.uniqueName();
 #endif
   char *schemeName = const_cast<char *>(entry.uniqueName().c_str());
-  int rv = varnam_init_from_id(schemeName, &varnam_handle);
+  int rv = varnam_init_from_id(schemeName, &m_varnam_handle);
   if (rv != VARNAM_SUCCESS) {
     VARNAM_WARN() << "Failed to initialize Varnam";
     throw std::runtime_error("failed to initialize varnam");
   }
 
-  varnam_config(varnam_handle, VARNAM_CONFIG_SET_DICTIONARY_MATCH_EXACT,
-                config_.strictlyFollowScheme.value());
-  varnam_config(varnam_handle, VARNAM_CONFIG_SET_DICTIONARY_SUGGESTIONS_LIMIT,
-                config_.dictionarySuggestionsLimit.value());
-  varnam_config(varnam_handle,
+  varnam_config(m_varnam_handle, VARNAM_CONFIG_SET_DICTIONARY_MATCH_EXACT,
+                m_config.strictlyFollowScheme.value());
+  varnam_config(m_varnam_handle, VARNAM_CONFIG_SET_DICTIONARY_SUGGESTIONS_LIMIT,
+                m_config.dictionarySuggestionsLimit.value());
+  varnam_config(m_varnam_handle,
                 VARNAM_CONFIG_SET_PATTERN_DICTIONARY_SUGGESTIONS_LIMIT,
-                config_.patternDictionarySuggestionsLimit.value());
-  varnam_config(varnam_handle, VARNAM_CONFIG_SET_TOKENIZER_SUGGESTIONS_LIMIT,
-                config_.tokenizerSuggestionsLimit.value());
+                m_config.patternDictionarySuggestionsLimit.value());
+  varnam_config(m_varnam_handle, VARNAM_CONFIG_SET_TOKENIZER_SUGGESTIONS_LIMIT,
+                m_config.tokenizerSuggestionsLimit.value());
+  varnam_config(m_varnam_handle, VARNAM_CONFIG_USE_INDIC_DIGITS,
+                m_config.enableIndicNumbers.value());
 }
 
 void VarnamEngine::deactivate(const InputMethodEntry &entry,
@@ -60,13 +63,13 @@ void VarnamEngine::deactivate(const InputMethodEntry &entry,
 #endif
   if (event.type() == EventType::InputContextSwitchInputMethod) {
     auto ic = event.inputContext();
-    auto state = ic->propertyFor(&factory_);
+    auto state = ic->propertyFor(&m_factory);
     state->commitText();
     state->updateUI();
   }
   reset(entry, event);
-  if (varnam_handle > 0) {
-    varnam_close(varnam_handle);
+  if (m_varnam_handle > 0) {
+    varnam_close(m_varnam_handle);
   }
 }
 
@@ -111,25 +114,25 @@ void VarnamEngine::keyEvent(const InputMethodEntry &entry, KeyEvent &keyEvent) {
     return;
   }
   auto ic = keyEvent.inputContext();
-  auto state = ic->propertyFor(&factory_);
+  auto state = ic->propertyFor(&m_factory);
   state->processKeyEvent(keyEvent);
 }
 
 void VarnamEngine::reset(const InputMethodEntry &entry,
                          InputContextEvent &event) {
   FCITX_UNUSED(entry);
   auto ic = event.inputContext();
-  auto state = ic->propertyFor(&factory_);
+  auto state = ic->propertyFor(&m_factory);
   state->reset();
   state->updateUI();
 }
 
 void VarnamEngine::setConfig(const RawConfig &config) {
-  config_.load(config);
-  safeSaveAsIni(config_, "conf/varnam.conf");
+  m_config.load(config);
+  safeSaveAsIni(m_config, "conf/varnam.conf");
 }
 
-void VarnamEngine::reloadConfig() { readAsIni(config_, "conf/varnam.conf"); }
+void VarnamEngine::reloadConfig() { readAsIni(m_config, "conf/varnam.conf"); }
 
 } // namespace fcitx
 

src/varnam_engine.h

@@ -16,11 +16,11 @@ class VarnamState;
 class VarnamEngine : public InputMethodEngineV3 {
 
 private:
-  int varnam_handle;
-  Instance *instance_;
-  VarnamEngineConfig config_;
-  KeyState selectionKeyModifer_;
-  FactoryFor<VarnamState> factory_;
+  int m_varnam_handle;
+  Instance *m_instance;
+  VarnamEngineConfig m_config;
+  KeyState m_selectionKeyModifer;
+  FactoryFor<VarnamState> m_factory;
 
 public:
   VarnamEngine(Instance *instance);
@@ -38,17 +38,17 @@ class VarnamEngine : public InputMethodEngineV3 {
 
   std::vector<InputMethodEntry> listInputMethods() override;
 
-  auto factory() { return &factory_; }
+  auto factory() { return &m_factory; }
 
   void setConfig(const RawConfig &) override;
 
   void reloadConfig() override;
 
-  const VarnamEngineConfig *getConfig() const override { return &config_; }
+  const VarnamEngineConfig *getConfig() const override { return &m_config; }
 
-  const KeyState &getSelectionModifer() const { return selectionKeyModifer_; }
+  const KeyState &getSelectionModifer() const { return m_selectionKeyModifer; }
 
-  int getVarnamHandle() const { return varnam_handle; }
+  int getVarnamHandle() const { return m_varnam_handle; }
 };
 
 class VarnamEngineFactory : public AddonFactory {