N_SE-44510 : add targetPost listener

Change-Id: I19ed144502850cc66202aacfdbbd189ec19c39ec

diff --git a/src/ui/FUi_InputConnectionImpl.cpp b/src/ui/FUi_InputConnectionImpl.cpp
index a81ff29..ec0bc39 100644 (file)
--- a/src/ui/FUi_InputConnectionImpl.cpp
+++ b/src/ui/FUi_InputConnectionImpl.cpp
@@ -1460,7 +1460,7 @@ _InputConnectionImpl::AddEcoreEventCallback(void)
 void
 _InputConnectionImpl::AddEvasObjectEventCallback(void)
 {
-       result r = _UiEventManager::GetInstance()->AddPostKeyEventListener(*this);
+       result r = _UiEventManager::GetInstance()->AddTargetPostKeyEventListener(*this);
        SysTryReturnVoidResult(NID_UI,  r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 
        return;
@@ -1499,7 +1499,7 @@ _InputConnectionImpl::RemoveEcoreEventCallback(void)
 void
 _InputConnectionImpl::RemoveEvasObjectEventCallback(void)
 {
-       result r = _UiEventManager::GetInstance()->RemovePostKeyEventListener(*this);
+       result r = _UiEventManager::GetInstance()->RemoveTargetPostKeyEventListener(*this);
        SysTryReturnVoidResult(NID_UI,  r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 
        return;

diff --git a/src/ui/FUi_UiEventManager.cpp b/src/ui/FUi_UiEventManager.cpp
index fddb8b5..76e37bf 100644 (file)
--- a/src/ui/FUi_UiEventManager.cpp
+++ b/src/ui/FUi_UiEventManager.cpp
@@ -89,61 +89,73 @@ _UiEventManager::InitInstance(void)
 result
 _UiEventManager::AddTouchEventListener(const _ITouchEventListener& listener)
 {
-       return AddEventListener(_UI_EVENT_TOUCH, false, listener);
+       return AddEventListener(_UI_EVENT_TOUCH, _UI_LISTENER_NONE, listener);
 }
 
 result
 _UiEventManager::AddKeyEventListener(const _IKeyEventListener& listener)
 {
-       return AddEventListener(_UI_EVENT_KEY, false, listener);
+       return AddEventListener(_UI_EVENT_KEY, _UI_LISTENER_NONE, listener);
 }
 
 result
 _UiEventManager::AddFocusEventListener(const _IFocusEventListener& listener)
 {
-       return AddEventListener(_UI_EVENT_FOCUS, false, listener);
+       return AddEventListener(_UI_EVENT_FOCUS, _UI_LISTENER_NONE, listener);
 }
 
 result
 _UiEventManager::AddNotificationEventListener(const _INotificationEventListener& listener)
 {
-       return AddEventListener(_UI_EVENT_NOTIFICAITON, false, listener);
+       return AddEventListener(_UI_EVENT_NOTIFICAITON, _UI_LISTENER_NONE, listener);
 }
 
 result
 _UiEventManager::RemoveTouchEventListener(const _ITouchEventListener& listener)
 {
-       return RemoveEventListener(_UI_EVENT_TOUCH, false, listener);
+       return RemoveEventListener(_UI_EVENT_TOUCH, _UI_LISTENER_NONE, listener);
 }
 
 result
 _UiEventManager::RemoveKeyEventListener(const _IKeyEventListener& listener)
 {
-       return RemoveEventListener(_UI_EVENT_KEY, false, listener);
+       return RemoveEventListener(_UI_EVENT_KEY, _UI_LISTENER_NONE, listener);
 }
 
 result
 _UiEventManager::RemoveFocusEventListener(const _IFocusEventListener& listener)
 {
-       return RemoveEventListener(_UI_EVENT_FOCUS, false, listener);
+       return RemoveEventListener(_UI_EVENT_FOCUS, _UI_LISTENER_NONE, listener);
 }
 
 result
 _UiEventManager::RemoveNotificationEventListener(const _INotificationEventListener& listener)
 {
-       return RemoveEventListener(_UI_EVENT_NOTIFICAITON, false, listener);
+       return RemoveEventListener(_UI_EVENT_NOTIFICAITON, _UI_LISTENER_NONE, listener);
 }
 
 result
 _UiEventManager::AddPostKeyEventListener(const _IKeyEventListener& listener)
 {
-       return AddEventListener(_UI_EVENT_KEY, true, listener);
+       return AddEventListener(_UI_EVENT_KEY, _UI_LISTENER_POST, listener);
 }
 
 result
 _UiEventManager::RemovePostKeyEventListener(const _IKeyEventListener& listener)
 {
-       return RemoveEventListener(_UI_EVENT_KEY, true, listener);
+       return RemoveEventListener(_UI_EVENT_KEY, _UI_LISTENER_POST, listener);
+}
+
+result
+_UiEventManager::AddTargetPostKeyEventListener(const _IKeyEventListener& listener)
+{
+       return AddEventListener(_UI_EVENT_KEY, _UI_LISTENER_TARGET_POST, listener);
+}
+
+result
+_UiEventManager::RemoveTargetPostKeyEventListener(const _IKeyEventListener& listener)
+{
+       return RemoveEventListener(_UI_EVENT_KEY, _UI_LISTENER_TARGET_POST, listener);
 }
 
 result
@@ -255,13 +267,13 @@ _UiEventManager::GetEventManager(void) const
 }
 
 result
-_UiEventManager::AddEventListener(_UiEventType eventType, bool postListener, const _IUiEventListener& listener)
+_UiEventManager::AddEventListener(_UiEventType eventType, _UiListenerType listenerType, const _IUiEventListener& listener)
 {
        result r = E_SUCCESS;
 
-       SysTryReturn(NID_UI, !IsListenerRegistered(eventType, postListener, listener), E_SYSTEM, E_SYSTEM, "[E_SYSTEM] System error occurred.");
+       SysTryReturn(NID_UI, !IsListenerRegistered(eventType, listenerType, listener), E_SYSTEM, E_SYSTEM, "[E_SYSTEM] System error occurred.");
 
-       LinkedListT <_IUiEventListener*>* pEventListeners = GetEventListeners(eventType, postListener);
+       LinkedListT <_IUiEventListener*>* pEventListeners = GetEventListeners(eventType, listenerType);
        if (pEventListeners)
        {
                pEventListeners->Add(const_cast <_IUiEventListener*>(&listener));
@@ -271,11 +283,11 @@ _UiEventManager::AddEventListener(_UiEventType eventType, bool postListener, con
 }
 
 result
-_UiEventManager::RemoveEventListener(_UiEventType eventType, bool postListener, const _IUiEventListener& listener)
+_UiEventManager::RemoveEventListener(_UiEventType eventType, _UiListenerType listenerType, const _IUiEventListener& listener)
 {
        result r = E_SUCCESS;
 
-       LinkedListT <_IUiEventListener*>* pEventListeners = GetEventListeners(eventType, postListener);
+       LinkedListT <_IUiEventListener*>* pEventListeners = GetEventListeners(eventType, listenerType);
        if (pEventListeners)
        {
                pEventListeners->Remove(const_cast <_IUiEventListener*>(&listener));
@@ -285,11 +297,11 @@ _UiEventManager::RemoveEventListener(_UiEventType eventType, bool postListener,
 }
 
 bool
-_UiEventManager::IsListenerRegistered(_UiEventType eventType, bool postListener, const _IUiEventListener& listener)
+_UiEventManager::IsListenerRegistered(_UiEventType eventType, _UiListenerType listenerType, const _IUiEventListener& listener)
 {
        bool isRegistered = false;
 
-       LinkedListT <_IUiEventListener*>* pEventListeners = GetEventListeners(eventType, postListener);
+       LinkedListT <_IUiEventListener*>* pEventListeners = GetEventListeners(eventType, listenerType);
        if (pEventListeners)
        {
                Tizen::Base::Collection::IEnumeratorT <_IUiEventListener*>* pEnumerator = pEventListeners->GetEnumeratorN();
@@ -353,14 +365,18 @@ _UiEventManager::Fire(const _UiEvent& event)
 }
 
 LinkedListT <_IUiEventListener*>*
-_UiEventManager::GetEventListeners(_UiEventType eventType, bool postListener) const
+_UiEventManager::GetEventListeners(_UiEventType eventType, _UiListenerType listenerType) const
 {
        LinkedListT <_IUiEventListener*>* pEventListeners = null;
 
-       if (postListener)
+       if (listenerType == _UI_LISTENER_POST)
        {
                __pPostEventListenerMap->GetValue(eventType, pEventListeners);
        }
+       else if (listenerType == _UI_LISTENER_TARGET_POST)
+       {
+               __pTargetPostEventListenerMap->GetValue(eventType, pEventListeners);
+       }
        else
        {
                result r = E_SUCCESS;
@@ -375,21 +391,27 @@ _UiEventManager::GetEventListeners(_UiEventType eventType, bool postListener) co
 result
 _UiEventManager::ProcessListener(const _UiEvent& event, bool& isFiltered)
 {
-       return ProcessListener(event, false, isFiltered);
+       return ProcessListener(event, _UI_LISTENER_NONE, isFiltered);
+}
+
+result
+_UiEventManager::ProcessTargetPostListener(const _UiEvent& event, bool& isFiltered)
+{
+       return ProcessListener(event, _UI_LISTENER_TARGET_POST, isFiltered);
 }
 
 result
 _UiEventManager::ProcessPostListener(const _UiEvent& event, bool& isFiltered)
 {
-       return ProcessListener(event, true, isFiltered);
+       return ProcessListener(event, _UI_LISTENER_POST, isFiltered);
 }
 
 result
-_UiEventManager::ProcessListener(const _UiEvent& event, bool postListener, bool& isFiltered)
+_UiEventManager::ProcessListener(const _UiEvent& event, _UiListenerType listenerType, bool& isFiltered)
 {
        result r = E_SUCCESS;
 
-       LinkedListT <_IUiEventListener*>* pEventListeners = GetEventListeners(event.GetEventType(), postListener);
+       LinkedListT <_IUiEventListener*>* pEventListeners = GetEventListeners(event.GetEventType(), listenerType);
        if (pEventListeners)
        {
                Tizen::Base::Collection::IEnumeratorT <_IUiEventListener*>* pEnumerator = pEventListeners->GetEnumeratorN();
@@ -641,6 +663,11 @@ _UiEventManager::ProcessBubblingEvent(const Tizen::Base::Collection::LinkedListT
                }
 
                r = const_cast<_UiEvent&>(event).ProcessEvent(*pControl, isFiltered);
+
+               if (!isFiltered && (event.GetDestination() == uiObjectHandle))
+               {
+                       ProcessTargetPostListener(event, isFiltered);
+               }
        }
 
        delete pEnumerator;
@@ -748,9 +775,24 @@ _UiEventManager::_UiEventManager(void)
        r = pPostEventListenerMap->Add(_UI_EVENT_KEY, pPostKeyEventListeners);
        SysTryReturnVoidResult(NID_UI, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
 
+       // target post
+       unique_ptr<HashMapT<_UiEventType, LinkedListT<_IUiEventListener*>*> > pTargetPostEventListenerMap(new (std::nothrow) HashMapT<_UiEventType, LinkedListT<_IUiEventListener*>*>);
+       SysTryReturnVoidResult(NID_UI, pTargetPostEventListenerMap, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
+
+       r = pTargetPostEventListenerMap->Construct();
+       SysTryReturnVoidResult(NID_UI, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
+
+       // target Key
+       LinkedListT<_IUiEventListener*>* pTargetPostKeyEventListeners = new (std::nothrow) LinkedListT<_IUiEventListener*>;
+       SysTryReturnVoidResult(NID_UI, pTargetPostKeyEventListeners, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Memory is insufficient.");
+
+       r = pTargetPostEventListenerMap->Add(_UI_EVENT_KEY, pTargetPostKeyEventListeners);
+       SysTryReturnVoidResult(NID_UI, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r));
+
        // move pointer
        __pEventListenerMap = move(pEventListenerMap);
        __pPostEventListenerMap = move(pPostEventListenerMap);
+       __pTargetPostEventListenerMap = move(pTargetPostEventListenerMap);
 }
 
 _UiEventManager::~_UiEventManager(void)

diff --git a/src/ui/inc/FUi_UiEventManager.h b/src/ui/inc/FUi_UiEventManager.h
index a08d744..a885a7d 100644 (file)
--- a/src/ui/inc/FUi_UiEventManager.h
+++ b/src/ui/inc/FUi_UiEventManager.h
@@ -77,6 +77,9 @@ public:
        result AddPostKeyEventListener(const _IKeyEventListener& listener);
        result RemovePostKeyEventListener(const _IKeyEventListener& listener);
 
+       result AddTargetPostKeyEventListener(const _IKeyEventListener& listener);
+       result RemoveTargetPostKeyEventListener(const _IKeyEventListener& listener);
+
        result SendEvent(const _UiEvent& event);
        result PostEvent(const _UiEvent& event);
 
@@ -87,15 +90,16 @@ public:
 
 private:
        static void InitInstance(void);
-       result AddEventListener(_UiEventType eventType, bool postListener, const _IUiEventListener& listener);
-       result RemoveEventListener(_UiEventType eventType, bool postListener, const _IUiEventListener& listener);
-       bool IsListenerRegistered(_UiEventType eventType, bool postListener, const _IUiEventListener& listener);
+       result AddEventListener(_UiEventType eventType, _UiListenerType listenerType, const _IUiEventListener& listene);
+       result RemoveEventListener(_UiEventType eventType, _UiListenerType listenerType, const _IUiEventListener& listener);
+       bool IsListenerRegistered(_UiEventType eventType, _UiListenerType listenerType, const _IUiEventListener& listener);
 
        result Fire(const _UiEvent& notification);
-       Tizen::Base::Collection::LinkedListT <_IUiEventListener*>* GetEventListeners(_UiEventType eventType, bool postListener) const;
+       Tizen::Base::Collection::LinkedListT <_IUiEventListener*>* GetEventListeners(_UiEventType eventType, _UiListenerType listenerType) const;
        result ProcessListener(const _UiEvent& event, bool& isFiltered);
        result ProcessPostListener(const _UiEvent& event, bool& isFiltered);
-       result ProcessListener(const _UiEvent& event, bool postListener, bool& isFiltered);
+       result ProcessTargetPostListener(const _UiEvent& event, bool& isFiltered);
+       result ProcessListener(const _UiEvent& event, _UiListenerType listenerType, bool& isFiltered);
        result ProcessEvent(const _UiEvent& event, bool& isFiltered);
        result ProcessGlobalGesture(const _UiEvent& event, bool& isFiltered);
        result MakeRoutingPath(Tizen::Base::Collection::LinkedListT <_UiObjectHandle>& tunnelingPath, Tizen::Base::Collection::LinkedListT <_UiObjectHandle>& bubblingPath, const _UiEvent& event);
@@ -115,6 +119,7 @@ private:
        std::unique_ptr<_IUiEventManager> __pEventManager;
        std::unique_ptr<Tizen::Base::Collection::HashMapT<_UiEventType, Tizen::Base::Collection::LinkedListT<_IUiEventListener*>*> > __pEventListenerMap;
        std::unique_ptr<Tizen::Base::Collection::HashMapT<_UiEventType, Tizen::Base::Collection::LinkedListT<_IUiEventListener*>*> > __pPostEventListenerMap;
+       std::unique_ptr<Tizen::Base::Collection::HashMapT<_UiEventType, Tizen::Base::Collection::LinkedListT<_IUiEventListener*>*> > __pTargetPostEventListenerMap;
 };
 
 }} // Tizen::Ui