summaryrefslogtreecommitdiffstats
path: root/editeng/source/rtf
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-15 05:54:39 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-15 05:54:39 +0000
commit267c6f2ac71f92999e969232431ba04678e7437e (patch)
tree358c9467650e1d0a1d7227a21dac2e3d08b622b2 /editeng/source/rtf
parentInitial commit. (diff)
downloadlibreoffice-267c6f2ac71f92999e969232431ba04678e7437e.tar.xz
libreoffice-267c6f2ac71f92999e969232431ba04678e7437e.zip
Adding upstream version 4:24.2.0.upstream/4%24.2.0
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'editeng/source/rtf')
-rw-r--r--editeng/source/rtf/rtfitem.cxx1873
-rw-r--r--editeng/source/rtf/svxrtf.cxx1162
2 files changed, 3035 insertions, 0 deletions
diff --git a/editeng/source/rtf/rtfitem.cxx b/editeng/source/rtf/rtfitem.cxx
new file mode 100644
index 0000000000..bf6b002f97
--- /dev/null
+++ b/editeng/source/rtf/rtfitem.cxx
@@ -0,0 +1,1873 @@
+/* -*- 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 <editeng/fontitem.hxx>
+#include <editeng/postitem.hxx>
+#include <editeng/wghtitem.hxx>
+#include <editeng/fhgtitem.hxx>
+#include <editeng/udlnitem.hxx>
+#include <editeng/crossedoutitem.hxx>
+#include <editeng/shdditem.hxx>
+#include <editeng/autokernitem.hxx>
+#include <editeng/wrlmitem.hxx>
+#include <editeng/contouritem.hxx>
+#include <editeng/colritem.hxx>
+#include <editeng/kernitem.hxx>
+#include <editeng/cmapitem.hxx>
+#include <editeng/escapementitem.hxx>
+#include <editeng/langitem.hxx>
+#include <editeng/emphasismarkitem.hxx>
+#include <editeng/twolinesitem.hxx>
+#include <editeng/lrspitem.hxx>
+#include <editeng/ulspitem.hxx>
+#include <editeng/shaditem.hxx>
+#include <editeng/borderline.hxx>
+#include <editeng/boxitem.hxx>
+#include <editeng/keepitem.hxx>
+#include <editeng/brushitem.hxx>
+#include <editeng/lspcitem.hxx>
+#include <editeng/adjustitem.hxx>
+#include <editeng/tstpitem.hxx>
+#include <editeng/spltitem.hxx>
+#include <editeng/hyphenzoneitem.hxx>
+#include <editeng/charscaleitem.hxx>
+#include <editeng/charrotateitem.hxx>
+#include <editeng/charreliefitem.hxx>
+#include <editeng/paravertalignitem.hxx>
+#include <editeng/forbiddenruleitem.hxx>
+#include <editeng/hngpnctitem.hxx>
+#include <editeng/scriptspaceitem.hxx>
+#include <editeng/frmdiritem.hxx>
+#include <editeng/charhiddenitem.hxx>
+
+#include <svtools/rtftoken.h>
+#include <svl/itempool.hxx>
+#include <svl/itemiter.hxx>
+#include <sal/log.hxx>
+#include <vcl/font.hxx>
+
+#include <editeng/svxrtf.hxx>
+#include <editeng/editids.hrc>
+
+#include <limits.h>
+
+#define BRACELEFT '{'
+#define BRACERIGHT '}'
+
+using namespace ::com::sun::star;
+using namespace editeng;
+
+void SvxRTFParser::SetScriptAttr( RTF_CharTypeDef eType, SfxItemSet& rSet,
+ SfxPoolItem& rItem )
+{
+ std::optional<sal_uInt16> pNormal;
+ std::optional<sal_uInt16> pCJK;
+ std::optional<sal_uInt16> pCTL;
+ switch( rItem.Which() )
+ {
+ case SID_ATTR_CHAR_FONT:
+ pNormal = aPlainMap[SID_ATTR_CHAR_FONT];
+ pCJK = aPlainMap[SID_ATTR_CHAR_CJK_FONT];
+ pCTL = aPlainMap[SID_ATTR_CHAR_CTL_FONT];
+ break;
+
+ case SID_ATTR_CHAR_FONTHEIGHT:
+ pNormal = aPlainMap[SID_ATTR_CHAR_FONTHEIGHT];
+ pCJK = aPlainMap[SID_ATTR_CHAR_CJK_FONTHEIGHT];
+ pCTL = aPlainMap[SID_ATTR_CHAR_CTL_FONTHEIGHT];
+ break;
+
+ case SID_ATTR_CHAR_POSTURE:
+ pNormal = aPlainMap[SID_ATTR_CHAR_POSTURE];
+ pCJK = aPlainMap[SID_ATTR_CHAR_CJK_POSTURE];
+ pCTL = aPlainMap[SID_ATTR_CHAR_CTL_POSTURE];
+ break;
+
+ case SID_ATTR_CHAR_WEIGHT:
+ pNormal = aPlainMap[SID_ATTR_CHAR_WEIGHT];
+ pCJK = aPlainMap[SID_ATTR_CHAR_CJK_WEIGHT];
+ pCTL = aPlainMap[SID_ATTR_CHAR_CTL_WEIGHT];
+ break;
+
+ case SID_ATTR_CHAR_LANGUAGE:
+ pNormal = aPlainMap[SID_ATTR_CHAR_LANGUAGE];
+ pCJK = aPlainMap[SID_ATTR_CHAR_CJK_LANGUAGE];
+ pCTL = aPlainMap[SID_ATTR_CHAR_CTL_LANGUAGE];
+ break;
+
+ case 0:
+ // it exist no WhichId - don't set this item
+ break;
+
+ default:
+ rSet.Put( rItem );
+ break;
+ }
+
+ if( DOUBLEBYTE_CHARTYPE == eType )
+ {
+ if( bIsLeftToRightDef && pCJK )
+ {
+ rItem.SetWhich( *pCJK );
+ rSet.Put( rItem );
+ }
+ }
+ else if( !bIsLeftToRightDef )
+ {
+ if( pCTL )
+ {
+ rItem.SetWhich( *pCTL );
+ rSet.Put( rItem );
+ }
+ }
+ else
+ {
+ if( LOW_CHARTYPE == eType )
+ {
+ if( pNormal )
+ {
+ rItem.SetWhich( *pNormal );
+ rSet.Put( rItem );
+ }
+ }
+ else if( HIGH_CHARTYPE == eType )
+ {
+ if( pCTL )
+ {
+ rItem.SetWhich( *pCTL );
+ rSet.Put( rItem );
+ }
+ }
+ else
+ {
+ if( pCJK )
+ {
+ rItem.SetWhich( *pCJK );
+ rSet.Put( rItem );
+ }
+ if( pCTL )
+ {
+ rItem.SetWhich( *pCTL );
+ rSet.Put( rItem );
+ }
+ if( pNormal )
+ {
+ rItem.SetWhich( *pNormal );
+ rSet.Put( rItem );
+ }
+ }
+ }
+}
+
+
+void SvxRTFParser::ReadAttr( int nToken, SfxItemSet* pSet )
+{
+ DBG_ASSERT( pSet, "A SfxItemSet has to be provided as argument!" );
+ bool bFirstToken = true;
+ bool bContinue = true;
+ FontLineStyle eUnderline;
+ FontLineStyle eOverline;
+ FontEmphasisMark eEmphasis;
+ RTF_CharTypeDef eCharType = NOTDEF_CHARTYPE;
+ SvxParaVertAlignItem::Align nFontAlign;
+
+ bool bChkStkPos = !bNewGroup && !aAttrStack.empty();
+
+ while( bContinue && IsParserWorking() ) // as long as known Attribute are recognized
+ {
+ switch( nToken )
+ {
+ case RTF_PARD:
+ RTFPardPlain( true, &pSet );
+ break;
+
+ case RTF_PLAIN:
+ RTFPardPlain( false, &pSet );
+ break;
+
+ default:
+ do { // middle checked loop
+ if( !bChkStkPos )
+ break;
+
+ SvxRTFItemStackType* pCurrent = aAttrStack.empty() ? nullptr : aAttrStack.back().get();
+ if( !pCurrent || (pCurrent->mxStartNodeIdx->GetIdx() == mxInsertPosition->GetNodeIdx() &&
+ pCurrent->nSttCnt == mxInsertPosition->GetCntIdx() ))
+ break;
+
+ int nLastToken = GetStackPtr(-1)->nTokenId;
+ if( RTF_PARD == nLastToken || RTF_PLAIN == nLastToken )
+ break;
+
+ if (pCurrent->aAttrSet.Count() || !pCurrent->maChildList.empty() ||
+ pCurrent->nStyleNo )
+ {
+ // Open a new Group
+ auto xNew(std::make_unique<SvxRTFItemStackType>(*pCurrent, *mxInsertPosition, true));
+ xNew->SetRTFDefaults( GetRTFDefaults() );
+
+ // "Set" all valid attributes up until this point
+ AttrGroupEnd();
+ pCurrent = aAttrStack.empty() ? nullptr : aAttrStack.back().get(); // can be changed after AttrGroupEnd!
+ xNew->aAttrSet.SetParent( pCurrent ? &pCurrent->aAttrSet : nullptr );
+
+ aAttrStack.push_back( std::move(xNew) );
+ pCurrent = aAttrStack.back().get();
+ }
+ else
+ // continue to use this entry as a new one
+ pCurrent->SetStartPos( *mxInsertPosition );
+
+ pSet = &pCurrent->aAttrSet;
+ } while( false );
+
+ switch( nToken )
+ {
+ case RTF_INTBL:
+ case RTF_PAGEBB:
+ case RTF_SBYS:
+ case RTF_CS:
+ case RTF_LS:
+ case RTF_ILVL:
+ UnknownAttrToken( nToken );
+ break;
+
+ case RTF_S:
+ if( bIsInReadStyleTab )
+ {
+ if( !bFirstToken )
+ SkipToken();
+ bContinue = false;
+ }
+ else
+ {
+ sal_uInt16 nStyleNo = -1 == nTokenValue ? 0 : sal_uInt16(nTokenValue);
+ // set StyleNo to the current style on the AttrStack
+ SvxRTFItemStackType* pCurrent = aAttrStack.empty() ? nullptr : aAttrStack.back().get();
+ if( !pCurrent )
+ break;
+
+ pCurrent->nStyleNo = nStyleNo;
+ }
+ break;
+
+ case RTF_KEEP:
+ if (const TypedWhichId<SvxFormatSplitItem> wid = aPardMap[SID_ATTR_PARA_SPLIT])
+ {
+ pSet->Put(SvxFormatSplitItem(false, wid));
+ }
+ break;
+
+ case RTF_KEEPN:
+ if (const TypedWhichId<SvxFormatKeepItem> wid = aPardMap[SID_ATTR_PARA_KEEP])
+ {
+ pSet->Put(SvxFormatKeepItem(true, wid));
+ }
+ break;
+
+ case RTF_LEVEL:
+ if (const TypedWhichId<SfxInt16Item> wid = aPardMap[SID_ATTR_PARA_OUTLLEVEL])
+ {
+ pSet->Put(SfxInt16Item(wid, static_cast<sal_uInt16>(nTokenValue)));
+ }
+ break;
+
+ case RTF_QL:
+ if (const TypedWhichId<SvxAdjustItem> wid = aPardMap[SID_ATTR_PARA_ADJUST])
+ {
+ pSet->Put(SvxAdjustItem(SvxAdjust::Left, wid));
+ }
+ break;
+ case RTF_QR:
+ if (const TypedWhichId<SvxAdjustItem> wid = aPardMap[SID_ATTR_PARA_ADJUST])
+ {
+ pSet->Put(SvxAdjustItem(SvxAdjust::Right, wid));
+ }
+ break;
+ case RTF_QJ:
+ if (const TypedWhichId<SvxAdjustItem> wid = aPardMap[SID_ATTR_PARA_ADJUST])
+ {
+ pSet->Put(SvxAdjustItem(SvxAdjust::Block, wid));
+ }
+ break;
+ case RTF_QC:
+ if (const TypedWhichId<SvxAdjustItem> wid = aPardMap[SID_ATTR_PARA_ADJUST])
+ {
+ pSet->Put(SvxAdjustItem(SvxAdjust::Center, wid));
+ }
+ break;
+
+ case RTF_FI:
+ if (const TypedWhichId<SvxLRSpaceItem> wid = aPardMap[SID_ATTR_LRSPACE])
+ {
+ SvxLRSpaceItem aLR(pSet->Get(wid));
+ sal_uInt16 nSz = 0;
+ if( -1 != nTokenValue )
+ {
+ if( IsCalcValue() )
+ CalcValue();
+ nSz = sal_uInt16(nTokenValue);
+ }
+ aLR.SetTextFirstLineOffset( nSz );
+ pSet->Put( aLR );
+ }
+ break;
+
+ case RTF_LI:
+ case RTF_LIN:
+ if (const TypedWhichId<SvxLRSpaceItem> wid = aPardMap[SID_ATTR_LRSPACE])
+ {
+ SvxLRSpaceItem aLR(pSet->Get(wid));
+ sal_uInt16 nSz = 0;
+ if( 0 < nTokenValue )
+ {
+ if( IsCalcValue() )
+ CalcValue();
+ nSz = sal_uInt16(nTokenValue);
+ }
+ aLR.SetTextLeft( nSz );
+ pSet->Put( aLR );
+ }
+ break;
+
+ case RTF_RI:
+ case RTF_RIN:
+ if (const TypedWhichId<SvxLRSpaceItem> wid = aPardMap[SID_ATTR_LRSPACE])
+ {
+ SvxLRSpaceItem aLR(pSet->Get(wid));
+ sal_uInt16 nSz = 0;
+ if( 0 < nTokenValue )
+ {
+ if( IsCalcValue() )
+ CalcValue();
+ nSz = sal_uInt16(nTokenValue);
+ }
+ aLR.SetRight( nSz );
+ pSet->Put( aLR );
+ }
+ break;
+
+ case RTF_SB:
+ if (const TypedWhichId<SvxULSpaceItem> wid = aPardMap[SID_ATTR_ULSPACE])
+ {
+ SvxULSpaceItem aUL(pSet->Get(wid));
+ sal_uInt16 nSz = 0;
+ if( 0 < nTokenValue )
+ {
+ if( IsCalcValue() )
+ CalcValue();
+ nSz = sal_uInt16(nTokenValue);
+ }
+ aUL.SetUpper( nSz );
+ pSet->Put( aUL );
+ }
+ break;
+
+ case RTF_SA:
+ if (const TypedWhichId<SvxULSpaceItem> wid = aPardMap[SID_ATTR_ULSPACE])
+ {
+ SvxULSpaceItem aUL(pSet->Get(wid));
+ sal_uInt16 nSz = 0;
+ if( 0 < nTokenValue )
+ {
+ if( IsCalcValue() )
+ CalcValue();
+ nSz = sal_uInt16(nTokenValue);
+ }
+ aUL.SetLower( nSz );
+ pSet->Put( aUL );
+ }
+ break;
+
+ case RTF_SLMULT:
+ if (const TypedWhichId<SvxLineSpacingItem> wid = aPardMap[SID_ATTR_PARA_LINESPACE];
+ wid && 1 == nTokenValue)
+ {
+ // then switches to multi-line!
+ SvxLineSpacingItem aLSpace(pSet->Get(wid, false));
+
+ // how much do you get from the line height value?
+
+ // Proportional-Size:
+ // Ie, the ratio is (n / 240) twips
+
+ nTokenValue = 240;
+ if( IsCalcValue() )
+ CalcValue();
+
+ nTokenValue = short( 100 * aLSpace.GetLineHeight() / nTokenValue );
+
+ aLSpace.SetPropLineSpace( static_cast<sal_uInt16>(nTokenValue) );
+ aLSpace.SetLineSpaceRule( SvxLineSpaceRule::Auto );
+
+ pSet->Put( aLSpace );
+ }
+ break;
+
+ case RTF_SL:
+ if (const TypedWhichId<SvxLineSpacingItem> wid = aPardMap[SID_ATTR_PARA_LINESPACE])
+ {
+ // Calculate the ratio between the default font and the
+ // specified size. The distance consists of the line height
+ // (100%) and the space above the line (20%).
+ SvxLineSpacingItem aLSpace(0, wid);
+
+ nTokenValue = !bTokenHasValue ? 0 : nTokenValue;
+ if (1000 == nTokenValue )
+ nTokenValue = 240;
+
+ SvxLineSpaceRule eLnSpc;
+ if (nTokenValue < 0)
+ {
+ eLnSpc = SvxLineSpaceRule::Fix;
+ nTokenValue = -nTokenValue;
+ }
+ else if (nTokenValue == 0)
+ {
+ //if \sl0 is used, the line spacing is automatically
+ //determined
+ eLnSpc = SvxLineSpaceRule::Auto;
+ }
+ else
+ eLnSpc = SvxLineSpaceRule::Min;
+
+ if (IsCalcValue())
+ CalcValue();
+
+ if (eLnSpc != SvxLineSpaceRule::Auto)
+ aLSpace.SetLineHeight( static_cast<sal_uInt16>(nTokenValue) );
+
+ aLSpace.SetLineSpaceRule(eLnSpc);
+ pSet->Put(aLSpace);
+ }
+ break;
+
+ case RTF_NOCWRAP:
+ if (const TypedWhichId<SvxForbiddenRuleItem> wid = aPardMap[SID_ATTR_PARA_FORBIDDEN_RULES])
+ {
+ pSet->Put(SvxForbiddenRuleItem(false, wid));
+ }
+ break;
+ case RTF_NOOVERFLOW:
+ if (const TypedWhichId<SvxHangingPunctuationItem> wid = aPardMap[SID_ATTR_PARA_HANGPUNCTUATION])
+ {
+ pSet->Put(SvxHangingPunctuationItem(false, wid));
+ }
+ break;
+
+ case RTF_ASPALPHA:
+ if (const TypedWhichId<SvxScriptSpaceItem> wid = aPardMap[SID_ATTR_PARA_SCRIPTSPACE])
+ {
+ pSet->Put(SvxScriptSpaceItem(true, wid));
+ }
+ break;
+
+ case RTF_FAFIXED:
+ case RTF_FAAUTO: nFontAlign = SvxParaVertAlignItem::Align::Automatic;
+ goto SET_FONTALIGNMENT;
+ case RTF_FAHANG: nFontAlign = SvxParaVertAlignItem::Align::Top;
+ goto SET_FONTALIGNMENT;
+ case RTF_FAVAR: nFontAlign = SvxParaVertAlignItem::Align::Bottom;
+ goto SET_FONTALIGNMENT;
+ case RTF_FACENTER: nFontAlign = SvxParaVertAlignItem::Align::Center;
+ goto SET_FONTALIGNMENT;
+ case RTF_FAROMAN: nFontAlign = SvxParaVertAlignItem::Align::Baseline;
+ goto SET_FONTALIGNMENT;
+SET_FONTALIGNMENT:
+ if (const TypedWhichId<SvxParaVertAlignItem> wid = aPardMap[SID_PARA_VERTALIGN])
+ {
+ pSet->Put(SvxParaVertAlignItem(nFontAlign, wid));
+ }
+ break;
+
+ case RTF_B:
+ case RTF_AB:
+ if( IsAttrSttPos() ) // not in the text flow?
+ {
+
+ SvxWeightItem aTmpItem(
+ nTokenValue ? WEIGHT_BOLD : WEIGHT_NORMAL,
+ SID_ATTR_CHAR_WEIGHT );
+ SetScriptAttr( eCharType, *pSet, aTmpItem);
+ }
+ break;
+
+ case RTF_CAPS:
+ case RTF_SCAPS:
+ if (const sal_uInt16 wid = aPlainMap[SID_ATTR_CHAR_CASEMAP];
+ wid && IsAttrSttPos()) // not in the text flow?
+ {
+ SvxCaseMap eCaseMap;
+ if( !nTokenValue )
+ eCaseMap = SvxCaseMap::NotMapped;
+ else if( RTF_CAPS == nToken )
+ eCaseMap = SvxCaseMap::Uppercase;
+ else
+ eCaseMap = SvxCaseMap::SmallCaps;
+
+ pSet->Put(SvxCaseMapItem(eCaseMap, wid));
+ }
+ break;
+
+ case RTF_DN:
+ case RTF_SUB:
+ if (const sal_uInt16 nEsc = aPlainMap[SID_ATTR_CHAR_ESCAPEMENT])
+ {
+ if( -1 == nTokenValue )
+ nTokenValue = 6; //RTF default \dn value in half-points
+ if( IsCalcValue() )
+ CalcValue();
+ const SvxEscapementItem& rOld =
+ static_cast<const SvxEscapementItem&>(pSet->Get( nEsc,false));
+ sal_Int16 nEs;
+ sal_uInt8 nProp;
+ if( DFLT_ESC_AUTO_SUPER == rOld.GetEsc() )
+ {
+ nEs = DFLT_ESC_AUTO_SUB;
+ nProp = rOld.GetProportionalHeight();
+ }
+ else
+ {
+ nEs = (nToken == RTF_SUB) ? DFLT_ESC_AUTO_SUB : -nTokenValue;
+ nProp = (nToken == RTF_SUB) ? DFLT_ESC_PROP : 100;
+ }
+ pSet->Put( SvxEscapementItem( nEs, nProp, nEsc ));
+ }
+ break;
+
+ case RTF_NOSUPERSUB:
+ if (const sal_uInt16 nEsc = aPlainMap[SID_ATTR_CHAR_ESCAPEMENT])
+ {
+ pSet->Put( SvxEscapementItem( nEsc ));
+ }
+ break;
+
+ case RTF_EXPND:
+ if (TypedWhichId<SvxKerningItem> wid = aPlainMap[SID_ATTR_CHAR_KERNING])
+ {
+ if( -1 == nTokenValue )
+ nTokenValue = 0;
+ else
+ nTokenValue *= 5;
+ if( IsCalcValue() )
+ CalcValue();
+ pSet->Put(SvxKerningItem(static_cast<short>(nTokenValue), wid));
+ }
+ break;
+
+ case RTF_KERNING:
+ if (const TypedWhichId<SvxAutoKernItem> wid = aPlainMap[SID_ATTR_CHAR_AUTOKERN])
+ {
+ if( -1 == nTokenValue )
+ nTokenValue = 0;
+ else
+ nTokenValue *= 10;
+ if( IsCalcValue() )
+ CalcValue();
+ pSet->Put(SvxAutoKernItem(0 != nTokenValue, wid));
+ }
+ break;
+
+ case RTF_EXPNDTW:
+ if (TypedWhichId<SvxKerningItem> wid = aPlainMap[SID_ATTR_CHAR_KERNING])
+ {
+ if( -1 == nTokenValue )
+ nTokenValue = 0;
+ if( IsCalcValue() )
+ CalcValue();
+ pSet->Put(SvxKerningItem(static_cast<short>(nTokenValue), wid));
+ }
+ break;
+
+ case RTF_F:
+ case RTF_AF:
+ {
+ const vcl::Font& rSVFont = GetFont( sal_uInt16(nTokenValue) );
+ SvxFontItem aTmpItem( rSVFont.GetFamilyType(),
+ rSVFont.GetFamilyName(), rSVFont.GetStyleName(),
+ rSVFont.GetPitch(), rSVFont.GetCharSet(),
+ SID_ATTR_CHAR_FONT );
+ SetScriptAttr( eCharType, *pSet, aTmpItem );
+ if( RTF_F == nToken )
+ {
+ SetEncoding( rSVFont.GetCharSet() );
+ RereadLookahead();
+ }
+ }
+ break;
+
+ case RTF_FS:
+ case RTF_AFS:
+ {
+ if( -1 == nTokenValue )
+ nTokenValue = 240;
+ else
+ nTokenValue *= 10;
+// #i66167#
+// for the SwRTFParser 'IsCalcValue' will be false and for the EditRTFParser
+// the conversion takes now place in EditRTFParser since for other reasons
+// the wrong MapUnit might still be use there
+// if( IsCalcValue() )
+// CalcValue();
+ SvxFontHeightItem aTmpItem(
+ static_cast<sal_uInt16>(nTokenValue), 100,
+ SID_ATTR_CHAR_FONTHEIGHT );
+ SetScriptAttr( eCharType, *pSet, aTmpItem );
+ }
+ break;
+
+ case RTF_I:
+ case RTF_AI:
+ if( IsAttrSttPos() ) // not in the text flow?
+ {
+ SvxPostureItem aTmpItem(
+ nTokenValue ? ITALIC_NORMAL : ITALIC_NONE,
+ SID_ATTR_CHAR_POSTURE );
+ SetScriptAttr( eCharType, *pSet, aTmpItem );
+ }
+ break;
+
+ case RTF_OUTL:
+ if (const TypedWhichId<SvxContourItem> wid = aPlainMap[SID_ATTR_CHAR_CONTOUR];
+ wid && IsAttrSttPos()) // not in the text flow?
+ {
+ pSet->Put(SvxContourItem(nTokenValue != 0, wid));
+ }
+ break;
+
+ case RTF_SHAD:
+ if (const TypedWhichId<SvxShadowedItem> wid = aPlainMap[SID_ATTR_CHAR_SHADOWED];
+ wid && IsAttrSttPos()) // not in the text flow?
+ {
+ pSet->Put(SvxShadowedItem(nTokenValue != 0, wid));
+ }
+ break;
+
+ case RTF_STRIKE:
+ if (const TypedWhichId<SvxCrossedOutItem> wid = aPlainMap[SID_ATTR_CHAR_STRIKEOUT];
+ wid && IsAttrSttPos()) // not in the text flow?
+ {
+ pSet->Put( SvxCrossedOutItem(
+ nTokenValue ? STRIKEOUT_SINGLE : STRIKEOUT_NONE,
+ wid ));
+ }
+ break;
+
+ case RTF_STRIKED:
+ if (const TypedWhichId<SvxCrossedOutItem> wid = aPlainMap[SID_ATTR_CHAR_STRIKEOUT]) // not in the text flow?
+ {
+ pSet->Put( SvxCrossedOutItem(
+ nTokenValue ? STRIKEOUT_DOUBLE : STRIKEOUT_NONE,
+ wid ));
+ }
+ break;
+
+ case RTF_UL:
+ if( !IsAttrSttPos() )
+ break;
+ eUnderline = nTokenValue ? LINESTYLE_SINGLE : LINESTYLE_NONE;
+ goto ATTR_SETUNDERLINE;
+
+ case RTF_ULD:
+ eUnderline = LINESTYLE_DOTTED;
+ goto ATTR_SETUNDERLINE;
+ case RTF_ULDASH:
+ eUnderline = LINESTYLE_DASH;
+ goto ATTR_SETUNDERLINE;
+ case RTF_ULDASHD:
+ eUnderline = LINESTYLE_DASHDOT;
+ goto ATTR_SETUNDERLINE;
+ case RTF_ULDASHDD:
+ eUnderline = LINESTYLE_DASHDOTDOT;
+ goto ATTR_SETUNDERLINE;
+ case RTF_ULDB:
+ eUnderline = LINESTYLE_DOUBLE;
+ goto ATTR_SETUNDERLINE;
+ case RTF_ULNONE:
+ eUnderline = LINESTYLE_NONE;
+ goto ATTR_SETUNDERLINE;
+ case RTF_ULTH:
+ eUnderline = LINESTYLE_BOLD;
+ goto ATTR_SETUNDERLINE;
+ case RTF_ULWAVE:
+ eUnderline = LINESTYLE_WAVE;
+ goto ATTR_SETUNDERLINE;
+ case RTF_ULTHD:
+ eUnderline = LINESTYLE_BOLDDOTTED;
+ goto ATTR_SETUNDERLINE;
+ case RTF_ULTHDASH:
+ eUnderline = LINESTYLE_BOLDDASH;
+ goto ATTR_SETUNDERLINE;
+ case RTF_ULLDASH:
+ eUnderline = LINESTYLE_LONGDASH;
+ goto ATTR_SETUNDERLINE;
+ case RTF_ULTHLDASH:
+ eUnderline = LINESTYLE_BOLDLONGDASH;
+ goto ATTR_SETUNDERLINE;
+ case RTF_ULTHDASHD:
+ eUnderline = LINESTYLE_BOLDDASHDOT;
+ goto ATTR_SETUNDERLINE;
+ case RTF_ULTHDASHDD:
+ eUnderline = LINESTYLE_BOLDDASHDOTDOT;
+ goto ATTR_SETUNDERLINE;
+ case RTF_ULHWAVE:
+ eUnderline = LINESTYLE_BOLDWAVE;
+ goto ATTR_SETUNDERLINE;
+ case RTF_ULULDBWAVE:
+ eUnderline = LINESTYLE_DOUBLEWAVE;
+ goto ATTR_SETUNDERLINE;
+
+ case RTF_ULW:
+ eUnderline = LINESTYLE_SINGLE;
+
+ if (const TypedWhichId<SvxWordLineModeItem> wid = aPlainMap[SID_ATTR_CHAR_WORDLINEMODE])
+ {
+ pSet->Put(SvxWordLineModeItem(true, wid));
+ }
+ goto ATTR_SETUNDERLINE;
+
+ATTR_SETUNDERLINE:
+ if (const sal_uInt16 wid = aPlainMap[SID_ATTR_CHAR_UNDERLINE])
+ {
+ pSet->Put(SvxUnderlineItem(eUnderline, wid));
+ }
+ break;
+
+ case RTF_ULC:
+ if (const sal_uInt16 wid = aPlainMap[SID_ATTR_CHAR_UNDERLINE])
+ {
+ std::unique_ptr<SvxUnderlineItem> aUL(std::make_unique<SvxUnderlineItem>(LINESTYLE_SINGLE, wid));
+ const SfxPoolItem* pItem(nullptr);
+
+ if (SfxItemState::SET == pSet->GetItemState(wid, false, &pItem))
+ {
+ // is switched off ?
+ if( LINESTYLE_NONE == static_cast<const SvxUnderlineItem*>(pItem)->GetLineStyle() )
+ break;
+
+ aUL.reset(static_cast<SvxUnderlineItem*>(pItem->Clone()));
+ }
+ else
+ {
+ aUL.reset(static_cast<SvxUnderlineItem*>(pSet->Get(wid, false).Clone()));
+ }
+
+ if(LINESTYLE_NONE == aUL->GetLineStyle())
+ {
+ aUL->SetLineStyle(LINESTYLE_SINGLE);
+ }
+
+ aUL->SetColor(GetColor(sal_uInt16(nTokenValue)));
+
+ pSet->Put(std::move(aUL));
+ }
+ break;
+
+ case RTF_OL:
+ if( !IsAttrSttPos() )
+ break;
+ eOverline = nTokenValue ? LINESTYLE_SINGLE : LINESTYLE_NONE;
+ goto ATTR_SETOVERLINE;
+
+ case RTF_OLD:
+ eOverline = LINESTYLE_DOTTED;
+ goto ATTR_SETOVERLINE;
+ case RTF_OLDASH:
+ eOverline = LINESTYLE_DASH;
+ goto ATTR_SETOVERLINE;
+ case RTF_OLDASHD:
+ eOverline = LINESTYLE_DASHDOT;
+ goto ATTR_SETOVERLINE;
+ case RTF_OLDASHDD:
+ eOverline = LINESTYLE_DASHDOTDOT;
+ goto ATTR_SETOVERLINE;
+ case RTF_OLDB:
+ eOverline = LINESTYLE_DOUBLE;
+ goto ATTR_SETOVERLINE;
+ case RTF_OLNONE:
+ eOverline = LINESTYLE_NONE;
+ goto ATTR_SETOVERLINE;
+ case RTF_OLTH:
+ eOverline = LINESTYLE_BOLD;
+ goto ATTR_SETOVERLINE;
+ case RTF_OLWAVE:
+ eOverline = LINESTYLE_WAVE;
+ goto ATTR_SETOVERLINE;
+ case RTF_OLTHD:
+ eOverline = LINESTYLE_BOLDDOTTED;
+ goto ATTR_SETOVERLINE;
+ case RTF_OLTHDASH:
+ eOverline = LINESTYLE_BOLDDASH;
+ goto ATTR_SETOVERLINE;
+ case RTF_OLLDASH:
+ eOverline = LINESTYLE_LONGDASH;
+ goto ATTR_SETOVERLINE;
+ case RTF_OLTHLDASH:
+ eOverline = LINESTYLE_BOLDLONGDASH;
+ goto ATTR_SETOVERLINE;
+ case RTF_OLTHDASHD:
+ eOverline = LINESTYLE_BOLDDASHDOT;
+ goto ATTR_SETOVERLINE;
+ case RTF_OLTHDASHDD:
+ eOverline = LINESTYLE_BOLDDASHDOTDOT;
+ goto ATTR_SETOVERLINE;
+ case RTF_OLHWAVE:
+ eOverline = LINESTYLE_BOLDWAVE;
+ goto ATTR_SETOVERLINE;
+ case RTF_OLOLDBWAVE:
+ eOverline = LINESTYLE_DOUBLEWAVE;
+ goto ATTR_SETOVERLINE;
+
+ case RTF_OLW:
+ eOverline = LINESTYLE_SINGLE;
+
+ if (const TypedWhichId<SvxWordLineModeItem> wid = aPlainMap[SID_ATTR_CHAR_WORDLINEMODE])
+ {
+ pSet->Put(SvxWordLineModeItem(true, wid));
+ }
+ goto ATTR_SETOVERLINE;
+
+ATTR_SETOVERLINE:
+ if (const TypedWhichId<SvxOverlineItem> wid = aPlainMap[SID_ATTR_CHAR_OVERLINE])
+ {
+ pSet->Put(SvxOverlineItem(eOverline, wid));
+ }
+ break;
+
+ case RTF_OLC:
+ if (const TypedWhichId<SvxOverlineItem> wid = aPlainMap[SID_ATTR_CHAR_OVERLINE])
+ {
+ std::unique_ptr<SvxOverlineItem> aOL(std::make_unique<SvxOverlineItem>(LINESTYLE_SINGLE, wid));
+ const SfxPoolItem* pItem(nullptr);
+
+ if (SfxItemState::SET == pSet->GetItemState(wid, false, &pItem))
+ {
+ // is switched off ?
+ if( LINESTYLE_NONE == static_cast<const SvxOverlineItem*>(pItem)->GetLineStyle() )
+ break;
+
+ aOL.reset(static_cast<SvxOverlineItem*>(pItem->Clone()));
+ }
+ else
+ {
+ aOL.reset(pSet->Get(wid, false).Clone());
+ }
+
+ if(LINESTYLE_NONE == aOL->GetLineStyle())
+ {
+ aOL->SetLineStyle(LINESTYLE_SINGLE);
+ }
+
+ aOL->SetColor(GetColor(sal_uInt16(nTokenValue)));
+
+ pSet->Put(std::move(aOL));
+ }
+ break;
+
+ case RTF_UP:
+ case RTF_SUPER:
+ if (const sal_uInt16 nEsc = aPlainMap[SID_ATTR_CHAR_ESCAPEMENT])
+ {
+ if( -1 == nTokenValue )
+ nTokenValue = 6; //RTF default \up value in half-points
+ if( IsCalcValue() )
+ CalcValue();
+ const SvxEscapementItem& rOld =
+ static_cast<const SvxEscapementItem&>(pSet->Get( nEsc,false));
+ sal_Int16 nEs;
+ sal_uInt8 nProp;
+ if( DFLT_ESC_AUTO_SUB == rOld.GetEsc() )
+ {
+ nEs = DFLT_ESC_AUTO_SUPER;
+ nProp = rOld.GetProportionalHeight();
+ }
+ else
+ {
+ nEs = (nToken == RTF_SUPER) ? DFLT_ESC_AUTO_SUPER : nTokenValue;
+ nProp = (nToken == RTF_SUPER) ? DFLT_ESC_PROP : 100;
+ }
+ pSet->Put( SvxEscapementItem( nEs, nProp, nEsc ));
+ }
+ break;
+
+ case RTF_CF:
+ if (const sal_uInt16 wid = aPlainMap[SID_ATTR_CHAR_COLOR])
+ {
+ pSet->Put(SvxColorItem(GetColor(sal_uInt16(nTokenValue)), wid));
+ }
+ break;
+ //#i12501# While cb is clearly documented in the rtf spec, word
+ //doesn't accept it at all
+#if 0
+ case RTF_CB:
+ if (const sal_uInt16 wid = aPlainMap[SID_ATTR_BRUSH_CHAR])
+ {
+ pSet->Put(SvxBrushItem(GetColor(sal_uInt16(nTokenValue)), wid));
+ }
+ break;
+#endif
+
+ case RTF_LANG:
+ if (const sal_uInt16 wid = aPlainMap[SID_ATTR_CHAR_LANGUAGE])
+ {
+ pSet->Put(SvxLanguageItem(LanguageType(nTokenValue), wid));
+ }
+ break;
+
+ case RTF_LANGFE:
+ if (const sal_uInt16 wid = aPlainMap[SID_ATTR_CHAR_CJK_LANGUAGE])
+ {
+ pSet->Put(SvxLanguageItem(LanguageType(nTokenValue), wid));
+ }
+ break;
+ case RTF_ALANG:
+ {
+ SvxLanguageItem aTmpItem( LanguageType(nTokenValue),
+ SID_ATTR_CHAR_LANGUAGE );
+ SetScriptAttr( eCharType, *pSet, aTmpItem );
+ }
+ break;
+
+ case RTF_RTLCH:
+ bIsLeftToRightDef = false;
+ break;
+ case RTF_LTRCH:
+ bIsLeftToRightDef = true;
+ break;
+ case RTF_RTLPAR:
+ if (const TypedWhichId<SvxFrameDirectionItem> wid = aPardMap[SID_ATTR_FRAMEDIRECTION])
+ {
+ pSet->Put(SvxFrameDirectionItem(SvxFrameDirection::Horizontal_RL_TB, wid));
+ }
+ break;
+ case RTF_LTRPAR:
+ if (const TypedWhichId<SvxFrameDirectionItem> wid = aPardMap[SID_ATTR_FRAMEDIRECTION])
+ {
+ pSet->Put(SvxFrameDirectionItem(SvxFrameDirection::Horizontal_LR_TB, wid));
+ }
+ break;
+ case RTF_LOCH: eCharType = LOW_CHARTYPE; break;
+ case RTF_HICH: eCharType = HIGH_CHARTYPE; break;
+ case RTF_DBCH: eCharType = DOUBLEBYTE_CHARTYPE; break;
+
+
+ case RTF_ACCNONE:
+ eEmphasis = FontEmphasisMark::NONE;
+ goto ATTR_SETEMPHASIS;
+ case RTF_ACCDOT:
+ eEmphasis = (FontEmphasisMark::Dot | FontEmphasisMark::PosAbove);
+ goto ATTR_SETEMPHASIS;
+
+ case RTF_ACCCOMMA:
+ eEmphasis = (FontEmphasisMark::Accent | FontEmphasisMark::PosAbove);
+ATTR_SETEMPHASIS:
+ if (const TypedWhichId<SvxEmphasisMarkItem> wid = aPlainMap[SID_ATTR_CHAR_EMPHASISMARK])
+ {
+ pSet->Put(SvxEmphasisMarkItem(eEmphasis, wid));
+ }
+ break;
+
+ case RTF_TWOINONE:
+ if (const TypedWhichId<SvxTwoLinesItem> wid = aPlainMap[SID_ATTR_CHAR_TWO_LINES])
+ {
+ sal_Unicode cStt, cEnd;
+ switch ( nTokenValue )
+ {
+ case 1: cStt = '('; cEnd = ')'; break;
+ case 2: cStt = '['; cEnd = ']'; break;
+ case 3: cStt = '<'; cEnd = '>'; break;
+ case 4: cStt = '{'; cEnd = '}'; break;
+ default: cStt = 0; cEnd = 0; break;
+ }
+
+ pSet->Put(SvxTwoLinesItem(true, cStt, cEnd, wid));
+ }
+ break;
+
+ case RTF_CHARSCALEX :
+ if (const TypedWhichId<SvxCharScaleWidthItem> wid = aPlainMap[SID_ATTR_CHAR_SCALEWIDTH])
+ {
+ //i21372
+ if (nTokenValue < 1 || nTokenValue > 600)
+ nTokenValue = 100;
+ pSet->Put(SvxCharScaleWidthItem(sal_uInt16(nTokenValue), wid));
+ }
+ break;
+
+ case RTF_HORZVERT:
+ if (const TypedWhichId<SvxCharRotateItem> wid = aPlainMap[SID_ATTR_CHAR_ROTATED])
+ {
+ // RTF knows only 90deg
+ pSet->Put(SvxCharRotateItem(900_deg10, 1 == nTokenValue, wid));
+ }
+ break;
+
+ case RTF_EMBO:
+ if (const TypedWhichId<SvxCharReliefItem> wid = aPlainMap[SID_ATTR_CHAR_RELIEF])
+ {
+ pSet->Put(SvxCharReliefItem(FontRelief::Embossed, wid));
+ }
+ break;
+ case RTF_IMPR:
+ if (const TypedWhichId<SvxCharReliefItem> wid = aPlainMap[SID_ATTR_CHAR_RELIEF])
+ {
+ pSet->Put(SvxCharReliefItem(FontRelief::Engraved, wid));
+ }
+ break;
+ case RTF_V:
+ if (const TypedWhichId<SvxCharHiddenItem> wid = aPlainMap[SID_ATTR_CHAR_HIDDEN])
+ {
+ pSet->Put(SvxCharHiddenItem(nTokenValue != 0, wid));
+ }
+ break;
+ case RTF_CHBGFDIAG:
+ case RTF_CHBGDKVERT:
+ case RTF_CHBGDKHORIZ:
+ case RTF_CHBGVERT:
+ case RTF_CHBGHORIZ:
+ case RTF_CHBGDKFDIAG:
+ case RTF_CHBGDCROSS:
+ case RTF_CHBGCROSS:
+ case RTF_CHBGBDIAG:
+ case RTF_CHBGDKDCROSS:
+ case RTF_CHBGDKCROSS:
+ case RTF_CHBGDKBDIAG:
+ case RTF_CHCBPAT:
+ case RTF_CHCFPAT:
+ case RTF_CHSHDNG:
+ if (aPlainMap[SID_ATTR_BRUSH_CHAR])
+ ReadBackgroundAttr( nToken, *pSet );
+ break;
+
+ case BRACELEFT:
+ {
+ // tests on Swg internal tokens
+ bool bHandled = false;
+ short nSkip = 0;
+ if( RTF_IGNOREFLAG != GetNextToken())
+ nSkip = -1;
+ else if( (nToken = GetNextToken() ) & RTF_SWGDEFS )
+ {
+ bHandled = true;
+ switch( nToken )
+ {
+ case RTF_PGDSCNO:
+ case RTF_PGBRK:
+ case RTF_SOUTLVL:
+ UnknownAttrToken( nToken );
+ // overwrite the closing parenthesis
+ break;
+
+ case RTF_SWG_ESCPROP:
+ {
+ // Store percentage change!
+ sal_uInt8 nProp = sal_uInt8( nTokenValue / 100 );
+ short nEsc = 0;
+ if( 1 == ( nTokenValue % 100 ))
+ // Recognize own auto-flags!
+ nEsc = DFLT_ESC_AUTO_SUPER;
+
+ if (const sal_uInt16 wid = aPlainMap[SID_ATTR_CHAR_ESCAPEMENT])
+ pSet->Put(SvxEscapementItem(nEsc, nProp, wid));
+ }
+ break;
+
+ case RTF_HYPHEN:
+ {
+ SvxHyphenZoneItem aHypenZone(
+ (nTokenValue & 1) != 0,
+ aPardMap[SID_ATTR_PARA_HYPHENZONE]);
+ aHypenZone.SetPageEnd((nTokenValue & 2) != 0);
+
+ if( aPardMap[SID_ATTR_PARA_HYPHENZONE] &&
+ RTF_HYPHLEAD == GetNextToken() &&
+ RTF_HYPHTRAIL == GetNextToken() &&
+ RTF_HYPHMAX == GetNextToken() )
+ {
+ aHypenZone.GetMinLead() =
+ sal_uInt8(GetStackPtr( -2 )->nTokenValue);
+ aHypenZone.GetMinTrail() =
+ sal_uInt8(GetStackPtr( -1 )->nTokenValue);
+ aHypenZone.GetMaxHyphens() =
+ sal_uInt8(nTokenValue);
+
+ pSet->Put( aHypenZone );
+ }
+ else
+ SkipGroup(); // at the end of the group
+ }
+ break;
+
+ // We expect these to be preceded by a RTF_HYPHEN and
+ // so normally are handled by the RTF_HYPHEN case, but
+ // if they appear 'bare' in a document then safely skip
+ // them here
+ case RTF_HYPHLEAD:
+ case RTF_HYPHTRAIL:
+ case RTF_HYPHMAX:
+ SkipGroup();
+ break;
+
+ case RTF_SHADOW:
+ {
+ bool bSkip = true;
+ do { // middle check loop
+ SvxShadowLocation eSL = SvxShadowLocation( nTokenValue );
+ if( RTF_SHDW_DIST != GetNextToken() )
+ break;
+ sal_uInt16 nDist = sal_uInt16( nTokenValue );
+
+ if( RTF_SHDW_STYLE != GetNextToken() )
+ break;
+
+ if( RTF_SHDW_COL != GetNextToken() )
+ break;
+ sal_uInt16 nCol = sal_uInt16( nTokenValue );
+
+ if( RTF_SHDW_FCOL != GetNextToken() )
+ break;
+
+ Color aColor = GetColor( nCol );
+
+ if (const TypedWhichId<SvxShadowItem> wid = aPardMap[SID_ATTR_BORDER_SHADOW])
+ pSet->Put(SvxShadowItem(wid, &aColor, nDist, eSL));
+
+ bSkip = false;
+ } while( false );
+
+ if( bSkip )
+ SkipGroup(); // at the end of the group
+ }
+ break;
+
+ default:
+ bHandled = false;
+ if( (nToken & ~(0xff | RTF_SWGDEFS)) == RTF_TABSTOPDEF )
+ {
+ nToken = SkipToken( -2 );
+ ReadTabAttr( nToken, *pSet );
+
+ /*
+ cmc: #i76140, he who consumed the { must consume the }
+ We rewound to a state of { being the current
+ token so it is our responsibility to consume the }
+ token if we consumed the {. We will not have consumed
+ the { if it belonged to our caller, i.e. if the { we
+ are handling is the "firsttoken" passed to us then
+ the *caller* must consume it, not us. Otherwise *we*
+ should consume it.
+ */
+ if (nToken == BRACELEFT && !bFirstToken)
+ {
+ nToken = GetNextToken();
+ SAL_WARN_IF( nToken != BRACERIGHT,
+ "editeng",
+ "} did not follow { as expected");
+ }
+ }
+ else if( (nToken & ~(0xff| RTF_SWGDEFS)) == RTF_BRDRDEF)
+ {
+ nToken = SkipToken( -2 );
+ ReadBorderAttr( nToken, *pSet );
+ }
+ else // so no more attribute
+ nSkip = -2;
+ break;
+ }
+
+#if 1
+ /*
+ cmc: #i4727# / #i12713# Who owns this closing bracket?
+ If we read the opening one, we must read this one, if
+ other is counting the brackets so as to push/pop off
+ the correct environment then we will have pushed a new
+ environment for the start { of this, but will not see
+ the } and so is out of sync for the rest of the
+ document.
+ */
+ if (bHandled && !bFirstToken)
+ GetNextToken();
+#endif
+ }
+ else
+ nSkip = -2;
+
+ if( nSkip ) // all completely unknown
+ {
+ if (!bFirstToken)
+ --nSkip; // BRACELEFT: is the next token
+ SkipToken( nSkip );
+ bContinue = false;
+ }
+ }
+ break;
+ default:
+ if( (nToken & ~0xff ) == RTF_TABSTOPDEF )
+ ReadTabAttr( nToken, *pSet );
+ else if( (nToken & ~0xff ) == RTF_BRDRDEF )
+ ReadBorderAttr( nToken, *pSet );
+ else if( (nToken & ~0xff ) == RTF_SHADINGDEF )
+ ReadBackgroundAttr( nToken, *pSet );
+ else
+ {
+ // unknown token, so token "returned in Parser"
+ if( !bFirstToken )
+ SkipToken();
+ bContinue = false;
+ }
+ }
+ }
+ if( bContinue )
+ {
+ nToken = GetNextToken();
+ }
+ bFirstToken = false;
+ }
+}
+
+void SvxRTFParser::ReadTabAttr( int nToken, SfxItemSet& rSet )
+{
+ bool bMethodOwnsToken = false; // #i52542# patch from cmc.
+// then read all the TabStops
+ SvxTabStop aTabStop;
+ SvxTabStopItem aAttr(0, 0, SvxTabAdjust::Default, aPardMap[SID_ATTR_TABSTOP]);
+ bool bContinue = true;
+ do {
+ switch( nToken )
+ {
+ case RTF_TB: // BarTab ???
+ case RTF_TX:
+ {
+ if( IsCalcValue() )
+ CalcValue();
+ aTabStop.GetTabPos() = nTokenValue;
+ aAttr.Insert( aTabStop );
+ aTabStop = SvxTabStop(); // all values default
+ }
+ break;
+
+ case RTF_TQL:
+ aTabStop.GetAdjustment() = SvxTabAdjust::Left;
+ break;
+ case RTF_TQR:
+ aTabStop.GetAdjustment() = SvxTabAdjust::Right;
+ break;
+ case RTF_TQC:
+ aTabStop.GetAdjustment() = SvxTabAdjust::Center;
+ break;
+ case RTF_TQDEC:
+ aTabStop.GetAdjustment() = SvxTabAdjust::Decimal;
+ break;
+
+ case RTF_TLDOT: aTabStop.GetFill() = '.'; break;
+ case RTF_TLHYPH: aTabStop.GetFill() = ' '; break;
+ case RTF_TLUL: aTabStop.GetFill() = '_'; break;
+ case RTF_TLTH: aTabStop.GetFill() = '-'; break;
+ case RTF_TLEQ: aTabStop.GetFill() = '='; break;
+
+ case BRACELEFT:
+ {
+ // Swg - control BRACELEFT RTF_IGNOREFLAG RTF_TLSWG BRACERIGHT
+ short nSkip = 0;
+ if( RTF_IGNOREFLAG != GetNextToken() )
+ nSkip = -1;
+ else if( RTF_TLSWG != ( nToken = GetNextToken() ))
+ nSkip = -2;
+ else
+ {
+ aTabStop.GetDecimal() = sal_uInt8(nTokenValue & 0xff);
+ aTabStop.GetFill() = sal_uInt8((nTokenValue >> 8) & 0xff);
+ // overwrite the closing parenthesis
+ if (bMethodOwnsToken)
+ GetNextToken();
+ }
+ if( nSkip )
+ {
+ SkipToken( nSkip ); // Ignore back again
+ bContinue = false;
+ }
+ }
+ break;
+
+ default:
+ bContinue = false;
+ }
+ if( bContinue )
+ {
+ nToken = GetNextToken();
+ bMethodOwnsToken = true;
+ }
+ } while( bContinue );
+
+ // Fill with defaults is still missing!
+ rSet.Put( aAttr );
+ SkipToken();
+}
+
+static void SetBorderLine( int nBorderTyp, SvxBoxItem& rItem,
+ const SvxBorderLine& rBorder )
+{
+ switch( nBorderTyp )
+ {
+ case RTF_BOX: // run through all levels
+ case RTF_BRDRT:
+ rItem.SetLine( &rBorder, SvxBoxItemLine::TOP );
+ if( RTF_BOX != nBorderTyp )
+ return;
+ [[fallthrough]];
+ case RTF_BRDRB:
+ rItem.SetLine( &rBorder, SvxBoxItemLine::BOTTOM );
+ if( RTF_BOX != nBorderTyp )
+ return;
+ [[fallthrough]];
+ case RTF_BRDRL:
+ rItem.SetLine( &rBorder, SvxBoxItemLine::LEFT );
+ if( RTF_BOX != nBorderTyp )
+ return;
+ [[fallthrough]];
+ case RTF_BRDRR:
+ rItem.SetLine( &rBorder, SvxBoxItemLine::RIGHT );
+ if( RTF_BOX != nBorderTyp )
+ return;
+ }
+}
+
+void SvxRTFParser::ReadBorderAttr( int nToken, SfxItemSet& rSet,
+ bool bTableDef )
+{
+ // then read the border attribute
+ std::unique_ptr<SvxBoxItem> aAttr(std::make_unique<SvxBoxItem>(aPardMap[SID_ATTR_BORDER_OUTER]));
+ const SfxPoolItem* pItem(nullptr);
+
+ if (SfxItemState::SET == rSet.GetItemState(aPardMap[SID_ATTR_BORDER_OUTER], false, &pItem))
+ {
+ aAttr.reset(static_cast<SvxBoxItem*>(pItem->Clone()));
+ }
+
+ SvxBorderLine aBrd( nullptr, SvxBorderLineWidth::Hairline );
+ bool bContinue = true;
+ int nBorderTyp = 0;
+
+ tools::Long nWidth = 1;
+ bool bDoubleWidth = false;
+
+ do {
+ switch( nToken )
+ {
+ case RTF_BOX:
+ case RTF_BRDRT:
+ case RTF_BRDRB:
+ case RTF_BRDRL:
+ case RTF_BRDRR:
+ nBorderTyp = nToken;
+ break;
+
+ case RTF_CLBRDRT: // Cell top border
+ {
+ if( bTableDef )
+ {
+ if (nBorderTyp != 0)
+ SetBorderLine( nBorderTyp, *aAttr, aBrd );
+ nBorderTyp = RTF_BRDRT;
+ }
+ break;
+ }
+ case RTF_CLBRDRB: // Cell bottom border
+ {
+ if( bTableDef )
+ {
+ if (nBorderTyp != 0)
+ SetBorderLine( nBorderTyp, *aAttr, aBrd );
+ nBorderTyp = RTF_BRDRB;
+ }
+ break;
+ }
+ case RTF_CLBRDRL: // Cell left border
+ {
+ if( bTableDef )
+ {
+ if (nBorderTyp != 0)
+ SetBorderLine( nBorderTyp, *aAttr, aBrd );
+ nBorderTyp = RTF_BRDRL;
+ }
+ break;
+ }
+ case RTF_CLBRDRR: // Cell right border
+ {
+ if( bTableDef )
+ {
+ if (nBorderTyp != 0)
+ SetBorderLine( nBorderTyp, *aAttr, aBrd );
+ nBorderTyp = RTF_BRDRR;
+ }
+ break;
+ }
+
+ case RTF_BRDRDOT: // dotted border
+ aBrd.SetBorderLineStyle(SvxBorderLineStyle::DOTTED);
+ break;
+ case RTF_BRDRDASH: // dashed border
+ aBrd.SetBorderLineStyle(SvxBorderLineStyle::DASHED);
+ break;
+ case RTF_BRDRHAIR: // hairline border
+ {
+ aBrd.SetBorderLineStyle( SvxBorderLineStyle::SOLID);
+ aBrd.SetWidth( SvxBorderLineWidth::Hairline );
+ }
+ break;
+ case RTF_BRDRDB: // Double border
+ aBrd.SetBorderLineStyle(SvxBorderLineStyle::DOUBLE);
+ break;
+ case RTF_BRDRINSET: // inset border
+ aBrd.SetBorderLineStyle(SvxBorderLineStyle::INSET);
+ break;
+ case RTF_BRDROUTSET: // outset border
+ aBrd.SetBorderLineStyle(SvxBorderLineStyle::OUTSET);
+ break;
+ case RTF_BRDRTNTHSG: // ThinThick Small gap
+ aBrd.SetBorderLineStyle(SvxBorderLineStyle::THINTHICK_SMALLGAP);
+ break;
+ case RTF_BRDRTNTHMG: // ThinThick Medium gap
+ aBrd.SetBorderLineStyle(SvxBorderLineStyle::THINTHICK_MEDIUMGAP);
+ break;
+ case RTF_BRDRTNTHLG: // ThinThick Large gap
+ aBrd.SetBorderLineStyle(SvxBorderLineStyle::THINTHICK_LARGEGAP);
+ break;
+ case RTF_BRDRTHTNSG: // ThickThin Small gap
+ aBrd.SetBorderLineStyle(SvxBorderLineStyle::THICKTHIN_SMALLGAP);
+ break;
+ case RTF_BRDRTHTNMG: // ThickThin Medium gap
+ aBrd.SetBorderLineStyle(SvxBorderLineStyle::THICKTHIN_MEDIUMGAP);
+ break;
+ case RTF_BRDRTHTNLG: // ThickThin Large gap
+ aBrd.SetBorderLineStyle(SvxBorderLineStyle::THICKTHIN_LARGEGAP);
+ break;
+ case RTF_BRDREMBOSS: // Embossed border
+ aBrd.SetBorderLineStyle(SvxBorderLineStyle::EMBOSSED);
+ break;
+ case RTF_BRDRENGRAVE: // Engraved border
+ aBrd.SetBorderLineStyle(SvxBorderLineStyle::ENGRAVED);
+ break;
+
+ case RTF_BRDRS: // single thickness border
+ bDoubleWidth = false;
+ break;
+ case RTF_BRDRTH: // double thickness border width*2
+ bDoubleWidth = true;
+ break;
+ case RTF_BRDRW: // border width <255
+ nWidth = nTokenValue;
+ break;
+
+ case RTF_BRDRCF: // Border color
+ aBrd.SetColor( GetColor( sal_uInt16(nTokenValue) ) );
+ break;
+
+ case RTF_BRDRSH: // Shadowed border
+ rSet.Put( SvxShadowItem( aPardMap[SID_ATTR_BORDER_SHADOW], nullptr, 60 /*3pt*/,
+ SvxShadowLocation::BottomRight ) );
+ break;
+
+ case RTF_BRSP: // Spacing to content in twip
+ {
+ switch( nBorderTyp )
+ {
+ case RTF_BRDRB:
+ aAttr->SetDistance( static_cast<sal_uInt16>(nTokenValue), SvxBoxItemLine::BOTTOM );
+ break;
+
+ case RTF_BRDRT:
+ aAttr->SetDistance( static_cast<sal_uInt16>(nTokenValue), SvxBoxItemLine::TOP );
+ break;
+
+ case RTF_BRDRL:
+ aAttr->SetDistance( static_cast<sal_uInt16>(nTokenValue), SvxBoxItemLine::LEFT );
+ break;
+
+ case RTF_BRDRR:
+ aAttr->SetDistance( static_cast<sal_uInt16>(nTokenValue), SvxBoxItemLine::RIGHT );
+ break;
+
+ case RTF_BOX:
+ aAttr->SetAllDistances( static_cast<sal_uInt16>(nTokenValue) );
+ break;
+ }
+ }
+ break;
+
+ case RTF_BRDRBTW: // Border formatting group
+ case RTF_BRDRBAR: // Border outside
+ // TODO unhandled ATM
+ break;
+
+ default:
+ bContinue = (nToken & ~(0xff| RTF_SWGDEFS)) == RTF_BRDRDEF;
+ }
+ if( bContinue )
+ nToken = GetNextToken();
+ } while( bContinue );
+
+ // Finally compute the border width
+ if ( bDoubleWidth ) nWidth *= 2;
+ aBrd.SetWidth( nWidth );
+
+ SetBorderLine( nBorderTyp, *aAttr, aBrd );
+
+ rSet.Put( std::move(aAttr) );
+ SkipToken();
+}
+
+static sal_uInt32 CalcShading( sal_uInt32 nColor, sal_uInt32 nFillColor, sal_uInt8 nShading )
+{
+ nColor = (nColor * nShading) / 100;
+ nFillColor = (nFillColor * ( 100 - nShading )) / 100;
+ return nColor + nFillColor;
+}
+
+void SvxRTFParser::ReadBackgroundAttr( int nToken, SfxItemSet& rSet,
+ bool bTableDef )
+{
+ // then read the border attribute
+ bool bContinue = true;
+ sal_uInt16 nColor = USHRT_MAX, nFillColor = USHRT_MAX;
+ sal_uInt8 nFillValue = 0;
+
+ sal_uInt16 nWh = ( nToken & ~0xff ) == RTF_CHRFMT
+ ? aPlainMap[SID_ATTR_BRUSH_CHAR]
+ : aPardMap[SID_ATTR_BRUSH];
+
+ do {
+ switch( nToken )
+ {
+ case RTF_CLCBPAT:
+ case RTF_CHCBPAT:
+ case RTF_CBPAT:
+ nFillColor = sal_uInt16( nTokenValue );
+ break;
+
+ case RTF_CLCFPAT:
+ case RTF_CHCFPAT:
+ case RTF_CFPAT:
+ nColor = sal_uInt16( nTokenValue );
+ break;
+
+ case RTF_CLSHDNG:
+ case RTF_CHSHDNG:
+ case RTF_SHADING:
+ nFillValue = static_cast<sal_uInt8>( nTokenValue / 100 );
+ break;
+
+ case RTF_CLBGDKHOR:
+ case RTF_CHBGDKHORIZ:
+ case RTF_BGDKHORIZ:
+ case RTF_CLBGDKVERT:
+ case RTF_CHBGDKVERT:
+ case RTF_BGDKVERT:
+ case RTF_CLBGDKBDIAG:
+ case RTF_CHBGDKBDIAG:
+ case RTF_BGDKBDIAG:
+ case RTF_CLBGDKFDIAG:
+ case RTF_CHBGDKFDIAG:
+ case RTF_BGDKFDIAG:
+ case RTF_CLBGDKCROSS:
+ case RTF_CHBGDKCROSS:
+ case RTF_BGDKCROSS:
+ case RTF_CLBGDKDCROSS:
+ case RTF_CHBGDKDCROSS:
+ case RTF_BGDKDCROSS:
+ // dark -> 60%
+ nFillValue = 60;
+ break;
+
+ case RTF_CLBGHORIZ:
+ case RTF_CHBGHORIZ:
+ case RTF_BGHORIZ:
+ case RTF_CLBGVERT:
+ case RTF_CHBGVERT:
+ case RTF_BGVERT:
+ case RTF_CLBGBDIAG:
+ case RTF_CHBGBDIAG:
+ case RTF_BGBDIAG:
+ case RTF_CLBGFDIAG:
+ case RTF_CHBGFDIAG:
+ case RTF_BGFDIAG:
+ case RTF_CLBGCROSS:
+ case RTF_CHBGCROSS:
+ case RTF_BGCROSS:
+ case RTF_CLBGDCROSS:
+ case RTF_CHBGDCROSS:
+ case RTF_BGDCROSS:
+ // light -> 20%
+ nFillValue = 20;
+ break;
+
+ default:
+ if( bTableDef )
+ bContinue = (nToken & ~(0xff | RTF_TABLEDEF) ) == RTF_SHADINGDEF;
+ else
+ bContinue = (nToken & ~0xff) == RTF_SHADINGDEF;
+ }
+ if( bContinue )
+ nToken = GetNextToken();
+ } while( bContinue );
+
+ Color aCol( COL_WHITE ), aFCol;
+ if( !nFillValue )
+ {
+ // there was only one of two colors specified or no BrushType
+ if( USHRT_MAX != nFillColor )
+ {
+ nFillValue = 100;
+ aCol = GetColor( nFillColor );
+ }
+ else if( USHRT_MAX != nColor )
+ aFCol = GetColor( nColor );
+ }
+ else
+ {
+ if( USHRT_MAX != nColor )
+ aCol = GetColor( nColor );
+ else
+ aCol = COL_BLACK;
+
+ if( USHRT_MAX != nFillColor )
+ aFCol = GetColor( nFillColor );
+ else
+ aFCol = COL_WHITE;
+ }
+
+ Color aColor;
+ if( 0 == nFillValue || 100 == nFillValue )
+ aColor = aCol;
+ else
+ aColor = Color(
+ static_cast<sal_uInt8>(CalcShading( aCol.GetRed(), aFCol.GetRed(), nFillValue )),
+ static_cast<sal_uInt8>(CalcShading( aCol.GetGreen(), aFCol.GetGreen(), nFillValue )),
+ static_cast<sal_uInt8>(CalcShading( aCol.GetBlue(), aFCol.GetBlue(), nFillValue )) );
+
+ rSet.Put( SvxBrushItem( aColor, nWh ) );
+ SkipToken();
+}
+
+
+// pard / plain handling
+void SvxRTFParser::RTFPardPlain( bool const bPard, SfxItemSet** ppSet )
+{
+ if( bNewGroup || aAttrStack.empty() ) // not at the beginning of a new group
+ return;
+
+ SvxRTFItemStackType* pCurrent = aAttrStack.back().get();
+
+ int nLastToken = GetStackPtr(-1)->nTokenId;
+ bool bNewStkEntry = true;
+ if( RTF_PARD != nLastToken &&
+ RTF_PLAIN != nLastToken &&
+ BRACELEFT != nLastToken )
+ {
+ if (pCurrent->aAttrSet.Count() || !pCurrent->maChildList.empty() || pCurrent->nStyleNo)
+ {
+ // open a new group
+ auto xNew(std::make_unique<SvxRTFItemStackType>(*pCurrent, *mxInsertPosition, true));
+ xNew->SetRTFDefaults( GetRTFDefaults() );
+
+ // Set all until here valid attributes
+ AttrGroupEnd();
+ pCurrent = aAttrStack.empty() ? nullptr : aAttrStack.back().get(); // can be changed after AttrGroupEnd!
+ xNew->aAttrSet.SetParent( pCurrent ? &pCurrent->aAttrSet : nullptr );
+ aAttrStack.push_back( std::move(xNew) );
+ pCurrent = aAttrStack.back().get();
+ }
+ else
+ {
+ // continue to use this entry as new
+ pCurrent->SetStartPos( *mxInsertPosition );
+ bNewStkEntry = false;
+ }
+ }
+
+ // now reset all to default
+ if( bNewStkEntry &&
+ ( pCurrent->aAttrSet.GetParent() || pCurrent->aAttrSet.Count() ))
+ {
+ const SfxPoolItem *pItem, *pDef;
+ std::map<sal_uInt16, sal_uInt16>::const_iterator aIt;
+ std::map<sal_uInt16, sal_uInt16>::const_iterator aEnd;
+ const SfxItemSet* pDfltSet = &GetRTFDefaults();
+ if( bPard )
+ {
+ pCurrent->nStyleNo = 0;
+ aIt = aPardMap.data.begin();
+ aEnd = aPardMap.data.end();
+ }
+ else
+ {
+ aIt = aPlainMap.data.begin();
+ aEnd = aPlainMap.data.end();
+ }
+
+ for (; aIt != aEnd; ++aIt)
+ {
+ const sal_uInt16 wid = aIt->second;
+ // Item set and different -> Set the Default Pool
+ if (!wid)
+ ;
+ else if (SfxItemPool::IsSlot(wid))
+ pCurrent->aAttrSet.ClearItem(wid);
+ else if( IsChkStyleAttr() )
+ pCurrent->aAttrSet.Put(pDfltSet->Get(wid));
+ else if( !pCurrent->aAttrSet.GetParent() )
+ {
+ if (SfxItemState::SET == pDfltSet->GetItemState(wid, false, &pDef))
+ pCurrent->aAttrSet.Put( *pDef );
+ else
+ pCurrent->aAttrSet.ClearItem(wid);
+ }
+ else if( SfxItemState::SET == pCurrent->aAttrSet.GetParent()->
+ GetItemState(wid, true, &pItem) &&
+ *( pDef = &pDfltSet->Get(wid)) != *pItem )
+ pCurrent->aAttrSet.Put( *pDef );
+ else
+ {
+ if (SfxItemState::SET == pDfltSet->GetItemState(wid, false, &pDef))
+ pCurrent->aAttrSet.Put( *pDef );
+ else
+ pCurrent->aAttrSet.ClearItem(wid);
+ }
+ }
+ }
+ else if( bPard )
+ pCurrent->nStyleNo = 0; // reset Style number
+
+ *ppSet = &pCurrent->aAttrSet;
+
+ if (bPard)
+ return;
+
+ //Once we have a default font, then any text without a font specifier is
+ //in the default font, and thus has the default font charset, otherwise
+ //we can fall back to the ansicpg set codeset
+ if (nDfltFont != -1)
+ {
+ const vcl::Font& rSVFont = GetFont(sal_uInt16(nDfltFont));
+ SetEncoding(rSVFont.GetCharSet());
+ }
+ else
+ SetEncoding(GetCodeSet());
+}
+
+void SvxRTFParser::SetDefault( int nToken, int nValue )
+{
+ if( !bNewDoc )
+ return;
+
+ SfxItemSet aTmp(*pAttrPool, aWhichMap);
+ bool bOldFlag = bIsLeftToRightDef;
+ bIsLeftToRightDef = true;
+ switch( nToken )
+ {
+ case RTF_ADEFF:
+ bIsLeftToRightDef = false;
+ [[fallthrough]];
+ case RTF_DEFF:
+ {
+ if( -1 == nValue )
+ nValue = 0;
+ const vcl::Font& rSVFont = GetFont( sal_uInt16(nValue) );
+ SvxFontItem aTmpItem(
+ rSVFont.GetFamilyType(), rSVFont.GetFamilyName(),
+ rSVFont.GetStyleName(), rSVFont.GetPitch(),
+ rSVFont.GetCharSet(), SID_ATTR_CHAR_FONT );
+ SetScriptAttr( NOTDEF_CHARTYPE, aTmp, aTmpItem );
+ }
+ break;
+
+ case RTF_ADEFLANG:
+ bIsLeftToRightDef = false;
+ [[fallthrough]];
+ case RTF_DEFLANG:
+ // store default Language
+ if( -1 != nValue )
+ {
+ SvxLanguageItem aTmpItem( LanguageType(nValue), SID_ATTR_CHAR_LANGUAGE );
+ SetScriptAttr( NOTDEF_CHARTYPE, aTmp, aTmpItem );
+ }
+ break;
+
+ case RTF_DEFTAB:
+ if (const sal_uInt16 wid = aPardMap[SID_ATTR_TABSTOP])
+ {
+ // RTF defines 720 twips as default
+ bIsSetDfltTab = true;
+ if( -1 == nValue || !nValue )
+ nValue = 720;
+
+ // who would like to have no twips ...
+ if( IsCalcValue() )
+ {
+ nTokenValue = nValue;
+ CalcValue();
+ nValue = nTokenValue;
+ }
+
+ // Calculate the ratio of default TabWidth / Tabs and
+ // calculate the corresponding new number.
+ // ?? how did one come up with 13 ??
+ sal_uInt16 nTabCount = (SVX_TAB_DEFDIST * 13 ) / sal_uInt16(nValue);
+ /*
+ cmc, make sure we have at least one, or all hell breaks loose in
+ everybody exporters, #i8247#
+ */
+ if (nTabCount < 1)
+ nTabCount = 1;
+
+ // we want Defaulttabs
+ SvxTabStopItem aNewTab(nTabCount, sal_uInt16(nValue), SvxTabAdjust::Default, wid);
+ while( nTabCount )
+ const_cast<SvxTabStop&>(aNewTab[ --nTabCount ]).GetAdjustment() = SvxTabAdjust::Default;
+
+ pAttrPool->SetPoolDefaultItem( aNewTab );
+ }
+ break;
+ }
+ bIsLeftToRightDef = bOldFlag;
+
+ if( aTmp.Count() )
+ {
+ SfxItemIter aIter( aTmp );
+ const SfxPoolItem* pItem = aIter.GetCurItem();
+ do
+ {
+ pAttrPool->SetPoolDefaultItem( *pItem );
+ pItem = aIter.NextItem();
+ } while (pItem);
+ }
+}
+
+// default: no conversion, leaving everything in twips.
+void SvxRTFParser::CalcValue()
+{
+}
+
+// for tokens that are not evaluated in ReadAttr
+void SvxRTFParser::UnknownAttrToken( int )
+{
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/editeng/source/rtf/svxrtf.cxx b/editeng/source/rtf/svxrtf.cxx
new file mode 100644
index 0000000000..1ef6f30b40
--- /dev/null
+++ b/editeng/source/rtf/svxrtf.cxx
@@ -0,0 +1,1162 @@
+/* -*- 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 <memory>
+#include <queue>
+#include <comphelper/diagnose_ex.hxx>
+#include <rtl/tencinfo.h>
+#include <svl/itemiter.hxx>
+#include <svl/whiter.hxx>
+#include <svtools/rtftoken.h>
+#include <svl/itempool.hxx>
+#include <i18nlangtag/languagetag.hxx>
+#include <tools/debug.hxx>
+#include <unotools/configmgr.hxx>
+
+#include <comphelper/string.hxx>
+
+#include <editeng/scriptspaceitem.hxx>
+#include <editeng/fontitem.hxx>
+#include <editeng/svxrtf.hxx>
+#include <editeng/editids.hrc>
+#include <vcl/font.hxx>
+#include <vcl/svapp.hxx>
+#include <vcl/settings.hxx>
+
+
+using namespace ::com::sun::star;
+
+
+static rtl_TextEncoding lcl_GetDefaultTextEncodingForRTF()
+{
+
+ OUString aLangString( Application::GetSettings().GetLanguageTag().getLanguage());
+
+ if ( aLangString == "ru" || aLangString == "uk" )
+ return RTL_TEXTENCODING_MS_1251;
+ if ( aLangString == "tr" )
+ return RTL_TEXTENCODING_MS_1254;
+ else
+ return RTL_TEXTENCODING_MS_1252;
+}
+
+// -------------- Methods --------------------
+
+SvxRTFParser::SvxRTFParser( SfxItemPool& rPool, SvStream& rIn )
+ : SvRTFParser( rIn, 5 )
+ , pAttrPool( &rPool )
+ , nDfltFont( 0)
+ , bNewDoc( true )
+ , bNewGroup( false)
+ , bIsSetDfltTab( false)
+ , bChkStyleAttr( false )
+ , bCalcValue( false )
+ , bIsLeftToRightDef( true)
+ , bIsInReadStyleTab( false)
+{
+ pDfltFont.emplace();
+ mxDefaultColor = Color();
+
+ // generate the correct WhichId table from the set WhichIds.
+ BuildWhichTable();
+}
+
+SvxRTFParser::~SvxRTFParser()
+{
+ if( !aAttrStack.empty() )
+ ClearAttrStack();
+}
+
+void SvxRTFParser::SetInsPos( const EditPosition& rNew )
+{
+ mxInsertPosition = rNew;
+}
+
+SvParserState SvxRTFParser::CallParser()
+{
+ DBG_ASSERT( mxInsertPosition, "no insertion position");
+
+ if( !mxInsertPosition )
+ return SvParserState::Error;
+
+ if( !maColorTable.empty() )
+ ClearColorTbl();
+ m_FontTable.clear();
+ m_StyleTable.clear();
+ if( !aAttrStack.empty() )
+ ClearAttrStack();
+
+ bIsSetDfltTab = false;
+ bNewGroup = false;
+ nDfltFont = 0;
+
+ return SvRTFParser::CallParser();
+}
+
+void SvxRTFParser::Continue( int nToken )
+{
+ SvRTFParser::Continue( nToken );
+
+ SvParserState eStatus = GetStatus();
+ if (eStatus != SvParserState::Pending && eStatus != SvParserState::Error)
+ {
+ SetAllAttrOfStk();
+ //Regardless of what "color 0" is, word defaults to auto as the default colour.
+ //e.g. see #i7713#
+ }
+}
+
+
+// is called for each token that is recognized in CallParser
+void SvxRTFParser::NextToken( int nToken )
+{
+ sal_Unicode cCh;
+ switch( nToken )
+ {
+ case RTF_COLORTBL: ReadColorTable(); break;
+ case RTF_FONTTBL: ReadFontTable(); break;
+ case RTF_STYLESHEET: ReadStyleTable(); break;
+
+ case RTF_DEFF:
+ if( bNewDoc )
+ {
+ if (!m_FontTable.empty())
+ // Can immediately be set
+ SetDefault( nToken, nTokenValue );
+ else
+ // is set after reading the font table
+ nDfltFont = int(nTokenValue);
+ }
+ break;
+
+ case RTF_DEFTAB:
+ case RTF_DEFLANG:
+ if( bNewDoc )
+ SetDefault( nToken, nTokenValue );
+ break;
+
+
+ case RTF_PICT: ReadBitmapData(); break;
+
+ case RTF_LINE: cCh = '\n'; goto INSINGLECHAR;
+ case RTF_TAB: cCh = '\t'; goto INSINGLECHAR;
+ case RTF_SUBENTRYINDEX: cCh = ':'; goto INSINGLECHAR;
+
+ case RTF_EMDASH: cCh = 0x2014; goto INSINGLECHAR;
+ case RTF_ENDASH: cCh = 0x2013; goto INSINGLECHAR;
+ case RTF_BULLET: cCh = 0x2022; goto INSINGLECHAR;
+ case RTF_LQUOTE: cCh = 0x2018; goto INSINGLECHAR;
+ case RTF_RQUOTE: cCh = 0x2019; goto INSINGLECHAR;
+ case RTF_LDBLQUOTE: cCh = 0x201C; goto INSINGLECHAR;
+ case RTF_RDBLQUOTE: cCh = 0x201D; goto INSINGLECHAR;
+INSINGLECHAR:
+ aToken = OUStringChar(cCh);
+ [[fallthrough]]; // aToken is set as Text
+ case RTF_TEXTTOKEN:
+ {
+ InsertText();
+ // all collected Attributes are set
+ for (size_t n = m_AttrSetList.size(); n; )
+ {
+ auto const& pStkSet = m_AttrSetList[--n];
+ SetAttrSet( *pStkSet );
+ m_AttrSetList.pop_back();
+ }
+ }
+ break;
+
+
+ case RTF_PAR:
+ InsertPara();
+ break;
+ case '{':
+ if (bNewGroup) // Nesting!
+ GetAttrSet_();
+ bNewGroup = true;
+ break;
+ case '}':
+ if( !bNewGroup ) // Empty Group ??
+ AttrGroupEnd();
+ bNewGroup = false;
+ break;
+ case RTF_INFO:
+ SkipGroup();
+ break;
+
+ // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+ // First overwrite all (all have to be in one group!!)
+ // Could also appear in the RTF-file without the IGNORE-Flag; all Groups
+ // with the IGNORE-Flag are overwritten in the default branch.
+
+ case RTF_SWG_PRTDATA:
+ case RTF_FIELD:
+ case RTF_ATNID:
+ case RTF_ANNOTATION:
+
+ case RTF_BKMKSTART:
+ case RTF_BKMKEND:
+ case RTF_BKMK_KEY:
+ case RTF_XE:
+ case RTF_TC:
+ case RTF_NEXTFILE:
+ case RTF_TEMPLATE:
+ // RTF_SHPRSLT disabled for #i19718#
+ SkipGroup();
+ break;
+ // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+ case RTF_PGDSCNO:
+ case RTF_PGBRK:
+ case RTF_SHADOW:
+ if( RTF_IGNOREFLAG != GetStackPtr( -1 )->nTokenId )
+ break;
+ nToken = SkipToken();
+ if( '{' == GetStackPtr( -1 )->nTokenId )
+ nToken = SkipToken();
+
+ ReadAttr( nToken, &GetAttrSet() );
+ break;
+
+ default:
+ switch( nToken & ~(0xff | RTF_SWGDEFS) )
+ {
+ case RTF_PARFMT: // here are no SWGDEFS
+ ReadAttr( nToken, &GetAttrSet() );
+ break;
+
+ case RTF_CHRFMT:
+ case RTF_BRDRDEF:
+ case RTF_TABSTOPDEF:
+
+ if( RTF_SWGDEFS & nToken)
+ {
+ if( RTF_IGNOREFLAG != GetStackPtr( -1 )->nTokenId )
+ break;
+ nToken = SkipToken();
+ if( '{' == GetStackPtr( -1 )->nTokenId )
+ {
+ nToken = SkipToken();
+ }
+ }
+ ReadAttr( nToken, &GetAttrSet() );
+ break;
+ default:
+ {
+ if( RTF_IGNOREFLAG == GetStackPtr( -1 )->nTokenId &&
+ '{' == GetStackPtr( -2 )->nTokenId )
+ SkipGroup();
+ }
+ break;
+ }
+ break;
+ }
+}
+
+void SvxRTFParser::ReadStyleTable()
+{
+ int bSaveChkStyleAttr = bChkStyleAttr ? 1 : 0;
+ sal_uInt16 nStyleNo = 0;
+ bool bHasStyleNo = false;
+ int _nOpenBrackets = 1; // the first was already detected earlier!!
+ std::optional<SvxRTFStyleType> xStyle(SvxRTFStyleType(*pAttrPool, aWhichMap));
+ xStyle->aAttrSet.Put( GetRTFDefaults() );
+
+ bIsInReadStyleTab = true;
+ bChkStyleAttr = false; // Do not check Attribute against the Styles
+
+ while( _nOpenBrackets && IsParserWorking() )
+ {
+ int nToken = GetNextToken();
+ switch( nToken )
+ {
+ case '}': if( --_nOpenBrackets && IsParserWorking() )
+ // Style has been completely read,
+ // so this is still a stable status
+ SaveState( RTF_STYLESHEET );
+ break;
+ case '{':
+ {
+ if( RTF_IGNOREFLAG != GetNextToken() )
+ SkipToken();
+ else if( RTF_UNKNOWNCONTROL != ( nToken = GetNextToken() ) &&
+ RTF_PN != nToken )
+ SkipToken( -2 );
+ else
+ {
+ // filter out at once
+ ReadUnknownData();
+ nToken = GetNextToken();
+ if( '}' != nToken )
+ eState = SvParserState::Error;
+ break;
+ }
+ ++_nOpenBrackets;
+ }
+ break;
+
+ case RTF_SBASEDON: xStyle->nBasedOn = sal_uInt16(nTokenValue); break;
+ case RTF_SNEXT: break;
+ case RTF_OUTLINELEVEL:
+ case RTF_SOUTLVL: xStyle->nOutlineNo = sal_uInt8(nTokenValue); break;
+ case RTF_S: nStyleNo = static_cast<short>(nTokenValue);
+ bHasStyleNo = true;
+ break;
+ case RTF_CS: nStyleNo = static_cast<short>(nTokenValue);
+ bHasStyleNo = true;
+ break;
+
+ case RTF_TEXTTOKEN:
+ if (bHasStyleNo)
+ {
+ DelCharAtEnd( aToken, ';' );
+ xStyle->sName = aToken.toString();
+
+ if (!m_StyleTable.empty())
+ {
+ m_StyleTable.erase(nStyleNo);
+ }
+ // All data from the font is available, so off to the table
+ m_StyleTable.emplace(nStyleNo, std::move(*xStyle));
+ xStyle.emplace(*pAttrPool, aWhichMap);
+ xStyle->aAttrSet.Put( GetRTFDefaults() );
+ nStyleNo = 0;
+ bHasStyleNo = false;
+ }
+ break;
+ default:
+ switch( nToken & ~(0xff | RTF_SWGDEFS) )
+ {
+ case RTF_PARFMT: // here are no SWGDEFS
+ ReadAttr( nToken, &xStyle->aAttrSet );
+ break;
+
+ case RTF_CHRFMT:
+ case RTF_BRDRDEF:
+ case RTF_TABSTOPDEF:
+#ifndef NDEBUG
+ auto nEnteringToken = nToken;
+#endif
+ auto nEnteringIndex = m_nTokenIndex;
+ int nSkippedTokens = 0;
+ if( RTF_SWGDEFS & nToken)
+ {
+ if( RTF_IGNOREFLAG != GetStackPtr( -1 )->nTokenId )
+ break;
+ nToken = SkipToken();
+ ++nSkippedTokens;
+ if( '{' == GetStackPtr( -1 )->nTokenId )
+ {
+ nToken = SkipToken();
+ ++nSkippedTokens;
+ }
+ }
+ ReadAttr( nToken, &xStyle->aAttrSet );
+ if (nSkippedTokens && m_nTokenIndex == nEnteringIndex - nSkippedTokens)
+ {
+ // we called SkipToken to go back one or two, but ReadAttrs
+ // read nothing, so on next loop of the outer while we
+ // would end up in the same state again (assert that)
+ assert(nEnteringToken == GetNextToken());
+ // and loop endlessly, skip format a token
+ // instead to avoid that
+ SkipToken(nSkippedTokens);
+ }
+ break;
+ }
+ break;
+ }
+ }
+ xStyle.reset(); // Delete the Last Style
+ SkipToken(); // the closing brace is evaluated "above"
+
+ // Flag back to old state
+ bChkStyleAttr = bSaveChkStyleAttr;
+ bIsInReadStyleTab = false;
+}
+
+void SvxRTFParser::ReadColorTable()
+{
+ int nToken;
+ sal_uInt8 nRed = 0xff, nGreen = 0xff, nBlue = 0xff;
+
+ for (;;)
+ {
+ nToken = GetNextToken();
+ if ( '}' == nToken || !IsParserWorking() )
+ break;
+ switch( nToken )
+ {
+ case RTF_RED: nRed = sal_uInt8(nTokenValue); break;
+ case RTF_GREEN: nGreen = sal_uInt8(nTokenValue); break;
+ case RTF_BLUE: nBlue = sal_uInt8(nTokenValue); break;
+
+ case RTF_TEXTTOKEN:
+ if( 1 == aToken.getLength()
+ ? aToken[ 0 ] != ';'
+ : -1 == aToken.indexOf( ";" ) )
+ break; // At least the ';' must be found
+
+ [[fallthrough]];
+
+ case ';':
+ if( IsParserWorking() )
+ {
+ // one color is finished, fill in the table
+ // try to map the values to SV internal names
+ Color aColor( nRed, nGreen, nBlue );
+ if( maColorTable.empty() &&
+ sal_uInt8(-1) == nRed && sal_uInt8(-1) == nGreen && sal_uInt8(-1) == nBlue )
+ aColor = COL_AUTO;
+ maColorTable.push_back( aColor );
+ nRed = 0;
+ nGreen = 0;
+ nBlue = 0;
+
+ // Color has been completely read,
+ // so this is still a stable status
+ SaveState( RTF_COLORTBL );
+ }
+ break;
+ }
+ }
+ SkipToken(); // the closing brace is evaluated "above"
+}
+
+void SvxRTFParser::ReadFontTable()
+{
+ int _nOpenBrackets = 1; // the first was already detected earlier!!
+ vcl::Font aFont;
+ short nFontNo(0), nInsFontNo (0);
+ OUString sAltNm, sFntNm;
+ bool bIsAltFntNm = false;
+
+ rtl_TextEncoding nSystemChar = lcl_GetDefaultTextEncodingForRTF();
+ aFont.SetCharSet( nSystemChar );
+ SetEncoding( nSystemChar );
+
+ while( _nOpenBrackets && IsParserWorking() )
+ {
+ bool bCheckNewFont = false;
+ int nToken = GetNextToken();
+ switch( nToken )
+ {
+ case '}':
+ bIsAltFntNm = false;
+ // Style has been completely read,
+ // so this is still a stable status
+ if( --_nOpenBrackets <= 1 && IsParserWorking() )
+ SaveState( RTF_FONTTBL );
+ bCheckNewFont = true;
+ nInsFontNo = nFontNo;
+ break;
+ case '{':
+ if( RTF_IGNOREFLAG != GetNextToken() )
+ SkipToken();
+ // immediately skip unknown and all known but non-evaluated
+ // groups
+ else if( RTF_UNKNOWNCONTROL != ( nToken = GetNextToken() ) &&
+ RTF_PANOSE != nToken && RTF_FNAME != nToken &&
+ RTF_FONTEMB != nToken && RTF_FONTFILE != nToken )
+ SkipToken( -2 );
+ else
+ {
+ // filter out at once
+ ReadUnknownData();
+ nToken = GetNextToken();
+ if( '}' != nToken )
+ eState = SvParserState::Error;
+ break;
+ }
+ ++_nOpenBrackets;
+ break;
+ case RTF_FROMAN:
+ aFont.SetFamily( FAMILY_ROMAN );
+ break;
+ case RTF_FSWISS:
+ aFont.SetFamily( FAMILY_SWISS );
+ break;
+ case RTF_FMODERN:
+ aFont.SetFamily( FAMILY_MODERN );
+ break;
+ case RTF_FSCRIPT:
+ aFont.SetFamily( FAMILY_SCRIPT );
+ break;
+ case RTF_FDECOR:
+ aFont.SetFamily( FAMILY_DECORATIVE );
+ break;
+ // for technical/symbolic font of the rtl_TextEncoding is changed!
+ case RTF_FTECH:
+ aFont.SetCharSet( RTL_TEXTENCODING_SYMBOL );
+ [[fallthrough]];
+ case RTF_FNIL:
+ aFont.SetFamily( FAMILY_DONTKNOW );
+ break;
+ case RTF_FCHARSET:
+ if (-1 != nTokenValue)
+ {
+ rtl_TextEncoding nrtl_TextEncoding = rtl_getTextEncodingFromWindowsCharset(
+ static_cast<sal_uInt8>(nTokenValue));
+ aFont.SetCharSet(nrtl_TextEncoding);
+ //When we're in a font, the fontname is in the font
+ //charset, except for symbol fonts I believe
+ if (nrtl_TextEncoding == RTL_TEXTENCODING_SYMBOL)
+ nrtl_TextEncoding = RTL_TEXTENCODING_DONTKNOW;
+ SetEncoding(nrtl_TextEncoding);
+ }
+ break;
+ case RTF_FPRQ:
+ switch( nTokenValue )
+ {
+ case 1:
+ aFont.SetPitch( PITCH_FIXED );
+ break;
+ case 2:
+ aFont.SetPitch( PITCH_VARIABLE );
+ break;
+ }
+ break;
+ case RTF_F:
+ bCheckNewFont = true;
+ nInsFontNo = nFontNo;
+ nFontNo = static_cast<short>(nTokenValue);
+ break;
+ case RTF_FALT:
+ bIsAltFntNm = true;
+ break;
+ case RTF_TEXTTOKEN:
+ DelCharAtEnd( aToken, ';' );
+ if ( !aToken.isEmpty() )
+ {
+ if( bIsAltFntNm )
+ sAltNm = aToken;
+ else
+ sFntNm = aToken;
+ }
+ break;
+ }
+
+ if( bCheckNewFont && 1 >= _nOpenBrackets && !sFntNm.isEmpty() ) // one font is ready
+ {
+ // All data from the font is available, so off to the table
+ if (!sAltNm.isEmpty())
+ sFntNm += ";" + sAltNm;
+
+ aFont.SetFamilyName( sFntNm );
+ m_FontTable.insert(std::make_pair(nInsFontNo, aFont));
+ aFont = vcl::Font();
+ aFont.SetCharSet( nSystemChar );
+ sAltNm.clear();
+ sFntNm.clear();
+ }
+ }
+ SkipToken(); // the closing brace is evaluated "above"
+
+ // set the default font in the Document
+ if( bNewDoc && IsParserWorking() )
+ SetDefault( RTF_DEFF, nDfltFont );
+}
+
+void SvxRTFParser::ClearColorTbl()
+{
+ maColorTable.clear();
+}
+
+void SvxRTFParser::ClearAttrStack()
+{
+ aAttrStack.clear();
+}
+
+void SvxRTFParser::DelCharAtEnd( OUStringBuffer& rStr, const sal_Unicode cDel )
+{
+ rStr.strip(' ');
+ if( !rStr.isEmpty() && cDel == rStr[ rStr.getLength()-1 ])
+ rStr.setLength( rStr.getLength()-1 );
+}
+
+
+const vcl::Font& SvxRTFParser::GetFont( sal_uInt16 nId )
+{
+ SvxRTFFontTbl::const_iterator it = m_FontTable.find( nId );
+ if (it != m_FontTable.end())
+ {
+ return it->second;
+ }
+ const SvxFontItem& rDfltFont =
+ pAttrPool->GetDefaultItem(aPlainMap[SID_ATTR_CHAR_FONT]);
+ pDfltFont->SetFamilyName( rDfltFont.GetStyleName() );
+ pDfltFont->SetFamily( rDfltFont.GetFamily() );
+ return *pDfltFont;
+}
+
+std::unique_ptr<SvxRTFItemStackType> SvxRTFItemStackType::createSvxRTFItemStackType(
+ SfxItemPool& rPool, const WhichRangesContainer& pWhichRange, const EditPosition& rEditPosition)
+{
+ struct MakeUniqueEnabler : public SvxRTFItemStackType
+ {
+ MakeUniqueEnabler(SfxItemPool& rPool, const WhichRangesContainer& pWhichRange, const EditPosition& rEditPosition)
+ : SvxRTFItemStackType(rPool, pWhichRange, rEditPosition)
+ {
+ }
+ };
+ return std::make_unique<MakeUniqueEnabler>(rPool, pWhichRange, rEditPosition);
+}
+
+SvxRTFItemStackType* SvxRTFParser::GetAttrSet_()
+{
+ SvxRTFItemStackType* pCurrent = aAttrStack.empty() ? nullptr : aAttrStack.back().get();
+ std::unique_ptr<SvxRTFItemStackType> xNew;
+ if( pCurrent )
+ xNew = std::make_unique<SvxRTFItemStackType>(*pCurrent, *mxInsertPosition, false/*bCopyAttr*/);
+ else
+ xNew = SvxRTFItemStackType::createSvxRTFItemStackType(*pAttrPool, aWhichMap, *mxInsertPosition);
+ xNew->SetRTFDefaults( GetRTFDefaults() );
+
+ aAttrStack.push_back( std::move(xNew) );
+
+ if (aAttrStack.size() > 96 && utl::ConfigManager::IsFuzzing())
+ throw std::range_error("ecStackOverflow");
+
+ bNewGroup = false;
+ return aAttrStack.back().get();
+}
+
+void SvxRTFParser::ClearStyleAttr_( SvxRTFItemStackType& rStkType )
+{
+ // check attributes to the attributes of the stylesheet or to
+ // the default attrs of the document
+ SfxItemSet &rSet = rStkType.GetAttrSet();
+ const SfxItemPool& rPool = *rSet.GetPool();
+ const SfxPoolItem* pItem;
+ SfxWhichIter aIter( rSet );
+
+ if( !IsChkStyleAttr() ||
+ !rStkType.GetAttrSet().Count() ||
+ m_StyleTable.count( rStkType.nStyleNo ) == 0 )
+ {
+ for( sal_uInt16 nWhich = aIter.GetCurWhich(); nWhich; nWhich = aIter.NextWhich() )
+ {
+ if (SfxItemPool::IsWhich(nWhich) &&
+ SfxItemState::SET == aIter.GetItemState( false, &pItem ) &&
+ rPool.GetDefaultItem( nWhich ) == *pItem )
+ aIter.ClearItem(); // delete
+ }
+ }
+ else
+ {
+ // Delete all Attributes, which are already defined in the Style,
+ // from the current AttrSet.
+ auto & rStyle = m_StyleTable.find(rStkType.nStyleNo)->second;
+ SfxItemSet &rStyleSet = rStyle.aAttrSet;
+ const SfxPoolItem* pSItem;
+ for( sal_uInt16 nWhich = aIter.GetCurWhich(); nWhich; nWhich = aIter.NextWhich() )
+ {
+ if( SfxItemState::SET == rStyleSet.GetItemState( nWhich, true, &pSItem ))
+ {
+ if( SfxItemState::SET == aIter.GetItemState( false, &pItem )
+ && *pItem == *pSItem )
+ rSet.ClearItem( nWhich ); // delete
+ }
+ else if (SfxItemPool::IsWhich(nWhich) &&
+ SfxItemState::SET == aIter.GetItemState( false, &pItem ) &&
+ rPool.GetDefaultItem( nWhich ) == *pItem )
+ rSet.ClearItem( nWhich ); // delete
+ }
+ }
+}
+
+void SvxRTFParser::AttrGroupEnd() // process the current, delete from Stack
+{
+ if( aAttrStack.empty() )
+ return;
+
+ std::unique_ptr<SvxRTFItemStackType> pOld = std::move(aAttrStack.back());
+ aAttrStack.pop_back();
+ SvxRTFItemStackType *pCurrent = aAttrStack.empty() ? nullptr : aAttrStack.back().get();
+
+ do { // middle check loop
+ sal_Int32 nOldSttNdIdx = pOld->mxStartNodeIdx->GetIdx();
+ if (pOld->maChildList.empty() &&
+ ((!pOld->aAttrSet.Count() && !pOld->nStyleNo ) ||
+ (nOldSttNdIdx == mxInsertPosition->GetNodeIdx() &&
+ pOld->nSttCnt == mxInsertPosition->GetCntIdx() )))
+ break; // no attributes or Area
+
+ // set only the attributes that are different from the parent
+ if( pCurrent && pOld->aAttrSet.Count() )
+ {
+ SfxItemIter aIter( pOld->aAttrSet );
+ const SfxPoolItem* pItem = aIter.GetCurItem(), *pGet;
+ do
+ {
+ if( SfxItemState::SET == pCurrent->aAttrSet.GetItemState(
+ pItem->Which(), false, &pGet ) &&
+ *pItem == *pGet )
+ aIter.ClearItem();
+
+ pItem = aIter.NextItem();
+ } while (pItem);
+
+ if (!pOld->aAttrSet.Count() && pOld->maChildList.empty() &&
+ !pOld->nStyleNo )
+ break;
+ }
+
+ // Set all attributes which have been defined from start until here
+ bool bCrsrBack = !mxInsertPosition->GetCntIdx();
+ if( bCrsrBack )
+ {
+ // at the beginning of a paragraph? Move back one position
+ sal_Int32 nNd = mxInsertPosition->GetNodeIdx();
+ MovePos(false);
+ // if can not move backward then later don't move forward !
+ bCrsrBack = nNd != mxInsertPosition->GetNodeIdx();
+ }
+
+ if( pOld->mxStartNodeIdx->GetIdx() < mxInsertPosition->GetNodeIdx() ||
+ ( pOld->mxStartNodeIdx->GetIdx() == mxInsertPosition->GetNodeIdx() &&
+ pOld->nSttCnt <= mxInsertPosition->GetCntIdx() ) )
+ {
+ if( !bCrsrBack )
+ {
+ // all pard attributes are only valid until the previous
+ // paragraph !!
+ if( nOldSttNdIdx == mxInsertPosition->GetNodeIdx() )
+ {
+ }
+ else
+ {
+ // Now it gets complicated:
+ // - all character attributes sre keep the area
+ // - all paragraph attributes to get the area
+ // up to the previous paragraph
+ auto xNew = std::make_unique<SvxRTFItemStackType>(*pOld, *mxInsertPosition, true);
+ xNew->aAttrSet.SetParent( pOld->aAttrSet.GetParent() );
+
+ // Delete all paragraph attributes from xNew
+ for (const auto& pair : aPardMap.data)
+ if (sal_uInt16 wid = pair.second)
+ xNew->aAttrSet.ClearItem(wid);
+ xNew->SetRTFDefaults( GetRTFDefaults() );
+
+ // Were there any?
+ if( xNew->aAttrSet.Count() == pOld->aAttrSet.Count() )
+ {
+ xNew.reset();
+ }
+ else
+ {
+ xNew->nStyleNo = 0;
+
+ // Now span the real area of xNew from old
+ SetEndPrevPara( pOld->mxEndNodeIdx, pOld->nEndCnt );
+ xNew->nSttCnt = 0;
+
+ if( IsChkStyleAttr() )
+ {
+ ClearStyleAttr_( *pOld );
+ ClearStyleAttr_( *xNew ); //#i10381#, methinks.
+ }
+
+ if( pCurrent )
+ {
+ pCurrent->Add(std::move(pOld));
+ pCurrent->Add(std::move(xNew));
+ }
+ else
+ {
+ // Last off the stack, thus cache it until the next text was
+ // read. (Span no attributes!)
+
+ m_AttrSetList.push_back(std::move(pOld));
+ m_AttrSetList.push_back(std::move(xNew));
+ }
+ break;
+ }
+ }
+ }
+
+ pOld->mxEndNodeIdx = mxInsertPosition->MakeNodeIdx();
+ pOld->nEndCnt = mxInsertPosition->GetCntIdx();
+
+ /*
+ #i21422#
+ If the parent (pCurrent) sets something e.g. , and the child (pOld)
+ unsets it and the style both are based on has it unset then
+ clearing the pOld by looking at the style is clearly a disaster
+ as the text ends up with pCurrents bold and not pOlds no bold, this
+ should be rethought out. For the moment its safest to just do
+ the clean if we have no parent, all we suffer is too many
+ redundant properties.
+ */
+ if (IsChkStyleAttr() && !pCurrent)
+ ClearStyleAttr_( *pOld );
+
+ if( pCurrent )
+ {
+ pCurrent->Add(std::move(pOld));
+ // split up and create new entry, because it makes no sense
+ // to create a "so long" depend list. Bug 95010
+ if (bCrsrBack && 50 < pCurrent->maChildList.size())
+ {
+ // at the beginning of a paragraph? Move back one position
+ MovePos();
+ bCrsrBack = false;
+
+ // Open a new Group.
+ auto xNew(std::make_unique<SvxRTFItemStackType>(*pCurrent, *mxInsertPosition, true));
+ xNew->SetRTFDefaults( GetRTFDefaults() );
+
+ // Set all until here valid Attributes
+ AttrGroupEnd();
+ pCurrent = aAttrStack.empty() ? nullptr : aAttrStack.back().get(); // can be changed after AttrGroupEnd!
+ xNew->aAttrSet.SetParent( pCurrent ? &pCurrent->aAttrSet : nullptr );
+ aAttrStack.push_back( std::move(xNew) );
+ }
+ }
+ else
+ // Last off the stack, thus cache it until the next text was
+ // read. (Span no attributes!)
+ m_AttrSetList.push_back(std::move(pOld));
+ }
+
+ if( bCrsrBack )
+ // at the beginning of a paragraph? Move back one position
+ MovePos();
+
+ } while( false );
+
+ bNewGroup = false;
+}
+
+void SvxRTFParser::SetAllAttrOfStk() // end all Attr. and set it into doc
+{
+ // repeat until all attributes will be taken from stack
+ while( !aAttrStack.empty() )
+ AttrGroupEnd();
+
+ for (size_t n = m_AttrSetList.size(); n; )
+ {
+ auto const& pStkSet = m_AttrSetList[--n];
+ SetAttrSet( *pStkSet );
+ pStkSet->DropChildList();
+ m_AttrSetList.pop_back();
+ }
+}
+
+// sets all the attributes that are different from the current
+void SvxRTFParser::SetAttrSet( SvxRTFItemStackType &rSet )
+{
+ // Was DefTab never read? then set to default
+ if( !bIsSetDfltTab )
+ SetDefault( RTF_DEFTAB, 720 );
+
+ if (!rSet.maChildList.empty())
+ rSet.Compress( *this );
+ if( rSet.aAttrSet.Count() || rSet.nStyleNo )
+ SetAttrInDoc( rSet );
+
+ // then process all the children
+ for (size_t n = 0; n < rSet.maChildList.size(); ++n)
+ SetAttrSet( *(rSet.maChildList[ n ]) );
+}
+
+// Has no text been inserted yet? (SttPos from the top Stack entry!)
+bool SvxRTFParser::IsAttrSttPos()
+{
+ SvxRTFItemStackType* pCurrent = aAttrStack.empty() ? nullptr : aAttrStack.back().get();
+ return !pCurrent || (pCurrent->mxStartNodeIdx->GetIdx() == mxInsertPosition->GetNodeIdx() &&
+ pCurrent->nSttCnt == mxInsertPosition->GetCntIdx());
+}
+
+
+void SvxRTFParser::SetAttrInDoc( SvxRTFItemStackType & )
+{
+}
+
+void SvxRTFParser::BuildWhichTable()
+{
+ aWhichMap.reset();
+
+ // Here are the IDs for all paragraph attributes, which can be detected by
+ // SvxParser and can be set in a SfxItemSet. The IDs are set correctly through
+ // the SlotIds from POOL.
+ static constexpr sal_uInt16 WIDS1[] {
+ SID_ATTR_PARA_LINESPACE,
+ SID_ATTR_PARA_ADJUST,
+ SID_ATTR_TABSTOP,
+ SID_ATTR_PARA_HYPHENZONE,
+ SID_ATTR_LRSPACE,
+ SID_ATTR_ULSPACE,
+ SID_ATTR_BRUSH,
+ SID_ATTR_BORDER_OUTER,
+ SID_ATTR_BORDER_SHADOW,
+ SID_ATTR_PARA_OUTLLEVEL,
+ SID_ATTR_PARA_SPLIT,
+ SID_ATTR_PARA_KEEP,
+ SID_PARA_VERTALIGN,
+ SID_ATTR_PARA_SCRIPTSPACE,
+ SID_ATTR_PARA_HANGPUNCTUATION,
+ SID_ATTR_PARA_FORBIDDEN_RULES,
+ SID_ATTR_FRAMEDIRECTION,
+ };
+ for (sal_uInt16 nWid : WIDS1)
+ {
+ sal_uInt16 nTrueWid = pAttrPool->GetTrueWhich(nWid, false);
+ aPardMap.data[nWid] = nTrueWid;
+ if (nTrueWid == 0)
+ continue;
+ aWhichMap = aWhichMap.MergeRange(nTrueWid, nTrueWid);
+ }
+
+ // Here are the IDs for all character attributes, which can be detected by
+ // SvxParser and can be set in a SfxItemSet. The IDs are set correctly through
+ // the SlotIds from POOL.
+ static constexpr sal_uInt16 WIDS[] {
+ SID_ATTR_CHAR_CASEMAP, SID_ATTR_BRUSH_CHAR, SID_ATTR_CHAR_COLOR,
+ SID_ATTR_CHAR_CONTOUR, SID_ATTR_CHAR_STRIKEOUT, SID_ATTR_CHAR_ESCAPEMENT,
+ SID_ATTR_CHAR_FONT, SID_ATTR_CHAR_FONTHEIGHT, SID_ATTR_CHAR_KERNING,
+ SID_ATTR_CHAR_LANGUAGE, SID_ATTR_CHAR_POSTURE, SID_ATTR_CHAR_SHADOWED,
+ SID_ATTR_CHAR_UNDERLINE, SID_ATTR_CHAR_OVERLINE, SID_ATTR_CHAR_WEIGHT,
+ SID_ATTR_CHAR_WORDLINEMODE, SID_ATTR_CHAR_AUTOKERN, SID_ATTR_CHAR_CJK_FONT,
+ SID_ATTR_CHAR_CJK_FONTHEIGHT, sal_uInt16(SID_ATTR_CHAR_CJK_LANGUAGE), SID_ATTR_CHAR_CJK_POSTURE,
+ SID_ATTR_CHAR_CJK_WEIGHT, SID_ATTR_CHAR_CTL_FONT, SID_ATTR_CHAR_CTL_FONTHEIGHT,
+ SID_ATTR_CHAR_CTL_LANGUAGE, SID_ATTR_CHAR_CTL_POSTURE, SID_ATTR_CHAR_CTL_WEIGHT,
+ SID_ATTR_CHAR_EMPHASISMARK, SID_ATTR_CHAR_TWO_LINES, SID_ATTR_CHAR_SCALEWIDTH,
+ SID_ATTR_CHAR_ROTATED, SID_ATTR_CHAR_RELIEF, SID_ATTR_CHAR_HIDDEN,
+ };
+ for (sal_uInt16 nWid : WIDS)
+ {
+ sal_uInt16 nTrueWid = pAttrPool->GetTrueWhich(nWid, false);
+ aPlainMap.data[nWid] = nTrueWid;
+ if (nTrueWid == 0)
+ continue;
+ aWhichMap = aWhichMap.MergeRange(nTrueWid, nTrueWid);
+ }
+}
+
+const SfxItemSet& SvxRTFParser::GetRTFDefaults()
+{
+ if( !pRTFDefaults )
+ {
+ pRTFDefaults.reset(new SfxItemSet(*pAttrPool, aWhichMap));
+ if (const sal_uInt16 nId = aPardMap[SID_ATTR_PARA_SCRIPTSPACE])
+ {
+ SvxScriptSpaceItem aItem( false, nId );
+ if( bNewDoc )
+ pAttrPool->SetPoolDefaultItem( aItem );
+ else
+ pRTFDefaults->Put( aItem );
+ }
+ }
+ return *pRTFDefaults;
+}
+
+
+SvxRTFStyleType::SvxRTFStyleType(SfxItemPool& rPool, const WhichRangesContainer& pWhichRange)
+ : aAttrSet(rPool, pWhichRange)
+ , nBasedOn(0)
+ , nOutlineNo(sal_uInt8(-1)) // not set
+{
+}
+
+SvxRTFItemStackType::SvxRTFItemStackType(
+ SfxItemPool& rPool, const WhichRangesContainer& pWhichRange,
+ const EditPosition& rPos )
+ : aAttrSet( rPool, pWhichRange )
+ , mxStartNodeIdx(rPos.MakeNodeIdx())
+#if !defined(__COVERITY__)
+ // coverity 2020 has difficulty wrt std::optional leading to bogus 'Uninitialized scalar variable'
+ , mxEndNodeIdx(mxStartNodeIdx)
+#endif
+ , nSttCnt(rPos.GetCntIdx())
+ , nEndCnt(nSttCnt)
+ , nStyleNo(0)
+{
+}
+
+SvxRTFItemStackType::SvxRTFItemStackType(
+ const SvxRTFItemStackType& rCpy,
+ const EditPosition& rPos,
+ bool const bCopyAttr )
+ : aAttrSet( *rCpy.aAttrSet.GetPool(), rCpy.aAttrSet.GetRanges() )
+ , mxStartNodeIdx(rPos.MakeNodeIdx())
+#if !defined(__COVERITY__)
+ // coverity 2020 has difficulty wrt std::optional leading to bogus 'Uninitialized scalar variable'
+ , mxEndNodeIdx(mxStartNodeIdx)
+#endif
+ , nSttCnt(rPos.GetCntIdx())
+ , nEndCnt(nSttCnt)
+ , nStyleNo(rCpy.nStyleNo)
+{
+ aAttrSet.SetParent( &rCpy.aAttrSet );
+ if( bCopyAttr )
+ aAttrSet.Put( rCpy.aAttrSet );
+}
+
+/* ofz#13491 SvxRTFItemStackType dtor recursively
+ calls the dtor of its m_pChildList. The recurse
+ depth can grow sufficiently to trigger asan.
+
+ So breadth-first iterate through the nodes
+ and make a flat vector of them which can
+ be iterated through in order of most
+ distant from root first and release
+ their children linearly
+*/
+void SvxRTFItemStackType::DropChildList()
+{
+ if (maChildList.empty())
+ return;
+
+ std::vector<SvxRTFItemStackType*> bfs;
+ std::queue<SvxRTFItemStackType*> aQueue;
+ aQueue.push(this);
+
+ while (!aQueue.empty())
+ {
+ auto* front = aQueue.front();
+ aQueue.pop();
+ if (!front->maChildList.empty())
+ {
+ for (const auto& a : front->maChildList)
+ aQueue.push(a.get());
+ bfs.push_back(front);
+ }
+ }
+
+ for (auto it = bfs.rbegin(); it != bfs.rend(); ++it)
+ {
+ SvxRTFItemStackType* pNode = *it;
+ pNode->maChildList.clear();
+ }
+}
+
+SvxRTFItemStackType::~SvxRTFItemStackType()
+{
+}
+
+void SvxRTFItemStackType::Add(std::unique_ptr<SvxRTFItemStackType> pIns)
+{
+ maChildList.push_back(std::move(pIns));
+}
+
+void SvxRTFItemStackType::SetStartPos( const EditPosition& rPos )
+{
+ mxStartNodeIdx = rPos.MakeNodeIdx();
+ mxEndNodeIdx = mxStartNodeIdx;
+ nSttCnt = rPos.GetCntIdx();
+}
+
+void SvxRTFItemStackType::Compress( const SvxRTFParser& rParser )
+{
+ ENSURE_OR_RETURN_VOID(!maChildList.empty(), "Compress: ChildList empty");
+
+ SvxRTFItemStackType* pTmp = maChildList[0].get();
+
+ if( !pTmp->aAttrSet.Count() ||
+ mxStartNodeIdx->GetIdx() != pTmp->mxStartNodeIdx->GetIdx() ||
+ nSttCnt != pTmp->nSttCnt )
+ return;
+
+ EditNodeIdx aLastNd = *pTmp->mxEndNodeIdx;
+ sal_Int32 nLastCnt = pTmp->nEndCnt;
+
+ SfxItemSet aMrgSet( pTmp->aAttrSet );
+ for (size_t n = 1; n < maChildList.size(); ++n)
+ {
+ pTmp = maChildList[n].get();
+ if (!pTmp->maChildList.empty())
+ pTmp->Compress( rParser );
+
+ if( !pTmp->nSttCnt
+ ? (aLastNd.GetIdx()+1 != pTmp->mxStartNodeIdx->GetIdx() ||
+ !rParser.IsEndPara( &aLastNd, nLastCnt ) )
+ : ( pTmp->nSttCnt != nLastCnt ||
+ aLastNd.GetIdx() != pTmp->mxStartNodeIdx->GetIdx() ))
+ {
+ while (++n < maChildList.size())
+ {
+ pTmp = maChildList[n].get();
+ if (!pTmp->maChildList.empty())
+ pTmp->Compress( rParser );
+ }
+ return;
+ }
+
+ if( n )
+ {
+ // Search for all which are set over the whole area
+ SfxItemIter aIter( aMrgSet );
+ const SfxPoolItem* pItem;
+ const SfxPoolItem* pIterItem = aIter.GetCurItem();
+ do {
+ sal_uInt16 nWhich = pIterItem->Which();
+ if( SfxItemState::SET != pTmp->aAttrSet.GetItemState( nWhich,
+ false, &pItem ) || *pItem != *pIterItem)
+ aIter.ClearItem();
+
+ pIterItem = aIter.NextItem();
+ } while(pIterItem);
+
+ if( !aMrgSet.Count() )
+ return;
+ }
+
+ aLastNd = *pTmp->mxEndNodeIdx;
+ nLastCnt = pTmp->nEndCnt;
+ }
+
+ if( mxEndNodeIdx->GetIdx() != aLastNd.GetIdx() || nEndCnt != nLastCnt )
+ return;
+
+ // It can be merged
+ aAttrSet.Put( aMrgSet );
+
+ size_t n = 0, nChildLen = maChildList.size();
+ while (n < nChildLen)
+ {
+ pTmp = maChildList[n].get();
+ pTmp->aAttrSet.Differentiate( aMrgSet );
+
+ if (pTmp->maChildList.empty() && !pTmp->aAttrSet.Count() && !pTmp->nStyleNo)
+ {
+ maChildList.erase( maChildList.begin() + n );
+ --nChildLen;
+ continue;
+ }
+ ++n;
+ }
+}
+void SvxRTFItemStackType::SetRTFDefaults( const SfxItemSet& rDefaults )
+{
+ if( rDefaults.Count() )
+ {
+ SfxItemIter aIter( rDefaults );
+ const SfxPoolItem* pItem = aIter.GetCurItem();
+ do {
+ sal_uInt16 nWhich = pItem->Which();
+ if( SfxItemState::SET != aAttrSet.GetItemState( nWhich, false ))
+ aAttrSet.Put(*pItem);
+
+ pItem = aIter.NextItem();
+ } while(pItem);
+ }
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-24 17:18:58 +0000