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