htmlpars.hxx

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * 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/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   Licensed to the Apache Software Foundation (ASF) under one or more
 *   contributor license agreements. See the NOTICE file distributed
 *   with this work for additional information regarding copyright
 *   ownership. The ASF licenses this file to you 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 .
 */

#ifndef INCLUDED_SC_SOURCE_FILTER_INC_HTMLPARS_HXX
#define INCLUDED_SC_SOURCE_FILTER_INC_HTMLPARS_HXX

#include <memory>
#include <map>
#include <stack>
#include <string_view>
#include <unordered_map>
#include <vector>
#include <o3tl/sorted_vector.hxx>

#include <rangelst.hxx>
#include "eeparser.hxx"

const sal_uInt32 SC_HTML_FONTSIZES = 7;        // like export, HTML options

// Pixel tolerance for SeekOffset and related.
const sal_uInt16 SC_HTML_OFFSET_TOLERANCE_SMALL = 1;    // single table
const sal_uInt16 SC_HTML_OFFSET_TOLERANCE_LARGE = 10;   // nested

// BASE class for HTML parser classes

class ScHTMLTable;

class ScHTMLStyles
{
    typedef std::unordered_map<OUString, OUString> PropsType;
    typedef ::std::map<OUString, std::unique_ptr<PropsType>> NamePropsType;
    typedef ::std::map<OUString, std::unique_ptr<NamePropsType>> ElemsType;

    NamePropsType m_GlobalProps;     
    NamePropsType m_ElemGlobalProps; 
    ElemsType m_ElemProps;           
    const OUString maEmpty;     
public:
    ScHTMLStyles();

    void add(const char* pElemName, size_t nElemName, const char* pClassName, size_t nClassName,
             const OUString& aProp, const OUString& aValue);

    const OUString& getPropertyValue(
        const OUString& rElem, const OUString& rClass, const OUString& rPropName) const;

private:
    static void insertProp(
        NamePropsType& rProps, const OUString& aName,
        const OUString& aProp, const OUString& aValue);
};

class ScHTMLParser : public ScEEParser
{
    ScHTMLStyles                maStyles;
protected:
    sal_uInt32                  maFontHeights[ SC_HTML_FONTSIZES ];
    ScDocument*                 mpDoc;          

public:
    explicit                    ScHTMLParser( EditEngine* pEditEngine, ScDocument* pDoc );
    virtual                     ~ScHTMLParser() override;

    virtual ErrCode             Read( SvStream& rStrm, const OUString& rBaseURL  ) override = 0;

    ScHTMLStyles&               GetStyles() { return maStyles;}
    ScDocument&                 GetDoc() { return *mpDoc;}

    virtual const ScHTMLTable*  GetGlobalTable() const = 0;
};

typedef o3tl::sorted_vector<sal_uLong> ScHTMLColOffset;

struct ScHTMLTableStackEntry
{
    ScRangeListRef      xLockedList;
    std::shared_ptr<ScEEParseEntry> xCellEntry;
    ScHTMLColOffset*    pLocalColOffset;
    sal_uLong           nFirstTableCell;
    SCROW               nRowCnt;
    SCCOL               nColCntStart;
    SCCOL               nMaxCol;
    sal_uInt16          nTable;
    sal_uInt16          nTableWidth;
    sal_uInt16          nColOffset;
    sal_uInt16          nColOffsetStart;
    bool                bFirstRow;
                        ScHTMLTableStackEntry( const std::shared_ptr<ScEEParseEntry>& rE,
                                const ScRangeListRef& rL, ScHTMLColOffset* pTO,
                                sal_uLong nFTC,
                                SCROW nRow,
                                SCCOL nStart, SCCOL nMax, sal_uInt16 nTab,
                                sal_uInt16 nTW, sal_uInt16 nCO, sal_uInt16 nCOS,
                                bool bFR )
                            : xLockedList( rL ), xCellEntry(rE),
                            pLocalColOffset( pTO ),
                            nFirstTableCell( nFTC ),
                            nRowCnt( nRow ),
                            nColCntStart( nStart ), nMaxCol( nMax ),
                            nTable( nTab ), nTableWidth( nTW ),
                            nColOffset( nCO ), nColOffsetStart( nCOS ),
                            bFirstRow( bFR )
                            {}
};

