Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 :
21 : #include <ctype.h>
22 : #include <hintids.hxx>
23 : #include <hints.hxx>
24 : #include <vcl/graphicfilter.hxx>
25 :
26 : #include <vcl/graph.hxx>
27 : #include <svl/urihelper.hxx>
28 : #include <editeng/boxitem.hxx>
29 : #include <editeng/wghtitem.hxx>
30 : #include <editeng/cmapitem.hxx>
31 : #include <editeng/contouritem.hxx>
32 : #include <editeng/postitem.hxx>
33 : #include <editeng/crossedoutitem.hxx>
34 : #include <svl/stritem.hxx>
35 : #include <unotools/charclass.hxx>
36 : #include <txtftn.hxx>
37 : #include <fmtpdsc.hxx>
38 : #include <fmtftn.hxx>
39 : #include <fmtanchr.hxx>
40 : #include <fmtrfmrk.hxx>
41 : #include <fmtclds.hxx>
42 : #include <fmtfld.hxx>
43 : #include <fmtfsize.hxx>
44 : #include <fmthdft.hxx>
45 : #include <fmtcntnt.hxx>
46 : #include <redline.hxx>
47 : #include <pam.hxx>
48 : #include <doc.hxx>
49 : #include <ndtxt.hxx>
50 : #include <frmatr.hxx>
51 : #include <fldbas.hxx> // RES_SETEXPFLD
52 : #include <charatr.hxx> // class SwFmtRefMark
53 : #include <swtable.hxx> // class SwTableLines, ...
54 : #include <tox.hxx>
55 : #include <expfld.hxx> // SwExpField
56 : #include <section.hxx> // class SwSection
57 : #include <tblsel.hxx> // class SwSelBoxes
58 : #include <pagedesc.hxx>
59 : #include <docsh.hxx> // class SwDocSh
60 : #include <fltshell.hxx>
61 : #include <viewsh.hxx>
62 : #include <shellres.hxx>
63 :
64 :
65 : using namespace com::sun::star;
66 :
67 14786 : static SwCntntNode* GetCntntNode(SwDoc* pDoc, SwNodeIndex& rIdx, bool bNext)
68 : {
69 14786 : SwCntntNode * pCNd = rIdx.GetNode().GetCntntNode();
70 14786 : if(!pCNd && 0 == (pCNd = bNext ? pDoc->GetNodes().GoNext(&rIdx)
71 0 : : pDoc->GetNodes().GoPrevious(&rIdx)))
72 : {
73 0 : pCNd = bNext ? pDoc->GetNodes().GoPrevious(&rIdx)
74 0 : : pDoc->GetNodes().GoNext(&rIdx);
75 : OSL_ENSURE(pCNd, "kein ContentNode gefunden");
76 : }
77 14786 : return pCNd;
78 : }
79 :
80 : // ------ Stack-Eintrag fuer die gesamten - Attribute vom Text -----------
81 16875 : SwFltStackEntry::SwFltStackEntry(const SwPosition& rStartPos, SfxPoolItem* pHt)
82 : : m_aMkPos(rStartPos)
83 : , m_aPtPos(rStartPos)
84 : , mnStartCP(-1)
85 : , mnEndCP(-1)
86 16875 : , bIsParaEnd(false)
87 : {
88 16875 : pAttr = pHt; // speicher eine Kopie vom Attribut
89 16875 : bOld = sal_False; // used for marking Attributes *before* skipping field results
90 16875 : bOpen = sal_True; // locke das Attribut --> darf erst
91 16875 : bConsumedByField = sal_False;
92 16875 : }
93 :
94 33750 : SwFltStackEntry::~SwFltStackEntry()
95 : {
96 : // Attribut kam zwar als Pointer, wird aber hier geloescht
97 16875 : delete pAttr;
98 16875 : }
99 :
100 17226 : void SwFltStackEntry::SetEndPos(const SwPosition& rEndPos)
101 : {
102 : // Attribut freigeben und das Ende merken.
103 : // Alles mit sal_uInt16's, weil sonst beim Einfuegen von neuem Text an der
104 : // Cursor-Position auch der Bereich vom Attribut weiter
105 : // verschoben wird.
106 : // Das ist aber nicht das gewollte!
107 17226 : bOpen = sal_False; // freigeben und das ENDE merken
108 17226 : m_aPtPos.SetPos(rEndPos);
109 17226 : }
110 :
111 :
112 16270 : bool SwFltStackEntry::MakeRegion(SwDoc* pDoc, SwPaM& rRegion, bool bCheck,
113 : const SwFltPosition &rMkPos, const SwFltPosition &rPtPos, bool bIsParaEnd,
114 : sal_uInt16 nWhich)
115 : {
116 : // does this range actually contain something?
117 : // empty range is allowed if at start of empty paragraph
118 : // fields are special: never have range, so leave them
119 : //
120 : // The only position of 0x0D will not be able to make region in the old logic
121 : // because it is beyond the length of para...need special consideration here.
122 : SwCntntNode *const pCntntNode(
123 16270 : SwNodeIndex(rMkPos.m_nNode, +1).GetNode().GetCntntNode());
124 38218 : if (rMkPos == rPtPos &&
125 10166 : ((0 != rPtPos.m_nCntnt) || (pCntntNode && (0 != pCntntNode->Len())))
126 3071 : && (RES_TXTATR_FIELD != nWhich)
127 19341 : && !(bIsParaEnd && pCntntNode && pCntntNode->IsTxtNode() && 0 != pCntntNode->Len() ))
128 : {
129 2896 : return false;
130 : }
131 : // !!! Die Content-Indizies beziehen sich immer auf den Node !!!
132 13374 : rRegion.GetPoint()->nNode = rMkPos.m_nNode.GetIndex() + 1;
133 13374 : SwCntntNode* pCNd = GetCntntNode(pDoc, rRegion.GetPoint()->nNode, true);
134 13374 : rRegion.GetPoint()->nContent.Assign(pCNd, rMkPos.m_nCntnt);
135 13374 : rRegion.SetMark();
136 13374 : if (rMkPos.m_nNode != rPtPos.m_nNode)
137 : {
138 1338 : rRegion.GetPoint()->nNode = rPtPos.m_nNode.GetIndex() + 1;
139 1338 : pCNd = GetCntntNode(pDoc, rRegion.GetPoint()->nNode, false);
140 : }
141 13374 : rRegion.GetPoint()->nContent.Assign(pCNd, rPtPos.m_nCntnt);
142 : OSL_ENSURE( CheckNodesRange( rRegion.Start()->nNode,
143 : rRegion.End()->nNode, true ),
144 : "atttribute or similar crosses section-boundaries" );
145 13374 : if( bCheck )
146 3 : return CheckNodesRange( rRegion.Start()->nNode,
147 6 : rRegion.End()->nNode, true );
148 : else
149 13371 : return true;
150 : }
151 :
152 16270 : bool SwFltStackEntry::MakeRegion(SwDoc* pDoc, SwPaM& rRegion, bool bCheck) const
153 : {
154 : return MakeRegion(pDoc, rRegion, bCheck, m_aMkPos, m_aPtPos, bIsParaEnd,
155 16270 : pAttr->Which());
156 : }
157 :
158 490 : SwFltControlStack::SwFltControlStack(SwDoc* pDo, sal_uLong nFieldFl)
159 490 : : nFieldFlags(nFieldFl),bHasSdOD(true), bSdODChecked(false), pDoc(pDo), bIsEndStack(false)
160 : {
161 490 : }
162 :
163 :
164 490 : SwFltControlStack::~SwFltControlStack()
165 : {
166 : OSL_ENSURE(maEntries.empty(), "There are still Attributes on the stack");
167 490 : }
168 :
169 : // MoveAttrs() ist fuer folgendes Problem:
170 : // Wenn ueber den Stack ein Feld wie z.B. "Variable setzen" gesetzt wird,
171 : // verschiebt sich der Text um ein \xff - Zeichen, und alle folgenden
172 : // Attribute stimmen in ihrer Position nicht mehr.
173 : // Dann muss MoveAttrs() nach dem Setzen des Attributes ins Doc gerufen werden,
174 : // so dass alle Attribut-Positionen,
175 : // die im selben Absatz weiter hinten stehen, um 1 Zeichen weiter
176 : // nach rechts verschoben werden.
177 0 : void SwFltControlStack::MoveAttrs( const SwPosition& rPos )
178 : {
179 0 : size_t nCnt = maEntries.size();
180 0 : sal_uLong nPosNd = rPos.nNode.GetIndex();
181 0 : sal_uInt16 nPosCt = rPos.nContent.GetIndex() - 1;
182 :
183 0 : for (size_t i=0; i < nCnt; ++i)
184 : {
185 0 : SwFltStackEntry& rEntry = maEntries[i];
186 0 : if (
187 0 : (rEntry.m_aMkPos.m_nNode.GetIndex()+1 == nPosNd) &&
188 0 : (rEntry.m_aMkPos.m_nCntnt >= nPosCt)
189 : )
190 : {
191 0 : rEntry.m_aMkPos.m_nCntnt++;
192 : OSL_ENSURE( rEntry.m_aMkPos.m_nCntnt
193 : <= pDoc->GetNodes()[nPosNd]->GetCntntNode()->Len(),
194 : "Attribut-Anfang hinter Zeilenende" );
195 : }
196 0 : if (
197 0 : (rEntry.m_aPtPos.m_nNode.GetIndex()+1 == nPosNd) &&
198 0 : (rEntry.m_aPtPos.m_nCntnt >= nPosCt)
199 : )
200 : {
201 0 : rEntry.m_aPtPos.m_nCntnt++;
202 : OSL_ENSURE( rEntry.m_aPtPos.m_nCntnt
203 : <= pDoc->GetNodes()[nPosNd]->GetCntntNode()->Len(),
204 : "Attribut-Ende hinter Zeilenende" );
205 : }
206 : }
207 0 : }
208 :
209 18 : void SwFltControlStack::MarkAllAttrsOld()
210 : {
211 18 : size_t nCnt = maEntries.size();
212 124 : for (sal_uInt16 i=0; i < nCnt; ++i)
213 106 : maEntries[i].bOld = sal_True;
214 18 : }
215 :
216 : namespace
217 : {
218 17284 : bool couldExtendEntry(const SwFltStackEntry *pExtendCandidate,
219 : const SfxPoolItem& rAttr)
220 : {
221 2181 : return (pExtendCandidate &&
222 4362 : !pExtendCandidate->bConsumedByField &&
223 : //potentially more, but lets keep it simple
224 22832 : (isPARATR_LIST(rAttr.Which()) || (isCHRATR(rAttr.Which()) && rAttr.Which() != RES_CHRATR_FONT && rAttr.Which() != RES_CHRATR_FONTSIZE)) &&
225 18470 : *(pExtendCandidate->pAttr) == rAttr);
226 : }
227 : }
228 :
229 17284 : void SwFltControlStack::NewAttr(const SwPosition& rPos, const SfxPoolItem& rAttr)
230 : {
231 17284 : sal_uInt16 nWhich = rAttr.Which();
232 : // Ende von evtl. gleichen Attributen auf dem Stack Setzen, damit sich die
233 : // Attribute nicht auf dem Stack haeufen
234 17284 : SwFltStackEntry *pExtendCandidate = SetAttr(rPos, nWhich);
235 17284 : if (couldExtendEntry(pExtendCandidate, rAttr))
236 : {
237 : //Here we optimize by seeing if there is an attribute uncommited
238 : //to the document which
239 : //
240 : //a) has the same value as this attribute
241 : //b) is already open, or ends at the same place as where we're starting
242 : //from. If so we merge it with this one and elide adding another
243 : //to the stack
244 409 : pExtendCandidate->SetEndPos(rPos);
245 409 : pExtendCandidate->bOpen=true;
246 : }
247 : else
248 : {
249 16875 : SwFltStackEntry *pTmp = new SwFltStackEntry(rPos, rAttr.Clone() );
250 16875 : pTmp->SetStartCP(GetCurrAttrCP());
251 16875 : maEntries.push_back(pTmp);
252 : }
253 17284 : }
254 :
255 605 : void SwFltControlStack::DeleteAndDestroy(Entries::size_type nCnt)
256 : {
257 : OSL_ENSURE(nCnt < maEntries.size(), "Out of range!");
258 605 : if (nCnt < maEntries.size())
259 : {
260 605 : myEIter aElement = maEntries.begin() + nCnt;
261 605 : maEntries.erase(aElement);
262 : }
263 : //Clear the para end position recorded in reader intermittently for the least impact on loading performance
264 : //Because the attributes handled based on the unit of para
265 605 : if ( empty() )
266 : {
267 110 : ClearParaEndPosition();
268 110 : bHasSdOD = true;
269 110 : bSdODChecked = false;
270 : }
271 605 : }
272 :
273 : // SwFltControlStack::StealAttr() loescht Attribute des angegebenen Typs vom Stack.
274 : // Als nAttrId sind erlaubt: 0 fuer alle, oder ein spezieller Typ.
275 : // Damit erscheinen sie nicht in der Doc-Struktur. Dabei werden nur die
276 : // Attribute entfernt, die im selben Absatz wie rPos stehen.
277 : // Wird fuer Grafik-Apos -> Grafiken benutzt.
278 0 : void SwFltControlStack::StealAttr(const SwNodeIndex& rNode, sal_uInt16 nAttrId)
279 : {
280 0 : size_t nCnt = maEntries.size();
281 :
282 0 : while (nCnt)
283 : {
284 0 : nCnt --;
285 0 : SwFltStackEntry& rEntry = maEntries[nCnt];
286 0 : if (rEntry.m_aPtPos.m_nNode.GetIndex()+1 == rNode.GetIndex() &&
287 0 : (!nAttrId || nAttrId == rEntry.pAttr->Which()))
288 : {
289 0 : DeleteAndDestroy(nCnt); // loesche aus dem Stack
290 : }
291 : }
292 0 : }
293 :
294 : // SwFltControlStack::KillUnlockedAttr() loescht alle Attribute vom Stack,
295 : // welche punktuell auf rPos aufgespannt sind.
296 : // Damit erscheinen sie nicht in der Doc-Struktur.
297 : // Wird im WW Import benoetigt zum ignorieren der auf dem 0x0c Section-
298 : // Break-Symbol gesetzten Attribute.
299 62 : void SwFltControlStack::KillUnlockedAttrs(const SwPosition& rPos)
300 : {
301 62 : SwFltPosition aFltPos(rPos);
302 :
303 62 : size_t nCnt = maEntries.size();
304 462 : while( nCnt )
305 : {
306 338 : nCnt --;
307 338 : SwFltStackEntry& rEntry = maEntries[nCnt];
308 676 : if( !rEntry.bOld
309 232 : && !rEntry.bOpen
310 127 : && (rEntry.m_aMkPos == aFltPos)
311 450 : && (rEntry.m_aPtPos == aFltPos))
312 : {
313 112 : DeleteAndDestroy( nCnt ); // loesche aus dem Stack
314 : }
315 62 : }
316 62 : }
317 :
318 : // Alle gelockten Attribute freigeben (unlocken) und das Ende setzen,
319 : // alle anderen im Document setzen und wieder aus dem Stack loeschen
320 : // Returned, ob das gesuchte Attribut / die gesuchten Attribute
321 : // ueberhaupt auf dem Stack standen
322 34169 : SwFltStackEntry* SwFltControlStack::SetAttr(const SwPosition& rPos,
323 : sal_uInt16 nAttrId, sal_Bool bTstEnde, long nHand,
324 : sal_Bool consumedByField)
325 : {
326 34169 : SwFltStackEntry *pRet = NULL;
327 :
328 34169 : SwFltPosition aFltPos(rPos);
329 :
330 : OSL_ENSURE(!nAttrId ||
331 : (POOLATTR_BEGIN <= nAttrId && POOLATTR_END > nAttrId) ||
332 : (RES_FLTRATTR_BEGIN <= nAttrId && RES_FLTRATTR_END > nAttrId),
333 : "Falsche Id fuers Attribut");
334 :
335 34169 : myEIter aI = maEntries.begin();
336 747647 : while (aI != maEntries.end())
337 : {
338 679309 : bool bLastEntry = aI == maEntries.end() - 1;
339 :
340 679309 : SwFltStackEntry& rEntry = *aI;
341 679309 : if (rEntry.bOpen)
342 : {
343 : // setze das Ende vom Attribut
344 121518 : bool bF = false;
345 121518 : if (!nAttrId )
346 : {
347 7 : bF = true;
348 : }
349 121511 : else if (nAttrId == rEntry.pAttr->Which())
350 : {
351 16812 : if( nAttrId != RES_FLTR_BOOKMARK )
352 : {
353 : // Handle abfragen
354 16804 : bF = true;
355 : }
356 8 : else if (nHand == ((SwFltBookmark*)(rEntry.pAttr))->GetHandle())
357 : {
358 6 : bF = true;
359 : }
360 : }
361 121518 : if (bF)
362 : {
363 16817 : rEntry.bConsumedByField = consumedByField;
364 16817 : rEntry.SetEndPos(rPos);
365 16817 : rEntry.SetEndCP(GetCurrAttrCP());
366 16817 : if (bLastEntry && nAttrId == rEntry.pAttr->Which())
367 : {
368 : //potential candidate for merging with an identical
369 : //property beginning at rPos
370 5671 : pRet = &rEntry;
371 : }
372 : }
373 121518 : ++aI;
374 121518 : continue;
375 : }
376 :
377 : // ist die Endposition die Cursor-Position, dann noch nicht
378 : // ins Dokument setzen, es muss noch Text folgen;
379 : // ausser am Dokumentende. (Attribut-Expandierung !!)
380 : // Beim Ende-Stack niemals ausser am DocEnde reinsetzen
381 557791 : if (bTstEnde)
382 : {
383 556966 : if (bIsEndStack)
384 : {
385 13 : ++aI;
386 13 : continue;
387 : }
388 :
389 : //defer inserting this attribute into the document until
390 : //we advance to the next node, or finish processing the document
391 556953 : if (rEntry.m_aPtPos.m_nNode.GetIndex() == aFltPos.m_nNode.GetIndex())
392 : {
393 543573 : if (bLastEntry && nAttrId == rEntry.pAttr->Which() &&
394 2065 : rEntry.m_aPtPos.m_nCntnt == aFltPos.m_nCntnt)
395 : {
396 : //potential candidate for merging with an identical
397 : //property beginning at rPos
398 2044 : pRet = &rEntry;
399 : }
400 :
401 541508 : ++aI;
402 541508 : continue;
403 : }
404 : }
405 16270 : SetAttrInDoc(rPos, rEntry);
406 16270 : aI = maEntries.erase(aI);
407 : }
408 :
409 34169 : return pRet;
410 : }
411 :
412 74 : static void MakePoint(const SwFltStackEntry& rEntry, SwDoc* pDoc,
413 : SwPaM& rRegion)
414 : {
415 : // der Anker ist der Point vom Pam. Dieser wird beim Einfugen von Text usw.
416 : // veraendert; darum wird er auf dem Stack gespeichert. Das Attribut muss
417 : // nur noch im Format gesetzt werden.
418 74 : rRegion.DeleteMark();
419 74 : rRegion.GetPoint()->nNode = rEntry.m_aMkPos.m_nNode.GetIndex() + 1;
420 74 : SwCntntNode* pCNd = GetCntntNode(pDoc, rRegion.GetPoint()->nNode, true);
421 74 : rRegion.GetPoint()->nContent.Assign(pCNd, rEntry.m_aMkPos.m_nCntnt);
422 74 : }
423 :
424 : // MakeBookRegionOrPoint() ist wie MakeRegionOrPoint, aber die besonderen
425 : // Beschraenkungen von Bookmarks in Tabellen werden beachtet.
426 : // ( Anfang und Ende muessen in selber Zelle sein )
427 6 : static void MakeBookRegionOrPoint(const SwFltStackEntry& rEntry, SwDoc* pDoc,
428 : SwPaM& rRegion, sal_Bool bCheck )
429 : {
430 6 : if (rEntry.MakeRegion(pDoc, rRegion, bCheck )){
431 : // sal_Bool b1 = rNds[rRegion.GetPoint()->nNode]->FindTableNode() != 0;
432 6 : if (rRegion.GetPoint()->nNode.GetNode().FindTableBoxStartNode()
433 3 : != rRegion.GetMark()->nNode.GetNode().FindTableBoxStartNode())
434 : {
435 0 : rRegion.Exchange(); // Ungueltiger Bereich
436 0 : rRegion.DeleteMark(); // -> beide auf Mark
437 : }
438 : }else{
439 3 : MakePoint(rEntry, pDoc, rRegion);
440 : }
441 6 : }
442 :
443 : // IterateNumrulePiece() sucht von rTmpStart bis rEnd den ersten
444 : // fuer Numrules gueltigen Bereich heraus.
445 : //
446 : // rNds sind die Doc-Nodes
447 : // rEnd ist Bereichs-Ende,
448 : // rTmpStart ist ReinRaus-Parameter: Anfang des zu untersuchenden Bereiches rein,
449 : // Anfang des gueltigen Bereichs raus
450 : // rTmpEnd ist raus-Parameter
451 : // Return-Bool ist true fuer gueltigen Bereich
452 0 : static bool IterateNumrulePiece( const SwNodeIndex& rEnd,
453 : SwNodeIndex& rTmpStart, SwNodeIndex& rTmpEnd )
454 : {
455 0 : while( ( rTmpStart <= rEnd )
456 0 : && !( rTmpStart.GetNode().IsTxtNode() ) ) // suche gueltigen Anfang
457 0 : ++rTmpStart;
458 :
459 0 : rTmpEnd = rTmpStart;
460 0 : while( ( rTmpEnd <= rEnd )
461 0 : && ( rTmpEnd.GetNode().IsTxtNode() ) ) // suche gueltiges Ende + 1
462 0 : ++rTmpEnd;
463 :
464 0 : rTmpEnd--; // gueltiges Ende
465 :
466 0 : return rTmpStart <= rTmpEnd; // gueltig ?
467 : }
468 :
469 : //***This function will check whether there is existing individual attribute positon for 0x0D***/
470 : //The check will happen only once for a paragraph during loading
471 88 : bool SwFltControlStack::HasSdOD()
472 : {
473 88 : bool bRet = false;
474 :
475 665 : for (Entries::iterator it = maEntries.begin(); it != maEntries.end(); ++it)
476 : {
477 589 : SwFltStackEntry& rEntry = *it;
478 589 : if ( rEntry.mnStartCP == rEntry.mnEndCP )
479 : {
480 111 : if ( CheckSdOD(rEntry.mnStartCP,rEntry.mnEndCP) )
481 : {
482 12 : bRet = true;
483 12 : break;
484 : }
485 : }
486 : }
487 :
488 88 : return bRet;
489 : }
490 :
491 14954 : void SwFltControlStack::SetAttrInDoc(const SwPosition& rTmpPos,
492 : SwFltStackEntry& rEntry)
493 : {
494 14954 : SwPaM aRegion( rTmpPos );
495 :
496 14954 : switch(rEntry.pAttr->Which())
497 : {
498 : case RES_FLTR_ANCHOR:
499 : {
500 71 : SwFrmFmt* pFmt = ((SwFltAnchor*)rEntry.pAttr)->GetFrmFmt();
501 71 : if (pFmt != NULL)
502 : {
503 71 : MakePoint(rEntry, pDoc, aRegion);
504 71 : SwFmtAnchor aAnchor(pFmt->GetAnchor());
505 71 : aAnchor.SetAnchor(aRegion.GetPoint());
506 71 : pFmt->SetFmtAttr(aAnchor);
507 : // Damit die Frames bei Einfuegen in existierendes Doc
508 : // erzeugt werden (erst nach Setzen des Ankers!):
509 142 : if(pDoc->GetCurrentViewShell() //swmod 071108//swmod 071225
510 71 : && (FLY_AT_PARA == pFmt->GetAnchor().GetAnchorId()))
511 : {
512 0 : pFmt->MakeFrms();
513 71 : }
514 : }
515 : }
516 71 : break;
517 : case RES_FLTR_STYLESHEET:
518 0 : break;
519 : case RES_TXTATR_FIELD:
520 0 : break;
521 : case RES_TXTATR_TOXMARK:
522 0 : break;
523 : case RES_FLTR_NUMRULE: // Numrule 'reinsetzen
524 : {
525 0 : const String& rNumNm = ((SfxStringItem*)rEntry.pAttr)->GetValue();
526 0 : SwNumRule* pRul = pDoc->FindNumRulePtr( rNumNm );
527 0 : if( pRul )
528 : {
529 0 : if( rEntry.MakeRegion(pDoc, aRegion, sal_True))
530 : {
531 0 : SwNodeIndex aTmpStart( aRegion.Start()->nNode );
532 0 : SwNodeIndex aTmpEnd( aTmpStart );
533 0 : SwNodeIndex& rRegEndNd = aRegion.End()->nNode;
534 0 : while( IterateNumrulePiece( rRegEndNd,
535 : aTmpStart, aTmpEnd ) )
536 : {
537 0 : SwPaM aTmpPam( aTmpStart, aTmpEnd );
538 : // no start of a new list
539 0 : pDoc->SetNumRule( aTmpPam, *pRul, false );
540 :
541 0 : aTmpStart = aTmpEnd; // Start fuer naechstes Teilstueck
542 0 : ++aTmpStart;
543 0 : }
544 : }
545 : else
546 0 : pDoc->DelNumRule( rNumNm );
547 0 : }
548 : }
549 0 : break;
550 : case RES_FLTR_NUMRULE_NUM:
551 0 : break;
552 : case RES_FLTR_BOOKMARK: // eigentlich nur fuer den Ende-Stack
553 : {
554 6 : SwFltBookmark* pB = (SwFltBookmark*)rEntry.pAttr;
555 6 : const String& rName = ((SwFltBookmark*)rEntry.pAttr)->GetName();
556 :
557 6 : if (IsFlagSet(BOOK_TO_VAR_REF))
558 : {
559 0 : if (pB->IsPgRef() && !pB->IsRef())
560 : {
561 : // XRefs und Bookmarks sind bereits geUpcased
562 0 : MakeBookRegionOrPoint(rEntry, pDoc, aRegion, sal_True);
563 0 : pDoc->InsertPoolItem(aRegion, SwFmtRefMark(rName), 0);
564 : }
565 0 : else if( !pB->IsOnlyRef() )
566 : {
567 0 : SwFieldType* pFT = pDoc->GetFldType(RES_SETEXPFLD, rName, false);
568 0 : if (!pFT)
569 : { // FieldType anlegen
570 0 : SwSetExpFieldType aS(pDoc, rName, nsSwGetSetExpType::GSE_STRING);
571 0 : pFT = pDoc->InsertFldType(aS);
572 : }
573 : SwSetExpField aFld((SwSetExpFieldType*)pFT,
574 0 : pB->GetValSys());
575 0 : aFld.SetSubType( nsSwExtendedSubType::SUB_INVISIBLE );
576 0 : MakePoint(rEntry, pDoc, aRegion);
577 0 : pDoc->InsertPoolItem(aRegion, SwFmtFld(aFld), 0);
578 0 : MoveAttrs( *(aRegion.GetPoint()) );
579 : }
580 : }
581 18 : if( !pB->IsOnlyRef() &&
582 6 : ( !IsFlagSet(HYPO) || IsFlagSet(BOOK_AND_REF) ) && !rEntry.bConsumedByField)
583 : {
584 6 : MakeBookRegionOrPoint(rEntry, pDoc, aRegion, sal_True);
585 6 : pDoc->getIDocumentMarkAccess()->makeMark( aRegion, rName, IDocumentMarkAccess::BOOKMARK);
586 : }
587 : }
588 6 : break;
589 : case RES_FLTR_TOX:
590 : {
591 0 : MakePoint(rEntry, pDoc, aRegion);
592 :
593 0 : SwPosition* pPoint = aRegion.GetPoint();
594 :
595 0 : SwFltTOX* pTOXAttr = (SwFltTOX*)rEntry.pAttr;
596 :
597 : // test if on this node there had been a pagebreak BEFORE the
598 : // tox attribut was put on the stack
599 0 : SfxItemSet aBkSet( pDoc->GetAttrPool(), RES_PAGEDESC, RES_BREAK );
600 0 : SwCntntNode* pNd = 0;
601 0 : if( !pTOXAttr->HadBreakItem() || !pTOXAttr->HadPageDescItem() )
602 : {
603 0 : pNd = pPoint->nNode.GetNode().GetCntntNode();
604 0 : if( pNd )
605 : {
606 0 : const SfxItemSet* pSet = pNd->GetpSwAttrSet();
607 : const SfxPoolItem* pItem;
608 0 : if( pSet )
609 : {
610 0 : if( !pTOXAttr->HadBreakItem()
611 0 : && SFX_ITEM_SET == pSet->GetItemState( RES_BREAK, sal_False, &pItem ) )
612 : {
613 0 : aBkSet.Put( *pItem );
614 0 : pNd->ResetAttr( RES_BREAK );
615 : }
616 0 : if( !pTOXAttr->HadPageDescItem()
617 0 : && SFX_ITEM_SET == pSet->GetItemState( RES_PAGEDESC, sal_False, &pItem ) )
618 : {
619 0 : aBkSet.Put( *pItem );
620 0 : pNd->ResetAttr( RES_PAGEDESC );
621 : }
622 : }
623 : }
624 : }
625 :
626 0 : delete pTOXAttr->GetBase();
627 :
628 : // set (aboved saved and removed) the break item at the node following the TOX
629 0 : if( aBkSet.Count() )
630 0 : pNd->SetAttr( aBkSet );
631 : }
632 0 : break;
633 : case RES_FLTR_SECTION:
634 0 : MakePoint(rEntry, pDoc, aRegion); // bislang immer Point==Mark
635 : pDoc->InsertSwSection(aRegion,
636 0 : *(static_cast<SwFltSection*>(rEntry.pAttr))->GetSectionData(),
637 0 : 0, 0, false);
638 0 : delete (((SwFltSection*)rEntry.pAttr)->GetSectionData());
639 0 : break;
640 : case RES_FLTR_REDLINE:
641 : {
642 0 : if (rEntry.MakeRegion(pDoc, aRegion, sal_True))
643 : {
644 : pDoc->SetRedlineMode((RedlineMode_t)( nsRedlineMode_t::REDLINE_ON
645 : | nsRedlineMode_t::REDLINE_SHOW_INSERT
646 0 : | nsRedlineMode_t::REDLINE_SHOW_DELETE ));
647 0 : SwFltRedline& rFltRedline = *((SwFltRedline*)rEntry.pAttr);
648 :
649 0 : if( USHRT_MAX != rFltRedline.nAutorNoPrev )
650 : {
651 : SwRedlineData aData(rFltRedline.eTypePrev,
652 : rFltRedline.nAutorNoPrev,
653 : rFltRedline.aStampPrev,
654 : aEmptyStr,
655 : 0
656 0 : );
657 0 : pDoc->AppendRedline(new SwRedline(aData, aRegion), true);
658 : }
659 : SwRedlineData aData(rFltRedline.eType,
660 : rFltRedline.nAutorNo,
661 : rFltRedline.aStamp,
662 : aEmptyStr,
663 : 0
664 0 : );
665 0 : pDoc->AppendRedline( new SwRedline(aData, aRegion), true );
666 : pDoc->SetRedlineMode((RedlineMode_t)( nsRedlineMode_t::REDLINE_NONE
667 : | nsRedlineMode_t::REDLINE_SHOW_INSERT
668 0 : | nsRedlineMode_t::REDLINE_SHOW_DELETE ));
669 : }
670 : }
671 0 : break;
672 : default:
673 : {
674 : //Revised for more complex situations should be considered
675 14877 : if ( !bSdODChecked )
676 : {
677 88 : bHasSdOD = HasSdOD();
678 88 : bSdODChecked = true;
679 : }
680 14877 : sal_Int32 nStart = rEntry.GetStartCP();
681 14877 : sal_Int32 nEnd = rEntry.GetEndCP();
682 14877 : if (nStart != -1 && nEnd != -1 && nEnd >= nStart )
683 : {
684 14877 : rEntry.SetIsParaEnd( IsParaEndInCPs(nStart,nEnd,bHasSdOD) );
685 : }
686 14877 : if (rEntry.MakeRegion(pDoc, aRegion, sal_False))
687 : {
688 12476 : nStart = rEntry.GetStartCP();
689 12476 : nEnd = rEntry.GetEndCP();
690 12476 : if (rEntry.IsParaEnd())
691 : {
692 2195 : pDoc->InsertPoolItem(aRegion, *rEntry.pAttr, 0, true);
693 : }
694 : else
695 : {
696 10281 : pDoc->InsertPoolItem(aRegion, *rEntry.pAttr, 0);
697 : }
698 : }
699 : }
700 14877 : break;
701 14954 : }
702 14954 : }
703 :
704 0 : bool SwFltControlStack::IsParaEndInCPs(sal_Int32 /*nStart*/, sal_Int32 /*nEnd*/,bool /*bSdOD*/) const
705 : {
706 0 : return false;
707 : }
708 :
709 0 : bool SwFltControlStack::CheckSdOD(sal_Int32 /*nStart*/, sal_Int32 /*nEnd*/)
710 : {
711 0 : return false;
712 : }
713 :
714 0 : SfxPoolItem* SwFltControlStack::GetFmtStackAttr(sal_uInt16 nWhich, sal_uInt16 * pPos)
715 : {
716 0 : size_t nSize = maEntries.size();
717 :
718 0 : while (nSize)
719 : {
720 : // ist es das gesuchte Attribut ? (gueltig sind nur gelockte,
721 : // also akt. gesetzte Attribute!!)
722 0 : SwFltStackEntry &rEntry = maEntries[--nSize];
723 0 : if (rEntry.bOpen && rEntry.pAttr->Which() == nWhich)
724 : {
725 0 : if (pPos)
726 0 : *pPos = nSize;
727 0 : return (SfxPoolItem*)rEntry.pAttr; // Ok, dann Ende
728 : }
729 : }
730 0 : return 0;
731 : }
732 :
733 0 : const SfxPoolItem* SwFltControlStack::GetFmtAttr(const SwPosition& rPos, sal_uInt16 nWhich)
734 : {
735 0 : SfxPoolItem* pHt = GetFmtStackAttr(nWhich);
736 0 : if (pHt)
737 0 : return (const SfxPoolItem*)pHt;
738 :
739 : // im Stack ist das Attribut nicht vorhanden, also befrage das Dokument
740 0 : SwCntntNode * pNd = rPos.nNode.GetNode().GetCntntNode();
741 :
742 0 : if (!pNd) // kein ContentNode, dann das dflt. Attribut
743 0 : return &pDoc->GetAttrPool().GetDefaultItem(nWhich);
744 0 : return &pNd->GetAttr(nWhich);
745 : }
746 :
747 1 : void SwFltControlStack::Delete(const SwPaM &rPam)
748 : {
749 1 : const SwPosition *pStt = rPam.Start(), *pEnd = rPam.End();
750 :
751 1 : if( !rPam.HasMark() || *pStt >= *pEnd )
752 0 : return;
753 :
754 1 : SwNodeIndex aStartNode(pStt->nNode, -1);
755 1 : sal_uInt16 nStartIdx = pStt->nContent.GetIndex();
756 2 : SwNodeIndex aEndNode(pEnd->nNode, -1);
757 1 : sal_uInt16 nEndIdx = pEnd->nContent.GetIndex();
758 :
759 : //We don't support deleting content that is over one node, or removing a node.
760 : OSL_ENSURE(aEndNode == aStartNode, "nodes must be the same, or this method extended");
761 1 : if (aEndNode != aStartNode)
762 0 : return;
763 :
764 2 : for (size_t nSize = maEntries.size(); nSize > 0;)
765 : {
766 0 : SwFltStackEntry& rEntry = maEntries[--nSize];
767 :
768 : bool bEntryStartAfterSelStart =
769 0 : (rEntry.m_aMkPos.m_nNode == aStartNode &&
770 0 : rEntry.m_aMkPos.m_nCntnt >= nStartIdx);
771 :
772 : bool bEntryStartBeforeSelEnd =
773 0 : (rEntry.m_aMkPos.m_nNode == aEndNode &&
774 0 : rEntry.m_aMkPos.m_nCntnt <= nEndIdx);
775 :
776 0 : bool bEntryEndAfterSelStart = false;
777 0 : bool bEntryEndBeforeSelEnd = false;
778 0 : if (!rEntry.bOpen)
779 : {
780 : bEntryEndAfterSelStart =
781 0 : (rEntry.m_aPtPos.m_nNode == aStartNode &&
782 0 : rEntry.m_aPtPos.m_nCntnt >= nStartIdx);
783 :
784 : bEntryEndBeforeSelEnd =
785 0 : (rEntry.m_aPtPos.m_nNode == aEndNode &&
786 0 : rEntry.m_aPtPos.m_nCntnt <= nEndIdx);
787 : }
788 :
789 0 : bool bTotallyContained = false;
790 0 : if (
791 0 : bEntryStartAfterSelStart && bEntryStartBeforeSelEnd &&
792 0 : bEntryEndAfterSelStart && bEntryEndBeforeSelEnd
793 : )
794 : {
795 0 : bTotallyContained = true;
796 : }
797 :
798 0 : if (bTotallyContained)
799 : {
800 : //after start, before end, delete
801 0 : DeleteAndDestroy(nSize);
802 0 : continue;
803 : }
804 :
805 0 : xub_StrLen nCntntDiff = nEndIdx - nStartIdx;
806 :
807 : //to be adjusted
808 0 : if (bEntryStartAfterSelStart)
809 : {
810 0 : if (bEntryStartBeforeSelEnd)
811 : {
812 : //move start to new start
813 0 : rEntry.m_aMkPos.SetPos(aStartNode, nStartIdx);
814 : }
815 : else
816 0 : rEntry.m_aMkPos.m_nCntnt -= nCntntDiff;
817 : }
818 :
819 0 : if (bEntryEndAfterSelStart)
820 : {
821 0 : if (bEntryEndBeforeSelEnd)
822 0 : rEntry.m_aPtPos.SetPos(aStartNode, nStartIdx);
823 : else
824 0 : rEntry.m_aPtPos.m_nCntnt -= nCntntDiff;
825 : }
826 :
827 : //That's what Open is, end equal to start, and nPtCntnt is invalid
828 0 : if (rEntry.bOpen)
829 0 : rEntry.m_aPtPos = rEntry.m_aMkPos;
830 1 : }
831 : }
832 :
833 : //------ hier stehen die Methoden von SwFltAnchor -----------
834 71 : SwFltAnchor::SwFltAnchor(SwFrmFmt* pFmt) :
835 71 : SfxPoolItem(RES_FLTR_ANCHOR), pFrmFmt(pFmt)
836 : {
837 71 : pClient = new SwFltAnchorClient(this);
838 71 : pFrmFmt->Add(pClient);
839 71 : }
840 :
841 71 : SwFltAnchor::SwFltAnchor(const SwFltAnchor& rCpy) :
842 71 : SfxPoolItem(RES_FLTR_ANCHOR), pFrmFmt(rCpy.pFrmFmt)
843 : {
844 71 : pClient = new SwFltAnchorClient(this);
845 71 : pFrmFmt->Add(pClient);
846 71 : }
847 :
848 355 : SwFltAnchor::~SwFltAnchor()
849 : {
850 142 : delete pClient;
851 213 : }
852 :
853 0 : void SwFltAnchor::SetFrmFmt(SwFrmFmt * _pFrmFmt)
854 : {
855 0 : pFrmFmt = _pFrmFmt;
856 0 : }
857 :
858 0 : const SwFrmFmt * SwFltAnchor::GetFrmFmt() const
859 : {
860 0 : return pFrmFmt;
861 : }
862 :
863 71 : SwFrmFmt * SwFltAnchor::GetFrmFmt()
864 : {
865 71 : return pFrmFmt;
866 : }
867 :
868 0 : int SwFltAnchor::operator==(const SfxPoolItem& rItem) const
869 : {
870 0 : return pFrmFmt == ((SwFltAnchor&)rItem).pFrmFmt;
871 : }
872 :
873 71 : SfxPoolItem* SwFltAnchor::Clone(SfxItemPool*) const
874 : {
875 71 : return new SwFltAnchor(*this);
876 : }
877 :
878 : // SwFltAnchorClient
879 :
880 142 : SwFltAnchorClient::SwFltAnchorClient(SwFltAnchor * pFltAnchor)
881 142 : : m_pFltAnchor(pFltAnchor)
882 : {
883 142 : }
884 :
885 44 : void SwFltAnchorClient::Modify(const SfxPoolItem *, const SfxPoolItem * pNew)
886 : {
887 44 : if (pNew->Which() == RES_FMT_CHG)
888 : {
889 0 : const SwFmtChg * pFmtChg = dynamic_cast<const SwFmtChg *> (pNew);
890 :
891 0 : if (pFmtChg != NULL)
892 : {
893 0 : SwFrmFmt * pFrmFmt = dynamic_cast<SwFrmFmt *> (pFmtChg->pChangedFmt);
894 :
895 0 : if (pFrmFmt != NULL)
896 0 : m_pFltAnchor->SetFrmFmt(pFrmFmt);
897 : }
898 : }
899 44 : }
900 :
901 : //------ hier stehen die Methoden von SwFltRedline -----------
902 0 : int SwFltRedline::operator==(const SfxPoolItem& rItem) const
903 : {
904 0 : return this == &rItem;
905 : }
906 :
907 0 : SfxPoolItem* SwFltRedline::Clone( SfxItemPool* ) const
908 : {
909 0 : return new SwFltRedline(*this);
910 : }
911 :
912 : //------ hier stehen die Methoden von SwFltBookmark -----------
913 6 : SwFltBookmark::SwFltBookmark( const String& rNa, const String& rVa,
914 : long nHand, sal_Bool bOnlyR )
915 : : SfxPoolItem(RES_FLTR_BOOKMARK), nHandle(nHand), aName(rNa), aVal(rVa),
916 6 : bOnlyRef(bOnlyR), bRef(sal_False), bPgRef(sal_False)
917 : {
918 : // eSrc: CHARSET_DONTKNOW fuer keine UEbersetzung bei operator <<
919 : // Upcase wird immer gemacht.
920 : // bei XXXStack.NewAttr(...) wird nie eine UEbersetzung vorgenommen.
921 : // ansonsten: uebergebener Src-Charset fuer aName
922 : // im Filter eingestellter Src-Charset fuer aVal ( Text )
923 6 : }
924 :
925 6 : SwFltBookmark::SwFltBookmark(const SwFltBookmark& rCpy)
926 : : SfxPoolItem(RES_FLTR_BOOKMARK),
927 : nHandle(rCpy.nHandle),
928 : aName(rCpy.aName),
929 : aVal(rCpy.aVal),
930 : bOnlyRef(rCpy.bOnlyRef),
931 : bRef(rCpy.bRef),
932 6 : bPgRef(rCpy.bPgRef)
933 : {
934 6 : }
935 :
936 0 : int SwFltBookmark::operator==(const SfxPoolItem& rItem) const
937 : {
938 0 : return (aName == ((SwFltBookmark&)rItem).aName)
939 0 : && (nHandle == ((SwFltBookmark&)rItem).nHandle);
940 : }
941 :
942 6 : SfxPoolItem* SwFltBookmark::Clone(SfxItemPool*) const
943 : {
944 6 : return new SwFltBookmark(*this);
945 : }
946 :
947 : //------ hier stehen die Methoden von SwFltTOX -----------
948 :
949 0 : SwFltTOX::SwFltTOX(SwTOXBase* pBase, sal_uInt16 _nCols)
950 : : SfxPoolItem(RES_FLTR_TOX), pTOXBase(pBase), nCols( _nCols ),
951 0 : bHadBreakItem( sal_False ), bHadPageDescItem( sal_False )
952 : {
953 0 : }
954 :
955 0 : SwFltTOX::SwFltTOX(const SwFltTOX& rCpy)
956 : : SfxPoolItem(RES_FLTR_TOX), pTOXBase(rCpy.pTOXBase), nCols( rCpy.nCols ),
957 0 : bHadBreakItem( rCpy.bHadBreakItem ), bHadPageDescItem( rCpy.bHadPageDescItem )
958 : {
959 0 : }
960 :
961 0 : int SwFltTOX::operator==(const SfxPoolItem& rItem) const
962 : {
963 0 : return pTOXBase == ((SwFltTOX&)rItem).pTOXBase;
964 : }
965 :
966 0 : SfxPoolItem* SwFltTOX::Clone(SfxItemPool*) const
967 : {
968 0 : return new SwFltTOX(*this);
969 : }
970 :
971 : //------ hier stehen die Methoden von SwFltSwSection -----------
972 :
973 0 : SwFltSection::SwFltSection(SwSectionData *const pSect)
974 : : SfxPoolItem(RES_FLTR_SECTION)
975 0 : , m_pSection(pSect)
976 : {
977 0 : }
978 :
979 0 : SwFltSection::SwFltSection(const SwFltSection& rCpy)
980 : : SfxPoolItem(RES_FLTR_SECTION)
981 0 : , m_pSection(rCpy.m_pSection)
982 : {
983 0 : }
984 :
985 0 : int SwFltSection::operator==(const SfxPoolItem& rItem) const
986 : {
987 0 : return m_pSection == ((SwFltSection&)rItem).m_pSection;
988 : }
989 :
990 0 : SfxPoolItem* SwFltSection::Clone(SfxItemPool*) const
991 : {
992 0 : return new SwFltSection(*this);
993 : }
994 :
995 : ///////////////////////////////////////////////////////////////////////
996 : //
997 : // hier beginnt der von mdt erzeugte code. dieser ist eine shell auf
998 : // der writer-seite nach moeglichkeit bald fuer alle filter. die ganze
999 : // schwierigkeit, texte & formatattribute einzufuegen, die positionen
1000 : // zu verwalten, styles & kopf/fuszzeilen etc.
1001 : //
1002 :
1003 : //////////////////////////////////////////////////////////// SwFltShell
1004 0 : SwFltShell::SwFltShell(SwDoc* pDoc, SwPaM& rPaM, const String& rBaseURL, sal_Bool bNew, sal_uLong nFieldFl) :
1005 : pCurrentPageDesc(0),
1006 : pSavedPos(0),
1007 : eSubMode(None),
1008 : nAktStyle(0),
1009 : aStack(pDoc, nFieldFl),
1010 : aEndStack(pDoc, nFieldFl),
1011 0 : pPaM(new SwPaM(*(rPaM.GetPoint()))),
1012 : sBaseURL(rBaseURL),
1013 0 : nPageDescOffset(GetDoc().GetPageDescCnt()),
1014 : eSrcCharSet(RTL_TEXTENCODING_MS_1252),
1015 : bNewDoc(bNew),
1016 : bStdPD(sal_False),
1017 0 : bProtect(sal_False)
1018 : {
1019 0 : memset( pColls, 0, sizeof( pColls ) );
1020 0 : pOutDoc = new SwFltOutDoc( *pDoc, pPaM, aStack, aEndStack );
1021 0 : pOut = pOutDoc;
1022 :
1023 0 : if( !bNewDoc ){ // in ein Dokument einfuegen ?
1024 : // Da immer ganze Zeile eingelesen werden, muessen
1025 : // evtl. Zeilen eingefuegt / aufgebrochen werden
1026 0 : const SwPosition* pPos = pPaM->GetPoint();
1027 0 : const SwTxtNode* pSttNd = pPos->nNode.GetNode().GetTxtNode();
1028 0 : sal_uInt16 nCntPos = pPos->nContent.GetIndex();
1029 0 : if (nCntPos && !pSttNd->GetTxt().isEmpty())
1030 : // EinfuegePos nicht in leerer Zeile
1031 0 : pDoc->SplitNode( *pPos, false ); // neue Zeile erzeugen
1032 0 : if (!pSttNd->GetTxt().isEmpty())
1033 : { // InsertPos not on empty line
1034 0 : pDoc->SplitNode( *pPos, false ); // neue Zeile
1035 0 : pPaM->Move( fnMoveBackward ); // gehe in leere Zeile
1036 : }
1037 :
1038 : // verhinder das Einlesen von Tabellen in Fussnoten / Tabellen
1039 0 : sal_uLong nNd = pPos->nNode.GetIndex();
1040 0 : bool bReadNoTbl = 0 != pSttNd->FindTableNode() ||
1041 0 : ( nNd < pDoc->GetNodes().GetEndOfInserts().GetIndex() &&
1042 0 : pDoc->GetNodes().GetEndOfInserts().StartOfSectionIndex() < nNd );
1043 0 : if( bReadNoTbl )
1044 0 : pOutDoc->SetReadNoTable();
1045 : }
1046 0 : pCurrentPageDesc = &pDoc->GetPageDesc( 0 ); // Standard
1047 :
1048 0 : }
1049 :
1050 0 : SwFltShell::~SwFltShell()
1051 : {
1052 : sal_uInt16 i;
1053 :
1054 0 : if (eSubMode == Style)
1055 0 : EndStyle();
1056 0 : if( pOutDoc->IsInTable() ) // falls nicht ordentlich abgeschlossen
1057 0 : EndTable();
1058 0 : if( pOutDoc->IsInFly() )
1059 0 : EndFly();
1060 :
1061 0 : GetDoc().SetUpdateExpFldStat(true);
1062 0 : GetDoc().SetInitDBFields(sal_True);
1063 0 : aStack.SetAttr(*pPaM->GetPoint(), 0, sal_False);
1064 0 : aStack.SetAttr(*pPaM->GetPoint(), 0, sal_False);
1065 0 : aEndStack.SetAttr(*pPaM->GetPoint(), 0, sal_False);
1066 0 : aEndStack.SetAttr(*pPaM->GetPoint(), 0, sal_False);
1067 0 : if( bProtect ){ // Das ganze Doc soll geschuetzt sein
1068 :
1069 0 : SwDoc& rDoc = GetDoc();
1070 : // 1. SectionFmt und Section anlegen
1071 0 : SwSectionFmt* pSFmt = rDoc.MakeSectionFmt( 0 );
1072 0 : SwSectionData aSectionData(CONTENT_SECTION, OUString("PMW-Protect"));
1073 0 : aSectionData.SetProtectFlag( true );
1074 : // 2. Start- und EndIdx suchen
1075 0 : const SwNode* pEndNd = &rDoc.GetNodes().GetEndOfContent();
1076 0 : SwNodeIndex aEndIdx( *pEndNd, -1L );
1077 0 : const SwStartNode* pSttNd = pEndNd->StartOfSectionNode();
1078 0 : SwNodeIndex aSttIdx( *pSttNd, 1L ); // +1 -> hinter StartNode
1079 : // Section einfuegen
1080 : // Section einfuegen
1081 0 : rDoc.GetNodes().InsertTextSection(
1082 0 : aSttIdx, *pSFmt, aSectionData, 0, &aEndIdx, false );
1083 :
1084 0 : if( !IsFlagSet(SwFltControlStack::DONT_HARD_PROTECT) ){
1085 0 : SwDocShell* pDocSh = rDoc.GetDocShell();
1086 0 : if( pDocSh )
1087 0 : pDocSh->SetReadOnlyUI( sal_True );
1088 0 : }
1089 : }
1090 : // Pagedescriptoren am Dokument updaten (nur so werden auch die
1091 : // linken Seiten usw. eingestellt).
1092 :
1093 0 : GetDoc().ChgPageDesc( 0, GetDoc().GetPageDesc( 0 )); // PageDesc "Standard"
1094 0 : for (i=nPageDescOffset;i<GetDoc().GetPageDescCnt();i++)
1095 : {
1096 0 : const SwPageDesc& rPD = GetDoc().GetPageDesc(i);
1097 0 : GetDoc().ChgPageDesc(i, rPD);
1098 : }
1099 :
1100 0 : delete pPaM;
1101 0 : for (i=0; i<sizeof(pColls)/sizeof(*pColls); i++)
1102 0 : delete pColls[i];
1103 0 : delete pOutDoc;
1104 0 : }
1105 :
1106 0 : SwFltShell& SwFltShell::operator << ( const String& rStr )
1107 : {
1108 : OSL_ENSURE(eSubMode != Style, "char insert while in style-mode");
1109 0 : GetDoc().InsertString( *pPaM, rStr );
1110 0 : return *this;
1111 : }
1112 :
1113 0 : void SwFltShell::ConvertUStr( String& rInOut )
1114 : {
1115 0 : rInOut = GetAppCharClass().uppercase( rInOut );
1116 0 : }
1117 :
1118 : // QuoteString() wandelt CRs abhaengig von nFieldIniFlags in '\n' oder "\0x0d"
1119 0 : OUString SwFltShell::QuoteStr( const OUString& rIn )
1120 : {
1121 0 : OUStringBuffer sOut( rIn );
1122 0 : sal_Bool bAllowCr = aStack.IsFlagSet( SwFltControlStack::ALLOW_FLD_CR );
1123 :
1124 0 : for( sal_Int32 n = 0; n < sOut.getLength(); ++n )
1125 : {
1126 0 : switch( sOut[ n ] )
1127 : {
1128 : case 0x0a:
1129 0 : sOut.remove( n, 1 ); // 0xd 0xa wird zu \n
1130 0 : break;
1131 :
1132 : case 0x0b:
1133 : case 0x0c:
1134 : case 0x0d:
1135 0 : if( bAllowCr )
1136 0 : sOut[n] = '\n';
1137 0 : break;
1138 : }
1139 : }
1140 0 : return sOut.makeStringAndClear();
1141 : }
1142 :
1143 0 : SwFltShell& SwFltShell::operator << ( const sal_Unicode c )
1144 : {
1145 : OSL_ENSURE( eSubMode != Style, "char insert while in style-mode");
1146 0 : GetDoc().InsertString( *pPaM, OUString(c) );
1147 0 : return *this;
1148 : }
1149 :
1150 0 : SwFltShell& SwFltShell::AddError( const sal_Char* pErr )
1151 : {
1152 0 : String aName(OUString("ErrorTag"));
1153 0 : SwFieldType* pFT = GetDoc().GetFldType( RES_SETEXPFLD, aName, false );
1154 0 : if( pFT == 0)
1155 : {
1156 0 : SwSetExpFieldType aS(&GetDoc(), aName, nsSwGetSetExpType::GSE_STRING);
1157 0 : pFT = GetDoc().InsertFldType(aS);
1158 : }
1159 : SwSetExpField aFld( (SwSetExpFieldType*)pFT,
1160 0 : OUString::createFromAscii( pErr ));
1161 : //, VVF_INVISIBLE
1162 0 : GetDoc().InsertPoolItem(*pPaM, SwFmtFld(aFld), 0);
1163 0 : return *this;
1164 : }
1165 :
1166 0 : SwFltShell& SwFltShell::operator << (Graphic& rGraphic)
1167 : {
1168 : // embedded Grafik !!
1169 0 : GetDoc().Insert(*pPaM, aEmptyStr, aEmptyStr, &rGraphic, NULL, NULL, NULL);
1170 0 : return *this;
1171 : }
1172 :
1173 0 : void SwFltShell::NextParagraph()
1174 : {
1175 0 : GetDoc().AppendTxtNode(*pPaM->GetPoint());
1176 0 : }
1177 :
1178 0 : void SwFltShell::NextPage()
1179 : {
1180 0 : NextParagraph();
1181 0 : GetDoc().InsertPoolItem(*pPaM,
1182 0 : SvxFmtBreakItem(SVX_BREAK_PAGE_BEFORE, RES_BREAK), 0);
1183 0 : }
1184 :
1185 0 : SwFltShell& SwFltShell::AddGraphic( const String& rPicName )
1186 : {
1187 : // embedded:
1188 0 : GraphicFilter& rFilter = GraphicFilter::GetGraphicFilter();
1189 0 : Graphic aGraphic;
1190 : // one of: GFF_NOT GFF_BMP GFF_GIF GFF_JPG GFF_PCD GFF_PCX GFF_PNG
1191 : // GFF_TIF GFF_XBM GFF_DXF GFF_MET GFF_PCT GFF_SGF GFF_SVM GFF_WMF
1192 : // GFF_SGV GFF_XXX
1193 : INetURLObject aDir(
1194 : URIHelper::SmartRel2Abs(
1195 0 : INetURLObject(GetBaseURL()), rPicName,
1196 0 : URIHelper::GetMaybeFileHdl()) );
1197 0 : switch (rFilter.ImportGraphic(aGraphic, aDir))
1198 : {
1199 : case GRFILTER_OK:
1200 0 : *this << aGraphic;
1201 0 : break;
1202 : case GRFILTER_OPENERROR:
1203 : case GRFILTER_IOERROR:
1204 : case GRFILTER_FORMATERROR:
1205 : case GRFILTER_VERSIONERROR:
1206 : case GRFILTER_FILTERERROR:
1207 : case GRFILTER_ABORT:
1208 : case GRFILTER_TOOBIG:
1209 : default:
1210 0 : AddError( "picture import error" );
1211 0 : break;
1212 : }
1213 0 : return *this;
1214 : }
1215 :
1216 0 : SwFltShell& SwFltShell::SetStyle( sal_uInt16 nStyle )
1217 : {
1218 0 : SwFltFormatCollection* p = pColls[ nStyle ];
1219 :
1220 0 : if (p)
1221 : {
1222 0 : if( !pOutDoc->IsInTable() && nStyle != nAktStyle )
1223 : {
1224 0 : if( pColls[nAktStyle]->IsInFly() && pOutDoc->IsInFly() )
1225 0 : pOutDoc->EndFly();
1226 0 : if( p->IsInFly() )
1227 0 : p->BeginStyleFly( pOutDoc );
1228 : }
1229 0 : GetDoc().SetTxtFmtColl(*pPaM, p->GetColl());
1230 0 : nAktStyle = nStyle;
1231 : }
1232 : else
1233 : {
1234 : OSL_FAIL( "Ungueltiger SwFltStyleCode" );
1235 : }
1236 0 : return *this;
1237 : }
1238 :
1239 0 : SwFltShell& SwFltShell::operator << (SwFltBookmark& aBook)
1240 : {
1241 0 : ConvertUStr( aBook.aName );
1242 0 : aBook.aVal = QuoteStr(aBook.aVal);
1243 0 : aEndStack.NewAttr(*pPaM->GetPoint(), aBook);
1244 0 : return *this;
1245 : }
1246 :
1247 0 : void SwFltShell::SetBookEnd(long nHandle)
1248 : {
1249 0 : aEndStack.SetAttr( *pPaM->GetPoint(), RES_FLTR_BOOKMARK, sal_True, nHandle );
1250 0 : }
1251 :
1252 0 : SwFltShell& SwFltShell::EndItem( sal_uInt16 nAttrId )
1253 : {
1254 0 : switch( nAttrId )
1255 : {
1256 : case RES_FLTR_BOOKMARK:
1257 : OSL_FAIL( "Falscher Aufruf fuer Bookmark-Ende" );
1258 0 : break;
1259 :
1260 : case RES_FLTR_TOX:
1261 0 : aEndStack.SetAttr(*pPaM->GetPoint(), nAttrId);
1262 0 : break;
1263 :
1264 : default:
1265 0 : aStack.SetAttr(*pPaM->GetPoint(), nAttrId);
1266 0 : break;
1267 : }
1268 0 : return *this;
1269 : }
1270 :
1271 0 : SwFltShell& SwFltShell::operator << (const SwField& rField)
1272 : {
1273 0 : GetDoc().InsertPoolItem(*pPaM, SwFmtFld(rField), 0);
1274 0 : return *this;
1275 : }
1276 :
1277 0 : /*virtual*/ SwFltOutBase& SwFltOutDoc::operator << (const SfxPoolItem& rItem)
1278 : {
1279 0 : rStack.NewAttr(*pPaM->GetPoint(), rItem);
1280 0 : return *this;
1281 : }
1282 :
1283 0 : /*virtual*/ SwFltOutBase& SwFltFormatCollection::operator <<
1284 : (const SfxPoolItem& rItem)
1285 : {
1286 0 : pColl->SetFmtAttr(rItem);
1287 0 : return *this;
1288 : }
1289 :
1290 0 : const SfxPoolItem& SwFltOutDoc::GetAttr(sal_uInt16 nWhich)
1291 : {
1292 0 : return *rStack.GetFmtAttr(*pPaM->GetPoint(), nWhich);
1293 : }
1294 :
1295 0 : const SfxPoolItem& SwFltFormatCollection::GetAttr(sal_uInt16 nWhich)
1296 : {
1297 0 : return GetColl()->GetFmtAttr(nWhich); // mit Parents
1298 : }
1299 :
1300 : // GetNodeOrStyAttr holt Attribute fuer Toggle- und Modify-Attribute:
1301 : // Bei Formatdefinitionen aus dem altuellen Style mit Parents
1302 : // sonst aus dem Node mit Parents
1303 : // Im Stack wird nicht nachgesehen
1304 :
1305 0 : const SfxPoolItem& SwFltOutDoc::GetNodeOrStyAttr(sal_uInt16 nWhich)
1306 : {
1307 0 : SwCntntNode * pNd = pPaM->GetPoint()->nNode.GetNode().GetCntntNode();
1308 0 : if (pNd) // ContentNode: Attribut mit Parent
1309 0 : return pNd->GetAttr(nWhich);
1310 : else // kein ContentNode, dann das dflt. Attribut
1311 0 : return GetDoc().GetAttrPool().GetDefaultItem(nWhich);
1312 : }
1313 :
1314 0 : const SfxPoolItem& SwFltFormatCollection::GetNodeOrStyAttr(sal_uInt16 nWhich)
1315 : {
1316 0 : return GetColl()->GetFmtAttr(nWhich); // mit Parents
1317 : }
1318 :
1319 0 : const SfxPoolItem& SwFltShell::GetNodeOrStyAttr(sal_uInt16 nWhich)
1320 : {
1321 0 : return pOut->GetNodeOrStyAttr( nWhich );
1322 : }
1323 :
1324 0 : const SfxPoolItem& SwFltShell::GetAttr(sal_uInt16 nWhich)
1325 : {
1326 0 : return pOut->GetAttr( nWhich );
1327 : }
1328 :
1329 0 : const SfxPoolItem& SwFltShell::GetFlyFrmAttr(sal_uInt16 nWhich)
1330 : {
1331 0 : return pOut->GetFlyFrmAttr( nWhich );
1332 : }
1333 :
1334 0 : SwFieldType* SwFltShell::GetSysFldType(sal_uInt16 eWhich)
1335 : {
1336 0 : return GetDoc().GetSysFldType(eWhich);
1337 : }
1338 :
1339 0 : bool SwFltShell::GetWeightBold()
1340 : {
1341 0 : return ((SvxWeightItem&)GetNodeOrStyAttr(RES_CHRATR_WEIGHT)).GetWeight()
1342 0 : != WEIGHT_NORMAL;
1343 : }
1344 :
1345 0 : bool SwFltShell::GetPostureItalic()
1346 : {
1347 0 : return ((SvxPostureItem&)GetNodeOrStyAttr(RES_CHRATR_POSTURE)).GetPosture()
1348 0 : != ITALIC_NONE;
1349 : }
1350 :
1351 0 : bool SwFltShell::GetCrossedOut()
1352 : {
1353 0 : return ((SvxCrossedOutItem&)GetNodeOrStyAttr(RES_CHRATR_CROSSEDOUT))
1354 0 : .GetStrikeout() != STRIKEOUT_NONE;
1355 : }
1356 :
1357 0 : bool SwFltShell::GetContour()
1358 : {
1359 0 : return ((SvxContourItem&)GetNodeOrStyAttr(RES_CHRATR_CONTOUR)).GetValue();
1360 : }
1361 :
1362 0 : bool SwFltShell::GetCaseKapitaelchen()
1363 : {
1364 0 : return ((SvxCaseMapItem&)GetNodeOrStyAttr(RES_CHRATR_CASEMAP))
1365 0 : .GetCaseMap() == SVX_CASEMAP_KAPITAELCHEN;
1366 : }
1367 :
1368 0 : bool SwFltShell::GetCaseVersalien()
1369 : {
1370 0 : return ((SvxCaseMapItem&)GetNodeOrStyAttr(RES_CHRATR_CASEMAP))
1371 0 : .GetCaseMap() == SVX_CASEMAP_VERSALIEN;
1372 : }
1373 :
1374 : //-------------------------------------------------------------------------
1375 : // Tabellen
1376 : //-------------------------------------------------------------------------
1377 :
1378 0 : SwFltOutBase::~SwFltOutBase()
1379 : {
1380 0 : }
1381 :
1382 0 : SwFltOutBase::SwFltOutBase(SwDoc& rDocu)
1383 0 : : rDoc(rDocu), eFlyAnchor(FLY_AT_PARA), bFlyAbsPos(false)
1384 : {
1385 0 : }
1386 :
1387 0 : const SfxPoolItem& SwFltOutBase::GetCellAttr(sal_uInt16 nWhich)
1388 : {
1389 : OSL_FAIL("GetCellAttr ausserhalb von normalem Text");
1390 0 : return GetDoc().GetAttrPool().GetDefaultItem(nWhich);
1391 : }
1392 :
1393 0 : bool SwFltOutBase::BeginTable()
1394 : {
1395 : OSL_FAIL("BeginTable ausserhalb von normalem Text");
1396 0 : return false;
1397 : }
1398 :
1399 0 : void SwFltOutBase::NextTableCell()
1400 : {
1401 : OSL_FAIL("NextTableCell ausserhalb von normalem Text");
1402 0 : }
1403 :
1404 0 : void SwFltOutBase::NextTableRow()
1405 : {
1406 : OSL_FAIL("NextTableRow ausserhalb von normalem Text");
1407 0 : }
1408 :
1409 0 : void SwFltOutBase::SetTableWidth(SwTwips /*nW*/)
1410 : {
1411 : OSL_FAIL("SetTableWidth ausserhalb von normalem Text");
1412 0 : }
1413 :
1414 0 : void SwFltOutBase::SetTableOrient(sal_Int16 /*eOri*/)
1415 : {
1416 : OSL_FAIL("SetTableOrient ausserhalb von normalem Text");
1417 0 : }
1418 :
1419 0 : void SwFltOutBase::SetCellWidth(SwTwips /*nWidth*/, sal_uInt16 /*nCell*/)
1420 : {
1421 : OSL_FAIL("SetCellWidth ausserhalb von normalem Text");
1422 0 : }
1423 :
1424 0 : void SwFltOutBase::SetCellHeight(SwTwips /*nH*/)
1425 : {
1426 : OSL_FAIL("SetCellHeight ausserhalb von normalem Text");
1427 0 : }
1428 :
1429 0 : void SwFltOutBase::SetCellBorder(const SvxBoxItem& /*rFmtBox*/, sal_uInt16 /*nCell*/)
1430 : {
1431 : OSL_FAIL("SetCellBorder ausserhalb von normalem Text");
1432 0 : }
1433 :
1434 0 : void SwFltOutBase::SetCellSpace(sal_uInt16 /*nSp*/)
1435 : {
1436 : OSL_FAIL("SetCellSpace ausserhalb von normalem Text");
1437 0 : }
1438 :
1439 0 : void SwFltOutBase::DeleteCell(sal_uInt16 /*nCell*/)
1440 : {
1441 : OSL_FAIL("DeleteCell ausserhalb von normalem Text");
1442 0 : }
1443 :
1444 0 : void SwFltOutBase::EndTable()
1445 : {
1446 : OSL_FAIL("EndTable ausserhalb von normalem Text");
1447 0 : }
1448 :
1449 0 : /*virtual*/ sal_Bool SwFltOutDoc::IsInTable()
1450 : {
1451 0 : return pTable != 0;
1452 : };
1453 :
1454 0 : bool SwFltOutDoc::BeginTable()
1455 : {
1456 0 : if(bReadNoTbl)
1457 0 : return false;
1458 :
1459 0 : if (pTable){
1460 : OSL_FAIL("BeginTable in Table");
1461 0 : return false;
1462 : }
1463 : // Alle Attribute schliessen, da sonst Attribute
1464 : // entstehen koennen, die in Flys reinragen
1465 0 : rStack.SetAttr( *pPaM->GetPoint(), 0, sal_False );
1466 0 : rEndStack.SetAttr( *pPaM->GetPoint(), 0, sal_False );
1467 :
1468 : // create table:
1469 : OSL_ENSURE(pTabSavedPos == NULL, "SwFltOutDoc");
1470 0 : pTabSavedPos = new SwPosition(*pPaM->GetPoint());
1471 0 : pTable = GetDoc().InsertTable(
1472 : SwInsertTableOptions( tabopts::HEADLINE_NO_BORDER, 1 ),
1473 0 : *pTabSavedPos, 1, 1, text::HoriOrientation::LEFT, 0, 0, sal_False, sal_False ); // TODO MULTIHEADER
1474 0 : nTableWidth = 0;
1475 0 : ((SwTable*)pTable)->LockModify(); // Nichts automatisch anpassen!
1476 : // set pam in 1. table cell
1477 : usTableX =
1478 0 : usTableY = 0;
1479 0 : SeekCell(usTableY, usTableX, sal_True);
1480 0 : return true;
1481 : }
1482 :
1483 0 : SwTableBox* SwFltOutDoc::GetBox(sal_uInt16 ny, sal_uInt16 nx /*= USHRT_MAX */)
1484 : {
1485 0 : if(!pTable){
1486 : OSL_ENSURE(pTable, "GetBox ohne Tabelle");
1487 0 : return 0;
1488 : }
1489 0 : if( nx == USHRT_MAX ) // aktuelle Zelle
1490 0 : nx = usTableX;
1491 :
1492 : // get structs to table cells
1493 0 : const SwTableLines* pTableLines = &pTable->GetTabLines();
1494 0 : if(!pTableLines){
1495 : OSL_FAIL("SwFltOutDoc:GetBox:pTableLines");
1496 0 : return 0;
1497 : }
1498 0 : if( ny >= pTableLines->size() ){ // Notbremse
1499 : OSL_FAIL( "SwFltOutDoc:GetBox:ny >= Count()");
1500 0 : ny = pTableLines->size() - 1;
1501 : }
1502 0 : SwTableLine* pTableLine = (*pTableLines)[ny];
1503 0 : if(!pTableLine){
1504 : OSL_FAIL("SwFltOutDoc:GetBox:pTableLine");
1505 0 : return 0;
1506 : }
1507 0 : SwTableBoxes* pTableBoxes = &pTableLine->GetTabBoxes();
1508 0 : if(!pTableBoxes){
1509 : OSL_FAIL("SwFltOutDoc:GetBox:pTableBoxes");
1510 0 : return 0;
1511 : }
1512 0 : if( nx >= pTableBoxes->size() ){ // Notbremse
1513 : OSL_FAIL("SwFltOutDoc:GetBox:nx >= Count()");
1514 0 : nx = pTableBoxes->size() - 1;
1515 : }
1516 0 : SwTableBox* pTableBox = (*pTableBoxes)[nx];
1517 :
1518 : OSL_ENSURE(pTableBox != 0, "SwFltOutDoc:GetBox:pTableBox");
1519 0 : return pTableBox;
1520 : }
1521 :
1522 0 : void SwFltOutDoc::NextTableCell()
1523 : {
1524 0 : if(!pTable){
1525 : OSL_ENSURE(pTable, "NextTableCell ohne Tabelle");
1526 0 : return;
1527 : }
1528 0 : const SwTableLines* pTableLines = &pTable->GetTabLines();
1529 0 : SwTableLine* pTableLine = (*pTableLines)[usTableY];
1530 0 : SwTableBoxes* pTableBoxes = &pTableLine->GetTabBoxes();
1531 0 : SwTableBox* pTableBox = (*pTableBoxes)[usTableX];
1532 : OSL_ENSURE(pTableBox != 0, "SwFltOutDoc:NextTableCell:pTableBox");
1533 0 : if(!pTableBox)
1534 0 : return;
1535 : //#pragma message(__FILE__ "(?) : Sw's const problem")
1536 : // insert cells:
1537 0 : if (++usTableX >= pTableBoxes->size())
1538 0 : GetDoc().GetNodes().InsBoxen(
1539 0 : GetDoc().IsIdxInTbl(pPaM->GetPoint()->nNode),
1540 : pTableLine,
1541 0 : (SwTableBoxFmt*)pTableBox->GetFrmFmt(),
1542 0 : GetDoc().GetTxtCollFromPool(RES_POOLCOLL_STANDARD, false ),
1543 : 0,
1544 0 : pTableBoxes->size());
1545 0 : SeekCell(usTableY, usTableX, sal_True);
1546 0 : pTableBox = (*pTableBoxes)[usTableX];
1547 : OSL_ENSURE(pTableBox != 0, "SwFltOutDoc:pTableBox");
1548 0 : if(pTableBox)
1549 0 : (*pTableBoxes)[usTableX]->ClaimFrmFmt();
1550 : }
1551 :
1552 0 : void SwFltOutDoc::NextTableRow()
1553 : {
1554 0 : SwTableBox* pTableBox = GetBox(usTableY, 0);
1555 0 : if (pTableBox)
1556 : {
1557 : // duplicate row:
1558 0 : SwSelBoxes aSelBoxes;
1559 0 : aSelBoxes.insert( pTableBox );
1560 0 : GetDoc().InsertRow(aSelBoxes);
1561 0 : usTableX = 0;
1562 0 : SeekCell(++usTableY, usTableX, sal_True);
1563 0 : GetDoc().SetTxtFmtColl(*pPaM,
1564 0 : GetDoc().GetTxtCollFromPool(RES_POOLCOLL_STANDARD, false ));
1565 : }
1566 0 : }
1567 :
1568 0 : void SwFltOutDoc::SetTableWidth(SwTwips nSwWidth)
1569 : {
1570 0 : if(!pTable){
1571 : OSL_ENSURE(pTable, "SetTableWidth ohne Tabelle");
1572 0 : return;
1573 : }
1574 : OSL_ENSURE( nSwWidth > MINLAY, "Tabellenbreite <= MINLAY" );
1575 0 : if( nSwWidth != nTableWidth ){
1576 0 : if( nTableWidth ) // Nicht beim ersten Setzen
1577 0 : SplitTable();
1578 0 : pTable->GetFrmFmt()->SetFmtAttr( SwFmtFrmSize(ATT_VAR_SIZE, nSwWidth));
1579 0 : nTableWidth = nSwWidth;
1580 : }
1581 : }
1582 :
1583 0 : void SwFltOutDoc::SetTableOrient(sal_Int16 eOri)
1584 : {
1585 0 : if(!pTable){
1586 : OSL_ENSURE(pTable, "SetTableOrient ohne Tabelle");
1587 0 : return;
1588 : }
1589 0 : pTable->GetFrmFmt()->SetFmtAttr( SwFmtHoriOrient( 0, eOri ));
1590 : }
1591 :
1592 0 : void SwFltOutDoc::SetCellWidth(SwTwips nWidth, sal_uInt16 nCell /* = USHRT_MAX */ )
1593 : {
1594 0 : if(!pTable){
1595 : OSL_ENSURE(pTable, "SetCellWidth ohne Tabelle");
1596 0 : return;
1597 : }
1598 : OSL_ENSURE( nWidth > MINLAY, "Tabellenzellenbreite <= MINLAY" );
1599 0 : if (nWidth < MINLAY)
1600 0 : nWidth = MINLAY;
1601 :
1602 0 : SwTableBox* pTableBox = GetBox(usTableY, nCell);
1603 0 : if(pTableBox && pTableBox->GetFrmFmt() ){
1604 0 : SwFmtFrmSize aFmtFrmSize(ATT_FIX_SIZE);
1605 0 : aFmtFrmSize.SetWidth(nWidth);
1606 0 : pTableBox->GetFrmFmt()->SetFmtAttr(aFmtFrmSize);
1607 : }
1608 : }
1609 :
1610 0 : void SwFltOutDoc::SetCellHeight(SwTwips nHeight)
1611 : {
1612 0 : if(!pTable){
1613 : OSL_ENSURE(pTable, "SetCellHeight ohne Tabelle");
1614 0 : return;
1615 : }
1616 :
1617 0 : const SwTableLines* pTableLines = &pTable->GetTabLines();
1618 0 : SwTableLine* pTableLine = (*pTableLines)[usTableY];
1619 0 : SwFmtFrmSize aFmtFrmSize(ATT_MIN_SIZE, 0, 0);
1620 0 : if (nHeight < MINLAY)
1621 0 : nHeight = MINLAY;
1622 0 : aFmtFrmSize.SetHeight(nHeight);
1623 0 : pTableLine->GetFrmFmt()->SetFmtAttr(aFmtFrmSize);
1624 : }
1625 :
1626 0 : const SfxPoolItem& SwFltOutDoc::GetCellAttr(sal_uInt16 nWhich)
1627 : {
1628 0 : if (!pTable){
1629 : OSL_ENSURE(pTable, "GetCellAttr ohne Table");
1630 0 : return GetDoc().GetAttrPool().GetDefaultItem(nWhich);
1631 : }
1632 :
1633 0 : SwTableBox* pTableBox = GetBox(usTableY, usTableX);
1634 0 : if(!pTableBox)
1635 0 : return GetDoc().GetAttrPool().GetDefaultItem(nWhich);
1636 0 : return pTableBox->GetFrmFmt()->GetFmtAttr( nWhich );
1637 : }
1638 :
1639 0 : void SwFltOutDoc::SetCellBorder(const SvxBoxItem& rFmtBox,
1640 : sal_uInt16 nCell /* = USHRT_MAX */ )
1641 : {
1642 0 : SwTableBox* pTableBox = GetBox(usTableY, nCell);
1643 0 : if(pTableBox)
1644 0 : pTableBox->GetFrmFmt()->SetFmtAttr(rFmtBox);
1645 0 : }
1646 :
1647 : // nicht aktiviert !!!
1648 0 : void SwFltOutDoc::SetCellSpace(sal_uInt16 nDist)
1649 : {
1650 0 : if(!pTable){
1651 : OSL_ENSURE(pTable, "SetCellSpace ohne Tabelle");
1652 0 : return;
1653 : }
1654 0 : SwTableBox* pTableBox = GetBox(usTableY, usTableX);
1655 0 : if(!pTableBox)
1656 0 : return;
1657 :
1658 : SvxBoxItem aFmtBox( *((SvxBoxItem*)
1659 0 : &pTableBox->GetFrmFmt()->GetFmtAttr( RES_BOX )));
1660 :
1661 : // versteh ich nich, sven: if (!nDist) nDist = 18; // ca. 0.03 cm
1662 0 : if (nDist > 42) // max. 0.7 mm
1663 0 : nDist = 42;
1664 : else
1665 0 : if (nDist < MIN_BORDER_DIST)
1666 0 : nDist = MIN_BORDER_DIST;
1667 0 : aFmtBox.SetDistance(nDist);
1668 0 : pTableBox->GetFrmFmt()->SetFmtAttr(aFmtBox);
1669 : }
1670 :
1671 0 : void SwFltOutDoc::DeleteCell(sal_uInt16 nCell /* = USHRT_MAX */)
1672 : {
1673 0 : SwTableBox* pTableBox = GetBox(usTableY, nCell);
1674 0 : if( pTableBox )
1675 : {
1676 0 : SwSelBoxes aSelBoxes;
1677 0 : aSelBoxes.insert( pTableBox );
1678 0 : GetDoc().DeleteRowCol(aSelBoxes);
1679 0 : usTableX--;
1680 : }
1681 0 : }
1682 :
1683 0 : void SwFltOutDoc::SplitTable()
1684 : {
1685 0 : if(!pTable)
1686 : {
1687 : OSL_ENSURE(pTable, "SplitTable ohne Tabelle");
1688 0 : return;
1689 : }
1690 0 : SwTableBox* pAktBox = GetBox(usTableY, usTableX);
1691 0 : SwTableBox* pSplitBox = GetBox(usTableY - 1, 0);
1692 0 : GetDoc().GetNodes().SplitTable(SwNodeIndex(*pSplitBox->GetSttNd()), false);
1693 0 : pTable = &pAktBox->GetSttNd()->FindTableNode()->GetTable();
1694 0 : usTableY = 0;
1695 : }
1696 :
1697 0 : void SwFltOutDoc::EndTable()
1698 : {
1699 0 : if (!pTable){
1700 : OSL_ENSURE(pTable, "EndTable ohne Table");
1701 0 : return;
1702 : }
1703 : // Alle Attribute schliessen, da sonst Attribute
1704 : // entstehen koennen, die in Flys reinragen
1705 0 : rStack.SetAttr( *pPaM->GetPoint(), 0, sal_False );
1706 0 : rEndStack.SetAttr( *pPaM->GetPoint(), 0, sal_False );
1707 :
1708 0 : if (GetDoc().GetCurrentViewShell()){ //swmod 071108//swmod 071225
1709 0 : SwTableNode* pTableNode = GetDoc().IsIdxInTbl(
1710 0 : pPaM->GetPoint()->nNode);
1711 0 : pTableNode->DelFrms();
1712 0 : pTableNode->MakeFrms(&pPaM->GetPoint()->nNode);
1713 : }
1714 :
1715 0 : *pPaM->GetPoint() = *pTabSavedPos; // restore Cursor
1716 0 : delete pTabSavedPos;
1717 0 : pTabSavedPos = 0;
1718 0 : ((SwTable*)pTable)->UnlockModify(); // Test, nuetzt nichts gegen Assert
1719 0 : pTable = 0;
1720 0 : nTableWidth = 0;
1721 : }
1722 :
1723 0 : sal_Bool SwFltOutDoc::SeekCell(short nRow, short nCol, sal_Bool bPam)
1724 : {
1725 : // get structs to table cells
1726 0 : const SwTableLines* pTableLines = &pTable->GetTabLines();
1727 0 : SwTableLine* pTableLine = (*pTableLines)[usTableY];
1728 0 : SwTableBoxes* pTableBoxes = &pTableLine->GetTabBoxes();
1729 0 : SwTableBox* pTableBox = (*pTableBoxes)[usTableX];
1730 :
1731 0 : if ((sal_uInt16)nRow >= pTableLines->size())
1732 : {
1733 : OSL_ENSURE((sal_uInt16)nRow >= pTableLines->size(), "SwFltOutDoc");
1734 0 : return sal_False;
1735 : }
1736 0 : pTableLine = (*pTableLines)[nRow];
1737 0 : pTableBoxes = &pTableLine->GetTabBoxes();
1738 0 : if (nCol >= (short)pTableBoxes->size())
1739 0 : return sal_False;
1740 0 : pTableBox = (*pTableBoxes)[nCol];
1741 0 : if( !pTableBox->GetSttNd() )
1742 : {
1743 : OSL_ENSURE(pTableBox->GetSttNd(), "SwFltOutDoc");
1744 0 : return sal_False;
1745 : }
1746 0 : if(bPam)
1747 : {
1748 0 : pPaM->GetPoint()->nNode = pTableBox->GetSttIdx() + 1;
1749 0 : pPaM->GetPoint()->nContent.Assign(pPaM->GetCntntNode(), 0);
1750 0 : GetDoc().SetTxtFmtColl(*pPaM,
1751 0 : GetDoc().GetTxtCollFromPool(RES_POOLCOLL_STANDARD, false ));
1752 : }
1753 0 : return sal_True;
1754 : }
1755 :
1756 :
1757 : //-----------------------------------------------------------------------------
1758 : // Flys in SwFltOutBase
1759 : //-----------------------------------------------------------------------------
1760 :
1761 0 : SfxItemSet* SwFltOutBase::NewFlyDefaults()
1762 : {
1763 : // Unbedingt noetige Standardwerte setzen ( falls diese Werte nicht
1764 : // spaeter explizit gesetzt werden )
1765 :
1766 0 : SfxItemSet* p = new SfxItemSet( GetDoc().GetAttrPool(),
1767 0 : RES_FRMATR_BEGIN, RES_FRMATR_END-1 );
1768 0 : SwFmtFrmSize aSz( ATT_VAR_SIZE, MINFLY, MINFLY );
1769 : // Default: Breite 100% ( = PMW:Auto )
1770 0 : aSz.SetWidthPercent( 100 ); // Hoehe: Auto
1771 0 : p->Put( aSz );
1772 0 : p->Put( SwFmtHoriOrient( 0, text::HoriOrientation::NONE, text::RelOrientation::FRAME ));
1773 0 : return p;
1774 : }
1775 :
1776 0 : bool SwFltOutBase::BeginFly( RndStdIds eAnchor /*= FLY_AT_PARA*/,
1777 : sal_Bool bAbsolutePos /*= sal_False*/,
1778 : const SfxItemSet* pMoreAttrs /*= 0*/)
1779 : {
1780 : (void) pMoreAttrs; // unused in non-debug
1781 : OSL_ENSURE(!pMoreAttrs, "SwFltOutBase:BeginFly mit pMoreAttrs" );
1782 0 : eFlyAnchor = eAnchor;
1783 0 : bFlyAbsPos = bAbsolutePos; // Bloedsinn eigentlich
1784 0 : return true;
1785 : }
1786 :
1787 0 : /*virtual*/ void SwFltOutBase::SetFlyAnchor( RndStdIds eAnchor )
1788 : {
1789 0 : if( !IsInFly() ){
1790 : OSL_FAIL( "SetFlyAnchor() ohne Fly" );
1791 0 : return;
1792 : }
1793 0 : if ( eAnchor == FLY_AS_CHAR ){
1794 : OSL_FAIL( "SetFlyAnchor( FLY_AS_CHAR ) nicht implementiert" );
1795 0 : return;
1796 : }
1797 0 : SwFmtAnchor& rAnchor = (SwFmtAnchor&)GetFlyFrmAttr( RES_ANCHOR );
1798 0 : rAnchor.SetType( eAnchor );
1799 : }
1800 :
1801 0 : void SwFltOutBase::EndFly()
1802 : {
1803 0 : if( bFlyAbsPos ){
1804 : // hier muessen die absoluten Positionen am Fly noch in
1805 : // die Writer-Koordinaten umgerechnet werden.
1806 : }
1807 0 : }
1808 :
1809 : //-----------------------------------------------------------------------------
1810 : // Flys in SwFltDoc
1811 : //-----------------------------------------------------------------------------
1812 :
1813 0 : /* virtual */ bool SwFltOutDoc::IsInFly()
1814 : {
1815 0 : return pFly != 0;
1816 : };
1817 :
1818 0 : SwFrmFmt* SwFltOutDoc::MakeFly( RndStdIds eAnchor, SfxItemSet* pSet )
1819 : {
1820 0 : pFly = (SwFlyFrmFmt*)GetDoc().MakeFlySection( eAnchor, pPaM->GetPoint(),
1821 0 : pSet );
1822 0 : return pFly;
1823 : }
1824 :
1825 0 : bool SwFltOutDoc::BeginFly( RndStdIds eAnchor,
1826 : sal_Bool bAbsolutePos ,
1827 : const SfxItemSet* pMoreAttrs)
1828 :
1829 : {
1830 0 : SwFltOutBase::BeginFly( eAnchor, bAbsolutePos, 0 );
1831 0 : SfxItemSet* pSet = NewFlyDefaults();
1832 :
1833 : // Alle Attribute schliessen, da sonst Attribute entstehen koennen,
1834 : // die in Flys reinragen
1835 0 : rStack.SetAttr( *pPaM->GetPoint(), 0, sal_False );
1836 0 : rEndStack.SetAttr( *pPaM->GetPoint(), 0, sal_False );
1837 :
1838 : // create Fly:
1839 : OSL_ENSURE(pFlySavedPos == NULL, "BeginFly in Fly"); // rekursiv geht noch nicht
1840 0 : pFlySavedPos = new SwPosition(*pPaM->GetPoint());
1841 :
1842 :
1843 0 : SwFmtAnchor aAnchor( eAnchor, 1 );
1844 :
1845 : // Wenn Fly-Attribute im Style waren, dann jetzt als Defaults reinsetzen
1846 0 : if (pMoreAttrs)
1847 0 : pSet->Put(*pMoreAttrs);
1848 :
1849 : // dieses NICHT bei Seitengebundenem Fly mit Seiten-NUMMER !
1850 0 : aAnchor.SetAnchor(pPaM->GetPoint()); // braucht erstaunlicherweise
1851 : // den Stack nicht
1852 :
1853 0 : pSet->Put( aAnchor );
1854 0 : SwFrmFmt* pF = MakeFly( eAnchor, pSet );
1855 0 : delete pSet;
1856 :
1857 : // set pam in Fly
1858 0 : const SwFmtCntnt& rCntnt = pF->GetCntnt();
1859 : OSL_ENSURE( rCntnt.GetCntntIdx(), "Kein Inhalt vorbereitet." );
1860 0 : pPaM->GetPoint()->nNode = rCntnt.GetCntntIdx()->GetIndex() + 1;
1861 0 : SwCntntNode *pNode = pPaM->GetCntntNode();
1862 0 : pPaM->GetPoint()->nContent.Assign( pNode, 0 );
1863 :
1864 0 : return true;
1865 : }
1866 :
1867 0 : /*virtual*/ void SwFltOutDoc::SetFlyFrmAttr(const SfxPoolItem& rAttr)
1868 : {
1869 0 : if (pFly){
1870 0 : pFly->SetFmtAttr( rAttr );
1871 : }else{
1872 : OSL_ENSURE(pFly, "SetFlyAttr ohne Doc-Fly");
1873 0 : return;
1874 : }
1875 : }
1876 :
1877 0 : /*virtual*/ const SfxPoolItem& SwFltOutDoc::GetFlyFrmAttr(sal_uInt16 nWhich)
1878 : {
1879 0 : if (pFly){
1880 0 : return pFly->GetFmtAttr( nWhich );
1881 : }else{
1882 : OSL_ENSURE(pFly, "GetFlyAttr ohne Fly");
1883 0 : return GetDoc().GetAttrPool().GetDefaultItem(nWhich);
1884 : }
1885 : }
1886 :
1887 0 : void SwFltOutDoc::EndFly()
1888 : {
1889 0 : if( pTable ){
1890 : OSL_FAIL( "SwFltOutDoc::EndFly() in Table" );
1891 0 : return;
1892 : }
1893 : // Alle Attribute schliessen, da sonst Attribute
1894 : // entstehen koennen, die aus Flys rausragen
1895 0 : rStack.SetAttr( *pPaM->GetPoint(), 0, sal_False );
1896 0 : rEndStack.SetAttr( *pPaM->GetPoint(), 0, sal_False );
1897 :
1898 0 : *pPaM->GetPoint() = *pFlySavedPos; // restore Cursor
1899 0 : delete pFlySavedPos;
1900 0 : pFlySavedPos = 0;
1901 0 : SwFltOutBase::EndFly();
1902 0 : pFly = 0;
1903 : }
1904 :
1905 : //-----------------------------------------------------------------------------
1906 : // Flys in SwFltFormatCollection
1907 : //-----------------------------------------------------------------------------
1908 0 : /*virtual*/ bool SwFltFormatCollection::IsInFly()
1909 : {
1910 0 : return bHasFly;
1911 : };
1912 :
1913 0 : /*virtual*/ void SwFltFormatCollection::SetFlyFrmAttr(const SfxPoolItem& rAttr)
1914 : {
1915 0 : if (!pFlyAttrs)
1916 0 : pFlyAttrs = new SfxItemSet( GetDoc().GetAttrPool(),
1917 0 : RES_FRMATR_BEGIN, RES_FRMATR_END-1 );
1918 0 : pFlyAttrs->Put( rAttr );
1919 0 : }
1920 :
1921 0 : /*virtual*/ const SfxPoolItem& SwFltFormatCollection::GetFlyFrmAttr(sal_uInt16 nWhich)
1922 : {
1923 0 : if( pFlyAttrs )
1924 0 : return pFlyAttrs->Get( nWhich, sal_False );
1925 : else
1926 0 : return GetDoc().GetAttrPool().GetDefaultItem(nWhich);
1927 : }
1928 :
1929 0 : bool SwFltFormatCollection::BeginFly( RndStdIds eAnchor,
1930 : sal_Bool bAbsolutePos,
1931 : const SfxItemSet* pMoreAttrs)
1932 :
1933 : {
1934 0 : SwFltOutBase::BeginFly( eAnchor, bAbsolutePos, pMoreAttrs );
1935 0 : bHasFly = true;
1936 0 : return true;
1937 : }
1938 :
1939 0 : void SwFltFormatCollection::EndFly() // Wird nie aufgerufen
1940 : {
1941 0 : }
1942 :
1943 0 : bool SwFltFormatCollection::BeginStyleFly( SwFltOutDoc* pOutDoc )
1944 : {
1945 : OSL_ENSURE( pOutDoc, "BeginStyleFly ohne pOutDoc" );
1946 : OSL_ENSURE( pOutDoc && !pOutDoc->IsInFly(), "BeginStyleFly in Fly" );
1947 0 : if( pOutDoc && !pOutDoc->IsInFly() )
1948 0 : return pOutDoc->BeginFly( eFlyAnchor, bFlyAbsPos, pFlyAttrs );
1949 : else
1950 0 : return false;
1951 : }
1952 :
1953 : //-----------------------------------------------------------------------------
1954 : // Flys in SwFltShell
1955 : //-----------------------------------------------------------------------------
1956 :
1957 0 : bool SwFltShell::BeginFly( RndStdIds eAnchor,
1958 : sal_Bool bAbsolutePos)
1959 : {
1960 0 : if (pOut->IsInFly()){
1961 : OSL_FAIL("BeginFly in Fly");
1962 0 : return false;
1963 : }
1964 0 : if (pOutDoc->IsInTable()){
1965 : OSL_FAIL("BeginFly in Table");
1966 0 : return false;
1967 : }
1968 0 : pOut->BeginFly( eAnchor, bAbsolutePos, pColls[nAktStyle]->GetpFlyAttrs() );
1969 0 : eSubMode = Fly;
1970 0 : return true;
1971 : }
1972 :
1973 0 : void SwFltShell::SetFlyXPos( short nXPos, sal_Int16 eHRel,
1974 : sal_Int16 eHAlign)
1975 : {
1976 0 : SetFlyFrmAttr( SwFmtHoriOrient( nXPos, eHAlign, eHRel ) );
1977 0 : }
1978 :
1979 0 : void SwFltShell::SetFlyYPos( short nYPos, sal_Int16 eVRel,
1980 : sal_Int16 eVAlign)
1981 : {
1982 0 : SetFlyFrmAttr( SwFmtVertOrient( nYPos, eVAlign, eVRel ) );
1983 0 : }
1984 :
1985 :
1986 0 : void SwFltShell::EndFly()
1987 : {
1988 0 : if (!pOut->IsInFly()){
1989 : OSL_FAIL("EndFly ohne Fly");
1990 0 : return;
1991 : }
1992 0 : if (pOutDoc->IsInTable()){ // Table verschraenkt mit Fly macht keinen Sinn
1993 : OSL_FAIL("EndFly in Table ( verschraenkt )");
1994 0 : EndTable(); // -> Table beenden
1995 : }
1996 0 : pOut->EndFly();
1997 0 : eSubMode = None;
1998 : }
1999 :
2000 : //-----------------------------------------------------------------------------
2001 : // Fussnoten
2002 : //-----------------------------------------------------------------------------
2003 :
2004 0 : void SwFltShell::BeginFootnote()
2005 : {
2006 0 : if( pOut->IsInFly() ){ // Passiert z.B. bei Fussnote in Fly
2007 : OSL_FAIL("Fussnote in Fly nicht erlaubt");
2008 0 : return;
2009 : }
2010 0 : if( pOutDoc->IsInTable() ){
2011 : OSL_FAIL("Fussnote in Table z.Zt. nicht erlaubt");
2012 0 : return;
2013 : }
2014 :
2015 : // Alle Attribute schliessen, da sonst Attribute entstehen koennen,
2016 : // die in Fussnoten reinragen
2017 0 : aStack.SetAttr( *pPaM->GetPoint(), 0, sal_False );
2018 : // EndStack erstmal nicht zwangs-Schliessen, damit Bookmarks ueber
2019 : // Fussnoten im PMW uebernommen werden
2020 :
2021 0 : SwFmtFtn aFtn;
2022 0 : GetDoc().InsertPoolItem(*pPaM, aFtn, 0);
2023 : OSL_ENSURE(pSavedPos == NULL, "SwFltShell");
2024 0 : pSavedPos = new SwPosition(*pPaM->GetPoint());
2025 0 : pPaM->Move(fnMoveBackward, fnGoCntnt);
2026 0 : SwTxtNode* pTxt = pPaM->GetNode()->GetTxtNode();
2027 : SwTxtAttr *const pFN = pTxt->GetTxtAttrForCharAt(
2028 0 : pPaM->GetPoint()->nContent.GetIndex(), RES_TXTATR_FTN);
2029 0 : if( !pFN ){ // Passiert z.B. bei Fussnote in Fly
2030 : OSL_ENSURE(pFN, "Probleme beim Anlegen des Fussnoten-Textes");
2031 0 : return;
2032 : }
2033 0 : const SwNodeIndex* pStartIndex = ((SwTxtFtn*)pFN)->GetStartNode();
2034 : OSL_ENSURE(pStartIndex, "Probleme beim Anlegen des Fussnoten-Textes");
2035 0 : pPaM->GetPoint()->nNode = pStartIndex->GetIndex() + 1;
2036 0 : pPaM->GetPoint()->nContent.Assign(pPaM->GetCntntNode(), 0);
2037 0 : eSubMode = Footnote;
2038 : }
2039 :
2040 0 : void SwFltShell::EndFootnote()
2041 : {
2042 0 : if(!pSavedPos)
2043 0 : return;
2044 : // Alle Attribute schliessen, da sonst Attribute
2045 : // entstehen koennen, die aus Fussnoten rausragen
2046 0 : aStack.SetAttr( *pPaM->GetPoint(), 0, sal_False );
2047 : // EndStack erstmal nicht zwangs-Schliessen, damit Bookmarks ueber
2048 : // Fussnoten im PMW uebernommen werden
2049 :
2050 0 : *pPaM->GetPoint() = *pSavedPos; // restore Cursor
2051 0 : delete pSavedPos;
2052 0 : pSavedPos = 0;
2053 : }
2054 :
2055 0 : void SwFltShell::BeginHeader(SwPageDesc* /*pPD*/)
2056 : {
2057 0 : SwFrmFmt* pFmt = &pCurrentPageDesc->GetMaster();
2058 : SwFrmFmt* pHdFtFmt;
2059 0 : pFmt->SetFmtAttr(SwFmtHeader(sal_True));
2060 0 : pHdFtFmt = (SwFrmFmt*)pFmt->GetHeader().GetHeaderFmt();
2061 0 : const SwNodeIndex* pStartIndex = pHdFtFmt->GetCntnt().GetCntntIdx();
2062 0 : if (!pStartIndex)
2063 0 : return;
2064 : OSL_ENSURE(pSavedPos == NULL, "SwFltShell");
2065 0 : pSavedPos = new SwPosition(*pPaM->GetPoint());
2066 0 : pPaM->GetPoint()->nNode = pStartIndex->GetIndex() + 1;
2067 0 : pPaM->GetPoint()->nContent.Assign(pPaM->GetCntntNode(), 0);
2068 0 : eSubMode = Header;
2069 : }
2070 :
2071 0 : void SwFltShell::BeginFooter(SwPageDesc* /*pPD*/)
2072 : {
2073 0 : SwFrmFmt* pFmt = &pCurrentPageDesc->GetMaster();
2074 : SwFrmFmt* pHdFtFmt;
2075 0 : pFmt->SetFmtAttr(SwFmtFooter(sal_True));
2076 0 : pHdFtFmt = (SwFrmFmt*)pFmt->GetFooter().GetFooterFmt();
2077 0 : const SwNodeIndex* pStartIndex = pHdFtFmt->GetCntnt().GetCntntIdx();
2078 0 : if (!pStartIndex)
2079 0 : return;
2080 : OSL_ENSURE(pSavedPos == NULL, "SwFltShell");
2081 0 : pSavedPos = new SwPosition(*pPaM->GetPoint());
2082 0 : pPaM->GetPoint()->nNode = pStartIndex->GetIndex() + 1;
2083 0 : pPaM->GetPoint()->nContent.Assign(pPaM->GetCntntNode(), 0);
2084 0 : eSubMode = Footer;
2085 : }
2086 :
2087 0 : void SwFltShell::EndHeaderFooter()
2088 : {
2089 0 : *pPaM->GetPoint() = *pSavedPos; // restore Cursor
2090 0 : delete pSavedPos;
2091 0 : pSavedPos = 0;
2092 0 : }
2093 :
2094 0 : SwPageDesc* SwFltShell::MakePageDesc(SwPageDesc* pFirstPageDesc)
2095 : {
2096 0 : if(bStdPD) // keine Neuen PageDescs
2097 0 : return pCurrentPageDesc;
2098 :
2099 0 : bool bFollow = (pFirstPageDesc != 0);
2100 : SwPageDesc* pNewPD;
2101 : sal_uInt16 nPos;
2102 0 : if (bFollow && pFirstPageDesc->GetFollow() != pFirstPageDesc)
2103 0 : return pFirstPageDesc; // Fehler: hat schon Follow
2104 : // Erkennung doppelter Namen fehlt noch (Wahrscheinlichkeit
2105 : // fuer dopp. Namen ist gering)
2106 :
2107 0 : nPos = GetDoc().MakePageDesc( ViewShell::GetShellRes()->GetPageDescName(
2108 0 : GetDoc().GetPageDescCnt(), bFollow ? ShellResource::FOLLOW_PAGE : ShellResource::NORMAL_PAGE),
2109 0 : pFirstPageDesc, false );
2110 :
2111 0 : pNewPD = &GetDoc().GetPageDesc(nPos);
2112 0 : if (bFollow)
2113 : { // Dieser ist der folgende von pPageDesc
2114 0 : pFirstPageDesc->SetFollow(pNewPD);
2115 0 : pNewPD->SetFollow(pNewPD);
2116 : }
2117 : else
2118 : {
2119 0 : GetDoc().InsertPoolItem( *pPaM, SwFmtPageDesc( pNewPD ), 0 );
2120 : }
2121 : pNewPD->WriteUseOn( // alle Seiten
2122 0 : (UseOnPage)(nsUseOnPage::PD_ALL | nsUseOnPage::PD_HEADERSHARE | nsUseOnPage::PD_FOOTERSHARE));
2123 0 : return pNewPD;
2124 : }
2125 :
2126 : ///////////////////////////////////////////////// SwFltFormatCollection
2127 0 : SwFltFormatCollection::SwFltFormatCollection(
2128 : SwDoc& _rDoc, RES_POOL_COLLFMT_TYPE nType ) :
2129 : SwFltOutBase(_rDoc),
2130 0 : pColl(_rDoc.GetTxtCollFromPool( static_cast< sal_uInt16 >(nType), false )),
2131 : pFlyAttrs( 0 ),
2132 0 : bHasFly( false )
2133 : {
2134 0 : Reset(); // Default-Attrs loeschen und Auto-Flag
2135 0 : }
2136 :
2137 0 : SwFltFormatCollection::SwFltFormatCollection(
2138 : SwDoc& _rDoc, const String& rName ) :
2139 : SwFltOutBase(_rDoc),
2140 : pFlyAttrs( 0 ),
2141 0 : bHasFly( false )
2142 : {
2143 0 : pColl = _rDoc.MakeTxtFmtColl(rName, (SwTxtFmtColl*)_rDoc.GetDfltTxtFmtColl());
2144 0 : Reset(); // Default-Attrs loeschen und Auto-Flag
2145 0 : }
2146 :
2147 0 : void SwFltShell::NextStyle(sal_uInt16 nWhich, sal_uInt16 nNext)
2148 : {
2149 : OSL_ENSURE(pColls[nWhich], "Next style for noexistent style" );
2150 : OSL_ENSURE(pColls[nNext], "Next style to noexistent style" );
2151 0 : if( pColls[nWhich] && pColls[nNext] )
2152 0 : pColls[nWhich]->GetColl()->SetNextTxtFmtColl(
2153 0 : *pColls[nNext]->GetColl() );
2154 0 : }
2155 :
2156 : // UpdatePageDescs muss am Ende des Einlesevorganges aufgerufen werden, damit
2157 : // der Writer den Inhalt der Pagedescs wirklich akzeptiert
2158 50 : void UpdatePageDescs(SwDoc &rDoc, sal_uInt16 nInPageDescOffset)
2159 : {
2160 : // Pagedescriptoren am Dokument updaten (nur so werden auch die
2161 : // linken Seiten usw. eingestellt).
2162 :
2163 : // PageDesc "Standard"
2164 50 : rDoc.ChgPageDesc(0, rDoc.GetPageDesc(0));
2165 :
2166 : // PageDescs "Konvert..."
2167 58 : for (sal_uInt16 i = nInPageDescOffset; i < rDoc.GetPageDescCnt(); ++i)
2168 8 : rDoc.ChgPageDesc(i, rDoc.GetPageDesc(i));
2169 149 : }
2170 :
2171 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
