static std::unique_ptr<RuleSet> makeRuleSet(const Vector<RuleFeature>& rules)
{
size_t size = rules.size();
if (!size)
return nullptr;
auto ruleSet = std::make_unique<RuleSet>();
for (size_t i = 0; i < size; ++i)
ruleSet->addRule(rules[i].rule, rules[i].selectorIndex, rules[i].hasDocumentSecurityOrigin ? RuleHasDocumentSecurityOrigin : RuleHasNoSpecialState);
ruleSet->shrinkToFit();
return ruleSet;
}
void
OpenSteer::PolylineSegmentedPathwaySegmentRadii::setPathway( size_type numOfPoints,
Ogre::Vector3 const points[],
float const radii[],
bool closedCycle )
{
assert( allRadiiNonNegative( radii, radii + radiiCount( numOfPoints, closedCycle ) ) && "All radii must be positive or zero." );
path_.setPath( numOfPoints, points, closedCycle );
segmentRadii_.assign( radii, radii + radiiCount( numOfPoints, closedCycle ) );
shrinkToFit( segmentRadii_ );
}
void
OpenSteer::PolylineSegmentedPath::setPath( size_type numOfPoints,
Vec3 const newPoints[],
bool closedCycle )
{
assert( 1 < numOfPoints && "Path must have at least two distinct points." );
// While testing say that no cyclus is used because the first point hasn't
// been copied to the back.
assert( adjacentPathPointsDifferent( newPoints, newPoints + numOfPoints, false ) && "Adjacent path points must be different." );
closedCycle_ = closedCycle;
size_type numberOfPoints = numOfPoints;
if ( closedCycle_ ) {
++numberOfPoints;
}
points_.reserve( numberOfPoints );
segmentTangents_.resize( numberOfPoints - 1 );
segmentLengths_.resize( numberOfPoints - 1 );
points_.assign( newPoints, newPoints + numOfPoints );
if ( closedCycle_ ) {
points_.push_back( points_[ 0 ] );
}
updateTangentsAndLengths( points_ ,
segmentTangents_,
segmentLengths_,
0,
numOfPoints,
closedCycle_ );
shrinkToFit( points_ );
shrinkToFit( segmentTangents_ );
shrinkToFit( segmentLengths_ );
}
std::unique_ptr<Lines> createLines(RenderBlockFlow& flow)
{
auto lines = std::make_unique<Lines>();
RenderText& textRenderer = toRenderText(*flow.firstChild());
ASSERT(!textRenderer.firstTextBox());
const RenderStyle& style = *flow.style();
const unsigned textLength = textRenderer.textLength();
float wordTrailingSpaceWidth = style.font().width(TextRun(&space, 1));
LazyLineBreakIterator lineBreakIterator(textRenderer.text(), style.locale());
int nextBreakable = -1;
unsigned lineEndOffset = 0;
while (lineEndOffset < textLength) {
lineEndOffset = skipWhitespaces(textRenderer, lineEndOffset, textLength);
unsigned lineStartOffset = lineEndOffset;
unsigned runEndOffset = lineEndOffset;
LineWidth lineWidth(flow, false, DoNotIndentText);
while (runEndOffset < textLength) {
ASSERT(!isWhitespace(textRenderer.characterAt(runEndOffset)));
bool previousWasSpaceBetweenRuns = runEndOffset > lineStartOffset && isWhitespace(textRenderer.characterAt(runEndOffset - 1));
unsigned runStartOffset = previousWasSpaceBetweenRuns ? runEndOffset - 1 : runEndOffset;
++runEndOffset;
while (runEndOffset < textLength) {
if (runEndOffset > lineStartOffset && isBreakable(lineBreakIterator, runEndOffset, nextBreakable, false))
break;
++runEndOffset;
}
unsigned runLength = runEndOffset - runStartOffset;
bool includeEndSpace = runEndOffset < textLength && textRenderer.characterAt(runEndOffset) == ' ';
float wordWidth;
if (includeEndSpace)
wordWidth = textWidth(textRenderer, runStartOffset, runLength + 1, lineWidth.committedWidth(), style) - wordTrailingSpaceWidth;
else
wordWidth = textWidth(textRenderer, runStartOffset, runLength, lineWidth.committedWidth(), style);
lineWidth.addUncommittedWidth(wordWidth);
if (!lineWidth.fitsOnLine()) {
if (!lineWidth.committedWidth()) {
lineWidth.commit();
lineEndOffset = runEndOffset;
}
break;
}
lineWidth.commit();
lineEndOffset = runEndOffset;
runEndOffset = skipWhitespaces(textRenderer, runEndOffset, textLength);
}
if (lineStartOffset == lineEndOffset)
continue;
Line line;
line.textOffset = lineStartOffset;
line.textLength = lineEndOffset - lineStartOffset;
line.width = lineWidth.committedWidth();
lines->append(line);
}
textRenderer.clearNeedsLayout();
lines->shrinkToFit();
return lines;
}