struct ScHTMLAdjustStackEntry
{
    SCCOL               nLastCol;
    SCROW               nNextRow;
    SCROW               nCurRow;
                        ScHTMLAdjustStackEntry( SCCOL nLCol, SCROW nNRow,
                                SCROW nCRow )
                            : nLastCol( nLCol ), nNextRow( nNRow ),
                            nCurRow( nCRow )
                            {}
};

class EditEngine;
class ScDocument;
class HTMLOption;

// TODO these need better names
typedef ::std::map<SCROW, SCROW> InnerMap;
typedef ::std::map<sal_uInt16, InnerMap*> OuterMap;

class ScHTMLLayoutParser : public ScHTMLParser
{
private:
    Size                aPageSize;
    OUString            aBaseURL;
    ::std::stack< std::unique_ptr<ScHTMLTableStackEntry> >
                        aTableStack;
    OUString            aString;
    ScRangeListRef      xLockedList;        // per table
    std::unique_ptr<OuterMap> pTables;
    ScHTMLColOffset     maColOffset;
    ScHTMLColOffset*    pLocalColOffset;    // per table
    sal_uLong           nFirstTableCell;    // per table
    short               nTableLevel;
    sal_uInt16          nTable;
    sal_uInt16          nMaxTable;
    SCCOL               nColCntStart;       // first Col per table
    SCCOL               nMaxCol;            // per table
    sal_uInt16          nTableWidth;        // per table
    sal_uInt16          nColOffset;         // current, pixel
    sal_uInt16          nColOffsetStart;    // start value per table, in pixel
    sal_uInt16          nOffsetTolerance;   // for use with SeekOffset and related
    bool                bFirstRow;          // per table, whether in first row
    bool                bTabInTabCell:1;
    bool                bInCell:1;
    bool                bInTitle:1;

    DECL_LINK( HTMLImportHdl, HtmlImportInfo&, void );
    void                NewActEntry( const ScEEParseEntry* );
    static void         EntryEnd( ScEEParseEntry*, const ESelection& );
    void                ProcToken( HtmlImportInfo* );
    void                CloseEntry( const HtmlImportInfo* );
    void                NextRow(  const HtmlImportInfo*  );
    void                SkipLocked( ScEEParseEntry*, bool bJoin = true );
    static bool         SeekOffset( const ScHTMLColOffset*, sal_uInt16 nOffset,
                                    SCCOL* pCol, sal_uInt16 nOffsetTol );
    static void         MakeCol( ScHTMLColOffset*, sal_uInt16& nOffset,
                                sal_uInt16& nWidth, sal_uInt16 nOffsetTol,
                                sal_uInt16 nWidthTol );
    static void         MakeColNoRef( ScHTMLColOffset*, sal_uInt16 nOffset,
                                sal_uInt16 nWidth, sal_uInt16 nOffsetTol,
                                sal_uInt16 nWidthTol );
    static void         ModifyOffset( ScHTMLColOffset*, sal_uInt16& nOldOffset,
                                    sal_uInt16& nNewOffset, sal_uInt16 nOffsetTol );
    void                Colonize( ScEEParseEntry* );
    sal_uInt16          GetWidth( const ScEEParseEntry* );
    void                SetWidths();
    void                Adjust();

    sal_uInt16          GetWidthPixel( const HTMLOption& );
    bool                IsAtBeginningOfText( const HtmlImportInfo* );

