inline bool DocumentMarkerController::possiblyHasMarkers(DocumentMarker::MarkerTypes types)
{
- return m_possiblyExistingMarkerTypes & types;
+ return m_possiblyExistingMarkerTypes.intersects(types);
}
DocumentMarkerController::DocumentMarkerController()
if (newMarker.endOffset == newMarker.startOffset)
return;
- m_possiblyExistingMarkerTypes |= newMarker.type;
+ m_possiblyExistingMarkerTypes.add(newMarker.type);
MarkerMapVectorPair* vectorPair = m_markers.get(node);
// copies markers from srcNode to dstNode, applying the specified shift delta to the copies. The shift is
// useful if, e.g., the caller has created the dstNode from a non-prefix substring of the srcNode.
-void DocumentMarkerController::copyMarkers(Node* srcNode, unsigned startOffset, int length, Node* dstNode, int delta, DocumentMarker::MarkerType markerType)
+void DocumentMarkerController::copyMarkers(Node* srcNode, unsigned startOffset, int length, Node* dstNode, int delta)
{
if (length <= 0)
return;
- if (!possiblyHasMarkers(markerType))
+ if (!possiblyHasMarkers(DocumentMarker::AllMarkers()))
return;
ASSERT(!m_markers.isEmpty());
break;
// skip marker that is before the specified range or is the wrong type
- if (marker.endOffset < startOffset || (marker.type != markerType && markerType != DocumentMarker::AllMarkers))
+ if (marker.endOffset < startOffset)
continue;
// pin the marker to the specified range and apply the shift delta
break;
// skip marker that is wrong type or before target
- if (marker.endOffset <= startOffset || !(marker.type & markerTypes)) {
+ if (marker.endOffset <= startOffset || !markerTypes.contains(marker.type)) {
i++;
continue;
}
DocumentMarker& marker = markers[markerIndex];
// skip marker that is wrong type
- if (marker.type != markerType && markerType != DocumentMarker::AllMarkers)
+ if (marker.type != markerType)
continue;
IntRect& r = rects[markerIndex];
return Vector<DocumentMarker>();
}
+Vector<DocumentMarker> DocumentMarkerController::markersInRange(Range* range, DocumentMarker::MarkerType markerType)
+{
+ if (!possiblyHasMarkers(markerType))
+ 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 (markerType != 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;
DocumentMarker marker = markers[markerIndex];
// skip marker that is wrong type
- if (marker.type != markerType && markerType != DocumentMarker::AllMarkers)
+ if (marker.type != markerType)
continue;
IntRect r = rects[markerIndex];
removeMarkersFromMarkerMapVectorPair(node, vectorPair, markerTypes);
}
- m_possiblyExistingMarkerTypes &= ~markerTypes;
+ m_possiblyExistingMarkerTypes.remove(markerTypes);
}
// This function may release node and vectorPair.
void DocumentMarkerController::removeMarkersFromMarkerMapVectorPair(Node* node, MarkerMapVectorPair* vectorPair, DocumentMarker::MarkerTypes markerTypes)
{
- if (!~(markerTypes & DocumentMarker::AllMarkers)) {
+ if (markerTypes == DocumentMarker::AllMarkers()) {
delete vectorPair;
m_markers.remove(node);
if (RenderObject* renderer = node->renderer())
DocumentMarker marker = markers[i];
// skip nodes that are not of the specified type
- if (!(marker.type & markerTypes)) {
+ if (!markerTypes.contains(marker.type)) {
++i;
continue;
}
m_possiblyExistingMarkerTypes = 0;
}
-void DocumentMarkerController::repaintMarkers(DocumentMarker::MarkerType markerType)
+void DocumentMarkerController::repaintMarkers(DocumentMarker::MarkerTypes markerTypes)
{
- if (!possiblyHasMarkers(markerType))
+ if (!possiblyHasMarkers(markerTypes))
return;
ASSERT(!m_markers.isEmpty());
DocumentMarker marker = markers[i];
// skip nodes that are not of the specified type
- if (marker.type == markerType || markerType == DocumentMarker::AllMarkers) {
+ if (markerTypes.contains(marker.type)) {
nodeNeedsRepaint = true;
break;
}
}
}
-void DocumentMarkerController::shiftMarkers(Node* node, unsigned startOffset, int delta, DocumentMarker::MarkerType markerType)
+void DocumentMarkerController::shiftMarkers(Node* node, unsigned startOffset, int delta)
{
- if (!possiblyHasMarkers(markerType))
+ if (!possiblyHasMarkers(DocumentMarker::AllMarkers()))
return;
ASSERT(!m_markers.isEmpty());
bool docDirty = false;
for (size_t i = 0; i != markers.size(); ++i) {
DocumentMarker& marker = markers[i];
- if (marker.startOffset >= startOffset && (markerType == DocumentMarker::AllMarkers || marker.type == markerType)) {
+ if (marker.startOffset >= startOffset) {
ASSERT((int)marker.startOffset + delta >= 0);
marker.startOffset += delta;
marker.endOffset += delta;
void DocumentMarkerController::setMarkersActive(Range* range, bool active)
{
- if (!possiblyHasMarkers(DocumentMarker::AllMarkers))
+ if (!possiblyHasMarkers(DocumentMarker::AllMarkers()))
return;
ASSERT(!m_markers.isEmpty());
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 & it->type))
+ if (!markerTypes.contains(it->type))
continue;
- if (node == startContainer && node == endContainer) {
- // The range spans only one node.
- if (it->endOffset > static_cast<unsigned>(range->startOffset()) && it->startOffset < static_cast<unsigned>(range->endOffset()))
- return true;
- } else {
- if (node == startContainer) {
- if (it->endOffset > static_cast<unsigned>(range->startOffset()))
- return true;
- } else if (node == endContainer) {
- if (it->startOffset < static_cast<unsigned>(range->endOffset()))
- return true;
- } else
- return true;
- }
+ 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;
break;
// skip marker that is wrong type or before target
- if (marker.endOffset <= startOffset || !(marker.type & markerTypes)) {
+ if (marker.endOffset <= startOffset || !markerTypes.contains(marker.type)) {
i++;
continue;
}