gecko-dev/gfx/thebes/gfxSkipChars.h

303 lines
9.3 KiB
C++

/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 4 -*-
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#ifndef GFX_SKIP_CHARS_H
#define GFX_SKIP_CHARS_H
#include "nsTArray.h"
/*
* gfxSkipChars is a data structure representing a list of characters that
* have been skipped. The initial string is called the "original string"
* and after skipping some characters, the result is called the "skipped string".
* gfxSkipChars provides efficient ways to translate between offsets in the
* original string and the skipped string. It is used by textrun code to keep
* track of offsets before and after text transformations such as whitespace
* compression and control code deletion.
*/
/**
* The gfxSkipChars is represented as a sorted array of skipped ranges.
*
* A freshly-created gfxSkipChars means "all chars kept".
*/
class gfxSkipChars
{
private:
class SkippedRange
{
public:
SkippedRange(uint32_t aOffset, uint32_t aLength, uint32_t aDelta)
: mOffset(aOffset), mLength(aLength), mDelta(aDelta)
{ }
uint32_t Start() const
{
return mOffset;
}
uint32_t End() const
{
return mOffset + mLength;
}
uint32_t Length() const
{
return mLength;
}
uint32_t SkippedOffset() const
{
return mOffset - mDelta;
}
uint32_t Delta() const
{
return mDelta;
}
uint32_t NextDelta() const
{
return mDelta + mLength;
}
void Extend(uint32_t aChars)
{
mLength += aChars;
}
private:
uint32_t mOffset; // original-string offset at which we want to skip
uint32_t mLength; // number of skipped chars at this offset
uint32_t mDelta; // sum of lengths of preceding skipped-ranges
};
public:
gfxSkipChars()
: mCharCount(0)
{ }
void SkipChars(uint32_t aChars)
{
NS_ASSERTION(mCharCount + aChars > mCharCount,
"Character count overflow");
uint32_t rangeCount = mRanges.Length();
uint32_t delta = 0;
if (rangeCount > 0) {
SkippedRange& lastRange = mRanges[rangeCount - 1];
if (lastRange.End() == mCharCount) {
lastRange.Extend(aChars);
mCharCount += aChars;
return;
}
delta = lastRange.NextDelta();
}
mRanges.AppendElement(SkippedRange(mCharCount, aChars, delta));
mCharCount += aChars;
}
void KeepChars(uint32_t aChars)
{
NS_ASSERTION(mCharCount + aChars > mCharCount,
"Character count overflow");
mCharCount += aChars;
}
void SkipChar()
{
SkipChars(1);
}
void KeepChar()
{
KeepChars(1);
}
void TakeFrom(gfxSkipChars* aSkipChars)
{
mRanges.SwapElements(aSkipChars->mRanges);
mCharCount = aSkipChars->mCharCount;
aSkipChars->mCharCount = 0;
}
int32_t GetOriginalCharCount() const
{
return mCharCount;
}
const SkippedRange& LastRange() const
{
// this is only valid if mRanges is non-empty; no assertion here
// because nsTArray will already assert if we abuse it
return mRanges[mRanges.Length() - 1];
}
friend class gfxSkipCharsIterator;
private:
nsTArray<SkippedRange> mRanges;
uint32_t mCharCount;
};
/**
* A gfxSkipCharsIterator represents a position in the original string. It lets you
* map efficiently to and from positions in the string after skipped characters
* have been removed. You can also specify an offset that is added to all
* incoming original string offsets and subtracted from all outgoing original
* string offsets --- useful when the gfxSkipChars corresponds to something
* offset from the original DOM coordinates, which it often does for gfxTextRuns.
*
* The current positions (in both the original and skipped strings) are
* always constrained to be >= 0 and <= the string length. When the position
* is equal to the string length, it is at the end of the string. The current
* positions do not include any aOriginalStringToSkipCharsOffset.
*
* When the position in the original string corresponds to a skipped character,
* the skipped-characters offset is the offset of the next unskipped character,
* or the skipped-characters string length if there is no next unskipped character.
*/
class gfxSkipCharsIterator
{
public:
/**
* @param aOriginalStringToSkipCharsOffset add this to all incoming and
* outgoing original string offsets
*/
gfxSkipCharsIterator(const gfxSkipChars& aSkipChars,
int32_t aOriginalStringToSkipCharsOffset,
int32_t aOriginalStringOffset)
: mSkipChars(&aSkipChars),
mOriginalStringOffset(0),
mSkippedStringOffset(0),
mCurrentRangeIndex(-1),
mOriginalStringToSkipCharsOffset(aOriginalStringToSkipCharsOffset)
{
SetOriginalOffset(aOriginalStringOffset);
}
gfxSkipCharsIterator(const gfxSkipChars& aSkipChars,
int32_t aOriginalStringToSkipCharsOffset = 0)
: mSkipChars(&aSkipChars),
mOriginalStringOffset(0),
mSkippedStringOffset(0),
mCurrentRangeIndex(-1),
mOriginalStringToSkipCharsOffset(aOriginalStringToSkipCharsOffset)
{ }
gfxSkipCharsIterator(const gfxSkipCharsIterator& aIterator)
: mSkipChars(aIterator.mSkipChars),
mOriginalStringOffset(aIterator.mOriginalStringOffset),
mSkippedStringOffset(aIterator.mSkippedStringOffset),
mCurrentRangeIndex(aIterator.mCurrentRangeIndex),
mOriginalStringToSkipCharsOffset(aIterator.mOriginalStringToSkipCharsOffset)
{ }
/**
* The empty constructor creates an object that is useless until it is assigned.
*/
gfxSkipCharsIterator()
: mSkipChars(nullptr)
{ }
/**
* Return true if this iterator is properly initialized and usable.
*/
bool IsInitialized()
{
return mSkipChars != nullptr;
}
/**
* Set the iterator to aOriginalStringOffset in the original string.
* This can efficiently move forward or backward from the current position.
* aOriginalStringOffset is clamped to [0,originalStringLength].
*/
void SetOriginalOffset(int32_t aOriginalStringOffset);
/**
* Set the iterator to aSkippedStringOffset in the skipped string.
* This can efficiently move forward or backward from the current position.
* aSkippedStringOffset is clamped to [0,skippedStringLength].
*/
void SetSkippedOffset(uint32_t aSkippedStringOffset);
uint32_t ConvertOriginalToSkipped(int32_t aOriginalStringOffset)
{
SetOriginalOffset(aOriginalStringOffset);
return GetSkippedOffset();
}
uint32_t ConvertSkippedToOriginal(int32_t aSkippedStringOffset)
{
SetSkippedOffset(aSkippedStringOffset);
return GetOriginalOffset();
}
/**
* Test if the character at the current position in the original string
* is skipped or not. If aRunLength is non-null, then *aRunLength is set
* to a number of characters all of which are either skipped or not, starting
* at this character. When the current position is at the end of the original
* string, we return true and *aRunLength is set to zero.
*/
bool IsOriginalCharSkipped(int32_t* aRunLength = nullptr) const;
void AdvanceOriginal(int32_t aDelta)
{
SetOriginalOffset(GetOriginalOffset() + aDelta);
}
void AdvanceSkipped(int32_t aDelta)
{
SetSkippedOffset(GetSkippedOffset() + aDelta);
}
/**
* @return the offset within the original string
*/
int32_t GetOriginalOffset() const
{
return mOriginalStringOffset - mOriginalStringToSkipCharsOffset;
}
/**
* @return the offset within the skipped string corresponding to the
* current position in the original string. If the current position
* in the original string is a character that is skipped, then we return
* the position corresponding to the first non-skipped character in the
* original string after the current position, or the length of the skipped
* string if there is no such character.
*/
uint32_t GetSkippedOffset() const
{
return mSkippedStringOffset;
}
int32_t GetOriginalEnd() const
{
return mSkipChars->GetOriginalCharCount() -
mOriginalStringToSkipCharsOffset;
}
private:
const gfxSkipChars* mSkipChars;
// Current position
int32_t mOriginalStringOffset;
uint32_t mSkippedStringOffset;
// Index of the last skippedRange that precedes or contains the current
// position in the original string.
// If index == -1 then we are before the first skipped char.
int32_t mCurrentRangeIndex;
// This offset is added to map from "skipped+unskipped characters in
// the original DOM string" character space to "skipped+unskipped
// characters in the textrun's gfxSkipChars" character space
int32_t mOriginalStringToSkipCharsOffset;
};
#endif /*GFX_SKIP_CHARS_H*/