Branch data Line data Source code
1 : : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : : /*************************************************************************
3 : : *
4 : : * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5 : : *
6 : : * Copyright 2000, 2010 Oracle and/or its affiliates.
7 : : *
8 : : * OpenOffice.org - a multi-platform office productivity suite
9 : : *
10 : : * This file is part of OpenOffice.org.
11 : : *
12 : : * OpenOffice.org is free software: you can redistribute it and/or modify
13 : : * it under the terms of the GNU Lesser General Public License version 3
14 : : * only, as published by the Free Software Foundation.
15 : : *
16 : : * OpenOffice.org is distributed in the hope that it will be useful,
17 : : * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 : : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 : : * GNU Lesser General Public License version 3 for more details
20 : : * (a copy is included in the LICENSE file that accompanied this code).
21 : : *
22 : : * You should have received a copy of the GNU Lesser General Public License
23 : : * version 3 along with OpenOffice.org. If not, see
24 : : * <http://www.openoffice.org/license.html>
25 : : * for a copy of the LGPLv3 License.
26 : : *
27 : : ************************************************************************/
28 : :
29 : : #include <hintids.hxx>
30 : :
31 : : #include <stack>
32 : :
33 : : #include <tools/errinf.hxx>
34 : : #include <tools/stream.hxx>
35 : : #include <tools/helpers.hxx>
36 : : #include <svl/itemiter.hxx>
37 : : #include <svtools/rtftoken.h>
38 : : #include <svtools/miscopt.hxx>
39 : : #include <svl/intitem.hxx>
40 : : #include <editeng/fhgtitem.hxx>
41 : : #include <editeng/ulspitem.hxx>
42 : : #include <editeng/tstpitem.hxx>
43 : : #include <editeng/lspcitem.hxx>
44 : : #include <editeng/lrspitem.hxx>
45 : : #include <editeng/escpitem.hxx>
46 : : #include <editeng/fontitem.hxx>
47 : : #include <editeng/frmdiritem.hxx>
48 : : #include <editeng/hyznitem.hxx>
49 : : #include <fmtpdsc.hxx>
50 : : #include <fmtfld.hxx>
51 : : #include <fmthdft.hxx>
52 : : #include <fmtcntnt.hxx>
53 : : #include <txtftn.hxx>
54 : : #include <fmtclds.hxx>
55 : : #include <fmtftn.hxx>
56 : : #include <fmtfsize.hxx>
57 : : #include <fmtflcnt.hxx>
58 : : #include <fmtanchr.hxx>
59 : : #include <frmatr.hxx>
60 : : #include <docstat.hxx>
61 : : #include <swtable.hxx>
62 : : #include <shellio.hxx>
63 : : #include <swtypes.hxx>
64 : : #include <ndtxt.hxx>
65 : : #include <doc.hxx>
66 : : #include <docary.hxx>
67 : : #include <pam.hxx>
68 : : #include <mdiexp.hxx> // ...Percent()
69 : : #include <swparrtf.hxx>
70 : : #include <charfmt.hxx>
71 : : #include <pagedesc.hxx>
72 : : #include <ftninfo.hxx>
73 : : #include <docufld.hxx>
74 : : #include <flddat.hxx>
75 : : #include <fltini.hxx>
76 : : #include <fchrfmt.hxx>
77 : : #include <paratr.hxx>
78 : : #include <section.hxx>
79 : : #include <fmtclbl.hxx>
80 : : #include <viewsh.hxx>
81 : : #include <shellres.hxx>
82 : : #include <hfspacingitem.hxx>
83 : : #include <tox.hxx>
84 : : #include <swerror.h>
85 : : #include <cmdid.h>
86 : : #include <statstr.hrc> // ResId fuer Statusleiste
87 : : #include <SwStyleNameMapper.hxx>
88 : : #include <tblsel.hxx> // SwSelBoxes
89 : :
90 : : #include <docsh.hxx>
91 : : #include <fmtlsplt.hxx> // SwLayoutSplit
92 : : #include <editeng/keepitem.hxx>
93 : : #include <svx/svdopath.hxx>
94 : : #include <svx/svdorect.hxx>
95 : :
96 : :
97 : : #include <fmtsrnd.hxx>
98 : : #include <fmtfollowtextflow.hxx>
99 : : #include <svx/svdmodel.hxx>
100 : : #include <svx/svdpage.hxx>
101 : : #include <editeng/opaqitem.hxx>
102 : : #include "svx/svdograf.hxx"
103 : : #include <svx/xflclit.hxx>
104 : : #include <svx/xlnwtit.hxx>
105 : : #include <svx/svdoutl.hxx>
106 : : #include <unotools/streamwrap.hxx>
107 : : #include <comphelper/processfactory.hxx>
108 : : #include <comphelper/string.hxx>
109 : : #include <editeng/outlobj.hxx>
110 : : #include <editeng/paperinf.hxx>
111 : :
112 : : #include <basegfx/polygon/b2dpolygon.hxx>
113 : : #include <basegfx/polygon/b2dpolypolygon.hxx>
114 : : #include <basegfx/range/b2drange.hxx>
115 : :
116 : : #include <com/sun/star/document/XDocumentPropertiesSupplier.hpp>
117 : : #include <com/sun/star/document/XFilter.hpp>
118 : : #include <com/sun/star/document/XImporter.hpp>
119 : : #include <com/sun/star/document/XExporter.hpp>
120 : :
121 : :
122 : : using namespace ::com::sun::star;
123 : :
124 : :
125 : : // einige Hilfs-Funktionen
126 : : // char
127 : 0 : inline const SvxFontHeightItem& GetSize(const SfxItemSet& rSet,sal_Bool bInP=sal_True)
128 : 0 : { return (const SvxFontHeightItem&)rSet.Get( RES_CHRATR_FONTSIZE,bInP); }
129 : 0 : inline const SvxLRSpaceItem& GetLRSpace(const SfxItemSet& rSet,sal_Bool bInP=sal_True)
130 : 0 : { return (const SvxLRSpaceItem&)rSet.Get( RES_LR_SPACE,bInP); }
131 : :
132 : :
133 : : /// Glue class to call RtfImport as an internal filter, needed by copy&paste support.
134 [ # # ]: 0 : class SwRTFReader : public Reader
135 : : {
136 : : virtual sal_uLong Read( SwDoc &, const String& rBaseURL, SwPaM &,const String &);
137 : : };
138 : :
139 : 0 : sal_uLong SwRTFReader::Read( SwDoc &rDoc, const String& /*rBaseURL*/, SwPaM& /*rPam*/, const String &)
140 : : {
141 [ # # ]: 0 : if (!pStrm)
142 : 0 : return ERR_SWG_READ_ERROR;
143 : :
144 : 0 : SwDocShell *pDocShell(rDoc.GetDocShell());
145 [ # # ]: 0 : uno::Reference<lang::XMultiServiceFactory> xMultiServiceFactory(comphelper::getProcessServiceFactory());
146 [ # # ]: 0 : uno::Reference<uno::XInterface> xInterface(xMultiServiceFactory->createInstance(
147 [ # # ][ # # ]: 0 : rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.comp.Writer.RtfFilter"))), uno::UNO_QUERY_THROW);
[ # # ]
148 : :
149 [ # # ]: 0 : uno::Reference<document::XImporter> xImporter(xInterface, uno::UNO_QUERY_THROW);
150 [ # # ][ # # ]: 0 : uno::Reference<lang::XComponent> xDstDoc(pDocShell->GetModel(), uno::UNO_QUERY_THROW);
151 [ # # ][ # # ]: 0 : xImporter->setTargetDocument(xDstDoc);
152 : :
153 [ # # ]: 0 : uno::Reference<document::XFilter> xFilter(xInterface, uno::UNO_QUERY_THROW);
154 [ # # ]: 0 : uno::Sequence<beans::PropertyValue> aDescriptor(1);
155 [ # # ][ # # ]: 0 : aDescriptor[0].Name = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("InputStream"));
156 [ # # ][ # # ]: 0 : uno::Reference<io::XStream> xStream(new utl::OStreamWrapper(*pStrm));
[ # # ]
157 [ # # ][ # # ]: 0 : aDescriptor[0].Value <<= xStream;
158 [ # # ][ # # ]: 0 : xFilter->filter(aDescriptor);
159 : :
160 [ # # ]: 0 : return 0;
161 : : }
162 : :
163 : 0 : extern "C" SAL_DLLPUBLIC_EXPORT Reader* SAL_CALL ImportRTF()
164 : : {
165 : : // Use the old rtf importer by default for paste, till the new one supports
166 : : // undo stack and PaM.
167 [ # # ]: 0 : SvtMiscOptions aMiscOptions;
168 [ # # ][ # # ]: 0 : if (!aMiscOptions.IsExperimentalMode())
169 [ # # ][ # # ]: 0 : return new RtfReader();
170 [ # # ][ # # ]: 0 : return new SwRTFReader();
[ # # ]
171 : : }
172 : :
173 : : // Aufruf fuer die allg. Reader-Schnittstelle
174 : 0 : sal_uLong RtfReader::Read( SwDoc &rDoc, const String& rBaseURL, SwPaM &rPam, const String &)
175 : : {
176 [ # # ]: 0 : if( !pStrm )
177 : : {
178 : : OSL_FAIL( "RTF-Read ohne Stream" );
179 : 0 : return ERR_SWG_READ_ERROR;
180 : : }
181 : :
182 [ # # ]: 0 : if( !bInsertMode )
183 : : {
184 : : // MIB 27.09.96: Umrandung uns Abstaende aus Frm-Vorlagen entf.
185 [ # # ]: 0 : Reader::ResetFrmFmts( rDoc );
186 : : }
187 : :
188 : 0 : sal_uLong nRet = 0;
189 : 0 : SwDocShell *pDocShell(rDoc.GetDocShell());
190 : : OSL_ENSURE(pDocShell, "no SwDocShell");
191 : 0 : uno::Reference<document::XDocumentProperties> xDocProps;
192 [ # # ]: 0 : if (pDocShell) {
193 : : uno::Reference<document::XDocumentPropertiesSupplier> xDPS(
194 [ # # ][ # # ]: 0 : pDocShell->GetModel(), uno::UNO_QUERY_THROW);
195 [ # # ][ # # ]: 0 : xDocProps.set(xDPS->getDocumentProperties());
[ # # ]
196 : : }
197 : :
198 : : SvParserRef xParser = new SwRTFParser( &rDoc, xDocProps,
199 [ # # ][ # # ]: 0 : rPam, *pStrm, rBaseURL, !bInsertMode );
200 [ # # ]: 0 : SvParserState eState = xParser->CallParser();
201 [ # # ][ # # ]: 0 : if( SVPAR_PENDING != eState && SVPAR_ACCEPTED != eState )
202 : : {
203 [ # # ]: 0 : String sErr( String::CreateFromInt32( xParser->GetLineNr() ));
204 [ # # ]: 0 : sErr += ',';
205 [ # # ][ # # ]: 0 : sErr += String::CreateFromInt32( xParser->GetLinePos() );
[ # # ]
206 : :
207 : : nRet = *new StringErrorInfo( ERR_FORMAT_ROWCOL, sErr,
208 [ # # ][ # # ]: 0 : ERRCODE_BUTTON_OK | ERRCODE_MSG_ERROR );
[ # # ][ # # ]
209 : : }
210 : :
211 : :
212 [ # # ]: 0 : return nRet;
213 : : }
214 : :
215 : 0 : sal_uLong RtfReader::Read(SvStream* pStream, SwDoc& rDoc, const String& rBaseURL, SwPaM& rPam)
216 : : {
217 : 0 : pStrm = pStream;
218 : 0 : return Read(rDoc, rBaseURL, rPam, rBaseURL);
219 : : }
220 : :
221 : 0 : SwRTFParser::SwRTFParser(SwDoc* pD,
222 : : uno::Reference<document::XDocumentProperties> i_xDocProps,
223 : : const SwPaM& rCrsr, SvStream& rIn, const String& rBaseURL,
224 : : int bReadNewDoc) :
225 : 0 : SvxRTFParser(pD->GetAttrPool(), rIn, i_xDocProps, bReadNewDoc),
226 : : maParaStyleMapper(*pD),
227 : : maCharStyleMapper(*pD),
228 : : maSegments(*this),
229 : : maInsertedTables(*pD),
230 : : mpBookmarkStart(0),
231 : : mpRedlineStack(0),
232 : : pGrfAttrSet(0),
233 : : pTableNode(0),
234 : : pOldTblNd(0),
235 : : pSttNdIdx(0),
236 : : pRegionEndIdx(0),
237 : : pDoc(pD),
238 [ # # ]: 0 : pRelNumRule(new SwRelNumRuleSpaces(*pD, static_cast< sal_Bool >(bReadNewDoc))),
239 : : pRedlineInsert(0),
240 : : pRedlineDelete(0),
241 : : sBaseURL( rBaseURL ),
242 : : nAktPageDesc(0),
243 : : nAktFirstPageDesc(0),
244 : : m_nCurrentBox(0),
245 : : nInsTblRow(USHRT_MAX),
246 : : nNewNumSectDef(USHRT_MAX),
247 : : nRowsToRepeat(0),
248 : : mbReadCellWhileReadSwFly( false ), // #i83368#
249 : :
250 : : bTrowdRead(0),
251 : : nReadFlyDepth(0),
252 [ # # ][ # # ]: 0 : nZOrder(0)
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
253 : : {
254 : : mbIsFootnote = mbReadNoTbl = bReadSwFly = bSwPageDesc = bStyleTabValid =
255 : 0 : bInPgDscTbl = bNewNumList = false;
256 : 0 : bFirstContinue = true;
257 : 0 : bContainsPara = false;
258 : 0 : bContainsTablePara = false;
259 : 0 : bNestedField = false;
260 : 0 : bForceNewTable = false;
261 : :
262 [ # # ][ # # ]: 0 : pPam = new SwPaM( *rCrsr.GetPoint() );
263 [ # # ]: 0 : SetInsPos( SwxPosition( pPam ) );
264 : 0 : SetChkStyleAttr( 0 != bReadNewDoc );
265 : 0 : SetCalcValue( sal_False );
266 : 0 : SetReadDocInfo( sal_True );
267 : :
268 : : // diese sollen zusaetzlich ueber \pard zurueck gesetzt werden
269 : : sal_uInt16 temp;
270 [ # # ]: 0 : temp = RES_TXTATR_CHARFMT; AddPlainAttr( temp );
271 [ # # ]: 0 : temp = RES_PAGEDESC; AddPardAttr( temp );
272 [ # # ]: 0 : temp = RES_BREAK; AddPardAttr( temp );
273 [ # # ]: 0 : temp = RES_PARATR_NUMRULE; AddPardAttr( temp );
274 [ # # ]: 0 : temp = FN_PARAM_NUM_LEVEL; AddPardAttr( temp );
275 : 0 : }
276 : :
277 : : // Aufruf des Parsers
278 : 0 : SvParserState SwRTFParser::CallParser()
279 : : {
280 : 0 : mbReadNoTbl = false;
281 : 0 : bFirstContinue = true;
282 : :
283 : 0 : rInput.Seek(STREAM_SEEK_TO_BEGIN);
284 : 0 : rInput.ResetError();
285 : :
286 [ # # ]: 0 : mpRedlineStack = new sw::util::RedlineStack(*pDoc);
287 : :
288 : 0 : return SvxRTFParser::CallParser();
289 : : }
290 : :
291 : 0 : bool lcl_UsedPara(SwPaM &rPam)
292 : : {
293 : : const SwCntntNode* pCNd;
294 : : const SfxItemSet* pSet;
295 [ # # ][ # # ]: 0 : if( rPam.GetPoint()->nContent.GetIndex() ||
[ # # # #
# # ][ # # ]
296 : : ( 0 != ( pCNd = rPam.GetCntntNode()) &&
297 : : 0 != ( pSet = pCNd->GetpSwAttrSet()) &&
298 : 0 : ( SFX_ITEM_SET == pSet->GetItemState( RES_BREAK, sal_False ) ||
299 : 0 : SFX_ITEM_SET == pSet->GetItemState( RES_PAGEDESC, sal_False ))))
300 : 0 : return true;
301 : 0 : return false;
302 : : }
303 : :
304 : 0 : void SwRTFParser::Continue( int nToken )
305 : : {
306 [ # # ]: 0 : if( bFirstContinue )
307 : : {
308 : 0 : bFirstContinue = sal_False;
309 : :
310 [ # # ]: 0 : if (IsNewDoc())
311 : : {
312 : : //
313 : : // COMPATIBILITY FLAGS START
314 : : //
315 : 0 : pDoc->set(IDocumentSettingAccess::PARA_SPACE_MAX, true);
316 : 0 : pDoc->set(IDocumentSettingAccess::PARA_SPACE_MAX_AT_PAGES, true);
317 : 0 : pDoc->set(IDocumentSettingAccess::TAB_COMPAT, true);
318 : 0 : pDoc->set(IDocumentSettingAccess::USE_VIRTUAL_DEVICE, true);
319 : 0 : pDoc->set(IDocumentSettingAccess::USE_HIRES_VIRTUAL_DEVICE, true);
320 : 0 : pDoc->set(IDocumentSettingAccess::ADD_FLY_OFFSETS, true);
321 : 0 : pDoc->set(IDocumentSettingAccess::ADD_EXT_LEADING, true);
322 : 0 : pDoc->set(IDocumentSettingAccess::OLD_NUMBERING, false);
323 : 0 : pDoc->set(IDocumentSettingAccess::IGNORE_FIRST_LINE_INDENT_IN_NUMBERING, false );
324 : 0 : pDoc->set(IDocumentSettingAccess::DO_NOT_JUSTIFY_LINES_WITH_MANUAL_BREAK, false);
325 : 0 : pDoc->set(IDocumentSettingAccess::OLD_LINE_SPACING, false);
326 : 0 : pDoc->set(IDocumentSettingAccess::ADD_PARA_SPACING_TO_TABLE_CELLS, true);
327 : 0 : pDoc->set(IDocumentSettingAccess::USE_FORMER_OBJECT_POS, false);
328 : 0 : pDoc->set(IDocumentSettingAccess::USE_FORMER_TEXT_WRAPPING, false);
329 : 0 : pDoc->set(IDocumentSettingAccess::CONSIDER_WRAP_ON_OBJECT_POSITION, true);
330 : 0 : pDoc->set(IDocumentSettingAccess::DO_NOT_RESET_PARA_ATTRS_FOR_NUM_FONT, false); // #i53199#
331 : :
332 : 0 : pDoc->set(IDocumentSettingAccess::TABLE_ROW_KEEP, true);
333 : 0 : pDoc->set(IDocumentSettingAccess::IGNORE_TABS_AND_BLANKS_FOR_LINE_CALCULATION, true);
334 : 0 : pDoc->set(IDocumentSettingAccess::INVERT_BORDER_SPACING, true);
335 : : //
336 : : // COMPATIBILITY FLAGS END
337 : : //
338 : : }
339 : :
340 : : // einen temporaeren Index anlegen, auf Pos 0 so wird er nicht bewegt!
341 [ # # ]: 0 : pSttNdIdx = new SwNodeIndex( pDoc->GetNodes() );
342 [ # # ]: 0 : if( !IsNewDoc() ) // in ein Dokument einfuegen ?
343 : : {
344 : 0 : const SwPosition* pPos = pPam->GetPoint();
345 : 0 : SwTxtNode* pSttNd = pPos->nNode.GetNode().GetTxtNode();
346 : :
347 [ # # ]: 0 : pDoc->SplitNode( *pPos, false );
348 : :
349 [ # # ]: 0 : *pSttNdIdx = pPos->nNode.GetIndex()-1;
350 [ # # ]: 0 : pDoc->SplitNode( *pPos, false );
351 : :
352 [ # # ]: 0 : SwPaM aInsertionRangePam( *pPos );
353 : :
354 [ # # ]: 0 : pPam->Move( fnMoveBackward );
355 : :
356 : : // split any redline over the insertion point
357 [ # # ]: 0 : aInsertionRangePam.SetMark();
358 [ # # ]: 0 : *aInsertionRangePam.GetPoint() = *pPam->GetPoint();
359 [ # # ]: 0 : aInsertionRangePam.Move( fnMoveBackward );
360 [ # # ]: 0 : pDoc->SplitRedline( aInsertionRangePam );
361 : :
362 : : pDoc->SetTxtFmtColl( *pPam, pDoc->GetTxtCollFromPool
363 [ # # ][ # # ]: 0 : ( RES_POOLCOLL_STANDARD, false ));
364 : :
365 : : // verhinder das einlesen von Tabellen in Fussnoten / Tabellen
366 : 0 : sal_uLong nNd = pPos->nNode.GetIndex();
367 [ # # ]: 0 : mbReadNoTbl = 0 != pSttNd->FindTableNode() ||
368 [ # # ]: 0 : ( nNd < pDoc->GetNodes().GetEndOfInserts().GetIndex() &&
369 [ # # # # ]: 0 : pDoc->GetNodes().GetEndOfInserts().StartOfSectionIndex() < nNd );
[ # # ][ # # ]
[ # # ]
370 : : }
371 : :
372 : : // Laufbalken anzeigen, aber nur bei synchronem Call
373 : 0 : sal_uLong nCurrPos = rInput.Tell();
374 : 0 : rInput.Seek(STREAM_SEEK_TO_END);
375 : 0 : rInput.ResetError();
376 : 0 : ::StartProgress( STR_STATSTR_W4WREAD, 0, rInput.Tell(), pDoc->GetDocShell());
377 : 0 : rInput.Seek( nCurrPos );
378 : 0 : rInput.ResetError();
379 : : }
380 : :
381 : 0 : SvxRTFParser::Continue( nToken );
382 : :
383 [ # # ]: 0 : if( SVPAR_PENDING == GetStatus() )
384 : 0 : return ; // weiter gehts beim naechsten mal
385 : :
386 : 0 : pRelNumRule->SetNumRelSpaces( *pDoc );
387 : :
388 : : // den Start wieder korrigieren
389 [ # # ][ # # ]: 0 : if( !IsNewDoc() && pSttNdIdx->GetIndex() )
[ # # ]
390 : : {
391 : : //die Flys muessen zuerst zurecht gerueckt werden, denn sonst wird
392 : : // ein am 1. Absatz verankerter Fly falsch eingefuegt
393 [ # # ]: 0 : if( SVPAR_ACCEPTED == eState )
394 : : {
395 [ # # ]: 0 : if( !aFlyArr.empty() )
396 [ # # ]: 0 : SetFlysInDoc();
397 [ # # ]: 0 : pRelNumRule->SetOultineRelSpaces( *pSttNdIdx, pPam->GetPoint()->nNode );
398 : : }
399 : :
400 : 0 : SwTxtNode* pTxtNode = pSttNdIdx->GetNode().GetTxtNode();
401 [ # # ]: 0 : SwNodeIndex aNxtIdx( *pSttNdIdx );
402 [ # # ][ # # ]: 0 : if( pTxtNode && pTxtNode->CanJoinNext( &aNxtIdx ))
[ # # ][ # # ]
403 : : {
404 : 0 : xub_StrLen nStt = pTxtNode->GetTxt().Len();
405 : : // wenn der Cursor noch in dem Node steht, dann setze in an das Ende
406 [ # # ]: 0 : if( pPam->GetPoint()->nNode == aNxtIdx )
407 : : {
408 [ # # ]: 0 : pPam->GetPoint()->nNode = *pSttNdIdx;
409 [ # # ][ # # ]: 0 : pPam->GetPoint()->nContent.Assign( pTxtNode, nStt );
410 : : }
411 : :
412 : : #if OSL_DEBUG_LEVEL > 0
413 : : // !!! sollte nicht moeglich sein, oder ??
414 : : OSL_ENSURE( pSttNdIdx->GetIndex()+1 != pPam->GetBound( sal_True ).nNode.GetIndex(),
415 : : "Pam.Bound1 steht noch im Node" );
416 : : OSL_ENSURE( pSttNdIdx->GetIndex()+1 != pPam->GetBound( sal_False ).nNode.GetIndex(),
417 : : "Pam.Bound2 steht noch im Node" );
418 : :
419 : : if( pSttNdIdx->GetIndex()+1 == pPam->GetBound( sal_True ).nNode.GetIndex() )
420 : : {
421 : : xub_StrLen nCntPos = pPam->GetBound( sal_True ).nContent.GetIndex();
422 : : pPam->GetBound( sal_True ).nContent.Assign( pTxtNode,
423 : : pTxtNode->GetTxt().Len() + nCntPos );
424 : : }
425 : : if( pSttNdIdx->GetIndex()+1 == pPam->GetBound( sal_False ).nNode.GetIndex() )
426 : : {
427 : : xub_StrLen nCntPos = pPam->GetBound( sal_False ).nContent.GetIndex();
428 : : pPam->GetBound( sal_False ).nContent.Assign( pTxtNode,
429 : : pTxtNode->GetTxt().Len() + nCntPos );
430 : : }
431 : : #endif
432 : : // Zeichen Attribute beibehalten!
433 : 0 : SwTxtNode* pDelNd = aNxtIdx.GetNode().GetTxtNode();
434 [ # # ]: 0 : if( pTxtNode->GetTxt().Len() )
435 [ # # ]: 0 : pDelNd->FmtToTxtAttr( pTxtNode );
436 : : else
437 [ # # ]: 0 : pTxtNode->ChgFmtColl( pDelNd->GetTxtColl() );
438 [ # # ]: 0 : pTxtNode->JoinNext();
439 [ # # ]: 0 : }
440 : : }
441 : :
442 [ # # ]: 0 : if( SVPAR_ACCEPTED == eState )
443 : : {
444 : : // den letzen Bereich wieder zumachen
445 [ # # ]: 0 : if( pRegionEndIdx )
446 : : {
447 : : // the last section in WW are not a balanced Section.
448 [ # # ]: 0 : if( !GetVersionNo() )
449 : : {
450 : 0 : SwSectionNode* pSectNd = pRegionEndIdx->GetNode().
451 : 0 : StartOfSectionNode()->GetSectionNode();
452 [ # # ]: 0 : if( pSectNd )
453 : 0 : pSectNd->GetSection().GetFmt()->SetFmtAttr(
454 [ # # ][ # # ]: 0 : SwFmtNoBalancedColumns( sal_True ) );
[ # # ]
455 : : }
456 : :
457 [ # # ]: 0 : DelLastNode();
458 [ # # ]: 0 : pPam->GetPoint()->nNode = *pRegionEndIdx;
459 [ # # ]: 0 : pPam->Move( fnMoveForward, fnGoNode );
460 [ # # ][ # # ]: 0 : delete pRegionEndIdx, pRegionEndIdx = 0;
461 : : }
462 : :
463 : 0 : sal_uInt16 nPageDescOffset = pDoc->GetPageDescCnt();
464 [ # # ]: 0 : maSegments.InsertSegments(IsNewDoc());
465 [ # # ]: 0 : UpdatePageDescs(*pDoc, nPageDescOffset);
466 : : // following garbage collecting code has been moved from the previous
467 : : // procedure UpdatePageDescs to here in order to fix a bug
468 : 0 : rtfSections::myrDummyIter aDEnd = maSegments.maDummyPageNos.rend();
469 [ # # ][ # # ]: 0 : for (rtfSections::myrDummyIter aI = maSegments.maDummyPageNos.rbegin(); aI != aDEnd; ++aI)
[ # # ]
470 [ # # ][ # # ]: 0 : pDoc->DelPageDesc(*aI);
471 : :
472 [ # # ]: 0 : if( !aFlyArr.empty() )
473 [ # # ]: 0 : SetFlysInDoc();
474 : :
475 : : // jetzt noch den letzten ueberfluessigen Absatz loeschen
476 : 0 : SwPosition* pPos = pPam->GetPoint();
477 [ # # ]: 0 : if( !pPos->nContent.GetIndex() )
478 : : {
479 : : SwTxtNode* pAktNd;
480 : 0 : sal_uLong nNodeIdx = pPos->nNode.GetIndex();
481 [ # # ]: 0 : if( IsNewDoc() )
482 : : {
483 [ # # ][ # # ]: 0 : SwNode* pTmp = pDoc->GetNodes()[ nNodeIdx -1 ];
484 [ # # ][ # # ]: 0 : if( pTmp->IsCntntNode() && !pTmp->FindTableNode() )
[ # # ][ # # ]
485 : : {
486 : : // Do not delete the paragraph if it has anchored objects:
487 : 0 : bool bAnchoredObjs = false;
488 : 0 : const SwFrmFmts* pFrmFmts = pDoc->GetSpzFrmFmts();
489 [ # # ][ # # ]: 0 : if ( pFrmFmts && !pFrmFmts->empty() )
[ # # ]
490 : : {
491 [ # # ]: 0 : for ( sal_uInt16 nI = pFrmFmts->size(); nI; --nI )
492 : : {
493 [ # # ]: 0 : const SwFmtAnchor & rAnchor = (*pFrmFmts)[ nI - 1 ]->GetAnchor();
494 [ # # # # ]: 0 : if ((FLY_AT_PARA == rAnchor.GetAnchorId()) ||
[ # # ]
495 : 0 : (FLY_AT_CHAR == rAnchor.GetAnchorId()))
496 : : {
497 [ # # ]: 0 : const SwPosition * pObjPos = rAnchor.GetCntntAnchor();
498 [ # # ][ # # ]: 0 : if ( pObjPos && nNodeIdx == pObjPos->nNode.GetIndex() )
[ # # ]
499 : : {
500 : 0 : bAnchoredObjs = true;
501 : 0 : break;
502 : : }
503 : : }
504 : : }
505 : : }
506 : :
507 [ # # ]: 0 : if ( !bAnchoredObjs )
508 [ # # ]: 0 : DelLastNode();
509 : : }
510 : : }
511 [ # # ][ # # ]: 0 : else if (0 != (pAktNd = pDoc->GetNodes()[nNodeIdx]->GetTxtNode()))
[ # # ]
512 : : {
513 [ # # ][ # # ]: 0 : if( pAktNd->CanJoinNext( &pPos->nNode ))
514 : : {
515 : 0 : SwTxtNode* pNextNd = pPos->nNode.GetNode().GetTxtNode();
516 [ # # ][ # # ]: 0 : pPos->nContent.Assign( pNextNd, 0 );
517 [ # # ][ # # ]: 0 : pPam->SetMark(); pPam->DeleteMark();
518 [ # # ]: 0 : pNextNd->JoinPrev();
519 : : }
520 [ # # # # ]: 0 : else if( !pAktNd->GetTxt().Len() &&
[ # # ]
521 : 0 : pAktNd->StartOfSectionIndex()+2 <
522 : 0 : pAktNd->EndOfSectionIndex() )
523 : : {
524 [ # # ]: 0 : pPos->nContent.Assign( 0, 0 );
525 [ # # ][ # # ]: 0 : pPam->SetMark(); pPam->DeleteMark();
526 [ # # ][ # # ]: 0 : pDoc->GetNodes().Delete( pPos->nNode, 1 );
527 [ # # ]: 0 : pPam->Move( fnMoveBackward );
528 : : }
529 : : }
530 : : }
531 : : // nun noch das SplitNode vom Ende aufheben
532 [ # # ]: 0 : else if( !IsNewDoc() )
533 : : {
534 [ # # ]: 0 : if( pPos->nContent.GetIndex() ) // dann gabs am Ende kein \par,
535 [ # # ]: 0 : pPam->Move( fnMoveForward, fnGoNode ); // als zum naechsten Node
536 : 0 : SwTxtNode* pTxtNode = pPos->nNode.GetNode().GetTxtNode();
537 [ # # ]: 0 : SwNodeIndex aPrvIdx( pPos->nNode );
538 [ # # ][ # # ]: 0 : if( pTxtNode && pTxtNode->CanJoinPrev( &aPrvIdx ) &&
[ # # # # ]
[ # # ]
539 : 0 : *pSttNdIdx <= aPrvIdx )
540 : : {
541 : : // eigentlich muss hier ein JoinNext erfolgen, aber alle Cursor
542 : : // usw. sind im pTxtNode angemeldet, so dass der bestehen
543 : : // bleiben MUSS.
544 : :
545 : : // Absatz in Zeichen-Attribute umwandeln, aus dem Prev die
546 : : // Absatzattribute und die Vorlage uebernehmen!
547 : 0 : SwTxtNode* pPrev = aPrvIdx.GetNode().GetTxtNode();
548 [ # # ]: 0 : pTxtNode->ChgFmtColl( pPrev->GetTxtColl() );
549 [ # # ]: 0 : pTxtNode->FmtToTxtAttr( pPrev );
550 [ # # ]: 0 : pTxtNode->ResetAllAttr();
551 : :
552 [ # # ][ # # ]: 0 : if( pPrev->HasSwAttrSet() )
553 [ # # ][ # # ]: 0 : pTxtNode->SetAttr( *pPrev->GetpSwAttrSet() );
554 : :
555 [ # # ][ # # ]: 0 : if( &pPam->GetBound(sal_True).nNode.GetNode() == pPrev )
556 [ # # ][ # # ]: 0 : pPam->GetBound(sal_True).nContent.Assign( pTxtNode, 0 );
557 [ # # ][ # # ]: 0 : if( &pPam->GetBound(sal_False).nNode.GetNode() == pPrev )
558 [ # # ][ # # ]: 0 : pPam->GetBound(sal_False).nContent.Assign( pTxtNode, 0 );
559 : :
560 [ # # ]: 0 : pTxtNode->JoinPrev();
561 [ # # ]: 0 : }
562 : : }
563 : : }
564 [ # # ]: 0 : delete pSttNdIdx, pSttNdIdx = 0;
565 [ # # ]: 0 : delete pRegionEndIdx, pRegionEndIdx = 0;
566 : 0 : RemoveUnusedNumRules();
567 : :
568 : 0 : pDoc->SetUpdateExpFldStat(true);
569 : 0 : pDoc->SetInitDBFields(true);
570 : :
571 : : // Laufbalken bei asynchronen Call nicht einschalten !!!
572 : 0 : ::EndProgress( pDoc->GetDocShell() );
573 : : }
574 : :
575 : 0 : bool rtfSections::SetCols(SwFrmFmt &rFmt, const rtfSection &rSection,
576 : : sal_uInt16 nNettoWidth)
577 : : {
578 : : //sprmSCcolumns - Anzahl der Spalten - 1
579 : 0 : sal_uInt16 nCols = static_cast< sal_uInt16 >(rSection.NoCols());
580 : :
581 [ # # ]: 0 : if (nCols < 2)
582 : 0 : return false; // keine oder bloedsinnige Spalten
583 : :
584 [ # # ]: 0 : SwFmtCol aCol; // Erzeuge SwFmtCol
585 : :
586 : : //sprmSDxaColumns - Default-Abstand 1.25 cm
587 : 0 : sal_uInt16 nColSpace = static_cast< sal_uInt16 >(rSection.StandardColSeperation());
588 : :
589 [ # # ]: 0 : aCol.Init( nCols, nColSpace, nNettoWidth );
590 : :
591 : : // not SFEvenlySpaced
592 [ # # ]: 0 : if (rSection.maPageInfo.maColumns.size())
593 : : {
594 : 0 : aCol._SetOrtho(false);
595 : 0 : sal_uInt16 nWishWidth = 0, nHalfPrev = 0;
596 [ # # ][ # # ]: 0 : for (sal_uInt16 n=0, i=0;
[ # # ]
597 : 0 : (static_cast<size_t>(n)+1) < rSection.maPageInfo.maColumns.size() && i < nCols;
598 : : n += 2, ++i)
599 : : {
600 [ # # ]: 0 : SwColumn* pCol = &aCol.GetColumns()[ i ];
601 : 0 : pCol->SetLeft( nHalfPrev );
602 [ # # ]: 0 : sal_uInt16 nSp = static_cast< sal_uInt16 >(rSection.maPageInfo.maColumns[ n+1 ]);
603 : 0 : nHalfPrev = nSp / 2;
604 : 0 : pCol->SetRight( nSp - nHalfPrev );
605 [ # # ]: 0 : pCol->SetWishWidth( static_cast< sal_uInt16 >(rSection.maPageInfo.maColumns[ n ]) +
606 : 0 : pCol->GetLeft() + pCol->GetRight());
607 : 0 : nWishWidth = nWishWidth + pCol->GetWishWidth();
608 : : }
609 : 0 : aCol.SetWishWidth( nWishWidth );
610 : : }
611 : :
612 [ # # ]: 0 : rFmt.SetFmtAttr(aCol);
613 [ # # ]: 0 : return true;
614 : : }
615 : :
616 : 0 : void rtfSections::SetPage(SwPageDesc &rInPageDesc, SwFrmFmt &rFmt,
617 : : const rtfSection &rSection, bool bIgnoreCols)
618 : : {
619 : : // 1. Orientierung
620 : 0 : rInPageDesc.SetLandscape(rSection.IsLandScape());
621 : :
622 : : // 2. Papiergroesse
623 [ # # ][ # # ]: 0 : SwFmtFrmSize aSz(rFmt.GetFrmSize());
624 : 0 : aSz.SetWidth(rSection.GetPageWidth());
625 : 0 : aSz.SetHeight(rSection.GetPageHeight());
626 [ # # ]: 0 : rFmt.SetFmtAttr(aSz);
627 : :
628 : : rFmt.SetFmtAttr(
629 [ # # ][ # # ]: 0 : SvxLRSpaceItem(rSection.GetPageLeft(), rSection.GetPageRight(), 0, 0, RES_LR_SPACE));
[ # # ]
630 : :
631 [ # # ]: 0 : if (!bIgnoreCols)
632 : : {
633 : 0 : SetCols(rFmt, rSection, static_cast< sal_uInt16 >(rSection.GetPageWidth() -
634 [ # # ]: 0 : rSection.GetPageLeft() - rSection.GetPageRight()));
635 : : }
636 : :
637 [ # # ][ # # ]: 0 : rFmt.SetFmtAttr(rSection.maPageInfo.maBox);
638 : 0 : }
639 : :
640 : 0 : bool HasHeader(const SwFrmFmt &rFmt)
641 : : {
642 : : const SfxPoolItem *pHd;
643 [ # # ][ # # ]: 0 : if (SFX_ITEM_SET == rFmt.GetItemState(RES_HEADER, false, &pHd))
644 : 0 : return ((const SwFmtHeader *)(pHd))->IsActive();
645 : 0 : return false;
646 : : }
647 : :
648 : 0 : bool HasFooter(const SwFrmFmt &rFmt)
649 : : {
650 : : const SfxPoolItem *pFt;
651 [ # # ][ # # ]: 0 : if (SFX_ITEM_SET == rFmt.GetItemState(RES_FOOTER, false, &pFt))
652 : 0 : return ((const SwFmtFooter *)(pFt))->IsActive();
653 : 0 : return false;
654 : : }
655 : :
656 : 0 : void rtfSections::GetPageULData(const rtfSection &rSection, bool bFirst,
657 : : rtfSections::wwULSpaceData& rData)
658 : : {
659 : 0 : short nWWUp = static_cast< short >(rSection.maPageInfo.mnMargtsxn);
660 : 0 : short nWWLo = static_cast< short >(rSection.maPageInfo.mnMargbsxn);
661 : 0 : short nWWHTop = static_cast< short >(rSection.maPageInfo.mnHeadery);
662 : 0 : short nWWFBot = static_cast< short >(rSection.maPageInfo.mnFootery);
663 : :
664 [ # # ]: 0 : if (bFirst)
665 : : {
666 [ # # # # ]: 0 : if (
[ # # ]
667 : 0 : rSection.mpTitlePage && HasHeader(rSection.mpTitlePage->GetMaster())
668 : : )
669 : : {
670 : 0 : rData.bHasHeader = true;
671 : : }
672 : : }
673 : : else
674 : : {
675 [ # # # # : 0 : if (rSection.mpPage &&
# # ][ # # ]
676 : : (
677 : 0 : HasHeader(rSection.mpPage->GetMaster())
678 : 0 : || HasHeader(rSection.mpPage->GetLeft())
679 : : )
680 : : )
681 : : {
682 : 0 : rData.bHasHeader = true;
683 : : }
684 : : }
685 : :
686 [ # # ]: 0 : if( rData.bHasHeader )
687 : : {
688 : 0 : rData.nSwUp = nWWHTop; // Header -> umrechnen, see ww8par6.cxx
689 : :
690 [ # # ][ # # ]: 0 : if ( nWWUp > 0 && nWWUp >= nWWHTop )
691 : 0 : rData.nSwHLo = nWWUp - nWWHTop;
692 : : else
693 : 0 : rData.nSwHLo = 0;
694 : :
695 [ # # ]: 0 : if (rData.nSwHLo < cMinHdFtHeight)
696 : 0 : rData.nSwHLo = cMinHdFtHeight;
697 : : }
698 : : else // kein Header -> Up einfach uebernehmen
699 : 0 : rData.nSwUp = Abs(nWWUp);
700 : :
701 [ # # ]: 0 : if (bFirst)
702 : : {
703 [ # # # # ]: 0 : if (
[ # # ]
704 : : rSection.mpTitlePage &&
705 : 0 : HasFooter(rSection.mpTitlePage->GetMaster())
706 : : )
707 : : {
708 : 0 : rData.bHasFooter = true;
709 : : }
710 : : }
711 : : else
712 : : {
713 [ # # # # : 0 : if (rSection.mpPage &&
# # ][ # # ]
714 : : (
715 : 0 : HasFooter(rSection.mpPage->GetMaster())
716 : 0 : || HasFooter(rSection.mpPage->GetLeft())
717 : : )
718 : : )
719 : : {
720 : 0 : rData.bHasFooter = true;
721 : : }
722 : : }
723 : :
724 [ # # ]: 0 : if( rData.bHasFooter )
725 : : {
726 : 0 : rData.nSwLo = nWWFBot; // Footer -> Umrechnen
727 [ # # ][ # # ]: 0 : if ( nWWLo > 0 && nWWLo >= nWWFBot )
728 : 0 : rData.nSwFUp = nWWLo - nWWFBot;
729 : : else
730 : 0 : rData.nSwFUp = 0;
731 : :
732 [ # # ]: 0 : if (rData.nSwFUp < cMinHdFtHeight)
733 : 0 : rData.nSwFUp = cMinHdFtHeight;
734 : : }
735 : : else // kein Footer -> Lo einfach uebernehmen
736 : 0 : rData.nSwLo = Abs(nWWLo);
737 : 0 : }
738 : :
739 : 0 : void rtfSections::SetPageULSpaceItems(SwFrmFmt &rFmt,
740 : : rtfSections::wwULSpaceData& rData)
741 : : {
742 [ # # ]: 0 : if (rData.bHasHeader) // ... und Header-Lower setzen
743 : : {
744 : : //Kopfzeilenhoehe minimal sezten
745 [ # # ][ # # ]: 0 : if (SwFrmFmt* pHdFmt = (SwFrmFmt*)rFmt.GetHeader().GetHeaderFmt())
746 : : {
747 [ # # ][ # # ]: 0 : pHdFmt->SetFmtAttr(SwFmtFrmSize(ATT_MIN_SIZE, 0, rData.nSwHLo));
[ # # ]
748 [ # # ][ # # ]: 0 : SvxULSpaceItem aHdUL(pHdFmt->GetULSpace());
749 : 0 : aHdUL.SetLower( rData.nSwHLo - cMinHdFtHeight );
750 [ # # ]: 0 : pHdFmt->SetFmtAttr(aHdUL);
751 : : pHdFmt->SetFmtAttr(SwHeaderAndFooterEatSpacingItem(
752 [ # # ][ # # ]: 0 : RES_HEADER_FOOTER_EAT_SPACING, true));
[ # # ][ # # ]
753 : : }
754 : : }
755 : :
756 [ # # ]: 0 : if (rData.bHasFooter) // ... und Footer-Upper setzen
757 : : {
758 [ # # ][ # # ]: 0 : if (SwFrmFmt* pFtFmt = (SwFrmFmt*)rFmt.GetFooter().GetFooterFmt())
759 : : {
760 [ # # ][ # # ]: 0 : pFtFmt->SetFmtAttr(SwFmtFrmSize(ATT_MIN_SIZE, 0, rData.nSwFUp));
[ # # ]
761 [ # # ][ # # ]: 0 : SvxULSpaceItem aFtUL(pFtFmt->GetULSpace());
762 : 0 : aFtUL.SetUpper( rData.nSwFUp - cMinHdFtHeight );
763 [ # # ]: 0 : pFtFmt->SetFmtAttr(aFtUL);
764 : : pFtFmt->SetFmtAttr(SwHeaderAndFooterEatSpacingItem(
765 [ # # ][ # # ]: 0 : RES_HEADER_FOOTER_EAT_SPACING, true));
[ # # ][ # # ]
766 : : }
767 : : }
768 : :
769 [ # # ]: 0 : SvxULSpaceItem aUL(rData.nSwUp, rData.nSwLo, RES_UL_SPACE ); // Page-UL setzen
770 [ # # ][ # # ]: 0 : rFmt.SetFmtAttr(aUL);
771 : 0 : }
772 : :
773 : 0 : void rtfSections::SetSegmentToPageDesc(const rtfSection &rSection,
774 : : bool bTitlePage, bool bIgnoreCols)
775 : : {
776 [ # # ]: 0 : SwPageDesc &rPage = bTitlePage ? *rSection.mpTitlePage : *rSection.mpPage;
777 : :
778 : 0 : SwFrmFmt &rFmt = rPage.GetMaster();
779 : :
780 : 0 : wwULSpaceData aULData;
781 [ # # ]: 0 : GetPageULData(rSection, bTitlePage, aULData);
782 [ # # ]: 0 : SetPageULSpaceItems(rFmt, aULData);
783 : :
784 [ # # ]: 0 : SetPage(rPage, rFmt, rSection, bIgnoreCols);
785 : :
786 : 0 : UseOnPage ePage = rPage.ReadUseOn();
787 [ # # ]: 0 : if(ePage & nsUseOnPage::PD_ALL)
788 : : {
789 : 0 : SwFrmFmt &rFmtLeft = rPage.GetLeft();
790 [ # # ]: 0 : SetPageULSpaceItems(rFmtLeft, aULData);
791 [ # # ]: 0 : SetPage(rPage, rFmtLeft, rSection, bIgnoreCols);
792 : : }
793 : :
794 : 0 : }
795 : :
796 : 0 : void rtfSections::CopyFrom(const SwPageDesc &rFrom, SwPageDesc &rDest)
797 : : {
798 : 0 : UseOnPage ePage = rFrom.ReadUseOn();
799 : 0 : rDest.WriteUseOn(ePage);
800 : :
801 : 0 : mrReader.pDoc->CopyHeader(rFrom.GetMaster(), rDest.GetMaster());
802 : 0 : SwFrmFmt &rDestFmt = rDest.GetMaster();
803 : 0 : rDestFmt.SetFmtAttr(rFrom.GetMaster().GetHeader());
804 : 0 : mrReader.pDoc->CopyHeader(rFrom.GetLeft(), rDest.GetLeft());
805 : 0 : mrReader.pDoc->CopyFooter(rFrom.GetMaster(), rDest.GetMaster());
806 : 0 : mrReader.pDoc->CopyFooter(rFrom.GetLeft(), rDest.GetLeft());
807 : 0 : }
808 : :
809 : 0 : void rtfSections::MoveFrom(SwPageDesc &rFrom, SwPageDesc &rDest)
810 : : {
811 : 0 : UseOnPage ePage = rFrom.ReadUseOn();
812 : 0 : rDest.WriteUseOn(ePage);
813 : :
814 : 0 : SwFrmFmt &rDestMaster = rDest.GetMaster();
815 : 0 : SwFrmFmt &rFromMaster = rFrom.GetMaster();
816 : 0 : rDestMaster.SetFmtAttr(rFromMaster.GetHeader());
817 : 0 : rDestMaster.SetFmtAttr(rFromMaster.GetFooter());
818 : :
819 : 0 : SwFrmFmt &rDestLeft = rDest.GetLeft();
820 : 0 : SwFrmFmt &rFromLeft = rFrom.GetLeft();
821 : 0 : rDestLeft.SetFmtAttr(rFromLeft.GetHeader());
822 : 0 : rDestLeft.SetFmtAttr(rFromLeft.GetFooter());
823 : 0 : }
824 : :
825 : 0 : void rtfSections::SetHdFt(rtfSection &rSection)
826 : : {
827 : : OSL_ENSURE(rSection.mpPage, "makes no sense to call without a main page");
828 [ # # ][ # # ]: 0 : if (rSection.mpPage && rSection.maPageInfo.mpPageHdFt)
829 : : {
830 [ # # ]: 0 : if (rSection.maPageInfo.mbPageHdFtUsed)
831 : : {
832 : 0 : MoveFrom(*rSection.maPageInfo.mpPageHdFt, *rSection.mpPage);
833 : 0 : rSection.maPageInfo.mbPageHdFtUsed = false;
834 : 0 : rSection.maPageInfo.mpPageHdFt = rSection.mpPage;
835 : : }
836 : : else
837 : 0 : CopyFrom(*rSection.maPageInfo.mpPageHdFt, *rSection.mpPage);
838 : : }
839 : :
840 [ # # ][ # # ]: 0 : if (rSection.mpTitlePage && rSection.maPageInfo.mpTitlePageHdFt)
841 : : {
842 [ # # ]: 0 : if (rSection.maPageInfo.mbTitlePageHdFtUsed)
843 : : {
844 : : MoveFrom(*rSection.maPageInfo.mpTitlePageHdFt,
845 : 0 : *rSection.mpTitlePage);
846 : 0 : rSection.maPageInfo.mbTitlePageHdFtUsed = false;
847 : 0 : rSection.maPageInfo.mpTitlePageHdFt = rSection.mpTitlePage;
848 : : }
849 : : else
850 : : {
851 : : CopyFrom(*rSection.maPageInfo.mpTitlePageHdFt,
852 : 0 : *rSection.mpTitlePage);
853 : : }
854 : : }
855 : 0 : }
856 : :
857 : 0 : SwSectionFmt *rtfSections::InsertSection(SwPaM& rMyPaM, rtfSection &rSection)
858 : : {
859 : : SwSectionData aSectionData(CONTENT_SECTION,
860 [ # # ][ # # ]: 0 : mrReader.pDoc->GetUniqueSectionName());
[ # # ]
861 : :
862 [ # # ]: 0 : SfxItemSet aSet( mrReader.pDoc->GetAttrPool(), aFrmFmtSetRange );
863 : :
864 [ # # ][ # # ]: 0 : sal_uInt8 nRTLPgn = maSegments.empty() ? 0 : maSegments.back().IsBiDi();
865 : : aSet.Put(SvxFrameDirectionItem(
866 [ # # ][ # # ]: 0 : nRTLPgn ? FRMDIR_HORI_RIGHT_TOP : FRMDIR_HORI_LEFT_TOP, RES_FRAMEDIR));
[ # # ][ # # ]
867 : :
868 : : rSection.mpSection =
869 [ # # ]: 0 : mrReader.pDoc->InsertSwSection( rMyPaM, aSectionData, 0, &aSet );
870 : : OSL_ENSURE(rSection.mpSection, "section not inserted!");
871 [ # # ]: 0 : if (!rSection.mpSection)
872 : 0 : return 0;
873 : :
874 : 0 : SwPageDesc *pPage = 0;
875 : 0 : mySegrIter aEnd = maSegments.rend();
876 [ # # ][ # # ]: 0 : for (mySegrIter aIter = maSegments.rbegin(); aIter != aEnd; ++aIter)
[ # # ]
877 : : {
878 [ # # ]: 0 : pPage = aIter->mpPage;
879 [ # # ]: 0 : if (pPage)
880 : 0 : break;
881 : : }
882 : :
883 : : OSL_ENSURE(pPage, "no page outside this section!");
884 : :
885 [ # # ]: 0 : if (!pPage)
886 [ # # ]: 0 : pPage = &mrReader.pDoc->GetPageDesc(0);
887 : :
888 [ # # ]: 0 : if (!pPage)
889 : 0 : return 0;
890 : :
891 : 0 : SwFrmFmt& rFmt = pPage->GetMaster();
892 [ # # ]: 0 : const SwFmtFrmSize& rSz = rFmt.GetFrmSize();
893 [ # # ]: 0 : const SvxLRSpaceItem& rLR = rFmt.GetLRSpace();
894 : 0 : SwTwips nWidth = rSz.GetWidth();
895 : 0 : long nLeft = rLR.GetTxtLeft();
896 : 0 : long nRight = rLR.GetRight();
897 : :
898 : 0 : SwSectionFmt *pFmt = rSection.mpSection->GetFmt();
899 : : OSL_ENSURE(pFmt, "impossible");
900 [ # # ]: 0 : if (!pFmt)
901 : 0 : return 0;
902 [ # # ]: 0 : SetCols(*pFmt, rSection, (sal_uInt16)(nWidth - nLeft - nRight) );
903 : :
904 [ # # ][ # # ]: 0 : return pFmt;
905 : : }
906 : :
907 : 0 : void rtfSections::InsertSegments(bool bNewDoc)
908 : : {
909 : 0 : sal_uInt16 nDesc(0);
910 : 0 : mySegIter aEnd = maSegments.end();
911 : 0 : mySegIter aStart = maSegments.begin();
912 [ # # ][ # # ]: 0 : for (mySegIter aIter = aStart; aIter != aEnd; ++aIter)
[ # # ]
913 : : {
914 [ # # ]: 0 : mySegIter aNext = aIter+1;
915 : :
916 [ # # ][ # # ]: 0 : bool bInsertSection = aIter != aStart ? aIter->IsContinous() : false;
917 : :
918 [ # # ]: 0 : if (!bInsertSection)
919 : : {
920 : : /*
921 : : If a cont section follow this section then we won't be
922 : : creating a page desc with 2+ cols as we cannot host a one
923 : : col section in a 2+ col pagedesc and make it look like
924 : : word. But if the current section actually has columns then
925 : : we are forced to insert a section here as well as a page
926 : : descriptor.
927 : : */
928 : :
929 : : /*
930 : : Note for the future:
931 : : If we want to import "protected sections" the here is
932 : : where we would also test for that and force a section
933 : : insertion if that was true.
934 : : */
935 : 0 : bool bIgnoreCols = false;
936 [ # # ][ # # ]: 0 : if (aNext != aEnd && aNext->IsContinous())
[ # # ][ # # ]
937 : : {
938 : 0 : bIgnoreCols = true;
939 [ # # ]: 0 : if (aIter->NoCols() > 1)
940 : 0 : bInsertSection = true;
941 : : }
942 : :
943 [ # # ]: 0 : if (aIter->HasTitlePage())
944 : : {
945 [ # # ][ # # ]: 0 : if (bNewDoc && aIter == aStart)
[ # # ]
946 : : {
947 : 0 : aIter->mpTitlePage =
948 [ # # ]: 0 : mrReader.pDoc->GetPageDescFromPool(RES_POOLPAGE_FIRST);
949 : : }
950 : : else
951 : : {
952 : : sal_uInt16 nPos = mrReader.pDoc->MakePageDesc(
953 : : ViewShell::GetShellRes()->GetPageDescName(nDesc, ShellResource::NORMAL_PAGE)
954 [ # # ][ # # ]: 0 : , 0, false);
[ # # ][ # # ]
955 [ # # ]: 0 : aIter->mpTitlePage = &mrReader.pDoc->GetPageDesc(nPos);
956 : : }
957 : : OSL_ENSURE(aIter->mpTitlePage, "no page!");
958 [ # # ]: 0 : if (!aIter->mpTitlePage)
959 : 0 : continue;
960 : :
961 [ # # ]: 0 : SetSegmentToPageDesc(*aIter, true, bIgnoreCols);
962 : : }
963 : :
964 [ # # ][ # # ]: 0 : if (!bNewDoc && aIter == aStart)
[ # # ]
965 : 0 : continue;
966 [ # # ][ # # ]: 0 : else if (bNewDoc && aIter == aStart)
[ # # ]
967 : : {
968 : 0 : aIter->mpPage =
969 [ # # ]: 0 : mrReader.pDoc->GetPageDescFromPool(RES_POOLPAGE_STANDARD);
970 : : }
971 : : else
972 : : {
973 : : sal_uInt16 nPos = mrReader.pDoc->MakePageDesc(
974 : : ViewShell::GetShellRes()->GetPageDescName(nDesc,
975 : 0 : aIter->HasTitlePage() ? ShellResource::FIRST_PAGE : ShellResource::NORMAL_PAGE),
976 [ # # ][ # # ]: 0 : aIter->mpTitlePage, false);
[ # # ][ # # ]
[ # # ]
977 [ # # ]: 0 : aIter->mpPage = &mrReader.pDoc->GetPageDesc(nPos);
978 : : }
979 : : OSL_ENSURE(aIter->mpPage, "no page!");
980 [ # # ]: 0 : if (!aIter->mpPage)
981 : 0 : continue;
982 : :
983 [ # # ]: 0 : SetHdFt(*aIter);
984 : :
985 [ # # ]: 0 : if (aIter->mpTitlePage)
986 [ # # ]: 0 : SetSegmentToPageDesc(*aIter, true, bIgnoreCols);
987 [ # # ]: 0 : SetSegmentToPageDesc(*aIter, false, bIgnoreCols);
988 : :
989 : 0 : SwFmtPageDesc aPgDesc(aIter->HasTitlePage() ?
990 [ # # ][ # # ]: 0 : aIter->mpTitlePage : aIter->mpPage);
991 : :
992 [ # # ]: 0 : if (aIter->mpTitlePage)
993 : 0 : aIter->mpTitlePage->SetFollow(aIter->mpPage);
994 : :
995 [ # # # # : 0 : if (aIter->PageRestartNo() ||
# # ][ # # ]
996 : 0 : ((aIter == aStart) && aIter->PageStartAt() != 1))
997 : 0 : aPgDesc.SetNumOffset( static_cast< sal_uInt16 >(aIter->PageStartAt()) );
998 : :
999 : : /*
1000 : : If its a table here, apply the pagebreak to the table
1001 : : properties, otherwise we add it to the para at this
1002 : : position
1003 : : */
1004 [ # # ]: 0 : if (aIter->maStart.GetNode().IsTableNode())
1005 : : {
1006 : : SwTable& rTable =
1007 : 0 : aIter->maStart.GetNode().GetTableNode()->GetTable();
1008 : 0 : SwFrmFmt* pApply = rTable.GetFrmFmt();
1009 : : OSL_ENSURE(pApply, "impossible");
1010 [ # # ]: 0 : if (pApply)
1011 [ # # ]: 0 : pApply->SetFmtAttr(aPgDesc);
1012 : : }
1013 : : else
1014 : : {
1015 [ # # ]: 0 : SwPosition aPamStart(aIter->maStart);
1016 : : aPamStart.nContent.Assign(
1017 [ # # ][ # # ]: 0 : aIter->maStart.GetNode().GetCntntNode(), 0);
1018 [ # # ]: 0 : SwPaM aPage(aPamStart);
1019 : :
1020 [ # # ][ # # ]: 0 : mrReader.pDoc->InsertPoolItem(aPage, aPgDesc, 0);
[ # # ]
1021 : : }
1022 [ # # ]: 0 : ++nDesc;
1023 : : }
1024 : :
1025 : 0 : SwTxtNode* pTxtNd = 0;
1026 [ # # ]: 0 : if (bInsertSection)
1027 : : {
1028 [ # # ]: 0 : SwPaM aSectPaM(*mrReader.pPam);
1029 [ # # ]: 0 : SwNodeIndex aAnchor(aSectPaM.GetPoint()->nNode);
1030 [ # # ][ # # ]: 0 : if (aNext != aEnd)
1031 : : {
1032 [ # # ]: 0 : aAnchor = aNext->maStart;
1033 [ # # ]: 0 : aSectPaM.GetPoint()->nNode = aAnchor;
1034 : 0 : aSectPaM.GetPoint()->nContent.Assign(
1035 [ # # ][ # # ]: 0 : aNext->maStart.GetNode().GetCntntNode(), 0);
1036 [ # # ]: 0 : aSectPaM.Move(fnMoveBackward);
1037 : : }
1038 : :
1039 : 0 : const SwPosition* pPos = aSectPaM.GetPoint();
1040 : 0 : SwTxtNode const*const pSttNd = pPos->nNode.GetNode().GetTxtNode();
1041 [ # # ][ # # ]: 0 : const SwTableNode* pTableNd = pSttNd ? pSttNd->FindTableNode() : 0;
1042 [ # # ]: 0 : if (pTableNd)
1043 : : {
1044 : : pTxtNd =
1045 [ # # ]: 0 : mrReader.pDoc->GetNodes().MakeTxtNode(aAnchor,
1046 [ # # ][ # # ]: 0 : mrReader.pDoc->GetTxtCollFromPool( RES_POOLCOLL_TEXT ));
1047 : :
1048 [ # # ][ # # ]: 0 : aSectPaM.GetPoint()->nNode = SwNodeIndex(*pTxtNd);
[ # # ]
1049 : 0 : aSectPaM.GetPoint()->nContent.Assign(
1050 [ # # ][ # # ]: 0 : aSectPaM.GetCntntNode(), 0);
1051 : : }
1052 : :
1053 [ # # ]: 0 : aSectPaM.SetMark();
1054 : :
1055 [ # # ]: 0 : aSectPaM.GetPoint()->nNode = aIter->maStart;
1056 : 0 : aSectPaM.GetPoint()->nContent.Assign(
1057 [ # # ][ # # ]: 0 : aSectPaM.GetCntntNode(), 0);
1058 : :
1059 [ # # ]: 0 : SwSectionFmt *pRet = InsertSection(aSectPaM, *aIter);
1060 : : //The last section if continous is always unbalanced
1061 [ # # ][ # # ]: 0 : if (aNext == aEnd && pRet)
[ # # ]
1062 [ # # ][ # # ]: 0 : pRet->SetFmtAttr(SwFmtNoBalancedColumns(true));
[ # # ][ # # ]
[ # # ]
1063 : : }
1064 : :
1065 [ # # ]: 0 : if (pTxtNd)
1066 : : {
1067 [ # # ]: 0 : SwNodeIndex aIdx(*pTxtNd);
1068 [ # # ]: 0 : SwPosition aPos(aIdx);
1069 [ # # ]: 0 : SwPaM aTest(aPos);
1070 [ # # ]: 0 : mrReader.pDoc->DelFullPara(aTest);
1071 [ # # ][ # # ]: 0 : pTxtNd = 0;
[ # # ]
1072 : : }
1073 : : }
1074 : 0 : }
1075 : :
1076 : : namespace sw{
1077 : : namespace util{
1078 : :
1079 : 0 : InsertedTableClient::InsertedTableClient(SwTableNode & rNode)
1080 : : {
1081 [ # # ]: 0 : rNode.Add(this);
1082 : 0 : }
1083 : :
1084 : 0 : SwTableNode * InsertedTableClient::GetTableNode()
1085 : : {
1086 [ # # ]: 0 : return dynamic_cast<SwTableNode *> (GetRegisteredInNonConst());
1087 : : }
1088 : :
1089 : 108 : InsertedTablesManager::InsertedTablesManager(const SwDoc &rDoc)
1090 : 108 : : mbHasRoot(rDoc.GetCurrentLayout()) //swmod 080218
1091 : : {
1092 : 108 : }
1093 : :
1094 : 102 : void InsertedTablesManager::DelAndMakeTblFrms()
1095 : : {
1096 [ - + ]: 102 : if (!mbHasRoot)
1097 : 102 : return;
1098 : 0 : TblMapIter aEnd = maTables.end();
1099 [ # # ]: 102 : for (TblMapIter aIter = maTables.begin(); aIter != aEnd; ++aIter)
1100 : : {
1101 : : // exitiert schon ein Layout, dann muss an dieser Tabelle die BoxFrames
1102 : : // neu erzeugt
1103 : 0 : SwTableNode *pTable = aIter->first->GetTableNode();
1104 : : OSL_ENSURE(pTable, "Why no expected table");
1105 [ # # ]: 0 : if (pTable)
1106 : : {
1107 : 0 : SwFrmFmt * pFrmFmt = pTable->GetTable().GetFrmFmt();
1108 : :
1109 [ # # ]: 0 : if (pFrmFmt != NULL)
1110 : : {
1111 : 0 : SwNodeIndex *pIndex = aIter->second;
1112 [ # # ]: 0 : pTable->DelFrms();
1113 [ # # ]: 0 : pTable->MakeFrms(pIndex);
1114 : : }
1115 : : }
1116 : : }
1117 : : }
1118 : :
1119 : 90 : void InsertedTablesManager::InsertTable(SwTableNode &rTableNode, SwPaM &rPaM)
1120 : : {
1121 [ - + ]: 90 : if (!mbHasRoot)
1122 : 90 : return;
1123 : : //Associate this tablenode with this after position, replace an //old
1124 : : //node association if necessary
1125 : :
1126 [ # # ][ # # ]: 0 : InsertedTableClient * pClient = new InsertedTableClient(rTableNode);
1127 : :
1128 [ # # ]: 90 : maTables.insert(TblMap::value_type(pClient, &(rPaM.GetPoint()->nNode)));
1129 : : }
1130 : : }
1131 : : }
1132 : :
1133 [ # # ][ # # ]: 0 : SwRTFParser::~SwRTFParser()
[ # # ][ # # ]
[ # # ][ # # ]
1134 : : {
1135 [ # # ]: 0 : maInsertedTables.DelAndMakeTblFrms();
1136 [ # # ]: 0 : mpRedlineStack->closeall(*pPam->GetPoint());
1137 [ # # ][ # # ]: 0 : delete mpRedlineStack;
1138 : :
1139 [ # # ][ # # ]: 0 : delete pSttNdIdx;
1140 [ # # ][ # # ]: 0 : delete pRegionEndIdx;
1141 [ # # ][ # # ]: 0 : delete pPam;
1142 [ # # ][ # # ]: 0 : delete pRelNumRule;
1143 : :
1144 [ # # ]: 0 : if (pGrfAttrSet)
1145 [ # # ][ # # ]: 0 : DELETEZ( pGrfAttrSet );
1146 [ # # ]: 0 : }
1147 : :
1148 : : //i19718
1149 : 0 : void SwRTFParser::ReadShpRslt()
1150 : : {
1151 : : int nToken;
1152 [ # # ][ # # ]: 0 : while ('}' != (nToken = GetNextToken() ) && IsParserWorking())
[ # # ]
1153 : : {
1154 [ # # ]: 0 : switch(nToken)
1155 : : {
1156 : : case RTF_PAR:
1157 : 0 : break;
1158 : : default:
1159 : 0 : NextToken(nToken);
1160 : 0 : break;
1161 : : }
1162 : : }
1163 : 0 : SkipToken(-1);
1164 : 0 : }
1165 : :
1166 : 0 : void SwRTFParser::ReadShpTxt(String& s)
1167 : : {
1168 : : int nToken;
1169 : 0 : int level=1;
1170 : 0 : s.AppendAscii("{\\rtf");
1171 [ # # ][ # # ]: 0 : while (level>0 && IsParserWorking())
[ # # ]
1172 : : {
1173 : 0 : nToken = GetNextToken();
1174 [ # # # # : 0 : switch(nToken)
# ]
1175 : : {
1176 : : case RTF_SN:
1177 : : case RTF_SV:
1178 : 0 : SkipGroup();
1179 : 0 : break;
1180 : : case RTF_TEXTTOKEN:
1181 : 0 : s.Append(aToken);
1182 : 0 : break;
1183 : : case '{':
1184 : 0 : level++;
1185 [ # # ][ # # ]: 0 : s.Append(rtl::OUString("{"));
[ # # ]
1186 : 0 : break;
1187 : : case '}':
1188 : 0 : level--;
1189 [ # # ][ # # ]: 0 : s.Append(rtl::OUString("}"));
[ # # ]
1190 : 0 : break;
1191 : : default:
1192 : 0 : s.Append(aToken);
1193 [ # # ]: 0 : if (bTokenHasValue)
1194 [ # # ][ # # ]: 0 : s.Append(rtl::OUString::valueOf(static_cast<sal_Int64>(nTokenValue)));
[ # # ]
1195 [ # # ][ # # ]: 0 : s.Append(rtl::OUString(" "));
[ # # ]
1196 : 0 : break;
1197 : : }
1198 : : }
1199 : 0 : SkipToken(-1);
1200 : 0 : }
1201 : :
1202 : : /*
1203 : : * Very basic support for the Z-line.
1204 : : */
1205 : 0 : void SwRTFParser::ReadDrawingObject()
1206 : : {
1207 : : int nToken;
1208 : : int level;
1209 : 0 : level=1;
1210 [ # # ]: 0 : Rectangle aRect;
1211 [ # # ]: 0 : ::basegfx::B2DPolygon aPolygon;
1212 : 0 : ::basegfx::B2DPoint aPoint;
1213 : 0 : bool bPolygonActive(false);
1214 : :
1215 [ # # ]: 0 : SwFmtHoriOrient aHori( 0, text::HoriOrientation::NONE, text::RelOrientation::PAGE_FRAME );
1216 [ # # ]: 0 : SwFmtVertOrient aVert( 0, text::VertOrientation::NONE, text::RelOrientation::PAGE_FRAME );
1217 : :
1218 [ # # ][ # # ]: 0 : while (level>0 && IsParserWorking())
[ # # ]
1219 : : {
1220 [ # # ]: 0 : nToken = GetNextToken();
1221 [ # # # # : 0 : switch(nToken)
# # # # #
# # # ]
1222 : : {
1223 : : case '}':
1224 : 0 : level--;
1225 : 0 : break;
1226 : : case '{':
1227 : 0 : level++;
1228 : 0 : break;
1229 : : case RTF_DOBXMARGIN:
1230 : 0 : aHori.SetRelationOrient( text::RelOrientation::PAGE_PRINT_AREA );
1231 : 0 : break;
1232 : : case RTF_DOBYMARGIN:
1233 : 0 : aVert.SetRelationOrient( text::RelOrientation::PAGE_PRINT_AREA );
1234 : 0 : break;
1235 : : case RTF_DPX:
1236 : 0 : aRect.setX(nTokenValue);
1237 : 0 : break;
1238 : : case RTF_DPXSIZE:
1239 : 0 : aRect.setWidth(nTokenValue);
1240 : 0 : break;
1241 : : case RTF_DPY:
1242 : 0 : aRect.setY(nTokenValue);
1243 : 0 : break;
1244 : : case RTF_DPYSIZE:
1245 : 0 : aRect.setHeight(nTokenValue);
1246 : 0 : break;
1247 : : case RTF_DPLINE:
1248 : : case RTF_DPPOLYCOUNT:
1249 : 0 : bPolygonActive = true;
1250 : 0 : break;
1251 : : case RTF_DPPTX:
1252 : 0 : aPoint.setX(nTokenValue);
1253 : 0 : break;
1254 : : case RTF_DPPTY:
1255 : 0 : aPoint.setY(nTokenValue);
1256 : :
1257 [ # # ]: 0 : if(bPolygonActive)
1258 : : {
1259 [ # # ]: 0 : aPolygon.append(aPoint);
1260 : : }
1261 : :
1262 : 0 : break;
1263 : : default:
1264 : 0 : break;
1265 : : }
1266 : : }
1267 [ # # ]: 0 : SkipToken(-1);
1268 : :
1269 [ # # ][ # # ]: 0 : if(bPolygonActive && aPolygon.count())
[ # # ][ # # ]
1270 : : {
1271 [ # # ][ # # ]: 0 : SdrPathObj* pStroke = new SdrPathObj(OBJ_PLIN, ::basegfx::B2DPolyPolygon(aPolygon));
[ # # ][ # # ]
1272 [ # # ]: 0 : SfxItemSet aFlySet(pDoc->GetAttrPool(), RES_FRMATR_BEGIN, RES_FRMATR_END-1);
1273 [ # # ]: 0 : SwFmtSurround aSur( SURROUND_PARALLEL );
1274 : 0 : aSur.SetContour( false );
1275 : 0 : aSur.SetOutside(true);
1276 [ # # ]: 0 : aFlySet.Put( aSur );
1277 [ # # ]: 0 : SwFmtFollowTextFlow aFollowTextFlow( sal_False );
1278 [ # # ]: 0 : aFlySet.Put( aFollowTextFlow );
1279 : :
1280 [ # # ]: 0 : SwFmtAnchor aAnchor( FLY_AT_PARA );
1281 [ # # ]: 0 : aAnchor.SetAnchor( pPam->GetPoint() );
1282 [ # # ]: 0 : aFlySet.Put( aAnchor );
1283 : :
1284 [ # # ]: 0 : aFlySet.Put( aHori );
1285 [ # # ]: 0 : aFlySet.Put( aVert );
1286 : :
1287 [ # # ]: 0 : pDoc->GetOrCreateDrawModel();
1288 [ # # ]: 0 : SdrModel* pDrawModel = pDoc->GetDrawModel();
1289 [ # # ]: 0 : SdrPage* pDrawPg = pDrawModel->GetPage(0);
1290 [ # # ]: 0 : pDrawPg->InsertObject(pStroke, 0);
1291 : :
1292 [ # # ]: 0 : pStroke->SetSnapRect(aRect);
1293 : :
1294 [ # # ][ # # ]: 0 : pDoc->Insert(*pPam, *pStroke, &aFlySet, NULL);
[ # # ][ # # ]
[ # # ]
1295 [ # # ][ # # ]: 0 : }
[ # # ]
1296 : 0 : }
1297 : :
1298 : 0 : void SwRTFParser::InsertShpObject(SdrObject* pStroke, int _nZOrder)
1299 : : {
1300 [ # # ]: 0 : SfxItemSet aFlySet(pDoc->GetAttrPool(), RES_FRMATR_BEGIN, RES_FRMATR_END-1);
1301 [ # # ]: 0 : SwFmtSurround aSur( SURROUND_THROUGHT );
1302 : 0 : aSur.SetContour( false );
1303 : 0 : aSur.SetOutside(true);
1304 [ # # ]: 0 : aFlySet.Put( aSur );
1305 [ # # ]: 0 : SwFmtFollowTextFlow aFollowTextFlow( sal_False );
1306 [ # # ]: 0 : aFlySet.Put( aFollowTextFlow );
1307 : :
1308 [ # # ]: 0 : SwFmtAnchor aAnchor( FLY_AT_PARA );
1309 [ # # ]: 0 : aAnchor.SetAnchor( pPam->GetPoint() );
1310 [ # # ]: 0 : aFlySet.Put( aAnchor );
1311 : :
1312 : :
1313 [ # # ]: 0 : SwFmtHoriOrient aHori( 0, text::HoriOrientation::NONE, text::RelOrientation::PAGE_FRAME );
1314 [ # # ]: 0 : aFlySet.Put( aHori );
1315 : :
1316 [ # # ]: 0 : SwFmtVertOrient aVert( 0, text::VertOrientation::NONE, text::RelOrientation::PAGE_FRAME );
1317 [ # # ]: 0 : aFlySet.Put( aVert );
1318 : :
1319 [ # # ][ # # ]: 0 : aFlySet.Put(SvxOpaqueItem(RES_OPAQUE,false));
[ # # ]
1320 : :
1321 [ # # ]: 0 : pDoc->GetOrCreateDrawModel();
1322 [ # # ]: 0 : SdrModel* pDrawModel = pDoc->GetDrawModel();
1323 [ # # ]: 0 : SdrPage* pDrawPg = pDrawModel->GetPage(0);
1324 [ # # ]: 0 : pDrawPg->InsertObject(pStroke);
1325 [ # # ][ # # ]: 0 : pDrawPg->SetObjectOrdNum(pStroke->GetOrdNum(), _nZOrder);
1326 [ # # ][ # # ]: 0 : pDoc->Insert(*pPam, *pStroke, &aFlySet, NULL);
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
1327 : 0 : }
1328 : :
1329 : 0 : ::basegfx::B2DPoint rotate(const ::basegfx::B2DPoint& rStart, const ::basegfx::B2DPoint& rEnd)
1330 : : {
1331 : 0 : const ::basegfx::B2DVector aVector(rStart - rEnd);
1332 : 0 : return ::basegfx::B2DPoint(aVector.getY() + rEnd.getX(), -aVector.getX() + rEnd.getY());
1333 : : }
1334 : :
1335 : :
1336 : 0 : void SwRTFParser::ReadShapeObject()
1337 : : {
1338 : : int nToken;
1339 : : int level;
1340 : 0 : level=1;
1341 : 0 : ::basegfx::B2DPoint aPointLeftTop;
1342 : 0 : ::basegfx::B2DPoint aPointRightBottom;
1343 [ # # ]: 0 : String sn;
1344 : 0 : sal_Int32 shapeType=-1;
1345 [ # # ]: 0 : Graphic aGrf;
1346 : 0 : bool bGrfValid=false;
1347 : 0 : bool fFilled=true;
1348 : 0 : Color fillColor(255, 255, 255);
1349 : 0 : bool fLine=true;
1350 : 0 : int lineWidth=9525/360;
1351 [ # # ]: 0 : String shpTxt;
1352 : 0 : bool bshpTxt=false;
1353 : 0 : int txflTextFlow=0;
1354 : 0 : ::rtl::OUString sDescription, sName;
1355 : :
1356 : :
1357 [ # # ][ # # ]: 0 : while (level>0 && IsParserWorking())
[ # # ]
1358 : : {
1359 [ # # ]: 0 : nToken = GetNextToken();
1360 [ # # # # : 0 : switch(nToken)
# # # # #
# # # ]
1361 : : {
1362 : : case '}':
1363 : 0 : level--;
1364 : 0 : break;
1365 : : case '{':
1366 : 0 : level++;
1367 : 0 : break;
1368 : : case RTF_SHPLEFT:
1369 : 0 : aPointLeftTop.setX(nTokenValue);
1370 : 0 : break;
1371 : : case RTF_SHPTOP:
1372 : 0 : aPointLeftTop.setY(nTokenValue);
1373 : 0 : break;
1374 : : case RTF_SHPBOTTOM:
1375 : 0 : aPointRightBottom.setY(nTokenValue);
1376 : 0 : break;
1377 : : case RTF_SHPRIGHT:
1378 : 0 : aPointRightBottom.setX(nTokenValue);
1379 : 0 : break;
1380 : : case RTF_SN:
1381 [ # # ]: 0 : nToken = GetNextToken();
1382 : : OSL_ENSURE(nToken==RTF_TEXTTOKEN, "expected name");
1383 [ # # ]: 0 : sn=aToken;
1384 : 0 : break;
1385 : : case RTF_SV:
1386 [ # # ]: 0 : nToken = GetNextToken();
1387 [ # # ]: 0 : if (nToken==RTF_TEXTTOKEN)
1388 : : {
1389 [ # # ][ # # ]: 0 : if (sn.EqualsAscii("shapeType"))
1390 : : {
1391 [ # # ]: 0 : shapeType=aToken.ToInt32();
1392 : :
1393 [ # # ][ # # ]: 0 : } else if (sn.EqualsAscii("fFilled"))
1394 : : {
1395 [ # # ]: 0 : fFilled=aToken.ToInt32();
1396 : :
1397 [ # # ][ # # ]: 0 : } else if (sn.EqualsAscii("fLine"))
1398 : : {
1399 [ # # ]: 0 : fLine=aToken.ToInt32();
1400 [ # # ][ # # ]: 0 : } else if (sn.EqualsAscii("lineWidth"))
1401 : : {
1402 [ # # ]: 0 : lineWidth=aToken.ToInt32()/360;
1403 : :
1404 [ # # ][ # # ]: 0 : } else if (sn.EqualsAscii("fillColor"))
1405 : : {
1406 [ # # ]: 0 : sal_uInt32 nColor=aToken.ToInt32();
1407 : 0 : fillColor=Color( (sal_uInt8)nColor, (sal_uInt8)( nColor >> 8 ), (sal_uInt8)( nColor >> 16 ) );
1408 [ # # ][ # # ]: 0 : }else if (sn.EqualsAscii("txflTextFlow"))
1409 : : {
1410 [ # # ]: 0 : txflTextFlow=aToken.ToInt32();
1411 : : }
1412 [ # # ][ # # ]: 0 : else if (sn.EqualsAscii("wzDescription"))
1413 : : {
1414 [ # # ]: 0 : sDescription = aToken;
1415 : : }
1416 [ # # ][ # # ]: 0 : else if(sn.EqualsAscii("wzName"))
1417 : : {
1418 [ # # ]: 0 : sName = aToken;
1419 : : }
1420 : : }
1421 : 0 : break;
1422 : : case RTF_PICT:
1423 : : {
1424 [ # # ]: 0 : SvxRTFPictureType aPicType;
1425 [ # # ]: 0 : bGrfValid=ReadBmpData( aGrf, aPicType );
1426 : : }
1427 : 0 : break;
1428 : : case RTF_SHPRSLT:
1429 [ # # ][ # # ]: 0 : if (shapeType!=1 && shapeType!=20 && shapeType!=75)
[ # # ]
1430 : : {
1431 [ # # ]: 0 : ReadShpRslt();
1432 : : }
1433 : 0 : break;
1434 : : case RTF_SHPTXT:
1435 [ # # ]: 0 : ReadShpTxt(shpTxt);
1436 : 0 : bshpTxt=true;
1437 : 0 : break;
1438 : :
1439 : : default:
1440 : 0 : break;
1441 : : }
1442 : : }
1443 [ # # ]: 0 : SkipToken(-1);
1444 : :
1445 : 0 : SdrObject* pSdrObject = 0;
1446 [ # # # # ]: 0 : switch(shapeType)
1447 : : {
1448 : : case 202: /* Text Box */
1449 : : case 1: /* Rectangle */
1450 : : {
1451 [ # # ]: 0 : ::basegfx::B2DRange aRange(aPointLeftTop);
1452 [ # # ]: 0 : aRange.expand(aPointRightBottom);
1453 : :
1454 [ # # ]: 0 : if (txflTextFlow==2) {
1455 [ # # ][ # # ]: 0 : const ::basegfx::B2DPoint a(rotate(aRange.getMinimum(), aRange.getCenter()));
1456 [ # # ][ # # ]: 0 : const ::basegfx::B2DPoint b(rotate(aRange.getMaximum(), aRange.getCenter()));
1457 : :
1458 [ # # ]: 0 : aRange.reset();
1459 [ # # ]: 0 : aRange.expand(a);
1460 [ # # ]: 0 : aRange.expand(b);
1461 : : }
1462 : :
1463 [ # # ][ # # ]: 0 : const Rectangle aRect(FRound(aRange.getMinX()), FRound(aRange.getMinY()), FRound(aRange.getMaxX()), FRound(aRange.getMaxY()));
[ # # ][ # # ]
[ # # ]
1464 [ # # ][ # # ]: 0 : SdrRectObj* pStroke = new SdrRectObj(aRect);
1465 : 0 : pSdrObject = pStroke;
1466 [ # # ]: 0 : pStroke->SetSnapRect(aRect);
1467 [ # # ]: 0 : pDoc->GetOrCreateDrawModel(); // create model
1468 [ # # ]: 0 : InsertShpObject(pStroke, this->nZOrder++);
1469 [ # # ][ # # ]: 0 : SfxItemSet aSet(pStroke->GetMergedItemSet());
1470 [ # # ]: 0 : if (fFilled)
1471 : : {
1472 [ # # ][ # # ]: 0 : aSet.Put(XFillStyleItem(XFILL_SOLID));
[ # # ]
1473 [ # # ][ # # ]: 0 : aSet.Put(XFillColorItem( String(), fillColor ) );
[ # # ][ # # ]
[ # # ]
1474 : : }
1475 : : else
1476 : : {
1477 [ # # ][ # # ]: 0 : aSet.Put(XFillStyleItem(XFILL_NONE));
[ # # ]
1478 : : }
1479 [ # # ]: 0 : if (!fLine) {
1480 [ # # ][ # # ]: 0 : aSet.Put(XLineStyleItem(XLINE_NONE));
[ # # ]
1481 : : } else {
1482 [ # # ][ # # ]: 0 : aSet.Put( XLineWidthItem( lineWidth/2 ) ); // lineWidth are in 1000th mm, seems that XLineWidthItem expects 1/2 the line width
[ # # ]
1483 : : }
1484 : :
1485 [ # # ]: 0 : pStroke->SetMergedItemSet(aSet);
1486 [ # # ]: 0 : if (bshpTxt) {
1487 [ # # ][ # # ]: 0 : SdrOutliner& rOutliner=pDoc->GetDrawModel()->GetDrawOutliner(pStroke);
1488 [ # # ]: 0 : rOutliner.Clear();
1489 : : rtl::OString bs(rtl::OUStringToOString(shpTxt,
1490 [ # # ][ # # ]: 0 : RTL_TEXTENCODING_ASCII_US));
1491 : 0 : SvMemoryStream aStream(const_cast<sal_Char*>(bs.getStr()),
1492 [ # # ]: 0 : bs.getLength(), STREAM_READ);
1493 [ # # ][ # # ]: 0 : rOutliner.Read(aStream, rtl::OUString(), EE_FORMAT_RTF);
[ # # ]
1494 [ # # ]: 0 : OutlinerParaObject* pParaObject=rOutliner.CreateParaObject();
1495 [ # # ]: 0 : pStroke->NbcSetOutlinerParaObject(pParaObject);
1496 [ # # ][ # # ]: 0 : rOutliner.Clear();
1497 : : }
1498 [ # # ]: 0 : if (txflTextFlow==2) {
1499 : 0 : long nAngle = 90;
1500 : 0 : double a = nAngle*100*nPi180;
1501 [ # # ][ # # ]: 0 : pStroke->Rotate(pStroke->GetCurrentBoundRect().Center(), nAngle*100, sin(a), cos(a) );
[ # # ]
1502 : :
1503 [ # # ]: 0 : }
1504 : :
1505 : : }
1506 : 0 : break;
1507 : : case 20: /* Line */
1508 : : {
1509 [ # # ]: 0 : ::basegfx::B2DPolygon aLine;
1510 [ # # ]: 0 : aLine.append(aPointLeftTop);
1511 [ # # ]: 0 : aLine.append(aPointRightBottom);
1512 : :
1513 [ # # ][ # # ]: 0 : SdrPathObj* pStroke = new SdrPathObj(OBJ_PLIN, ::basegfx::B2DPolyPolygon(aLine));
[ # # ][ # # ]
1514 : 0 : pSdrObject = pStroke;
1515 : :
1516 [ # # ]: 0 : InsertShpObject(pStroke, this->nZOrder++);
1517 [ # # ][ # # ]: 0 : SfxItemSet aSet(pStroke->GetMergedItemSet());
1518 [ # # ]: 0 : if (!fLine) {
1519 [ # # ][ # # ]: 0 : aSet.Put(XLineStyleItem(XLINE_NONE));
[ # # ]
1520 : : } else {
1521 [ # # ][ # # ]: 0 : aSet.Put( XLineWidthItem( lineWidth/2 ) ); // lineWidth are in 1000th mm, seems that XLineWidthItem expects 1/2 the line width
[ # # ]
1522 : : }
1523 : :
1524 [ # # ][ # # ]: 0 : pStroke->SetMergedItemSet(aSet);
[ # # ]
1525 : : }
1526 : 0 : break;
1527 : : case 75 : /* Picture */
1528 [ # # ]: 0 : if (bGrfValid) {
1529 [ # # ]: 0 : ::basegfx::B2DRange aRange(aPointLeftTop);
1530 [ # # ]: 0 : aRange.expand(aPointRightBottom);
1531 [ # # ][ # # ]: 0 : const Rectangle aRect(FRound(aRange.getMinX()), FRound(aRange.getMinY()), FRound(aRange.getMaxX()), FRound(aRange.getMaxY()));
[ # # ][ # # ]
[ # # ]
1532 : :
1533 [ # # ][ # # ]: 0 : SdrRectObj* pStroke = new SdrGrafObj(aGrf);
1534 : 0 : pSdrObject = pStroke;
1535 [ # # ]: 0 : pStroke->SetSnapRect(aRect);
1536 : :
1537 [ # # ]: 0 : InsertShpObject(pStroke, this->nZOrder++);
1538 : : }
1539 : : }
1540 [ # # ]: 0 : if( pSdrObject )
1541 : : {
1542 [ # # ]: 0 : pSdrObject->SetDescription(sDescription);
1543 [ # # ]: 0 : pSdrObject->SetTitle(sName);
1544 [ # # ][ # # ]: 0 : }
[ # # ]
1545 : 0 : }
1546 : :
1547 : : extern void sw3io_ConvertFromOldField( SwDoc& rDoc, sal_uInt16& rWhich,
1548 : : sal_uInt16& rSubType, sal_uLong &rFmt,
1549 : : sal_uInt16 nVersion );
1550 : :
1551 : 0 : sal_uInt16 SwRTFParser::ReadRevTbl()
1552 : : {
1553 : 0 : int nNumOpenBrakets = 1, nToken; // die erste wurde schon vorher erkannt !!
1554 : 0 : sal_uInt16 nAuthorTableIndex = 0;
1555 : :
1556 [ # # ][ # # ]: 0 : while( nNumOpenBrakets && IsParserWorking() )
[ # # ]
1557 : : {
1558 [ # # ]: 0 : switch( nToken = GetNextToken() )
[ # # # # ]
1559 : : {
1560 : 0 : case '}': --nNumOpenBrakets; break;
1561 : : case '{':
1562 : : {
1563 [ # # ][ # # ]: 0 : if( RTF_IGNOREFLAG != GetNextToken() )
1564 [ # # ]: 0 : nToken = SkipToken( -1 );
1565 [ # # ][ # # ]: 0 : else if( RTF_UNKNOWNCONTROL != GetNextToken() )
1566 [ # # ]: 0 : nToken = SkipToken( -2 );
1567 : : else
1568 : : {
1569 [ # # ]: 0 : ReadUnknownData();
1570 [ # # ]: 0 : nToken = GetNextToken();
1571 [ # # ]: 0 : if( '}' != nToken )
1572 : 0 : eState = SVPAR_ERROR;
1573 : 0 : break;
1574 : : }
1575 : 0 : ++nNumOpenBrakets;
1576 : : }
1577 : 0 : break;
1578 : :
1579 : : case RTF_TEXTTOKEN:
1580 [ # # ][ # # ]: 0 : aToken = comphelper::string::stripEnd(aToken, ';');
[ # # ]
1581 : :
1582 [ # # ]: 0 : sal_uInt16 nSWId = pDoc->InsertRedlineAuthor(aToken);
1583 : : // Store matchpair
1584 [ # # ]: 0 : m_aAuthorInfos[nAuthorTableIndex] = nSWId;
1585 : :
1586 [ # # ]: 0 : aRevTbl.push_back(aToken);
1587 : 0 : nAuthorTableIndex++;
1588 : 0 : break;
1589 : : }
1590 : : }
1591 [ # # ]: 0 : SkipToken( -1 );
1592 : 0 : return nAuthorTableIndex;
1593 : : }
1594 : :
1595 : 0 : void SwRTFParser::NextToken( int nToken )
1596 : : {
1597 : : sal_uInt16 eDateFmt;
1598 : :
1599 [ # # # # : 0 : switch( nToken )
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # ]
1600 : : {
1601 : : case RTF_FOOTNOTE:
1602 : : {
1603 : : //We can only insert a footnote if we're not inside a footnote. e.g.
1604 : : //#i7713#
1605 : :
1606 : : // in insert mode it's also possible to be inside of a footnote!
1607 : 0 : bool bInsertIntoFootnote = false;
1608 [ # # ]: 0 : if( !IsNewDoc() )
1609 : : {
1610 : 0 : SwStartNode* pSttNode = pPam->GetNode()->StartOfSectionNode();
1611 [ # # ][ # # ]: 0 : while(pSttNode && pSttNode->IsSectionNode())
[ # # ]
1612 : : {
1613 : 0 : pSttNode = pSttNode->StartOfSectionNode();
1614 : : }
1615 [ # # ]: 0 : if( SwFootnoteStartNode == pSttNode->GetStartNodeType() )
1616 : 0 : bInsertIntoFootnote = true;
1617 : : }
1618 [ # # ][ # # ]: 0 : if (!mbIsFootnote && !bInsertIntoFootnote)
1619 : : {
1620 : 0 : ReadHeaderFooter( nToken );
1621 : 0 : SkipToken( -1 ); // Klammer wieder zurueck
1622 : : }
1623 : : }
1624 : 0 : break;
1625 : : case RTF_SWG_PRTDATA:
1626 : 0 : ReadPrtData();
1627 : 0 : break;
1628 : : case RTF_XE:
1629 : 0 : ReadXEField();
1630 : 0 : break;
1631 : : case RTF_FIELD:
1632 : 0 : ReadField();
1633 : 0 : break;
1634 : : case RTF_SHPRSLT:
1635 : 0 : ReadShpRslt();
1636 : 0 : break;
1637 : : case RTF_DO:
1638 : 0 : ReadDrawingObject();
1639 : 0 : break;
1640 : : case RTF_SHP:
1641 : 0 : ReadShapeObject();
1642 : 0 : break;
1643 : : case RTF_SHPPICT:
1644 : : case RTF_PICT:
1645 : 0 : ReadBitmapData();
1646 : 0 : break;
1647 : : #ifdef READ_OLE_OBJECT
1648 : : case RTF_OBJECT:
1649 : : ReadOLEData();
1650 : : break;
1651 : : #endif
1652 : 0 : case RTF_TROWD: ReadTable( nToken ); break;
1653 : : case RTF_PGDSCTBL:
1654 [ # # ]: 0 : if( !IsNewDoc() )
1655 : 0 : SkipPageDescTbl();
1656 : : else
1657 : 0 : ReadPageDescTbl();
1658 : 0 : break;
1659 : 0 : case RTF_LISTTABLE: ReadListTable(); break;
1660 : 0 : case RTF_LISTOVERRIDETABLE: ReadListOverrideTable(); break;
1661 : :
1662 : : case RTF_LISTTEXT:
1663 [ # # ][ # # ]: 0 : GetAttrSet().Put( SfxUInt16Item( FN_PARAM_NUM_LEVEL, 0 ));
1664 : 0 : SkipGroup();
1665 : 0 : break;
1666 : :
1667 : : case RTF_PN:
1668 [ # # ]: 0 : if( bNewNumList )
1669 : 0 : SkipGroup();
1670 : : else
1671 : : {
1672 : 0 : bStyleTabValid = sal_True;
1673 [ # # ]: 0 : if (SwNumRule* pRule = ReadNumSecLevel( nToken ))
1674 : : {
1675 [ # # ][ # # ]: 0 : GetAttrSet().Put( SwNumRuleItem( pRule->GetName() ));
1676 : :
1677 [ # # ]: 0 : if( SFX_ITEM_SET != GetAttrSet().GetItemState( FN_PARAM_NUM_LEVEL, sal_False ))
1678 [ # # ][ # # ]: 0 : GetAttrSet().Put( SfxUInt16Item( FN_PARAM_NUM_LEVEL, 0 ));
1679 : : }
1680 : : }
1681 : 0 : break;
1682 : :
1683 : :
1684 : : case RTF_BKMKSTART:
1685 [ # # ]: 0 : if(RTF_TEXTTOKEN == GetNextToken())
1686 [ # # ]: 0 : mpBookmarkStart = new BookmarkPosition(*pPam);
1687 : : else
1688 : 0 : SkipToken(-1);
1689 : :
1690 : 0 : SkipGroup();
1691 : 0 : break;
1692 : :
1693 : : case RTF_BKMKEND:
1694 [ # # ]: 0 : if(RTF_TEXTTOKEN == GetNextToken())
1695 : : {
1696 : 0 : const String& sBookmark = aToken;
1697 : 0 : KeyCode aEmptyKeyCode;
1698 [ # # ]: 0 : if (mpBookmarkStart)
1699 : : {
1700 [ # # ]: 0 : BookmarkPosition aBookmarkEnd(*pPam);
1701 : : SwPaM aBookmarkRegion( mpBookmarkStart->maMkNode, mpBookmarkStart->mnMkCntnt,
1702 [ # # ]: 0 : aBookmarkEnd.maMkNode, aBookmarkEnd.mnMkCntnt);
1703 [ # # ][ # # ]: 0 : if (*mpBookmarkStart == aBookmarkEnd)
[ # # ]
1704 [ # # ]: 0 : aBookmarkRegion.DeleteMark();
1705 [ # # ][ # # ]: 0 : pDoc->getIDocumentMarkAccess()->makeMark(aBookmarkRegion, sBookmark, IDocumentMarkAccess::BOOKMARK);
[ # # ][ # # ]
[ # # ]
1706 : : }
1707 [ # # ][ # # ]: 0 : delete mpBookmarkStart, mpBookmarkStart = 0;
1708 : : }
1709 : : else
1710 : 0 : SkipToken(-1);
1711 : :
1712 : 0 : SkipGroup();
1713 : 0 : break;
1714 : :
1715 : :
1716 : : case RTF_PNSECLVL:{
1717 [ # # ]: 0 : if( bNewNumList)
1718 : 0 : SkipGroup();
1719 : : else
1720 : 0 : ReadNumSecLevel( nToken );
1721 : 0 : break;
1722 : : }
1723 : :
1724 : : case RTF_PNTEXT:
1725 : : case RTF_NONSHPPICT:
1726 : 0 : SkipGroup();
1727 : 0 : break;
1728 : :
1729 : : case RTF_DEFFORMAT:
1730 : : case RTF_DEFTAB:
1731 : : case RTF_DEFLANG:
1732 : : // sind zwar Dok-Controls, werden aber manchmal auch vor der
1733 : : // Font/Style/Color-Tabelle gesetzt!
1734 : 0 : SvxRTFParser::NextToken( nToken );
1735 : 0 : break;
1736 : :
1737 : : case RTF_PAGE:
1738 [ # # ]: 0 : if (pTableNode==NULL) { //A \page command within a table is ignored by Word.
1739 [ # # ]: 0 : if (lcl_UsedPara(*pPam))
1740 : 0 : InsertPara();
1741 : 0 : CheckInsNewTblLine();
1742 : : pDoc->InsertPoolItem(*pPam,
1743 [ # # ]: 0 : SvxFmtBreakItem(SVX_BREAK_PAGE_BEFORE, RES_BREAK), 0);
1744 : : }
1745 : 0 : break;
1746 : :
1747 : : case RTF_SECT:
1748 : 0 : ReadSectControls( nToken );
1749 : 0 : break;
1750 : : case RTF_CELL:
1751 : 0 : mbReadCellWhileReadSwFly = bReadSwFly; // #i83368#
1752 [ # # ]: 0 : if (CantUseTables())
1753 : 0 : InsertPara();
1754 : : else
1755 : : {
1756 : : // Tabelle nicht mehr vorhanden ?
1757 [ # # ][ # # ]: 0 : if (USHRT_MAX != nInsTblRow && !pTableNode)
1758 : 0 : NewTblLine(); // evt. Line copieren
1759 : 0 : GotoNextBox();
1760 : : }
1761 : 0 : break;
1762 : :
1763 : : case RTF_ROW:
1764 : 0 : bTrowdRead=false;
1765 [ # # ]: 0 : if (!CantUseTables())
1766 : : {
1767 : : // aus der Line raus
1768 : 0 : m_nCurrentBox = 0;
1769 : 0 : pTableNode = 0;
1770 : : // noch in der Tabelle drin?
1771 : 0 : SwNodeIndex& rIdx = pPam->GetPoint()->nNode;
1772 [ # # ]: 0 : const SwTableNode* pTblNd = rIdx.GetNode().FindTableNode();
1773 [ # # ]: 0 : if( pTblNd )
1774 : : {
1775 : : // search the end of this row
1776 : : const SwStartNode* pBoxStt =
1777 [ # # ]: 0 : rIdx.GetNode().FindTableBoxStartNode();
1778 : 0 : const SwTableBox* pBox = pTblNd->GetTable().GetTblBox(
1779 [ # # ]: 0 : pBoxStt->GetIndex() );
1780 : 0 : const SwTableLine* pLn = pBox->GetUpper();
1781 [ # # ]: 0 : pBox = pLn->GetTabBoxes().back();
1782 [ # # ]: 0 : rIdx = *pBox->GetSttNd()->EndOfSectionNode();
1783 [ # # ]: 0 : pPam->Move( fnMoveForward, fnGoNode );
1784 : : }
1785 : 0 : nInsTblRow = static_cast< sal_uInt16 >(GetOpenBrakets());
1786 : 0 : SetPardTokenRead( sal_False );
1787 [ # # ]: 0 : SwPaM aTmp(*pPam);
1788 [ # # ][ # # ]: 0 : aTmp.Move( fnMoveBackward, fnGoNode );
1789 : : }
1790 : 0 : ::SetProgressState( rInput.Tell(), pDoc->GetDocShell() );
1791 : 0 : break;
1792 : :
1793 : : case RTF_INTBL:
1794 [ # # ]: 0 : if (!CantUseTables())
1795 : : {
1796 [ # # ]: 0 : if( !pTableNode ) // Tabelle nicht mehr vorhanden ?
1797 : : {
1798 [ # # ]: 0 : if (RTF_TROWD != GetNextToken())
1799 : 0 : NewTblLine(); // evt. Line copieren
1800 : 0 : SkipToken(-1);
1801 : : }
1802 : : else
1803 : : {
1804 : : // Crsr nicht mehr in der Tabelle ?
1805 [ # # ]: 0 : if( !pPam->GetNode()->FindTableNode() )
1806 : : {
1807 : : // dann wieder in die letzte Box setzen
1808 : : // (kann durch einlesen von Flys geschehen!)
1809 : 0 : pPam->GetPoint()->nNode = *pTableNode->EndOfSectionNode();
1810 : 0 : pPam->Move( fnMoveBackward );
1811 : : }
1812 : : }
1813 : : }
1814 : 0 : break;
1815 : :
1816 : : case RTF_REVTBL:
1817 : 0 : ReadRevTbl();
1818 : 0 : break;
1819 : :
1820 : : case RTF_REVISED:
1821 [ # # ][ # # ]: 0 : pRedlineInsert = new SwFltRedline(nsRedlineType_t::REDLINE_INSERT, 0, DateTime(Date( 0 ), Time( 0 )));
[ # # ]
1822 : 0 : break;
1823 : :
1824 : : case RTF_DELETED:
1825 [ # # ][ # # ]: 0 : pRedlineDelete = new SwFltRedline(nsRedlineType_t::REDLINE_DELETE, 0, DateTime(Date( 0 ), Time( 0 )));
[ # # ]
1826 : 0 : break;
1827 : :
1828 : : case RTF_REVAUTH:
1829 [ # # ]: 0 : if (pRedlineInsert)
1830 : : {
1831 : 0 : sal_uInt16 nRevAuth = static_cast<sal_uInt16>(nTokenValue);
1832 [ # # ]: 0 : pRedlineInsert->nAutorNo = m_aAuthorInfos[nRevAuth];
1833 : : }
1834 : 0 : break;
1835 : :
1836 : : case RTF_REVAUTHDEL:
1837 [ # # ]: 0 : if(pRedlineDelete)
1838 : : {
1839 : 0 : sal_uInt16 nRevAuthDel = static_cast<sal_uInt16>(nTokenValue);
1840 [ # # ]: 0 : pRedlineDelete->nAutorNo = m_aAuthorInfos[nRevAuthDel];
1841 : : }
1842 : 0 : break;
1843 : :
1844 : : case RTF_REVDTTM:
1845 [ # # ]: 0 : if (pRedlineInsert != NULL)
1846 [ # # ]: 0 : pRedlineInsert->aStamp = msfilter::util::DTTM2DateTime(nTokenValue);
1847 : :
1848 : 0 : break;
1849 : :
1850 : : case RTF_REVDTTMDEL:
1851 [ # # ]: 0 : pRedlineDelete->aStamp = msfilter::util::DTTM2DateTime(nTokenValue);
1852 : 0 : break;
1853 : :
1854 : :
1855 : : case RTF_FLY_INPARA:
1856 : : // \pard und plain ueberlesen !
1857 [ # # ][ # # ]: 0 : if( '}' != GetNextToken() && '}' != GetNextToken() )
[ # # ]
1858 : : {
1859 : : // Zeichengebundener Fly in Fly
1860 : 0 : ReadHeaderFooter( nToken );
1861 : 0 : SetPardTokenRead( sal_False );
1862 : : }
1863 : 0 : break;
1864 : :
1865 : : case RTF_PGDSCNO:
1866 [ # # ]: 0 : if( IsNewDoc() && bSwPageDesc &&
[ # # # # ]
[ # # ]
1867 : 0 : sal_uInt16(nTokenValue) < pDoc->GetPageDescCnt() )
1868 : : {
1869 : : const SwPageDesc* pPgDsc =
1870 : : &const_cast<const SwDoc *>(pDoc)
1871 : 0 : ->GetPageDesc( sal_uInt16(nTokenValue) );
1872 : 0 : CheckInsNewTblLine();
1873 [ # # ]: 0 : pDoc->InsertPoolItem(*pPam, SwFmtPageDesc( pPgDsc ), 0);
1874 : : }
1875 : 0 : break;
1876 : :
1877 : : case RTF_COLUM:
1878 : : pDoc->InsertPoolItem(*pPam,
1879 [ # # ]: 0 : SvxFmtBreakItem( SVX_BREAK_COLUMN_BEFORE, RES_BREAK ), 0);
1880 : 0 : break;
1881 : :
1882 : : case RTF_DXFRTEXT: // werden nur im Zusammenhang mit Flys ausgewertet
1883 : : case RTF_DFRMTXTX:
1884 : : case RTF_DFRMTXTY:
1885 : 0 : break;
1886 : :
1887 : 0 : case RTF_CHDATE: eDateFmt = DF_SHORT; goto SETCHDATEFIELD;
1888 : 0 : case RTF_CHDATEA: eDateFmt = DF_SSYS; goto SETCHDATEFIELD;
1889 : 0 : case RTF_CHDATEL: eDateFmt = DF_LSYS; goto SETCHDATEFIELD;
1890 : : SETCHDATEFIELD:
1891 : : {
1892 : 0 : sal_uInt16 nSubType = DATEFLD, nWhich = RES_DATEFLD;
1893 : 0 : sal_uLong nFormat = eDateFmt;
1894 [ # # ]: 0 : sw3io_ConvertFromOldField( *pDoc, nWhich, nSubType, nFormat, 0x0110 );
1895 : :
1896 : : SwDateTimeField aDateFld( (SwDateTimeFieldType*)
1897 [ # # ][ # # ]: 0 : pDoc->GetSysFldType( RES_DATETIMEFLD ), DATEFLD, nFormat);
1898 [ # # ]: 0 : CheckInsNewTblLine();
1899 [ # # ][ # # ]: 0 : pDoc->InsertPoolItem(*pPam, SwFmtFld( aDateFld ), 0);
[ # # ][ # # ]
1900 : : }
1901 : 0 : break;
1902 : :
1903 : : case RTF_CHTIME:
1904 : : {
1905 : 0 : sal_uInt16 nSubType = TIMEFLD, nWhich = RES_TIMEFLD;
1906 : 0 : sal_uLong nFormat = TF_SSMM_24;
1907 [ # # ]: 0 : sw3io_ConvertFromOldField( *pDoc, nWhich, nSubType, nFormat, 0x0110 );
1908 : : SwDateTimeField aTimeFld( (SwDateTimeFieldType*)
1909 [ # # ][ # # ]: 0 : pDoc->GetSysFldType( RES_DATETIMEFLD ), TIMEFLD, nFormat);
1910 [ # # ]: 0 : CheckInsNewTblLine();
1911 [ # # ][ # # ]: 0 : pDoc->InsertPoolItem(*pPam, SwFmtFld( aTimeFld ), 0);
[ # # ][ # # ]
1912 : : }
1913 : 0 : break;
1914 : :
1915 : : case RTF_CHPGN:
1916 : : {
1917 : : SwPageNumberField aPageFld( (SwPageNumberFieldType*)
1918 [ # # ]: 0 : pDoc->GetSysFldType( RES_PAGENUMBERFLD ),
1919 [ # # ]: 0 : PG_RANDOM, SVX_NUM_ARABIC );
1920 [ # # ]: 0 : CheckInsNewTblLine();
1921 [ # # ][ # # ]: 0 : pDoc->InsertPoolItem(*pPam, SwFmtFld(aPageFld), 0);
[ # # ][ # # ]
1922 : : }
1923 : 0 : break;
1924 : :
1925 : : case RTF_CHFTN:
1926 : 0 : bFootnoteAutoNum = sal_True;
1927 : 0 : break;
1928 : :
1929 : : case RTF_NOFPAGES:
1930 [ # # ][ # # ]: 0 : if( IsNewDoc() && nTokenValue && -1 != nTokenValue )
[ # # ][ # # ]
1931 : 0 : ((SwDocStat&)pDoc->GetDocStat()).nPage = (sal_uInt16)nTokenValue;
1932 : 0 : break;
1933 : :
1934 : : case RTF_NOFWORDS:
1935 [ # # ][ # # ]: 0 : if( IsNewDoc() && nTokenValue && -1 != nTokenValue )
[ # # ][ # # ]
1936 : 0 : ((SwDocStat&)pDoc->GetDocStat()).nWord = (sal_uInt16)nTokenValue;
1937 : 0 : break;
1938 : : case RTF_NOFCHARS:
1939 [ # # ][ # # ]: 0 : if( IsNewDoc() && nTokenValue && -1 != nTokenValue )
[ # # ][ # # ]
1940 : 0 : ((SwDocStat&)pDoc->GetDocStat()).nChar = (sal_uInt16)nTokenValue;
1941 : 0 : break;
1942 : : case RTF_LYTPRTMET:
1943 [ # # ]: 0 : if (IsNewDoc())
1944 : 0 : pDoc->set(IDocumentSettingAccess::USE_VIRTUAL_DEVICE, false);
1945 : 0 : break;
1946 : : case RTF_U:
1947 : : {
1948 : 0 : CheckInsNewTblLine();
1949 [ # # ]: 0 : if( nTokenValue )
1950 : 0 : aToken = (sal_Unicode )nTokenValue;
1951 : 0 : pDoc->InsertString( *pPam, aToken );
1952 : : }
1953 : 0 : break;
1954 : :
1955 : : case RTF_USERPROPS:
1956 : 0 : ReadUserProperties(); // #i28758 For now we don't support user properties
1957 : 0 : break;
1958 : :
1959 : : // RTF_SUBENTRYINDEX
1960 : :
1961 : : default:
1962 [ # # # # : 0 : switch( nToken & ~(0xff | RTF_SWGDEFS) )
# # ]
1963 : : {
1964 : : case RTF_DOCFMT:
1965 : 0 : ReadDocControls( nToken );
1966 : 0 : break;
1967 : : case RTF_SECTFMT:
1968 : 0 : ReadSectControls( nToken );
1969 : 0 : break;
1970 : : case RTF_APOCTL:
1971 [ # # ]: 0 : if (nReadFlyDepth < 10)
1972 : : {
1973 : 0 : nReadFlyDepth++;
1974 : 0 : ReadFly( nToken );
1975 : 0 : nReadFlyDepth--;
1976 : : }
1977 : 0 : break;
1978 : :
1979 : : case RTF_BRDRDEF | RTF_TABLEDEF:
1980 : : case RTF_SHADINGDEF | RTF_TABLEDEF:
1981 : : case RTF_TABLEDEF:
1982 : 0 : ReadTable( nToken );
1983 : 0 : break;
1984 : :
1985 : : case RTF_INFO:
1986 : 0 : ReadInfo();
1987 : 0 : break;
1988 : :
1989 : : default:
1990 [ # # # # : 0 : if( USHRT_MAX != nInsTblRow &&
# # ][ # # ]
1991 : 0 : (nInsTblRow > GetOpenBrakets() || IsPardTokenRead() ))
1992 : 0 : nInsTblRow = USHRT_MAX;
1993 : :
1994 : 0 : SvxRTFParser::NextToken( nToken );
1995 : 0 : break;
1996 : : }
1997 : : }
1998 [ # # # # : 0 : if( USHRT_MAX != nInsTblRow &&
# # ][ # # ]
1999 : 0 : (nInsTblRow > GetOpenBrakets() || IsPardTokenRead() ))
2000 : 0 : nInsTblRow = USHRT_MAX;
2001 : 0 : }
2002 : :
2003 : :
2004 : :
2005 : 0 : void SwRTFParser::InsertText()
2006 : : {
2007 : 0 : bContainsPara = false;
2008 : : // dann fuege den String ein, ohne das Attribute am Ende
2009 : : // aufgespannt werden.
2010 : 0 : CheckInsNewTblLine();
2011 : :
2012 [ # # ]: 0 : if(pRedlineInsert)
2013 : 0 : mpRedlineStack->open(*pPam->GetPoint(), *pRedlineInsert);
2014 [ # # ]: 0 : if(pRedlineDelete)
2015 : 0 : mpRedlineStack->open(*pPam->GetPoint(), *pRedlineDelete);
2016 : :
2017 : 0 : pDoc->InsertString( *pPam, aToken );
2018 : :
2019 [ # # ]: 0 : if(pRedlineDelete)
2020 : : {
2021 : 0 : mpRedlineStack->close(*pPam->GetPoint(), pRedlineDelete->eType);
2022 : : }
2023 : :
2024 [ # # ]: 0 : if(pRedlineInsert)
2025 : : {
2026 : 0 : mpRedlineStack->close(*pPam->GetPoint(), pRedlineInsert->eType);
2027 : : }
2028 : :
2029 : :
2030 : 0 : }
2031 : :
2032 : :
2033 : 0 : void SwRTFParser::InsertPara()
2034 : : {
2035 : 0 : bContainsPara = true;
2036 [ # # ]: 0 : CheckInsNewTblLine();
2037 [ # # ]: 0 : pDoc->AppendTxtNode(*pPam->GetPoint());
2038 : :
2039 : : // setze das default Style
2040 [ # # ]: 0 : if( !bStyleTabValid )
2041 [ # # ]: 0 : MakeStyleTab();
2042 : :
2043 : 0 : SwTxtFmtColl* pColl = NULL;
2044 [ # # ]: 0 : std::map<sal_Int32,SwTxtFmtColl*>::iterator iter = aTxtCollTbl.find(0);
2045 : :
2046 [ # # ][ # # ]: 0 : if( iter == aTxtCollTbl.end() )
2047 [ # # ]: 0 : pColl = pDoc->GetTxtCollFromPool( RES_POOLCOLL_STANDARD, false );
2048 : : else
2049 [ # # ]: 0 : pColl = iter->second;
2050 : :
2051 [ # # ]: 0 : pDoc->SetTxtFmtColl( *pPam, pColl );
2052 : :
2053 [ # # ]: 0 : ::SetProgressState( rInput.Tell(), pDoc->GetDocShell() );
2054 : 0 : }
2055 : :
2056 : :
2057 : :
2058 : 0 : void SwRTFParser::MovePos( int bForward )
2059 : : {
2060 [ # # ]: 0 : if( bForward )
2061 : 0 : pPam->Move( fnMoveForward );
2062 : : else
2063 : 0 : pPam->Move( fnMoveBackward );
2064 : 0 : }
2065 : :
2066 : 0 : int SwRTFParser::IsEndPara( SvxNodeIdx* pNd, xub_StrLen nCnt ) const
2067 : : {
2068 : 0 : SwCntntNode *pNode = pDoc->GetNodes()[pNd->GetIdx()]->GetCntntNode();
2069 [ # # ][ # # ]: 0 : return pNode && pNode->Len() == nCnt;
2070 : : }
2071 : :
2072 : 0 : bool SwRTFParser::UncompressableStackEntry(const SvxRTFItemStackType &rSet)
2073 : : const
2074 : : {
2075 : : /*
2076 : : #i21961#
2077 : : Seeing as CHARFMT sets all the properties of the charfmt itself, its not
2078 : : good enough to just see it as a single property from the point of
2079 : : compressing property sets. If bold and charfmt are in a child, and bold is
2080 : : in the parent, removing bold from the child will not result in the same
2081 : : thing, if the charfmt removes bold itself for example
2082 : : */
2083 : 0 : bool bRet = false;
2084 [ # # ]: 0 : if (rSet.GetAttrSet().Count())
2085 : : {
2086 : :
2087 [ # # ]: 0 : if (SFX_ITEM_SET ==
2088 : 0 : rSet.GetAttrSet().GetItemState(RES_TXTATR_CHARFMT, sal_False))
2089 : : {
2090 : 0 : bRet = true;
2091 : : }
2092 : : }
2093 : 0 : return bRet;
2094 : : }
2095 : :
2096 : 0 : void SwRTFParser::SetEndPrevPara( SvxNodeIdx*& rpNodePos, xub_StrLen& rCntPos )
2097 : : {
2098 [ # # ]: 0 : SwNodeIndex aIdx( pPam->GetPoint()->nNode );
2099 [ # # ][ # # ]: 0 : SwCntntNode* pNode = pDoc->GetNodes().GoPrevious( &aIdx );
2100 : : if( !pNode )
2101 : : {
2102 : : OSL_FAIL( "keinen vorherigen ContentNode gefunden" );
2103 : : }
2104 : :
2105 [ # # ][ # # ]: 0 : rpNodePos = new SwNodeIdx( aIdx );
2106 [ # # ][ # # ]: 0 : rCntPos = pNode->Len();
2107 : 0 : }
2108 : :
2109 : 0 : void SwRTFParser::SetAttrInDoc( SvxRTFItemStackType &rSet )
2110 : : {
2111 [ # # ][ # # ]: 0 : sal_uLong nSNd = rSet.GetSttNodeIdx(), nENd = rSet.GetEndNodeIdx();
2112 : 0 : xub_StrLen nSCnt = rSet.GetSttCnt(), nECnt = rSet.GetEndCnt();
2113 : :
2114 [ # # ]: 0 : SwPaM aPam( *pPam->GetPoint() );
2115 : :
2116 : : #if OSL_DEBUG_LEVEL > 0
2117 : : OSL_ENSURE( nSNd <= nENd, "Start groesser als Ende" );
2118 : : SwNode* pDebugNd = pDoc->GetNodes()[ nSNd ];
2119 : : OSL_ENSURE( pDebugNd->IsCntntNode(), "Start kein ContentNode" );
2120 : : pDebugNd = pDoc->GetNodes()[ nENd ];
2121 : : OSL_ENSURE( pDebugNd->IsCntntNode(), "Ende kein ContentNode" );
2122 : : #endif
2123 : :
2124 [ # # ][ # # ]: 0 : SwCntntNode* pCNd = pDoc->GetNodes()[ nSNd ]->GetCntntNode();
2125 [ # # ]: 0 : aPam.GetPoint()->nNode = nSNd;
2126 [ # # ][ # # ]: 0 : aPam.GetPoint()->nContent.Assign( pCNd, nSCnt );
2127 [ # # ]: 0 : aPam.SetMark();
2128 [ # # ]: 0 : if( nENd == nSNd )
2129 [ # # ]: 0 : aPam.GetPoint()->nContent = nECnt;
2130 : : else
2131 : : {
2132 [ # # ]: 0 : aPam.GetPoint()->nNode = nENd;
2133 : 0 : pCNd = aPam.GetCntntNode();
2134 [ # # ][ # # ]: 0 : aPam.GetPoint()->nContent.Assign( pCNd, nECnt );
2135 : : }
2136 : :
2137 : : // setze ueber den Bereich das entsprechende Style
2138 [ # # ]: 0 : if( rSet.StyleNo() )
2139 : : {
2140 : : // setze jetzt das Style
2141 [ # # ]: 0 : if( !bStyleTabValid )
2142 [ # # ]: 0 : MakeStyleTab();
2143 : :
2144 [ # # ]: 0 : std::map<sal_Int32,SwTxtFmtColl*>::iterator iter = aTxtCollTbl.find(rSet.StyleNo());
2145 : :
2146 [ # # ][ # # ]: 0 : if (iter != aTxtCollTbl.end())
2147 [ # # ][ # # ]: 0 : pDoc->SetTxtFmtColl( aPam, iter->second, false );
2148 : : }
2149 : :
2150 : : const SfxPoolItem* pItem;
2151 : : const SfxPoolItem* pCharFmt;
2152 [ # # ]: 0 : if (rSet.GetAttrSet().Count() )
2153 : : {
2154 : :
2155 : : // falls eine Zeichenvorlage im Set steht, deren Attribute
2156 : : // aus dem Set loeschen. Sonst sind diese doppelt, was man ja
2157 : : // nicht will.
2158 [ # # # # ]: 0 : if( SFX_ITEM_SET == rSet.GetAttrSet().GetItemState(
[ # # ]
2159 [ # # ]: 0 : RES_TXTATR_CHARFMT, sal_False, &pCharFmt ) &&
2160 : 0 : ((SwFmtCharFmt*)pCharFmt)->GetCharFmt() )
2161 : : {
2162 : 0 : const String& rName = ((SwFmtCharFmt*)pCharFmt)->GetCharFmt()->GetName();
2163 [ # # ][ # # ]: 0 : for (SvxRTFStyleTbl::iterator it = GetStyleTbl().begin(); it != GetStyleTbl().end(); ++it)
[ # # ][ # # ]
[ # # ]
2164 : : {
2165 [ # # ]: 0 : SvxRTFStyleType* pStyle = it->second;
2166 [ # # ][ # # ]: 0 : if( pStyle->bIsCharFmt && pStyle->sName == rName )
[ # # ][ # # ]
2167 : : {
2168 : : // alle Attribute, die schon vom Style definiert sind, aus dem
2169 : : // akt. AttrSet entfernen
2170 : 0 : SfxItemSet &rAttrSet = rSet.GetAttrSet(),
2171 : 0 : &rStyleSet = pStyle->aAttrSet;
2172 [ # # ]: 0 : SfxItemIter aIter( rAttrSet );
2173 : 0 : sal_uInt16 nWhich = aIter.GetCurItem()->Which();
2174 : 0 : while( sal_True )
2175 : : {
2176 : : const SfxPoolItem* pI;
2177 [ # # ][ # # ]: 0 : if( SFX_ITEM_SET == rStyleSet.GetItemState(
[ # # ]
2178 [ # # ][ # # ]: 0 : nWhich, sal_False, &pI ) && *pI == *aIter.GetCurItem())
2179 [ # # ]: 0 : rAttrSet.ClearItem( nWhich ); // loeschen
2180 : :
2181 [ # # ]: 0 : if( aIter.IsAtEnd() )
2182 : : break;
2183 [ # # ]: 0 : nWhich = aIter.NextItem()->Which();
2184 : : }
2185 [ # # ]: 0 : break;
2186 : : }
2187 : : }
2188 : :
2189 [ # # ]: 0 : pDoc->InsertPoolItem(aPam, *pCharFmt, 0);
2190 [ # # ]: 0 : rSet.GetAttrSet().ClearItem(RES_TXTATR_CHARFMT); //test hack
2191 : : }
2192 [ # # ]: 0 : if (rSet.GetAttrSet().Count())
2193 : : {
2194 : : // dann setze ueber diesen Bereich die Attrbiute
2195 [ # # ]: 0 : SetSwgValues(rSet.GetAttrSet());
2196 : 0 : pDoc->InsertItemSet(aPam, rSet.GetAttrSet(),
2197 [ # # ]: 0 : nsSetAttrMode::SETATTR_DONTCHGNUMRULE);
2198 : : }
2199 : : }
2200 : :
2201 [ # # ]: 0 : if( SFX_ITEM_SET == rSet.GetAttrSet().GetItemState(
2202 [ # # ]: 0 : FN_PARAM_NUM_LEVEL, sal_False, &pItem ))
2203 : : {
2204 : : // dann ueber den Bereich an den Nodes das NodeNum setzen
2205 [ # # ]: 0 : for( sal_uLong n = nSNd; n <= nENd; ++n )
2206 : : {
2207 [ # # ][ # # ]: 0 : SwTxtNode* pTxtNd = pDoc->GetNodes()[ n ]->GetTxtNode();
2208 [ # # ]: 0 : if( pTxtNd )
2209 : : {
2210 [ # # ]: 0 : pTxtNd->SetAttrListLevel((sal_uInt8) ((SfxUInt16Item*)pItem)->GetValue());
2211 : : // Update vom LR-Space abschalten?
2212 : : }
2213 : : }
2214 : : }
2215 : :
2216 [ # # ]: 0 : if( SFX_ITEM_SET == rSet.GetAttrSet().GetItemState(
2217 [ # # ]: 0 : RES_PARATR_NUMRULE, sal_False, &pItem ))
2218 : : {
2219 : : const SwNumRule* pRule = pDoc->FindNumRulePtr(
2220 [ # # ]: 0 : ((SwNumRuleItem*)pItem)->GetValue() );
2221 [ # # ][ # # ]: 0 : if( pRule && ( pRule->IsContinusNum() || !bNewNumList ))
[ # # ][ # # ]
2222 : : {
2223 : : // diese Rule hat keinen Level, also muss die Einrueckung
2224 : : // erhalten bleiben!
2225 : : // dann ueber den Bereich an den Nodes das Flag zuruecksetzen
2226 [ # # ]: 0 : for( sal_uLong n = nSNd; n <= nENd; ++n )
2227 : : {
2228 [ # # ][ # # ]: 0 : SwTxtNode* pTxtNd = pDoc->GetNodes()[ n ]->GetTxtNode();
2229 [ # # ]: 0 : if( pTxtNd )
2230 : : {
2231 : : // Update vom LR-Space abschalten
2232 : 0 : pTxtNd->SetNumLSpace( sal_False );
2233 : : }
2234 : : }
2235 : : }
2236 : : }
2237 : :
2238 : 0 : bool bNoNum = true;
2239 [ # # ][ # # ]: 0 : if (
[ # # ]
2240 [ # # ]: 0 : (SFX_ITEM_SET == rSet.GetAttrSet().GetItemState(RES_PARATR_NUMRULE))
2241 [ # # ]: 0 : || (SFX_ITEM_SET == rSet.GetAttrSet().GetItemState(FN_PARAM_NUM_LEVEL))
2242 : : )
2243 : : {
2244 : 0 : bNoNum = false;
2245 : : }
2246 : :
2247 [ # # ]: 0 : if (bNoNum)
2248 : : {
2249 [ # # ]: 0 : for( sal_uLong n = nSNd; n <= nENd; ++n )
2250 : : {
2251 [ # # ][ # # ]: 0 : SwTxtNode* pTxtNd = pDoc->GetNodes()[ n ]->GetTxtNode();
2252 [ # # ]: 0 : if( pTxtNd )
2253 : : {
2254 : : pTxtNd->SetAttr(
2255 [ # # ][ # # ]: 0 : *GetDfltAttr(RES_PARATR_NUMRULE));
2256 : : }
2257 : : }
2258 [ # # ]: 0 : }
2259 : 0 : }
2260 : :
2261 : 0 : DocPageInformation::DocPageInformation()
2262 : : : maBox( RES_BOX ),
2263 : : mnPaperw(12240), mnPaperh(15840), mnMargl(1800), mnMargr(1800),
2264 : : mnMargt(1440), mnMargb(1440), mnGutter(0), mnPgnStart(1), mbFacingp(false),
2265 : 0 : mbLandscape(false), mbRTLdoc(false)
2266 : : {
2267 : 0 : }
2268 : :
2269 : 0 : SectPageInformation::SectPageInformation(const DocPageInformation &rDoc)
2270 : : : maBox(rDoc.maBox), mpTitlePageHdFt(0), mpPageHdFt(0),
2271 : : mnPgwsxn(rDoc.mnPaperw), mnPghsxn(rDoc.mnPaperh), mnMarglsxn(rDoc.mnMargl),
2272 : : mnMargrsxn(rDoc.mnMargr), mnMargtsxn(rDoc.mnMargt),
2273 : : mnMargbsxn(rDoc.mnMargb), mnGutterxsn(rDoc.mnGutter), mnHeadery(720),
2274 : : mnFootery(720), mnPgnStarts(rDoc.mnPgnStart), mnCols(1), mnColsx(720),
2275 : : mnStextflow(rDoc.mbRTLdoc ? 3 : 0), mnBkc(2), mbLndscpsxn(rDoc.mbLandscape),
2276 : : mbTitlepg(false), mbFacpgsxn(rDoc.mbFacingp), mbRTLsection(rDoc.mbRTLdoc),
2277 [ # # ][ # # ]: 0 : mbPgnrestart(false), mbTitlePageHdFtUsed(false), mbPageHdFtUsed(false)
[ # # ]
2278 : : {
2279 : 0 : };
2280 : :
2281 : 0 : SectPageInformation::SectPageInformation(const SectPageInformation &rSect)
2282 : : : maColumns(rSect.maColumns), maBox(rSect.maBox),
2283 : : maNumType(rSect.maNumType), mpTitlePageHdFt(rSect.mpTitlePageHdFt),
2284 : : mpPageHdFt(rSect.mpPageHdFt), mnPgwsxn(rSect.mnPgwsxn),
2285 : : mnPghsxn(rSect.mnPghsxn), mnMarglsxn(rSect.mnMarglsxn),
2286 : : mnMargrsxn(rSect.mnMargrsxn), mnMargtsxn(rSect.mnMargtsxn),
2287 : : mnMargbsxn(rSect.mnMargbsxn), mnGutterxsn(rSect.mnGutterxsn),
2288 : : mnHeadery(rSect.mnHeadery), mnFootery(rSect.mnFootery),
2289 : : mnPgnStarts(rSect.mnPgnStarts), mnCols(rSect.mnCols),
2290 : : mnColsx(rSect.mnColsx), mnStextflow(rSect.mnStextflow), mnBkc(rSect.mnBkc),
2291 : : mbLndscpsxn(rSect.mbLndscpsxn), mbTitlepg(rSect.mbTitlepg),
2292 : : mbFacpgsxn(rSect.mbFacpgsxn), mbRTLsection(rSect.mbRTLsection),
2293 : : mbPgnrestart(rSect.mbPgnrestart),
2294 : : mbTitlePageHdFtUsed(rSect.mbTitlePageHdFtUsed),
2295 [ # # ][ # # ]: 0 : mbPageHdFtUsed(rSect.mbPageHdFtUsed)
2296 : : {
2297 : 0 : };
2298 : :
2299 : 0 : rtfSection::rtfSection(const SwPosition &rPos,
2300 : : const SectPageInformation &rPageInfo)
2301 : : : maStart(rPos.nNode), maPageInfo(rPageInfo), mpSection(0), mpTitlePage(0),
2302 [ # # ]: 0 : mpPage(0)
2303 : : {
2304 : 0 : }
2305 : :
2306 : 0 : void rtfSections::push_back(const rtfSection &rSect)
2307 : : {
2308 [ # # ][ # # ]: 0 : if (!maSegments.empty() && (maSegments.back().maStart == rSect.maStart))
[ # # ]
2309 : 0 : maSegments.pop_back();
2310 : 0 : maSegments.push_back(rSect);
2311 : 0 : }
2312 : :
2313 : : // lese alle Dokument-Controls ein
2314 : 0 : void SwRTFParser::SetPageInformationAsDefault(const DocPageInformation &rInfo)
2315 : : {
2316 : : //If we are at the beginning of the document then start the document with
2317 : : //a segment with these properties. See #i14982# for this requirement
2318 [ # # ][ # # ]: 0 : rtfSection aSect(*pPam->GetPoint(), SectPageInformation(rInfo));
[ # # ]
2319 [ # # ][ # # ]: 0 : if (maSegments.empty() || (maSegments.back().maStart == aSect.maStart))
[ # # ][ # # ]
2320 [ # # ]: 0 : maSegments.push_back(aSect);
2321 : :
2322 [ # # ][ # # ]: 0 : if (!bSwPageDesc && IsNewDoc())
[ # # ]
2323 : : {
2324 [ # # ]: 0 : SwFmtFrmSize aFrmSize(ATT_FIX_SIZE, rInfo.mnPaperw, rInfo.mnPaperh);
2325 : :
2326 [ # # ]: 0 : SvxLRSpaceItem aLR( static_cast< sal_uInt16 >(rInfo.mnMargl), static_cast< sal_uInt16 >(rInfo.mnMargr), 0, 0, RES_LR_SPACE );
2327 [ # # ]: 0 : SvxULSpaceItem aUL( static_cast< sal_uInt16 >(rInfo.mnMargt), static_cast< sal_uInt16 >(rInfo.mnMargb), RES_UL_SPACE );
2328 : :
2329 : : UseOnPage eUseOn;
2330 [ # # ]: 0 : if (rInfo.mbFacingp)
2331 : 0 : eUseOn = UseOnPage(nsUseOnPage::PD_MIRROR | nsUseOnPage::PD_HEADERSHARE | nsUseOnPage::PD_FOOTERSHARE);
2332 : : else
2333 : 0 : eUseOn = UseOnPage(nsUseOnPage::PD_ALL | nsUseOnPage::PD_HEADERSHARE | nsUseOnPage::PD_FOOTERSHARE);
2334 : :
2335 : 0 : sal_uInt16 nPgStart = static_cast< sal_uInt16 >(rInfo.mnPgnStart);
2336 : :
2337 : : SvxFrameDirectionItem aFrmDir(rInfo.mbRTLdoc ?
2338 [ # # ][ # # ]: 0 : FRMDIR_HORI_RIGHT_TOP : FRMDIR_HORI_LEFT_TOP, RES_FRAMEDIR);
2339 : :
2340 : : // direkt an der Standartseite drehen
2341 [ # # ]: 0 : SwPageDesc& rPg = pDoc->GetPageDesc( 0 );
2342 : 0 : rPg.WriteUseOn( eUseOn );
2343 : :
2344 [ # # ]: 0 : if (rInfo.mbLandscape)
2345 : 0 : rPg.SetLandscape(true);
2346 : :
2347 : 0 : SwFrmFmt &rFmt1 = rPg.GetMaster(), &rFmt2 = rPg.GetLeft();
2348 : :
2349 [ # # ][ # # ]: 0 : rFmt1.SetFmtAttr( aFrmSize ); rFmt2.SetFmtAttr( aFrmSize );
2350 [ # # ][ # # ]: 0 : rFmt1.SetFmtAttr( aLR ); rFmt2.SetFmtAttr( aLR );
2351 [ # # ][ # # ]: 0 : rFmt1.SetFmtAttr( aUL ); rFmt2.SetFmtAttr( aUL );
2352 [ # # ][ # # ]: 0 : rFmt1.SetFmtAttr( aFrmDir ); rFmt2.SetFmtAttr( aFrmDir );
2353 : :
2354 : : // StartNummer der Seiten setzen
2355 [ # # ]: 0 : if (nPgStart != 1)
2356 : : {
2357 [ # # ]: 0 : SwFmtPageDesc aPgDsc( &rPg );
2358 : 0 : aPgDsc.SetNumOffset( nPgStart );
2359 [ # # ][ # # ]: 0 : pDoc->InsertPoolItem( *pPam, aPgDsc, 0 );
2360 [ # # ][ # # ]: 0 : }
[ # # ][ # # ]
2361 [ # # ]: 0 : }
2362 : 0 : }
2363 : :
2364 : 0 : void SwRTFParser::SetBorderLine(SvxBoxItem& rBox, sal_uInt16 nLine)
2365 : : {
2366 : 0 : int bWeiter = true;
2367 : 0 : short nLineThickness = 1;
2368 : 0 : short nPageDistance = 0;
2369 : 0 : sal_uInt8 nCol = 0;
2370 : 0 : short nIdx = 0;
2371 : :
2372 : 0 : int nToken = GetNextToken();
2373 [ # # # # ]: 0 : do {
[ # # ]
2374 [ # # # # : 0 : switch( nToken )
# # # # #
# # # # #
# # # # #
# # # ]
2375 : : {
2376 : : case RTF_BRDRS:
2377 : 0 : nIdx = 1;
2378 : 0 : break;
2379 : :
2380 : : case RTF_BRDRDB:
2381 : 0 : nIdx = 3;
2382 : 0 : break;
2383 : :
2384 : : case RTF_BRDRTRIPLE:
2385 : 0 : nIdx = 10;
2386 : 0 : break;
2387 : :
2388 : : case RTF_BRDRTNTHSG:
2389 : 0 : nIdx = 11;
2390 : 0 : break;
2391 : :
2392 : : case RTF_BRDRTHTNSG:
2393 : 0 : nIdx = 12;
2394 : 0 : break;
2395 : :
2396 : : case RTF_BRDRTNTHTNSG:
2397 : 0 : nIdx = 13;
2398 : 0 : break;
2399 : :
2400 : : case RTF_BRDRTNTHMG:
2401 : 0 : nIdx = 14;
2402 : 0 : break;
2403 : :
2404 : : case RTF_BRDRTHTNMG:
2405 : 0 : nIdx = 15;
2406 : 0 : break;
2407 : :
2408 : : case RTF_BRDRTNTHTNMG:
2409 : 0 : nIdx = 16;
2410 : 0 : break;
2411 : :
2412 : : case RTF_BRDRTNTHLG:
2413 : 0 : nIdx = 17;
2414 : 0 : break;
2415 : :
2416 : : case RTF_BRDRTHTNLG:
2417 : 0 : nIdx = 18;
2418 : 0 : break;
2419 : :
2420 : : case RTF_BRDRTNTHTNLG:
2421 : 0 : nIdx = 19;
2422 : 0 : break;
2423 : :
2424 : : case RTF_BRDRWAVY:
2425 : 0 : nIdx = 20;
2426 : 0 : break;
2427 : :
2428 : : case RTF_BRDRWAVYDB:
2429 : 0 : nIdx = 21;
2430 : 0 : break;
2431 : :
2432 : : case RTF_BRDREMBOSS:
2433 : 0 : nIdx = 24;
2434 : 0 : break;
2435 : :
2436 : : case RTF_BRDRENGRAVE:
2437 : 0 : nIdx = 25;
2438 : 0 : break;
2439 : :
2440 : : case RTF_BRSP:
2441 : 0 : nPageDistance = static_cast< short >(nTokenValue);
2442 : 0 : break;
2443 : :
2444 : : case RTF_BRDRDOT: // SO does not have dashed or dotted lines
2445 : 0 : nIdx = 6;
2446 : 0 : break;
2447 : : case RTF_BRDRDASH:
2448 : 0 : nIdx = 7;
2449 : 0 : break;
2450 : : case RTF_BRDRDASHSM:
2451 : : case RTF_BRDRDASHD:
2452 : : case RTF_BRDRDASHDD:
2453 : : case RTF_BRDRDASHDOTSTR:
2454 : : case RTF_BRDRSH: // shading not supported
2455 : : case RTF_BRDRCF: // colors not supported
2456 : 0 : break;
2457 : :
2458 : : case RTF_BRDRW:
2459 : 0 : nLineThickness = static_cast< short >(nTokenValue);
2460 : 0 : break;
2461 : : default:
2462 : 0 : bWeiter = false;
2463 : 0 : SkipToken(-1);
2464 : 0 : break;
2465 : : }
2466 [ # # ]: 0 : if (bWeiter)
2467 : 0 : nToken = GetNextToken();
2468 : 0 : } while (bWeiter && IsParserWorking());
2469 : :
2470 : 0 : GetLineIndex(rBox, nLineThickness, nPageDistance, nCol, nIdx, nLine, nLine, 0);
2471 : 0 : }
2472 : :
2473 : : // lese alle Dokument-Controls ein
2474 : 0 : void SwRTFParser::ReadDocControls( int nToken )
2475 : : {
2476 : 0 : int bWeiter = true;
2477 : :
2478 [ # # ]: 0 : SwFtnInfo aFtnInfo;
2479 [ # # ]: 0 : SwEndNoteInfo aEndInfo;
2480 : 0 : bool bSetHyph = false;
2481 : :
2482 : 0 : sal_Bool bEndInfoChgd = sal_False, bFtnInfoChgd = sal_False;
2483 : :
2484 [ # # # # ]: 0 : do {
[ # # ]
2485 : 0 : sal_uInt16 nValue = sal_uInt16( nTokenValue );
2486 [ # # # # : 0 : switch( nToken )
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # ]
2487 : : {
2488 : : case RTF_RTLDOC:
2489 : 0 : maPageDefaults.mbRTLdoc = true;
2490 : 0 : break;
2491 : : case RTF_LTRDOC:
2492 : 0 : maPageDefaults.mbRTLdoc = false;
2493 : 0 : break;
2494 : : case RTF_LANDSCAPE:
2495 : 0 : maPageDefaults.mbLandscape = true;
2496 : 0 : break;
2497 : : case RTF_PAPERW:
2498 [ # # ]: 0 : if( 0 < nTokenValue )
2499 : 0 : maPageDefaults.mnPaperw = nTokenValue;
2500 : 0 : break;
2501 : : case RTF_PAPERH:
2502 [ # # ]: 0 : if( 0 < nTokenValue )
2503 : 0 : maPageDefaults.mnPaperh = nTokenValue;
2504 : 0 : break;
2505 : : case RTF_MARGL:
2506 [ # # ]: 0 : if( 0 <= nTokenValue )
2507 : 0 : maPageDefaults.mnMargl = nTokenValue;
2508 : 0 : break;
2509 : : case RTF_MARGR:
2510 [ # # ]: 0 : if( 0 <= nTokenValue )
2511 : 0 : maPageDefaults.mnMargr = nTokenValue;
2512 : 0 : break;
2513 : : case RTF_MARGT:
2514 [ # # ]: 0 : if( 0 <= nTokenValue )
2515 : 0 : maPageDefaults.mnMargt = nTokenValue;
2516 : 0 : break;
2517 : : case RTF_MARGB:
2518 [ # # ]: 0 : if( 0 <= nTokenValue )
2519 : 0 : maPageDefaults.mnMargb = nTokenValue;
2520 : 0 : break;
2521 : : case RTF_FACINGP:
2522 : 0 : maPageDefaults.mbFacingp = true;
2523 : 0 : break;
2524 : : case RTF_PGNSTART:
2525 : 0 : maPageDefaults.mnPgnStart = nTokenValue;
2526 : 0 : break;
2527 : : case RTF_ENDDOC:
2528 : : case RTF_ENDNOTES:
2529 : 0 : aFtnInfo.ePos = FTNPOS_CHAPTER; bFtnInfoChgd = sal_True;
2530 : 0 : break;
2531 : : case RTF_FTNTJ:
2532 : : case RTF_FTNBJ:
2533 : 0 : aFtnInfo.ePos = FTNPOS_PAGE; bFtnInfoChgd = sal_True;
2534 : 0 : break;
2535 : :
2536 : : case RTF_AENDDOC:
2537 : : case RTF_AENDNOTES:
2538 : : case RTF_AFTNTJ:
2539 : : case RTF_AFTNBJ:
2540 : : case RTF_AFTNRESTART:
2541 : : case RTF_AFTNRSTCONT:
2542 : 0 : break; // wir kenn nur am Doc Ende und Doc weite Num.!
2543 : :
2544 : : case RTF_FTNSTART:
2545 [ # # ]: 0 : if( nValue )
2546 : : {
2547 : 0 : aFtnInfo.nFtnOffset = nValue-1;
2548 : 0 : bFtnInfoChgd = sal_True;
2549 : : }
2550 : 0 : break;
2551 : : case RTF_AFTNSTART:
2552 [ # # ]: 0 : if( nValue )
2553 : : {
2554 : 0 : aEndInfo.nFtnOffset = nValue-1;
2555 : 0 : bEndInfoChgd = sal_True;
2556 : : }
2557 : 0 : break;
2558 : : case RTF_FTNRSTPG:
2559 : 0 : aFtnInfo.eNum = FTNNUM_PAGE; bFtnInfoChgd = sal_True;
2560 : 0 : break;
2561 : : case RTF_FTNRESTART:
2562 : 0 : aFtnInfo.eNum = FTNNUM_CHAPTER; bFtnInfoChgd = sal_True;
2563 : 0 : break;
2564 : : case RTF_FTNRSTCONT:
2565 : 0 : aFtnInfo.eNum = FTNNUM_DOC; bFtnInfoChgd = sal_True;
2566 : 0 : break;
2567 : :
2568 : : case RTF_FTNNAR:
2569 : 0 : aFtnInfo.aFmt.SetNumberingType(SVX_NUM_ARABIC); bFtnInfoChgd = sal_True; break;
2570 : : case RTF_FTNNALC:
2571 : 0 : aFtnInfo.aFmt.SetNumberingType(SVX_NUM_CHARS_LOWER_LETTER_N); bFtnInfoChgd = sal_True; break;
2572 : : case RTF_FTNNAUC:
2573 : 0 : aFtnInfo.aFmt.SetNumberingType(SVX_NUM_CHARS_UPPER_LETTER_N); bFtnInfoChgd = sal_True; break;
2574 : : case RTF_FTNNRLC:
2575 : 0 : aFtnInfo.aFmt.SetNumberingType(SVX_NUM_ROMAN_LOWER); bFtnInfoChgd = sal_True; break;
2576 : : case RTF_FTNNRUC:
2577 : 0 : aFtnInfo.aFmt.SetNumberingType(SVX_NUM_ROMAN_UPPER); bFtnInfoChgd = sal_True; break;
2578 : : case RTF_FTNNCHI:
2579 : 0 : aFtnInfo.aFmt.SetNumberingType(SVX_NUM_CHAR_SPECIAL); bFtnInfoChgd = sal_True; break;
2580 : :
2581 : : case RTF_AFTNNAR:
2582 : 0 : aEndInfo.aFmt.SetNumberingType(SVX_NUM_ARABIC); bEndInfoChgd = sal_True; break;
2583 : : case RTF_AFTNNALC:
2584 : 0 : aEndInfo.aFmt.SetNumberingType(SVX_NUM_CHARS_LOWER_LETTER_N);
2585 : 0 : bEndInfoChgd = sal_True;
2586 : 0 : break;
2587 : : case RTF_AFTNNAUC:
2588 : 0 : aEndInfo.aFmt.SetNumberingType(SVX_NUM_CHARS_UPPER_LETTER_N);
2589 : 0 : bEndInfoChgd = sal_True;
2590 : 0 : break;
2591 : : case RTF_AFTNNRLC:
2592 : 0 : aEndInfo.aFmt.SetNumberingType(SVX_NUM_ROMAN_LOWER);
2593 : 0 : bEndInfoChgd = sal_True;
2594 : 0 : break;
2595 : : case RTF_AFTNNRUC:
2596 : 0 : aEndInfo.aFmt.SetNumberingType(SVX_NUM_ROMAN_UPPER);
2597 : 0 : bEndInfoChgd = sal_True;
2598 : 0 : break;
2599 : : case RTF_AFTNNCHI:
2600 : 0 : aEndInfo.aFmt.SetNumberingType(SVX_NUM_CHAR_SPECIAL);
2601 : 0 : bEndInfoChgd = sal_True;
2602 : 0 : break;
2603 : : case RTF_HYPHAUTO:
2604 [ # # ]: 0 : if (nTokenValue)
2605 : 0 : bSetHyph = true;
2606 : : //FOO//
2607 : 0 : break;
2608 : : case RTF_PGBRDRT:
2609 [ # # ]: 0 : SetBorderLine(maPageDefaults.maBox, BOX_LINE_TOP);
2610 : 0 : break;
2611 : :
2612 : : case RTF_PGBRDRB:
2613 [ # # ]: 0 : SetBorderLine(maPageDefaults.maBox, BOX_LINE_BOTTOM);
2614 : 0 : break;
2615 : :
2616 : : case RTF_PGBRDRL:
2617 [ # # ]: 0 : SetBorderLine(maPageDefaults.maBox, BOX_LINE_LEFT);
2618 : 0 : break;
2619 : :
2620 : : case RTF_PGBRDRR:
2621 [ # # ]: 0 : SetBorderLine(maPageDefaults.maBox, BOX_LINE_RIGHT);
2622 : 0 : break;
2623 : :
2624 : : case '{':
2625 : : {
2626 : 0 : short nSkip = 0;
2627 [ # # ][ # # ]: 0 : if( RTF_IGNOREFLAG != GetNextToken() )
2628 : 0 : nSkip = -1;
2629 [ # # ][ # # ]: 0 : else if( RTF_DOCFMT != (( nToken = GetNextToken() )
2630 : : & ~(0xff | RTF_SWGDEFS)) )
2631 : 0 : nSkip = -2;
2632 : : else
2633 : : {
2634 [ # # ]: 0 : SkipGroup(); // erstmal komplett ueberlesen
2635 : : // ueberlese noch die schliessende Klammer
2636 [ # # ]: 0 : GetNextToken();
2637 : : }
2638 [ # # ]: 0 : if( nSkip )
2639 : : {
2640 [ # # ]: 0 : SkipToken( nSkip ); // Ignore wieder zurueck
2641 : 0 : bWeiter = sal_False;
2642 : : }
2643 : : }
2644 : 0 : break;
2645 : :
2646 : : default:
2647 [ # # ][ # # ]: 0 : if( RTF_DOCFMT == (nToken & ~(0xff | RTF_SWGDEFS)) ||
2648 : : RTF_UNKNOWNCONTROL == nToken )
2649 [ # # ]: 0 : SvxRTFParser::NextToken( nToken );
2650 : : else
2651 : 0 : bWeiter = sal_False;
2652 : 0 : break;
2653 : : }
2654 [ # # ]: 0 : if( bWeiter )
2655 [ # # ]: 0 : nToken = GetNextToken();
2656 : 0 : } while( bWeiter && IsParserWorking() );
2657 : :
2658 [ # # ]: 0 : if (IsNewDoc())
2659 : : {
2660 [ # # ]: 0 : if( bEndInfoChgd )
2661 [ # # ]: 0 : pDoc->SetEndNoteInfo( aEndInfo );
2662 [ # # ]: 0 : if( bFtnInfoChgd )
2663 [ # # ]: 0 : pDoc->SetFtnInfo( aFtnInfo );
2664 : : }
2665 : :
2666 [ # # ]: 0 : if (!bSwPageDesc)
2667 : : {
2668 [ # # ]: 0 : SetPageInformationAsDefault(maPageDefaults);
2669 : :
2670 [ # # ]: 0 : MakeStyleTab();
2671 : :
2672 : 0 : SwTxtFmtColl *pColl = NULL;
2673 [ # # ]: 0 : std::map<sal_Int32,SwTxtFmtColl*>::iterator iter = aTxtCollTbl.find(0);
2674 : :
2675 [ # # ][ # # ]: 0 : if (iter == aTxtCollTbl.end())
2676 [ # # ]: 0 : pColl = pDoc->GetTxtCollFromPool(RES_POOLCOLL_STANDARD, false );
2677 : : else
2678 [ # # ]: 0 : pColl = iter->second;
2679 : :
2680 : : OSL_ENSURE(pColl, "impossible to have no standard style");
2681 : :
2682 [ # # ]: 0 : if (pColl)
2683 : : {
2684 [ # # ][ # # ]: 0 : if (
[ # # ][ # # ]
2685 : 0 : IsNewDoc() && bSetHyph &&
2686 : : SFX_ITEM_SET != pColl->GetItemState(RES_PARATR_HYPHENZONE,
2687 [ # # ]: 0 : false)
2688 : : )
2689 : : {
2690 [ # # ][ # # ]: 0 : pColl->SetFmtAttr(SvxHyphenZoneItem(true, RES_PARATR_HYPHENZONE));
[ # # ]
2691 : : }
2692 : :
2693 [ # # ]: 0 : pDoc->SetTxtFmtColl( *pPam, pColl );
2694 : : }
2695 : : }
2696 : :
2697 [ # # ][ # # ]: 0 : SkipToken( -1 );
[ # # ]
2698 : 0 : }
2699 : :
2700 : 0 : void SwRTFParser::MakeStyleTab()
2701 : : {
2702 : : // dann erzeuge aus der SvxStyle-Tabelle die Swg-Collections
2703 [ # # ]: 0 : if( !GetStyleTbl().empty() )
2704 : : {
2705 : 0 : sal_uInt16 nValidOutlineLevels = 0;
2706 [ # # ]: 0 : if( !IsNewDoc() )
2707 : : {
2708 : : // search all outlined collections
2709 : 0 : const SwTxtFmtColls& rColls = *pDoc->GetTxtFmtColls();
2710 [ # # ]: 0 : for( sal_uInt16 n = rColls.size(); n; )
2711 [ # # ]: 0 : if( rColls[ --n ]->IsAssignedToListLevelOfOutlineStyle())
2712 : 0 : nValidOutlineLevels |= 1 << rColls[ n ]->GetAssignedOutlineStyleLevel();//<-end,zhaojianwei
2713 : : }
2714 : :
2715 [ # # ][ # # ]: 0 : for (SvxRTFStyleTbl::iterator it = GetStyleTbl().begin(); it != GetStyleTbl().end(); ++it)
[ # # ][ # # ]
[ # # ]
2716 : : {
2717 [ # # ]: 0 : sal_uInt16 nNo = it->first;
2718 [ # # ]: 0 : SvxRTFStyleType* pStyle = it->second;
2719 [ # # ]: 0 : if( pStyle->bIsCharFmt )
2720 : : {
2721 [ # # ][ # # ]: 0 : if(aCharFmtTbl.find( nNo ) == aCharFmtTbl.end())
[ # # ]
2722 : : // existiert noch nicht, also anlegen
2723 [ # # ]: 0 : MakeCharStyle( nNo, *pStyle );
2724 : : }
2725 [ # # ][ # # ]: 0 : else if( aTxtCollTbl.find( nNo ) == aTxtCollTbl.end() )
[ # # ]
2726 : : {
2727 : : // existiert noch nicht, also anlegen
2728 [ # # ]: 0 : MakeStyle( nNo, *pStyle );
2729 : : }
2730 : :
2731 : : }
2732 : 0 : bStyleTabValid = sal_True;
2733 : : }
2734 : 0 : }
2735 : :
2736 : 0 : sal_Bool lcl_SetFmtCol( SwFmt& rFmt, sal_uInt16 nCols, sal_uInt16 nColSpace,
2737 : : const std::vector<sal_uInt16>& rColumns )
2738 : : {
2739 : 0 : sal_Bool bSet = sal_False;
2740 [ # # ][ # # ]: 0 : if( nCols && USHRT_MAX != nCols )
2741 : : {
2742 [ # # ]: 0 : SwFmtCol aCol;
2743 [ # # ]: 0 : if( USHRT_MAX == nColSpace )
2744 : 0 : nColSpace = 720;
2745 : :
2746 [ # # ]: 0 : aCol.Init( nCols, nColSpace, USHRT_MAX );
2747 [ # # ]: 0 : if( nCols == ( rColumns.size() / 2 ) )
2748 : : {
2749 : 0 : aCol._SetOrtho( sal_False );
2750 : 0 : sal_uInt16 nWishWidth = 0, nHalfPrev = 0;
2751 [ # # ]: 0 : for (sal_uInt16 n = 0, i = 0; static_cast<size_t>(n+1) < rColumns.size(); n += 2, ++i)
2752 : : {
2753 [ # # ]: 0 : SwColumn* pCol = &aCol.GetColumns()[ i ];
2754 : 0 : pCol->SetLeft( nHalfPrev );
2755 [ # # ]: 0 : sal_uInt16 nSp = rColumns[ n+1 ];
2756 : 0 : nHalfPrev = nSp / 2;
2757 : 0 : pCol->SetRight( nSp - nHalfPrev );
2758 [ # # ]: 0 : pCol->SetWishWidth( rColumns[ n ] +
2759 : 0 : pCol->GetLeft() + pCol->GetRight() );
2760 : 0 : nWishWidth = nWishWidth + pCol->GetWishWidth();
2761 : : }
2762 : 0 : aCol.SetWishWidth( nWishWidth );
2763 : : }
2764 [ # # ]: 0 : rFmt.SetFmtAttr( aCol );
2765 [ # # ]: 0 : bSet = sal_True;
2766 : : }
2767 : 0 : return bSet;
2768 : : }
2769 : :
2770 : 0 : void SwRTFParser::DoHairyWriterPageDesc(int nToken)
2771 : : {
2772 : 0 : int bWeiter = sal_True;
2773 [ # # # # ]: 0 : do {
[ # # ]
2774 [ # # ]: 0 : if( '{' == nToken )
2775 : : {
2776 [ # # # ]: 0 : switch( nToken = GetNextToken() )
2777 : : {
2778 : : case RTF_IGNOREFLAG:
2779 [ # # ]: 0 : if( RTF_SECTFMT != (( nToken = GetNextToken() )
2780 : : & ~(0xff | RTF_SWGDEFS)) )
2781 : : {
2782 : 0 : SkipToken( -2 ); // Ignore und Token wieder zurueck
2783 : 0 : bWeiter = sal_False;
2784 : 0 : break;
2785 : : }
2786 : : // kein break, Gruppe ueberspringen
2787 : :
2788 : : case RTF_FOOTER:
2789 : : case RTF_HEADER:
2790 : : case RTF_FOOTERR:
2791 : : case RTF_HEADERR:
2792 : : case RTF_FOOTERL:
2793 : : case RTF_HEADERL:
2794 : : case RTF_FOOTERF:
2795 : : case RTF_HEADERF:
2796 : 0 : SkipGroup(); // erstmal komplett ueberlesen
2797 : : // ueberlese noch die schliessende Klammer
2798 : 0 : GetNextToken();
2799 : 0 : break;
2800 : :
2801 : : default:
2802 : 0 : SkipToken( -1 ); // Ignore wieder zurueck
2803 : 0 : bWeiter = sal_False;
2804 : 0 : break;
2805 : : }
2806 : : }
2807 [ # # ][ # # ]: 0 : else if( RTF_SECTFMT == (nToken & ~(0xff | RTF_SWGDEFS)) ||
2808 : : RTF_UNKNOWNCONTROL == nToken )
2809 : 0 : SvxRTFParser::NextToken( nToken );
2810 : : else
2811 : 0 : bWeiter = sal_False;
2812 [ # # ]: 0 : if( bWeiter )
2813 : 0 : nToken = GetNextToken();
2814 : 0 : } while( bWeiter && IsParserWorking() );
2815 : 0 : SkipToken( -1 ); // letztes Token wieder zurueck
2816 : 0 : return;
2817 : : }
2818 : :
2819 : 0 : void SwRTFParser::ReadSectControls( int nToken )
2820 : : {
2821 : : //this is some hairy stuff to try and retain writer style page descriptors
2822 : : //in rtf, almost certainy a bad idea, but we've inherited it, so here it
2823 : : //stays
2824 [ # # ]: 0 : if (bInPgDscTbl)
2825 : : {
2826 [ # # ]: 0 : DoHairyWriterPageDesc(nToken);
2827 : 0 : return;
2828 : : }
2829 : :
2830 : : OSL_ENSURE(!maSegments.empty(), "suspicious to have a section with no "
2831 : : "page info, though probably legal");
2832 [ # # ]: 0 : if (maSegments.empty())
2833 : : {
2834 : 0 : maSegments.push_back(rtfSection(*pPam->GetPoint(),
2835 [ # # # # ]: 0 : SectPageInformation(maPageDefaults)));
[ # # ][ # # ]
[ # # ]
2836 : : }
2837 : :
2838 [ # # ][ # # ]: 0 : SectPageInformation aNewSection(maSegments.back().maPageInfo);
2839 : :
2840 : 0 : bool bNewSection = false;
2841 : 0 : bool bNewSectionHeader = false;
2842 : 0 : const SwFmtHeader* _pKeepHeader = NULL;
2843 : 0 : const SwFmtFooter* _pKeepFooter = NULL;
2844 : 0 : int bWeiter = true;
2845 : 0 : bool bKeepFooter = false;
2846 [ # # # # ]: 0 : do {
[ # # ]
2847 : 0 : sal_uInt16 nValue = sal_uInt16( nTokenValue );
2848 [ # # # # : 0 : switch( nToken )
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # ]
2849 : : {
2850 : : case RTF_SECT:
2851 : 0 : bNewSection = true;
2852 : 0 : bForceNewTable = true;
2853 : 0 : break;
2854 : : case RTF_SECTD: {
2855 : : //Reset to page defaults
2856 : 0 : SwPageDesc* oldPageDesc=aNewSection.mpPageHdFt;
2857 [ # # ][ # # ]: 0 : aNewSection = SectPageInformation(maPageDefaults);
[ # # ]
2858 : 0 : aNewSection.mpPageHdFt=oldPageDesc;
2859 : 0 : _pKeepHeader = NULL;
2860 : 0 : _pKeepFooter = NULL;
2861 : 0 : } break;
2862 : : case RTF_PGWSXN:
2863 [ # # ]: 0 : if (0 < nTokenValue)
2864 : 0 : aNewSection.mnPgwsxn = nTokenValue;
2865 : 0 : break;
2866 : : case RTF_PGHSXN:
2867 [ # # ]: 0 : if (0 < nTokenValue)
2868 : 0 : aNewSection.mnPghsxn = nTokenValue;
2869 : 0 : break;
2870 : : case RTF_MARGLSXN:
2871 [ # # ]: 0 : if (0 <= nTokenValue)
2872 : 0 : aNewSection.mnMarglsxn = nTokenValue;
2873 : 0 : break;
2874 : : case RTF_MARGRSXN:
2875 [ # # ]: 0 : if (0 <= nTokenValue)
2876 : 0 : aNewSection.mnMargrsxn = nTokenValue;
2877 : 0 : break;
2878 : : case RTF_MARGTSXN:
2879 [ # # ]: 0 : if (0 <= nTokenValue)
2880 : 0 : aNewSection.mnMargtsxn = nTokenValue;
2881 : 0 : break;
2882 : : case RTF_MARGBSXN:
2883 [ # # ]: 0 : if (0 <= nTokenValue)
2884 : 0 : aNewSection.mnMargbsxn = nTokenValue;
2885 : 0 : break;
2886 : : case RTF_FACPGSXN:
2887 : 0 : aNewSection.mbFacpgsxn = true;
2888 : 0 : break;
2889 : : case RTF_HEADERY:
2890 : 0 : aNewSection.mnHeadery = nTokenValue;
2891 : 0 : break;
2892 : : case RTF_FOOTERY:
2893 : 0 : aNewSection.mnFootery = nTokenValue;
2894 : 0 : break;
2895 : : case RTF_LNDSCPSXN:
2896 : 0 : aNewSection.mbLndscpsxn = true;
2897 : 0 : break;
2898 : : case RTF_PGNSTARTS:
2899 : 0 : aNewSection.mnPgnStarts = nTokenValue;
2900 : 0 : break;
2901 : : case RTF_PGNDEC:
2902 : 0 : aNewSection.maNumType.SetNumberingType(SVX_NUM_ARABIC);
2903 : 0 : break;
2904 : : case RTF_PGNUCRM:
2905 : 0 : aNewSection.maNumType.SetNumberingType(SVX_NUM_ROMAN_UPPER);
2906 : 0 : break;
2907 : : case RTF_PGNLCRM:
2908 : 0 : aNewSection.maNumType.SetNumberingType(SVX_NUM_ROMAN_LOWER);
2909 : 0 : break;
2910 : : case RTF_PGNUCLTR:
2911 : : aNewSection.maNumType.SetNumberingType(
2912 : 0 : SVX_NUM_CHARS_UPPER_LETTER_N);
2913 : 0 : break;
2914 : : case RTF_PGNLCLTR:
2915 : : aNewSection.maNumType.SetNumberingType(
2916 : 0 : SVX_NUM_CHARS_LOWER_LETTER_N);
2917 : 0 : break;
2918 : : case RTF_SBKNONE:
2919 : 0 : aNewSection.mnBkc = 0;
2920 : 0 : break;
2921 : : case RTF_SBKCOL:
2922 : 0 : aNewSection.mnBkc = 1;
2923 : 0 : break;
2924 : : case RTF_PGBRDRT:
2925 [ # # ]: 0 : SetBorderLine(aNewSection.maBox, BOX_LINE_TOP);
2926 : 0 : break;
2927 : :
2928 : : case RTF_PGBRDRB:
2929 [ # # ]: 0 : SetBorderLine(aNewSection.maBox, BOX_LINE_BOTTOM);
2930 : 0 : break;
2931 : :
2932 : : case RTF_PGBRDRL:
2933 [ # # ]: 0 : SetBorderLine(aNewSection.maBox, BOX_LINE_LEFT);
2934 : 0 : break;
2935 : :
2936 : : case RTF_PGBRDRR:
2937 [ # # ]: 0 : SetBorderLine(aNewSection.maBox, BOX_LINE_RIGHT);
2938 : 0 : break;
2939 : :
2940 : : case RTF_PGBRDROPT:
2941 : : case RTF_ENDNHERE:
2942 : : case RTF_BINFSXN:
2943 : : case RTF_BINSXN:
2944 : : case RTF_SBKPAGE:
2945 : : case RTF_SBKEVEN:
2946 : : case RTF_SBKODD:
2947 : : case RTF_LINEBETCOL:
2948 : : case RTF_LINEMOD:
2949 : : case RTF_LINEX:
2950 : : case RTF_LINESTARTS:
2951 : : case RTF_LINERESTART:
2952 : : case RTF_LINEPAGE:
2953 : : case RTF_LINECONT:
2954 : : case RTF_GUTTERSXN:
2955 : : case RTF_PGNCONT:
2956 : : case RTF_PGNRESTART:
2957 : : case RTF_PGNX:
2958 : : case RTF_PGNY:
2959 : : case RTF_VERTALT:
2960 : : case RTF_VERTALB:
2961 : : case RTF_VERTALC:
2962 : : case RTF_VERTALJ:
2963 : 0 : break;
2964 : : case RTF_TITLEPG:
2965 : 0 : aNewSection.mbTitlepg = true;
2966 : 0 : break;
2967 : : case RTF_HEADER:
2968 : : case RTF_HEADERL:
2969 : : case RTF_HEADERR:
2970 [ # # ]: 0 : if (aNewSection.mpPageHdFt!=NULL)
2971 : : {
2972 : 0 : _pKeepHeader = NULL;
2973 : 0 : bKeepFooter = true; // #i82008
2974 [ # # ]: 0 : _pKeepFooter = &aNewSection.mpPageHdFt->GetMaster().GetFooter();
2975 : : }
2976 : : case RTF_FOOTER:
2977 : : case RTF_FOOTERL:
2978 : : case RTF_FOOTERR:
2979 [ # # ][ # # ]: 0 : if (aNewSection.mpPageHdFt!=NULL && !bKeepFooter )
2980 : : {
2981 : 0 : _pKeepFooter = NULL;
2982 [ # # ]: 0 : _pKeepHeader = &aNewSection.mpPageHdFt->GetMaster().GetHeader();
2983 : : }
2984 : 0 : bKeepFooter = false;
2985 [ # # ]: 0 : if (!bNewSectionHeader) { // If a header is redefined in a section
2986 : 0 : bNewSectionHeader=true; // a new header must be created.
2987 : 0 : aNewSection.mpPageHdFt=NULL;
2988 : : }
2989 [ # # ]: 0 : if (!aNewSection.mpPageHdFt)
2990 : : {
2991 [ # # ]: 0 : String aName(RTL_CONSTASCII_USTRINGPARAM("rtfHdFt"));
2992 [ # # ][ # # ]: 0 : aName += String::CreateFromInt32(maSegments.size());
[ # # ]
2993 [ # # ]: 0 : sal_uInt16 nPageNo = pDoc->MakePageDesc(aName);
2994 [ # # ]: 0 : aNewSection.mpPageHdFt = &pDoc->GetPageDesc(nPageNo);
2995 : 0 : aNewSection.mbPageHdFtUsed = true;
2996 [ # # ][ # # ]: 0 : maSegments.maDummyPageNos.push_back(nPageNo);
2997 : : }
2998 [ # # ]: 0 : ReadHeaderFooter(nToken, aNewSection.mpPageHdFt);
2999 [ # # ][ # # ]: 0 : if (_pKeepHeader) aNewSection.mpPageHdFt->GetMaster().SetFmtAttr(*_pKeepHeader);
3000 [ # # ][ # # ]: 0 : if (_pKeepFooter) aNewSection.mpPageHdFt->GetMaster().SetFmtAttr(*_pKeepFooter);
3001 : 0 : break;
3002 : : case RTF_FOOTERF:
3003 : : case RTF_HEADERF:
3004 [ # # ]: 0 : if (!aNewSection.mpTitlePageHdFt)
3005 : : {
3006 [ # # ]: 0 : String aTitle(RTL_CONSTASCII_USTRINGPARAM("rtfTitleHdFt"));
3007 [ # # ][ # # ]: 0 : aTitle += String::CreateFromInt32(maSegments.size());
[ # # ]
3008 [ # # ]: 0 : sal_uInt16 nPageNo = pDoc->MakePageDesc(aTitle);
3009 [ # # ]: 0 : aNewSection.mpTitlePageHdFt = &pDoc->GetPageDesc(nPageNo);
3010 : 0 : aNewSection.mbTitlePageHdFtUsed = true;
3011 [ # # ][ # # ]: 0 : maSegments.maDummyPageNos.push_back(nPageNo);
3012 : : }
3013 [ # # ]: 0 : ReadHeaderFooter(nToken, aNewSection.mpTitlePageHdFt);
3014 : 0 : break;
3015 : : case RTF_COLS:
3016 : 0 : aNewSection.mnCols = nTokenValue;
3017 : 0 : break;
3018 : : case RTF_COLSX:
3019 : 0 : aNewSection.mnColsx = nTokenValue;
3020 : 0 : break;
3021 : : case RTF_COLNO:
3022 : : {
3023 : : // next token must be either colw or colsr
3024 : 0 : unsigned long nAktCol = nValue;
3025 : 0 : long nWidth = 0, nSpace = 0;
3026 [ # # ]: 0 : int nColToken = GetNextToken();
3027 [ # # ]: 0 : if (RTF_COLW == nColToken)
3028 : : {
3029 : : // next token could be colsr (but not required)
3030 : 0 : nWidth = nTokenValue;
3031 [ # # ][ # # ]: 0 : if( RTF_COLSR == GetNextToken() )
3032 : 0 : nSpace = nTokenValue;
3033 : : else
3034 [ # # ]: 0 : SkipToken( -1 ); // put back token
3035 : : }
3036 [ # # ]: 0 : else if (RTF_COLSR == nColToken)
3037 : : {
3038 : : // next token must be colw (what sense should it make to have colsr only?!)
3039 : 0 : nSpace = nTokenValue;
3040 [ # # ][ # # ]: 0 : if( RTF_COLW == GetNextToken() )
3041 : 0 : nWidth = nTokenValue;
3042 : : else
3043 : : // what should we do if an isolated colsr without colw is found? Doesn't make sense!
3044 [ # # ]: 0 : SkipToken( -1 ); // put back token
3045 : : }
3046 : : else
3047 : : break;
3048 : :
3049 [ # # ]: 0 : if (--nAktCol == (aNewSection.maColumns.size() / 2))
3050 : : {
3051 [ # # ]: 0 : aNewSection.maColumns.push_back(nWidth);
3052 [ # # ]: 0 : aNewSection.maColumns.push_back(nSpace);
3053 : : }
3054 : : }
3055 : 0 : break;
3056 : : case RTF_STEXTFLOW:
3057 : 0 : aNewSection.mnStextflow = nTokenValue;
3058 : 0 : break;
3059 : : case RTF_RTLSECT:
3060 : 0 : aNewSection.mbRTLsection = true;
3061 : 0 : break;
3062 : : case RTF_LTRSECT:
3063 : 0 : aNewSection.mbRTLsection = false;
3064 : 0 : break;
3065 : : case '{':
3066 : : {
3067 : 0 : short nSkip = 0;
3068 [ # # ][ # # ]: 0 : if( RTF_IGNOREFLAG != ( nToken = GetNextToken() ))
3069 : 0 : nSkip = -1;
3070 [ # # ][ # # ]: 0 : else if( RTF_SECTFMT != (( nToken = GetNextToken() )
[ # # ][ # # ]
3071 : : & ~(0xff | RTF_SWGDEFS)) &&
3072 : : ( RTF_DOCFMT != ( nToken & ~(0xff | RTF_SWGDEFS))) )
3073 : 0 : nSkip = -2;
3074 : : else
3075 : : {
3076 : : // erstmal komplett ueberlesen
3077 [ # # ]: 0 : SkipGroup();
3078 : : // ueberlese noch die schliessende Klammer
3079 [ # # ]: 0 : GetNextToken();
3080 : : }
3081 [ # # ]: 0 : if (nSkip)
3082 : : {
3083 : : bWeiter = ((-1 == nSkip) &&
3084 : : (
3085 : : RTF_FOOTER == nToken || RTF_HEADER == nToken ||
3086 : : RTF_FOOTERR == nToken || RTF_HEADERR == nToken ||
3087 : : RTF_FOOTERL == nToken || RTF_HEADERL == nToken ||
3088 : : RTF_FOOTERF == nToken || RTF_HEADERF == nToken
3089 [ # # ][ # # ]: 0 : ));
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
3090 [ # # ]: 0 : SkipToken (nSkip); // Ignore wieder zurueck
3091 : : }
3092 : : }
3093 : 0 : break;
3094 : : case RTF_PAPERW:
3095 : : case RTF_PAPERH:
3096 : : case RTF_MARGL:
3097 : : case RTF_MARGR:
3098 : : case RTF_MARGT:
3099 : : case RTF_MARGB:
3100 : : case RTF_FACINGP:
3101 : : OSL_ENSURE(!this, "why are these tokens found in this section?");
3102 [ # # ]: 0 : ReadDocControls( nToken );
3103 : 0 : break;
3104 : : default:
3105 [ # # ]: 0 : if (RTF_DOCFMT == (nToken & ~(0xff | RTF_SWGDEFS)))
3106 [ # # ]: 0 : ReadDocControls( nToken );
3107 [ # # ][ # # ]: 0 : else if (RTF_SECTFMT == (nToken & ~(0xff | RTF_SWGDEFS)) ||
3108 : : RTF_UNKNOWNCONTROL == nToken)
3109 : : {
3110 [ # # ]: 0 : SvxRTFParser::NextToken(nToken);
3111 : : }
3112 : : else
3113 : 0 : bWeiter = false;
3114 : 0 : break;
3115 : : }
3116 : :
3117 [ # # ]: 0 : if (bWeiter)
3118 [ # # ]: 0 : nToken = GetNextToken();
3119 : 0 : } while (bWeiter && IsParserWorking());
3120 : :
3121 [ # # ][ # # ]: 0 : if (bNewSection || maSegments.empty())
[ # # ]
3122 : : {
3123 [ # # ]: 0 : AttrGroupEnd();
3124 [ # # ][ # # ]: 0 : if(!bContainsPara && !bContainsTablePara) // bContainsTablePara is set in rtftbl.cxx
3125 [ # # ]: 0 : pDoc->AppendTxtNode(*pPam->GetPoint());
3126 : 0 : bContainsPara = false;
3127 : 0 : bContainsTablePara = false;
3128 [ # # ][ # # ]: 0 : maSegments.push_back(rtfSection(*pPam->GetPoint(), aNewSection));
[ # # ]
3129 : : }
3130 : : else //modifying/replacing the current section
3131 : : {
3132 [ # # ][ # # ]: 0 : SwPaM aPamStart(maSegments.back().maStart);
3133 [ # # ]: 0 : maSegments.pop_back();
3134 [ # # ][ # # ]: 0 : maSegments.push_back(rtfSection(*aPamStart.GetPoint(), aNewSection));
[ # # ][ # # ]
3135 : : }
3136 : :
3137 [ # # ][ # # ]: 0 : SkipToken(-1);
3138 : : }
3139 : :
3140 : 0 : void SwRTFParser::EnterEnvironment()
3141 : : {
3142 : 0 : }
3143 : :
3144 : :
3145 : 0 : void SwRTFParser::LeaveEnvironment()
3146 : : {
3147 [ # # ]: 0 : if(pRedlineDelete)
3148 : : {
3149 [ # # ]: 0 : delete pRedlineDelete;
3150 : 0 : pRedlineDelete = 0;
3151 : : }
3152 : :
3153 [ # # ]: 0 : if(pRedlineInsert)
3154 : : {
3155 [ # # ]: 0 : delete pRedlineInsert;
3156 : 0 : pRedlineInsert = 0;
3157 : : }
3158 : 0 : }
3159 : :
3160 : 0 : void SwRTFParser::SkipPageDescTbl()
3161 : : {
3162 : : // I have to use this glorified SkipGroup because the
3163 : : // SvParser SkipGroup uses nNextCh which is not set correctly <groan>
3164 : 0 : int nNumOpenBrakets = 1;
3165 : :
3166 [ # # ][ # # ]: 0 : while( nNumOpenBrakets && IsParserWorking() )
[ # # ]
3167 : : {
3168 [ # # # ]: 0 : switch( GetNextToken() )
3169 : : {
3170 : : case '}':
3171 : : {
3172 : 0 : --nNumOpenBrakets;
3173 : : }
3174 : 0 : break;
3175 : :
3176 : : case '{':
3177 : : {
3178 : 0 : nNumOpenBrakets++;
3179 : : }
3180 : 0 : break;
3181 : : }
3182 : : }
3183 : :
3184 : 0 : SkipToken( -1 );
3185 : 0 : }
3186 : :
3187 : :
3188 : : #define SETPAGEDESC_DEFAULTS() \
3189 : : do {\
3190 : : aSz.SetWidth( a4.Width() ); aSz.SetHeight( a4.Height() );\
3191 : : aLR.SetLeft( 0 ); aLR.SetRight( 0 ); \
3192 : : aUL.SetLower( 0 ); aUL.SetUpper( 0 ); \
3193 : : aHLR.SetLeft( 0 ); aHLR.SetRight( 0 ); \
3194 : : aHUL.SetLower( 0 ); aHUL.SetUpper( 0 ); \
3195 : : aFLR.SetLeft( 0 ); aFLR.SetRight( 0 ); \
3196 : : aFUL.SetLower( 0 ); aFUL.SetUpper( 0 ); \
3197 : : nCols = USHRT_MAX; nColSpace = USHRT_MAX; nAktCol = 0; \
3198 : : aFSz.SetHeightSizeType( ATT_MIN_SIZE ); aFSz.SetHeight( 0 ); \
3199 : : aHSz.SetHeightSizeType( ATT_MIN_SIZE ); aHSz.SetHeight( 0 ); \
3200 : : } while (0)
3201 : :
3202 : 0 : void SwRTFParser::ReadPageDescTbl()
3203 : : {
3204 : : // dann erzeuge aus der SvxStyle-Tabelle die Swg-Collections, damit
3205 : : // diese auch in den Headers/Footer benutzt werden koennen!
3206 [ # # ]: 0 : MakeStyleTab();
3207 : : // das default-Style schon gleich am ersten Node setzen
3208 : 0 : SwTxtFmtColl* pColl = NULL;
3209 [ # # ]: 0 : std::map<sal_Int32,SwTxtFmtColl*>::iterator iter = aTxtCollTbl.find( 0 );
3210 : :
3211 [ # # ][ # # ]: 0 : if( iter == aTxtCollTbl.end() )
3212 [ # # ]: 0 : pColl = pDoc->GetTxtCollFromPool( RES_POOLCOLL_STANDARD, false );
3213 : : else
3214 [ # # ]: 0 : pColl = iter->second;
3215 : :
3216 [ # # ]: 0 : pDoc->SetTxtFmtColl( *pPam, pColl );
3217 : :
3218 : 0 : int nToken, bSaveChkStyleAttr = IsChkStyleAttr();
3219 : 0 : int nNumOpenBrakets = 1; // die erste wurde schon vorher erkannt !!
3220 : :
3221 : 0 : SetChkStyleAttr(sal_False); // Attribute nicht gegen die Styles checken
3222 : :
3223 : 0 : bInPgDscTbl = true;
3224 : 0 : sal_uInt16 nPos = 0;
3225 : 0 : SwPageDesc* pPg = 0;
3226 : 0 : SwFrmFmt* pPgFmt = 0;
3227 : :
3228 [ # # ][ # # ]: 0 : SvxULSpaceItem aUL( RES_UL_SPACE ), aHUL( RES_UL_SPACE ), aFUL( RES_UL_SPACE );
[ # # ]
3229 [ # # ][ # # ]: 0 : SvxLRSpaceItem aLR( RES_LR_SPACE ), aHLR( RES_LR_SPACE ), aFLR( RES_LR_SPACE );
[ # # ]
3230 [ # # ]: 0 : Size a4 = SvxPaperInfo::GetPaperSize(PAPER_A4);
3231 [ # # ]: 0 : SwFmtFrmSize aSz( ATT_FIX_SIZE, a4.Width(), a4.Height() ); // DIN A4 defaulten
3232 [ # # ][ # # ]: 0 : SwFmtFrmSize aFSz( ATT_MIN_SIZE ), aHSz( ATT_MIN_SIZE );
3233 : :
3234 [ # # ]: 0 : SvxFrameDirectionItem aFrmDir(FRMDIR_HORI_LEFT_TOP, RES_FRAMEDIR);
3235 : :
3236 : 0 : sal_uInt16 nCols = USHRT_MAX, nColSpace = USHRT_MAX, nAktCol = 0;
3237 [ # # ]: 0 : std::vector<sal_uInt16> aColumns;
3238 [ # # ]: 0 : ::std::map< const SwPageDesc*, sal_uInt16 > aFollowMap; //store index of following page descriptors
3239 : :
3240 [ # # ][ # # ]: 0 : while( nNumOpenBrakets && IsParserWorking() )
[ # # ]
3241 : : {
3242 [ # # ][ # # : 0 : switch( nToken = GetNextToken() )
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # ]
3243 : : {
3244 : : case '{':
3245 : 0 : ++nNumOpenBrakets;
3246 : 0 : break;
3247 : : case '}':
3248 [ # # ]: 0 : if (1 == --nNumOpenBrakets)
3249 : : {
3250 : : OSL_ENSURE(pPgFmt && pPg, "Serious problem here");
3251 [ # # ][ # # ]: 0 : if (pPgFmt && pPg)
3252 : : {
3253 : : // PageDesc ist fertig, setze am Doc
3254 [ # # ]: 0 : pPgFmt->SetFmtAttr(aFrmDir);
3255 [ # # ]: 0 : pPgFmt->SetFmtAttr(aLR);
3256 [ # # ]: 0 : pPgFmt->SetFmtAttr(aUL);
3257 [ # # ]: 0 : pPgFmt->SetFmtAttr(aSz);
3258 [ # # ]: 0 : ::lcl_SetFmtCol(*pPgFmt, nCols, nColSpace, aColumns);
3259 [ # # ][ # # ]: 0 : if (pPgFmt->GetHeader().GetHeaderFmt())
3260 : : {
3261 : : SwFrmFmt* pHFmt =
3262 [ # # ]: 0 : (SwFrmFmt*)pPgFmt->GetHeader().GetHeaderFmt();
3263 [ # # ]: 0 : pHFmt->SetFmtAttr(aHUL);
3264 [ # # ]: 0 : pHFmt->SetFmtAttr(aHLR);
3265 [ # # ]: 0 : pHFmt->SetFmtAttr(aHSz);
3266 : : }
3267 [ # # ][ # # ]: 0 : if (pPgFmt->GetFooter().GetFooterFmt())
3268 : : {
3269 : : SwFrmFmt* pFFmt =
3270 [ # # ]: 0 : (SwFrmFmt*)pPgFmt->GetFooter().GetFooterFmt();
3271 [ # # ]: 0 : pFFmt->SetFmtAttr(aHUL);
3272 [ # # ]: 0 : pFFmt->SetFmtAttr(aHLR);
3273 [ # # ]: 0 : pFFmt->SetFmtAttr(aHSz);
3274 : : }
3275 [ # # ]: 0 : if( nPos < pDoc->GetPageDescCnt() )
3276 [ # # ]: 0 : pDoc->ChgPageDesc(nPos++, *pPg);
3277 : : }
3278 : : }
3279 : 0 : break;
3280 : : case RTF_PGDSC:
3281 [ # # ]: 0 : if (nPos) // kein && wg MAC
3282 : : {
3283 : 0 : if (nPos != pDoc->MakePageDesc(
3284 [ # # ][ # # ]: 0 : String::CreateFromInt32(nTokenValue)))
[ # # ]
3285 : : {
3286 : : OSL_FAIL( "PageDesc an falscher Position" );
3287 : : }
3288 : : }
3289 [ # # ]: 0 : pPg = &pDoc->GetPageDesc(nPos);
3290 : 0 : pPg->SetLandscape( sal_False );
3291 : 0 : pPgFmt = &pPg->GetMaster();
3292 : :
3293 : 0 : SETPAGEDESC_DEFAULTS();
3294 : 0 : break;
3295 : :
3296 : : case RTF_PGDSCUSE:
3297 : 0 : pPg->WriteUseOn( (UseOnPage)nTokenValue );
3298 : 0 : break;
3299 : :
3300 : : case RTF_PGDSCNXT:
3301 : : // store index of follow in map; will be fixed up later
3302 [ # # ]: 0 : if( nTokenValue )
3303 [ # # ][ # # ]: 0 : aFollowMap.insert( ::std::pair<const SwPageDesc*, sal_uInt16>( pPg, nTokenValue ));
3304 : : else
3305 [ # # ]: 0 : pPg->SetFollow( &pDoc->GetPageDesc( 0 ) );
3306 : 0 : break;
3307 : :
3308 : : case RTF_FORMULA: /* Zeichen "\|" !!! */
3309 [ # # ]: 0 : pPgFmt->SetFmtAttr( aLR );
3310 [ # # ]: 0 : pPgFmt->SetFmtAttr( aUL );
3311 [ # # ]: 0 : pPgFmt->SetFmtAttr( aSz );
3312 [ # # ]: 0 : ::lcl_SetFmtCol( *pPgFmt, nCols, nColSpace, aColumns );
3313 [ # # ][ # # ]: 0 : if( pPgFmt->GetHeader().GetHeaderFmt() )
3314 : : {
3315 [ # # ]: 0 : SwFrmFmt* pHFmt = (SwFrmFmt*)pPgFmt->GetHeader().GetHeaderFmt();
3316 [ # # ]: 0 : pHFmt->SetFmtAttr( aHUL );
3317 [ # # ]: 0 : pHFmt->SetFmtAttr( aHLR );
3318 [ # # ]: 0 : pHFmt->SetFmtAttr( aHSz );
3319 : : }
3320 [ # # ][ # # ]: 0 : if( pPgFmt->GetFooter().GetFooterFmt() )
3321 : : {
3322 [ # # ]: 0 : SwFrmFmt* pFFmt = (SwFrmFmt*)pPgFmt->GetFooter().GetFooterFmt();
3323 [ # # ]: 0 : pFFmt->SetFmtAttr( aHUL );
3324 [ # # ]: 0 : pFFmt->SetFmtAttr( aHLR );
3325 [ # # ]: 0 : pFFmt->SetFmtAttr( aHSz );
3326 : : }
3327 : :
3328 : 0 : pPgFmt = &pPg->GetLeft();
3329 : :
3330 : 0 : SETPAGEDESC_DEFAULTS();
3331 : 0 : break;
3332 : :
3333 : : case RTF_RTLSECT:
3334 : 0 : aFrmDir.SetValue(FRMDIR_HORI_RIGHT_TOP);
3335 : 0 : break;
3336 : :
3337 : : case RTF_LTRSECT:
3338 : 0 : aFrmDir.SetValue(FRMDIR_HORI_LEFT_TOP);
3339 : 0 : break;
3340 : :
3341 : : // alt: LI/RI/SA/SB, neu: MARG?SXN
3342 : : case RTF_MARGLSXN:
3343 : 0 : case RTF_LI: aLR.SetLeft( (sal_uInt16)nTokenValue ); break;
3344 : : case RTF_MARGRSXN:
3345 : 0 : case RTF_RI: aLR.SetRight( (sal_uInt16)nTokenValue ); break;
3346 : : case RTF_MARGTSXN:
3347 : 0 : case RTF_SA: aUL.SetUpper( (sal_uInt16)nTokenValue ); break;
3348 : : case RTF_MARGBSXN:
3349 : 0 : case RTF_SB: aUL.SetLower( (sal_uInt16)nTokenValue ); break;
3350 : 0 : case RTF_PGWSXN: aSz.SetWidth( nTokenValue ); break;
3351 : 0 : case RTF_PGHSXN: aSz.SetHeight( nTokenValue ); break;
3352 : :
3353 : 0 : case RTF_HEADERY: aHUL.SetUpper( (sal_uInt16)nTokenValue ); break;
3354 : 0 : case RTF_HEADER_YB: aHUL.SetLower( (sal_uInt16)nTokenValue ); break;
3355 : 0 : case RTF_HEADER_XL: aHLR.SetLeft( (sal_uInt16)nTokenValue ); break;
3356 : 0 : case RTF_HEADER_XR: aHLR.SetRight( (sal_uInt16)nTokenValue ); break;
3357 : 0 : case RTF_FOOTERY: aFUL.SetLower( (sal_uInt16)nTokenValue ); break;
3358 : 0 : case RTF_FOOTER_YT: aFUL.SetUpper( (sal_uInt16)nTokenValue ); break;
3359 : 0 : case RTF_FOOTER_XL: aFLR.SetLeft( (sal_uInt16)nTokenValue ); break;
3360 : 0 : case RTF_FOOTER_XR: aFLR.SetRight( (sal_uInt16)nTokenValue ); break;
3361 : :
3362 : : case RTF_HEADER_YH:
3363 [ # # ]: 0 : if( 0 > nTokenValue )
3364 : : {
3365 : 0 : aHSz.SetHeightSizeType( ATT_FIX_SIZE );
3366 : 0 : nTokenValue = -nTokenValue;
3367 : : }
3368 : 0 : aHSz.SetHeight( (sal_uInt16)nTokenValue );
3369 : 0 : break;
3370 : :
3371 : : case RTF_FOOTER_YH:
3372 [ # # ]: 0 : if( 0 > nTokenValue )
3373 : : {
3374 : 0 : aFSz.SetHeightSizeType( ATT_FIX_SIZE );
3375 : 0 : nTokenValue = -nTokenValue;
3376 : : }
3377 : 0 : aFSz.SetHeight( (sal_uInt16)nTokenValue );
3378 : 0 : break;
3379 : :
3380 : :
3381 : 0 : case RTF_LNDSCPSXN: pPg->SetLandscape( sal_True ); break;
3382 : :
3383 : 0 : case RTF_COLS: nCols = (sal_uInt16)nTokenValue; break;
3384 : 0 : case RTF_COLSX: nColSpace = (sal_uInt16)nTokenValue; break;
3385 : :
3386 : : case RTF_COLNO:
3387 : 0 : nAktCol = (sal_uInt16)nTokenValue;
3388 [ # # ][ # # ]: 0 : if( RTF_COLW == GetNextToken() )
3389 : : {
3390 : 0 : sal_uInt16 nWidth = sal_uInt16( nTokenValue ), nSpace = 0;
3391 [ # # ][ # # ]: 0 : if( RTF_COLSR == GetNextToken() )
3392 : 0 : nSpace = sal_uInt16( nTokenValue );
3393 : : else
3394 [ # # ]: 0 : SkipToken( -1 ); // wieder zurueck
3395 : :
3396 [ # # ]: 0 : if( --nAktCol == ( aColumns.size() / 2 ) )
3397 : : {
3398 [ # # ]: 0 : aColumns.push_back( nWidth );
3399 [ # # ]: 0 : aColumns.push_back( nSpace );
3400 : : }
3401 : : }
3402 : 0 : break;
3403 : :
3404 : : case RTF_PAGEBB:
3405 : : {
3406 [ # # ][ # # ]: 0 : pPgFmt->SetFmtAttr( SvxFmtBreakItem( SVX_BREAK_PAGE_BEFORE, RES_BREAK ) );
[ # # ]
3407 : : }
3408 : 0 : break;
3409 : :
3410 : : case RTF_HEADER:
3411 : : case RTF_HEADERL:
3412 : : case RTF_HEADERR:
3413 : : case RTF_FOOTER:
3414 : : case RTF_FOOTERL:
3415 : : case RTF_FOOTERR:
3416 : : case RTF_FOOTERF:
3417 : : case RTF_HEADERF:
3418 [ # # ]: 0 : ReadHeaderFooter(nToken, pPg);
3419 : 0 : --nNumOpenBrakets; // Klammer wird im ReadAttr ueberlesen!
3420 : 0 : break;
3421 : : case RTF_TEXTTOKEN:
3422 [ # # ][ # # ]: 0 : if (!DelCharAtEnd(aToken, ';' ).Len())
3423 : 0 : break;
3424 : : OSL_ENSURE(pPg, "Unexpected missing pPg");
3425 [ # # ]: 0 : if (pPg)
3426 : : {
3427 [ # # ]: 0 : pPg->SetName(aToken);
3428 : :
3429 : : // sollte es eine Vorlage aus dem Pool sein ??
3430 : : sal_uInt16 n = SwStyleNameMapper::GetPoolIdFromUIName(aToken,
3431 [ # # ]: 0 : nsSwGetPoolIdFromName::GET_POOLID_PAGEDESC);
3432 [ # # ]: 0 : if (USHRT_MAX != n)
3433 : : {
3434 : : // dann setze bei der Neuen die entsp. PoolId
3435 : 0 : pPg->SetPoolFmtId(n);
3436 : : }
3437 : : }
3438 : 0 : break;
3439 : : case RTF_BRDBOX:
3440 [ # # ]: 0 : if (3 == nNumOpenBrakets)
3441 : : {
3442 : : ReadBorderAttr(SkipToken(-2),
3443 [ # # ][ # # ]: 0 : (SfxItemSet&)pPgFmt->GetAttrSet());
3444 : 0 : --nNumOpenBrakets; // Klammer wird im ReadAttr ueberlesen!
3445 : : }
3446 : 0 : break;
3447 : : case RTF_SHADOW:
3448 [ # # ]: 0 : if( 3 == nNumOpenBrakets )
3449 : : {
3450 [ # # ][ # # ]: 0 : ReadAttr( SkipToken( -2 ), (SfxItemSet*)&pPgFmt->GetAttrSet() );
3451 : 0 : --nNumOpenBrakets; // Klammer wird im ReadAttr ueberlesen!
3452 : : }
3453 : 0 : break;
3454 : :
3455 : :
3456 : : default:
3457 [ # # ]: 0 : if( (nToken & ~0xff ) == RTF_SHADINGDEF )
3458 [ # # ]: 0 : ReadBackgroundAttr( nToken, (SfxItemSet&)pPgFmt->GetAttrSet() );
3459 : 0 : break;
3460 : : }
3461 : : }
3462 : :
3463 : :
3464 : : // setze jetzt noch bei allen die entsprechenden Follows !!
3465 : : // Die, die ueber die Tabelle eingelesen wurden und einen
3466 : : // Follow definiert haben, ist dieser als Tabposition im
3467 : : // Follow schon gesetzt.
3468 [ # # ]: 0 : for( nPos = 0; nPos < pDoc->GetPageDescCnt(); ++nPos )
3469 : : {
3470 [ # # ]: 0 : SwPageDesc* pPgDsc = &pDoc->GetPageDesc( nPos );
3471 : : std::map< const SwPageDesc*, sal_uInt16 >::const_iterator aIter =
3472 [ # # ][ # # ]: 0 : aFollowMap.find( pPgDsc );
3473 [ # # ][ # # ]: 0 : if (aIter != aFollowMap.end())
[ # # ]
3474 : : {
3475 [ # # ][ # # ]: 0 : if ((*aIter).second < pDoc->GetPageDescCnt())
3476 [ # # ][ # # ]: 0 : pPgDsc->SetFollow(& pDoc->GetPageDesc((*aIter).second));
3477 : : }
3478 : : }
3479 : :
3480 : 0 : SetChkStyleAttr( bSaveChkStyleAttr );
3481 : :
3482 : 0 : bInPgDscTbl = false;
3483 : 0 : nAktPageDesc = 0;
3484 : 0 : nAktFirstPageDesc = 0;
3485 : 0 : bSwPageDesc = true;
3486 [ # # ][ # # ]: 0 : SkipToken( -1 );
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
3487 : 0 : }
3488 : :
3489 : 0 : void SwRTFParser::ReadPrtData()
3490 : : {
3491 [ # # ]: 0 : while( IsParserWorking() )
3492 : : {
3493 : 0 : int nToken = GetNextToken();
3494 [ # # ][ # # ]: 0 : if( (RTF_TEXTTOKEN != nToken) && ('}' == nToken) )
3495 : 0 : break;
3496 : : }
3497 : :
3498 : 0 : SkipToken( -1 ); // schliessende Klammer wieder zurueck!!
3499 : 0 : }
3500 : :
3501 : 0 : static const SwNodeIndex* SetHeader(SwFrmFmt* pHdFtFmt, sal_Bool bReuseOld)
3502 : : {
3503 : : OSL_ENSURE(pHdFtFmt, "Impossible, no header");
3504 : : const SwFrmFmt* pExisting = bReuseOld ?
3505 [ # # ]: 0 : pHdFtFmt->GetHeader().GetHeaderFmt() : 0;
3506 [ # # ]: 0 : if (!pExisting)
3507 : : {
3508 : : //No existing header, create a new one
3509 [ # # ]: 0 : pHdFtFmt->SetFmtAttr(SwFmtHeader(sal_True));
3510 : 0 : pExisting = pHdFtFmt->GetHeader().GetHeaderFmt();
3511 : : }
3512 : 0 : return pExisting->GetCntnt().GetCntntIdx();
3513 : : }
3514 : :
3515 : 0 : static const SwNodeIndex* SetFooter(SwFrmFmt* pHdFtFmt, sal_Bool bReuseOld)
3516 : : {
3517 : : OSL_ENSURE(pHdFtFmt, "Impossible, no footer");
3518 : : const SwFrmFmt* pExisting = bReuseOld ?
3519 [ # # ]: 0 : pHdFtFmt->GetFooter().GetFooterFmt() : 0;
3520 [ # # ]: 0 : if (!pExisting)
3521 : : {
3522 : : //No exist footer, create a new one
3523 [ # # ]: 0 : pHdFtFmt->SetFmtAttr(SwFmtFooter(sal_True));
3524 : 0 : pExisting = pHdFtFmt->GetFooter().GetFooterFmt();
3525 : : }
3526 : 0 : return pExisting->GetCntnt().GetCntntIdx();
3527 : : }
3528 : :
3529 : :
3530 : 0 : void SwRTFParser::ReadHeaderFooter( int nToken, SwPageDesc* pPageDesc )
3531 : : {
3532 : : OSL_ENSURE( RTF_FOOTNOTE == nToken ||
3533 : : RTF_FLY_INPARA == nToken ||
3534 : : pPageDesc, "PageDesc is missing" );
3535 : :
3536 : 0 : bool bContainsParaCache = bContainsPara;
3537 : : // backup all important data
3538 [ # # ]: 0 : SwPosition aSavePos( *pPam->GetPoint() );
3539 [ # # ]: 0 : SvxRTFItemStack aSaveStack(GetAttrStack());
3540 : 0 : GetAttrStack().clear();
3541 : :
3542 : : // save the fly array - after read, all flys may be set into
3543 : : // the header/footer
3544 [ # # ]: 0 : SwFlySaveArr aSaveArray(aFlyArr);
3545 [ # # ]: 0 : aSaveArray.reserve(255);
3546 : 0 : aFlyArr.clear();
3547 : 0 : sal_Bool bSetFlyInDoc = sal_True;
3548 : :
3549 : 0 : const SwNodeIndex* pSttIdx = 0;
3550 : 0 : SwFrmFmt* pHdFtFmt = 0;
3551 : 0 : SwTxtAttr* pTxtAttr = 0;
3552 : 0 : int bDelFirstChar = sal_False;
3553 : 0 : bool bOldIsFootnote = mbIsFootnote;
3554 : 0 : sal_Bool bOldGrpStt = sal::static_int_cast< sal_Bool, int >(IsNewGroup());
3555 : :
3556 : 0 : int nNumOpenBrakets = GetOpenBrakets() - 1;
3557 : :
3558 [ # # # # : 0 : switch( nToken )
# # # #
# ]
3559 : : {
3560 : : case RTF_FOOTNOTE:
3561 : : {
3562 [ # # ]: 0 : bool bIsEndNote = RTF_FTNALT == GetNextToken();
3563 [ # # ]: 0 : if (!bIsEndNote)
3564 [ # # ]: 0 : SkipToken(-1);
3565 : :
3566 : 0 : SwTxtNode* pTxtNd = pPam->GetNode()->GetTxtNode();
3567 [ # # ]: 0 : SwFmtFtn aFtnNote(bIsEndNote);
3568 : 0 : xub_StrLen nPos = pPam->GetPoint()->nContent.GetIndex();
3569 : :
3570 [ # # ][ # # ]: 0 : if (nPos && !bFootnoteAutoNum)
3571 : : {
3572 [ # # ]: 0 : pPam->GetPoint()->nContent--;
3573 : 0 : nPos--;
3574 [ # # ][ # # ]: 0 : aFtnNote.SetNumStr(rtl::OUString(pTxtNd->GetTxt().GetChar(nPos)));
[ # # ]
3575 [ # # ]: 0 : ((String&)pTxtNd->GetTxt()).SetChar( nPos, CH_TXTATR_BREAKWORD );
3576 : 0 : bDelFirstChar = sal_True;
3577 : : }
3578 : :
3579 : : pTxtAttr = pTxtNd->InsertItem( aFtnNote, nPos, nPos,
3580 [ # # ][ # # ]: 0 : bDelFirstChar ? nsSetAttrMode::SETATTR_NOTXTATRCHR : 0 );
3581 : :
3582 : : OSL_ENSURE( pTxtAttr, "konnte die Fussnote nicht einfuegen/finden" );
3583 : :
3584 [ # # ]: 0 : if( pTxtAttr )
3585 : 0 : pSttIdx = ((SwTxtFtn*)pTxtAttr)->GetStartNode();
3586 : 0 : mbIsFootnote = true;
3587 : :
3588 : : // wurde an der Position ein Escapement aufgespannt, so entferne
3589 : : // das jetzt. Fussnoten sind bei uns immer hochgestellt.
3590 [ # # ][ # # ]: 0 : SvxRTFItemStackType* pTmp = aSaveStack.empty() ? 0 : aSaveStack.back();
3591 [ # # ][ # # : 0 : if( pTmp && pTmp->GetSttNodeIdx() ==
# # # # ]
[ # # ]
3592 : 0 : pPam->GetPoint()->nNode.GetIndex() &&
3593 : 0 : pTmp->GetSttCnt() == nPos )
3594 [ # # ][ # # ]: 0 : pTmp->GetAttrSet().ClearItem( RES_CHRATR_ESCAPEMENT );
3595 : : }
3596 : 0 : break;
3597 : :
3598 : : case RTF_FLY_INPARA:
3599 : : {
3600 : 0 : xub_StrLen nPos = pPam->GetPoint()->nContent.GetIndex();
3601 : 0 : SfxItemSet aSet( pDoc->GetAttrPool(), RES_FRMATR_BEGIN,
3602 [ # # ]: 0 : RES_FRMATR_END-1 );
3603 [ # # ][ # # ]: 0 : aSet.Put( SwFmtAnchor( FLY_AS_CHAR ));
[ # # ]
3604 : : pHdFtFmt = pDoc->MakeFlySection( FLY_AS_CHAR,
3605 [ # # ]: 0 : pPam->GetPoint(), &aSet );
3606 : :
3607 : : pTxtAttr = pPam->GetNode()->GetTxtNode()->GetTxtAttrForCharAt(
3608 [ # # ]: 0 : nPos, RES_TXTATR_FLYCNT );
3609 : : OSL_ENSURE( pTxtAttr, "konnte den Fly nicht einfuegen/finden" );
3610 : :
3611 [ # # ]: 0 : pSttIdx = pHdFtFmt->GetCntnt().GetCntntIdx();
3612 [ # # ]: 0 : bSetFlyInDoc = sal_False;
3613 : : }
3614 : 0 : break;
3615 : :
3616 : : case RTF_HEADERF:
3617 : : case RTF_HEADER:
3618 : 0 : pPageDesc->WriteUseOn( (UseOnPage)(pPageDesc->ReadUseOn() | nsUseOnPage::PD_HEADERSHARE) );
3619 : 0 : pHdFtFmt = &pPageDesc->GetMaster();
3620 [ # # ]: 0 : pSttIdx = SetHeader( pHdFtFmt, sal_False );
3621 : 0 : break;
3622 : :
3623 : : case RTF_HEADERL:
3624 : : // we cannot have left or right, must have always both
3625 : 0 : pPageDesc->WriteUseOn( (UseOnPage)((pPageDesc->ReadUseOn() & ~nsUseOnPage::PD_HEADERSHARE) | nsUseOnPage::PD_ALL));
3626 [ # # ]: 0 : SetHeader( pPageDesc->GetRightFmt(), sal_True );
3627 : 0 : pHdFtFmt = pPageDesc->GetLeftFmt();
3628 [ # # ]: 0 : pSttIdx = SetHeader(pHdFtFmt, sal_False );
3629 : 0 : break;
3630 : :
3631 : : case RTF_HEADERR:
3632 : : // we cannot have left or right, must have always both
3633 : 0 : pPageDesc->WriteUseOn( (UseOnPage)((pPageDesc->ReadUseOn() & ~nsUseOnPage::PD_HEADERSHARE) | nsUseOnPage::PD_ALL));
3634 [ # # ]: 0 : SetHeader( pPageDesc->GetLeftFmt(), sal_True );
3635 : 0 : pHdFtFmt = pPageDesc->GetRightFmt();
3636 [ # # ]: 0 : pSttIdx = SetHeader(pHdFtFmt, sal_False );
3637 : 0 : break;
3638 : :
3639 : : case RTF_FOOTERF:
3640 : : case RTF_FOOTER:
3641 : 0 : pPageDesc->WriteUseOn( (UseOnPage)(pPageDesc->ReadUseOn() | nsUseOnPage::PD_FOOTERSHARE) );
3642 : 0 : pHdFtFmt = &pPageDesc->GetMaster();
3643 [ # # ]: 0 : pSttIdx = SetFooter(pHdFtFmt, sal_False );
3644 : 0 : break;
3645 : :
3646 : : case RTF_FOOTERL:
3647 : : // we cannot have left or right, must have always both
3648 : 0 : pPageDesc->WriteUseOn( (UseOnPage)((pPageDesc->ReadUseOn() & ~nsUseOnPage::PD_FOOTERSHARE) | nsUseOnPage::PD_ALL));
3649 [ # # ]: 0 : SetFooter( pPageDesc->GetRightFmt(), sal_True );
3650 : 0 : pHdFtFmt = pPageDesc->GetLeftFmt();
3651 [ # # ]: 0 : pSttIdx = SetFooter(pHdFtFmt, sal_False );
3652 : 0 : break;
3653 : :
3654 : : case RTF_FOOTERR:
3655 : : // we cannot have left or right, must have always both
3656 : 0 : pPageDesc->WriteUseOn( (UseOnPage)((pPageDesc->ReadUseOn() & ~nsUseOnPage::PD_FOOTERSHARE) | nsUseOnPage::PD_ALL));
3657 [ # # ]: 0 : SetFooter( pPageDesc->GetLeftFmt(), sal_True );
3658 : 0 : pHdFtFmt = pPageDesc->GetRightFmt();
3659 [ # # ]: 0 : pSttIdx = SetFooter(pHdFtFmt, sal_False );
3660 : 0 : break;
3661 : : }
3662 : :
3663 : 0 : sal_uInt16 nOldFlyArrCnt = aFlyArr.size();
3664 [ # # ]: 0 : if( !pSttIdx )
3665 [ # # ]: 0 : SkipGroup();
3666 : : else
3667 : : {
3668 : : // es ist auf jedenfall jetzt ein TextNode im Kopf/Fusszeilen-Bereich
3669 : : // vorhanden. Dieser muss jetzt nur noch gefunden und der neue Cursor
3670 : : // dort hinein gesetzt werden.
3671 [ # # ]: 0 : SwCntntNode *pNode = pDoc->GetNodes()[ pSttIdx->GetIndex()+1 ]->
3672 [ # # ]: 0 : GetCntntNode();
3673 : :
3674 : : // immer ans Ende der Section einfuegen !!
3675 [ # # ]: 0 : pPam->GetPoint()->nNode = *pNode->EndOfSectionNode();
3676 [ # # ]: 0 : pPam->Move( fnMoveBackward );
3677 : :
3678 : 0 : SwTxtFmtColl* pColl = NULL;
3679 [ # # ]: 0 : std::map<sal_Int32,SwTxtFmtColl*>::iterator iter = aTxtCollTbl.find( 0 );
3680 : :
3681 [ # # ][ # # ]: 0 : if( iter == aTxtCollTbl.end() )
3682 [ # # ]: 0 : pColl = pDoc->GetTxtCollFromPool( RES_POOLCOLL_STANDARD, false );
3683 : : else
3684 [ # # ]: 0 : pColl = iter->second;
3685 : :
3686 [ # # ]: 0 : pDoc->SetTxtFmtColl( *pPam, pColl );
3687 : :
3688 : 0 : SetNewGroup( sal_True );
3689 : :
3690 [ # # ][ # # ]: 0 : while( !( nNumOpenBrakets == GetOpenBrakets() && !GetStackPos()) && IsParserWorking() )
[ # # ][ # # ]
3691 : : {
3692 [ # # ]: 0 : switch( nToken = GetNextToken() )
[ # # # ]
3693 : : {
3694 : : case RTF_U:
3695 [ # # ]: 0 : if( bDelFirstChar )
3696 : : {
3697 : 0 : bDelFirstChar = sal_False;
3698 : 0 : nToken = 0;
3699 : : }
3700 : 0 : break;
3701 : :
3702 : : case RTF_TEXTTOKEN:
3703 [ # # ]: 0 : if( bDelFirstChar )
3704 : : {
3705 [ # # ][ # # ]: 0 : if( !aToken.Erase( 0, 1 ).Len() )
3706 : 0 : nToken = 0;
3707 : 0 : bDelFirstChar = sal_False;
3708 : : }
3709 : 0 : break;
3710 : : }
3711 [ # # ]: 0 : if( nToken )
3712 [ # # ]: 0 : NextToken( nToken );
3713 : : }
3714 : :
3715 [ # # ]: 0 : SetAllAttrOfStk();
3716 [ # # ][ # # ]: 0 : if( !aFlyArr.empty() && bSetFlyInDoc )
[ # # ]
3717 [ # # ]: 0 : SetFlysInDoc();
3718 : :
3719 : : // sollte der letze Node leer sein, dann loesche ihn
3720 : : // (\par heisst ja Absatzende und nicht neuer Absatz!)
3721 [ # # ]: 0 : DelLastNode();
3722 : : }
3723 : :
3724 : : // vom FlyFmt noch die richtigen Attribute setzen
3725 [ # # ][ # # ]: 0 : if( pTxtAttr && RES_TXTATR_FLYCNT == pTxtAttr->Which() )
[ # # ][ # # ]
3726 : : {
3727 : : // is add a new fly ?
3728 [ # # ]: 0 : if( nOldFlyArrCnt < aFlyArr.size() )
3729 : : {
3730 [ # # ]: 0 : SwFlySave* pFlySave = aFlyArr.back();
3731 [ # # ]: 0 : pFlySave->aFlySet.ClearItem( RES_ANCHOR );
3732 [ # # ]: 0 : pHdFtFmt->SetFmtAttr( pFlySave->aFlySet );
3733 [ # # ][ # # ]: 0 : delete aFlyArr.back();
[ # # ]
3734 [ # # ]: 0 : aFlyArr.pop_back();
3735 : : }
3736 : : else
3737 : : {
3738 : : // no, so remove the created textattribute
3739 : 0 : SwFrmFmt* pFlyFmt = pTxtAttr->GetFlyCnt().GetFrmFmt();
3740 : : // remove the pam from the flynode
3741 [ # # ]: 0 : *pPam->GetPoint() = aSavePos;
3742 [ # # ]: 0 : pDoc->DelLayoutFmt( pFlyFmt );
3743 : : }
3744 : : }
3745 : :
3746 : 0 : bFootnoteAutoNum = sal_False; // default auf aus!
3747 : :
3748 : : // und alles wieder zurueck
3749 [ # # ]: 0 : *pPam->GetPoint() = aSavePos;
3750 [ # # ]: 0 : if (mbIsFootnote)
3751 : 0 : SetNewGroup( bOldGrpStt ); // Status wieder zurueck
3752 : : else
3753 : 0 : SetNewGroup( sal_False ); // { - Klammer war kein Group-Start!
3754 : 0 : mbIsFootnote = bOldIsFootnote;
3755 [ # # ]: 0 : GetAttrStack() = aSaveStack;
3756 : :
3757 [ # # ]: 0 : std::copy(aSaveArray.begin(), aSaveArray.end(), aFlyArr.begin() );
3758 : 0 : aSaveArray.clear();
3759 [ # # ][ # # ]: 0 : bContainsPara = bContainsParaCache;
3760 : 0 : }
3761 : :
3762 : 0 : void SwRTFParser::SetSwgValues( SfxItemSet& rSet )
3763 : : {
3764 : : const SfxPoolItem* pItem;
3765 : : // Escapement korrigieren
3766 [ # # ][ # # ]: 0 : if( SFX_ITEM_SET == rSet.GetItemState( RES_CHRATR_ESCAPEMENT, sal_False, &pItem ))
3767 : : {
3768 : : /* prozentuale Veraenderung errechnen !
3769 : : * Formel : (FontSize * 1/20 ) pts Escapement * 2
3770 : : * ----------------------- = ----------------
3771 : : * 100% x
3772 : : */
3773 : :
3774 : : // die richtige
3775 : 0 : long nEsc = ((SvxEscapementItem*)pItem)->GetEsc();
3776 : :
3777 : : // automatische Ausrichtung wurde schon richtig berechnet
3778 [ # # ][ # # ]: 0 : if( DFLT_ESC_AUTO_SUPER != nEsc && DFLT_ESC_AUTO_SUB != nEsc )
3779 : : {
3780 [ # # ]: 0 : const SvxFontHeightItem& rFH = GetSize( rSet );
3781 : 0 : nEsc *= 1000L;
3782 [ # # ]: 0 : if(rFH.GetHeight()) nEsc /= long(rFH.GetHeight()); // #i77256#
3783 : :
3784 : : SvxEscapementItem aEsc( (short) nEsc,
3785 [ # # ]: 0 : ((SvxEscapementItem*)pItem)->GetProp(), RES_CHRATR_ESCAPEMENT);
3786 [ # # ][ # # ]: 0 : rSet.Put( aEsc );
3787 : : }
3788 : : }
3789 : :
3790 : : // TabStops anpassen
3791 [ # # ][ # # ]: 0 : if( SFX_ITEM_SET == rSet.GetItemState( RES_PARATR_TABSTOP, sal_False, &pItem ))
3792 : : {
3793 [ # # ]: 0 : const SvxLRSpaceItem& rLR = GetLRSpace( rSet );
3794 [ # # ]: 0 : SvxTabStopItem aTStop( *(SvxTabStopItem*)pItem );
3795 : :
3796 : 0 : long nOffset = rLR.GetTxtLeft();
3797 [ # # ]: 0 : if( nOffset )
3798 : : {
3799 : : // Tabs anpassen !!
3800 [ # # ]: 0 : for( sal_uInt16 n = 0; n < aTStop.Count(); ++n)
3801 [ # # ][ # # ]: 0 : if( SVX_TAB_ADJUST_DEFAULT != aTStop[n].GetAdjustment() )
3802 : : {
3803 [ # # ]: 0 : const_cast<SvxTabStop&>(aTStop[n]).GetTabPos() -= nOffset;
3804 : : }
3805 : :
3806 : : // negativer Einzug, dann auf 0 Pos einen Tab setzen
3807 [ # # ]: 0 : if( rLR.GetTxtFirstLineOfst() < 0 )
3808 [ # # ][ # # ]: 0 : aTStop.Insert( SvxTabStop() );
3809 : : }
3810 : :
3811 [ # # ]: 0 : if( !aTStop.Count() )
3812 : : {
3813 : : const SvxTabStopItem& rDflt = (const SvxTabStopItem&)rSet.
3814 [ # # ]: 0 : GetPool()->GetDefaultItem(RES_PARATR_TABSTOP);
3815 [ # # ]: 0 : if( rDflt.Count() )
3816 [ # # ]: 0 : aTStop.Insert( &rDflt, 0 );
3817 : : }
3818 [ # # ][ # # ]: 0 : rSet.Put( aTStop );
3819 : : }
3820 [ # # ]: 0 : else if( SFX_ITEM_SET == rSet.GetItemState( RES_LR_SPACE, sal_False, &pItem )
[ # # # # ]
[ # # ]
3821 : 0 : && ((SvxLRSpaceItem*)pItem)->GetTxtFirstLineOfst() < 0 )
3822 : : {
3823 : : // negativer Einzug, dann auf 0 Pos einen Tab setzen
3824 [ # # ][ # # ]: 0 : rSet.Put( SvxTabStopItem( 1, 0, SVX_TAB_ADJUST_DEFAULT, RES_PARATR_TABSTOP ));
[ # # ]
3825 : : }
3826 : :
3827 : : // NumRules anpassen
3828 [ # # ][ # # ]: 0 : if( !bStyleTabValid &&
[ # # ]
3829 [ # # ]: 0 : SFX_ITEM_SET == rSet.GetItemState( RES_PARATR_NUMRULE, sal_False, &pItem ))
3830 : : {
3831 : : // dann steht im Namen nur ein Verweis in das ListArray
3832 : : SwNumRule* pRule = GetNumRuleOfListNo( ((SwNumRuleItem*)pItem)->
3833 [ # # ][ # # ]: 0 : GetValue().ToInt32() );
3834 [ # # ]: 0 : if( pRule )
3835 [ # # ][ # # ]: 0 : rSet.Put( SwNumRuleItem( pRule->GetName() ));
[ # # ]
3836 : : else
3837 [ # # ]: 0 : rSet.ClearItem( RES_PARATR_NUMRULE );
3838 : :
3839 : : }
3840 : :
3841 : 0 : }
3842 : :
3843 : :
3844 : 0 : SwTxtFmtColl* SwRTFParser::MakeColl(const String& rName, sal_uInt16 nPos,
3845 : : sal_uInt8 nOutlineLevel, bool& rbCollExist)
3846 : : {
3847 [ # # ]: 0 : if( sal_uInt8(-1) == nOutlineLevel )
3848 : 0 : nOutlineLevel = MAXLEVEL;
3849 : :
3850 : 0 : rbCollExist = false;
3851 : : SwTxtFmtColl* pColl;
3852 [ # # ]: 0 : String aNm( rName );
3853 [ # # ]: 0 : if( !aNm.Len() )
3854 : : {
3855 : : OSL_ENSURE(!this, "not a bug, but I (cmc) want to see an example of this");
3856 [ # # ]: 0 : if( !nPos )
3857 : : {
3858 [ # # ]: 0 : pColl = pDoc->GetTxtCollFromPool( RES_POOLCOLL_STANDARD, false );
3859 [ # # ]: 0 : if(nOutlineLevel < MAXLEVEL )
3860 [ # # ]: 0 : pColl->AssignToListLevelOfOutlineStyle( nOutlineLevel );
3861 : : else
3862 [ # # ]: 0 : pColl->DeleteAssignmentToListLevelOfOutlineStyle();
3863 : 0 : return pColl;
3864 : : }
3865 : :
3866 : : // erzeuge einen Namen
3867 [ # # ]: 0 : aNm.AssignAscii( RTL_CONSTASCII_STRINGPARAM( "NoName(" ));
3868 [ # # ][ # # ]: 0 : aNm += String::CreateFromInt32( nPos );
[ # # ]
3869 [ # # ]: 0 : aNm += ')';
3870 : : }
3871 : 0 : ww::sti eSti = ww::GetCanonicalStiFromEnglishName(rName);
3872 : : sw::util::ParaStyleMapper::StyleResult aResult =
3873 [ # # ]: 0 : maParaStyleMapper.GetStyle(rName, eSti);
3874 : 0 : pColl = aResult.first;
3875 : 0 : rbCollExist = aResult.second;
3876 [ # # ][ # # ]: 0 : if (IsNewDoc() && rbCollExist)
[ # # ]
3877 : : {
3878 [ # # ]: 0 : pColl->ResetAllFmtAttr(); // #i73790# - method renamed
3879 : 0 : rbCollExist = false;
3880 : : }
3881 : :
3882 [ # # ]: 0 : if (!rbCollExist)
3883 : : {
3884 [ # # ]: 0 : if(nOutlineLevel < MAXLEVEL)
3885 [ # # ]: 0 : pColl->AssignToListLevelOfOutlineStyle( nOutlineLevel );
3886 : : else
3887 [ # # ]: 0 : pColl->DeleteAssignmentToListLevelOfOutlineStyle();
3888 : : }
3889 : :
3890 [ # # ]: 0 : return pColl;
3891 : : }
3892 : :
3893 : 0 : SwCharFmt* SwRTFParser::MakeCharFmt(const String& rName, sal_uInt16 nPos,
3894 : : int& rbCollExist)
3895 : : {
3896 : 0 : rbCollExist = sal_False;
3897 : : SwCharFmt* pFmt;
3898 [ # # ]: 0 : String aNm( rName );
3899 [ # # ]: 0 : if( !aNm.Len() )
3900 : : {
3901 : : OSL_ENSURE(!this, "not a bug, but I (cmc) want to see an example of this");
3902 [ # # ]: 0 : aNm.AssignAscii( RTL_CONSTASCII_STRINGPARAM( "NoName(" ));
3903 [ # # ][ # # ]: 0 : aNm += String::CreateFromInt32( nPos );
[ # # ]
3904 [ # # ]: 0 : aNm += ')';
3905 : : }
3906 : :
3907 : 0 : ww::sti eSti = ww::GetCanonicalStiFromEnglishName(rName);
3908 : : sw::util::CharStyleMapper::StyleResult aResult =
3909 [ # # ]: 0 : maCharStyleMapper.GetStyle(rName, eSti);
3910 : 0 : pFmt = aResult.first;
3911 : 0 : rbCollExist = aResult.second;
3912 [ # # ][ # # ]: 0 : if (IsNewDoc() && rbCollExist)
[ # # ]
3913 : : {
3914 [ # # ]: 0 : pFmt->ResetAllFmtAttr(); // #i73790# - method renamed
3915 : 0 : rbCollExist = false;
3916 : : }
3917 [ # # ]: 0 : return pFmt;
3918 : : }
3919 : :
3920 : 0 : void SwRTFParser::SetStyleAttr( SfxItemSet& rCollSet,
3921 : : const SfxItemSet& rStyleSet,
3922 : : const SfxItemSet& rDerivedSet )
3923 : : {
3924 : 0 : rCollSet.Put( rStyleSet );
3925 [ # # ]: 0 : if( rDerivedSet.Count() )
3926 : : {
3927 : : // suche alle Attribute, die neu gesetzt werden:
3928 : : const SfxPoolItem* pItem;
3929 [ # # ]: 0 : SfxItemIter aIter( rDerivedSet );
3930 : 0 : sal_uInt16 nWhich = aIter.GetCurItem()->Which();
3931 : 0 : while( sal_True )
3932 : : {
3933 [ # # ]: 0 : switch( rStyleSet.GetItemState( nWhich, sal_False, &pItem ) )
[ # # # ]
3934 : : {
3935 : : case SFX_ITEM_DEFAULT:
3936 : : // auf default zuruecksetzen
3937 [ # # ]: 0 : if( RES_FRMATR_END > nWhich )
3938 [ # # ][ # # ]: 0 : rCollSet.Put( rCollSet.GetPool()->GetDefaultItem( nWhich ));
3939 : 0 : break;
3940 : : case SFX_ITEM_SET:
3941 [ # # ][ # # ]: 0 : if( *pItem == *aIter.GetCurItem() ) // gleiches Attribut?
3942 : : // definition kommt aus dem Parent
3943 [ # # ]: 0 : rCollSet.ClearItem( nWhich ); // loeschen
3944 : 0 : break;
3945 : : }
3946 : :
3947 [ # # ]: 0 : if( aIter.IsAtEnd() )
3948 : 0 : break;
3949 [ # # ]: 0 : nWhich = aIter.NextItem()->Which();
3950 [ # # ]: 0 : }
3951 : : }
3952 : : // und jetzt noch auf unsere Werte abgleichen
3953 : 0 : SetSwgValues( rCollSet );
3954 : 0 : }
3955 : :
3956 : 0 : SwTxtFmtColl* SwRTFParser::MakeStyle( sal_uInt16 nNo, const SvxRTFStyleType& rStyle)
3957 : : {
3958 : : bool bCollExist;
3959 : : SwTxtFmtColl* pColl = MakeColl( rStyle.sName, sal_uInt16(nNo),
3960 [ # # ]: 0 : rStyle.nOutlineNo, bCollExist);
3961 [ # # ][ # # ]: 0 : aTxtCollTbl.insert(std::make_pair(nNo,pColl));
3962 : :
3963 : : // in bestehendes Dok einfuegen, dann keine Ableitung usw. setzen
3964 [ # # ]: 0 : if( bCollExist )
3965 : 0 : return pColl;
3966 : :
3967 : 0 : sal_uInt16 nStyleNo = rStyle.nBasedOn;
3968 [ # # ][ # # ]: 0 : if( rStyle.bBasedOnIsSet && nStyleNo != nNo )
3969 : : {
3970 [ # # ]: 0 : SvxRTFStyleTbl::iterator styleIter = GetStyleTbl().find( nStyleNo );
3971 : 0 : SvxRTFStyleType* pDerivedStyle = NULL;
3972 [ # # ][ # # ]: 0 : if ( styleIter != GetStyleTbl().end() )
[ # # ]
3973 [ # # ]: 0 : pDerivedStyle = styleIter->second;
3974 : :
3975 : 0 : SwTxtFmtColl* pDerivedColl = NULL;
3976 [ # # ]: 0 : std::map<sal_Int32,SwTxtFmtColl*>::iterator iter = aTxtCollTbl.find(nStyleNo);
3977 : :
3978 [ # # ][ # # ]: 0 : if(iter == aTxtCollTbl.end() ) // noch nicht vorhanden, also anlegen
3979 : : {
3980 : : // ist die ueberhaupt als Style vorhanden ?
3981 : : pDerivedColl = pDerivedStyle
3982 : 0 : ? MakeStyle( nStyleNo, *pDerivedStyle )
3983 [ # # ][ # # ]: 0 : : pDoc->GetTxtCollFromPool( RES_POOLCOLL_STANDARD, false );
[ # # ]
3984 : : }
3985 : : else
3986 [ # # ]: 0 : pDerivedColl = iter->second;
3987 : :
3988 [ # # ]: 0 : if( pColl == pDerivedColl )
3989 [ # # ]: 0 : ((SfxItemSet&)pColl->GetAttrSet()).Put( rStyle.aAttrSet );
3990 : : else
3991 : : {
3992 [ # # ]: 0 : pColl->SetDerivedFrom( pDerivedColl );
3993 : :
3994 : : // setze die richtigen Attribute
3995 : : const SfxItemSet* pDerivedSet;
3996 [ # # ]: 0 : if( pDerivedStyle )
3997 : 0 : pDerivedSet = &pDerivedStyle->aAttrSet;
3998 : : else
3999 : 0 : pDerivedSet = &pDerivedColl->GetAttrSet();
4000 : :
4001 : 0 : SetStyleAttr( (SfxItemSet&)pColl->GetAttrSet(),
4002 [ # # ]: 0 : rStyle.aAttrSet, *pDerivedSet );
4003 : 0 : }
4004 : : }
4005 : : else
4006 [ # # ]: 0 : ((SfxItemSet&)pColl->GetAttrSet()).Put( rStyle.aAttrSet );
4007 : :
4008 : :
4009 : 0 : nStyleNo = rStyle.nNext;
4010 [ # # ]: 0 : if( nStyleNo != nNo )
4011 : : {
4012 : 0 : SwTxtFmtColl* pNext = NULL;
4013 [ # # ]: 0 : std::map<sal_Int32,SwTxtFmtColl*>::iterator iter = aTxtCollTbl.find( nStyleNo );
4014 : :
4015 [ # # ][ # # ]: 0 : if( iter == aTxtCollTbl.end()) // noch nicht vorhanden, also anlegen
4016 : : {
4017 : : // ist die ueberhaupt als Style vorhanden ?
4018 [ # # ]: 0 : SvxRTFStyleTbl::iterator styleIter = GetStyleTbl().find( nStyleNo );
4019 [ # # ][ # # ]: 0 : if ( styleIter != GetStyleTbl().end() )
[ # # ]
4020 [ # # ][ # # ]: 0 : pNext = MakeStyle( nStyleNo, *styleIter->second );
4021 : : else
4022 [ # # ]: 0 : pNext = pDoc->GetTxtCollFromPool( RES_POOLCOLL_STANDARD, false );
4023 : : }
4024 : : else
4025 [ # # ]: 0 : pNext = iter->second;
4026 : :
4027 : 0 : pColl->SetNextTxtFmtColl( *pNext );
4028 : : }
4029 : 0 : return pColl;
4030 : : }
4031 : :
4032 : 0 : SwCharFmt* SwRTFParser::MakeCharStyle( sal_uInt16 nNo, const SvxRTFStyleType& rStyle )
4033 : : {
4034 : : int bCollExist;
4035 [ # # ]: 0 : SwCharFmt* pFmt = MakeCharFmt( rStyle.sName, sal_uInt16(nNo), bCollExist );
4036 [ # # ][ # # ]: 0 : aCharFmtTbl.insert(std::make_pair(nNo,pFmt));
4037 : :
4038 : : // in bestehendes Dok einfuegen, dann keine Ableitung usw. setzen
4039 [ # # ]: 0 : if( bCollExist )
4040 : 0 : return pFmt;
4041 : :
4042 : 0 : sal_uInt16 nStyleNo = rStyle.nBasedOn;
4043 [ # # ][ # # ]: 0 : if( rStyle.bBasedOnIsSet && nStyleNo != nNo )
4044 : : {
4045 [ # # ]: 0 : SvxRTFStyleTbl::iterator styleIter = GetStyleTbl().find( nStyleNo );
4046 : 0 : SvxRTFStyleType* pDerivedStyle = NULL;
4047 [ # # ][ # # ]: 0 : if ( styleIter != GetStyleTbl().end() )
[ # # ]
4048 [ # # ]: 0 : pDerivedStyle = styleIter->second;
4049 : :
4050 : 0 : SwCharFmt* pDerivedFmt = NULL;
4051 [ # # ]: 0 : std::map<sal_Int32,SwCharFmt*>::iterator iter = aCharFmtTbl.find( nStyleNo );
4052 : :
4053 [ # # ][ # # ]: 0 : if(iter == aCharFmtTbl.end()) // noch nicht vorhanden, also anlegen
4054 : : {
4055 : : // ist die ueberhaupt als Style vorhanden ?
4056 : : pDerivedFmt = pDerivedStyle
4057 : 0 : ? MakeCharStyle( nStyleNo, *pDerivedStyle )
4058 [ # # ][ # # ]: 0 : : pDoc->GetDfltCharFmt();
4059 : : }
4060 : : else
4061 [ # # ]: 0 : pDerivedFmt = iter->second;
4062 : :
4063 [ # # ]: 0 : if( pFmt == pDerivedFmt )
4064 [ # # ]: 0 : ((SfxItemSet&)pFmt->GetAttrSet()).Put( rStyle.aAttrSet );
4065 : : else
4066 : : {
4067 [ # # ]: 0 : pFmt->SetDerivedFrom( pDerivedFmt );
4068 : :
4069 : : // setze die richtigen Attribute
4070 : : const SfxItemSet* pDerivedSet;
4071 [ # # ]: 0 : if( pDerivedStyle )
4072 : 0 : pDerivedSet = &pDerivedStyle->aAttrSet;
4073 : : else
4074 : 0 : pDerivedSet = &pDerivedFmt->GetAttrSet();
4075 : :
4076 : 0 : SetStyleAttr( (SfxItemSet&)pFmt->GetAttrSet(),
4077 [ # # ]: 0 : rStyle.aAttrSet, *pDerivedSet );
4078 : 0 : }
4079 : : }
4080 : : else
4081 [ # # ]: 0 : ((SfxItemSet&)pFmt->GetAttrSet()).Put( rStyle.aAttrSet );
4082 : :
4083 : 0 : return pFmt;
4084 : : }
4085 : :
4086 : : // loesche den letzten Node (Tabelle/Fly/Ftn/..)
4087 : 0 : void SwRTFParser::DelLastNode()
4088 : : {
4089 : : // sollte der letze Node leer sein, dann loesche ihn
4090 : : // (\par heisst ja Absatzende und nicht neuer Absatz!)
4091 : :
4092 [ # # ]: 0 : if( !pPam->GetPoint()->nContent.GetIndex() )
4093 : : {
4094 : 0 : sal_uLong nNodeIdx = pPam->GetPoint()->nNode.GetIndex();
4095 : 0 : SwCntntNode* pCNd = pDoc->GetNodes()[ nNodeIdx ]->GetCntntNode();
4096 : : // paragraphs with page break information are not empty!)
4097 [ # # ]: 0 : if(const SfxPoolItem* pItem=&(pCNd->GetAttr( RES_PAGEDESC, sal_False)))
4098 : : {
4099 : 0 : SwFmtPageDesc* pPageDescItem = ((SwFmtPageDesc*)pItem);
4100 [ # # ]: 0 : if (pPageDescItem->GetPageDesc()!=NULL)
4101 : 0 : return;
4102 : : }
4103 : :
4104 [ # # ][ # # ]: 0 : if( pCNd && pCNd->StartOfSectionIndex()+2 <
[ # # ]
4105 : 0 : pCNd->EndOfSectionIndex() )
4106 : : {
4107 [ # # ]: 0 : if( !GetAttrStack().empty() )
4108 : : {
4109 : : // Attribut Stack-Eintraege, muessen ans Ende des vorherigen
4110 : : // Nodes verschoben werden.
4111 : 0 : sal_Bool bMove = sal_False;
4112 [ # # ]: 0 : for( size_t n = GetAttrStack().size(); n; )
4113 : : {
4114 : : SvxRTFItemStackType* pStkEntry = (SvxRTFItemStackType*)
4115 : 0 : GetAttrStack()[ --n ];
4116 [ # # ]: 0 : if( nNodeIdx == pStkEntry->GetSttNode().GetIdx() )
4117 : : {
4118 [ # # ]: 0 : if( !bMove )
4119 : : {
4120 : 0 : pPam->Move( fnMoveBackward );
4121 : 0 : bMove = sal_True;
4122 : : }
4123 [ # # ]: 0 : pStkEntry->SetStartPos( SwxPosition( pPam ) );
4124 : : }
4125 : : }
4126 [ # # ]: 0 : if( bMove )
4127 : 0 : pPam->Move( fnMoveForward );
4128 : : }
4129 : 0 : pPam->GetPoint()->nContent.Assign( 0, 0 );
4130 : 0 : pPam->SetMark();
4131 : 0 : pPam->DeleteMark();
4132 : :
4133 : 0 : pDoc->GetNodes().Delete( pPam->GetPoint()->nNode );
4134 : : }
4135 : : }
4136 : : }
4137 : :
4138 : : // fuer Tokens, die im ReadAttr nicht ausgewertet werden
4139 : 0 : void SwRTFParser::UnknownAttrToken( int nToken, SfxItemSet* pSet )
4140 : : {
4141 [ # # # # : 0 : switch( nToken )
# # # # ]
4142 : : {
4143 : : case RTF_INTBL:
4144 : : {
4145 [ # # ]: 0 : if( !pTableNode ) // Tabelle nicht mehr vorhanden ?
4146 : 0 : NewTblLine(); // evt. Line copieren
4147 : : else
4148 : : {
4149 : : static int _do=0;
4150 : : // Crsr nicht mehr in der Tabelle ?
4151 [ # # ][ # # ]: 0 : if( !pPam->GetNode()->FindTableNode() && _do )
[ # # ]
4152 : : {
4153 : 0 : sal_uLong nOldPos = pPam->GetPoint()->nNode.GetIndex();
4154 : :
4155 : : // dann wieder in die letzte Box setzen
4156 : : // (kann durch einlesen von Flys geschehen!)
4157 : 0 : pPam->GetPoint()->nNode = *pTableNode->EndOfSectionNode();
4158 : 0 : pPam->Move( fnMoveBackward );
4159 : :
4160 : : // alle Attribute, die schon auf den nachfolgen zeigen
4161 : : // auf die neue Box umsetzen !!
4162 : 0 : SvxRTFItemStack& rAttrStk = GetAttrStack();
4163 : : const SvxRTFItemStackType* pStk;
4164 [ # # ]: 0 : for( size_t n = 0; n < rAttrStk.size(); ++n )
4165 [ # # # # ]: 0 : if( ( pStk = rAttrStk[ n ])->GetSttNodeIdx() == nOldPos &&
[ # # ]
4166 : 0 : !pStk->GetSttCnt() )
4167 [ # # ]: 0 : ((SvxRTFItemStackType*)pStk)->SetStartPos( SwxPosition( pPam ) );
4168 : : }
4169 : : }
4170 : : }
4171 : 0 : break;
4172 : :
4173 : : case RTF_PAGEBB:
4174 : : {
4175 [ # # ]: 0 : pSet->Put( SvxFmtBreakItem( SVX_BREAK_PAGE_BEFORE, RES_BREAK ));
4176 : : }
4177 : 0 : break;
4178 : :
4179 : : case RTF_PGBRK:
4180 : : {
4181 : : pSet->Put( SvxFmtBreakItem( 1 == nTokenValue ?
4182 [ # # ][ # # ]: 0 : SVX_BREAK_PAGE_BOTH : SVX_BREAK_PAGE_AFTER, RES_BREAK ));
4183 : : }
4184 : 0 : break;
4185 : :
4186 : : case RTF_PGDSCNO:
4187 [ # # ]: 0 : if( IsNewDoc() && bSwPageDesc &&
[ # # # # ]
[ # # ]
4188 : 0 : sal_uInt16(nTokenValue) < pDoc->GetPageDescCnt() )
4189 : : {
4190 : 0 : const SwPageDesc* pPgDsc = &pDoc->GetPageDesc( (sal_uInt16)nTokenValue );
4191 [ # # ]: 0 : pDoc->InsertPoolItem( *pPam, SwFmtPageDesc( pPgDsc ), 0);
4192 : : }
4193 : 0 : break;
4194 : : case RTF_CS:
4195 : : {
4196 [ # # ]: 0 : std::map<sal_Int32,SwCharFmt*>::iterator iter = aCharFmtTbl.find( nTokenValue );
4197 : :
4198 [ # # ][ # # ]: 0 : if(iter != aCharFmtTbl.end())
4199 [ # # ][ # # ]: 0 : pSet->Put( SwFmtCharFmt(iter->second));
[ # # ][ # # ]
4200 : : }
4201 : 0 : break;
4202 : :
4203 : : case RTF_LS:
4204 [ # # ]: 0 : if( -1 != nTokenValue )
4205 : : {
4206 [ # # ]: 0 : if( bStyleTabValid )
4207 : : {
4208 : : // dann ist auch die ListTabelle gueltig, also suche die
4209 : : // enstprechende NumRule
4210 : 0 : SwNumRule* pRule = GetNumRuleOfListNo( nTokenValue );
4211 [ # # ]: 0 : if( pRule )
4212 [ # # ]: 0 : pSet->Put( SwNumRuleItem( pRule->GetName() ));
4213 : :
4214 [ # # ]: 0 : if( SFX_ITEM_SET != pSet->GetItemState( FN_PARAM_NUM_LEVEL, sal_False ))
4215 [ # # ]: 0 : pSet->Put( SfxUInt16Item( FN_PARAM_NUM_LEVEL, 0 ));
4216 : : }
4217 : : else
4218 : : {
4219 : : // wir sind in der Style-Definitions - Phase. Der Name
4220 : : // wird dann spaeter umgesetzt
4221 : : // pSet->Put( SwNumRuleItem( String::CreateFromInt32( nTokenValue )));
4222 : : }
4223 : :
4224 : : }
4225 : 0 : break;
4226 : :
4227 : : case RTF_ILVL:
4228 : : case RTF_SOUTLVL:
4229 : : {
4230 : : sal_uInt8 nLevel = MAXLEVEL <= nTokenValue ? MAXLEVEL - 1
4231 [ # # ]: 0 : : sal_uInt8( nTokenValue );
4232 [ # # ]: 0 : pSet->Put( SfxUInt16Item( FN_PARAM_NUM_LEVEL, nLevel ));
4233 : : }
4234 : 0 : break;
4235 : :
4236 : : }
4237 : 0 : }
4238 : :
4239 : 0 : void SwRTFParser::ReadInfo( const sal_Char* pChkForVerNo )
4240 : : {
4241 : 0 : sal_Char const aChkForVerNo[] = "StarWriter";
4242 : :
4243 : : // falls nicht schon was vorgegeben wurde, setzen wir unseren Namen
4244 : : // rein. Wenn das im Kommentar match, wird im Parser die VersionNummer
4245 : : // gelesen und gesetzt
4246 [ # # ]: 0 : if( !pChkForVerNo )
4247 : 0 : pChkForVerNo = aChkForVerNo;
4248 : :
4249 [ # # ]: 0 : SvxRTFParser::ReadInfo( pChkForVerNo );
4250 : 0 : }
4251 : :
4252 : 0 : void SwRTFParser::ReadUserProperties()
4253 : : {
4254 : : // For now we don't support user properties but at least the parser is here.
4255 : : // At the moment it just swallows the tokens to prevent them being displayed
4256 : 0 : int nNumOpenBrakets = 1, nToken;
4257 : :
4258 [ # # ][ # # ]: 0 : while( nNumOpenBrakets && IsParserWorking() )
[ # # ]
4259 : : {
4260 [ # # # # : 0 : switch( nToken = GetNextToken() )
# # ]
4261 : : {
4262 : : case '}':
4263 : 0 : --nNumOpenBrakets;
4264 : 0 : break;
4265 : : case '{':
4266 : : {
4267 [ # # ]: 0 : if( RTF_IGNOREFLAG != GetNextToken() )
4268 : 0 : nToken = SkipToken( -1 );
4269 [ # # ]: 0 : else if( RTF_UNKNOWNCONTROL != GetNextToken() )
4270 : 0 : nToken = SkipToken( -2 );
4271 : : else
4272 : : {
4273 : : // gleich herausfiltern
4274 : 0 : ReadUnknownData();
4275 : 0 : nToken = GetNextToken();
4276 [ # # ]: 0 : if( '}' != nToken )
4277 : 0 : eState = SVPAR_ERROR;
4278 : 0 : break;
4279 : : }
4280 : 0 : ++nNumOpenBrakets;
4281 : : }
4282 : 0 : break;
4283 : :
4284 : : case RTF_PROPNAME:
4285 : 0 : SkipGroup();
4286 : 0 : break;
4287 : :
4288 : : case RTF_PROPTYPE:
4289 : 0 : break;
4290 : :
4291 : : case RTF_STATICVAL:
4292 : 0 : SkipGroup();
4293 : 0 : break;
4294 : :
4295 : : // default:
4296 : : }
4297 : : }
4298 : :
4299 : 0 : SkipToken( -1 );
4300 : 0 : }
4301 : :
4302 : :
4303 : : #ifdef USED
4304 : : void SwRTFParser::SaveState( int nToken )
4305 : : {
4306 : : SvxRTFParser::SaveState( nToken );
4307 : : }
4308 : :
4309 : : void SwRTFParser::RestoreState()
4310 : : {
4311 : : SvxRTFParser::RestoreState();
4312 : : }
4313 : : #endif
4314 : :
4315 : : /**/
4316 : :
4317 : 0 : BookmarkPosition::BookmarkPosition(const SwPaM &rPaM)
4318 : 0 : : maMkNode(rPaM.GetMark()->nNode),
4319 : 0 : mnMkCntnt(rPaM.GetMark()->nContent.GetIndex())
4320 : : {
4321 : 0 : }
4322 : :
4323 : 0 : BookmarkPosition::BookmarkPosition(const BookmarkPosition &rEntry)
4324 : 0 : : maMkNode(rEntry.maMkNode), mnMkCntnt(rEntry.mnMkCntnt)
4325 : : {
4326 : 0 : }
4327 : :
4328 : 0 : bool BookmarkPosition::operator==(const BookmarkPosition rhs)
4329 : : {
4330 [ # # ][ # # ]: 0 : return(maMkNode.GetIndex() == rhs.maMkNode.GetIndex() && mnMkCntnt == rhs.mnMkCntnt);
4331 : : }
4332 : :
4333 : 0 : sal_uLong SwNodeIdx::GetIdx() const
4334 : : {
4335 : 0 : return aIdx.GetIndex();
4336 : : }
4337 : :
4338 : 0 : SvxNodeIdx* SwNodeIdx::Clone() const
4339 : : {
4340 [ # # ]: 0 : return new SwNodeIdx( aIdx );
4341 : : }
4342 : :
4343 : 0 : SvxPosition* SwxPosition::Clone() const
4344 : : {
4345 : 0 : return new SwxPosition( pPam );
4346 : : }
4347 : :
4348 : 0 : SvxNodeIdx* SwxPosition::MakeNodeIdx() const
4349 : : {
4350 [ # # ]: 0 : return new SwNodeIdx( pPam->GetPoint()->nNode );
4351 : : }
4352 : :
4353 : 0 : sal_uLong SwxPosition::GetNodeIdx() const
4354 : : {
4355 : 0 : return pPam->GetPoint()->nNode.GetIndex();
4356 : : }
4357 : :
4358 : 0 : xub_StrLen SwxPosition::GetCntIdx() const
4359 : : {
4360 : 0 : return pPam->GetPoint()->nContent.GetIndex();
4361 : : }
4362 : :
4363 : : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