    void                TableOn( HtmlImportInfo* );
    void                ColOn( HtmlImportInfo* );
    void                TableRowOn( const HtmlImportInfo* );
    void                TableRowOff( const HtmlImportInfo* );
    void                TableDataOn( HtmlImportInfo* );
    void                TableDataOff( const HtmlImportInfo* );
    void                TableOff( const HtmlImportInfo* );
    void                Image( HtmlImportInfo* );
    void                AnchorOn( HtmlImportInfo* );
    void                FontOn( HtmlImportInfo* );

public:
                        ScHTMLLayoutParser( EditEngine*, const OUString& rBaseURL, const Size& aPageSize, ScDocument* );
    virtual             ~ScHTMLLayoutParser() override;
    virtual ErrCode     Read( SvStream&, const OUString& rBaseURL  ) override;
    virtual const ScHTMLTable*  GetGlobalTable() const override;
};

// HTML DATA QUERY PARSER

enum ScHTMLOrient { tdCol = 0 , tdRow = 1 };

typedef sal_uInt16 ScHTMLTableId;
const ScHTMLTableId SC_HTML_GLOBAL_TABLE = 0;
const ScHTMLTableId SC_HTML_NO_TABLE = 0;

struct ScHTMLPos
{
    SCCOL               mnCol;
    SCROW               mnRow;

    explicit     ScHTMLPos() : mnCol( 0 ), mnRow( 0 ) {}
    explicit     ScHTMLPos( SCCOL nCol, SCROW nRow ) :
                            mnCol( nCol ), mnRow( nRow ) {}
    explicit     ScHTMLPos( const ScAddress& rAddr ) { Set( rAddr ); }

    SCCOLROW     Get( ScHTMLOrient eOrient ) const
                            { return (eOrient == tdCol) ? mnCol : mnRow; }
    void         Set( SCCOL nCol, SCROW nRow )
                            { mnCol = nCol; mnRow = nRow; }
    void         Set( const ScAddress& rAddr )
                            { Set( rAddr.Col(), rAddr.Row() ); }
    ScAddress    MakeAddr() const
                            { return ScAddress( mnCol, mnRow, 0 ); }
};

inline bool operator<( const ScHTMLPos& rPos1, const ScHTMLPos& rPos2 )
{
    return (rPos1.mnRow < rPos2.mnRow) || ((rPos1.mnRow == rPos2.mnRow) && (rPos1.mnCol < rPos2.mnCol));
}

struct ScHTMLSize
{
    SCCOL               mnCols;
    SCROW               mnRows;

    explicit     ScHTMLSize( SCCOL nCols, SCROW nRows ) :
                            mnCols( nCols ), mnRows( nRows ) {}
    void         Set( SCCOL nCols, SCROW nRows )
                            { mnCols = nCols; mnRows = nRows; }
};

struct ScHTMLEntry : public ScEEParseEntry
{
public:
    explicit            ScHTMLEntry(
                            const SfxItemSet& rItemSet,
                            ScHTMLTableId nTableId = SC_HTML_NO_TABLE );

    bool         IsEmpty() const { return !aSel.HasRange(); }
    bool                HasContents() const;
    bool         IsTable() const { return nTab != SC_HTML_NO_TABLE; }
    ScHTMLTableId GetTableId() const { return nTab; }

    void         SetImportAlways() { mbImportAlways = true; }
    void                AdjustStart( const HtmlImportInfo& rInfo );
    void                AdjustEnd( const HtmlImportInfo& rInfo );
    void                Strip( const EditEngine& rEditEngine );

    SfxItemSet&  GetItemSet() { return aItemSet; }
    const SfxItemSet& GetItemSet() const { return aItemSet; }

private:
    bool                mbImportAlways;     
};

struct ScHTMLTableAutoId
{
    const ScHTMLTableId mnTableId;          
    ScHTMLTableId&      mrnUnusedId;        

    explicit            ScHTMLTableAutoId( ScHTMLTableId& rnUnusedId );
};

class ScHTMLTableMap;

class ScHTMLTable
{
public:
    explicit            ScHTMLTable(
                            ScHTMLTable& rParentTable,
                            const HtmlImportInfo& rInfo,
                            bool bPreFormText );

    virtual             ~ScHTMLTable();

    const OUString& GetTableName() const { return maTableName; }
    ScHTMLTableId GetTableId() const { return maTableId.mnTableId; }
    ScHTMLSize          GetSpan( const ScHTMLPos& rCellPos ) const;

