EventTrackingRegions.cpp [plain text]
#include "config.h"
#include "EventTrackingRegions.h"
namespace WebCore {
TrackingType EventTrackingRegions::trackingTypeForPoint(const String& eventName, const IntPoint& point)
{
auto synchronousRegionIterator = eventSpecificSynchronousDispatchRegions.find(eventName);
if (synchronousRegionIterator != eventSpecificSynchronousDispatchRegions.end()) {
if (synchronousRegionIterator->value.contains(point))
return TrackingType::Synchronous;
}
if (asynchronousDispatchRegion.contains(point))
return TrackingType::Asynchronous;
return TrackingType::NotTracking;
}
bool EventTrackingRegions::isEmpty() const
{
return asynchronousDispatchRegion.isEmpty() && eventSpecificSynchronousDispatchRegions.isEmpty();
}
void EventTrackingRegions::translate(IntSize offset)
{
asynchronousDispatchRegion.translate(offset);
for (auto& slot : eventSpecificSynchronousDispatchRegions)
slot.value.translate(offset);
}
void EventTrackingRegions::uniteSynchronousRegion(const String& eventName, const Region& region)
{
if (region.isEmpty())
return;
auto addResult = eventSpecificSynchronousDispatchRegions.add(eventName, region);
if (!addResult.isNewEntry)
addResult.iterator->value.unite(region);
}
void EventTrackingRegions::unite(const EventTrackingRegions& eventTrackingRegions)
{
asynchronousDispatchRegion.unite(eventTrackingRegions.asynchronousDispatchRegion);
for (auto& slot : eventTrackingRegions.eventSpecificSynchronousDispatchRegions)
uniteSynchronousRegion(slot.key, slot.value);
}
bool operator==(const EventTrackingRegions& a, const EventTrackingRegions& b)
{
return a.asynchronousDispatchRegion == b.asynchronousDispatchRegion
&& a.eventSpecificSynchronousDispatchRegions == b.eventSpecificSynchronousDispatchRegions;
}
}