/* -*- 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 <unotools/charclass.hxx>
#include <com/sun/star/i18n/CollatorOptions.hpp>
#include <editeng/unolingu.hxx>
#include <txtfld.hxx>
#include <doc.hxx>
#include <IDocumentLayoutAccess.hxx>
#include <IDocumentMarkAccess.hxx>
#include <docary.hxx>
#include <cntfrm.hxx>
#include <node.hxx>
#include <frmatr.hxx>
#include <pam.hxx>
#include <txttxmrk.hxx>
#include <frmfmt.hxx>
#include <fmtfld.hxx>
#include <txmsrt.hxx>
#include <ndtxt.hxx>
#include <txtatr.hxx>
#include <swtable.hxx>
#include <expfld.hxx>
#include <authfld.hxx>
#include <toxwrap.hxx>
#include <strings.hrc>
#include <numrule.hxx>
#include <reffld.hxx>
using namespace ::com::sun::star;
using namespace ::com::sun::star::uno;
// Initialize strings
SwTOIOptions SwTOXSortTabBase::nOpt = SwTOIOptions::NONE;
SwTOXInternational::SwTOXInternational( LanguageType nLang, SwTOIOptions nOpt,
const OUString& rSortAlgorithm ) :
m_eLang( nLang ),
m_sSortAlgorithm(rSortAlgorithm),
m_nOptions( nOpt )
{
Init();
}
SwTOXInternational::SwTOXInternational( const SwTOXInternational& rIntl ) :
m_eLang( rIntl.m_eLang ),
m_sSortAlgorithm(rIntl.m_sSortAlgorithm),
m_nOptions( rIntl.m_nOptions )
{
Init();
}
void SwTOXInternational::Init()
{
m_pIndexWrapper.reset( new IndexEntrySupplierWrapper() );
const lang::Locale aLcl( LanguageTag::convertToLocale( m_eLang ) );
m_pIndexWrapper->SetLocale( aLcl );
if(m_sSortAlgorithm.isEmpty())
{
Sequence < OUString > aSeq( m_pIndexWrapper->GetAlgorithmList( aLcl ));
if(aSeq.getLength())
m_sSortAlgorithm = aSeq.getConstArray()[0];
}
if ( m_nOptions & SwTOIOptions::CaseSensitive )
m_pIndexWrapper->LoadAlgorithm( aLcl, m_sSortAlgorithm, 0 );
else
m_pIndexWrapper->LoadAlgorithm( aLcl, m_sSortAlgorithm, SW_COLLATOR_IGNORES );
m_pCharClass.reset( new CharClass( LanguageTag( aLcl )) );
}
SwTOXInternational::~SwTOXInternational()
{
m_pCharClass.reset();
m_pIndexWrapper.reset();
}
OUString SwTOXInternational::ToUpper( const OUString& rStr, sal_Int32 nPos ) const
{
return m_pCharClass->uppercase( rStr, nPos, 1 );
}
inline bool SwTOXInternational::IsNumeric( const OUString& rStr ) const
{
return m_pCharClass->isNumeric( rStr );
}
sal_Int32 SwTOXInternational::Compare( const TextAndReading& rTaR1,
const lang::Locale& rLocale1,
const TextAndReading& rTaR2,
const lang::Locale& rLocale2 ) const
{
return m_pIndexWrapper->CompareIndexEntry( rTaR1.sText, rTaR1.sReading, rLocale1,
rTaR2.sText, rTaR2.sReading, rLocale2 );
}
OUString SwTOXInternational::GetIndexKey( const TextAndReading& rTaR,
const lang::Locale& rLocale ) const
{
return m_pIndexWrapper->GetIndexKey( rTaR.sText, rTaR.sReading, rLocale );
}
OUString SwTOXInternational::GetFollowingText( bool bMorePages ) const
{
return m_pIndexWrapper->GetFollowingText( bMorePages );
}
// SortElement for TOX entries
SwTOXSortTabBase::SwTOXSortTabBase( TOXSortType nTyp, const SwContentNode* pNd,
const SwTextTOXMark* pMark,
const SwTOXInternational* pInter,
const lang::Locale* pLocale )
: pTOXNd( nullptr ), pTextMark( pMark ), pTOXIntl( pInter ),
nPos( 0 ), nCntPos( 0 ), nType( static_cast<sal_uInt16>(nTyp) ), bValidText( false )
{
if ( pLocale )
aLocale = *pLocale;
if( pNd )
{
sal_Int32 n = 0;
if( pTextMark )
n = pTextMark->GetStart();
SwTOXSource aTmp( pNd, n, pTextMark && pTextMark->GetTOXMark().IsMainEntry() );
aTOXSources.push_back(aTmp);
nPos = pNd->GetIndex();
switch( nTyp )
{
case TOX_SORT_CONTENT:
case TOX_SORT_PARA:
case TOX_SORT_TABLE:
// If they are in a special areas, we should get the position at the
// body
if( nPos < pNd->GetNodes().GetEndOfExtras().GetIndex() )
{
// Then get the 'anchor' (body) position
Point aPt;
const SwContentFrame* pFrame = pNd->getLayoutFrame( pNd->GetDoc()->getIDocumentLayoutAccess().GetCurrentLayout(), &aPt, nullptr, false );
if( pFrame )
{
SwPosition aPos( *pNd );
const SwDoc& rDoc = *pNd->GetDoc();
bool const bResult = GetBodyTextNode( rDoc, aPos, *pFrame );
OSL_ENSURE(bResult, "where is the text node");
nPos = aPos.nNode.GetIndex();
nCntPos = aPos.nContent.GetIndex();
}
}
else
nCntPos = n;
break;
default: break;
}
}
}
OUString SwTOXSortTabBase::GetURL() const
{
return OUString();
}
void SwTOXSortTabBase::FillText( SwTextNode& rNd, const SwIndex& rInsPos,
sal_uInt16 ) const
{
rNd.InsertText( GetText().sText, rInsPos );
}
bool SwTOXSortTabBase::operator==( const SwTOXSortTabBase& rCmp )
{
bool bRet = nPos == rCmp.nPos && nCntPos == rCmp.nCntPos &&
(!aTOXSources[0].pNd || !rCmp.aTOXSources[0].pNd ||
aTOXSources[0].pNd == rCmp.aTOXSources[0].pNd );
if( TOX_SORT_CONTENT == nType )
{
bRet = bRet && pTextMark && rCmp.pTextMark &&
pTextMark->GetStart() == rCmp.pTextMark->GetStart();
if( bRet )
{
// Both pointers exist -> compare text
// else -> compare AlternativeText
const sal_Int32 *pEnd = pTextMark->End();
const sal_Int32 *pEndCmp = rCmp.pTextMark->End();
bRet = ( ( pEnd && pEndCmp ) || ( !pEnd && !pEndCmp ) ) &&
pTOXIntl->IsEqual( GetText(), GetLocale(),
rCmp.GetText(), rCmp.GetLocale() );
}
}
return bRet;
}
bool SwTOXSortTabBase::operator<( const SwTOXSortTabBase& rCmp )
{
if( nPos < rCmp.nPos )
return true;
if( nPos == rCmp.nPos )
{
if( nCntPos < rCmp.nCntPos )
return true;
if( nCntPos == rCmp.nCntPos )
{
const SwNode* pFirst = aTOXSources[0].pNd;
const SwNode* pNext = rCmp.aTOXSources[0].pNd;
if( pFirst && pFirst == pNext )
{
if( TOX_SORT_CONTENT == nType && pTextMark && rCmp.pTextMark )
{
if( pTextMark->GetStart() < rCmp.pTextMark->GetStart() )
return true;
if( pTextMark->GetStart() == rCmp.pTextMark->GetStart() )
{
const sal_Int32 *pEnd = pTextMark->End();
const sal_Int32 *pEndCmp = rCmp.pTextMark->End();
// Both pointers exist -> compare text
// else -> compare AlternativeText
if( ( pEnd && pEndCmp ) || ( !pEnd && !pEndCmp ) )
{
return pTOXIntl->IsLess( GetText(), GetLocale(),
rCmp.GetText(), rCmp.GetLocale() );
}
if( pEnd && !pEndCmp )
return true;
}
}
}
else if( pFirst && pFirst->IsTextNode() &&
pNext && pNext->IsTextNode() )
return ::IsFrameBehind( *static_cast<const SwTextNode*>(pNext), nCntPos,
*static_cast<const SwTextNode*>(pFirst), nCntPos );
}
}
return false;
}
// Sorted keyword entry
SwTOXIndex::SwTOXIndex( const SwTextNode& rNd,
const SwTextTOXMark* pMark, SwTOIOptions nOptions,
sal_uInt8 nKyLevel,
const SwTOXInternational& rIntl,
const lang::Locale& rLocale )
: SwTOXSortTabBase( TOX_SORT_INDEX, &rNd, pMark, &rIntl, &rLocale ),
nKeyLevel(nKyLevel)
{
nPos = rNd.GetIndex();
nOpt = nOptions;
}
// Compare keywords. Only relates to the text.
bool SwTOXIndex::operator==( const SwTOXSortTabBase& rCmpBase )
{
const SwTOXIndex& rCmp = static_cast<const SwTOXIndex&>(rCmpBase);
// Respect case taking dependencies into account
if(GetLevel() != rCmp.GetLevel() || nKeyLevel != rCmp.nKeyLevel)
return false;
OSL_ENSURE(pTextMark, "pTextMark == 0, No keyword");
bool bRet = pTOXIntl->IsEqual( GetText(), GetLocale(),
rCmp.GetText(), rCmp.GetLocale() );
// If we don't summarize we need to evaluate the Pos
if(bRet && !(GetOptions() & SwTOIOptions::SameEntry))
bRet = nPos == rCmp.nPos;
return bRet;
}
// operator, only depends on the text
bool SwTOXIndex::operator<( const SwTOXSortTabBase& rCmpBase )
{
const SwTOXIndex& rCmp = static_cast<const SwTOXIndex&>(rCmpBase);
OSL_ENSURE(pTextMark, "pTextMark == 0, No keyword");
const TextAndReading aMyTaR(GetText());
const TextAndReading aOtherTaR(rCmp.GetText());
bool bRet = GetLevel() == rCmp.GetLevel() &&
pTOXIntl->IsLess( aMyTaR, GetLocale(),
aOtherTaR, rCmp.GetLocale() );
// If we don't summarize we need to evaluate the Pos
if( !bRet && !(GetOptions() & SwTOIOptions::SameEntry) )
{
bRet = pTOXIntl->IsEqual( aMyTaR, GetLocale(),
aOtherTaR, rCmp.GetLocale() ) &&
nPos < rCmp.nPos;
}
return bRet;
}
// The keyword itself
TextAndReading SwTOXIndex::GetText_Impl() const
{
OSL_ENSURE(pTextMark, "pTextMark == 0, No keyword");
const SwTOXMark& rTOXMark = pTextMark->GetTOXMark();
TextAndReading aRet;
switch(nKeyLevel)
{
case FORM_PRIMARY_KEY :
{
aRet.sText = rTOXMark.GetPrimaryKey();
aRet.sReading = rTOXMark.GetPrimaryKeyReading();
}
break;
case FORM_SECONDARY_KEY :
{
aRet.sText = rTOXMark.GetSecondaryKey();
aRet.sReading = rTOXMark.GetSecondaryKeyReading();
}
break;
case FORM_ENTRY :
{
aRet.sText = rTOXMark.GetText();
aRet.sReading = rTOXMark.GetTextReading();
}
break;
}
// if SwTOIOptions::InitialCaps is set, first character is to be capitalized
if( SwTOIOptions::InitialCaps & nOpt && pTOXIntl && !aRet.sText.isEmpty())
{
aRet.sText = pTOXIntl->ToUpper( aRet.sText, 0 ) + aRet.sText.copy(1);
}
return aRet;
}
void SwTOXIndex::FillText( SwTextNode& rNd, const SwIndex& rInsPos, sal_uInt16 ) const
{
const sal_Int32* pEnd = pTextMark->End();
TextAndReading aRet;
if( pEnd && !pTextMark->GetTOXMark().IsAlternativeText() &&
!(GetOptions() & SwTOIOptions::KeyAsEntry))
{
aRet.sText = static_cast<const SwTextNode*>(aTOXSources[0].pNd)->GetExpandText(
pTextMark->GetStart(),
*pEnd - pTextMark->GetStart());
if(SwTOIOptions::InitialCaps & nOpt && pTOXIntl && !aRet.sText.isEmpty())
{
aRet.sText = pTOXIntl->ToUpper( aRet.sText, 0 ) + aRet.sText.copy(1);
}
}
else
aRet = GetText();
rNd.InsertText( aRet.sText, rInsPos );
}
sal_uInt16 SwTOXIndex::GetLevel() const
{
OSL_ENSURE(pTextMark, "pTextMark == 0, No keyword");
sal_uInt16 nForm = FORM_PRIMARY_KEY;
if( !(GetOptions() & SwTOIOptions::KeyAsEntry)&&
!pTextMark->GetTOXMark().GetPrimaryKey().isEmpty() )
{
nForm = FORM_SECONDARY_KEY;
if( !pTextMark->GetTOXMark().GetSecondaryKey().isEmpty() )
nForm = FORM_ENTRY;
}
return nForm;
}
// Key and separator
SwTOXCustom::SwTOXCustom(const TextAndReading& rKey,
sal_uInt16 nLevel,
const SwTOXInternational& rIntl,
const lang::Locale& rLocale )
: SwTOXSortTabBase( TOX_SORT_CUSTOM, nullptr, nullptr, &rIntl, &rLocale ),
m_aKey(rKey), nLev(nLevel)
{
}
bool SwTOXCustom::operator==(const SwTOXSortTabBase& rCmpBase)
{
return GetLevel() == rCmpBase.GetLevel() &&
pTOXIntl->IsEqual( GetText(), GetLocale(),
rCmpBase.GetText(), rCmpBase.GetLocale() );
}
bool SwTOXCustom::operator < (const SwTOXSortTabBase& rCmpBase)
{
return GetLevel() <= rCmpBase.GetLevel() &&
pTOXIntl->IsLess( GetText(), GetLocale(),
rCmpBase.GetText(), rCmpBase.GetLocale() );
}
sal_uInt16 SwTOXCustom::GetLevel() const
{
return nLev;
}
TextAndReading SwTOXCustom::GetText_Impl() const
{
return m_aKey;
}
// Sorts the TOX entries
SwTOXContent::SwTOXContent( const SwTextNode& rNd, const SwTextTOXMark* pMark,
const SwTOXInternational& rIntl)
: SwTOXSortTabBase( TOX_SORT_CONTENT, &rNd, pMark, &rIntl )
{
}
// The content's text
TextAndReading SwTOXContent::GetText_Impl() const
{
const sal_Int32* pEnd = pTextMark->End();
if( pEnd && !pTextMark->GetTOXMark().IsAlternativeText() )
{
return TextAndReading(
static_cast<const SwTextNode*>(aTOXSources[0].pNd)->GetExpandText(
pTextMark->GetStart(),
*pEnd - pTextMark->GetStart() ),
pTextMark->GetTOXMark().GetTextReading());
}
return TextAndReading(pTextMark->GetTOXMark().GetAlternativeText(), OUString());
}
void SwTOXContent::FillText( SwTextNode& rNd, const SwIndex& rInsPos, sal_uInt16 ) const
{
const sal_Int32* pEnd = pTextMark->End();
if( pEnd && !pTextMark->GetTOXMark().IsAlternativeText() )
static_cast<const SwTextNode*>(aTOXSources[0].pNd)->GetExpandText( rNd, &rInsPos,
pTextMark->GetStart(),
*pEnd - pTextMark->GetStart() );
else
{
rNd.InsertText( GetText().sText, rInsPos );
}
}
// The level for displaying it
sal_uInt16 SwTOXContent::GetLevel() const
{
return pTextMark->GetTOXMark().GetLevel();
}
// TOX assembled from paragraphs
// Watch out for OLE/graphics when sorting!
// The position must not come from the document, but from the "anchor"!
SwTOXPara::SwTOXPara( const SwContentNode& rNd, SwTOXElement eT, sal_uInt16 nLevel, const OUString& sSeqName )
: SwTOXSortTabBase( TOX_SORT_PARA, &rNd, nullptr, nullptr ),
eType( eT ),
m_nLevel(nLevel),
nStartIndex(0),
nEndIndex(-1),
m_sSequenceName( sSeqName )
{
}
TextAndReading SwTOXPara::GetText_Impl() const
{
const SwContentNode* pNd = aTOXSources[0].pNd;
switch( eType )
{
case SwTOXElement::Sequence:
case SwTOXElement::Template:
case SwTOXElement::OutlineLevel:
{
return TextAndReading(static_cast<const SwTextNode*>(pNd)->GetExpandText(
nStartIndex,
nEndIndex == -1 ? -1 : nEndIndex - nStartIndex,
false, false, false, false),
OUString());
}
break;
case SwTOXElement::Ole:
case SwTOXElement::Graphic:
case SwTOXElement::Frame:
{
// Find the FlyFormat; the object/graphic name is there
SwFrameFormat* pFly = pNd->GetFlyFormat();
if( pFly )
return TextAndReading(pFly->GetName(), OUString());
OSL_ENSURE( false, "Graphic/object without name" );
const char* pId = SwTOXElement::Ole == eType
? STR_OBJECT_DEFNAME
: SwTOXElement::Graphic == eType
? STR_GRAPHIC_DEFNAME
: STR_FRAME_DEFNAME;
return TextAndReading(SwResId(pId), OUString());
}
break;
default: break;
}
return TextAndReading();
}
void SwTOXPara::FillText( SwTextNode& rNd, const SwIndex& rInsPos, sal_uInt16 ) const
{
if( SwTOXElement::Template == eType || SwTOXElement::Sequence == eType || SwTOXElement::OutlineLevel == eType)
{
const SwTextNode* pSrc = static_cast<const SwTextNode*>(aTOXSources[0].pNd);
pSrc->GetExpandText( rNd, &rInsPos, nStartIndex,
nEndIndex == -1 ? -1 : nEndIndex - nStartIndex,
false, false, true );
}
else
{
rNd.InsertText( GetText().sText.replace('\t', ' '), rInsPos );
}
}
sal_uInt16 SwTOXPara::GetLevel() const
{
sal_uInt16 nRet = m_nLevel;
const SwContentNode* pNd = aTOXSources[0].pNd;
if( SwTOXElement::OutlineLevel == eType && pNd->GetTextNode() )
{
const int nTmp = static_cast<const SwTextNode*>(pNd)->GetAttrOutlineLevel();
if(nTmp != 0 )
nRet = static_cast<sal_uInt16>(nTmp);
}
return nRet;
}
OUString SwTOXPara::GetURL() const
{
OUString aText;
const SwContentNode* pNd = aTOXSources[0].pNd;
switch( eType )
{
case SwTOXElement::Template:
case SwTOXElement::OutlineLevel:
{
const SwTextNode * pTextNd = pNd->GetTextNode();
SwDoc* pDoc = const_cast<SwDoc*>( pTextNd->GetDoc() );
::sw::mark::IMark const * const pMark = pDoc->getIDocumentMarkAccess()->getMarkForTextNode(
*pTextNd,
IDocumentMarkAccess::MarkType::CROSSREF_HEADING_BOOKMARK);
aText = "#" + pMark->GetName();
}
break;
case SwTOXElement::Ole:
case SwTOXElement::Graphic:
case SwTOXElement::Frame:
{
// Find the FlyFormat; the object/graphic name is there
SwFrameFormat* pFly = pNd->GetFlyFormat();
if( pFly )
{
aText = "#" + pFly->GetName() + OUStringLiteral1(cMarkSeparator);
const sal_Char* pStr;
switch( eType )
{
case SwTOXElement::Ole: pStr = "ole"; break;
case SwTOXElement::Graphic: pStr = "graphic"; break;
case SwTOXElement::Frame: pStr = "frame"; break;
default: pStr = nullptr;
}
if( pStr )
aText += OUString::createFromAscii( pStr );
}
}
break;
case SwTOXElement::Sequence:
{
aText = "#" + m_sSequenceName + OUStringLiteral1(cMarkSeparator)
+ "sequence";
}
break;
default: break;
}
return aText;
}
// Table
SwTOXTable::SwTOXTable( const SwContentNode& rNd )
: SwTOXSortTabBase( TOX_SORT_TABLE, &rNd, nullptr, nullptr ),
nLevel(FORM_ALPHA_DELIMITTER)
{
}
TextAndReading SwTOXTable::GetText_Impl() const
{
const SwNode* pNd = aTOXSources[0].pNd;
if( pNd )
{
const SwTableNode* pTableNd =
reinterpret_cast<const SwTableNode*>(pNd->FindTableNode());
if (pTableNd)
{
return TextAndReading(pTableNd->GetTable().GetFrameFormat()->GetName(), OUString());
}
}
OSL_ENSURE( false, "Where's my table?" );
return TextAndReading(SwResId( STR_TABLE_DEFNAME ), OUString());
}
sal_uInt16 SwTOXTable::GetLevel() const
{
return nLevel;
}
OUString SwTOXTable::GetURL() const
{
const SwNode* pNd = aTOXSources[0].pNd;
if (!pNd)
return OUString();
pNd = pNd->FindTableNode();
if (!pNd)
return OUString();
const OUString sName = static_cast<const SwTableNode*>(pNd)->GetTable().GetFrameFormat()->GetName();
if ( sName.isEmpty() )
return OUString();
return "#" + sName + OUStringLiteral1(cMarkSeparator) + "table";
}
SwTOXAuthority::SwTOXAuthority( const SwContentNode& rNd,
SwFormatField& rField, const SwTOXInternational& rIntl ) :
SwTOXSortTabBase( TOX_SORT_AUTHORITY, &rNd, nullptr, &rIntl ),
m_rField(rField)
{
if(rField.GetTextField())
nCntPos = rField.GetTextField()->GetStart();
}
sal_uInt16 SwTOXAuthority::GetLevel() const
{
OUString sText(static_cast<SwAuthorityField*>(m_rField.GetField())->GetFieldText(AUTH_FIELD_AUTHORITY_TYPE));
//#i18655# the level '0' is the heading level therefore the values are incremented here
sal_uInt16 nRet = 1;
if( pTOXIntl->IsNumeric( sText ) )
{
nRet = sText.toUInt32();
nRet++;
}
//illegal values are also set to 'ARTICLE' as non-numeric values are
if(nRet > AUTH_TYPE_END)
nRet = 1;
return nRet;
}
static OUString lcl_GetText(SwFormatField const& rField)
{
return rField.GetField()->ExpandField(true);
}
TextAndReading SwTOXAuthority::GetText_Impl() const
{
return TextAndReading(lcl_GetText(m_rField), OUString());
}
void SwTOXAuthority::FillText( SwTextNode& rNd,
const SwIndex& rInsPos, sal_uInt16 nAuthField ) const
{
SwAuthorityField* pField = static_cast<SwAuthorityField*>(m_rField.GetField());
OUString sText;
if(AUTH_FIELD_IDENTIFIER == nAuthField)
{
sText = lcl_GetText(m_rField);
const SwAuthorityFieldType* pType = static_cast<const SwAuthorityFieldType*>(pField->GetTyp());
sal_Unicode cChar = pType->GetPrefix();
if(cChar && cChar != ' ')
sText = sText.copy(1);
cChar = pType->GetSuffix();
if(cChar && cChar != ' ')
sText = sText.copy(0, sText.getLength() - 1);
}
else if(AUTH_FIELD_AUTHORITY_TYPE == nAuthField)
{
sal_uInt16 nLevel = GetLevel();
if(nLevel)
sText = SwAuthorityFieldType::GetAuthTypeName(static_cast<ToxAuthorityType>(--nLevel));
}
else
sText = pField->GetFieldText(static_cast<ToxAuthorityField>(nAuthField));
rNd.InsertText( sText, rInsPos );
}
bool SwTOXAuthority::operator==( const SwTOXSortTabBase& rCmp)
{
return nType == rCmp.nType &&
static_cast<SwAuthorityField*>(m_rField.GetField())->GetHandle() ==
static_cast<SwAuthorityField*>(static_cast<const SwTOXAuthority&>(rCmp).m_rField.GetField())->GetHandle();
}
bool SwTOXAuthority::operator<( const SwTOXSortTabBase& rBase)
{
bool bRet = false;
SwAuthorityField* pField = static_cast<SwAuthorityField*>(m_rField.GetField());
SwAuthorityFieldType* pType = static_cast<SwAuthorityFieldType*>(
pField->GetTyp());
if(pType->IsSortByDocument())
bRet = SwTOXSortTabBase::operator<(rBase);
else
{
SwAuthorityField* pCmpField =
static_cast<SwAuthorityField*>(static_cast<const SwTOXAuthority&>(rBase).m_rField.GetField());
for(sal_uInt16 i = 0; i < pType->GetSortKeyCount(); i++)
{
const SwTOXSortKey* pKey = pType->GetSortKey(i);
const TextAndReading aMy(pField->GetFieldText(pKey->eField), OUString());
const TextAndReading aOther(pCmpField->GetFieldText(pKey->eField), OUString());
sal_Int32 nComp = pTOXIntl->Compare( aMy, GetLocale(),
aOther, rBase.GetLocale() );
if( nComp )
{
bRet = (-1 == nComp) == pKey->bSortAscending;
break;
}
}
}
return bRet;
}
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
↑ V728 An excessive check can be simplified. The '(A && B) || (!A && !B)' expression is equivalent to the 'bool(A) == bool(B)' expression.
↑ V728 An excessive check can be simplified. The '(A && B) || (!A && !B)' expression is equivalent to the 'bool(A) == bool(B)' expression.