Attachment #537515 for bug #263359

Attachment #537515: Patch part 2.5: cache the lines for each frame while building mLogicalArray for bug #263359

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





 *  We may also need to call RemoveBidiContinuation() to convert frames created
 *  by EnsureBidiContinuation() in previous reflows into fluid continuations.
 */
nsresult
nsBidiPresUtils::Resolve(nsBlockFrame* aBlockFrame)
{
  mLogicalFrames.Clear();
  mContentToFrameIndex.Clear();
  mLinePerFrame.Clear();
  mBuffer.SetLength(0);
  
  nsPresContext *presContext = aBlockFrame->PresContext();

  const nsStyleVisibility* vis = aBlockFrame->GetStyleVisibility();

  mParaLevel = (NS_STYLE_DIRECTION_RTL == vis->mDirection) ?
                NSBIDI_RTL : NSBIDI_LTR;

  mLineIter = new nsBlockInFlowLineIterator(aBlockFrame,
                                            aBlockFrame->begin_lines(),
                                            PR_FALSE);
  if (mLineIter->GetLine() == aBlockFrame->end_lines()) {
    // Advance to first valid line (might be in a next-continuation)
    mLineIter->Next();
  }

  mIsVisual = presContext->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

         content = content->GetParent()) {
      if (content->IsNodeOfType(nsINode::eHTML_FORM_CONTROL) ||
          content->IsXUL()) {
        mIsVisual = PR_FALSE;
        break;
      }
    }
  }
  mPrevFrame = nsnull;

  // handle bidi-override being set on the block itself before calling
  // InitLogicalArray.
  const nsStyleTextReset* text = aBlockFrame->GetStyleTextReset();
  PRUnichar ch = 0;
  if (text->mUnicodeBidi == NS_STYLE_UNICODE_BIDI_OVERRIDE) {
    if (NS_STYLE_DIRECTION_RTL == vis->mDirection) {
      ch = kRLO;
    }
    else if (NS_STYLE_DIRECTION_LTR == vis->mDirection) {
      ch = kLRO;
    }
    if (ch != 0) {
      mLogicalFrames.AppendElement(NS_BIDI_CONTROL_FRAME);
      mLinePerFrame.AppendElement((nsLineBox*)nsnull);
      mBuffer.Append(ch);
    }
  }
  mPrevContent = nsnull;
  for (nsBlockFrame* block = aBlockFrame; block;
       block = static_cast<nsBlockFrame*>(block->GetNextContinuation())) {
    block->RemoveStateBits(NS_BLOCK_NEEDS_BIDI_RESOLUTION);
    nsBlockInFlowLineIterator lineIter(block, block->begin_lines(), PR_FALSE);
    mPrevFrame = nsnull;
    InitLogicalArray(&lineIter, block->GetFirstChild(nsnull));
  }

  if (ch != 0) {
    mLogicalFrames.AppendElement(NS_BIDI_CONTROL_FRAME);
    mLinePerFrame.AppendElement((nsLineBox*)nsnull);
    mBuffer.Append(kPDF);
  }

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

  PRInt32     frameCount     = mLogicalFrames.Length();
  PRInt32     contentOffset  = 0;   // offset of current frame in its content node
  PRBool      isTextFrame    = PR_FALSE;
  nsIFrame*   frame = nsnull;
  nsIContent* content = nsnull;
  PRInt32     contentTextLength;

  FramePropertyTable *propTable = presContext->PropertyTable();
  nsLineBox* currentLine = nsnull;
  
#ifdef DEBUG
#ifdef NOISY_BIDI
  printf("Before Resolve(), aBlockFrame=0x%p, mBuffer='%s', frameCount=%d\n",
         (void*)aBlockFrame, NS_ConvertUTF16toUTF8(mBuffer).get(), frameCount);
