Activities templates allowing setting specific value to int type vconf keys.

Refactor ChangeScanningMethod, also renamed to ChangeScanningMethodActivity
Add:
+ ChangeTextEditionModeActivity
+ SetCharacterGranularityActivity
+ SetWordGranularityActivity
+ SetLineGranularityActivity
+ SetParagraphGranularityActivity

Set...Activity needs new functionality in UI,
Select Activity allow returning to the previous menu after sending activity change request

Change-Id: I27d591e948b33efc43cde4c42b33f3773266f222

diff --git a/res/po/en_US.po b/res/po/en_US.po
index f29876d..60a8062 100644 (file)
--- a/res/po/en_US.po
+++ b/res/po/en_US.po
@@ -51,7 +51,11 @@ msgstr "Decrease"
 
 
 msgid "IDS_SELECTION_MODE"
-msgstr "Selection mode"
+msgstr "Enable text selection"
+
+
+msgid "IDS_EDITION_MODE"
+msgstr "Disable text selection"
 
 
 msgid "IDS_SELECT_ALL"

diff --git a/src/ChangeIntTypeVconfKeyActivity.cpp b/src/ChangeIntTypeVconfKeyActivity.cpp
new file mode 100644 (file)
index 0000000..8f7c84b
--- /dev/null
+++ b/src/ChangeIntTypeVconfKeyActivity.cpp
@@ -0,0 +1,101 @@
+#include "Activity.hpp"
+#include "ActivityFactory.hpp"
+#include "ScreenScannerManager.hpp"
+#include "UniversalSwitch.hpp"
+#include "VConf.hpp"
+#include "VConfKeys.hpp"
+
+#include <memory>
+
+template <typename DerivedType>
+class ChangeIntTypeVconfKeyActivity : public Activity, private RegisterActivity<DerivedType>
+{
+public:
+       constexpr static const char *activityType = DerivedType::activityType;
+       ChangeIntTypeVconfKeyActivity() : Activity(activityType) {}
+
+       void process() override
+       {
+               auto state = Singleton<VConfInterface>::instance().get(DerivedType::KEY, 0);
+               if (!state) {
+                       markAsCompleted();
+                       return;
+               }
+
+               state = state % DerivedType::STATES + 1;
+               Singleton<VConfInterface>::instance().set(DerivedType::KEY, state);
+               markAsCompleted();
+       }
+};
+
+class ChangeScanningMethodActivity : public ChangeIntTypeVconfKeyActivity<ChangeScanningMethodActivity>
+{
+public:
+       static constexpr const char *activityType = "CHANGE_SCANNING_METHOD";
+       static constexpr const char *KEY = VCONF_KEY_SCAN_METHOD;
+       static constexpr int STATES = 2;
+};
+
+class ChangeTextEditionModeActivity : public ChangeIntTypeVconfKeyActivity<ChangeTextEditionModeActivity>
+{
+public:
+       static constexpr const char *activityType = "CHANGE_TEXT_EDITION_MODE";
+       static constexpr const char *KEY = VCONF_KEY_TEXT_EDITION_MODE;
+       static constexpr int STATES = 2;
+};
+
+namespace
+{
+       enum granularity {
+               CHARACTER = 1,
+               WORD,
+               LINE,
+               PARAGRAPH
+       };
+}
+
+template <typename DerivedType>
+class SetIntTypeVconfKeyActivity : public Activity, private RegisterActivity<DerivedType>
+{
+public:
+       constexpr static const char *activityType = DerivedType::activityType;
+       SetIntTypeVconfKeyActivity() : Activity(activityType) {}
+
+       void process() override
+       {
+               Singleton<VConfInterface>::instance().set(DerivedType::KEY, DerivedType::STATE);
+               markAsCompleted();
+       }
+};
+
+class SetCharacterGranularityActivity : public SetIntTypeVconfKeyActivity<SetCharacterGranularityActivity>
+{
+public:
+       static constexpr const char *activityType = "CHARACTER";
+       static constexpr const char *KEY = VCONF_KEY_GRANULARITY_UNIT;
+       static constexpr int STATE = CHARACTER;
+};
+
+class SetWordGranularityActivity : public SetIntTypeVconfKeyActivity<SetWordGranularityActivity>
+{
+public:
+       static constexpr const char *activityType = "WORD";
+       static constexpr const char *KEY = VCONF_KEY_GRANULARITY_UNIT;
+       static constexpr int STATE = WORD;
+};
+
+class SetLineGranularityActivity : public SetIntTypeVconfKeyActivity<SetLineGranularityActivity>
+{
+public:
+       static constexpr const char *activityType = "LINE";
+       static constexpr const char *KEY = VCONF_KEY_GRANULARITY_UNIT;
+       static constexpr int STATE = LINE;
+};
+
+class SetParagraphGranularityActivity : public SetIntTypeVconfKeyActivity<SetParagraphGranularityActivity>
+{
+public:
+       static constexpr const char *activityType = "PARAGRAPH";
+       static constexpr const char *KEY = VCONF_KEY_GRANULARITY_UNIT;
+       static constexpr int STATE = PARAGRAPH;
+};
\ No newline at end of file

