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 .
 */
 
#pragma once
 
#include <memory>
#include <map>
#include <optional>
#include <stack>
#include <string_view>
#include <unordered_map>
#include <utility>
#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, PropsType> NamePropsType;
    typedef ::std::map<OUString, 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( std::shared_ptr<ScEEParseEntry> xE,
                                ScRangeListRef xL, 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(std::move( xL )), xCellEntry(std::move(xE)),
                            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*, OUString aBaseURL, 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,
                            const ScDocument& rDoc );
 
    virtual             ~ScHTMLTable();
 
    const OUString& GetTableName() const { return maTableName; }
    const OUString& GetTableCaption() const { return maCaption; }
    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 );
    void                CaptionOn();
    void                CaptionOff();
    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,
                            const ScDocument& rDoc );
 
    void                FillEmptyCells();
    void                RecalcDocSize();
    void                RecalcDocPos( const ScHTMLPos& rBasePos );
 
private:
    typedef ::std::unique_ptr< ScHTMLTableMap >         ScHTMLTableMapPtr;
    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;        
    OUString            maCaption;          
    OUStringBuffer      maCaptionBuffer;    
    ScHTMLTableAutoId   maTableId;          
    SfxItemSet          maTableItemSet;     
    std::optional<SfxItemSet> moRowItemSet;       
    std::optional<SfxItemSet> moDataItemSet;      
    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;
    const ScDocument&   mrDoc;
    bool                mbBorderOn:1;       
    bool                mbPreFormText:1;    
    bool                mbRowOn:1;          
    bool                mbDataOn:1;         
    bool                mbPushEmptyLine:1;  
    bool                mbCaptionOn:1;      
};
 
class ScHTMLGlobalTable : public ScHTMLTable
{
public:
    explicit            ScHTMLGlobalTable(
                            SfxItemPool& rPool,
                            EditEngine& rEditEngine,
                            std::vector<std::shared_ptr<ScEEParseEntry>>& rEEParseList,
                            ScHTMLTableId& rnUnusedId, ScHTMLParser* pParser,
                            const ScDocument& rDoc );
 
    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 );
 
    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;          
};
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */