    /* -*- 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 .
     */

    #include <sal/config.h>
    #include <sal/log.hxx>

    #include <comphelper/string.hxx>
    #include <tools/solar.h>
    #include <vcl/vclenum.hxx>
    #include <vcl/font.hxx>
    #include <hintids.hxx>
    #include <editeng/colritem.hxx>
    #include <editeng/orphitem.hxx>
    #include <editeng/widwitem.hxx>
    #include <editeng/brushitem.hxx>
    #include <editeng/boxitem.hxx>
    #include <editeng/lrspitem.hxx>
    #include <editeng/ulspitem.hxx>
    #include <editeng/fhgtitem.hxx>
    #include <editeng/hyphenzoneitem.hxx>
    #include <editeng/frmdiritem.hxx>
    #include <editeng/langitem.hxx>
    #include <editeng/charrotateitem.hxx>
    #include <editeng/pgrditem.hxx>
    #include <msfilter.hxx>
    #include <pam.hxx>
    #include <doc.hxx>
    #include <IDocumentStylePoolAccess.hxx>
    #include <docary.hxx>
    #include <ndtxt.hxx>
    #include <paratr.hxx>
    #include <poolfmt.hxx>
    #include <swtable.hxx>
    #include <tblsel.hxx>
    #include <mdiexp.hxx>
    #include <fmtpdsc.hxx>
    #include <txtftn.hxx>
    #include <frmfmt.hxx>
    #include <ftnidx.hxx>
    #include <fmtftn.hxx>
    #include <fmtlsplt.hxx>
    #include <charfmt.hxx>
    #include <SwStyleNameMapper.hxx>
    #include <fltshell.hxx>
    #include <fmtanchr.hxx>
    #include <fmtrowsplt.hxx>
    #include <fmtfollowtextflow.hxx>
    #include <numrule.hxx>
    #include "sprmids.hxx"
    #include <wwstyles.hxx>
    #include "writerhelper.hxx"
    #include "ww8struc.hxx"
    #include "ww8par.hxx"
    #include "ww8par2.hxx"

    #include <frmatr.hxx>
    #include <itabenum.hxx>
    #include <unocrsr.hxx>

    #include <iostream>
    #include <memory>

    using namespace ::com::sun::star;

    WW8TabBandDesc::WW8TabBandDesc()
    {
        memset(this, 0, sizeof(*this));
        for (sal_uInt16 & rn : maDirections)
            rn = 4;
    }

    WW8TabBandDesc::~WW8TabBandDesc()
    {
        delete[] pTCs;
        delete[] pSHDs;
        delete[] pNewSHDs;
    }

    void sw::util::RedlineStack::close( const SwPosition& rPos,
        RedlineType_t eType, WW8TabDesc* pTabDesc )
    {
        // If the redline type is not found in the redline stack, we have to check if there has been
        // a tabledesc and to check its saved redline stack, too. (#136939, #i68139)
        if( !close( rPos, eType ) )
        {
            if( pTabDesc && pTabDesc->getOldRedlineStack() )
            {
                bool const bResult =
                    pTabDesc->getOldRedlineStack()->close(rPos, eType);
                OSL_ENSURE( bResult, "close without open!");
            }
        }
    }

    void wwSectionManager::SetCurrentSectionHasFootnote()
    {
        OSL_ENSURE(!maSegments.empty(),
            "should not be possible, must be at least one segment");
        if (!maSegments.empty())
            maSegments.back().mbHasFootnote = true;
    }

    void wwSectionManager::SetCurrentSectionVerticalAdjustment(const drawing::TextVerticalAdjust nVA)
    {
        OSL_ENSURE(!maSegments.empty(),
            "should not be possible, must be at least one segment");
        if ( !maSegments.empty() )
            maSegments.back().mnVerticalAdjustment = nVA;
    }

    bool wwSectionManager::CurrentSectionIsVertical() const
    {
        OSL_ENSURE(!maSegments.empty(),
            "should not be possible, must be at least one segment");
        if (!maSegments.empty())
            return maSegments.back().IsVertical();
        return false;
    }

    bool wwSectionManager::CurrentSectionIsProtected() const
    {
        OSL_ENSURE(!maSegments.empty(),
            "should not be possible, must be at least one segment");
        if (!maSegments.empty())
            return SectionIsProtected(maSegments.back());
        return false;
    }

    sal_uInt32 wwSectionManager::GetPageLeft() const
    {
        return !maSegments.empty() ? maSegments.back().nPgLeft : 0;
    }

    sal_uInt32 wwSectionManager::GetPageRight() const
    {
        return !maSegments.empty() ? maSegments.back().nPgRight : 0;
    }

    sal_uInt32 wwSectionManager::GetPageWidth() const
    {
        return !maSegments.empty() ? maSegments.back().GetPageWidth() : 0;
    }

    sal_uInt32 wwSectionManager::GetTextAreaWidth() const
    {
        return !maSegments.empty() ? maSegments.back().GetTextAreaWidth() : 0;
    }

    sal_uInt32 wwSectionManager::GetWWPageTopMargin() const
    {
        return !maSegments.empty() ? maSegments.back().maSep.dyaTop : 0;
    }

    sal_uInt16 SwWW8ImplReader::End_Footnote()
    {
        /*
        Ignoring Footnote outside of the normal Text. People will put footnotes
        into field results and field commands.
        */
        if (m_bIgnoreText ||
            m_pPaM->GetPoint()->nNode < m_rDoc.GetNodes().GetEndOfExtras().GetIndex())
        {
            return 0;
        }

        OSL_ENSURE(!m_aFootnoteStack.empty(), "footnote end without start");
        if (m_aFootnoteStack.empty())
            return 0;

        bool bFtEdOk = false;
        const FootnoteDescriptor &rDesc = m_aFootnoteStack.back();

        //Get the footnote character and remove it from the txtnode. We'll
        //replace it with the footnote
        SwTextNode* pText = m_pPaM->GetNode().GetTextNode();
        sal_Int32 nPos = m_pPaM->GetPoint()->nContent.GetIndex();

        OUString sChar;
        SwTextAttr* pFN = nullptr;
        //There should have been a footnote char, we will replace this.
        if (pText && nPos)
        {
            sChar += OUStringLiteral1(pText->GetText()[--nPos]);
            m_pPaM->SetMark();
            --m_pPaM->GetMark()->nContent;
            std::shared_ptr<SwUnoCursor> xLastAnchorCursor(m_pLastAnchorPos ? m_rDoc.CreateUnoCursor(*m_pLastAnchorPos) : nullptr);
            m_pLastAnchorPos.reset();
            m_rDoc.getIDocumentContentOperations().DeleteRange( *m_pPaM );
            m_pPaM->DeleteMark();
            if (xLastAnchorCursor)
                m_pLastAnchorPos.reset(new SwPosition(*xLastAnchorCursor->GetPoint()));
            SwFormatFootnote aFootnote(rDesc.meType == MAN_EDN);
            pFN = pText->InsertItem(aFootnote, nPos, nPos);
        }
        OSL_ENSURE(pFN, "Problems creating the footnote text");
        if (pFN)
        {

            SwPosition aTmpPos( *m_pPaM->GetPoint() );    // remember old cursor position
            WW8PLCFxSaveAll aSave;
            m_xPlcxMan->SaveAllPLCFx( aSave );
            std::shared_ptr<WW8PLCFMan> xOldPlcxMan = m_xPlcxMan;

            const SwNodeIndex* pSttIdx = static_cast<SwTextFootnote*>(pFN)->GetStartNode();
            OSL_ENSURE(pSttIdx, "Problems creating footnote text");

            static_cast<SwTextFootnote*>(pFN)->SetSeqNo( m_rDoc.GetFootnoteIdxs().size() );

            bool bOld = m_bFootnoteEdn;
            m_bFootnoteEdn = true;

            // read content of Ft-/End-Note
            Read_HdFtFootnoteText( pSttIdx, rDesc.mnStartCp, rDesc.mnLen, rDesc.meType);
            bFtEdOk = true;
            m_bFootnoteEdn = bOld;

            OSL_ENSURE(sChar.getLength()==1 && ((rDesc.mbAutoNum == (sChar[0] == 2))),
             "footnote autonumbering must be 0x02, and everything else must not be");

            // If no automatic numbering use the following char from the main text
            // as the footnote number
            if (!rDesc.mbAutoNum)
                static_cast<SwTextFootnote*>(pFN)->SetNumber(0, sChar);

            /*
                Delete the footnote char from the footnote if its at the beginning
                as usual. Might not be if the user has already deleted it, e.g.
                #i14737#
            */
            SwNodeIndex& rNIdx = m_pPaM->GetPoint()->nNode;
            rNIdx = pSttIdx->GetIndex() + 1;
            SwTextNode* pTNd = rNIdx.GetNode().GetTextNode();
            if (pTNd && !pTNd->GetText().isEmpty() && !sChar.isEmpty())
            {
                const OUString &rText = pTNd->GetText();
                if (rText[0] == sChar[0])
                {
                    // Allow MSO to emulate LO footnote text starting at left margin - only meaningful with hanging indent
                    sal_Int32 nFirstLineIndent=0;
                    SfxItemSet aSet( m_rDoc.GetAttrPool(), svl::Items<RES_LR_SPACE, RES_LR_SPACE>{} );
                    if ( pTNd->GetAttr(aSet) )
                    {
                        const SvxLRSpaceItem* pLRSpace = aSet.GetItem<SvxLRSpaceItem>(RES_LR_SPACE);
                        if ( pLRSpace )
                            nFirstLineIndent = pLRSpace->GetTextFirstLineOfst();
                    }

                    m_pPaM->GetPoint()->nContent.Assign( pTNd, 0 );
                    m_pPaM->SetMark();
                    // Strip out aesthetic tabs we may have inserted on export #i24762#
                    if (nFirstLineIndent < 0 && rText.getLength() > 1 && rText[1] == 0x09)
                        ++m_pPaM->GetMark()->nContent;
                    ++m_pPaM->GetMark()->nContent;
                    m_xReffingStck->Delete(*m_pPaM);
                    m_rDoc.getIDocumentContentOperations().DeleteRange( *m_pPaM );
                    m_pPaM->DeleteMark();
                }
            }

            *m_pPaM->GetPoint() = aTmpPos;        // restore Cursor

            m_xPlcxMan = xOldPlcxMan;             // Restore attributes
            m_xPlcxMan->RestoreAllPLCFx( aSave );
        }

        if (bFtEdOk)
            m_aSectionManager.SetCurrentSectionHasFootnote();

        m_aFootnoteStack.pop_back();
        return 0;
    }

    long SwWW8ImplReader::Read_Footnote(WW8PLCFManResult* pRes)
    {
        /*
        Ignoring Footnote outside of the normal Text. People will put footnotes
        into field results and field commands.
        */
        if (m_bIgnoreText ||
            m_pPaM->GetPoint()->nNode < m_rDoc.GetNodes().GetEndOfExtras().GetIndex())
        {
            return 0;
        }

        FootnoteDescriptor aDesc;
        aDesc.mbAutoNum = true;
        if (eEDN == pRes->nSprmId)
        {
            aDesc.meType = MAN_EDN;
            WW8PLCFx_SubDoc* pEndNote = m_xPlcxMan->GetEdn();
            if (const void* pData = pEndNote ? pEndNote->GetData() : nullptr)
                aDesc.mbAutoNum = 0 != *static_cast<short const*>(pData);
        }
        else
        {
            aDesc.meType = MAN_FTN;
            WW8PLCFx_SubDoc* pFootNote = m_xPlcxMan->GetFootnote();
            if (const void* pData = pFootNote ? pFootNote->GetData() : nullptr)
                aDesc.mbAutoNum = 0 != *static_cast<short const*>(pData);
        }

        aDesc.mnStartCp = pRes->nCp2OrIdx;
        aDesc.mnLen = pRes->nMemLen;

        m_aFootnoteStack.push_back(aDesc);

        return 0;
    }

    bool SwWW8ImplReader::SearchRowEnd(WW8PLCFx_Cp_FKP* pPap, WW8_CP &rStartCp,
        int nLevel) const
    {
        WW8PLCFxDesc aRes;
        aRes.pMemPos = nullptr;
        aRes.nEndPos = rStartCp;
        std::set<std::pair<WW8_CP, WW8_CP>> aPrevRes;

        while (pPap->HasFkp() && rStartCp != WW8_CP_MAX)
        {
            if (pPap->Where() != WW8_CP_MAX)
            {
                SprmResult aSprmRes = pPap->HasSprm(TabRowSprm(nLevel));
                const sal_uInt8* pB = aSprmRes.pSprm;
                if (pB && aSprmRes.nRemainingData >= 1 && *pB == 1)
                {
                    aSprmRes = pPap->HasSprm(0x6649);
                    const sal_uInt8 *pLevel = aSprmRes.pSprm;
                    if (pLevel && aSprmRes.nRemainingData >= 1)
                    {
                        if (nLevel + 1 == *pLevel)
                            return true;
                    }
                    else
                    {
                        OSL_ENSURE(!nLevel || pLevel, "sublevel without level sprm");
                        return true;    // RowEnd found
                    }
                }
            }

            aRes.nStartPos = aRes.nEndPos;
            aRes.pMemPos = nullptr;
            //Seek to our next block of properties
            if (!(pPap->SeekPos(aRes.nStartPos)))
            {
                aRes.nEndPos = WW8_CP_MAX;
                pPap->SetDirty(true);
            }
            pPap->GetSprms(&aRes);
            pPap->SetDirty(false);
            auto aBounds(std::make_pair(aRes.nStartPos, aRes.nEndPos));
            if (!aPrevRes.insert(aBounds).second) //already seen these bounds, infinite loop
            {
                SAL_WARN("sw.ww8", "SearchRowEnd, loop in paragraph property chain");
                break;
            }
            //Update our aRes to get the new starting point of the next properties
            rStartCp = aRes.nEndPos;
        }

        return false;
    }

    bool SwWW8ImplReader::SearchTableEnd(WW8PLCFx_Cp_FKP* pPap) const
    {
        if (m_bVer67)
            // The below SPRM is for WW8 only.
            return false;

        WW8PLCFxDesc aRes;
        aRes.pMemPos = nullptr;
        aRes.nEndPos = pPap->Where();
        std::set<std::pair<WW8_CP, WW8_CP>> aPrevRes;

        while (pPap->HasFkp() && pPap->Where() != WW8_CP_MAX)
        {
            // See if the current pap is outside the table.
            SprmResult aSprmRes = pPap->HasSprm(NS_sprm::sprmPFInTable);
            const sal_uInt8* pB = aSprmRes.pSprm;
            if (!pB || aSprmRes.nRemainingData < 1 || *pB != 1)
                // Yes, this is the position after the end of the table.
                return true;

            // It is, so seek to the next pap.
            aRes.nStartPos = aRes.nEndPos;
            aRes.pMemPos = nullptr;
            if (!pPap->SeekPos(aRes.nStartPos))
                return false;

            // Read the sprms and make sure we moved forward to avoid infinite loops.
            pPap->GetSprms(&aRes);
            auto aBounds(std::make_pair(aRes.nStartPos, aRes.nEndPos));
            if (!aPrevRes.insert(aBounds).second) //already seen these bounds, infinite loop
            {
                SAL_WARN("sw.ww8", "SearchTableEnd, loop in paragraph property chain");
                break;
            }
        }

        return false;
    }

    ApoTestResults SwWW8ImplReader::TestApo(int nCellLevel, bool bTableRowEnd,
        const WW8_TablePos *pTabPos)
    {
        const WW8_TablePos *pTopLevelTable = nCellLevel <= 1 ? pTabPos : nullptr;
        ApoTestResults aRet;
        // Frame in Style Definition (word appears to ignore them if inside an
        // text autoshape)
        sal_uInt16 const nStyle(m_xPlcxMan->GetColl());
        if (!m_bTxbxFlySection && nStyle < m_vColl.size())
            aRet.mpStyleApo = StyleExists(nStyle) ? m_vColl[nStyle].m_xWWFly.get() : nullptr;

        /*
        #i1140#
        If I have a table and apply a style to one of its frames that should cause
        a paragraph that it is applied to it to only exist as a separate floating
        frame, then the behaviour depends on which cell that it has been applied
        to. If it is the first cell of a row then the whole table row jumps into the
        new frame, if it isn't then the paragraph attributes are applied
        "except" for the floating frame stuff. i.e. it's ignored. So if there's a
        table, and we're not in the first cell then we ignore the fact that the
        paragraph style wants to be in a different frame.

        This sort of mindbending inconsistency is surely why frames are deprecated
        in word 97 onwards and hidden away from the user

        #i1532# & #i5379#
        If we are already a table in a frame then we must grab the para properties
        to see if we are still in that frame.
        */

        aRet.m_bHasSprm37 = m_xPlcxMan->HasParaSprm(m_bVer67 ? 37 : 0x2423).pSprm != nullptr;
        SprmResult aSrpm29 = m_xPlcxMan->HasParaSprm(m_bVer67 ? 29 : 0x261B);
        const sal_uInt8 *pSrpm29 = aSrpm29.pSprm;
        aRet.m_bHasSprm29 = pSrpm29 != nullptr;
        aRet.m_nSprm29 = (pSrpm29 && aSrpm29.nRemainingData >= 1) ? *pSrpm29 : 0;

        // Is there some frame data here
        bool bNowApo = aRet.HasFrame() || pTopLevelTable;
        if (bNowApo)
        {
            if (WW8FlyPara *pTest = ConstructApo(aRet, pTabPos))
                delete pTest;
            else
                bNowApo = false;
        }

        bool bTestAllowed = !m_bTxbxFlySection && !bTableRowEnd;
        if (bTestAllowed)
        {
            //Test is allowed if there is no table.
            //Otherwise only allowed if we are in the
            //first paragraph of the first cell of a row.
            //(And only if the row we are inside is at the
            //same level as the previous row, think tables
            //in tables)
            if (nCellLevel == m_nInTable)
            {

                if (!m_nInTable)
                    bTestAllowed = true;
                else
                {
                    if (!m_xTableDesc)
                    {
                        OSL_ENSURE(m_xTableDesc.get(), "What!");
                        bTestAllowed = false;
                    }
                    else
                    {
                        // #i39468#
                        // If current cell isn't valid, the test is allowed.
                        // The cell isn't valid, if e.g. there is a new row
                        // <pTableDesc->nCurrentRow> >= <pTableDesc->pTabLines->Count()>
                        bTestAllowed =
                            m_xTableDesc->GetCurrentCol() == 0 &&
                            ( !m_xTableDesc->IsValidCell( m_xTableDesc->GetCurrentCol() ) ||
                              m_xTableDesc->InFirstParaInCell() );
                    }
                }
            }
        }

        if (!bTestAllowed)
            return aRet;

        aRet.mbStartApo = bNowApo && !InEqualOrHigherApo(1); // APO-start
        aRet.mbStopApo = InEqualOrHigherApo(nCellLevel) && !bNowApo;  // APO-end

        //If it happens that we are in a table, then if it's not the first cell
        //then any attributes that might otherwise cause the contents to jump
        //into another frame don't matter, a table row sticks together as one
        //unit no matter what else happens. So if we are not in a table at
        //all, or if we are in the first cell then test that the last frame
        //data is the same as the current one
        if (bNowApo && InEqualApo(nCellLevel))
        {
            // two bordering each other
            if (!TestSameApo(aRet, pTabPos))
                aRet.mbStopApo = aRet.mbStartApo = true;
        }

        return aRet;
    }

    // helper methods for outline, numbering and bullets

    static void SetBaseAnlv(SwNumFormat &rNum, WW8_ANLV const &rAV, sal_uInt8 nSwLevel )
    {
        static const SvxNumType eNumA[8] = { SVX_NUM_ARABIC, SVX_NUM_ROMAN_UPPER, SVX_NUM_ROMAN_LOWER,
            SVX_NUM_CHARS_UPPER_LETTER_N, SVX_NUM_CHARS_LOWER_LETTER_N, SVX_NUM_ARABIC,
            SVX_NUM_ARABIC, SVX_NUM_ARABIC };

        static const SvxAdjust eAdjA[4] = { SvxAdjust::Left,
            SvxAdjust::Right, SvxAdjust::Left, SvxAdjust::Left };
        if (rAV.nfc < 8) {
            rNum.SetNumberingType( eNumA[ rAV.nfc ] );
        } else {
            SvxNumType nType = SVX_NUM_ARABIC;
            switch( rAV.nfc ) {
            case 14:
            case 19:nType = SVX_NUM_FULL_WIDTH_ARABIC; break;
            case 30:nType = SVX_NUM_TIAN_GAN_ZH; break;
            case 31:nType = SVX_NUM_DI_ZI_ZH; break;
            case 35:
            case 36:
            case 37:
            case 39:nType = SVX_NUM_NUMBER_LOWER_ZH; break;
            case 34:nType = SVX_NUM_NUMBER_UPPER_ZH_TW; break;
            case 38:nType = SVX_NUM_NUMBER_UPPER_ZH; break;
            case 10:
            case 11:nType = SVX_NUM_NUMBER_TRADITIONAL_JA; break;
            case 20:nType = SVX_NUM_AIU_FULLWIDTH_JA; break;
            case 12:nType = SVX_NUM_AIU_HALFWIDTH_JA; break;
            case 21:nType = SVX_NUM_IROHA_FULLWIDTH_JA; break;
            case 13:nType = SVX_NUM_IROHA_HALFWIDTH_JA; break;
            case 24:nType = SVX_NUM_HANGUL_SYLLABLE_KO; break;
            case 25:nType = SVX_NUM_HANGUL_JAMO_KO; break;
            case 41:nType = SVX_NUM_NUMBER_HANGUL_KO; break;
            //case 42:
            //case 43:
            case 44:nType = SVX_NUM_NUMBER_UPPER_KO; break;
            default:
                nType= SVX_NUM_ARABIC;break;
            }
            rNum.SetNumberingType( nType );
        }

        if ((rAV.aBits1 & 0x4) >> 2)
        {
            rNum.SetIncludeUpperLevels(nSwLevel + 1);
        }
        rNum.SetStart( SVBT16ToShort( rAV.iStartAt ) );
        rNum.SetNumAdjust( eAdjA[ rAV.aBits1 & 0x3] );

        rNum.SetCharTextDistance( SVBT16ToShort( rAV.dxaSpace ) );
        sal_Int16 nIndent = std::abs(static_cast<sal_Int16>(SVBT16ToShort( rAV.dxaIndent )));
        if( rAV.aBits1 & 0x08 )      //fHang
        {
            rNum.SetFirstLineOffset( -nIndent );
            rNum.SetAbsLSpace( nIndent );
        }
        else
            rNum.SetCharTextDistance( nIndent );        // width of number is missing

        if( rAV.nfc == 5 || rAV.nfc == 7 )
        {
            OUString sP = "." + rNum.GetSuffix();
            rNum.SetSuffix( sP );   // ordinal number
        }
    }

    void SwWW8ImplReader::SetAnlvStrings(SwNumFormat &rNum, WW8_ANLV const &rAV,
        const sal_uInt8* pText, size_t nStart, size_t nElements, bool bOutline)
    {
        if (nStart > nElements)
            return;

        pText += nStart;
        nElements -= nStart;

        bool bInsert = false;                       // Default
        rtl_TextEncoding eCharSet = m_eStructCharSet;

        const WW8_FFN* pF = m_xFonts->GetFont(SVBT16ToShort(rAV.ftc)); // FontInfo
        bool bListSymbol = pF && ( pF->aFFNBase.chs == 2 );      // Symbol/WingDings/...

        OUStringBuffer sText;
        sal_uInt32 nLen = rAV.cbTextBefore + rAV.cbTextAfter;
        if (m_bVer67)
        {
            if (nLen > nElements)
            {
                SAL_WARN("sw.ww8", "SetAnlvStrings: ignoring out of range "
                    << nLen << " vs " << nElements << " max");
                return;
            }
            sText = OUString(reinterpret_cast<char const *>(pText), nLen, eCharSet);
        }
        else
        {
            if (nLen > nElements / 2)
            {
                SAL_WARN("sw.ww8", "SetAnlvStrings: ignoring out of range "
                    << nLen << " vs " << nElements / 2 << " max");
                return;
            }
            for(sal_uInt32 i = 0; i < nLen; ++i, pText += 2)
            {
                sText.append(static_cast<sal_Unicode>(SVBT16ToShort(*reinterpret_cast<SVBT16 const *>(pText))));
            }
        }

        if( bOutline )
        {                             // outline
            if( !rNum.GetIncludeUpperLevels()                          // there are  <= 1 number to show
                || rNum.GetNumberingType() == SVX_NUM_NUMBER_NONE )    // or this level has none
            {
                                                    // if self defined digits
                bInsert = true;                     // then apply character

                // replace by simple Bullet ?
                if( bListSymbol )
                {
                    // use cBulletChar for correct mapping on MAC
                    OUStringBuffer aBuf;
                    comphelper::string::padToLength(aBuf, rAV.cbTextBefore
                        + rAV.cbTextAfter, cBulletChar);
                    sText = aBuf;
                }
            }
        }
        else
        {                                       // numbering / bullets
            bInsert = true;
            if( bListSymbol )
            {
                FontFamily eFamily;
                OUString aName;
                FontPitch ePitch;

                if( GetFontParams( SVBT16ToShort( rAV.ftc ), eFamily, aName,
                                    ePitch, eCharSet ) ){

                    vcl::Font aFont;
                    aFont.SetFamilyName( aName );
                    aFont.SetFamily( eFamily );

                    aFont.SetCharSet( eCharSet );
                    rNum.SetNumberingType(SVX_NUM_CHAR_SPECIAL);

                    rNum.SetBulletFont( &aFont );

                    // take only the very first character
                    if (rAV.cbTextBefore || rAV.cbTextAfter)
                        rNum.SetBulletChar( sText[ 0 ] );
                    else
                        rNum.SetBulletChar( 0x2190 );
                }
            }
        }
        if( bInsert )
        {
            if (rAV.cbTextBefore)
            {
                OUString sP( sText.copy( 0, rAV.cbTextBefore ).makeStringAndClear() );
                rNum.SetPrefix( sP );
            }
            if( rAV.cbTextAfter )
            {
                OUString sP( rNum.GetSuffix() );
                sP += sText.copy( rAV.cbTextBefore, rAV.cbTextAfter).makeStringAndClear();
                rNum.SetSuffix( sP );
            }
    // The characters before and after multiple digits do not apply because
    // those are handled differently by the writer and the result is in most
    // cases worse than without.
        }
    }

    // SetAnld gets a WW-ANLD-Descriptor and a Level and modifies the NumRules
    // which are provided by pNumR. This is used for everything beside
    // outline inside the text.
    void SwWW8ImplReader::SetAnld(SwNumRule* pNumR, WW8_ANLD const * pAD, sal_uInt8 nSwLevel,
        bool bOutLine)
    {
        SwNumFormat aNF;
        if (pAD)
        {                                                       // there is a Anld-Sprm
            m_bCurrentAND_fNumberAcross = 0 != pAD->fNumberAcross;
            WW8_ANLV const &rAV = pAD->eAnlv;
            SetBaseAnlv(aNF, rAV, nSwLevel);                    // set the base format
            SetAnlvStrings(aNF, rAV, pAD->rgchAnld, 0, SAL_N_ELEMENTS(pAD->rgchAnld), bOutLine); // set the rest
        }
        pNumR->Set(nSwLevel, aNF);
    }

    // chapter numbering and bullets

    // Chapter numbering happens in the style definition.
    // Sprm 13 provides the level, Sprm 12 the content.

    SwNumRule* SwWW8ImplReader::GetStyRule()
    {
        if( m_xStyles->mpStyRule )         // Bullet-Style already present
            return m_xStyles->mpStyRule;

        const OUString aBaseName("WW8StyleNum");
        const OUString aName( m_rDoc.GetUniqueNumRuleName( &aBaseName, false) );

        // #i86652#
        sal_uInt16 nRul = m_rDoc.MakeNumRule( aName, nullptr, false,
                                        SvxNumberFormat::LABEL_ALIGNMENT );
        m_xStyles->mpStyRule = m_rDoc.GetNumRuleTable()[nRul];
        // Auto == false-> numbering style
        m_xStyles->mpStyRule->SetAutoRule(false);

        return m_xStyles->mpStyRule;
    }

    // Sprm 13
    void SwWW8ImplReader::Read_ANLevelNo( sal_uInt16, const sal_uInt8* pData, short nLen )
    {
        m_nSwNumLevel = 0xff; // Default: invalid

        if( nLen <= 0 )
            return;

        // StyleDef ?
        if( m_pCurrentColl )
        {
            // only for SwTextFormatColl, not CharFormat
            // WW: 0 = no Numbering
            SwWW8StyInf * pColl = GetStyle(m_nCurrentColl);
            if (pColl != nullptr && pColl->m_bColl && *pData)
            {
                // Range WW:1..9 -> SW:0..8 no bullets / numbering

                if (*pData <= MAXLEVEL && *pData <= 9)
                {
                    m_nSwNumLevel = *pData - 1;
                    if (!m_bNoAttrImport)
                        static_cast<SwTextFormatColl*>(m_pCurrentColl)->AssignToListLevelOfOutlineStyle( m_nSwNumLevel );
                        // For WW-NoNumbering also NO_NUMBERING could be used.
                        // ( For normal numberierung NO_NUM has to be used:
                        //   NO_NUM : pauses numbering,
                        //   NO_NUMBERING : no numbering at all )

                }
                else if( *pData == 10 || *pData == 11 )
                {
                    // remember type, the rest happens at Sprm 12
                    m_xStyles->mnWwNumLevel = *pData;
                }
            }
        }
        else
        {
            //Not StyleDef
            if (!m_bAnl)
                StartAnl(pData);        // begin of outline / bullets
            NextAnlLine(pData);
        }
    }

    void SwWW8ImplReader::Read_ANLevelDesc( sal_uInt16, const sal_uInt8* pData, short nLen ) // Sprm 12
    {
        SwWW8StyInf * pStyInf = GetStyle(m_nCurrentColl);
        if( !m_pCurrentColl || nLen <= 0                       // only for Styledef
            || (pStyInf && !pStyInf->m_bColl)              // ignore  CharFormat ->
            || ( m_nIniFlags & WW8FL_NO_OUTLINE ) )
        {
            m_nSwNumLevel = 0xff;
            return;
        }

        if (static_cast<size_t>(nLen) < sizeof(WW8_ANLD))
        {
            SAL_WARN("sw.ww8", "ANLevelDesc property is " << nLen << " long, needs to be at least " << sizeof(WW8_ANLD));
            m_nSwNumLevel = 0xff;
            return;
        }

        if( m_nSwNumLevel <= MAXLEVEL         // Value range mapping WW:1..9 -> SW:0..8
            && m_nSwNumLevel <= 9 ){          // No Bullets or Numbering

            // If NumRuleItems were set, either directly or through inheritance, disable them now
            m_pCurrentColl->SetFormatAttr( SwNumRuleItem() );

            const OUString aName("Outline");
            SwNumRule aNR( m_rDoc.GetUniqueNumRuleName( &aName ),
                           SvxNumberFormat::LABEL_WIDTH_AND_POSITION,
                           OUTLINE_RULE );
            aNR = *m_rDoc.GetOutlineNumRule();

            SetAnld(&aNR, reinterpret_cast<WW8_ANLD const *>(pData), m_nSwNumLevel, true);

            // Missing Levels need not be replenished
            m_rDoc.SetOutlineNumRule( aNR );
        }else if( m_xStyles->mnWwNumLevel == 10 || m_xStyles->mnWwNumLevel == 11 ){
            SwNumRule* pNR = GetStyRule();
            SetAnld(pNR, reinterpret_cast<WW8_ANLD const *>(pData), 0, false);
            m_pCurrentColl->SetFormatAttr( SwNumRuleItem( pNR->GetName() ) );

            pStyInf = GetStyle(m_nCurrentColl);
            if (pStyInf != nullptr)
                pStyInf->m_bHasStyNumRule = true;
        }
    }

    // Numbering / Bullets

    // SetNumOlst() carries the Numrules for this cell to SwNumFormat.
    // For this the info is fetched from OLST and not from ANLD ( see later )
    // ( only for outline inside text; Bullets / numbering use ANLDs )
    void SwWW8ImplReader::SetNumOlst(SwNumRule* pNumR, WW8_OLST* pO, sal_uInt8 nSwLevel)
    {
        SwNumFormat aNF;
        WW8_ANLV &rAV = pO->rganlv[nSwLevel];
        SetBaseAnlv(aNF, rAV, nSwLevel);
                                                // ... and then the Strings
        int nTextOfs = 0;
        sal_uInt8 i;
        WW8_ANLV* pAV1;                 // search String-Positions
        for (i = 0, pAV1 = pO->rganlv; i < nSwLevel; ++i, ++pAV1)
            nTextOfs += pAV1->cbTextBefore + pAV1->cbTextAfter;

        if (!m_bVer67)
            nTextOfs *= 2;
        SetAnlvStrings(aNF, rAV, pO->rgch, nTextOfs, SAL_N_ELEMENTS(pO->rgch), true); // and apply
        pNumR->Set(nSwLevel, aNF);
    }

    // The OLST is at the beginning of each section that contains outlines.
    // The ANLDs that are connected to each outline-line contain only nonsense,
    // so the OLSTs are remembered for the section to have usable information
    // when outline-paragraphs occur.
    void SwWW8ImplReader::Read_OLST( sal_uInt16, const sal_uInt8* pData, short nLen )
    {
        m_xNumOlst.reset();
        if (nLen <= 0)
            return;

        if (static_cast<size_t>(nLen) < sizeof(WW8_OLST))
        {
            SAL_WARN("sw.ww8", "WW8_OLST property is " << nLen << " long, needs to be at least " << sizeof(WW8_OLST));
            return;
        }

        m_xNumOlst.reset(new WW8_OLST);
        *m_xNumOlst = *reinterpret_cast<WW8_OLST const *>(pData);
    }

    WW8LvlType GetNumType(sal_uInt8 nWwLevelNo)
    {
        WW8LvlType nRet = WW8_None;
        if( nWwLevelNo == 12 )
           nRet = WW8_Pause;
        else if( nWwLevelNo == 10 )
           nRet = WW8_Numbering;
        else if( nWwLevelNo == 11 )
           nRet = WW8_Sequence;
        else if( nWwLevelNo > 0 && nWwLevelNo <= 9 )
           nRet = WW8_Outline;
        return nRet;
    }

    SwNumRule *ANLDRuleMap::GetNumRule(const SwDoc& rDoc, sal_uInt8 nNumType)
    {
        const OUString& rNumRule = WW8_Numbering == nNumType ? msNumberingNumRule : msOutlineNumRule;
        if (rNumRule.isEmpty())
            return nullptr;
        return rDoc.FindNumRulePtr(rNumRule);
    }

    void ANLDRuleMap::SetNumRule(const OUString& rNumRule, sal_uInt8 nNumType)
    {
        if (WW8_Numbering == nNumType)
            msNumberingNumRule = rNumRule;
        else
            msOutlineNumRule = rNumRule;
    }

    // StartAnl is called at the beginning of a row area that contains
    // outline / numbering / bullets
    void SwWW8ImplReader::StartAnl(const sal_uInt8* pSprm13)
    {
        m_bCurrentAND_fNumberAcross = false;

        sal_uInt8 nT = static_cast< sal_uInt8 >(GetNumType(*pSprm13));
        if (nT == WW8_Pause || nT == WW8_None)
            return;

        m_nWwNumType = nT;
        SwNumRule *pNumRule = m_aANLDRules.GetNumRule(m_rDoc, m_nWwNumType);

        // check for COL numbering:
        SprmResult aS12; // sprmAnld
        OUString sNumRule;

        if (m_xTableDesc)
        {
            sNumRule = m_xTableDesc->GetNumRuleName();
            if (!sNumRule.isEmpty())
            {
                pNumRule = m_rDoc.FindNumRulePtr(sNumRule);
                if (!pNumRule)
                    sNumRule.clear();
                else
                {
                    // this is ROW numbering ?
                    aS12 = m_xPlcxMan->HasParaSprm(m_bVer67 ? 12 : NS_sprm::LN_PAnld); // sprmAnld
                    if (aS12.pSprm && aS12.nRemainingData >= sal_Int32(sizeof(WW8_ANLD)) && 0 != reinterpret_cast<WW8_ANLD const *>(aS12.pSprm)->fNumberAcross)
                        sNumRule.clear();
                }
            }
        }

        SwWW8StyInf * pStyInf = GetStyle(m_nCurrentColl);
        if (sNumRule.isEmpty() && pStyInf != nullptr &&  pStyInf->m_bHasStyNumRule)
        {
            sNumRule = pStyInf->m_pFormat->GetNumRule().GetValue();
            pNumRule = m_rDoc.FindNumRulePtr(sNumRule);
            if (!pNumRule)
                sNumRule.clear();
        }

        if (sNumRule.isEmpty())
        {
            if (!pNumRule)
            {
                // #i86652#
                pNumRule = m_rDoc.GetNumRuleTable()[
                                m_rDoc.MakeNumRule( sNumRule, nullptr, false,
                                                  SvxNumberFormat::LABEL_ALIGNMENT ) ];
            }
            if (m_xTableDesc)
            {
                if (!aS12.pSprm)
                    aS12 = m_xPlcxMan->HasParaSprm(m_bVer67 ? 12 : NS_sprm::LN_PAnld); // sprmAnld
                if (!aS12.pSprm || aS12.nRemainingData < sal_Int32(sizeof(WW8_ANLD)) || !reinterpret_cast<WW8_ANLD const *>(aS12.pSprm)->fNumberAcross)
                    m_xTableDesc->SetNumRuleName(pNumRule->GetName());
            }
        }

        m_bAnl = true;

        sNumRule = pNumRule ? pNumRule->GetName() : OUString();
        // set NumRules via stack
        m_xCtrlStck->NewAttr(*m_pPaM->GetPoint(),
            SfxStringItem(RES_FLTR_NUMRULE, sNumRule));

        m_aANLDRules.SetNumRule(sNumRule, m_nWwNumType);
    }

    // NextAnlLine() is called once for every row of a
    // outline / numbering / bullet
    void SwWW8ImplReader::NextAnlLine(const sal_uInt8* pSprm13)
    {
        if (!m_bAnl)
            return;

        SwNumRule *pNumRule = m_aANLDRules.GetNumRule(m_rDoc, m_nWwNumType);

        // pNd->UpdateNum without a set of rules crashes at the latest whilst storing as sdw3

        // WW:10 = numbering -> SW:0 & WW:11 = bullets -> SW:0
        if (*pSprm13 == 10 || *pSprm13 == 11)
        {
            m_nSwNumLevel = 0;
            if (pNumRule && !pNumRule->GetNumFormat(m_nSwNumLevel))
            {
                // not defined yet
                // sprmAnld o. 0
                SprmResult aS12 = m_xPlcxMan->HasParaSprm(m_bVer67 ? 12 : NS_sprm::LN_PAnld);
                if (aS12.nRemainingData >= sal_Int32(sizeof(WW8_ANLD)))
                    SetAnld(pNumRule, reinterpret_cast<WW8_ANLD const *>(aS12.pSprm), m_nSwNumLevel, false);
            }
        }
        else if( *pSprm13 > 0 && *pSprm13 <= MAXLEVEL )          // range WW:1..9 -> SW:0..8
        {
            m_nSwNumLevel = *pSprm13 - 1;             // outline
            // undefined
            if (pNumRule && !pNumRule->GetNumFormat(m_nSwNumLevel))
            {
                if (m_xNumOlst)                       // there was a OLST
                {
                    //Assure upper levels are set, #i9556#
                    for (sal_uInt8 nI = 0; nI < m_nSwNumLevel; ++nI)
                    {
                        if (!pNumRule->GetNumFormat(nI))
                            SetNumOlst(pNumRule, m_xNumOlst.get(), nI);
                    }

                    SetNumOlst(pNumRule, m_xNumOlst.get(), m_nSwNumLevel);
                }
                else                                // no Olst -> use Anld
                {
                    // sprmAnld
                    SprmResult aS12 = m_xPlcxMan->HasParaSprm(m_bVer67 ? 12 : NS_sprm::LN_PAnld);
                    if (aS12.nRemainingData >= sal_Int32(sizeof(WW8_ANLD)))
                        SetAnld(pNumRule, reinterpret_cast<WW8_ANLD const *>(aS12.pSprm), m_nSwNumLevel, false);
                }
            }
        }
        else
            m_nSwNumLevel = 0xff;                 // no number

        SwTextNode* pNd = m_pPaM->GetNode().GetTextNode();
        if (!pNd)
            return;

        if (m_nSwNumLevel < MAXLEVEL)
            pNd->SetAttrListLevel( m_nSwNumLevel );
        else
        {
            pNd->SetAttrListLevel(0);
            pNd->SetCountedInList( false );
        }
    }

    void SwWW8ImplReader::StopAllAnl(bool bGoBack)
    {
        //Of course we're not restarting, but we'll make use of our knowledge
        //of the implementation to do it.
        StopAnlToRestart(WW8_None, bGoBack);
    }

    void SwWW8ImplReader::StopAnlToRestart(sal_uInt8 nNewType, bool bGoBack)
    {
        if (bGoBack)
        {
            SwPosition aTmpPos(*m_pPaM->GetPoint());
            m_pPaM->Move(fnMoveBackward, GoInContent);
            m_xCtrlStck->SetAttr(*m_pPaM->GetPoint(), RES_FLTR_NUMRULE);
            *m_pPaM->GetPoint() = aTmpPos;
        }
        else
            m_xCtrlStck->SetAttr(*m_pPaM->GetPoint(), RES_FLTR_NUMRULE);

        m_aANLDRules.msNumberingNumRule.clear();
        /*
         #i18816#
         my take on this problem is that moving either way from an outline to a
         numbering doesn't halt the outline, while the numbering is always halted
        */
        bool bNumberingNotStopOutline =
            (((m_nWwNumType == WW8_Outline) && (nNewType == WW8_Numbering)) ||
            ((m_nWwNumType == WW8_Numbering) && (nNewType == WW8_Outline)));
        if (!bNumberingNotStopOutline)
            m_aANLDRules.msOutlineNumRule.clear();

        m_nSwNumLevel = 0xff;
        m_nWwNumType = WW8_None;
        m_bAnl = false;
    }

    WW8TabBandDesc::WW8TabBandDesc( WW8TabBandDesc const & rBand )
    {
        *this = rBand;
        if( rBand.pTCs )
        {
            pTCs = new WW8_TCell[nWwCols];
            memcpy( pTCs, rBand.pTCs, nWwCols * sizeof( WW8_TCell ) );
        }
        if( rBand.pSHDs )
        {
            pSHDs = new WW8_SHD[nWwCols];
            memcpy( pSHDs, rBand.pSHDs, nWwCols * sizeof( WW8_SHD ) );
        }
        if( rBand.pNewSHDs )
        {
            pNewSHDs = new Color[nWwCols];
            memcpy(pNewSHDs, rBand.pNewSHDs, nWwCols * sizeof(Color));
        }
        memcpy(aDefBrcs, rBand.aDefBrcs, sizeof(aDefBrcs));
    }

    // ReadDef reads the cell position and the borders of a band
    void WW8TabBandDesc::ReadDef(bool bVer67, const sal_uInt8* pS, short nLen)
    {
        if (!bVer67)
        {
            //the ww8 version of this is unusual in masquerading as a a srpm with a
            //single byte len arg while it really has a word len arg, after this
            //increment nLen is correct to describe the remaining amount of data
            pS++;
        }

        --nLen; //reduce len by expected nCols arg
        if (nLen < 0)
            return;
        sal_uInt8 nCols = *pS;                       // number of cells

        if (nCols > MAX_COL)
            return;

        nLen -= 2 * (nCols + 1); //reduce len by claimed amount of next x-borders arguments
        if (nLen < 0)
            return;

        short nOldCols = nWwCols;
        nWwCols = nCols;

        const sal_uInt8* pT = &pS[1];
        for (int i = 0; i <= nCols; i++, pT+=2)
            nCenter[i] = static_cast<sal_Int16>(SVBT16ToShort( pT ));    // X-borders

        if( nCols != nOldCols ) // different column count
        {
            delete[] pTCs;
            pTCs = nullptr;
            delete[] pSHDs;
            pSHDs = nullptr;
            delete[] pNewSHDs;
            pNewSHDs = nullptr;
        }

        short nFileCols = nLen / ( bVer67 ? 10 : 20 );  // really saved

        if (!pTCs && nCols)
        {
            // create empty TCs
            pTCs = new WW8_TCell[nCols];
            setcelldefaults(pTCs,nCols);
        }

        short nColsToRead = std::min<short>(nFileCols, nCols);

        if (nColsToRead > 0)
        {
            // read TCs

            /*
                Attention: Beginning with Ver8 there is an extra ushort per TC
                           added and the size of the border code is doubled.
                           Because of this a simple copy (pTCs[i] = *pTc;)
                           is not possible.
                ---
                Advantage: The work structure suits better.
            */
            WW8_TCell* pCurrentTC  = pTCs;
            if( bVer67 )
            {
                WW8_TCellVer6 const * pTc = reinterpret_cast<WW8_TCellVer6 const *>(pT);
                for (int i = 0; i < nColsToRead; i++, ++pCurrentTC,++pTc)
                {
                    // TC from file ?
                    sal_uInt8 aBits1 = pTc->aBits1Ver6;
                    pCurrentTC->bFirstMerged = sal_uInt8( ( aBits1 & 0x01 ) != 0 );
                    pCurrentTC->bMerged = sal_uInt8( ( aBits1 & 0x02 ) != 0 );
                    pCurrentTC->rgbrc[ WW8_TOP ]
                        = WW8_BRCVer9(WW8_BRC( pTc->rgbrcVer6[ WW8_TOP ] ));
                    pCurrentTC->rgbrc[ WW8_LEFT ]
                        = WW8_BRCVer9(WW8_BRC( pTc->rgbrcVer6[ WW8_LEFT ] ));
                    pCurrentTC->rgbrc[ WW8_BOT ]
                        = WW8_BRCVer9(WW8_BRC( pTc->rgbrcVer6[ WW8_BOT ] ));
                    pCurrentTC->rgbrc[ WW8_RIGHT ]
                        = WW8_BRCVer9(WW8_BRC( pTc->rgbrcVer6[ WW8_RIGHT ] ));
                    if(    ( pCurrentTC->bMerged )
                            && ( i > 0             ) )
                    {
                        // Cell merged -> remember
                        //bWWMergedVer6[i] = true;
                        pTCs[i-1].rgbrc[ WW8_RIGHT ]
                            = WW8_BRCVer9(WW8_BRC( pTc->rgbrcVer6[ WW8_RIGHT ] ));
                            // apply right border to previous cell
                            // bExist must not be set to false, because WW
                            // does not count this cells in text boxes....
                    }
                }
            }
            else
            {
                WW8_TCellVer8 const * pTc = reinterpret_cast<WW8_TCellVer8 const *>(pT);
                for (int k = 0; k < nColsToRead; ++k, ++pCurrentTC, ++pTc )
                {
                    sal_uInt16 aBits1 = SVBT16ToShort( pTc->aBits1Ver8 );
                    pCurrentTC->bFirstMerged    = sal_uInt8( ( aBits1 & 0x0001 ) != 0 );
                    pCurrentTC->bMerged         = sal_uInt8( ( aBits1 & 0x0002 ) != 0 );
                    pCurrentTC->bVertical       = sal_uInt8( ( aBits1 & 0x0004 ) != 0 );
                    pCurrentTC->bBackward       = sal_uInt8( ( aBits1 & 0x0008 ) != 0 );
                    pCurrentTC->bRotateFont     = sal_uInt8( ( aBits1 & 0x0010 ) != 0 );
                    pCurrentTC->bVertMerge      = sal_uInt8( ( aBits1 & 0x0020 ) != 0 );
                    pCurrentTC->bVertRestart    = sal_uInt8( ( aBits1 & 0x0040 ) != 0 );
                    pCurrentTC->nVertAlign      = ( ( aBits1 & 0x0180 ) >> 7 );
                    // note: in aBits1 there are 7 bits unused,
                    //       followed by another 16 unused bits

                    pCurrentTC->rgbrc[ WW8_TOP   ] = WW8_BRCVer9(pTc->rgbrcVer8[ WW8_TOP   ]);
                    pCurrentTC->rgbrc[ WW8_LEFT  ] = WW8_BRCVer9(pTc->rgbrcVer8[ WW8_LEFT  ]);
                    pCurrentTC->rgbrc[ WW8_BOT   ] = WW8_BRCVer9(pTc->rgbrcVer8[ WW8_BOT   ]);
                    pCurrentTC->rgbrc[ WW8_RIGHT ] = WW8_BRCVer9(pTc->rgbrcVer8[ WW8_RIGHT ]);
                }
            }

            // #i25071 In '97 text direction appears to be only set using TC properties
            // not with sprmTTextFlow so we need to cycle through the maDirections and
            // double check any non-default directions
            for (int k = 0; k < nCols; ++k)
            {
                if(maDirections[k] == 4)
                {
                    if(pTCs[k].bVertical)
                    {
                        if(pTCs[k].bBackward)
                            maDirections[k] = 3;
                        else
                            maDirections[k] = 1;
                    }
                }
            }
        }
    }

    void WW8TabBandDesc::ProcessSprmTSetBRC(int nBrcVer, const sal_uInt8* pParamsTSetBRC)
    {
        if( !pParamsTSetBRC || !pTCs ) // set one or more cell border(s)
            return;

        sal_uInt8 nitcFirst= pParamsTSetBRC[0];// first col to be changed
        sal_uInt8 nitcLim  = pParamsTSetBRC[1];// (last col to be changed)+1
        sal_uInt8 nFlag    = *(pParamsTSetBRC+2);

        if (nitcFirst >= nWwCols)
            return;

        if (nitcLim > nWwCols)
            nitcLim = nWwCols;

        bool bChangeRight  = (nFlag & 0x08) != 0;
        bool bChangeBottom = (nFlag & 0x04) != 0;
        bool bChangeLeft   = (nFlag & 0x02) != 0;
        bool bChangeTop    = (nFlag & 0x01) != 0;

        WW8_TCell* pCurrentTC  = pTCs + nitcFirst;
        WW8_BRCVer9 brcVer9;
        if( nBrcVer == 6 )
            brcVer9 = WW8_BRCVer9(WW8_BRC(*reinterpret_cast<WW8_BRCVer6 const *>(pParamsTSetBRC+3)));
        else if( nBrcVer == 8 )
            brcVer9 = WW8_BRCVer9(*reinterpret_cast<WW8_BRC const *>(pParamsTSetBRC+3));
        else
            brcVer9 = *reinterpret_cast<WW8_BRCVer9 const *>(pParamsTSetBRC+3);

        for( int i = nitcFirst; i < nitcLim; ++i, ++pCurrentTC )
        {
            if( bChangeTop )
                pCurrentTC->rgbrc[ WW8_TOP   ] = brcVer9;
            if( bChangeLeft )
                pCurrentTC->rgbrc[ WW8_LEFT  ] = brcVer9;
            if( bChangeBottom )
                pCurrentTC->rgbrc[ WW8_BOT   ] = brcVer9;
            if( bChangeRight )
                pCurrentTC->rgbrc[ WW8_RIGHT ] = brcVer9;
        }

    }

    void WW8TabBandDesc::ProcessSprmTTableBorders(int nBrcVer, const sal_uInt8* pParams, sal_uInt16 nParamsLen)
    {
        // sprmTTableBorders
        if( nBrcVer == 6 )
        {
            if (nParamsLen < sizeof(WW8_BRCVer6) * 6)
            {
                SAL_WARN("sw.ww8", "table border property is too short");
                return;
            }
            WW8_BRCVer6 const *pVer6 = reinterpret_cast<WW8_BRCVer6 const *>(pParams);
            for (int i = 0; i < 6; ++i)
                aDefBrcs[i] = WW8_BRCVer9(WW8_BRC(pVer6[i]));
        }
        else if ( nBrcVer == 8 )
        {
            static_assert(sizeof (WW8_BRC) == 4, "this has to match the msword size");
            if (nParamsLen < sizeof(WW8_BRC) * 6)
            {
                SAL_WARN("sw.ww8", "table border property is too short");
                return;
            }
            for( int i = 0; i < 6; ++i )
                aDefBrcs[i] = WW8_BRCVer9(reinterpret_cast<WW8_BRC const *>(pParams)[i]);
        }
        else
        {
            if (nParamsLen < sizeof( aDefBrcs ))
            {
                SAL_WARN("sw.ww8", "table border property is too short");
                return;
            }
            memcpy( aDefBrcs, pParams, sizeof( aDefBrcs ) );
        }
    }

    void WW8TabBandDesc::ProcessSprmTDxaCol(const sal_uInt8* pParamsTDxaCol)
    {
        // sprmTDxaCol (opcode 0x7623) changes the width of cells
        // whose index is within a certain range to be a certain value.

        if( nWwCols && pParamsTDxaCol ) // set one or more cell length(s)
        {
            sal_uInt8 nitcFirst= pParamsTDxaCol[0]; // first col to be changed
            sal_uInt8 nitcLim  = pParamsTDxaCol[1]; // (last col to be changed)+1
            short nDxaCol = static_cast<sal_Int16>(SVBT16ToShort( pParamsTDxaCol + 2 ));

            for( int i = nitcFirst; (i < nitcLim) && (i < nWwCols); i++ )
            {
                const short nOrgWidth  = nCenter[i+1] - nCenter[i];
                const short nDelta = nDxaCol - nOrgWidth;
                for( int j = i+1; j <= nWwCols; j++ )
                {
                    nCenter[j] = nCenter[j] + nDelta;
                }
            }
        }
    }

    void WW8TabBandDesc::ProcessSprmTInsert(const sal_uInt8* pParamsTInsert)
    {
        if( !nWwCols || !pParamsTInsert )        // set one or more cell length(s)
            return;

        sal_uInt8 nitcInsert = pParamsTInsert[0]; // position at which to insert
        if (nitcInsert >= MAX_COL)  // cannot insert into cell outside max possible index
            return;
        sal_uInt8 nctc  = pParamsTInsert[1];      // number of cells
        sal_uInt16 ndxaCol = SVBT16ToShort( pParamsTInsert+2 );

        short nNewWwCols;
        if (nitcInsert > nWwCols)
        {
            nNewWwCols = nitcInsert+nctc;
            //if new count would be outside max possible count, clip it, and calc a new replacement
            //legal nctc
            if (nNewWwCols > MAX_COL)
            {
                nNewWwCols = MAX_COL;
                nctc = ::sal::static_int_cast<sal_uInt8>(nNewWwCols-nitcInsert);
            }
        }
        else
        {
            nNewWwCols = nWwCols+nctc;
            //if new count would be outside max possible count, clip it, and calc a new replacement
            //legal nctc
            if (nNewWwCols > MAX_COL)
            {
                nNewWwCols = MAX_COL;
                nctc = ::sal::static_int_cast<sal_uInt8>(nNewWwCols-nWwCols);
            }
        }

        WW8_TCell *pTC2s = new WW8_TCell[nNewWwCols];
        setcelldefaults(pTC2s, nNewWwCols);

        if (pTCs)
        {
            memcpy( pTC2s, pTCs, nWwCols * sizeof( WW8_TCell ) );
            delete[] pTCs;
        }
        pTCs = pTC2s;

        //If we have to move some cells
        if (nitcInsert <= nWwCols)
        {
            // adjust the left x-position of the dummy at the very end
            nCenter[nWwCols + nctc] = nCenter[nWwCols]+nctc*ndxaCol;
            for( int i = nWwCols-1; i >= nitcInsert; i--)
            {
                // adjust the left x-position
                nCenter[i + nctc] = nCenter[i]+nctc*ndxaCol;

                // adjust the cell's borders
                pTCs[i + nctc] = pTCs[i];
            }
        }

        //if itcMac is larger than full size, fill in missing ones first
        for( int i = nWwCols; i > nitcInsert+nWwCols; i--)
            nCenter[i] = i ? (nCenter[i - 1]+ndxaCol) : 0;

        //now add in our new cells
        for( int j = 0;j < nctc; j++)
            nCenter[j + nitcInsert] = (j + nitcInsert) ? (nCenter[j + nitcInsert -1]+ndxaCol) : 0;

        nWwCols = nNewWwCols;

    }

    void WW8TabBandDesc::ProcessDirection(const sal_uInt8* pParams)
    {
        sal_uInt8 nStartCell = *pParams++;
        sal_uInt8 nEndCell = *pParams++;
        sal_uInt16 nCode = SVBT16ToShort(pParams);

        OSL_ENSURE(nStartCell < nEndCell, "not as I thought");
        OSL_ENSURE(nEndCell < MAX_COL + 1, "not as I thought");
        if (nStartCell > MAX_COL)
            return;
        if (nEndCell > MAX_COL + 1)
            nEndCell = MAX_COL + 1;

        for (;nStartCell < nEndCell; ++nStartCell)
            maDirections[nStartCell] = nCode;
    }

    void WW8TabBandDesc::ProcessSpacing(const sal_uInt8* pParams)
    {
        sal_uInt8 nLen = pParams ? *(pParams - 1) : 0;
        OSL_ENSURE(nLen == 6, "Unexpected spacing len");
        if (nLen != 6)
            return;
        mbHasSpacing=true;
    #if OSL_DEBUG_LEVEL > 0
        sal_uInt8 nWhichCell = *pParams;
        OSL_ENSURE(nWhichCell == 0, "Expected cell to be 0!");
    #endif
        ++pParams; //Skip which cell
        ++pParams; //unknown byte

        sal_uInt8 nSideBits = *pParams++;
        OSL_ENSURE(nSideBits < 0x10, "Unexpected value for nSideBits");
        ++pParams; //unknown byte
        sal_uInt16 nValue =  SVBT16ToShort( pParams );
        for (int i = wwTOP; i <= wwRIGHT; i++)
        {
            switch (nSideBits & (1 << i))
            {
                case 1 << wwTOP:
                    mnDefaultTop = nValue;
                    break;
                case 1 << wwLEFT:
                    mnDefaultLeft = nValue;
                    break;
                case 1 << wwBOTTOM:
                    mnDefaultBottom = nValue;
                    break;
                case 1 << wwRIGHT:
                    mnDefaultRight = nValue;
                    break;
                case 0:
                    break;
                default:
                    OSL_ENSURE(false, "Impossible");
                    break;
            }
        }
    }

    void WW8TabBandDesc::ProcessSpecificSpacing(const sal_uInt8* pParams)
    {
        sal_uInt8 nLen = pParams ? *(pParams - 1) : 0;
        OSL_ENSURE(nLen == 6, "Unexpected spacing len");
        if (nLen != 6)
            return;
        sal_uInt8 nWhichCell = *pParams++;
        OSL_ENSURE(nWhichCell < MAX_COL + 1, "Cell out of range in spacings");
        if (nWhichCell >= MAX_COL + 1)
            return;

        ++pParams; //unknown byte
        sal_uInt8 nSideBits = *pParams++;
        OSL_ENSURE(nSideBits < 0x10, "Unexpected value for nSideBits");
        nOverrideSpacing[nWhichCell] |= nSideBits;

        OSL_ENSURE(nOverrideSpacing[nWhichCell] < 0x10,
            "Unexpected value for nSideBits");
    #if OSL_DEBUG_LEVEL > 0
        sal_uInt8 nUnknown2 = *pParams;
        OSL_ENSURE(nUnknown2 == 0x3, "Unexpected value for spacing2");
    #endif
        ++pParams;
        sal_uInt16 nValue =  SVBT16ToShort( pParams );

        for (int i=0; i < 4; i++)
        {
            if (nSideBits & (1 << i))
                nOverrideValues[nWhichCell][i] = nValue;
        }
    }

    void WW8TabBandDesc::ProcessSprmTDelete(const sal_uInt8* pParamsTDelete)
    {
        if( nWwCols && pParamsTDelete )        // set one or more cell length(s)
        {
            sal_uInt8 nitcFirst= pParamsTDelete[0]; // first col to be deleted
            if (nitcFirst >= nWwCols) // first index to delete from doesn't exist
                return;
            sal_uInt8 nitcLim  = pParamsTDelete[1]; // (last col to be deleted)+1
            if (nitcLim <= nitcFirst) // second index to delete to is not greater than first index
                return;

            /*
             * sprmTDelete causes any rgdxaCenter and rgtc entries whose index is
             * greater than or equal to itcLim to be moved
             */
            int nShlCnt  = nWwCols - nitcLim; // count of cells to be shifted

            if (nShlCnt >= 0) //There exist entries whose index is greater than or equal to itcLim
            {
                WW8_TCell* pCurrentTC  = pTCs + nitcFirst;
                int i = 0;
                while( i < nShlCnt )
                {
                    // adjust the left x-position
                    nCenter[nitcFirst + i] = nCenter[nitcLim + i];

                    // adjust the cell's borders
                    *pCurrentTC = pTCs[ nitcLim + i];

                    ++i;
                    ++pCurrentTC;
                }
                // adjust the left x-position of the dummy at the very end
                nCenter[nitcFirst + i] = nCenter[nitcLim + i];
            }

            short nCellsDeleted = nitcLim - nitcFirst;
            //clip delete request to available number of cells
            if (nCellsDeleted > nWwCols)
                nCellsDeleted = nWwCols;
            nWwCols -= nCellsDeleted;
        }
    }

    // ReadShd reads the background color of a cell
    // ReadDef must be called before
    void WW8TabBandDesc::ReadShd(const sal_uInt8* pS )
    {
        sal_uInt8 nLen = pS ? *(pS - 1) : 0;
        if( !nLen )
            return;

        if( !pSHDs )
        {
            pSHDs = new WW8_SHD[nWwCols];
        }

        short nCount = nLen >> 1;
        if (nCount > nWwCols)
            nCount = nWwCols;

        SVBT16 const * pShd;
        int i;
        for(i=0, pShd = reinterpret_cast<SVBT16 const *>(pS); i<nCount; i++, pShd++ )
            pSHDs[i].SetWWValue( *pShd );
    }

    void WW8TabBandDesc::ReadNewShd(const sal_uInt8* pS, bool bVer67)
    {
        sal_uInt8 nLen = pS ? *(pS - 1) : 0;
        if (!nLen)
            return;

        if (!pNewSHDs)
            pNewSHDs = new Color[nWwCols];

        short nCount = nLen / 10; //10 bytes each
        if (nCount > nWwCols)
            nCount = nWwCols;

        int i=0;
        while (i < nCount)
            pNewSHDs[i++] = SwWW8ImplReader::ExtractColour(pS, bVer67);

        while (i < nWwCols)
            pNewSHDs[i++] = COL_AUTO;
    }

    void WW8TabBandDesc::setcelldefaults(WW8_TCell *pCells, short nCols)
    {
        memset(static_cast<void*>(pCells), 0, nCols * sizeof(WW8_TCell));
    }

    namespace
    {
        SprmResult HasTabCellSprm(WW8PLCFx_Cp_FKP* pPap, bool bVer67)
        {
            if (bVer67)
                return pPap->HasSprm(24);
            SprmResult aRes = pPap->HasSprm(0x244B);
            if (aRes.pSprm == nullptr)
                aRes = pPap->HasSprm(0x2416);
            return aRes;
        }
    }

    enum wwTableSprm
    {
        sprmNil,

        sprmTTableWidth, sprmTTextFlow, sprmTFCantSplit, sprmTJc, sprmTFBiDi,
        sprmTDefTable, sprmTDyaRowHeight, sprmTDefTableShd, sprmTDxaLeft,
        sprmTSetBrc, sprmTSetBrc90, sprmTDxaCol, sprmTInsert, sprmTDelete,
        sprmTTableHeader, sprmTDxaGapHalf, sprmTTableBorders, sprmTTableBorders90,
        sprmTDefTableNewShd, sprmTCellPadding, sprmTCellPaddingDefault
    };

    wwTableSprm GetTableSprm(sal_uInt16 nId, ww::WordVersion eVer)
    {
        switch (eVer)
        {
            case ww::eWW8:
                switch (nId)
                {
                    case NS_sprm::sprmTTableWidth:
                        return sprmTTableWidth;
                    case NS_sprm::sprmTTextFlow:
                        return sprmTTextFlow;
                    case NS_sprm::sprmTTableHeader:
                        return sprmTTableHeader;
                    case NS_sprm::sprmTFCantSplit:
                        return sprmTFCantSplit;
                    case NS_sprm::sprmTJc90:
                        return sprmTJc;
                    case NS_sprm::sprmTFBiDi:
                        return sprmTFBiDi;
                    case NS_sprm::sprmTDelete:
                        return sprmTDelete;
                    case NS_sprm::sprmTInsert:
                        return sprmTInsert;
                    case NS_sprm::sprmTDxaCol:
                        return sprmTDxaCol;
                    case NS_sprm::sprmTDyaRowHeight:
                        return sprmTDyaRowHeight;
                    case NS_sprm::sprmTDxaLeft:
                        return sprmTDxaLeft;
                    case NS_sprm::sprmTDxaGapHalf:
                        return sprmTDxaGapHalf;
                    case NS_sprm::sprmTTableBorders80:
                        return sprmTTableBorders;
                    case NS_sprm::sprmTDefTable:
                        return sprmTDefTable;
                    case NS_sprm::sprmTDefTableShd80:
                        return sprmTDefTableShd;
                    case NS_sprm::sprmTDefTableShd:
                        return sprmTDefTableNewShd;
                    case NS_sprm::sprmTTableBorders:
                        return sprmTTableBorders90;
                    case NS_sprm::sprmTSetBrc80:
                        return sprmTSetBrc;
                    case NS_sprm::sprmTSetBrc:
                        return sprmTSetBrc90;
                    case NS_sprm::sprmTCellPadding:
                        return sprmTCellPadding;
                    case NS_sprm::sprmTCellPaddingDefault:
                        return sprmTCellPaddingDefault;
                }
                break;
            case ww::eWW7:
            case ww::eWW6:
                switch (nId)
                {
                    case 182:
                        return sprmTJc;
                    case 183:
                        return sprmTDxaLeft;
                    case 184:
                        return sprmTDxaGapHalf;
                    case 186:
                        return sprmTTableHeader;
                    case 187:
                        return sprmTTableBorders;
                    case 189:
                        return sprmTDyaRowHeight;
                    case 190:
                        return sprmTDefTable;
                    case 191:
                        return sprmTDefTableShd;
                    case 193:
                        return sprmTSetBrc;
                    case 194:
                        return sprmTInsert;
                    case 195:
                        return sprmTDelete;
                    case 196:
                        return sprmTDxaCol;
                }
                break;
            case ww::eWW1:
            case ww::eWW2:
                switch (nId)
                {
                    case 146:
                        return sprmTJc;
                    case 147:
                        return sprmTDxaLeft;
                    case 148:
                        return sprmTDxaGapHalf;
                    case 153:
                        return sprmTDyaRowHeight;
                    case 154:
                        return sprmTDefTable;
                    case 155:
                        return sprmTDefTableShd;
                    case 157:
                        return sprmTSetBrc;
                    case 158:
                        return sprmTInsert;
                    case 159:
                        return sprmTDelete;
                    case 160:
                        return sprmTDxaCol;
                }
                break;
        }
        return sprmNil;
    }

    WW8TabDesc::WW8TabDesc(SwWW8ImplReader* pIoClass, WW8_CP nStartCp) :
        m_pIo(pIoClass),
        m_pFirstBand(nullptr),
        m_pActBand(nullptr),
        m_pTableNd(nullptr),
        m_pTabLines(nullptr),
        m_pTabLine(nullptr),
        m_pTabBoxes(nullptr),
        m_pTabBox(nullptr),
        m_pCurrentWWCell(nullptr),
        m_nRows(0),
        m_nDefaultSwCols(0),
        m_nBands(0),
        m_nMinLeft(0),
        m_nConvertedLeft(0),
        m_nMaxRight(0),
        m_nSwWidth(0),
        m_nPreferredWidth(0),
        m_nPercentWidth(0),
        m_bOk(true),
        m_bClaimLineFormat(false),
        m_eOri(text::HoriOrientation::NONE),
        m_bIsBiDi(false),
        m_nCurrentRow(0),
        m_nCurrentBandRow(0),
        m_nCurrentCol(0),
        m_nRowsToRepeat(0),
        m_pTable(nullptr),
        m_pParentPos(nullptr),
        m_pFlyFormat(nullptr),
        m_aItemSet(m_pIo->m_rDoc.GetAttrPool(),svl::Items<RES_FRMATR_BEGIN,RES_FRMATR_END-1>{})
    {
        m_pIo->m_bCurrentAND_fNumberAcross = false;

        static const sal_Int16 aOriArr[] =
        {
            text::HoriOrientation::LEFT, text::HoriOrientation::CENTER, text::HoriOrientation::RIGHT, text::HoriOrientation::CENTER
        };

        bool bOldVer = ww::IsSevenMinus(m_pIo->GetFib().GetFIBVersion());
        WW8_TablePos aTabPos;

        WW8PLCFxSave1 aSave;
        m_pIo->m_xPlcxMan->GetPap()->Save( aSave );

        WW8PLCFx_Cp_FKP* pPap = m_pIo->m_xPlcxMan->GetPapPLCF();

        m_eOri = text::HoriOrientation::LEFT;

        WW8TabBandDesc* pNewBand = new WW8TabBandDesc;

        wwSprmParser aSprmParser(m_pIo->GetFib());

        // process pPap until end of table found
        do
        {
            short nTabeDxaNew      = SHRT_MAX;
            bool bTabRowJustRead   = false;
            const sal_uInt8* pShadeSprm = nullptr;
            const sal_uInt8* pNewShadeSprm = nullptr;
            const sal_uInt8* pTableBorders = nullptr;
            sal_uInt16 nTableBordersLen = 0;
            const sal_uInt8* pTableBorders90 = nullptr;
            sal_uInt16 nTableBorders90Len = 0;
            std::vector<const sal_uInt8*> aTSetBrcs, aTSetBrc90s;
            WW8_TablePos *pTabPos  = nullptr;

            // search end of a tab row
            if(!(m_pIo->SearchRowEnd(pPap, nStartCp, m_pIo->m_nInTable)))
            {
                m_bOk = false;
                break;
            }

            // Get the SPRM chains:
            // first from PAP and then from PCD (of the Piece Table)
            WW8PLCFxDesc aDesc;
            pPap->GetSprms( &aDesc );
            WW8SprmIter aSprmIter(aDesc.pMemPos, aDesc.nSprmsLen, aSprmParser);

            for (int nLoop = 0; nLoop < 2; ++nLoop)
            {
                const sal_uInt8* pParams;
                while (aSprmIter.GetSprms() && nullptr != (pParams = aSprmIter.GetCurrentParams()))
                {
                    sal_uInt16 nId = aSprmIter.GetCurrentId();
                    sal_uInt16 nFixedLen = aSprmParser.DistanceToData(nId);
                    sal_uInt16 nL = aSprmParser.GetSprmSize(nId, aSprmIter.GetSprms(), aSprmIter.GetRemLen());
                    sal_uInt16 nLen = nL - nFixedLen;
                    wwTableSprm eSprm = GetTableSprm(nId, m_pIo->GetFib().GetFIBVersion());
                    switch (eSprm)
                    {
                        case sprmTTableWidth:
                            {
                            const sal_uInt8 b0 = pParams[0];
                            const sal_uInt8 b1 = pParams[1];
                            const sal_uInt8 b2 = pParams[2];
                            if (b0 == 3) // Twips
                                m_nPreferredWidth = b2 * 0x100 + b1;
                            else if (b0 == 2) // percent in fiftieths of a percent
                            {
                                m_nPercentWidth = (b2 * 0x100 + b1);
                                // MS documentation: non-negative, and 600% max
                                if ( m_nPercentWidth >= 0 && m_nPercentWidth <= 30000 )
                                    m_nPercentWidth *= .02;
                                else
                                    m_nPercentWidth = 100;
                            }
                            }
                            break;
                        case sprmTTextFlow:
                            pNewBand->ProcessDirection(pParams);
                            break;
                        case sprmTFCantSplit:
                            pNewBand->bCantSplit = *pParams;
                            m_bClaimLineFormat = true;
                            break;
                        case sprmTTableBorders:
                            pTableBorders = pParams; // process at end
                            nTableBordersLen = nLen;
                            break;
                        case sprmTTableBorders90:
                            pTableBorders90 = pParams; // process at end
                            nTableBorders90Len = nLen;
                            break;
                        case sprmTTableHeader:
                            // tdf#105570
                            if ( m_nRowsToRepeat == m_nRows )
                                m_nRowsToRepeat = (m_nRows + 1);
                            break;
                        case sprmTJc:
                            // sprmTJc  -  Justification Code
                            if (m_nRows == 0)
                                m_eOri = aOriArr[*pParams & 0x3];
                            break;
                        case sprmTFBiDi:
                            m_bIsBiDi = SVBT16ToShort(pParams) != 0;
                            break;
                        case sprmTDxaGapHalf:
                            pNewBand->nGapHalf = static_cast<sal_Int16>(SVBT16ToShort( pParams ));
                            break;
                        case sprmTDyaRowHeight:
                            pNewBand->nLineHeight = static_cast<sal_Int16>(SVBT16ToShort( pParams ));
                            m_bClaimLineFormat = true;
                            break;
                        case sprmTDefTable:
                            pNewBand->ReadDef(bOldVer, pParams, nLen);
                            bTabRowJustRead = true;
                            break;
                        case sprmTDefTableShd:
                            pShadeSprm = pParams;
                            break;
                        case sprmTDefTableNewShd:
                            pNewShadeSprm = pParams;
                            break;
                        case sprmTDxaLeft:
                            // our Writer cannot shift single table lines
                            // horizontally so we have to find the smallest
                            // parameter (meaning the left-most position) and then
                            // shift the whole table to that margin (see below)
                            {
                                short nDxaNew = static_cast<sal_Int16>(SVBT16ToShort( pParams ));
                                if( nDxaNew < nTabeDxaNew )
                                    nTabeDxaNew = nDxaNew;
                            }
                            break;
                        case sprmTSetBrc:
                            aTSetBrcs.push_back(pParams); // process at end
                            break;
                        case sprmTSetBrc90:
                            aTSetBrc90s.push_back(pParams); // process at end
                            break;
                        case sprmTDxaCol:
                            pNewBand->ProcessSprmTDxaCol(pParams);
                            break;
                        case sprmTInsert:
                            pNewBand->ProcessSprmTInsert(pParams);
                            break;
                        case sprmTDelete:
                            pNewBand->ProcessSprmTDelete(pParams);
                            break;
                        case sprmTCellPaddingDefault:
                            pNewBand->ProcessSpacing(pParams);
                            break;
                        case sprmTCellPadding:
                            pNewBand->ProcessSpecificSpacing(pParams);
                            break;
                        default:
                            ;
                    }
                    aSprmIter.advance();
                }

                if( !nLoop )
                {
                    pPap->GetPCDSprms(  aDesc );
                    aSprmIter.SetSprms( aDesc.pMemPos, aDesc.nSprmsLen );
                }
            }

            // WW-Tables can contain Fly-changes. For this abort tables here
            // and start again. *pPap is still before TabRowEnd, so TestApo()
            // can be called with the last parameter set to false and therefore
            // take effect.

            if (bTabRowJustRead)
            {
                // Some SPRMs need to be processed *after* ReadDef is called
                // so they were saved up until here
                if (pShadeSprm)
                    pNewBand->ReadShd(pShadeSprm);
                if (pNewShadeSprm)
                    pNewBand->ReadNewShd(pNewShadeSprm, bOldVer);
                if (pTableBorders90)
                    pNewBand->ProcessSprmTTableBorders(9, pTableBorders90, nTableBorders90Len);
                else if (pTableBorders)
                    pNewBand->ProcessSprmTTableBorders(bOldVer ? 6 : 8,
                        pTableBorders, nTableBordersLen);
                std::vector<const sal_uInt8*>::const_iterator iter;
                for (iter = aTSetBrcs.begin(); iter != aTSetBrcs.end(); ++iter)
                    pNewBand->ProcessSprmTSetBRC(bOldVer ? 6 : 8, *iter);
                for (iter = aTSetBrc90s.begin(); iter != aTSetBrc90s.end(); ++iter)
                    pNewBand->ProcessSprmTSetBRC(9, *iter);
            }

            if( nTabeDxaNew < SHRT_MAX )
            {
                short* pCenter  = pNewBand->nCenter;
                short firstDxaCenter = *pCenter;
                for( int i = 0; i < pNewBand->nWwCols; i++, ++pCenter )
                {
                    // #i30298# Use sprmTDxaLeft to adjust the left indent
                    // #i40461# Use dxaGapHalf during calculation
                    *pCenter +=
                        (nTabeDxaNew - (firstDxaCenter + pNewBand->nGapHalf));
                }
            }

            if (!m_pActBand)
                m_pActBand = m_pFirstBand = pNewBand;
            else
            {
                m_pActBand->pNextBand = pNewBand;
                m_pActBand = pNewBand;
            }
            m_nBands++;

            pNewBand = new WW8TabBandDesc;

            m_nRows++;
            m_pActBand->nRows++;

            //Seek our pap to its next block of properties
            WW8PLCFxDesc aRes;
            aRes.pMemPos = nullptr;
            aRes.nStartPos = nStartCp;

            if (!(pPap->SeekPos(aRes.nStartPos)))
            {
                aRes.nEndPos = WW8_CP_MAX;
                pPap->SetDirty(true);
            }
            pPap->GetSprms(&aRes);
            pPap->SetDirty(false);

            //Are we at the end of available properties
            if (
                 !pPap->HasFkp() || pPap->Where() == WW8_CP_MAX ||
                 aRes.nStartPos == WW8_CP_MAX
               )
            {
                m_bOk = false;
                break;
            }

            //Are we still in a table cell
            SprmResult aParamsRes = HasTabCellSprm(pPap, bOldVer);
            const sal_uInt8* pParams = aParamsRes.pSprm;
            SprmResult aLevelRes = pPap->HasSprm(0x6649);
            const sal_uInt8 *pLevel = aLevelRes.pSprm;
            // InTable
            if (!pParams || aParamsRes.nRemainingData < 1 || (1 != *pParams) ||
                (pLevel && aLevelRes.nRemainingData >= 1 && (*pLevel <= m_pIo->m_nInTable)))
            {
                break;
            }

            //Get the end of row new table positioning data
            WW8_CP nMyStartCp=nStartCp;
            if (m_pIo->SearchRowEnd(pPap, nMyStartCp, m_pIo->m_nInTable))
                if (m_pIo->ParseTabPos(&aTabPos, pPap))
                    pTabPos = &aTabPos;

            //Move back to this cell
            aRes.pMemPos = nullptr;
            aRes.nStartPos = nStartCp;

            // PlcxMan currently points too far ahead so we need to bring
            // it back to where we are trying to make a table
            m_pIo->m_xPlcxMan->GetPap()->nOrigStartPos = aRes.nStartPos;
            m_pIo->m_xPlcxMan->GetPap()->nCpOfs = aRes.nCpOfs;
            if (!(pPap->SeekPos(aRes.nStartPos)))
            {
                aRes.nEndPos = WW8_CP_MAX;
                pPap->SetDirty(true);
            }
            pPap->GetSprms(&aRes);
            pPap->SetDirty(false);

            //Does this row match up with the last row closely enough to be
            //considered part of the same table
            ApoTestResults aApo = m_pIo->TestApo(m_pIo->m_nInTable + 1, false, pTabPos);

            /*
            ##513##, #79474# If this is not sufficient, then we should look at
            sprmPD{y|x}aAbs as our indicator that the following set of rows is not
            part of this table, but instead is an absolutely positioned table
            outside of this one
            */
            if (aApo.mbStopApo)
                break;
            if (aApo.mbStartApo)
            {
                //if there really is a fly here, and not a "null" fly then break.
                WW8FlyPara *pNewFly = m_pIo->ConstructApo(aApo, pTabPos);
                if (pNewFly)
                    delete pNewFly;
                else
                    break;
            }

            nStartCp = aRes.nEndPos;
        }
        while(true);

        if( m_bOk )
        {
            if( m_pActBand->nRows > 1 )
            {
                // last band has more than 1 cell
                delete pNewBand;
                pNewBand = new WW8TabBandDesc( *m_pActBand ); // create new
                m_pActBand->nRows--;      // because of special treatment of border defaults
                pNewBand->nRows = 1;
                m_pActBand->pNextBand = pNewBand; // append at the end
                m_nBands++;
                pNewBand = nullptr;               // do not delete
            }
            CalcDefaults();
        }
        delete pNewBand;

        m_pIo->m_xPlcxMan->GetPap()->Restore( aSave );
    }

    WW8TabDesc::~WW8TabDesc()
    {
        WW8TabBandDesc* pR = m_pFirstBand;
        while(pR)
        {
            WW8TabBandDesc* pR2 = pR->pNextBand;
            delete pR;
            pR = pR2;
        }

        delete m_pParentPos;
    }

    void WW8TabDesc::CalcDefaults()
    {
        short nMinCols = SHRT_MAX;
        WW8TabBandDesc* pR;

        m_nMinLeft = SHRT_MAX;
        m_nMaxRight = SHRT_MIN;

        /*
        If we are an honestly inline centered table, then the normal rules of
        engagement for left and right margins do not apply. The multiple rows are
        centered regardless of the actual placement of rows, so we cannot have
        mismatched rows as is possible in other configurations.

        e.g. change the example bugdoc in word from text wrapping of none (inline)
        to around (in frame (bApo)) and the table splits into two very disjoint
        rows as the beginning point of each row are very different
        */
        if ((!m_pIo->InLocalApo()) && (m_eOri == text::HoriOrientation::CENTER))
        {
            for (pR = m_pFirstBand; pR; pR = pR->pNextBand)
                for( short i = pR->nWwCols; i >= 0; --i)
                    pR->nCenter[i] = pR->nCenter[i] -  pR->nCenter[0];
        }

        // First loop: find outermost L and R borders
        for( pR = m_pFirstBand; pR; pR = pR->pNextBand )
        {
            if( pR->nCenter[0] < m_nMinLeft )
                m_nMinLeft = pR->nCenter[0];

            // Following adjustment moves a border and then uses it to find width
            // of next cell, so collect current widths, to avoid situation when width
            // adjustment to too narrow cell makes next cell have negative width
            short nOrigWidth[MAX_COL + 1];
            for( short i = 0; i < pR->nWwCols; i++ )
            {
                nOrigWidth[i] = pR->nCenter[i+1] - pR->nCenter[i];
            }

            for( short i = 0; i < pR->nWwCols; i++ )
            {
               /*
                If the margins are so large as to make the displayable
                area inside them smaller than the minimum allowed then adjust the
                width to fit. But only do it if the two cells are not the exact
                same value, if they are then the cell does not really exist and will
                be blended together into the same cell through the use of the
                nTrans(late) array.
                #i28333# If the nGapHalf is greater than the cell width best to ignore it
                */
                int nCellWidth = pR->nCenter[i+1] - pR->nCenter[i];
                if (nCellWidth != nOrigWidth[i])
                {
                    if (nOrigWidth[i] == 0)
                        nCellWidth = 0; // restore zero-width "cell"
                    else if ((pR->nGapHalf >= nCellWidth) && (pR->nGapHalf < nOrigWidth[i]))
                        nCellWidth = pR->nGapHalf + 1; // avoid false ignore
                    else if ((nCellWidth <= 0) && (nOrigWidth[i] > 0))
                        nCellWidth = 1; // minimal non-zero width to minimize distortion
                }
                if (nCellWidth && ((nCellWidth - pR->nGapHalf*2) < MINLAY) && pR->nGapHalf < nCellWidth)
                {
                    nCellWidth = MINLAY + pR->nGapHalf * 2;
                }
                pR->nCenter[i + 1] = pR->nCenter[i] + nCellWidth;
            }

            if( pR->nCenter[pR->nWwCols] > m_nMaxRight )
                m_nMaxRight = pR->nCenter[pR->nWwCols];
        }
        m_nSwWidth = m_nMaxRight - m_nMinLeft;

        // If the table is right aligned we need to align all rows to the
        // row that has the furthest right point

        if(m_eOri == text::HoriOrientation::RIGHT)
        {
            for( pR = m_pFirstBand; pR; pR = pR->pNextBand )
            {
                int adjust = m_nMaxRight - pR->nCenter[pR->nWwCols];
                for( short i = 0; i < pR->nWwCols + 1; i++ )
                {
                    pR->nCenter[i] = static_cast< short >(pR->nCenter[i] + adjust);
                }

            }
        }

        // 2. pass: Detect number of writer columns. This can exceed the count
        // of columns in WW by 2, because SW in contrast to WW does not provide
        // fringed left and right borders and has to fill with empty boxes.
        // Non existent cells can reduce the number of columns.

        // 3. pass: Replace border with defaults if needed
        m_nConvertedLeft = m_nMinLeft;

        short nLeftMaxThickness = 0, nRightMaxThickness=0;
        for( pR = m_pFirstBand ; pR; pR = pR->pNextBand )
        {
            if( !pR->pTCs )
            {
                pR->pTCs = new WW8_TCell[ pR->nWwCols ];
                WW8TabBandDesc::setcelldefaults(pR->pTCs, pR->nWwCols);
            }
            for (int k = 0; k < pR->nWwCols; ++k)
            {
                WW8_TCell& rT = pR->pTCs[k];
                for (int i = 0; i < 4; ++i)
                {
                    if (rT.rgbrc[i].brcType()==0)
                    {
                        // if shadow is set, its invalid
                        int j = i;
                        switch( i )
                        {
                        case 0:
                            // outer top / horizontally inside
                            j = (pR == m_pFirstBand) ? 0 : 4;
                            break;
                        case 1:
                            // outer left / vertically inside
                            j = k ? 5 : 1;
                            break;
                        case 2:
                            // outer bottom  / horizontally inside
                            j = pR->pNextBand ? 4 : 2;
                            break;
                        case 3:
                            // outer right / vertically inside
                            j = (k == pR->nWwCols - 1) ? 3 : 5;
                            break;
                        }
                        // merge with above defaults
                        rT.rgbrc[i] = pR->aDefBrcs[j];
                    }
                }
            }
            if (pR->nWwCols)
            {
                /*
                Similar to graphics and other elements word does not totally
                factor the width of the border into its calculations of size, we
                do so we must adjust out widths and other dimensions to fit.  It
                appears that what occurs is that the last cell's right margin if
                the margin width that is not calculated into winwords table
                dimensions, so in that case increase the table to include the
                extra width of the right margin.
                */
                if ( ! pR->pTCs[pR->nWwCols-1].rgbrc[3].fShadow() )
                {
                    short nThickness = pR->pTCs[pR->nWwCols-1].rgbrc[3].
                        DetermineBorderProperties();
                    pR->nCenter[pR->nWwCols] = pR->nCenter[pR->nWwCols] + nThickness;
                    if (nThickness > nRightMaxThickness)
                        nRightMaxThickness = nThickness;
                }

                /*
                The left space of the table is in nMinLeft, but again this
                does not consider the margin thickness to its left in the
                placement value, so get the thickness of the left border,
                half is placed to the left of the nominal left side, and
                half to the right.
                */
                if ( ! pR->pTCs[0].rgbrc[1].fShadow() )
                {
                    short nThickness = pR->pTCs[0].rgbrc[1].
                        DetermineBorderProperties();
                    if (nThickness > nLeftMaxThickness)
                        nLeftMaxThickness = nThickness;
                }
            }
        }
        m_nSwWidth = m_nSwWidth + nRightMaxThickness;
        m_nMaxRight = m_nMaxRight + nRightMaxThickness;
        m_nConvertedLeft = m_nMinLeft-(nLeftMaxThickness/2);

        for( pR = m_pFirstBand; pR; pR = pR->pNextBand )
        {
            pR->nSwCols = pR->nWwCols;
            pR->bLEmptyCol = pR->nCenter[0] - m_nMinLeft >= MINLAY;
            pR->bREmptyCol = (m_nMaxRight - pR->nCenter[pR->nWwCols] - nRightMaxThickness) >= MINLAY;

            short nAddCols = short(pR->bLEmptyCol) + short(pR->bREmptyCol);
            sal_uInt16 i;
            sal_uInt16 j = ( pR->bLEmptyCol ) ? 1 : 0;
            for (i = 0; i < pR->nWwCols; ++i)
            {
                pR->nTransCell[i] = static_cast<sal_Int8>(j);
                if ( pR->nCenter[i] < pR->nCenter[i+1] )
                {
                    pR->bExist[i] = true;
                    j++;
                }
                else
                {
                    pR->bExist[i] = false;
                    nAddCols--;
                }
            }

            OSL_ENSURE(i,"no columns in row ?");

            /*
            If the last cell was "false" then there is no valid cell following it,
            so the default mapping forward won't work. So map it (and
            contiguous invalid cells backwards to the last valid cell instead.)
            */
            if (i && !pR->bExist[i-1])
            {
                sal_uInt16 k=i-1;
                while (k && !pR->bExist[k])
                    k--;
                for (sal_uInt16 n=k+1;n<i;n++)
                    pR->nTransCell[n] = pR->nTransCell[k];
            }

            pR->nTransCell[i++] = static_cast<sal_Int8>(j++);  // Can exceed by 2 among other
            pR->nTransCell[i] = static_cast<sal_Int8>(j);        // things because of bREmptyCol

            pR->nSwCols = pR->nSwCols + nAddCols;
            if( pR->nSwCols < nMinCols )
                nMinCols = pR->nSwCols;
        }

        if ((m_nMinLeft && !m_bIsBiDi && text::HoriOrientation::LEFT == m_eOri) ||
            (m_nMinLeft != -108 && m_bIsBiDi && text::HoriOrientation::RIGHT == m_eOri)) // Word sets the first nCenter value to -108 when no indent is used
            m_eOri = text::HoriOrientation::LEFT_AND_WIDTH; //  absolutely positioned

        m_nDefaultSwCols = nMinCols;  // because inserting cells is cheaper than merging
        if( m_nDefaultSwCols == 0 )
            m_bOk = false;
        m_pActBand = m_pFirstBand;
        m_nCurrentBandRow = 0;
        OSL_ENSURE( m_pActBand, "pActBand is 0" );
    }

    void WW8TabDesc::SetSizePosition(SwFrameFormat* pFrameFormat)
    {
        SwFrameFormat* pApply = pFrameFormat;
        if (!pApply )
            pApply = m_pTable->GetFrameFormat();
        OSL_ENSURE(pApply,"No frame");
        pApply->SetFormatAttr(m_aItemSet);
        if (pFrameFormat)
        {
            SwFormatFrameSize aSize = pFrameFormat->GetFrameSize();
            aSize.SetHeightSizeType(ATT_MIN_SIZE);
            aSize.SetHeight(MINLAY);
            pFrameFormat->SetFormatAttr(aSize);
            m_pTable->GetFrameFormat()->SetFormatAttr(SwFormatHoriOrient(0,text::HoriOrientation::FULL));
        }
    }

    void wwSectionManager::PrependedInlineNode(const SwPosition &rPos,
        const SwNode &rNode)
    {
        OSL_ENSURE(!maSegments.empty(),
            "should not be possible, must be at least one segment");
        if ((!maSegments.empty()) && (maSegments.back().maStart == rPos.nNode))
            maSegments.back().maStart.Assign(rNode);
    }

    void WW8TabDesc::CreateSwTable()
    {
        ::SetProgressState(m_pIo->m_nProgress, m_pIo->m_pDocShell);   // Update

        // if there is already some content on the Node append new node to ensure
        // that this content remains ABOVE the table
        SwPosition* pPoint = m_pIo->m_pPaM->GetPoint();
        bool bInsNode = pPoint->nContent.GetIndex() != 0;
        bool bSetMinHeight = false;

        /*
         #i8062#
         Set fly anchor to its anchor pos, so that if a table starts immediately
         at this position a new node will be inserted before inserting the table.
        */
        if (!bInsNode && m_pIo->m_pFormatOfJustInsertedApo)
        {
            const SwPosition* pAPos =
                m_pIo->m_pFormatOfJustInsertedApo->GetAnchor().GetContentAnchor();
            if (pAPos && &pAPos->nNode.GetNode() == &pPoint->nNode.GetNode())
            {
                bInsNode = true;
                bSetMinHeight = true;

                SwFormatSurround aSur(m_pIo->m_pFormatOfJustInsertedApo->GetSurround());
                aSur.SetAnchorOnly(true);
                m_pIo->m_pFormatOfJustInsertedApo->SetFormatAttr(aSur);
            }
        }

        if (bSetMinHeight)
        {
            // minimize Fontsize to minimize height growth of the header/footer
            // set font size to 1 point to minimize y-growth of Hd/Ft
            SvxFontHeightItem aSz(20, 100, RES_CHRATR_FONTSIZE);
            m_pIo->NewAttr( aSz );
            m_pIo->m_xCtrlStck->SetAttr(*pPoint, RES_CHRATR_FONTSIZE);
        }

        if (bInsNode)
            m_pIo->AppendTextNode(*pPoint);

        m_xTmpPos.reset(new SwPosition(*m_pIo->m_pPaM->GetPoint()));

        // The table is small: The number of columns is the lowest count of
        // columns of the origin, because inserting is faster than deleting.
        // The number of rows is the count of bands because (identically)
        // rows of a band can be duplicated easy.
        m_pTable = m_pIo->m_rDoc.InsertTable(
                SwInsertTableOptions( SwInsertTableFlags::HeadlineNoBorder, 0 ),
                *m_xTmpPos, m_nBands, m_nDefaultSwCols, m_eOri );

        OSL_ENSURE(m_pTable && m_pTable->GetFrameFormat(), "insert table failed");
        if (!m_pTable || !m_pTable->GetFrameFormat())
            return;

        SwTableNode* pTableNode = m_pTable->GetTableNode();
        OSL_ENSURE(pTableNode, "no table node!");
        if (pTableNode)
        {
            m_pIo->m_aSectionManager.PrependedInlineNode(*m_pIo->m_pPaM->GetPoint(),
                *pTableNode);
        }

        // Check if the node into which the table should be inserted already
        // contains a Pagedesc. If so that Pagedesc would be moved to the
        // row after the table, that would be wrong. So delete and
        // set later to the table format.
        if (SwTextNode *const pNd = m_xTmpPos->nNode.GetNode().GetTextNode())
        {
            if (const SfxItemSet* pSet = pNd->GetpSwAttrSet())
            {
                SfxPoolItem *pSetAttr = nullptr;
                const SfxPoolItem* pItem;
                if (SfxItemState::SET == pSet->GetItemState(RES_BREAK, false, &pItem))
                {
                    pSetAttr = new SvxFormatBreakItem( *static_cast<const SvxFormatBreakItem*>(pItem) );
                    pNd->ResetAttr( RES_BREAK );
                }

                // eventually set the PageDesc/Break now to the table
                if (pSetAttr)
                {
                    m_aItemSet.Put(*pSetAttr);
                    delete pSetAttr;
                }
            }
        }

        // total width of table
        if( m_nMaxRight - m_nMinLeft > MINLAY * m_nDefaultSwCols )
        {
            SwFormatFrameSize aFrameSize(ATT_FIX_SIZE, m_nSwWidth);
            if( m_nPercentWidth )
                aFrameSize.SetWidthPercent(m_nPercentWidth);
            m_pTable->GetFrameFormat()->SetFormatAttr(aFrameSize);
            m_aItemSet.Put(aFrameSize);
        }

        SvxFrameDirectionItem aDirection(
            m_bIsBiDi ? SvxFrameDirection::Horizontal_RL_TB : SvxFrameDirection::Horizontal_LR_TB, RES_FRAMEDIR );
        m_pTable->GetFrameFormat()->SetFormatAttr(aDirection);

        if (text::HoriOrientation::LEFT_AND_WIDTH == m_eOri)
        {
            if (!m_pIo->m_nInTable && m_pIo->InLocalApo() && m_pIo->m_xSFlyPara &&
                m_pIo->m_xSFlyPara->pFlyFormat && GetMinLeft())
            {
                //If we are inside a frame and we have a border, the frames
                //placement does not consider the tables border, which word
                //displays outside the frame, so adjust here.
                SwFormatHoriOrient aHori(m_pIo->m_xSFlyPara->pFlyFormat->GetHoriOrient());
                sal_Int16 eHori = aHori.GetHoriOrient();
                if ((eHori == text::HoriOrientation::NONE) || (eHori == text::HoriOrientation::LEFT) ||
                    (eHori == text::HoriOrientation::LEFT_AND_WIDTH))
                {
                    //With multiple table, use last table settings. Perhaps
                    //the maximum is what word does ?
                    aHori.SetPos(m_pIo->m_xSFlyPara->nXPos + GetMinLeft());
                    aHori.SetHoriOrient(text::HoriOrientation::NONE);
                    m_pIo->m_xSFlyPara->pFlyFormat->SetFormatAttr(aHori);
                }
            }
            else
            {
                //If bApo is set, then this table is being placed in a floating
                //frame, and the frame matches the left and right *lines* of the
                //table, so the space to the left of the table isn't to be used
                //inside the frame, in word the dialog involved greys out the
                //ability to set the margin.
                SvxLRSpaceItem aL( RES_LR_SPACE );

                long nLeft = 0;
                if (!m_bIsBiDi)
                    nLeft = GetMinLeft();
                else
                {
                    const short nTableWidth = m_nPreferredWidth ? m_nPreferredWidth : m_nSwWidth;
                    nLeft = m_pIo->m_aSectionManager.GetTextAreaWidth();
                    nLeft = nLeft - nTableWidth - GetMinLeft();
                }
                aL.SetLeft(nLeft);

                m_aItemSet.Put(aL);
            }
        }

        mxOldRedlineStack = std::move(m_pIo->m_xRedlineStack);
        m_pIo->m_xRedlineStack.reset(new sw::util::RedlineStack(m_pIo->m_rDoc));
    }

    void WW8TabDesc::UseSwTable()
    {
        // init global Vars
        m_pTabLines = &m_pTable->GetTabLines();
        m_nCurrentRow = m_nCurrentCol = m_nCurrentBandRow = 0;

        m_pTableNd  = const_cast<SwTableNode*>((*m_pTabLines)[0]->GetTabBoxes()[0]->
            GetSttNd()->FindTableNode());
        OSL_ENSURE( m_pTableNd, "Where is my table node" );

        // #i69519# - Restrict rows to repeat to a decent value
        if ( m_nRowsToRepeat == static_cast<sal_uInt16>(m_nRows) )
            m_nRowsToRepeat = 1;

        m_pTableNd->GetTable().SetRowsToRepeat( m_nRowsToRepeat );
        // insert extra cells if needed and something like this
        AdjustNewBand();

        WW8DupProperties aDup(m_pIo->m_rDoc, m_pIo->m_xCtrlStck.get());
        m_pIo->m_xCtrlStck->SetAttr(*m_pIo->m_pPaM->GetPoint(), 0, false);

        // now set the correct PaM and prepare first merger group if any
        SetPamInCell(m_nCurrentCol, true);
        aDup.Insert(*m_pIo->m_pPaM->GetPoint());

        m_pIo->m_bWasTabRowEnd = false;
        m_pIo->m_bWasTabCellEnd = false;
    }

    void WW8TabDesc::MergeCells()
    {
        short nRow;

        for (m_pActBand=m_pFirstBand, nRow=0; m_pActBand; m_pActBand=m_pActBand->pNextBand)
        {
            // insert current box into merge group if appropriate.
            // The algorithm must ensure proper row and column order in WW8SelBoxInfo!
            if( m_pActBand->pTCs )
            {
                for( short j = 0; j < m_pActBand->nRows; j++, nRow++ )
                    for( short i = 0; i < m_pActBand->nWwCols; i++ )
                    {
                        WW8SelBoxInfo* pActMGroup = nullptr;

                        // start a new merge group if appropriate

                        OSL_ENSURE(nRow < static_cast<sal_uInt16>(m_pTabLines->size()),
                            "Too few lines, table ended early");
                        if (nRow >= static_cast<sal_uInt16>(m_pTabLines->size()))
                            return;
                        m_pTabLine = (*m_pTabLines)[ nRow ];
                        m_pTabBoxes = &m_pTabLine->GetTabBoxes();

                        sal_uInt16 nCol = m_pActBand->nTransCell[ i ];
                        if (!m_pActBand->bExist[i])
                            continue;
                        OSL_ENSURE(nCol < m_pTabBoxes->size(),
                            "Too few columns, table ended early");
                        if (nCol >= m_pTabBoxes->size())
                            return;
                        m_pTabBox = (*m_pTabBoxes)[nCol];
                        WW8_TCell& rCell = m_pActBand->pTCs[ i ];
                        // is this the left upper cell of a merge group ?

                        bool bMerge = false;
                        if ( rCell.bVertRestart && !rCell.bMerged )
                            bMerge = true;
                        else if (rCell.bFirstMerged && m_pActBand->bExist[i])
                        {
                            // Some tests to avoid merging cells which previously were
                            // declared invalid because of sharing the exact same dimensions
                            // as their previous cell

                            //If there's anything underneath/above we're ok.
                            if (rCell.bVertMerge || rCell.bVertRestart)
                                bMerge = true;
                            else
                            {
                                //If it's a hori merge only, and the only things in
                                //it are invalid cells then it's already taken care
                                //of, so don't merge.
                                for (sal_uInt16 i2 = i+1; i2 < m_pActBand->nWwCols; i2++ )
                                    if (m_pActBand->pTCs[ i2 ].bMerged &&
                                        !m_pActBand->pTCs[ i2 ].bFirstMerged  )
                                    {
                                        if (m_pActBand->bExist[i2])
                                        {
                                            bMerge = true;
                                            break;
                                        }
                                    }
                                    else
                                        break;
                            }
                        }

                        // remove numbering from cells that will be disabled in the merge
                        if( rCell.bVertMerge && !rCell.bVertRestart )
                        {
                            SwPaM aPam( *m_pTabBox->GetSttNd(), 0 );
                            aPam.GetPoint()->nNode++;
                            SwTextNode* pNd = aPam.GetNode().GetTextNode();
                            while( pNd )
                            {
                                pNd->SetCountedInList( false );

                                aPam.GetPoint()->nNode++;
                                pNd = aPam.GetNode().GetTextNode();
                            }
                        }

                        if (bMerge)
                        {
                            short nX1    = m_pActBand->nCenter[ i ];
                            short nWidth = m_pActBand->nWidth[ i ];

                            // 2. create current merge group
                            pActMGroup = new WW8SelBoxInfo( nX1, nWidth );

                            // determine size of new merge group
                            // before inserted the new merge group.
                            // Needed to correctly locked previously created merge groups.
                            // Calculate total width and set
                            short nSizCell = m_pActBand->nWidth[ i ];
                            for (sal_uInt16 i2 = i+1; i2 < m_pActBand->nWwCols; i2++ )
                                if (m_pActBand->pTCs[ i2 ].bMerged &&
                                    !m_pActBand->pTCs[ i2 ].bFirstMerged  )
                                {
                                    nSizCell = nSizCell + m_pActBand->nWidth[ i2 ];
                                }
                                else
                                    break;
                            pActMGroup->nGroupWidth = nSizCell;

                            // locked previously created merge groups,
                            // after determining the size for the new merge group.
                            // 1. If necessary close old merge group(s) that overlap
                            // the X-area of the new group
                            for (;;)
                            {
                                WW8SelBoxInfo* p = FindMergeGroup(
                                    nX1, pActMGroup->nGroupWidth, false );
                                if (p == nullptr)
                                {
                                    break;
                                }
                                p->bGroupLocked = true;
                            }

                            // 3. push to group array
                            m_MergeGroups.push_back(std::unique_ptr<WW8SelBoxInfo>(pActMGroup));
                        }

                        // if necessary add the current box to a merge group
                        // (that can be a newly created or another group)
                        UpdateTableMergeGroup( rCell, pActMGroup, m_pTabBox, i );
                    }
                }
        }
    }

    //There is a limbo area in word at the end of the row marker
    //where properties can live in word, there is no location in
    //writer equivalent, so try and park the cursor in the best
    //match, see #i23022#/#i18644#
    void WW8TabDesc::ParkPaM()
    {
        SwTableBox *pTabBox2 = nullptr;
        short nRow = m_nCurrentRow + 1;
        if (nRow < static_cast<sal_uInt16>(m_pTabLines->size()))
        {
            if (SwTableLine *pLine = (*m_pTabLines)[nRow])
            {
                SwTableBoxes &rBoxes = pLine->GetTabBoxes();
                pTabBox2 = rBoxes.empty() ? nullptr : rBoxes.front();
            }
        }

        if (!pTabBox2 || !pTabBox2->GetSttNd())
        {
            MoveOutsideTable();
            return;
        }

        sal_uLong nSttNd = pTabBox2->GetSttIdx() + 1,
                  nEndNd = pTabBox2->GetSttNd()->EndOfSectionIndex();

        if (m_pIo->m_pPaM->GetPoint()->nNode != nSttNd)
        {
            do
            {
                m_pIo->m_pPaM->GetPoint()->nNode = nSttNd;
            }
            while (m_pIo->m_pPaM->GetNode().GetNodeType() != SwNodeType::Text && ++nSttNd < nEndNd);

            m_pIo->m_pPaM->GetPoint()->nContent.Assign(m_pIo->m_pPaM->GetContentNode(), 0);
            m_pIo->m_rDoc.SetTextFormatColl(*m_pIo->m_pPaM, const_cast<SwTextFormatColl*>(m_pIo->m_pDfltTextFormatColl));
        }
    }

    void WW8TabDesc::MoveOutsideTable()
    {
        OSL_ENSURE(m_xTmpPos.get() && m_pIo, "I've forgotten where the table is anchored");
        if (m_xTmpPos && m_pIo)
            *m_pIo->m_pPaM->GetPoint() = *m_xTmpPos;
    }

    void WW8TabDesc::FinishSwTable()
    {
        m_pIo->m_xRedlineStack->closeall(*m_pIo->m_pPaM->GetPoint());
        m_pIo->m_aFrameRedlines.emplace(std::move(m_pIo->m_xRedlineStack));
        m_pIo->m_xRedlineStack = std::move(mxOldRedlineStack);

        WW8DupProperties aDup(m_pIo->m_rDoc,m_pIo->m_xCtrlStck.get());
        m_pIo->m_xCtrlStck->SetAttr( *m_pIo->m_pPaM->GetPoint(), 0, false);

        MoveOutsideTable();
        m_xTmpPos.reset();

        aDup.Insert(*m_pIo->m_pPaM->GetPoint());

        m_pIo->m_bWasTabRowEnd = false;
        m_pIo->m_bWasTabCellEnd = false;

        m_pIo->m_aInsertedTables.InsertTable(*m_pTableNd, *m_pIo->m_pPaM);

        MergeCells();

        // if needed group cells together that should be merged
        if (!m_MergeGroups.empty())
        {
            // process all merge groups one by one
            for (auto const& groupIt : m_MergeGroups)
            {
                if((1 < groupIt->size()) && groupIt->row(0)[0])
                {
                    SwFrameFormat* pNewFormat = groupIt->row(0)[0]->ClaimFrameFormat();
                    pNewFormat->SetFormatAttr(SwFormatFrameSize(ATT_VAR_SIZE, groupIt->nGroupWidth, 0));
                    const sal_uInt16 nRowSpan = groupIt->rowsCount();
                    for (sal_uInt16 n = 0; n < nRowSpan; ++n)
                    {
                        auto& rRow = groupIt->row(n);
                        for (size_t i = 0; i<rRow.size(); ++i)
                        {
                            const long nRowSpanSet = (n == 0) && (i == 0) ?
                                nRowSpan :
                                (-1 * (nRowSpan - n));
                            SwTableBox* pCurrentBox = rRow[i];
                            pCurrentBox->setRowSpan(nRowSpanSet);

                            if (i == 0)
                                pCurrentBox->ChgFrameFormat(static_cast<SwTableBoxFormat*>(pNewFormat));
                            else
                            {
                                SwFrameFormat* pFormat = pCurrentBox->ClaimFrameFormat();
                                pFormat->SetFormatAttr(SwFormatFrameSize(ATT_VAR_SIZE, 0, 0));
                            }
                        }
                    }
                }
            }
            m_pIo->m_pFormatOfJustInsertedApo = nullptr;
            m_MergeGroups.clear();
        }
    }

    // browse m_MergeGroups, detect the index of the first fitting group or -1 otherwise

    // Parameter: nXcenter  = center position of asking box
    //            nWidth    = width of asking box
    //            bExact    = flag, if box has to fit into group
    //                              or only has to touch

    WW8SelBoxInfo* WW8TabDesc::FindMergeGroup(short nX1, short nWidth, bool bExact)
    {
        if (!m_MergeGroups.empty())
        {
            // still valid area near the boundery
            const short nTolerance = 4;
            // box boundery
            short nX2 = nX1 + nWidth;
            // approximate group boundery
            short nGrX1;
            short nGrX2;

            // improvement: search backwards
            for (short iGr = m_MergeGroups.size() - 1; iGr >= 0; --iGr)
            {
                // the currently inspected group
                WW8SelBoxInfo& rActGroup = *m_MergeGroups[ iGr ];
                if (!rActGroup.bGroupLocked)
                {
                    // approximate group boundery with room (tolerance) to the *outside*
                    nGrX1 = rActGroup.nGroupXStart - nTolerance;
                    nGrX2 = rActGroup.nGroupXStart
                            + rActGroup.nGroupWidth + nTolerance;

                    // If box fits report success

                    if( ( nX1 > nGrX1 ) && ( nX2 < nGrX2 ) )
                    {
                        return &rActGroup;
                    }

                    // does the box share areas with the group?

                    if( !bExact )
                    {
                        // successful if nX1 *or* nX2 are inside the group
                        if(    (     ( nX1 > nGrX1 )
                                            && ( nX1 < nGrX2 - 2*nTolerance ) )
                                || (     ( nX2 > nGrX1 + 2*nTolerance )
                                            && ( nX2 < nGrX2 ) )
                                // or nX1 and nX2 surround the group
                                || (     ( nX1 <=nGrX1 )
                                            && ( nX2 >=nGrX2 ) ) )
                        {
                            return &rActGroup;
                        }
                    }
                }
            }
        }
        return nullptr;
    }

    bool WW8TabDesc::IsValidCell(short nCol) const
    {
        return (static_cast<size_t>(nCol) < SAL_N_ELEMENTS(m_pActBand->bExist)) &&
               m_pActBand->bExist[nCol] &&
               static_cast<sal_uInt16>(m_nCurrentRow) < m_pTabLines->size();
    }

    bool WW8TabDesc::InFirstParaInCell() const
    {
        //e.g. #i19718#
        if (!m_pTabBox || !m_pTabBox->GetSttNd())
        {
            OSL_FAIL("Problem with table");
            return false;
        }

        if (!IsValidCell(GetCurrentCol()))
            return false;

        return m_pIo->m_pPaM->GetPoint()->nNode == m_pTabBox->GetSttIdx() + 1;
    }

    void WW8TabDesc::StartMiserableHackForUnsupportedDirection(short nWwCol)
    {
        OSL_ENSURE(m_pActBand, "Impossible");
        if (m_pActBand && nWwCol <= MAX_COL && m_pActBand->maDirections[nWwCol] == 3)
        {
            m_pIo->m_xCtrlStck->NewAttr(*m_pIo->m_pPaM->GetPoint(),
                SvxCharRotateItem(900, false, RES_CHRATR_ROTATE));
        }
    }

    void WW8TabDesc::EndMiserableHackForUnsupportedDirection(short nWwCol)
    {
        OSL_ENSURE(m_pActBand, "Impossible");
        if (m_pActBand && nWwCol <= MAX_COL && m_pActBand->maDirections[nWwCol] == 3)
            m_pIo->m_xCtrlStck->SetAttr(*m_pIo->m_pPaM->GetPoint(), RES_CHRATR_ROTATE);
    }

    void WW8TabDesc::SetPamInCell(short nWwCol, bool bPam)
    {
        OSL_ENSURE( m_pActBand, "pActBand is 0" );
        if (!m_pActBand)
            return;

        sal_uInt16 nCol = m_pActBand->transCell(nWwCol);

        if (static_cast<sal_uInt16>(m_nCurrentRow) >= m_pTabLines->size())
        {
            OSL_ENSURE(false, "Actual row bigger than expected." );
            if (bPam)
                MoveOutsideTable();
            return;
        }

        m_pTabLine = (*m_pTabLines)[m_nCurrentRow];
        m_pTabBoxes = &m_pTabLine->GetTabBoxes();

        if (nCol >= m_pTabBoxes->size())
        {
            if (bPam)
            {
                // The first paragraph in a cell with upper autospacing has upper
                // spacing set to 0
                if (
                     m_pIo->m_bParaAutoBefore && m_pIo->m_bFirstPara &&
                     !m_pIo->m_xWDop->fDontUseHTMLAutoSpacing
                   )
                {
                    m_pIo->SetUpperSpacing(*m_pIo->m_pPaM, 0);
                }

                // The last paragraph in a cell with lower autospacing has lower
                // spacing set to 0
                if (m_pIo->m_bParaAutoAfter && !m_pIo->m_xWDop->fDontUseHTMLAutoSpacing)
                    m_pIo->SetLowerSpacing(*m_pIo->m_pPaM, 0);

                ParkPaM();
            }
            return;
        }
        m_pTabBox = (*m_pTabBoxes)[nCol];
        if( !m_pTabBox->GetSttNd() )
        {
            OSL_ENSURE(m_pTabBox->GetSttNd(), "Problems building the table");
            if (bPam)
                MoveOutsideTable();
            return;
        }
        if (bPam)
        {
            m_pCurrentWWCell = &m_pActBand->pTCs[ nWwCol ];

           // The first paragraph in a cell with upper autospacing has upper spacing set to 0
            if(m_pIo->m_bParaAutoBefore && m_pIo->m_bFirstPara && !m_pIo->m_xWDop->fDontUseHTMLAutoSpacing)
                m_pIo->SetUpperSpacing(*m_pIo->m_pPaM, 0);

            // The last paragraph in a cell with lower autospacing has lower spacing set to 0
            if(m_pIo->m_bParaAutoAfter && !m_pIo->m_xWDop->fDontUseHTMLAutoSpacing)
                m_pIo->SetLowerSpacing(*m_pIo->m_pPaM, 0);

            //We need to set the pPaM on the first cell, invalid
            //or not so that we can collect paragraph properties over
            //all the cells, but in that case on the valid cell we do not
            //want to reset the fmt properties
            sal_uLong nSttNd = m_pTabBox->GetSttIdx() + 1,
                      nEndNd = m_pTabBox->GetSttNd()->EndOfSectionIndex();
            if (m_pIo->m_pPaM->GetPoint()->nNode != nSttNd)
            {
                do
                {
                    m_pIo->m_pPaM->GetPoint()->nNode = nSttNd;
                }
                while (m_pIo->m_pPaM->GetNode().GetNodeType() != SwNodeType::Text && ++nSttNd < nEndNd);
                m_pIo->m_pPaM->GetPoint()->nContent.Assign(m_pIo->m_pPaM->GetContentNode(), 0);
                // Precautionally set now, otherwise the style is not set for cells
                // that are inserted for margin balancing.
                m_pIo->m_rDoc.SetTextFormatColl(*m_pIo->m_pPaM, const_cast<SwTextFormatColl*>(m_pIo->m_pDfltTextFormatColl));
                // because this cells are invisible helper constructions only to simulate
                // the frayed view of WW-tables we do NOT need SetTextFormatCollAndListLevel()
            }

            // Better to turn Snap to Grid off for all paragraphs in tables
            if(SwTextNode *pNd = m_pIo->m_pPaM->GetNode().GetTextNode())
            {
                const SfxPoolItem &rItm = pNd->SwContentNode::GetAttr(RES_PARATR_SNAPTOGRID);
                const SvxParaGridItem &rSnapToGrid = static_cast<const SvxParaGridItem&>(rItm);

                if(rSnapToGrid.GetValue())
                {
                    SvxParaGridItem aGridItem( rSnapToGrid );
                    aGridItem.SetValue(false);

                    SwPosition* pGridPos = m_pIo->m_pPaM->GetPoint();

                    const sal_Int32 nEnd = pGridPos->nContent.GetIndex();
                    pGridPos->nContent.Assign(m_pIo->m_pPaM->GetContentNode(), 0);
                    m_pIo->m_xCtrlStck->NewAttr(*pGridPos, aGridItem);
                    pGridPos->nContent.Assign(m_pIo->m_pPaM->GetContentNode(), nEnd);
                    m_pIo->m_xCtrlStck->SetAttr(*pGridPos, RES_PARATR_SNAPTOGRID);
                }
            }

            StartMiserableHackForUnsupportedDirection(nWwCol);
        }
    }

    void WW8TabDesc::InsertCells( short nIns )
    {
        m_pTabLine = (*m_pTabLines)[m_nCurrentRow];
        m_pTabBoxes = &m_pTabLine->GetTabBoxes();
        m_pTabBox = (*m_pTabBoxes)[0];

        m_pIo->m_rDoc.GetNodes().InsBoxen( m_pTableNd, m_pTabLine, static_cast<SwTableBoxFormat*>(m_pTabBox->GetFrameFormat()),
                                const_cast<SwTextFormatColl*>(m_pIo->m_pDfltTextFormatColl), nullptr, m_pTabBoxes->size(), nIns );
        // The third parameter contains the FrameFormat of the boxes.
        // Here it is possible to optimize to save (reduce) FrameFormats.
    }

    void WW8TabDesc::SetTabBorders(SwTableBox* pBox, short nWwIdx)
    {
        if( nWwIdx < 0 || nWwIdx >= m_pActBand->nWwCols )
            return;                 // faked cells -> no border

        SvxBoxItem aFormatBox( RES_BOX );
        if (m_pActBand->pTCs)     // neither Cell Border nor Default Border defined ?
        {
            WW8_TCell* pT = &m_pActBand->pTCs[nWwIdx];
            if (SwWW8ImplReader::IsBorder(pT->rgbrc))
                SwWW8ImplReader::SetBorder(aFormatBox, pT->rgbrc);
        }

        if (m_pActBand->nOverrideSpacing[nWwIdx] & (1 << WW8TabBandDesc::wwTOP))
        {
            aFormatBox.SetDistance(
                m_pActBand->nOverrideValues[nWwIdx][WW8TabBandDesc::wwTOP],
                SvxBoxItemLine::TOP);
        }
        else
            aFormatBox.SetDistance(m_pActBand->mnDefaultTop, SvxBoxItemLine::TOP);
        if (m_pActBand->nOverrideSpacing[nWwIdx] & (1 << WW8TabBandDesc::wwBOTTOM))
        {
            aFormatBox.SetDistance(
                m_pActBand->nOverrideValues[nWwIdx][WW8TabBandDesc::wwBOTTOM],
                SvxBoxItemLine::BOTTOM);
        }
        else
            aFormatBox.SetDistance(m_pActBand->mnDefaultBottom,SvxBoxItemLine::BOTTOM);

        // nGapHalf for WW is a *horizontal* gap between table cell and content.
        short nLeftDist =
            m_pActBand->mbHasSpacing ? m_pActBand->mnDefaultLeft : m_pActBand->nGapHalf;
        short nRightDist =
            m_pActBand->mbHasSpacing ? m_pActBand->mnDefaultRight : m_pActBand->nGapHalf;
        if (m_pActBand->nOverrideSpacing[nWwIdx] & (1 << WW8TabBandDesc::wwLEFT))
        {
            aFormatBox.SetDistance(
                m_pActBand->nOverrideValues[nWwIdx][WW8TabBandDesc::wwLEFT],
                SvxBoxItemLine::LEFT);
        }
        else
            aFormatBox.SetDistance(nLeftDist, SvxBoxItemLine::LEFT);
        if (m_pActBand->nOverrideSpacing[nWwIdx] & (1 << WW8TabBandDesc::wwRIGHT))
        {
            aFormatBox.SetDistance(
                m_pActBand->nOverrideValues[nWwIdx][WW8TabBandDesc::wwRIGHT],
                SvxBoxItemLine::RIGHT);
        }
        else
            aFormatBox.SetDistance(nRightDist,SvxBoxItemLine::RIGHT);

        pBox->GetFrameFormat()->SetFormatAttr(aFormatBox);
    }

    void WW8TabDesc::SetTabShades( SwTableBox* pBox, short nWwIdx )
    {
        if( nWwIdx < 0 || nWwIdx >= m_pActBand->nWwCols )
            return;                 // faked cells -> no color

        bool bFound=false;
        if (m_pActBand->pNewSHDs && m_pActBand->pNewSHDs[nWwIdx] != COL_AUTO)
        {
            Color aColor(m_pActBand->pNewSHDs[nWwIdx]);
            pBox->GetFrameFormat()->SetFormatAttr(SvxBrushItem(aColor, RES_BACKGROUND));
            bFound = true;
        }

        //If there was no new shades, or no new shade setting
        if (m_pActBand->pSHDs && !bFound)
        {
            WW8_SHD& rSHD = m_pActBand->pSHDs[nWwIdx];
            if (!rSHD.GetValue())       // auto
                return;

            SwWW8Shade aSh( m_pIo->m_bVer67, rSHD );
            pBox->GetFrameFormat()->SetFormatAttr(SvxBrushItem(aSh.aColor, RES_BACKGROUND));
        }
    }

    SvxFrameDirection MakeDirection(sal_uInt16 nCode, bool bIsBiDi)
    {
        SvxFrameDirection eDir = SvxFrameDirection::Environment;
        // 1: Asian layout with rotated CJK characters
        // 5: Asian layout
        // 3: Western layout rotated by 90 degrees
        // 4: Western layout
        switch (nCode)
        {
            default:
                OSL_ENSURE(eDir == SvxFrameDirection::Environment, "unknown direction code, maybe it's a bitfield");
                SAL_FALLTHROUGH;
            case 3:
                eDir = bIsBiDi ? SvxFrameDirection::Horizontal_RL_TB : SvxFrameDirection::Horizontal_LR_TB; // #i38158# - Consider RTL tables
                break;
            case 5:
                eDir = SvxFrameDirection::Vertical_RL_TB;
                break;
            case 1:
                eDir = SvxFrameDirection::Vertical_RL_TB;
                break;
            case 4:
                eDir = bIsBiDi ? SvxFrameDirection::Horizontal_RL_TB : SvxFrameDirection::Horizontal_LR_TB; // #i38158# - Consider RTL tables
                break;
        }
        return eDir;
    }

    void WW8TabDesc::SetTabDirection(SwTableBox* pBox, short nWwIdx)
    {
        if (nWwIdx < 0 || nWwIdx >= m_pActBand->nWwCols)
            return;
        SvxFrameDirectionItem aItem(MakeDirection(m_pActBand->maDirections[nWwIdx], m_bIsBiDi), RES_FRAMEDIR);
        pBox->GetFrameFormat()->SetFormatAttr(aItem);
    }

    void WW8TabDesc::SetTabVertAlign( SwTableBox* pBox, short nWwIdx )
    {
        if( nWwIdx < 0 || nWwIdx >= m_pActBand->nWwCols )
            return;

        sal_Int16 eVertOri=text::VertOrientation::TOP;

        if( m_pActBand->pTCs )
        {
            WW8_TCell* pT = &m_pActBand->pTCs[nWwIdx];
            switch (pT->nVertAlign)
            {
                case 0:
                default:
                    eVertOri = text::VertOrientation::TOP;
                    break;
                case 1:
                    eVertOri = text::VertOrientation::CENTER;
                    break;
                case 2:
                    eVertOri = text::VertOrientation::BOTTOM;
                    break;
            }
        }

        pBox->GetFrameFormat()->SetFormatAttr( SwFormatVertOrient(0,eVertOri) );
    }

    void WW8TabDesc::AdjustNewBand()
    {
        if( m_pActBand->nSwCols > m_nDefaultSwCols )        // split cells
            InsertCells( m_pActBand->nSwCols - m_nDefaultSwCols );

        SetPamInCell( 0, false);
        OSL_ENSURE( m_pTabBoxes && m_pTabBoxes->size() == static_cast<sal_uInt16>(m_pActBand->nSwCols),
            "Wrong column count in table" );

        if( m_bClaimLineFormat )
        {
            m_pTabLine->ClaimFrameFormat();            // necessary because of cell height
            SwFormatFrameSize aF( ATT_MIN_SIZE, 0, 0 );  // default

            if (m_pActBand->nLineHeight == 0)    // 0 = Auto
                aF.SetHeightSizeType( ATT_VAR_SIZE );
            else
            {
                if (m_pActBand->nLineHeight < 0) // positive = min, negative = exact
                {
                    aF.SetHeightSizeType(ATT_FIX_SIZE);
                    m_pActBand->nLineHeight = -m_pActBand->nLineHeight;
                }
                if (m_pActBand->nLineHeight < MINLAY) // invalid cell height
                    m_pActBand->nLineHeight = MINLAY;

                aF.SetHeight(m_pActBand->nLineHeight);// set min/exact height
            }
            m_pTabLine->GetFrameFormat()->SetFormatAttr(aF);
        }

        //Word stores 1 for bCantSplit if the row cannot be split, we set true if
        //we can split the row
        bool bSetCantSplit = m_pActBand->bCantSplit;
        m_pTabLine->GetFrameFormat()->SetFormatAttr(SwFormatRowSplit(!bSetCantSplit));

        //  if table is only a single row, and row is set as don't split, set the same value for the whole table.
        if( bSetCantSplit && m_pTabLines->size() == 1 )
            m_pTable->GetFrameFormat()->SetFormatAttr(SwFormatLayoutSplit( !bSetCantSplit ));

        short i;    // SW-Index
        short j;    // WW-Index
        short nW;   // Width
        SwFormatFrameSize aFS( ATT_FIX_SIZE );
        j = m_pActBand->bLEmptyCol ? -1 : 0;

        for( i = 0; i < m_pActBand->nSwCols; i++ )
        {
            // set cell width
            if( j < 0 )
                nW = m_pActBand->nCenter[0] - m_nMinLeft;
            else
            {
                //Set j to first non invalid cell
                while ((j < m_pActBand->nWwCols) && (!m_pActBand->bExist[j]))
                    j++;

                if( j < m_pActBand->nWwCols )
                    nW = m_pActBand->nCenter[j+1] - m_pActBand->nCenter[j];
                else
                    nW = m_nMaxRight - m_pActBand->nCenter[j];
                m_pActBand->nWidth[ j ] = nW;
            }

            SwTableBox* pBox = (*m_pTabBoxes)[i];
            // could be reduced further by intelligent moving of FrameFormats
            pBox->ClaimFrameFormat();

            SetTabBorders(pBox, j);

            // #i18128# word has only one line between adjoining vertical cells
            // we have to mimic this in the filter by picking the larger of the
            // sides and using that one on one side of the line (right)
            SvxBoxItem aCurrentBox(sw::util::ItemGet<SvxBoxItem>(*(pBox->GetFrameFormat()), RES_BOX));
            if (i != 0)
            {
                SwTableBox* pBox2 = (*m_pTabBoxes)[i-1];
                SvxBoxItem aOldBox(sw::util::ItemGet<SvxBoxItem>(*(pBox2->GetFrameFormat()), RES_BOX));
                if( aOldBox.CalcLineWidth(SvxBoxItemLine::RIGHT) > aCurrentBox.CalcLineWidth(SvxBoxItemLine::LEFT) )
                    aCurrentBox.SetLine(aOldBox.GetLine(SvxBoxItemLine::RIGHT), SvxBoxItemLine::LEFT);

                aOldBox.SetLine(nullptr, SvxBoxItemLine::RIGHT);
                pBox2->GetFrameFormat()->SetFormatAttr(aOldBox);
            }

            pBox->GetFrameFormat()->SetFormatAttr(aCurrentBox);

            SetTabVertAlign(pBox, j);
            SetTabDirection(pBox, j);
            if( m_pActBand->pSHDs || m_pActBand->pNewSHDs)
                SetTabShades(pBox, j);
            j++;

            aFS.SetWidth( nW );
            pBox->GetFrameFormat()->SetFormatAttr( aFS );

            // skip non existing cells
            while( ( j < m_pActBand->nWwCols ) && !m_pActBand->bExist[j] )
            {
                m_pActBand->nWidth[j] = m_pActBand->nCenter[j+1] - m_pActBand->nCenter[j];
                j++;
            }
        }
    }

    void WW8TabDesc::TableCellEnd()
    {
        ::SetProgressState(m_pIo->m_nProgress, m_pIo->m_pDocShell);   // Update

        EndMiserableHackForUnsupportedDirection(m_nCurrentCol);

        // new line/row
        if( m_pIo->m_bWasTabRowEnd )
        {
            // bWasTabRowEnd will be deactivated in
            // SwWW8ImplReader::ProcessSpecial()

            sal_uInt16 iCol = GetLogicalWWCol();
            if (iCol < m_aNumRuleNames.size())
            {
                m_aNumRuleNames.erase(m_aNumRuleNames.begin() + iCol,
                    m_aNumRuleNames.end());
            }

            m_nCurrentCol = 0;
            m_nCurrentRow++;
            m_nCurrentBandRow++;
            OSL_ENSURE( m_pActBand , "pActBand is 0" );
            if( m_pActBand )
            {
                if( m_nCurrentRow >= m_nRows )  // nothing to at end of table
                    return;

                bool bNewBand = m_nCurrentBandRow >= m_pActBand->nRows;
                if( bNewBand )
                {                       // new band needed ?
                    m_pActBand = m_pActBand->pNextBand;
                    m_nCurrentBandRow = 0;
                    OSL_ENSURE( m_pActBand, "pActBand is 0" );
                    AdjustNewBand();
                }
                else
                {
                    SwTableBox* pBox = (*m_pTabBoxes)[0];
                    SwSelBoxes aBoxes;
                    m_pIo->m_rDoc.InsertRow( SwTable::SelLineFromBox( pBox, aBoxes ) );
                }
            }
        }
        else
        {                       // new column ( cell )
            m_nCurrentCol++;
        }
        SetPamInCell(m_nCurrentCol, true);

        // finish Annotated Level Numbering ?
        if (m_pIo->m_bAnl && !m_pIo->m_bCurrentAND_fNumberAcross && m_pActBand)
            m_pIo->StopAllAnl(IsValidCell(m_nCurrentCol));
    }

    // if necessary register the box for the merge group for this column
    void WW8TabDesc::UpdateTableMergeGroup(  WW8_TCell const &     rCell,
                                                    WW8SelBoxInfo* pActGroup,
                                                    SwTableBox*    pActBox,
                                                    sal_uInt16         nCol )
    {
        // check if the box has to be merged
        // If cell is the first one to be merged, a new merge group has to be provided.
        // E.g., it could be that a cell is the first one to be merged, but no
        // new merge group is provided, because the potential other cell to be merged
        // doesn't exist - see method <WW8TabDesc::MergeCells>.
        if ( m_pActBand->bExist[ nCol ] &&
             ( ( rCell.bFirstMerged && pActGroup ) ||
               rCell.bMerged ||
               rCell.bVertMerge ||
               rCell.bVertRestart ) )
        {
            // detect appropriate merge group
            WW8SelBoxInfo* pTheMergeGroup = nullptr;
            if( pActGroup )
                // assign group
                pTheMergeGroup = pActGroup;
            else
            {
                // find group
                pTheMergeGroup = FindMergeGroup(
                    m_pActBand->nCenter[ nCol ], m_pActBand->nWidth[  nCol ], true );
            }
            if( pTheMergeGroup )
            {
                // add current box to merge group
                pTheMergeGroup->push_back(pActBox);
            }
        }
    }

    sal_uInt16 WW8TabDesc::GetLogicalWWCol() const // returns number of col as INDICATED within WW6 UI status line -1
    {
        sal_uInt16 nCol = 0;
        if( m_pActBand && m_pActBand->pTCs)
        {
            for( sal_uInt16 iCol = 1; iCol <= m_nCurrentCol && iCol <= m_pActBand->nWwCols; ++iCol )
            {
                if( !m_pActBand->pTCs[ iCol-1 ].bMerged )
                    ++nCol;
            }
        }
        return nCol;
    }

    // find name of numrule valid for current WW-COL
    OUString WW8TabDesc::GetNumRuleName() const
    {
        sal_uInt16 nCol = GetLogicalWWCol();
        if (nCol < m_aNumRuleNames.size())
            return m_aNumRuleNames[nCol];
        return OUString();
    }

    void WW8TabDesc::SetNumRuleName( const OUString& rName )
    {
        sal_uInt16 nCol = GetLogicalWWCol();
        for (sal_uInt16 nSize = static_cast< sal_uInt16 >(m_aNumRuleNames.size()); nSize <= nCol; ++nSize)
            m_aNumRuleNames.emplace_back();
        m_aNumRuleNames[nCol] = rName;
    }

    bool SwWW8ImplReader::StartTable(WW8_CP nStartCp)
    {
        // Entering a table so make sure the FirstPara flag gets set
        m_bFirstPara = true;
        // no recursive table, not with InsertFile in table or foot note
        if (m_bReadNoTable)
            return false;

        if (m_xTableDesc)
            m_aTableStack.push(std::move(m_xTableDesc));

        // #i33818# - determine absolute position object attributes,
        // if possible. It's needed for nested tables.
        WW8FlyPara* pTableWFlyPara( nullptr );
        WW8SwFlyPara* pTableSFlyPara( nullptr );
        // #i45301# - anchor nested table inside Writer fly frame
        // only at-character, if absolute position object attributes are available.
        // Thus, default anchor type is as-character anchored.
        RndStdIds eAnchor( RndStdIds::FLY_AS_CHAR );
        if ( m_nInTable )
        {
            WW8_TablePos* pNestedTabPos( nullptr );
            WW8_TablePos aNestedTabPos;
            WW8PLCFxSave1 aSave;
            m_xPlcxMan->GetPap()->Save( aSave );
            WW8PLCFx_Cp_FKP* pPap = m_xPlcxMan->GetPapPLCF();
            WW8_CP nMyStartCp = nStartCp;
            if ( SearchRowEnd( pPap, nMyStartCp, m_nInTable ) &&
                 ParseTabPos( &aNestedTabPos, pPap ) )
            {
                pNestedTabPos = &aNestedTabPos;
            }
            m_xPlcxMan->GetPap()->Restore( aSave );
            if ( pNestedTabPos )
            {
                ApoTestResults aApo = TestApo( m_nInTable + 1, false, pNestedTabPos );
                pTableWFlyPara = ConstructApo( aApo, pNestedTabPos );
                if ( pTableWFlyPara )
                {
                    // <WW8SwFlyPara> constructor has changed - new 4th parameter
                    // containing WW8 page top margin.
                    pTableSFlyPara = new WW8SwFlyPara(*m_pPaM, *this, *pTableWFlyPara,
                        m_aSectionManager.GetWWPageTopMargin(),
                        m_aSectionManager.GetTextAreaWidth(),
                        m_nIniFlyDx, m_nIniFlyDy);

                    // #i45301# - anchor nested table Writer fly frame at-character
                    eAnchor = RndStdIds::FLY_AT_CHAR;
                }
            }
        }
        // if first paragraph in table has break-before-page, transfer that setting to the table itself.
        else if( StyleExists(m_nCurrentColl) )
        {
            const SwFormat* pStyleFormat = m_vColl[m_nCurrentColl].m_pFormat;
            if( pStyleFormat && pStyleFormat->GetBreak().GetBreak() == SvxBreak::PageBefore )
                NewAttr( pStyleFormat->GetBreak() );
        }

        m_xTableDesc.reset(new WW8TabDesc(this, nStartCp));

        if( m_xTableDesc->Ok() )
        {
            int nNewInTable = m_nInTable + 1;

            if ((eAnchor == RndStdIds::FLY_AT_CHAR)
                && !m_aTableStack.empty() && !InEqualApo(nNewInTable) )
            {
                m_xTableDesc->m_pParentPos = new SwPosition(*m_pPaM->GetPoint());
                SfxItemSet aItemSet(m_rDoc.GetAttrPool(),
                                    svl::Items<RES_FRMATR_BEGIN, RES_FRMATR_END-1>{});
                // #i33818# - anchor the Writer fly frame for the nested table at-character.
                // #i45301#
                SwFormatAnchor aAnchor( eAnchor );
                aAnchor.SetAnchor( m_xTableDesc->m_pParentPos );
                aItemSet.Put( aAnchor );
                m_xTableDesc->m_pFlyFormat = m_rDoc.MakeFlySection( eAnchor,
                                                          m_xTableDesc->m_pParentPos, &aItemSet);
                OSL_ENSURE( m_xTableDesc->m_pFlyFormat->GetAnchor().GetAnchorId() == eAnchor,
                       "Not the anchor type requested!" );
                MoveInsideFly(m_xTableDesc->m_pFlyFormat);
            }
            m_xTableDesc->CreateSwTable();
            if (m_xTableDesc->m_pFlyFormat)
            {
                m_xTableDesc->SetSizePosition(m_xTableDesc->m_pFlyFormat);
                // #i33818# - Use absolute position object attributes,
                // if existing, and apply them to the created Writer fly frame.
                if ( pTableWFlyPara && pTableSFlyPara )
                {
                    WW8FlySet aFlySet( *this, pTableWFlyPara, pTableSFlyPara, false );
                    SwFormatAnchor aAnchor( RndStdIds::FLY_AT_CHAR );
                    aAnchor.SetAnchor( m_xTableDesc->m_pParentPos );
                    aFlySet.Put( aAnchor );
                    m_xTableDesc->m_pFlyFormat->SetFormatAttr( aFlySet );
                }
                else
                {
                    SwFormatHoriOrient aHori =
                                m_xTableDesc->m_pTable->GetFrameFormat()->GetHoriOrient();
                    m_xTableDesc->m_pFlyFormat->SetFormatAttr(aHori);
                    m_xTableDesc->m_pFlyFormat->SetFormatAttr( SwFormatSurround( css::text::WrapTextMode_NONE ) );
                }
                // #i33818# - The nested table doesn't have to leave
                // the table cell. Thus, the Writer fly frame has to follow the text flow.
                m_xTableDesc->m_pFlyFormat->SetFormatAttr( SwFormatFollowTextFlow( true ) );
            }
            else
                m_xTableDesc->SetSizePosition(nullptr);
            m_xTableDesc->UseSwTable();
        }
        else
            PopTableDesc();

        // #i33818#
        delete pTableWFlyPara;
        delete pTableSFlyPara;

        return m_xTableDesc.get() != nullptr;
    }

    void SwWW8ImplReader::TabCellEnd()
    {
        if (m_nInTable && m_xTableDesc)
            m_xTableDesc->TableCellEnd();

        m_bFirstPara = true;    // We have come to the end of a cell so FirstPara flag
        m_bReadTable = false;
    }

    void SwWW8ImplReader::Read_TabCellEnd( sal_uInt16, const sal_uInt8* pData, short nLen)
    {
        if( ( nLen > 0 ) && ( *pData == 1 ) )
            m_bWasTabCellEnd = true;
    }

    void SwWW8ImplReader::Read_TabRowEnd( sal_uInt16, const sal_uInt8* pData, short nLen )   // Sprm25
    {
        if( ( nLen > 0 ) && ( *pData == 1 ) )
            m_bWasTabRowEnd = true;
    }

    void SwWW8ImplReader::PopTableDesc()
    {
        if (m_xTableDesc && m_xTableDesc->m_pFlyFormat)
        {
            MoveOutsideFly(m_xTableDesc->m_pFlyFormat, *m_xTableDesc->m_pParentPos);
        }

        m_xTableDesc.reset();
        if (!m_aTableStack.empty())
        {
           m_xTableDesc = std::move(m_aTableStack.top());
           m_aTableStack.pop();
        }
    }

    void SwWW8ImplReader::StopTable()
    {
        OSL_ENSURE(m_xTableDesc.get(), "Panic, stop table with no table!");
        if (!m_xTableDesc)
            return;

        // We are leaving a table so make sure the next paragraph doesn't think
        // it's the first paragraph
        m_bFirstPara = false;

        m_xTableDesc->FinishSwTable();
        PopTableDesc();

        m_bReadTable = true;
    }

    bool SwWW8ImplReader::IsInvalidOrToBeMergedTabCell() const
    {
        if( !m_xTableDesc )
            return false;

        const WW8_TCell* pCell = m_xTableDesc->GetCurrentWWCell();

        return     !m_xTableDesc->IsValidCell( m_xTableDesc->GetCurrentCol() )
                || (    pCell
                     && (    !pCell->bFirstMerged
                          && (    pCell->bMerged
                               || (    pCell->bVertMerge
                                    && !pCell->bVertRestart
                                  )
                             )
                        )
                    );
    }

    sal_uInt16 SwWW8ImplReader::StyleUsingLFO( sal_uInt16 nLFOIndex ) const
    {
        sal_uInt16 nRes = USHRT_MAX;
        if( !m_vColl.empty() )
        {
            for(sal_uInt16 nI = 0; nI < m_xStyles->GetCount(); nI++ )
                if(    m_vColl[ nI ].m_bValid
                    && (nLFOIndex == m_vColl[ nI ].m_nLFOIndex) )
                    nRes = nI;
        }
        return nRes;
    }

    const SwFormat* SwWW8ImplReader::GetStyleWithOrgWWName( OUString const & rName ) const
    {
        SwFormat* pRet = nullptr;
        if( !m_vColl.empty() )
        {
            for(sal_uInt16 nI = 0; nI < m_xStyles->GetCount(); nI++ )
                if(    m_vColl[ nI ].m_bValid
                    && (rName == m_vColl[ nI ].GetOrgWWName()) )
                {
                    pRet = m_vColl[ nI ].m_pFormat;
                    break;
                }
        }
        return pRet;
    }

    //          class WW8RStyle

    SprmResult WW8RStyle::HasParaSprm(sal_uInt16 nId) const
    {
        if( !mpParaSprms || !mnSprmsLen )
            return SprmResult();

        return maSprmParser.findSprmData(nId, mpParaSprms, mnSprmsLen);
    }

    void WW8RStyle::ImportSprms(sal_uInt8 *pSprms, short nLen, bool bPap)
    {
        if (!nLen)
            return;

        if( bPap )
        {
            mpParaSprms = pSprms;   // for HasParaSprms()
            mnSprmsLen = nLen;
        }

        WW8SprmIter aSprmIter(pSprms, nLen, maSprmParser);
        while (const sal_uInt8* pSprm = aSprmIter.GetSprms())
        {
    #ifdef DEBUGSPRMREADER
            fprintf(stderr, "id is %x\n", aIter.GetCurrentId());
    #endif
            mpIo->ImportSprm(pSprm, aSprmIter.GetRemLen(), aSprmIter.GetCurrentId());
            aSprmIter.advance();
        }

        mpParaSprms = nullptr;
        mnSprmsLen = 0;
    }

    void WW8RStyle::ImportSprms(std::size_t nPosFc, short nLen, bool bPap)
    {
        if (!nLen)
            return;

        if (checkSeek(*mpStStrm, nPosFc))
        {
            std::unique_ptr<sal_uInt8[]> pSprms( new sal_uInt8[nLen] );
            nLen = mpStStrm->ReadBytes(pSprms.get(), nLen);
            ImportSprms(pSprms.get(), nLen, bPap);
        }
    }

    static inline short WW8SkipOdd(SvStream* pSt )
    {
        if ( pSt->Tell() & 0x1 )
        {
            sal_uInt8 c;
            return pSt->ReadBytes( &c, 1 );
        }
        return 0;
    }

    static inline short WW8SkipEven(SvStream* pSt )
    {
        if (!(pSt->Tell() & 0x1))
        {
            sal_uInt8 c;
            return pSt->ReadBytes( &c, 1 );
        }
        return 0;
    }

    short WW8RStyle::ImportUPX(short nLen, bool bPAP, bool bOdd)
    {
        if( 0 < nLen ) // Empty ?
        {
            if (bOdd)
                nLen = nLen - WW8SkipEven( mpStStrm );
            else
                nLen = nLen - WW8SkipOdd( mpStStrm );

            sal_Int16 cbUPX(0);
            mpStStrm->ReadInt16( cbUPX );

            nLen-=2;

            if ( cbUPX > nLen )
                cbUPX = nLen;       // shrink cbUPX to nLen

            if( (1 < cbUPX) || ( (0 < cbUPX) && !bPAP ) )
            {
                if( bPAP )
                {
                    sal_uInt16 id;
                    mpStStrm->ReadUInt16( id );

                    cbUPX-=  2;
                    nLen-=  2;
                }

                if( 0 < cbUPX )
                {
                    sal_uInt64 const nPos = mpStStrm->Tell(); // if something is interpreted wrong,
                                                     // this should make it work again
                    ImportSprms( nPos, cbUPX, bPAP );

                    if ( mpStStrm->Tell() != nPos + cbUPX )
                        mpStStrm->Seek( nPos+cbUPX );

                    nLen = nLen - cbUPX;
                }
            }
        }
        return nLen;
    }

    void WW8RStyle::ImportGrupx(short nLen, bool bPara, bool bOdd)
    {
        if( nLen <= 0 )
            return;
        if (bOdd)
            nLen = nLen - WW8SkipEven( mpStStrm );
        else
            nLen = nLen - WW8SkipOdd( mpStStrm );

        if( bPara ) // Grupx.Papx
            nLen = ImportUPX(nLen, true, bOdd);
        ImportUPX(nLen, false, bOdd);                   // Grupx.Chpx
    }

    WW8RStyle::WW8RStyle(WW8Fib& _rFib, SwWW8ImplReader* pI)
        : WW8Style(*pI->m_pTableStream, _rFib)
        , maSprmParser(_rFib)
        , mpIo(pI)
        , mpStStrm(pI->m_pTableStream)
        , mpStyRule(nullptr)
        , mpParaSprms(nullptr)
        , mnSprmsLen(0)
        , mnWwNumLevel(0)
        , mbTextColChanged(false)
        , mbFontChanged(false)
        , mbCJKFontChanged(false)
        , mbCTLFontChanged(false)
        , mbFSizeChanged(false)
        , mbFCTLSizeChanged(false)
        , mbWidowsChanged(false)
    {
        mpIo->m_vColl.resize(m_cstd);
    }

    void WW8RStyle::Set1StyleDefaults()
    {
        // see #i25247#, #i25561#, #i48064#, #i92341# for default font
        if (!mbCJKFontChanged)   // Style no CJK Font? set the default
            mpIo->SetNewFontAttr(m_ftcFE, true, RES_CHRATR_CJK_FONT);

        if (!mbCTLFontChanged)   // Style no CTL Font? set the default
            mpIo->SetNewFontAttr(m_ftcBi, true, RES_CHRATR_CTL_FONT);

        // western 2nd to make western charset conversion the default
        if (!mbFontChanged)      // Style has no Font? set the default,
            mpIo->SetNewFontAttr(m_ftcAsci, true, RES_CHRATR_FONT);

        if( !mpIo->m_bNoAttrImport )
        {
            // Style has no text color set, winword default is auto
            if ( !mbTextColChanged )
                mpIo->m_pCurrentColl->SetFormatAttr(SvxColorItem(COL_AUTO, RES_CHRATR_COLOR));

            // Style has no FontSize ? WinWord Default is 10pt for western and asian
            if( !mbFSizeChanged )
            {
                SvxFontHeightItem aAttr(200, 100, RES_CHRATR_FONTSIZE);
                mpIo->m_pCurrentColl->SetFormatAttr(aAttr);
                aAttr.SetWhich(RES_CHRATR_CJK_FONTSIZE);
                mpIo->m_pCurrentColl->SetFormatAttr(aAttr);
            }

            // Style has no FontSize ? WinWord Default is 10pt for western and asian
            if( !mbFCTLSizeChanged )
            {
                SvxFontHeightItem aAttr(200, 100, RES_CHRATR_FONTSIZE);
                aAttr.SetWhich(RES_CHRATR_CTL_FONTSIZE);
                mpIo->m_pCurrentColl->SetFormatAttr(aAttr);
            }

            if( !mbWidowsChanged )  // Widows ?
            {
                mpIo->m_pCurrentColl->SetFormatAttr( SvxWidowsItem( 2, RES_PARATR_WIDOWS ) );
                mpIo->m_pCurrentColl->SetFormatAttr( SvxOrphansItem( 2, RES_PARATR_ORPHANS ) );
            }
        }
    }

    bool WW8RStyle::PrepareStyle(SwWW8StyInf &rSI, ww::sti eSti, sal_uInt16 nThisStyle, sal_uInt16 nNextStyle)
    {
        SwFormat* pColl;
        bool bStyExist;

        if (rSI.m_bColl)
        {
            // Para-Style
            sw::util::ParaStyleMapper::StyleResult aResult =
                mpIo->m_aParaStyleMapper.GetStyle(rSI.GetOrgWWName(), eSti);
            pColl = aResult.first;
            bStyExist = aResult.second;
        }
        else
        {
            // Char-Style
            sw::util::CharStyleMapper::StyleResult aResult =
                mpIo->m_aCharStyleMapper.GetStyle(rSI.GetOrgWWName(), eSti);
            pColl = aResult.first;
            bStyExist = aResult.second;
        }

        bool bImport = !bStyExist || mpIo->m_bNewDoc; // import content ?

        // Do not override character styles the list import code created earlier.
        if (bImport && bStyExist && rSI.GetOrgWWName().startsWith("WW8Num"))
            bImport = false;

        bool bOldNoImp = mpIo->m_bNoAttrImport;
        rSI.m_bImportSkipped = !bImport;

        if( !bImport )
            mpIo->m_bNoAttrImport = true;
        else
        {
            if (bStyExist)
            {
                pColl->ResetAllFormatAttr(); // #i73790# - method renamed
            }
            pColl->SetAuto(false);          // suggested by JP
        }                                   // but changes the UI
        mpIo->m_pCurrentColl = pColl;
        rSI.m_pFormat = pColl;                  // remember translation WW->SW
        rSI.m_bImportSkipped = !bImport;

        // Set Based on style
        sal_uInt16 j = rSI.m_nBase;
        if (j != nThisStyle && j < m_cstd )
        {
            SwWW8StyInf* pj = &mpIo->m_vColl[j];
            if (rSI.m_pFormat && pj->m_pFormat && rSI.m_bColl == pj->m_bColl)
            {
                rSI.m_pFormat->SetDerivedFrom( pj->m_pFormat );  // ok, set Based on
                rSI.m_eLTRFontSrcCharSet = pj->m_eLTRFontSrcCharSet;
                rSI.m_eRTLFontSrcCharSet = pj->m_eRTLFontSrcCharSet;
                rSI.m_eCJKFontSrcCharSet = pj->m_eCJKFontSrcCharSet;
                rSI.m_n81Flags = pj->m_n81Flags;
                rSI.m_n81BiDiFlags = pj->m_n81BiDiFlags;
                if (!rSI.IsWW8BuiltInHeadingStyle())
                {
                    rSI.mnWW8OutlineLevel = pj->mnWW8OutlineLevel;
                }
                rSI.m_bParaAutoBefore = pj->m_bParaAutoBefore;
                rSI.m_bParaAutoAfter = pj->m_bParaAutoAfter;

                if (pj->m_xWWFly)
                    rSI.m_xWWFly.reset(new WW8FlyPara(mpIo->m_bVer67, pj->m_xWWFly.get()));
            }
        }
        else if( mpIo->m_bNewDoc && bStyExist )
            rSI.m_pFormat->SetDerivedFrom();

        rSI.m_nFollow = nNextStyle;       // remember Follow

        mpStyRule = nullptr;                   // recreate if necessary
        mbTextColChanged = mbFontChanged = mbCJKFontChanged = mbCTLFontChanged =
            mbFSizeChanged = mbFCTLSizeChanged = mbWidowsChanged = false;
        mpIo->SetNCurrentColl( nThisStyle );
        mpIo->m_bStyNormal = nThisStyle == 0;
        return bOldNoImp;
    }

    void WW8RStyle::PostStyle(SwWW8StyInf const &rSI, bool bOldNoImp)
    {
        // Reset attribute flags, because there are no style-ends.

        mpIo->m_bHasBorder = mpIo->m_bSpec = mpIo->m_bObj = mpIo->m_bSymbol = false;
        mpIo->m_nCharFormat = -1;

        // if style is based on nothing or base ignored
        if ((rSI.m_nBase >= m_cstd || mpIo->m_vColl[rSI.m_nBase].m_bImportSkipped) && rSI.m_bColl)
        {
            // If Char-Styles does not work
            // -> set hard WW-Defaults
            Set1StyleDefaults();
        }

        mpStyRule = nullptr;                   // to be on the safe side
        mpIo->m_bStyNormal = false;
        mpIo->SetNCurrentColl( 0 );
        mpIo->m_bNoAttrImport = bOldNoImp;
        // reset the list-remember-fields, if used when reading styles
        mpIo->m_nLFOPosition = USHRT_MAX;
        mpIo->m_nListLevel = WW8ListManager::nMaxLevel;
    }

    void WW8RStyle::Import1Style( sal_uInt16 nNr )
    {
        if (nNr >= mpIo->m_vColl.size())
            return;

        SwWW8StyInf &rSI = mpIo->m_vColl[nNr];

        if( rSI.m_bImported || !rSI.m_bValid )
            return;

        rSI.m_bImported = true;                      // set flag now to avoid endless loops

        // valid and not NUL and not yet imported

        if( rSI.m_nBase < m_cstd && !mpIo->m_vColl[rSI.m_nBase].m_bImported )
            Import1Style( rSI.m_nBase );

        mpStStrm->Seek( rSI.m_nFilePos );

        sal_uInt16 nSkip;
        OUString sName;

        std::unique_ptr<WW8_STD> xStd(Read1Style(nSkip, &sName));// read Style

        if (xStd)
            rSI.SetOrgWWIdent( sName, xStd->sti );

        // either no Name or unused Slot or unknown Style

        if ( !xStd || sName.isEmpty() || ((1 != xStd->sgc) && (2 != xStd->sgc)) )
        {
            nSkip = std::min<sal_uInt64>(nSkip, mpStStrm->remainingSize());
            mpStStrm->Seek(mpStStrm->Tell() + nSkip);
            return;
        }

        bool bOldNoImp = PrepareStyle(rSI, static_cast<ww::sti>(xStd->sti), nNr, xStd->istdNext);

        // if something is interpreted wrong, this should make it work again
        long nPos = mpStStrm->Tell();

        //Variable parts of the STD start at even byte offsets, but "inside
        //the STD", which I take to meaning even in relation to the starting
        //position of the STD, which matches findings in #89439#, generally it
        //doesn't matter as the STSHI starts off nearly always on an even
        //offset

        //Import of the Style Contents
        ImportGrupx(nSkip, xStd->sgc == 1, rSI.m_nFilePos & 1);

        PostStyle(rSI, bOldNoImp);

        mpStStrm->Seek( nPos+nSkip );
    }

    void WW8RStyle::RecursiveReg(sal_uInt16 nNr)
    {
        if (nNr >= mpIo->m_vColl.size())
            return;

        SwWW8StyInf &rSI = mpIo->m_vColl[nNr];
        if( rSI.m_bImported || !rSI.m_bValid )
            return;

        rSI.m_bImported = true;

        if( rSI.m_nBase < m_cstd && !mpIo->m_vColl[rSI.m_nBase].m_bImported )
            RecursiveReg(rSI.m_nBase);

        mpIo->RegisterNumFormatOnStyle(nNr);

    }

    /*
     After all styles are imported then we can recursively apply numbering
     styles to them, and change their tab stop settings if they turned out
     to have special first line indentation.
    */
    void WW8RStyle::PostProcessStyles()
    {
        sal_uInt16 i;
        /*
         Clear all imported flags so that we can recursively apply numbering
         formats and use it to mark handled ones
        */
        for (i=0; i < m_cstd; ++i)
            mpIo->m_vColl[i].m_bImported = false;

        /*
         Register the num formats and tabstop changes on the styles recursively.
        */

        /*
         In the same loop apply the tabstop changes required because we need to
         change their location if there's a special indentation for the first line,
         By avoiding making use of each styles margins during reading of their
         tabstops we don't get problems with doubly adjusting tabstops that
         are inheritied.
        */
        for (i=0; i < m_cstd; ++i)
        {
            if (mpIo->m_vColl[i].m_bValid)
            {
                RecursiveReg(i);
            }
        }
    }

    void WW8RStyle::ScanStyles()        // investigate style dependencies
    {                                   // and detect Filepos for each Style
        for (sal_uInt16 i = 0; i < m_cstd; ++i)
        {
            SwWW8StyInf &rSI = mpIo->m_vColl[i];

            rSI.m_nFilePos = mpStStrm->Tell();        // remember FilePos
            sal_uInt16 nSkip;
            std::unique_ptr<WW8_STD> xStd(Read1Style(nSkip, nullptr));  // read STD
            rSI.m_bValid = xStd.get() != nullptr;
            if (rSI.m_bValid)
            {
                rSI.m_nBase = xStd->istdBase; // remember Basis
                rSI.m_bColl = xStd->sgc == 1; // Para-Style
            }
            else
                rSI = SwWW8StyInf();

            xStd.reset();
            nSkip = std::min<sal_uInt64>(nSkip, mpStStrm->remainingSize());
            mpStStrm->Seek(mpStStrm->Tell() + nSkip);              // skip Names and Sprms
        }
    }

    std::vector<sal_uInt8> ChpxToSprms(const Word2CHPX &rChpx)
    {
        std::vector<sal_uInt8> aRet;

        aRet.push_back(60);
        aRet.push_back( static_cast< sal_uInt8 >(128 + rChpx.fBold) );

        aRet.push_back(61);
        aRet.push_back( static_cast< sal_uInt8 >(128 + rChpx.fItalic) );

        aRet.push_back(62);
        aRet.push_back( static_cast< sal_uInt8 >(128 + rChpx.fStrike) );

        aRet.push_back(63);
        aRet.push_back( static_cast< sal_uInt8 >(128 + rChpx.fOutline) );

        aRet.push_back(65);
        aRet.push_back( static_cast< sal_uInt8 >(128 + rChpx.fSmallCaps) );

        aRet.push_back(66);
        aRet.push_back( static_cast< sal_uInt8 >(128 + rChpx.fCaps) );

        aRet.push_back(67);
        aRet.push_back( static_cast< sal_uInt8 >(128 + rChpx.fVanish) );

        if (rChpx.fsFtc)
        {
            aRet.push_back(68);
            SVBT16 a;
            ShortToSVBT16(rChpx.ftc, a);
            aRet.push_back(a[1]);
            aRet.push_back(a[0]);
        }

        if (rChpx.fsKul)
        {
            aRet.push_back(69);
            aRet.push_back(rChpx.kul);
        }

        if (rChpx.fsLid)
        {
            aRet.push_back(72);
            SVBT16 a;
            ShortToSVBT16(rChpx.lid, a);
            aRet.push_back(a[1]);
            aRet.push_back(a[0]);
        }

        if (rChpx.fsIco)
        {
            aRet.push_back(73);
            aRet.push_back(rChpx.ico);
        }

        if (rChpx.fsHps)
        {
            aRet.push_back(74);

            SVBT16 a;
            ShortToSVBT16(rChpx.hps, a);
            aRet.push_back(a[0]);
        }

        if (rChpx.fsPos)
        {
            aRet.push_back(76);
            aRet.push_back(rChpx.hpsPos);
        }

        aRet.push_back(80);
        aRet.push_back( static_cast< sal_uInt8 >(128 + rChpx.fBoldBi) );

        aRet.push_back(81);
        aRet.push_back( static_cast< sal_uInt8 >(128 + rChpx.fItalicBi) );

        if (rChpx.fsFtcBi)
        {
            aRet.push_back(82);
            SVBT16 a;
            ShortToSVBT16(rChpx.fsFtcBi, a);
            aRet.push_back(a[1]);
            aRet.push_back(a[0]);
        }

        if (rChpx.fsLidBi)
        {
            aRet.push_back(83);
            SVBT16 a;
            ShortToSVBT16(rChpx.lidBi, a);
            aRet.push_back(a[1]);
            aRet.push_back(a[0]);
        }

        if (rChpx.fsIcoBi)
        {
            aRet.push_back(84);
            aRet.push_back(rChpx.icoBi);
        }

        if (rChpx.fsHpsBi)
        {
            aRet.push_back(85);
            SVBT16 a;
            ShortToSVBT16(rChpx.hpsBi, a);
            aRet.push_back(a[1]);
            aRet.push_back(a[0]);
        }

        return aRet;
    }

    Word2CHPX ReadWord2Chpx(SvStream &rSt, std::size_t nOffset, sal_uInt8 nSize)
    {
        Word2CHPX aChpx;

        if (!nSize)
            return aChpx;

        rSt.Seek(nOffset);

        sal_uInt8 nCount=0;

        while (true)
        {
            sal_uInt8 nFlags8;
            rSt.ReadUChar( nFlags8 );
            nCount++;

            aChpx.fBold = nFlags8 & 0x01;
            aChpx.fItalic = (nFlags8 & 0x02) >> 1;
            aChpx.fRMarkDel = (nFlags8 & 0x04) >> 2;
            aChpx.fOutline = (nFlags8 & 0x08) >> 3;
            aChpx.fFieldVanish = (nFlags8 & 0x10) >> 4;
            aChpx.fSmallCaps = (nFlags8 & 0x20) >> 5;
            aChpx.fCaps = (nFlags8 & 0x40) >> 6;
            aChpx.fVanish = (nFlags8 & 0x80) >> 7;

            if (nCount >= nSize) break;
            rSt.ReadUChar( nFlags8 );
            nCount++;

            aChpx.fRMark = nFlags8 & 0x01;
            aChpx.fSpec = (nFlags8 & 0x02) >> 1;
            aChpx.fStrike = (nFlags8 & 0x04) >> 2;
            aChpx.fObj = (nFlags8 & 0x08) >> 3;
            aChpx.fBoldBi = (nFlags8 & 0x10) >> 4;
            aChpx.fItalicBi = (nFlags8 & 0x20) >> 5;
            aChpx.fBiDi = (nFlags8 & 0x40) >> 6;
            aChpx.fDiacUSico = (nFlags8 & 0x80) >> 7;

            if (nCount >= nSize) break;
            rSt.ReadUChar( nFlags8 );
            nCount++;

            aChpx.fsIco = nFlags8 & 0x01;
            aChpx.fsFtc = (nFlags8 & 0x02) >> 1;
            aChpx.fsHps = (nFlags8 & 0x04) >> 2;
            aChpx.fsKul = (nFlags8 & 0x08) >> 3;
            aChpx.fsPos = (nFlags8 & 0x10) >> 4;
            aChpx.fsSpace = (nFlags8 & 0x20) >> 5;
            aChpx.fsLid = (nFlags8 & 0x40) >> 6;
            aChpx.fsIcoBi = (nFlags8 & 0x80) >> 7;

            if (nCount >= nSize) break;
            rSt.ReadUChar( nFlags8 );
            nCount++;

            aChpx.fsFtcBi = nFlags8 & 0x01;
            aChpx.fsHpsBi = (nFlags8 & 0x02) >> 1;
            aChpx.fsLidBi = (nFlags8 & 0x04) >> 2;

            if (nCount >= nSize) break;
            rSt.ReadUInt16( aChpx.ftc );
            nCount+=2;

            if (nCount >= nSize) break;
            rSt.ReadUInt16( aChpx.hps );
            nCount+=2;

            if (nCount >= nSize) break;
            rSt.ReadUChar( nFlags8 );
            nCount++;

            aChpx.qpsSpace = nFlags8 & 0x3F;
            aChpx.fSysVanish = (nFlags8 & 0x40) >> 6;
            aChpx.fNumRun = (nFlags8 & 0x80) >> 7;

            if (nCount >= nSize) break;
            rSt.ReadUChar( nFlags8 );
            nCount++;

            aChpx.ico = nFlags8 & 0x1F;
            aChpx.kul = (nFlags8 & 0xE0) >> 5;

            if (nCount >= nSize) break;
            rSt.ReadUChar( aChpx.hpsPos );
            nCount++;

            if (nCount >= nSize) break;
            rSt.ReadUChar( aChpx.icoBi );
            nCount++;

            if (nCount >= nSize) break;
            rSt.ReadUInt16( aChpx.lid );
            nCount+=2;

            if (nCount >= nSize) break;
            rSt.ReadUInt16( aChpx.ftcBi );
            nCount+=2;

            if (nCount >= nSize) break;
            rSt.ReadUInt16( aChpx.hpsBi );
            nCount+=2;

            if (nCount >= nSize) break;
            rSt.ReadUInt16( aChpx.lidBi );
            nCount+=2;

            if (nCount >= nSize) break;
            rSt.ReadUInt32( aChpx.fcPic );
            nCount+=4;

            break;
        }

        rSt.SeekRel(nSize-nCount);
        return aChpx;
    }

    namespace
    {
        struct pxoffset { std::size_t mnOffset; sal_uInt8 mnSize; };
    }

    void WW8RStyle::ImportOldFormatStyles()
    {
        for (sal_uInt16 i=0; i < m_cstd; ++i)
        {
            mpIo->m_vColl[i].m_bColl = true;
            //every chain must end eventually at the null style (style code 222)
            mpIo->m_vColl[i].m_nBase = 222;
        }

        rtl_TextEncoding eStructChrSet = WW8Fib::GetFIBCharset(
            mpIo->m_xWwFib->m_chseTables, mpIo->m_xWwFib->m_lid);

        sal_uInt16 cstcStd(0);
        m_rStream.ReadUInt16( cstcStd );

        size_t nMaxByteCount = m_rStream.remainingSize();
        sal_uInt16 cbName(0);
        m_rStream.ReadUInt16(cbName);
        if (cbName > nMaxByteCount)
        {
            SAL_WARN("sw.ww8", "WW8RStyle::ImportOldFormatStyles: truncating out of range "
                << cbName << " to " << nMaxByteCount);
            cbName = nMaxByteCount;
        }
        sal_uInt16 nByteCount = 2;
        sal_uInt16 stcp=0;
        while (nByteCount < cbName)
        {
            sal_uInt8 nCount(0);
            m_rStream.ReadUChar( nCount );
            nByteCount++;

            sal_uInt8 stc = static_cast< sal_uInt8 >((stcp - cstcStd) & 255);
            if (stc >=mpIo->m_vColl.size())
                continue;

            SwWW8StyInf &rSI = mpIo->m_vColl[stc];
            OUString sName;

            if (nCount != 0xFF)    // undefined style
            {
                if (nCount != 0)   // user style
                {
                    OString aTmp = read_uInt8s_ToOString(m_rStream, nCount);
                    nByteCount += aTmp.getLength();
                    sName = OStringToOUString(aTmp, eStructChrSet);
                }
                rSI.m_bImported = true;
            }

            if (sName.isEmpty())
            {
                ww::sti eSti = ww::GetCanonicalStiFromStc(stc);
                if (const sal_Char *pStr = GetEnglishNameFromSti(eSti))
                    sName = OUString(pStr, strlen(pStr), RTL_TEXTENCODING_ASCII_US);
            }

            if (sName.isEmpty())
                sName = "Unknown Style: " + OUString::number(stc);

            rSI.SetOrgWWIdent(sName, stc);
            stcp++;
        }

        sal_uInt16 nStyles=stcp;

        std::vector<pxoffset> aCHPXOffsets(stcp);
        nMaxByteCount = m_rStream.remainingSize();
        sal_uInt16 cbChpx(0);
        m_rStream.ReadUInt16(cbChpx);
        if (cbChpx > nMaxByteCount)
        {
            SAL_WARN("sw.ww8", "WW8RStyle::ImportOldFormatStyles: truncating out of range "
                << cbChpx << " to " << nMaxByteCount);
            cbChpx = nMaxByteCount;
        }
        nByteCount = 2;
        stcp=0;
        std::vector< std::vector<sal_uInt8> > aConvertedChpx;
        while (nByteCount < cbChpx)
        {
            if (stcp == aCHPXOffsets.size())
            {
                //more data than style slots, skip remainder
                m_rStream.SeekRel(cbChpx-nByteCount);
                break;
            }

            sal_uInt8 cb(0);
            m_rStream.ReadUChar( cb );
            nByteCount++;

            aCHPXOffsets[stcp].mnSize = 0;

            if (cb != 0xFF)
            {
                sal_uInt8 nRemainder = cb;

                aCHPXOffsets[stcp].mnOffset = m_rStream.Tell();
                aCHPXOffsets[stcp].mnSize = nRemainder;

                Word2CHPX aChpx = ReadWord2Chpx(m_rStream, aCHPXOffsets[stcp].mnOffset,
                    aCHPXOffsets[stcp].mnSize);
                aConvertedChpx.push_back( ChpxToSprms(aChpx) );

                nByteCount += nRemainder;
            }
            else
                aConvertedChpx.emplace_back( );

            ++stcp;
        }

        std::vector<pxoffset> aPAPXOffsets(stcp);
        nMaxByteCount = m_rStream.remainingSize();
        sal_uInt16 cbPapx(0);
        m_rStream.ReadUInt16(cbPapx);
        if (cbPapx > nMaxByteCount)
        {
            SAL_WARN("sw.ww8", "WW8RStyle::ImportOldFormatStyles: truncating out of range "
                << cbPapx << " to " << nMaxByteCount);
            cbPapx = nMaxByteCount;
        }
        nByteCount = 2;
        stcp=0;
        while (nByteCount < cbPapx)
        {
            if (stcp == aPAPXOffsets.size())
            {
                m_rStream.SeekRel(cbPapx-nByteCount);
                break;
            }

            sal_uInt8 cb(0);
            m_rStream.ReadUChar( cb );
            nByteCount++;

            aPAPXOffsets[stcp].mnSize = 0;

            if (cb != 0xFF)
            {
                sal_uInt8 stc2(0);
                m_rStream.ReadUChar( stc2 );
                m_rStream.SeekRel(6);
                nByteCount+=7;
                sal_uInt8 nRemainder = cb-7;

                aPAPXOffsets[stcp].mnOffset = m_rStream.Tell();
                aPAPXOffsets[stcp].mnSize = nRemainder;

                m_rStream.SeekRel(nRemainder);
                nByteCount += nRemainder;
            }

            ++stcp;
        }

        sal_uInt16 iMac(0);
        m_rStream.ReadUInt16( iMac );

        if (iMac > nStyles) iMac = nStyles;

        for (stcp = 0; stcp < iMac; ++stcp)
        {
            sal_uInt8 stcNext(0), stcBase(0);
            m_rStream.ReadUChar( stcNext );
            m_rStream.ReadUChar( stcBase );

            sal_uInt8 stc = static_cast< sal_uInt8 >((stcp - cstcStd) & 255);

            /*
              #i64557# style based on itself
              every chain must end eventually at the null style (style code 222)
            */
            if (stc == stcBase)
                stcBase = 222;

            SwWW8StyInf &rSI = mpIo->m_vColl[stc];
            rSI.m_nBase = stcBase;

            ww::sti eSti = ww::GetCanonicalStiFromStc(stc);

            if (eSti == ww::stiNil)
                continue;

            if (stcp >= aPAPXOffsets.size())
                continue;

            rSI.m_bValid = true;

            if (ww::StandardStiIsCharStyle(eSti) && !aPAPXOffsets[stcp].mnSize)
                mpIo->m_vColl[stc].m_bColl = false;

            bool bOldNoImp = PrepareStyle(rSI, eSti, stc, stcNext);

            ImportSprms(aPAPXOffsets[stcp].mnOffset, aPAPXOffsets[stcp].mnSize,
                true);

            if (aConvertedChpx[stcp].size() > 0)
                ImportSprms(&(aConvertedChpx[stcp][0]),
                            static_cast< short >(aConvertedChpx[stcp].size()),
                            false);

            PostStyle(rSI, bOldNoImp);
        }
    }

    void WW8RStyle::ImportNewFormatStyles()
    {
        ScanStyles();                       // Scan Based On

        for (sal_uInt16 i = 0; i < m_cstd; ++i) // import Styles
            if (mpIo->m_vColl[i].m_bValid)
                Import1Style( i );
    }

    void WW8RStyle::Import()
    {
        mpIo->m_pDfltTextFormatColl  = mpIo->m_rDoc.GetDfltTextFormatColl();
        mpIo->m_pStandardFormatColl =
            mpIo->m_rDoc.getIDocumentStylePoolAccess().GetTextCollFromPool(RES_POOLCOLL_STANDARD, false);

        if( mpIo->m_nIniFlags & WW8FL_NO_STYLES )
            return;

        if (mpIo->m_xWwFib->GetFIBVersion() <= ww::eWW2)
            ImportOldFormatStyles();
        else
            ImportNewFormatStyles();

        for (sal_uInt16 i = 0; i < m_cstd; ++i)
        {
            // Follow chain
            SwWW8StyInf* pi = &mpIo->m_vColl[i];
            sal_uInt16 j = pi->m_nFollow;
            if( j < m_cstd )
            {
                SwWW8StyInf* pj = &mpIo->m_vColl[j];
                if ( j != i                             // rational Index ?
                     && pi->m_pFormat                        // Format ok ?
                     && pj->m_pFormat                        // Derived-Format ok ?
                     && pi->m_bColl                       // only possible for paragraph templates (WW)
                     && pj->m_bColl ){                    // identical Type ?
                        static_cast<SwTextFormatColl*>(pi->m_pFormat)->SetNextTextFormatColl(
                         *static_cast<SwTextFormatColl*>(pj->m_pFormat) );    // ok, register
                }
            }
        }

        // Missing special handling for default character template
        // "Absatz-Standardschriftart" ( Style-ID 65 ).
        // That is empty by default ( WW6 dt and US ) and not changeable
        // via WW-UI so this does not matter.
        // This could be done by:
        //  if( bNew ) rDoc.SetDefault( pDefCharFormat->GetAttrSet() );

        // for e.g. tables an always valid Std-Style is necessary

        if( mpIo->StyleExists(0) && !mpIo->m_vColl.empty() &&
            mpIo->m_vColl[0].m_pFormat && mpIo->m_vColl[0].m_bColl && mpIo->m_vColl[0].m_bValid )
            mpIo->m_pDfltTextFormatColl = static_cast<SwTextFormatColl*>(mpIo->m_vColl[0].m_pFormat);
        else
            mpIo->m_pDfltTextFormatColl = mpIo->m_rDoc.GetDfltTextFormatColl();

        // set Hyphenation flag on BASIC para-style
        if (mpIo->m_bNewDoc && mpIo->m_pStandardFormatColl)
        {
            if (mpIo->m_xWDop->fAutoHyphen
                && SfxItemState::SET != mpIo->m_pStandardFormatColl->GetItemState(
                                                RES_PARATR_HYPHENZONE, false) )
            {
                SvxHyphenZoneItem aAttr(true, RES_PARATR_HYPHENZONE);
                aAttr.GetMinLead()    = 2;
                aAttr.GetMinTrail()   = 2;
                aAttr.GetMaxHyphens() = 0;

                mpIo->m_pStandardFormatColl->SetFormatAttr( aAttr );
            }

            /*
            Word defaults to ltr not from environment like writer. Regardless of
            the page/sections rtl setting the standard style lack of rtl still
            means ltr
            */
            if (SfxItemState::SET != mpIo->m_pStandardFormatColl->GetItemState(RES_FRAMEDIR,
                false))
            {
               mpIo->m_pStandardFormatColl->SetFormatAttr(
                    SvxFrameDirectionItem(SvxFrameDirection::Horizontal_LR_TB, RES_FRAMEDIR));
            }
        }

        // we do not read styles anymore:
        mpIo->m_pCurrentColl = nullptr;
    }

    rtl_TextEncoding SwWW8StyInf::GetCharSet() const
    {
        if ((m_pFormat) && (m_pFormat->GetFrameDir().GetValue() == SvxFrameDirection::Horizontal_RL_TB))
            return m_eRTLFontSrcCharSet;
        return m_eLTRFontSrcCharSet;
    }

    rtl_TextEncoding SwWW8StyInf::GetCJKCharSet() const
    {
        if ((m_pFormat) && (m_pFormat->GetFrameDir().GetValue() == SvxFrameDirection::Horizontal_RL_TB))
            return m_eRTLFontSrcCharSet;
        return m_eCJKFontSrcCharSet;
    }

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

↑ V590 Consider inspecting the '* pData <= MAXLEVEL && * pData <= 9' expression. The expression is excessive or contains a misprint.

↑ V590 Consider inspecting this expression. The expression is excessive or contains a misprint.

↑ V614 Uninitialized variable 'nWwCols' used.

↑ V773 The 'pNewBand' pointer was assigned values twice without releasing the memory. A memory leak is possible.

↑ V1004 The 'pParams' pointer was used unsafely after it was verified against nullptr. Check lines: 1469, 1473.

↑ V547 Expression '!bSetCantSplit' is always false.

↑ V1029 Numeric Truncation Error. Result of the 'size' function is written to the 16-bit variable.