    ScHTMLTable*        FindNestedTable( ScHTMLTableId nTableId ) const;

    void                PutItem( const SfxPoolItem& rItem );
    void                PutText( const HtmlImportInfo& rInfo );
    void                InsertPara( const HtmlImportInfo& rInfo );

    void                BreakOn();
    void                HeadingOn();
    void                AnchorOn();

    ScHTMLTable*        TableOn( const HtmlImportInfo& rInfo );
    ScHTMLTable*        TableOff( const HtmlImportInfo& rInfo );
    ScHTMLTable*        PreOn( const HtmlImportInfo& rInfo );
    ScHTMLTable*        PreOff( const HtmlImportInfo& rInfo );

    void                RowOn( const HtmlImportInfo& rInfo );
    void                RowOff( const HtmlImportInfo& rInfo );
    void                DataOn( const HtmlImportInfo& rInfo );
    void                DataOff( const HtmlImportInfo& rInfo );

    void                BodyOn( const HtmlImportInfo& rInfo );
    void                BodyOff( const HtmlImportInfo& rInfo );

    ScHTMLTable*        CloseTable( const HtmlImportInfo& rInfo );

    SCCOLROW            GetDocSize( ScHTMLOrient eOrient, SCCOLROW nCellPos ) const;
    SCCOLROW            GetDocSize( ScHTMLOrient eOrient, SCCOLROW nCellBegin, SCCOLROW nCellEnd ) const;
    SCCOLROW            GetDocSize( ScHTMLOrient eOrient ) const;
    ScHTMLSize          GetDocSize( const ScHTMLPos& rCellPos ) const;

    const ScHTMLPos& GetDocPos() const { return maDocBasePos; }
    SCCOLROW            GetDocPos( ScHTMLOrient eOrient, SCCOLROW nCellPos ) const;
    ScHTMLPos           GetDocPos( const ScHTMLPos& rCellPos ) const;

    void                GetDocRange( ScRange& rRange ) const;

    void                ApplyCellBorders( ScDocument* pDoc, const ScAddress& rFirstPos ) const;

    SvNumberFormatter* GetFormatTable();

protected:
    explicit            ScHTMLTable(
                            SfxItemPool& rPool,
                            EditEngine& rEditEngine,
                            std::vector<std::shared_ptr<ScEEParseEntry>>& rEEParseList,
                            ScHTMLTableId& rnUnusedId, ScHTMLParser* pParser );

    void                FillEmptyCells();
    void                RecalcDocSize();
    void                RecalcDocPos( const ScHTMLPos& rBasePos );

private:
    typedef ::std::unique_ptr< ScHTMLTableMap >         ScHTMLTableMapPtr;
    typedef ::std::unique_ptr< SfxItemSet >             SfxItemSetPtr;
    typedef ::std::vector< SCCOLROW >                   ScSizeVec;
    typedef ::std::vector< ScHTMLEntry* >               ScHTMLEntryVector;
    typedef ::std::unique_ptr< ScHTMLEntry >            ScHTMLEntryPtr;

    bool                IsEmptyCell() const;
    const SfxItemSet&   GetCurrItemSet() const;

    static bool         IsSpaceCharInfo( const HtmlImportInfo& rInfo );

    ScHTMLEntryPtr      CreateEntry() const;
    void                CreateNewEntry( const HtmlImportInfo& rInfo );

    void                InsertLeadingEmptyLine();

    void                ImplPushEntryToVector( ScHTMLEntryVector& rEntryVector, ScHTMLEntryPtr& rxEntry );
    bool                PushEntry( ScHTMLEntryPtr& rxEntry );
    bool                PushEntry( const HtmlImportInfo& rInfo, bool bLastInCell = false );
    void                PushTableEntry( ScHTMLTableId nTableId );

    ScHTMLTable*        GetExistingTable( ScHTMLTableId nTableId ) const;
    ScHTMLTable*        InsertNestedTable( const HtmlImportInfo& rInfo, bool bPreFormText );