diff --git a/src/ChangeScanningMethodActivity.cpp b/src/ChangeScanningMethodActivity.cpp
deleted file mode 100644 (file)
index 967d992..0000000
--- a/src/ChangeScanningMethodActivity.cpp
+++ /dev/null
@@ -1,31 +0,0 @@
-#include "Activity.hpp"
-#include "ActivityFactory.hpp"
-#include "ScreenScannerManager.hpp"
-#include "UniversalSwitch.hpp"
-#include "VConf.hpp"
-#include "VConfKeys.hpp"
-
-#include <memory>
-
-class ChangeScanningMethod : public Activity, private RegisterActivity<ChangeScanningMethod>
-{
-public:
-       constexpr static const char *activityType = "CHANGE_SCANNING_METHOD";
-       ChangeScanningMethod()
-               : Activity(activityType)
-       {}
-
-       void process() override
-       {
-               auto method = Singleton<VConfInterface>::instance().get(VCONF_KEY_SCAN_METHOD, 0);
-               if (!method) {
-                       markAsCompleted();
-                       return;
-               }
-
-               method = method % 2 + 1;
-               Singleton<VConfInterface>::instance().set(VCONF_KEY_SCAN_METHOD, method);
-               Singleton<UniversalSwitch>::instance().getScreenScannerManager()->startAutoscanning();
-               markAsCompleted();
-       }
-};

diff --git a/src/MenuBuilder.cpp b/src/MenuBuilder.cpp
index 2ae255c..9d54bca 100644 (file)
--- a/src/MenuBuilder.cpp
+++ b/src/MenuBuilder.cpp
@@ -273,23 +273,37 @@ MenuBuilderImplementation::MenuBuilderImplementation()
                                                                                std::string {},
                                                                                std::string {},
                                                                                RepetitionPolicy::multiple);