#ifdef REALLY_NOISY_BIDI
  printf(" block frame tree=:\n");
  aBlockFrame->List(stdout, 0);


  for (; ;) {
    if (fragmentLength <= 0) {
      // Get the next frame from mLogicalFrames
      if (++frameIndex >= frameCount) {
        break;
      }
      frame = mLogicalFrames[frameIndex];
      lineNeedsUpdate = PR_TRUE;
      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 = PR_FALSE;
        fragmentLength = 1;
      }
      else {
        currentLine = mLinePerFrame[frameIndex];
        content = frame->GetContent();
        if (!content) {
          mSuccess = NS_OK;
          break;
        }
        contentTextLength = content->TextLength();
        if (contentTextLength == 0) {
          frame->AdjustOffsetsForBidi(0, 0);

      propTable->Set(frame, nsIFrame::BaseLevelProperty(),
                     NS_INT32_TO_PTR(mParaLevel));
      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();
            AdvanceLineIteratorToFrame(frame, mLineIter, mPrevFrame);
            lineNeedsUpdate = PR_FALSE;
          }
          mLineIter->GetLine()->MarkDirty();
          nsIFrame* nextBidi;
          PRInt32 runEnd = contentOffset + runLength;
          EnsureBidiContinuation(frame, &nextBidi, frameIndex,
                                 contentOffset,
                                 runEnd);
          if (NS_FAILED(mSuccess)) {
            break;
          }

             */
            nsIFrame* next = frame->GetNextInFlow();
            if (next) {
              frame->SetNextContinuation(next);
              next->SetPrevContinuation(frame);
            }
          }
          frame->AdjustOffsetsForBidi(contentOffset, contentOffset + fragmentLength);
          currentLine->MarkDirty();
            AdvanceLineIteratorToFrame(frame, mLineIter, mPrevFrame);
            lineNeedsUpdate = PR_FALSE;
          }
          mLineIter->GetLine()->MarkDirty();
        }
      } // isTextFrame
      else {
        ++lineOffset;
      }
    } // not bidi control frame
    PRInt32 temp = runLength;
    runLength -= fragmentLength;

// 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(nsBlockInFlowLineIterator* aLineIter,
                                  nsIFrame*    aCurrentFrame)
{
  if (!aCurrentFrame)
    return;

  for (nsIFrame* childFrame = aCurrentFrame; childFrame;
       childFrame = childFrame->GetNextSibling()) {

    // If the real frame for a placeholder is a first letter frame, we need to

          }
          break;
      }

      // Add a dummy frame pointer representing a bidi control code before the
      // first frame of an element specifying embedding or override
      if (ch != 0 && !frame->GetPrevContinuation()) {
        mLogicalFrames.AppendElement(NS_BIDI_CONTROL_FRAME);
        mLinePerFrame.AppendElement((nsLineBox*)nsnull);
        mBuffer.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
       * frame in the array with a given content.
       */
      nsIContent* content = frame->GetContent();
      if (content) {
        mContentToFrameIndex.Put(content, mLogicalFrames.Length());
      }
      mLogicalFrames.AppendElement(frame);

      AdvanceLineIteratorToFrame(frame, aLineIter, mPrevFrame);
      mLinePerFrame.AppendElement(aLineIter->GetLine().get());

      // Append the content of the frame to the paragraph buffer
      nsIAtom* frameType = frame->GetType();
      if (nsGkAtoms::textFrame == frameType) {
        if (content != mPrevContent) {
          mPrevContent = content;
          content->AppendTextTo(mBuffer);
        }
      } else if (nsGkAtoms::brFrame == frameType) {

        // other frame type -- see the Unicode Bidi Algorithm:
        // "...inline objects (such as graphics) are treated as if they are ...
        // U+FFFC"
        mBuffer.Append(kObjectSubstitute);
      }
    }
    else {
      nsIFrame* kid = frame->GetFirstChild(nsnull);
      InitLogicalArray(aLineIter, kid);
    }

    // If the element is attributed by dir, indicate direction pop (add PDF frame)
    if (ch != 0 && !frame->GetNextContinuation()) {
      // Add a dummy frame pointer representing a bidi control code after the
      // last frame of an element specifying embedding or override
      mLogicalFrames.AppendElement(NS_BIDI_CONTROL_FRAME);
      mLinePerFrame.AppendElement((nsLineBox*)nsnull);
      mBuffer.Append(kPDF);
    }
  } // for
}

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





                                          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(nsBlockInFlowLineIterator* aLineIter,
                        nsIFrame* aCurrentFrame);

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


                                     nsBidi* aBidiEngine);

 static void WriteReverse(const PRUnichar* aSrc,
                          PRUint32 aSrcLength,
                          PRUnichar* aDest);

  nsAutoString    mBuffer;
  nsTArray<nsIFrame*> mLogicalFrames;
  nsTArray<nsLineBox*> mLinePerFrame;
  nsTArray<nsIFrame*> mVisualFrames;
  nsDataHashtable<nsISupportsHashKey, PRInt32> mContentToFrameIndex;
  PRInt32         mArraySize;
  PRInt32*        mIndexMap;
  PRUint8*        mLevels;
  nsresult        mSuccess;
  PRPackedBool    mIsVisual;
  nsBidiLevel     mParaLevel;
  nsIFrame*       mPrevFrame;
  nsIContent*     mPrevContent;

  nsAutoPtr<nsBlockInFlowLineIterator> mLineIter;
  nsBidi*         mBidiEngine;
};

#endif /* nsBidiPresUtils_h___ */

#endif // IBMBIDI

Return to bug 263359