    void                InsertNewCell( const ScHTMLSize& rSpanSize );

    void                ImplRowOn();
    void                ImplRowOff();
    void                ImplDataOn( const ScHTMLSize& rSpanSize );
    void                ImplDataOff();

    static void         ProcessFormatOptions( SfxItemSet& rItemSet, const HtmlImportInfo& rInfo );

    void                SetDocSize( ScHTMLOrient eOrient, SCCOLROW nCellPos, SCCOLROW nSize );
    void                CalcNeededDocSize(
                            ScHTMLOrient eOrient, SCCOLROW nCellPos,
                            SCCOLROW nCellSpan, SCCOLROW nRealDocSize );

private:
    ScHTMLTable*        mpParentTable;      
    ScHTMLTableMapPtr   mxNestedTables;     
    OUString       maTableName;        
    ScHTMLTableAutoId   maTableId;          
    SfxItemSet          maTableItemSet;     
    SfxItemSetPtr       mxRowItemSet;       
    SfxItemSetPtr       mxDataItemSet;      
    ScRangeList         maHMergedCells;     
    ScRangeList         maVMergedCells;     
    ScRangeList         maUsedCells;        
    EditEngine&         mrEditEngine;       
    std::vector<std::shared_ptr<ScEEParseEntry>>& mrEEParseList;      
    std::map< ScHTMLPos, ScHTMLEntryVector >      maEntryMap;         
    ScHTMLEntryVector*  mpCurrEntryVector;  
    ScHTMLEntryPtr      mxCurrEntry;        
    ScSizeVec           maCumSizes[ 2 ];    
    ScHTMLSize          maSize;             
    ScHTMLPos           maCurrCell;         
    ScHTMLPos           maDocBasePos;       
    ScHTMLParser*       mpParser;
    bool                mbBorderOn:1;       
    bool                mbPreFormText:1;    
    bool                mbRowOn:1;          
    bool                mbDataOn:1;         
    bool                mbPushEmptyLine:1;  
};

class ScHTMLGlobalTable : public ScHTMLTable
{
public:
    explicit            ScHTMLGlobalTable(
                            SfxItemPool& rPool,
                            EditEngine& rEditEngine,
                            std::vector<std::shared_ptr<ScEEParseEntry>>& rEEParseList,
                            ScHTMLTableId& rnUnusedId, ScHTMLParser* pParser );

    virtual             ~ScHTMLGlobalTable() override;

    void                Recalc();
};

class ScHTMLQueryParser : public ScHTMLParser
{
public:
    explicit            ScHTMLQueryParser( EditEngine* pEditEngine, ScDocument* pDoc );
    virtual             ~ScHTMLQueryParser() override;

    virtual ErrCode     Read( SvStream& rStrm, const OUString& rBaseURL  ) override;

    virtual const ScHTMLTable* GetGlobalTable() const override;

private:
    void                ProcessToken( const HtmlImportInfo& rInfo );
    void                InsertText( const HtmlImportInfo& rInfo );
    void                FontOn( const HtmlImportInfo& rInfo );

    void                MetaOn( const HtmlImportInfo& rInfo );
    void                TitleOn();
    void                TitleOff( const HtmlImportInfo& rInfo );

    void                TableOn( const HtmlImportInfo& rInfo );
    void                TableOff( const HtmlImportInfo& rInfo );
    void                PreOn( const HtmlImportInfo& rInfo );
    void                PreOff( const HtmlImportInfo& rInfo );

    void                CloseTable( const HtmlImportInfo& rInfo );

    static void         ParseStyle(std::u16string_view rStrm);

    DECL_LINK( HTMLImportHdl, HtmlImportInfo&, void );

private:
    typedef ::std::unique_ptr< ScHTMLGlobalTable >    ScHTMLGlobalTablePtr;

    OUStringBuffer      maTitle;            
    ScHTMLGlobalTablePtr mxGlobTable;       
    ScHTMLTable*        mpCurrTable;        
    ScHTMLTableId       mnUnusedId;         
    bool                mbTitleOn;          
};

#endif

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */