pkg_check_modules(pkgs REQUIRED
capi-appfw-service-application
capi-appfw-application
+ capi-telephony
elementary
ecore
sqlite3
ADD_DEFINITIONS("-DICONS_DIR=\"${ICONS_DIR}\"")
ADD_DEFINITIONS("-DLOCALE_DIR=\"${LOCALE_DIR}\"")
ADD_DEFINITIONS("-DPROJECT_NAME=\"${PROJECT_NAME}\"")
-
-INSTALL(DIRECTORY res/icons/ DESTINATION ${ICONS_DIR} FILES_MATCHING PATTERN "*.png")
+ADD_DEFINITIONS("-DUNIVERSAL_SWITCH_EDJ=\"${RES_DIR}/${PROJECT_NAME}.edj\"")
ADD_DEFINITIONS("-DDEBUG_PRINTING_LEVEL=DEBUG_PRINTING_LEVEL_DEBUG")
-# Install Manifest File
-INSTALL(FILES org.tizen.universal-switch.xml DESTINATION ${TZ_SYS_RO_PACKAGES})
-
ADD_SUBDIRECTORY(src)
ADD_SUBDIRECTORY(res/po)
if(TESTS)
ADD_SUBDIRECTORY(tests)
-endif()
\ No newline at end of file
+endif()
+
+ADD_CUSTOM_TARGET(${PROJECT_NAME}.edj
+ COMMAND edje_cc -no-save res/${PROJECT_NAME}.edc ${CMAKE_BINARY_DIR}/${PROJECT_NAME}.edj
+ DEPENDS res/${PROJECT_NAME}.edc
+)
+ADD_DEPENDENCIES(${PROJECT_NAME} ${PROJECT_NAME}.edj)
+
+# Install Manifest File
+INSTALL(DIRECTORY res/icons/ DESTINATION ${ICONS_DIR} FILES_MATCHING PATTERN "*.png")
+INSTALL(FILES org.tizen.universal-switch.xml DESTINATION ${TZ_SYS_RO_PACKAGES})
+INSTALL(FILES ${PROJECT_NAME}.edj DESTINATION ${RES_DIR})
</ui-application>
<privileges>
<privilege>http://tizen.org/privilege/window.priority.set</privilege>
+ <privilege>http://tizen.org/privilege/telephony</privilege>
</privileges>
</manifest>
BuildRequires: gettext-tools
BuildRequires: pkgconfig(capi-appfw-service-application)
BuildRequires: pkgconfig(capi-appfw-application)
+BuildRequires: pkgconfig(capi-telephony)
BuildRequires: pkgconfig(ecore)
BuildRequires: pkgconfig(elementary)
BuildRequires: pkgconfig(efl-extension)
msgid "IDS_GRANULARITY_SETTINGS"
msgstr "Granularity settings"
+
+msgid "IDS_MENU_MAIN"
+msgstr "Main menu"
+
+
+msgid "IDS_MENU_GESTURES"
+msgstr "Gestures menu"
+
+
+msgid "IDS_MENU_ACTIONS"
+msgstr "Actions menu"
+
+
+
+msgid "IDS_MENU_ROTATE_SCREEN"
+msgstr "Rotate screen menu"
+
+
+msgid "IDS_MENU_SETTINGS"
+msgstr "Settings menu"
+
+
+msgid "IDS_MENU_BUTTONS_KEYS"
+msgstr "Buttons and keys menu"
+
+msgid "IDS_MENU_EDIT_TEXT"
+msgstr "Edit text menu"
+
+
+msgid "IDS_MENU_AUTO_SCROLL"
+msgstr "Auto scroll menu"
+
+msgid "IDS_MENU_GRANULARITY"
+msgstr "Granularity menu"
+
+
+msgid "IDS_NAVIGATE_UP"
+msgstr "Navigate up"
+
+
#ACTIVITIES
msgid "IDS_ACTIVITY_NAME_AUTO_SCAN_ON"
--- /dev/null
+#define ALPHA 150
+#define EDCDEBUG(PART_TEXT, R, G, B) part { type: RECT; \
+ scale: 1; \
+ description { state: "default" 0.0; \
+ rel1.to: PART_TEXT; \
+ rel2.to: PART_TEXT; \
+ color: R G B ALPHA; \
+ } \
+}\
+
+
+collections {
+group { name: "elm/notify/block_events/popup/universalSwitchTransparent";
+ parts {
+ part { name: "base"; type: RECT;
+ description { state: "default" 0.0;
+ color: 0 0 0 0;
+ }
+ description { state: "clicked" 0.0;
+ color: 0 0 0 192;
+ }
+ }
+ program {
+ signal: "mouse,down,1"; source: "base";
+ action: SIGNAL_EMIT "elm,action,click" "elm";
+ after: "click1";
+ }
+ program { name: "click1";
+ action: STATE_SET "clicked" 0.0;
+ target: "base";
+ transition: SINUSOIDAL 0.2;
+ }
+ program {
+ signal: "mouse,up,1"; source: "base";
+ action: STATE_SET "default" 0.0;
+ target: "base";
+ transition: DECELERATE 0.5;
+ }
+ }
+}
+
+group { name: "elm/popup/base/universalSwitchTransparent";
+ parts {
+ part { name: "base"; type: RECT;
+ scale: 1;
+ description { state: "default" 0.0;
+ min: 240 0;
+ color: 255 255 255 ALPHA;
+ }
+ }
+ part { name: "elm.swallow.back"; type: SWALLOW;
+ scale: 0;
+ description { state: "default" 0.0;
+ fixed: 0 1;
+ visible: 0;
+ }
+ description { state: "back_visible" 0.0;
+ inherit: "default" 0.0;
+ align: 0.0 0.0;
+ min: 0 50;
+ max: -1 50;
+ visible: 1;
+ }
+ }
+ part { name: "elm.swallow.content"; type: SWALLOW;
+ scale: 0;
+ description { state: "default" 0.0;
+ }
+ description { state: "back_visible" 0.0;
+ inherit: "default" 0.0;
+ rel1.relative: 0.0 1.0;
+ rel1.to_y: "elm.swallow.back";
+ rel2.relative: 1.0 1.0;
+ }
+
+ }
+ }
+ programs {
+ program {
+ signal: "elm,state,back,visible"; source: "elm";
+ action: STATE_SET "back_visible" 0.0;
+ target: "elm.swallow.back";
+ target: "elm.swallow.content";
+ }
+ program {
+ signal: "elm,state,back,hidden"; source: "elm";
+ action: STATE_SET "default" 0.0;
+ target: "elm.swallow.back";
+ target: "elm.swallow.content";
+ }
+ }
+}
+
+group { name: "universalSwitchTransparentLayout";
+ inherit: "elm/popup/base/universalSwitchTransparent";
+}
+
+group { name: "elm/notify/center/universalSwitchTransparent";
+ data.item: "hide_finished_signal" "on";
+ parts {
+ part { name: "clip"; type: RECT;
+ description { state: "default" 0.0;
+ color: 255 255 255 0;
+ }
+ description { state: "visible" 0.0;
+ inherit: "default" 0.0;
+ color: 255 255 255 255;
+ }
+ }
+ part { name: "base"; type: RECT;
+ description { state: "default" 0.0;
+ rel1.offset: 10 10;
+ rel2.offset: -10 -10;
+ rel1.relative: 0.0 0.0;
+ rel2.relative: 1.0 1.0;
+ color: 0 0 0 0;
+ }
+ }
+ part { name: "elm.swallow.content"; type: SWALLOW;
+ clip_to: "clip";
+ description { state: "default" 0.0;
+ rel1.to: "base";
+ rel1.offset: 12 12;
+ rel2.to: "base";
+ rel2.offset: -13 -13;
+ }
+ }
+ }
+ programs {
+ program {
+ signal: "show"; source: "";
+ action: STATE_SET "visible" 0.0;
+ target: "clip";
+ target: "base";
+ transition: DECELERATE 0.5;
+ }
+ program {
+ signal: "hide"; source: "";
+ action: STATE_SET "default" 0.0;
+ target: "clip";
+ target: "base";
+ }
+ program {
+ signal: "elm,state,hide"; source: "elm";
+ action: STATE_SET "default" 0.0;
+ target: "clip";
+ target: "base";
+ transition: DECELERATE 0.5;
+ }
+ }
+}
+
+group { name: "elm/notify/center/popup/universalSwitchTransparent";
+ inherit: "elm/notify/center/universalSwitchTransparent";
+}
+
+group { name: "elm/button/base/universalSwitchTransparent";
+ parts {
+ spacer { "base";
+ desc { "default";
+ rel1.offset: 0 0;
+ rel2.offset: 0 0;
+ }
+ }
+ rect { "icon_clip";
+ desc { "default";
+ }
+ }
+ swallow { "elm.swallow.content"; nomouse;
+ clip_to: "icon_clip";
+ desc { "default";
+ fixed: 1 0;
+ align: 0.0 0.5;
+ rel1.to: "base";
+ rel2.relative: 0.0 1.0;
+
+ rel2.to: "base";
+ visible: 1;
+ aspect: 1.0 1.0;
+ }
+ desc { "visible";
+ inherit: "default";
+ fixed: 1 0;
+ aspect: 1.0 1.0;
+ visible: 1;
+ }
+ desc { "icononly";
+ inherit: "default";
+ fixed: 0 0;
+ align: 0.5 0.5;
+ rel2.relative: 1.0 1.0;
+ rel2.offset: -1 -5;
+ visible: 1;
+ }
+ }
+ text { "elm.text"; nomouse;
+ scale: 1;
+ desc { "default";
+ rel1.relative: 0.1 0.0;
+ rel2.relative: 1.0 1.0;
+ color: 0 0 0 255;
+ color2: 0 0 0 0;
+ color3: 0 0 0 0;
+ text
+ {
+ font: "Tizen:style=Regular";
+ align: 0.0 0.5;
+ size: 12;
+ text_class: "tizen";
+ }
+ visible: 1;
+ }
+ }
+ rect { "event";
+ desc { "default";
+ color: 0 0 0 0;
+ }
+ desc { "disabled";
+ inherit: "default";
+ visible: 0;
+ }
+ }
+ }
+ programs {
+ program {
+ signal: "mouse,clicked,1"; source: "event";
+ action: SIGNAL_EMIT "elm,action,click" "elm";
+ }
+ }
+}
+
+}
#include "Activity.hpp"
Activity::Activity(const std::string &activityType)
- : type(activityType)
+ : completed(false), type(activityType)
{}
std::string Activity::getType()
{
return type;
}
+
+bool Activity::isCompleted()
+{
+ return completed;
+}
virtual bool process() = 0;
+ virtual bool isCompleted();
+
+protected:
+ bool completed;
+
private:
std::string type;
};
{
return uiElement;
}
+
+bool ActivityChangeRequest::hasUIElement()
+{
+ return uiElement != nullptr;
+}
ActivityChangeRequest(const std::string &activityType, const std::shared_ptr<UIElement> &uiElement);
std::string getActivityType();
std::shared_ptr<UIElement> getUIElement();
+ bool hasUIElement();
protected:
std::string activityType;
#include "UniversalSwitchLog.hpp"
-MenuItem::MenuItem(std::vector<std::string> names, std::string imgPath, std::string activityType, std::string key)
- : names(std::move(names)), imgPath(std::move(imgPath)), activityType(std::move(activityType)), key(std::move(key)) {}
+MenuItem::MenuItem(std::vector<std::string> names, std::string iconPath, std::string activityType, std::string key, std::string subMenuLabel)
+ : names(std::move(names)), iconPath(std::move(iconPath)), activityType(std::move(activityType)),
+ key(std::move(key)), subMenuLabel(std::move(subMenuLabel)) {}
-std::string MenuItem::getName()
+std::string MenuItem::getName() const
{
return gettext(names[key.empty() ? 0 : getMessageIndex()].c_str());
}
-std::string MenuItem::getIcon()
+std::string MenuItem::getIconPath() const
{
- return imgPath;
+ return iconPath;
}
-std::string MenuItem::getActivityType()
+std::string MenuItem::getActivityType() const
{
return activityType;
}
-std::string MenuItem::getKey()
+std::string MenuItem::getVconfKey() const
{
return key;
}
-int MenuItem::getMessageIndex() //works for Universal Switch keys, TODO check system keys
+std::string MenuItem::getSubMenuLabel() const
{
- auto val = VConfSingleton::instance().get(key.c_str(), 0) - 1;
+ return subMenuLabel;
+}
+
+int MenuItem::getMessageIndex() const /*works for Vconf keynodes having integer value*/
+{
+ auto val = VConfSingleton::instance().get(key.c_str(), 0) - 1; /*correct index starts from 1, 0 means error*/
if (val >= static_cast<int>(names.size()) || val < 0) {
ERROR("Wrong message index from vconf, using default value");
return 0;
std::string defaultImg = std::string(ICONS_DIR) + std::string("/tizen.png");
auto tap = std::make_shared<MenuItem>(
std::vector<std::string> {"IDS_TAP"},
- defaultImg
- );
+ defaultImg,
+ "TAP");
auto homeScreen = std::make_shared<MenuItem>(
std::vector<std::string> {"IDS_HOME_SCREEN"},
defaultImg
);
auto back = std::make_shared<MenuItem>(
std::vector<std::string> {"IDS_BACK"},
- defaultImg,
- "SELECT");
+ defaultImg
+ );
auto openCloseNotifications = std::make_shared<MenuItem>(
std::vector<std::string> {"IDS_OPEN_NOTI_PANEL", "IDS_CLOSE_NOTI_PANEL"},
defaultImg
);
auto autoScroll = std::make_shared<MenuItem>(
std::vector<std::string> {"IDS_AUTO_SCROLL"},
- defaultImg
+ defaultImg,
+ "SELECT",
+ "",
+ "IDS_MENU_AUTO_SCROLL"
);
auto ScreenRotation = std::make_shared<MenuItem>(
std::vector<std::string> {"IDS_SCREEN_ROTATION"},
- defaultImg
+ defaultImg,
+ "SELECT",
+ "",
+ "IDS_MENU_ROTATE_SCREEN"
);
auto gestures = std::make_shared<MenuItem>(
std::vector<std::string> {"IDS_GESTURES"},
- defaultImg
+ defaultImg,
+ "SELECT",
+ "",
+ "IDS_MENU_GESTURES"
);
auto actions = std::make_shared<MenuItem>(
std::vector<std::string> {"IDS_ACTIONS"},
- defaultImg
+ defaultImg,
+ "SELECT",
+ "",
+ "IDS_MENU_ACTIONS"
);
auto settings = std::make_shared<MenuItem>(
std::vector<std::string> {"IDS_SETTINGS"},
- defaultImg
+ defaultImg,
+ "SELECT",
+ "",
+ "IDS_MENU_SETTINGS"
);
auto buttonsAndKeys = std::make_shared<MenuItem>(
std::vector<std::string> {"IDS_BUTTONS_AND_KEYS"},
- defaultImg
+ defaultImg,
+ "SELECT",
+ "",
+ "IDS_MENU_BUTTONS_KEYS"
);
auto editText = std::make_shared<MenuItem>(
std::vector<std::string> {"IDS_EDIT_TEXT"},
- defaultImg
+ defaultImg,
+ "SELECT",
+ "",
+ "IDS_MENU_EDIT_TEXT"
);
auto granularitySettings = std::make_shared<MenuItem>(
std::vector<std::string> {"IDS_GRANULARITY_SETTINGS"},
- defaultImg
+ defaultImg,
+ "SELECT",
+ "",
+ "IDS_MENU_GRANULARITY"
);
auto emptyItem = std::make_shared<MenuItem>(
std::vector<std::string> {""},
"");
- addToMap("menu-main-normal", {tap, gestures, actions, settings, recentApps, homeScreen, back, buttonsAndKeys});
- addToMap("menu-main-home-apps", {tap, leftPage, rightPage, emptyItem, gestures, actions, settings, recentApps, homeScreen, back, buttonsAndKeys});
- addToMap("menu-main-slider", {increase, decrease, emptyItem, emptyItem, tap, gestures, actions, settings, recentApps, homeScreen, back, buttonsAndKeys});
- addToMap("menu-main-editable-text", {tap, editText, emptyItem, emptyItem, gestures, actions, settings, recentApps, homeScreen, back, buttonsAndKeys});
- addToMap("menu-main-sip", {tap, touchHold});
- addToMap("menu-main-incoming-call", {tap, accept, reject, emptyItem, gestures, actions, settings, recentApps, homeScreen, back, buttonsAndKeys});
- addToMap("menu-main-during-call", {tap, endCall, emptyItem, emptyItem, gestures, actions, settings, recentApps, homeScreen, back, buttonsAndKeys});
- addToMap("menu-gestures", {swipeUp, swipeDown, swipeLeft, swipeRight, autoScroll, touchHold, drag, touchHoldThenDrag});
- addToMap("menu-actions", {zoomIn, zoomOut, ScreenRotation, soundVibrationMute, lock, openCloseNotifications, captureScreenshot});
- addToMap("menu-rotate-screen", {rotateLeft, rotateToPortrait, rotateRight});
- addToMap("menu-settings-auto-scan-off", {pointRowScan, scanMethod, turnOnOffSound, turnOnOffVoice, moreSettings});
- addToMap("menu-settings-auto-scan-on", {speedUpScaning, slowDownScaning, pointRowScan, scanMethod, turnOnOffSound, turnOnOffVoice, moreSettings});
- addToMap("menu-buttons-keys", {ringtoneVolIncrease, ringtoneVolDecrease, mediaVolumeIncrease, mediaVolumeDecrease,
- tapHomeButtonx2, tapHomeButtonx3, viewPowerKeyMenu
- });
- addToMap("menu-buttons-keys-wifi", {notiVolumeIncrease, notiVolumeDecrease, mediaVolumeIncrease, mediaVolumeDecrease,
+ addToMap("IDS_MENU_MAIN_NORMAL", {tap, gestures, actions, settings, recentApps, homeScreen, back, buttonsAndKeys});
+ addToMap("IDS_MENU_MAIN_HOME_APPS", {tap, leftPage, rightPage, emptyItem, gestures, actions, settings, recentApps, homeScreen, back, buttonsAndKeys});
+ addToMap("IDS_MENU_MAIN_SLIDER", {increase, decrease, emptyItem, emptyItem, tap, gestures, actions, settings, recentApps, homeScreen, back, buttonsAndKeys});
+ addToMap("IDS_MENU_MAIN_EDITABLE_TEXT", {tap, editText, emptyItem, emptyItem, gestures, actions, settings, recentApps, homeScreen, back, buttonsAndKeys});
+ addToMap("IDS_MENU_MAIN_SIP", {tap, touchHold});
+ addToMap("IDS_MENU_MAIN_INCOMING_CALL", {tap, accept, reject, emptyItem, gestures, actions, settings, recentApps, homeScreen, back, buttonsAndKeys});
+ addToMap("IDS_MENU_MAIN_DURING_CALL", {tap, endCall, emptyItem, emptyItem, gestures, actions, settings, recentApps, homeScreen, back, buttonsAndKeys});
+ addToMap("IDS_MENU_GESTURES", {swipeUp, swipeDown, swipeLeft, swipeRight, autoScroll, touchHold, drag, touchHoldThenDrag});
+ addToMap("IDS_MENU_ACTIONS", {zoomIn, zoomOut, ScreenRotation, soundVibrationMute, lock, openCloseNotifications, captureScreenshot});
+ addToMap("IDS_MENU_ROTATE_SCREEN", {rotateLeft, rotateToPortrait, rotateRight});
+ addToMap("IDS_MENU_SETTINGS_AUTO_SCAN_OFF", {pointRowScan, scanMethod, turnOnOffSound, turnOnOffVoice, moreSettings});
+ addToMap("IDS_MENU_SETTINGS_AUTO_SCAN_ON", {speedUpScaning, slowDownScaning, pointRowScan, scanMethod, turnOnOffSound, turnOnOffVoice, moreSettings});
+ addToMap("IDS_MENU_BUTTONS_KEYS", {ringtoneVolIncrease, ringtoneVolDecrease, mediaVolumeIncrease, mediaVolumeDecrease,
tapHomeButtonx2, tapHomeButtonx3, viewPowerKeyMenu
});
- addToMap("menu-edit-text", {selectionMode, selectAll, previous, next, copy, paste, cut, granularitySettings});
- addToMap("menu-auto-scroll-off", {turnOnOffAutoScroll, scrollUp, scrollDown, scrollTop});
- addToMap("menu-auto-scroll-on", {turnOnOffAutoScroll, speedUpAutoScroll, slowDownAutoScroll});
- addToMap("menu-granularity", {character, word, line, paragraph});
+ addToMap("IDS_MENU_BUTTONS_KEYS_WIFI", {notiVolumeIncrease, notiVolumeDecrease, mediaVolumeIncrease, mediaVolumeDecrease,
+ tapHomeButtonx2, tapHomeButtonx3, viewPowerKeyMenu
+ });
+ addToMap("IDS_MENU_EDIT_TEXT", {selectionMode, selectAll, previous, next, copy, paste, cut, granularitySettings});
+ addToMap("IDS_MENU_AUTO_SCROLL_OFF", {turnOnOffAutoScroll, scrollUp, scrollDown, scrollTop});
+ addToMap("IDS_MENU_AUTO_SCROLL_ON", {turnOnOffAutoScroll, speedUpAutoScroll, slowDownAutoScroll});
+ addToMap("IDS_MENU_GRANULARITY", {character, word, line, paragraph});
}
-std::vector<std::shared_ptr<MenuItem>> MenuMap::find(const std::string &searchKey)
+std::vector<std::shared_ptr<MenuItem>> MenuMap::find(const std::string &menuLabel)
{
- std::vector<std::shared_ptr<MenuItem>> returnVector;
- auto keyRange = map.equal_range(searchKey);
+ std::vector<std::shared_ptr<MenuItem>> foundMenuItems;
+ auto keyRange = map.equal_range(menuLabel);
for (auto ii = keyRange.first; ii != keyRange.second; ++ii)
- returnVector.push_back(ii->second);
+ foundMenuItems.push_back(ii->second);
- return returnVector;
+ return foundMenuItems;
}
-void MenuMap::addToMap(std::string menu, std::vector<std::shared_ptr<MenuItem>> menuVector)
+void MenuMap::addToMap(std::string menuLabel, std::vector<std::shared_ptr<MenuItem>> menuItems)
{
- while (!menuVector.empty()) {
- map.insert(std::make_pair(menu, menuVector.back()));
- menuVector.pop_back();
+ while (!menuItems.empty()) {
+ map.insert(std::make_pair(menuLabel, menuItems.back()));
+ menuItems.pop_back();
}
}
class MenuItem
{
public:
- MenuItem(std::vector<std::string> names, std::string imgPath, std::string activityType = "", std::string key = "");
+ MenuItem(std::vector<std::string> names, std::string iconPath, std::string activityType = "", std::string key = "", std::string subMenuLabel = "");
- std::string getName();
- std::string getIcon();
- std::string getActivityType();
- std::string getKey();
+ std::string getName() const;
+ std::string getIconPath() const;
+ std::string getActivityType() const;
+ std::string getVconfKey() const;
+ std::string getSubMenuLabel() const;
private:
std::vector<std::string> names;
- std::string imgPath;
+ std::string iconPath;
std::string activityType;
std::string key;
+ std::string subMenuLabel;
- int getMessageIndex();
+ int getMessageIndex() const;
};
class MenuMap
public:
MenuMap();
- std::vector<std::shared_ptr<MenuItem>> find(const std::string &searchKey);
+ std::vector<std::shared_ptr<MenuItem>> find(const std::string &);
private:
- void addToMap(std::string menu, std::vector<std::shared_ptr<MenuItem>> menuVector);
+ void addToMap(std::string, std::vector<std::shared_ptr<MenuItem>>);
std::multimap<std::string, std::shared_ptr<MenuItem>> map;
};
#include "UIActivity.hpp"
#include "ActivityFactory.hpp"
+#include "UniversalSwitchLog.hpp"
+#include "MenuBuilder.hpp"
+#include "Window.hpp"
+#include "VConf.hpp"
+#include "ScreenScannerManager.hpp"
+#include "Optional.hpp"
+#include <Elementary.h>
+#include <ui/efl_util.h>
+#include <efl_extension.h>
+#include <telephony.h>
+#include <memory>
+#include <vector>
+#include <stack>
+#include <string>
+
+static const double GENGRID_ITEM_HEIGHT_WIDTH_PROPORTION = 1.2;
+static const int ITEMS_IN_GENGRID_PER_ROW = 4;
+static const int POPUP_GENGRID_SIZE_FACTOR = 50;
+static const int AUTO_TAP_WAITING_PERIOD_DEFAULT_TIME = 3;
+
+static const std::string AUTO_SCAN_KEY = "__KEY_ACCESSIBILITY_UNIVERSAL_SWITCH_SETTINGS_AUTO_SCAN_ENABLED";
+static const std::string AUTO_SCROLL_KEY = "__KEY_ACCESSIBILITY_UNIVERSAL_SWITCH_SETTINGS_AUTO_SCROLL";
+static const std::string AUTO_TAP_KEY = "__KEY_ACCESSIBILITY_UNIVERSAL_SWITCH_SETTINGS_AUTO_TAP_STATE";
+static const std::string AUTO_TAP_WAITING_PERIOD_KEY = "__KEY_ACCESSIBILITY_UNIVERSAL_SWITCH_SETTINGS_AUTO_TAP_VALUE";
class SelectActivity : public UIActivity, RegisterActivity<SelectActivity>
{
public:
static constexpr const char *activityType = "SELECT";
- SelectActivity(): UIActivity(activityType) {}
- bool process() override
- {
+ SelectActivity(): UIActivity(activityType), popup(nullptr, evas_object_del),
+ virtualBackButton(nullptr, evas_object_del), timer(nullptr), autoTapWaitingPeriod(AUTO_TAP_WAITING_PERIOD_DEFAULT_TIME) {}
+ ~SelectActivity();
+
+ bool process() override;
+ void update(const std::shared_ptr<UIElement> &elem) override;
+
+private:
+ typedef std::pair<SelectActivity *, std::shared_ptr<MenuItem>> GengridItemSelectedCbData;
+
+ void createMenu();
+ void removeMenu();
+ void createMenuContent();
+ void addBackButton(Evas_Object *);
+ void refreshMenu();
+ void getAutoTapWaitingPeriodCb(int);
+ void navigateThroughSubMenuOrCreateActivityChangeRequest(MenuItem *);
+ void navigateThroughSubMenu(const std::string &);
+ void navigateBack();
+ void sendTapActivityChangeRequest();
+ std::string getCompleteLabelOfMenu();
+ std::string getCompleteLabelOfMainMenu();
+ Optional<telephony_call_state_e> getPhoneCallState();
+ bool isUIElementSlider();
+ bool hasUIElementEditableTextIface();
+ std::string getCompleteLabelOfButtonsKeysMenu();
+ int addItemsToMenu(Evas_Object *, const std::string &);
+
+ static void popupDismissedCb(void *, Evas_Object *, void *);
+ static void popupBackCb(void *, Evas_Object *, void *);
+ static void gengridItemSelectedCb(void *, Evas_Object *, void *);
+ static char *gengridItemLabelGetCb(void *, Evas_Object *, const char *);
+ static Evas_Object *gengridItemContentGetCb(void *, Evas_Object *, const char *);
+ static Eina_Bool autoTapCb(void *);
+ static void deleteAndClearTimer(Ecore_Timer *&);
+ static int divideAndRoundOut(int, int);
+
+ std::vector<std::string> nestedMenusLabels;
+ std::stack<VConfInterface::CallbackHandle> callbackHandle;
+ std::stack<GengridItemSelectedCbData> gengridItemsSelectedCbData;
+ std::shared_ptr<UIElement> realUiElement;
+ std::unique_ptr<Evas_Object, void(*)(Evas_Object *)> popup;
+ std::unique_ptr<Evas_Object, void(*)(Evas_Object *)> virtualBackButton;
+ VConfInterface::CallbackHandle autoTapWaitingPeriodCallbackHandle;
+ Ecore_Timer *timer;
+ int autoTapWaitingPeriod;
+};
+
+SelectActivity::~SelectActivity()
+{
+ removeMenu();
+}
+
+bool SelectActivity::process()
+{
+ if (completed)
return true;
+
+ if (timer) {
+ deleteAndClearTimer(timer);
+ nestedMenusLabels.push_back("IDS_MENU_MAIN");
+ createMenu();
}
-};
+
+ ScreenScannerManager::instance().acceptAutoscanning();
+
+ return false;
+}
+
+void SelectActivity::update(const std::shared_ptr<UIElement> &elem)
+{
+ if (realUiElement) {
+ elem->activate(); /*elem is popup menu item*/
+ return;
+ }
+
+ realUiElement = elem;
+ if (VConfSingleton::instance().get(AUTO_TAP_KEY, 1) - 1) {
+ VConfSingleton::instance().registerAndGet<int>(AUTO_TAP_WAITING_PERIOD_KEY, AUTO_TAP_WAITING_PERIOD_DEFAULT_TIME,
+ std::bind(&SelectActivity::getAutoTapWaitingPeriodCb, this, std::placeholders::_1));
+ timer = ecore_timer_add(autoTapWaitingPeriod, autoTapCb, this);
+ return;
+ }
+
+ nestedMenusLabels.push_back("IDS_MENU_MAIN");
+ createMenu();
+}
+
+void SelectActivity::createMenu()
+{
+ popup.reset(elm_popup_add(Window::getHandler().get()));
+ elm_atspi_accessible_name_set(popup.get(), "");
+ elm_popup_orient_set(popup.get(), ELM_POPUP_ORIENT_CENTER);
+ elm_theme_extension_add(NULL, UNIVERSAL_SWITCH_EDJ);
+ elm_object_style_set(popup.get(), "universalSwitchTransparent");
+ elm_atspi_accessible_attribute_append(popup.get(), "ScanningMethod", "RowScanner");
+ createMenuContent();
+ evas_object_size_hint_weight_set(popup.get(), EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
+ evas_object_smart_callback_add(popup.get(), "dismissed", popupDismissedCb, this);
+ eext_object_event_callback_add(popup.get(), EEXT_CALLBACK_BACK, popupBackCb, this);
+ evas_object_show(popup.get());
+}
+
+void SelectActivity::removeMenu()
+{
+ while (!callbackHandle.empty())
+ callbackHandle.pop();
+
+ while (!gengridItemsSelectedCbData.empty())
+ gengridItemsSelectedCbData.pop();
+
+ if (virtualBackButton) {
+ evas_object_smart_callback_del(virtualBackButton.get(), "clicked", popupBackCb);
+ virtualBackButton.reset();
+ }
+
+ if (popup) {
+ eext_object_event_callback_del(popup.get(), EEXT_CALLBACK_BACK, popupBackCb);
+ evas_object_smart_callback_del(popup.get(), "dismissed", popupDismissedCb);
+ popup.reset();
+ }
+
+ deleteAndClearTimer(timer);
+}
+
+void SelectActivity::createMenuContent()
+{
+ auto content = elm_layout_add(popup.get());
+ auto gengrid = elm_gengrid_add(popup.get());
+
+ elm_layout_file_set(content, UNIVERSAL_SWITCH_EDJ, "universalSwitchTransparentLayout");
+ elm_object_style_set(gengrid, "popup");
+ evas_object_size_hint_min_set(content, 1, 1);
+ elm_object_content_set(popup.get(), content);
+ elm_object_part_content_set(content, "elm.swallow.content", gengrid);
+
+ if (nestedMenusLabels.size() > 1)
+ addBackButton(content);
+
+ auto screenWidth = 0;
+ evas_object_geometry_get(content, nullptr, nullptr, &screenWidth, nullptr);
+
+ int itemWidth = screenWidth / ITEMS_IN_GENGRID_PER_ROW;
+ int itemHeight = itemWidth * GENGRID_ITEM_HEIGHT_WIDTH_PROPORTION;
+ elm_gengrid_item_size_set(gengrid, itemWidth, itemHeight);
+
+ auto completeLabelOfMenu = getCompleteLabelOfMenu();
+ auto numberOfItems = addItemsToMenu(gengrid, completeLabelOfMenu);
+ auto rows = divideAndRoundOut(numberOfItems, ITEMS_IN_GENGRID_PER_ROW);
+
+ evas_object_size_hint_min_set(gengrid, 1, itemHeight * rows + POPUP_GENGRID_SIZE_FACTOR);
+ evas_object_size_hint_weight_set(gengrid, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
+}
+
+void SelectActivity::addBackButton(Evas_Object *content)
+{
+ virtualBackButton.reset(elm_button_add(content));
+ elm_atspi_accessible_name_set(virtualBackButton.get(), gettext("IDS_NAVIGATE_UP"));
+ elm_object_style_set(virtualBackButton.get(), "universalSwitchTransparent");
+ elm_object_part_content_set(content, "elm.swallow.back", virtualBackButton.get());
+ elm_layout_signal_emit(content, "elm,state,back,visible", "elm");
+ elm_object_part_text_set(virtualBackButton.get(), "default", gettext(nestedMenusLabels.end()[-2].c_str()));
+ auto backIcon = elm_icon_add(content);
+ auto iconPath = std::string(ICONS_DIR) + std::string("/back.png");
+ elm_image_file_set(backIcon, iconPath.c_str(), NULL);
+ elm_object_part_content_set(virtualBackButton.get(), "icon", backIcon);
+ evas_object_smart_callback_add(virtualBackButton.get(), "clicked", popupBackCb, this);
+}
+
+void SelectActivity::refreshMenu()
+{
+ removeMenu();
+ createMenu();
+}
+
+void SelectActivity::getAutoTapWaitingPeriodCb(int value)
+{
+ autoTapWaitingPeriod = value;
+}
+
+void SelectActivity::navigateThroughSubMenuOrCreateActivityChangeRequest(MenuItem *menuItem)
+{
+ if (menuItem->getName().empty())
+ return;
+
+ if (menuItem->getActivityType() == SelectActivity::activityType) {
+ navigateThroughSubMenu(menuItem->getSubMenuLabel());
+ return;
+ }
+
+ removeMenu();
+ completed = true;
+ notify(std::make_shared<ActivityChangeRequest>(menuItem->getActivityType(), realUiElement));
+}
+
+void SelectActivity::navigateThroughSubMenu(const std::string &subMenuLabel)
+{
+ nestedMenusLabels.push_back(subMenuLabel);
+ refreshMenu();
+}
+
+void SelectActivity::navigateBack()
+{
+ removeMenu();
+ nestedMenusLabels.pop_back();
+ if (nestedMenusLabels.empty())
+ completed = true;
+ else
+ refreshMenu();
+}
+
+void SelectActivity::sendTapActivityChangeRequest()
+{
+ timer = nullptr;
+ completed = true;
+ notify(std::make_shared<ActivityChangeRequest>("TAP", realUiElement));
+}
+
+std::string SelectActivity::getCompleteLabelOfMenu()
+{
+ if (nestedMenusLabels.back() == "IDS_MENU_MAIN")
+ return getCompleteLabelOfMainMenu();
+
+ if (nestedMenusLabels.back() == "IDS_MENU_SETTINGS") {
+ auto completeLabelOfSettingsMenu = VConfSingleton::instance().get(AUTO_SCAN_KEY, false) ?
+ "IDS_MENU_SETTINGS_AUTO_SCAN_ON" : "IDS_MENU_SETTINGS_AUTO_SCAN_OFF";
+ callbackHandle.push(VConfSingleton::instance().registerKeyChangedCb<bool>(AUTO_SCAN_KEY,
+ std::bind(&SelectActivity::refreshMenu, this)));
+ return completeLabelOfSettingsMenu;
+ }
+
+ if (nestedMenusLabels.back() == "IDS_MENU_AUTO_SCROLL")
+ return (VConfSingleton::instance().get(AUTO_SCROLL_KEY, 1) - 1) ?
+ "IDS_MENU_AUTO_SCROLL_ON" : "IDS_MENU_AUTO_SCROLL_OFF";
+
+ if (nestedMenusLabels.back() == "IDS_MENU_BUTTONS_KEYS")
+ return getCompleteLabelOfButtonsKeysMenu();
+
+ return nestedMenusLabels.back();
+}
+
+std::string SelectActivity::getCompleteLabelOfMainMenu()
+{
+ //TODO sip, home-apps
+ auto phoneCallState = getPhoneCallState();
+
+ if (phoneCallState && *phoneCallState == TELEPHONY_CALL_STATE_CONNECTED)
+ return "IDS_MENU_MAIN_DURING_CALL";
+ if (phoneCallState && *phoneCallState == TELEPHONY_CALL_STATE_CONNECTING)
+ return "IDS_MENU_MAIN_INCOMING_CALL";
+
+ if (isUIElementSlider())
+ return "IDS_MENU_MAIN_SLIDER";
+
+ if (hasUIElementEditableTextIface())
+ return "IDS_MENU_MAIN_EDITABLE_TEXT";
+
+ return "IDS_MENU_MAIN_NORMAL";
+}
+
+Optional<telephony_call_state_e> SelectActivity::getPhoneCallState()
+{
+ telephony_handle_list_s list;
+ auto error = telephony_init(&list);
+ if (error != TELEPHONY_ERROR_NONE) {
+ ERROR("Can't init telephony API. Error no. %d", error);
+ return {};
+ }
+
+ for (auto i = 0u; i < list.count; i++) {
+ telephony_call_state_e callState;
+ error = telephony_call_get_voice_call_state(list.handle[i], &callState);
+ if (error != TELEPHONY_ERROR_NONE) {
+ ERROR("Can't get call state. Error no. %d", error);
+ break;
+ }
+
+ if (callState != TELEPHONY_CALL_STATE_IDLE) {
+ telephony_deinit(&list);
+ return callState;
+ }
+ }
+
+ telephony_deinit(&list);
+ return TELEPHONY_CALL_STATE_IDLE;
+}
+
+bool SelectActivity::isUIElementSlider()
+{
+ return realUiElement && atspi_accessible_get_role(realUiElement->getObject().get(), nullptr) == ATSPI_ROLE_SLIDER;
+}
+
+bool SelectActivity::hasUIElementEditableTextIface()
+{
+ if (!realUiElement)
+ return false;
+
+ auto editableTextIface = atspi_accessible_get_editable_text_iface(realUiElement->getObject().get());
+ if (editableTextIface) {
+ g_object_unref(editableTextIface);
+ return true;
+ }
+
+ return false;
+}
+
+std::string SelectActivity::getCompleteLabelOfButtonsKeysMenu()
+{
+ telephony_handle_list_s list;
+ auto error = telephony_init(&list);
+ if (error != TELEPHONY_ERROR_NONE) {
+ ERROR("Can't init telephony API. Error no. %d", error);
+ return "IDS_MENU_BUTTONS_KEYS_WIFI";
+ }
+
+ for (auto i = 0u; i < list.count; i++) {
+ telephony_sim_state_e simState;
+ error = telephony_sim_get_state(list.handle[i], &simState);
+ if (error != TELEPHONY_ERROR_NONE) {
+ ERROR("Can't get sim state. Error no. %d", error);
+ break;
+ }
+
+ if (simState == TELEPHONY_SIM_STATE_AVAILABLE || simState == TELEPHONY_SIM_STATE_LOCKED) {
+ telephony_deinit(&list);
+ return "IDS_MENU_BUTTONS_KEYS";
+ }
+
+ }
+
+ telephony_deinit(&list);
+ return "IDS_MENU_BUTTONS_KEYS_WIFI";
+}
+
+int SelectActivity::addItemsToMenu(Evas_Object *gengrid, const std::string &completeLabelOfMenu)
+{
+ Elm_Gengrid_Item_Class *gic = elm_gengrid_item_class_new();
+ gic->item_style = "default";
+ gic->func.text_get = gengridItemLabelGetCb;
+ gic->func.content_get = gengridItemContentGetCb;
+
+ auto menuItems = Singleton<MenuMap>::instance().find(completeLabelOfMenu);
+ auto numberOfItems = menuItems.size();
+ while (!menuItems.empty()) {
+ gengridItemsSelectedCbData.push(std::make_pair(this, menuItems.back()));
+ auto object = elm_gengrid_item_append(gengrid, gic, menuItems.back().get(), gengridItemSelectedCb, &(gengridItemsSelectedCbData.top()));
+ if (object && menuItems.back()->getName().empty())
+ elm_atspi_accessible_can_highlight_set(object, EINA_FALSE);
+
+ if (!menuItems.back()->getVconfKey().empty()) {
+ callbackHandle.push(VConfSingleton::instance().registerKeyChangedCb<int>(menuItems.back()->getVconfKey(),
+ std::bind(&SelectActivity::refreshMenu, this)));
+ }
+ menuItems.pop_back();
+ }
+
+ elm_gengrid_item_class_free(gic);
+
+ return numberOfItems;
+}
+
+void SelectActivity::popupDismissedCb(void *data, Evas_Object *obj, void *event_info)
+{
+ static_cast<SelectActivity *>(data)->removeMenu();
+}
+
+void SelectActivity::popupBackCb(void *data, Evas_Object *obj, void *event_info)
+{
+ static_cast<SelectActivity *>(data)->navigateBack();
+}
+
+char *SelectActivity::gengridItemLabelGetCb(void *data, Evas_Object *obj, const char *part)
+{
+ auto menuItem = static_cast<MenuItem *>(data);
+ if (part && !strcmp(part, "elm.text") && menuItem)
+ return strdup(menuItem->getName().c_str());
+
+ return strdup("");
+}
+
+Evas_Object *SelectActivity::gengridItemContentGetCb(void *data, Evas_Object *obj, const char *part)
+{
+ auto menuItem = static_cast<MenuItem *>(data);
+ if (!part || strcmp(part, "elm.swallow.icon") || !menuItem || menuItem->getIconPath().empty())
+ return nullptr;
+
+ auto img = elm_image_add(obj);
+ elm_image_file_set(img, menuItem->getIconPath().c_str(), nullptr);
+ return img;
+}
+
+void SelectActivity::gengridItemSelectedCb(void *data, Evas_Object *obj, void *event_info)
+{
+ elm_gengrid_item_selected_set(static_cast<Elm_Gengrid_Item *>(event_info), EINA_FALSE);
+ auto pair = static_cast<GengridItemSelectedCbData *>(data);
+ pair->first->navigateThroughSubMenuOrCreateActivityChangeRequest(pair->second.get());
+}
+
+Eina_Bool SelectActivity::autoTapCb(void *data)
+{
+ static_cast<SelectActivity *>(data)->sendTapActivityChangeRequest();
+ return ECORE_CALLBACK_CANCEL;
+}
+
+void SelectActivity::deleteAndClearTimer(Ecore_Timer *&timer)
+{
+ if (!timer)
+ return;
+
+ ecore_timer_del(timer);
+ timer = nullptr;
+}
+
+int SelectActivity::divideAndRoundOut(int dividend, int divisor)
+{
+ ASSERT(divisor, "Zero divisor");
+
+ return (dividend + divisor - 1) / divisor;
+}
\ No newline at end of file
void SwitchManager::changeActivity(const std::shared_ptr<ActivityChangeRequest> &request)
{
ASSERT(request, "request is not initialized");
+
+ while (!activities.empty() && activities.top()->isCompleted())
+ activities.pop();
+
if (activities.empty() || (activities.top() && activities.top()->getType() != request->getActivityType())) {
auto activity = activityFactory->createActivity(request->getActivityType());
if (!activity) {
auto cond = std::unique_ptr<Condition<ActivityChangeRequest>>(new ConditionAll<ActivityChangeRequest>);
activity->attach(shared_from_this(), std::move(cond));
- auto uiActivity = dynamic_cast<UIActivity *>(activity.get());
-
- if (uiActivity)
+ auto uiActivity = std::dynamic_pointer_cast<UIActivity>(activity);
+ if (uiActivity && request->hasUIElement())
uiActivity->update(request->getUIElement());
activities.push(activity);
}
- bool completed = false;
- if (activities.empty())
+ if (activities.empty()) {
ERROR("No activity provided.");
- else
- completed = activities.top()->process();
+ return;
+ }
+
+ bool completed = activities.top()->process();
if (completed)
activities.pop();
{
return y;
}
+
+void UIElement::activate()
+{
+ //TODO use at-spi action intrtface
+}
\ No newline at end of file
std::shared_ptr<AtspiAccessible> getObject() const;
int getX() const;
int getY() const;
+ void activate();
private:
std::shared_ptr<AtspiAccessible> obj;
for (auto ii = 0u; ii < actualMenuItems.size(); ++ii) {
EXPECT_EQ(actualMenuItems[ii]->getName(), expectedMenuItemsNames[actualMenuItems.size() - 1 - ii]);
if (!expectedMenuItemsKeys.empty())
- EXPECT_EQ(actualMenuItems[ii]->getKey(), expectedMenuItemsKeys[actualMenuItems.size() - 1 - ii]);
+ EXPECT_EQ(actualMenuItems[ii]->getVconfKey(), expectedMenuItemsKeys[actualMenuItems.size() - 1 - ii]);
}
}
};
TEST_F(MenuBuilderTest, checkContentOfMenuMainNormal)
{
- testMenuContent("menu-main-normal", {
+ testMenuContent("IDS_MENU_MAIN_NORMAL", {
"IDS_TAP", "IDS_GESTURES", "IDS_ACTIONS", "IDS_SETTINGS", "IDS_RECENT_APPS",
"IDS_HOME_SCREEN", "IDS_BACK", "IDS_BUTTONS_AND_KEYS"
});
TEST_F(MenuBuilderTest, checkContentOfMenuMainHomeApps)
{
- testMenuContent("menu-main-home-apps", {
+ testMenuContent("IDS_MENU_MAIN_HOME_APPS", {
"IDS_TAP", "IDS_LEFT_PAGE", "IDS_RIGHT_PAGE", "", "IDS_GESTURES", "IDS_ACTIONS", "IDS_SETTINGS",
"IDS_RECENT_APPS", "IDS_HOME_SCREEN", "IDS_BACK", "IDS_BUTTONS_AND_KEYS"
});
TEST_F(MenuBuilderTest, checkContentOfMenuMainSlider)
{
- testMenuContent("menu-main-slider", {
+ testMenuContent("IDS_MENU_MAIN_SLIDER", {
"IDS_INCREASE", "IDS_DECREASE", "", "", "IDS_TAP", "IDS_GESTURES", "IDS_ACTIONS",
"IDS_SETTINGS", "IDS_RECENT_APPS", "IDS_HOME_SCREEN", "IDS_BACK", "IDS_BUTTONS_AND_KEYS"
});
TEST_F(MenuBuilderTest, checkContentOfMenuMainEditableText)
{
- testMenuContent("menu-main-editable-text", {
+ testMenuContent("IDS_MENU_MAIN_EDITABLE_TEXT", {
"IDS_TAP", "IDS_EDIT_TEXT", "", "", "IDS_GESTURES", "IDS_ACTIONS",
"IDS_SETTINGS", "IDS_RECENT_APPS", "IDS_HOME_SCREEN", "IDS_BACK", "IDS_BUTTONS_AND_KEYS"
});
TEST_F(MenuBuilderTest, checkContentOfMainMenuSip)
{
- testMenuContent("menu-main-sip", {
+ testMenuContent("IDS_MENU_MAIN_SIP", {
"IDS_TAP", "IDS_TOUCH_AND_HOLD"
});
}
TEST_F(MenuBuilderTest, checkContentOfMenuMainIncomingCall)
{
- testMenuContent("menu-main-incoming-call", {
+ testMenuContent("IDS_MENU_MAIN_INCOMING_CALL", {
"IDS_TAP", "IDS_ACCEPT", "IDS_REJECT", "", "IDS_GESTURES", "IDS_ACTIONS", "IDS_SETTINGS",
"IDS_RECENT_APPS", "IDS_HOME_SCREEN", "IDS_BACK", "IDS_BUTTONS_AND_KEYS"
});
TEST_F(MenuBuilderTest, checkContentOfMenuMainDuringCall)
{
- testMenuContent("menu-main-during-call", {
+ testMenuContent("IDS_MENU_MAIN_DURING_CALL", {
"IDS_TAP", "IDS_END_CALL", "", "", "IDS_GESTURES", "IDS_ACTIONS", "IDS_SETTINGS",
"IDS_RECENT_APPS", "IDS_HOME_SCREEN", "IDS_BACK", "IDS_BUTTONS_AND_KEYS"
});
TEST_F(MenuBuilderTest, checkContentOfMenuGestures)
{
- testMenuContent("menu-gestures", {
+ testMenuContent("IDS_MENU_GESTURES", {
"IDS_SWIPE_UP", "IDS_SWIPE_DOWN", "IDS_SWIPE_LEFT", "IDS_SWIPE_RIGHT",
"IDS_AUTO_SCROLL", "IDS_TOUCH_AND_HOLD", "IDS_DRAG", "IDS_TOUCH_HOLD_THEN_DRAG"
});
TEST_F(MenuBuilderTest, checkContentOfMenuActions)
{
- testMenuContent("menu-actions", {
+ testMenuContent("IDS_MENU_ACTIONS", {
"IDS_ZOOM_IN", "IDS_ZOOM_OUT", "IDS_SCREEN_ROTATION", "IDS_SOUND",
"IDS_LOCK", "IDS_OPEN_NOTI_PANEL", "IDS_CAPTURE_SCREENSHOT"
}/*TODO complete test when sound, and noti. panel activities will be ready*/);
TEST_F(MenuBuilderTest, checkContentOfMenuRotateScreen)
{
- testMenuContent("menu-rotate-screen", {
+ testMenuContent("IDS_MENU_ROTATE_SCREEN", {
"IDS_ROTATE_LEFT", "IDS_ROTATE_TO_PORTRAIT", "IDS_ROTATE_RIGHT"
});
}
TEST_F(MenuBuilderTest, checkContentOfMenuSettings)
{
- testMenuContent("menu-settings-auto-scan-off", {
+ testMenuContent("IDS_MENU_SETTINGS_AUTO_SCAN_OFF", {
"IDS_ROW_SCAN", "IDS_BOTTOM_TO_TOP", "IDS_TURN_ON_SOUND", "IDS_TURN_ON_VOICE", "IDS_MORE_SETTINGS"
}, {
"__KEY_ACCESSIBILITY_UNIVERSAL_SWITCH_SETTINGS_SCAN_METHOD",
""
});
setKeys(2);
- testMenuContent("menu-settings-auto-scan-on", {
+ testMenuContent("IDS_MENU_SETTINGS_AUTO_SCAN_ON", {
"IDS_SPEED_UP_SCANING", "IDS_SLOW_DOWN_SCANING", "IDS_POINT_SCAN", "IDS_TOP_TO_BOTTOM",
"IDS_TURN_OFF_SOUND", "IDS_TURN_OFF_VOICE", "IDS_MORE_SETTINGS"
}, {
TEST_F(MenuBuilderTest, checkContentOfMenuButtonsKeys)
{
- testMenuContent("menu-buttons-keys", {
+ testMenuContent("IDS_MENU_BUTTONS_KEYS", {
"IDS_RINGTONE_VOLUME_INC", "IDS_RINGTONE_VOLUME_DEC", "IDS_MEDIA_VOLUME_INC", "IDS_MEDIA_VOLUME_DEC",
"IDS_TAP_HOME_BUTTON_X2", "IDS_TAP_HOME_BUTTON_X3", "IDS_VIEW_POWER_KEY_MENU"
});
- testMenuContent("menu-buttons-keys-wifi", {
+ testMenuContent("IDS_MENU_BUTTONS_KEYS_WIFI", {
"IDS_NOTI_VOLUME_INC", "IDS_NOTI_VOLUME_DEC", "IDS_MEDIA_VOLUME_INC", "IDS_MEDIA_VOLUME_DEC",
"IDS_TAP_HOME_BUTTON_X2", "IDS_TAP_HOME_BUTTON_X3", "IDS_VIEW_POWER_KEY_MENU"
});
TEST_F(MenuBuilderTest, checkContentOfMenuEditText)
{
- testMenuContent("menu-edit-text", {
+ testMenuContent("IDS_MENU_EDIT_TEXT", {
"IDS_SELECTION_MODE", "IDS_SELECT_ALL", "IDS_PREVIOUS_CHARACTER", "IDS_NEXT_CHARACTER",
"IDS_COPY", "IDS_PASTE", "IDS_CUT", "IDS_GRANULARITY_SETTINGS"
}, {
TEST_F(MenuBuilderTest, checkContentOfMenuAutoScroll)
{
- testMenuContent("menu-auto-scroll-off", {
+ testMenuContent("IDS_MENU_AUTO_SCROLL_OFF", {
"IDS_TURN_ON_AUTO_SCROLL", "IDS_SCROLL_UP", "IDS_SCROLL_DOWN", "IDS_SCROLL_TOP"
}, {
"__KEY_ACCESSIBILITY_UNIVERSAL_SWITCH_SETTINGS_AUTO_SCROLL",
"", "", ""
});
setKeys(2);
- testMenuContent("menu-auto-scroll-on", {
+ testMenuContent("IDS_MENU_AUTO_SCROLL_ON", {
"IDS_TURN_OFF_AUTO_SCROLL", "IDS_SPEED_UP_AUTO_SCROLL", "IDS_SLOW_DOWN_AUTO_SCROLL"
}, {
"__KEY_ACCESSIBILITY_UNIVERSAL_SWITCH_SETTINGS_AUTO_SCROLL",
TEST_F(MenuBuilderTest, checkContentOfMenuGranularity)
{
- testMenuContent("menu-granularity", {
+ testMenuContent("IDS_MENU_GRANULARITY", {
"IDS_CHARACTER", "IDS_WORD", "IDS_LINE", "IDS_PARAGRAPH"
});
}
TEST_F(MenuBuilderTest, checkAllGranularityOptions)
{
- auto actualMenuItems = Singleton<MenuMap>::instance().find("menu-edit-text");
+ auto actualMenuItems = Singleton<MenuMap>::instance().find("IDS_MENU_EDIT_TEXT");
auto next = actualMenuItems[4];
auto prev = actualMenuItems[5];
auto requiredStates = std::vector<std::string> {"CHARACTER", "WORD", "LINE", "PARAGRAPH"};
TEST_F(MenuBuilderTest, checkTranslations)
{
- auto menuItem = Singleton<MenuMap>::instance().find("menu-main-normal").back();
+ auto menuItem = Singleton<MenuMap>::instance().find("IDS_MENU_MAIN_NORMAL").back();
EXPECT_EQ(menuItem->getName(), "IDS_TAP");
bindtextdomain(PROJECT_NAME, LOCALE_DIR);
textdomain(PROJECT_NAME);
projects / platform / core / accessibility / universal-switch.git / commitdiff
