* @brief Gets contact name
* @return Contact name
*/
- virtual const std::string &getName() const = 0;
+ virtual std::string getName() const = 0;
/**
* @brief Gets path to contact image
* @return Contact image path
*/
- virtual const std::string &getImagePath() const = 0;
+ virtual std::string getImagePath() const = 0;
/**
* @brief Gets name source type
* @brief Deletes audio state handler
* @param[in] handler Handler to delete
*/
- virtual void delAudioStateHandler(const NotiHandler &handler) = 0;
+ virtual void delAudioStateHandler(NotiHandler::CDRef handler) = 0;
/**
* @brief Adds mute state handler
* @brief Deletes mute state handler
* @param[in] handler Handler to delete
*/
- virtual void delMuteStateHandler(const NotiHandler &handler) = 0;
+ virtual void delMuteStateHandler(NotiHandler::CDRef handler) = 0;
/**
* @brief Adds volume state handler
* @brief Deletes volume state handler
* @param[in] handler Handler to delete
*/
- virtual void delVolumeStateHandler(const NotiHandler &handler) = 0;
+ virtual void delVolumeStateHandler(NotiHandler::CDRef handler) = 0;
/**
* @brief Gets max volume level
* @param[in] handler Handler to delete
*/
virtual void delBTHeadsetConnectionChangeHandler(
- const NotiHandler &handler) = 0;
+ NotiHandler::CDRef handler) = 0;
protected:
~ISoundManager() = default;
using namespace ucl;
ActiveCall::ActiveCall(CallManagerWRef cm, cm_call_data_h callData):
- m_cm(cm),
- m_isDialing(false)
+ m_cm(std::move(cm)),
+ m_isDialing(false)
{
}
ActiveCallSRef ActiveCall::newInstance(CallManagerWRef cm, cm_call_data_h callData)
{
if (!cm) {
- LOG_RETURN_VALUE(RES_FAIL, {}, "cm is NULL");
+ LOG_RETURN_VALUE(RES_INVALID_ARGUMENTS, {}, "cm is NULL");
}
if (!callData) {
- LOG_RETURN_VALUE(RES_FAIL, {}, "callData is NULL");
+ LOG_RETURN_VALUE(RES_INVALID_ARGUMENTS, {}, "callData is NULL");
}
- auto result = makeShared<ActiveCall>(cm, callData);
+ auto result = makeShared<ActiveCall>(std::move(cm), callData);
FAIL_RETURN_VALUE(result->prepare(callData), {}, "result->prepare() failed!");
return result;
}
ucl::Result prepare(cm_call_data_h callData);
private:
- CallManagerWRef m_cm;
+ const CallManagerWRef m_cm;
+
CallInfoSRef m_callInfo;
bool m_isDialing;
void BatteryStateSource::onBatteryStateChangedCb(keynode_t *node)
{
- if (updateBatteryState() && m_handler) {
- m_handler();
+ if (updateBatteryState()) {
+ if (const auto handler = m_handler.lock()) {
+ handler();
+ }
}
}
return {m_bits.value};
}
- void BatteryStateSource::setStateChangeHandler(const NotiHandler &handler)
+ void BatteryStateSource::setStateChangeHandler(NotiHandler handler)
{
- m_handler = handler;
+ m_handler = std::move(handler);
}
int getBatteryLevel(IndicatorState state)
/**
* @see IIndicatorStateSource::setStateChangeHandler()
*/
- virtual void setStateChangeHandler(
- const NotiHandler &handler) override final;
+ virtual void setStateChangeHandler(NotiHandler handler) override final;
private:
BatteryStateSource();
if (res != BT_ERROR_NONE) {
LOG_RETURN(RES_FAIL, "BT initialize failed! "
"res[%d] msg[%s]", res, get_error_message(res));
-
}
+
m_btInitialized = true;
return RES_OK;
}
return RES_OK;
}
- void BluetoothManager::setVolumeStateHandler(
- const NotiHandler &handler)
+ void BluetoothManager::setVolumeStateHandler(NotiHandler handler)
{
- m_btVolumeHandler = handler;
+ m_btVolumeHandler = std::move(handler);
}
Result BluetoothManager::registerAudioHandling()
void BluetoothManager::onVolumeChanged(int volume)
{
if (impl::isScoOpened() && impl::isCallCurrentSoundType()) {
- if (m_btVolumeHandler) {
- m_btVolumeHandler();
+ if (const auto handler = m_btVolumeHandler.lock()) {
+ handler();
}
}
}
return m_isHeadsetConnected;
}
- void BluetoothManager::setHeadsetConnectionChangeHandler(const NotiHandler &handler)
+ void BluetoothManager::setHeadsetConnectionChangeHandler(
+ NotiHandler handler)
{
- m_btConnectionHandler = handler;
+ m_btConnectionHandler = std::move(handler);
}
bool BluetoothManager::getHeadsetConnectionState() const
if (m_isHeadsetConnected != isConnected) {
DLOG("BT Headset connection state update");
m_isHeadsetConnected = isConnected;
- if (m_btConnectionHandler) {
- m_btConnectionHandler();
+ if (const auto handler = m_btConnectionHandler.lock()) {
+ handler();
}
}
}
* @brief Sets volume state change handler
* @param[in] handler Volume state change handler
*/
- void setVolumeStateHandler(const NotiHandler &handler);
+ void setVolumeStateHandler(NotiHandler handler);
/**
* @brief Checks whether headset device is connected
* @brief Sets handler for monitoring headset connection change
* @return true if headset device is connected, false
*/
- void setHeadsetConnectionChangeHandler(const NotiHandler &handler);
+ void setHeadsetConnectionChangeHandler(NotiHandler handler);
private:
BluetoothManager();
CallInfoSRef CallInfo::newInstance(CallClient &client,
cm_call_data_h callData,
- ContactInfoProviderSRef callInfoProvider)
+ const ContactInfoProviderSRef &contactInfoProvider)
{
- if (!client) {
- LOG_RETURN_VALUE(RES_FAIL, {}, "client is NULL");
- }
-
if (!callData) {
- LOG_RETURN_VALUE(RES_FAIL, {}, "callData is NULL");
+ LOG_RETURN_VALUE(RES_INVALID_ARGUMENTS, {}, "callData is NULL");
}
auto result = makeShared<CallInfo>();
FAIL_RETURN_VALUE(result->prepare(client,
callData,
- callInfoProvider),
+ contactInfoProvider),
{}, "result->prepare() failed!");
return result;
}
Result CallInfo::prepare(CallClient &client,
cm_call_data_h callData,
- ContactInfoProviderSRef callInfoProvider)
+ const ContactInfoProviderSRef &contactInfoProvider)
{
Result res = convertCMResult(
cm_call_data_get_call_id(callData, &m_callId));
cm_call_data_get_person_id(callData, &personId));
FAIL_RETURN(res, "cm_call_data_get_person_id() failed!");
- if (personId >= 0 && callInfoProvider) {
- m_contactInfo = callInfoProvider->createContactInfo(personId);
+ if (personId >= 0 && contactInfoProvider) {
+ m_contactInfo = contactInfoProvider->createContactInfo(personId);
if (!m_contactInfo) {
LOG_RETURN(RES_FAIL, "createContactInfo() failed!");
}
FAIL_RETURN(res, "cm_call_data_get_call_member_count() failed!");
if (m_confMemberCount > 1) {
- res = initConferenceCallInfoList(client, callInfoProvider);
+ res = initConferenceCallInfoList(client, contactInfoProvider);
FAIL_RETURN(res, "initConferenceCallInfoList() failed!");
}
}
Result CallInfo::initConferenceCallInfoList(CallClient &client,
- ContactInfoProviderSRef callInfoProvider)
+ const ContactInfoProviderSRef &contactInfoProvider)
{
// XXX: must be initialized with nullptr. If not an there is no conference calls
// cm_get_conference_callList return CM_ERROR_NONE and pointer will be not changed.
for (; l != nullptr; l = g_slist_next(l)) {
auto confCallInfo = ConferenceCallInfo::newInstance(
static_cast<cm_conf_call_data_t *>(l->data),
- callInfoProvider);
+ contactInfoProvider);
if (!confCallInfo) {
LOG_BREAK(res = RES_OUT_OF_MEMORY, "ConferenceCallInfo::newInstance() failed!");
}
*/
static CallInfoSRef newInstance(CallClient &client,
cm_call_data_h callData,
- ContactInfoProviderSRef callInfoProvider);
+ const ContactInfoProviderSRef &contactInfoProvider);
// ICallInfo //
ucl::Result prepare(CallClient &client,
cm_call_data_h callData,
- ContactInfoProviderSRef callInfoProvider);
+ const ContactInfoProviderSRef &contactInfoProvider);
ucl::Result initConferenceCallInfoList(CallClient &client,
- ContactInfoProviderSRef callInfoProvider);
+ const ContactInfoProviderSRef &contactInfoProvider);
private:
unsigned int m_callId;
using namespace ucl;
CallManager::CallManager(IRefCountObj &rc,
- const CallClientSRef &callClient,
- ICallManagerListenerWRef listener):
- RefCountAware(&rc),
- m_callClient(callClient),
- m_listener(listener),
- m_slot(SimSlot::UNDEFINED),
- m_waitDialing(false),
- m_confTypeCallReq(CALL_FLAG_NONE),
- m_blockCMEvents(false)
+ CallClientSRef callClient,
+ ICallManagerListenerWRef listener):
+ RefCountAware(&rc),
+ m_callClient(std::move(callClient)),
+ m_listener(std::move(listener)),
+ m_slot(SimSlot::UNDEFINED),
+ m_waitDialing(false),
+ m_confTypeCallReq(CALL_FLAG_NONE),
+ m_blockCMEvents(false)
{
}
- CallManagerSRef CallManager::newInstance(const CallClientSRef &callClient,
+ CallManagerSRef CallManager::newInstance(CallClientSRef callClient,
ICallManagerListenerWRef listener)
{
- auto result = makeShared<CallManager>(callClient, listener);
+ if (!callClient) {
+ LOG_RETURN_VALUE(RES_INVALID_ARGUMENTS, {}, "callClient is NULL");
+ }
+
+ auto result = makeShared<CallManager>(std::move(callClient),
+ std::move(listener));
FAIL_RETURN_VALUE(result->prepare(), {}, "result->prepare() failed!");
return result;
}
snprintf(buff, sizeof(buff), "%s", number.c_str());
return convertCMResult(
- cm_dial_call(*m_callClient, buff, CM_CALL_TYPE_VOICE, convertCUISimSlot(m_slot)));
+ cm_dial_call(*m_callClient, buff, CM_CALL_TYPE_VOICE,
+ convertCUISimSlot(m_slot)));
}
Result CallManager::endCall(unsigned int callId, CallReleaseType type)
}
return convertCMResult(
- cm_end_call(*m_callClient, callId, convertCUICallReleaseType(type)));
+ cm_end_call(*m_callClient, callId,
+ convertCUICallReleaseType(type)));
}
- Result CallManager::splitCalls(CallInfoSRef callInfo, const IConferenceCallInfoSCRef &confCallInfo)
+ Result CallManager::splitCalls(CallInfoSRef callInfo,
+ const IConferenceCallInfoSCRef &confCallInfo)
{
if (callInfo->getConferenceMemberCount() <= 1) {
LOG_RETURN(RES_FAIL, "Not conference call");
if (!m_rejectMsgProvider) {
m_rejectMsgProvider = RejectMsgProvider::newInstance();
if (!m_rejectMsgProvider) {
- LOG_RETURN_VALUE(RES_FAIL, {}, "RejectMsgProvider::newInstance() failed!");
+ LOG_RETURN_VALUE(RES_FAIL, {},
+ "RejectMsgProvider::newInstance() failed!");
}
}
return RES_OK;
}
- FAIL_RETURN(updateCall(m_incomingCall, cmIncom), "updateCall() failed!");
- FAIL_RETURN(updateCall(m_activeCall, cmActive), "updateCall() failed!");
- FAIL_RETURN(updateCall(m_heldCall, cmHeld), "updateCall() failed!");
+ FAIL_RETURN(updateCall(m_incomingCall, cmIncom),
+ "updateCall() failed!");
+ FAIL_RETURN(updateCall(m_activeCall, cmActive),
+ "updateCall() failed!");
+ FAIL_RETURN(updateCall(m_heldCall, cmHeld),
+ "updateCall() failed!");
return RES_OK;
}
- void CallManager::callEventCb(cm_call_event_e callEvent, cm_call_event_data_h callEventData)
+ void CallManager::callEventCb(cm_call_event_e callEvent,
+ cm_call_event_data_h callEventData)
{
m_waitDialing = false;
* @return Shared reference to CallManager instance on success
* or NULL otherwise
*/
- static CallManagerSRef newInstance(const CallClientSRef &callClient,
+ static CallManagerSRef newInstance(CallClientSRef callClient,
ICallManagerListenerWRef listener);
/**
virtual IEndCallSRef getEndCall() override final;
private:
- CallManager(ucl::IRefCountObj &rc, const CallClientSRef &callClient,
+ CallManager(ucl::IRefCountObj &rc, CallClientSRef callClient,
ICallManagerListenerWRef listener);
~CallManager() = default;
void dialStatusCb(cm_dial_status_e status);
private:
- CallClientSRef m_callClient;
+ const CallClientSRef m_callClient;
+ const ICallManagerListenerWRef m_listener;
+
RejectMsgProviderSRef m_rejectMsgProvider;
ContactInfoProviderSRef m_contactInfoProvider;
- ICallManagerListenerWRef m_listener;
IncomingCallSRef m_incomingCall;
ActiveCallSRef m_activeCall;
HeldCallSRef m_heldCall;
ConferenceCallInfoSRef ConferenceCallInfo::newInstance(
cm_conf_call_data_t *confCallData,
- ContactInfoProviderSRef callInfoProvider)
+ const ContactInfoProviderSRef &contactInfoProvider)
{
if (!confCallData) {
- LOG_RETURN_VALUE(RES_FAIL, {}, "callData is NULL");
+ LOG_RETURN_VALUE(RES_INVALID_ARGUMENTS, {}, "callData is NULL");
}
auto result = makeShared<ConferenceCallInfo>();
- FAIL_RETURN_VALUE(result->prepare(confCallData, callInfoProvider), {}, "result->prepare() failed!");
+ FAIL_RETURN_VALUE(result->prepare(confCallData, contactInfoProvider),
+ {}, "result->prepare() failed!");
return result;
}
Result ConferenceCallInfo::prepare(
cm_conf_call_data_t *confCallData,
- ContactInfoProviderSRef callInfoProvider)
+ const ContactInfoProviderSRef &contactInfoProvider)
{
Result res = convertCMResult(
cm_conf_call_data_get_call_id(confCallData, &m_callId));
cm_conf_call_data_get_person_id(confCallData, &personId));
FAIL_RETURN(res, "cm_conf_call_data_get_person_id() failed!");
- if (personId >= 0 && callInfoProvider) {
- m_contactInfo = callInfoProvider->createContactInfo(personId);
+ if (personId >= 0 && contactInfoProvider) {
+ m_contactInfo = contactInfoProvider->createContactInfo(personId);
if (!m_contactInfo) {
- LOG_RETURN_VALUE(RES_FAIL, RES_FAIL, "createContactInfo() failed!");
+ LOG_RETURN_VALUE(RES_FAIL, RES_FAIL,
+ "createContactInfo() failed!");
}
}
return RES_OK;
/**
* @brief Creates new instance of ConferenceCallInfo
* @param[in] confCallData Native Call Manager conference call handler
- * @param[in] callInfoProvider Contact info provider
+ * @param[in] contactInfoProvider Contact info provider
* @return Shared reference to ConferenceCallInfo instance on success
* or NULL otherwise
*/
static ConferenceCallInfoSRef newInstance(
cm_conf_call_data_t *confCallData,
- ContactInfoProviderSRef callInfoProvider);
+ const ContactInfoProviderSRef &contactInfoProvider);
// IConferenceCallInfo //
~ConferenceCallInfo() = default;
ucl::Result prepare(cm_conf_call_data_t *confCallData,
- ContactInfoProviderSRef callInfoProvider);
+ const ContactInfoProviderSRef &contactInfoProvider);
private:
unsigned int m_callId;
std::string m_phoneNum;
}
if (needNotify && m_handler) {
- m_handler();
+ if (const auto handler = m_handler.lock()) {
+ handler();
+ }
}
}
void ConnectionStateSource::onPacketStateChangedCb(keynode_t *node)
{
ILOG();
- if (updatePacketDir() && m_handler) {
- m_handler();
+ if (updatePacketDir()) {
+ if (const auto handler = m_handler.lock()) {
+ handler();
+ }
}
}
return {m_bits.value};
}
- void ConnectionStateSource::setStateChangeHandler(const NotiHandler &handler)
+ void ConnectionStateSource::setStateChangeHandler(NotiHandler handler)
{
- m_handler = handler;
+ m_handler = std::move(handler);
}
ConnectionType getConnectionState(IndicatorState state)
/**
* @see IIndicatorStateSource::setStateChangeHandler()
*/
- virtual void setStateChangeHandler(const NotiHandler &handler) override final;
+ virtual void setStateChangeHandler(NotiHandler handler) override final;
private:
ConnectionStateSource();
using namespace ucl;
ContactInfo::ContactInfo(int personId,
- const std::string &name,
- const std::string &imagePath,
+ std::string name,
+ std::string imagePath,
ContactNameSourceType type):
- m_personId(personId),
- m_name(name),
- m_imagePath(imagePath),
- m_nameSource(type)
+ m_personId(personId),
+ m_name(std::move(name)),
+ m_imagePath(std::move(imagePath)),
+ m_nameSource(type)
{
}
ContactInfoSRef ContactInfo::newInstance(int personId,
- const std::string &name,
- const std::string &imagePath,
+ std::string name,
+ std::string imagePath,
ContactNameSourceType type)
{
- return makeShared<ContactInfo>(personId, name, imagePath, type);
+ return makeShared<ContactInfo>(personId,
+ std::move(name),
+ std::move(imagePath),
+ type);
}
- const std::string &ContactInfo::getName() const
+ std::string ContactInfo::getName() const
{
return m_name;
}
- const std::string &ContactInfo::getImagePath() const
+ std::string ContactInfo::getImagePath() const
{
return m_imagePath;
}
* or NULL otherwise
*/
static ContactInfoSRef newInstance(int personId,
- const std::string &name,
- const std::string &imagePath,
+ std::string name,
+ std::string imagePath,
ContactNameSourceType type);
// IContactInfo //
/**
* @see IContactInfo::getName()
*/
- virtual const std::string &getName() const override final;
+ virtual std::string getName() const override final;
/**
* @see IContactInfo::getImagePath()
*/
- virtual const std::string &getImagePath() const override final;
+ virtual std::string getImagePath() const override final;
/**
* @see IContactInfo::getNameSourceType()
private:
ContactInfo(int personId,
- const std::string &name,
- const std::string &imagePath,
+ std::string name,
+ std::string imagePath,
ContactNameSourceType type);
~ContactInfo() = default;
private:
- int m_personId;
- std::string m_name;
- std::string m_imagePath;
- ContactNameSourceType m_nameSource;
+ const int m_personId;
+ const std::string m_name;
+ const std::string m_imagePath;
+ const ContactNameSourceType m_nameSource;
friend class ucl::ReffedObj<ContactInfo>;
};
using namespace ucl;
EndCall::EndCall(CallManagerWRef cm, ICallInfoSCRef callInfo):
- m_cm(cm),
- m_callInfo(callInfo),
+ m_cm(std::move(cm)),
+ m_callInfo(std::move(callInfo)),
m_callbackInProgress(false)
{
}
EndCallSRef EndCall::newInstance(CallManagerWRef cm, ICallInfoSCRef callInfo)
{
if (!cm) {
- LOG_RETURN_VALUE(RES_FAIL, {}, "cm is NULL");
+ LOG_RETURN_VALUE(RES_INVALID_ARGUMENTS, {}, "cm is NULL");
}
if (!callInfo) {
- LOG_RETURN_VALUE(RES_FAIL, {}, "callInfo is NULL");
+ LOG_RETURN_VALUE(RES_INVALID_ARGUMENTS, {}, "callInfo is NULL");
}
- return makeShared<EndCall>(cm, callInfo);
+ return makeShared<EndCall>(std::move(cm), std::move(callInfo));
}
ICallInfoSCRef EndCall::getInfo() const
ucl::Result prepare();
private:
- CallManagerWRef m_cm;
- ICallInfoSCRef m_callInfo;
+ const CallManagerWRef m_cm;
+ const ICallInfoSCRef m_callInfo;
+
bool m_callbackInProgress;
friend class ucl::ReffedObj<EndCall>;
if (m_bits.isEnable != isEnable) {
m_bits.isEnable = isEnable;
- if (m_handler) {
- m_handler();
+ if (const auto handler = m_handler.lock()) {
+ handler();
}
}
}
return {m_bits.value};
}
- void HdVoiceStateSource::setStateChangeHandler(const NotiHandler &handler)
+ void HdVoiceStateSource::setStateChangeHandler(NotiHandler handler)
{
- m_handler = handler;
+ m_handler = std::move(handler);
}
bool getHDVoiceState(IndicatorState state)
/**
* @see IIndicatorStateSource::setStateChangeHandler()
*/
- virtual void setStateChangeHandler(const NotiHandler &handler) override final;
+ virtual void setStateChangeHandler(NotiHandler handler) override final;
private:
HdVoiceStateSource(bool isEnable);
using namespace ucl;
HeldCall::HeldCall(CallManagerWRef cm, cm_call_data_h callData):
- m_cm(cm)
+ m_cm(std::move(cm))
{
}
HeldCallSRef HeldCall::newInstance(CallManagerWRef cm, cm_call_data_h callData)
{
if (!cm) {
- LOG_RETURN_VALUE(RES_FAIL, {}, "cm is NULL");
+ LOG_RETURN_VALUE(RES_INVALID_ARGUMENTS, {}, "cm is NULL");
}
if (!callData) {
- LOG_RETURN_VALUE(RES_FAIL, {}, "callData is NULL");
+ LOG_RETURN_VALUE(RES_INVALID_ARGUMENTS, {}, "callData is NULL");
}
- auto result = makeShared<HeldCall>(cm, callData);
- FAIL_RETURN_VALUE(result->prepare(callData), {}, "result->prepare() failed!");
+ auto result = makeShared<HeldCall>(std::move(cm), callData);
+ FAIL_RETURN_VALUE(result->prepare(callData), {},
+ "result->prepare() failed!");
return result;
}
callData,
cm->getContactInfoProvider());
if (!m_callInfo) {
- LOG_RETURN_VALUE(RES_FAIL, RES_FAIL, "CallInfo::newInstance() failed!");
+ LOG_RETURN_VALUE(RES_FAIL, RES_FAIL,
+ "CallInfo::newInstance() failed!");
}
return RES_OK;
}
ucl::Result prepare(cm_call_data_h callData);
private:
- CallManagerWRef m_cm;
+ const CallManagerWRef m_cm;
+
CallInfoSRef m_callInfo;
friend class ucl::ReffedObj<HeldCall>;
/**
* @brief Sets state change handler
- * @param[in] handler Handler to be set
+ * @param[in] handler Handler to set
*/
- virtual void setStateChangeHandler(const NotiHandler &handler) = 0;
+ virtual void setStateChangeHandler(NotiHandler handler) = 0;
protected:
~IIndicatorStateSource() = default;
using namespace ucl;
IncomingCall::IncomingCall(CallManagerWRef cm, cm_call_data_h callData):
- m_cm(cm)
+ m_cm(std::move(cm))
{
}
- IncomingCallSRef IncomingCall::newInstance(CallManagerWRef cm, cm_call_data_h callData)
+ IncomingCallSRef IncomingCall::newInstance(CallManagerWRef cm,
+ cm_call_data_h callData)
{
if (!cm) {
- LOG_RETURN_VALUE(RES_FAIL, {}, "cm is NULL");
+ LOG_RETURN_VALUE(RES_INVALID_ARGUMENTS, {}, "cm is NULL");
}
if (!callData) {
- LOG_RETURN_VALUE(RES_FAIL, {}, "callData is NULL");
+ LOG_RETURN_VALUE(RES_INVALID_ARGUMENTS, {}, "callData is NULL");
}
- auto result = makeShared<IncomingCall>(cm, callData);
- FAIL_RETURN_VALUE(result->prepare(callData), {}, "result->prepare() failed!");
+ auto result = makeShared<IncomingCall>(std::move(cm), callData);
+ FAIL_RETURN_VALUE(result->prepare(callData), {},
+ "result->prepare() failed!");
return result;
}
callData,
cm->getContactInfoProvider());
if (!m_callInfo) {
- LOG_RETURN_VALUE(RES_FAIL, RES_FAIL, "CallInfo::newInstance() failed!");
+ LOG_RETURN_VALUE(RES_FAIL, RES_FAIL,
+ "CallInfo::newInstance() failed!");
}
return RES_OK;
if (!cm) {
LOG_RETURN(RES_FAIL, "Call Manager is NULL");
}
- return convertCMResult(cm_answer_call(cm->getCallClient(), convertCUICallAnswerType(type)));
+ return convertCMResult(cm_answer_call(cm->getCallClient(),
+ convertCUICallAnswerType(type)));
}
Result IncomingCall::reject()
ucl::Result prepare(cm_call_data_h callData);
private:
- CallManagerWRef m_cm;
+ const CallManagerWRef m_cm;
+
CallInfoSRef m_callInfo;
friend class ucl::ReffedObj<IncomingCall>;
using namespace ucl;
- class IndicatorStateProvider::SourceHandler :
+ class IndicatorStateProvider::SourceHandler final :
public RefCountAware {
public:
SourceHandler(IRefCountObj &rc,
m_source(source)
{
m_source->setStateChangeHandler(
- WEAK_DELEGATE(SourceHandler::onStateChanged,
- asWeak(*this)));
+ WEAK_DELEGATE_THIS(onStateChanged));
}
IndicatorState getState() const
* @brief Implementation of IIndicatorStateProvider interface
* @see IIncomingCall
*/
- class IndicatorStateProvider final: public IIndicatorStateProvider {
+ class IndicatorStateProvider final : public IIndicatorStateProvider {
public:
/**
using namespace ucl;
- RejectMsg::RejectMsg(MsgClientWRef client, const TString &string):
- m_msgClient(client),
- m_msg(string)
+ RejectMsg::RejectMsg(MsgClientWRef client, TString string):
+ m_msgClient(std::move(client)),
+ m_msg(std::move(string))
{
}
- RejectMsgSRef RejectMsg::newInstance(MsgClientWRef client, const TString &string)
+ RejectMsgSRef RejectMsg::newInstance(MsgClientWRef client, TString string)
{
- return makeShared<RejectMsg>(client, string);
+ if (!client) {
+ LOG_RETURN_VALUE(RES_INVALID_ARGUMENTS, {}, "client is NULL");
+ }
+
+ return makeShared<RejectMsg>(std::move(client), std::move(string));
}
std::string RejectMsg::getText() const
msg_set_bool_value(sendOpt, MSG_SEND_OPT_SETTING_BOOL, false);
// Set message body
- if (msg_set_str_value(msgInfo, MSG_MESSAGE_SMS_DATA_STR, msgText, strlen(msgText)) != MSG_SUCCESS) {
+ if (msg_set_str_value(msgInfo,
+ MSG_MESSAGE_SMS_DATA_STR,
+ msgText,
+ strlen(msgText)) != MSG_SUCCESS) {
ELOG("msg_set_str_value() failed!");
} else {
// Create address list
msg_struct_list_s *addrList = nullptr;
- msg_get_list_handle(msgInfo, MSG_MESSAGE_ADDR_LIST_STRUCT, (void **)&addrList);
+ msg_get_list_handle(msgInfo,
+ MSG_MESSAGE_ADDR_LIST_STRUCT,
+ (void **)&addrList);
msg_struct_t addrInfo = addrList->msg_struct_info[0];
const char *number = phoneNumber.c_str();
// Set message address
- msg_set_int_value(addrInfo, MSG_ADDRESS_INFO_RECIPIENT_TYPE_INT, MSG_RECIPIENTS_TYPE_TO);
- msg_set_str_value(addrInfo, MSG_ADDRESS_INFO_ADDRESS_VALUE_STR, number, strlen(number));
+ msg_set_int_value(addrInfo,
+ MSG_ADDRESS_INFO_RECIPIENT_TYPE_INT,
+ MSG_RECIPIENTS_TYPE_TO);
+ msg_set_str_value(addrInfo,
+ MSG_ADDRESS_INFO_ADDRESS_VALUE_STR,
+ number,
+ strlen(number));
addrList->nCount = 1;
// Set message struct to Request
* @brief Implementation of IRejectMsg interface
* @see IRejectMsg
*/
- class RejectMsg : public IRejectMsg {
+ class RejectMsg final : public IRejectMsg {
public:
/**
* or NULL otherwise
*/
static RejectMsgSRef newInstance(MsgClientWRef client,
- const ucl::TString &string);
+ ucl::TString string);
/**
* @brief Sends reject message
std::string getText() const override final;
private:
- RejectMsg(MsgClientWRef client, const ucl::TString &string);
+ RejectMsg(MsgClientWRef client, ucl::TString string);
~RejectMsg() = default;
ucl::Result prepare();
private:
- MsgClientWRef m_msgClient;
- ucl::TString m_msg;
+ const MsgClientWRef m_msgClient;
+ const ucl::TString m_msg;
friend class ucl::ReffedObj<RejectMsg>;
};
* @brief Implementation of IRejectMsgProvider interface
* @see IRejectMsgProvider
*/
- class RejectMsgProvider : public IRejectMsgProvider {
+ class RejectMsgProvider final : public IRejectMsgProvider {
public:
/**
}
if (needNotify && m_handler) {
- m_handler();
+ if (const auto handler = m_handler.lock()) {
+ handler();
+ }
}
}
return {m_bits.value};
}
- void RssiStateSource::setStateChangeHandler(const NotiHandler &handler)
+ void RssiStateSource::setStateChangeHandler(NotiHandler handler)
{
- m_handler = handler;
+ m_handler = std::move(handler);
}
RssiState getRssiState(IndicatorState state)
/**
* @see IIndicatorStateSource::setStateChangeHandler()
*/
- virtual void setStateChangeHandler(const NotiHandler &handler) override final;
+ virtual void setStateChangeHandler(NotiHandler handler) override final;
private:
RssiStateSource();
needUpdate = true;
}
- if (needUpdate && m_handler) {
- m_handler();
+ if (needUpdate) {
+ if (const auto handler = m_handler.lock()) {
+ handler();
+ }
}
}
return {m_bits.value};
}
- void SimSlotStateSource::setStateChangeHandler(const NotiHandler &handler)
+ void SimSlotStateSource::setStateChangeHandler(NotiHandler handler)
{
- m_handler = handler;
+ m_handler = std::move(handler);
}
SimSlot getSimSlotType(IndicatorState state)
/**
* @see IIndicatorStateSource::setStateChangeHandler()
*/
- virtual void setStateChangeHandler(
- const NotiHandler &handler) override final;
+ virtual void setStateChangeHandler(NotiHandler handler) override final;
private:
SimSlotStateSource(SimSlot slot, bool isForwarded);
using namespace ucl;
- SoundManager::SoundManager(IRefCountObj &rc, const CallClientSRef &client):
- RefCountAware(&rc),
- m_client(client),
- m_deviceVolumeCbId(-1)
+ SoundManager::SoundManager(IRefCountObj &rc, CallClientSRef client):
+ RefCountAware(&rc),
+ m_client(std::move(client)),
+ m_deviceVolumeCbId(-1)
{
}
cm_unset_mute_status_cb(*m_client);
}
- SoundManagerSRef SoundManager::newInstance(const CallClientSRef &client)
+ SoundManagerSRef SoundManager::newInstance(CallClientSRef client)
{
- auto result = makeShared<SoundManager>(client);
+ if (!client) {
+ LOG_RETURN_VALUE(RES_INVALID_ARGUMENTS, {}, "client is NULL");
+ }
+
+ auto result = makeShared<SoundManager>(std::move(client));
FAIL_RETURN_VALUE(result->prepare(), {}, "result->prepare() failed!");
return result;
}
if (isBTSupported()) {
m_btManager->setVolumeStateHandler(
- WEAK_DELEGATE(SoundManager::onBTHeadsetVolumeChanged,
- asWeak(*this)));
+ WEAK_DELEGATE_THIS(onBTHeadsetVolumeChanged));
m_btManager->setHeadsetConnectionChangeHandler(
- WEAK_DELEGATE(SoundManager::onHeadsetConnectionChanged,
- asWeak(*this)));
+ WEAK_DELEGATE_THIS(onHeadsetConnectionChanged));
}
return RES_OK;
m_audioStateEvent += std::move(handler);
}
- void SoundManager::delAudioStateHandler(const NotiHandler &handler)
+ void SoundManager::delAudioStateHandler(NotiHandler::CDRef handler)
{
m_audioStateEvent -= handler;
}
m_muteStateEvent += std::move(handler);
}
- void SoundManager::delMuteStateHandler(const NotiHandler &handler)
+ void SoundManager::delMuteStateHandler(NotiHandler::CDRef handler)
{
m_muteStateEvent -= handler;
}
m_volumeLevelEvent += std::move(handler);
}
- void SoundManager::delVolumeStateHandler(const NotiHandler &handler)
+ void SoundManager::delVolumeStateHandler(NotiHandler::CDRef handler)
{
m_volumeLevelEvent -= handler;
}
}
void SoundManager::delBTHeadsetConnectionChangeHandler(
- const NotiHandler &handler)
+ NotiHandler::CDRef handler)
{
m_btVoiceDeviceConnEvent -= handler;
}
* @return Shared reference to SoundManager on success
* or NULL otherwise
*/
- static SoundManagerSRef newInstance(const CallClientSRef &client);
+ static SoundManagerSRef newInstance(CallClientSRef client);
// ISoundManager //
* @see ISoundManager::delAudioStateHandler()
*/
virtual void delAudioStateHandler(
- const NotiHandler &handler) override final;
+ NotiHandler::CDRef handler) override final;
/**
* @see ISoundManager::addMuteStateHandler()
* @see ISoundManager::delMuteStateHandler()
*/
virtual void delMuteStateHandler(
- const NotiHandler &handler) override final;
+ NotiHandler::CDRef handler) override final;
/**
* @see ISoundManager::addVolumeStateHandler()
* @see ISoundManager::delVolumeStateHandler()
*/
virtual void delVolumeStateHandler(
- const NotiHandler &handler) override final;
+ NotiHandler::CDRef handler) override final;
/**
* @see ISoundManager::getMaxVolume()
* @see ISoundManager::delBTHeadsetConnectionChangeHandler()
*/
virtual void delBTHeadsetConnectionChangeHandler(
- const NotiHandler &handler) override final;
+ NotiHandler::CDRef handler) override final;
private:
- SoundManager(ucl::IRefCountObj &rc, const CallClientSRef &client);
+ SoundManager(ucl::IRefCountObj &rc, CallClientSRef client);
~SoundManager();
ucl::Result prepare();
void onGearVolumeChanged(sound_type_e type, unsigned int volume);
private:
- CallClientSRef m_client;
+ const CallClientSRef m_client;
+
BluetoothManagerSRef m_btManager;
ucl::Event<NotiHandler> m_audioStateEvent;
ucl::Event<NotiHandler> m_muteStateEvent;
FAIL_RETURN(utils::createCircleSurface(*m_navi),
"createCircleSurface() failed!");
- m_sysEventProvider.addEventHandler(
- WEAK_DELEGATE(Instance::onSysEvent, asWeak(*this)));
+ m_sysEventProvider.addEventHandler(WEAK_DELEGATE_THIS(onSysEvent));
return RES_OK;
}
auto page = MainPage::Builder().
setNaviframe(m_navi).
setCallUI(m_call).
- build(WEAK_DELEGATE(Instance::onPageExitRequest,
- asWeak(*this)));
+ build(WEAK_DELEGATE_THIS(onPageExitRequest));
if (!page) {
ELOG("Create page failed! Exit application");
m_context->exitApp();
m_powerKeyHoldTimout = Timeout::create(
impl::POWER_KEY_HOLD_TIMEOUT,
- WEAK_DELEGATE(Instance::onPowerKeyHoldTimeout,
- asWeak(*this)));
+ WEAK_DELEGATE_THIS(onPowerKeyHoldTimeout));
return ECORE_CALLBACK_DONE;
}
}
m_navi->addEventHandler(NAVI_TRANSITION_STARTED,
- WEAK_DELEGATE(Page::onTransitionStarted, asWeak(*this)));
+ WEAK_DELEGATE_THIS(onTransitionStarted));
m_navi->addEventHandler(NAVI_TRANSITION_FINISHED,
- WEAK_DELEGATE(Page::onTransitionFinished, asWeak(*this)));
+ WEAK_DELEGATE_THIS(onTransitionFinished));
m_navi->addEventHandler(impl::TOP_PAGE_CHANGED,
- WEAK_DELEGATE(Page::onTopPageChanged, asWeak(*this)));
+ WEAK_DELEGATE_THIS(onTopPageChanged));
eext_object_event_callback_add(content, EEXT_CALLBACK_BACK,
CALLBACK_A(Page::onHWBackKey), this);
void Page::requestExit()
{
- if (m_onExitRequest) {
- m_onExitRequest(*this);
+ if (const auto handler = m_onExitRequest.lock()) {
+ handler(*this);
} else {
WLOG("m_onExitRequest is NULL");
exit();
AcceptDialog::AcceptDialog(IRefCountObj &rc,
const EventHandler &handler):
- GuiPresenter(rc),
- m_handler(handler),
- m_isDismissed(false)
+ GuiPresenter(rc),
+ m_handler(handler),
+ m_isDismissed(false)
{
}
m_popup->setWeight(EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
show(*m_popup);
- m_popup->addEventHandler(impl::POPUP_DISMISSED, WEAK_DELEGATE(
- AcceptDialog::onPopupDismissed, asWeak(*this)));
+ m_popup->addEventHandler(impl::POPUP_DISMISSED,
+ WEAK_DELEGATE_THIS(onPopupDismissed));
eext_object_event_callback_add(*m_popup, EEXT_CALLBACK_BACK,
CALLBACK_A(AcceptDialog::onPopupHWBackKey), this);
void AcceptDialog::setLanguageChangeCallback()
{
- getWindow().addEventHandler(WIN_LANGUAGE_CHANGED, WEAK_DELEGATE(
- AcceptDialog::onLanguageChanged, asWeak(*this)));
+ getWindow().addEventHandler(WIN_LANGUAGE_CHANGED,
+ WEAK_DELEGATE_THIS(onLanguageChanged));
}
void AcceptDialog::unsetLanguageChangeCallback()
{
- getWindow().delEventHandler(WIN_LANGUAGE_CHANGED, WEAK_DELEGATE(
- AcceptDialog::onLanguageChanged, asWeak(*this)));
+ getWindow().delEventHandler(WIN_LANGUAGE_CHANGED,
+ DELEGATE_THIS(onLanguageChanged));
}
void AcceptDialog::onLanguageChanged(Widget &widget, void *eventInfo)
bool AcceptDialog::dispatchEvent(Event event)
{
- if (!m_handler) {
- WLOG("Handler was destroyed!");
- return true;
+ if (const auto handler = m_handler.lock()) {
+ return handler(*this, event);
}
- return m_handler(*this, event);
+ WLOG("Handler was destroyed!");
+ return true;
}
void AcceptDialog::onPopupDismissed(ucl::Widget &widget, void *eventInfo)
void onGenlistItemClickedCb(Evas_Object *obj, void *eventInfo);
private:
+ const EventHandler m_handler;
ucl::StyledWidgetSRef m_popup;
ucl::StyledWidgetSRef m_genlist;
- EventHandler m_handler;
AcceptDialogSRef m_selfRef;
bool m_isDismissed;
}
AcceptRejectPresenter::Builder &
- AcceptRejectPresenter::Builder::setIncomingCall(
- const IIncomingCallSRef &call)
+ AcceptRejectPresenter::Builder::setIncomingCall(IIncomingCallSRef call)
{
- m_call = call;
+ m_call = std::move(call);
return *this;
}
}
AcceptRejectPresenter::Builder &
- AcceptRejectPresenter::Builder::setSoundManager(
- const ISoundManagerSRef &sm)
+ AcceptRejectPresenter::Builder::setSoundManager(ISoundManagerSRef sm)
{
- m_sm = sm;
+ m_sm = std::move(sm);
return *this;
}
AcceptRejectPresenter::Builder &
- AcceptRejectPresenter::Builder::setParentWidget(
- const ElmWidgetSRef &parentWidget)
+ AcceptRejectPresenter::Builder::setParentWidget(ElmWidgetSRef parentWidget)
{
- m_parentWidget = parentWidget;
+ m_parentWidget = std::move(parentWidget);
return *this;
}
// AcceptRejectPresenter //
AcceptRejectPresenter::AcceptRejectPresenter(IRefCountObj &rc,
- const IIncomingCallSRef &call,
+ IIncomingCallSRef call,
CallMask calls,
- const ISoundManagerSRef &sm):
- GuiPresenter(rc),
- m_call(call),
- m_callMask(calls),
- m_sm(sm)
+ ISoundManagerSRef sm):
+ GuiPresenter(rc),
+ m_call(std::move(call)),
+ m_sm(std::move(sm)),
+ m_callMask(calls)
{
}
}
m_sm->delBTHeadsetConnectionChangeHandler(
- WEAK_DELEGATE(AcceptRejectPresenter::
- onBTHeadsetConnectionChanged,
- asWeak(*this)));
+ DELEGATE_THIS(onBTHeadsetConnectionChanged));
}
Result AcceptRejectPresenter::prepare(GuiPresenter &parent,
"Presenter::prepare() failed!");
m_sm->addBTHeadsetConnectionChangeHandler(
- WEAK_DELEGATE(AcceptRejectPresenter::
- onBTHeadsetConnectionChanged,
- asWeak(*this)));
+ WEAK_DELEGATE_THIS(onBTHeadsetConnectionChanged));
FAIL_RETURN(createWidget(parentWidget),
"createWidget() failed!");
Result AcceptRejectPresenter::createWidget(ElmWidget &parent)
{
m_widget = AcceptRejectWidget::Builder().
- setAcceptEventHandler(WEAK_DELEGATE(
- AcceptRejectPresenter::onAcceptEvent,
- asWeak(*this))).
- setRejectEventHandler(WEAK_DELEGATE(
- AcceptRejectPresenter::onRejectEvent,
- asWeak(*this))).
+ setAcceptEventHandler(WEAK_DELEGATE_THIS(onAcceptEvent)).
+ setRejectEventHandler(WEAK_DELEGATE_THIS(onRejectEvent)).
setAcceptBtnType(m_sm->isBTHeadsetConnected() ?
AcceptButtonType::BT_HEADSET :
AcceptButtonType::SIMPLE).
Result AcceptRejectPresenter::createMotionSensorPresenter()
{
m_motionPrs = MotionSensorPresenter::Builder().
- build(WEAK_DELEGATE(AcceptRejectPresenter::onMotionEvent,
- asWeak(*this)));
+ build(WEAK_DELEGATE_THIS(onMotionEvent));
if (!m_motionPrs) {
LOG_RETURN(RES_FAIL,
{
if (!m_popup) {
m_popup = AcceptDialog::Builder().
- setHandler(WEAK_DELEGATE(
- AcceptRejectPresenter::onAcceptPopupEvent,
- asWeak(*this))).
+ setHandler(WEAK_DELEGATE_THIS(onAcceptPopupEvent)).
build(*m_widget);
} else {
WLOG("Popup already shown!");
* @param[in] call Incoming Call instance
* @return Reference to builder
*/
- Builder &setIncomingCall(const IIncomingCallSRef &call);
+ Builder &setIncomingCall(IIncomingCallSRef call);
/**
* @brief Sets Sound Manager instance
* @param[in] sm Sound Manager instance
* @return Reference to builder
*/
- Builder &setSoundManager(const ISoundManagerSRef &sm);
+ Builder &setSoundManager(ISoundManagerSRef sm);
/**
* @brief Sets available calls flag
* @param[in] parentWidget Parent widget
* @return Reference to builder
*/
- Builder &setParentWidget(const ucl::ElmWidgetSRef &parentWidget);
+ Builder &setParentWidget(ucl::ElmWidgetSRef parentWidget);
/**
* @brief Creates new instance of AcceptRejectPresenter
private:
AcceptRejectPresenter(ucl::IRefCountObj &rc,
- const IIncomingCallSRef &call,
+ IIncomingCallSRef call,
CallMask calls,
- const ISoundManagerSRef &sm);
+ ISoundManagerSRef sm);
~AcceptRejectPresenter();
ucl::Result prepare(ucl::GuiPresenter &parent,
virtual void onDeactivate() final override;
private:
+ const IIncomingCallSRef m_call;
+ const ISoundManagerSRef m_sm;
AcceptRejectWidgetSRef m_widget;
AcceptDialogWRef m_popup;
MotionSensorPresenterSRef m_motionPrs;
-
- IIncomingCallSRef m_call;
CallMask m_callMask;
- ISoundManagerSRef m_sm;
friend class ucl::ReffedObj<AcceptRejectPresenter>;
};
}
AccessoryPresenter::Builder &
- AccessoryPresenter::Builder::setSoundManager(const ISoundManagerSRef &sm)
+ AccessoryPresenter::Builder::setSoundManager(ISoundManagerSRef sm)
{
- m_sm = sm;
+ m_sm = std::move(sm);
return *this;
}
AccessoryPresenter::Builder &
- AccessoryPresenter::Builder::setCallManager(const ICallManagerSRef &cm)
+ AccessoryPresenter::Builder::setCallManager(ICallManagerSRef cm)
{
- m_cm = cm;
+ m_cm = std::move(cm);
return *this;
}
AccessoryPresenter::Builder &
- AccessoryPresenter::Builder::setRequestExitHandler(const NotiHandler &handler)
+ AccessoryPresenter::Builder::setRequestExitHandler(NotiHandler handler)
{
- m_exitHandler = handler;
+ m_exitHandler = std::move(handler);
return *this;
}
AccessoryPresenter::Builder &
- AccessoryPresenter::Builder::setParentWidget(
- const ElmWidgetSRef &parentWidget)
+ AccessoryPresenter::Builder::setParentWidget(ElmWidgetSRef parentWidget)
{
- m_parentWidget = parentWidget;
+ m_parentWidget = std::move(parentWidget);
return *this;
}
}
AccessoryPresenter::AccessoryPresenter(IRefCountObj &rc,
- const ISoundManagerSRef &sm,
- const NotiHandler &handler):
- GuiPresenter(rc),
- m_sm(sm),
- m_vcTimer(nullptr),
- m_audioState(m_sm->getAudioState()),
- m_mode(CallMode::UNDEFINED),
- m_exitHandler(handler),
- m_isVcShowOnRotaryEvent(false)
+ ISoundManagerSRef sm,
+ NotiHandler handler):
+ GuiPresenter(rc),
+ m_sm(std::move(sm)),
+ m_exitHandler(std::move(handler)),
+ m_vcTimer(nullptr),
+ m_audioState(m_sm->getAudioState()),
+ m_mode(CallMode::UNDEFINED),
+ m_isVcShowOnRotaryEvent(false)
{
}
m_vc = VolumeControl::Builder().
setInfoText(STR_VOLUME).
setMaxValue(m_sm->getMaxVolume()).
- setEventHandler(WEAK_DELEGATE(
- AccessoryPresenter::onVolumeControlEventCb,
- asWeak(*this))).
+ setEventHandler(WEAK_DELEGATE_THIS(onVolumeControlEventCb)).
build(*m_widget);
if (!m_vc) {
LOG_RETURN(RES_FAIL, "VolumeControl::build() failed");
m_volumeBtn = makeShared<StyledWidget>(eo);
m_volumeBtn->setStyle(impl::STYLE_BTN_VOLUME);
m_volumeBtn->addEventHandler(BTN_CLICKED,
- WEAK_DELEGATE(AccessoryPresenter::onVolumeBtnClicked,
- asWeak(*this)));
+ WEAK_DELEGATE_THIS(onVolumeBtnClicked));
show(*m_volumeBtn);
// Screen Reader
m_muteBtn = makeShared<StyledWidget>(eo);
m_muteBtn->setStyle(impl::STYLE_BTN_MUTE);
m_muteBtn->addEventHandler(BTN_CLICKED,
- WEAK_DELEGATE(AccessoryPresenter::onMuteBtnClicked,
- asWeak(*this)));
+ WEAK_DELEGATE_THIS(onMuteBtnClicked));
show(*m_muteBtn);
m_bluetoothBtn = makeShared<StyledWidget>(eo);
m_bluetoothBtn->setStyle(impl::STYLE_BTN_BT);
m_bluetoothBtn->addEventHandler(BTN_CLICKED,
- WEAK_DELEGATE(AccessoryPresenter::onBluetoothBtnClicked,
- asWeak(*this)));
+ WEAK_DELEGATE_THIS(onBluetoothBtnClicked));
show(*m_bluetoothBtn);
m_addContactBtn = makeShared<StyledWidget>(eo);
m_addContactBtn->setStyle(impl::STYLE_BTN_ADD_CONTACT);
m_addContactBtn->addEventHandler(BTN_CLICKED,
- WEAK_DELEGATE(AccessoryPresenter::onAddContactBtnClicked,
- asWeak(*this)));
+ WEAK_DELEGATE_THIS(onAddContactBtnClicked));
show(*m_addContactBtn);
// Screen Reader
RESLOG(res, "launchAddContact() failed");
}
- if (m_exitHandler) {
- m_exitHandler();
+ if (const auto handler = m_exitHandler.lock()) {
+ handler();
}
}
void AccessoryPresenter::registerCallbacks()
{
- addRotaryEventHandler(CALLBACK_A(
- AccessoryPresenter::onRotaryEvent), this);
-
- m_sm->addAudioStateHandler(WEAK_DELEGATE(
- AccessoryPresenter::onAudioStateChanged, asWeak(*this)));
-
- m_sm->addVolumeStateHandler(WEAK_DELEGATE(
- AccessoryPresenter::onVolumeLevelChanged, asWeak(*this)));
+ addRotaryEventHandler(
+ CALLBACK_A(AccessoryPresenter::onRotaryEvent), this);
- m_sm->addMuteStateHandler(WEAK_DELEGATE(
- AccessoryPresenter::onMuteStateChanged, asWeak(*this)));
+ m_sm->addAudioStateHandler(WEAK_DELEGATE_THIS(onAudioStateChanged));
+ m_sm->addVolumeStateHandler(WEAK_DELEGATE_THIS(onVolumeLevelChanged));
+ m_sm->addMuteStateHandler(WEAK_DELEGATE_THIS(onMuteStateChanged));
}
void AccessoryPresenter::unregisterCallbacks()
delRotaryEventHandler(
CALLBACK_A(AccessoryPresenter::onRotaryEvent), this);
- m_sm->delAudioStateHandler(WEAK_DELEGATE(
- AccessoryPresenter::onAudioStateChanged, asWeak(*this)));
-
- m_sm->delVolumeStateHandler(WEAK_DELEGATE(
- AccessoryPresenter::onVolumeLevelChanged, asWeak(*this)));
-
- m_sm->delMuteStateHandler(WEAK_DELEGATE(
- AccessoryPresenter::onMuteStateChanged, asWeak(*this)));
+ m_sm->delAudioStateHandler(DELEGATE_THIS(onAudioStateChanged));
+ m_sm->delVolumeStateHandler(DELEGATE_THIS(onVolumeLevelChanged));
+ m_sm->delMuteStateHandler(DELEGATE_THIS(onMuteStateChanged));
}
Eina_Bool AccessoryPresenter::onVCTimerCb()
auto decrBtn = m_vc->getDecreaseBtn();
if (decrBtn) {
decrBtn->addEventHandler(ATSPI_HIGHLIGHTED,
- WEAK_DELEGATE(AccessoryPresenter::
- onVolumeControlScreenReaderReadStart,
- asWeak(*this)));
+ WEAK_DELEGATE_THIS(onVolumeControlScreenReaderReadStart));
}
auto incrBtn = m_vc->getIncreaseBtn();
if (incrBtn) {
incrBtn->addEventHandler(ATSPI_HIGHLIGHTED,
- WEAK_DELEGATE(AccessoryPresenter::
- onVolumeControlScreenReaderReadStart,
- asWeak(*this)));
+ WEAK_DELEGATE_THIS(onVolumeControlScreenReaderReadStart));
}
}
* @param[in] sm Sound Manager instance
* @return Reference to builder
*/
- Builder &setSoundManager(const ISoundManagerSRef &sm);
+ Builder &setSoundManager(ISoundManagerSRef sm);
/**
* @brief Sets Call Manager instance
* @param[in] cm Call Manager instance
* @return Reference to builder
*/
- Builder &setCallManager(const ICallManagerSRef &cm);
+ Builder &setCallManager(ICallManagerSRef cm);
/**
* @brief Sets request exit application handler
* @param[in] handler Event Request exit handler
* @return Reference to builder
*/
- Builder &setRequestExitHandler(const NotiHandler &handler);
+ Builder &setRequestExitHandler(NotiHandler handler);
/**
* @brief Sets parent widget for UI components creation
* @param[in] parentWidget Parent widget
* @return Reference to builder
*/
- Builder &setParentWidget(const ucl::ElmWidgetSRef &parentWidget);
+ Builder &setParentWidget(ucl::ElmWidgetSRef parentWidget);
/**
* @brief Creates new instance of AccessoryPresenter
ucl::ElmWidget *getVolumeControlValueTxtAo();
private:
- AccessoryPresenter(ucl::IRefCountObj &rc, const ISoundManagerSRef &sm,
- const NotiHandler &handler);
+ AccessoryPresenter(ucl::IRefCountObj &rc,
+ ISoundManagerSRef sm,
+ NotiHandler handler);
~AccessoryPresenter();
ucl::Result prepare(ucl::GuiPresenter &parent,
void onVolumeControlScreenReaderReadStart(ucl::Widget &widget, void *eventInfo);
private:
+ const ISoundManagerSRef m_sm;
+ const NotiHandler m_exitHandler;
ucl::LayoutSRef m_widget;
ucl::StyledWidgetSRef m_volumeBtn;
ucl::StyledWidgetSRef m_muteBtn;
SliderSRef m_slider;
VolumeControlSRef m_vc;
- ISoundManagerSRef m_sm;
Ecore_Timer *m_vcTimer;
AudioStateType m_audioState;
CallMode m_mode;
std::string m_unsavedPhoneNumber;
- NotiHandler m_exitHandler;
bool m_isVcShowOnRotaryEvent;
void AtspiHighlightHelper::registerWidget(ElmWidget &widget)
{
- widget.addEventHandler(ATSPI_ON_GESTURE, WEAK_DELEGATE(
- AtspiHighlightHelper::onAtspiGesture, asWeak(*this)));
+ widget.addEventHandler(ATSPI_ON_GESTURE,
+ WEAK_DELEGATE_THIS(onAtspiGesture));
}
void AtspiHighlightHelper::handleAtspiGesture(
e.stopPropagation = true;
- if (m_gestureEventHandler) {
- if (m_gestureEventHandler(ao, e.gestureInfo.type)) {
+ if (const auto handler = m_gestureEventHandler.lock()) {
+ if (handler(ao, e.gestureInfo.type)) {
DLOG("Prevent default handler");
e.preventDefault = true;
return;
return;
}
- const auto relationObj = m_relationEventHandler(ao, relation);
+ Elm_Interface_Atspi_Accessible *relationObj = nullptr;
+ if (const auto handler = m_relationEventHandler.lock()) {
+ relationObj = handler(ao, relation);
+ }
if (!relationObj) {
DLOG("Relation object is NULL!");
return;
}
CallInfoPresenter::Builder &
- CallInfoPresenter::Builder::setCallManager(const ICallManagerSRef &cm)
+ CallInfoPresenter::Builder::setCallManager(ICallManagerSRef cm)
{
- m_cm = cm;
+ m_cm = std::move(cm);
return *this;
}
CallInfoPresenter::Builder &
- CallInfoPresenter::Builder::setParentWidget(
- const ucl::ElmWidgetSRef &parentWidget)
+ CallInfoPresenter::Builder::setParentWidget(ucl::ElmWidgetSRef parentWidget)
{
- m_parentWidget = parentWidget;
+ m_parentWidget = std::move(parentWidget);
return *this;
}
CallInfoPresenter::Builder::build(GuiPresenter &parent) const
{
if (!m_cm || !m_parentWidget) {
- LOG_RETURN_VALUE(RES_FAIL, {}, "Main params are are set");
+ LOG_RETURN_VALUE(RES_INVALID_ARGUMENTS, {},
+ "Main params are are set");
}
auto result = makeShared<CallInfoPresenter>(m_cm);
CallInfoPresenter::CallInfoPresenter(IRefCountObj &rc,
const ICallManagerSRef &cm):
- GuiPresenter(rc),
- m_mode(getCallMode(cm)),
- m_isSubTxtEnable(false),
- m_needModifyCallStatus(false)
+ GuiPresenter(rc),
+ m_mode(getCallMode(cm)),
+ m_isSubTxtEnable(false),
+ m_needModifyCallStatus(false)
{
initCallInfos(cm);
}
void CallInfoPresenter::setLanguageChangeCallback()
{
- getWindow().addEventHandler(WIN_LANGUAGE_CHANGED, WEAK_DELEGATE(
- CallInfoPresenter::onLanguageChanged, asWeak(*this)));
+ getWindow().addEventHandler(WIN_LANGUAGE_CHANGED,
+ WEAK_DELEGATE_THIS(onLanguageChanged));
}
void CallInfoPresenter::unsetLanguageChangeCallback()
{
- getWindow().delEventHandler(WIN_LANGUAGE_CHANGED, WEAK_DELEGATE(
- CallInfoPresenter::onLanguageChanged, asWeak(*this)));
+ getWindow().delEventHandler(WIN_LANGUAGE_CHANGED,
+ DELEGATE_THIS(onLanguageChanged));
}
void CallInfoPresenter::onLanguageChanged(Widget &widget, void *eventInfo)
const ICallInfoSCRef &callInfo)
{
if (!callInfo) {
- LOG_RETURN_VALUE(RES_FAIL, "", "callInfo is NULL");
+ LOG_RETURN_VALUE(RES_INVALID_ARGUMENTS, "", "callInfo is NULL");
}
if (callInfo->getConferenceMemberCount() > 1) {
* @param[in] cm Call Manager instance
* @return Reference to builder
*/
- Builder &setCallManager(const ICallManagerSRef &cm);
+ Builder &setCallManager(ICallManagerSRef cm);
/**
* @brief Sets parent widget for UI components creation
* @param[in] parentWidget Parent widget
* @return Reference to builder
*/
- Builder &setParentWidget(const ucl::ElmWidgetSRef &parentWidget);
+ Builder &setParentWidget(ucl::ElmWidgetSRef parentWidget);
/**
* @brief Creates new instance of CallInfoPresenter
}
CallStatusPresenter::Builder &
- CallStatusPresenter::Builder::setCallInfo(const ICallInfoWCRef &info)
+ CallStatusPresenter::Builder::setCallInfo(ICallInfoWCRef info)
{
- m_info = info;
+ m_info = std::move(info);
return *this;
}
}
CallStatusPresenter::Builder &
- CallStatusPresenter::Builder::setLayout(const LayoutSRef &layout)
+ CallStatusPresenter::Builder::setLayout(LayoutSRef layout)
{
- m_ly = layout;
+ m_ly = std::move(layout);
return *this;
}
CallStatusPresenter::CallStatusPresenter(IRefCountObj &rc,
- const LayoutSRef &layout,
+ LayoutSRef layout,
CallMode mode,
- const ICallInfoWCRef &info,
+ ICallInfoWCRef info,
bool isHeld):
GuiPresenter(rc),
- m_ly(layout),
+ m_ly(std::move(layout)),
m_mode(mode),
- m_info(info),
+ m_info(std::move(info)),
m_isOnHold(isHeld),
m_timer(nullptr),
m_duration{0},
void CallStatusPresenter::setLanguageChangeCallback()
{
- getWindow().addEventHandler(WIN_LANGUAGE_CHANGED, WEAK_DELEGATE(
- CallStatusPresenter::onLanguageChanged, asWeak(*this)));
+ getWindow().addEventHandler(WIN_LANGUAGE_CHANGED,
+ WEAK_DELEGATE_THIS(onLanguageChanged));
}
void CallStatusPresenter::unsetLanguageChangeCallback()
{
- getWindow().delEventHandler(WIN_LANGUAGE_CHANGED, WEAK_DELEGATE(
- CallStatusPresenter::onLanguageChanged, asWeak(*this)));
+ getWindow().delEventHandler(WIN_LANGUAGE_CHANGED,
+ DELEGATE_THIS(onLanguageChanged));
}
void CallStatusPresenter::onLanguageChanged(Widget &widget, void *eventInfo)
* @param[in] info Call Info instance
* @return Reference to builder
*/
- Builder &setCallInfo(const ICallInfoWCRef &info);
+ Builder &setCallInfo(ICallInfoWCRef info);
/**
* @brief Sets call Hold state
* @param[in] info Call Info layout
* @return Reference to builder
*/
- Builder &setLayout(const ucl::LayoutSRef &layout);
+ Builder &setLayout(ucl::LayoutSRef layout);
/**
* @brief Creates new instance of CallStatusPresenter
private:
CallStatusPresenter(ucl::IRefCountObj &rc,
- const ucl::LayoutSRef &layout,
+ ucl::LayoutSRef layout,
CallMode mode,
- const ICallInfoWCRef &info,
+ ICallInfoWCRef info,
bool isOnHold);
~CallStatusPresenter();
}
DeviceStatePresenterSRef
- DeviceStatePresenter::Builder::build(const ucl::WindowSRef &window) const
+ DeviceStatePresenter::Builder::build(ucl::WindowSRef window) const
{
- auto result = makeShared<DeviceStatePresenter>(window);
+ if (!window) {
+ LOG_RETURN_VALUE(RES_INVALID_ARGUMENTS, {}, "window is NULL");
+ }
+
+ auto result = makeShared<DeviceStatePresenter>(std::move(window));
FAIL_RETURN_VALUE(result->prepare(m_state,
m_mode, m_lockState), {},
"result->prepare() failed!");
// DeviceStatePresenter //
- DeviceStatePresenter::DeviceStatePresenter(const ucl::WindowSRef &window):
- m_window(window),
+ DeviceStatePresenter::DeviceStatePresenter(ucl::WindowSRef window):
+ m_window(std::move(window)),
m_mode(DisplayMode::UNDEFINED),
m_lockState(false)
{
* @return Shared reference to DeviceStatePresenter instance
* on success or NULL otherwise
*/
- DeviceStatePresenterSRef build(
- const ucl::WindowSRef &window) const;
+ DeviceStatePresenterSRef build(ucl::WindowSRef window) const;
private:
DisplayState m_state;
DisplayMode m_mode;
ucl::Result setCpuLockState(bool lockState);
private:
- DeviceStatePresenter(const ucl::WindowSRef &window);
+ DeviceStatePresenter(ucl::WindowSRef window);
~DeviceStatePresenter() = default;
ucl::Result prepare(DisplayState state,
IndicatorPresenter::Builder &
IndicatorPresenter::Builder::setIndicatorStateProvider(
- const IIndicatorStateProviderSRef &provider)
+ IIndicatorStateProviderSRef provider)
{
- m_provider = provider;
+ m_provider = std::move(provider);
return *this;
}
IndicatorPresenter::Builder &
- IndicatorPresenter::Builder::setParentWidget(const ucl::ElmWidgetSRef &parentWidget)
+ IndicatorPresenter::Builder::setParentWidget(
+ ucl::ElmWidgetSRef parentWidget)
{
- m_parentWidget = parentWidget;
+ m_parentWidget = std::move(parentWidget);
return *this;
}
}
IndicatorPresenter::IndicatorPresenter(IRefCountObj &rc,
- const IIndicatorStateProviderSRef &provider):
+ IIndicatorStateProviderSRef provider):
GuiPresenter(rc),
- m_provider(provider)
+ m_provider(std::move(provider))
{
}
* @return Reference to builder
*/
Builder &setIndicatorStateProvider(
- const IIndicatorStateProviderSRef &provider);
+ IIndicatorStateProviderSRef provider);
/**
* @brief Sets parent widget for UI components creation
* @param[in] parentWidget Parent widget
* @return Reference to builder
*/
- Builder &setParentWidget(const ucl::ElmWidgetSRef &parentWidget);
+ Builder &setParentWidget(ucl::ElmWidgetSRef parentWidget);
/**
* @brief Creates new instance of IndicatorPresenter
private:
IndicatorPresenter(ucl::IRefCountObj &rc,
- const IIndicatorStateProviderSRef &provider);
+ IIndicatorStateProviderSRef provider);
~IndicatorPresenter() = default;
ucl::Result prepare(ucl::GuiPresenter &parent,
virtual void onStateChanged(IndicatorProperty property) override final;
private:
+ const IIndicatorStateProviderSRef m_provider;
+
ucl::LayoutSRef m_widget;
ucl::LayoutSRef m_connLayout;
ucl::LayoutSRef m_rssiLayout;
ucl::LayoutSRef m_simLayout;
ucl::LayoutSRef m_hdCallLayout;
- IIndicatorStateProviderSRef m_provider;
-
friend class ucl::ReffedObj<IndicatorPresenter>;
};
- ucl::EdjeSignal getConnectionSignal(ConnectionType type);
}
#endif // __CALL_UI_PRESENTERS_MISC_MISC_INDICATOR_PRESENTER_H__
}
MoreOptionsPresenter::Builder &
- MoreOptionsPresenter::Builder::setCallManager(const ICallManagerSRef &cm)
+ MoreOptionsPresenter::Builder::setCallManager(ICallManagerSRef cm)
{
- m_cm = cm;
+ m_cm = std::move(cm);
return *this;
}
MoreOptionsPresenter::Builder &
- MoreOptionsPresenter::Builder::setSoundManager(const ISoundManagerSRef &sm)
+ MoreOptionsPresenter::Builder::setSoundManager(ISoundManagerSRef sm)
{
- m_sm = sm;
+ m_sm = std::move(sm);
return *this;
}
MoreOptionsPresenter::Builder &
- MoreOptionsPresenter::Builder::setNaviframe(const NaviframeSRef &navi)
+ MoreOptionsPresenter::Builder::setNaviframe(NaviframeSRef navi)
{
- m_navi = navi;
+ m_navi = std::move(navi);
return *this;
}
MoreOptionsPresenter::Builder &
- MoreOptionsPresenter::Builder::setParentWidget(
- const ElmWidgetSRef &parentWidget)
+ MoreOptionsPresenter::Builder::setParentWidget(ElmWidgetSRef parentWidget)
{
- m_parentWidget = parentWidget;
+ m_parentWidget = std::move(parentWidget);
return *this;
}
// MoreOptionsPresenter //
MoreOptionsPresenter::MoreOptionsPresenter(IRefCountObj &rc,
- const ICallManagerSRef &cm,
- const ISoundManagerSRef &sm,
- const NaviframeSRef &navi):
+ ICallManagerSRef cm,
+ ISoundManagerSRef sm,
+ NaviframeSRef navi):
GuiPresenter(rc),
- m_cm(cm),
- m_sm(sm),
- m_navi(navi),
+ m_cm(std::move(cm)),
+ m_sm(std::move(sm)),
+ m_navi(std::move(navi)),
m_timer(nullptr),
m_duration()
{
void MoreOptionsPresenter::registerPageTransitionCallback()
{
m_navi->addEventHandler(NAVI_TRANSITION_FINISHED,
- WEAK_DELEGATE(
- MoreOptionsPresenter::onPageTransitionFinished,
- asWeak(*this)));
+ WEAK_DELEGATE_THIS(onPageTransitionFinished));
}
void MoreOptionsPresenter::unregisterPageTransitionCallback()
{
m_navi->delEventHandler(NAVI_TRANSITION_FINISHED,
- WEAK_DELEGATE(
- MoreOptionsPresenter::onPageTransitionFinished,
- asWeak(*this)));
+ DELEGATE_THIS(onPageTransitionFinished));
}
void MoreOptionsPresenter::onPageTransitionFinished(Widget &widget,
Result MoreOptionsPresenter::createSwapButton()
{
m_btnSwap = createButton(impl::STYLE_BTN_SWAP, STR_MORE_SWAP,
- WEAK_DELEGATE(MoreOptionsPresenter::onSwapBtnClick,
- asWeak(*this)));
+ WEAK_DELEGATE_THIS(onSwapBtnClick));
if (!m_btnSwap) {
LOG_RETURN(RES_FAIL, "Create Swap button failed!");
}
Result MoreOptionsPresenter::createUnholdButton()
{
m_btnUnhold = createButton(impl::STYLE_BTN_UNHOLD, STR_MORE_UNHOLD,
- WEAK_DELEGATE(MoreOptionsPresenter::onUnholdBtnClick,
- asWeak(*this)));
+ WEAK_DELEGATE_THIS(onUnholdBtnClick));
if (!m_btnUnhold) {
LOG_RETURN(RES_FAIL, "Create Unhold button failed!");
}
Result MoreOptionsPresenter::createKeypadButton()
{
m_btnKeypad = createButton(impl::STYLE_BTN_KEYPAD, STR_MORE_KEYPAD,
- WEAK_DELEGATE(MoreOptionsPresenter::onKeypadBtnClick,
- asWeak(*this)));
+ WEAK_DELEGATE_THIS(onKeypadBtnClick));
if (!m_btnKeypad) {
LOG_RETURN(RES_FAIL, "Create Keypad button failed!");
}
LOG_RETURN_VOID(RES_FAIL, "Naviframe is NULL");
}
m_keypad = builder.setSoundManager(m_sm)
- .build(WEAK_DELEGATE(
- MoreOptionsPresenter::onPageExitRequest,
- asWeak(*this)));
+ .build(WEAK_DELEGATE_THIS(onPageExitRequest));
}
void MoreOptionsPresenter::onPageExitRequest(Page &page)
StyledWidgetSRef MoreOptionsPresenter::createButton(
const ElmStyle &style,
const TString &txt,
- const WidgetEventHandler &handler)
+ WidgetEventHandler handler)
{
auto *eo = elm_button_add(*m_panelLy);
if (!eo) {
auto btn = makeShared<StyledWidget>(eo);
btn->setStyle(style);
btn->setText(txt);
- btn->addEventHandler(BTN_CLICKED, handler);
+ btn->addEventHandler(BTN_CLICKED, std::move(handler));
hide(*btn);
btn->bindToEo();
"AtspiHighlightHelper::newInstance() failed!");
}
- m_atspiHelper->setRelationEventHandler(WEAK_DELEGATE(
- MoreOptionsPresenter::onAtspiHighlight, asWeak(*this)));
+ m_atspiHelper->setRelationEventHandler(
+ WEAK_DELEGATE_THIS(onAtspiHighlight));
if (m_fakeAo) {
m_atspiHelper->registerWidget(*m_fakeAo);
* @param[in] cm Call Manager instance
* @return Reference to builder
*/
- Builder &setCallManager(const ICallManagerSRef &cm);
+ Builder &setCallManager(ICallManagerSRef cm);
/**
* @brief Sets Sound Manager instance
* @param[in] sm Sound Manager instance
* @return Reference to builder
*/
- Builder &setSoundManager(const ISoundManagerSRef &sm);
+ Builder &setSoundManager(ISoundManagerSRef sm);
/**
* @brief Sets Naviframe instance
* @param[in] sm Naviframe instance
* @return Reference to builder
*/
- Builder &setNaviframe(const ucl::NaviframeSRef &navi);
+ Builder &setNaviframe(ucl::NaviframeSRef navi);
/**
* @brief Sets parent widget for UI components creation
* @param[in] parentWidget Parent widget
* @return Reference to builder
*/
- Builder &setParentWidget(const ucl::ElmWidgetSRef &parentWidget);
+ Builder &setParentWidget(ucl::ElmWidgetSRef parentWidget);
/**
* @brief Creates new instance of MoreOptionsPresenter
private:
MoreOptionsPresenter(ucl::IRefCountObj &rc,
- const ICallManagerSRef &cm,
- const ISoundManagerSRef &sm,
- const ucl::NaviframeSRef &navi);
+ ICallManagerSRef cm,
+ ISoundManagerSRef sm,
+ ucl::NaviframeSRef navi);
~MoreOptionsPresenter();
ucl::Result prepare(ucl::GuiPresenter &parent,
ucl::StyledWidgetSRef createButton(const ucl::ElmStyle &style,
const ucl::TString &txt,
- const ucl::WidgetEventHandler &handler);
+ ucl::WidgetEventHandler handler);
void registerPageTransitionCallback();
void unregisterPageTransitionCallback();
Elm_Access_Action_Info *actionInfo);
private:
+ const ICallManagerSRef m_cm;
+ const ISoundManagerSRef m_sm;
+ const ucl::NaviframeSRef m_navi;
+
ucl::LayoutSRef m_widget;
ucl::StyledWidgetSRef m_panel;
ucl::LayoutSRef m_panelLy;
ucl::StyledWidgetSRef m_btnKeypad;
PageWRef m_keypad;
- ICallManagerSRef m_cm;
- ISoundManagerSRef m_sm;
- ucl::NaviframeSRef m_navi;
ICallInfoWCRef m_info;
Ecore_Timer *m_timer;
}
MotionSensorPresenterSRef
- MotionSensorPresenter::Builder::build(
- const NotiHandler handler) const
+ MotionSensorPresenter::Builder::build(NotiHandler handler) const
{
- auto result = makeShared<MotionSensorPresenter>(handler);
+ auto result = makeShared<MotionSensorPresenter>(std::move(handler));
FAIL_RETURN_VALUE(result->prepare(),
{}, "result->prepare() failed!");
return result;
}
MotionSensorPresenter::MotionSensorPresenter(
- const NotiHandler &handler):
- m_handler(handler),
+ NotiHandler handler):
+ m_handler(std::move(handler)),
m_gesture(nullptr)
{
}
"err[%d] msg[%s]", res, get_error_message(res));
}
- if (event == GESTURE_EVENT_DETECTED && m_handler) {
- m_handler();
+ if (event == GESTURE_EVENT_DETECTED) {
+ if (const auto handler = m_handler.lock()) {
+ handler();
+ }
}
}
}
* @return Shared reference to MotionSensorPresenter instance
* on success or NULL otherwise
*/
- MotionSensorPresenterSRef build(const NotiHandler handler) const;
+ MotionSensorPresenterSRef build(NotiHandler handler) const;
};
private:
- MotionSensorPresenter(const NotiHandler &handler);
+ MotionSensorPresenter(NotiHandler handler);
~MotionSensorPresenter();
ucl::Result prepare();
gesture_error_e error);
private:
- NotiHandler m_handler;
+ const NotiHandler m_handler;
gesture_h m_gesture;
friend class ucl::ReffedObj<MotionSensorPresenter>;
{
}
- virtual ~RejectMsgItem()
- {
- }
+ virtual ~RejectMsgItem() = default;
std::string getDisplayText() const
{
}
RejectMsgPresenter::Builder &
- RejectMsgPresenter::Builder::setProvider(
- const IRejectMsgProviderSRef &provider)
+ RejectMsgPresenter::Builder::setProvider(IRejectMsgProviderSRef provider)
{
- m_provider = provider;
+ m_provider = std::move(provider);
return *this;
}
RejectMsgPresenter::Builder &
- RejectMsgPresenter::Builder::setStateHandler(
- const StateHandler &handler)
+ RejectMsgPresenter::Builder::setStateHandler(StateHandler handler)
{
- m_stateHandler = handler;
+ m_stateHandler = std::move(handler);
return *this;
}
RejectMsgPresenter::Builder &
- RejectMsgPresenter::Builder::setSelectHandler(
- const SelectHandler &handler)
+ RejectMsgPresenter::Builder::setSelectHandler(SelectHandler handler)
{
- m_selectHandler = handler;
+ m_selectHandler = std::move(handler);
return *this;
}
RejectMsgPresenter::Builder &
- RejectMsgPresenter::Builder::setParentWidget(
- const ElmWidgetSRef &parentWidget)
+ RejectMsgPresenter::Builder::setParentWidget(ElmWidgetSRef parentWidget)
{
- m_parentWidget = parentWidget;
+ m_parentWidget = std::move(parentWidget);
return *this;
}
}
RejectMsgPresenter::RejectMsgPresenter(IRefCountObj &rc,
- const IRejectMsgProviderSRef &provider,
- const StateHandler &stateHandler,
- const SelectHandler &selectHandler):
- GuiPresenter(rc),
- m_circleEo(nullptr),
- m_provider(provider),
- m_stateHandler(stateHandler),
- m_selectHandler(selectHandler),
- m_state(State::HIDDEN)
+ IRejectMsgProviderSRef provider,
+ StateHandler stateHandler,
+ SelectHandler selectHandler):
+ GuiPresenter(rc),
+ m_provider(std::move(provider)),
+ m_stateHandler(std::move(stateHandler)),
+ m_selectHandler(std::move(selectHandler)),
+ m_circleEo(nullptr),
+ m_state(State::HIDDEN)
{
}
sendDeactivate(*m_widget);
}
- if (m_stateHandler) {
- m_stateHandler(m_state);
+ if (const auto handler = m_stateHandler.lock()) {
+ handler(m_state);
}
}
}
show(*m_panel);
m_panel->addEventHandler(impl::EVENT_SCROLL,
- WEAK_DELEGATE(RejectMsgPresenter::panelScrollCb,
- asWeak(*this)));
+ WEAK_DELEGATE_THIS(panelScrollCb));
m_widget->setContent(*m_panel, impl::PART_SWL_RIGHT);
void RejectMsgPresenter::setLanguageChangeCallback()
{
- getWindow().addEventHandler(WIN_LANGUAGE_CHANGED, WEAK_DELEGATE(
- RejectMsgPresenter::onLanguageChanged, asWeak(*this)));
+ getWindow().addEventHandler(WIN_LANGUAGE_CHANGED,
+ WEAK_DELEGATE_THIS(onLanguageChanged));
}
void RejectMsgPresenter::unsetLanguageChangeCallback()
{
- getWindow().delEventHandler(WIN_LANGUAGE_CHANGED, WEAK_DELEGATE(
- RejectMsgPresenter::onLanguageChanged, asWeak(*this)));
+ getWindow().delEventHandler(WIN_LANGUAGE_CHANGED,
+ DELEGATE_THIS(onLanguageChanged));
}
void RejectMsgPresenter::onLanguageChanged(Widget &widget, void *eventInfo)
void RejectMsgPresenter::handleSelectEvent(const RejectMsgItem &item)
{
- if (m_selectHandler) {
- m_selectHandler(item.getRejectMsg());
+ if (const auto handler = m_selectHandler.lock()) {
+ handler(item.getRejectMsg());
}
}
}
}
- void RejectMsgPresenter::setStateHandler(
- const RejectMsgPresenter::StateHandler &handler)
- {
- m_stateHandler = handler;
- }
-
- void RejectMsgPresenter::setSelectHandler(
- const SelectHandler &handler)
- {
- m_selectHandler = handler;
- }
-
void RejectMsgPresenter::onActivate()
{
DLOG();
LOG_RETURN(RES_FAIL, "AtspiHighlightHelper::newInstance() failed!");
}
- m_atspiHelper->setRelationEventHandler(WEAK_DELEGATE(
- RejectMsgPresenter::onAtspiHighlight, asWeak(*this)));
+ m_atspiHelper->setRelationEventHandler(
+ WEAK_DELEGATE_THIS(onAtspiHighlight));
return RES_OK;
}
* @param[in] provider Reject message provider instance
* @return Reference to builder
*/
- Builder &setProvider(const IRejectMsgProviderSRef &provider);
+ Builder &setProvider(IRejectMsgProviderSRef provider);
/**
* @brief Sets state change event handler
* @param[in] handler State change event handler
* @return Reference to builder
*/
- Builder &setStateHandler(const StateHandler &handler);
+ Builder &setStateHandler(StateHandler handler);
/**
* @brief Sets select reject message event handler
* @param[in] handler Select reject message event handler
* @return Reference to builder
*/
- Builder &setSelectHandler(const SelectHandler &handler);
+ Builder &setSelectHandler(SelectHandler handler);
/**
* @brief Sets parent widget for UI components creation
* @param[in] parentWidget Parent widget
* @return Reference to builder
*/
- Builder &setParentWidget(const ucl::ElmWidgetSRef &parentWidget);
+ Builder &setParentWidget(ucl::ElmWidgetSRef parentWidget);
/**
* @brief Creates new instance of RejectMsgPresenter
*/
void hidePanel();
- /**
- * @brief Sets state change event handler
- * @param[in] handler State change event handler
- */
- void setStateHandler(const StateHandler &handler);
-
- /**
- * @brief Sets select reject message event handler
- * @param[in] handler Select reject message event handler
- */
- void setSelectHandler(const SelectHandler &handler);
-
private:
class RejectMsgItem;
private:
RejectMsgPresenter(ucl::IRefCountObj &rc,
- const IRejectMsgProviderSRef &provider,
- const StateHandler &stateHandler,
- const SelectHandler &selectHandler);
+ IRejectMsgProviderSRef provider,
+ StateHandler stateHandler,
+ SelectHandler selectHandler);
~RejectMsgPresenter();
ucl::Result prepare(ucl::GuiPresenter &parent,
virtual void onDeactivate() final override;
private:
+ const IRejectMsgProviderSRef m_provider;
+ const StateHandler m_stateHandler;
+ const SelectHandler m_selectHandler;
+
ucl::LayoutSRef m_widget;
ucl::StyledWidgetSRef m_panel;
ucl::ElmWidgetSRef m_panelBg;
ucl::StyledWidgetSRef m_genlist;
Evas_Object *m_circleEo;
- IRejectMsgProviderSRef m_provider;
- StateHandler m_stateHandler;
- SelectHandler m_selectHandler;
State m_state;
AtspiHighlightHelperSRef m_atspiHelper;
{
}
- KeypadPage::Builder &KeypadPage::Builder::setNaviframe(
- const NaviframeSRef &navi)
+ KeypadPage::Builder &KeypadPage::Builder::setNaviframe(NaviframeSRef navi)
{
- m_navi = navi;
+ m_navi = std::move(navi);
return *this;
}
KeypadPage::Builder
- &KeypadPage::Builder::setSoundManager(const ISoundManagerSRef &sm)
+ &KeypadPage::Builder::setSoundManager(ISoundManagerSRef sm)
{
- m_sm = sm;
+ m_sm = std::move(sm);
return *this;
}
KeypadPageSRef KeypadPage::Builder::build(
- const ExitRequestHandler onExitRequest) const
+ ExitRequestHandler onExitRequest) const
{
if (!onExitRequest) {
LOG_RETURN_VALUE(RES_INVALID_ARGUMENTS, {},
"onExitRequest is NULL");
}
if (!m_navi) {
- LOG_RETURN_VALUE(RES_INVALID_ARGUMENTS, {},
- "m_navi is NULL");
+ LOG_RETURN_VALUE(RES_FAIL, {}, "m_navi is NULL");
}
if (!m_sm) {
LOG_RETURN_VALUE(RES_FAIL, {}, "m_sm is NULL");
}
- auto result = makeShared<KeypadPage>(m_sm, m_navi, onExitRequest);
+ auto result = makeShared<KeypadPage>(m_navi,
+ std::move(onExitRequest), m_sm);
FAIL_RETURN_VALUE(result->prepare([&result](NaviItem &item)
{
// KeypadPage //
KeypadPage::KeypadPage(IRefCountObj &rc,
- const ISoundManagerSRef &sm,
- const NaviframeSRef &navi,
- const ExitRequestHandler onExitRequest):
- Page(rc, navi, onExitRequest),
- m_sm(sm),
+ NaviframeSRef navi,
+ ExitRequestHandler onExitRequest,
+ ISoundManagerSRef sm):
+ Page(rc, std::move(navi), std::move(onExitRequest)),
+ m_sm(std::move(sm)),
m_smInUse(false),
m_vcTimer(nullptr),
m_audioState(m_sm->getAudioState())
LOG_RETURN(RES_FAIL, "win is NULL!");
}
- win->addEventHandler(WIN_POWER_KEY_UP_EVENT, WEAK_DELEGATE(
- KeypadPage::onPowerKeyUp, asWeak(*this)));
+ win->addEventHandler(WIN_POWER_KEY_UP_EVENT,
+ WEAK_DELEGATE_THIS(onPowerKeyUp));
return RES_OK;
}
LOG_RETURN_VOID(RES_FAIL, "win is NULL!");
}
- win->delEventHandler(WIN_POWER_KEY_UP_EVENT, WEAK_DELEGATE(
- KeypadPage::onPowerKeyUp, asWeak(*this)));
+ win->delEventHandler(WIN_POWER_KEY_UP_EVENT,
+ DELEGATE_THIS(onPowerKeyUp));
}
void KeypadPage::onPowerKeyUp(Widget &widget, void *eventInfo)
if (impl::buttonsInfo[i].type == impl::OperationType::DTMF) {
buttonSRef->addEventHandler(impl::BTN_PRESSED,
- WEAK_DELEGATE(KeypadPage::onBtnPressed,
- asWeak(*this)));
+ WEAK_DELEGATE_THIS(onBtnPressed));
buttonSRef->addEventHandler(impl::BTN_UNPRESSED,
- WEAK_DELEGATE(KeypadPage::onBtnUnpressed,
- asWeak(*this)));
+ WEAK_DELEGATE_THIS(onBtnUnpressed));
} else {
buttonSRef->addEventHandler(BTN_CLICKED,
- WEAK_DELEGATE(KeypadPage::onBtnClicked,
- asWeak(*this)));
+ WEAK_DELEGATE_THIS(onBtnClicked));
// RTL support
elm_object_mirrored_automatic_set(*buttonSRef, EINA_FALSE);
void KeypadPage::stopDtmf()
{
if (m_smInUse) {
- m_sm->stopDtmf();
m_smInUse = false;
+ m_sm->stopDtmf();
}
}
m_vc = VolumeControl::Builder().
setInfoText(STR_VOLUME).
setMaxValue(m_sm->getMaxVolume()).
- setEventHandler(WEAK_DELEGATE(
- KeypadPage::onVolumeControlEventCb,
- asWeak(*this))).
+ setEventHandler(WEAK_DELEGATE_THIS(onVolumeControlEventCb)).
build(*m_widget);
if (!m_vc) {
LOG_RETURN(RES_FAIL, "VolumeControl::build() failed");
void KeypadPage::registerCallbacks()
{
- addRotaryEventHandler(CALLBACK_A(
- KeypadPage::onRotaryEvent), this);
-
- m_sm->addAudioStateHandler(WEAK_DELEGATE(
- KeypadPage::onAudioStateChanged, asWeak(*this)));
+ addRotaryEventHandler(
+ CALLBACK_A(KeypadPage::onRotaryEvent), this);
- m_sm->addVolumeStateHandler(WEAK_DELEGATE(
- KeypadPage::onVolumeLevelChanged, asWeak(*this)));
+ m_sm->addAudioStateHandler(WEAK_DELEGATE_THIS(onAudioStateChanged));
+ m_sm->addVolumeStateHandler(WEAK_DELEGATE_THIS(onVolumeLevelChanged));
}
void KeypadPage::unregisterCallbacks()
delRotaryEventHandler(
CALLBACK_A(KeypadPage::onRotaryEvent), this);
- m_sm->delAudioStateHandler(WEAK_DELEGATE(
- KeypadPage::onAudioStateChanged, asWeak(*this)));
-
- m_sm->delVolumeStateHandler(WEAK_DELEGATE(
- KeypadPage::onVolumeLevelChanged, asWeak(*this)));
+ m_sm->delAudioStateHandler(DELEGATE_THIS(onAudioStateChanged));
+ m_sm->delVolumeStateHandler(DELEGATE_THIS(onVolumeLevelChanged));
}
Result KeypadPage::createAtspiHighlightHelper()
"AtspiHighlightHelper::newInstance() failed!");
}
- m_atspiHelper->setRelationEventHandler(WEAK_DELEGATE(
- KeypadPage::onAtspiHighlight, asWeak(*this)));
+ m_atspiHelper->setRelationEventHandler(
+ WEAK_DELEGATE_THIS(onAtspiHighlight));
m_atspiHelper->registerWidget(*getFirstButton());
m_atspiHelper->registerWidget(*getLastButton());
if (decrBtn) {
decrBtn->addEventHandler(ATSPI_HIGHLIGHTED,
- WEAK_DELEGATE(KeypadPage::
- onVolumeControlScreenReaderReadStart,
- asWeak(*this)));
+ WEAK_DELEGATE_THIS(onVolumeControlScreenReaderReadStart));
}
auto incrBtn = m_vc->getIncreaseBtn();
if (incrBtn) {
incrBtn->addEventHandler(ATSPI_HIGHLIGHTED,
- WEAK_DELEGATE(KeypadPage::
- onVolumeControlScreenReaderReadStart,
- asWeak(*this)));
+ WEAK_DELEGATE_THIS(onVolumeControlScreenReaderReadStart));
}
}
* @param[in] navi Naviframe instance
* @return Reference to builder
*/
- Builder &setNaviframe(const ucl::NaviframeSRef &navi);
+ Builder &setNaviframe(ucl::NaviframeSRef navi);
/**
* @brief Sets Sound Manager instance
* @param[in] navi Sound Manager instance
* @return Reference to builder
*/
- Builder &setSoundManager(const ISoundManagerSRef &sm);
+ Builder &setSoundManager(ISoundManagerSRef sm);
/**
* @brief Creates new instance of KeypadPage
* @return Shared reference to KeypadPage instance
* on success or NULL otherwise
*/
- KeypadPageSRef build(const ExitRequestHandler onExitRequest) const;
+ KeypadPageSRef build(ExitRequestHandler onExitRequest) const;
private:
ISoundManagerSRef m_sm;
ucl::NaviframeSRef m_navi;
private:
KeypadPage(ucl::IRefCountObj &rc,
- const ISoundManagerSRef &sm,
- const ucl::NaviframeSRef &navi,
- const ExitRequestHandler onExitRequest);
+ ucl::NaviframeSRef navi,
+ ExitRequestHandler onExitRequest,
+ ISoundManagerSRef sm);
~KeypadPage();
ucl::Result doPrepare(ucl::NaviItem &item);
virtual void onBackKey() override final;
private:
+ const ISoundManagerSRef m_sm;
+
ucl::LayoutSRef m_widget;
ucl::ElmWidgetSRef m_entry;
- ISoundManagerSRef m_sm;
bool m_smInUse;
VolumeControlSRef m_vc;
}
MainPage::Builder &MainPage::Builder::setNaviframe(
- const NaviframeSRef &navi)
+ NaviframeSRef navi)
{
- m_navi = navi;
+ m_navi = std::move(navi);
return *this;
}
MainPage::Builder &MainPage::Builder::setCallUI(
- const ICallUISRef &call)
+ ICallUISRef call)
{
- m_call = call;
+ m_call = std::move(call);
return *this;
}
MainPageSRef MainPage::Builder::build(
- const ExitRequestHandler onExitRequest) const
+ ExitRequestHandler onExitRequest) const
{
if (!onExitRequest) {
LOG_RETURN_VALUE(RES_INVALID_ARGUMENTS, {},
}
auto result = makeShared<MainPage>(
- m_navi, onExitRequest, m_call);
+ m_navi, std::move(onExitRequest), m_call);
FAIL_RETURN_VALUE(result->prepare([&result](NaviItem &item)
{
// MainPage //
MainPage::MainPage(IRefCountObj &rc,
- const NaviframeSRef &navi,
- const ExitRequestHandler onExitRequest,
- const ICallUISRef &call) :
- Page(rc, navi, onExitRequest),
- m_call(call),
+ NaviframeSRef navi,
+ ExitRequestHandler onExitRequest,
+ ICallUISRef call) :
+ Page(rc, std::move(navi), std::move(onExitRequest)),
+ m_call(std::move(call)),
+ m_cm(m_call->getCallManager()),
m_mode(CallMode::UNDEFINED),
m_ecTimer(nullptr),
m_ecTimerBtnReq(false)
Result MainPage::doPrepare(NaviItem &item)
{
- m_cm = m_call->getCallManager();
if (!m_cm) {
LOG_RETURN(RES_FAIL, "Call manager is NULL!");
}
LOG_RETURN(RES_FAIL, "win is NULL!");
}
- win->addEventHandler(WIN_POWER_KEY_UP_EVENT, WEAK_DELEGATE(
- MainPage::onPowerKeyUp, asWeak(*this)));
+ win->addEventHandler(WIN_POWER_KEY_UP_EVENT,
+ WEAK_DELEGATE_THIS(onPowerKeyUp));
return RES_OK;
}
LOG_RETURN_VOID(RES_FAIL, "win is NULL!");
}
- win->delEventHandler(WIN_POWER_KEY_UP_EVENT, WEAK_DELEGATE(
- MainPage::onPowerKeyUp, asWeak(*this)));
+ win->delEventHandler(WIN_POWER_KEY_UP_EVENT,
+ DELEGATE_THIS(onPowerKeyUp));
}
void MainPage::processKeyPress(bool isPowerKey)
m_bottomBtn->setStyle(style);
m_bottomBtn->addEventHandler(BTN_CLICKED,
- WEAK_DELEGATE(MainPage::onBottomBtnClicked,
- asWeak(*this)));
+ WEAK_DELEGATE_THIS(MainPage::onBottomBtnClicked));
elm_atspi_accessible_translation_domain_set(*m_bottomBtn, TEXT_DOMAIN);
if (style == impl::STYLE_BB_RECALL) {
m_accessoryPrs = AccessoryPresenter::Builder().
setSoundManager(m_call->getSoundManager()).
setCallManager(m_cm).
- setRequestExitHandler(WEAK_DELEGATE(MainPage::onExitAppRequest,
- asWeak(*this))).
+ setRequestExitHandler(WEAK_DELEGATE_THIS(onExitAppRequest)).
setParentWidget(m_widget).
build(*this);
{
m_rmPrs = RejectMsgPresenter::Builder().
setProvider(provider).
- setStateHandler(WEAK_DELEGATE(MainPage::RejectMsgPresenterStateCb,
- asWeak(*this))).
- setSelectHandler(WEAK_DELEGATE(MainPage::RejectMsgSelectCb,
- asWeak(*this))).
+ setStateHandler(WEAK_DELEGATE_THIS(RejectMsgPresenterStateCb)).
+ setSelectHandler(WEAK_DELEGATE_THIS(RejectMsgSelectCb)).
setParentWidget(m_widget).
build(*this);
void MainPage::registerIncomingCallModeAo()
{
DLOG("ENTER");
- m_atspiHelper->setRelationEventHandler(WEAK_DELEGATE(
- MainPage::onIncomingCallModeAtspiHighlight, asWeak(*this)));
+ m_atspiHelper->setRelationEventHandler(
+ WEAK_DELEGATE_THIS(onIncomingCallModeAtspiHighlight));
- m_atspiHelper->setGestureEventHandler(WEAK_DELEGATE(
- MainPage::onIncomingModeAtspiGesture, asWeak(*this)));
+ m_atspiHelper->setGestureEventHandler(
+ WEAK_DELEGATE_THIS(onIncomingModeAtspiGesture));
auto acceptAO = m_acceptRejectPrs->getAcceptAo();
if (!acceptAO) {
void MainPage::registerActiveCallModeAo()
{
DLOG("ENTER");
- m_atspiHelper->setRelationEventHandler(WEAK_DELEGATE(
- MainPage::onActiveCallModeAtspiHighlight, asWeak(*this)));
+ m_atspiHelper->setRelationEventHandler(
+ WEAK_DELEGATE_THIS(onActiveCallModeAtspiHighlight));
auto statusTxtAo = m_callInfoPrs->getStatusTxtAo();
if (!statusTxtAo) {
void MainPage::registerEndCallModeAo()
{
- m_atspiHelper->setRelationEventHandler(WEAK_DELEGATE(
- MainPage::onEndCallModeAtspiHighlight, asWeak(*this)));
+ m_atspiHelper->setRelationEventHandler(
+ WEAK_DELEGATE_THIS(onEndCallModeAtspiHighlight));
auto statusTxtAo = m_callInfoPrs->getStatusTxtAo();
if (!statusTxtAo) {
* @param[in] navi Naviframe instance
* @return Reference to builder
*/
- Builder &setNaviframe(const ucl::NaviframeSRef &navi);
+ Builder &setNaviframe(ucl::NaviframeSRef navi);
/**
* @brief Sets CallUI instance
* @param[in] call CallUI instance
* @return Reference to builder
*/
- Builder &setCallUI(const ICallUISRef &call);
+ Builder &setCallUI(ICallUISRef call);
/**
* @brief Creates new instance of MainPage
* @return Shared reference to MainPage instance
* on success or NULL otherwise
*/
- MainPageSRef build(const ExitRequestHandler onExitRequest) const;
+ MainPageSRef build(ExitRequestHandler onExitRequest) const;
private:
ucl::NaviframeSRef m_navi;
ICallUISRef m_call;
private:
MainPage(ucl::IRefCountObj &rc,
- const ucl::NaviframeSRef &navi,
- const ExitRequestHandler onExitRequest,
- const ICallUISRef &call);
+ ucl::NaviframeSRef navi,
+ ExitRequestHandler onExitRequest,
+ ICallUISRef call);
~MainPage() = default;
ucl::Result doPrepare(ucl::NaviItem &item);
virtual void onError(CallErr err) final override;
private:
+ const ICallUISRef m_call;
+ const ICallManagerSRef m_cm;
+
ucl::LayoutSRef m_widget;
ucl::LayoutSRef m_rmLy;
ucl::StyledWidgetSRef m_bottomBtn;
- ICallUISRef m_call;
- ICallManagerSRef m_cm;
IndicatorPresenterSRef m_indicator;
CallInfoPresenterSRef m_callInfoPrs;
AcceptRejectPresenterSRef m_acceptRejectPrs;
}
AcceptRejectWidget::Builder &
- AcceptRejectWidget::Builder::setAcceptEventHandler(
- const NotiHandler &handler)
+ AcceptRejectWidget::Builder::setAcceptEventHandler(NotiHandler handler)
{
- m_acceptHandler = handler;
+ m_acceptHandler = std::move(handler);
return *this;
}
AcceptRejectWidget::Builder &
- AcceptRejectWidget::Builder::setRejectEventHandler(
- const NotiHandler &handler)
+ AcceptRejectWidget::Builder::setRejectEventHandler(NotiHandler handler)
{
- m_rejectHandler = handler;
+ m_rejectHandler = std::move(handler);
return *this;
}
AcceptRejectWidget::AcceptRejectWidget(IRefCountObj &rc,
const LayoutSRef &layout,
- const NotiHandler &acceptHandler,
- const NotiHandler &rejectHandler,
+ NotiHandler acceptHandler,
+ NotiHandler rejectHandler,
AcceptButtonType acceptBtnType):
ElmWidget(&rc, *layout, false),
+ m_accHandler(std::move(acceptHandler)),
+ m_rejHandler(std::move(rejectHandler)),
m_layout(layout.get()),
- m_accHandler(acceptHandler),
- m_rejHandler(rejectHandler),
m_accBezelCueImg(impl::BC_ITEM_COUNT),
m_rejBezelCueImg(impl::BC_ITEM_COUNT),
m_isFreezed(false),
m_expandTimeout.reset();
m_accEventLy->delEventHandler(WidgetEvent::MOUSE_DOWN,
- WEAK_DELEGATE(AcceptRejectWidget::onMouseDown, asWeak(*this)));
+ DELEGATE_THIS(onMouseDown));
m_accEventLy->delEventHandler(WidgetEvent::MOUSE_UP,
- WEAK_DELEGATE(AcceptRejectWidget::onMouseUp, asWeak(*this)));
+ DELEGATE_THIS(onMouseUp));
m_accEventLy->delEventHandler(WidgetEvent::MOUSE_MOVE,
- WEAK_DELEGATE(AcceptRejectWidget::onMouseMove, asWeak(*this)));
+ DELEGATE_THIS(onMouseMove));
m_rejEventLy->delEventHandler(WidgetEvent::MOUSE_DOWN,
- WEAK_DELEGATE(AcceptRejectWidget::onMouseDown, asWeak(*this)));
+ DELEGATE_THIS(onMouseDown));
m_rejEventLy->delEventHandler(WidgetEvent::MOUSE_UP,
- WEAK_DELEGATE(AcceptRejectWidget::onMouseUp, asWeak(*this)));
+ DELEGATE_THIS(onMouseUp));
m_rejEventLy->delEventHandler(WidgetEvent::MOUSE_MOVE,
- WEAK_DELEGATE(AcceptRejectWidget::onMouseMove, asWeak(*this)));
+ DELEGATE_THIS(onMouseMove));
DEL_TRANSIT(m_lastAccBezelTr1);
DEL_TRANSIT(m_lastAccBezelTr2);
build(*m_layout);
m_accEventLy->addEventHandler(WidgetEvent::MOUSE_DOWN,
- WEAK_DELEGATE(AcceptRejectWidget::onMouseDown, asWeak(*this)));
+ WEAK_DELEGATE_THIS(onMouseDown));
m_accEventLy->addEventHandler(WidgetEvent::MOUSE_UP,
- WEAK_DELEGATE(AcceptRejectWidget::onMouseUp, asWeak(*this)));
+ WEAK_DELEGATE_THIS(onMouseUp));
m_accEventLy->addEventHandler(WidgetEvent::MOUSE_MOVE,
- WEAK_DELEGATE(AcceptRejectWidget::onMouseMove, asWeak(*this)));
+ WEAK_DELEGATE_THIS(onMouseMove));
m_layout->setContent(*m_accEventLy,
impl::PART_SWL_ACCEPT_FINGER_EVENT);
build(*m_layout);
m_rejEventLy->addEventHandler(WidgetEvent::MOUSE_DOWN,
- WEAK_DELEGATE(AcceptRejectWidget::onMouseDown, asWeak(*this)));
+ WEAK_DELEGATE_THIS(onMouseDown));
m_rejEventLy->addEventHandler(WidgetEvent::MOUSE_UP,
- WEAK_DELEGATE(AcceptRejectWidget::onMouseUp, asWeak(*this)));
+ WEAK_DELEGATE_THIS(onMouseUp));
m_rejEventLy->addEventHandler(WidgetEvent::MOUSE_MOVE,
- WEAK_DELEGATE(AcceptRejectWidget::onMouseMove, asWeak(*this)));
+ WEAK_DELEGATE_THIS(onMouseMove));
m_layout->setContent(*m_rejEventLy,
impl::PART_SWL_REJECT_FINGER_EVENT);
if (m_lastMoveDistance >= impl::FINGER_STROKE_HALF_DIM) {
m_isFreezed = true;
- if (m_accTracer == img && m_accHandler) {
- m_accHandler();
- } else if (m_rejTracer == img && m_rejHandler) {
- m_rejHandler();
+ if (m_accTracer == img) {
+ if (const auto handler = m_accHandler.lock()) {
+ handler();
+ }
+ } else if (m_rejTracer == img ) {
+ if (const auto handler = m_rejHandler.lock()) {
+ handler();
+ }
}
}
}
m_isFreezed = true;
impl::resizeImage(*m_accTracer, impl::FINGER_STROKE_DIM);
- if (m_accHandler) {
- m_accHandler();
+ if (const auto handler = m_accHandler.lock()) {
+ handler();
}
}
m_isFreezed = true;
impl::resizeImage(*m_rejTracer, impl::FINGER_STROKE_DIM);
- if (m_rejHandler) {
- m_rejHandler();
+ if (const auto handler = m_rejHandler.lock()) {
+ handler();
}
}
if (m_rotaryClockwiseCount == 1) {
setAcceptPressedState();
m_expandTimeout = Timeout::create(impl::EXPAND_WAITING_TIMEOUT,
- WEAK_DELEGATE(AcceptRejectWidget::onAcceptExpandTimeout,
- asWeak(*this)));
+ WEAK_DELEGATE_THIS(onAcceptExpandTimeout));
} else if (m_rotaryClockwiseCount == 2) {
m_expandTimeout.reset();
impl::resizeImage(*m_accTracer, impl::FINGER_TRACER_DIM);
return EINA_TRUE;
}
- m_rotaryCounterClockwiseCount ++;
+ m_rotaryCounterClockwiseCount++;
if (m_rotaryCounterClockwiseCount == 1) {
setRejectPressedState();
m_expandTimeout = Timeout::create(impl::EXPAND_WAITING_TIMEOUT,
- WEAK_DELEGATE(AcceptRejectWidget::onRejectExpandTimeout,
- asWeak(*this)));
+ WEAK_DELEGATE_THIS(onRejectExpandTimeout));
} else if (m_rotaryCounterClockwiseCount == 2) {
m_expandTimeout.reset();
* @param[in] handler Accept event handler
* @return Reference to builder
*/
- Builder &setAcceptEventHandler(const NotiHandler &handler);
+ Builder &setAcceptEventHandler(NotiHandler handler);
/**
* @brief Sets reject event handler
* @param[in] handler Reject event handler
* @return Reference to builder
*/
- Builder &setRejectEventHandler(const NotiHandler &handler);
+ Builder &setRejectEventHandler(NotiHandler handler);
/**
* @brief Sets Accept button type
private:
AcceptRejectWidget(ucl::IRefCountObj &rc,
const ucl::LayoutSRef &layout,
- const NotiHandler &acceptHandler,
- const NotiHandler &rejectHandler,
+ NotiHandler acceptHandler,
+ NotiHandler rejectHandler,
AcceptButtonType acceptBtnType);
void prepare();
ucl::ElmWidget &widget);
private:
+ const NotiHandler m_accHandler;
+ const NotiHandler m_rejHandler;
+
ucl::Layout *m_layout;
- NotiHandler m_accHandler;
- NotiHandler m_rejHandler;
std::vector<ucl::ElmWidgetSRef> m_accBezelCueImg;
std::vector<ucl::ElmWidgetSRef> m_rejBezelCueImg;
{
}
- VolumeControl::Builder &VolumeControl::Builder::setInfoText(const TString &info)
+ VolumeControl::Builder &
+ VolumeControl::Builder::setInfoText(TString info)
{
- m_info = info;
+ m_info = std::move(info);
return *this;
}
}
VolumeControl::Builder &VolumeControl::Builder::setEventHandler(
- const EventHandler &handler)
+ EventHandler handler)
{
- m_handler = handler;
+ m_handler = std::move(handler);
return *this;
}
const TString &info,
int maxValue,
int curValue,
- const EventHandler &handler):
- Slider(rc, layout, maxValue, curValue),
- m_decreaseBtn(elm_button_add(*m_layout)),
- m_increaseBtn(elm_button_add(*m_layout)),
- m_handler(handler)
+ EventHandler handler):
+ Slider(rc, layout, maxValue, curValue),
+ m_handler(std::move(handler)),
+ m_decreaseBtn(elm_button_add(*m_layout)),
+ m_increaseBtn(elm_button_add(*m_layout))
{
prepare(info, curValue);
}
void VolumeControl::prepare(const TString &info, int curValue)
{
- m_layout->addEventHandler(WidgetEvent::SHOW, WEAK_DELEGATE(
- VolumeControl::onWidgetShowCb, asWeak(*this)));
- m_layout->addEventHandler(WidgetEvent::HIDE, WEAK_DELEGATE(
- VolumeControl::onWidgetHideCb, asWeak(*this)));
+ m_layout->addEventHandler(WidgetEvent::SHOW,
+ WEAK_DELEGATE_THIS(onWidgetShowCb));
+ m_layout->addEventHandler(WidgetEvent::HIDE,
+ WEAK_DELEGATE_THIS(onWidgetHideCb));
m_decreaseBtn.setStyle(impl::STYLE_BTN_MINUS);
- m_decreaseBtn.addEventHandler(BTN_CLICKED, WEAK_DELEGATE(
- VolumeControl::onDecreaseBtnClickedCb, asWeak(*this)));
+ m_decreaseBtn.addEventHandler(BTN_CLICKED,
+ WEAK_DELEGATE_THIS(onDecreaseBtnClickedCb));
m_layout->setContent(m_decreaseBtn, impl::PART_SWL_MINUS);
show(m_decreaseBtn);
m_increaseBtn.setStyle(impl::STYLE_BTN_PLUS);
- m_increaseBtn.addEventHandler(BTN_CLICKED, WEAK_DELEGATE(
- VolumeControl::onIncreaseBtnClickedCb, asWeak(*this)));
+ m_increaseBtn.addEventHandler(BTN_CLICKED,
+ WEAK_DELEGATE_THIS(onIncreaseBtnClickedCb));
m_layout->setContent(m_increaseBtn, impl::PART_SWL_PLUS);
show(m_increaseBtn);
isEnable ? enable(m_decreaseBtn) : disable(m_decreaseBtn);
}
- void VolumeControl::setEventHandler(
- const EventHandler &handler)
- {
- m_handler = handler;
- }
-
void VolumeControl::onDecreaseBtnClickedCb(Widget &widget, void *eventInfo)
{
- if (m_handler) {
- m_handler(Event::DECREASE);
+ if (const auto handler = m_handler.lock()) {
+ handler(Event::DECREASE);
}
}
void VolumeControl::onIncreaseBtnClickedCb(Widget &widget, void *eventInfo)
{
- if (m_handler) {
- m_handler(Event::INCREASE);
+ if (const auto handler = m_handler.lock()) {
+ handler(Event::INCREASE);
}
}
* @param[in] info Text to set
* @return Reference to builder
*/
- Builder &setInfoText(const ucl::TString &info);
+ Builder &setInfoText(ucl::TString info);
/**
* @brief Sets max volume value to display
* @param[in] handler Event handler
* @return Reference to builder
*/
- Builder &setEventHandler(const EventHandler &handler);
+ Builder &setEventHandler(EventHandler handler);
/**
* @brief Creates new instance of VolumeControl
*/
void setIncreaseBtnEnable(bool isEnable);
- /**
- * @brief Sets event handler
- * @param[in] handler Event handler
- */
- void setEventHandler(const EventHandler &handler);
-
/**
* @brief Gets Access object of decrease volume button
* @remark Use only for Screen Reader feature
const ucl::TString &info,
int maxValue,
int curValue,
- const EventHandler &handler);
+ EventHandler handler);
void prepare(const ucl::TString &info, int curValue);
void registerAccessObjectInformation();
private:
+ const EventHandler m_handler;
+
ucl::StyledWidget m_decreaseBtn;
ucl::StyledWidget m_increaseBtn;
- EventHandler m_handler;
ucl::ElmWidgetSRef m_valueTxtAo;
USER_C_INC_DIRS =
USER_INC_FILES =
## C++ Compiler
-USER_CPP_INC_DIRS = . ucl/include
+USER_CPP_INC_DIRS = /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/libxml2 /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/SDL2 /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/appcore/ /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/appcore-agent /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/appcore-watch /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/appfw /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/asp/ /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/aul/ /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/badge /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/base /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/cairo /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/calendar-service2 /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/call-manager /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/chromium-ewk /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/ckm /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/contacts-svc /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/content /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/context-service /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/csr /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/dali /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/dali-toolkit /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/dbus-1.0 /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/device /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/dlog /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/ecore-1 /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/ecore-buffer-1 /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/ecore-con-1 /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/ecore-evas-1 /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/ecore-file-1 /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/ecore-imf-1 /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/ecore-imf-evas-1 /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/ecore-input-1 /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/ecore-input-evas-1 /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/ecore-ipc-1 /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/ector-1 /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/e_dbus-1 /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/edje-1 /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/eet-1 /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/efl-1 /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/efl-extension /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/efreet-1 /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/eina-1 /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/eina-1/eina /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/eio-1 /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/eldbus-1 /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/elementary-1 /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/embryo-1 /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/emile-1 /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/eo-1 /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/eom /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/ethumb-1 /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/ethumb-client-1 /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/evas-1 /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/feedback /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/fontconfig /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/freetype2 /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/gio-unix-2.0 /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/glib-2.0 /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/harfbuzz /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/iotcon /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/json-glib-1.0 /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/location /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/maps /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/media /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/media-content /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/messaging /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/metadata-editor /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/minizip /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/msg-service /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/network /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/notification /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/nsd/ /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/phonenumber-utils /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/pkgmgr /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/rua/ /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/sensor /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/storage /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/system /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/telephony /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/telephony-client /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/tzsh /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/ug-1 /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/ui /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/vconf /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/vulkan /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/widget_service /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/widget_viewer_dali /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/widget_viewer_evas /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/include/yaca /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/lib/dbus-1.0/include /home/igor/TizenStudio/tizen-studio/tools/smart-build-interface/../../platforms/tizen-4.0/wearable/rootstraps/wearable-4.0-emulator.core.private/usr/lib/glib-2.0/include . ucl/include
USER_CPP_INC_FILES =
USER_INC_DIRS = $(USER_C_INC_DIRS) $(USER_CPP_INC_DIRS)
# EDC Resource Path
USER_EDCS_IMAGE_DIRS = ${OUTPUT_DIR} edc/images
-USER_EDCS_SOUND_DIRS =
-USER_EDCS_FONT_DIRS =
+USER_EDCS_SOUND_DIRS = ${OUTPUT_DIR} edc/sounds
+USER_EDCS_FONT_DIRS = ${OUTPUT_DIR} edc/fonts
# EDC Flags
USER_EXT_EDC_KEYS = EDC0
USER_EXT_EDC0_EDCS = res/edje/theme.edc
USER_EXT_EDC0_EDCS_IMAGE_DIRS = ${OUTPUT_DIR} edc/images
-USER_EXT_EDC0_EDCS_SOUND_DIRS =
-USER_EXT_EDC0_EDCS_FONT_DIRS =
+USER_EXT_EDC0_EDCS_SOUND_DIRS = ${OUTPUT_DIR} edc/sounds
+USER_EXT_EDC0_EDCS_FONT_DIRS = ${OUTPUT_DIR} edc/fonts
# Resource Filter
USER_RES_INCLUDE =
EventHandlerDelFunc delFunc);
~SysEventProvider();
- void addEventHandler(const SysEventHandler &handler);
- void delEventHandler(const SysEventHandler &handler);
+ void addEventHandler(SysEventHandler handler);
+ void delEventHandler(SysEventHandler::CDRef handler);
private:
int addEventHandler(app_event_handler_h *handler,
namespace ucl {
inline void SysEventProvider::addEventHandler(
- const SysEventHandler &handler)
+ SysEventHandler handler)
{
- m_event += handler;
+ m_event += std::move(handler);
}
inline void SysEventProvider::delEventHandler(
- const SysEventHandler &handler)
+ SysEventHandler::CDRef handler)
{
m_event -= handler;
}
public:
using WidgetItem::WidgetItem;
- void setPopHandler(const PopHandler &handler) const;
+ void setPopHandler(PopHandler handler) const;
void popTo() const;
void promote() const;
namespace ucl {
- inline void NaviItem::setPopHandler(const PopHandler &handler) const
+ inline void NaviItem::setPopHandler(const PopHandler handler) const
{
elm_naviframe_item_pop_cb_set(getIt(),
handler.getStubA(), handler.getData());
void addEventHandler(WidgetEvent event, WidgetEventHandler handler);
void addEventHandler(SmartEvent event, WidgetEventHandler handler);
- void delEventHandler(WidgetEvent event, WidgetEventHandler handler);
- void delEventHandler(SmartEvent event, WidgetEventHandler handler);
+ void delEventHandler(WidgetEvent event,
+ WidgetEventHandler::CDRef handler);
+ void delEventHandler(SmartEvent event,
+ WidgetEventHandler::CDRef handler);
void callEvent(SmartEvent event, void *eventInfo = nullptr);
Builder &setName(std::string value);
Builder &setTitle(std::string value);
- Builder &setSetIndicatorVisible(bool value);
+ Builder &setIndicatorVisible(bool value);
Builder &setRotations(std::vector<int> value);
Builder &setIsOwner(bool value);
bool isRotationsSupported() const;
void setRotations(const std::vector<int> &value);
+ void resizeToScreen();
void lower();
private:
return *this;
}
- inline Window::Builder &Window::Builder::setSetIndicatorVisible(
+ inline Window::Builder &Window::Builder::setIndicatorVisible(
const bool value)
{
m_isIndicatorVisible = value;
void Event<DELEGATE>::operator-=(const DELEGATE2 &delegate)
{
const auto it = std::find(
- m_delegates.begin(), m_delegates.end(), delegate);
- if (it != m_delegates.end()) {
+ m_delegates.rbegin(), m_delegates.rend(), delegate);
+ if (it != m_delegates.rend()) {
if (isLocked()) {
*it = {};
m_isFragmented = true;
} else {
- m_delegates.erase(it);
+ m_delegates.erase(it.base() - 1);
}
}
}
void Event<DELEGATE>::dispatch(ARGS &&...args)
{
dispatchImpl(
- [](const DELEGATE &delegate, ARGS &&...args)
+ [](const typename DELEGATE::LockDelegate &delegate, ARGS &&...args)
{
delegate(std::forward<ARGS>(args)...);
return true;
void Event<DELEGATE>::dispatchPred(PREDICATE &&pred, ARGS &&...args)
{
dispatchImpl(
- [&pred](const DELEGATE &delegate, ARGS &&...args)
+ [&pred](const typename DELEGATE::LockDelegate &delegate,
+ ARGS &&...args)
{
return impl::doInvokePred(std::forward<PREDICATE>(pred),
delegate, std::forward<ARGS>(args)...);
lock();
const auto size = m_delegates.size();
for (size_t i = 0; i < size; ++i) {
- const auto &delegate = m_delegates[i];
- if (delegate) {
+ if (const auto delegate = m_delegates[i].lock()) {
if (!doInvoke(delegate, std::forward<ARGS>(args)...)) {
break;
}
{
if (!(value == m_value)) {
m_value = value;
- if (m_onValueChanged) {
- m_onValueChanged();
+ if (const auto handler = m_onValueChanged.lock()) {
+ handler();
}
}
return *this;
Observable &operator=(Observable v) noexcept;
void addObserver(NotiHandler handler);
- void removeObserver(const NotiHandler &handler);
+ void removeObserver(NotiHandler::CDRef handler);
const T &getValue() const noexcept;
}
template <class T>
- inline void Observable<T>::removeObserver(const NotiHandler &handler)
+ inline void Observable<T>::removeObserver(NotiHandler::CDRef handler)
{
m_onValueChanged -= handler;
}
using TimeoutHandler = WeakDelegate<void(Timeout *sender)>;
public:
- static TimeoutSRef create(double timeoutSec,
- const TimeoutHandler &handler);
+ static TimeoutSRef create(double timeoutSec, TimeoutHandler handler);
bool isExpired() const;
private:
- Timeout(const TimeoutHandler &handler, Private);
+ Timeout(TimeoutHandler handler, Private);
~Timeout();
Result prepare(double timeoutSec);
Eina_Bool onTimer();
private:
+ const TimeoutHandler m_handler;
Ecore_Timer *m_timer;
- TimeoutHandler m_handler;
friend class ReffedObj<Timeout>;
};
Result prepare(GuiPresenter &parent, int flags = PF_DEFAULT);
Window &getWindow();
- bool isWindowReady() const;
+ WindowSRef getWindowRef();
void addDeactivatorException(const void *deactivator);
void setDeactivatorSink(const WidgetSRef &sink);
+ const void *getSelfDeactivator() const;
+ void activateSelf();
+ void deactivateSelf();
+
void sendActivate(Widget &sender);
void sendDeactivate(Widget &sender);
private:
std::unordered_set<const void *> m_deactivatorExceptions;
std::unordered_set<const void *> m_deactivators;
- WindowSRef m_window;
+ WindowWRef m_window;
WidgetSRef m_sink;
WidgetWRef m_parentSink;
bool m_hasBuildInSources;
protected IPicker {
public:
Result updateItem();
+ Result bringInItem(Elm_Genlist_Item_Scrollto_Type type =
+ ELM_GENLIST_ITEM_SCROLLTO_IN);
+ Result showItem(Elm_Genlist_Item_Scrollto_Type type =
+ ELM_GENLIST_ITEM_SCROLLTO_IN);
+
// IDisposable //
explicit operator bool() const noexcept;
protected:
- BaseDelegate(const DATA &data, StubA stubA) noexcept;
+ BaseDelegate(DATA data, StubA stubA) noexcept;
protected:
DATA m_data;
template <class R, class ...ARGS, class DATA>
inline BaseDelegate<R(ARGS...), DATA>::
- BaseDelegate(const DATA &data, StubA stubA) noexcept :
- m_data(data),
+ BaseDelegate(DATA data, StubA stubA) noexcept :
+ m_data(std::move(data)),
m_stubA(stubA)
{
}
StubB getStubB() const noexcept;
protected:
- BaseDelegate2(const DATA &data, StubA stubA, StubB stubB) noexcept;
+ BaseDelegate2(DATA data, StubA stubA, StubB stubB) noexcept;
private:
StubB m_stubB;
template <class R, class ...ARGS, class DATA>
inline BaseDelegate2<R(ARGS...), DATA>::
- BaseDelegate2(const DATA &data, StubA stubA, StubB stubB) noexcept :
- BaseDelegate<R(ARGS...), DATA>(data, stubA),
+ BaseDelegate2(DATA data, StubA stubA, StubB stubB) noexcept :
+ BaseDelegate<R(ARGS...), DATA>(std::move(data), stubA),
m_stubB(stubB)
{
}
template <class R, class ...ARGS>
class Delegate<R(ARGS...)> : public BaseDelegate<R(ARGS...), void *> {
+ public:
+ using LockDelegate = Delegate;
+
public:
using BaseDelegate<R(ARGS...), void *>::BaseDelegate;
+ LockDelegate lock() const;
+
R operator()(ARGS ...args) const;
template <class CLASS, R(CLASS::*METHOD)(ARGS...)>
static Delegate make(const CLASS *data) noexcept;
template <class CLASS, R(*FUNC)(CLASS &, ARGS...)>
- static Delegate makeA(CLASS &data) noexcept;
+ static Delegate makeA(CLASS *data) noexcept;
template <class CLASS, R(*FUNC)(ARGS..., CLASS &)>
- static Delegate makeB(CLASS &data) noexcept;
+ static Delegate makeB(CLASS *data) noexcept;
template <class HANDLE, R(*FUNC)(HANDLE, ARGS...)>
static Delegate makeA(HANDLE data) noexcept;
namespace ucl {
+ template <class R, class ...ARGS>
+ inline typename Delegate<R(ARGS...)>::LockDelegate
+ Delegate<R(ARGS...)>::lock() const
+ {
+ return *this;
+ }
+
template <class R, class ...ARGS>
inline R Delegate<R(ARGS...)>::operator()(ARGS ...args) const
{
template <class R, class ...ARGS>
template <class CLASS, R(*FUNC)(CLASS &, ARGS...)>
inline Delegate<R(ARGS...)>
- Delegate<R(ARGS...)>::makeA(CLASS &data) noexcept
+ Delegate<R(ARGS...)>::makeA(CLASS *data) noexcept
{
- return {const_cast<void *>(static_cast<const void *>(&data)),
+ return {const_cast<void *>(static_cast<const volatile void *>(data)),
Delegate::Cb::template stubA2A<CLASS, FUNC>};
}
template <class R, class ...ARGS>
template <class CLASS, R(*FUNC)(ARGS..., CLASS &)>
inline Delegate<R(ARGS...)>
- Delegate<R(ARGS...)>::makeB(CLASS &data) noexcept
+ Delegate<R(ARGS...)>::makeB(CLASS *data) noexcept
{
- return {const_cast<void *>(static_cast<const void *>(&data)),
+ return {const_cast<void *>(static_cast<const volatile void *>(data)),
Delegate::Cb::template stubA2B<CLASS, FUNC>};
}
inline Delegate<R(ARGS...)>
Delegate<R(ARGS...)>::makeA(const HANDLE data) noexcept
{
- return {const_cast<void *>(static_cast<const void *>(data)),
+ return {const_cast<void *>(static_cast<const volatile void *>(data)),
Delegate::Cb::template stubA2A<HANDLE, FUNC>};
}
inline Delegate<R(ARGS...)>
Delegate<R(ARGS...)>::makeB(const HANDLE data) noexcept
{
- return {const_cast<void *>(static_cast<const void *>(data)),
+ return {const_cast<void *>(static_cast<const volatile void *>(data)),
Delegate::Cb::template stubA2B<HANDLE, FUNC>};
}
template <class R, class ...ARGS>
class Delegate2<R(ARGS...)> : public BaseDelegate2<R(ARGS...), void *> {
+ public:
+ using LockDelegate = Delegate2;
+
public:
using BaseDelegate2<R(ARGS...), void *>::BaseDelegate2;
+ LockDelegate lock() const;
+
R operator()(ARGS ...args) const;
template <class CLASS, R(CLASS::*METHOD)(ARGS...)>
static Delegate2 make(const CLASS *data) noexcept;
template <class CLASS, R(*FUNC)(CLASS &, ARGS...)>
- static Delegate2 makeA(CLASS &data) noexcept;
+ static Delegate2 makeA(CLASS *data) noexcept;
template <class CLASS, R(*FUNC)(ARGS..., CLASS &)>
- static Delegate2 makeB(CLASS &data) noexcept;
+ static Delegate2 makeB(CLASS *data) noexcept;
template <class HANDLE, R(*FUNC)(HANDLE, ARGS...)>
static Delegate2 makeA(HANDLE data) noexcept;
namespace ucl {
+ template <class R, class ...ARGS>
+ inline typename Delegate2<R(ARGS...)>::LockDelegate
+ Delegate2<R(ARGS...)>::lock() const
+ {
+ return *this;
+ }
+
template <class R, class ...ARGS>
inline R Delegate2<R(ARGS...)>::operator()(ARGS ...args) const
{
template <class R, class ...ARGS>
template <class CLASS, R(*FUNC)(CLASS &, ARGS...)>
inline Delegate2<R(ARGS...)>
- Delegate2<R(ARGS...)>::makeA(CLASS &data) noexcept
+ Delegate2<R(ARGS...)>::makeA(CLASS *data) noexcept
{
- return {const_cast<void *>(static_cast<const void *>(&data)),
+ return {const_cast<void *>(static_cast<const volatile void *>(data)),
Delegate2::Cb::template stubA2A<CLASS, FUNC>,
Delegate2::Cb::template stubB2A<CLASS, FUNC>};
}
template <class R, class ...ARGS>
template <class CLASS, R(*FUNC)(ARGS..., CLASS &)>
inline Delegate2<R(ARGS...)>
- Delegate2<R(ARGS...)>::makeB(CLASS &data) noexcept
+ Delegate2<R(ARGS...)>::makeB(CLASS *data) noexcept
{
- return {const_cast<void *>(static_cast<const void *>(&data)),
+ return {const_cast<void *>(static_cast<const volatile void *>(data)),
Delegate2::Cb::template stubA2B<CLASS, FUNC>,
Delegate2::Cb::template stubB2B<CLASS, FUNC>};
}
inline Delegate2<R(ARGS...)>
Delegate2<R(ARGS...)>::makeA(const HANDLE data) noexcept
{
- return {const_cast<void *>(static_cast<const void *>(data)),
+ return {const_cast<void *>(static_cast<const volatile void *>(data)),
Delegate2::Cb::template stubA2A<HANDLE, FUNC>,
Delegate2::Cb::template stubB2A<HANDLE, FUNC>};
}
inline Delegate2<R(ARGS...)>
Delegate2<R(ARGS...)>::makeB(const HANDLE data) noexcept
{
- return {const_cast<void *>(static_cast<const void *>(data)),
+ return {const_cast<void *>(static_cast<const volatile void *>(data)),
Delegate2::Cb::template stubA2B<HANDLE, FUNC>,
Delegate2::Cb::template stubB2B<HANDLE, FUNC>};
}
// Automatic function signature detection for a specific type //
- template <template <typename ...> class T, class TAG, class FUNC>
+ template <template <typename ...> class T, class FUNC>
struct AutoFuncSig;
template <template <typename ...> class T,
- class R, class CLASS, class ...ARGS>
- struct AutoFuncSig<T, void *, R(CLASS::*)(ARGS...)> {
+ class R, class CLASS, class ...ARGS>
+ struct AutoFuncSig<T, R(CLASS::*)(ARGS...)> {
using Data = CLASS;
using Type = T<R(ARGS...)>;
+
+ template <R(CLASS::*METHOD)(ARGS...), class DATA>
+ static Type makeDelegate(DATA &&data) noexcept
+ {
+ return Type::template make<CLASS, METHOD>(std::forward<DATA>(data));
+ }
};
template <template <typename ...> class T,
class CLASS, class R, class ...ARGS>
- struct AutoFuncSig<T, void *, R(CLASS::*)(ARGS...) const> {
+ struct AutoFuncSig<T, R(CLASS::*)(ARGS...) const> {
using Data = CLASS;
using Type = T<R(ARGS...)>;
+
+ template <R(CLASS::*METHOD)(ARGS...) const, class DATA>
+ static Type makeDelegate(DATA &&data) noexcept
+ {
+ return Type::template make<CLASS, METHOD>(std::forward<DATA>(data));
+ }
};
template <template <typename ...> class T,
class CLASS, class R, class ...ARGS>
- struct AutoFuncSig<T, void *, R(*)(CLASS &, ARGS...)> {
+ struct AutoFuncSig<T, R(*)(CLASS &, ARGS...)> {
using Data = CLASS;
using Type = T<R(ARGS...)>;
+
+ template <R(*FUNC)(CLASS &, ARGS...), class DATA>
+ static Type makeDelegate(DATA &&data) noexcept
+ {
+ return Type::template makeA<CLASS, FUNC>(std::forward<DATA>(data));
+ }
};
template <template <typename ...> class T,
class HANDLE, class R, class ...ARGS>
- struct AutoFuncSig<T, void *, R(*)(HANDLE, ARGS...)> {
+ struct AutoFuncSig<T, R(*)(HANDLE, ARGS...)> {
using Data = HANDLE;
using Type = T<R(ARGS...)>;
+ using TypeV = T<R(HANDLE, ARGS...)>;
+
+ template <R(*FUNC)(HANDLE, ARGS...), class DATA>
+ static Type makeDelegate(DATA &&data) noexcept
+ {
+ return Type::template makeA<HANDLE, FUNC>(std::forward<DATA>(data));
+ }
+
+ template <R(*FUNC)(HANDLE, ARGS...)>
+ static TypeV makeDelegate() noexcept
+ {
+ return TypeV::template make<FUNC>();
+ }
};
- template <template <typename ...> class T,
- class R, class ...ARGS>
- struct AutoFuncSig<T, void, R(*)(ARGS...)> {
- using Type = T<R(ARGS...)>;
+ template <template <typename ...> class T, class R>
+ struct AutoFuncSig<T, R(*)()> {
+ using TypeV = T<R()>;
+
+ template <R(*FUNC)()>
+ static TypeV makeDelegate() noexcept
+ {
+ return TypeV::template make<FUNC>();
+ }
};
// Relation operators //
// Helper macro to simplify use of AutoFuncSig template
#define _UCL_AFS(DELEGATE, FUNC) \
- ::ucl::AutoFuncSig<DELEGATE, void *, decltype(&FUNC)>
-#define _UCL_AFS_V(DELEGATE, FUNC) \
- ::ucl::AutoFuncSig<DELEGATE, void, decltype(&FUNC)>
+ ::ucl::AutoFuncSig<DELEGATE, decltype(&FUNC)>
// Helper macro to automatically generate different delegate objects //
-#define _UCL_DELEGATE(DELEGATE, FUNC, DATA) _UCL_AFS(DELEGATE, FUNC)::Type:: \
- template make<typename _UCL_AFS(DELEGATE, FUNC)::Data, &FUNC>(DATA)
-
-#define _UCL_DELEGATE_A(DELEGATE, FUNC, DATA) _UCL_AFS(DELEGATE, FUNC)::Type:: \
- template makeA<typename _UCL_AFS(DELEGATE, FUNC)::Data, &FUNC>(DATA)
-
-#define _UCL_DELEGATE_V(DELEGATE, FUNC) _UCL_AFS_V(DELEGATE, FUNC)::Type:: \
- template make<&FUNC>()
+#define _UCL_DELEGATE(DELEGATE, FUNC, DATA...) \
+ _UCL_AFS(DELEGATE, FUNC)::template makeDelegate<&FUNC>(DATA)
// Helper macro to automatically generate Delegate objects //
-#define UCL_DELEGATE(FUNC, DATA) _UCL_DELEGATE(::ucl::Delegate, FUNC, DATA)
-#define UCL_DELEGATE_A(FUNC, DATA) _UCL_DELEGATE_A(::ucl::Delegate, FUNC, DATA)
-#define UCL_DELEGATE_V(FUNC) _UCL_DELEGATE_V(::ucl::Delegate, FUNC)
+#define UCL_DELEGATE(FUNC, DATA...) _UCL_DELEGATE( \
+ ::ucl::Delegate, FUNC, ##DATA)
+
+#define UCL_DELEGATE_THIS(FUNC_NAME) UCL_DELEGATE( \
+ std::remove_pointer<decltype(this)>::type::FUNC_NAME, this)
// Helper macro to automatically generate Delegate2 objects //
-#define UCL_DELEGATE2(FUNC, DATA) _UCL_DELEGATE(::ucl::Delegate2, FUNC, DATA)
-#define UCL_DELEGATE2_A(FUNC, DATA) \
- _UCL_DELEGATE_A(::ucl::Delegate2, FUNC, DATA)
-#define UCL_DELEGATE2_V(FUNC) _UCL_DELEGATE_V(::ucl::Delegate2, FUNC)
+#define UCL_DELEGATE2(FUNC, DATA...) _UCL_DELEGATE( \
+ ::ucl::Delegate2, FUNC, ##DATA)
+
+#define UCL_DELEGATE2_THIS(FUNC_NAME) UCL_DELEGATE2( \
+ std::remove_pointer<decltype(this)>::type::FUNC_NAME, this)
// Helper macro to automatically generate Callback stubs //
#define UCL_CALLBACK_B2A(FUNC) &_UCL_AFS(::ucl::Callback, FUNC)::Type:: \
template stubB2A<typename _UCL_AFS(::ucl::Callback, FUNC)::Data, &FUNC>
-#define UCL_CALLBACK_A2V(FUNC) &_UCL_AFS_V(::ucl::Callback, FUNC)::Type:: \
+#define UCL_CALLBACK_A2V(FUNC) &_UCL_AFS(::ucl::Callback, FUNC)::TypeV:: \
template stubA2V<&FUNC>
-#define UCL_CALLBACK_B2V(FUNC) &_UCL_AFS_V(::ucl::Callback, FUNC)::Type:: \
+#define UCL_CALLBACK_B2V(FUNC) &_UCL_AFS(::ucl::Callback, FUNC)::TypeV:: \
template stubB2V<&FUNC>
#endif // __UCL_UTIL_DELEGATION_MACRO_H__
// Helper macro to automatically generate Delegate objects //
-#define DELEGATE(FUNC, DATA) UCL_DELEGATE(FUNC, DATA)
-#define DELEGATE_A(FUNC, DATA) UCL_DELEGATE_A(FUNC, DATA)
-#define DELEGATE_V(FUNC) UCL_DELEGATE_V(FUNC)
+#define DELEGATE(FUNC, DATA...) UCL_DELEGATE(FUNC, ##DATA)
+
+#define DELEGATE_THIS(FUNC_NAME) UCL_DELEGATE_THIS(FUNC_NAME)
// Helper macro to automatically generate Delegate2 objects //
-#define DELEGATE2(FUNC, DATA) UCL_DELEGATE2(FUNC, DATA)
-#define DELEGATE2_A(FUNC, DATA) UCL_DELEGATE2_A(FUNC, DATA)
-#define DELEGATE2_V(FUNC) UCL_DELEGATE2_V(FUNC)
+#define DELEGATE2(FUNC, DATA...) UCL_DELEGATE2(FUNC, ##DATA)
+
+#define DELEGATE2_THIS(FUNC_NAME) UCL_DELEGATE2_THIS(FUNC_NAME)
// Helper macro to automatically generate Callback stubs //
template <class T>
inline T *WeakRef<T>::getUnsafePtr() const noexcept
{
- return (operator bool() ? this->m_ptr : nullptr);
+ return this->m_ptr;
}
template <class T>
namespace himpl {
+ template <class T>
+ struct IsShared : std::false_type {};
+ template <class T>
+ struct IsShared<SharedRef<T>> : std::true_type {};
+ template <class T>
+ struct IsShared<WeakRef<T>> : std::true_type {};
+
template <class T, class = typename std::enable_if<
- !std::is_base_of<BaseRef<typename T::Type>, T>::value>::type>
+ !IsShared<T>::value>::type>
inline const T &getCmpPtr(const T &ptr) noexcept
{
return ptr;
}
template <class T, class U, class = typename std::enable_if<
- std::is_base_of<BaseRef<typename T::Type>, T>::value ||
- std::is_base_of<BaseRef<typename U::Type>, U>::value>::type>
+ himpl::IsShared<T>::value || himpl::IsShared<U>::value>::type>
inline bool operator==(const T &lhs, const U &rhs) noexcept
{
return (himpl::getCmpPtr(lhs) == himpl::getCmpPtr(rhs));
}
template <class T, class U, class = typename std::enable_if<
- std::is_base_of<BaseRef<typename T::Type>, T>::value ||
- std::is_base_of<BaseRef<typename U::Type>, U>::value>::type>
+ himpl::IsShared<T>::value || himpl::IsShared<U>::value>::type>
inline bool operator!=(const T &lhs, const U &rhs) noexcept
{
return (himpl::getCmpPtr(lhs) != himpl::getCmpPtr(rhs));
}
template <class T, class U, class = typename std::enable_if<
- std::is_base_of<BaseRef<typename T::Type>, T>::value ||
- std::is_base_of<BaseRef<typename U::Type>, U>::value>::type>
+ himpl::IsShared<T>::value || himpl::IsShared<U>::value>::type>
inline bool operator<(const T &lhs, const U &rhs) noexcept
{
return (himpl::getCmpPtr(lhs) < himpl::getCmpPtr(rhs));
}
template <class T, class U, class = typename std::enable_if<
- std::is_base_of<BaseRef<typename T::Type>, T>::value ||
- std::is_base_of<BaseRef<typename U::Type>, U>::value>::type>
+ himpl::IsShared<T>::value || himpl::IsShared<U>::value>::type>
inline bool operator<=(const T &lhs, const U &rhs) noexcept
{
return (himpl::getCmpPtr(lhs) <= himpl::getCmpPtr(rhs));
}
template <class T, class U, class = typename std::enable_if<
- std::is_base_of<BaseRef<typename T::Type>, T>::value ||
- std::is_base_of<BaseRef<typename U::Type>, U>::value>::type>
+ himpl::IsShared<T>::value || himpl::IsShared<U>::value>::type>
inline bool operator>(const T &lhs, const U &rhs) noexcept
{
return (himpl::getCmpPtr(lhs) > himpl::getCmpPtr(rhs));
}
template <class T, class U, class = typename std::enable_if<
- std::is_base_of<BaseRef<typename T::Type>, T>::value ||
- std::is_base_of<BaseRef<typename U::Type>, U>::value>::type>
+ himpl::IsShared<T>::value || himpl::IsShared<U>::value>::type>
inline bool operator>=(const T &lhs, const U &rhs) noexcept
{
return (himpl::getCmpPtr(lhs) >= himpl::getCmpPtr(rhs));
}
template <class T, class = typename std::enable_if<
- std::is_base_of<BaseRef<typename T::Type>, T>::value>::type>
+ himpl::IsShared<T>::value>::type>
inline bool operator==(const T &lhs, std::nullptr_t rhs) noexcept
{
return !lhs;
}
template <class T, class = typename std::enable_if<
- std::is_base_of<BaseRef<typename T::Type>, T>::value>::type>
+ himpl::IsShared<T>::value>::type>
bool operator==(std::nullptr_t lhs, const T &rhs) noexcept
{
return !rhs;
}
template <class T, class = typename std::enable_if<
- std::is_base_of<BaseRef<typename T::Type>, T>::value>::type>
+ himpl::IsShared<T>::value>::type>
bool operator!=(const T &lhs, std::nullptr_t rhs) noexcept
{
return lhs;
}
template <class T, class = typename std::enable_if<
- std::is_base_of<BaseRef<typename T::Type>, T>::value>::type>
+ himpl::IsShared<T>::value>::type>
bool operator!=(std::nullptr_t lhs, const T &rhs) noexcept
{
return rhs;
template <class R, class ...ARGS>
class WeakDelegate<R(ARGS...)> :
public BaseDelegate<R(ARGS...), WeakRef<void>> {
+ public:
+ using CDRef = const Delegate<R(ARGS...)> &;
+
+ class LockDelegate {
+ public:
+ explicit operator bool() const noexcept;
+ R operator()(ARGS ...args) const;
+ private:
+ LockDelegate(SharedRef<void> data,
+ typename WeakDelegate::StubA stubA) noexcept;
+ private:
+ SharedRef<void> m_data;
+ typename WeakDelegate::StubA m_stubA;
+ friend class WeakDelegate;
+ };
+
public:
using BaseDelegate<R(ARGS...), WeakRef<void>>::BaseDelegate;
- R operator()(ARGS ...args) const;
+ LockDelegate lock() const;
template <class CLASS, R(CLASS::*METHOD)(ARGS...)>
- static WeakDelegate make(const WeakRef<CLASS> &data) noexcept;
+ static WeakDelegate make(WeakRef<CLASS> data) noexcept;
template <class CLASS, R(CLASS::*METHOD)(ARGS...) const>
- static WeakDelegate make(const WeakRef<const CLASS> &data) noexcept;
+ static WeakDelegate make(WeakRef<const CLASS> data) noexcept;
};
}
namespace ucl {
+ // WeakDelegate<R(ARGS...)>::Lock //
+
+ template <class R, class ...ARGS>
+ inline WeakDelegate<R(ARGS...)>::LockDelegate::LockDelegate(
+ SharedRef<void> data,
+ const typename WeakDelegate::StubA stubA) noexcept :
+ m_data(std::move(data)),
+ m_stubA(stubA)
+ {
+ }
+
template <class R, class ...ARGS>
- inline R WeakDelegate<R(ARGS...)>::operator()(ARGS ...args) const
+ inline WeakDelegate<R(ARGS...)>::LockDelegate::
+ operator bool() const noexcept
{
- const auto tmp = this->m_data.lock();
- if (tmp) {
- return this->m_stubA(tmp.get(), std::forward<ARGS>(args)...);
- }
- return R();
+ return !!m_data;
+ }
+
+ template <class R, class ...ARGS>
+ inline R WeakDelegate<R(ARGS...)>::LockDelegate::
+ operator()(ARGS ...args) const
+ {
+ return m_stubA(m_data.get(), std::forward<ARGS>(args)...);
+ }
+
+ // WeakDelegate<R(ARGS...)> //
+
+ template <class R, class ...ARGS>
+ typename WeakDelegate<R(ARGS...)>::LockDelegate
+ WeakDelegate<R(ARGS...)>::lock() const
+ {
+ return {this->m_data.lock(), this->m_stubA};
}
template <class R, class ...ARGS>
template <class CLASS, R(CLASS::*METHOD)(ARGS...)>
inline WeakDelegate<R(ARGS...)> WeakDelegate<R(ARGS...)>::make(
- const WeakRef<CLASS> &data) noexcept
+ WeakRef<CLASS> data) noexcept
{
- return {data, WeakDelegate::Cb::template stubA<CLASS, METHOD>};
+ return {std::move(data),
+ WeakDelegate::Cb::template stubA<CLASS, METHOD>};
}
template <class R, class ...ARGS>
template <class CLASS, R(CLASS::*METHOD)(ARGS...) const>
inline WeakDelegate<R(ARGS...)> WeakDelegate<R(ARGS...)>::make(
- const WeakRef<const CLASS> &data) noexcept
+ WeakRef<const CLASS> data) noexcept
{
- return {constRefCast<CLASS>(data),
+ return {constRefCast<CLASS>(std::move(data)),
WeakDelegate::Cb::template stubA<CLASS, METHOD>};
}
}
#ifndef __UCL_UTIL_SMART_DELEGATION_MACRO_H__
#define __UCL_UTIL_SMART_DELEGATION_MACRO_H__
-#define UCL_WEAK_DELEGATE(FUNC, DATA) \
- _UCL_DELEGATE(::ucl::WeakDelegate, FUNC, DATA)
+#define UCL_WEAK_DELEGATE(FUNC, DATA) _UCL_DELEGATE( \
+ ::ucl::WeakDelegate, FUNC, DATA)
+
+#define UCL_WEAK_DELEGATE_THIS(FUNC_NAME) UCL_WEAK_DELEGATE( \
+ std::remove_pointer<decltype(this)>::type::FUNC_NAME, asWeak(*this))
#endif // __UCL_UTIL_SMART_DELEGATION_MACRO_H__
#define WEAK_DELEGATE(FUNC, DATA) UCL_WEAK_DELEGATE(FUNC, DATA)
+#define WEAK_DELEGATE_THIS(FUNC_NAME) UCL_WEAK_DELEGATE_THIS(FUNC_NAME)
+
#endif // __UCL_UTIL_SMART_DELEGATION_SHORT_MACRO_H__
{
m_instance.reset();
m_instanceMgr.setSysEventProvider(nullptr);
- m_window.reset();
+ if (m_window) {
+ m_window->setIsOwner(false);
+ m_window->markForDeletion();
+ m_window.reset();
+ }
}
void UIApp::onPause()
StyledWidget(&rc, eo),
m_isInTransition(false)
{
- addEventHandler(NAVI_TRANSITION_FINISHED, WEAK_DELEGATE(
- Naviframe::onTransitionFinished, asWeak(*this)));
+ addEventHandler(NAVI_TRANSITION_FINISHED,
+ WEAK_DELEGATE_THIS(onTransitionFinished));
}
void Naviframe::setInTransition(const bool inTransition)
class Widget::EventProxy : protected NonCopyable {
public:
EventProxy(Widget &widget, const WidgetEvent event,
- const WidgetEventHandler handler) :
+ WidgetEventHandler handler) :
m_widget(widget),
- m_handler(handler),
+ m_handler(std::move(handler)),
m_type(static_cast<Evas_Callback_Type>(event))
{
evas_object_event_callback_add(m_widget.getEo(),
}
EventProxy(Widget &widget, const SmartEvent event,
- const WidgetEventHandler handler) :
+ WidgetEventHandler handler) :
m_widget(widget),
m_smartEvent(event),
- m_handler(handler),
+ m_handler(std::move(handler)),
m_type(impl::WIDGET_EVENT_SMART)
{
evas_object_smart_callback_add(m_widget.getEo(),
m_selfIt = it;
}
- bool operator==(const std::pair<WidgetEvent, WidgetEventHandler> &rhs)
+ bool operator==(
+ const std::pair<WidgetEvent, WidgetEventHandler::CDRef> &rhs)
{
return ((m_type == static_cast<Evas_Callback_Type>(rhs.first)) &&
(m_handler == rhs.second));
}
- bool operator==(const std::pair<SmartEvent, WidgetEventHandler> &rhs)
+ bool operator==(
+ const std::pair<SmartEvent, WidgetEventHandler::CDRef> &rhs)
{
return ((m_type == impl::WIDGET_EVENT_SMART) &&
(m_handler == rhs.second) &&
void dispatchEvent(void *const event_info)
{
- if (m_handler) {
- m_handler(m_widget, event_info);
+ if (const auto handler = m_handler.lock()) {
+ handler(m_widget, event_info);
} else {
m_widget.delEventProxy(m_selfIt);
}
}
void Widget::addEventHandler(const WidgetEvent event,
- const WidgetEventHandler handler)
+ WidgetEventHandler handler)
{
- m_eventProxies.emplace_front(*this, event, handler);
+ m_eventProxies.emplace_front(*this, event, std::move(handler));
m_eventProxies.front().setSelfIt(m_eventProxies.begin());
}
void Widget::addEventHandler(const SmartEvent event,
- const WidgetEventHandler handler)
+ WidgetEventHandler handler)
{
if (strncmp(event.name, UCL_SMART_FWD, strlen(UCL_SMART_FWD)) == 0) {
if (!ensureFwdEvent(event)) {
"Event is not supported: %s;", event.name);
}
}
- m_eventProxies.emplace_front(*this, event, handler);
+ m_eventProxies.emplace_front(*this, event, std::move(handler));
m_eventProxies.front().setSelfIt(m_eventProxies.begin());
}
void Widget::delEventHandler(const WidgetEvent event,
- const WidgetEventHandler handler)
+ WidgetEventHandler::CDRef handler)
{
delEventProxy(std::find(m_eventProxies.begin(), m_eventProxies.end(),
std::make_pair(event, handler)));
}
void Widget::delEventHandler(const SmartEvent event,
- const WidgetEventHandler handler)
+ WidgetEventHandler::CDRef handler)
{
delEventProxy(std::find(m_eventProxies.begin(), m_eventProxies.end(),
std::make_pair(event, handler)));
return result;
}
+
+ // Window //
+
+ void Window::resizeToScreen()
+ {
+ int w = 0;
+ int h = 0;
+ getScreenSize(&w, &h);
+ if ((w > 0) && (h > 0)) {
+ setGeometry(0, 0, w, h);
+ m_conform.setGeometry(0, 0, w, h);
+ }
+ }
}
namespace ucl {
- TimeoutSRef Timeout::create(double timeoutSec,
- const TimeoutHandler &handler)
+ TimeoutSRef Timeout::create(double timeoutSec, TimeoutHandler handler)
{
- auto result = makeShared<Timeout>(handler, PRIVATE);
+ auto result = makeShared<Timeout>(std::move(handler), PRIVATE);
FAIL_RETURN_VALUE(result->prepare(timeoutSec), {},
"result->prepare() failed!");
return result;
}
- Timeout::Timeout(const TimeoutHandler &handler, Private) :
- m_timer(nullptr),
- m_handler(handler)
+ Timeout::Timeout(TimeoutHandler handler, Private) :
+ m_handler(std::move(handler)),
+ m_timer(nullptr)
{
}
{
const auto self = static_cast<Timeout *>(data);
self->m_timer = nullptr;
- if (self->m_handler) {
- self->m_handler(self);
+ if (const auto handler = self->m_handler.lock()) {
+ handler(self);
}
return ECORE_CALLBACK_CANCEL;
},
if (const auto parentSink = m_parentSink.lock()) {
delDeactivatorSource(*parentSink);
}
- } else if (m_window) {
- delDeactivatorSource(*m_window);
+ } else if (const auto window = getWindowRef()) {
+ delDeactivatorSource(*window);
}
}
}
Result GuiPresenter::prepare(ElmWidget &widget, const int flags)
{
- m_window = asShared(widget.getWindow());
- if (!m_window) {
- LOG_RETURN(RES_FAIL, "m_window is NULL!");
+ const auto window = asShared(widget.getWindow());
+ if (!window) {
+ LOG_RETURN(RES_FAIL, "window is NULL!");
}
if (flags & PF_ADD_DEACTIVATOR_SOURCES) {
- addDeactivatorSource(*m_window);
+ addDeactivatorSource(*window);
m_hasBuildInSources = true;
}
addDeactivatorException(getObjPtr());
}
+ m_window = window;
m_isPrepared = true;
return RES_OK;
Result GuiPresenter::prepare(GuiPresenter &parent, const int flags)
{
+ const auto window = parent.getWindowRef();
+ if (!window) {
+ LOG_RETURN(RES_FAIL, "window is NULL!");
+ }
+
if (flags & PF_ADD_DEACTIVATOR_SOURCES) {
if (!parent.m_sink) {
addDeactivatorException(getObjPtr());
}
- m_window = parent.m_window;
+ m_window = window;
m_isChild = true;
m_isPrepared = true;
Window &GuiPresenter::getWindow()
{
- UCL_ASSERT(isWindowReady(), "m_window is NULL!");
- return *m_window;
+ const auto window = getWindowRef();
+ UCL_ASSERT(window, "window is NULL!");
+ // Since GUI is single threaded Window instance will not be deleted
+ // on "window" shared reference destroy
+ return *window;
}
- bool GuiPresenter::isWindowReady() const
+ WindowSRef GuiPresenter::getWindowRef()
{
- return !!m_window;
+ return m_window.lock();
}
void GuiPresenter::addDeactivatorException(const void *const deactivator)
m_sink = sink;
}
+ const void *GuiPresenter::getSelfDeactivator() const
+ {
+ // Just return some unknown pointer that will never be aliaced
+ return &m_isPrepared;
+ }
+
+ void GuiPresenter::activateSelf()
+ {
+ activateByImpl({getSelfDeactivator(), false});
+ }
+
+ void GuiPresenter::deactivateSelf()
+ {
+ deactivateByImpl({getSelfDeactivator(), false});
+ }
+
void GuiPresenter::sendActivate(Widget &sender)
{
sendDeactivator(sender, impl::ACTIVATE_BY, getObjPtr());
void GuiPresenter::broadcastDeactivator(const SmartEvent event,
const void *const deactivator)
{
- sendDeactivatorInfo(*m_window, event, {deactivator, true});
+ if (const auto window = getWindowRef()) {
+ sendDeactivatorInfo(*window, event, {deactivator, true});
+ }
}
void GuiPresenter::sendDeactivatorInfo(Widget &sender,
void GuiPresenter::addDeactivatorSource(Widget &source)
{
- source.addEventHandler(impl::ACTIVATE_BY, WEAK_DELEGATE(
- GuiPresenter::onActivateBySmart, asWeak(*this)));
- source.addEventHandler(impl::DEACTIVATE_BY, WEAK_DELEGATE(
- GuiPresenter::onDeactivateBySmart, asWeak(*this)));
+ source.addEventHandler(
+ impl::ACTIVATE_BY, WEAK_DELEGATE_THIS(onActivateBySmart));
+ source.addEventHandler(
+ impl::DEACTIVATE_BY, WEAK_DELEGATE_THIS(onDeactivateBySmart));
}
void GuiPresenter::delDeactivatorSource(Widget &source)
{
- source.delEventHandler(impl::ACTIVATE_BY, WEAK_DELEGATE(
- GuiPresenter::onActivateBySmart, asWeak(*this)));
- source.delEventHandler(impl::DEACTIVATE_BY, WEAK_DELEGATE(
- GuiPresenter::onDeactivateBySmart, asWeak(*this)));
+ source.delEventHandler(
+ impl::ACTIVATE_BY, DELEGATE_THIS(onActivateBySmart));
+ source.delEventHandler(
+ impl::DEACTIVATE_BY, DELEGATE_THIS(onDeactivateBySmart));
}
void GuiPresenter::activateByImpl(const DeactivatorInfo &info)
evas_object_repeat_events_set(*check, EINA_FALSE);
evas_object_propagate_events_set(*check, EINA_FALSE);
- check->addEventHandler(impl::CHECK_CHANGED, WEAK_DELEGATE(
- ListItemPresenter::onPickCheckChanged, asWeak(*this)));
+ check->addEventHandler(
+ impl::CHECK_CHANGED, WEAK_DELEGATE_THIS(onPickCheckChanged));
return check;
}
return RES_OK;
}
+ Result ListItemPresenter::bringInItem(Elm_Genlist_Item_Scrollto_Type type)
+ {
+ if (!m_item) {
+ LOG_RETURN(RES_INVALID_OPERATION, "m_item is NULL!");
+ }
+
+ elm_genlist_item_bring_in(m_item, type);
+
+ return RES_OK;
+ }
+
+ Result ListItemPresenter::showItem(Elm_Genlist_Item_Scrollto_Type type)
+ {
+ if (!m_item) {
+ LOG_RETURN(RES_INVALID_OPERATION, "m_item is NULL!");
+ }
+
+ elm_genlist_item_show(m_item, type);
+
+ return RES_OK;
+ }
+
Result ListItemPresenter::updateItemStyle(const ElmStyle newItemStyle)
{
if (!m_item) {
void ListPresenter::registerItemEvents(int flags)
{
- m_genlist->addEventHandler(impl::ITEM_SELECTED, WEAK_DELEGATE(
- ListPresenter::onItemSelected, asWeak(*this)));
+ m_genlist->addEventHandler(impl::ITEM_SELECTED,
+ WEAK_DELEGATE_THIS(onItemSelected));
if (flags & FLAG_NOTIFY_REALIZED) {
- m_genlist->addEventHandler(impl::ITEM_REALIZED, WEAK_DELEGATE(
- ListPresenter::onItemRealized, asWeak(*this)));
+ m_genlist->addEventHandler(impl::ITEM_REALIZED,
+ WEAK_DELEGATE_THIS(onItemRealized));
}
if (flags & FLAG_NOTIFY_UNREALIZED) {
- m_genlist->addEventHandler(impl::ITEM_UNREALIZED, WEAK_DELEGATE(
- ListPresenter::onItemUnrealized, asWeak(*this)));
+ m_genlist->addEventHandler(impl::ITEM_UNREALIZED,
+ WEAK_DELEGATE_THIS(onItemUnrealized));
}
if (flags & FLAG_NOTIFY_HIGHLIGHTED) {
- m_genlist->addEventHandler(impl::ITEM_HIGHLIGHTED, WEAK_DELEGATE(
- ListPresenter::onItemHighlighted, asWeak(*this)));
+ m_genlist->addEventHandler(impl::ITEM_HIGHLIGHTED,
+ WEAK_DELEGATE_THIS(onItemHighlighted));
}
if (flags & FLAG_NOTIFY_UNHIGHLIGHTED) {
- m_genlist->addEventHandler(impl::ITEM_UNHIGHLIGHTED, WEAK_DELEGATE(
- ListPresenter::onItemUnhighlighted, asWeak(*this)));
+ m_genlist->addEventHandler(impl::ITEM_UNHIGHLIGHTED,
+ WEAK_DELEGATE_THIS(onItemUnhighlighted));
}
if (flags & FLAG_NOTIFY_LONGPRESSED) {
- m_genlist->addEventHandler(impl::ITEM_LONGPRESSED, WEAK_DELEGATE(
- ListPresenter::onItemLongpressed, asWeak(*this)));
+ m_genlist->addEventHandler(impl::ITEM_LONGPRESSED,
+ WEAK_DELEGATE_THIS(onItemLongpressed));
}
}
projects / profile / wearable / apps / native / call-ui.git / commitdiff