michael@0: /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
michael@0: /* This Source Code Form is subject to the terms of the Mozilla Public
michael@0:  * License, v. 2.0. If a copy of the MPL was not distributed with this
michael@0:  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
michael@0: 
michael@0: /*
michael@0:  * nsIContentSerializer implementation that can be used with an
michael@0:  * nsIDocumentEncoder to convert a DOM into plaintext in a nice way
michael@0:  * (eg for copy/paste as plaintext).
michael@0:  */
michael@0: 
michael@0: #include "nsPlainTextSerializer.h"
michael@0: #include "nsLWBrkCIID.h"
michael@0: #include "nsIServiceManager.h"
michael@0: #include "nsGkAtoms.h"
michael@0: #include "nsNameSpaceManager.h"
michael@0: #include "nsTextFragment.h"
michael@0: #include "nsContentUtils.h"
michael@0: #include "nsReadableUtils.h"
michael@0: #include "nsUnicharUtils.h"
michael@0: #include "nsCRT.h"
michael@0: #include "mozilla/dom/Element.h"
michael@0: #include "mozilla/Preferences.h"
michael@0: 
michael@0: using namespace mozilla;
michael@0: using namespace mozilla::dom;
michael@0: 
michael@0: #define PREF_STRUCTS "converter.html2txt.structs"
michael@0: #define PREF_HEADER_STRATEGY "converter.html2txt.header_strategy"
michael@0: 
michael@0: static const  int32_t kTabSize=4;
michael@0: static const  int32_t kIndentSizeHeaders = 2;  /* Indention of h1, if
michael@0:                                                 mHeaderStrategy = 1 or = 2.
michael@0:                                                 Indention of other headers
michael@0:                                                 is derived from that.
michael@0:                                                 XXX center h1? */
michael@0: static const  int32_t kIndentIncrementHeaders = 2;  /* If mHeaderStrategy = 1,
michael@0:                                                 indent h(x+1) this many
michael@0:                                                 columns more than h(x) */
michael@0: static const  int32_t kIndentSizeList = kTabSize;
michael@0:                                // Indention of non-first lines of ul and ol
michael@0: static const  int32_t kIndentSizeDD = kTabSize;  // Indention of <dd>
michael@0: static const  char16_t  kNBSP = 160;
michael@0: static const  char16_t kSPACE = ' ';
michael@0: 
michael@0: static int32_t HeaderLevel(nsIAtom* aTag);
michael@0: static int32_t GetUnicharWidth(char16_t ucs);
michael@0: static int32_t GetUnicharStringWidth(const char16_t* pwcs, int32_t n);
michael@0: 
michael@0: // Someday may want to make this non-const:
michael@0: static const uint32_t TagStackSize = 500;
michael@0: static const uint32_t OLStackSize = 100;
michael@0: 
michael@0: nsresult NS_NewPlainTextSerializer(nsIContentSerializer** aSerializer)
michael@0: {
michael@0:   nsPlainTextSerializer* it = new nsPlainTextSerializer();
michael@0:   if (!it) {
michael@0:     return NS_ERROR_OUT_OF_MEMORY;
michael@0:   }
michael@0: 
michael@0:   return CallQueryInterface(it, aSerializer);
michael@0: }
michael@0: 
michael@0: nsPlainTextSerializer::nsPlainTextSerializer()
michael@0:   : kSpace(NS_LITERAL_STRING(" ")) // Init of "constant"
michael@0: {
michael@0: 
michael@0:   mOutputString = nullptr;
michael@0:   mHeadLevel = 0;
michael@0:   mAtFirstColumn = true;
michael@0:   mIndent = 0;
michael@0:   mCiteQuoteLevel = 0;
michael@0:   mStructs = true;       // will be read from prefs later
michael@0:   mHeaderStrategy = 1 /*indent increasingly*/;   // ditto
michael@0:   mDontWrapAnyQuotes = false;                 // ditto
michael@0:   mHasWrittenCiteBlockquote = false;
michael@0:   mSpanLevel = 0;
michael@0:   for (int32_t i = 0; i <= 6; i++) {
michael@0:     mHeaderCounter[i] = 0;
michael@0:   }
michael@0: 
michael@0:   // Line breaker
michael@0:   mWrapColumn = 72;     // XXX magic number, we expect someone to reset this
michael@0:   mCurrentLineWidth = 0;
michael@0: 
michael@0:   // Flow
michael@0:   mEmptyLines = 1; // The start of the document is an "empty line" in itself,
michael@0:   mInWhitespace = false;
michael@0:   mPreFormatted = false;
michael@0:   mStartedOutput = false;
michael@0: 
michael@0:   // initialize the tag stack to zero:
michael@0:   // The stack only ever contains pointers to static atoms, so they don't
michael@0:   // need refcounting.
michael@0:   mTagStack = new nsIAtom*[TagStackSize];
michael@0:   mTagStackIndex = 0;
michael@0:   mIgnoreAboveIndex = (uint32_t)kNotFound;
michael@0: 
michael@0:   // initialize the OL stack, where numbers for ordered lists are kept
michael@0:   mOLStack = new int32_t[OLStackSize];
michael@0:   mOLStackIndex = 0;
michael@0: 
michael@0:   mULCount = 0;
michael@0: 
michael@0:   mIgnoredChildNodeLevel = 0;
michael@0: }
michael@0: 
michael@0: nsPlainTextSerializer::~nsPlainTextSerializer()
michael@0: {
michael@0:   delete[] mTagStack;
michael@0:   delete[] mOLStack;
michael@0:   NS_WARN_IF_FALSE(mHeadLevel == 0, "Wrong head level!");
michael@0: }
michael@0: 
michael@0: NS_IMPL_ISUPPORTS(nsPlainTextSerializer,
michael@0:                   nsIContentSerializer)
michael@0: 
michael@0: 
michael@0: NS_IMETHODIMP 
michael@0: nsPlainTextSerializer::Init(uint32_t aFlags, uint32_t aWrapColumn,
michael@0:                             const char* aCharSet, bool aIsCopying,
michael@0:                             bool aIsWholeDocument)
michael@0: {
michael@0: #ifdef DEBUG
michael@0:   // Check if the major control flags are set correctly.
michael@0:   if (aFlags & nsIDocumentEncoder::OutputFormatFlowed) {
michael@0:     NS_ASSERTION(aFlags & nsIDocumentEncoder::OutputFormatted,
michael@0:                  "If you want format=flowed, you must combine it with "
michael@0:                  "nsIDocumentEncoder::OutputFormatted");
michael@0:   }
michael@0: 
michael@0:   if (aFlags & nsIDocumentEncoder::OutputFormatted) {
michael@0:     NS_ASSERTION(!(aFlags & nsIDocumentEncoder::OutputPreformatted),
michael@0:                  "Can't do formatted and preformatted output at the same time!");
michael@0:   }
michael@0: #endif
michael@0: 
michael@0:   mFlags = aFlags;
michael@0:   mWrapColumn = aWrapColumn;
michael@0: 
michael@0:   // Only create a linebreaker if we will handle wrapping.
michael@0:   if (MayWrap()) {
michael@0:     mLineBreaker = nsContentUtils::LineBreaker();
michael@0:   }
michael@0: 
michael@0:   // Set the line break character:
michael@0:   if ((mFlags & nsIDocumentEncoder::OutputCRLineBreak)
michael@0:       && (mFlags & nsIDocumentEncoder::OutputLFLineBreak)) {
michael@0:     // Windows
michael@0:     mLineBreak.AssignLiteral("\r\n");
michael@0:   }
michael@0:   else if (mFlags & nsIDocumentEncoder::OutputCRLineBreak) {
michael@0:     // Mac
michael@0:     mLineBreak.Assign(char16_t('\r'));
michael@0:   }
michael@0:   else if (mFlags & nsIDocumentEncoder::OutputLFLineBreak) {
michael@0:     // Unix/DOM
michael@0:     mLineBreak.Assign(char16_t('\n'));
michael@0:   }
michael@0:   else {
michael@0:     // Platform/default
michael@0:     mLineBreak.AssignLiteral(NS_LINEBREAK);
michael@0:   }
michael@0: 
michael@0:   mLineBreakDue = false;
michael@0:   mFloatingLines = -1;
michael@0: 
michael@0:   if (mFlags & nsIDocumentEncoder::OutputFormatted) {
michael@0:     // Get some prefs that controls how we do formatted output
michael@0:     mStructs = Preferences::GetBool(PREF_STRUCTS, mStructs);
michael@0: 
michael@0:     mHeaderStrategy =
michael@0:       Preferences::GetInt(PREF_HEADER_STRATEGY, mHeaderStrategy);
michael@0: 
michael@0:     // DontWrapAnyQuotes is set according to whether plaintext mail
michael@0:     // is wrapping to window width -- see bug 134439.
michael@0:     // We'll only want this if we're wrapping and formatted.
michael@0:     if (mFlags & nsIDocumentEncoder::OutputWrap || mWrapColumn > 0) {
michael@0:       mDontWrapAnyQuotes =
michael@0:         Preferences::GetBool("mail.compose.wrap_to_window_width",
michael@0:                              mDontWrapAnyQuotes);
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   // XXX We should let the caller pass this in.
michael@0:   if (Preferences::GetBool("browser.frames.enabled")) {
michael@0:     mFlags &= ~nsIDocumentEncoder::OutputNoFramesContent;
michael@0:   }
michael@0:   else {
michael@0:     mFlags |= nsIDocumentEncoder::OutputNoFramesContent;
michael@0:   }
michael@0: 
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: bool
michael@0: nsPlainTextSerializer::GetLastBool(const nsTArray<bool>& aStack)
michael@0: {
michael@0:   uint32_t size = aStack.Length();
michael@0:   if (size == 0) {
michael@0:     return false;
michael@0:   }
michael@0:   return aStack.ElementAt(size-1);
michael@0: }
michael@0: 
michael@0: void
michael@0: nsPlainTextSerializer::SetLastBool(nsTArray<bool>& aStack, bool aValue)
michael@0: {
michael@0:   uint32_t size = aStack.Length();
michael@0:   if (size > 0) {
michael@0:     aStack.ElementAt(size-1) = aValue;
michael@0:   }
michael@0:   else {
michael@0:     NS_ERROR("There is no \"Last\" value");
michael@0:   }
michael@0: }
michael@0: 
michael@0: void
michael@0: nsPlainTextSerializer::PushBool(nsTArray<bool>& aStack, bool aValue)
michael@0: {
michael@0:     aStack.AppendElement(bool(aValue));
michael@0: }
michael@0: 
michael@0: bool
michael@0: nsPlainTextSerializer::PopBool(nsTArray<bool>& aStack)
michael@0: {
michael@0:   bool returnValue = false;
michael@0:   uint32_t size = aStack.Length();
michael@0:   if (size > 0) {
michael@0:     returnValue = aStack.ElementAt(size-1);
michael@0:     aStack.RemoveElementAt(size-1);
michael@0:   }
michael@0:   return returnValue;
michael@0: }
michael@0: 
michael@0: bool
michael@0: nsPlainTextSerializer::ShouldReplaceContainerWithPlaceholder(nsIAtom* aTag)
michael@0: {
michael@0:   // If nsIDocumentEncoder::OutputNonTextContentAsPlaceholder is set,
michael@0:   // non-textual container element should be serialized as placeholder
michael@0:   // character and its child nodes should be ignored. See bug 895239.
michael@0:   if (!(mFlags & nsIDocumentEncoder::OutputNonTextContentAsPlaceholder)) {
michael@0:     return false;
michael@0:   }
michael@0: 
michael@0:   return
michael@0:     (aTag == nsGkAtoms::audio) ||
michael@0:     (aTag == nsGkAtoms::canvas) ||
michael@0:     (aTag == nsGkAtoms::iframe) ||
michael@0:     (aTag == nsGkAtoms::meter) ||
michael@0:     (aTag == nsGkAtoms::progress) ||
michael@0:     (aTag == nsGkAtoms::object) ||
michael@0:     (aTag == nsGkAtoms::svg) ||
michael@0:     (aTag == nsGkAtoms::video);
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP 
michael@0: nsPlainTextSerializer::AppendText(nsIContent* aText,
michael@0:                                   int32_t aStartOffset,
michael@0:                                   int32_t aEndOffset, 
michael@0:                                   nsAString& aStr)
michael@0: {
michael@0:   if (mIgnoreAboveIndex != (uint32_t)kNotFound) {
michael@0:     return NS_OK;
michael@0:   }
michael@0:     
michael@0:   NS_ASSERTION(aStartOffset >= 0, "Negative start offset for text fragment!");
michael@0:   if ( aStartOffset < 0 )
michael@0:     return NS_ERROR_INVALID_ARG;
michael@0: 
michael@0:   NS_ENSURE_ARG(aText);
michael@0: 
michael@0:   nsresult rv = NS_OK;
michael@0: 
michael@0:   nsIContent* content = aText;
michael@0:   const nsTextFragment* frag;
michael@0:   if (!content || !(frag = content->GetText())) {
michael@0:     return NS_ERROR_FAILURE;
michael@0:   }
michael@0:   
michael@0:   int32_t fragLength = frag->GetLength();
michael@0:   int32_t endoffset = (aEndOffset == -1) ? fragLength : std::min(aEndOffset, fragLength);
michael@0:   NS_ASSERTION(aStartOffset <= endoffset, "A start offset is beyond the end of the text fragment!");
michael@0: 
michael@0:   int32_t length = endoffset - aStartOffset;
michael@0:   if (length <= 0) {
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   nsAutoString textstr;
michael@0:   if (frag->Is2b()) {
michael@0:     textstr.Assign(frag->Get2b() + aStartOffset, length);
michael@0:   }
michael@0:   else {
michael@0:     // AssignASCII is for 7-bit character only, so don't use it
michael@0:     const char *data = frag->Get1b();
michael@0:     CopyASCIItoUTF16(Substring(data + aStartOffset, data + endoffset), textstr);
michael@0:   }
michael@0: 
michael@0:   mOutputString = &aStr;
michael@0: 
michael@0:   // We have to split the string across newlines
michael@0:   // to match parser behavior
michael@0:   int32_t start = 0;
michael@0:   int32_t offset = textstr.FindCharInSet("\n\r");
michael@0:   while (offset != kNotFound) {
michael@0: 
michael@0:     if (offset>start) {
michael@0:       // Pass in the line
michael@0:       DoAddText(false,
michael@0:                 Substring(textstr, start, offset-start));
michael@0:     }
michael@0: 
michael@0:     // Pass in a newline
michael@0:     DoAddText(true, mLineBreak);
michael@0:     
michael@0:     start = offset+1;
michael@0:     offset = textstr.FindCharInSet("\n\r", start);
michael@0:   }
michael@0: 
michael@0:   // Consume the last bit of the string if there's any left
michael@0:   if (start < length) {
michael@0:     if (start) {
michael@0:       DoAddText(false, Substring(textstr, start, length - start));
michael@0:     }
michael@0:     else {
michael@0:       DoAddText(false, textstr);
michael@0:     }
michael@0:   }
michael@0:   
michael@0:   mOutputString = nullptr;
michael@0: 
michael@0:   return rv;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsPlainTextSerializer::AppendCDATASection(nsIContent* aCDATASection,
michael@0:                                           int32_t aStartOffset,
michael@0:                                           int32_t aEndOffset,
michael@0:                                           nsAString& aStr)
michael@0: {
michael@0:   return AppendText(aCDATASection, aStartOffset, aEndOffset, aStr);
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsPlainTextSerializer::AppendElementStart(Element* aElement,
michael@0:                                           Element* aOriginalElement,
michael@0:                                           nsAString& aStr)
michael@0: {
michael@0:   NS_ENSURE_ARG(aElement);
michael@0: 
michael@0:   mElement = aElement;
michael@0: 
michael@0:   nsresult rv;
michael@0:   nsIAtom* id = GetIdForContent(mElement);
michael@0: 
michael@0:   bool isContainer = !nsContentUtils::IsHTMLVoid(id);
michael@0: 
michael@0:   mOutputString = &aStr;
michael@0: 
michael@0:   if (isContainer) {
michael@0:     rv = DoOpenContainer(id);
michael@0:   }
michael@0:   else {
michael@0:     rv = DoAddLeaf(id);
michael@0:   }
michael@0: 
michael@0:   mElement = nullptr;
michael@0:   mOutputString = nullptr;
michael@0: 
michael@0:   if (id == nsGkAtoms::head) {
michael@0:     ++mHeadLevel;
michael@0:   }
michael@0: 
michael@0:   return rv;
michael@0: } 
michael@0:  
michael@0: NS_IMETHODIMP 
michael@0: nsPlainTextSerializer::AppendElementEnd(Element* aElement,
michael@0:                                         nsAString& aStr)
michael@0: {
michael@0:   NS_ENSURE_ARG(aElement);
michael@0: 
michael@0:   mElement = aElement;
michael@0: 
michael@0:   nsresult rv;
michael@0:   nsIAtom* id = GetIdForContent(mElement);
michael@0: 
michael@0:   bool isContainer = !nsContentUtils::IsHTMLVoid(id);
michael@0: 
michael@0:   mOutputString = &aStr;
michael@0: 
michael@0:   rv = NS_OK;
michael@0:   if (isContainer) {
michael@0:     rv = DoCloseContainer(id);
michael@0:   }
michael@0: 
michael@0:   mElement = nullptr;
michael@0:   mOutputString = nullptr;
michael@0: 
michael@0:   if (id == nsGkAtoms::head) {
michael@0:     NS_ASSERTION(mHeadLevel != 0,
michael@0:                  "mHeadLevel being decremented below 0");
michael@0:     --mHeadLevel;
michael@0:   }
michael@0: 
michael@0:   return rv;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP 
michael@0: nsPlainTextSerializer::Flush(nsAString& aStr)
michael@0: {
michael@0:   mOutputString = &aStr;
michael@0:   FlushLine();
michael@0:   mOutputString = nullptr;
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: NS_IMETHODIMP
michael@0: nsPlainTextSerializer::AppendDocumentStart(nsIDocument *aDocument,
michael@0:                                            nsAString& aStr)
michael@0: {
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: nsPlainTextSerializer::DoOpenContainer(nsIAtom* aTag)
michael@0: {
michael@0:   // Check if we need output current node as placeholder character and ignore
michael@0:   // child nodes.
michael@0:   if (ShouldReplaceContainerWithPlaceholder(mElement->Tag())) {
michael@0:     if (mIgnoredChildNodeLevel == 0) {
michael@0:       // Serialize current node as placeholder character
michael@0:       Write(NS_LITERAL_STRING("\xFFFC"));
michael@0:     }
michael@0:     // Ignore child nodes.
michael@0:     mIgnoredChildNodeLevel++;
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   if (mFlags & nsIDocumentEncoder::OutputRaw) {
michael@0:     // Raw means raw.  Don't even think about doing anything fancy
michael@0:     // here like indenting, adding line breaks or any other
michael@0:     // characters such as list item bullets, quote characters
michael@0:     // around <q>, etc.  I mean it!  Don't make me smack you!
michael@0: 
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   if (mTagStackIndex < TagStackSize) {
michael@0:     mTagStack[mTagStackIndex++] = aTag;
michael@0:   }
michael@0: 
michael@0:   if (mIgnoreAboveIndex != (uint32_t)kNotFound) {
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   // Reset this so that <blockquote type=cite> doesn't affect the whitespace
michael@0:   // above random <pre>s below it.
michael@0:   mHasWrittenCiteBlockquote = mHasWrittenCiteBlockquote &&
michael@0:                               aTag == nsGkAtoms::pre;
michael@0: 
michael@0:   bool isInCiteBlockquote = false;
michael@0: 
michael@0:   // XXX special-case <blockquote type=cite> so that we don't add additional
michael@0:   // newlines before the text.
michael@0:   if (aTag == nsGkAtoms::blockquote) {
michael@0:     nsAutoString value;
michael@0:     nsresult rv = GetAttributeValue(nsGkAtoms::type, value);
michael@0:     isInCiteBlockquote = NS_SUCCEEDED(rv) && value.EqualsIgnoreCase("cite");
michael@0:   }
michael@0: 
michael@0:   if (mLineBreakDue && !isInCiteBlockquote)
michael@0:     EnsureVerticalSpace(mFloatingLines);
michael@0: 
michael@0:   // Check if this tag's content that should not be output
michael@0:   if ((aTag == nsGkAtoms::noscript &&
michael@0:        !(mFlags & nsIDocumentEncoder::OutputNoScriptContent)) ||
michael@0:       ((aTag == nsGkAtoms::iframe || aTag == nsGkAtoms::noframes) &&
michael@0:        !(mFlags & nsIDocumentEncoder::OutputNoFramesContent))) {
michael@0:     // Ignore everything that follows the current tag in 
michael@0:     // question until a matching end tag is encountered.
michael@0:     mIgnoreAboveIndex = mTagStackIndex - 1;
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   if (aTag == nsGkAtoms::body) {
michael@0:     // Try to figure out here whether we have a
michael@0:     // preformatted style attribute.
michael@0:     //
michael@0:     // Trigger on the presence of a "pre-wrap" in the
michael@0:     // style attribute. That's a very simplistic way to do
michael@0:     // it, but better than nothing.
michael@0:     // Also set mWrapColumn to the value given there
michael@0:     // (which arguably we should only do if told to do so).
michael@0:     nsAutoString style;
michael@0:     int32_t whitespace;
michael@0:     if (NS_SUCCEEDED(GetAttributeValue(nsGkAtoms::style, style)) &&
michael@0:        (kNotFound != (whitespace = style.Find("white-space:")))) {
michael@0: 
michael@0:       if (kNotFound != style.Find("pre-wrap", true, whitespace)) {
michael@0: #ifdef DEBUG_preformatted
michael@0:         printf("Set mPreFormatted based on style pre-wrap\n");
michael@0: #endif
michael@0:         mPreFormatted = true;
michael@0:         int32_t widthOffset = style.Find("width:");
michael@0:         if (widthOffset >= 0) {
michael@0:           // We have to search for the ch before the semicolon,
michael@0:           // not for the semicolon itself, because nsString::ToInteger()
michael@0:           // considers 'c' to be a valid numeric char (even if radix=10)
michael@0:           // but then gets confused if it sees it next to the number
michael@0:           // when the radix specified was 10, and returns an error code.
michael@0:           int32_t semiOffset = style.Find("ch", false, widthOffset+6);
michael@0:           int32_t length = (semiOffset > 0 ? semiOffset - widthOffset - 6
michael@0:                             : style.Length() - widthOffset);
michael@0:           nsAutoString widthstr;
michael@0:           style.Mid(widthstr, widthOffset+6, length);
michael@0:           nsresult err;
michael@0:           int32_t col = widthstr.ToInteger(&err);
michael@0: 
michael@0:           if (NS_SUCCEEDED(err)) {
michael@0:             mWrapColumn = (uint32_t)col;
michael@0: #ifdef DEBUG_preformatted
michael@0:             printf("Set wrap column to %d based on style\n", mWrapColumn);
michael@0: #endif
michael@0:           }
michael@0:         }
michael@0:       }
michael@0:       else if (kNotFound != style.Find("pre", true, whitespace)) {
michael@0: #ifdef DEBUG_preformatted
michael@0:         printf("Set mPreFormatted based on style pre\n");
michael@0: #endif
michael@0:         mPreFormatted = true;
michael@0:         mWrapColumn = 0;
michael@0:       }
michael@0:     } 
michael@0:     else {
michael@0:       /* See comment at end of function. */
michael@0:       mInWhitespace = true;
michael@0:       mPreFormatted = false;
michael@0:     }
michael@0: 
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   // Keep this in sync with DoCloseContainer!
michael@0:   if (!DoOutput()) {
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   if (aTag == nsGkAtoms::p)
michael@0:     EnsureVerticalSpace(1);
michael@0:   else if (aTag == nsGkAtoms::pre) {
michael@0:     if (GetLastBool(mIsInCiteBlockquote))
michael@0:       EnsureVerticalSpace(0);
michael@0:     else if (mHasWrittenCiteBlockquote) {
michael@0:       EnsureVerticalSpace(0);
michael@0:       mHasWrittenCiteBlockquote = false;
michael@0:     }
michael@0:     else
michael@0:       EnsureVerticalSpace(1);
michael@0:   }
michael@0:   else if (aTag == nsGkAtoms::tr) {
michael@0:     PushBool(mHasWrittenCellsForRow, false);
michael@0:   }
michael@0:   else if (aTag == nsGkAtoms::td || aTag == nsGkAtoms::th) {
michael@0:     // We must make sure that the content of two table cells get a
michael@0:     // space between them.
michael@0: 
michael@0:     // To make the separation between cells most obvious and
michael@0:     // importable, we use a TAB.
michael@0:     if (GetLastBool(mHasWrittenCellsForRow)) {
michael@0:       // Bypass |Write| so that the TAB isn't compressed away.
michael@0:       AddToLine(MOZ_UTF16("\t"), 1);
michael@0:       mInWhitespace = true;
michael@0:     }
michael@0:     else if (mHasWrittenCellsForRow.IsEmpty()) {
michael@0:       // We don't always see a <tr> (nor a <table>) before the <td> if we're
michael@0:       // copying part of a table
michael@0:       PushBool(mHasWrittenCellsForRow, true); // will never be popped
michael@0:     }
michael@0:     else {
michael@0:       SetLastBool(mHasWrittenCellsForRow, true);
michael@0:     }
michael@0:   }
michael@0:   else if (aTag == nsGkAtoms::ul) {
michael@0:     // Indent here to support nested lists, which aren't included in li :-(
michael@0:     EnsureVerticalSpace(mULCount + mOLStackIndex == 0 ? 1 : 0);
michael@0:          // Must end the current line before we change indention
michael@0:     mIndent += kIndentSizeList;
michael@0:     mULCount++;
michael@0:   }
michael@0:   else if (aTag == nsGkAtoms::ol) {
michael@0:     EnsureVerticalSpace(mULCount + mOLStackIndex == 0 ? 1 : 0);
michael@0:     if (mFlags & nsIDocumentEncoder::OutputFormatted) {
michael@0:       // Must end the current line before we change indention
michael@0:       if (mOLStackIndex < OLStackSize) {
michael@0:         nsAutoString startAttr;
michael@0:         int32_t startVal = 1;
michael@0:         if (NS_SUCCEEDED(GetAttributeValue(nsGkAtoms::start, startAttr))) {
michael@0:           nsresult rv = NS_OK;
michael@0:           startVal = startAttr.ToInteger(&rv);
michael@0:           if (NS_FAILED(rv))
michael@0:             startVal = 1;
michael@0:         }
michael@0:         mOLStack[mOLStackIndex++] = startVal;
michael@0:       }
michael@0:     } else {
michael@0:       mOLStackIndex++;
michael@0:     }
michael@0:     mIndent += kIndentSizeList;  // see ul
michael@0:   }
michael@0:   else if (aTag == nsGkAtoms::li &&
michael@0:            (mFlags & nsIDocumentEncoder::OutputFormatted)) {
michael@0:     if (mTagStackIndex > 1 && IsInOL()) {
michael@0:       if (mOLStackIndex > 0) {
michael@0:         nsAutoString valueAttr;
michael@0:         if (NS_SUCCEEDED(GetAttributeValue(nsGkAtoms::value, valueAttr))) {
michael@0:           nsresult rv = NS_OK;
michael@0:           int32_t valueAttrVal = valueAttr.ToInteger(&rv);
michael@0:           if (NS_SUCCEEDED(rv))
michael@0:             mOLStack[mOLStackIndex-1] = valueAttrVal;
michael@0:         }
michael@0:         // This is what nsBulletFrame does for OLs:
michael@0:         mInIndentString.AppendInt(mOLStack[mOLStackIndex-1]++, 10);
michael@0:       }
michael@0:       else {
michael@0:         mInIndentString.Append(char16_t('#'));
michael@0:       }
michael@0: 
michael@0:       mInIndentString.Append(char16_t('.'));
michael@0: 
michael@0:     }
michael@0:     else {
michael@0:       static char bulletCharArray[] = "*o+#";
michael@0:       uint32_t index = mULCount > 0 ? (mULCount - 1) : 3;
michael@0:       char bulletChar = bulletCharArray[index % 4];
michael@0:       mInIndentString.Append(char16_t(bulletChar));
michael@0:     }
michael@0: 
michael@0:     mInIndentString.Append(char16_t(' '));
michael@0:   }
michael@0:   else if (aTag == nsGkAtoms::dl) {
michael@0:     EnsureVerticalSpace(1);
michael@0:   }
michael@0:   else if (aTag == nsGkAtoms::dt) {
michael@0:     EnsureVerticalSpace(0);
michael@0:   }
michael@0:   else if (aTag == nsGkAtoms::dd) {
michael@0:     EnsureVerticalSpace(0);
michael@0:     mIndent += kIndentSizeDD;
michael@0:   }
michael@0:   else if (aTag == nsGkAtoms::span) {
michael@0:     ++mSpanLevel;
michael@0:   }
michael@0:   else if (aTag == nsGkAtoms::blockquote) {
michael@0:     // Push
michael@0:     PushBool(mIsInCiteBlockquote, isInCiteBlockquote);
michael@0:     if (isInCiteBlockquote) {
michael@0:       EnsureVerticalSpace(0);
michael@0:       mCiteQuoteLevel++;
michael@0:     }
michael@0:     else {
michael@0:       EnsureVerticalSpace(1);
michael@0:       mIndent += kTabSize; // Check for some maximum value?
michael@0:     }
michael@0:   }
michael@0:   else if (aTag == nsGkAtoms::q) {
michael@0:     Write(NS_LITERAL_STRING("\""));
michael@0:   }
michael@0: 
michael@0:   // Else make sure we'll separate block level tags,
michael@0:   // even if we're about to leave, before doing any other formatting.
michael@0:   else if (nsContentUtils::IsHTMLBlock(aTag)) {
michael@0:     EnsureVerticalSpace(0);
michael@0:   }
michael@0: 
michael@0:   //////////////////////////////////////////////////////////////
michael@0:   if (!(mFlags & nsIDocumentEncoder::OutputFormatted)) {
michael@0:     return NS_OK;
michael@0:   }
michael@0:   //////////////////////////////////////////////////////////////
michael@0:   // The rest of this routine is formatted output stuff,
michael@0:   // which we should skip if we're not formatted:
michael@0:   //////////////////////////////////////////////////////////////
michael@0: 
michael@0:   // Push on stack
michael@0:   bool currentNodeIsConverted = IsCurrentNodeConverted();
michael@0: 
michael@0:   if (aTag == nsGkAtoms::h1 || aTag == nsGkAtoms::h2 ||
michael@0:       aTag == nsGkAtoms::h3 || aTag == nsGkAtoms::h4 ||
michael@0:       aTag == nsGkAtoms::h5 || aTag == nsGkAtoms::h6)
michael@0:   {
michael@0:     EnsureVerticalSpace(2);
michael@0:     if (mHeaderStrategy == 2) {  // numbered
michael@0:       mIndent += kIndentSizeHeaders;
michael@0:       // Caching
michael@0:       int32_t level = HeaderLevel(aTag);
michael@0:       // Increase counter for current level
michael@0:       mHeaderCounter[level]++;
michael@0:       // Reset all lower levels
michael@0:       int32_t i;
michael@0: 
michael@0:       for (i = level + 1; i <= 6; i++) {
michael@0:         mHeaderCounter[i] = 0;
michael@0:       }
michael@0: 
michael@0:       // Construct numbers
michael@0:       nsAutoString leadup;
michael@0:       for (i = 1; i <= level; i++) {
michael@0:         leadup.AppendInt(mHeaderCounter[i]);
michael@0:         leadup.Append(char16_t('.'));
michael@0:       }
michael@0:       leadup.Append(char16_t(' '));
michael@0:       Write(leadup);
michael@0:     }
michael@0:     else if (mHeaderStrategy == 1) { // indent increasingly
michael@0:       mIndent += kIndentSizeHeaders;
michael@0:       for (int32_t i = HeaderLevel(aTag); i > 1; i--) {
michael@0:            // for h(x), run x-1 times
michael@0:         mIndent += kIndentIncrementHeaders;
michael@0:       }
michael@0:     }
michael@0:   }
michael@0:   else if (aTag == nsGkAtoms::a && !currentNodeIsConverted) {
michael@0:     nsAutoString url;
michael@0:     if (NS_SUCCEEDED(GetAttributeValue(nsGkAtoms::href, url))
michael@0:         && !url.IsEmpty()) {
michael@0:       mURL = url;
michael@0:     }
michael@0:   }
michael@0:   else if (aTag == nsGkAtoms::sup && mStructs && !currentNodeIsConverted) {
michael@0:     Write(NS_LITERAL_STRING("^"));
michael@0:   }
michael@0:   else if (aTag == nsGkAtoms::sub && mStructs && !currentNodeIsConverted) {
michael@0:     Write(NS_LITERAL_STRING("_"));
michael@0:   }
michael@0:   else if (aTag == nsGkAtoms::code && mStructs && !currentNodeIsConverted) {
michael@0:     Write(NS_LITERAL_STRING("|"));
michael@0:   }
michael@0:   else if ((aTag == nsGkAtoms::strong || aTag == nsGkAtoms::b)
michael@0:            && mStructs && !currentNodeIsConverted) {
michael@0:     Write(NS_LITERAL_STRING("*"));
michael@0:   }
michael@0:   else if ((aTag == nsGkAtoms::em || aTag == nsGkAtoms::i)
michael@0:            && mStructs && !currentNodeIsConverted) {
michael@0:     Write(NS_LITERAL_STRING("/"));
michael@0:   }
michael@0:   else if (aTag == nsGkAtoms::u && mStructs && !currentNodeIsConverted) {
michael@0:     Write(NS_LITERAL_STRING("_"));
michael@0:   }
michael@0: 
michael@0:   /* Container elements are always block elements, so we shouldn't
michael@0:      output any whitespace immediately after the container tag even if
michael@0:      there's extra whitespace there because the HTML is pretty-printed
michael@0:      or something. To ensure that happens, tell the serializer we're
michael@0:      already in whitespace so it won't output more. */
michael@0:   mInWhitespace = true;
michael@0: 
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: nsPlainTextSerializer::DoCloseContainer(nsIAtom* aTag)
michael@0: {
michael@0:   if (ShouldReplaceContainerWithPlaceholder(mElement->Tag())) {
michael@0:     mIgnoredChildNodeLevel--;
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   if (mFlags & nsIDocumentEncoder::OutputRaw) {
michael@0:     // Raw means raw.  Don't even think about doing anything fancy
michael@0:     // here like indenting, adding line breaks or any other
michael@0:     // characters such as list item bullets, quote characters
michael@0:     // around <q>, etc.  I mean it!  Don't make me smack you!
michael@0: 
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   if (mTagStackIndex > 0) {
michael@0:     --mTagStackIndex;
michael@0:   }
michael@0: 
michael@0:   if (mTagStackIndex >= mIgnoreAboveIndex) {
michael@0:     if (mTagStackIndex == mIgnoreAboveIndex) {
michael@0:       // We're dealing with the close tag whose matching
michael@0:       // open tag had set the mIgnoreAboveIndex value.
michael@0:       // Reset mIgnoreAboveIndex before discarding this tag.
michael@0:       mIgnoreAboveIndex = (uint32_t)kNotFound;
michael@0:     }
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   // End current line if we're ending a block level tag
michael@0:   if ((aTag == nsGkAtoms::body) || (aTag == nsGkAtoms::html)) {
michael@0:     // We want the output to end with a new line,
michael@0:     // but in preformatted areas like text fields,
michael@0:     // we can't emit newlines that weren't there.
michael@0:     // So add the newline only in the case of formatted output.
michael@0:     if (mFlags & nsIDocumentEncoder::OutputFormatted) {
michael@0:       EnsureVerticalSpace(0);
michael@0:     }
michael@0:     else {
michael@0:       FlushLine();
michael@0:     }
michael@0:     // We won't want to do anything with these in formatted mode either,
michael@0:     // so just return now:
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   // Keep this in sync with DoOpenContainer!
michael@0:   if (!DoOutput()) {
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   if (aTag == nsGkAtoms::tr) {
michael@0:     PopBool(mHasWrittenCellsForRow);
michael@0:     // Should always end a line, but get no more whitespace
michael@0:     if (mFloatingLines < 0)
michael@0:       mFloatingLines = 0;
michael@0:     mLineBreakDue = true;
michael@0:   }
michael@0:   else if (((aTag == nsGkAtoms::li) ||
michael@0:             (aTag == nsGkAtoms::dt)) &&
michael@0:            (mFlags & nsIDocumentEncoder::OutputFormatted)) {
michael@0:     // Items that should always end a line, but get no more whitespace
michael@0:     if (mFloatingLines < 0)
michael@0:       mFloatingLines = 0;
michael@0:     mLineBreakDue = true;
michael@0:   }
michael@0:   else if (aTag == nsGkAtoms::pre) {
michael@0:     mFloatingLines = GetLastBool(mIsInCiteBlockquote) ? 0 : 1;
michael@0:     mLineBreakDue = true;
michael@0:   }
michael@0:   else if (aTag == nsGkAtoms::ul) {
michael@0:     FlushLine();
michael@0:     mIndent -= kIndentSizeList;
michael@0:     if (--mULCount + mOLStackIndex == 0) {
michael@0:       mFloatingLines = 1;
michael@0:       mLineBreakDue = true;
michael@0:     }
michael@0:   }
michael@0:   else if (aTag == nsGkAtoms::ol) {
michael@0:     FlushLine(); // Doing this after decreasing OLStackIndex would be wrong.
michael@0:     mIndent -= kIndentSizeList;
michael@0:     NS_ASSERTION(mOLStackIndex, "Wrong OLStack level!");
michael@0:     mOLStackIndex--;
michael@0:     if (mULCount + mOLStackIndex == 0) {
michael@0:       mFloatingLines = 1;
michael@0:       mLineBreakDue = true;
michael@0:     }
michael@0:   }  
michael@0:   else if (aTag == nsGkAtoms::dl) {
michael@0:     mFloatingLines = 1;
michael@0:     mLineBreakDue = true;
michael@0:   }
michael@0:   else if (aTag == nsGkAtoms::dd) {
michael@0:     FlushLine();
michael@0:     mIndent -= kIndentSizeDD;
michael@0:   }
michael@0:   else if (aTag == nsGkAtoms::span) {
michael@0:     NS_ASSERTION(mSpanLevel, "Span level will be negative!");
michael@0:     --mSpanLevel;
michael@0:   }
michael@0:   else if (aTag == nsGkAtoms::div) {
michael@0:     if (mFloatingLines < 0)
michael@0:       mFloatingLines = 0;
michael@0:     mLineBreakDue = true;
michael@0:   }
michael@0:   else if (aTag == nsGkAtoms::blockquote) {
michael@0:     FlushLine();    // Is this needed?
michael@0: 
michael@0:     // Pop
michael@0:     bool isInCiteBlockquote = PopBool(mIsInCiteBlockquote);
michael@0: 
michael@0:     if (isInCiteBlockquote) {
michael@0:       NS_ASSERTION(mCiteQuoteLevel, "CiteQuote level will be negative!");
michael@0:       mCiteQuoteLevel--;
michael@0:       mFloatingLines = 0;
michael@0:       mHasWrittenCiteBlockquote = true;
michael@0:     }
michael@0:     else {
michael@0:       mIndent -= kTabSize;
michael@0:       mFloatingLines = 1;
michael@0:     }
michael@0:     mLineBreakDue = true;
michael@0:   }
michael@0:   else if (aTag == nsGkAtoms::q) {
michael@0:     Write(NS_LITERAL_STRING("\""));
michael@0:   }
michael@0:   else if (nsContentUtils::IsHTMLBlock(aTag)
michael@0:            && aTag != nsGkAtoms::script) {
michael@0:     // All other blocks get 1 vertical space after them
michael@0:     // in formatted mode, otherwise 0.
michael@0:     // This is hard. Sometimes 0 is a better number, but
michael@0:     // how to know?
michael@0:     if (mFlags & nsIDocumentEncoder::OutputFormatted)
michael@0:       EnsureVerticalSpace(1);
michael@0:     else {
michael@0:       if (mFloatingLines < 0)
michael@0:         mFloatingLines = 0;
michael@0:       mLineBreakDue = true;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   //////////////////////////////////////////////////////////////
michael@0:   if (!(mFlags & nsIDocumentEncoder::OutputFormatted)) {
michael@0:     return NS_OK;
michael@0:   }
michael@0:   //////////////////////////////////////////////////////////////
michael@0:   // The rest of this routine is formatted output stuff,
michael@0:   // which we should skip if we're not formatted:
michael@0:   //////////////////////////////////////////////////////////////
michael@0: 
michael@0:   // Pop the currentConverted stack
michael@0:   bool currentNodeIsConverted = IsCurrentNodeConverted();
michael@0:   
michael@0:   if (aTag == nsGkAtoms::h1 || aTag == nsGkAtoms::h2 ||
michael@0:       aTag == nsGkAtoms::h3 || aTag == nsGkAtoms::h4 ||
michael@0:       aTag == nsGkAtoms::h5 || aTag == nsGkAtoms::h6) {
michael@0:     
michael@0:     if (mHeaderStrategy) {  /*numbered or indent increasingly*/ 
michael@0:       mIndent -= kIndentSizeHeaders;
michael@0:     }
michael@0:     if (mHeaderStrategy == 1 /*indent increasingly*/ ) {
michael@0:       for (int32_t i = HeaderLevel(aTag); i > 1; i--) {
michael@0:            // for h(x), run x-1 times
michael@0:         mIndent -= kIndentIncrementHeaders;
michael@0:       }
michael@0:     }
michael@0:     EnsureVerticalSpace(1);
michael@0:   }
michael@0:   else if (aTag == nsGkAtoms::a && !currentNodeIsConverted && !mURL.IsEmpty()) {
michael@0:     nsAutoString temp; 
michael@0:     temp.AssignLiteral(" <");
michael@0:     temp += mURL;
michael@0:     temp.Append(char16_t('>'));
michael@0:     Write(temp);
michael@0:     mURL.Truncate();
michael@0:   }
michael@0:   else if ((aTag == nsGkAtoms::sup || aTag == nsGkAtoms::sub)
michael@0:            && mStructs && !currentNodeIsConverted) {
michael@0:     Write(kSpace);
michael@0:   }
michael@0:   else if (aTag == nsGkAtoms::code && mStructs && !currentNodeIsConverted) {
michael@0:     Write(NS_LITERAL_STRING("|"));
michael@0:   }
michael@0:   else if ((aTag == nsGkAtoms::strong || aTag == nsGkAtoms::b)
michael@0:            && mStructs && !currentNodeIsConverted) {
michael@0:     Write(NS_LITERAL_STRING("*"));
michael@0:   }
michael@0:   else if ((aTag == nsGkAtoms::em || aTag == nsGkAtoms::i)
michael@0:            && mStructs && !currentNodeIsConverted) {
michael@0:     Write(NS_LITERAL_STRING("/"));
michael@0:   }
michael@0:   else if (aTag == nsGkAtoms::u && mStructs && !currentNodeIsConverted) {
michael@0:     Write(NS_LITERAL_STRING("_"));
michael@0:   }
michael@0: 
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: bool
michael@0: nsPlainTextSerializer::MustSuppressLeaf()
michael@0: {
michael@0:   if (mIgnoredChildNodeLevel > 0) {
michael@0:     return true;
michael@0:   }
michael@0: 
michael@0:   if ((mTagStackIndex > 1 &&
michael@0:        mTagStack[mTagStackIndex-2] == nsGkAtoms::select) ||
michael@0:       (mTagStackIndex > 0 &&
michael@0:         mTagStack[mTagStackIndex-1] == nsGkAtoms::select)) {
michael@0:     // Don't output the contents of SELECT elements;
michael@0:     // Might be nice, eventually, to output just the selected element.
michael@0:     // Read more in bug 31994.
michael@0:     return true;
michael@0:   }
michael@0: 
michael@0:   if (mTagStackIndex > 0 &&
michael@0:       (mTagStack[mTagStackIndex-1] == nsGkAtoms::script ||
michael@0:        mTagStack[mTagStackIndex-1] == nsGkAtoms::style)) {
michael@0:     // Don't output the contents of <script> or <style> tags;
michael@0:     return true;
michael@0:   }
michael@0: 
michael@0:   return false;
michael@0: }
michael@0: 
michael@0: void
michael@0: nsPlainTextSerializer::DoAddText(bool aIsLineBreak, const nsAString& aText)
michael@0: {
michael@0:   // If we don't want any output, just return
michael@0:   if (!DoOutput()) {
michael@0:     return;
michael@0:   }
michael@0: 
michael@0:   if (!aIsLineBreak) {
michael@0:     // Make sure to reset this, since it's no longer true.
michael@0:     mHasWrittenCiteBlockquote = false;
michael@0:   }
michael@0: 
michael@0:   if (mLineBreakDue)
michael@0:     EnsureVerticalSpace(mFloatingLines);
michael@0: 
michael@0:   if (MustSuppressLeaf()) {
michael@0:     return;
michael@0:   }
michael@0: 
michael@0:   if (aIsLineBreak) {
michael@0:     // The only times we want to pass along whitespace from the original
michael@0:     // html source are if we're forced into preformatted mode via flags,
michael@0:     // or if we're prettyprinting and we're inside a <pre>.
michael@0:     // Otherwise, either we're collapsing to minimal text, or we're
michael@0:     // prettyprinting to mimic the html format, and in neither case
michael@0:     // does the formatting of the html source help us.
michael@0:     if ((mFlags & nsIDocumentEncoder::OutputPreformatted) ||
michael@0:         (mPreFormatted && !mWrapColumn) ||
michael@0:         IsInPre()) {
michael@0:       EnsureVerticalSpace(mEmptyLines+1);
michael@0:     }
michael@0:     else if (!mInWhitespace) {
michael@0:       Write(kSpace);
michael@0:       mInWhitespace = true;
michael@0:     }
michael@0:     return;
michael@0:   }
michael@0: 
michael@0:   /* Check, if we are in a link (symbolized with mURL containing the URL)
michael@0:      and the text is equal to the URL. In that case we don't want to output
michael@0:      the URL twice so we scrap the text in mURL. */
michael@0:   if (!mURL.IsEmpty() && mURL.Equals(aText)) {
michael@0:     mURL.Truncate();
michael@0:   }
michael@0:   Write(aText);
michael@0: }
michael@0: 
michael@0: nsresult
michael@0: nsPlainTextSerializer::DoAddLeaf(nsIAtom* aTag)
michael@0: {
michael@0:   // If we don't want any output, just return
michael@0:   if (!DoOutput()) {
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   if (mLineBreakDue)
michael@0:     EnsureVerticalSpace(mFloatingLines);
michael@0: 
michael@0:   if (MustSuppressLeaf()) {
michael@0:     return NS_OK;
michael@0:   }
michael@0: 
michael@0:   if (aTag == nsGkAtoms::br) {
michael@0:     // Another egregious editor workaround, see bug 38194:
michael@0:     // ignore the bogus br tags that the editor sticks here and there.
michael@0:     nsAutoString tagAttr;
michael@0:     if (NS_FAILED(GetAttributeValue(nsGkAtoms::type, tagAttr))
michael@0:         || !tagAttr.EqualsLiteral("_moz")) {
michael@0:       EnsureVerticalSpace(mEmptyLines+1);
michael@0:     }
michael@0:   }
michael@0:   else if (aTag == nsGkAtoms::hr &&
michael@0:            (mFlags & nsIDocumentEncoder::OutputFormatted)) {
michael@0:     EnsureVerticalSpace(0);
michael@0: 
michael@0:     // Make a line of dashes as wide as the wrap width
michael@0:     // XXX honoring percentage would be nice
michael@0:     nsAutoString line;
michael@0:     uint32_t width = (mWrapColumn > 0 ? mWrapColumn : 25);
michael@0:     while (line.Length() < width) {
michael@0:       line.Append(char16_t('-'));
michael@0:     }
michael@0:     Write(line);
michael@0: 
michael@0:     EnsureVerticalSpace(0);
michael@0:   }
michael@0:   else if (mFlags & nsIDocumentEncoder::OutputNonTextContentAsPlaceholder) {
michael@0:     Write(NS_LITERAL_STRING("\xFFFC"));
michael@0:   }
michael@0:   else if (aTag == nsGkAtoms::img) {
michael@0:     /* Output (in decreasing order of preference)
michael@0:        alt, title or nothing */
michael@0:     // See <http://www.w3.org/TR/REC-html40/struct/objects.html#edef-IMG>
michael@0:     nsAutoString imageDescription;
michael@0:     if (NS_SUCCEEDED(GetAttributeValue(nsGkAtoms::alt,
michael@0:                                        imageDescription))) {
michael@0:       // If the alt attribute has an empty value (|alt=""|), output nothing
michael@0:     }
michael@0:     else if (NS_SUCCEEDED(GetAttributeValue(nsGkAtoms::title,
michael@0:                                             imageDescription))
michael@0:              && !imageDescription.IsEmpty()) {
michael@0:       imageDescription = NS_LITERAL_STRING(" [") +
michael@0:                          imageDescription +
michael@0:                          NS_LITERAL_STRING("] ");
michael@0:     }
michael@0:    
michael@0:     Write(imageDescription);
michael@0:   }
michael@0: 
michael@0:   return NS_OK;
michael@0: }
michael@0: 
michael@0: /**
michael@0:  * Adds as many newline as necessary to get |noOfRows| empty lines
michael@0:  *
michael@0:  * noOfRows = -1    :   Being in the middle of some line of text
michael@0:  * noOfRows =  0    :   Being at the start of a line
michael@0:  * noOfRows =  n>0  :   Having n empty lines before the current line.
michael@0:  */
michael@0: void
michael@0: nsPlainTextSerializer::EnsureVerticalSpace(int32_t noOfRows)
michael@0: {
michael@0:   // If we have something in the indent we probably want to output
michael@0:   // it and it's not included in the count for empty lines so we don't
michael@0:   // realize that we should start a new line.
michael@0:   if (noOfRows >= 0 && !mInIndentString.IsEmpty()) {
michael@0:     EndLine(false);
michael@0:     mInWhitespace = true;
michael@0:   }
michael@0: 
michael@0:   while(mEmptyLines < noOfRows) {
michael@0:     EndLine(false);
michael@0:     mInWhitespace = true;
michael@0:   }
michael@0:   mLineBreakDue = false;
michael@0:   mFloatingLines = -1;
michael@0: }
michael@0: 
michael@0: /**
michael@0:  * This empties the current line cache without adding a NEWLINE.
michael@0:  * Should not be used if line wrapping is of importance since
michael@0:  * this function destroys the cache information.
michael@0:  *
michael@0:  * It will also write indentation and quotes if we believe us to be
michael@0:  * at the start of the line.
michael@0:  */
michael@0: void
michael@0: nsPlainTextSerializer::FlushLine()
michael@0: {
michael@0:   if (!mCurrentLine.IsEmpty()) {
michael@0:     if (mAtFirstColumn) {
michael@0:       OutputQuotesAndIndent(); // XXX: Should we always do this? Bug?
michael@0:     }
michael@0: 
michael@0:     Output(mCurrentLine);
michael@0:     mAtFirstColumn = mAtFirstColumn && mCurrentLine.IsEmpty();
michael@0:     mCurrentLine.Truncate();
michael@0:     mCurrentLineWidth = 0;
michael@0:   }
michael@0: }
michael@0: 
michael@0: /**
michael@0:  * Prints the text to output to our current output device (the string mOutputString).
michael@0:  * The only logic here is to replace non breaking spaces with a normal space since
michael@0:  * most (all?) receivers of the result won't understand the nbsp and even be
michael@0:  * confused by it.
michael@0:  */
michael@0: void 
michael@0: nsPlainTextSerializer::Output(nsString& aString)
michael@0: {
michael@0:   if (!aString.IsEmpty()) {
michael@0:     mStartedOutput = true;
michael@0:   }
michael@0: 
michael@0:   if (!(mFlags & nsIDocumentEncoder::OutputPersistNBSP)) {
michael@0:     // First, replace all nbsp characters with spaces,
michael@0:     // which the unicode encoder won't do for us.
michael@0:     aString.ReplaceChar(kNBSP, kSPACE);
michael@0:   }
michael@0:   mOutputString->Append(aString);
michael@0: }
michael@0: 
michael@0: static bool
michael@0: IsSpaceStuffable(const char16_t *s)
michael@0: {
michael@0:   if (s[0] == '>' || s[0] == ' ' || s[0] == kNBSP ||
michael@0:       nsCRT::strncmp(s, MOZ_UTF16("From "), 5) == 0)
michael@0:     return true;
michael@0:   else
michael@0:     return false;
michael@0: }
michael@0: 
michael@0: /**
michael@0:  * This function adds a piece of text to the current stored line. If we are
michael@0:  * wrapping text and the stored line will become too long, a suitable
michael@0:  * location to wrap will be found and the line that's complete will be
michael@0:  * output.
michael@0:  */
michael@0: void
michael@0: nsPlainTextSerializer::AddToLine(const char16_t * aLineFragment, 
michael@0:                                  int32_t aLineFragmentLength)
michael@0: {
michael@0:   uint32_t prefixwidth = (mCiteQuoteLevel > 0 ? mCiteQuoteLevel + 1:0)+mIndent;
michael@0:   
michael@0:   if (mLineBreakDue)
michael@0:     EnsureVerticalSpace(mFloatingLines);
michael@0: 
michael@0:   int32_t linelength = mCurrentLine.Length();
michael@0:   if (0 == linelength) {
michael@0:     if (0 == aLineFragmentLength) {
michael@0:       // Nothing at all. Are you kidding me?
michael@0:       return;
michael@0:     }
michael@0: 
michael@0:     if (mFlags & nsIDocumentEncoder::OutputFormatFlowed) {
michael@0:       if (IsSpaceStuffable(aLineFragment)
michael@0:          && mCiteQuoteLevel == 0  // We space-stuff quoted lines anyway
michael@0:          )
michael@0:         {
michael@0:           // Space stuffing a la RFC 2646 (format=flowed).
michael@0:           mCurrentLine.Append(char16_t(' '));
michael@0:           
michael@0:           if (MayWrap()) {
michael@0:             mCurrentLineWidth += GetUnicharWidth(' ');
michael@0: #ifdef DEBUG_wrapping
michael@0:             NS_ASSERTION(GetUnicharStringWidth(mCurrentLine.get(),
michael@0:                                                mCurrentLine.Length()) ==
michael@0:                          (int32_t)mCurrentLineWidth,
michael@0:                          "mCurrentLineWidth and reality out of sync!");
michael@0: #endif
michael@0:           }
michael@0:         }
michael@0:     }
michael@0:     mEmptyLines=-1;
michael@0:   }
michael@0:     
michael@0:   mCurrentLine.Append(aLineFragment, aLineFragmentLength);
michael@0:   if (MayWrap()) {
michael@0:     mCurrentLineWidth += GetUnicharStringWidth(aLineFragment,
michael@0:                                                aLineFragmentLength);
michael@0: #ifdef DEBUG_wrapping
michael@0:     NS_ASSERTION(GetUnicharstringWidth(mCurrentLine.get(),
michael@0:                                        mCurrentLine.Length()) ==
michael@0:                  (int32_t)mCurrentLineWidth,
michael@0:                  "mCurrentLineWidth and reality out of sync!");
michael@0: #endif
michael@0:   }
michael@0: 
michael@0:   linelength = mCurrentLine.Length();
michael@0: 
michael@0:   //  Wrap?
michael@0:   if (MayWrap())
michael@0:   {
michael@0: #ifdef DEBUG_wrapping
michael@0:     NS_ASSERTION(GetUnicharstringWidth(mCurrentLine.get(),
michael@0:                                   mCurrentLine.Length()) ==
michael@0:                  (int32_t)mCurrentLineWidth,
michael@0:                  "mCurrentLineWidth and reality out of sync!");
michael@0: #endif
michael@0:     // Yes, wrap!
michael@0:     // The "+4" is to avoid wrap lines that only would be a couple
michael@0:     // of letters too long. We give this bonus only if the
michael@0:     // wrapcolumn is more than 20.
michael@0:     uint32_t bonuswidth = (mWrapColumn > 20) ? 4 : 0;
michael@0: 
michael@0:     // XXX: Should calculate prefixwidth with GetUnicharStringWidth
michael@0:     while(mCurrentLineWidth+prefixwidth > mWrapColumn+bonuswidth) {      
michael@0:       // We go from the end removing one letter at a time until
michael@0:       // we have a reasonable width
michael@0:       int32_t goodSpace = mCurrentLine.Length();
michael@0:       uint32_t width = mCurrentLineWidth;
michael@0:       while(goodSpace > 0 && (width+prefixwidth > mWrapColumn)) {
michael@0:         goodSpace--;
michael@0:         width -= GetUnicharWidth(mCurrentLine[goodSpace]);
michael@0:       }
michael@0: 
michael@0:       goodSpace++;
michael@0:       
michael@0:       if (mLineBreaker) {
michael@0:         goodSpace = mLineBreaker->Prev(mCurrentLine.get(), 
michael@0:                                     mCurrentLine.Length(), goodSpace);
michael@0:         if (goodSpace != NS_LINEBREAKER_NEED_MORE_TEXT &&
michael@0:             nsCRT::IsAsciiSpace(mCurrentLine.CharAt(goodSpace-1))) {
michael@0:           --goodSpace;    // adjust the position since line breaker returns a position next to space
michael@0:         }
michael@0:       }
michael@0:       // fallback if the line breaker is unavailable or failed
michael@0:       if (!mLineBreaker) {
michael@0:         goodSpace = mWrapColumn-prefixwidth;
michael@0:         while (goodSpace >= 0 &&
michael@0:                !nsCRT::IsAsciiSpace(mCurrentLine.CharAt(goodSpace))) {
michael@0:           goodSpace--;
michael@0:         }
michael@0:       }
michael@0:       
michael@0:       nsAutoString restOfLine;
michael@0:       if (goodSpace == NS_LINEBREAKER_NEED_MORE_TEXT) {
michael@0:         // If we don't found a good place to break, accept long line and
michael@0:         // try to find another place to break
michael@0:         goodSpace=(prefixwidth>mWrapColumn+1)?1:mWrapColumn-prefixwidth+1;
michael@0:         if (mLineBreaker) {
michael@0:           if ((uint32_t)goodSpace < mCurrentLine.Length())
michael@0:             goodSpace = mLineBreaker->Next(mCurrentLine.get(), 
michael@0:                                            mCurrentLine.Length(), goodSpace);
michael@0:           if (goodSpace == NS_LINEBREAKER_NEED_MORE_TEXT)
michael@0:             goodSpace = mCurrentLine.Length();
michael@0:         }
michael@0:         // fallback if the line breaker is unavailable or failed
michael@0:         if (!mLineBreaker) {
michael@0:           goodSpace=(prefixwidth>mWrapColumn)?1:mWrapColumn-prefixwidth;
michael@0:           while (goodSpace < linelength &&
michael@0:                  !nsCRT::IsAsciiSpace(mCurrentLine.CharAt(goodSpace))) {
michael@0:             goodSpace++;
michael@0:           }
michael@0:         }
michael@0:       }
michael@0:       
michael@0:       if ((goodSpace < linelength) && (goodSpace > 0)) {
michael@0:         // Found a place to break
michael@0: 
michael@0:         // -1 (trim a char at the break position)
michael@0:         // only if the line break was a space.
michael@0:         if (nsCRT::IsAsciiSpace(mCurrentLine.CharAt(goodSpace))) {
michael@0:           mCurrentLine.Right(restOfLine, linelength-goodSpace-1);
michael@0:         }
michael@0:         else {
michael@0:           mCurrentLine.Right(restOfLine, linelength-goodSpace);
michael@0:         }
michael@0:         // if breaker was U+0020, it has to consider for delsp=yes support
michael@0:         bool breakBySpace = mCurrentLine.CharAt(goodSpace) == ' ';
michael@0:         mCurrentLine.Truncate(goodSpace); 
michael@0:         EndLine(true, breakBySpace);
michael@0:         mCurrentLine.Truncate();
michael@0:         // Space stuff new line?
michael@0:         if (mFlags & nsIDocumentEncoder::OutputFormatFlowed) {
michael@0:           if (!restOfLine.IsEmpty() && IsSpaceStuffable(restOfLine.get())
michael@0:               && mCiteQuoteLevel == 0  // We space-stuff quoted lines anyway
michael@0:             )
michael@0:           {
michael@0:             // Space stuffing a la RFC 2646 (format=flowed).
michael@0:             mCurrentLine.Append(char16_t(' '));
michael@0:             //XXX doesn't seem to work correctly for ' '
michael@0:           }
michael@0:         }
michael@0:         mCurrentLine.Append(restOfLine);
michael@0:         mCurrentLineWidth = GetUnicharStringWidth(mCurrentLine.get(),
michael@0:                                                   mCurrentLine.Length());
michael@0:         linelength = mCurrentLine.Length();
michael@0:         mEmptyLines = -1;
michael@0:       } 
michael@0:       else {
michael@0:         // Nothing to do. Hopefully we get more data later
michael@0:         // to use for a place to break line
michael@0:         break;
michael@0:       }
michael@0:     }
michael@0:   } 
michael@0:   else {
michael@0:     // No wrapping.
michael@0:   }
michael@0: }
michael@0: 
michael@0: /**
michael@0:  * Outputs the contents of mCurrentLine, and resets line specific
michael@0:  * variables. Also adds an indentation and prefix if there is
michael@0:  * one specified. Strips ending spaces from the line if it isn't
michael@0:  * preformatted.
michael@0:  */
michael@0: void
michael@0: nsPlainTextSerializer::EndLine(bool aSoftlinebreak, bool aBreakBySpace)
michael@0: {
michael@0:   uint32_t currentlinelength = mCurrentLine.Length();
michael@0: 
michael@0:   if (aSoftlinebreak && 0 == currentlinelength) {
michael@0:     // No meaning
michael@0:     return;
michael@0:   }
michael@0: 
michael@0:   /* In non-preformatted mode, remove spaces from the end of the line for
michael@0:    * format=flowed compatibility. Don't do this for these special cases:
michael@0:    * "-- ", the signature separator (RFC 2646) shouldn't be touched and
michael@0:    * "- -- ", the OpenPGP dash-escaped signature separator in inline
michael@0:    * signed messages according to the OpenPGP standard (RFC 2440).
michael@0:    */  
michael@0:   if (!(mFlags & nsIDocumentEncoder::OutputPreformatted) &&
michael@0:       !(mFlags & nsIDocumentEncoder::OutputDontRemoveLineEndingSpaces) &&
michael@0:      (aSoftlinebreak || 
michael@0:      !(mCurrentLine.EqualsLiteral("-- ") || mCurrentLine.EqualsLiteral("- -- ")))) {
michael@0:     // Remove spaces from the end of the line.
michael@0:     while(currentlinelength > 0 &&
michael@0:           mCurrentLine[currentlinelength-1] == ' ') {
michael@0:       --currentlinelength;
michael@0:     }
michael@0:     mCurrentLine.SetLength(currentlinelength);
michael@0:   }
michael@0:   
michael@0:   if (aSoftlinebreak &&
michael@0:      (mFlags & nsIDocumentEncoder::OutputFormatFlowed) &&
michael@0:      (mIndent == 0)) {
michael@0:     // Add the soft part of the soft linebreak (RFC 2646 4.1)
michael@0:     // We only do this when there is no indentation since format=flowed
michael@0:     // lines and indentation doesn't work well together.
michael@0: 
michael@0:     // If breaker character is ASCII space with RFC 3676 support (delsp=yes),
michael@0:     // add twice space.
michael@0:     if ((mFlags & nsIDocumentEncoder::OutputFormatDelSp) && aBreakBySpace)
michael@0:       mCurrentLine.Append(NS_LITERAL_STRING("  "));
michael@0:     else
michael@0:       mCurrentLine.Append(char16_t(' '));
michael@0:   }
michael@0: 
michael@0:   if (aSoftlinebreak) {
michael@0:     mEmptyLines=0;
michael@0:   } 
michael@0:   else {
michael@0:     // Hard break
michael@0:     if (!mCurrentLine.IsEmpty() || !mInIndentString.IsEmpty()) {
michael@0:       mEmptyLines=-1;
michael@0:     }
michael@0: 
michael@0:     mEmptyLines++;
michael@0:   }
michael@0: 
michael@0:   if (mAtFirstColumn) {
michael@0:     // If we don't have anything "real" to output we have to
michael@0:     // make sure the indent doesn't end in a space since that
michael@0:     // would trick a format=flowed-aware receiver.
michael@0:     bool stripTrailingSpaces = mCurrentLine.IsEmpty();
michael@0:     OutputQuotesAndIndent(stripTrailingSpaces);
michael@0:   }
michael@0: 
michael@0:   mCurrentLine.Append(mLineBreak);
michael@0:   Output(mCurrentLine);
michael@0:   mCurrentLine.Truncate();
michael@0:   mCurrentLineWidth = 0;
michael@0:   mAtFirstColumn=true;
michael@0:   mInWhitespace=true;
michael@0:   mLineBreakDue = false;
michael@0:   mFloatingLines = -1;
michael@0: }
michael@0: 
michael@0: 
michael@0: /**
michael@0:  * Outputs the calculated and stored indent and text in the indentation. That is
michael@0:  * quote chars and numbers for numbered lists and such. It will also reset any
michael@0:  * stored text to put in the indentation after using it.
michael@0:  */
michael@0: void
michael@0: nsPlainTextSerializer::OutputQuotesAndIndent(bool stripTrailingSpaces /* = false */)
michael@0: {
michael@0:   nsAutoString stringToOutput;
michael@0:   
michael@0:   // Put the mail quote "> " chars in, if appropriate:
michael@0:   if (mCiteQuoteLevel > 0) {
michael@0:     nsAutoString quotes;
michael@0:     for(int i=0; i < mCiteQuoteLevel; i++) {
michael@0:       quotes.Append(char16_t('>'));
michael@0:     }
michael@0:     if (!mCurrentLine.IsEmpty()) {
michael@0:       /* Better don't output a space here, if the line is empty,
michael@0:          in case a receiving f=f-aware UA thinks, this were a flowed line,
michael@0:          which it isn't - it's just empty.
michael@0:          (Flowed lines may be joined with the following one,
michael@0:          so the empty line may be lost completely.) */
michael@0:       quotes.Append(char16_t(' '));
michael@0:     }
michael@0:     stringToOutput = quotes;
michael@0:     mAtFirstColumn = false;
michael@0:   }
michael@0:   
michael@0:   // Indent if necessary
michael@0:   int32_t indentwidth = mIndent - mInIndentString.Length();
michael@0:   if (indentwidth > 0
michael@0:       && (!mCurrentLine.IsEmpty() || !mInIndentString.IsEmpty())
michael@0:       // Don't make empty lines look flowed
michael@0:       ) {
michael@0:     nsAutoString spaces;
michael@0:     for (int i=0; i < indentwidth; ++i)
michael@0:       spaces.Append(char16_t(' '));
michael@0:     stringToOutput += spaces;
michael@0:     mAtFirstColumn = false;
michael@0:   }
michael@0:   
michael@0:   if (!mInIndentString.IsEmpty()) {
michael@0:     stringToOutput += mInIndentString;
michael@0:     mAtFirstColumn = false;
michael@0:     mInIndentString.Truncate();
michael@0:   }
michael@0: 
michael@0:   if (stripTrailingSpaces) {
michael@0:     int32_t lineLength = stringToOutput.Length();
michael@0:     while(lineLength > 0 &&
michael@0:           ' ' == stringToOutput[lineLength-1]) {
michael@0:       --lineLength;
michael@0:     }
michael@0:     stringToOutput.SetLength(lineLength);
michael@0:   }
michael@0: 
michael@0:   if (!stringToOutput.IsEmpty()) {
michael@0:     Output(stringToOutput);
michael@0:   }
michael@0:     
michael@0: }
michael@0: 
michael@0: /**
michael@0:  * Write a string. This is the highlevel function to use to get text output.
michael@0:  * By using AddToLine, Output, EndLine and other functions it handles quotation,
michael@0:  * line wrapping, indentation, whitespace compression and other things.
michael@0:  */
michael@0: void
michael@0: nsPlainTextSerializer::Write(const nsAString& aStr)
michael@0: {
michael@0:   // XXX Copy necessary to use nsString methods and gain
michael@0:   // access to underlying buffer
michael@0:   nsAutoString str(aStr);
michael@0: 
michael@0: #ifdef DEBUG_wrapping
michael@0:   printf("Write(%s): wrap col = %d\n",
michael@0:          NS_ConvertUTF16toUTF8(str).get(), mWrapColumn);
michael@0: #endif
michael@0: 
michael@0:   int32_t bol = 0;
michael@0:   int32_t newline;
michael@0:   
michael@0:   int32_t totLen = str.Length();
michael@0: 
michael@0:   // If the string is empty, do nothing:
michael@0:   if (totLen <= 0) return;
michael@0: 
michael@0:   // For Flowed text change nbsp-ses to spaces at end of lines to allow them
michael@0:   // to be cut off along with usual spaces if required. (bug #125928)
michael@0:   if (mFlags & nsIDocumentEncoder::OutputFormatFlowed) {
michael@0:     for (int32_t i = totLen-1; i >= 0; i--) {
michael@0:       char16_t c = str[i];
michael@0:       if ('\n' == c || '\r' == c || ' ' == c || '\t' == c)
michael@0:         continue;
michael@0:       if (kNBSP == c)
michael@0:         str.Replace(i, 1, ' ');
michael@0:       else
michael@0:         break;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   // We have two major codepaths here. One that does preformatted text and one
michael@0:   // that does normal formatted text. The one for preformatted text calls
michael@0:   // Output directly while the other code path goes through AddToLine.
michael@0:   if ((mPreFormatted && !mWrapColumn) || IsInPre()
michael@0:       || ((mSpanLevel > 0 || mDontWrapAnyQuotes)
michael@0:           && mEmptyLines >= 0 && str.First() == char16_t('>'))) {
michael@0:     // No intelligent wrapping.
michael@0: 
michael@0:     // This mustn't be mixed with intelligent wrapping without clearing
michael@0:     // the mCurrentLine buffer before!!!
michael@0:     NS_ASSERTION(mCurrentLine.IsEmpty(),
michael@0:                  "Mixed wrapping data and nonwrapping data on the same line");
michael@0:     if (!mCurrentLine.IsEmpty()) {
michael@0:       FlushLine();
michael@0:     }
michael@0: 
michael@0:     // Put the mail quote "> " chars in, if appropriate.
michael@0:     // Have to put it in before every line.
michael@0:     while(bol<totLen) {
michael@0:       bool outputQuotes = mAtFirstColumn;
michael@0:       bool atFirstColumn = mAtFirstColumn;
michael@0:       bool outputLineBreak = false;
michael@0:       bool spacesOnly = true;
michael@0: 
michael@0:       // Find one of '\n' or '\r' using iterators since nsAString
michael@0:       // doesn't have the old FindCharInSet function.
michael@0:       nsAString::const_iterator iter;           str.BeginReading(iter);
michael@0:       nsAString::const_iterator done_searching; str.EndReading(done_searching);
michael@0:       iter.advance(bol); 
michael@0:       int32_t new_newline = bol;
michael@0:       newline = kNotFound;
michael@0:       while(iter != done_searching) {
michael@0:         if ('\n' == *iter || '\r' == *iter) {
michael@0:           newline = new_newline;
michael@0:           break;
michael@0:         }
michael@0:         if (' ' != *iter)
michael@0:           spacesOnly = false;
michael@0:         ++new_newline;
michael@0:         ++iter;
michael@0:       }
michael@0: 
michael@0:       // Done searching
michael@0:       nsAutoString stringpart;
michael@0:       if (newline == kNotFound) {
michael@0:         // No new lines.
michael@0:         stringpart.Assign(Substring(str, bol, totLen - bol));
michael@0:         if (!stringpart.IsEmpty()) {
michael@0:           char16_t lastchar = stringpart[stringpart.Length()-1];
michael@0:           if ((lastchar == '\t') || (lastchar == ' ') ||
michael@0:              (lastchar == '\r') ||(lastchar == '\n')) {
michael@0:             mInWhitespace = true;
michael@0:           } 
michael@0:           else {
michael@0:             mInWhitespace = false;
michael@0:           }
michael@0:         }
michael@0:         mEmptyLines=-1;
michael@0:         atFirstColumn = mAtFirstColumn && (totLen-bol)==0;
michael@0:         bol = totLen;
michael@0:       } 
michael@0:       else {
michael@0:         // There is a newline
michael@0:         stringpart.Assign(Substring(str, bol, newline-bol));
michael@0:         mInWhitespace = true;
michael@0:         outputLineBreak = true;
michael@0:         mEmptyLines=0;
michael@0:         atFirstColumn = true;
michael@0:         bol = newline+1;
michael@0:         if ('\r' == *iter && bol < totLen && '\n' == *++iter) {
michael@0:           // There was a CRLF in the input. This used to be illegal and
michael@0:           // stripped by the parser. Apparently not anymore. Let's skip
michael@0:           // over the LF.
michael@0:           bol++;
michael@0:         }
michael@0:       }
michael@0: 
michael@0:       mCurrentLine.AssignLiteral("");
michael@0:       if (mFlags & nsIDocumentEncoder::OutputFormatFlowed) {
michael@0:         if ((outputLineBreak || !spacesOnly) && // bugs 261467,125928
michael@0:             !stringpart.EqualsLiteral("-- ") &&
michael@0:             !stringpart.EqualsLiteral("- -- "))
michael@0:           stringpart.Trim(" ", false, true, true);
michael@0:         if (IsSpaceStuffable(stringpart.get()) && stringpart[0] != '>')
michael@0:           mCurrentLine.Append(char16_t(' '));
michael@0:       }
michael@0:       mCurrentLine.Append(stringpart);
michael@0: 
michael@0:       if (outputQuotes) {
michael@0:         // Note: this call messes with mAtFirstColumn
michael@0:         OutputQuotesAndIndent();
michael@0:       }
michael@0: 
michael@0:       Output(mCurrentLine);
michael@0:       if (outputLineBreak) {
michael@0:         Output(mLineBreak);
michael@0:       }
michael@0:       mAtFirstColumn = atFirstColumn;
michael@0:     }
michael@0: 
michael@0:     // Reset mCurrentLine.
michael@0:     mCurrentLine.Truncate();
michael@0: 
michael@0: #ifdef DEBUG_wrapping
michael@0:     printf("No wrapping: newline is %d, totLen is %d\n",
michael@0:            newline, totLen);
michael@0: #endif
michael@0:     return;
michael@0:   }
michael@0: 
michael@0:   // Intelligent handling of text
michael@0:   // If needed, strip out all "end of lines"
michael@0:   // and multiple whitespace between words
michael@0:   int32_t nextpos;
michael@0:   const char16_t * offsetIntoBuffer = nullptr;
michael@0:   
michael@0:   while (bol < totLen) {    // Loop over lines
michael@0:     // Find a place where we may have to do whitespace compression
michael@0:     nextpos = str.FindCharInSet(" \t\n\r", bol);
michael@0: #ifdef DEBUG_wrapping
michael@0:     nsAutoString remaining;
michael@0:     str.Right(remaining, totLen - bol);
michael@0:     foo = ToNewCString(remaining);
michael@0:     //    printf("Next line: bol = %d, newlinepos = %d, totLen = %d, string = '%s'\n",
michael@0:     //           bol, nextpos, totLen, foo);
michael@0:     nsMemory::Free(foo);
michael@0: #endif
michael@0: 
michael@0:     if (nextpos == kNotFound) {
michael@0:       // The rest of the string
michael@0:       offsetIntoBuffer = str.get() + bol;
michael@0:       AddToLine(offsetIntoBuffer, totLen-bol);
michael@0:       bol=totLen;
michael@0:       mInWhitespace=false;
michael@0:     } 
michael@0:     else {
michael@0:       // There's still whitespace left in the string
michael@0:       if (nextpos != 0 && (nextpos + 1) < totLen) {
michael@0:         offsetIntoBuffer = str.get() + nextpos;
michael@0:         // skip '\n' if it is between CJ chars
michael@0:         if (offsetIntoBuffer[0] == '\n' && IS_CJ_CHAR(offsetIntoBuffer[-1]) && IS_CJ_CHAR(offsetIntoBuffer[1])) {
michael@0:           offsetIntoBuffer = str.get() + bol;
michael@0:           AddToLine(offsetIntoBuffer, nextpos-bol);
michael@0:           bol = nextpos + 1;
michael@0:           continue;
michael@0:         }
michael@0:       }
michael@0:       // If we're already in whitespace and not preformatted, just skip it:
michael@0:       if (mInWhitespace && (nextpos == bol) && !mPreFormatted &&
michael@0:           !(mFlags & nsIDocumentEncoder::OutputPreformatted)) {
michael@0:         // Skip whitespace
michael@0:         bol++;
michael@0:         continue;
michael@0:       }
michael@0: 
michael@0:       if (nextpos == bol) {
michael@0:         // Note that we are in whitespace.
michael@0:         mInWhitespace = true;
michael@0:         offsetIntoBuffer = str.get() + nextpos;
michael@0:         AddToLine(offsetIntoBuffer, 1);
michael@0:         bol++;
michael@0:         continue;
michael@0:       }
michael@0:       
michael@0:       mInWhitespace = true;
michael@0:       
michael@0:       offsetIntoBuffer = str.get() + bol;
michael@0:       if (mPreFormatted || (mFlags & nsIDocumentEncoder::OutputPreformatted)) {
michael@0:         // Preserve the real whitespace character
michael@0:         nextpos++;
michael@0:         AddToLine(offsetIntoBuffer, nextpos-bol);
michael@0:         bol = nextpos;
michael@0:       } 
michael@0:       else {
michael@0:         // Replace the whitespace with a space
michael@0:         AddToLine(offsetIntoBuffer, nextpos-bol);
michael@0:         AddToLine(kSpace.get(),1);
michael@0:         bol = nextpos + 1; // Let's eat the whitespace
michael@0:       }
michael@0:     }
michael@0:   } // Continue looping over the string
michael@0: }
michael@0: 
michael@0: 
michael@0: /**
michael@0:  * Gets the value of an attribute in a string. If the function returns
michael@0:  * NS_ERROR_NOT_AVAILABLE, there was none such attribute specified.
michael@0:  */
michael@0: nsresult
michael@0: nsPlainTextSerializer::GetAttributeValue(nsIAtom* aName,
michael@0:                                          nsString& aValueRet)
michael@0: {
michael@0:   if (mElement) {
michael@0:     if (mElement->GetAttr(kNameSpaceID_None, aName, aValueRet)) {
michael@0:       return NS_OK;
michael@0:     }
michael@0:   }
michael@0: 
michael@0:   return NS_ERROR_NOT_AVAILABLE;
michael@0: }
michael@0: 
michael@0: /**
michael@0:  * Returns true, if the element was inserted by Moz' TXT->HTML converter.
michael@0:  * In this case, we should ignore it.
michael@0:  */
michael@0: bool 
michael@0: nsPlainTextSerializer::IsCurrentNodeConverted()
michael@0: {
michael@0:   nsAutoString value;
michael@0:   nsresult rv = GetAttributeValue(nsGkAtoms::_class, value);
michael@0:   return (NS_SUCCEEDED(rv) &&
michael@0:           (value.EqualsIgnoreCase("moz-txt", 7) ||
michael@0:            value.EqualsIgnoreCase("\"moz-txt", 8)));
michael@0: }
michael@0: 
michael@0: 
michael@0: // static
michael@0: nsIAtom*
michael@0: nsPlainTextSerializer::GetIdForContent(nsIContent* aContent)
michael@0: {
michael@0:   if (!aContent->IsHTML()) {
michael@0:     return nullptr;
michael@0:   }
michael@0: 
michael@0:   nsIAtom* localName = aContent->Tag();
michael@0:   return localName->IsStaticAtom() ? localName : nullptr;
michael@0: }
michael@0: 
michael@0: /**
michael@0:  * Returns true if we currently are inside a <pre>. The check is done
michael@0:  * by traversing the tag stack looking for <pre> until we hit a block
michael@0:  * level tag which is assumed to override any <pre>:s below it in
michael@0:  * the stack. To do this correctly to a 100% would require access
michael@0:  * to style which we don't support in this converter.
michael@0:  */  
michael@0: bool
michael@0: nsPlainTextSerializer::IsInPre()
michael@0: {
michael@0:   int32_t i = mTagStackIndex;
michael@0:   while(i > 0) {
michael@0:     if (mTagStack[i - 1] == nsGkAtoms::pre)
michael@0:       return true;
michael@0:     if (nsContentUtils::IsHTMLBlock(mTagStack[i - 1])) {
michael@0:       // We assume that every other block overrides a <pre>
michael@0:       return false;
michael@0:     }
michael@0:     --i;
michael@0:   }
michael@0: 
michael@0:   // Not a <pre> in the whole stack
michael@0:   return false;
michael@0: }
michael@0: 
michael@0: /**
michael@0:  * This method is required only to identify LI's inside OL.
michael@0:  * Returns TRUE if we are inside an OL tag and FALSE otherwise.
michael@0:  */
michael@0: bool
michael@0: nsPlainTextSerializer::IsInOL()
michael@0: {
michael@0:   int32_t i = mTagStackIndex;
michael@0:   while(--i >= 0) {
michael@0:     if (mTagStack[i] == nsGkAtoms::ol)
michael@0:       return true;
michael@0:     if (mTagStack[i] == nsGkAtoms::ul) {
michael@0:       // If a UL is reached first, LI belongs the UL nested in OL.
michael@0:       return false;
michael@0:     }
michael@0:   }
michael@0:   // We may reach here for orphan LI's.
michael@0:   return false;
michael@0: }
michael@0: 
michael@0: /*
michael@0:   @return 0 = no header, 1 = h1, ..., 6 = h6
michael@0: */
michael@0: int32_t HeaderLevel(nsIAtom* aTag)
michael@0: {
michael@0:   if (aTag == nsGkAtoms::h1) {
michael@0:     return 1;
michael@0:   }
michael@0:   if (aTag == nsGkAtoms::h2) {
michael@0:     return 2;
michael@0:   }
michael@0:   if (aTag == nsGkAtoms::h3) {
michael@0:     return 3;
michael@0:   }
michael@0:   if (aTag == nsGkAtoms::h4) {
michael@0:     return 4;
michael@0:   }
michael@0:   if (aTag == nsGkAtoms::h5) {
michael@0:     return 5;
michael@0:   }
michael@0:   if (aTag == nsGkAtoms::h6) {
michael@0:     return 6;
michael@0:   }
michael@0:   return 0;
michael@0: }
michael@0: 
michael@0: 
michael@0: /*
michael@0:  * This is an implementation of GetUnicharWidth() and
michael@0:  * GetUnicharStringWidth() as defined in
michael@0:  * "The Single UNIX Specification, Version 2, The Open Group, 1997"
michael@0:  * <http://www.UNIX-systems.org/online.html>
michael@0:  *
michael@0:  * Markus Kuhn -- 2000-02-08 -- public domain
michael@0:  *
michael@0:  * Minor alterations to fit Mozilla's data types by Daniel Bratell
michael@0:  */
michael@0: 
michael@0: /* These functions define the column width of an ISO 10646 character
michael@0:  * as follows:
michael@0:  *
michael@0:  *    - The null character (U+0000) has a column width of 0.
michael@0:  *
michael@0:  *    - Other C0/C1 control characters and DEL will lead to a return
michael@0:  *      value of -1.
michael@0:  *
michael@0:  *    - Non-spacing and enclosing combining characters (general
michael@0:  *      category code Mn or Me in the Unicode database) have a
michael@0:  *      column width of 0.
michael@0:  *
michael@0:  *    - Spacing characters in the East Asian Wide (W) or East Asian
michael@0:  *      FullWidth (F) category as defined in Unicode Technical
michael@0:  *      Report #11 have a column width of 2.
michael@0:  *
michael@0:  *    - All remaining characters (including all printable
michael@0:  *      ISO 8859-1 and WGL4 characters, Unicode control characters,
michael@0:  *      etc.) have a column width of 1.
michael@0:  *
michael@0:  * This implementation assumes that wchar_t characters are encoded
michael@0:  * in ISO 10646.
michael@0:  */
michael@0: 
michael@0: int32_t GetUnicharWidth(char16_t ucs)
michael@0: {
michael@0:   /* sorted list of non-overlapping intervals of non-spacing characters */
michael@0:   static const struct interval {
michael@0:     uint16_t first;
michael@0:     uint16_t last;
michael@0:   } combining[] = {
michael@0:     { 0x0300, 0x034E }, { 0x0360, 0x0362 }, { 0x0483, 0x0486 },
michael@0:     { 0x0488, 0x0489 }, { 0x0591, 0x05A1 }, { 0x05A3, 0x05B9 },
michael@0:     { 0x05BB, 0x05BD }, { 0x05BF, 0x05BF }, { 0x05C1, 0x05C2 },
michael@0:     { 0x05C4, 0x05C4 }, { 0x064B, 0x0655 }, { 0x0670, 0x0670 },
michael@0:     { 0x06D6, 0x06E4 }, { 0x06E7, 0x06E8 }, { 0x06EA, 0x06ED },
michael@0:     { 0x0711, 0x0711 }, { 0x0730, 0x074A }, { 0x07A6, 0x07B0 },
michael@0:     { 0x0901, 0x0902 }, { 0x093C, 0x093C }, { 0x0941, 0x0948 },
michael@0:     { 0x094D, 0x094D }, { 0x0951, 0x0954 }, { 0x0962, 0x0963 },
michael@0:     { 0x0981, 0x0981 }, { 0x09BC, 0x09BC }, { 0x09C1, 0x09C4 },
michael@0:     { 0x09CD, 0x09CD }, { 0x09E2, 0x09E3 }, { 0x0A02, 0x0A02 },
michael@0:     { 0x0A3C, 0x0A3C }, { 0x0A41, 0x0A42 }, { 0x0A47, 0x0A48 },
michael@0:     { 0x0A4B, 0x0A4D }, { 0x0A70, 0x0A71 }, { 0x0A81, 0x0A82 },
michael@0:     { 0x0ABC, 0x0ABC }, { 0x0AC1, 0x0AC5 }, { 0x0AC7, 0x0AC8 },
michael@0:     { 0x0ACD, 0x0ACD }, { 0x0B01, 0x0B01 }, { 0x0B3C, 0x0B3C },
michael@0:     { 0x0B3F, 0x0B3F }, { 0x0B41, 0x0B43 }, { 0x0B4D, 0x0B4D },
michael@0:     { 0x0B56, 0x0B56 }, { 0x0B82, 0x0B82 }, { 0x0BC0, 0x0BC0 },
michael@0:     { 0x0BCD, 0x0BCD }, { 0x0C3E, 0x0C40 }, { 0x0C46, 0x0C48 },
michael@0:     { 0x0C4A, 0x0C4D }, { 0x0C55, 0x0C56 }, { 0x0CBF, 0x0CBF },
michael@0:     { 0x0CC6, 0x0CC6 }, { 0x0CCC, 0x0CCD }, { 0x0D41, 0x0D43 },
michael@0:     { 0x0D4D, 0x0D4D }, { 0x0DCA, 0x0DCA }, { 0x0DD2, 0x0DD4 },
michael@0:     { 0x0DD6, 0x0DD6 }, { 0x0E31, 0x0E31 }, { 0x0E34, 0x0E3A },
michael@0:     { 0x0E47, 0x0E4E }, { 0x0EB1, 0x0EB1 }, { 0x0EB4, 0x0EB9 },
michael@0:     { 0x0EBB, 0x0EBC }, { 0x0EC8, 0x0ECD }, { 0x0F18, 0x0F19 },
michael@0:     { 0x0F35, 0x0F35 }, { 0x0F37, 0x0F37 }, { 0x0F39, 0x0F39 },
michael@0:     { 0x0F71, 0x0F7E }, { 0x0F80, 0x0F84 }, { 0x0F86, 0x0F87 },
michael@0:     { 0x0F90, 0x0F97 }, { 0x0F99, 0x0FBC }, { 0x0FC6, 0x0FC6 },
michael@0:     { 0x102D, 0x1030 }, { 0x1032, 0x1032 }, { 0x1036, 0x1037 },
michael@0:     { 0x1039, 0x1039 }, { 0x1058, 0x1059 }, { 0x17B7, 0x17BD },
michael@0:     { 0x17C6, 0x17C6 }, { 0x17C9, 0x17D3 }, { 0x18A9, 0x18A9 },
michael@0:     { 0x20D0, 0x20E3 }, { 0x302A, 0x302F }, { 0x3099, 0x309A },
michael@0:     { 0xFB1E, 0xFB1E }, { 0xFE20, 0xFE23 }
michael@0:   };
michael@0:   int32_t min = 0;
michael@0:   int32_t max = sizeof(combining) / sizeof(struct interval) - 1;
michael@0:   int32_t mid;
michael@0: 
michael@0:   /* test for 8-bit control characters */
michael@0:   if (ucs == 0)
michael@0:     return 0;
michael@0:   if (ucs < 32 || (ucs >= 0x7f && ucs < 0xa0))
michael@0:     return -1;
michael@0: 
michael@0:   /* first quick check for Latin-1 etc. characters */
michael@0:   if (ucs < combining[0].first)
michael@0:     return 1;
michael@0: 
michael@0:   /* binary search in table of non-spacing characters */
michael@0:   while (max >= min) {
michael@0:     mid = (min + max) / 2;
michael@0:     if (combining[mid].last < ucs)
michael@0:       min = mid + 1;
michael@0:     else if (combining[mid].first > ucs)
michael@0:       max = mid - 1;
michael@0:     else if (combining[mid].first <= ucs && combining[mid].last >= ucs)
michael@0:       return 0;
michael@0:   }
michael@0: 
michael@0:   /* if we arrive here, ucs is not a combining or C0/C1 control character */
michael@0: 
michael@0:   /* fast test for majority of non-wide scripts */
michael@0:   if (ucs < 0x1100)
michael@0:     return 1;
michael@0: 
michael@0:   return 1 +
michael@0:     ((ucs >= 0x1100 && ucs <= 0x115f) || /* Hangul Jamo */
michael@0:      (ucs >= 0x2e80 && ucs <= 0xa4cf && (ucs & ~0x0011) != 0x300a &&
michael@0:       ucs != 0x303f) ||                  /* CJK ... Yi */
michael@0:      (ucs >= 0xac00 && ucs <= 0xd7a3) || /* Hangul Syllables */
michael@0:      (ucs >= 0xf900 && ucs <= 0xfaff) || /* CJK Compatibility Ideographs */
michael@0:      (ucs >= 0xfe30 && ucs <= 0xfe6f) || /* CJK Compatibility Forms */
michael@0:      (ucs >= 0xff00 && ucs <= 0xff5f) || /* Fullwidth Forms */
michael@0:      (ucs >= 0xffe0 && ucs <= 0xffe6));
michael@0: }
michael@0: 
michael@0: 
michael@0: int32_t GetUnicharStringWidth(const char16_t* pwcs, int32_t n)
michael@0: {
michael@0:   int32_t w, width = 0;
michael@0: 
michael@0:   for (;*pwcs && n-- > 0; pwcs++)
michael@0:     if ((w = GetUnicharWidth(*pwcs)) < 0)
michael@0:       ++width; // Taking 1 as the width of non-printable character, for bug# 94475.
michael@0:     else
michael@0:       width += w;
michael@0: 
michael@0:   return width;
michael@0: }
michael@0: