InputDelegate::~InputDelegate(void)
{
auto dispatcher = EventDispatcher::getInstance();
dispatcher->removeEventListener(_touchListener);
dispatcher->removeEventListener(_keyboardListener);
dispatcher->removeEventListener(_accelerometerListener);
}
FontAtlas::~FontAtlas()
{
#if CC_ENABLE_CACHE_TEXTURE_DATA
FontFreeType* fontTTf = dynamic_cast<FontFreeType*>(_font);
if (fontTTf)
{
auto eventDispatcher = Director::getInstance()->getEventDispatcher();
if (_toForegroundListener)
{
eventDispatcher->removeEventListener(_toForegroundListener);
_toForegroundListener = nullptr;
}
if (_toBackgroundListener)
{
eventDispatcher->removeEventListener(_toBackgroundListener);
_toBackgroundListener = nullptr;
}
}
#endif
_font->release();
relaseTextures();
delete []_currentPageData;
}
InputDelegate::~InputDelegate(void)
{
auto dispatcher = Director::getInstance()->getEventDispatcher();
dispatcher->removeEventListener(_touchListener);
dispatcher->removeEventListener(_keyboardListener);
dispatcher->removeEventListener(_accelerometerListener);
Device::setAccelerometerEnabled(false);
}
bool EventTarget::removeEventListener(const AtomicString& eventType, PassRefPtrWillBeRawPtr<EventListener> listener, const EventListenerOptionsOrBoolean& optionsUnion)
{
if (optionsUnion.isBoolean())
return removeEventListener(eventType, listener, optionsUnion.getAsBoolean());
if (optionsUnion.isEventListenerOptions()) {
EventListenerOptions options = optionsUnion.getAsEventListenerOptions();
return removeEventListener(eventType, listener, options);
}
return removeEventListener(eventType, listener);
}
bool EventTarget::clearAttributeEventListener(const AtomicString& eventType)
{
EventListener* listener = getAttributeEventListener(eventType);
if (!listener)
return false;
return removeEventListener(eventType, *listener, false);
}
void EventTargetNode::addEventListener(const AtomicString& eventType, PassRefPtr<EventListener> listener, bool useCapture)
{
Document* document = this->document();
if (!document->attached())
return;
document->addListenerTypeIfNeeded(eventType);
RegisteredEventListenerVector& listeners = ensureRareData()->ensureListeners();
// Remove existing identical listener set with identical arguments.
// The DOM2 spec says that "duplicate instances are discarded" in this case.
removeEventListener(eventType, listener.get(), useCapture);
// adding the first one
if (listeners.isEmpty() && !inDocument())
document->registerDisconnectedNodeWithEventListeners(this);
listeners.append(RegisteredEventListener::create(eventType, listener, useCapture));
updateSVGElementInstancesAfterEventListenerChange(this);
#if ENABLE(TOUCH_EVENTS) // Android
if (eventType == eventNames().touchstartEvent ||
eventType == eventNames().touchendEvent ||
eventType == eventNames().touchmoveEvent ||
eventType == eventNames().touchcancelEvent)
document->addTouchEventListener(this);
#endif
}
TITANIUM_FUNCTION(Module, removeEventListener)
{
ENSURE_STRING_AT_INDEX(name, 0);
ENSURE_OBJECT_AT_INDEX(callback, 1);
TITANIUM_ASSERT(callback.IsFunction());
removeEventListener(name, callback, this_object);
return get_context().CreateUndefined();
}
void EventTarget::fireEventListeners(Event& event, EventTargetData* d, EventListenerVector& entry)
{
Ref<EventTarget> protectedThis(*this);
// Fire all listeners registered for this event. Don't fire listeners removed during event dispatch.
// Also, don't fire event listeners added during event dispatch. Conveniently, all new event listeners will be added
// after or at index |size|, so iterating up to (but not including) |size| naturally excludes new event listeners.
size_t i = 0;
size_t size = entry.size();
if (!d->firingEventIterators)
d->firingEventIterators = std::make_unique<FiringEventIteratorVector>();
d->firingEventIterators->append(FiringEventIterator(event.type(), i, size));
ScriptExecutionContext* context = scriptExecutionContext();
Document* document = nullptr;
InspectorInstrumentationCookie willDispatchEventCookie;
if (is<Document>(context)) {
document = downcast<Document>(context);
willDispatchEventCookie = InspectorInstrumentation::willDispatchEvent(*document, event, size > 0);
}
for (; i < size; ++i) {
RegisteredEventListener registeredListener = entry[i];
if (event.eventPhase() == Event::CAPTURING_PHASE && !registeredListener.useCapture)
continue;
if (event.eventPhase() == Event::BUBBLING_PHASE && registeredListener.useCapture)
continue;
// If stopImmediatePropagation has been called, we just break out immediately, without
// handling any more events on this target.
if (event.immediatePropagationStopped())
break;
// Do this before invocation to avoid reentrancy issues.
if (registeredListener.isOnce)
removeEventListener(event.type(), *registeredListener.listener, ListenerOptions(registeredListener.useCapture));
if (registeredListener.isPassive)
event.setInPassiveListener(true);
InspectorInstrumentationCookie cookie = InspectorInstrumentation::willHandleEvent(context, event);
// To match Mozilla, the AT_TARGET phase fires both capturing and bubbling
// event listeners, even though that violates some versions of the DOM spec.
registeredListener.listener->handleEvent(context, &event);
InspectorInstrumentation::didHandleEvent(cookie);
if (registeredListener.isPassive)
event.setInPassiveListener(false);
}
d->firingEventIterators->removeLast();
if (document)
InspectorInstrumentation::didDispatchEvent(willDispatchEventCookie);
}
void EventDispatcher::cleanTarget(Node* node)
{
auto listenerIter = _nodeListenersMap.find(node);
if (listenerIter != _nodeListenersMap.end())
{
auto listeners = listenerIter->second;
auto listenersCopy = *listeners;
for (auto& l : listenersCopy)
{
removeEventListener(l);
}
}
}
void EventDispatcher::dispatchEvent(Event * event){
string type = event->type();
// Leave if no event registered
if( !hasEventListener(type) ){
return;
}
event->_target = this;
_runningDispatch = true;
{
// A reference to keep code clean
std::map<int, std::list<IEventListener*> > &list = _listenerList[event->type()];
// Iterate through all functions in the event, from high proproty to low
for( std::map<int, std::list<IEventListener*> >::reverse_iterator it=list.rbegin(); it!=list.rend(); ++it ){
std::list<IEventListener*> &funcList = it->second;
std::list<IEventListener*>::iterator it_f=funcList.begin();
std::list<IEventListener*>::iterator end_f=funcList.end();
// Execute callbacks
while( it_f != end_f ){
(*it_f++)->exec(event);
// return immediately if cancel() called.
if( event->_canceled == true ){
_runningDispatch = false;
return;
}
}
}
}
_runningDispatch = false;
// If call removeEventListener during dispatchEvent. Remove listener after dispatch.
if( 0 < _removeList.size() ){
// Iterate through all functions in the event, from high proproty to low
for( std::list<IEventListener*>::iterator it=_removeList.begin(); it!=_removeList.end(); ++it ){
removeEventListener( type, (*it) );
}
_removeList.clear();
}
};
void EventDispatcher::removeEventListenersForTarget(Node* target, bool recursive/* = false */)
{
// Ensure the node is removed from these immediately also.
// Don't want any dangling pointers or the possibility of dealing with deleted objects..
_nodePriorityMap.erase(target);
_dirtyNodes.erase(target);
auto listenerIter = _nodeListenersMap.find(target);
if (listenerIter != _nodeListenersMap.end())
{
auto listeners = listenerIter->second;
auto listenersCopy = *listeners;
for (auto& l : listenersCopy)
{
removeEventListener(l);
}
}
// Bug fix: ensure there are no references to the node in the list of listeners to be added.
// If we find any listeners associated with the destroyed node in this list then remove them.
// This is to catch the scenario where the node gets destroyed before it's listener
// is added into the event dispatcher fully. This could happen if a node registers a listener
// and gets destroyed while we are dispatching an event (touch etc.)
for (auto iter = _toAddedListeners.begin(); iter != _toAddedListeners.end(); )
{
EventListener * listener = *iter;
if (listener->getAssociatedNode() == target)
{
listener->setAssociatedNode(nullptr); // Ensure no dangling ptr to the target node.
listener->setRegistered(false);
releaseListener(listener);
iter = _toAddedListeners.erase(iter);
}
else
{
++iter;
}
}
if (recursive)
{
const auto& children = target->getChildren();
for (const auto& child : children)
{
removeEventListenersForTarget(child, true);
}
}
}
void MediaControlsApple::hideClosedCaptionTrackList()
{
if (!m_closedCaptionsContainer || !m_closedCaptionsContainer->isShowing())
return;
m_closedCaptionsContainer->hide();
// Buttons in the controls panel may now be interactive.
m_panel->removeInlineStyleProperty(CSSPropertyPointerEvents);
EventListener& listener = eventListener();
m_closedCaptionsContainer->removeEventListener(eventNames().wheelEvent, &listener, true);
document().removeEventListener(eventNames().clickEvent, &listener, true);
removeEventListener(eventNames().clickEvent, &listener, true);
}
void InputDelegate::setAccelerometerEnabled(bool enabled)
{
if (enabled != _accelerometerEnabled)
{
_accelerometerEnabled = enabled;
auto dispatcher = EventDispatcher::getInstance();
dispatcher->removeEventListener(_accelerometerListener);
_accelerometerListener = nullptr;
if (enabled)
{
auto listener = EventListenerAcceleration::create(CC_CALLBACK_2(InputDelegate::onAcceleration, this));
dispatcher->addEventListenerWithFixedPriority(listener, -1);
_accelerometerListener = listener;
}
}
}
void InputDelegate::setKeypadEnabled(bool enabled)
{
if (enabled != _keypadEnabled)
{
_keypadEnabled = enabled;
auto dispatcher = Director::getInstance()->getEventDispatcher();
dispatcher->removeEventListener(_keyboardListener);
if (enabled)
{
auto listener = EventListenerKeyboard::create();
listener->onKeyPressed = CC_CALLBACK_2(InputDelegate::onKeyPressed, this);
listener->onKeyReleased = CC_CALLBACK_2(InputDelegate::onKeyReleased, this);
dispatcher->addEventListenerWithFixedPriority(listener, -1);
_keyboardListener = listener;
}
}
}
void EventTarget::addEventListener(EventTargetNode* referenceNode, const AtomicString& eventType, PassRefPtr<EventListener> listener, bool useCapture)
{
ASSERT(referenceNode);
if (!referenceNode->document()->attached())
return;
addListenerTypeToDocumentIfNeeded(eventType, referenceNode->document());
if (!referenceNode->m_regdListeners)
referenceNode->m_regdListeners = new RegisteredEventListenerList;
// Remove existing identical listener set with identical arguments.
// The DOM2 spec says that "duplicate instances are discarded" in this case.
removeEventListener(referenceNode, eventType, listener.get(), useCapture);
// adding the first one
if (referenceNode->m_regdListeners->isEmpty() && !referenceNode->inDocument())
referenceNode->document()->registerDisconnectedNodeWithEventListeners(referenceNode);
referenceNode->m_regdListeners->append(RegisteredEventListener::create(eventType, listener, useCapture));
}
void SceneNodeWrapper::destroy()
{
removeEventListener(mObjectManager, OgreObjectManagerEvent::FACTORY_UNREGISTERED, &SceneNodeWrapper::onFactoryUnregister);
for(auto& pair : mChildren)
{
for(auto& objectPair : pair.second)
{
objectPair.second->destroy();
}
}
if(mParentNode != 0)
mParentNode->removeChild(mNode);
if(mNode != 0)
{
destroyAllAttachedMovableObjects(mNode);
mNode->removeAndDestroyAllChildren();
mSceneManager->destroySceneNode(mNode);
}
}
void InputDelegate::setTouchEnabled(bool enabled)
{
if (_touchEnabled != enabled)
{
auto dispatcher = Director::getInstance()->getEventDispatcher();
_touchEnabled = enabled;
if (enabled)
{
if( _touchMode == Touch::DispatchMode::ALL_AT_ONCE ) {
// Register Touch Event
auto listener = EventListenerTouchAllAtOnce::create();
listener->onTouchesBegan = CC_CALLBACK_2(InputDelegate::onTouchesBegan, this);
listener->onTouchesMoved = CC_CALLBACK_2(InputDelegate::onTouchesMoved, this);
listener->onTouchesEnded = CC_CALLBACK_2(InputDelegate::onTouchesEnded, this);
listener->onTouchesCancelled = CC_CALLBACK_2(InputDelegate::onTouchesCancelled, this);
dispatcher->addEventListenerWithFixedPriority(listener, _touchPriority);
_touchListener = listener;
} else {
// Register Touch Event
auto listener = EventListenerTouchOneByOne::create();
listener->setSwallowTouches(true);
listener->onTouchBegan = CC_CALLBACK_2(InputDelegate::onTouchBegan, this);
listener->onTouchMoved = CC_CALLBACK_2(InputDelegate::onTouchMoved, this);
listener->onTouchEnded = CC_CALLBACK_2(InputDelegate::onTouchEnded, this);
listener->onTouchCancelled = CC_CALLBACK_2(InputDelegate::onTouchCancelled, this);
dispatcher->addEventListenerWithFixedPriority(listener, _touchPriority);
_touchListener = listener;
}
}
else
{
dispatcher->removeEventListener(_touchListener);
}
}
}
FontAtlas::~FontAtlas()
{
#if CC_ENABLE_CACHE_TEXTURE_DATA
if (_fontFreeType && _rendererRecreatedListener)
{
auto eventDispatcher = Director::getInstance()->getEventDispatcher();
eventDispatcher->removeEventListener(_rendererRecreatedListener);
_rendererRecreatedListener = nullptr;
}
#endif
_font->release();
relaseTextures();
delete []_currentPageData;
#if CC_TARGET_PLATFORM != CC_PLATFORM_WIN32 && CC_TARGET_PLATFORM != CC_PLATFORM_WINRT && CC_TARGET_PLATFORM != CC_PLATFORM_ANDROID
if (_iconv)
{
iconv_close(_iconv);
_iconv = nullptr;
}
#endif
}
void Button::_mouseEvent(Event* event)
{
TouchEvent* me = safeCast<TouchEvent*>(event);
if (event->type == TouchEvent::CLICK)
{
if (me->mouseButton == MouseButton_Left)
{
event->phase = Event::phase_target;
event->target = this;
}
else
{
event->stopImmediatePropagation();
}
return;
}
if (me->mouseButton != MouseButton_Left)
return;
switch (event->type)
{
case TouchEvent::OVER:
{
if (!_btnOvered)
{
_btnOvered = me->index;
if (!_btnPressed)
setState(stateOvered);
}
}
break;
case TouchEvent::OUT:
{
if (_btnOvered == me->index)
{
if (!_btnPressed)
setState(stateNormal);
_btnOvered = 0;
}
}
break;
case TouchEvent::TOUCH_DOWN:
{
if (!_btnPressed)
{
_btnPressed = me->index;
setState(statePressed);
addEventListener(TouchEvent::TOUCH_UP, CLOSURE(this, &Button::_mouseEvent));
}
}
break;
case TouchEvent::TOUCH_UP:
{
if (_btnPressed == me->index)
{
setState(stateNormal);
removeEventListener(TouchEvent::TOUCH_UP, CLOSURE(this, &Button::_mouseEvent));
_btnPressed = 0;
}
}
break;
}
}
InventoryPanel::~InventoryPanel()
{
auto eventDispatcher = cocos2d::Director::getInstance()->getEventDispatcher();
eventDispatcher->removeEventListener(_inventoryChangedListener);
}
void EventTarget::removeEventListenerForBindings(const AtomicString& eventType, RefPtr<EventListener>&& listener, const ListenerOptions& options)
{
if (!listener)
return;
removeEventListener(eventType, *listener, options);
}
void PopupLayer::onExit() {
Layer::onExit();
auto dispatcher = Director::getInstance()->getEventDispatcher();
dispatcher->removeEventListener(mTouchListener);
}
bool ImageOutport::removeResizeEventListener(EventListener* el) { return removeEventListener(el); }
void MovieClip::stop()
{
passoneframe_ = false;
playing_ = false;
removeEventListener(EnterFrameEvent::ENTER_FRAME, &MovieClip::nextFrame);
}
Msg_Layer::~Msg_Layer()
{
_widgetVector.clear();
removeEventListener();
}
