DLOG();
if (state == CM_AUDIO_STATE_NONE_E) {
- ILOG("Ignore. Unhandled state [%d]", state);
+ ILOG("Ignored. Unhandled state [%d]", state);
return;
}
m_audioStateEvent.dispatch(convertCMAudioState(state));
#include "common.h"
// Temporary until VCONFLAG will not be added to a system
-#define VCONFKEY_CISSAPPL_CALL_VOICE_ANSWER VCONFKEY_CISSAPPL_ANSWERING_KEY_BOOL
+#define VCONFKEY_CISSAPPL_CALL_VOICE_ANSWER_BOOL VCONFKEY_CISSAPPL_ANSWERING_KEY_BOOL
namespace callui {
Result VoiceControlStateProvider::initState()
{
auto val = 0;
- if (vconf_get_bool(VCONFKEY_CISSAPPL_CALL_VOICE_ANSWER, &val) != 0) {
+ if (vconf_get_bool(VCONFKEY_CISSAPPL_CALL_VOICE_ANSWER_BOOL, &val) != 0) {
LOG_RETURN(RES_FAIL, "vconf_get_bool() failed!"
"err[%d]", vconf_get_ext_errno());
}
Result VoiceControlStateProvider::addSysStateCallback()
{
- if (vconf_notify_key_changed(VCONFKEY_CISSAPPL_CALL_VOICE_ANSWER,
+ if (vconf_notify_key_changed(VCONFKEY_CISSAPPL_CALL_VOICE_ANSWER_BOOL,
CALLBACK_B(VoiceControlStateProvider::onStateChanged),
this) != 0) {
void VoiceControlStateProvider::delSysStateCallback()
{
- vconf_ignore_key_changed(VCONFKEY_CISSAPPL_CALL_VOICE_ANSWER,
+ vconf_ignore_key_changed(VCONFKEY_CISSAPPL_CALL_VOICE_ANSWER_BOOL,
CALLBACK_B(VoiceControlStateProvider::onStateChanged));
}
keynode_t *node)
{
auto val = 0;
- if (vconf_get_bool(VCONFKEY_CISSAPPL_CALL_VOICE_ANSWER, &val) != 0) {
+ if (vconf_get_bool(VCONFKEY_CISSAPPL_CALL_VOICE_ANSWER_BOOL, &val) != 0) {
LOG_RETURN_VOID(RES_FAIL, "vconf_get_bool() failed!"
"err[%d]", vconf_get_ext_errno());
}
#include "pages/MainPage.h"
#include "call-ui/resources.h"
+#include "call-ui/presenters/types.h"
#include "common.h"
namespace callui { namespace { namespace impl {
using namespace ucl;
+ constexpr auto POWER_KEY_HOLD_TIMEOUT = 0.4;
+
const char *STR_POWER_KEY = "XF86PowerOff";
}}}
RefCountAware(&rc),
m_sysEventProvider(sysEventProvider),
m_context(nullptr),
- m_keyUpEventHandler(nullptr)
+ m_keyUpEventHandler(nullptr),
+ m_keyDownEventHandler(nullptr),
+ m_ignorePowerClick(false)
{
}
Instance::~Instance()
{
+ m_powerKeyHoldTimout.reset();
+
elm_win_keygrab_unset(*m_win, impl::STR_POWER_KEY, 0, 0);
if (m_keyUpEventHandler) {
m_win = m_context->getWindow();
elm_win_keygrab_set(*m_win, impl::STR_POWER_KEY, 0, 0, 0,
- ELM_WIN_KEYGRAB_EXCLUSIVE);
+ ELM_WIN_KEYGRAB_TOPMOST);
m_keyUpEventHandler = ecore_event_handler_add(ECORE_EVENT_KEY_UP,
CALLBACK_A(Instance::onKeyUpEventCb), this);
+ m_keyDownEventHandler = ecore_event_handler_add(ECORE_EVENT_KEY_DOWN,
+ CALLBACK_A(Instance::onKeyDownEventCb), this);
+
if (!m_keyUpEventHandler) {
LOG_RETURN(RES_FAIL, "m_eventHandler is NULL");
}
void Instance::onPause()
{
- ILOG("PAUSED");
+ DLOG("PAUSE");
+
+ setInstancePaused(*m_win, true);
}
void Instance::onResume()
{
- ILOG("RESUMED");
+ DLOG("RESUME");
+
+ setInstancePaused(*m_win, false);
}
void Instance::onAppControl(app_control_h appControl)
return RES_OK;
}
+ Eina_Bool Instance::onKeyDownEventCb(int type, void *event)
+ {
+ if (!event) {
+ LOG_RETURN_VALUE(RES_FAIL, ECORE_CALLBACK_PASS_ON, "event is NULL");
+ }
+
+ Ecore_Event_Key *ev = static_cast<Ecore_Event_Key *>(event);
+ if (!strcmp(ev->keyname, impl::STR_POWER_KEY)) {
+ DLOG("Key Power [Down]");
+ return processPowerKeyDownEvent();
+ }
+ return ECORE_CALLBACK_PASS_ON;
+ }
+
Eina_Bool Instance::onKeyUpEventCb(int type, void *event)
{
if (!event) {
- LOG_RETURN_VALUE(RES_FAIL, ECORE_CALLBACK_DONE, "event is NULL");
+ LOG_RETURN_VALUE(RES_FAIL, ECORE_CALLBACK_PASS_ON, "event is NULL");
}
Ecore_Event_Key *ev = static_cast<Ecore_Event_Key *>(event);
if (!strcmp(ev->keyname, impl::STR_POWER_KEY)) {
- DLOG("Key power [Up]");
- m_win->callEvent(WIN_POWER_KEY_UP_EVENT, nullptr);
+ DLOG("Key Power [Up]");
+ return processPowerKeyUpEvent();
+ }
+ return ECORE_CALLBACK_PASS_ON;
+ }
+
+ Eina_Bool Instance::processPowerKeyDownEvent()
+ {
+ m_ignorePowerClick = isInstancePaused(*m_win);
+ if (m_ignorePowerClick) {
+ DLOG("Ignored. Instance is in pause state");
+ return ECORE_CALLBACK_PASS_ON;
}
+
+ m_powerKeyHoldTimout = Timeout::create(
+ impl::POWER_KEY_HOLD_TIMEOUT,
+ WEAK_DELEGATE(Instance::onPowerKeyHoldTimeout,
+ asWeak(*this)));
+
return ECORE_CALLBACK_DONE;
}
+ Eina_Bool Instance::processPowerKeyUpEvent()
+ {
+ if (m_ignorePowerClick) {
+ DLOG("Ignored.");
+ return ECORE_CALLBACK_PASS_ON;
+ }
+
+ PowerBtnEventInfo eventInfo;
+ m_win->callEvent(WIN_POWER_KEY_UP_EVENT, &eventInfo);
+
+ return ECORE_CALLBACK_DONE;
+ }
+
+ void Instance::onPowerKeyHoldTimeout(Timeout *sender)
+ {
+ m_ignorePowerClick = true;
+ m_powerKeyHoldTimout.reset();
+ }
+
void Instance::onPageExitRequest(Page &page)
{
m_context->exitApp();
#include "ucl/appfw/SysEventProvider.h"
#include "ucl/gui/Theme.h"
#include "ucl/gui/Naviframe.h"
+#include "ucl/misc/Timeout.h"
#include "call-ui/model/ICallUI.h"
void onSysEvent(const ucl::SysEvent sysEvent);
void onPageExitRequest(Page &page);
+ Eina_Bool onKeyDownEventCb(int type, void *event);
Eina_Bool onKeyUpEventCb(int type, void *event);
+ Eina_Bool processPowerKeyDownEvent();
+ Eina_Bool processPowerKeyUpEvent();
+ void onPowerKeyHoldTimeout(ucl::Timeout *sender);
private:
ucl::SysEventProvider &m_sysEventProvider;
PageWRef m_page;
Ecore_Event_Handler *m_keyUpEventHandler;
+ Ecore_Event_Handler *m_keyDownEventHandler;
+ ucl::TimeoutSRef m_powerKeyHoldTimout;
+
+ bool m_ignorePowerClick;
};
}
#include "call-ui/view/common.h"
namespace callui {
+
constexpr auto CALL_VC_TIMER_INTERVAL = 1.5;
constexpr auto CALL_VC_SCREEN_READER_TIMER_INTERVAL = 5.0;
constexpr auto VOLUME_LEVEL_MIN = 1;
void AccessoryPresenter::onVolumeBtnClicked(Widget &widget, void *eventInfo)
{
if (!isActive()) {
- ILOG("Presenter is not active. Ignore");
+ ILOG("Ignored. Presenter is not active");
return;
}
void AccessoryPresenter::onMuteBtnClicked(Widget &widget, void *eventInfo)
{
if (!isActive()) {
- ILOG("Presenter is not active. Ignore");
+ ILOG("Ignored. Presenter is not active");
return;
}
{
if (!isActive()) {
LOG_RETURN_VALUE(RES_OK, EINA_TRUE,
- "Presenter is not active. Ignore");
+ "Ignored. Presenter is not active");
}
if (m_vcTimer) {
void AccessoryPresenter::onVolumeControlEventCb(VolumeControl::Event event)
{
if (!isActive()) {
- LOG_RETURN_VOID(RES_OK, "Presenter is not active. Ignore");
+ LOG_RETURN_VOID(RES_OK, "Ignored. Presenter is not active");
}
if (!m_vcTimer) {
- DLOG("Ignore as control is hidden");
+ DLOG("Ignored. Control is hidden");
return;
}
void AtspiHighlightHelper::registerWidget(ElmWidget &widget)
{
- DLOG("this [%p] widget [%p]", this, widget.getEo());
-
widget.addEventHandler(ATSPI_ON_GESTURE, WEAK_DELEGATE(
AtspiHighlightHelper::onAtspiGesture, asWeak(*this)));
}
Elm_Interface_Atspi_Accessible *ao,
AtspiGestureEventInfo &e)
{
- DLOG("this [%p] ao [%p]", this, ao);
+ DLOG("Access object [%p]", ao);
if (e.stopPropagation) {
- DLOG("e.stopPropagation");
+ DLOG("Ignored. Propagation was stopped.");
return;
}
if (!isActive()) {
- DLOG("!isActive()");
+ DLOG("Ignored. Presenter is not active");
if (e.gestureInfo.type != ELM_ATSPI_GESTURE_ONE_FINGER_SINGLE_TAP) {
+ DLOG("Prevent default handler");
e.preventDefault = true;
}
return;
e.stopPropagation = true;
if (m_gestureEventHandler) {
- DLOG("m_gestureEventHandler");
if (m_gestureEventHandler(ao, e.gestureInfo.type)) {
+ DLOG("Prevent default handler");
e.preventDefault = true;
return;
}
e.preventDefault = false;
if (!m_relationEventHandler) {
- DLOG("!m_relationEventHandler");
+ DLOG("Relation event handler does not set");
return;
}
const Elm_Atspi_Relation_Type relation = getFlowRelation(e.gestureInfo);
if (relation == ELM_ATSPI_RELATION_NULL) {
+ DLOG("Not supported gesture type for processing");
return;
}
const auto relationObj = m_relationEventHandler(ao, relation);
if (!relationObj) {
+ DLOG("Relation object is NULL!");
return;
}
+ DLOG("Relation object [%p]", relationObj);
auto &win = getWindow();
auto atspiHelper = static_cast<Elm_Interface_Atspi_Accessible *>
sendActivate(*m_widget);
}
+ unregisterPageTransitionCallback();
+
util::dispose(m_keypad);
}
FAIL_RETURN(createAtspiHighlightHelper(), "createAtspiHighlightHelper() failed!");
+ registerPageTransitionCallback();
+
deactivateBy(m_widget.get());
parent.addDeactivatorSource(*m_widget);
return RES_OK;
}
+ void MoreOptionsPresenter::registerPageTransitionCallback()
+ {
+ m_navi->addEventHandler(NAVI_TRANSITION_FINISHED,
+ WEAK_DELEGATE(
+ MoreOptionsPresenter::onPageTransitionFinished,
+ asWeak(*this)));
+ }
+
+ void MoreOptionsPresenter::unregisterPageTransitionCallback()
+ {
+ m_navi->delEventHandler(NAVI_TRANSITION_FINISHED,
+ WEAK_DELEGATE(
+ MoreOptionsPresenter::onPageTransitionFinished,
+ asWeak(*this)));
+ }
+
+ void MoreOptionsPresenter::onPageTransitionFinished(Widget &widget,
+ void *eventInfo)
+ {
+ if (const auto keypad = m_keypad.lock()) {
+ if (keypad->isAtTop()) {
+ elm_panel_hidden_set(*m_panel, EINA_TRUE);
+ }
+ }
+ }
+
void MoreOptionsPresenter::updateSlots()
{
unsetPanelContent(impl::PART_SWL_SLOT1);
const ucl::TString &txt,
const ucl::WidgetEventHandler &handler);
+ void registerPageTransitionCallback();
+ void unregisterPageTransitionCallback();
+ void onPageTransitionFinished(ucl::Widget &widget, void *eventInfo);
+
void updateSlots();
void updateStatusText();
* limitations under the License.
*/
+#include "ucl/gui/Window.h"
+
#include "common.h"
namespace callui { namespace { namespace himpl {
+ constexpr EoDataKey INSTANCE_PTR {"callui,instance,data,ptr"};
+
const TString STR_HH_MM_SS_TIME{"%02d:%02d:%02d"};
const TString STR_MM_SS_TIME{"%02d:%02d"};
using namespace ucl;
+ void setInstancePaused(Window &win, const bool value)
+ {
+ win.setData(himpl::INSTANCE_PTR, reinterpret_cast<void *>(value));
+ win.callEvent((value ? INSTANCE_PAUSED : INSTANCE_RESUMED), nullptr);
+ }
+
+ bool isInstancePaused(const Window &win)
+ {
+ return (reinterpret_cast<intptr_t>(
+ win.getData(himpl::INSTANCE_PTR)) != 0);
+ }
+
void replaceSubstringInString(std::string &str,
const std::string &from, const std::string &to)
{
namespace callui {
+ constexpr ucl::SmartEvent INSTANCE_PAUSED {"callui,instance,paused"};
+ constexpr ucl::SmartEvent INSTANCE_RESUMED {"callui,instance,resumed"};
+
+ void setInstancePaused(ucl::Window &win, bool value);
+ bool isInstancePaused(const ucl::Window &win);
+
void replaceSubstringInString(std::string &str,
const std::string &from, const std::string &to);
#include "KeypadPage.h"
+#include "call-ui/presenters/types.h"
#include "call-ui/resources.h"
#include "common.h"
}}}
namespace callui {
+
using namespace ucl;
// KeypadPage::Builder
KeypadPage::~KeypadPage()
{
stopDtmf();
+
stopVCTimer();
+
+ unregisterPowerKeyHandling();
+
unregisterCallbacks();
+
}
Result KeypadPage::doPrepare(NaviItem &item)
{
- FAIL_RETURN(createWidget(), "createWidget() failed!");
+ FAIL_RETURN(createWidget(),
+ "createWidget() failed!");
+
+ FAIL_RETURN(createEntry(),
+ "createEntry() failed!");
- FAIL_RETURN(createEntry(), "createEntry() failed!");
+ FAIL_RETURN(createButtons(),
+ "createButtons() failed!");
- FAIL_RETURN(createButtons(), "createButtons() failed!");
+ FAIL_RETURN(createVolumeControl(),
+ "createVolumeControl() failed!");
- FAIL_RETURN(createVolumeControl(), "createVolumeControl() failed!");
+ FAIL_RETURN(registerPowerKeyHandling(),
+ "registerPowerKeyHandling() failed!");
registerCallbacks();
return RES_OK;
}
+ Result KeypadPage::registerPowerKeyHandling()
+ {
+ auto win = m_widget->getWindow();
+ if (!win) {
+ LOG_RETURN(RES_FAIL, "win is NULL!");
+ }
+
+ win->addEventHandler(WIN_POWER_KEY_UP_EVENT, WEAK_DELEGATE(
+ KeypadPage::onPowerKeyUp, asWeak(*this)));
+
+ return RES_OK;
+ }
+
+ void KeypadPage::unregisterPowerKeyHandling()
+ {
+ auto win = m_widget->getWindow();
+ if (!win) {
+ LOG_RETURN_VOID(RES_FAIL, "win is NULL!");
+ }
+
+ win->delEventHandler(WIN_POWER_KEY_UP_EVENT, WEAK_DELEGATE(
+ KeypadPage::onPowerKeyUp, asWeak(*this)));
+ }
+
+ void KeypadPage::onPowerKeyUp(Widget &widget, void *eventInfo)
+ {
+ auto info = static_cast<PowerBtnEventInfo *>(eventInfo);
+ if (info) {
+ info->stopPropagation = true;
+ }
+
+ requestExit();
+ }
+
void KeypadPage::onBtnPressed(Widget &widget, void *eventInfo)
{
impl::ButtonInfo *info =
void KeypadPage::onVolumeControlEventCb(VolumeControl::Event event)
{
if (!isActive()) {
- LOG_RETURN_VOID(RES_OK, "Presenter is not active. Ignore");
+ LOG_RETURN_VOID(RES_OK, "Ignored. Presenter is not active");
}
if (!m_vcTimer) {
- DLOG("Ignore as control is hidden");
+ DLOG("Ignored. Control is hidden");
return;
}
if (!isActive()) {
LOG_RETURN_VALUE(RES_OK,
EINA_TRUE,
- "Presenter is not active. Ignore");
+ "Ignored. Presenter is not active");
}
if (!m_vcTimer) {
- DLOG("Ignore as control is hidden");
+ DLOG("Ignore .Control is hidden");
return EINA_FALSE;
}
ucl::Result doPrepare(ucl::NaviItem &item);
+ ucl::Result registerPowerKeyHandling();
+ void unregisterPowerKeyHandling();
+
+ void onPowerKeyUp(ucl::Widget &widget, void *eventInfo);
+
void onBtnPressed(ucl::Widget &widget, void *eventInfo);
void onBtnUnpressed(ucl::Widget &widget, void *eventInfo);
void onBtnClicked(ucl::Widget &widget, void *eventInfo);
VolumeControlSRef m_vc;
Ecore_Timer *m_vcTimer;
-
AudioStateType m_audioState;
// Screen Reader
#include "ucl/gui/Widget.h"
#include "call-ui/resources.h"
+#include "call-ui/presenters/types.h"
+
#include "common.h"
namespace callui { namespace { namespace impl {
using namespace ucl;
- constexpr double CU_RECALL_BTN_SHOW_TIMEOUT = 1.0;
- constexpr double CU_EXIT_APP_TIMEOUT = 4.0;
+ constexpr auto RECALL_BTN_SHOW_TIMEOUT = 1.0;
+ constexpr auto EXIT_APP_TIMEOUT = 4.0;
constexpr LayoutTheme LAYOUT_MAIN_WIDGET
{"layout", "callui", "main"};
}
FAIL_RETURN(createWidget(), "createWidget() failed!");
- FAIL_RETURN(createIndicatorPresenter(), "createIndicatorPresenter() failed!");
- FAIL_RETURN(createDisplayPresenter(), "createDisplayPresenter() failed!");
+ FAIL_RETURN(createIndicatorPresenter(),
+ "createIndicatorPresenter() failed!");
+
+ FAIL_RETURN(createDisplayPresenter(),
+ "createDisplayPresenter() failed!");
+
+ FAIL_RETURN(registerPowerKeyHandling(),
+ "registerPowerKeyHandling() failed!");
+
+ item = getNaviframe().push(*m_widget);
+ if (!item) {
+ LOG_RETURN(RES_FAIL, "Naviframe::push() failed!");
+ }
+
+ return RES_OK;
+ }
+
+ Result MainPage::registerPowerKeyHandling()
+ {
auto win = m_widget->getWindow();
if (!win) {
LOG_RETURN(RES_FAIL, "win is NULL!");
}
+
win->addEventHandler(WIN_POWER_KEY_UP_EVENT, WEAK_DELEGATE(
MainPage::onPowerKeyUp, asWeak(*this)));
- item = getNaviframe().push(*m_widget);
- if (!item) {
- LOG_RETURN(RES_FAIL, "Naviframe::push() failed!");
- }
-
return RES_OK;
}
- void MainPage::processKeyPress()
+ void MainPage::unregisterPowerKeyHandling()
{
- switch (m_mode) {
- case CallMode::INCOMING:
- {
- auto incom = m_cm->getIncomingCall();
- if (!incom) {
- LOG_RETURN_VOID(RES_FAIL, "incom is NULL");
- }
- incom->stopAlert();
- break;
+ auto win = m_widget->getWindow();
+ if (!win) {
+ LOG_RETURN_VOID(RES_FAIL, "win is NULL!");
}
- case CallMode::END:
+
+ win->delEventHandler(WIN_POWER_KEY_UP_EVENT, WEAK_DELEGATE(
+ MainPage::onPowerKeyUp, asWeak(*this)));
+ }
+
+ void MainPage::processKeyPress(bool isPowerKey)
+ {
+ if (m_mode == CallMode::END) {
requestExit();
- break;
- default:
- if (m_accessoryPrs) {
- m_accessoryPrs->hideVolumeControls();
+ } else if (m_mode != CallMode::INCOMING) {
+ if (isPowerKey) {
+ m_devicePrs->setDisplayState(
+ DeviceStatePresenter::DisplayState::OFF);
+ } else {
+ if (m_accessoryPrs) {
+ m_accessoryPrs->hideVolumeControls();
+ }
}
- break;
}
}
void MainPage::onPowerKeyUp(Widget &widget, void *eventInfo)
{
- if (isActive()) {
- processKeyPress();
+ auto info = static_cast<PowerBtnEventInfo *>(eventInfo);
+ if (info && info->stopPropagation) {
+ DLOG("Ignored. Propagation was stopped.");
+ return;
}
+ processKeyPress(true);
}
Result MainPage::processIncomingCallMode()
stopEndCallTimer();
m_ecTimer = ecore_timer_add(
- impl::CU_RECALL_BTN_SHOW_TIMEOUT,
+ impl::RECALL_BTN_SHOW_TIMEOUT,
CALLBACK_B(MainPage::onEndCallTimerCb),
this);
}
m_widget->setContent(*m_bottomBtn, impl::PART_SWL_BOTTOM_BTN);
show(*m_bottomBtn);
}
- ecore_timer_interval_set(m_ecTimer, impl::CU_EXIT_APP_TIMEOUT);
+ ecore_timer_interval_set(m_ecTimer, impl::EXIT_APP_TIMEOUT);
m_ecTimerBtnReq = true;
return ECORE_CALLBACK_RENEW;
} else {
#include "ucl/gui/Layout.h"
#include "call-ui/model/ICallUI.h"
-
#include "call-ui/presenters/misc/IndicatorPresenter.h"
#include "call-ui/presenters/misc/AcceptRejectPresenter.h"
#include "call-ui/presenters/misc/CallInfoPresenter.h"
ucl::Result doPrepare(ucl::NaviItem &item);
+ ucl::Result registerPowerKeyHandling();
+ void unregisterPowerKeyHandling();
+
+ void processKeyPress(bool isPowerKey = false);
+
ucl::Result showWindow();
void updateCallMode();
Eina_Bool onEndCallTimerCb();
void onPowerKeyUp(ucl::Widget &widget, void *eventInfo);
- void processKeyPress();
ucl::Result updateDeviceState(CallMode prevMode, CallMode curMode);
#include "call-ui/view/types.h"
#include "call-ui/model/types.h"
+namespace callui {
+
+ struct PowerBtnEventInfo {
+ bool stopPropagation = false;
+ };
+}
+
#endif // __CALL_UI_PRESENTERS_TYPES_H__
m_isContracting = true;
setAcceptUnpressedState();
} else {
- DLOG("Counter is 0. Ignored");
+ DLOG("Ignored. Counter is 0");
}
m_expandTimeout.reset();
}
m_isContracting = true;
setRejectUnpressedState();
} else {
- DLOG("Counter is 0. Ignored");
+ DLOG("Ignored. Counter is 0");
}
m_expandTimeout.reset();
}
m_expandTimeout.reset();
if (m_isContracting) {
- DLOG("Contracting. Ignore");
+ DLOG("Ignored. Contracting state");
return EINA_TRUE;
}
group { "elm/layout/callui/main";
parts {
+ rect { "bg";
+ scale;
+ desc { "default";
+ min: CU_WIN_W CU_WIN_H;
+ max: CU_WIN_W CU_WIN_H;
+ color: 0 0 0 0;
+ }
+ }
swallow { "swl.call_info";
scale;
desc { "default";
+ rel1.to: "bg";
+ rel2.to: "bg";
}
}
swallow { "swl.indicator";
scale;
desc { "default";
+ rel1.to: "bg";
+ rel2.to: "bg";
}
}
swallow { "swl.rm"
scale;
desc { "default";
+ rel1.to: "bg";
+ rel2.to: "bg";
}
}
swallow { "swl.accept_reject";
scale;
desc { "default";
+ rel1.to: "bg";
+ rel2.to: "bg";
}
}
swallow { "swl.bottom_btn";
scale;
desc { "default";
- rel1.relative: 0.0 1.0;
- rel2.relative: 1.0 1.0;
+ rel1 { relative: 0.0 1.0; to: "bg"; }
+ rel2 { relative: 1.0 1.0; to: "bg"; }
align: 0.5 1.0;
fixed: 0 1;
}
swallow { "swl.overlay";
scale;
desc { "default";
+ rel1.to: "bg";
+ rel2.to: "bg";
}
}
swallow { "swl.more_option";
scale;
desc { "default";
+ rel1.to: "bg";
+ rel2.to: "bg";
}
}
}
projects / profile / wearable / apps / native / call-ui.git / commitdiff