DocumentMarkerController.cpp [plain text]
#include "config.h"
#include "DocumentMarkerController.h"
#include "Node.h"
#include "Range.h"
#include "RenderObject.h"
#include "RenderedDocumentMarker.h"
#include "TextIterator.h"
namespace WebCore {
inline bool DocumentMarkerController::possiblyHasMarkers(DocumentMarker::MarkerTypes types)
{
return m_possiblyExistingMarkerTypes.intersects(types);
}
DocumentMarkerController::DocumentMarkerController()
: m_possiblyExistingMarkerTypes(0)
{
}
void DocumentMarkerController::detach()
{
m_possiblyExistingMarkerTypes = 0;
if (m_markers.isEmpty())
return;
deleteAllValues(m_markers);
m_markers.clear();
}
void DocumentMarkerController::addMarker(Range* range, DocumentMarker::MarkerType type, String description)
{
for (TextIterator markedText(range); !markedText.atEnd(); markedText.advance()) {
RefPtr<Range> textPiece = markedText.range();
int exception = 0;
DocumentMarker marker = {type, textPiece->startOffset(exception), textPiece->endOffset(exception), description, false};
addMarker(textPiece->startContainer(exception), marker);
}
}
void DocumentMarkerController::removeMarkers(Range* range, DocumentMarker::MarkerTypes markerTypes, RemovePartiallyOverlappingMarkerOrNot shouldRemovePartiallyOverlappingMarker)
{
for (TextIterator markedText(range); !markedText.atEnd(); markedText.advance()) {
if (!possiblyHasMarkers(markerTypes))
return;
ASSERT(!m_markers.isEmpty());
RefPtr<Range> textPiece = markedText.range();
int startOffset = textPiece->startOffset();
int endOffset = textPiece->endOffset();
removeMarkers(textPiece->startContainer(), startOffset, endOffset - startOffset, markerTypes, shouldRemovePartiallyOverlappingMarker);
}
}
void DocumentMarkerController::addMarker(Node* node, const DocumentMarker& newMarker)
{
ASSERT(newMarker.endOffset >= newMarker.startOffset);
if (newMarker.endOffset == newMarker.startOffset)
return;
m_possiblyExistingMarkerTypes.add(newMarker.type);
MarkerList* list = m_markers.get(node);
if (!list) {
list = new MarkerList;
list->append(RenderedDocumentMarker(newMarker));
m_markers.set(node, list);
} else {
RenderedDocumentMarker toInsert(newMarker);
size_t numMarkers = list->size();
size_t i;
for (i = 0; i < numMarkers; ++i) {
DocumentMarker marker = list->at(i);
if (marker.startOffset > toInsert.startOffset)
break;
if (marker.type == toInsert.type && marker.endOffset >= toInsert.startOffset) {
toInsert.startOffset = marker.startOffset;
list->remove(i);
numMarkers--;
break;
}
}
size_t j = i;
while (j < numMarkers) {
DocumentMarker marker = list->at(j);
if (marker.startOffset > toInsert.endOffset)
break;
if (marker.type == toInsert.type) {
list->remove(j);
if (toInsert.endOffset <= marker.endOffset) {
toInsert.endOffset = marker.endOffset;
break;
}
numMarkers--;
} else
j++;
}
list->insert(i, RenderedDocumentMarker(toInsert));
}
if (node->renderer())
node->renderer()->repaint();
}
void DocumentMarkerController::copyMarkers(Node* srcNode, unsigned startOffset, int length, Node* dstNode, int delta)
{
if (length <= 0)
return;
if (!possiblyHasMarkers(DocumentMarker::AllMarkers()))
return;
ASSERT(!m_markers.isEmpty());
MarkerList* list = m_markers.get(srcNode);
if (!list)
return;
bool docDirty = false;
unsigned endOffset = startOffset + length - 1;
for (size_t i = 0; i != list->size(); ++i) {
DocumentMarker marker = list->at(i);
if (marker.startOffset > endOffset)
break;
if (marker.endOffset < startOffset)
continue;
docDirty = true;
if (marker.startOffset < startOffset)
marker.startOffset = startOffset;
if (marker.endOffset > endOffset)
marker.endOffset = endOffset;
marker.startOffset += delta;
marker.endOffset += delta;
addMarker(dstNode, marker);
}
if (docDirty && dstNode->renderer())
dstNode->renderer()->repaint();
}
void DocumentMarkerController::removeMarkers(Node* node, unsigned startOffset, int length, DocumentMarker::MarkerTypes markerTypes, RemovePartiallyOverlappingMarkerOrNot shouldRemovePartiallyOverlappingMarker)
{
if (length <= 0)
return;
if (!possiblyHasMarkers(markerTypes))
return;
ASSERT(!(m_markers.isEmpty()));
MarkerList* list = m_markers.get(node);
if (!list)
return;
bool docDirty = false;
unsigned endOffset = startOffset + length;
for (size_t i = 0; i < list->size();) {
DocumentMarker marker = list->at(i);
if (marker.startOffset >= endOffset)
break;
if (marker.endOffset <= startOffset || !markerTypes.contains(marker.type)) {
i++;
continue;
}
docDirty = true;
list->remove(i);
if (shouldRemovePartiallyOverlappingMarker)
continue;
if (startOffset > marker.startOffset) {
DocumentMarker newLeft = marker;
newLeft.endOffset = startOffset;
list->insert(i, RenderedDocumentMarker(newLeft));
i++;
}
if (marker.endOffset > endOffset) {
DocumentMarker newRight = marker;
newRight.startOffset = endOffset;
list->insert(i, RenderedDocumentMarker(newRight));
i++;
}
}
if (list->isEmpty()) {
m_markers.remove(node);
delete list;
}
if (m_markers.isEmpty())
m_possiblyExistingMarkerTypes = 0;
if (docDirty && node->renderer())
node->renderer()->repaint();
}
DocumentMarker* DocumentMarkerController::markerContainingPoint(const IntPoint& point, DocumentMarker::MarkerType markerType)
{
if (!possiblyHasMarkers(markerType))
return 0;
ASSERT(!(m_markers.isEmpty()));
MarkerMap::iterator end = m_markers.end();
for (MarkerMap::iterator nodeIterator = m_markers.begin(); nodeIterator != end; ++nodeIterator) {
MarkerList* list = nodeIterator->second;
unsigned markerCount = list->size();
for (unsigned markerIndex = 0; markerIndex < markerCount; ++markerIndex) {
RenderedDocumentMarker& marker = list->at(markerIndex);
if (marker.type != markerType)
continue;
if (marker.contains(point))
return ▮
}
}
return 0;
}
Vector<DocumentMarker> DocumentMarkerController::markersForNode(Node* node)
{
Vector<DocumentMarker> result;
MarkerList* list = m_markers.get(node);
if (!list)
return result;
for (size_t i = 0; i < list->size(); ++i)
result.append(list->at(i));
return result;
}
Vector<DocumentMarker> DocumentMarkerController::markersInRange(Range* range, DocumentMarker::MarkerTypes markerTypes)
{
if (!possiblyHasMarkers(markerTypes))
return Vector<DocumentMarker>();
Vector<DocumentMarker> foundMarkers;
Node* startContainer = range->startContainer();
ASSERT(startContainer);
Node* endContainer = range->endContainer();
ASSERT(endContainer);
Node* pastLastNode = range->pastLastNode();
for (Node* node = range->firstNode(); node != pastLastNode; node = node->traverseNextNode()) {
Vector<DocumentMarker> markers = markersForNode(node);
Vector<DocumentMarker>::const_iterator end = markers.end();
for (Vector<DocumentMarker>::const_iterator it = markers.begin(); it != end; ++it) {
if (!markerTypes.contains(it->type))
continue;
if (node == startContainer && it->endOffset <= static_cast<unsigned>(range->startOffset()))
continue;
if (node == endContainer && it->startOffset >= static_cast<unsigned>(range->endOffset()))
continue;
foundMarkers.append(*it);
}
}
return foundMarkers;
}
Vector<IntRect> DocumentMarkerController::renderedRectsForMarkers(DocumentMarker::MarkerType markerType)
{
Vector<IntRect> result;
if (!possiblyHasMarkers(markerType))
return result;
ASSERT(!(m_markers.isEmpty()));
MarkerMap::iterator end = m_markers.end();
for (MarkerMap::iterator nodeIterator = m_markers.begin(); nodeIterator != end; ++nodeIterator) {
MarkerList* list = nodeIterator->second;
unsigned markerCount = list->size();
for (unsigned markerIndex = 0; markerIndex < markerCount; ++markerIndex) {
const RenderedDocumentMarker& marker = list->at(markerIndex);
if (marker.type != markerType)
continue;
if (!marker.isRendered())
continue;
result.append(marker.renderedRect());
}
}
return result;
}
void DocumentMarkerController::removeMarkers(Node* node, DocumentMarker::MarkerTypes markerTypes)
{
if (!possiblyHasMarkers(markerTypes))
return;
ASSERT(!m_markers.isEmpty());
MarkerMap::iterator iterator = m_markers.find(node);
if (iterator != m_markers.end())
removeMarkersFromList(node, iterator->second, markerTypes);
}
void DocumentMarkerController::removeMarkers(DocumentMarker::MarkerTypes markerTypes)
{
if (!possiblyHasMarkers(markerTypes))
return;
ASSERT(!m_markers.isEmpty());
MarkerMap markerMapCopy = m_markers;
MarkerMap::iterator end = markerMapCopy.end();
for (MarkerMap::iterator i = markerMapCopy.begin(); i != end; ++i)
removeMarkersFromList(i->first.get(), i->second, markerTypes);
m_possiblyExistingMarkerTypes.remove(markerTypes);
}
void DocumentMarkerController::removeMarkersFromList(Node* node, MarkerList* list, DocumentMarker::MarkerTypes markerTypes)
{
if (markerTypes == DocumentMarker::AllMarkers()) {
delete list;
m_markers.remove(node);
if (RenderObject* renderer = node->renderer())
renderer->repaint();
} else {
bool needsRepaint = false;
for (size_t i = 0; i != list->size();) {
DocumentMarker marker = list->at(i);
if (!markerTypes.contains(marker.type)) {
++i;
continue;
}
list->remove(i);
needsRepaint = true;
}
if (needsRepaint) {
RenderObject* renderer = node->renderer();
if (renderer)
renderer->repaint();
}
if (list->isEmpty()) {
m_markers.remove(node);
delete list;
}
}
if (m_markers.isEmpty())
m_possiblyExistingMarkerTypes = 0;
}
void DocumentMarkerController::repaintMarkers(DocumentMarker::MarkerTypes markerTypes)
{
if (!possiblyHasMarkers(markerTypes))
return;
ASSERT(!m_markers.isEmpty());
MarkerMap::iterator end = m_markers.end();
for (MarkerMap::iterator i = m_markers.begin(); i != end; ++i) {
Node* node = i->first.get();
MarkerList* list = i->second;
bool nodeNeedsRepaint = false;
for (size_t i = 0; i != list->size(); ++i) {
DocumentMarker marker = list->at(i);
if (markerTypes.contains(marker.type)) {
nodeNeedsRepaint = true;
break;
}
}
if (!nodeNeedsRepaint)
continue;
if (RenderObject* renderer = node->renderer())
renderer->repaint();
}
}
void DocumentMarkerController::setRenderedRectForMarker(Node* node, const DocumentMarker& marker, const IntRect& r)
{
MarkerList* list = m_markers.get(node);
if (!list) {
ASSERT_NOT_REACHED(); return;
}
size_t markerCount = list->size();
for (size_t markerIndex = 0; markerIndex < markerCount; ++markerIndex) {
RenderedDocumentMarker& m = list->at(markerIndex);
if (m == marker) {
m.setRenderedRect(r);
return;
}
}
ASSERT_NOT_REACHED(); }
void DocumentMarkerController::invalidateRenderedRectsForMarkersInRect(const IntRect& r)
{
MarkerMap::iterator end = m_markers.end();
for (MarkerMap::iterator i = m_markers.begin(); i != end; ++i) {
MarkerList* list = i->second;
for (size_t listIndex = 0; listIndex < list->size(); ++listIndex)
list->at(listIndex).invalidate(r);
}
}
void DocumentMarkerController::shiftMarkers(Node* node, unsigned startOffset, int delta)
{
if (!possiblyHasMarkers(DocumentMarker::AllMarkers()))
return;
ASSERT(!m_markers.isEmpty());
MarkerList* list = m_markers.get(node);
if (!list)
return;
bool docDirty = false;
for (size_t i = 0; i != list->size(); ++i) {
RenderedDocumentMarker& marker = list->at(i);
if (marker.startOffset >= startOffset) {
ASSERT((int)marker.startOffset + delta >= 0);
marker.startOffset += delta;
marker.endOffset += delta;
docDirty = true;
marker.invalidate();
}
}
if (docDirty && node->renderer())
node->renderer()->repaint();
}
void DocumentMarkerController::setMarkersActive(Range* range, bool active)
{
if (!possiblyHasMarkers(DocumentMarker::AllMarkers()))
return;
ASSERT(!m_markers.isEmpty());
ExceptionCode ec = 0;
Node* startContainer = range->startContainer(ec);
Node* endContainer = range->endContainer(ec);
Node* pastLastNode = range->pastLastNode();
for (Node* node = range->firstNode(); node != pastLastNode; node = node->traverseNextNode()) {
int startOffset = node == startContainer ? range->startOffset(ec) : 0;
int endOffset = node == endContainer ? range->endOffset(ec) : INT_MAX;
setMarkersActive(node, startOffset, endOffset, active);
}
}
void DocumentMarkerController::setMarkersActive(Node* node, unsigned startOffset, unsigned endOffset, bool active)
{
MarkerList* list = m_markers.get(node);
if (!list)
return;
bool docDirty = false;
for (size_t i = 0; i != list->size(); ++i) {
DocumentMarker& marker = list->at(i);
if (marker.startOffset >= endOffset)
break;
if (marker.endOffset < startOffset || marker.type != DocumentMarker::TextMatch)
continue;
marker.activeMatch = active;
docDirty = true;
}
if (docDirty && node->renderer())
node->renderer()->repaint();
}
bool DocumentMarkerController::hasMarkers(Range* range, DocumentMarker::MarkerTypes markerTypes)
{
if (!possiblyHasMarkers(markerTypes))
return false;
ASSERT(!m_markers.isEmpty());
Node* startContainer = range->startContainer();
ASSERT(startContainer);
Node* endContainer = range->endContainer();
ASSERT(endContainer);
Node* pastLastNode = range->pastLastNode();
for (Node* node = range->firstNode(); node != pastLastNode; node = node->traverseNextNode()) {
Vector<DocumentMarker> markers = markersForNode(node);
Vector<DocumentMarker>::const_iterator end = markers.end();
for (Vector<DocumentMarker>::const_iterator it = markers.begin(); it != end; ++it) {
if (!markerTypes.contains(it->type))
continue;
if (node == startContainer && it->endOffset <= static_cast<unsigned>(range->startOffset()))
continue;
if (node == endContainer && it->startOffset >= static_cast<unsigned>(range->endOffset()))
continue;
return true;
}
}
return false;
}
void DocumentMarkerController::clearDescriptionOnMarkersIntersectingRange(Range* range, DocumentMarker::MarkerTypes markerTypes)
{
if (!possiblyHasMarkers(markerTypes))
return;
ASSERT(!m_markers.isEmpty());
Node* startContainer = range->startContainer();
Node* endContainer = range->endContainer();
Node* pastLastNode = range->pastLastNode();
for (Node* node = range->firstNode(); node != pastLastNode; node = node->traverseNextNode()) {
unsigned startOffset = node == startContainer ? range->startOffset() : 0;
unsigned endOffset = node == endContainer ? static_cast<unsigned>(range->endOffset()) : std::numeric_limits<unsigned>::max();
MarkerList* list = m_markers.get(node);
if (!list)
continue;
for (size_t i = 0; i < list->size(); ++i) {
DocumentMarker& marker = list->at(i);
if (marker.startOffset >= endOffset)
break;
if (marker.endOffset <= startOffset || !markerTypes.contains(marker.type)) {
i++;
continue;
}
marker.description = String();
}
}
}
#ifndef NDEBUG
void DocumentMarkerController::showMarkers() const
{
fprintf(stderr, "%d nodes have markers:\n", m_markers.size());
MarkerMap::const_iterator end = m_markers.end();
for (MarkerMap::const_iterator nodeIterator = m_markers.begin(); nodeIterator != end; ++nodeIterator) {
Node* node = nodeIterator->first.get();
fprintf(stderr, "%p", node);
MarkerList* list = nodeIterator->second;
for (unsigned markerIndex = 0; markerIndex < list->size(); ++markerIndex)
fprintf(stderr, " %d:[%d:%d](%d)", list->at(markerIndex).type, list->at(markerIndex).startOffset, list->at(markerIndex).endOffset, list->at(markerIndex).activeMatch);
fprintf(stderr, "\n");
}
}
#endif
}
#ifndef NDEBUG
void showDocumentMarkers(const WebCore::DocumentMarkerController* controller)
{
if (controller)
controller->showMarkers();
}
#endif