Attachment #493939 for bug #263359

Attachment #493939: Patch part 3: Call ResolveParagraph on encountering <br> or embedded blocks for bug #263359

View | Details | Raw Unified | Return to bug 263359
Collapse All | Expand All





 *  by EnsureBidiContinuation() in previous reflows into fluid continuations.
 */
nsresult
nsBidiPresUtils::Resolve(nsBlockFrame* aBlockFrame)
{
  mLogicalFrames.Clear();
  mContentToFrameIndex.Clear();
  mBuffer.SetLength(0);
  mEmbeddingStack.SetLength(0);
  
  nsPresContext *presContext = aBlockFrame->PresContext();
  nsIPresShell* shell = presContext->PresShell();
  nsStyleContext* styleContext = aBlockFrame->GetStyleContext();

  // handle bidi-override being set on the block itself before calling
  // InitLogicalArray.
  const nsStyleVisibility* vis = aBlockFrame->GetStyleVisibility();

    else if (NS_STYLE_DIRECTION_LTR == vis->mDirection) {
      ch = kLRO;
    }
    if (ch != 0) {
      directionalFrame = NS_NewDirectionalFrame(shell, styleContext);
      if (directionalFrame) {
        mLogicalFrames.AppendElement(directionalFrame);
        mBuffer.Append(ch);
        mEmbeddingStack.Append(ch);
      }
    }
  }
  nsIContent* prevContent = nsnull;
  for (nsBlockFrame* block = aBlockFrame; block;
       block = static_cast<nsBlockFrame*>(block->GetNextContinuation())) {
    block->RemoveStateBits(NS_BLOCK_NEEDS_BIDI_RESOLUTION);
    InitLogicalArray(aBlockFrame, block->GetFirstChild(nsnull), prevContent);
  }

  if (ch != 0) {
    nsIFrame* directionalFrame = NS_NewDirectionalFrame(shell, styleContext);
    if (directionalFrame) {
      mLogicalFrames.AppendElement(directionalFrame);
      mBuffer.Append(kPDF);
      mEmbeddingStack.SetLength(mEmbeddingStack.Length() - 1);
    }
  }
  return ResolveParagraph(aBlockFrame, PR_FALSE);
}

nsresult
nsBidiPresUtils::ResolveParagraph(nsBlockFrame* aBlockFrame, PRBool aIsMore)
{
  // XXX: TODO: Handle preformatted text ('\n')
  mBuffer.ReplaceChar("\t\r\n", kSpace);

  if (aIsMore) {
    // pop all embeddings and overrides
    for (PRUint32 i = 0; i < mEmbeddingStack.Length(); ++i) {
      mBuffer.Append(kPDF);
    }
  }

  // XXX: TODO: Handle preformatted text ('\n')
  mBuffer.ReplaceChar("\t\r\n", kSpace);
  return ResolveParagraph(aBlockFrame);
}

nsresult
nsBidiPresUtils::ResolveParagraph(nsBlockFrame* aBlockFrame)
{
  nsPresContext *presContext = aBlockFrame->PresContext();
  const nsStyleVisibility* vis = aBlockFrame->GetStyleVisibility();
  PRInt32 bufferLength = mBuffer.Length();

  if (bufferLength < 1) {
    mSuccess = NS_OK;
    return mSuccess;
  }

        ++lineOffset;
      }
    } // not directionalFrame
    PRInt32 temp = runLength;
    runLength -= fragmentLength;
    fragmentLength -= temp;

    if (frame && 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 (numRun + 1 < runCount && runLength <= 0 && !frame->GetNextInFlow()) {
        nsIFrame* child = frame;
        nsIFrame* parent = frame->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 &&

        // We're not at an end of a run, and |frame| is the last child of its parent.
        // If its ancestors happen to have bidi continuations, convert them into
        // fluid continuations.
        nsIFrame* parent = frame->GetParent();
        JoinInlineAncestors(parent);
      }
    }
  } // for

  if (aIsMore) {
    // Clear the frame array and paragraph buffer, and restore the stored 
    // embeddings and overrides
    mLogicalFrames.Clear();
    mContentToFrameIndex.Clear();
    mBuffer.SetLength(0);
    mBuffer.Append(mEmbeddingStack);

    nsIPresShell* shell = presContext->PresShell();
    nsStyleContext* styleContext = aBlockFrame->GetStyleContext();
    for (PRUint32 i = 0; i < mEmbeddingStack.Length(); ++i) {
      nsIFrame* dirFrame = NS_NewDirectionalFrame(shell, styleContext);
      if (dirFrame) {
        mLogicalFrames.AppendElement(dirFrame);
      }
    }
  }
  return mSuccess;
}