-       auto selectionMode                      =       std::make_shared<MenuItemImplementation>(
-                                                                               std::vector<std::string> {"IDS_SELECTION_MODE"},
-                                                                               defaultImg);
+       auto textEditionMode            =       std::make_shared<VconfIntTypeMenuItem>(
+                                                                               std::vector<std::string> {"IDS_SELECTION_MODE", "IDS_EDITION_MODE"},
+                                                                               defaultImg,
+                                                                               std::string {"CHANGE_TEXT_EDITION_MODE"},
+                                                                               std::string {VCONF_KEY_TEXT_EDITION_MODE},
+                                                                               std::string {},
+                                                                               std::string {},
+                                                                               RepetitionPolicy::multiple);
        auto selectAll                          =       std::make_shared<MenuItemImplementation>(
                                                                                std::vector<std::string> {"IDS_SELECT_ALL"},
                                                                                defaultImg,
-                                                                               "SELECT_ALL");
+                                                                               "SELECT_ALL",
+                                                                               std::string {},
+                                                                               std::string {},
+                                                                               RepetitionPolicy::multiple);
        auto previous                           =       std::make_shared<VconfIntTypeMenuItem>(
                                                                                std::vector<std::string> { "IDS_PREVIOUS_CHARACTER", "IDS_PREVIOUS_WORD", "IDS_PREVIOUS_LINE", "IDS_PREVIOUS_PARAGRAPH"},
                                                                                defaultImg,
                                                                                std::string {},/*TODO add activity*/
-                                                                               std::string {VCONF_KEY_GRANULARITY_UNIT});
+                                                                               std::string {VCONF_KEY_GRANULARITY_UNIT},
+                                                                               std::string {},
+                                                                               std::string {},
+                                                                               RepetitionPolicy::multiple);
        auto next                                       =       std::make_shared<VconfIntTypeMenuItem>(
                                                                                std::vector<std::string> { "IDS_NEXT_CHARACTER", "IDS_NEXT_WORD", "IDS_NEXT_LINE", "IDS_NEXT_PARAGRAPH"},
                                                                                defaultImg,
                                                                                std::string {},/*TODO add activity*/
-                                                                               std::string {VCONF_KEY_GRANULARITY_UNIT});
+                                                                               std::string {VCONF_KEY_GRANULARITY_UNIT},
+                                                                               std::string {},
+                                                                               std::string {},
+                                                                               RepetitionPolicy::multiple);
        auto copy                                       =       std::make_shared<MenuItemImplementation>(
                                                                                std::vector<std::string> {"IDS_COPY"},
                                                                                defaultImg,
@@ -426,16 +440,24 @@ MenuBuilderImplementation::MenuBuilderImplementation()
                                                                                "START_SETTINGS");
        auto character                          =       std::make_shared<MenuItemImplementation>(
                                                                                std::vector<std::string> {"IDS_CHARACTER"},
-                                                                               defaultImg);
+                                                                               defaultImg,
+                                                                               std::string {"CHARACTER"},
+                                                                               std::string {"PREVIOUS_MENU"});
        auto word                                       =       std::make_shared<MenuItemImplementation>(
                                                                                std::vector<std::string> {"IDS_WORD"},
-                                                                               defaultImg);
+                                                                               defaultImg,
+                                                                               std::string {"WORD"},
+                                                                               std::string {"PREVIOUS_MENU"});
        auto line                                       =       std::make_shared<MenuItemImplementation>(
                                                                                std::vector<std::string> {"IDS_LINE"},
-                                                                               defaultImg);
+                                                                               defaultImg,
+                                                                               std::string {"LINE"},
+                                                                               std::string {"PREVIOUS_MENU"});
        auto paragraph                          =       std::make_shared<MenuItemImplementation>(
                                                                                std::vector<std::string> {"IDS_PARAGRAPH"},
-                                                                               defaultImg);
+                                                                               defaultImg,
+                                                                               std::string {"PARAGRAPH"},
+                                                                               std::string {"PREVIOUS_MENU"});
        auto ringtoneVolIncrease        =       std::make_shared<MenuItemImplementation>(
                                                                                std::vector<std::string> {"IDS_RINGTONE_VOLUME_INC"},
                                                                                defaultImg,
@@ -493,46 +515,46 @@ MenuBuilderImplementation::MenuBuilderImplementation()
        auto autoScroll                         =       std::make_shared<MenuItemImplementation>(
                                                                                std::vector<std::string> {"IDS_AUTO_SCROLL"},
                                                                                defaultImg,
-                                                                               "SELECT",
+                                                                               std::string {},
                                                                                "IDS_MENU_AUTO_SCROLL");
        auto ScreenRotation                     =       std::make_shared<MenuItemImplementation>(
                                                                                std::vector<std::string> {"IDS_SCREEN_ROTATION"},
                                                                                defaultImg,
-                                                                               "SELECT",
+                                                                               std::string {},
                                                                                "IDS_MENU_ROTATE_SCREEN");
        auto gestures                           =       std::make_shared<MenuItemImplementation>(
                                                                                std::vector<std::string> {"IDS_GESTURES"},
                                                                                defaultImg,
-                                                                               "SELECT",
+                                                                               std::string {},
                                                                                "IDS_MENU_GESTURES",
                                                                                VCONF_KEY_SHOW_GESTURES_MENU_ITEM);
        auto actions                            =       std::make_shared<MenuItemImplementation>(
                                                                                std::vector<std::string> {"IDS_ACTIONS"},
                                                                                defaultImg,
-                                                                               "SELECT",
+                                                                               std::string {},
                                                                                "IDS_MENU_ACTIONS",
                                                                                VCONF_KEY_SHOW_ACTIONS_MENU_ITEM);
        auto settings                           =       std::make_shared<MenuItemImplementation>(
                                                                                std::vector<std::string> {"IDS_SETTINGS"},
                                                                                defaultImg,
-                                                                               "SELECT",
+                                                                               std::string {},
                                                                                "IDS_MENU_SETTINGS",
                                                                                VCONF_KEY_SHOW_SETTINGS_MENU_ITEM);
        auto buttonsAndKeys                     =       std::make_shared<MenuItemImplementation>(
                                                                                std::vector<std::string> {"IDS_BUTTONS_AND_KEYS"},
                                                                                defaultImg,
-                                                                               "SELECT",
+                                                                               std::string {},
                                                                                "IDS_MENU_BUTTONS_KEYS",
                                                                                VCONF_KEY_SHOW_BUTTONS_AND_KEYS_MENU_ITEM);
        auto editText                           =       std::make_shared<MenuItemImplementation>(
                                                                                std::vector<std::string> {"IDS_EDIT_TEXT"},
                                                                                defaultImg,
-                                                                               "SELECT",
+                                                                               std::string {},
                                                                                "IDS_MENU_EDIT_TEXT");
        auto granularitySettings        =       std::make_shared<MenuItemImplementation>(
                                                                                std::vector<std::string> {"IDS_GRANULARITY_SETTINGS"},
                                                                                defaultImg,
-                                                                               "SELECT",
+                                                                               std::string {},
                                                                                "IDS_MENU_GRANULARITY");
        auto emptyItem                          =       std::make_shared<MenuItemImplementation>();
 
@@ -597,7 +619,7 @@ MenuBuilderImplementation::MenuBuilderImplementation()
                tapHomeButtonx2, tapHomeButtonx3, viewPowerKeyMenu
        });
        addToMap("IDS_MENU_EDIT_TEXT", {
-               selectionMode, selectAll, previous, next,
+               textEditionMode, selectAll, previous, next,
                copy, paste, cut, granularitySettings
        });
        addToMap("IDS_MENU_AUTO_SCROLL_OFF", {

diff --git a/src/SelectActivity.cpp b/src/SelectActivity.cpp
index 41b08c0..0aa67ce 100644 (file)
--- a/src/SelectActivity.cpp
+++ b/src/SelectActivity.cpp
@@ -25,6 +25,7 @@ static const double    AUTO_TAP_WAITING_PERIOD_DEFAULT_TIME = 3.0;
 
 static const std::string AUTO_SCAN_KEY                      = VCONF_KEY_AUTO_SCAN_ENABLED;
 static const std::string AUTO_SCROLL_KEY                    = VCONF_KEY_AUTO_SCROLL_ENABLED;
+static const std::string TEXT_EDITION_MODE                  = VCONF_KEY_TEXT_EDITION_MODE;
 static const std::string AUTO_TAP_KEY                       = VCONF_KEY_AUTO_TAP_ENABLED;
 static const std::string AUTO_TAP_WAITING_PERIOD_KEY        = VCONF_KEY_AUTO_TAP_WAITING_TIME;
 
@@ -145,6 +146,13 @@ void SelectActivity::update(const std::shared_ptr<MenuItem> &menuitem)
 void SelectActivity::createMenu()
 {
        ASSERT(realUiElement, "realUiElement is NULL");
+
+       if (nestedMenusLabels.empty()) {
+               DEBUG("Empty menu vector");
+               markAsCompleted();
+               return;
+       }
+
        popup.reset(elm_popup_add(Singleton<UniversalSwitch>::instance().getMainWindow()->getHandler()));
        elm_popup_orient_set(popup.get(), ELM_POPUP_ORIENT_CENTER);
        elm_theme_extension_add(NULL, UNIVERSAL_SWITCH_EDJ);
@@ -254,7 +262,10 @@ void SelectActivity::navigateThroughSubMenuOrCreateActivityChangeRequest(MenuIte
        if (menuItem->getName().empty())
                return;
 
-       if (menuItem->getActivityType() == SelectActivity::activityType) {
+       if (!menuItem->getSubMenuLabel().empty()) {
+               if (!menuItem->getActivityType().empty())
+                       notify(std::make_shared<ActivityChangeRequest>(menuItem->getActivityType(), realUiElement));
+
                navigateThroughSubMenu(menuItem->getSubMenuLabel());
                return;
        }
@@ -272,18 +283,27 @@ void SelectActivity::navigateThroughSubMenuOrCreateActivityChangeRequest(MenuIte
 
 void SelectActivity::navigateThroughSubMenu(const std::string &subMenuLabel)
 {
-       nestedMenusLabels.push_back(subMenuLabel);
+       if (subMenuLabel == "PREVIOUS_MENU") {
+               navigateBack();
+       } else {
+               if (subMenuLabel == "IDS_MENU_EDIT_TEXT")
+                       Singleton<VConfInterface>::instance().set(TEXT_EDITION_MODE, 1);
+
+               nestedMenusLabels.push_back(subMenuLabel);
+       }
+
        refreshMenu();
 }
 
 void SelectActivity::navigateBack()
 {
-       removeMenu();
        nestedMenusLabels.pop_back();
-       if (nestedMenusLabels.empty())
+       if (nestedMenusLabels.empty()) {
+               removeMenu();
                markAsCompleted();
-       else
+       } else {
                refreshMenu();
+       }
 }
 
 void SelectActivity::sendTapActivityChangeRequest()

diff --git a/src/VConfKeys.hpp b/src/VConfKeys.hpp
index 1b595e5..bc2ef92 100644 (file)
--- a/src/VConfKeys.hpp
+++ b/src/VConfKeys.hpp
@@ -59,6 +59,8 @@
 #define VCONF_KEY_TAP_DURATION_VALUE                           VCONF_PROJECT_PREFIX "TAP_DURATION_VALUE"
 #define VCONF_KEY_TAP_DURATION_ENABLED                         VCONF_PROJECT_PREFIX "TAP_DURATION_ENABLED"
 
+#define VCONF_KEY_TEXT_EDITION_MODE                                    VCONF_PROJECT_PREFIX "TEXT_EDITION_MODE"
+
 
 #define VCONF_KEY_SOUND_ENABLED                                                "db/setting/sound/sound_on"
 #define VCONF_KEY_VIBRATION_ENABLED                                    "db/setting/sound/vibration_on"

diff --git a/utils/setVconfKeys.sh b/utils/setVconfKeys.sh
index 4ee9c6f..fe6c196 100755 (executable)
--- a/utils/setVconfKeys.sh
+++ b/utils/setVconfKeys.sh
@@ -68,3 +68,5 @@ $VCONFTOOL double "${VCONF_PROJECT_PREFIX}TAP_DURATION_VALUE" 0.0
 $VCONFTOOL bool   "${VCONF_PROJECT_PREFIX}TAP_DURATION_ENABLED" 0
 
 $VCONFTOOL bool "${VCONF_ACCESSIBILITY_PREFIX}universal-switch"   0
+
+$VCONFTOOL int "${VCONF_PROJECT_PREFIX}TEXT_EDITION_MODE" 1
\ No newline at end of file