diff options
Diffstat (limited to 'layout/base/nsBidiPresUtils.cpp')
| -rw-r--r-- | layout/base/nsBidiPresUtils.cpp | 2297 |
1 files changed, 2297 insertions, 0 deletions
diff --git a/layout/base/nsBidiPresUtils.cpp b/layout/base/nsBidiPresUtils.cpp new file mode 100644 index 000000000..b3c20aabb --- /dev/null +++ b/layout/base/nsBidiPresUtils.cpp @@ -0,0 +1,2297 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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/. */ + +#include "mozilla/IntegerRange.h" + +#include "nsAutoPtr.h" +#include "nsBidiPresUtils.h" +#include "nsFontMetrics.h" +#include "nsGkAtoms.h" +#include "nsPresContext.h" +#include "nsRenderingContext.h" +#include "nsBidiUtils.h" +#include "nsCSSFrameConstructor.h" +#include "nsContainerFrame.h" +#include "nsInlineFrame.h" +#include "nsPlaceholderFrame.h" +#include "nsFirstLetterFrame.h" +#include "nsUnicodeProperties.h" +#include "nsTextFrame.h" +#include "nsBlockFrame.h" +#include "nsIFrameInlines.h" +#include "nsStyleStructInlines.h" +#include "RubyUtils.h" +#include "nsRubyFrame.h" +#include "nsRubyBaseFrame.h" +#include "nsRubyTextFrame.h" +#include "nsRubyBaseContainerFrame.h" +#include "nsRubyTextContainerFrame.h" +#include <algorithm> + +#undef NOISY_BIDI +#undef REALLY_NOISY_BIDI + +using namespace mozilla; + +static const char16_t kSpace = 0x0020; +static const char16_t kZWSP = 0x200B; +static const char16_t kLineSeparator = 0x2028; +static const char16_t kObjectSubstitute = 0xFFFC; +static const char16_t kLRE = 0x202A; +static const char16_t kRLE = 0x202B; +static const char16_t kLRO = 0x202D; +static const char16_t kRLO = 0x202E; +static const char16_t kPDF = 0x202C; +static const char16_t kLRI = 0x2066; +static const char16_t kRLI = 0x2067; +static const char16_t kFSI = 0x2068; +static const char16_t kPDI = 0x2069; +static const char16_t kSeparators[] = { + // All characters with Bidi type Segment Separator or Block Separator + char16_t('\t'), + char16_t('\r'), + char16_t('\n'), + char16_t(0xb), + char16_t(0x1c), + char16_t(0x1d), + char16_t(0x1e), + char16_t(0x1f), + char16_t(0x85), + char16_t(0x2029), + char16_t(0) +}; + +#define NS_BIDI_CONTROL_FRAME ((nsIFrame*)0xfffb1d1) + +static bool +IsIsolateControl(char16_t aChar) +{ + return aChar == kLRI || aChar == kRLI || aChar == kFSI; +} + +// Given a style context, return any bidi control character necessary to +// implement style properties that override directionality (i.e. if it has +// unicode-bidi:bidi-override, or text-orientation:upright in vertical +// writing mode) when applying the bidi algorithm. +// +// Returns 0 if no override control character is implied by this style. +static char16_t +GetBidiOverride(nsStyleContext* aStyleContext) +{ + const nsStyleVisibility* vis = aStyleContext->StyleVisibility(); + if ((vis->mWritingMode == NS_STYLE_WRITING_MODE_VERTICAL_RL || + vis->mWritingMode == NS_STYLE_WRITING_MODE_VERTICAL_LR) && + vis->mTextOrientation == NS_STYLE_TEXT_ORIENTATION_UPRIGHT) { + return kLRO; + } + const nsStyleTextReset* text = aStyleContext->StyleTextReset(); + if (text->mUnicodeBidi & NS_STYLE_UNICODE_BIDI_BIDI_OVERRIDE) { + return NS_STYLE_DIRECTION_RTL == vis->mDirection ? kRLO : kLRO; + } + return 0; +} + +// Given a style context, return any bidi control character necessary to +// implement style properties that affect bidi resolution (i.e. if it +// has unicode-bidiembed, isolate, or plaintext) when applying the bidi +// algorithm. +// +// Returns 0 if no control character is implied by the style. +// +// Note that GetBidiOverride and GetBidiControl need to be separate +// because in the case of unicode-bidi:isolate-override we need both +// FSI and LRO/RLO. +static char16_t +GetBidiControl(nsStyleContext* aStyleContext) +{ + const nsStyleVisibility* vis = aStyleContext->StyleVisibility(); + const nsStyleTextReset* text = aStyleContext->StyleTextReset(); + if (text->mUnicodeBidi & NS_STYLE_UNICODE_BIDI_EMBED) { + return NS_STYLE_DIRECTION_RTL == vis->mDirection ? kRLE : kLRE; + } + if (text->mUnicodeBidi & NS_STYLE_UNICODE_BIDI_ISOLATE) { + if (text->mUnicodeBidi & NS_STYLE_UNICODE_BIDI_BIDI_OVERRIDE) { + // isolate-override + return kFSI; + } + // <bdi> element already has its directionality set from content so + // we never need to return kFSI. + return NS_STYLE_DIRECTION_RTL == vis->mDirection ? kRLI : kLRI; + } + if (text->mUnicodeBidi & NS_STYLE_UNICODE_BIDI_PLAINTEXT) { + return kFSI; + } + return 0; +} + +struct BidiParagraphData { + nsString mBuffer; + AutoTArray<char16_t, 16> mEmbeddingStack; + nsTArray<nsIFrame*> mLogicalFrames; + nsTArray<nsLineBox*> mLinePerFrame; + nsDataHashtable<nsISupportsHashKey, int32_t> mContentToFrameIndex; + // Cached presentation context for the frames we're processing. + nsPresContext* mPresContext; + bool mIsVisual; + nsBidiLevel mParaLevel; + nsIContent* mPrevContent; + nsAutoPtr<nsBidi> mBidiEngine; + nsIFrame* mPrevFrame; +#ifdef DEBUG + // Only used for NOISY debug output. + nsBlockFrame* mCurrentBlock; +#endif + + void Init(nsBlockFrame* aBlockFrame) + { + mBidiEngine = new nsBidi(); + mPrevContent = nullptr; +#ifdef DEBUG + mCurrentBlock = aBlockFrame; +#endif + + mParaLevel = nsBidiPresUtils::BidiLevelFromStyle(aBlockFrame->StyleContext()); + + mPresContext = aBlockFrame->PresContext(); + mIsVisual = mPresContext->IsVisualMode(); + if (mIsVisual) { + /** + * Drill up in content to detect whether this is an element that needs to + * be rendered with logical order even on visual pages. + * + * We always use logical order on form controls, firstly so that text + * entry will be in logical order, but also because visual pages were + * written with the assumption that even if the browser had no support + * for right-to-left text rendering, it would use native widgets with + * bidi support to display form controls. + * + * We also use logical order in XUL elements, since we expect that if a + * XUL element appears in a visual page, it will be generated by an XBL + * binding and contain localized text which will be in logical order. + */ + for (nsIContent* content = aBlockFrame->GetContent() ; content; + content = content->GetParent()) { + if (content->IsNodeOfType(nsINode::eHTML_FORM_CONTROL) || + content->IsXULElement()) { + mIsVisual = false; + break; + } + } + } + } + + nsresult SetPara() + { + return mBidiEngine->SetPara(mBuffer.get(), BufferLength(), + mParaLevel); + } + + /** + * mParaLevel can be NSBIDI_DEFAULT_LTR as well as NSBIDI_LTR or NSBIDI_RTL. + * GetParaLevel() returns the actual (resolved) paragraph level which is + * always either NSBIDI_LTR or NSBIDI_RTL + */ + nsBidiLevel GetParaLevel() + { + nsBidiLevel paraLevel = mParaLevel; + if (paraLevel == NSBIDI_DEFAULT_LTR || paraLevel == NSBIDI_DEFAULT_RTL) { + mBidiEngine->GetParaLevel(¶Level); + } + return paraLevel; + } + + nsBidiDirection GetDirection() + { + nsBidiDirection dir; + mBidiEngine->GetDirection(&dir); + return dir; + } + + nsresult CountRuns(int32_t *runCount){ return mBidiEngine->CountRuns(runCount); } + + nsresult GetLogicalRun(int32_t aLogicalStart, + int32_t* aLogicalLimit, + nsBidiLevel* aLevel) + { + nsresult rv = mBidiEngine->GetLogicalRun(aLogicalStart, + aLogicalLimit, aLevel); + if (mIsVisual || NS_FAILED(rv)) + *aLevel = GetParaLevel(); + return rv; + } + + void ResetData() + { + mLogicalFrames.Clear(); + mLinePerFrame.Clear(); + mContentToFrameIndex.Clear(); + mBuffer.SetLength(0); + mPrevContent = nullptr; + for (uint32_t i = 0; i < mEmbeddingStack.Length(); ++i) { + mBuffer.Append(mEmbeddingStack[i]); + mLogicalFrames.AppendElement(NS_BIDI_CONTROL_FRAME); + mLinePerFrame.AppendElement((nsLineBox*)nullptr); + } + } + + void AppendFrame(nsIFrame* aFrame, + nsBlockInFlowLineIterator* aLineIter, + nsIContent* aContent = nullptr) + { + if (aContent) { + mContentToFrameIndex.Put(aContent, FrameCount()); + } + mLogicalFrames.AppendElement(aFrame); + + AdvanceLineIteratorToFrame(aFrame, aLineIter, mPrevFrame); + mLinePerFrame.AppendElement(aLineIter->GetLine().get()); + } + + void AdvanceAndAppendFrame(nsIFrame** aFrame, + nsBlockInFlowLineIterator* aLineIter, + nsIFrame** aNextSibling) + { + nsIFrame* frame = *aFrame; + nsIFrame* nextSibling = *aNextSibling; + + frame = frame->GetNextContinuation(); + if (frame) { + AppendFrame(frame, aLineIter, nullptr); + + /* + * If we have already overshot the saved next-sibling while + * scanning the frame's continuations, advance it. + */ + if (frame == nextSibling) { + nextSibling = frame->GetNextSibling(); + } + } + + *aFrame = frame; + *aNextSibling = nextSibling; + } + + int32_t GetLastFrameForContent(nsIContent *aContent) + { + int32_t index = 0; + mContentToFrameIndex.Get(aContent, &index); + return index; + } + + int32_t FrameCount(){ return mLogicalFrames.Length(); } + + int32_t BufferLength(){ return mBuffer.Length(); } + + nsIFrame* FrameAt(int32_t aIndex){ return mLogicalFrames[aIndex]; } + + nsLineBox* GetLineForFrameAt(int32_t aIndex){ return mLinePerFrame[aIndex]; } + + void AppendUnichar(char16_t aCh){ mBuffer.Append(aCh); } + + void AppendString(const nsDependentSubstring& aString){ mBuffer.Append(aString); } + + void AppendControlChar(char16_t aCh) + { + mLogicalFrames.AppendElement(NS_BIDI_CONTROL_FRAME); + mLinePerFrame.AppendElement((nsLineBox*)nullptr); + AppendUnichar(aCh); + } + + void PushBidiControl(char16_t aCh) + { + AppendControlChar(aCh); + mEmbeddingStack.AppendElement(aCh); + } + + void AppendPopChar(char16_t aCh) + { + AppendControlChar(IsIsolateControl(aCh) ? kPDI : kPDF); + } + + void PopBidiControl(char16_t aCh) + { + MOZ_ASSERT(mEmbeddingStack.Length(), "embedding/override underflow"); + MOZ_ASSERT(aCh == mEmbeddingStack.LastElement()); + AppendPopChar(aCh); + mEmbeddingStack.TruncateLength(mEmbeddingStack.Length() - 1); + } + + void ClearBidiControls() + { + for (char16_t c : Reversed(mEmbeddingStack)) { + AppendPopChar(c); + } + } + + static bool + IsFrameInCurrentLine(nsBlockInFlowLineIterator* aLineIter, + nsIFrame* aPrevFrame, nsIFrame* aFrame) + { + nsIFrame* endFrame = aLineIter->IsLastLineInList() ? nullptr : + aLineIter->GetLine().next()->mFirstChild; + nsIFrame* startFrame = aPrevFrame ? aPrevFrame : aLineIter->GetLine()->mFirstChild; + for (nsIFrame* frame = startFrame; frame && frame != endFrame; + frame = frame->GetNextSibling()) { + if (frame == aFrame) + return true; + } + return false; + } + + static void + AdvanceLineIteratorToFrame(nsIFrame* aFrame, + nsBlockInFlowLineIterator* aLineIter, + nsIFrame*& aPrevFrame) + { + // Advance aLine to the line containing aFrame + nsIFrame* child = aFrame; + nsIFrame* parent = nsLayoutUtils::GetParentOrPlaceholderFor(child); + while (parent && !nsLayoutUtils::GetAsBlock(parent)) { + child = parent; + parent = nsLayoutUtils::GetParentOrPlaceholderFor(child); + } + NS_ASSERTION (parent, "aFrame is not a descendent of a block frame"); + while (!IsFrameInCurrentLine(aLineIter, aPrevFrame, child)) { +#ifdef DEBUG + bool hasNext = +#endif + aLineIter->Next(); + NS_ASSERTION(hasNext, "Can't find frame in lines!"); + aPrevFrame = nullptr; + } + aPrevFrame = child; + } + +}; + +struct BidiLineData { + nsTArray<nsIFrame*> mLogicalFrames; + nsTArray<nsIFrame*> mVisualFrames; + nsTArray<int32_t> mIndexMap; + AutoTArray<uint8_t, 18> mLevels; + bool mIsReordered; + + BidiLineData(nsIFrame* aFirstFrameOnLine, int32_t aNumFramesOnLine) + { + /** + * Initialize the logically-ordered array of frames using the top-level + * frames of a single line + */ + mLogicalFrames.Clear(); + + bool isReordered = false; + bool hasRTLFrames = false; + bool hasVirtualControls = false; + + auto appendFrame = [&](nsIFrame* frame, nsBidiLevel level) { + mLogicalFrames.AppendElement(frame); + mLevels.AppendElement(level); + mIndexMap.AppendElement(0); + if (IS_LEVEL_RTL(level)) { + hasRTLFrames = true; + } + }; + + bool firstFrame = true; + for (nsIFrame* frame = aFirstFrameOnLine; + frame && aNumFramesOnLine--; + frame = frame->GetNextSibling()) { + FrameBidiData bidiData = nsBidiPresUtils::GetFrameBidiData(frame); + // Ignore virtual control before the first frame. Doing so should + // not affect the visual result, but could avoid running into the + // stripping code below for many cases. + if (!firstFrame && bidiData.precedingControl != kBidiLevelNone) { + appendFrame(NS_BIDI_CONTROL_FRAME, bidiData.precedingControl); + hasVirtualControls = true; + } + appendFrame(frame, bidiData.embeddingLevel); + firstFrame = false; + } + + // Reorder the line + nsBidi::ReorderVisual(mLevels.Elements(), FrameCount(), + mIndexMap.Elements()); + + // Strip virtual frames + if (hasVirtualControls) { + auto originalCount = mLogicalFrames.Length(); + nsTArray<int32_t> realFrameMap(originalCount); + size_t count = 0; + for (auto i : MakeRange(originalCount)) { + if (mLogicalFrames[i] == NS_BIDI_CONTROL_FRAME) { + realFrameMap.AppendElement(-1); + } else { + mLogicalFrames[count] = mLogicalFrames[i]; + mLevels[count] = mLevels[i]; + realFrameMap.AppendElement(count); + count++; + } + } + // Only keep index map for real frames. + for (size_t i = 0, j = 0; i < originalCount; ++i) { + auto newIndex = realFrameMap[mIndexMap[i]]; + if (newIndex != -1) { + mIndexMap[j] = newIndex; + j++; + } + } + mLogicalFrames.TruncateLength(count); + mLevels.TruncateLength(count); + mIndexMap.TruncateLength(count); + } + + for (int32_t i = 0; i < FrameCount(); i++) { + mVisualFrames.AppendElement(LogicalFrameAt(mIndexMap[i])); + if (i != mIndexMap[i]) { + isReordered = true; + } + } + + // If there's an RTL frame, assume the line is reordered + mIsReordered = isReordered || hasRTLFrames; + } + + int32_t FrameCount(){ return mLogicalFrames.Length(); } + + nsIFrame* LogicalFrameAt(int32_t aIndex){ return mLogicalFrames[aIndex]; } + + nsIFrame* VisualFrameAt(int32_t aIndex){ return mVisualFrames[aIndex]; } +}; + +#ifdef DEBUG +extern "C" { +void MOZ_EXPORT +DumpFrameArray(const nsTArray<nsIFrame*>& aFrames) +{ + for (nsIFrame* frame : aFrames) { + if (frame == NS_BIDI_CONTROL_FRAME) { + fprintf_stderr(stderr, "(Bidi control frame)\n"); + } else { + frame->List(); + } + } +} + +void MOZ_EXPORT +DumpBidiLine(BidiLineData* aData, bool aVisualOrder) +{ + DumpFrameArray(aVisualOrder ? aData->mVisualFrames : aData->mLogicalFrames); +} +} +#endif + +/* Some helper methods for Resolve() */ + +// Should this frame be split between text runs? +static bool +IsBidiSplittable(nsIFrame* aFrame) +{ + // Bidi inline containers should be split, unless they're line frames. + nsIAtom* frameType = aFrame->GetType(); + return (aFrame->IsFrameOfType(nsIFrame::eBidiInlineContainer) && + frameType != nsGkAtoms::lineFrame) || + frameType == nsGkAtoms::textFrame; +} + +// Should this frame be treated as a leaf (e.g. when building mLogicalFrames)? +static bool +IsBidiLeaf(nsIFrame* aFrame) +{ + nsIFrame* kid = aFrame->PrincipalChildList().FirstChild(); + return !kid || !aFrame->IsFrameOfType(nsIFrame::eBidiInlineContainer); +} + +/** + * Create non-fluid continuations for the ancestors of a given frame all the way + * up the frame tree until we hit a non-splittable frame (a line or a block). + * + * @param aParent the first parent frame to be split + * @param aFrame the child frames after this frame are reparented to the + * newly-created continuation of aParent. + * If aFrame is null, all the children of aParent are reparented. + */ +static nsresult +SplitInlineAncestors(nsContainerFrame* aParent, + nsIFrame* aFrame) +{ + nsPresContext* presContext = aParent->PresContext(); + nsIPresShell* presShell = presContext->PresShell(); + nsIFrame* frame = aFrame; + nsContainerFrame* parent = aParent; + nsContainerFrame* newParent; + + while (IsBidiSplittable(parent)) { + nsContainerFrame* grandparent = parent->GetParent(); + NS_ASSERTION(grandparent, "Couldn't get parent's parent in nsBidiPresUtils::SplitInlineAncestors"); + + // Split the child list after |frame|, unless it is the last child. + if (!frame || frame->GetNextSibling()) { + + newParent = static_cast<nsContainerFrame*>(presShell->FrameConstructor()-> + CreateContinuingFrame(presContext, parent, grandparent, false)); + + nsFrameList tail = parent->StealFramesAfter(frame); + + // Reparent views as necessary + nsresult rv; + rv = nsContainerFrame::ReparentFrameViewList(tail, parent, newParent); + if (NS_FAILED(rv)) { + return rv; + } + + // The parent's continuation adopts the siblings after the split. + newParent->InsertFrames(nsIFrame::kNoReflowPrincipalList, nullptr, tail); + + // The list name kNoReflowPrincipalList would indicate we don't want reflow + nsFrameList temp(newParent, newParent); + grandparent->InsertFrames(nsIFrame::kNoReflowPrincipalList, parent, temp); + } + + frame = parent; + parent = grandparent; + } + + return NS_OK; +} + +static void +MakeContinuationFluid(nsIFrame* aFrame, nsIFrame* aNext) +{ + NS_ASSERTION (!aFrame->GetNextInFlow() || aFrame->GetNextInFlow() == aNext, + "next-in-flow is not next continuation!"); + aFrame->SetNextInFlow(aNext); + + NS_ASSERTION (!aNext->GetPrevInFlow() || aNext->GetPrevInFlow() == aFrame, + "prev-in-flow is not prev continuation!"); + aNext->SetPrevInFlow(aFrame); +} + +static void +MakeContinuationsNonFluidUpParentChain(nsIFrame* aFrame, nsIFrame* aNext) +{ + nsIFrame* frame; + nsIFrame* next; + + for (frame = aFrame, next = aNext; + frame && next && + next != frame && next == frame->GetNextInFlow() && + IsBidiSplittable(frame); + frame = frame->GetParent(), next = next->GetParent()) { + + frame->SetNextContinuation(next); + next->SetPrevContinuation(frame); + } +} + +// If aFrame is the last child of its parent, convert bidi continuations to +// fluid continuations for all of its inline ancestors. +// If it isn't the last child, make sure that its continuation is fluid. +static void +JoinInlineAncestors(nsIFrame* aFrame) +{ + nsIFrame* frame = aFrame; + do { + nsIFrame* next = frame->GetNextContinuation(); + if (next) { + MakeContinuationFluid(frame, next); + } + // Join the parent only as long as we're its last child. + if (frame->GetNextSibling()) + break; + frame = frame->GetParent(); + } while (frame && IsBidiSplittable(frame)); +} + +static nsresult +CreateContinuation(nsIFrame* aFrame, + nsIFrame** aNewFrame, + bool aIsFluid) +{ + NS_PRECONDITION(aNewFrame, "null OUT ptr"); + NS_PRECONDITION(aFrame, "null ptr"); + + *aNewFrame = nullptr; + + nsPresContext *presContext = aFrame->PresContext(); + nsIPresShell *presShell = presContext->PresShell(); + NS_ASSERTION(presShell, "PresShell must be set on PresContext before calling nsBidiPresUtils::CreateContinuation"); + + nsContainerFrame* parent = aFrame->GetParent(); + NS_ASSERTION(parent, "Couldn't get frame parent in nsBidiPresUtils::CreateContinuation"); + + nsresult rv = NS_OK; + + // Have to special case floating first letter frames because the continuation + // doesn't go in the first letter frame. The continuation goes with the rest + // of the text that the first letter frame was made out of. + if (parent->GetType() == nsGkAtoms::letterFrame && + parent->IsFloating()) { + nsFirstLetterFrame* letterFrame = do_QueryFrame(parent); + rv = letterFrame->CreateContinuationForFloatingParent(presContext, aFrame, + aNewFrame, aIsFluid); + return rv; + } + + *aNewFrame = presShell->FrameConstructor()-> + CreateContinuingFrame(presContext, aFrame, parent, aIsFluid); + + // The list name kNoReflowPrincipalList would indicate we don't want reflow + // XXXbz this needs higher-level framelist love + nsFrameList temp(*aNewFrame, *aNewFrame); + parent->InsertFrames(nsIFrame::kNoReflowPrincipalList, aFrame, temp); + + if (!aIsFluid) { + // Split inline ancestor frames + rv = SplitInlineAncestors(parent, aFrame); + if (NS_FAILED(rv)) { + return rv; + } + } + + return NS_OK; +} + +/* + * Overview of the implementation of Resolve(): + * + * Walk through the descendants of aBlockFrame and build: + * * mLogicalFrames: an nsTArray of nsIFrame* pointers in logical order + * * mBuffer: an nsString containing a representation of + * the content of the frames. + * In the case of text frames, this is the actual text context of the + * frames, but some other elements are represented in a symbolic form which + * will make the Unicode Bidi Algorithm give the correct results. + * Bidi isolates, embeddings, and overrides set by CSS, <bdi>, or <bdo> + * elements are represented by the corresponding Unicode control characters. + * <br> elements are represented by U+2028 LINE SEPARATOR + * Other inline elements are represented by U+FFFC OBJECT REPLACEMENT + * CHARACTER + * + * Then pass mBuffer to the Bidi engine for resolving of embedding levels + * by nsBidi::SetPara() and division into directional runs by + * nsBidi::CountRuns(). + * + * Finally, walk these runs in logical order using nsBidi::GetLogicalRun() and + * correlate them with the frames indexed in mLogicalFrames, setting the + * baseLevel and embeddingLevel properties according to the results returned + * by the Bidi engine. + * + * The rendering layer requires each text frame to contain text in only one + * direction, so we may need to call EnsureBidiContinuation() to split frames. + * We may also need to call RemoveBidiContinuation() to convert frames created + * by EnsureBidiContinuation() in previous reflows into fluid continuations. + */ +nsresult +nsBidiPresUtils::Resolve(nsBlockFrame* aBlockFrame) +{ + BidiParagraphData bpd; + bpd.Init(aBlockFrame); + + // Handle bidi-override being set on the block itself before calling + // TraverseFrames. + // No need to call GetBidiControl as well, because isolate and embed + // values of unicode-bidi property are redundant on block elements. + // unicode-bidi:plaintext on a block element is handled by block frame + // via using nsIFrame::GetWritingMode(nsIFrame*). + char16_t ch = GetBidiOverride(aBlockFrame->StyleContext()); + if (ch != 0) { + bpd.PushBidiControl(ch); + } + for (nsBlockFrame* block = aBlockFrame; block; + block = static_cast<nsBlockFrame*>(block->GetNextContinuation())) { +#ifdef DEBUG + bpd.mCurrentBlock = block; +#endif + block->RemoveStateBits(NS_BLOCK_NEEDS_BIDI_RESOLUTION); + nsBlockInFlowLineIterator it(block, block->LinesBegin()); + bpd.mPrevFrame = nullptr; + TraverseFrames(&it, block->PrincipalChildList().FirstChild(), &bpd); + nsBlockFrame::FrameLines* overflowLines = block->GetOverflowLines(); + if (overflowLines) { + nsBlockInFlowLineIterator it(block, overflowLines->mLines.begin(), true); + bpd.mPrevFrame = nullptr; + TraverseFrames(&it, overflowLines->mFrames.FirstChild(), &bpd); + } + } + + if (ch != 0) { + bpd.PopBidiControl(ch); + } + + return ResolveParagraph(&bpd); +} + +nsresult +nsBidiPresUtils::ResolveParagraph(BidiParagraphData* aBpd) +{ + if (aBpd->BufferLength() < 1) { + return NS_OK; + } + aBpd->mBuffer.ReplaceChar(kSeparators, kSpace); + + int32_t runCount; + + nsresult rv = aBpd->SetPara(); + NS_ENSURE_SUCCESS(rv, rv); + + nsBidiLevel embeddingLevel = aBpd->GetParaLevel(); + + rv = aBpd->CountRuns(&runCount); + NS_ENSURE_SUCCESS(rv, rv); + + int32_t runLength = 0; // the length of the current run of text + int32_t logicalLimit = 0; // the end of the current run + 1 + int32_t numRun = -1; + int32_t fragmentLength = 0; // the length of the current text frame + int32_t frameIndex = -1; // index to the frames in mLogicalFrames + int32_t frameCount = aBpd->FrameCount(); + int32_t contentOffset = 0; // offset of current frame in its content node + bool isTextFrame = false; + nsIFrame* frame = nullptr; + nsIContent* content = nullptr; + int32_t contentTextLength = 0; + + FramePropertyTable* propTable = aBpd->mPresContext->PropertyTable(); + nsLineBox* currentLine = nullptr; + +#ifdef DEBUG +#ifdef NOISY_BIDI + printf("Before Resolve(), mCurrentBlock=%p, mBuffer='%s', frameCount=%d, runCount=%d\n", + (void*)aBpd->mCurrentBlock, NS_ConvertUTF16toUTF8(aBpd->mBuffer).get(), frameCount, runCount); +#ifdef REALLY_NOISY_BIDI + printf(" block frame tree=:\n"); + aBpd->mCurrentBlock->List(stdout, 0); +#endif +#endif +#endif + + if (runCount == 1 && frameCount == 1 && + aBpd->GetDirection() == NSBIDI_LTR && aBpd->GetParaLevel() == 0) { + // We have a single left-to-right frame in a left-to-right paragraph, + // without bidi isolation from the surrounding text. + // Make sure that the embedding level and base level frame properties aren't + // set (because if they are this frame used to have some other direction, + // so we can't do this optimization), and we're done. + nsIFrame* frame = aBpd->FrameAt(0); + if (frame != NS_BIDI_CONTROL_FRAME) { + FrameBidiData bidiData = frame->GetBidiData(); + if (!bidiData.embeddingLevel && !bidiData.baseLevel) { +#ifdef DEBUG +#ifdef NOISY_BIDI + printf("early return for single direction frame %p\n", (void*)frame); +#endif +#endif + frame->AddStateBits(NS_FRAME_IS_BIDI); + return NS_OK; + } + } + } + + nsIFrame* lastRealFrame = nullptr; + nsBidiLevel lastEmbedingLevel = kBidiLevelNone; + nsBidiLevel precedingControl = kBidiLevelNone; + + auto storeBidiDataToFrame = [&]() { + FrameBidiData bidiData; + bidiData.embeddingLevel = embeddingLevel; + bidiData.baseLevel = aBpd->GetParaLevel(); + // If a control character doesn't have a lower embedding level than + // both the preceding and the following frame, it isn't something + // needed for getting the correct result. This optimization should + // remove almost all of embeds and overrides, and some of isolates. + if (precedingControl >= embeddingLevel || + precedingControl >= lastEmbedingLevel) { + bidiData.precedingControl = kBidiLevelNone; + } else { + bidiData.precedingControl = precedingControl; + } + precedingControl = kBidiLevelNone; + lastEmbedingLevel = embeddingLevel; + propTable->Set(frame, nsIFrame::BidiDataProperty(), bidiData); + }; + + for (; ;) { + if (fragmentLength <= 0) { + // Get the next frame from mLogicalFrames + if (++frameIndex >= frameCount) { + break; + } + frame = aBpd->FrameAt(frameIndex); + if (frame == NS_BIDI_CONTROL_FRAME || + nsGkAtoms::textFrame != frame->GetType()) { + /* + * Any non-text frame corresponds to a single character in the text buffer + * (a bidi control character, LINE SEPARATOR, or OBJECT SUBSTITUTE) + */ + isTextFrame = false; + fragmentLength = 1; + } else { + currentLine = aBpd->GetLineForFrameAt(frameIndex); + content = frame->GetContent(); + if (!content) { + rv = NS_OK; + break; + } + contentTextLength = content->TextLength(); + if (contentTextLength == 0) { + frame->AdjustOffsetsForBidi(0, 0); + // Set the base level and embedding level of the current run even + // on an empty frame. Otherwise frame reordering will not be correct. + storeBidiDataToFrame(); + continue; + } + int32_t start, end; + frame->GetOffsets(start, end); + NS_ASSERTION(!(contentTextLength < end - start), + "Frame offsets don't fit in content"); + fragmentLength = std::min(contentTextLength, end - start); + contentOffset = start; + isTextFrame = true; + } + } // if (fragmentLength <= 0) + + if (runLength <= 0) { + // Get the next run of text from the Bidi engine + if (++numRun >= runCount) { + break; + } + int32_t lineOffset = logicalLimit; + if (NS_FAILED(aBpd->GetLogicalRun( + lineOffset, &logicalLimit, &embeddingLevel) ) ) { + break; + } + runLength = logicalLimit - lineOffset; + } // if (runLength <= 0) + + if (frame == NS_BIDI_CONTROL_FRAME) { + // In theory, we only need to do this for isolates. However, it is + // easier to do this for all here because we do not maintain the + // index to get corresponding character from buffer. Since we do + // have proper embedding level for all those characters, including + // them wouldn't affect the final result. + precedingControl = std::min(precedingControl, embeddingLevel); + } + else { + storeBidiDataToFrame(); + if (isTextFrame) { + if ( (runLength > 0) && (runLength < fragmentLength) ) { + /* + * The text in this frame continues beyond the end of this directional run. + * Create a non-fluid continuation frame for the next directional run. + */ + currentLine->MarkDirty(); + nsIFrame* nextBidi; + int32_t runEnd = contentOffset + runLength; + rv = EnsureBidiContinuation(frame, &nextBidi, contentOffset, runEnd); + if (NS_FAILED(rv)) { + break; + } + nextBidi->AdjustOffsetsForBidi(runEnd, + contentOffset + fragmentLength); + frame = nextBidi; + contentOffset = runEnd; + } // if (runLength < fragmentLength) + else { + if (contentOffset + fragmentLength == contentTextLength) { + /* + * We have finished all the text in this content node. Convert any + * further non-fluid continuations to fluid continuations and advance + * frameIndex to the last frame in the content node + */ + int32_t newIndex = aBpd->GetLastFrameForContent(content); + if (newIndex > frameIndex) { + currentLine->MarkDirty(); + RemoveBidiContinuation(aBpd, frame, frameIndex, newIndex); + frameIndex = newIndex; + frame = aBpd->FrameAt(frameIndex); + } + } else if (fragmentLength > 0 && runLength > fragmentLength) { + /* + * There is more text that belongs to this directional run in the next + * text frame: make sure it is a fluid continuation of the current frame. + * Do not advance frameIndex, because the next frame may contain + * multi-directional text and need to be split + */ + int32_t newIndex = frameIndex; + do { + } while (++newIndex < frameCount && + aBpd->FrameAt(newIndex) == NS_BIDI_CONTROL_FRAME); + if (newIndex < frameCount) { + currentLine->MarkDirty(); + RemoveBidiContinuation(aBpd, frame, frameIndex, newIndex); + } + } else if (runLength == fragmentLength) { + /* + * If the directional run ends at the end of the frame, make sure + * that any continuation is non-fluid, and do the same up the + * parent chain + */ + nsIFrame* next = frame->GetNextInFlow(); + if (next) { + currentLine->MarkDirty(); + MakeContinuationsNonFluidUpParentChain(frame, next); + } + } + frame->AdjustOffsetsForBidi(contentOffset, contentOffset + fragmentLength); + } + } // isTextFrame + } // not bidi control frame + int32_t temp = runLength; + runLength -= fragmentLength; + fragmentLength -= temp; + + // Record last real frame so that we can do spliting properly even + // if a run ends after a virtual bidi control frame. + if (frame != NS_BIDI_CONTROL_FRAME) { + lastRealFrame = frame; + } + if (lastRealFrame && fragmentLength <= 0) { + // If the frame is at the end of a run, and this is not the end of our + // paragrah, split all ancestor inlines that need splitting. + // To determine whether we're at the end of the run, we check that we've + // finished processing the current run, and that the current frame + // doesn't have a fluid continuation (it could have a fluid continuation + // of zero length, so testing runLength alone is not sufficient). + if (runLength <= 0 && !lastRealFrame->GetNextInFlow()) { + if (numRun + 1 < runCount) { + nsIFrame* child = lastRealFrame; + nsContainerFrame* parent = child->GetParent(); + // As long as we're on the last sibling, the parent doesn't have to + // be split. + // However, if the parent has a fluid continuation, we do have to make + // it non-fluid. This can happen e.g. when we have a first-letter + // frame and the end of the first-letter coincides with the end of a + // directional run. + while (parent && + IsBidiSplittable(parent) && + !child->GetNextSibling()) { + nsIFrame* next = parent->GetNextInFlow(); + if (next) { + parent->SetNextContinuation(next); + next->SetPrevContinuation(parent); + } + child = parent; + parent = child->GetParent(); + } + if (parent && IsBidiSplittable(parent)) { + SplitInlineAncestors(parent, child); + } + } + } else if (frame != NS_BIDI_CONTROL_FRAME) { + // We're not at an end of a run. If |frame| is the last child of its + // parent, and its ancestors happen to have bidi continuations, convert + // them into fluid continuations. + JoinInlineAncestors(frame); + } + } + } // for + +#ifdef DEBUG +#ifdef REALLY_NOISY_BIDI + printf("---\nAfter Resolve(), frameTree =:\n"); + aBpd->mCurrentBlock->List(stdout, 0); + printf("===\n"); +#endif +#endif + + return rv; +} + +void +nsBidiPresUtils::TraverseFrames(nsBlockInFlowLineIterator* aLineIter, + nsIFrame* aCurrentFrame, + BidiParagraphData* aBpd) +{ + if (!aCurrentFrame) + return; + +#ifdef DEBUG + nsBlockFrame* initialLineContainer = aLineIter->GetContainer(); +#endif + + nsIFrame* childFrame = aCurrentFrame; + do { + /* + * It's important to get the next sibling and next continuation *before* + * handling the frame: If we encounter a forced paragraph break and call + * ResolveParagraph within this loop, doing GetNextSibling and + * GetNextContinuation after that could return a bidi continuation that had + * just been split from the original childFrame and we would process it + * twice. + */ + nsIFrame* nextSibling = childFrame->GetNextSibling(); + + // If the real frame for a placeholder is a first letter frame, we need to + // drill down into it and include its contents in Bidi resolution. + // If not, we just use the placeholder. + nsIFrame* frame = childFrame; + if (nsGkAtoms::placeholderFrame == childFrame->GetType()) { + nsIFrame* realFrame = + nsPlaceholderFrame::GetRealFrameForPlaceholder(childFrame); + if (realFrame->GetType() == nsGkAtoms::letterFrame) { + frame = realFrame; + } + } + + auto DifferentBidiValues = [](nsIFrame* aFrame1, nsIFrame* aFrame2) { + nsStyleContext* sc1 = aFrame1->StyleContext(); + nsStyleContext* sc2 = aFrame2->StyleContext(); + return GetBidiControl(sc1) != GetBidiControl(sc2) || + GetBidiOverride(sc1) != GetBidiOverride(sc2); + }; + + nsIFrame* nextContinuation = frame->GetNextContinuation(); + nsIFrame* prevContinuation = frame->GetPrevContinuation(); + bool isLastFrame = !nextContinuation || + DifferentBidiValues(frame, nextContinuation); + bool isFirstFrame = !prevContinuation || + DifferentBidiValues(frame, prevContinuation); + + char16_t controlChar = 0; + char16_t overrideChar = 0; + if (frame->IsFrameOfType(nsIFrame::eBidiInlineContainer)) { + if (!(frame->GetStateBits() & NS_FRAME_FIRST_REFLOW)) { + nsContainerFrame* c = static_cast<nsContainerFrame*>(frame); + MOZ_ASSERT(c == do_QueryFrame(frame), + "eBidiInlineContainer must be a nsContainerFrame subclass"); + c->DrainSelfOverflowList(); + } + + controlChar = GetBidiControl(frame->StyleContext()); + overrideChar = GetBidiOverride(frame->StyleContext()); + + // Add dummy frame pointers representing bidi control codes before + // the first frames of elements specifying override, isolation, or + // plaintext. + if (isFirstFrame) { + if (controlChar != 0) { + aBpd->PushBidiControl(controlChar); + } + if (overrideChar != 0) { + aBpd->PushBidiControl(overrideChar); + } + } + } + + if (IsBidiLeaf(frame)) { + /* Bidi leaf frame: add the frame to the mLogicalFrames array, + * and add its index to the mContentToFrameIndex hashtable. This + * will be used in RemoveBidiContinuation() to identify the last + * frame in the array with a given content. + */ + nsIContent* content = frame->GetContent(); + aBpd->AppendFrame(frame, aLineIter, content); + + // Append the content of the frame to the paragraph buffer + nsIAtom* frameType = frame->GetType(); + if (nsGkAtoms::textFrame == frameType) { + if (content != aBpd->mPrevContent) { + aBpd->mPrevContent = content; + if (!frame->StyleText()->NewlineIsSignificant( + static_cast<nsTextFrame*>(frame))) { + content->AppendTextTo(aBpd->mBuffer); + } else { + /* + * For preformatted text we have to do bidi resolution on each line + * separately. + */ + nsAutoString text; + content->AppendTextTo(text); + nsIFrame* next; + do { + next = nullptr; + + int32_t start, end; + frame->GetOffsets(start, end); + int32_t endLine = text.FindChar('\n', start); + if (endLine == -1) { + /* + * If there is no newline in the text content, just save the + * text from this frame and its continuations, and do bidi + * resolution later + */ + aBpd->AppendString(Substring(text, start)); + while (frame && nextSibling) { + aBpd->AdvanceAndAppendFrame(&frame, aLineIter, &nextSibling); + } + break; + } + + /* + * If there is a newline in the frame, break the frame after the + * newline, do bidi resolution and repeat until the last sibling + */ + ++endLine; + + /* + * If the frame ends before the new line, save the text and move + * into the next continuation + */ + aBpd->AppendString(Substring(text, start, + std::min(end, endLine) - start)); + while (end < endLine && nextSibling) { + aBpd->AdvanceAndAppendFrame(&frame, aLineIter, &nextSibling); + NS_ASSERTION(frame, "Premature end of continuation chain"); + frame->GetOffsets(start, end); + aBpd->AppendString(Substring(text, start, + std::min(end, endLine) - start)); + } + + if (end < endLine) { + aBpd->mPrevContent = nullptr; + break; + } + + bool createdContinuation = false; + if (uint32_t(endLine) < text.Length()) { + /* + * Timing is everything here: if the frame already has a bidi + * continuation, we need to make the continuation fluid *before* + * resetting the length of the current frame. Otherwise + * nsTextFrame::SetLength won't set the continuation frame's + * text offsets correctly. + * + * On the other hand, if the frame doesn't have a continuation, + * we need to create one *after* resetting the length, or + * CreateContinuingFrame will complain that there is no more + * content for the continuation. + */ + next = frame->GetNextInFlow(); + if (!next) { + // If the frame already has a bidi continuation, make it fluid + next = frame->GetNextContinuation(); + if (next) { + MakeContinuationFluid(frame, next); + JoinInlineAncestors(frame); + } + } + + nsTextFrame* textFrame = static_cast<nsTextFrame*>(frame); + textFrame->SetLength(endLine - start, nullptr); + + if (!next) { + // If the frame has no next in flow, create one. + CreateContinuation(frame, &next, true); + createdContinuation = true; + } + // Mark the line before the newline as dirty. + aBpd->GetLineForFrameAt(aBpd->FrameCount() - 1)->MarkDirty(); + } + ResolveParagraphWithinBlock(aBpd); + + if (!nextSibling && !createdContinuation) { + break; + } else if (next) { + frame = next; + aBpd->AppendFrame(frame, aLineIter); + // Mark the line after the newline as dirty. + aBpd->GetLineForFrameAt(aBpd->FrameCount() - 1)->MarkDirty(); + } + + /* + * If we have already overshot the saved next-sibling while + * scanning the frame's continuations, advance it. + */ + if (frame && frame == nextSibling) { + nextSibling = frame->GetNextSibling(); + } + + } while (next); + } + } + } else if (nsGkAtoms::brFrame == frameType) { + // break frame -- append line separator + aBpd->AppendUnichar(kLineSeparator); + ResolveParagraphWithinBlock(aBpd); + } else { + // other frame type -- see the Unicode Bidi Algorithm: + // "...inline objects (such as graphics) are treated as if they are ... + // U+FFFC" + // <wbr>, however, is treated as U+200B ZERO WIDTH SPACE. See + // http://dev.w3.org/html5/spec/Overview.html#phrasing-content-1 + aBpd->AppendUnichar(content->IsHTMLElement(nsGkAtoms::wbr) ? + kZWSP : kObjectSubstitute); + if (!frame->IsInlineOutside()) { + // if it is not inline, end the paragraph + ResolveParagraphWithinBlock(aBpd); + } + } + } else { + // For a non-leaf frame, recurse into TraverseFrames + nsIFrame* kid = frame->PrincipalChildList().FirstChild(); + MOZ_ASSERT(!frame->GetChildList(nsIFrame::kOverflowList).FirstChild(), + "should have drained the overflow list above"); + if (kid) { + TraverseFrames(aLineIter, kid, aBpd); + } + } + + // If the element is attributed by dir, indicate direction pop (add PDF frame) + if (isLastFrame) { + // Add a dummy frame pointer representing a bidi control code after the + // last frame of an element specifying embedding or override + if (overrideChar != 0) { + aBpd->PopBidiControl(overrideChar); + } + if (controlChar != 0) { + aBpd->PopBidiControl(controlChar); + } + } + childFrame = nextSibling; + } while (childFrame); + + MOZ_ASSERT(initialLineContainer == aLineIter->GetContainer()); +} + +void +nsBidiPresUtils::ResolveParagraphWithinBlock(BidiParagraphData* aBpd) +{ + aBpd->ClearBidiControls(); + ResolveParagraph(aBpd); + aBpd->ResetData(); +} + +/* static */ nscoord +nsBidiPresUtils::ReorderFrames(nsIFrame* aFirstFrameOnLine, + int32_t aNumFramesOnLine, + WritingMode aLineWM, + const nsSize& aContainerSize, + nscoord aStart) +{ + nsSize containerSize(aContainerSize); + + // If this line consists of a line frame, reorder the line frame's children. + if (aFirstFrameOnLine->GetType() == nsGkAtoms::lineFrame) { + // The line frame is positioned at the start-edge, so use its size + // as the container size. + containerSize = aFirstFrameOnLine->GetSize(); + + aFirstFrameOnLine = aFirstFrameOnLine->PrincipalChildList().FirstChild(); + if (!aFirstFrameOnLine) { + return 0; + } + // All children of the line frame are on the first line. Setting aNumFramesOnLine + // to -1 makes InitLogicalArrayFromLine look at all of them. + aNumFramesOnLine = -1; + } + + BidiLineData bld(aFirstFrameOnLine, aNumFramesOnLine); + return RepositionInlineFrames(&bld, aLineWM, containerSize, aStart); +} + +nsIFrame* +nsBidiPresUtils::GetFirstLeaf(nsIFrame* aFrame) +{ + nsIFrame* firstLeaf = aFrame; + while (!IsBidiLeaf(firstLeaf)) { + nsIFrame* firstChild = firstLeaf->PrincipalChildList().FirstChild(); + nsIFrame* realFrame = nsPlaceholderFrame::GetRealFrameFor(firstChild); + firstLeaf = (realFrame->GetType() == nsGkAtoms::letterFrame) ? + realFrame : firstChild; + } + return firstLeaf; +} + +FrameBidiData +nsBidiPresUtils::GetFrameBidiData(nsIFrame* aFrame) +{ + return GetFirstLeaf(aFrame)->GetBidiData(); +} + +nsBidiLevel +nsBidiPresUtils::GetFrameEmbeddingLevel(nsIFrame* aFrame) +{ + return GetFirstLeaf(aFrame)->GetEmbeddingLevel(); +} + +nsBidiLevel +nsBidiPresUtils::GetFrameBaseLevel(nsIFrame* aFrame) +{ + nsIFrame* firstLeaf = aFrame; + while (!IsBidiLeaf(firstLeaf)) { + firstLeaf = firstLeaf->PrincipalChildList().FirstChild(); + } + return firstLeaf->GetBaseLevel(); +} + +void +nsBidiPresUtils::IsFirstOrLast(nsIFrame* aFrame, + const nsContinuationStates* aContinuationStates, + bool aSpanDirMatchesLineDir, + bool& aIsFirst /* out */, + bool& aIsLast /* out */) +{ + /* + * Since we lay out frames in the line's direction, visiting a frame with + * 'mFirstVisualFrame == nullptr', means it's the first appearance of one + * of its continuation chain frames on the line. + * To determine if it's the last visual frame of its continuation chain on + * the line or not, we count the number of frames of the chain on the line, + * and then reduce it when we lay out a frame of the chain. If this value + * becomes 1 it means that it's the last visual frame of its continuation + * chain on this line. + */ + + bool firstInLineOrder, lastInLineOrder; + nsFrameContinuationState* frameState = aContinuationStates->GetEntry(aFrame); + nsFrameContinuationState* firstFrameState; + + if (!frameState->mFirstVisualFrame) { + // aFrame is the first visual frame of its continuation chain + nsFrameContinuationState* contState; + nsIFrame* frame; + + frameState->mFrameCount = 1; + frameState->mFirstVisualFrame = aFrame; + + /** + * Traverse continuation chain of aFrame in both backward and forward + * directions while the frames are on this line. Count the frames and + * set their mFirstVisualFrame to aFrame. + */ + // Traverse continuation chain backward + for (frame = aFrame->GetPrevContinuation(); + frame && (contState = aContinuationStates->GetEntry(frame)); + frame = frame->GetPrevContinuation()) { + frameState->mFrameCount++; + contState->mFirstVisualFrame = aFrame; + } + frameState->mHasContOnPrevLines = (frame != nullptr); + + // Traverse continuation chain forward + for (frame = aFrame->GetNextContinuation(); + frame && (contState = aContinuationStates->GetEntry(frame)); + frame = frame->GetNextContinuation()) { + frameState->mFrameCount++; + contState->mFirstVisualFrame = aFrame; + } + frameState->mHasContOnNextLines = (frame != nullptr); + + firstInLineOrder = true; + firstFrameState = frameState; + } else { + // aFrame is not the first visual frame of its continuation chain + firstInLineOrder = false; + firstFrameState = aContinuationStates->GetEntry(frameState->mFirstVisualFrame); + } + + lastInLineOrder = (firstFrameState->mFrameCount == 1); + + if (aSpanDirMatchesLineDir) { + aIsFirst = firstInLineOrder; + aIsLast = lastInLineOrder; + } else { + aIsFirst = lastInLineOrder; + aIsLast = firstInLineOrder; + } + + if (frameState->mHasContOnPrevLines) { + aIsFirst = false; + } + if (firstFrameState->mHasContOnNextLines) { + aIsLast = false; + } + + if ((aIsFirst || aIsLast) && + (aFrame->GetStateBits() & NS_FRAME_PART_OF_IBSPLIT)) { + // For ib splits, don't treat anything except the last part as + // endmost or anything except the first part as startmost. + // As an optimization, only get the first continuation once. + nsIFrame* firstContinuation = aFrame->FirstContinuation(); + if (firstContinuation->FrameIsNonLastInIBSplit()) { + // We are not endmost + aIsLast = false; + } + if (firstContinuation->FrameIsNonFirstInIBSplit()) { + // We are not startmost + aIsFirst = false; + } + } + + // Reduce number of remaining frames of the continuation chain on the line. + firstFrameState->mFrameCount--; + + nsInlineFrame* testFrame = do_QueryFrame(aFrame); + + if (testFrame) { + aFrame->AddStateBits(NS_INLINE_FRAME_BIDI_VISUAL_STATE_IS_SET); + + if (aIsFirst) { + aFrame->AddStateBits(NS_INLINE_FRAME_BIDI_VISUAL_IS_FIRST); + } else { + aFrame->RemoveStateBits(NS_INLINE_FRAME_BIDI_VISUAL_IS_FIRST); + } + + if (aIsLast) { + aFrame->AddStateBits(NS_INLINE_FRAME_BIDI_VISUAL_IS_LAST); + } else { + aFrame->RemoveStateBits(NS_INLINE_FRAME_BIDI_VISUAL_IS_LAST); + } + } +} + +/* static */ void +nsBidiPresUtils::RepositionRubyContentFrame( + nsIFrame* aFrame, WritingMode aFrameWM, const LogicalMargin& aBorderPadding) +{ + const nsFrameList& childList = aFrame->PrincipalChildList(); + if (childList.IsEmpty()) { + return; + } + + // Reorder the children. + // XXX It currently doesn't work properly because we do not + // resolve frames inside ruby content frames. + nscoord isize = ReorderFrames(childList.FirstChild(), + childList.GetLength(), + aFrameWM, aFrame->GetSize(), + aBorderPadding.IStart(aFrameWM)); + isize += aBorderPadding.IEnd(aFrameWM); + + if (aFrame->StyleText()->mRubyAlign == NS_STYLE_RUBY_ALIGN_START) { + return; + } + nscoord residualISize = aFrame->ISize(aFrameWM) - isize; + if (residualISize <= 0) { + return; + } + + // When ruby-align is not "start", if the content does not fill this + // frame, we need to center the children. + const nsSize dummyContainerSize; + for (nsIFrame* child : childList) { + LogicalRect rect = child->GetLogicalRect(aFrameWM, dummyContainerSize); + rect.IStart(aFrameWM) += residualISize / 2; + child->SetRect(aFrameWM, rect, dummyContainerSize); + } +} + +/* static */ nscoord +nsBidiPresUtils::RepositionRubyFrame( + nsIFrame* aFrame, + const nsContinuationStates* aContinuationStates, + const WritingMode aContainerWM, + const LogicalMargin& aBorderPadding) +{ + nsIAtom* frameType = aFrame->GetType(); + MOZ_ASSERT(RubyUtils::IsRubyBox(frameType)); + + nscoord icoord = 0; + WritingMode frameWM = aFrame->GetWritingMode(); + bool isLTR = frameWM.IsBidiLTR(); + nsSize frameSize = aFrame->GetSize(); + if (frameType == nsGkAtoms::rubyFrame) { + icoord += aBorderPadding.IStart(frameWM); + // Reposition ruby segments in a ruby container + for (RubySegmentEnumerator e(static_cast<nsRubyFrame*>(aFrame)); + !e.AtEnd(); e.Next()) { + nsRubyBaseContainerFrame* rbc = e.GetBaseContainer(); + AutoRubyTextContainerArray textContainers(rbc); + + nscoord segmentISize = RepositionFrame(rbc, isLTR, icoord, + aContinuationStates, + frameWM, false, frameSize); + for (nsRubyTextContainerFrame* rtc : textContainers) { + nscoord isize = RepositionFrame(rtc, isLTR, icoord, aContinuationStates, + frameWM, false, frameSize); + segmentISize = std::max(segmentISize, isize); + } + icoord += segmentISize; + } + icoord += aBorderPadding.IEnd(frameWM); + } else if (frameType == nsGkAtoms::rubyBaseContainerFrame) { + // Reposition ruby columns in a ruby segment + auto rbc = static_cast<nsRubyBaseContainerFrame*>(aFrame); + AutoRubyTextContainerArray textContainers(rbc); + + for (RubyColumnEnumerator e(rbc, textContainers); !e.AtEnd(); e.Next()) { + RubyColumn column; + e.GetColumn(column); + + nscoord columnISize = RepositionFrame(column.mBaseFrame, isLTR, icoord, + aContinuationStates, + frameWM, false, frameSize); + for (nsRubyTextFrame* rt : column.mTextFrames) { + nscoord isize = RepositionFrame(rt, isLTR, icoord, aContinuationStates, + frameWM, false, frameSize); + columnISize = std::max(columnISize, isize); + } + icoord += columnISize; + } + } else { + if (frameType == nsGkAtoms::rubyBaseFrame || + frameType == nsGkAtoms::rubyTextFrame) { + RepositionRubyContentFrame(aFrame, frameWM, aBorderPadding); + } + // Note that, ruby text container is not present in all conditions + // above. It is intended, because the children of rtc are reordered + // with the children of ruby base container simultaneously. We only + // need to return its isize here, as it should not be changed. + icoord += aFrame->ISize(aContainerWM); + } + return icoord; +} + +/* static */ nscoord +nsBidiPresUtils::RepositionFrame(nsIFrame* aFrame, + bool aIsEvenLevel, + nscoord aStartOrEnd, + const nsContinuationStates* aContinuationStates, + WritingMode aContainerWM, + bool aContainerReverseDir, + const nsSize& aContainerSize) +{ + nscoord lineSize = aContainerWM.IsVertical() ? + aContainerSize.height : aContainerSize.width; + NS_ASSERTION(lineSize != NS_UNCONSTRAINEDSIZE, + "Unconstrained inline line size in bidi frame reordering"); + if (!aFrame) + return 0; + + bool isFirst, isLast; + WritingMode frameWM = aFrame->GetWritingMode(); + IsFirstOrLast(aFrame, + aContinuationStates, + aContainerWM.IsBidiLTR() == frameWM.IsBidiLTR(), + isFirst /* out */, + isLast /* out */); + + // We only need the margin if the frame is first or last in its own + // writing mode, but we're traversing the frames in the order of the + // container's writing mode. To get the right values, we set start and + // end margins on a logical margin in the frame's writing mode, and + // then convert the margin to the container's writing mode to set the + // coordinates. + + // This method is called from nsBlockFrame::PlaceLine via the call to + // bidiUtils->ReorderFrames, so this is guaranteed to be after the inlines + // have been reflowed, which is required for GetUsedMargin/Border/Padding + nscoord frameISize = aFrame->ISize(); + LogicalMargin frameMargin = aFrame->GetLogicalUsedMargin(frameWM); + LogicalMargin borderPadding = aFrame->GetLogicalUsedBorderAndPadding(frameWM); + // Since the visual order of frame could be different from the continuation + // order, we need to remove any inline border/padding [that is already applied + // based on continuation order] and then add it back based on the visual order + // (i.e. isFirst/isLast) to get the correct isize for the current frame. + // We don't need to do that for 'box-decoration-break:clone' because then all + // continuations have border/padding/margin applied. + if (aFrame->StyleBorder()->mBoxDecorationBreak == + StyleBoxDecorationBreak::Slice) { + // First remove the border/padding that was applied based on logical order. + if (!aFrame->GetPrevContinuation()) { + frameISize -= borderPadding.IStart(frameWM); + } + if (!aFrame->GetNextContinuation()) { + frameISize -= borderPadding.IEnd(frameWM); + } + // Set margin/border/padding based on visual order. + if (!isFirst) { + frameMargin.IStart(frameWM) = 0; + borderPadding.IStart(frameWM) = 0; + } + if (!isLast) { + frameMargin.IEnd(frameWM) = 0; + borderPadding.IEnd(frameWM) = 0; + } + // Add the border/padding which is now based on visual order. + frameISize += borderPadding.IStartEnd(frameWM); + } + + nscoord icoord = 0; + if (!IsBidiLeaf(aFrame)) { + bool reverseDir = aIsEvenLevel != frameWM.IsBidiLTR(); + icoord += reverseDir ? + borderPadding.IEnd(frameWM) : borderPadding.IStart(frameWM); + LogicalSize logicalSize(frameWM, frameISize, aFrame->BSize()); + nsSize frameSize = logicalSize.GetPhysicalSize(frameWM); + // Reposition the child frames + for (nsFrameList::Enumerator e(aFrame->PrincipalChildList()); + !e.AtEnd(); e.Next()) { + icoord += RepositionFrame(e.get(), aIsEvenLevel, icoord, + aContinuationStates, + frameWM, reverseDir, frameSize); + } + icoord += reverseDir ? + borderPadding.IStart(frameWM) : borderPadding.IEnd(frameWM); + } else if (RubyUtils::IsRubyBox(aFrame->GetType())) { + icoord += RepositionRubyFrame(aFrame, aContinuationStates, + aContainerWM, borderPadding); + } else { + icoord += + frameWM.IsOrthogonalTo(aContainerWM) ? aFrame->BSize() : frameISize; + } + + // In the following variables, if aContainerReverseDir is true, i.e. + // the container is positioning its children in reverse of its logical + // direction, the "StartOrEnd" refers to the distance from the frame + // to the inline end edge of the container, elsewise, it refers to the + // distance to the inline start edge. + const LogicalMargin margin = frameMargin.ConvertTo(aContainerWM, frameWM); + nscoord marginStartOrEnd = + aContainerReverseDir ? margin.IEnd(aContainerWM) + : margin.IStart(aContainerWM); + nscoord frameStartOrEnd = aStartOrEnd + marginStartOrEnd; + + LogicalRect rect = aFrame->GetLogicalRect(aContainerWM, aContainerSize); + rect.ISize(aContainerWM) = icoord; + rect.IStart(aContainerWM) = + aContainerReverseDir ? lineSize - frameStartOrEnd - icoord + : frameStartOrEnd; + aFrame->SetRect(aContainerWM, rect, aContainerSize); + + return icoord + margin.IStartEnd(aContainerWM); +} + +void +nsBidiPresUtils::InitContinuationStates(nsIFrame* aFrame, + nsContinuationStates* aContinuationStates) +{ + nsFrameContinuationState* state = aContinuationStates->PutEntry(aFrame); + state->mFirstVisualFrame = nullptr; + state->mFrameCount = 0; + + if (!IsBidiLeaf(aFrame) || RubyUtils::IsRubyBox(aFrame->GetType())) { + // Continue for child frames + for (nsIFrame* frame : aFrame->PrincipalChildList()) { + InitContinuationStates(frame, + aContinuationStates); + } + } +} + +/* static */ nscoord +nsBidiPresUtils::RepositionInlineFrames(BidiLineData *aBld, + WritingMode aLineWM, + const nsSize& aContainerSize, + nscoord aStart) +{ + nscoord start = aStart; + nsIFrame* frame; + int32_t count = aBld->mVisualFrames.Length(); + int32_t index; + nsContinuationStates continuationStates; + + // Initialize continuation states to (nullptr, 0) for + // each frame on the line. + for (index = 0; index < count; index++) { + InitContinuationStates(aBld->VisualFrameAt(index), &continuationStates); + } + + // Reposition frames in visual order + int32_t step, limit; + if (aLineWM.IsBidiLTR()) { + index = 0; + step = 1; + limit = count; + } else { + index = count - 1; + step = -1; + limit = -1; + } + for (; index != limit; index += step) { + frame = aBld->VisualFrameAt(index); + start += RepositionFrame( + frame, !(IS_LEVEL_RTL(aBld->mLevels[aBld->mIndexMap[index]])), + start, &continuationStates, + aLineWM, false, aContainerSize); + } + return start; +} + +bool +nsBidiPresUtils::CheckLineOrder(nsIFrame* aFirstFrameOnLine, + int32_t aNumFramesOnLine, + nsIFrame** aFirstVisual, + nsIFrame** aLastVisual) +{ + BidiLineData bld(aFirstFrameOnLine, aNumFramesOnLine); + int32_t count = bld.FrameCount(); + + if (aFirstVisual) { + *aFirstVisual = bld.VisualFrameAt(0); + } + if (aLastVisual) { + *aLastVisual = bld.VisualFrameAt(count-1); + } + + return bld.mIsReordered; +} + +nsIFrame* +nsBidiPresUtils::GetFrameToRightOf(const nsIFrame* aFrame, + nsIFrame* aFirstFrameOnLine, + int32_t aNumFramesOnLine) +{ + BidiLineData bld(aFirstFrameOnLine, aNumFramesOnLine); + + int32_t count = bld.mVisualFrames.Length(); + + if (aFrame == nullptr && count) + return bld.VisualFrameAt(0); + + for (int32_t i = 0; i < count - 1; i++) { + if (bld.VisualFrameAt(i) == aFrame) { + return bld.VisualFrameAt(i+1); + } + } + + return nullptr; +} + +nsIFrame* +nsBidiPresUtils::GetFrameToLeftOf(const nsIFrame* aFrame, + nsIFrame* aFirstFrameOnLine, + int32_t aNumFramesOnLine) +{ + BidiLineData bld(aFirstFrameOnLine, aNumFramesOnLine); + + int32_t count = bld.mVisualFrames.Length(); + + if (aFrame == nullptr && count) + return bld.VisualFrameAt(count-1); + + for (int32_t i = 1; i < count; i++) { + if (bld.VisualFrameAt(i) == aFrame) { + return bld.VisualFrameAt(i-1); + } + } + + return nullptr; +} + +inline nsresult +nsBidiPresUtils::EnsureBidiContinuation(nsIFrame* aFrame, + nsIFrame** aNewFrame, + int32_t aStart, + int32_t aEnd) +{ + NS_PRECONDITION(aNewFrame, "null OUT ptr"); + NS_PRECONDITION(aFrame, "aFrame is null"); + + aFrame->AdjustOffsetsForBidi(aStart, aEnd); + return CreateContinuation(aFrame, aNewFrame, false); +} + +void +nsBidiPresUtils::RemoveBidiContinuation(BidiParagraphData *aBpd, + nsIFrame* aFrame, + int32_t aFirstIndex, + int32_t aLastIndex) +{ + FrameBidiData bidiData = aFrame->GetBidiData(); + bidiData.precedingControl = kBidiLevelNone; + for (int32_t index = aFirstIndex + 1; index <= aLastIndex; index++) { + nsIFrame* frame = aBpd->FrameAt(index); + if (frame != NS_BIDI_CONTROL_FRAME) { + // Make the frame and its continuation ancestors fluid, + // so they can be reused or deleted by normal reflow code + frame->Properties().Set(nsIFrame::BidiDataProperty(), bidiData); + frame->AddStateBits(NS_FRAME_IS_BIDI); + while (frame) { + nsIFrame* prev = frame->GetPrevContinuation(); + if (prev) { + MakeContinuationFluid(prev, frame); + frame = frame->GetParent(); + } else { + break; + } + } + } + } + + // Make sure that the last continuation we made fluid does not itself have a + // fluid continuation (this can happen when re-resolving after dynamic changes + // to content) + nsIFrame* lastFrame = aBpd->FrameAt(aLastIndex); + MakeContinuationsNonFluidUpParentChain(lastFrame, lastFrame->GetNextInFlow()); +} + +nsresult +nsBidiPresUtils::FormatUnicodeText(nsPresContext* aPresContext, + char16_t* aText, + int32_t& aTextLength, + nsCharType aCharType) +{ + nsresult rv = NS_OK; + // ahmed + //adjusted for correct numeral shaping + uint32_t bidiOptions = aPresContext->GetBidi(); + switch (GET_BIDI_OPTION_NUMERAL(bidiOptions)) { + + case IBMBIDI_NUMERAL_HINDI: + HandleNumbers(aText,aTextLength,IBMBIDI_NUMERAL_HINDI); + break; + + case IBMBIDI_NUMERAL_ARABIC: + HandleNumbers(aText,aTextLength,IBMBIDI_NUMERAL_ARABIC); + break; + + case IBMBIDI_NUMERAL_PERSIAN: + HandleNumbers(aText,aTextLength,IBMBIDI_NUMERAL_PERSIAN); + break; + + case IBMBIDI_NUMERAL_REGULAR: + + switch (aCharType) { + + case eCharType_EuropeanNumber: + HandleNumbers(aText,aTextLength,IBMBIDI_NUMERAL_ARABIC); + break; + + case eCharType_ArabicNumber: + HandleNumbers(aText,aTextLength,IBMBIDI_NUMERAL_HINDI); + break; + + default: + break; + } + break; + + case IBMBIDI_NUMERAL_HINDICONTEXT: + if ( ( (GET_BIDI_OPTION_DIRECTION(bidiOptions)==IBMBIDI_TEXTDIRECTION_RTL) && (IS_ARABIC_DIGIT (aText[0])) ) || (eCharType_ArabicNumber == aCharType) ) + HandleNumbers(aText,aTextLength,IBMBIDI_NUMERAL_HINDI); + else if (eCharType_EuropeanNumber == aCharType) + HandleNumbers(aText,aTextLength,IBMBIDI_NUMERAL_ARABIC); + break; + + case IBMBIDI_NUMERAL_PERSIANCONTEXT: + if ( ( (GET_BIDI_OPTION_DIRECTION(bidiOptions)==IBMBIDI_TEXTDIRECTION_RTL) && (IS_ARABIC_DIGIT (aText[0])) ) || (eCharType_ArabicNumber == aCharType) ) + HandleNumbers(aText,aTextLength,IBMBIDI_NUMERAL_PERSIAN); + else if (eCharType_EuropeanNumber == aCharType) + HandleNumbers(aText,aTextLength,IBMBIDI_NUMERAL_ARABIC); + break; + + case IBMBIDI_NUMERAL_NOMINAL: + default: + break; + } + + StripBidiControlCharacters(aText, aTextLength); + return rv; +} + +void +nsBidiPresUtils::StripBidiControlCharacters(char16_t* aText, + int32_t& aTextLength) +{ + if ( (nullptr == aText) || (aTextLength < 1) ) { + return; + } + + int32_t stripLen = 0; + + for (int32_t i = 0; i < aTextLength; i++) { + // XXX: This silently ignores surrogate characters. + // As of Unicode 4.0, all Bidi control characters are within the BMP. + if (IsBidiControl((uint32_t)aText[i])) { + ++stripLen; + } + else { + aText[i - stripLen] = aText[i]; + } + } + aTextLength -= stripLen; +} + +#if 0 // XXX: for the future use ??? +void +RemoveDiacritics(char16_t* aText, + int32_t& aTextLength) +{ + if (aText && (aTextLength > 0) ) { + int32_t offset = 0; + + for (int32_t i = 0; i < aTextLength && aText[i]; i++) { + if (IS_BIDI_DIACRITIC(aText[i]) ) { + ++offset; + continue; + } + aText[i - offset] = aText[i]; + } + aTextLength = i - offset; + aText[aTextLength] = 0; + } +} +#endif + +void +nsBidiPresUtils::CalculateCharType(nsBidi* aBidiEngine, + const char16_t* aText, + int32_t& aOffset, + int32_t aCharTypeLimit, + int32_t& aRunLimit, + int32_t& aRunLength, + int32_t& aRunCount, + uint8_t& aCharType, + uint8_t& aPrevCharType) + +{ + bool strongTypeFound = false; + int32_t offset; + nsCharType charType; + + aCharType = eCharType_OtherNeutral; + + int32_t charLen; + for (offset = aOffset; offset < aCharTypeLimit; offset += charLen) { + // Make sure we give RTL chartype to all characters that would be classified + // as Right-To-Left by a bidi platform. + // (May differ from the UnicodeData, eg we set RTL chartype to some NSMs.) + charLen = 1; + uint32_t ch = aText[offset]; + if (IS_HEBREW_CHAR(ch) ) { + charType = eCharType_RightToLeft; + } else if (IS_ARABIC_ALPHABETIC(ch) ) { + charType = eCharType_RightToLeftArabic; + } else { + if (NS_IS_HIGH_SURROGATE(ch) && offset + 1 < aCharTypeLimit && + NS_IS_LOW_SURROGATE(aText[offset + 1])) { + ch = SURROGATE_TO_UCS4(ch, aText[offset + 1]); + charLen = 2; + } + charType = unicode::GetBidiCat(ch); + } + + if (!CHARTYPE_IS_WEAK(charType) ) { + + if (strongTypeFound + && (charType != aPrevCharType) + && (CHARTYPE_IS_RTL(charType) || CHARTYPE_IS_RTL(aPrevCharType) ) ) { + // Stop at this point to ensure uni-directionality of the text + // (from platform's point of view). + // Also, don't mix Arabic and Hebrew content (since platform may + // provide BIDI support to one of them only). + aRunLength = offset - aOffset; + aRunLimit = offset; + ++aRunCount; + break; + } + + if ( (eCharType_RightToLeftArabic == aPrevCharType + || eCharType_ArabicNumber == aPrevCharType) + && eCharType_EuropeanNumber == charType) { + charType = eCharType_ArabicNumber; + } + + // Set PrevCharType to the last strong type in this frame + // (for correct numeric shaping) + aPrevCharType = charType; + + strongTypeFound = true; + aCharType = charType; + } + } + aOffset = offset; +} + +nsresult nsBidiPresUtils::ProcessText(const char16_t* aText, + int32_t aLength, + nsBidiLevel aBaseLevel, + nsPresContext* aPresContext, + BidiProcessor& aprocessor, + Mode aMode, + nsBidiPositionResolve* aPosResolve, + int32_t aPosResolveCount, + nscoord* aWidth, + nsBidi* aBidiEngine) +{ + NS_ASSERTION((aPosResolve == nullptr) != (aPosResolveCount > 0), "Incorrect aPosResolve / aPosResolveCount arguments"); + + int32_t runCount; + + nsAutoString textBuffer(aText, aLength); + textBuffer.ReplaceChar(kSeparators, kSpace); + const char16_t* text = textBuffer.get(); + + nsresult rv = aBidiEngine->SetPara(text, aLength, aBaseLevel); + if (NS_FAILED(rv)) + return rv; + + rv = aBidiEngine->CountRuns(&runCount); + if (NS_FAILED(rv)) + return rv; + + nscoord xOffset = 0; + nscoord width, xEndRun = 0; + nscoord totalWidth = 0; + int32_t i, start, limit, length; + uint32_t visualStart = 0; + uint8_t charType; + uint8_t prevType = eCharType_LeftToRight; + + for(int nPosResolve=0; nPosResolve < aPosResolveCount; ++nPosResolve) + { + aPosResolve[nPosResolve].visualIndex = kNotFound; + aPosResolve[nPosResolve].visualLeftTwips = kNotFound; + aPosResolve[nPosResolve].visualWidth = kNotFound; + } + + for (i = 0; i < runCount; i++) { + nsBidiDirection dir; + rv = aBidiEngine->GetVisualRun(i, &start, &length, &dir); + if (NS_FAILED(rv)) + return rv; + + nsBidiLevel level; + rv = aBidiEngine->GetLogicalRun(start, &limit, &level); + if (NS_FAILED(rv)) + return rv; + + dir = DIRECTION_FROM_LEVEL(level); + int32_t subRunLength = limit - start; + int32_t lineOffset = start; + int32_t typeLimit = std::min(limit, aLength); + int32_t subRunCount = 1; + int32_t subRunLimit = typeLimit; + + /* + * If |level| is even, i.e. the direction of the run is left-to-right, we + * render the subruns from left to right and increment the x-coordinate + * |xOffset| by the width of each subrun after rendering. + * + * If |level| is odd, i.e. the direction of the run is right-to-left, we + * render the subruns from right to left. We begin by incrementing |xOffset| by + * the width of the whole run, and then decrement it by the width of each + * subrun before rendering. After rendering all the subruns, we restore the + * x-coordinate of the end of the run for the start of the next run. + */ + + if (dir == NSBIDI_RTL) { + aprocessor.SetText(text + start, subRunLength, dir); + width = aprocessor.GetWidth(); + xOffset += width; + xEndRun = xOffset; + } + + while (subRunCount > 0) { + // CalculateCharType can increment subRunCount if the run + // contains mixed character types + CalculateCharType(aBidiEngine, text, lineOffset, typeLimit, subRunLimit, subRunLength, subRunCount, charType, prevType); + + nsAutoString runVisualText; + runVisualText.Assign(text + start, subRunLength); + if (int32_t(runVisualText.Length()) < subRunLength) + return NS_ERROR_OUT_OF_MEMORY; + FormatUnicodeText(aPresContext, runVisualText.BeginWriting(), + subRunLength, (nsCharType)charType); + + aprocessor.SetText(runVisualText.get(), subRunLength, dir); + width = aprocessor.GetWidth(); + totalWidth += width; + if (dir == NSBIDI_RTL) { + xOffset -= width; + } + if (aMode == MODE_DRAW) { + aprocessor.DrawText(xOffset, width); + } + + /* + * The caller may request to calculate the visual position of one + * or more characters. + */ + for(int nPosResolve=0; nPosResolve<aPosResolveCount; ++nPosResolve) + { + nsBidiPositionResolve* posResolve = &aPosResolve[nPosResolve]; + /* + * Did we already resolve this position's visual metric? If so, skip. + */ + if (posResolve->visualLeftTwips != kNotFound) + continue; + + /* + * First find out if the logical position is within this run. + */ + if (start <= posResolve->logicalIndex && + start + subRunLength > posResolve->logicalIndex) { + /* + * If this run is only one character long, we have an easy case: + * the visual position is the x-coord of the start of the run + * less the x-coord of the start of the whole text. + */ + if (subRunLength == 1) { + posResolve->visualIndex = visualStart; + posResolve->visualLeftTwips = xOffset; + posResolve->visualWidth = width; + } + /* + * Otherwise, we need to measure the width of the run's part + * which is to the visual left of the index. + * In other words, the run is broken in two, around the logical index, + * and we measure the part which is visually left. + * If the run is right-to-left, this part will span from after the index + * up to the end of the run; if it is left-to-right, this part will span + * from the start of the run up to (and inclduing) the character before the index. + */ + else { + /* + * Here is a description of how the width of the current character + * (posResolve->visualWidth) is calculated: + * + * LTR (current char: "P"): + * S A M P L E (logical index: 3, visual index: 3) + * ^ (visualLeftPart) + * ^ (visualRightSide) + * visualLeftLength == 3 + * ^^^^^^ (subWidth) + * ^^^^^^^^ (aprocessor.GetWidth() -- with visualRightSide) + * ^^ (posResolve->visualWidth) + * + * RTL (current char: "M"): + * E L P M A S (logical index: 2, visual index: 3) + * ^ (visualLeftPart) + * ^ (visualRightSide) + * visualLeftLength == 3 + * ^^^^^^ (subWidth) + * ^^^^^^^^ (aprocessor.GetWidth() -- with visualRightSide) + * ^^ (posResolve->visualWidth) + */ + nscoord subWidth; + // The position in the text where this run's "left part" begins. + const char16_t* visualLeftPart; + const char16_t* visualRightSide; + if (dir == NSBIDI_RTL) { + // One day, son, this could all be replaced with mBidiEngine.GetVisualIndex ... + posResolve->visualIndex = visualStart + (subRunLength - (posResolve->logicalIndex + 1 - start)); + // Skipping to the "left part". + visualLeftPart = text + posResolve->logicalIndex + 1; + // Skipping to the right side of the current character + visualRightSide = visualLeftPart - 1; + } + else { + posResolve->visualIndex = visualStart + (posResolve->logicalIndex - start); + // Skipping to the "left part". + visualLeftPart = text + start; + // In LTR mode this is the same as visualLeftPart + visualRightSide = visualLeftPart; + } + // The delta between the start of the run and the left part's end. + int32_t visualLeftLength = posResolve->visualIndex - visualStart; + aprocessor.SetText(visualLeftPart, visualLeftLength, dir); + subWidth = aprocessor.GetWidth(); + aprocessor.SetText(visualRightSide, visualLeftLength + 1, dir); + posResolve->visualLeftTwips = xOffset + subWidth; + posResolve->visualWidth = aprocessor.GetWidth() - subWidth; + } + } + } + + if (dir == NSBIDI_LTR) { + xOffset += width; + } + + --subRunCount; + start = lineOffset; + subRunLimit = typeLimit; + subRunLength = typeLimit - lineOffset; + } // while + if (dir == NSBIDI_RTL) { + xOffset = xEndRun; + } + + visualStart += length; + } // for + + if (aWidth) { + *aWidth = totalWidth; + } + return NS_OK; +} + +class MOZ_STACK_CLASS nsIRenderingContextBidiProcessor final + : public nsBidiPresUtils::BidiProcessor +{ +public: + typedef mozilla::gfx::DrawTarget DrawTarget; + + nsIRenderingContextBidiProcessor(nsRenderingContext* aCtx, + DrawTarget* aTextRunConstructionDrawTarget, + nsFontMetrics* aFontMetrics, + const nsPoint& aPt) + : mCtx(aCtx) + , mTextRunConstructionDrawTarget(aTextRunConstructionDrawTarget) + , mFontMetrics(aFontMetrics) + , mPt(aPt) + {} + + ~nsIRenderingContextBidiProcessor() + { + mFontMetrics->SetTextRunRTL(false); + } + + virtual void SetText(const char16_t* aText, + int32_t aLength, + nsBidiDirection aDirection) override + { + mFontMetrics->SetTextRunRTL(aDirection==NSBIDI_RTL); + mText = aText; + mLength = aLength; + } + + virtual nscoord GetWidth() override + { + return nsLayoutUtils::AppUnitWidthOfString(mText, mLength, *mFontMetrics, + mTextRunConstructionDrawTarget); + } + + virtual void DrawText(nscoord aIOffset, + nscoord) override + { + nsPoint pt(mPt); + if (mFontMetrics->GetVertical()) { + pt.y += aIOffset; + } else { + pt.x += aIOffset; + } + mFontMetrics->DrawString(mText, mLength, pt.x, pt.y, + mCtx, mTextRunConstructionDrawTarget); + } + +private: + nsRenderingContext* mCtx; + DrawTarget* mTextRunConstructionDrawTarget; + nsFontMetrics* mFontMetrics; + nsPoint mPt; + const char16_t* mText; + int32_t mLength; +}; + +nsresult nsBidiPresUtils::ProcessTextForRenderingContext(const char16_t* aText, + int32_t aLength, + nsBidiLevel aBaseLevel, + nsPresContext* aPresContext, + nsRenderingContext& aRenderingContext, + DrawTarget* aTextRunConstructionDrawTarget, + nsFontMetrics& aFontMetrics, + Mode aMode, + nscoord aX, + nscoord aY, + nsBidiPositionResolve* aPosResolve, + int32_t aPosResolveCount, + nscoord* aWidth) +{ + nsIRenderingContextBidiProcessor processor(&aRenderingContext, + aTextRunConstructionDrawTarget, + &aFontMetrics, + nsPoint(aX, aY)); + nsBidi bidiEngine; + return ProcessText(aText, aLength, aBaseLevel, aPresContext, processor, + aMode, aPosResolve, aPosResolveCount, aWidth, &bidiEngine); +} + +/* static */ +nsBidiLevel +nsBidiPresUtils::BidiLevelFromStyle(nsStyleContext* aStyleContext) +{ + if (aStyleContext->StyleTextReset()->mUnicodeBidi & + NS_STYLE_UNICODE_BIDI_PLAINTEXT) { + return NSBIDI_DEFAULT_LTR; + } + + if (aStyleContext->StyleVisibility()->mDirection == NS_STYLE_DIRECTION_RTL) { + return NSBIDI_RTL; + } + + return NSBIDI_LTR; +} |