1 /**************************************************************
2 *
3 * Licensed to the Apache Software Foundation (ASF) under one
4 * or more contributor license agreements. See the NOTICE file
5 * distributed with this work for additional information
6 * regarding copyright ownership. The ASF licenses this file
7 * to you under the Apache License, Version 2.0 (the
8 * "License"); you may not use this file except in compliance
9 * with the License. You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing,
14 * software distributed under the License is distributed on an
15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16 * KIND, either express or implied. See the License for the
17 * specific language governing permissions and limitations
18 * under the License.
19 *
20 *************************************************************/
21
22
23
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_sw.hxx"
26
27
28 #include <limits.h>
29 #include <hintids.hxx>
30
31 #define _SVSTDARR_STRINGSSORT
32 #include <svl/svstdarr.hxx>
33 #include <editeng/langitem.hxx>
34 #include <editeng/brkitem.hxx>
35 #include <editeng/tstpitem.hxx>
36 #include <editeng/lrspitem.hxx>
37 #include <sot/clsids.hxx>
38 #include <docsh.hxx>
39 #include <ndole.hxx>
40 #include <txttxmrk.hxx>
41 #include <fmtinfmt.hxx>
42 #include <fmtpdsc.hxx>
43 #include <frmfmt.hxx>
44 #include <fmtfsize.hxx>
45 #include <frmatr.hxx>
46 #include <pagedesc.hxx>
47 #include <doc.hxx>
48 #include <IDocumentUndoRedo.hxx>
49 #include <pagefrm.hxx>
50 #include <ndtxt.hxx>
51 #include <swtable.hxx>
52 #include <doctxm.hxx>
53 #include <txmsrt.hxx>
54 #include <rolbck.hxx>
55 #include <poolfmt.hxx>
56 #include <txtfrm.hxx>
57 #include <rootfrm.hxx>
58 #include <UndoAttribute.hxx>
59 #include <swundo.hxx>
60 #include <mdiexp.hxx>
61 #include <docary.hxx>
62 #include <charfmt.hxx>
63 #include <fchrfmt.hxx>
64 #include <fldbas.hxx>
65 #include <fmtfld.hxx>
66 #include <txtfld.hxx>
67 #include <expfld.hxx>
68 #include <chpfld.hxx>
69 #include <mvsave.hxx>
70 #include <node2lay.hxx>
71 #include <SwStyleNameMapper.hxx>
72 #include <breakit.hxx>
73 #include <editsh.hxx>
74 #include <scriptinfo.hxx>
75 #include <switerator.hxx>
76
77 using namespace ::com::sun::star;
78
79 const sal_Unicode cNumRepl = '@';
80 const sal_Unicode cEndPageNum = '~';
81 const sal_Char __FAR_DATA sPageDeli[] = ", ";
82
83 SV_IMPL_PTRARR(SwTOXSortTabBases, SwTOXSortTabBasePtr)
84
85 TYPEINIT2( SwTOXBaseSection, SwTOXBase, SwSection ); // fuers RTTI
86
87 struct LinkStruct
88 {
89 SwFmtINetFmt aINetFmt;
90 xub_StrLen nStartTextPos, nEndTextPos;
91
LinkStructLinkStruct92 LinkStruct( const String& rURL, xub_StrLen nStart, xub_StrLen nEnd )
93 : aINetFmt( rURL, aEmptyStr),
94 nStartTextPos( nStart),
95 nEndTextPos(nEnd) {}
96 };
97
98 typedef LinkStruct* LinkStructPtr;
99 SV_DECL_PTRARR(LinkStructArr, LinkStructPtr, 0, 5 )
SV_IMPL_PTRARR(LinkStructArr,LinkStructPtr)100 SV_IMPL_PTRARR(LinkStructArr, LinkStructPtr)
101
102 sal_uInt16 SwDoc::GetTOIKeys( SwTOIKeyType eTyp, SvStringsSort& rArr ) const
103 {
104 if( rArr.Count() )
105 rArr.Remove( sal_uInt16(0), rArr.Count() );
106
107 // dann mal ueber den Pool und alle Primary oder Secondary heraussuchen
108 const SwTxtTOXMark* pMark;
109 const SfxPoolItem* pItem;
110 const SwTOXType* pTOXType;
111 sal_uInt32 i, nMaxItems = GetAttrPool().GetItemCount2( RES_TXTATR_TOXMARK );
112 for( i = 0; i < nMaxItems; ++i )
113 if( 0 != (pItem = GetAttrPool().GetItem2( RES_TXTATR_TOXMARK, i ) ) &&
114 0!= ( pTOXType = ((SwTOXMark*)pItem)->GetTOXType()) &&
115 TOX_INDEX == pTOXType->GetType() &&
116 0 != ( pMark = ((SwTOXMark*)pItem)->GetTxtTOXMark() ) &&
117 pMark->GetpTxtNd() &&
118 pMark->GetpTxtNd()->GetNodes().IsDocNodes() )
119 {
120 const String* pStr;
121 if( TOI_PRIMARY == eTyp )
122 pStr = &((SwTOXMark*)pItem)->GetPrimaryKey();
123 else
124 pStr = &((SwTOXMark*)pItem)->GetSecondaryKey();
125
126 if( pStr->Len() )
127 rArr.Insert( (StringPtr)pStr );
128 }
129
130 return rArr.Count();
131 }
132
133 /*--------------------------------------------------------------------
134 Beschreibung: aktuelle Verzeichnismarkierungen ermitteln
135 --------------------------------------------------------------------*/
136
137
GetCurTOXMark(const SwPosition & rPos,SwTOXMarks & rArr) const138 sal_uInt16 SwDoc::GetCurTOXMark( const SwPosition& rPos,
139 SwTOXMarks& rArr ) const
140 {
141 // search on Position rPos for all SwTOXMarks
142 SwTxtNode *const pTxtNd = rPos.nNode.GetNode().GetTxtNode();
143 if( !pTxtNd || !pTxtNd->GetpSwpHints() )
144 return 0;
145
146 const SwpHints & rHts = *pTxtNd->GetpSwpHints();
147 const SwTxtAttr* pHt;
148 xub_StrLen nSttIdx;
149 const xub_StrLen *pEndIdx;
150
151 xub_StrLen nAktPos = rPos.nContent.GetIndex();
152
153 for( sal_uInt16 n = 0; n < rHts.Count(); ++n )
154 {
155 if( RES_TXTATR_TOXMARK != (pHt = rHts[n])->Which() )
156 continue;
157 if( ( nSttIdx = *pHt->GetStart() ) < nAktPos )
158 {
159 // pruefe Ende mit ab
160 if( 0 == ( pEndIdx = pHt->End() ) ||
161 *pEndIdx <= nAktPos )
162 continue; // weiter suchen
163 }
164 else if( nSttIdx > nAktPos )
165 // ist Start vom Hint groesser als rPos, dann abbrechen. Denn
166 // die Attribute sind nach Start sortiert !
167 break;
168
169 const SwTOXMark* pTMark = &pHt->GetTOXMark();
170 rArr.Insert( pTMark, rArr.Count() );
171 }
172 return rArr.Count();
173 }
174
175 /*--------------------------------------------------------------------
176 Beschreibung: Marke loeschen
177 --------------------------------------------------------------------*/
178
DeleteTOXMark(const SwTOXMark * pTOXMark)179 void SwDoc::DeleteTOXMark( const SwTOXMark* pTOXMark )
180 {
181 // hole den TextNode und
182 const SwTxtTOXMark* pTxtTOXMark = pTOXMark->GetTxtTOXMark();
183 ASSERT( pTxtTOXMark, "Kein TxtTOXMark, kann nicht geloescht werden" );
184
185 SwTxtNode& rTxtNd = const_cast<SwTxtNode&>(pTxtTOXMark->GetTxtNode());
186 ASSERT( rTxtNd.GetpSwpHints(), "kann nicht geloescht werden" );
187
188 if (GetIDocumentUndoRedo().DoesUndo())
189 {
190 // save attributes for Undo
191 SwUndoResetAttr* pUndo = new SwUndoResetAttr(
192 SwPosition( rTxtNd, SwIndex( &rTxtNd, *pTxtTOXMark->GetStart() ) ),
193 RES_TXTATR_TOXMARK );
194 GetIDocumentUndoRedo().AppendUndo( pUndo );
195
196 SwRegHistory aRHst( rTxtNd, &pUndo->GetHistory() );
197 rTxtNd.GetpSwpHints()->Register( &aRHst );
198 }
199
200 rTxtNd.DeleteAttribute( const_cast<SwTxtTOXMark*>(pTxtTOXMark) );
201
202 if (GetIDocumentUndoRedo().DoesUndo())
203 {
204 if( rTxtNd.GetpSwpHints() )
205 rTxtNd.GetpSwpHints()->DeRegister();
206 }
207 SetModified();
208 }
209
210 /*--------------------------------------------------------------------
211 Beschreibung: Traveln zwischen TOXMarks
212 --------------------------------------------------------------------*/
213
214 class CompareNodeCntnt
215 {
216 sal_uLong nNode;
217 xub_StrLen nCntnt;
218 public:
CompareNodeCntnt(sal_uLong nNd,xub_StrLen nCnt)219 CompareNodeCntnt( sal_uLong nNd, xub_StrLen nCnt )
220 : nNode( nNd ), nCntnt( nCnt ) {}
221
operator ==(const CompareNodeCntnt & rCmp)222 int operator==( const CompareNodeCntnt& rCmp )
223 { return nNode == rCmp.nNode && nCntnt == rCmp.nCntnt; }
operator !=(const CompareNodeCntnt & rCmp)224 int operator!=( const CompareNodeCntnt& rCmp )
225 { return nNode != rCmp.nNode || nCntnt != rCmp.nCntnt; }
operator <(const CompareNodeCntnt & rCmp)226 int operator< ( const CompareNodeCntnt& rCmp )
227 { return nNode < rCmp.nNode ||
228 ( nNode == rCmp.nNode && nCntnt < rCmp.nCntnt); }
operator <=(const CompareNodeCntnt & rCmp)229 int operator<=( const CompareNodeCntnt& rCmp )
230 { return nNode < rCmp.nNode ||
231 ( nNode == rCmp.nNode && nCntnt <= rCmp.nCntnt); }
operator >(const CompareNodeCntnt & rCmp)232 int operator> ( const CompareNodeCntnt& rCmp )
233 { return nNode > rCmp.nNode ||
234 ( nNode == rCmp.nNode && nCntnt > rCmp.nCntnt); }
operator >=(const CompareNodeCntnt & rCmp)235 int operator>=( const CompareNodeCntnt& rCmp )
236 { return nNode > rCmp.nNode ||
237 ( nNode == rCmp.nNode && nCntnt >= rCmp.nCntnt); }
238 };
239
GotoTOXMark(const SwTOXMark & rCurTOXMark,SwTOXSearch eDir,sal_Bool bInReadOnly)240 const SwTOXMark& SwDoc::GotoTOXMark( const SwTOXMark& rCurTOXMark,
241 SwTOXSearch eDir, sal_Bool bInReadOnly )
242 {
243 const SwTxtTOXMark* pMark = rCurTOXMark.GetTxtTOXMark();
244 ASSERT(pMark, "pMark==0 Ungueltige TxtTOXMark");
245
246 const SwTxtNode *pTOXSrc = pMark->GetpTxtNd();
247
248 CompareNodeCntnt aAbsIdx( pTOXSrc->GetIndex(), *pMark->GetStart() );
249 CompareNodeCntnt aPrevPos( 0, 0 );
250 CompareNodeCntnt aNextPos( ULONG_MAX, STRING_NOTFOUND );
251 CompareNodeCntnt aMax( 0, 0 );
252 CompareNodeCntnt aMin( ULONG_MAX, STRING_NOTFOUND );
253
254 const SwTOXMark* pNew = 0;
255 const SwTOXMark* pMax = &rCurTOXMark;
256 const SwTOXMark* pMin = &rCurTOXMark;
257
258 const SwTOXType* pType = rCurTOXMark.GetTOXType();
259 SwTOXMarks aMarks;
260 SwTOXMark::InsertTOXMarks( aMarks, *pType );
261
262 const SwTOXMark* pTOXMark;
263 const SwCntntFrm* pCFrm;
264 Point aPt;
265 for( sal_uInt16 nMark=0; nMark<aMarks.Count(); nMark++ )
266 {
267 pTOXMark = aMarks[nMark];
268 if( pTOXMark != &rCurTOXMark &&
269 0 != ( pMark = pTOXMark->GetTxtTOXMark()) &&
270 0 != ( pTOXSrc = pMark->GetpTxtNd() ) &&
271 0 != ( pCFrm = pTOXSrc->getLayoutFrm( GetCurrentLayout(), &aPt, 0, sal_False )) &&
272 ( bInReadOnly || !pCFrm->IsProtected() ))
273 {
274 CompareNodeCntnt aAbsNew( pTOXSrc->GetIndex(), *pMark->GetStart() );
275 switch( eDir )
276 {
277 //Die untenstehenden etwas komplizierter ausgefallen Ausdruecke
278 //dienen dazu auch ueber Eintraege auf der selben (!) Position
279 //traveln zu koennen. Wenn einer Zeit hat mag er sie mal
280 //optimieren.
281
282 case TOX_SAME_PRV:
283 if( pTOXMark->GetText() != rCurTOXMark.GetText() )
284 break;
285 /* no break here */
286 case TOX_PRV:
287 if ( (aAbsNew < aAbsIdx && aAbsNew > aPrevPos &&
288 aPrevPos != aAbsIdx && aAbsNew != aAbsIdx ) ||
289 (aAbsIdx == aAbsNew &&
290 (sal_uLong(&rCurTOXMark) > sal_uLong(pTOXMark) &&
291 (!pNew ||
292 (pNew && (aPrevPos < aAbsIdx ||
293 sal_uLong(pNew) < sal_uLong(pTOXMark)))))) ||
294 (aPrevPos == aAbsNew && aAbsIdx != aAbsNew &&
295 sal_uLong(pTOXMark) > sal_uLong(pNew)) )
296 {
297 pNew = pTOXMark;
298 aPrevPos = aAbsNew;
299 if ( aAbsNew >= aMax )
300 {
301 aMax = aAbsNew;
302 pMax = pTOXMark;
303 }
304 }
305 break;
306
307 case TOX_SAME_NXT:
308 if( pTOXMark->GetText() != rCurTOXMark.GetText() )
309 break;
310 /* no break here */
311 case TOX_NXT:
312 if ( (aAbsNew > aAbsIdx && aAbsNew < aNextPos &&
313 aNextPos != aAbsIdx && aAbsNew != aAbsIdx ) ||
314 (aAbsIdx == aAbsNew &&
315 (sal_uLong(&rCurTOXMark) < sal_uLong(pTOXMark) &&
316 (!pNew ||
317 (pNew && (aNextPos > aAbsIdx ||
318 sal_uLong(pNew) > sal_uLong(pTOXMark)))))) ||
319 (aNextPos == aAbsNew && aAbsIdx != aAbsNew &&
320 sal_uLong(pTOXMark) < sal_uLong(pNew)) )
321 {
322 pNew = pTOXMark;
323 aNextPos = aAbsNew;
324 if ( aAbsNew <= aMin )
325 {
326 aMin = aAbsNew;
327 pMin = pTOXMark;
328 }
329 }
330 break;
331 }
332 }
333 }
334
335
336 // kein Nachfolger wurde gefunden
337 // Min oder Max benutzen
338 if(!pNew)
339 {
340 switch(eDir)
341 {
342 case TOX_PRV:
343 case TOX_SAME_PRV:
344 pNew = pMax;
345 break;
346 case TOX_NXT:
347 case TOX_SAME_NXT:
348 pNew = pMin;
349 break;
350 default:
351 pNew = &rCurTOXMark;
352 }
353 }
354 return *pNew;
355 }
356
357
InsertTableOf(const SwPosition & rPos,const SwTOXBase & rTOX,const SfxItemSet * pSet,sal_Bool bExpand)358 const SwTOXBaseSection* SwDoc::InsertTableOf( const SwPosition& rPos,
359 const SwTOXBase& rTOX,
360 const SfxItemSet* pSet,
361 sal_Bool bExpand )
362 {
363 GetIDocumentUndoRedo().StartUndo( UNDO_INSTOX, NULL );
364
365 String sSectNm( rTOX.GetTOXName() );
366 sSectNm = GetUniqueTOXBaseName( *rTOX.GetTOXType(), &sSectNm );
367 SwPaM aPam( rPos );
368 SwSectionData aSectionData( TOX_CONTENT_SECTION, sSectNm );
369 SwTOXBaseSection *const pNewSection = dynamic_cast<SwTOXBaseSection *>(
370 InsertSwSection( aPam, aSectionData, & rTOX, pSet, false ));
371 if (pNewSection)
372 {
373 SwSectionNode *const pSectNd = pNewSection->GetFmt()->GetSectionNode();
374 pNewSection->SetTOXName(sSectNm); // rTOX may have had no name...
375
376 if( bExpand )
377 {
378 // OD 19.03.2003 #106329# - add value for 2nd parameter = true to
379 // indicate, that a creation of a new table of content has to be performed.
380 // Value of 1st parameter = default value.
381 pNewSection->Update( 0, true );
382 }
383 else if( 1 == rTOX.GetTitle().Len() && IsInReading() )
384 // insert title of TOX
385 {
386 // then insert the headline section
387 SwNodeIndex aIdx( *pSectNd, +1 );
388
389 SwTxtNode* pHeadNd = GetNodes().MakeTxtNode( aIdx,
390 GetTxtCollFromPool( RES_POOLCOLL_STANDARD ) );
391
392 String sNm( pNewSection->GetTOXName() );
393 // ??Resource
394 sNm.AppendAscii( RTL_CONSTASCII_STRINGPARAM( "_Head" ));
395
396 SwSectionData headerData( TOX_HEADER_SECTION, sNm );
397
398 SwNodeIndex aStt( *pHeadNd ); aIdx--;
399 SwSectionFmt* pSectFmt = MakeSectionFmt( 0 );
400 GetNodes().InsertTextSection(
401 aStt, *pSectFmt, headerData, 0, &aIdx, true, false);
402 }
403 }
404
405 GetIDocumentUndoRedo().EndUndo( UNDO_INSTOX, NULL );
406
407 return pNewSection;
408 }
409
410
411
InsertTableOf(sal_uLong nSttNd,sal_uLong nEndNd,const SwTOXBase & rTOX,const SfxItemSet * pSet)412 const SwTOXBaseSection* SwDoc::InsertTableOf( sal_uLong nSttNd, sal_uLong nEndNd,
413 const SwTOXBase& rTOX,
414 const SfxItemSet* pSet )
415 {
416 // check for recursiv TOX
417 SwNode* pNd = GetNodes()[ nSttNd ];
418 SwSectionNode* pSectNd = pNd->FindSectionNode();
419 while( pSectNd )
420 {
421 SectionType eT = pSectNd->GetSection().GetType();
422 if( TOX_HEADER_SECTION == eT || TOX_CONTENT_SECTION == eT )
423 return 0;
424 pSectNd = pSectNd->StartOfSectionNode()->FindSectionNode();
425 }
426
427 String sSectNm( rTOX.GetTOXName() );
428 sSectNm = GetUniqueTOXBaseName(*rTOX.GetTOXType(), &sSectNm);
429
430 SwSectionData aSectionData( TOX_CONTENT_SECTION, sSectNm );
431
432 SwNodeIndex aStt( GetNodes(), nSttNd ), aEnd( GetNodes(), nEndNd );
433 SwSectionFmt* pFmt = MakeSectionFmt( 0 );
434 if(pSet)
435 pFmt->SetFmtAttr(*pSet);
436
437 // --aEnd; // im InsertSection ist Ende inclusive
438
439 SwSectionNode *const pNewSectionNode =
440 GetNodes().InsertTextSection(aStt, *pFmt, aSectionData, &rTOX, &aEnd);
441 if (!pNewSectionNode)
442 {
443 DelSectionFmt( pFmt );
444 return 0;
445 }
446
447 SwTOXBaseSection *const pNewSection(
448 dynamic_cast<SwTOXBaseSection*>(& pNewSectionNode->GetSection()));
449 pNewSection->SetTOXName(sSectNm); // rTOX may have had no name...
450 return pNewSection;
451 }
452
453 /*--------------------------------------------------------------------
454 Beschreibung: Aktuelles Verzeichnis ermitteln
455 --------------------------------------------------------------------*/
456
GetCurTOX(const SwPosition & rPos) const457 const SwTOXBase* SwDoc::GetCurTOX( const SwPosition& rPos ) const
458 {
459 const SwNode& rNd = rPos.nNode.GetNode();
460 const SwSectionNode* pSectNd = rNd.FindSectionNode();
461 while( pSectNd )
462 {
463 SectionType eT = pSectNd->GetSection().GetType();
464 if( TOX_CONTENT_SECTION == eT )
465 {
466 ASSERT( pSectNd->GetSection().ISA( SwTOXBaseSection ),
467 "keine TOXBaseSection!" );
468 SwTOXBaseSection& rTOXSect = (SwTOXBaseSection&)
469 pSectNd->GetSection();
470 return &rTOXSect;
471 }
472 pSectNd = pSectNd->StartOfSectionNode()->FindSectionNode();
473 }
474 return 0;
475 }
476
GetTOXBaseAttrSet(const SwTOXBase & rTOXBase) const477 const SwAttrSet& SwDoc::GetTOXBaseAttrSet(const SwTOXBase& rTOXBase) const
478 {
479 ASSERT( rTOXBase.ISA( SwTOXBaseSection ), "no TOXBaseSection!" );
480 const SwTOXBaseSection& rTOXSect = (const SwTOXBaseSection&)rTOXBase;
481 SwSectionFmt* pFmt = rTOXSect.GetFmt();
482 ASSERT( pFmt, "invalid TOXBaseSection!" );
483 return pFmt->GetAttrSet();
484 }
485
GetDefaultTOXBase(TOXTypes eTyp,sal_Bool bCreate)486 const SwTOXBase* SwDoc::GetDefaultTOXBase( TOXTypes eTyp, sal_Bool bCreate )
487 {
488 SwTOXBase** prBase = 0;
489 switch(eTyp)
490 {
491 case TOX_CONTENT: prBase = &pDefTOXBases->pContBase; break;
492 case TOX_INDEX: prBase = &pDefTOXBases->pIdxBase; break;
493 case TOX_USER: prBase = &pDefTOXBases->pUserBase; break;
494 case TOX_TABLES: prBase = &pDefTOXBases->pTblBase; break;
495 case TOX_OBJECTS: prBase = &pDefTOXBases->pObjBase; break;
496 case TOX_ILLUSTRATIONS: prBase = &pDefTOXBases->pIllBase; break;
497 case TOX_AUTHORITIES: prBase = &pDefTOXBases->pAuthBase; break;
498 }
499 if(!(*prBase) && bCreate)
500 {
501 SwForm aForm(eTyp);
502 const SwTOXType* pType = GetTOXType(eTyp, 0);
503 (*prBase) = new SwTOXBase(pType, aForm, 0, pType->GetTypeName());
504 }
505 return (*prBase);
506 }
507
SetDefaultTOXBase(const SwTOXBase & rBase)508 void SwDoc::SetDefaultTOXBase(const SwTOXBase& rBase)
509 {
510 SwTOXBase** prBase = 0;
511 switch(rBase.GetType())
512 {
513 case TOX_CONTENT: prBase = &pDefTOXBases->pContBase; break;
514 case TOX_INDEX: prBase = &pDefTOXBases->pIdxBase; break;
515 case TOX_USER: prBase = &pDefTOXBases->pUserBase; break;
516 case TOX_TABLES: prBase = &pDefTOXBases->pTblBase; break;
517 case TOX_OBJECTS: prBase = &pDefTOXBases->pObjBase; break;
518 case TOX_ILLUSTRATIONS: prBase = &pDefTOXBases->pIllBase; break;
519 case TOX_AUTHORITIES: prBase = &pDefTOXBases->pAuthBase; break;
520 }
521 if(*prBase)
522 delete (*prBase);
523 (*prBase) = new SwTOXBase(rBase);
524 }
525
526 /*--------------------------------------------------------------------
527 Beschreibung: Verzeichnis loeschen
528 --------------------------------------------------------------------*/
529
530
DeleteTOX(const SwTOXBase & rTOXBase,sal_Bool bDelNodes)531 sal_Bool SwDoc::DeleteTOX( const SwTOXBase& rTOXBase, sal_Bool bDelNodes )
532 {
533 // its only delete the TOX, not the nodes
534 sal_Bool bRet = sal_False;
535 ASSERT( rTOXBase.ISA( SwTOXBaseSection ), "keine TOXBaseSection!" );
536
537 const SwTOXBaseSection& rTOXSect = (const SwTOXBaseSection&)rTOXBase;
538 SwSectionFmt* pFmt = rTOXSect.GetFmt();
539 if( pFmt )
540 {
541 GetIDocumentUndoRedo().StartUndo( UNDO_CLEARTOXRANGE, NULL );
542
543 /* Save the start node of the TOX' section. */
544 SwSectionNode * pMyNode = pFmt->GetSectionNode();
545 /* Save start node of section's surrounding. */
546 SwNode * pStartNd = pMyNode->StartOfSectionNode();
547
548 /* Look for point where to move the cursors in the area to
549 delete to. This is done by first searching forward from the
550 end of the TOX' section. If no content node is found behind
551 the TOX one is searched before it. If this is not
552 successful, too, insert new text node behind the end of
553 the TOX' section. The cursors from the TOX' section will be
554 moved to the content node found or the new text node. */
555
556 /* Set PaM to end of TOX' section and search following content node.
557
558 aSearchPam will contain the point where to move the cursors
559 to. */
560 SwPaM aSearchPam(*pMyNode->EndOfSectionNode());
561 SwPosition aEndPos(*pStartNd->EndOfSectionNode());
562 if (! aSearchPam.Move() /* no content node found */
563 || *aSearchPam.GetPoint() >= aEndPos /* content node found
564 outside surrounding */
565 )
566 {
567 /* Set PaM to beginning of TOX' section and search previous
568 content node */
569 SwPaM aTmpPam(*pMyNode);
570 aSearchPam = aTmpPam;
571 SwPosition aStartPos(*pStartNd);
572
573 if ( ! aSearchPam.Move(fnMoveBackward) /* no content node found */
574 || *aSearchPam.GetPoint() <= aStartPos /* content node
575 found outside
576 surrounding */
577 )
578 {
579 /* There is no content node in the surrounding of
580 TOX'. Append text node behind TOX' section. */
581
582 SwPosition aInsPos(*pMyNode->EndOfSectionNode());
583 AppendTxtNode(aInsPos);
584
585 SwPaM aTmpPam1(aInsPos);
586 aSearchPam = aTmpPam1;
587 }
588 }
589
590
591 /* PaM containing the TOX. */
592 SwPaM aPam(*pMyNode->EndOfSectionNode(), *pMyNode);
593
594 /* Move cursors contained in TOX to point determined above. */
595 PaMCorrAbs(aPam, *aSearchPam.GetPoint());
596
597 if( !bDelNodes )
598 {
599 SwSections aArr( 0, 4 );
600 sal_uInt16 nCnt = pFmt->GetChildSections( aArr, SORTSECT_NOT, sal_False );
601 for( sal_uInt16 n = 0; n < nCnt; ++n )
602 {
603 SwSection* pSect = aArr[ n ];
604 if( TOX_HEADER_SECTION == pSect->GetType() )
605 {
606 DelSectionFmt( pSect->GetFmt(), bDelNodes );
607 }
608 }
609 }
610
611 DelSectionFmt( pFmt, bDelNodes );
612
613 GetIDocumentUndoRedo().EndUndo( UNDO_CLEARTOXRANGE, NULL );
614 bRet = sal_True;
615 }
616
617 return bRet;
618 }
619
620 /*--------------------------------------------------------------------
621 Beschreibung: Verzeichnistypen verwalten
622 --------------------------------------------------------------------*/
623
GetTOXTypeCount(TOXTypes eTyp) const624 sal_uInt16 SwDoc::GetTOXTypeCount(TOXTypes eTyp) const
625 {
626 const SwTOXTypePtr * ppTTypes = pTOXTypes->GetData();
627 sal_uInt16 nCnt = 0;
628 for( sal_uInt16 n = 0; n < pTOXTypes->Count(); ++n, ++ppTTypes )
629 if( eTyp == (*ppTTypes)->GetType() )
630 ++nCnt;
631 return nCnt;
632 }
633
GetTOXType(TOXTypes eTyp,sal_uInt16 nId) const634 const SwTOXType* SwDoc::GetTOXType( TOXTypes eTyp, sal_uInt16 nId ) const
635 {
636 const SwTOXTypePtr * ppTTypes = pTOXTypes->GetData();
637 sal_uInt16 nCnt = 0;
638 for( sal_uInt16 n = 0; n < pTOXTypes->Count(); ++n, ++ppTTypes )
639 if( eTyp == (*ppTTypes)->GetType() && nCnt++ == nId )
640 return (*ppTTypes);
641 return 0;
642 }
643
644
InsertTOXType(const SwTOXType & rTyp)645 const SwTOXType* SwDoc::InsertTOXType( const SwTOXType& rTyp )
646 {
647 SwTOXType * pNew = new SwTOXType( rTyp );
648 pTOXTypes->Insert( pNew, pTOXTypes->Count() );
649 return pNew;
650 }
651
GetUniqueTOXBaseName(const SwTOXType & rType,const String * pChkStr) const652 String SwDoc::GetUniqueTOXBaseName( const SwTOXType& rType,
653 const String* pChkStr ) const
654 {
655 sal_uInt16 n;
656 const SwSectionNode* pSectNd;
657 const SwSection* pSect;
658
659 if(pChkStr && !pChkStr->Len())
660 pChkStr = 0;
661 String aName( rType.GetTypeName() );
662 xub_StrLen nNmLen = aName.Len();
663
664 sal_uInt16 nNum = 0;
665 sal_uInt16 nTmp = 0;
666 sal_uInt16 nFlagSize = ( pSectionFmtTbl->Count() / 8 ) +2;
667 sal_uInt8* pSetFlags = new sal_uInt8[ nFlagSize ];
668 memset( pSetFlags, 0, nFlagSize );
669
670 for( n = 0; n < pSectionFmtTbl->Count(); ++n )
671 if( 0 != ( pSectNd = (*pSectionFmtTbl)[ n ]->GetSectionNode( sal_False ) )&&
672 TOX_CONTENT_SECTION == (pSect = &pSectNd->GetSection())->GetType())
673 {
674 const String& rNm = pSect->GetSectionName();
675 if( rNm.Match( aName ) == nNmLen )
676 {
677 // Nummer bestimmen und das Flag setzen
678 nNum = (sal_uInt16)rNm.Copy( nNmLen ).ToInt32();
679 if( nNum-- && nNum < pSectionFmtTbl->Count() )
680 pSetFlags[ nNum / 8 ] |= (0x01 << ( nNum & 0x07 ));
681 }
682 if( pChkStr && pChkStr->Equals( rNm ) )
683 pChkStr = 0;
684 }
685
686 if( !pChkStr )
687 {
688 // alle Nummern entsprechend geflag, also bestimme die richtige Nummer
689 nNum = pSectionFmtTbl->Count();
690 for( n = 0; n < nFlagSize; ++n )
691 if( 0xff != ( nTmp = pSetFlags[ n ] ))
692 {
693 // also die Nummer bestimmen
694 nNum = n * 8;
695 while( nTmp & 1 )
696 ++nNum, nTmp >>= 1;
697 break;
698 }
699 }
700 delete [] pSetFlags;
701 if( pChkStr )
702 return *pChkStr;
703 return aName += String::CreateFromInt32( ++nNum );
704 }
705
SetTOXBaseName(const SwTOXBase & rTOXBase,const String & rName)706 sal_Bool SwDoc::SetTOXBaseName(const SwTOXBase& rTOXBase, const String& rName)
707 {
708 ASSERT( rTOXBase.ISA( SwTOXBaseSection ),
709 "keine TOXBaseSection!" );
710 SwTOXBaseSection* pTOX = (SwTOXBaseSection*)&rTOXBase;
711
712 String sTmp = GetUniqueTOXBaseName(*rTOXBase.GetTOXType(), &rName);
713 sal_Bool bRet = sTmp == rName;
714 if(bRet)
715 {
716 pTOX->SetTOXName(rName);
717 pTOX->SetSectionName(rName);
718 SetModified();
719 }
720 return bRet;
721 }
722
723
lcl_FindChapterNode(const SwNode & rNd,sal_uInt8 nLvl=0)724 const SwTxtNode* lcl_FindChapterNode( const SwNode& rNd, sal_uInt8 nLvl = 0 )
725 {
726 const SwNode* pNd = &rNd;
727 if( pNd->GetNodes().GetEndOfExtras().GetIndex() > pNd->GetIndex() )
728 {
729 // then find the "Anchor" (Body) position
730 Point aPt;
731 SwNode2Layout aNode2Layout( *pNd, pNd->GetIndex() );
732 const SwFrm* pFrm = aNode2Layout.GetFrm( &aPt, 0, sal_False );
733
734 if( pFrm )
735 {
736 SwPosition aPos( *pNd );
737 pNd = GetBodyTxtNode( *pNd->GetDoc(), aPos, *pFrm );
738 ASSERT( pNd, "wo steht der Absatz" );
739 }
740 }
741 return pNd ? pNd->FindOutlineNodeOfLevel( nLvl ) : 0;
742 }
743
744
745 /*--------------------------------------------------------------------
746 Beschreibung: Verzeichnis-Klasse
747 --------------------------------------------------------------------*/
748
SwTOXBaseSection(SwTOXBase const & rBase,SwSectionFmt & rFmt)749 SwTOXBaseSection::SwTOXBaseSection(SwTOXBase const& rBase, SwSectionFmt & rFmt)
750 : SwTOXBase( rBase )
751 , SwSection( TOX_CONTENT_SECTION, aEmptyStr, rFmt )
752 {
753 SetProtect( rBase.IsProtected() );
754 SetSectionName( GetTOXName() );
755 }
756
757
~SwTOXBaseSection()758 SwTOXBaseSection::~SwTOXBaseSection()
759 {
760 aSortArr.DeleteAndDestroy( 0, aSortArr.Count() ); // i120680
761 }
762
763
SetPosAtStartEnd(SwPosition & rPos,sal_Bool bAtStart) const764 sal_Bool SwTOXBaseSection::SetPosAtStartEnd( SwPosition& rPos, sal_Bool bAtStart ) const
765 {
766 sal_Bool bRet = sal_False;
767 const SwSectionNode* pSectNd = GetFmt()->GetSectionNode();
768 if( pSectNd )
769 {
770 SwCntntNode* pCNd;
771 xub_StrLen nC = 0;
772 if( bAtStart )
773 {
774 rPos.nNode = *pSectNd;
775 pCNd = pSectNd->GetDoc()->GetNodes().GoNext( &rPos.nNode );
776 }
777 else
778 {
779 rPos.nNode = *pSectNd->EndOfSectionNode();
780 pCNd = pSectNd->GetDoc()->GetNodes().GoPrevious( &rPos.nNode );
781 if( pCNd ) nC = pCNd->Len();
782 }
783 rPos.nContent.Assign( pCNd, nC );
784 bRet = sal_True;
785 }
786 return bRet;
787 }
788
789 /*--------------------------------------------------------------------
790 Beschreibung: Verzeichnisinhalt zusammensammeln
791 --------------------------------------------------------------------*/
792
Update(const SfxItemSet * pAttr,const bool _bNewTOX)793 void SwTOXBaseSection::Update(const SfxItemSet* pAttr,
794 const bool _bNewTOX )//swmodtest 080307
795 {
796 const SwSectionNode* pSectNd;
797 if( !SwTOXBase::GetRegisteredIn()->GetDepends() ||
798 !GetFmt() || 0 == (pSectNd = GetFmt()->GetSectionNode() ) ||
799 !pSectNd->GetNodes().IsDocNodes() ||
800 IsHiddenFlag() )
801 {
802 return;
803 }
804
805 if ( !mbKeepExpression )
806 {
807 maMSTOCExpression = String();
808 }
809
810 SwDoc* pDoc = (SwDoc*)pSectNd->GetDoc();
811
812 DBG_ASSERT(pDoc != NULL, "Where is the document?");
813
814 if(pAttr && pDoc && GetFmt())
815 pDoc->ChgFmt(*GetFmt(), *pAttr);
816
817 // OD 18.03.2003 #106329# - determine default page description, which
818 // will be used by the content nodes, if no approriate one is found.
819 const SwPageDesc* pDefaultPageDesc;
820 {
821 pDefaultPageDesc =
822 pSectNd->GetSection().GetFmt()->GetPageDesc().GetPageDesc();
823 if ( !_bNewTOX && !pDefaultPageDesc )
824 {
825 // determine page description of table-of-content
826 sal_uInt32 nPgDescNdIdx = pSectNd->GetIndex() + 1;
827 sal_uInt32* pPgDescNdIdx = &nPgDescNdIdx;
828 pDefaultPageDesc = pSectNd->FindPageDesc( sal_False, pPgDescNdIdx );
829 if ( nPgDescNdIdx < pSectNd->GetIndex() )
830 {
831 pDefaultPageDesc = 0;
832 }
833 }
834 // OD 28.04.2003 #109166# - consider end node of content section in the
835 // node array.
836 if ( !pDefaultPageDesc &&
837 ( pSectNd->EndOfSectionNode()->GetIndex() <
838 (pSectNd->GetNodes().GetEndOfContent().GetIndex() - 1) )
839 )
840 {
841 // determine page description of content after table-of-content
842 SwNodeIndex aIdx( *(pSectNd->EndOfSectionNode()) );
843 const SwCntntNode* pNdAfterTOX = pSectNd->GetNodes().GoNext( &aIdx );
844 const SwAttrSet& aNdAttrSet = pNdAfterTOX->GetSwAttrSet();
845 const SvxBreak eBreak = aNdAttrSet.GetBreak().GetBreak();
846 if ( !( eBreak == SVX_BREAK_PAGE_BEFORE ||
847 eBreak == SVX_BREAK_PAGE_BOTH )
848 )
849 {
850 pDefaultPageDesc = pNdAfterTOX->FindPageDesc( sal_False );
851 }
852 }
853 // OD 28.04.2003 #109166# - consider start node of content section in
854 // the node array.
855 if ( !pDefaultPageDesc &&
856 ( pSectNd->GetIndex() >
857 (pSectNd->GetNodes().GetEndOfContent().StartOfSectionIndex() + 1) )
858 )
859 {
860 // determine page description of content before table-of-content
861 SwNodeIndex aIdx( *pSectNd );
862 pDefaultPageDesc =
863 pSectNd->GetNodes().GoPrevious( &aIdx )->FindPageDesc( sal_False );
864
865 }
866 if ( !pDefaultPageDesc )
867 {
868 // determine default page description
869 pDefaultPageDesc =
870 &const_cast<const SwDoc *>(pDoc)->GetPageDesc( 0 );
871 }
872 }
873
874 pDoc->SetModified();
875
876 // get current Language
877 SwTOXInternational aIntl( GetLanguage(),
878 TOX_INDEX == GetTOXType()->GetType() ?
879 GetOptions() : 0,
880 GetSortAlgorithm() );
881
882 aSortArr.DeleteAndDestroy( 0, aSortArr.Count() );
883
884 // find the first layout node for this TOX, if it only find the content
885 // in his own chapter
886 const SwTxtNode* pOwnChapterNode = IsFromChapter()
887 ? ::lcl_FindChapterNode( *pSectNd, 0 )
888 : 0;
889
890 SwNode2Layout aN2L( *pSectNd );
891 ((SwSectionNode*)pSectNd)->DelFrms();
892
893 // remove old content an insert one empty textnode (to hold the layout!)
894 SwTxtNode* pFirstEmptyNd;
895 {
896 pDoc->DeleteRedline( *pSectNd, true, USHRT_MAX );
897
898 SwNodeIndex aSttIdx( *pSectNd, +1 );
899 SwNodeIndex aEndIdx( *pSectNd->EndOfSectionNode() );
900 pFirstEmptyNd = pDoc->GetNodes().MakeTxtNode( aEndIdx,
901 pDoc->GetTxtCollFromPool( RES_POOLCOLL_TEXT ) );
902
903 {
904 // Task 70995 - save and restore PageDesc and Break Attributes
905 SwNodeIndex aNxtIdx( aSttIdx );
906 const SwCntntNode* pCNd = aNxtIdx.GetNode().GetCntntNode();
907 if( !pCNd )
908 pCNd = pDoc->GetNodes().GoNext( &aNxtIdx );
909 if( pCNd->HasSwAttrSet() )
910 {
911 SfxItemSet aBrkSet( pDoc->GetAttrPool(), aBreakSetRange );
912 aBrkSet.Put( *pCNd->GetpSwAttrSet() );
913 if( aBrkSet.Count() )
914 pFirstEmptyNd->SetAttr( aBrkSet );
915 }
916 }
917 aEndIdx--;
918 SwPosition aPos( aEndIdx, SwIndex( pFirstEmptyNd, 0 ));
919 pDoc->CorrAbs( aSttIdx, aEndIdx, aPos, sal_True );
920
921 // delete all before
922 DelFlyInRange( aSttIdx, aEndIdx );
923 _DelBookmarks( aSttIdx, aEndIdx );
924
925 pDoc->GetNodes().Delete( aSttIdx, aEndIdx.GetIndex() - aSttIdx.GetIndex() );
926
927 }
928
929 //
930 // insert title of TOX
931 if( GetTitle().Len() )
932 {
933 // then insert the headline section
934 SwNodeIndex aIdx( *pSectNd, +1 );
935
936 SwTxtNode* pHeadNd = pDoc->GetNodes().MakeTxtNode( aIdx,
937 GetTxtFmtColl( FORM_TITLE ) );
938 pHeadNd->InsertText( GetTitle(), SwIndex( pHeadNd ) );
939
940 String sNm( GetTOXName() );
941 // ??Resource
942 sNm.AppendAscii( RTL_CONSTASCII_STRINGPARAM( "_Head" ));
943
944 SwSectionData headerData( TOX_HEADER_SECTION, sNm );
945
946 SwNodeIndex aStt( *pHeadNd ); aIdx--;
947 SwSectionFmt* pSectFmt = pDoc->MakeSectionFmt( 0 );
948 pDoc->GetNodes().InsertTextSection(
949 aStt, *pSectFmt, headerData, 0, &aIdx, true, false);
950 }
951
952 // jetzt waere ein prima Zeitpunkt, um die Numerierung zu updaten
953 pDoc->UpdateNumRule();
954
955 if( GetCreateType() & nsSwTOXElement::TOX_MARK )
956 UpdateMarks( aIntl, pOwnChapterNode );
957
958 if( GetCreateType() & nsSwTOXElement::TOX_OUTLINELEVEL )
959 UpdateOutline( pOwnChapterNode );
960
961 if( GetCreateType() & nsSwTOXElement::TOX_TEMPLATE )
962 UpdateTemplate( pOwnChapterNode );
963
964 if( GetCreateType() & nsSwTOXElement::TOX_OLE ||
965 TOX_OBJECTS == SwTOXBase::GetType())
966 UpdateCntnt( nsSwTOXElement::TOX_OLE, pOwnChapterNode );
967
968 if( GetCreateType() & nsSwTOXElement::TOX_TABLE ||
969 (TOX_TABLES == SwTOXBase::GetType() && IsFromObjectNames()) )
970 UpdateTable( pOwnChapterNode );
971
972 if( GetCreateType() & nsSwTOXElement::TOX_GRAPHIC ||
973 (TOX_ILLUSTRATIONS == SwTOXBase::GetType() && IsFromObjectNames()))
974 UpdateCntnt( nsSwTOXElement::TOX_GRAPHIC, pOwnChapterNode );
975
976 if( GetSequenceName().Len() && !IsFromObjectNames() &&
977 (TOX_TABLES == SwTOXBase::GetType() ||
978 TOX_ILLUSTRATIONS == SwTOXBase::GetType() ) )
979 UpdateSequence( pOwnChapterNode );
980
981 if( GetCreateType() & nsSwTOXElement::TOX_FRAME )
982 UpdateCntnt( nsSwTOXElement::TOX_FRAME, pOwnChapterNode );
983
984 if(TOX_AUTHORITIES == SwTOXBase::GetType())
985 UpdateAuthorities( aIntl );
986
987 // Bei Bedarf Alphadelimitter einfuegen (nur bei Stichwoertern)
988 //
989 if( TOX_INDEX == SwTOXBase::GetType() &&
990 ( GetOptions() & nsSwTOIOptions::TOI_ALPHA_DELIMITTER ) )
991 InsertAlphaDelimitter( aIntl );
992
993 // sortierte Liste aller Verzeichnismarken und Verzeichnisbereiche
994 void* p = 0;
995 String* pStr = 0;
996 sal_uInt16 nCnt = 0, nFormMax = GetTOXForm().GetFormMax();
997 SvStringsDtor aStrArr( (sal_uInt8)nFormMax );
998 SvPtrarr aCollArr( (sal_uInt8)nFormMax );
999 for( ; nCnt < nFormMax; ++nCnt )
1000 {
1001 aCollArr.Insert( p, nCnt );
1002 aStrArr.Insert( pStr, nCnt );
1003 }
1004
1005 SwNodeIndex aInsPos( *pFirstEmptyNd, 1 );
1006 for( nCnt = 0; nCnt < aSortArr.Count(); ++nCnt )
1007 {
1008 ::SetProgressState( 0, pDoc->GetDocShell() );
1009
1010 // setze den Text in das Verzeichniss
1011 sal_uInt16 nLvl = aSortArr[ nCnt ]->GetLevel();
1012 SwTxtFmtColl* pColl = (SwTxtFmtColl*)aCollArr[ nLvl ];
1013 if( !pColl )
1014 {
1015 pColl = GetTxtFmtColl( nLvl );
1016 aCollArr.Remove( nLvl );
1017 p = pColl;
1018 aCollArr.Insert( p , nLvl );
1019 }
1020
1021 // Generierung: dynamische TabStops setzen
1022 SwTxtNode* pTOXNd = pDoc->GetNodes().MakeTxtNode( aInsPos , pColl );
1023 aSortArr[ nCnt ]->pTOXNd = pTOXNd;
1024
1025 // Generierung: Form auswerten und Platzhalter
1026 // fuer die Seitennummer eintragen
1027 //if it is a TOX_INDEX and the SwForm IsCommaSeparated()
1028 // then a range of entries must be generated into one paragraph
1029 sal_uInt16 nRange = 1;
1030 if(TOX_INDEX == SwTOXBase::GetType() &&
1031 GetTOXForm().IsCommaSeparated() &&
1032 aSortArr[nCnt]->GetType() == TOX_SORT_INDEX)
1033 {
1034 const SwTOXMark& rMark = aSortArr[nCnt]->pTxtMark->GetTOXMark();
1035 const String sPrimKey = rMark.GetPrimaryKey();
1036 const String sSecKey = rMark.GetSecondaryKey();
1037 const SwTOXMark* pNextMark = 0;
1038 while(aSortArr.Count() > (nCnt + nRange)&&
1039 aSortArr[nCnt + nRange]->GetType() == TOX_SORT_INDEX &&
1040 0 != (pNextMark = &(aSortArr[nCnt + nRange]->pTxtMark->GetTOXMark())) &&
1041 pNextMark->GetPrimaryKey() == sPrimKey &&
1042 pNextMark->GetSecondaryKey() == sSecKey)
1043 nRange++;
1044 }
1045 // OD 18.03.2003 #106329# - pass node index of table-of-content section
1046 // and default page description to method <GenerateText(..)>.
1047 GenerateText( nCnt, nRange, aStrArr, pSectNd->GetIndex(), pDefaultPageDesc );
1048 nCnt += nRange - 1;
1049 }
1050
1051 // delete the first dummy node and remove all Cursor into the prev node
1052 aInsPos = *pFirstEmptyNd;
1053 {
1054 SwPaM aCorPam( *pFirstEmptyNd );
1055 aCorPam.GetPoint()->nContent.Assign( pFirstEmptyNd, 0 );
1056 if( !aCorPam.Move( fnMoveForward ) )
1057 aCorPam.Move( fnMoveBackward );
1058 SwNodeIndex aEndIdx( aInsPos, 1 );
1059 pDoc->CorrAbs( aInsPos, aEndIdx, *aCorPam.GetPoint(), sal_True );
1060
1061 // Task 70995 - save and restore PageDesc and Break Attributes
1062 if( pFirstEmptyNd->HasSwAttrSet() )
1063 {
1064 if( GetTitle().Len() )
1065 aEndIdx = *pSectNd;
1066 else
1067 aEndIdx = *pFirstEmptyNd;
1068 SwCntntNode* pCNd = pDoc->GetNodes().GoNext( &aEndIdx );
1069 if( pCNd ) // Robust against defect documents, e.g. i60336
1070 pCNd->SetAttr( *pFirstEmptyNd->GetpSwAttrSet() );
1071 }
1072 }
1073
1074 // now create the new Frames
1075 sal_uLong nIdx = pSectNd->GetIndex();
1076 // don't delete if index is empty
1077 if(nIdx + 2 < pSectNd->EndOfSectionIndex())
1078 pDoc->GetNodes().Delete( aInsPos, 1 );
1079
1080 aN2L.RestoreUpperFrms( pDoc->GetNodes(), nIdx, nIdx + 1 );
1081 std::set<SwRootFrm*> aAllLayouts = pDoc->GetAllLayouts();
1082 for ( std::set<SwRootFrm*>::iterator pLayoutIter = aAllLayouts.begin(); pLayoutIter != aAllLayouts.end(); pLayoutIter++)
1083 {
1084 SwFrm::CheckPageDescs( (SwPageFrm*)(*pLayoutIter)->Lower() );
1085 }//swmod 080310
1086
1087 SetProtect( SwTOXBase::IsProtected() );
1088 }
1089
1090 /*--------------------------------------------------------------------
1091 Beschreibung: AlphaDelimitter einfuegen
1092 --------------------------------------------------------------------*/
1093
1094
InsertAlphaDelimitter(const SwTOXInternational & rIntl)1095 void SwTOXBaseSection::InsertAlphaDelimitter( const SwTOXInternational& rIntl )
1096 {
1097 SwDoc* pDoc = (SwDoc*)GetFmt()->GetDoc();
1098 String sDeli, sLastDeli;
1099 sal_uInt16 i = 0;
1100 while( i < aSortArr.Count() )
1101 {
1102 ::SetProgressState( 0, pDoc->GetDocShell() );
1103
1104 sal_uInt16 nLevel = aSortArr[i]->GetLevel();
1105
1106 // Alpha-Delimitter ueberlesen
1107 if( nLevel == FORM_ALPHA_DELIMITTER )
1108 continue;
1109
1110 String sMyString, sMyStringReading;
1111 aSortArr[i]->GetTxt( sMyString, sMyStringReading );
1112
1113 sDeli = rIntl.GetIndexKey( sMyString, sMyStringReading,
1114 aSortArr[i]->GetLocale() );
1115
1116 // Delimitter schon vorhanden ??
1117 if( sDeli.Len() && sLastDeli != sDeli )
1118 {
1119 // alle kleiner Blank wollen wir nicht haben -> sind Sonderzeichen
1120 if( ' ' <= sDeli.GetChar( 0 ) )
1121 {
1122 SwTOXCustom* pCst = new SwTOXCustom( sDeli, aEmptyStr, FORM_ALPHA_DELIMITTER,
1123 rIntl, aSortArr[i]->GetLocale() );
1124 aSortArr.Insert( pCst, i++ );
1125 }
1126 sLastDeli = sDeli;
1127 }
1128
1129 // Skippen bis gleibhes oder kleineres Level erreicht ist
1130 do {
1131 i++;
1132 } while (i < aSortArr.Count() && aSortArr[i]->GetLevel() > nLevel);
1133 }
1134 }
1135
1136 /*--------------------------------------------------------------------
1137 Beschreibung: Template auswerten
1138 --------------------------------------------------------------------*/
1139
GetTxtFmtColl(sal_uInt16 nLevel)1140 SwTxtFmtColl* SwTOXBaseSection::GetTxtFmtColl( sal_uInt16 nLevel )
1141 {
1142 SwDoc* pDoc = (SwDoc*)GetFmt()->GetDoc();
1143 const String& rName = GetTOXForm().GetTemplate( nLevel );
1144 SwTxtFmtColl* pColl = rName.Len() ? pDoc->FindTxtFmtCollByName(rName) :0;
1145 if( !pColl )
1146 {
1147 sal_uInt16 nPoolFmt = 0;
1148 const TOXTypes eMyType = SwTOXBase::GetType();
1149 switch( eMyType )
1150 {
1151 case TOX_INDEX: nPoolFmt = RES_POOLCOLL_TOX_IDXH; break;
1152 case TOX_USER:
1153 if( nLevel < 6 )
1154 nPoolFmt = RES_POOLCOLL_TOX_USERH;
1155 else
1156 nPoolFmt = RES_POOLCOLL_TOX_USER6 - 6;
1157 break;
1158 case TOX_ILLUSTRATIONS: nPoolFmt = RES_POOLCOLL_TOX_ILLUSH; break;
1159 case TOX_OBJECTS: nPoolFmt = RES_POOLCOLL_TOX_OBJECTH; break;
1160 case TOX_TABLES: nPoolFmt = RES_POOLCOLL_TOX_TABLESH; break;
1161 case TOX_AUTHORITIES: nPoolFmt = RES_POOLCOLL_TOX_AUTHORITIESH; break;
1162
1163 case TOX_CONTENT:
1164 // im Content Bereich gibt es einen Sprung!
1165 if( nLevel < 6 )
1166 nPoolFmt = RES_POOLCOLL_TOX_CNTNTH;
1167 else
1168 nPoolFmt = RES_POOLCOLL_TOX_CNTNT6 - 6;
1169 break;
1170 }
1171
1172 if(eMyType == TOX_AUTHORITIES && nLevel)
1173 nPoolFmt = nPoolFmt + 1;
1174 else if(eMyType == TOX_INDEX && nLevel)
1175 {
1176 //pool: Level 1,2,3, Delimiter
1177 //SwForm: Delimiter, Level 1,2,3
1178 nPoolFmt += 1 == nLevel ? nLevel + 3 : nLevel - 1;
1179 }
1180 else
1181 nPoolFmt = nPoolFmt + nLevel;
1182 pColl = pDoc->GetTxtCollFromPool( nPoolFmt );
1183 }
1184 return pColl;
1185 }
1186
1187
1188 /*--------------------------------------------------------------------
1189 Beschreibung: Aus Markierungen erzeugen
1190 --------------------------------------------------------------------*/
1191
UpdateMarks(const SwTOXInternational & rIntl,const SwTxtNode * pOwnChapterNode)1192 void SwTOXBaseSection::UpdateMarks( const SwTOXInternational& rIntl,
1193 const SwTxtNode* pOwnChapterNode )
1194 {
1195 const SwTOXType* pType = (SwTOXType*) SwTOXBase::GetRegisteredIn();
1196 if( !pType->GetDepends() )
1197 return;
1198
1199 SwDoc* pDoc = (SwDoc*)GetFmt()->GetDoc();
1200 TOXTypes eTOXTyp = GetTOXType()->GetType();
1201 SwIterator<SwTOXMark,SwTOXType> aIter( *pType );
1202
1203 SwTxtTOXMark* pTxtMark;
1204 SwTOXMark* pMark;
1205 for( pMark = aIter.First(); pMark; pMark = aIter.Next() )
1206 {
1207 ::SetProgressState( 0, pDoc->GetDocShell() );
1208
1209 if( pMark->GetTOXType()->GetType() == eTOXTyp &&
1210 0 != ( pTxtMark = pMark->GetTxtTOXMark() ) )
1211 {
1212 const SwTxtNode* pTOXSrc = pTxtMark->GetpTxtNd();
1213 // nur TOXMarks einfuegen die im Doc stehen
1214 // nicht die, die im UNDO stehen
1215 //
1216 // if selected use marks from the same chapter only
1217 if( pTOXSrc->GetNodes().IsDocNodes() &&
1218 pTOXSrc->GetTxt().Len() && pTOXSrc->GetDepends() &&
1219 pTOXSrc->getLayoutFrm( pDoc->GetCurrentLayout() ) &&
1220 (!IsFromChapter() || ::lcl_FindChapterNode( *pTOXSrc, 0 ) == pOwnChapterNode ) &&
1221 !pTOXSrc->HasHiddenParaField() &&
1222 !SwScriptInfo::IsInHiddenRange( *pTOXSrc, *pTxtMark->GetStart() ) )
1223 {
1224 SwTOXSortTabBase* pBase = 0;
1225 if(TOX_INDEX == eTOXTyp)
1226 {
1227 // Stichwortverzeichnismarkierung
1228 lang::Locale aLocale;
1229 if ( pBreakIt->GetBreakIter().is() )
1230 {
1231 aLocale = pBreakIt->GetLocale(
1232 pTOXSrc->GetLang( *pTxtMark->GetStart() ) );
1233 }
1234
1235 pBase = new SwTOXIndex( *pTOXSrc, pTxtMark,
1236 GetOptions(), FORM_ENTRY, rIntl, aLocale );
1237 InsertSorted(pBase);
1238 if(GetOptions() & nsSwTOIOptions::TOI_KEY_AS_ENTRY &&
1239 pTxtMark->GetTOXMark().GetPrimaryKey().Len())
1240 {
1241 pBase = new SwTOXIndex( *pTOXSrc, pTxtMark,
1242 GetOptions(), FORM_PRIMARY_KEY, rIntl, aLocale );
1243 InsertSorted(pBase);
1244 if(pTxtMark->GetTOXMark().GetSecondaryKey().Len())
1245 {
1246 pBase = new SwTOXIndex( *pTOXSrc, pTxtMark,
1247 GetOptions(), FORM_SECONDARY_KEY, rIntl, aLocale );
1248 InsertSorted(pBase);
1249 }
1250 }
1251 }
1252 else if( TOX_USER == eTOXTyp ||
1253 pMark->GetLevel() <= GetLevel())
1254 { // Inhaltsberzeichnismarkierung
1255 // also used for user marks
1256 pBase = new SwTOXContent( *pTOXSrc, pTxtMark, rIntl );
1257 InsertSorted(pBase);
1258 }
1259 }
1260 }
1261 }
1262 }
1263
1264
1265 /*--------------------------------------------------------------------
1266 Beschreibung: Verzeichnisinhalt aus Gliederungsebene generieren
1267 --------------------------------------------------------------------*/
1268
1269
UpdateOutline(const SwTxtNode * pOwnChapterNode)1270 void SwTOXBaseSection::UpdateOutline( const SwTxtNode* pOwnChapterNode )
1271 {
1272 SwDoc* pDoc = (SwDoc*)GetFmt()->GetDoc();
1273 SwNodes& rNds = pDoc->GetNodes();
1274
1275 const SwOutlineNodes& rOutlNds = rNds.GetOutLineNds();
1276 for( sal_uInt16 n = 0; n < rOutlNds.Count(); ++n )
1277 {
1278 ::SetProgressState( 0, pDoc->GetDocShell() );
1279 SwTxtNode* pTxtNd = rOutlNds[ n ]->GetTxtNode();
1280 if( pTxtNd && pTxtNd->Len() && pTxtNd->GetDepends() &&
1281 //sal_uInt16(pTxtNd->GetTxtColl()->GetOutlineLevel()+1) <= GetLevel() && //#outline level,zhaojianwei
1282 sal_uInt16( pTxtNd->GetAttrOutlineLevel()) <= GetLevel() && //<-end,zhaojianwei
1283 pTxtNd->getLayoutFrm( pDoc->GetCurrentLayout() ) &&
1284 !pTxtNd->HasHiddenParaField() &&
1285 !pTxtNd->HasHiddenCharAttribute( true ) &&
1286 ( !IsFromChapter() ||
1287 ::lcl_FindChapterNode( *pTxtNd, 0 ) == pOwnChapterNode ))
1288 {
1289 SwTOXPara * pNew = new SwTOXPara( *pTxtNd, nsSwTOXElement::TOX_OUTLINELEVEL );
1290 InsertSorted( pNew );
1291 }
1292 }
1293 }
1294
1295 /*--------------------------------------------------------------------
1296 Beschreibung: Verzeichnisinhalt aus Vorlagenbereichen generieren
1297 --------------------------------------------------------------------*/
1298
UpdateTemplate(const SwTxtNode * pOwnChapterNode)1299 void SwTOXBaseSection::UpdateTemplate( const SwTxtNode* pOwnChapterNode )
1300 {
1301 SwDoc* pDoc = (SwDoc*)GetFmt()->GetDoc();
1302 for(sal_uInt16 i = 0; i < MAXLEVEL; i++)
1303 {
1304 String sTmpStyleNames = GetStyleNames(i);
1305 sal_uInt16 nTokenCount = sTmpStyleNames.GetTokenCount(TOX_STYLE_DELIMITER);
1306 for( sal_uInt16 nStyle = 0; nStyle < nTokenCount; ++nStyle )
1307 {
1308 SwTxtFmtColl* pColl = pDoc->FindTxtFmtCollByName(
1309 sTmpStyleNames.GetToken( nStyle,
1310 TOX_STYLE_DELIMITER ));
1311 //TODO: no outline Collections in content indexes if OutlineLevels are already included
1312 if( !pColl ||
1313 ( TOX_CONTENT == SwTOXBase::GetType() &&
1314 GetCreateType() & nsSwTOXElement::TOX_OUTLINELEVEL &&
1315 //NO_NUMBERING != pColl->GetOutlineLevel() ) )//#outline level,zhaojianwei
1316 pColl->IsAssignedToListLevelOfOutlineStyle()) )//<-end,zhaojianwei
1317 continue;
1318
1319 SwIterator<SwTxtNode,SwFmtColl> aIter( *pColl );
1320 for( SwTxtNode* pTxtNd = aIter.First(); pTxtNd; pTxtNd = aIter.Next() )
1321 {
1322 ::SetProgressState( 0, pDoc->GetDocShell() );
1323
1324 if( pTxtNd->GetTxt().Len() && pTxtNd->getLayoutFrm( pDoc->GetCurrentLayout() ) &&
1325 pTxtNd->GetNodes().IsDocNodes() &&
1326 ( !IsFromChapter() || pOwnChapterNode ==
1327 ::lcl_FindChapterNode( *pTxtNd, 0 ) ) )
1328 {
1329 SwTOXPara * pNew = new SwTOXPara( *pTxtNd, nsSwTOXElement::TOX_TEMPLATE, i + 1 );
1330 InsertSorted(pNew);
1331 }
1332 }
1333 }
1334 }
1335 }
1336
1337 /* -----------------14.07.99 09:59-------------------
1338 Description: generate content from sequence fields
1339 --------------------------------------------------*/
UpdateSequence(const SwTxtNode * pOwnChapterNode)1340 void SwTOXBaseSection::UpdateSequence( const SwTxtNode* pOwnChapterNode )
1341 {
1342 SwDoc* pDoc = (SwDoc*)GetFmt()->GetDoc();
1343 SwFieldType* pSeqFld = pDoc->GetFldType(RES_SETEXPFLD, GetSequenceName(), false);
1344 if(!pSeqFld)
1345 return;
1346
1347 SwIterator<SwFmtFld,SwFieldType> aIter( *pSeqFld );
1348 for( SwFmtFld* pFmtFld = aIter.First(); pFmtFld; pFmtFld = aIter.Next() )
1349 {
1350 const SwTxtFld* pTxtFld = pFmtFld->GetTxtFld();
1351 if(!pTxtFld)
1352 continue;
1353 const SwTxtNode& rTxtNode = pTxtFld->GetTxtNode();
1354 ::SetProgressState( 0, pDoc->GetDocShell() );
1355
1356 if( rTxtNode.GetTxt().Len() && rTxtNode.getLayoutFrm( pDoc->GetCurrentLayout() ) &&
1357 rTxtNode.GetNodes().IsDocNodes() &&
1358 ( !IsFromChapter() ||
1359 ::lcl_FindChapterNode( rTxtNode, 0 ) == pOwnChapterNode ) )
1360 {
1361 SwTOXPara * pNew = new SwTOXPara( rTxtNode, nsSwTOXElement::TOX_SEQUENCE, 1 );
1362 //set indexes if the number or the reference text are to be displayed
1363 if( GetCaptionDisplay() == CAPTION_TEXT )
1364 {
1365 pNew->SetStartIndex(
1366 SwGetExpField::GetReferenceTextPos( *pFmtFld, *pDoc ));
1367 }
1368 else if(GetCaptionDisplay() == CAPTION_NUMBER)
1369 {
1370 pNew->SetEndIndex(*pTxtFld->GetStart() + 1);
1371 }
1372 InsertSorted(pNew);
1373 }
1374 }
1375 }
1376
UpdateAuthorities(const SwTOXInternational & rIntl)1377 void SwTOXBaseSection::UpdateAuthorities( const SwTOXInternational& rIntl )
1378 {
1379 SwDoc* pDoc = (SwDoc*)GetFmt()->GetDoc();
1380 SwFieldType* pAuthFld = pDoc->GetFldType(RES_AUTHORITY, aEmptyStr, false);
1381 if(!pAuthFld)
1382 return;
1383
1384 SwIterator<SwFmtFld,SwFieldType> aIter( *pAuthFld );
1385 for( SwFmtFld* pFmtFld = aIter.First(); pFmtFld; pFmtFld = aIter.Next() )
1386 {
1387 const SwTxtFld* pTxtFld = pFmtFld->GetTxtFld();
1388 //undo
1389 if(!pTxtFld)
1390 continue;
1391 const SwTxtNode& rTxtNode = pTxtFld->GetTxtNode();
1392 ::SetProgressState( 0, pDoc->GetDocShell() );
1393
1394 // const SwTxtNode* pChapterCompareNode = 0;
1395
1396 if( rTxtNode.GetTxt().Len() && rTxtNode.getLayoutFrm( pDoc->GetCurrentLayout() ) &&
1397 rTxtNode.GetNodes().IsDocNodes() /*&&
1398 (!IsFromChapter() || pChapterCompareNode == pOwnChapterNode) */)
1399 {
1400 //#106485# the body node has to be used!
1401 SwCntntFrm *pFrm = rTxtNode.getLayoutFrm( pDoc->GetCurrentLayout() );
1402 SwPosition aFldPos(rTxtNode);
1403 const SwTxtNode* pTxtNode = 0;
1404 if(pFrm && !pFrm->IsInDocBody())
1405 pTxtNode = GetBodyTxtNode( *pDoc, aFldPos, *pFrm );
1406 if(!pTxtNode)
1407 pTxtNode = &rTxtNode;
1408 SwTOXAuthority* pNew = new SwTOXAuthority( *pTxtNode, *pFmtFld, rIntl );
1409
1410 InsertSorted(pNew);
1411 }
1412 }
1413 }
1414
lcl_IsSOObject(const SvGlobalName & rFactoryNm)1415 long lcl_IsSOObject( const SvGlobalName& rFactoryNm )
1416 {
1417 static struct _SoObjType {
1418 long nFlag;
1419 // GlobalNameId
1420 struct _GlobalNameIds {
1421 sal_uInt32 n1;
1422 sal_uInt16 n2, n3;
1423 sal_uInt8 b8, b9, b10, b11, b12, b13, b14, b15;
1424 } aGlNmIds[4];
1425 } aArr[] = {
1426 { nsSwTOOElements::TOO_MATH,
1427 { {SO3_SM_CLASSID_60},{SO3_SM_CLASSID_50},
1428 {SO3_SM_CLASSID_40},{SO3_SM_CLASSID_30} } },
1429 { nsSwTOOElements::TOO_CHART,
1430 { {SO3_SCH_CLASSID_60},{SO3_SCH_CLASSID_50},
1431 {SO3_SCH_CLASSID_40},{SO3_SCH_CLASSID_30} } },
1432 { nsSwTOOElements::TOO_CALC,
1433 { {SO3_SC_CLASSID_60},{SO3_SC_CLASSID_50},
1434 {SO3_SC_CLASSID_40},{SO3_SC_CLASSID_30} } },
1435 { nsSwTOOElements::TOO_DRAW_IMPRESS,
1436 { {SO3_SIMPRESS_CLASSID_60},{SO3_SIMPRESS_CLASSID_50},
1437 {SO3_SIMPRESS_CLASSID_40},{SO3_SIMPRESS_CLASSID_30} } },
1438 { nsSwTOOElements::TOO_DRAW_IMPRESS,
1439 { {SO3_SDRAW_CLASSID_60},{SO3_SDRAW_CLASSID_50}}},
1440 { 0,{{0,0,0,0,0,0,0,0,0,0,0},{0,0,0,0,0,0,0,0,0,0,0},
1441 {0,0,0,0,0,0,0,0,0,0,0},{0,0,0,0,0,0,0,0,0,0,0} } }
1442 };
1443
1444 long nRet = 0;
1445 for( const _SoObjType* pArr = aArr; !nRet && pArr->nFlag; ++pArr )
1446 for ( int n = 0; n < 4; ++n )
1447 {
1448 const _SoObjType::_GlobalNameIds& rId = pArr->aGlNmIds[ n ];
1449 if( !rId.n1 )
1450 break;
1451 SvGlobalName aGlbNm( rId.n1, rId.n2, rId.n3,
1452 rId.b8, rId.b9, rId.b10, rId.b11,
1453 rId.b12, rId.b13, rId.b14, rId.b15 );
1454 if( rFactoryNm == aGlbNm )
1455 {
1456 nRet = pArr->nFlag;
1457 break;
1458 }
1459 }
1460
1461 return nRet;
1462 }
1463
UpdateCntnt(SwTOXElement eMyType,const SwTxtNode * pOwnChapterNode)1464 void SwTOXBaseSection::UpdateCntnt( SwTOXElement eMyType,
1465 const SwTxtNode* pOwnChapterNode )
1466 {
1467 SwDoc* pDoc = (SwDoc*)GetFmt()->GetDoc();
1468 SwNodes& rNds = pDoc->GetNodes();
1469 // auf den 1. Node der 1. Section
1470 sal_uLong nIdx = rNds.GetEndOfAutotext().StartOfSectionIndex() + 2,
1471 nEndIdx = rNds.GetEndOfAutotext().GetIndex();
1472
1473 while( nIdx < nEndIdx )
1474 {
1475 ::SetProgressState( 0, pDoc->GetDocShell() );
1476
1477 SwNode* pNd = rNds[ nIdx ];
1478 SwCntntNode* pCNd = 0;
1479 switch( eMyType )
1480 {
1481 case nsSwTOXElement::TOX_FRAME:
1482 if( !pNd->IsNoTxtNode() )
1483 {
1484 pCNd = pNd->GetCntntNode();
1485 if( !pCNd )
1486 {
1487 SwNodeIndex aTmp( *pNd );
1488 pCNd = rNds.GoNext( &aTmp );
1489 }
1490 }
1491 break;
1492 case nsSwTOXElement::TOX_GRAPHIC:
1493 if( pNd->IsGrfNode() )
1494 pCNd = (SwCntntNode*)pNd;
1495 break;
1496 case nsSwTOXElement::TOX_OLE:
1497 if( pNd->IsOLENode() )
1498 {
1499 sal_Bool bInclude = sal_True;
1500 if(TOX_OBJECTS == SwTOXBase::GetType())
1501 {
1502 SwOLENode* pOLENode = pNd->GetOLENode();
1503 long nMyOLEOptions = GetOLEOptions();
1504 SwOLEObj& rOLEObj = pOLENode->GetOLEObj();
1505
1506 if( rOLEObj.IsOleRef() ) //Noch nicht geladen
1507 {
1508 SvGlobalName aTmpName = SvGlobalName( rOLEObj.GetOleRef()->getClassID() );
1509 long nObj = ::lcl_IsSOObject( aTmpName );
1510 bInclude = ( (nMyOLEOptions & nsSwTOOElements::TOO_OTHER) && 0 == nObj)
1511 || (0 != (nMyOLEOptions & nObj));
1512 }
1513 else
1514 {
1515 DBG_ERROR("OLE-object nicht geladen?");
1516 bInclude = sal_False;
1517 }
1518 }
1519
1520 if(bInclude)
1521 pCNd = (SwCntntNode*)pNd;
1522 }
1523 break;
1524 default: break;
1525 }
1526
1527 if( pCNd )
1528 {
1529 //find node in body text
1530 int nSetLevel = USHRT_MAX;
1531
1532 //#111105# tables of tables|illustrations|objects don't support hierarchies
1533 if( IsLevelFromChapter() &&
1534 TOX_TABLES != SwTOXBase::GetType() &&
1535 TOX_ILLUSTRATIONS != SwTOXBase::GetType() &&
1536 TOX_OBJECTS != SwTOXBase::GetType() )
1537 {
1538 const SwTxtNode* pOutlNd = ::lcl_FindChapterNode( *pCNd,
1539 MAXLEVEL - 1 );
1540 if ( pOutlNd )
1541 {
1542 if ( pOutlNd->GetTxtColl()->IsAssignedToListLevelOfOutlineStyle() )
1543 {
1544 nSetLevel = pOutlNd->GetTxtColl()->GetAttrOutlineLevel();
1545 }
1546 }
1547 }
1548
1549 if ( pCNd->getLayoutFrm( pDoc->GetCurrentLayout() ) && ( !IsFromChapter() ||
1550 ::lcl_FindChapterNode( *pCNd, 0 ) == pOwnChapterNode ) )
1551 {
1552 SwTOXPara * pNew =
1553 new SwTOXPara(
1554 *pCNd,
1555 eMyType,
1556 ( USHRT_MAX != nSetLevel ) ? static_cast< sal_uInt16 >( nSetLevel ) : FORM_ALPHA_DELIMITTER );
1557 InsertSorted( pNew );
1558 }
1559 }
1560
1561 nIdx = pNd->StartOfSectionNode()->EndOfSectionIndex() + 2; // 2 == End-/StartNode
1562 }
1563 }
1564
1565 /*--------------------------------------------------------------------
1566 Beschreibung: Tabelleneintraege zusammensuchen
1567 --------------------------------------------------------------------*/
1568
UpdateTable(const SwTxtNode * pOwnChapterNode)1569 void SwTOXBaseSection::UpdateTable( const SwTxtNode* pOwnChapterNode )
1570 {
1571 SwDoc* pDoc = (SwDoc*)GetFmt()->GetDoc();
1572 SwNodes& rNds = pDoc->GetNodes();
1573 const SwFrmFmts& rArr = *pDoc->GetTblFrmFmts();
1574
1575 for( sal_uInt16 n = 0; n < rArr.Count(); ++n )
1576 {
1577 ::SetProgressState( 0, pDoc->GetDocShell() );
1578
1579 SwTable* pTmpTbl = SwTable::FindTable( rArr[ n ] );
1580 SwTableBox* pFBox;
1581 if( pTmpTbl && 0 != (pFBox = pTmpTbl->GetTabSortBoxes()[0] ) &&
1582 pFBox->GetSttNd() && pFBox->GetSttNd()->GetNodes().IsDocNodes() )
1583 {
1584 const SwTableNode* pTblNd = pFBox->GetSttNd()->FindTableNode();
1585 SwNodeIndex aCntntIdx( *pTblNd, 1 );
1586
1587 SwCntntNode* pCNd;
1588 while (0 != ( pCNd = rNds.GoNext( &aCntntIdx ) ) &&
1589 aCntntIdx.GetIndex() < pTblNd->EndOfSectionIndex())
1590 {
1591 if ( pCNd->getLayoutFrm( pDoc->GetCurrentLayout() )
1592 && ( !IsFromChapter()
1593 || ::lcl_FindChapterNode( *pCNd, 0 ) == pOwnChapterNode ) )
1594 {
1595 SwTOXTable * pNew = new SwTOXTable( *pCNd );
1596 if ( IsLevelFromChapter() && TOX_TABLES != SwTOXBase::GetType() )
1597 {
1598 const SwTxtNode* pOutlNd = ::lcl_FindChapterNode( *pCNd, MAXLEVEL - 1 );
1599 if ( pOutlNd )
1600 {
1601 if ( pOutlNd->GetTxtColl()->IsAssignedToListLevelOfOutlineStyle() )
1602 {
1603 const int nTmp = pOutlNd->GetTxtColl()->GetAttrOutlineLevel();
1604 pNew->SetLevel( static_cast< sal_uInt16 >( nTmp ) );
1605 }
1606 }
1607 }
1608 InsertSorted( pNew );
1609 break;
1610 }
1611 }
1612 }
1613 }
1614 }
1615
1616 /*--------------------------------------------------------------------
1617 Beschreibung: String generieren anhand der Form
1618 SonderZeichen 0-31 und 255 entfernen
1619 --------------------------------------------------------------------*/
1620
lcl_GetNumString(const SwTOXSortTabBase & rBase,sal_Bool bUsePrefix,sal_uInt8 nLevel)1621 String lcl_GetNumString( const SwTOXSortTabBase& rBase, sal_Bool bUsePrefix, sal_uInt8 nLevel )
1622 {
1623 String sRet;
1624
1625 if( !rBase.pTxtMark && rBase.aTOXSources.Count() > 0 )
1626 { // nur wenn es keine Marke ist
1627 const SwTxtNode* pNd = rBase.aTOXSources[0].pNd->GetTxtNode();
1628 if( pNd )
1629 {
1630 const SwNumRule* pRule = pNd->GetNumRule();
1631
1632 if( pRule && pNd->GetActualListLevel() < MAXLEVEL )
1633 sRet = pNd->GetNumString(bUsePrefix, nLevel);
1634 }
1635 }
1636 return sRet;
1637 }
1638
1639 // OD 18.03.2003 #106329# - add parameter <_TOXSectNdIdx> and <_pDefaultPageDesc>
1640 // in order to control, which page description is used, no appropriate one is found.
GenerateText(sal_uInt16 nArrayIdx,sal_uInt16 nCount,SvStringsDtor &,const sal_uInt32 _nTOXSectNdIdx,const SwPageDesc * _pDefaultPageDesc)1641 void SwTOXBaseSection::GenerateText( sal_uInt16 nArrayIdx,
1642 sal_uInt16 nCount,
1643 SvStringsDtor& ,
1644 const sal_uInt32 _nTOXSectNdIdx,
1645 const SwPageDesc* _pDefaultPageDesc )
1646 {
1647 LinkStructArr aLinkArr;
1648 SwDoc* pDoc = (SwDoc*)GetFmt()->GetDoc();
1649 ::SetProgressState( 0, pDoc->GetDocShell() );
1650
1651 //pTOXNd is only set at the first mark
1652 SwTxtNode* pTOXNd = (SwTxtNode*)aSortArr[nArrayIdx]->pTOXNd;
1653 String& rTxt = (String&)pTOXNd->GetTxt();
1654 rTxt.Erase();
1655 for(sal_uInt16 nIndex = nArrayIdx; nIndex < nArrayIdx + nCount; nIndex++)
1656 {
1657 if(nIndex > nArrayIdx)
1658 rTxt.AppendAscii( RTL_CONSTASCII_STRINGPARAM( ", " )); // comma separation
1659 // String mit dem Pattern aus der Form initialisieren
1660 const SwTOXSortTabBase& rBase = *aSortArr[nIndex];
1661 sal_uInt16 nLvl = rBase.GetLevel();
1662 ASSERT( nLvl < GetTOXForm().GetFormMax(), "ungueltiges FORM_LEVEL");
1663
1664 SvxTabStopItem aTStops( 0, 0, SVX_TAB_ADJUST_DEFAULT, RES_PARATR_TABSTOP );
1665 xub_StrLen nLinkStartPosition = STRING_NOTFOUND;
1666 String sLinkCharacterStyle; //default to "Default" character style - which is none
1667 String sURL;
1668 // create an enumerator
1669 // #i21237#
1670 SwFormTokens aPattern = GetTOXForm().GetPattern(nLvl);
1671 SwFormTokens::iterator aIt = aPattern.begin();
1672 // remove text from node
1673 while(aIt != aPattern.end()) // #i21237#
1674 {
1675 SwFormToken aToken = *aIt; // #i21237#
1676 xub_StrLen nStartCharStyle = rTxt.Len();
1677 switch( aToken.eTokenType )
1678 {
1679 case TOKEN_ENTRY_NO:
1680 // fuer Inhaltsverzeichnis Numerierung
1681 rTxt.Insert( lcl_GetNumString( rBase, aToken.nChapterFormat == CF_NUMBER, static_cast<sal_uInt8>(aToken.nOutlineLevel - 1)) );
1682 break;
1683
1684 case TOKEN_ENTRY_TEXT:
1685 {
1686 SwIndex aIdx( pTOXNd, rTxt.Len() );
1687 rBase.FillText( *pTOXNd, aIdx );
1688 }
1689 break;
1690
1691 case TOKEN_ENTRY:
1692 {
1693 // fuer Inhaltsverzeichnis Numerierung
1694 rTxt.Insert( lcl_GetNumString( rBase, sal_True, MAXLEVEL ));
1695
1696 SwIndex aIdx( pTOXNd, rTxt.Len() );
1697 rBase.FillText( *pTOXNd, aIdx );
1698 }
1699 break;
1700
1701 case TOKEN_TAB_STOP:
1702 if (aToken.bWithTab) // #i21237#
1703 rTxt.Append('\t');
1704 //
1705
1706 if(SVX_TAB_ADJUST_END > aToken.eTabAlign)
1707 {
1708 const SvxLRSpaceItem& rLR =
1709 (SvxLRSpaceItem&)pTOXNd->
1710 SwCntntNode::GetAttr( RES_LR_SPACE, sal_True );
1711
1712 long nTabPosition = aToken.nTabStopPosition;
1713 if( !GetTOXForm().IsRelTabPos() && rLR.GetTxtLeft() )
1714 nTabPosition -= rLR.GetTxtLeft();
1715 aTStops.Insert( SvxTabStop( nTabPosition,
1716 aToken.eTabAlign,
1717 cDfltDecimalChar,
1718 aToken.cTabFillChar ));
1719 }
1720 else
1721 {
1722 const SwPageDesc* pPageDesc = ((SwFmtPageDesc&)pTOXNd->
1723 SwCntntNode::GetAttr( RES_PAGEDESC )).GetPageDesc();
1724
1725 sal_Bool bCallFindRect = sal_True;
1726 long nRightMargin;
1727 if( pPageDesc )
1728 {
1729 const SwFrm* pFrm = pTOXNd->getLayoutFrm( pDoc->GetCurrentLayout(), 0, 0, sal_True );
1730 if( !pFrm || 0 == ( pFrm = pFrm->FindPageFrm() ) ||
1731 pPageDesc != ((SwPageFrm*)pFrm)->GetPageDesc() )
1732 // dann muss man ueber den PageDesc gehen
1733 bCallFindRect = sal_False;
1734 }
1735
1736 SwRect aNdRect;
1737 if( bCallFindRect )
1738 aNdRect = pTOXNd->FindLayoutRect( sal_True );
1739
1740 if( aNdRect.IsEmpty() )
1741 {
1742 // dann hilft alles nichts, wir muessen ueber die Seiten-
1743 // vorlage gehen.
1744 // OD 18.03.2003 #106329# - call
1745 sal_uInt32 nPgDescNdIdx = pTOXNd->GetIndex() + 1;
1746 sal_uInt32* pPgDescNdIdx = &nPgDescNdIdx;
1747 pPageDesc = pTOXNd->FindPageDesc( sal_False, pPgDescNdIdx );
1748 if ( !pPageDesc ||
1749 *pPgDescNdIdx < _nTOXSectNdIdx )
1750 {
1751 // use default page description, if none is found
1752 // or the found one is given by a node before the
1753 // table-of-content section.
1754 pPageDesc = _pDefaultPageDesc;
1755 }
1756
1757 const SwFrmFmt& rPgDscFmt = pPageDesc->GetMaster();
1758 nRightMargin = rPgDscFmt.GetFrmSize().GetWidth() -
1759 rPgDscFmt.GetLRSpace().GetLeft() -
1760 rPgDscFmt.GetLRSpace().GetRight();
1761 }
1762 else
1763 nRightMargin = aNdRect.Width();
1764 //#i24363# tab stops relative to indent
1765 if( pDoc->get(IDocumentSettingAccess::TABS_RELATIVE_TO_INDENT) )
1766 {
1767 //left margin of paragraph style
1768 const SvxLRSpaceItem& rLRSpace = pTOXNd->GetTxtColl()->GetLRSpace();
1769 nRightMargin -= rLRSpace.GetLeft();
1770 nRightMargin -= rLRSpace.GetTxtFirstLineOfst();
1771 }
1772
1773 aTStops.Insert( SvxTabStop( nRightMargin, SVX_TAB_ADJUST_RIGHT,
1774 cDfltDecimalChar,
1775 aToken.cTabFillChar ));
1776 }
1777 break;
1778
1779 case TOKEN_TEXT:
1780 rTxt.Append( aToken.sText );
1781 break;
1782
1783 case TOKEN_PAGE_NUMS:
1784 // Platzhalter fuer Seitennummer(n) es wird nur der erste beachtet
1785 //
1786 {
1787 // Die Anzahl der gleichen Eintrage bestimmt die Seitennummern-Pattern
1788 //
1789 sal_uInt16 nSize = rBase.aTOXSources.Count();
1790 if( nSize > 0 )
1791 {
1792 String aInsStr( cNumRepl );
1793 for(sal_uInt16 i=1; i < nSize; ++i)
1794 {
1795 aInsStr.AppendAscii( sPageDeli );
1796 aInsStr += cNumRepl;
1797 }
1798 aInsStr += cEndPageNum;
1799 rTxt.Append( aInsStr );
1800 }
1801 // // Tab entfernen, wenn keine Seitennummer
1802 // else if( rTxt.Len() && '\t' == rTxt.GetChar( rTxt.Len() - 1 ))
1803 // rTxt.Erase( rTxt.Len()-1, 1 );
1804 }
1805 break;
1806
1807 case TOKEN_CHAPTER_INFO:
1808 {
1809 // ein bischen trickreich: suche irgend einen Frame
1810 const SwTOXSource* pTOXSource = 0;
1811 if(rBase.aTOXSources.Count())
1812 pTOXSource = &rBase.aTOXSources[0];
1813
1814 // --> OD 2008-02-14 #i53420#
1815 // if( pTOXSource && pTOXSource->pNd
1816 // pTOXSource->pNd->IsTxtNode() )
1817 if ( pTOXSource && pTOXSource->pNd &&
1818 pTOXSource->pNd->IsCntntNode() )
1819 // <--
1820 {
1821 const SwCntntFrm* pFrm = pTOXSource->pNd->getLayoutFrm( pDoc->GetCurrentLayout() );
1822 if( pFrm )
1823 {
1824 SwChapterFieldType aFldTyp;
1825 SwChapterField aFld( &aFldTyp, aToken.nChapterFormat );
1826 aFld.SetLevel( static_cast<sal_uInt8>(aToken.nOutlineLevel - 1) );
1827 // --> OD 2008-02-14 #i53420#
1828 // aFld.ChangeExpansion( pFrm, (SwTxtNode*)pTOXSource->pNd, sal_True );
1829 aFld.ChangeExpansion( pFrm,
1830 dynamic_cast<const SwCntntNode*>(pTOXSource->pNd),
1831 sal_True );
1832 // <--
1833 //---> i89791
1834 // OD 2008-06-26 - continue to support CF_NUMBER
1835 // and CF_NUM_TITLE in order to handle ODF 1.0/1.1
1836 // written by OOo 3.x in the same way as OOo 2.x
1837 // would handle them.
1838 if ( CF_NUM_NOPREPST_TITLE == aToken.nChapterFormat ||
1839 CF_NUMBER == aToken.nChapterFormat )
1840 rTxt.Insert(aFld.GetNumber()); //get the string number without pre/postfix
1841 else if ( CF_NUMBER_NOPREPST == aToken.nChapterFormat ||
1842 CF_NUM_TITLE == aToken.nChapterFormat )
1843 //<---
1844 {
1845 rTxt += aFld.GetNumber();
1846 rTxt += ' ';
1847 rTxt += aFld.GetTitle();
1848 }
1849 else if(CF_TITLE == aToken.nChapterFormat)
1850 rTxt += aFld.GetTitle();
1851 }
1852 }
1853 }
1854 break;
1855
1856 case TOKEN_LINK_START:
1857 nLinkStartPosition = rTxt.Len();
1858 sLinkCharacterStyle = aToken.sCharStyleName;
1859 break;
1860
1861 case TOKEN_LINK_END:
1862 //TODO: only paired start/end tokens are valid
1863 if( STRING_NOTFOUND != nLinkStartPosition)
1864 {
1865 SwIndex aIdx( pTOXNd, nLinkStartPosition );
1866 //pTOXNd->Erase( aIdx, SwForm::nFormLinkSttLen );
1867 xub_StrLen nEnd = rTxt.Len();
1868
1869 if( !sURL.Len() )
1870 {
1871 sURL = rBase.GetURL();
1872 if( !sURL.Len() )
1873 break;
1874 }
1875 LinkStruct* pNewLink = new LinkStruct(sURL, nLinkStartPosition,
1876 nEnd);
1877 const sal_uInt16 nPoolId =
1878 sLinkCharacterStyle.Len() == 0
1879 ? USHRT_MAX
1880 : SwStyleNameMapper::GetPoolIdFromUIName( sLinkCharacterStyle, nsSwGetPoolIdFromName::GET_POOLID_CHRFMT );
1881 pNewLink->aINetFmt.SetVisitedFmtAndId( sLinkCharacterStyle, nPoolId );
1882 pNewLink->aINetFmt.SetINetFmtAndId( sLinkCharacterStyle, nPoolId );
1883 aLinkArr.Insert( pNewLink, aLinkArr.Count() );
1884 nLinkStartPosition = STRING_NOTFOUND;
1885 sLinkCharacterStyle.Erase();
1886 }
1887 break;
1888
1889 case TOKEN_AUTHORITY:
1890 {
1891 ToxAuthorityField eField = (ToxAuthorityField)aToken.nAuthorityField;
1892 SwIndex aIdx( pTOXNd, rTxt.Len() );
1893 rBase.FillText( *pTOXNd, aIdx, static_cast<sal_uInt16>(eField) );
1894 }
1895 break;
1896 case TOKEN_END: break;
1897 }
1898
1899 if( aToken.sCharStyleName.Len() )
1900 {
1901 SwCharFmt* pCharFmt;
1902 if( USHRT_MAX != aToken.nPoolId )
1903 pCharFmt = pDoc->GetCharFmtFromPool( aToken.nPoolId );
1904 else
1905 pCharFmt = pDoc->FindCharFmtByName( aToken.sCharStyleName);
1906
1907 if (pCharFmt)
1908 {
1909 SwFmtCharFmt aFmt( pCharFmt );
1910 pTOXNd->InsertItem( aFmt, nStartCharStyle,
1911 rTxt.Len(), nsSetAttrMode::SETATTR_DONTEXPAND );
1912 }
1913 }
1914
1915 aIt++; // #i21237#
1916 }
1917
1918 pTOXNd->SetAttr( aTStops );
1919 }
1920
1921 if(aLinkArr.Count())
1922 for(sal_uInt16 i = 0; i < aLinkArr.Count(); ++i )
1923 {
1924 LinkStruct* pTmp = aLinkArr.GetObject(i);
1925 pTOXNd->InsertItem( pTmp->aINetFmt, pTmp->nStartTextPos,
1926 pTmp->nEndTextPos);
1927 }
1928 }
1929
1930 /*--------------------------------------------------------------------
1931 Beschreibung: Seitennummer errechnen und nach dem Formatieren
1932 eintragen
1933 --------------------------------------------------------------------*/
1934
UpdatePageNum()1935 void SwTOXBaseSection::UpdatePageNum()
1936 {
1937 if( !aSortArr.Count() )
1938 return ;
1939
1940 // die aktuellen Seitennummern ins Verzeichnis eintragen
1941 SwPageFrm* pAktPage = 0;
1942 sal_uInt16 nPage = 0;
1943 SwDoc* pDoc = (SwDoc*)GetFmt()->GetDoc();
1944
1945 SwTOXInternational aIntl( GetLanguage(),
1946 TOX_INDEX == GetTOXType()->GetType() ?
1947 GetOptions() : 0,
1948 GetSortAlgorithm() );
1949
1950 for( sal_uInt16 nCnt = 0; nCnt < aSortArr.Count(); ++nCnt )
1951 {
1952 // Schleife ueber alle SourceNodes
1953 SvUShorts aNums; //Die Seitennummern
1954 SvPtrarr aDescs; //Die PageDescriptoren passend zu den Seitennummern.
1955 SvUShorts* pMainNums = 0; // contains page numbers of main entries
1956
1957 // process run in lines
1958 sal_uInt16 nRange = 0;
1959 if(GetTOXForm().IsCommaSeparated() &&
1960 aSortArr[nCnt]->GetType() == TOX_SORT_INDEX)
1961 {
1962 const SwTOXMark& rMark = aSortArr[nCnt]->pTxtMark->GetTOXMark();
1963 const String sPrimKey = rMark.GetPrimaryKey();
1964 const String sSecKey = rMark.GetSecondaryKey();
1965 const SwTOXMark* pNextMark = 0;
1966 while(aSortArr.Count() > (nCnt + nRange)&&
1967 aSortArr[nCnt + nRange]->GetType() == TOX_SORT_INDEX &&
1968 0 != (pNextMark = &(aSortArr[nCnt + nRange]->pTxtMark->GetTOXMark())) &&
1969 pNextMark->GetPrimaryKey() == sPrimKey &&
1970 pNextMark->GetSecondaryKey() == sSecKey)
1971 nRange++;
1972 }
1973 else
1974 nRange = 1;
1975
1976 for(sal_uInt16 nRunInEntry = nCnt; nRunInEntry < nCnt + nRange; nRunInEntry++)
1977 {
1978 SwTOXSortTabBase* pSortBase = aSortArr[nRunInEntry];
1979 sal_uInt16 nSize = pSortBase->aTOXSources.Count();
1980 sal_uInt16 i;
1981 for( sal_uInt16 j = 0; j < nSize; ++j )
1982 {
1983 ::SetProgressState( 0, pDoc->GetDocShell() );
1984
1985 SwTOXSource& rTOXSource = pSortBase->aTOXSources[j];
1986 if( rTOXSource.pNd )
1987 {
1988 SwCntntFrm* pFrm = rTOXSource.pNd->getLayoutFrm( pDoc->GetCurrentLayout() );
1989 ASSERT( pFrm || pDoc->IsUpdateTOX(), "TOX, no Frame found");
1990 if( !pFrm )
1991 continue;
1992 if( pFrm->IsTxtFrm() && ((SwTxtFrm*)pFrm)->HasFollow() )
1993 {
1994 // dann suche den richtigen heraus
1995 SwTxtFrm* pNext = (SwTxtFrm*)pFrm;
1996 while( 0 != ( pNext = (SwTxtFrm*)pFrm->GetFollow() )
1997 && rTOXSource.nPos >= pNext->GetOfst() )
1998 pFrm = pNext;
1999 }
2000
2001 SwPageFrm* pTmpPage = pFrm->FindPageFrm();
2002 if( pTmpPage != pAktPage )
2003 {
2004 nPage = pTmpPage->GetVirtPageNum();
2005 pAktPage = pTmpPage;
2006 }
2007
2008 // sortiert einfuegen
2009 for( i = 0; i < aNums.Count() && aNums[i] < nPage; ++i )
2010 ;
2011
2012 if( i >= aNums.Count() || aNums[ i ] != nPage )
2013 {
2014 aNums.Insert( nPage, i );
2015 aDescs.Insert( (void*)pAktPage->GetPageDesc(), i );
2016 }
2017 // is it a main entry?
2018 if(TOX_SORT_INDEX == pSortBase->GetType() &&
2019 rTOXSource.bMainEntry)
2020 {
2021 if(!pMainNums)
2022 pMainNums = new SvUShorts;
2023 pMainNums->Insert(nPage, pMainNums->Count());
2024 }
2025 }
2026 }
2027 // einfuegen der Seitennummer in den Verzeichnis-Text-Node
2028 const SwTOXSortTabBase* pBase = aSortArr[ nCnt ];
2029 if(pBase->pTOXNd)
2030 {
2031 const SwTxtNode* pTxtNd = pBase->pTOXNd->GetTxtNode();
2032 ASSERT( pTxtNd, "kein TextNode, falsches Verzeichnis" );
2033
2034 _UpdatePageNum( (SwTxtNode*)pTxtNd, aNums, aDescs, pMainNums,
2035 aIntl );
2036 }
2037 DELETEZ(pMainNums);
2038 aNums.Remove(0, aNums.Count());
2039 }
2040 }
2041 // nach dem Setzen der richtigen Seitennummer, das Mapping-Array
2042 // wieder loeschen !!
2043 aSortArr.DeleteAndDestroy( 0, aSortArr.Count() );
2044 }
2045
2046
2047 /*--------------------------------------------------------------------
2048 Beschreibung: Austausch der Seitennummer-Platzhalter
2049 --------------------------------------------------------------------*/
2050
2051 // search for the page no in the array of main entry page numbers
lcl_HasMainEntry(const SvUShorts * pMainEntryNums,sal_uInt16 nToFind)2052 sal_Bool lcl_HasMainEntry( const SvUShorts* pMainEntryNums, sal_uInt16 nToFind )
2053 {
2054 for(sal_uInt16 i = 0; pMainEntryNums && i < pMainEntryNums->Count(); ++i)
2055 if(nToFind == (*pMainEntryNums)[i])
2056 return sal_True;
2057 return sal_False;
2058 }
2059
_UpdatePageNum(SwTxtNode * pNd,const SvUShorts & rNums,const SvPtrarr & rDescs,const SvUShorts * pMainEntryNums,const SwTOXInternational & rIntl)2060 void SwTOXBaseSection::_UpdatePageNum( SwTxtNode* pNd,
2061 const SvUShorts& rNums,
2062 const SvPtrarr & rDescs,
2063 const SvUShorts* pMainEntryNums,
2064 const SwTOXInternational& rIntl )
2065 {
2066 //collect starts end ends of main entry character style
2067 SvUShorts* pCharStyleIdx = pMainEntryNums ? new SvUShorts : 0;
2068
2069 String sSrchStr( cNumRepl );
2070 sSrchStr.AppendAscii( sPageDeli ) += cNumRepl;
2071 xub_StrLen nStartPos = pNd->GetTxt().Search( sSrchStr );
2072 ( sSrchStr = cNumRepl ) += cEndPageNum;
2073 xub_StrLen nEndPos = pNd->GetTxt().Search( sSrchStr );
2074 sal_uInt16 i;
2075
2076 if( STRING_NOTFOUND == nEndPos || !rNums.Count() )
2077 return;
2078
2079 if( STRING_NOTFOUND == nStartPos || nStartPos > nEndPos)
2080 nStartPos = nEndPos;
2081
2082 sal_uInt16 nOld = rNums[0],
2083 nBeg = nOld,
2084 nCount = 0;
2085 String aNumStr( SvxNumberType( ((SwPageDesc*)rDescs[0])->GetNumType() ).
2086 GetNumStr( nBeg ) );
2087 if( pCharStyleIdx && lcl_HasMainEntry( pMainEntryNums, nBeg ))
2088 {
2089 sal_uInt16 nTemp = 0;
2090 pCharStyleIdx->Insert( nTemp, pCharStyleIdx->Count());
2091 }
2092
2093 // Platzhalter loeschen
2094 SwIndex aPos(pNd, nStartPos);
2095 SwCharFmt* pPageNoCharFmt = 0;
2096 SwpHints* pHints = pNd->GetpSwpHints();
2097 if(pHints)
2098 for(sal_uInt16 nHintIdx = 0; nHintIdx < pHints->GetStartCount(); nHintIdx++)
2099 {
2100 SwTxtAttr* pAttr = pHints->GetStart(nHintIdx);
2101 const xub_StrLen nTmpEnd = pAttr->End() ? *pAttr->End() : 0;
2102 if( nStartPos >= *pAttr->GetStart() &&
2103 (nStartPos + 2) <= nTmpEnd &&
2104 pAttr->Which() == RES_TXTATR_CHARFMT)
2105 {
2106 pPageNoCharFmt = pAttr->GetCharFmt().GetCharFmt();
2107 break;
2108 }
2109 }
2110 pNd->EraseText(aPos, nEndPos - nStartPos + 2);
2111
2112 for( i = 1; i < rNums.Count(); ++i)
2113 {
2114 SvxNumberType aType( ((SwPageDesc*)rDescs[i])->GetNumType() );
2115 if( TOX_INDEX == SwTOXBase::GetType() )
2116 { // Zusammenfassen f. ff.
2117 // Alle folgenden aufaddieren
2118 // break up if main entry starts or ends and
2119 // insert a char style index
2120 sal_Bool bMainEntryChanges = lcl_HasMainEntry(pMainEntryNums, nOld)
2121 != lcl_HasMainEntry(pMainEntryNums, rNums[i]);
2122
2123 if(nOld == rNums[i]-1 && !bMainEntryChanges &&
2124 0 != (GetOptions() & (nsSwTOIOptions::TOI_FF|nsSwTOIOptions::TOI_DASH)))
2125 nCount++;
2126 else
2127 {
2128 // ff. f. alten Wert flushen
2129 if(GetOptions() & nsSwTOIOptions::TOI_FF)
2130 {
2131 if ( nCount >= 1 )
2132 aNumStr += rIntl.GetFollowingText( nCount > 1 );
2133 }
2134 else
2135 {
2136 if(nCount >= 2 )
2137 aNumStr += '-';
2138 else if(nCount == 1 )
2139 aNumStr.AppendAscii( sPageDeli );
2140 //#58127# Wenn nCount == 0, dann steht die einzige Seitenzahl schon im aNumStr!
2141 if(nCount)
2142 aNumStr += aType.GetNumStr( nBeg + nCount );
2143 }
2144
2145 // neuen String anlegen
2146 nBeg = rNums[i];
2147 aNumStr.AppendAscii( sPageDeli );
2148 //the change of the character style must apply after sPageDeli is appended
2149 if(pCharStyleIdx && bMainEntryChanges)
2150 pCharStyleIdx->Insert(aNumStr.Len(),
2151 pCharStyleIdx->Count());
2152 aNumStr += aType.GetNumStr( nBeg );
2153 nCount = 0;
2154 }
2155 nOld = rNums[i];
2156 }
2157 else
2158 { // Alle Nummern eintragen
2159 aNumStr += aType.GetNumStr( sal_uInt16(rNums[i]) );
2160 if(i != (rNums.Count()-1))
2161 aNumStr.AppendAscii( sPageDeli );
2162 }
2163 }
2164 // Bei Ende und ff. alten Wert flushen
2165 if( TOX_INDEX == SwTOXBase::GetType() )
2166 {
2167 if(GetOptions() & nsSwTOIOptions::TOI_FF)
2168 {
2169 if( nCount >= 1 )
2170 aNumStr += rIntl.GetFollowingText( nCount > 1 );
2171 }
2172 else
2173 {
2174 if(nCount >= 2)
2175 aNumStr +='-';
2176 else if(nCount == 1)
2177 aNumStr.AppendAscii( sPageDeli );
2178 //#58127# Wenn nCount == 0, dann steht die einzige Seitenzahl schon im aNumStr!
2179 if(nCount)
2180 aNumStr += SvxNumberType( ((SwPageDesc*)rDescs[i-1])->
2181 GetNumType() ).GetNumStr( nBeg+nCount );
2182 }
2183 }
2184 pNd->InsertText( aNumStr, aPos,
2185 static_cast<IDocumentContentOperations::InsertFlags>(
2186 IDocumentContentOperations::INS_EMPTYEXPAND |
2187 IDocumentContentOperations::INS_FORCEHINTEXPAND) );
2188 if(pPageNoCharFmt)
2189 {
2190 SwFmtCharFmt aCharFmt( pPageNoCharFmt );
2191 pNd->InsertItem(aCharFmt, nStartPos, nStartPos + aNumStr.Len(), nsSetAttrMode::SETATTR_DONTEXPAND);
2192 }
2193
2194 //now the main entries should get there character style
2195 if(pCharStyleIdx && pCharStyleIdx->Count() && GetMainEntryCharStyle().Len())
2196 {
2197 // eventually the last index must me appended
2198 if(pCharStyleIdx->Count()&0x01)
2199 pCharStyleIdx->Insert(aNumStr.Len(), pCharStyleIdx->Count());
2200
2201 //search by name
2202 SwDoc* pDoc = pNd->GetDoc();
2203 sal_uInt16 nPoolId = SwStyleNameMapper::GetPoolIdFromUIName( GetMainEntryCharStyle(), nsSwGetPoolIdFromName::GET_POOLID_CHRFMT );
2204 SwCharFmt* pCharFmt = 0;
2205 if(USHRT_MAX != nPoolId)
2206 pCharFmt = pDoc->GetCharFmtFromPool(nPoolId);
2207 else
2208 pCharFmt = pDoc->FindCharFmtByName( GetMainEntryCharStyle() );
2209 if(!pCharFmt)
2210 pCharFmt = pDoc->MakeCharFmt(GetMainEntryCharStyle(), 0);
2211
2212 //find the page numbers in aNumStr and set the character style
2213 xub_StrLen nOffset = pNd->GetTxt().Len() - aNumStr.Len();
2214 SwFmtCharFmt aCharFmt(pCharFmt);
2215 for(sal_uInt16 j = 0; j < pCharStyleIdx->Count(); j += 2)
2216 {
2217 xub_StrLen nStartIdx = (*pCharStyleIdx)[j] + nOffset;
2218 xub_StrLen nEndIdx = (*pCharStyleIdx)[j + 1] + nOffset;
2219 pNd->InsertItem(aCharFmt, nStartIdx, nEndIdx, nsSetAttrMode::SETATTR_DONTEXPAND);
2220 }
2221
2222 }
2223 delete pCharStyleIdx;
2224 }
2225
2226
2227 /*--------------------------------------------------------------------
2228 Beschreibung: Sortiert einfuegen in das SortArr
2229 --------------------------------------------------------------------*/
2230
InsertSorted(SwTOXSortTabBase * pNew)2231 void SwTOXBaseSection::InsertSorted(SwTOXSortTabBase* pNew)
2232 {
2233 Range aRange(0, aSortArr.Count());
2234 if( TOX_INDEX == SwTOXBase::GetType() && pNew->pTxtMark )
2235 {
2236 const SwTOXMark& rMark = pNew->pTxtMark->GetTOXMark();
2237 // Schluessel auswerten
2238 // Den Bereich ermitteln, in dem einzufuegen ist
2239 if( 0 == (GetOptions() & nsSwTOIOptions::TOI_KEY_AS_ENTRY) &&
2240 rMark.GetPrimaryKey().Len() )
2241 {
2242 aRange = GetKeyRange( rMark.GetPrimaryKey(),
2243 rMark.GetPrimaryKeyReading(),
2244 *pNew, FORM_PRIMARY_KEY, aRange );
2245
2246 if( rMark.GetSecondaryKey().Len() )
2247 aRange = GetKeyRange( rMark.GetSecondaryKey(),
2248 rMark.GetSecondaryKeyReading(),
2249 *pNew, FORM_SECONDARY_KEY, aRange );
2250 }
2251 }
2252 //search for identical entries and remove the trailing one
2253 if(TOX_AUTHORITIES == SwTOXBase::GetType())
2254 {
2255 for(short i = (short)aRange.Min(); i < (short)aRange.Max(); ++i)
2256 {
2257 SwTOXSortTabBase* pOld = aSortArr[i];
2258 if(*pOld == *pNew)
2259 {
2260 if(*pOld < *pNew)
2261 {
2262 delete pNew;
2263 return;
2264 }
2265 else
2266 {
2267 // remove the old content
2268 aSortArr.DeleteAndDestroy( i, 1 );
2269 aRange.Max()--;
2270 break;
2271 }
2272 }
2273 }
2274 }
2275
2276 // find position and insert
2277 //
2278 short i;
2279
2280 for( i = (short)aRange.Min(); i < (short)aRange.Max(); ++i)
2281 { // nur auf gleicher Ebene pruefen
2282 //
2283 SwTOXSortTabBase* pOld = aSortArr[i];
2284 if(*pOld == *pNew)
2285 {
2286 if(TOX_AUTHORITIES != SwTOXBase::GetType())
2287 {
2288 // Eigener Eintrag fuer Doppelte oder Keywords
2289 //
2290 if( pOld->GetType() == TOX_SORT_CUSTOM &&
2291 pNew->GetOptions() & nsSwTOIOptions::TOI_KEY_AS_ENTRY)
2292 continue;
2293
2294 if(!(pNew->GetOptions() & nsSwTOIOptions::TOI_SAME_ENTRY))
2295 { // Eigener Eintrag
2296 aSortArr.Insert(pNew, i );
2297 return;
2298 }
2299 // Eintrag schon vorhanden in Referenzliste aufnehmen
2300 pOld->aTOXSources.Insert( pNew->aTOXSources[0],
2301 pOld->aTOXSources.Count() );
2302
2303 delete pNew;
2304 return;
2305 }
2306 #ifdef DBG_UTIL
2307 else
2308 DBG_ERROR("Bibliography entries cannot be found here");
2309 #endif
2310 }
2311 if(*pNew < *pOld)
2312 break;
2313 }
2314 // SubLevel Skippen
2315 while( TOX_INDEX == SwTOXBase::GetType() && i < aRange.Max() &&
2316 aSortArr[i]->GetLevel() > pNew->GetLevel() )
2317 i++;
2318
2319 // An Position i wird eingefuegt
2320 aSortArr.Insert(pNew, i );
2321 }
2322
2323 /*--------------------------------------------------------------------
2324 Beschreibung: Schluessel-Bereich suchen und evtl einfuegen
2325 --------------------------------------------------------------------*/
2326
GetKeyRange(const String & rStr,const String & rStrReading,const SwTOXSortTabBase & rNew,sal_uInt16 nLevel,const Range & rRange)2327 Range SwTOXBaseSection::GetKeyRange(const String& rStr, const String& rStrReading,
2328 const SwTOXSortTabBase& rNew,
2329 sal_uInt16 nLevel, const Range& rRange )
2330 {
2331 const SwTOXInternational& rIntl = *rNew.pTOXIntl;
2332 String sToCompare(rStr);
2333 String sToCompareReading(rStrReading);
2334
2335 if( 0 != (nsSwTOIOptions::TOI_INITIAL_CAPS & GetOptions()) )
2336 {
2337 String sUpper( rIntl.ToUpper( sToCompare, 0 ));
2338 sToCompare.Erase( 0, 1 ).Insert( sUpper, 0 );
2339 }
2340
2341 ASSERT(rRange.Min() >= 0 && rRange.Max() >= 0, "Min Max < 0");
2342
2343 const sal_uInt16 nMin = (sal_uInt16)rRange.Min();
2344 const sal_uInt16 nMax = (sal_uInt16)rRange.Max();
2345
2346 sal_uInt16 i;
2347
2348 for( i = nMin; i < nMax; ++i)
2349 {
2350 SwTOXSortTabBase* pBase = aSortArr[i];
2351
2352 String sMyString, sMyStringReading;
2353 pBase->GetTxt( sMyString, sMyStringReading );
2354
2355 if( rIntl.IsEqual( sMyString, sMyStringReading, pBase->GetLocale(),
2356 sToCompare, sToCompareReading, rNew.GetLocale() ) &&
2357 pBase->GetLevel() == nLevel )
2358 break;
2359 }
2360 if(i == nMax)
2361 { // Falls nicht vorhanden erzeugen und einfuegen
2362 //
2363 SwTOXCustom* pKey = new SwTOXCustom( sToCompare, sToCompareReading, nLevel, rIntl,
2364 rNew.GetLocale() );
2365 for(i = nMin; i < nMax; ++i)
2366 {
2367 if(nLevel == aSortArr[i]->GetLevel() && *pKey < *(aSortArr[i]))
2368 break;
2369 }
2370 aSortArr.Insert(pKey, i );
2371 }
2372 sal_uInt16 nStart = i+1;
2373 sal_uInt16 nEnd = aSortArr.Count();
2374
2375 // Ende des Bereiches suchen
2376 for(i = nStart; i < aSortArr.Count(); ++i)
2377 {
2378 if(aSortArr[i]->GetLevel() <= nLevel)
2379 { nEnd = i;
2380 break;
2381 }
2382 }
2383 return Range(nStart, nEnd);
2384 }
2385
2386
IsTOXBaseInReadonly() const2387 sal_Bool SwTOXBase::IsTOXBaseInReadonly() const
2388 {
2389 const SwTOXBaseSection *pSect = PTR_CAST(SwTOXBaseSection, this);
2390 sal_Bool bRet = sal_False;
2391 const SwSectionNode* pSectNode;
2392 if(pSect && pSect->GetFmt() &&
2393 0 != (pSectNode = pSect->GetFmt()->GetSectionNode()))
2394 {
2395 const SwDocShell* pDocSh;
2396 bRet = (0 != (pDocSh = pSectNode->GetDoc()->GetDocShell()) &&
2397 pDocSh->IsReadOnly()) ||
2398 (0 != (pSectNode = pSectNode->StartOfSectionNode()->FindSectionNode())&&
2399 pSectNode->GetSection().IsProtectFlag());
2400
2401 }
2402 return bRet;
2403 }
2404
GetAttrSet() const2405 const SfxItemSet* SwTOXBase::GetAttrSet() const
2406 {
2407 const SwTOXBaseSection *pSect = PTR_CAST(SwTOXBaseSection, this);
2408 if(pSect && pSect->GetFmt())
2409 return &pSect->GetFmt()->GetAttrSet();
2410 return 0;
2411 }
2412
SetAttrSet(const SfxItemSet & rSet)2413 void SwTOXBase::SetAttrSet( const SfxItemSet& rSet )
2414 {
2415 SwTOXBaseSection *pSect = PTR_CAST(SwTOXBaseSection, this);
2416 if( pSect && pSect->GetFmt() )
2417 pSect->GetFmt()->SetFmtAttr( rSet );
2418 }
2419
GetInfo(SfxPoolItem & rInfo) const2420 sal_Bool SwTOXBase::GetInfo( SfxPoolItem& rInfo ) const
2421 {
2422 switch( rInfo.Which() )
2423 {
2424 case RES_CONTENT_VISIBLE:
2425 {
2426 SwTOXBaseSection *pSect = PTR_CAST(SwTOXBaseSection, this);
2427 if( pSect && pSect->GetFmt() )
2428 pSect->GetFmt()->GetInfo( rInfo );
2429 }
2430 return sal_False;
2431 }
2432 return sal_True;
2433 }
2434
2435