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 an XML DOM to an XML string that
michael@0:  * could be parsed into more or less the original DOM.
michael@0:  */
michael@0: 
michael@0: #ifndef nsXMLContentSerializer_h__
michael@0: #define nsXMLContentSerializer_h__
michael@0: 
michael@0: #include "mozilla/Attributes.h"
michael@0: #include "nsIContentSerializer.h"
michael@0: #include "nsISupportsUtils.h"
michael@0: #include "nsCOMPtr.h"
michael@0: #include "nsTArray.h"
michael@0: #include "nsString.h"
michael@0: 
michael@0: #define kIndentStr NS_LITERAL_STRING("  ")
michael@0: #define kEndTag NS_LITERAL_STRING("</")
michael@0: 
michael@0: class nsIAtom;
michael@0: class nsIDOMNode;
michael@0: class nsINode;
michael@0: 
michael@0: class nsXMLContentSerializer : public nsIContentSerializer {
michael@0:  public:
michael@0:   nsXMLContentSerializer();
michael@0:   virtual ~nsXMLContentSerializer();
michael@0: 
michael@0:   NS_DECL_ISUPPORTS
michael@0: 
michael@0:   NS_IMETHOD Init(uint32_t flags, uint32_t aWrapColumn,
michael@0:                   const char* aCharSet, bool aIsCopying,
michael@0:                   bool aRewriteEncodingDeclaration) MOZ_OVERRIDE;
michael@0: 
michael@0:   NS_IMETHOD AppendText(nsIContent* aText, int32_t aStartOffset,
michael@0:                         int32_t aEndOffset, nsAString& aStr) MOZ_OVERRIDE;
michael@0: 
michael@0:   NS_IMETHOD AppendCDATASection(nsIContent* aCDATASection,
michael@0:                                 int32_t aStartOffset, int32_t aEndOffset,
michael@0:                                 nsAString& aStr) MOZ_OVERRIDE;
michael@0: 
michael@0:   NS_IMETHOD AppendProcessingInstruction(nsIContent* aPI,
michael@0:                                          int32_t aStartOffset,
michael@0:                                          int32_t aEndOffset,
michael@0:                                          nsAString& aStr) MOZ_OVERRIDE;
michael@0: 
michael@0:   NS_IMETHOD AppendComment(nsIContent* aComment, int32_t aStartOffset,
michael@0:                            int32_t aEndOffset, nsAString& aStr) MOZ_OVERRIDE;
michael@0:   
michael@0:   NS_IMETHOD AppendDoctype(nsIContent *aDoctype,
michael@0:                            nsAString& aStr) MOZ_OVERRIDE;
michael@0: 
michael@0:   NS_IMETHOD AppendElementStart(mozilla::dom::Element* aElement,
michael@0:                                 mozilla::dom::Element* aOriginalElement,
michael@0:                                 nsAString& aStr) MOZ_OVERRIDE;
michael@0: 
michael@0:   NS_IMETHOD AppendElementEnd(mozilla::dom::Element* aElement,
michael@0:                               nsAString& aStr) MOZ_OVERRIDE;
michael@0: 
michael@0:   NS_IMETHOD Flush(nsAString& aStr) MOZ_OVERRIDE { return NS_OK; }
michael@0: 
michael@0:   NS_IMETHOD AppendDocumentStart(nsIDocument *aDocument,
michael@0:                                  nsAString& aStr) MOZ_OVERRIDE;
michael@0: 
michael@0:  protected:
michael@0: 
michael@0:   /**
michael@0:    * Appends a char16_t character and increments the column position
michael@0:    */
michael@0:   void AppendToString(const char16_t aChar,
michael@0:                       nsAString& aOutputStr);
michael@0: 
michael@0:   /**
michael@0:    * Appends a nsAString string and increments the column position
michael@0:    */
michael@0:   void AppendToString(const nsAString& aStr,
michael@0:                       nsAString& aOutputStr);
michael@0: 
michael@0:   /**
michael@0:    * Appends a string by replacing all line-endings
michael@0:    * by mLineBreak, except in the case of raw output.
michael@0:    * It increments the column position.
michael@0:    */
michael@0:   void AppendToStringConvertLF(const nsAString& aStr,
michael@0:                                nsAString& aOutputStr);
michael@0: 
michael@0:   /**
michael@0:    * Appends a string by wrapping it when necessary.
michael@0:    * It updates the column position.
michael@0:    */
michael@0:   void AppendToStringWrapped(const nsASingleFragmentString& aStr,
michael@0:                              nsAString& aOutputStr);
michael@0: 
michael@0:   /**
michael@0:    * Appends a string by formating and wrapping it when necessary
michael@0:    * It updates the column position.
michael@0:    */
michael@0:   void AppendToStringFormatedWrapped(const nsASingleFragmentString& aStr,
michael@0:                                      nsAString& aOutputStr);
michael@0: 
michael@0:   // used by AppendToStringWrapped
michael@0:   void AppendWrapped_WhitespaceSequence(
michael@0:           nsASingleFragmentString::const_char_iterator &aPos,
michael@0:           const nsASingleFragmentString::const_char_iterator aEnd,
michael@0:           const nsASingleFragmentString::const_char_iterator aSequenceStart,
michael@0:           nsAString &aOutputStr);
michael@0: 
michael@0:   // used by AppendToStringFormatedWrapped
michael@0:   void AppendFormatedWrapped_WhitespaceSequence(
michael@0:           nsASingleFragmentString::const_char_iterator &aPos,
michael@0:           const nsASingleFragmentString::const_char_iterator aEnd,
michael@0:           const nsASingleFragmentString::const_char_iterator aSequenceStart,
michael@0:           bool &aMayIgnoreStartOfLineWhitespaceSequence,
michael@0:           nsAString &aOutputStr);
michael@0: 
michael@0:   // used by AppendToStringWrapped and AppendToStringFormatedWrapped
michael@0:   void AppendWrapped_NonWhitespaceSequence(
michael@0:           nsASingleFragmentString::const_char_iterator &aPos,
michael@0:           const nsASingleFragmentString::const_char_iterator aEnd,
michael@0:           const nsASingleFragmentString::const_char_iterator aSequenceStart,
michael@0:           bool &aMayIgnoreStartOfLineWhitespaceSequence,
michael@0:           bool &aSequenceStartAfterAWhiteSpace,
michael@0:           nsAString &aOutputStr);
michael@0: 
michael@0:   /**
michael@0:    * add mLineBreak to the string
michael@0:    * It updates the column position and other flags.
michael@0:    */
michael@0:   void AppendNewLineToString(nsAString& aOutputStr);
michael@0: 
michael@0: 
michael@0:   /**
michael@0:    * Appends a string by translating entities
michael@0:    * It doesn't increment the column position
michael@0:    */
michael@0:   virtual void AppendAndTranslateEntities(const nsAString& aStr,
michael@0:                                           nsAString& aOutputStr);
michael@0: 
michael@0:   /**
michael@0:    * retrieve the text content of the node and append it to the given string
michael@0:    * It doesn't increment the column position
michael@0:    */
michael@0:   nsresult AppendTextData(nsIContent* aNode,
michael@0:                           int32_t aStartOffset,
michael@0:                           int32_t aEndOffset,
michael@0:                           nsAString& aStr,
michael@0:                           bool aTranslateEntities);
michael@0: 
michael@0:   virtual nsresult PushNameSpaceDecl(const nsAString& aPrefix,
michael@0:                                      const nsAString& aURI,
michael@0:                                      nsIContent* aOwner);
michael@0:   void PopNameSpaceDeclsFor(nsIContent* aOwner);
michael@0: 
michael@0:   /**
michael@0:    * The problem that ConfirmPrefix fixes is that anyone can insert nodes
michael@0:    * through the DOM that have a namespace URI and a random or empty or
michael@0:    * previously existing prefix that's totally unrelated to the prefixes
michael@0:    * declared at that point through xmlns attributes.  So what ConfirmPrefix
michael@0:    * does is ensure that we can map aPrefix to the namespace URI aURI (for
michael@0:    * example, that the prefix is not already mapped to some other namespace).
michael@0:    * aPrefix will be adjusted, if necessary, so the value of the prefix
michael@0:    * _after_ this call is what should be serialized.
michael@0:    * @param aPrefix the prefix that may need adjusting
michael@0:    * @param aURI the namespace URI we want aPrefix to point to
michael@0:    * @param aElement the element we're working with (needed for proper default
michael@0:    *                 namespace handling)
michael@0:    * @param aIsAttribute true if we're confirming a prefix for an attribute.
michael@0:    * @return true if we need to push the (prefix, uri) pair on the namespace
michael@0:    *                 stack (note that this can happen even if the prefix is
michael@0:    *                 empty).
michael@0:    */
michael@0:   bool ConfirmPrefix(nsAString& aPrefix,
michael@0:                        const nsAString& aURI,
michael@0:                        nsIContent* aElement,
michael@0:                        bool aIsAttribute);
michael@0:   /**
michael@0:    * GenerateNewPrefix generates a new prefix and writes it to aPrefix
michael@0:    */
michael@0:   void GenerateNewPrefix(nsAString& aPrefix);
michael@0: 
michael@0:   uint32_t ScanNamespaceDeclarations(nsIContent* aContent,
michael@0:                                      nsIContent *aOriginalElement,
michael@0:                                      const nsAString& aTagNamespaceURI);
michael@0: 
michael@0:   virtual void SerializeAttributes(nsIContent* aContent,
michael@0:                                    nsIContent *aOriginalElement,
michael@0:                                    nsAString& aTagPrefix,
michael@0:                                    const nsAString& aTagNamespaceURI,
michael@0:                                    nsIAtom* aTagName,
michael@0:                                    nsAString& aStr,
michael@0:                                    uint32_t aSkipAttr,
michael@0:                                    bool aAddNSAttr);
michael@0: 
michael@0:   void SerializeAttr(const nsAString& aPrefix,
michael@0:                      const nsAString& aName,
michael@0:                      const nsAString& aValue,
michael@0:                      nsAString& aStr,
michael@0:                      bool aDoEscapeEntities);
michael@0: 
michael@0:   bool IsJavaScript(nsIContent * aContent,
michael@0:                       nsIAtom* aAttrNameAtom,
michael@0:                       int32_t aAttrNamespaceID,
michael@0:                       const nsAString& aValueString);
michael@0: 
michael@0:   /**
michael@0:    * This method can be redefined to check if the element can be serialized.
michael@0:    * It is called when the serialization of the start tag is asked 
michael@0:    * (AppendElementStart)
michael@0:    * In this method you can also force the formating
michael@0:    * by setting aForceFormat to true.
michael@0:    * @return boolean  true if the element can be output
michael@0:    */
michael@0:   virtual bool CheckElementStart(nsIContent * aContent,
michael@0:                                    bool & aForceFormat,
michael@0:                                    nsAString& aStr);
michael@0: 
michael@0:   /**
michael@0:    * this method is responsible to finish the start tag,
michael@0:    * in particulary to append the "greater than" sign
michael@0:    */
michael@0:   virtual void AppendEndOfElementStart(nsIContent *aOriginalElement,
michael@0:                                        nsIAtom * aName,
michael@0:                                        int32_t aNamespaceID,
michael@0:                                        nsAString& aStr);
michael@0: 
michael@0:   /**
michael@0:    * This method can be redefine to serialize additional things just after
michael@0:    * after the serialization ot the start tag.
michael@0:    * (called at the end of AppendElementStart)
michael@0:    */
michael@0:   virtual void AfterElementStart(nsIContent * aContent,
michael@0:                                  nsIContent *aOriginalElement,
michael@0:                                  nsAString& aStr) { };
michael@0: 
michael@0:   /**
michael@0:    * This method can be redefined to check if the element can be serialized.
michael@0:    * It is called when the serialization of the end tag is asked 
michael@0:    * (AppendElementEnd)
michael@0:    * In this method you can also force the formating
michael@0:    * by setting aForceFormat to true.
michael@0:    * @return boolean  true if the element can be output
michael@0:    */
michael@0:   virtual bool CheckElementEnd(nsIContent * aContent,
michael@0:                                  bool & aForceFormat,
michael@0:                                  nsAString& aStr);
michael@0: 
michael@0:   /**
michael@0:    * This method can be redefine to serialize additional things just after
michael@0:    * after the serialization ot the end tag.
michael@0:    * (called at the end of AppendElementStart)
michael@0:    */
michael@0:   virtual void AfterElementEnd(nsIContent * aContent,
michael@0:                                nsAString& aStr) { };
michael@0: 
michael@0:   /**
michael@0:    * Returns true if a line break should be inserted before an element open tag
michael@0:    */
michael@0:   virtual bool LineBreakBeforeOpen(int32_t aNamespaceID, nsIAtom* aName);
michael@0: 
michael@0:   /**
michael@0:    * Returns true if a line break should be inserted after an element open tag
michael@0:    */
michael@0:   virtual bool LineBreakAfterOpen(int32_t aNamespaceID, nsIAtom* aName);
michael@0: 
michael@0:   /**
michael@0:    * Returns true if a line break should be inserted after an element close tag
michael@0:    */
michael@0:   virtual bool LineBreakBeforeClose(int32_t aNamespaceID, nsIAtom* aName);
michael@0: 
michael@0:   /**
michael@0:    * Returns true if a line break should be inserted after an element close tag
michael@0:    */
michael@0:   virtual bool LineBreakAfterClose(int32_t aNamespaceID, nsIAtom* aName);
michael@0: 
michael@0:   /**
michael@0:    * add intendation. Call only in the case of formating and if the current
michael@0:    * position is at 0. It updates the column position.
michael@0:    */
michael@0:   void AppendIndentation(nsAString& aStr);
michael@0:   void IncrIndentation(nsIAtom* aName);
michael@0:   void DecrIndentation(nsIAtom* aName);
michael@0: 
michael@0:   // Functions to check for newlines that needs to be added between nodes in
michael@0:   // the root of a document. See mAddNewlineForRootNode
michael@0:   void MaybeAddNewlineForRootNode(nsAString& aStr);
michael@0:   void MaybeFlagNewlineForRootNode(nsINode* aNode);
michael@0: 
michael@0:   // Functions to check if we enter in or leave from a preformated content
michael@0:   virtual void MaybeEnterInPreContent(nsIContent* aNode);
michael@0:   virtual void MaybeLeaveFromPreContent(nsIContent* aNode);
michael@0: 
michael@0:   int32_t mPrefixIndex;
michael@0: 
michael@0:   struct NameSpaceDecl {
michael@0:     nsString mPrefix;
michael@0:     nsString mURI;
michael@0:     nsIContent* mOwner;
michael@0:   };
michael@0: 
michael@0:   nsTArray<NameSpaceDecl> mNameSpaceStack;
michael@0: 
michael@0:   // nsIDocumentEncoder flags
michael@0:   uint32_t  mFlags;
michael@0: 
michael@0:   // characters to use for line break
michael@0:   nsString  mLineBreak;
michael@0: 
michael@0:   // The charset that was passed to Init()
michael@0:   nsCString mCharset;
michael@0:   
michael@0:   // current column position on the current line
michael@0:   uint32_t   mColPos;
michael@0: 
michael@0:   // true = pretty formating should be done (OutputFormated flag)
michael@0:   bool mDoFormat;
michael@0: 
michael@0:   // true = no formatting,(OutputRaw flag)
michael@0:   // no newline convertion and no rewrap long lines even if OutputWrap is set.
michael@0:   bool mDoRaw;
michael@0: 
michael@0:   // true = wrapping should be done (OutputWrap flag)
michael@0:   bool mDoWrap;
michael@0: 
michael@0:   // number of maximum column in a line, in the wrap mode
michael@0:   uint32_t   mMaxColumn;
michael@0: 
michael@0:   // current indent value
michael@0:   nsString   mIndent;
michael@0: 
michael@0:   // this is the indentation level after the indentation reached
michael@0:   // the maximum length of indentation
michael@0:   int32_t    mIndentOverflow;
michael@0: 
michael@0:   // says if the indentation has been already added on the current line
michael@0:   bool mIsIndentationAddedOnCurrentLine;
michael@0: 
michael@0:   // the string which is currently added is in an attribute
michael@0:   bool mInAttribute;
michael@0: 
michael@0:   // true = a newline character should be added. It's only
michael@0:   // useful when serializing root nodes. see MaybeAddNewlineForRootNode and
michael@0:   // MaybeFlagNewlineForRootNode
michael@0:   bool mAddNewlineForRootNode;
michael@0: 
michael@0:   // Indicates that a space will be added if and only if content is
michael@0:   // continued on the same line while serializing source.  Otherwise,
michael@0:   // the newline character acts as the whitespace and no space is needed.
michael@0:   // used when mDoFormat = true
michael@0:   bool          mAddSpace;
michael@0: 
michael@0:   // says that if the next string to add contains a newline character at the
michael@0:   // begining, then this newline character should be ignored, because a
michael@0:   // such character has already been added into the output string
michael@0:   bool          mMayIgnoreLineBreakSequence;
michael@0: 
michael@0:   bool          mBodyOnly;
michael@0:   int32_t       mInBody;
michael@0: 
michael@0:   // number of nested elements which have preformated content
michael@0:   int32_t       mPreLevel;
michael@0: };
michael@0: 
michael@0: nsresult
michael@0: NS_NewXMLContentSerializer(nsIContentSerializer** aSerializer);
michael@0: 
michael@0: #endif