blob: 003bf8c4fe24e5a54f8857741a20000b81fd0d75 [file] [log] [blame]
/*
* Copyright 2006 The Android Open Source Project
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "SkEventSink.h"
#include "SkMutex.h"
#include "SkTagList.h"
#include "SkTime.h"
class SkEventSink_Globals {
public:
SkEventSink_Globals() {
fNextSinkID = 0;
fSinkHead = nullptr;
}
SkMutex fSinkMutex;
SkEventSinkID fNextSinkID;
SkEventSink* fSinkHead;
};
static SkEventSink_Globals& getGlobals() {
// leak this, so we don't incur any shutdown perf hit
static SkEventSink_Globals* gGlobals = new SkEventSink_Globals;
return *gGlobals;
}
SkEventSink::SkEventSink() : fTagHead(nullptr) {
SkEventSink_Globals& globals = getGlobals();
globals.fSinkMutex.acquire();
fID = ++globals.fNextSinkID;
fNextSink = globals.fSinkHead;
globals.fSinkHead = this;
globals.fSinkMutex.release();
}
SkEventSink::~SkEventSink() {
SkEventSink_Globals& globals = getGlobals();
if (fTagHead)
SkTagList::DeleteAll(fTagHead);
globals.fSinkMutex.acquire();
SkEventSink* sink = globals.fSinkHead;
SkEventSink* prev = nullptr;
for (;;) {
SkEventSink* next = sink->fNextSink;
if (sink == this) {
if (prev) {
prev->fNextSink = next;
} else {
globals.fSinkHead = next;
}
break;
}
prev = sink;
sink = next;
}
globals.fSinkMutex.release();
}
bool SkEventSink::doEvent(const SkEvent& evt) {
return this->onEvent(evt);
}
bool SkEventSink::doQuery(SkEvent* evt) {
SkASSERT(evt);
return this->onQuery(evt);
}
bool SkEventSink::onEvent(const SkEvent&) {
return false;
}
bool SkEventSink::onQuery(SkEvent*) {
return false;
}
///////////////////////////////////////////////////////////////////////////////
SkTagList* SkEventSink::findTagList(U8CPU tag) const {
return fTagHead ? SkTagList::Find(fTagHead, tag) : nullptr;
}
void SkEventSink::addTagList(SkTagList* rec) {
SkASSERT(rec);
SkASSERT(fTagHead == nullptr || SkTagList::Find(fTagHead, rec->fTag) == nullptr);
rec->fNext = fTagHead;
fTagHead = rec;
}
void SkEventSink::removeTagList(U8CPU tag) {
if (fTagHead) {
SkTagList::DeleteTag(&fTagHead, tag);
}
}
///////////////////////////////////////////////////////////////////////////////
struct SkListenersTagList : SkTagList {
SkListenersTagList(U16CPU count) : SkTagList(kListeners_SkTagList)
{
fExtra16 = SkToU16(count);
fIDs = (SkEventSinkID*)sk_malloc_throw(count * sizeof(SkEventSinkID));
}
virtual ~SkListenersTagList()
{
sk_free(fIDs);
}
int countListners() const { return fExtra16; }
int find(SkEventSinkID id) const
{
const SkEventSinkID* idptr = fIDs;
for (int i = fExtra16 - 1; i >= 0; --i)
if (idptr[i] == id)
return i;
return -1;
}
SkEventSinkID* fIDs;
};
void SkEventSink::addListenerID(SkEventSinkID id)
{
if (id == 0)
return;
SkListenersTagList* prev = (SkListenersTagList*)this->findTagList(kListeners_SkTagList);
int count = 0;
if (prev)
{
if (prev->find(id) >= 0)
return;
count = prev->countListners();
}
SkListenersTagList* next = new SkListenersTagList(count + 1);
if (prev)
{
memcpy(next->fIDs, prev->fIDs, count * sizeof(SkEventSinkID));
this->removeTagList(kListeners_SkTagList);
}
next->fIDs[count] = id;
this->addTagList(next);
}
void SkEventSink::copyListeners(const SkEventSink& sink)
{
SkListenersTagList* sinkList = (SkListenersTagList*)sink.findTagList(kListeners_SkTagList);
if (sinkList == nullptr)
return;
SkASSERT(sinkList->countListners() > 0);
const SkEventSinkID* iter = sinkList->fIDs;
const SkEventSinkID* stop = iter + sinkList->countListners();
while (iter < stop)
addListenerID(*iter++);
}
void SkEventSink::removeListenerID(SkEventSinkID id)
{
if (id == 0)
return;
SkListenersTagList* list = (SkListenersTagList*)this->findTagList(kListeners_SkTagList);
if (list == nullptr)
return;
int index = list->find(id);
if (index >= 0)
{
int count = list->countListners();
SkASSERT(count > 0);
if (count == 1)
this->removeTagList(kListeners_SkTagList);
else
{
// overwrite without resize/reallocating our struct (for speed)
list->fIDs[index] = list->fIDs[count - 1];
list->fExtra16 = SkToU16(count - 1);
}
}
}
bool SkEventSink::hasListeners() const
{
return this->findTagList(kListeners_SkTagList) != nullptr;
}
void SkEventSink::postToListeners(const SkEvent& evt, SkMSec delay) {
SkListenersTagList* list = (SkListenersTagList*)this->findTagList(kListeners_SkTagList);
if (list) {
SkASSERT(list->countListners() > 0);
const SkEventSinkID* iter = list->fIDs;
const SkEventSinkID* stop = iter + list->countListners();
while (iter < stop) {
SkEvent* copy = new SkEvent(evt);
copy->setTargetID(*iter++)->postDelay(delay);
}
}
}
///////////////////////////////////////////////////////////////////////////////
SkEventSink::EventResult SkEventSink::DoEvent(const SkEvent& evt) {
SkEvent::Proc proc = evt.getTargetProc();
if (proc) {
return proc(evt) ? kHandled_EventResult : kNotHandled_EventResult;
}
SkEventSink* sink = SkEventSink::FindSink(evt.getTargetID());
if (sink) {
return sink->doEvent(evt) ? kHandled_EventResult : kNotHandled_EventResult;
}
return kSinkNotFound_EventResult;
}
SkEventSink* SkEventSink::FindSink(SkEventSinkID sinkID)
{
if (sinkID == 0)
return 0;
SkEventSink_Globals& globals = getGlobals();
SkAutoMutexAcquire ac(globals.fSinkMutex);
SkEventSink* sink = globals.fSinkHead;
while (sink)
{
if (sink->getSinkID() == sinkID)
return sink;
sink = sink->fNextSink;
}
return nullptr;
}
////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////
#if 0 // experimental, not tested
#include "SkMutex.h"
#include "SkTDict.h"
#define kMinStringBufferSize 128
SK_DECLARE_STATIC_MUTEX(gNamedSinkMutex);
static SkTDict<SkEventSinkID> gNamedSinkIDs(kMinStringBufferSize);
/** Register a name/id pair with the system. If the name already exists,
replace its ID with the new id. This pair will persist until UnregisterNamedSink()
is called.
*/
void SkEventSink::RegisterNamedSinkID(const char name[], SkEventSinkID id)
{
if (id && name && *name)
{
SkAutoMutexAcquire ac(gNamedSinkMutex);
gNamedSinkIDs.set(name, id);
}
}
/** Return the id that matches the specified name (from a previous call to
RegisterNamedSinkID(). If no match is found, return 0
*/
SkEventSinkID SkEventSink::FindNamedSinkID(const char name[])
{
SkEventSinkID id = 0;
if (name && *name)
{
SkAutoMutexAcquire ac(gNamedSinkMutex);
(void)gNamedSinkIDs.find(name, &id);
}
return id;
}
/** Remove all name/id pairs from the system. This is call internally
on shutdown, to ensure no memory leaks. It should not be called
before shutdown.
*/
void SkEventSink::RemoveAllNamedSinkIDs()
{
SkAutoMutexAcquire ac(gNamedSinkMutex);
(void)gNamedSinkIDs.reset();
}
#endif