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 : :
30 : : #include <algorithm>
31 : : #include <functional>
32 : :
33 : : #include <com/sun/star/i18n/ScriptType.hpp>
34 : : #include <rtl/tencinfo.h>
35 : : #include <hintids.hxx>
36 : : #include <editeng/boxitem.hxx>
37 : : #include <editeng/fontitem.hxx>
38 : : #include <svx/svdobj.hxx>
39 : : #include <svx/svdotext.hxx>
40 : : #include <svx/fmglob.hxx>
41 : : #include <editeng/frmdiritem.hxx>
42 : : #include <editeng/lrspitem.hxx>
43 : : #include <editeng/ulspitem.hxx>
44 : : #include <doc.hxx>
45 : : #include <wrtww8.hxx>
46 : : #include <docary.hxx>
47 : : #include <poolfmt.hxx>
48 : : #include <fmtpdsc.hxx>
49 : : #include <pagedesc.hxx>
50 : : #include <ndtxt.hxx>
51 : : #include <ftninfo.hxx>
52 : : #include <fmthdft.hxx>
53 : : #include <section.hxx>
54 : : #include <fmtcntnt.hxx>
55 : : #include <fmtftn.hxx>
56 : : #include <ndindex.hxx>
57 : : #include <txtftn.hxx>
58 : : #include <charfmt.hxx>
59 : : #include <docufld.hxx>
60 : : #include <dcontact.hxx>
61 : : #include <fmtcnct.hxx>
62 : : #include <ftnidx.hxx>
63 : : #include <fmtclds.hxx>
64 : : #include <lineinfo.hxx>
65 : : #include <fmtline.hxx>
66 : : #include <swtable.hxx>
67 : : #include <msfilter.hxx>
68 : : #include <swmodule.hxx>
69 : :
70 : : #include <writerfilter/doctok/sprmids.hxx>
71 : :
72 : : #include "writerhelper.hxx"
73 : : #include "writerwordglue.hxx"
74 : : #include "../inc/wwstyles.hxx"
75 : : #include "ww8par.hxx"
76 : : #include "ww8attributeoutput.hxx"
77 : : #include "docxattributeoutput.hxx"
78 : : #include "rtfattributeoutput.hxx"
79 : :
80 : : using namespace sw::util;
81 : : using namespace nsHdFtFlags;
82 : :
83 : : struct WW8_SED
84 : : {
85 : : SVBT16 aBits1; // orientation change + internal, Default: 6
86 : : SVBT32 fcSepx; // FC file offset to beginning of SEPX for section.
87 : : // 0xFFFFFFFF for no Sprms
88 : : SVBT16 fnMpr; // used internally by Windows Word, Default: 0
89 : : SVBT32 fcMpr; // FC, points to offset in FC space for MacWord
90 : : // Default: 0xffffffff ( nothing )
91 : : // cbSED is 12 (decimal)), C (hex).
92 : : };
93 : :
94 : : // class WW8_WrPlc0 ist erstmal nur fuer Header / Footer-Positionen, d.h. es
95 : : // gibt keine inhaltstragende Struktur.
96 : 15 : class WW8_WrPlc0
97 : : {
98 : : private:
99 : : std::vector<sal_uLong> aPos; // PTRARR von CPs / FCs
100 : : sal_uLong nOfs;
101 : :
102 : : //No copying
103 : : WW8_WrPlc0(const WW8_WrPlc0&);
104 : : WW8_WrPlc0 &operator=(const WW8_WrPlc0&);
105 : : public:
106 : : WW8_WrPlc0( sal_uLong nOffset );
107 : 12 : sal_uInt16 Count() const { return aPos.size(); }
108 : : void Append( sal_uLong nStartCpOrFc );
109 : : void Write( SvStream& rStrm );
110 : : };
111 : :
112 : : //------------------------------------------------------------
113 : : // Styles
114 : : //------------------------------------------------------------
115 : :
116 : : #define WW8_RESERVED_SLOTS 15
117 : :
118 : : // GetId( SwCharFmt ) zur Benutzung im Text -> nil verboten,
119 : : // "Default Char Style" stattdessen
120 : 9 : sal_uInt16 MSWordExportBase::GetId( const SwCharFmt& rFmt ) const
121 : : {
122 : 9 : sal_uInt16 nRet = pStyles->GetSlot( rFmt );
123 [ + - ]: 9 : return ( nRet != 0x0fff ) ? nRet : 10; // Default Char Style
124 : : }
125 : :
126 : : // GetId( SwTxtFmtColl ) zur Benutzung an TextNodes -> nil verboten,
127 : : // "Standard" stattdessen
128 : 300 : sal_uInt16 MSWordExportBase::GetId( const SwTxtFmtColl& rColl ) const
129 : : {
130 : 300 : sal_uInt16 nRet = pStyles->GetSlot( rColl );
131 [ + - ]: 300 : return ( nRet != 0xfff ) ? nRet : 0; // Default TxtFmtColl
132 : : }
133 : :
134 : :
135 : :
136 : : //typedef pFmtT
137 : 144 : MSWordStyles::MSWordStyles( MSWordExportBase& rExport )
138 : 144 : : m_rExport( rExport )
139 : : {
140 : : // if exist any Foot-/End-Notes then get from the EndNoteInfo struct
141 : : // the CharFormats. They will create it!
142 [ + + ]: 144 : if ( !m_rExport.pDoc->GetFtnIdxs().empty() )
143 : : {
144 : 3 : m_rExport.pDoc->GetEndNoteInfo().GetAnchorCharFmt( *m_rExport.pDoc );
145 : 3 : m_rExport.pDoc->GetEndNoteInfo().GetCharFmt( *m_rExport.pDoc );
146 : 3 : m_rExport.pDoc->GetFtnInfo().GetAnchorCharFmt( *m_rExport.pDoc );
147 : 3 : m_rExport.pDoc->GetFtnInfo().GetCharFmt( *m_rExport.pDoc );
148 : : }
149 : 144 : sal_uInt16 nAlloc = WW8_RESERVED_SLOTS + m_rExport.pDoc->GetCharFmts()->size() - 1 +
150 : 144 : m_rExport.pDoc->GetTxtFmtColls()->size() - 1;
151 : :
152 : : // etwas grosszuegig ( bis zu 15 frei )
153 : 144 : pFmtA = new SwFmt*[ nAlloc ];
154 : 144 : memset( pFmtA, 0, nAlloc * sizeof( SwFmt* ) );
155 : :
156 : 144 : BuildStylesTable();
157 : 144 : }
158 : :
159 : 66 : MSWordStyles::~MSWordStyles()
160 : : {
161 [ + - ]: 66 : delete[] pFmtA;
162 : 66 : }
163 : :
164 : : // Sty_SetWWSlot() fuer Abhaengigkeiten der Styles -> nil ist erlaubt
165 : 2457 : sal_uInt16 MSWordStyles::GetSlot( const SwFmt& rFmt ) const
166 : : {
167 : : sal_uInt16 n;
168 [ + + ]: 37236 : for ( n = 0; n < nUsedSlots; n++ )
169 [ + + ]: 36999 : if ( pFmtA[n] == &rFmt )
170 : 2220 : return n;
171 : 2457 : return 0xfff; // 0xfff: WW: nil
172 : : }
173 : :
174 : 1074 : sal_uInt16 MSWordStyles::BuildGetSlot( const SwFmt& rFmt )
175 : : {
176 : : sal_uInt16 nRet;
177 [ + + + ]: 1074 : switch ( nRet = rFmt.GetPoolFmtId() )
178 : : {
179 : : case RES_POOLCOLL_STANDARD:
180 : 144 : nRet = 0;
181 : 144 : break;
182 : :
183 : : case RES_POOLCOLL_HEADLINE1:
184 : : case RES_POOLCOLL_HEADLINE2:
185 : : case RES_POOLCOLL_HEADLINE3:
186 : : case RES_POOLCOLL_HEADLINE4:
187 : : case RES_POOLCOLL_HEADLINE5:
188 : : case RES_POOLCOLL_HEADLINE6:
189 : : case RES_POOLCOLL_HEADLINE7:
190 : : case RES_POOLCOLL_HEADLINE8:
191 : : case RES_POOLCOLL_HEADLINE9:
192 : 9 : nRet -= RES_POOLCOLL_HEADLINE1-1;
193 : 9 : break;
194 : :
195 : : default:
196 : 921 : nRet = nUsedSlots++;
197 : 921 : break;
198 : : }
199 : 1074 : return nRet;
200 : : }
201 : :
202 : 1074 : sal_uInt16 MSWordStyles::GetWWId( const SwFmt& rFmt ) const
203 : : {
204 : 1074 : sal_uInt16 nRet = ww::stiUser; // User-Style als default
205 : 1074 : sal_uInt16 nPoolId = rFmt.GetPoolFmtId();
206 [ + + ]: 1074 : if( nPoolId == RES_POOLCOLL_STANDARD )
207 : 144 : nRet = 0;
208 [ + + ][ + + ]: 930 : else if( nPoolId >= RES_POOLCOLL_HEADLINE1 &&
209 : : nPoolId <= RES_POOLCOLL_HEADLINE9 )
210 : 9 : nRet = static_cast< sal_uInt16 >(nPoolId + 1 - RES_POOLCOLL_HEADLINE1);
211 [ + + ][ - + ]: 921 : else if( nPoolId >= RES_POOLCOLL_TOX_IDX1 &&
212 : : nPoolId <= RES_POOLCOLL_TOX_IDX3 )
213 : 0 : nRet = static_cast< sal_uInt16 >(nPoolId + 10 - RES_POOLCOLL_TOX_IDX1);
214 [ + + ][ + + ]: 921 : else if( nPoolId >= RES_POOLCOLL_TOX_CNTNT1 &&
215 : : nPoolId <= RES_POOLCOLL_TOX_CNTNT5 )
216 : 9 : nRet = static_cast< sal_uInt16 >(nPoolId + 19 - RES_POOLCOLL_TOX_CNTNT1);
217 [ + + ][ - + ]: 912 : else if( nPoolId >= RES_POOLCOLL_TOX_CNTNT6 &&
218 : : nPoolId <= RES_POOLCOLL_TOX_CNTNT9 )
219 : 0 : nRet = static_cast< sal_uInt16 >(nPoolId + 24 - RES_POOLCOLL_TOX_CNTNT6);
220 : : else
221 [ + - + + : 912 : switch( nPoolId )
- + - - -
+ - + - +
+ - - - -
+ + - + +
- + + - -
- - - + -
+ + + + -
- - - -
+ ]
222 : : {
223 : 3 : case RES_POOLCOLL_FOOTNOTE: nRet = 29; break;
224 : 0 : case RES_POOLCOLL_MARGINAL: nRet = 30; break;
225 : 3 : case RES_POOLCOLL_HEADER: nRet = 31; break;
226 : 6 : case RES_POOLCOLL_FOOTER: nRet = 32; break;
227 : 0 : case RES_POOLCOLL_TOX_IDXH: nRet = 33; break;
228 : 144 : case RES_POOLCOLL_LABEL: nRet = 34; break;
229 : 0 : case RES_POOLCOLL_LABEL_DRAWING: nRet = 35; break;
230 : 0 : case RES_POOLCOLL_JAKETADRESS: nRet = 36; break;
231 : 0 : case RES_POOLCOLL_SENDADRESS: nRet = 37; break;
232 : 3 : case RES_POOLCOLL_ENDNOTE: nRet = 43; break;
233 : 0 : case RES_POOLCOLL_TOX_AUTHORITIESH: nRet = 44; break;
234 : 3 : case RES_POOLCOLL_TOX_CNTNTH: nRet = 46; break;
235 : 0 : case RES_POOLCOLL_BUL_LEVEL1: nRet = 48; break;
236 : 144 : case RES_POOLCOLL_LISTS_BEGIN: nRet = 47; break;
237 : 3 : case RES_POOLCOLL_NUM_LEVEL1: nRet = 49; break;
238 : 0 : case RES_POOLCOLL_BUL_LEVEL2: nRet = 54; break;
239 : 0 : case RES_POOLCOLL_BUL_LEVEL3: nRet = 55; break;
240 : 0 : case RES_POOLCOLL_BUL_LEVEL4: nRet = 56; break;
241 : 0 : case RES_POOLCOLL_BUL_LEVEL5: nRet = 57; break;
242 : 3 : case RES_POOLCOLL_NUM_LEVEL2: nRet = 58; break;
243 : 3 : case RES_POOLCOLL_NUM_LEVEL3: nRet = 59; break;
244 : 0 : case RES_POOLCOLL_NUM_LEVEL4: nRet = 60; break;
245 : 3 : case RES_POOLCOLL_NUM_LEVEL5: nRet = 61; break;
246 : 3 : case RES_POOLCOLL_DOC_TITEL: nRet = 62; break;
247 : 0 : case RES_POOLCOLL_SIGNATURE: nRet = 64; break;
248 : 144 : case RES_POOLCOLL_TEXT: nRet = 66; break;
249 : 3 : case RES_POOLCOLL_TEXT_MOVE: nRet = 67; break;
250 : 0 : case RES_POOLCOLL_BUL_NONUM1: nRet = 68; break;
251 : 0 : case RES_POOLCOLL_BUL_NONUM2: nRet = 69; break;
252 : 0 : case RES_POOLCOLL_BUL_NONUM3: nRet = 70; break;
253 : 0 : case RES_POOLCOLL_BUL_NONUM4: nRet = 71; break;
254 : 0 : case RES_POOLCOLL_BUL_NONUM5: nRet = 72; break;
255 : 3 : case RES_POOLCOLL_DOC_SUBTITEL: nRet = 74; break;
256 : 0 : case RES_POOLCOLL_GREETING: nRet = 75; break;
257 : 3 : case RES_POOLCOLL_TEXT_IDENT: nRet = 77; break;
258 : :
259 : 3 : case RES_POOLCHR_FOOTNOTE_ANCHOR: nRet = 38; break;
260 : 3 : case RES_POOLCHR_ENDNOTE_ANCHOR: nRet = 42; break;
261 : 6 : case RES_POOLCHR_INET_NORMAL: nRet = 85; break;
262 : 0 : case RES_POOLCHR_INET_VISIT: nRet = 86; break;
263 : 0 : case RES_POOLCHR_HTML_STRONG: nRet = 87; break;
264 : 0 : case RES_POOLCHR_HTML_EMPHASIS: nRet = 88; break;
265 : 0 : case RES_POOLCHR_LINENUM: nRet = 40; break;
266 : 0 : case RES_POOLCHR_PAGENO: nRet = 41; break;
267 : : }
268 : 1074 : return nRet;
269 : : }
270 : :
271 : 144 : void MSWordStyles::BuildStylesTable()
272 : : {
273 : 144 : nUsedSlots = WW8_RESERVED_SLOTS; // soviele sind reserviert fuer
274 : : // Standard und HeadingX u.a.
275 : 144 : const SwCharFmts& rArr = *m_rExport.pDoc->GetCharFmts(); // erst CharFmt
276 : : // das Default-ZeichenStyle ( 0 ) wird nicht mit ausgegeben !
277 [ + + ]: 264 : for( sal_uInt16 n = 1; n < rArr.size(); n++ )
278 : : {
279 : 120 : SwCharFmt* pFmt = rArr[n];
280 : 120 : pFmtA[ BuildGetSlot( *pFmt ) ] = pFmt;
281 : : }
282 : :
283 : 144 : const SwTxtFmtColls& rArr2 = *m_rExport.pDoc->GetTxtFmtColls(); // dann TxtFmtColls
284 : : // das Default-TextStyle ( 0 ) wird nicht mit ausgegeben !
285 [ + + ]: 1098 : for( sal_uInt16 n = 1; n < rArr2.size(); n++ )
286 : : {
287 : 954 : SwTxtFmtColl* pFmt = rArr2[n];
288 : 954 : pFmtA[ BuildGetSlot( *pFmt ) ] = pFmt;
289 : : }
290 : 144 : }
291 : :
292 : : /// For WW8 only - extend pO so that the size of pTableStrm is even.
293 : 567 : static void impl_SkipOdd( ww::bytes* pO, sal_Size nTableStrmTell )
294 : : {
295 [ + + ]: 567 : if ( ( nTableStrmTell + pO->size() ) & 1 ) // Start auf gerader
296 [ + - ]: 300 : pO->push_back( (sal_uInt8)0 ); // Adresse
297 : 567 : }
298 : :
299 : 219 : void WW8AttributeOutput::EndStyle()
300 : : {
301 : 219 : impl_SkipOdd( m_rWW8Export.pO, m_rWW8Export.pTableStrm->Tell() );
302 : :
303 : 219 : short nLen = m_rWW8Export.pO->size() - 2; // Laenge des Styles
304 : 219 : sal_uInt8* p = &m_rWW8Export.pO->front() + nPOPosStdLen1;
305 : 219 : ShortToSVBT16( nLen, p ); // nachtragen
306 : 219 : p = &m_rWW8Export.pO->front() + nPOPosStdLen2;
307 : 219 : ShortToSVBT16( nLen, p ); // dito
308 : :
309 : 219 : m_rWW8Export.pTableStrm->Write( m_rWW8Export.pO->data(), m_rWW8Export.pO->size() ); // ins File damit
310 : 219 : m_rWW8Export.pO->clear();
311 : 219 : }
312 : :
313 : 219 : void WW8AttributeOutput::StartStyle( const String& rName, bool bPapFmt, sal_uInt16 nWwBase,
314 : : sal_uInt16 nWwNext, sal_uInt16 nWwId, sal_uInt16 /*nId*/, bool bAutoUpdate )
315 : : {
316 : : sal_uInt8 aWW8_STD[ sizeof( WW8_STD ) ];
317 : 219 : sal_uInt8* pData = aWW8_STD;
318 : 219 : memset( &aWW8_STD, 0, sizeof( WW8_STD ) );
319 : :
320 : 219 : sal_uInt16 nBit16 = 0x1000; // fInvalHeight
321 : 219 : nBit16 |= (ww::stiNil & nWwId);
322 : 219 : Set_UInt16( pData, nBit16 );
323 : :
324 : 219 : nBit16 = nWwBase << 4; // istdBase
325 [ + + ]: 219 : nBit16 |= bPapFmt ? 1 : 2; // sgc
326 : 219 : Set_UInt16( pData, nBit16 );
327 : :
328 : 219 : nBit16 = nWwNext << 4; // istdNext
329 [ + + ]: 219 : nBit16 |= bPapFmt ? 2 : 1; // cupx
330 : 219 : Set_UInt16( pData, nBit16 );
331 : :
332 : 219 : pData += sizeof( sal_uInt16 ); // bchUpe
333 : :
334 [ + - ]: 219 : if( m_rWW8Export.bWrtWW8 )
335 : : {
336 [ - + ]: 219 : nBit16 = bAutoUpdate ? 1 : 0; // fAutoRedef : 1
337 : 219 : Set_UInt16( pData, nBit16 );
338 : : //-------- jetzt neu:
339 : : // ab Ver8 gibts zwei Felder mehr:
340 : : //sal_uInt16 fHidden : 1; /* hidden from UI? */
341 : : //sal_uInt16 : 14; /* unused bits */
342 : : }
343 : :
344 : :
345 : : sal_uInt16 nLen = static_cast< sal_uInt16 >( ( pData - aWW8_STD ) + 1 +
346 [ + - ]: 219 : ((m_rWW8Export.bWrtWW8 ? 2 : 1 ) * (rName.Len() + 1)) ); // vorlaeufig
347 : :
348 : 219 : nPOPosStdLen1 = m_rWW8Export.pO->size(); // Adr1 zum nachtragen der Laenge
349 : :
350 [ + - ]: 219 : SwWW8Writer::InsUInt16( *m_rWW8Export.pO, nLen );
351 [ + - ]: 219 : m_rWW8Export.pO->insert( m_rWW8Export.pO->end(), aWW8_STD, pData );
352 : :
353 : 219 : nPOPosStdLen2 = nPOPosStdLen1 + 8; // Adr2 zum nachtragen von "end of upx"
354 : :
355 : : // Namen schreiben
356 [ + - ]: 219 : if( m_rWW8Export.bWrtWW8 )
357 : : {
358 [ + - ]: 219 : SwWW8Writer::InsUInt16( *m_rWW8Export.pO, rName.Len() ); // Laenge
359 [ + - ]: 219 : SwWW8Writer::InsAsString16( *m_rWW8Export.pO, rName );
360 : : }
361 : : else
362 : : {
363 [ # # ]: 0 : m_rWW8Export.pO->push_back( (sal_uInt8)rName.Len() ); // Laenge
364 [ # # ]: 0 : SwWW8Writer::InsAsString8( *m_rWW8Export.pO, rName, RTL_TEXTENCODING_MS_1252 );
365 : : }
366 [ + - ]: 219 : m_rWW8Export.pO->push_back( (sal_uInt8)0 ); // Trotz P-String 0 am Ende!
367 : 219 : }
368 : :
369 : 288 : void MSWordStyles::SetStyleDefaults( const SwFmt& rFmt, bool bPap )
370 : : {
371 : 288 : const SwModify* pOldMod = m_rExport.pOutFmtNode;
372 : 288 : m_rExport.pOutFmtNode = &rFmt;
373 : : bool aFlags[ static_cast< sal_uInt16 >(RES_FRMATR_END) - RES_CHRATR_BEGIN ];
374 : : sal_uInt16 nStt, nEnd, n;
375 [ + + ]: 288 : if( bPap )
376 : 144 : nStt = RES_PARATR_BEGIN, nEnd = RES_FRMATR_END;
377 : : else
378 : 144 : nStt = RES_CHRATR_BEGIN, nEnd = RES_TXTATR_END;
379 : :
380 : : // dynamic defaults
381 : 288 : const SfxItemPool& rPool = *rFmt.GetAttrSet().GetPool();
382 [ + + ]: 17712 : for( n = nStt; n < nEnd; ++n )
383 [ + - ]: 17424 : aFlags[ n - RES_CHRATR_BEGIN ] = 0 != rPool.GetPoolDefaultItem( n );
384 : :
385 : : // static defaults, that differs between WinWord and SO
386 [ + + ]: 288 : if( bPap )
387 : : {
388 : 144 : aFlags[ static_cast< sal_uInt16 >(RES_PARATR_WIDOWS) - RES_CHRATR_BEGIN ] = 1;
389 : 144 : aFlags[ static_cast< sal_uInt16 >(RES_PARATR_HYPHENZONE) - RES_CHRATR_BEGIN ] = 1;
390 : : }
391 : : else
392 : : {
393 : 144 : aFlags[ RES_CHRATR_FONTSIZE - RES_CHRATR_BEGIN ] = 1;
394 : 144 : aFlags[ RES_CHRATR_LANGUAGE - RES_CHRATR_BEGIN ] = 1;
395 : : }
396 : :
397 : 288 : const SfxItemSet* pOldI = m_rExport.GetCurItemSet();
398 : 288 : m_rExport.SetCurItemSet( &rFmt.GetAttrSet() );
399 : :
400 : 288 : const bool* pFlags = aFlags + ( nStt - RES_CHRATR_BEGIN );
401 [ + + ]: 17712 : for ( n = nStt; n < nEnd; ++n, ++pFlags )
402 : : {
403 [ + + ][ + - ]: 19839 : if ( *pFlags && !m_rExport.ignoreAttributeForStyles( n )
[ + - ][ + + ]
[ + + ]
404 [ + - ]: 2415 : && SFX_ITEM_SET != rFmt.GetItemState(n, false))
405 : : {
406 : : //If we are a character property then see if it is one of the
407 : : //western/asian ones that must be collapsed together for export to
408 : : //word. If so default to the western varient.
409 [ + + ][ + + ]: 2865 : if ( bPap || m_rExport.CollapseScriptsforWordOk(
[ + + ]
410 [ + - ]: 1092 : i18n::ScriptType::LATIN, n) )
411 : : {
412 [ + - ][ + - ]: 1677 : m_rExport.AttrOutput().OutputItem( rFmt.GetFmtAttr( n, true ) );
[ + - ]
413 : : }
414 : : }
415 : : }
416 : :
417 : 288 : m_rExport.SetCurItemSet( pOldI );
418 : 288 : m_rExport.pOutFmtNode = pOldMod;
419 : 288 : }
420 : :
421 : 348 : void WW8AttributeOutput::StartStyleProperties( bool bParProp, sal_uInt16 nStyle )
422 : : {
423 : 348 : impl_SkipOdd( m_rWW8Export.pO, m_rWW8Export.pTableStrm->Tell() );
424 : :
425 [ + + ]: 348 : sal_uInt16 nLen = ( bParProp ) ? 2 : 0; // Default-Laenge
426 : 348 : m_nStyleLenPos = m_rWW8Export.pO->size(); // Laenge zum Nachtragen
427 : : // Keinen Pointer merken, da sich bei
428 : : // _grow der Pointer aendert !
429 : :
430 : 348 : SwWW8Writer::InsUInt16( *m_rWW8Export.pO, nLen ); // Style-Len
431 : :
432 : 348 : m_nStyleStartSize = m_rWW8Export.pO->size();
433 : :
434 [ + + ]: 348 : if ( bParProp )
435 : 129 : SwWW8Writer::InsUInt16( *m_rWW8Export.pO, nStyle ); // Style-Nummer
436 : 348 : }
437 : :
438 : 2028 : void MSWordStyles::WriteProperties( const SwFmt* pFmt, bool bParProp, sal_uInt16 nPos,
439 : : bool bInsDefCharSiz )
440 : : {
441 : 2028 : m_rExport.AttrOutput().StartStyleProperties( bParProp, nPos );
442 : :
443 : : OSL_ENSURE( m_rExport.pCurrentStyle == NULL, "Current style not NULL" ); // set current style before calling out
444 : 2028 : m_rExport.pCurrentStyle = pFmt;
445 : :
446 : 2028 : m_rExport.OutputFormat( *pFmt, bParProp, !bParProp );
447 : :
448 : : OSL_ENSURE( m_rExport.pCurrentStyle == pFmt, "current style was changed" );
449 : : // reset current style...
450 : 2028 : m_rExport.pCurrentStyle = NULL;
451 : :
452 [ + + ]: 2028 : if ( bInsDefCharSiz ) // nicht abgeleitet v. anderem Style
453 : 288 : SetStyleDefaults( *pFmt, bParProp );
454 : :
455 : 2028 : m_rExport.AttrOutput().EndStyleProperties( bParProp );
456 : 2028 : }
457 : :
458 : 348 : void WW8AttributeOutput::EndStyleProperties( bool /*bParProp*/ )
459 : : {
460 : 348 : sal_uInt16 nLen = m_rWW8Export.pO->size() - m_nStyleStartSize;
461 : 348 : sal_uInt8* pUpxLen = &m_rWW8Export.pO->front() + m_nStyleLenPos; // Laenge zum Nachtragen
462 : 348 : ShortToSVBT16( nLen, pUpxLen ); // Default-Laenge eintragen
463 : 348 : }
464 : :
465 : 1074 : void MSWordStyles::GetStyleData( SwFmt* pFmt, bool& bFmtColl, sal_uInt16& nBase, sal_uInt16& nNext )
466 : : {
467 [ + + ][ + + ]: 1074 : bFmtColl = pFmt->Which() == RES_TXTFMTCOLL || pFmt->Which() == RES_CONDTXTFMTCOLL;
468 : :
469 : : // Default: none
470 : 1074 : nBase = 0xfff;
471 : :
472 : : // Derived from?
473 [ + - ]: 1074 : if ( !pFmt->IsDefault() )
474 : 1074 : nBase = GetSlot( *pFmt->DerivedFrom() );
475 : :
476 : : SwFmt* pNext;
477 [ + + ]: 1074 : if ( bFmtColl )
478 : 954 : pNext = &((SwTxtFmtColl*)pFmt)->GetNextTxtFmtColl();
479 : : else
480 : 120 : pNext = pFmt; // CharFmt: next CharFmt == self
481 : :
482 : 1074 : nNext = GetSlot( *pNext );
483 : 1074 : }
484 : :
485 : 117 : void WW8AttributeOutput::DefaultStyle( sal_uInt16 nStyle )
486 : : {
487 [ + + ]: 117 : if ( nStyle == 10 ) // Default Char-Style ( nur WW )
488 : : {
489 [ + - ]: 9 : if ( m_rWW8Export.bWrtWW8 )
490 : : {
491 : : static sal_uInt8 aDefCharSty[] = {
492 : : 0x42, 0x00,
493 : : 0x41, 0x40, 0xF2, 0xFF, 0xA1, 0x00, 0x42, 0x00,
494 : : 0x00, 0x00, 0x19, 0x00, 0x41, 0x00, 0x62, 0x00,
495 : : 0x73, 0x00, 0x61, 0x00, 0x74, 0x00, 0x7A, 0x00,
496 : : 0x2D, 0x00, 0x53, 0x00, 0x74, 0x00, 0x61, 0x00,
497 : : 0x6E, 0x00, 0x64, 0x00, 0x61, 0x00, 0x72, 0x00,
498 : : 0x64, 0x00, 0x73, 0x00, 0x63, 0x00, 0x68, 0x00,
499 : : 0x72, 0x00, 0x69, 0x00, 0x66, 0x00, 0x74, 0x00,
500 : : 0x61, 0x00, 0x72, 0x00, 0x74, 0x00, 0x00, 0x00,
501 : : 0x00, 0x00 };
502 : 9 : m_rWW8Export.pTableStrm->Write( &aDefCharSty, sizeof( aDefCharSty ) );
503 : : }
504 : : else
505 : : {
506 : : static sal_uInt8 aDefCharSty[] = {
507 : : 0x26, 0x00,
508 : : 0x41, 0x40, 0xF2, 0xFF, 0xA1, 0x00, 0x26, 0x00,
509 : : 0x19, 0x41, 0x62, 0x73, 0x61, 0x74, 0x7A, 0x2D,
510 : : 0x53, 0x74, 0x61, 0x6E, 0x64, 0x61, 0x72, 0x64,
511 : : 0x73, 0x63, 0x68, 0x72, 0x69, 0x66, 0x74, 0x61,
512 : : 0x72, 0x74, 0x00, 0x00, 0x00, 0x00 };
513 : 0 : m_rWW8Export.pTableStrm->Write( &aDefCharSty, sizeof( aDefCharSty ) );
514 : : }
515 : : }
516 : : else
517 : : {
518 : 108 : sal_uInt16 n = 0;
519 [ + - ]: 108 : m_rWW8Export.pTableStrm->Write( &n , 2 ); // leerer Style
520 : : }
521 : 117 : }
522 : :
523 : : // OutputStyle geht fuer TxtFmtColls und CharFmts
524 : 3081 : void MSWordStyles::OutputStyle( SwFmt* pFmt, sal_uInt16 nPos )
525 : : {
526 [ + + ]: 3081 : if ( !pFmt )
527 : 2007 : m_rExport.AttrOutput().DefaultStyle( nPos );
528 : : else
529 : : {
530 : : bool bFmtColl;
531 : : sal_uInt16 nBase, nWwNext;
532 : :
533 : 1074 : GetStyleData( pFmt, bFmtColl, nBase, nWwNext );
534 : :
535 [ + - ]: 1074 : String aName = pFmt->GetName();
536 [ + - ][ + + ]: 1074 : if ( aName.EqualsAscii( "Default" ) )
537 [ + - ]: 144 : aName = rtl::OUString("Normal");
538 : :
539 [ + - ]: 1074 : m_rExport.AttrOutput().StartStyle( aName, bFmtColl,
540 : 1074 : nBase, nWwNext, GetWWId( *pFmt ), nPos,
541 [ + - ]: 2148 : pFmt->IsAutoUpdateFmt() );
542 : :
543 [ + + ]: 1074 : if ( bFmtColl )
544 [ + - ]: 954 : WriteProperties( pFmt, true, nPos, nBase==0xfff ); // UPX.papx
545 : :
546 [ + + ][ + + ]: 1074 : WriteProperties( pFmt, false, nPos, bFmtColl && nBase==0xfff ); // UPX.chpx
[ + - ]
547 : :
548 [ + - ][ + - ]: 1074 : m_rExport.AttrOutput().EndStyle();
[ + - ]
549 : : }
550 : 3081 : }
551 : :
552 : 9 : void WW8AttributeOutput::StartStyles()
553 : : {
554 : 9 : WW8Fib& rFib = *m_rWW8Export.pFib;
555 : :
556 : 9 : sal_uLong nCurPos = m_rWW8Export.pTableStrm->Tell();
557 [ - + ]: 9 : if ( nCurPos & 1 ) // Start auf gerader
558 : : {
559 : 0 : *m_rWW8Export.pTableStrm << (char)0; // Adresse
560 : 0 : ++nCurPos;
561 : : }
562 : 9 : rFib.fcStshfOrig = rFib.fcStshf = nCurPos;
563 : 9 : m_nStyAnzPos = nCurPos + 2; // Anzahl wird nachgetragen
564 : :
565 [ + - ]: 9 : if ( m_rWW8Export.bWrtWW8 )
566 : : {
567 : : static sal_uInt8 aStShi[] = {
568 : : 0x12, 0x00,
569 : : 0x0F, 0x00, 0x0A, 0x00, 0x01, 0x00, 0x5B, 0x00,
570 : : 0x0F, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
571 : : 0x00, 0x00 };
572 : :
573 : 9 : m_rWW8Export.pTableStrm->Write( &aStShi, sizeof( aStShi ) );
574 : : }
575 : : else
576 : : {
577 : : static sal_uInt8 aStShi[] = {
578 : : 0x0E, 0x00,
579 : : 0x0F, 0x00, 0x08, 0x00, 0x01, 0x00, 0x4B, 0x00,
580 : : 0x0F, 0x00, 0x00, 0x00, 0x00, 0x00 };
581 : 0 : m_rWW8Export.pTableStrm->Write( &aStShi, sizeof( aStShi ) );
582 : : }
583 : 9 : }
584 : :
585 : 9 : void WW8AttributeOutput::EndStyles( sal_uInt16 nNumberOfStyles )
586 : : {
587 : 9 : WW8Fib& rFib = *m_rWW8Export.pFib;
588 : :
589 : 9 : rFib.lcbStshfOrig = rFib.lcbStshf = m_rWW8Export.pTableStrm->Tell() - rFib.fcStshf;
590 : 9 : SwWW8Writer::WriteShort( *m_rWW8Export.pTableStrm, m_nStyAnzPos, nNumberOfStyles );
591 : 9 : }
592 : :
593 : 144 : void MSWordStyles::OutputStylesTable()
594 : : {
595 : 144 : m_rExport.bStyDef = true;
596 : :
597 : 144 : m_rExport.AttrOutput().StartStyles();
598 : :
599 : : sal_uInt16 n;
600 [ + + ]: 3225 : for ( n = 0; n < nUsedSlots; n++ )
601 : 3081 : OutputStyle( pFmtA[n], n );
602 : :
603 : 144 : m_rExport.AttrOutput().EndStyles( nUsedSlots );
604 : :
605 : 144 : m_rExport.bStyDef = false;
606 : 144 : }
607 : :
608 : : //---------------------------------------------------------------------------
609 : : // Fonts
610 : : //---------------------------------------------------------------------------
611 : 2460 : wwFont::wwFont(const String &rFamilyName, FontPitch ePitch, FontFamily eFamily,
612 [ + - ]: 2460 : rtl_TextEncoding eChrSet, bool bWrtWW8) : mbAlt(false), mbWrtWW8(bWrtWW8), mePitch(ePitch), meFamily(eFamily), meChrSet(eChrSet)
613 : : {
614 [ + - ]: 2460 : FontMapExport aResult(rFamilyName);
615 [ + - ]: 2460 : msFamilyNm = aResult.msPrimary;
616 [ + - ]: 2460 : msAltNm = aResult.msSecondary;
617 [ + + ][ + - ]: 3354 : if (msAltNm.Len() && msAltNm != msFamilyNm &&
[ + - + - ]
[ + + ]
618 : 894 : (msFamilyNm.Len() + msAltNm.Len() + 2 <= 65) )
619 : : {
620 : : //max size of szFfn in 65 chars
621 : 894 : mbAlt = true;
622 : : }
623 : :
624 : 2460 : memset(maWW8_FFN, 0, sizeof(maWW8_FFN));
625 : :
626 [ + - ]: 2460 : if (bWrtWW8)
627 : : {
628 : 2460 : maWW8_FFN[0] = (sal_uInt8)( 6 - 1 + 0x22 + ( 2 * ( 1 + msFamilyNm.Len() ) ));
629 [ + + ]: 2460 : if (mbAlt)
630 : 894 : maWW8_FFN[0] = static_cast< sal_uInt8 >(maWW8_FFN[0] + 2 * ( 1 + msAltNm.Len()));
631 : : }
632 : : else
633 : : {
634 : 0 : maWW8_FFN[0] = (sal_uInt8)( 6 - 1 + 1 + msFamilyNm.Len() );
635 [ # # ]: 0 : if (mbAlt)
636 : 0 : maWW8_FFN[0] = static_cast< sal_uInt8 >(maWW8_FFN[0] + 1 + msAltNm.Len());
637 : : }
638 : :
639 : 2460 : sal_uInt8 aB = 0;
640 [ + - + ]: 2460 : switch(ePitch)
641 : : {
642 : : case PITCH_VARIABLE:
643 : 717 : aB |= 2; // aF.prg = 2
644 : 717 : break;
645 : : case PITCH_FIXED:
646 : 0 : aB |= 1;
647 : 0 : break;
648 : : default: // aF.prg = 0 : DEFAULT_PITCH (windows.h)
649 : 1743 : break;
650 : : }
651 : 2460 : aB |= 1 << 2; // aF.fTrueType = 1; weiss ich nicht besser;
652 : :
653 [ + + + - : 2460 : switch(eFamily)
- + ]
654 : : {
655 : : case FAMILY_ROMAN:
656 : 1056 : aB |= 1 << 4; // aF.ff = 1;
657 : 1056 : break;
658 : : case FAMILY_SWISS:
659 : 360 : aB |= 2 << 4; // aF.ff = 2;
660 : 360 : break;
661 : : case FAMILY_MODERN:
662 : 12 : aB |= 3 << 4; // aF.ff = 3;
663 : 12 : break;
664 : : case FAMILY_SCRIPT:
665 : 0 : aB |= 4 << 4; // aF.ff = 4;
666 : 0 : break;
667 : : case FAMILY_DECORATIVE:
668 : 0 : aB |= 5 << 4; // aF.ff = 5;
669 : 0 : break;
670 : : default: // aF.ff = 0; FF_DONTCARE (windows.h)
671 : 1032 : break;
672 : : }
673 : 2460 : maWW8_FFN[1] = aB;
674 : :
675 : 2460 : ShortToSVBT16( 400, &maWW8_FFN[2] ); // weiss ich nicht besser
676 : : // 400 == FW_NORMAL (windows.h)
677 : : //
678 : : //#i61927# For unicode fonts like Arial Unicode, Word 97+ sets the chs
679 : : //to SHIFTJIS presumably to capture that it's a multi-byte encoding font
680 : : //but Word95 doesn't do this, and sets it to 0 (ANSI), so we should do the
681 : : //same
682 : : maWW8_FFN[4] = bWrtWW8 ?
683 : 2460 : sw::ms::rtl_TextEncodingToWinCharset(eChrSet) :
684 [ + - ][ # # ]: 2460 : rtl_getBestWindowsCharsetFromTextEncoding(eChrSet);
[ + - ]
685 : :
686 [ + + ]: 2460 : if (mbAlt)
687 [ + - ]: 2460 : maWW8_FFN[5] = static_cast< sal_uInt8 >(msFamilyNm.Len() + 1);
688 : 2460 : }
689 : :
690 : 96 : bool wwFont::Write(SvStream *pTableStrm) const
691 : : {
692 : 96 : pTableStrm->Write(maWW8_FFN, sizeof(maWW8_FFN)); // fixed part
693 [ + - ]: 96 : if (mbWrtWW8)
694 : : {
695 : : // ab Ver8 sind folgende beiden Felder eingeschoben,
696 : : // werden von uns ignoriert.
697 : : //char panose[ 10 ]; // 0x6 PANOSE
698 : : //char fs[ 24 ]; // 0x10 FONTSIGNATURE
699 : 96 : SwWW8Writer::FillCount(*pTableStrm, 0x22);
700 : 96 : SwWW8Writer::WriteString16(*pTableStrm, msFamilyNm, true);
701 [ + + ]: 96 : if (mbAlt)
702 : 21 : SwWW8Writer::WriteString16(*pTableStrm, msAltNm, true);
703 : : }
704 : : else
705 : : {
706 : : SwWW8Writer::WriteString8(*pTableStrm, msFamilyNm, true,
707 : 0 : RTL_TEXTENCODING_MS_1252);
708 [ # # ]: 0 : if (mbAlt)
709 : : {
710 : : SwWW8Writer::WriteString8( *pTableStrm, msAltNm, true,
711 : 0 : RTL_TEXTENCODING_MS_1252);
712 : : }
713 : : }
714 : 96 : return true;
715 : : }
716 : :
717 : 285 : void wwFont::WriteDocx( const DocxAttributeOutput* rAttrOutput ) const
718 : : {
719 : : // no font embedding, panose id, subsetting, ... implemented
720 : :
721 : 285 : rAttrOutput->StartFont( msFamilyNm );
722 : :
723 [ + + ]: 285 : if ( mbAlt )
724 : 102 : rAttrOutput->FontAlternateName( msAltNm );
725 : 285 : rAttrOutput->FontCharset( sw::ms::rtl_TextEncodingToWinCharset( meChrSet ), meChrSet );
726 : 285 : rAttrOutput->FontFamilyType( meFamily );
727 : 285 : rAttrOutput->FontPitchType( mePitch );
728 : :
729 : 285 : rAttrOutput->EndFont();
730 : 285 : }
731 : :
732 : 705 : void wwFont::WriteRtf( const RtfAttributeOutput* rAttrOutput ) const
733 : : {
734 : 705 : rAttrOutput->FontFamilyType( meFamily, *this );
735 : 705 : rAttrOutput->FontPitchType( mePitch );
736 : 705 : rAttrOutput->FontCharset( rtl_getBestWindowsCharsetFromTextEncoding( meChrSet ) );
737 : 705 : rAttrOutput->StartFont( msFamilyNm );
738 [ + + ]: 705 : if ( mbAlt )
739 : 234 : rAttrOutput->FontAlternateName( msAltNm );
740 : 705 : rAttrOutput->EndFont();
741 : 705 : }
742 : :
743 : 16983 : bool operator<(const wwFont &r1, const wwFont &r2)
744 : : {
745 : 16983 : int nRet = memcmp(r1.maWW8_FFN, r2.maWW8_FFN, sizeof(r1.maWW8_FFN));
746 [ + + ]: 16983 : if (nRet == 0)
747 : : {
748 : 5055 : StringCompare eRet = r1.msFamilyNm.CompareTo(r2.msFamilyNm);
749 [ + + ]: 5055 : if (eRet == COMPARE_EQUAL)
750 : 4158 : eRet = r1.msAltNm.CompareTo(r2.msAltNm);
751 : 5055 : nRet = eRet;
752 : : }
753 : 16983 : return nRet < 0;
754 : : }
755 : :
756 : :
757 : 3165 : sal_uInt16 wwFontHelper::GetId(const wwFont &rFont)
758 : : {
759 : : sal_uInt16 nRet;
760 [ + - ]: 3165 : ::std::map<wwFont, sal_uInt16>::const_iterator aIter = maFonts.find(rFont);
761 [ + + ]: 3165 : if (aIter != maFonts.end())
762 : 2079 : nRet = aIter->second;
763 : : else
764 : : {
765 : 1086 : nRet = static_cast< sal_uInt16 >(maFonts.size());
766 [ + - ]: 1086 : maFonts[rFont] = nRet;
767 : : }
768 : 3165 : return nRet;
769 : : }
770 : :
771 : 144 : void wwFontHelper::InitFontTable(bool bWrtWW8,const SwDoc& rDoc)
772 : : {
773 : 144 : mbWrtWW8 = bWrtWW8;
774 : :
775 : : GetId(wwFont(rtl::OUString("Times New Roman"), PITCH_VARIABLE,
776 [ + - ][ + - ]: 144 : FAMILY_ROMAN, RTL_TEXTENCODING_MS_1252,bWrtWW8));
[ + - ][ + - ]
[ + - ]
777 : :
778 : : GetId(wwFont(rtl::OUString("Symbol"), PITCH_VARIABLE, FAMILY_ROMAN,
779 [ + - ][ + - ]: 144 : RTL_TEXTENCODING_SYMBOL,bWrtWW8));
[ + - ][ + - ]
[ + - ]
780 : :
781 : : GetId(wwFont(rtl::OUString("Arial"), PITCH_VARIABLE, FAMILY_SWISS,
782 [ + - ][ + - ]: 144 : RTL_TEXTENCODING_MS_1252,bWrtWW8));
[ + - ][ + - ]
[ + - ]
783 : :
784 [ + - ]: 144 : const SvxFontItem* pFont = (const SvxFontItem*)GetDfltAttr(RES_CHRATR_FONT);
785 : :
786 : 144 : GetId(wwFont(pFont->GetFamilyName(), pFont->GetPitch(),
787 [ + - ][ + - ]: 288 : pFont->GetFamily(), pFont->GetCharSet(),bWrtWW8));
[ + - ]
788 : :
789 : 144 : const SfxItemPool& rPool = rDoc.GetAttrPool();
790 [ + - ][ + - ]: 144 : if (0 != (pFont = (const SvxFontItem*)rPool.GetPoolDefaultItem(RES_CHRATR_FONT)))
791 : : {
792 : 144 : GetId(wwFont(pFont->GetFamilyName(), pFont->GetPitch(),
793 [ + - ][ + - ]: 288 : pFont->GetFamily(), pFont->GetCharSet(),bWrtWW8));
[ + - ]
794 : : }
795 : :
796 [ + + ]: 144 : if (!bLoadAllFonts)
797 : 144 : return;
798 : :
799 : 78 : const sal_uInt16 aTypes[] = { RES_CHRATR_FONT, RES_CHRATR_CJK_FONT, RES_CHRATR_CTL_FONT, 0 };
800 [ + + ]: 378 : for (const sal_uInt16* pId = aTypes; *pId; ++pId)
801 : : {
802 [ + - ]: 234 : sal_uInt32 const nMaxItem = rPool.GetItemCount2( *pId );
803 [ + + ]: 711 : for (sal_uInt32 nGet = 0; nGet < nMaxItem; ++nGet)
804 : : {
805 [ + - ]: 477 : pFont = (const SvxFontItem*)rPool.GetItem2( *pId, nGet );
806 [ + + ]: 477 : if (0 != pFont)
807 : : {
808 : 387 : GetId(wwFont(pFont->GetFamilyName(), pFont->GetPitch(),
809 [ + - ][ + - ]: 774 : pFont->GetFamily(), pFont->GetCharSet(),bWrtWW8));
[ + - ]
810 : : }
811 : : }
812 : : }
813 : : }
814 : :
815 : 0 : sal_uInt16 wwFontHelper::GetId(const Font& rFont)
816 : : {
817 [ # # ]: 0 : wwFont aFont(rFont.GetName(), rFont.GetPitch(), rFont.GetFamily(),
818 [ # # ][ # # ]: 0 : rFont.GetCharSet(), mbWrtWW8);
[ # # ][ # # ]
819 [ # # ][ # # ]: 0 : return GetId(aFont);
820 : : }
821 : :
822 : 1353 : sal_uInt16 wwFontHelper::GetId(const SvxFontItem& rFont)
823 : : {
824 : 1353 : wwFont aFont(rFont.GetFamilyName(), rFont.GetPitch(), rFont.GetFamily(),
825 [ + - ]: 2706 : rFont.GetCharSet(), mbWrtWW8);
826 [ + - ][ + - ]: 1353 : return GetId(aFont);
827 : : }
828 : :
829 : 144 : ::std::vector< const wwFont* > wwFontHelper::AsVector() const
830 : : {
831 [ + - ]: 144 : ::std::vector<const wwFont *> aFontList( maFonts.size() );
832 : :
833 : : typedef ::std::map<wwFont, sal_uInt16>::const_iterator myiter;
834 : 144 : myiter aEnd = maFonts.end();
835 [ + + ]: 1230 : for ( myiter aIter = maFonts.begin(); aIter != aEnd; ++aIter )
836 : 1086 : aFontList[aIter->second] = &aIter->first;
837 : :
838 : 144 : return aFontList;
839 : : }
840 : :
841 : 9 : void wwFontHelper::WriteFontTable(SvStream *pTableStream, WW8Fib& rFib)
842 : : {
843 : 9 : rFib.fcSttbfffn = pTableStream->Tell();
844 : : /*
845 : : * Reserve some space to fill in the len after we know how big it is
846 : : */
847 [ + - ]: 9 : if (mbWrtWW8)
848 [ + - ]: 9 : SwWW8Writer::WriteLong(*pTableStream, 0);
849 : : else
850 [ # # ]: 0 : SwWW8Writer::WriteShort(*pTableStream, 0);
851 : :
852 : : /*
853 : : * Convert from fast insertion map to linear vector in the order that we
854 : : * want to write.
855 : : */
856 [ + - ]: 9 : ::std::vector<const wwFont *> aFontList( AsVector() );
857 : :
858 : : /*
859 : : * Write them all to pTableStream
860 : : */
861 : : ::std::for_each(aFontList.begin(), aFontList.end(),
862 [ + - ][ + - ]: 9 : ::std::bind2nd(::std::mem_fun(&wwFont::Write),pTableStream));
[ + - ]
863 : :
864 : : /*
865 : : * Write the position and len in the FIB
866 : : */
867 : 9 : rFib.lcbSttbfffn = pTableStream->Tell() - rFib.fcSttbfffn;
868 [ + - ]: 9 : if (mbWrtWW8)
869 [ + - ]: 9 : SwWW8Writer::WriteLong( *pTableStream, rFib.fcSttbfffn, maFonts.size());
870 : : else
871 : : {
872 : : SwWW8Writer::WriteShort( *pTableStream, rFib.fcSttbfffn,
873 [ # # ]: 0 : (sal_Int16)rFib.lcbSttbfffn );
874 : 9 : }
875 : 9 : }
876 : :
877 : 57 : void wwFontHelper::WriteFontTable( const DocxAttributeOutput& rAttrOutput )
878 : : {
879 [ + - ]: 57 : ::std::vector<const wwFont *> aFontList( AsVector() );
880 : :
881 : : ::std::for_each( aFontList.begin(), aFontList.end(),
882 [ + - ][ + - ]: 57 : ::std::bind2nd( ::std::mem_fun( &wwFont::WriteDocx ), &rAttrOutput ) );
[ + - ]
883 : 57 : }
884 : :
885 : 78 : void wwFontHelper::WriteFontTable( const RtfAttributeOutput& rAttrOutput )
886 : : {
887 [ + - ]: 78 : ::std::vector<const wwFont *> aFontList( AsVector() );
888 : :
889 : : ::std::for_each( aFontList.begin(), aFontList.end(),
890 [ + - ][ + - ]: 78 : ::std::bind2nd( ::std::mem_fun( &wwFont::WriteRtf ), &rAttrOutput ) );
[ + - ]
891 : 78 : }
892 : :
893 : :
894 : 15 : WW8_WrPlc0::WW8_WrPlc0( sal_uLong nOffset )
895 : 15 : : nOfs( nOffset )
896 : : {
897 : 15 : }
898 : :
899 : 138 : void WW8_WrPlc0::Append( sal_uLong nStartCpOrFc )
900 : : {
901 [ + - ]: 138 : aPos.push_back( nStartCpOrFc - nOfs );
902 : 138 : }
903 : :
904 : 12 : void WW8_WrPlc0::Write( SvStream& rStrm )
905 : : {
906 : 12 : std::vector<sal_uLong>::const_iterator iter;
907 [ + - ][ + - ]: 81 : for( iter = aPos.begin(); iter != aPos.end(); ++iter )
[ + - ][ + + ]
908 : : {
909 : : SVBT32 nP;
910 [ + - ]: 69 : UInt32ToSVBT32( *iter, nP );
911 [ + - ]: 69 : rStrm.Write( nP, 4 );
912 : : }
913 : 12 : }
914 : :
915 : : //------------------------------------------------------------------------------
916 : :
917 : : //------------------------------------------------------------------------------
918 : : // class MSWordSections : Uebersetzung PageDescs in Sections
919 : : // behandelt auch Header und Footer
920 : : //------------------------------------------------------------------------------
921 : :
922 : 144 : MSWordSections::MSWordSections( MSWordExportBase& rExport )
923 : 144 : : mbDocumentIsProtected( false )
924 : : {
925 : 144 : const SwSectionFmt *pFmt = 0;
926 [ + - ]: 144 : rExport.pAktPageDesc = &rExport.pDoc->GetPageDesc( 0 );
927 : :
928 : : const SfxPoolItem* pI;
929 [ + - ]: 144 : const SwNode* pNd = rExport.pCurPam->GetCntntNode();
930 [ + - ][ + - ]: 144 : const SfxItemSet* pSet = pNd ? &((SwCntntNode*)pNd)->GetSwAttrSet() : 0;
[ + - ]
931 : :
932 [ + - ][ + - ]: 144 : sal_uLong nRstLnNum = pSet ? ((SwFmtLineNumber&)pSet->Get( RES_LINENUMBER )).GetStartValue() : 0;
933 : :
934 [ + - ]: 144 : const SwTableNode* pTblNd = rExport.pCurPam->GetNode()->FindTableNode();
935 : : const SwSectionNode* pSectNd;
936 [ - + ]: 144 : if ( pTblNd )
937 : : {
938 : 0 : pSet = &pTblNd->GetTable().GetFrmFmt()->GetAttrSet();
939 : 0 : pNd = pTblNd;
940 : : }
941 [ + - ][ - + ]: 144 : else if ( 0 != ( pSectNd = pNd->FindSectionNode() ) )
942 : : {
943 [ # # # # ]: 0 : if ( TOX_HEADER_SECTION == pSectNd->GetSection().GetType() &&
[ # # ]
944 : 0 : pSectNd->StartOfSectionNode()->IsSectionNode() )
945 : : {
946 : 0 : pSectNd = pSectNd->StartOfSectionNode()->GetSectionNode();
947 : : }
948 : :
949 [ # # ]: 0 : if ( TOX_CONTENT_SECTION == pSectNd->GetSection().GetType() )
950 : : {
951 : 0 : pNd = pSectNd;
952 [ # # ]: 0 : rExport.pCurPam->GetPoint()->nNode = *pNd;
953 : : }
954 : :
955 [ # # ]: 0 : if ( CONTENT_SECTION == pSectNd->GetSection().GetType() )
956 : 0 : pFmt = pSectNd->GetSection().GetFmt();
957 : : }
958 : :
959 : : // Hole evtl. Pagedesc des 1. Nodes
960 [ + - ]: 414 : if ( pSet &&
[ + + + - ]
[ + + ]
961 [ + - ]: 144 : SFX_ITEM_ON == pSet->GetItemState( RES_PAGEDESC, true, &pI ) &&
962 : 126 : ( (SwFmtPageDesc*)pI )->GetPageDesc() )
963 : : {
964 [ + - ]: 126 : AppendSection( *(SwFmtPageDesc*)pI, *pNd, pFmt, nRstLnNum );
965 : : }
966 : : else
967 [ + - ]: 18 : AppendSection( rExport.pAktPageDesc, pFmt, nRstLnNum );
968 : 144 : }
969 : :
970 : 9 : WW8_WrPlcSepx::WW8_WrPlcSepx( MSWordExportBase& rExport )
971 : : : MSWordSections( rExport ),
972 : : pAttrs( 0 ),
973 : : pTxtPos( 0 ),
974 [ + - ]: 9 : bNoMoreSections( false )
975 : : {
976 : : // to be in sync with the AppendSection() call in the MSWordSections
977 : : // constructor
978 [ + - ]: 9 : aCps.push_back( 0 );
979 : 9 : }
980 : :
981 : 66 : MSWordSections::~MSWordSections()
982 : : {
983 [ - + ]: 123 : }
984 : :
985 : 9 : WW8_WrPlcSepx::~WW8_WrPlcSepx()
986 : : {
987 : 9 : sal_uInt16 nLen = aSects.size();
988 [ + - ]: 9 : if( pAttrs )
989 : : {
990 [ + + ]: 18 : while( nLen )
991 [ + - ]: 9 : delete[] pAttrs[ --nLen ].pData;
992 [ + - ]: 9 : delete[] pAttrs;
993 : : }
994 [ + - ]: 9 : delete pTxtPos;
995 [ - + ]: 18 : }
996 : :
997 : 0 : sal_uInt16 MSWordSections::CurrentNumberOfColumns( const SwDoc &rDoc ) const
998 : : {
999 : : OSL_ENSURE( !aSects.empty(), "no segement inserted yet" );
1000 [ # # ]: 0 : if ( aSects.empty() )
1001 : 0 : return 1;
1002 : :
1003 : 0 : return NumberOfColumns( rDoc, aSects.back() );
1004 : : }
1005 : :
1006 : 0 : sal_uInt16 MSWordSections::NumberOfColumns( const SwDoc &rDoc, const WW8_SepInfo& rInfo ) const
1007 : : {
1008 : 0 : const SwPageDesc* pPd = rInfo.pPageDesc;
1009 [ # # ]: 0 : if ( !pPd )
1010 [ # # ]: 0 : pPd = &rDoc.GetPageDesc( 0 );
1011 : :
1012 [ # # ]: 0 : if ( !pPd )
1013 : : {
1014 : : OSL_ENSURE( pPd, "totally impossible" );
1015 : 0 : return 1;
1016 : : }
1017 : :
1018 : 0 : const SfxItemSet &rSet = pPd->GetMaster().GetAttrSet();
1019 [ # # ]: 0 : SfxItemSet aSet( *rSet.GetPool(), RES_COL, RES_COL );
1020 : 0 : aSet.SetParent( &rSet );
1021 : :
1022 : : //0xffffffff, what the hell is going on with that!, fixme most terribly
1023 [ # # ][ # # ]: 0 : if ( rInfo.pSectionFmt && (SwSectionFmt*)0xFFFFFFFF != rInfo.pSectionFmt )
1024 [ # # ][ # # ]: 0 : aSet.Put( rInfo.pSectionFmt->GetFmtAttr( RES_COL ) );
1025 : :
1026 [ # # ]: 0 : const SwFmtCol& rCol = (const SwFmtCol&)aSet.Get( RES_COL );
1027 : 0 : const SwColumns& rColumns = rCol.GetColumns();
1028 [ # # ]: 0 : return rColumns.size();
1029 : : }
1030 : :
1031 : 60 : const WW8_SepInfo* MSWordSections::CurrentSectionInfo()
1032 : : {
1033 [ + - ]: 60 : if ( !aSects.empty() )
1034 : 60 : return &aSects.back();
1035 : :
1036 : 60 : return NULL;
1037 : : }
1038 : :
1039 : 18 : void MSWordSections::AppendSection( const SwPageDesc* pPd,
1040 : : const SwSectionFmt* pSectionFmt, sal_uLong nLnNumRestartNo )
1041 : : {
1042 [ + - ]: 18 : aSects.push_back( WW8_SepInfo( pPd, pSectionFmt, nLnNumRestartNo ) );
1043 : 18 : NeedsDocumentProtected( aSects.back() );
1044 : 18 : }
1045 : :
1046 : 0 : void WW8_WrPlcSepx::AppendSep( WW8_CP nStartCp, const SwPageDesc* pPd,
1047 : : const SwSectionFmt* pSectionFmt, sal_uLong nLnNumRestartNo )
1048 : : {
1049 [ # # ]: 0 : if ( !bNoMoreSections )
1050 : : {
1051 : 0 : aCps.push_back( nStartCp );
1052 : :
1053 : 0 : AppendSection( pPd, pSectionFmt, nLnNumRestartNo );
1054 : : }
1055 : 0 : }
1056 : :
1057 : 132 : void MSWordSections::AppendSection( const SwFmtPageDesc& rPD,
1058 : : const SwNode& rNd, const SwSectionFmt* pSectionFmt, sal_uLong nLnNumRestartNo )
1059 : : {
1060 : : WW8_SepInfo aI( rPD.GetPageDesc(), pSectionFmt, nLnNumRestartNo,
1061 : 132 : rPD.GetNumOffset(), &rNd );
1062 [ + - ]: 132 : aSects.push_back( aI );
1063 [ + - ]: 132 : NeedsDocumentProtected( aI );
1064 : 132 : }
1065 : :
1066 : 0 : void WW8_WrPlcSepx::AppendSep( WW8_CP nStartCp, const SwFmtPageDesc& rPD,
1067 : : const SwNode& rNd, const SwSectionFmt* pSectionFmt, sal_uLong nLnNumRestartNo )
1068 : : {
1069 [ # # ]: 0 : if ( !bNoMoreSections )
1070 : : {
1071 : 0 : aCps.push_back( nStartCp );
1072 : :
1073 : 0 : AppendSection( rPD, rNd, pSectionFmt, nLnNumRestartNo );
1074 : : }
1075 : 0 : }
1076 : :
1077 : : // MSWordSections::SetNum() setzt in jeder Section beim 1. Aufruf den
1078 : : // Num-Pointer, alle folgenden Aufrufe werden ignoriert. Damit wird
1079 : : // die erste Aufzaehlung einer Section uebernommen.
1080 : :
1081 : 0 : void MSWordSections::SetNum( const SwTxtNode* pNumNd )
1082 : : {
1083 : 0 : WW8_SepInfo& rInfo = aSects.back();
1084 [ # # ]: 0 : if ( !rInfo.pNumNd ) // noch nicht belegt
1085 : 0 : rInfo.pNumNd = pNumNd;
1086 : 0 : }
1087 : :
1088 : 9 : void WW8_WrPlcSepx::WriteFtnEndTxt( WW8Export& rWrt, sal_uLong nCpStt )
1089 : : {
1090 : 9 : sal_uInt8 nInfoFlags = 0;
1091 : 9 : const SwFtnInfo& rInfo = rWrt.pDoc->GetFtnInfo();
1092 [ - + ]: 9 : if( rInfo.aErgoSum.Len() ) nInfoFlags |= 0x02;
1093 [ - + ]: 9 : if( rInfo.aQuoVadis.Len() ) nInfoFlags |= 0x04;
1094 : :
1095 [ + - ]: 9 : sal_uInt8 nEmptyStt = rWrt.bWrtWW8 ? 0 : 6;
1096 [ - + ]: 9 : if( nInfoFlags )
1097 : : {
1098 [ # # ]: 0 : if( rWrt.bWrtWW8 )
1099 : 0 : pTxtPos->Append( nCpStt ); // empty footenote separator
1100 : :
1101 [ # # ]: 0 : if( 0x02 & nInfoFlags ) // Footenote contiunation separator
1102 : : {
1103 : 0 : pTxtPos->Append( nCpStt );
1104 : 0 : rWrt.WriteStringAsPara( rInfo.aErgoSum );
1105 : 0 : rWrt.WriteStringAsPara( aEmptyStr );
1106 : 0 : nCpStt = rWrt.Fc2Cp( rWrt.Strm().Tell() );
1107 : : }
1108 [ # # ]: 0 : else if( rWrt.bWrtWW8 )
1109 : 0 : pTxtPos->Append( nCpStt );
1110 : :
1111 [ # # ]: 0 : if( 0x04 & nInfoFlags ) // Footenote contiunation notice
1112 : : {
1113 : 0 : pTxtPos->Append( nCpStt );
1114 : 0 : rWrt.WriteStringAsPara( rInfo.aQuoVadis );
1115 : 0 : rWrt.WriteStringAsPara( aEmptyStr );
1116 : 0 : nCpStt = rWrt.Fc2Cp( rWrt.Strm().Tell() );
1117 : : }
1118 [ # # ]: 0 : else if( rWrt.bWrtWW8 )
1119 : 0 : pTxtPos->Append( nCpStt );
1120 : :
1121 [ # # ]: 0 : if( rWrt.bWrtWW8 )
1122 : 0 : nEmptyStt = 3;
1123 : : else
1124 : 0 : rWrt.pDop->grpfIhdt = nInfoFlags;
1125 : : }
1126 : :
1127 [ + + ]: 63 : while( 6 > nEmptyStt++ )
1128 : 54 : pTxtPos->Append( nCpStt );
1129 : :
1130 : : // gleich die Flags am Dop setzen
1131 : 9 : WW8Dop& rDop = *rWrt.pDop;
1132 : : // Footnote Info
1133 [ - - + ]: 9 : switch( rInfo.eNum )
1134 : : {
1135 : 0 : case FTNNUM_PAGE: rDop.rncFtn = 2; break;
1136 : 0 : case FTNNUM_CHAPTER: rDop.rncFtn = 1; break;
1137 : 9 : default: rDop.rncFtn = 0; break;
1138 : : } // rncFtn
1139 : 9 : rDop.nfcFtnRef = WW8Export::GetNumId( rInfo.aFmt.GetNumberingType() );
1140 : 9 : rDop.nFtn = rInfo.nFtnOffset + 1;
1141 [ + + ]: 9 : rDop.fpc = rWrt.bFtnAtTxtEnd ? 2 : 1;
1142 : :
1143 : : // Endnote Info
1144 : 9 : rDop.rncEdn = 0; // rncEdn: Don't Restart
1145 : 9 : const SwEndNoteInfo& rEndInfo = rWrt.pDoc->GetEndNoteInfo();
1146 : 9 : rDop.nfcEdnRef = WW8Export::GetNumId( rEndInfo.aFmt.GetNumberingType() );
1147 : 9 : rDop.nEdn = rEndInfo.nFtnOffset + 1;
1148 [ + - ]: 9 : rDop.epc = rWrt.bEndAtTxtEnd ? 3 : 0;
1149 : 9 : }
1150 : :
1151 : 69 : void MSWordSections::SetHeaderFlag( sal_uInt8& rHeadFootFlags, const SwFmt& rFmt,
1152 : : sal_uInt8 nFlag )
1153 : : {
1154 : : const SfxPoolItem* pItem;
1155 [ + - ][ + + : 138 : if( SFX_ITEM_SET == rFmt.GetItemState(RES_HEADER, true, &pItem)
+ + + - ]
[ + + ]
1156 : 66 : && ((SwFmtHeader*)pItem)->IsActive() &&
1157 : 3 : ((SwFmtHeader*)pItem)->GetHeaderFmt() )
1158 : 3 : rHeadFootFlags |= nFlag;
1159 : 69 : }
1160 : :
1161 : 69 : void MSWordSections::SetFooterFlag( sal_uInt8& rHeadFootFlags, const SwFmt& rFmt,
1162 : : sal_uInt8 nFlag )
1163 : : {
1164 : : const SfxPoolItem* pItem;
1165 [ + - ][ + + : 138 : if( SFX_ITEM_SET == rFmt.GetItemState(RES_FOOTER, true, &pItem)
+ + + - ]
[ + + ]
1166 : 66 : && ((SwFmtFooter*)pItem)->IsActive() &&
1167 : 3 : ((SwFmtFooter*)pItem)->GetFooterFmt() )
1168 : 3 : rHeadFootFlags |= nFlag;
1169 : 69 : }
1170 : :
1171 : 54 : void WW8_WrPlcSepx::OutHeaderFooter( WW8Export& rWrt, bool bHeader,
1172 : : const SwFmt& rFmt, sal_uLong& rCpPos, sal_uInt8 nHFFlags,
1173 : : sal_uInt8 nFlag, sal_uInt8 nBreakCode)
1174 : : {
1175 [ + + ]: 54 : if ( nFlag & nHFFlags )
1176 : : {
1177 : 6 : pTxtPos->Append( rCpPos );
1178 : 6 : rWrt.WriteHeaderFooterText( rFmt, bHeader);
1179 : 6 : rWrt.WriteStringAsPara( aEmptyStr ); // CR ans Ende ( sonst mault WW )
1180 : 6 : rCpPos = rWrt.Fc2Cp( rWrt.Strm().Tell() );
1181 : : }
1182 [ + - ]: 48 : else if ( rWrt.bWrtWW8 )
1183 : : {
1184 : 48 : pTxtPos->Append( rCpPos );
1185 [ + - ][ + + ]: 48 : if (rWrt.bHasHdr && nBreakCode!=0)
1186 : : {
1187 : 9 : rWrt.WriteStringAsPara( aEmptyStr ); // Empty paragraph for empty header/footer
1188 : 9 : rWrt.WriteStringAsPara( aEmptyStr ); // a CR that WW8 needs for end of the stream
1189 : 9 : rCpPos = rWrt.Fc2Cp( rWrt.Strm().Tell() );
1190 : : }
1191 : : }
1192 : 54 : }
1193 : :
1194 : 150 : void MSWordSections::NeedsDocumentProtected(const WW8_SepInfo &rInfo)
1195 : : {
1196 [ - + ]: 150 : if (rInfo.IsProtected())
1197 : 0 : mbDocumentIsProtected = true;
1198 : 150 : }
1199 : :
1200 : 219 : bool WW8_SepInfo::IsProtected() const
1201 : : {
1202 : 219 : bool bRet = false;
1203 [ - + ][ # # ]: 219 : if (
1204 : : pSectionFmt &&
1205 : : ((SwSectionFmt*)0xFFFFFFFF != pSectionFmt)
1206 : : )
1207 : : {
1208 : 0 : const SwSection *pSection = pSectionFmt->GetSection();
1209 [ # # ][ # # ]: 0 : if (pSection && pSection->IsProtect())
[ # # ]
1210 : : {
1211 : 0 : bRet = true;
1212 : : }
1213 : : }
1214 : 219 : return bRet;
1215 : : }
1216 : :
1217 : :
1218 : 9 : void MSWordSections::CheckForFacinPg( WW8Export& rWrt ) const
1219 : : {
1220 : : // 2 Werte werden gesetzt
1221 : : // Dop.fFacingPages == Kopf-/Fusszeilen unterschiedlich
1222 : : // Dop.fSwapBordersFacingPgs == gespiegelte Raender
1223 : 9 : std::vector<WW8_SepInfo>::const_iterator iter = aSects.begin();
1224 [ + - ][ + + ]: 18 : for( sal_uInt16 nEnde = 0; iter != aSects.end(); ++iter )
1225 : : {
1226 : 9 : const WW8_SepInfo& rSepInfo = *iter;
1227 [ + - ]: 9 : if( !rSepInfo.pSectionFmt )
1228 : : {
1229 : 9 : const SwPageDesc* pPd = rSepInfo.pPageDesc;
1230 [ + - ]: 9 : if( pPd->GetFollow() && pPd != pPd->GetFollow() &&
[ - + # # ]
[ # # ][ # # ]
[ - + ]
1231 : 0 : pPd->GetFollow()->GetFollow() == pPd->GetFollow() &&
1232 : : rSepInfo.pPDNd &&
1233 [ # # ]: 0 : pPd->IsFollowNextPageOfNode( *rSepInfo.pPDNd ) )
1234 : : // das ist also 1.Seite und nachfolgende, also nur den
1235 : : // follow beachten
1236 : 0 : pPd = pPd->GetFollow();
1237 : :
1238 : : // left-/right chain of pagedescs ?
1239 [ + - + - : 27 : else if( !( 1 & nEnde ) &&
- + # # #
# # # # #
# # ][ - + ]
1240 : 18 : pPd->GetFollow() && pPd != pPd->GetFollow() &&
1241 : 0 : pPd->GetFollow()->GetFollow() == pPd &&
1242 : 0 : (( nsUseOnPage::PD_LEFT == ( nsUseOnPage::PD_ALL & pPd->ReadUseOn() ) &&
1243 : 0 : nsUseOnPage::PD_RIGHT == ( nsUseOnPage::PD_ALL & pPd->GetFollow()->ReadUseOn() )) ||
1244 : 0 : ( nsUseOnPage::PD_RIGHT == ( nsUseOnPage::PD_ALL & pPd->ReadUseOn() ) &&
1245 : 0 : nsUseOnPage::PD_LEFT == ( nsUseOnPage::PD_ALL & pPd->GetFollow()->ReadUseOn() )) ))
1246 : : {
1247 : 0 : rWrt.pDop->fFacingPages = rWrt.pDop->fMirrorMargins = true;
1248 : 0 : nEnde |= 1;
1249 : : }
1250 : :
1251 [ + - + - : 27 : if( !( 1 & nEnde ) &&
- + ][ - + ]
1252 : 18 : ( !pPd->IsHeaderShared() || !pPd->IsFooterShared() ))
1253 : : {
1254 : 0 : rWrt.pDop->fFacingPages = true;
1255 : 0 : nEnde |= 1;
1256 : : }
1257 [ + - - + ]: 18 : if( !( 2 & nEnde ) &&
[ - + ]
1258 : 9 : nsUseOnPage::PD_MIRROR == ( nsUseOnPage::PD_MIRROR & pPd->ReadUseOn() ))
1259 : : {
1260 : : rWrt.pDop->fSwapBordersFacingPgs =
1261 : 0 : rWrt.pDop->fMirrorMargins = true;
1262 : 0 : nEnde |= 2;
1263 : : }
1264 : :
1265 [ - + ]: 9 : if( 3 == nEnde )
1266 : 0 : break; // weiter brauchen wird nicht
1267 : : }
1268 : : }
1269 : 9 : }
1270 : :
1271 : 9 : int MSWordSections::HasBorderItem( const SwFmt& rFmt )
1272 : : {
1273 : : const SfxPoolItem* pItem;
1274 [ + - ]: 9 : return SFX_ITEM_SET == rFmt.GetItemState(RES_BOX, true, &pItem) &&
1275 : 0 : ( ((SvxBoxItem*)pItem)->GetTop() ||
1276 : 0 : ((SvxBoxItem*)pItem)->GetBottom() ||
1277 : 0 : ((SvxBoxItem*)pItem)->GetLeft() ||
1278 [ - + # # : 9 : ((SvxBoxItem*)pItem)->GetRight() );
# # # # ]
[ # # ]
1279 : : }
1280 : :
1281 : 9 : void WW8AttributeOutput::StartSection()
1282 : : {
1283 : 9 : m_rWW8Export.pO->clear();
1284 : 9 : }
1285 : :
1286 : 9 : void WW8AttributeOutput::SectionFormProtection( bool bProtected )
1287 : : {
1288 : : //If the document is to be exported as protected, then if a segment
1289 : : //is not protected, set the unlocked flag
1290 [ - + ][ # # ]: 9 : if ( m_rWW8Export.pSepx->DocumentIsProtected() && !bProtected )
[ - + ]
1291 : : {
1292 [ # # ]: 0 : if ( m_rWW8Export.bWrtWW8 )
1293 : 0 : SwWW8Writer::InsUInt16( *m_rWW8Export.pO, NS_sprm::LN_SFProtected );
1294 : : else
1295 [ # # ]: 0 : m_rWW8Export.pO->push_back( 139 );
1296 [ # # ]: 0 : m_rWW8Export.pO->push_back( 1 );
1297 : : }
1298 : 9 : }
1299 : :
1300 : 0 : void WW8AttributeOutput::SectionLineNumbering( sal_uLong nRestartNo, const SwLineNumberInfo& rLnNumInfo )
1301 : : {
1302 : : // sprmSNLnnMod - activate Line Numbering and define Modulo
1303 [ # # ]: 0 : if ( m_rWW8Export.bWrtWW8 )
1304 : 0 : SwWW8Writer::InsUInt16( *m_rWW8Export.pO, NS_sprm::LN_SNLnnMod );
1305 : : else
1306 [ # # ]: 0 : m_rWW8Export.pO->push_back( 154 );
1307 : 0 : SwWW8Writer::InsUInt16( *m_rWW8Export.pO, (sal_uInt16)rLnNumInfo.GetCountBy() );
1308 : :
1309 : : // sprmSDxaLnn - xPosition of Line Number
1310 [ # # ]: 0 : if ( m_rWW8Export.bWrtWW8 )
1311 : 0 : SwWW8Writer::InsUInt16( *m_rWW8Export.pO, NS_sprm::LN_SDxaLnn );
1312 : : else
1313 [ # # ]: 0 : m_rWW8Export.pO->push_back( 155 );
1314 : 0 : SwWW8Writer::InsUInt16( *m_rWW8Export.pO, (sal_uInt16)rLnNumInfo.GetPosFromLeft() );
1315 : :
1316 : : // sprmSLnc - restart number: 0 per page, 1 per section, 2 never restart
1317 [ # # ][ # # ]: 0 : if ( nRestartNo || !rLnNumInfo.IsRestartEachPage() )
[ # # ]
1318 : : {
1319 [ # # ]: 0 : if ( m_rWW8Export.bWrtWW8 )
1320 : 0 : SwWW8Writer::InsUInt16( *m_rWW8Export.pO, NS_sprm::LN_SLnc );
1321 : : else
1322 [ # # ]: 0 : m_rWW8Export.pO->push_back( 152 );
1323 [ # # ][ # # ]: 0 : m_rWW8Export.pO->push_back( nRestartNo ? 1 : 2 );
1324 : : }
1325 : :
1326 : : // sprmSLnnMin - Restart the Line Number with given value
1327 [ # # ]: 0 : if ( nRestartNo )
1328 : : {
1329 [ # # ]: 0 : if ( m_rWW8Export.bWrtWW8 )
1330 : 0 : SwWW8Writer::InsUInt16( *m_rWW8Export.pO, NS_sprm::LN_SLnnMin );
1331 : : else
1332 [ # # ]: 0 : m_rWW8Export.pO->push_back( 160 );
1333 : 0 : SwWW8Writer::InsUInt16( *m_rWW8Export.pO, (sal_uInt16)nRestartNo - 1 );
1334 : : }
1335 : 0 : }
1336 : :
1337 : 0 : void WW8AttributeOutput::SectionTitlePage()
1338 : : {
1339 : : // sprmSFTitlePage
1340 [ # # ]: 0 : if ( m_rWW8Export.bWrtWW8 )
1341 : 0 : SwWW8Writer::InsUInt16( *m_rWW8Export.pO, NS_sprm::LN_SFTitlePage );
1342 : : else
1343 [ # # ]: 0 : m_rWW8Export.pO->push_back( 143 );
1344 [ # # ]: 0 : m_rWW8Export.pO->push_back( 1 );
1345 : 0 : }
1346 : :
1347 : 9 : void WW8AttributeOutput::SectionPageBorders( const SwFrmFmt* pPdFmt, const SwFrmFmt* pPdFirstPgFmt )
1348 : : {
1349 [ + - ]: 9 : if ( m_rWW8Export.bWrtWW8 ) // Seitenumrandung schreiben
1350 : : {
1351 [ - + ]: 9 : sal_uInt16 nPgBorder = MSWordSections::HasBorderItem( *pPdFmt ) ? 0 : USHRT_MAX;
1352 [ - + ]: 9 : if ( pPdFmt != pPdFirstPgFmt )
1353 : : {
1354 [ # # ]: 0 : if ( MSWordSections::HasBorderItem( *pPdFirstPgFmt ) )
1355 : : {
1356 [ # # ]: 0 : if ( USHRT_MAX == nPgBorder )
1357 : : {
1358 : 0 : nPgBorder = 1;
1359 : : // nur die 1. Seite umrandet -> BoxItem aus dem
1360 : : // richtigen Format besorgen
1361 : 0 : m_rWW8Export.pISet = &pPdFirstPgFmt->GetAttrSet();
1362 : 0 : OutputItem( pPdFirstPgFmt->GetFmtAttr( RES_BOX ) );
1363 : : }
1364 : : }
1365 [ # # ]: 0 : else if ( !nPgBorder )
1366 : 0 : nPgBorder = 2;
1367 : : }
1368 : :
1369 [ - + ]: 9 : if ( USHRT_MAX != nPgBorder )
1370 : : {
1371 : : // Flag und das Border Attribut schreiben
1372 : 0 : SwWW8Writer::InsUInt16( *m_rWW8Export.pO, NS_sprm::LN_SPgbProp );
1373 : 0 : SwWW8Writer::InsUInt16( *m_rWW8Export.pO, nPgBorder );
1374 : : }
1375 : : }
1376 : 9 : }
1377 : :
1378 : 0 : void WW8AttributeOutput::SectionBiDi( bool bBiDi )
1379 : : {
1380 [ # # ]: 0 : if ( m_rWW8Export.bWrtWW8 )
1381 : : {
1382 : 0 : SwWW8Writer::InsUInt16( *m_rWW8Export.pO, NS_sprm::LN_SFBiDi );
1383 [ # # ][ # # ]: 0 : m_rWW8Export.pO->push_back( bBiDi? 1: 0 );
1384 : : }
1385 : 0 : }
1386 : :
1387 : 9 : void WW8AttributeOutput::SectionPageNumbering( sal_uInt16 nNumType, sal_uInt16 nPageRestartNumber )
1388 : : {
1389 : : // sprmSNfcPgn
1390 [ + - ]: 9 : sal_uInt8 nb = WW8Export::GetNumId( nNumType );
1391 [ + - ]: 9 : if ( m_rWW8Export.bWrtWW8 )
1392 [ + - ]: 9 : SwWW8Writer::InsUInt16( *m_rWW8Export.pO, NS_sprm::LN_SNfcPgn );
1393 : : else
1394 [ # # ]: 0 : m_rWW8Export.pO->push_back( 147 );
1395 [ + - ]: 9 : m_rWW8Export.pO->push_back( nb );
1396 : :
1397 [ - + ]: 9 : if ( nPageRestartNumber )
1398 : : {
1399 : : // sprmSFPgnRestart
1400 [ # # ]: 0 : if ( m_rWW8Export.bWrtWW8 )
1401 [ # # ]: 0 : SwWW8Writer::InsUInt16( *m_rWW8Export.pO, NS_sprm::LN_SFPgnRestart );
1402 : : else
1403 [ # # ]: 0 : m_rWW8Export.pO->push_back( 150 );
1404 [ # # ]: 0 : m_rWW8Export.pO->push_back( 1 );
1405 : :
1406 : : // sprmSPgnStart
1407 [ # # ]: 0 : if ( m_rWW8Export.bWrtWW8 )
1408 [ # # ]: 0 : SwWW8Writer::InsUInt16( *m_rWW8Export.pO, NS_sprm::LN_SPgnStart );
1409 : : else
1410 [ # # ]: 0 : m_rWW8Export.pO->push_back( 161 );
1411 [ # # ]: 0 : SwWW8Writer::InsUInt16( *m_rWW8Export.pO, nPageRestartNumber );
1412 : : }
1413 : 9 : }
1414 : :
1415 : 9 : void WW8AttributeOutput::SectionType( sal_uInt8 nBreakCode )
1416 : : {
1417 [ - + ]: 9 : if ( 2 != nBreakCode ) // new page is the default
1418 : : {
1419 [ # # ]: 0 : if ( m_rWW8Export.bWrtWW8 )
1420 : 0 : SwWW8Writer::InsUInt16( *m_rWW8Export.pO, NS_sprm::LN_SBkc );
1421 : : else
1422 [ # # ]: 0 : m_rWW8Export.pO->push_back( 142 );
1423 : 0 : m_rWW8Export.pO->push_back( nBreakCode );
1424 : : }
1425 : 9 : }
1426 : :
1427 : 9 : void WW8AttributeOutput::SectionWW6HeaderFooterFlags( sal_uInt8 nHeadFootFlags )
1428 : : {
1429 [ + + ][ - + ]: 9 : if ( nHeadFootFlags && !m_rWW8Export.bWrtWW8 )
1430 : : {
1431 : 0 : sal_uInt8 nTmpFlags = nHeadFootFlags;
1432 [ # # ]: 0 : if ( m_rWW8Export.pDop->fFacingPages )
1433 : : {
1434 [ # # ][ # # ]: 0 : if ( !(nTmpFlags & WW8_FOOTER_EVEN) && (nTmpFlags & WW8_FOOTER_ODD ) )
1435 : 0 : nTmpFlags |= WW8_FOOTER_EVEN;
1436 : :
1437 [ # # ][ # # ]: 0 : if ( !(nTmpFlags & WW8_HEADER_EVEN) && (nTmpFlags & WW8_HEADER_ODD ) )
1438 : 0 : nTmpFlags |= WW8_HEADER_EVEN;
1439 : : }
1440 : :
1441 : : // sprmSGprfIhdt, wird nur noch im WW95 benoetigt
1442 [ # # ]: 0 : m_rWW8Export.pO->push_back( 153 );
1443 [ # # ]: 0 : m_rWW8Export.pO->push_back( nTmpFlags );
1444 : : }
1445 : 9 : }
1446 : :
1447 : 9 : void WW8Export::SetupSectionPositions( WW8_PdAttrDesc* pA )
1448 : : {
1449 [ - + ]: 9 : if ( !pA )
1450 : 9 : return;
1451 : :
1452 [ + - ]: 9 : if ( !pO->empty() )
1453 : : { // waren Attrs vorhanden ?
1454 : 9 : pA->nLen = pO->size();
1455 : 9 : pA->pData = new sal_uInt8 [pO->size()];
1456 : 9 : memcpy( pA->pData, pO->data(), pO->size() ); // -> merken
1457 : 9 : pO->clear(); // leeren fuer HdFt-Text
1458 : : }
1459 : : else
1460 : : { // keine Attrs da
1461 : 0 : pA->pData = 0;
1462 : 0 : pA->nLen = 0;
1463 : : }
1464 : : }
1465 : :
1466 : 9 : void WW8Export::WriteHeadersFooters( sal_uInt8 nHeadFootFlags,
1467 : : const SwFrmFmt& rFmt, const SwFrmFmt& rLeftFmt, const SwFrmFmt& rFirstPageFmt, sal_uInt8 nBreakCode )
1468 : : {
1469 [ + - ][ + - ]: 9 : sal_uLong nCpPos = Fc2Cp( Strm().Tell() );
1470 : :
1471 : 9 : IncrementHdFtIndex();
1472 [ - + ][ + - ]: 9 : if ( !(nHeadFootFlags & WW8_HEADER_EVEN) && pDop->fFacingPages )
1473 [ # # ]: 0 : pSepx->OutHeaderFooter( *this, true, rFmt, nCpPos, nHeadFootFlags, WW8_HEADER_ODD, nBreakCode );
1474 : : else
1475 [ + - ]: 9 : pSepx->OutHeaderFooter( *this, true, rLeftFmt, nCpPos, nHeadFootFlags, WW8_HEADER_EVEN, nBreakCode );
1476 : 9 : IncrementHdFtIndex();
1477 [ + - ]: 9 : pSepx->OutHeaderFooter( *this, true, rFmt, nCpPos, nHeadFootFlags, WW8_HEADER_ODD, nBreakCode );
1478 : :
1479 : 9 : IncrementHdFtIndex();
1480 [ - + ][ + - ]: 9 : if ( !(nHeadFootFlags & WW8_FOOTER_EVEN) && pDop->fFacingPages )
1481 [ # # ]: 0 : pSepx->OutHeaderFooter( *this, false, rFmt, nCpPos, nHeadFootFlags, WW8_FOOTER_ODD, nBreakCode );
1482 : : else
1483 [ + - ]: 9 : pSepx->OutHeaderFooter( *this, false, rLeftFmt, nCpPos, nHeadFootFlags, WW8_FOOTER_EVEN, nBreakCode );
1484 : 9 : IncrementHdFtIndex();
1485 [ + - ]: 9 : pSepx->OutHeaderFooter( *this, false, rFmt, nCpPos, nHeadFootFlags, WW8_FOOTER_ODD, nBreakCode );
1486 : :
1487 : : //#i24344# Drawing objects cannot be directly shared between main hd/ft
1488 : : //and title hd/ft so we need to differenciate them
1489 : 9 : IncrementHdFtIndex();
1490 [ + - ]: 9 : pSepx->OutHeaderFooter( *this, true, rFirstPageFmt, nCpPos, nHeadFootFlags, WW8_HEADER_FIRST, nBreakCode );
1491 [ + - ]: 9 : pSepx->OutHeaderFooter( *this, false, rFirstPageFmt, nCpPos, nHeadFootFlags, WW8_FOOTER_FIRST, nBreakCode );
1492 : 9 : }
1493 : :
1494 : 69 : void MSWordExportBase::SectionProperties( const WW8_SepInfo& rSepInfo, WW8_PdAttrDesc* pA )
1495 : : {
1496 : 69 : const SwPageDesc* pPd = rSepInfo.pPageDesc;
1497 : :
1498 [ - + ][ # # ]: 69 : if ( rSepInfo.pSectionFmt && !pPd )
1499 [ # # ]: 0 : pPd = &pDoc->GetPageDesc( 0 );
1500 : :
1501 : 69 : pAktPageDesc = pPd;
1502 : :
1503 [ + - ]: 69 : if ( !pPd )
1504 : 69 : return;
1505 : :
1506 : 69 : bool bOldPg = bOutPageDescs;
1507 : 69 : bOutPageDescs = true;
1508 : :
1509 [ + - ][ + - ]: 69 : AttrOutput().StartSection();
1510 : :
1511 [ + - ][ + - ]: 69 : AttrOutput().SectFootnoteEndnotePr();
1512 : :
1513 : : // forms
1514 [ + - ][ + - ]: 69 : AttrOutput().SectionFormProtection( rSepInfo.IsProtected() );
[ + - ]
1515 : :
1516 : : // line numbers
1517 [ + - ]: 69 : const SwLineNumberInfo& rLnNumInfo = pDoc->GetLineNumberInfo();
1518 [ - + ]: 69 : if ( rLnNumInfo.IsPaintLineNumbers() )
1519 [ # # ][ # # ]: 0 : AttrOutput().SectionLineNumbering( rSepInfo.nLnNumRestartNo, rLnNumInfo );
1520 : :
1521 : : /* sprmSBkc, break code: 0 No break, 1 New column
1522 : : 2 New page, 3 Even page, 4 Odd page
1523 : : */
1524 : 69 : sal_uInt8 nBreakCode = 2; // default neue Seite beginnen
1525 : 69 : bool bOutPgDscSet = true, bLeftRightPgChain = false;
1526 : 69 : const SwFrmFmt* pPdFmt = &pPd->GetMaster();
1527 : 69 : const SwFrmFmt* pPdFirstPgFmt = pPdFmt;
1528 [ - + ]: 69 : if ( rSepInfo.pSectionFmt )
1529 : : {
1530 : : // ist pSectionFmt gesetzt, dann gab es einen SectionNode
1531 : : // gueltiger Pointer -> Section beginnt,
1532 : : // 0xfff -> Section wird beendet
1533 : 0 : nBreakCode = 0; // fortlaufender Abschnitt
1534 : :
1535 [ # # ][ # # ]: 0 : if ( rSepInfo.pPDNd && rSepInfo.pPDNd->IsCntntNode() )
[ # # ]
1536 : : {
1537 [ # # ][ # # ]: 0 : if ( !NoPageBreakSection( &rSepInfo.pPDNd->GetCntntNode()->GetSwAttrSet() ) )
[ # # ]
1538 : : {
1539 : 0 : nBreakCode = 2;
1540 : : }
1541 : : }
1542 : :
1543 [ # # ]: 0 : if ( (SwSectionFmt*)0xFFFFFFFF != rSepInfo.pSectionFmt )
1544 : : {
1545 [ # # ]: 0 : if ( nBreakCode == 0 )
1546 : 0 : bOutPgDscSet = false;
1547 : :
1548 : : // Itemset erzeugen, das das PgDesk-AttrSet beerbt:
1549 : : // als Nachkomme wird bei 'deep'-OutputItemSet
1550 : : // auch der Vorfahr abgeklappert
1551 : 0 : const SfxItemSet* pPdSet = &pPdFmt->GetAttrSet();
1552 [ # # ]: 0 : SfxItemSet aSet( *pPdSet->GetPool(), pPdSet->GetRanges() );
1553 : 0 : aSet.SetParent( pPdSet );
1554 : :
1555 : : // am Nachkommen NUR die Spaltigkeit gemaess Sect-Attr.
1556 : : // umsetzen
1557 [ # # ][ # # ]: 0 : aSet.Put( rSepInfo.pSectionFmt->GetFmtAttr( RES_COL ) );
1558 : :
1559 : : const SvxLRSpaceItem &rSectionLR =
1560 [ # # ]: 0 : ItemGet<SvxLRSpaceItem>( *(rSepInfo.pSectionFmt), RES_LR_SPACE );
1561 : : const SvxLRSpaceItem &rPageLR =
1562 [ # # ]: 0 : ItemGet<SvxLRSpaceItem>( *pPdFmt, RES_LR_SPACE );
1563 : :
1564 : 0 : SvxLRSpaceItem aResultLR( rPageLR.GetLeft() +
1565 : 0 : rSectionLR.GetLeft(), rPageLR.GetRight() +
1566 [ # # ]: 0 : rSectionLR.GetRight(), 0, 0, RES_LR_SPACE );
1567 : :
1568 [ # # ]: 0 : aSet.Put( aResultLR );
1569 : :
1570 : : // und raus damit ins WW-File
1571 : 0 : const SfxItemSet* pOldI = pISet;
1572 : 0 : pISet = &aSet;
1573 : :
1574 : : // Switch off test on default item values, if page description
1575 : : // set (value of <bOutPgDscSet>) isn't written.
1576 [ # # ][ # # ]: 0 : AttrOutput().OutputStyleItemSet( aSet, true, bOutPgDscSet );
1577 : :
1578 : : //Cannot export as normal page framedir, as continous sections
1579 : : //cannot contain any grid settings like proper sections
1580 [ # # ][ # # ]: 0 : AttrOutput().SectionBiDi( FRMDIR_HORI_RIGHT_TOP == TrueFrameDirection( *rSepInfo.pSectionFmt ) );
[ # # ]
1581 : :
1582 [ # # ][ # # ]: 0 : pISet = pOldI;
1583 : : }
1584 : : }
1585 : :
1586 : 69 : bool titlePage = false;
1587 [ + - ]: 69 : if ( bOutPgDscSet )
1588 : : {
1589 : : // es ist ein Follow gesetzt und dieser zeigt nicht auf sich
1590 : : // selbst, so liegt eine Seitenverkettung vor.
1591 : : // Falls damit eine "Erste Seite" simuliert werden soll, so
1592 : : // koennen wir das auch als solches schreiben.
1593 : : // Anders sieht es mit Links/Rechts wechseln aus. Dafuer muss
1594 : : // erkannt werden, wo der Seitenwechsel statt findet. Hier ist
1595 : : // es aber dafuer zuspaet!
1596 [ + - ]: 69 : if ( pPd->GetFollow() && pPd != pPd->GetFollow() &&
[ - + # # ]
[ # # ][ # # ]
[ - + ]
1597 : 0 : pPd->GetFollow()->GetFollow() == pPd->GetFollow() &&
1598 [ # # ]: 0 : ( !rSepInfo.pPDNd || pPd->IsFollowNextPageOfNode( *rSepInfo.pPDNd ) ) )
1599 : : {
1600 : 0 : const SwPageDesc *pFollow = pPd->GetFollow();
1601 : 0 : const SwFrmFmt& rFollowFmt = pFollow->GetMaster();
1602 [ # # ][ # # ]: 0 : if ( sw::util::IsPlausableSingleWordSection( *pPdFmt, rFollowFmt ) )
1603 : : {
1604 [ # # ]: 0 : if (rSepInfo.pPDNd)
1605 [ # # ]: 0 : pPdFirstPgFmt = pPd->GetPageFmtOfNode( *rSepInfo.pPDNd );
1606 : : else
1607 : 0 : pPdFirstPgFmt = &pPd->GetMaster();
1608 : :
1609 : 0 : pAktPageDesc = pPd = pFollow;
1610 : 0 : pPdFmt = &rFollowFmt;
1611 : :
1612 : : // has different headers/footers for the title page
1613 : 0 : titlePage = true;
1614 : : }
1615 : : }
1616 : :
1617 : : // The code above tries to detect if this is first page headers/footers,
1618 : : // but it doesn't work even for quite trivial testcases. As I don't actually
1619 : : // understand that code, I'll keep it. The simple and (at least for me) reliable way
1620 : : // to detect for first page seems to be just RES_POOLPAGE_FIRST.
1621 [ - + ]: 69 : if( pPd->GetPoolFmtId() == RES_POOLPAGE_FIRST )
1622 : 0 : titlePage = true;
1623 [ - + ]: 69 : if( titlePage )
1624 [ # # ][ # # ]: 0 : AttrOutput().SectionTitlePage();
1625 : :
1626 : 69 : const SfxItemSet* pOldI = pISet;
1627 : :
1628 [ + - ][ + - ]: 69 : AttrOutput().SectionPageBorders( pPdFmt, pPdFirstPgFmt );
1629 : :
1630 : : const SfxPoolItem* pItem;
1631 [ - + ][ # # ]: 69 : if ( pPdFmt != pPdFirstPgFmt && SFX_ITEM_SET ==
[ - + ]
1632 [ # # ]: 0 : pPdFirstPgFmt->GetItemState( RES_PAPER_BIN, true, &pItem ) )
1633 : : {
1634 : 0 : pISet = &pPdFirstPgFmt->GetAttrSet();
1635 : 0 : bOutFirstPage = true;
1636 [ # # ][ # # ]: 0 : AttrOutput().OutputItem( *pItem );
1637 : 0 : bOutFirstPage = false;
1638 : : }
1639 : :
1640 : : // left-/right chain of pagedescs ?
1641 [ + - ][ - + : 69 : if ( pPd->GetFollow() && pPd != pPd->GetFollow() &&
# # # # #
# # # #
# ][ - + ]
1642 : 0 : pPd->GetFollow()->GetFollow() == pPd &&
1643 : 0 : (( nsUseOnPage::PD_LEFT == ( nsUseOnPage::PD_ALL & pPd->ReadUseOn() ) &&
1644 : 0 : nsUseOnPage::PD_RIGHT == ( nsUseOnPage::PD_ALL & pPd->GetFollow()->ReadUseOn() )) ||
1645 : 0 : ( nsUseOnPage::PD_RIGHT == ( nsUseOnPage::PD_ALL & pPd->ReadUseOn() ) &&
1646 : 0 : nsUseOnPage::PD_LEFT == ( nsUseOnPage::PD_ALL & pPd->GetFollow()->ReadUseOn() )) ))
1647 : : {
1648 : 0 : bLeftRightPgChain = true;
1649 : :
1650 : : // welches ist der Bezugspunkt ????? (links oder rechts?)
1651 : : // annahme die rechte Seite!
1652 [ # # ]: 0 : if ( nsUseOnPage::PD_LEFT == ( nsUseOnPage::PD_ALL & pPd->ReadUseOn() ) )
1653 : : {
1654 : 0 : nBreakCode = 3;
1655 : 0 : pPd = pPd->GetFollow();
1656 : 0 : pPdFmt = &pPd->GetMaster();
1657 : : }
1658 : : else
1659 : 0 : nBreakCode = 4;
1660 : : }
1661 : :
1662 : 69 : pISet = &pPdFmt->GetAttrSet();
1663 [ + - ][ + - ]: 69 : AttrOutput().OutputStyleItemSet( pPdFmt->GetAttrSet(), true, false );
1664 : 69 : pISet = pOldI;
1665 : :
1666 : : // dann noch die restlichen Einstellungen aus dem PageDesc
1667 : :
1668 [ + - ][ + - ]: 69 : AttrOutput().SectionPageNumbering( pPd->GetNumType().GetNumberingType(), rSepInfo.nPgRestartNo );
1669 : :
1670 : : // werden es nur linke oder nur rechte Seiten?
1671 [ + - ]: 69 : if ( 2 == nBreakCode )
1672 : : {
1673 [ - + ]: 69 : if ( nsUseOnPage::PD_LEFT == ( nsUseOnPage::PD_ALL & pPd->ReadUseOn() ) )
1674 : 0 : nBreakCode = 3;
1675 [ - + ]: 69 : else if ( nsUseOnPage::PD_RIGHT == ( nsUseOnPage::PD_ALL & pPd->ReadUseOn() ) )
1676 : 69 : nBreakCode = 4;
1677 : : }
1678 : : }
1679 : :
1680 [ + - ][ + - ]: 69 : AttrOutput().SectionType( nBreakCode );
1681 : :
1682 : 69 : const SwTxtNode* pNd = rSepInfo.pNumNd;
1683 [ - + ]: 69 : if ( pNd )
1684 : : {
1685 [ # # ]: 0 : const SwNumRule* pRule = pNd->GetNumRule();
1686 [ # # ]: 0 : if ( pRule )
1687 [ # # ]: 0 : OutputOlst( *pRule );
1688 : : }
1689 : :
1690 : : // Header oder Footer
1691 : 69 : sal_uInt8 nHeadFootFlags = 0;
1692 : :
1693 : : const SwFrmFmt* pPdLeftFmt = bLeftRightPgChain
1694 : 0 : ? &pPd->GetFollow()->GetMaster()
1695 [ - + ]: 69 : : &pPd->GetLeft();
1696 : :
1697 [ + - ]: 69 : if ( nBreakCode != 0 )
1698 : : {
1699 [ - + ]: 69 : if ( titlePage )
1700 : : {
1701 : : // es gibt eine ErsteSeite:
1702 [ # # ]: 0 : MSWordSections::SetHeaderFlag( nHeadFootFlags, *pPdFirstPgFmt, WW8_HEADER_FIRST );
1703 [ # # ]: 0 : MSWordSections::SetFooterFlag( nHeadFootFlags, *pPdFirstPgFmt, WW8_FOOTER_FIRST );
1704 : : }
1705 : : // write other headers/footers only if it's not on the first page - I'm not quite sure
1706 : : // this is technically correct, but it avoids first-page headers/footers
1707 : : // extending to all pages (bnc#654230)
1708 [ - + ][ # # ]: 69 : if( !titlePage || pPdFmt != pPdFirstPgFmt )
1709 : : {
1710 [ + - ]: 69 : MSWordSections::SetHeaderFlag( nHeadFootFlags, *pPdFmt, WW8_HEADER_ODD );
1711 [ + - ]: 69 : MSWordSections::SetFooterFlag( nHeadFootFlags, *pPdFmt, WW8_FOOTER_ODD );
1712 : :
1713 [ + - ][ - + ]: 69 : if ( !pPd->IsHeaderShared() || bLeftRightPgChain )
[ - + ]
1714 [ # # ]: 0 : MSWordSections::SetHeaderFlag( nHeadFootFlags, *pPdLeftFmt, WW8_HEADER_EVEN );
1715 : :
1716 [ + - ][ - + ]: 69 : if ( !pPd->IsFooterShared() || bLeftRightPgChain )
[ - + ]
1717 [ # # ]: 0 : MSWordSections::SetFooterFlag( nHeadFootFlags, *pPdLeftFmt, WW8_FOOTER_EVEN );
1718 : : }
1719 [ + - ][ + - ]: 69 : AttrOutput().SectionWW6HeaderFooterFlags( nHeadFootFlags );
1720 : : }
1721 : :
1722 : : // binary filters only
1723 [ + - ]: 69 : SetupSectionPositions( pA );
1724 : :
1725 : : /*
1726 : : !!!!!!!!!!!
1727 : : // Umrandungen an Kopf- und Fusstexten muessten etwa so gehen:
1728 : : // Dabei muss etwas wie pOut eingebaut werden,
1729 : : // das bei jeder Spezialtext-Zeile wiederholt wird.
1730 : : const SwFrmFmt* pFFmt = rFt.GetFooterFmt();
1731 : : const SvxBoxItem& rBox = pFFmt->GetBox(false);
1732 : : OutWW8_SwFmtBox1( m_rWW8Export.pOut, rBox, false);
1733 : : !!!!!!!!!!!
1734 : : Man koennt daraus Absatzattribute machen, die dann bei jedem Absatz
1735 : : beachtet werden. Gilt fuer Hintergrund/Umrandung
1736 : : !!!!!!!!!!!
1737 : : */
1738 : :
1739 : 69 : const SwTxtNode *pOldPageRoot = GetHdFtPageRoot();
1740 [ + + ]: 69 : SetHdFtPageRoot( rSepInfo.pPDNd ? rSepInfo.pPDNd->GetTxtNode() : 0 );
1741 : :
1742 [ + - ]: 69 : WriteHeadersFooters( nHeadFootFlags, *pPdFmt, *pPdLeftFmt, *pPdFirstPgFmt, nBreakCode );
1743 : :
1744 : 69 : SetHdFtPageRoot( pOldPageRoot );
1745 : :
1746 [ + - ][ + - ]: 69 : AttrOutput().EndSection();
1747 : :
1748 : : // outside of the section properties again
1749 : 69 : bOutPageDescs = bOldPg;
1750 : : }
1751 : :
1752 : 9 : bool WW8_WrPlcSepx::WriteKFTxt( WW8Export& rWrt )
1753 : : {
1754 : 9 : pAttrs = new WW8_PdAttrDesc[ aSects.size() ];
1755 : 9 : sal_uLong nCpStart = rWrt.Fc2Cp( rWrt.Strm().Tell() );
1756 : :
1757 : : OSL_ENSURE( !pTxtPos, "wer hat den Pointer gesetzt?" );
1758 [ + - ]: 9 : pTxtPos = new WW8_WrPlc0( nCpStart );
1759 : :
1760 : 9 : WriteFtnEndTxt( rWrt, nCpStart );
1761 : 9 : CheckForFacinPg( rWrt );
1762 : :
1763 : 9 : unsigned int nOldIndex = rWrt.GetHdFtIndex();
1764 : 9 : rWrt.SetHdFtIndex( 0 );
1765 [ + + ]: 18 : for ( sal_uInt16 i = 0; i < aSects.size(); ++i )
1766 : : {
1767 : 9 : WW8_PdAttrDesc* pA = pAttrs + i;
1768 : 9 : pA->pData = 0;
1769 : 9 : pA->nLen = 0;
1770 : 9 : pA->nSepxFcPos = 0xffffffff; // Default: none
1771 : :
1772 : 9 : WW8_SepInfo& rSepInfo = aSects[i];
1773 : 9 : rWrt.SectionProperties( rSepInfo, pA );
1774 : :
1775 : 9 : bNoMoreSections = true;
1776 : : }
1777 : 9 : rWrt.SetHdFtIndex( nOldIndex ); //0
1778 : :
1779 [ + - ]: 9 : if ( pTxtPos->Count() )
1780 : : {
1781 : : // HdFt vorhanden ?
1782 : 9 : sal_uLong nCpEnd = rWrt.Fc2Cp( rWrt.Strm().Tell() );
1783 : 9 : pTxtPos->Append( nCpEnd ); // Ende letzter Hd/Ft fuer PlcfHdd
1784 : :
1785 [ + + ]: 9 : if ( nCpEnd > nCpStart )
1786 : : {
1787 : 3 : ++nCpEnd;
1788 : 3 : pTxtPos->Append( nCpEnd + 1 ); // Ende letzter Hd/Ft fuer PlcfHdd
1789 : :
1790 : 3 : rWrt.WriteStringAsPara( aEmptyStr ); // CR ans Ende ( sonst mault WW )
1791 : : }
1792 : 9 : rWrt.pFldHdFt->Finish( nCpEnd, rWrt.pFib->ccpText + rWrt.pFib->ccpFtn );
1793 : 9 : rWrt.pFib->ccpHdr = nCpEnd - nCpStart;
1794 : : }
1795 : : else
1796 [ # # ]: 0 : delete pTxtPos, pTxtPos = 0;
1797 : :
1798 : 9 : return rWrt.pFib->ccpHdr != 0;
1799 : : }
1800 : :
1801 : 9 : void WW8_WrPlcSepx::WriteSepx( SvStream& rStrm ) const
1802 : : {
1803 : : sal_uInt16 i;
1804 [ + + ]: 18 : for( i = 0; i < aSects.size(); i++ )
1805 : : {
1806 : 9 : WW8_PdAttrDesc* pA = pAttrs + i;
1807 [ + - ][ + - ]: 9 : if( pA->nLen && pA->pData != NULL)
1808 : : {
1809 : : SVBT16 nL;
1810 : 9 : pA->nSepxFcPos = rStrm.Tell();
1811 : 9 : ShortToSVBT16( pA->nLen, nL );
1812 [ + - ]: 9 : rStrm.Write( nL, 2 );
1813 [ + - ]: 9 : rStrm.Write( pA->pData, pA->nLen );
1814 : : }
1815 : : }
1816 : 9 : }
1817 : :
1818 : 9 : void WW8_WrPlcSepx::WritePlcSed( WW8Export& rWrt ) const
1819 : : {
1820 : : OSL_ENSURE( aCps.size() == aSects.size() + 1, "WrPlcSepx: DeSync" );
1821 : 9 : sal_uLong nFcStart = rWrt.pTableStrm->Tell();
1822 : :
1823 : : sal_uInt16 i;
1824 [ + + ]: 27 : for( i = 0; i <= aSects.size(); i++ )
1825 : : {
1826 [ + - ]: 18 : sal_uInt32 nP = aCps[i];
1827 : : SVBT32 nPos;
1828 : 18 : UInt32ToSVBT32( nP, nPos );
1829 [ + - ]: 18 : rWrt.pTableStrm->Write( nPos, 4 );
1830 : : }
1831 : :
1832 : : static WW8_SED aSed = {{4, 0},{0, 0, 0, 0},{0, 0},{0xff, 0xff, 0xff, 0xff}};
1833 : :
1834 [ + + ]: 18 : for( i = 0; i < aSects.size(); i++ )
1835 : : {
1836 : 9 : WW8_PdAttrDesc* pA = pAttrs + i;
1837 : 9 : UInt32ToSVBT32( pA->nSepxFcPos, aSed.fcSepx ); // Sepx-Pos
1838 : 9 : rWrt.pTableStrm->Write( &aSed, sizeof( aSed ) );
1839 : : }
1840 : 9 : rWrt.pFib->fcPlcfsed = nFcStart;
1841 : 9 : rWrt.pFib->lcbPlcfsed = rWrt.pTableStrm->Tell() - nFcStart;
1842 : 9 : }
1843 : :
1844 : :
1845 : 9 : void WW8_WrPlcSepx::WritePlcHdd( WW8Export& rWrt ) const
1846 : : {
1847 : : // Don't write out the PlcfHdd if ccpHdd is 0: it's a validation failure case.
1848 [ + + ][ + - ]: 9 : if( rWrt.pFib->ccpHdr != 0 && pTxtPos && pTxtPos->Count() )
[ + - ][ + + ]
1849 : : {
1850 : 3 : rWrt.pFib->fcPlcfhdd = rWrt.pTableStrm->Tell();
1851 : 3 : pTxtPos->Write( *rWrt.pTableStrm ); // Plc0
1852 : 3 : rWrt.pFib->lcbPlcfhdd = rWrt.pTableStrm->Tell() -
1853 : 3 : rWrt.pFib->fcPlcfhdd;
1854 : : }
1855 : 9 : }
1856 : :
1857 : 6 : void MSWordExportBase::WriteHeaderFooterText( const SwFmt& rFmt, bool bHeader )
1858 : : {
1859 : : const SwFmtCntnt *pCntnt;
1860 [ + + ]: 6 : if ( bHeader )
1861 : : {
1862 : 3 : bHasHdr = true;
1863 : 3 : const SwFmtHeader& rHd = rFmt.GetHeader();
1864 : : OSL_ENSURE( rHd.GetHeaderFmt(), "Header text is not here" );
1865 : 3 : pCntnt = &rHd.GetHeaderFmt()->GetCntnt();
1866 : : }
1867 : : else
1868 : : {
1869 : 3 : bHasFtr = true;
1870 : 3 : const SwFmtFooter& rFt = rFmt.GetFooter();
1871 : : OSL_ENSURE( rFt.GetFooterFmt(), "Footer text is not here" );
1872 : 3 : pCntnt = &rFt.GetFooterFmt()->GetCntnt();
1873 : : }
1874 : :
1875 : 6 : const SwNodeIndex* pSttIdx = pCntnt->GetCntntIdx();
1876 : :
1877 [ + - ]: 6 : if ( pSttIdx )
1878 : : {
1879 [ + - ]: 6 : SwNodeIndex aIdx( *pSttIdx, 1 ),
1880 [ + - ]: 6 : aEnd( *pSttIdx->GetNode().EndOfSectionNode() );
1881 : 6 : sal_uLong nStart = aIdx.GetIndex();
1882 : 6 : sal_uLong nEnd = aEnd.GetIndex();
1883 : :
1884 : : // Bereich also gueltiger Node
1885 [ + - ]: 6 : if ( nStart < nEnd )
1886 : : {
1887 : 6 : bool bOldKF = bOutKF;
1888 : 6 : bOutKF = true;
1889 [ + - ]: 6 : WriteSpecialText( nStart, nEnd, TXT_HDFT );
1890 : 6 : bOutKF = bOldKF;
1891 : : }
1892 : : else
1893 [ + - ][ + - ]: 6 : pSttIdx = 0;
1894 : : }
1895 : :
1896 [ - + ]: 6 : if ( !pSttIdx )
1897 : : {
1898 : : // es gibt keine Kopf-/Fusszeile, aber ein CR ist immer noch noetig
1899 : : OSL_ENSURE( pSttIdx, "K/F-Text nicht richtig da" );
1900 : 0 : AttrOutput().EmptyParagraph(); // CR ans Ende ( sonst mault WW )
1901 : : }
1902 : 6 : }
1903 : :
1904 : : //------------------------------------------------------------------------------
1905 : : // class WW8_WrPlcFtnEdn : Sammeln der Fuss/Endnoten und Ausgeben der Texte
1906 : : // und Plcs am Ende des Docs.
1907 : : // WW8_WrPlcFtnEdn ist die Klasse fuer Fuss- und Endnoten
1908 : : //------------------------------------------------------------------------------
1909 : 45 : WW8_WrPlcSubDoc::WW8_WrPlcSubDoc()
1910 [ + - ]: 45 : : pTxtPos( 0 )
1911 : : {
1912 : 45 : }
1913 : :
1914 : 45 : WW8_WrPlcSubDoc::~WW8_WrPlcSubDoc()
1915 : : {
1916 [ + + ]: 45 : delete pTxtPos;
1917 [ - + ]: 45 : }
1918 : :
1919 : 3 : void WW8_WrPlcFtnEdn::Append( WW8_CP nCp, const SwFmtFtn& rFtn )
1920 : : {
1921 : 3 : aCps.push_back( nCp );
1922 [ + - ]: 3 : aCntnt.push_back( &rFtn );
1923 : 3 : }
1924 : :
1925 : 0 : WW8_Annotation::WW8_Annotation(const SwPostItField* pPostIt)
1926 : : :
1927 [ # # ]: 0 : maDateTime( DateTime::EMPTY )
1928 : : {
1929 [ # # ]: 0 : mpRichText = pPostIt->GetTextObject();
1930 [ # # ]: 0 : if (!mpRichText)
1931 [ # # ]: 0 : msSimpleText = pPostIt->GetTxt();
1932 [ # # ][ # # ]: 0 : msOwner = pPostIt->GetPar1();
1933 [ # # ][ # # ]: 0 : maDateTime = DateTime(pPostIt->GetDate(), pPostIt->GetTime());
1934 : 0 : }
1935 : :
1936 : 0 : WW8_Annotation::WW8_Annotation(const SwRedlineData* pRedline)
1937 : : :
1938 : : mpRichText(0),
1939 [ # # ]: 0 : maDateTime( DateTime::EMPTY )
1940 : : {
1941 [ # # ]: 0 : msSimpleText = pRedline->GetComment();
1942 [ # # ][ # # ]: 0 : msOwner = SW_MOD()->GetRedlineAuthor(pRedline->GetAuthor());
[ # # ]
1943 [ # # ]: 0 : maDateTime = pRedline->GetTimeStamp();
1944 : 0 : }
1945 : :
1946 : 0 : void WW8_WrPlcAnnotations::Append( WW8_CP nCp, const SwPostItField *pPostIt )
1947 : : {
1948 : 0 : aCps.push_back( nCp );
1949 [ # # ]: 0 : WW8_Annotation* p = new WW8_Annotation(pPostIt);
1950 [ # # ]: 0 : aCntnt.push_back( p );
1951 : 0 : }
1952 : :
1953 : 0 : void WW8_WrPlcAnnotations::Append( WW8_CP nCp, const SwRedlineData *pRedline )
1954 : : {
1955 : 0 : maProcessedRedlines.insert(pRedline);
1956 : 0 : aCps.push_back( nCp );
1957 [ # # ]: 0 : WW8_Annotation* p = new WW8_Annotation(pRedline);
1958 [ # # ]: 0 : aCntnt.push_back( p );
1959 : 0 : }
1960 : :
1961 : 0 : bool WW8_WrPlcAnnotations::IsNewRedlineComment( const SwRedlineData *pRedline )
1962 : : {
1963 [ # # ][ # # ]: 0 : return maProcessedRedlines.find(pRedline) == maProcessedRedlines.end();
1964 : : }
1965 : :
1966 : 9 : WW8_WrPlcAnnotations::~WW8_WrPlcAnnotations()
1967 : : {
1968 [ - + ]: 9 : for( sal_uInt16 n=0; n < aCntnt.size(); n++ )
1969 [ # # ][ # # ]: 0 : delete (WW8_Annotation*)aCntnt[n];
[ # # ]
1970 [ - + ]: 18 : }
1971 : :
1972 : 45 : bool WW8_WrPlcSubDoc::WriteGenericTxt( WW8Export& rWrt, sal_uInt8 nTTyp,
1973 : : WW8_CP& rCount )
1974 : : {
1975 : 45 : sal_uInt16 nLen = aCntnt.size();
1976 [ + + ]: 45 : if ( !nLen )
1977 : 39 : return false;
1978 : :
1979 : 6 : sal_uLong nCpStart = rWrt.Fc2Cp( rWrt.Strm().Tell() );
1980 [ + - ]: 6 : pTxtPos = new WW8_WrPlc0( nCpStart );
1981 : : sal_uInt16 i;
1982 : :
1983 [ - + + - ]: 6 : switch ( nTTyp )
1984 : : {
1985 : : case TXT_ATN:
1986 [ # # ]: 0 : for ( i = 0; i < nLen; i++ )
1987 : : {
1988 : : // Anfaenge fuer PlcfAtnTxt
1989 : 0 : pTxtPos->Append( rWrt.Fc2Cp( rWrt.Strm().Tell() ));
1990 : :
1991 : 0 : rWrt.WritePostItBegin();
1992 : 0 : const WW8_Annotation& rAtn = *(const WW8_Annotation*)aCntnt[i];
1993 [ # # ]: 0 : if (rAtn.mpRichText)
1994 : 0 : rWrt.WriteOutliner(*rAtn.mpRichText, nTTyp);
1995 : : else
1996 : : {
1997 [ # # ]: 0 : String sTxt(rAtn.msSimpleText);
1998 [ # # ]: 0 : sTxt.SearchAndReplaceAll(0x0A, 0x0B);
1999 [ # # ][ # # ]: 0 : rWrt.WriteStringAsPara( sTxt );
2000 : : }
2001 : : }
2002 : 0 : break;
2003 : :
2004 : : case TXT_TXTBOX:
2005 : : case TXT_HFTXTBOX:
2006 [ + + ]: 6 : for ( i = 0; i < nLen; i++ )
2007 : : {
2008 : : // textbox - content
2009 [ + - ][ + - ]: 3 : WW8_CP nCP = rWrt.Fc2Cp( rWrt.Strm().Tell() );
2010 [ + - ][ + - ]: 3 : aCps.insert( aCps.begin()+i, nCP );
2011 [ + - ]: 3 : pTxtPos->Append( nCP );
2012 : :
2013 : : // is it an writer or sdr - textbox?
2014 [ + - ]: 3 : const SdrObject& rObj = *(SdrObject*)aCntnt[ i ];
2015 [ + - ][ + - ]: 3 : if (rObj.GetObjInventor() == FmFormInventor)
2016 : : {
2017 : 3 : sal_uInt8 nOldTyp = rWrt.nTxtTyp;
2018 : 3 : rWrt.nTxtTyp = nTTyp;
2019 [ + - ]: 3 : rWrt.GetOCXExp().ExportControl(rWrt,&rObj);
2020 : 3 : rWrt.nTxtTyp = nOldTyp;
2021 : : }
2022 [ # # ][ # # ]: 0 : else if( rObj.ISA( SdrTextObj ) )
[ # # ]
2023 [ # # ]: 0 : rWrt.WriteSdrTextObj(rObj, nTTyp);
2024 : : else
2025 : : {
2026 [ # # ]: 0 : const SwFrmFmt* pFmt = ::FindFrmFmt( &rObj );
2027 : : OSL_ENSURE( pFmt, "wo ist das Format geblieben?" );
2028 : :
2029 [ # # ]: 0 : const SwNodeIndex* pNdIdx = pFmt->GetCntnt().GetCntntIdx();
2030 : : OSL_ENSURE( pNdIdx, "wo ist der StartNode der Textbox?" );
2031 : 0 : rWrt.WriteSpecialText( pNdIdx->GetIndex() + 1,
2032 : 0 : pNdIdx->GetNode().EndOfSectionIndex(),
2033 [ # # ]: 0 : nTTyp );
2034 : : {
2035 [ # # ]: 0 : SwNodeIndex aContentIdx = *pNdIdx;
2036 [ # # ]: 0 : aContentIdx++;
2037 [ # # ]: 0 : if ( aContentIdx.GetNode().IsTableNode() )
2038 : : {
2039 : 0 : bool bContainsOnlyTables = true;
2040 [ # # ]: 0 : do {
2041 [ # # ]: 0 : aContentIdx = *(aContentIdx.GetNode().EndOfSectionNode());
2042 [ # # ]: 0 : aContentIdx++;
2043 [ # # # # ]: 0 : if ( !aContentIdx.GetNode().IsTableNode() &&
[ # # ]
2044 : 0 : aContentIdx.GetIndex() != pNdIdx->GetNode().EndOfSectionIndex() )
2045 : : {
2046 : 0 : bContainsOnlyTables = false;
2047 : : }
2048 : 0 : } while ( aContentIdx.GetNode().IsTableNode() );
2049 [ # # ]: 0 : if ( bContainsOnlyTables )
2050 : : {
2051 : : // Additional paragraph containing a space to
2052 : : // assure that by WW created RTF from written WW8
2053 : : // does not crash WW.
2054 [ # # ][ # # ]: 0 : rWrt.WriteStringAsPara( rtl::OUString(" ") );
[ # # ]
2055 : : }
2056 [ # # ]: 0 : }
2057 : : }
2058 : : }
2059 : :
2060 : : // CR at end of one textbox text ( otherwise WW gpft :-( )
2061 [ + - ]: 3 : rWrt.WriteStringAsPara( aEmptyStr );
2062 : : }
2063 : 3 : break;
2064 : :
2065 : : case TXT_EDN:
2066 : : case TXT_FTN:
2067 [ + + ]: 6 : for ( i = 0; i < nLen; i++ )
2068 : : {
2069 : : // Anfaenge fuer PlcfFtnTxt/PlcfEdnTxt
2070 : 3 : pTxtPos->Append( rWrt.Fc2Cp( rWrt.Strm().Tell() ));
2071 : :
2072 : : // Noten-Inhalt
2073 : 3 : const SwFmtFtn* pFtn = (SwFmtFtn*)aCntnt[ i ];
2074 : 3 : rWrt.WriteFtnBegin( *pFtn );
2075 : 3 : const SwNodeIndex* pIdx = pFtn->GetTxtFtn()->GetStartNode();
2076 : : OSL_ENSURE( pIdx, "wo ist der StartNode der Fuss-/EndNote?" );
2077 : 3 : rWrt.WriteSpecialText( pIdx->GetIndex() + 1,
2078 : 3 : pIdx->GetNode().EndOfSectionIndex(),
2079 : 6 : nTTyp );
2080 : : }
2081 : 3 : break;
2082 : :
2083 : : default:
2084 : : OSL_ENSURE( !this, "was ist das fuer ein SubDocType?" );
2085 : : }
2086 : :
2087 : 6 : pTxtPos->Append( rWrt.Fc2Cp( rWrt.Strm().Tell() ));
2088 : : // CR ans Ende ( sonst mault WW )
2089 : 6 : rWrt.WriteStringAsPara( aEmptyStr );
2090 : :
2091 : 6 : WW8_CP nCpEnd = rWrt.Fc2Cp( rWrt.Strm().Tell() );
2092 : 6 : pTxtPos->Append( nCpEnd );
2093 : 6 : rCount = nCpEnd - nCpStart;
2094 : :
2095 : 45 : return ( rCount != 0 );
2096 : : }
2097 : :
2098 : 45 : void WW8_WrPlcSubDoc::WriteGenericPlc( WW8Export& rWrt, sal_uInt8 nTTyp,
2099 : : WW8_FC& rTxtStart, sal_Int32& rTxtCount, WW8_FC& rRefStart, sal_Int32& rRefCount ) const
2100 : : {
2101 : : typedef ::std::vector<String>::iterator myiter;
2102 : :
2103 : 45 : sal_uLong nFcStart = rWrt.pTableStrm->Tell();
2104 : 45 : sal_uInt16 nLen = aCps.size();
2105 [ + + ]: 45 : if ( !nLen )
2106 : 45 : return;
2107 : :
2108 : : OSL_ENSURE( aCps.size() + 2 == pTxtPos->Count(), "WritePlc: DeSync" );
2109 : :
2110 [ + - ]: 6 : ::std::vector<String> aStrArr;
2111 : 6 : WW8Fib& rFib = *rWrt.pFib; // n+1-te CP-Pos nach Handbuch
2112 : : sal_uInt16 i;
2113 : 6 : bool bWriteCP = true;
2114 : :
2115 [ - + + ]: 6 : switch ( nTTyp )
2116 : : {
2117 : : case TXT_ATN:
2118 : : {
2119 : : // then write first the GrpXstAtnOwners
2120 [ # # ]: 0 : for ( i = 0; i < nLen; ++i )
2121 : : {
2122 [ # # ]: 0 : const WW8_Annotation& rAtn = *(const WW8_Annotation*)aCntnt[i];
2123 [ # # ]: 0 : aStrArr.push_back(rAtn.msOwner);
2124 : : }
2125 : :
2126 : : //sort and remove duplicates
2127 [ # # ]: 0 : ::std::sort(aStrArr.begin(), aStrArr.end());
2128 [ # # ]: 0 : myiter aIter = ::std::unique(aStrArr.begin(), aStrArr.end());
2129 [ # # ]: 0 : aStrArr.erase(aIter, aStrArr.end());
2130 : :
2131 [ # # ]: 0 : if ( rWrt.bWrtWW8 )
2132 : : {
2133 [ # # ]: 0 : for ( i = 0; i < aStrArr.size(); ++i )
2134 : : {
2135 [ # # ]: 0 : const String& rStr = aStrArr[i];
2136 [ # # ]: 0 : SwWW8Writer::WriteShort(*rWrt.pTableStrm, rStr.Len());
2137 : : SwWW8Writer::WriteString16(*rWrt.pTableStrm, rStr,
2138 [ # # ]: 0 : false);
2139 : : }
2140 : : }
2141 : : else
2142 : : {
2143 [ # # ]: 0 : for ( i = 0; i < aStrArr.size(); ++i )
2144 : : {
2145 [ # # ]: 0 : const String& rStr = aStrArr[i];
2146 [ # # ]: 0 : *rWrt.pTableStrm << (sal_uInt8)rStr.Len();
2147 : : SwWW8Writer::WriteString8(*rWrt.pTableStrm, rStr, false,
2148 [ # # ]: 0 : RTL_TEXTENCODING_MS_1252);
2149 : : }
2150 : : }
2151 : :
2152 : 0 : rFib.fcGrpStAtnOwners = nFcStart;
2153 : 0 : nFcStart = rWrt.pTableStrm->Tell();
2154 : 0 : rFib.lcbGrpStAtnOwners = nFcStart - rFib.fcGrpStAtnOwners;
2155 : :
2156 : : // Write the extended >= Word XP ATLD records
2157 [ # # ]: 0 : if( rWrt.bWrtWW8 )
2158 : : {
2159 [ # # ]: 0 : for( i = 0; i < nLen; ++i )
2160 : : {
2161 [ # # ]: 0 : const WW8_Annotation& rAtn = *(const WW8_Annotation*)aCntnt[i];
2162 : :
2163 [ # # ]: 0 : sal_uInt32 nDTTM = sw::ms::DateTime2DTTM(rAtn.maDateTime);
2164 : :
2165 [ # # ]: 0 : SwWW8Writer::WriteLong( *rWrt.pTableStrm, nDTTM );
2166 [ # # ]: 0 : SwWW8Writer::WriteShort( *rWrt.pTableStrm, 0 );
2167 [ # # ]: 0 : SwWW8Writer::WriteLong( *rWrt.pTableStrm, 0 );
2168 [ # # ]: 0 : SwWW8Writer::WriteLong( *rWrt.pTableStrm, 0 );
2169 [ # # ]: 0 : SwWW8Writer::WriteLong( *rWrt.pTableStrm, 0 );
2170 : : }
2171 : :
2172 : 0 : rFib.fcAtrdExtra = nFcStart;
2173 : 0 : nFcStart = rWrt.pTableStrm->Tell();
2174 : 0 : rFib.lcbAtrdExtra = nFcStart - rFib.fcAtrdExtra;
2175 : 0 : rFib.fcHplxsdr = 0x01010002; //WTF, but apparently necessary
2176 : 0 : rFib.lcbHplxsdr = 0;
2177 : : }
2178 : : }
2179 : 0 : break;
2180 : : case TXT_TXTBOX:
2181 : : case TXT_HFTXTBOX:
2182 : : {
2183 [ + - ]: 3 : pTxtPos->Write( *rWrt.pTableStrm );
2184 [ + - ]: 3 : const std::vector<sal_uInt32>* pShapeIds = GetShapeIdArr();
2185 : : OSL_ENSURE( pShapeIds, "wo sind die ShapeIds?" );
2186 : :
2187 [ + + ]: 6 : for ( i = 0; i < nLen; ++i )
2188 : : {
2189 : : // write textbox story - FTXBXS
2190 : : // is it an writer or sdr - textbox?
2191 [ + - ]: 3 : const SdrObject* pObj = (SdrObject*)aCntnt[ i ];
2192 : 3 : sal_Int32 nCnt = 1;
2193 [ + - ][ + - ]: 3 : if ( !pObj->ISA( SdrTextObj ) )
[ - + ]
2194 : : {
2195 : : // find the "highest" SdrObject of this
2196 [ # # ]: 0 : const SwFrmFmt& rFmt = *::FindFrmFmt( pObj );
2197 : :
2198 [ # # ]: 0 : const SwFmtChain* pChn = &rFmt.GetChain();
2199 [ # # ]: 0 : while ( pChn->GetNext() )
2200 : : {
2201 : : // has a chain?
2202 : : // then calc the cur pos in the chain
2203 : 0 : ++nCnt;
2204 [ # # ]: 0 : pChn = &pChn->GetNext()->GetChain();
2205 : : }
2206 : : }
2207 : : // long cTxbx / iNextReuse
2208 [ + - ]: 3 : SwWW8Writer::WriteLong( *rWrt.pTableStrm, nCnt );
2209 : : // long cReusable
2210 [ + - ]: 3 : SwWW8Writer::WriteLong( *rWrt.pTableStrm, 0 );
2211 : : // short fReusable
2212 [ + - ]: 3 : SwWW8Writer::WriteShort( *rWrt.pTableStrm, 0 );
2213 : : // long reserved
2214 [ + - ]: 3 : SwWW8Writer::WriteLong( *rWrt.pTableStrm, -1 );
2215 : : // long lid
2216 : : SwWW8Writer::WriteLong( *rWrt.pTableStrm,
2217 [ + - ][ + - ]: 3 : (*pShapeIds)[i]);
2218 : : // long txidUndo
2219 [ + - ]: 3 : SwWW8Writer::WriteLong( *rWrt.pTableStrm, 0 );
2220 : : }
2221 [ + - ]: 3 : SwWW8Writer::FillCount( *rWrt.pTableStrm, 22 );
2222 : 3 : bWriteCP = false;
2223 : : }
2224 : 3 : break;
2225 : : }
2226 : :
2227 [ + + ]: 6 : if ( bWriteCP )
2228 : : {
2229 : : // Schreibe CP-Positionen
2230 [ + + ]: 6 : for ( i = 0; i < nLen; i++ )
2231 [ + - ][ + - ]: 3 : SwWW8Writer::WriteLong( *rWrt.pTableStrm, aCps[ i ] );
2232 : :
2233 : : // n+1-te CP-Pos nach Handbuch
2234 : : SwWW8Writer::WriteLong( *rWrt.pTableStrm,
2235 : : rFib.ccpText + rFib.ccpFtn + rFib.ccpHdr + rFib.ccpEdn +
2236 [ + - ]: 3 : rFib.ccpTxbx + rFib.ccpHdrTxbx + 1 );
2237 : :
2238 [ - + ]: 3 : if ( TXT_ATN == nTTyp )
2239 : : {
2240 [ # # ]: 0 : for ( i = 0; i < nLen; ++i )
2241 : : {
2242 [ # # ]: 0 : const WW8_Annotation& rAtn = *(const WW8_Annotation*)aCntnt[i];
2243 : :
2244 : : //aStrArr is sorted
2245 : : myiter aIter = ::std::lower_bound(aStrArr.begin(),
2246 [ # # ]: 0 : aStrArr.end(), rAtn.msOwner);
2247 : : OSL_ENSURE(aIter != aStrArr.end() && *aIter == rAtn.msOwner,
2248 : : "Impossible");
2249 [ # # ]: 0 : sal_uInt16 nFndPos = static_cast< sal_uInt16 >(aIter - aStrArr.begin());
2250 [ # # ][ # # ]: 0 : String sAuthor(*aIter);
2251 : 0 : sal_uInt8 nNameLen = (sal_uInt8)sAuthor.Len();
2252 [ # # ]: 0 : if ( nNameLen > 9 )
2253 : : {
2254 [ # # ]: 0 : sAuthor.Erase( 9 );
2255 : 0 : nNameLen = 9;
2256 : : }
2257 : :
2258 : : // xstUsrInitl[ 10 ] pascal-style String holding initials
2259 : : // of annotation author
2260 [ # # ]: 0 : if ( rWrt.bWrtWW8 )
2261 : : {
2262 [ # # ]: 0 : SwWW8Writer::WriteShort(*rWrt.pTableStrm, nNameLen);
2263 : : SwWW8Writer::WriteString16(*rWrt.pTableStrm, sAuthor,
2264 [ # # ]: 0 : false);
2265 : : SwWW8Writer::FillCount( *rWrt.pTableStrm,
2266 [ # # ]: 0 : (9 - nNameLen) * 2 );
2267 : :
2268 : : }
2269 : : else
2270 : : {
2271 [ # # ]: 0 : *rWrt.pTableStrm << nNameLen;
2272 : : SwWW8Writer::WriteString8(*rWrt.pTableStrm, sAuthor,
2273 [ # # ]: 0 : false, RTL_TEXTENCODING_MS_1252);
2274 [ # # ]: 0 : SwWW8Writer::FillCount(*rWrt.pTableStrm, 9 - nNameLen);
2275 : : }
2276 : :
2277 [ # # ]: 0 : SwWW8Writer::WriteShort( *rWrt.pTableStrm, nFndPos );
2278 [ # # ]: 0 : SwWW8Writer::WriteShort( *rWrt.pTableStrm, 0 );
2279 [ # # ]: 0 : SwWW8Writer::WriteShort( *rWrt.pTableStrm, 0 );
2280 [ # # ]: 0 : SwWW8Writer::WriteLong( *rWrt.pTableStrm, -1 );
2281 [ # # ]: 0 : }
2282 : : }
2283 : : else
2284 : : {
2285 : 3 : sal_uInt16 nNo = 0;
2286 [ + + ]: 6 : for ( i = 0; i < nLen; ++i ) // Schreibe Flags
2287 : : {
2288 [ + - ]: 3 : const SwFmtFtn* pFtn = (SwFmtFtn*)aCntnt[ i ];
2289 : : SwWW8Writer::WriteShort( *rWrt.pTableStrm,
2290 [ + - ][ + - ]: 3 : pFtn->GetNumStr().Len() ? 0 : ++nNo );
2291 : : }
2292 : : }
2293 : : }
2294 : 6 : rRefStart = nFcStart;
2295 : 6 : nFcStart = rWrt.pTableStrm->Tell();
2296 : 6 : rRefCount = nFcStart - rRefStart;
2297 : :
2298 [ + - ]: 6 : pTxtPos->Write( *rWrt.pTableStrm );
2299 : :
2300 [ + + ]: 6 : switch ( nTTyp )
2301 : : {
2302 : : case TXT_TXTBOX:
2303 : : case TXT_HFTXTBOX:
2304 [ + + ]: 6 : for ( i = 0; i < nLen; ++i )
2305 : : {
2306 : : // write break descriptor (BKD)
2307 : : // short itxbxs
2308 [ + - ]: 3 : SwWW8Writer::WriteShort( *rWrt.pTableStrm, i );
2309 : : // short dcpDepend
2310 [ + - ]: 3 : SwWW8Writer::WriteShort( *rWrt.pTableStrm, 0 );
2311 : : // short flags : icol/fTableBreak/fColumnBreak/fMarked/
2312 : : // fUnk/fTextOverflow
2313 [ + - ]: 3 : SwWW8Writer::WriteShort( *rWrt.pTableStrm, 0x800 );
2314 : : }
2315 [ + - ]: 3 : SwWW8Writer::FillCount( *rWrt.pTableStrm, 6 );
2316 : 3 : break;
2317 : : }
2318 : :
2319 : 6 : rTxtStart = nFcStart;
2320 : 45 : rTxtCount = rWrt.pTableStrm->Tell() - nFcStart;
2321 : : }
2322 : :
2323 : 0 : const std::vector<sal_uInt32>* WW8_WrPlcSubDoc::GetShapeIdArr() const
2324 : : {
2325 : 0 : return 0;
2326 [ + - ][ + - ]: 54 : }
2327 : :
2328 : : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
