/* -*- 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 <config_features.h>
#include <sal/types.h>
#include <tools/solar.h>
#include <comphelper/processfactory.hxx>
#include <comphelper/string.hxx>
#include <comphelper/simplefileaccessinteraction.hxx>
#include <sot/storinfo.hxx>
#include <com/sun/star/embed/XStorage.hpp>
#include <com/sun/star/embed/ElementModes.hpp>
#include <com/sun/star/embed/XTransactedObject.hpp>
#include <com/sun/star/task/InteractionHandler.hpp>
#include <com/sun/star/ucb/XCommandEnvironment.hpp>
#include <svl/urihelper.hxx>
#include <svl/zforlist.hxx>
#include <svl/zformat.hxx>
#include <sfx2/linkmgr.hxx>
#include <ucbhelper/content.hxx>
#include <ucbhelper/commandenvironment.hxx>
#include <com/sun/star/i18n/ScriptType.hpp>
#include <hintids.hxx>
#include <editeng/fontitem.hxx>
#include <editeng/fhgtitem.hxx>
#include <editeng/langitem.hxx>
#include <fmtfld.hxx>
#include <fmtanchr.hxx>
#include <pam.hxx>
#include <doc.hxx>
#include <IDocumentFieldsAccess.hxx>
#include <IDocumentMarkAccess.hxx>
#include <IDocumentState.hxx>
#include <charatr.hxx>
#include <flddat.hxx>
#include <docufld.hxx>
#include <reffld.hxx>
#include <IMark.hxx>
#include <expfld.hxx>
#include <dbfld.hxx>
#include <usrfld.hxx>
#include <tox.hxx>
#include <section.hxx>
#include <ndtxt.hxx>
#include <fmtinfmt.hxx>
#include <chpfld.hxx>
#include <ftnidx.hxx>
#include <txtftn.hxx>
#include <viewsh.hxx>
#include <shellres.hxx>
#include <fmtruby.hxx>
#include <charfmt.hxx>
#include <txtatr.hxx>
#include <breakit.hxx>
#include <fmtclds.hxx>
#include <pagedesc.hxx>
#include <SwStyleNameMapper.hxx>
#include "ww8scan.hxx"
#include "ww8par.hxx"
#include "ww8par2.hxx"
#include "writerhelper.hxx"
#include "fields.hxx"
#include <o3tl/safeint.hxx>
#include <unotools/fltrcfg.hxx>
#include <xmloff/odffields.hxx>
#include <algorithm>
#define MAX_FIELDLEN 64000
#define WW8_TOX_LEVEL_DELIM ':'
using namespace ::com::sun::star;
using namespace msfilter::util;
using namespace sw::util;
using namespace sw::mark;
using namespace std; // #i24377#
using namespace nsSwDocInfoSubType;
// Bookmarks
namespace
{
// #120879# - helper method to identify a bookmark name to match the internal TOC bookmark naming convention
bool IsTOCBookmarkName(const OUString& rName)
{
return rName.startsWith("_Toc") || rName.startsWith(IDocumentMarkAccess::GetCrossRefHeadingBookmarkNamePrefix()+"_Toc");
}
OUString EnsureTOCBookmarkName(const OUString& rName)
{
OUString sTmp = rName;
if ( IsTOCBookmarkName ( rName ) )
{
if ( ! rName.startsWith(IDocumentMarkAccess::GetCrossRefHeadingBookmarkNamePrefix()) )
sTmp = IDocumentMarkAccess::GetCrossRefHeadingBookmarkNamePrefix() + rName;
}
return sTmp;
}
}
long SwWW8ImplReader::Read_Book(WW8PLCFManResult*)
{
// should also work via pRes.nCo2OrIdx
WW8PLCFx_Book* pB = m_xPlcxMan->GetBook();
if( !pB )
{
OSL_ENSURE( pB, "WW8PLCFx_Book - Pointer does not exist" );
return 0;
}
eBookStatus eB = pB->GetStatus();
if (eB & BOOK_IGNORE)
return 0; // ignore bookmark
if (pB->GetIsEnd())
{
m_xReffedStck->SetAttr(*m_pPaM->GetPoint(), RES_FLTR_BOOKMARK, true,
pB->GetHandle(), (eB & BOOK_FIELD)!=0);
return 0;
}
// "_Hlt*" are unnecessary
const OUString* pName = pB->GetName();
// Now, as we read the TOC field completely, we also need the hyperlinks inside keep available.
// So the hidden bookmarks inside for hyperlink jumping also should be kept.
if ( !pName ||
pName->startsWithIgnoreAsciiCase( "_Hlt" ) )
{
return 0;
}
// do NOT call ToUpper as the bookmark name can also be a hyperlink target!
OUString aVal;
if( SwFltGetFlag( m_nFieldFlags, SwFltControlStack::BOOK_TO_VAR_REF ) )
{
// set variable for translation bookmark
long nLen = pB->GetLen();
if( nLen > MAX_FIELDLEN )
nLen = MAX_FIELDLEN;
long nOldPos = m_pStrm->Tell();
m_xSBase->WW8ReadString( *m_pStrm, aVal, pB->GetStartPos(), nLen,
m_eStructCharSet );
m_pStrm->Seek( nOldPos );
// now here the implementation of the old "QuoteString" and
// I hope with a better performance as before. It's also only
// needed if the filterflags say we will convert bookmarks
// to SetExpFields! And this the exception!
bool bSetAsHex;
bool bAllowCr = SwFltGetFlag(m_nFieldFlags,
SwFltControlStack::ALLOW_FLD_CR);
for( sal_Int32 nI = 0;
nI < aVal.getLength() && aVal.getLength() < (MAX_FIELDLEN - 4);
++nI )
{
const sal_Unicode cChar = aVal[nI];
switch( cChar )
{
case 0x0b:
case 0x0c:
case 0x0d:
if( bAllowCr )
{
aVal = aVal.replaceAt( nI, 1, "\n" );
bSetAsHex = false;
}
else
bSetAsHex = true;
break;
case 0xFE:
case 0xFF:
bSetAsHex = true;
break;
default:
bSetAsHex = 0x20 > cChar;
break;
}
if( bSetAsHex )
{
//all Hex-Numbers with \x before
OUString sTmp( "\\x" );
if( cChar < 0x10 )
sTmp += "0";
sTmp += OUString::number( cChar, 16 );
aVal = aVal.replaceAt( nI, 1 , sTmp );
nI += sTmp.getLength() - 1;
}
}
if ( aVal.getLength() > (MAX_FIELDLEN - 4))
aVal = aVal.copy( 0, MAX_FIELDLEN - 4 );
}
//e.g. inserting bookmark around field result, so we need to put
//it around the entire writer field, as we don't have the separation
//of field and field result of word, see #i16941#
SwPosition aStart(*m_pPaM->GetPoint());
if (!m_aFieldStack.empty())
{
const WW8FieldEntry &rTest = m_aFieldStack.back();
aStart = rTest.maStartPos;
}
const OUString sOrigName = BookmarkToWriter(*pName);
m_xReffedStck->NewAttr( aStart,
SwFltBookmark( EnsureTOCBookmarkName( sOrigName ), aVal, pB->GetHandle(), IsTOCBookmarkName( sOrigName ) ));
return 0;
}
long SwWW8ImplReader::Read_AtnBook(WW8PLCFManResult*)
{
if (WW8PLCFx_AtnBook* pAtnBook = m_xPlcxMan->GetAtnBook())
{
if (pAtnBook->getIsEnd())
m_xReffedStck->SetAttr(*m_pPaM->GetPoint(), RES_FLTR_ANNOTATIONMARK, true, pAtnBook->getHandle());
else
m_xReffedStck->NewAttr(*m_pPaM->GetPoint(), CntUInt16Item(RES_FLTR_ANNOTATIONMARK, pAtnBook->getHandle()));
}
return 0;
}
long SwWW8ImplReader::Read_FactoidBook(WW8PLCFManResult*)
{
if (WW8PLCFx_FactoidBook* pFactoidBook = m_xPlcxMan->GetFactoidBook())
{
if (pFactoidBook->getIsEnd())
m_xReffedStck->SetAttr(*m_pPaM->GetPoint(), RES_FLTR_RDFMARK, true, pFactoidBook->getHandle());
else
{
SwFltRDFMark aMark;
aMark.SetHandle(pFactoidBook->getHandle());
GetSmartTagInfo(aMark);
m_xReffedStck->NewAttr(*m_pPaM->GetPoint(), aMark);
}
}
return 0;
}
// general help methods to separate parameters
/// translate FieldParameter names into the system character set and
/// at the same time, double backslashes are converted into single ones
OUString SwWW8ImplReader::ConvertFFileName(const OUString& rOrg)
{
OUString aName = rOrg;
aName = aName.replaceAll("\\\\", "\\");
aName = aName.replaceAll("%20", " ");
// remove attached quotation marks
if (aName.endsWith("\""))
aName = aName.copy(0, aName.getLength()-1);
// Need the more sophisticated url converter.
if (!aName.isEmpty())
aName = URIHelper::SmartRel2Abs(
INetURLObject(m_sBaseURL), aName, Link<OUString *, bool>(), false);
return aName;
}
namespace
{
/// translate FieldParameter names into the
/// system character set and makes them uppercase
void ConvertUFName( OUString& rName )
{
rName = GetAppCharClass().uppercase( rName );
}
}
static void lcl_ConvertSequenceName(OUString& rSequenceName)
{
ConvertUFName(rSequenceName);
if ('0' <= rSequenceName[0] && '9' >= rSequenceName[0])
rSequenceName = "_" + rSequenceName;
}
// FindParaStart() finds 1st Parameter that follows '\' and cToken
// and returns start of this parameter or -1
sal_Int32 FindParaStart( const OUString& rStr, sal_Unicode cToken, sal_Unicode cToken2 )
{
bool bStr = false; // ignore inside a string
for( sal_Int32 nBuf = 0; nBuf+1 < rStr.getLength(); nBuf++ )
{
if( rStr[ nBuf ] == '"' )
bStr = !bStr;
if( !bStr
&& rStr[ nBuf ] == '\\'
&& ( rStr[ nBuf + 1 ] == cToken
|| rStr[ nBuf + 1 ] == cToken2 ) )
{
nBuf += 2;
// skip spaces between cToken and its parameters
while( nBuf < rStr.getLength()
&& rStr[ nBuf ] == ' ' )
nBuf++;
// return start of parameters
return nBuf < rStr.getLength() ? nBuf : -1;
}
}
return -1;
}
// FindPara() finds the first parameter including '\' and cToken.
// A new String will be allocated (has to be deallocated by the caller)
// and everything that is part of the parameter will be returned.
OUString FindPara( const OUString& rStr, sal_Unicode cToken, sal_Unicode cToken2 )
{
sal_Int32 n2; // end
sal_Int32 n = FindParaStart( rStr, cToken, cToken2 ); // start
if( n == -1)
return OUString();
if( rStr[ n ] == '"'
|| rStr[ n ] == 132 )
{ // Quotationmark in front of parameter
n++; // Skip quotationmark
n2 = n; // search for the end starting from here
while( n2 < rStr.getLength()
&& rStr[ n2 ] != 147
&& rStr[ n2 ] != '"' )
n2++; // search end of parameter
}
else
{ // no quotationmarks
n2 = n; // search for the end starting from here
while( n2 < rStr.getLength()
&& rStr[ n2 ] != ' ' )
n2++; // search end of parameter
}
return rStr.copy( n, n2-n );
}
static SvxNumType GetNumTypeFromName(const OUString& rStr,
bool bAllowPageDesc = false)
{
SvxNumType eTyp = bAllowPageDesc ? SVX_NUM_PAGEDESC : SVX_NUM_ARABIC;
if( rStr.startsWithIgnoreAsciiCase( "Arabi" ) ) // Arabisch, Arabic
eTyp = SVX_NUM_ARABIC;
else if( rStr.startsWith( "misch" ) ) // r"omisch
eTyp = SVX_NUM_ROMAN_LOWER;
else if( rStr.startsWith( "MISCH" ) ) // R"OMISCH
eTyp = SVX_NUM_ROMAN_UPPER;
else if( rStr.startsWithIgnoreAsciiCase( "alphabeti" ) )// alphabetisch, alphabetic
eTyp = ( rStr[0] == 'A' )
? SVX_NUM_CHARS_UPPER_LETTER_N
: SVX_NUM_CHARS_LOWER_LETTER_N;
else if( rStr.startsWithIgnoreAsciiCase( "roman" ) ) // us
eTyp = ( rStr[0] == 'R' )
? SVX_NUM_ROMAN_UPPER
: SVX_NUM_ROMAN_LOWER;
return eTyp;
}
static SvxNumType GetNumberPara(const OUString& rStr, bool bAllowPageDesc = false)
{
OUString s( FindPara( rStr, '*', '*' ) ); // Type of number
SvxNumType aType = GetNumTypeFromName( s, bAllowPageDesc );
return aType;
}
bool SwWW8ImplReader::ForceFieldLanguage(SwField &rField, LanguageType nLang)
{
bool bRet(false);
const SvxLanguageItem *pLang =
static_cast<const SvxLanguageItem*>(GetFormatAttr(RES_CHRATR_LANGUAGE));
OSL_ENSURE(pLang, "impossible");
LanguageType nDefault = pLang ? pLang->GetValue() : LANGUAGE_ENGLISH_US;
if (nLang != nDefault)
{
rField.SetAutomaticLanguage(false);
rField.SetLanguage(nLang);
bRet = true;
}
return bRet;
}
OUString GetWordDefaultDateStringAsUS(SvNumberFormatter* pFormatter, LanguageType nLang)
{
//Get the system date in the correct final language layout, convert to
//a known language and modify the 2 digit year part to be 4 digit, and
//convert back to the correct language layout.
const sal_uInt32 nIndex = pFormatter->GetFormatIndex(NF_DATE_SYSTEM_SHORT, nLang);
SvNumberformat aFormat = *(pFormatter->GetEntry(nIndex));
aFormat.ConvertLanguage(*pFormatter, nLang, LANGUAGE_ENGLISH_US);
OUString sParams(aFormat.GetFormatstring());
// #i36594#
// Fix provided by mloiseleur@openoffice.org.
// A default date can have already 4 year digits, in some case
const sal_Int32 pos = sParams.indexOf("YYYY");
if ( pos == -1 )
{
sParams = sParams.replaceFirst("YY", "YYYY");
}
return sParams;
}
SvNumFormatType SwWW8ImplReader::GetTimeDatePara(OUString const & rStr, sal_uInt32& rFormat,
LanguageType &rLang, int nWhichDefault, bool bHijri)
{
bool bRTL = false;
if (m_xPlcxMan && !m_bVer67)
{
SprmResult aResult = m_xPlcxMan->HasCharSprm(0x85A);
if (aResult.pSprm && aResult.nRemainingData >= 1 && *aResult.pSprm)
bRTL = true;
}
sal_uInt16 eLang = bRTL ? RES_CHRATR_CTL_LANGUAGE : RES_CHRATR_LANGUAGE;
const SvxLanguageItem *pLang = static_cast<const SvxLanguageItem*>(GetFormatAttr(eLang));
OSL_ENSURE(pLang, "impossible");
rLang = pLang ? pLang->GetValue() : LANGUAGE_ENGLISH_US;
SvNumberFormatter* pFormatter = m_rDoc.GetNumberFormatter();
OUString sParams( FindPara( rStr, '@', '@' ) );// Date/Time
if (sParams.isEmpty())
{
bool bHasTime = false;
switch (nWhichDefault)
{
case ww::ePRINTDATE:
case ww::eSAVEDATE:
sParams = GetWordDefaultDateStringAsUS(pFormatter, rLang);
sParams += " HH:MM:SS AM/PM";
bHasTime = true;
break;
case ww::eCREATEDATE:
sParams += "DD/MM/YYYY HH:MM:SS";
bHasTime = true;
break;
default:
case ww::eDATE:
sParams = GetWordDefaultDateStringAsUS(pFormatter, rLang);
break;
}
if (bHijri)
sParams = "[~hijri]" + sParams;
sal_Int32 nCheckPos = 0;
SvNumFormatType nType = SvNumFormatType::DEFINED;
rFormat = 0;
OUString sTemp(sParams);
pFormatter->PutandConvertEntry(sTemp, nCheckPos, nType, rFormat,
LANGUAGE_ENGLISH_US, rLang, false);
sParams = sTemp;
return bHasTime ? SvNumFormatType::DATETIME : SvNumFormatType::DATE;
}
sal_uLong nFormatIdx =
sw::ms::MSDateTimeFormatToSwFormat(sParams, pFormatter, rLang, bHijri,
GetFib().m_lid);
SvNumFormatType nNumFormatType = SvNumFormatType::UNDEFINED;
if (nFormatIdx)
nNumFormatType = pFormatter->GetType(nFormatIdx);
rFormat = nFormatIdx;
return nNumFormatType;
}
// Fields
// Update respective fields after loading (currently references)
void SwWW8ImplReader::UpdateFields()
{
m_rDoc.getIDocumentState().SetUpdateExpFieldStat(true);
m_rDoc.SetInitDBFields(true); // Also update fields in the database
}
sal_uInt16 SwWW8ImplReader::End_Field()
{
sal_uInt16 nRet = 0;
WW8PLCFx_FLD* pF = m_xPlcxMan->GetField();
OSL_ENSURE(pF, "WW8PLCFx_FLD - Pointer not available");
WW8_CP nCP = 0;
if (!pF || !pF->EndPosIsFieldEnd(nCP))
return nRet;
const SvtFilterOptions &rOpt = SvtFilterOptions::Get();
bool bUseEnhFields = rOpt.IsUseEnhancedFields();
OSL_ENSURE(!m_aFieldStack.empty(), "Empty field stack");
if (!m_aFieldStack.empty())
{
/*
only hyperlinks currently need to be handled like this, for the other
cases we have inserted a field not an attribute with an unknown end
point
*/
nRet = m_aFieldStack.back().mnFieldId;
switch (nRet)
{
case 70:
if (bUseEnhFields && m_pPaM!=nullptr && m_pPaM->GetPoint()!=nullptr) {
SwPosition aEndPos = *m_pPaM->GetPoint();
SwPaM aFieldPam( m_aFieldStack.back().GetPtNode(), m_aFieldStack.back().GetPtContent(), aEndPos.nNode, aEndPos.nContent.GetIndex());
IDocumentMarkAccess* pMarksAccess = m_rDoc.getIDocumentMarkAccess( );
IFieldmark *pFieldmark = pMarksAccess->makeFieldBookmark(
aFieldPam, m_aFieldStack.back().GetBookmarkName(), ODF_FORMTEXT );
OSL_ENSURE(pFieldmark!=nullptr, "hmmm; why was the bookmark not created?");
if (pFieldmark!=nullptr) {
const IFieldmark::parameter_map_t& rParametersToAdd = m_aFieldStack.back().getParameters();
pFieldmark->GetParameters()->insert(rParametersToAdd.begin(), rParametersToAdd.end());
}
}
break;
// Doing corresponding status management for TOX field, index field, hyperlink field and page reference field
case 13://TOX
case 8://index
if (m_bLoadingTOXCache)
{
if (m_nEmbeddedTOXLevel > 0)
{
JoinNode(*m_pPaM);
--m_nEmbeddedTOXLevel;
}
else
{
m_aTOXEndCps.insert(nCP);
m_bLoadingTOXCache = false;
if ( m_pPaM->End() &&
m_pPaM->End()->nNode.GetNode().GetTextNode() &&
m_pPaM->End()->nNode.GetNode().GetTextNode()->Len() == 0 )
{
JoinNode(*m_pPaM);
}
else
{
m_bCareLastParaEndInToc = true;
}
if (m_pPosAfterTOC)
{
*m_pPaM = *m_pPosAfterTOC;
m_pPosAfterTOC.reset();
}
}
}
break;
case 37: //REF
if (m_bLoadingTOXCache && !m_bLoadingTOXHyperlink)
{
m_xCtrlStck->SetAttr(*m_pPaM->GetPoint(),RES_TXTATR_INETFMT);
}
break;
case 88:
if (m_bLoadingTOXHyperlink)
m_bLoadingTOXHyperlink = false;
m_xCtrlStck->SetAttr(*m_pPaM->GetPoint(), RES_TXTATR_INETFMT);
break;
case 36:
case 68:
//Move outside the section associated with this type of field
*m_pPaM->GetPoint() = m_aFieldStack.back().maStartPos;
break;
case 7: // IF-field
{
// conditional field parameters
const OUString& fieldDefinition = m_aFieldStack.back().GetBookmarkCode();
OUString paramCondition;
OUString paramTrue;
OUString paramFalse;
SwHiddenTextField::ParseIfFieldDefinition(fieldDefinition, paramCondition, paramTrue, paramFalse);
// create new field
SwFieldType* pFieldType = m_rDoc.getIDocumentFieldsAccess().GetSysFieldType(SwFieldIds::HiddenText);
SwHiddenTextField aHTField(
static_cast<SwHiddenTextFieldType*>(pFieldType),
paramCondition,
paramTrue,
paramFalse,
static_cast<sal_uInt16>(TYP_CONDTXTFLD));
// insert new field into document
m_rDoc.getIDocumentContentOperations().InsertPoolItem(*m_pPaM, SwFormatField(aHTField));
break;
}
default:
OUString aCode = m_aFieldStack.back().GetBookmarkCode();
if ( !aCode.isEmpty() )
{
// Unhandled field with stored code
SwPosition aEndPos = *m_pPaM->GetPoint();
SwPaM aFieldPam(
m_aFieldStack.back().GetPtNode(), m_aFieldStack.back().GetPtContent(),
aEndPos.nNode, aEndPos.nContent.GetIndex());
IDocumentMarkAccess* pMarksAccess = m_rDoc.getIDocumentMarkAccess( );
IFieldmark* pFieldmark = pMarksAccess->makeFieldBookmark(
aFieldPam,
m_aFieldStack.back().GetBookmarkName(),
ODF_UNHANDLED );
if ( pFieldmark )
{
// adapt redline positions to inserted field mark start
// dummy char (assume not necessary for end dummy char)
m_xRedlineStack->MoveAttrs(*aFieldPam.Start());
const IFieldmark::parameter_map_t& rParametersToAdd = m_aFieldStack.back().getParameters();
pFieldmark->GetParameters()->insert(rParametersToAdd.begin(), rParametersToAdd.end());
OUString sFieldId = OUString::number( m_aFieldStack.back().mnFieldId );
pFieldmark->GetParameters()->insert(
std::pair< OUString, uno::Any > (
ODF_ID_PARAM,
uno::makeAny( sFieldId ) ) );
pFieldmark->GetParameters()->insert(
std::pair< OUString, uno::Any > (
ODF_CODE_PARAM,
uno::makeAny( aCode ) ) );
if ( m_aFieldStack.back().mnObjLocFc > 0 )
{
// Store the OLE object as an internal link
OUString sOleId('_');
sOleId += OUString::number( m_aFieldStack.back().mnObjLocFc );
tools::SvRef<SotStorage> xSrc0 = m_pStg->OpenSotStorage(SL::aObjectPool);
tools::SvRef<SotStorage> xSrc1 = xSrc0->OpenSotStorage( sOleId, StreamMode::READ );
// Store it now!
uno::Reference< embed::XStorage > xDocStg = GetDoc().GetDocStorage();
if (xDocStg.is())
{
uno::Reference< embed::XStorage > xOleStg = xDocStg->openStorageElement(
"OLELinks", embed::ElementModes::WRITE );
tools::SvRef<SotStorage> xObjDst = SotStorage::OpenOLEStorage( xOleStg, sOleId );
if ( xObjDst.is() )
{
xSrc1->CopyTo( xObjDst.get() );
if ( !xObjDst->GetError() )
xObjDst->Commit();
}
uno::Reference< embed::XTransactedObject > xTransact( xOleStg, uno::UNO_QUERY );
if ( xTransact.is() )
xTransact->commit();
}
// Store the OLE Id as a parameter
pFieldmark->GetParameters()->insert(
std::pair< OUString, uno::Any >(
ODF_OLE_PARAM, uno::makeAny( sOleId ) ) );
}
}
}
break;
}
m_aFieldStack.pop_back();
}
return nRet;
}
bool AcceptableNestedField(sal_uInt16 nFieldCode)
{
switch (nFieldCode)
{
case 8: // allow recursive field in TOC...
case 13: // allow recursive field in TOC...
case 36:
case 68:
case 79:
case 88:
// Accept AutoTextList field as nested field.
// Thus, the field result is imported as plain text.
case 89:
return true;
default:
return false;
}
}
WW8FieldEntry::WW8FieldEntry(SwPosition const &rPos, sal_uInt16 nFieldId) throw()
: maStartPos(rPos), mnFieldId(nFieldId), mnObjLocFc(0)
{
}
WW8FieldEntry::WW8FieldEntry(const WW8FieldEntry &rOther) throw()
: maStartPos(rOther.maStartPos), mnFieldId(rOther.mnFieldId), mnObjLocFc(rOther.mnObjLocFc)
{
}
void WW8FieldEntry::Swap(WW8FieldEntry &rOther) throw()
{
std::swap(maStartPos, rOther.maStartPos);
std::swap(mnFieldId, rOther.mnFieldId);
}
WW8FieldEntry &WW8FieldEntry::operator=(const WW8FieldEntry &rOther) throw()
{
WW8FieldEntry aTemp(rOther);
Swap(aTemp);
return *this;
}
void WW8FieldEntry::SetBookmarkName(const OUString& bookmarkName)
{
msBookmarkName=bookmarkName;
}
void WW8FieldEntry::SetBookmarkType(const OUString& bookmarkType)
{
msMarkType=bookmarkType;
}
void WW8FieldEntry::SetBookmarkCode(const OUString& bookmarkCode)
{
msMarkCode = bookmarkCode;
}
// Read_Field reads a field or returns 0 if the field cannot be read,
// so that the calling function reads the field in text format.
// Returnvalue: Total length of field
long SwWW8ImplReader::Read_Field(WW8PLCFManResult* pRes)
{
typedef eF_ResT (SwWW8ImplReader:: *FNReadField)( WW8FieldDesc*, OUString& );
enum Limits {eMax = 96};
static const FNReadField aWW8FieldTab[eMax+1] =
{
nullptr,
&SwWW8ImplReader::Read_F_Input,
nullptr,
&SwWW8ImplReader::Read_F_Ref, // 3
nullptr,
nullptr,
&SwWW8ImplReader::Read_F_Set, // 6
nullptr,
&SwWW8ImplReader::Read_F_Tox, // 8
nullptr,
&SwWW8ImplReader::Read_F_Styleref, // 10
nullptr,
&SwWW8ImplReader::Read_F_Seq, // 12
&SwWW8ImplReader::Read_F_Tox, // 13
&SwWW8ImplReader::Read_F_DocInfo, // 14
&SwWW8ImplReader::Read_F_DocInfo, // 15
&SwWW8ImplReader::Read_F_DocInfo, // 16
&SwWW8ImplReader::Read_F_Author, // 17
&SwWW8ImplReader::Read_F_DocInfo, // 18
&SwWW8ImplReader::Read_F_DocInfo, // 19
&SwWW8ImplReader::Read_F_DocInfo, // 20
&SwWW8ImplReader::Read_F_DocInfo, // 21
&SwWW8ImplReader::Read_F_DocInfo, // 22
&SwWW8ImplReader::Read_F_DocInfo, // 23
&SwWW8ImplReader::Read_F_DocInfo, // 24
&SwWW8ImplReader::Read_F_DocInfo, // 25
&SwWW8ImplReader::Read_F_Num, // 26
&SwWW8ImplReader::Read_F_Num, // 27
&SwWW8ImplReader::Read_F_Num, // 28
&SwWW8ImplReader::Read_F_FileName, // 29
&SwWW8ImplReader::Read_F_TemplName, // 30
&SwWW8ImplReader::Read_F_DateTime, // 31
&SwWW8ImplReader::Read_F_DateTime, // 32
&SwWW8ImplReader::Read_F_CurPage, // 33
nullptr,
nullptr,
&SwWW8ImplReader::Read_F_IncludeText, // 36
&SwWW8ImplReader::Read_F_PgRef, // 37
&SwWW8ImplReader::Read_F_InputVar, // 38
&SwWW8ImplReader::Read_F_Input, // 39
nullptr,
&SwWW8ImplReader::Read_F_DBNext, // 41
nullptr,
nullptr,
&SwWW8ImplReader::Read_F_DBNum, // 44
nullptr,
nullptr,
nullptr,
nullptr,
&SwWW8ImplReader::Read_F_Equation, // 49
nullptr,
&SwWW8ImplReader::Read_F_Macro, // 51
&SwWW8ImplReader::Read_F_ANumber, // 52
&SwWW8ImplReader::Read_F_ANumber, // 53
&SwWW8ImplReader::Read_F_ANumber, // 54
nullptr,
nullptr, // 56
&SwWW8ImplReader::Read_F_Symbol, // 57
&SwWW8ImplReader::Read_F_Embedd, // 58
&SwWW8ImplReader::Read_F_DBField, // 59
nullptr,
nullptr,
nullptr,
nullptr,
&SwWW8ImplReader::Read_F_DocInfo, // 64 - DOCVARIABLE
nullptr,
nullptr,
&SwWW8ImplReader::Read_F_IncludePicture, // 67
&SwWW8ImplReader::Read_F_IncludeText, // 68
nullptr,
&SwWW8ImplReader::Read_F_FormTextBox, // 70
&SwWW8ImplReader::Read_F_FormCheckBox, // 71
&SwWW8ImplReader::Read_F_NoteReference, // 72
nullptr, /*&SwWW8ImplReader::Read_F_Tox*/
nullptr,
nullptr,
nullptr,
nullptr,
nullptr,
nullptr,
nullptr,
nullptr,
nullptr,
&SwWW8ImplReader::Read_F_FormListBox, // 83
nullptr, // 84
&SwWW8ImplReader::Read_F_DocInfo, // 85
nullptr, // 86
&SwWW8ImplReader::Read_F_OCX, // 87
&SwWW8ImplReader::Read_F_Hyperlink, // 88
nullptr, // 89
nullptr, // 90
&SwWW8ImplReader::Read_F_HTMLControl, // 91
nullptr, // 92
nullptr, // 93
nullptr, // 94
&SwWW8ImplReader::Read_F_Shape, // 95
nullptr // eMax - Dummy empty method
};
OSL_ENSURE( SAL_N_ELEMENTS( aWW8FieldTab ) == eMax+1, "FieldFunc table not right" );
WW8PLCFx_FLD* pF = m_xPlcxMan->GetField();
OSL_ENSURE(pF, "WW8PLCFx_FLD - Pointer not available");
if (!pF || !pF->StartPosIsFieldStart())
return 0;
bool bNested = false;
if (!m_aFieldStack.empty())
{
bNested = std::any_of(m_aFieldStack.cbegin(), m_aFieldStack.cend(),
[](const WW8FieldEntry& aField) { return !AcceptableNestedField(aField.mnFieldId); });
}
WW8FieldDesc aF;
bool bOk = pF->GetPara(pRes->nCp2OrIdx, aF);
OSL_ENSURE(bOk, "WW8: Bad Field!");
if (aF.nId == 33) aF.bCodeNest=false; // do not recurse into nested page fields
bool bCodeNest = aF.bCodeNest;
if ( aF.nId == 6 ) bCodeNest = false; // We can handle them and lose the inner data
m_aFieldStack.emplace_back(*m_pPaM->GetPoint(), aF.nId);
if (bNested)
return 0;
sal_uInt16 n = (aF.nId <= eMax) ? aF.nId : static_cast<sal_uInt16>(eMax);
sal_uInt16 nI = n / 32; // # of sal_uInt32
sal_uInt32 nMask = 1 << ( n % 32 ); // Mask for bits
if (SAL_N_ELEMENTS(m_nFieldTagAlways) <= nI)
{ // if indexes larger than 95 are needed, then a new configuration
// item has to be added, and nFieldTagAlways/nFieldTagBad expanded!
return aF.nLen;
}
if( m_nFieldTagAlways[nI] & nMask ) // Flag: Tag it
return Read_F_Tag( &aF ); // Result not as text
if( !bOk || !aF.nId ) // Field corrupted
return aF.nLen; // -> ignore
if( aF.nId > eMax - 1) // WW: Nested Field
{
if( m_nFieldTagBad[nI] & nMask ) // Flag: Tag it when bad
return Read_F_Tag( &aF ); // Result not as text
else
return aF.nLen;
}
//Only one type of field (hyperlink) in drawing textboxes exists
if (aF.nId != 88 && m_xPlcxMan->GetDoingDrawTextBox())
return aF.nLen;
bool bHasHandler = aWW8FieldTab[aF.nId] != nullptr;
if (aF.nId == 10) // STYLEREF
{
// STYLEREF, by default these are not handled.
bHasHandler = false;
sal_uInt64 nOldPos = m_pStrm->Tell();
OUString aStr;
aF.nLCode = m_xSBase->WW8ReadString(*m_pStrm, aStr, m_xPlcxMan->GetCpOfs() + aF.nSCode, aF.nLCode, m_eTextCharSet);
m_pStrm->Seek(nOldPos);
WW8ReadFieldParams aReadParam(aStr);
sal_Int32 nRet = aReadParam.SkipToNextToken();
if (nRet == -2 && !aReadParam.GetResult().isEmpty())
// Single numeric argument: this can be handled by SwChapterField.
bHasHandler = rtl::isAsciiDigit(aReadParam.GetResult()[0]);
if (bHasHandler)
{
nRet = aReadParam.SkipToNextToken();
// Handle using SwChapterField only in case there is no \[a-z]
// switch after the field argument.
bHasHandler = nRet < 0 || nRet == '*';
}
}
// no routine available
if (!bHasHandler || bCodeNest)
{
if( m_nFieldTagBad[nI] & nMask ) // Flag: Tag it when bad
return Read_F_Tag( &aF ); // Result not as text
// only read result
if (aF.bResNest && !AcceptableNestedField(aF.nId))
return aF.nLen; // Result nested -> unusable
long nOldPos = m_pStrm->Tell();
OUString aStr;
aF.nLCode = m_xSBase->WW8ReadString( *m_pStrm, aStr, m_xPlcxMan->GetCpOfs()+
aF.nSCode, aF.nLCode, m_eTextCharSet );
m_pStrm->Seek( nOldPos );
// field codes which contain '/' or '.' are not displayed in WinWord
// skip if it is formula field or found space before. see #i119446, #i119585.
const sal_Int32 nDotPos = aStr.indexOf('.');
const sal_Int32 nSlashPos = aStr.indexOf('/');
sal_Int32 nSpacePos = aStr.indexOf( ' ', 1 );
if ( nSpacePos<0 )
nSpacePos = aStr.getLength();
if ( !( aStr.getLength()>1 && aStr[1]=='=') &&
(( nDotPos>=0 && nDotPos < nSpacePos ) ||
( nSlashPos>=0 && nSlashPos < nSpacePos )))
return aF.nLen;
else
{
// Link fields aren't supported, but they are bound to an OLE object
// that needs to be roundtripped
if ( aF.nId == 56 )
m_bEmbeddObj = true;
// Field not supported: store the field code for later use
m_aFieldStack.back().SetBookmarkCode( aStr );
return aF.nLen - aF.nLRes - 1; // skipped too many, the resulted field will be read like main text
}
}
else
{ // read field
auto nOldPos = m_pStrm->Tell();
OUString aStr;
if ( aF.nId == 6 && aF.bCodeNest )
{
// TODO Extract the whole code string using the nested codes
aF.nLCode = m_xSBase->WW8ReadString( *m_pStrm, aStr, m_xPlcxMan->GetCpOfs() +
aF.nSCode, aF.nSRes - aF.nSCode - 1, m_eTextCharSet );
}
else
{
aF.nLCode = m_xSBase->WW8ReadString( *m_pStrm, aStr, m_xPlcxMan->GetCpOfs()+
aF.nSCode, aF.nLCode, m_eTextCharSet );
}
// #i51312# - graphics inside field code not supported by Writer.
// Thus, delete character 0x01, which stands for such a graphic.
if (aF.nId==51) //#i56768# only do it for the MACROBUTTON field, since DropListFields need the 0x01.
{
aStr = aStr.replaceAll("\x01", "");
}
eF_ResT eRes = (this->*aWW8FieldTab[aF.nId])( &aF, aStr );
m_pStrm->Seek(nOldPos);
switch ( eRes )
{
case eF_ResT::OK:
return aF.nLen;
case eF_ResT::TEXT:
// skipped too many, the resulted field will be read like main text
// attributes can start at char 0x14 so skip one
// char more back == "-2"
if (aF.nLRes)
return aF.nLen - aF.nLRes - 2;
else
return aF.nLen;
case eF_ResT::TAGIGN:
if ( m_nFieldTagBad[nI] & nMask ) // Flag: Tag bad
return Read_F_Tag( &aF ); // Tag it
return aF.nLen; // or ignore
case eF_ResT::READ_FSPA:
return aF.nLen - aF.nLRes - 2; // position on char 1
default:
return aF.nLen; // ignore
}
}
}
// Tag fields
// MakeTagString() returns the position of the first CR / end of line / page break
// in pText and converts only up to this point.
// If none of these special characters is found, the function returns 0.
void SwWW8ImplReader::MakeTagString( OUString& rStr, const OUString& rOrg )
{
bool bAllowCr = SwFltGetFlag( m_nFieldFlags, SwFltControlStack::TAGS_IN_TEXT )
|| SwFltGetFlag( m_nFieldFlags, SwFltControlStack::ALLOW_FLD_CR );
sal_Unicode cChar;
rStr = rOrg;
for( sal_Int32 nI = 0;
nI < rStr.getLength() && rStr.getLength() < (MAX_FIELDLEN - 4); ++nI )
{
bool bSetAsHex = false;
switch( cChar = rStr[ nI ] )
{
case 132: // Exchange typographical quotation marks for normal ones
case 148:
case 147:
rStr = rStr.replaceAt( nI, 1, "\"" );
break;
case 19:
rStr = rStr.replaceAt( nI, 1, "{" );
break; // 19..21 to {|}
case 20:
rStr = rStr.replaceAt( nI, 1, "|" );
break;
case 21:
rStr = rStr.replaceAt( nI, 1, "}" );
break;
case '\\': // Tag \{|} with \ ...
case '{':
case '|':
case '}':
rStr = rStr.replaceAt( nI, 0, "\\" );
++nI;
break;
case 0x0b:
case 0x0c:
case 0x0d:
if( bAllowCr )
rStr = rStr.replaceAt( nI, 1, "\n" );
else
bSetAsHex = true;
break;
case 0xFE:
case 0xFF:
bSetAsHex = true;
break;
default:
bSetAsHex = 0x20 > cChar;
break;
}
if( bSetAsHex )
{
//all Hex-Numbers with \x before
OUString sTmp( "\\x" );
if( cChar < 0x10 )
sTmp += "0";
sTmp += OUString::number( cChar, 16 );
rStr = rStr.replaceAt( nI, 1 , sTmp );
nI += sTmp.getLength() - 1;
}
}
if( rStr.getLength() > (MAX_FIELDLEN - 4))
rStr = rStr.copy( 0, MAX_FIELDLEN - 4 );
}
void SwWW8ImplReader::InsertTagField( const sal_uInt16 nId, const OUString& rTagText )
{
OUString aName("WwFieldTag");
if( SwFltGetFlag( m_nFieldFlags, SwFltControlStack::TAGS_DO_ID ) ) // Number?
aName += OUString::number( nId ); // return it?
if( SwFltGetFlag(m_nFieldFlags, SwFltControlStack::TAGS_IN_TEXT))
{
aName += rTagText; // tag as text
m_rDoc.getIDocumentContentOperations().InsertString(*m_pPaM, aName,
SwInsertFlags::NOHINTEXPAND);
}
else
{ // tag normally
SwFieldType* pFT = m_rDoc.getIDocumentFieldsAccess().InsertFieldType(
SwSetExpFieldType( &m_rDoc, aName, nsSwGetSetExpType::GSE_STRING ) );
SwSetExpField aField( static_cast<SwSetExpFieldType*>(pFT), rTagText ); // SUB_INVISIBLE
sal_uInt16 nSubType = ( SwFltGetFlag( m_nFieldFlags, SwFltControlStack::TAGS_VISIBLE ) ) ? 0 : nsSwExtendedSubType::SUB_INVISIBLE;
aField.SetSubType(nSubType | nsSwGetSetExpType::GSE_STRING);
m_rDoc.getIDocumentContentOperations().InsertPoolItem( *m_pPaM, SwFormatField( aField ) );
}
}
WW8_CP SwWW8ImplReader::Read_F_Tag( WW8FieldDesc* pF )
{
long nOldPos = m_pStrm->Tell();
WW8_CP nStart = pF->nSCode - 1; // starting with 0x19
WW8_CP nL = pF->nLen; // Total length with result and nest
if( nL > MAX_FIELDLEN )
nL = MAX_FIELDLEN; // MaxLength, by quoting
// max. 4 times as big
OUString sFText;
m_xSBase->WW8ReadString( *m_pStrm, sFText,
m_xPlcxMan->GetCpOfs() + nStart, nL, m_eStructCharSet);
OUString aTagText;
MakeTagString( aTagText, sFText );
InsertTagField( pF->nId, aTagText );
m_pStrm->Seek( nOldPos );
return pF->nLen;
}
// normal fields
eF_ResT SwWW8ImplReader::Read_F_Input( WW8FieldDesc* pF, OUString& rStr )
{
OUString aDef;
OUString aQ;
WW8ReadFieldParams aReadParam( rStr );
for (;;)
{
const sal_Int32 nRet = aReadParam.SkipToNextToken();
if ( nRet==-1 )
break;
switch( nRet )
{
case -2:
if( aQ.isEmpty() )
aQ = aReadParam.GetResult();
break;
case 'd':
case 'D':
if ( aReadParam.GoToTokenParam() )
aDef = aReadParam.GetResult();
break;
}
}
if( aDef.isEmpty() )
aDef = GetFieldResult( pF );
if ( pF->nId != 0x01 ) // 0x01 fields have no result
{
SwInputField aField( static_cast<SwInputFieldType*>(m_rDoc.getIDocumentFieldsAccess().GetSysFieldType( SwFieldIds::Input )),
aDef, aQ, INP_TXT, 0, false );
m_rDoc.getIDocumentContentOperations().InsertPoolItem( *m_pPaM, SwFormatField( aField ) );
}
return eF_ResT::OK;
}
// GetFieldResult allocates a string and reads the resulted field
OUString SwWW8ImplReader::GetFieldResult( WW8FieldDesc const * pF )
{
long nOldPos = m_pStrm->Tell();
WW8_CP nStart = pF->nSRes; // result start
WW8_CP nL = pF->nLRes; // result length
if( !nL )
return OUString(); // no result
if( nL > MAX_FIELDLEN )
nL = MAX_FIELDLEN; // MaxLength, by quoting
// max. 4 times as big
OUString sRes;
m_xSBase->WW8ReadString( *m_pStrm, sRes, m_xPlcxMan->GetCpOfs() + nStart,
nL, m_eStructCharSet );
m_pStrm->Seek( nOldPos );
//replace both CR 0x0D and VT 0x0B with LF 0x0A
return sRes.replace(0x0D, 0x0A).replace(0x0B, 0x0A);
}
/*
Bookmarks can be set with fields SET and ASK, and they can be referenced with
REF. When set, they behave like variables in writer, otherwise they behave
like normal bookmarks. We can check whether we should use a show variable
instead of a normal bookmark ref by converting to "show variable" at the end
of the document those refs which look for the content of a bookmark but whose
bookmarks were set with SET or ASK. (See SwWW8FltRefStack)
The other piece of the puzzle is that refs that point to the "location" of the
bookmark will in word actually point to the last location where the bookmark
was set with SET or ASK, not the actual bookmark. This is only noticeable when
a document sets the bookmark more than once. This is because word places the
true bookmark at the location of the last set, but the refs will display the
position of the first set before the ref.
So what we will do is
1) keep a list of all bookmarks that were set, any bookmark names mentioned
here that are referred by content will be converted to show variables.
2) create pseudo bookmarks for every position that a bookmark is set with SET
or ASK but has no existing bookmark. We can then keep a map from the original
bookmark name to the new one. As we parse the document new pseudo names will
replace the older ones, so the map always contains the bookmark of the
location that msword itself would use.
3) word's bookmarks are case insensitive, writers are not. So we need to
map case different versions together, regardless of whether they are
variables or not.
4) when a reference is (first) SET or ASK, the bookmark associated with it
is placed around the 0x14 0x15 result part of the field. We will fiddle
the placement to be the writer equivalent of directly before and after
the field, which gives the same effect and meaning, to do so we must
get any bookmarks in the field range, and begin them immediately before
the set/ask field, and end them directly afterwards. MapBookmarkVariables
returns an identifier of the bookmark attribute to close after inserting
the appropriate set/ask field.
*/
long SwWW8ImplReader::MapBookmarkVariables(const WW8FieldDesc* pF,
OUString &rOrigName, const OUString &rData)
{
OSL_ENSURE(m_xPlcxMan.get(), "No pPlcxMan");
long nNo;
/*
If there was no bookmark associated with this set field, then we create a
pseudo one and insert it in the document.
*/
sal_uInt16 nIndex;
m_xPlcxMan->GetBook()->MapName(rOrigName);
OUString sName = m_xPlcxMan->GetBook()->GetBookmark(
pF->nSCode, pF->nSCode + pF->nLen, nIndex);
if (!sName.isEmpty())
{
m_xPlcxMan->GetBook()->SetStatus(nIndex, BOOK_IGNORE);
nNo = nIndex;
}
else
{
nNo = m_xReffingStck->aFieldVarNames.size()+1;
sName = "WWSetBkmk" + OUString::number(nNo);
nNo += m_xPlcxMan->GetBook()->GetIMax();
}
m_xReffedStck->NewAttr(*m_pPaM->GetPoint(),
SwFltBookmark( BookmarkToWriter(sName), rData, nNo ));
m_xReffingStck->aFieldVarNames[rOrigName] = sName;
return nNo;
}
/*
Word can set a bookmark with set or with ask, such a bookmark is equivalent to
our variables, but until the end of a document we cannot be sure if a bookmark
is a variable or not, at the end we will have a list of reference names which
were set or asked, all bookmarks using the content of those bookmarks are
converted to show variables, those that reference the position of the field
can be left as references, because a bookmark is also inserted at the position
of a set or ask field, either by word, or in some special cases by the import
filter itself.
*/
SwFltStackEntry *SwWW8FltRefStack::RefToVar(const SwField* pField,
SwFltStackEntry &rEntry)
{
SwFltStackEntry *pRet=nullptr;
if (pField && SwFieldIds::GetRef == pField->Which())
{
//Get the name of the ref field, and see if actually a variable
const OUString sName = pField->GetPar1();
std::map<OUString, OUString, SwWW8::ltstr>::const_iterator
aResult = aFieldVarNames.find(sName);
if (aResult != aFieldVarNames.end())
{
SwGetExpField aField( static_cast<SwGetExpFieldType*>(
pDoc->getIDocumentFieldsAccess().GetSysFieldType(SwFieldIds::GetExp)), sName, nsSwGetSetExpType::GSE_STRING, 0);
SwFormatField aTmp(aField);
rEntry.pAttr.reset( aTmp.Clone() );
pRet = &rEntry;
}
}
return pRet;
}
OUString SwWW8ImplReader::GetMappedBookmark(const OUString &rOrigName)
{
OUString sName(BookmarkToWriter(rOrigName));
OSL_ENSURE(m_xPlcxMan.get(), "no pPlcxMan");
m_xPlcxMan->GetBook()->MapName(sName);
//See if there has been a variable set with this name, if so get
//the pseudo bookmark name that was set with it.
std::map<OUString, OUString, SwWW8::ltstr>::const_iterator aResult =
m_xReffingStck->aFieldVarNames.find(sName);
return (aResult == m_xReffingStck->aFieldVarNames.end())
? sName : (*aResult).second;
}
// "ASK"
eF_ResT SwWW8ImplReader::Read_F_InputVar( WW8FieldDesc* pF, OUString& rStr )
{
OUString sOrigName, aQ;
OUString aDef;
WW8ReadFieldParams aReadParam( rStr );
for (;;)
{
const sal_Int32 nRet = aReadParam.SkipToNextToken();
if ( nRet==-1 )
break;
switch( nRet )
{
case -2:
if (sOrigName.isEmpty())
sOrigName = aReadParam.GetResult();
else if (aQ.isEmpty())
aQ = aReadParam.GetResult();
break;
case 'd':
case 'D':
if ( aReadParam.GoToTokenParam() )
aDef = aReadParam.GetResult();
break;
}
}
if (sOrigName.isEmpty())
return eF_ResT::TAGIGN; // does not make sense without textmark
const OUString aResult(GetFieldResult(pF));
//#i24377#, munge Default Text into title as we have only one slot
//available for aResult and aDef otherwise
if (!aDef.isEmpty())
{
if (!aQ.isEmpty())
aQ += " - ";
aQ += aDef;
}
const long nNo = MapBookmarkVariables(pF, sOrigName, aResult);
SwSetExpFieldType* pFT = static_cast<SwSetExpFieldType*>(m_rDoc.getIDocumentFieldsAccess().InsertFieldType(
SwSetExpFieldType(&m_rDoc, sOrigName, nsSwGetSetExpType::GSE_STRING)));
SwSetExpField aField(pFT, aResult);
aField.SetSubType(nsSwExtendedSubType::SUB_INVISIBLE | nsSwGetSetExpType::GSE_STRING);
aField.SetInputFlag(true);
aField.SetPromptText( aQ );
m_rDoc.getIDocumentContentOperations().InsertPoolItem( *m_pPaM, SwFormatField( aField ) );
m_xReffedStck->SetAttr(*m_pPaM->GetPoint(), RES_FLTR_BOOKMARK, true, nNo);
return eF_ResT::OK;
}
// "AUTONR"
eF_ResT SwWW8ImplReader::Read_F_ANumber( WW8FieldDesc*, OUString& rStr )
{
if( !m_pNumFieldType ){ // 1st time
SwSetExpFieldType aT( &m_rDoc, "AutoNr", nsSwGetSetExpType::GSE_SEQ );
m_pNumFieldType = m_rDoc.getIDocumentFieldsAccess().InsertFieldType( aT );
}
SwSetExpField aField( static_cast<SwSetExpFieldType*>(m_pNumFieldType), OUString(),
GetNumberPara( rStr ) );
aField.SetValue( ++m_nFieldNum );
m_rDoc.getIDocumentContentOperations().InsertPoolItem( *m_pPaM, SwFormatField( aField ) );
return eF_ResT::OK;
}
// "SEQ"
eF_ResT SwWW8ImplReader::Read_F_Seq( WW8FieldDesc*, OUString& rStr )
{
OUString aSequenceName;
OUString aBook;
bool bHidden = false;
bool bFormat = false;
bool bCountOn = true;
OUString sStart;
SvxNumType eNumFormat = SVX_NUM_ARABIC;
WW8ReadFieldParams aReadParam( rStr );
for (;;)
{
const sal_Int32 nRet = aReadParam.SkipToNextToken();
if ( nRet==-1 )
break;
switch( nRet )
{
case -2:
if( aSequenceName.isEmpty() )
aSequenceName = aReadParam.GetResult();
else if( aBook.isEmpty() )
aBook = aReadParam.GetResult();
break;
case 'h':
if( !bFormat )
bHidden = true; // activate hidden flag
break;
case '*':
bFormat = true; // activate format flag
if ( aReadParam.SkipToNextToken()!=-2 )
break;
if ( aReadParam.GetResult()!="MERGEFORMAT" && aReadParam.GetResult()!="CHARFORMAT" )
eNumFormat = GetNumTypeFromName( aReadParam.GetResult() );
break;
case 'r':
bCountOn = false;
if ( aReadParam.SkipToNextToken()==-2 )
sStart = aReadParam.GetResult();
break;
case 'c':
bCountOn = false;
break;
case 'n':
bCountOn = true; // Increase value by one (default)
break;
case 's': // Outline Level
//#i19682, what am I to do with this value
break;
}
}
if (aSequenceName.isEmpty() && aBook.isEmpty())
return eF_ResT::TAGIGN;
SwSetExpFieldType* pFT = static_cast<SwSetExpFieldType*>(m_rDoc.getIDocumentFieldsAccess().InsertFieldType(
SwSetExpFieldType( &m_rDoc, aSequenceName, nsSwGetSetExpType::GSE_SEQ ) ) );
SwSetExpField aField( pFT, OUString(), eNumFormat );
//#i120654# Add bHidden for /h flag (/h: Hide the field result.)
if (bHidden)
aField.SetSubType(aField.GetSubType() | nsSwExtendedSubType::SUB_INVISIBLE);
if (!sStart.isEmpty())
aField.SetFormula( ( aSequenceName += "=" ) += sStart );
else if (!bCountOn)
aField.SetFormula(aSequenceName);
m_rDoc.getIDocumentContentOperations().InsertPoolItem(*m_pPaM, SwFormatField(aField));
return eF_ResT::OK;
}
eF_ResT SwWW8ImplReader::Read_F_Styleref(WW8FieldDesc*, OUString& rString)
{
WW8ReadFieldParams aReadParam(rString);
sal_Int32 nRet = aReadParam.SkipToNextToken();
if (nRet != -2)
// \param was found, not normal text.
return eF_ResT::TAGIGN;
OUString aResult = aReadParam.GetResult();
sal_Int32 nResult = aResult.toInt32();
if (nResult < 1)
return eF_ResT::TAGIGN;
SwFieldType* pFieldType = m_rDoc.getIDocumentFieldsAccess().GetSysFieldType(SwFieldIds::Chapter);
SwChapterField aField(static_cast<SwChapterFieldType*>(pFieldType), CF_TITLE);
aField.SetLevel(nResult - 1);
m_rDoc.getIDocumentContentOperations().InsertPoolItem(*m_pPaM, SwFormatField(aField));
return eF_ResT::OK;
}
eF_ResT SwWW8ImplReader::Read_F_DocInfo( WW8FieldDesc* pF, OUString& rStr )
{
sal_uInt16 nSub=0;
// RegInfoFormat, DefaultFormat for DocInfoFields
sal_uInt16 nReg = DI_SUB_AUTHOR;
bool bDateTime = false;
if( 85 == pF->nId )
{
OUString aDocProperty;
WW8ReadFieldParams aReadParam( rStr );
for (;;)
{
const sal_Int32 nRet = aReadParam.SkipToNextToken();
if ( nRet==-1 )
break;
switch( nRet )
{
case -2:
if( aDocProperty.isEmpty() )
aDocProperty = aReadParam.GetResult();
break;
case '*':
//Skip over MERGEFORMAT
(void)aReadParam.SkipToNextToken();
break;
}
}
aDocProperty = aDocProperty.replaceAll("\"", "");
/*
There are up to 26 fields that may be meant by 'DocumentProperty'.
Which of them is to be inserted here ?
This Problem can only be solved by implementing a name matching
method that compares the given Parameter String with the four
possible name sets (english, german, french, spanish)
*/
static const sal_Char* aName10 = "\x0F"; // SW field code
static const sal_Char* aName11 // German
= "TITEL";
static const sal_Char* aName12 // French
= "TITRE";
static const sal_Char* aName13 // English
= "TITLE";
static const sal_Char* aName14 // Spanish
= "TITRO";
static const sal_Char* aName20 = "\x15"; // SW field code
static const sal_Char* aName21 // German
= "ERSTELLDATUM";
static const sal_Char* aName22 // French
= "CR\xC9\xC9";
static const sal_Char* aName23 // English
= "CREATED";
static const sal_Char* aName24 // Spanish
= "CREADO";
static const sal_Char* aName30 = "\x16"; // SW field code
static const sal_Char* aName31 // German
= "ZULETZTGESPEICHERTZEIT";
static const sal_Char* aName32 // French
= "DERNIERENREGISTREMENT";
static const sal_Char* aName33 // English
= "SAVED";
static const sal_Char* aName34 // Spanish
= "MODIFICADO";
static const sal_Char* aName40 = "\x17"; // SW field code
static const sal_Char* aName41 // German
= "ZULETZTGEDRUCKT";
static const sal_Char* aName42 // French
= "DERNI\xC8" "REIMPRESSION";
static const sal_Char* aName43 // English
= "LASTPRINTED";
static const sal_Char* aName44 // Spanish
= "HUPS PUPS";
static const sal_Char* aName50 = "\x18"; // SW field code
static const sal_Char* aName51 // German
= "\xDC" "BERARBEITUNGSNUMMER";
static const sal_Char* aName52 // French
= "NUM\xC9" "RODEREVISION";
static const sal_Char* aName53 // English
= "REVISIONNUMBER";
static const sal_Char* aName54 // Spanish
= "SNUBBEL BUBBEL";
static const sal_uInt16 nFieldCnt = 5;
// additional fields are to be coded soon!
static const sal_uInt16 nLangCnt = 4;
static const sal_Char *aNameSet_26[nFieldCnt][nLangCnt+1] =
{
{aName10, aName11, aName12, aName13, aName14},
{aName20, aName21, aName22, aName23, aName24},
{aName30, aName31, aName32, aName33, aName34},
{aName40, aName41, aName42, aName43, aName44},
{aName50, aName51, aName52, aName53, aName54}
};
bool bFieldFound= false;
sal_uInt16 nFIdx;
for(sal_uInt16 nLIdx=1; !bFieldFound && (nLangCnt > nLIdx); ++nLIdx)
{
for(nFIdx = 0; !bFieldFound && (nFieldCnt > nFIdx); ++nFIdx)
{
if( aDocProperty == OUString( aNameSet_26[nFIdx][nLIdx], strlen(aNameSet_26[nFIdx][nLIdx]),
RTL_TEXTENCODING_MS_1252 ) )
{
bFieldFound = true;
pF->nId = aNameSet_26[nFIdx][0][0];
}
}
}
if( !bFieldFound )
{
SwDocInfoField aField( static_cast<SwDocInfoFieldType*>(
m_rDoc.getIDocumentFieldsAccess().GetSysFieldType( SwFieldIds::DocInfo )), DI_CUSTOM|nReg, aDocProperty, GetFieldResult( pF ) );
m_rDoc.getIDocumentContentOperations().InsertPoolItem(*m_pPaM, SwFormatField(aField));
return eF_ResT::OK;
}
}
switch( pF->nId )
{
case 14:
/* supports all INFO variables! */
nSub = DI_KEYS;
break;
case 15:
nSub = DI_TITEL;
break;
case 16:
nSub = DI_THEMA;
break;
case 18:
nSub = DI_KEYS;
break;
case 19:
nSub = DI_COMMENT;
break;
case 20:
nSub = DI_CHANGE;
nReg = DI_SUB_AUTHOR;
break;
case 21:
nSub = DI_CREATE;
nReg = DI_SUB_DATE;
bDateTime = true;
break;
case 23:
nSub = DI_PRINT;
nReg = DI_SUB_DATE;
bDateTime = true;
break;
case 24:
nSub = DI_DOCNO;
break;
case 22:
nSub = DI_CHANGE;
nReg = DI_SUB_DATE;
bDateTime = true;
break;
case 25:
nSub = DI_CHANGE;
nReg = DI_SUB_TIME;
bDateTime = true;
break;
case 64: // DOCVARIABLE
nSub = DI_CUSTOM;
break;
}
sal_uInt32 nFormat = 0;
LanguageType nLang(LANGUAGE_SYSTEM);
if (bDateTime)
{
SvNumFormatType nDT = GetTimeDatePara(rStr, nFormat, nLang, pF->nId);
switch (nDT)
{
case SvNumFormatType::DATE:
nReg = DI_SUB_DATE;
break;
case SvNumFormatType::TIME:
nReg = DI_SUB_TIME;
break;
case SvNumFormatType::DATETIME:
nReg = DI_SUB_DATE;
break;
default:
nReg = DI_SUB_DATE;
break;
}
}
OUString aData;
// Extract DOCVARIABLE varname
if ( 64 == pF->nId )
{
WW8ReadFieldParams aReadParam( rStr );
for (;;)
{
const sal_Int32 nRet = aReadParam.SkipToNextToken();
if ( nRet==-1)
break;
switch( nRet )
{
case -2:
if( aData.isEmpty() )
aData = aReadParam.GetResult();
break;
case '*':
//Skip over MERGEFORMAT
(void)aReadParam.SkipToNextToken();
break;
}
}
aData = aData.replaceAll("\"", "");
}
SwDocInfoField aField( static_cast<SwDocInfoFieldType*>(
m_rDoc.getIDocumentFieldsAccess().GetSysFieldType( SwFieldIds::DocInfo )), nSub|nReg, aData, nFormat );
if (bDateTime)
ForceFieldLanguage(aField, nLang);
m_rDoc.getIDocumentContentOperations().InsertPoolItem(*m_pPaM, SwFormatField(aField));
return eF_ResT::OK;
}
eF_ResT SwWW8ImplReader::Read_F_Author( WW8FieldDesc*, OUString& )
{
// SH: The SwAuthorField refers not to the original author but to the current user, better use DocInfo
SwDocInfoField aField( static_cast<SwDocInfoFieldType*>(
m_rDoc.getIDocumentFieldsAccess().GetSysFieldType( SwFieldIds::DocInfo )),
DI_CREATE|DI_SUB_AUTHOR, OUString() );
m_rDoc.getIDocumentContentOperations().InsertPoolItem( *m_pPaM, SwFormatField( aField ) );
return eF_ResT::OK;
}
eF_ResT SwWW8ImplReader::Read_F_TemplName( WW8FieldDesc*, OUString& )
{
SwTemplNameField aField( static_cast<SwTemplNameFieldType*>(
m_rDoc.getIDocumentFieldsAccess().GetSysFieldType( SwFieldIds::TemplateName )), FF_NAME );
m_rDoc.getIDocumentContentOperations().InsertPoolItem( *m_pPaM, SwFormatField( aField ) );
return eF_ResT::OK;
}
// Both the date and the time fields can be used for showing a date a time or both.
eF_ResT SwWW8ImplReader::Read_F_DateTime( WW8FieldDesc*pF, OUString& rStr )
{
bool bHijri = false;
WW8ReadFieldParams aReadParam(rStr);
for (;;)
{
const sal_Int32 nTok = aReadParam.SkipToNextToken();
if ( nTok==-1 )
break;
switch (nTok)
{
default:
case 'l':
case -2:
break;
case 'h':
bHijri = true;
break;
case 's':
//Saka Calendar, should we do something with this ?
break;
}
}
sal_uInt32 nFormat = 0;
LanguageType nLang(LANGUAGE_SYSTEM);
SvNumFormatType nDT = GetTimeDatePara(rStr, nFormat, nLang, ww::eDATE, bHijri);
if( SvNumFormatType::UNDEFINED == nDT ) // no D/T-Formatstring
{
if (32 == pF->nId)
{
nDT = SvNumFormatType::TIME;
nFormat = m_rDoc.GetNumberFormatter()->GetFormatIndex(
NF_TIME_START, LANGUAGE_SYSTEM );
}
else
{
nDT = SvNumFormatType::DATE;
nFormat = m_rDoc.GetNumberFormatter()->GetFormatIndex(
NF_DATE_START, LANGUAGE_SYSTEM );
}
}
if (nDT & SvNumFormatType::DATE)
{
SwDateTimeField aField(static_cast<SwDateTimeFieldType*>(
m_rDoc.getIDocumentFieldsAccess().GetSysFieldType(SwFieldIds::DateTime )), DATEFLD, nFormat);
ForceFieldLanguage(aField, nLang);
m_rDoc.getIDocumentContentOperations().InsertPoolItem( *m_pPaM, SwFormatField( aField ) );
}
else if (nDT == SvNumFormatType::TIME)
{
SwDateTimeField aField(static_cast<SwDateTimeFieldType*>(
m_rDoc.getIDocumentFieldsAccess().GetSysFieldType(SwFieldIds::DateTime)), TIMEFLD, nFormat);
ForceFieldLanguage(aField, nLang);
m_rDoc.getIDocumentContentOperations().InsertPoolItem( *m_pPaM, SwFormatField( aField ) );
}
return eF_ResT::OK;
}
eF_ResT SwWW8ImplReader::Read_F_FileName(WW8FieldDesc*, OUString &rStr)
{
SwFileNameFormat eType = FF_NAME;
WW8ReadFieldParams aReadParam(rStr);
for (;;)
{
const sal_Int32 nRet = aReadParam.SkipToNextToken();
if ( nRet==-1 )
break;
switch (nRet)
{
case 'p':
eType = FF_PATHNAME;
break;
case '*':
//Skip over MERGEFORMAT
(void)aReadParam.SkipToNextToken();
break;
default:
OSL_ENSURE(false, "unknown option in FileName field");
break;
}
}
SwFileNameField aField(
static_cast<SwFileNameFieldType*>(m_rDoc.getIDocumentFieldsAccess().GetSysFieldType(SwFieldIds::Filename)), eType);
m_rDoc.getIDocumentContentOperations().InsertPoolItem(*m_pPaM, SwFormatField(aField));
return eF_ResT::OK;
}
eF_ResT SwWW8ImplReader::Read_F_Num( WW8FieldDesc* pF, OUString& rStr )
{
sal_uInt16 nSub = DS_PAGE; // page number
switch ( pF->nId ){
case 27: nSub = DS_WORD; break; // number of words
case 28: nSub = DS_CHAR; break; // number of characters
}
SwDocStatField aField( static_cast<SwDocStatFieldType*>(
m_rDoc.getIDocumentFieldsAccess().GetSysFieldType( SwFieldIds::DocStat )), nSub,
GetNumberPara( rStr ) );
m_rDoc.getIDocumentContentOperations().InsertPoolItem( *m_pPaM, SwFormatField( aField ) );
return eF_ResT::OK;
}
eF_ResT SwWW8ImplReader::Read_F_CurPage( WW8FieldDesc*, OUString& rStr )
{
// page number
SwPageNumberField aField( static_cast<SwPageNumberFieldType*>(
m_rDoc.getIDocumentFieldsAccess().GetSysFieldType( SwFieldIds::PageNumber )), PG_RANDOM,
GetNumberPara(rStr, true));
m_rDoc.getIDocumentContentOperations().InsertPoolItem( *m_pPaM, SwFormatField( aField ) );
return eF_ResT::OK;
}
eF_ResT SwWW8ImplReader::Read_F_Symbol( WW8FieldDesc*, OUString& rStr )
{
//e.g. #i20118#
OUString aQ;
OUString aName;
sal_Int32 nSize = 0;
WW8ReadFieldParams aReadParam( rStr );
for (;;)
{
const sal_Int32 nRet = aReadParam.SkipToNextToken();
if ( nRet==-1 )
break;
switch( nRet )
{
case -2:
if( aQ.isEmpty() )
aQ = aReadParam.GetResult();
break;
case 'f':
case 'F':
if ( aReadParam.GoToTokenParam() )
aName = aReadParam.GetResult();
break;
case 's':
case 'S':
if ( aReadParam.GoToTokenParam() )
{
const OUString aSiz = aReadParam.GetResult();
if (!aSiz.isEmpty())
{
bool bFail = o3tl::checked_multiply<sal_Int32>(aSiz.toInt32(), 20, nSize); // pT -> twip
if (bFail)
nSize = -1;
}
}
break;
}
}
if( aQ.isEmpty() )
return eF_ResT::TAGIGN; // -> no 0-char in text
if (sal_Unicode cChar = static_cast<sal_Unicode>(aQ.toInt32()))
{
if (!aName.isEmpty()) // Font Name set ?
{
SvxFontItem aFont(FAMILY_DONTKNOW, aName, OUString(),
PITCH_DONTKNOW, RTL_TEXTENCODING_SYMBOL, RES_CHRATR_FONT);
NewAttr(aFont); // new Font
}
if (nSize > 0) //#i20118#
{
SvxFontHeightItem aSz(nSize, 100, RES_CHRATR_FONTSIZE);
NewAttr(aSz);
}
m_rDoc.getIDocumentContentOperations().InsertString(*m_pPaM, OUString(cChar));
if (nSize > 0)
m_xCtrlStck->SetAttr(*m_pPaM->GetPoint(), RES_CHRATR_FONTSIZE);
if (!aName.isEmpty())
m_xCtrlStck->SetAttr(*m_pPaM->GetPoint(), RES_CHRATR_FONT);
}
else
{
m_rDoc.getIDocumentContentOperations().InsertString(*m_pPaM, "###");
}
return eF_ResT::OK;
}
// "EMBED"
eF_ResT SwWW8ImplReader::Read_F_Embedd( WW8FieldDesc*, OUString& rStr )
{
WW8ReadFieldParams aReadParam( rStr );
for (;;)
{
const sal_Int32 nRet = aReadParam.SkipToNextToken();
if ( nRet==-1 )
break;
switch( nRet )
{
case -2:
// sHost
break;
case 's':
// use ObjectSize
break;
}
}
if( m_bObj && m_nPicLocFc )
m_nObjLocFc = m_nPicLocFc;
m_bEmbeddObj = true;
return eF_ResT::TEXT;
}
// "SET"
eF_ResT SwWW8ImplReader::Read_F_Set( WW8FieldDesc* pF, OUString& rStr )
{
OUString sOrigName;
OUString sVal;
WW8ReadFieldParams aReadParam( rStr );
for (;;)
{
const sal_Int32 nRet = aReadParam.SkipToNextToken();
if ( nRet==-1 )
break;
switch( nRet )
{
case -2:
if (sOrigName.isEmpty())
sOrigName = aReadParam.GetResult();
else if (sVal.isEmpty())
sVal = aReadParam.GetResult();
break;
}
}
const long nNo = MapBookmarkVariables(pF, sOrigName, sVal);
SwFieldType* pFT = m_rDoc.getIDocumentFieldsAccess().InsertFieldType( SwSetExpFieldType( &m_rDoc, sOrigName,
nsSwGetSetExpType::GSE_STRING ) );
SwSetExpField aField( static_cast<SwSetExpFieldType*>(pFT), sVal, ULONG_MAX );
aField.SetSubType(nsSwExtendedSubType::SUB_INVISIBLE | nsSwGetSetExpType::GSE_STRING);
m_rDoc.getIDocumentContentOperations().InsertPoolItem( *m_pPaM, SwFormatField( aField ) );
m_xReffedStck->SetAttr(*m_pPaM->GetPoint(), RES_FLTR_BOOKMARK, true, nNo);
return eF_ResT::OK;
}
// "REF"
eF_ResT SwWW8ImplReader::Read_F_Ref( WW8FieldDesc*, OUString& rStr )
{ // Reference - Field
OUString sOrigBkmName;
REFERENCEMARK eFormat = REF_CONTENT;
WW8ReadFieldParams aReadParam( rStr );
for (;;)
{
const sal_Int32 nRet = aReadParam.SkipToNextToken();
if ( nRet==-1 )
break;
switch( nRet )
{
case -2:
if( sOrigBkmName.isEmpty() ) // get name of bookmark
sOrigBkmName = aReadParam.GetResult();
break;
/* References to numbers in Word could be either to a numbered
paragraph or to a chapter number. However Word does not seem to
have the capability we do, of referring to the chapter number some
other bookmark is in. As a result, cross-references to chapter
numbers in a word document will be cross-references to a numbered
paragraph, being the chapter heading paragraph. As it happens, our
cross-references to numbered paragraphs will do the right thing
when the target is a numbered chapter heading, so there is no need
for us to use the REF_CHAPTER bookmark format on import.
*/
case 'n':
eFormat = REF_NUMBER_NO_CONTEXT;
break;
case 'r':
eFormat = REF_NUMBER;
break;
case 'w':
eFormat = REF_NUMBER_FULL_CONTEXT;
break;
case 'p':
eFormat = REF_UPDOWN;
break;
case 'h':
break;
default:
// unimplemented switch: just do 'nix nought nothing' :-)
break;
}
}
OUString sBkmName(GetMappedBookmark(sOrigBkmName));
// #i120879# add cross reference bookmark name prefix, if it
// matches internal TOC bookmark naming convention
if ( IsTOCBookmarkName( sBkmName ) )
{
sBkmName = EnsureTOCBookmarkName(sBkmName);
// track <sBookmarkName> as referenced TOC bookmark.
m_xReffedStck->aReferencedTOCBookmarks.insert( sBkmName );
}
SwGetRefField aField(
static_cast<SwGetRefFieldType*>(m_rDoc.getIDocumentFieldsAccess().GetSysFieldType( SwFieldIds::GetRef )),
sBkmName,"",REF_BOOKMARK,0,eFormat);
if (eFormat == REF_CONTENT)
{
/*
If we are just inserting the contents of the bookmark, then it
is possible that the bookmark is actually a variable, so we
must store it until the end of the document to see if it was,
in which case we'll turn it into a show variable
*/
m_xReffingStck->NewAttr( *m_pPaM->GetPoint(), SwFormatField(aField) );
m_xReffingStck->SetAttr( *m_pPaM->GetPoint(), RES_TXTATR_FIELD);
}
else
{
m_rDoc.getIDocumentContentOperations().InsertPoolItem(*m_pPaM, SwFormatField(aField));
}
return eF_ResT::OK;
}
// Note Reference - Field
eF_ResT SwWW8ImplReader::Read_F_NoteReference( WW8FieldDesc*, OUString& rStr )
{
OUString aBkmName;
bool bAboveBelow = false;
WW8ReadFieldParams aReadParam( rStr );
for (;;)
{
const sal_Int32 nRet = aReadParam.SkipToNextToken();
if ( nRet==-1 )
break;
switch( nRet )
{
case -2:
if( aBkmName.isEmpty() ) // get name of foot/endnote
aBkmName = aReadParam.GetResult();
break;
case 'r':
// activate flag 'Chapter Number'
break;
case 'p':
bAboveBelow = true;
break;
case 'h':
break;
default:
// unimplemented switch: just do 'nix nought nothing' :-)
break;
}
}
// set Sequence No of corresponding Foot-/Endnote to Zero
// (will be corrected in
SwGetRefField aField( static_cast<SwGetRefFieldType*>(
m_rDoc.getIDocumentFieldsAccess().GetSysFieldType( SwFieldIds::GetRef )), aBkmName, "", REF_FOOTNOTE, 0,
REF_ONLYNUMBER );
m_xReffingStck->NewAttr(*m_pPaM->GetPoint(), SwFormatField(aField));
m_xReffingStck->SetAttr(*m_pPaM->GetPoint(), RES_TXTATR_FIELD);
if (bAboveBelow)
{
SwGetRefField aField2( static_cast<SwGetRefFieldType*>(
m_rDoc.getIDocumentFieldsAccess().GetSysFieldType( SwFieldIds::GetRef )),aBkmName, "", REF_FOOTNOTE, 0,
REF_UPDOWN );
m_xReffingStck->NewAttr(*m_pPaM->GetPoint(), SwFormatField(aField2));
m_xReffingStck->SetAttr(*m_pPaM->GetPoint(), RES_TXTATR_FIELD);
}
return eF_ResT::OK;
}
// "PAGEREF"
eF_ResT SwWW8ImplReader::Read_F_PgRef( WW8FieldDesc*, OUString& rStr )
{
OUString sOrigName;
WW8ReadFieldParams aReadParam( rStr );
for (;;)
{
const sal_Int32 nRet = aReadParam.SkipToNextToken();
if ( nRet==-1 )
break;
else if ( nRet == -2 && sOrigName.isEmpty() )
{
sOrigName = aReadParam.GetResult();
}
}
const OUString sName(GetMappedBookmark(sOrigName));
// loading page reference field in TOX
if (m_bLoadingTOXCache)
{
// insert page ref representation as plain text --> return FLD_TEXT
// if there is no hyperlink settings for current toc and referenced bookmark is available,
// assign link to current ref area
if (!m_bLoadingTOXHyperlink && !sName.isEmpty())
{
// #i120879# add cross reference bookmark name prefix, if it
// matches internal TOC bookmark naming convention
OUString sBookmarkName;
if ( IsTOCBookmarkName( sName ) )
{
sBookmarkName = EnsureTOCBookmarkName(sName);
// track <sBookmarkName> as referenced TOC bookmark.
m_xReffedStck->aReferencedTOCBookmarks.insert( sBookmarkName );
}
else
{
sBookmarkName = sName;
}
OUString sURL = "#" + sBookmarkName;
const OUString sTarget;
SwFormatINetFormat aURL( sURL, sTarget );
const OUString sLinkStyle("Index Link");
const sal_uInt16 nPoolId =
SwStyleNameMapper::GetPoolIdFromUIName( sLinkStyle, SwGetPoolIdFromName::ChrFmt );
aURL.SetVisitedFormatAndId( sLinkStyle, nPoolId);
aURL.SetINetFormatAndId( sLinkStyle, nPoolId );
m_xCtrlStck->NewAttr( *m_pPaM->GetPoint(), aURL );
}
return eF_ResT::TEXT;
}
// #i120879# add cross reference bookmark name prefix, if it matches
// internal TOC bookmark naming convention
OUString sPageRefBookmarkName;
if ( IsTOCBookmarkName( sName ) )
{
sPageRefBookmarkName = EnsureTOCBookmarkName(sName);
// track <sPageRefBookmarkName> as referenced TOC bookmark.
m_xReffedStck->aReferencedTOCBookmarks.insert( sPageRefBookmarkName );
}
else
{
sPageRefBookmarkName = sName;
}
SwGetRefField aField( static_cast<SwGetRefFieldType*>(m_rDoc.getIDocumentFieldsAccess().GetSysFieldType( SwFieldIds::GetRef )),
sPageRefBookmarkName, "", REF_BOOKMARK, 0, REF_PAGE );
m_rDoc.getIDocumentContentOperations().InsertPoolItem( *m_pPaM, SwFormatField( aField ) );
return eF_ResT::OK;
}
//helper function
//For MS MacroButton field, the symbol in plain text is always "(" (0x28),
//which should be mapped according to the macro type
bool ConvertMacroSymbol( const OUString& rName, OUString& rReference )
{
bool bConverted = false;
if( rReference == "(" )
{
bConverted = true;
sal_Unicode cSymbol = sal_Unicode(); // silence false warning
if (rName == "CheckIt")
cSymbol = 0xF06F;
else if (rName == "UncheckIt")
cSymbol = 0xF0FE;
else if (rName == "ShowExample")
cSymbol = 0xF02A;
//else if... : todo
else
bConverted = false;
if( bConverted )
rReference = OUString(cSymbol);
}
return bConverted;
}
// "MACROBUTTON"
eF_ResT SwWW8ImplReader::Read_F_Macro( WW8FieldDesc*, OUString& rStr)
{
OUString aName;
OUString aVText;
bool bNewVText = true;
bool bBracket = false;
WW8ReadFieldParams aReadParam( rStr );
sal_Int32 nOffset = 0;
for (;;)
{
const sal_Int32 nRet = aReadParam.SkipToNextToken();
if ( nRet==-1 )
break;
switch( nRet )
{
case -2:
if( aName.isEmpty() )
aName = aReadParam.GetResult();
else if( aVText.isEmpty() || bBracket )
{
nOffset = aReadParam.GetTokenSttPtr() + 1;
if( bBracket )
aVText += " ";
aVText += aReadParam.GetResult();
if (bNewVText)
{
bBracket = (aVText[0] == '[');
bNewVText = false;
}
else if( aVText.endsWith("]") )
bBracket = false;
}
break;
}
}
if( aName.isEmpty() )
return eF_ResT::TAGIGN; // makes no sense without Macro-Name
//try converting macro symbol according to macro name
bool bApplyWingdings = ConvertMacroSymbol( aName, aVText );
aName = "StarOffice.Standard.Modul1." + aName;
SwMacroField aField( static_cast<SwMacroFieldType*>(
m_rDoc.getIDocumentFieldsAccess().GetSysFieldType( SwFieldIds::Macro )), aName, aVText );
if( !bApplyWingdings )
{
m_rDoc.getIDocumentContentOperations().InsertPoolItem( *m_pPaM, SwFormatField( aField ) );
WW8_CP nOldCp = m_xPlcxMan->Where();
WW8_CP nCp = nOldCp + nOffset;
SwPaM aPaM(*m_pPaM, m_pPaM);
aPaM.SetMark();
aPaM.Move(fnMoveBackward);
aPaM.Exchange();
m_pPostProcessAttrsInfo.reset(new WW8PostProcessAttrsInfo(nCp, nCp, aPaM));
}
else
{
//set Wingdings font
sal_uInt16 i = 0;
for ( ; i < m_xFonts->GetMax(); i++ )
{
FontFamily eFamily;
OUString aFontName;
FontPitch ePitch;
rtl_TextEncoding eSrcCharSet;
if( GetFontParams( i, eFamily, aFontName, ePitch, eSrcCharSet )
&& aFontName=="Wingdings" )
{
break;
}
}
if ( i < m_xFonts->GetMax() )
{
SetNewFontAttr( i, true, RES_CHRATR_FONT );
m_rDoc.getIDocumentContentOperations().InsertPoolItem( *m_pPaM, SwFormatField( aField ) );
m_xCtrlStck->SetAttr( *m_pPaM->GetPoint(), RES_CHRATR_FONT );
ResetCharSetVars();
}
}
return eF_ResT::OK;
}
WW8PostProcessAttrsInfo::WW8PostProcessAttrsInfo(WW8_CP nCpStart, WW8_CP nCpEnd,
SwPaM & rPaM)
: mbCopy(false)
, mnCpStart(nCpStart)
, mnCpEnd(nCpEnd)
, mPaM(*rPaM.GetMark(), *rPaM.GetPoint())
, mItemSet(rPaM.GetDoc()->GetAttrPool(), svl::Items<RES_CHRATR_BEGIN, RES_PARATR_END - 1>{})
{
}
bool CanUseRemoteLink(const OUString &rGrfName)
{
bool bUseRemote = false;
try
{
// Related: tdf#102499, add a default css::ucb::XCommandEnvironment
// in order to have https protocol manage certificates correctly
uno::Reference< task::XInteractionHandler > xIH(
task::InteractionHandler::createWithParent(comphelper::getProcessComponentContext(), nullptr));
uno::Reference< ucb::XProgressHandler > xProgress;
::ucbhelper::CommandEnvironment* pCommandEnv =
new ::ucbhelper::CommandEnvironment(new comphelper::SimpleFileAccessInteraction( xIH ), xProgress);
::ucbhelper::Content aCnt(rGrfName,
static_cast< ucb::XCommandEnvironment* >(pCommandEnv),
comphelper::getProcessComponentContext());
if ( !INetURLObject( rGrfName ).isAnyKnownWebDAVScheme() )
{
OUString aTitle;
aCnt.getPropertyValue("Title") >>= aTitle;
bUseRemote = !aTitle.isEmpty();
}
else
{
// is a link to a WebDAV resource
// need to use MediaType to check for link usability
OUString aMediaType;
aCnt.getPropertyValue("MediaType") >>= aMediaType;
bUseRemote = !aMediaType.isEmpty();
}
}
catch ( ... )
{
// this file did not exist, so we will not set this as graphiclink
bUseRemote = false;
}
return bUseRemote;
}
// "INCLUDEPICTURE"
eF_ResT SwWW8ImplReader::Read_F_IncludePicture( WW8FieldDesc*, OUString& rStr )
{
OUString aGrfName;
bool bEmbedded = true;
WW8ReadFieldParams aReadParam( rStr );
for (;;)
{
const sal_Int32 nRet = aReadParam.SkipToNextToken();
if ( nRet==-1 )
break;
switch( nRet )
{
case -2:
if (aGrfName.isEmpty())
aGrfName = ConvertFFileName(aReadParam.GetResult());
break;
case 'd':
bEmbedded = false;
break;
case 'c':// skip the converter name
aReadParam.FindNextStringPiece();
break;
}
}
if (!bEmbedded)
bEmbedded = !CanUseRemoteLink(aGrfName);
if (!bEmbedded)
{
/*
Special case:
Now we write the Link into the Doc and remember the SwFlyFrameFormat.
Since we end on return FLD_READ_FSPA below, the skip value will be set
so that Char-1 will still be read.
When we then call SwWW8ImplReader::ImportGraf() it will then recognize
that we have inserted a graphic link and the suiting SwAttrSet will be
inserted into the frame format.
*/
SfxItemSet aFlySet( m_rDoc.GetAttrPool(), svl::Items<RES_FRMATR_BEGIN,
RES_FRMATR_END-1>{} );
aFlySet.Put( SwFormatAnchor( RndStdIds::FLY_AS_CHAR ) );
aFlySet.Put( SwFormatVertOrient( 0, text::VertOrientation::TOP, text::RelOrientation::FRAME ));
m_pFlyFormatOfJustInsertedGraphic =
m_rDoc.getIDocumentContentOperations().InsertGraphic(*m_pPaM,
aGrfName,
OUString(),
nullptr, // Graphic*
&aFlySet,
nullptr, nullptr); // SwFrameFormat*
m_aGrfNameGenerator.SetUniqueGraphName(m_pFlyFormatOfJustInsertedGraphic,
INetURLObject(aGrfName).GetBase());
}
return eF_ResT::READ_FSPA;
}
OUString wwSectionNamer::UniqueName()
{
const OUString aName(msFileLinkSeed + OUString::number(++mnFileSectionNo));
return mrDoc.GetUniqueSectionName(&aName);
}
// "INCLUDETEXT"
eF_ResT SwWW8ImplReader::Read_F_IncludeText( WW8FieldDesc* /*pF*/, OUString& rStr )
{
OUString aPara;
OUString aBook;
WW8ReadFieldParams aReadParam( rStr );
for (;;)
{
const sal_Int32 nRet = aReadParam.SkipToNextToken();
if ( nRet==-1 )
break;
switch( nRet )
{
case -2:
if( aPara.isEmpty() )
aPara = aReadParam.GetResult();
else if( aBook.isEmpty() )
aBook = aReadParam.GetResult();
break;
case '*':
//Skip over MERGEFORMAT
(void)aReadParam.SkipToNextToken();
break;
}
}
aPara = ConvertFFileName(aPara);
if (!aBook.isEmpty() && aBook[ 0 ] != '\\')
{
// Section from Source (no switch)?
ConvertUFName(aBook);
aPara += OUStringLiteral1(sfx2::cTokenSeparator)
+ OUStringLiteral1(sfx2::cTokenSeparator) + aBook;
}
/*
##509##
What we will do is insert a section to be linked to a file, but just in
case the file is not available we will fill in the section with the stored
content of this winword field as a fallback.
*/
SwPosition aTmpPos(*m_pPaM->GetPoint());
SwSectionData aSection(FILE_LINK_SECTION,
m_aSectionNameGenerator.UniqueName());
aSection.SetLinkFileName( aPara );
aSection.SetProtectFlag(true);
SwSection *const pSection =
m_rDoc.InsertSwSection(*m_pPaM, aSection, nullptr, nullptr, false);
OSL_ENSURE(pSection, "no section inserted");
if (!pSection)
return eF_ResT::TEXT;
const SwSectionNode* pSectionNode = pSection->GetFormat()->GetSectionNode();
OSL_ENSURE(pSectionNode, "no section node!");
if (!pSectionNode)
return eF_ResT::TEXT;
m_pPaM->GetPoint()->nNode = pSectionNode->GetIndex()+1;
m_pPaM->GetPoint()->nContent.Assign(m_pPaM->GetContentNode(), 0 );
//we have inserted a section before this point, so adjust pos
//for future page/section segment insertion
m_aSectionManager.PrependedInlineNode(aTmpPos, m_pPaM->GetNode());
return eF_ResT::TEXT;
}
// "SERIALPRINT"
eF_ResT SwWW8ImplReader::Read_F_DBField( WW8FieldDesc* pF, OUString& rStr )
{
#if !HAVE_FEATURE_DBCONNECTIVITY
(void) pF;
(void) rStr;
#else
OUString aName;
WW8ReadFieldParams aReadParam( rStr );
for (;;)
{
const sal_Int32 nRet = aReadParam.SkipToNextToken();
if ( nRet==-1 )
break;
switch( nRet )
{
case -2:
if( aName.isEmpty() )
aName = aReadParam.GetResult();
break;
}
}
SwDBFieldType aD( &m_rDoc, aName, SwDBData() ); // Database: nothing
SwFieldType* pFT = m_rDoc.getIDocumentFieldsAccess().InsertFieldType( aD );
SwDBField aField( static_cast<SwDBFieldType*>(pFT) );
aField.SetFieldCode( rStr );
OUString aResult;
m_xSBase->WW8ReadString( *m_pStrm, aResult, m_xPlcxMan->GetCpOfs()+
pF->nSRes, pF->nLRes, m_eTextCharSet );
aResult = aResult.replace( '\xb', '\n' );
aField.InitContent(aResult);
m_rDoc.getIDocumentContentOperations().InsertPoolItem(*m_pPaM, SwFormatField( aField ));
#endif
return eF_ResT::OK;
}
// "NEXT"
eF_ResT SwWW8ImplReader::Read_F_DBNext( WW8FieldDesc*, OUString& )
{
#if HAVE_FEATURE_DBCONNECTIVITY
SwDBNextSetFieldType aN;
SwFieldType* pFT = m_rDoc.getIDocumentFieldsAccess().InsertFieldType( aN );
SwDBNextSetField aField( static_cast<SwDBNextSetFieldType*>(pFT), OUString(),
SwDBData() ); // Database: nothing
m_rDoc.getIDocumentContentOperations().InsertPoolItem( *m_pPaM, SwFormatField( aField ) );
#endif
return eF_ResT::OK;
}
// "DATASET"
eF_ResT SwWW8ImplReader::Read_F_DBNum( WW8FieldDesc*, OUString& )
{
#if HAVE_FEATURE_DBCONNECTIVITY
SwDBSetNumberFieldType aN;
SwFieldType* pFT = m_rDoc.getIDocumentFieldsAccess().InsertFieldType( aN );
SwDBSetNumberField aField( static_cast<SwDBSetNumberFieldType*>(pFT),
SwDBData() ); // Datenbase: nothing
m_rDoc.getIDocumentContentOperations().InsertPoolItem( *m_pPaM, SwFormatField( aField ) );
#endif
return eF_ResT::OK;
}
/*
EQ , only the usage for
a. Combined Characters supported, must be exactly in the form that word
only accepts as combined characters, i.e.
eq \o(\s\up Y(XXX),\s\do Y(XXX))
b. Ruby Text supported, must be in the form that word recognizes as being
ruby text
...
*/
eF_ResT SwWW8ImplReader::Read_F_Equation( WW8FieldDesc*, OUString& rStr )
{
WW8ReadFieldParams aReadParam( rStr );
const sal_Int32 cChar = aReadParam.SkipToNextToken();
if ('o' == cChar || 'O' == cChar)
{
EquationResult aResult(ParseCombinedChars(rStr));
if (aResult.sType == "Input")
{
SwInputField aField( static_cast<SwInputFieldType*>(m_rDoc.getIDocumentFieldsAccess().GetSysFieldType( SwFieldIds::Input )),
aResult.sResult, aResult.sResult, INP_TXT, 0 );
m_rDoc.getIDocumentContentOperations().InsertPoolItem( *m_pPaM, SwFormatField( aField ) ); // insert input field
}
else if (aResult.sType == "CombinedCharacters")
{
SwCombinedCharField aField(static_cast<SwCombinedCharFieldType*>(
m_rDoc.getIDocumentFieldsAccess().GetSysFieldType(SwFieldIds::CombinedChars)), aResult.sType);
m_rDoc.getIDocumentContentOperations().InsertPoolItem(*m_pPaM, SwFormatField(aField));
}
}
else if ('*' == cChar)
Read_SubF_Ruby(aReadParam);
return eF_ResT::OK;
}
void SwWW8ImplReader::Read_SubF_Ruby( WW8ReadFieldParams& rReadParam)
{
sal_uInt16 nJustificationCode=0;
OUString sFontName;
sal_uInt32 nFontSize=0;
OUString sRuby;
OUString sText;
for (;;)
{
const sal_Int32 nRet = rReadParam.SkipToNextToken();
if ( nRet==-1 )
break;
switch( nRet )
{
case -2:
{
OUString sTemp = rReadParam.GetResult();
if( sTemp.startsWithIgnoreAsciiCase( "jc" ) )
{
sTemp = sTemp.copy(2);
nJustificationCode = static_cast<sal_uInt16>(sTemp.toInt32());
}
else if( sTemp.startsWithIgnoreAsciiCase( "hps" ) )
{
sTemp = sTemp.copy(3);
nFontSize= static_cast<sal_uInt32>(sTemp.toInt32());
}
else if( sTemp.startsWithIgnoreAsciiCase( "Font:" ) )
{
sTemp = sTemp.copy(5);
sFontName = sTemp;
}
}
break;
case '*':
break;
case 'o':
for (;;)
{
const sal_Int32 nRes = rReadParam.SkipToNextToken();
if ( nRes==-1 )
break;
if ('u' == nRes)
{
if (-2 == rReadParam.SkipToNextToken() &&
rReadParam.GetResult().startsWithIgnoreAsciiCase("p"))
{
if (-2 == rReadParam.SkipToNextToken())
{
OUString sPart = rReadParam.GetResult();
sal_Int32 nBegin = sPart.indexOf('(');
//Word disallows brackets in this field,
sal_Int32 nEnd = sPart.indexOf(')');
if ((nBegin != -1) &&
(nEnd != -1) && (nBegin < nEnd))
{
sRuby = sPart.copy(nBegin+1,nEnd-nBegin-1);
}
if (-1 != nEnd)
{
if (-1 ==
(nBegin = sPart.indexOf(',',nEnd)))
{
nBegin = sPart.indexOf(';',nEnd);
}
nEnd = sPart.lastIndexOf(')');
}
if ((nBegin != -1) && (nEnd != -1) && (nBegin < nEnd))
{
sText = sPart.copy(nBegin+1,nEnd-nBegin-1);
}
}
}
}
}
break;
}
}
//Translate and apply
if (sRuby.isEmpty() || sText.isEmpty() || sFontName.isEmpty() || !nFontSize)
return;
css::text::RubyAdjust eRubyAdjust;
switch (nJustificationCode)
{
case 0:
eRubyAdjust = css::text::RubyAdjust_CENTER;
break;
case 1:
eRubyAdjust = css::text::RubyAdjust_BLOCK;
break;
case 2:
eRubyAdjust = css::text::RubyAdjust_INDENT_BLOCK;
break;
default:
case 3:
eRubyAdjust = css::text::RubyAdjust_LEFT;
break;
case 4:
eRubyAdjust = css::text::RubyAdjust_RIGHT;
break;
}
SwFormatRuby aRuby(sRuby);
const SwCharFormat *pCharFormat=nullptr;
//Make a guess at which of asian of western we should be setting
assert(g_pBreakIt && g_pBreakIt->GetBreakIter().is());
sal_uInt16 nScript = g_pBreakIt->GetBreakIter()->getScriptType(sRuby, 0);
//Check to see if we already have a ruby charstyle that this fits
std::vector<const SwCharFormat*>::const_iterator aEnd =
m_aRubyCharFormats.end();
for(std::vector<const SwCharFormat*>::const_iterator aIter
= m_aRubyCharFormats.begin(); aIter != aEnd; ++aIter)
{
const SvxFontHeightItem &rFH =
ItemGet<SvxFontHeightItem>(*(*aIter),
GetWhichOfScript(RES_CHRATR_FONTSIZE,nScript));
if (rFH.GetHeight() == nFontSize*10)
{
const SvxFontItem &rF = ItemGet<SvxFontItem>(*(*aIter),
GetWhichOfScript(RES_CHRATR_FONT,nScript));
if (rF.GetFamilyName() == sFontName)
{
pCharFormat=*aIter;
break;
}
}
}
//Create a new char style if necessary
if (!pCharFormat)
{
OUString aNm;
//Take this as the base name
SwStyleNameMapper::FillUIName(RES_POOLCHR_RUBYTEXT,aNm);
aNm+=OUString::number(m_aRubyCharFormats.size()+1);
SwCharFormat *pFormat = m_rDoc.MakeCharFormat(aNm, m_rDoc.GetDfltCharFormat());
SvxFontHeightItem aHeightItem(nFontSize*10, 100, RES_CHRATR_FONTSIZE);
SvxFontItem aFontItem(FAMILY_DONTKNOW,sFontName,
OUString(), PITCH_DONTKNOW, RTL_TEXTENCODING_DONTKNOW, RES_CHRATR_FONT);
aHeightItem.SetWhich(GetWhichOfScript(RES_CHRATR_FONTSIZE,nScript));
aFontItem.SetWhich(GetWhichOfScript(RES_CHRATR_FONT,nScript));
pFormat->SetFormatAttr(aHeightItem);
pFormat->SetFormatAttr(aFontItem);
m_aRubyCharFormats.push_back(pFormat);
pCharFormat = pFormat;
}
//Set the charstyle and justification
aRuby.SetCharFormatName(pCharFormat->GetName());
aRuby.SetCharFormatId(pCharFormat->GetPoolFormatId());
aRuby.SetAdjustment(eRubyAdjust);
NewAttr(aRuby);
m_rDoc.getIDocumentContentOperations().InsertString( *m_pPaM, sText );
m_xCtrlStck->SetAttr( *m_pPaM->GetPoint(), RES_TXTATR_CJK_RUBY );
}
// "table of ..." fields
static void lcl_toxMatchACSwitch(SwDoc const & rDoc,
SwTOXBase& rBase,
WW8ReadFieldParams& rParam,
SwCaptionDisplay eCaptionType)
{
if ( rParam.GoToTokenParam() )
{
SwTOXType* pType = const_cast<SwTOXType*>(rDoc.GetTOXType( TOX_ILLUSTRATIONS, 0));
rBase.RegisterToTOXType( *pType );
rBase.SetCaptionDisplay( eCaptionType );
// Read Sequence Name and store in TOXBase
OUString sSeqName( rParam.GetResult() );
lcl_ConvertSequenceName( sSeqName );
rBase.SetSequenceName( sSeqName );
}
}
static void EnsureMaxLevelForTemplates(SwTOXBase& rBase)
{
//If the TOC contains Template entries at levels > the evaluation level
//that was initially taken from the max normal outline level of the word TOC
//then we cannot use that for the evaluation level because writer cuts off
//all styles above that level, while word just cuts off the "standard"
//outline styles, we have no option but to expand to the highest level
//Word included.
if ((rBase.GetLevel() != MAXLEVEL) && (SwTOXElement::Template & rBase.GetCreateType()))
{
for (sal_uInt16 nI = MAXLEVEL; nI > 0; --nI)
{
if (!rBase.GetStyleNames(nI-1).isEmpty())
{
rBase.SetLevel(nI);
break;
}
}
}
}
static void lcl_toxMatchTSwitch(SwWW8ImplReader const & rReader, SwTOXBase& rBase,
WW8ReadFieldParams& rParam)
{
if ( rParam.GoToTokenParam() )
{
OUString sParams( rParam.GetResult() );
if( !sParams.isEmpty() )
{
sal_Int32 nIndex = 0;
// Delimiters between styles and style levels appears to allow both ; and ,
OUString sTemplate( sParams.getToken(0, ';', nIndex) );
if( -1 == nIndex )
{
nIndex=0;
sTemplate = sParams.getToken(0, ',', nIndex);
}
if( -1 == nIndex )
{
const SwFormat* pStyle = rReader.GetStyleWithOrgWWName(sTemplate);
if( pStyle )
sTemplate = pStyle->GetName();
// Store Style for Level 0 into TOXBase
rBase.SetStyleNames( sTemplate, 0 );
}
else while( -1 != nIndex )
{
sal_Int32 nOldIndex=nIndex;
sal_uInt16 nLevel = static_cast<sal_uInt16>(
sParams.getToken(0, ';', nIndex).toInt32());
if( -1 == nIndex )
{
nIndex = nOldIndex;
nLevel = static_cast<sal_uInt16>(
sParams.getToken(0, ',', nIndex).toInt32());
}
if( (0 < nLevel) && (MAXLEVEL >= nLevel) )
{
nLevel--;
// Store Style and Level into TOXBase
const SwFormat* pStyle
= rReader.GetStyleWithOrgWWName( sTemplate );
if( pStyle )
sTemplate = pStyle->GetName();
OUString sStyles( rBase.GetStyleNames( nLevel ) );
if( !sStyles.isEmpty() )
sStyles += OUStringLiteral1(TOX_STYLE_DELIMITER);
sStyles += sTemplate;
rBase.SetStyleNames( sStyles, nLevel );
}
// read next style name...
nOldIndex = nIndex;
sTemplate = sParams.getToken(0, ';', nIndex);
if( -1 == nIndex )
{
nIndex=nOldIndex;
sTemplate = sParams.getToken(0, ',', nIndex);
}
}
}
}
}
sal_uInt16 wwSectionManager::CurrentSectionColCount() const
{
sal_uInt16 nIndexCols = 1;
if (!maSegments.empty())
nIndexCols = maSegments.back().maSep.ccolM1 + 1;
return nIndexCols;
}
//Will there be a new pagebreak at this position (don't know what type
//until later)
bool wwSectionManager::WillHavePageDescHere(const SwNodeIndex& rIdx) const
{
bool bRet = false;
if (!maSegments.empty())
{
if (!maSegments.back().IsContinuous() &&
maSegments.back().maStart == rIdx)
{
bRet = true;
}
}
return bRet;
}
static sal_uInt16 lcl_GetMaxValidWordTOCLevel(const SwForm &rForm)
{
// GetFormMax() returns level + 1, hence the -1
sal_uInt16 nRet = rForm.GetFormMax()-1;
// If the max of this type of TOC is greater than the max of a word
// possible toc, then clip to the word max
if (nRet > WW8ListManager::nMaxLevel)
nRet = WW8ListManager::nMaxLevel;
return nRet;
}
eF_ResT SwWW8ImplReader::Read_F_Tox( WW8FieldDesc* pF, OUString& rStr )
{
if (!m_bLoadingTOXCache)
{
m_bLoadingTOXCache = true;
}
else
{
// Embedded TOX --> continue reading its content, but no further TOX
// field
++m_nEmbeddedTOXLevel;
return eF_ResT::TEXT;
}
if (pF->nLRes < 3)
return eF_ResT::TEXT; // ignore (#i25440#)
TOXTypes eTox; // create a ToxBase
switch( pF->nId )
{
case 8:
eTox = TOX_INDEX;
break;
case 13:
eTox = TOX_CONTENT;
break;
default:
eTox = TOX_USER;
break;
}
SwTOXElement nCreateOf = (eTox == TOX_CONTENT) ? SwTOXElement::OutlineLevel : SwTOXElement::Mark;
sal_uInt16 nIndexCols = 1;
const SwTOXType* pType = m_rDoc.GetTOXType( eTox, 0 );
SwForm aOrigForm(eTox);
SwTOXBase* pBase = new SwTOXBase( pType, aOrigForm, nCreateOf, OUString() );
pBase->SetProtected(m_aSectionManager.CurrentSectionIsProtected());
switch( eTox ){
case TOX_INDEX:
{
SwTOIOptions eOptions = SwTOIOptions::SameEntry | SwTOIOptions::CaseSensitive;
// We set SwTOXElement::OutlineLevel only if
// the parameter \o is within 1 to 9
// or the parameter \f exists
// or NO switch parameter are given at all.
WW8ReadFieldParams aReadParam( rStr );
for (;;)
{
const sal_Int32 nRet = aReadParam.SkipToNextToken();
if ( nRet==-1 )
break;
switch( nRet )
{
case 'c':
if ( aReadParam.GoToTokenParam() )
{
const OUString sParams( aReadParam.GetResult() );
// if NO OUString just ignore the \c
if( !sParams.isEmpty() )
{
nIndexCols = static_cast<sal_uInt16>(sParams.toInt32());
}
}
break;
case 'e':
{
if ( aReadParam.GoToTokenParam() ) // if NO String just ignore the \e
{
OUString sDelimiter( aReadParam.GetResult() );
SwForm aForm( pBase->GetTOXForm() );
// Attention: if TOX_CONTENT brave
// GetFormMax() returns MAXLEVEL + 1 !!
sal_uInt16 nEnd = aForm.GetFormMax()-1;
for(sal_uInt16 nLevel = 1;
nLevel <= nEnd;
++nLevel)
{
// Levels count from 1
// Level 0 is reserved for CAPTION
// Insert delimiter instead of tab in front of the page number if there is one:
FormTokenType ePrevType = TOKEN_END;
FormTokenType eType;
// -> #i21237#
SwFormTokens aPattern =
aForm.GetPattern(nLevel);
SwFormTokens::iterator aIt = aPattern.begin();
do
{
eType = ++aIt == aPattern.end() ? TOKEN_END : aIt->eTokenType;
if (eType == TOKEN_PAGE_NUMS)
{
if (TOKEN_TAB_STOP == ePrevType)
{
--aIt;
if(0x09 == sDelimiter[0])
aIt->eTabAlign = SvxTabAdjust::End;
else
{
SwFormToken aToken(TOKEN_TEXT);
aToken.sText = sDelimiter;
*aIt = aToken;
}
aForm.SetPattern(nLevel, aPattern);
}
eType = TOKEN_END;
}
ePrevType = eType;
}
while (TOKEN_END != eType);
// <- #i21237#
}
pBase->SetTOXForm( aForm );
}
}
break;
case 'h':
{
eOptions |= SwTOIOptions::AlphaDelimiter;
}
break;
}
}
pBase->SetOptions( eOptions );
}
break;
case TOX_CONTENT:
{
bool bIsHyperlink = false;
// We set SwTOXElement::OutlineLevel only if
// the parameter \o is within 1 to 9
// or the parameter \f exists
// or NO switch parameter are given at all.
SwTOXElement eCreateFrom = SwTOXElement::NONE;
sal_Int32 nMaxLevel = 0;
WW8ReadFieldParams aReadParam( rStr );
for (;;)
{
const sal_Int32 nRet = aReadParam.SkipToNextToken();
if ( nRet==-1 )
break;
switch( nRet )
{
case 'h':
bIsHyperlink = true;
break;
case 'a':
case 'c':
lcl_toxMatchACSwitch(m_rDoc, *pBase, aReadParam,
('c' == nRet)
? CAPTION_COMPLETE
: CAPTION_TEXT );
break;
case 'o':
{
sal_Int32 nVal;
if( !aReadParam.GetTokenSttFromTo(nullptr, &nVal, WW8ListManager::nMaxLevel) )
nVal = lcl_GetMaxValidWordTOCLevel(aOrigForm);
if( nMaxLevel < nVal )
nMaxLevel = nVal;
eCreateFrom |= SwTOXElement::OutlineLevel;
}
break;
case 'f':
eCreateFrom |= SwTOXElement::Mark;
break;
case 'l':
{
sal_Int32 nVal;
if( aReadParam.GetTokenSttFromTo(nullptr, &nVal, WW8ListManager::nMaxLevel) )
{
if( nMaxLevel < nVal )
nMaxLevel = nVal;
eCreateFrom |= SwTOXElement::Mark;
}
}
break;
case 't': // paragraphs using special styles shall
// provide the TOX's content
lcl_toxMatchTSwitch(*this, *pBase, aReadParam);
eCreateFrom |= SwTOXElement::Template;
break;
case 'p':
{
if ( aReadParam.GoToTokenParam() ) // if NO String just ignore the \p
{
OUString sDelimiter( aReadParam.GetResult() );
SwForm aForm( pBase->GetTOXForm() );
// Attention: if TOX_CONTENT brave
// GetFormMax() returns MAXLEVEL + 1 !!
sal_uInt16 nEnd = aForm.GetFormMax()-1;
for(sal_uInt16 nLevel = 1;
nLevel <= nEnd;
++nLevel)
{
// Levels count from 1
// Level 0 is reserved for CAPTION
// Insert delimiter instead of tab in front of the pagenumber if there is one:
FormTokenType ePrevType = TOKEN_END;
FormTokenType eType;
// -> #i21237#
SwFormTokens aPattern = aForm.GetPattern(nLevel);
SwFormTokens::iterator aIt = aPattern.begin();
do
{
eType = ++aIt == aPattern.end() ? TOKEN_END : aIt->eTokenType;
if (eType == TOKEN_PAGE_NUMS)
{
if (TOKEN_TAB_STOP == ePrevType)
{
--aIt;
SwFormToken aToken(TOKEN_TEXT);
aToken.sText = sDelimiter;
*aIt = aToken;
aForm.SetPattern(nLevel,
aPattern);
}
eType = TOKEN_END;
}
ePrevType = eType;
}
while( TOKEN_END != eType );
// <- #i21237#
}
pBase->SetTOXForm( aForm );
}
}
break;
case 'n': // don't print page numbers
{
// read START and END param
sal_Int32 nStart(0);
sal_Int32 nEnd(0);
if( !aReadParam.GetTokenSttFromTo( &nStart, &nEnd,
WW8ListManager::nMaxLevel ) )
{
nStart = 1;
nEnd = aOrigForm.GetFormMax()-1;
}
// remove page numbers from this levels
SwForm aForm( pBase->GetTOXForm() );
if (aForm.GetFormMax() <= nEnd)
nEnd = aForm.GetFormMax()-1;
for ( sal_Int32 nLevel = nStart; nLevel<=nEnd; ++nLevel )
{
// Levels count from 1
// Level 0 is reserved for CAPTION
// Remove pagenumber and if necessary the tab in front of it:
FormTokenType eType;
// -> #i21237#
SwFormTokens aPattern = aForm.GetPattern(nLevel);
SwFormTokens::iterator aIt = aPattern.begin();
do
{
eType = ++aIt == aPattern.end() ? TOKEN_END : aIt->eTokenType;
if (eType == TOKEN_PAGE_NUMS)
{
aIt = aPattern.erase(aIt);
--aIt;
if (
TOKEN_TAB_STOP ==
aIt->eTokenType
)
{
aPattern.erase(aIt);
aForm.SetPattern(nLevel, aPattern);
}
eType = TOKEN_END;
}
}
while (TOKEN_END != eType);
// <- #i21237#
}
pBase->SetTOXForm( aForm );
}
break;
/*
// the following switches are not (yet) supported
// by good old StarWriter:
case 'b':
case 's':
case 'd':
break;
*/
}
}
// For loading the expression of TOC field, we need to mapping its parameters to TOX entries tokens
// also include the hyperlinks and page references
SwFormToken aLinkStart(TOKEN_LINK_START);
SwFormToken aLinkEnd(TOKEN_LINK_END);
aLinkStart.sCharStyleName = "Index Link";
aLinkEnd.sCharStyleName = "Index Link";
SwForm aForm(pBase->GetTOXForm());
sal_uInt16 nEnd = aForm.GetFormMax()-1;
for(sal_uInt16 nLevel = 1; nLevel <= nEnd; ++nLevel)
{
SwFormTokens aPattern = aForm.GetPattern(nLevel);
if ( bIsHyperlink )
{
aPattern.insert(aPattern.begin(), aLinkStart);
}
else
{
for (SwFormTokens::iterator aItr = aPattern.begin();aItr!= aPattern.end();++aItr)
{
if (aItr->eTokenType == TOKEN_PAGE_NUMS)
{
aPattern.insert(aItr,aLinkStart);
break;
}
}
}
aPattern.push_back(aLinkEnd);
aForm.SetPattern(nLevel, aPattern);
}
pBase->SetTOXForm(aForm);
if (!nMaxLevel)
nMaxLevel = WW8ListManager::nMaxLevel;
pBase->SetLevel(nMaxLevel);
const TOXTypes eType = pBase->GetTOXType()->GetType();
switch( eType )
{
case TOX_CONTENT:
{
//If we would be created from outlines, either explicitly or by default
//then see if we need extra styles added to the outlines
SwTOXElement eEffectivelyFrom = eCreateFrom != SwTOXElement::NONE ? eCreateFrom : SwTOXElement::OutlineLevel;
if (eEffectivelyFrom & SwTOXElement::OutlineLevel)
{
// #i19683# Insert a text token " " between the number and entry token.
// In an ideal world we could handle the tab stop between the number and
// the entry correctly, but I currently have no clue how to obtain
// the tab stop position. It is _not_ set at the paragraph style.
SwForm* pForm = nullptr;
for (SwWW8StyInf & rSI : m_vColl)
{
if (rSI.IsOutlineNumbered())
{
sal_uInt16 nStyleLevel = rSI.mnWW8OutlineLevel;
const SwNumFormat& rFormat = rSI.GetOutlineNumrule()->Get( nStyleLevel );
if ( SVX_NUM_NUMBER_NONE != rFormat.GetNumberingType() )
{
++nStyleLevel;
if ( !pForm )
pForm = new SwForm( pBase->GetTOXForm() );
SwFormTokens aPattern = pForm->GetPattern(nStyleLevel);
SwFormTokens::iterator aIt =
find_if(aPattern.begin(), aPattern.end(),
SwFormTokenEqualToFormTokenType(TOKEN_ENTRY_NO));
if ( aIt != aPattern.end() )
{
SwFormToken aNumberEntrySeparator( TOKEN_TEXT );
aNumberEntrySeparator.sText = " ";
aPattern.insert( ++aIt, aNumberEntrySeparator );
pForm->SetPattern( nStyleLevel, aPattern );
}
}
}
}
if ( pForm )
{
pBase->SetTOXForm( *pForm );
delete pForm;
}
}
if (eCreateFrom != SwTOXElement::NONE)
pBase->SetCreate(eCreateFrom);
EnsureMaxLevelForTemplates(*pBase);
}
break;
case TOX_ILLUSTRATIONS:
{
if( eCreateFrom == SwTOXElement::NONE )
eCreateFrom = SwTOXElement::Sequence;
pBase->SetCreate( eCreateFrom );
/*
We don't know until here if we are an illustration
or not, and so have being used a TOX_CONTENT so far
which has 10 levels, while TOX has only two, this
level is set only in the constructor of SwForm, so
create a new one and copy over anything that could
be set in the old one, and remove entries from the
pattern which do not apply to illustration indices
*/
SwForm aOldForm( pBase->GetTOXForm() );
SwForm aNewForm( eType );
sal_uInt16 nNewEnd = aNewForm.GetFormMax()-1;
// #i21237#
for(sal_uInt16 nLevel = 1; nLevel <= nNewEnd; ++nLevel)
{
SwFormTokens aPattern = aOldForm.GetPattern(nLevel);
SwFormTokens::iterator new_end =
remove_if(aPattern.begin(), aPattern.end(), SwFormTokenEqualToFormTokenType(TOKEN_ENTRY_NO));
aPattern.erase(new_end, aPattern.end() ); // table index imported with wrong page number format
aForm.SetPattern( nLevel, aPattern );
aForm.SetTemplate( nLevel, aOldForm.GetTemplate(nLevel) );
}
pBase->SetTOXForm( aNewForm );
}
break;
default:
OSL_ENSURE(false, "Unhandled toc options!");
break;
}
}
break;
case TOX_USER:
break;
default:
OSL_ENSURE(false, "Unhandled toc options!");
break;
} // ToxBase fertig
// #i21237# - propagate tab stops from paragraph styles used in TOX to patterns of the TOX
pBase->AdjustTabStops( m_rDoc );
//#i10028# inserting a toc implicitly acts like a parabreak in word and writer
if ( m_pPaM->End() &&
m_pPaM->End()->nNode.GetNode().GetTextNode() &&
m_pPaM->End()->nNode.GetNode().GetTextNode()->Len() != 0 )
{
m_bCareFirstParaEndInToc = true;
}
if (m_pPaM->GetPoint()->nContent.GetIndex())
AppendTextNode(*m_pPaM->GetPoint());
const SwPosition* pPos = m_pPaM->GetPoint();
SwFltTOX aFltTOX( pBase );
// test if there is already a break item on this node
if(SwContentNode* pNd = pPos->nNode.GetNode().GetContentNode())
{
const SfxItemSet* pSet = pNd->GetpSwAttrSet();
if( pSet )
{
if (SfxItemState::SET == pSet->GetItemState(RES_BREAK, false))
aFltTOX.SetHadBreakItem(true);
if (SfxItemState::SET == pSet->GetItemState(RES_PAGEDESC, false))
aFltTOX.SetHadPageDescItem(true);
}
}
//Will there be a new pagebreak at this position (don't know what type
//until later)
if (m_aSectionManager.WillHavePageDescHere(pPos->nNode))
aFltTOX.SetHadPageDescItem(true);
// Set start in stack
m_xReffedStck->NewAttr( *pPos, aFltTOX );
m_rDoc.InsertTableOf(*m_pPaM->GetPoint(), *aFltTOX.GetBase());
//The TOC field representation contents should be inserted into TOC section, but not after TOC section.
//So we need update the document position when loading TOC representation and after loading TOC;
m_pPosAfterTOC.reset(new SwPaM(*m_pPaM, m_pPaM));
(*m_pPaM).Move(fnMoveBackward);
SwPaM aRegion(*m_pPaM, m_pPaM);
OSL_ENSURE(SwDoc::GetCurTOX(*aRegion.GetPoint()), "Misunderstood how toc works");
if (SwTOXBase* pBase2 = SwDoc::GetCurTOX(*aRegion.GetPoint()))
{
pBase2->SetMSTOCExpression(rStr);
if ( nIndexCols > 1 )
{
// Set the column number for index
SfxItemSet aSet( m_rDoc.GetAttrPool(), svl::Items<RES_COL, RES_COL>{} );
SwFormatCol aCol;
aCol.Init( nIndexCols, 708, USHRT_MAX );
aSet.Put( aCol );
pBase2->SetAttrSet( aSet );
}
// inserting a toc inserts a section before this point, so adjust pos
// for future page/section segment insertion
m_aSectionManager.PrependedInlineNode( *m_pPosAfterTOC->GetPoint(), aRegion.GetNode() );
}
// Set end in stack
m_xReffedStck->SetAttr( *pPos, RES_FLTR_TOX );
if (!m_aApos.back()) //a para end in apo doesn't count
m_bWasParaEnd = true;
//Return FLD_TEXT, instead of FLD_OK
//FLD_TEXT means the following content, commonly indicate the field representation content should be parsed
//FLD_OK means the current field loading is finished. The rest part should be ignored.
return eF_ResT::TEXT;
}
eF_ResT SwWW8ImplReader::Read_F_Shape(WW8FieldDesc* /*pF*/, OUString& /*rStr*/)
{
/*
#i3958# 0x8 followed by 0x1 where the shape is the 0x8 and its anchoring
to be ignored followed by a 0x1 with an empty drawing. Detect in inserting
the drawing that we are in the Shape field and respond accordingly
*/
return eF_ResT::TEXT;
}
eF_ResT SwWW8ImplReader::Read_F_Hyperlink( WW8FieldDesc* /*pF*/, OUString& rStr )
{
OUString sURL, sTarget, sMark;
//HYPERLINK "filename" [switches]
rStr = comphelper::string::stripEnd(rStr, 1);
bool bOptions = false;
WW8ReadFieldParams aReadParam( rStr );
for (;;)
{
const sal_Int32 nRet = aReadParam.SkipToNextToken();
if ( nRet==-1 )
break;
switch( nRet )
{
case -2:
if (sURL.isEmpty() && !bOptions)
sURL = ConvertFFileName(aReadParam.GetResult());
break;
case 'n':
sTarget = "_blank";
bOptions = true;
break;
case 'l':
bOptions = true;
if ( aReadParam.SkipToNextToken()==-2 )
{
sMark = aReadParam.GetResult();
if( sMark.endsWith("\""))
{
sMark = sMark.copy( 0, sMark.getLength() - 1 );
}
// #120879# add cross reference bookmark name prefix, if it matches internal TOC bookmark naming convention
if ( IsTOCBookmarkName( sMark ) )
{
sMark = EnsureTOCBookmarkName(sMark);
// track <sMark> as referenced TOC bookmark.
m_xReffedStck->aReferencedTOCBookmarks.insert( sMark );
}
if (m_bLoadingTOXCache)
{
m_bLoadingTOXHyperlink = true; //on loading a TOC field nested hyperlink field
}
}
break;
case 't':
bOptions = true;
if ( aReadParam.SkipToNextToken()==-2 )
sTarget = aReadParam.GetResult();
break;
case 'h':
case 'm':
OSL_ENSURE( false, "Analysis still missing - unknown data" );
SAL_FALLTHROUGH;
case 's': //worthless fake anchor option
bOptions = true;
break;
}
}
// use the result
OSL_ENSURE(!sURL.isEmpty() || !sMark.isEmpty(), "WW8: Empty URL");
if( !sMark.isEmpty() )
( sURL += "#" ) += sMark;
SwFormatINetFormat aURL(sURL, sTarget);
// If on loading TOC field, change the default style into the "index link"
if (m_bLoadingTOXCache)
{
OUString sLinkStyle("Index Link");
sal_uInt16 nPoolId =
SwStyleNameMapper::GetPoolIdFromUIName( sLinkStyle, SwGetPoolIdFromName::ChrFmt );
aURL.SetVisitedFormatAndId( sLinkStyle, nPoolId );
aURL.SetINetFormatAndId( sLinkStyle, nPoolId );
}
//As an attribute this needs to be closed, and that'll happen from
//EndExtSprm in conjunction with the maFieldStack. If there are flyfrms
//between the start and begin, their hyperlinks will be set at that time
//as well.
m_xCtrlStck->NewAttr( *m_pPaM->GetPoint(), aURL );
return eF_ResT::TEXT;
}
static void lcl_ImportTox(SwDoc &rDoc, SwPaM const &rPaM, const OUString &rStr, bool bIdx)
{
TOXTypes eTox = ( !bIdx ) ? TOX_CONTENT : TOX_INDEX; // Default
sal_uInt16 nLevel = 1;
OUString sFieldText;
WW8ReadFieldParams aReadParam(rStr);
for (;;)
{
const sal_Int32 nRet = aReadParam.SkipToNextToken();
if ( nRet==-1 )
break;
switch( nRet )
{
case -2:
if( sFieldText.isEmpty() )
{
// PrimaryKey without ":", 2nd after
sFieldText = aReadParam.GetResult();
}
break;
case 'f':
if ( aReadParam.GoToTokenParam() )
{
const OUString sParams( aReadParam.GetResult() );
if( sParams[0]!='C' && sParams[0]!='c' )
eTox = TOX_USER;
}
break;
case 'l':
if ( aReadParam.GoToTokenParam() )
{
const OUString sParams( aReadParam.GetResult() );
// if NO String just ignore the \l
if( !sParams.isEmpty() && sParams[0]>'0' && sParams[0]<='9' )
{
nLevel = static_cast<sal_uInt16>(sParams.toInt32());
}
}
break;
}
}
OSL_ENSURE( rDoc.GetTOXTypeCount( eTox ), "Doc.GetTOXTypeCount() == 0 :-(" );
const SwTOXType* pT = rDoc.GetTOXType( eTox, 0 );
SwTOXMark aM( pT );
if( eTox != TOX_INDEX )
aM.SetLevel( nLevel );
else
{
sal_Int32 nFnd = sFieldText.indexOf( WW8_TOX_LEVEL_DELIM );
if( -1 != nFnd ) // it exist levels
{
aM.SetPrimaryKey( sFieldText.copy( 0, nFnd ) );
sal_Int32 nScndFnd = sFieldText.indexOf( WW8_TOX_LEVEL_DELIM, nFnd+1 );
if( -1 != nScndFnd )
{
aM.SetSecondaryKey( sFieldText.copy( nFnd+1, nScndFnd - nFnd - 1 ));
nFnd = nScndFnd;
}
sFieldText = sFieldText.copy( nFnd+1 );
}
}
if (!sFieldText.isEmpty())
{
aM.SetAlternativeText( sFieldText );
rDoc.getIDocumentContentOperations().InsertPoolItem( rPaM, aM );
}
}
void SwWW8ImplReader::ImportTox( int nFieldId, const OUString& aStr )
{
bool bIdx = (nFieldId != 9);
lcl_ImportTox(m_rDoc, *m_pPaM, aStr, bIdx);
}
void SwWW8ImplReader::Read_FieldVanish( sal_uInt16, const sal_uInt8*, short nLen )
{
//Meaningless in a style
if (m_pCurrentColl || !m_xPlcxMan)
return;
const int nChunk = 64; //number of characters to read at one time
// Careful: MEMICMP doesn't work with fieldnames including umlauts!
const static sal_Char *aFieldNames[] = { "\x06""INHALT", "\x02""XE", // dt.
"\x02""TC" }; // us
const static sal_uInt8 aFieldId[] = { 9, 4, 9 };
if( nLen < 0 )
{
m_bIgnoreText = false;
return;
}
// our method was called from
// ''Skip attributes of field contents'' loop within ReadTextAttr()
if( m_bIgnoreText )
return;
m_bIgnoreText = true;
long nOldPos = m_pStrm->Tell();
WW8_CP nStartCp = m_xPlcxMan->Where() + m_xPlcxMan->GetCpOfs();
OUString sFieldName;
sal_Int32 nFieldLen = m_xSBase->WW8ReadString( *m_pStrm, sFieldName, nStartCp,
nChunk, m_eStructCharSet );
nStartCp+=nFieldLen;
sal_Int32 nC = 0;
//If the first chunk did not start with a field start then
//reset the stream position and give up
if( !nFieldLen || sFieldName[nC]!=0x13 ) // Field Start Mark
{
// If Field End Mark found
if( nFieldLen && sFieldName[nC]==0x15 )
m_bIgnoreText = false;
m_pStrm->Seek( nOldPos );
return; // no field found
}
sal_Int32 nFnd;
//If this chunk does not contain a field end, keep reading chunks
//until we find one, or we run out of text,
for (;;)
{
nFnd = sFieldName.indexOf(0x15);
//found field end, we can stop now
if (nFnd != -1)
break;
OUString sTemp;
nFieldLen = m_xSBase->WW8ReadString( *m_pStrm, sTemp,
nStartCp, nChunk, m_eStructCharSet );
sFieldName+=sTemp;
nStartCp+=nFieldLen;
if (!nFieldLen)
break;
}
m_pStrm->Seek( nOldPos );
//if we have no 0x15 give up, otherwise erase everything from the 0x15
//onwards
if (nFnd<0)
return;
sFieldName = sFieldName.copy(0, nFnd);
nC++;
while ( sFieldName[nC]==' ' )
nC++;
for( int i = 0; i < 3; i++ )
{
const sal_Char* pName = aFieldNames[i];
const sal_Int32 nNameLen = static_cast<sal_Int32>(*pName++);
if( sFieldName.matchIgnoreAsciiCaseAsciiL( pName, nNameLen, nC ) )
{
ImportTox( aFieldId[i], sFieldName.copy( nC + nNameLen ) );
break; // no duplicates allowed
}
}
m_bIgnoreText = true;
m_pStrm->Seek( nOldPos );
}
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
↑ V1001 The 'sParams' variable is assigned but is not used by the end of the function.
↑ V653 A suspicious string consisting of two parts is used for initialization. It is possible that a comma is missing. Consider inspecting this literal: "\x06""INHALT".
↑ V653 A suspicious string consisting of two parts is used for initialization. It is possible that a comma is missing. Consider inspecting this literal: "\x02""XE".
↑ V653 A suspicious string consisting of two parts is used for initialization. It is possible that a comma is missing. Consider inspecting this literal: "\x02""TC".