Xalan-C++ API Documentation

The Xalan C++ XSLT Processor Version 1.10

             

---

FormatterToHTML.hpp

Go to the documentation of this file.

/*
 * Copyright 1999-2004 The Apache Software Foundation.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#if !defined(FORMATTERTOHTML_HEADER_GUARD_1357924680)
#define FORMATTERTOHTML_HEADER_GUARD_1357924680



// Base include file.  Must be first.
#include <xalanc/XMLSupport/XMLSupportDefinitions.hpp>



#include <xalanc/Include/XalanVector.hpp>



// Base class header file.
#include <xalanc/XMLSupport/FormatterToXML.hpp>



#include <xalanc/PlatformSupport/DOMStringHelper.hpp>



#include <xalanc/XMLSupport/XalanHTMLElementsProperties.hpp>



XALAN_CPP_NAMESPACE_BEGIN



class XALAN_XMLSUPPORT_EXPORT FormatterToHTML : public FormatterToXML 
{  
    
public:


    typedef XalanVector<XalanHTMLElementsProperties::ElementProperties> ElementPropertiesStackType;


    enum
    {
        eDefaultIndentAmount = 0
    };

    FormatterToHTML(
            Writer&                 writer,
            const XalanDOMString&   encoding = XalanDOMString(XalanMemMgrs::getDummyMemMgr()),
            const XalanDOMString&   mediaType = XalanDOMString(XalanMemMgrs::getDummyMemMgr()),
            const XalanDOMString&   doctypeSystem = XalanDOMString(XalanMemMgrs::getDummyMemMgr()),
            const XalanDOMString&   doctypePublic = XalanDOMString(XalanMemMgrs::getDummyMemMgr()),
            bool                    doIndent = true,
            int                     indent = eDefaultIndentAmount,
            bool                    escapeURLs = true,
            bool                    omitMetaTag = false,
            MemoryManagerType&      theManager XALAN_DEFAULT_MEMMGR);

    static FormatterToHTML*
    create(
            MemoryManagerType&      theManager,
            Writer&                 writer,
            const XalanDOMString&   encoding, 
            const XalanDOMString&   mediaType,
            const XalanDOMString&   doctypeSystem,
            const XalanDOMString&   doctypePublic,
            bool                    doIndent,
            int                     indent,
            bool                    escapeURLs,
            bool                    omitMetaTag);
    virtual
    ~FormatterToHTML();

    // These methods are inherited from DocumentHandler ...

    virtual void
    startDocument();

    virtual void
    endDocument();

    virtual void
    startElement(
            const   XMLCh* const    name,
            AttributeListType&      attrs);

    virtual void
    endElement(const XMLCh* const   name);

    virtual void
    characters(
            const XMLCh* const  chars,
            const unsigned int  length);

    // These methods are inherited from FormatterToXML...

    virtual bool
    accumDefaultEntity(
            XalanDOMChar                ch,
            bool                        escLF);

    // These methods are inherited from FormatterListener ...

    virtual void
    entityReference(const XMLCh* const  name);

    virtual void
    cdata(
            const XMLCh* const  ch,
            const unsigned int  length);

    virtual void
    processingInstruction(
            const XMLCh* const  target,
            const XMLCh* const  data);


    bool
    getEscapeURLs() const
    {
        return m_escapeURLs;
    }

    void
    setEscapeURLs(bool  flag)
    {
        m_escapeURLs = flag;
    }

    struct Entity
    {
        enum { eMaxLength = 8 };

        XalanDOMChar                m_char;

        XalanDOMString::size_type   m_length;

        XalanDOMChar                m_string[eMaxLength + 1];
    };

protected:

    virtual void
    writeAttrString(
            const XalanDOMChar*         theString,
            XalanDOMString::size_type   theStringLength);

    virtual void
    accumCommentData(const XalanDOMChar*    data);

    void
    writeCharacters(const XalanDOMString&   theString);

    void
    writeCharacters(
            const XalanDOMChar*         theString,
            XalanDOMString::size_type   theLength);

private:

    typedef XalanDOMString::size_type   size_type;

    static const XalanDOMChar   s_doctypeHeaderStartString[];

    static const size_type      s_doctypeHeaderStartStringLength;

    static const XalanDOMChar   s_doctypeHeaderPublicString[];

    static const size_type      s_doctypeHeaderPublicStringLength;

    static const XalanDOMChar   s_doctypeHeaderSystemString[];

    static const size_type      s_doctypeHeaderSystemStringLength;

    static const XalanDOMChar   s_metaString[];

    static const size_type      s_metaStringLength;

    void
    initAttrCharsMap();

    void
    initCharsMap();

    void
    copyEntityIntoBuffer(
            const XalanDOMChar*         s,
            XalanDOMString::size_type   theLength);

    void
    copyEntityIntoBuffer(const XalanDOMString&  s);

    virtual void
    processAttribute(
            const XalanDOMChar*                                     name,
            const XalanDOMChar*                                     value,
            const XalanHTMLElementsProperties::ElementProperties&   elemProperties);

    void
    writeAttrURI(
            const XalanDOMChar*         theString,
            XalanDOMString::size_type   theStringLength);

    void
    accumHexNumber(XalanDOMChar     theChar);

    bool
    popHasNamespace();

    bool
    pushHasNamespace(const XalanDOMChar*    theElementName);

    // Data members...
    XalanDOMString          m_currentElementName;

    bool                    m_inBlockElem;

    BoolStackType           m_isRawStack;

    bool                    m_isScriptOrStyleElem;

    BoolStackType           m_inScriptElemStack;

    bool                    m_escapeURLs;

    bool                    m_isFirstElement;

    bool                    m_isUTF8;

    int                     m_elementLevel;

    BoolStackType           m_hasNamespaceStack;

    bool                    m_omitMetaTag;

    ElementPropertiesStackType      m_elementPropertiesStack;

    static const XalanDOMString     s_emptyString;

    static const Entity             s_entities[];

    static const Entity* const      s_lastEntity;
};



XALAN_CPP_NAMESPACE_END



#endif  // FORMATTERTOHTML_HEADER_GUARD_1357924680

Interpreting class diagrams

Doxygen and GraphViz are used to generate this API documentation from the Xalan-C header files.

Xalan-C++ XSLT Processor Version 1.10 Copyright © 1999-2004 The Apache Software Foundation. All Rights Reserved.