SurroundingText::SurroundingText(const VisiblePosition& visiblePosition, unsigned maxLength)
: m_positionOffsetInContent(0)
{
if (visiblePosition.isNull())
return;
const unsigned halfMaxLength = maxLength / 2;
CharacterIterator forwardIterator(makeRange(visiblePosition, endOfDocument(visiblePosition)).get(), TextIteratorStopsOnFormControls);
if (!forwardIterator.atEnd())
forwardIterator.advance(maxLength - halfMaxLength);
Position position = visiblePosition.deepEquivalent().parentAnchoredEquivalent();
Document* document = position.document();
ASSERT(document);
RefPtr<Range> forwardRange = forwardIterator.range();
if (!forwardRange || !Range::create(*document, position, forwardRange->startPosition())->text().length()) {
ASSERT(forwardRange);
return;
}
BackwardsCharacterIterator backwardsIterator(makeRange(startOfDocument(visiblePosition), visiblePosition).get(), TextIteratorStopsOnFormControls);
if (!backwardsIterator.atEnd())
backwardsIterator.advance(halfMaxLength);
RefPtr<Range> backwardsRange = backwardsIterator.range();
if (!backwardsRange) {
ASSERT(backwardsRange);
return;
}
m_positionOffsetInContent = Range::create(*document, backwardsRange->endPosition(), position)->text().length();
m_contentRange = Range::create(*document, backwardsRange->endPosition(), forwardRange->startPosition());
ASSERT(m_contentRange);
}
void appendJoin(StringReference<Str>& dst, It1 first, It1 last,
Range<It2> delimiter)
{
if (first == last)
return;
auto appender = dst.getAppender();
appender.append(makeRange(*first));
while (++first != last)
{
appender.append(delimiter);
appender.append(makeRange(*first));
}
dst.terminate();
}
//////////////////////////domain/////////////////////////
const ValVec<htmRange> &
htmInterface::domain( SpatialDomain & domain ) {
domain.intersect(index_, idList_);
range_.cut(range_.length());
makeRange();
return range_;
}
const ValVec<htmRange> &
htmInterface::doHull() {
if(polyCorners_.length() < 3)
throw SpatialInterfaceError("htmInterface:convexHull: empty hull: points on one line");
SpatialVector v;
SpatialConvex x;
SpatialDomain d;
// The constraint we have for each side is a 0-constraint (great circle)
// passing through the 2 corners. Since we are in counterclockwise order,
// the vector product of the two successive corners just gives the correct
// constraint.
size_t i, len = polyCorners_.length();
for(i = 0; i < len; i++) {
v = polyCorners_[i].c_ ^ polyCorners_[ i == len-1 ? 0 : i + 1].c_;
#ifdef DIAG
cerr << v << " " << i << "," << i+1 << "\n";
#endif
v.normalize();
SpatialConstraint c(v,0);
x.add(c);
}
d.add(x);
d.intersect(index_, idList_);
range_.cut(range_.length());
makeRange();
return range_;
}
void appendJoin(StringReference<Str>& dst, It first, It last)
{
auto appender = dst.getAppender();
for (; first != last; ++first)
appender.append(makeRange(*first));
dst.terminate();
}
int offsetFromStartOfBlock(const VisiblePosition offset)
{
RefPtr<Range> range = makeRange(startOfBlock(offset), offset);
if (!range)
return -1;
return range->text().latin1().length();
}
PassRefPtr<InjectedBundleRangeHandle> InjectedBundleNodeHandle::visibleRange()
{
VisiblePosition start = firstPositionInNode(m_node.ptr());
VisiblePosition end = lastPositionInNode(m_node.ptr());
RefPtr<Range> range = makeRange(start, end);
return InjectedBundleRangeHandle::getOrCreate(range.get());
}
bool HitTestResult::isMisspelled() const
{
if (!targetNode() || !targetNode()->renderer())
return false;
VisiblePosition pos(targetNode()->renderer()->positionForPoint(localPoint()));
if (pos.isNull())
return false;
return m_innerNonSharedNode->document().markers().markersInRange(
makeRange(pos, pos).get(), DocumentMarker::MisspellingMarkers()).size() > 0;
}
PassRefPtr<Range> trimWhitespaceFromRange(VisiblePosition startPosition, VisiblePosition endPosition)
{
if (startPosition == endPosition || isRangeTextAllWhitespace(startPosition, endPosition))
return 0;
while (isWhitespace(startPosition.characterAfter()))
startPosition = startPosition.next();
while (isWhitespace(endPosition.characterBefore()))
endPosition = endPosition.previous();
return makeRange(startPosition, endPosition);
}
PassRefPtr<Range> LocalFrame::rangeForPoint(const IntPoint& framePoint)
{
VisiblePosition position = visiblePositionForPoint(framePoint);
if (position.isNull())
return nullptr;
VisiblePosition previous = position.previous();
if (previous.isNotNull()) {
RefPtr<Range> previousCharacterRange = makeRange(previous, position);
LayoutRect rect = firstRectForRange(previousCharacterRange.get());
if (rect.contains(framePoint))
return previousCharacterRange.release();
}
VisiblePosition next = position.next();
if (RefPtr<Range> nextCharacterRange = makeRange(position, next)) {
LayoutRect rect = firstRectForRange(nextCharacterRange.get());
if (rect.contains(framePoint))
return nextCharacterRange.release();
}
return nullptr;
}
const ValVec<htmRange> &
htmInterface::circleRegion( float64 ra,
float64 dec,
float64 rad ) {
SpatialDomain domain;
SpatialConvex convex;
float64 d = cos(gPi * rad/10800.0);
SpatialConstraint c(SpatialVector(ra,dec),d);
convex.add(c);
domain.add(convex);
domain.intersect(index_, idList_);
range_.cut(range_.length());
makeRange();
return range_;
}
void Editor::transpose()
{
if (!canEdit())
return;
VisibleSelection selection = m_frame.selection().selection();
if (!selection.isCaret())
return;
// Make a selection that goes back one character and forward two characters.
VisiblePosition caret = selection.visibleStart();
VisiblePosition next = isEndOfParagraph(caret) ? caret : caret.next();
VisiblePosition previous = next.previous();
if (next == previous)
return;
previous = previous.previous();
if (!inSameParagraph(next, previous))
return;
RefPtr<Range> range = makeRange(previous, next);
if (!range)
return;
VisibleSelection newSelection(range.get(), DOWNSTREAM);
// Transpose the two characters.
String text = plainText(range.get());
if (text.length() != 2)
return;
String transposed = text.right(1) + text.left(1);
// Select the two characters.
if (newSelection != m_frame.selection().selection())
m_frame.selection().setSelection(newSelection);
// Insert the transposed characters.
replaceSelectionWithText(transposed, false, false);
}
Instruction Instruction::makeJumpTableRange(byte first, byte last) {
Instruction i = makeRange(first, last);
i.OpCode = JUMP_TABLE_RANGE_OP;
return i;
}
static int32_t insertionPointFromCurrentSelection(const VisibleSelection& currentSelection)
{
VisiblePosition selectionStart = currentSelection.visibleStart();
VisiblePosition paragraphStart = startOfParagraph(selectionStart);
return TextIterator::rangeLength(makeRange(paragraphStart, selectionStart).get());
}
