зеркало из https://github.com/mozilla/gecko-dev.git
250 строки
8.9 KiB
C++
250 строки
8.9 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
/*
|
|
* nsIContentSerializer implementation that can be used with an
|
|
* nsIDocumentEncoder to convert a DOM into plaintext in a nice way
|
|
* (eg for copy/paste as plaintext).
|
|
*/
|
|
|
|
#ifndef nsPlainTextSerializer_h__
|
|
#define nsPlainTextSerializer_h__
|
|
|
|
#include "mozilla/Attributes.h"
|
|
#include "mozilla/intl/LineBreaker.h"
|
|
#include "nsCOMPtr.h"
|
|
#include "nsAtom.h"
|
|
#include "nsCycleCollectionParticipant.h"
|
|
#include "nsIContentSerializer.h"
|
|
#include "nsIDocumentEncoder.h"
|
|
#include "nsString.h"
|
|
#include "nsTArray.h"
|
|
|
|
#include <stack>
|
|
|
|
class nsIContent;
|
|
|
|
namespace mozilla {
|
|
namespace dom {
|
|
class DocumentType;
|
|
class Element;
|
|
} // namespace dom
|
|
} // namespace mozilla
|
|
|
|
class nsPlainTextSerializer final : public nsIContentSerializer {
|
|
public:
|
|
nsPlainTextSerializer();
|
|
|
|
NS_DECL_CYCLE_COLLECTING_ISUPPORTS
|
|
NS_DECL_CYCLE_COLLECTION_CLASS(nsPlainTextSerializer)
|
|
|
|
// nsIContentSerializer
|
|
NS_IMETHOD Init(uint32_t flags, uint32_t aWrapColumn,
|
|
const mozilla::Encoding* aEncoding, bool aIsCopying,
|
|
bool aIsWholeDocument,
|
|
bool* aNeedsPreformatScanning) override;
|
|
|
|
NS_IMETHOD AppendText(nsIContent* aText, int32_t aStartOffset,
|
|
int32_t aEndOffset, nsAString& aStr) override;
|
|
NS_IMETHOD AppendCDATASection(nsIContent* aCDATASection, int32_t aStartOffset,
|
|
int32_t aEndOffset, nsAString& aStr) override;
|
|
NS_IMETHOD AppendProcessingInstruction(
|
|
mozilla::dom::ProcessingInstruction* aPI, int32_t aStartOffset,
|
|
int32_t aEndOffset, nsAString& aStr) override {
|
|
return NS_OK;
|
|
}
|
|
NS_IMETHOD AppendComment(mozilla::dom::Comment* aComment,
|
|
int32_t aStartOffset, int32_t aEndOffset,
|
|
nsAString& aStr) override {
|
|
return NS_OK;
|
|
}
|
|
NS_IMETHOD AppendDoctype(mozilla::dom::DocumentType* aDoctype,
|
|
nsAString& aStr) override {
|
|
return NS_OK;
|
|
}
|
|
NS_IMETHOD AppendElementStart(mozilla::dom::Element* aElement,
|
|
mozilla::dom::Element* aOriginalElement,
|
|
nsAString& aStr) override;
|
|
NS_IMETHOD AppendElementEnd(mozilla::dom::Element* aElement,
|
|
nsAString& aStr) override;
|
|
NS_IMETHOD Flush(nsAString& aStr) override;
|
|
|
|
NS_IMETHOD AppendDocumentStart(nsIDocument* aDocument,
|
|
nsAString& aStr) override;
|
|
|
|
NS_IMETHOD ScanElementForPreformat(mozilla::dom::Element* aElement) override;
|
|
NS_IMETHOD ForgetElementForPreformat(
|
|
mozilla::dom::Element* aElement) override;
|
|
|
|
private:
|
|
~nsPlainTextSerializer();
|
|
|
|
nsresult GetAttributeValue(nsAtom* aName, nsString& aValueRet);
|
|
void AddToLine(const char16_t* aStringToAdd, int32_t aLength);
|
|
void EndLine(bool softlinebreak, bool aBreakBySpace = false);
|
|
void EnsureVerticalSpace(int32_t noOfRows);
|
|
void FlushLine();
|
|
void OutputQuotesAndIndent(bool stripTrailingSpaces = false);
|
|
void Output(nsString& aString);
|
|
void Write(const nsAString& aString);
|
|
bool IsInPre();
|
|
bool IsInOL();
|
|
bool IsCurrentNodeConverted();
|
|
bool MustSuppressLeaf();
|
|
|
|
/**
|
|
* Returns the local name of the element as an atom if the element is an
|
|
* HTML element and the atom is a static atom. Otherwise, nullptr is returned.
|
|
*/
|
|
static nsAtom* GetIdForContent(nsIContent* aContent);
|
|
nsresult DoOpenContainer(nsAtom* aTag);
|
|
nsresult DoCloseContainer(nsAtom* aTag);
|
|
nsresult DoAddLeaf(nsAtom* aTag);
|
|
void DoAddText(bool aIsWhitespace, const nsAString& aText);
|
|
|
|
// Inlined functions
|
|
inline bool MayWrap() {
|
|
return mWrapColumn && ((mFlags & nsIDocumentEncoder::OutputFormatted) ||
|
|
(mFlags & nsIDocumentEncoder::OutputWrap));
|
|
}
|
|
inline bool MayBreakLines() {
|
|
return !(mFlags & nsIDocumentEncoder::OutputDisallowLineBreaking);
|
|
}
|
|
|
|
inline bool DoOutput() { return mHeadLevel == 0; }
|
|
|
|
inline bool IsQuotedLine(const nsAString& aLine) {
|
|
return !aLine.IsEmpty() && aLine.First() == char16_t('>');
|
|
}
|
|
|
|
// Stack handling functions
|
|
bool GetLastBool(const nsTArray<bool>& aStack);
|
|
void SetLastBool(nsTArray<bool>& aStack, bool aValue);
|
|
void PushBool(nsTArray<bool>& aStack, bool aValue);
|
|
bool PopBool(nsTArray<bool>& aStack);
|
|
|
|
bool ShouldReplaceContainerWithPlaceholder(nsAtom* aTag);
|
|
bool IsIgnorableRubyAnnotation(nsAtom* aTag);
|
|
|
|
bool IsElementPreformatted(mozilla::dom::Element* aElement);
|
|
bool IsElementBlock(mozilla::dom::Element* aElement);
|
|
|
|
private:
|
|
nsString mCurrentLine;
|
|
uint32_t mHeadLevel;
|
|
bool mAtFirstColumn;
|
|
|
|
bool mStructs; // Output structs (pref)
|
|
|
|
// If we've just written out a cite blockquote, we need to remember it
|
|
// so we don't duplicate spaces before a <pre wrap> (which mail uses to quote
|
|
// old messages).
|
|
bool mHasWrittenCiteBlockquote;
|
|
|
|
int32_t mIndent;
|
|
// mInIndentString keeps a header that has to be written in the indent.
|
|
// That could be, for instance, the bullet in a bulleted list.
|
|
nsString mInIndentString;
|
|
int32_t mCiteQuoteLevel;
|
|
int32_t mFlags;
|
|
int32_t mFloatingLines; // To store the number of lazy line breaks
|
|
|
|
// The wrap column is how many standard sized chars (western languages)
|
|
// should be allowed on a line. There could be less chars if the chars
|
|
// are wider than latin chars of more if the chars are more narrow.
|
|
uint32_t mWrapColumn;
|
|
|
|
// The width of the line as it will appear on the screen (approx.)
|
|
uint32_t mCurrentLineWidth;
|
|
|
|
// Treat quoted text as though it's preformatted -- don't wrap it.
|
|
// Having it on a pref is a temporary measure, See bug 69638.
|
|
int32_t mSpanLevel;
|
|
|
|
int32_t mEmptyLines; // Will be the number of empty lines before
|
|
// the current. 0 if we are starting a new
|
|
// line and -1 if we are in a line.
|
|
|
|
bool mInWhitespace;
|
|
bool mPreFormattedMail; // we're dealing with special DOM
|
|
// used by Thunderbird code.
|
|
bool mStartedOutput; // we've produced at least a character
|
|
|
|
// While handling a new tag, this variable should remind if any line break
|
|
// is due because of a closing tag. Setting it to "TRUE" while closing the
|
|
// tags. Hence opening tags are guaranteed to start with appropriate line
|
|
// breaks.
|
|
bool mLineBreakDue;
|
|
|
|
bool mPreformattedBlockBoundary;
|
|
|
|
// Whether the output should include ruby annotations.
|
|
bool mWithRubyAnnotation;
|
|
|
|
nsString mURL;
|
|
int32_t mHeaderStrategy; /* Header strategy (pref)
|
|
0 = no indention
|
|
1 = indention, increased with
|
|
header level (default)
|
|
2 = numbering and slight indention */
|
|
int32_t mHeaderCounter[7]; /* For header-numbering:
|
|
Number of previous headers of
|
|
the same depth and in the same
|
|
section.
|
|
mHeaderCounter[1] for <h1> etc. */
|
|
|
|
RefPtr<mozilla::dom::Element> mElement;
|
|
|
|
// For handling table rows
|
|
AutoTArray<bool, 8> mHasWrittenCellsForRow;
|
|
|
|
// Values gotten in OpenContainer that is (also) needed in CloseContainer
|
|
AutoTArray<bool, 8> mIsInCiteBlockquote;
|
|
|
|
// The output data
|
|
nsAString* mOutputString;
|
|
|
|
// The tag stack: the stack of tags we're operating on, so we can nest.
|
|
// The stack only ever points to static atoms, so they don't need to be
|
|
// refcounted.
|
|
nsAtom** mTagStack;
|
|
uint32_t mTagStackIndex;
|
|
|
|
// The stack indicating whether the elements we've been operating on are
|
|
// CSS preformatted elements, so that we can tell if the text inside them
|
|
// should be formatted.
|
|
std::stack<bool> mPreformatStack;
|
|
|
|
// Content in the stack above this index should be ignored:
|
|
uint32_t mIgnoreAboveIndex;
|
|
|
|
// The stack for ordered lists
|
|
int32_t* mOLStack;
|
|
uint32_t mOLStackIndex;
|
|
|
|
uint32_t mULCount;
|
|
|
|
nsString mLineBreak;
|
|
RefPtr<mozilla::intl::LineBreaker> mLineBreaker;
|
|
|
|
// Conveniance constant. It would be nice to have it as a const static
|
|
// variable, but that causes issues with OpenBSD and module unloading.
|
|
const nsString kSpace;
|
|
|
|
// If nsIDocumentEncoder::OutputNonTextContentAsPlaceholder is set, the child
|
|
// nodes of specific nodes - <iframe>, <canvas>, etc. should be ignored.
|
|
// mIgnoredChildNodeLevel is used to tell if current node is an ignorable
|
|
// child node. The initial value of mIgnoredChildNodeLevel is 0. When
|
|
// serializer enters those specific nodes, mIgnoredChildNodeLevel increases
|
|
// and is greater than 0. Otherwise when serializer leaves those nodes,
|
|
// mIgnoredChildNodeLevel decreases.
|
|
uint32_t mIgnoredChildNodeLevel;
|
|
};
|
|
|
|
nsresult NS_NewPlainTextSerializer(nsIContentSerializer** aSerializer);
|
|
|
|
#endif
|