// Should this frame be treated as a leaf (e.g. when building mLogicalFrames)?
PRBool IsBidiLeaf(nsIFrame* aFrame) {
  nsIFrame* kid = aFrame->GetFirstChild(nsnull);
  return !kid
    || !aFrame->IsFrameOfType(nsIFrame::eBidiInlineContainer);
}

void
nsBidiPresUtils::InitLogicalArray(nsBlockFrame* aBlockFrame,
                                  nsIFrame*    aCurrentFrame,
                                  nsIContent*& aPrevContent)
{
  if (!aCurrentFrame)
    return;

  nsIPresShell* shell = aCurrentFrame->PresContext()->PresShell();
  nsStyleContext* styleContext;



      // Create a directional frame before the first frame of an
      // element specifying embedding or override
      if (ch != 0 && !frame->GetPrevContinuation()) {
        nsIFrame* dirFrame = NS_NewDirectionalFrame(shell, styleContext);
        if (dirFrame) {
          mLogicalFrames.AppendElement(dirFrame);
          mBuffer.Append(ch);
          mEmbeddingStack.Append(ch);
        }
      }
    }

    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

      if (nsGkAtoms::textFrame == frameType) {
        if (content != aPrevContent) {
          aPrevContent = content;
          content->AppendTextTo(mBuffer);
        }
      } else if (nsGkAtoms::brFrame == frameType) {
        // break frame -- append line separator
        mBuffer.Append(kLineSeparator);
        ResolveParagraph(aBlockFrame, PR_TRUE);
      } else { 
        // other frame type -- see the Unicode Bidi Algorithm:
        // "...inline objects (such as graphics) are treated as if they are ...
        // U+FFFC"
        mBuffer.Append(kObjectSubstitute);
        if (frame->GetStyleContext()->GetStyleDisplay()->mDisplay !=
          NS_STYLE_DISPLAY_INLINE) {
          // if it is not inline, end the paragraph
          ResolveParagraph(aBlockFrame, PR_TRUE);
        }
      }
    }
    else {
      nsIFrame* kid = frame->GetFirstChild(nsnull);
      InitLogicalArray(aBlockFrame, kid, aPrevContent);
    }

    // If the element is attributed by dir, indicate direction pop (add PDF frame)
    if (ch != 0 && !frame->GetNextContinuation()) {
      // Create a directional frame after the last frame of an
      // element specifying embedding or override
      nsIFrame* dirFrame = NS_NewDirectionalFrame(shell, styleContext);
      if (dirFrame) {
        mLogicalFrames.AppendElement(dirFrame);
        mBuffer.Append(kPDF);
        mEmbeddingStack.SetLength(mEmbeddingStack.Length() - 1);
      }
    }
  } // for
}

void
nsBidiPresUtils::ReorderFrames(nsIFrame*            aFirstFrameOnLine,
                               PRInt32              aNumFramesOnLine)





   * Make Bidi engine calculate the embedding levels of the frames that are
   * descendants of a given block frame.
   *
   * @param aBlockFrame          The block frame
   *
   *  @lina 06/18/2000
   */
  nsresult Resolve(nsBlockFrame* aBlockFrame);
  nsresult ResolveParagraph(nsBlockFrame* aBlockFrame, PRBool aIsMore);

  /**
   * Reorder this line using Bidi engine.
   * Update frame array, following the new visual sequence.
   * 
   * @lina 05/02/2000
   */
  void ReorderFrames(nsIFrame*            aFirstFrameOnLine,

                                          PRInt32                aPosResolveCount,
                                          nscoord*               aWidth /* may be null */);

  /**
   * Set up an array of the frames after splitting frames so that each frame has
   * consistent directionality. At this point the frames are still in logical
   * order
   */
  void InitLogicalArray(nsBlockFrame* aBlockFrame,
                        nsIFrame* aCurrentFrame,
                        nsIContent*& aPrevContent);

  /**
   * Initialize the logically-ordered array of frames
   * using the top-level frames of a single line
   */
  void InitLogicalArrayFromLine(nsIFrame* aFirstFrameOnLine,
                                PRInt32   aNumFramesOnLine);


                         PRInt32& aRunLength,
                         PRInt32& aRunCount,
                         PRUint8& aCharType,
                         PRUint8& aPrevCharType) const;
  
  void StripBidiControlCharacters(PRUnichar* aText,
                                  PRInt32&   aTextLength) const;
  nsAutoString    mBuffer;
  nsAutoString    mEmbeddingStack;
  nsTArray<nsIFrame*> mLogicalFrames;
  nsTArray<nsIFrame*> mVisualFrames;
  nsDataHashtable<nsISupportsHashKey, PRInt32> mContentToFrameIndex;
  PRInt32         mArraySize;
  PRInt32*        mIndexMap;
  PRUint8*        mLevels;
  nsresult        mSuccess;


Return to bug 263359