/************************************************************** * * 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 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. * *************************************************************/ // MARKER(update_precomp.py): autogen include statement, do not remove #include "precompiled_sw.hxx" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include extern sal_Bool IsFrameBehind( const SwTxtNode& rMyNd, xub_StrLen nMySttPos, const SwTxtNode& rBehindNd, xub_StrLen nSttPos ); using namespace ::com::sun::star; using namespace ::com::sun::star::uno; using ::rtl::OUString; /*-------------------------------------------------------------------- Beschreibung: Strings initialisieren --------------------------------------------------------------------*/ sal_uInt16 SwTOXSortTabBase::nOpt = 0; SV_IMPL_VARARR( SwTOXSources, SwTOXSource ) SwTOXInternational::SwTOXInternational( LanguageType nLang, sal_uInt16 nOpt, const String& rSortAlgorithm ) : eLang( nLang ), sSortAlgorithm(rSortAlgorithm), nOptions( nOpt ) { Init(); } SwTOXInternational::SwTOXInternational( const SwTOXInternational& rIntl ) : eLang( rIntl.eLang ), sSortAlgorithm(rIntl.sSortAlgorithm), nOptions( rIntl.nOptions ) { Init(); } void SwTOXInternational::Init() { pIndexWrapper = new IndexEntrySupplierWrapper(); const lang::Locale aLcl( SvxCreateLocale( eLang ) ); pIndexWrapper->SetLocale( aLcl ); if(!sSortAlgorithm.Len()) { Sequence < OUString > aSeq( pIndexWrapper->GetAlgorithmList( aLcl )); if(aSeq.getLength()) sSortAlgorithm = aSeq.getConstArray()[0]; } if ( nOptions & nsSwTOIOptions::TOI_CASE_SENSITIVE ) pIndexWrapper->LoadAlgorithm( aLcl, sSortAlgorithm, 0 ); else pIndexWrapper->LoadAlgorithm( aLcl, sSortAlgorithm, SW_COLLATOR_IGNORES ); pCharClass = new CharClass( aLcl ); } SwTOXInternational::~SwTOXInternational() { delete pCharClass; delete pIndexWrapper; } String SwTOXInternational::ToUpper( const String& rStr, xub_StrLen nPos ) const { return pCharClass->toUpper( rStr, nPos, 1 ); } inline sal_Bool SwTOXInternational::IsNumeric( const String& rStr ) const { return pCharClass->isNumeric( rStr ); } sal_Int32 SwTOXInternational::Compare( const String& rTxt1, const String& rTxtReading1, const lang::Locale& rLocale1, const String& rTxt2, const String& rTxtReading2, const lang::Locale& rLocale2 ) const { return pIndexWrapper->CompareIndexEntry( rTxt1, rTxtReading1, rLocale1, rTxt2, rTxtReading2, rLocale2 ); } String SwTOXInternational::GetIndexKey( const String& rTxt, const String& rTxtReading, const lang::Locale& rLocale ) const { return pIndexWrapper->GetIndexKey( rTxt, rTxtReading, rLocale ); } String SwTOXInternational::GetFollowingText( sal_Bool bMorePages ) const { return pIndexWrapper->GetFollowingText( bMorePages ); } /*-------------------------------------------------------------------- Beschreibung: SortierElement fuer Verzeichniseintraege --------------------------------------------------------------------*/ SwTOXSortTabBase::SwTOXSortTabBase( TOXSortType nTyp, const SwCntntNode* pNd, const SwTxtTOXMark* pMark, const SwTOXInternational* pInter, const lang::Locale* pLocale ) : pTOXNd( 0 ), pTxtMark( pMark ), pTOXIntl( pInter ), nPos( 0 ), nCntPos( 0 ), nType( static_cast(nTyp) ), bValidTxt( sal_False ) { if ( pLocale ) aLocale = *pLocale; if( pNd ) { xub_StrLen n = 0; if( pTxtMark ) n = *pTxtMark->GetStart(); SwTOXSource aTmp( pNd, n, pTxtMark ? pTxtMark->GetTOXMark().IsMainEntry() : sal_False ); aTOXSources.Insert( aTmp, aTOXSources.Count() ); nPos = pNd->GetIndex(); switch( nTyp ) { case TOX_SORT_CONTENT: case TOX_SORT_PARA: case TOX_SORT_TABLE: // falls sie in Sonderbereichen stehen, sollte man die // Position im Body besorgen if( nPos < pNd->GetNodes().GetEndOfExtras().GetIndex() ) { // dann die "Anker" (Body) Position holen. Point aPt; const SwCntntFrm* pFrm = pNd->getLayoutFrm( pNd->GetDoc()->GetCurrentLayout(), &aPt, 0, sal_False ); if( pFrm ) { SwPosition aPos( *pNd ); const SwDoc& rDoc = *pNd->GetDoc(); #ifdef DBG_UTIL ASSERT( GetBodyTxtNode( rDoc, aPos, *pFrm ), "wo steht der Absatz" ); #else GetBodyTxtNode( rDoc, aPos, *pFrm ); #endif nPos = aPos.nNode.GetIndex(); nCntPos = aPos.nContent.GetIndex(); } } else nCntPos = n; break; default: break; } } } String SwTOXSortTabBase::GetURL() const { return aEmptyStr; } void SwTOXSortTabBase::FillText( SwTxtNode& rNd, const SwIndex& rInsPos, sal_uInt16 ) const { String sMyTxt; String sMyTxtReading; GetTxt( sMyTxt, sMyTxtReading ); rNd.InsertText( sMyTxt, rInsPos ); } sal_Bool SwTOXSortTabBase::operator==( const SwTOXSortTabBase& rCmp ) { sal_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 && pTxtMark && rCmp.pTxtMark && *pTxtMark->GetStart() == *rCmp.pTxtMark->GetStart(); if( bRet ) { // beide Pointer vorhanden -> vergleiche Text // beide Pointer nicht vorhanden -> vergleiche AlternativText const xub_StrLen* pEnd = pTxtMark->End(); const xub_StrLen* pEndCmp = rCmp.pTxtMark->End(); String sMyTxt; String sMyTxtReading; GetTxt( sMyTxt, sMyTxtReading ); String sOtherTxt; String sOtherTxtReading; rCmp.GetTxt( sOtherTxt, sOtherTxtReading ); bRet = ( ( pEnd && pEndCmp ) || ( !pEnd && !pEndCmp ) ) && pTOXIntl->IsEqual( sMyTxt, sMyTxtReading, GetLocale(), sOtherTxt, sOtherTxtReading, rCmp.GetLocale() ); } } return bRet; } sal_Bool SwTOXSortTabBase::operator<( const SwTOXSortTabBase& rCmp ) { if( nPos < rCmp.nPos ) return sal_True; if( nPos == rCmp.nPos ) { if( nCntPos < rCmp.nCntPos ) return sal_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 && pTxtMark && rCmp.pTxtMark ) { if( *pTxtMark->GetStart() < *rCmp.pTxtMark->GetStart() ) return sal_True; if( *pTxtMark->GetStart() == *rCmp.pTxtMark->GetStart() ) { const xub_StrLen* pEnd = pTxtMark->End(); const xub_StrLen* pEndCmp = rCmp.pTxtMark->End(); String sMyTxt; String sMyTxtReading; GetTxt( sMyTxt, sMyTxtReading ); String sOtherTxt; String sOtherTxtReading; rCmp.GetTxt( sOtherTxt, sOtherTxtReading ); // beide Pointer vorhanden -> vergleiche Text // beide Pointer nicht vorhanden -> vergleiche AlternativText if( ( pEnd && pEndCmp ) || ( !pEnd && !pEndCmp ) ) pTOXIntl->IsEqual( sMyTxt, sMyTxtReading, GetLocale(), sOtherTxt, sOtherTxtReading, rCmp.GetLocale() ); if( pEnd && !pEndCmp ) return sal_True; } } } else if( pFirst && pFirst->IsTxtNode() && pNext && pNext->IsTxtNode() ) return ::IsFrameBehind( *(SwTxtNode*)pNext, nCntPos, *(SwTxtNode*)pFirst, nCntPos ); } } return sal_False; } /*-------------------------------------------------------------------- Beschreibung: sortierter Stichworteintrag --------------------------------------------------------------------*/ SwTOXIndex::SwTOXIndex( const SwTxtNode& rNd, const SwTxtTOXMark* pMark, sal_uInt16 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; } // // Stichworte vergleichen. Bezieht sich nur auf den Text // sal_Bool SwTOXIndex::operator==( const SwTOXSortTabBase& rCmpBase ) { SwTOXIndex& rCmp = (SwTOXIndex&)rCmpBase; // In Abhaengigkeit von den Optionen Grosskleinschreibung beachten if(GetLevel() != rCmp.GetLevel() || nKeyLevel != rCmp.nKeyLevel) return sal_False; ASSERT(pTxtMark, "pTxtMark == 0, Kein Stichwort"); String sMyTxt; String sMyTxtReading; GetTxt( sMyTxt, sMyTxtReading ); String sOtherTxt; String sOtherTxtReading; rCmp.GetTxt( sOtherTxt, sOtherTxtReading ); sal_Bool bRet = pTOXIntl->IsEqual( sMyTxt, sMyTxtReading, GetLocale(), sOtherTxt, sOtherTxtReading, rCmp.GetLocale() ); // Wenn nicht zusammengefasst wird muss die Pos aus gewertet werden if(bRet && !(GetOptions() & nsSwTOIOptions::TOI_SAME_ENTRY)) bRet = nPos == rCmp.nPos; return bRet; } // // kleiner haengt nur vom Text ab // sal_Bool SwTOXIndex::operator<( const SwTOXSortTabBase& rCmpBase ) { SwTOXIndex& rCmp = (SwTOXIndex&)rCmpBase; ASSERT(pTxtMark, "pTxtMark == 0, Kein Stichwort"); String sMyTxt; String sMyTxtReading; GetTxt( sMyTxt, sMyTxtReading ); String sOtherTxt; String sOtherTxtReading; rCmp.GetTxt( sOtherTxt, sOtherTxtReading ); sal_Bool bRet = GetLevel() == rCmp.GetLevel() && pTOXIntl->IsLess( sMyTxt, sMyTxtReading, GetLocale(), sOtherTxt, sOtherTxtReading, rCmp.GetLocale() ); // Wenn nicht zusammengefasst wird muss die Pos aus gewertet werden if( !bRet && !(GetOptions() & nsSwTOIOptions::TOI_SAME_ENTRY) ) { bRet = pTOXIntl->IsEqual( sMyTxt, sMyTxtReading, GetLocale(), sOtherTxt, sOtherTxtReading, rCmp.GetLocale() ) && nPos < rCmp.nPos; } return bRet; } // // Das Stichwort selbst // void SwTOXIndex::GetText_Impl( String& rTxt, String& rTxtReading ) const { ASSERT(pTxtMark, "pTxtMark == 0, Kein Stichwort"); const SwTOXMark& rTOXMark = pTxtMark->GetTOXMark(); switch(nKeyLevel) { case FORM_PRIMARY_KEY : { rTxt = rTOXMark.GetPrimaryKey(); rTxtReading = rTOXMark.GetPrimaryKeyReading(); } break; case FORM_SECONDARY_KEY : { rTxt = rTOXMark.GetSecondaryKey(); rTxtReading = rTOXMark.GetSecondaryKeyReading(); } break; case FORM_ENTRY : { rTxt = rTOXMark.GetText(); rTxtReading = rTOXMark.GetTextReading(); } break; } // if TOI_INITIAL_CAPS is set, first character is to be capitalized if( nsSwTOIOptions::TOI_INITIAL_CAPS & nOpt && pTOXIntl ) { String sUpper( pTOXIntl->ToUpper( rTxt, 0 )); rTxt.Erase( 0, 1 ).Insert( sUpper, 0 ); } } void SwTOXIndex::FillText( SwTxtNode& rNd, const SwIndex& rInsPos, sal_uInt16 ) const { const xub_StrLen* pEnd = pTxtMark->End(); String sTmp; String sTmpReading; if( pEnd && !pTxtMark->GetTOXMark().IsAlternativeText() && 0 == (GetOptions() & nsSwTOIOptions::TOI_KEY_AS_ENTRY)) { sTmp = ((SwTxtNode*)aTOXSources[0].pNd)->GetExpandTxt( *pTxtMark->GetStart(), *pEnd - *pTxtMark->GetStart()); if(nsSwTOIOptions::TOI_INITIAL_CAPS&nOpt && pTOXIntl) { String sUpper( pTOXIntl->ToUpper( sTmp, 0 )); sTmp.Erase( 0, 1 ).Insert( sUpper, 0 ); } } else GetTxt( sTmp, sTmpReading ); rNd.InsertText( sTmp, rInsPos ); } sal_uInt16 SwTOXIndex::GetLevel() const { ASSERT(pTxtMark, "pTxtMark == 0, Kein Stichwort"); sal_uInt16 nForm = FORM_PRIMARY_KEY; if( 0 == (GetOptions() & nsSwTOIOptions::TOI_KEY_AS_ENTRY)&& pTxtMark->GetTOXMark().GetPrimaryKey().Len() ) { nForm = FORM_SECONDARY_KEY; if( pTxtMark->GetTOXMark().GetSecondaryKey().Len() ) nForm = FORM_ENTRY; } return nForm; } /*-------------------------------------------------------------------- Beschreibung: Schluessel und Trennzeichen --------------------------------------------------------------------*/ SwTOXCustom::SwTOXCustom(const String& rStr, const String& rReading, sal_uInt16 nLevel, const SwTOXInternational& rIntl, const lang::Locale& rLocale ) : SwTOXSortTabBase( TOX_SORT_CUSTOM, 0, 0, &rIntl, &rLocale ), aKey(rStr), sReading(rReading), nLev(nLevel) { } sal_Bool SwTOXCustom::operator==(const SwTOXSortTabBase& rCmpBase) { String sMyTxt; String sMyTxtReading; GetTxt( sMyTxt, sMyTxtReading ); String sOtherTxt; String sOtherTxtReading; rCmpBase.GetTxt( sOtherTxt, sOtherTxtReading ); return GetLevel() == rCmpBase.GetLevel() && pTOXIntl->IsEqual( sMyTxt, sMyTxtReading, GetLocale(), sOtherTxt, sOtherTxtReading, rCmpBase.GetLocale() ); } sal_Bool SwTOXCustom::operator < (const SwTOXSortTabBase& rCmpBase) { String sMyTxt; String sMyTxtReading; GetTxt( sMyTxt, sMyTxtReading ); String sOtherTxt; String sOtherTxtReading; rCmpBase.GetTxt( sOtherTxt, sOtherTxtReading ); return GetLevel() <= rCmpBase.GetLevel() && pTOXIntl->IsLess( sMyTxt, sMyTxtReading, GetLocale(), sOtherTxt, sOtherTxtReading, rCmpBase.GetLocale() ); } sal_uInt16 SwTOXCustom::GetLevel() const { return nLev; } void SwTOXCustom::GetText_Impl( String& rTxt, String &rTxtReading ) const { rTxt = aKey; rTxtReading = sReading; /// !!!!!!!!!!!!!! } /*-------------------------------------------------------------------- Beschreibung: sortierter Inhaltsverz. Eintrag --------------------------------------------------------------------*/ SwTOXContent::SwTOXContent( const SwTxtNode& rNd, const SwTxtTOXMark* pMark, const SwTOXInternational& rIntl) : SwTOXSortTabBase( TOX_SORT_CONTENT, &rNd, pMark, &rIntl ) { } // Der Text des Inhalts // void SwTOXContent::GetText_Impl( String& rTxt, String& rTxtReading ) const { const xub_StrLen* pEnd = pTxtMark->End(); if( pEnd && !pTxtMark->GetTOXMark().IsAlternativeText() ) { rTxt = ((SwTxtNode*)aTOXSources[0].pNd)->GetExpandTxt( *pTxtMark->GetStart(), *pEnd - *pTxtMark->GetStart() ); rTxtReading = pTxtMark->GetTOXMark().GetTextReading(); } else rTxt = pTxtMark->GetTOXMark().GetAlternativeText(); } void SwTOXContent::FillText( SwTxtNode& rNd, const SwIndex& rInsPos, sal_uInt16 ) const { const xub_StrLen* pEnd = pTxtMark->End(); if( pEnd && !pTxtMark->GetTOXMark().IsAlternativeText() ) ((SwTxtNode*)aTOXSources[0].pNd)->GetExpandTxt( rNd, &rInsPos, *pTxtMark->GetStart(), *pEnd - *pTxtMark->GetStart() ); else { String sTmp, sTmpReading; GetTxt( sTmp, sTmpReading ); rNd.InsertText( sTmp, rInsPos ); } } // // Die Ebene fuer Anzeige // sal_uInt16 SwTOXContent::GetLevel() const { return pTxtMark->GetTOXMark().GetLevel(); } /*-------------------------------------------------------------------- Beschreibung: Verzeichnis aus Absaetzen zusammengesammelt --------------------------------------------------------------------*/ // bei Sortierung von OLE/Grafiken aufpassen !!! // Die Position darf nicht die im Dokument, // sondern muss die vom "Henkel" sein !! SwTOXPara::SwTOXPara( const SwCntntNode& rNd, SwTOXElement eT, sal_uInt16 nLevel ) : SwTOXSortTabBase( TOX_SORT_PARA, &rNd, 0, 0 ), eType( eT ), m_nLevel(nLevel), nStartIndex(0), nEndIndex(STRING_LEN) { } void SwTOXPara::GetText_Impl( String& rTxt, String& ) const { const SwCntntNode* pNd = aTOXSources[0].pNd; switch( eType ) { case nsSwTOXElement::TOX_SEQUENCE: case nsSwTOXElement::TOX_TEMPLATE: case nsSwTOXElement::TOX_OUTLINELEVEL: { xub_StrLen nStt = nStartIndex; /* JP 22.01.98: Tabs ueberspringen - macht aber keinen Sinn, solange in der TOX-Form nicht die KapitelNummer eingestellt werden kann const String& rTmp = ((SwTxtNode*)pNd)->GetTxt(); while( '\t' == rTmp.GetChar( nStt ) && nStt < rTmp.Len() ) ++nStt; */ rTxt = ((SwTxtNode*)pNd)->GetExpandTxt( nStt, STRING_NOTFOUND == nEndIndex ? STRING_LEN : nEndIndex - nStt); } break; case nsSwTOXElement::TOX_OLE: case nsSwTOXElement::TOX_GRAPHIC: case nsSwTOXElement::TOX_FRAME: { // suche das FlyFormat, dort steht der Object/Grafik-Name SwFrmFmt* pFly = pNd->GetFlyFmt(); if( pFly ) rTxt = pFly->GetName(); else { ASSERT( !this, "Grafik/Object ohne Namen" ) sal_uInt16 nId = nsSwTOXElement::TOX_OLE == eType ? STR_OBJECT_DEFNAME : nsSwTOXElement::TOX_GRAPHIC == eType ? STR_GRAPHIC_DEFNAME : STR_FRAME_DEFNAME; rTxt = SW_RESSTR( nId ); } } break; default: break; } } void SwTOXPara::FillText( SwTxtNode& rNd, const SwIndex& rInsPos, sal_uInt16 ) const { if( nsSwTOXElement::TOX_TEMPLATE == eType || nsSwTOXElement::TOX_SEQUENCE == eType || nsSwTOXElement::TOX_OUTLINELEVEL == eType) { SwTxtNode* pSrc = (SwTxtNode*)aTOXSources[0].pNd; xub_StrLen nStt = nStartIndex; /* JP 22.01.98: Tabs ueberspringen - macht aber keinen Sinn, solange in der TOX-Form nicht die KapitelNummer eingestellt werden kann const String& rTxt = pSrc->GetTxt(); while( '\t' == rTxt.GetChar( nStt ) && nStt < rTxt.Len() ) ++nStt; */ pSrc->GetExpandTxt( rNd, &rInsPos, nStt, nEndIndex == STRING_LEN ? STRING_LEN : nEndIndex - nStt, sal_False, sal_False, sal_True ); } else { String sTmp, sTmpReading; GetTxt( sTmp, sTmpReading ); sTmp.SearchAndReplaceAll('\t', ' '); rNd.InsertText( sTmp, rInsPos ); } } sal_uInt16 SwTOXPara::GetLevel() const { sal_uInt16 nRet = m_nLevel; const SwCntntNode* pNd = aTOXSources[0].pNd; if( nsSwTOXElement::TOX_OUTLINELEVEL == eType && pNd->GetTxtNode() ) { //sal_uInt16 nTmp = ((SwTxtNode*)pNd)->GetTxtColl()->GetOutlineLevel();//#outline level,zhaojianwei //if(nTmp < NO_NUMBERING) // nRet = nTmp + 1; const int nTmp = ((SwTxtNode*)pNd)->GetAttrOutlineLevel();//#outline level,zhaojianwei???? if(nTmp != 0 ) nRet = static_cast(nTmp); } return nRet; } String SwTOXPara::GetURL() const { String aTxt; const SwCntntNode* pNd = aTOXSources[0].pNd; switch( eType ) { case nsSwTOXElement::TOX_TEMPLATE: case nsSwTOXElement::TOX_OUTLINELEVEL: { const SwTxtNode * pTxtNd = static_cast(pNd); // --> OD 2009-08-05 #i103265# // //if( MAXLEVEL >= pTxtNd->GetTxtColl()->GetOutlineLevel()) //#outline level,zhaojianwei // if ( pTxtNd->GetAttrOutlineLevel() > 0) //<-end,zhaojianwei // { // aTxt = '#'; // const SwNumRule * pRule = pTxtNd->GetNumRule(); // if( pRule ) // { // // dann noch die rel. Nummer davor setzen // const sal_uInt16 nCurrLevel = static_cast(pTxtNd->GetActualListLevel()); // if(nCurrLevel <= MAXLEVEL) // { // // --> OD 2005-11-02 #i51089 - TUNING# // if ( pTxtNd->GetNum() ) // { // SwNumberTree::tNumberVector aNumVector = // pTxtNd->GetNumberVector(); // for( sal_uInt16 n = 0; n <= nCurrLevel; ++n ) // { // int nNum = aNumVector[ n ]; // nNum -= ( pRule->Get( n ).GetStart() - 1 ); // ( aTxt += String::CreateFromInt32( nNum )) += '.'; // } // } // else // { // ASSERT( false, // " - text node with numbering rule, but without number. This is a serious defect -> inform OD" ); // } // } // } // aTxt += pTxtNd->GetExpandTxt(); // ( aTxt += cMarkSeperator ).AppendAscii( pMarkToOutline ); // } SwDoc* pDoc = const_cast( pTxtNd->GetDoc() ); ::sw::mark::IMark const * const pMark = pDoc->getIDocumentMarkAccess()->getMarkForTxtNode( *(pTxtNd), IDocumentMarkAccess::CROSSREF_HEADING_BOOKMARK); aTxt = '#'; const String aMarkName( pMark->GetName() ); aTxt += aMarkName; // <-- } break; case nsSwTOXElement::TOX_OLE: case nsSwTOXElement::TOX_GRAPHIC: case nsSwTOXElement::TOX_FRAME: { // suche das FlyFormat, dort steht der Object/Grafik-Name SwFrmFmt* pFly = pNd->GetFlyFmt(); if( pFly ) { (( aTxt = '#' ) += pFly->GetName() ) += cMarkSeperator; const sal_Char* pStr; switch( eType ) { case nsSwTOXElement::TOX_OLE: pStr = pMarkToOLE; break; case nsSwTOXElement::TOX_GRAPHIC: pStr = pMarkToGraphic; break; case nsSwTOXElement::TOX_FRAME: pStr = pMarkToFrame; break; default: pStr = 0; } if( pStr ) aTxt.AppendAscii( pStr ); } } break; default: break; } return aTxt; } /*-------------------------------------------------------------------- Beschreibung: Tabelle --------------------------------------------------------------------*/ SwTOXTable::SwTOXTable( const SwCntntNode& rNd ) : SwTOXSortTabBase( TOX_SORT_TABLE, &rNd, 0, 0 ), nLevel(FORM_ALPHA_DELIMITTER) { } void SwTOXTable::GetText_Impl( String& rTxt, String& ) const { const SwNode* pNd = aTOXSources[0].pNd; if( pNd && 0 != ( pNd = pNd->FindTableNode() ) ) { rTxt = ((SwTableNode*)pNd)->GetTable().GetFrmFmt()->GetName(); } else { ASSERT( !this, "Wo ist meine Tabelle geblieben?" ) rTxt = SW_RESSTR( STR_TABLE_DEFNAME ); } } sal_uInt16 SwTOXTable::GetLevel() const { return nLevel; } String SwTOXTable::GetURL() const { String aTxt; const SwNode* pNd = aTOXSources[0].pNd; if( pNd && 0 != ( pNd = pNd->FindTableNode() ) ) { aTxt = ((SwTableNode*)pNd)->GetTable().GetFrmFmt()->GetName(); if( aTxt.Len() ) { ( aTxt.Insert( '#', 0 ) += cMarkSeperator ). AppendAscii( pMarkToTable ); } } return aTxt; } /*-- 15.09.99 14:28:08--------------------------------------------------- -----------------------------------------------------------------------*/ SwTOXAuthority::SwTOXAuthority( const SwCntntNode& rNd, SwFmtFld& rField, const SwTOXInternational& rIntl ) : SwTOXSortTabBase( TOX_SORT_AUTHORITY, &rNd, 0, &rIntl ), m_rField(rField) { if(rField.GetTxtFld()) nCntPos = *rField.GetTxtFld()->GetStart(); } sal_uInt16 SwTOXAuthority::GetLevel() const { String sText(((SwAuthorityField*)m_rField.GetField())->GetFieldText(AUTH_FIELD_AUTHORITY_TYPE)); //#i18655# the level '0' is the heading level therefor the values are incremented here sal_uInt16 nRet = 1; if( pTOXIntl->IsNumeric( sText ) ) { nRet = (sal_uInt16)sText.ToInt32(); nRet++; } //illegal values are also set to 'ARTICLE' as non-numeric values are if(nRet > AUTH_TYPE_END) nRet = 1; return nRet; } /*-- 15.09.99 14:28:08--------------------------------------------------- -----------------------------------------------------------------------*/ static String lcl_GetText(SwFmtFld const& rField) { return rField.GetField()->ExpandField(true); } void SwTOXAuthority::GetText_Impl( String& rTxt, String& ) const { rTxt = lcl_GetText(m_rField); } /* -----------------21.09.99 12:50------------------- --------------------------------------------------*/ void SwTOXAuthority::FillText( SwTxtNode& rNd, const SwIndex& rInsPos, sal_uInt16 nAuthField ) const { SwAuthorityField* pField = (SwAuthorityField*)m_rField.GetField(); String sText; if(AUTH_FIELD_IDENTIFIER == nAuthField) { sText = lcl_GetText(m_rField); const SwAuthorityFieldType* pType = (const SwAuthorityFieldType*)pField->GetTyp(); sal_Unicode cChar = pType->GetPrefix(); if(cChar && cChar != ' ') sText.Erase(0, 1); cChar = pType->GetSuffix(); if(cChar && cChar != ' ') sText.Erase(sText.Len() - 1, 1); } else if(AUTH_FIELD_AUTHORITY_TYPE == nAuthField) { sal_uInt16 nLevel = GetLevel(); if(nLevel) sText = SwAuthorityFieldType::GetAuthTypeName((ToxAuthorityType) --nLevel); } else sText = (pField->GetFieldText((ToxAuthorityField) nAuthField)); rNd.InsertText( sText, rInsPos ); } /* -----------------14.10.99 09:35------------------- --------------------------------------------------*/ sal_Bool SwTOXAuthority::operator==( const SwTOXSortTabBase& rCmp) { return nType == rCmp.nType && ((SwAuthorityField*)m_rField.GetField())->GetHandle() == ((SwAuthorityField*)((SwTOXAuthority&)rCmp).m_rField.GetField())->GetHandle(); } /* -----------------21.10.99 09:52------------------- --------------------------------------------------*/ sal_Bool SwTOXAuthority::operator<( const SwTOXSortTabBase& rBase) { sal_Bool bRet = sal_False; SwAuthorityField* pField = (SwAuthorityField*)m_rField.GetField(); SwAuthorityFieldType* pType = (SwAuthorityFieldType*) pField->GetTyp(); if(pType->IsSortByDocument()) bRet = SwTOXSortTabBase::operator<(rBase); else { SwAuthorityField* pCmpField = (SwAuthorityField*)((SwTOXAuthority&)rBase).m_rField.GetField(); for(sal_uInt16 i = 0; i < pType->GetSortKeyCount(); i++) { const SwTOXSortKey* pKey = pType->GetSortKey(i); String sMyTxt = pField->GetFieldText(pKey->eField); String sMyTxtReading; String sOtherTxt = pCmpField->GetFieldText(pKey->eField); String sOtherTxtReading; sal_Int32 nComp = pTOXIntl->Compare( sMyTxt, sMyTxtReading, GetLocale(), sOtherTxt, sOtherTxtReading, rBase.GetLocale() ); if( nComp ) { bRet = (-1 == nComp) == pKey->bSortAscending; break; } } } return bRet; }